diff --git a/.github/workflows/ci_pipeline.yml b/.github/workflows/ci_pipeline.yml
new file mode 100644
index 0000000..4152b8e
--- /dev/null
+++ b/.github/workflows/ci_pipeline.yml
@@ -0,0 +1,26 @@
+name: Run Pytest
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: 📥 Checkout code
+      uses: actions/checkout@v3
+
+    - name: 🐍 Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'  # or whatever version you need
+
+    - name: 📦 Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        pip install pytest
+
+    - name: 🧪 Run Pytest
+      run: |
+        pytest
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 0a19790..24aacf6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@ __pycache__/
 # C extensions
 *.so
 
+.DS_Store
 # Distribution / packaging
 .Python
 build/
diff --git a/README.md b/README.md
index 84a7f1e..266eb42 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,41 @@
-# qec-surface-code
-Quantum Error Correction: Surface Code in Q#
+# Quantum Error Correction: Surface Code
+
+The repository implements rotated surface code with MWPM algorithm for decoder.
+We build a logical qubit, identify errors using error syndromes at each timestep and finally apply error correction on the data qubits. The logical qubit is measured to finally to know if error correction was successful.
+
+## Objective
+- Implement a d=3 surface code in Q# with separate layouts for data and ancilla qubits.
+- Simulate Pauli noise (bit-flip, phase-flip) across multiple rounds of stabilizer cycles.
+- Extract syndrome measurements and apply MWPM using a classical decoder.
+- Visualize syndrome defects and correction paths for debugging and intuition.
+- Assess logical qubit fidelity post-correction by varying physical error rates
+
+## Workflow
+![Workflow](/qec-highlevel.png)
+
+## Components
+- Surface Code Architecture in Q#
+- Pauli Tracking Layer for syndrome measurements history
+- Error detection at each timestep using Minimum-weight perfect matching decoder with error graphs
+- Error correction on logical qubits
+
+
+## Setup
+- Clone repository
+- Setup virtual environment in python
+```bash
+python3 -m virtualenv venv
+```
+- Activate venv
+```bash
+source venv/bin/activate
+```
+- Install Requirements
+```bash
+python3 -m pip install -r requirements.txt
+```
+- Run Notebook and choose *venv*
+
+
+
+
diff --git a/decoder.py b/decoder.py
new file mode 100644
index 0000000..208c82c
--- /dev/null
+++ b/decoder.py
@@ -0,0 +1,502 @@
+import math
+from itertools import combinations
+from collections import defaultdict
+
+import networkx as nx
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+from qiskit.synthesis import OneQubitEulerDecomposer
+
+
+
+
+class GraphDecoder:
+    """
+    Class to construct the graph corresponding to the possible syndromes
+    of a quantum error correction code, and then run suitable decoders.
+    """
+
+    def __init__(self, d, T):
+        
+        self.d = d
+        self.T = T
+        self.virtual = self._specify_virtual()
+        self.S = {"X": nx.Graph(), "Z": nx.Graph()}
+        self._make_syndrome_graph()
+
+    def _specify_virtual(self):
+        """Define coordinates of Z and X virtual nodes. Our convention is that Z
+        virtual nodes are top/bottom and X virtual nodes are left/right.
+        """
+        virtual = {}
+        virtual["X"] = []
+        virtual["Z"] = []
+        for j in range(0, self.d, 2):
+            # Z virtual nodes
+            virtual["Z"].append((-1, -0.5, j - 0.5))  # top
+            virtual["Z"].append((-1, self.d - 0.5, j + 0.5))  # bottom
+
+            # X virtual nodes
+            virtual["X"].append((-1, j + 0.5, -0.5))  # left
+            virtual["X"].append((-1, j - 0.5, self.d - 0.5))  # right
+        return virtual
+
+    def _make_syndrome_graph(self):
+        start_nodes = {"Z": (0.5, 0.5), "X": (0.5, 1.5)}
+        for error_key in ["X", "Z"]:
+            # subgraphs for each time step
+            for t in range(0, self.T):
+                start_node = start_nodes[error_key]
+                self.S[error_key].add_node(
+                    (t,) + start_node,
+                    virtual=0,
+                    pos=(start_node[1], -start_node[0]),
+                    time=t,
+                    pos_3D=(
+                        start_node[1],
+                        -start_node[0],
+                        t,
+                    ),  # y-coord is flipped for plot purposes
+                )
+                self.populate_syndrome_graph(
+                    (t,) + start_node, t, [], error_key, edge_weight=1
+                )
+
+            # connect physical qubits in same location across subgraphs of adjacent times
+            syndrome_nodes_t0 = [
+                x for x, y in self.S[error_key].nodes(data=True) if y["time"] == 0
+            ]
+            for node in syndrome_nodes_t0:
+                space_label = (node[1], node[2])
+                for t in range(0, self.T - 1):
+                    self.S[error_key].add_edge(
+                        (t,) + space_label, (t + 1,) + space_label, distance=1
+                    )
+
+
+    def populate_syndrome_graph(
+        self, current_node, t, visited_nodes, error_key, edge_weight=1
+    ):
+        """Recursive function to populate syndrome subgraph at time t with error_key X/Z. The current_node
+        is connected to neighboring nodes without revisiting a node.
+        """
+        visited_nodes.append(current_node)
+        neighbors = []
+        i = current_node[1]  # syndrome node x coordinate
+        j = current_node[2]  # syndrome node y coordinate
+        neighbors.append((i - 1, j - 1))  # up left
+        neighbors.append((i + 1, j - 1))  # down left
+        neighbors.append((i - 1, j + 1))  # up right
+        neighbors.append((i + 1, j + 1))  # down right
+
+        normal_neighbors = [
+            n
+            for n in neighbors
+            if self.valid_syndrome(n, error_key)
+            and (t, n[0], n[1]) not in visited_nodes
+        ]  # syndrome node neighbors of current_node not already visited
+        virtual_neighbors = [
+            n
+            for n in neighbors
+            if (-1, n[0], n[1]) in self.virtual[error_key]
+            and (-1, n[0], n[1]) not in visited_nodes
+        ]  # virtual node neighbors of current_node not already visited
+
+        # no neighbors to add edges
+        if not normal_neighbors and not virtual_neighbors:
+            return
+
+        # add normal/non-virtual neighbors
+        for target in normal_neighbors:
+            target_node = (
+                t,
+            ) + target  # target_node has time t with x and y coordinates from target
+            if not self.S[error_key].has_node(target_node):
+                self.S[error_key].add_node(
+                    target_node,
+                    virtual=0,
+                    pos=(target[1], -target[0]),
+                    time=t,
+                    pos_3D=(target[1], -target[0], t),
+                )  # add target_node to syndrome subgraph if it doesn't already exist
+            self.S[error_key].add_edge(
+                current_node, target_node, distance=edge_weight
+            )  # add edge between current_node and target_node
+
+        # add virtual neighbors
+        for target in virtual_neighbors:
+            target_node = (
+                -1,
+            ) + target  # virtual target_node has time -1 with x and y coordinates from target
+            if not self.S[error_key].has_node(target_node):
+                self.S[error_key].add_node(
+                    target_node,
+                    virtual=1,
+                    pos=(target[1], -target[0]),
+                    time=-1,
+                    pos_3D=(target[1], -target[0], (self.T - 1) / 2),
+                )  # add virtual target_node to syndrome subgraph with z coordinate (T-1)/2 for nice plotting, if it doesn't already exist
+            self.S[error_key].add_edge(
+                current_node, target_node, distance=edge_weight
+            )  # add edge between current_node and virtual target_node
+
+        # recursively traverse normal neighbors
+        for target in normal_neighbors:
+            self.populate_syndrome_graph(
+                (t,) + target, t, visited_nodes, error_key, edge_weight=1
+            )
+
+        # recursively traverse virtual neighbors
+        for target in virtual_neighbors:
+            self.populate_syndrome_graph(
+                (-1,) + target, t, visited_nodes, error_key, edge_weight=1
+            )
+
+    def valid_syndrome(self, node, error_key):
+        """Checks whether a node is a syndrome node under our error_key, which is either X or Z.
+        """
+        i = node[0]
+        j = node[1]
+        if error_key == "Z":
+            if i > 0 and i < self.d - 1 and j < self.d and j > -1:
+                return True
+            else:
+                return False
+        elif error_key == "X":
+            if j > 0 and j < self.d - 1 and i < self.d and i > -1:
+                return True
+            else:
+                return False
+
+    def make_error_graph(self, nodes, error_key, err_prob=None):
+        """Creates error syndrome subgraph from list of syndrome nodes. The output of
+        this function is a graph that's ready for minimum weight perfect matching (MWPM).
+
+        If err_prob is specified, we adjust the shortest distance between syndrome
+        nodes by the degeneracy of the error path.
+        """
+        paths = {}
+        virtual_dict = nx.get_node_attributes(self.S[error_key], "virtual")
+        time_dict = nx.get_node_attributes(self.S[error_key], "time")
+        error_graph = nx.Graph()
+        nodes += self.virtual[error_key]
+
+        for node in nodes:
+            if not error_graph.has_node(node):
+                error_graph.add_node(
+                    node,
+                    virtual=virtual_dict[node],
+                    pos=(node[2], -node[1]),
+                    time=time_dict[node],
+                    pos_3D=(node[2], -node[1], time_dict[node]),
+                )
+
+        for source, target in combinations(nodes, 2):
+            # Distance is proportional to the probability of this error chain, so
+            # finding the maximum-weight perfect matching of the whole graph gives
+            # the most likely sequence of errors that led to these syndromes.
+            distance = int(
+                nx.shortest_path_length(
+                    self.S[error_key], source, target, weight="distance"
+                )
+            )
+
+            # If err_prob is specified, we also account for path degeneracies
+            deg, path = self._path_degeneracy(source, target, error_key)
+            paths[(source, target)] = path
+            if err_prob:
+                distance = distance - math.log(deg)/(math.log1p(-err_prob) - math.log(err_prob))
+            distance = -distance    
+            error_graph.add_edge(source, target, weight=distance)
+
+
+
+        return error_graph, paths
+
+    def analytic_paths(self, matches, error_key):
+        analytic_decoder = GraphDecoder(self.d,self.T)
+        paths = {}
+        for (source,target) in matches:
+            _, path = analytic_decoder._path_degeneracy(source[:3],target[:3], error_key)
+            paths[(source[:3], target[:3])] = path
+        return paths
+
+    def _path_degeneracy(self, a, b, error_key):
+        """Calculate the number of shortest error paths that link two syndrome nodes
+        through both space and time.
+        """
+        # Check which subgraph node is on. If x + y is even => X, else Z.
+        # a_sum, b_sum = a[1] + a[2], b[1] + b[2]
+        if error_key == "X":
+            subgraph = self.S["X"]
+        elif error_key == "Z":
+            subgraph = self.S["Z"]
+        else:
+            raise nx.exception.NodeNotFound("error_key must be X or Z")
+
+        shortest_paths = list(nx.all_shortest_paths(subgraph, a, b, weight="distance"))
+        one_path = shortest_paths[
+            0
+        ]  # We can pick any path to return as the error chain
+        degeneracy = len(shortest_paths)
+
+        # If either node is a virtual node, we also find degeneracies from the other
+        # node to *any* nearest virtual node
+        source = None
+        if a[0] == -1:
+            target = a
+            source = b
+        elif b[0] == -1:
+            target = b
+            source = a
+
+        # Compute additional degeneracies to edge boundaries
+        if source:
+            virtual_nodes = self.virtual[error_key]
+            shortest_distance = nx.shortest_path_length(
+                subgraph, a, b, weight="distance"
+            )
+            for node in virtual_nodes:
+                distance = nx.shortest_path_length(
+                    subgraph, source, node, weight="distance"
+                )
+                if distance == shortest_distance and node != target:
+                    degeneracy += len(
+                        list(
+                            nx.all_shortest_paths(
+                                subgraph, source, node, weight="distance"
+                            )
+                        )
+                    )
+        return degeneracy, one_path
+
+    def matching_graph(self, error_graph, error_key):
+        """Return subgraph of error graph to be matched.
+        """
+        time_dict = nx.get_node_attributes(self.S[error_key], "time")
+        subgraph = nx.Graph()
+        syndrome_nodes = [
+            x for x, y in error_graph.nodes(data=True) if y["virtual"] == 0
+        ]
+        virtual_nodes = [
+            x for x, y in error_graph.nodes(data=True) if y["virtual"] == 1
+        ]
+
+        # add and connect each syndrome node to subgraph
+        for node in syndrome_nodes:
+            if not subgraph.has_node(node):
+                subgraph.add_node(
+                    node,
+                    virtual=0,
+                    pos=(node[2], -node[1]),
+                    time=time_dict[node],
+                    pos_3D=(node[2], -node[1], time_dict[node]),
+                )
+        for source, target in combinations(syndrome_nodes, 2):
+            subgraph.add_edge(
+                source, target, weight=error_graph[source][target]["weight"]
+            )
+
+        # connect each syndrome node to its closest virtual node in subgraph
+        for source in syndrome_nodes:
+            potential_virtual = {}
+            for target in virtual_nodes:
+                potential_virtual[target] = error_graph[source][target]["weight"]
+            nearest_virtual = max(potential_virtual, key=potential_virtual.get)
+            paired_virtual = (
+                nearest_virtual + source
+            )  # paired_virtual (virtual, syndrome) allows for the virtual node to be matched more than once
+            subgraph.add_node(
+                paired_virtual,
+                virtual=1,
+                pos=(nearest_virtual[2], -nearest_virtual[1]),
+                time=-1,
+                pos_3D=(nearest_virtual[2], -nearest_virtual[1], -1),
+            )  # add paired_virtual to subgraph
+            subgraph.add_edge(
+                source, paired_virtual, weight=potential_virtual[nearest_virtual]
+            )  # add (syndrome, paired_virtual) edge to subgraph
+
+        paired_virtual_nodes = [
+            x for x, y in subgraph.nodes(data=True) if y["virtual"] == 1
+        ]
+
+        # add 0 weight between paired virtual nodes
+        for source, target in combinations(paired_virtual_nodes, 2):
+            subgraph.add_edge(source, target, weight=0)
+
+        return subgraph
+
+    def matching(self, matching_graph, error_key):
+        """Return matches of minimum weight perfect matching (MWPM) on matching_graph.
+        """
+        matches = nx.max_weight_matching(matching_graph, maxcardinality=True)
+        filtered_matches = [
+            (source, target)
+            for (source, target) in matches
+            if not (len(source) > 3 and len(target) > 3)
+        ]  # remove 0 weighted matched edges between virtual syndrome nodes
+        return filtered_matches
+
+    def calculate_qubit_flips(self, matches, paths, error_key):
+        physical_qubit_flips = {}
+        for (source, target) in matches:
+            # Trim "paired virtual" nodes to nearest virtual node
+            if len(source) > 3:
+                source = source[:3]
+            if len(target) > 3:
+                target = target[:3]
+
+            # Paths dict is encoded in one direction, check other if not found
+            if (source, target) not in paths:
+                source, target = (target, source)
+
+            path = paths[(source, target)]  # This is an arbitrary shortest error path
+            for i in range(0, len(path) - 1):
+                start = path[i]
+                end = path[i + 1]
+                # Check if syndromes are in different physical locations
+                # If they're in the same location, this is a measurement error
+                if start[1:] != end[1:]:
+                    time = start[0]
+                    if time == -1:  # Grab time from non-virtual syndrome
+                        time = end[0]
+                    physical_qubit = (
+                        time,
+                        (start[1] + end[1]) / 2,
+                        (start[2] + end[2]) / 2,
+                    )
+
+                    # Paired flips at the same time can be ignored
+                    if physical_qubit in physical_qubit_flips:
+                        physical_qubit_flips[physical_qubit] = (
+                            physical_qubit_flips[physical_qubit] + 1
+                        ) % 2
+                    else:
+                        physical_qubit_flips[physical_qubit] = 1
+
+        physical_qubit_flips = {
+            x: error_key for x, y in physical_qubit_flips.items() if y == 1
+        }
+        return physical_qubit_flips
+
+    def net_qubit_flips(self, flips_x, flips_z, decompose=False):
+        flipsx = {flip: "X" for flip, _ in flips_x.items() if flip not in flips_z}
+        flipsz = {flip: "Z" for flip, _ in flips_z.items() if flip not in flips_x}
+        flipsy = {flip: "Y" for flip, _ in flips_x.items() if flip in flips_z}
+        flips = {**flipsx, **flipsy, **flipsz}
+
+        individual_flips = defaultdict(dict)
+
+        for flip, error_key in flips.items():
+            individual_flips[flip[1:]][flip[0]] = error_key
+
+        paulis = {
+            "X": np.array([[0, 1], [1, 0]]),
+            "Y": np.array([[0, -1j], [1j, 0]]),
+            "Z": np.array([[1, 0], [0, -1]]),
+            "I": np.array([[1, 0], [0, 1]]),
+        }
+
+        physical_qubit_flips = {}
+        for qubit_loc, flip_record in individual_flips.items():
+            net_error = paulis["I"]
+            # print("Physical Qubit: " + str(qubit_loc))
+            for time, error in sorted(flip_record.items(), key=lambda item: item[0]):
+                # print("Error: " + error + " at time: " + str(time))
+                net_error = net_error.dot(paulis[error])
+            physical_qubit_flips[qubit_loc] = net_error
+            if decompose:
+                physical_qubit_flips[qubit_loc] = self.decomposeGate(net_error)
+
+        physical_qubit_flips = {x:y for x,y in physical_qubit_flips.items() if not np.array_equal(y,paulis["I"])}
+        return physical_qubit_flips, paulis
+
+
+    def graph_2D(self, G, edge_label):
+        pos = nx.get_node_attributes(G, "pos")
+        nx.draw_networkx(G, pos)
+        labels = nx.get_edge_attributes(G, edge_label)
+        labels = {x: round(y, 3) for (x, y) in labels.items()}
+        nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
+        plt.show()
+      
+    
+    def decomposeGate(self, unitary):
+        '''Get decomposed unitary angles'''
+        return OneQubitEulerDecomposer("ZYZ").angles(unitary)
+
+    def graph_3D(self, G, edge_label, angle=[-116, 22]):
+        """Plots a graph with edge labels in 3D.
+        """
+        # Get node 3D positions
+        pos_3D = nx.get_node_attributes(G, "pos_3D")
+
+        # Define color range based on time
+        colors = {
+            x: plt.cm.plasma((y["time"] + 1) / self.T) for x, y in G.nodes(data=True)
+        }
+
+        # 3D network plot
+        with plt.style.context(("ggplot")):
+
+            fig = plt.figure(figsize=(20, 14))
+            ax = Axes3D(fig)
+
+            # Loop on the nodes and look up in pos dictionary to extract the x,y,z coordinates of each node
+            for node in G.nodes():
+                xi, yi, zi = pos_3D[node]
+
+                # Scatter plot
+                ax.scatter(
+                    xi,
+                    yi,
+                    zi,
+                    color=colors[node],
+                    s=120 * (1 + G.degree(node)),
+                    edgecolors="k",
+                    alpha=0.7,
+                )
+
+                # Label node position
+                ax.text(xi, yi, zi, node, fontsize=20)
+
+            # Loop on the edges to get the x,y,z, coordinates of the connected nodes
+            # Those two points are the extrema of the line to be plotted
+            for src, tgt in G.edges():
+                x_1, y_1, z_1 = pos_3D[src]
+                x_2, y_2, z_2 = pos_3D[tgt]
+
+                x_line = np.array((x_1, x_2))
+                y_line = np.array((y_1, y_2))
+                z_line = np.array((z_1, z_2))
+
+                # Plot the connecting lines
+                ax.plot(x_line, y_line, z_line, color="black", alpha=0.5)
+
+                # Label edges at midpoints
+                x_mid = (x_1 + x_2) / 2
+                y_mid = (y_1 + y_2) / 2
+                z_mid = (z_1 + z_2) / 2
+                label = round(G[src][tgt][edge_label], 2)
+                ax.text(x_mid, y_mid, z_mid, label, fontsize=14)
+
+                # Set the initial view
+                ax.view_init(angle[1], angle[0])
+
+                # Hide the axes
+                ax.set_axis_off()
+
+                # Get rid of colored axes planes
+                # First remove fill
+                ax.xaxis.pane.fill = False
+                ax.yaxis.pane.fill = False
+                ax.zaxis.pane.fill = False
+
+                # Now set color to white (or whatever is "invisible")
+                ax.xaxis.pane.set_edgecolor("w")
+                ax.yaxis.pane.set_edgecolor("w")
+                ax.zaxis.pane.set_edgecolor("w")
+
+                plt.show()
\ No newline at end of file
diff --git a/final.ipynb b/final.ipynb
new file mode 100644
index 0000000..57eb7b5
--- /dev/null
+++ b/final.ipynb
@@ -0,0 +1,835 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "11d584e1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/javascript": "// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\n// This file provides CodeMirror syntax highlighting for Q# magic cells\n// in classic Jupyter Notebooks. It does nothing in other (Jupyter Notebook 7,\n// VS Code, Azure Notebooks, etc.) environments.\n\n// Detect the prerequisites and do nothing if they don't exist.\nif (window.require && window.CodeMirror && window.Jupyter) {\n  // The simple mode plugin for CodeMirror is not loaded by default, so require it.\n  window.require([\"codemirror/addon/mode/simple\"], function defineMode() {\n    let rules = [\n      {\n        token: \"comment\",\n        regex: /(\\/\\/).*/,\n        beginWord: false,\n      },\n      {\n        token: \"string\",\n        regex: String.raw`^\\\"(?:[^\\\"\\\\]|\\\\[\\s\\S])*(?:\\\"|$)`,\n        beginWord: false,\n      },\n      {\n        token: \"keyword\",\n        regex: String.raw`(namespace|open|as|operation|function|body|adjoint|newtype|controlled|internal)\\b`,\n        beginWord: true,\n      },\n      {\n        token: \"keyword\",\n        regex: String.raw`(if|elif|else|repeat|until|fixup|for|in|return|fail|within|apply)\\b`,\n        beginWord: true,\n      },\n      {\n        token: \"keyword\",\n        regex: String.raw`(Adjoint|Controlled|Adj|Ctl|is|self|auto|distribute|invert|intrinsic)\\b`,\n        beginWord: true,\n      },\n      {\n        token: \"keyword\",\n        regex: String.raw`(let|set|use|borrow|mutable)\\b`,\n        beginWord: true,\n      },\n      {\n        token: \"operatorKeyword\",\n        regex: String.raw`(not|and|or)\\b|(w/)`,\n        beginWord: true,\n      },\n      {\n        token: \"operatorKeyword\",\n        regex: String.raw`(=)|(!)|(<)|(>)|(\\+)|(-)|(\\*)|(/)|(\\^)|(%)|(\\|)|(&&&)|(~~~)|(\\.\\.\\.)|(\\.\\.)|(\\?)`,\n        beginWord: false,\n      },\n      {\n        token: \"meta\",\n        regex: String.raw`(Int|BigInt|Double|Bool|Qubit|Pauli|Result|Range|String|Unit)\\b`,\n        beginWord: true,\n      },\n      {\n        token: \"atom\",\n        regex: String.raw`(true|false|Pauli(I|X|Y|Z)|One|Zero)\\b`,\n        beginWord: true,\n      },\n    ];\n    let simpleRules = [];\n    for (let rule of rules) {\n      simpleRules.push({\n        token: rule.token,\n        regex: new RegExp(rule.regex, \"g\"),\n        sol: rule.beginWord,\n      });\n      if (rule.beginWord) {\n        // Need an additional rule due to the fact that CodeMirror simple mode doesn't work with ^ token\n        simpleRules.push({\n          token: rule.token,\n          regex: new RegExp(String.raw`\\W` + rule.regex, \"g\"),\n          sol: false,\n        });\n      }\n    }\n\n    // Register the mode defined above with CodeMirror\n    window.CodeMirror.defineSimpleMode(\"qsharp\", { start: simpleRules });\n    window.CodeMirror.defineMIME(\"text/x-qsharp\", \"qsharp\");\n\n    // Tell Jupyter to associate %%qsharp magic cells with the qsharp mode\n    window.Jupyter.CodeCell.options_default.highlight_modes[\"qsharp\"] = {\n      reg: [/^%%qsharp/],\n    };\n\n    // Force re-highlighting of all cells the first time this code runs\n    for (const cell of window.Jupyter.notebook.get_cells()) {\n      cell.auto_highlight();\n    }\n  });\n}\n",
+      "text/plain": []
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# \n",
+    "# Encoder implementation\n",
+    "# Decoder from library\n",
+    "# Results\n",
+    "# Formatting code\n",
+    "# Test cases\n",
+    "# Report\n",
+    "\n",
+    "import qsharp\n",
+    "from collections import deque\n",
+    "from typing import List\n",
+    "from decoder import GraphDecoder\n",
+    "import numpy as np\n",
+    "\n",
+    "# StabilizerMap: Holds the information related to the stabilizers present \n",
+    "# in the logical qubit and defines operations to maintain mapping between\n",
+    "# measure qubits, its coordinates and relation with data qubits\n",
+    "\n",
+    "class StabilizerMap:\n",
+    "    '''\n",
+    "    Position of stabilizer on the lattice matters, this map keeps \n",
+    "    mapping of local qubits to the global order on the surface\n",
+    "    '''\n",
+    "\n",
+    "    def __init__(self, d, xMaps, zMaps, order):\n",
+    "        self.d = d\n",
+    "        self.zMaps = zMaps\n",
+    "        self.xMaps = xMaps\n",
+    "        self.order = order\n",
+    "        self.orderedMappings = []\n",
+    "        self.ancillaMappings = {X: {}, Z: {}}\n",
+    "        self.__generateStabilizerMap()\n",
+    "    \n",
+    "    def getByAncillaPosition(self, type, ancillaPosition):\n",
+    "        # Position of stabilizer measured ancilla to order on surface code lattice\n",
+    "        orderedPosition = self.ancillaMappings[type][ancillaPosition]\n",
+    "        return self.orderedMappings[orderedPosition]\n",
+    "\n",
+    "    def __generateStabilizerMap(self):\n",
+    "        # Map: index is position, value is dict - {\"type\": X|Z, \"coordinates\": (x,y)}\n",
+    "        xqueue = deque(self.stabilizerCoordinates(self.xMaps))\n",
+    "        zqueue = deque(self.stabilizerCoordinates(self.zMaps))\n",
+    "        zi = 0\n",
+    "        xi = 0\n",
+    "        for position in range(len(self.order)):\n",
+    "            self.orderedMappings.append({\n",
+    "                \"type\": self.order[position],\n",
+    "                \"coordinates\": (\n",
+    "                    zqueue if self.order[position] == Z else xqueue\n",
+    "                ).popleft()\n",
+    "            })\n",
+    "            if self.order[position] == Z:\n",
+    "                self.ancillaMappings[Z][zi] = position\n",
+    "                zi += 1\n",
+    "            else:\n",
+    "                self.ancillaMappings[X][xi] = position\n",
+    "                xi += 1\n",
+    "    \n",
+    "    def _correctCoordinate(self, coordinate):\n",
+    "        # Boundary stabilizers should be corrected to space away from data qubits which lie on 0 or d axis\n",
+    "        if coordinate == 0:\n",
+    "            return coordinate-0.5\n",
+    "        if coordinate == (self.d-1):\n",
+    "            return coordinate + 0.5\n",
+    "        return coordinate\n",
+    "\n",
+    "    def stabilizerCoordinates(self, stabilizerMap):\n",
+    "        syndromeMap = []\n",
+    "        for i,neighbourQubits in enumerate(stabilizerMap):\n",
+    "            qubits = []\n",
+    "            for qubit in neighbourQubits:\n",
+    "                qubits.append((qubit//self.d, qubit%self.d))\n",
+    "            x = sum(q[0] for q in qubits)/len(qubits)\n",
+    "            y = sum(q[1] for q in qubits)/len(qubits)\n",
+    "\n",
+    "            syndromeMap.append((self._correctCoordinate(x), self._correctCoordinate(y)))\n",
+    "        return syndromeMap\n",
+    "\n",
+    "\n",
+    "X = \"X\"\n",
+    "Z = \"Z\"\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ba7561c",
+   "metadata": {},
+   "source": [
+    "\n",
+    "## Pauli Tracker\n",
+    "Tracks the list of measures and syndrome\n",
+    "in the logical qubit, effective to identify the errors to perform error correction through detection events that signal possibilities of errors\n",
+    "\n",
+    "<img src=\"timeline.png\"/>\n",
+    "<br/>\n",
+    "The below class tracks the error in timeline as shown in the above image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "462d5a71",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# PauliTracker: Tracks the list of measures and syndrome across timesteps in 3D space\n",
+    "class PauliTracker:\n",
+    "    '''Tracks the Pauli X&Z stabilizers measurements, Record \n",
+    "    the stabilizer measurement outcomes in each round without\n",
+    "    physically correcting the qubits'''\n",
+    "\n",
+    "    def __init__(self):\n",
+    "        self.tracker = {X: [], Z: []}\n",
+    "        self.order = []\n",
+    "\n",
+    "    def getChanges(self, type, currentMeasures):\n",
+    "        '''Get parity of previous stabilizer measures v/s current to detect event of error'''\n",
+    "        if not self.tracker[type]:\n",
+    "            return currentMeasures\n",
+    "        return [1 if a==b else 0 for a,b in zip(self.tracker[type][-1], currentMeasures)]\n",
+    "\n",
+    "\n",
+    "    def track(self, xMeasures, zMeasures):\n",
+    "        xMeasures = LogicalQubit.convertResultToBinaryArray(xMeasures)\n",
+    "        zMeasures = LogicalQubit.convertResultToBinaryArray(zMeasures)\n",
+    "    \n",
+    "        self.tracker[X].append(self.getChanges(X, xMeasures))\n",
+    "        self.tracker[Z].append(self.getChanges(Z, zMeasures))\n",
+    "    \n",
+    "    def getX(self):\n",
+    "        return self.tracker[X]\n",
+    "    def getZ(self):\n",
+    "        return self.tracker[Z]\n",
+    "    def setOrder(self, order):\n",
+    "        self.order = order\n",
+    "    \n",
+    "    def getTrackedErrors(self, stabilizerMap: StabilizerMap):\n",
+    "        '''Get difference in each timestep errors of X and Z stabilizers'''\n",
+    "        X_ERRORS = []\n",
+    "        Z_ERRORS = []\n",
+    "        for error in self.tracker:\n",
+    "            for timestep in range(len(self.tracker[error])):\n",
+    "                for stabilizerIndex in range(len(self.tracker[error][timestep])):\n",
+    "                    if self.tracker[error][timestep][stabilizerIndex]:\n",
+    "                        stabilizer = stabilizerMap.getByAncillaPosition(error, stabilizerIndex)\n",
+    "                        bucket = X_ERRORS if error == X else Z_ERRORS\n",
+    "                        bucket.append((timestep, stabilizer[\"coordinates\"][0], stabilizer[\"coordinates\"][1]))\n",
+    "        return X_ERRORS, Z_ERRORS\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "94e1489d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# **Logical Qubit**: Complete implementation of the logical qubit\n",
+    "# Implements rotated surface code through QSharp by first encodes the logical qubit by \n",
+    "# generating a map of lattice with stabilizers, uses the map to construct the lattice with stabilizers,\n",
+    "# then decodes the errors using syndromes tracked by PauliTracker & MWPM algorithm to correct \n",
+    "# errors on data qubits. Finally, measures data qubit to check the true logical state.\n",
+    "class LogicalQubit:\n",
+    "    def __init__(self, d, T):\n",
+    "        self.d: int = d\n",
+    "        self.timesteps: int = T\n",
+    "        self.PAULI_TRACKER = PauliTracker()\n",
+    "        self.decoder: GraphDecoder = GraphDecoder(d, T)\n",
+    "        self.stabilizerMap: StabilizerMap = None\n",
+    "        self.TOTAL_DATA_QUBITS = self.d**2\n",
+    "    \n",
+    "    @staticmethod\n",
+    "    def convertResultToBinaryArray(result: List[qsharp.Result]):\n",
+    "        return [1 if bit == qsharp.Result.One else 0 for bit in result]\n",
+    "    \n",
+    "    def getDataQubitCoordinates(self, i, j):\n",
+    "        return (i*self.d) + j\n",
+    "\n",
+    "\n",
+    "    def runRound(self):\n",
+    "        xSyndrome, zSyndrome = qsharp.eval(f\"RotatedSurfaceCode.Round(TOTAL_DATA_QUBITS, qubits, xMaps, zMaps, order);\")\n",
+    "        self.PAULI_TRACKER.track(xSyndrome, zSyndrome)\n",
+    "\n",
+    "        \n",
+    "\n",
+    "    def encode(self, xnoise: float, znoise: float):\n",
+    "        \n",
+    "        qsharp.init(project_root=\".\")\n",
+    "        qsharp.eval(f\"import Std.Diagnostics.ConfigurePauliNoise;\")\n",
+    "        qsharp.eval(f\"import Std.Arrays.ForEach;\")\n",
+    "        qsharp.eval(f\"let d = {self.d};\")\n",
+    "        qsharp.eval(f\"let TOTAL_DATA_QUBITS = {self.TOTAL_DATA_QUBITS};\")\n",
+    "        qsharp.eval(\"use qubits = Qubit[TOTAL_DATA_QUBITS];\")\n",
+    "        qsharp.eval(\"ApplyToEach(X, qubits);\")\n",
+    "        qsharp.eval(f\"ConfigurePauliNoise({xnoise}, 0.0, {znoise});\")\n",
+    "        qsharp.eval(\"ResetAll(qubits);\")\n",
+    "        \n",
+    "        xMaps, zMaps, order = qsharp.eval(f\"RotatedSurfaceCode.GetMaps(d);\")\n",
+    "        self.stabilizerMap = StabilizerMap(self.d, xMaps, zMaps, order)\n",
+    "        qsharp.eval(f\"let (xMaps, zMaps, order) = RotatedSurfaceCode.GetMaps(d);\")\n",
+    "\n",
+    "        self.runRound()\n",
+    "        for t in range(self.timesteps-1):\n",
+    "            self.runRound()\n",
+    "\n",
+    "    def __searchOperator(self, operations:dict, query):\n",
+    "        for k,v in operations.items():\n",
+    "            if np.array_equal(v, query):\n",
+    "                return k\n",
+    "\n",
+    "    def decode(self, xnoise: float, znoise: float):\n",
+    "        flips = {}\n",
+    "        X_ERRORS, Z_ERRORS = self.PAULI_TRACKER.getTrackedErrors(self.stabilizerMap)\n",
+    "\n",
+    "        for error_key,errors in dict(zip((X,Z), (X_ERRORS,Z_ERRORS))).items():\n",
+    "            if errors:\n",
+    "                error_graph, paths = self.decoder.make_error_graph(errors, error_key, xnoise+znoise)\n",
+    "                matching_graph = self.decoder.matching_graph(error_graph,error_key)\n",
+    "                matches = self.decoder.matching(matching_graph,error_key)\n",
+    "                flips[error_key] = self.decoder.calculate_qubit_flips(matches, paths,error_key)\n",
+    "            else:\n",
+    "                flips[error_key] = {}\n",
+    "        decodedResults, operatorMap = self.decoder.net_qubit_flips(flips[\"X\"], flips[\"Z\"], decompose=True)\n",
+    "\n",
+    "        for position, operation in decodedResults.items():\n",
+    "            # operator = self.__searchOperator(operatorMap, operation)\n",
+    "            corruptQubit = self.getDataQubitCoordinates(int(position[0]), int(position[1]))\n",
+    "            correction = f\"RotatedSurfaceCode.CorrectDataQubit(qubits[{corruptQubit}], {operation[0]}, {operation[1]}, {operation[2]});\"\n",
+    "            # print(\"Applying:\",correction)\n",
+    "            qsharp.eval(correction)\n",
+    "\n",
+    "    def getState(self):\n",
+    "        all = qsharp.eval(\"RotatedSurfaceCode.MeasureLogicalZ(d, qubits);\")\n",
+    "        topdown = qsharp.eval(\"RotatedSurfaceCode.MeasureLogicalZTopDown(d, qubits);\")\n",
+    "        antidiagonal = qsharp.eval(\"RotatedSurfaceCode.MeasureLogicalZAntiDiagonal(d, qubits);\")\n",
+    "        lastrow = qsharp.eval(\"RotatedSurfaceCode.MeasureLogicalZLastRow(d, qubits);\")\n",
+    "        qsharp.eval(\"ResetAll(qubits);\")\n",
+    "        return all, topdown, antidiagonal, lastrow\n",
+    "        \n",
+    "        \n",
+    "  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "00a4ebe2",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "553f0940",
+   "metadata": {},
+   "source": [
+    "#### Experiment showing that measuring along diagonal is effective\n",
+    "<img style=\"margin:auto;\" src=\"rotated_surface_code_measures.png\" width=\"20%\">\n",
+    "<br/>\n",
+    "<br/>\n",
+    "\n",
+    "- The image shows that the orginal lattice is rotated to save the number of qubits used.\n",
+    "- This causes the logical qubits positions spacially which also changes the measurement direction.\n",
+    "- As shown above XL Logical operation of X is defined by applying X operation or measuring it on the anti-diagonal qubits.\n",
+    "<br/>\n",
+    "<br/>\n",
+    "The following snippet experimentally proves that we should that measuring along the anti-diagonal data qubits is effective."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "20a80f0c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Round 0:\n",
+      "Success Rate 0: 0.58\n",
+      "Success Rate 1: 0.39\n",
+      "Success Rate 2: 0.63\n",
+      "Success Rate 3: 0.55\n",
+      "Best in Round: Parity of qubits in anti-diagonal\n",
+      "Round 1:\n",
+      "Success Rate 0: 0.53\n",
+      "Success Rate 1: 0.43\n",
+      "Success Rate 2: 0.69\n",
+      "Success Rate 3: 0.51\n",
+      "Best in Round: Parity of qubits in anti-diagonal\n",
+      "Round 2:\n",
+      "Success Rate 0: 0.54\n",
+      "Success Rate 1: 0.48\n",
+      "Success Rate 2: 0.7\n",
+      "Success Rate 3: 0.52\n",
+      "Best in Round: Parity of qubits in anti-diagonal\n",
+      "Round 3:\n",
+      "Success Rate 0: 0.54\n",
+      "Success Rate 1: 0.59\n",
+      "Success Rate 2: 0.54\n",
+      "Success Rate 3: 0.55\n",
+      "Best in Round: Parity of top to down\n",
+      "Round 4:\n",
+      "Success Rate 0: 0.56\n",
+      "Success Rate 1: 0.45\n",
+      "Success Rate 2: 0.59\n",
+      "Success Rate 3: 0.51\n",
+      "Best in Round: Parity of qubits in anti-diagonal\n",
+      "Round 5:\n",
+      "Success Rate 0: 0.5\n",
+      "Success Rate 1: 0.63\n",
+      "Success Rate 2: 0.65\n",
+      "Success Rate 3: 0.56\n",
+      "Best in Round: Parity of qubits in anti-diagonal\n",
+      "Round 6:\n",
+      "Success Rate 0: 0.58\n",
+      "Success Rate 1: 0.54\n",
+      "Success Rate 2: 0.63\n",
+      "Success Rate 3: 0.45\n",
+      "Best in Round: Parity of qubits in anti-diagonal\n",
+      "Round 7:\n",
+      "Success Rate 0: 0.55\n",
+      "Success Rate 1: 0.43\n",
+      "Success Rate 2: 0.61\n",
+      "Success Rate 3: 0.46\n",
+      "Best in Round: Parity of qubits in anti-diagonal\n",
+      "Round 8:\n",
+      "Success Rate 0: 0.54\n",
+      "Success Rate 1: 0.49\n",
+      "Success Rate 2: 0.64\n",
+      "Success Rate 3: 0.47\n",
+      "Best in Round: Parity of qubits in anti-diagonal\n",
+      "Round 9:\n",
+      "Success Rate 0: 0.59\n",
+      "Success Rate 1: 0.56\n",
+      "Success Rate 2: 0.67\n",
+      "Success Rate 3: 0.48\n",
+      "Best in Round: Parity of qubits in anti-diagonal\n",
+      "Best data qubits for logical measurement in Z basis is  Parity of qubits in anti-diagonal\n"
+     ]
+    }
+   ],
+   "source": [
+    "d = 3\n",
+    "noise = 0.1\n",
+    "T = 1\n",
+    "import networkx as nx\n",
+    "\n",
+    "true_state = qsharp.Result.Zero\n",
+    "\n",
+    "# Warm up for experiment\n",
+    "for i in range(10):\n",
+    "  qubit = LogicalQubit(d, T)\n",
+    "  qubit.encode(noise//2, noise//2)\n",
+    "  qubit.decode(noise//2, noise//2)\n",
+    "  state = qubit.getState()\n",
+    "\n",
+    "maps = [\"Parity of all data qubits\", \"Parity of top to down\", \"Parity of qubits in anti-diagonal\", \"Parity of qubits along the last row of lattice\"]\n",
+    "votes = {}\n",
+    "for round in range(10):\n",
+    "  successResults = [[], [], [], []]\n",
+    "  print(f\"Round {round}:\")\n",
+    "  for i in range(100):\n",
+    "    qubit = LogicalQubit(d, T)\n",
+    "    qubit.encode(noise//2, noise//2)\n",
+    "    qubit.decode(noise//2, noise//2)\n",
+    "    state = qubit.getState()\n",
+    "    for i,s in enumerate(state):\n",
+    "      successResults[i].append(1 if s == qsharp.Result.Zero else 0)\n",
+    "  winner = 0\n",
+    "  winpos = 0\n",
+    "  for i,r in enumerate(successResults):\n",
+    "    successRate = sum(r)/100\n",
+    "    print(f\"Success Rate {i}: {successRate}\")\n",
+    "    if max(successRate, winner) == successRate:\n",
+    "      winner = successRate\n",
+    "      winpos = i\n",
+    "  votes[winpos] = votes.get(winpos, 0) + 1\n",
+    "  print(\"Best in Round:\", maps[winpos])\n",
+    "print(\"Best data qubits for logical measurement in Z basis is \", maps[max(votes, key=votes.get)])\n",
+    "\n",
+    "      \n",
+    "\n",
+    "  \n",
+    "  \n",
+    "# qubit.decoder.graph_2D(qubit.decoder.S[X],'distance')\n",
+    "# qubit.decoder.graph_2D(qubit.decoder.S[Z],'distance')\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "595dfaf8",
+   "metadata": {},
+   "source": [
+    "### Setup for Noisy simulation experiment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8d13b78",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running for code distance d=3\n",
+      "Physical error rate p=0.005\n",
+      "Physical error rate p=0.010\n",
+      "Physical error rate p=0.015\n",
+      "Physical error rate p=0.020\n",
+      "Physical error rate p=0.025\n",
+      "Physical error rate p=0.030\n",
+      "Physical error rate p=0.035\n",
+      "Physical error rate p=0.040\n",
+      "Physical error rate p=0.045\n",
+      "Physical error rate p=0.050\n",
+      "Physical error rate p=0.075\n",
+      "Physical error rate p=0.100\n",
+      "Physical error rate p=0.150\n",
+      "Physical error rate p=0.200\n",
+      "Physical error rate p=0.300\n",
+      "Physical error rate p=0.400\n"
+     ]
+    }
+   ],
+   "source": [
+    "def isLogicalState(state):\n",
+    "    # Anti-Diagonal Measurement\n",
+    "    return qsharp.Result.Zero == state[2]\n",
+    "\n",
+    "\n",
+    "def run_experiment_for_d(d_values, p_values, num_trials):\n",
+    "    results = {}\n",
+    "    for d in d_values:\n",
+    "        logical_error_rates = []\n",
+    "        print(f\"Running for code distance d={d}\")\n",
+    "    \n",
+    "        for p in p_values:\n",
+    "            logical_errors = 0\n",
+    "            print(f\"Physical error rate p={p:.3f}\")\n",
+    "            true_state = qsharp.Result.Zero\n",
+    "\n",
+    "            for i in range(num_trials):\n",
+    "                qubit = LogicalQubit(d, d)\n",
+    "                qubit.encode(p//2, p//2)\n",
+    "                qubit.decode(p//2, p//2)\n",
+    "                state = qubit.getState()\n",
+    "                logical_errors += int(not isLogicalState(state))\n",
+    "            logical_error_rates.append(logical_errors / num_trials)\n",
+    "\n",
+    "        results[d] = logical_error_rates\n",
+    "\n",
+    "    return results\n",
+    "physical_error_values = [0.005, 0.01, 0.015, 0.02, 0.025, 0.03, 0.035, 0.04, 0.045, 0.05, 0.1, 0.15, 0.2, 0.3, 0.4]\n",
+    "\n",
+    "TRAILS = 100\n",
+    "logical_errors = run_experiment_for_d(d_values=[3], p_values=physical_error_values, num_trials=TRAILS)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2312303d",
+   "metadata": {},
+   "source": [
+    "### Physical v/s Logical Noise"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3a80a1b7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{3: [0.03, 0.09, 0.1, 0.1, 0.03, 0.06, 0.1, 0.05, 0.06, 0.06, 0.03, 0.04, 0.05, 0.09, 0.04, 0.04]}\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "print(logical_errors)\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "for d, errors in logical_errors.items():\n",
+    "    plt.plot(physical_error_values, errors, marker='o', label=f'Code Distance d={d}')\n",
+    "\n",
+    "# Labels and title\n",
+    "plt.xlabel('Physical Error Rate', fontsize=12)\n",
+    "plt.ylabel('Logical Error Rate', fontsize=12)\n",
+    "plt.title('Rotated Surface Code: Logical v/s Physical Error Rates', fontsize=14)\n",
+    "plt.legend(title='Code Distance')\n",
+    "plt.grid(True)\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "# Save and show\n",
+    "plt.savefig('logical_vs_physical_error_rates.png', dpi=300)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3bdf5e74",
+   "metadata": {},
+   "source": [
+    "- The varying d values are not simulated due to the resource constraint of the machine as d=5 requires 49 qubits in total including ancillas\n",
+    "- We expect the logical error rate to decrease with increase in physical error rate.\n",
+    "- As we can see that the error distance decreases with increase in showing that the logical qubit is resilient to errors. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9044d97",
+   "metadata": {},
+   "source": [
+    "### Results of comparing with increase in Timesteps T\n",
+    "- The commonly used T values are d or d**d to know the relationship we simulate an experiment for varying timesteps\n",
+    "- The previous expereiment was run with T=3, 3 timesteps same as distance code, now we run varying time steps keeping the distance code (d) and physical error rate (p) as constant. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b2859fb1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running for code distance d=3, timesteps t=1\n",
+      "Physical error rate p=0.001\n",
+      "Physical error rate p=0.010\n",
+      "Physical error rate p=0.100\n",
+      "Physical error rate p=0.150\n",
+      "Physical error rate p=0.200\n",
+      "Physical error rate p=0.300\n",
+      "Physical error rate p=0.400\n",
+      "Running for code distance d=3, timesteps t=2\n",
+      "Physical error rate p=0.001\n",
+      "Physical error rate p=0.010\n",
+      "Physical error rate p=0.100\n",
+      "Physical error rate p=0.150\n",
+      "Physical error rate p=0.200\n",
+      "Physical error rate p=0.300\n",
+      "Physical error rate p=0.400\n",
+      "Running for code distance d=3, timesteps t=3\n",
+      "Physical error rate p=0.001\n",
+      "Physical error rate p=0.010\n",
+      "Physical error rate p=0.100\n",
+      "Physical error rate p=0.150\n",
+      "Physical error rate p=0.200\n",
+      "Physical error rate p=0.300\n",
+      "Physical error rate p=0.400\n",
+      "Running for code distance d=3, timesteps t=9\n",
+      "Physical error rate p=0.001\n",
+      "Physical error rate p=0.010\n",
+      "Physical error rate p=0.100\n",
+      "Physical error rate p=0.150\n",
+      "Physical error rate p=0.200\n",
+      "Physical error rate p=0.300\n",
+      "Physical error rate p=0.400\n",
+      "Running for code distance d=3, timesteps t=12\n",
+      "Physical error rate p=0.001\n",
+      "Physical error rate p=0.010\n",
+      "Physical error rate p=0.100\n",
+      "Physical error rate p=0.150\n",
+      "Physical error rate p=0.200\n",
+      "Physical error rate p=0.300\n",
+      "Physical error rate p=0.400\n"
+     ]
+    }
+   ],
+   "source": [
+    "def isLogicalState(state):\n",
+    "    # Anti-Diagonal Measurement\n",
+    "    return qsharp.Result.Zero == state[2]\n",
+    "\n",
+    "\n",
+    "\n",
+    "def run_experiment_for_T(tValues, pValues):\n",
+    "    SHOTS = 100\n",
+    "    results = {}\n",
+    "    for t in tValues:\n",
+    "        logical_error_rates = []\n",
+    "        print(f\"Running for code distance d=3, timesteps t={t}\")\n",
+    "    \n",
+    "        for p in pValues:\n",
+    "            logical_errors = 0\n",
+    "            print(f\"Physical error rate p={p:.3f}\")\n",
+    "\n",
+    "            for i in range(SHOTS):\n",
+    "                qubit = LogicalQubit(3, t)\n",
+    "                qubit.encode(p//2, p//2)\n",
+    "                qubit.decode(p//2, p//2)\n",
+    "                state = qubit.getState()\n",
+    "                logical_errors += int(not isLogicalState(state))\n",
+    "            logical_error_rates.append(logical_errors / SHOTS)\n",
+    "\n",
+    "        results[t] = logical_error_rates\n",
+    "\n",
+    "    return results\n",
+    "\n",
+    "physical_error_values = [0.001, 0.01, 0.1, 0.15, 0.2, 0.3, 0.4]\n",
+    "logical_errors = run_experiment_for_T(tValues=[1,2,3,9,12], pValues=physical_error_values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "4ebe9223",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{1: [0.41, 0.36, 0.34, 0.35, 0.46, 0.39, 0.38], 2: [0.36, 0.43, 0.48, 0.5, 0.4, 0.44, 0.38], 3: [0.05, 0.04, 0.09, 0.02, 0.04, 0.12, 0.11], 9: [0.37, 0.42, 0.36, 0.5, 0.42, 0.34, 0.4], 12: [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]}\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAJOCAYAAACqS2TfAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQV4W9X/xt+6u65r5+7euQATNob7sA37A8NtuI8Nl2E/YMhgMNwmTIC5u7u2q7tb/s97bm+bpKmubZL2+3mes6XJTXJy5dzznq85GAwGAwRBEARBEARBEARBqHcc6/8jBUEQBEEQBEEQBEEgIroFQRAEQRAEQRAEoYEQ0S0IgiAIgiAIgiAIDYSIbkEQBEEQBEEQBEFoIER0C4IgCIIgCIIgCEIDIaJbEARBEARBEARBEBoIEd2CIAiCIAiCIAiC0ECI6BYEQRAEQRAEQRCEBkJEtyAIgiAIgiAIgiA0ECK6hSbPl19+CQcHB/W/PfHee++he/fu8PT0VP1/5513rN0lu+H5559X++y///47588yGAzo378/xo0bV+P33HLLLer7T5w4AWvy2WefwcnJCbt370ZTg/uW+5j7urHg940ePRpNGV4z/J28hppTP6xxPglNg7qcq7ZynTU2tnJvrCtt2rRRTRDqgojuJoI+YTBuLi4uaNmyJa6++mps2bLFpgZLW5/gLFy4EJMmTUJoaKjaj8HBwejRowemTZuG33//vcG///vvv8f9998PNzc39f9zzz2HwYMHw97YunUrbr31VnTs2BFeXl7w8PBA+/btceONN2LZsmWwB77++mts27YNL774orW7gm+//RaXXXaZ2oc+Pj7w9vZWCzMPPvggYmJiKmx/8803o3Xr1nj00UfrrQ+8brt06VJvnydUhGPNgAED6u3zuFBgfG9wdHREQEAARowYoRYjubAk1G0xt6pmq/e3mohB48b7EIXG1KlTcfjw4Wa7EF5bRKDZ15y5qmbvx7E+DRFC3XE+h/cKNggn4zfccIN6nJ2drUTPjz/+iN9++w3Lly/HyJEjrd1Fm+eFF15QAxQtzBdddJEabIuKirB3714sWLAAhw4dwiWXXNKgffjrr7/K/o+IiIC9UVJSgkceeQRvv/02nJ2dcd555+Hiiy9WCxjHjh1TixrffPONErLPPPMMbPl38FygOLGFRQ8uxnDSy760aNFCiaUdO3bg3XffVRPYNWvWKBGuw/1NQX7fffdh7dq1GDZsGJoKXFDcv38//Pz80JQ4evSoGmteeumlev/shx9+WC3UFBcXq+vwl19+UecM7xPvv/8+bIlBgwap48sFT1vm/PPPx/Dhwy2+1qdPH9gr9O7h/Y+kp6er8YNjDM+ZTZs2oXPnztbuos1gL+eqLfDqq69ixowZavy2Jv7+/sqYYWn+x3vKAw88UGF7smLFikbro9D0ENHdxOjQoUMFd6VZs2bhiSeeUOJm5cqVVuubvax+UghGRUVhw4YNFQRvbm4uNm7c2OD9iI2NVf/bo+AmTz/9tBLcnHT+9NNPajHIfD/OmTMHycnJsGUWL16szomnnnoKtgAX0Nzd3Ss8//nnn+O2225T1z63Mebaa6/FQw89hI8//rhJiW4uKDRFi7vuSdMQC3tcCAsPDy/7m2EH0dHR+OCDD9Q50rZtW9gKXPS0h+N7wQUXKBHR1KCnhflc4v/+7//wySefYObMmfjqq6+s1jdbw17OVVuAi8Vs1oYi2pJrP0V3Za8R87mMINQGcS9vBtC9l9CaYU5SUpJa0eNkiy5kdKemO/qePXtMtqO1V7/Jclvd5cY4vvHXX3/Fddddp4Q/b0JcLaSF8Oeffzb5LK6W65M7fqaxC4+x6wuteHPnzlVCwdfXV30mJwJ8zhIpKSlqUhAWFqa2HThwoOpTbeAKPq2bl19+uUXBS/do85jOqtzuLbn0GMdyrVu3TsUKc5DX3e34/7///qu2Nd43Ovz9nJDzmFCABQYGYvz48WXvscSqVatw6aWXqn3D48xFBf5GWrmMqe0+t8SRI0fw2muvISgoCEuWLLF4k+J+pMszb3B1OR91Tp8+rc457gNa8EaNGqV+a1Xw9cmTJyurBL+Dru9cJMjJyamw7RdffKH2/RVXXGHxs2iRpDWIrt483ydOnFhpX+sDS4KbXHXVVWX73pyQkBB1znLxIysrC41JbY8nr6FrrrmmwvG0dB1VFaKSmZmpzq1evXqVjUV9+/ZVC4+FhYW1HrNqy7x581TfKgtJYLgCX58yZYpF0c391bNnz7Ln2B/uC+4/ngMcmyj2zrWf/A5+Lq97SyFIfG7s2LFl5zdDG4zHOVpAGTZi7F1hDMdSjlN0ZedCG8nLy8Obb76J3r17q8/k+7kNz4udO3fWKOY1ISFBWe1pbeVYwvOFiwdvvPGGyXZ1GSsbiqrGfWJ8jvM+0K9fP3VOGt9vTp48qe7ntBK6uroiMjJS/X3q1KlKQwq4vzm+cRzmQtW5xBBXNpcoKChQnhLct7y36Nc67zHbt2832ZbXK93UCf+3dI/Tr2FaInlu8RhzX/Hzze9Z5OzZsyoMi2O5vm3Xrl3VfIDnaFXwnON3T58+3eR5egfqrvXm9waeT8YLVObnqj428XixGf9GS/u/uuusOk8LhovweyxBLyd+rx7OVZtjZR4K8Oeff6q5AfvJfUDvSb529913V+q1w77xu6qaLxnvv9rsC3pdcH7CY865ze23347U1NQGdeu39NnG1y7nDBxX2SeeI8zNQzjGctzjmMWxiOcqQ9cswWP01ltvqTGA4yP3Be9Lf/zxR4VteX4/++yz6Natm7pnct7G+xlDy/RzgmOBPtcaM2ZMpS7zHFfpGcf387zgHIlzH0v3a30/pKWl4c4771SLufxdvM9+9913Fbav6bjf1BFLdzOCbr7GJCYmYsiQIWpg5EVJi9jx48fV5Jzuv3///XeZ2xwnzhx0eXHw5qa72hhftLSmcyLA93Alk5/PQeLKK69UA8+9996rtqP1k59Bl1hegBSDOvrncYDihJQXLwen66+/Xn02bxy88e/bt89kgsWbIn8DLTf8TZxIUpBxAl+bBFgUiqQ+4taqgxMvWgw4CN5xxx1q4sR9w4kG9zUHTEvuT/fcc4/ab5x0U1AxlpcTBP7Nm5C5hYz7mQMpbwK8gbVq1Uq9h5MXHmv9GNd2n1cG+073VQ7EvBFWBQf2upyP+kSL2/O38KbOGxRd/HjD5j61xEcffaT2H89fCm9ONniTf+WVV9REnI2/Wd8f/Js3SYoGc3gj4gSEQpYTFu4zLtrwOR6fxoT7R48FtgT3EydI+mTf+Fhx4ssbdH3HV9b2ePI4Dh06VB3XCRMmqJv3wYMH1fFkeEJN4cSB1/+BAwfU9XTXXXcp8ce/Z8+ercSaPn7VdMyqLTwf+L2MweeEyJIoJ8xtYL5IQTde4+/lOctJLfvH65djVFxcnDrXuGhQ2YJQbTEXPZs3b1aLZ7yWeC1zQs5xhmMsz31OsDh54nGluOW5xeNnDMcOjmO85jj+EJ5rP/zwg1oQ4bnHMYBjNa81fmd11w7PCfaJ5wmPG+8fDKXiAhjHU1rz6zpWNgaWxn1jXn/9dbUv2Ddeq0yESBjWxN/Lc5RjF8UojwP3PcUQx/NOnTpV+D6eH7xv85rieV8f3gzmcwkueHOOQGHAhUeOlwxf4LVEbyEunHERnPB4caLOxSX+Rksu+Pw8hsLxmHI8pXjOyMhQ7+F+ozePPm/gvZ/bUJhxf/EaoWjhWMPrjOdDVSEoPA95TZkvxOh/87N4TXIcIvxcntP6wkFVrst68lNjV2XzRfuaXGdVwTHkn3/+UWPNk08+afIaw+IYksRFOorz2h4rY7jPly5dqhaZOR7xePAzuZgzf/58NTfgIpF5Ik/eRymGa0Jt9gXPe85LKDJvuukmdYwXLVqkjhMXVrnA1NjweFN487zmPYuLopzrcr/wt/Bv7j/uNx4XjoWc8xqHfebn56trlZ/Da4O/kb+H90x+LhdM9AUi7lvOfeh9yWuA79MXYHg8eW4wp4u+ME1PV/07iX4fJPp9+syZM+o64vXFeyn7zHs13eq5sGkMrw2OpZwD8bs4DnNs59yR9zLj+9i5jvtNBoPQJDh+/Dgz4RjGjx9f4bWZM2eq1yZNmmTy/NSpU9XzTzzxhMnzCxcuVM936NDBUFxcXPb8zTffrJ7nd1ni6NGjFZ7LzMw09OzZ0+Dn52fIzs6u0F9+piX+97//qdfZx4KCgrLn8/PzDZMnT1avbdmypez55557Tj13++23m3zOkiVL1PNsX3zxhcXvMu9vq1atyvbXvHnzDAcPHjSUlJRU+p6q9over3///bfsOT7W+zR37lyLnzlq1Cj1uiWOHTtW4bnY2FhDRESEoWPHjibP79ixw+Do6KheM+8ff1NMTEyd93lljB49Wm27fPlyQ22o6/n48ssvm2z/ySeflO1f4/2+d+9eg7Ozs6F3796GpKQkk/e8+uqravs33njDZHs+N2XKlCqP0TfffGPyPPuvf7/5Puf5UJtW2bW2YMEC9fqjjz5qmDhxosHJycnQtm1bi+cG+f3331V/nn32WZPneU1UdR1agtt37ty53o/nDTfcoJ5/5ZVXTLb//PPPLR7PysaQK664Qj3/5JNPVuhTXFycobCwsE5jlv7bedxrgv57Nm7caPJ8UVGRISwszBAeHq4eWzoe//33X9lz/fr1M7i6uhri4+MrfIf5eVwZ+rl69uxZk+f37Nlj8PDwMDg4OJSda8bj0/fff2+y/Y033qie/+6778qe4+/jc7fcckuF773yyivVaxyHSFpamvqu/v37V/jt/Ds1NbXsb70fPM+NGTBggHqe45U5p0+frvNYWd09yRz9WJ1//vmVXr/79++v8biv3yu8vLwMu3btqvD6mDFj1Osc34z54IMP1PPnnXeexWPep08fQ3Jyco1+k3E/77zzzgqv8Tm+ds8995g8n5eXZzhz5kyF7Xl+eXt7Gy644AKL+66ye/L111+vXv/0009Nnuc1EBUVZQgJCTHk5uaq5/744w+17QMPPGDxWmbfquPyyy9Xn8HxQYdjwIgRI9S1ZzyG6ePR119/Xe252rp1a9UsUdvrrDIyMjLUNdytW7cKr/3555/qcx555JFzPlacRyxbtqzC+2bPnq1e//LLL02e5zjbokULQ2hoqMl8wtJ8qbb7guME+8pr5dChQybfyeuA21e236ujuvdaOqb6tRsYGGhyTzl16pQ6f3gv6dSpkyEhIaHstQ0bNqj3cG5lDO9bfP6ZZ54xmXfyOHPs4+fp8zaOE9z20ksvrdBPHmee/+Z9NL6HGjN06FA1j+Cc2RjOf318fNT1YL4f+HkjR45Uc0TjMTg4ONjg5uZWdp7VZtxv6ojobiLoE4b27duX3fA50Oo3ak7y9u3bV7Y9LxJ3d3dDUFBQhYklGTt2rHrfqlWraiy6K+PNN9+sMJGsboLTq1cvNaDm5ORUeE0faB5++OGy5yg4OBiZTyoJJ0U1Fd1k27Zthu7du5fdBNg4aF500UWGX375pd5ENyfTlVGV6K6Me++9V73nxIkTZc/dddddVYr7c9nnldGlSxe17YEDB2rc99qej/r2vKHrky8dCjlOqM33+3333VfhnDZ+DydyvCno/P3332r7hx56qML2J0+eVK9xn5nDG52/v7/Fc8L4nKpJq+wGqQtLvfFmfOTIkUr2bvkNftq0aSbP82ZIYUAhUp+iu7bHkxME3qR5PM0nyZx48PtqIrp5/fPmznHQeKJXWyyNWbUV3fr5w+vSmEWLFlUqEjh54j4znphwnOB1mZKSUuffo48nvH45Jj399NNqMYmTdT7Pa8N8fOJkyhz9NfNrom/fvqqP6enpZc9xgskxeeDAgWXP8XW+f9iwYVUuZFYmZHSBb6lv5zpW1lV0V9V+/fXXGo/7+r3iwQcfrHS8obAy328cu/Qxl5N882POBbfaoPeTY6E+l2CfeBz5PMWDpftsZVBU8Dwwvh6rEt2JiYlq8m++iKDz3nvvqfdSUBqLbvPFvdrw/vvvmwg79oHjCBdjea5FR0dXWEwz3tfnIrprc51VxnXXXae237p1q8nzV199tcmi17kcq8suu8zie/TrfPjw4SbP//bbb+p9XBg2pirRXdN9QYFvPm7prFu3zmqi+4UXXqiwvb4I8NVXX1V4rV27dsrIY3wtBwQEqPuXpfFRP9d5vhrPy3j8q6Mq0c05r6X5gQ73PV/fvXu3yX7gc2vWrKmw/UsvvWRixKjNuN/UEffyJgZdRMzjZBlrsXr1ahWnoUNXS8ZY0I3H3CWI8Hm6BjIzMt2QagJdUZi0jS5KdG/RY/jMk4NVB93F6E5Elyi6g5qjx2TyNxC6OdHlizEtxkmCdNj/2mScpFsrv3/9+vXK9YXxa3TdYyZxNrpg6zGb54IlF66aQFcwZgClSxndJemOZL6f6VJE6IJKqnOxr+0+r29qez7SxZTb04XL3P2O7lV0tTIPEWBiPKK7SplDdzTj36cneTN2wdLRY5AsZS1mXBXdwiyV5qiv0kx00SZ006TbGhO9MdswXWYtuWIzlpXQ5csYuuQ1RPbvuhxPnseMzzMOOSC8zui2zG2qg6EC3Mf8/Jq4F9bXmGUJuhDSJZxuhIzP011ymbXfkms5v5vum3Rt112KCd23H3vsMRU6QLc9/jaed3SrrC2MqdP3Kd/P/U33RbpnmsPzyRzGEOvnnTF0BaULMN1M+T9hvCLdD41dS/mddGmlGyjDQZiLgC6NHAtrcrxqOp7VZaw812zM9TXuMxO2ObxOCMMmzO87HO/onsprjtsxTre6z6sJvO+Zx24z1Ib3QktZuvnddA3m6wx/MM6doI89NUmgRVdThifxWFmKf9bHdf5euuryt/NzeR1zXOZz3E+M6a7pPVoPR+L9ntcbx26OIxxLOY4x/Igx5oyt5TZ0qTbfz3WlNtdZZXAsYVgY5yW8rvR5EcMOGF9s7rpbl2NV2XnEsA2G03Cc4zHRE8rRtZwwwWd974uq7r90gTYPf2gsLIVK6PuxsteME/PyHseYdM7DzOfxhKElRJ+n8BynuzaPPd3C6RLO8ZTfxXGhpuhzo/j4eIvXnP59/N84hI37mSFk5uiaQc8RcK7jflNCRHcTg/EdTF6lX6BMVPb444+rck2csFAQ6AMyqSzmVh8o9O2qg3FCvIAYn0bBwzgPihVOHjnAMxbLfMJTGRx0eMPjJMnSwKPD+BHjPjI+1xLVxRVbQp/o6zGK7A9/AyenjJ1inBxjx86FuvSLibJ48+Nv5kSBsX0c0DjAcqLAmB3j/cwkG/wt1U12arvPq4ILHxyc+Vk1LStT2/NRT45Tm2POc5RwAlUT9BhUTrrMqcv3NwS8xnge8Jrnvub5yQUo8xuZLiYtCeCGoLbHs76uYf241KQcTX2OWZbg51AkU+hyoWfSpEkq9o0xilwg1CfHOlyE4OKXeZwxY1IZc8rYbn4WYyc52eHnsUJAbWJ0GQdtaWHSEpZEvT6ZpSgyhr+T/eREWxfdzKjP+w0T1ZnHhjKmmQJdrwrA72KcH5+v6hytzfGt7VjZWFR3Llt6/Vzu13Udi7iQwooHvC/wvOG5xnOPE2bmhzBeGGKcur7YxwUR5rfgsee9h+c7RVJN97U+TjOOmq26exEXDSkamDuBIpMTe0JRzMWQypJ8GcP4eI49ehw3/+e5QhHIsZP3RBou+Lt4X6uNkKzP66wyuM95nCl8eYx4bLgwy76bL+7V9VhVdR7xXOF38/rn93MxiwuZXPywlGfgXPdFVfcLXt/WKt1WVf8re41x9+bnPnMZsFV37vP9XFCkUGbsNfOV6AshjPvm+Gp8nVaG/r2MG9fzw1T1vTrcz5bEvX6uGCcxPJdxvykhorsJwwuPEyGe+C+//LLKYKon9tAHAK5sWYKrn8bbVQcnWJy8srYsv8cYrkDrZXBqgv6dvOFZyqhb2fa0Wlmist9YG3hD4ioiE5IxIzEHOl1064OO8eCpU1Xm1LpYyjnxoUDmirZej12Hk13zknAUEfqkqaqJam33eVVQwHBSS2tyTRNg1fZ81K2ztTnm+nt5w6bFoibXj/ENyZi6fD+pbeZgJkCpSRZW/jbW7uakiWKDK+DG6L9B/00NTW2PZ31dw7pXAifGjTlmVQYnvBTKtG5TJHNiRGFtPhEm/D56bRhn+tXHiWnTpqlG7wtO/mnZYFIaWv127dpVo4lVQ8LriR5ALCfFBQtOzpjUkOJEX+jV4eSK9yM2LhBR4FDcMeEjRQI/oz6Ob23HysaiunHf0uvncr8+V48svp+WNyZ44/fwXGYyJ+PkYFzIpFDjuWlufaQgrk12Yv03UEDUJHEnYXJQJoJkwkReD/QYYSJEJtJjojDzhR9L0PLGa4rnFu9ftKDzuuK4ygVYnqf6eVdZok5rwX7yN3J+xwURjiE87zk34YKYMXU9VlWdR9x3tHDTu4UCihm8KZJrmkCttlR1v+A5QEu9teuAn8vvolFH92arDi7I8nrk+U5jB+em/JuJ/Lj4zmShNf1e4yRtNYH7mfvbXHjr45SxF925jPtNCSkZ1gxgRkveND/88MOy0gscIDnBoyuXpVJJumussUuMPrGztPpKt3ZiKRssB3dzqvosTuAoGjhpq4l7FQcMWnsoNvTJR3XfX1fMJ5BEz2xtaSJoqQTHuVDZfqawtmQV0F3COAmpitru8+qEIo/v//73vzJ3qMrQV9Rrez5y9Zzbc4HA3BLNmwBX883RM2/qrlQ1sX7wZmLJrVl317NUvobWTN0d1BxaTGrTalo2xtgV2pK7lv4bjMtQNSS1PZ600tOtnO6s5lYWntsM9agJdJfmMeMN3dxl8lzHrLrA84T7nIKa7qkULJZKhfGcZegKre0spVLVBIuLfwsWLFALWqwoYKlMnDWgtYt8+umnZa6l1U26OW5zMYECmGOrpZI4dRnP6jJW2jL6dcLM0uYhKvxbL5NoyYW1PqFLMgUoJ848n433NUNYzEUcr32Wx6vN/Z/eJ7xGanrNG8Nrn/uA4Rh62aLqzikdXUjzfbyu9AVjjkv0eKOY0S3h5hnIK4O/s6bW6nNFX8jjGMOs0Lym+JvMxWdtj1VNYSZ+3u+58MvM4pwX1Vdlhcruv5auY3p0WjKA2AOcg3E+y3lNdfcvc3jN8P1caNLLwxmf+1Vdc/rcqLbXHPezpffo90+GatbHuN+UENHdDOBNki7mvIhp1SEsk8OVUa5UMSbNGLqq0h2SMeC0WprHhXJAN0ePizMXIXQl0d29jOGAzEHC0mfptSV5E+CkzZJLM1fKjAUJbziMHzQvz8PJWW3iuTlgc7XWkksxbyj6ZNL4hqXH6JmXXOJKZX1bUyrbz7TMWaqlSIsOB1ta8szreHKyZhyzWtt9Xhk8bzjp4bl14YUXqveZw/3LOFfd8lvb85ETIdZ35Eq3Hqeqw2PE8jrm0M2Q7lgsY2Gprq0eH21sVWO8FG+AFEXmlhVaQmhVYbiBMVzpr2zhojR5ZY2b8eSOk9zK4po5yeG5S1dB49wNOnrcGN39zD0xuDpOT4j6pC7Hk7HMXCHXvXF0eD3WNJcA3do40bOU24LwfNEnZLUds+oKxyau5NMSwYk7j4F5PCgnLuybpQUAPb7UGI7luvdCdSWFGgtOsDgW8nqgKyGvHfM4UI6hlsYpWqS52FLdb+Hns1FkUtybY7zwWdux0pbheEMBRZdTXuvGcHGTi6UUifUVZ1wZdGPnPYUeF8bXKfc1j6GxSywn9/S0s7TwWtVcguEPHNu5cErruqU8GBzP9MU8fqclDwD9uZpeH7ro5sICMfbS4mtcSOV8ggu+NGLUBP5OjoGW5hP1DcNVGLbCMoK0GnK/WfKoqe2xqiksCcV9TW9A5lLgdzfU2MRxkmKN3kr64hrh2P7MM8/AXuH8hKUmOVfj8bAkvDl26RZ+zscszcksnftVXXMcpym8ueDEBV1zOP+pbC5Lox7n3jqMLaf1mvd05keoj3G/KSHu5c0ErkIyQRYnsLxImAiEf/NC4qo1b3C86HgBc8JEVxC6CBm7jfAmRHcvfhYntrTIcADn4MrGz6Og4Wown6ebEgUvk2wwwZMxHDD1yRPfS7HA79LrCtJqQoskY9K5mkkLEG90HEw4AedNl5Nj3fWWIo/fwYkYbyYURBxc6C5Gt86q4lSMoQjlzYMuNvwMWuw4EHIQpCWKVkx+HuPajG8A3J8U3fxOTj45CeIEW08eUV9wwsPjwv3PiQktX9xPXKG29DtpZePkiIKalltaybh/6RHAfc/36JOn2u7zquA5xYkGXTxpxeS5wwQctMJShNMFjhM3bqdT2/ORk2eeX1xQ4MRa3+/c34xVM7eG8fvp7cGbGvvEY8PjRjHLSQK/m1Z6ujzpMISAblrcL+Y1iD/44AMlGhlHzdV9vU43rbtMJFKfHhaE+4sr2bTm8rykBYM3LX4fjz9XyHnszOHki/uJ7zWPr+MErS51uinS9dqf5jDOi+NEbY8nxTnPC8Zh8n16nW5ed6w/SrFek+QwPMa8wdONkucCzz3uAy7E8Jzg+cwFldqOWXWF7p38TVwE4OTF0kSY5w9/G+OOzeE1q4cPsI+ciNGSQWscFyrONRFYfcLxiYnZKrNyUxTzuNJSRVHOc5jnNT0B+LuMa2xXBkU9F6N4H6ILLRP5cKzhuM9FMz0BYm3HyrrCc7YyUUUBqce4nyuM6ediL/crY5cpsPibaSVi2Ahfbwy4gE9Rx0VTXju8lvg/ry32j/uak2guFvF481iZJ5XkMaMxgPcejmF62Ise5sFrmNc+7+v6Meb38P7KRVCGVXAM4jjCa+HRRx9VYzHHNx5nve40+0HLX03gPYGLCvxcfgbPT2PRzWuX5xavuZrCsYf95eIz7wlcjOS8wrguc33CsYXuxFw44L6xZGmu7bGqKRR1nBfxeJGGci0nPBd4/nEMYEgcxZ1ep5tij/OW2iQSsyV4n+AYxUVajlE8Vxi7zuPDZLe8R3GRls9xIYj3KopmPZEwt9PvJ1wAMT6Haeji/J/jBvcX96PuTk7BzW24L3ldchGH1ygNFPw+CmfzcY7XCw00vFZ479LrdPM6Yf91L4v6GPebDNZOny40fJ1u87IYrHuow9IYLLvA9P8uLi6qvh5rqxqXBjDmtddeU+WYuK15+RyWpRg3bpwqecC6fnyNtZorKw/C+n+sMczySizPYamcAesRs24kP5Pf2bJlS1UHmiV92HdjWIv0jjvuUKWfWK6IJU9Y4qu6mqDGsBYi6y5zH7FsGPvG2s78TJYeY41O8zqD+v5nuR/+bpbO4babN2+usmSYeXmRmpYM4/tZeoHfxf5xH7JUSFUlIfgcS56xjiTLe0RGRqqyU2vXrq2wbW32eXVwH7AMBWsyszwRy0K1adNG1WG1VPOztucjS+lcc801aj94enqquqorV66scl9s2rTJcO2116pavfp3sIzPjBkzTOrqEtbD5PFn6TVLsF/c/6wZyuNx4YUXqufqWl6vKrKyslSdbZZVYY1n9p3nGs9TlvQxr1Gsw7JX7Ms777xT4bW61umuqhmXU6nt8WRd5auuukqV6DM+ntOnT1efvX379hqVeGKJEtY5ZSklnnP8PNYr5v4zLodT2zGrNiXDjOH1xPdyXDIuq6XDMZV1Ui3x4YcfGi6++GK1D/UybIMGDTJ89NFHNS6LVlmdbktUNT5VV1aL5eG4v3mtW6q9yueef/55dQ6zhi/HIl6HEyZMMCxevLjG/WA95fvvv1+V3OFncFxjWae33nqrzmNlQ5QM6927d41+T03q6BKWOJs6daradxyX+D//Ni59di5lJ6ur063D0nPchteYzk8//aTGUV63vM5Zroo1iysbCxcuXKjKkOll68z7ytKVnG/wPs5xjtuxNCjvs6yRzZrMhKVQeS6wbB2vDZ5/PC/4vXv37q3Vb9frg/PeaAyvM47xxmXFLO0z82PL8pG33367Ok4sg2a8zblcZ5XBMmasp11dGanaHKvazJ84dnLbwYMHV7pNVSXDarsvfvzxR3Xc9XKTt912m5oH8lgZX3uNVTLM0rVb1VygsmuUc8xPPvlEjV2+vr7q97G0GMdJjvucCxDe8zlv4f7m7+dYyO1Yd379+vUVPpel1lhvm59n6XeyLCXLSfbo0UNdb9yPvDfxujAvl6vvB76H826WJebncr/Pnz+/zuN+U8eB/1hb+AuCINgqtB5wxZneDjVJwGZrMIkUM8nSDc9S+TN7gFYZrrbTHd5SXgV7ht4ZtFLQ6k7Lnj1Dqx49mHjN0KtKEITmAz2c6HVAt2/G7FoD5rig1xmt+JZcpYX6Qfd4rE3eGUFiugVBEKqE7tGMyWVmT3uDLtUs5UK3TXsQ3JZiy5kYSA93aGqCm+hZ0i3Fc9sbjMElDOEQBKH5QNfjOXPmqHw9eixvQ6LHAxvD+7TuUs2wHEGwNSSmWxAEoQoYM8tY6fooPdfYMKkJY9JrGtdobRh3z9gvWn71etmMMaSHQU3LB9kbjPdms1cY88dcD4wTZDwfyxUxBlcQhKYP86kwBweTY9IbjLk5GqPmMr+T+SOYv4WJBpmwjnl0aHllLP0111zT4H0QhNoi7uWCIAiCTfDUU0+pJFEUckzKwgRLTO7CjLRMHifYHlwU4TGiFwL/ZzZtJvQRBKHpwwokTP7FBJoMK2ESNyafbWiYTI/3BSbp1LOusyIGxTYTczWnjNjWQNzL64aIbkEQBEEQBEEQBEFoICSmWxAEQRAEQRAEQRAaCBHdgiAIgiAIgiAIgtBANPtEaiUlJYiNjVWJelg4XhAEQRAEQRAEQRCqg5HamZmZiIiIgKNj5fbsZi+6KbijoqKs3Q1BEARBEARBEATBDjl9+jQiIyMrfb3Zi25auPUd5evrC1ujsLAQS5cuVWURXFxcrN0dwQw5PraNHB/bRo6P7SPHyLaR42PbyPGxbeT42DaFdnJ8MjIylAFX15SV0exFt+5STsFtq6KbNQ/ZN1s+4ZorcnxsGzk+to0cH9tHjpFtI8fHtpHjY9vI8bFtCu3s+FQXpiyJ1ARBEARBEARBEAShgRDRLQiCIAiCIAiCIAgNhIhuQRAEQRAEQRAEQWggRHQLgiAIgiAIgiAIQgMholsQBEEQBEEQBEEQGggR3YIgCIIgCIIgCILQQIjoFgRBEARBEARBEIQGQkS3IAiCIAiCIAiCIDQQIroFQRAEQRAEQRAEoYEQ0S0IgiAIgiAIgiAIDYSIbkEQBEEQBEEQBEFoIER0C4IgCIIgCIIgCEIDIaJbEARBEARBEARBEBoIEd2CIAiCIAiCIAiC0ECI6BYEQRAEQRAEQRCEBkJEtyAIgtDoGAoLkPvnXLRa86P6n38LgiAIgiA0RWxSdH/wwQdo06YN3N3dER0djU2bNlW67ZdffgkHBweTxvcJgiAItknG3Jk4Mrg3Yp58B+5/blX/828+LwiCIAiC0NSwOdG9YMECPPTQQ3juueewbds29O7dG+PHj0dCQkKl7/H19cXZs2fL2smTJxu1z4IgCELNoLCOee1rFGUbTJ7n33xehLcgCIIgCE0NmxPdb731Fm6//XZMnToV3bp1w8cffwxPT0/MnTu30vfQuh0eHl7WwsLCGrXPgiAIQvXQhTz+g3mlfzmYvar9zdfF1VwQBEEQhKaEM2yIgoICbN26FU888UTZc46Ojrjggguwfv36St+XlZWF1q1bo6SkBP369cPMmTPRvXt3i9vm5+erppORkaH+LywsVM3W0Ptki30T5PjYOnJ8bIjiAuT+8CaKsi0Jbh0H9Xrmn1/AY/K0xu2fYBG5hmwbOT62jRwf20aOj21TaCfHp6b9czAYDKY+flYkNjYWLVu2xLp16zBkyJCy5x977DGsXLkSGzdurPAeivHDhw+jV69eSE9PxxtvvIFVq1Zh7969iIyMrLD9888/jxdeeKHC8/Pnz1cWdUEQBOEcMJTAsyAZvnmn4ZN7Br5seWfgnXcWmSddEbs+oNqPyJvcH6eGX9Uo3RUEQRAEQagrOTk5uP7665UOZcizXVi66wLFubFAHzp0KLp27YpPPvkEL730UoXtaUVnzLixpTsqKgrjxo2rckdZc/Vk2bJlGDt2LFxcXKzdHcEMOT62jRyfBiY7CQ6J++CQsB8OifsB/p90AA4FypxdASfvmt1y2g0Zjh4TJ9ZzZ4W6INeQbSPHx7aR42PbyPGxbQrt5PjoXtPVYVOiOzg4GE5OToiPjzd5nn8zVrsm8KD07dsXR44csfi6m5ubapbeZ8sH1Nb719yR42PbyPE5R/KzgMSDQMJeIH4fkFDashMtb+/kCgR3BsK6AaFdgdDu6n8vz1A4D+6DohxDFS7mQMby7fAakwXngOqt4kLjINeQbSPHx7aR42PbyPGxbVxs/PjUtG82JbpdXV3Rv39/rFixApdeeql6jnHa/Hv69Ok1+ozi4mLs3r0bE8VKIgiCUDuKC4HkI5qgNhbXqScqeYMDENAGCNNENUK7aY8D2wFOFW9ChoICOPoFAzlJ/MtMeJdGOjkAWf+swrGLJiHi1VnwHjmyYX6rIAiCIAhCI2FTopvQ9fvmm2/GgAEDMGjQILzzzjvIzs5W2czJTTfdpOK+X331VfX3iy++iMGDB6NDhw5IS0vD66+/rkqG3XbbbVb+JYIgCDYKU3mknzYV1nycdAgoqSQhiHeYidVaWbFDugCuXjX8SgPinnseBWeT4ODmCkfHAhTnlr/u7OWAsFsmwDV2CWJWFKIgORWn77gTAddfh9BHH4Wjh0c9/XhBEARBEIRmLrqvueYaJCYm4tlnn0VcXBz69OmDJUuWlJUBO3XqlMporpOamqpKjHHbgIAAZSlnIjaWGxMEQWj25KQA8XtNxXXCfqAg0/L2rj6l4rqrqQXbK/icupHy1VdI//VXlqRA5IcfwmvQQJWl/Oj61Wg/ZAR8Jk+Fg4srkP4I2kZchcRlp5FyyBup879D9rr1iHj9NXj07HlOfRAEQRAEQbAGNie6CV3JK3Mn/++//0z+fvvtt1UTBEFo1hTkAIkHKrqGZ5nmyCjD0QUI7lRutdYt2P6tAIfK463rQtbqNUh47XX1OGzG4/AeNkw9ZlmwU07hKmmagx4T5dcSjrcvQZj/zfBeuwaxGwNQcOIETlx7HYLvvgvBd94JB2ebvHUJgiAIgiBYRGYugiAI9kRxEZBytKK4TjleHhdtjn9rC3HX7QFn1wbvbv7x44h5+GEm6IDfFZcj4MYbq3+Tuy9w/Q/w8n0Q7QK+QdxWf2Sc8kDS+3OQtWoVWs6eDdc2bRq874IgCIIgCPWBiG5BEARbjbvOiDEV1myJh4DifMvv8Qoxi7vursVdu3nDGhRnZuLM3fegJCMDHn37Ivy55+BQUys6E7Fd/D6cAlqjpdvL8G6Zh7jtwcjbuQvHLrscYY8/Dv9rrq755wmCIAiCIFgJEd2CIAjWJje1YlIzxl3np1ve3sXLQtx1d8A7BLaCobhYWbgLjh+Hc3g4It9/D46utbSsU1CPfBTwawW/3++BZ3AMYne2Rs6pXMQ9/zyy/vsPLV5+Cc7B5xZvLgiCIAiC0JCI6BYEQWgsCnNL613vK01utl97nHnW8vaOzkBQxwr1rpW7uFFCSVsk4a23kL1qNRzc3RH5wZxzE8a9rwF8I+CyYApaDTmOlKjWSNwMJbqPTb4YLV56ET4XXFCf3RcEQRAEQag3RHQLgiDUNyXFQMoxC3HXxwBDieX3+LUyFdd8TMHdCHHX9U36778j5fO56nHEzFfg0b37uX9o2xHAtKVw+PYqBDmchFdoMGJ3dkD+sVM4M/1eFS8e9sSTcPKuWQkzQRAEQRCExkJEtyAIwrnEXdNKXSHu+iBQlGf5PR6BpS7h3Uzjrpk8rAmQu3Mnzj7zrHoc9H93wnfixPr78NAuwG3LgflXw/3sDrSJzkJS78uQ/NsqpP/8C3I2bkLEa7Ph2a9f/X2nIAiCIAjCOSKiWxCEpklJMRxOrkHLlPVwOOkLtBsJODrV/fNy00rdwUvdwnWhnZdmeXsXT01Mq2zhRhZs79B6L8llKxTGJyirs6GgAN7nn4+Q++6r/y/xCQOmLgJ+mgbHQ0sQ6vY9vGfcg9ivNqDwzBmcvOFGBN1+O0LuuRsOtY0hFwRBEARBaABEdAuC0PTY9wew5HE4Z8RiAP8++ZGKCcaE2UC3i6t+b2EekHSoYtw1M4lbwsEJCOpQKqz11hUIaGvzcdf1SUleHs5Mn46ixES4deyAiNmz4dBQv9/VC7jmW3WMsfkzeB6fg7bTpyF+00Ck//Y7kj/5BFmrV6Hla6/BrUOHhumDIAiCIAhCDRHRLQhC0xPcP9xUsWZ1xlnt+au/1oQ3465TTxjFXZcK7OSjTL1t+bN9I03FtR537eKO5ozBYMDZZ59F3u7dcPLzQ+SHHzZ8bLWTMzDxDS2p3LJn4LRrLiJ6T4T3iNmIe+lV5O/bj+NXXInQhx9GwA1TGm4BQBAEQRAEoRpEdAuC0HSgkKb101xwK0qf+/VOYPWbpXHXuZY/x92/PO66TGR3Bdz9GrT79krK3LnI+ONPwMkJLd99F65RUY3zxXTTH3Yf4B8F/HIncHARfCPi4PH9XJyd+bbKnh4/c6ZWWuzVmXAJC2ucfgmCIAiCIBgholsQhKbDyXVARmzV2xTmAGd3aI+d3S3HXfuEN9m46/oma+VKJLzxpnoc9uQT8Boc3fid6H4Z4NMC+O46IHYbXH67GlEv/4S0FWMQP/s1ZK9bh2MXX4IWzz1bv4ndBEEQBEEQaoCIbkEQ7JuCbOD0JuDUemDvbzV7z+C7gQG3AoFtzy25WjMn/+hRxDz8iMri7n/11Qi4/nrrdabVYC2z+TdXAKnH4TB3HAKunQ/PX35B7OOPK9f3mIceRuY//yL82Wfg5Ns0ssULgiAIgmD7iOgWBMG+yE0FTm0ETq7VLNu0WpcU1e4zOk8EgiXB1rlQnJ6O03ffjZKsLHgM6I/wp5+Cg7W9A4Laa8L7u2uBM5uBeZfC7dKP0Gb+t0j66GMkffIJMv76CzlbtiBi1qvwGjzYuv0VBEEQBKFZIKJbEATbJitBE9d6i99TMWabCc7aDNOsnf+9CmQlVhLX7aBlMW89tLF63yQxFBUh5sGHUHjyFFwiIhD53nu2U57LKxi4+U/glzuA/X8AP98Kh/NPIuTeh+A9cgRiHn9c9fvULVMReMstCHnwATi6uVm714IgCIIgNGFEdAuCYFuknS4V2KWW7OTDFbdhiS4K59bDtP/9W5W/5hlcmr3cwUx4l1phJ8wSl/JzJOH1N1SctIOHByI//ADOgYGwKVw8gKu+UlnNsX4OsOJFIPUkPCa9hXa//qrivNMWLEDKl18ie+1aRLz+Gty7dLF2rwVBEARBaKKI6BYEwXoYDFqJLl1gs6WfMtvIQcskrkT2UKDVUMCniizULAfGsmDMYm6cVE3V6Z5VfZ1uoUrSfv4FKV99pR5HzJplu2KVJcLGv6KVFOO5sO0rVWvd8aov0eKF5+E9ZjTOPvU08g8fxvGrrkbo/fchcOpUODjJgowgCIIgCPWLiG5BEBqPkhKtHvbJ9eVCOzvBdBsHJyCib7klu1U04BFQu++hsO4yCUXHVmHH6r/RZ8R4OLcbKRbucyRn23bEPf+8ehw8fTp8x4+DzRN9B+AXCfw0DTiyHPjiQuD6H+EzejQ8/vwDZ595FlkrVqgM7Fn/rUSLWbPgGtnS2r0WBEEQBKEJIaJbEISGo7gQOLuzXGAzw3heuuk2Tm5A5MBySzYfu3mf+3c7OsHQejhi9magd+vhIrjPkcKzZ3HmvvtgKCyEz7hxCL77LtgNXSYCtywEvrsGiNsNfHY+MOVHOId1R+Sc95H+yy+If2WmSrB2/JJLEPbM0/C75BLrJ4YTBEEQBKFJIKJbEIT6ozAXiNlaHpPNUl6si22MqzcQFV1uyW7ZD3CWRFa2TEluLs7cMx3FSUlw69wZEa/OhAPdt+2JyP6lJcWu1PIEzJ2gwhAc2o+B/xVXwHPQIMQ+PgO527bh7IwnkMXSYi88D+eAWnpZCIIgCIIgmCGiWxCEupOfCZzeWB6PTcFdXGC6DV3DGYetW7LDewFOMvTYCwaDAWefegp5+/bBKSAAkR98AEcvL9glAW2AW5cCC27QFoW+vRKY/B7Qdwpco6LQet7XSP7scyS+/z4yly5FzvZtiJg5E94jRli754IgCIIg2DEy8xUEoebkpGgu4rolm67jhhLTbbzDywU2LdkhXbSkVoJdkvzJ/5CxaDHg7IzI9961/3hnz0Dgxl+B3+8Bdv8I/H43kHYKGD1DJVELvvMOeA0fhtjHHkfB0aM4ffsdCLj+OoQ++igcPTys3XtBEARBEOwQEd2CIFROxlnglFGN7IR9Fbdhdmi9dBdbYDtAYmGbBJn//IPEd99Vj8OfeQaeAweiScBwhsv+p5WaW/0msHKWJrwnvws4u8Kje3e0/fknJLz5FlLnzUPq/O+QvW69Ki3m0bOntXsvCIIgCIKdIaJbEITy8l1pJ01rZKccq7gdLdd66a7WQ7TM0EKTg6W0Yh95VJ0XAddfj4BrrkaTgt4X5z8L+EUBCx8Gds4HMs4AV88DPPzh6O6O8KeehPfoUTj7xJMoOHECJ669TiWQC77zTjg4y+1TEARBEISaIbMGQWjOIjvxoGlm8YwY020cHIHwnuWW7FZDAK9ga/VYaCSKUlNx+u57UJKTA8/oaIQ9MQNNlgFTtYWjH28Bjq/SEqxN+RHwj1Ivew8bhnZ//I64F19UbvZJ789B1qpVaDl7NlzbtLF27wVBEARBsANEdAtCc6GkWCuXpFuyKbJzkk23cXTRsonr8dhRgwB3P2v1WLACLAkW88CDKDx9Gi6RkWj5zttwcHFBk6bjWGDqYmD+1UDifq2k2PU/ABF91MtO/v6IePNNeI85T4nvvJ27cOyyyxE2Ywb8r76qyZYWKy4xYOPxFGxNckDQ8RQM6RAKJ8em+VsFQRAEoSER0S0ITZWiAiB2e7klm1nG8zNMt3H2AKIGlluyWw4AXD2t1WPBBoifNRs5GzfC0dMTkR9+0HxKZrXopZUU+/YqLXfBFxOBq74EOo1TL1NY+02+CJ79+yH2iSfVPop77jlk/fsvWrz8EpyDm5YHyJI9Z/HCn/twNj2Pyw74+vAWtPBzx3OTu2FCjxbW7p4gCIIg2BUiugWhqVCQA5zZXG7JPrMFKMo13cbNF2g1uNyS3aKPShwlCCR1wQ9I/fZb9ZhJw9w7dUKzgm7m05YAP9wEHPsP+O5aYNIbwIBpZZu4RESg1RdzkfLV10h86y1k/fcfjk2+WAlvn/PPR1MR3Hd9sw0Gs+fj0vPU8x/d0E+EtyAIgiDUAhHdgmCv5KUDpzaWW7JjtwElRabbeAZryc50S3ZYD8DRyVo9FmyYnC1bEPfSS+pxyAP3NxkBWWsYTnH9j8BfDwA7vgX+ehBIPQmc/1xZ6TsHR0cETb0FXsOGIvbRx5B/8CDO3DMdfldegbAZT8DJ28uuXcpp4TYX3ITP0bmcr4/tFi6u5oIgCIJQQ0R0C4K9kJ1UXrqLQpvx2eZTY9+WRuW7hgHBHaV8l1AthTExOHPf/UBREXwnXoigO+9Es4beH5d8oJXD+28msPYdIP00cMmHgIt72Wb0BGjz4w9Ieu89JH8+F+k//YycjZsQMXs2PPv1hT2y6XhKqUu5ZTji8HVuN6R9UKP2TRAEQRDsFRHdgmCrpJ8xEtnrgKSDFbcJbF8usPk/6w6LyBZqATOUn75nOopTUuDWrStavPJKk00MViu4D0Y/rl1Tf0wH9vwMZMQC184HPAPLNnN0dUXoI4/Aa+RIxM6YoRLQnbzhBgTdfjtC7rkbDq72Fb6RkFm54DYmLt0sdEUQBEEQhEoR0S0ItlK+izWxdVdx/p92quJ2od1LRXZp8wm3Rm+FJoKhpASxM55A/oEDcAoKQtQHH8DRw8Pa3bIt+lwH+EYAC27UMv5/PhaY8hMQ2NZkM69Bg9Du998R/8pMpP/2G5I/+QTZq1er2Hi39u1hL4T6lFvyq+Lp3/dg9eEkXNAtDCM7hcDbTaYTgiAIglAZcpcUBGtQUqKVJtIFNv/PijfdxsEJaNG73JLNBGhGFjZBOFeSPvoImUuXAi4uiHz/fbi0kORYFmk3Crj1b+CbK4HkI8BnF2glxSL7m2zm5OODiFmvwnvMGMQ9+yzy9u3D8cuvQOjDDyPghikqFtzWcXZyUHHblmK6jZ0AsvOL8cv2GNVcnRwxuH0QxnYNxfldwxDhLws3giAIgmCMiG5BaAyKi4C4nabu4nlppts4uWolu3QrNmtku/lYq8dCEydj6VIkvT9HPW7x/HN2G4PcaIR21UqKsZZ33C7gy0nAFZ8BXS+qsKnv+HHw6NsHZ596Wlm742fOVFnOW7w6Ey5hYbBVNhxLxq1fbi4T3ObiWw86mHNdXwR7u2H5/ngs2xePE8k5WHUoUbVnft+L7hG+uKBrGMZ2C1OPJVxBEARBaO6I6BaEhqAwT8smXlYjexNQkGW6jYuXJqzLamT3N0nSJAgNRd6BA4h9fIZ6HHDTjfC/4gprd8k+8G0BTF0M/DQVOLwUWHADMOFVYPBdFTZ1CQ1F1P8+Qer8+Uh4/Q1kr1uHYxdfohY4fC+8ELbGykOJuOPrLcgvKsHwDsG4akAkZi0+YJJULdysTnd0uyA8ObErjiZmKwG+fF88tp5Kxd7YDNXeXXFY1fY+v2uoEuFMvObmLNUTBEEQhOaHiG5BqA8oqE9tL7dis0Z2cb7pNu7+pvHY4b0AJxdr9VhophSlpODM3ffAkJsLr6FDEPbYY9bukn3h5g1c+x2w6BFg6xfAkhlaSbHxr1Qox0cLb+CUKfAaMgSxjz2OvD17EPPgQ8j851+EP/M0nHx9YQv8vTcO987fjoLiEpzfJRQfTOkHdxcnXNQrAuuPJGDp6o0YNyIaQzqEVigTxt/YIdRbtf8b1R5JWfn490CCEuGrDiUp0f7NhlOqebk6YVTnECXAx3QORYCXfSWZEwRBEIS6IqJbEOpCTgpwagMcj6/GyINL4LzjJGAoNt3GKxRoM6zckh3StazOryBYA0NBAWLuux+FsbFwad0KLd96Cw7OchuoNU7OwEVvAwFtgOXPARs/0kqKXf4p4OpZYXO3du3Q5rv5KoY+6eNPkPHnn6ouesSrr8JrcDSsye87YvDQDztVfe5JPVvg7Wv6wNVZG6cosKPbBiJ5v0H9X5O63HQ7v2pAlGp5hcVYfzQZS/fFY8X+eCRk5mPR7jjV+FED2gRibNcwlYytbbD91jYXBEEQhOqQ2ZYg1ITMONN47IS96mnatQL0bVhayLhGdmA7Kd8l2BRxM2cqsefo5YWoDz+Ek7+/tbtkv/DaHv4A4B8F/Pp/wIG/gK8mA9d9D3iHVNzcxQUh990H75EjEfPY4yg8dQqnpk5F4C23IOSB++Ho5tboP+GHzafx+C+7VPGEy/u2xGtX9oKzU/0tDNJaPqZLqGolJT2wOya9LA78QFymqvXN9sqi/Wgf4qXEN0V431YBNRL4giAIgmAviOgWBHM4A2W5LuPM4ilHK24X3AnFUYOxI8UTvSb/H1yCTUsICYItkfrdd0j7foESixFvvmFXZaxsmh5XAD4tgO+uA2K2AJ9fAEz5GQjuYHFzjz590O7XXxA/+zWk/fADUr74Atlr1qjSYu5dujRat79adwLP/aEtHl4f3QovX9IDjg0odPnZvaP8VXt4XGecTslR1u/l+xNUAjfGhR9deQyfrDyGQC9XnNdFiwMf0TEYXlKOTBAEQbBz5E4mCBTZSYeNamSvAzLOmG3kAIT3KLdktxqqrFklhYU4s2gRevlFWqnzglA92Rs2Iu6Vmepx6MMPwWf0aGt3qWnBMYGZzb+5Akg9oQlvxn23HmJxc3oatHjxBXiPHo2zzzyD/MOHceKqq5XFm5ZvB6eGTTb28cqjKkkauXV4Wzw9qWujZxiPCvTELcPaqpaRV4iVBxOVFZzx4CnZBfhp6xnV6Oo+jOXIuoWrhGxhvpJsUhAEQbA/RHQLzY+SYiB+r6klOyfJdBtHZyCib7mreFQ04CGuuIL9UXD6NGIeeAAoKoLv5MkIvPVWa3epaRLcEbhtBfDdNUDMVuDrS4DLPtIs4ZXgc94YePT+HWefeRZZ//yjspxn/fsfImbPgkvLlvXeRYPBgHeWH1ZZxcm953XAQ2M7Wb2kl6+7Cyb3jlCtsLgEm0+kYPm+BCzbH4fTKbn492CiavgV6B3ppyzgdEXvEu5j9b4LgiAIQk0Q0S00fYoKgLM7ywX2qQ1AfrrpNs7uQOTAUkv2EO2xqyT2Eeyb4qxslam8OC0N7j16oMVLL4pIaUgYy33zX8Avt2sx3j9NA9JOA8PurzS/g3NQECI/mIP0n39G3MxXVcz9sUsuRdjTT8Hvkkvq7XhRcL+6+AD+t+qY+vuxCZ1x92jLLvDWxMXJEUPbB6v2zEVdcTghS8WAs+04nYadZ9JVe3PZIbT091C1wCnCB7UNLEsAJwiCIAi2hohuoelRkKPFVuqWbJbvKswx3cbVB2g1uNySHdEHcG78REaC0FAYSkoQ+/jjynXZKSRYCTtHd3HNbXCYvfzqr4G/n9KymjO7edpJ4MLXtaznFqCw9r/ySngOGqTqp+du346zM55AFkuLvfA8nAPK0jXWiZISg4rfnrfhpPqbtbanDrP9HBTcL53CfFS7Z0wHJGTm4Z/9Wjmy1YeTEJOWiy/XnVDNx81ZlSOjCB/dKRR+nlKOURAEQbAdRHQL9k9eBnB6Y7klO2YbUFJouo1HYLnA5v9hPSqdAAtCUyBpzhxkrVgBB1dXRM2ZA5ewMGt3qfnAet0XzgICWgNLngC2zAXSY4Ar52p1vivBtVUrtJ73NZI/+wyJcz5A5tKlSoC3mPkKvEeMqFNXWArs8Z93qfhoGs1fvawnrh3UCvZIqI+76jtbbkEx1hxJwnKWIzsQj6SsAvy166xqzo4OyvKt3NC7hqFVUMUyboIgCILQmIjqEOyP7GTglF6+ay0Qt5tmPdNtmE3YuHxXcCepkS00GzIWL0bShx+px+EvvgCP3r2t3aXmyeC7ACZZ/Pk24PDfwJcTget/AHzCK30L66YH/9//wWv4CMQ+9hgKjh3D6dvvQMD11yP00Ufg6OFR469nfPSDC3YoIcoSXG9e1RuX9q3/WHFr4OHqpKzabLTk7ziTpgQ43dDpkr7uaLJqL/61D53DfHBBNy0beu9I/wbN0i4IZZQUw+HkGrRMWQ+Hk75Au5HagpwgCM0SEd2C7ZMRa5r0LFHLumtCQFsjkT0UCGgjNbKFZknevn2IfeJJ9Thw2jT4X3qptbvUvOk6GbhlITD/Gi23xGcsKfYjENq1yrd59OiOtr/8jIQ33kTqN98gdf58ZK9fj4jXXoNHzx7Vfm1eYTGmz9+uXLFdnBzw/nV9MaFHCzRFKKL7tQpQ7bEJXXAiKVv9brbNJ1JxMD5TtQ/+PYpgbzdc0FUT4MM6BCvxLgj1zr4/gCWPwzkjFgP498mPAN8IYMJsoNvF1u6dIAhWQES3YHvlu1KPl5fuotBmCR5zQrqWC2w23swEoZlTlJSE0/dMhyEvD14jRqjyYIINEDkAuG0Z8O1VQPIR4PPxwDXzgHajqnwbY/DDn35KKy325JMoOH4cJ667DsF334XgO+5QVnFL0PX6jnlbVNyzm7MjPr6hP8Z0CUVzoU2wF24b0U61tJwC/HcwEcv2x6uyZElZ+fh+82nV3F0cMbwD48BDcV6XMIT4SF4PoZ4E9w83cUJj+nzGWe155nwQ4S0IzQ4R3YJ1KSkBkg6a1sjOPGu6jYMjEN7LqEb2EMAryFo9FgSbpKSgAGfuvQ9FZ8/CtW1btHzzjQav9yzUgsB2wK3LgO+vB06t12p6XzIH6H1ttW/1Hj4M7f74HWeffwGZS5Yg6b33kb1yFSJemw3X1q1Nts3KL8K0Lzdj0/EUeLo64bObBmBoh2A0V/w9XZVLPVtBUQk2Hk9WbujL9yeoRGy6RdzBYTf6RPkrCzhd1juGekumf6FuJUmXPF5RcCv4nAOwZAbQZZK4mgtCM0NEt9C4FBcBcbtKS3et1/7PTTHdxskVaNm/3IodOQhw97VWjwXB5mE5qLgXXlBJtxx9fBD54Qdw8pVrxubwDARu/A347S5g7y/Ar3cCaaeAkY9WGw7j5O+Plm+/hYzzz0Pciy8hd+dOHLvscoTNeBz+V12lBGJ6TiFu+mITdp5OU9m8v5w2EP1bBzbaz7N1WFJsRMcQ1Z6/2ID9ZzPLRPeuM+nYfipNtdf/PojWQZ5lidgGtgmAs5PkBBEskJsKxO8DEkrbyfVaSFylGICMGGDPz0Cvqxuxo4IgWBsR3ULDUpSvZRPXLdnMMl6QZbqNiycQNajckk3B7VLzZEGC0NxJnfcN0n/+RSULbPnWW3Bra/vloJotLu7AFZ8D/lHA2neBf18BUk8Ck98BnKouc0Vh7Td5Mjz790fsjCeQs2kT4p59TpUWc3/iGdz821HsO5sBf08XzJsWjZ6Rfo32s+wN7stuEb6q3Xd+R8Sl56ks6LSCrz2ajJPJOfh8zXHV/DxcMKZzCC7oFoZRnULg4y7lyJodhblA4sFyca0LbXPPvJryy+3APy8BbUcB7UYDbUcC3s0nBEQQmiMiuoX6pSAbOL2p3FX8zGagON90Gzc/oPWQ8sziLXpXO9kUBMEy2evWIX72bPU49NFH4T1iuLW7JFQHKymMfRHwbw0segTY8Q2QcUaL9XSvXii7RESg1ZdfIOXLr5D49tvI+u8/nN2wFT69r0Rwx3745rZB6BIung61IdzPHVOiW6uWnV+E1YcTsWxfAv45EI/UnEL8tiNWNSalG9wuSFnAz+8aisgAKUfW5NzDU44DCXtNLdgpxypWSdHxiwJCu2nJER2dgdVvVP89DJujl8v2eVoj/AyKbwrxNsNqNBYIgmA/iOgWzt216pRRjeyzO4CSItNtvEJMa2TzxiKxTIJwzhScPIkzDz4EFBfD79JLEXjLzdbuklAbBt6qTdh/vAU49h8w90Its7lf9WW9HBwdETRtKrJ69sOh+x5CZGosnt/4BRyDU9DBe0ijdL+p4uXmrDK9s7HO+bZTqVo5sv3xOJaYrRLUsT33x150beGLscyG3i0MPVv6SRy4PSVtpZXa2GrNRmt2UZ7l93gEAKHdgbBSgc3HoV1MxTFF+875WtI0i3HdDlri17vWA2c2adf98ZVa6VO9Dxs/BhycgIi+WrJFivCoaM1LRhAEu0VEt1A7shKMMouvA+L3VLyx+EZqq7S60A7qIOW7BKGeKc7Kwum770FJerqqwx3+wvMy4bdHOo0Dpi4C5l+tWdc+O1+r5d2iV7VvZWms65cnIXH4fbjnxHKM37MCJQt/x/Fd2xAxezY8+/VtlJ/QlGF984FtAlV7YmJXHE3MwgrGge9LwJaTKdh/NkO19/45gjBfliMLUwJ8SLsguLvI4rJNkJsGJOyv6Bqel2Z5e2cPTUwr63WpwA7rDniHVT+XoUGBZcFU9nIHs/lR6XsnzAI8/ICOY7VGspOBE6uAYys1EU7LeswWra1+E3B214S3EuGjgYg+YrwQBDtDRHdzg6uwFMtZ8doNhMK4qoGb7k9MDKJbspMPV9yGotrYku3fqkF/giA0dwzFxYh9+BEUHD0K57AwtHz/PTi6Sbkju4UT6NuWayXFEg8AX1wIXP0V0OGCSt9yOD4TUz7biITMfLQL98O1T78On4O7EDtjBgpPn8bJG25A0O23I+Seu+Hg6tqoP6cp0z7EW7U7RrZHSnYB/j2QoBKxrTyUiPiMfHy78ZRqzBw/sqMWB35el1AEeskxaJQcMhXirvdroRuVuXhz/qKLa2XB7gYEtDk3QctyYAwVYRZz46Rqqk73LMvlwliRpftlWiNppzXxrYtwztn4Pxte1ML02gwvFeEjgZAuYtwQBBtHRHdzqx1p8SYwW7sJ0N2KNWSNy3elnzb7EAcgrEd5ZnGW7/IJa+xfIgjNmsR33kXWypVwcHND5Jw5cAmVBDx2Dxcrp/0NLLgBOLEa+PZq4KK3gf4VQwb2xKTjprmblOjrEu6DebdGazWmBw1Cu99/R/zLLyP99z+Q/MknyF69GhGvvwa39u2t8rOaMhTSV/SPVC2vsBgbjiVjmSpHFq8E+JK9cao5OgD9WweUWcEp2oVzNB6knqjoGp58lCuSlt/j29JUWLMFd2o4l23OqbpMQtGxVdix+m/0GTEezu1G1lzMM9Fi3xu0xrlZ0qFyAX58NZCfDhxcqDVCI4oeD04hLsYPQbA5RHQ3J8Gt3J3MXMEpwH+4EYgcqN3EshNNX9fjinRLdqtoLa5JEASrkP7nX0j+9FP1uMUrr8CjZw9rd0moLzz8gRt+Af64F9j1PfDnfUDaSeC8Z8qsWIwvvmXuJmTkFaFXpB++njZI1aLWcfLxUa7l3mPGIO6555G3bx+OX34FQh95BAFTrlex4EL9Q1fy0Z1DVXv50h7YE5OhYsAZC86M8ptPpKr26uIDaBfspcQ3RTjFOF3YBQtQbNLCay6uEw4ARbmW38P46gpx1121a6uxcXSCofVwxOzNQO/Ww+tuPee1H9JZa9F3aIsOzJ+ji/BTG7T9tPtHrZGAtuXx4BTjXsH1+tMEQag9IrqbAxygaeG2mNSjFGYZJ05umgAvq5E9EHCTVXlBsAVyd+/B2aefVo/pOux30SRrd0mob5xdgcs+BgJaAytna/GcDPO55ANsOJWFW7/cjOyCYgxoHYC5UwfCt5LyVb4TJsCjbz+cffJJZK9di/hXXlFZzlvMfAUuYeKd1JAwtwLLtbE9NLYTYtJyVRw4reC0hh9Lysb/Vh1TLcDTBed1CcPYbqGqfjiTuDVL8jJM4675OH4vkJtieXvGOFOElsVdl1qxfVo0fTdrineWVmUb8RBQmFealK1UhLNMa+pxYCvbl9p7wnqWi3BWj3HzsfavEIRmRzMd3ZsZdBM3dimvDLqZD5gKOEtsqCDYGoUJCTgzfToM+fnwHj0aIQ/cb+0uCQ0FRcOYJzUX0T/vV9artPiTuDf2DmQXeWJYhyB8etMAeLpWfQt3CQtF1GefInX+fCS89roS38cuvgQtnn8Ovhde2Gg/p7nT0t8DNw1po1pmXiFWHUpSLuj/HEhQ5ch+3nZGNVcnRwztoJUjY2MZsyZHUYHmKm0ed51+qvK468B25VZr3T2cz0kiMQ26yCvX8pEAntEWMDjv02PCVfmz3VpbP0cra0bBrrui07gi8z5BaHBEdDcH6HZUE+h+JAOvINgcJfn5OHPvvSiKj4dr+/aIeON1ODjJhLPJw3hO35Yo+m4K/BM24TvHM/hf+9l48eaBNc6MTatr4JQp8BoyBLGPPoa8vXsR8+BDyPz3X4Q//TScfKWed2Pi4+6CSb1aqFZUXIItJ8vLkZ1MzsF/BxNVe/q3PaoEmRYHHopuLXztqzpBSYkWGmGeMZx5Y8zLiurQSm2cLZyPac128Wjs3ts37r5A5wla06vOHF9VLsJ5XE5v1Nqq17Rs7bR+6yI8vJcsaAhCAyCiuznABBv1uZ0gCI2GwWDQYnN37oKjnx+iPvwATt4S8tFc+COrMz7KfRafO89GB8dYzE57CA4JLTVLVS1wa9cObb7/DokffojkT/6HjD/+RM7mLYiYNQte0YMarP9C5Tg7OWJwuyDVnprUFUcSssriwLefTsPumHTV3l5+CBF+7mVx4Nze1dmGYvMp6izFXRdmW96embeVsDZyDeffnoGN3fPmgXco0PNKrRHm7ylLyrZKy+Vz9B+tEXd/oO2IUhE+Wsq+CkI9IaK7OcDYbGYpr9TF3EF7ndsJgmBTpHz5FdJ/+w1wckLkO2/DtXVra3dJaCR+2HIaj/+8CwZDFD7t+j88m/k8HOL3AF9eBFzxOdBlYq0+z8HFBaH33w/vkSMR+/gMFJ46hVO33ILAW25R4QpSds560IrdMcxHtbtHd0BiZr4qR0YRvvpwImLT8/D1+pOqebs5Y1SnEIztFoZh7RoxsWl+llncdanQzkmyvL2Tq+W4a2YSFxFnPVgSrT/bzVqyOh5Him8K8RNrtPrl+//UGvGJ0FzX9Zhwv5bW/gWCYJeI6G4O0E2I8drMUl6B0hsfa0eKO5Eg2BRZq1cj4fXX1eOwGTOUi7DQPPh6/Qk8+/te9fi6Qa3wzKU94FA4GPjxFuDIcmDBFODC14BBt9f6sz379kW7X39B/KzZSPvxR6R88YWK92ZpMffOnRvg1wi1hSXgrh4YpRrLka09osWBL9+foAT5wt1nVWPm87bejoj3P4nxPVqgdZDXuX95cSGQdLiiazjdki3iAAS2rVjvOrA94CTTTJuGix905WcbfBdQXATEbgeO/6eJcLqgZ8Zq1RTYCC3fuit6mxHioSAINURGw+ZCl0mAqzcMeVnISXRFUZ4TnN2L4dk+GA4TS+t0C4JgM+QfO46Yhx5WsZH+V12JgBumWLtLQiPxycqjqrQUmTasLZ65qKsWz8uMw9d9Dyx8GNj2FbDoEc1VdOxLQC1LgTl6eaHFSy/Ce8xonH36GeQfOoQTV16lLN60fDNngKG4GDmbN8Nnxw7khITANzpacglYAcbvn981TLVXSgzYFZOuXNApwg/EZeJIhiNmLj6oWsdQ7zI39D5R/lWXI2PcdfrpiuKagruksPIwNCWsS0tx6XHXrvUg9gXrw0WSqIFaG/koUJirlSTT48FZqoxx+WxbPtcWXFr0KhfhrYbIuSAIlSCiu7kQsw0ZR4sQvz0cRTnlkzPnfWEI6+UO325W7Z0gCEYUZ2TgzN13oyQzEx79+iH8mWfsK4mSUOf4/XdXHMY7yw+rv+89r4MqOWVy7J1cgMnvaiXFVryoZSOmcLrskzolnPI57zx4/NlbCe+sf/9FwutvIOu/lfCdNBFJH3+Corg4tAAQ+933SAgPR9iTT8B33Lj6/NlCLXB0dFBimu2R8Z1xND4dc35diTjHEGw6kYrDCVmqffTfUQR7u+K8LqFKgA9v6QDP1INmcdf7gYIsy1/k6mMh7rob4BXU2D9ZsCYcU9qP0RrJTQNOri2PCU88AJzdqbV17wGOLkDUoNJs6syMPkAbswRBENHdXMj44VPErGXsl+nEvSghATH3PwC8+45MpATBBqB1MebhR1Bw4gScW7RA5HvvwsHV1drdEhpBcM9afACfrDqm/n50fGfcM6aD5Y0pwkc8DPi1An6/G9j3O5BxFrjuO60KRS1xDgpC5IcfIO2nnxD/6ixl3WYzh9nz5X5hW7QK9MToFgZMnDgAOYXA6n0nsH/XFmSc3IE2eSfRaedpdNl9Gp4O6ZY/gCJJxV13NXUP94uSuGuhIh7+muckG8mMK48HpwjnAiBFOdt/rwIuXlq+ID0ePKxHrb1yBKGpIKK7mUzi479bW8mLBnVjjZ/5KnzOP19cBwXByiS8+RayV6+Gg7s7oj6YA+fg2osowb4oKTHg+T/3qiRZ5NmLumHa8LbVv7HXVYBvC+D764Ezm4DPxwJTfgKC2te6D7SmB1x1FTz798exSy4FCi24F8v9wnZg7G3yETic3Y0usX/A6cfv4Jd4ABelnsBF4HGqOMM7WRKKQ4YoHDBEIS+gMyI790e/vgPRKSJAPGmEuuETDvS6WmscH1KOlbuiU4znpgBHlmmNeAZpceC6CGe9dTn3hGaCiO5mQM7KJSjKKqlg5S7DYFAuhDlbtkrpGEGwImm//YaUuXPV44hZr8K9m8R9NHWKSwwqQ/lPW8+ouefMy3qqxGk1ps1w4NZlwLdXahPezy7Q4r5bRdepP0WJSZYFt47cLxoXCpn0Mxbirg8BxQVqEqdS38UbvccrxMRqbQjthkOGllh2mCXJErDzdBqQCCCxCFizHlGBHsoFfWzXMAxsGwgXJ7FECnWAAxgX/NgGTNNyBrDagl6a7MRaICcZ2Peb1gg9Kii+9ezoFPGC0EQR0d0MKNrzX422i581SyVs8h45Cq6RUhJCEBqT3B07EPfMs+px8N13wXfCBGt3SWhgCotL8OCCHfhrl5aF+o2reuGyvpG1/yC6B9+2Aph/tZZ5+KvJwOX/A7pfWuuPKkqkGquejIUL4d6tK5x8fGrfX8EyOSkW6l3vB/IzLG/v4oWSkC44le+NqH7j4NSipya0vUNMNnMoFeado4Dp53VEQkYeVrAc2b54rDmShNMpufhi7QnVfNydMaZzqErGxrJkfh4SjyvUEbqRM8ka29B7taz4MVvLXdFPb9Lc0Xd8ozUS3LncCs4FRbqzC0ITQUR3M8A5a3+Ntsvfvx/xL76EeLwE1w7tlfhmPVfP/v1UfVdBEBqGwvh4nL73XhgKC+F9wfkInj7d2l0SGpj8omJMn79dCR8XJwe8d21fXNiTKcvqiHcocMtC4KdbgUOLtdJi6S8BQ6bXyn3TOcRUsFVG2g8/qPrx3qNGwnfSJHiPHg1Hd/e69785UZADJJklNePjrDjL2zs6A8GdLMRdt0JxcTF2LlqEloMmwqmG9+lQX3flTcGWU1CE1YeTVDb0fw4kIDm7AH/sjFXN2dEB0e0ClRWcLSrQs373g9C8YEK1VoO1NvpxoCAbOLW+XISf3aVdF2yb/gc4ULT3KRfhfF8dkkUKgq0gorupU5gLz6ItcPbwRVFuJfF3Dg5wCgpCwI03qFjS3O07UHDkKFLY5s6Fo7c3vIYOVZMrrxEj4BIa2ti/QhCaLCV5eThzz3QUJybBrVMntJw9Gw6SaKZJk1tQjDvmbVFix9XZEZ/c0B9jutTDuMpSPdd+CyyZoU1alz4NpJ4ELpwNONYs/tpzQH84h4erpGnKtdkCvCc4hYai8NgxZC5brpqjp6daMPK76CJVT14WakvjrunyXyas92qWaz7HuGtL+LcCQkvLcelluYI6As6VJFMsLj6nLnq6OmN893DVGOqw43Qqlu1LUOXIjiRkYe2RZNVe+HMfuoT7YGxpObKeLf1UJnVBOKfxqsMFWtM9PU6sLo8HTz4MxG7T2pq3ASc3LTO6LsIj+kkdeMGukLO1qXNiDRxKchE8IABxqy28XmoBCX/2GZWNNuTOO1Gcno7stWuRtXIVslavRnFKCjKXLlWNMM7Ua9RI+IwaBfeePSWZjiCcQ8ZqlmrK27MHTv7+KoM06ycLTZes/CJM+3IzNh1PgYeLEz67eQCGdajHZHkU1xe+Bvi31kT35k+1mOArP69R/VyO5ywLprKU8/5gLLxL7xctZr4Cn7FjkX/woHIzz1i4CIWxscj440/VeC77TBgPv0mT4NG/f9NfROI+yoitGHedeBAozrf8HiaUMql33V0LE3D3hbVgiEP/1oGqzbiwC44nZWPF/njljbH5RIqqCc72/j9HEOrjpuqGj+0WiqHtg1UtcUE4JzwDgW6XaI2kx2jiW0/MlhmriXI2vKyVtWszrLxGOK8nScom2DAiuu2AEgOw8XgKknOKEOrjjkFtA9XNsUYcWqL+K3JrB+CYKj1kKCgoe9k5LKxC3VUnPz/4TpyomqGkRAkCJcBXrULe7t3I27dPteSPPoZTQAC8RgzXXNGHD1OTLUEQakbyZ58h46+/AGdntHz3XbhG1iGeV7Ab0nMKcfMXm7DjdBp83JzxxdSBGNAmsP6/iBPPodMB/yjglzs0d/MvJwHXLQB8wqp9u7ofvPuOylLOpGmV3S/cu3RRLeShh5SHlBLgixerhdq07xeoRqu5up9MmqgWbO0+S3Zuqmat1q3WutDOq6Qkl4snENLFtN41hTaTndn4vmgb7IXbRrRTLTW7AP8dSsDyfQn472ACEjLz8d2mU6px8WhEx2AVB8664MHebtbuutAU8GsJ9LlOa1zYSj4CHPuvNDHbaiAvTZvjls5z1TWl1wenCA9oY+1fIAgmiOi2cf7eG48XtjkhbcOWsuda+LnjucndMKFHNfF/HKQOLYWhGEjdqiXHaTHrVTgHBatkOYzdoythVZZqWig8evVSLeTe6ShKSkLW6jXIWrUS2WvWojg1tcy6waQZHn36qDhwuqK7deli/xMsQWggMv/7D4lvva0ehz/1pGSCbuIkZ+Xjxs83Yd/ZDPh7uuDraYPQK7KBFylpMfJpAXx3rZZgjZnNb/hJs6hWA4U1y4JlbNyIrcuWof/YsfCNjrZ4v+A479mvr2phT8xA9oaNSoBnLlumRDvDlNhc27SB70UXKQHu1rYGJdGsSWGe5bhrWtss4eAEBHcst1or9/BugH+bJlGXOMDLVSX5Y2M+gg3HUlQcON3Qz6bnYem+eNV4y+/XKkDLht4tFO1DvGUeIJw7PId4fbENuh0oKQbidpXHg59cD2QnAnt+1hqht4/uik4xzrwXgmBFHAz0b2zGZGRkwM/PD+np6fD1tZ5blyWW7DmLu77ZBoOK/Sq/aemPPrqhX9XCmxOEj4YgI8YXMau94RQSjI7//FNvsXZM+sSMy7SAZ/23EvmHD5u87hwaqsWBjxwJryFD4eTd9NxmCwsLsWjRIkycOBEuEsNoc9jq8ck/ehQnrr4GJdnZ8L/2GrR4/nk0R2z1+NQ3zBY95bONOJyQhWBvV3xzWzS6hDfi/Sb5aHlJMXc/4Nr5WmbgBj5GJfn56v6Q8ddCZP33Hwz55a7WtHozAZvvxAvh0uIcEsidK5y8pxw3yhZeKq5TjgIGltq0AMsc6UnNdPdwJjpzdmt21xCnkHtjM5T4ZtsTY5ppvU2QZ6kAD0P/1gFwbmblyKx9fJoNRfnAmS3lrugxW4CSItNteL3qVvDWw1Qohxwf26bQTo5PTbWkWLptFCY0YeISbUXEdJVYl+B8fWy38MpdzQ//rf5LPcXVvRwEXHV1vSa34Wd5DhyoWujDD6uYvqxVq5G1ciWyN2xAUUIC0n78STVw2wH9NTf0UaPg2raNrH4LzZLitDScvvtuJbh57YQ/+aS1uyQ0IGdSc5TgPpmcg3Bfd3x7e7Sy/jUqrJt763LN4n1mE/D1pcClHwK9rm7Qr3V0c4MvLeRjx6I4KwtZK1YgfeFCZK9dVxamlPD66/AcMAC+F02Cz/jxcA4IaJjO0L6QGQcklLqFG8ddF+Vafo9HgKnVWj3uoi1cCArex3u09FPtgQs6ITYtV5UjoxV8/dFknEjOwWdrjqtGD4/zSsuRjewUAm83mYIK9QQXvBjfzTbmSSA/U7N+6yI8fnf5otrGjzTPlJb94Nh6BIIzXYGi89Q8VRAaEhnxbBQm2aHLVmVQePN1bjekfZDljQ79jfx0Z+SczAGcnOB/9VUN12GGrkVEIODaa1SjhSNn8xYlwNkKT51CzvoNqiXMng2XqCjNDX30KCU8pNSM0BwwFBUh5qGHUHjyFFxatkTLd99ReRaEpsmJpGxc/+kGxKbnISrQA/NvG2y9skteQcDNfwC/3gns+x345XYg7SQw4pFGiS128vaG3yWXqFbE5Jx//60EeO6WrcjZskW1uJdfgdfQISoBm/f5F9TdO4rx1ZbirhmPbQlnD83lviypWakF2zvM5uOubY0Ifw/cOLi1akwauPpQIpbt18qRpeUU4pftMaq5OjlicPsgjO0aqhKy8X2CUG+4+QCdxmmNZCeVJmUrTcxGr58zm+F0ZjOG8d785jtaSTLdEs5SZTWs+CAINUVEt42SkJl3btux9MLpjUg9ollUfM4bA5fwcDQWtHAwsRobnnoSBSdOlArwVcjZvBmFp08j9dtvVXNwd4fX4MHKFZ1CnGJEEJoi8a+9hux16+Hg6akylTsHNkASLcEmOByfqSzcTDjVLthLWbhb+FlZWLDG7ZVfAsufBda9D/zzMpB2Cpj0llZDt5HgeR9w3XWqqaznixcrAZ6/bz+yV61WzYH3kDFjVPw37wu8p1h0KU06VGq1NrJgZ5yx/MWs+xvUwSzuuruWcEkm2PUOLdmsPc9WVFyCbafSlAs6s6EzM/qqQ4mqPfP7XnSP8C1zQ+dj8YQT6hWvYKDH5VojHPeOr0LJ0X9RcGAZ3IvStSRtbCso2v20EBw9JpyLcnJOCueIiG4bhVnKz2m7IytQUmBA+glNdHNyY02YQCeQ7eablVst3c/1jOhMtMN4Pza1bYf2ygWdruhMzCP1XoWmQNpPPyH163nqccTsWXDvXH0yK8E+2ROTjpvmbkJKdoGqbTzv1miE+NhIRmcm9Rr3spZkaPFjwLavtdI8V31plXJV9JAKuvVW1fKPHS8tQbZQLdRmLlmimqOPD3xGRsN3QFt4hRXAIfmAJq6ZzZiZQi3h27I0W7hRvevgzoCLeFVZA8Zys/IK25MTu6oa4CoOfF88tp5KVXHhbO+uOKySxZ7fNVSJcHryuTnLgohQz/i3AvregOIe1+Bv54WYOKgDXE6v1VzRT6wB8tOBgwu1RrzDtWRsughnZQhBqCUium0U3ph444lLzyuN6zaF623hflr5MIsc/hvpJz1QUqgJXs/Bg2ErsA4xs+KyMQlL/qFDmgBfuRK527ej4MhRpLB9PheO3t7wGjZMc0UfOUJlXBcEeyNn2zacfeFF9Tj43ukqxlVommw/lYqb525CRl4RekX64aupg1TmZ5uDGYD9IoGfpgFHVwBfTASm/AD4RlitS25t2yDklqsQfGFX5G1ehYx/1iNjewyKMjORvnA50hcCTm7F8G2VC9/WufAIKoaDh5/luGvGYws2S4dQb9X+b1R7ldmf7ucU4asOJanQuW82nFLNy9UJozqHKAE+pnOobV5Lgn1DCzYt2RE9gOg7geIi4OxO4DjLk60CTm0AsuKA3T9ojQS2K3dFbzNSC98RhGoQ0W2jMDkay4Ixe3l56jRT+LrFJGrFRTAcWobUI1o8XMB116rSX7YIXcho8WMLvuN2FKenI3vtWs0VfdVqVZKMsX9sxL17d80NfdQouPfoUWW5M0GwBeg+e+be+5iGUyWKCr7rLmt3SWggNhxLxq1fbkZ2QTEGtA7A3KkD4etuw546nS8EblkIzL9GSzTEkmLX/wCE92j472aiI0tx1znJ6m5HR3wPGqsjgNxEV6Sf8kbmGQ8U5zkh9bC3ai4twrUSZMMmw71zp4bvs9AgBHm74aoBUarlFRarBGzLSq3gDM9YtDtONU53WNd+bNcwlYyNdcQFod5xcgYi+2ttxMNa+UAmoNTLk8Vs02LC2bZ+ob0nrGe5Fbz1UMCtkZNlCnaBTYruDz74AK+//jri4uLQu3dvvP/++xg0qPoatt9//z2uu+46XHLJJfjtt99g77Ac2PvX9sbTv+xAWoHpoty71/SpvFzYmU3IjclGflqIipf2u/RS2AtOfn7wnThRNUNJCfL27FHlyOiGzsd5e/eqlvThR3AKCIDXiOGaK/qwYXDyb+Cat4JQS0pyc3F6+nQUJyeruvURr8602QUw4dxYeSgRd87bgrzCEgxtH4TPbh4AT1ebvMWa0rIfcNty4NurtLrUcycAV38FdDhfldNyOLkGLVPWw+GkL9BuZO1jn4sKgOTDFetdp5+qPO6aVqTSuGuH0K7wDOsOz4C2CC8xIHvdOhX/nbV8BQrPxiH5089Uc+vYQStBNmkSXKPE9dNecXdxwpguoaq9fEkP7IlNV+J72f4E7D+boZLHsr2yaD/ah3gp8U0R3rdVQOWVXAThXGBICl3L2fCMlqjx5LpyEa7GtN1aWz8HcHQGWg4oF+GRAwFn8dCoLYbiYpUDymfHDuSEhMA3OtruDW02NyNYsGABHnroIXz88ceIjo7GO++8g/Hjx+PgwYMIDa28sP2JEyfwyCOPYMSIEWhKjO8ehsITxQjpNhiJWYV4aeE+pGQXoriq8uqH/kbqYW0FmEloKGTtEYoTj169VAu5714UJSVpJclWrUL2mjXKCp7xx5+qMU7Ro08fTYCPGgm3zp0lEYtgVRg6Efvkkyo5lFNgIKI+mANHTytlrhYalKV74zB9/nYUFJdgTOcQfHRDfyUe7IaA1sCtfwPf3wCcXAPMvxrodwtwaBGcM2IxgNuc/EhzPZ8wG+h2ccXPKCnRsqErq7VRUjMKbvN6uTo+LSrWuw7poiV8swCr/Ghj/Ci1oMU8IKoE2cpVyD98BInvvKuae69e8GMJsgkT4FLFvEGwbRwdHdAr0l+1h8Z1VuX3VuxPUInY6FVyNDEbR1cewycrjyHQyxXnddHiwEd0DIaXlCMTGgqWDKSXEBvJStDc0JmEjSKcSdpOb9DaytmAiyfQaki5CA/vpeXWEColY+lSxM98VeV8onkx9rvvkRAejrAnn4DvuNKM9HaIg4EzQxuCQnvgwIGYM2eO+rukpARRUVG49957MWPGDIvvKS4uxsiRIzFt2jSsXr0aaWlpNbZ017Sgua0Uhn9/xWG8uewQ+rcOwM93DbX4nqLXB+HIFxkwlDigzU8/waNHdzQ1DIWFyNm+HdmrtFhwTriMcQ4L0+LAR42E15AhKo68MY6PYFtY8/gkffyxEgCs/dn6yy/g2b9/o36/PdAUrp8/d8bigQU7UFxiwIU9wvHutX3h6mynEypmA/99enncYgVKFzIvngP4R5q6hyceAAqyLL/NzdcsqVnpY8/6yd5fnJGBzGXLkbHwL2Rv2KgtABBHR3gOGqQWnzlRs9cF6KZ+DdWFjLxCrDyYqOLA/z2QoHIo6PD6G8ZyZN3CVUK2MF/rJc9rrsfHXmiQ45N6otwKTjGenWj6OvNNMDO6igkfrVVUECORieCOuf8BWi5gQuk+YqlVWxPeNdWSNrUUWFBQgK1bt+KJJ54oe87R0REXXHAB1q9fX+n7XnzxRWUFv/XWW5XobspcMyhKZffcepLZPtPRPcJsEpF6EmmbY2Ao8YV7j25NUnATZjT3GjRItdBHHkFhTAyyVq9WCdmYGb0oPh5pP/6oGrf1HDgAXkqEj1KJ5cQKLjQkmStWaIKbCQ+ffUYEdxPlxy2n8fjPu1BiAC7r2xKvX9lLZWm2W5zdgEs/Ag4uqkRAl06C/rjH8vudXLUM4SqhWWlZLj5mJvEGHHOdfH3hf8XlqhUlJiJjyd8qA3ou3RI3bFAt7sWX4D1ihBLgPmPGiNeJncNcCZN7R6hWWFyCzSdSsHxfApbtj8PplFz8ezBRNfwK9I70UxZwuqKzmoDc/4UGhSUI+7PdrAlHup/rIvzEWiA3Fdj/p9YIx0flvl6amM2KySxtwaU8fuarFQW3etGg7iN8nYmY7dHV3KZEd1JSkrJah4WFmTzPvw8cOGDxPWvWrMHnn3+OHTt21Og78vPzVTNendBXu9hsDb1P+v8B7k4Y1y0Ui/bE4+t1J/DyJd1MtnfYtxBpR7XJhO+119nkb2oQQkPhfcUVqpXk5yN3yxbkqHqvq1B05oyqjcyWMGs2XKKi4DliBDxHjoDHgAGW67/W8fgItoU1jg+z8cc8+ph67Hf99fC+9FI5P5rg9fPtxlN4/i/tvnTNgEi8OLkrDCXFKCyppISVncAYbufKLNZGGLzDYYjoB0NoVxhCusJA6zVjsRnPaE5RJe7lDYG/P3yuvUa1wjNnVMmxrEWLUXD4MLL++Uc1Bw8PeI0eDZ9JE+E5dKhdl6W052uoPhnYyk+1GeM74EhCNlYcSMCKg4nYcTodO89ojV6CLf3dlRv6+V1CMLB1QIN7pcjxsW0a5fgEdtLagNtVqI1D7HY4nFiltTOb4ZARA+z8TmscW4M6oKTNSBjYWg9rVpUYctavVy7llWIwqNczNm6E58CBsBVqev7YlHt5bGwsWrZsiXXr1mHIkCFlzz/22GNYuXIlNm7caLJ9ZmYmevXqhQ8//BAXXqjFVtxyyy1Vupc///zzeOGFFyo8P3/+fHjaycr3kXTg/X3OcHU04MX+xfAwmuP0+3cmspZkwODmjCPPPAeDHU8m6gWDAS5JSfA6cABeBw7C8/hxOBSXT4pLXFyQ06E9srt0QXbnLigKkGRsQt1xzM5GqzkfwDUlBTnt2+PMrdMAO1yNFapmRYwD/jilHddRLUpwWeuSJuMdyKRpAxi/XQ1bWt+FmMDy+7St4xoXD5+dO+CzY6e6PnWKPTyQ2bMnMvv0Rm7bthJr2cTIKAD2pjpgT6oDDqY7oLCk/EJ1dzKgq78BPQIM6BZggKdNmaGE5oBTST4Csw4jOGsfQjL3wT/nOByMCgUb4IB0j9ZI9OmORJ+uSPHujGLHuhuKbI6SErjGx8PzyBF4Hjmq/neswSLt2euuRWafPrAVcnJycP3111frXm5Topvu5RS+P/30Ey41yrh98803KyH9+++/m2xP63bfvn3hZDSpZQy47pbO5Gvt27ev1tLNmHFa2W01pnvZsmUYO3ZsWbwJD9nE99fhSGI2np3UBTcObqVtXJCNs5P7IzvWFf5XTUbws69Yt/M2SEl2NnI2bETO6tXIXr0axQkJJq+7dmgPzxEj4TViBNz79K7WAmLp+Ai2Q2MeH+YZiP2//0Pups1wjoxE1HfzJaN+Ndjb9cOxd86/x/Dev0fV33eNaosHz+/QpNxVlaX7m+orXhTd8BsMrYfD3uAxzN+9G5mLFyNryd8oTkoqe82JHlPjx8Nn4oVw697dLo6rvV1D1iS3oBjrjiYrC/g/BxKRnF1eFsbZ0QED2wTgvC4hOK9zCFoF1o8RRo6PbWNzxyc3DQ6n1ikruCMt4UmHTF42OLrAEDlAs4KzRfQDnGyg37Wg8PQZ5GzcgNyNm5C7aSOKU1Jr/RkRcz+3KUs3tWRwcLB9xXS7urqif//+WLFiRZnopojm39OnT6+wfZcuXbB7926T555++mllAX/33XeVmDbHzc1NNXN4sdnEBVcJ5v27aWgbPPv7XszffAZTh7dTk4OCdX8hO1bbJujWu23691gNf3+4TRiPgAnjtcnXwYMqDpwZ0XO3b0fBkaOqpX3xBRx9fOA1bJiWkG3EcDiHhFT6sbZ+/jR3GuP4xL06Swluxoq2+uhDuFVxvgj2d/1wvJi1+AA+WXVM/f3o+M64Z0wHNDlYFowxhRlny2O4TXBQrzvXpXyYjeDavz98+veH4YknVEma9L/+QubSZWoRNn3ePNVcWrdSpSv9LroIbmaL97aIPVxD1ob7Z0KvlqqVlBiw40yaKkfGZGyH4rOw/liKaq8sOojOYT64oJuWDb13pL/KpH6u3y3Hx3axmePjEgL0uERrhOMwk7ExHvzYSjhknIHDqfUA26rZgKu3VhdcjwdnHg0b89Zhng0muMzesF4ZvZiDyRiG+3gOGACvwYPhOWggzky/F0U0iFmyCTs4qETJtlY+rKbnjk2JbsJyYbRsDxgwQNXmZsmw7OxsTJ06Vb1+0003KRf0V199Fe7u7ujRo4fJ+/1LLUvmzzc1mLSHE8AjCVnYcCwFQ9oHIe27b9WEyKtziEoWJlQNFyrcu3RRLfjOO1CcloastWu1jOirVquSZIwHZCPuPXpoAnz0KPVY6i0LOqnfL0Dq/PnqhhDxxhtw69jR2l0S6hFO0J//cy++Xn9S/f3MRd1w6/C2aJJQSLMs2A83lWYrN574lAqPCbPsVnAbw0kbJ3psJc8+q0pRZvy1EJn//IPCk6eQ/NHHqrl16aISsPkxw3HLltbutlAPUET3axWg2mMTuuBkcjaW709QInzTiRQcjM9U7YN/jyLY2w0XdNUE+LAOwfBwtf9zX7ATfFsAva/RGkVoyrHS0mQU4quA3BTg8FKtEc8g06RsAW0bPTN6cWamWszMXs8klusrVBeCszM8evfWxt4hg1VZYAfX8jrmYU89qWUvZ7+NhXfp72DZMFsS3LXB5kT3Nddcg8TERDz77LOIi4tDnz59sGTJkrLkaqdOnVKu480dH3cXXNq3JeZvPIVvNpxEdEsvpG04oV4LuLJ610ChInQF9ps0STVmUMzbs0eVI6MlPG/vXvU3W9KHH6q6y7R+uw8fDsecHGt3XbAivLnEvfyyehzywAPwOW+Mtbsk1CMsBTbj5134cesZdc9/5dKeuD66NKSnqcI63Fd/DSx5HMiILX9e1emeZblOt53j6OoKn/POU41hSJn//KsyoGetWYP8AweQyPbmW/Do2xe+F02C74QJcA4Ksna3hXqidZCXWkhjS88pxH+HtHrgLEuWlJWP7zefVs3dxRHDO4RgbLdQnNclDCE+blWOHRuPp2BrkgOCjqdgSIdQOJ2jxVxoxvAGFNReawNv1Uojxu8ps4Lj5DogJxnY+6vWiF9UuQDn/z6miarrA5W8mCV8129Q1uy8PXtZy9mk325du8Br8BB4DY5W1VyqKuOryoG9+05ZnW4dWrilTredY291uo3ZF5uBie+tVrFIK9seRsabH8PZswQd1m6Fg4e31frcFKF7DK3fdEPPXrsWJVnl2X0NDg7w6NsHPqPHqLrgbp062UUsYHOgoWukFpyJwYmrrlJeEXRFjXjzDTn2TaiGLUsRPfTDTlWLm3PlN6/ujcv6RqLZUFKMomOrsGP13+gzYrxdu5TXFXpAsW4sLeBcYCuzvJRayX0nTYLP2Avg5ONjlf7Z+jVk7xQUlWDj8eRSN/QExKTllr3Gob5PlL+ygI/tFoaOod5l4/+SPWfxwp/7cDY9r2z7Fn7ueG5yN0zo0cIqv0Vo4tdPUQEQs7VchJ/ZDJSYZdUO6VIuwlVm9NrnnTEUFSlDlBLZjM3eth0Go1xZxLV1a3gOoRfREHhGD4JzQO0zsNP4xSzlW5ctQ/+xY23OpbwuWlJEtx2LbnLlR+uw5WQq/tz0CpxjUxEyJhzBH/1rlb42F5gwK2fbdmStohV8pYoBN8Y5PFxzQx81Uk3KqlrRE+z3hkpr2Inrp6i8AO7du6P1N/Pg6OFRr9/R1LHlCU9+UTGmz9+urF1c2Hzvur6Y2LP5TZZt+Rg1NoXx8chYvBgZCxchzyifDF0jvUeNUgKc4UeO7u6N1yc5Po0Gp8v7z2aqGHC2XWfSTV5vHeSpBDhriL+z/FCFjAj6cuxHN/QT4W0jNOnrpyAbOLleE+FsZ3eZhgs5OAIRfctFeFQ04OJh8bwvOHKk1JK9QS0+lmRmmmzDnEe6yKbLuEuLFs3q+GTUUEvanHu5UDtuHNIaKTv3KMENRwP8r7zC2l1q8jCjuVf0INUCH3gAS7/5BtEuLshds1YNSHSHSfvhB9W4LTMsKgE+ciTcWJJGsHsMJSWInfGEEtxOwcGI/GCOCO4mluX4zm+2YtWhRFXH9+Mb+ilXUqF54xIWhqBbblGt4ORJpC9cqAR4wdGjyFy2TDUusvpccIFyQeeiqz3XABdMoRW7W4Svaved3xFx6XlYcSBeWcHXHk3GyeQcfL7meKXvN5QKb1rAx3YLF1dzoWFx9QI6XqA1kpMCnFitWcEpwpOPaJZxtjVvAU5uQNQgJcALPXsg+3gWsjduUtbs4sTyKg/E0ddXzYE9o7W4bNd2WkJnoWpEdNs5E3qEI+HMavXYNzIPzgMvt3aXmh1FgYEqwU7wDTegJC9PrQKqjOgrV6Lw9Glkr1unGl6dpTLieo8cpSzhzNLoaCGTvmD7JH34kZpgc0Id+f57cAkPt3aXhHoiK78It365WcVierg44bObB6jkSYJg7j4ZcvfdCL7rLrX4xvhvivCi2LNI//131ZwCAuAzYbzKgM5YcEm+2bQI93PHlOjWqmXnF2H14STM33QSqw6ZChRz4U2X8/4vLUOAl6saYzxdnVRyNv7v6eqsHnup55xLn3Mq3c4Znm5O8Cx9XP4e7f2uTo4ifITK8QwEul2iNZIeU+aKXrRvJXKOpSJ7wy5kxx9EYZapPHRwc4Vn/wFl1mz3bl1t1tXblhHRbec45+Zg6Mkd6nFeF38t0Y1gNehW6D1ihGqGp55EwfETZW7oOVu2qoy4qfPmqcYyCbSE0ApOEe4SIcfOHsj4eymS5sxRj8Offx6efftau0tCPcEESrd8uQnbT6XB280ZX0wdiIFtAq3dLcFOqmCEPPggcnfsUPHfGUuWoDglBWnffa+ac4sW8J14oUrU6da1q4ijJoaXm7MygjAspSrRrZOWW6hafcIwGBPxXiroPd2cS4V6ubjXBb2xuFevGYt79bcm7unxIzQdirOykbP9MHLWn0L2hnjkH+R4ZHSvczDAI7AQnmH58ArLh0dwARx9cwCGZhe6ARk+QEBra/4Eu0REt52T/tvvcCwsgptfIf70GYTJiVloFyJJ1GwBTqrc2rVVje6IapDbsL4sIzrrEGb9+69qhGWmGA9IAe7Rp4+4JdogeQcOIHbGDPU48Oab4X+FeJY0FZKz8nHj55uw72wG/D1d8PW0QegVWfskM0LzhZZsz379VGOWXcZA0gKeuXw5is6eRcrnc1VzbdtWuZ9TgEt5z6ZFqE/N4vlnXtYDHUJ9kFNQpMJZctgKi5GTX6Qe5/JxQenjgmJkq//L/1bbl/5dVKLF6fL/zLwi1QDTxFb1Kei9jKzsSrCXiXszsV/6uibsS8W8sVXfRRP3Lk4i6BuakoICtSCYs2GDGpdymZOiiOdJOW6dO2u1slWG8X5wyjpW7orO2PDsBGDPT1ojAW20eHC9RJl3iHV+nB0hotuOYXKD1O/mq8f+HbLxb0k/ZGw8pWrICraHk7cW68fGY8cyNMoNfdUqNRjmHz6sWvKnn8HRxwdew4dprugjhsM5WNxbrU1RcjJO3303DLm58Bo2DKGPPmLtLgn1REJGHqZ8thGHE7IQ7O2Kb26LRpdw20usKdgPDs7OauxmK8l/Xi22Mv6bi6wFx48j6f05qjEJIxOw0QouYSr2z6C2gSpLOeO9LWUpdih1S79mYKt6i+lmhnUlxAtNRXm2kaDXBbsu6OkObyz2jQV9ttHjxhD0Lk4O5e7zpaLcy0TYm1rvvdxMxb6xoDd20efj5iroVdnb/QeUoUfVy966FYa88kz6xCUqqqxWtmd0dMUSiL59tURrwx8AivK1bOi6CGcceOoJrW37Sts+tHt5abLWQwF3uYeaI6LbjsnZuAkFx47D0bkEnp3csTO3HY5tOY1HxnVWA45g4y6JXbuqFvx/d6IoNRXZa9cpV/TsVatVmZrMxUtUI+49e5ZlRHfv0UNiAxsZQ0EBztx/v4rXZCxny7feVJNqwf5hCaApn27AieQchPu649vbo9FevIWEeoS5O1hblq04K0tZvinAmeuDpXfYEl5/HZ4DBmglyMaPq1OJHcH6UEizLNhd32xTAttYeOsSm6/XZxI1un6z+aEBymIaCfrsfF3QF5UK9XJBn20m7i0KfyPrPRvrmJPCYgMKi4uQoQQ9GkTQ0/3f2MKuP2bd9cRYR+z++xC83V1MrPdl4r4spt40rt7ZhgS9yjB+/Diy16/XrNmbNqMk3TS7PpO+ekVHayJ78BC4Rras+Rc4uwFthmsNTwH5meWZ0SnE43cDCXu1tuFDwMEJaNm/XIQzQZuz5DCSWaMdk/r99+p/3za5cOs1EZGHvXA6JVfVlL16YJS1uyfUAk6w/OhueNEkbYVy925lAc/6byXy9u1Tf7MlffABnAIDtbhxZkQfNgxOfn7W7n6ThjezuJdeRu6WrXD09kbkRx/KPm8inEjKVhZuCu/IAA98d/tgRAV6WrtbQhPGydsb/pdeqlpRSoqK/aYAz926VSXhZIt7+WV4DRuqErD5nHeelJ20M1gOjGXBzOt0h9thne6GEvRKJBaXCvoywW4qypXrvRLqpuLeeDtzV3ttgaC2gt4Ra+JP1Po3MHGdJWt8efI7U+u76XZVuN7XUNAXxsVpVmxaszdsRFF8vOmv8vZW1XM0kT1YhTDWWy4JNx+g0zitkewk4PiqchGeehw4s0lrq14HnD2AVoPLRXiL3oBj1cbB4qIiHNiwGAUnN+DABgd0GzIRTnZu7LDv3jdjCuMT1Go5CeiQDYdOEzAlsDVmLT6AbzaeFNFtxzAjJGO62ULuuw+FCQnIXr1GuSdmr12rkvPo2XHBbfv20dzQR42CW6d6HFQFRer8+Uj78Ue6JygLt1u7dtbuklAPHI7PVII7ITMf7YK9lIW7hZ+UfRMaD+fAQARef71qhbGxqgY4M6Dn79uP7JWrVHNgcs4xo1X8N8tOOrq6WrvbQg2gsGZZsPVHErB09UaMGxGNIR1CpUyYcc4bZyfV/Ot5nbOioDdyrTcT9Bk5Bdi97yBatm6LvGKDBeFvZr03EvT8joLcEqTXc0I8XdDrFnVdlAeW5KLz2UPocPoAok7shX/yWZP3lDi7ILdzdxT06g/0GwjXbl1R5OGGIldnFFHQ5xepz2mQc9ArGOhxudZI2qlyV3SK8ax44Ni/WiPufkCbEeU1woM7qTmWzva/v0LE+hfQE8noySdWfIj4FUGIHfIc+o6/GfaKiG47Je2nH1USBI/gfLgz4WD7Mbi6jQfeWnYIu86kY+fpNPSOkiRATQGX0FCVsIuNbs4523doydhWrUTBkaPKAsuW+NZbKkOu7oZONyKxkJwbrLseP/NV9Tj0kYfVvhXsn72x6SppWkp2ATqH+agY7hAfcX0TrAerVwTdeqtq+ceOaRnQFy5U9cD1UCPm+vAZN1YJcMZgSske24biJrptIJL3G9T/IrhtT9AXFhZiUdZ+TLywM1xqkLxW5eMpc7k3jZW3JO71100S4RlZ700t9kUo1fNK0Dtk5KJ98nH0STyM3olH0D49Fo5GAQvFcMDhgEjsCOmInSEdsS+wDQqcXIBcAGuzgLWbLf4Gei5obval8fN0vTdyn7dotTey3tPt3tySry8MlJ3j/q2AfjdqzWAAEg+UivBVwIk1QF46cOAvrRGfFmUJ2facTkTvrc+VHszyfocYkhGy7j5sB+xWeIvotkMMRUVI++FH9TigY05pwgI/lez/op4t8Mv2GMzbcFJEdxPEwdUVXtGDVAt77FEUnInR4sBpFdm4UWXITVuwQDVmP6drkZ4RXbLk1o6C06cRc/8DQHExfC+ejMBp06zdJaEe2H4qFTfP3aTcDXu29FNZylkvVxBsBXrThNx3L4LvnY68vfuU+M5YtEi5j6b//ItqjM/0nTABXhPGa5NaQRAaJx+PC2PBnVT1rPrOMJ6xfScy161H7sYNKN5TMcN4XsvWSOvSG4kde+Jsm67IcPZAQUEx2hQUIdRcyJeKez05nj5MME6fLQ31b6F30wW9cSK8spj6QfB0GQLvro+hTeFRdMzeitbpmxGevgNOmWeBXQtU61GaC8HcaZN6nosSLda/gOLzp9ilq7n99VhA5r//qpuvk6cTfCJzgY7jy167YUhrJboZ1/30pK7w95TJZFOGiTB098SSvDzkbNqkZURfuRKFZ86oRD1stNYyAZiXqgk+Cp6DBoqbYhWwvNuZu+9GcXo63Hv1QouXXhK3/SbAxmPJmPblZmV16N86QNXh9nWX0nyCbcIxx6NHd9VYLSFnyxYV/53JGuBJSUj95hvV2gQGIvnIEfhPvhjunTtZu9uCINQAQ0kJ8g8eVHHZ2RvWI2fLVhhycip4wHgOGQyvwUPgGT1IeT7W6btKLfRlrvUFlVvb9SR5KnFeaUZ8yzH3pdb7wuIyQc/vYEvNqU7QuwMYppobCtDP8TCGOe7BeMfN6OgYW0FwGwvvcCRj78a/0X3YJNgbIrrtkLTvvlP/+7fJ1PIQdJpQ9lrfKH90a+Gras3+tPUMbhsh8afNBUfG/tG1fORIGJ5+SmWy1AU4y0XQTbHg63lI/XoeHDw84DVkSJkruksL+0ns0hg3wtjHHkP+4SNwDglB5Pvvq+zDgn2z6lAi7pi3BXmFJRjaPgif3jRArb4Lgj3AihVegwapFv70U2oxNf0vrQa4a0oKUj/7XDW3jh3gO+ki+E6aCNcoye0iCLYChW/hyZMq6RlD13I2bkRxaqrJNk4BAapONkU2E6CxrFd9LPgbW+gD69mzy1jQq1J0Ze7zxiXrTEvRaZb4Utd7Je5bYEXBMCSmtMMLRW9X+525qTGwR2TGYWfkHzuO7HXrld9FQPtMILA9ENzB5MK6cUhrPPHLbnyz4SSmDWsLR4kjap4xTe3aqRY09RZVpoalJFQytpWrUJSYiKx//lGNuHXqpMQ3k7ExgVtzLoeV+N57ar/QlT/ygzlwCavbyrJgOyzbF497vt2m4uTGdA7BRzf0V5MPQbBHGDrEsZotPyMDa955Fx3j4pCzerVaLEx85x3V3Hv3UvHfPhMm1NlCJghC3WEiXFXCi9bsjRtU2VFjHD094TFwQJnI5lzM3krC1qeg37s2DVhW/XYeAbUod2ZDNN+ZtZ2StkArE+bdJQguXjFAp3LXcp1L+kRg5sL9qu7smiNJGNkpxAo9FWytTI3v2LGqqVXJAwe0ZGwrVyF3507kHzqkWvKnn8HR11eVq1GTuhEj4BwUhOYC4yaTP/5EPW7x8kvw6NXL2l0SzhGG2jywYIfKODuhezjeu66vSiQjCE0BRw8PZPXuhRZPzIBjbi4yly1TMeC0puXt3KVa/KzZyjVVCfCxY6XkoSA0EMUZGSrMT3MZ34CCo0dNN2CunT59Sl3GB8OjZ0+1iCZodIkej/hlQSppmiV7IWO6ExyC1Hb2iIhuO6IkNxdpv/6mHgdEldbjsyC6mcDgiv6R+HLdCZVQTUS3UGFVsmtX1YL/7/9QlJqK7DVrVV3w7NWrUZyWVpYtlx4V7j17lrmhu3fvbnersDUld+9exD75lHocdNut8Lv4Ymt3SThHftxyGo//vEvdqC/r2xKvX9mrRvVPBcEecfL1hf8VV6hGb6aMxawBvlAtrOawnu/6DYh74UVVesxv0kR4jxmjRLsgCHWDuXRyt20rE9l5e/cCJSXlG3AO1a1baa3sIfDs30+uuSpgcjSWBWOWct63jYW3ntn97JDnEG6n3pj22evmRkkJcjZvRs6SJSjJyIBzeDC8AnYBrj5Aq6EW33LD4FZKdK/YH4/YtFxE+MtFLljGOSAAfpMvUs1QXIzcXbs0Ab5yFfL27UPerl2qJc2ZA6egIGX9ViXJhg1Tk7ymQFFSEs7cMx2GvDyVbC7kwQet3SXhHJm3/gSe+X2venzdoCi8cmlPCbURmg3MRxF4042qFZw5oxKwZfz1F/IPH0bWihWqOXh6wue88+B70SR4Dx2qQmoEQai6elDu7t1lLuO527fDUGiaNMy1bdtSkT1Y5WBw8pdKQrWh7/ibVVkw1ukOQ3LZ87RwU3Dba7kwIqLbxslavhxtZ81GbHp62XMlaenIPOMO33FjAGfLN8kOoT4Y0i4I648l47tNp/DwuM6N2GvBXmHdV8++fVXD/fejMD4B2WtWI+u/lSpxT3FyMtJ/+001lG6rMqKPGgW3jh3tMsM3y3Scufc+FMXFwbVdO7R84w2pf2vn/G/VUcxcdEA9njqsDZ69qJtdnpuCUB+4RkYi+M47VMs7dEgT4AsXqgoXFOJsdDn3GT8evqwBPnBAk/VoEoTaoMLxDh1Gzob1SmTTAFaSnW2yjXNYmHIVVy7jQ4bAJSzMav1tKvQdf7MqC7Z7/SIc2L4eXfoOQbchE+3Wwq1j371v4mQsXYq4hx6Gs1kNzpK8QsSsDQAGtUZVdkYmVNNE92nce15HiWMUag2TiOnuioaCAuRs267Fgq9apWKVWMKGLfHNt+DcokWpG/ooeA2OVglC7OGGGvf8C2q1mrHsTJzm5ONj7W4J53A831txBG8vP6T+vmdMezwyrrMIbkEoxb1TJ9VCHrhfeTAxA3rG4sWqBFnaDz+o5hwaCt+JE5UAd+/RXa4foVlBzxAmnmU4RjYzjCeXW1sJF6g8o6PLrNmubdrINdJAruZdBl+IYykG9b891uU2x/5/QROFbr6srczid5VdyvHzV8PntuJKrXJju4Uh1McNCZn5+HtvHCb3jmjQPgtNG7oeUkyzhT3+mLox6QI8Z8NGFJ09i7QFC1RjYhDPQYNKM+yOVDXCbZHUefOQ/ssvgKMjWr71FtzatrV2l4RzENyzlhzAJyuPqb8fGdcJ08/raO1uCYLt1gDv3Vu1sBmPq+RP6QsXInPpMhQlJCDlyy9Vc2ndSiVgowB3a9/e2t0WhHrHKTMTmYsWIY9hnBs2Kg8QY1hi1bN//zKRzXw44gki1AUR3TZKzpatyt21chxQFJ+gtvOKHmRxCxcnR1w3qBXeXXFYlQ8T0S3Ut8ti4JQpqjGZCGtO6nXBC2NikL12rWrxM2eqlWAVBz5yJDwHDoSjDcQOZq1Zq7L6Ei4ieA8fZu0uCXWkpMSAF/7ci6/Wn1R/P3NRN9w6XBZQBKEmcOGebrFsJc8+qxJq0v08859/UXjyFJI+/Eg1t65dVQI2WsFdImQ+IdgnLKGas2kzsukyvm492h85gtLUxBrOzqpyCV3GKbS5MCX5DoT6QES3jcLMo/WxHUX3nH+PYOPxFByKz0SnMHGdFeofR3f3srqxBsPTKDh2TBPgtIJv2YKCEyeQwvbV1yp5Dyd3ekZ0l/DwRu8v+xPz0EMqSaHf5Zcj4KabGr0PQv3AUmBP/LILP2w5w0SxePnSHpgSbZueFYJg63BB1Of881Vj7CqFN2O+s9auRf7+/Uhge+NNePTrpxKw+U6YAOfAQGt3WxAqpSQ/H7nbdyiRTZfx3D17gOJik21cu3SBt1p4Gqys2o5eXlbrr9B0EdFtw5lH62O7cD93jO0ahiV745S1+8VLetRTDwWhcrdFuiGyBU2bqlaVmYRNz4jOhSI9ey5x69xZE+CjR2kryg0ct1OcmYnTd9+jKgF49OmD8Oefk3gsO6WwuAQP/7ATf+yMVaVF3riqNy7vF2ntbglCk4DCQ69swdKSdD2nBZzJpFgmiS3+lZlqEZXu5z5jL4CTt7e1uy00cxieydJdKvHZxg3I2boNhvx8k20YNuE1eAjcBw7Emox0TLjqKrhIvWyhgRHRbaN4DugP5/BwFMXHq7juCjg4qIyJ3K46mFCNovuXbTF4bEIXeLvJYRcaD07CfMeNU01lAt2/XwlwZkRn/dj8gwdVS/70U5XMjG7eKhnbiBH1bkHhzTj2kUeVJZ7XV+T779mEq7tQe/KLinHv/O1Yui8ezo4OePfavpjUq4W1uyUITba0ZMA1V6tWGB+PjEWLlQDP27MH2WvWqBb33HPwHj1aCXB6MdEDShAaGs4rmNhVr5XN/AQlmZkm2ziFBCuRrbuM6+ERhYWFKFm0yEo9F5obor5sOMYq7MknEHP/A6DktmSH4+s1KW00tH0Q2oV44VhiNn7bHoMbBovrpWAdaFF279ZNteD/+z9lPeFkja7ojCMsTk/XJnOLFquFJfeePdXkzXvkKLh373bOyUsS33lHxZw7uLkhcs6cGnuUCLZFbkEx7vxmK1YdSlRVGT6a0g/nd5UyLYLQGLAkUtDUW1RjqE76ItYAX6gWMzOXLlWNVnKfCy6A70UXKZHT0B5MQvOiMDa2XGRv2FAh1NLRxwee0YM0oT1ksCoHKh5tgrWRUdCGoWWw+K03cfr55+GSnlH2vHOQH8Kee1G9XhM40NwQ3Rov/rUP89afQPsQL5XRPNTHHYPaBsKJfpmCYCXrid/kyarRCp27cxeyVmkZ0fP37VclbdiS3p8Dp+BgeI8YoSVkGzoUTr6+1Vq16Qbps2MHckJCYEhMRPKnn6nXWsx8BR49ujfSrxTqk6z8Itz65WaVp8LDxQmf3jQAwzsGW7tbgtAsYZLMkLvvRvBddyH/wAFl/aYIL4o9i/Tff1fNKTAQvhO0GuAefftK5meh1nCBnuI6e8NGFZvNBH/GcCHds38/eJaKbC7s18QoJQiNiYhuG8cnMg8dLkqAITYLRXlOcHYvhmc7Axwi82r1OVf0j8Sri/fjYHwWrvt0Y9nzLfzc8dzkbpjQQ9wyBevCG6Rnv76qhT7wAArjE5C9mtnQV6mYcNaRTf/1V9Wgtu2nWcFHjYJrhw4mq9iscc+Se6wAwDM79rvvy14LuvNOVQJHsD/ScwtxyxebsP1UmgqT+WLqQAxsI0mcBMEmvJi6dlUt5KGHkLtjh0rAlrHkbxSnpCB1/neqOUe0gF9pDXC3Ll3E+ihYhEn8mIRVt2ZzQccEJyd49OgBzyGDlTXbo28fOLq5Wau7glAjRHTbMvv+gNPPU+EBAxyMPSez44AfbgKu/hrodnGNPmr90SQUFleMDY9Lz8Nd32zDRzf0E+Et2BQuYaHwv/JK1QwFBcjZtq2sJBndGGnFZmMmXU7ktGzoo1CSlY3Yxx6znAsBgHu3ro3+W4RzJyW7ADd+vhF7YzPg5+GCr6cNQu8of2t3SxAEM2jJ5qIoW9iTTyrhpEqQLVumLODJn32uGl1+fSdNVIugtJgLzRfe45njRRfZubt2AUVFJtu4depUViubpUclaZ9gb4jotlVKioElj3MoshDPXRrlvWQG0GUS4OhUbUmdF/7cZ/E1PV6cr4/tFi6u5oJNwhqZKgHK4MGqpnbB6dNaMraVK5GzcZOayKV9v0C16oh/dZaKNRTXM/shISMPUz7biMMJWQj2dsW8W6PRtUXV4QWCIFgfxnJ7jxiuWsnzz6mFUwrwrP/+U4unDB1ic+/RQ1m/fSdeqGLGhWaQYXz/AZVdXGUZ37oVhtxck21cIiPLRLZXdDScgyWMSLBvRHTbKifXARmxFhOoaRiAjBhtu7YjqvyoTcdTcDa9cnd0Cm++/t6Kwyo2MtTHTcV7e7iKKBFsE9eoKAROmaJaSW6uylZKAZ7x91IUJydX+V66nOds2Qqv6EGN1l+h7sSk5WLKpxtwIjkHYb5u+Pa2wegQKhYOQbA3mM3cd/w41VhKMnP5cpWALXv9epUFnS3htdeUFVOVIBs3VuX9EJpIhvHjJ8pqZWczw3h6usk2TkFBSlwrl/EhQ+AaKeUfhaaFiG5bJSu+3rZLyKxZ/Pe7Kw6rpsOYSQrwEIpwX3eEePN/tzJRzsd8zt/TReKyBKvh6OGh3MrZPPr1UyXBqsM806lgm5xMzsb1n25UwjsywAPzbxuMVkGe1u6WIAjnCF2D/S+9VLWi5GRk/P03MhYuQu7WrWoRlS3upZfgPWyYyoDuc94YlRFdsB9YWo4LKkpkM8M4S+AawePpOWiQZs2OHgy3Th1lLik0aUR02yreYfW2HQVyTegU5o28whIl0vk/swSzHUvKrvJ9rk6OSpjrzViUl4l2H3flFursJFlLhYbDOSS0httJqTBb50hCphLcrLTQLtgL39wWjQh/D2t3SxCEesY5KAiB11+vGktBZSxahPSFi5C/f7/yYFJlHt3dlfCmBdxrxAg4urpau9uCGcVpacqCrbKMr9+AguPHTV53cHFRC+MU2QwVY0iBlJITmhNyttsqrYcCvhEwZJyFg3IAN8dBva62qwaWBWOWciZNq+STEO7njsX3j1Qx3XQDyswvQmJmPhIy8pUIV48z80v/zyt9Pl9lEy4oLlGWKLaq4AJmkJcrQnzcjcS5LszLRbq4tgt1xXNAfziHh2sr6pYSqTk4wDksTG0n2C57Y9Nx0+ebkJxdgM5hPph326AaLx4KgmC/uEREIOi221TLP3pUWb/TF/6lSkRlLFqsmqOvr3I9ZwI2WkolP4d1KMnJQc7WbWUu43n795vedx0d4d69u5aPZchgJbgZYiAIzRUR3bYKk6NNmK2ylOvJzsop/WvCrGqTqBEKaZYFY5ZyvtNYiuify9f1JGp07/F1d1GtfUjVsZN5hcVIytIEOIV4IgV5mTgvF+jcpsQAJGUVqLb/bNV99nFzLrec+7obiXNTKzqzGIs7kqDDyVfYk08g5v4HtFUe4wlA6XnC12WSZrtsP5WKm+duQkZeEXq09MW8adEI8BKrliA0N9zat0fIffci+N7pyNuzVyVgoxW8KCEB6T/9rJpTSDB8J1wIv0kT4d67t8wHGhBDYSFyd+8ucxnP2bkTKCw02ca1Q3tVwstrcLRaEHHylYSXgqAjotuW6XYxiq/4AoV/PASPwpTy52nhpuCuYbkwwnJgLAvGLOXGSdXCz7FOt7uLEyIDPFWrLoM6S/4k6KKcAp1iPUP721ig5xeVKEt7Zi1d25UwV3HmplZzPqaFXVzbmwe+48YB775TVqdbhxZuCm71umB1OCZsPJ6CrUkOCDqegiEdQrHlRAqmfbkZ2QXF6NfKH19MHaQW1gRBaL5QSHv07KFa6KOPqESYqgTZ33+jODEJqfPmqeYSFQVfVQN8Itw7dbJ2t+0eQ0kJ8g8dKi3jtR65m7co67YxLNepRLaKy46GS2jNQrwEoTkiotvGMXS5CEuPApN6+MM5N1mL4aZLeQ0s3OZQWLMsGLOZU+BSkNL1vDHKhPE7dHHcvYrtdNd2Y7f2Mqt5qUDX/66ra3u5xVwX6sbPiWt7U4DC2uf885GxcSO2LluG/mPHwjc6WizcNsKSPWeNFgCd8PXhLQj0dEVmfiEKiw0Y0i4In908AF5ucosSBKEcjuGsPMEW/vRTyFq3TrmgZ65YgcLTp5H8ySequXXsqBKwUYBLFuyawflX4alTZbWyczZuRHFqqsk2Tv7+WgmvUpdxl1atxLtAEGqIzGjsAQdHGFoPB1xc6kX8DmkfBFvF2LW9urJAdG1XojzL1LVdPc46R9f20szsxq7t5lZ0scDZ/uSMpWcyExPV/yK4bUdwM9TFPOI+JadA/d89whdfTB2ovGgEQRAqw8HVFT6jR6tGCyxrfzMBW/aqVcg/fBiJb7+tmkfv3loN8AsnSBJNMwoTEpS41q3ZRbGmEyQHT094DhwAr2hNZLt17gwHR/EaFIS6IKJbsFs4KY8K9FStOjfW5OxyC3miWXI4i67tiUU4lliNa7uzI0KYkb3ICX+l7UCYHwW6cZI4cW0XBPNrkRZuSwkddZg8zUWuF0EQaoGjp6fmWj5xIorT05G5bBnSFy5EzsZNyN25U7X4WbNUrLGqAT52bLOMNy7OyEDO5s1lIrvgyFHTDVxc4Nm7d1mtbI+ePVXWcUEQzh0R3UKTh9Z9JYB93Gvt2p5gIfY8UXdtL6JrO91jHXByf0KNXdvLrebGlnRNrItru9CUyM4vQjI9TLLzkZSZj80nUkxySliCVRYYAmPLHjmCINguTn5+8L/yStWKEhORsXiJigGn8M5et161uOdfgNfIkfC7aBK8R4+Go0fTLEdYkpeH3G3bylzG8/buBUpKyjdwcIB7166ayB48BJ79+6kFDEEQ6h8R3YJwDq7tZ1OzsWTlerTq1B3JOeWCXRfndXVtNxbiukg3/luytgvWslSn5vBcztfEtNn/yqOE/5f+nVtYXKfv4TUkCIJwrtCdPPCmG1UrOH1axX9TgNP9PGvFCtUoMr3PP1/Ff3sPG2bXll1DURHy9uxRAptCO3f7dhgKtNAdHde2beE5OFoT2YMGwjkgwGr9FYTmhIhuQTgH1/ZwHxecDTJgYnQruFi4Ueuu7brFXHdttxR7XnvXdmOLeak7u1nsubi2C9WRU1Bqjc7iIlGpYM42+7v0dcZdWyp/XhXuLo4I9nZDkLcb6Mex7XRate+RmtyCINQ3rlFRCP6/O1XLO3RIE+B//YXCmBhk/PmnarSS+0yYoAS454ABNh+/TA89LiDklIpsuo6XZGWZbMPKHUx8plmzB8MlPNxq/RWE5oyIbkFoJNf26m6crEusxZmXu7ZXiD3PyFPbaa7tNc3abp6t3c1i7LkkrmoacKEnTVmjNcGclF36f5l4LrVMZ2t/5xTUzhrNcyrA01Ut6GhiuvR//u2j/U+BHVL6mqerU5lXBvs2fPY/yoXcknZ3KC1jyKoKgiAIDQVLirGFPHA/8nbuVAnYMhYvRnFSEtIWLFCNYtX3wgtVFnT37t1sxrus4MyZMpGdzQzjSUkmrzv6+cFr0KAyl3HXtm1spu+C0JwR0S0INgBviHQZZ6upa7vmwm5URs3Yip5JQaW7tmuCq1rXdndnUyGuW82N//Zxh6+Hs9zAG5ncguJSoVygYqMpmDVRbSqglTU6u0Ad99qge04Ee2uC2VhAU1Dr4pqNpb3q6j3BRajnJndT2ct5Bhl3Uz+j+HpjlDEUBEFQNcD79FEtbMbjKpM3E7BlLl2Govh4pHz5pWqurVtrGdAvmgS3du0atY9FyclaCa9SoV145ozpb3B3h2f//lqt7MFD4N61i1TrEAQbRES3IDTxrO1aOTUzq7luRS8tt6Zc2/OKVKuNa3tVsefWdm3n7994PAVbkxwQxMRcHUJtRsyV0BqdW1i2IKLioXV37lJBbfx8di2t0STA08VEQAeXWqDLrdO6pdoNXkbW6IZmQo8W+OiGfkZ1ujVo4abg5uuCIAhWqQE+dKhqJc89h+zVq1X8d+Y//6Lg5Ekkffiham7dusKPAnziRLi0qHy8MhQXK3dvnx07kBMSAt/o6BqJ4eKsLPU+XWTnHzpkuoGzMzx69Sqrle3euzccXV3rYxcIgtCAiOgWhCZK7V3btdhyXYhXiD2vpWs79W2gl3m29nKreUgDurazFnS5qHPC14e3oEUDizp6IFRIMGZkgTaOm2YyMi4K1AYudgSbuXBrVmhXIxdv7e8AL1ebLrvFYzC2WzjWH0nA0tUbMW5EtE0tigiC0LyhiPU5/3zVSrKzkfnPP8j4ayGy1q5F/r79SGB7/Q149O+vMqD7jB8P58DysJiMpUsRP/NVFMXFgXec2O++R0J4OMKefAK+48aZfFdJQQFyt+9QJbxymPxs926g2HSh1a1LlzKR7dF/AJy8vRptXwiCUD+I6BaEZo6pa7tPrV3bLcWem7u276uBa7uJEK8k9rwmru0U3HRfNpe0jCPm87Sy1kR40xrN0nBlCcWMBHRZvHSpyzefz8ovQm3xpzXaLAaawlkX0bq7N//3dmtabv0U2NFtA5G836D+F8EtCIIt4ujlBb/Jk1UrSk1F5t9LlQU8Z8sW5G7dqlrcy68oCzkTsMHREWcfn8EVbZPPobt6zP0PAG+/BZeWLbXEZxTaW7fBkJ9vsq1Lq1ZlItszOtpE0AuCYJ+I6BYEoVFc2y1a0TPzleVcd20/WgPX9nJxbmY1V9na3fDs73stJunic5R1fD3M17209JUmmI0FdJJRbHStrdFOjmWxz8aW5/KY6PK/mYyMv0cQBEGwD1heK+Daa1QrjI9HxqLFKgM661/THZ2tUkpFeMyDD1UQ5E4hwSrpmZcq5TVYiXJBEJoWIroFQbAZ1/aEymLPM/PLXNvPpOaqVhc4zeHnXvbhuhq/x9fduTQm2ihTd6mADjFLPObTxKzRgiAIgmVcwsIQNPUW1fKPH0fGokVI++lnFJ2txrXLYICDh4cWP15qzXZt317uHYLQxBHRLQiCnbm2Vx57fjo1R1nMq4PfFxngYVLyKriCa7cbAr3EGi0IgiBUjVvbtgi55x6V5Tz2kUer3b7FC8/D7+KLG6VvgiDYBiK6BUFoMq7t648m47pPN1T7WR/f0B9D2gfVcw8FQRCE5oxzSGjNtgsLb/C+CIJgW4gJRxCEJsOgtoEqS3llTnp8nq9zO0EQBEGoTzwH9IdzeDjduCxv4OCgXud2giA0L0R0C4LQpGLJWRaMmE959L/5umTKFgRBEOob1uFmWTDtD7P7TOnffL0m9boFQWhaiOgWBKFJwXJgLAsW7meaxI1/17RcmCAIgiDUBdbhbvnuO3AOCzN5nn/zefM63YIgNA8kplsQhCYHhfXYbuFYfyQBS1dvxLgR0RjSIVQs3IIgCEKDQ2Htc/75yNi4EVuXLUP/sWPhGx0tFm5BaMaI6BYEoUlCgR3dNhDJ+w3qfxHcgiAIQmNBge05cCAyExPV/yK4BaF5I+7lgiAIgiAIgiAIgtBAiOgWBEEQBEEQBEEQhAZCRLcgCIIgCIIgCIIg2GJMd35+PrZt24aEhAQMGzYMwcHB9dczQRAEQRAEQRAEQWiulu733nsPLVq0wPDhw3H55Zdj165d6vmkpCQlvufOnVuf/RQEQRAEQRAEQRCE5iG6v/jiCzzwwAOYMGECPv/8cxgMhrLXKLjPO+88fP/99/XZT0EQBEEQBEEQBEFoHqL7zTffxCWXXIL58+dj8uTJFV7v378/9u7dWx/9EwRBEARBEARBEITmJbqPHDmCCy+8sNLXAwMDkZycfC79EgRBEARBEARBEITmKbr9/f1V7HZl7Nu3D+Hh4efSL0EQBEEQBEEQBEFontnLJ06ciP/973+4++67K7xGt/JPP/0U06ZNq4/+CYIgCIIgCILQzCguLkZhYWGDfT4/29nZGXl5eeq7BNui0EaOj4uLC5ycnKwjul9++WVER0ejR48eKqbbwcEBX331lcpY/vPPP6us5s8+++w5d04QBEEQBEEQhOYDEzTHxcUhLS2twb+HnrmnT59WWkawLQw2dHzo5c2+nEs/6iS6IyIisHXrVjz55JNYsGCB2inz5s2Dj48PrrvuOsyaNUtqdguCIAiCIAiCUCt0wR0aGgpPT88GE1wlJSXIysqCt7c3HB3rXEVZaCBKbOD4UOPm5OQgISFB/U3DcqOKbsIL4bPPPlMtMTFR7ZiQkBA5aQVBEARBEARBqDV0I9YFd1BQUIN+F7VLQUEB3N3dRb/YICU2cnw8PDzU/xTePC/r6mpep1/AeO2NGzeW/U2xHRYWVrZDNm3aJDHdgiAIgiAIgiDUGD2GmxZuQbAV9PPxXHIM1El0f/nllzh69Gilrx8/flzFeAuCIAiCIAiCINQGa8fwCkJ9n48NYquPjY0tM8ULgiAIgiAIgiAIQnOlxjHdv//+u2o6LBm2fPnyCtsxDoPPDxw4sP56KQiCIAiCIAiCYOfccsstSi/99ttv1u6KYIuie9++ffjxxx/LTOyM6WYGc2P4vJeXF0aOHIm33nqr/nsrCIIgCIIgCIJgh27Izz33HN59912VFbuhYaJrlnBeuHAh4uPjERAQgN69e6vnhg0bVtbfX3/9FZdeemmD96e5U2PR/cQTT6hGmDDt888/x/XXX9+QfRMEQRAEQRAEQbALzp49W/aYZZUpcA8ePFj2HMtfsTUGV1xxhcr+zTxb7dq1U8J7xYoVSE5ObpTvF+ohppsp3EVwC4IgCIIgCIIgaISHh5c1Pz8/ZUk2fo6Cm+7lxpbl0aNH495778UDDzygrNGsCPXpp58iOzsbU6dOhY+PDzp06IDFixebfNeePXtw4YUXqs/ke2688UYkJSWp1+i+vnr1asyePRtjxoxB69atMWjQIGVAvfjii9U2bdq0Uf9fdtllqp/634Qhxf369VPluijYX3jhBRQVFZW9zu0/+ugj9f3M48Vtfvrpp7LXKfanT5+u6lrzM1q3bo1XX30VzRkpSicIgiAIgiAIgmAlaI0ODg5WZZcpwO+66y5cddVVGDp0KLZt24Zx48YpUZ2Tk1Mmqs877zz07dsXW7ZswZIlS5Ql++qrrzaxqDNuPD8/3+J3bt68Wf3/xRdfKAu9/jfF+k033YT7779fhRd/8sknqnLVK6+8YvL+Z555RlnTd+7ciSlTpuDaa6/F/v371Wvvvfce/vjjD/zwww/K0v/tt9+aiPrmSJ1FN1dbxo4dqwrXOzs7q0Lh5k0QBEEQBEEQBEGoHMZaP/300+jYsaOyRtM6TBF+++23q+fopk638F27dqnt58yZowT3zJkz0aVLF/V47ty5+Pfff3Ho0CGlzSiUKeb9/f1VDPeTTz5Z9n4SEhKi/ufrtMLrf9OqPWPGDNx8883Kgk2999JLLynxbQwXBW677TZ06tRJvT5gwAC8//776rVTp06pfg8fPlxZuYcPH47rrrsOzZk6ie6ff/4ZF110kVpR4aoG3c25I/mYLga9evVSJ4cgCIIgCIIgCIJQOdROOjRc0qjZs2fPsufoPk4SEhLU/7QuU2DrFm02im9y9OhR9T+t0CzjTIvzhAkT8N9//ymXcYrxquBnv/jiiyafTfFPa7huaSdDhgwxeR//1i3ddKHfsWMHOnfujPvuuw9Lly5Fc6fGidSMoU8+4wLWrFmD1NRU5dM/bdo05eZw4sQJDB48GG3btq3/3gqCIAiCIAiCIDQhXFxcTP5mzLTxc3pWdBo6SVZWFiZPnqxits1hHLUOLea0VLPRHZyWaWZQpyiuDH42rd2XX355hdf4eTWB4v748ePKM5qlpK+++mpccMEFJnHfzY06Wbrp30+rNldi6L5ACgsL1f/017/77rstngSCIAiCIAiCIAhC3aGo3bt3r9JdTLJm3Fi+uTK6deumErTpUNgXFxdX+GzGYZt/LhsrWOls2LDB5H38u2vXrmV/+/r64pprrlFJ4RYsWKA8pVNSUtBcqZPo9vT0hKura1kcgJubm0mKfLpAcHWjrnzwwQfqJOJqSnR0tEoqUBm//PKLiiFgP3iS9enTB/PmzavzdwuCIAiCIAiCINgq99xzjxKwDO9lAjS6lP/9998q2zlFNOO/6YH8zTffqDhu6rIff/wRr732Gi655JKyz6HeYhmxuLg45b1MGCL89ddfK2s3hT1dxr///nsVc24MP49x5Iwhp/Wceo0Zy8lbb72F7777DgcOHFCv//jjjypunHqtuVIn0U3/fFq7dXShy1TyeXl5mD9/Plq1alWnDnEl5KGHHlIHj9n6mFhg/PjxZTEM5gQGBuKpp57C+vXr1UnFk42NJ54gCIIgCIIgCEJTIiIiAmvXrlUCm5nNGf/NkmMUtbRGMw6bhsu3334bI0eORI8ePZR7OWOzmYRN580338SyZcsQFRWlkrER6q6//vpLxWEPHDhQhQ3zc5gQzRiKcopxxqNTpFNk05JOWOaMAp+GUX7GiRMnsGjRIhNLeXPDwWAwGGr7pjfe+P/27gM8qmpr4/iCQOgQEELvTRFBilFQEQQEe5erXsVy7eUqNmzYKYqIXa8NvfYOVxEpio0mIiCCNKlSEpQeICGZ73k33xknySQkIZM5k/x/zzMkmTmZOZkzQ/KevfbaI10r+KVLl7pRbh0YnTVREzXNOVDZgs585DVfIDd6gejgeC8IzV3QC0Ht89VJLz9UFnHyySe7Tnr7s23bNreO3tatW10ZhN+obF8v0pNOOinHfA9EH8fH3zg+/sbx8T+Okb9xfPyN41NwGrzTqKx6Q+V3/nBhKWMoB+jv/9IcBgtDee+TTz7Jst54ST4+u/N4XeY3SxbqJ7j11ltdK3gFblEnc3XE09mTq666ypUpFCZwayH1n376yU20D+5g2bLua41k74/OH+ixNQ9BZ3UAAAAAAIi57uXhHHvsse7i2b59uystKIhNmza5MgmvLb5HX2tOQG50ZqFhw4Zu8Xc1d3vuuedcl75wtE3oIvE6O+GdjfSawfmJt09+3DdwfPyO4+NvHB//4xj5G8fH3zg+BafnSoNoGuX0OnVHilfs6z0eCibSxyjgo+Ojx9d+6PWprBkqv+/vIgvdHs29Hj16tFtGzJuQH2kK91oLTi3uNdKtOeFazL1nz55hlzvTHITsNG9BDeL8SvMt4F8cH3/j+Pgbx8f/OEb+xvHxN45P/mlVJDXc0t/0qoAtDhooRMF4Gc8bvCzpxyctLc127dpl3377rethFip07fIiC90K1Joorw55NWvWdIuud+nSxd32xx9/2COPPOIWXFfde7jAuz+1a9d2Zw82btyY5Xp9rTdgblSCrjb2XlM3ddlTuA63D3feeacL5R69WDRnXE0I/DqnW/9Za+Se+UD+w/HxN46Pv3F8/I9j5G8cH3/j+BScMsSaNWtcI7BIz+nWyKVXmeutgw3/CPjo+Oh1qd5lmr4cbk53kYZulXfrgdSC3hvuV1c6taLXE6HF1rVDCuK33XZbMIwXhJYh0/dptNqbmK/hfH3ttaDPD31PaAl5KM1D9+aih9J/hn7+D9Hv+1facXz8jePjbxwf/+MY+RvHx984PvmnaabKFRpQi3TzLK9k2Xs8+Eumj46PHl/7Ee69nN/3dr5Dt9rMq9RD86U1d1sd3G6++WbXnl5zqk899VQbPny4K+s+EBqFHjhwoGsxn5SU5ErV1Q1dy4DJxRdf7OZvayRb9FHbtmzZ0gVtdYnU8mUqbwcAAAAAIJryHbpVw37NNde47uSiddg07+LEE090Ifm1114rkh0aMGCApaSkuIXZtVC7ysUnTJgQbK6mrumhZzsUyK+99lpbu3atG/Y/+OCD3ei77gcAAAAAgJgI3Sor1+LnoTp27Og+nnnmmUW6Uyolz62cXEuThXr44YfdBQAAAAAAvylbkLr63GrY1ewAAAAAAAAcQPfy2bNnZ+nYpo5ymlT+/fff25YtW3Jsf9ZZZxXk7gEAAACgRLnkkktcVvr000+jvSuIhdCtpma6ZHf//ffnuE5hXB0IAQAAAKC4ZGQGbNaKvyx5+25LrFbRkprXsriykVl2an/LWd1333325JNPBld/Km4vvfSSPfPMM27JZ/Xjat68uZ133nluGWU/nRCYOnWq9erVy60BnpCQUOj70RLWn3/+uc2dO9etjBVuYNjXofvrr7+O7J4AAAAAwAGYsGC9PfC/hbZ+6+7gdfVrVLT7Tm1n/dvXL/LHW79+ffDz9957zzWDXrx4cfA6TcON1lTcV1991a009dRTT9lxxx3nVnqaP3++LViwwEqqtLQ0O/fcc61bt272yiuvmF/kO3TrQAEAAACAXwP3NW/Osexjyhu27nbXP//PzkUevOvVqxf8vEaNGm7kO/S6cKPJPXv2tMMOO8zi4uLs9ddfdyOyagx9wQUXuGbSH374oVu56emnn3YrRXkUlm+77Tb77rvvrEqVKnbCCSfYE088YbVr1w67b+PGjXOj2pdffnnwukMPPTRLtbIeP3TEXgOt2r81a9bYLbfcYhMnTnQrR2nJaI3YN2vWLMvP1KlTJzeSrkCv/VfA188j+jkeeOABW7ZsmVWuXNltO3bsWLfvoVauXOlGuaVmzZrBZaL1eAWlx5MxY8aYn7ASPAAAAADfUUl2atrefF227063+8b9miNwu/v5/4/3j1votvO+Z1daRq73F+lycIVdheVZs2bZDTfc4JZm1ght9+7dbc6cOS5QX3TRRZaamuq2V8A9/vjjXXBVny0tqbxx40YXqnOj8D9jxgxbtWpV2NtvvfVW9/39+/d3I/a66PHT09OtX79+Vq1aNRfwf/jhBzdar+00kuyZMmWKLVq0yJWGv/POO/bxxx8HQ6/u6/zzz7fLLrssuI36fYV7Xhs3bmwfffSR+1xVAvpeb0rzsGHDgtUCuV20pHSJmtMNAAAAAMVhV3qGtRvyZZHcl6Lehm277bD7J+Zr+4UP9rPK8ZGLSlp6+Z577nGfa3718OHDXQi/4oor3HUqU3/++eddOfhRRx3lRpMVuIcOHZqlfFyBdcmSJdamTZuw88kVdDU6rdtVcn3SSSfZOeec40avFVgrVarkRqlDR+fffPNNt3LVyy+/HBwBf+2119xca4VnnRAQjWhrHzSKrRH0Bx980I3EP/TQQy4479271z1+06ZN3fYa3Q9HI/61atVynycmJrrH0eNv27bNrrrqKhswYECez2WDBg3M7wjdAAAAAFCMOnTokCV0HnTQQVlCqcrLJTk52X2cN2+eK/0ONz9cTdLChe769evb9OnTXVn6t99+a9OmTbOBAwe6MK2RcgXvcPRYKgnXSHeo3bt3u8cKPXGgwO1RqN+xY4crTddtvXv3dj9Tv379XFBX2PfKx/NLYTy38vlYQugGAAAA4DuVyse5Eef8ULfyS177cb/bjbn0CNfNXCOp27dtt2rVq4UNn3rsSCpfvnyWrzWiHHqdN8Ks/RSF2VNPPdVGjBgRNlznpX379u5y7bXX2tVXX+3mZ3/zzTfBedTZ6bG6dOlib731Vo7b6tSpk6+fTycSJk2a5IL+xIkT3fz0u+++22bOnOk6qOeXyst1ycvChQutSZMm5meEbgAAAAC+o+CZ3xLvY1vXcV3K1TQt3GxsRdh6NSq67bR8mMLs3vg4d/+5jfj6SefOnd28Z5WKa+mvwmrXrp37uHPnzmCJePZlnvVY6sSuUu/q1avnel8aEd+1a5crURfNH9dIvEreveN39NFHu4vK5VVm/sknn9igQYNy3JfXfC37vpSU8vICv8I0mV9nPl544YXI7BEAAAAAFICCtJYFk+wrZ3tf6/ZIrdcdadddd5399ddfrjnZjz/+6Mq8v/zyS7v00ktzBFWPmrNpfrUaoamZmkKxuoJrtFql4KIQr3njamC2adMm10TtwgsvdCXdp59+umuktmLFCjeX+8Ybb7S1a9cG719N1dQZXSPN48ePd3PI1X1dJzE0oq3552r6tnr1atdkLSUlxQ455JCw+6pArpD+2Wefue002u6Vl7dq1SrPS+hJCD2W1ujWRz0v+lwX7/5iJnSrbl9P/P4WggcAAACA4qLlwLQsmEa0Q+nrSCwXVpw0mqvwrCCp+dGaK601uNV0LLeR+j59+rigra7omvN99tlnW8WKFV3Xcc0hFzVua9u2rXXt2tWFcT2G8p7mgKtkW43QFJQVrjWnO3TkW3O2W7dubT169HCj0aeddppbhky0ne5DjdvatGnjmsY9/vjjWZZAC9WwYUPX+Xzw4MFuPrs6uheGRtTVcE4nABS09bnX8T2aygQK0Q9fa7DpSdcZi1inrnhaU2/r1q15lk9Ei8426cyRXrDZ534g+jg+/sbx8TeOj/9xjPyN4+NvHJ+CU77Q4J7m/CocFlZGZsDN8U7evtsSq1V0c7izj3B73bH1938slJf7Tfa1x4tapo+OT16vy/xmyUJNCLj33nvdGROtHac6e+2AV8sfymv9DgAAAADFQQG7W8t9I7mAHxQqdGsdNlH9/ttvv53rdrnNLwAAAAAAoDQoV9haeeZ0AwAAAEDpM2bMmGjvQskP3d4EeQAAAAAAkLsimZWu9dl0AQAAAAAARRC6tfaZ1oVTS3ctgq6LPr/sssvcOnAAAAAAAJR2hSov/+233+yYY45xbeL79u0bXORc17/xxhv2v//9z77//nu35hsAAAAAAKVVoUK3Fi3Xemk///yzW5g91IIFC9xC6drmk08+Kar9BAAAAACgdJSXf/PNN3bjjTfmCNzSvn17u/76623q1KlFsX8AAAAAAJSu0J2enm6VKlXK9fbKlSu7bQAAAACgNLvkkkvsjDPOiPZuINZCd6dOnezll1+2rVu35rht27Zt9sorr1jnzp2LYv8AAAAAIP8yM8xWfGf2y4f7PurrCClTpkyeFy21/OSTT0ZtXeuXXnrJOnbs6JpeJyQkuBw3bNgw350QmDp1qnu+1DOssFauXGmXX365NW/e3A0Qt2zZ0u677z5LS0uzmJzT/cADD1j//v3t4IMPdh3M27Rp465fvHixvf766/bnn3/as88+W9T7CgAAAAC5WzjObMIdZtvW/X1d9QZm/UeYtTutyB9u/fr1wc/fe+89GzJkiMtEHm+Vp2h49dVX7aabbrKnnnrKjjvuONuzZ4/Nnz/f9eAqiX777TfLzMy0F1980Vq1auV+ziuuuMJ27txpI0eOjL2R7uOPP97Gjx9v9erVs+HDh7tlwnQZMWKEu0639erVq+j3FgAAAAByC9zvX5w1cMu29fuu1+1FTNnHu9SoUcON1oZep8CdfTS5Z8+edsMNN7hAXLNmTbfsskakFQ41oFmtWjUXGr/44ossj6UQeeKJJwaXar7ooots06ZNue7buHHj7LzzznOjv7q/Qw891M4//3x75JFH3O0ahdeA6dixY4Mj815frjVr1rjv1eh4rVq17PTTT3cjyR7vZ9JgbJ06dax69ep29dVXZxlV/vDDD10PsEqVKtlBBx1kffr0cT9jdrpfLzvq+dB+6HkoKA0Kv/baa3bCCSdYixYt7LTTTrNbb73VPv74Y4u2AoduzdXWGRKNcqt7+bp162z69Onuos/nzJnjupcDAAAAQKEFAmZpO/N32b3N7Ivb9U3h7mjfB42Aazvve9JTc78/PXYEKezWrl3bZs2a5QL4NddcY+eee651797d5SkFR4Xq1NRUt73KrjXwqfLw2bNn24QJE2zjxo0uGOdGoX/GjBm2atWqsLcrkOr7FVY1Yq+LHl95r1+/fi78f/fdd/bDDz+4oK/tQkP1lClTbNGiRS6ov/POOy7cKoSL7ksBXwOzi/5/m7POOssCYZ7Xxo0b20cffeQ+V5WAvnf06NHua5XCe9UCuV1Wr16d63Og6dA6aRBz5eVaKqxLly72+OOPuw7m3lkcAAAAACgyCsVDGxTRnQX2jYAPbxwceUzIa/O71pnFV7FI0Tzre+65x31+5513uuphhXCVQ4vK1J9//nk32HnUUUfZM8884wL30KFDs5SPK7AuWbIkON03lOYzK+g2a9bM3d6tWzc76aST7JxzznGZToFVo9AqOw/Nc2+++aYr01YPL406i0aQNeqt8KwTAhIfH+/2QU20NYr+4IMP2m233WYPPfSQC8579+51j9+0aVO3fbiVryQuLi4YjBMTE93j6PHVK+yqq66yAQMG5PlcNmgQ/jWybNkye/rpp6NeWl6o0K0nRU+cDg4AAAAAoGA6dOiQJV+p/Do0lKp8XJKTk93HefPm2ddffx12fvjy5cvDhu769eu7amSVpX/77bc2bdo0GzhwoAvTGilX8A5Hj6XAqpHuULt373aPFXriQIHbo1C/Y8cOV5qu21T9rJ+pX79+Lqgr7Kt8vCAUxnUyoqD++OMPNzKv6gHvREbMNVJTCYTOtmh+gB+G6wEAAACUMOUr7xtxzo9V08zeOmf/2134oVnT7vtGUrdvt+rVqoUPn3rsCCpfvnyWrzWiHHqdN8Ks/RSF2VNPPdX10AoXrvPSvn17d7n22mvdvOtjjz3Wvvnmm1x7cOmxVNn81ltv5bhN87fzQycSJk2a5IL+xIkT3Yjz3XffbTNnznTdxfNL5eWh3dbDWbhwoTVp0iT4taY862dTqfx//vMf84NChe6MjAyrUKGCa8OuMxYqWci+brdeKDfffHNR7ScAAACA0kTBM78l3i2P39elXE3Tws7rLrPvdm1XNk5p1qx8xr77z2XE10+0HLPmPSt3lStXqAjntGvXzn30GpqpRFzZLvtjqRO7Sr3VIC03GhHftWtXMAdq/rhG4lXy7uXBo48+2l1ULq9q6U8++cQGDRqU4760H5J9XwpaXq4RbgVunTRQSXxuo/nFrVBHTJPuPVqTOxxCNwAAAIBioSCtZcHUpVwBO0vw3jdqbP2H79suBl133XWuw7mak91+++2u2lgl4O+++64rF9fIcnZqzqZAqgZsjRo1cvOsH374YTdarVJwUYj/8ssvXQMzlbirA/uFF15ojz32mOtYrnna+l41Y1OjND22vhY1VVPls+amqwO55pBff/31LuhqRFuN1lRWnpiY6L5OSUmxQw45JOzPp0Cu/PjZZ5+5eeca4C1oebkCtzrD6740j1uP54l2D7JChe4VK1YU/Z4AAAAAQGFpHe7z3shlne7hEVmnu7goPKuL+B133OGCrPprKVxq3nJuo7laokuNztSQ7c8//3ThVWFbYVgBWzTfWc3Runbt6srKNW9cwVVzwPVYaoS2fft2a9iwoZujHTryra9bt25tPXr0cPujEwJahky0ne5DXci3bdvm9lWNuLXkWTi6f3U+Hzx4sFsuTJ3bn3zyyQI9Rypn14kIXbwTA55wXdOLU5lAAfdAJQSqx9ewveYVxDq9CHRGR+3k8yqfiBa17Ne65zrjk33uB6KP4+NvHB9/4/j4H8fI3zg+/sbxKTg16tLgnub8VqxYsfB3lJmxb473jo1mVeu6OdzZR7i97tj6+98vJcixROt0axmzTz/9NCL3n+mj45PX6zK/WbLAI92q2X/xxReD8wEAAAAAwDcUsJsfG+29AIIKddpAE9PVeh4AAAAAABTxnG7V5qtURq3nVVpwIB30AAAAAACxY8yYMdHehZhSqLSsoK3aerVwv/HGG93E93BLhqmNPAAAAAAApVWhQrdat6vjXdu2bYt+jwAAAAAAKM2hW23lAQAAAABA3uiPDwAAAABAtEP3tddea7Nnz86y9uD7779vKSkpObadPHmyHX/88UW3lwAAAAAAlOTQ/cILL9iSJUuyLAR+/vnn2y+//JJj240bN9o333xTdHsJAAAAADFITajPOOOMaO8GYrW8PBAIFN2eAAAAAEAM0YpNeV3uv/9+e/LJJ6O2xNZLL71kHTt2tKpVq1pCQoJ16tTJhg0b5rsTAlOnTnXP15YtWw7ofk477TRr0qSJVaxY0erXr28XXXSRrVu3zqKNBbYBAAAAlBgZmRk2J3mOpaSmWJ3KdaxzYmeLKxsXkcdav3598PP33nvPhgwZYosXLw5ep7CrSzS8+uqrdtNNN9lTTz1lxx13nO3Zs8fmz59vCxYssJKqV69edtddd7nA/ccff9itt95q55xzjk2bNi2q+0UjNQAAAAAlwuRVk63fR/3ssi8vszu+u8N91Ne6PhLq1asXvNSoUcON1oZep8CdfTS5Z8+edsMNN7hAXLNmTatbt64bkd65c6ddeumlVq1aNWvVqpV98cUXWR5LYfnEE09096nv0Sjupk2bct23cePG2XnnnWeXX365u79DDz3UTQ9+5JFH3O0ahX/99ddt7NixwZF5b5WqNWvWuO/V6LiWiz799NNt5cqVwfv2fqYHHnjA6tSpY9WrV7err77a0tLSgtt8+OGHdthhh1mlSpXcctN9+vRxP2N2ul+FZdHzof3Q81AYN998sx111FHWtGlT6969uw0ePNhmzJjh+pFFE6EbAAAAQMxTsB40dZBtTN2Y5frk1GR3faSCd2Eo7NauXdtmzZrlAvg111xj5557rguKc+bMsRNOOMGF6tTUVLe9yq7VqFrl4WpuPWHCBNdHS8E4Nwr9CpyrVq0Ke7tGgfX9/fv3dyP2uujxFVD79evnwv93331nP/zwgwv62i40VE+ZMsUWLVrkgvo777xjH3/8sQvhovtSwL/sssuC25x11llhpyc3btzYPvroI/e5qgT0vaNHj3ZfqxTeqxbI7bJ69eqwP99ff/1lb731lvuZypcvbzFTXv7GG2+4Aye7d+92ZyGeeeYZ+/TTT7NsF9pwDQAAAAAKSgFt195d+S4pHzZrmAUsZ6jzrhs+a7gdWe9IV2qemZnp7rtcejkrWzbnOGSlcpVc1okUzbO+55573Od33nmnDR8+3IXwK664wl2nMvXnn3/elYNr5FaZS4F76NChWcrHFViVvdq0aZPjMe677z4XdJs1a+Zu79atm5100kmu3Fo/swKrRqFVdq6A7nnzzTfd8/Pyyy8Hn4PXXnvNjXorPOuEgMTHx7t9qFy5shtFf/DBB+22226zhx56yAXnvXv3usdv2rSp216j3uHExcW50XRJTEx0j6PHV+Puq666ygYMGJDnc9mgQYMsX99xxx3u+dIJCz13n332mUVbgUL3xIkT3SVU9sDtieSLFAAAAEDJplB85NtHFtn9aQS8+7vd87XtzAtmWuXylS1SOnTokCV0qvw6NJSqfFySk5Pdx3nz5tnXX38ddn748uXLw4ZuzWuePn26K0v/9ttv3bzmgQMHujCtkfJwJxu8x1q2bJkb6Q6lQVc9VuiJAwVuj0L9jh07XGm6buvdu7f7mfr16+eCusK+yscLQmFcJyMKQsFfJfUa4dfI+8UXX+yCdzTzab5Dt842AAAAAAAOTPZyZwXC0Ou8gOhlMIXZU0891UaMGBE2XOelffv27nLttde6edfHHnusW97Zm0ednR6rS5curjQ7O83fzg+dSJg0aZIL+hMnTrSnn37a7r77bps5c6Y1b97c8kvl5aHd1sNZuHCh61juUUjXRSciDjnkEFcNoGptnRSIFrqXAwAAAPAdlXhrxDk/ftr4k1075dr9bvdc7+esS90uLsxu377djebmVl7uJ507d3bznlUqXq5c4SNcu3bt3EevoZlKxDMyMnI8ljqxq9RbDdJyoxHxXbt2uRJ1UbDVSLxCrnfi4Oijj3YXlcurzPyTTz6xQYMG5bgv7Ydk35fClJeH8k5aqIQ+mgjdAAAAAHxHoS2/Jd7dG3S3upXruqZp4eZ1l7Ey7nZt583p3ltur7v/3Mqs/eS6665zHc7VnOz22293ZdcqAX/33XddubhGlrNTczYFUjVga9SokZtn/fDDD7vRam/UVyH+yy+/dA3MVOKuDuwXXnihPfbYY65jueZp63tVqq1GaXpsfS1qqqYybs1NVwdyzSG//vrr3fOpEW01WlNZeWJiovs6JSXFjTyHo0Cu460ycM07r1ChQoHLy/UYP/74ox1zzDGujF2l8Pfee6+1bNkyqqPc4v9XGAAAAADkQUF6cNLgYMAO5X19R9IdEVuvO9IUntVFXCPBCrKaK60lx9R0LLeTBlqiS6PP6oquUuuzzz7bKlas6MKwAraocVvbtm2ta9euLozrMTRPW3PAVbKtRmgKygrXmtMdOvKtOdutW7e2Hj16uNHo0047zS1DJtpO96EA3aZNGxfMH3/8cbfkWTgNGzZ086+1xJfms6uje0Fpv3ViQPuln0n7rLnzKqX3Qny0lAmE69teiqgrns7obN26Nc/yiWhRy/7x48e7F2y0W90jJ46Pv3F8/I3j438cI3/j+Pgbx6fgFOpWrFjh5vwqHBaGlgVTl/LQZcPqVa7nAnefpn2C13ndsfX3fyyMdPuN1unWMma5NdU+UJk+Oj55vS7zmyUpLwcAAABQIihY92rcy+Ykz7GU1BSrU7mOdU7sHLMj3CgZCN0AAAAASgwF7CPqHRHt3QCCCN0AAAAAgHwbM2ZMtHeh5IXuyy67rMB3rO5zr7zySmH2CQAAAACA0hO6v/rqq+AC7flV0O0BAAAAACiVoVvrrgEAAAAAgIKhPz4AAAAAABFC6AYAAAAAwG+h+4svvrC+ffvaQQcdZOXKlbO4uLgcFwAAAAAASrNChe6PPvrITjnlFNu4caP94x//sMzMTDv//PPd55UqVbIOHTrYkCFDin5vAQAAACCGXHLJJXbGGWdEezcQa6F72LBhlpSUZD///LM98MADwWXF3nrrLVuwYIGtX7/emjdvXtT7CgAAAAC+oRWb8rrcf//99uSTT0ZtXeuXXnrJOnbsaFWrVrWEhATr1KmTy3J+OyEwdepU93xt2bLlgO5nzpw5rhpbP6sqsq+88krbsWOHxWToXrhwoRvVVgm5SsslPT3dfWzWrJlde+21NmLEiKLdUwAAAADYj0BGhu2cOcu2fva5+6ivI0WDjd5l9OjRVr169SzX3XrrrVajRg0XAovbq6++ajfddJPdeOONNnfuXPvhhx/s9ttv90UIjYR169ZZnz59rFWrVjZz5kybMGGC/frrr+7EQkyG7sqVK1t8fLz7XC+gChUquBeVp27durZixYqi20sAAAAA2I9tEyfast59bPXAgbbu1lvdR32t6yOhXr16wYvCtUZrQ6/TCHP20eSePXvaDTfc4AJxzZo1XXbSiPTOnTvt0ksvtWrVqrngqB5aoVRRfOKJJ7r71PdcdNFFtmnTplz3bdy4cXbeeefZ5Zdf7u7v0EMPdVOCH3nkEXe7RuFff/11Gzt2bHBkXiPOsmbNGve9ynq1atWy008/Pcsy0t7PpKrnOnXquJMNV199taWlpQW3+fDDD+2www5z04816qxArJ8xO91vr1693Od6PrQfeh4K6rPPPrPy5cvbs88+a23btrUjjjjCXnjhBTc1etmyZRZzoVs/hEa7PYcffrj997//tb1799ru3bvt7bfftiZNmhTlfgIAAABArhSs//j3TbZ3w4Ys1+/duNFdH6ngXRgKu7Vr17ZZs2a5AH7NNdfYueeea927d3cl0ieccIIL1ampqW57lV0ff/zxrjx89uzZbhRX/bUUjHOj0D9jxgxbtWpV2Ns1Cq/v79+/f3BkXo+vCuZ+/fq58P/dd9+5EXIFfW0XGqqnTJliixYtckH9nXfesY8//jg49Vj3pYCvKciL/n+bs846ywKBQI79aNy4sQvGsnjx4mDVgKgUXo+d12X16tVu2z179riB4bJl/464Cvzy/fffWzTtqw0voDPPPNOeeuopGzlypBvlvvvuu93ZD50J0ZkJncFQOQMAAAAAFIYCWmDXrvxtm5FhGx9+RN8U7o7MyphtfGSoVenWzcrExblG0Jm7dlmmpsqGhDRPmUqVXK6JFM2zvueee9znd955pw0fPtyF8CuuuMJdp6bUzz//vM2fP9+OOuooe+aZZ1zgHjp0aPA+lLcUWJcsWWJt2rTJ8Rj33XefC7qa/qvbu3XrZieddJKdc845LpgqsCqUKqwqoHvefPNN9/y8/PLLwefgtddec1lP4VknBEQBV/ugKmiNoj/44IN222232UMPPeSCswZk9fhNmzZ122vUOxxNWdZouiQmJrrH0eNv27bNrrrqKhswYECez2WDBg3cR52UGDRokD322GP273//22XSwYMHu9tCq7JjJnTrrIguHnUy1wHQ2Q09aSeffHKwRAAAAAAACkqBe3HnLkV0Z/tGvJcckZTl6o25bN52zk9WpnJlixSt9uRRflL5dWgoVfm4JCcnu4/z5s2zr7/+2gXl7JYvXx42dNevX9+mT5/uytK//fZbmzZtmg0cONCFaY2Uh44Ih9JjqRxbI92hVNGsxwo9caDA7VGo13xxlabrtt69e7ufqV+/fi6oK+yrfLwgFMZ1MiI/FPxVQaDgrRMZel41n13PZW4/q69DdzjHHnusuwAAAAAAcqe5x6E0ohx6nTfCrBFfUZg99dRTwzarVrjOS/v27d1Fza4171qZ7Ztvvsl1kFSP1aVLF7cyVXaav50fCryTJk1yQX/ixIn29NNPu+poNTgryCpXKi8P7bYejqY9e1ObL7jgAndR6X2VKlXc8zhq1Chr0aKFxVzoVpM0nTHRgQ/nf//7nzuroVIGAAAAACgolXhrxDk/UmfPtjVXXrXf7Rr/50Wr3LXrvvLl7duterVqYUdB9dh+0rlzZzfvWfnKWz2qMNq1a+c+eg3NVCKeka27ux7rvffec6XeapCWG42I79q1KzhvWvPHNRKvkndR4D366KPdReXyKjP/5JNP3Eh0dl6T7uz7UpDy8lBepYDK3ytWrOiWEYvJ8nLV2OcWutUxTrX477777oHuHwAAAIBSyHXUzmeJd5Wjj7Zy9eq5EvKw87rLlLFydeu67TSn2zIzrezevVa2cuWolx7nx3XXXec6nKs5mZb9Utm1SsCVt1QurpHl7NScTYFUc50bNWrk5jU//PDDbrRapeCiEP/ll1+6BmYqcVcH9gsvvNDNi1bPLs3T1veqGZumEuux9bWoqZo6o2tuujqQaw759ddf755PjWir0ZrKyhMTE93XKSkpdsghh4T9+RTIdbzVgVzzztU3rKDl5aK572oGp/CvkXbNMdd8+Wgs2RaqUK8wzQ3I62yB6vfV6Q4AAAAAIk1Buu5dd/7/F9kaoP3/17rdBe4YpPCsLuIaCVaQVVWxlhxTmMztpIGW6NLos7qia8732Wef7UZ9FYYVsEWN27QyVdeuXV0Y12NonrbmgKtkW43QFJQVrjWnO3TkW5mvdevW1qNHDzcafdppp7llyETb6T4UoNu0aeOC+eOPP+6WPAunYcOGrvO5Gp9plFod3QtD3eCVU/X8/Oc//7EXX3zRzeuOtkKNdG/evDnHxPpQOrPw559/Hsh+AQAAAEC+VVdX7SdH28ahw7IsG6YRbgVud3sEae1qXbIbM2ZMlq+9tbBDha6B7cm+vJYCrkab80shW5e8KGhrznV26maupmT7o6DsLRMWSkFdzdoK4t5773UX8bqXF9Qbb7xhflSo0K2zHjoLopKFcDTK7ZUdAAAAAEBxULCu1ru3pc7+yfampFi5OnWsctcuMTvCjZKhUOXlmkugBdC1VrfXUU9U7vDkk0+6iffqGgcAAAAAxUkBu8qRSVbjlJPdRwI3YnKkW+ueff/9924ewSOPPOLmAYgm4GuCfM+ePV1LeAAAAABAyZK9ZB4RGOlWNznV/r/yyiuWlJRkmzZtchd9rrbskydPDnacAwAAAACgtCr0Im/qknfppZe6CwAAAAAAyMmXi9JpnW+tGaeW9kceeaRr/Z4brVd37LHHWs2aNd1FrfHz2h4AAAAAAF+NdPfq1cuNbGvh9HLlyrkF1vdHi5trDbiCUhO2QYMG2QsvvOAC9+jRo61fv35uvrgWVs9OLffV2E2LoCukjxgxwq1d9+uvv7r13gAAAAAA8PVIt9aIC+1Srs91XV6X0O0LYtSoUW6RdpWtt2vXzoVvLdCuueLhvPXWW3bttdfa4YcfbgcffLC9/PLL7rELE/gBAAAAACj2ke7sC7iHW9C9KKSlpdlPP/3kuqN7NMKukvHp06fn6z5SU1MtPT3datWqFfb2PXv2uIvHW3Rd36OL33j75Md9A8fH7zg+/sbx8T+Okb9xfPyN41Nweq68wbvCDuDllx7H+xjpx0JsHx9vwFmvz7hsy8/l9/1dJuD9RD6wbt06VxI+bdo069atW/D622+/3b755hubOXPmfu9Do94qg1d5ucrNs7v//vvtgQceyHH922+/7UbUAQAAABQ/TWOtV6+eNW7c2OLj462kUD7ZunWrq9BF7NHA8Jo1a2zDhg22d+/eHAO+F1xwgTu+1atXL9ru5atXr97vfG4F3tq1a7vPi8vw4cPt3XffdSPx4QK3aBRdc8ZDR7r1xtY88LyeqGjR2ZNJkyZZ3759rXz58tHeHWTD8fE3jo+/cXz8j2Pkbxwff+P4FNzu3btduKlatWquf8sXFY07bt++3apVq3ZAeSX7yGd2Q4YMcU2i9XjRyBpqOv3cc8/Z8uXL3UmN5s2b27nnnmuDBw92t2tK75YtW+yTTz6xaJo6dar17t3b/vzzT0tISCj08Rk6dKiNHz/e5s6d607c/PXXX1lunzdvnusB9sMPP7glr9W8+6qrrrIbb7wxz9dlpUqVrEePHjlel17V9P4UKnRr5/Lzw2un1Fn83nvvtaOPPnq/2yuk64W7cePGLNfra531ysvIkSNd6NYa4R06dMh1O60fHm4Ncf1n6Of/EP2+f6Udx8ffOD7+xvHxP46Rv3F8/I3jk38ZGRkuY2h6qS6FlZkZsPVLt9jObXusSvUKVr91gpUtmzW7eCXL3uMV1vr167M0hFbIVgNoj04g6BIN6omlwcannnrKjjvuODfFdv78+bZgwYLgz6yf/0Cfg6JQ9v8f3zv2hT0+Otmlkwqqmn7llVdyfO/PP/9sdevWtTfffNMNvKrC+sorr3QnJK6//vpc9037Ee69nN/3dqFCt34AHTydibrwwgutVatW7vqlS5e6Mu2mTZu6sybLli1zP5C6nU+YMMF1Qc+LzkZ06dLFNUE744wz3HVeU7TcngR59NFH7ZFHHnFl5V27di3MjwQAAAAgxi3/Odm+e2+p7dzydw+nKgkV7NgBra1lp5wrIR2o0IHBGjVquHCWfbDwkksucaPJn376qfu6Z8+edthhh7nBxtdff91loIcfftiVKSvzfPjhhy4YPv3003biiScG70dh+bbbbrPvvvvOqlSp4ip1n3jiCTdwGc64cePsvPPOs8svvzx43aGHHppl2q0eX7wB1a+//trtn3LeLbfcYhMnTnShUwOpTz75pBt8Df2ZOnXqZM8884wL9Np/ZURvaoB+Dk3rXbZsmZvGq23Hjh3r9j3UypUrgzlRS0DLxRdf7B6voLxpxGPGjAl7+2WXXZbl6xYtWrjeYR9//HGeefNAlS3s3GvVtusJ1JNxww03uIue5CVLltiuXbvcRct96UxP/fr1w86jDkdnY1QGoRfAokWL7JprrrGdO3e6EO8dgNBGayoP0Ei6zuToRaBae1127NhRmB8NAAAAQIwG7gkvLsgSuEVf63rd7hfKOgrLs2bNcjlKmUcjtFoGec6cOS5QX3TRRW7OsCjgaiBTwXX27NluQFPVwArVuVH4nzFjhq1atSrs7bfeeqv7/v79+7sRe130+Bot1pLNKu1WwFcptkbrtZ0yoEcDo8prKg1/5513XHD1Mp/uS8s6K+Qu+v9tzjrrrGCDtFAacf7oo4/c58qO+l7lSBk2bFiwWiC3y/6mPu+P5mPn1oS7qBRqpFvLeCkcq94+O+3wv/71LxfGdSbmoIMOck/2Y489lq/7HjBggKWkpLjSDIVnLQWmF5XO9oie1NAygeeff94d/HPOOSfL/dx3333u7A0AAACA2KOAtjctM98l5d+9tyTPbTQC3ujgWq7UXNW0e9MyLH1PhpUtmzMIlovfV1IcKR07drR77rnHfa4BRU2TVQjX0smiLKSco3Lwo446yo0mK3BrzrJHg44KrBr0bNOmTY7HUB5S0NXApG5XyfVJJ53kcpPylAKr5iprlDp0dF6Vynp+tBSz9xy89tprLvspPOuEgGhEW/ugUWyNoD/44IMu/z300EMuOKvpmB6/adOmbnuN7oejEX8v9CYmJrrH0eNrvrTmWysf5qVBgwZWWCov17SAzz//3HwXujXB3TvrEo5GphWcPTqIBWmSrqH93Ib3sy9XpnIEAAAAACWLAvd//v1Nkd2fRrxfvvnbfG175ZPHWfkKeTdJOxChPagUOjVQGRpKvQHH5OTkYAMwlX6Hmx+uJmnhQreqjVU6rbL0b7/91gXMgQMHujCtQc3c5krrsVTRrJHu7A3F9FihJw5CV39SqFe1sUrTdZsao+ln6tevnwvqCvte+Xh+KYznVj5/oPS8nH766e7khHciwVeh+4gjjnAj2aeddlqOMxY6G6P5B0lJScHrVFLQqFGjA99bAAAAAIhx2RtweY26Qr8Wr6GYwuypp57qptaGC9d5ad++vbto6bKrr77azc/Wcsy59dvSY6nPVrglzurUqZOvn08nEtS9X0F/4sSJLh/efffdbglodVDPL5WX65KXhQsXWpMmTfJ9n9736KSAmqh5FQe+C9160nSQVOKgMxpeIzWdEdHZFLXD1/xu74yIRqezl38DAAAAQG5U4q0R5/xYt3SLffbMvP1ud8r1Ha1B633ly9u3b7Nq1aqHHfHVY/tJ586d3bxnlYqr03ZhtWvXLliZ7JWIq2t89sdSybVKvfNa5kwj4urjpRJ10fxxjcSr5N07caAVrI4++mhXLq8ycy1NFrp8s8drvpZ9XyJRXv7rr7+6+fEa9Vcz7uJQrrDlEL/88oube6CO4T/++KO7Xk+kzqDcfvvtwZFtLRum1uwAAAAAkF9u9DefJd6N29VyXcqzN1ELVbVmBbfdvjndZazcnjh3/9FeLis/rrvuOtdsWs3JlLVUdq0Bz3fffdeVi4dbL1zN2RRIFTCVzTTPWl3SNVqtgVNRiFeeUwMzlbirA7tWp1I/LpVea562vlfN2NQoLTTnqa+WOqNrpFhTflWmrSnCej41oq1GayrbTkxMdF9r+vEhhxwS9udTjtTx/uyzz9y8c2+J54KWl6v/l9bm1kcFeK3XLRok1gkBlZTr+VDJu8K/eoiJnr/8juIXRqFfYTqAGs3WAdJoti76XNdRSg4AAACguChIa1mwvBxzXusc63XHCmUvdRFXkFSQ1RTfm266yTUdy+2kQZ8+fdzos7qia8732Wef7QZEFYYVsEWN29q2beuWXVbo1GNonrbmgKtkW43QFJQVrpX3Qke+VZ7dunVr69GjhxuN1tRjr5G1ttN9KEC3adPGBfPHH388yxJooRo2bOg6nw8ePNjNZ1dH98LQiLqqsXUCQGXy+tzr+O4tY6bwr2ZxKsv3Lpo+HUllAgXpcBaGN1leVEoQrcXfC0td8XRGR63i8yqfiBa17B8/frx7weZ38XUUH46Pv3F8/I3j438cI3/j+Pgbx6fgFOpWrFjh5vwqHBbVOt0a4VbgDl2n2+uOrb//Y2Gk22+yrz1e1DJ9dHzyel3mN0sWekKASspVXvD9998HJ/h7C6c/+uij7mwJAAAAABQXBevmHevY+qVbbOe2PValegWr3zohZke4UTIUKnSrJr9nz55uwrvW5PZq89WlXAujq8RAzdNCO5gDAAAAQKQpYDdsW7ClqQDfhW61e1fdvUa5QxdSF9Xxq0OdtlGbeAAAAABAyTFmzJho70JMKVvYkW61b88euEUT37XemSbtAwAAAABQmhUqdGvu9t69e3O9XV31oj3hHQAAAACAaCtUMu7evbs9++yzbr227LQm2nPPPedKzAEAAACgIA5wcSXAd6/HQs3pHjp0qGuWdvDBB9uZZ57p1l4TrdM9duxYK1eunA0bNuyAdw4AAABA6eAtrZaammqVKlWK9u4AwdejHMjSf4UK3VpgXPO61Sxt3LhxwR3RQur9+/e3hx9+2Nq1a1fonQIAAABQusTFxVlCQoIlJycHs0WZMpFZ6ktLHqelpbk1mJkW6z+ZPjg+GuFWztXrUa9LvT4Lq9DrdCtUf/LJJ+4JSUlJcdfVqVPHPSk7d+60devWWYMGDQq9YwAAAABKF69Rsxe8Ixmodu3a5UbUIxXsUTKOT0JCQtgG4sUSuj0K2epYHmr06NE2ZMgQ11ANAAAAAPJDAat+/fqWmJho6enpEXsc3fe3337rpsweSNkwSvbxKV++/AGNcBdZ6AYAAACAoqSgUxRhJ6/712pMFStWJHT7UFwJOz5MYAAAAAAAIEII3QAAAAAARAihGwAAAACACMn3nO45c+bk+07VuRwAAAAAgNIu36G7a9eu+W7Xrhbv0W7tDgAAAABAzITu1157LbJ7AgAAAABAaQ3dAwcOjOyeAAAAAABQwtBIDQAAAACACCF0AwAAAAAQIYRuAAAAAAAihNANAAAAAECEELoBAAAAAIgQQjcAAAAAABFC6AYAAAAAIEII3QAAAAAARAihGwAAAACACCF0AwAAAAAQIYRuAAAAAAAihNANAAAAAECEELoBAAAAAIgQQjcAAAAAABFC6AYAAAAAIEII3QAAAAAARAihGwAAAACACCF0AwAAAAAQIYRuAAAAAAAihNANAAAAAECEELoBAAAAAIgQQjcAAAAAABFC6AYAAAAAIEII3QAAAAAARAihGwAAAACACCF0AwAAAAAQIYRuAAAAAAAihNANAAAAAECEELoBAAAAAIgQQjcAAAAAABFC6AYAAAAAIEII3QAAAAAARAihGwAAAACACCF0AwAAAAAQIYRuAAAAAAAihNANAAAAAECEELoBAAAAAIgQQjcAAAAAABFC6AYAAACKUEZmhs3eONvmpc1zH/U1gNKrXLR3AAAAACgpJq+abMNnDbeNqRvd1x9M+cDqVq5rg5MGW5+mfaK9ewCigJFuAAAAoIgC96Cpg4KB25Ocmuyu1+0ASh9CNwAAAHCAVEKuEe6ABXLc5l03YtYISs2BUojycgAAAOAAzUmek2OEO3vw3pC6wf7x2T+sbpW6VqlcpeClcvnKWb7O6/rK5SpbxXIVrWwZxs6AWEHoBgAAAA7AHzv+sPcXv5+vbX/b/Ju7HKhwIT00mFcqn8v13tflw99GoAeKHqEbAAAAKKBNuzbZlyu/tC9WfGHzUubl+/uu6nCV1a9S33bt3ZXjkpqemvXrvVm/1sWT/euilGdYDwnsOa7fz8i9LmXKlInIPgN+RugGAAAA8mF72nbXDE1Be+aGmZYZyHTXl7EydkTdI9wI9ra0bWG/V9uoi/k1Ha+xuLJxhXp8Pd7uvbvDB/P0MCE+NLSn5x3mox7o8wjy+Sm/rxhXkUAP3yJ0AwAAALlQyP1m7TcuaH+79ltLz0wP3nZY7cPspOYnWb9m/axO5TrB7uUS2lBNgVvuSLqj0IFbVPatoKlLUfMCfdhAnp57UA83Qp/9+t0ZuyMe6PUcqzR+f/Phvc8rlK1gK/assLTlaVa1QtU8y+8J9DhQhG4AAAAghIL1jHUzbPyK8fbV6q9c4PS0rNHSTmpxkp3Y7ERrXL1xlu/TOtyjeo7Ksk63aIRbgdvP63QXd6DfX1DP721eoNdJjsIE+s9nfp6vQB+uvH5/I/P5Kb+vEFeBQJ+NOvzP3jjb5qXNs8SNiZbUIOmATlb5AaEbAAAApZ6C4ZyNc9yI9sRVE23Lni3B2xpWbWj9m/W3E5ufaG1qtskzJClY92rcy2atm2WTpk+yvt36lojQ4NdAr4Cm4J3biHxu5fc70nbY72t+t4Q6CbYnc0/Y8vs9GXuCgV7XhZ58KcrnRiPpBe1kHxroc/ueWAz0k1dNznLS6oMpH7iTVoOTBvv6pNX+ELoBAABQKgUCAVv01yIXtHUJHZ2uVbFWMGh3rNOxQOFFAbtr3a6WHJ/sPpbmwB1pem6rlK1iVcpXMauU/+9LT0+38X+Nt5N6nmTly5cvUKDPUWqfR/l9biP3XqDXyZ5IBvpCd7gvn3OkPvS2+LLxRR7oJ///9Izsa90npya761VFEqvBm9ANAACAUmXF1hXBoL1y28rg9dXKV7PeTXu7oJ1UL8nKleVP5dKssIE+PxTow4Z0hfdChPjQEf20zLRgoN+ZvtNdIhnow5bR59Xhvvzf13sf4+PibejMoTkCt+g6lfiPmDXCVZHE4kks/icBAABAibdh5wabsGKCm6et0W2PSnCPa3Scm6d9TMNj3NdApCk4Vo2v6i5FbW/m3ixd7rOX2GeZW59L+X1uDfWKI9CHo+C9IXWDzUmeY0fUO8JiDaEbAAAAJdLm3Ztt0qpJ9vnvn7s/1j3lypSzbg26uRHt45scv28kEyghVKERyUAfttFdHvPpU/PRHE/hPSOQsd/HT0lNsVhE6AYAAECJoT/e1XFcI9rqQL43sDd4W5e6XdwSX32b9rWaFWtGdT+BWA301eKruUtR+nHDj3bZl5ftdzstzReLCN0AAACIaWpK9f3a713Q1praXpMqOaTWIS5o92/e3+pVqRfV/QQQXufEzq5LuZqmhZvXrTndul3bxSJCNwAAAGKOylxnrZ/lgvaU1VNsR/qO4G3NqjdzQVvl481qNIvqfgLI3xx3LQumLuUK2KHBW1+L1rqPxSZqQugGAABAzCzxNS9lngvaX6780v7a/VfwNo2CKWTrotHtWFufGCjt+jTt45YFC12n23tvK3DH6nJhvgzdzz77rD322GO2YcMG69ixoz399NOWlJQUdttff/3VhgwZYj/99JOtWrXKnnjiCbvpppuKfZ8BAAAQuaC9ZPOS4BJf63auC96WUCHBTmh6gus83imxk1vGCEDs6tO0j1sWbNa6WTZp+iTr262vJTVIitkRbl+G7vfee88GDRpkL7zwgh155JE2evRo69evny1evNgSExNzbJ+ammotWrSwc889126++eao7DMAAACK3ppta9yItoL28q3Lg9drXd/eTfatpX1Ug6OsfNnyUd1PAEUrrmycda3b1ZLjk93HWA/cvgvdo0aNsiuuuMIuvfRS97XC9+eff26vvvqqDR48OMf2RxxxhLtIuNsBAAAQO7Qc0ISVE1zQ/mXTL8HrFax7NOrhgrbW1K5YrmJU9xMAYjJ0p6WluTLxO++8M3hd2bJlrU+fPjZ9+vQie5w9e/a4i2fbtm3uY3p6urv4jbdPftw3cHz8juPjbxwf/+MY+VtJOT7b0ra5RmhfrPrCftr4U7CBkkrFk+omWf9m/a1Xo15/L1EUiI2fuaQcn5KK4+Nv6TFyfPK7f74J3Zs2bbKMjAyrW7duluv19W+//VZkjzNs2DB74IEHclw/ceJEq1y5svnVpEmTor0LyAPHx984Pv7G8fE/jpG/xeLxSQuk2aL0RfZL2i+2dO9Sy7CM4G1N4ppYh/gO1r58e6u6u6rZb2bf/fadxapYPD6lCcfH3yb5/PhounNMhe7iopF0zRsPHelu3LixnXDCCVa9enXz49kTvdj69u1r5cszZ8lvOD7+xvHxN46P/3GM/C3Wjk96RrpNWz/Nvlz1pU1dO9V2Z+wO3tY6obX1b9rf+jXtZw2qNrCSINaOT2nD8fG39Bg5Pl7VdMyE7tq1a1tcXJxt3Ph3e3jR1/Xq1Suyx6lQoYK7ZKeD6ecD6vf9K+04Pv7G8fE3jo//cYz8zc/HJyMzw5WMqyHapFWTXCm5p1HVRq7ruNbTbpnQ0koqPx8fcHz8rrzPj09+9803oTs+Pt66dOliU6ZMsTPOOMNdl5mZ6b6+/vrro717AAAAyOcSXws2LQiupZ2yKyV4W51Kdaxfs34uaLev3Z61tAGUCr4J3aKy74EDB1rXrl3d2txaMmznzp3BbuYXX3yxNWzY0M3L9pqvLVy4MPj5H3/8YXPnzrWqVataq1atovqzAIj+6MrsjbNtXto8S9yYWCLWeAQAP1u+ZXlwia8129cEr68eX936Nu3rgnaXul34vxhAqeOr0D1gwABLSUmxIUOG2IYNG+zwww+3CRMmBJurrV692nU096xbt846deoU/HrkyJHuctxxx9nUqVOj8jMAiL7Jqybb8FnDbWPqvukqH0z5wOpWrmuDkwZbn6Z9or17AFBirNuxzoVshe0lm5cEr69UrpL1bNzTBe2jGxxt5eP8Wx4KAKUqdItKyXMrJ88epJs1a+ZKmAAgNHAPmjoouOSMJzk12V0/qucogjcAHIBNuzbZxJUTXdiemzI3eH25suXsmAbHuLW0Fbgrl/fvqjAAUKpDNwAcSEm5RrizB27RdWWsjI2YNcJ6Ne5FeSMAFMD2tO371tJe8YXNWD/DMgOZ7nr9v3pEvSNc0FYJeY0KNaK9qwDgO4RuACXGnOQ5wZLycBS8N6RucNvpj0QAQO52791t36z9xgXt79Z+Z2mZacHbDqt9mAvaaoqWWDkxqvsJAH5H6AYQ0zTFZOW2lW5JmnHLx+Xre1JS/+6kCwD4W3pmus1YN8MF7a/WfGU703cGb2tZo6UL2ro0qd4kqvsJALGE0A0gpqikcenmpa4zuYK2Ln/t/qtA91Gncp2I7R8AxOL/qz8n/+yCtuZqb96zOXhbgyoNrH/z/q4hWpuabVjiCwAKgdANwPejLov+XBQM2CoN19zCUPFl461DnQ7WKbGTfbjkwyx/MIbz1sK3rHG1xlavSr0I7z0A+LdK6Le/fnNdxyesnGAbdm4I3larYq3gWtod63QkaAPAASJ0A/DdHMJfNv0SDNnzUubZrr27smxTuVxlF7C13qsu7Wu3t/i4eHdbu4PauS7lEq6hWlkra1PWTLFp66fZNR2vsX+2+6eVL8tSNgBKh5VbVwaX+NLUHE/V8lWtd5PeLmgn1U9yncgBAEWD/1EBRJXmC85NnhsM2QrcGt0OpW64nRM7u4DdtW5Xa1urba5/EGo5MC0LFrpOt9SrXM/uSLrDzUN8eMbDrpRy1E+j3Dzwe466x903AJREGsX+cuWX9vnvn9uivxYFr68QV8F6NOphJzc/2Y5pdIz7GgBQ9AjdAIrV5t2bXYm4F7JV3ugtPeOpU6mOC9ed6+4L2i0TWlrZMmXz/RgK3loWbNa6WTZp+iTr262vJTVICi4TNqb/GBe2R80eZcu2LLNLJlxip7U8zQZ1GWQHVTqoyH9mAIjG/7WTVk1yI9pzNs4JVv7ElYmzbg26uRFt/T9ZNb5qtHcVAEo8QjeAiEpOTQ4GbF0UcrNrVLVRsFRcYbtRtUYHPIdQAVv3lRyf7D6GrsutAH9GqzPcH5xPznnSzQNXCP96zdd2U+eb7OzWZ7OON4CYrBz6avVXrnx8+rrptjewN3ibqoUUtPs26+vmbAMAig+hG0CRNuZZu2NtlpC9ZvuaHNtp2RkvZGs0O1oNzVS2PqTbEDu91en2yIxHXNnlQzMesk+XfWp3H3W3HXrQoVHZLwDILwVrnTCcuGaifbPmG9udsTt42yG1DnHLe/Vv1t/qV60f1f0EgNKM0A3ggEL271t/d+HaW8JLI9uhNKrctmbb4Ch2p7qdfDfKou68b5/8tr23+D175udn3LzyCz6/wAa0HWDXd7reqsdXj/YuAkDQ3sy9NmvDLPt8+ec2cetE2/3d30G7WfVmwbW0m9doHtX9BADsQ+gGkG8ZmRm2ePPiv5fv2jgnx/JcanDW/qD2wZHswxMPt2rx1czvtN8XHnKhndD0BBs5e6SbB/nOb++4NWtvPeJW12iIZXMARPMkp1ZzUOm4mqL9ufvP4G2JlRL3Be0WJ1q7Wu34vwoAfIbQDSBXaRlp9uufvwZDtjp+a85gqIpxFd1IsReyD6tzmFUqV8liVZ3KdWxEjxF2VuuzXJdzLalz53d32sdLP7Z7jrzHWiS0iPYuAihFlmxeYuN/37eW9h87/ghen1AhwXo37m0JGxLsmlOvsQrxdB4HAL8idAMISk1Ptfmb5gdD9vyU+bYnY0+WbbSWq9dVXBeNqpSPK3nrXB9Z/0j76LSP7I2Fb9iL8160Hzf8aGf/72wb2G6gXdnhSqtcvnK0dxFACaVeGBrR1iW0+WTlcpXt+CbHu1FtdSC3DLPx48cXaHUHAEDxI3QDpdi2tG1ujWxvPvbCTQuzdLsVzb/2ArYurRNal5rO3vFx8favw/7lmhBp3e9v1n5jryx4xZWeD04a7P74BYCikJKa4srGFbR18tNTvmx5O7bhsa50/LhGx2WpJErPSI/S3gIACoLQDZQif+76M8sa2Yv/Whxcu9VTt3Jd61qvazBkN6/evNTPD9QSZs/0fsa+Xv21DZs1zNbvXG///vrf1rNRTxt85GBrWLVhtHcRQAzaumerTV412QXtHzf+aJmBTHe9Rq6T6iW5Jb56N+1NM0cAiHGEbqAE27BzQ3AUW5cVW1fk2KZp9aZZRrIbVGlQ6kN2bno16eXKzl/65SUb8+sYm7p2qs1YP8OVmw88dKAbGQeA/U3jUdWMKma+/+N714nco/4YKh3v16yf1a5UO6r7CQAoOoRuoAR1tl29fXWWNbJDm+54WtdsbV0Su1iXel3cRzUOQ/5pLve/O//bTm1xqj0y8xG3bM9TPz9l45aPc2t7H1X/qGjvIgCfURn4tHXTXNDWmtq79u7K8n+yRrQ1jUVVNQCAkofQDcQolSEu3bw0S7n4pl2bsmwTVybODql1SHAUWw3QalSoEbV9LknUxfzlE162z1d8biN/HOm6nF8x8Qo3SnVb19s4mQGUclpiUf8vK2hPXj3ZlZJ7NCVFQVuXVjVbRXU/AQCRR+gGYkR6Zrr99udvf6+RnTzHNUILFV823i3ZFVwju87hdNmOIJXhn9LiFOvRqIc98/Mz9t7i99zczO/WfmfXd7reBrQd4Nb/BlB6Ko60zKKC9pcrvrTkXcnB21QurtFsnZg7rPZhTOMBgFKEvwYBn9JSXb+k/BIM2XNT5mYpSRR1se2U2CkYstvXbm8V4lirtbipydFdR95lp7c63R6e/rAt+HOB63Y+dtlYu+eoe6xDnQ7R3kUAEfT7lt9d0NZJN03z8VSLr2Z9m/Z1I9pd63YtNSs/AACyInQDPrEzfafNS54XbHz2y6Zf3Oh29nCnEnH98aaQ3bZWW7ecDPzh0IMOtTdPetM+WvqRjZ4z2hb9tcj+Of6fdnabs+2mzjdR2g+UIOt2rAuupb148+Lg9RXjKlqvxr3ciPbRDY+mwSIAgNANRIvm983Z+Pd8bAW0jEBGlm1UjhjaWbxVQiu3lAz8SyNZ57U9z3o36W2jfhrlGqx9uORDm7Jqit3c5WY3Gs4xBGJ32cWJqya6oP1z8s/B68uVKecCtoK2AjfTegAAoQjdQDFJSU2xn5J/sp82/OQ+qgladmquExqym1Rrwry/GHVQpYPskWMesTNbnem6nC/bssyGTBtiny771HU5b1OzTbR3EUA+7EjbYVNWT3Hl4zPXzwyeHC1jZaxrva4uaPdt0tcSKiZEe1cBAD5F6AYi1ExHy3WFLt8VOs/P07xG879DdmIXq1+1flT2F5GjP8rfP/V9e2vhW/bcvOdcA7zz/nee/fOQf9o1h19jVcpXifYuAshm997d9u3ab92Itj6mZaYFb2t/UPvgWtp1q9SN6n4CAGIDoRsoopCtRjrefGxdNqZuzLKNRkUOrnVwcOmuzomd3WgoSj7Nu7+k/SXWv3l/GzFrhFs+6PWFr9sXK7+wO464wzVaoqIBiC710NBItoK2RrbVZ8PTokYLF7R1aVq9aVT3EwAQewjdQCHXX12yeYnNWjfLxu8cb49//Lht3rM5yzaa43do7UP/Xr4r8XDXCA2lV70q9eyJXk+4kbNhM4fZ2h1r7ZZvbnFzQe9KusuaVG8S7V0ESpXMQKbNTZ7rSscnrpyY5f/x+lXquxNlJzc/2U0H4cQYAKCwCN1APqRnpLu1V71RbDXQ2ZG+I8s2WqqrY52OwZCtdVhppoNwtK53Ur0ke2XBK/bKL6/YD3/8YGeOPdP+ddi/7LLDLmPZNyDClUm//fXbvs7jK7+wDTs3BG+rVbGWndD0BDupxUnu/3OaHgIAigKhGwhD62GHrpE9L2We7c7YnWUbzcU9vPbhVnlzZbvg2AusQ90OLA2DfKtYrqJdd/h1dkqLU+yRGY/Y9PXT3Zzv//3+P7fm9zENj4n2LgIlyqptq4Jraa/YuiLL/+VabUBraR9Z/0grV5Y/jQAARYvfLICZbU/b7koMvZC94M8Ftjdzb5ZtEiokZOks3rZmW8vMyLTx48e7EZHycayXjYLT/NAX+77oliF6dNajtmb7Grtm8jVunvftR9zuStIBFI5Gsb9c+aUL2wv/XBi8Pr5svB3X+DgXtI9tdCzVJQCAiCJ0o1T6a/dfWdbIXrx5sZvbFyqxcqIL113rdnUf1Ugn+5w+hW7gQOl1pU7IRzc42o12v73obZu0apIrO7/28GvtgkMucM3YAOzflt1bgmtp6//3gAXc9XFl4uyoBke5oH184+OtanzVaO8qAKCUIHSj1Ix2hC7f9fvW33NsozWx1VXcG8luVLURjXNQrBQCNLp9esvT7aEZD7lpDSNnj7Sxy8faPUfe416fAHJKTU+1r9Z85YL2tD+m2d7A35VKWilCXcdPaHaCm7MNAEBxI3SjRDbJUYmuwrW3hJfWzM6uVUKr4Ei2woxGtgE/aFurrb1x4hs2dtlYG/XTKFu6eakNnDDQzmh1ht3c5WaCA2BmaRlp9t0f37mg/c2ab7L03dDyjBrR7t+sv9WvWj+q+wkAAKEbMU9l4cu3LM8ykp2yKyXLNupAe0itQ4Kj2Br5SKiYELV9BvZHr9kzW59pvRr3stFzRttHSz+yT5d9al+t/spu6nKTnd36bDoro1Qu1zhrwywXtCevmmzb07dn6Y/graWt6UAAAPgFoTtGQqVGbDenbbY6leu4wBhXNs5KKzU4W/zX4uAo9pzkObZ1z9Ys22j+q5bs8kK2Gp0xfw+xSCeH7u9+vxvlfnjGw67/wIPTH7RPl35q9xx1jx1y0CHR3kUg4tVL8zfNd0F7wooJ9ufuP4O3qUJJo9la4qtdrXZMCQIA+BKh2+emrJliI7eNtG1TtgWvq1u5rg1OGmx9mvax0mBPxh5bsGlBsPGZ1shO3ZuaZZtK5SrlWCNbSzIBJcXhiYfbu6e8a+/+9q49M/cZF0L+8fk/7B9t/2HXd7reqsVXi/YuAkVK0yq8Jb5CpwjVqFDDraWtEW39f0/FBwDA7wjdPqbSudu/uz3YedWTnJpsg6YOslE9R5XI4K2GOHNT/l6+S+tlp2WmZdlGAUMj/l7I1mgf3Z1R0mn94H+2+6drCDXyx5H2xcov7O3f3nadmm/repsLIYz0IZapH4dGsxW2l21ZluXE6vFNjnfztLvV78YSjQCAmELo9vG8teGzhucI3KLrylgZGzFrhJvvGeul5ioN1+i1F7K1lmpGICPLNmoc5S3dpUvrmq0Z3UCppZLaR4971M35HjpzqK3cttLu+O4O+3jpx3bXUXcxnxUxZdOuTfvW0v59vKvg8OhE6jENj3FBW2tqK3gDABCLCN0+pXnKG1M35nq7gveG1A1uuyPqHWGx9gdWaNMzlRBmP7nQoEqDYMDWRQ1yGMEDsurWoJt9dNpH9tqC1+ylX16ymRtm2tnjzrZLD73UruhwBSEFvj7ZOmX1FDei/eOGH13vEtHJ1KR6SS5o927a26rHV4/2rgIAcMAI3T6Vkpq1+3ZuVGrud+t2rMsSsjUql12z6s2yhOwGVRtEZV+BWBMfF29XdbzKNZIaNnOYW0JJAVxh5s6kO90IIeAHu/buckt76bX5/R/fW3pmevC2DnU6uKDdr1k/q12pdlT3EwCAokbo9il1Kc+P5+Y+ZxXiKri5bn4ot1aXWYXq0JC9fuf6LNuoNL5NzTZ/L99VtzN/ZAEHqHG1xvZs72ftqzVfuakpajx1/VfXuykoarzIiSxEQ3pGuk1fP90+//1z+3rN1y54e1oltNq3lnbz/u71CwBASUXo9ik1CVOXco1kh5vX7Vm9fbXdPPVma1mjpSsn1SiBmi0V59xzNbvxlu/S5a/df2XZJq5MnB160KHBkK0uzOo+C6BoaQpG7ya9XaOpF+a/YP/99b8u6ExfN92Nhg9sN5AGVIg4lYrrd4FGtCetmpRlSceGVRu6oK2mf+rNAQBAaUDo9ik1R9PolLqUZ6eRYnnw6Addp9e3F71ty7cut8HfDXYj3/867F92SotTIvLHtcoB1ejMC9g/b/zZtqdvz7JNfNl4VyoYukZ25fKVi3xfAISn99ugLoPstBan2cMzH3bv1SfnPGnjlo+ze468x5LqJ0V7F1HCqMpJvxsUtNV9PHnX31OfDqp4kBvNVtDuULsD/TkAAKUOodvHtBzYo8c+ag99/5BtC2Rdp/uOpDuCy4UNPHSgW7v3vwv/60a+h0wbYs/Pe94ubX+pndX6LFd+HjoyreZrmjOuEnaNqOfV/Xz33t32y6ZfgiPZ81PmZykPlMrlKlunup1cd3HdX/va7d08UwDR1apmK3ut32v22e+f2cjZI23F1hV2+cTL7eQWJ9utXW9lWgfypN8X+r9/Xto8S9yYaEkNknL8vvh9y+/BtbT1+8dTrXw19ztKvQaOqHtEzK+yAQDAgSB0+1zvxr1tV/VdVq9rPductjlsUFZ31ys7XGn/POSf9sGSD2zMr2PcPGotJfSf+f+xSw69xM5tc65NWzfNzfUM7YquAK8RdS/A70jbkXWN7E2/2N7MvVn2SaXhXRL/v+lZvS7WtmbbYi1pB5B/GlU8teWp1qNRD3v656ft/cXvu/m136751m7ofIOd1+Y8AhFymLxqcpbfFx9M+SD4+0LThbRGvIL2b3/9FvyeinEVrWfjnm5EW0t9cfIVAIB9SEoxQA3SNIpcvnz5/ZaUatR7QNsB9smyT+zVBa/ahp0b3AiXys5T96bm+B79QaU54cc1Os5SdqW4P6C8pVs8dSrVybJGdouEFr5o2gYg/3Sy7J6j7rEzWp1hD814yJUC68TcJ0s/sXuPutcOq3NYtHcRPgrcmtqUvZ+I9/siVLky5ax7w+4uaB/f+HimEgEAEAahuwSqWK6inX/w+XZO63NcWalGu9fuWJvn93yz9pvg542qNgoGbIXtRtUaMQcPKCE0/ePtk952VTFPzXnKFv21yC4cf6Grhrmx8400OSzlVFKuEe68GniKqugLZp4AAB+ESURBVJ1Obnmy9W3S1xIqJhTb/gEAEIsI3SWYGqmd2fpMq1+lvl0x6Yr9bn/lYVfauW3PtXpV6hXL/gGIDpWT/+Pgf7hpJaNmj7L//f4/e3/J+zZ59WS7pestdmqLUznRVooaoGk60tLNS23plqU2Y92MLFOQcnNdp+vsiHpHFMs+AgAQ6wjdpUD2Jbxy0zKhJYEbKEXUSG3osUPdybmHZzxsv2/93e7+/m77aMlHrhSdJZ1Kli27t7hgvWTzErfUo4K2Pu5M31ng+1IzTgAAkD+E7lJAzdeKcjsAJYtGLD889UP776L/2gvzXnArHJz3v/PsonYX2dUdr2aebozRChPqKh4arhW2N+3aFHZ7zctuVqOZO8lSKa6Sfbzs4/0+Br8vAADIP0J3KaBu5+o6m5yaHHaentb91u3aDkDpnY5yWfvL7MRmJ9qIH0fYlNVT7LVfX3PLQaljde8mvSk59xmtLLF622oXqL1Ra31cs31NrnOyG1ZtaK0TWruA3SqhlfvYrHozd/y9Od0/rPuB3xcAABQhQncpmb+pP5rVjVZ/MIX+IaWvRet+s2wQgPpV69voXqPtmzXf2LBZw+yPHX+4jtVaAuqupLuscfXG0d7FUjnvWvOsvRFrL2BrNDstMy3s99SsUNMFandJaO3WbFfIrlK+Sp6Pxe8LAACKHqG7lHANk3qOCrtOt/6A8tbpBgA5rvFxllQ/yV7+5WW3/OD3f3xvZ4470/512L/s0vaXWoW4CtHexRJp656tWUatFbKXbV5m29O3h92+UrlKLkx7o9beCLbm6xcWvy8AAChahO5SRH8o9Wrcy83XVBMczclTiSAjFgByC3Q3dLrBTmlxij0y8xGbuX6mPTv3WbcU4V1H3mXdG3SP9i7GrN17d7vGdVkC9uallrwrOez2cWXiXBl4aFm4LioXL1umbMR+X8xaN8smTZ9kfbv1taQGSfy+AACgEAjdpYz+YGKZFwAF0bxGc3up70s2YeUEe/THR23VtlV21aSrrF+zfnZb19usbpW60d5F39Icac2xzj7vevX21ZYZyAz7PVrmMbQsXB91DOLj4ov990XXul0tOT7ZfSRwAwBQOIRuAMB+qYnaic1PdHO7n5v7nL3929v25cov7bu139l1h19nFxxygZUrW65Uz7tW87HQsnB91Gj2now9Yb+nRoUawaZmXsjW0o3V4qsV+/4DAIDIKb1/IQEACkyBUPN6T291uj004yGbnzLfHpv9mI1dPtat7d0psZOVdNvStrl51grYWpbLG8HW9eFUjKvownSwLPz/g7bmXdMRHgCAko/QDQAosINrHWz/PfG/9vHSj+2Jn55w4fPiLy62M1udaTd3udlqVqxpsS4tIy047zq0PHzDzg1ht9fc6qbVmwbLwtsktHEfG1VtRGk2AAClGKEbAFAoCpnntDnHjm9yvI3+abR9suwTd/lqzVd2c+eb7czWZ0akyVck5l1raTSF6iVblrhRbIVsrYGdEcgI+z3q5B1aFq6PmndNV3cAAJAdoRsAcEBqVaxlDx79oAvZKjlXeL1/+v328bKP7d6j7nWj4n6Zd71p16bgqLU3cr18y3LbnbE713L64Lzr//+o0evq8dWLff8BAEBsInQDAIqE5nO/f8r79vait93SYprvPeCzAXbBwRe4ZmtV46sW277sSNuxr6lZtq7hW/ZsCbu9Rqhb1GiRo2t4YuVE5l0DAIADQugGABQZdTC/+NCL3XJiWl5s4qqJ9uaiN12n89uPuN1drxCrku7ZG2fbvLR5lrgxsdBrQKdnpO+bd71labAsXB/X7VwXdnuVuzep1iTLWtf6XNcx7xoAAEQCoRsAUOS0dvfjPR+3H/74wYbOHOrWpb7t29vso6UfWa/GvezVBa/axtSNbtsPpnzg5kgPThpsfZr2CXt/WtPam3cdXJZr81K3ZvjewN6w35NYKTEYqr2ArdHsiuUqRvRnBwAACEXoBgBEzNENj7aPT//YheyX579sM9bPcJfstMb1oKmDbFTPUXZ44uHBYB36cdfeXWEfo1r5asFycO+jArbWwQYAAIg2QjcAIKI0X/qajtfYic1OtLPHnW1pmWk5tglYwH1U8PY+z6582fJ/z7v+/xHsNjXbuFFy5l0DAAC/InQDAIpFyq6UsIE7lBe4s8+71uh1k+pN3JxxAACAWMJfLwCAYpGSmpKv7R7svm/5MQAAgJKgbLR3AABQOtSpXCdf2zWq1iji+wIAAFBcCN0AgGLRObHzvvnXFn7+ta6vV7me2w4AAKCkIHQDAIqF1sHWsmCSPXh7X9+RdAfrZQMAgBKF0A0AKDZah1vLgiVWTsxyvUbAdX1u63QDAADEKhqpAQCKlYJ1r8a9bNa6WTZp+iTr262vJTVIYoQbAACUSIRuAECxU8DuWrerJccnu48EbgAAUFJRXg4AAAAAQIQQugEAAAAAiBBCNwAAAAAAEULoBgAAAAAgQgjdAAAAAABECKEbAAAAAIAIIXTHgEDAbN3SLbbkxw32x+LNlpkZKPR96Xt1H0VxX4Cf6bWt903qunLuI691f+H4+B/HCCg83j9A4WWWwPePL9fpfvbZZ+2xxx6zDRs2WMeOHe3pp5+2pKSkXLf/4IMP7N5777WVK1da69atbcSIEXbSSSdZSbBi7ibbMLWKfTbhl+B1VRIq2LEDWlvLTokFuq/lPyfbd+8ttZ1b9hzwfQF+lvW1Xsk+m/cLr3Uf4fj4H8cIKDzeP0DhLS+h7x/fjXS/9957NmjQILvvvvtszpw5LnT369fPkpOTw24/bdo0O//88+3yyy+3n3/+2c444wx3WbBggZWEF92kVxZZxu4yWa7Xi3DCiwvc7QW5L31PaOAu7H0BfsZr3d84Pv7HMQIKj/cPUHjLS/D7x3cj3aNGjbIrrrjCLr30Uvf1Cy+8YJ9//rm9+uqrNnjw4BzbP/nkk9a/f3+77bbb3NcPPfSQTZo0yZ555hn3vbFKZRQ6y7NP1tDt0e2NDq5lZcuWycd9Lclzm/zeF7JKT8+wzL1m6XsyzDJ9dw6r1OG17m8cH//jGMUWfgf5C++f2ML7J/beP9+/v9Sad6wTk++fMoGAZgz7Q1pamlWuXNk+/PBDN1rtGThwoG3ZssXGjh2b43uaNGniRsZvuumm4HUaJf/0009t3rx5Obbfs2ePu3i2bdtmjRs3tk2bNln16tXNLzR/4bOn/i4pBwAAAIDS7JQbD7MGrRPML5Qla9eubVu3bs0zS/pqpFvBNyMjw+rWrZvlen3922+/hf0ezfsOt72uD2fYsGH2wAMP5Lh+4sSJLvD7hRoHaB4DAAAAAMBs2jezrPLSveYXqamp+drOV6G7ONx5551uZDz7SPcJJ5zgv5Huefsf6e5/9aFWv1WNPLdZv2yrTXjh1yK5L2SVnp5uX331lR1//PFWvnz5aO9Oqcdr3d84Pv7HMYot/A7yF94/sYX3T2y+f7ofl+S7ke6YC90amo+Li7ONGzdmuV5f16tXL+z36PqCbF+hQgV3yU5vNj+94RofXNt16sveSCBU1ZoVrHmHxP3Oa2jeoYJVSVhWJPeFrNLT46xsObPKVSv66vVTWvFa9zeOj/9xjGILv4P8hfdPbOH9E5vvn8YH1/bV+ye/rx1fdQ2Ij4+3Ll262JQpU4LXZWZmuq+7desW9nt0fej2okZquW0fK/RiUmv8fcJPuz/mvNb5etFlvS87oPsC/IzXur9xfPyPYwQUHu8foPDKlvD3j69Ct6j0+6WXXrLXX3/dFi1aZNdcc43t3Lkz2M384osvdiXinn//+982YcIEe/zxx9287/vvv99mz55t119/vcU6rUXX9/JDLK5iIMdZnv5XtS/QWnXaVt+j0fMDvS/Az3it+xvHx/84RkDh8f4BCq9lCX7/+Kq8XAYMGGApKSk2ZMgQ1wzt8MMPd6Haa5a2evVqK1v273MF3bt3t7ffftvuueceu+uuu6x169auc3n79u2tJGh+eG2r98dO69Smu+3ZmWFVqlew+q0TCnWWRy9Utdlfv3SL7dy254DuC/Az77W+5rdNruGG5v/4rRypNOP4+B/HCCg83j9A4bUsoe8f34Vu0Sh1biPVU6dOzXHdueee6y4lVZky5hoGFMV8E71gG7atWST7BfiZXut636jDpT7G+n/WJQ3Hx/84RkDh8f4BCq9sCXz/+K68HAAAAACAkoLQDQAAAABAhBC6AQAAAACIEEI3AAAAAAARQugGAAAAACBCCN0AAAAAAEQIoRsAAAAAgAghdAMAAAAAECGEbgAAAAAAIoTQDQAAAABAhBC6AQAAAACIEEI3AAAAAAARQugGAAAAACBCCN0AAAAAAEQIoRsAAAAAgAgpZ6VcIBBwH7dt22Z+lJ6ebqmpqW7/ypcvH+3dQTYcH3/j+Pgbx8f/OEb+xvHxN46Pv3F8/C09Ro6PlyG9TJmbUh+6t2/f7j42btw42rsCAAAAAIjBTFmjRo1cby8T2F8sL+EyMzNt3bp1Vq1aNStTpoz58eyJTgisWbPGqlevHu3dQTYcH3/j+Pgbx8f/OEb+xvHxN46Pv3F8/G1bjBwfRWkF7gYNGljZsrnP3C71I916cho1amR+pxebn19wpR3Hx984Pv7G8fE/jpG/cXz8jePjbxwff6seA8cnrxFuD43UAAAAAACIEEI3AAAAAAARQuj2uQoVKth9993nPsJ/OD7+xvHxN46P/3GM/I3j428cH3/j+PhbhRJ2fEp9IzUAAAAAACKFkW4AAAAAACKE0A0AAAAAQIQQugEAAAAAiBBCdzF79tlnrVmzZlaxYkU78sgjbdasWXlu/8EHH9jBBx/stj/ssMNs/PjxWW7XlPwhQ4ZY/fr1rVKlStanTx9bunRphH+Kkq2oj9Ell1xiZcqUyXLp379/hH+Kkqsgx+fXX3+1s88+222v53306NEHfJ8o3uNz//3353j/6P2GyB+fl156yY499lirWbOmu+j3S/bt+R3k7+PD75/oHqOPP/7YunbtagkJCValShU7/PDD7b///W+WbXgP+fv48B4qWs8W8u+td9991z33Z5xxRuy+f9RIDcXj3XffDcTHxwdeffXVwK+//hq44oorAgkJCYGNGzeG3f6HH34IxMXFBR599NHAwoULA/fcc0+gfPnygV9++SW4zfDhwwM1atQIfPrpp4F58+YFTjvttEDz5s0Du3btKsafrOSIxDEaOHBgoH///oH169cHL3/99Vcx/lSl9/jMmjUrcOuttwbeeeedQL169QJPPPHEAd8nivf43HfffYFDDz00y/snJSWlGH6akqegx+eCCy4IPPvss4Gff/45sGjRosAll1zift+sXbs2uA2/g/x9fPj9E91j9PXXXwc+/vhj9/fBsmXLAqNHj3Z/M0yYMCG4De8hfx8f3kNF591C/r21YsWKQMOGDQPHHnts4PTTT89yWyy9fwjdxSgpKSlw3XXXBb/OyMgINGjQIDBs2LCw25933nmBk08+Oct1Rx55ZOCqq65yn2dmZro/VB977LHg7Vu2bAlUqFDB/RGL6B8j7z/s7P9JoHiOT6imTZuGDXUHcp+I/PFR6O7YsWOR72tpdKCv9b179waqVasWeP31193X/A7y9/ERfv8UraL4fdGpUyd3gl54D/n7+Ajvoegen7179wa6d+8eePnll3Mci1h7/1BeXkzS0tLsp59+cmUPnrJly7qvp0+fHvZ7dH3o9tKvX7/g9itWrLANGzZk2aZGjRquXCO3+0TxHiPP1KlTLTEx0dq2bWvXXHON/fnnnxH6KUquwhyfaNxnaRXJ51KlYg0aNLAWLVrYhRdeaKtXry6CPS5diuL4pKamWnp6utWqVct9ze8gfx8fD79//HGMNNA1ZcoUW7x4sfXo0cNdx3vI38fHw3soesfnwQcfdM/95ZdfnuO2WHv/lIv2DpQWmzZtsoyMDKtbt26W6/X1b7/9FvZ79EIKt72u9273rsttG0T3GInm/px11lnWvHlzW758ud1111124oknuv8Q4uLiIvTTlDyFOT7RuM/SKlLPpX55jhkzxv2xs379envggQfcPNYFCxZYtWrVimDPS4eiOD533HGHO/nh/YHD7yB/Hx/h90/0j9HWrVutYcOGtmfPHvecP/fcc9a3b193G+8hfx8f4T0UvePz/fff2yuvvGJz584Ne3usvX8I3UCE/eMf/wh+rkZrHTp0sJYtW7ozp717947qvgF+pz9uPHrvKIQ3bdrU3n///bBnvhEZw4cPd41s9P+WGuAgNo4Pv3+iTycHFRp27NjhRlIHDRrkqnZ69uwZ7V1DPo4P76Ho2L59u1100UWuYWTt2rWtJKC8vJjoBaMzYhs3bsxyvb6uV69e2O/R9Xlt730syH2ieI9ROPrPXI+1bNmyItrz0qEwxyca91laFddzqS6zbdq04f1TjMdn5MiRLtRNnDjR/cHp4XeQv49POPz+Kf5jpBLaVq1auc7Yt9xyi51zzjk2bNgwdxvvIX8fn3B4DxXP8Vm+fLmtXLnSTj31VCtXrpy7vPHGGzZu3Dj3uW6PtfcPobuYxMfHW5cuXdxZNE9mZqb7ulu3bmG/R9eHbi+TJk0Kbq9SF72oQrfZtm2bzZw5M9f7RPEeo3DWrl3r5gNpeQNE9vhE4z5Lq+J6LjUaoV+2vH+K5/g8+uij9tBDD9mECRPc0jqh+B3k7+MTDr9/ov9/nL5HpczCe8jfxycc3kPFc3wOPvhg++WXX1wVgnc57bTTrFevXu7zxo0bx977J9qd3Epbq3x11BszZoxbnuDKK690rfI3bNjgbr/ooosCgwcPzrIcVbly5QIjR450y4Goi2+4JcN0H2PHjg3Mnz/fdfXza6v80niMtm/f7pZEmj59ulvyYPLkyYHOnTsHWrduHdi9e3fUfs7Scnz27NnjltPRpX79+u5Y6POlS5fm+z4R3eNzyy23BKZOnereP3q/9enTJ1C7du1AcnJyVH7G0nR89PtFy7t8+OGHWZbL0f9rodvwO8ifx4ffP9E/RkOHDg1MnDgxsHz5cre9/lbQ3wwvvfRScBveQ/49PryHont8sgvXST6W3j+E7mL29NNPB5o0aeJ+Uap1/owZM4K3HXfcce4FFer9998PtGnTxm2vtWo///zzLLerXf69994bqFu3rnsh9+7dO7B48eJi+3lKoqI8RqmpqYETTjghUKdOHRfGtSyS1iUk0BXP8dEvSZ1bzH7Rdvm9T0T3+AwYMMAFct2f1unU11pPFZE/Pvr/Ktzx0clFD7+D/Ht8+P0T/WN09913B1q1ahWoWLFioGbNmoFu3bq54BGK95B/jw/voej/jb2/0B1L758y+ifao+0AAAAAAJREzOkGAAAAACBCCN0AAAAAAEQIoRsAAAAAgAghdAMAAAAAECGEbgAAAAAAIoTQDQAAAABAhBC6AQAAAACIEEI3AAAAAAARQugGACCbMWPGWJkyZWz27NnF9pgrV650j6nHjoSpU6e6+9dHAABQfAjdAIBSF6a9S8WKFa1NmzZ2/fXX28aNG6O9e758jrJfZsyYYX50ySWXZNnPChUquGM7ZMgQ2717d6Huc+HChXb//fe7EyIAABRWuUJ/JwAAMerBBx+05s2buzD2/fff2/PPP2/jx4+3BQsWWOXKlaOyT02bNrVdu3ZZ+fLlzU/PUXatWrUyv1LQfvnll93nW7dutbFjx9pDDz1ky5cvt7feeqtQofuBBx6wnj17WrNmzSKwxwCA0oDQDQAodU488UTr2rWr+/xf//qXHXTQQTZq1CgX0s4///yo7JM38u7H5yi/9u7da5mZmRYfH5/jtp07d1qVKlUKvT+BQMCdJKlUqVKu25QrV87++c9/Br++9tprrXv37vbOO++441u3bt1CPz4AAIVFeTkAoNQ7/vjj3ccVK1ZkuX7Pnj02aNAgq1OnjguMZ555pqWkpARvHzhwoNWuXdvS09Nz3OcJJ5xgbdu2DX49adIkO+aYYywhIcGqVq3qbrvrrrv2O6f7t99+s/POO8/tgwKnvu/uu+8O3r5q1SoXLnW9btcJhHPPPTfiJdHe/o4cOdJGjx5tLVu2dCPNXkm2btPnF1xwgdWsWdP97F4w1+izt71GkPU86LkOpetPOeUU+/LLL13418/24osvFmgftQ96XAX233//vUDPmY6DrpNevXoFy9ZD58R/8cUXduyxx7rXRrVq1ezkk0+2X3/9tdDPKQCgZGKkGwBQ6qn8WBS+Qt1www0uMN53330ukClcav73e++9526/6KKL7I033nDBUAHRs2HDBvvqq6/c94mCmG7v0KGDK9tW2Fy2bJn98MMPee7X/PnzXahTyfmVV17pgqj29X//+5898sgjbpsff/zRpk2bZv/4xz+sUaNGbj9VLq+SaIXewpbLqzx706ZNWa5T6Mz+HL322mtuBFr7p5+rVq1awdsUWlu3bm1Dhw51wderLHj99dftnHPOsVtuucVmzpxpw4YNs0WLFtknn3yS5b4XL17sKg+uuuoqu+KKK7KcxMgvL0jrOHry85z16NHDbrzxRnvqqafcSYFDDjnEfa/38b///a876dKvXz8bMWKEpaamuvtQyP/5558pRwcA/C0AAEAp8dprryn5BSZPnhxISUkJrFmzJvDuu+8GDjrooEClSpUCa9euzbJdnz59ApmZmcHvv/nmmwNxcXGBLVu2uK8zMjICjRo1CgwYMCDL44waNSpQpkyZwO+//+6+fuKJJ9z96TFzs2LFCreNHtvTo0ePQLVq1QKrVq3Ksm3oPqWmpua4r+nTp7v7euONN4LXff311+46fczPcxTuUqFChRz7W7169UBycnKW+7jvvvvcbeeff36W6+fOneuu/9e//pXl+ltvvdVd/9VXXwWva9q0qbtuwoQJgfwYOHBgoEqVKu451mXZsmWBkSNHuuPQvn37Qj1nH3zwQdjnbPv27YGEhITAFVdckeX6DRs2BGrUqJHjegBA6UZ5OQCg1OnTp48r127cuLEb7VS5t0ZZGzZsmGU7jd5qdNejUeeMjAxXnixly5a1Cy+80MaNG2fbt28PbqemXZpL7DUiU0m5aM645jznh8rYv/32W7vsssusSZMmWW4L3afQOc4qc//zzz9dszM95pw5c6ywnn32WVcSH3pROXV2Z599tnsuw7n66quzfK1mdaKS/VAa8ZbPP/88y/V6/jSSnF+aN6590UXPwa233mpHH320e96L8jnTc7FlyxY3Cq9qAO8SFxdnRx55pH399df53mcAQMlHeTkAoNRRoNRyUmq8peZaKltWgM4ue9j1SpQ3b94cvO7iiy925cUK7fpcJdE//fSTvfDCC8FtBgwY4Lpqq7R68ODB1rt3bzvrrLNciXW4xxVvDnL79u3z/FnU8Vzl2Srz/uOPP4Jl3F6JeGElJSXlq5FauA7nud2mkxX6ebN3QK9Xr54LvN7JjPzcdzhqRKfSe1m7dq09+uijlpycnKP52oE+Z0uXLs3SCyC76tWrF2i/AQAlG6EbAFDq5DdQauQynNCQ1q5dO+vSpYu9+eabLnTro7p3q/mZR6FPo9YaAdVo7oQJE9y8cIW2iRMn5vo4+aF55wqPN910k3Xr1s1q1KjhRnU1gp/fUfUDkVc38dxuCx11Lux9h6PnUVUMHo2SH3zwwW5OuKoRiuo587bRvG6dMMhOJ3MAAPDwWwEAgAOksK2S6fXr19vbb7/tuliHNu4SjfBqhFsXLV+l5mLqQq4gHhoUPS1atHAftXZ4Xj788EPX0Ovxxx8PXqfGZip/9hutRa7AqpFiryGZbNy40e2vbi9K9evXt5tvvtmttT1jxgw76qijCvSc5XZyQJ3XJTExMeyxAwAgFHO6AQA4QJrbq4D273//25WFh64VLX/99VeO7zn88MPdx+xLZXk0L1kdtF999VVbvXp1riPtGt0N/VqefvppN/fcb0466ST3UV3gQ+kkhOhkRVHTqLa6kQ8fPrzAz5m3rnj2MK4RdJWQ68RJuOXiQpeVAwCAkW4AAA6QAnL//v3tgw8+cHOTs4dHLROm8nJdr9FczTN+7rnn3HJV3vrV4Wi5Kt3euXNn19RNc5y1vJVK1OfOneu20VJkKnNWibRK3adPn26TJ0/OsbRXQalpmtYIz04N4rxR+ILq2LGjG2H+z3/+44LscccdZ7NmzXJLiJ1xxhluPeyipufh0ksvdc+3liXTCHt+nzOdGFFA15x9zfXWkmiaEqARbi0PpiXjdGxUlq7XgE6O6NioedszzzxT5D8LACA2EboBACiiEvPPPvvMzeVWOAt12mmnubCsUWt1ua5du7YLnCp7VvDLK6SqLPree+91IU8l0ArtofPFn3zySRcM1TFdtyvwKUAWpOt3OEOGDAl7veZCFzZ0ixrK6fvHjBnjms9pTvSdd94ZXNM8ElT6r8Z2Cs963Pw+Z9o3fZ+arl1++eVuJFzTARS6L7jgAmvQoIEbQX/sscdcxYK636vDvUI+AACeMlo3LPgVAAAoFC1LpdFajWgreAEAAAihGwCAIqCSZZUvL1u2LN/duQEAQMlHeTkAAAfg3Xfftfnz57u5vCpbJnADAIBQjHQDAHAAFLKrVq1qAwYMcPN/WaMZAACE4i8DAAAOAOeuAQBAXlinGwAAAACACCF0AwAAAAAQIYRuAAAAAAAihNANAAAAAECEELoBAAAAAIgQQjcAAAAAABFC6AYAAAAAIEII3QAAAAAARAihGwAAAAAAi4z/A2GUxYKIyfCIAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "print(logical_errors)\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "for t, errors in logical_errors.items():\n",
+    "    plt.plot(physical_error_values, errors, marker='o', label=f'Time Steps t={t}')\n",
+    "\n",
+    "# Labels and title\n",
+    "plt.xlabel('Physical Error Rate', fontsize=12)\n",
+    "plt.ylabel('Logical Error Rate', fontsize=12)\n",
+    "plt.title('Rotated Surface Code(d=3): Logical v/s Physical Error Rates with varying Timesteps', fontsize=14)\n",
+    "plt.legend(title='TimeSteps')\n",
+    "plt.grid(True)\n",
+    "plt.tight_layout()\n",
+    "\n",
+    "# Save and show\n",
+    "plt.savefig('logical_vs_physical_timesteps.png', dpi=300)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "441f968d",
+   "metadata": {},
+   "source": [
+    "- The logical errors tend to decrease with increase in timesteps.\n",
+    "- The correction is better for values with t=(d>3), except for t=9 where it seems to have higher error rate."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "97ef9cd5",
+   "metadata": {},
+   "source": [
+    "### Visualization of matching graphs for error correction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "5b6788d9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p = 0.1\n",
+    "qubit = LogicalQubit(d=3, T=1)\n",
+    "qubit.encode(p//2, p//2)\n",
+    "qubit.decode(p//2, p//2)\n",
+    "qubit.decoder.graph_2D(qubit.decoder.S[X], \"distance\")\n",
+    "qubit.decoder.graph_2D(qubit.decoder.S[Z], \"distance\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4431403",
+   "metadata": {},
+   "source": [
+    "- The graphs shows the surfaces of stabilizer surfaces in 2D plane and their connection marking an event of detection. - The coordinates of the stabilizers are all factors of 0.5 as the data qubits lie between them.\n",
+    "- We use this matching graphs mapping the error detection zones to affected qubits to identify and correct errors\n",
+    "- The coordinates with -1 are virtual qubits which do not exits and are added to connect the boundaries for matching a concept of torus code\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "74d4ae6a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 2000x1400 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "p = 0.1\n",
+    "qubit = LogicalQubit(d=3, T=5)\n",
+    "qubit.encode(p//2, p//2)\n",
+    "qubit.decode(p//2, p//2)\n",
+    "\n",
+    "qubit.decoder.graph_3D(qubit.decoder.S[X], \"distance\")\n",
+    "# plt.show()\n",
+    "# qubit.decoder.graph_3D(qubit.decoder.S[Z], \"distance\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe401d48",
+   "metadata": {},
+   "source": [
+    "### Conclusion:\n",
+    "- Successfully implemented a logical qubit using the surface code in Q#.\n",
+    "\n",
+    "- Applied Minimum-Weight Perfect Matching (MWPM) to correct quantum errors effectively.\n",
+    "\n",
+    "- Visualized error syndromes, aiding in understanding and debugging the error correction process.\n",
+    "\n",
+    "- Conducted a comparative analysis of logical qubit measurement outcomes to assess correction performance.\n",
+    "\n",
+    "- Simulated error correction across varying error rates, demonstrating the robustness and limitations of the surface code under different noise conditions.\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f5e60fb",
+   "metadata": {},
+   "source": [
+    "### References: \n",
+    "https://www.nature.com/articles/s41586-022-05434-1 - d=3 Implementation <br/>\n",
+    "https://www.nature.com/articles/s41586-022-04566-8 - More on implementation <br/>\n",
+    "https://arxiv.org/html/2307.14989v4/#S5.F7 - Diagrams <br/>\n",
+    "https://arxiv.org/pdf/2409.14765 Core Rotated circuit comparision <br/>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12270a6c",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/logical_vs_physical_error_rates_d3.png b/logical_vs_physical_error_rates_d3.png
new file mode 100644
index 0000000..1a5f51c
Binary files /dev/null and b/logical_vs_physical_error_rates_d3.png differ
diff --git a/logical_vs_physical_timesteps.png b/logical_vs_physical_timesteps.png
new file mode 100644
index 0000000..8a1e544
Binary files /dev/null and b/logical_vs_physical_timesteps.png differ
diff --git a/output.png b/output.png
new file mode 100644
index 0000000..0222b61
Binary files /dev/null and b/output.png differ
diff --git a/qec-highlevel.png b/qec-highlevel.png
new file mode 100644
index 0000000..9e8120f
Binary files /dev/null and b/qec-highlevel.png differ
diff --git a/qsharp.json b/qsharp.json
new file mode 100644
index 0000000..9e26dfe
--- /dev/null
+++ b/qsharp.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..f56c92e
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,6 @@
+qsharp==1.15.0
+matplotlib
+qiskit==2.0.0
+matplotlib==3.10.1
+azure-quantum==3.1.0
+networkx
\ No newline at end of file
diff --git a/rotated_surface_code_measures.png b/rotated_surface_code_measures.png
new file mode 100644
index 0000000..3e4ae5e
Binary files /dev/null and b/rotated_surface_code_measures.png differ
diff --git a/src/RotatedSurfaceCode.qs b/src/RotatedSurfaceCode.qs
new file mode 100644
index 0000000..acf54f1
--- /dev/null
+++ b/src/RotatedSurfaceCode.qs
@@ -0,0 +1,252 @@
+import Std.ResourceEstimation.MeasurementCount;
+import Std.Arrays.ForEach;
+import Std.Diagnostics.ConfigurePauliNoise;
+
+import Std.Diagnostics.DumpMachine;
+import Std.Convert.IntAsDouble;
+import Std.Convert.DoubleAsStringWithPrecision;
+import Std.Diagnostics.DumpRegister;
+
+function validIndex(d: Int, index:Int): Bool {
+  if 0 <= index and index < d*d {
+    return true;
+  }
+  return false;
+}
+
+operation CorrectDataQubit(qubit: Qubit, theta1: Double, theta2: Double, theta3: Double) : Unit is Adj + Ctl {
+  // Applies the correction of on data qubit as unitary
+    Rz(theta1, qubit);
+    Ry(theta2, qubit);
+    Rz(theta3, qubit);
+}
+
+operation MeasureLogicalZ(d: Int, dataQubits: Qubit[]): Result {
+    // Logical Z is assumed to be a product of physical Zs on a vertical line
+    // Choose the first column: index i*d for i in 0..d-1
+    let results = MeasureEachZ(dataQubits);
+    mutable parity = Zero;
+    
+    for res in results {
+        if res == One {
+            set parity = if (parity == Zero) { One } else { Zero };
+        }
+    }
+    return parity;
+}
+operation MeasureLogicalZTopDown(d: Int, dataQubits: Qubit[]): Result {
+    // Logical Z is assumed to be a product of physical Zs on a vertical line
+    // Choose the first column: index i*d for i in 0..d-1
+    mutable parity = Zero;
+    
+    for i in 0..d-1 {
+        let index = i * d;
+        let res = M(dataQubits[index]);
+        
+        if res == One {
+            set parity = if (parity == Zero) { One } else { Zero };
+        }
+    }
+    return parity;
+}
+
+operation MeasureLogicalZAntiDiagonal(d: Int, dataQubits: Qubit[]): Result {
+    mutable parity = Zero;
+
+    for i in 0..d-1 {
+        let index = i * d + (d - 1 - i); // anti-diagonal index
+        let res = M(dataQubits[index]);
+
+        if res == One {
+            set parity = if (parity == Zero) { One } else { Zero };
+        }
+    }
+
+    return parity;
+}
+
+operation MeasureLogicalZLastRow(d: Int, dataQubits: Qubit[]): Result {
+    mutable parity = Zero;
+    let startIndex = (d - 1) * d;
+
+    for i in 0..d-1 {
+        let index = startIndex + i;
+        let res = M(dataQubits[index]);
+
+        if res == One {
+            set parity = if (parity == Zero) { One } else { Zero };
+        }
+    }
+
+    return parity;
+}
+
+  operation XStabilizer(indexes: Int[], dataQubits: Qubit[], q: Qubit): Unit {
+    Reset(q);
+    H(q);
+    for index in indexes {
+      // if (validIndex(d, index)) {
+        CX(q, dataQubits[index]);
+      // }
+    }
+    H(q);
+  }
+
+  operation ZStabilizer(indexes: Int[], dataQubits: Qubit[], q:Qubit): Unit {
+    Reset(q);
+    for index in indexes {
+      // if (validIndex(d, index)) {
+        CX( dataQubits[index], q);
+      // }
+    }
+  }
+
+
+  operation GetMaps(d: Int): (Int[][], Int[][], String[]) {
+    let TOTAL_DATA_QUBITS = d*d;
+    mutable xMaps = [];
+    mutable zMaps = [];
+    mutable order = [];
+    mutable isZ = true;
+    for i in 0..d-2 {
+    for j in 0..d-2 {
+      let id = (i*d)+j;
+      if (i == 0)  and (j % 2 == 0) {
+        order += ["X"];
+        let indexes = [id, id+1];
+        xMaps += [indexes];
+      }
+      if (i%2 == 1)  and (j == 0) {
+        order += ["Z"];
+        let indexes = [id, id+d];
+        zMaps += [indexes];
+      }
+
+      let indexes = [id, id+1, id+d, id+d+1];
+      if (isZ) {
+        order += ["Z"];
+        zMaps += [indexes];
+      } else {
+        order += ["X"];
+        xMaps += [indexes];
+      }
+      
+      if j != d-2 {
+        set isZ = not isZ;
+      }
+
+
+      if (j == d-2)  and (i % 2 == 0) {
+        order += ["Z"];
+        let indexes = [id+1, id+d+1];
+        zMaps += [indexes];
+      }
+    }
+  }
+  for j in 0..d-2 {
+    if (j % 2 == 1) {
+        order += ["X"];
+        let id = ((d-1)*d)+j;
+        let indexes = [id, id+1];
+        xMaps += [indexes];
+      }
+  }
+  return (xMaps, zMaps, order);
+  }
+
+operation GenerateLattice(xMaps: Int[][], zMaps: Int[][], qubits: Qubit[], ancillaX: Qubit[], ancillaZ: Qubit[], order: String[]): Unit {
+  mutable xi = 0;
+  mutable zi = 0;
+  for o in order {
+    if o == "X" {
+      XStabilizer(xMaps[xi], qubits, ancillaX[xi]);
+      xi += 1;
+    } else {
+      ZStabilizer(zMaps[zi], qubits, ancillaZ[zi]);
+      
+      zi += 1;
+    }
+    
+  }
+
+}
+
+operation Detector(initX: Result[], currX:Result[], initZ: Result[], currZ: Result[]): (Result[], Result[]) {
+  mutable xSyndrome = [];
+  mutable zSyndrome = [];
+  for i in 0..Length(initX)-1 {
+    xSyndrome += [initX[i] != currX[i] ? One | Zero];
+  }
+  for i in 0..Length(initZ)-1 {
+    zSyndrome += [initZ[i] != currZ[i] ? One | Zero];
+  }
+  return (xSyndrome, zSyndrome);
+}
+
+
+operation Round(TOTAL_DATA_QUBITS: Int, qubits: Qubit[], xMaps:Int[][], zMaps: Int[][], order: String[]): (Result[], Result[]) {
+  use ancillaX = Qubit[(TOTAL_DATA_QUBITS-1)/2];
+  use ancillaZ = Qubit[(TOTAL_DATA_QUBITS-1)/2];
+  GenerateLattice(xMaps, zMaps, qubits, ancillaX, ancillaZ, order);
+  let measuresZ = MeasureEachZ(ancillaZ);
+  let measuresX = MeasureEachZ(ancillaX);
+  ResetAll(ancillaX);
+  ResetAll(ancillaZ);
+  return (measuresX, measuresZ);
+}
+
+
+operation RotatedSurfaceCode(d: Int, r: Int): Result[] {
+  let TOTAL_DATA_QUBITS = d*d;
+  use qubits = Qubit[TOTAL_DATA_QUBITS];
+  // ConfigurePauliNoise(0.1, 0.0, 0.0);
+  
+  ResetAll(qubits);
+
+  let (xMaps, zMaps, order) = GetMaps(d);
+  
+  let (syndromeX1, syndromeZ1) = Round(TOTAL_DATA_QUBITS, qubits, xMaps, zMaps, order);
+  let (syndromeX2, syndromeZ2) = Round(TOTAL_DATA_QUBITS, qubits, xMaps, zMaps, order);
+  let (detectionX, detectionZ) = Detector(syndromeX1, syndromeX2, syndromeZ1, syndromeZ2);
+  let results = MeasureEachZ(qubits);
+  
+
+  ResetAll(qubits);
+  return detectionX + detectionZ + results;
+}
+operation RunRotated(): Result[] {
+  return RotatedSurfaceCode(3,5);
+}
+
+
+function printMaps(xMaps: Int[][], zMaps: Int[][]): Unit {
+  // Utility to print the maps of surface code
+  Message("Printing X Maps:");
+  for i in 0..Length(xMaps)-1 {
+    mutable str = "";
+    for val in xMaps[i] {
+      str += DoubleAsStringWithPrecision(IntAsDouble(val), 0) + ",";
+    }
+    Message(DoubleAsStringWithPrecision(IntAsDouble(i), 0)+"["+str+"]")
+  }
+  Message("Printing Z Maps:");
+  for i in 0..Length(zMaps)-1 {
+    mutable str = "";
+    for val in zMaps[i] {
+      str += DoubleAsStringWithPrecision(IntAsDouble(val), 0) + ",";
+    }
+    Message(DoubleAsStringWithPrecision(IntAsDouble(i), 0)+"["+str+"]")
+  }
+}
+
+
+function printArray(map: Int[]): Unit {
+  mutable str = "";
+    for val in map {
+      str += DoubleAsStringWithPrecision(IntAsDouble(val), 0) + ",";
+    }
+    Message("["+str+"]");
+}
+
+
+
diff --git a/src/Test.qs b/src/Test.qs
new file mode 100644
index 0000000..56175c0
--- /dev/null
+++ b/src/Test.qs
@@ -0,0 +1,349 @@
+import RotatedSurfaceCode.XStabilizer;
+import Std.Diagnostics.DumpMachine;
+import Std.Diagnostics.CheckAllZero;
+import Std.Arrays.All;
+import Std.Arrays.ForEach;
+import RotatedSurfaceCode.ZStabilizer;
+import RotatedSurfaceCode.MeasureLogicalZTopDown;
+import RotatedSurfaceCode.MeasureLogicalZ;
+import Std.Random.DrawRandomDouble;
+
+import RotatedSurfaceCode.CorrectDataQubit;
+
+operation PrepareTestState(d : Int, onesAtIndices: Int[], dataQubits: Qubit[]) : Unit {
+        for idx in onesAtIndices {
+            X(dataQubits[idx]);
+        }
+    }
+
+operation PrepareState(indicesToFlip: Int[], qubits: Qubit[]) : Unit {
+        for idx in indicesToFlip {
+            X(qubits[idx]);
+        }
+    }
+
+operation TestMeasureLogicalZ_AllZero() : Bool {
+    use qs = Qubit[9];
+    let d = 3;
+    let expected = Zero;
+    let result = MeasureLogicalZ(d, qs);
+    ResetAll(qs);
+    return expected == result;
+}
+
+operation TestMeasureLogicalZ_AllOne() : Bool {
+    use qs = Qubit[9];
+    let d = 3;
+    PrepareTestState(d, [0, 3, 6], qs); // Logical Z line
+    let expected = One;
+    let result = MeasureLogicalZ(d, qs);
+    ResetAll(qs);
+    return expected == result;
+}
+
+  operation TestMeasureLogicalZ_OneOneOne() : Bool {
+      use qs = Qubit[9];
+      let d = 3;
+      PrepareTestState(d, [0, 3, 6], qs);
+      let expected = One;
+      let result = MeasureLogicalZ(d, qs);
+      ResetAll(qs);
+      return expected == result;
+  }
+
+    operation TestMeasureLogicalZ_TwoOnes() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        PrepareTestState(d, [0, 3], qs);
+        let expected = Zero;
+        let result = MeasureLogicalZ(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+    
+    operation TestMeasureLogicalZ_OneOneZero() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        PrepareTestState(d, [3, 6], qs);
+        let expected = Zero;
+        let result = MeasureLogicalZ(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation TestMeasureLogicalZ_OnlyMiddleOne() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        PrepareTestState(d, [3], qs);
+        let expected = One;
+        let result = MeasureLogicalZ(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation TestMeasureLogicalZ_EmptyGrid() : Bool {
+        use qs = Qubit[1];
+        let d = 1;
+        let expected = Zero;
+        let result = MeasureLogicalZ(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation TestMeasureLogicalZ_Superposition() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        for i in [0, 3, 6] {
+            H(qs[i]); // Put logical line into superposition
+        }
+        let result = MeasureLogicalZ(d, qs);
+        // Result could be Zero or One; just check it's valid Result
+        ResetAll(qs);
+        return result == One or result == Zero;
+    }
+
+    
+    operation TestMeasureLogicalZ_IrrelevantQubitsFlipped() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        PrepareTestState(d, [1, 2, 4, 5, 7, 8], qs); // Flip non-logical-Z qubits
+        let expected = Zero;
+        let result = MeasureLogicalZ(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    operation TestMeasureLogicalZ_LargeGrid() : Bool {
+        let d = 5;
+        use qs = Qubit[d * d];
+        // Flip every second qubit in logical Z line (indices 0, 5, 10, 15, 20)
+        PrepareTestState(d, [0, 10, 20], qs);
+        let expected = One;
+        let result = MeasureLogicalZ(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+    
+    
+    operation Test_MeasureLogicalZTopDown_AllZero() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        let expected = Zero;
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation Test_MeasureLogicalZTopDown_AllOne() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        PrepareState([0, 3, 6], qs);
+        let expected = One;
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation Test_MeasureLogicalZTopDown_OneQubitFlipped() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        PrepareState([3], qs);
+        let expected = One;
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation Test_MeasureLogicalZTopDown_TwoFlipped() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        PrepareState([0, 6], qs);
+        let expected = Zero;
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation Test_MeasureLogicalZTopDown_IgnoreNonColumnQubits() : Bool {
+        use qs = Qubit[9];
+        let d = 3;
+        // Flip qubits not in first column
+        PrepareState([1, 2, 4, 5, 7, 8], qs);
+        let expected = Zero;
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation Test_MeasureLogicalZTopDown_ThreeFlipped_OddParity() : Bool {
+        use qs = Qubit[16];
+        let d = 4;
+        PrepareState([0, 4, 8], qs); // Flip 3 qubits in logical Z
+        let expected = One;
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation Test_MeasureLogicalZTopDown_LargeGrid_ZeroParity() : Bool {
+        let d = 5;
+        use qs = Qubit[d * d];
+        PrepareState([0, 10, 20], qs); // Indices = 0, 2, 4 in logical Z
+        let expected = One;
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation Test_MeasureLogicalZTopDown_SingleQubitGrid() : Bool {
+        use qs = Qubit[1];
+        let d = 1;
+        PrepareState([0], qs);
+        let expected = One;
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation Test_MeasureLogicalZTopDown_AllFiveFlipped() : Bool {
+        use qs = Qubit[25];
+        let d = 5;
+        PrepareState([0, 5, 10, 15, 20], qs); // Full logical Z column
+        let expected = One; // 5 is odd
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+
+    
+    operation Test_MeasureLogicalZTopDown_AllFourFlipped() : Bool {
+        use qs = Qubit[16];
+        let d = 4;
+        PrepareState([0, 4, 8, 12], qs);
+        let expected = Zero;
+        let result = MeasureLogicalZTopDown(d, qs);
+        ResetAll(qs);
+        return expected == result;
+    }
+    
+    operation Test_ZStabilizerApplyLater() : Bool {
+        use qs = Qubit[16];
+        let indexes = [0,5,7];
+        ResetAll(qs);
+        ZStabilizer(indexes, qs[0..Length(qs)-2], qs[Length(qs)-1]);
+        X(qs[Length(qs)-1]);
+        DumpMachine();
+        let result = CheckAllZero(qs[0..Length(qs)-2]);
+        ResetAll(qs[0..Length(qs)-2]);
+        return (MResetEachZ([qs[Length(qs)-1]]) == [One] )and result;
+    }
+    
+    operation Test_ZStabilizer_ShouldNotActivate() : Bool {
+        use qs = Qubit[16];
+        ResetAll(qs);
+        let indexes = [3,5,7];
+        ZStabilizer(indexes, qs[0..Length(qs)-2], qs[Length(qs)-1]);
+        X(qs[Length(qs)-1]);
+        let result = CheckAllZero(qs[0..Length(qs)-2]);
+        ResetAll(qs);
+        return result;
+    }
+    operation Test_ZStabilizerShouldResetAncillaBeforeUse() : Bool {
+        use qs = Qubit[16];
+        let indexes = [];
+        
+        X(qs[Length(qs)-1]);
+        ZStabilizer(indexes, qs[0..Length(qs)-2], qs[Length(qs)-1]);
+        let expected = Zero;
+        let res = M(qs[Length(qs)-1]);
+        ResetAll(qs);
+        return expected == res;
+    }
+    
+
+    operation PrepareInXBasis(indicesToFlip : Int[], dataQubits : Qubit[]) : Unit {
+        // Prepare all qubits in |+⟩
+        for q in dataQubits {
+            H(q);
+        }
+        // Flip selected qubits to |−⟩
+        for i in indicesToFlip {
+            Z(dataQubits[i]);
+        }
+    }
+
+    
+    operation Test_XStabilizer_EvenParity() : Bool {
+        use data = Qubit[4];
+        use ancilla = Qubit();
+        let indexes = [0, 1, 2, 3];
+
+        // Prepare even number of |−⟩: flip qubits 1 and 3
+        PrepareInXBasis([1, 3], data);
+        
+        XStabilizer(indexes, data, ancilla);
+        let result = M(ancilla);
+
+        ResetAll(data + [ancilla]);
+        return Zero == result;
+    }
+
+    
+    operation Test_XStabilizer_OddParity() : Bool {
+        use data = Qubit[4];
+        use ancilla = Qubit();
+        let indexes = [0, 1, 2, 3];
+
+        // Prepare odd number of |−⟩: flip qubits 1, 2, and 3
+        PrepareInXBasis([1, 2, 3], data);
+        
+        XStabilizer(indexes, data, ancilla);
+        let result = M(ancilla);
+
+        ResetAll(data + [ancilla]);
+        return One == result;
+    }
+
+    
+    operation Test_XStabilizer_SingleQubit() : Bool {
+        use data = Qubit[1];
+        use ancilla = Qubit();
+        let indexes = [0];
+
+        // Flip to |−⟩
+        PrepareInXBasis([0], data);
+
+        XStabilizer(indexes, data, ancilla);
+        let result = M(ancilla);
+
+        
+        ResetAll(data + [ancilla]);
+        return One == result;
+    }
+
+    
+    operation Test_XStabilizer_ZeroParity() : Bool {
+        use data = Qubit[3];
+        use ancilla = Qubit();
+        let indexes = [0, 1, 2];
+
+        // All in |+⟩
+        PrepareInXBasis([], data);
+
+        XStabilizer(indexes, data, ancilla);
+        let result = M(ancilla);
+
+        ResetAll(data + [ancilla]);
+        return Zero == result
+    }
diff --git a/test_surface_code.py b/test_surface_code.py
new file mode 100644
index 0000000..ec8a533
--- /dev/null
+++ b/test_surface_code.py
@@ -0,0 +1,89 @@
+import qsharp
+import pytest
+
+def test_2() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.TestMeasureLogicalZ_AllZero()")
+    assert correct
+
+def test_3() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.TestMeasureLogicalZ_AllOne()")
+    assert correct
+
+def test_4() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.TestMeasureLogicalZ_OneOneOne()")
+    assert correct
+
+def test_5() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.TestMeasureLogicalZ_TwoOnes()")
+    assert correct
+
+def test_6() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.TestMeasureLogicalZ_OneOneZero()")
+    assert correct
+def test_7() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.TestMeasureLogicalZ_OnlyMiddleOne()")
+    assert correct
+def test_8() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.TestMeasureLogicalZ_EmptyGrid()")
+    assert correct
+def test_9() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.TestMeasureLogicalZ_Superposition()")
+    assert correct
+def test_10() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.Test_MeasureLogicalZTopDown_AllFourFlipped()")
+    assert correct
+def test_11() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.Test_MeasureLogicalZTopDown_AllFiveFlipped()")
+    assert correct
+def test_12() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.Test_MeasureLogicalZTopDown_SingleQubitGrid()")
+    assert correct
+def test_12() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.Test_MeasureLogicalZTopDown_LargeGrid_ZeroParity()")
+    assert correct
+def test_13() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.Test_MeasureLogicalZTopDown_ThreeFlipped_OddParity()")
+    assert correct
+def test_14() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.Test_MeasureLogicalZTopDown_IgnoreNonColumnQubits()")
+    assert correct
+def test_15() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.Test_ZStabilizerApplyLater()")
+    assert correct
+def test_16() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.Test_ZStabilizer_ShouldNotActivate()")
+    assert correct
+def test_17() -> None:
+    qsharp.init(project_root=".")
+    correct = qsharp.eval("Test.Test_ZStabilizerShouldResetAncillaBeforeUse()")
+    assert correct
+
+@pytest.mark.parametrize("functionName", [
+    "Test_XStabilizer_EvenParity",
+    "Test_XStabilizer_OddParity",
+    "Test_XStabilizer_SingleQubit",
+    "Test_XStabilizer_ZeroParity"
+])
+def test_runner(functionName):
+    print(functionName)
+    qsharp.init(project_root=".")
+    correct = qsharp.eval(f"Test.{functionName}()")
+    assert correct
+
+
diff --git a/timeline.png b/timeline.png
new file mode 100644
index 0000000..f3ec077
Binary files /dev/null and b/timeline.png differ