From 5bc2f4caa8816cf192ae3eaff421ff9ecced5a7f Mon Sep 17 00:00:00 2001 From: Jonhas Colina Date: Wed, 21 Feb 2024 13:47:34 -0700 Subject: [PATCH 01/11] First commit to package qca with the introduction of a qca/utils module that contains utility functions reused in the photosynthesis and fermi hubbard notebooks --- .gitignore | 50 ++++++++++++++++++++++ pyproject.toml | 24 +++++++++++ src/__init__.py | 0 src/qca/__init__.py | 1 + src/qca/utils/__init__.py | 1 + src/qca/utils/utils.py | 87 +++++++++++++++++++++++++++++++++++++++ 6 files changed, 163 insertions(+) create mode 100644 pyproject.toml create mode 100644 src/__init__.py create mode 100644 src/qca/__init__.py create mode 100644 src/qca/utils/__init__.py create mode 100644 src/qca/utils/utils.py diff --git a/.gitignore b/.gitignore index 8e2791d..7e396d5 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,53 @@ QSP/* GSE/* *.zip qasm_circuits/* + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..5c22723 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,24 @@ +[build-system] +requires = ["setuptools", "setuptools-scm"] +build-backend = "setuptools.build_meta" + +[project] +name = "qca" +version = "0.0.1" +dependencies = [ + "cirq == 1.3.0.dev20231102230836", + "matplotlib", + "networkx", + "numpy", + "openfermion", + "openfermionpyscf", + "pandas", + "pyLIQTR >=1.0.0" +] +requires-python = ">=3.9" +description = "Documentation of Applications for Quantum Computers" +readme = "readme.md" +license = {file = "LICENSE.txt"} +classifiers = [ + "Programming Language :: Python" +] diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/qca/__init__.py b/src/qca/__init__.py new file mode 100644 index 0000000..afb8fbf --- /dev/null +++ b/src/qca/__init__.py @@ -0,0 +1 @@ +from qca import utils diff --git a/src/qca/utils/__init__.py b/src/qca/utils/__init__.py new file mode 100644 index 0000000..9f9161b --- /dev/null +++ b/src/qca/utils/__init__.py @@ -0,0 +1 @@ +from . import utils \ No newline at end of file diff --git a/src/qca/utils/utils.py b/src/qca/utils/utils.py new file mode 100644 index 0000000..8a96951 --- /dev/null +++ b/src/qca/utils/utils.py @@ -0,0 +1,87 @@ +import os +from re import findall +from typing import Union +from cirq import Circuit, QasmOutput +from pyLIQTR.utils.qsp_helpers import circuit_decompose_once +from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform +from pyLIQTR.utils.utils import count_T_gates + + +def extract_number(string) -> Union[int, None]: + number = findall(r'\d+', string) + return int(number[0]) if number else None + + +def count_gates(cpt_circuit) -> int: + count = 0 + for moment in cpt_circuit: + count += len(moment) + return count + + +def estimate_gsee( + circuit: Circuit, + outdir: str, + circuit_name: str = 'gse_circuit', + write_circuits: bool = False) -> None: + if not os.path.exists(outdir): + os.makedirs(outdir) + + t_counts = {} + gate_counts = {} + clifford_counts = {} + subcircuit_counts = {} + subcircuit_depths = {} + + outfile_data = f'{outdir}{circuit_name}_high_level.dat' + + for moment in circuit: + for operation in moment: + gate_type = type(operation.gate) + if gate_type in subcircuit_counts: + subcircuit_counts[gate_type] += 1 + else: + decomposed_circuit = circuit_decompose_once( + circuit_decompose_once(Circuit(operation))) + cpt_circuit = clifford_plus_t_direct_transform( + decomposed_circuit) + + if write_circuits: + outfile_qasm_decomposed = f'{outdir}{str(gate_type)[8:-2]}.decomposed.qasm' + outfile_qasm_cpt = f'{outdir}{str(gate_type)[8:-2]}.cpt.qasm' + QasmOutput( + decomposed_circuit, + decomposed_circuit.all_qubits()).save(outfile_qasm_decomposed) + QasmOutput(cpt_circuit, + cpt_circuit.all_qubits()).save(outfile_qasm_cpt) + + subcircuit_counts[gate_type] = 1 + subcircuit_depths[gate_type] = len(cpt_circuit) + t_counts[gate_type] = count_T_gates(cpt_circuit) + gate_counts[gate_type] = count_gates(cpt_circuit) + clifford_counts[gate_type] = gate_counts[gate_type] - \ + t_counts[gate_type] + + total_gate_count = 0 + total_gate_depth = 0 + total_T_count = 0 + total_clifford_count = 0 + for gate in subcircuit_counts: + total_gate_count += subcircuit_counts[gate] * gate_counts[gate] + total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate] + total_T_count += subcircuit_counts[gate] * t_counts[gate] + total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate] + with open(outfile_data, 'w', encoding='utf-8') as file: + file.write(f'Logical Qubit Count: {len(circuit.all_qubits())}\n') + file.write(f'Total Gate Count: {total_gate_count}\n') + file.write(f'Total Gate Depth: {total_gate_depth}\n') + file.write(f'Total T Count: {total_T_count}\n') + file.write(f'Total Clifford Count: {total_clifford_count}\n') + file.write('Subcircuit Info:\n') + for gate in subcircuit_counts: + file.write(f'{gate}\n') + file.write(f'Subcircuit Occurrences: {subcircuit_counts[gate]}\n') + file.write(f'Gate count: {gate_counts[gate]}\n') + file.write(f'Gate depth: {subcircuit_counts[gate]}\n') + file.write(f'T Count: {t_counts[gate]}\n') + file.write(f'Clifford Count: {clifford_counts[gate]}\n') From 146f38e7fe7095ae684f6c5adb748d822f0bdfbe Mon Sep 17 00:00:00 2001 From: Jonhas Colina Date: Wed, 21 Feb 2024 15:20:16 -0700 Subject: [PATCH 02/11] responded to changes in gitignore and pyproject. Removed requirements.txt as pyproject now handles that --- .gitignore | 3 +-- pyproject.toml | 2 +- requirements.txt | 8 -------- 3 files changed, 2 insertions(+), 11 deletions(-) delete mode 100644 requirements.txt diff --git a/.gitignore b/.gitignore index 7e396d5..189ca2c 100644 --- a/.gitignore +++ b/.gitignore @@ -47,8 +47,7 @@ MANIFEST env/ venv/ ENV/ -env.bak/ -venv.bak/ +*.back # mypy .mypy_cache/ diff --git a/pyproject.toml b/pyproject.toml index 5c22723..94b0761 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -17,7 +17,7 @@ dependencies = [ ] requires-python = ">=3.9" description = "Documentation of Applications for Quantum Computers" -readme = "readme.md" +readme = "README.md" license = {file = "LICENSE.txt"} classifiers = [ "Programming Language :: Python" diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index 0098b5d..0000000 --- a/requirements.txt +++ /dev/null @@ -1,8 +0,0 @@ -cirq -matplotlib -networkx -numpy -openfermion -openfermionpyscf -pandas -pyLIQTR==0.3.3 From f466eb9cf85ab7ac363de2ec9d229d43c043f15a Mon Sep 17 00:00:00 2001 From: Jonhas Colina Date: Wed, 21 Feb 2024 15:31:15 -0700 Subject: [PATCH 03/11] fixed *.bak typo --- .gitignore | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 189ca2c..b97d95b 100644 --- a/.gitignore +++ b/.gitignore @@ -47,7 +47,7 @@ MANIFEST env/ venv/ ENV/ -*.back +*.bak # mypy .mypy_cache/ From 3f492f428061db5f3a9d1d19da1276229134348a Mon Sep 17 00:00:00 2001 From: Jonhas Colina Date: Wed, 21 Feb 2024 15:33:53 -0700 Subject: [PATCH 04/11] reverted versioning to be prev versions --- pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 94b0761..807a40a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,14 +6,14 @@ build-backend = "setuptools.build_meta" name = "qca" version = "0.0.1" dependencies = [ - "cirq == 1.3.0.dev20231102230836", + "cirq", "matplotlib", "networkx", "numpy", "openfermion", "openfermionpyscf", "pandas", - "pyLIQTR >=1.0.0" + "pyLIQTR == 0.3.3" ] requires-python = ">=3.9" description = "Documentation of Applications for Quantum Computers" From ad54843431afa021d8b54bba899f30a36599b707 Mon Sep 17 00:00:00 2001 From: Jonhas Colina <159941307+JonhasSC@users.noreply.github.com> Date: Wed, 28 Feb 2024 11:36:34 -0700 Subject: [PATCH 05/11] Feature/magnetic lattice 1.0 (#5) * pyliqrt 1.0 support up to qsp estimation * complete translation to pyliqtr1.0.0 for the magneticlattices notebook * fixed bug with qsp estimation and went through the notebook * made the change to pyliqtr1.0 to HightemperatureSuperConductorExample jupyter notebook * added output for the notebook * removed old fermi hubbard notebook * removed unused imports * added hamiltonian utils file. Would proabbly be moved to some hamiltonian module in the future * have the notebook use the packaged utility functions * finalized adding additional features for fermi hubbard support * fixed pyproject versioning * successfull running of magnetic lattice using pyliqtr1.0 ontop of modularized functionality * adding back fermihubbard notebook from main * forgot to remove requirements file * changed generate_square_hamiltonian to generate_square_hamiltonian and generate_triangle_hamiltonian to better seperate the two * changed notebook to respond to PR comments, i.e, changed shape_graph to graph_shape and just manually imported all functions that are needed --- MagneticLattices.ipynb | 1138 ---------------------------- notebooks/MagneticLattices.ipynb | 873 +++++++++++++++++++++ pyproject.toml | 4 +- src/qca/utils/__init__.py | 3 +- src/qca/utils/hamiltonian_utils.py | 220 ++++++ src/qca/utils/utils.py | 71 +- 6 files changed, 1158 insertions(+), 1151 deletions(-) delete mode 100644 MagneticLattices.ipynb create mode 100644 notebooks/MagneticLattices.ipynb create mode 100644 src/qca/utils/hamiltonian_utils.py diff --git a/MagneticLattices.ipynb b/MagneticLattices.ipynb deleted file mode 100644 index fbb48a7..0000000 --- a/MagneticLattices.ipynb +++ /dev/null @@ -1,1138 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "59027812-8512-4ef0-814d-2ba849b7a428", - "metadata": {}, - "source": [ - "# Example Proxy Simulations\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "7577458a-97b6-4dd1-b848-46c0f2c283fc", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "import networkx as nx\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import numpy as np\n", - "import random\n", - "import time\n", - "import sys\n", - "import os\n", - "import openfermion\n", - "from openfermion.circuits import trotter\n", - "import re" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e8f2a807-f99c-42b1-8aac-6bb4646dc007", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "###\n", - "### Imports to support the pyQSP Gate-Based Hamiltonian simulation\n", - "###\n", - "import cirq\n", - "from cirq.contrib.svg import SVGCircuit\n", - "from cirq.contrib import qasm_import\n", - "\n", - "import pyLIQTR.QSP.gen_qsp as qspFuncs\n", - "import pyLIQTR.QSP.QSP as pQSP\n", - "\n", - "from pyLIQTR.QSP.Hamiltonian import Hamiltonian as pyH\n", - "from pyLIQTR.QSP.qsp_helpers import qsp_decompose_once, print_to_openqasm, prettyprint_qsp_to_qasm # these should move to a utils.\n", - "from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform\n", - "from pyLIQTR.utils.utils import count_T_gates, open_fermion_to_qasm\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "6dd69d4a-3d3b-4a7f-aeaf-2affa530e3e3", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "##defining helper functions\n", - "def get_T_depth_wire(cpt_circuit):\n", - " #maximum number of T-gates on a wire. This may be more optimistic than\n", - " #number of layers with T-gates. Perhaps good to treat as lower bound\n", - " #for an implementation\n", - " count_dict = dict()\n", - " for moment in cpt_circuit:\n", - " for operator in moment:\n", - " opstr = str(operator)\n", - " if opstr[0] == 'T':\n", - " reg_label = opstr[opstr.find(\"(\")+1:opstr.find(\")\")]\n", - " if not reg_label in count_dict:\n", - " count_dict[reg_label] = 1\n", - " else:\n", - " count_dict[reg_label] += 1\n", - " max_depth=0\n", - " for register in count_dict:\n", - " if count_dict[register] > max_depth:\n", - " max_depth = count_dict[register]\n", - " return max_depth\n", - "\n", - "def get_T_depth(cpt_circuit):\n", - " t_depth = 0\n", - " for moment in cpt_circuit:\n", - " for operator in moment:\n", - " opstr = str(operator)\n", - " if opstr[0] == 'T':\n", - " t_depth += 1\n", - " break\n", - " return t_depth\n", - "\n", - "def plot_T_step_histogram(cpt_circuit, lowest_ind=0, **kwargs):\n", - " t_widths = [0] * (len(cpt_circuit))\n", - " for (i, moment) in enumerate(cpt_circuit):\n", - " width = 0\n", - " for operator in moment:\n", - " opstr = str(operator)\n", - " if opstr[0] == 'T':\n", - " width += 1\n", - " t_widths[i] = width\n", - " bins = range(max(t_widths))\n", - " histogram = plt.hist(t_widths, bins[lowest_ind:-1], **kwargs)\n", - " return histogram\n", - " \n", - "def count_gates(cpt_circuit):\n", - " count = 0\n", - " for moment in cpt_circuit:\n", - " for operator in moment:\n", - " count += 1\n", - " return count\n", - "\n", - "def pyliqtr_hamiltonian_to_openfermion_qubit_operator(H):\n", - " open_fermion_operator = openfermion.QubitOperator()\n", - " for term in H.terms:\n", - " open_fermion_term = \"\"\n", - " for (i,pauli) in enumerate(term[0]):\n", - " if not pauli == 'I':\n", - " open_fermion_term = open_fermion_term + pauli + str(i) + \" \"\n", - " open_fermion_term_op = openfermion.QubitOperator(open_fermion_term)\n", - " if not open_fermion_term == \"\":\n", - " open_fermion_operator += term[1] * open_fermion_term_op\n", - " return open_fermion_operator" - ] - }, - { - "cell_type": "markdown", - "id": "b379daf8-0a6a-401d-83e5-da546ddeb08f", - "metadata": {}, - "source": [ - "# Basic examples\n", - "This notebook outlines the construction of Hamiltonians which are not inherently useful\n", - "on their own, but are of a similar form to what we expect for the most basic\n", - "simulations where a quantum computer may be useful. This version is a working version and\n", - "will likely be updated later to include more application relevant examples. The dynamic\n", - "simulation of these Hamiltonians can be thought of as a necessary but not sufficient\n", - "condition for demonstrating the viability of a quantum computer as a useful tool for \n", - "quanutm dynamic simulation.\n", - "\n", - "Note that running this entire notebook should take on the order of an hour.\n", - "To see smaller cases, simply reduce the sizes of the lattices for the various Hamiltonians.\n", - "\n", - "## Basic Hamiltonian\n", - "In this section we consider the time independent transverse field Ising Hamiltonians represented by graphs\n", - "with a lattice structure. There are more complicated models which would likely\n", - "be interesting to simulate, but as an initial pass we start by considering two models\n", - "* 32x32 Triangular Lattice (1024 spins, 2 dimensions) with antiferromagnetic unit couplings\n", - "* 12x12x12 Cubic Lattice (1728 spins, 3 dimensions) with random unit couplings\n", - "The transverse field Ising Hamiltonian for a lattice graph, $G = (V,E)$ is as follows:\n", - "\n", - "\\begin{equation}\n", - "H = \\sum_{i \\in V} \\Gamma_{i}\\sigma_{i}^{x} + \\sum_{i \\in V} h_{i} \\sigma_{i}^{z} + \\sum_{(i,j) \\in E} J_{i,j} \\sigma_{i}^{z} \\sigma_{j}^{z}\n", - "\\end{equation}\n", - "Note that in the instances presented here, we do not consider local longitudinal field terms ($\\boldsymbol{h}=0$), though this may not always be the case.\n", - "We also do not consider in this example the state preparation circuit that may be required as that is heavily application dependent.\n", - "For the purposes of these initial experiments, we can assume that the initial state is an eigenstate of either the $X$ or $Z$ basis since the preparation circuits for these have $O(1)$ depth.\n", - "\n", - "To be clear, the dynamic simulations mean simulating the Schrodinger Equation\n", - "\\begin{equation}\n", - "i \\hbar \\frac{\\partial}{\\partial t}|\\psi(t)\\rangle = H |\\psi(t)\\rangle\n", - "\\end{equation}\n", - "with solution\n", - "\\begin{equation}\n", - "|\\psi(t)\\rangle = e^{-\\frac{i}{\\hbar}H t}|\\psi(0)\\rangle\n", - "\\end{equation}\n", - "\n", - "A subgraph of each lattice is plotted below to clarify the graph structure to clarify the graph structure.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "135cff57-3f16-4f02-8813-0cce625facb4", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "t_initial = time.perf_counter()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "7f64c2b4-4e50-496c-ada6-1d1bdb20a5af", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#a triangle lattice which can be embedded on a square can be constructed\n", - "#by making a square lattice then adding an edge across the diagonal\n", - "#of each square\n", - "def nx_triangle_lattice(lattice_size):\n", - " g = nx.generators.lattice.grid_2d_graph(lattice_size,lattice_size)\n", - " for i in range(lattice_size - 1):\n", - " for j in range(lattice_size - 1):\n", - " g.add_edge((i,j),(i+1,j+1))\n", - " return g\n", - "\n", - "test_lattice_size=3\n", - "g_square = nx.grid_graph(dim = (test_lattice_size, test_lattice_size))\n", - "g_triangle = nx_triangle_lattice(test_lattice_size)\n", - "g_cube = nx.generators.grid_graph(dim = (test_lattice_size,test_lattice_size,test_lattice_size))\n", - "nx.draw(g_square)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "45627e28-6870-4363-8491-3317e03f2027", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "nx.draw(g_triangle)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "347ef393-084a-4fff-9e75-aff5eda6d514", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "nx.draw(g_cube)" - ] - }, - { - "cell_type": "markdown", - "id": "9ec84065-0d56-4d2a-95a4-e5232ac91777", - "metadata": {}, - "source": [ - "Now that we have an idea of what our Hamiltonians look like, we can begin generating them in a form accepted by pyLIQTR." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "3138ec14-981d-48fe-8302-0dc18de33df3", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "###defining helper functions for Hamiltonian string generation\n", - "\n", - "#given a networkx graph g, construct a hamiltonian with random weights\n", - "#which can be processed by pyLIQTR\n", - "def nx_longitudinal_ising_terms(g,p,magnitude=1):\n", - " H_longitudinal = []\n", - " n = len(g.nodes)\n", - " for (n1,n2) in g.edges:\n", - " weight = magnitude if random.random() < p else -magnitude\n", - " string = n*'I' \n", - " for i in range(len(g)):\n", - " if i == n1 or i == n2:\n", - " string = string[:i] + 'Z' + string[i+1:]\n", - " else:\n", - " pass\n", - " H_longitudinal.append((string,weight))\n", - " return H_longitudinal\n", - "\n", - "def nx_transverse_ising_terms(g,p,magnitude=0.1):\n", - " H_transverse = []\n", - " n = len(g)\n", - " for i in range(n):\n", - " w = magnitude if random.random() < p else -magnitude\n", - " string = n*'I'\n", - " for k in range(n):\n", - " if i == k:\n", - " string = string[:i] + 'X' + string[i+1:]\n", - " else:\n", - " pass\n", - " H_transverse.append((string, w))\n", - " return H_transverse\n", - "\n", - "def flatten_nx_graph(g):\n", - " new_ids = {}\n", - " count = 0\n", - " for node in g.nodes:\n", - " if node in new_ids:\n", - " pass\n", - " else:\n", - " new_ids[node] = count\n", - " count = count + 1\n", - " new_g = nx.relabel_nodes(g, new_ids)\n", - " return new_g\n", - "\n", - "def generate_square_hamiltonian(lattice_size, longitudinal_weight_prob=0.5, transverse_weight_prob=1):\n", - " g = nx.grid_graph(dim=(lattice_size,lattice_size))\n", - " g = flatten_nx_graph(g)\n", - " H_transverse = nx_transverse_ising_terms(g, transverse_weight_prob)\n", - " H_longitudinal = nx_longitudinal_ising_terms(g, longitudinal_weight_prob)\n", - " return H_transverse, H_longitudinal\n", - "\n", - "def generate_triangular_hamiltonian(lattice_size, longitudinal_weight_prob=1, transverse_weight_prob=1):\n", - " g = nx_triangle_lattice(lattice_size)\n", - " g = flatten_nx_graph(g)\n", - " H_transverse = nx_transverse_ising_terms(g, transverse_weight_prob)\n", - " H_longitudinal = nx_longitudinal_ising_terms(g, longitudinal_weight_prob)\n", - " return H_transverse, H_longitudinal\n", - "\n", - "def generate_cubic_hamiltonian(lattice_size, longitudinal_weight_prob=0.5, transverse_weight_prob=1):\n", - " g = nx.grid_graph(dim=(lattice_size,lattice_size,lattice_size))\n", - " g = flatten_nx_graph(g)\n", - " H_transverse = nx_transverse_ising_terms(g, transverse_weight_prob)\n", - " H_longitudinal = nx_longitudinal_ising_terms(g, longitudinal_weight_prob)\n", - " return H_transverse, H_longitudinal\n", - "\n", - "def estimate_qsp(pyliqtr_hamiltonian, timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n", - " timestep_of_interest=1 #for magnus like argument\n", - " angles, tolerances = qspFuncs.compute_hamiltonian_angles(pyliqtr_hamiltonian, simtime=timestep_of_interest, req_prec=energy_precision)\n", - " qsp_generator = pQSP.QSP(phis=angles, hamiltonian=pyliqtr_hamiltonian, target_size=pyliqtr_hamiltonian.problem_size)\n", - " qsp_circuit = qsp_generator.circuit()\n", - " \n", - " if not os.path.exists(outdir):\n", - " os.makedirs(outdir)\n", - " \n", - " subcircuit_counts = dict()\n", - " t_counts = dict()\n", - " t_depths = dict()\n", - " t_depth_wires = dict()\n", - " clifford_counts = dict()\n", - " gate_counts = dict()\n", - " subcircuit_depths = dict()\n", - " \n", - " outfile_qasm_high_level = outdir + hamiltonian_name + \"_high_level.qasm\"\n", - " outfile_data = outdir + hamiltonian_name + \"_high_level.dat\"\n", - " \n", - " for moment in qsp_circuit:\n", - " for operation in moment:\n", - " gate_type = type(operation.gate)\n", - " if gate_type in subcircuit_counts:\n", - " subcircuit_counts[gate_type] += 1\n", - " \n", - " else:\n", - " outfile_qasm_decomposed = outdir+str(gate_type)[8:-2]+\".decomposed.qasm\"\n", - " outfile_qasm_cpt = outdir+str(gate_type)[8:-2]+\".cpt.qasm\"\n", - " \n", - " decomposed_circuit = qsp_decompose_once(qsp_decompose_once(cirq.Circuit(operation)))\n", - " cpt_circuit = clifford_plus_t_direct_transform(decomposed_circuit)\n", - " \n", - " if write_circuits:\n", - " with open(outfile_qasm_decomposed, 'w') as f:\n", - " print_to_openqasm(f, decomposed_circuit, qubits=decomposed_circuit.all_qubits())\n", - " \n", - " with open(outfile_qasm_cpt, 'w') as f:\n", - " print_to_openqasm(f, cpt_circuit, qubits=cpt_circuit.all_qubits())\n", - " \n", - " subcircuit_counts[gate_type] = 1\n", - " subcircuit_depths[gate_type] = len(cpt_circuit)\n", - " t_counts[gate_type] = count_T_gates(cpt_circuit)\n", - " gate_counts[gate_type] = count_gates(cpt_circuit)\n", - " t_depths[gate_type] = get_T_depth(cpt_circuit)\n", - " t_depth_wires[gate_type] = get_T_depth_wire(cpt_circuit)\n", - " clifford_counts[gate_type] = gate_counts[gate_type] - t_counts[gate_type]\n", - " \n", - " total_gate_count = 0\n", - " total_gate_depth = 0\n", - " total_T_depth = 0\n", - " total_T_depth_wire = 0\n", - " total_T_count = 0\n", - " total_clifford_count = 0\n", - " for gate in subcircuit_counts:\n", - " total_gate_count += subcircuit_counts[gate] * gate_counts[gate] * timesteps / timestep_of_interest\n", - " total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate] * timesteps / timestep_of_interest\n", - " total_T_depth += subcircuit_counts[gate] * t_depths[gate] * timesteps / timestep_of_interest\n", - " total_T_depth_wire += subcircuit_counts[gate] * t_depth_wires[gate] * timesteps / timestep_of_interest\n", - " total_T_count += subcircuit_counts[gate] * t_counts[gate] * timesteps / timestep_of_interest\n", - " total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate] * timesteps / timestep_of_interest\n", - " with open(outfile_data, 'w') as f:\n", - " total_gate_count \n", - " f.write(str(\"Logical Qubit Count:\"+str(len(qsp_circuit.all_qubits()))+\"\\n\"))\n", - " f.write(str(\"Total Gate Count:\"+str(total_gate_count)+\"\\n\"))\n", - " f.write(str(\"Total Gate Depth:\"+str(total_gate_depth)+\"\\n\"))\n", - " f.write(str(\"Total T Count:\"+str(total_T_count)+\"\\n\"))\n", - " f.write(str(\"Total T Depth:\"+str(total_T_depth)+\"\\n\"))\n", - " f.write(str(\"Maximum T Count on Single Wire:\"+str(total_T_depth_wire)+\"\\n\"))\n", - " f.write(str(\"Total Clifford Count:\"+str(total_clifford_count)+\"\\n\"))\n", - " f.write(\"Subcircuit Info:\\n\")\n", - " for gate in subcircuit_counts:\n", - " f.write(str(str(gate)+\"\\n\"))\n", - " f.write(str(\"Subcircuit Occurrences:\"+str(subcircuit_counts[gate]*timesteps)+\"\\n\"))\n", - " f.write(str(\"Gate Count:\"+str(gate_counts[gate])+\"\\n\"))\n", - " f.write(str(\"Gate Depth:\"+str(subcircuit_depths[gate])+\"\\n\"))\n", - " f.write(str(\"T Count:\"+str(t_counts[gate])+\"\\n\"))\n", - " f.write(str(\"T Depth:\"+str(t_depths[gate])+\"\\n\"))\n", - " f.write(str(\"Maximum T Count on a Single Wire:\"+str(t_depth_wires[gate])+\"\\n\"))\n", - " f.write(str(\"Clifford Count:\"+str(clifford_counts[gate])+\"\\n\"))\n", - " return qsp_circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "8a6e1a51-7c17-40e8-aa8f-9e9f1e517358", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "##initializing seed for consistent results for the cubic lattice and generating Hamiltonians\n", - "random.seed(0)\n", - "np.random.seed(0)\n", - "square_lattice_size=10\n", - "triangle_lattice_size=32\n", - "cubic_lattice_size=12\n", - "test_lattice_size=3\n", - "\n", - "square_hamiltonian = generate_square_hamiltonian(square_lattice_size)\n", - "triangular_hamiltonian = generate_triangular_hamiltonian(triangle_lattice_size)\n", - "cubic_hamiltonian = generate_cubic_hamiltonian(cubic_lattice_size)\n", - "#square_hamiltonian = generate_square_hamiltonian(test_lattice_size)\n", - "#triangular_hamiltonian = generate_triangular_hamiltonian(test_lattice_size)\n", - "#cubic_hamiltonian = generate_cubic_hamiltonian(test_lattice_size)" - ] - }, - { - "cell_type": "markdown", - "id": "616d328e-14d9-4ed5-ade8-964b7e2f72d9", - "metadata": {}, - "source": [ - "Now that we have generated our Hamiltonians, we can start generating the circuits for a preferred dynamic simulation method (e.g., QSP, Trotter 4th order, ...). Shown below is QSP." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "c3653189-c665-408b-840f-f5994a5ed51e", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "timesteps=1000\n", - "required_precision = 1e-16" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "13809189-52c3-46e2-a8d9-fedb0643c58b", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "#feeding square Hamiltonian to PyLIQTR for circuit generation\n", - "H_square = pyH(square_hamiltonian[0] + square_hamiltonian[1])\n", - "H_triangle = pyH(triangular_hamiltonian[0] + triangular_hamiltonian[1])\n", - "H_cube = pyH(cubic_hamiltonian[0] + cubic_hamiltonian[1])" - ] - }, - { - "cell_type": "markdown", - "id": "6c3aa727-7273-46f6-a2d2-2fef9526ca9e", - "metadata": {}, - "source": [ - "Now we need to extract resource estimates for each of the subcircuits of the high level circuit. The information which we are interested in is as follows:\n", - "* Total gate count for full circuit\n", - "* Total depth for full circuit\n", - "* Decomposed QASM circuit for each subcircuit\n", - "* Clifford + T circuits for each subcircuit\n", - "* Total T gate count for each subcircuit\n", - "* Total Clifford count for each subcircuit\n", - "* T gate depth for each subcircuit\n", - "\n", - "This information can be extracted by obtaining the information for each subcircuit and multiplying by the number of repetitions of the subcircuits. In this\n", - "notebook, we show the process for both QSP and second order Suzuki-Trotter, though this process could likely be generalized to many quantum algorithms.\n", - "It should be noted that the approach shown here provides a slight over-estimation since it assumes that each of the subcircuits operate in serial. This\n", - "assumption is valid for both QSP and second order Suzuki-Trotter since the operations which consume the bulk of the circuit volume do operate in serial\n", - "(Select and Reflect Operations and Trotter steps respectively)." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "0539e963-7921-4c81-926d-8bb281a386a8", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Estimating Square\n", - "Estimating Triangle\n", - "Estimating Cube\n", - "Finished estimating\n" - ] - } - ], - "source": [ - "print(\"Estimating Square\", flush=True)\n", - "qsp_circ_square = estimate_qsp(H_square, timesteps, required_precision, \"QSP/square_circuits/\", hamiltonian_name=\"square\")\n", - "print(\"Estimating Triangle\", flush=True)\n", - "qsp_circ_triangle = estimate_qsp(H_triangle, timesteps, required_precision, \"QSP/triangle_circuits/\", hamiltonian_name=\"triangle\")\n", - "print(\"Estimating Cube\", flush=True)\n", - "qsp_circ_cube = estimate_qsp(H_cube, timesteps, required_precision, \"QSP/cube_circuits/\", hamiltonian_name=\"cube\")\n", - "print(\"Finished estimating\", flush=True)" - ] - }, - { - "cell_type": "markdown", - "id": "6eeb2af2-d380-42bb-bc5f-f0e331398087", - "metadata": {}, - "source": [ - "# More complicated Hamiltonian\n", - "There are a few ways to make the simulation task more challenging and more application relevant.\n", - "The Kitaev honeycomb model is hypothesized to be a good model for the structure of many materials (see for example [here](https://www.sciencedirect.com/science/article/pii/S0370157321004051)). This model is appealing for quantum simulation purposes because while the behavior in the infinite time regime is [understood](https://www.cambridge.org/core/books/introduction-to-topological-quantum-computation/kitaevs-honeycomb-lattice-model/85E968DD7C54F8062C4EAF5394DAAAF6), the behavior with minor perturbations to the model or the dynamics of the model are not so well [understood](https://courses.physics.illinois.edu/phys598PTD/fa2013/L26.pdf). The Kitaev honeycomb model consists of directionally defined $XX$, $YY$, and $ZZ$ couplings on a honeycomb lattice. These assignments are denoted in the plot below by 'X', 'Y', or 'Z' respectively." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "7c2dd2b5-b8f7-409b-9a87-50cecd2a9f9c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def assign_hexagon_labels(g):\n", - " for n1, n2 in g.edges:\n", - " #start by making sure that the edges are ordered correctly\n", - " r1,c1 = n1\n", - " r2,c2 = n2\n", - " if r2 - r1 < 0 or c2 - c1 < 0:\n", - " swap_r2 = r1\n", - " swap_c2 = c1\n", - " r1 = r2\n", - " c1 = c2\n", - " r2 = swap_r2\n", - " c2 = swap_c2\n", - " \n", - " #now that they are ordered correctly, we can assign labels\n", - " label = ''\n", - " if c1 == c2:\n", - " label = 'Z'\n", - " elif (((r1 % 2) + (c1 % 2)) % 2 == 0):#apparently you can differentiate X and Y labels based off nx's node label parity. Huh.\n", - " label = 'Y'\n", - " else:\n", - " label = 'X'\n", - " \n", - " g[n1][n2]['label'] = label\n", - "\n", - "g_hexagon = nx.generators.lattice.hexagonal_lattice_graph(3,3)\n", - "pos = nx.get_node_attributes(g_hexagon, 'pos')\n", - "assign_hexagon_labels(g_hexagon)\n", - "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in g_hexagon.edges(data=True)]);\n", - "nx.draw(g_hexagon, pos)\n", - "nx.draw_networkx_edge_labels(g_hexagon, pos,edge_labels = edge_labels);" - ] - }, - { - "cell_type": "markdown", - "id": "004a4862-23ed-43b1-ab8e-83b46985b721", - "metadata": {}, - "source": [ - "From this graph we can generate the Hamiltonian\n", - "\\begin{equation*}\n", - "H_{\\text{Kitaev}} = \\sum_{(i,j) \\in X \\text{ edges}} J_{i,j} \\sigma_i^x \\sigma_j^x + \\sum_{(i,j) \\in Y \\text{ edges}} J_{i,j} \\sigma_i^y \\sigma_j^y + \\sum_{(i,j) \\in Z \\text{ edges}} J_{i,j} \\sigma_i^z \\sigma_j^z\n", - "\\end{equation*}" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "99de221e-bbed-476f-b5b0-4332f1cfa4a7", - "metadata": {}, - "outputs": [], - "source": [ - "def nx_kitaev_terms(g, p):\n", - " H = []\n", - " n = len(g.nodes)\n", - " for (n1,n2,d) in g.edges(data=True):\n", - " label = d['label']\n", - " weight = 1 if random.random() < p else -1\n", - " string = n*'I' \n", - " for i in range(len(g)):\n", - " if i == n1 or i == n2:\n", - " string = string[:i] + label + string[i+1:]\n", - " else:\n", - " pass\n", - " H.append((string,weight))\n", - " return H\n", - "\n", - "def generate_kitaev_hamiltonian(lattice_size, weight_prob=1):\n", - " g = nx.generators.lattice.hexagonal_lattice_graph(lattice_size,lattice_size)\n", - " assign_hexagon_labels(g)\n", - " g = flatten_nx_graph(g)\n", - " H = nx_kitaev_terms(g, weight_prob)\n", - " return H" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "45ec26c4-376f-4759-b58b-737c546640f1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Estimating Kitaev\n", - "Finished Estimating\n" - ] - } - ], - "source": [ - "lattice_size_kitaev = 32\n", - "#lattice_size_kitaev = 3\n", - "kitaev_hamiltonian = generate_kitaev_hamiltonian(lattice_size_kitaev)\n", - "\n", - "timesteps=1000\n", - "required_precision = 1e-16\n", - "H_kitaev = pyH(kitaev_hamiltonian)\n", - "print(\"Estimating Kitaev\", flush=True)\n", - "qsp_circ_kitaev = estimate_qsp(H_kitaev, timesteps, required_precision, \"QSP/kitaev_circuits/\", hamiltonian_name=\"kitaev\")\n", - "print(\"Finished Estimating\", flush=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "5f09fc3a-d5a0-4540-b431-e9ca26c52907", - "metadata": {}, - "outputs": [], - "source": [ - "def assign_directional_triangular_labels(g,lattice_size): \n", - " for i in range(lattice_size - 1):\n", - " for j in range(lattice_size - 1):\n", - " g[(i,j)][(i+1,j)]['label'] = 'Z'\n", - " g[(i,j)][(i,j+1)]['label'] = 'X'\n", - " g[(i,j)][i+1,j+1]['label'] = 'Y'\n", - " g[(i,lattice_size-1)][(i+1,lattice_size-1)]['label'] = 'Z'\n", - " for j in range(lattice_size - 1):\n", - " g[(lattice_size-1,j)][(lattice_size-1,j+1)]['label'] = 'X'\n", - "\n", - "def generate_directional_triangular_hamiltonian(lattice_size, weight_prob = 1):\n", - " g = nx_triangle_lattice(lattice_size)\n", - " assign_directional_triangular_labels(g,lattice_size)\n", - " g = flatten_nx_graph(g)\n", - " H = nx_kitaev_terms(g, weight_prob)\n", - " return H\n", - "\n", - "g_triangle = nx_triangle_lattice(3)\n", - "assign_directional_triangular_labels(g_triangle,3)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "00a1b407-b45a-43bf-a0c1-856fe51aa0ec", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "g_triangle = nx_triangle_lattice(3)\n", - "assign_directional_triangular_labels(g_triangle,3)\n", - "pos = nx.spring_layout(g_triangle)\n", - "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in g_triangle.edges(data=True)]);\n", - "nx.draw(g_triangle,pos)\n", - "nx.draw_networkx_edge_labels(g_triangle,pos,edge_labels = edge_labels);" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "baa4cf7c-490f-420f-b402-df68739c8b51", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Estimating Directional Triangle\n", - "Finished Estimating\n" - ] - } - ], - "source": [ - "lattice_size_directional_triangle = 32\n", - "#lattice_size_directional_triangle = 3\n", - "directional_triangle_hamiltonian = generate_directional_triangular_hamiltonian(lattice_size_directional_triangle)\n", - "\n", - "timesteps=1000\n", - "required_precision = 1e-16\n", - "timestep_of_interest = 1 # sim_time\n", - "H_directional_triangle = pyH(directional_triangle_hamiltonian)\n", - "\n", - "print(\"Estimating Directional Triangle\", flush=True)\n", - "qsp_circ_directional_triangle = estimate_qsp(H_directional_triangle, timesteps, required_precision, \"QSP/directional_triangle_circuits/\", hamiltonian_name=\"directional_triangle\")\n", - "print(\"Finished Estimating\", flush=True)" - ] - }, - { - "cell_type": "markdown", - "id": "c72b2b05-0464-4b46-9f03-cd56941ba609", - "metadata": {}, - "source": [ - "# Trotter imeplementations\n", - "Now we can do all of this again for second order Suzuki Trotter rather than QSP. Below we will see how to construct a single trotter step of second order Suzuki-Trotter for these hamiltonians along with a loose upper bound for the number of trotter steps required. According to the [documentation](https://quantumai.google/reference/python/openfermion/circuits/error_bound) from openfermion the trotter step estimate for the second order Suzuki-Trotter expansion." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "9d384532-4feb-4026-9578-b531f10876c5", - "metadata": {}, - "outputs": [], - "source": [ - "def find_hamiltonian_ordering(of_hamiltonian):\n", - " \"\"\"\n", - " Function to generate a near optimal term ordering for trotterization of transverse field Ising Models.\n", - " This would need to be modified if there were multi-qubit interactions that were not just ZZ\n", - " \"\"\"\n", - " #ordering hamiltonian terms by performing edge coloring to make optimal trotter ordering\n", - " #assuming that any 2 body interactions are ZZ\n", - " sorted_terms = sorted(list(of_hamiltonian.terms.keys()))\n", - " sorted_terms.sort(key=lambda x: len(x) * 100 + ord(x[0][1])) #Z and X get translated to 90 and 88 respectively, multiplying by 100 ensures interacting term weight is considered\n", - " one_body_terms_ordered = list(filter(lambda x: len(x) == 1, sorted_terms))\n", - " two_body_terms = list(filter(lambda x: len(x) == 2, sorted_terms))\n", - " \n", - " #assigning edge colorings to order two body terms\n", - " g = nx.Graph()\n", - " for term in two_body_terms:\n", - " edge = (term[0][0], term[1][0])\n", - " g.add_edge(*edge)\n", - " edge_coloring = nx.greedy_color(nx.line_graph(g))\n", - " nx.set_edge_attributes(g, edge_coloring, \"color\")\n", - " colors = list()\n", - " for (i,term) in enumerate(two_body_terms):\n", - " n1,n2 = (term[0][0], term[1][0])\n", - " color = g.edges[n1,n2]['color']\n", - " term = (*term, color)\n", - " two_body_terms[i] = term\n", - " \n", - " two_body_terms.sort(key=lambda x: x[2])\n", - " two_body_terms_ordered = list()\n", - " for (i,term) in enumerate(two_body_terms):\n", - " new_item = (term[0],term[1])\n", - " two_body_terms_ordered.append((term[0], term[1]))\n", - " return one_body_terms_ordered + two_body_terms_ordered\n", - "\n", - "def estimate_trotter(openfermion_hamiltonian,timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n", - " nsteps = openfermion.circuits.trotter_steps_required(trotter_error_bound = openfermion.circuits.error_bound(list(openfermion_hamiltonian.get_operators()),tight=False),\n", - " time = timesteps, \n", - " energy_precision = energy_precision)\n", - " term_ordering = find_hamiltonian_ordering(openfermion_hamiltonian)\n", - " trotter_circuit_of = openfermion.circuits.trotter_exp_to_qgates.trotterize_exp_qubop_to_qasm(openfermion_hamiltonian, trotter_order=2, evolution_time=timesteps/nsteps, term_ordering=term_ordering)\n", - " qasm_str_trotter = open_fermion_to_qasm(openfermion.count_qubits(openfermion_hamiltonian), trotter_circuit_of)\n", - " trotter_circuit_qasm = qasm_import.circuit_from_qasm(qasm_str_trotter)\n", - " cpt_trotter = clifford_plus_t_direct_transform(trotter_circuit_qasm)\n", - " \n", - " #writing the the higher level trotter circuit to a file as well as the clifford + T circuit\n", - " if not os.path.exists(outdir):\n", - " os.makedirs(outdir)\n", - " \n", - " if write_circuits:\n", - " outfile_qasm_decomposed = outdir + \"trotter_circuit_\" + hamiltonian_name + \".qasm\" \n", - " outfile_qasm_cpt = outdir + \"trotter_cpt_\" + hamiltonian_name + \".qasm\"\n", - " with open(outfile_qasm_decomposed, 'w') as f:\n", - " print_to_openqasm(f, trotter_circuit_qasm, qubits=trotter_circuit_qasm.all_qubits())\n", - " with open(outfile_qasm_cpt, 'w') as f:\n", - " print_to_openqasm(f, cpt_trotter, qubits=cpt_trotter.all_qubits())\n", - " \n", - " outfile_data = outdir + \"trotter_\" + hamiltonian_name + \".dat\"\n", - " gate_count = count_gates(cpt_trotter)\n", - " t_count = count_T_gates(cpt_trotter)\n", - " t_depth = get_T_depth(cpt_trotter)\n", - " t_depth_wire = get_T_depth_wire(cpt_trotter)\n", - " with open(outfile_data, 'w') as f:\n", - " f.write(\"Logical Qubit Count:\"+str(len(cpt_trotter.all_qubits()))+\"\\n\")\n", - " f.write(\"Number of Trotter Steps Required (Loose Upper Bound):\"+ str(nsteps) +\"\\n\")\n", - " f.write(\"Total T Depth:\"+str(t_depth * nsteps)+\"\\n\")\n", - " f.write(\"Maximum T Count on a Single Wire:\"+str(t_depth_wire * nsteps)+\"\\n\")\n", - " f.write(\"Single Step Gate Count:\"+str(gate_count)+\"\\n\")\n", - " f.write(\"Single Step Gate Depth:\"+str(len(cpt_trotter))+\"\\n\")\n", - " f.write(\"Single Step T Count:\"+str(t_count)+\"\\n\")\n", - " f.write(\"Single Step T Depth:\"+str(t_depth)+\"\\n\")\n", - " f.write(\"Single Step Maximum T Count on a Single Wire:\"+str(t_depth_wire)+\"\\n\")\n", - " f.write(\"Single Step Clifford Count:\"+str(gate_count - t_count)+\"\\n\")\n", - " \n", - " return cpt_trotter" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "34b95e4f-f45d-4101-ade3-c500fd8be257", - "metadata": {}, - "outputs": [], - "source": [ - "##Translating the hamiltonians from above into a form usable by openfermion\n", - "openfermion_hamiltonian_square = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_square)\n", - "openfermion_hamiltonian_triangle = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_triangle)\n", - "openfermion_hamiltonian_cube = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_cube)\n", - "openfermion_hamiltonian_kitaev = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_kitaev)\n", - "openfermion_hamiltonian_directional_triangle = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_directional_triangle)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "f1fceb25-e1c6-46fd-9290-32eb5abe620b", - "metadata": {}, - "outputs": [], - "source": [ - "#defining precision required for the trotterized circuit\n", - "energy_precision = 1e-6\n", - "timesteps=1000" - ] - }, - { - "cell_type": "markdown", - "id": "ba4875f2-fc0f-4ade-a1e9-0d4823fc98eb", - "metadata": {}, - "source": [ - "## Estimates\n", - "Trotterizing the Hamiltonians and writing estimates to files" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "0dbcf4e9-b48a-486c-bea1-bf4428201a90", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Estimating Square\n", - "Estimating Triangle\n", - "Estimating Cube\n", - "Estimating Kitaev\n", - "Estimating Directional Triangle\n", - "Finished with estimates\n" - ] - } - ], - "source": [ - "print(\"Estimating Square\", flush=True)\n", - "cpt_trotter_square = estimate_trotter(openfermion_hamiltonian_square, timesteps, energy_precision, \"Trotter/square_circuits/\", hamiltonian_name=\"square\")\n", - "print(\"Estimating Triangle\", flush=True)\n", - "cpt_trotter_triangle = estimate_trotter(openfermion_hamiltonian_triangle, timesteps, energy_precision, \"Trotter/triangle_circuits/\", hamiltonian_name=\"triangle\")\n", - "print(\"Estimating Cube\", flush=True)\n", - "cpt_trotter_cube = estimate_trotter(openfermion_hamiltonian_cube, timesteps, energy_precision, \"Trotter/cube_circuits/\", hamiltonian_name=\"cube\")\n", - "print(\"Estimating Kitaev\", flush=True)\n", - "cpt_trotter_kitaev = estimate_trotter(openfermion_hamiltonian_kitaev, timesteps, energy_precision, \"Trotter/kitaev_circuits/\", hamiltonian_name=\"kitaev\")\n", - "print(\"Estimating Directional Triangle\", flush=True)\n", - "cpt_trotter_directional_triangle = estimate_trotter(openfermion_hamiltonian_directional_triangle, timesteps, energy_precision, \"Trotter/directional_triangle_circuits/\", hamiltonian_name=\"directional_triangle\")\n", - "print(\"Finished with estimates\", flush=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "9586f806-d9cb-41d0-8045-590d55509a84", - "metadata": {}, - "outputs": [], - "source": [ - "figdir = \"Trotter/Figures/\"\n", - "widthdir = \"Trotter/Widths/\"\n", - "if not os.path.exists(figdir):\n", - " os.makedirs(figdir)\n", - "if not os.path.exists(widthdir):\n", - " os.makedirs(widthdir)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "97f2fe81-0741-4b4e-9702-6133d01ad86a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAAsTAAALEwEAmpwYAAAWHklEQVR4nO3dfbRddX3n8fdHEHzAFigxhSR4sUan0C7BdbUIDoPSVh7sQF2WQh2liI0u0YJjtcG6RjouZjIjxae2OBGoWCnCIAwoLCsglZHyYIKMGtAxYiLJ5AkEiU9o4Dt/nH23h3Bzcy7knHNvzvu11l337N/e+5zv3dk5n/P77X32TlUhSRLA04ZdgCRp5jAUJEktQ0GS1DIUJEktQ0GS1DIUJEktQ0GS1DIUNCslWZXkd5/C+mNJKsmuXW1/muQrO6ZCaXYyFLRT6n6z35lfsxcztS7NTIaCZp0k/wjsD3wuyY+SvKfrk/9pSb4PfCnJ05K8L8nqJBuTfCrJrzZPc3Pz+6HmOV4OfBx4eTP9UPNauyc5N8n3k2xI8vEkz2zmHZlkTZK/TLIe+IdJan1Bki8n+WGS+5Nc1jXv95J8q5n3t81yb27mnZ3k013LPq5nk+TUJPck2Zzk3iRv6Vr2CXU122Jxku8meSDJ5Un23lH/Jtp5GAqadarqDcD3gT+oqj2q6r93zf53wG8Crwb+tPl5JfB8YA/gb5vljmh+79k8x63AW4Fbm+k9m/lLgBcCBwMvAOYB/6nr9X4d2Bt4HrBoknI/AHwR2AuYD3wMIMk+wJXA+4B9gO8Ch09jM2wEXgP8CnAq8KEkL5mirncAJ9DZPvsBDwJ/N43X04gwFLSzObuqflxVPwVeD5xXVfdW1Y+As4CTeh1OSRI6b6jvrKofVNVm4L8AJ3Ut9hjw/qp6pHnNrf2CzhvzflX1s6qaOGZxLLCiqq6oql8AHwbW9/pHVtW1VfXd6vgyneD5t1PU9Vbgr6pqTVU9ApwNvM6hJW3NUNDO5r6ux/sBq7umVwO7AnN7fK45wLOA5UkeaoaUvtC0T9hUVT+b4jneAwS4I8mKJG/qqq2ttTpXprxvkvUnleSYJLcl+UFT17F0ehzbqut5wFVdf8c9wKP0vi00IvyUoNlqW5f37W7/f3TeDCfsD2wBNtAZBtrec94P/BQ4qKrWTrOOzsyq9cCfASR5BXBDkpuBdcCCieWaXsmCrlV/TCeQJvx617K7A58F3ghcXVW/SPK/6ITPtuq6D3hTVd0yVb2SPQXNVhvoHCeYyqXAO5MckGQPOkM/l1XVFmATnSGW7ufYAMxPshtAVT0GfILOeP1zAZLMS/LqXotM8kdJ5jeTD9J5s34MuBY4KMlrmyGcP6frjR+4Czgiyf7NwfGzuubtBuze/A1bkhwD/P52Svk4cE6S5zV1zUlyfK9/h0aHoaDZ6r8C72uGQ/5iG8tcBPwjnTONvgf8jM4BV6rqJ8A5wC3NcxwKfAlYAaxPcn/zHH8JrARuS/IwcAPwomnU+VLg9iQ/Aq4BzmiOcdwP/BGdA9kPAAuB9lN8VV0PXAZ8HVgOfL5r3mY6IXI5naD5k+a5p/KRZpkvJtkM3Ab8zjT+Do2IeJMdaWZI8i/Ap6vqgmHXotFlT0GS1DIUJEkth48kSS17CpKk1qz+nsI+++xTY2Njwy5DkmaV5cuX319VcyabN6tDYWxsjGXLlg27DEmaVZKs3tY8h48kSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSa1Z/Y1mPd7Y4mvbx6uWHDfESiTNVvYUJEktQ0GS1DIUJEktQ0GS1DIUJEktQ0GS1DIUJEktv6ewk+r+zgL4vQVJvbGnIElqGQqSpJahIElqeUxhFtv6uEGvy3p8QdK22FOQJLUMBUlSy1CQJLUMBUlSy1CQJLUMBUlSq2+hkGRBkpuS3J1kRZIzmvazk6xNclfzc2zXOmclWZnk20le3a/aJEmT6+f3FLYA76qqO5M8B1ie5Ppm3oeq6tzuhZMcCJwEHATsB9yQ5IVV9Wgfa5QkdelbT6Gq1lXVnc3jzcA9wLwpVjke+ExVPVJV3wNWAi/rV32SpCcayDGFJGPAIcDtTdPbk3w9yUVJ9mra5gH3da22hqlDRJK0g/U9FJLsAXwWOLOqHgbOB34DOBhYB/zNNJ9vUZJlSZZt2rRpR5crSSOtr6GQ5Ol0AuGSqroSoKo2VNWjVfUY8Al+OUS0FljQtfr8pu1xqmppVY1X1ficOXP6Wb4kjZx+nn0U4ELgnqo6r6t9367F/hD4ZvP4GuCkJLsnOQBYCNzRr/okSU/Uz7OPDgfeAHwjyV1N23uBk5McDBSwCngLQFWtSHI5cDedM5dO98wjSRqsvoVCVX0FyCSzrptinXOAc/pVkyRpan6jWZLUMhQkSS1DQZLUMhQkSS3v0TyCtr63s/dsljTBnoIkqWVPYZbZ+lO+JO1I9hQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSS1DQZLUMhQkSa2+hUKSBUluSnJ3khVJzmja905yfZLvNL/3atqT5KNJVib5epKX9Ks2SdLk+tlT2AK8q6oOBA4FTk9yILAYuLGqFgI3NtMAxwALm59FwPl9rE2SNIm+hUJVrauqO5vHm4F7gHnA8cDFzWIXAyc0j48HPlUdtwF7Jtm3X/VJkp5o10G8SJIx4BDgdmBuVa1rZq0H5jaP5wH3da22pmlb19VGkkV0ehLsv//+/St6hhhbfO2wS5A0Qvp+oDnJHsBngTOr6uHueVVVQE3n+apqaVWNV9X4nDlzdmClkqS+hkKSp9MJhEuq6sqmecPEsFDze2PTvhZY0LX6/KZNkjQg/Tz7KMCFwD1VdV7XrGuAU5rHpwBXd7W/sTkL6VDgh13DTJKkAejnMYXDgTcA30hyV9P2XmAJcHmS04DVwInNvOuAY4GVwE+AU/tYmyRpEn0Lhar6CpBtzD5qkuULOL1f9Wjbug9mr1py3BArkTRsfqNZktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktTqKRSSHN5LmyRpduu1p/CxHtskSbPYrlPNTPJy4DBgTpL/2DXrV4Bd+lmYJGnwpgwFYDdgj2a553S1Pwy8rl9FSZKGY8pQqKovA19O8smqWj2gmiRJQ7K9nsKE3ZMsBca616mqV/WjKEnScPQaCv8T+DhwAfBo/8qRJA1Tr2cfbamq86vqjqpaPvEz1QpJLkqyMck3u9rOTrI2yV3Nz7Fd885KsjLJt5O8+kn+PZKkp6DXUPhckrcl2TfJ3hM/21nnk8DRk7R/qKoObn6uA0hyIHAScFCzzt8n8ewmSRqwXoePTml+v7urrYDnb2uFqro5yViPz3888JmqegT4XpKVwMuAW3tcXzvI2OJrHze9aslxQ6pE0jD0FApVdcAOfM23J3kjsAx4V1U9CMwDbutaZk3T9gRJFgGLAPbff/8dWJYkqadQaN7En6CqPjXN1zsf+ACdXsYHgL8B3jSdJ6iqpcBSgPHx8Zrm60uSptDr8NFLux4/AzgKuBOYVihU1YaJx0k+AXy+mVwLLOhadH7TJkkaoF6Hj97RPZ1kT+Az032xJPtW1bpm8g+BiTOTrgH+Kcl5wH7AQuCO6T6/JOmp6bWnsLUfA1MeZ0hyKXAksE+SNcD7gSOTHExn+GgV8BaAqlqR5HLgbmALcHpV+X0ISRqwXo8pfI7OGzl0LoT3m8DlU61TVSdP0nzhFMufA5zTSz07u63PAJKkQem1p3Bu1+MtwOqqWtOHeiRJQ9TTl9eaC+N9i86VUvcCft7PoiRJw9Hr8NGJwAeBfwECfCzJu6vqij7WphmgeyjLL7JJO79eh4/+CnhpVW0ESDIHuAEwFCRpJ9LrtY+eNhEIjQemsa4kaZbotafwhST/DFzaTP8xcF1/SpIkDcv27tH8AmBuVb07yWuBVzSzbgUu6XdxkqTB2l5P4cPAWQBVdSVwJUCS327m/UEfa5MkDdj2jgvMrapvbN3YtI31pSJJ0tBsLxT2nGLeM3dgHZKkGWB7obAsyZ9t3ZjkzcCUt+OUJM0+2zumcCZwVZLX88sQGAd2o3OVU0nSTmTKUGjuf3BYklcCv9U0X1tVX+p7ZZKkgev1fgo3ATf1uRZJ0pD5rWRJUstQkCS1DAVJUstQkCS1DAVJUstQkCS1DAVJUstQkCS1DAVJUstQkCS1DAVJUstQkCS1DAVJUqunq6RKAGOLr33c9Kolxw2pEkn90reeQpKLkmxM8s2utr2TXJ/kO83vvZr2JPlokpVJvp7kJf2qS5K0bf0cPvokcPRWbYuBG6tqIXBjMw1wDLCw+VkEnN/HuiRJ29C3UKiqm4EfbNV8PHBx8/hi4ISu9k9Vx23Ankn27VdtkqTJDfpA89yqWtc8Xg/MbR7PA+7rWm5N0/YESRYlWZZk2aZNm/pXqSSNoKGdfVRVBdSTWG9pVY1X1ficOXP6UJkkja5Bh8KGiWGh5vfGpn0tsKBruflNmyRpgAYdCtcApzSPTwGu7mp/Y3MW0qHAD7uGmSRJA9K37ykkuRQ4EtgnyRrg/cAS4PIkpwGrgRObxa8DjgVWAj8BTu1XXZKkbetbKFTVyduYddQkyxZwer9qkST1xstcSJJahoIkqWUoSJJahoIkqWUoSJJahoIkqWUoSJJahoIkqWUoSJJahoIkqWUoSJJahoIkqWUoSJJahoIkqdW3S2erd2OLrx12CZIE2FOQJHUxFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktQyFCRJLUNBktTyG8160rq/ib1qyXFDrETSjmJPQZLUMhQkSS1DQZLUGsoxhSSrgM3Ao8CWqhpPsjdwGTAGrAJOrKoHh1Gfpm/rK716jEGanYbZU3hlVR1cVePN9GLgxqpaCNzYTEuSBmgmDR8dD1zcPL4YOGF4pUjSaBpWKBTwxSTLkyxq2uZW1brm8Xpg7mQrJlmUZFmSZZs2bRpErZI0Mob1PYVXVNXaJM8Frk/yre6ZVVVJarIVq2opsBRgfHx80mUkSU/OUHoKVbW2+b0RuAp4GbAhyb4Aze+Nw6hNkkbZwHsKSZ4NPK2qNjePfx/4z8A1wCnAkub31YOubZC8L7OkmWgYw0dzgauSTLz+P1XVF5J8Fbg8yWnAauDEIdQmSSNt4KFQVfcCL56k/QHgqEHXI0n6pZl0SqokacgMBUlSy1CQJLUMBUlSy1CQJLW885r6wruySbOTPQVJUstQkCS1DAVJUstQkCS1DAVJUsuzj9R33r9Zmj0MhQHxUtmSZgOHjyRJLUNBktRy+EhD5fEGaWYxFDRwHl+RZi6HjyRJLXsKfeQnYkmzjT0FSVLLUJAktRw+0owyzPsweCaUZE9BktRlZHsK/fhU6IHlmWFn+MS/M/wNmp1GNhQ0Orw16OC4rWc/Q2Ga/ASnYfDNVoNiKEzCN/6ZaSa9Mc6kWvrN/w+jxVDogccKZp4d9UY11b/tbHzjn0lv4NYyO824UEhyNPARYBfggqpaMuSStBPpR8AP+g1nOq/Xj2CbjWGp3qWqhl1DK8kuwP8Ffg9YA3wVOLmq7p5s+fHx8Vq2bNmTei0//atfut8op9rPtn5D7fc+2Wt4bL3soP+vTKfOqdbrddmZ3IvoVwAnWV5V45PNm2k9hZcBK6vqXoAknwGOByYNBUm9e7I9jEEbxJt0r3/foE9df7LBvSPNtJ7C64Cjq+rNzfQbgN+pqrd3LbMIWNRMvgj49pN8uX2A+59CuTsrt8vk3C6Tc7tMbqZvl+dV1ZzJZsy0nsJ2VdVSYOlTfZ4ky7bVfRplbpfJuV0m53aZ3GzeLjPtMhdrgQVd0/ObNknSAMy0UPgqsDDJAUl2A04CrhlyTZI0MmbU8FFVbUnyduCf6ZySelFVrejTyz3lIaidlNtlcm6XybldJjdrt8uMOtAsSRqumTZ8JEkaIkNBktQayVBIcnSSbydZmWTxsOsZliQLktyU5O4kK5Kc0bTvneT6JN9pfu817FqHIckuSb6W5PPN9AFJbm/2m8uakyFGSpI9k1yR5FtJ7knycvcXSPLO5v/QN5NcmuQZs3V/GblQaC6l8XfAMcCBwMlJDhxuVUOzBXhXVR0IHAqc3myLxcCNVbUQuLGZHkVnAPd0Tf834ENV9QLgQeC0oVQ1XB8BvlBV/wZ4MZ3tM9L7S5J5wJ8D41X1W3ROkjmJWbq/jFwo0HUpjar6OTBxKY2RU1XrqurO5vFmOv/B59HZHhc3i10MnDCUAocoyXzgOOCCZjrAq4ArmkVGbrsk+VXgCOBCgKr6eVU9hPsLdM7kfGaSXYFnAeuYpfvLKIbCPOC+ruk1TdtISzIGHALcDsytqnXNrPXA3GHVNUQfBt4DPNZM/xrwUFVtaaZHcb85ANgE/EMzrHZBkmcz4vtLVa0FzgW+TycMfggsZ5buL6MYCtpKkj2AzwJnVtXD3fOqc87ySJ23nOQ1wMaqWj7sWmaYXYGXAOdX1SHAj9lqqGhE95e96PSWDgD2A54NHD3Uop6CUQwFL6XRJcnT6QTCJVV1ZdO8Icm+zfx9gY3Dqm9IDgf+fZJVdIYXX0VnLH3PZngARnO/WQOsqarbm+kr6ITEqO8vvwt8r6o2VdUvgCvp7EOzcn8ZxVDwUhqNZpz8QuCeqjqva9Y1wCnN41OAqwdd2zBV1VlVNb+qxujsH1+qqtcDNwGvaxYbxe2yHrgvyYuapqPoXNZ+pPcXOsNGhyZ5VvN/amK7zMr9ZSS/0ZzkWDpjxhOX0jhnuBUNR5JXAP8b+Aa/HDt/L53jCpcD+wOrgROr6gdDKXLIkhwJ/EVVvSbJ8+n0HPYGvgb8h6p6ZIjlDVySg+kcfN8NuBc4lc6Hy5HeX5L8NfDHdM7o+xrwZjrHEGbd/jKSoSBJmtwoDh9JkrbBUJAktQwFSVLLUJAktQwFSVLLUJAaSX4tyV3Nz/oka7umd2uWOSPJh7vW+R9JbuiafkeSjyYZT/LRbbzOqiT7NFccfVtX+5ETV2SVhmVG3Y5TGqaqegA4GCDJ2cCPqurcrRa7BXh91/SLgV2S7FJVjwKHAVdX1TJg2XZeck/gbcDfP+XipR3EnoI0PXcBL0zyzOaqoT9t2n67mX8YcEv3p/6mB/LF5nr7FwBpll0C/EbTE/lg07ZH1/0KLmm+ISsNjKEgTUNz1cuvAS+lcw+K24HbgMOa6+qnqu7barX3A1+pqoOAq+h88xc6F5P7blUdXFXvbtoOAc6kc6+P59O5ho40MIaCNH3/SqdHcBhwa/MzMf2vkyx/BPBpgKq6ls4NV7bljqpaU1WP0emBjO2wqqUeeExBmr5bgLcCz6BzF79NdD7Zb2LyUJiO7mvjPIr/RzVg9hSk6buVztDRnKra2NxDYBOda+rfMsnyNwN/ApDkGGDiHsabgef0v1ypd4aCNE1V9SCdEFjR1Xwr8Fzg/0yyyl8DRyRZAbyWzqWWJ852uqW52fsHJ1lPGjivkipJatlTkCS1DAVJUstQkCS1DAVJUstQkCS1DAVJUstQkCS1/j8rKIKwRS3qpQAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "histogram_trotter_square = plot_T_step_histogram(cpt_trotter_square)\n", - "plt.title(\"trotter square\")\n", - "plt.xlabel(\"T Width\")\n", - "plt.ylabel(\"Count\")\n", - "plt.savefig(figdir + \"trotter_cpt_t_width_histogram_square.pdf\")\n", - "\n", - "df_histogram_trotter_square = pd.DataFrame({\"bin\": histogram_trotter_square[1][:-1], \\\n", - " \"count\": histogram_trotter_square[0]})\n", - "df_histogram_trotter_square.to_csv(widthdir + \"widths_square.csv\", sep=\",\", index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "98cf6cfe-6013-432b-b0ef-05ec1ce938e5", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "histogram_trotter_triangle = plot_T_step_histogram(cpt_trotter_triangle)\n", - "plt.title(\"trotter triangle\")\n", - "plt.xlabel(\"T Width\")\n", - "plt.ylabel(\"count\")\n", - "plt.savefig(figdir + \"trotter_cpt_t_width_histogram_triangle.pdf\")\n", - "\n", - "df_histogram_trotter_triangle = pd.DataFrame({\"bin\": histogram_trotter_triangle[1][:-1], \\\n", - " \"count\": histogram_trotter_triangle[0]})\n", - "df_histogram_trotter_triangle.to_csv(widthdir + \"widths_triangle.csv\", sep=\",\", index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "51c4ebd5-c444-41dd-8e23-5692ad216006", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "histogram_trotter_cube = plot_T_step_histogram(cpt_trotter_cube)\n", - "plt.title(\"trotter cube\")\n", - "plt.xlabel(\"T Width\")\n", - "plt.ylabel(\"count\")\n", - "plt.savefig(figdir + \"trotter_cpt_t_width_histogram_cube.pdf\")\n", - "\n", - "df_histogram_trotter_cube = pd.DataFrame({\"bin\": histogram_trotter_cube[1][:-1], \\\n", - " \"count\": histogram_trotter_cube[0]})\n", - "df_histogram_trotter_cube.to_csv(widthdir + \"widths_cube.csv\", sep=\",\", index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "9dd0392d-3d1e-43fc-92e5-da82d1437a2a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "histogram_trotter_kitaev = plot_T_step_histogram(cpt_trotter_kitaev)\n", - "plt.title(\"trotter kitaev\")\n", - "plt.xlabel(\"T Width\")\n", - "plt.ylabel(\"Count\")\n", - "plt.savefig(figdir + \"trotter_cpt_t_width_histogram_kitaev.pdf\")\n", - "\n", - "df_histogram_trotter_kitaev = pd.DataFrame({\"bin\": histogram_trotter_kitaev[1][:-1], \\\n", - " \"count\": histogram_trotter_kitaev[0]})\n", - "df_histogram_trotter_kitaev.to_csv(widthdir + \"widths_kitaev.csv\", sep=\",\", index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "a345d7cd-2f67-48c4-8c76-4bd991f203e3", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "histogram_trotter_directional_triangle = plot_T_step_histogram(cpt_trotter_directional_triangle)\n", - "plt.title(\"trotter directional_triangle\")\n", - "plt.xlabel(\"T Width\")\n", - "plt.ylabel(\"Count\")\n", - "plt.savefig(figdir + \"trotter_cpt_t_width_histogram_directional_triangle.pdf\")\n", - "\n", - "df_histogram_trotter_directional_triangle = pd.DataFrame({\"bin\": histogram_trotter_directional_triangle[1][:-1], \\\n", - " \"count\": histogram_trotter_directional_triangle[0]})\n", - "df_histogram_trotter_directional_triangle.to_csv(widthdir + \"widths_directional_triangle.csv\", sep=\",\", index=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "79f52ea8-0d7a-4074-856b-153c29162e24", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total Notebook Runtime: 2413.169842057\n" - ] - } - ], - "source": [ - "t_final = time.perf_counter()\n", - "print(\"Total Notebook Runtime: \" + str(t_final))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a97bb917-466e-4a75-b554-e413278ba830", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.8.8" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/MagneticLattices.ipynb b/notebooks/MagneticLattices.ipynb new file mode 100644 index 0000000..dcc8f5b --- /dev/null +++ b/notebooks/MagneticLattices.ipynb @@ -0,0 +1,873 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basic examples\n", + "This notebook outlines the construction of Hamiltonians which are not inherently useful\n", + "on their own, but are of a similar form to what we expect for the most basic\n", + "simulations where a quantum computer may be useful. This version is a working version and\n", + "will likely be updated later to include more application relevant examples. The dynamic\n", + "simulation of these Hamiltonians can be thought of as a necessary but not sufficient\n", + "condition for demonstrating the viability of a quantum computer as a useful tool for \n", + "quanutm dynamic simulation.\n", + "\n", + "Note that running this entire notebook should take on the order of an hour.\n", + "To see smaller cases, simply reduce the sizes of the lattices for the various Hamiltonians.\n", + "\n", + "## Basic Hamiltonian\n", + "In this section we consider the time independent transverse field Ising Hamiltonians represented by graphs\n", + "with a lattice structure. There are more complicated models which would likely\n", + "be interesting to simulate, but as an initial pass we start by considering two models\n", + "* 32x32 Triangular Lattice (1024 spins, 2 dimensions) with antiferromagnetic unit couplings\n", + "* 12x12x12 Cubic Lattice (1728 spins, 3 dimensions) with random unit couplings\n", + "The transverse field Ising Hamiltonian for a lattice graph, $G = (V,E)$ is as follows:\n", + "\n", + "\\begin{equation}\n", + "H = \\sum_{i \\in V} \\Gamma_{i}\\sigma_{i}^{x} + \\sum_{i \\in V} h_{i} \\sigma_{i}^{z} + \\sum_{(i,j) \\in E} J_{i,j} \\sigma_{i}^{z} \\sigma_{j}^{z}\n", + "\\end{equation}\n", + "Note that in the instances presented here, we do not consider local longitudinal field terms ($\\boldsymbol{h}=0$), though this may not always be the case.\n", + "We also do not consider in this example the state preparation circuit that may be required as that is heavily application dependent.\n", + "For the purposes of these initial experiments, we can assume that the initial state is an eigenstate of either the $X$ or $Z$ basis since the preparation circuits for these have $O(1)$ depth.\n", + "\n", + "To be clear, the dynamic simulations mean simulating the Schrodinger Equation\n", + "\\begin{equation}\n", + "i \\hbar \\frac{\\partial}{\\partial t}|\\psi(t)\\rangle = H |\\psi(t)\\rangle\n", + "\\end{equation}\n", + "with solution\n", + "\\begin{equation}\n", + "|\\psi(t)\\rangle = e^{-\\frac{i}{\\hbar}H t}|\\psi(0)\\rangle\n", + "\\end{equation}\n", + "\n", + "A subgraph of each lattice is plotted below to clarify the graph structure to clarify the graph structure." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import random\n", + "import numpy as np\n", + "import networkx as nx\n", + "from networkx import grid_graph\n", + "from openfermion import count_qubits\n", + "from networkx.classes.graph import Graph\n", + "from openfermion.circuits import error_bound\n", + "from openfermion.circuits import trotter_steps_required\n", + "from networkx.generators.lattice import hexagonal_lattice_graph\n", + "from openfermion.circuits.trotter_exp_to_qgates import trotterize_exp_qubop_to_qasm\n", + "from qca.utils.utils import count_gates, get_T_depth_wire, get_T_depth, plot_histogram\n", + "from qca.utils.hamiltonian_utils import (nx_triangle_lattice, flatten_nx_graph,\n", + " generate_square_hamiltonian, pyliqtr_hamiltonian_to_openfermion_qubit_operator,\n", + " assign_directional_triangular_labels, generate_triangle_hamiltonian,\n", + " assign_hexagon_labels)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import cirq\n", + "from cirq.contrib import qasm_import\n", + "from pyLIQTR.circuits.qsp import generate_QSP_circuit\n", + "from pyLIQTR.utils.qsp_helpers import print_to_openqasm\n", + "from pyLIQTR.utils.Hamiltonian import Hamiltonian as pyH\n", + "from pyLIQTR.utils.qsp_helpers import circuit_decompose_once\n", + "from pyLIQTR.utils.utils import open_fermion_to_qasm, count_T_gates\n", + "from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform\n", + "from pyLIQTR.phase_factors.fourier_response.fourier_response import Angler_fourier_response\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "lattice_size = 3\n", + "graph_square = grid_graph(dim = (lattice_size, lattice_size))\n", + "graph_triangle = nx_triangle_lattice(lattice_size)\n", + "graph_cube = grid_graph(dim = (lattice_size, lattice_size, lattice_size))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw(graph_square)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw(graph_triangle)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeUDM+f/A8edUQu5K7txZKndCkg4hR8lt3SzWbV257/u2WPfVuhblPkvkTFboQAhlUSpHB2ma+f3h13xZrNJMM1Pvx59bfT6vWfWZ17zfr/frJZHL5XIEQRAEQRAE4QfpqDsAQRAEQRAEQbuJhFIQBEEQBEHIEpFQCoIgCIIgCFkiEkpBEARBEAQhS0RCKQiCIAiCIGSJSCgFQRAEQRCELBEJpSAIgiAIgpAlIqEUBEEQBEEQskQklIIgCIIgCEKWiIRSEARBEARByBKRUAqCIAiCIAhZIhJKQRAEQRAEIUtEQikIgiAIgiBkiUgoBUEQBEEQhCwRCaUgCIIgCIKQJSKhFARBEARBELJEJJSCIAiCIAhCloiEUhAEQRAEQcgSkVAKgiAIgiAIWSISSkEQBEEQBCFLREIpCIIgCIIgZIlIKAVBEARBEIQsEQmlIAiCIAiCkCUioRQEQRAEQRCyRCSUgiAIgiAIQpaIhFIQBEEQBEHIEpFQCoIgCIIgCFkiEkpBEARBEAQhS0RCKQiCIAiCIGSJSCgFQRAEQRCELBEJpSAIgiAIgpAlIqEUBEEQBEEQskQklIIgCIIgCEKWiIRSEARBEARByBKRUAqCIAiCIAhZIhJKQRAEQRAEIUtEQikIgiAIgiBkiZ66AxAEQRCUKylFyuO4JD5IZejr6VDBqAAF8orHvSAIqiOeMIIgCDnA/egEdgZE4ncvhsj4ZOSffE0CmBoaYF/NhJ+tTalaopC6whQEIYeSyOVy+fe/TRAEQdBEUfHJTPIO5sKDWHR1JKTJvv1IT/+6bRVj5rW3pJyhQTZGKghCTiYSSkEQBC21JzCS6YdDkcrk/5lI/puujgQ9HQkz25nT1cpUhREKgpBbiIRSEARBC632u8+S0+FZvs5YZzOG2VdVQkSCIORm4pS3IAiCltkTGKmUZBJgyelw9gZGKuVagiDkXiKhFARB0CJR8clMPxyq1GtOOxxKVHyyUq8pCELuIhJKQRAELTLJOxhpJuolM0IqkzPJO1ip1xQEIXcRCaUgCIKWuB+dwIUHsZk6gJMRaTI5Fx7E8iAmQanXFQQh9xAJpSAIgpbYGRCJro5EJdfW1ZHw51VRSykIwo8RCaUgCIKW8LsXo/TVyXRpMjl+4TEqubYgCDmfSCgFQRC0QGKKlEgVH5yJjEsmKUWq0nsIgpAziYRSEARBCzyJS0LVTYPlwOO4JBXfRRCEnEgklIIgCFrgg1SWo+4jCELOIhJKQRAELfAq7mW23EdfT7wtCIKQeeLJIQiCoGHkcjkPHz5k69at9OnTh0qVKuFkXQtVT8qVABWMCqj0HoIg5Ex66g5AEAQht5PL5dy9exd/f3/Onz+Pv78///zzDxKJhJo1a9K2bVuaNm3Ksvv5+OdNisriMDUyoEBe8bYgCELmiSeHIAhCNpPJZAQHByuSR39/f16+fImuri716tWjW7duNG3alCZNmlCsWDHFzwUfDsUz4IlKWgfp6kiwNzNR+nUFQcgdJHJV76EIgiDkclKplBs3biiSxwsXLvD69Wv09fVp0KABTZs2xc7OjkaNGlGoUKFvXud+dALNV/irLE6f0U2pYvLt+wuCIHyLSCgFQRCULCUlhcDAQMUW9uXLl0lMTCR//vw0atQIOzs7mjZtirW1Nfnz58/UtXtuDuByRJxyVyllabx7cos2BR4zb948SpQoobxrC4KQK4iEUhAEIYuSk5O5evWqYgv76tWrvH//nkKFCtGkSRPFCmS9evXQ19fP0r2i4pNxWn6eFCW298mrp0MfkyiWzJiIVCplxowZDBs2jDx58ijtHoIg5GwioRQEQcikt2/fcvnyZUUCGRgYSGpqKsWKFaNp06aKBLJWrVro6Sm/VH1PYCQeXsFKu95Cd0u6WJkSFxfHtGnTWLduHdWqVWPFihU4Ozsr7T6CIORcIqEUBEH4jvj4eC5cuKDYwg4KCkImk1GiRAlF8ti0aVPMzc3R0cmebmyr/e6z5HR4lq8zzrkaQ+2rfPbfbt26xYgRI/D398fV1ZVly5ZRqVKlLN9LEIScSySUgiAI/xIdHa04QHP+/HmCgz+uBpYtWxY7OztFAmlmZoZEIlFbnHsCI5l+OBSpTJ6pmkpdHQl6OhJmtTOni5XpV79HLpezb98+xowZw8uXLxk7diwTJ06kQAHRp1IQhC+JhFIQhFwvKirqsx6Q9+7dA6By5cqK5NHOzo7y5curNYH8mqj4ZCZ5B3PhQSy6OpL/TCzTv25bxZh57S0pZ2jw3esnJSWxcOFCFi1aRPHixVm8eDFdunTRuP8PgiCol0goBUHIVeRyOREREYrk8fz58zx+/BiAGjVqKJJHW1tbypQpo95gM+F+dAI7AyLxC48hMi6ZTx/sEj42Lbc3M6FHQ9Mfag306NEjxowZg7e3N7a2tqxatYratWsrK3xBELScSCgFQcjR0qfQfNpEPH0KTa1atT5LIIsXL67ucJUiKUVK0P2nODq3YNmSRfTp0FppE3DOnDnDyJEjuXfvHoMGDWL27NkYGRkp5dqCIGgvkVAKgpCjpKWlERwcrFh9vHDhwmdTaNK3sJs0aULRokXVHa7KpKamoq+vz5YtW+jbt6/Sr7127VqmT5+Ojo4Os2fPZtCgQSo50S4IgnYQCaUgCFotNTWVoKAgxQrkxYsXP5tCk55ANm7cmIIFC6o73GxVuHBhpk2bxtixY1Vy/ZiYGCZPnszmzZuxsLBg1apVNGvWTCX3EgRBs4mEUhAErZI+hSY9gbx06RJJSUnkz5+fxo0bK7awGzRokOkpNDlNxYoV6datG/PmzVPpfa5fv86IESO4cuUKnTt3ZvHixZiafv30uCAIOZNIKAVB0GjJyclcuXJFsYV99epVUlJSFFNo0lcglTGFJqepV68eVlZWrFu3TuX3kslk7Ny5k/Hjx/PmzRsmTpzI2LFjc31SLwi5hUgoBUHQKG/fvuXSpUuKBPL69eukpqZiaGiomELTtGlTlU2hyUmaN29O0aJF2bdvX7bdMyEhgTlz5rB8+XLKlCnD0qVLad++vWgzJAg5nEgoBUFQq7i4OC5evKjYwv50Cs2nPSBr1KiRbVNocoquXbvy8uVLfH19s/3e4eHh/Pbbbxw7dgxHR0dWrlyJubl5tschCEL2EAmlIAjZ6sWLF4r2Pf7+/oopNOXKlfssgaxatapY1cqiIUOGcOXKFYKCgtQWw7Fjxxg9ejQREREMGzaMGTNm5OjT9YKQW4mEUhAElYqKivqsiXh4+Mf501WqVPlsDnaFChXUG2gONGXKFDw9PXny5Ila40hJSWHlypXMnj2bfPnyMX/+fPr27Yuurq5a4xIEQXlEQikIgtLI5XIePnz42RjDT6fQpCeP2jaFRlstX76cqVOnkpiYqO5QAHj27BkeHh54enpSr149Vq1aRePGjdUdliAISiASSkFQs6QUKY/jkvgglaGvp0MFowJKm2qianK5nDt37nyWQD579gyJRELt2rUVB2hy0hQabbJ9+3b69OnD+/fvyZs3r7rDUbhy5QrDhw/n77//pkePHixcuJDSpUurOyxBELJAJJSCoAaKucv3YoiM/8rcZUMD7KuZ8LO1KVVLZH7usqqkT6H5dIxhbGwsurq61K9fX7GFbWNjI+rkNMCRI0do164dz58/p2TJkuoO5zMymYytW7cyceJEkpOTmTp1KqNGjdKoxFcQhIwTCaUgZKOo+GQmeQdz4UEsujoS0mTf/vNL/7ptFWPmtbeknKFBNkb6UWpqKjdu3FAkjxcuXODNmzfo6+tjbW2t2MJu1KhRrptCow0uX76MjY0NISEhGnvC+vXr18ycOZPff/+dihUrsmLFClq3bq3usARByCSRUApCNtkTGMn0w6FIZfL/TCT/TVdHgp6OhJntzOlqpdrpIykpKVy7dk2xhX358uXPptCkJ5DW1tbky5dPpbEIWXf37l2qV6+Ov78/tra26g7nP4WFhTFy5Eh8fHxo1aoVK1aswMzMTN1hCYKQQSKhFIRssNrvPktOh2f5OmOdzRhmX1UJEX2UlJTE1atXFVvY6VNoChcuTJMmTRQ1kGIKjXaKiYmhRIkSHDx4EFdXV3WH811yuZxDhw4xevRo/vnnH0aNGsWUKVMoXLiwukMTBOE7REIpCCq2JzASD69gpV1vobslXX5wpTJ9Ck16AhkYGIhUKv1sCo2dnR21atUSLV1ygNTUVPT19dm8eTP9+vVTdzgZ9u7dO5YuXcq8efMoUqQICxcupEePHqKxvSBoMJFQCoIKRcUn47T8PClSmdKumVdPB5/RdhmqqYyLi+PChQuKLeybN28ik8koWbLkZz0gxRSanKtIkSJMnTqVsWPHqjuUTIuMjGT8+PHs3buXhg0bsmrVKqysrNQdliAIXyESSkFQoZ6bA7gcEZepmsnv0dWR0LiSEZ79rb/42qdTaM6fP09ISAgApqamn02hqVKliphCk0tUrFiRbt26MW/ePHWH8sPOnz/PiBEjCA4Opl+/fsybNw8TExN1hyUIwidEQikIKnI/OoHmK/xVdn2f0U3Rf//qsx6Q6VNoqlat+tkWdvny5VUWh6DZ6tWrh5WVFevWrVN3KFkilUrZsGEDU6ZMIS0tjZkzZzJ06FDy5Mmj7tAEQUAklIKgMjMOh+IZ8ESpq5MKchmE+/PEewkA5ubmiuTR1tZWNIkWFJydnSlSpAj79u1TdyhKERcXx7Rp01i3bh3VqlVj5cqVNG/eXN1hCUKuJ4qmBEFF/O7FqCaZBJDoUKBqA7y8vIiJiSEkJIS1a9fSpUsXkUwKnzE0NCQ+Pl7dYSiNkZERa9as4caNGxQvXhxnZ2fat29PRESEukMThFxNJJSCoAKJKVIi45NVeo9kHQOcXdqKkYbCf8ppCWW6WrVqce7cOfbs2cP169epUaMGU6dOJSkpSd2hCUKuJBJKQVCBJ3FJqLqWRA48jhNvnsJ/MzIyIi4uTt1hqIREIqFLly7cvXuXcePGsXjxYn766Sf27NmDqOYShOwlEkpBUIEPSmwTpAn3EbRXTl2h/FSBAgWYPXs2d+7cwcrKim7dumFnZ8etW7fUHZog5BoioRQEFdDXy54/rey6j6C9DA0NSUpKIiUlRd2hqFzFihXx8vLi9OnTxMbGUrduXYYMGZJjV2gFQZOIdyNBUIHyGWg6nlUSoIJRAZXfR9BuhoaGADl+lfJTzZs359atWyxdupSdO3dStWpV1q5di1QqVXdogpBjiYRSEJREJpMREBDAhAkTqGNZg9RXz1R6P1MjAwrk1VPpPQTtZ2RkBOSuhBIgT548jBo1ivv37+Pu7s6wYcOoV68e58+fV3dogpAjiYRSELJAKpVy7tw5RowYgampKQ0bNmTr1q3Y29vjbFEGXR3VTKPR1ZFgbyYmhQjflxtXKD9lYmLCpk2buHbtGgYGBjRr1owuXboQGRmp7tAEIUcRCaUgZFJKSgonTpxgwIABlCpVCnt7e7y9venQoQPnzp3j+fPnbNiwgUmdbFXWhzJNJqdHQ1OVXFvIWXJ7Qpmufv36XLp0iR07duDv789PP/3E7NmzeffunbpDE4QcQSSUgpABSUlJHDhwgJ9//hkTExNcXFzw9/dnwIABXLt2jcjISFauXImdnR26uroAVC1RCNsqxkpfpdRBjm0VY6qYFFLqdYWcKT2hFAdTQEdHh549exIeHs7w4cOZPXs2NWrUwNvbW7QZEoQsEgmlIHzD69ev+fPPP3F3d6d48eJ07NiRkJAQxowZQ3BwMPfu3WP+/PlYWVkhkXw9aZzX3hI9ZSaUcjnS1A+889/Cq1evlHddIcfS09OjcOHCuX6F8lOFChVi4cKFhISEUKNGDdzd3XF2diYsLEzdoQmC1hIJpSB8IiYmho0bN9KqVStMTEzo2bMnz58/Z+bMmdy/f59bt24xbdo0LCwsvplEfqqcoQEz25krL0CJBPfyUnwO7cXS0pLTp08r79pCjpUbelH+CDMzM44dO8bRo0d5/PgxNWvWZPTo0bx+/VrdoQmC1hEJpZDrRUVFsWrVKpo1a0apUqUYPHgwKSkpLFu2jKioKK5cucK4ceOoUqXKD12/q5UpY53NlBLrOOdqrBjemeDgYGrUqEGLFi0YMmSIGDcn/KecPC1HGVq3bk1ISAjz5s1j06ZNmJmZsWnTJtLS0tQdmiBoDYlcFI4IudD9+/fx8vLiwIEDBAYGkidPHpo3b467uzvt2rVTyXzsPYGRTD8cilQmz9RhHV0dCXo6Ema1M6eL1f8O4sjlcv744w/Gjh1L6dKl2bFjB40bN1Z63IL2c3Z2pkiRIuzbt0/doWi8Z8+e4eHhgaenJ/Xq1WPVqlXi70oQMkCsUAq5glwu5/bt20yfPh1LS0vMzMyYNWsWpqam7Ny5k5cvX3Ls2DH69++vkmQSPq5U+oy2o3Glj30Bv3dYJ/3rjSsZ4TPa7rNkEj7OMR4yZAi3bt3CxMQEW1tbPDw8csVEFCFzxJZ3xqV/OLt06RIANjY29OrVi2fPVNtXVhC0nVihFHIsmUzGtWvX8PLywsvLi4cPH1KkSBHatm1Lhw4dcHZ2xsBA9RNtvuZ+dAI7AyLxC4/hSWwSfFKPKeFj03J7MxN6NDTN0GnutLQ0Fi9ezLRp0/jpp5/w9PSkVq1aKnwFgjYZMmQIly9f5ubNm+oORaukpaWxdetWJk2axLt375g6dSojR44kb9686g5NEDSOSCiFHEUqlXLhwgW8vLzw9vbmn3/+wcTEBDc3N9zd3bG3t0dfX1/dYX7GtFJV2nbvx4CBg9HX06GCUYEfnoBz69YtevXqxZ07d5g5cybjxo1DT09M08ntpk6dyvbt20Uz7x/0+vVrZs6cye+//07FihVZsWIFrVu3VndYgqBRxJa3oPVSUlI4fvy4otG4g4MDhw4domPHjpw/f55nz56xfv16WrRooXHJJEDCq1gqFNGjjmkxzEsXydI4xVq1anHt2jXGjBnDlClTsLW15f79+0qMVtBGYss7a4oWLcry5cu5ffs25cuXp02bNrRu3Zrw8HB1hyYIGkMklIJW+nej8datW3/WaPzJkyesWLGCpk2bKhqNayK5XM7bt28pVEh5Tcrz5s3L/PnzuXDhArGxsdSqVYvVq1cjk8mUdg9BuxgaGpKUlCTqa7OoRo0anDlzBi8vL8LCwrCwsGDChAkkJCSoOzRBUDuRUApaI73RePv27TE2NqZjx46EhoZmqtG4pnn37h0ymYzChQsr/dqNGzfm5s2b9OvXj+HDh9OiRQuioqKUfh9B8xkZfTwIJlYps04ikdC+fXvCwsKYNm0av//+O2ZmZuzYsUNpH9qSUqSEPntDUOQrQp+9ISlFqpTrCoIqiRpKQaPFxMRw8OBBvLy88PX1RSqV0rBhQ9zd3XF3d6dy5crqDjFLXrx4QalSpThy5Aht2rRR2X3OnDlD3759SUxM5Pfff6dHjx5ak3QLWXf58mVsbGwICQnB3FyJjfYFIiMjGT9+PHv37qVhw4b8/vvv1K9fP9PXURzUuxdDZHwyn74xSwBTQwPsq5nws7UpVUuIsauC5hErlILG+XQudqlSpfj111/58OEDK1as4OnTp4pG49qeTAK8ffsWQKlb3l/TvHlzgoODadu2Lb169aJDhw68fPlSpfcUNEf6PG+xQql8pqam7Nmzh3PnzpGUlESDBg0YMGAAMTExGfr5qPhkem4OoPkKfzwDnvDkX8kkgBx4Ep+MZ8ATmq/wp+fmAKLik5X+WgQhK0RCKWiE8PBwFixYQIMGDShfvjzjx4+nUKFCbNy4kejoaM6ePcvQoUMpU6aMukNVqvTaK1Vsef9bsWLF8PT05MCBA1y4cAFzc3MOHjyo8vsK6pe+5S2m5aiOnZ0dN27cYPXq1Xh5eWFmZsaKFStITU395s/sCYzEafl5Lkd8/Hf53sCD9K9fjojDafl59gSKU/uC5hAJpaAWcrmcW7duMX36dCwsLKhWrRqzZ8+mfPny7Nq1i5iYGI4ePUq/fv0wNjZWd7gqk10rlJ9yd3cnJCSERo0a0b59e/r06cObN2+y7f5C9itWrBggVihVTU9PjyFDhnD//n1+/vlnxowZQ61atThz5swX37va7z4eXsGkSGWZmpwFHxPLFKkMD69gVvuJLg6CZhAJpZBtZDIZV69eZfz48VStWpXatWuzcuVK6tati7e3Ny9fvmTfvn1069aNIkWKqDvcbJGdK5SfKlGiBAcPHmTr1q14eXlhaWmJr69vtsYgZB89PT0KFy4sEspsYmRkxJo1a7hx4wbFixfH2dmZ9u3bExERAXxcmVxyWjkth5acDmevWKkUNIBIKAWVkkql+Pn5MWzYMMqVK0ejRo3Yvn07jo6OnDx5kpiYGHbs2IGbm5vaptaokzpWKNNJJBL69OlDcHAwVapUwcnJiREjRpCcLGqzciJDQ0Ox5Z3NatWqxblz59izZw/Xr1+nRo0ajJoyh+mHQ5V6n2mHQ0VNpaB2IqEUlC690Xj//v0pWbIkDg4OHD58mE6dOuHv76/xjcazU0JCAnp6euTLl09tMZQvXx4fHx9WrlzJxo0bqVOnDgEBAWqLR1ANIyMjsUKpBhKJhC5dunD37l3GjRvH3ggJ7z98u67yR0hlciZ5Byv1moKQWSKhFJQiMTGR/fv30717d4oXL07r1q25cOECv/zyC4GBgYpG47a2thrdaDy7vX37lsKFC6u9hY+Ojg4jRowgKCiIIkWK0LhxY6ZMmcKHDx/UGpegPGJajnoVKFCAXsPGk7d8bSQ6yn0GpsnkXHgQy4MY0WBdUB+RUAo/7NWrV3h6etK+fXuKFy9Op06dCAsLY9y4cYSEhCgajdevX1/tCZOmUvaUnKz66aefuHz5MjNnzmThwoVYW1sTHCxWPnICseWtfjsDItHVUc2zUFdHwp9XRS2loD4ioRQyJTo6mg0bNtCyZUtMTEzo1asX0dHRzJ49mwcPHnDz5k2mTp2Kubm5SCIzICEhIdsP5HyPnp4eU6ZMISAggNTUVOrXr8+iRYtIS0tTd2hCFogtb/XzuxeT6RPdGZUmk+MXnrHel4KgCnrqDkDQfJGRkXh7e3PgwAEuXryIjo4OdnZ2rFixAjc3txzXGzI7adoK5afq1q3L9evXmTZtGh4eHhw+fJjt27fniIbyuZHY8lavxBQpkSo+OBMZl0xSipQCecVbu5D9xAql8FXh4eGKudjpjcYLFy7Mpk2bePHiBb6+vjmy0Xh208QVyk/ly5ePRYsWcf78eZ49e0atWrVYt24dYmKr9hEJpXo9iUv6YgKOssmBx3FJKr6LIHyd+BgjAP9rNO7l5YWXlxehoaEYGBjg4uLCb7/9RuvWrTU68dFWb9++VYzF02S2trbcunWLsWPH8uuvv3Lw4EE2b94sPlBoESMjI5KSkkhJSSFv3rzqDifX+SCV5aj7CMK/iRXKXEwmkynmYlepUoU6derw+++/U7duXQ4ePEhsbKyi0bhIJlVDk7e8/61QoUKsX7+e48ePc/v2bSwsLNi1a5dYrdQSBYoYksekIhfCogh99oakFKm6Q8pV9PWy5+02u+4jCP8mVihzGalUir+/P15eXnh7e/Ps2TNMTExo37497u7uNGvWLNf3hsxOmr7l/TWtWrUiJCSEYcOG8fPPP+Pt7c0ff/yRo0dkaqv70QnsDIjE714MT+IllO73OwP+ugfcQwKYGhpgX82En61NqVpCOz7YaKOEhATuXr8Icjmo8LCiBKhgVEBl1xeE/yISylwgJSUFHx8fvLy8OHToEHFxcZiamtK5c2fc3d1p3Lix6A2pJtq0QvkpQ0NDdu3ahZubG7/++isWFhZs2rSJNm3aqDs0AYiKT2aSdzAXHsSiqyP56sliOfAkPhnPgCdsu/IY2yrGzGtvSTnD3DexStlSUlK4evUqvr6++Pr6cu3aNaRSKaZDtyApZKKy+5oaGYgDOYLaiN88JUlKkfI4LokPUhn6ejpUMCqg1j/sxMRETp48yYEDBzh27BgJCQmYmZkxcOBA3N3dqVevnmjrowG0cYXyU507d8bW1pYBAwbQtm1b+vfvz7Jly7T6NWm7PYGRTD8civT/k8jvtalJ//rliDiclp9nZjtzulqZqjzOnCQtLY2goCBFAnnx4kXevXuHoaEhDg4O/P777zg6OvLnnRT+DIhUSesgXR0J9maqS1YF4XskclEA9cM+3U6KjE/+7ASfOraTXr16xZEjR/Dy8uLUqVO8f/+e2rVr4+7ujru7OzVq1BBJpAaRyWTo6emxfv16fvnlF3WHkyVyuZzNmzczevRojIyM2LZtG82aNVN3WLnOar/7LDkdnuXrjHU2Y5h9VSVElDPJ5XLu3bunSCDPnTvHq1evMDAwoGnTpjg6OuLo6EitWrXQ0flfTeP96ASar/BXWVw+o5tSxUT7djyEnEEklD8gI9tJ6dK/rqrtpBcvXnDo0CG8vLw4e/YsUqmURo0aKZLISpUqKfV+gvKkr07u3r2brl27qjscpXj06BF9+vTB39+fUaNGMW/ePPLnz6/usHKFPYGReHgpb6rRQndLuoiVSoWnT58qEkhfX1+ePXuGnp4eDRs2VCSQ1tbW361B77k5gMsRcUpdpZQgx6ZKcf7sb620awpCZomEMpM+3U7KzANBV0eCno5EKdtJT548wdvbGy8vr88ajXfo0AE3NzdKly6dpesL2ePZs2eUKVOGY8eO4eLiou5wlEYmk7FixQomTZpExYoV8fT0pH79+uoOK0eLik/Gafl5UpTYMiavng4+o+1ybU1lfHw8fn5+igQyPPzjym/t2rUVCaStrS0FCxbM1HWV/m8llyOTfqDSnZ1sX7uM8uXLK+e6gpBJIqHMBHVuJ927dw8vLy8OHDjA33//jb6+Ps7Ozri7u9O2bVtxwlYL3b17l+rVq+Pv74+tra26w1G6sLAwevbsya1bt5gyZQqTJ08mT5486g4rR1LFqpeujoTGlYzwzCWrXklJSVy4cAFfX1/Onj1LUFAQcrmcqlWrKhLIZs2aKeVZq+zV5F7VdNk2bSCvXr1i8eLFDBw48LOtdkHIDiKhzKDs3k76tNH4gQMHCAsLo0CBAri4uODu7o6Li4s4+KDlAgMDadCgATdv3qRWrVrqDkclUlNTmTt3LnPmzKF27drs2LGDGjVqqDusHEXU5f2Y1NRUAgICFCuQV69eJTU1lVKlSikSSAcHB0xNVbPtr6wFinHO1RhqX4W3b98yfvx41q9fj4ODA5s2baJixYpKiFQQMkYklBmQXdtJMpmMgIAADhw4gJeXF48ePaJo0aK0a9cOd3d3nJ2dRT1aDuLr64uTkxMPHz7M8bWugYGB9OrVi0ePHjF37lxGjRolWlUpyYzDoXgGPFHZyeGe1uWZ0c5c6dfObjKZjNu3bysSSH9/f5KSkihatCjNmjVTJJE//fRTth1ezGoJ1ax25l8sTPj4+DBgwABiY2NZuHAhv/76q1itFLKFSCgzQJXbSVt71+P8+fOKRuPPnz//rNG4vb292CbMoQ4ePEj79u15+fJlrihZePfuHZMnT2bFihXY2tqybds2sYKiBHaL/XgSn6yy65c3MuD8WHuVXV9V5HI5Dx8+VCSQfn5+xMbGki9fPpo0aaJIIOvWravWDzeqOOSZkJDAhAkT+OOPP7Czs2PLli05/kOroH4iofwOVW8nJf3lQWxECKampri7u9OhQwcaNWokVm9ygR07dtC7d2/ev3+fq2Yrnzt3jj59+hAXF8fy5cvp37+/aGf1gxJTpFjOOIUqH+ISIGRGC61omP38+XPOnj2rSCIjIyPR1dWlQYMGODg44OjoSKNGjciXL5+6Q/2Cog1deAyRcV9pQ2dkgL2ZCT0amma4BOHs2bP079+fmJgYFixYwNChQ8VqpaAyIqH8DlVuJyFLw0wnmvkd61K3bl3xpprLrF69mjFjxpCSkqLuULLd27dvGT16NFu2bKF169Zs3LiRUqVKqTssrRP67A2tf7+o8vscG94E89JFVH6fzHr9+jXnz59XJJBhYWEAWFpaKlYgmzZtqnX15kkpUtbtPMCkKdO45H+e6uWMfzihT0xMxMPDgzVr1tC0aVM2b95MlSpVlByxIID4qPIdfvdiVJNMAujokmJURUytyaW0fUpOVhQuXJjNmzdz+PBhrl+/joWFBX/99Ze6w9I6H5RY160J9/med+/e4ePjw8SJE2nQoAFGRka4ublx9OhRGjduzO7du3nx4gW3b99m+fLltGnTRiv/xgrk1aOaSQE+PA+nTAF5llaHCxYsyOrVq/Hz8+Pp06fUrFmTlStXIpNpxr+pkHOIhPI/JKZIiVRhbRJAZFwySSlSld5D0EzaOsdbmdq2bUtISAgODg506dKFbt26ER8fr+6wtIa+XvY8wrPrPv8mlUq5evUqc+fOxcHBgWLFitG8eXO2bNlC5cqVWb9+PREREURERLBx40a6du1KiRIl1BKrsqUnwgkJCUq5XrNmzbh9+zYDBgxg1KhR2NnZcf/+faVcWxBAJJT/6UlckkprkwDkwOO4JBXfRdBEuXmF8lPGxsb89ddf7Ny5k5MnT2JhYcGJEyfUHZbGk8vlSF89BxU/pSRABaMCKr1HOrlcTkhICCtXrqRdu3YYGRnRqFEjFi5cSIECBViwYAG3b9/mxYsX7N69mwEDBuTYg13pHzbfvn2rtGsWKFCAVatWcf78eZ4/f07NmjVZvnw5aWlpSruHkHuJhPI/5LbtJCF7vX37ViSU/08ikdC9e3dCQkKoWbMmLi4uDBo0iMTERHWHplGeP3/On3/+Sd++fSlfvjy1LaojffVCpfc0NTJQ6YGcx48fs3nzZrp3706pUqWwtLRk/PjxJCQkMG7cOC5fvkx8fDxHjhxh1KhRWFpa5ooSofSEUlkrlJ9q2rQpt2/fZvDgwYwZMwZbW1vu3bun9PsIuYvmH9tTo5y+nSSol9jy/lKZMmU4ceIE69evZ8yYMfj4+LB9+3aaNGmi7tDU4s2bN5w7d+6LQyc1a9akY8eOODo6cul9afbeeK6yPpT2ZiZKvWZMTAxnz55VnMaOiIhAR0eHevXq0bdvXxwdHWncuDEGBrlz5GM6VSaUAAYGBixfvpwOHTrQr18/ateuzezZsxk9erToMiL8EJFQ/ocKRgWQoNoNpezcThI0S0JCAiYmyn2zzgkkEgmDBw/GycmJ3r1707RpU8aOHcusWbM0st2LMr1//57Lly8rEsjAwEBkMhkVKlTAycmJqVOn4uDg8NnvjVl0AruuP1NJPGkyOT0aZm1STEJCwmcnsYODP04cq169Oi4uLjg6OmJnZ0exYsWUEXKOoewaym9p0qQJN2/eZOrUqYwfP54DBw6wdetWfvrpJ5XeV8h5REL5Hwrk1cPU0EClTYNVvZ0kaK63b99SuXJldYehsapUqYK/vz9Lly5l6tSpHD9+HE9PT+rUqaPu0JQmLS2NoKAgfHx88PX15eLFi7x//x5jY2McHR3p378/jo6O/9mUumqJQthWMVb68AW5LI0K+VOoZJy5D7wpKSlcuXJFkUBeu3aNtLQ0ypUrh6OjI+PHj8fBwYHSpUsrLdacKF++fOjq6iq1hvJbDAwMWLp0KR06dKBv377Url2bWbNm8dtvv6GnJ96fhIwRe63fYV/NBF0d1dTrqGI7SdAe4lDO9+nq6jJ+/HiuX7+Onp4eDRo0YPbs2Uil2tkZQS6Xc+/ePdasWYO7uzvGxsZYWVkxZ84c9PX1mTt3Ljdv3iQ6Opo9e/bwyy+/ZGjCybz2lugp+TmlK4HLK4Zja2vLnTt3vvl9aWlpXL9+nYULF+Ls7EyxYsWwt7fnjz/+oEyZMqxevZrw8HCePHnC1q1b6dGjh0gmM0AikVCoUCGVr1B+qnHjxty8eZPhw4czceJEbGxsFGUWgvA9IqH8jp+tTVXWh1IZ20mC9hKHcjLO0tKSa9euMWHCBGbMmIGNjY3WHCJ49uwZnp6e9O7dm3LlyvHTTz8xatQoXr58yahRo7hw4QLx8fEcO3aM3377jVq1amV6mkk5QwNmKnne9vwOtfE9/BexsbGKFasPHz4gl8u5e/euIikuXrw4VlZWzJ49Gz09PWbNmsWNGzeIiYlh3759DB48mKpVq+aKgzTKlt0JJUD+/PlZvHgxly5d4u3bt9SpU4cFCxZo7Yc4IfuISTkZoMpZ3p79rZV2TUG7FCxYUFEEL2Tc1atX6dWrF1FRUSxcuJBhw4Zp1Di5169fKw7S+Pj4cPfuXQBq1aqFk5MTjo6O2NraUrBgQaXfe7XffZacDs/ydcY5V2Oo/cdpKu/fv2fcuHH88ccfFCpUCD09PWJjY8mTJw8NGzZUTKRp0KAB+vr6Wb638D8WFhY4OTmxYsUKtdz//fv3zJgxg8WLF1O3bl22bt2KhYWFWmIRNJ9IKDMgKj4Zp+XnSVFSex+5XI4uMnzHNKNicbFClRulpaWhp6fHpk2b6N+/v7rD0TrJycl4eHjw+++/Y29vz9atWylfvrxaYnn//j2XLl1S1Axev34dmUxGpUqVcHR0xMnJCXt7e4oXL54t8ewJjGT64VCkMnmmPgTr6kjQ05Ewq505TpUK4Ofnh6+vL2fPniU8/GOSmj9/ft69e4ebmxvr168Xh8pUrFGjRlSvXp0tW7aoNY5r167Rp08fHj58yLRp0xg/fjx58uRRa0yC5tGcj/UaTNnbSRKJhLhTfzCga3vi4uKUdl1Be6T3VxRtg36MgYEBq1atwsfHhwcPHmBpacnWrVvJjs/HaWlpXLt2jfnz5+Pk5ETRokVxcnJi8+bNVKpUiQ0bNvDo0SMePnzIhg0b6Ny5c7YlkwBdrUzxGW1H40pGAN+tAU//ulkROY7vL7NwkBvFixenU6dO+Pr64uDgwL59+4iNjeXt27csXryYU6dOYW1tzenTp1X+enIzdWx5f02DBg24ceMGY8aMYdq0aTRs2JDbt2+rOyxBw4gVykxQ5naSueQpnTp1olChQhw8eJCaNWsqIUJBWzx9+pRy5cpx4sQJWrZsqe5wtNqbN28YOXIk27dvp127dmzYsEGp4/fSawbTVyDPnTvH69evKViwIHZ2dopVSAsLC42rE7wfncDOgEj8wmN4EpfEx0Zl/1OI98ifhRBxajvvoh9RqlQpxRa2o6Mj5cqV++p1Hz58yMCBAzl79iy9evVi2bJlGBkZZcMryl06dOhAUlISJ0+eVHcoCoGBgfTt25fw8HCmTp2Kh4eHWK0UAJFQZpoytpO6WH08iPPkyRPc3NwIDw9n+/btdOzYUVVhCxomLCwMc3NzLl68iI2NjbrDyREOHjzIwIEDkcvlrFu3jg4dOvzwtZ4+fapIIH19fXn27Bl58uShUaNGn9UMassbqUwmY/L0WSzb6EkjG1uC/g4k4VkERQrko1mzZorX9NNPP2U4KZbL5WzdupUxY8aQJ08efv/9dzp37qxxSbU2S0/cLl26pO5QPpOSksLs2bNZsGABNWvWZOvWrdSqVUvdYQlqJhLKHxAVn8wk72AuPIhFV0fyn4ll+tdtqxgzr70l5Qw/n/6QnJxMv3792Lt3L1OmTGHmzJkadcBAUI2AgADFtpGlpaW6w8kxYmJiGDx4MN7e3vTo0YPff/+dokWLfvfnXr16pagZ9PX1VZwgr1OnjiLZsrW1pUAB7RhCIJfLefDggWIajZ+fH7GxsQA0b94cR0dHHBwcqFu3bpanorx48YLhw4ezf/9+2rZty9q1aylbtqwyXkauN2LECPz8/BTN4DXN33//Td++fblz5w5Tpkxh4sSJ4mBWLiYSyixI307y9P2btPyG8Mkncwkfm5bbm5nQo6EpVUy+XSsnl8tZuHAhkyZNok2bNvz555+inUwOd+bMGZydnXn8+LHaDpPkVHK5HE9PT4YPH06hQoXYsmULzs7On33Pu3fvuHTpkqKh+I0bN5DJZFSuXFlxEtve3p78hYryOC6JD1IZ+no6VDAqoLGDCJ4/f65IiM+ePUtkZCS6uro0aNAAR0dH7t+/z99//839+/dVcn9vb2+GDh1KYmIiCxcuZNCgQeLDcRZNnjyZnTt38vjxY3WH8k0fPnxgzpw5zJ8/H3Nzc7Zt20bt2rXVHZagBiKhzCK5XE7hwoXxmDodtx6/ZOmN59ixY3Tv3p0yZcpw8OBBzMzMVBS1oG4HDhygY8eOxMXFYWhoqO5wcqSoqCj69u2Lr68vgwcPpkuXLorT2JcvXyYlJYUSJUp8VjNYvnz5/9Ud3oshMj75s9GrEsDU0AD7aib8bG1K1RLqO1T1aXsiX19fRfNxS0tLxetp2rSp4sNp3759uXv3LleuXFFpTOPHj2fjxo3Y2tqyceNGqlWrprL75XQLFixg8eLFWnF4MygoiL59+xIaGsqkSZOYPHmyWK3MZURCmUVRUVGYmppy9OhRWrduneXr3bt3D1dXV168eMGePXvEgY0catu2bfTt25cPHz5oTR2eNpHL5dy5c4czZ86wefNmxZahgYEBDg4OilVIc3NzRc2fMktZVCF9VTU9gfz777+RyWRUrFhRkUD+e873p9q1a4dcLufIkSMqj/XcuXP88ssvREVFMW3aNMaNGyd+z3/A2rVrGTVqFB8+fFB3KBny4cMH5s+fz5w5c6hevTrbtm2jbt266g5LyCZiPyKL0lcFatSooZTrVatWjYCAAJo0aYKLiwuLFi3KllYoQvZ6+/Yt+fLlE2+yShQVFcW2bdvo0aMHZcqUwdzcnPHjx2NoaMjIkSMxNzfn/fv3WFhYMHjw4M9OZe8JjMRp+XkuR3xcCfregbv0r1+OiMNp+Xn2BEYq/fVIpVKuXr3K3LlzcXBwoFixYjRv3pwtW7ZQuXJl1q9fT0REBBEREWzcuJGuXbv+Z1/IuLi4bDuJ3axZM27fvs2oUaOYNm0a9evX5/r169ly75ykUKFCpKamkpKSou5QMkRfX5/p06cTGBioKLeYMmWK1sQvZI1IKLMoLCyM/PnzK7UOrkiRIhw6dIiJEycyYcIEfv75Z5KTk5V2fUH9xBzvrIuPj+fAgQMMGTIEMzMzTE1N6devH3fu3KFHjx6cOnWKV69ece7cOVasWMHNmzeZPXs2S5cupUGDBty6dQv42A7MwyuYFKks09Ow0mRyUqQyPLyCWe2XtdpEuVxOSEgIK1eupF27dhgZGdGoUSMWLlxIwYIFWbhwIcHBwbx48YLdu3czYMAAKlasmOHrx8bGZmtrn/z587NgwQKuXbuGrq4u1tbWjB07lqSkpGyLQdul96l9+/atmiPJnNq1a3Pt2jWmT5/OokWLqFevnvhAkQtoZnW5FgkLC+Onn35SevG5rq4uc+fOpVatWorap4MHD2JqKmZ/5wRijnfmJScnc/HiRcWW740bN5DL5VStWhVHR0fmz59Ps2bNvpk06enpMWnSJFxcXOjZsydWVlZ0nfw7/u+VcyJ5yelwihfMq2gLlhGPHj1SHKI5e/Ys0dHR6OvrY2Njw/jx43F0dKR+/fro6WX9UR0XF4exsXGWr5NZdevW5dq1ayxdupQZM2bg5eXFxo0bcXR0zPZYtE16QpmQkJCtzfGVIU+ePEydOhVXV1f69u1Lw4YNGT9+PNOnTydv3rzqDk9QAZFQZlFYWJjStru/pnPnzpiZmeHm5kb9+vXZv38/TZs2Vdn9hOzx9u1bMSXnO6RSKYGBgYoE8vLly3z48IGSJUvi6OjI0KFDcXR0zPSHrNq1a3P9+nXGTJ/H4YTi6OjJP+vQkBXTDofSuLLxN2sqY2JiFK18fH19efToETo6OtSrV4++ffvi6OiIjY0N+fPnV0o86dLS0nj16pXamo/r6ekxYcIE3N3dGThwIE5OTvTt25elS5dSrFgxtcSkDdI/dGrCtJwfVbNmTa5evcqiRYuYOXMmhw4dYuvWrTRo0EDdoQlKJra8s0Aul6s8oYSPb4CBgYGYm5vj6OjIH3/8IeoqtZzY8v6SXC4nNDT0sy3fxo0bs3jxYgoXLszixYsJDQ3l2bNn/Pnnn/Tt2/eHV+zz5s3Lm6ou6OnnVVoyCSCVyZnk/b+egW/fvuXo0aOMHj2amjVrUqJECbp168alS5do3bo13t7exMXFfTbKUdnJJHw8fS2TydQ+zaZq1ar4+vqyYcMGvLy8qF69Ovv37xfPs2/4dIVSm+XJk4fJkydz48YN8ufPT6NGjZgwYQLv379Xd2iCEokVyiyIiYnh1atXKk8oAYoXL87p06cZM2YMQ4YMISgoiNWrV4u2DFpKrFB+FBkZqegFefbsWV68eKGyLd9P3Y9O4MKDWKVeEz7WVF54EMuIKXO5fvYY165dIy0tDVNTUxwdHZkwYQL29vaULl1a6ff+L+ltZ9Sx5f1vOjo6/PLLL7Ru3Zphw4bRqVMnXF1dWbt2bbb/f9F02lpD+S0WFhZcvXqVJUuWMH36dA4fPszWrVtp2LChukMTlEAklFkQFhYGQPXq1bPlfnny5GHVqlXUrl2bX3/9lbCwMA4cOKDUucVC9khISMiVb55xcXH4+fkpksgHDx4gkUioV68evXv3Vmz5Ghiotg3PzoDI77YG+lFyWRr7Q2JoUras4jVVrlxZrSMJ0xNKda9Qfqp06dJ4eXlx4MABhg4dSvXq1Vm8eDEDBgwQDdH/X05ZofyUnp4eHh4etGvXjj59+mBjY8Nvv/3GrFmzVLI6L2Qf8VebBWFhYeTJk4fKlStn63379evHuXPnePjwoWjHoaVyy6GcpKQkTp06xbhx46hbty7FixenU6dO+Pn54ezszIEDB4iNjSUwMJAFCxbQvHlzlSeTAH73YlSSTAJIdHSp2tSNv/76i0GDBlGlShW1z7dOH7uoSQllug4dOnDnzh06duzIoEGDcHBwUNk0H21TsGBBIGcllOlq1KjB5cuXmT9/Pr///ju1a9fm8uXL6g5LyAKRUGZBWFgY1apVU/p2XEY0atSI69evU7p0aWxtbfnzzz+zPQbhx+XULe/U1FQuX77M7NmzsbOzo1ixYrRs2ZKdO3dibm7O1q1biYqK4t69e6xZswZ3d/dsnxSUmCIlMl61bbgi45NJSpGq9B6ZoYkrlJ8qVqwYmzdvxsfHh6ioKCwtLVmwYAGpqanqDk2tdHR0KFiwYI5MKOHjauX48eMJCgqiWLFiNGnShDFjxog2eVpKJJRZcOfOnWypn/yWMmXKcP78ebp06ULPnj0ZO3YsUqnmvIkJ35ZTDuXI5XKCg4NZsWIFbdq0wdDQEBsbG8Xp3WXLlhEWFsY///yDp6cnvXv3pmxZ5bTp+VFP4pJQ9REQOfA4TnP6LcbFxVGoUCGNr7l2dHQkODiY4cOHM3nyZBo0aMCNGzfUHZZaFSpUKMfUUH5L9erVuXTpEosWLWLt2rXUrl2bixcvqjssIZNEQpkFYWFh2VY/+S358uVj69atrFixghUrVuDi4kJ8fLxaYxK+T5tXKB8/fszmzZvp3r07JUuWpGbNmnh4ePDu3TsmTpxIQEAAsbGxHDx4kGHDhlG9enW1b/l+6oNUlqPukxHZ3dQ8KwwMDFi8eDEBAQHIZDIaNGjAhAkTcu2qVaFChXLsCuWndHV1GTt2LDdv3sTY2JimTZsyevToXPvvro1EQvmD4uLiiI6OVusKZTqJRMLIkSM5deoUf//9Nw0aNCA0NFTdYQlfkZQi5XZUPGlFy5Gsb6hR26LfEhsbq6gHrFy5MhUrVmTgwIE8ePCAfv364ePjw6tXr/D19WXSpEk0aNBALWUgGaWvlz2Pvey6T0aoq6l5VqTXh8+ePZuVK1dSs2ZN/Pz81B1WtsstCWW6atWqceHCBZYsWcK6deuoWbMm/v7+6g5LyACJXDQA+yEXL17E1taW4OBgLCws1B2OQkREBG5ubjx69AhPT0/c3NzUHVKudz86gZ0BkfjdiyEyPvmz7VYJYGpogH01E362NqVqCfWvWiYmJnLhwgVF8+2bN28C8NNPP+Ho6IijoyPNmjXTyobUUVFR7PM+zKpn5ZXaf/LfJEDIjBYUyKsZiXWHDh1ISkri5MmT6g7lh9y7d49ffvmFCxcuMGDAABYvXkzRokXVHVa2cHBwoGTJkuzatUvdoWS78PBw+vXrx6VLlxg+fDjz58+nQIEC6g5L+AaRUP6gjRs38uuvv5KUlKRxY6QSExPp06cPBw4cYMaMGUydOlW04VCDqPhkJnkHc+FB7Hdb1KR/3baKMfPaW35z0ooqpKamEhAQoEggr169SmpqKmXKlFEkkI6OjpQpUybbYlIWuVzOrVu3OHToEIcOHSIoKAg9PT0qDNtGar6iKrtveSMDzo+1V9n1M8vOzo6yZcuyc+dOdYfyw2QyGRs2bGD8+PEULFiQNWvW0L59e3WHpXKurq6kpaVx9OhRdYeiFmlpaaxevZqJEydSqlQptmzZgp2dnbrDEr5CZBk/KCwsjMqVK2tcMgkfW03s27eP2bNnM2PGDDp06JCrtkw0wZ7ASJyWn+dyxMfTtd9rUZP+9csRcTgtP8+ewEiVxSaTybh16xbLli2jdevWGBoaYmtry4oVKzA2Nmb58uXcuXOHqKgotm/fTq9evbQqmUxNTcXX15cRI0ZQsWJF6tSpw7JlyzAzM2PXrl28fPmSn+1ro6ujmhVKXR0J9mYmKrn2j9LGLe9/09HRYfDgwYSFhVG/fn3c3d3p0KEDz58/V3doKpXbtrz/TVdXl5EjR3L79m3KlClDs2bNGDZsGImJieoOTfgXzdiP0ULZMXIxKyQSCVOmTKFmzZr06NGDRo0acejQoWzvmZkbrfa7z5LT4T/0s2kyOWkyOR5ewcQmpjDMvqpSYnr06NFnE2levnxJvnz5aNKkCZMnT8bR0ZG6deuiq6urlPtlt7dv33Ly5EkOHTrE8ePHef36NWXLlsXV1RVXV1fs7Ow+O+H8s7Uu2648VkksaTI5PRr+2EhIVYmLi9OaQznfU7ZsWQ4dOsS+ffsYPnw4NWrUYMmSJfTr10+jDn8pS25PKNNVqVKFc+fOsWbNGjw8PDh27BibN2/GwcFB3aEJ/0+sUP4gTU8o07Vr146AgABSUlKwsrLizJkz6g4pR9sTGPnDyeS/LTkdzt4fXKl8+fIle/fu5ZdffqFSpUpUqlSJwYMH8/jxY3755Rd8fX159eoVZ86cwcPDAysrK61LJp8+fcratWtp0aIFxsbGdOnShdDQUEaMGMHff/9NZGQkq1evpnnz5l+0y6laohC2VYyVvkopl6VRtVAaVUzUXwubTi6Xa9Up74yQSCR07tyZsLAwXF1dGTBgAI6Ojjx48EDdoSld4cKFRUL5/3R0dBg+fDi3b9+mfPnyODo6MmTIEPH/R0OIhPIHvH37lqdPn2pFQgkfe3xdu3aNBg0a0LJlS5YtW4YonVW+qPhkph9W7un6aYdDicpAE+7ExESOHz/OmDFjqFWrFiYmJnTt2pVLly7Rpk0bDh48SFxcHFevXmXu3Lk4ODiQL18+pcaqanK5nNu3bzN79mzq169PuXLlGDlyJGlpaSxZsoRHjx5x8+ZNZs6cSd26db+7WjWvvSV6Sk4odZBzbtFAOnbsSHR0tFKv/aMSEhKQSqVav+X9NUZGRmzbto1Tp07x6NEjatasyeLFi3NUP97c0IcysypXrszZs2dZvXo1O3bswNLSEl9fX3WHleuJhPIH3L17F8i+Gd7KUKxYMY4dO8aYMWMYM2YMvXr14t27d+oOK0eZ5B2MVMnj/KQyOZO8g7/47x8+fODChQvMmDGDJk2aUKxYMVq3bs1ff/1FnTp18PT05J9//iEsLIxVq1bh6uqqladipVIpfn5+jBo1ikqVKlGrVi0WL15M5cqV2blzJzExMfj4+DBixAgqVKiQqWuXMzRgZjtzpca7oGMddm38HX9/f8zNzdmzZ4/aP7xp+pQcZXB2diYkJITBgwfj4eFBw4YNFd0JtJ3Y8v46HR0dhg4dyu3bt6lUqRJOTk4MHjxYJN9qJBLKHxAWFoZEIuGnn35SdyiZoqury6JFi9i5cyf79++nadOmPH36VN1h5Qj3oxO48CBW6fOh02RyLjyIJfzFW27evMnSpUtxcXHB0NCQpk2bsmrVKkqUKMHKlSu5d+8ekZGRbNu2jR49elC6dGmlxpJdEhIS2LdvHz169MDExAQHBwf2799Pq1atOHnypGI7v3v37lluXdTVypSxzmZKiXucczW6WJnSqVMnQkNDcXJyolu3bnTo0IEXL14o5R4/QpPneCtTgQIFWLZsGVeuXCElJYX69eszadIk3r9/r+7QsqRQoUK8e/cuR626KlOlSpXw8fHhjz/+YOfOnVhaWorSLjURCeUPCAsLo0KFChgYZF9rF2Xq3r07Fy9eJDo6mvr163Pp0iV1h6T1dgZEquzUMHIZ9gOnUadOHaZMmYJUKmXq1Klcv36dly9fcuDAAYYMGYKZmZnWHkp49uwZ69ato1WrVhgbG9O5c2du377N0KFDCQwMJCoqSlEvqezOCsPsq7LA3ZK8ejqZ/jfU1ZGQV0+Hhe6WDLWvovjvxYsXZ8+ePezfv59Lly5hbm7Ozp071bJamb5CmRO3vL+mQYMG/P3330yfPp2lS5dSq1YtrW6MnT6iVZxq/rb0DgDBwcFUrVoVZ2dnBg4cyJs3b9QdWq4iEsofoC0Hcv5LvXr1uH79OmZmZtjb27Nx40Z1h6TV/O7FKH11UkGig6F5E86ePcurV684ffo0EyZMoF69elp3kCadXC4nJCSEuXPn0qBBA8qUKcOwYcNISUlh0aJFREREfFYvqepEuauVKT6j7Whc6eMq3vcSy/SvN65khM9oO7pYff1Ud4cOHQgNDaVly5b06NEDV1dXnj17ptzgvyM3bHn/m76+PlOnTuXmzZsUL14cOzs7Bg8erJUJRvqIVrGV+30VKlTgzJkzrF+/nt27d2NhYaG1zfy1kUgof8CdO3e0qn7yW0xMTPDx8WHAgAEMHDiQoUOHkpqaqu6wtE5iipTIDBycydI9yE+DxrZad5DmU1KplHPnzjF69GiqVKmCpaUlCxYsoHz58nh6ehITE8PZs2cZOXIkFStWzPb4yhka4NnfmjOjmtLTujzljQyAzz8kSPjYtLyndXl8RjfFs7/1d5vQGxsbs3PnTry9vbl27Rrm5ubs2LEj21Yr4+LiyJcvn9buqGRF9erV8ff3Z/Xq1ezcuZMaNWpw6NAhdYeVKekJpaijzBiJRMLAgQMJCQmhevXqtGrViv79+/P69Wt1h5bjiYQyk5KTk3n06JHWr1Cm09fXZ+3ataxfv56NGzfi5ORETEyMusPSKk/iklB1aiAHHsclqfguypeYmMiBAwfo1asXJUqUwN7enr1799K8eXOOHz9ObGysol7S0NBQ3eECH1sKzWhnzvmx9syt/Z5nW4bj2bMmx4Y3IWRGC86PtWdGO/NMtwZyc3MjLCyMNm3a0Lt3b9q2bcs///yjolfxP7Gxsblmu/tr0g9vhIaGUrt2bdzc3OjcubPGnML/HpFQ/pjy5ctz6tQpNm7cyL59+7CwsOD48ePqDitHEwllJt27dw+5XJ5jEsp0AwcO5OzZs9y9excrKyuCgoLUHZLW+CCV5aj7ZNXz58/ZsGEDrVu3xtjYmI4dOxIUFMSvv/5KQEAAT58+VdRLauKkqU/pyqWkxjyijmkxzEsXyfJsbkNDQzw9PTl8+DA3btzA3NycrVu3qnS1Mic1Nc8KU1NTjh49yq5du/Dz86N69eps27ZN7afwvye9hlIklJknkUgYMGAAoaGhWFhY0Lp1a/r27curV6/UHVqOJBLKTAoLCwO0q2VQRjVp0oTr169TvHhxbGxs2LNnj7pD0gr6etnzZ5Rd98ksuVxOaGgo8+bNw9ramtKlSyvm3M+fP58HDx4QHBzMnDlzaNCggVbNlU8/Waunp9yhYm3btiU0NBQ3Nzf69euHi4sLUVFRSr1HOpFQ/o9EIqFbt27cuXNHkVw4OzsTERGh7tC+SdRQZl25cuU4ceIEmzdvxsvLCwsLi1w7G12VtOfJriHCwsIoW7as4lNjTlOuXDkuXLhAhw4d6NatGx4eHqSlpak7LI1WwagAqj5bLfn/+2gKqVSKv78/Y8aMoWrVqlhYWDBv3jzKli3L9u3biYmJUdRLavO4T1UllPCxN+y2bds4evQot2/fxsLCgs2bNyt9xSy3b3l/jbGxMZ6enpw4cYLw8HAsLS1ZtmyZRj7rxJa3ckgkEvr166cofWjbti29evUiPj7+h6+ZlCIl9NkbgiJfEfrsDUkpubu1k5jlnUk55UDOf8mfPz87duygdu3ajB8/ntu3b7Nr1y6tbIytSnK5nOvXr7Nv3z7kyTWgUHGV3cvUyCDL261ZlZSUxOnTpzl06BBHjx4lLi6OkiVL0q5dO1atWqWV03e+Jz2hVOVp+tatWxMaGsqYMWMYMGAAf/31Fxs3bsTUVDnzwOPi4jAzU06vzZymZcuWhISEMGXKFMaOHcuePXvYtGkTNWvWVHdoCnny5CFv3rwioVSSsmXLcvToUXbs2MHIkSMVp8LbtWuXoZ+/H53AzoBI/O7FEBmf/Fn9vAQwNTTAvpoJP1ubUrWE5oxgzQ5ihTKTckLLoIyQSCSMGTOGEydOcOXKFRo0aMCdO3fUHZbayWQyrly5wpgxY6hQoQINGjRg27ZtmOZJQFVtKHV1JNibmajm4t/x4sULNm7cSJs2bTAyMsLd3Z3AwEAGDhzI1atX+eeff1i/fj0uLi45LpkESEtLQ0dHR+Vti4oWLcrmzZs5ceIEYWFhWFhYsGHDBqWsVoot7/9WqFAhVq5cyaVLl0hKSqJevXpMnTpVoxqii3neyiWRSOjduzehoaHUq1cPV1dXevTooWix9TVR8cn03BxA8xX+eAY84cm/kkn4eHjySXwyngFPaL7Cn56bAzI0OjenEAllJqSkpPDgwYNckVCmc3Z2JjAwkDx58mBtbc2RI0fUHVK2k8lkXLx4kVGjRlG+fHkaN27Mrl27aNOmDX5+fjx//pzNHn1QVRvKNJmcHg2Vs1r1PXK5nDt37rBgwQIaNWpE6dKlFePM5s6dy/379z+rl9SmesgfIZVKVbLd/S3pK2ZdunRh0KBBODs78/jx4yxdU2x5Z0yjRo24ceMGkydPZuHChdSpU4eLFy+qOyxAzPNWlTJlynDkyBF27NjBsWPHMDc35+DBg198357ASJyWn+dyxMeE83s9h9O/fjkiDqfl59kTGKn02DVRzn43ULL79++TlpaWqxJKgCpVqnD16lUcHR1xdXVl7ty5Gn8yMqvS0tI4f/48w4cPp2zZstja2rJv3z7c3d3x9/fn6dOnrFmzhmbNmqGrq0vVEoWwrWKs9Gk5OhKwrWKc6RY1mZGWlsbFixcZN24c1apVo0aNGsyePZtSpUqxdetWoqOjFfWSVapU+f4Fc5DsTigBihQpwsaNGzl16pSivu+PP/5AJsv8Kf93797x7t07sUKZQXnz5mXGjBkEBQVRtGhRbG1tGTp0qNqTOTHPW3UkEgk9e/YkLCwMa2tr2rdvT/fu3RUjS1f73cfDK5gUqSzTwyvSZHJSpDI8vIJZ7XdfFeFrFJFQZkL6lm9Or6H8mkKFCnHgwAGmTZvGlClT6Ny5c44bBSaVSjl79iy//vorpUuXplmzZhw6dIiuXbty6dIloqKiWLlyJba2tl+tqZvX3hI9ZSaUcjnSDymYRPoqfY5vcnIyBw8epG/fvpQsWRJbW1s8PT2xs7PjyJEjxMbG4uXlRe/evXP16pY6Esp0zs7OBAcH06NHD4YMGYKTkxOPHj3K1DVy45QcZTA3N+fixYusXLmS7du3Y25uzrFjx9QWj0goVa9UqVIcPHiQP//8k5MnT2Jubs749QdZcjpcKddfcjqcvTl8pVIklJkQFhaGiYlJrn046+joMGPGDLy8vDhx4gQ2NjaZfoPTNKmpqZw+fZqBAwdSqlQpHB0dOXnyJL169eLq1as8efKEZcuW0bhx4+9u75YzNGBmO3PlBSeRYJv/OSvmTKVZs2Y8efIkS5eLiYlh8+bNtGvXDiMjI9q3b8/Vq1fp378/ly9f5tmzZ4p6yfz58yvpRWg3qVSq1vGWhQsX5o8//sDHx4eIiAgsLS1Zs2ZNhlcr01dZcvOHgh+lq6vLiBEjFD0M27RpQ7du3dQy+EHUUGYPiUTCzz//TFhYGPXsnNlzXwZK3I2bdjg0R9dUioQyE3LLgZzvSU9EEhMTsbKy4uzZs+oOKVM+fPjAiRMn6N+/PyVLlqRFixacPXuW/v37c/36dSIiIli8eDHW1taZPozR1cqUsc7KOVE7zrkaO2cPxd/fn6ioKGrVqsXevXszdY179+6xaNEibGxsKFmyJL/88gvx8fHMmjWLe/fufVYvmdPrIX9EWlqa2lYoP+Xo6EhwcDC9e/dm2LBhODg48PDhw+/+nFihzLry5ctz/PhxPD09OXPmDNWrV8fT0zNby37ECmX2KlmyJIYthqGXRx+UeCBPKpMzyTtYadfTNOIdJBNEQvk/FhYWBAYGUrduXZydnVm1apVG11WmpKRw9OhRevfujYmJCS4uLly8eJFff/2VoKAg7t+/z4IFC6hXr16WT/QOs6/KAndL8urpZLqmUldHQl49HRa6WzLU/mO9oo2NDbdu3aJFixZ07dqVfv36fbPcIC0tjUuXLjF+/HiqVavGTz/9xIwZMyhevDibN28mOjpaUS8pWsl8nzq3vP+tUKFCrFmzhrNnzxIZGUnNmjVZtWrVf65WioRSOSQSCT169CAsLIwWLVrQq1cvWrVqleVdg4wSh3Ky1/3oBC4+iEWm5A7DaTI5Fx7E8iAmZ344EAllBkmlUsLDw3Nl/eS3GBoacvz4cUaOHMnIkSPp378/KSkp6g5L4d27dxw8eJAePXpgYmJC27ZtCQwMZOTIkdy+fZu7d+8yZ84cateurfS2MF2tTPEZbUfjSh/fyL+XWKZ/vXElI3xG29HF6vNT3UWLFmXPnj1s2bKFv/76i3r16nHjxg3gYz3k4cOH6d+/P6VLl6ZJkyZs27aNJk2acOjQIWJjYxX1ksWLq65XZk6kSQllOnt7e27fvk3//v0ZOXIkzZo14/79rxf8x8bGoqenl2MHMWQ3ExMTdu3axdGjRwkLC8Pc3JyVK1eqvCG6WKHMXjsDIpV+wDKdro6EP6/mzFpKkVBmUEREBB8+fBArlP+ip6fH0qVL2b59O7t27cLOzo5nz56pLZ7k5GQOHDhAt27dMDExoX379ty+fZsxY8YQGhpKWFgYM2fOxNLSUuW9BcsZGuDZ35ozo5rS07o85Y0MvqjHkQDljQzoaV0en9FN8exvTTlDg69eTyKR0LdvX27cuEG+fPlo0KABFhYWGBkZ4erqysWLF+nduzcXL1782Mro/+slDQy+fj3h+zQxoQQoWLAgq1at4ty5czx79oxatWqxfPnyLxKb9B6Uqv5dz23Sm9H36dOHUaNGYWNjQ2hoqMruJ2oos5ffvZhMn+jOqDSZHL/w7K/DzQ6a96TUUOkzvEVC+XW9evWievXqtG/fnvr16+Pt7Y21tXW23DsxMZHjx4+zf/9+jh07RnJyMrVr18bDw4OOHTtSrVq1bInjW6qWKMSMdubMwByzGpY0denA0BEj0dfToYJRgQxPwAkPD+fw4cMcOnSI4OBgxQztqlWrsmXLFpo0aaLiV5L7qPtQzvfY2dlx69YtJk+ezJgxY9i/fz9btmxR/M6LpuaqU6hQIVavXk23bt0YMGAAderUYeLEiUyaNIm8efMq/V4iocweiSlSIlV8cCYyLpmkFKnap58pm1ihzKCwsDCKFStGiRIl1B2KxrKysuL69etUrFiRpk2bsnXrVpXd6+3bt+zevRt3d3eKFy9Oly5diIiIYNq0ady/f5+goCAmT56s9mTy314+f4qZiQF1TIthXrrIfz5Q0qfyeHh4UL16dapVq8bUqVMpVqwYGzdu5MWLF5w6dYq3b9/i7u6u1rYmOZWmHMr5LwUKFGDFihX4+/vz8uVLateuzdKlS0lLSxNNzbOBjY0NQUFBeHh4MG/ePOrWrcuVK1eUeo/0hFKT69RziidxSV9MwFE2OfA4LknFd8l+IqHMoLCwMKpXry62jr6jZMmSnD17ll69etGvXz9GjhxJamqqUq79+vVrPD09cXV1xcTEhO7du/Ps2TNmz55NREQE169fZ8KECRrbfDslJYXXr1//54eSd+/ecfToUX755RdKly5N48aN2bx5Mw0bNsTb25vY2FhFvWSJEiVwdnbm9u3bWFlZ0aZNG0aOHKlRI+O0naZueX9NkyZNuHnzJkOGDGHcuHE0adKEyMhIsUKZDfLly8esWbO4ceMGBQoUwMbGhhEjRihtVbFQoULI5XKSknJeEqJpPkgzP0BAk++TnURCmUF37twR290ZlDdvXjZs2MCaNWtYu3YtLVq0UPTDy6z4+Hi2bdtGmzZtMDExoVevXsTGxjJ//nyePHnC1atXGTt2LBUrVlTyq1C+ly9fAh8L+z8VGxvLtm3bcHd3x9jYmLZt23L+/Hl69uzJhQsXePHiBVu3bsXNzY0CBQp8cV0TExOOHj3KypUrWbduHdbW1ooSDSFrtCmhBDAwMGDp0qVcvHiR+Ph4Ll68yNOnT5XeGF/4OktLS65cucLSpUvZvHkzFhYWnDhxIsvXLVTo46Qsse2tevp62ZMWZdd9slPOe0UqIJPJREKZSRKJhCFDhuDj40NwcDBWVlbcvn07Qz8bGxvL5s2badmyJSVKlKBfv368ffuWJUuW8PTpUy5dusTo0aMxNc2e+dbKkt4Q2cTEhAcPHrB06VKaNm2qeI3Pnz9n6tSphIWFce/ePRYvXkyTJk0yVMMnkUgYMWIE165dIzU1lfr167N+/XqxRZZF2pZQpmvcuDE3b96kcOHCBAYGYmNjIz5kZBNdXV1Gjx5NSEgI1apVw8XFhR49evzwh2oAfYNC5DGpyLWIl4Q+e0NSiviAoCoVjAoouVnQlyT/f5+cRiIX7zjf9ejRIypVqsTJkydp0aKFusPROk+ePMHNzY3w8HC2bdtGp06dvviemJgYvL292b9/P35+fsjlcuzs7OjYsSPt27enVKlSaohceWQyGStXruS3336jatWq3L9/n7x58+Lk5ISrqytt27alZMmSSrlXcnIyv/32G+vXr8fd3Z2NGzdiaGiolGvnNv379yc0NJSrV6+qO5QfUqRIEXr16qWYtDNjxgzGjRunlUmyNpLL5ezYsYPRo0ejq6vLypUr6datW4ZKp+5HJ7AzIBK/ezE8+dchEQlgamiAfTUTfrY2pWqJQip6BbmHVCrl0qVLHDx4EO/UWlBIdS3WyhsZcH6svcqury5ihTID0j/Zix6UP6Z8+fJcunSJtm3b0rlzZ6ZMmYJMJuPFixesXbsWBwcHSpUqxdChQwFYs2YNz5494+zZswwZMkRrk8n3799z7NgxBg0aRNmyZfntt98AsLa2xsvLi7i4OEW9pLKSSfi47blu3ToOHDiAn58fNWvW5Ny5c0q7fm6iDYdyviU1NZW3b99St25dgoKCGD16NFOmTKFRo0aEhISoO7xcQSKR0Lt3b+7cuYODgwM///wzbdq0ITLy230Io+KT6bk5gOYr/PEMePJFMgkfD3U8iU/GM+AJzVf403NzQI4e6acqycnJih69JUuWpFmzZvz1119U0E9SWXKkqyPB3szk+9+ohURCmQF37tyhYMGClCtXTt2haC0DAwN2797NxIkTmTdvHsWLF6dUqVKMHDkSfX191q9fz4sXLzhz5gyDBg3S2tP0cXFx7Nixgw4dOmBsbEybNm3w9fWlW7duDB48mCJFiuDp6Un79u2/Wg+pTO7u7ty+fZsqVarg4ODAlClTlHZAKrfQ1i1v+N+UHGNjY/Lly8eCBQu4cuUKycnJ1K1blzlz5ojfh2xSokQJ9u7dy6FDh7h58ybm5uasXr36iylHewIjcVp+nssRH//tvtcLMf3rlyPicFp+nj2BObNhtjKl16y7ublhbGxM+/btuXbtGoMGDeLatWtERUWxcUIvVHVkJk0mp0dD7SrXyiiRUGaAOOGdNVFRUaxYsYImTZowf/58dHR0ePv2LaVKleLSpUucPHmSAQMGZKi9SVKKlNBnbwiKfKUxtUQREREsX76cZs2aUaJECXr37s0///zDpEmTCAkJ4f79+yxdupSCBQt+cSBH1cqWLYuvry+zZ89mwYIFNG3alIiIiGyNQZvlhITy01PeDRo04MaNG4wbN44ZM2ZgbW2d4dpmIevatWtHWFgYPXr0YPjw4dja2nLnzh0AVvvdx8MrmBSpLNNNtdNkclKkMjy8glnt9/WpSbnZo0ePWLFiheIZ3a9fP16+fMnMmTO5d+8eoaGhzJ07FysrK3R0dKhaohC2VYyVPi1HV0eCbRVjqpjkzBIFUUOZAQ0bNuSnn35i27Zt6g5Fazx69IgDBw6wf/9+AgIC0NfXp2XLlnTs2JG2bdsSExODq6srz58/Z/fu3bRq1eqb1/q0ligyPvmzHmHqqCWSyWRcv35d0WQ8JCSEvHnz4ujoqKiH/No2fa9evYiIiODixYsqj/Frrly5Qvfu3YmLi2PdunV0795dLXFok44dO5KYmMjJkyfVHUqm+fv7Y2dnx927d7/aj/Xvv/+mT58+3L17lylTpjBx4kT09fXVEGnu5O/vzy+//MLjx4/pOGEZl1IrKO3aC90tvxjfmpvI5XJu3brFwYMHOXjwILdu3UJfXx8nJyfc3NwyVLMeFZ+M0/LzpCixvU9ePR18Rtt9cxqathMJ5XfI5XKKFCnC5MmTmTBhgrrD0WgPHz5k//797N+/n+vXr5MvXz5atWpFx44dadOmzRfzhN+8eUOPHj04duwY8+fPZ/z48Z+tAkfFJzPJO5gLD2LR1ZH856f29K/bVjFmXntLpf/BpqSkcPbsWQ4dOsSRI0d49uwZhoaGtG7dGldXV1q0aEHBggX/8xotW7akQIECHDhwQKmxZcabN28YMmQIu3btomfPnqxZs0bRkkT4kpubG6mpqVrZNN7Ly4sOHToQGxv7zV6UKSkpzJ07l3nz5mFhYcG2bduoXbt29gaai71//57xMxdyKNUSiZ4+KGkXLKcnLl8jlUq5ePGiIol88uQJRYoUoU2bNri5udGiRYtMP+v2BEbi4RWstBhzeqIvtry/49mzZyQkJIiWQd8QHh7OvHnzqFOnDlWqVGHmzJlUqFCBvXv38vLlS7y8vOjevfsXySR8PIF66NAhJk2ahIeHB927dyc5+WNhuSbUEsXHx/Pnn3/SqVMnjI2NcXFx4fTp03Tu3Bk/Pz+io6MV9ZLfSybh40n27N7y/rciRYrw559/sn37dry9valTpw7Xrl1Ta0yaTJsP5cTFxSGRSChatOg3vydv3rzMmjWLa9euIZfLsbKyYvr06Xz48CH7As3F8uXLx6sqLdHVz6u0ZBJAKpMzyVt5iZCmSj9U06dPH0qUKIG9vT379++nTZs2nDlzhpiYGP788086duz4Qx+cu1qZMtbZTCmxjnOulqOTSRCzvL9LzPD+0p07d9i3bx/79+8nODiYAgUK0LZtW6ZMmaJYhcsoHR0d5syZQ61atejTpw9NmjTBfeoGNl2L/qHY0mRy0mRyPLyCiU1MYZh91Uz9/OPHjzl06BCHDh3C39+ftLQ0rKys8PDwwNXVFXNz8x+upY2OjlZ7QgkfT5726tWLxo0b0717d2xsbJg9ezbjx49HR0d8xvyUVCrFwEA7V3ni4uIoVqxYhvqY1q1bl8DAQObNm8fcuXPx9vZm27Zt1K1bNxsizb3uRydw4cGP96f8ljSZnAsPYnkQk5Dj6vVevnzJ0aNHOXjwIKdPn+b9+/eYm5vz66+/4ubmRr169ZR63mGYfVWMC+Zl+uFQpP///pJRujoS9HQkzGpnnuOTSRAJ5XeFhYWRL18+KlSooO5Q1EYulxMSEqLYzg4LC6NQoUK0a9eOWbNm0aJFC/Lnz5+le3Tq1AkzMzNcf1v4w8nkvy05HU7xgnn/8w9ZLpfz999/c+jQIQ4fPszt27fR19fHwcGB1atX07ZtW8qUKZPlWORyOTExMRp1er1KlSpcvHiR6dOnM2nSJM6cOYOnpyelS5dWd2gaQ5sP5WR2jre+vj4zZszAzc2Nvn370qBBAzw8PJg6dSp58+ZVYaS5186AyO+W8/woXR0Jf16NZEY7c6VfO7tFRERw6NAhDh48yMWLF5HL5TRu3JjZs2fj6upK1aqZWzjIrK5WpthUNs50CVbjSkYqKcHSVNr5pMxGYWFhVKtWLUOf8nOS9KLm9CTy3r17FClSBFdXVxYsWEDz5s3Jly+fUu9pWK4qeRv3ICVVprTtn2mHQ2lc2fizP+iUlBTOnTunSCL/+ecfihYtSuvWrRWrrMquK3z9+jVSqVQjVig/pa+vz/z583FycqJnz57UrFmTLVu20K5dO3WHphG0OaGMi4v7oTnetWvX5tq1ayxYsIDZs2dz8OBBtm3bRv369VUQZe7mdy9GJckkfFyl9AuPYQbal1DK5XJu3rypqIe8ffu2YhDE+vXradu2bbZ/OC9naIBnf+v/HRINjyEy7iuHRI0MsDczoUdD0xy3Ovw92vmkzEZhYWG5ZrtbLpdz48YNxXb2w4cPKVasGG5ubixbtgwnJyeVngKd5B2MVIZKaol+71CN48ePc+jQIU6cOEFCQgIVKlSgY8eOtGvXDltbW/LkyaO0+/7bp2MXNZGjoyO3b9+mX79+uLq6MmTIEJYsWZLllWdtJ5VKtfbD5I8mlAB58uRh6tSpuLm50adPHxo2bMi4ceOYPn260j9I5laJKVIiVdyMPDIumaQUKQXyav5bvVQq5cKFC4okMjIykqJFi9KmTRumTp36Q4dqVKFqiULMaGfODMyJe5tIqao1mT5rDm5tW1PBqIBW/L9Wldz7yjNALpcTFhaWo8ctyuVyrl27pliJfPz4MUZGRrRv3561a9dib2+v0kQrnapriUpV68r7mMfUq1ePcePG4erqiqWlZbb1Fo2O/riNr6kJJXxsgH3o0CHWrl3LmDFj8Pf3Z/fu3VhYWKg7NLXR9kM5ZmZZO1BgaWnJ1atXWbx4MTNnzuTQoUNs3boVa2trJUWZez2JS0LVLVbkwOO4JMxLF1HxnX5MUlISp0+f5uDBgxw5coRXr15RtmxZ3NzccHNzo2nTptny/vOjpO+SSI15hGWpghr7/zg7aeeTMpu8fPmS+Pj4HLdCKZPJuHr1qiKJjIqKwsTEBHd3dzp27IidnV22v4mqspYIuYxWI+axqrctZcuWVf71MyB9hVKTaii/RiKRMHToUOzs7OjatSv169dn6dKlDBkyJFc29tfmLe/Y2FgaNWqU5evkyZOHSZMm4erqSt++fWncuDFjx45l5syZYrUyCz4osb+hJtwno16+fMmRI0c4ePAgZ86c4f3791hYWDB06FDc3NyoW7eu1jxr3rx5A3zsniGIhPI/5aQT3mlpaVy+fJn9+/dz4MAB/vnnH0qWLEmHDh3o2LEjtra2at3aU2UtERId4vKWVFsyCR8TSj09vf9s4aJJLCwsCAwMZNy4cQwbNoxTp06xZcuWTB3yyAm0OaHMypb315ibm3P58mWWLl3KtGnTOHz4MFu2bFFK0pob6etlT0eF7LrPf4mIiFBsZV+6dAm5XI6NjQ1z5szB1dWVKlWqqDvEHyISys9p55Mym4SFhaGnp0flypXVHcoPSUtL48KFC+zbtw8vLy9evHhBmTJl6NChA506daJRo0YaUR+WG2qJ0lsGacsnb4D8+fOzevVqnJ2d6devHzVr1sTT0xNHR0d1h5ZttDWhTEtL49WrV0r/AKCnp8eECRNo27Yt/fr1w8bGht9++43Zs2fn+nrbjEpISMDHx4fDx08hN2qj0meCBKhglPE2bsoil8sJCgpSJJHBwcHkzZuX5s2bs2HDBtq2bavR5T8ZJRLKz2nfkzIb3blzBzMzM42u4fg3qVTKuXPn2L9/P97e3sTExGBqakr37t3p2LEj1tbWGtdrMDfUEmlay6DMaNeuHbdu3aJXr140b96c8ePHM3v2bK36u/hR2noo5/Xr18hkMqWuUH6qRo0aXLp0ieXLlzNlyhSOHDnCli1bsLGxUcn9tJlcLufOnTscP36c48ePc/HiRVJTU6lWrRoFXR1JkqiupYypkUG2fYhOTU397FBNVFSU4lDN9OnTMzRNTNuIhPJzIqH8D9pywjs1NZWzZ88qksi4uDgqVKhA79696dixI1ZWVhq9MpYbaok0YUpOVpQpU4YzZ86wePFipkyZwtmzZ9m1a5fWblVllDYeyklKkXIt/Bn6pcxIzFNUZSvzurq6jB07ljZt2tCvXz9sbW0ZOXIkc+fO1dpm8MqSlJTE2bNnOX78OCdOnODJkyfky5cPBwcHli9fTqtWrahUqRIzDofiGfBEZX0o7c1U+8xJTEzk1KlTHDx4kGPHjvHq1SvKlSunOFSj6u4Z6vb69WuAr06Cy42060mZzcLCwhg4cKC6w/iqDx8+4OPjw759+zh06BCvXr2icuXK/PLLL3Ts2FGrCptzQy1RTEwMFStWVNv9lUFHR4cJEybg4OBAt27dqFOnDmvWrKFnz55a87uWWdqy5a3ojXcvhsj4j73xSvVexrTL75h++RSmhgbYVzPhZ2tTqpZQbuuVn376iQsXLrBy5UomT57M0aNH2bJlC7a2tkq9jyaTy+Xcv39fsQp5/vx5Pnz4QKVKlWjXrh0uLi7Y2dl9URbws7Up2648VklMaTI5PRoqfzpLTEzMZ4dqUlJSsLS0ZNiwYbi5uVGnTp0c+zz4tzdv3lCwYEGteEZkB/F/4RtevXrFixcvqF69urpDUXj//j2nT59m//79HD58mDdv3mBmZsaQIUPo1KkTNWvW1Mo/5ApGBZCASre91VVLlC46OjrHtFqxsrIiKCiIYcOG0bt3b06dOsXatWtz5LaPpieUUfHJ353eIQeexCfjGfCEbVceY1vFWOnTO3R1dfntt98Uq5V2dnYMHz6cefPmZWoUqzZ59+4d586dU6xCPnz4EH19fZo1a8aiRYto1aoVVatW/c9nctUShbCtYszliDilrlLqSqBxZWOlNdZ++PDhZ4dqAJo0acK8efNwdXXV2nMGWfXmzZsc+dz7UZr7pFSDpBQpj+OS+CCVcSc0GEmefGrf8n737h0nT55k//79HDlyhISEBGrUqMGoUaPo2LFjlmZLa4oCefUwNTTgiQoP5mRnLdHXaHMN5dcUKlSI7du306JFCwYPHsyVK1fYtWsXDRs2VHdoSqXJCeWewEjFfGHguwlJ+tcvR8ThtPw8M9uZ01XJ84XNzMw4f/48q1evZuLEiYrVSjs7O6XeR10iIiIUCeTZs2d5//495cuXx8XFhVatWuHg4JDpBHpee0uclp9XXkIplyOVptKq+JssXOLjkIv0JDIkJIS8efPi7OzMpk2baNOmjVaX8CiLSCg/p5lPymz0ta2idOV+28ewk7E4PA5VyVbRtyQlJXHixAn279/P0aNHSUpKombNmowbN44OHTqoPclVBftqJlpdS/RfUlJSePPmTY58AHfv3p2GDRvSvXt3mjRpwsyZM/Hw8NDKgyxfo6mHclb73WfJ6fAf+tk0mZw0mRwPr2BiE1MYZq/cOci6urqMHDmS1q1b069fP5o1a8bQoUNZsGCB1h3KSElJwd/fnxMnTnD8+HHu3btHnjx5sLW1Zc6cObRq1Yrq1atn6UN9OUMDZrYzx8MrWDlBSySU+ucCPduv5On8+YwbNy5D8aWmpuLv769IIp8+fUqxYsVo06YNM2fOxNnZWev+/VRNJJSfy7UJZUa2iiQSCZGv3ql0qyhdYmIix44dY9++fRw/fpx3795Rp04dJk2aRMeOHbM88ULTaWMtUUZp+tjFrKpUqRIXLlxg5syZTJ06lTNnzuDp6Um5cuXUHVqWaeKhnD2BkT+cTP7bktPhFC+Yly5KXqkEqFKlCufOnWPt2rVMmDCBY8eOsXnzZhwcHJR+L2WKjIxUJJC+vr4kJSVRpkwZXFxcmD9/Po6Ojko/hNHVypTYxBSl/LuOc67G4KYtmVohHxMmTODGjRts3rz5qyuniYmJnDx5UnGo5vXr15iamuLu7o6bmxtNmjTJ0YdqskoklJ+TyOVyVXds0TifbhVlZkVMV0eCno5EaVtFb9++5ciRI+zfv5+TJ0/y/v176tevT6dOnejQoUOuq0vpuTlA6bVE8jQpJXUSOD+jo9qmevz999/Ur1+f69evU69ePbXEkF3Onz9Pjx49SEpKYtOmTbi7u6s7pCwpWrQoU6ZMYezYseoOBfj4Qdhp+XlSlNixIK+eDj6j7VTyQTldREQE/fv359y5c/z6668sXLhQI+Yyw8cDjpcuXVIkkaGhoejq6mJjY6PYys6uMa1ZfW+a1c78sw8H+/fvp0+fPlSuXBlvb28qVapEdHS04lCNj48PKSkp1KxZU3Eyu3bt2lpfRpVdHBwcMDExYc+ePeoORSPkuoQyK1tFnxrrbPZDW0WvX7/m8OHD7N+/n1OnTvHhwwesra0VSWSFChWyHJu2UsWbpS4ynm8agqlRAbZs2ULjxo2Vdu2MOnHiBC4uLkRFRal1Wk92iY+PZ8CAAXh7ezNw4ECWL1+utW1kChYsyJw5cxg1apS6QwFU86FLV0dC40pGePZX7aExmUzGunXrGD9+PMbGxmzatAknJyeV3vNb/vnnH06ePMnx48c5c+YMCQkJlCxZklatWtGqVSuaN2+utqlWGdk9S5f+9f/aPQsJCaF169a8fPmSihUrcufOHSQSCU2aNMHNzQ1XV1cqVaqkypeUY9WrVw8rKyvWrVun7lA0gmbt5aiYuraK4uPjOXToEPv27cPHx4fU1FRsbGxYuHAh7u7umJqqbztWkyi9lgiY514Lix4n6devH02aNGHUqFHMmTMnWxOc9C3v4sWLZ9s91cnQ0JADBw6wceNGRo0axYULF9i9eze1atVSd2iZpkmHcu5HJ3DhQazSr5smk3PhQSwPYhKUdir4a3R0dBgyZAitWrViwIABNG/enF9++YUlS5aovI+fVCrlypUrilXIW7duoaOjQ8OGDRk/fjwuLi7Url1bI4Y+lDM0wLO/9f/q+8NjeBKbBJ+sGkr4eNDQ3syEHg1Nv/h3k8vl/P3334p6yMjISHR0dAgLC6NTp06sXr06x5bgZCex5f05zXhSZoOo+GSmHw5V6jWnHQ6lcWXjr34qjI2Nxdvbm/3793P27FnS0tKwtbVl6dKluLu7U6ZMGaXGklMou5YoPeG/dOkSK1asYOrUqRw+fJjNmzdn28nT6OhoihQpQt68ebPlfppAIpEwcOBAmjRpQrdu3WjQoAGLFy9m+PDhWrWdpkmHcnYGRH53xepH6epI+PNqJDPamSv92v9WsWJFfHx82LBhA2PHjuXkyZNs3LiRFi1aKPU+0dHRilXI06dP8/r1a4yNjWnZsiUTJkzA2dlZZZOElKFqiULMaGfODMzpPWAgIY+j2bRlG/p6OlQwKvBF14rU1FTOnz+vSCL/+ecfihUrRtu2bZk9ezaOjo4sWLCA+fPnI5FI2LJlS45t6ZRdREL5OfV/HMsmk7yDFe01lEUqkzPJ+3+radHR0axbtw4nJydKlizJ4MGDSU1NZeXKlTx79ozz588zfPhwkUx+xzD7qixwtySvng66OplLPnR1JOTV02GhuyVD7f83xUVPT4+xY8dy69YtSpYsSbNmzRg2bBiJiYnKDv8LOa1lUGbUqFGDgIAABg8ezMiRI2nTpo1ixVbTyeVyjTqU43cvRiXJJHxcpfQLz75/F4lEwqBBgwgJCaFatWq0bNmSAQMGKEbZ/Yi0tDSuXr3KtGnTqF+/PiVLlqRv3748evSIkSNHEhAQwIsXL/D09KRbt24anUz+29u4l5TQT6WOaTHMSxdRJJMJCQns27ePHj16ULx4cZo3b87Ro0fp2LEjfn5+xMTEsH37dtq3b0/hwoWZN28e+/bt49ixYzRq1IiIiAg1vzLtJZfLRUL5L7kioUzfKlL2wzh9q2jWig3Y29tTunRphg0bhkQiYe3atTx//pyzZ88yZMgQSpYsqdR753RdrUzxGW1H40ofH/rfSyzTv964khE+o+2+WYqQ3idv5cqVbN26FUtLS3x9fZUb/L9o+9jFrMqXLx8rV67k6NGjBAYGUrNmTU6fPq3usL5LJvtYy6sJCWViipRIFfZpBYiMSyYpRarSe/xb+fLlOX36NBs3buSvv/7C3Nyc48ePZ/jnY2Nj2blzJz///DMlSpSgUaNGrF69mqpVq7Jjxw5evHjBtWvXmDFjBg0aNNCY1ebMio+Px9DQEPi4cLFx40Zat26NsbExnTt3JiQkhFGjRhEUFMSjR49YsWIFzZo1++rvbseOHbl69SrJycnUr19fK/4WNdH79+9JTU0VCeUnckVCmb5VpApyWRqrTgSRL18+NmzYwIsXLzhz5gwDBw7M1UmEMqTXEp0Z1ZSe1uUpb2QA/zpDJgHKGxnQ07o8PqOb4tnf+runVXV1dRkxYgS3b9+mQoUKODk5MWjQoCytjvyX6Oho8bsAtG7dmlu3blGzZk1atGjB2LFj+fDhg7rD+iap9GNypQkJ5ZO4JJVOkoKPE3UexyWp+C5fkkgkDBgwgJCQECwsLGjdujV9+/bl1atXX3yvTCbj+vXrzJo1i4YNG2JiYkKPHj24c+cOgwcP5tKlS8TExLB792569uyZY/7uXrx4wePHj7GxsaFUqVIMHjyYpKQkFi5cSEREBDdv3mTGjBkZPqFtYWFBYGAg1tbWtGrVikWLFpHLzudmWfocb5FQ/o/6n5TZQJVbRRIdXao7dOTEBEeVXF/4vJaoXMUquPYYQP9fBn2zliijKleujK+vLxs2bGDcuHEcP36cjRs30rJlS6XGHxMTI05R/r9SpUpx8uRJli9fzsSJE/Hz82PXrl1Uq1ZN3aF9IT2h1IRVrQ9K7HygCff5GlNTU06cOMHWrVsZPXo0p0+fZv369djY2HD69GmOHz/OyZMniYmJoXDhwjg7OzNo0CBatmxJqVKl1Ba3Kshkss8O1YSHh/Pw4UPatGnDli1baNOmDcbGxlm6R7FixTh69ChTp05lwoQJ/P3336KuMhPSFyDU1Q1AE+X4Fcrs2Cp6+vp9tm8V5VbxMc+pYpTvi1qiH6Wjo8PgwYMJCQmhevXqtGrV6purIz8qN9dQfo2Ojg5jxozhypUrJCQkULduXbZs2aJxKySatEKpr5c9j+rsus+3SCQS+vbty19//UXBggVp27YthoaGdO3alaCgIPr27cv58+eJjY1l37599O3bN8ckkx8+fOD06dMMHToUU1NTGjRowLp167CyskJfX5/58+dz8OBB+vTpk+VkMp2uru4XdZUPHz5UyrVzuvSEUqxQ/k+OTyhz8lZRbvP+/XuSk5MVtUTKVL58eU6dOsWmTZvw8vLC3Nycw4cPZ/m6crk819dQfku9evW4ceMGXbt2pX///nTt2lWxjaQJ0tLSAM1IKPXevwIVP8kkQAUj9axOvXnzhgMHDtC/f3/KlClDy5Yt+eeff6hbty758+fHxMSEOXPmsGDBApo2bfpD01uSUqSEPntDUOQrQp+90YhFgLdv3/LXX3/RvXt3ihcvTosWLTh27BidOnXCz8+P6Oho/vjjDz58+KDSxPnTukorKytOnTqlsnvlFCKh/JL6n5Qqlhu2inKL+Ph4AJWdzpRIJPTv358WLVowaNAgXF1d6d69O6tWrfrhe7569QqpVCoSym8oWLAgmzdvpkWLFgwcOJBatWqxa9cubGxs1B2aWlcoP3z4wMWLFzlx4gQnTpwgNDSU0oM2kqeY6pIKUyODLK/4Z5RcLic0NJTjx49z4sQJLl68iFQqpXr16nTv3h0XFxeaNGmCvr4+z549U/w9/vzzz6xcuTLDf4+KXo73YoiMT/4sJZcApoYG2Fcz4WdrU6qWyJ7JPS9evODw4cMcPHgQX19fPnz4QO3atfntt99wc3OjZs2an9VBRkdHA6jkg/Sn0usqf/75Z1xcXJg3bx7jx4/XqjZf2UkklF/K8SuUuWWrKDdITyhV/WAtW7YsR48eZceOHZw4cYIaNWqwf//+H7pWTp/jrSydO3fm1q1blCtXjqZNmzJz5kxFQqcu2Z1QRkZGsn79etzc3DAyMsLR0ZE///wTKysr9u7dS0/HOio7XKirI8HeTLW/o4mJiRw6dIjBgwdTvnx5LC0tmTlzJgULFmTVqlU8evSIsLAwlixZgoODA/r6+gCULl2aw4cP4+npyfHjxzE3N8fb2/s/7xUVn0zPzQE0X+GPZ8ATnvwrmYSP671P4pPxDHhC8xX+9NwcQJSKyqPCw8NZtGgRjRs3pnTp0vz666+8e/eORYsW8ejRI4KCgpg+fTq1atX6IoHLrucefKyrPHLkCB4eHnh4eNClS5dsaa2mjdITSk0ZIaoJcvwKZQWjAkhQ7WaROreKcpPsfLBKJBJ69uyJk5MTQ4YMoVOnTnTs2JE1a9ZkKjlMTyhFDeX3lS9fnnPnzjFnzhxmzZqFj48Pf/75J+XLl1dLPKo+lJOSkvLZKmRYWBi6uro0atSIiRMn0qpVK2rVqqWY3lInOoE9N16oJJY0mZweDZU7sUsul3Pv3j3FKqS/vz8fPnygatWquLu74+LiQtOmTcmXL993ryWRSOjRoweOjo78+uuvuLu707VrV37//fcv6gk/nYed/tr+S/rXL0fE4bT8PDPbmdM1AxPQ/kv6afT0QzV37twhf/78tGjRgq1btypa/mREdj734OPv+9y5c6lbty69e/emcePGeHt7U7ly5Wy5v7Z4/fo1hQsX1ohDe5oixy+rFcirh+l32shkVXZuFeVmcXFxgOq2vL+mVKlSeHl5sWfPHs6dO0eNGjXYtWtXhg+QpG9XiRXKjNHT02PGjBmcO3eOJ0+eUKtWLfbt26eWWFSxQvnkyRPWrVuHq6srRkZGODk5sWvXLqytrfnrr7+IjY3lwoULTJo0iTp16nw2CrBqiULYVjFW+iqljgRsqxgrZexicnIyx44dY9iwYVSuXJnq1aszadIk9PT0WLJkCffv3yc8PJwVK1bg7OycoWTyU6VKlcLb25tdu3Zx+vTpL3YPVvvdx8MrmBSpLNOdPdJkclKkMjy8glntdz9TPwv/O1QzZMgQypUrh7W1NRs2bMDa2pqDBw8qpqf17t07U4dqVF3q8y0dOnQgICCAd+/eibrKrxBNzb+U4xNKAPtqJlq9VSR8lP5gze42DRKJhC5duhAWFoajoyM///wzbm5uPH/+/Ls/GxMTQ548eURriUyytbXl1q1bODs707lzZ/r3709SUvYefFPGoZyUlBR8fHwYM2YMNWrUoEKFCgwbNoxXr14xefJkgoKC+Oeff9iyZQudOnX67u/JvPaW6CnzWSaXI/2QQqG7R3n//v0PXeLBgwf8/vvvtGrVCkNDQ9q0acPx48dxcXHh2LFjxMfHc+LECYYPH06VKlW+f8HvkEgkdOvWjbCwMGxtbenUqROdO3dmg2+oUka2Aiw5Hc7ewMjvft/bt2/Zu3cv3bp1UxyqOXHiBJ07d+bcuXO8ePGCrVu34urqioHBjy1sqOu5B2Bubs61a9do2LAhrVq1YsGCBRrXjUFdREL5pVyRUP5sbarSkWXK3ioSvi4uLo4iRYqo7dRt8eLF2bt3LwcOHCAgIIAaNWqwbdu2/3zApp/wFoXtmVesWDH27t3Lpk2b2LNnD3Xr1uXGjRvZdv8fXaF8/Pgxf/zxB+3atcPIyIjmzZuzZ88eGjVqxL59+4iNjcXf35+JEydmuBF1unKGBsxU5rxtiQTHonFsXrWI+vXrZ+j/7/v37zl16hSjRo3CzMyMqlWrMmbMGKRSKfPnz+fu3bs8fPiQ1atX4+Li8sOJ1PeUKFGC/fv3s3fvXs4FBjP3ZDjKLG6adjj0qzWVz58/Z/369bRq1QpjY2O6du3KvXv3GDNmDLdu3SIiIoLly5djZ2enlGdVXFwcRYsWVdvWanpd5aRJk5g4caKoq/x/IqH8Uq5IKFW1VaSrxK0i4fvi4+M1Yv6uu7s7oaGhtGnThr59+9K6dWuioqK++r2iZVDWpJ+8v3HjBgUKFKBhw4YsXbpUMRZRlTKaUKakpHDmzBl+++03qlevTsWKFRk+fDhv3rxhypQp3Lx5k6dPn7J582Y6duyY5ZWmrlamjHU2y9I10o1zrsbWKb9w48YN8ubNi7W1NbNmzSI1NfWz70tPktu2bYuRkREtW7bEy8sLBwcHDh06RHx8PGfOnGH06NFUq1Yt2z5ASSQSOnfujP34DUh09fhY0a4cUpmcSd7BANy7d4+FCxfSqFEjSpcuzdChQ0lJSWHJkiU8evSIGzduMG3atC9OaCvDp2MX1UVXV5c5c+Zw4MABjh8/LvpVIhLKr8k1hX/z2lvitPy80lYq5XI5aWlS+tdUbX2m8D+a8GBNZ2RkhKenJ126dGHQoEGYm5uzdOlSBgwY8EXLD5FQZl21atW4cuUKkydPZuzYsZw+fZrt27dTsmRJld3zvw7lPHr0SHGY5uzZsyQnJyv6J86ZMwcnJyeVvtkMs6+KccG8isMnmXmu6epI0NORMKuduWLmvbm5OVevXlUciDp8+DBDhgwhLCyM48ePc+fOHfT09GjSpAkzZszAxcWFGjVqaMTK+/3oBAIi34JEuesjaTI5Fx7EUs3KjvDr/uTPn5+WLVuyfft2WrdunW0fbjXpuefu7k61atVwc3Ojfv367N69W+mTxbTFmzdvckxTfWXJFSuUoPytIolEgv5tb9rYN2L37t1Ku67wbXFxcRrzYE3Xpk0bQkND6dSpEwMHDqR58+Y8fvxY8XWxQqk8efPmZcmSJZw8eZJbt25Rq1YtTpw4obL7fbpC+ek2b7Vq1ahUqRIjR44kMTGR6dOnc+vWLaKioti0aRMdOnTIlpWLrlam+Iy2o3Glj4nN93Zg0r/euJIRPqPtFMlkuujoaMqWLUuTJk24ceMG/fv3Z8OGDTRq1IgDBw4QFxeHn58f48aNw9zcXCOSSYCdAZEqq5GXy9Io3tidQ4cOERsbi5eXF7169crWnRJNSijh44ePwMBAGjdujIuLS66tq3z9+rWojf+XXJNQgvK3im7sX4Obmxvdu3dnyJAhpKSkKOXawtdpypb3vxUtWpTNmzdz6tQp7t+/j4WFBWvWrEEmk4mxiyrQokULbt++Tb169XBxcWHUqFEq+dt78uQJACNGjMDQ0JCWLVty4MAB7Ozs8PLyUiRY48ePV8lWZ0aUMzTAs781Z0Y1pad1ecobGXyx6SsByhsZ0NO6PD6jm+LZ35pyhgakpqbi7++Ph4cHNWvWpFy5cgwePJi0tDRmzJhBjx49SExM5MGDB9SpU4fChQtn++vLCL97MSqrkZfo6KJbribt2rVTWS3o92haQgkfn3mHDx9W1FV27tw519VVii3vL+WaLe90yt4q8vT0xNbWlhEjRnDt2jX27dtHxYoVVRV+rhYfH4+5uRIPJCiZs7MzwcHBTJgwgWHDhvHXX3/x/PlzsUKpAiYmJhw7doxVq1Yxfvx4zp07x+7du6levfoPX/Pdu3ecP39esZV9//7H1jEpKSnMnDmTVq1aadTK3KeqlijEjHbmzMCcpBQpj+OS+CCVoa+nQwWjAoq2Zs+fP2fr1v0cP36c06dP8/btW0xMTGjVqhWTJ0/G2dmZYsWKKa47YMAA+vTpQ82aNVm2bNkXJR3qlpgiJVJFzcjTRcYlk5QiVVtruPj4+Cz9XqtKel1ler/KRo0a4e3trZST/NpAJJRfylUrlOmUuVUkkUgYNGgQV65cIT4+nrp16yplBrTwpbi4OI1cofxU4cKF+eOPP/D19eXJkyckJiYSFBSkaEEjKI9EImHkyJEEBASQkpJCvXr12LBhQ6a239Jb3ri4uGBkZESrVq3w9vbG3t6e2bNnA7Bz507GjRuHhYWFRiVT31Igrx7mpYtQx7QYP5UoyK2/rzFlyhTq1q1L6dKl6d+/P0+fPmXs2LEEBgby/Plztm3bRpcuXT5LJgHs7Oy4ffs2Xbt2ZeDAgbRu3Zpnz56p6ZV96UlckoonnH88N/44LntbVn1KE1coP+Xu7q74G7SysuLkyZPqDknl5HK5SCi/IlcmlJC1raKvSW9p0qxZM1xdXRk/fvwXJyWFrNH0B+unHBwcFA/W3bt3Y2try927d9UcVc5Uu3Ztrl+/Ts+ePRk0aBAdO3ZU9O77t3fv3nHixAlGjBhB1apVFS1vUlJSmDVrFiEhITx58oT169fTsGFDQHWTclQlJiYGT09PRW9EGxsb1q1bR40aNfjzzz+JiYnhypUrTJ06lfr163/WPP1rChUqxMaNGzl69ChBQUFYWFiwe/dujaib+yBV/Wn/7LzP12jDc69GjRpcu3ZNUVc5f/58jfj9UJXk5GTS0tJEQvkvuW7L+9/+vVVk3rAZLVq1ZsSwIZ9tFWVE0aJF8fLyYtmyZUyYMIErV66wZ88eypQpo8JXkDu8e/eOd+/eafyD9VPpjbg3bdrEwoULqV27NjNnzmTMmDFq66WZUxUoUID169fj7OzML7/8Qq1atfjzzz+xs7Pj/v37im3sc+fO8f79e0xNTWnVqpVibvTX5vFm9yzvH5U+5u/48eMcP36c69evI5fLqV+/PsOGDcPFxQUrK6ssJ8atW7cmJCSEYcOG0b17d7y9vVm7dm2mpr4om75e9qyJZNd9/i0lJYWkpCSteO4VLVqUI0eOMH36dCZNmsSNGzfYunUrBQsWVHdoSpc+x1sklJ/LtSuUX1Mgrx7J/4RTvqAc89JFfqhmRiKRMGbMGM6fP8+jR4+oU6cOPj4+Kog2d1HX+LGsSB+72KJFC27evMnw4cOZNGkSjRs3JiQkRM3R5UwdOnTg6tWrFC1alGbNmmFoaIiZmRljx44lNTWVOXPmEBoayuPHjxUjEL+WTCalSHn8Jg39UmZEvPpAUopUDa/m2+Li4ti9eze9evWiZMmSWFtbs3LlSipVqsTWrVt58eIFgYGBzJo1i4YNGyptldXIyIjdu3ezd+9efH19sbCw4OjRo0q5dmbJ5XJeP72PMpuZf40EqGBUQKX3+JZXr14B2TfHO6t0dHSYPXs2Bw4c4OTJkzRs2JAHDx6oOyyle/36NaCe6UWaTCSU/5KUlKSU03w2NjYEBQVRp04dnJ2dmTVrVrY0Y86p0hNKbXmwwsetR/g4YcfAwIDFixdz+fJlEhMTqVu3LnPmzBFlEUogl8sJDw9n5cqVtGzZkpo1axISEkKRIkV4/fo11apV48aNG5+NQPxaLeT96ARmHA7FbrEfFjNOseAmlOq9jN6772Ix4xR2i/2YcTiU+9EJ2f4aZTIZN27cYM6cOdjY2GBiYkL37t0JDg5mwIABXLhwgZcvX7Jnzx569+6t8s4CnTt3JiQkhPr169O2bVv69+/P27dvVXpP+LjVeOTIEQYNGvSxxZG1FWlvYlR6T1MjA7UeyAHt+iAN/6ur/PDhA1ZWVipt76UOYoXy60RC+QmZTEZycjIFCijn02jx4sU5fvw4M2bMYMaMGbRq1YqXL18q5dq5jbYmlEWLFiVv3ryK/2Ztbc2NGzcYN24cM2bMoEGDBty8eVN9QWqp5ORkjh07xrBhw6hSpQrVqlVj/PjxyGQy5s+fz507d3j16hWXLl0iJSUFGxubb/aLjYpPpufmAJqv8Mcz4AlP4pO/WPOSA0/ik/EMeELzFf703Bzw1bF8yvT69Wv27dtHv379KFOmDPXq1WPRokWUKlWKDRs28PTpU4KCgpg3bx5NmjTJ9q35UqVKceTIETZt2sRff/2FpaUlfn5+Sr/P06dPWb9+PW3atMHIyIh27drh5+dH165dOXv2LH2crVTWh1JXR4K9mfq6NGjjcy9del2ljY0NrVu3Zt68eTmmrlIklF8nEspPvHv3DkBpCSV8LOifNm0ap06dUqxYXr58WWnXzy3i4uIA7fqk/q0pOfny5WPu3LkEBASQlpaGlZUV06ZNE31M/4NcLufevXusWLGCFi1aYGhoSJs2bTh+/DgtW7bkyJEjxMfHc/r0aUaPHs1PP/2ERCKhUaNG3Lx5k9atW9O9e3f69OlDQsL/Vhj3BEbitPw8lyM+/n59r41Y+tcvR8ThtPw8ewIjlfoab9++zYIFC7Czs8PY2JjOnTsTGBhIz5498fPzIzY2lv3799O/f3+NqM1OH40ZHBxMpUqVcHBwYOTIkSQn/3iyLZPJuHbtGtOmTaNOnTqUK1eOoUOHkpSUxJw5c7h37x7h4eEsXboUe3t7ejWqoLI+lGkyOT0amn7/G1Uk/bmnjQkl/K9f5ZQpU5g8eTKdOnXKEf0qRUL5dZpdbZ7N0g9RKDOhTNe8eXOCgoLo0qULdnZ2LFy4kNGjR2tFGxJNkP5JXZtqVr43JadevXpcv36defPmMXfuXLy8vNi6dStWVlbZGKXmSkpK4uzZs5w4cYKTJ0/y6NEj8ubNi52dHQsWLKBVq1aYmZl992+oSJEi7Ny5kxYtWjB06FAuXbrErl27CEgsypLT4T8UW9r/97D18AomNjGFYfZVf+g6CQkJ+Pj4cOLECY4fP84///xDgQIFcHJyYs2aNbRq1QpTU/UlNBlVoUIFfH19+f333/Hw8ODkyZPs2LEDa2vrDP18YmIiPj4+HDlyhGPHjhEdHU2xYsVo1aoVEyZMoEWLFl+0NEpXtUQhbKsYczkiTqmJpa6OhMaVjKhi8mWNbXZJf+5967VrAx0dHWbNmkWdOnXo1asXDRs25ODBg1rdr/LNmzdIJJIceeAoK8QK5SdUmVAClClTBj8/P0aNGsWYMWPo0KGDorhX+G9xcXEULVpUq1q4ZGTsor6+PjNmzOD69evo6+vTsGFDPDw8eP/+fTZFqTnkcjl37txh2bJlNG/eHENDQ9q1a8epU6dwcXHh6NGjxMXFfTYCMaMfyCQSCb179yYoKIiiRYviNGjaDyeT/7bkdDh7M7hSKZf/H3vnHVDz/v/xx2kSikrokj0r2RFJqNBA9t57703Zm2/2ukbmRaiMaMjOTnZC2amIiurU+f3hdn7uvUbjnM459Xn8d2/1fr+OOp/zfL/er9fzJeH+/fssX76cFi1aYGBggKurK+fPn6dz586cOXOG2NhYjh49ypAhQ1RCTGagpqbGmDFjpP/GVlZWzJw5k5SUlB9+f2RkpFQ0Gxoa0r59ey5dukTv3r0JDg4mOjqaPXv20LVr198KqoXtzdGQ8bW3hpqIhe3NZbpmVomLi6NIkSJoamoqNA5Z0L59+zxTV/nx40d0dXV/a7mV3xAylN+RcU0jL0EJoKmpybJly2jSpAl9+vShbt26HDp0iNq1a8ttz7yAso5d/BXR0dFUrFgxU99rYWFBSEgIy5Ytw93dnaNHj/Lnn39iZWUl5ygVS0JCgjQLefLkSSIjI9HW1qZZs2YsXbqU1q1bU7lyZZll8itXrsx+X3/sVwUjlkhktu5s73tYVTT8oU9tYmIiQUFBUlufyMhIChYsSPPmzVm1ahWtW7emQoUKMolDGahWrRoXL15k8eLFuLu7c/z4cXbt2iWtqfP19cXHx4ewsDA0NDSkNzaOjo7ZzlqV0dfB3cWUqV5hMnsdc11Mf+o7nFuoggdlVsj4G+jZsyeOjo7Mnz+fadOmqdxNXXx8vErdluUWgqD8DnlnKL+nbdu23Lx5k06dOtGoUSM8PDwYNGiQyr2xcgtVfLD+rIbyZ2hqajJ9+nTatm1L//79adKkCWPHjmX+/PkKmyMsazKykBkC8vz586SkpFCxYkWcnZ1p3bo1zZo1k+vrdfN9COoaiGR4PSpOlzD9SBieA75d8YaHh0sFZHBwMMnJyVSsWBEXFxfatGmDjY0NBQsWlNn+yoaGhgYzZ87ExsaGHj16UKtWLQoWLEhiYiKGhoa0adOGWbNmYW9vL7M6tK71TYhJSJZJ5nmSfdV/TERTFKr43PsdGXWVbm5uzJgxgxs3brBjx44f2ncpK8KUnB8jCMrvyE1BCVChQgUuXrzIuHHjGDJkCOfPn2fjxo25tr8qERsbq1IP1vT0dN6/f5+tOd6mpqZcunSJVatWMWvWLLy9vdm2bRs2NjZyiFT+JCQkEBAQIBWRUVFRFChQgGbNmrFs2TJpFjI3CH/3mfNPYmS+blq6hPNPYug3Zhrnjx8kIiJCWu+5ZMkS2rRpk2uvUdE8ffpUmoUMDg4mNTUVQ0NDYmNjMTMz4+DBg1SrVk0ue4+0rYxhYW3meN9D/Heda2ZRVxOhoSZiroupUohJyJuCEv6/rrJOnTr06tVLWlepKu8RQVD+GKEA4DtyW1DCt47fDRs2sGfPHo4cOUKDBg148OBBru2vKqjalffHjx8Ri8XZEpTwzR1g4sSJhIaGUrJkSZo1a8bIkSNVokNSIpFw7949aZ2gvr4+7dq1IyAggLZt23LixAni4uL+MQIxt9gTEiU3ixlJehpBL8TY29vj4+MjrfccM2aMynxQZgexWMyFCxeYMmUKpqamVKxYkUmTJqGurs7KlSt59uwZ79+/58KFC3z58oW6deuybt06ufnydq1vgv84G6wqfHte/O73nfF1qwoG+I+zURoxCXlXUGbQrl07rl69ilgsVqm6SkFQ/hhBUH6HIgRlBt27d+fatWsA1K9fn7179+Z6DMqMqj1YM6bk5NRgukqVKgQHB/O///2P7du3Y25uTkBAgCxClCmfP3+WNpKULVsWMzMzZs2ahba2NitWrCA8PJzw8HA8PDxo3bq1wq57gx5Fy81iRqSmTlmrNqxfvx4nJ6c8fdPw8eNHDhw4QM+ePSlRogTW1tbs2LEDS0tLvLy8iImJ4dSpU4wcOZJy5coBYGVlRWhoKH379mXkyJE4ODjw4sULucRXRl8HzwGWnBnblF6WZSlegP94IIqAsgY69LIsi/+4pngOsFR4zeS/UbXnXnaoXr06V69exdraWmX8KgVB+WOEK+/vyBCUiqpXy3hjDRs2jB49enD+/HlWrVpFgQIFFBKPMhEbG6tSGcqMKTnZzVB+j7q6OqNHj8bR0ZGBAwfSsmVLBg8ezNKlSxX2UMvIQmZcY1+4cIHU1FQqV65M+/btad26tdLVCSYki4mSsxl5VGwSiclihU1WkSfh4eH4+Pjg6+vL+fPnEYvFWFhYMHz4cJycnKhfv/5vu14LFSrEunXrpHXC5ubmeHh40KtXL7nUj1cuUQQ3F1NMYkIYOHQEN8NfIhGpoaWhRjmDQkr/e8oPghK+WXsdO3ZMZeoqP378iJmZmaLDUDqU+92UyyQmJqKtra1Qa5pChQqxc+dOrK2tGTVqFFevXuXgwYN5qgs0O6jag1WWgjKDihUrEhAQwObNm5k0aRInTpxgy5YttGrVSmZ7/IpPnz79oxby5cuX/+hWbtWqVaa72hVBZGyinKc+f5uo8zw2EVNj1c9epKamcvHiRamIfPz4Mdra2rRo0QIPDw+cnJwoU6ZMtta2t7fn7t27jB49mj59+nDkyBE2bdok0/fL97x58wZ93ULUKqs6h1JQvedeTvi+rvJ7v0plLBcRurx/jHDl/R2JiYlKcU0lEokYNGgQly9fJj4+njp16nDs2DFFh6Uwvnz5wtevX1XqwRodHY2mpqbMHzpqamoMHTqUu3fvUr16dVq3bk2/fv348OGDTPeB/5/csmTJEmxtbaWeiefOnaNjx474+fkRFxeHr68vI0aMUGoxCZAilk/NnqL2kQdxcXHs2bOHbt26YWRkhK2tLfv27cPGxoZjx44RGxvL8ePHGTZsWLbFZAZFixZl165deHl5cfHiRUxNTfHy8pLRK/knb968wdjYWC5ry4vU1FQ+ffqkUs89WdCuXTtCQkKkdZUnTpxQdEj/Qbjy/jGCoPwOZRGUGdSuXZsbN27QvHlz2rVrx8SJE0lNTVV0WLmOKo9dlJcNVNmyZfHz82Pbtm0cOXIEU1NTvL29c7xufHw8hw8fZuDAgZQpUwYLCwvmzp1L4cKF+d///kdERAQPHz5k1apV2Nvbq1Q5hpZG7jzucmsfWZBh47Rs2TKaNm1K8eLF6dmzJ+Hh4YwZM4br16/z8uVLNm/ejIuLi1yej+3bt+fu3btYW1vToUMHevXqJfOBD2/evKFUqVIyXVPeZPwbqNJzT1Z8X1fp5OTEggULlKauUiKR8OnTJ0FQ/gDVefLlAsomKOFbbcnhw4dZsWIF//vf/7C1teXVq1eKDitXyRg/pkon9cxMyckpIpGI/v37c+/ePerUqUPbtm3p0aMHMTGZt8WRSCSEhob+Y350x44duXjxIp07d+b06dPExsbi4+PD8OHDVbb0Ii0tjTeP74CcP5REQDkD5XqG/JuUlBT8/f0ZO3YslStXpkaNGsyZM4dixYqxceNGXr16xfXr13Fzc6Nu3bq5Mg3EyMiIw4cPs2vXLnx8fDAzM+P06dMyW18VBaWqz/HOKRl1lbNmzWLmzJl07NiRz58/KzosEhISSE9PFwTlDxAE5Xcoo6CEb8Jh/PjxBAcH8/z5c2rVqsWZM2cUHVauoUqCMjFZzL3X8Tz7JEG3bA0Sk8Vy3/OPP/7Ax8eHXbt2cfLkSUxNTTl06NBPvz8+Pp5Dhw4xYMAASpcuTa1atZg3bx56enp4eHjw7Nmzf4xAVKUs5PfEx8fz119/0bt3b0qUKIGdbVPSP0fLdU8TAx2lbPR4//49u3btolOnThgaGmJnZ8fhw4exs7Pj+PHjxMbGcuzYMQYNGqSwq2GRSESvXr0ICwujRo0aODg4MHz4cJlYZamioFSl5568UFNTw93dnSNHjnDmzBkaNmxIeHi4QmOKj48HEATlD1C+J58CSUpKUkpBmYGVlRW3bt2iZ8+eODg4MGfOHGbOnKlS862zg7JfeYe/+8yekCiCHkUTFZf0rfGjrAsAZm5+mOjrYFvViB6WJlQuIZ+uxYwP45YtWzJ8+HA6depEx44dWbduHcWLFyc0NFTaTHPp0iXS0tKoXr06Xbt2pXXr1lhbW6OtrS2X2HKTiIgIfHx88PHx4dy5c4jFYszNzRkyZAhOTk6cjC7Mnqsv5GIdpK4mwraKfLPSmSWjCz+joeby5ctIJBIaNGjA5MmTcXJywsLCQiknc5UpUwY/Pz82bNjApEmTOH36NDt27KBJkybZWk8ikQiCUsXJqKts166d1FavTZs2CokloxRBaMr5L4Kg/A5lzVB+T/HixTlx4gQLFizAzc2NixcvsmfPHooXL67o0ORGXFwcIpFI6U6EL+KSmH4kjPNPYlBXE/1QpEiAyLgkPEMi2XH5OdaVDFnY3lxufnelSpXCy8uL7du3M3bsWExMTChYsCAfP36kUKFCtGjRgrVr19K6dWvKli0rlxhyE7FYzOXLl6Ui8uHDh2hpaWFra8vq1atxcnL6x+s0fPeZXVei5BJLWrqEng0VZ4qdnJzM2bNn8fX1xdfXl+fPn1OoUCHs7e3ZunUrbdq0oWTJkgqLLyuIRCKGDx+Ovb09ffr0oWnTpkycOJG5c+dmOWP+8eNHkpOTVVZQFitWTMGRKAcZdZW9evXCycmJefPmMW3atFwpyfgeIUP5cwRB+R2JiYno6uoqOozfoq6uzuzZs2ncuDHdu3endu3aHDhwgMaNGys6NLkQGxtL0aJFlSoTu/9alHS8G/DbjFfG1y89jaXlqmDcXUzpKsOJHBKJhNu3b0uzkJcvXyYtLQ1dXV0+fvxIo0aN2Lt3r9RkWpX5+PEjp06dwtfXl5MnTxIXF4eRkRFOTk4sXLgQOzs7Chcu/MOfrVyiCNaVDLn0NFa2Wcr0NOqULkwlo9z1zXv37h3Hjx/H19eX06dPk5iYiImJCc7Ozjg7O2NjY6OyJQsAlSpV4ty5c6xYsYJZs2Zx4sQJdu3aRZ06dTK9xps3bwBUUlDq6Oio9O9P1ujp6XH06FHmzp3LzJkzuXHjBjt37sxVv0pBUP4coYbyO1QhQ/k9LVq04NatW1SoUAEbGxtWrFihNJ1wskTZxi6uDQpnqlcYyeL0LIuStHQJyeJ0pnqFsTYoZ7VAHz584K+//qJfv34YGxtTp04dFi1ahIGBAevWrSMyMpL4+Hi8vLx4+vQptWvXZseOHSr5NxIeHs7KlStp3rw5xYsXp1u3bty9e5fhw4dz5coV3rx5w7Zt22jfvv1PxWQGC9uboyHr8YuSNM4s7M+2bdvk+u+bcXCYP38+lpaWlCxZkoEDB/Lu3TtmzJhBWFgYz58/Z+3atTg4OOQJMaKurs7kyZO5fv06mpqaWFpaMm/ePMTizNUnq7KgFK67/4uamhpubm4cPXoUf39/LC0tefz4ca7tLwjKnyMIyu9QNUEJYGxsTGBgIBMmTGDixIm4urrK3HJD0SjTg3X/tSiWn5bNw2v56cccuJb569f09HRu3rzJggULaNKkCYaGhnTp0oXr16/Tq1cvAgMDiY2NlY5ANDH5lgFt37499+7dw8nJiX79+uHo6Ci3kXeyQiwWExwczMSJE6latSpVqlRh+vTpFChQAA8PD6Kiorh9+zbz5s3D0tIyS9deZfR1cHcxlWm87i5mdHFsycCBA+nUqZP0ulIWfPnyRer9aGJiQu3atVm6dCkmJibs3LmTd+/ecfHiRaZNm4aZmZlS1kXKAnNzc0JCQpg6dSru7u5YWVnx4MGD3/6cICjzJm3btuXq1aukp6fToEEDjh8/niv7xsfHo66urnJaITcQBOV3JCYmKmzsYk7Q0NBgyZIlHDt2jLNnz1K3bl1u3ryp6LBkRmxsrFI8WF/EJTHH+55M15ztfY8XvxgHGBcXx/79++nTpw/GxsbUrVuXJUuWYGRkxMaNG4mKiiIsLIylS5dia2uLlpbWD9cxMDDA09MTHx8fQkNDMTU1ZcuWLUqVrfzw4QN79+6le/fuFC9enGbNmrFnzx6aNm3K0aNHiY2N5cSJEzIx1e5a34SJ9lVkEvck+6r0aVKZrVu3cujQIQIDA7GwsODs2bPZXvP169ds2bIFFxcXDAwMcHJy4vTp03To0IEzZ84QExPDwYMH6d27d56un/43WlpazJs3j0uXLvHp0yfq1KnDqlWrSE//uZn869ev0dXVVblnuyAof0+1atUICQmhadOmODs7M3/+/F/+LciC+Ph4dHV18+zBLScIgvI7VDFD+T0uLi7cvHmTYsWKYWVlxaZNm5RKMGQXZbnynn4kTFozKSvE6RKmHwmT/nd6ejrXr19n3rx5WFlZSa93b926RZ8+fQgKCiImJgYvLy8GDRqUZWHl5OTEvXv36NSpE4MHD8bOzo7nz5/L9DVlhUePHrF8+XKaNWtG8eLF6dGjBw8fPmT06NFcvXqVV69esWXLFtq2bSvz9+ZI28osdjVHW0MN9SxegauridDWUGOJqzkjbCtJ/3+HDh0IDQ2lUqVKNG/enGnTpmVqGEF6ejo3btzAzc2NevXq8ccffzB06FA+fvyIu7s79+/f58mTJ6xevZqWLVv+9OCQX2jQoAG3bt1iyJAhjB8/nubNm/Ps2bMffq8qdniDICgzS0Zd5Zw5c5g1a5bc/So/fvwodHj/BEFQfoeqC0qA8uXLc/HiRQYMGMDQoUPp2bOnTHzcFIkyPFjD333m/JMYmdvNpKVLOP8khv9tP0Dv3r0pVaoU9evXZ9myZZQqVYpNmzbx4sUL6QjEZs2a5VhMFC1alG3btuHn50d4eDhmZmasW7dO7id7+DZOLigoiPHjx1OlShWqVavGrFmzKFy4MOvWrePFixfcvHkTd3d36tevL/cOzq71TfAfZ4NVhW8Hlt8Jy4yvW1UwwH+cDV1+0FhVpkwZ/P39WbhwIcuXL8fKyuqH3nmJiYl4e3szePBgSpcuTb169Vi9ejWVK1dm9+7dvH//nnPnzjFp0iSqV68uZET+RcGCBVm9ejWBgYE8f/6cmjVr/jDrLgjKvI+amhpz5szh2LFjcq+rFMYu/hyhy/s78oKgBNDW1mbdunU0adKEQYMGcevWLQ4dOkSNGjUUHVq2UIYr7z0hUT+1BsopkvQ03PcGUiY6lH79+tG6dWusrKzQ1NSU+V7fY29vT1hYGFOmTGHkyJH89ddfbNu2jUqVKv3+h7NAbGwsJ0+exNfXl1OnThEfH4+xsTFOTk6sWLGCFi1aKPQ6soy+Dp4DLP/fT/RxNFGxf/uJ/o2Ib6bltlWM6NnQ5Lfd3Orq6kydOpUWLVpInRg8PDxo2bKltCs7MDCQr1+/UqVKFbp164azszONGzeW++89r2Fra8udO3cYP348gwcP5ujRo2zdulUqIt+8eUPp0qUVHGXWEQRl1nFxceHq1atSv8o9e/bg5OQk0z0EQflzRJK8cCcqA1JSUtDW1mbHjh306dNH0eHIjIcPH9KxY0eePXvGpk2b6Nmzp6JDyhISiYSCBQuybNkyRo0apbA4bJYFEfmLWsecUlpPiwtT7eS2/u8IDAxk4MCBvH37lgULFjB69Ohs2zRJJBIePnwoNdW+ePEi6enp1K1bF2dnZ5ycnKhTp45SZ9wSk8U8eh1Ho8bWLJjnzrCeHbM1ASc9PZ3g4GDGjRtHaGgo8C2bklHz5eTkRJUqsqnlFABfX18GDRpEcnIy69evp2vXrlSpUgUXFxeWL1+u6PCyhL6+PlOnTmXy5MmKDkXliI+Pp3fv3vj4+ODu7s6MGTNkdtvh5OSEuro6x44dk8l6eQnhyvtvkpK+iYW8kKH8noyi5Q4dOtCrVy+GDBnC169fFR1Wpvny5QvJyckKPaknJIuJkqOYBHgVn5IrYxp/RvPmzQkLC2PQoEFMmDABa2trHj58mOmfT0lJISAggLFjx1KpUiVq1KiBm5sbRYsW/cd86Dlz5lC3bl2lFpMAhbQ1qFXWkJQ3jylGYpbEZEJCAkeOHKF///6UKlWK5s2bExUVRZMmTShUqBClSpXCzc1Neu0vIDucnJy4e/cudnZ2dOvWjS5duvD69WuVu/JOS0vj48ePQoYym+jp6XHkyBHmzJnD7Nmz6dChg8zqKoUM5c8RBOXfJCYmAnlPUMK317Rz5062bNnCzp07sbKyIiIiQtFhZQplGLsYGZuIvNP4EuB5bKKcd/k1hQoV4n//+x/nzp0jJiaGWrVqsWTJkp/6/cXExODp6Unnzp0pXrw4LVu25NChQ9jb2+Pr60tsbCze3t4KnQ+dE9TU1NDS0srUASzD+7FVq1YYGBjg6urKlStX6Nu3L+fOnSM6Oprz58/z4MEDKlWqhK2tLTNmzMhUw45A1jAwMODAgQPs27ePM2fOkJiYyNu3bxUdVpb4+PEjEolEEJQ54Pu6ysDAQJnVVQqC8ucIgvJv8rKghG+jzAYOHMiVK1f49OkTdevW5ejRo4oO67cowzzbFLH8m1Vyc5/f0aRJE27fvs2oUaOYPn06VlZW3L17VzofevHixTRp0oQSJUrQu3dvnj9/zsSJE7l58yYvXrxgw4YNODo6UrBgQUW/lBxToECBHwrKtLQ0Ll26xLRp0zA3N6d8+fKMHz+etLQ0li5dypMnT7h//z5LlizB2toaDY1vGc4yZcoQEBDA/PnzWbp0KU2aNOHJkye5/bLyBV27dsXb2xuA5cuXM2DAAD59+qTgqDKHMjz38goZdZUSiYT69evj6+ubo/WELu+fIwjKv8nrgjKDWrVqcePGDVq0aEH79u2ZOHGiUmdJlOHBqqWRO2+T3NonM+jo6LBs2TLOnj3Lu3fvsLCwQF9fHzMzM+bNm4ehoSGbN2/m9evXXL16lVmzZlG7dm2lv8rOKgULFpQKyvj4eA4ePEifPn0oWbIkjRs3ZuvWrdStW5eDBw8SExPDmTNnGDNmDBUrVvzpmurq6kyfPp2LFy8SGxur0hOMlJ0M54K5c+fy119/UbNmzRz5g+YWyvDcy0tUrVqVkJAQmjVrhrOzM3Pnzs2yq0Visph7r+NJ0DYkpZCRQkuUlBWhy/tv8oughG/1JYcOHeJ///sfkyZN4sqVK+zfv18pOyGV4cq7nEEhRCDXa2/R3/soA+/fv+fEiRP4+Pjg5+dHQkICRYoUIT4+ngoVKrB3714sLS0VHWauoKGhQXBwMEFBQQQHByMWizE3N2fQoEE4OzvToEGDbDcvZXgpjh49mn79+nHy5Ek2btxIsWLFZPwq8i8ZU3JGjx5Nz5496devH7a2towZM4ZFixYpbRZdEJSyR1dXlyNHjjB//nzmzJnDrVu32LlzJ7q6uj/9Ganzw6NoouK+OT/odpzHgXj4y80PE30dbKsa0cPShMolcm+euLKiPCkRBZMhKFVtmkJ2EYlEjB07lnPnzhEZGUnt2rU5ffq0osP6D3FxcYhEIoXUrDx//pyVK1di39yGlA9v5LqXiYFOtrqIZYFEIiEsLIyFCxdiZWVFiRIl6NevHy9fvmTq1Kncvn2b+Ph4rl27RqFChWjSpAmzZ88mOTk523tmnPZvRX3g3ut4pTnti8Vizp07x+TJk6levTqvXr0iICAADQ0NVq9ezbNnz7hz5w4LFy6kUaNG2RaTGRQpUoTt27dz4MAB/Pz8sLCw4Ny5czJ6NQJv3ryhYMGC6OrqUr58eQIDA1m5ciUbN26kdu3aXL16VdEh/hBBUMoHNTU1Zs+ejbe3t7Su8tGjR//5vhdxSfTaFoLd6nN4hkQSGZf0n4SCBIiMS8IzJBK71efotS3kl1PP8gNChvJv8lOG8nsaNWrErVu36NmzJ61atWLWrFnMnj07xx+UsiIuLo5ixYrJ3eA6gwcPHuDl5YWXlxc3b95EW1sbBwcHSlcoyvWPkCaHNKW6mgjbKkayX/gXJCcnc/bsWam1T2RkJIUKFcLe3p5t27bRpk0bSpQo8Y+fqVu3LtevX2fhwoUsWLAALy8vtm/fTv369TO1549O+xmIQGGn/Q8fPuDn54ePjw8nT57kw4cPlChRAkdHR75+/Yq9vT2bNm2SawydO3emYcOG9OzZE1tbW6ZNm8acOXMET8ockmFqnlGKoaamxrhx42jVqhW9e/fGysqKadOmMWvWLKWaPhQXF4e2trbSZlBVHWdnZ6lfZYMGDf7hV7n/WhRzvO9Jp6L9zns44+uXnsbSclUw7i6mdP3BwIP8gJCh/Jv8KigBDA0NOXHiBHPnzmX+/Pm0atWK6OhoRYcFfLvylud1t0Qi4datW8ycOZMaNWpQo0YNFi9eTOXKlTlw4AAxMTEcO3aM+X0c5CIm4dsDqWdD+T+A3r17x/bt23F1dcXAwIBWrVrh4+ODk5MTp06dIjY2Fi8vL/r16/cfMZmBlpYWbm5uXL9+HS0tLRo2bMjUqVN/2QmtjKf9R48esWLFCunIx27dunH//n1GjhxJSEgIr1+/Ztu2bZQoUYK0tDS5xfE9JiYmBAUFMXfuXBYvXoy1tbXKuDEoKz+zDKpevTqXLl1izpw5LF68GEtLS8LCwn6wgmLIMDXPazXJykRGXaWtra20rnJNwGOmeoWRLE7P8hCLtHQJyeJ0pnqFsTbov5Ox8gOCoPybxMRE1NTU0NbWVnQoCkFNTY2ZM2dy5swZ7ty5Q+3atblw4YKiw5LLtIj09HQuXbrExIkTqVixInXq1GH9+vVYWlri7e3N+/fv2b9/P507d6Zw4cIAVC5RBOtKhlme+fw7JOlplNFIoJy+7DMREomE0NBQ5s+fT8OGDSlVqhQDBgzg7du3zJgxgzt37kjtbhwcHLL0t29hYUFISAjz5s1j1apV1KpVi0uXLv3n+/Zfi6LlqmAuPf1WC5vV0/7+a1FZeMU/50cjH2fOnEnhwoVZu3YtL1684NatW8ydO5cGDRpIM+I/6/KWF+rq6syYMYOLFy/y/v17atWqxc6dO4WGnWzyq7GLmpqazJo1i5CQEFJTU6lXrx5LlizJtQPErxCm5OQOurq6eHl54e7uzrLDF1nhLxshuPz0Yw7I6NmlSgiC8m8yxi7m9xNh8+bNuXXrFhUrVqRZs2YsW7ZMoR9mshq7KBaLCQgIYMSIEZQuXZrGjRuze/duHBwcOHPmjDR75+zsTIECBX64xsL25mjIWFCqiyBk3TgaNGjAzZs3c7ze169fOXnyJMOHD6ds2bJSL8nSpUuzfft23r59+w+7m5z8vWtqajJ9+nRu3ryJnp4eTZo0Yfz48dIhAWuDwhV62o+NjWX37t107dqV4sWL07x5c/bv30+zZs3w9vYmNjYWX19fhg4d+tOGtO+7vHMTS0tLbt++TYcOHejbty/dunXj48ePuR6HqpOZOd516tTh+vXrjBkzhmnTptG0aVOFWzkJgjL3UFNTo9/IiZR0GiXTz7rZ3vfyXU2lICj/Jq/M8ZYFxsbGBAYGMnHiRCZPnky7du348OGDQmKJi4vL9pV3cnIyx48fp3///pQoUUI6R7lr165cuHCBV69esWHDBlq2bJmpWrUy+jq4u5hmK5afsahDLS6d9iY9PZ0GDRowefJkqSDLLG/fvmXbtm20a9cOAwMD2rRpw8mTJ2nXrh2nT58mJiaGQ4cO0adPH4yMZF+raWpqyqVLl1i6dCkbNmygZs2auO/2Z/npnJsIQ+ZP+xKJ5B/ej0ZGRvTq1YuIiAjGjRvH9evXefXqFZs3b8bZ2TlTDXi5naH8niJFirBjxw7279/PqVOnsLCw4Pz58wqJRVV58+ZNpkz1CxQowNKlSzl37hxv377FwsKC9evXK+wwLQjK3GX6kTDSUZNpQkmcLmH6EeUpo8gNBEH5N0lJSYKg/A4NDQ0WL16Mj48P58+fp27duty4cSPX48jqgzUhIYFDhw7RrVs3ihcvjpOTE5cuXWLo0KFcv36dZ8+esXLlSho3bpytxqOu9U2YaC+bcXmT7KvSpb4J9erV49q1a8yfPx8PDw/Mzc0JCAj46c9l1H3OmzePBg0aUKpUKQYPHkxMTAyzZ8/m7t27PH36FA8PD+zs7HKljENdXZ2JEycSGhqKYdmqbLv9CXLhtJ+SkvIP70dTU1Pc3d3R19dn06ZNvHr1imvXrmV75KMiBWUGXbp0ITQ0FBMTE5o1a8bs2bN/Or1I4P/5+vUrHz58yNLYxSZNmhAaGkrv3r0ZMWIEDg4OvHjxQo5R/picHKQFskb4u8+cfxKT5VuU35GWLuH8kxieRMtm5KMqIAjKvxEylD/GycmJmzdvYmBggJWVFRs2bMjVU3tmrrw/fPiAp6cn7dq1o3jx4nTq1ImHDx8yefJk7t27x8OHD1mwYIHMZkiPtK3MYldztDXUslxTqa4mQltDjSWu5oywrST9/5qamkydOpU7d+5QpkwZWrZsSf/+/aX2IV++fOH48eMMHTqUMmXKUKdOHZYtW0a5cuXYtWsX796948KFC0yZMgVTU1OFlW5UqVKFSt1noa6pBXI67UdHR7Nz5046duyIoaEh9vb2HDlyhFatWnH8+HFiY2M5duwYAwcOzPHIxwIFCvDlyxdZvIQcUbZsWc6ePYu7uzsLFy7E2tqap0+fKjospSZj3GJW53gXLlyYDRs2cOrUKe7fv4+5uTm7du3K1eeekKHMPfaERMm8Nj4DdTURu6/kn1pKwTbobwRB+XPKlSvHhQsXmDBhAsOHD+fChQts2rRJ2rAiLyQSyU9P6tHR0Rw9ehQvLy8CAgIQi8U0atSIefPm4erqSoUKFeQaW9f6JjSuaMj0I2GcfxKDuprolyfcjK9bVTBgYXtzyuj/+Lq1SpUqBAYG8ueffzJhwgQOHTpElSpVuHfvHl+/fqVChQp07NgRZ2dnrK2tlcrqBL6d9i88ieWbEZDsyDjt12/pzI3A48A3Y/ApU6bg5OREzZo15SKilSFDmYG6ujozZ86kZcuWdO/enVq1arFu3Tp69uyZ72u/f0SGqXlWBWUGDg4OhIWFMXr0aPr06cORI0fYtGmTXMpG/o2sascFfk/Qo2iZZyczSEuXEPQ4GjdkWyqlrAiC8m8EQflrtLW1Wbt2LdbW1gwcOJBbt25x6NAhatSoIbc9k5KSSElJkT5YX7x4IfWIzOhAb9asGatXr6Zdu3b88ccfcovlR5TR18FzgOX/+ys+jiYq9gf+igY62FYxomdDEyoZ/dxfUSKRcPPmTXx9ffHx8ZHOHb5x4wbVq1dn3bp1NGvWTKnFQ8ZpXx4PaEl6GlSyZlsP1x/6ZMoDZRKUGTRs2JDbt28zcuRIevfuzcmTJ9mwYYNCzP+VmZwKSoBixYrh6elJ+/btGTJkCGZmZmzatIn27dvLKsz/kJ6ezocPHwRBmQskJIuJknPjTFRsEonJYoUNrshN8v4rzCSJiYn5ZkpOTujSpQu1atWiY8eO1K9fn40bN9KrVy+57JUxdjEgIIDVq1dz7do1tLS0sLOzY8uWLbi4uGBoaCiXvbNC5RJFcHMxxQ1TEpPFPI9NJEWcjpaGGuUMCv3yQZKUlERAQAA+Pj4cP36c169fo6enR6tWraQGzOfPn2fEiBG0bduWxYsXM3To0Fwzes8q8jzti9TU0alUn379bOWy/o9QRkEJ3+xOdu3aRevWrRk6dCgWFhbs2bOHxo0bKzo0peHNmzdoamrKpBbR1dWVxo0bM2TIEFxdXenVqxceHh4ULVo054H+i0+fPpGeni4IylwgMjZRriN14ZvH7vPYREyN8/6BTzk/lRSAkKHMPBmGsJ06daJ3794MHjxYZh+6EomEO3fu4ObmRosWLQDYs2cPJiYm7N27l+joaHx9fenfv79SiMl/U0hbA1NjPWqbFMPUWO+HYvLly5ds2rQJJycnDAwMcHFxISgoiC5duhAYGCj1wezRowcGBga0a9eO+/fv06NHD0aMGIG1tTX3799XwKv7Nbl52s8tFGUblFm6detGaGgopUuXpmnTpsyZM0do2PmbN2/eULJkSZll9EuUKMGRI0fYsWMHx44dw9zcnDNnzshk7e8Rxi7mHini9Dy1j6IRBOXfCIIya+jo6LB9+3a2bt2Kp6cnjRo1yvZUD4lEwtWrV5kyZQpVqlTBwsKC1atXU65cOQCuX78u7dxWxWu99PR0aadxnTp1KFOmDCNGjCAhIYF58+bx8OFDwsPDWblyJba2tj+0MNLT02PDhg2cO3eO2NhYateujbu7e47macua3Dzt5xbKmqH8nnLlynH27FnmzJnDggULaNq0Kc+ePVN0WAonMx6UWUUkEtGnTx/CwsKoWrUq9vb2DB8+XDppTRYIgjL30NLIHQmUW/somvzxKjOBICizjkgkYsCAAVy5coWEhATq1KmDl5dXpn42LS2N4OBgRo8ejYmJCZaWlmzfvh1bW1tOnjxJdHQ0gwcPBvip6bQyk5iYKO00/uOPP2jQoAEeHh5Uq1ZNmmk9e/YsEydOpGrVqple19ramtu3bzN58mTmz59PnTp1uHz5shxfSebJi6d9VRCU8M3ma/bs2Zw/f17qo7h7925Fh6VQ5CEoMzAxMeH06dOsXbuWHTt2YGFhwcWLF2WytiAoc48yRX88xEKWiIByBvlDWwiC8m8EQZl9LCwsuH79OnZ2dnTo0IHx48eTmpr6n+9LSUnh1KlTDB48mFKlStGsWTO8vLxo3749Z8+e5c2bN2zevJlWrVqhpaVFXFwcampq6OrqKuBVZZ0XL16wYcMG2rRpI72qvnDhAj169ODs2bNER0ezd+9eunXrlqMPiwIFCjBv3jxu3rxJ4cKFady4MaNGjeLzZ8X6neXF036GbZCqjD5s1KgRt2/fpm3btvTq1YsePXoQHx+v6LAUws/meMsKNTU1RowYwe3btylevDhNmzZlypQp2b41SEwWc+91PLdffETTqDwFCqvebYwqkJCQwJEjR+jXrx+VypUh9cNrue5nYqCTLxpyQGjKkSIIypyhp6fHwYMH8fDwYOLEiVy5coUDBw5gYGCAn58fXl5e+Pj4EB8fT8WKFenXrx8dOnSgXr16P20wiYuLo1ixYkrbgJJxlZ3RlR0aGoq6ujpNmzZl4cKFODs7U7lyZbntb25uzqVLl1i7di0zZszg6NGjbNiwAScnJ7nt+SvKGRRCBHK99s7t036BAgWQSCSkpqYqnUXTz9DV1cXT05PWrVszbNgwLl26xO7du/Ndw448M5TfU6VKFS5cuMCyZcuYPXs2J06cYNeuXdSuXfu3Pyt1iHgUTVRchkNEIYz7r6Hh8ouY6OtgW9WIHpYmVC7xc4cIgV/z8uVLfH198fb2JjAwkOTkZGrUqMGAAQOIK18e/8gUuTQTqquJsK0if5spZUE5P6kVgDApJ+eIRCLGjBnDqVOnePz4MZUqVUJfXx9XV1dCQ0MZO3Ysd+7cITw8nCVLltCgQYMfisWMk/rjuFSKVTDP1SaM35Fxuh0wYADGxsY0bNiQdevWYWZmxv79+4mJiSEwMJDx48fLVUxmoK6uzpgxY7h79y5mZmY4OzvTrVs3oqOj5b73vymkrYHJT/w1ZUVun/Yz5rqrwrX3v+nevTu3b9/G2NiYpk2b4ubmlm8adsRiMe/fv88VQQnf3odTp07l+vXrqKur06BBA+bPn//Tf+8XcUn02haC3epzeIZEEhmX9J+DmASIjEvCMyQSu9Xn6LUtJN/Nhs4uGRZs7u7u1K1blzJlyjBy5Ei+fv3K4sWLefLkCffu3WPRokVMbGspVx/Kng1N5LK2MiJkKPmWaRIEZc6IiYnB29ubw4cP4+/vT0pKCnp6enz69Inhw4fj4eHxy1GHPzypa9SFFnUxc/NT6Ek9MjJSmoUMCgoiJSWFatWq0bt3b5ydnWnUqBEaGop9K5UrV44TJ06wb98+xowZQ/Xq1Vm5ciW9e/fOVd9K26pGeIZE5pnTfsGCBYFvglJVSi++p3z58gQHB7NgwQLmzp3LmTNn2L17N+XLl1d0aHLl3bt3SCSSXBOUGdSsWZOrV6/i7u7OnDlz8Pb2ZteuXVSrVk36PfuvRTHH+x7iv98jv3uvZHz90tNYWq4Kxt3FlK71849IySxfv34lKCgIHx8ffHx8ePnyJXp6erRu3ZqJEyfSqlUrihUr9p+fq1yiCNaVDLn0NFamzy11NRFWFQx+6T2c1xAylCAdrSYIyqzx6tUr1q1bR4sWLShZsiQDBw4kISGBZcuWERkZSVxcHPPmzWPjxo04ODj8MGumjCf1tLQ0Ll++zIwZM6hZsyblypVj7NixiMVilixZQnh4OA8ePGDp0qVYW1srXExmIBKJ6N69Ow8ePMDR0ZG+fftib2+fqyP6elia5KnTvipnKDPQ0NBgzpw5nD9/ntevX1OrVi327Nmj6LDkSoapeU5Hb2YHLS0tFixYwMWLF4mPj6d27dqsXr2a9PR01gaFM9UrjGRxepbfJ2npEpLF6Uz1CmNtULicolct3r9/z44dO+jQoQOGhoa0adOGU6dO0aFDBwICAnj//j379u2jW7duPxSTGSxsb46GjMcvaqiJWNjeXKZrKjsiiapUm8uR6OhoSpQowbFjx3BxcVF0OErN06dPpdNqLl++jIaGBi1atMDV1ZW2bdv+cHpJUFAQ3bp1Q01NjQMHDmBtbQ3886SelYerupoIDTWRTE/qnz9/5vTp0/j4+HDixAnev3+PgYEBbdq0wdnZGXt7e5WzLPLz82PIkCFER0czd+5cxo4dmyvit9e2ELmd9j0HWMpszcxw/vx5mjZtyqNHj6hSpUqu7i0P4uPjGTFiBHv27KFHjx6sW7dO5f6uM4OPjw8uLi5yb8z5HUlJSUybNg0PDw/qdhpFTEUHma29xNWcLvksUymRSHj48CHe3t74+Phw6dIlACwtLXFxccHFxYUaNWpk61Zm/7UopnqFySzW/Pj7EQQl8OzZMypUqIC/v7/UTFvgGxKJhAcPHuDl5cXhw4e5ffs2BQoUoFWrVri6uuLk5PTLk18Gb968oWvXrly8eJGFCxdSsG47Vvjn/JQ90b4KI22zV6v4/Plz6fXI2bNnSU1NxdTUFCcnJ5ydnWnYsOEvr+lVgYSEBGbPns3//vc/atWqxdatWzPVLJATXsQl0XJVMMkytPfR1lDDf5zNT2egy4tr167RoEEDbt++jYWFRa7uLU92797N8OHDMTAwYM+ePVhZWSk6JJmyefNmhg0bRkpKilK8hw8c92fy2c+grimzEhRFvSdyG7FYzIULF6Qi8smTJ+jo6GBnZ4eLiwuOjo4yG8O6Niic5acf53idSfZVGWFbSQYRqRbClTdITWmF0YvfkEgk3LhxgxkzZlC9enVMTU1ZsmQJ1apV4+DBg7x//54jR47Qq1evTIlJ+DZPNyAggEmTJjFvT4BMxCTA8tOPOXAtKlPfm5aWxsWLF5k2bRpmZmaUL1+eCRMmfFtn+XIiIiK4e/cuixcvpnHjxkrxQZRTChcuzMqVK7l8+TKpqanUr1+fqVOnSss85EEZfR3cXUxluuZcF1OFfHDmhSvvH9GzZ09CQ0MpVaoUTZs2xd3dPU817Lx58wYjIyOleQ/7vi2ChqaWTOuZxekSph+RXUZNmYiPj+fAgQP07NkTIyMjbG1t2b9/P82bN8fX15eYmBiOHj1K//79ZSYmAUbaVmaxqznaGmqoZ/EKXF1NhLaGGktczfOlmAShKQf4f0GZn2so09PTuXTpkvQ6OzIyEn19fdq2bcuKFSto0aKF9MM1u2hoaDB80iwOqQWSkiaR2cN1tvc9rCoa/lBwfPr0CT8/P3x9fTlx4gQxMTEYGhri6OiIm5sb9vb2KtlskVUaNGjAjRs3WLZsGXPnzuXQoUNs3ryZ5s2by2W/rvVNiElIltlpX1FXR3lVUMK3hp1z584xf/78fzTsZEyoUmVyyzIoM4S/+8z5JzEyXzctXcL5JzE8if6cJxo/nj17ho+PD97e3gQHByMWi6lVqxajRo3C2dmZOnXq5IqFXNf6JjSuaMj0I2GcfxKDuprol+U7GV+3qmDAwvbmeT5j/CsEQUn+FZSpqakEBwdz+PBhjh49ytu3bylVqhTt27fH1dUVGxsbmdfcTT8SRjpqiESyq7TIOKln1Nc9ffpUepV97tw5UlNTMTMzY9CgQTg7O9OgQQOlyVzkJpqamkyfPp0OHTowePBgWrRoQf/+/Vm+fHmmM81ZYaRtZQwLa+eoTnaui6lC65C+7/LOi2hoaODm5oadnR09evTAwsKCDRs20L17d0WHliOUSVDuCYn6rSjJLupqInZficJNxjcCuUGGj6+3tzfe3t7cvXsXTU1NmjdvzurVq3F2dsbERDHv/TL6OngOsJS6jxy79oS4VPV/JEFEfLMxs61iRM+GJnlC1OcUQVCSvwTl169fOXPmDF5eXnh7exMXF0e5cuXo0aMHrq6uNGzYUG6nQHmf1IdNcSPY5y8ePHiAlpYWtra2rFy5EicnpzyRdZEVVatWJSgoiG3btjFp0iSOHz/OmjVr6Nixo8wthlT9tJ+XM5Tf07hxY0JDQxk+fDg9evTg5MmTrFu3TmWz92/evKFmzZqKDgOAoEfRcnU+CHocjRuqISiTkpLw9/fH29sbX19f3r17h4GBAY6OjsyZM0fpbowqlyiCm4spXy7u4q8jx/A9G0KKOB0tDTXKGRTKNxNwMovwr0HeF5SfP3/m5MmTeHl5cfz4cRISEqhevTrDhw/H1dWVWrVq5YpXoTxP6pL0NHwexGPfsCHz58/Hzs6OIkWEE+PPUFNTY9CgQTg6OjJq1Cg6d+6Mi4sL69atk/ns9H+f9o/fek70F4lKnPbzi6CEb9Ou9uzZQ+vWrRk+fDgXL15kz549NGrUSNGhZZk3b97g4CC7jurskpAsJkrOZuRRsUkkJouVVty8efNGOqXG39+fr1+/UrVqVaXy8f0dERERVCpbBlPjvOeIIEuU+7eYSyQlfXvD56WmnA8fPuDt7Y2Xlxd+fn4kJydTp04dpk6diqurK9WrV8/1mOR5UhepqVPR2oU/J9nKZf28irGxMYcPH8bLy4uRI0dSo0YNlixZwpAhQ2Seqc447Zd6c4ERY8ZzM/wFaRKRUp/2MwSlPJuYlI2ePXtiZWVFjx49sLa2Zs6cOUyfPl1lykTS09Ol5TuKJjI2Ua6jSOGbT+/z2ESlETsSiYQ7d+5I6yGvXbuGmpoaTZo0Yf78+Tg7O6ucBVdERASWlrlrWaaKKN8TXAEkJiZSoEABlXlg/oy3b99y7NgxDh8+TFBQEGlpaVhZWbFw4ULat2+v0OkYuXJSj1Puk7oy4+rqSvPmzZkyZQrDhw9nz549bNmyRS4Hj5cvX1KquD41y+jLfG1Zo6Ghgbq6er7IUH5PhQoVOH/+PPPmzcPNzY3Tp0+ze/duypYtq+jQfktMTAxisVgpBGWKDK2zlGGfn5GcnExwcLBUREZFRVGkSBFatWrF6NGjad26NQYGBgqNMbtIJBKePHmi8nXFuYFgG8Q3Qamq192RkZGsXr0aa2trjI2NGTFiBOnp6Xh4ePDq1SsuXLjA+PHjFT5qLTdP6gLZo2jRomzatImzZ88SHR1NrVq1mDdvHikpKTLd5+XLlzK/VpcnBQoUyHeCEr6JaXd3d4KDg4mKisLCwoL9+/crOqzfkjElRxkEpZZG7nzE5tY+3xMbG4unpyedOnWiePHiODg4SA3lT58+TUxMDH/99Rc9e/ZUWTEJ36bxJCQkULFiRUWHovQIqRxUT1A+evRIau9z/fp1tLS0sLe3588//8TZ2Vkp37z55aSeF7CxseHOnTvMmzePuXPncuDAAbZs2SKzWroXL16olKAsWLBgvhSUGTRp0oTQ0FCGDRtGt27dOHnyJGvXrlXaGmVlEpSG2hK+HXXlV6MuAsoZ5M7n1+PHj6Vd2RcvXiQ9PZ369eszefJkXFxcMDc3z5V6/NwkIiICQBCUmUDIUKL8glIikRAaGsrs2bMxMzOjWrVqLFiwgPLly7Nv3z7ev3+Pj48Pffv2VUoxCXn7pJ4XKVCgAAsWLODGjRvo6OjQuHFjRo8ezefPn3O8tpChVD2KFi3K3r172blzJ15eXtSqVYuQkBBFh/VDMgRlyZIlc31viUTCo0ePWLlyJS1btqRMKSNSP7yR654mBjpyK/MRi8WcP3+eSZMmUbVqVapWrcqsWbPQ09Nj48aNvH79mqtXrzJz5kxq1qyZ58Qk/L+grFChgoIjUX6EDCXfBKWyNeSkp6dz9epVacPE06dPKVq0KC4uLixYsAB7e3upR54qUM6gECKQ67V3bp7U8ws1a9bk8uXLrFmzhhkzZnD06FE2bNiAo6NjttaTSCS8fPmSMmXKyDhS+SEIym+IRCJ69+5N48aN6dGjB40bN8bNzY1p06YpVf35mzdvMDAwQFtbO1f2+/r1K+fOneP48eMcP36ciIgItLW1ad68OStXriSiqBneDz7IzYfStoqRTNf8/Pkzfn5+eHt7c/z4ceLi4ihRogROTk4sW7aMli1bKt3npTyJiIjAyMhIaTPyykS+F5SJyWLepWiiUaIS917HK7TbNOM06OXlxZEjR3j16hVGRka0a9eODh060KxZM7S0tBQSW04ppK2Bib4OkXJszJHnST0/o66uztixY2nXrh1Dhw7FycmJbt26sXr1aoyMsvZh9vHjRxITE1UuQ5mfurx/R8WKFTl//jxz585lzpw50oYdRZlQ/5vcMDV/+fIlJ06c4Pjx4/j7+5OUlESZMmVwdHRk9erVNG/eXCq6wt995si9c3KJIy1dQs+GOf93j4qKkjbUnD17lpSUFMzNzRk6dCguLi7Ur18/V6bUKCMRERHCdXcmyZefvhl+eEGPoomKS0JSsjWUBMc1F7754enrYFvViB6WJlQuId9TSXJyMoGBgRw+fJhjx44RExNDmTJl6NixI66urnlmpjSAbVUjPEMiVeakLvBPypUrx8mTJ9mzZw9jx46levXqrFq1il69emX6quvly5cAKicohQzlP9HU1GTevHnY29vTs2dPatasyaZNm+jSpYuiQ5OLoExLS+PKlSvSLOSdO3dQV1fHysqK2bNn4+joiKmp6Q/fB5VLFMG6kiGXnsbK9NmnLgKriobZ8mxNT0/nxo0bUhEZGhqKhoYGzZo1Y/ny5Tg7OwvDIP5GEJSZJ18JyhdxSb+d2CEBIuOS8AyJZMfl51hXMpT5xI7ExET8/Pw4fPgwvr6+fPr0icqVKzNw4EBcXV2pV69enqxF6WFpwo7Lz+WytqxO6gK/RiQS0bNnTxwcHBg/fjx9+vRh9+7dbNq0KVNOAhmCUrjyzhtYW1sTGhrK0KFD6dq1KydPnmTNmjUKvR588+YNlSpVyvE6sbGxnDp1ihMnTnDq1Cni4uIwNDSkdevWTJ8+HXt7+0yPLF3Y3pyWq4JlJyglEsTiVJrrRmf6R758+UJAQIB0LO2bN28oVqwYbdq0Yfr06Tg4OKCnpxxelspEREQEdnZ2ig5DJcg3Oez916JouSqYS09jAX77xs74+qWnsbRcFcz+a1E52j8+Pp49e/bg6upK8eLF6dChA3fv3mXChAmEhYXx6NEjFi1aRP369fOkmIT/P6mrq8n29UnSxBROeEHB1E8yXVfg5xQvXhxPT09OnjzJo0ePMDMzY+XKlYjF4l/+3MuXL1FTU1NIw0R2EQTlrylatCj79u1jx44dHD58mNq1a3P16lWFxZPdDKVEIuH27dssXLiQxo0bY2RkRM+ePXn48CHDhw/n8uXLvH37ll27dtGlS5dMi0n4Ni3KXZbztkUiyr6/Qv/OLsyePZu0tLQfftu7d+/Ytm0b7dq1w8DAAGdnZwIDA+nWrZvUHmz37t107txZEJM/ICEhgXfv3snkgJIfyBcZyrVB4Sw//ThbP5uWLiEtXcJUrzBiEpIZaVs50z/7/v17jh07hpeXF/7+/qSmpmJpaYmbmxuurq758o9U5id1QFNDndhT66ixawrLli1j4MCB+bbeJ7dp1aoV9+7dY+bMmUycOJG9e/eydetWatWq9cPvf/HiBSVLlkRTUzN3A80B+d02KDOIRCL69OkjbdixsrLC3d2dqVOn5mrJjkQiyZKgTEhIICAggOPHj3PixAlevXpF4cKFsbOzY/PmzbRu3RpjY2OZxNa1vgkxCcnZ/iz6nkn2VRlm05olVYsyY8YMrl+/zu7duylWrBj37t3D29sbHx8faSe+lZUVbm5uuLi4ULVq1TybtJA1T58+BQTLoMwikkgk8vabVij7r0Ux1StMZustcTWnS/2fX62+fPmSI0eO4OXlxblz3wqxmzZtiqurK+3bt1ep2jF5IY/fiX2lIkycOJE///yTZs2asWXLlnwp2BVJSEgIAwcO5MGDB0yaNInZs2f/x4mgf//+3Lt3T2ktZ35E586diY+Px8/PT9GhqASpqam4u7uzcOFCrK2t2b17d66VOHz8+JFixYpx4MABOnfu/MPvefLkibQWMjg4mJSUFKpUqYKjoyOOjo5YW1vLtflx/7Uo5njfQ/x3siKzqKuJ0FATMdfF9B+fQSdOnKBr166IRCIKFy7M69evKVSoEA4ODri4uNCmTRuKFy8uj5eS5zly5Aiurq68e/cuyw2I+ZE8ncZ5EZfEHO97Ml1ztvc9XvyrUzkiIoJly5bRsGFDypQpw4QJEyhQoACbNm3izZs3BAUFMWrUKEFM/k3X+iZMtJfNLNdJ9lXpUt+EYsWKsW3bNs6cOcPz58+pWbMmK1as+O0VrIDssLS05MaNG7i7u7Ny5Upq1qxJUFDQP75H1SyDQLjyziqamprMnz+fs2fP8uzZM2rWrMnBgwdzZe8fmZqnpKTg7+/PuHHjqFq1KpUrV2by5MmIRCKWLVtGeHi41DuyRYsWcnfS6FrfBP9xNlhV+OYZ/LsSoIyvW1UwwH+cDV3qm/Dhwwf27t1L165d6d69O58/f+bLly9ER0czadIkYmJiOHz4MH369BHEZA6IiIigcOHCwr9hJsnTgnL6kTDEMu4oFqdLmHYkjLt37zJ37lxq1apFpUqVmDNnDsbGxuzevZvo6GhOnjzJwIEDhVPNTxhpW5nFruZoa6hluaZSXU2EtoYaS1zNGWH7zyxky5YtuXv3LkOGDGHSpElYWVkRFia7bKjAr9HS0mLGjBmEhoZSqlQpmjdvzqBBg/jw4QOgelNyQLANyi5NmzYlNDQUe3t7OnfuTP/+/UlISJDrnq9fvwZATU2NrVu34urqioGBAXZ2dhw8eJBmzZpx9OhRYmNj8fPzY/To0Qq5ySijr4PnAEvOjG1KL8uylDXQ+c8sHRFQ1kCHXpZl8R/XlDk2BhzauQlbW1uKFy9Ojx49ePLkCePGjePmzZt8/PiRHj16sGzZMiZPnkxqamquv668RkaHt1AikDny7JV3+LvP2K2Wj/cXwKstQ9FJ/YSTkxMdOnTAwcFBqaftKCuZ6bzPIOPrme28v3LlCgMGDODx48dMmzaNGTNm5JrZscA3a5ItW7YwefJkChYsyJo1a+jbty/u7u5MnDhR0eFlmtGjR3P27Fnu3Lmj6FBUEolEwo4dOxg1ahSlSpVi79691K9fX6Z7pKWlce3aNRYvXsyxY8eAb6KyUaNGtGnTBkdHR6Wf5JKYLOZ5bCIp4nS0NNQoU7QAYbeuS619Hjx4gLa2Ni1atMDZ2RknJ6f/HM4kEgkbN25kzJgxWFpa8tdffynFCEpVxd7eniJFinD48GFFh6IS5FlB6eZ9T26ehyJJOjZ/qLFpcEtBoMgIqTfo42iiYpP+MVFHxDfTctsqRvRsaJIl37Xk5GQWLlzIwoULqVy5Mtu2bZPZTGqBzPHq1StGjhzJ0aNHAVi/fj3Dhg1TbFBZYPLkyRw9epTHj3PeTJGfCQ8Pp0ePHty6dYu5c+cyefLkHDXsfPjwAT8/P44fP86pU6eIiYmhYMGCpKamsnPnThwcHJR2FO3PSEhI4PTp0/j4+ODr60tMTAzFixfHyckJZ2dn7OzsKFy48G/XuXTpEh07dgTg0KFDWFlZyTv0PEnFihXp0KEDS5cuVXQoKkGeFZQ2y4LkOpWlrIEOwRNt5bZ+fibjpD552gzi42LwO7Q7xxNw7ty5w4ABA7hx4wajR49m/vz5mXowC8iO1atXM27cOAoVKsTy5csZPHiwSnTjz5kzh+3btxMVlTPrMIFvDTtz5sxh8eLFNG3aFE9Pz0zX1EokEu7evSttqLl06RLp6elYWFhIG2r++usvqZWVqvDy5Ut8fX3x9vYmICCAlJQUatSogYuLC87OzlhaWmZLeL99+5bOnTtz+fJlVq9ezfDhw5U6Q6tspKamUrBgQdatW8eQIUMUHY5KoPxP82yQkCwmSo5iEiAqNonEZKHhQx4U0tbA1FiP0gVS+frmiUzGKWbMpF62bBmbN2/G3NycM2fOyCBagcxSrVo1AFxcXBg2bBg2NjY8fPhQwVH9HqEpR3ZoamqycOFCAgMDiYiIwMLCgkOHDv30+xMTE/Hx8WHYsGGULVuWmjVrMn/+fAwMDNi4cSMvXrzg9u3bLFiwACsrK969eyczmx95IZFIuHnzJu7u7tStW5cyZcowcuRIvn79yuLFiwkPD+fevXssWrQIKyurbGdxS5YsSUBAACNGjGDkyJH07dtXqAXOApGRkaSlpQmWQVkgTwrKyNhE5J12lQDPYxPlvEv+RldXl0+fZGdWrqGhwYQJE7hz5w7lypXD3t6eAQMGSBtGBOTLy5cvEYlE7Ny5k6CgIN69e4eFhQXz588nJSVF0eH9FEFQyp5mzZoRGhpKixYt6NSpEwMGDJA27Dx9+pS1a9fSunVrDAwMcHFxwd/fH1dXV/z8/IiNjeXo0aMMGjToPzWEuTHHOzt8/fqVkydPMmzYMExMTKhbty6rVq2iSpUq7N27l/fv3xMYGMi4ceNk2iSkqanJ6tWr2bNnDwcPHsTKyopnz57JbP28TEREBCB4UGaFPCkoU8TpeWqf/Iqenh7x8fEyX7dSpUoEBgayefNmDh06RI0aNfDy8pL5PgL/5OXLl1JT8wxBMWHCBNzc3Khbt67SelMKXd7yQV9fn7/++otNmzaxd+9eTExMKFeuHBUrVmT8+PGkpqayaNEiHj16RHh4OKtXr8be3v6HdeuJyWLuvY7n1VdNChpXVorbo/fv37Njxw5cXV0xNDSkTZs2+Pn50aFDBwICAnj//j379u2jW7duWZq6kx26d+/OlStX+PTpE3Xr1uXUqVNy3S8vEBERgYaGhsrZnCmSPDkpR0sjd3Rybu2TX9HT05NphvJ7RCIRgwYNok2bNgwfPpwOHTrQoUMH1q5dq1JjAVWJf1sGFSxYkIULF9KlSxcGDhxIo0aNGDVqFAsWLFCq+tYCBQogFosRi8VoaOTJR2au8/btW06ePMnx48c5ffo0X79+JS0tjY8fP9KzZ0/WrFlD0aJFf7mGtJHvUTRRcX838tmOJQAwc/PDRF8H26pG9LA0oXIJ+c8Wl0gkPHz4EG9vb7y9vbl8+TLwzZ91xowZuLi4UKNGDYXVMdasWZPr16/Ts2dP2rRpw9y5c5k+fbpK1DErgoiICMqVKye857NAnvxLKmdQ6D+eXrJG9Pc+AvJDV1eXr1+/yvU69I8//uDo0aPs37+fc+fOUaNGDXbs2EEe7VVTKC9fvvyhB6WFhQWXL19m+fLlbN26FVNTU06ePKmACH9MgQIFgG+OAQLZIz09natXrzJnzhzq169PqVKlGDBgAK9evWLy5MncvHmTz58/M2XKFPbs2UP79u15+fLlD9d6EZdEr20h2K0+h2dIJJFxSf8pcZIAkXFJeIZEYrf6HL22hfxnIIUsSE1N5ezZs4wfP57KlStTo0YN5s6dS/Hixdm6dStv3rzh8uXLTJs2DVNTU4U3xRQrVgwfHx9mz57NrFmzaN++vVxugfICGR6UApknTwrKQtoamPzGozCnmBjoyKRZRODn6OnpAcgtS5mBSCSiS5cu3L9/H0dHR/r164eDgwPPnz+X6775jV9NydHQ0GD8+PHcvXuXatWq0aZNG3r06MH79+9zOcr/kjE+UqijzBofP37kr7/+om/fvpQqVQpLS0s8PDyoVKkSnp6evHv3jsuXLzNz5kxq166NtrY2ixYtIiAggPDwcGrWrPkf/7/916JouSqYS09jAX5rC5fx9UtPY2m5Kpj913LeqR8fH8+BAwfo0aMHRkZG2Nrasn//flq0aCG1+jl69Cj9+/enRIkSOd5P1qipqeHm5oaPjw/BwcHUr1+fe/dkO1EuLyAIyqyTJwUlgG1VoyxPYMks6moibKsIE3Dkja6uLkCunaANDQ3x9PTk+PHjPHz4EDMzMzw8PEhLS8uV/fM6P8tQfk/58uU5deoUu3bt4tSpU1SvXh1PT0+FZowzMpSCoPw1EomE+/fvs2zZMpo1a4ahoSFdunTh5s2b9OvXj3PnzknrBnv27PnTcXa2trbcuXOH5s2b07FjRwYNGkRiYiJrg8KZ6hVGsjg9y/7CaekSksXpTPUKY21QeJZf27Nnz/Dw8KBly5YYGhrStWtX7t+/z6hRo7h27RovX75k06ZNODo6/md+vbLi5OTE9evX0dbWlpqgC3xDIpHw9OlTQVBmkTwrKHtYmsjF1By+PZx6NjSRy9oC/09GhjK3r2TatGnD3bt36dOnD2PGjMHa2poHDx7kagx5jU+fPvHp06dMjV0UiUT06tWLBw8e4ODgQO/evWnVqpXCulMFQflzvnz5wokTJxgxYgQVKlTA1NSUOXPmUKRIEdauXUtkZCR37txh8eLFWFtbZ7oeTV9fn4MHD7J161b27t2Lheswlp+WjbH88tOPOfCbTGV6ejpXrlxh+vTpmJubU6FCBSZOnIiGhgarV68mMjJSatBer149la1DrFSpEleuXMHFxYUuXbowadIkxGLFNzQpmrdv35KUlKSQsZyqjGq+CzJB5RJFsK5kKPssZXoadYwLZmlai0D2yMhQyvvK+2d7r1u3jnPnzhEbG0utWrWYP3++MB83m2TUw2VljreRkRF79uzh+PHjPHjwADMzM1atWpXrGeMMQSl0en8jMjKS9evX4+joiL6+Po6Ojpw8eRInJydOnjxJbGwsPj4+DB06FBOT7B+8RSIRAwYM4MS5q4gtXGWapZ7tfe8/NZWJiYkcO3aMAQMGYGxsTKNGjdi8eTN16tTh4MGDxMTEcOrUKUaMGJGj16VsFCpUiD179rBq1SpWrVqFvb090dHRig5LoQiWQdkjzwpKgIXtzdGQtaCUpOE3vx8rV64UrkLljKIylN9jbW1NaGgo48ePx83NjXr16nH9+nWFxaOqZAjK7FhwtGnThnv37jFw4EAmTJhAo0aNCA0NlXWIPyW/ZyhTU1MJDg5mypQpmJmZUa5cOcaMGcOXL1+YP38+9+/fJyIigjVr1tCqVSuZX/luvZ2AuqaWTBtaxOkSph8J4/Xr12zevBknJycMDQ1p164dFy9epHfv3pw7d463b9+yc+dOOnbsKD3g5kVEIhFjx44lICCAe/fuUbduXa5evarosBRGhqCsUKGCgiNRLfK0oCyjr4O7i6lM15zX1pxB3dozceJEbGxshPm+ciS3mnJ+R4ECBVi0aBFXr15FTU0NS0tLJk+eTFKSfKcx5SUyBGV2p5gUKVKE//3vf1y6dImkpCTq1avH9OnTcyVrmB8FZXR0NLt27aJLly4UL16cZs2asXPnTho0aCDN1gUGBjJhwgSqV68ut+7l8HefOf8kRublS2npEs4/iaFsTUuGDRvG58+fmT9/Po8ePeLhw4csXbo0S1f0eQUbGxtu3rxJ6dKlsba2ZsuWLYoOSSFERERgbGysMvWwykKeFpQAXeubMNG+ikzWmmRflV6NK7F69WqCg4N5+/YtFhYWCrmGyw9oa2ujpaWlNLYWderU4erVq8yfPx8PDw8sLCw4e/asosNSCV68eEGJEiXQ0tLK0ToNGzbk5s2bzJkzhxUrVmBhYUFwcLCMovwx+aHLOz09nRs3bjB37lwsLS0pWbIkffr04dmzZ4wbN45r167x+vVr/vzzTzp27Cg97MmbPSFRcmuuRJJOhymriY6OJjg4mAkTJlClimw+K1SZP/74g7NnzzJgwAAGDx7MoEGD8vTf/o8QOryzR54XlAAjbSuz2NUcbQ21LD+c1NVEaGuoscTVnBG2/1+gm3EVOnjwYMaPH0+zZs0ID89696DAr5GnuXl20NTUZNq0ady+fZsSJUpga2vL0KFDlUb0KiuZ6fDOLFpaWsycOZPQ0FBKlChBs2bNGDx4MB8/fpTJ+v8mr2YoP336xOHDh+nfvz9//PEH9erVY8WKFZQtW5bt27fz9u1bqXekohpPgh5Fy625EpEab0T6GBgYyGd9FUZbW5v169ezfft2PD09adq0KS9evFB0WLmGICizR74QlPAtU+k/zgarCt8eHr8Tlhlft6pggP84G7rU/28RdqFChfjf//5HcHAwr1+/xsLCgtWrV5OeLoxklBW6urpKKdaqVavGuXPnWLduHXv27MHU1BRfX19Fh6W0/MqDMrtUq1aN4OBgNmzYwP79+6levbpcRmjmFUGZMcllxYoVtGjRAkNDQzp27EhISAi9evXi7NmzxMTE8Ndff9GnTx+FeygmJIuJkoMZ+fdExSYpxZhGZaVv375cvHiR6Oho6tSpQ2BgoKJDyhUEQZk98o2ghG81lZ4DLDkztim9LMtS1kDnPxN1REBZAx16WZbFf1xTPAdYUuY3JulNmzblzp07DBw4kHHjxmFjY8OTJ0/k9jryE8qWofweNTU1hg8fzr179zA3N8fZ2Znu3bsrhRm3svHvsYuyQk1NjaFDh3L//n0aNGhAhw4daN++Pa9evZLZHqrc5f3161dOnTrF6NGjqVSpEtWrV2fmzJkUKFCA1atX8+zZM+7du8fSpUuxsbFBU1NT0SFLiYxN/M8EHFkjAZ7HJsp5F9Wmbt26XL9+nVq1amFnZ8fy5cvz9CSx+Ph4YmJiBEGZDfJXxfHfVC5RBDcXU9wwJTFZzPPYRFLE6WhpqFHOoFC2JuAUKlQIDw8POnToQP/+/alZsyaLFi1i1KhRKutRpgwoa4bye0xMTDhx4gS7d+9m7NixVK9eHQ8PD7p166bwUWvKgiyvvH9E6dKlOXr0KIcPH2bkyJHUqFGDpUuXMmjQoBy//zLqPlUlQ/nixQtOnDjB8ePHCQgIICkpCRMTExwdHXF0dMTW1hYdHflOEpMFKeLcuenJrX1UGUNDQ06dOsWsWbOYNGkSV69eZdu2bRQpkvfs8wTLoOyT75VOIW0NTI31qG1SDFNjvRyPU7SxseHOnTsMGDCAsWPHYmtrK/0DFcg6enp6Si8o4f/NuO/fv0+LFi3o0aMHzs7O+aru6Gd8/vyZ+Ph4mV95/xuRSETHjh158OABnTp1YujQodja2vLo0aMcrZuUkkbhMtV49knCvdfxSndFKhaLuXDhAtOmTaNmzZqYmJgwYsQI4uPjmTNnDnfv3uX58+dS70hVEJMAWhq58/GUW/uoOurq6ixcuJDDhw9z8uRJGjZsmOP3ljIiCMrsI7yT5EChQoVYs2YNQUFBvHjxgpo1a7JmzRqhtjIb6OrqKu2V948oUaIEBw4c4MiRI9y8eRNTU1M2btyYr3/3GdfP8sxQfk+xYsXYunUrgYGB0trmBQsWkJKSkuk1wt99xs37HjbLgjBz88Ogx3L2xvyB45oLmLn5YbMsCDfve4S/+yzHV/JzYmJi2L17N926dcPIyAhra2u2bdtG7dq1OXDgADExMQQHBzN58mRMTU1VJlMeHx/P0aNHGT58OC62jeR+tSoCyhkUkuseeQ1XV1euXbtGeno69evX5+jRo4oOSaZERESgp6eHvr6+okNROQRBKUeaNWvGnTt36NevH6NHjxayldlAVTKU/6Zdu3bcv3+frl27MmzYMGxtbfOtC0BGlja3BGUGGTOhx40bJ+1U/p1Z84u4JHptC8Fu9Tk8QyKJjEv6Tx2fBIiMS8IzJBK71efotS3kP1NXZI1EIuHWrVvMnz8fKysrjIyM6NWrF+Hh4YwaNYqQkBCpCXfnzp0pWrSoXOORFWlpaYSEhDBv3jysra0xMDCgffv2nDlzhlYtbSleQL77mxjo5PhWKj9SrVo1rl69ip2dHe3bt2fGjBl5xjovoyFHVQ5hyoQgKOVM4cKFWbt2LYGBgURFRQnZyiyizE05v6No0aJs3ryZgIAAXr58Sc2aNVm6dGm+m5WbYWr+xx9/5PreBQsWZNGiRVy/fh0tLS0aNmzIuHHjSEhI+M/37r8WRctVwVx6GgvwW7uajK9fehpLy1XB7P/NfOis8vnzZ44cOcKgQYMoXbo0derUYenSpRgbG7N161Zev37N9evXcXd3p0GDBipTqx0ZGcmWLVvo1KkTxYsXp2HDhqxYsQIjIyPWrVtHREQE4eHhrFu3Dqc65eXmQ6muJsK2ipFc1s4PFClShEOHDrF48WIWL15MmzZtiI2NVXRYOUbo8M4+qvEEygPY2toSFhZG3759GT16NM2bN+fp06eKDkvpUYWmnN/RvHlzwsLCGD58ONOmTcPS0jJXRwcqmpcvX2JkZIS2trbCYqhVqxZXrlxh2bJlbNq0CTMzM06dOiX9+tqgcKZ6hZEsTs+y72FauoRkcTpTvcJYG5SzLHR4eDirV6/Gzs4OAwMDXF1duXDhAl27diUgIICYmBgOHTpE//79KVWqVI72yi0SEhLw9fVl9OjRVKtWjXLlyjF06FBevXrF6NGjuXjxIjExMRw+fJghQ4b8Y9xdD0sTuflQpqVL6Nkw78zkVgQikYgpU6bg5+fHjRs3qFevHjdv3lR0WDlCEJTZRxCUuUjhwoVZt24dAQEBREZGUrNmTdatWydkK39BRoZS1W0qdHR0WLFiBZcuXSI5OZl69eoxc+ZMlekczgnysgzKKhoaGkyYMIG7d+9SuXJlWrduTc+ePdkSeI/lp2UzQnX56cccyEKmMjk5mTNnzjB27FgqV65MlSpVmDp1Kurq6qxYsYKIiAgePHjAihUraN68eY4nDeUGGVN3Fi1aRLNmzdDX18fZ2Rlvb29sbGw4fPgwsbGxXLp0CTc3N6ysrH464rByiSJYVzKUeZZSXU2EdSVDKhnlvS5lRdCyZUtu3LiBgYEBjRs3ZufOnYoOKVskJyfz4sULQVBmE5FE1T+pVZSEhAQmT57Mhg0baNasGdu2bRMG0f+Affv20b17dz5//kzhwoUVHY5MSElJYdGiRSxYsICKFSuydetWGjdurOiw5EabNm3Q1NTk2LFjig5FikQiYdeuXYyfvZDCnRcj0tCE/7jSZg9tDTX8x9n81L/21atXUlsff39/EhMTKV26tNTWp3nz5hQqpFqNIi9fvuTMmTOcPn2aM2fOEBsbS+HChWnevDn29vbY29tTqVKlbNWlvYhLouWqYJJlaO/zu9+RQPb4+vUrw4cPZ/v27QwfPpxVq1apxCEog0ePHlGtWjUCAwOxtbVVdDgqh5ChVBCFCxdm/fr1BAQE8OzZMyFb+RMyZgar+rX392hpaTFnzhxu3bqFnp4e1tbWjB49+od1fXkBeUzJySkikYg+ffrQYuoWROoayEpMAojTJUw/Eib977S0NC5dusTMmTOpXbs2pUuXZujQocTGxjJz5kzu3LlDVFQUGzduxNnZWSXEZFJSEqdOnWL8+PGYmZlRpkwZBgwYQEREBEOHDiU4OJi4uDiOHTvGiBEjqFy5crabHMro6+DuYirT+Oe6mApiUg4UKFCAbdu2sXHjRrZs2UKzZs14/fq1osPKNBlNs5UqVfrNdwr8CCFDqQR8/vyZyZMns3HjRmxtbdm2bRvly5dXdFhKwYULF7C2tub+/ftUr15d0eHInLS0NNasWcOMGTMwNDRk8+bNODg4KDosmaKvr8/kyZOZOnWqokP5B+HvPmO3+pzc1h9XJYFrAT6cOnWK2NhYDAwMaNWqFY6Ojjg4OKiULUl6ejphYWH4+flx+vRpzp8/T0pKCqVLl8bBwQF7e3tatGgh17nYa4PCZVKaMMm+KiNsBcEgb0JCQujQoQNisZiDBw9ibW2t6JB+y5o1a5g0aRJJSUkq0+SmTAj/YkpAkSJF2LBhA/7+/jx9+hRzc3M2bNggZCvJmxnK71FXV2fs2LGEhYVRuXJlWrVqRd++fYmLi1N0aDIhMTGRDx8+KEUN5b/ZExIltw5iSXoa7nsDuXfvHkOHDuXSpUu8e/dO6h2pCmLy7du3eHp60qtXL4yNjalVqxbu7u5oa2uzdOlS7t+/T1RUFFu3bqVz585yFZMAI20rs9jVHG0NtSz/3tTVRGhrqLHE1VwQk7mEpaUlN27coFq1ajRv3hwPDw+lr4WPiIigfPnygpjMJkKGUsn4/PkzkyZNYtOmTdja2vLnn39Srlw5RYelMKKioihbtix+fn7Y29srOhy5IpFI2L59O+PHj0dbW5t169bRoUMHlfZDy6hJCgoKolmzZooO5x/YLAsiUo7+kaX1tLgw1U5u68uar1+/cuHCBU6fPo2fnx937twBoHbt2tjb2+Pg4ICVlZVCu/XhW03l9CNhnH8Sg7qa6Jdd4Blft65kyML25sI1twIQi8VMmTKFlStX0r17d7Zs2aK005qcnZ2RSCT4+voqOhSVRJDhSkaRIkXYuHEjZ86cISIiAjMzs3ydrdTV1QXybobye0QiEf379+f+/ftYWVnRqVMnOnTowJs3bxQdWrbJ8KBUthrKhGQxUXI2I38Vn6J0Yxq/RyKRcPfuXVauXEmrVq0oVqwYdnZ27N69m9q1a7Nnzx7evXvHzZs3Wbx4Mba2tgoXk/CtptJzgCVnxjall2VZyhr8V5yIgLIGOvSyLIv/uKZ4DrAUxKSC0NDQYMWKFezfv5+jR4/SqFEjpR3wIVgG5QxhRICS0rJlS8LCwpg0aRLDhw/n8OHDbNu2jbJlyyo6tFylSJFvth6qam6eHYyNjfHy8uLw4cOMGDGC6tWrs3LlSvr166dy2cqMKTmKMDX/FZGxif+ZgCNrJMDz2ERMjfXkvFPmef/+Pf7+/pw+fZrTp0/z+vVrChQoQNOmTZk/fz729vaYmZmpxN9Z5RJFcHMxxQ1TvE/40bHfMLx9T1Dmj1KUMygkTMBRMrp06YKpqSnt27enXr167NmzhzZt2ig6LCnp6ek8ffpUEJQ5QMhQKjG6urps2rSJ06dP8/jxY8zMzNi0aZPS16HIEnV1dQoXLpwvMpTfIxKJ6NixI/fv36ddu3YMGDAAOzs7lTPDf/nyJYaGhhQoIOcZelkkRYYWNMqwz0/3T0nh7NmzTJs2jbp162JkZET37t25ceMG3bp14/Tp08TFxeHn58eECRMwNzdXCTH5bzRIIzX6GRal9TA11hPEpJJiZmbGtWvXsLa2xsnJiblz5yrN7dvr169JTk4WBGUOEASlCmBnZ8fdu3fp1q0bQ4cOxc7OjsjISEWHlWuo8vjFnGJgYMCOHTs4deoU4eHhmJubs3r1apWZm6uMlkEAWhq58+jLrX0ykEgkPHz4EA8PD5ycnNDX15c6R1SvXp2dO3fy6tUr7ty5w/Lly7Gzs6NgwYK5GqM8SE1NBfipQbqA8lC0aFGOHj2Ku7s7bm5utG3blo8fPyo6LOk1vCAos48gKFUEXV1dNm/ejJ+fX77LVuaF8Ys5xcHBgbt379K/f3/Gjx9P48aNuXfvnqLD+i0vX75Uug5vsVjMm8d3QM6X3iKgnIH8PSXj4uI4ePAggwYNoly5clSvXp1Jkybx5csXZs2axc2bN3n79i27d++md+/eGBsbyz2m3CZDUGpqaio4EoHMoKamxqxZszh+/DgXLlygfv36hIWF/f4H5ciTJ08QiUSCZV8OEASlimFvb09YWBhdu3Zl6NChODg4EBWV+VFvqoienl6+F5TwrZ50zZo1nD9/no8fP1K7dm3mzp1LSkqKokP7KcoydvH58+ds2rQJV1dXDAwMsLNtSnp8tFz3NDHQkcvVa2pqKufPn2fWrFlYWlpiaGhI586duXjxIq6urpw4cYK4uDgCAgKYMmUKtWvXzvM2KGLxt+YnIUOpWrRu3Zrr16+jo6NDw4YN2b9/v8JiiYiIoHTp0krReKaq5O2nTB5FT0+PLVu2cOrUKR48eICZmRlbtmzJs9lKXV3dfHvl/SMaN27M7du3mTx5MnPnzqVu3bpcvXpV0WH9EEVlKBMSEjh+/DijR4+matWqlC9fnhEjRvD+/XsmTZrE1atX6etQX24+lOpqImyrGMlkLYlEwpMnT1i/fj3t2rXDwMCApk2bsn79esqXL8/WrVuJiori/v37rFq1itatW6vEtB1ZImQoVZeKFSty+fJl2rdvT7du3Rg/frz095mbCB3eOUc4zqkwGdegEyZMYPDgwRw8eJCtW7diYmKi6NBkip6eHh8+fFB0GEpFgQIFmD9/Ph07dmTAgAE0atSIsWPHMm/ePKXxeEtKSiIuLi5XaiglEgmhoaH4+fnh5+fHhQsXSE1NpVy5cjg4OLB48WKaN28uNcoHKPruM7uuyCe7n5YuoWfD7L8PP378SFBQkHQyzbNnz9DQ0MDKyoopU6bg4OBA7dq1UVdXl2HUqosgKFUbHR0dPD09sbS0ZPz48dy8eZMDBw5QokSJXIshIiKCWrVq5dp+eRFBUKo4enp6bN26lY4dOzJo0CDMzMxYsWIFAwcOVMluzR+hp6eXr5qQskKtWrUICQlh5cqVzJkzh6NHj7JlyxaaN2+u6NB49eoVgNwylNHR0Zw5c0Yqut69e0ehQoWwtbVlxYoVODg4/HKGdOUSRbCuZMilp7G/NMfOMpJ06pUuQiWjIpn+EbFYzLVr16R2PiEhIaSlpVGlShUcHR2xt7enWbNmUhstgX8iFosRiUR5/mo/LyMSiRg1ahS1a9emU6dO1K1bl0OHDtGwYcNc2T8iIoIOHTrkyl55FeHdl0do1aoVd+/epVOnTgwePJjWrVtLPQBVHaEp59doaGgwefJkQkNDKV26NC1atGDQoEEK75zM+PuTlaD8twVOiRIl6NmzJ2FhYfTt25fAwEBiY2Px8fFh1KhRVKlS5beHqoXtzdGQ8bW3JE2M/6IB/Pnnn78sQ3n+/DmbN2+mY8eOFC9eHCsrK1atWkWpUqVYv349T58+5dGjR6xZswZnZ2dBTP6C1NRUITuZR2jSpAk3btygbNmyNG3alI0bN8q9nCsuLo6PHz8KV945RBCUeQg9PT22bdvGiRMnuHv3LmZmZmzbtk3layvzs21QVqhSpQpBQUFs2LCBAwcOYGpqire3t8LiyZiSkxNT8ydPnrBu3TpcXFwwMDD4hwXOrl27ePPmDbdu3cr2JJcy+jq4u5hmO74f4eZcg/b2TRkwYAAuLi68ffsW+DZW1dvbm5EjR1KlShXKly/P8OHDefPmDePGjePy5cvExMRw6NAhBg8eLHSbZgFBUOYtjI2NCQoKYvDgwQwbNowBAwbw5csXue0nWAbJBuHKOw/SunVr7t69y/jx4xk4cCAHDx5ky5YtSukHmBmEDGXmUVNTY+jQoTg6OjJ06FDatm1Lly5d8PDwwMhINk0imeXly5cYGBhkqabz06dP0tpBPz8/nj59iqamJo0bN2bGjBnY29tTq1YtmV5tdq1vQkxCMstPP87xWpPsq9KvaSX6Nd2Oi4sLAwcOpGLFipQtW5bw8HDEYjHly5fHwcGBJUuWYGtrS9GiRXP+IvI5YrFY6PDOY2hpabF27VoaNGjAkCFDCA0NxcvLSy7T4gRBKRuEd2AepWjRovz555//qK1cuXIl/fv3V7naSj09PZKSkoQsRBYoU6YMvr6+7Nu3j9GjR1O9enVWr15Nz549c+33nxnLoPT0dG7evCkVkJcvX0YsFlOpUiVat26Ng4NDrtQOjrStjGFhbeZ430OcLslSTaW6mggNNRFzXUyxKinizz//5PTp0/j7+xMXF4eGhgYPHjygXr16bNq0iTp16sjxleRPhGdD3qV3796Ym5vj6upK3bp12bdvH3Z2djLdIyIiAgMDA+Fwl0OEK+88Tps2bbh37x6urq4MHDiQNm3aSK8iVQVdXV3g25WhQOYRiUR0796dBw8e4ODgQO/evWnTpk2u+Zb+zDLozZs37Ny5k+7du1OiRAnq16/PkiVL0NfXx8PDg4iICMLDw1m7dm2u1g52rW+C/zgbrCoYAPzWUijj61V0JTRNCMa9TytMTEwYOHAgz58/Z/jw4Zw/f57ExEQ8PT0JDw/HxcUFPz8/ub+W/IYgKPM2tWvX5vr169SrV49WrVqxePFimZZyCZZBskEQlPmAokWLsn37dnx9fblz5w5mZmZs375dZWorM6xehGvv7FG8eHH27t2Lt7c3YWFhmJqasm7dOrnP0M0Yu5icnExAQACTJ0/GwsICY2Nj+vXrR3h4OEOGDOHcuXPExsZy9OhRhg0bRoUKFeQa168oo6+D5wBLzoxtSi/LspQ10OFHslJXLZnCr2/yfscoTk11wu/wXho3bsxff/1FTEwMV65cYe7cuTRp0gQtLS1p81CNGjVo1aoVw4YNIyEhIddfX15FuPLO+xgYGHD8+HGmT5/OtGnT6Nixo8xq6wVBKSMkAvmKuLg4SZ8+fSSApHXr1pIXL14oOqTfcvXqVQkguX37tqJDUXk+fvwoGTJkiASQNGnSRPLw4UOZ75Geni558OCBpFChQpLKlStLChYsKAEkpUqVkvTp00eyd+9eSXR0tMz3lRdPnr+QLN60W+LSb7SkRLW6EpFmAYmOjo7E0dFR4uHhIXn48KEkPT09U2ulp6dL1q1bJ9HR0ZFUrFhRcuHCBTlHnz+YOnWqpEKFCooOQyCXOHr0qERXV1dSrVo1yYMHD3K83h9//CGZOXOmDCLL3wiCMp/i6+srKVWqlERPT0/y559/ZvoDURE8fPhQAkiCg4MVHUqeISgoSFKxYkWJtra2ZNGiRZKUlJQcrffhwwfJoUOHJIMGDZKYmJhI+DYoW1KjRg3J0qVLJaGhoUr9N/Y9SUlJEj8/P8mECRMk5ubm0tdSt25dybRp0yRBQUGSr1+/5miPx48fSxo1aiQRiUSSyZMn53i9/M6ECRMkVapUUXQYArnIo0ePJDVq1JAULlxYcvjw4Sz/fMLXVMndVx8llx+/kWgalZds3LZd9kHmM0QSiYrcewrInA8fPjB27Fh27dpFmzZt2Lx5c44sXuTF27dvKVWqFD4+Pjg5OSk6nDxDUlISbm5urFixgpo1a/Lnn39Su3btTP1sWlqa1Ijbz89PasRdrVo1HBwcMDc3Z+DAgfj7+9OiRQs5v5KcIZFIuHv3rtRU/Ny5c3z9+hVjY2Ps7e2xt7enZcuWFC9eXKb7pqWlsWzZMmbPnk3VqlXx9PQUJnVkk7Fjx+Lv78/du3cVHYpALpKQkED//v05ePAgU6dOZf78+b+cHhX+7jN7QqIIehRNVFwS/xY/ZfV1sK1qRA9LEyqXEHxfs4ogKAXw8fFhyJAhJCUl8b///Y/evXsrVSd4UlIShQoVYvfu3fTo0UPR4eQ5rl+/Tv/+/bl//z6TJk1i9uzZFCxY8D/f9/LlS2k3tr+/Px8+fEBPT4+WLVvi4OCAvb09hiX/4HlsIleuXmfYkEFcCzyBhWk1BbyqXxMdHY2/vz9+fn6cOXOGN2/eULBgQWxsbKQiskaNGrnyPrhz5w69evXi/v37uLm5MWXKFKEeMIuMGDGCS5cucevWLUWHIpDLSCQSVq5cyeTJk2nevDn79u3D0NDwH9/zIi6J6UfCOP8kBnU10S9dHDK+bl3JkIXtzSmjrxyjbFUBQVAKAN8mBYwdOxZPT08cHR3ZtGmT0mQrJRIJWlpaeHh4MGzYMEWHkydJSUlh6dKlzJs3j3LlyrF161bq1avHuXPnpCLy/v37qKmp0aBBA+zt7XFwcKBBgwY8i/3y01O/CDBRglN/cnIyFy9elGYhM4SHhYWFVEA2adKEAgUKKCw+d3d3lixZQv369dm1axdVqlRRSCyqyJAhQ7h58ybXrl1TdCgCCiIwMJAuXbqgo6ODl5cXdevWBWD/tagc2YG5u5jStb6JvMLOUwiCUuAf+Pj4MHjwYL5+/crq1auVJltpYGDApEmTmDp1qqJDybNIJBK8vb0ZM2YMkZGRqKurk5aWRunSpXFwcMDBwYEWLVqgr68PKPepXyKR8PDhQ6mAPHv2LElJSRgZGUkFpJ2dHSVLlpRrHFnl8uXL9O7dm1evXrFkyRJGjBghzKfOBP379+fhw4dcunRJ0aEIKJAXL17QoUMH7ty5w4YNG0gs10QmAwsm2ldhpG1lGUSYtxEEpcB/iIuLY8yYMezevRsnJyc2bdqEsbGxQmOqUKECXbp0YdGiRQqNI68RGxsrvfo9ffo0r169Qltbm/Lly/P06VP09fXZtm0bbdq0+cfPKeOpP+O1ZIjIly9foq2tjbW1tVREmpubK71AS0xMZMqUKaxbt47mzZuzfft2TEyEDMmv6NWrF1FRUQQHBys6FAEF8/XrV0aPHs2+kEgM2oyW2bpLXM3pImQqf4lyP1kFFIK+vj6enp4cO3aM69evY2pqiqenp0J9K3V1dYV53jJALBZz8eJFZs+ejaWlJcWLF6dr165cu3aNrl274ufnx4cPH3jw4AEPHz7E3NwcR0dHevXqRUxMDABrg8KZ6hVGsjg9S2ISIC1dQrI4naleYawNCs/Ra0lJSeHcuXPMnDmTBg0aSF9LSEgInTp14uTJk8TFxXHmzBkmTZqEhYWF0otJgEKFCrF27VrOnDnD48ePMTc3Z+fOnSrjG6sIBB9KgQwKFCjArMWrKeE4Sqbvmdne93gRlySz9fIiQoZS4JfExcUxevRo9uzZg7OzM5s2baJUqVK5HoeNjQ1lypRh9+7dub63qvP8+XNpHWRAQACfPn1CX18fOzs7aTPNz+plJRIJO3fuZNy4cWhqatLLbQOHX8iuzjArp36JRMKTJ0+kneVBQUEkJCRgYGAgfS12dnZKU/srCz5+/MiYMWPYtWsXbdu2ZfPmzbk+k10V6NixIwkJCZw6dUrRoQgoAb22hXDpaWyWD7y/Ql1NhFUFAzwHWMpszbyGICgFMsWxY8cYMmQIycnJeHh45OpMaAAXFxcAvL29c21PVSUxMZGzZ89KReTjx49RV1enYcOG0lrIunXr/tJe49+8ffuWQWOnElraBTUNLZDR715bQw3/cTY/ran88OEDgYGB0mvs58+fo6mpSePGjaXX2LVr11aJzGNOOHLkCEOGDEEikbB582bat2+v6JCUirZt25Keno6Pj4+iQxFQMOHvPmO3+pzc1vcf15RKRoKl0I8Q7ggEMkXbtm1p0qQJo0ePpnfv3hw6dIiNGzfmWrZSV1eXFy9e5MpeqoZEIiE0NFSaubtw4QIpKSmUK1cOBwcHFi9eTPPmzaUjLLNDyZIlKWo3DI0n70n/4TDC7CFOlzD9SJj01C8Wi7l69apUQIaEhJCenk7VqlVxdnbG3t6eZs2aUbhwYZnFoAq0b9+exo0bM3jwYFxdXenVqxceHh4ULVpU0aEpBWKxGC0tLUWHIaAE7AmJ+m2TYHZRVxOx+0oUbi6mMl87LyBkKAWyzNGjRxkyZAipqamsWbOG7t27yz1bKfjM/ZPo6GjOnDkjbaZ59+4dOjo62NraSrOQlStXltnvRd6n/oHGb7gZdEJ6JV+0aFGpv6WdnR1ly5aV296qhEQiYdeuXYwePRpdXV3+/PNP7OzsFB2WwrG3t6do0aL89ddfig5FQMHYLAsiUo61jmUNdAieaCu39VUZIUMpkGXatWuHtbU1o0aNomfPnhw8eJCNGzfK1YJFV1eX+Ph4ua2v7KSkpHD58mXpNfbNmzcBqFWrFn369MHBwYHGjRujra0tl/3leeqXpKexyucGNb68Z+LEidjb21OvXr0sXcnnF0QiEX369MHW1pb+/ftjb2/PiBEjWLJkCYUKFVJ0eAojNTVVaMoRICFZTJScG2eiYpNITBZTSFv4e/s3wr+IQLYwMDBg7969dOrUiaFDh1KjRg25Ziv19PTynaB88uSJNAMZGBhIQkICxYsXx97enrFjx+aqj2LQo2i5iEkAkZo6NVp25PzkDXJZPy9iYmLC6dOnWbduHVOmTMHPz49du3bRqFEjRYemEMRiMZqamooOQ0DBRMYm/mecoqyRAM9jEzE1zn4JUV4lb1eyC8id9u3bc+/ex6StsAAAIyZJREFUPRwcHOjZsyeurq68fftW5vtk2Abl5QqNz58/c+zYMYYPH07FihWpXLkyY8eOJT4+nunTp3Pjxg3evn3L7t276dWrV66Jydw49b/88JXEZLFc98hrqKmpMWrUKG7fvo2BgQFNmjRh+vTpJCcnKzq0XCc1NVUQlAKkiNPz1D6qhiAoBXKMoaEh+/bt4/Dhw1y8eBFTU1P27dsnU/Gnp6eHWCzmy5cvMltT0aSnp3Pjxg0WLlyIjY0N+vr6tGvXjjNnztC6dWuOHTtGXFwcZ8+eZdq0adSpU0ch3cy5eeoXyDpVqlThwoULzJs3j+XLl9OgQQPu3Lmj6LByFeHKWwBASyN3no+5tY+qIfyrCMgMV1dX7t+/j52dHd27d6dDhw68e/dOJmtndCirurn5mzdv2LlzJ927d6dEiRLUq1ePxYsXU6xYMTw8PIiIiCA8PJy1a9fi4uJCkSKKt6cQTv3Kj4aGBtOnT+fq1aukp6dL/67S0tIUHVquIFx5CwAYF5H/34AIKGeQf+uVf4UgKAVkiqGhIfv37+fQoUNcuHCBGjVqyCRbqaurC6BydZTJyckEBAQwefJkLCwsMDY2pl+/fjx+/JjBgwcTHBxMbGwsR48eZdiwYVSoUEHRIf8H4dSvOtSqVYvr168zfvx4pk+fjrW1NeHhOZtIpAoIV975l7i4OPbs2UOXLl0o+0dJUj+8lut+JgY6QkPOTxCe4AJyoUOHDty7d4+WLVvSvXt3OnbsmKNspZZOETSNynPjeSz3Xscrbb2dRCLh0aNHeHh44OjoiL6+Pi1btsTT05PatWuzd+9e3r17x/Xr11mwYAFNmzZV+g/CcgaFZOg8+WOEU7/s0NbWZvHixZw/f57o6Ghq1arF+vXr83T9sXDlnb+IiIhg1apV2NraYmRkRM+ePXn69CmTJk2iXYMqqKvJ54mlribCtoowqepnCD6UAnLn0KFDDBs2DIlEwrp16+jcuXOmOsHD331mT0gUQY+i/+MrJgJM9HWwrWpED0sTKpdQ3NXwx48fCQgIkHZkR0ZGoqWlhbW1tdQT0tzcPFcnC8kawdtNNUlISGDy5Mls2LABOzs7/vzzT0qXLq3osGRO+fLl6d69OwsWLFB0KAJyID09natXr+Lt7Y23tzf37t1DW1ubFi1a4OLigpOTk3TkqjApR3EIglIgV3j//j0jRozg4MGDdOjQgfXr1/90JvGLuCSmHwnj/JOY33ofZnzdupIhC9ub/3SEnyxJS0vj+vXrUk/IkJAQ0tLSqFq1qlRA2tjY5ClfQDfve3iGRMpt+kQvy7LC9Ak54ufnR//+/UlMTGTNmjW5PjpV3pQuXZoBAwbg7u6u6FAEZERSUhL+/v54e3vj6+vLu3fvMDQ0xMnJCRcXF+zs7H46MUuY5a0YBEEpkKscPHiQ4cOHI5FIWL9+PZ07d/7H1/dfi2KO9z3E6ZIsPQzU1URoqIlwdzGla30TWYfNy5cvpRlIf39/4uLi0NPTk05zsbe3z9PTXIRTv+rz4cMHRo0axZ49e3B1dWXjxo0UL15c0WHJhJIlSzJy5Ehmzpyp6FAEcsDbt2/x9fXF29ubM2fO8PXrV6pWrYqLiwsuLi40atQoUwMPXsQl0XJVMMkybPTT1lDDf5xNriQtVBVBUArkOtHR0YwYMYJDhw7RsWNH1q1bh5GREWuDwll++nGO159oX4WRtpVztMaXL184d+6cNAt5//591NTUqF+/vjQL2aBBg3xVtyWc+vMGhw4dYujQoairq7N582batm2r6JByjIGBAZMnT2bKlCmKDkUgC0gkEu7fvy+9yg4JCUEkEtG4cWNcXFxwdnamatWq2Vp7/7UopnqFySzWJa7mdJFDsiIvIQhKAYXx119/MXz48G/j5OZu4lCU7MYGZvXNn/FgyxCQ586d4+vXr/zxxx9SAdmyZUv09fVlFqOqIZz68w5v375l8ODB+Pj40LdvX1avXi215lJFdHV1mTNnDhMmTFB0KAK/ITU1lQsXLkhF5NOnTylUqBCtWrXCxcWFNm3aYGhoKJO9ZJWkmGRflRG2lWQQUd5GEJQCCiU6OpoBoycTWtoFNQ0tkFFdV2aESmxsLP7+/tKr7FevXlGgQAFsbGykIrJ69ep5qtYspwin/ryDRCJhx44djBkzhmLFirF9+3aaN2+u6LCyhY6ODosXL2b06NGKDkXgB8THx3Pq1Cm8vb05ceIEHz9+xNjYGBcXF9q2bUuzZs0oUKCAXPbOaRnVXBdT4RmVSQRBKaBwem4L4dKT96TL0JzmR1epYrGYkJAQaRby2rVrSCQSTE1NpQLS2tqaggULyiyOvIhw6s9bREZG0rdvX86ePcvo0aNZtGgROjqqlTHW1NTEw8ODYcOGKToUgb+JjIyUZiHPnj2LWCymVq1a0nrIOnXq5NphXdkbPfMKgqAUUCjybvbY2aUSj64G4+fnR0BAAPHx8ejr62NnZydtpsmwmxDIPMKpP2+Rnp7OmjVrmDp1KiYmJuzatQtLS9Woa5VIJKipqbF582YGDRqk6HDyLenp6dy8eVMqIkNDQ9HU1MTW1lZaD2liotj3vNSK7nE0UbFJ/xgpK+KbabltFSN6NjQRmgSzgSAoBRSKPO1oSE/j083jfAraRsOGDaVZyLp162aqU1Dg1win/rzHw4cP6d27Nzdu3GDatGnMnj0bLS0tRYf1SzLGLm7fvp2+ffsqOpx8xdevXwkMDMTb2xsfHx9ev35NsWLFcHR0xMXFBQcHB+mUM2UjMVnM89hEUsTpaGmoUc6gkDABJ4cIglJAocjbMNtQOx3/sdYULVpUbnvkd4RTf95CLBazaNEi5s6di5mZGZ6enpiZmSk6rJ/y5csXdHR02L17Nz169FB0OHme9+/fc/z4cby9vTl9+jSJiYlUqFCBtm3b4uLiQuPGjZV++peAfBAEpYDCSEgWY+7mhzz/AEXAXTcH4eSZS2Sc+u89eETP7l3xP7KPplaqcXUq8E9u3rxJr169ePLkCfPnz2f8+PFKmdn/9OkTenp67N+/ny5duig6nDzJo0eP8Pb25tixY1y6dAmAhg0bSushheZFAQDhU1ZAYUTGJspVTAJIgOexiZgaq64liipRSFsDU2M9imuUIzX6GXHRbxQdkkA2qVOnDjdu3GDWrFlMmTIFb29vduzYQcWKFRUd2j8Qi8UAQlZMhojFYi5fviyth3z8+DEFCxbE3t6erVu34ujoSIkSJRQdpoCSoaboAATyLyky9DNUhn0E/h9DQ0M0NTV5/fq1okMRyAEFChRg2bJlBAcH8+rVKywsLNi4cSPKdLGVmpoKkK+GDMiDz58/c/jwYfr06UPJkiVp2rQpnp6eNG3aFB8fH2JjYzl69Cj9+/cXxKTADxHegQIKQ0sjd84zubWPwP+jpqZGqVKlBEGZR7C2tiY0NJSJEycybNgwjh07xtatW5XCISFDUAoZyqzz8uVLfHx88Pb2JjAwkJSUFMzMzBgyZAguLi7Ur18fNTXh+SmQOQRBKaAwyhkUQgRyr6EsZ1BIjjsI/AxjY2NevXql6DAEZESRIkXYtGkTbdu2ZeDAgZiZmbFu3Tq6deum0Po54co780gkEkJDQ6VX2Tdu3EBdXR0bGxuWLl2Ks7MzFSpUUHSYAiqKICgFFEYhbQ1M9HXk2uVtYqAjNOQoCGNjYyFDmQdp06YNd+/eZcSIEfTo0YMjR46wYcMGmY3LyyrClfevSU5OJjg4WCoiX7x4ga6uLm3atGHChAm0atWKYsWKKTpMgTyAkMsWUCi2VY1QV5NPdkNdTYRtFSO5rC3wewRBmXfR19dn3759HDhwgMDAQMzMzPD19VVILMKV93+Ji4tj9+7ddO7cmeLFi+Pg4ICvry/t2rXjzJkzvH//nn379tGtWzdBTArIDEFQCiiUHpYm8jE1B9LSJbQzM5DL2gK/548//hAEZR6nc+fO3L17l7p16+Ls7MzAgQP59OlTrsYgXHl/IyIiglWrVtGsWTOMjIzo1asXz58/Z/LkyYSGhvLs2TM8PDxo2bKl0pvVC6gmgqAUUCiVSxTBupKhzLOUIiQkR4Zi37Am69evl2YxBHIPY2Nj4uLi+Pr1q6JDEZAjpUqVwtfXly1btnDgwAFq1qzJ2bNnc23//HrlnZaWxuXLl5k2bRqmpqZUqlSJadOmUbhwYdavX8+rV6+4evUqM2fOpGbNmoJPpIDcEQSlgMJZ2N4cDRkLSi0NdbxndcXJyYmRI0dSs2ZNfHx8lMruJK9jbGwMIGQp8wEikYiBAwdy584dypYti62tLePGjePLly9y3zs/ZSgTExM5duwYAwYMwNjYGCsrK7Zu3UqDBg04cuQIsbGx+Pr6MnjwYOn7T0AgtxAEpYDCKaOvg7uLqUzXnOtiSv3qFfjzzz+5efMmf/zxBy4uLjRv3pwbN27IdC+BHyMIyvxH+fLlCQoKYsWKFWzYsIE6depw/fp1ue6Z12so37x5w5YtW3B2dsbQ0JB27dpx6dIl+vbty4ULF3j79i3bt2+nXbt2FCokOFoIKA5BUAooBV3rmzDRvopM1ppkX5Uu9U2k/12rVi3OnDnDiRMniI6Opl69evTu3ZsXL17IZD+BHyMIyvyJmpoa48eP5+bNm+jo6NCwYUPmzJkjt7KTvHblLZFIuHv3LgsXLqRhw4YYGxszdOhQPn36xPz583n06BEPHjxgyZIlNG7cWCnHYQrkTwRBKaA0jLStzGJXc7Q11LJcU6muJkJbQ40lruaMsK30n6+LRCJat25NaGgomzZtws/PjypVqjB9+vRcbyLIL+jp6aGjoyMIynxKjRo1uHLlCjNnzmTBggU0bNiQ+/fvy3yfvHDlnZqaSmBgIGPHjqVixYqYm5uzaNEiypQpw65du4iOjiY4OJgJEyZQpYpsDt4CArJGEJQCSkXX+ib4j7PBqsK37uzfCcuMr1tVMMB/nM0/MpM/QkNDg8GDB/PkyRMmTpzI6tWrqVSpEhs2bJB+MAnIBpFIJFgH5XM0NTVxc3PjypUrfPnyhTp16rBixQrS0tJktoeqZig/fvzI/v376d69O8WLF6dFixYcOnSIVq1acfLkSWJiYjh48CC9evXCwEBwqxBQfkQSoUtBQEkJf/eZPSFRBD2OJio26R8TdUR8My23rWJEz4YmVDIqkq09Xr58yaxZs9i5cydVq1Zl2bJlODo6Ch2RMsLGxobSpUuzZ88eRYcioGC+fPnCjBkzWL16NdbW1uzYsYPy5cvneN1jx47Rrl073r17h5GRcvvOPn/+HB8fH44dO0ZwcDBisZjatWvj4uKCi4sLtWvXFp49AiqLICgFVILEZDHPYxNJEaejpaFGOYNCMp2Ac+vWLSZOnEhgYCC2trasWLGC2rVry2z9/Eq3bt14+/YtQUFBig5FQEkIDg6mb9++xMTEsHLlSgYOHJgjEXX48GE6duxIXFyc0pl0p6enc+PGDemUmjt37qCpqUnz5s1xcXHB2dmZMmXKKDpMAQGZIFx5C6gEhbQ1MDXWo7ZJMUyN9WQ+TrF27dr4+/vj6+vL27dvqVu3Ln369BEad3KIYG4u8G9sbGy4c+cOXbt2ZfDgwTg5OfHmzZtsrZWYLCbyUxpaparwJPYricmKL1v58uULx48fZ8iQIZQuXZoGDRqwfv16LCwsOHjwIDExMZw6dYrhw4cLYlIgTyFkKAUE/oVYLGbbtm3Mnj2bT58+MX78eKZOnUqRItm7Vs/PrFy5kjlz5vD582dFhyKghBw/fpyBAweSkpLC+vXr6dKly29/RloK8yiaqLgflMLo62Bb1YgeliZULpE779no6GiOHz+Ot7c3p0+fJikpiYoVK9K2bVtcXFxo3LixytV4CghkFUFQCgj8hE+fPrF06VJWrFiBrq4u7u7uDBw4UPhgyAL79++nW7duxMfHo6urq+hwBJSQ2NhYhg0bxsGDB+natSvr1q1DX1//P9/3Ii6J6UfCOP8kBnU10S9HtmZ83bqSIQvbm1NGX0emMUskEh49eiS9yr506RIAjRo1ktZDVqtWTaiHFMhXCIJSQOA3vHz5khkzZuDp6Um1atVYtmwZbdq0ET4sMsG5c+ewsbHhwYMHVKtWTdHhCCgpEomE/fv3M2LECAoUKMC2bdto3bq19Ov7r0Uxx/se4nTJL4Xkv1FXE6GhJsLdxZSuv3GA+B1isZhLly5JRWR4eDg6OjrY29vj4uKCo6Oj0jcFCQjIE6GGUkDgN5QuXZqdO3dy/fp1SpYsiZOTEy1btuTWrVuKDk3pEczNBTKDSCSiW7du3L17FwsLC9q0acPgwYP5/Pkza4PCmeoVRrI4PUtiEiAtXUKyOJ2pXmGsDQrPclyfP3/m0KFD9O7dmxIlSmBjY8OePXuwtbXF19eXmJgYjhw5Qr9+/QQxKZDvETKUAgJZQCKRcOLECSZNmsTDhw/p3bs38+fPp3Tp0ooOTSlJSkqiUKFCeHp60rNnT0WHI6ACSCQSNm/ezIQJEyjesC2S+t1ltvYSV/PfetW+fPlSmoUMCgoiJSUFc3Nz6VV2vXr1UFMTcjECAv9GEJQCAtlALBazdetWZs+eTUJCAuPHj2fKlClC484PKFasGNOmTWPy5MmKDkVAhbhw+wE99z5CoqYhs/ISbQ01/MfZ/KOmUiKRcPv2bamIvHnzJhoaGtjY2EitfWThlykgkNcRjlkCAtlAQ0ODoUOH8uTJE8aNG8eKFSuoVKkSmzZtEibu/AtjY2NevXql6DAEVIxNNz6hrqkl01plcbqE6UfCSE5Oxs/PjxEjRmBiYkKdOnVYtWoVVatWZd++fbx//x5/f39Gjx79f+3df0yV9d/H8dc5hx+GmihIZoHUDdgEQsEESQRXYFbSXWur9u1bYq1y375bieA3XBPBUd/BVqZl2dpazrLbLYPqdt9vLfmRLcNmgjgR46e/QAFdgoF4rvuP7s46dz9u8DqHw+E8H5t/Hb0+b//w8PS6rs91EZPAMHGGEnCBjo4Ox8adOXPmqLS0VMuWLWPjjqTMzEwFBwdr165dnh4FXqKp80dlvlrttuOf37FaFzqOKTIy0nEpOy0tTQEBAW5bExjvOEMJuEB4eLjee+89fffddwoLC9M999yjzMxMff/9954ezeN4uDlGasf+dtmsbvrPmP2Kbl/xgurq6tTc3KxNmzbpjjvuICYBkwhKwIUSExP15ZdfqqKiQidOnFBiYqJycnJ8+pLvzJkzCUqMyN7GrhHv6B42q00Xr52l+Ph4riAALkRQAi5msVi0fPly1dfX6/XXX9dnn32m6Ohovfjiiz75xphfgpK7azAcFweG1N7T79Y12rv7x8RrGoHxhKAE3MTf31+rVq1SU1OTnnvuOZWVlSk6Olrbtm3zqY07M2fO1ODgoLq7uz09CrxAW3ef3P1fD0NSa3efm1cBfAtBCbjZlClTVFJSosbGRmVmZurpp5/W3LlztWfPHp84a8fDzTESg0P2cbUO4CsISmCUREREaPv27Tpw4IBCQ0N19913KysrS4cOHfL0aG51ww03SCIoMTwDl0bnzGGAHz/+AFfiXxQwypKSkrR3716Vl5ero6ND8+bN08qVK8ftxp0ZM2ZIIijx+3p7e1VRUaHc3FwlJSXp9ltj3H7m3iIpMmSiW9cAfA1BCXiAxWJRdna26uvrtXnzZn3yySeKiYnR+vXrdfHiRU+P51L+/v4KCwsjKCFJ6unpUXl5uVavXq3ExESFhITovvvu065duxQbG6u3t27RDde69xE+ESFBmhjo59Y1AF/Dg82BMeDChQt6+eWX9corryg4OFjFxcVauXKlbDabp0dziXnz5iklJUVbt2719CgYZT09PaqurlZlZaWqqqp06NAhGYahiIgIZWRkOH5FRkY6HuNTWNGg7fvb3PLoIJvVor8mz1JhdqzLjw34MoISGEPa2tq0bt067dixQ3FxcSotLdXSpUu9/nl59957r2w2m8rLyz09Ctysu7vbKSDr6upkGIYiIyOVkZGh9PR0R0D+EXe/KeeL5xcrKmyy244P+CKCEhiDDhw4oNzcXFVXVyszM1OlpaVKSEjw9FhX7amnntLBgwdVW1vr6VHgYufOnXMEZGVlperr6yVJN910k+PsY3p6umbNmjWi4/71nf36urnbpWcpbVaLUm8O0fYnkl12TAA/IyiBMcowDFVUVCg/P19NTU3KyclRcXGx4zE83qSwsFBvv/32uN145EvOnj2rqqoqVVVVqbKyUocPH5Yk3XzzzU4BGRERYWqdjp5+3flKlQZc+HifQD+rvng+XeHTglx2TAA/IyiBMe7y5cvatm2bCgsL1d/frzVr1igvL0+TJk3y9GjDtm3bNq1atUoDAwPy82MzhDfp6upyCsiGhgZJUlRUlOPydXp6usLDw12+9s7adv3jo3qXHe+fD8TrodvMhS6A30dQAl7iwoULeumll/Tqq69q6tSpKi4uVk5Ojlds3Pn000+1fPlynTx50ivPsPqSzs5ORzxWVVXpyJEjkqTo6GingLzxxhtHZZ4te5tU9u9jpo+TlzVbf1sS5YKJAPweghLwMq2trVq3bp3ef/99xcXFqaysTEuXLvX0WH/q4MGDSkxMVG1trebPn+/pcfArZ86ccQRkZWWljh49KkmKiYlxxGN6errjAfWesLO2XesrGjRkN0Z0T6XNapGf1aKi7FjOTAJuRlACXqq2tla5ubmqqalRVlaWysrKFB8f7+mxfldnZ6dmzJih8vJyZWdne3ocn3b69GmngGxsbJQkzZ4923EP5OLFi8fcmeSOnn4V7K5XzfFzslktfxqWv3yeFhWqkvvjuWcSGAUEJeDFDMNQeXm58vPz9cMPPygnJ0dFRUVjLgbsdrsCAgK0ZcsWPfPMM54ex6ecOnXKKSCPHfv58vEtt9ziFJDXX3+9hycdnqbOH7Vjf7v2HutSe3e/fv0DzKKfH1q+JCZMj6ZE8GggYBQRlMA4cPnyZb311lsqLCzUpUuXlJeXp7y8PE2cOHZeLxceHq4VK1aouLjY06OMaydPnnTc/1hZWammpiZJ0pw5cxz3QC5evNjxSkxv1jcwpNbuPg0O2RXgZ1VkyETegAN4CEEJjCPnz593bNwJCQlRcXGxVqxYMSY27qSkpCg2NlbvvPOOp0cZVzo6Opw20Rw/flySFBsb67gHcvHixbruuus8PCmA8YygBMah1tZWFRQU6IMPPlB8fLzKysqUlZXl0ZkeeOABXbp0SXv27PHoHN6uvb3d6RJ2c3OzJCkuLs7pEvb06dM9PCkAX0JQAuPYt99+q9zcXH311VdaunSpSktLPbZx59lnn1VNTY0OHTrkkfW9VVtbm1NAtrS0SJLi4+OdAjI0NNTDkwLwZdxsAoxjCxYsUHV1tT7++GPl5+dr7ty5WrlypYqKikZ9E8bMmTN16tSpUV3TG7W2tjrdA9na2ipJSkhI0PLly5WRkaG0tDQCEsCYwhlKwEcMDg7qzTff1IYNGzQwMKC8vDytWbNm1DbuvPvuu8rJydFPP/2kwMDAUVlzrDMM4zcB2dbWJovFooSEBMcmmrS0NIWEhHh6XAD4QwQl4GPOnz+vkpISbdq0SSEhIdq4caMef/xxt2/c+fzzz5WVlaWWlhZFRka6da2xyjAMtbS0OC5fV1VVqb29XRaLRXPnznVsoklLS9O0adM8PS4ADBtBCfiolpYWFRQUaOfOnbr11ltVVlamzMxMt63X0NCguLg47du3T6mpqW5bZywxDEPNzc2OgKysrNSJEydksVg0b948p4CcOnWqp8cFgKtGUAI+bv/+/crNzdW+fft01113qbS0VHFxcS5fp7e3V9OmTdOuXbv04IMPuvz4Y4FhGDp+/LjTJpqTJ0/KarU6AjIjI0OLFi1ScHCwp8cFAJdhUw7g45KTk1VTU6Pdu3dr7dq1SkhI0BNPPKGioiKXPvw6ODhYEyZMGFcbcwzDUFNTk9M9kKdOnZLValVSUpIeeeQRR0BOmTLF0+MCgNtwhhKAw+DgoLZu3aqioiINDAwoPz9fubm5Ltu48x+z5+iO/3xYq/72d698s4lhGDp27JjTPZCnT5+WzWZTUlKS4xL2okWLdO2113p6XAAYNQQlgN/o7e1VSUmJXnvtNYWGhmrjxo167LHHrmrjjuPdy41dauvukywWx2cWSRHTgrRkdpj+khyh6OvG1ruXDcNQY2OjU0CeOXNGNptN8+fPdwTk7bffTkAC8GkEJYA/1NzcrIKCAn344YdKSEhQWVmZ7rzzzmH92Y6efhXsrlfN8XOyWS26Yv/jr5pfPk+LClXJ/fEKnxbkqr/CiBiGoaNHjzoFZGdnp/z8/BwBmZGRodTUVE2ePLbiFwA8iaAE8P/65ptvlJubq6+//lrLli1TaWmpYmNj//D376xt1/qKBg3ZjT8Nyf/LZrXIz2rRhuxYPXxbhCtG/1OGYejIkSNO78Lu6uqSn5+fFixY4HgOZGpqqiZNmuT2eQDAWxGUAIbFMAx99NFHWrt2rVpaWvTkk09qw4YNv9m4s2Vvk8r+fcz0emuyYvTskmjTx/k1u92uI0eOOOKxqqpKZ8+elb+//28CcrQe+A4A4wFBCWBEBgcH9cYbb6ioqEiXL1/W2rVrtXr1agUFBWlnbbv+8VG9y9b65wPxesjEmUq73a6GhgbHJezq6mqdO3dO/v7+Sk5OdgTkwoULCUgAMIGgBHBVent7tXHjRm3evFnTp0/XmvUv6c2O6RoYsrtsjUA/q754Pn3Y91Ta7XYdPnzYKSC7u7sVEBCg5ORkxyaahQsXKijIM/dpAsB4RFACMKW5uVkvvPCCKi1xumZWgmR13SscbVaLUm8O0fYnkn/3c7vdrrq6Osc9kNXV1erp6VFAQIBSUlIcm2hSUlJ0zTXXuGwuAIAzghKAaU2dPyrz1Wq3Hf+L5xcrKmyyrly5orq6Osc9kNXV1ert7VVgYKAWLlzouISdnJxMQALAKCIoAZhWWNGg7fvbRrSje7isFil+Qq+MA/+lmpoanT9/XoGBgUpNTXUKyAkTJrh8bQDA8HjPKyoAjFl7G7vcEpOSZDek7079pNl9fVq9erXS09O1YMECAhIAxhCCEoApFweG1N7T79Y1/Kder4r//pdXvaYRAHyJ1dMDAPBubd19cvd9M4ak1u4+N68CALhaBCUAUwZd+JigsbAOAGDkCEoApgT4jc7XyGitAwAYOb6hAZgSGTJRFjevYfnfdQAAYxNBCcCUiYF+ihjmm2yuVkRIEBtyAGAMIygBmLZkdphsVvecp7RZLVoSE+aWYwMAXIOgBGDaX5Ij3PYcyit2Q4+mRLjl2AAA1yAoAZgWfd1kpUWFuvwspc1qUVpUqKLCJrv0uAAA1yIoAbhEyf3x8nNxUPpZLSq5P96lxwQAuB5BCcAlwqcFaUN2rEuPWZQdq3A3b/gBAJhHUAJwmYdvi9CarBiXHCsva7Yeuo17JwHAG1gMw3D3W9MA+Jidte1aX9GgIbsxos06NqtFflaLirJjiUkA8CIEJQC36OjpV8HuetUcPyeb1fKnYfnL52lRoSq5P57L3ADgZQhKAG7V1Pmjduxv195jXWrv7tevv3As+vmh5UtiwvRoSgS7uQHASxGUAEZN38CQWrv7NDhkV4CfVZEhE3kDDgCMAwQlAAAATGGXNwAAAEwhKAEAAGAKQQkAAABTCEoAAACYQlACAADAFIISAAAAphCUAAAAMIWgBAAAgCkEJQAAAEwhKAEAAGAKQQkAAABTCEoAAACYQlACAADAFIISAAAAphCUAAAAMIWgBAAAgCkEJQAAAEwhKAEAAGAKQQkAAABTCEoAAACYQlACAADAFIISAAAAphCUAAAAMIWgBAAAgCkEJQAAAEwhKAEAAGAKQQkAAABTCEoAAACYQlACAADAFIISAAAAphCUAAAAMIWgBAAAgCkEJQAAAEwhKAEAAGAKQQkAAABTCEoAAACYQlACAADAlP8BsKtH/CI3X1EAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nx.draw(graph_cube)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have an idea of what our Hamiltonians look like, we can begin generating them in a form accepted by pyLIQTR." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def estimate_qsp(pyliqtr_hamiltonian, timesteps, energy_precision, outdir, hamiltonian_name='hamiltonian', write_circuits=False):\n", + " timestep_of_interest = 1 #for magnus like argument\n", + " angles_response = Angler_fourier_response(tau=timestep_of_interest*pyliqtr_hamiltonian.alpha, eps=energy_precision, random=True, silent=True)\n", + " angles_response.generate()\n", + " angles = angles_response.phases\n", + "\n", + " qsp_circuit = generate_QSP_circuit(pyliqtr_hamiltonian, angles, pyliqtr_hamiltonian.problem_size)\n", + " if not os.path.exists(outdir):\n", + " os.makedirs(outdir)\n", + " \n", + " subcircuit_counts = dict()\n", + " t_counts = dict()\n", + " t_depths = dict()\n", + " t_depth_wires = dict()\n", + " clifford_counts = dict()\n", + " gate_counts = dict()\n", + " subcircuit_depths = dict()\n", + " \n", + " outfile_data = f'{outdir}{hamiltonian_name}__high_level.dat'\n", + " \n", + " for moment in qsp_circuit:\n", + " for operation in moment:\n", + " gate_type = type(operation.gate)\n", + " if gate_type in subcircuit_counts:\n", + " subcircuit_counts[gate_type] += 1\n", + " else:\n", + " outfile_qasm_decomposed = f'{outdir}{str(gate_type)[8:-2]}.decomposed.qasm'\n", + " outfile_qasm_cpt = f'{outdir}{str(gate_type)[8:-2]}.cpt.qasm'\n", + " decomposed_circuit = circuit_decompose_once(circuit_decompose_once(cirq.Circuit(operation)))\n", + " cpt_circuit = clifford_plus_t_direct_transform(decomposed_circuit)\n", + " \n", + " if write_circuits:\n", + " with open(outfile_qasm_decomposed, 'w') as f:\n", + " print_to_openqasm(f, decomposed_circuit, qubits=decomposed_circuit.all_qubits())\n", + " \n", + " with open(outfile_qasm_cpt, 'w') as f:\n", + " print_to_openqasm(f, cpt_circuit, qubits=cpt_circuit.all_qubits())\n", + " \n", + " subcircuit_counts[gate_type] = 1\n", + " subcircuit_depths[gate_type] = len(cpt_circuit)\n", + " t_counts[gate_type] = count_T_gates(cpt_circuit)\n", + " gate_counts[gate_type] = count_gates(cpt_circuit)\n", + " t_depths[gate_type] = get_T_depth(cpt_circuit)\n", + " t_depth_wires[gate_type] = get_T_depth_wire(cpt_circuit)\n", + " clifford_counts[gate_type] = gate_counts[gate_type] - t_counts[gate_type]\n", + " \n", + " total_gate_count = 0\n", + " total_gate_depth = 0\n", + " total_T_depth = 0\n", + " total_T_depth_wire = 0\n", + " total_T_count = 0\n", + " total_clifford_count = 0\n", + " for gate in subcircuit_counts:\n", + " total_gate_count += subcircuit_counts[gate] * gate_counts[gate] * timesteps / timestep_of_interest\n", + " total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate] * timesteps / timestep_of_interest\n", + " total_T_depth += subcircuit_counts[gate] * t_depths[gate] * timesteps / timestep_of_interest\n", + " total_T_depth_wire += subcircuit_counts[gate] * t_depth_wires[gate] * timesteps / timestep_of_interest\n", + " total_T_count += subcircuit_counts[gate] * t_counts[gate] * timesteps / timestep_of_interest\n", + " total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate] * timesteps / timestep_of_interest\n", + " with open(outfile_data, 'w') as f:\n", + " total_gate_count \n", + " f.write(str(\"Logical Qubit Count:\"+str(len(qsp_circuit.all_qubits()))+\"\\n\"))\n", + " f.write(str(\"Total Gate Count:\"+str(total_gate_count)+\"\\n\"))\n", + " f.write(str(\"Total Gate Depth:\"+str(total_gate_depth)+\"\\n\"))\n", + " f.write(str(\"Total T Count:\"+str(total_T_count)+\"\\n\"))\n", + " f.write(str(\"Total T Depth:\"+str(total_T_depth)+\"\\n\"))\n", + " f.write(str(\"Maximum T Count on Single Wire:\"+str(total_T_depth_wire)+\"\\n\"))\n", + " f.write(str(\"Total Clifford Count:\"+str(total_clifford_count)+\"\\n\"))\n", + " f.write(\"Subcircuit Info:\\n\")\n", + " for gate in subcircuit_counts:\n", + " f.write(str(str(gate)+\"\\n\"))\n", + " f.write(str(\"Subcircuit Occurrences:\"+str(subcircuit_counts[gate]*timesteps)+\"\\n\"))\n", + " f.write(str(\"Gate Count:\"+str(gate_counts[gate])+\"\\n\"))\n", + " f.write(str(\"Gate Depth:\"+str(subcircuit_depths[gate])+\"\\n\"))\n", + " f.write(str(\"T Count:\"+str(t_counts[gate])+\"\\n\"))\n", + " f.write(str(\"T Depth:\"+str(t_depths[gate])+\"\\n\"))\n", + " f.write(str(\"Maximum T Count on a Single Wire:\"+str(t_depth_wires[gate])+\"\\n\"))\n", + " f.write(str(\"Clifford Count:\"+str(clifford_counts[gate])+\"\\n\"))\n", + " return qsp_circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "## initializing seed for consistent results for the cubic lattice and generating Hamiltonians\n", + "random.seed(0)\n", + "np.random.seed(0)\n", + "square_lattice_size=10\n", + "triangle_lattice_size=32\n", + "cubic_lattice_size=12\n", + "test_lattice_size=3\n", + "\n", + "square_hamiltonian = generate_square_hamiltonian(square_lattice_size, dim=2)\n", + "cubic_hamiltonian = generate_square_hamiltonian(cubic_lattice_size, dim=3)\n", + "triangular_hamiltonian = generate_triangle_hamiltonian(triangle_lattice_size)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have generated our Hamiltonians, we can start generating the circuits for a preferred dynamic simulation method (e.g., QSP, Trotter 4th order, ...). Shown below is QSP." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "timesteps=1000\n", + "required_precision = 1e-16\n", + "\n", + "#feeding square Hamiltonian to PyLIQTR for circuit generation\n", + "H_square = pyH(square_hamiltonian[0] + square_hamiltonian[1])\n", + "H_triangle = pyH(triangular_hamiltonian[0] + triangular_hamiltonian[1])\n", + "H_cube = pyH(cubic_hamiltonian[0] + cubic_hamiltonian[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we need to extract resource estimates for each of the subcircuits of the high level circuit. The information which we are interested in is as follows:\n", + "* Total gate count for full circuit\n", + "* Total depth for full circuit\n", + "* Decomposed QASM circuit for each subcircuit\n", + "* Clifford + T circuits for each subcircuit\n", + "* Total T gate count for each subcircuit\n", + "* Total Clifford count for each subcircuit\n", + "* T gate depth for each subcircuit\n", + "\n", + "This information can be extracted by obtaining the information for each subcircuit and multiplying by the number of repetitions of the subcircuits. In this\n", + "notebook, we show the process for both QSP and second order Suzuki-Trotter, though this process could likely be generalized to many quantum algorithms.\n", + "It should be noted that the approach shown here provides a slight over-estimation since it assumes that each of the subcircuits operate in serial. This\n", + "assumption is valid for both QSP and second order Suzuki-Trotter since the operations which consume the bulk of the circuit volume do operate in serial\n", + "(Select and Reflect Operations and Trotter steps respectively)." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimating Square\n", + "Estimating Triangle\n", + "Estimating Cube\n", + "Finished estimating\n" + ] + } + ], + "source": [ + "print('Estimating Square', flush=True)\n", + "qsp_circ_square = estimate_qsp(H_square, timesteps, required_precision, 'QSP/square_circuits/', hamiltonian_name='square')\n", + "print('Estimating Triangle', flush=True)\n", + "qsp_circ_triangle = estimate_qsp(H_triangle, timesteps, required_precision, 'QSP/triangle_circuits/', hamiltonian_name='triangle')\n", + "print('Estimating Cube', flush=True)\n", + "qsp_circ_cube = estimate_qsp(H_cube, timesteps, required_precision, 'QSP/cube_circuits/', hamiltonian_name='cube')\n", + "print('Finished estimating', flush=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# More complicated Hamiltonian\n", + "There are a few ways to make the simulation task more challenging and more application relevant.\n", + "The Kitaev honeycomb model is hypothesized to be a good model for the structure of many materials (see for example [here](https://www.sciencedirect.com/science/article/pii/S0370157321004051)). This model is appealing for quantum simulation purposes because while the behavior in the infinite time regime is [understood](https://www.cambridge.org/core/books/introduction-to-topological-quantum-computation/kitaevs-honeycomb-lattice-model/85E968DD7C54F8062C4EAF5394DAAAF6), the behavior with minor perturbations to the model or the dynamics of the model are not so well [understood](https://courses.physics.illinois.edu/phys598PTD/fa2013/L26.pdf). The Kitaev honeycomb model consists of directionally defined $XX$, $YY$, and $ZZ$ couplings on a honeycomb lattice. These assignments are denoted in the plot below by 'X', 'Y', or 'Z' respectively." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "hexagon_graph = hexagonal_lattice_graph(3,3)\n", + "pos = nx.get_node_attributes(hexagon_graph, 'pos')\n", + "assign_hexagon_labels(hexagon_graph)\n", + "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in hexagon_graph.edges(data=True)]);\n", + "nx.draw(hexagon_graph, pos)\n", + "nx.draw_networkx_edge_labels(hexagon_graph, pos,edge_labels = edge_labels);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From this graph we can generate the Hamiltonian\n", + "\\begin{equation*}\n", + "H_{\\text{Kitaev}} = \\sum_{(i,j) \\in X \\text{ edges}} J_{i,j} \\sigma_i^x \\sigma_j^x + \\sum_{(i,j) \\in Y \\text{ edges}} J_{i,j} \\sigma_i^y \\sigma_j^y + \\sum_{(i,j) \\in Z \\text{ edges}} J_{i,j} \\sigma_i^z \\sigma_j^z\n", + "\\end{equation*}" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def nx_kitaev_terms(g:Graph, p:float) -> list:\n", + " hamiltonian = []\n", + " n = len(g.nodes)\n", + " for (n1, n2, d) in g.edges(data=True):\n", + " label = d['label']\n", + " weight = 1 if random.random() < p else -1\n", + " pauli_string = n * 'I'\n", + " for i in range(len(g)):\n", + " if i == n1 or i == n2:\n", + " pauli_string = f'{pauli_string[:i]}{label}{pauli_string[i+1:]}'\n", + " else:\n", + " pass\n", + " hamiltonian.append((pauli_string, weight))\n", + " return hamiltonian\n", + "\n", + "def generate_kitaev_hamiltonian(lattice_size:int, weight_prob:float=1):\n", + " graph = hexagonal_lattice_graph(lattice_size,lattice_size)\n", + " assign_hexagon_labels(graph)\n", + " graph = flatten_nx_graph(graph)\n", + " H = nx_kitaev_terms(graph, weight_prob)\n", + " return H\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimating Kitaev\n", + "Finished Estimating\n" + ] + } + ], + "source": [ + "# lattice_size_kitaev = 3\n", + "lattice_size_kitaev = 32\n", + "kitaev_hamiltonian = generate_kitaev_hamiltonian(lattice_size_kitaev)\n", + "\n", + "timesteps = 1000\n", + "required_precision = 1e-16\n", + "H_kitaev = pyH(kitaev_hamiltonian)\n", + "print('Estimating Kitaev', flush=True)\n", + "qsp_circ_kitaev = estimate_qsp(H_kitaev, timesteps, \n", + " required_precision, \n", + " 'QSP/kitaev_circuits/',\n", + " hamiltonian_name='kitaev')\n", + "print('Finished Estimating', flush=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_directional_triangular_hamiltonian(lattice_size:int, weight_prob:float = 1):\n", + " graph = nx_triangle_lattice(lattice_size)\n", + " assign_directional_triangular_labels(graph,lattice_size)\n", + " graph = flatten_nx_graph(graph)\n", + " H = nx_kitaev_terms(graph, weight_prob)\n", + " return H\n", + "\n", + "g_triangle = nx_triangle_lattice(3)\n", + "assign_directional_triangular_labels(g_triangle,3)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACTDklEQVR4nOzdd1iUR7sG8HuXpmAFa6yRJlVBEMSKNWo00Wjs0VhjiRUVO1YUERt2jRpLsPfYMMQCSJO6lF1ABSwoYEFAYHff84cHPokV2N3Z8vyuK9d3TtCZG6N4M++8MzyO4zgQQgghhBBSQXzWAQghhBBCiGqjQkkIIYQQQiqFCiUhhBBCCKkUKpSEEEIIIaRSqFASQgghhJBKoUJJCCGEEEIqhQolIYQQQgipFCqUhBBCCCGkUqhQEkIIIYSQSqFCSQghhBBCKoUKJSGEEEIIqRQqlIQQQgghpFKoUBJCCCGEkEqhQkkIIYQQQiqFCiUhhBBCCKkUKpSEEEIIIaRSqFASQgghhJBKoUJJCCGEEEIqhQolIYQQQgipFCqUhBBCCCGkUqhQEkIIIYSQSqFCSQghhBBCKoUKJSGEEEIIqRQqlIQQQgghpFKoUBJCCCGEkEqhQkkIIYQQQiqFCiUhhBBCCKkUKpSEEEIIIaRSqFASQgghhJBKoUJJCCGEEEIqhQolIYQQQgipFCqUhBBCCCGkUqhQEkIIIYSQSqFCSQghhBBCKoUKJSGEEEIIqRQqlIQQQgghpFKoUBJCCCGEkErRZh2AtbxCMR5k56FILIWuNh/NjQxgoKfxvyyEEEIIIV9NI5uTKDMXR0LSEJD0DGk5+eDe+xgPQFNDfbia18MIp6YwrV+dVUxCCCGEEJXA4ziO+/IPUw/pOflYeCYWt5OzoMXnQSL99Kde8vGOJnWwZoANmhjqKzApIYQQQojq0JhC6ReWhmXnBRBLuc8Wyf/S4vOgzedheX8rDHVsKseEhBBCCCGqSSMKpW+ACN7XhJUex62nGaa5msogESGEEEKI+lD7t7z9wtJkUiYBwPuaEMfC0mQyFiGEEEKIulDrQpmek49l5wUyHXPpeQHSc/JlOiYhhBBCiCpT60K58EwsxOXYL/k1xFIOC8/EynRMQgghhBBVpraFUpSZi9vJWeV6AedrSKQcbidnIflZrkzHJYQQQghRVWpbKI+EpEGLz5PL2Fp8Hg7fpb2UhBBCCCGAGhfKgKRnMl+dLCGRcggQPpPL2IQQQgghqkYtC+WbQjHS5PziTFp2PvIKxXKdgxBCCCFEFahloXyYnQd5H67JAXiQnSfnWQghhBBClJ9aFsoisVSt5iGEEEIIUWZqWSh1tRXzaaWIklBUVKSQuQghhBBClJU26wDy0NzIADxAro+9OY7Dz71docOTolWrVnB0dISDgwMcHR1hYWEBLS0tOc5OCCGEEKI81PYu787rA/BQji/mNK1dFes6VkV4eDjCw8MRFhaGxMREcBwHfX192Nvbw8HBobRkmpiYgM9XywVhQgghhGg4tS2UHucFOBTyUC5HB2nxeRjl1Awe/a3K/Pvc3Fzcu3evtGCGh4cjJSUFAFCzZk20adOmtGA6ODigWbNm4PHkc1YmIYQQQoiiqG2hFGXmosemW3Ib339WJ5jUq/7FH5eTk4OIiIjSghkeHo709HQAQJ06dcoUTEdHRzRs2FBumQkhhBBC5EFtCyUAjNoXgqDUbJmuUmrxeXBpYYRD45wqPMbTp0/LlMywsDA8e/buoPRvvvmmTMl0cHBAnTp1ZBWfEEIIIUTm1LpQpufko/vGmyiU4fE+etp8+M/qjCaG+jIbk+M4ZGRklCmY4eHhePnyJQCgefPmZVYx7e3tUbNmTZnNTwghhBBSGWpdKAHALywN7qdjZTbeuoE2GOLYVGbjfQrHcUhJSSnz0k9ERATy8t4dpm5mZlamZLZu3RoGBgZyz0UIIYQQ8l9qXygBwDdABO9rwkqPM7enOaa6msggUcVIJBIkJSWVWcWMjIxEYWEh+Hw+rKysyjwut7W1hZ6eHrO8hBBCCNEMGlEogXcrlcvOCyCWcuXaU8kDB11tLazob6WQlcnyKi4uhkAgKPO4PDY2FmKxGDo6OrC1tS1TMq2srKCtrZbHjxJCCCGEEY0plMC7PZULz8TidnIWtPi8zxbLko8Xp8fgkscotDZprMCklfP27VvExMSUKZkJCQmQSqWoWrUqWrduXeZxuZmZmczOyExPT8fWrVvRunVruLq60lvrhBBCiAbQqEJZQpSZiyMhaQgQPkNadn6ZG3V4AJoa6cPVrB76mtdADycbjBw5Er6+vqziysSbN28QGRlZ5nG5SCQCAFSvXh329vZlSua3335boTMyMzIyMGfOHNy7dw8PHjyAjo4OzMzM0LVrV/Tr1w8ODg6oXv3Lxy0RQgghRHVoZKF8X16hGA+y81AklkJXm4/mRgYw0PvfI+ENGzZg/vz5iImJgaWlJcOksvfy5UtERESUKZkPHz4EABgaGpa56cfBwQGNGjUqV8nMy8tDQkICAgMDceDAAURHR+P777/H+fPn5fUpEUIIIYQBjS+UX1JYWAgrKyuYm5vj0qVLrOPI3bNnzz44I/Pp06cAgAYNGsDR0RGnTp2Cjo7OJ8fgOA5SqbT0PvPQ0FC4u7tDKpViz549MDU1VcjnQgghhBDFoEL5FU6fPo2ffvoJV69eRc+ePVnHUSiO4/D48ePScpmZmYk9e/Z89udIJJLSMrl9+3asWrUKXbp0wcaNG1G/fn1wHEdXThJCCCFqhArlV+A4Dl26dEFOTg4iIyPpLenPeL8szpgxA/v378fChQvh5uYGbW1tKpOEEEKIGqJC+ZUiIiLg4OCAXbt2YeLEiazjKLXnz59j6tSpuH79Oo4ePYrevXuzjkQIIYQQOaJCWQ6jR4/GlStXIBKJUKNGDdZxlFJUVBRmzpyJjIwMnDlzBjY2NmUegb8vIyMDK1asKH3xx9ra+rN7MwkhhBCinGRz+KCGWL16NXJzc+Hp6ck6ilI6deoUJk6ciAYNGuDWrVulZfJjZ1xKpVJkZGTg7t27mDx5Muzt7VG9enU4Oztj2rRpOHjwIAQCASQSCYPPhBBCCCHlQSuU5eTh4YG1a9ciMTERzZs3Zx1HaaSkpKBjx454+vQpFi5ciOHDh6NJkyZfdeZkfn4+oqKiyrxZnpSUBAAwMDAoc0amg4MDTExMaB8mIYQQokSoUJZTXl4ezMzM0LFjR/j5+bGOozSKi4sREhKC69ev4+LFi0hMTERRURGaNm2Ktm3bolOnThgzZgyqVq36VeO9evUK9+7dK3NG5v379wEAtWrVQps2bcocxN6kSRO1LZlfOiuVEEIIYY0KZQUcPHgQY8aMQVBQENq1a8c6jtJ6+vQp7ty5A39/fyQkJODSpUuoVq1ahcfLysoqc0ZmeHg4Hj16BACoW7dumYLp4OCABg0ayOpTUbjS25ySniEt5yO3ORnqw9W8HkY4NYVpfbp5iBBCCFtUKCtAKpXC0dEROjo6CAoKktk92KT8Hj9+/MFB7FlZWQCARo0alSmZbdq0gZGREePEn1eR++Y7mtTBmgE2aGKor8CkhBBCyP9QoaygmzdvokuXLjh69CiGDRvGOg75fxzHIS0trUzBjIiIwKtXrwAALVq0KLOKaW9vrzRv7PuFpWHZeQHEUu6zRfK/tPg8aPN5WN7fCkMdm8oxISGEEPJxVCgrYeDAgQgPD0dSUtJX7w0kiieVSpGSklKmZN67dw/5+fng8XgwNzcvUzJbt24NfX3Frvb5BojgfU1Y6XHcepphmitdbUkIIUSxqFBWQnJyMiwtLeHh4YGFCxeyjkPKQSKRICEhocxLP1FRUSgqKoKWlhasrKzKvFlua2sLXV1duWTxC0uD++lYmY23bqANhtBKJSGEEAWiQllJc+bMwe7duyESiVT6JRACFBUVIS4urkzJjI2NhUQiga6uLmxtbcvsybSwsKj0NZzpOfnovvEmCsVSGX0WgJ42H/6zOtOeSkIIIQpDhbKSXrx4ARMTEwwcOBB79uxhHYfIWEFBAaKjo8s8Lk9MTATHcdDX14ednV2Zx+Wmpqbleklr1L4QBKVml2vP5Jdo8XlwaWGEQ+OcZDYmIYQQ8jlUKGVg69atmDFjBiIjI9GqVSvWcYic5ebmlp6RWVIyU1JSAAA1atRAmzZtypTM5s2bf/SMTFFmLnpsuiW3nP6zOsGkHh0pRAghRP6oUMpAcXExbGxs0LhxY1y/fl1tD9gmn5aTk4OIiIgyj8vT09MBAEZGRmUKpoODAxo1agSP8wIcCnko09XJElp8HkY5NYNHfyuZj00IIYT8FxVKGbl48SL69euHCxcu4Pvvv2cdhyiBzMzMMgUzLCwMz549AwA0bNgQ1YZ6o0ivptzmb2akj5turnIbnxBCCClBhVJGOI5Dz549kZ6ejtjYWOjo6LCORJQMx3HIyMhAWFgYgsMicYJzAuS4ms0DEOfRi65pJIQQInd0xYuM8Hg8bNiwAUKhEDt37mQdhyghHo+HJk2aYODAgRjzu5tcyyQAcAAeZOfJdQ5CCCEEoEIpU7a2thg3bhw8PDzw4sUL1nGIEiuS4TFByjAPIYQQzUaFUsZWrlyJoqIirFy5knUUosR0tRXzR09Xi/6IE0IIkT/620bGGjRogAULFsDX1xcikYh1HKKkmhsZQN5nAXAchw6tzdGpUydMnToVu3btQlBQEF6/fi3nmQkhhGgaeilHDgoKCtCyZUvY29vjzJkzrOMQJdV5fQAe5uTLbfw6VTgM0I5GbGwsYmJiIBQKIZFIAADNmzeHra0tbGxsYGNjA1tbW5iamlb65h9CCCGaiQqlnPz1118YPnw4AgIC0KVLF9ZxiBJS9DmUb9++RUJCQmnBjI2NRWxsLJ48eQIA0NPTg6WlZWnBLCmbDRo0oLNVCSGEfBYVSjnhOA7t2rVDUVERwsPDy3UdH9EMynJTTlZWVpmSGRMTA4FAgPz8d6underUKVMybW1tYWVlBX19uiucEELIO1Qo5Sg4OBguLi7Yv38/xowZwzoOUULKepe3VCpFampqmZIZGxuL5ORkcBwHHo8HY2PjMiXTxsYGLVq0gJaWlsw+F0IIIaqBCqWcDR06FLdu3YJIJIKBgQHrOETJpOfko/vGmyiU4fE+etp8+M/qjCaGsl9BzMvLQ3x8/AcrmllZWQCAqlWrwtra+oMVzTp16sg8CyGEEOVBhVLOHjx4gJYtW2L+/PlYvnw56zhECfmFpcH9dKzMxls30AZDHJvKbLwv4TgOmZmZH5TM+Ph4FBYWAnh3+sF/XwKysLBAlSpVFJaTEEKI/FChVIAFCxZg8+bNEAqFaNy4Mes4RAn5BojgfU0IcFylbtCZ29McU11NZJis4sRiMUQiUenLPyVl8/79+wAALS0tmJmZlSmZNjY2aNasGe05JoQQFUOFUgFev34NU1NTfPfddzh48CDrOERJrT1+C9tDs6ClowuuPKdUSiXQ09XBiv5WCl2ZrKjc3FzExcWVedM8JiYGL1++BABUr14d1tbWH+zPrFWrltwyXb58GXv37kXXrl3h7OwMW1tb6OjoyG0+QghRN1QoFWT37t2YNGkSwsLC4ODgwDoOUTLFxcXvfl9UM4L1r2sQmJINLT7vsy/rlHy84H4kfncywuJZkxWYWLY4jsOjR48+KJmJiYkoLi4GADRu3PiDkmlubg5dXd1Kzx8dHQ0vLy8kJycjKSkJr1+/Rq1atWBnZ4eePXuiZ8+esLOzq/Q8hBCirqhQKohYLIadnR1q166Nmzdv0rl+pIzVq1dj2bJlCAsLg52dHUSZuTgSkoYA4TOkZefj/T+kPABNjfThalYPI52bYv0SNxw/fhxCoRB169Zl9SnIRVFREZKSkj44OzM9PR0AoKOjg5YtW37wElCjRo0q9WcsJycHYWFhmDVrFhITE+Hj44OZM2fK6LMihBD1Q4VSga5fv46ePXvi5MmT+Omnn1jHIUoiMTERrVq1wqxZs7B27doPPp5XKMaD7DwUiaXQ1eajuZEBDPT+d6PN8+fPYWpqiqFDh2Lnzp2KjM7MixcvPnhsHhsbi9zcXABArVq1PiiZNjY2qFat2mfHLS4uLn3UvXDhQpw9exbjx4/HjBkz6DgkQgj5DCqUCta3b18kJiYiPj4eenp6rOMQxqRSKTp37ozMzExER0ejatWqFRpny5YtmDlzJiIiIjT20SzHcXj48OEHZ2cmJSVBKpWif//+OHfu3Cd/vkQigZaWFoqKijB8+HAEBgbCx8cHw4YNU+BnQQghqokKpYIlJCTAxsYGa9euhZubG+s4hLHt27dj6tSp+Pfff9G5c+cKj1NcXIzWrVvD0NAQt27doi0V7ym5chIAbG1tP7vS+PTpUwwZMgQPHjzAiRMn0LZtW0XFJIQQlUaFkoFp06bh0KFDSE5OVrs9b+Trpaenw9LSEsOHD8euXbsqPZ6/vz969OiBo0eP0qpaBURGRmLChAkoLi7G33//jUaNGkEqldIRRoQQ8hWoUDKQlZUFExMTjBw5Er6+vqzjEAY4jkO/fv0QGRmJ+Ph41KxZUybjDhw4EKGhoUhKSqKbmcrh0qVLcHNzQ5MmTXDs2DHUrl37k2VSIpEgIiICly9fLt2f2aJFCyqehBCNRl8BGahTpw6WLFmCnTt3Ij4+nnUcwoCfnx8uXbqE7du3y6xMAsCGDRuQlZUFT09PmY2p7nbv3g13d3f069cPf//9d2mZ5PF4+NT324mJifD19cVPP/0EU1NTVK9eHW3btsX48eOxefNmBAQElF5HSQghmoBWKBkpLCyElZUVzM3NcenSJdZxiAJlZWXBwsICrq6uOH78uMzHX7JkCdavX4/4+Hi0aNFC5uOrk4SEBLRv3x4vX77ElClT0Lt3bxgbG8PY2PiLB5uXXDn537MzP3XlZMn/avqVk186tYAQopqoUDJ0+vRp/PTTT7h69Sp69uzJOg5RkFGjRuHSpUtISEhA/fr1ZT5+Xl4eWrZsCQcHB5w5c0bm46sTsViM6Oho3LlzB9euXUNMTAyePn0KbW1tNGnSBHZ2dtixYwcMDQ3LNWbJlZPvl83/Xjn537vNmzVrprYvU5Weq5r0DGk5HzlX1VAfrub1MMKpKUzrV2cVkxBSCVQoGeI4Dp07d0ZOTg6ioqKgrU3fpau7K1euoHfv3ti/fz/GjBkjt3n8/PwwbNgwXLt2DT169JDbPOrq/v37CA0NRVxcHJYuXSqTaxhfv34NgUDwwbFG7185WVIwFXXlpLyl5+Rj4ZlY3E7O+uqbnzqa1MGaATZoYqivwKSEkMqiQslYeHg4HB0dsWvXLkycOJF1HCJHubm5sLa2hrm5Oa5evSrX1aiSb1aysrIQHR1N91Irqf9eOVnyv+9fOdmkSZMPDmk3NzdX+v+mfmFpWHZeALGU+2yR/C8tPg/afB6W97fCUBW4m54Q8g4VSiUwevRoXLlyBSKRCDVq1GAdh8jJ9OnTsW/fPsTFxeHbb7+V+3xRUVFo06YNfHx8MGPGDLnPR2TnY1dOxsTEICMjA8D/rpz87/7Myl45KSu+ASJ4XxNWehy3nmaY5moqg0SEEHmjQqkEMjIyYGZmhhkzZtDbuWoqODgY7du3x4YNGzBr1iyFzTt58mT89ddfEIlEdOapGvjvlZMxMTGIi4srvXKydu3aHzwyt7a2RvXqituX6BeWBvfTsTIbb91AGwyhlUpClB4VSiXh4eGBtWvXIjExEc2bN2cdh8hQYWEh7OzsUK1aNQQHByv0TuisrCyYmppi8ODB2L17t8LmJYrzpSsnAeDbb7/94CUgExMTme/bTs/JR/eNN1EolspsTD1tPvxndaY9lYQoOSqUSiIvLw+mpqbo1KkT/Pz8WMchMrRs2TKsWbMGERERsLW1Vfj8vr6+mD59OsLCwtCmTRuFz0/YKLly8r+PzZ8+fQoA0NPTg5WV1QcrmvXr16/wY/NR+0IQlJpdrj2TX6LF58GlhREOjXOS2ZiEENmjQqlEDhw4gF9//RWBgYFwcXFhHYfIQFxcHOzt7TF//nysXLmSSQaxWAw7OzvUqFEDd+7cUYo9doSd58+flx5lVFIyBQIB8vPzAQB169b94CUgS0tL6Ot/foVQlJmLHptuyS23/6xOMKlHRwoRoqyoUCoRqVQKR0dHaGtrIzg4mK5yU3ESiQTt27fHq1evEBUVBT09PWZZ/vnnH3Tr1g2HDx/GiBEjmOUgykkikSA1NfWDszOTk5PBcRx4PB5MTEw+eAno/SsnPc4LcCjkoUxXJ0to8XkY5dQMHv2tZD42IUQ2qFAqmZs3b6JLly44evQohg0bxjoOqYRNmzZh9uzZuH37Ntq3b886DgYNGoTg4GAkJSWhWrVqrOMQFZCXl4f4+PgPbgMquVZSX18f1tbWsLGxQViD7/FKIr+jjJoZ6eOmm6vcxieEVA4VSiU0cOBAhIeHIykpCVWrVmUdh1TA/fv3YW1tjV9//RW+vr6s4wAAHjx4AAsLC8yaNQtr1qxhHYeoqP9eORkTE4OY+CTkdFss1+0UPABxHr3omkZClBQVSiUkEolgZWUFDw8PLFy4kHUcUk4cx6FXr15ITEyEQCBQ6JEtX7Js2TKsXbsW8fHxMDY2Zh2HqAnB41fou/WO3Oe59HsHWH1TU+7zEELKjzbpKSFTU1NMmzYNnp6epW9kEtVx6NAhXL9+HTt37lSqMgkA8+fPR/369TF79mzWUYgaKZLhMUHKMA8hpPyoUCqpJUuWQFdXF0uWLGEdhZTDs2fPMGvWLAwfPhx9+vRhHecD+vr68Pb2xvnz53H16lXWcYia0NVWzF8lipqHEFJ+9KdTSdWuXRseHh7Yt28foqOjWcchX2n69Ong8XjYtGkT6yifNHjwYHTu3BkzZ84svS+akMpobmQAeR9Gxfv/eQghyokKpRL77bffYGZmhjlz5oC2uiq/Cxcu4NixY9i8ebNSX3PI4/GwZcsWCIVCpXlhiKg2Az1tNJXzTTZNjfTphRxClBgVSiWmo6MDb29v5Obm4uXLl6zjkM949eoVJk+ejN69e2P48OGs43yRra0tfvvtN3h4eCAzM5N1HKIGXM3rQYsvn3VKLT4Prmb15DI2IUQ26C1vJVdyqLBYLJb5vbtEdiZPnozDhw9DIBCgadOmrON8lezsbJiammLgwIHYu3cv6zhExdFNOYRoNlqhVHIl57pRmVRet27dws6dO+Hp6akyZRIAjIyMsGrVKvzxxx8ICwtjHYeoONP61dHRpI7MVym1+Dx0NKlDZZIQJUcrlIRUwtu3b9GqVSvUqVMHt2/fVrnrMsViMezt7WFgYIDAwECVy0+US3pOPrpvvIlCGR7vo6fNh/+szmgi5z2ahJDKob891ERcXByeP3/OOobGWbFiBR48eIC9e/eqZBnT1tbGli1bcPfuXRw5coR1HKLimhjqY7mM79te0d+KyiQhKoBWKNXEmDFjULt2bWzcuJF1FI0RFRUFBwcHLFu2TOXPCx0yZAhu3boFoVCodIexE9XjGyCC9zUhwHFAJa5jnNvTHFNdTWSYjBAiL6q3pEJKlXwvcO/ePZw6dQq2traME2kOsViMcePGwcLCAvPnz2cdp9LWr1+PV69eYfXq1ayjEDUwzdUUo8z4kIqLwEf51iz4vHePudcNtKEySYgKoUKpYqTS/+1NKnlh588//4SDgwNGjRrFKpbG2bhxI6KiorBv3z7o6uqyjlNpTZs2hbu7O3x8fCASiVjHISruzZs3OLR8Mr6NPwwXk3dnsn7pZZ2Sj2tnp+D6zE4Y4qg6L7gRQuiRt8p49OgRcnNz0bJlS+Tl5cHAwABisRiPHj1Cr169sGHDBvTt27f0x5ccN0RkLzk5GTY2Npg8eTJ8fHxYx5GZgoICWFhYwMbGBhcuXGAdh6iwmTNnYvfu3YiLi0OLFi0gyszFkZA0BAifIS07v8yaJQ/vDi13NauHFtwjjP6xF86ePYsffviBVXxCSAVQoVQRCxcuhI+PDxo2bIhq1apBS0sLFhYWyM7ORmxsLObPn48OHTqAx+PB2NgYtWrVYh1ZLXEch27duuHBgweIjY2FgYF6XQV36tQpDBo0CH///Td69+7NOg5RQXfv3oWLiwvWr1+POXPmfPDxvEIxHmTnoUgsha42H82NDMrcgNOtWzdkZmYiOjoaWlpaioxOCKkEKpQqori4GElJSYiPj4dYLEZ6ejqePHmCLVu2wNzcHLVq1UJ0dDQaNGiAtLQ0+Pj4YPr06axjq529e/diwoQJuHbtGnr06ME6jsyVFOZHjx4hNjZWLR7nE8UpKiqCvb09qlSpgrt371bo/NyQkBA4Ozvjzz//pG08hKgQKpQqbOLEiXj48CFOnTqF4uJi5OXloaCgAM+fP8fz58/pkZGMPX78GJaWlvjxxx9x4MAB1nHkJjY2FnZ2dli7di3c3NxYxyEqZMWKFVi5ciXCw8PRqlWrCo8zYMAAREVFISkpib6pIURFUKFUMSV7I2NjY+Hq6op169Zh3Lhxpf+e9k7Kz8CBAxEYGIiEhAQYGhqyjiNXv//+Ow4ePAihUIgGDRqwjkNUQHx8PFq3bo25c+dW+rQAgUAAGxsbbNmyBdOmTZNRQkKIPFGhVFHu7u64d+8erl27xjqKRijZW3js2DH8/PPPrOPIXU5ODszMzNCvXz/s37+fdRyi5CQSCTp27IicnBxERUWhSpUqlR5z9OjRuHr1KlJSUtRurzIh6oiODVJBoaGh2Lx5M0aOHAng3RdzIj8vXrzAtGnT0L9/fwwePJh1HIUwNDTEqlWrcODAAYSGhrKOQ5Tc9u3bERwcjD179sikTALA8uXLkZOTg82bN8tkPEKIfNEKpQpKTEzEiBEjEBERwTqKRhg3bhxOnjyJ+Ph4NGrUiHUchZFIJGjTpg309PQQHByskldLEvl7+PAhrKys8Msvv2D79u0yHXv69On4888/kZqaqvbbTAhRdfQ3hApq2bIlzpw5U+bficViRmnU240bN/DHH3/Ay8tLo8okAGhpaWHr1q0IDQ3FoUOHWMchSojjOPz222+oVasW1q5dK/PxFy1aBLFYDC8vL5mPTQiRLVqhVBNCoRALFy7EkSNHoKenxzqOWsjPz4eNjQ0aN26MgIAAjV2hGzZsGAICAiAUClGjRg3WcYgSOXz4MEaNGoXz58+jX79+cplj8eLF8PHxQUpKCho2bCiXOQghlaeZf0OqIYlEgrNnz2Lr1q2so6iNO3fu4NmzZ9izZ4/GlkkA8PLywuvXr7Fq1SrWUYgSef78OWbOnIkhQ4bIrUwCgJubG6pUqYKVK1fKbQ5CSOXRCqUamTZtGg4dOoTk5GTUrVuXdRyVJ5VK8eLFCxgZGbGOwtyqVauwYsUKxMXFwczMjHUcogRGjBiBK1euICEhAfXq1ZPrXF5eXli0aBESExNhbGws17kIIRVDhVKNZGVlwcTEBCNGjMC2bdtYx1F6Fy5cgK2tLZo1a/bJH0Pner5TUFAAS0tLWFpa4tKlS6zjEMYuXbqE77//HgcPHsQvv/wi9/ny8/NhYmKCrl274vDhw3KfjxBSfpr7HE8N1alTB0uWLMGuXbsQHx/POo5SKy4uxtKlS/HXX38BeFccP4bK5DtVq1aFj48P/v77byqUGi43NxeTJ09Gz549FXY1or6+PpYuXYqjR48iJiZGIXMSQsqHVijVTGFhISwtLdGyZUv6i/8zOI6Du7s7Lly4gNDQUBgYGFB5/AKO49CjRw+kpaUhNjaWXv7SUNOmTcOBAwcQFxeH5s2bK2ze4uJiWFhYwMLCAhcuXFDYvISQr0MrlGpGT08PXl5e+Pvvv+kWnc/g8XiYO3cuOI5DZGQklcmvwOPxsHnzZqSmptJh0xoqMDAQ27dvx+rVqxVaJgFAR0cHK1aswMWLFxEYGKjQuQkhX0YrlGqI4zh07ty59Bo0bW1t1pGU1i+//IInT57g77//hpaWFng8HpXLL5gxYwb++OMPCIVCOsZFg7x9+xZ2dnaoWbMmAgMDoaWlpfAMUqkUdnZ2qFWrFv7991/6s0qIEqEVSjXE4/Hg4+MDgUCAffv2sY6jVNLS0pCXlwehUIiCggJ06tQJ2dnZSExMBJ/PB4/Ho6ssv8DDwwNVqlSBu7s76yhEgVavXo2UlBTs3buXSZkEAD6fjzVr1uDWrVu4evUqkwyEkI+jFUo1Nnr0aFy+fBnJycl0IDWAmzdvYvjw4eA4DmKxGNWrV0d+fj4yMzNhZ2eHqVOnYuzYsQDerYRo8tmTX7J7925MmjQJwcHBcHZ2Zh2HyFlsbCzs7e2xcOFCLF++nGkWjuPQsWNH5OfnIzw8nP6cEqIkqFCqsYyMDJiZmWHGjBnw9PRkHYe5oKAgvHz5Enp6emjQoAGeP38OU1NTREVF4cqVK/D394ednR2WLFkCCwsL1nGVmkQigaOjI7S1tXH37l36S12NSSQSuLi4IDc3F5GRkUrxMtbt27fRqVMnHDt2DD///DPrOIQQUKFUe8uWLcO6deuQmJio8E30qiQjIwOXLl3CyZMnIRAIEBAQAHNzc9axlNqdO3fQsWNH/PHHH/j1119ZxyFysnHjRsyZMweBgYFo164d6zil+vTpg5SUFAgEAtonTogSoEKp5vLy8mBqaopOnTrBz8+PdRyl8akDywMCApCSkoLx48czSKV6RowYAX9/fwiFQtSsWZN1HCJj9+/fh7W1NcaNG4ctW7awjlNGZGQk7O3tsWfPHvrzSogSoEKpAQ4cOIBff/0VgYGBcHFxYR1HKb1fMOl2nK+XkZEBc3NzTJ48Gd7e3qzjEBniOA49e/aEUCiEQCBAtWrVWEf6wNChQxEYGAihUIiqVauyjkOIRqONTxrgl19+gb29PWbNmgWpVMo6jlLi8Xilt+VQmfx6jRs3xqJFi7B582YkJiayjkNk6ODBg/D398fOnTuVskwCwMqVK/HkyRNs376ddRRCNB6tUGqIf//9F66urjhy5AiGDx/OOg5RI2/fvoWVlRVMTU1x+fJlKuRqIDMzExYWFujTp4/S3509ceJEnD59GqmpqXSaBSEM0QqlhujSpQt+/PFHuLu7o6CggHUcpp4+fQoAtForI1WqVIGPjw+uXr2Kixcvso5DZGD69OnQ0tLCpk2bWEf5oqVLlyIvLw8bNmxgHYUQjUaFUoN4eXnh6dOn2LhxI+sozBQWFqJbt26YOHEiraTJUP/+/dGzZ0/MmjULhYWFrOOQSjh//jyOHz+OzZs3o06dOqzjfFHjxo0xbdo0+Pj44Pnz56zjEKKxqFBqEFNTU0ybNg2enp6lq3SaxtPTE0KhENOmTaNCKUM8Hg+bNm3Cw4cPNfobFlX36tUrTJ48GX369MGwYcNYx/lq7u7upbfoEELYoEKpYZYsWQJdXV0sWbKEdRSFEwgEWLNmDebPnw9bW1vWcdSOhYUFfv/9d6xatQqPHj1iHYdUwPz58/H69Wvs2LFDpb7hMjIygpubG7Zv3460tDTWcQjRSPRSjgbaunUrZsyYgcjISLRq1Yp1HIWQSCRo3749Xr58iaioKFSpUoV1JLX08uVLODg4wNfXF9999x3rOKQcbt68iS5dusDX1xdTp05lHafccnNzYWxsjH79+mHfvn2s4xCicahQaqDi4mLY2NigUaNG8Pf3V6mViIravHkzZs6cidu3b6NDhw6s46i1t2/fQkdHB1paWqyjkK9UUFCAVq1aoV69erh165bKXqW5efNmzJ49GwKBAC1btmQdhxCNQoVSQ128eBH9+vXDhQsX8P3337OOI1cPHjyAlZUVxowZg23btrGOo/boYHjVs2DBAvj4+CAqKkql77EvLCyEmZkZ2rZtixMnTrCOQ4hGoUKpoTiOQ48ePZCRkYHY2Fjo6OiwjiQXHMfhu+++Q3x8PAQCAZ1TR8h/REZGwtHREcuWLVOLvdX79+/H2LFjERYWBgcHB9ZxCNEYVCg1WExMDFq3bo3Nmzfj999/Zx1HLg4dOoRffvkFFy9eRN++fVnHIf/v/PnzsLOzQ5MmTVhH0WhisRhOTk4oKipCREQEdHV1WUeqNLFYDBsbGzRp0gTXrl1jHYcQjaGaG2WITNja2mLcuHHw8PDAixcvWMeRuWfPnmHmzJkYNmwYlUkls3PnTrouTwls3LgRUVFR2Ldvn1qUSQDQ1tbGqlWrcP36dQQEBLCOQ4jGoBVKDff06VOYmppiwoQJ8PHxYR1HpoYNG4br168jISEBdevWZR1H45XsrQwICMAPP/yAU6dOoUePHqxjaazk5GTY2Nhg8uTJavdnn+M4tG3bFlpaWggODqY9vYQoABVKgjVr1sDDwwMCgQCmpqas48hEyUtHhw4dwsiRI1nHIe8ZOnQoXr9+jQsXLtCb4IxwHIdu3brhwYMHiI2NhYGBAetIMufv748ePXrg7Nmz+OGHH1jHIUTtUaEkKCgoQMuWLWFvb48zZ86wjlNpr1+/hpWVFWxsbHDp0iVanWAgLS0NL168gKWlJXJzc2FoaIiCggI8evQIgwYNwq5du+Dk5FT64+nNcMXau3cvJkyYgOvXr6N79+6s48hNt27dkJmZiejoaPrmhRA5o0JJAAB//fUXhg8fjoCAAHTp0oV1nEqZMmUK/vzzTwgEAjRr1ox1HI20ZMkSeHl5oU6dOtDX10dxcTEsLCyQnp6OBw8eYPz48WjTpg10dXXRtGlT2NraquUqmTJ6/PgxLC0tMWDAAOzfv591HLkKCQmBs7Mz/vzzT4waNYp1HELUGhVKAuDdClG7du1QVFSEsLAwlf1u/vbt2+jUqRO2bNmitm+uqwKpVIrU1FSIRCJwHIenT5/iwYMHWLVqFTp06ABDQ0OEhobCyMgICQkJcHd3x6pVq1jH1ggDBw5EYGAgEhISYGhoyDqO3A0YMADR0dFITExUmxePCFFGVChJqaCgILRv3x779+/HmDFjWMcpt7dv36JVq1YwMjLC7du3VbYUq6vJkyfj0aNHOH/+PKRSKcRiMYqKisBxHJKSkujMQAU4ffo0fvrpJxw7dgw///wz6zgKIRAIYGNjg61bt6rklZKEqAoqlKSMoUOH4tatWxAKhahWrRrrOOWyaNEieHt7IzIyEpaWlqzjEPxvb2RMTAw6deoELy8vTJw4ERKJBFpaWqX/S+SvZE9r27ZtcfbsWY3aszp69GhcvXoVKSkptLWCEDmhcyhJGWvXrkVOTg7Wr1/POkq5REdHw8vLC4sWLaIyqURKSsupU6fg6OiIiRMnAkBpiaQyqThz585Ffn4+tm/frlFlEgCWL1+OnJwcbN68mXUUQtQWrVCSDyxYsACbN2+GUChE48aNWcf5IrFYDGdnZxQWFqrNbR/qJDY2Fi4uLti0aRPGjRsHqVQKPp++l1Wkf/75B926dcPOnTsxadIk1nGY+P3333Ho0CGkpqZqxN5RQhSNCiX5wOvXr2FqaopevXrhzz//ZB3ni7y9vTFv3jwEBweXOYqGKIeXL1/iu+++w7Vr1+gudQby8/NhY2ODxo0bIyAgQGPLfGZmJoyNjTFt2jSsXbuWdRxC1I5mfmUhn1WjRg2sXLkShw4dQnh4OOs4n5WSkoKlS5dixowZVCaVVK1atXDhwoUPyiTHcZBIJIxSaY5ly5bh0aNH2LNnj8aWSQCoX78+Zs6ciS1btuDJkyes4xCidmiFknyUWCyGnZ0datWqhVu3binlniuO49C9e3ekpqYiLi6ONturEKlUikWLFqGwsFDtrv1TNjdu3EBSUhKmTJnCOgpzL1++RIsWLTB06FC6S54QGdPcb1fJZ2lra2PDhg24c+cOTp8+zTrOR/3xxx/4559/sGvXLiqTKobP56N27drYsmULBAIB6zhqrXPnzpg8eTLrGEqhVq1acHd3x549e5CSksI6DiFqhVYoyWf17dsXiYmJiI+Ph56eHus4pZ48eQILCwv88MMPOHjwIOs4pAIKCwthY2ODpk2b4vr160q5Cq4KLl68CBsbG7oV6ivl5+fDxMQEXbt2xeHDh1nHIURt0Aol+Sxvb288fPgQW7duZR2ljGnTpkFXV5cel6owPT09bNy4ETdu3MDZs2dZx1FJxcXFWLRoEfz8/AC82wZCPk9fXx9Lly7F0aNHERsbyzoOIWqDVijJF02bNg2HDh1CcnIy6tatyzpO6W0ffn5+GDJkCOs4pJL69u2L+Ph4xMfHo2rVqqzjqBSO4zB//nxcunQJoaGh0NfXp5Xer1Byt7ylpSXOnz/POg4haoFWKMkXLVu2DDweDx4eHqyj4MWLF5g6dSr69eunMVfHqbuNGzfi0aNH2LBhA+soKofH42HevHmQSqWIjIykMvmVdHR0sGLFCly4cAGBgYGs4xCiFmiFknwVb29vuLu7IyYmhulNNOPHj8fx48cRHx+vEoeuk68zb948+Pr6IikpCU2aNGEdR+WMGjUKT58+xd9//w0tLS3weDwql18glUpLT7L4999/6deLkEqiFUryVX7//Xc0a9YMbm5uzDL8888/2LdvH7y8vKhMqpnFixejRo0amDt3LusoKiEtLQ15eXkQCoUoKChA586dkZ2djaSkJPD5fPB4PDrj8wv4fD7WrFmDW7du4erVq6zjEKLyaIWSfLVTp05h0KBBuHLlCnr16qXQuem2D/V38OBBjBkzBjdv3kSnTp1Yx1FaN2/exPDhw8FxHMRiMapXr478/HxkZmbCzs4OU6dOxdixYwGArrn8Ao7j0LFjR+Tn5yM8PJx+rQipBCqU5KtxHIfOnTsjJycHUVFR0NbWVtjc8+bNw5YtWxATEwMzMzOFzUsURyqVwsXFBW/fvkVERAS0tLRYR1JKgYGBePXqFXR1ddGgQQNkZWXBxMQE0dHRuHLlCvz9/WFnZ4clS5bAwsKCdVyld/v2bXTq1AnHjh2jfdmEVAIVSlIu4eHhcHR0xM6dOzFp0iSFzBkREYG2bdti1apVWLBggULmJGyEhobCyckJO3bswG+//cY6jsrJyMjAxYsXcerUKQgEAgQEBMDc3Jx1LKXXp08fpKSkQCAQKPQbZULUCRVKUm6//PILrly5guTk5A/uZ5a14uJiODo6gsfjITQ0FDo6OnKdj7A3duxYnDt3DiKRCIaGhqzjKDWO4z76MklAQABSUlIwfvx4BqlUT2RkJOzt7bFnzx76NSOkgqhQknLLyMiAmZkZpk+fjrVr18p1Lk9PTyxevBihoaFo06aNXOciyuHp06cwMzPD6NGjle5AfWX3fsH8VNkkHzd06FAEBgZCJBKhSpUqrOMQonJoBzIpt8aNG2Pu3LnYuHEj7t+/L7d5kpKSsHz5csyZM4fKpAZp0KABli1bhu3bt9NNJuXE4/FKb8uhMlk+K1euxJMnT7B9+3bWUQhRSbRCSSokLy8Ppqam6NixI44dOybz8aVSKbp06YLHjx8jJiYG+vr6Mp+DKK+ioiLY2trim2++wY0bN6gcfQK9xS1bEydOxOnTp5Gamir37TyEqBv6SkQqxMDAAGvWrMHx48cRFBQk8/F3796N27dvY8+ePVQmNZCuri42bdqEgIAAnDp1inUcpVNUVIQFCxYgLy+P7u+WoaVLl+LNmzd0axMhFUArlKTCpFIpHBwcoKOjg+DgYJmtlGRkZMDS0hJDhgzBnj17ZDImUU39+vVDTEwMEhIS6BuL96xYsQIrVqxAZGQkbGxsWMdRK3PnzsXOnTuRmpqKunXrso5DiMqgFUpSYXw+Hz4+PggNDYWfn59MxuQ4DlOmTEG1atWwfv16mYxJVNfGjRvx9OlT+r3wnvj4eKxatQrz5s2jMikH7u7upbfoEEK+Hq1QkkobMGAAIiIikJSUhKpVq1ZqrGPHjmHo0KE4ffo0BgwYIKOERJW5u7tj8+bNSExMRLNmzVjHYUoqlaJjx47IyspCdHQ0vY0sJytXrsSqVauQkpJC17wS8pWoUJJKE4lEsLKywrJly7Bo0aIKj5OdnQ0LCwt06tQJJ0+elGFCospyc3Nhbm6ODh064Pjx46zjMOXr64vff/+drqeUs9zcXOzfvx+TJ0+ms28J+UpUKIlMzJ49G7t370ZycjIaNGhQoTFGjx6N8+fPIyEhocJjEPV06NAh/PLLLwgICECXLl1Yx2EiLS0NVlZWGDlyJHbs2ME6jtqjN+gJKR8qlEQmXrx4ARMTEwwcOLBCL9JcvXoV3333Hfbt24exY8fKISFRZVKpFB06dMCbN29w7949jbsej+M49O3bFzExMYiPj6cjbQghSocKJZGZrVu3YsaMGYiMjESrVq1K/31eoRgPsvNQJJZCV5uP5kYGMND7XyF48+YNrK2tYWJiguvXr9OZg+SjwsPD0bZtW/j6+mLKlCms4yjUkSNHMHLkSJw7dw79+/dnHYcQQj5AhZLITHFxMWxsbNCoUSPsOHIGR0PTEZD0DGk5+Xj/NxkPQFNDfbia18MIp6bY5rkEu3fvRmxsLIyNjVnFJypg/PjxOH36NEQiEYyMjFjHUYjnz5/DwsIC3bp1k8slAqRy3r59Sy9HEQIqlETGDpy8iPknI1H1W3to8XmQSD/926vk4wX3IzHJrjpWzJ+hwKREFT179gympqYYOXIktm3bxjqOQowcORJ///03EhISUL9+fdZxyHu8vLyQmZlJB6ETAjqHksiQX1gaPKO1ULV5awD4bJl8/+NVm9ni2Bsz+IWlyTsiUXH16tWDh4cHdu7ciejoaNZx5O7y5cs4cuQINm7cSGVSyTx79gx//PEHioqKIJVKWcchhDlaoSQy4Rsggvc1YaXHcetphmmupjJIRNRVcXExbG1tUb9+fQQEBKjtntvc3FxYWVnBwsICV65cUdvPUxVIJBJoaWmB47jS/w4HDhzAxo0b8c8//2jM9gtCPodWKEml+YWlyaRMAoD3NSGO0Uol+QwdHR1s3rwZN2/exIkTJ1jHkZuFCxciOzsbu3btojLJyPPnz/Ho0aMPymRmZiY8PDzw008/wcjICBKJhHFSQtijFUpSKek5+ei+8SYKxbJ75KOnzYf/rM5oYkh3N5NP++GHHxAZGYnExES1u+c7KCgIHTp0gI+PD2bOnMk6jsaaO3cuduzYATMzM9SuXRt169aFqakpioqKcPXqVWzZsgWdOnVCYWEh9PT0WMclhCkqlKRSRu0LQVBq9hf3S5aHFp8HlxZGODTOSWZjEvWTkpICS0tLuLu7Y/ny5azjyExhYSHs7OxQvXp1BAUFQUtLi3UkjZWbm4vo6GiEhoaioKAASUlJyM/Px+nTp1GlShU0a9YMr1+/hrGxMXR0dLB27Vo4Ojqyjk0IE5p1OjCRKVFmLm4nZ8l8XImUw+3kLCQ/y4VJveoyH5+oB2NjY8yZMwdeXl749ddf0bx5c9aRZGL16tUQiUS4d+8elUnGqlevjg4dOqBDhw6l/27cuHGws7PD3r17kZ+fj9TUVOTk5CAiIgLBwcFUKInGohVKUmEe5wU4FPJQpquTJbT4PIxyagaP/lYyH5uojzdv3sDc3Bzt2rVTi/vfY2NjYW9vjwULFmDFihWs45D/V7J/MikpCd27d8fatWsxYsSID36cWCzWuFucCClBhZJUWOf1AXiYky+38ZsZ6eOmm6vcxifqoeQWmRs3bqBr166s41SYRCJB+/bt8fr1a0RGRtKePCU0efJkiEQi+Pv7f/Cx91/aIUQT0VvepELeFIqRJscyCQBp2fnIKxTLdQ6i+oYPHw4XFxdMnz4dYrHq/n7ZunUrQkNDsXfvXiqTSujatWvYv38/Jk+eDAAfnD1JZZJoOiqUpEIeZudB3kvbHIAH2XlynoWoOh6Ph61btyI+Ph47duxgHadC7t+/j0WLFmHq1KlwcXFhHYd8RGZmJpycnPDTTz8BAPh8+uuTkPfRI29SIZFpLzBgR5Dc5zkz2QV2TWvLfR6i+iZOnIgTJ05AJBKhTp06rON8NY7j0KtXLyQmJkIgEKB6dXoRTVnFxMTA1tYWwLv/biX/0MtThNAKJakgXW3F/NYRJSWguLhYIXMR1bZ69WpwHIfFixezjlIuf/75J65fv45du3ZRmVRyJWWyxPLlyzF79mxGaQhRLlQoSYU0NzKAvHcMcRyHoX27oUaNGujYsSPmz5+Ps2fPIjMzU84zE1VUt25dLF++HLt370ZkZCTrOF8lMzMTs2bNwogRI9C7d2/WcUg58Hg8GBgYYPv27UhJSWEdhxDm6JE3qTB5v+Xd1LAqvDrqIzg4GEFBQQgODsajR48AAN9++y3atWsHFxcXtGvXDra2tnRcB0FxcTFat24NQ0ND3Lp1S+lflBgyZAhu3LiBhIQE1K1bl3UcUk75+fkwMTFB165dcfjwYdZxCGGKCiWpMBbnUKanpyM4OLj0n3v37qG4uBj6+vpwdHREu3btSv+hv6A1k7+/P3r06IG//voLQ4cOZR3nk86fP48ffvgBhw8f/uiZhkQ17Ny5E1OmTEF0dDRsbGxYxyGEGSqUpMJEmbnosemW3Mb3n9XpizflvH37tvSGipJ/njx5AgAwMTEpUzCtra1pFVNDDBw4EKGhoUhKSoKBgQHrOB949eoVrKysYGtri0uXLin9Sir5tOLiYlhYWMDS0hLnz59nHYcQZqhQkkpRtru8OY5DWlpa6SPy4OBgREVFQSwWw8DAAE5OTqUF09nZGUZGRjLLTZTH/fv3YWFhgblz52LlypWs43xg8uTJOHz4MAQCAZo2bco6Dqmko0ePYsSIEQgMDKRjn4jGokJJKiU9Jx/dN95EoVj65R/8lfS0+fCf1RlNDPVlMl5+fn7pKmZJ0Xz27BkAwMzMrMxeTEtLSzoCRE0sWbIE69evR3x8PFq0aME6Tqlbt26hc+fO2Lp1K6ZNm8Y6DpEBqVQKOzs71K5dGwEBAbTiTDQSFUpSaX5haXA/HSuz8dYNtMEQR/mt2nAch/v375d5TB4dHQ2JRILq1at/sIpZuzadg6mK8vLy0LJlSzg6OuL06dOs4wB4t0WjVatWqFOnDm7fvk2HY6uRS5cu4fvvv8eVK1fQq1cv1nEIUTgqlEQmfANE8L4mrPQ4c3uaY6qriQwSlU9eXh7CwsLKlMysrCwAgIWFRZm9mBYWFlQEVISfnx+GDRuG69evo3v37qzjYOHChdiwYQMiIyNhaWnJOg6RIY7j0LFjR+Tn5yM8PJy+RhCNQ4WSyIxfWBqWnRdALOXKt6eSk0JPRxsr+lvJdWWyPDiOQ3JycpmCGRsbC6lUipo1a8LZ2bm0YDo5OaFmzZqsI5OP4DgOnTt3RnZ2NqKioqCjo8MsS1RUFBwcHLB06VIsXbqUWQ4iP7dv30anTp1w7Ngx/Pzzz6zjEKJQVCiJTKXn5GPhmVjcTs6CFp/32WJZ8vGC+/fgM9QRI378ToFJyy83NxdhYWGl+zDv3r2LnJwc8Hg8WFpalu7DbNeuHczMzGiFQklERUWhTZs28PHxwYwZM5hkEIvFcHZ2RmFhISIiIqCrq8skB5G/Pn36ICUlBQKBgE6VIBqFCiWRC1FmLo6EpCFA+Axp2fl4/zcZD0BTI324mtXDCKem+PWn3ir5mIjjOAiFwtIVzKCgIAgEAnAch9q1a5euYrq4uKBt27Z0rR5Dv/32G/z8/CASiZicT+rt7Y158+YhODgYTk7lP72AqI7IyEjY29tjz549GD9+POs4hCgMFUoid3mFYjzIzkORWApdbT6aGxnAQO9/37nfuXMHHTt2VIvHRK9evUJoaGhpybx79y5evnwJPp8Pa2vrMnsxTU1NK/026Js3b7Bv3z60aNECXbt2VcozF5VBVlYWTE1NMXjwYOzevVuhc6ekpMDGxgaTJk3Cxo0bFTo3YWPo0KEIDAyESCRClSpVWMchRCGoUBKl0LdvX4hEIggEAqb73GRNKpUiMTGxzF7M+Ph4AECdOnXK7MV0dHREtWrVyjX+y5cvMXPmTFy6dAkvXryAoaEh2rZti969e6Nv375o3ry5HD4r1bR161bMmDED4eHhsLe3V8icHMehe/fuSE1NRVxcHBV+DSESiWBhYQEvLy/Mnj2bdRxCFIIKJVEK0dHRaN26NXbv3o0JEyawjiNXL1++REhISOlezJCQELx+/Rp8Ph+2trZl9mK2aNHiq1cxnz9/jrt37yIgIACXL19GUlIS2rdvj8uXL5e7qKojsViM1q1bo1atWrh9+7ZCzgrct28fxo8fj6tXr6Jnz55yn48oj4kTJ+L06dNITU1FjRo1WMchRO6oUBKlMXz4cNy8eRPJycmoWrUq6zgKI5FIkJCQUObg9aSkJABAvXr1sGrVKowbN+6T+0s5jgPHcaUfz83NhZubG86ePYtdu3bhxx9/VNSnovT++ecfdOvWDUeOHMHw4cPlOteTJ09gYWGBH3/8EQcOHJDrXET5ZGRkwMTEBO7u7vDw8GAdhxC5o0JJlEZycjIsLCzg6ekJNzc31nGYysnJwd27dxEcHIyuXbuiY8eOn3xjVCqVlpbJgIAAzJkzB2KxGDt37qRr4D5i0KBBpaVdniu3P/30E+7cuYP4+Hi64lNDzZ07Fzt37kRqaiqTl8EIUSQqlESpTJ48GcePH0dqaiqd7fgVOI4rfXS7detWrFixAj179oSXlxcaNWrEOJ1yevDgASwsLDB79mysXr1aLnOcPn0aP/30E/z8/DBkyBC5zEGUX3Z2Nlq0aIGxY8fSC1lE7anOGS1EIyxZsgQFBQXw9vZmHUUl8Hg8FBYWYubMmZg3bx4WLVqEQ4cOUZn8jObNm2PevHnw9vZGSkqKzMd/+fIlpk6din79+qn8qQWkcoyMjODm5obt27cjLS2NdRxC5IpWKInScXd3h6+vL1JSUlC/fn3WcZTa/fv34ebmhn///Rd+fn7o0aNHmUfg7+M4DleuXEGtWrVgb28PPT09BomVQ35+Plq2bAl7e3ucPXtWpmNPmDABx44dQ3x8PBo3bizTsYnqyc3NhbGxMfr164d9+/axjkOI3NAKJVE68+fPh46OjtweR6qLq1evYsyYMXj16hVu3ryJHj16QCKRfPLtZR6Ph/nz58PFxQU1atRAu3btMHv2bJw4cQIZGRkKTs+Wvr4+vL29ce7cOVy7dk1m4wYEBGDv3r3w8vKiMkkAANWrV8eiRYtw4MABJCYmso5DiNzQCiVRSp6enli2bBmSkpLw7bffso6jdB4+fIjOnTsjLS0NK1euxIQJE1CvXr0v/rzi4mJER0eXORfzwYMHAIAmTZqUOXjdzs5Ora8I5DgOrq6uyMzMRExMTKXPP83Pz4etrS0aNWqEgIAAlbr1ichXYWEhzMzM0LZtW5w4cYJ1HELkggolUUp5eXkwMTFBz549cfDgQdZxlI5YLMbNmzdx4cIFXLp0CampqahWrRpat24NV1dXdO3aFR06dPiqUvPkyZMyBTM8PByFhYXQ09ODg4NDmZLZsGFDBXx2ihMdHQ17e3t4e3tj1qxZlRpr3rx52LJlC2JiYmBmZiajhERd7N+/H2PHjkV4eDjatGnDOg4hMkeFkiit7du3Y9q0aYiJiYG1tTXrOEovPDwcV65cgb+/Px48eIDIyEjUrl273OMUFRUhKiqq9EzM4OBgpKenAwCaNWtWej95u3bt0KpVK5W/2WjKlCk4cuQIRCLRV63yfkxERATatm2LVatWYcGCBTJOSNSBWCyGjY0NmjZtiqtXr7KOQ4jMUaEkSquoqAgWFhawsbGR+YsTpHwePXpUWi6DgoJw7949FBUVoWrVqh+sYqrai1TZ2dkwNTXFwIEDsXfv3nL//OLiYjg6OgIAwsLCVL5gE/k5deoUBg0ahICAAHTp0oV1HEJkigolUWpHjhzByJEjERQUhHbt2rGOQ/5fYWEh7t27V6ZkPn78GADQokWLMgXT1tb2k4eyK4tt27bh999/R2hoKBwcHMp8LK9QjAfZeSgSS6GrzUdzIwMY6P3v81m7di0WLVqEkJCQD34uIe/jOA5t27aFtrY2goKCFHL9JyGKQoWSKDWpVAo7OzvUrl0bAQEB9AVYSXEch/T09DJ7MSMjI1FcXAx9fX20bdu2TMmsU6cO68hliMVi2Nvbo1q1arhz5w5SnufhSEgaApKeIS0nH+9/keQBaGqoD1fzemjfQIp+nRzx+++/Y/369aziExXi7++PHj164Ny5c+jfvz/rOITIDBVKovQuXryIfv364cqVK+jVqxfrOOQrFRQUICIiokzJfPr0KQDAxMSkzF5Ma2traGlpMc3777//osePQ9HJbQdS8nShxedBIv30l8fSjz9NxLVVY2DWiK5XJF+nW7duyMzMRHR0NPPf94TIChVKovQ4jkPHjh1RUFCAsLAwOo5FRXEch4cPH5Z5TB4VFQWJRIJq1aqVWcV0dnZW+P3XfmFpWHAyElLwwON//V/yfB6go8XH8v5WGOrYVI4JiboICQmBs7Mz/vzzT4waNYp1HEJkggolUQm3b99Gp06dcOzYMbrOTo3k5+cjPDy8TMl8/vw5AMDc3LzMY3JLS0u5reb4BojgfU1Y6XHcepphmqupDBIRdTdgwABER0cjMTFRrc97JZqDCiVRGX379oVIJIJAIKA3adUUx3FITU0t85g8JiYGEokENWrUgJOTU5lVzFq1alV6Tr+wNLifjq18+P+3bqANhtBKJfkCgUAAGxsbbN26FVOnTmUdh5BKo0JJVEZUVBTs7Oywe/duTJgwgXUcoiBv3rxBeHh4mXMxs7OzAQAWFhal+zDbtWuHli1blmtLRHpOPrpvvIlCsVRmefW0+fCf1RlNDPVlNiZRT6NHj8bVq1eRkpICAwMD1nEIqRQqlESlDB8+HLdu3YJIJELVqlVZxyEMcByH5OTk0kfkwcHBiIuLg1QqRa1atUpXMV1cXODk5IQaNWp8cqxR+0IQlJr92ZdvykuLz4NLCyMcGuckszGJenrw4AHMzMywfPlyOhCfqDwqlESlJCcnw8LCAmvXrsWcOXNYxyFKIjc3F6GhoaUl8+7du3jx4gV4PB6srKzK7MU0NzcHj8eDKDMXPTbdklsm/1mdYFKvutzGJ+rh999/x+HDh5Gamlqhm60IURZUKInKmTx5Mo4fP47U1FTUrFmTdRyihKRSKYRCYZm9mAKBABzHwdDQEM7OzuDsByFRUg8yXJwspcXnYZRTM3j0t5L94EStZGZmwtjYGL///js8PT1ZxyGkwqhQEpXz+PFjmJiYwM3NDStWrGAdh6iIV69eISQk5H8Fs8XP0Kopv2simxnp46abq9zGJ+pj8eLF8PHxQUpKCho2bMg6DiEVQoWSqCR3d3f4+voiJSVF5e6OJuy9KRTDxuMq5PnFjwcgzqNXmWsaCfmYly9fokWLFhg6dCi2b9/OOg4hFUInRBOVNH/+fGhra2PNmjWsoxAV9DA7T65lEgA4AA+y8+Q8C1EHtWrVgru7O/bs2YOUlBTWcQipECqURCXVrl0b8+fPx44dO/DgwQPWcYiKKZLhMUHKMA9RfdOmTUPdunWxbNky1lEIqRAqlERlTZ8+HYaGhvDw8GAdhagYXW3FfOlT1DxE9enr62Pp0qU4evQoYmNld9A+IYpCeyiJStu+fTumTZuG2NhYWFnRG7Xk6+QVimEt5z2UHMdB95w72js5wMXFBS4uLrC0tKS76MknFRcXw8LCApaWljh//jzrOISUCxVKotKKiorQsmVLtGrVCmfOnGEdh6iQzusD8DAnX27jG+lK4JJzHUFBQYiOjoZEIkHNmjXh7OyM9u3bw8XFBW3btkX16nRWJfmfo0ePYsSIEQgMDISLiwvrOIR8NSqUROUdOXIEI0eORHBwMJydnVnHISrC47wAh0IeyvSWnBL/PYfyzZs3CAsLQ1BQUOk/L1++BJ/Ph62tbekKpouLC5o3bw4ejyfzTEQ1SKVS2NnZoXbt2ggICKDfC0RlUKEkKk8qlaJ169YwMjLCP//8Q1+AyVdheVOOVCpFUlISAgMDSwtmUlISAKBBgwZlCqa9vT309PTklpMon0uXLuH777/HlStX0KtXL9ZxCPkqVCiJWrhw4QL69++Pq1evomfPnqzjEBWhTHd5Z2Vl4e7du6UFMzQ0FAUFBdDV1YWDw7t9mO3bt0e7du3o7FU1x3EcOnbsiIKCAoSFhdG+W6ISqFAStcBxHDp06IDCwkKEhobSF2DyVdJz8tF9400UyvB4Hz1tPvxndUYTQ/1KjVNcXIzo6Ogyj8nT09MBAMbGxmVWMa2srKClpSWL+ERJ3L59G506dcLx48cxePBg1nEI+SIqlERt3Lp1C507d6YvwKRc/MLS4H5adse0rBtogyGOTWU23vvS09MRHBxcWjAjIyMhFotRvXp1ODs7lxZMJycnuudeDfTp0wcpKSkQCATQ1qYbl4hyo0JJ1Ap9ASYV4Rsggvc1ITiOq9Qe3Lk9zTHV1USGyT4vPz//g5d9cnJywOPxYG1tXfqY3MXFBS1atKD9xSomMjIS9vb22LNnD8aPH886DiGfRYWSqBX6Akwqwt/fHwPmrEf9vr+D4/HLtaeSx0mhq6ONFf2t5LYy+bU4joNQKCxTMOPj4wEA9erVK/OYvE2bNqhSpQrTvOTLhg4disDAQIhEIvrvRZQaFUqidoYNG4Y7d+5AKBSiatWqrOMQJZefnw9ra2s0a9YMB09exKKzcbidnAUtPu+zxbLk428fROKY2wB0bqOcB+u/ePGizMs+ISEhyMvLg46ODtq0aVOmZDZs2JB1XPIfIpEIFhYW8PLywuzZs1nHIeSTqFAStVPyBXjdunWYM2cO6zhEybm5uWHbtm2IiYmBqakpgHdHCh0JSUOA8BnSsvPL3KjDA9DUSB+uZvUwqHV9fN/JATY2Nrhw4QKT/OUlFosRGxtb5siihw8fAgCaN29eWi7bt28Pa2tr2jqiBCZOnIjTp08jNTUVNWrUYB2HkI+iQknU0m+//YaTJ08iJSWFXk4gnxQeHg4nJyesWbMG8+fP/+iPySsU40F2HorEUuhq89HcyAAGev8rWSdPnsTgwYNV+szAR48elXnZ5969eyguLka1atXg5ORUWjKdnZ1Rq1YtmcyZn5+PgwcPomnTpujWrRs9zv2MjIwMmJiYwN3dHR4eHqzjEPJRVCiJWnr06BFMTEwwd+5crFixgnUcooSKi4vh6OgIHo+H0NBQ6OjoVGgcjuPg6uqKZ8+eITo6usLjKJOCggJERESU2Yv5/PlzAICVlVWZx+SmpqYVetnn9evXmDlzJs6ePYvXr1+jbt26cHZ2Rt++fdGnTx988803sv60VNrcuXOxc+dOpKamom7duqzjEPIBKpREbc2fPx/btm1Damoq6tWrxzoOUTKenp5YvHgxQkND0aZNm0qNFRUVBXt7e2zatAnTp0+XUULlwXEcUlJSEBQUVPqoXCAQgOM41KlTB+3atSstmI6OjuXeu5yZmYng4GD4+/vj2rVrSE5OhouLCy5evCizFVFVl52djRYtWmDcuHHw8fFhHYeQD1ChJGorJycHLVq0wOjRo7F582bWcYgSEQqFsLW1xfTp0+Hl5SWTMSdNmoTjx49DJBKhTp06MhlTmb18+RIhISGlK5h3797FmzdvoK2tDXt7e7i4uKB///5wdXX95Bglf/2UrHAWFRVh3rx5OHjwIHx9fTFixAiFfC6qYuXKlVi9ejWEQiGaNmV7ogAh/0WFkqi1NWvWYPny5UhKSkLz5s1ZxyFKQCqVwtXVFY8ePUJMTAz09St3o02JZ8+ewdTUFCNHjsS2bdtkMqYqkUgkiIuLK/OYfNCgQVi9evUnX+yRSqWlt1oFBQVhzpw5yM7Oxq5duz5bRDVVbm4ujI2N0a9fP+zbt491HELKoEJJ1FpeXh6MjY3x3Xff4cCBA6zjECWwe/duTJo0CTdu3EDXrl1lOraPjw/mzp2LqKgo2NjYyHRsVfT27Vvo6up+9CrU9w+R3717N5YuXYr27dvD29sb3377raKjqozNmzdj9uzZEAgEaNmyJes4hJSiQknU3rZt2zB9+nTExMTAyko5zwokivH48WNYWFhg0KBBclnhKSoqgo2NDRo3bgx/f3+6meYLiouLsXjxYmzZsgXLli3DnDlz1OKlJnkqLCyEmZkZ2rZtixMnTrCOQ0gpKpRE7RUVFaFly5Zo1aoVzpw5wzoOYYTjOAwcOBDBwcFISEhA7dq15TLPpUuX8P333+PMmTP48ccf5TKHOkhLS4ObmxuuXbuGI0eOoG/fvmUegb9PKpVCIpFQ2fx/+/fvx9ixYxEeHl7pF8oIkRUqlEQjHD58GKNGjcLdu3fh5OTEOg5h4NSpUxg0aBBOnDiBQYMGyW0ejuPQp08fCIVCxMfHQ09PT25zqarr169jzZo14DgOmzZtQuvWrSGRSMDn8z+5qjts2DCIRKIyRxZp6ospYrEYNjY2aNq0Ka5evco6DiEAqFASDSGRSNC6dWvUrVsXN27coEeRGubFixewtLSEk5MTzpw5I/f//gkJCbCxscHq1as/eWC6pkpLS0Pnzp3x8OFDrF69GhMnToSRkdEXf96RI0dw7do1BAUFITk5GQDQuHHjMgWzdevWGrOKWfINUkBAALp06cI6DiFUKInmuHDhAvr3749r166hR48erOMQBRo/fjxOnDiB+Ph4NGrUSCFzzpw5E/v27YNQKKQ7st8jFovx77//4vz587h06RIePHiAGjVqwMHBAV27doWrqyucnJw+W/qfPXtW5mafsLAwFBYWomrVqnB0dCwtmO3atVPbI5w4jkPbtm2hra2NoKAg+iaZMEeFkmgMjuPQvn17FBUVISwsjL4Aa4h//vkH3bp1w86dOzFp0iSFzfvixQuYmpqif//++OOPPxQ2ryoKCgrC5cuX4e/vj/T0dMTExMDQ0PCrf35RUREiIyNLC2ZgYCCePHkCADAzMyuzimlhYfHRfZqqyN/fHz169MC5c+fQv39/1nGIhqNCSTTKrVu30LlzZ7nvoyPKIT8/H7a2tmjUqBECAgIUXiR27NiBKVOmICwsDA4ODgqdW5NxHIe0tLQyZ2JGRUVBKpWiVq1aZW72adu2LapVq8Y6coV169YNz549Q1RUFLS0tFjHIRqMCiXROL1798b9+/cRFxf3yQOXiXqYP38+Nm/ejOjoaJibmyt8frFYDHt7e1SvXh137tyhVXGG3rx5g9DQ0NKCGRwcjJcvX4LP56NVq1ZlVjGbNWumMv+tQkJC4OzsjEOHDmHkyJGl/z6vUIwH2XkoEkuhq81HcyMDGOjR1zsiP1QoicaJjIyEvb099u7di3HjxrGOQ+Tk3r17aNu2LVasWIGFCxcyy1HyyP3o0aMYNmwYsxykLKlUisTExDKrmElJSQCAhg0blimYdnZ2Sv22/oABAxAdHY2Lt8Jx/N4TBCQ9Q1pOPt7/y50HoKmhPlzN62GEU1OY1q/OKi5RU1QoiUYaOnQoAgMDIRKJUKVKFdZxiIyJxWK0bdsWEokE4eHhzN/8HThwIMLCwpCYmAgDAwOmWcinZWVl4e7du6UFMzQ0FAUFBdDT0/vgZZ969eqxjlvqRkgUhm+8iKrf2kGLz4NE+um/1ks+3tGkDtYMsEETQ9lcPUoIFUqikUQiESwsLODl5YXZs2ezjkNkzMvLCwsWLMDdu3fh6OjIOg5SU1NhYWGBBQsWwMPDg3Uc8pWKi4sRHR2NwMDA0pd9Hj16BAAwMTEps4ppaWnJZA+jX1galp0XoLBYDPC+fo+wFp8HbT4Py/tbYaijZp7nSWSLCiXRWJMmTcKpU6eQmpqKGjVqsI5DZEQkEsHW1hZTpkzBhg0bWMcptWDBAmzatAlJSUkaeyC3OkhPTy/zmDwyMhISiQQ1atSAs7NzacF0cnKS+9cV3wARvK8JKz2OW08zTHM1lUEiosmoUBKN9ejRI5iYmGDevHlYvnw56zhEBjiOQ9euXfHw4UPExsYq1ePl3NxcmJmZoUuXLvjrr79YxyEykpeXh/Dw8DIlMycnB3w+HzY2NmVWMb/99luZvezjF5YG99OxMhkLANYNtMEQWqkklUCFkmi0efPmYfv27UhNTVWqPVGkYvbt24fx48fj+vXr6N69O+s4Hzh48CDGjBmDW7duoWPHjqzjEDngOA5CobDMmZgJCQkAgPr165cpmPb29hXaw52ek4/uG2+iUCyVWW49bT78Z3WmPZWkwqhQEo2Wk5ODFi1aYMyYMdi0aRPrOKQSnjx5AgsLCwwYMAD79+9nHeejpFIpnJ2dIZFIEBYWpjYHbJPPy8nJKfOyT0hICPLz86Grq4s2bdqUKZkNGjT44nij9oUgKDX7sy/flJcWnweXFkY4NM5JZmMSzUKFkmi81atXY8WKFRAKhWjWrBnrOKSCBg0ahNu3byM+Pv6r7oZmJTg4GC4uLti3bx/Gjh3LOg5hQCwWIyYmpsxj8ocPHwIAvv32W7Rv3760YFpbW5d52UeUmYsem27JLZv/rE4wqUdHCpHyo0JJNN6bN29gYmKC3r17K+3KFvm8M2fOYODAgfDz88OQIUNYx/miESNGwN/fHyKRiF4IIwDe7el+/37ye/fuobi4GNWqVSvzss+/uXVxPPKpTFcnS2jxeRjl1Awe/a1kPjZRf1QoCQHg6+uLGTNmIDY2FpaWlqzjkHJ4+fIlLC0t4eDggHPnzqnEDScZGRkwNzfH1KlT4eXlxToOUUIFBQUfvOyTlZWFbybtgU7thnKbt5mRPm66ucptfKK+qFASAqCoqAh9+vTBqlWr4OzszDoOKYdJkybhr7/+Qnx8PBo3bsw6zldbuXIlVq5cCYFAAFNTOrKFfB7HcYhJEOKHQyK8u/dGPngA4jx60TWNpNxoRzghAHR1dXH9+nW0adOGdRRSDjdv3sTu3buxbt06lSqTAODm5oaGDRvCzc2NdRSiAng8HrRrNYA8yyQAcAAeZOfJdQ6inqhQEvL/eDwe8yv6yNcrKCjAhAkT0L59e0yaNIl1nHKrWrUq1q9fj/Pnz+P69eus4xAVUCTDY4KUYR6iXqhQEkJU0sqVK/Hw4UPs3btXZY/fGTx4MDp27IiZM2dCLBazjkOUnK62Yn6fK2oeol7odw0h5VRQUMA6gsaLioqCl5cXlixZgpYtW7KOU2E8Hg+bN29GQkICdu7cyToOUXLNjQzk/MD73QP15kbKc8MUUR30Ug4h5bB27Vo8e/YMPj4+rKNoLLFYDGdnZxQWFiIiIgK6urqsI1XahAkTcOrUKYhEIqU+Q5Ow13l9AB7m5MttfHrLm1QUrVAS8pUyMzOxf/9+iMViSKW0x4iVTZs24d69e9i3b59alEkAWLVqFcRiMTw8PFhHIUrO1bwetPjyWafU4vPgakZX0JKKoUJJyEdIJBIA747qKHHp0iVUrVoVHh4eKrtnT9WlpKRg6dKlmDFjBtq2bcs6jszUr18fS5cuxY4dOyAQCFjHIUpshFNTuRxqDgASKYeRzk3lMjZRf/TIm5D3PH/+HEVFRWjUqBGkUmlpcczMzISTkxPGjx+PxYsXQyKRlLkOjcgfx3Ho0aMHkpOTERcXh2rVqrGOJFNFRUWwtrZG8+bNcfXqVZU4oJ2wQXd5E2VEJ5cS8h4vLy/s2LEDJiYmMDQ0RJ06dWBqaorCwkLUrFkTHTt2BPDuL/+qVasyTqtZDhw4gBs3buDKlStqVyaBd2ehbtiwAf3798eFCxfQv39/1pGIklozwAbdN96UaaHU5vOwZoCNzMYjmodWKAl5T25uLmJiYhAWFoaCggIIhULk5eXh5MmTqFq1Kpo2bYoXL17A2NgYWlpa8PLyopt1FODp06ewtLTE999/jz///JN1HLnhOA7fffcdUlNTERcXBz09PdaRiJLyC0uD++lYmY23bqANhjjS425ScVQoCfmC8ePHIyoqCvv27UN+fj7u37+PFy9eICIiAnZ2dvj9999ZR1R7P//8MwICApCQkIA6deqwjiNX8fHxsLW1haenJ+bOncs6DlFivgEieF8T4t39NhXfIjG3pzmmuprILBfRTFQoCfkIjuPA4/GQlJSEbt26Yd26dRgxYsQHP472UsrfuXPn8OOPP+Lo0aMYNmwY6zgKMX36dBw4cAAikQj169dnHYcosd034rD6igg8LW2AV46XBaUS6OnqYEV/K1qZJDJBhZKQz5gyZQqEQiH8/f0/+FhJ6STy8+rVK1haWqJ169a4ePGixvx65+TkwNTUFAMGDMDevXtZxyFKbMiQIQgIjYHr/N0IefgaWnzeZ/dWlny84P49zO7QEPOnjVdgWqLO6OwTQj7h+vXr+OOPP/Dbb78BwAdnT2pKuWHJ3d0dr1+/xo4dOzTq19vQ0BArVqzAH3/8gXv37rGOQ5TU+fPncfz4cWxavQTHfuuI6zM7YZRTMzQz0v/gATgP7w4tH+XUDP6zOqGXrgg+Kxfh9evXLKITNUQrlIR8wuHDh7Fnzx7cvHmTdRSNdPv2bXTq1Albt27FtGnTWMdROLFYjNatW6N27dq4deuWRhVq8mVfWr3PKxTjQXYeisRS6Grz0dzIAAZ6/zvYJT09Hebm5pg5cybWrFmj6PhEDVGhJOQzYmNjYWPzv6M0aM+kYrx9+xatWrWCkZERbt++rbG/5jdu3ED37t3h5+eHIUOGsI5DlMhvv/2GI0eOQCAQoGnTiu2BXLJkCdavX4+kpCQ0a9ZMxgmJpqFCSUg5pKam4sSJE5g/fz7rKGpt8eLF8PLyQlRUFCwtLVnHYerHH3/EvXv3kJiYCH19fdZxiBK4efMmunTpAl9fX0ydOrXC47x58wampqbo2rUrjhw5IsOERBPRHkpCyiEwMBDu7u4IDQ1lHUVtxcTEYN26dVi0aJHGl0kA8Pb2RmZmJry9vVlHIUqgoKAAEyZMQPv27TF58uRKjVWtWjWsXLkSR48epa9ppNJohZKQcpBIJGjVqhUaNGjw0Te/SeVIJBK0a9cO+fn5uHfvHnR1dVlHUgrz58/H1q1bkZSUhCZNmrCOQxhasGABfHx8EB0djZYtW1Z6PIlEAjs7O9SoUQO3b9+mvbqkwmiFkpBy0NLSwurVq3Hjxg0qlHJw5swZhIeHY8+ePVQm37No0SLUqFED7u7urKMQhiIjI7F+/XosWbJEJmUSePc1bcOGDQgMDMTp06dlMibRTLRCSUg5cRwHFxcXiMVihIaG0nf0MlJyrufdu3fpOsuP2L9/P8aOHYs7d+6gffv2rOMQBROLxXByckJxcTHCw8Nl/g1X3759kZiYiPj4eLryk1QIrVASUk48Hg+enp4IDw+n7+jL6cKFC8jIyPjox0qKuZOTkyIjqYzRo0ejTZs2mDFjxgdnohL15+PjU3oFrDxW79evX4+HDx9i27ZtMh+baAZaoSSkgr777js8fPgQsbGx0NbW/vJP0HBFRUWwt7fH2LFjMXv2bLppqAICAwPRoUMH7N+/H2PGjGEdhyiISCSCra0tpkyZgg0bNshtnsmTJ8PPzw/JyckwMjKS2zxEPVGhJKSC7t27hzZt2mDfvn0YO3Ys6zhKTyqVws3NDf7+/rh79y6qVq1KhbIChg0bhoCAAAiFQtSoUYN1HCJnHMeha9eupd+8GhgYyG2uZ8+ewcTEBL/++is2b94st3mIeqJH3oRUkL29PX7++Wd4eHjg7du3rOMoPT6fD3d3dxQVFSE6OprKZAWtW7cOr1+/pttNNMTevXvx77//Yvfu3XItkwBQr149LFy4ENu3b4dQKJTrXET90AolIZUgFAphaWmJ9evXY9asWazjqIThw4cjJycHFy5cgJaWFng8HpXLclq+fDnWrFmD+Ph4GBsbs45D5OTx48ewtLTEwIED8ccffyhkzrdv36Jly5Zo3bo1zp49q5A5iXqgFUpCKsHMzAxjx47FmjVr8Pr1a9ZxlFJGRgby8/ORnJyMgoICdOnSBc+fP4dIJAKfzwePx4NEImEdU6XMnTsX9evXh5ubG+soRE44jsPUqVNRpUoVue6b/K8qVarA09MT586dw7///quweYnqoxVKQiopIyMDJiYmcHd3h4eHB+s4SuXff//FiBEjAADFxcWoUaMG8vLykJmZCXt7e0ydOhW//vorgHd7LPl8+h73a/n5+WHYsGHw9/dHt27dWMchMnby5EkMHjwYJ06cwKBBgxQ6N8dxaNeuHYqLixEWFkZ/LslXoUJJiAzMnTsXO3fuRGpqKurWrcs6jtK4ffs2Xr16BT09PTRo0ADZ2dkwMTFBVFQUrl69Cn9/f9jZ2WHJkiWwsLBgHVelcByHjh074tWrV4iMjKSTBtRITk4OLC0t0a5dO5w+fZrJlpCgoCC0b98eBw8exC+//KLw+YnqoUJJiAxkZ2ejRYsWGDt2LDZu3Mg6jkrIyMjAhQsXcPr0aQgEAvz7778wMzNjHUulREREwNHREb6+vpgyZQrrOERGxo4di9OnTyM+Ph7ffPMNsxw///wzgoKCIBQKoa+vzywHUQ1UKAmRkVWrVmHlypUQiURo2rQp6zhKp+Tcyf+ePxkQEIDU1FSMGzeOYTrVNW7cOJw7dw5CoRCGhoas45BK8vf3R48ePbB7925MmDCBaZbU1FRYWFhg8eLFWLJkCdMsRPlRoSRERt68eQNjY2P07dtXYW9kqrL3iyUdcl5xT58+hZmZGZ0dqAby8vJgY2ODZs2a4Z9//lGKPxNz587Fjh07IBKJ0LBhQ9ZxiBKjnbaEyEi1atWwePFiHDx4EAkJCazjKL2S1cqS/5tUTIMGDbB48WJs27YN8fHxrOOQSli6dCmePHmCPXv2KM2fiUWLFqFKlSq0Qkm+iFYoCZGhwsJCmJubo02bNjh16hTrOERDFBYWwsrKCsbGxrhy5YrSlBHy9cLCwuDs7AxPT0/MmzePdZwyfH19MX36dERGRqJVq1as4xAlRYWSEBn7888/MXr0aISGhsLR0ZF1HKVQVFQEbW1tOn5Ejs6dO4cff/wRFy9eRN++fVnHIeVQVFQEBwcH6OjoICQkROne2C8uLoaNjQ0aN26M69ev0zcs5KPoqzshMjZixAhYWVlh4cKFrKMoBY7jMGDAAHh5eYG+f5Wf/v37Y+HChbCxsaFfZxXj5eWF+Ph47Nu3T+nKJADo6Ohg/fr1uHHjBv7++2/WcYiSohVKQuSgZLWIDp0GDh8+jFGjRuHChQv4/vvvWcdRe2KxWClLCfm4hIQEtG7dGnPmzFHq+9k5jkO3bt3w5MkTxMTEQEdHh3UkomSoUBIiBxzHwcXFBRKJBCEhIRr7iOj58+ewsLBAjx498Ndff7GOQ4hSkUql6NixI7KyshAdHY0qVaqwjvRZkZGRaNOmDZ17Sj6KHnkTIgc8Hg+enp4ICwvDmTNnWMdhZtasWeA4jo6zIeQjtm/fjqCgIOzZs0fpyyQA2NnZYfTo0Vi2bBlevXrFOg5RMrRCSYgc9erVC+np6YiJidG4x5CXL19Gnz596Oo2JRMQEABzc3OmN7AQIC0tDVZWVhg5ciR27NjBOs5Xe/ToEczMzDBt2jSsW7eOdRyiRKhQEiJHERERcHBwwB9//IFff/2VdRyFyc3NhZWVFSwsLOgYGyUzcOBAmJiYwMvLi3UUjcVxHPr27YuYmBjEx8ejRo0arCOVi4eHBzw9PZGYmIhvv/2WdRyiJOiRNyFy1KZNGwwePBgeHh54+/Yt6zgKs2jRImRnZ2Pnzp1UJpVAybrBnTt3cO3aNbRv355xIs129OhRXL58GTt27FC5Mgm8uz3HyMgICxYsYB2FKBFaoSREzpKSkmBlZQVvb2/MnDmTdRy5Cw4ORvv27bFhwwbMmjWLdRyN9bHrLEePHo3MzExcunQJWlpajJJptpIX1bp37w4/Pz/WcSps//79GDt2LIKCgtCuXTvWcYgSoEJJiAJMmDABZ8+eRWpqKqpXr846jtwUFRXBzs4OBgYGCA4OptLCQHp6Ol69egULCwvk5uaiVq1aKCwsxKNHj/DDDz9gx44d6NChQ+mPp3vUFWvEiBG4cuUKEhISUK9ePdZxKkwikaBNmzaoWrUqgoKC6PcQoUfehCjCsmXLkJubCx8fH9ZR5MrT0xNCoRB79+6lMsnIrl270KZNGzRv3hzOzs4wNTXF4MGDMXToUGRkZODKlSu4cOECLl++jMTERIjFYtaRNcalS5dw9OhRbNy4UaXLJABoaWlhw4YNuHv3Lk6cOME6DlECtEJJiIK4ublh9+7dSElJQd26dVnHkbn4+Hi0bt0a8+bNw6pVq1jH0VgSiQTJyclISkqCRCLBkydPkJ6ejnXr1sHBwQG1atVCeHg46tatC5FIhOXLl2PJkiWsY6s9dX1RrV+/fhAIBIiPj1eJo4+I/FChJERBsrKy0KJFC4wfP17tViolEgk6duyInJwcREVF0V8sSmbSpEl4/Pgxzp07h+LiYhQVFaGwsBCFhYVISUlBp06dWEdUe9OmTcOBAwcQFxeH5s2bs44jM4mJibC2toanpyfmzp3LOg5hiB55E6IgderUwdy5c7F9+3akpaWxjiNTO3bsQHBwsMoc0KwJStYKYmJicOLECfTv3x98Ph/a2tqoXr06DA0N0ahRIyqTChAYGIjt27dj9erValUmAaBly5b47bffsGrVKjx//px1HMIQrVASokC5ubkwNjZGv379sG/fPtZxZEJVD2jWFIsXL0ZoaCiuXbvGOopGevv2Lezs7FCzZk0EBgaq5d7i58+fw9TUFCNHjoSvry/rOIQRWqEkRIGqV6+OxYsX48CBA0hMTGQdp9I4jsPkyZNRs2ZNrF27lnUc8h9RUVHYtGkThg0bBuDd3dFEsVavXo2UlBTs27dPLcskANStWxeLFi3Czp071eLrGqkYWqEkRMEKCwthbm4OBwcHnDx5knWcSvnrr78wfPhwnDt3Dv3792cdh/zHkydP0L9/f9y5cwd6enqs42icmJgYtGnTBosWLYKHhwfrOHL19u1bWFhYwNraGhcuXGAdhzBAhZIQBg4ePIgxY8YgNDQUjo6OrONUSFZWFiwsLNC1a1ccO3aMdRzyCU+fPkWDBg1K/3+JRAKO45CXl4eaNWsyTKbeJBIJ2rVrh7y8PNy7d08jCv3x48cxZMgQ+Pv7o1u3bqzjEAWjQkkIAxKJBLa2tvjmm29w/fp11nEq5JdffsHFixeRkJCA+vXrs45DvpJYLEa3bt1Qp04dnDp1inUcteXj4wM3NzcEBgZqzE0yHMehffv2yM/PR0REhNo+4icfR3soCWFAS0sLq1evhr+/P27cuME6TrldvXoVhw4dwoYNG6hMqhhtbW1MmjQJp0+fRkBAAOs4aik1NRWLFy/G77//rjFlEgB4PB58fHwQHR2NP//8k3UcomC0QkkIIxzHoV27duA4Dnfv3lWZg47fvHkDa2trmJiY4Pr16yqTm/wPx3Ho0KED3rx5g4iICGhra7OOpDY4jkPPnj0hEokQFxeHatWqsY6kcEOHDsWtW7cgFAo18vPXVLRCSQgjPB4Pnp6eCA0NxdmzZ1nH+WpLlizBs2fPsHv3biqTKorH42HTpk2IiYnB3r17WcdRK+Hh4QgICMCuXbs0tkytXbsWOTk58Pb2Zh2FKBCtUBLCWM+ePZGRkYHY2Fil33MUEhKCdu3aYf369ZgzZw7rOKSSfv31V1y4cAEikQi1a9dmHUctSKVSpKeno1mzZqyjMDV//nxs3boVIpEIjRo1Yh2HKAAVSkIYCw8Ph6OjI/bv348xY8awjvNJRUVFaNOmDfT09HD37l16TKoGnjx5AjMzM4wfPx4bN25kHUclXLx4EdbW1p+98YbjOI1fvX/16hVMTEzw/fffY//+/azjEAWgR96EMObg4IBBgwZh2bJlKCwsZB3nk7y8vJCQkIC9e/dSmVQTDRs2xKJFi+Dr60sHUn8FsViMJUuWwM/PD8D/rrf8L00vkwBQs2ZNLF++HAcPHkRkZCTrOEQBaIWSECWQlJQEKysrbNiwATNmzGAd5wMJCQlo3bo15syZgzVr1rCOQ2To7du3sLKygrm5Of7++2/WcZQax3FYsGABzp8/j9DQUBgYGFB5/AyxWAxbW1s0aNAAN27coF8rNUeFkhAlMX78eJw7dw6pqamoXr066zilpFIpOnXqhGfPniE6OhpVq1ZlHYnI2JkzZzBw4EBcunQJffr0YR1HqWVnZ6NDhw7YvXs3OnbsyDqO0rt06RK+//57nD9/Hv369WMdh8gRFUpClER6ejpMTU2xcOFCLF26lHWcUjt27MCUKVPw77//onPnzqzjEDngOA7du3fHo0ePEBMTA11dXdaRlNovv/yCx48f4/Lly9DS0gKPx6PVt08oOUYpLS0NcXFx0NHRYR2JyAntoSRESTRp0gRTp06Ft7c3srKyWMcBAGRkZGD+/PmYOHEilUk1VnKMkEgkwrZt21jHUTppaWnIy8uDUChEQUEBOnfujJycHCQmJoLP54PH40EikbCOqZR4PB68vb0hEomwa9cu1nGIHNEKJSFKJCsrCy1atMCECROwYcMGplk4jkP//v0RERGB+Ph41KpVi2keIn9TpkzB0aNHIRKJULduXdZxlMLNmzcxfPhwcBwHsViM6tWrIz8/H5mZmbCzs8PUqVMxduxYAO+2h/D5tE7zMePGjcO5c+eQnJxMX0vUFBVKQpTMihUrsGbNGohEIjRp0oRZjmPHjmHo0KE4c+YMfvzxR2Y5iOJkZWXB1NQUQ4YMwc6dO1nHUQpBQUF48eIFqlSpgvr16yMrKwsmJiaIjo7G1atXcf36ddjZ2WHJkiWwsLBgHVdpPX78GGZmZpg8eTLWr1/POg6RAyqUhCiZ3NxcGBsbo3///sxuMcnOzoaFhQU6deqEkydPMslA2Ni8eTNmz56Ne/fuoVWrVqzjKLWMjAxcunQJJ0+ehEAgQEBAAMzNzVnHUlorVqzA6tWrkZCQgBYtWrCOQ2SMCiUhSqjkL3WBQICWLVsqfP5ff/0VZ8+eRUJCAho0aKDw+Qk7xcXFpUe9/PPPP/SyyXs+dWB5QEAAUlJSMH78eAapVEdeXh7Mzc3h4uKC48ePs45DZIwKJSFKqLCwEGZmZmjbti1OnDih0LmvX7+Onj17Yu/evRg3bpxC5ybK4erVq/juu+9w8uRJ/PTTT6zjKK33CybdjvN1Dh48iDFjxuDOnTto37496zhEhqhQEqKkDhw4gF9//RVhYWFwcHBQyJx5eXmwsbFB8+bN6SBiDff9999DIBAgISEBVapUYR1HaVGRLB+pVApHR0doa2sjODiYXmJSI/RfkhAlNWrUKFhaWmLhwoUKm3Pp0qV48uQJdu/eTX9JajgfHx9kZGTAx8eHdRSlRn9OyofP52PDhg0IDQ3FsWPHWMchMkQrlIQosZIbTG7cuIGuXbvKda6wsDA4OzvD09MT8+bNk+tcRDXMmTMHu3btQlJSEho1asQ6DlN5eXkwMDCgo4Fk5Mcff0RkZCQSExPp9i01QYWSECXGcRycnZ0BAHfv3pXbakhxcTEcHBygpaWF0NBQaGtry2UeolpevnwJMzMzfPfdd/jzzz9Zx2GG4zj88MMPqFatGg4fPkyFUgaEQiGsrKywcuVKuLu7s45DZID+VBCixHg8Hjw9PREaGoqzZ8/KbZ7169dDIBBg7969VCZJqVq1amH16tU4dOgQQkJCWMdh5vjx47hw4QIGDRpEZVJGzMzM4OHhATs7O9ZRiIzQCiUhKqBnz56l9yxraWnJdOykpCS0atUKM2bMwLp162Q6NlF9EokEbdq0QZUqVRAUFKRxharkTNaOHTvi1KlTrOOolZLbh+h+b/VAhZIQFRAeHg5HR0ccOHAAo0ePltm4UqkUrq6uePToEWJjY2kvE/momzdvokuXLjh06BBGjhzJOo5CjR49GufPn0d8fDwaNmzIOg4hSosKJSEqYvDgwQgNDYVQKISenp5Mxty1axd+++03/PPPP3B1dZXJmEQ9/fzzzwgMDERSUhKqVavGOo5ClJzHuW/fvtL7ugkhH0eFkhAVkZiYCCsrK2zcuBHTp0+v9HiPHj2CpaUlBg8ezOyKR6I6Hjx4gJYtW8LNzQ2rVq1iHUfu3rx5A2tra5iYmOD69et0PBBDQqEQRkZGMDIyYh2FfAYVSkJUyPjx43H+/HmkpKSgevXqFR6H4zgMGDAAISEhiI+PR+3atWWYkqirJUuWYP369UhMTETz5s1Zx5GrmTNnYvfu3YiLi6N7pxmbMGECqlWrho0bN7KOQj5Ds3ZXE6Lili1bhtevX2PTpk2VGufUqVM4d+4cfH19qUySrzZ//nwYGRlh7ty5rKPI1d27d7FlyxasXLmSyiQjJWtd0dHROHbsGMzNzRknIl9CK5SEqJg5c+Zgz549SE1NRZ06dcr981+8eAELCwu4uLjg9OnTckhI1Nnhw4cxatQo/Pvvv+jcuTPrODJXVFQEe3t7VK1aFcHBwXSMlgJ97ND4efPm4e7du/D394euri6jZORr0AolISpmwYIFAIC1a9dW6Oe7ubmhoKAAvr6+soxFNMTw4cPh7OyMGTNmQCKRsI4jc56enkhKSsK+ffuoTCrI48ePIRQKwefzkZ+fD+DdcVVpaWk4d+4cZs2aVaZM0jqYcqI/LYSomDp16sDNzQ1r1qzBjBkz0KRJk9KP5RWK8SA7D0ViKXS1+WhuZAADvf/9Mb9x4wb++OMP7Nq1C9988w2L+ETF8fl8bN68GU5OTti3bx8mTpzIOpLMCAQCrF69GvPnz4etrS3rOBrD19cXPj4+aNSoEapVqwZdXV2Ym5vjxYsXePPmDZ48eYK4uDhwHAcTExM63kxJ0SNvQlRQbm4ujI2N8cMPP2DeKh8cCUlDQNIzpOXk4/0/0DwATQ314WpeDwNb1cOArs5o0qQJ/vnnH407oJrI1ujRo3H58mUIhULUqlWLdZxKk0gk6NChA168eIGoqChUqVKFdSSNUVRUhKSkJMTFxUEsFuPhw4d49uwZfH19YWxsjNq1ayM2NhYNGzbEo0ePsHHjRkyZMoV1bPIfVCgJUVErNmzD9rAXqPKtHbT4PEikn/6jXPLxwodR8JvzIzq3sVJgUqKOHj9+DDMzM0yaNAkbNmxgHafStmzZghkzZuD27dvo0KED6zgab9KkSUhNTcXJkydRXFyM3Nxc5Ofn48mTJ3j58iUGDRrEOiL5DyqUhKggv7A0LDsvwNuiYvD4X38VIw8cdLW1sLy/FYY6NpVjQqIJ1qxZg2XLliEuLk6l38J9+PAhrKysMHr0aGzbto11HI3FcRx4PB7i4uLg6uqKtWvXYty4caX/vuR/iXKiQkmIivENEMH7mrDS47j1NMM0V1MZJCKa6u3bt7CwsICVlRUuXrzIOk6FcByH3r17QyAQQCAQoEaNGqwjabz58+cjMjIS165dYx2FlANtoiJEhfiFpcmkTAKA9zUhjoWlyWQsopmqVKkCb29vXLp0CVeuXGEdp0IOHz6Mq1evYufOnVQmlUBISAi2bNlSeme8Op4koK5ohZIQFZGek4/uG2+iUCyV2Zh62nz4z+qMJob6MhuTaBaO49C1a1c8ffoUMTEx0NHRYR3pqz179gwWFhbo1asXjh49yjoOARAbG4sxY8YgIiKCdRRSTrRCSYiKWHgmFuLPvHhTEWIph4VnYmU6JtEsPB4PmzZtglAoxPbt21nHKZcZM2aAx+Nh8+bNrKOQ/2djY4NTp06V/v8lK5TFxcWsIpGvRIWSEBUgyszF7eSsz77JXRESKYfbyVlIfpYr03GJZmnVqhUmTJgADw8PZGVlsY7zVS5evAg/Pz9s2rQJdevWZR2HvOf9e+I5jsOgQYMwf/58doHIV6FCSYgKOBKSBi2+fN5u1OLzcPgu7aUklbNy5UpwHIelS5eyjvJFr1+/xuTJk9G7d2+MGDGCdRzyGdra2rCzs4Ovry+Sk5NZxyGfQYWSEBUQkPRM5quTJSRSDgHCZ3IZm2iOunXrYtmyZdi1axdiYmJYx/ksd3d3vHjxAjt27KBjaFTArFmzUL9+fVqlVHJUKAlRcm8KxUjLyZfrHGnZ+cgrFMt1DqL+pk6dClNTU8ycOVNp71u+ffs2duzYAU9PTzRr1ox1HPIV9PX14enpidOnT+P27dus45BPoLe8CVFygsev0HfrHbnPc+n3DrD6pqbc5yHq7fLly+jTpw9Onz6NAQMGsI5Txtu3b9GqVSsYGRnh9u3b0NL6+ksBCFtSqRROTk4A3h0tRFfHKh/6L0KIkiuS4TFByjAPUW+9e/dG7969MWfOHLx9+5Z1nDJWrlyJBw8eYO/evVQmVQyfz8eGDRsQHh6Ov/76i3Uc8hFUKAlRcrraivljunXzRhw4cAAREREoKChQyJxEPfn4+CA9PR2bNm1iHaVUdHQ0vLy8sGjRIlhaWrKOQyqgU6dOGDBgABYsWEBfo5QQPfImRMnlFYph7XEVcv2DynHQPjsfqcIEcBwHPp8PMzMz2Nralv5jY2ODZs2a0UsM5KvMmjULe/bsgVAoxDfffMM0i1gshrOzMwoLCxEREQFdXV2meUjFiUQiWFlZwcPDAwsXLmQdh7yHCiUhKqDz+gA8lOOLOc2M9HHTzRVv3ryBQCBATEwMYmNjERMTg5iYGLx48QIAUKNGDdjY2JQpmTY2NnRlHfnAixcvYGZmhr59++LAgQNMs3h7e2PevHkIDg4u3YdHVNesWbOwd+9eiEQiNGjQgHUc8v+oUBKiAjzOC3Ao5KFcjg7S4vMwyqkZPPpbffTjHMfh0aNHH5TMxMREiMXv3gxv3rx5mZJpa2sLExMTaGtryzwvUR27du3Cb7/9htDQUDg6OjLJkJKSAhsbG0yaNAkbN25kkoHIVk5ODkxMTDB48GDs2rWLdRzy/6hQEqICRJm56LHpltzG95/VCSb1qpfr5xQWFiIxMbFMyYyJicGTJ08AAFWqVIGVlVWZkmlra0u3kmgQiUQCe3t7GBgYIDAwUOHbJTiOQ/fu3ZGamoq4uDgYGBgodH4iP5s2bcKcOXMQHR0Na2tr1nEIqFASojJG7QtBUGq2TFcptfg8uLQwwqFxsnsMmJWV9UHJjIuLK33jt0GDBh+UTAsLC+jp6cksA1EeAQEB6Nq1K44cOYLhw4crdO59+/Zh/PjxuHr1Knr27KnQuYl8FRUVwcrKCsbGxrhy5QrrOARUKAlRGek5+ei+8SYKZXi8j542H/6zOqOJob7MxvwYiUSC5OTkD4rm/fv3AQBaWlpo2bLlB0WzcePG9BKQGhg0aBDu3r2LpKQkha0SPnnyBBYWFvjxxx+Z7+Ek8nHmzBkMHDgQly9fxnfffcc6jsajQkmICvELS4P76ViZjbduoA2GODaV2XjllZubi7i4uDIlMyYmBq9fvwYA1KpV64OSaW1tjWrVqjHLTMrv/v37sLCwwLx587BixQqFzPnTTz/hzp07SEhIgKGhoULmJIrFcRw6d+6MnJwcREVF0Z5txqhQEqJifANE8L4mrPQ4c3uaY6qriQwSyRbHcUhPT/+gZAqFQkgkEgCAsbFxmZJpa2uLFi1a0GHVSmzRokXw8fFBYmKi3K88PHXqFAYNGoRjx47h559/lutchK3w8HA4Ojpi586dmDRpEus4Go0KJSEqyC8sDcvOCyCWcuXaU6nF50Gbz8OK/lZMVyYr4u3bt0hISChTMmNjY5GZmQng3X2/JS8Bvf/GuZGRkUxzXLt2DXv27IGrqyucnZ3RqlUrKrJf4c2bNzAzM0PHjh1x7Ngxuc3z4sULWFpaom3btjh79ixtmdAAo0aNwrVr1yASiegIM4aoUBKiotJz8rHwTCxuJ2dBi8/7bLEs+XhHkzpYM8BG7nsmFSkzM/ODvZnx8fEoLCwEAHzzzTdlSqatrS3Mzc0rfLh1TEwM1q5di+TkZCQlJSE3Nxe1a9eGnZ0devXqhR49eqB169Yy/AzVx59//onRo0fj1q1b6Nixo1zmGDduHE6ePIn4+Hg0atRILnMQ5ZKeng4zMzPMmjULa9asYR1HY1GhJETFiTJzcSQkDQHCZ0jLzi9zow4PQFMjfbia1cNI56blPhpIVYnFYohEojIrmTExMXj48CEAQEdHp/QloPdXM7/55ptyr2hlZWUhLCwMbm5uSEhIgJeXF9zc3OTxaak8qVSKdu3aobi4GGFhYTJf2b1x4wa6d+9Ojz810OLFi+Ht7Y2kpCS5b6kgH0eFkhA1klcoxoPsPBSJpdDV5qO5kQEM9GijeomXL1+WvgT0/qrmmzdvAACGhoawtbXF33//japVq352rOLiYujo6AAAli5dipMnT+LXX3/FrFmz6OWAz7h79y7atWuHPXv2YPz48TIbNz8/HzY2NmjcuDECAgLA5/NlNjZRfrm5uTA1NUW3bt1w5MgR1nE0EhVKQohGk0qlePjwYWm5zMjI+OLtGxKJBFpaWhCLxRgxYgRu3rwJb29vjBw5UkGpVVvJnjehUIiaNWvKZEw3Nzf4+voiJiYGZmZmMhmTqJY9e/Zg4sSJCAkJQdu2bVnH0ThUKAkhpAKePXuGn3/+GSkpKThx4gScnZ1ZR1IZjx49gpmZGaZMmYL169dXerywsDA4Oztj9erVcHd3l0FCoookEgns7OxQs2ZN3Lp1i17IUjAqlIQQUk7R0dEYP3483r59i7///htNmjSBVCr96GPWxMREGBsblz4eJ++sWrUKK1asgEAggKmpaYXHKS4uhoODA/h8PkJDQ+nXWcNdu3YNvXr1wsmTJ/HTTz+xjqNRqFASQkg5XL58GXPmzME333yDY8eOwcjI6JNlMjMzEw0aNICuri4sLS0/OKS9fv36GruKUlBQAAsLC9ja2uL8+fMVHmf16tVYtmwZQkNDYW9vL8OERFX16dMHQqEQAoGArnRVICqUhBDylfbu3YvNmzejV69e8PT0hI6ODqRSaWkp/G85LC4uRnBw8AdnZ+bn5wMA6tat+0HJtLS0/OILQerixIkT+Pnnnyt813ZiYiJatWqFmTNnYt26dXJISFSRQCCAra0t1q9fj9mzZ7OOozGoUBJCyFdITEyEi4sLXr58ialTp6J3794wMTFBixYtyvVWt1QqRWpq6gdnZ6akpIDjOPD5fJiZmX1QNJs1a6Z2q5kcx6FLly7IyspCVFRUmcfVXzqxQCqVonPnznj69CliYmI0poSTrzN58mT4+fkhOTlZ5pcbkI+jQkkIIV9BLBYjKioKd+7cwbVr1xAbG4snT55AR0cHzZo1g52dHbZt21bhe6Pz8vIgEAg+uHLyxYsXAIAaNWrAxsamTMm0sbFR+ZtBoqKiYG9vj82bN+O7n8e8O1M16RnScj5ypqqhPlzN62GEU1NcP3UIU6dORUBAALp06cIoPVFWz549g4mJCX799Vds3ryZdRyNQIWSEEIqISUlBSEhIYiLi8Py5ctl+lIIx3F4/PjxByUzMTERYrEYANCsWbMPbgIyMTFRqbMwR/42E/++aQDtJjZffetTUVo0utV4jkM7NiowKVEla9euxZIlSyAQCOgoKQWgQkkIISqmqKgIiYmJH+zNfPz4MQBAT0/vo/ea16tXj3HyD/mFpWHZuTi8LRaDx//6m3M4qQRVdHWwvL8VhqrYvfREMd6+fQtzc3PY2dnh7NmzrOOoPSqUhBCiJrKyssrszYyNjUVcXBwKCgoAAPXr1/9gNdPCwoLZm7C+ASJ4XxNWehy3nmaY5lrxo4eI+jp69ChGjBhBWyMUgAolIYSoMYlEgpSUlA/uNU9NTQUAaGlpwdzc/IPVzCZNmsj1JSC/sDS4n46V2XjrBtpgCK1Ukv8ouT9eLBYjLCyMruSUIyqUhBCigXJzcz96r/mrV68AADVr1vygZFpbW6N69eqVnjs9Jx/dN95EoVha6bFK6Gnz4T+rM5oY6stsTKIeAgMD0aFDBxw8eBC//PIL6zhqiwolIYQQAO9eAkpPT/+gZCYlJUEikQAAWrRoUaZk2trawtjYGFpaX7//cdS+EASlZn/25Zvy0uLz4NLCCIfGOclsTKI+Bg8ejODgYAiFQujr0zcd8kCFkhBCyGe9ffsWCQkJHxTNzMxMAEDVqlVhbW39wdmZHzv/T5SZix6bbsktq/+sTjCpV/lVVKJeUlJSYGFhgSVLlmDJkiWs46glKpSEEEIqJDMzE7GxsWVKpkAgQGFhIQDgm2+++WA180QqcDQsQ6arkyW0+DyMcmoGj/5WMh+bqD43Nzfs3LkTIpEIDRs2ZB1H7VChJIQQIjNisRgikeiDm4AePnwIAGg0aQ+0a8vvL/NmRvq46eYqt/GJ6nrx4gVMTEwwYMAA7N27l3UctUOFkhBCiNy9evUKYVGxGH/lJd7deyMfPABxHr3KXNNISImtW7dixowZiIyMRKtWrVjHUSv0/jwhhBC5q1mzJhqa2kCeZRIAOAAPsvPkOgdRXb/99htMTU3h5uYGWk+TLSqUhBBCFKJIhscEKcM8RPXo6Ohg/fr18Pf3x+XLl1nHUStUKAkhhCiErrZi/spJTRaiqKhIIXMR1dOvXz906dIFbm5uEIvFrOOoDSqUhBBCFKK5kYGcH3i/O0tz8HddUKNGDTg5OWHq1KnYv38/4uLiqDwQAACPx8OGDRuQmJiIPXv2sI6jNuilHEIIIQrTeX0AHubky238prWrYl3HqggPD0dYWBjCw8ORmJgIjuOgr68POzs7ODg4wNHREQ4ODjA1NaXr+DTUmDFjcOnSJSQnJ6NmzZqs46g8KpSEEEIUxuO8AIdCHir0HMrc3FxERkaWFszw8HAkJycDAKpXr442bdqUFkwHBwd8++23cr3HnCiHR48ewdTUFNOnT8fatWtZx1F5VCgJIYQojLLclPPixQtERESUFszw8PDSszINDQ1Ly2XJP40bN6aSqYb+r727i42qzOM4/pszo3Vb7QUFJkoZWugrMBLaTiBNulgCXS6ABGMEolwIFyawxmiAAIkBTUAwRFytF2sigai8XCARY2IUIQpsbWZ4LbRpS1GmCS+FEgm26dvM7AUM29MFbDkzPTPT7+eSJs88k17wzel5nv/GjRu1detWNTY2Kicnx+7tJDWCEgAwrBJ1lndbW5spMv1+v65evSpJcrvdpsD0+Xxyu92x2j5s8ueffyo/P18vvPCC9u7da/d2khpBCQAYVq23OjVnx8/qjuH1PmkuQ4ffmqXxo9JjtqYkXblyxRSYgUBAN2/elCRlZ2ebArO0tPSB88uR2Hbu3KkVK1aopqZGM2fOtHs7SYugBAAMu33+oNZ9XRez9ba96NVinydm6z1MJBJRMBg0BWYgENDt27clSbm5uaZDPyUlJRz4SHChUEglJSXKyMjQiRMneLXhMRGUAABbVB9t1vYfmiyvs6aqUKsq82Kwo8cTDod16dIlU2CePHlSHR13J/YUFBSYDv1Mnz5dGRkZtu0X/+/w4cOaO3eu9u/fr5dfftnu7SQlghIAYJt9/qA2HrqgvnBkSO9UOg2HXIZD7y2cMixPJocqFAqpqanJFJmnT59WV1eXDMNQcXGxKTKnTZump556yu5tj2jz589XfX296uvr+V08BoISAGCr1lud2nCwTscu3pTTcDwyLKM/r8gbrS2LvDF/ZzKeent7VV9fb3on89y5c+rt7ZXL5ZLX6zW9kzl16lQ98cQTMfnsYDCoTz75RCUlJZo1a5aee+65mKybShoaGuT1evX+++9rzZo1dm8n6RCUAICE0Hz9jr6qDepoU5uC7Z3q/5+TQ5InK12VBWP16kzPoK4GSgbd3d2qq6szReaFCxcUCoWUlpamadOmmd7JLCoqksvlGvLntLa2avXq1Tp16pQuX74sl8ulgoICVVZWasGCBSorK1NmZmYcvmFyWbVqlb788ktdvHhRY8aMsXs7SYWgBAAknI7uPv3e3qGevrCedBnKycpQRtrQQyoZdXZ26uzZs3Gb9tPZ2amGhgadOHFCu3bt0pkzZ7RgwQJ98803cfxWyeHGjRvKy8vTsmXLVF1dbfd2kgpBCQBAgrtz545OnTpluog9Ou0nMzNTpaWlWrt2raqqqh4al5FIROFwWE6nU5L066+/at26dXI6nfrss880adKkYfs+ieyDDz7Qhg0bdP78eRUVFdm9naRBUAIAkIQGTvt5/fXXNXv27PvBOFAoFLr/s+rqam3evFlz5szRhx9+qDFjxigSiXBljqSuri4VFxfL6/Xq0KFDdm8naRCUAACkuP6x+MYbb2j37t1655139Pbbb8vpdBKTA+zfv19LlizRTz/9pNmzZ9u9naRAUAIAMAK0tbVp5cqVOnLkiPbs2aN58+bZvaWEFYlEVF5erq6uLgUCgYc+9cX/EJQAAKS406dP680339TVq1d18OBBTZ061fQn8IG2b9+uSCQyoqf91NTUqLy8XDt37tRrr71m93YSHkEJAEAKO3DggLZt26aJEydqx44devbZZxUKhWQYxkP/zP3SSy/p+++/vz/tp7Cw8P4dmSNp2s/ixYt17NgxNTc3j4jvawVBCQBAimppaVFFRYWuXbum9evXa+nSpZowYYKeeeav7/EMhUJqbGw0nSzvP+1n8uTJpshMxWk/v/32m4qKirR+/Xpt2rTJ7u0kNIISAIAU1dvbq9raWv3444/67rvv1NDQoJ6eHnk8HpWVlamiokLLly9XevrgJg71n/YTvSPzQdN+ondkxnLaj13Wrl2rTz/9VE1NTRo3btz9fx/Jd6U+CEEJAMAIcv36dR0/flxHjhxRfX29vv32Wz399NOPvV7/aT/RyBw47af/3PLi4uKkOuTyxx9/KD8/X/Pnz9eGrR/fnebU2KbgrQdMcxqVrsrCsXplhkf57tSY5jRYBCUAAIip6LSfaGA+aNpP/8gc6rSf4bb5X//WxzU39Lfc6Sk9b94KghIAAMTdYKb9RAPT5/MpJycnIe7G3OcPauOhC+ru6ZWMwT9ZdRoOuQyH3l04RUt8njjuMDEQlAAAwBb9p/1En2YGg0FJ0qhRo0yHfnw+n8aNGzeskVl9tFnbf2iyvM7qqgL9szI/BjtKXAQlAABIGG1tbabI9Pv9unbtmiTJ7XabArOsrExutzsu+9jnD2rd13UxW2/bi14tTuEnlQQlAABIaFeuXDE9xfT7/Wpvb5ckZWdnmwKztLRUWVlZlj6v9Van5uz4Wd194VhsX5KU5jJ0+K1ZKftOJUEJAACSSiQSUTAYNB36CQQCun37tiQpNzfXdOintLRUmZmZg15/2ee1+s+l9kcevhkqp+FQ+cQsfbFiRszWTCQEJQAASHrhcFgtLS2mwDx58uSQp/00X7+juR/9Erd9Hn7r78obm3pXChGUAAAgJQ2c9uP3+3XmzJkHTvvx+Xx6/vnntfWHFn1RezmmTyejnIZDy2ZM0KaFU2K+tt0ISgAAMGL81bSf8Ss/Vzjd2juYjzIhK10/r66M2/p2ISgBAMCIFp32c7w2oI9as6U4Xk3kkHR+0z9Sbkxj4l5LDwAAMAzS0tJUVlamuYuWxjUmJSki6ff2jrh+hh0ISgAAAEk9MbwmKBE+ZzgRlAAAAJKedA1PFg3X5wyn1PtGAAAAjyEnK0PxHuzouPc5qYagBAAAkJSR5pInzpNsPFnpKXcgRyIoAQAA7qssHCunEZ/nlE7DocqCsXFZ224EJQAAwD2vzPDE5VJzSQqFI3p1picua9uNoAQAALgn3/2MKvJGx/wppdNwqCJvdEqOXZQISgAAAJMti7xyxTgoXYZDWxZ5Y7pmIiEoAQAA+hk/Kl3vxnje9nsLp2h8nA/82ImgBAAAGGCJz6PVVQUxWWtNVaEW+1Lz3ckoZnkDAAA8xD5/UBsPXVBfODKkwzpOwyGX4dB7C6ekfExKBCUAAMAjtd7q1IaDdTp28aachuORYRn9eUXeaG1Z5E3pP3P3R1ACAAAMQvP1O/qqNqijTW0Ktneqf0A5dPfS8sqCsXp1pidlT3M/DEEJAAAwRB3dffq9vUM9fWE96TKUk5WRkhNwBougBAAAgCWc8gYAAIAlBCUAAAAsISgBAABgCUEJAAAASwhKAAAAWEJQAgAAwBKCEgAAAJYQlAAAALCEoAQAAIAlBCUAAAAsISgBAABgCUEJAAAASwhKAAAAWEJQAgAAwBKCEgAAAJYQlAAAALCEoAQAAIAlBCUAAAAsISgBAABgCUEJAAAASwhKAAAAWEJQAgAAwBKCEgAAAJYQlAAAALCEoAQAAIAlBCUAAAAsISgBAABgCUEJAAAASwhKAAAAWEJQAgAAwBKCEgAAAJYQlAAAALCEoAQAAIAlBCUAAAAsISgBAABgCUEJAAAASwhKAAAAWPJf4GvPdDFqnrYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "graph_triangle = nx_triangle_lattice(3)\n", + "assign_directional_triangular_labels(graph_triangle, 3)\n", + "pos = nx.spring_layout(graph_triangle)\n", + "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in graph_triangle.edges(data=True)]);\n", + "nx.draw(graph_triangle, pos)\n", + "nx.draw_networkx_edge_labels(graph_triangle, pos,edge_labels = edge_labels);" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimating Directional Triangle\n", + "Finished Estimating\n" + ] + } + ], + "source": [ + "lattice_size_directional_triangle = 32\n", + "# lattice_size_directional_triangle = 3\n", + "directional_triangle_hamiltonian = generate_directional_triangular_hamiltonian(lattice_size_directional_triangle)\n", + "\n", + "timesteps = 1000\n", + "required_precision = 1e-16\n", + "timestep_of_interest = 1 # sim_time\n", + "H_directional_triangle = pyH(directional_triangle_hamiltonian)\n", + "\n", + "print('Estimating Directional Triangle', flush=True)\n", + "qsp_circ_directional_triangle = estimate_qsp(H_directional_triangle, timesteps,\n", + " required_precision, 'QSP/directional_triangle_circuits/',\n", + " hamiltonian_name='directional_triangle')\n", + "print('Finished Estimating', flush=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Trotter imeplementations\n", + "Now we can do all of this again for second order Suzuki Trotter rather than QSP. Below we will see how to construct a single trotter step of second order Suzuki-Trotter for these hamiltonians along with a loose upper bound for the number of trotter steps required. According to the [documentation](https://quantumai.google/reference/python/openfermion/circuits/error_bound) from openfermion the trotter step estimate for the second order Suzuki-Trotter expansion." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "def find_hamiltonian_ordering(of_hamiltonian):\n", + " \"\"\"\n", + " Function to generate a near optimal term ordering for trotterization of transverse field Ising Models.\n", + " This would need to be modified if there were multi-qubit interactions that were not just ZZ\n", + " \"\"\"\n", + " # ordering hamiltonian terms by performing edge coloring to make optimal trotter ordering\n", + " # assuming that any 2 body interactions are ZZ\n", + " sorted_terms = sorted(list(of_hamiltonian.terms.keys()))\n", + " \n", + " # Z and X get translated to 90 and 88 respectively, multiplying by 100 \n", + " # ensures interacting term weight is considered\n", + " sorted_terms.sort(key=lambda x: len(x) * 100 + ord(x[0][1]))\n", + " \n", + " one_body_terms_ordered = list(filter(lambda x: len(x) == 1, sorted_terms))\n", + " two_body_terms = list(filter(lambda x: len(x) == 2, sorted_terms))\n", + " \n", + " # assigning edge colorings to order two body terms\n", + " graph = Graph()\n", + " for term in two_body_terms:\n", + " edge = (term[0][0], term[1][0])\n", + " graph.add_edge(*edge)\n", + " edge_coloring = nx.greedy_color(nx.line_graph(graph))\n", + " nx.set_edge_attributes(graph, edge_coloring, 'color')\n", + " for (i, term) in enumerate(two_body_terms):\n", + " n1, n2 = (term[0][0], term[1][0])\n", + " color = graph.edges[n1, n2]['color']\n", + " term = (*term, color)\n", + " two_body_terms[i] = term\n", + " \n", + " two_body_terms.sort(key=lambda x: x[2])\n", + " two_body_terms_ordered = list()\n", + " for (i, term) in enumerate(two_body_terms):\n", + " two_body_terms_ordered.append((term[0], term[1]))\n", + " return one_body_terms_ordered + two_body_terms_ordered" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "def estimate_trotter(openfermion_hamiltonian,\n", + " timesteps, \n", + " energy_precision, \n", + " outdir, \n", + " hamiltonian_name=\"hamiltonian\", \n", + " write_circuits=False):\n", + " bounded_error = error_bound(list(openfermion_hamiltonian.get_operators()), tight=False)\n", + " nsteps = trotter_steps_required(trotter_error_bound = bounded_error,\n", + " time = timesteps,\n", + " energy_precision = energy_precision)\n", + " term_ordering = find_hamiltonian_ordering(openfermion_hamiltonian)\n", + " trotter_circuit_of = trotterize_exp_qubop_to_qasm(openfermion_hamiltonian, \n", + " trotter_order=2, \n", + " evolution_time=timesteps/nsteps,\n", + " term_ordering=term_ordering)\n", + " \n", + " qasm_str_trotter = open_fermion_to_qasm(count_qubits(openfermion_hamiltonian), \n", + " trotter_circuit_of)\n", + " \n", + " trotter_circuit_qasm = qasm_import.circuit_from_qasm(qasm_str_trotter)\n", + " cpt_trotter = clifford_plus_t_direct_transform(trotter_circuit_qasm)\n", + " \n", + " #writing the the higher level trotter circuit to a file as well as the clifford + T circuit\n", + " if not os.path.exists(outdir):\n", + " os.makedirs(outdir)\n", + " \n", + " if write_circuits:\n", + " outfile_qasm_decomposed = f'{outdir}trotter_circuit_{hamiltonian_name}.qasm'\n", + " outfile_qasm_cpt = f'{outdir}trotter_cpt_{hamiltonian_name}.qasm'\n", + " with open(outfile_qasm_decomposed, 'w') as f:\n", + " print_to_openqasm(f, trotter_circuit_qasm, qubits=trotter_circuit_qasm.all_qubits())\n", + " with open(outfile_qasm_cpt, 'w') as f:\n", + " print_to_openqasm(f, cpt_trotter, qubits=cpt_trotter.all_qubits())\n", + " \n", + " outfile_data = f'{outdir}trotter_{hamiltonian_name}.dat'\n", + " gate_count = count_gates(cpt_trotter)\n", + " t_count = count_T_gates(cpt_trotter)\n", + " t_depth = get_T_depth(cpt_trotter)\n", + " t_depth_wire = get_T_depth_wire(cpt_trotter)\n", + " with open(outfile_data, 'w') as f:\n", + " f.write(f'Logical Qubit Count: {str(len(cpt_trotter.all_qubits()))}\\n')\n", + " f.write(f'Number of Trotter Steps Required (Loose Upper Bound): {str(nsteps)}\\n')\n", + " f.write(f'Total T Depth: {str(t_depth * nsteps)}\\n')\n", + " f.write(f'Maximum T Count on a Single Wire: {str(t_depth_wire * nsteps)}\\n')\n", + " f.write(f'Single Step Gate Count: {str(gate_count)}\\n')\n", + " f.write(f'Single Step Gate Depth: {str(len(cpt_trotter))} \\n')\n", + " f.write(f'Single Step T Count: {str(t_count)}')\n", + " f.write(f'Single Step T Depth: {str(t_depth)}\\n')\n", + " f.write(f'Single Step Maximum T Count on a Single Wire: {str(t_depth_wire)}\\n')\n", + " f.write(f'Single Step Clifford Count: {str(gate_count - t_count)}\\n')\n", + " \n", + " return cpt_trotter" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Translating the hamiltonians from above into a form usable by openfermion\n", + "openfermion_hamiltonian_square = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_square)\n", + "openfermion_hamiltonian_triangle = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_triangle)\n", + "openfermion_hamiltonian_cube = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_cube)\n", + "openfermion_hamiltonian_kitaev = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_kitaev)\n", + "openfermion_hamiltonian_directional_triangle = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_directional_triangle)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Estimates\n", + "Trotterizing the Hamiltonians and writing estimates to files" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "# defining precision required for the trotterized circuit\n", + "energy_precision = 1e-6\n", + "timesteps=1000" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimating Square\n", + "Estimating Triangle\n", + "Estimating Cube\n", + "Estimating Kitaev\n", + "Estimating Directional Triangle\n", + "Finished with estimates\n" + ] + } + ], + "source": [ + "print('Estimating Square', flush=True)\n", + "cpt_trotter_square = estimate_trotter(openfermion_hamiltonian_square,\n", + " timesteps, energy_precision,\n", + " 'Trotter/square_circuits/',\n", + " hamiltonian_name='square')\n", + "print('Estimating Triangle', flush=True)\n", + "cpt_trotter_triangle = estimate_trotter(openfermion_hamiltonian_triangle,\n", + " timesteps, energy_precision,\n", + " 'Trotter/triangle_circuits/',\n", + " hamiltonian_name='triangle')\n", + "print('Estimating Cube', flush=True)\n", + "cpt_trotter_cube = estimate_trotter(openfermion_hamiltonian_cube,\n", + " timesteps, energy_precision,\n", + " 'Trotter/cube_circuits/',\n", + " hamiltonian_name='cube')\n", + "print('Estimating Kitaev', flush=True)\n", + "cpt_trotter_kitaev = estimate_trotter(openfermion_hamiltonian_kitaev,\n", + " timesteps, energy_precision,\n", + " 'Trotter/kitaev_circuits/',\n", + " hamiltonian_name='kitaev')\n", + "print('Estimating Directional Triangle', flush=True)\n", + "cpt_trotter_directional_triangle = estimate_trotter(openfermion_hamiltonian_directional_triangle, \n", + " timesteps, energy_precision, 'Trotter/directional_triangle_circuits/', \n", + " hamiltonian_name='directional_triangle')\n", + "print('Finished with estimates', flush=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "figdir = 'Trotter/Figures/'\n", + "widthdir = 'Trotter/Widths/'\n", + "if not os.path.exists(figdir):\n", + " os.makedirs(figdir)\n", + "if not os.path.exists(widthdir):\n", + " os.makedirs(widthdir)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_histogram(\n", + " cpt_trotter_square,\n", + " 'Trotter Square',\n", + " figdir,\n", + " widthdir\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_histogram(\n", + " cpt_trotter_triangle,\n", + " 'Trotter Triangle',\n", + " figdir,\n", + " widthdir\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_histogram(\n", + " cpt_trotter_cube,\n", + " 'Trotter Cube',\n", + " figdir,\n", + " widthdir\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_histogram(\n", + " cpt_trotter_kitaev,\n", + " 'Trotter Kitaev',\n", + " figdir,\n", + " widthdir\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_histogram(\n", + " cpt_trotter_directional_triangle,\n", + " 'Trotter Directional Triangle',\n", + " figdir,\n", + " widthdir\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/pyproject.toml b/pyproject.toml index 807a40a..94b0761 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,14 +6,14 @@ build-backend = "setuptools.build_meta" name = "qca" version = "0.0.1" dependencies = [ - "cirq", + "cirq == 1.3.0.dev20231102230836", "matplotlib", "networkx", "numpy", "openfermion", "openfermionpyscf", "pandas", - "pyLIQTR == 0.3.3" + "pyLIQTR >=1.0.0" ] requires-python = ">=3.9" description = "Documentation of Applications for Quantum Computers" diff --git a/src/qca/utils/__init__.py b/src/qca/utils/__init__.py index 9f9161b..74adb9d 100644 --- a/src/qca/utils/__init__.py +++ b/src/qca/utils/__init__.py @@ -1 +1,2 @@ -from . import utils \ No newline at end of file +from . import utils +from . import hamiltonian_utils \ No newline at end of file diff --git a/src/qca/utils/hamiltonian_utils.py b/src/qca/utils/hamiltonian_utils.py new file mode 100644 index 0000000..eca9532 --- /dev/null +++ b/src/qca/utils/hamiltonian_utils.py @@ -0,0 +1,220 @@ +import random +from networkx import relabel_nodes, Graph, grid_graph +from networkx.generators.lattice import grid_2d_graph +from openfermion import FermionOperator, QubitOperator +from pyLIQTR.utils import Hamiltonian + +def flatten_nx_graph(graph: Graph) -> Graph: + new_ids = {} + count = 0 + for node in graph.nodes: + if node not in new_ids: + new_ids[node] = count + count = count + 1 + new_graph = relabel_nodes(graph, new_ids) + return new_graph + + +def generate_two_orbital_nx(Lx: int, Ly: int) -> Graph: + # can combine logic between loops if this is slow + g = Graph() + for m in range(Lx): + for n in range(Ly): + for a in range(2): + for s in range(2): + g.add_node((m, n, a, s), pos=( + m + a * (Lx + 1), n + s * (Ly + 1))) + + for m in range(Lx): + for n in range(Ly): + for s in range(2): + # t_1 terms + n1, n2 = (m, n, 0, s), (m, n + 1, 0, s) + n3, n4 = (m, n, 1, s), (m + 1, n, 1, s) + if n2 in g: + g.add_edge(n1, n2, label="-t1") + if n4 in g: + g.add_edge(n3, n4, label="-t1") + + # t_2 terms + n1, n2 = (m, n, 0, s), (m + 1, n, 0, s) + n3, n4 = (m, n, 1, s), (m, n + 1, 1, s) + if n2 in g: + g.add_edge(n1, n2, label="-t2") + if n4 in g: + g.add_edge(n3, n4, label="-t2") + + # t_3 terms + n1, n2 = (m, n, 0, s), (m + 1, n + 1, 0, s) + n3, n4 = (m, n, 1, s), (m + 1, n + 1, 1, s) + if n2 in g: + g.add_edge(n1, n2, label="-t3") + if n4 in g: + g.add_edge(n3, n4, label="-t3") + + n1, n2 = (m, n, 0, s), (m + 1, n - 1, 0, s) + n3, n4 = (m, n, 1, s), (m + 1, n - 1, 1, s) + if n2 in g: + g.add_edge(n1, n2, label="-t3") + if n4 in g: + g.add_edge(n3, n4, label="-t3") + + n1, n2 = (m, n, 0, s), (m + 1, n, 0, s) + n3, n4 = (m, n, 1, s), (m + 1, n, 1, s) + if n2 in g: + g.add_edge(n1, n2, label="-t3") + if n4 in g: + g.add_edge(n3, n4, label="-t3") + + n1, n2 = (m, n, 0, s), (m, n + 1, 0, s) + n3, n4 = (m, n, 1, s), (m, n + 1, 1, s) + if n2 in g: + g.add_edge(n1, n2, label="-t3") + if n4 in g: + g.add_edge(n3, n4, label="-t3") + + # +t_4 terms + n1, n2 = (m, n, 0, s), (m + 1, n + 1, 1, s) + n3, n4 = (m, n, 1, s), (m + 1, n + 1, 0, s) + if n2 in g: + g.add_edge(n1, n2, label="+t4") + if n4 in g: + g.add_edge(n3, n4, label="+t4") + + # -t4 terms + n1, n2 = (m, n, 0, s), (m + 1, n - 1, 1, s) + n3, n4 = (m, n, 1, s), (m + 1, n - 1, 0, s) + if n2 in g: + g.add_edge(n1, n2, label="-t4") + if n4 in g: + g.add_edge(n3, n4, label="-t4") + return g + + +def nx_to_two_orbital_hamiltonian( + graph: Graph, + t1: float, + t2: float, + t3: float, + t4: float, + mu: float) -> FermionOperator: + g_flat = flatten_nx_graph(graph) + H = FermionOperator() + + # generating hopping terms on each edge + for i, j, d in g_flat.edges(data=True): + w = 0 + label = d['label'] + if label == "-t1": + w = -t1 + elif label == "-t2": + w = -t2 + elif label == "-t3": + w = -t3 + elif label == "-t4": + w = -t4 + elif label == "+t4": + w = t4 + else: + raise ValueError("Graph improperly labeled") + + H += FermionOperator(((i, 1), (j, 0)), w) + H += FermionOperator(((j, 1), (i, 0)), w) + + # applying number operator to each qubit + for i in g_flat.nodes: + H += FermionOperator(((i, 1), (i, 0)), -mu) + + return H + +# given a networkx graph g, construct a hamiltonian with random weights +# which can be processed by pyLIQTR +def nx_longitudinal_ising_terms(graph,p,magnitude=1) -> list[tuple[str, float]]: + H_longitudinal = [] + n = len(graph.nodes) + for n1, n2 in graph.edges: + weight = magnitude if random.random() < p else -magnitude + curr_hamil_string = n * 'I' + for idx in range(len(graph)): + if idx == n1 or idx == n2: + curr_hamil_string = f'{curr_hamil_string[:idx]}Z{curr_hamil_string[idx+1:]}' + H_longitudinal.append((curr_hamil_string, weight)) + return H_longitudinal + +def nx_transverse_ising_terms(graph: Graph,p,magnitude=0.1) -> list[tuple[str, float]]: + H_transverse = [] + n = len(graph) + for idx in range(n): + w = magnitude if random.random() < p else -magnitude + curr_hamil_string = n * 'I' + for k in range(n): + if idx == k: + curr_hamil_string = f'{curr_hamil_string[:idx]}X{curr_hamil_string[idx+1:]}' + H_transverse.append((curr_hamil_string, w)) + return H_transverse + + +def nx_triangle_lattice(lattice_size: int) -> Graph: + graph = grid_2d_graph(lattice_size, lattice_size) + for i in range(lattice_size - 1): + for j in range(lattice_size - 1): + graph.add_edge((i,j),(i+1,j+1)) + return graph + +def generate_triangle_hamiltonian(lattice_size: int, longitudinal_weight_prob:float=0.5, transverse_weight_prob:float=1): + graph = nx_triangle_lattice(lattice_size) + graph = flatten_nx_graph(graph) + H_transverse = nx_transverse_ising_terms(graph, transverse_weight_prob) + H_longitudinal = nx_longitudinal_ising_terms(graph, longitudinal_weight_prob) + return H_transverse, H_longitudinal + +def generate_square_hamiltonian(lattice_size: int, dim:int, longitudinal_weight_prob:float=0.5, transverse_weight_prob:float=1): + dimensions = (lattice_size, lattice_size) if dim == 2 else (lattice_size, lattice_size, lattice_size) + graph = grid_graph(dim=dimensions) + graph = flatten_nx_graph(graph) + H_transverse = nx_transverse_ising_terms(graph, transverse_weight_prob) + H_longitudinal = nx_longitudinal_ising_terms(graph, longitudinal_weight_prob) + return H_transverse, H_longitudinal + +def pyliqtr_hamiltonian_to_openfermion_qubit_operator(H:Hamiltonian) -> QubitOperator: + open_fermion_operator = QubitOperator() + for term in H.terms: + open_fermion_term = '' + for i, pauli in enumerate(term[0]): + if pauli != 'I': + open_fermion_term = f'{open_fermion_term}{pauli}{i} ' + open_fermion_term_op = QubitOperator(open_fermion_term) + if open_fermion_term: + open_fermion_operator += term[1] * open_fermion_term_op + return open_fermion_operator + +def assign_hexagon_labels(graph:Graph): + for n1, n2 in graph.edges: + # start by making sure that the edges are ordered correctly + r1,c1 = n1 + r2,c2 = n2 + if r2 - r1 < 0 or c2 - c1 < 0: + r1, r2 = r2, r1 + c1, c2 = c2, c1 + + # now that they are ordered correctly, we can assign labels + label = '' + if c1 == c2: + label = 'Z' + # You can differentiate X and Y labels based off nx's node label parity + elif (((r1 % 2) + (c1 % 2)) % 2 == 0): + label = 'Y' + else: + label = 'X' + + graph[n1][n2]['label'] = label + +def assign_directional_triangular_labels(g:Graph, lattice_size:int) -> None: + for i in range(lattice_size - 1): + for j in range(lattice_size - 1): + g[(i,j)][(i+1,j)]['label'] = 'Z' + g[(i,j)][(i,j+1)]['label'] = 'X' + g[(i,j)][i+1,j+1]['label'] = 'Y' + g[(i,lattice_size-1)][(i+1,lattice_size-1)]['label'] = 'Z' + for j in range(lattice_size - 1): + g[(lattice_size-1,j)][(lattice_size-1,j+1)]['label'] = 'X' \ No newline at end of file diff --git a/src/qca/utils/utils.py b/src/qca/utils/utils.py index 8a96951..c5856dd 100644 --- a/src/qca/utils/utils.py +++ b/src/qca/utils/utils.py @@ -1,23 +1,74 @@ import os -from re import findall -from typing import Union -from cirq import Circuit, QasmOutput +from cirq import Circuit, QasmOutput, AbstractCircuit from pyLIQTR.utils.qsp_helpers import circuit_decompose_once from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform from pyLIQTR.utils.utils import count_T_gates +import matplotlib.pyplot as plt +import pandas as pd - -def extract_number(string) -> Union[int, None]: - number = findall(r'\d+', string) - return int(number[0]) if number else None - - -def count_gates(cpt_circuit) -> int: +def count_gates(cpt_circuit: AbstractCircuit) -> int: count = 0 for moment in cpt_circuit: count += len(moment) return count +def get_T_depth_wire(cpt_circuit: AbstractCircuit): + # maximum number of T-gates on a wire. This may be more optimistic than + # number of layers with T-gates. Perhaps good to treat as lower bound + # for an implementation + count_dict = {} + for moment in cpt_circuit: + for operator in moment: + opstr = str(operator) + if opstr[0] == 'T': + reg_label = opstr[opstr.find("(")+1:opstr.find(")")] + if not reg_label in count_dict: + count_dict[reg_label] = 1 + else: + count_dict[reg_label] += 1 + max_depth=0 + for register in count_dict: + if count_dict[register] > max_depth: + max_depth = count_dict[register] + return max_depth + +def plot_T_step_histogram(cpt_circuit:AbstractCircuit, kwargs, lowest_ind:int=0) -> plt.hist: + t_widths = [0] * len(cpt_circuit) + for i, moment in enumerate(cpt_circuit): + width = 0 + for operator in moment: + opstr = str(operator) + if opstr[0] == 'T': + width += 1 + t_widths[i] = width + bins = range(max(t_widths)) + histogram = plt.hist(t_widths, bins[lowest_ind:-1], **kwargs) + return histogram + +def plot_histogram(cpt_circuit: AbstractCircuit, + histogram_title:str, + figdir:str, + widthdir:str, + lowest_ind:int=0, + **kwargs) -> None: + circuit_histogram = plot_T_step_histogram(cpt_circuit, kwargs=kwargs, lowest_ind=lowest_ind) + plt.title(histogram_title) + plt.xlabel('T Width') + plt.ylabel('Count') + plt.savefig(f'{figdir}_width_histogram_square.pdf') + df_histogram_trotter_square = pd.DataFrame({'bin': circuit_histogram[1][:-1], \ + 'count': circuit_histogram[0]}) + df_histogram_trotter_square.to_csv(f'{widthdir}widths_square.csv', sep=',',index=False) + +def get_T_depth(cpt_circuit: AbstractCircuit): + t_depth = 0 + for moment in cpt_circuit: + for operator in moment: + opstr = str(operator) + if opstr[0] == 'T': + t_depth += 1 + break + return t_depth def estimate_gsee( circuit: Circuit, From 78e4ddceac13ec946b8d3a43f9d78ea47846980a Mon Sep 17 00:00:00 2001 From: Jonhas Colina <159941307+JonhasSC@users.noreply.github.com> Date: Wed, 28 Feb 2024 11:42:58 -0700 Subject: [PATCH 06/11] Fermi Hubbard Notebook translation to pyLIQTR1.0 (#3) * made the change to pyliqtr1.0 to HightemperatureSuperConductorExample jupyter notebook * added output for the notebook * removed old fermi hubbard notebook * removed unused imports * added hamiltonian utils file. Would proabbly be moved to some hamiltonian module in the future * have the notebook use the packaged utility functions * finalized adding additional features for fermi hubbard support * fixed pyproject versioning --- HighTemperatureSuperConductorExample.ipynb | 579 ------------------ ...HighTemperatureSuperConductorExample.ipynb | 342 +++++++++++ src/qca/utils/hamiltonian_utils.py | 4 +- 3 files changed, 344 insertions(+), 581 deletions(-) delete mode 100644 HighTemperatureSuperConductorExample.ipynb create mode 100644 notebooks/HighTemperatureSuperConductorExample.ipynb diff --git a/HighTemperatureSuperConductorExample.ipynb b/HighTemperatureSuperConductorExample.ipynb deleted file mode 100644 index 19bb369..0000000 --- a/HighTemperatureSuperConductorExample.ipynb +++ /dev/null @@ -1,579 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "16833c13-2d9f-4ce6-997a-3b9b80e06efc", - "metadata": {}, - "source": [ - "# Fermi Hubbard Ground State Energy Estimation with Quantum Circuits" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "d3fb0ae1-feb4-44c4-9250-33aa4180b89a", - "metadata": {}, - "outputs": [], - "source": [ - "import networkx as nx\n", - "import openfermion as of\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import time\n", - "import cirq\n", - "import os\n", - "from pyLIQTR.utils.utils import count_T_gates, open_fermion_to_qasm\n", - "from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform\n", - "from cirq.contrib.qasm_import import circuit_from_qasm\n", - "from pyLIQTR.GSE.GSE import GSE\n", - "from pyLIQTR.QSP.qsp_helpers import qsp_decompose_once" - ] - }, - { - "cell_type": "markdown", - "id": "03bf0aff-68e3-4aec-b821-cf2843837ef8", - "metadata": {}, - "source": [ - "Consider the two orbital tight binding Fermi Hubbard Model for cuprate superconductors (seen for example [here](http://sces.phys.utk.edu/publications/Pub2011/7-FOP-11107-ED.pdf)) on a square lattice:\n", - "\n", - "\\begin{equation}\n", - "\\begin{split}\n", - " H_{TB} & = -t_1 \\sum_{i,\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{y},x,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{x}, y, \\sigma} + h.c. \\right) \\\\\n", - " & -t_2 \\sum_{i,\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{x},x,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{y}, y, \\sigma} + h.c. \\right) \\\\\n", - " & -t_3 \\sum_{i,\\hat{\\mu}, \\hat{\\nu},\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{\\mu} + \\hat{\\nu},x,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{\\mu} + \\hat{\\nu}, y, \\sigma} + h.c. \\right) \\\\\n", - " & +t_4 \\sum_{i,\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{x}+\\hat{y},y,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{x}+\\hat{y},x,\\sigma} + h.c. \\right) \\\\\n", - " & -t_4 \\sum_{i,\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{x}-\\hat{y},y,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{x}-\\hat{y},x,\\sigma} + h.c. \\right) \\\\\n", - " & -\\mu \\sum_{i} \\left( n_{i}^{x} + n_{i}^{y} \\right)\n", - "\\end{split}\n", - "\\end{equation}\n", - "\n", - "where $t_1 = -1.0, t_2 = 1.3, t_3 = t_4 = -0.85$ with operators $d^{\\dagger}_{i,\\alpha,\\sigma}$ and $d_{i,\\alpha,\\sigma}$ respectively create or annihilate electrons on an atom at site $i$, with orbital $\\alpha$, and spin $\\sigma$. The operator $n^{\\alpha}_{i}$ represents the number operator of an atom at a given orbital, i.e. $n^x_i = \\sum_{\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma} d_{i,x,\\sigma} \\right)$. The indices in the Hamiltonian are assigned in the following manner: the index $i$ will correspond to a 2-tuple $(m,n)$ indicating the x and y coordinates of the atom in the lattice. Since there are 2 orbitals, $\\alpha \\in \\{x,y\\}$. Lastly, $\\sigma \\in \\{\\uparrow, \\downarrow \\}$. For the sake of simplicity of coding, we will remap these labels to integer values, meaning we will assign indices $m \\in L_x, n \\in L_y, a \\in \\mathbb{Z}^2, s \\in \\mathbb{Z}^2$ where $L_x$ is the $x$ dimension of the square lattice, and $L_y$ is the $y$ dimension of the square lattice. In the summations, $\\hat{x}$ and $\\hat{y}$ correspond to adjacent sites in the lattice, rather than the orbitals. The summation over unit vectors $\\hat{\\mu}$ and $\\hat{\\nu}$ correspond to the summing over unit vectors in all 8 cardinal and intercardinal directions without double counting." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "de1743f4-5721-46b4-aa30-e4a26843b542", - "metadata": {}, - "outputs": [], - "source": [ - "def count_gates(cpt_circuit):\n", - " count = 0\n", - " for moment in cpt_circuit:\n", - " for operator in moment:\n", - " count += 1\n", - " return count\n", - "\n", - "def flatten_nx_graph(g):\n", - " new_ids = {}\n", - " count = 0\n", - " for node in g.nodes:\n", - " if node in new_ids:\n", - " pass\n", - " else:\n", - " new_ids[node] = count\n", - " count = count + 1\n", - " new_g = nx.relabel_nodes(g, new_ids)\n", - " return new_g\n", - "\n", - "def num_fermion_qubits(ham):\n", - " n_qubits = 0\n", - " for term in ham.terms:\n", - " for op in term:\n", - " qubit = op[0]\n", - " if qubit >= n_qubits:\n", - " n_qubits = qubit+1\n", - " return n_qubits\n", - "\n", - "def generate_two_orbital_nx(Lx,Ly):\n", - " #can combine logic between loops if this is slow\n", - " g = nx.Graph()\n", - " for m in range(Lx):\n", - " for n in range(Ly):\n", - " for a in range(2):\n", - " for s in range(2):\n", - " g.add_node((m,n,a,s), pos=(m+a*(Lx+1),n+s*(Ly+1)))\n", - " \n", - " for m in range(Lx):\n", - " for n in range(Ly):\n", - " for s in range(2):\n", - " #t_1 terms\n", - " n1, n2 = (m,n,0,s), (m,n+1,0,s)\n", - " n3, n4 = (m,n,1,s), (m+1,n,1,s)\n", - " if n2 in g:\n", - " g.add_edge(n1,n2,label=\"-t1\")\n", - " if n4 in g:\n", - " g.add_edge(n3,n4,label=\"-t1\")\n", - " \n", - " #t_2 terms\n", - " n1, n2 = (m,n,0,s), (m+1,n,0,s)\n", - " n3, n4 = (m,n,1,s), (m,n+1,1,s)\n", - " if n2 in g:\n", - " g.add_edge(n1,n2,label=\"-t2\")\n", - " if n4 in g:\n", - " g.add_edge(n3,n4,label=\"-t2\")\n", - " \n", - " #t_3 terms\n", - " n1, n2 = (m,n,0,s), (m+1,n+1,0,s)\n", - " n3, n4 = (m,n,1,s), (m+1,n+1,1,s)\n", - " if n2 in g:\n", - " g.add_edge(n1,n2,label=\"-t3\")\n", - " if n4 in g:\n", - " g.add_edge(n3,n4,label=\"-t3\")\n", - " \n", - " n1, n2 = (m,n,0,s), (m+1,n-1,0,s)\n", - " n3, n4 = (m,n,1,s), (m+1,n-1,1,s)\n", - " if n2 in g:\n", - " g.add_edge(n1,n2,label=\"-t3\")\n", - " if n4 in g:\n", - " g.add_edge(n3,n4,label=\"-t3\")\n", - " \n", - " n1, n2 = (m,n,0,s), (m+1,n,0,s)\n", - " n3, n4 = (m,n,1,s), (m+1,n,1,s)\n", - " if n2 in g:\n", - " g.add_edge(n1,n2,label=\"-t3\")\n", - " if n4 in g:\n", - " g.add_edge(n3,n4,label=\"-t3\")\n", - " \n", - " n1, n2 = (m,n,0,s), (m,n+1,0,s)\n", - " n3, n4 = (m,n,1,s), (m,n+1,1,s)\n", - " if n2 in g:\n", - " g.add_edge(n1,n2,label=\"-t3\")\n", - " if n4 in g:\n", - " g.add_edge(n3,n4,label=\"-t3\")\n", - " \n", - " #+t_4 terms\n", - " n1, n2 = (m,n,0,s), (m+1,n+1,1,s)\n", - " n3, n4 = (m,n,1,s), (m+1,n+1,0,s)\n", - " if n2 in g:\n", - " g.add_edge(n1,n2,label=\"+t4\")\n", - " if n4 in g:\n", - " g.add_edge(n3,n4,label=\"+t4\")\n", - " \n", - " #-t4 terms\n", - " n1, n2 = (m,n,0,s), (m+1,n-1,1,s)\n", - " n3, n4 = (m,n,1,s), (m+1,n-1,0,s)\n", - " if n2 in g:\n", - " g.add_edge(n1,n2,label=\"-t4\")\n", - " if n4 in g:\n", - " g.add_edge(n3,n4,label=\"-t4\")\n", - " return g" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "f0a96c06-03aa-465b-a19a-4cbb34a3884d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "g_example = generate_two_orbital_nx(2,2)\n", - "pos = nx.get_node_attributes(g_example, 'pos')\n", - "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in g_example.edges(data=True)]);\n", - "nx.draw(g_example, pos)\n", - "nx.draw_networkx_edge_labels(g_example,pos, edge_labels = edge_labels);" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "442c3ec3-7811-4d22-946c-76a8ec78928b", - "metadata": {}, - "outputs": [], - "source": [ - "def nx_to_two_orbital_hamiltonian(g, t1, t2, t3, t4, mu):\n", - " g_flat = flatten_nx_graph(g)\n", - " H = of.FermionOperator()\n", - " \n", - " # generating hopping terms on each edge\n", - " for i,j,d in g_flat.edges(data=True):\n", - " w = 0\n", - " label = d['label']\n", - " if label == \"-t1\":\n", - " w = -t1\n", - " elif label == \"-t2\":\n", - " w = -t2\n", - " elif label == \"-t3\":\n", - " w = -t3\n", - " elif label == \"-t4\":\n", - " w = -t4\n", - " elif label == \"+t4\":\n", - " w = t4\n", - " else:\n", - " raise ValueError(\"Graph improperly labeled\")\n", - " \n", - " H += of.FermionOperator(((i,1),(j,0)),w)\n", - " H += of.FermionOperator(((j,1),(i,0)),w)\n", - " \n", - " #applying number operator to each qubit\n", - " for i in g_flat.nodes:\n", - " H += of.FermionOperator(((i,1), (i,0)), -mu)\n", - " \n", - " return H" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "8fa89362-c0d0-4637-9727-aeef44fbba15", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-1.0 [0^ 0] +\n", - "-0.85 [0^ 4] +\n", - "-0.85 [0^ 8] +\n", - "-0.85 [0^ 12] +\n", - "0.85 [0^ 14] +\n", - "-1.0 [1^ 1] +\n", - "-0.85 [1^ 5] +\n", - "-0.85 [1^ 9] +\n", - "-0.85 [1^ 13] +\n", - "0.85 [1^ 15] +\n", - "-1.0 [2^ 2] +\n", - "-0.85 [2^ 6] +\n", - "-0.85 [2^ 10] +\n", - "0.85 [2^ 12] +\n", - "-0.85 [2^ 14] +\n", - "-1.0 [3^ 3] +\n", - "-0.85 [3^ 7] +\n", - "-0.85 [3^ 11] +\n", - "0.85 [3^ 13] +\n", - "-0.85 [3^ 15] +\n", - "-0.85 [4^ 0] +\n", - "-1.0 [4^ 4] +\n", - "-0.85 [4^ 8] +\n", - "-0.85 [4^ 10] +\n", - "-0.85 [4^ 12] +\n", - "-0.85 [5^ 1] +\n", - "-1.0 [5^ 5] +\n", - "-0.85 [5^ 9] +\n", - "-0.85 [5^ 11] +\n", - "-0.85 [5^ 13] +\n", - "-0.85 [6^ 2] +\n", - "-1.0 [6^ 6] +\n", - "-0.85 [6^ 8] +\n", - "-0.85 [6^ 10] +\n", - "-0.85 [6^ 14] +\n", - "-0.85 [7^ 3] +\n", - "-1.0 [7^ 7] +\n", - "-0.85 [7^ 9] +\n", - "-0.85 [7^ 11] +\n", - "-0.85 [7^ 15] +\n", - "-0.85 [8^ 0] +\n", - "-0.85 [8^ 4] +\n", - "-0.85 [8^ 6] +\n", - "-1.0 [8^ 8] +\n", - "-0.85 [8^ 12] +\n", - "-0.85 [9^ 1] +\n", - "-0.85 [9^ 5] +\n", - "-0.85 [9^ 7] +\n", - "-1.0 [9^ 9] +\n", - "-0.85 [9^ 13] +\n", - "-0.85 [10^ 2] +\n", - "-0.85 [10^ 4] +\n", - "-0.85 [10^ 6] +\n", - "-1.0 [10^ 10] +\n", - "-0.85 [10^ 14] +\n", - "-0.85 [11^ 3] +\n", - "-0.85 [11^ 5] +\n", - "-0.85 [11^ 7] +\n", - "-1.0 [11^ 11] +\n", - "-0.85 [11^ 15] +\n", - "-0.85 [12^ 0] +\n", - "0.85 [12^ 2] +\n", - "-0.85 [12^ 4] +\n", - "-0.85 [12^ 8] +\n", - "-1.0 [12^ 12] +\n", - "-0.85 [13^ 1] +\n", - "0.85 [13^ 3] +\n", - "-0.85 [13^ 5] +\n", - "-0.85 [13^ 9] +\n", - "-1.0 [13^ 13] +\n", - "0.85 [14^ 0] +\n", - "-0.85 [14^ 2] +\n", - "-0.85 [14^ 6] +\n", - "-0.85 [14^ 10] +\n", - "-1.0 [14^ 14] +\n", - "0.85 [15^ 1] +\n", - "-0.85 [15^ 3] +\n", - "-0.85 [15^ 7] +\n", - "-0.85 [15^ 11] +\n", - "-1.0 [15^ 15]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "t1 = -1\n", - "t2 = 1.3\n", - "t3 = 0.85\n", - "t4 = 0.85\n", - "mu = 1\n", - "nx_to_two_orbital_hamiltonian(g_example, t1, t2, t3, t4, mu)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "4ebda67d-2295-4266-a56f-a01696b92cbc", - "metadata": {}, - "outputs": [], - "source": [ - "g_current_limit = generate_two_orbital_nx(6,7)\n", - "g_ideal = generate_two_orbital_nx(10,10)\n", - "\n", - "##### START UNCOMMENT FOR TESTING\n", - "#n_test = 2\n", - "#g_current_limit = generate_two_orbital_nx(n_test,n_test) \n", - "#g_ideal = generate_two_orbital_nx(n_test,n_test)\n", - "##### END UNCOMMENT FOR TESTING\n", - "n_qubits_current_limit = len(g_current_limit)\n", - "n_qubits_ideal = len(g_ideal)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "2e6b71f6-2027-427e-b39d-d670fba38894", - "metadata": {}, - "outputs": [], - "source": [ - "ham_current_limit = nx_to_two_orbital_hamiltonian(g_current_limit,t1,t2,t3,t4,mu)\n", - "ham_ideal = nx_to_two_orbital_hamiltonian(g_ideal,t1,t2,t3,t4,mu)\n", - "trotter_order_current_limit = 2\n", - "trotter_steps_current_limit = 1\n", - "\n", - "trotter_order_ideal = 2\n", - "trotter_steps_ideal = 1\n", - "\n", - "#note that we would actually like ~10 bits of precision, it just takes a really long time to run\n", - "bits_precision_ideal = 1\n", - "bits_precision_current_limit = 1\n", - "\n", - "current_limit_args = {\n", - " 'trotterize' : True,\n", - " 'mol_ham' : ham_current_limit,\n", - " 'ev_time' : 1,\n", - " 'trot_ord' : trotter_order_current_limit,\n", - " 'trot_num' : trotter_steps_current_limit\n", - "}\n", - "\n", - "ideal_args = {\n", - " 'trotterize' : True,\n", - " 'mol_ham' : ham_ideal,\n", - " 'ev_time' : 1,\n", - " 'trot_ord' : trotter_order_ideal,\n", - " 'trot_num' : trotter_steps_ideal\n", - "}" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "9a9c39b5-7d06-409c-82cf-58eacf3fd76f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "starting\n", - "current limit time to generate high level: 0.6936667519999995\n", - "ideal time to generate high level: 3.5612669230000007\n" - ] - } - ], - "source": [ - "E_min_ideal = -len(ham_ideal.terms)\n", - "E_max_ideal = 0\n", - "\n", - "E_min_current_limit = -len(ham_current_limit.terms)\n", - "E_max_current_limit = 0\n", - "\n", - "init_state_ideal = [0] * n_qubits_ideal\n", - "init_state_current_limit = [0] * n_qubits_current_limit\n", - "\n", - "print(\"starting\")\n", - "t0 = time.perf_counter()\n", - "gse_inst_current_limit = GSE(\n", - " precision_order=bits_precision_current_limit,\n", - " init_state=init_state_current_limit,\n", - " E_max = E_max_current_limit,\n", - " E_min = E_min_current_limit,\n", - " include_classical_bits=False, # Do this so print to openqasm works\n", - " kwargs=current_limit_args)\n", - "t1 = time.perf_counter()\n", - "print(\"current limit time to generate high level: \", t1 - t0)\n", - "\n", - "t0 = time.perf_counter()\n", - "gse_inst_ideal = GSE(\n", - " precision_order=bits_precision_ideal,\n", - " init_state=init_state_ideal,\n", - " E_max = E_max_ideal,\n", - " E_min = E_min_ideal,\n", - " include_classical_bits=False, # Do this so print to openqasm works\n", - " kwargs=ideal_args)\n", - "t1 = time.perf_counter()\n", - "print(\"ideal time to generate high level: \", t1 - t0)\n", - "\n", - "gse_circuit_ideal = gse_inst_ideal.pe_inst.pe_circuit\n", - "gse_circuit_current_limit = gse_inst_current_limit.pe_inst.pe_circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "666c0755-c80c-4214-bab6-742128bdf574", - "metadata": {}, - "outputs": [], - "source": [ - "def estimate_gse(circuit, outdir, circuit_name=\"gse_circuit\", write_circuits=False):\n", - " if not os.path.exists(outdir):\n", - " os.makedirs(outdir)\n", - " \n", - " subcircuit_counts = dict()\n", - " t_counts = dict()\n", - " clifford_counts = dict()\n", - " gate_counts = dict()\n", - " subcircuit_depths = dict()\n", - " \n", - " outfile_data = outdir+circuit_name+\"_high_level.dat\"\n", - " \n", - " for moment in circuit:\n", - " for operation in moment:\n", - " gate_type = type(operation.gate)\n", - " if gate_type in subcircuit_counts:\n", - " subcircuit_counts[gate_type] += 1\n", - " else:\n", - " decomposed_circuit = qsp_decompose_once(qsp_decompose_once(cirq.Circuit(operation)))\n", - " cpt_circuit = clifford_plus_t_direct_transform(decomposed_circuit)\n", - " \n", - " outfile_qasm_decomposed = outdir+str(gate_type)[8:-2]+\".decomposed.qasm\"\n", - " outfile_qasm_cpt = outdir+str(gate_type)[8:-2]+\".cpt.qasm\"\n", - " \n", - " if write_circuits:\n", - " with open(outfile_qasm_decomposed, 'w') as f:\n", - " print_to_openqasm(f, decomposed_circuit, qubits=decomposed_circuit.all_qubits())\n", - " \n", - " with open(outfile_qasm_cpt, 'w') as f:\n", - " print_to_openqasm(f, cpt_circuit, qubits=cpt_circuit.all_qubits())\n", - " \n", - " subcircuit_counts[gate_type] = 1\n", - " subcircuit_depths[gate_type] = len(cpt_circuit)\n", - " t_counts[gate_type] = count_T_gates(cpt_circuit)\n", - " gate_counts[gate_type] = count_gates(cpt_circuit)\n", - " clifford_counts[gate_type] = gate_counts[gate_type] - t_counts[gate_type]\n", - " \n", - " \n", - " total_gate_count = 0\n", - " total_gate_depth = 0\n", - " total_T_count = 0\n", - " total_clifford_count = 0\n", - " for gate in subcircuit_counts:\n", - " total_gate_count += subcircuit_counts[gate] * gate_counts[gate]\n", - " total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate]\n", - " total_T_count += subcircuit_counts[gate] * t_counts[gate]\n", - " total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate]\n", - " with open(outfile_data, 'w') as f:\n", - " total_gate_count \n", - " f.write(str(\"Logical Qubit Count:\"+str(len(circuit.all_qubits()))+\"\\n\"))\n", - " f.write(str(\"Total Gate Count:\"+str(total_gate_count)+\"\\n\"))\n", - " f.write(str(\"Total Gate Depth:\"+str(total_gate_depth)+\"\\n\"))\n", - " f.write(str(\"Total T Count:\"+str(total_T_count)+\"\\n\"))\n", - " f.write(str(\"Total Clifford Count:\"+str(total_clifford_count)+\"\\n\"))\n", - " f.write(\"Subcircuit Info:\\n\")\n", - " for gate in subcircuit_counts:\n", - " f.write(str(str(gate)+\"\\n\"))\n", - " f.write(str(\"Subcircuit Occurrences:\"+str(subcircuit_counts[gate])+\"\\n\"))\n", - " f.write(str(\"Gate Count:\"+str(gate_counts[gate])+\"\\n\"))\n", - " f.write(str(\"Gate Depth:\"+str(subcircuit_depths[gate])+\"\\n\"))\n", - " f.write(str(\"T Count:\"+str(t_counts[gate])+\"\\n\"))\n", - " f.write(str(\"Clifford Count:\"+str(clifford_counts[gate])+\"\\n\"))" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "10ae61fd-03b3-447c-bbc5-2aa68028f755", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Estimating Ideal\n", - "Time to estimate Ideal: 1577.596524861\n", - "Estimating Current Limit\n", - "Time to estimate Current Limit: 310.04503533\n" - ] - } - ], - "source": [ - "print(\"Estimating Ideal\")\n", - "t0 = time.perf_counter()\n", - "estimate_gse(gse_circuit_ideal, outdir=\"GSE/\", circuit_name=\"ideal\")\n", - "t1 = time.perf_counter()\n", - "print(\"Time to estimate Ideal:\", t1-t0)\n", - "\n", - "print(\"Estimating Current Limit\")\n", - "t0 = time.perf_counter()\n", - "estimate_gse(gse_circuit_current_limit, outdir=\"GSE/\", circuit_name=\"current_limit\")\n", - "t1 = time.perf_counter()\n", - "print(\"Time to estimate Current Limit:\", t1-t0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "afe80c93-2e6b-4ff3-9a63-962d530c1ce3", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "27bc4327-4e76-492f-9668-e80f33f425dc", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.8.8" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/HighTemperatureSuperConductorExample.ipynb b/notebooks/HighTemperatureSuperConductorExample.ipynb new file mode 100644 index 0000000..b070443 --- /dev/null +++ b/notebooks/HighTemperatureSuperConductorExample.ipynb @@ -0,0 +1,342 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fermi Hubbard Ground State Energy Estimation with Quantum Circuits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Consider the two orbital tight binding Fermi Hubbard Model for cuprate superconductors (seen for example [here](http://sces.phys.utk.edu/publications/Pub2011/7-FOP-11107-ED.pdf)) on a square lattice:\n", + "\n", + "\\begin{equation}\n", + "\\begin{split}\n", + " H_{TB} & = -t_1 \\sum_{i,\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{y},x,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{x}, y, \\sigma} + h.c. \\right) \\\\\n", + " & -t_2 \\sum_{i,\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{x},x,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{y}, y, \\sigma} + h.c. \\right) \\\\\n", + " & -t_3 \\sum_{i,\\hat{\\mu}, \\hat{\\nu},\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{\\mu} + \\hat{\\nu},x,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{\\mu} + \\hat{\\nu}, y, \\sigma} + h.c. \\right) \\\\\n", + " & +t_4 \\sum_{i,\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{x}+\\hat{y},y,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{x}+\\hat{y},x,\\sigma} + h.c. \\right) \\\\\n", + " & -t_4 \\sum_{i,\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma}d_{i+\\hat{x}-\\hat{y},y,\\sigma} + d^{\\dagger}_{i,y,\\sigma}d_{i+\\hat{x}-\\hat{y},x,\\sigma} + h.c. \\right) \\\\\n", + " & -\\mu \\sum_{i} \\left( n_{i}^{x} + n_{i}^{y} \\right)\n", + "\\end{split}\n", + "\\end{equation}\n", + "\n", + "where $t_1 = -1.0, t_2 = 1.3, t_3 = t_4 = -0.85$ with operators $d^{\\dagger}_{i,\\alpha,\\sigma}$ and $d_{i,\\alpha,\\sigma}$ respectively create or annihilate electrons on an atom at site $i$, with orbital $\\alpha$, and spin $\\sigma$. The operator $n^{\\alpha}_{i}$ represents the number operator of an atom at a given orbital, i.e. $n^x_i = \\sum_{\\sigma} \\left( d^{\\dagger}_{i,x,\\sigma} d_{i,x,\\sigma} \\right)$. The indices in the Hamiltonian are assigned in the following manner: the index $i$ will correspond to a 2-tuple $(m,n)$ indicating the x and y coordinates of the atom in the lattice. Since there are 2 orbitals, $\\alpha \\in \\{x,y\\}$. Lastly, $\\sigma \\in \\{\\uparrow, \\downarrow \\}$. For the sake of simplicity of coding, we will remap these labels to integer values, meaning we will assign indices $m \\in L_x, n \\in L_y, a \\in \\mathbb{Z}^2, s \\in \\mathbb{Z}^2$ where $L_x$ is the $x$ dimension of the square lattice, and $L_y$ is the $y$ dimension of the square lattice. In the summations, $\\hat{x}$ and $\\hat{y}$ correspond to adjacent sites in the lattice, rather than the orbitals. The summation over unit vectors $\\hat{\\mu}$ and $\\hat{\\nu}$ correspond to the summing over unit vectors in all 8 cardinal and intercardinal directions without double counting." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import numpy as np\n", + "from qca.utils.utils import estimate_gsee\n", + "from pyLIQTR.PhaseEstimation.pe import PhaseEstimation\n", + "from networkx import get_node_attributes, draw, draw_networkx_edge_labels\n", + "from qca.utils.hamiltonian_utils import generate_two_orbital_nx, nx_to_two_orbital_hamiltonian" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "g_example = generate_two_orbital_nx(2,2)\n", + "pos = get_node_attributes(g_example, 'pos')\n", + "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in g_example.edges(data=True)]);\n", + "draw(g_example, pos)\n", + "draw_networkx_edge_labels(g_example,pos, edge_labels = edge_labels);" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-1.0 [0^ 0] +\n", + "-0.85 [0^ 4] +\n", + "-0.85 [0^ 8] +\n", + "-0.85 [0^ 12] +\n", + "0.85 [0^ 14] +\n", + "-1.0 [1^ 1] +\n", + "-0.85 [1^ 5] +\n", + "-0.85 [1^ 9] +\n", + "-0.85 [1^ 13] +\n", + "0.85 [1^ 15] +\n", + "-1.0 [2^ 2] +\n", + "-0.85 [2^ 6] +\n", + "-0.85 [2^ 10] +\n", + "0.85 [2^ 12] +\n", + "-0.85 [2^ 14] +\n", + "-1.0 [3^ 3] +\n", + "-0.85 [3^ 7] +\n", + "-0.85 [3^ 11] +\n", + "0.85 [3^ 13] +\n", + "-0.85 [3^ 15] +\n", + "-0.85 [4^ 0] +\n", + "-1.0 [4^ 4] +\n", + "-0.85 [4^ 8] +\n", + "-0.85 [4^ 10] +\n", + "-0.85 [4^ 12] +\n", + "-0.85 [5^ 1] +\n", + "-1.0 [5^ 5] +\n", + "-0.85 [5^ 9] +\n", + "-0.85 [5^ 11] +\n", + "-0.85 [5^ 13] +\n", + "-0.85 [6^ 2] +\n", + "-1.0 [6^ 6] +\n", + "-0.85 [6^ 8] +\n", + "-0.85 [6^ 10] +\n", + "-0.85 [6^ 14] +\n", + "-0.85 [7^ 3] +\n", + "-1.0 [7^ 7] +\n", + "-0.85 [7^ 9] +\n", + "-0.85 [7^ 11] +\n", + "-0.85 [7^ 15] +\n", + "-0.85 [8^ 0] +\n", + "-0.85 [8^ 4] +\n", + "-0.85 [8^ 6] +\n", + "-1.0 [8^ 8] +\n", + "-0.85 [8^ 12] +\n", + "-0.85 [9^ 1] +\n", + "-0.85 [9^ 5] +\n", + "-0.85 [9^ 7] +\n", + "-1.0 [9^ 9] +\n", + "-0.85 [9^ 13] +\n", + "-0.85 [10^ 2] +\n", + "-0.85 [10^ 4] +\n", + "-0.85 [10^ 6] +\n", + "-1.0 [10^ 10] +\n", + "-0.85 [10^ 14] +\n", + "-0.85 [11^ 3] +\n", + "-0.85 [11^ 5] +\n", + "-0.85 [11^ 7] +\n", + "-1.0 [11^ 11] +\n", + "-0.85 [11^ 15] +\n", + "-0.85 [12^ 0] +\n", + "0.85 [12^ 2] +\n", + "-0.85 [12^ 4] +\n", + "-0.85 [12^ 8] +\n", + "-1.0 [12^ 12] +\n", + "-0.85 [13^ 1] +\n", + "0.85 [13^ 3] +\n", + "-0.85 [13^ 5] +\n", + "-0.85 [13^ 9] +\n", + "-1.0 [13^ 13] +\n", + "0.85 [14^ 0] +\n", + "-0.85 [14^ 2] +\n", + "-0.85 [14^ 6] +\n", + "-0.85 [14^ 10] +\n", + "-1.0 [14^ 14] +\n", + "0.85 [15^ 1] +\n", + "-0.85 [15^ 3] +\n", + "-0.85 [15^ 7] +\n", + "-0.85 [15^ 11] +\n", + "-1.0 [15^ 15]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t1 = -1\n", + "t2 = 1.3\n", + "t3 = 0.85\n", + "t4 = 0.85\n", + "mu = 1\n", + "nx_to_two_orbital_hamiltonian(g_example, t1, t2, t3, t4, mu)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "g_current_limit = generate_two_orbital_nx(6,7)\n", + "g_ideal = generate_two_orbital_nx(10,10)\n", + "\n", + "##### START UNCOMMENT FOR TESTING\n", + "#n_test = 2\n", + "#g_current_limit = generate_two_orbital_nx(n_test,n_test) \n", + "#g_ideal = generate_two_orbital_nx(n_test,n_test)\n", + "##### END UNCOMMENT FOR TESTING\n", + "n_qubits_current_limit = len(g_current_limit)\n", + "n_qubits_ideal = len(g_ideal)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "ham_current_limit = nx_to_two_orbital_hamiltonian(g_current_limit,t1,t2,t3,t4,mu)\n", + "ham_ideal = nx_to_two_orbital_hamiltonian(g_ideal,t1,t2,t3,t4,mu)\n", + "trotter_order_current_limit = 2\n", + "trotter_steps_current_limit = 1\n", + "\n", + "trotter_order_ideal = 2\n", + "trotter_steps_ideal = 1\n", + "\n", + "#note that we would actually like ~10 bits of precision, it just takes a really long time to run\n", + "bits_precision_ideal = 1\n", + "bits_precision_current_limit = 1\n", + "\n", + "current_limit_args = {\n", + " 'trotterize' : True,\n", + " 'mol_ham' : ham_current_limit,\n", + " 'ev_time' : 1,\n", + " 'trot_ord' : trotter_order_current_limit,\n", + " 'trot_num' : trotter_steps_current_limit\n", + "}\n", + "\n", + "ideal_args = {\n", + " 'trotterize' : True,\n", + " 'mol_ham' : ham_ideal,\n", + " 'ev_time' : 1,\n", + " 'trot_ord' : trotter_order_ideal,\n", + " 'trot_num' : trotter_steps_ideal\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "starting\n", + "current limit time to generate high level: 0.16728520899778232\n", + "ideal time to generate high level: 0.9127594170131488\n" + ] + } + ], + "source": [ + "E_min_ideal = -len(ham_ideal.terms)\n", + "E_max_ideal = 0\n", + "ideal_omega = E_max_ideal-E_min_ideal\n", + "t_ideal = 2*np.pi/ideal_omega\n", + "ideal_phase_offset = E_max_ideal*t_ideal\n", + "\n", + "E_min_current_limit = -len(ham_current_limit.terms)\n", + "E_max_current_limit = 0\n", + "limited_omega = E_max_current_limit-E_min_current_limit\n", + "limited_t = 2*np.pi/limited_omega\n", + "limited_phase_offset = E_max_current_limit*limited_t\n", + "\n", + "init_state_ideal = [0] * n_qubits_ideal\n", + "init_state_current_limit = [0] * n_qubits_current_limit\n", + "\n", + "print('starting')\n", + "t0 = time.perf_counter()\n", + "gse_inst_current_limit = PhaseEstimation(\n", + " precision_order=bits_precision_current_limit,\n", + " init_state=init_state_current_limit,\n", + " phase_offset=limited_phase_offset,\n", + " include_classical_bits=False, # Do this so print to openqasm works\n", + " kwargs=current_limit_args)\n", + "gse_inst_current_limit.generate_circuit()\n", + "t1 = time.perf_counter()\n", + "print(f'current limit time to generate high level: {t1 - t0}')\n", + "\n", + "t0 = time.perf_counter()\n", + "gse_inst_ideal = PhaseEstimation(\n", + " precision_order=bits_precision_ideal,\n", + " init_state=init_state_ideal,\n", + " phase_offset=ideal_phase_offset,\n", + " include_classical_bits=False, # Do this so print to openqasm works\n", + " kwargs=ideal_args)\n", + "gse_inst_ideal.generate_circuit()\n", + "t1 = time.perf_counter()\n", + "print(f'ideal time to generate high level: {t1 - t0}')\n", + "\n", + "gse_circuit_ideal = gse_inst_ideal.pe_circuit\n", + "gse_circuit_current_limit = gse_inst_current_limit.pe_circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimating Ideal\n", + "Time to estimate Ideal: 266.92374454200035\n", + "Estimating Current Limit\n", + "Time to estimate Current Limit: 55.14061645799666\n" + ] + } + ], + "source": [ + "print('Estimating Ideal')\n", + "t0 = time.perf_counter()\n", + "estimate_gsee(gse_circuit_ideal, outdir='GSE/', circuit_name='ideal')\n", + "t1 = time.perf_counter()\n", + "print(f'Time to estimate Ideal: {t1-t0}')\n", + "\n", + "print('Estimating Current Limit')\n", + "t0 = time.perf_counter()\n", + "estimate_gsee(gse_circuit_current_limit, outdir='GSE/', circuit_name='current_limit')\n", + "t1 = time.perf_counter()\n", + "print(f'Time to estimate Current Limit: {t1-t0}')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qca/utils/hamiltonian_utils.py b/src/qca/utils/hamiltonian_utils.py index eca9532..904c909 100644 --- a/src/qca/utils/hamiltonian_utils.py +++ b/src/qca/utils/hamiltonian_utils.py @@ -1,8 +1,8 @@ import random +from pyLIQTR.utils import Hamiltonian from networkx import relabel_nodes, Graph, grid_graph from networkx.generators.lattice import grid_2d_graph from openfermion import FermionOperator, QubitOperator -from pyLIQTR.utils import Hamiltonian def flatten_nx_graph(graph: Graph) -> Graph: new_ids = {} @@ -217,4 +217,4 @@ def assign_directional_triangular_labels(g:Graph, lattice_size:int) -> None: g[(i,j)][i+1,j+1]['label'] = 'Y' g[(i,lattice_size-1)][(i+1,lattice_size-1)]['label'] = 'Z' for j in range(lattice_size - 1): - g[(lattice_size-1,j)][(lattice_size-1,j+1)]['label'] = 'X' \ No newline at end of file + g[(lattice_size-1,j)][(lattice_size-1,j+1)]['label'] = 'X' From 36246ff09f9d835eb2a452d8d572765ec64e8d30 Mon Sep 17 00:00:00 2001 From: Jonhas Colina <159941307+JonhasSC@users.noreply.github.com> Date: Wed, 28 Feb 2024 11:49:09 -0700 Subject: [PATCH 07/11] PhotoSynthesis Notebook pyLIQTR1.0 Migration (#6) * translated PyLIQTR1.0 to Photosynthesis example. GSE object was originally just a wrapped PE object, so had to explicitly specify PE objects now for GSEE * made the change to pyliqtr1.0 to HightemperatureSuperConductorExample jupyter notebook * added output for the notebook * whitespace changes t photosynthesis * removed old fermi hubbard notebook * removed unused imports * added hamiltonian utils file. Would proabbly be moved to some hamiltonian module in the future * have the notebook use the packaged utility functions * finalized adding additional features for fermi hubbard support * fixed pyproject versioning * finished modularizing qca with respect to photosynthesis notebook --- PhotosynthesisExample.ipynb | 371 -------------------------- notebooks/PhotosynthesisExample.ipynb | 273 +++++++++++++++++++ src/qca/utils/utils.py | 5 + 3 files changed, 278 insertions(+), 371 deletions(-) delete mode 100644 PhotosynthesisExample.ipynb create mode 100644 notebooks/PhotosynthesisExample.ipynb diff --git a/PhotosynthesisExample.ipynb b/PhotosynthesisExample.ipynb deleted file mode 100644 index 2dbe453..0000000 --- a/PhotosynthesisExample.ipynb +++ /dev/null @@ -1,371 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "16833c13-2d9f-4ce6-997a-3b9b80e06efc", - "metadata": {}, - "source": [ - "# Ground State Energy Estimation for Photosynthesis with Quantum Circuits" - ] - }, - { - "cell_type": "markdown", - "id": "8c340bc4-f690-453b-88f9-3b21300e4fae", - "metadata": {}, - "source": [ - "Artificial photosynthesis mimics natural photosynthesis by\n", - "absorbing solar light and splitting water into O2, protons (H+) and electrons (e).\n", - "\n", - "The electrons extracted from water can reduce protons or CO2\n", - "to produce energy carrier fuels such as H2 or hydrocarbons\n", - "\n", - "Water oxidation reaction\n", - "2H2O -> O2 + 4(H+) + 4e\n", - "\n", - "Proton reduciton reaction:\n", - "2(H+) + 2e -> H2\n", - "\n", - "CO2 reduciton reactions:\n", - "- CO2 + 2(H+) + 2e -> CO + H2O (CO2 Reduction 1)\n", - "\n", - "- CO2 + 6(H+) + 6e -> CH3OH + H2O (CO2 Reduction 2)\n", - "\n", - "- CO2 + 8(H+) + 8e -> CH4 + 2H2O (CO2 Reduction 3)\n", - "\n", - "Typical examples of water oxidation:\n", - "Co_4O_4 catalysis (https://pubs.acs.org/doi/10.1021/ja202320q)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "63b75a0f-0fa9-4d28-8cc0-944a83e34289", - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "import re\n", - "from openfermion.chem import MolecularData\n", - "from openfermionpyscf import run_pyscf\n", - "from openfermion.transforms import get_fermion_operator, jordan_wigner, bravyi_kitaev\n", - "from openfermion.linalg import get_ground_state, get_sparse_operator\n", - "\n", - "import networkx as nx\n", - "import openfermion as of\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import time\n", - "import cirq\n", - "import os\n", - "from pyLIQTR.utils.utils import count_T_gates, open_fermion_to_qasm\n", - "from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform\n", - "from cirq.contrib.qasm_import import circuit_from_qasm\n", - "from pyLIQTR.GSE.GSE import GSE\n", - "from pyLIQTR.QSP.qsp_helpers import qsp_decompose_once" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "356dc68e-36ec-47cc-80b1-ad1cbe945894", - "metadata": {}, - "outputs": [], - "source": [ - "def extract_number(string):\n", - " number = re.findall(r'\\d+', string)\n", - " return int(number[0]) if number else None\n", - "\n", - "def count_gates(cpt_circuit):\n", - " count = 0\n", - " for moment in cpt_circuit:\n", - " for operator in moment:\n", - " count += 1\n", - " return count\n", - "\n", - "def num_fermion_qubits(ham):\n", - " n_qubits = 0\n", - " for term in ham.terms:\n", - " for op in term:\n", - " qubit = op[0]\n", - " if qubit >= n_qubits:\n", - " n_qubits = qubit+1\n", - " return n_qubits\n", - "\n", - "def estimate_gse(circuit, outdir, circuit_name=\"gse_circuit\"):\n", - " if not os.path.exists(outdir):\n", - " os.makedirs(outdir)\n", - " \n", - " subcircuit_counts = dict()\n", - " t_counts = dict()\n", - " clifford_counts = dict()\n", - " gate_counts = dict()\n", - " subcircuit_depths = dict()\n", - " \n", - " outfile_data = outdir+circuit_name+\"_high_level.dat\"\n", - " \n", - " for moment in circuit:\n", - " for operation in moment:\n", - " gate_type = type(operation.gate)\n", - " if gate_type in subcircuit_counts:\n", - " subcircuit_counts[gate_type] += 1\n", - " else:\n", - " decomposed_circuit = qsp_decompose_once(qsp_decompose_once(cirq.Circuit(operation)))\n", - " cpt_circuit = clifford_plus_t_direct_transform(decomposed_circuit)\n", - " \n", - " outfile_qasm_decomposed = outdir+str(gate_type)[8:-2]+\".decomposed.qasm\"\n", - " outfile_qasm_cpt = outdir+str(gate_type)[8:-2]+\".cpt.qasm\"\n", - " \n", - " if write_circuits:\n", - " with open(outfile_qasm_decomposed, 'w') as f:\n", - " print_to_openqasm(f, decomposed_circuit, qubits=decomposed_circuit.all_qubits())\n", - " \n", - " with open(outfile_qasm_cpt, 'w') as f:\n", - " print_to_openqasm(f, cpt_circuit, qubits=cpt_circuit.all_qubits())\n", - " \n", - " subcircuit_counts[gate_type] = 1\n", - " subcircuit_depths[gate_type] = len(cpt_circuit)\n", - " t_counts[gate_type] = count_T_gates(cpt_circuit)\n", - " gate_counts[gate_type] = count_gates(cpt_circuit)\n", - " clifford_counts[gate_type] = gate_counts[gate_type] - t_counts[gate_type]\n", - " \n", - " \n", - " total_gate_count = 0\n", - " total_gate_depth = 0\n", - " total_T_count = 0\n", - " total_clifford_count = 0\n", - " for gate in subcircuit_counts:\n", - " total_gate_count += subcircuit_counts[gate] * gate_counts[gate]\n", - " total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate]\n", - " total_T_count += subcircuit_counts[gate] * t_counts[gate]\n", - " total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate]\n", - " with open(outfile_data, 'w') as f:\n", - " total_gate_count \n", - " f.write(str(\"Logical Qubit Count:\"+str(len(circuit.all_qubits()))+\"\\n\"))\n", - " f.write(str(\"Total Gate Count:\"+str(total_gate_count)+\"\\n\"))\n", - " f.write(str(\"Total Gate Depth:\"+str(total_gate_depth)+\"\\n\"))\n", - " f.write(str(\"Total T Count:\"+str(total_T_count)+\"\\n\"))\n", - " f.write(str(\"Total Clifford Count:\"+str(total_clifford_count)+\"\\n\"))\n", - " f.write(\"Subcircuit Info:\\n\")\n", - " for gate in subcircuit_counts:\n", - " f.write(str(str(gate)+\"\\n\"))\n", - " f.write(str(\"Subcircuit Occurrences:\"+str(subcircuit_counts[gate])+\"\\n\"))\n", - " f.write(str(\"Gate Count:\"+str(gate_counts[gate])+\"\\n\"))\n", - " f.write(str(\"Gate Depth:\"+str(subcircuit_depths[gate])+\"\\n\"))\n", - " f.write(str(\"T Count:\"+str(t_counts[gate])+\"\\n\"))\n", - " f.write(str(\"Clifford Count:\"+str(clifford_counts[gate])+\"\\n\"))\n", - "\n", - "def load_pathway_xyz(fname, pathway=None):\n", - " coordinates_pathway = []\n", - " with open(fname) as f:\n", - " data = f.readlines()\n", - " coordinates_pathway = []\n", - " for k, line in enumerate(data):\n", - " if \"multiplicity\" in line or \"charge\" in line:\n", - " coords_list = []\n", - " geo_name = None\n", - " if len(line.split(',')) > 2:\n", - " geo_name = line.split(',')[2]\n", - "\n", - " # Use a regular expression to extract the multiplicity value\n", - " match = re.search(r\"multiplicity\\s*=\\s*(\\d+)\", line)\n", - " if match:\n", - " multiplicity = int(match.group(1)) # Convert the string to an integer\n", - " match = re.search(r\"charge\\s*=\\s*(\\d+)\", line)\n", - " if match:\n", - " charge = int(match.group(1)) # Convert the string to an integer\n", - "\n", - " nat = int(data[k-1].split()[0])\n", - " print(f\"{geo_name} Multiplicity: {multiplicity} total no. of atoms={nat}, charge = {charge}\")\n", - " coords_list.append([nat, charge, multiplicity])\n", - " for i in range(nat):\n", - " tmp = data[k+1+i].split()\n", - " aty = tmp[0]\n", - " xyz = [float(tmp[i]) for i in range(1,4)]\n", - " coords_list.append([aty, xyz])\n", - "\n", - " if geo_name is not None and pathway is not None:\n", - " order = extract_number(geo_name)\n", - " if order is not None and order in pathway:\n", - " #print(f\"{geo_name} is in pathway 1\")\n", - " coordinates_pathway.append(coords_list)\n", - " else:\n", - " coordinates_pathway.append(coords_list)\n", - " return coordinates_pathway\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "de1743f4-5721-46b4-aa30-e4a26843b542", - "metadata": {}, - "outputs": [], - "source": [ - "molecular_hamiltonians = []\n", - "pathway0 = [5, 10, 28, 29, 30, 31, 32, 33]\n", - "pathway1 = [2, 1, 14, 15, 16, 17, 18, 19]\n", - "pathway2 = [3, 1, 14, 15, 16, 20, 21, 22, 23]\n", - "pathway3 = [27, 1, 14, 15, 16, 24, 25, 26]\n", - "#Water oxidation via Co4O4 catalyst.\n", - "# water oxidation\n", - "coordinates_pathway = load_pathway_xyz(\"data/water_oxidation_Co4O4.xyz\", pathway=pathway0)\n", - "\n", - "# co2 reduction\n", - "coordinates_pathway = load_pathway_xyz(\"data/CO2_reduciton_CoPc.xyz\")\n", - "\n", - "# Set calculation parameters.\n", - "run_scf = 1\n", - "run_mp2 = 0\n", - "run_cisd = 0\n", - "run_ccsd = 0\n", - "run_fci = 0\n", - "\n", - "# Set molecule parameters.\n", - "basis = 'sto-3g'\n", - "multiplicity = 1\n", - "n_points = 40\n", - "bond_length_interval = 3.0 / n_points\n", - "\n", - "print(\"\\n Generating the electronic Hamiltonain along the reaction pathway!\\n\")\n", - "active_space_frac = 5 # 1 over n\n", - "\n", - "if len(coordinates_pathway) > 0:\n", - " # generate the Hamiltonians\n", - " for coords in coordinates_pathway:\n", - " nat, charge, multi = [int(coords[0][j]) for j in range(3)]\n", - " print(f\"\\nGenerating the qubit Hamiltonian for the molecule: \\n {coords}\\n\")\n", - " #print(f\"\\nNatoms={nat} charge={charge} multiplicity={multi}\")\n", - "\n", - " # set molecular geometry in pyscf format\n", - " basis = \"cc-pvdz\"\n", - " #basis = \"STO3G\"\n", - " geometry = []\n", - " for k, coord in enumerate(coords[1:]):\n", - " coord_str = ' '.join(map(str, coord[1]))\n", - " if k == nat-1:\n", - " coord_str = f\"{coord[0]} {coord_str}\"\n", - " else:\n", - " coord_str = f\"{coord[0]} {coord_str};\\n\"\n", - " atom = (coord[0], tuple(coord[1]))\n", - " geometry.append(atom)\n", - "\n", - " molecule = MolecularData(geometry, basis, multi, charge=charge, description=\"catalyst\")\n", - "\n", - " print(\"no, of atoms = \", len(geometry))\n", - " # Run pyscf.\n", - " molecule = run_pyscf(molecule,\n", - " run_scf=run_scf,\n", - " run_mp2=run_mp2,\n", - " run_cisd=run_cisd,\n", - " run_ccsd=run_ccsd,\n", - " run_fci=run_fci)\n", - "\n", - " print(f\"number of orbitals = {molecule.n_orbitals}\")\n", - " print(f\"number of electrons = {molecule.n_electrons}\")\n", - "\n", - " print(f\"number of qubits = {molecule.n_qubits}\")\n", - " print(f\"Hartree-Fock energy = {molecule.hf_energy}\")\n", - " nocc = molecule.n_electrons // 2\n", - " nvir = molecule.n_orbitals - nocc\n", - " sys.stdout.flush()\n", - "\n", - " # get molecular Hamiltonian\n", - " active_space_start = nocc - nocc // active_space_frac # start index of active space\n", - " active_space_stop = nocc + nvir // active_space_frac # end index of active space\n", - "\n", - " print(f\"active_space start = {active_space_start}\")\n", - " print(f\"active_space stop = {active_space_stop}\")\n", - " sys.stdout.flush()\n", - " sys.exit()\n", - "\n", - " molecular_hamiltonian = molecule.get_molecular_hamiltonian(\n", - " occupied_indices=range(active_space_start),\n", - " active_indices=range(active_space_start, active_space_stop)\n", - " )\n", - "\n", - " # shifted by HF energy\n", - " molecular_hamiltonian -= molecule.hf_energy\n", - " molecular_hamiltonians.append(molecular_hamiltonian)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2e6b71f6-2027-427e-b39d-d670fba38894", - "metadata": {}, - "outputs": [], - "source": [ - "for i in molecular_hamiltonians:\n", - " molecular_hamiltonian = molecular_hamiltonians[i]\n", - " trotter_order = 2\n", - " trotter_steps = 1\n", - " n_qubits = molecular_hamiltonian.n_qubits\n", - " #note that we would actually like within chemical precision\n", - " #which should take > 10 bits of precision, it just takes a \n", - " #really long time to run so a scaling argument will be needed\n", - " bits_precision = 1\n", - " \n", - " gse_args = {\n", - " 'trotterize' : True,\n", - " 'mol_ham' : molecular_hamiltonian,\n", - " 'ev_time' : 1,\n", - " 'trot_ord' : trotter_order,\n", - " 'trot_num' : trotter_steps\n", - " }\n", - "\n", - " E_min = -4000\n", - " E_max = -3000\n", - " \n", - " init_state = [0] * n_qubits\n", - " \n", - " print(\"starting\")\n", - " t0 = time.perf_counter()\n", - " gse_inst = GSE(\n", - " precision_order=bits_precision,\n", - " init_state=init_state,\n", - " E_max = E_max,\n", - " E_min = E_min,\n", - " include_classical_bits=False, # Do this so print to openqasm works\n", - " kwargs=gse_args)\n", - " t1 = time.perf_counter()\n", - " print(\"Co4O4 time to generate high level number \" +str(i)+ \": \", t1 - t0)\n", - " gse_circuit = gse_inst.pe_inst.pe_circuit\n", - " \n", - " print(\"Estimating Co4O4 circuit \" + str(i))\n", - " t0 = time.perf_counter()\n", - " estimate_gse(gse_circuit, outdir=\"GSE/\", circuit_name=\"Co4O4_\"+str(i))\n", - " t1 = time.perf_counter()\n", - " print(\"Time to estimate Co4O4:\", t1-t0)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "10ae61fd-03b3-447c-bbc5-2aa68028f755", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.8.8" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/PhotosynthesisExample.ipynb b/notebooks/PhotosynthesisExample.ipynb new file mode 100644 index 0000000..fb09618 --- /dev/null +++ b/notebooks/PhotosynthesisExample.ipynb @@ -0,0 +1,273 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Ground State Energy Estimation for Photosynthesis with Quantum Circuits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Artificial photosynthesis mimics natural photosynthesis by\n", + "absorbing solar light and splitting water into O2, protons (H+) and electrons (e).\n", + "\n", + "The electrons extracted from water can reduce protons or CO2\n", + "to produce energy carrier fuels such as H2 or hydrocarbons\n", + "\n", + "Water oxidation reaction\n", + "2H2O -> O2 + 4(H+) + 4e\n", + "\n", + "Proton reduciton reaction:\n", + "2(H+) + 2e -> H2\n", + "\n", + "CO2 reduciton reactions:\n", + "- CO2 + 2(H+) + 2e -> CO + H2O (CO2 Reduction 1)\n", + "\n", + "- CO2 + 6(H+) + 6e -> CH3OH + H2O (CO2 Reduction 2)\n", + "\n", + "- CO2 + 8(H+) + 8e -> CH4 + 2H2O (CO2 Reduction 3)\n", + "\n", + "Typical examples of water oxidation:\n", + "Co_4O_4 catalysis (https://pubs.acs.org/doi/10.1021/ja202320q)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "import re\n", + "import sys\n", + "import time\n", + "import numpy as np\n", + "from openfermionpyscf import run_pyscf\n", + "from openfermion.chem import MolecularData\n", + "from pyLIQTR.PhaseEstimation.pe import PhaseEstimation\n", + "from qca.utils.utils import extract_number, estimate_gsee" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def load_pathway_xyz(fname, pathway=None):\n", + " coordinates_pathway = []\n", + " with open(fname) as f:\n", + " data = f.readlines()\n", + " coordinates_pathway = []\n", + " for k, line in enumerate(data):\n", + " if 'multiplicity' in line or 'charge' in line:\n", + " coords_list = []\n", + " geo_name = None\n", + " if len(line.split(',')) > 2:\n", + " geo_name = line.split(',')[2]\n", + "\n", + " # Use a regular expression to extract the multiplicity value\n", + " match = re.search(r\"multiplicity\\s*=\\s*(\\d+)\", line)\n", + " if match:\n", + " multiplicity = int(match.group(1)) # Convert the string to an integer\n", + " match = re.search(r\"charge\\s*=\\s*(\\d+)\", line)\n", + " if match:\n", + " charge = int(match.group(1)) # Convert the string to an integer\n", + "\n", + " nat = int(data[k-1].split()[0])\n", + " print(f'{geo_name} Multiplicity: {multiplicity} total no. of atoms={nat}, charge = {charge}')\n", + " coords_list.append([nat, charge, multiplicity])\n", + " for i in range(nat):\n", + " tmp = data[k+1+i].split()\n", + " aty = tmp[0]\n", + " xyz = [float(tmp[i]) for i in range(1,4)]\n", + " coords_list.append([aty, xyz])\n", + "\n", + " if geo_name is not None and pathway is not None:\n", + " order = extract_number(geo_name)\n", + " if order is not None and order in pathway:\n", + " coordinates_pathway.append(coords_list)\n", + " else:\n", + " coordinates_pathway.append(coords_list)\n", + " return coordinates_pathway" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "molecular_hamiltonians = []\n", + "pathway0 = [5, 10, 28, 29, 30, 31, 32, 33]\n", + "pathway1 = [2, 1, 14, 15, 16, 17, 18, 19]\n", + "pathway2 = [3, 1, 14, 15, 16, 20, 21, 22, 23]\n", + "pathway3 = [27, 1, 14, 15, 16, 24, 25, 26]\n", + "# Water oxidation via Co4O4 catalyst.\n", + "# water oxidation\n", + "coordinates_pathway = load_pathway_xyz('../data/water_oxidation_Co4O4.xyz', pathway=pathway0)\n", + "\n", + "# co2 reduction\n", + "coordinates_pathway = load_pathway_xyz('../data/CO2_reduciton_CoPc.xyz')\n", + "\n", + "# Set calculation parameters.\n", + "run_scf = 1\n", + "run_mp2 = 0\n", + "run_cisd = 0\n", + "run_ccsd = 0\n", + "run_fci = 0\n", + "\n", + "# Set molecule parameters.\n", + "basis = 'sto-3g'\n", + "multiplicity = 1\n", + "n_points = 40\n", + "bond_length_interval = 3.0 / n_points\n", + "active_space_frac = 5 # 1 over n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print('\\nGenerating the electronic Hamiltonain along the reaction pathway!\\n')\n", + "\n", + "if len(coordinates_pathway) > 0:\n", + " # generate the Hamiltonians\n", + " for coords in coordinates_pathway:\n", + " nat, charge, multi = [int(coords[0][j]) for j in range(3)]\n", + " print(f'\\nGenerating the qubit Hamiltonian for the molecule: \\n {coords}\\n')\n", + "\n", + " # set molecular geometry in pyscf format\n", + " basis = 'cc-pvdz'\n", + " #basis = \"STO3G\"\n", + " geometry = []\n", + " for k, coord in enumerate(coords[1:]):\n", + " coord_str = ' '.join(map(str, coord[1]))\n", + " if k == nat-1:\n", + " coord_str = f'{coord[0]} {coord_str}'\n", + " else:\n", + " coord_str = f'{coord[0]} {coord_str};\\n'\n", + " atom = (coord[0], tuple(coord[1]))\n", + " geometry.append(atom)\n", + "\n", + " molecule = MolecularData(geometry, basis, multi, charge=charge, description='catalyst')\n", + "\n", + " print(f'no, of atoms = {len(geometry)}')\n", + " # Run pyscf.\n", + " molecule = run_pyscf(molecule,\n", + " run_scf=run_scf,\n", + " run_mp2=run_mp2,\n", + " run_cisd=run_cisd,\n", + " run_ccsd=run_ccsd,\n", + " run_fci=run_fci)\n", + "\n", + " print(f'number of orbitals = {molecule.n_orbitals}')\n", + " print(f'number of electrons = {molecule.n_electrons}')\n", + "\n", + " print(f'number of qubits = {molecule.n_qubits}')\n", + " print(f'Hartree-Fock energy = {molecule.hf_energy}')\n", + " nocc = molecule.n_electrons // 2\n", + " nvir = molecule.n_orbitals - nocc\n", + " sys.stdout.flush()\n", + "\n", + " # get molecular Hamiltonian\n", + " active_space_start = nocc - nocc // active_space_frac # start index of active space\n", + " active_space_stop = nocc + nvir // active_space_frac # end index of active space\n", + "\n", + " print(f'active_space start = {active_space_start}')\n", + " print(f'active_space stop = {active_space_stop}')\n", + " \n", + "\n", + " molecular_hamiltonian = molecule.get_molecular_hamiltonian(\n", + " occupied_indices=range(active_space_start),\n", + " active_indices=range(active_space_start, active_space_stop)\n", + " )\n", + "\n", + " # shifted by HF energy\n", + " molecular_hamiltonian -= molecule.hf_energy\n", + " molecular_hamiltonians.append(molecular_hamiltonian)\n", + " sys.stdout.flush()\n", + " sys.exit()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "E_min = -4000\n", + "E_max = -3000\n", + "omega = E_max - E_min\n", + "t = 2*np.pi/omega\n", + "phase_offset = E_max * t\n", + "for i in molecular_hamiltonians:\n", + " molecular_hamiltonian = molecular_hamiltonians[i]\n", + " trotter_order = 2\n", + " trotter_steps = 1\n", + " n_qubits = molecular_hamiltonian.n_qubits\n", + " # note that we would actually like within chemical precision\n", + " # which should take > 10 bits of precision, it just takes a \n", + " # really long time to run so a scaling argument will be needed\n", + " bits_precision = 1\n", + " \n", + " gse_args = {\n", + " 'trotterize' : True,\n", + " 'mol_ham' : molecular_hamiltonian,\n", + " 'ev_time' : 1,\n", + " 'trot_ord' : trotter_order,\n", + " 'trot_num' : trotter_steps\n", + " }\n", + "\n", + " \n", + " init_state = [0] * n_qubits\n", + " \n", + " print('starting')\n", + " t0 = time.perf_counter()\n", + " gse_inst = PhaseEstimation(\n", + " precision_order=bits_precision,\n", + " init_state=init_state,\n", + " phase_offset=phase_offset,\n", + " include_classical_bits=False,\n", + " kwargs=gse_args\n", + " )\n", + " gse_inst.generate_circuit()\n", + " t1 = time.perf_counter()\n", + " print(f'Co4O4 time to generate high level number {i} : {t1 - t0}')\n", + " gse_circuit = gse_inst.pe_circuit\n", + " \n", + " print('Estimating Co4O4 circuit {i}')\n", + " t0 = time.perf_counter()\n", + " estimate_gsee(gse_circuit, outdir='GSE/', circuit_name=f'Co4O4_{i}')\n", + " t1 = time.perf_counter()\n", + " print(f'Time to estimate Co4O4: {t1-t0}')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/qca/utils/utils.py b/src/qca/utils/utils.py index c5856dd..25ea43a 100644 --- a/src/qca/utils/utils.py +++ b/src/qca/utils/utils.py @@ -1,4 +1,5 @@ import os +import re from cirq import Circuit, QasmOutput, AbstractCircuit from pyLIQTR.utils.qsp_helpers import circuit_decompose_once from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform @@ -12,6 +13,10 @@ def count_gates(cpt_circuit: AbstractCircuit) -> int: count += len(moment) return count +def extract_number(string): + number = re.findall(r'\d+', string) + return int(number[0]) if number else None + def get_T_depth_wire(cpt_circuit: AbstractCircuit): # maximum number of T-gates on a wire. This may be more optimistic than # number of layers with T-gates. Perhaps good to treat as lower bound From de442b562a96fd9ece00e2352cfc09ab8c5d30c5 Mon Sep 17 00:00:00 2001 From: Zain Mughal <93842795+zain2864@users.noreply.github.com> Date: Mon, 4 Mar 2024 11:27:18 -0700 Subject: [PATCH 08/11] RuCl migration of pyLIQTR-1.0 (#4) * RuCl migration of pyLIQTR-1.0 * deleted old RuCl notebook * Fix Trotter printing, update pyproject.toml to use pyLIQTR 1.0.0, update gitignore * updated notebook to take out unused imports and fix unused colors issue * structured RuCl notebook to use qca package, fixed plot_T_histogram header in qca.utils.utils * removed unused functs and imports, changed the plot_histogram funct in qca, and reverted some previous changes, fixed plotting, changed assign_labels to allow generic x y z labels * added default args to assign_hexagon_labels, removed the commented code for plotting for qsp, made the labels uppercase --------- Co-authored-by: Zain Mughal Co-authored-by: Zachary Alexander Morrell --- .gitignore | 3 + RuClExample.ipynb | 1069 ---------------------------- notebooks/MagneticLattices.ipynb | 75 +- notebooks/RuClExample.ipynb | 989 +++++++++++++++++++++++++ src/qca/utils/hamiltonian_utils.py | 8 +- 5 files changed, 1038 insertions(+), 1106 deletions(-) delete mode 100644 RuClExample.ipynb create mode 100644 notebooks/RuClExample.ipynb diff --git a/.gitignore b/.gitignore index b97d95b..008eb2f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,8 +1,11 @@ Trotter/* +notebooks/Trotter/* QSP/* +notebooks/QSP/* .ipynb* *.sh GSE/* +notebooks/GSE/* *.zip qasm_circuits/* diff --git a/RuClExample.ipynb b/RuClExample.ipynb deleted file mode 100644 index 4a85b24..0000000 --- a/RuClExample.ipynb +++ /dev/null @@ -1,1069 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "e5f96d16-ff66-4a0c-b801-5b9eda3a4efc", - "metadata": { - "tags": [] - }, - "source": [ - "# RuCl Full Scale Example\n", - "We can now implement a full scale example, with details described here https://www.nature.com/articles/s41535-019-0203-y" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "38469f7e-7a4f-4efb-8dc4-e4d36186ab3d", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "import networkx as nx\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import random\n", - "import time\n", - "import sys\n", - "import os\n", - "import openfermion\n", - "from openfermion.circuits import trotter\n", - "import re\n", - "import pandas as pd\n", - "\n", - "import cirq\n", - "from cirq.contrib.svg import SVGCircuit\n", - "from cirq.contrib import qasm_import\n", - "\n", - "import pyLIQTR.QSP.gen_qsp as qspFuncs\n", - "import pyLIQTR.QSP.QSP as pQSP\n", - "\n", - "from pyLIQTR.QSP.Hamiltonian import Hamiltonian as pyH\n", - "from pyLIQTR.QSP.qsp_helpers import qsp_decompose_once, print_to_openqasm, prettyprint_qsp_to_qasm # these should move to a utils.\n", - "from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform\n", - "from pyLIQTR.utils.utils import count_T_gates, open_fermion_to_qasm" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "5d41c521-fa39-4ffd-9704-b60d4932e4da", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "##defining helper functions\n", - "t_init = time.perf_counter()\n", - "def get_T_depth_wire(cpt_circuit):\n", - " #maximum number of T-gates on a wire. This may be more optimistic than\n", - " #number of layers with T-gates. Perhaps good to treat as lower bound\n", - " #for an implementation\n", - " count_dict = dict()\n", - " for moment in cpt_circuit:\n", - " for operator in moment:\n", - " opstr = str(operator)\n", - " if opstr[0] == 'T':\n", - " reg_label = opstr[opstr.find(\"(\")+1:opstr.find(\")\")]\n", - " if not reg_label in count_dict:\n", - " count_dict[reg_label] = 1\n", - " else:\n", - " count_dict[reg_label] += 1\n", - " max_depth=0\n", - " for register in count_dict:\n", - " if count_dict[register] > max_depth:\n", - " max_depth = count_dict[register]\n", - " return max_depth\n", - "\n", - "def get_T_depth(cpt_circuit):\n", - " t_depth = 0\n", - " for moment in cpt_circuit:\n", - " for operator in moment:\n", - " opstr = str(operator)\n", - " if opstr[0] == 'T':\n", - " t_depth += 1\n", - " break\n", - " return t_depth\n", - "\n", - "def plot_T_step_histogram(cpt_circuit, lowest_ind=0, **kwargs):\n", - " t_widths = [0] * (len(cpt_circuit))\n", - " for (i, moment) in enumerate(cpt_circuit):\n", - " width = 0\n", - " for operator in moment:\n", - " opstr = str(operator)\n", - " if opstr[0] == 'T':\n", - " width += 1\n", - " t_widths[i] = width\n", - " bins = range(max(t_widths))\n", - " fig = plt.hist(t_widths, bins[lowest_ind:-1], **kwargs)\n", - " return fig\n", - " \n", - "def count_gates(cpt_circuit):\n", - " count = 0\n", - " for moment in cpt_circuit:\n", - " for operator in moment:\n", - " count += 1\n", - " return count\n", - "\n", - "def pyliqtr_hamiltonian_to_openfermion_qubit_operator(H):\n", - " open_fermion_operator = openfermion.QubitOperator()\n", - " for term in H.terms:\n", - " open_fermion_term = \"\"\n", - " for (i,pauli) in enumerate(term[0]):\n", - " if not pauli == 'I':\n", - " open_fermion_term = open_fermion_term + pauli + str(i) + \" \"\n", - " open_fermion_term_op = openfermion.QubitOperator(open_fermion_term)\n", - " if not open_fermion_term == \"\":\n", - " open_fermion_operator += term[1] * open_fermion_term_op\n", - " return open_fermion_operator\n", - "\n", - "def flatten_nx_graph(g):\n", - " new_ids = {}\n", - " count = 0\n", - " for node in g.nodes:\n", - " if node in new_ids:\n", - " pass\n", - " else:\n", - " new_ids[node] = count\n", - " count = count + 1\n", - " new_g = nx.relabel_nodes(g, new_ids)\n", - " return new_g\n", - "\n", - "def estimate_qsp(pyliqtr_hamiltonian, timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n", - " timestep_of_interest=1 #for magnus like argument\n", - " \n", - " t0 = time.perf_counter()\n", - " angles, tolerances = qspFuncs.compute_hamiltonian_angles(pyliqtr_hamiltonian, simtime=timestep_of_interest, req_prec=energy_precision)\n", - " qsp_generator = pQSP.QSP(phis=angles, hamiltonian=pyliqtr_hamiltonian, target_size=pyliqtr_hamiltonian.problem_size)\n", - " qsp_circuit = qsp_generator.circuit()\n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\" Time to generate high level QSP circuit: \" + str(elapsed) + \" seconds\")\n", - " \n", - " if not os.path.exists(outdir):\n", - " os.makedirs(outdir)\n", - " \n", - " subcircuit_counts = dict()\n", - " t_counts = dict()\n", - " t_depths = dict()\n", - " t_depth_wires = dict()\n", - " clifford_counts = dict()\n", - " gate_counts = dict()\n", - " subcircuit_depths = dict()\n", - " \n", - " outfile_qasm_high_level = outdir + hamiltonian_name + \"_high_level.qasm\"\n", - " outfile_data = outdir + hamiltonian_name + \"_high_level.dat\"\n", - " \n", - " for moment in qsp_circuit:\n", - " for operation in moment:\n", - " gate_type = type(operation.gate)\n", - " if gate_type in subcircuit_counts:\n", - " subcircuit_counts[gate_type] += 1\n", - " \n", - " else:\n", - " outfile_qasm_decomposed = outdir+str(gate_type)[8:-2]+\".decomposed.qasm\"\n", - " outfile_qasm_cpt = outdir+str(gate_type)[8:-2]+\".cpt.qasm\"\n", - " \n", - " t0 = time.perf_counter()\n", - " decomposed_circuit = qsp_decompose_once(qsp_decompose_once(cirq.Circuit(operation)))\n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\" Time to decompose high level \" + str(gate_type)[8:-2] +\" circuit: \" + str(elapsed) + \" seconds\")\n", - " \n", - " t0 = time.perf_counter()\n", - " cpt_circuit = clifford_plus_t_direct_transform(decomposed_circuit)\n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\" Time to transform decomposed \" + str(gate_type)[8:-2] + \" circuit to Clifford+T: \" + str(elapsed) + \" seconds\")\n", - " \n", - " if write_circuits:\n", - " with open(outfile_qasm_decomposed, 'w') as f:\n", - " print_to_openqasm(f, decomposed_circuit, qubits=decomposed_circuit.all_qubits())\n", - " \n", - " with open(outfile_qasm_cpt, 'w') as f:\n", - " print_to_openqasm(f, cpt_circuit, qubits=cpt_circuit.all_qubits())\n", - " \n", - " subcircuit_counts[gate_type] = 1\n", - " subcircuit_depths[gate_type] = len(cpt_circuit)\n", - " t_counts[gate_type] = count_T_gates(cpt_circuit)\n", - " gate_counts[gate_type] = count_gates(cpt_circuit)\n", - " t_depths[gate_type] = get_T_depth(cpt_circuit)\n", - " t_depth_wires[gate_type] = get_T_depth_wire(cpt_circuit)\n", - " clifford_counts[gate_type] = gate_counts[gate_type] - t_counts[gate_type]\n", - " \n", - " total_gate_count = 0\n", - " total_gate_depth = 0\n", - " total_T_depth = 0\n", - " total_T_depth_wire = 0\n", - " total_T_count = 0\n", - " total_clifford_count = 0\n", - " for gate in subcircuit_counts:\n", - " total_gate_count += subcircuit_counts[gate] * gate_counts[gate] * timesteps / timestep_of_interest\n", - " total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate] * timesteps / timestep_of_interest\n", - " total_T_depth += subcircuit_counts[gate] * t_depths[gate] * timesteps / timestep_of_interest\n", - " total_T_depth_wire += subcircuit_counts[gate] * t_depth_wires[gate] * timesteps / timestep_of_interest\n", - " total_T_count += subcircuit_counts[gate] * t_counts[gate] * timesteps / timestep_of_interest\n", - " total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate] * timesteps / timestep_of_interest\n", - " with open(outfile_data, 'w') as f:\n", - " total_gate_count \n", - " f.write(str(\"Logical Qubit Count:\"+str(len(qsp_circuit.all_qubits()))+\"\\n\"))\n", - " f.write(str(\"Total Gate Count:\"+str(total_gate_count)+\"\\n\"))\n", - " f.write(str(\"Total Gate Depth:\"+str(total_gate_depth)+\"\\n\"))\n", - " f.write(str(\"Total T Count:\"+str(total_T_count)+\"\\n\"))\n", - " f.write(str(\"Total T Depth:\"+str(total_T_depth)+\"\\n\"))\n", - " f.write(str(\"Maximum T Count on Single Wire:\"+str(total_T_depth_wire)+\"\\n\"))\n", - " f.write(str(\"Total Clifford Count:\"+str(total_clifford_count)+\"\\n\"))\n", - " f.write(\"Subcircuit Info:\\n\")\n", - " for gate in subcircuit_counts:\n", - " f.write(str(str(gate)+\"\\n\"))\n", - " f.write(str(\"Subcircuit Occurrences:\"+str(subcircuit_counts[gate]*timesteps)+\"\\n\"))\n", - " f.write(str(\"Gate Count:\"+str(gate_counts[gate])+\"\\n\"))\n", - " f.write(str(\"Gate Depth:\"+str(subcircuit_depths[gate])+\"\\n\"))\n", - " f.write(str(\"T Count:\"+str(t_counts[gate])+\"\\n\"))\n", - " f.write(str(\"T Depth:\"+str(t_depths[gate])+\"\\n\"))\n", - " f.write(str(\"Maximum T Count on a Single Wire:\"+str(t_depth_wires[gate])+\"\\n\"))\n", - " f.write(str(\"Clifford Count:\"+str(clifford_counts[gate])+\"\\n\"))\n", - " return qsp_circuit\n", - "\n", - "def find_hamiltonian_ordering(of_hamiltonian):\n", - " \"\"\"\n", - " Function to generate a near optimal term ordering for trotterization of transverse field Ising Models.\n", - " This would need to be modified if there were multi-qubit interactions that were not just ZZ\n", - " \"\"\"\n", - " #ordering hamiltonian terms by performing edge coloring to make optimal trotter ordering\n", - " #assuming that any 2 body interactions are ZZ\n", - " sorted_terms = sorted(list(of_hamiltonian.terms.keys()))\n", - " sorted_terms.sort(key=lambda x: len(x) * 100 + ord(x[0][1])) #Z and X get translated to 90 and 88 respectively, multiplying by 100 ensures interacting term weight is considered\n", - " one_body_terms_ordered = list(filter(lambda x: len(x) == 1, sorted_terms))\n", - " two_body_terms = list(filter(lambda x: len(x) == 2, sorted_terms))\n", - " \n", - " #assigning edge colorings to order two body terms\n", - " g = nx.Graph()\n", - " for term in two_body_terms:\n", - " edge = (term[0][0], term[1][0])\n", - " g.add_edge(*edge)\n", - " edge_coloring = nx.greedy_color(nx.line_graph(g))\n", - " nx.set_edge_attributes(g, edge_coloring, \"color\")\n", - " colors = list()\n", - " for (i,term) in enumerate(two_body_terms):\n", - " n1,n2 = (term[0][0], term[1][0])\n", - " color = g.edges[n1,n2]['color']\n", - " term = (*term, color)\n", - " two_body_terms[i] = term\n", - " \n", - " two_body_terms.sort(key=lambda x: x[2])\n", - " two_body_terms_ordered = list()\n", - " for (i,term) in enumerate(two_body_terms):\n", - " new_item = (term[0],term[1])\n", - " two_body_terms_ordered.append((term[0], term[1]))\n", - " return one_body_terms_ordered + two_body_terms_ordered\n", - "\n", - "def estimate_trotter(openfermion_hamiltonian,timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n", - " t0 = time.perf_counter()\n", - " nsteps = openfermion.circuits.trotter_steps_required(trotter_error_bound = openfermion.circuits.error_bound(list(openfermion_hamiltonian.get_operators()),tight=False),\n", - " time = timesteps, \n", - " energy_precision = energy_precision)\n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\" Time to estimate Number of steps required: \" + str(elapsed) + \" seconds\")\n", - " \n", - " t0 = time.perf_counter()\n", - " term_ordering = find_hamiltonian_ordering(openfermion_hamiltonian)\n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\" Time to find term ordering: \" + str(elapsed) + \" seconds\")\n", - " \n", - " t0 = time.perf_counter()\n", - " trotter_circuit_of = openfermion.circuits.trotter_exp_to_qgates.trotterize_exp_qubop_to_qasm(openfermion_hamiltonian, trotter_order=2, evolution_time=timesteps/nsteps, term_ordering=term_ordering)\n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\" Time to generate trotter circuit from openfermion: \" + str(elapsed) + \" seconds\")\n", - " \n", - " qasm_str_trotter = open_fermion_to_qasm(openfermion.count_qubits(openfermion_hamiltonian), trotter_circuit_of)\n", - " trotter_circuit_qasm = qasm_import.circuit_from_qasm(qasm_str_trotter)\n", - " \n", - " t0 = time.perf_counter()\n", - " cpt_trotter = clifford_plus_t_direct_transform(trotter_circuit_qasm)\n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\" Time to decompose trotter to Clifford + T: \" + str(elapsed) + \" seconds\")\n", - " \n", - " #writing the the higher level trotter circuit to a file as well as the clifford + T circuit\n", - " if not os.path.exists(outdir):\n", - " os.makedirs(outdir)\n", - " \n", - " if write_circuits:\n", - " outfile_qasm_decomposed = outdir + \"trotter_circuit_\" + hamiltonian_name + \".qasm\" \n", - " outfile_qasm_cpt = outdir + \"trotter_cpt_\" + hamiltonian_name + \".qasm\"\n", - " with open(outfile_qasm_decomposed, 'w') as f:\n", - " print_to_openqasm(f, trotter_circuit, qubits=trotter_circuit.all_qubits())\n", - " with open(outfile_qasm_cpt, 'w') as f:\n", - " print_to_openqasm(f, cpt_trotter, qubits=cpt_trotter.all_qubits())\n", - " \n", - " t0 = time.perf_counter()\n", - " outfile_data = outdir + \"trotter_\" + hamiltonian_name + \".dat\"\n", - " gate_count = count_gates(cpt_trotter)\n", - " t_count = count_T_gates(cpt_trotter)\n", - " t_depth = get_T_depth(cpt_trotter)\n", - " t_depth_wire = get_T_depth_wire(cpt_trotter)\n", - " with open(outfile_data, 'w') as f:\n", - " f.write(\"Logical Qubit Count:\"+str(len(cpt_trotter.all_qubits()))+\"\\n\")\n", - " f.write(\"Number of Trotter Steps Required (Loose Upper Bound):\"+ str(nsteps) +\"\\n\")\n", - " f.write(\"Total T Depth:\"+str(t_depth * nsteps)+\"\\n\")\n", - " f.write(\"Maximum T Count on a Single Wire:\"+str(t_depth_wire * nsteps)+\"\\n\")\n", - " f.write(\"Single Step Gate Count:\"+str(gate_count)+\"\\n\")\n", - " f.write(\"Single Step Gate Depth:\"+str(len(cpt_trotter))+\"\\n\")\n", - " f.write(\"Single Step T Count:\"+str(t_count)+\"\\n\")\n", - " f.write(\"Single Step T Depth:\"+str(t_depth)+\"\\n\")\n", - " f.write(\"Single Step Maximum T Count on a Single Wire:\"+str(t_depth_wire)+\"\\n\")\n", - " f.write(\"Single Step Clifford Count:\"+str(gate_count - t_count)+\"\\n\")\n", - " \n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\" Time to enumerate resource estimates: \" + str(elapsed) + \" seconds\")\n", - " \n", - " return cpt_trotter" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "0275aeb7-e4fc-4348-8256-e7aa5c0bef71", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def assign_hexagon_labels_rucl(g):\n", - " for n1, n2 in g.edges:\n", - " #start by making sure that the edges are ordered correctly\n", - " r1,c1 = n1\n", - " r2,c2 = n2\n", - " if r2 - r1 < 0 or c2 - c1 < 0:\n", - " swap_r2 = r1\n", - " swap_c2 = c1\n", - " r1 = r2\n", - " c1 = c2\n", - " r2 = swap_r2\n", - " c2 = swap_c2\n", - " \n", - " #now that they are ordered correctly, we can assign labels\n", - " label = ''\n", - " if c1 == c2:\n", - " label = 'Z1'\n", - " elif (((r1 % 2) + (c1 % 2)) % 2 == 0):#apparently you can differentiate X and Y labels based off nx's node label parity. Huh.\n", - " label = 'Y1'\n", - " else:\n", - " label = 'X1'\n", - " \n", - " g[n1][n2]['label'] = label\n", - " \n", - " #Adding next nearest and next-next nearest neighbor edges and labels\n", - " for n in g.nodes:\n", - " r,c = n\n", - " \n", - " #next nearest neighbors\n", - " if (r, c+2) in g:\n", - " g.add_edge(n, (r, c+2), label = 'Z2')\n", - " if (r+1, c+1) in g:\n", - " g.add_edge(n, (r+1, c+1), label = \"Y2\")\n", - " if (r-1, c+1) in g:\n", - " g.add_edge(n, (r-1, c+1), label = \"X2\")\n", - " \n", - " #next-next nearest neighbors\n", - " if (r+1, c) in g and not ((n, (r+1, c)) in g.edges):\n", - " g.add_edge(n, (r+1,c), label = \"Z3\")\n", - " if (r+1, c+2) in g and (r + c)%2 == 0:\n", - " g.add_edge(n, (r+1, c+2), label=\"X3\")\n", - " if (r-1, c+2) in g and (r + c)%2 == 1:\n", - " g.add_edge(n, (r-1, c+2), label=\"Y3\")\n", - "\n", - "g_rucl = nx.generators.lattice.hexagonal_lattice_graph(3,3)\n", - "pos = nx.get_node_attributes(g_rucl, 'pos')\n", - "assign_hexagon_labels_rucl(g_rucl)\n", - "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in g_rucl.edges(data=True)]);\n", - "nx.draw(g_rucl, pos, with_labels=True)\n", - "nx.draw_networkx_edge_labels(g_rucl, pos,edge_labels = edge_labels);" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "705727b5-1cc4-4da7-aa0f-06d08bf772d0", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
referencemethodJ1K1Gam1Gam_prime1J2K2J3K3
0Winter et al. PRBAb initio (DFT + exact diag.)-1.70-6.706.60-0.900.000.002.70000.00
1Winter et al. NCAb initio-inspired (INS fit)-0.50-5.002.500.000.000.000.50000.00
2Wu et al.THz spectroscopy fit-0.35-2.802.400.000.000.000.34000.00
3Cookmeyer and MooreMagnon thermal Hall (sign)-0.50-5.002.500.000.000.000.11250.00
4Kim and KeeDFT + t=U expansion-1.53-6.555.25-0.950.000.000.00000.00
5Suzuki and SugaMagnetic specific heat-1.53-24.405.25-0.950.000.000.00000.00
6Yadav et al.Quantum chemistry (MRCI)1.20-5.601.20-0.700.250.000.25000.00
7Ran et al.Spin wave fit to INS gap0.00-6.809.500.000.000.000.00000.00
8Hou et al.Constrained DFT + U-1.87-10.703.800.000.000.001.27000.63
9Wang et al.DFT + t=U expansion-0.30-10.906.100.000.000.000.03000.00
10Eichstaedt et al.Fully ab initio (DFT + cRPA + t=U)-1.40-14.309.80-2.230.00-0.631.00000.03
11Eichstaedt et al.Neglecting non-local Coulomb-0.20-4.503.00-0.730.00-0.330.70000.10
12Eichstaedt et al.Neglecting non-local SOC-1.30-13.309.40-2.300.00-0.671.00000.10
13Banerjee et al.Spin wave fit-4.607.000.000.000.000.000.00000.00
14Kim et al.DFT + t=U expansion-12.0017.0012.000.000.000.000.00000.00
15Kim and KeeDFT + t=U expansion-3.504.606.42-0.040.000.000.00000.00
16Winter et al.Ab initio (DFT + exact diag.)-5.507.608.400.200.000.002.30000.00
17Ozel et al.Spin wave fit/THz spectroscopy-0.951.153.800.000.000.000.00000.00
18Ozel et al.Spin wave fit/THz spectroscopy0.46-3.502.350.000.000.000.00000.00
\n", - "
" - ], - "text/plain": [ - " reference method J1 K1 \\\n", - "0 Winter et al. PRB Ab initio (DFT + exact diag.) -1.70 -6.70 \n", - "1 Winter et al. NC Ab initio-inspired (INS fit) -0.50 -5.00 \n", - "2 Wu et al. THz spectroscopy fit -0.35 -2.80 \n", - "3 Cookmeyer and Moore Magnon thermal Hall (sign) -0.50 -5.00 \n", - "4 Kim and Kee DFT + t=U expansion -1.53 -6.55 \n", - "5 Suzuki and Suga Magnetic specific heat -1.53 -24.40 \n", - "6 Yadav et al. Quantum chemistry (MRCI) 1.20 -5.60 \n", - "7 Ran et al. Spin wave fit to INS gap 0.00 -6.80 \n", - "8 Hou et al. Constrained DFT + U -1.87 -10.70 \n", - "9 Wang et al. DFT + t=U expansion -0.30 -10.90 \n", - "10 Eichstaedt et al. Fully ab initio (DFT + cRPA + t=U) -1.40 -14.30 \n", - "11 Eichstaedt et al. Neglecting non-local Coulomb -0.20 -4.50 \n", - "12 Eichstaedt et al. Neglecting non-local SOC -1.30 -13.30 \n", - "13 Banerjee et al. Spin wave fit -4.60 7.00 \n", - "14 Kim et al. DFT + t=U expansion -12.00 17.00 \n", - "15 Kim and Kee DFT + t=U expansion -3.50 4.60 \n", - "16 Winter et al. Ab initio (DFT + exact diag.) -5.50 7.60 \n", - "17 Ozel et al. Spin wave fit/THz spectroscopy -0.95 1.15 \n", - "18 Ozel et al. Spin wave fit/THz spectroscopy 0.46 -3.50 \n", - "\n", - " Gam1 Gam_prime1 J2 K2 J3 K3 \n", - "0 6.60 -0.90 0.00 0.00 2.7000 0.00 \n", - "1 2.50 0.00 0.00 0.00 0.5000 0.00 \n", - "2 2.40 0.00 0.00 0.00 0.3400 0.00 \n", - "3 2.50 0.00 0.00 0.00 0.1125 0.00 \n", - "4 5.25 -0.95 0.00 0.00 0.0000 0.00 \n", - "5 5.25 -0.95 0.00 0.00 0.0000 0.00 \n", - "6 1.20 -0.70 0.25 0.00 0.2500 0.00 \n", - "7 9.50 0.00 0.00 0.00 0.0000 0.00 \n", - "8 3.80 0.00 0.00 0.00 1.2700 0.63 \n", - "9 6.10 0.00 0.00 0.00 0.0300 0.00 \n", - "10 9.80 -2.23 0.00 -0.63 1.0000 0.03 \n", - "11 3.00 -0.73 0.00 -0.33 0.7000 0.10 \n", - "12 9.40 -2.30 0.00 -0.67 1.0000 0.10 \n", - "13 0.00 0.00 0.00 0.00 0.0000 0.00 \n", - "14 12.00 0.00 0.00 0.00 0.0000 0.00 \n", - "15 6.42 -0.04 0.00 0.00 0.0000 0.00 \n", - "16 8.40 0.20 0.00 0.00 2.3000 0.00 \n", - "17 3.80 0.00 0.00 0.00 0.0000 0.00 \n", - "18 2.35 0.00 0.00 0.00 0.0000 0.00 " - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rucl_references = [\"Winter et al. PRB\", \"Winter et al. NC\", \"Wu et al.\", \"Cookmeyer and Moore\", \"Kim and Kee\", \"Suzuki and Suga\", \n", - " \"Yadav et al.\", \"Ran et al.\", \"Hou et al.\", \"Wang et al.\", \"Eichstaedt et al.\", \"Eichstaedt et al.\", \n", - " \"Eichstaedt et al.\", \"Banerjee et al.\", \"Kim et al.\", \"Kim and Kee\", \"Winter et al.\", \"Ozel et al.\", \"Ozel et al.\"]\n", - "\n", - "rucl_methods = [\"Ab initio (DFT + exact diag.)\", \"Ab initio-inspired (INS fit)\", \"THz spectroscopy fit\",\n", - " \"Magnon thermal Hall (sign)\", \"DFT + t=U expansion\", \"Magnetic specific heat\", \"Quantum chemistry (MRCI)\",\n", - " \"Spin wave fit to INS gap\", \"Constrained DFT + U\", \"DFT + t=U expansion\", \"Fully ab initio (DFT + cRPA + t=U)\",\n", - " \"Neglecting non-local Coulomb\", \"Neglecting non-local SOC\", \"Spin wave fit\", \"DFT + t=U expansion\",\n", - " \"DFT + t=U expansion\", \"Ab initio (DFT + exact diag.)\", \"Spin wave fit/THz spectroscopy\", \"Spin wave fit/THz spectroscopy\"]\n", - "\n", - "rucl_J1 = [-1.7, -0.5, -0.35, -0.5, -1.53, -1.53, 1.2, 0, -1.87, -0.3, -1.4, -0.2, -1.3, -4.6, -12, -3.5, -5.5, -0.95, 0.46]\n", - "rucl_K1 = [-6.7, -5.0, -2.8, -5.0, -6.55, -24.4, -5.6, -6.8, -10.7, -10.9, -14.3, -4.5, -13.3, 7.0, 17., 4.6, 7.6, 1.15, -3.5]\n", - "rucl_Gam1 = [6.6, 2.5, 2.4, 2.5, 5.25, 5.25, 1.2, 9.5, 3.8, 6.1, 9.8, 3.0, 9.4, 0, 12., 6.42, 8.4, 3.8, 2.35]\n", - "rucl_Gam_prime1 = [-0.9, 0, 0, 0, -0.95, -0.95, -0.7, 0, 0, 0, -2.23, -0.73, -2.3, 0, 0, -0.04, 0.2, 0, 0]\n", - "rucl_J2 = [0, 0, 0, 0, 0, 0, 0.25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", - "rucl_K2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.63, -0.33, -0.67, 0, 0, 0, 0, 0, 0]\n", - "rucl_J3 = [2.7, 0.5, 0.34, 0.1125, 0, 0, 0.25, 0, 1.27, 0.03, 1.0, 0.7, 1.0, 0, 0, 0, 2.3, 0, 0]\n", - "rucl_K3 = [0, 0, 0, 0, 0, 0, 0, 0, 0.63, 0, 0.03, 0.1, 0.1, 0, 0, 0, 0, 0, 0]\n", - "\n", - "d_rucl = {'reference': rucl_references, 'method': rucl_methods, 'J1': rucl_J1, 'K1': rucl_K1,\n", - " 'Gam1': rucl_Gam1, 'Gam_prime1': rucl_Gam_prime1,\n", - " 'J2': rucl_J2, 'K2': rucl_K2, 'J3': rucl_J3, 'K3': rucl_K3}\n", - "df_rucl = pd.DataFrame(d_rucl)\n", - "df_rucl" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "c2c67168-10fb-4925-bbb4-a02013ec28f4", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "def nx_rucl_terms(g, data_series):\n", - " H = []\n", - " n = len(g.nodes)\n", - " for (n1,n2,d) in g.edges(data=True):\n", - " label = d['label'][0]\n", - " distance = int(d['label'][1])\n", - " \n", - " #Heisenberg and Kitaev terms\n", - " if distance == 1:\n", - " weight_J = data_series.J1\n", - " elif distance == 2:\n", - " weight_J = data_series.J2\n", - " else:\n", - " weight_J = data_series.J3\n", - " \n", - " if distance == 1:\n", - " weight_K = data_series.K1\n", - " elif distance == 2:\n", - " weight_K = data_series.K2\n", - " else:\n", - " weight_K = data_series.K3\n", - " \n", - " if not (weight_J == 0 and weight_K == 0):\n", - " string_x = n*'I' \n", - " string_y = n*'I' \n", - " string_z = n*'I'\n", - " \n", - " weight_x = weight_J\n", - " weight_y = weight_J\n", - " weight_z = weight_J\n", - " for i in [n1,n2]:\n", - " string_x = string_x[:i] + 'X' + string_x[i+1:]\n", - " string_y = string_y[:i] + 'Y' + string_y[i+1:]\n", - " string_z = string_z[:i] + 'Z' + string_z[i+1:]\n", - " if label == 'X':\n", - " weight_x += weight_K\n", - " elif label == 'Y':\n", - " weight_y += weight_K\n", - " else:\n", - " weight_z += weight_K\n", - " if weight_x != 0:\n", - " H.append((string_x, weight_x))\n", - " if weight_y != 0:\n", - " H.append((string_y, weight_y))\n", - " if weight_z != 0:\n", - " H.append((string_z, weight_z))\n", - " \n", - " #Gamma Terms\n", - " if distance == 1 and data_series.Gam1 != 0:\n", - " string_gam1_1 = n*'I'\n", - " string_gam1_2 = n*'I'\n", - " #unwrapping loop since there is no ordering guarantee\n", - " labels=['X', 'Y', 'Z']\n", - " labels.remove(label)\n", - " l1,l2 = labels\n", - " string_gam1_1 = string_gam1_1[:n1] + l1 + string_gam1_1[n1+1:]\n", - " string_gam1_1 = string_gam1_1[:n2] + l2 + string_gam1_1[n2+1:]\n", - " \n", - " string_gam1_2 = string_gam1_2[:n1] + l2 + string_gam1_2[n1+1:]\n", - " string_gam1_2 = string_gam1_2[:n2] + l1 + string_gam1_2[n2+1:]\n", - " \n", - " H.append((string_gam1_1, data_series.Gam1))\n", - " H.append((string_gam1_2, data_series.Gam1))\n", - " \n", - " #Gamma' Terms\n", - " if distance == 1 and data_series.Gam_prime1 != 0:\n", - " #unwrapping inner loop since there is no ordering guarantee\n", - " labels=['X', 'Y', 'Z']\n", - " labels.remove(label)\n", - " for label_offset in labels:\n", - " string_gam1_1 = n*'I'\n", - " string_gam1_2 = n*'I'\n", - " l1 = label\n", - " l2 = label_offset\n", - " \n", - " string_gam1_1 = string_gam1_1[:n1] + l1 + string_gam1_1[n1+1:]\n", - " string_gam1_1 = string_gam1_1[:n2] + l2 + string_gam1_1[n2+1:]\n", - " string_gam1_2 = string_gam1_2[:n1] + l2 + string_gam1_2[n1+1:]\n", - " string_gam1_2 = string_gam1_2[:n2] + l1 + string_gam1_2[n2+1:]\n", - " H.append((string_gam1_1, data_series.Gam_prime1))\n", - " H.append((string_gam1_2, data_series.Gam_prime1))\n", - " return H\n", - "\n", - "def generate_time_varying_terms(g, s, x = lambda s: 0, y = lambda s: 0, z = lambda s: 0):\n", - " assert callable(x)\n", - " assert callable(y)\n", - " assert callable(z)\n", - " \n", - " weight_x, weight_y, weight_z = x(s), y(s), z(s)\n", - " n = len(g)\n", - " H = []\n", - " if not (weight_x == 0):\n", - " for node in g.nodes:\n", - " string_x = n*'I'\n", - " string_x = string_x[:node] + 'X' + string_x[node+1:]\n", - " H.append((string_x, weight_x))\n", - " if not (weight_y == 0):\n", - " for node in g.nodes:\n", - " string_y = n*'I'\n", - " string_y = string_y[:node] + 'y' + string_y[node+1:]\n", - " H.append((string_y, weight_y))\n", - " if not (weight_z == 0):\n", - " for node in g.nodes:\n", - " string_z = n*'I'\n", - " string_z = string_z[:node] + 'z' + string_z[node+1:]\n", - " H.append((string_z, weight_z))\n", - " return H\n", - "\n", - "#using normalized time s = t_current / t_total to allow for more variation of total time\n", - "def generate_rucl_hamiltonian(lattice_size, data_series, s=0, field_x=lambda s: 0, field_y=lambda s: 0, field_z=lambda s: 0):\n", - " g = nx.generators.lattice.hexagonal_lattice_graph(lattice_size,lattice_size)\n", - " assign_hexagon_labels_rucl(g)\n", - " g = flatten_nx_graph(g)\n", - " H_constant = nx_rucl_terms(g, data_series)\n", - " H_time_varied = generate_time_varying_terms(g, s, x=field_x, y = field_y, z = field_z)\n", - " H = H_constant + H_time_varied\n", - " return H" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "58ea9762-5b90-477b-9d20-fff664f8cf87", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Estimating RuCl row 13 using Trotterization\n", - " Time to estimate Number of steps required: 58.982447494999995 seconds\n", - " Time to find term ordering: 0.16902502400000685 seconds\n", - " Time to generate trotter circuit from openfermion: 5.884000003675283e-06 seconds\n", - " Time to decompose trotter to Clifford + T: 621.37379112 seconds\n", - " Time to enumerate resource estimates: 41.273443928999995 seconds\n", - "Total time to estimate RuCl row 13: 754.742733289 seconds\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#Commenting out range, to avoid long runtimes. This still takes ~20-30 minutes as written\n", - "for i in [13]:\n", - "#for i in range(19):\n", - " #defining precision required for the trotterized circuit\n", - " energy_precision = 1e-3\n", - " figdir=\"Trotter/Figures/\"\n", - " if not os.path.exists(figdir):\n", - " os.makedirs(figdir)\n", - " timesteps=1000\n", - " H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i])\n", - " H_rucl_pyliqtr = pyH(H_rucl)\n", - " openfermion_hamiltonian_rucl = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_rucl_pyliqtr)\n", - " \n", - " print(\"Estimating RuCl row \" + str(i) + \" using Trotterization\")\n", - " t0 = time.perf_counter()\n", - " cpt_trotter_rucl = estimate_trotter(openfermion_hamiltonian_rucl, timesteps, energy_precision, \"Trotter/RuCl_circuits/\", hamiltonian_name=\"rucl_\" + str(i))\n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\"Total time to estimate RuCl row \" + str(i) + \": \" + str(elapsed) + \" seconds\\n\")\n", - " \n", - " plot_T_step_histogram(cpt_trotter_rucl)\n", - " plt.title(\"trotter RuCl, row \" + str(i))\n", - " plt.xlabel(\"T Width\")\n", - " plt.ylabel(\"count\")\n", - " plt.savefig(figdir + \"trotter_cpt_t_width_histogram_rucl_\" + str(i) + \".pdf\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "e2ccb7bf-252d-489f-b292-619549ba1e15", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Estimating RuCl row 13 using QSP\n", - " Time to generate high level QSP circuit: 257.6114212550001 seconds\n", - " Time to decompose high level cirq.ops.common_channels.ResetChannel circuit: 0.0004568480001125863 seconds\n", - " Time to transform decomposed cirq.ops.common_channels.ResetChannel circuit to Clifford+T: 0.0003812750001088716 seconds\n", - " Time to decompose high level cirq.ops.pauli_gates._PauliX circuit: 0.0002850809999017656 seconds\n", - " Time to transform decomposed cirq.ops.pauli_gates._PauliX circuit to Clifford+T: 0.00010283599999638682 seconds\n", - " Time to decompose high level cirq.ops.common_gates.Rx circuit: 0.00035275799996270507 seconds\n", - " Time to transform decomposed cirq.ops.common_gates.Rx circuit to Clifford+T: 0.054105950999883135 seconds\n", - " Time to decompose high level pyLIQTR.QSP.qsp_cirq_gates.SelectV circuit: 300.36175675699997 seconds\n", - " Time to transform decomposed pyLIQTR.QSP.qsp_cirq_gates.SelectV circuit to Clifford+T: 1927.61035602 seconds\n", - " Time to decompose high level pyLIQTR.QSP.qsp_cirq_gates.Reflect circuit: 0.8477977160000592 seconds\n", - " Time to transform decomposed pyLIQTR.QSP.qsp_cirq_gates.Reflect circuit to Clifford+T: 7.592521574999864 seconds\n", - "Time to estimate RuCl row 13: 2670.952123478 seconds\n", - "\n", - "\n" - ] - } - ], - "source": [ - "#Commenting out range, to avoid long runtimes. This still takes ~20-30 minutes as written\n", - "for i in [13]:\n", - "#for i in range(19):\n", - " #defining precision required for the trotterized circuit\n", - " energy_precision = 1e-3\n", - " figdir=\"QSP/Figures/\"\n", - " if not os.path.exists(figdir):\n", - " os.makedirs(figdir)\n", - " timesteps=1000\n", - " H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i])\n", - " H_rucl_pyliqtr = pyH(H_rucl)\n", - " \n", - " print(\"Estimating RuCl row \" + str(i) + \" using QSP\")\n", - " t0 = time.perf_counter()\n", - " #change to Clifford+T dictionary in future revision\n", - " qsp_high_level_rucl = estimate_qsp(H_rucl_pyliqtr, timesteps, energy_precision, \"QSP/RuCl_circuits/\", hamiltonian_name=\"rucl_\" + str(i))\n", - " t1 = time.perf_counter()\n", - " elapsed = t1 - t0\n", - " print(\"Time to estimate RuCl row \" + str(i) + \": \" + str(elapsed) + \" seconds\\n\")\n", - " print()\n", - " \n", - " #plot_T_step_histogram(cpt_trotter_rucl)\n", - " #plt.title(\"QSP RuCl, row \" + str(i))\n", - " #plt.xlabel(\"T Width\")\n", - " #plt.ylabel(\"count\")\n", - " #plt.savefig(figdir + \"qsp_cpt_t_width_histogram_rucl_\" + str(i) + \".pdf\")" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "c39ea21d-6ed9-47a8-bbcb-42665a577b73", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total time to run notebook (only using the fastest row): 3442.918268621\n" - ] - } - ], - "source": [ - "t_end = time.perf_counter()\n", - "print(\"Total time to run notebook (only using the fastest row): \" + str(t_end - t_init))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2f256c6e-4063-458f-839d-29cb8f4d03d6", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.8.8" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/notebooks/MagneticLattices.ipynb b/notebooks/MagneticLattices.ipynb index dcc8f5b..df31e76 100644 --- a/notebooks/MagneticLattices.ipynb +++ b/notebooks/MagneticLattices.ipynb @@ -45,9 +45,18 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zain/anaconda3/lib/python3.11/site-packages/attr/_make.py:918: RuntimeWarning: Running interpreter doesn't sufficiently support code object introspection. Some features like bare super() or accessing __class__ will not work with slotted classes.\n", + " set_closure_cell(cell, cls)\n" + ] + } + ], "source": [ "import os\n", "import random\n", @@ -69,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -86,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -98,12 +107,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -118,12 +127,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -138,12 +147,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddVzV5/v48RdhO51it5sdsyUUFQtRkBZQ0dk6u2bNrunM6Zw5FUS6QcDGAAlb7MQOLASkzvv3x77ym585FTgJ9/Px+P7x3Tnc94WfwznXueO6tCRJkhAEQRAEQRCEPNJWdQCCIAiCIAiCZhMJpSAIgiAIgpAvIqEUBEEQBEEQ8kUklIIgCIIgCEK+iIRSEARBEARByBeRUAqCIAiCIAj5IhJKQRAEQRAEIV9EQikIgiAIgiDki0goBUEQBEEQhHwRCaUgCIIgCIKQLyKhFARBEARBEPJFJJSCIAiCIAhCvoiEUhAEQRAEQcgXkVAKgiAIgiAI+SISSkEQBEEQBCFfREIpCIIgCIIg5ItIKAVBEARBEIR8EQmlIAiCIAiCkC8ioRQEQRAEQRDyRSSUgiAIgiAIQr6IhFIQBEEQBEHIF5FQCoIgCIIgCPkiEkpBEARBEAQhX0RCKQiCIAiCIOSLSCgFQRAEQRCEfBEJpSAIgiAIgpAvIqEUBEEQBEEQ8kUklIIgCIIgCEK+iIRSEARBEARByBeRUAqCIAiCIAj5IhJKQRAEQRAEIV9EQikIgiAIgiDki0goBUEQBEEQhHwRCaUgCIIgCIKQLyKhFARBEARBEPJFJJSCIAiCIAhCvoiEUhAEQRAEQcgXXVUHIAiCIBRMKelZ3E1KISNLRlFdberolaJUMfGxIwgFkfjLFgRBEOTmxtNk3GISOXLtGYkvU5H+8ZgWUKt8SUwaVmKAfi3qV/5GVWEKgiBnWpIkSV9+miAIgiD8t/svU5ntf5HjN1+go61Ftuy/P1o+PG5crwLLrJtTs3xJJUYqCIIiiIRSEARByBePuETmByWQJZM+m0j+Lx1tLXS1tVjYtymO7WopMEJBEBRNJJSCIAhCnm08coNV+6/ne5xpPRswzqS+HCISBEEVxC1vQRAEIU884hLlkkwCrNp/Hc+4RLmMJQiC8omEUhAEQci1+y9TmR+UINcx5wUlcP9lqlzHFARBOURCKQiCIOTabP+LZOXivOTXyJJJzPa/KNcxBUFQDpFQCoIgCLly42kyx2++yNUFnK+RLZM4fvMFN58ly3VcQRAUTySUgiAIQq64xSSio62lkLF1tLXYc0qcpRQETSMSSkEQBCFXjlx7JvfVyQ+yZRJHrj9TyNiCICiOSCgFQRCEr/YuPYtEBV+cSUxKJSU9S6FzCIIgXyKhFARBEL7avaQUFF28WALuJqUoeBZBEORJJJSCIAjCV8vIkhWoeQRBkA+RUAqCIAhfJTMzk5vXryplrqK64uNJEDSJrqoDEARBENTTo0ePOHXqFNHR0Zw6dYr4+HjSs6HmFG+0tBRzyxtAC6ijV0ph4wuCIH8ioRQEQRBIT0/n7NmzHyWQiYl/l++pWbMmhoaGLFu2DENDQ34+lkriqzSFxVJLrySliomPJ0HQJOIvVhAEoZCRJIkHDx7kJI7R0dGcOXOGjIwMihUrRtu2benXrx8GBgYYGBhQvXr1j36+67MEXGPuKaR0kI62FiYNKsl9XEEQFEtLkiRFX9gTBEEQVCgtLY0zZ858lEA+evQIgLp162JgYIChoSEGBga0aNGCokWLfna8G0+T6bHumMLiPTi5E/UqfaOw8QVBkD+xQikIglCASJLE3bt3P9q6PnfuHJmZmZQsWZJ27drh7OyMoaEh+vr6VKlSJddz1K/8Dcb1KhB1O0muq5Rakgyj7yuIZFIQNJBYoRQEQdBgKSkpxMfHf5RAPn36FIB69erlrDwaGhrSvHlzdHXls45w/2Uq3ddGki638j4SUmYG5U9tws91G3Xr1pXTuIIgKINIKAVBEDSEJEncunXro63rCxcukJ2dTenSpWnfvn1OAmlgYECFChUUGo9HXCIz/S7Kbbyf2pZl8/RBvHr1it27d9O3b1+5jS0IgmKJhFIQBEFNJScnExsb+9HqY1JSEgCNGjX66Oxj06ZN0dHRUWp8O3fuZNK2cMp1HpTvsab3bMhYk3q8fv2aIUOGEBAQwLRp01i2bBlFihSRQ7SCICiSSCgFQdAoKelZ3E1KISNLRlFdberolSoQJWZkMhnXr1//aPUxISEBmUxGmTJl0NfXx9DQEENDQ9q3b0/58uVVGm9ISAhWVlYMGzaMLsPmsCA4gSyZlKszlTraWuhqa7Gob1Mc2tXK+e+SJLF27VpmzJiBvr4+Hh4e1KhRQxG/hiAIciISSkEQ1N6Np8m4xSRy5NozEl+mftRLWguoVb4kJg0rMUC/FvUra8aFjtevXxMbG5uTQMbExPDq1Su0tLRo0qTJR6uPjRs3RltbfTrHREdH061bN0xNTfHx8UFHR4f7L1OZ7X+R4zdfoKOt9dnE8sPjxvUqsMy6OTXLl/zk86KionBwcOD9+/e4ubnRs2dPRf1KgiDkk0goBUFQW4pIUlRBJpNx+fLlj7aur1y5giRJlCtXLufM44fVx7Jly6o65P905coVOnbsSNOmTYmIiKBEiRIfPZ6T/F9/RmLSJ5J/vZKYNKjEQINaX3Wb+8WLFzg7OxMREcHcuXOZN2+e0rf2BUH4MpFQCoKgljziEpkflPdt1IV9m+L4j21UZXr58iWnTp3KSSBjY2N5+/Yt2traNGvW7KOb1/Xr11er1cfPefjwIUZGRpQpU4Zjx45Rrly5zz5fXscTZDIZy5cvZ968eZiYmODm5kblypXz+msIgqAAIqEUBEHtbDxyg1X7r+d7nGk9GzDOpL4cIvpvWVlZJCQkfHT28fr1v2OvUKHCR1vX7dq145tvNGNL/n+9fv0aY2Nj3rx5Q1RUlErONB45cgQnJye0tbXx8PCgU6dOSo9BEIRPEwmlIAhqRd6laFbYNP/owkd+PX/+/KOt69jYWFJSUtDR0aFFixYfle35/vvv0dLSktvcqvL+/XtMTU25dOkSJ06coHHjxiqL5fHjxzg5OXHixAmWLl3K9OnTNWaFVxAKMpFQCoKgNuRfLBuK6WpzcHLnPJ2pzMzM5MKFCx8lkLdu3QKgcuXKObeuDQwMaNu2LSVLqs+5TXnJzs6mX79+hIWFcejQIQwNDVUdEllZWcyfP59ly5Zhbm7O7t27VX7rXRAKO5FQCoKgNpx3xMi9nZ+OthZG3+nhOkz/i8998uTJR1vX8fHxpKWlUaRIEVq1avXR9nXt2rULxOrj50iSxE8//cS2bdvw9/fHwsJC1SF9JCwsjIEDB1K6dGm8vb1p3769qkMShEJLJJSCIKiFG0+T6bHumMLGPzi500e3ijMyMjh37txHCeS9e/cAqF69+kcXZ1q1avWv28yFwaJFi5g/fz7bt29n2LBhqg7nkxITE3FwcOD06dOsWrWK8ePHF/hEXxDUkUgoBUFQCwuCEnCNuSfX1ckPdLS1sG6qh0HR+zkJ5OnTp0lPT6do0aK0adPmowRSFNGGrVu3MmrUKJYsWcKcOXNUHc5nZWRkMGPGDNatW4ednR3bt29X69JLglAQiYRSEAS10Pm3I9x7maqw8TNfPuLR1pHUrl37o63rli1bUqxYMYXNq4kCAgKwtbVlzJgxbNiwQWNW/Pz8/BgyZAiVKlXC29ubli1bqjokQSg0REIpCILKvUvPovmCCBT7ZiRxcFQL6tWpqdBZNN2JEyfo0aMH5ubmeHh4aFwR8Vu3bmFvb8/ly5fZuHEjw4YN05iEWBA0mai1IAiCyt1LSlFwMgmgRXrRMgqfRZMlJCRgYWGBgYEBrq6uGpdMAnz//fdERUXx448/MmLECAYPHkxKSoqqwxKEAk8klIIgqFyGHMsEqcM8muj+/fv06tWL2rVrExAQQPHixVUdUp4VL16czZs34+rqiq+vL+3bt+fKlSuqDksQCjSRUAqCoHJFdZXzVqSseTTNy5cvMTU1RVdXl7CwsAJzoWXgwIHExcUB0K5dO/bu3aviiASh4BLvroIgqFwdvVIo+pSb1v/NI3wsNTUVCwsLnj9/TkREBFWrVlV1SHLVpEkTYmNjsba2ZsCAAYwePZr379+rOixBKHBEQikIgsrIZDKioqJYNG8O0rsXCp2rll5JShXTVegcmiYrKwtHR0fOnTtHSEgIDRo0UHVIClGqVClcXFzYunUru3btwsjIKKfjkSAI8iESSkEQlOr9+/eEhIQwYsQIqlWrRocOHdi5cyc1tF+jraCrOTraWpg0qKSQsTWVJEmMHj2asLAwfHx80Nf/cichTaalpcWIESM4deoUb9++pU2bNvj7+6s6LEEoMERCKQiCwiUlJeHi4oKtrS0VKlTAwsKCyMhInJ2dOX78OI8fP2bn7KHIFLTxnS2TGGhQSyFja6p58+axY8cOduzYgZmZmarDUZqWLVty+vRpunfvjo2NDVOmTCEjI0PVYQmCxhN1KAVBUIg7d+4QGBhIYGAgx48fJzs7G319fSwtLbGysqJRo0b/qg+o6l7ehcWmTZsYO3YsK1as4Oeff1Z1OCohSRIbNmxg2rRptG3bFk9PT2rWFDVKBSGvREIpCIJcSJLE2bNnCQgIIDAwkAsXLlC0aFG6deuGpaUlFhYWVKtW7bNj3H+ZSve1kaTLq7yPJFFUV5tDU7pQs3xJ+Yyp4Xx8fOjXrx8TJ05kzZo1hb7od0xMDP369SMlJQVXV9dCtVorCPIkEkpBEPIsMzOTyMhIAgICCAoK4v79+3z77bf06dMHS0tLevXqxTfffJOrMT3iEpnpd1FuMSYf/JP1Ex0ZOHCg3MbUVJGRkfTs2RNbW1v27NmDtrY49QR/H8kYNGgQ+/btY86cOSxYsABdXXGBSxByQySUgiDkytu3bwkLCyMwMJB9+/bx5s0batWqlbOVbWxsTJEiRfI8flJSEu0G/4KsuXm+Y53YpS7n9q7AxcWF4cOH8/vvv1OiRIl8j6uJLly4gLGxMe3btyc0NJSiRYuqOiS1IpPJWLlyJXPmzKFTp064u7tTpUoVVYclCBpDJJSCIHzRw4cPCQoKIjAwkMOHD5OZmUnLli1zksgWLVrIZes0IyODnj17kpCQwLzd4WyMfkaWTMrVmUodbS10tbVY1LcpDu1qIUkSO3fuZOzYsTRo0ABvb+8CWx7nv9y9excjIyOqVq3K0aNHc71qXJhERkbi5OSETCbDw8ODLl26qDokQdAIIqEUBOFfJEni8uXLOech4+Li0NHRoXPnzlhaWmJpaUnt2rXlPueoUaPYtWsXhw4dwtjYmPsvU5ntf5HjN1+go6312cTyw+PG9SqwzLr5v85MXrhwAXt7ex49esT27dtxcHCQa/zq6sWLF3To0IGsrCyioqKoXLmyqkNSe0+fPqV///4cPXqUxYsXM3PmTHE8QBC+QCSUgiAAkJ2dTVRUVE4SeevWLUqXLk2vXr2wtLSkd+/elC9fXmHzr1u3jsmTJ7Nz505+/PHHjx678TQZt5hEjlx/RmJS6kfVKrX4u2i5SYNKDDSoRb1K/736lpyczMiRI/Hw8OCnn35izZo1FCtWTCG/jzpISUmha9eu3L17l5MnT1KvXj1Vh6QxsrOzWbhwIUuWLMHU1BRXV1cqVKig6rAEQW2JhFIQCrHU1FT2799PYGAgISEhvHjxgipVqtC3b18sLS3p2rUrxYsXV3gc+/btw8LCgmnTprFixYrPPjclPYu7SSlkZMkoqqtNHb1SueqAI0kSW7ZsYeLEiTRr1gxvb2++++67/P4KaiczMxNLS0uOHz/O0aNHadOmjapD0kgREREMHDiQ4sWL4+XlhaGhoapDEgS1JBJKQShknj9/TnBwMIGBgRw4cIC0tDQaN26ccx6yXbt2St3eu3TpEkZGRpiYmODn54eOjo5S5j1z5gz29vYkJSWxc+dOrK2tlTKvMkiSxJAhQ9i7dy+hoaH06NFD1SFptAcPHuDg4EBsbCwrV65k0qRJhb7ckiD8L5FQCkIhcPPmzZyt7KioKCRJwsjIKOc8pKouqTx//pz27dtTpkwZTpw4ofTLIm/evGHYsGH4+voyadIkVqxYUSBuP8+cOZMVK1awd+9enJycVB1OgZCZmcmsWbNYvXo11tbW/PXXX3z77beqDksQ1IZIKAWhAJLJZMTHx+ckkZcvX6Z48eL06NEDS0tLzM3NVX45Iz09ne7du3P9+nViY2Plfsnna/2zY0rr1q3x9PRUWSzysH79eiZNmsSaNWuYPHmyqsMpcAIDAxk8eDB6enp4e3vTunVrVYckCGpBJJSCUECkp6dz5MiRnCLjjx8/Rk9PD3Nzc6ysrOjRowelSpVSdZjA30nc0KFD2bt3L0ePHlWLc2mxsbH069ePt2/f4uLigrl5/utgKpunpydOTk5MmzaNlStXqjqcAuv27dv069ePS5cusX79ekaOHCm2wAVBEgRBY7169Upyc3OT7O3tpW+++UYCpO+++06aPHmyFBkZKWVmZqo6xE9auXKlBEiurq6qDuUjSUlJkoWFhQRIP//8s5SRkaHqkL7awYMHpSJFikjOzs5Sdna2qsMp8NLS0qSffvpJAqT+/ftLycnJqg5JEFRKrFAKgoZJTEwkKCiIgIAAIiMjycrKom3btlhZWWFpaUnTpk3VerUkKCgIKysrZs2axdKlS1Udzr9IksSaNWuYMWMGhoaGeHh4UL16dVWH9Vlnz56lc+fOGBkZERwcnK9ORULuuLu7M2LECGrWrImPjw9NmzZVdUiCoBIioRSE/5PfcjSKIkkSFy5cyDkPefbsWYoUKYKJiQmWlpb07duXGjVqqDrMr3LhwgWMjIwwNTXF29tbrYtFnzx5EgcHB9LT09mzZw+mpqaqDumTbt++jZGREbVq1eLw4cOULl1a1SEVOlevXsXe3p7bt2+zefNmnJ2dVR2SICidSCiFQi2nYPa1ZyS+/ETB7PIlMWlYiQH6tahfWXk3kLOysjh+/HhOEnnv3j3KlClD7969sbKyolevXpQtW1Zp8cjD06dPad++PXp6ehw/flxtznN+zosXL3B2diYiIoI5c+awYMECpZU1+hrPnj2jQ4cOaGlpcfLkSSpWrKjqkAqt1NRUxo4dy65duwp933ihcBIJpVAoybOln7y8e/eOiIgIAgICCA0N5dWrV1SvXj2nPmTnzp01tqTN+/fvMTEx4e7du8TFxWnMiir8fWN+xYoV/PLLL3Tq1Im9e/dStWpVVYdFcnIyJiYmPHz4kKioKOrWravqkARg586d/PTTTzRs2BBvb2/q16+v6pAEQSlEQikUOh5xicwPSiBLJn02kfxfOtpa6GprsbBvUxzb1ZJLLE+ePCE4OJiAgAAOHTpEeno6zZs3z0kiW7durdbnIb+GJEk4Ozvj6+tLZGQk7du3V3VIeRIZGYmjoyOSJLF37166du2qslgyMjIwNzfn1KlTHDt2jJYtW6osFuHfPvSNf/z4MX/99Rd2dnaqDkkQFE4klEKhsvHIDVbtv57vcab1bMA4k7ytPFy9ejVnKzsmJgYtLS2MjY1ziowXtDaAy5YtY86cOXh4eODg4KDqcPLl6dOnDBgwgCNHjrBgwQJmz56t9C1wmUyGs7MzPj4+hIeHY2JiotT5ha/z9u1bRowYgZeXFxMmTOC3337T2B0GQfgaIqEUCg2PuERm+l2U23grbJrj8BUrldnZ2cTExOQkkdevX6dkyZKYmppiZWVFnz590NPTk1tc6sTPzw9bW1vmz5/PggULVB2OXGRnZ7NkyRIWLlxI9+7d2bNnD5UqVVLa/NOmTWPNmjV4enpib2+vtHmF3JMkiU2bNjF58mRatWqFl5eXRhfNF4TPEQmlUCjcf5lK97WRpGfJ5DZmMV1tDk7u/MkzlWlpaRw6dIjAwECCgoJ49uwZlSpVwsLCAisrK7p161bgD+yfOXMGY2NjzM3NcXd3V+sb3Xlx8OBB+vfvT5EiRfDw8MDY2Fjhc65evZpp06axYcMGxo0bp/D5BPmIi4ujX79+vHnzBldXV/r06aPqkARB7kRCKRQKzjtiiLqdlKszk1+io62F0Xd6uA7TByApKYnQ0FACAgKIiIggNTWVBg0a5NSH1NfXV6sbwor0+PFj2rVrR7Vq1YiMjCywyfOjR49wcnLi5MmTLF26lOnTpysscd6zZw/Ozs7Mnj1bLet3Cp/36tUrBg8eTHBwMDNnzmTx4sXo6qq+LJkgyItIKIUC78bTZHqsO6aw8Qfp3eVYiDcnTpwgOzsbAwODnCSyUaNGCptXXaWlpdG5c2cePXpEbGws1apVU3VICpWVlcW8efNYvnw5vXv3xsXFRe5HGCIiIjA3N2fQoEFs375d4y9qFVaSJLFq1SpmzZpFhw4dcHd3L/B/H0LhIRJKocBbEJSAa8w9ua5OfiDJskk9H057nXtYWVlhYWFBlSpV5D6PppAkCUdHR4KDgzlx4gStW7dWdUhKExYWhrOzMyVLlsTLywsDAwO5jBsXF4eJiQldunQhICBArGoVACdOnMDBwYHMzEz27t1L9+7dVR2SIORbwTrUJAifcOTaM4UkkwBa2jo07mpLaGgoI0aMKNTJJMCiRYvw8vLC1dW1UCWTAGZmZpw9e5YaNWpgbGzM2rVrye/39Rs3btC7d2+aN2+Ol5eXSCYLiI4dO3L27FlatGhBz549WbRoEdnZ2aoOSxDyRSSUQoH2Lj2LxJepCp3j/qv3pKRnKXQOTeDp6cmCBQtYsmQJtra2qg5HJWrWrElkZCQTJ05kypQp2NjY8OrVqzyN9eTJE0xNTalQoQIhISGULKmYgvqCalSqVInw8PCcCgi9e/fm+fPnqg5LEPJMJJRCgXYvKQVFn+mQgLtJKQqeRb3FxcXx448/0r9/f2bPnq3qcFSqSJEirFq1isDAQI4ePUrr1q2Jj4/P1Rhv377FzMyM9PR0IiIiCmxZqcJOR0eH+fPns3//fs6ePUurVq04ceKEqsMShDwRCaVQoGXIsUyQOsyjjh48eIClpSUtW7Zkx44d4sLI/+nbty9nz56lYsWKdOjQgT/++OOrtsDT09Oxtrbmzp07hIeHU6uWfLoyCeqre/funD17lrp169KlSxdWrVqV7+MSgqBsIqEUCrSiusp5iStrHnWTkpKCpaUlurq6BAQEULx4cVWHpFbq1KnDiRMnGD16NOPGjcPBwYG3b9/+5/NlMhmDBg3i5MmTBAUF0bx5cyVGK6hS9erVOXLkCNOmTWP69OlYWVnl+biEIKhC4fwUFAqNOnqlUPR6mdb/zVPYfEh+rl27RnBwMJUrV1Z1SGqpaNGirF+/Hm9vbyIiImjTpg3nzp371/MkSWLy5Mn4+Pjg7u5Op06dlB+soFK6urr8+uuvBAUFcfz48TwdlxAEVREJpVCglSqmS61PdLKRp1p6JSlVrPDdvp03bx7+/v7s3buXFi1aqDoctWdnZ8fp06cpXbo0BgYGbN269aNtzRUrVvD777/zxx9/YG1trcJIBVWzsLDgzJkzOcclNm3alKct8JT0LBIeveFs4isSHr0RlwcFhSp8n4JCoWPSsJLC6lDqaGth0kB5fZzVhZubG0uXLmXFihX07dtX1eFojHr16hEdHc3kyZMZNWoUx44dY/Pmzfj4+DBr1izmzZvH6NGjVR2moAbq1KnD8ePHmT59OmPHjuX48eNs3bqVb7755rM/d+NpMm4xiRy59ozEl6kfXUrUAmqVL4lJw0oM0K9F/cqfH0sQckMUNhcKPEV3yjk4uRP1KhWeN+bo6GhMTExwdHRk586d4hJOHrm7uzNixAjKlSvHo0ePGD58OJs3bxb/nsK/eHt7M2zYMKpWrYqPj88nz9bef5nKbP+LHL/5Ah1trc9+gf7wuHG9Ciyzbk5NBe/iCIWD2PIWCrz6lb/BuF4FdLTl+0Gto62Fcb0KhSqZvHfv745Abdu2ZcuWLSL5yQcnJye2b9/Ow4cP0dLSon379uLfU/gke3t74uPjKV68OPr6+uzateujxz3iEum+NpKo20kAX9yN+fB41O0kuq+NxCMuUSFxC4WLWKEUCoX7L1PpvjaSdHmV95EkiupqcWiKSaH5dv/u3Ts6dOjA27dviY2NpWLFiqoOSaNdvXqVDh060LBhQ+rXr4+LiwtDhgxh48aNooi58ElpaWlMmDCB7du357xW/op5yKr91/M99rSeDRhnUl8OUQqFlVihFAqFmuVLsrBvU/kNqKXF8/BNHAnxkd+YakwmkzFgwADu3LlDcHCwSCbz6eHDh5iamlK1alVCQ0PZvXs3u3btwsPDA319fa5evarqEAU1VKJECbZt25bzWmltP04uySTAqv3X8RQrlUI+iIRSKDQc29WibdHH//f/5W9hfpLJd1j/UJnBgwfz008/kZ6env8A1disWbMICQnBw8ODZs2aqTocjfb69WvMzMyQJInw8HDKlSsHwODBg4mNjSUrK4u2bduyd+9eFUcqqKvBgwcTdPgk75v2lWsB9HlBCdxXcKtaoeASCaVQaOzfvx+/xSMx1LlNMV2dXJ+p1NHWopiuNitsmjOpZ2N27NjB1q1b2bFjB506deL+/fsKily1du3axcqVK1m1ahW9e/dWdTga7f3791haWvLgwQMiIiKoUaPGR483a9aMuLg4rK2tGTBgAKNGjeL9+/cqilZQZ7sTMtDRLSLXc7dZMonZ/hflNp5QuIgzlEKhcO/ePdq0aUO7du0ICQnh0Zt0ud2IjIuLw87OjtTUVNzd3enevbuifx2lOXHiBF27dmXw4MFs3bpVXBrJh+zsbPr160dYWBgHDx7EyMjoP58rSRI7duxg3LhxNG7cGG9vb+rVq6fEaAV1JipXCOpIJJRCgff+/Xs6duxIUlISp0+fpnz58jmP5dRsu/6MxKRP1GzTK4lJg0oMNKj12TfYFy9e0L9/fw4dOsSSJUuYMWMG2tqavQFw584d2rdvT9OmTdm/fz9FixZVdUgaS5Ikxo4dy5YtWwgICMDCwuKrfu78+fPY29vz5MkT/vrrL+zs7BQcqaAJFgQlKLS2rrN+bRbI88y5UCiIhFIo8IYPH46bmxtRUVG0atXqP5+Xkp7F3aQUMrJkFNXVpo5eqVx1wMnOzmbBggUsWbKEvn37snv3br799ls5/AbK9/btW4yMjHj//j0xMTHo6empOiSNtnjxYubNm8e2bdsYPnx4rn727du3jBgxAi8vL8aNG8eqVasoVqyYgiIVNEHn345wT4FnHWvrlSRymonCxhcKJpFQCgXatm3bGDlyJLt27WLw4MFKmTM4OBhnZ2cqVqyIn5/fJ4sQq7Ps7Gz69u3LyZMniY6OpnHjxqoOSe3k5svHh9fg4sWL+eWXX/I0nyRJ/Pnnn0yePJkffvgBLy8v6tatm59fQdBQ79KzaL4gIp/XCj9PC7i0wLRQtpQV8k4klEKBFRcXR8eOHRk6dCh//vmnUue+desWtra2XL9+nW3btjFgwAClzp8fU6dOZf369ezbt4+ePXuqOhy1kZeWdoGBgdjY2DBmzBg2bNiQ7zOop0+fxt7enlevXrFr1y4sLS3zNZ6geRIevaHPhhMKnyd0fEeaViur8HmEgkMklEKB9Pz5c9q0aUO1atWIjIxUyRZhamoqY8aMwcXFhbFjx7JmzRq1P4e4fft2RowYwYYNGxg3bpyqw1ELeW1pZ1Mrnf59TTE3N8fDwwMdHR25xPP69WuGDBlCQEAAU6ZM4ddff6VIkSJyGVtQf2cTX2H9Z5TC5/EfY0SrWuUUPo9QcIiEUihwsrKy6NWrFxcuXODMmTP/Ks2iTJIksWXLFiZMmECbNm3w9vZWaTyfc/ToUXr06MGIESP4448/xI1u/m5pNz8ogSyZlKsLENpakJ2ZQYV7hznp8hvFixeXa1ySJLF+/XqmT59Ou3bt8PT0pGbNmnKdQ1BPYoVSUFeafQ1VED5h7ty5HDlyBE9PT5Unb1paWowePZrjx4/z4MEDWrduzZEjR1Qa06fcvHkTW1tbOnfuzPr160UyCWw8coOZfhdJz5Ll+jatTAItnSIkfd+L7dHyr0+qpaXFpEmTOH78OA8fPqRly5bs27dP7vMI6qeOXikU/dep9X/zCEJuiIRSKFD8/f359ddfWbFiBSYm6nNLUV9fnzNnztC8eXO6d+/OypUr5drhIj9ev36NhYUFFSpUwNvbW2yf8vfKZL5b2v1fUq7IlnYGBgacOXMGQ0ND+vTpw6xZs8jKylLIXIJqyWQy4uPj+W35ErRSXyp0rlp6JcWFHCHXREIpFBhXr15l8ODB2NnZMXXqVFWH8y8VK1YkIiKCn3/+mRkzZmBnZ8fbt29VGlNWVhYODg48efKE4ODgnDaAhdn9l6nMD0qQ65iKbGmnp6dHUFAQK1as4LfffqNbt248evRIIXMJypWcnIyfnx9Dhw6lWrVqtGvXjnXr1lEp8xnaCrrnraOthUmDSgoZWyjYxBlKoUB49+4d7du3ByAmJoZvvlHvLg+BgYEMGjSIKlWq4OfnR9OmqikiPGHCBDZt2kRERATdunVTSQzqxnlHDFG3k+RaNFpHWwuj7/RwHaYvtzE/5cSJEzg4OJCZmYmbmxs9evRQ6HyC/N24cYPQ0FBCQkI4duwYmZmZNGnShD59+tCnTx+MjIy4+/K96JQjqB2xQiloPEmSGDp0KA8ePMDPz0/tk0kAS0tL4uPjKVq0KO3bt8fd3V3pMfz5559s2LCBP/74QyST/+fG02SO33wh9w4k2TKJ4zdfcPNZslzH/V8dO3bk3LlztGrVClNTU+bPn092drZC5xTyJyMjg0OHDjF58mQaNGhAgwYNmDlzJkWKFGHNmjXcvn2bhIQEVq5cSefOnSlSpAj1K3+Dcb0K6GjL9zSljrYWxvUqiGRSyBORUAoab82aNXh7e7Nr1y4aNWqk6nC+Wv369Tl16hTW1tb079+fiRMnkpGRoZS5Dx48yPjx45kwYQKjRo1SypyawC0mUe4f0h/oaGux55RizlL+U8WKFQkLC2PRokUsWbIEU1NTnj59qvB5ha/35MkTdu7cia2tLRUqVKB79+54e3tjYmJCYGAgSUlJhIWFMW7cuP8sYL/Mujm6cn6t6mprscxasxoxCOpDbHkLGu3o0aN0796dqVOnsmLFClWHkyeSJLFp0yYmTZqEvr4+Xl5eVKtWTWHzXbt2DQMDA/T19QkJCUFXVxy+/6CgtbQ7cuQITk5OaGlp4e7uTpcuXZQ2t/D/yWQyzpw5k7OVHR8fj5aWFgYGBjlb2S1atMh1dQWPuERm+l2UW5xW1VJYN76f3MYTCheRUAoa68GDB7Rp04ZmzZoRERGh8YlRdHQ0dnZ2ZGdn4+npSefOneU+x8uXLzEwMEBXV5fo6GjKlhV15j4oqC3tnjx5Qv/+/YmMjGTRokXMmjULbW2xOaVoycnJHDhwgJCQEMLCwnjy5Ally5alV69e9OnTh169elGxYsV8z7PxyA1W7b+OJEn5Kvf1/bsEDm+cwYoVK5g+fbooHSbkmnhXETRSeno69vb2FC1aFHd3d41PJgEMDQ05c+YMjRs3plu3bqxevVqupYUyMzOxt7cnKSmJ4OBgkUz+j3tJKQpNJgEk4G5SioJn+ViVKlU4cOAAc+bMYe7cufTu3ZsXL14oNYbC4saNG6xbt47u3bujp6eHra0tp06dwtnZmaNHj/L8+XM8PDxwdnaWSzIJUO5RLEn7fqeItpTr4xo62loU09VmhU1zDv4+nV9++YUZM2YwadIkcfZWyDXN/xQWCqUpU6Zw5swZjh8/TqVKBafEReXKlXM+/KdNm8apU6f466+/8n3RSJIkxo8fz7Fjxzh48CDff/+9nCIuODKyZAVqnn/S0dFh0aJFdOzYkQEDBtCyZUs8PT3p0KGD0mMpSDIyMjh+/DghISGEhoZy48YNihUrhomJCWvWrKFPnz7/eQZSHi5dusTIkSOxtbVlydSuzAm4lKsWoUbf6bHMujk1y5cEYPHixVSvXp2xY8fy6NEjXF1d5d7lSSi4xJa3oHFcXFwYPHgwW7ZsYeTIkaoOR2H8/Pz48ccfqV69On5+fjRu3DjPY23YsIEJEyawfft2hg0bJscoC47C0tLu4cOHODo6Eh0dzfLly5k6darYAs+FJ0+eEBYWRkhICAcOHCA5OZnq1avnnIXs1q0bpUopvsvM27dvadeuHcWKFePUqVOULPl3UnjjaTJuMYkcuf6MxKTUj1bdtfi7aLlJg0oMNKj1n7e5AwICcHJyQl9fn4CAAL799luF/z6C5hMJpaBRzp07h6GhIU5OTuzYsaPAn/O5du0aNjY23Lt3j7/++ot+/XJ/YD48PJw+ffowefJkVq1apYAoNdvDhw8JCwsjOGw/5+oPUuhrShVnKD8lKyuLX375hRUrVmBhYcGuXbsoX768SmNSV4q6UJMfkiRhZ2fHwYMHiY+Pp379+p98Xkp6FneTUsjIklFUV5s6eqW++rV38uRJLCwsqF69OuHh4VSvXl2ev4JQAImEUtAYL1++pG3btpQrV44TJ05QokQJVYekFO/evWPEiBF4eHgwefJkVqxY8dXtES9fvoyhoSHGxsYEBgaio6Oj4GjVX2ZmJtHR0ezbt4+wsDAuXLiAtrY2BgYGvO08lWSpmMLmVvYt7y8JDQ3F2dmZMmXK4Onpib6+YguvawplXajJq9WrVzNt2jT8/f2xsrJS2DxXrlyhV69eSJJEWFiYyhowCJpBJJSCRpDJZJibmxMTE8Pp06epU6eOqkNSKkmS2LBhA1OnTsXQ0BBPT0+qVq362Z958eIF+vr6lCxZkpMnT1KmTBklRat+Hj9+TFhYGGFhYezfv5+3b99SsWJFzMzMMDMzo2fPnpQvX54FQQm4xtyTe2Fz+PvcmrN+bRb0Va8P5cTERBwcHDh9+jS//fYbEyZMKPAr/5/yqQ41jRs3xtzcPKdDjTr0uT927Bhdu3ZVWqm0hw8f0rt3bxITEwkODqZjx44Kn1PQTCKhFDTCggULWLRoEeHh4fTs2VPV4ajMyZMnsbe3R5IkvL29//PNPSMjgx49enDlyhViY2MLXQKelZVFTExMzirk2bNn0dLSQl9fHzMzM3r37k3r1q3/dXbwxtPkQtnSLiMjg5kzZ7J27VpsbGzYsWNHgT839+FCzYck8p8Xaj5sZSvyQk1ePH78mNatW9OoUSMOHDigtOoWb968wcrKiujoaPbu3YuNjY1S5hU0i0goBbUXGhqKubk5S5YsYc6cOaoOR+WePHmCg4MDUVFR/Pbbb0ycOPGjFSVJkhg+fDh79uzh0KFDhWZF4enTp4SHhxMWFkZERASvX79GT0+PXr16YWZmhqmpKRUqVPjiOJrcyzu/AgIC+PHHH9HT08Pb25vWrVvn6ufzc2ZPGT51oaZatWo5q5DKulCTF5mZmXTt2pVbt25x9uxZKleurNT509PTGTRoEN7e3mzcuJGffvpJqfML6k8klIJau3XrFm3btqVTp074+/uL26j/JzMzk1mzZrF69WocHBzYvn07pUuXBv5uRTl16lR27drF4MGDVRyp4mRnZxMXF8e+ffvYt28fp0+fBqBdu3Y5q5Bt27bN9bnR+y9T6b42knQ5lfeRJAktWRY+Q1rQtrF6rXh9yu3bt+nXrx8XL15k3bp1jB49+rNb4Dm3iq89I/HlJ24Vly+JScNKDNCvRf3Kyl2d/a8LNfr6+jlJpLIv1OTVtGnTWL9+PUePHlVZuSeZTMbUqVNZt24ds2fPZsmSJRrxbycoh0goBbWVmpqKoaEhqampxMXFFfgtuLzw9vZm6NCh1KpVC19fX27evEnfvn35+eef+fXXX1Udntw9f/6ciIiInFXIpKQkypUrh6mpKb1798bU1FQudUldTt5iXshVOUT8t+xoF7KuHcPLywtjY2O5jaso6enpTJ06lT/++AMHBwe2bdv2r1qo91+mMtv/Yq7qHhrXq/BR3UNF+HChJjQ0lH379qndhZq88PHxwd7enrVr1zJp0iRVh5NzKejHH39k69atanG2VFA9kVAKakmSJAYNGoSfnx8xMTE0a9ZM1SGprStXrmBjY0NiYiIymYxevXrh6+tbIFZzZTIZ8fHxhIWFsW/fPuLi4pAkidatW9O7d2/MzMxo3769XM+SSZJE//79OfBIh9JGTvkeb3rPhtg1+QYHBwdOnjzJmjVrGDdunEas7Hh5eTF8+HCqVq2Kt7c3P/zwA/B3D+n5QQlkyaRcHQ3Q0dZCV1uLhX2b4tiultzi1JQLNXlx7dq1nFV3Dw8PtXnduLm5MWTIELp164a3t3fODolQeImEUlBLGzduZPz48ezduxcnp/x/qBd0t2/fpnnz5qSmpjJhwgRWr16tse0ok5KS2L9/P2FhYYSHh/P8+XPKli1Lz5496d27N7169aJKlSoKm3/BggUsXLgQb29vsmq3z1fitKhvUxz+L3HKzMxkxowZrF27FmdnZzZv3pxTjFqd3bhxA3t7e65du8bGjRtJrduJ1Qeu53vcaT0bMM7k0/UTv+S/LtR06dIlJ4lUtws1efHu3Tv09fWRyWTExsbmu2OWvB08eBAbGxsaNmxIaGhogepaJuSeSCgFtRMVFUXnzp0ZO3Ys69atU3U4ai89PZ2uXbty8+ZNRo4cyfLlyzE2NsbDw0PpB/fzQiaTcfbs2ZxVyJiYGGQyGS1atMhZhTQ0NFRKgrx3714GDBjA0qVLmT17NiD/rV13d3eGDRtGw4YN8fPz04jEJy0tjYkTJ+Iecw+93hPkNu4Km+Y5CfeXPH36lH379hEaGsr+/fs16kJNXkiSxIABAwgKCiIuLi5fnbIU6dy5c5iZmVGqVCkiIiJEW9dCTCSUglp58uQJrVu3pl69ehw6dEhjt6mURZIkfvzxRzw9PTl69CgGBgYcO3aMfv36oaOjg7e3N0ZGRqoO819evXrFgQMH2LdvH+Hh4Tx9+pRvvvmGnj17YmZmRq9evZTemSMqKgoTExOcnJzYuXPnv7YW5dHS7oMLFy5gbW3Nq1evcHd3x9TUVP6/kJzdf5mKyarDZMqQ27ZrMV1tDk7u/MnEuyBdqMmLD7s0Hh4eODg4qDqcz7pz5w69evXi1atX7Nu3j7Zt26o6JEEFREIpqI3MzEy6devGzZs3OXPmjEK3NQuKFStWMHPmTNzc3Ojfv3/Of3/06BH9+vUjJiZGLc7sSZLE+fPnc1Yho6Ojyc7Opnnz5jk3slV5zu3OnTvo6+vn1PcrVuzz3XLkUR7n1atXDBgwgPDwcJYsWcKsWbPUOjlSRjml/7pQY2pqirm5uUZeqMmL6OhoOnfuzE8//aQxuzQvXrzA3NycS5cu4ePjQ69evVQdkqBkIqEU1MaUKVPYsGGDSstiaJKAgABsbGyYM2cOixcv/tfjmZmZ/Pzzz6xbtw4nJye2bdum1C3BN2/ecPDgwZxVyEePHlG6dGm6d++ecxayZs2aSovnc3EaGRmRnp7OqVOnvqpWpbzIZDIWLlzIokWLsLa2ZteuXWrZ0UjRBd8H6d0lOiKAyMjIAnWhJi+eP39Oq1atqF27NkeOHKFo0aKqDumrpaam4uDgQHh4ONu3by/QZcuEfxMJpaAWPDw8cHJy4vfff2f8+PGqDkftnTt3jo4dO2JmZoanp+dnb3R7eHgwfPhw6tati6+vLw0aNFBITJIkcenSpZzuNCdPniQrK4smTZrkrEJ27NhRrT4gs7KyMDc359SpU5w6dYpGjRqpJI7g4GAGDhxI1apV8ff3V7vzcopsSSnJskk9H04bbheoCzV5kZ2djampKRcvXuTMmTNKP/YhD1lZWYwZM4bt27ezbNkyZs6cqdYr74L8iIRSULmEhATat2+PtbU1rq6u4s3nC548eUL79u2pVKkSx44d+6qbwgkJCdja2vL48WN27dqFtbW1XGJJTk7m4MGDOX2yHzx4QMmSJenWrVvOhZratWvLZS5FGDduHJs3byY8PJzu3burNJbr169jbW1NYmIiu3fvVqv2dp1/O8K9l6kKG79WueIc+7mbwsbXFHPmzOHXX3/l4MGDmJiYqDqcPJMkiYULF7Jw4ULGjh3L+vXrc91gQNA8IqEUVOrNmze0a9eO4sWLEx0dXaBuaSpCWloaJiYmJCYmEhcXl6sVjLdv3zJkyBD8/PyYMWMGS5YsyfXNaUmSuHLlSs4q5PHjx8nMzKRhw4Y5q5DGxsYUL148t7+a0m3YsIEJEyawZcsWRo4cqepwgL/LxAwdOhRvb29mzpzJkiVLVP5B/C49i+YLIlDkB4UWcGmBqVq1aVS24OBg+vbty6+//sqMGTNUHY5cbNu2jdGjR2NlZYWbm5tGvC8IeScSSkFlZDIZNjY2HD16lPj4eOrVq6fqkFTiay94fCgj4u/vz/Hjx/N0k1KSJFatWsXMmTPp0qUL7u7uX6wd9+7dOw4fPpxzoSYxMZESJUpgYmKSswr53Xff5ToWVQoLC8Pc3JxJkyaxevVqVYfzEUmSWL16NTNmzKBbt264u7ujp6ensngSHr2hz4YTCp8ndHxHmlYrq/B51NHt27dp3bo1Xbp0wd/fv0Dt0gQHB+Pg4EDbtm0JDAykXLlyqg5JUBCRUAoqs3z5cmbPnk1wcDDm5uaqDkep8tL/eMmSJcydOxdPT0/69euXr/mPHDmCo6MjRYoUwcfHBwMDg5zHJEni2rVrOQnksWPHyMjIoF69ejkJZOfOnSlRokS+YlCVS5cuYWRklPPhreoVwP9y+PBhHBwcKFWqFH5+frRu3VolcZxNfIX1n1EKn8d/jBGtahW+ZCMtLQ0jIyPevXtHfHw8ZcsWvKQ6Ojoac3NzqlSpQnh4uFpcxhPkTySUgkocOHCAXr16MWfOHBYtWqTqcJQmr0WyOxZ/wOiBdixcuJB58+bJJZaHDx9ib29PfHw8K1eupF69eoSHh7Nv3z7u3LlDsWLFMDExwczMDDMzM+rXz1tXE3Xy9OlT9PX1+fbbbzlx4oTat4tLTEzE1taWS5cusWXLFgYNGqT0GMQKpeJIksTQoUPx9PTk1KlTOa0tC6Jr165hampKVlYW4eHhop1uASQSSkHp7t27R5s2bWjXrh0hISFqu0Ikb3ntf6ytBdmZ6Xz/+iyHti6S23bYjRs3CA4OZv369SQmJgJQu3ZtzM3N6d27N126dNGI1oBfKy0tja5du3L37l1iY2M1ZpXk/fv3/PTTT+zcuZOxY8eyZs0apd6UT0nPopk4Q6kQ27dvZ8SIEezevVslXxaU7fHjx5iZmXH37l0CAwPp3LmzqkMS5EgklIJSvX//no4dO5KUlMTp06cpX768qkNSio1HbrBqfz76H0sSaGnlq/9xWloakZGRORdqbt68SdGiRencuTOVKlXCz8+P+vXr4+vrW+DOs0qSRP/+/QkMDCQyMpJ27dqpOqRckSSJrVu3Mn78eNq1a4e3tzfVqlVT+LwJCQl4enri8up7KK24+py19UoSOU1zbzXnxenTp+nQoQNDhgzhzz//VHU4SvP27VtsbGw4fvw4bm5u2NnZqTokQU7+u3idICjAuHHjSEhIwM/Pr9Akkx5xiflLJgH+b1Vy1f7reMYlfvWP3b59mz/++IM+ffqgp6eHmZkZgYGBdO/enaCgIJKSkti/fz979uwhJiaG1NRU2rZtS1BQUP7iVTMLFy7Ew8MDFxcXjUsm4e9Wh6NGjeLYsWPcvXuXNm3acOKEYrahr1+/zuLFi2nWrBnNmjXj999/p7rWK4V9WOhoa2HS4PMXwwqaly9fYmdnR/PmzTWmE468lClThn379mFra0u/fv3YsGGDqkMS5EQklILSbNu2jR07drB582ZatWql6nCU4v7LVOYHJch1zHlBCdz/j5qA6enpHDhwgMmTJ9OoUSO+//57Jk+ezPv371m8eDEJCQncvXuXP//8EwsLi4/OEDZv3pz4+Hi6dOmCpaUlc+bMITs7W66xq8LevXtZuHAhy5Yt0/jVEAMDA06fPk2DBg0wMTHhjz/+QB6bTHfu3OHXX3+lVatWNGzYkJUrV9KiRQuCgoJ4+vQpu+YMQyaH+D8lWyYx0KCWgkZXPzKZjIEDB/L27Vt8fHy+2OazICpatCh79uxhypQpTJgwgZkzZ8rldSyoltjyFpQiLi6Ojh07MmzYMDZt2qTqcJRGGf2P7927l3Mj+9ChQ6SmplKjRo2cG9ndunXjm2+++erxZTIZK1euZM6cOXTt2hV3d3eltiOUp6ioKExMTHBycmLnzp0FphzLP9tqDho0iM2bN+f61v39+/fx8vLC09OTuLg4SpQogbm5OQ4ODvTu3ftf4ynjtVwYLF68mPnz5xMWFoapqamqw1G5tWvXMmXKFJydndm+fbtaddISckcklILCPX/+nDZt2lCtWjUiIyMLzTdyRfc/7pkZw8kwXy5fvoyuri4dOnTISSKbNWuW7+Tp0KFDODk5Ubx4cXx8fGjfvr2cIleOO3fuoK+vT6NGjThw4ECBfN25ubkxYsQIGjVqhJ+fH3Xq1Pns8x8/foy3tzeenp5ERUVRrFgxzMzMcHBwwNzc/LO33u+/TKX72kjSs+SzVilJEkW04ci0rtQsX3Auf31OREQEZmZmLFiwQG7VGgoCDw8PBg0ahImJCT4+Prn6AiyoD5FQCgqVlZVFr169uHjxIqdPn6ZGjRqqDklpFN3/WHbtKKYV3mJmZkb37t0VUr/u/v372Nvbc/bsWX7//XdGjhypEat8b968wcjIiPT0dE6dOqWxK6xf4/z581hbW/PmzRs8PDzo0aPHR48/e/YMX19fPD09OXbsGLq6uvTs2RMHBwcsLS0pU6bMV8/lEZfITL+Lcos9ad96frYz5pdfftGI11V+3Lt3j9atW6Ovr09ISAja2uLE2T8dPnwYa2tr6tWrx759+6hcubKqQxJySSSUgkLNmjWL3377jYMHD9KlSxdVh6NUiu5/rKybsenp6UyZMoVNmzYxePBg/vzzT7Uuap6VlUWfPn2IjY0lOjqaRo0aqTokhXv58iUDBgxg//79LF26lBEjRuDv74+npydHjhwBoFu3bjg4OGBtbZ2vbiU/7zqE17X3OZUH8mpazwa8OuHBvHnzcHZ2Ztu2bQVyFRn+/hsyNjbm2bNnnD59WqWdj9TZ+fPnMTMzo0SJEoSHhxeI2reFiUgoBYXx9/fHxsaG3377jWnTpqk6HKUqiP2PXV1dGTVqFA0bNsTX11dt2y2OGzeOzZs3ExERQbdu3VQdjtK8fPmSIUOGEBQUlLPa16VLFxwcHLCxsaFixYr5nuPx48e0adOGykbWpDY2z3VNVR1tLXS1tVjUtykO7f6+iOPu7s6QIUNo3749fn5+BXI1ecyYMfz1119ERUXRpk0bVYej1u7du4epqSlJSUmEhoZq3FGbwkysuQsKcfXqVQYPHoy9vT1Tp05VdThKdy8pRaHJJIAE3E1KUfAs/5+zszPR0dEkJyfTpk0bQkNDlTb319qwYQN//PEHmzZtKhTJ5Lt373B3d8fKyoqqVasSFBRE48aNKVq0KN9//z2bNm1i1KhRckkmMzIysLe3ByBs41wOTu6M0Xd/r7TpaH9+pfLD40bf6XFwcuecZBLAycmJw4cPc+XKFQwMDLh27Vq+Y1UnLi4ubN68mY0bN4pk8ivUrl2bkydP5lQy2Ldvn6pDEr6SSCgFuXv37h02NjbUqFGDHTt2FPizUZ+SIaeLC+oyzwctWrQgPj4eY2NjzM3NmTdvntqUFtq3bx+TJk1iypQpjBw5UtXhKExqaio+Pj7Y29tTqVIl+vfvz+PHj1m+fDmJiYlcvnyZ8+fPU7RoUdq3b4+/v79c5p06dSqxsbH4+vpSpUoVapYvieswfQ5M6oSzfm1q65Xkf//Stfj7aIazfm0OTu6E6zD9T17AMTIyIiYmhqJFi2JoaMjRo0flErOqXbhwgdGjR/Pjjz8yfPhwVYejMfT09Dh48CA9evSgb9++7Ny5U9UhCV9BbHkLciVJEg4ODoSHhxMbG1sozq99SkHvfyyTyVi+fDlz586lZ8+euLm5qfRc2MWLF+nQoQNdunTB39+/wLXzTE9PJzw8HE9PT4KCgkhJSaFVq1Y4ODjQr18/6tat+6+fSU5OZujQofj4+DB79mwWLVqU538XFxeXnPOzo0eP/s/npaRncTcphYwsGUV1tamjVypXRzJev36Nvb09R48eZevWrQwZMiRP8aqDN2/e0LZtW0qVKkV0dLRanztWV1lZWYwbN44tW7awePFi5syZUygXKDSFSCgFuVqzZg1Tp07F19cXGxsbVYejMinpWTRdEKHQOdSh//GBAwdwcnKidOnS+Pj40LZtW6XH8PTpU/T19fn22285ceLEZ0vfaJKMjAwOHjyIp6cnAQEBvH37lmbNmuHg4ICDg8NXXViQJIlVq1Yxc+ZMunfvzt69e3Od+J85c4YOHTrg5OSklB2HzMxMxo4dy7Zt25g5cyZLly7VuBvRkiRhY2PDkSNHOH36NN9//72qQ9JYkiSxZMkS5s2bx+jRo9m4cWOB+8JYUIiEUpCbo0eP0r17d6ZOncqKFStUHY7SSZJEQkIC3t7eeHt786bTZIqUU1y/ZXXpf5yYmIitrS0XLlzgjz/+UOrWXlpaGl27duXu3bvExsZSs2ZNpc2tCFlZWRw5cgRPT0/8/Px49eoVDRs2zEkimzRpkqdxDx48iKOjI9988w1+fn5f3akqKSmJNm3aUKFCBU6cOEHx4sXzNH9uSZLEmjVrmD59Ora2tuzevZuSJTWnVuXKlSuZMWMGQUFBWFhYqDqcAmHHjh2MGjUKCwsL9u7dK1Z81ZBIKAW5ePDgAW3atKFZs2ZERESgq6u6VTNlkiSJixcv4u3tjY+PD1evXqVs2bJYWlpCa3tOPNUmWwF/YjraWjjr12ZB36ZyHzsv0tPTmThxIlu2bGHo0KFs3LhR4W/4kiTRv39/AgMDiYyM1Mge3QDZ2dkcP34cT09PfH19ef78Od99911OEvnDDz/IZVXw3r172NjYcPnyZbZt28bAgQO/GJeZmRlnz57l9OnT1Kql/PaIAQEBDBgwgGbNmhEYGEiVKlWUHkNuHT16lG7duuWsrgryExoair29Pa1atSI4OJjy5curOiThH0RCKeRbRkYGnTt35sGDB5w5c0YuN0rVmSRJnD9/Pmcl8saNG3z77bdYWVlhb29Pt27dKFasmMI75Ryc3Il6ldSro8SuXbsYM2YMTZo0wcfH55Nn++Rl/vz5LFq0CG9vb43r0S2TyTh16hSenp54e3vz+PFjatWqRb9+/XBwcKBNmzYK2VpOS0vjp59+YteuXYwfP55Vq1b9Z6u7WbNmsXLlSg4cOEDXrl3lHsvXOn36NBYWFhQpUoSQkBCaN2+usli+5OHDh7Ru3ZrmzZsTEREhtmYVICYmBnNzcypUqEB4eDi1a9dWdUjC/xEJpZBvY8eOZfv27Rw/frzA1gyTJIkzZ87g4+ODj48PN2/epHz58jlJZNeuXT/5wVwY+x+fPXsWW1tbXr9+jZubG2ZmZnKfw83NjYEDB7Js2TJmzZol9/EVQZIk4uPj8fT0xMvLi/v371O1atWcJFJfX18pZwUlSWLz5s1MnDgRfX19vLy8qFq16kfP8fX1xc7OTm1qyD548ABzc3Nu376Nl5cXvXr1UnVI/5KZmUmXLl24d+8eZ86coVKlSqoOqcC6fv06vXr1Ij09nbCwMH744QdVhyQgEkohnz7c/tyyZUuBK9XyIQH4kETevn0bPT09rK2tsbe3x8TEhCJFinx2jMLa//jVq1cMHDiQsLAw5s+fz9y5c+WWLEVFRWFiYoKTkxM7d+5U61ufH1azPySRt2/fpmLFitjZ2eHg4EDHjh1VtooVFRWVs7Lr4+ODkZERAJcvX0ZfXx8zMzM8PT3V5t/33bt3ODk5sW/fPn7//XfGjh2r6pA+MnnyZP744w8iIyMxNDRUdTgF3pMnT+jduze3bt0iICAAExPVnycv7ERCKeTZuXPnMDQ0pH///mzfvl1tPnjyQ5IkYmNjc85E3rt3jwoVKmBjY4O9vT1dunTJ9flQRfQ/nmjRnkWLFqn17VeZTMbSpUuZP38+vXr1Ys+ePfk+83Tnzh309fVp1KgRBw4cUNtWfQkJCXh6euLp6cn169cpX748NjY2ODg45Ok1pChPnjyhX79+nDp1inXr1tG/f3/09fUpUqQIp06dUrsb89nZ2UybNo1169YxceJEVq9erRbbyl5eXjg4OLBhwwbGjRun6nAKjeTkZGxtbYmMjMTFxQUHBwdVh1SoiYRSyJOXL1/Stm1bypUrx4kTJzT6xp1MJiMmJiYnibx//z6VKlXC1tYWOzs7OnXqlO8EYFXYJTYeuyeX/sepcf7MnDkTa2trXFxcKFWqVL5iU7Tw8HAGDBhAmTJlcnXD+H+9efMGIyMj0tPTOXXqlNq16Lt+/XpOEpmQkEDZsmWxsrLCwcGB7t27f3E1W1UyMzOZNm0av//+OzVr1uTNmzfEx8erdR/lTZs2MX78eMzMzHB3d+ebb1R3lvjKlSu0a9eOvn374ubmViC+WGuSjIwMhg0bxp49e1i7di2TJk1SdUiFlkgohVyTyWSYm5sTExPD6dOnqVOnjqpDyjWZTEZ0dDTe3t74+vry4MEDqlSpkpNEGhsby3Xlw9nZmfDrbynXYxTZEvnufxwYGMiAAQNo0KABQUFB1KhRQ26xKsLdu3extbUlISGBP//8M9cFq7OysujTpw+xsbFER0erTcH8O3fu5CSR586do3Tp0vTt2xcHBwdMTU3VdgX1U+zt7fHx8eH777/n0KFDan/ZITw8nH79+vHdd98RHByskpJRycnJtG/fHm1tbWJiYtRuRbewkMlkOZfIpk2bxooVK9R696bAkgQhl+bPny9paWlJERERqg4lV7KysqRjx45J48ePl6pVqyYBUrVq1aTx48dLkZGRUlZWlkLmdXV1lQDJ1dVVSkxKkQZuPyXVnhkifTc7VKo9M+Q//+/D4wO3n5ISk1L+Ne65c+ekmjVrSlWqVJFiYmIUErs8paWlScOGDZMAacSIEVJaWtpX/ZxMJpN++uknqUiJ0tJf/vulM/deSpcevpbevc9UcMSflpiYKK1atUpq166dBEglSpSQ7O3tJR8fHyk1NVUlMeXXvn37JC0tLWnUqFFSnTp1JD09PenAgQOqDuuLLl68KNWqVUuqWrWqFB8fr9S5ZTKZ5ODgIJUuXVq6evWqUucWPm39+vWSlpaWNGDAACk9PV3V4RQ6YoVSyJXQ0FDMzc1ZsmQJc+bMUXU4X5Sdnc2JEydyViKfPHlC9erVsbOzw97eHkNDQ4V+k7116xYtW7bEysoKV1fXnP9+42kybjGJHLn+jMSkVP75R6gF1NIriUmDSgw0qPXZ0kBPnjzB2tqac+fOsWvXLo04Q7Rjxw7Gjh1Ls2bN8PX1/exK2I2nyfy8LZjYBykUKVcV/tEtWguoVb4kJg0rMUC/FvUrK27b8/Hjx/j4+ODp6cnJkycpVqwYZmZmODg4YG5urtErU7du3aJt27YYGRkRHBzM69ev6d+/PwcOHGDZsmX8/PPPar2N++TJEywtLbl48SJ79+7FyspKKfOuX7+eSZMmaWTZqoLMy8sLZ2dnOnXqhK+vL2XKlFF1SIWGSCiFr/bhg6dTp074+/ur7ZZCVlYWx44dw8fHBz8/P54+fUrNmjVzkkhllWfJyMigY8eOvHz5kjNnzvznG1t++x+/f/+e4cOH4+bmxvz585k/f75aJwDwd21BW1tbkpOTcXd3p2fPnh89fv9lKrP9L3L85gskWTZa2v99/EBHW4tsmYRxvQoss24ut9vvz58/x9fXF09PTyIjI9HR0cHU1BQHBwcsLS0LxAdVSkoKRkZGpKSkEBcXR7ly5YC/v4jNnz+fpUuXYmtry86dO1V6TvFL0tLSGDx4MD4+PqxcuZKpU6cq9G/g5MmTdOnShQkTJrB69WqFzSPkzdGjR7GysqJu3bqEhYVpREH8gkAklMJXSU1NxdDQkNTUVOLj4ylbtqyqQ/pIVlYWR48ezUkinz9/Tu3atXOSyPbt2ys9yZo5cyarV68mKipK4V1cJEli+fLlzJkzh379+rFz5061b1WXlJTEwIEDiYiIYNGiRcyePRttbW084hKZH5RAZraM3JTv/HDWdGHfpji2y1tXl5cvX+Lv74+npyeHDx8GoGvXrjg4OGBtbV2gOnNIksTAgQMJCAjg1KlTnywYHhAQwKBBg6hRowb+/v40bNhQBZF+HZlMxi+//MLy5csZMWIEf/zxh0IuQj19+pTWrVvnnDVV18tWhd3Fixfp1asXRYsWJTw8XK1fuwWFSCiFL5IkiUGDBuHn50dMTAzNmjVTdUjA37dTjxw5go+PD/7+/rx48YK6devmJJFt27ZV2UrdwYMH6dmzJ8uXL2fGjBlKm9fPzw9nZ2eaNGlCYGAg1aoprpe4PGRnZ7N48WIWLlyIubk5ncYs44/jifked1rPBowz+bpbym/evCEwMBBPT0/2799PdnY2nTt3xsHBAVtb2wLb+enDlq27uzuOjo7/+bxr165hbW3NgwcPcHFxUdqWcl7t3LmTUaNG0alTJ3x8fPj222/lNnZWVhY9evTgypUrnD179l8F4QX1kpiYiJmZGU+fPiUkJAQDAwNVh1SgiYRS+KKNGzcyfvz4L37wKENmZiaHDh3C29ubgIAAXr58yffff4+9vT12dna0bt1a5du9z58/54cffsjpa67sowFnzpyhb9++SJJEUFAQbdq0Uer8ebFv3z5+XLyNkl2Gy23MFTbNc27F/693794RHByMp6cnYWFhZGRk0KFDBxwcHLCzsyvwiUJkZCTdunVj0qRJrFq16ovPT05OZsiQIfj6+jJnzhwWLlyoFvUf/8vRo0exsbGhcuXKhIaG8t1338ll3JkzZ7Jq1SoOHz5Mp06d5DKmoFgvX77E0tKS06dP4+Xlhbm5uapDKrBEQil8VlRUFJ07d2bcuHGsXbtWJTFkZGRw8OBBvL29CQwM5NWrV9SvXz8niWzZsqXKk8gPJEnCwsKCmJgYLly4oLLE5PHjx1haWnLp0iVcXFzU/tLA/ZepdFtzlIwsWb7qdP5TMV1tDk7unHOmMjU1lX379uHp6UloaChpaWm0b98eBwcH7O3tVVJ2RhUePHhAmzZtaNKkCQcOHPjqGquSJLFy5Upmz55Nz549cXNzU+sjANevX6dPnz68fv2awMDAnE5AeRUQEIC1tbXatKMUvl5aWhoDBgwgMDCQLVu2MHy4/L64Cv+fSCiF//TkyRNat25NvXr1lH5WKD09nQMHDuQkkW/evKFhw4bY29tjb29P8+bN1SaJ/KcNGzYwYcIEgoODVf5NOC0tjSFDhuDp6cnixYuZM2eOWv6bgeJ6nhvUKUe/Ss/w9PQkKCiIlJQUWrVqhYODA/369aNu3bpym08TpKen07lzZx4+fMjp06fz1G/6wIEDODo6UrZsWfz9/WnRooUCIpWPFy9eYGNjQ2xsLDt37sTJySlP49y8eZM2bdrQvXt3fHx81PbvSPhv2dnZTJgwgU2bNrFgwQLmzZsn/neUM5FQCp+UmZlJ9+7duXHjBmfOnFHKLbn379+zf/9+vL29CQoK4u3btzRu3DgniWzatKlavwGcP3+e9u3bM3r0aNavX6/qcIC/V5UWL17M/PnzcXJyYseOHWrX1ejG02R6rDumsPEfbhtNo6rf5iSRDRo0UNhc6m7UqFHs2rWLEydO5Oui2N27d7GxseHq1ats27aNAQMGyDFK+UpPT2fEiBG4urqycOFC5s6dm6v3kQ8XEtPS0oiPjy8Qt/sLq39eXhwxYgSbNm1SmzaoBYH4lyxEclOeZsaMGURFRXH06FGFJpNpaWmEh4fj4+NDcHAwycnJNG3alClTpmBvb0+TJk0UNrc8paam4ujoSOPGjVmxYoWqw8mhpaXFvHnzaNSoEYMHD+b27dsEBASoVRkNt5hEtLXI1Y3ur6WFxJhVe/n9R2P5D65htm/fztatW9m+fXu+qw7UqVOHkydPMnr0aAYOHEhsbCyrVq1SyxvPxYoVY/fu3TRo0IC5c+dy48YNtm/f/lVdjCRJYvTo0dy8eZOYmBiRTGo4LS0tZs+eTbVq1Rg+fDhPnjzBw8ND7StiaAqxQlnA5RTQvvaMxJefKKD9icLQHh4eODk58fvvvzN+/Hi5x5SamkpYWBg+Pj6EhITw7t07fvjhB+zs7LCzs6Nx48Zyn1PRRo0ahaurK6dPn1bb+OPi4rC0tERXV5egoCBatmyp6pAAMFq+n0dvMxU2fm29kkROM1HY+JogNjYWY2NjhgwZwubNm+U2riRJ/Pnnn0ycOBFDQ0O8vLzU6svK//L09GTw4MG0a9cOf3//L/aD37JlC6NHj2bPnj1qvQor5F5YWBh2dnb88MMPBAcHf/G1IHyZSCgLqH8Whv5Q+Pm//LMw9I/NitG3awesra1xdXWV2xZzSkoK+/btw9vbm9DQUFJTU2nZsmVOiR9N3ob08fHB3t6erVu3MmLECFWH81kPHz6kb9++XL16FTc3N5WXgHn0LAmjNdFyu4jzKVrApQWmuSoWX5A8e/aMNm3aUL16dSIjIxXSXzwqKgo7Ozu0tLTw8fHB0NBQ7nPIS3R0dE5h+pCQkP/sCx8XF0fHjh0ZMWIEGzduVHKUgjLExcXRp08fypcvT3h4OHXq1FF1SBpNJJQF0IfC0FkyKVeXHHS0IDsrgxIJIZz23pDvbYB3794RGhqKt7c3+/btIy0tjdatW2Nvb4+trS31639dnUB1lpiYSIsWLejWrRve3t5qfcbzg9TU1JyuIh/qZKoi7qysLLrZDeZe4/4Knyt0fEeaVlOvYvzK8KFu4uXLlzl9+jQ1atRQ2FyPHz/G3t6e2NhYfv/9d0aNGqW2fw937tzB3NycR48e4evrS9euXT96/MWLF7Rp04aqVasqLAkX1MPNmzcxNTXN2TlTl50bTaSevfOEPNt45AYz/S6SniXL9Y3ZbAkk7SKk/WDDXzEP8zT/h1Z6NjY2VKxYEUdHR+7du8eCBQu4efMmp0+fZubMmQUimczKymLgwIF88803bNu2TW0/PP9XyZIl8fT0ZO7cucyaNYvBgweTnp6u1BgkSWLixInEnT6rlPkysmRKmUfdzJgxg+PHj+Pt7a3QZBKgatWqHD58mFGjRjFmzBiGDRvG+/fvFTpnXtWtW5eTJ0/Srl07TE1N+euvv3Iey87OZsCAAaSmpuLt7S2SyQKuXr16REVFUb16dTp16sShQ4e++mdT0rNIePSGs4mvSHj0hpT0LAVGqv4K5x5QAeURl8iq/dfzNcaHpGjV/utULF3sPwtD/9Pbt28JDg7G29ub8PBw0tPTad++PYsXL8bOzq7AbiMsXbqUkydPcvTo0ZweyJpCW1ubRYsW0bhxY4YMGcKtW7fw9/fPUxmZvNiwYQObNm1i0Ya/2JG37y65UlS38H139vDwYM2aNaxbt05pRbiLFi3Khg0baNeuHaNGjeLChQv4+flRq1beWmEq0rfffktoaCjjx49n2LBhXL9+nWXLlrF48WIOHDjA/v37C01t0sKucuXKHD16FDs7O8zMzNi9e/d/lpjKy72EwkJseRcQ91+m0n1tJOlyXIn538LQ//T69eucJDIiIoKMjAwMDAxytrNr164ttzjU0YkTJ+jcuTNz585lwYIFqg4nX2JiYrC0tKR48eIEBQXxww8/KHS+ffv2YWFhwaRJk1i0bAXNFkSgyDehwniG8sKFCxgaGsr9LHRunD17FhsbG969e4eHhwfdunVTegxfQ5Ik1q5dy7Rp0zAyMuLkyZMsWbKEOXPmqDo0QckyMzMZPnw4Li4urFq1iqlTp+Y8ltd7Ccusm3/yM7QgEgllAaGowtBG3+nhOkwfgFevXhEYGIiPjw/79+8nMzOTDh06YGdnh62tbaH5Nv/q1StatmxJzZo1OXr0aIGoY3b//n0sLCy4desWe/fuxcLCQiHzXLx4kQ4dOmBiYoKfnx86Ojp0/u0I916mKmQ+KHy3vF+9ekW7du0oXbo0UVFRKi2JkpSURP/+/Tl48CC//vor06ZNU9ujIVu3bmXUqFGULVuWhIQEqlevruqQBBWQJIk5c+awfPlyJk+ezKpVq/A6/SBv9xK0tdDV1mJh36Y4fsVun6YTCWUBoOjC0GNqvyAyyJODBw+SlZVFx44dc5LIwvamK0kS/fr14+DBg5w7d65ArcS+e/cOZ2dnAgMDWblyJVOnTpXrh/+TJ0/Q19enXLlynDhxgtKlSwOwICgB15h7cv0y9IGOthbO+rVZ0Lep3MdWRzKZDAsLC6Kjo4mPj5dbD+v8yM7OZu7cuSxfvhw7Ozv++usvvvlGvbYC379/T8eOHXn8+DGSJKGrq0tISIjCV+sF9bVx40YmTJhAh5GLuV+uZb7Hm9azAeNMNP/uwOcUvoNFBZBbTCI62or51i/JslnpG01qaipr167lwYMHHDt2jAkTJhS6ZBJgx44d+Pj4sG3btgKVTAKULl0aX19fZs2axfTp0xk2bBgZGRlyGTstLQ0rKysyMzMJDg7OSSYBBujXUkgyCZAtkxhoUPBXBj5YuHAhYWFh7N27Vy2SSQAdHR2WLVuGr68v4eHhGBgYcP16/s56y9uECRO4dOkSISEhxMbGoqenR4cOHdi3b5+qQxNUZNy4cUzd5CeXZBL+vpfgGZcol7HUlUgoC4Aj154p7ANZS1uHxt3sOHr0KGPHjqVatWoKmUcTXLlyhYkTJzJ8+HDs7OxUHY5CaGtrs3TpUlxcXHBzc6N79+48f/48X2PKZDKGDBnChQsXCAoK+tfRiPqVv8G4XgW5fynS0dbCuF4F6lVSr9UwRQkODmbRokUsXryYXr16qTqcf7GxsSEuLg6ZTEa7du0ICgpSdUgA7Ny5k23btrFp0yZatWpFjRo1OH78OCYmJlhYWIgalIXU/ZepBD2U7w3/eUEJ3Ffg8R5VEwmlhnuXnkWigl+gD9+kF/pyCO/fv8fJyYlatWqxbt06VYejcM7Ozhw5coSrV6+ir69PQkJCnsdauHAhnp6euLq60rZt208+Z5l1c3TlmFBKkoQsM4MpnQrHF6Dr168zcOBArKysmDVrlqrD+U+NGjUiJiaGbt26YWlpybx588jOzlZZPOfOneOnn35i+PDhDB06NOe/ly5dGn9/fyZOnMj48eOZMGGCSuMUlG+2/0Wy5LxQkyWTmO1/Ua5jqhORUGq4e0kpCr0hCyABd5NSFDyLeps5cyZXrlzBw8ODUqVKqTocpTAyMiIuLo7SpUtjaGhIWFhYrsdwc3Nj0aJFLFu2DFtb2/98Xs3yJVkox3OOWlpaZETvwbJbB86eVU6tS1V59+4d1tbWVK1ald27d6Otrd5v62XKlMHX15dly5axZMkSLCwsePXqldLjeP36Nba2tjRp0oQNGzb863EdHR3WrFnDpk2b2LRpE5aWliQnJys9TkH5bjxN5vjNF3Lf+cuWSRy/+YKbzwrm60i933mEL1JWwebCWhgaIDQ0lPXr17Ny5UpatGih6nCUqnbt2pw8eZIuXbpgbm7OunXr+Np7fCdPnmTo0KEMHjyYmTNnfvH5vRt+S5Er4fkNGYDpPRtyau9aKlWqRIcOHfDw8JDLuOpGkiSGDBlCYmIi/v7+lClTRtUhfRUtLS1mzZpFeHg4MTExtG3blgsXLihtfplMxqBBg3j16hU+Pj4UL178P587ZswYQkNDOX78OB07diQxsWCfgxMUey9BR1uLPacK5mtIJJQaTlkFmwtjYWj4u53cjz/+SJ8+fZgwYYKqw1GJb775Bn9/f6ZOncrkyZMZNWrUFy/r3L59GysrK/T19dmyZcsXb4vLZDIGDhzIsyMuTDSsQDFd7Vy/oetoa1FMV5sVNs0Za1KPmjVrcvz4caytrXFycmLWrFkFbtty1apV+Pj4sHv3bho3bqzqcHKtZ8+exMfHU6ZMGQwMDNi7d69S5l2xYgXBwcHs2bOHunXrfvH5pqamREVF8ebNG/T19YmPj1dClIKqKPJeQrZM4sj1ZwoZW9UKZ5ZQgNTRK4Wiq7pp/d88hc2HVQxdXV127typtvXzlEFHR4eVK1fy119/sWvXLkxNTUlKSvrkc9+8eYOFhQVly5bFz8/vq1rXzZ07l5CQENzd3ZncV5+Dkztj9J3e33N/IbH88LjRd3ocnNz5o+5OJUqUYM+ePaxcuZIVK1ZgaWnJmzdvvvbXVmuHDh1i5syZzJw5ExsbG1WHk2cf2iDa2dkxYMAAJk2aRGZmZq7H+do2eIcOHeKXX35h7ty59O7d+6vHb9q0KTExMdSuXZtOnTrh5+eX6xgF9aeMewmJSakF8l6CqENZAIjC0Irx22+/8fPPP7N//3569Oih6nDUxvHjx7GxsaFs2bKEhITQqFGjnMeysrLo06cPsbGxREdHf/TYf/H09MTR0ZGVK1cyffr0jx7LaXN2/RmJSZ9oc6ZXEpMGlRhoUOuLt7nDw8NxdHSkSpUqBAUF0aBBg9z82mrl3r17tGnThtatWxMWFoaOjo6qQ8o3SZL4448/mDx5MkZGRnh5eVG5cuXP/kxu2+A9ePCA1q1b07Jlyzz/u6WlpfHjjz/i5eXFihUrmD59eqH+slnQJDx6Q58NJxQ+T+j4jjStVlbh8yiTSCgLAFEYWv7i4uIwMjJiypQprFixQtXhqJ07d+5gYWHBgwcP8PLyomfPnkiSxNixY9m2bRvh4eFf1Wrv9OnTGBsbY2tri4uLy2c/mFPSs7iblEJGloyiutrU0SuV63aK169fx9LSksePH+Pu7o6ZmVmufl4dpKWl0bFjR16+fEl8fDx6enqqDkmuPqxWamtr4+vri4GBwb+ek5c2eB2+K8/1vYt4eiuBM2fOUKFChTzHKJPJmDdvHkuXLmX48OFs2rSJIkWK5Hk8QX2cTXyF9Z9RCp/Hf4wRrWqVU/g8yiQSygJA0Z1yDk7uVGhq+QEkJyfTqlUrypUrx8mTJylatKiqQ1JLb9++xcnJiYiICNatW0d2djaTJk1i69atjBgx4os//+TJE9q1a0fVqlWJjIykRIkSSoj67y35AQMGsG/fPn799VeNWmGSJImhQ4fi4eFBVFQUrVq1UnVICvHo0SPs7e2Ji4tjw4YNjBw5Mud/I4+4xDy1wdOSZMiyMhndXo9Z/TrLJc7du3czYsQIjI2N8fHxoVy5gpUgFEZihTLvxBnKAkAUhpavcePG8fTpU9zd3UUy+RllypQhKCiICRMmMH78eCZNmsSkSZO+KplMT0/HxsaG7Oxs/P39lZZMApQtW5bAwEBmzpzJjBkzGDhwIGlpaUqbPz82b97Mrl272Lp1a4FNJgGqVavGkSNHGDlyJKNHj2bEiBG8f/+ejUduMNPvIulZslzvyEha2mgVKcqWs+/YeOSGXOIcPHgwBw4c4Ny5cxgaGnLr1i25jCuojriXkHcioSwg5F0YGkBXW4tl1s3lOqa6c3Nzw8XFhU2bNlGvXj1Vh6P2dHR0GDJkCMWKFUNLS4sLFy58saagJEmMGTOGM2fO4O/vr5IWnh/aAXp4eODv74+xsTH3799Xehy5ERUVxcSJExk3bhzOzs6qDkfhihYtysaNG9m1axdubm60dZjIqv35bdn493ukPNvgde7cmVOnTiGTyTAwMODkyZNyGVdQjVLFdKlWVrELCbX0Sub6uI4mEAllASHvwtAAdnVl1CxfUq5jqrPbt28zZswYBgwYUCg+sOXhyZMnmJub06hRI0JDQzl37twXezX//vvvOe3u9PX1lRjtvzk4OHDy5EmeP39O27Zt1TYZePz4MXZ2dujr67N69WpVh6NUgwcPxm9/JO8a9PrqGqhfQ55t8OrXr090dDRNmjSha9euSit/JMhPSkoKe/bsoWfPnlw97IskU0yJMR1tLUwaVFLI2KomEsoCxLFdLab1/HBzNX9vvFWexbJipCW7du3Kd1yaIDMzEycnJypWrMimTZtUHY5GSEtLw8rKiszMTIKDgzEzMyMmJgZtbW309fU5dOjQv35m//79TJkyhWnTpqlN0t6qVSvi4uJo2LAhJiYmbN++XdUhfSQjIwN7e3sAvL29C+UxjL3XJXSKFJXrWVd5t8HT09PjwIEDODk5MWDAABYuXCjXBFiQv+zsbA4ePMjgwYOpXLkyzs7OpKenM83KAC1txVROyJZJDDSo9eUnaiCRUBYw40zq80vP75CyMkHKXXebfxaGPrFlLsOGDWPIkCEsX768wL8xzp8/nzNnzrB3716N6TaiSjKZjB9//JELFy4QFBREzZo1AahXrx7R0dG0b98eU1NTNm/enPMzN27cwMHBgZ49e/Lrr7+qKvRPqlSpEgcPHmTYsGGMGDGCcePG5akWoiJMnTqV2NhYfH19qVKliqrDUbqcNnhyfgtSRBu8okWLsnPnTpYuXcqCBQsYOHAg79+/l9v4gnxcunSJGTNmULt2bXr06EF0dDQzZ87k9u3bREZGMuunH8W9hDwQCWUBFOX6G8meM2hf++8bZHkpDK2rq8vmzZuZP38+s2fPZuLEiQWuy8gHhw8f5tdff2Xx4sUq34LVFAsWLMDLywtXV1fatm370WPffvstoaGh/PTTT4wZM4YJEyaQlJRE3759qVy5Mu7u7mpZN7Fo0aL8+eef/Pnnn2zZsoWePXvy/Plzlcbk4uLCxo0bWb9+PYaGhiqNRVU0rQ2elpYWs2fPxtPTEz8/P7p3767y15EAT58+Ze3atbRu3ZrmzZuzfft2rKysOHXqFNeuXeOXX375qGuSuJeQe6JsUAFz+PBhunXrllO6RR6Fobds2cJPP/2UUyvwc31vNc2LFy/44YcfaNy4MQcOHEBbW3zH+hI3NzcGDhzIsmXLmDVr1mefu3nzZsaOHUv58uXJyMggLi5OIwqKHz9+HFtbW0qWLElgYKBKerifOXOGDh064OjoyF9//aUxpY3kTZMbN5w6dQpLS0tKly5NaGjoVxX6F+QnLS2NwMBAXFxc2L9/Pzo6OpibmzNo0CDMzMy+eHzEIy6RmX7yOxaxwqb5R528ChqRUBYg79+/54cffqBKlSocPXr0X8lRfgpDBwQE4OTkhIGBAQEBAZQtq/n1syRJwtLSkqioKC5cuEC1atVUHZLaO3nyJF27dsXJyemr21E6Ojri6elJjRo1OHLkiMbcnk9MTMTKyopr166xe/du7OzslDZ3UlISbdq0oUKFChw/flypZZXUybv0LJoviMjnifDP0wIuLTBV2K3bu3fvYm5uzoMHD/D19f2qgv9C3slkMo4dO4arqyve3t4kJydjZGSEs7Mz/fr1o3z58rkab+ORG3KoLgDTezZkrIlmvPfllViOKUCWLl3KvXv32LJlyydX2koV06VptbK0qlWOptXK5uoN1MrKKqfeWqdOnXj06JE8Q1eJP/74g+DgYHbu3CmSya9w+/ZtrKysMDAwYOvWrV+VTLq5ueHp6cnMmTMpUaIE+vr6HD16VPHBykGtWrU4ceIEFhYW2NvbM3fuXGSy3J1Lzovs7GycnJxISUnB19e30CaTAPeSUhSaTMLf1xfvJqUobPw6depw8uRJ9PX16dWrl9pd+ioorl69ypw5c6hbty4mJiYcOXKEKVOmcOPGDU6ePMno0aNznUzC3/cSlls3R0uWBbm8+f3PewkFPZkEkVAWGJcuXeLXX39l1qxZNG7cWCFzdOzYkRMnTvDy5UsMDQ25evWqQuZRhgsXLjBt2jTGjRuHhYWFqsNRe2/evMHc3JyyZcvi6+v7VTeN4+LiGDZsGIMHD2bZsmXExMTQqlUrevTooTEfqiVLlsTd3Z3ly5ezdOlSrK2tefv2rULn/OWXXzh06BAeHh7Url1boXOpu4wsxSfwypinbNmyhIaGMnz4cEaMGMGMGTOU8uWkoHvx4gUbN26kffv2NG7cmE2bNtGrVy9OnDjBrVu3WLBggVx2RLRuR/Fgyygalf/77Hde7iUUBmLLuwCQyWQYGxuTlJTE+fPnKVasmELne/DgAb169eLx48eEhIRo3GWB1NRU2rVrh46ODrGxsQXqTGhufO0RiKysLPr06UNsbCynTp2iYcOGXxz78ePHtG3bllq1anHkyJGcf+PMzEwmTpzIn3/+yeTJk/ntt9/U8oLOp4SGhtK/f39q1KhBYGCgQrbufX19sbOzY+XKlUyfPl3u42uagtYGT5Ik1q9fz5QpU7C2tsbV1ZWSJQtPrV95eP/+PSEhIbi4uBAWFgZA7969cXZ2xtzcXO7v569fv6ZRo0YYGxvj7e0tl3sJBZVIKAuAzZs3M2bMGCIjI+nUqZNS5nz16hWWlpbEx8fj5eWFubm5UuaVh9GjR+Pi4kJ8fDxNmjRRdThKlfNmeO0ZiS8/8WZYviQmDSsxQL8W9St/gyRJjB07lm3bthEeHv5V57/ev39Ply5dePDgAXFxcVStWvVfz9m4cSMTJ06kV69euLu7a0yppqtXr2JpacmzZ8/w9PSkZ8+echv78uXL6OvrY2ZmhqenZ6G9hPNPKelZNNPwM5SfEhwcjJOTE40bNyYoKOiTfyPC/ydJEidPnsTV1RUvLy9ev35N+/btcXZ2xsHBgYoVKyps7jFjxuDm5sbVq1f/dTQqP/cSCiKRUGq4R48e0bhxY/r168e2bduUOndaWhoDBgwgKCiILVu2MGzYMKXOnxd+fn7Y2tqyefNmRo0apepwlOb+y1Rm+1/k+M0X6GhrfbYP8ofHjetVoMGb08ybOjanasCXSJLE4MGD8fb25vjx4/8qKfRP+/fvp1+/flSvXp3g4GC+++67PP1uyvb69WucnJzYv38/q1atYtKkSflO/t68eUP79u3R1dUlJiaG0qVLyylazSVJEjExMQzzv0+KtuJW8RR5y/tzzp49i4WFBVpaWoSEhKikkoC6u3nzJq6uruzZs4fbt29Tq1YtnJ2dGThwoFJuzEdHR2NkZMSGDRsYN26cwufTdCKh1HB2dnacOHGCK1euUK5cOaXPn52dzfjx4/nzzz9ZvHgxc+bMUduVlfv379OiRQtMTEzw8fFR2zjlzSMukflBCWTJpM8mkv9LG8jKTKed1h18f5v6VT+zevVqpk2bhpubG/379//i869evYq5uTlv3rzBz88PY2Pjr45PlbKzs5k9ezYrV65k0KBBbNmyJc9bbTKZDBsbG44cOaIxZZUURZIkLly4gIeHBx4eHty9e5fqfSdTpLEJkpb8j/zraGvhrF+bBXJuW/u1Hj58iIWFBTdu3MDDw4M+ffqoJA518vLlS7y8vHBxcSE6OppvvvkGe3t7Bg0ahLGxsdJKu2VmZtKmTRuKFSvGqVOnNOZojiqJSzkaLCgoCF9fX9avX6+SZBJAR0eHP/74gyVLljB37lx++ukntSyAnp2dzcCBAylVqhTbtm0rNMnkxiM3mOl3kfQsWa6SSQAZoK1blNO6jdh45MYXnx8eHs7PP//MzJkzvyqZBGjUqBExMTE0a9aMbt26aUyrTx0dHVasWIGbmxteXl506tSJhw8f5mms5cuXExgYyJ49ewptMnnt2jUWLlxIkyZNaNmyJVu3bqVnz54cPnyYg5vnKySZBNW3watevTrHjh2ja9eu9O3blw0bNqgsFlXKyMggICAAW1tbqlatyrhx4yhXrhzu7u48efKEHTt20LlzZ6XWCV67di0JCQls3bpVJJNfSaxQaqjk5GSaNGlC8+bNCQ0NVYsEaceOHYwaNYq+ffvi5uamVuVOFi9ezIIFCzhy5IjSzpmqmjKL8l67dg19fX2MjY0JCAjI9RtwRkYG48aNY9u2bUyfPp3ly5drzJv46dOnsbKyIjs7Gz8/PwwMDL76Z8PDw+nduzdz585l4cKFCoxS/dy9exdPT088PDw4d+4c33zzDVZWVjg6OtKjRw+KFCmS81znHTFE3U7K9Zeiz9HR1sLoOz1ch6m+O1Z2djYzZsxg9erVjBs3jrVr16KrW7DP4n040uDq6oqHhwcvX76kdevWODs74+TkROXKlVUW2927d2nSpAmjR49mzZo1KotD04iEUkNNnDiR7du3k5CQQJ06dVQdTo6QkBD69etH27ZtCQwMVNnK6T+dPHmSzp07M3v2bBYtWqTqcJTi/stUuq+NJF2O5VCK6WpzcHJnapb/+Dzb69ev0dfXR0dHh1OnTuX5gs2HG7BTp06lT58+uLm58c03mnFL8smTJ9ja2hIfH8/mzZsZMmTIF3/m9u3btG3bFkNDQ4KDgwtFl6ZHjx7h7e2Nh4cHp06donjx4lhYWODo6IiZmdl/fglV5utZlbZs2cLYsWPp2bMnHh4eGnNZLTfu3LnDnj17cHV15caNG1SvXp2BAwfi7OxM06aqOXrwT5IkYW5uzsWLF7l8+bI4z5wLIqHUQLGxsRgYGLBq1SqmTJmi6nD+JTo6GnNzc6pWrUp4eDg1atRQWSyvX7+mRYsW1KhRg8jIyAL/rf8DZa3oZGdn55QUio2NlUspnbCwMBwcHKhTpw7BwcEaU4sxPT2dcePGsX37diZOnMiqVav+8/WWmpqKoaEhKSkpxMXFqcUXL0V58eIFvr6+eHh45PwN9urVC0dHRywsLL76S4O8V9xNy71gy8+D5TaevBw4cAA7Oztq165NSEgItWppfg3D169f4+Pjg4uLC8ePH6dUqVLY2toyaNAgunTpola7ET4+Ptjb2xMQEIClpaWqw9EoIqHUMJmZmTk1FGNiYtQ2Qbp69SqmpqbIZDIiIiJUUp5HkiQcHR2JiIjg/PnzGpOY5NeNp8n0WHdMYeMfnNwpp77atGnTWLduHeHh4XTv3l1ucyQkJGBhYUFKSgr+/v4YGRnJbWxFkiSJTZs2MXHiRDp37oyXlxd6enr/es7AgQMJCAjg1KlTNG/eXEXRKs6bN28IDAzE3d2dAwcOIEkS3bp1w9HREWtr6zwn0KZT1nKtWP7PmTbJvEnY6kmMHz+eNWvWqN376OXLl+nTpw9paWkEBwfTrl07VYeUa5mZmURERODq6kpgYCCZmZl0794dZ2dnrK2tKVWqlKpD/Jc3b97QuHFj9PX18ff3V3U4Gqfg77EUMGvXruXixYts3bpV7d4E/6lRo0ZER0dTrlw5OnbsyMmTJ5Uew86dO/Hy8mLr1q2FJpkEcItJ/GInh7zS0dZiz6lEAFxcXFi9ejVr1qyRazIJ0LRpU2JjY2nYsCEmJia4urrKdXxF0dLSYuzYsRw8eJDz58/Tvn17Ll269NFzfv/9d/bu3cuOHTsKVDKZmpqKl5cXNjY2VK5cmcGDB/Pu3TvWr1/Po0eP2L9/P0OHDs1zMrljxw72r52Cmd5Liulq5/o1/s82ePtW/V1cf9OmTfTt21fh3Y9yq0mTJsTExFC3bl06d+6Mr6/vV/9sSnoWCY/ecDbxFQmP3pCSnqXASD8mSRLx8fFMnDiR6tWrY2FhwZUrV1iyZAn3798nIiIi53KkOvrll19ITk7m999/V3UoGkmsUGqQ27dv06xZM8aMGcPq1atVHc5Xef36NVZWVsTExODu7o6VlZVS5r169Spt2rTByclJY9r8yUvn345w72WqwsavrVeSFR1L0LlzZ5ydnRV6az49PZ0xY8awc+dOZs2axZIlSzTmrOHdu3extLTk1q1buLq6Ym1tTWRkJN26dWPixIka8zf8Oenp6URERODh4UFQUBApKSm0bdsWR0dH+vXrR82aNeUyz6lTp+jcuTM//vgjW7ZsyXNd1WXWzT86M7l//37s7e3Vdns5LS2NIUOG4Onpya+//srPP//8yb+13DYskLf79+/nnIu8cuUKVapUoX///gwaNEhj6mt+OEq2Zs0aJk2apOpwNJJIKDWEJEn06tWLq1evkpCQoFEHhd+/f4+zszN+fn5s2rRJ4QXF09PTMTAwIC0tjdOnT6vtt2FFeJeeRXMldBZ5v2cs39WqzuHDhxXe6lOSJFavXs3PP/+MpaUlrq6uGvP6T0lJ4ccff8THx4cpU6bg6upK06ZNOXDggFrvMHxOVlYWhw8fxsPDAz8/P968eUOzZs1wdHTEwcFB7i0pHz9+TJs2bahbt+6/Xm/yaIN3+fJlzM3NSU1NJSgoiPbt28s1/vySyWQsWLCAxYsXM2zYMDZt2kTRokWBvDcs+N/EOi+Sk5Px9fXFxcWFo0ePUrx4caytrRk0aBDdunXTqNd3VlYW7dq1Q0tLi9jYWI2KXZ2IhFJDuLm5MXDgQEJDQ+ndu7eqw8m17OxsJk2axMaNG5k/fz7z589X2KrWlClT+OOPPzh16hStWrVSyBzqSlm9j7NDlxB/IECppT1CQkJwcnKiXr16BAUFyW31S9EkSWLhwoUsXLiQ4sWLc/nyZerWravqsHJFJpNx8uRJ3N3d8fHx4fnz59SrVy8niWzWrJlC5k1PT8fExIR79+4RHx//2RaF+WmD9+zZM6ysrDh79iwuLi7Y29vL61eQGxcXF4YPH07Hjh3x9fUl4mZynhoW6GhroautxcK+TXH8jzJg/yUrK4uDBw/i6uqKv78/79+/x8TEBGdnZ2xtbTWmKsP/WrNmDdOnTycmJuaz3b2EzxMJpQZISkqiUaNGdOvWDQ8PD1WHk2eSJLFixQpmzZrFiBEj2LRpk9y/CYaFhdG7d2/Wrl1bKLctzia+wvrPKIXP82tXPRx7fH29RXm5ePEiFhYWvH//nsDAQPT1VV9D8GuMHj2aHTt2ULRoUb777jsCAwPVvtXkh/NwHh4eeHp68vDhQ2rUqIGjoyOOjo60bt1aofVvJUli5MiRuLi4cOzYMYX/b/3+/XuGDh2Ku7s7S5cuZdasWWpR3/efjh079velpg6OZDXN/8LCtJ4NGGdS/4vPO3/+PC4uLuzdu5cnT57QuHFjBg0axIABAzTmi91/SUxMpEmTJgwdOlScncwnkVBqgKFDh+Lv759zNkXT7dq1i+HDh9OnTx/c3d0pWVI+deCePHnCDz/8QNu2bdWm2LuyKWuFMnR8R5pWK6vweT7l2bNnWFtbc/r0aXbu3ImTk5NK4vhaO3bsYPjw4Wzfvh0DAwMsLS159eoVXl5edOvWTdXhfUSSJC5dupTT+vD27dtUqlQJe3t7nJycMDQ0VNoZ1s2bNzNmzBj++uuvr6rrKQ+SJLFo0SIWLFjA4MGD2bJli8KPdOTW+pB41p58Krfx/qthwaNHj3Bzc8PV1ZWLFy9SsWJFnJycGDRokMK/TCiTpaUl8fHxXLlypUDW/VQmkVCqucOHD9OtWze2bt3KiBEjVB2O3ISFhWFnZ0fLli0JDg6mfPny+RpPJpNhZmbG+fPnuXDhApUqVZJTpJolJT2LZko4Q3lpgelXbycqwvv37xk5ciSurq7MnTuXBQsWqOVlndjYWIyNjXMuk8DfvYodHR05fPgwa9asYfz48Sr/cP7QS9rDw4PLly/z7bffYmtri6OjI126dFH6mbLjx4/TtWtXRo8erZJ2hHv37mXIkCHo6+vj5+dHhQoVlB7Dpyi6wPuHMl0uLi4cOnSIIkWKYGlpibOzM6amph91LyoIAgICsLa2xsfHB1tbW1WHo/FEQqnG3r9/zw8//ECVKlU4evSoWn5g5kdsbCx9+vShYsWKhIeH5+uG5apVq5g+fToRERH07NlTjlFqhuzsbCIjI9m7dy8RRY3QKau4s4219UoSOc1EYeN/LUmSWLlyJbNmzcLW1pbdu3fLbbVbHp49e0abNm2oXr06kZGRH610ZWVlMWPGDNasWcPQoUPZtGmT0lfCEhMT8fLywt3dnTNnzlCqVKmc1oc9e/bMufihbA8ePKBNmzY0atSIgwcPqiyJiYqKwsrKijJlyhAaGkrDhg1VEsc/KaphQcNvoeIlT3x9fUlJSaFTp044OztjZ2fHt99+K7e51ElycjKNGzemVatWBAUFqfxLXUEgEko1NnfuXFasWMH58+dp3LixqsNRiOvXr2NqakpGRgbh4eF5qst3+vRpDA0NmThxIr/99psColRPkiQRFxfH3r178fLy4vHjx9StW5f6jrO5QVXk+JmTQ0dbC2f92izoq/oWaR8EBAQwYMAAGjduTGBgINWrV1d1SGRlZdGjRw8uX77M6dOn/7NblIuLCyNHjqRVq1b4+fl99tKJPDx58gQfHx88PDw4efIkxYoVw9zcHEdHR3r37q3yhPz9+/cYGxvz9OlT4uPjVb7TcOfOHczNzXn06BF+fn6YmKjui5SiGxYU2b+cwda9GDBggMZdGsuLyZMns3XrVi5fvlyo6hQrkkgo1dSlS5do1aoVc+bMYcGCBaoOR6GePHmCmZkZd+7cISgoiE6dOn31zyYnJ9O6dWvKli1LVFSUylZVlOny5cvs3bsXDw8Pbt26RZUqVXBwcMDJyYn27dtz89k7pXXKURfnzp3DwsKC7OxsgoKCVH5T80MHoUOHDtG5c+fPPjc2NhZra2sA/P395V625uXLl/j5+eHh4cGRI0fQ1tbG1NQUR0dH+vbtqzbnxiRJyqm5eOLECdq0aaPqkIC/u6f069ePw4cPs3nzZoYNG6aSOBYEJeAac0+uq5MfaGuBs0FtFvZVzG19dXPmzBnatWvHihUrmDZtmqrDKTBEQqmGZDIZxsbGJCUlcf78ebU7FK4Ib9++xdrampMnT+Lm5vbV51k+1Pg7e/Ys9et/+baiprp79y4eHh64u7tz4cIFypYti52dHU5OTp/shausXt7q5MmTJ1hZWXH+/Hl2795Nv379VBKHh4cHTk5OrFu3jokTJ37Vzzx+/BgbGxvOnj3Ltm3bcHZ2zlcMycnJBAYG4uHhQUREBDKZDBMTk5zWh//bDlId/P7770ycOBFXV1cGDhyo6nA+kpWVxfjx49m8eTPTp0/n119/VfoRJGU0LFCHoyyKlp2djb6+PpmZmcTHxxe4c6GqJKp3qqGtW7cSFRX1r3NXBVmZMmXYt28fP/74I/b29mzcuJGffvrpsz/j7u7O7t272bVrV4FMJp89e5Zzxi0qKooSJUrQt29fFi1aRK9evT772lhm3ZzuayPlllBKkoT2/42rrj6cNR42bBgODg5cvXqVuXPnKvVs1MWLFxk2bBj9+/dnwoQJX/1zVatW5ejRo4wZM4ZBgwZx/vx5fv3111xdhklLSyM0NBQPDw9CQ0N5//49RkZGrFmzBnt7e7WuEHHkyBGmTJnClClT1C6ZBNDV1WXTpk00bNiQKVOmcOPGDfbs2aO0pgnv0rNIVGAyCZCYlEpKepZKL9spwx9//MGZM2eIiooSyaSciRVKNfPo0SMaN25Mv3792LZtm6rDUTqZTMbUqVNZt24dc+bMYfHixZ9MCG7fvk2rVq3o06cPbm5uBeZA9Zs3b/D398fd3Z1Dhw6hpaWFqakpTk5OWFpa5qpDjEdcIjP9LsottlfhG1k+woIxY8ao9b+3JEksW7aMX375BUdHR/766y9KlCih8HlfvXpFu3btKF26NFFRUXk6jyhJEhs2bGDKlCk5dWc/1/s6IyOD/fv34+HhQWBgIO/evaN169Y5rQ814WzY3bt3adu2LS1btiQ8PFztu5SEhITg6OhIw4YNCQ4Oplq1agqfszCUA1OGBw8e0KRJEwYOHMimTZtUHU6BIxJKNWNnZ8eJEye4cuXKZz9ICrIPrfamT5/O0KFD2bJly0cfMpmZmRgbG/Ps2TPOnj1L2bKa/Qb4YWXJ3d2d0NBQMjIy6NSpE05OTtjZ2eVre3LjkRus2n893zFO6V6fW0F/8PvvvzNy5Eg2bNig9udVfXx8GDRoEM2aNSMwMFChF15kMhkWFhZERUVx+vTpfBctP3ToEP369aN8+fIEBgbSpEmTnMeys7M5evQoHh4e+Pr68urVKxo3boyTkxMODg40aNAgv7+O0qSmptKhQwdev35NfHy8Wm7Ff8r58+cxNzdHkiSCg4MV3pFLWQ0L/McY0apWwf3csbW1JSoqiitXrhTY2+uqpN5fBQuZoKAgfH19v7gqUdBpaWkxbdo0qlSpwpAhQ3j69Cmenp4520sLFiwgPj6eEydOaGwy+aGFmbu7O/7+/iQnJ9OmTRuWLl2Kg4PDf94Kzq1xJvWpULpYvlq0Lerb9O/Cx93W06JFC8aMGcPly5fx9fVV+S3cz7Gzs6Nu3bpYWlrSrl27XH/w56aV36JFiwgLC2Pfvn1y6YDTrVs34uLisLS0RF9fH1dXVypWrIiHhwfe3t48ffqU7777jjFjxuDo6EizZs3UetX4UyRJYvjw4Vy/fp2oqCiNSSYBWrRoQWxsLH379qVjx464u7vTt29fhc1XVFc55zWVNY8qBAcH51xOE8mkYogVSjWRnJxMkyZNaN68eaHt8vIp+/fvx8bGhmbNmhESEsLFixfp1q0bS5YsYfbs2aoOL1dkMhnR0dHs3bsXb29vnj9/TsOGDXFycsLJyUmhK0v3X6Yy2/8ix2++QEdb67OJpbYWyCQwrleBZdbNqVn+463b6OhorK2tKVq0KIGBgWrfL/3Ro0dYWlpy+fJlXF1dsbGx+c/n3niajFtMIkeuPSPxZepHBeK1gFrlS2LSsBID9GtRv/LfN92Dg4Pp27cvS5YsYc6cOXKLW5IkTpw4wbBhw7hx4wbw91nLD60P27Vrp9HvEx9qx3p6eqrsAlV+paam4uzsjL+/P7/99htTpkxRyP8mhaVhgaKkpKTQpEkTmjRpwr59+zT670adiYRSTUycOJHt27eTkJBAnTp1VB2OWomPj6d3796UKVOG5ORkmjZtyoEDB/51s1kdSZLE+fPncXd3x8PDg8TExJx+yP3796dly5ZKfXPLSZiuPyMx6eOESZIkKhaXMG/9HQMNan22NNCDBw+wtrYmISGBnTt34uDgoPjg8yE1NZUhQ4bg5eWV82Xkn//uuUm4PzxuXK8CI1p9g4WJISYmJvj5+cnl5m9CQkJO15qbN2+ip6dH3bp1iY+Px87Ojl27dintMoiiHDhwgF69evHzzz+zfPlyVYeTLzKZjDlz5vDrr78ycuRINm7cKLfLHpIkcfbsWfbs2YNPenO0yyhuR6Ag3/KePn06GzduJCEhQS47CMKniYRSDcTGxmJgYMCqVauYMmWKqsNRSzdu3KBly5akpaURERFBjx49VB3SZ928eRN3d3fc3d25cuUKenp6Of2QO3bsqBZdjz5s6R48fJTpUyczffSPLF0476t/Pi0tjREjRuDm5sasWbNYsmSJWvxe/0WSJBYuXMjChQsZMGAA27dvp3jx4njEJebtSIAWZGdlonvejzPeG/NVz/HmzZt4enri6enJxYsXKVu2LDY2Njg6OtK1a1d0dXXx9/fH2dmZ77//nsDAQI394nn79m3atm2Lvr4+ISEhGvHF8Gvs3LmTkSNH0rlzZ7y9vfN1bOnevXvs3buXPXv2cPnyZSpVqkTTQQu4W6RWoWlYIC/nz5+nTZs2LFmyhJkzZ6o6nAJNJJQqlpmZSbt27dDR0SEmJkbtbziqyqZNmxg7dizff/89z58/JyAgQKVdKz7l0aNHeHp64u7uTlxcHKVLl8bKyor+/fvTvXt3tSxRcenSJQwNDenZsyfe3t65Tgg/XKCaMWMGvXv3xs3NTW0KZf8XT09PfvzxR1q2bInl7E1sjnqU57EkSfr7zG/PBowzyV3pqgcPHuSUhYqPj6dkyZJYWlri6OiIqanpJ8tCXbx4EUtLS96+fYuPjw9dunTJc+yq8O7dO4yMjEhLSyM2NrbAnRU/evQoNjY2VK5cmZCQEL7//vuv/tnXr1/j4+PDnj17iIyMpESJElhbWzNw4EB69OjBnaS0QtewIL+ys7Pp0KED79694+zZs2r5HlyQqO9yQiGxdu1aLl68yNatW0Uy+R8uXrzIlClTGDt2LGfPnsXAwIBevXrh5eWl6tB4+fIl27Zto2vXrtSoUYOZM2dSvXp1vLy8ePr0Ka6urpiZmanlG1lSUhKWlpZ899137N69O0+rix8uUIWGhnL8+HEMDAxyzvupKwcHB44dO8b9ojXzlUwCOdvmq/ZfxzMu8YvPf/bsGZs2baJTp07UrFmT2bNnU7NmTTw9PXn27Bl79+6lb9++/1ljtHnz5sTFxdGiRQt69OjBpk2b0JQ1gQ+dcO7cuUNAQECBSyYBunTpwqlTp3KKZ5848flSPxkZGQQFBeXUCR05ciRFihRh9+7dPH36FDc3N8zMzNDV1aV+5W8wrlcBHW35HpHR0dbCuF6FApdMAmzZsoWYmBi2bNmilu/BBY1YoVSh27dv06xZM8aMGcPq1atVHY5aSktLy7l8EBsbS4kSJcjIyGDo0KHs3buXdevW5aqAtDykpKQQFBSEu7s74eHhZGdn07VrV5ycnLCxsdGIG4SZmZmYmppy8eJF4uLi5LJ9eu3aNSwtLXn69CkeHh6YmprmP1AFuf8ylW5rjpKRJQM5nWEtpqvNwcmd/3WJ6dWrV/j7++Ph4ZFTW7RHjx44OjpiZWWVp0oFWVlZTJs2jfXr1zNixAg2btyo9mWcli9fzuzZs/Hz88tpNVlQvXz5EhsbG6Kjo9mxY8dHxdolSeLUqVPs2bMHT09PkpKSaNGiBQMHDsTJyemzvejvv0yl+9pI0rNkcov1v163mu7x48c0atQIBwcHtm7dqupwCgWRUKqIJEn06tWLq1evkpCQkKuC1YXJTz/9xM6dO4mPj6dp0/9/vkcmkzFjxv9j7z4Dorqeh49/QWKN0aiJmlhiYo29UEQRURGUIrBUBTVq7D12Y4ktdo091ihIc5eOCqKICkoRe+8Qu2BBQNre50X+8sRfLJRtwP28DHjPRGF39pwzM9NZuXIlM2bMYMmSJUotbsnOziYsLAwvLy8CAwPJyMjAwMCA/v37a/wUkvd5O0bu8OHDhZqd/ikvX76kf//+HDx4kOXLlyut6rW4lD2a8vXr1wQFBeHt7c3BgwfJzc3F2NgYZ2dnJBIJtWrVUsiau3btYuTIkejq6iKTyahdu7ZCnqto+/fvx9LSkjlz5vDbb7+pOxyVyM7OZsSIEfz111/MmTMHV1fX/HuRt27d4ttvv2XAgAG4urrSunXBJ1ApemDBMrvW/7QFK2WcnJw4evQoV65coUaNGuoOp0wQE0o12bt3L66uroSGhtK3b191h6ORAgICsLW1ZfPmzYwcOfK937N69Wp++eUXBg4cyPbt2xV6rJGXl8exY8fw8vJCKpXy/PlzWrVqRf/+/XF2dqZRo0YKW0uVtm3bxvDhw9myZQsjRoxQ+PPz8vKYPXs2y5Ytw83Nja1bt1KxYkWFr1NUNx6nKfUuWpvkQCL8PMjMzMTAwABnZ2ccHByUNlHl1KlT2NraoqOjQ0BAAB07dlTKOkV1/fp19PT06NatGwEBARpduKVoT58+ZdiwYQQFBQFQtWpV7O3tcXV1xdjYuMgFSeuP3GDVoev5d3iLamrvZowxaVzkP6+pDhw4QN++ffHw8GDAgAHqDqfMEBNKNUhJSaF58+b5o9VE//X333/Ttm1bunXrhp+f30dfNL28vBg0aBA9e/Zk3759xdrtFQSBhISE/DY/Dx8+5LvvvqN///64uLjQqlWrIj9bExw/fpyePXvy888/s3HjRqWu5enpydChQ2ndujX+/v4fPcpTpflBl3CPvafQ3cm3BHkeFZPjGNK2Ko6Ojir70HH//n1sbW25cOECO3bsoH///ipZ91NevXqFgYEBgiAQGxur8QVbipCZmUlISAju7u4cOHAAQRBo27YtFy5coF27dgQHBxd7J3n9+vXM2h5CHctxyNEu3sCCUiYjI4OWLVvSuHFjwsPDNfKEpLQSE0o1GDJkCP7+/ly5cqXEHZWqQl5eHj179uTmzZucO3euQBM0IiIisLW1pUWLFoSGhvLVV18Vas0rV67kt/m5efMmtWvXxsnJCRcXF/T19UvFi9K9e/fQ1dWlZcuWhIeHq+SS+unTp7GxsSEvLw8/Pz8MDAyUvuanGK+I5F5qhtKer65+fm/evGH48OG4u7szbdo0lixZotaWPHK5HDs7OyIjI4mLi6NZs2Zqi0XZ5HI5x44dw8PDg3379vHq1Sv09PRwdXXF2dmZr776ivj4+PyCq5CQkCJ/OD137hx6enqMGDGCqfOXFql/6vsGFpQWM2fOZM2aNVy8eJHGjUvf7qsmExNKFTty5Ag9e/Zk69at/Pzzz+oORyMtXryYOXPmcOTIkUK1RTlz5gx9+vShatWqhIWFfbKBbVJSEt7e3nh6enLu3DmqVauGRCLBxcWF7t27l6qq+/T0dLp06cLLly+Jj49X2B2+gnj06BESiYSEhAS2bt3KoEGDVLb2/3qdlUvrUjxxRBAE1q5dy5QpUzAzM8PT01NtRWJve34GBwdjYWGhlhiU7dKlS3h4eLB3716Sk5Np1KgRrq6uDBgw4L0JdHJyMlZWVty+fRtfX1/Mzc0LtV5GRgYdO3akfPnyxMbG5l8l+djAAi2gQc3KmDT9+pMDC0q6ixcv0r59e+bNm8evv/6q7nDKHDGhVKE3b97Qpk0b6tSpw9GjR8vUXSIo2GzkkydPYmRkxMyZM1m4cGGh17h9+zbm5ua8evWK/fv306FDh3e+/vTpU/bt24eXlxcnTpygYsWKWFtb4+LiQp8+fT7YrqUkk8vlODo6cvDgQU6ePFmoAgBFycrKYsyYMezYsYOJEyeyYsUKtSTslx68xGL9x1u5KELouK60/EZ9c+bDw8NxcnLi66+/JjAwkObNm6t0/cDAQGxsbBQ+jlITPHz4EC8vLzw8PDhz5gxffvklTk5OuLq6Ymho+MnTjLS0NFxcXDhw4ADr1q1jzJgxBV57xIgRuLu7c/r0aVq0aPHe7ynMDPrSRC6XY2RkRGpqKmfPni2Vr+WarvT/lGmQxYsXc/fuXQIDA8tMMlmY2chfV5TTv39/9PT0mDdvXpHW+/7774mOjsbCwgJjY2P8/f3R09MjICAALy8vDh06hJaWFr1798bd3Z1+/fpRtWrp/cQOsGjRImQyGf7+/mpJJgEqVKjAtm3baNeuHRMnTswfL6jq6stsBbZb0YR1PqR37975R6z6+vp4enqqbJfw8uXLuLq6IpFImDVrlkrWVLbXr18TEBCAu7s7ERER6OjoYGlpydy5cwv9QbRq1aoEBgYyZcoUxo4dy7Vr11i9evUnP2D5+fmxdetW/vzzzw8mkwBVKuio9cOMumzfvp2YmBiioqLEZFJNxB1KFXm7FT979mzmz5+v7nCUriizkatlPCBJtowzJyKK3Rfx2bNn9O7dm7Nnz6Kjo0NOTg7dunXDxcUFe3t7lR75qpO/vz92dnYsXLhQY46AIiMjcXBwoHr16gQGBr7TDkrZysoO5VuvXr3Czc2N4OBglixZwvTp05V6H/jFixfo6elRoUIFTp48WaLboeXm5nL48GHc3d3x9/cnIyMDIyMjXF1dcXBwUEhj9i1btjB27FjMzMzw9vb+4Ifb5ORk2rZti4mJCVKptFTc6Vakx48f07x5c2xtbdm5c6e6wymzxIRSBd5uxaekpHDu3LlS/+mpqLORhbxcPtMpxyLbNjgXofowNzeXI0eO4Onpib+/P69evaJGjRqkpqYyZ84cFixYUOhnlmTnz5/H0NCQvn374uPjo1FvQnfu3KFfv37cuXOHvXv3Ym1trZJ107NyaVWK71C+j1wuZ/78+SxcuBBnZ2d27NhB5cqKL8jIy8vDysqKkydPkpCQUKixg5pCEATOnDmDh4cHXl5ePHr0iGbNmuHm5saAAQOUMj89PDwcBwcHGjZsSEhICA0avPva93Zwwu3btzl37pzYU/E9BgwYQHh4OFevXi1QEadIOcrGuauabd26lZiYGLZu3Vrqk8kNkTeY4XeBrFx5oduyaJXTIVfQYobfBTZEFmx8nyAIxMTEMG7cOL799lvMzMw4efIkkyZN4urVqzx79iz/PuaUKVOQy9V7FKkqT58+xdramiZNmrBr1y6NSiYBGjVqRExMDKamptjY2LB48WKljxDMzs7m2JFDVMx9rdR1GtSsrDHJJIC2tjYLFizA19eXoKAgunbtSlLSp8dEFtbcuXMJCwvD29u7xCWTSUlJ/P7777Rq1YqOHTuyd+9enJyciI+P58qVK8yePVspyST8cz3h5MmTpKWloaenR1xc3DtfX7JkCSdOnGDv3r1iMvkehw4dwtPTk5UrV4rJpJqJO5RK9uDBA1q0aIGjoyPbtm1TdzhKpaoJDoIgcOHChfw2P/fu3ePbb7/F2dmZ/v370759+/8kUOvXr2fChAm4uLiwa9cujR9TVxw5OTmYmppy+fJlEhIS/rPjoUnkcjkLFy5k/vz5ODg4sGvXLqpUqaKw52dmZhIeHo5MJiMoKIiXL1/SSDINoYkRAopPsstpa+Gm35D51qo7xi+Mc+fO0a9fPzIyMpDJZBgZGSnkufv27cPR0ZHly5czdepUhTxT2V68eIFMJsPd3Z2oqCgqVaqEra0trq6umJqaqrxo7MmTJ9jY2HDmzBn27NmDg4MDMTExdOvWjVmzZpW5E5aCyMzMpHXr1tSvX58jR45o3AfnskZMKJXM3t6eEydOcOXKFYXcudFUqpgxe/v2bby8vPD09OTy5cvUqFEDBwcHXFxcMDIy+mSh0759+/InVMhkslJbjDN69Gi2b9/OkSNH6Nq1q7rDKRA/Pz8GDhxIkyZNCAgIoGHDhkV+Vnp6OgcOHEAqlRIaGsrr16/58ccfsbe3RyKRUPHr7+j9x3EFRv+uiEndNLo1y9OnT3F0dOTEiRNs2LCh2NOSzp8/T+fOnbG2tsbT01Oj39Szs7M5ePAgHh4eBAUFkZ2dTc+ePXFzc8PW1lbtrwlv3rxhyJAheHl58euvv+Lu7s63335LVFRUqWpjpihz5sxh+fLlnD9/vlT3OS0pxIRSiYKCgujXrx9eXl44OzurOxylUtZs5I7ffk6XnDN4enoSFxdHlSpVsLGxoX///piamha6OXdkZCQ2NjY0btyY/fv3a+zs46LavHlzfkI5dOhQdYdTKBcuXKBfv36kpaUhk8kKNWP81atXhISEIJPJOHDgAJmZmbRr1w6JRIJEIvlPVayyZ3lrupycHCZPnsyGDRsYNWoUa9euLdKufWpqKp06daJatWpER0cr5W5mcQmCwKlTp/Dw8MDHx4eUlBTatm2Lq6srLi4uGjPB6S1BEPJ7eH722WdcuHBBTJbe48qVK7Rt25ZZs2aViULXkkBMKJUkLS2NH3/8kdatWxMaGqrRn9qLS9mzkZ/+NQ5T/Tb0798fS0vLYr9pnTt3jj59+lCpUiXCwsJKzTSFo0ePYmpqyqhRo1i3bp26wymSZ8+e4ejoyPHjx1m/fv0HZ7gDPH/+nKCgIKRSKeHh4WRnZ6Onp5efRH7sHp+id9QFQaAccsInGNG4bsk5idi2bRtjxoyhc+fO7Nu3j6+//rrAfzY3N5e+ffuSmJhIQkKC0u4YFtXNmzfx8PDAw8ODW7du8e233zJgwABcXV3V1j6roHbu3MnQoUMpV64choaG+Pn5lZnOFAUhl8vp3r07jx494vz58/kN3kXqJSaUSjJhwgS2b9/OpUuXNO6FVtGUORtZCwGnDnVZ6tBRoc+9e/cu5ubmpKamsn//fjp16qTQ56vanTt30NXVpV27dhw8eLBEH4/9e/dsxIgRrFu3Ln/37OnTpwQEBCCTyTh8+DB5eXkYGhpib2+PnZ1doe6LKvrO78tDm/iBx0il0hL1Ox8dHY2dnR0VK1YkICCA9u3bF+jPTZ06lTVr1hAeHk6PHj2UHGXBPHv2DB8fHzw8PDh16hRVq1bF3t4+/6qLOkdRFtS1a9fo0KEDzs7ODB06FBsbG7744gtCQ0PFncr/8zbhPnz4sMb87InEhFIp4uLiMDAwYMWKFfzyyy/qDkfpSups5GfPnmFpacnFixeRyWSYmZkpfA1VeP36NYaGhmRkZBAbG1tqKh23b9/O6NGjad++Pba2toSHhxMVFQWAsbExEokEW1tbvvnmmyKvsdg/gW1xj0EQoBinCFN7N8OwehoSiYSXL1/i6elZon6ekpOTsbW15fLly+zatQsnJ6ePfr+npycDBgxg7dq1DBs5Rq2TWTIzMwkJCcHd3Z0DBw4gCALm5ua4ublhZWWlkcfwH5KVlUXnzp1JT08nMTGRKlWqcOfOHSwtLXnw4AF+fn6YmKh+Trwmefr0Kc2bN8fCwoI9e/aoOxzRv4gJpYLl5OSgq6uLtrY2cXFxJXqnqCBK+mzk9PR0nJycCAsLY+fOnbi5uSl8DWWSy+XY29sTERHByZMnVdokXJmSkpLw8/Nj586dXLjwzy5i586d+emnn+jXr1+hjmY/JDMzEyMjI55+0YSKhm7kChRql72cthY62lossG6Z340gNTUVV1dXDh48yIIFC5g1a1aJmYqVmZnJsGHD8PT0ZNasWSxcuPC9sScmJtLNyom2dmMo16AtyZ+YgNWktuILXeRyOceOHcPDw4N9+/bx6tUr9PT0cHNzw8nJia+++krha6rCL7/8wvr16zl16tQ7Y2NfvnyJg4MDkZGRbNmypcTdj1akQYMGERISwtWrV0vsv3NpVbqzHTVYs2YNFy5cKBPJJMC9lHSlJpMAAnA3JV0pk0eqVKlCQEAAI0aMYODAgTx69IgpU6aUmDuvv/32GwEBASqfOKMMt27dQiaTIZPJiIuLo3z58vTu3ZvBgweze/duzp49S7Vq1RSSTAqCwMiRI7l06RLR0Vv56rvmhZ7sZPh9TZbYts7vQgBQo0YNQkJCWLBgAXPnziUuLo49e/ZQvXr1YsesbJUqVcLDw4N27doxffp0zp8/j4eHB9Wq/f/fu7M3/8Z23WFqDVzLIy3Ie8/JhADcS83APfYef528i1HjWv/5eyqqy5cv4+7uzt69e0lOTqZRo0ZMmDABV1dXmjZtWuznq9PBgwdZvXo1q1ateieZBKhWrRqhoaGMHz+eYcOGce3aNZYuXVpiPqwoSmRkJHv27GH79u1iMqmBxB1KBbp9+zatWrVi5MiRrF69Wt3hqMSZpOfYbo5R+jr+owxp30B5xQ6CIDB37lwWLVrExIkTWbVqlca/WL/t/bdkyRJmzpyp7nCK5OrVq8hkMqRSKWfPnqVSpUr06dMHiUSCpaUlX3zxBQAZGRkMGzYMLy8vZs+ezYIFC4r177Nu3TomTJiAh4cHAwYMyP/v+bPnrz8hKeU9O281K2PS9GtcDRp8sjXQ/v37GTBgADVr1sTPz482bdoUOV5VO3DgAC4uLtStW5fAwECaNm3K3lN3+NX/HHK00dIu+F3Etzu5v1m3LNIErIcPH+Lt7Y27uztnzpzhyy+/xMnJCVdXVwwNDUvMh7+Pefz4MW3atKF9+/bs37//gz/bgiDwxx9/MHnyZGxsbHB3d1do31ZNlpWVRZs2bahduzZHjx7V+NfnskhMKBXk7b2dq1evcunSpRI9w7YwStts5E2bNjF27FgcHR3ZvXu3xk42Onv2LF26dCkRvf/+TRAELl68iFQqRSaT5f+uWFhYYG9vT58+fT74BikIAitWrGDGjBlYWlri4eGRn3AWRmRkJKampkyYMIFVq1Z98PvSs3KLfTfw9u3b2NnZcf36dbZt2/ZO8qrprl+/jrW1NY8ePWLgMk+C7goIglCsn7UpvZsy1qTJJ7/v9evXBAQE4O7uTkREBDo6OlhaWuLm5kafPn009veyKORyORYWFiQmJnL+/PkCtTILDg7GxcWFZs2aERwcXKx7xCXFb7/9xuLFizl79iw//vijusMRvYeYUCrI3r17cXV1JTQ0lL59+6o7HJVJz8ql5fwwpa6h6tnIfn5+9O/fny5duuDv71+kpEWZnjx5gq6uLl999RXHjh3T+KIDQRBITEzM34m8ceMG1apVw9raGolEQu/evalUqVKBn7d//35cXFyoV68egYGBhWr7dO/ePTp16kTbtm1VVg2fkZHBqFGj2LNnD2PHjmXVqlUlZlLTy5cv6TN2EQ/qdVfYMz80ASs3N5fDhw/j4eGBv78/6enpGBkZ4erqioODQ6kdDLFmzRomT57MgQMHMDc3L/CfO3v2LFZWVgiCQHBwcIGr80uia9eu0aZNG6ZOncqiRYvUHY7oA8SEUgFSUlJo3rw5PXr0wMfHR93hqMTdu3fx8fHBx8eHx3qj+OxL5X1CVlaV98ccP34ca2trGjZsyIEDB6hbt65K1/+Qt5M9bty4QUJCAvXq1VN3SO8ll8uJjY3NvxN59+5datSogY2NDfb29vTs2bNYSdXVq1fp168fT58+xcfHB1NT00/+mYyMDLp27crz589JSEhQaTW8IAhs2bKFCRMmoKury759+0rErlJyagY9VkWSnVe8ncl/+/cELEEQOHv2LO7u7nh5efHo0SOaNWuGm5sbAwYMKFHtl4oiMTERAwMDxo4dW6RrUg8fPsTa2porV67g6emJtbW1EqJUL0EQ6NmzJ0lJSVy4cKFQHz5FqiUmlAowZMgQ/Pz8uHr1KnXq1FF3OEpz//599u3bh7e3N7GxsVSsWBFLS0sqGLpy8qkOeUr4SVLnbOSLFy9ibm7OZ599RlhYmNov/QuCwPDhw9mzZw9Hjx6lc+fOao3nf+Xl5REdHY1UKsXPz4/79+9Tu3ZtbG1tkUgkGBsbF3qy0ce8ePECFxcXwsPDWblyJRMnTvxg0iMIAq6urgQEBBATE0Pbtm0VFkdhnDp1Cnt7e3Jzc/Hx8cHY2FgtcRSU4+ZjxN59Uag7k59STluL9t9UoeOrGDw8PLh8+TJff/01Li4uuLq60rFjxxJzhaM4Xr9+TceOHalSpQonT54s8jF+RkYGbm5u+Pv7s2LFCiZPnlyq/v727NnDoEGDCAsLo3fv3uoOR/QRYkJZTEeOHKFnz55s3bqVn3/+Wd3hKNyTJ0+QSqX4+Phw/PhxPvvsM8zNzXFycsLKyoqqVasqfVKOOmcjJyUlYW5uztOnTwkJCUFfX31j9TZs2MC4cePYuXMnP/30k9ri+Lfc3FyOHj2KTCbDz8+PJ0+e8O233+ZPq+nSpYtSm0nn5eUxc+ZMVqxYwaBBg9iyZct7p2asWrWKKVOm4OPjg6Ojo9LiKYgnT57g7OzMsWPHWL58OZMmTdLIBODy36n03XhSac9P2TMR6+56uLq6YmpqWia6Yvzb0KFD8fb2JjExsdgNy+VyObNmzWLZsmUMHz6cDRs2KPTDm7q8Pf0zNTXF09NT3eGIPkFMKIvhzZs3+VVnUVFRpabqLDU1FT8/P3x8fDhy5AhaWlqYmpri5OSEjY3Ne1uglObZyKmpqVhZWXH27Fn27dunljuyhw8fxszMjPHjx6u9g0B2djaHDx9GKpUSGBhISkoK3333HRKJBHt7e/T09FT+u7B3716GDRtG27Zt8ff3f+eKwqFDhzA3N2fq1KksXbpUpXF9SG5uLrNnz2b58uU4OjqyY8cOjSvkM568gbufNVDo7uRb2gg4d/qWJZLSe+/vY3x9fXFycmLHjh0MGTJEYc/dtWsXw4cPx9jYGKlUWiLaVX3M0KFD8fPz48qVK6X69K+0EBPKYpgzZw7Lli3j3LlztGjRQt3hFMvLly8JDAzEx8eH8PBw8vLyMDExwcnJCTs7u0/OkVX0bGQEgfI62hye3F0h/euKKzMzE2dnZ0JDQ9m+fTuDBw9W2dq3bt1CT0+PTp06ERoaqpadnMzMTMLDw5FKpQQHB/Py5UuaNGmCvb09EomEDh06qH2XLSEhARsbGwRBwN/fHz09PW7fvo2uri66urqEhoZq3Og9mUzG4MGDqV+/Pv7+/hozWm/r1q38lqhV6u5Ga4K7d+/Srl07zMzM8Pb2VvjvzdGjR7Gzs6N27dqEhIR8dKa9Jjt27BjGxsZs2bKFESNGqDscUQGICWURXbx4kfbt2zN79mzmz5+v7nCKJD09nZCQELy9vTlw4ABZWVl06dIFZ2dn7O3tC/2JUNGzkXNjdhO8dqbGVC/m5uYyZswYtm7dypIlS5gxY4bSk6hXr17RuXNncnJyiI2NVWmla3p6Ovv370cmkxESEkJ6ejotW7bM34ls1aqV2pPI//Xw4UMkEgmJiYmsX7+e9evXk5GRQXx8vMZWCV+9ehU7Ozv+/vtv/vrrL+zs7NQaT0xMDCam5tQd51mscZSfouruDZogNzcXY2Nj7t+/z9mzZ5W2g3j9+nUsLS1JTU0lICCArl27KmUdZcnOzqZdu3ZUr16dEydOlJrTv9Ku7PwmK5BcLmfEiBH88MMPJa6h9Js3bzhw4AA+Pj4EBweTkZGBrq4uS5YswcHBgfr16xf52c66DXj2OouV4deLHefIzt8gi7iDkZER3t7eWFpaFvuZxaWjo8OWLVv45ptvmDVrFg8ePGDt2rVK2/WSy+W4urry999/qyyZfPXqFSEhIUilUg4ePEhmZibt27dn5syZSCQSmjdvrvQYiqNu3bpERkYyatQohg8fzmeffUZcXJzGJpMAzZs3JzY2lqFDhyKRSJg2bRqLFy9Wy070/fv3kUgktDMy5bGSPywocwKWplq4cCGnTp3i2LFjSj2Obtq0KSdPnkQikdCzZ0927NiBq6ur0tZTtBUrVnDjxg0SExPFZLIEERPKIti6dSsxMTEcPXq0RDTYzc7O5tChQ/j4+BAQEEBaWhpt27bl119/xcnJie+//15ha401aUKtzyswL+gSuXKhWLORx/eKwtXVlX79+rFmzRrGjx+vsDiLSktLi3nz5lG3bl1GjRrFo0ePcHd3f28hyPsUpln2nDlzCAkJISQkRKmJXGpqKkFBQchkMsLDw8nOzkZPT4/ffvsNiUSi0J8PVahQoUJ+RX5eXh7Tp0/H29tbo5PKqlWr4uPjg76+PtOnTychIQEvLy+FjJksqDdv3mBnZ0e5cuVYsnQ5Q32uKn3NbEVdkSkBjh8/zqJFi5g3bx5dunRR+no1a9YkPDycESNG4ObmxvXr1/ntt9807lThf928eZOFCxfyyy+/0Lp1a3WHIyoE8ci7kB48eECLFi1wdHRk27Zt6g7ng3Jzc4mMjMTHxwc/Pz+eP39O8+bNcXZ2xsnJSek7TcmpGYWejfy+mb9yuZzp06ezcuVKxo0bx5o1azTmHlxgYCDOzs7o6+sTEBDwwR2H/HF+156QlPqecX41KmPS7GsG6DegSe1/qtl9fHxwdnZm+fLlTJ06VeGxP3nyhICAAGQyGUeOHCEvL48uXbogkUiws7OjQYPCj8jTFAcPHqRv377Mnj2b7t274+DgQM2aNQkKCioRd52PHj2Kk5MT5cuXRyqVqqSzgCAIDBs2jL1793L8+HEqf9u0VE3AUrfnz5/Ttm1bvvvuOyIjI1X6GiYIAsuWLWPmzJk4OTmxa9cuje3lKAgCZmZm3Lhxg0uXLmn80AbRu8SEspDs7e05fvw4V69e1bgdD7lczokTJ/D29kYqlfL06VN++OEHnJyccHJyonXr1ir/dKqo2ch//vknY8aMoU+fPnh5eWlMRWx0dDRWVlbUq1ePAwcO8O233+Z/rahJtUsTsDc3QSKRsGfPHoX9mz148AB/f3+kUinHjv3T5snY2Bh7e3tsbW01pnl7cdy4cQM9PT26dOlCUFAQ2tra3Lp1i379+pGUlISnp6dGXJ/4lPv37+Pg4EBCQgLr1q1jxIgRSv3d3bhxI2PHjmX37t0MHDiQ9KxcWs0PQ5lvDmXlDqUgCDg4OHD48GHOnTuntg9rMpkMNzc32rZtS0BAQIFGPKqap6cnAwYMYP/+/fTp00fd4YgKSUwoCyEoKIh+/frh5eWFs7OzusMB/nmxio2NxcfHB19fXx48eED9+vXzk0hNahJc3NnIYWFhODg48MMPPxAcHKwxU2IuX76Mubk5WlpaHDx4kBYtWuAdn1S0Y38tyM3J5osbB4nzWlvsnYSkpKT8aTUxMTGUK1eOnj17IpFIsLGx4auvvirW8zVJWloaBgYG5ObmEhsb+86OcVpaGm5ubgQFBbFo0SJmzpypMb8XH5Kdnc3kyZPZuHEjgwYNYvPmzUrZWYqKiqJXr16MGTOGtWvX5v934xWR3EvNUPh6b5WVKu+tW7cyYsQIpFIpEolErbHEx8djbW1NhQoVCAkJoVWrVmqN59/enqIZGxvj6+ur7nBERSAmlAWUlpbGjz/+SOvWrQkNDVXrm5EgCJw5cyZ/9OG9e/eoU6cODg4OODs7Y2BgUGovMl+8eBELCwtyc3MJCQnRmArwv//+mz59+vDgwQOGrt6H79XMIj9LEP4Zczeld1PGmjQp9J+/detW/tzs+Ph4ypcvj5mZGRKJBGtra43bWVcEuVyOvb09ERERxMbGvvdoWy6X89tvv7FgwQKcnJzYuXNniThSc3d3Z8SIETRr1gyZTKbQO61JSUl06tSJVq1aERYW9k4z7PlBl3CPvafQ3rJvqXMClipdvnyZTp064ebmxp9//qnucABITk7GysqK27dv4+vrW6j54co0YsQIvL29uXLlSokYSyr6LzGhLKAJEyawfft2Ll26pLb5spcuXcLb2xsfHx9u3LhBrVq1kEgkODs7Y2RkpDF3C5Xt0aNHWFlZceXKFY2pAId/PmH3HD6H1MaKO6pZZtcaJ91PH5FduXIlfyfy7NmzVKpUiT59+mBvb4+FhQVffPGFwmLSRIsWLWLOnDkEBgZ+cp6xTCZj4MCBNGvWjICAgBJxX/TcuXPY2dnx/Plz9u7dq5DjwMzMTLp27UpKSgrx8fH/2a0uzROwVOHNmzfo6+uTk5NDQkKCRn14SUtLw8XFhQMHDrBu3TrGjBmj1nhiYmLo0qULGzZsUHssoqITE8oCiIuLw8DAgBUrVvDLL7+odO3r16/n70ReunSJ6tWrY2tri7OzMyYmJqVivFZRZGRk4OrqSmBgoMZUgOc3d8/JU1j/vgo62kRMMv5Pc3dBELhw4QJSqRSZTMbly5f5/PPPsbS0RCKR0KdPH6pUqaKQGDRdSEgI1tbWzJs3j3nz5hXoz5w/f55+/fqRnp6OTCbDyMhIyVEW3/Pnzxk4cCChoaHMmzePOXPmFPkkQhAEBg4ciEwmIzo6+oM7/aV5ApayTZgwgS1bthAXF6e22fEfk5eXx5QpU1i7dm3+BC51bErk5OTQoUMHKleunH8tR1QyiQnlJ+Tk5KCrq4u2tjZxcXEq6Q139+7d/CTyzJkzfP755/Tr1w8nJyd69+5dIloVqYKmVYAr+81XEAROnz6df5x98+ZNqlWrhrW1Nfb29vTu3bvA7YtKi2vXrqGnp4eJiQl+fn6FSrCePXuGg4MD0dHRbNiwgeHDhysxUsWQy+UsWbKEuXPn0qdPHzw8PIp0hWHNmjVMnjwZT09PXFxcPvh9Cp+AxYc/JJUmoaGhWFpa8scff2jEh92P2bJlC2PHjs2f3FO1qmp3jZctW8bs2bNJSEigXbt2Kl1bpFhlPqH8VKHI8uXLmTlzJnFxcXTs2FFpcdy/f599+/bh7e1NbGwslSpVwtLSEicnJ/r27auxbR40gSZUgCv7eNA0+xSHZO7cu3ePmjVrYmNjg729PT169KB8+fJKW1eTvXz5En19fbS1tTl16lSRjvVzcnKYNGkSGzduZPTo0axdu7ZE7PofPHiQ/v37U716dfz8/Ar1RhwREYGZmRm//PILy5cv/+T3K3oCVkGvcZRUDx8+pE2bNujr6xMcHKzxxV8A4eHhODg40LBhQ0JCQlR2DeTOnTu0bNmS0aNHs3LlSpWsKVKeMplQFrQvYLdvtbE06sjIkSNZvXq1wuN48uQJUqkUb29vTpw4wWeffUafPn1wcnLCyspKY1rjlAT/rgAPCQl5p32PKiizgEGQ55F3NRLrb7OQSCQYGxurZYqKJpHL5djY2HDs2DHi4uLyG5kX1bZt2xgzZgyGhobs27evRFS/37lzB4lEwpUrV/jzzz8ZOHBggf5Mp06d6NSpE/v37y/Qjv61a9cwHv07FfUcih3z1N7NGGPSuNjP0VRyuRwzMzMuXrzI+fPnS8TP0VuXLl3C0tKSzMxMgoKC0NPTU+p6giBgYWHBxYsX86/siEq2MpVQFqUvoPDwMmGLBtO8nmJeGFJTU/Hz88PHx4cjR46gra1Nr169cHZ2pl+/fkodx1XaXbhwAUtLS/Ly8ggJCVHp8YnSW6zUqEzU1NLfYqWg5s2bx8KFCwkODsbCwkIhzzxx4gR2dnZUrlyZwMBAjbz39r8yMzMZM2YMu3btYtSoUaxZs+aDV2LS09MxNDTk9evXxMfHU6NGjU8+/9mzZxgYGFC+fHmmbPZjWcSdYk/AKs1WrFjBtGnTCA8Px9TUVN3hFNqTJ0+wsbHhzJkzuLu7Y29vr7S19u3bh6OjI0FBQVhZWSltHZHqlJmEsqh9AbWBz3S0+c26Jc5FfDF8+fIlgYGB+Pj4EB4ejlwup3v37jg5OWFnZ0etWrWK9FzRfz18+BBra2uVVoC/zsqltdgEWmUCAgKwtbVl8eLFzJo1S6HPTkpKwsbGhmvXrrF7926lvqEqiiAIbN++nbFjx9K+fXukUul/erQKgoCzszOhoaGcPHmyQCPtsrKy6NWrF9euXSM2NpZGjRopbAJWaRQfH4+hoSGTJk0q0FUCTfXmzRuGDBmCl5cXixcvVkrP1pcvX9K8eXM6d+6Mn5+fQp8tUp8ykVBuiLzByvDrxX5OYfoCpqenExwcjI+PDwcOHCArK4uuXbvi5OSEvb09derUKXY8ovdLT0/Hzc2NwMBA1q5dy7hx45S63qUHL8UxdSpy+fJl9PX1MTMzY9++fUq5n5aRkcGQIUPw8fFhzpw5zJ8/v0T0dY2Li8Pe3p43b97g4+ODicn/39FetmwZM2bMKHBzbUEQcHNzQyqVEhkZSefOnd/5uqImYJUWaWlptG/fni+//JLo6OgSf69ZEAR+++03fvvtNwYNGsSff/5Z4GLQggyweDuV6cqVKxozoEJUfKU+oVTlhfI3b95w4MABvL29CQkJISMjAz09PZycnHBwcKB+/foKi0P0cXl5eUyfPp1Vq1YpvQL8TNJzbDfHKOXZ/+Y/ypD2DUpfU/KCevHiBXp6elSoUIGTJ08q9c6VIAgsXbqU2bNnY21tjbu7u8qrX4vi6dOnuLi4EBkZydKlS5kyZQphYWH07duXWbNmsWjRogI957fffmP+/Pn4+Pjg6Oj40e8t7gSs0mDQoEH4+flx5swZGjcuPXdEPT09+emnn9DX18ff35+aNWu+9/sKWpcwQL8Bz+9dwcDAgDVr1jBhwgSV/H+IVKNUJ5SqaHmRnZ3NoUOH8PHxISAggLS0NNq1a4eTkxOOjo4KnWohKry3LTGUWQEu7lAqX15eHlZWVpw8eZKEhAR++OEHlawbEhJC//79adCgAYGBgSpbtzjy8vKYM2cOv//+O7179yY2NpauXbsSGBhYoA9Ve/fuxdXVVSlXCkqjt/On385BL21iYmKwsbGhWrVqhISE0KxZs/yvFeUKhM7TG1S9GkJCVJjYc7KUKdUJpbL6Aho0qsHghmn4+Pjg5+fH8+fPadGiBc7Ozjg5Ob3zCydSv7cV4I0bNyY4OFjhFeDpWbm0Eu9QKtXs2bNZunQp+/fvx8zMTKVrX7lyBWtra1JSUvD19aVXr14qXb+oPD09cXNzQ0dHh2PHjqGv/+lG4sePH6dXr17079+fnTt3loiWN+p0+/Zt2rVrh5WVFR4eHqX27+vOnTtYWFjw8OFD/Pz8MDExKXJdgpCXS4XPdFhg07rIdQkizVRqE0pl9wW8v20kDatXwMnJCWdnZ1q1alVqX0xKgwsXLmBhYYFcLldKBbjSq7xrViZqStms8n5bDbps2TKmTZumlhieP3+Os7Mzhw8fZtWqVYwfP16jf9/lcjkSiYRDhw5Rt25dHj16xM6dO3Fw+HDrn5s3b2JgYEDr1q0JCwsr8fcAlS0nJwcjIyOePHnC2bNnS/140xcvXuDo6EhkZCQDlrhzNLX4V0AKU5cg0nyaf9O8iPbGJlFOWzkv+FqCnJ+X7eHGjRssXryY1q1ba/Sbiwhat25NbGwsdevWpWvXroSEhCj0+SbNvlbaz1s5bS1Mmn6tlGdrugsXLjB48GCcnJyYOnWq2uL48ssvCQ0NZdKkSUycOJGhQ4eSlZWltng+ZfHixQQEBODp6cmZM2ewsLDA0dGRKVOmkJub+5/vT01NxcLCgpo1ayKTycRksgDmz59PQkICnp6epT6ZBKhevTqhoaGYjf5NIckkwMrw6/jEJynkWSL1K7UJZeS1J0ppMg0gaGlz6TliElnC1K1bl6NHj2Jqakq/fv1Yv369wp49QL+B0n7e8uQCrgZl72goNTUVGxsbmjRpwo4dO9T++6ajo8OKFSvYs2cPnp6edO/enYcPH6o1pvcJDg5m3rx5/Pbbb1hbW/P555/j5eXFmjVrWLt2Lb169eLx48f535+dnY2dnR0pKSns37+/QP0py7rIyEh+//13FixYgIGBgbrDUZlHaTnc+KI9KPCCz9ygSyQr8XRHpDqlMqF8nZVLkpJ/QJNSMkjP+u8nfZFmq1KlClKplEmTJjF+/HjGjx9PXl5esZ/bpHZVjBrXUvguZTltLYwa1yoTrVf+LTc3F2dnZ168eIG/vz9VqlRRd0j53NzcOHbsGElJSejq6hIfH6/ukPJdvXoVV1dX+vXrx6+//pr/37W0tJg4cSKRkZFcu3aNDh06cPLkSQRB4Oeff+bkyZMEBASUiKIjdUtJScHNzQ1jY2OmT5+u7nBUapb/BXLlAv/c6laMXLnALH/FdWIRqU+pTCjvpaQrtUAC/vl8djclXcmriJShXLlyrFy5ks2bN7Np0yZsbGx4/fp1sZ+7xLY1OgpMKAVBQBuBJbafbkJd2syaNYvDhw/j6+tLo0aN1B3Of+jp6ZGQkED9+vUxMjLCw8ND3SHx8uVLbGxsqFevHnv27Hlv70wjIyMSExNp1KgRxsbGWFtbs2fPHnbt2kXXrl3VEHXJIggCQ4cOJTMzEw8PjzJVpXzjcRrHbz5T+ElMnlzg+M1n3HySptDnilSvVCaU2QpsE6QJ64iUY+TIkYSGhhIVFUW3bt24f/9+sZ5Xv0ZlfrNuqaDo/tlVehy6nr1b11FKa+fey9vbmxUrVrBy5Up69uyp7nA+qG7dukRGRuLi4oKbmxtTp05VyG53UcjlclxdXXn06BEBAQEf7Zn5Nu6ePXsSEhJCmzZtsLGxUV2wJdjmzZsJDAxk586dCu8WoemUWZdQTlsLj1PiXcqSrlQmlOV1VPO/pap1RMpjZmZGdHQ0z549Q19fn7Nnzxbrec66Dejz7durEMVLAn/p1YQJVrrMnDkTiUTCq1evivW8kuDs2bMMGTIEV1dXJk6cqO5wPqlixYrs3LmTNWvWsHr1aiwtLXnx4oXK45g/fz6hoaF4eXnRpMmnq2bj4+OJjIyka9eu3Lhxg86dO3Pr1i0VRFpyXbx4kV9++YXRo0fTr18/dYejcsqsS8iTC0Ref6KUZ4tUp1RmRN/VrKLAGx7vp/V/64hKvrcV4HXq1KFr166EhoYW+VmXL1/GY6Yr3z2JpoJOuUJ/oi+nrUUFHW2W2bVmXM+mLFy4kMDAQA4fPoyenh6XL18ucmya7tmzZ9jY2NCiRQu2bt2q9iKcgnp7PzEsLIzY2Fj09fW5evWqytb38/Nj4cKFLFmyhD59+nzy+2/fvk2/fv3Q09MjIiKC2NhYMjIy6Nixo8K7H5QWmZmZODs707hxY1auXKnucFROrEsQFUSpTCirVNChwf9NslGWBjUrl9km06VR3bp1iYqKwtTUFGtr6yJVgL98+RJbW1saNmxIyB+ziJhkjOH3/4wq+1Ri+fbrht/XJGKS8TvjPa2trYmPj0dHRwd9fX2kUmmhY9N0ubm5ODk5kZGRgb+/P5UqVVJ3SIXWq1cv4uLi8v+d9u/fr/Q1L168yMCBA3FwcChQgcjz58+xsLCgevXq+Pv7U6FCBVq3bk1CQgLGxsZYWVkxd+5ctR3da6opU6Zw69YtvLy8SuTPZnGJdQmigiiVCSWIfQFFhfe/FeATJkwo8BurXC7Hzc2Nx48f4+/vz+eff079GpVxH6rPoYndcNNvSMOalf+zc67FP03L3fQbEjGpG+5D9fPHev5b06ZNOXXqFBYWFjg4ODBt2rT39hMsqaZNm0ZUVBT79u2jQYOS2yKpcePGnDx5ku7du2NpacmyZcsKff81PSuXSw9ecibpOZcevPzgrs3z58+xsbHh+++/Z9euXZ/c0c3Ozsbe3p4nT54QGhr6zlzmatWq4e/vz5IlS1i8eDEWFhakpKQUKu7SKjAwkE2bNrFq1SpatWql7nDUQqxLEBWEOCmniCImdStzrVzKksLOAF+wYAHz588nODgYCwuLD35felYud1PSyc6VU15Hm+9qVinUTrcgCKxdu5apU6fSrVs3fHx8+Oqrrwr85zWRu7s7AwcOZN26dYwbN07d4SiEXC5n3rx5LFq0CBcXF7Zv307lyh8+NbnxOI29sUlEXntCUmrGO7tBWkCDGpUxafY1A/Qb0KR2VfLy8rCwsCA+Pp74+Hi+//77j8YjCALDhg3D3d2diIgIunXr9sHvPXToEC4uLlStWhWZTEaHDh0K+X9fety/f582bdpgZGSEv79/ibmGoWiXHrzEYv0Jpa8TOq4rLb+ppvR1RMpRahNKUN4sb8Pva+I+9NNzcUUl28GDB3F0dPzkDPCQkBCsrKxYsGABc+bMUUlsUVFRODo6Ur58eWQyGXp6eipZV9FOnz5N165dcXZ2LpWzo/ft28fgwYNp3rw5AQEB1K9f/52vJ6dmMMv/AsdvPqOcttZHX6veft2ocS2q3djP5hWLCAsLK9Bs8aVLlzJz5kx2797NwIEDP/n99+7dw97engsXLrB582Z++umnT//PljJ5eXmYmppy7do1zp07R61atdQdktqkZ+XSan6YUo+9tYCL883Eq2QlWKk98gbF9wUE0NHWKpN9Acsic3PzT1aAX79+nQEDBtCvXz9mz56tstiMjY05ffo09erVw8jIiG3btqlsbUV58uQJtra2tG7dms2bN5e6ZBLAwcEh/2eoU6dOREdH53/NOz6JXmuiiLn9z9Hypz74vv169M2nBOW2ZdCCrQVKJqVSKTNnzmTOnDkFSiYBGjZsyPHjxxk4cCBDhgxhxIgRGj1qUhmWL1/O0aNH8fDwKNPJpFwu53RsDJXylHu/UaxLKPlKdUKp6L6AAFN7NHzvHTdR6fSxCvC0tDRsbW2pW7fuBxtJK1O9evU4evQoQ4cOZfjw4QwbNow3b96oNIaiysnJwcHBgezsbPz8/KhYsaK6Q1Kadu3akZCQQPPmzTExMWH79u1siLzBDL8LZOXKC32CIkcLbZ3yHHldhw2RNz76vbGxsbi5ueHi4sJvv/1WqHUqVqzI1q1b2b59O7t378bIyIikpLLRK/DUqVPMmTOHGTNmYGJiou5wVE4QBOLi4pg8eTINGjTA2NiY1zdi0RKUc8dRrEsoHUr1kfdbGyJvsDL8erGfk50gpfr9WMLDw6lXr54CIhOVFOnp6QwYMIDg4GD++OMPxowZg4ODA+Hh4cTFxdG8eXO1xvfXX38xcuRIWrdujUwm0/jClnHjxrFly5b8XohlQXZ2NhMnTsQ9+hY1+45X2HOX2bV+pyvAW3fv3kVfX5/GjRtz+PDhYiXtCQkJSCQSMjIy8Pb21uiG88X18uVL2rdvz9dff83x48f57LPP1B2SSgiCwLlz5/Dx8cHHx4c7d+5Qu3ZtHBwccHZ2ptYPrTD7Q3n3KMW6hJKvTCSU8M/x0rygS+TKhULtCJTT1kJHW4sF1i1pX+0NpqamwD8X15s2baqscEUaKC8vj2nTprF69WoMDQ2JiYnB399fY6aMJCYmYmdnx+vXr/H29i7Qcag67Nq1iyFDhrB582ZGjhyp7nBUKjk1A5OVR8iRo7Aj/go62kRMMn7n5OTly5cYGhry5s0bTp06pZDCrWfPnjFgwAAiIiJYvHgx06dPL3XXFARBwNXVleDgYM6ePfvJYqfS4MqVK/j4+ODt7c21a9eoUaMGEokEZ2dnjI2N3xkvKdYliD6mzCSUUPQL8EtsW+e/WP/999+YmZnx9OlTDh48WKYrIMuqcePGsWHDBpo0aUJiYuInK8BVKSUlhf79+xMREcGSJUuYNm2aRr3px8bG0q1bNwYNGsSff/6pUbGpgirekHNycvIrwE+ePKnQ3fO8vDzmz5/PokWLsLGx4a+//qJatdJTlbtnzx4GDRrE3r176d+/v7rDUZrbt2/nJ5Hnz5+natWq2Nra4uzsTK9evT64K5ucmkGvNVFkKbC9z/s+EIlKpjKVUL6V36Lj+hOSUt7ToqNmZUyafo2rQYP3bsGnpKTQt29frly5QnBwMMbGxiqLXaRet2/fplOnTvzwww9cvXqVJk2afLQCXB3y8vKYN28eixcvxs7Ojl27dvHFF1+oOywePXpEx44dadiwIZGRkVSoUEHdIamUKlqZ/fDV54wcOZKdO3cSFhZGjx49lLJWUFAQbm5u1K5dGz8/v1LRn/HmzZu0b98eOzs7du/ere5wFO7vv//G19cXb29v4uPjqVy5MlZWVjg7O2Nubl7gKxHe8UnM8LugsLg+dGVDVPKUyYTy34raF/BtQcaJEyfw9fXF2tpaBdGK1Ck9PR1DQ0PS09OJj48nOTkZS0tL5HI5ISEhtGvXTt0hviMwMJCBAwfyzTff4OfnR4sWLdQWS3Z2Nj169OD27dskJCTwzTffqC0WdZkfdAn32HtKmYdcTlsLN/2GfH79AFOnTmXnzp1Kb/Vz48YNJBIJt27dYseOHTg7Oyt1PWXKzs6mS5cuvHjxgsTERKpWLR13+R4/foxUKsXb25sTJ05Qvnx5+vbti7OzM5aWllSpUrTxwesPX2dVxA0EQSjWKcPU3s0YY9K4yH9epFlKdZV3QVSpoEPLb6rRvsGXtPymWoHbFlStWpXQ0FAsLS2xs7Njz549So5UpE6CIPDzzz9z69YtAgIC+PLLL2nTpo3CZoArQ79+/YiPj0dbWxs9PT1kMpnaYpkwYQLx8fH4+fmVyWQSIPLaE6Ukk/BPS6GQxDtMmzaNmTNnqqRvZJMmTTh58iQ2Nja4uLgwadIkcnJylL6uMsyZM4ezZ8/i6elZ4pPJ1NRUtm/fTq9evfjmm2+YOHEiVatWZffu3Tx58gR/f3+cnJyKnEwCpMVKSdm/jvLltAo9ka6cthYVdLRZZtdaTCZLmTKfUBZHhQoV8PHxYfDgwQwaNIi1a9eqOySRkqxZswYvLy927tz5zvHe2xngvXr1wtramg0bNqgxyv9q2rQpsbGx9O3bF3t7e6ZPn67ykY1bt25ly5YtbNy4EQMDA5WurSleZ+WSlJqh1DWevgFbB2cWLVqk1HX+rUqVKnh4eLB+/Xo2bNhAjx49ePjwocrWV4SIiAiWL1/O4sWL0dXVVXc4RfLq1Svc3d2xsLCgdu3ajBgxAkEQ2LJlC48ePWL//v0MHDhQIfddjxw5wpw5c5horceRX0ww/P6fEZ6fSizfft3w+5pETDIWj7lLoTJ/5K0IgiAwY8YMli9fzq+//sqCBQvKXLFBaXbkyBFMTU2ZMmUKy5Yte+/3/LsCfPz48axevfqd6kh1EwSB1atXM336dIyNjfH29lbJyMaYmBi6d+/OsGHD2LRpk9LX01SqGl3nN1yXDo3U088vJiYGe3t7BEFg3759JaId1NOnT2nTpg2tWrUiLCxM5b1kiyMjI4OQkBC8vb3Zv38/WVlZdOnSBWdnZ+zt7alTp47C17x//z4dOnSgdevWhIWF5b/GFbcuQVQ6iAmlAi1fvpzp06czevRo1q9fX6JenETvd+/ePTp16kS7du04cOAAOjofvxKxefNmxo4di4WFBZ6enhpVAQ5w9OhRHB0dqVixIjKZTKk7Mg8ePKBjx475fRDLly+vtLU03Zmk59hujlH6Ov6jDGnf4Eulr/Mhjx49wsnJiZiYGFatWsW4ceM09sO1IAhYWVkRGxvL+fPnqVu3rrpD+qSsrCwOHjyIt7c3wcHBpKen06lTJ5ydnXFwcFBq/9mcnBx69OjBnTt3SExM5Ouv3//Bpah1CaKST/xXVqBp06ZRs2ZNhg8fTmpqKrt37y7Tb6IlXWZmJnZ2dnz++ed4e3t/MpkEGDVqFN999x2Ojo5069ZN4yrAu3fvTmJiIvb29nTt2pWNGzcybNgwha+TlZWFnZ0d5cqVQyqVlvnfg/I6qvlwqap1PqROnTpEREQwY8YMJkyYwKlTp9i2bVux7uspy/r16wkNDSUkJESjk8mcnBwOHz6Mt7c3AQEBvHz5ktatWzNr1iwcHR1p3Fg19xBnzpzJqVOnOHr06AeTSfj/dQmiskfcoVQCPz8/XFxc6NGjB1KpVCNfTEUfJwgCgwcPxtfXl5iYGNq3b1+oP3/+/HksLCwQBIHQ0FDatm2rpEiLJisriwkTJvDnn38ybNgw1q9fr7Dxh4IgMGzYMPbu3cvx48dL7L00RUrPyqXV/DCU+WKrBVycb6Yxu0G+vr4MGTKERo0a4efnR5MmTdQdUr5z586hp6fHyJEj+eOPP9Qdzn/k5eVx7NgxvL29kclkpKSk0LRpU5ydnXFycuLHH39UaTx+fn5IJBJWr17NpEmTVLq2qOQQE0oliYiIwMbGhrZt2xISEsKXX6rvGEpUeBs2bGDcuHG4u7vj6upapGc8ePAAKysrrl+/jo+PD3379lVwlMW3a9cuRo0aRZs2bZDJZNSvX7/Yz9y0aRNjxoxh165dDB48uPhBlmC5ublERUUhlUoJ1dZF+4vaSlurYc3KRE3RrLnTly9fxtbWlkePHrFnzx769eun7pDIyMigY8eOVKhQgVOnTmnMHHm5XM6pU6fw9vZm3759PHr0iIYNG+Ynke3atVPL9YEbN27QqVMnTE1N2bdvn8ZeYRCpn5hQKlFcXBx9+/blm2++ISwsTKOPVUT/3/Hjx+nRowdjxowpduX+/84AHzt2rGKCVKDTp08jkUhIT0/Hx8enWM2w3/7djR49WiN3flQhOzubI0eOIJPJ8Pf3JyUlhe+++44fHGZwW6ceyugc9LYP5Xzrlop/eDG9evWKwYMH4+/vz6xZs1iwYIFaC9ZGjBiBu7s7p0+fVmtvVvhnNz8xMRFvb298fX1JSkqibt26ODk54eTkhL6+vloTuIyMDDp37kxmZiYJCQkaMSBBpLnEhFLJLl++TO/evalQoQKHDh0qE7NhS7K3VYwtWrTg0KFDHxxBVhj/rgCfMGECq1at0qgKcPhnTnP//v05fPgwv//+O1OnTi30G1lycjKdOnXixx9/JDw8XCF/dyVFVlYWhw4dQiqVEhgYyIsXL2jcuDH29vbY29vToUMHbj55rfRJOZpaQSsIAitWrGDmzJn06NEDLy8vatWqpfI43h7d/vnnnwwfPlzl67918eJFvL298fHx4ebNm9SqVQsHBwecnJzo2rWrxrw+DBkyBG9vb2JjY2ndurW6wxFpODGhVIF79+5hampKWloaYWFhtGnTRt0hid4jKysLY2Nj7t+/z+nTpz968bwoNL0CPC8vj7lz57JkyRIkEgm7du0qcJPnzMxMjIyMePr0KQkJCSppSaRumZmZhIWFIZVKCQ4O5tWrVzRv3jw/iWzTps1/knJVzPLWZEeOHMHJyYnKlSsjlUpVer82OTmZtm3bYmJiglQqVfnO39urLz4+Ply6dInq1atjZ2eHk5MTPXr0KFDRnyrt2LGDYcOGsXv3bgYOHKjucEQlgJhQqsiTJ08wNzfnzp07hIaGYmhoqO6QRP9j+PDh7NmzR6mFJAcOHMDR0VEjZ4C/FRAQwMCBA6lXrx5+fn40b978o9//7wKm6OhoOnTooKJIVS89PZ39+/f/cycyNJT09HRat26dn0R+qlgiOTWDXmuiyMqVKyQeQRDQkufiOaAFhm2bKeSZypacnIy9vT1nz55VWpeB/5WXl5c/+vPcuXPUqFFD6WvCP5sJb+dnJyYmUqVKFWxsbHBycso/udJEZ8+excDAgIEDB7J161Z1hyMqIcSEUoVevnyJtbV1/gg6c3NzdYck+j9bt25lxIgRKpmBfO7cOSwtLTW2Ahzg2rVr2NnZkZyczF9//YWdnd0Hv3fdunVMmDABDw8PBgwYoMIoVePVq1eEhoYilUo5cOAAmZmZtG/fHnt7eyQSCc2aFS6R845PYobfBYXFpxW3l+en97Nz586P/jtpkqysLCZOnMiWLVsYOnQoGzZsUGpxzMKFC5k/fz6RkZF069ZNaevAP8V4+/btw8fHh5MnT1KxYkUsLCxwdnamb9++VK5cWanrF9eLFy/o2LEj1apVIyYmRmOKlkSaT0woVSwzMxMnJycOHDiAu7s7zs7O6g6pzDt58iTGxsYqneZSEirAX79+zZAhQ9i3bx8zZsxg0aJF/7nbFRkZiampaf7d0NLixYsXBAUFIZPJCAsLIysrCz09PSQSCRKJhB9++KFYz98QeYOV4deLHefU3s0Y0L4Ww4YNQyaTMXbsWFasWFFikoC//vqLUaNG0bJlS6RSKd99912h/nxBmmhHR0djbGycXxCkDM+ePUMmk+Ht7U1UVBQ6OjqYmZnh7OyMtbV1iZkPLggCtra2REVFcfr0afHOv6hQxIRSDXJychg6dCgeHh5s3LiRUaNGqTukMuvRo0d07NiR7777jsjISJU24E5PT6d///6EhISwbt06xowZo7K1C+rfIxtNTEzeKaZ4O0Wobdu2HDx4UOPugBVWSkoKgYGBSKVSIiIiyMnJwdDQEHt7e+zs7GjYsKFC1/OOT2Je0CVy5UKh7lSW09ZCR1uLBdYt8+chC4LA5s2bmTRpEi1btsTX11dlDa+L68yZM0gkEl6+fImnpydmZmYf/f78MX/XnpCU+p4xfzUqY9LsawboN+CrCnm0bduWevXq5Sd6ivLixQv8/f3x8fEhIiICgB49euDs7IytrW2JbBW3YsUKpk2bRmBgINbW1uoOR1TCiAmlmsjlcn755RfWrl3LwoULmT17ttjfS8Wys7Pp2bMnt27d4vTp02pp65SXl8fUqVNZs2aNxlaAwz87kU5OTlSqVAmZTMaPP/5I165def78OQkJCdSsWVPdIRbJkydPCAgIQCqVcuTIEeRyOUZGRvlJpLLvuCanZjDL/wLHbz6jnLbWRxPLt183alyLJbatqV/jv0enZ86cwdHRkcePH7N169YScwKSmpqKq6srBw8eZMGCBcyaNes/o2uL8nf1RcYD/vZbzpkTEQr5QPD69WuCg4Px9vbm4MGD5OTkYGRkhLOzMxKJROGFfKp07NgxevTowZQpU1i6dKm6wxGVQGJCqUaCILB48WLmzJnDxIkTWbVqlTj/W4XGjh3L1q1bOXr0qNqLpDZt2sS4ceM0tgIc/n8xxblz52jXrh0XLlwgJiZGI++AfszDhw/x8/NDKpVy7Ng/bXxMTEywt7fHxsaGOnXqqDym/F23609ISnnPrlvNypg0/RpXgwafbA2UlpbGiBEj8PLyYvjw4axdu5ZKlSopNX5FkMvlLFiwgN9++w0rKyv27NlD9erVgaLv5gp5uXymU45Ftm1w1i3anOvMzEwOHDiAt7c3ISEhZGZmoq+vnz8/WxML6wrr0aNHtG/fnmbNmhEREVHiTxtE6iEmlBpg06ZNjB07Fjc3N7Zv316m+vepy19//cVPP/3Eli1bGDFihLrDAd6tAA8JCeGbb75Rd0j/kZWVRffu3Tl16hQ9e/YkNDRUYytV/y05OTk/iYyOjqZcuXL07NkTe3t7+vXrp1Ftjm7eTcbE2pEva33Nzm1/0qJerUKPUxQEge3btzN+/HiaNGmCr6/vJ6v1NUVoaCiurq7UrFkTPz8/jqVUUsh90ym9mzLWpGDjH7Ozszl06FD+/OzXr1/Trl07nJ2dcXR0pFGjRsWOR1Pk5uZiamrK1atXOXPmjFo+UIlKBzGh1BBeXl4MHDiQPn364OPjUyJ2FEqqhIQEunbtiqurK9u2bdOoqwZvK8ABQkJCNG7379ChQ5ibm2NmZsaRI0do27YtUqlUISMbFe3OnTvIZDJkMhmnTp2ifPny9O7dG4lEgrW1tcpaxxRGeno63bp14/Hjx8TFxRX7Q8WFCxdwdHQkOTmZzZs34+bmpqBIlev27dvY2dmR9Fk9vuiluDvmy+xa5987/V+5ubkcPXoUb29v/Pz8eP78OS1atMgffVjYav6SYubMmaxYsYIjR44ovQJeVLqJCaUGOXDgABKJBD09PQIDA6lWrZq6Qyp1nj59SseOHalbty5RUVEaWQ2rqRXgt2/fRldXF11dXUJDQ/OLKTIzM/Hx8cHERP1zpG/evIlUKkUqlXL69GkqVKhAnz59sLe3x9LSUqN/p/Ly8pBIJERERHDixAnatWunkOe+fv2aMWPGsGfPHn766SfWr19PlSpVFPJsZbp+PwXz9SfIo5zCPvRV0NEmYpJx/v1TuVxOdHR0/vzsp0+f8v333+Ps7IyzszOtWrXSqA+cihYcHIy1tTXLli1j2rRp6g5HVMKJCaWGiY6OxtLSkkaNGnHw4MESfclb07w92rl8+TKnT5+mXr166g7pgzStAjw9PZ3OnTuTkZFBfHx8fgXrs2fPcHFx4ciRIyxbtoxffvlF5W/AV69ezU8iz507R+XKlenbty/29vb07du3xLRseVukFxQUhIWFhcKf/9dffzFmzBi+++47fH19adlS8+Z+/5uypgp1/r4m41tr5c/Pvn//PvXq1cPJyQlnZ2c6duxYqpPIt27fvk3Hjh0xNjbG39+/TPw/i5RLTCg10Pnz5zEzM+OLL74gPDxc4e1KyqpffvmFdevWcfjw4RJxtKMpFeCCIODs7ExoaCinTp2iVatW/4lzzpw5/P777zg4OLBjxw6lJnGCIHDx4kWkUikymYxLly7x+eefY2Vlhb29Pebm5hrfPPp/bdmyhVGjRrFu3TrGjRuntHUuX76Mo6Mjt2/fZsOGDfz0008amUjceJym1Lnn97eNpEa5bBwdHXF2dqZz585lqiDyzZs3dOnShRcvXnD69On84ieRqDjEhFJD3bp1i969e5OdnU14eDgtWrRQd0glmqenJwMGDOCPP/5g/Pjx6g6nUNRdAb5s2TJmzJiBTCb76CQWf39/Bg0aRL169fD391fonTNBEDh79mz+TuT169epVq0a1tbW2Nvb07t3b428vlAQYWFhWFhYMHr0aNatW6f09TIyMpgwYQLbt29nwIABbNmyReO6CswPuoR77D2F7k6+pSXI6dHgM7aOMNXIFl2qMGLECHbv3s3Jkydp3769usMRlRJiQqnBHj58SO/evXn48CH79+9HT09P3SGVSGfPns1vUL17926N3JH5lP379+Pk5KTyCvCDBw/St29fZs+ezcKFCz/5/VevXsXOzo6///6b3bt3Y2trW+S1BUEgPj4emUyGVCrl9u3b1KhRAxsbGyQSCT179iwRFeYfc+HCBbp06UK3bt0IDAxUaYLj6enJiBEj+Oabb/D19dWoAjDjFZHcS81Q2vMb1qxM1BT13/lVhz179jBo0CC2bdumkjnqorJDTCg13PPnz7GwsOD8+fMEBgbSs2dPdYdUoqSkpKCrq0v16tWJjo4u0dXzqq4Av3HjBnp6enTp0oWgoKACHwmmpaUxZMgQpFIpM2fOZOHChQVOlORyOadOnco/zk5KSuKrr77C1tYWe3t7unfvXmraaj169Ah9fX2+/PJLjh8/rpa7ntevX8fR0ZGrV6/yxx9/MHz4cLV/4HqdlUvr+WEo841JC7g436zQ7ZhKugsXLqCvr4+TkxM7d+5U+7+1qHQRE8oSID09HXt7e44cOYKXl9dHjx1F/19eXh59+/bl9OnTJCQkFHpOsCZSVQV4WloaBgYG5ObmEhsbW+g7VoIgsHLlSmbMmEHPnj3x9PTMH9n4v/Ly8oiOjs5PIh88eECdOnWws7PD3t4eIyOjUtdoOSMjg+7du/P3338TFxen1gKxN2/eMHnyZDZv3oyjoyPbtm3jiy++UFs8lx68xGL9CaWvEzquKy2/0dyqf0V79eoVnTp1olKlSpw8ebLE3TMWab6ycwu5BKtSpQqBgYHY2trmFz2IPu3XX38lIiICHx+fUpFMAnzzzTf5I9KsrKzYuHFjgf9selYulx685EzScy49eEl6Vu57v08ulzNo0CCSk5MJCAgo0oV9LS0tpk6dyqFDhzhz5gydOnXi9OnT+V/Pzc3l8OHDjBo1im+//RZjY2P8/PxwcHDg+PHj/P3332zcuBETE5NSl0zK5XLc3Ny4dOkSwcHBau82ULFiRTZt2oSPjw8HDx6kQ4cOJCYmqi2e7Fx5qVpHEwiCwNChQ3n8+DFSqVRMJkVKUbpeqUux8uXLs3fvXr788kuGDRtGamoqU6dOVXdYGksqlbJ06VJWrFhR6q4JVKlSBT8/P6ZMmcLYsWO5efMmK1eufO+xcv5Iv2tPSEp9z0i/GpUxafY1A/Qb0KT2P0euS5Yswd/fn8DAwGIXg/Xo0YPExEQkEgldunRh9OjRpKWl4e/vT0pKCg0bNsTV1RV7e3v09PTKRKXtzJkz8ff3x9/fn44dO6o7nHyOjo507NgRJycnOnfuzMqVKxk7dqzKj0XL66jmZ0BV62iCP/74I/8EoEmTgk0LEokKSzzyLmEEQWDu3LksWrSI6dOn8/vvv4v3YP7HpUuX0NfXx9LSEi8vr1L997Nx40bGjx+PpaUle/fuza/WTU7NYJb/BY7ffEY5ba2PVsu+/bpR41r0rPaUIY7WzJs3j3nz5hU7vqysLA4dOoSPjw++vr5kZ2fzxRdfMHz4cJycnMpMz7+3tm3bxvDhw1m9ejWTJk1SdzjvlZWVxbRp01i3bh22trbs2LEjv++oKpy9eAWbvbf45yOPcpSlO5QxMTEYGxszfvx4Vq1ape5wRKWYmFCWUGvXrmXSpEkMGzaMLVu2lNn2F//rxYsX6Orq5t8TKgkTQYrrfyvAj93PZV7QJXLlQqHarpTTgtycbBo8PUXUzt+LvFuYmZlJWFgYUqmU4OBgXr16RbNmzXBwcKBcuXIsXbqUdu3aIZVK1X7cq0oRERGYm5szfPhwNm7cqPGJdEBAAD/99BPVq1fHx8dHaV0mcnJyiI6OJjg4mODgYG7cuMG3I7ejU115M6XLSpX3kydP6NChA9999x2RkZGlpqBNpJnEhLIE2717N0OHDsXGxoa9e/eW+BYqxSWXy7G2tiY6OpqEhAR++OEHdYekMufOncPCwgLt1n3Rbtev6A8SBNDSYkrvpow1KfjRWHp6OgcOHEAqlRISEkJ6ejqtWrXC3t4ee3t7fvzxx/wEKiEhATs7O968eaMxIxuV7fLlyxgaGtK5c2eCg4NLzL3Qu3fv4uzszOnTp1m2bBmTJk1SSCL8/PlzDh48SHBwMAcOHODFixfUqVMHS0tLrKysiM1tgPfpB0rpQ1lOWws3/YbMt9bsSUHFlZeXh7m5OefPnycxMZFvv/1W3SGJSjkxoSzhgoKCcHR0xMjICH9/f41rUKxK8+bNY+HChezfvx9zc3N1h6Nym8PPsywyWWHPW2bXGifdBh/8elpaGiEhIchkMvbv309mZibt27fH3t4eiUTy0cbmT58+xcXFhaNHj7Js2TImT56s8Tt2RfX48WMMDAyoWrUqJ06cUGsFdVFkZ2cza9YsVq1ahaWlJX/99Rc1a9Ys9HNu3LiRvwt5/Phx8vLyaN++PVZWVlhaWtKxY8f8XXFlT8qJmNSNxl+XjJGcRTV37lwWL15MeHh4qbtHLtJMYkJZCkRFRWFlZUWLFi3Yv39/kV7sS7rAwEBsbGxYvHgxs2bNUnc4KpecmkGvNVFkKbBytYKONhGTjKlf4/9XhL548YLg4GCkUilhYWFkZWWhq6ubn0QWZlc4NzeXX3/9lWXLluHo6MiOHTtK3QeizMxMTExMuHv3LnFxcTRo8OEEXdOFhIQwaNAgqlSpgre3N4aGhh/9/tzcXKKjowkJCSE4OJhr165RoUIFevbsmZ9EfuzKg7JmeRt+XxP3ofoKe6YmOnDgAH379mXRokXMnj1b3eGIyggxoSwlEhMTMTc356uvviI8PLxMHW9cvXoVPT09TE1NkUqlpXan62OU+eb7h20TAgMDkUqlHDp0iJycHAwNDZFIJEgkkmLPmvfz82PQoEE0aNAAPz8/hY5sVCe5XI6zszMhISFERUWhq6ur7pCKLTk5GRcXF06dOsXixYuZOnXqO3dtX7x48c5R9vPnz6ldu3b+UXavXr0KfK9ZVR+SSpt79+7RoUMHDAwMCA4OLhOdE0SaQUwoS5Fr167Ru3dvtLS0CA8Pp2nTpuoOSelevXqFvr4+WlpaxMbGqmXaiLop+3jw8c6xZD29h5GREfb29tjZ2Sn8A8uVK1ews7Pj/v377NmzBxsbG4U+Xx1mz57N77//jlQqLVXDCHJzc5k7dy6///475ubmzJ8/n5iYmPyj7NzcXNq2bYuVlRVWVlZ06tSpyEmNd3wSM/wuKCz2T13jKOmysrLo1q0bjx8/JjExkRo1aqg7JFEZIiaUpUxycjK9e/cmJSWFsLAw2rdvr+6QlEYulyORSDhy5AhxcXGlZmersOYHXcI99p5SChgQ5HSsms7God2pU0d5Vbfwz53Mn376CZlMxqxZs1iwYEGJ7V6wa9cuhgwZwvLly0tdv9jc3FxOnjzJunXr8Pf3Jy8vj88+++ydo2xFHe1fvnyZ7mOWUtnAqdjPmtq7GWNMGisgKs01duxYtm3bRnR0NJ06dVJ3OKIyRtwLL2Xq16/P8ePHadiwId27d+fYMeXtXKnb77//TkBAAO7u7mU2mQSIvPZEOckkgJY2zyrUVnoyCVC1alX27dvHsmXLWLp0KX379iUlJUXp6ypaZGQkw4cP5+eff2bKlCnqDkchXr58ia+vL25ubtSuXZtu3bpx7Ngx7O3tadmyJbm5uRgaGjJixAiFJZOpqalYW1tT+9kZ5vdtQgUdbcppF+46SzltLSroaLPMrnWpTya9vLzYuHEja9euFZNJkVqIO5SlVFpaGjY2NsTExODr64uVlZW6Q1KoAwcOYGFhwdy5c5k/f766w1Gb11m5tJ4fhjJ/idXRBPrw4cM4OzvnTwXq0KGDytYujqtXr9K5c2d0dXUJDQ0t0X3/bt++nV+VHRUVRW5uLq1bt84/yn472SgvL48FCxawcOFCevTogYeHR7E/gOTm5mJubs7Zs2eJj4+nUaNGRW7Wv8S2dam+Mwn/7OTq6elhY2ODu7t7mbxHLlI/MaEsxd68eUP//v0JCgpi165duLm5qTskhbh58ya6urp07dqVwMDAMn3p/NKDl1isP6H0dULHdaXlN9WUvs6/JSUlIZFIuHjxIps3b2bw4MEqXb+wnj59ioGBARUrViQmJoZq1VT791VceXl5nDp1Kj+JvHz5MuXLl8fExCS/qOZjBVhHjhyhf//+AOzdu7dYrWrGjx/P5s2bOXToEN27d3/na/njRK8/ISnlPeNEa1bGpOnXuBo0KPWtgQBev36Nnp4eWlpaxMXFlYlhDiLNJCaUpVxubi4jR45kx44drF27lgkTJqg7pGJ5/fo1nTt3Jisri7i4OKpXr67ukNTqTNJzbDfHKH0d/1GGtG+guvF7b71584Zx48axfft2Ro4cydq1azWygf+bN2/o2bMnN2/eJDY2lu+++07dIRXIq1evCA8PJzg4mP379/Ps2TO++uorLCwssLKywtTUtFCFbo8fP8bV1ZXDhw/z66+/Mm/evELfg307nnLz5s2MHDnyo9+bnpXL3ZR0snPllNfR5ruaVcrEOMW3BEFgwIABBAUFkZCQQPPmzdUdkqgMKzu/eWWUjo4O27Zto0aNGkycOJHU1FTmz59fIo9EBEFg6NCh3Llzh9jY2DKfTAKU11HN7qyq1vlfFStWZNu2bejr6zNmzBjOnj2LVCrVqLZYgiAwZMgQEhMTiYyM1Phk8s6dO+8cZefk5NCqVSt+/vnn/KPsohZD1a5dm4MHD7J06VLmzp3LsWPH8PT05JtvvinQnz9+/Dhjxoxh9OjRn0wmAapU0FH5zrkm2bRpE15eXnh7e4vJpEjtxB3KMmTZsmXMmDGDMWPGsG7duhJ3VLxy5UqmTp2KVCpFIpGoOxy1EgSBc+fOEXwgnB0vfwQlfkBQxx3K94mLi8Pe3p6srCx8fX0xNjZWazxvzZ07l4ULF+Lr64uDg4O6w/mPvLw8YmNj85PIS5cu8dlnn9G9e/f8quxGjRopfN1jx47h4uJCdnY27u7un5xede/ePXR1dWnVqhVhYWEl+v6pKsTFxdG1a1dGjhzJunXr1B2OSCQmlGXNtm3bGDlyJE5OTuzevbvEvGhHRERgZmbG9OnTWbJkibrDUYtnz55x6NAhwsLCCAsL49GjR1SpUoVvhm8lu4Lydmka1qxM1BTNmLf99OlTnJ2diYqKYvny5QqbLV1Ue/bsYdCgQSxZsoSZM2eqLY7/lZaW9s5R9tOnT6lZs2b+UXbv3r1VMgLy6dOnDBw4kIMHDzJjxgwWLlz43jnmr1+/pkuXLqSlpREfH18mp30VRkpKCh06dKBu3bocO3aM8uXLqzskkUhMKMsiqVRK//796dWrF1KplMqVNbsC8u7du3Ts2DG/crak9iYsrNzcXOLi4ggLC+PgwYPEx8cjCAJt2rTB3Nwcc3NzDA0N+T3sptL6UJbT1sJNvyHzrVsq/NlFlZuby+zZs1m+fDlOTk5s375dLSMbjx07Rq9evXBzc2P79u1qv0Zy7969/F3Io0ePkp2dzY8//phflW1gYKCW3x25XM7KlSuZNWsWBgYGeHl5Ub9+/Xe+7uDgQHh4OCdPnqRVq1Yqj7EkkcvlWFhYEB8fT2JiYoke5ykqXcSEsow6dOgQtra2tGvXjpCQEI29j5iRkUGXLl14+fIlCQkJpX7yw/379/MTyEOHDvHixQu+/PJLevfujbm5Ob179/7PfTRlT8qJmNRNI6tlZTIZgwcPpmHDhvj7+9OkSROVrX3jxg0MDAxo27YtBw8eVMsOkVwuJy4uLj+JvHDhAjo6OhgbG+cnkd9//73K4/qQmJgYnJ2dSU9PZ/fu3VhaWgIwf/58FixYQEBAANbW1mqOUvMtXLiQefPmceDAAczMzNQdjkiUT0woy7DY2Fj69u1LvXr1OHjwIHXr1lV3SO8QBIGBAwcik8k4efIkbdu2VXdICpeVlcXx48fzk8iLFy+ira2Nnp5e/i5kp06dPrmzpIxZ3ghy9L/7Ep+RXRX3TAW7cuUKtra2PHz4EHd3d5UkJCkpKRgYGKCjo0NMTAxffqm66vfXr19z6NAhgoODCQ0N5cmTJ9SoUYO+fftiZWWFmZmZRrcrSk1NZfDgwQQHBzN58mR0dXVxcXHRuCsDmioiIoLevXuX+f67Is0kJpRl3KVLl+jduzcVK1bk0KFDGrWjsW7dOiZMmICnpycuLi7qDkdhbt68ycGDBzl48CCRkZFkZGRQt27d/ASyV69ehd6JTU7NoNeaKLJy5QqLU8jNRh78Gz47N2FoaKiw5yraq1evGDx4MP7+/vz666/Mnz+/UEe7hWk9k5WVhampKVeuXCE2NlYlvy9JSUn5u5CRkZFkZ2fTokWL/F3Izp07l6hrIIIgsHbtWqZNm5Z/fBsYGKj2KwOa7u+//6Z9+/Z06NCB/fv3l6h/c1HZICaUIu7evYupqSnp6emEhYXRunVrdYdEVFQUPXv2ZMKECaxatUrd4RTL69eviYyMzE8ib9++zWeffYaRkRHm5uaYmZnRunXrYr+hescnMcPvgoKihhkm9fBYMIbY2Fh+//13Jk+erLGdAQRBYPny5cyaNQtTU1M8PT0/mpTnN8e+9oSk1Pc0x65RGZNmXzNAvwFNalfNX2PgwIHs27ePI0eOKC3JlsvlxMfH5yeR58+fR0dHh27duuVXZTduXLLHCD5+/Ji2bdvy/PlzKlWqxK5du7C1tVV3WBorJycHY2NjkpOTOXPmDLVq1VJ3SCLRf4gJpQj45wXe3Nycu3fvsn//fjp37qy2WJKTk+nYsSOtW7cmLCzsvVWhmkwQBC5cuJCfQJ44cYKcnBy+//57+vTpg5mZGSYmJkopJNkQeYOV4deL/ZypvZsxxqQxOTk5zJkzh2XLlmFpacnu3bs1+h5rREQEzs7OVK1aFT8/P9q3b//O14szvm/XhpXMmzdPKTvm6enp7xxlP378mC+//PKdo2xNvedcWNnZ2fTo0YNbt24RERHB3Llz8fPzY9y4caxYsUIjG9er26RJk9iwYQPHjx/HwMBA3eGIRO8lJpSifC9fvsTKyorTp0/j5+enlgvfb968oVu3bjx+/JiEhAS++uorlcdQFCkpKURERHDw4EHCwsJ4+PAhlStXpkePHvm7kKraVfKOT2Je0CVy5UKh7lSW09ZCR1uLBdYtcdJ9t3I0NDSUgQMH8vnnn+Pj46PRb2r37t1DIpFw6dIltmzZwqBBg4Di/b1oCXIeh65nmn1X5syZo5A4k5OTCQkJITg4mCNHjpCVlUWzZs3yj7INDQ1L3IepTxEEgZ9//hl3d3eioqIwMDBAEAQ2bdrE5MmTad26NT4+Pvzwww/qDlVjSKVSHBwc+OOPPxg/fry6wxGJPkhMKEXvyMzMxNHRkbCwMNzd3XFyclLZ2oIgMGzYMPbu3Ut0dDQdO3ZU2dqFlZeXR3x8fP4uZHx8PHK5nNatW+cnkF27dlXbbktxduLq13h/G6nk5GScnJyIj49n6dKlTJ48WWPvvb1584axY8eyY8cORo8eTVObcaw5cqvIzxMEAS0tLX4xbcq4HkWrJpfL5Zw+fTr/KPvs2bOUK1cOIyOj/CRSlZXq6vD2XvTu3bsZOHDgO19LTEzE0dGRJ0+esH37dhwdHdUUpea4fv06nTp1ok+fPnh7e2vs75tIBGJCKXqPnJwchgwZwt69e9m0aVOBRqApwpYtWxg1atR732w0wYMHD95p6fP8+XOqV69O7969MTMzw8zMTKNGAsK/7gpef0JSynvuCtasjEnTr3E1aFCg1kA5OTnMnj2bFStWYG1tza5duzT6CHzbtm1M3RJA9d6jFfbMZXat/7OD+yEZGRlEREQQHBxMSEgIjx49onr16vTp0wcrKyvMzc1VWiWuTocOHcLc3JzJkyezYsWK937Pq1evGD58OD4+PowcOZLVq1dTqVIlFUeqGTIyMtDX1ycnJ4f4+PhCzVQXidRBTChF7yWXy5k0aRLr1q1j0aJFzJo1S6mfjmNiYujevTsjRoxg/fr1SlunMLKysoiOjs7fhbxw4QJaWlro6elhZmaGubk5urq6JeZYsjDVzJ8SHBzMoEGD+OKLL/Dx8UFfX1/B0SpGcmoGPVZFkp0nKOznt4KONhGTjD+4k3v//v38o+zDhw/z5s0bmjRpkr8L2aVLlxIzoUpRbty4gZ6eHgYGBoSEhHy0QlkQBLZt28b48eNp1qwZvr6+NGvWTIXRqp8gCAwePBipVEpcXBwtW2rOYAGR6EPEhFL0QYIg5DfRnTRpEitXrlRKle+DBw/o2LEjTZo04fDhw2p9s71169Y7LX3S09OpU6dOfgJpamoqjoX7P0lJSTg5OXH69GmWL1/OhAkTNO5IThn9Octpa2H4fU3ch/6TRMvlchITE/OPss+cOUO5cuXo0qVLfhJZ1hKif3v58mX+XclTp04VuLjo/PnzODo68vfff/Pnn38yYMAA5QaqQbZt28bw4cNxd3fH1dVV3eGIRAUiJpSiT9qwYQPjxo1j0KBBbN++vUA7cgXdDcvOzsbExIS7d+9y+vRp6tSpo4z/hQ96/fo1R48ezS+muXnzJp999hldunTJ7wvZpk0bjUuUNEV2djazZs1i1apV9OvXj127dmnMEa6yJwjNbicn/vA/VdkPHjygWrVq7xxla/JVAFXJy8vDysqKkydPEhsbS9OmTQv151+/fs3o0aNxd3dn6NChrFu3TuNHxRZXYmIihoaG/PTTT2zevFnd4YhEBSYmlKIC8fT0ZNCgQVhYWODt7U3FihX/8z1F6e03evRoduzYkV/xqWyCIHDx4sX8BPL48eNkZ2fTqFGj/ATSxMREvK9USEFBQQwaNIjq1avj4+ODnp6eukNiftAlpc04F+R5pCWGUvPukfxdyK5du5a5o+xPmTZtGqtWreLAgQP07t27SM8QBIG//vqLMWPG8P333+Pr68uPP/6o4Eg1w/Pnz+nYsSM1atTgxIkT732dFYk0lZhQigps//792Nvbo6enR1BQEF988QVQ9IridrlXmDLyJ7Zu3crPP/+stLhTU1OJiIjIL6h58OABlSpVwsTEJD+JbNy4sbgLWUx3797FycmJM2fOsGLFCsaPH6/Wv1PjFZHcS81Q2vO/qapD9Mze4s/NB7i7uzNw4EDWrFnDxIkTi/28y5cv4+DgwJ07d9i0aRODBw8u9jM1iVwux8bGhhMnTpCYmMh3332n7pBEokIRE0pRoZw4cQJLS0t++OEHDh48yOG7mUXq7aetBXnZWbTKvkLoutkKjTEvL4+EhIT8XcjY2FjkcjktW7bMTyC7du0qfvpXguzsbGbMmMGaNWuwtbVl586damnI/Torl9bzw1Dmi5sWcHG+WZELm0qz2NhYjI2NGTBgANu3b1dY0p2RkcG4cePYuXMnAwcOZOPGjUoZEKAOS5cuZebMmYSEhGBhYaHucESiQhMTSlGhnTt3DjMzM6roSchr2bfoDxIE0NJiSu+mjDUpXv+9hw8fEhYWRlhYGOHh4aSmplK9enV69eqV3xeyXr16xVpDVHABAQH89NNPfPnll/j6+tKpUyeVrn/pwUss1p9Q+jqh47rS8ptqSl+nJLl//z6dOnXi+++/58iRI0rpxerh4cHIkSOpX78+Pj4+tGnTRuFrqNLRo0fp2bMnM2bMYPHixeoORyQqEjGhFBXJutAEVp94rLDnFaa3H/yzExYdHZ1/jH3u3Dm0tLTo1KlT/i6knp5eiWnpUxrduXMHJycnzp49y6pVqxg7dqzKjofPJD3HdnOM0tfxH2VI+waaUYSkCTIzM/MnXcXHx1O7dm2lrXXt2jUcHR25fv06f/zxBz///HOJvH7w8OFD2rdvz48//kh4eLj4miUqscSfXFGhJadmsPHUU4U+c27QJQx/qPXB3n4At2/fzk8gjxw5wuvXr6lduzZmZmZMnz4dU1NTatWqpdC4REXXqFEjTpw4wbRp0xg/fjxRUVHs2LGDatWUv6NXXkfx7a3UuU5JIAgCQ4cO5dKlS0RHRys1mQRo1qwZp06dYvLkyYwYMYLIyEj+/PPP/LvdJUFubi5OTk5oa2vj5eUlJpOiEk3coRQVmip6+wGkp6dz9OjR/CTyxo0b6Ojo/KeljzJ6Y4oUy9/fn59++omaNWvi6+ur9LGa6Vm5tBLvUKrU2zuAvr6+ODg4qHRtHx8ffv75Z2rXro2vry/t27dX6fpFNW3aNFavXs3Ro0fp2rWrusMRiYpFfCcWFcqNx2kcv/lM4a1Y8uQCx28+40D0GVatWoWpqSk1atTA0tKS4OBgevbsSUBAACkpKRw9epQZM2bQrl07MZksIWxtbUlMTKRGjRoYGhqyceNGlPlZtkoFHRp8ZLdbERrUrCwmk/8nODiYWbNmMXfuXJUnkwBOTk4kJibyxRdfYGBgoPSfL0UICAhgxYoVLFu2TEwmRaWCuEMpKhRV9PbLPLEnv6WPmZkZTZs2LZF3o0T/lZWVxdSpU1m/fj0ODg5s27ZNaUfgyvxZLaethZt+Q+ZbiyPxLl26hIGBAaampkilUrV+yPv3z5dEImH79u1q6TLwKbdu3aJjx4706NEDmUwmvr6JSgUxoRQVirJ7+31VCY5N7UGlSpWUtoZI/WQyGUOGDOGrr77C19eXDh06KHwNZU/KiZjUjcZfl+0G+CkpKejp6fH5558THR2tMS18/Pz8GDJkCDVq1MDHxwddXV11h5QvMzMTQ0NDXr9+TUJCgkruFItEqiCeF4oK7HVWLklKTCYBnmWCXFucNlLaSSQSEhMTqVatGp07d2bz5s0KP6JsUrsqRo1rUU5bsbs/5bS1MGpcq8wnkzk5OTg4OPDq1SsCAwM1JpkEsLOz48yZM3z11Vd06dKFtWvXaswR+Lhx47h69SpSqVRMJkWliphQigrsXkq6UoscAATgbkq6klcRaYIffviBmJgYhg8fzujRo3FxceHVq1cKXWOJbWt0FJxQ6mhrscS2tUKfWRJNmjSJ48ePI5PJNHKqS6NGjTh+/Djjx49n0qRJ2NjYkJqaqtaYdu3axY4dO9i0aRNt27ZVaywikaKJCaWowLJz5aVqHZH6VahQgfXr1+Pr68v+/fvp2LEjZ8+eVdjz69eozG8Kvue4wLrlR9tblQV//vknGzduZOPGjXTr1k3d4XxQ+fLlWblyJUFBQZw4cYL27dtz8uRJtcRy7tw5Ro8ezdChQ/npp5/UEoNIpExiQikqMLG3n0hZHBwcSExMpGrVqhgYGPDnn38q7IjyxwovyIz1VcizpvZuVqgG/KVRVFQUY8eOZezYsQwfPlzd4RSIlZUVZ86coV69ehgZGbF8+XLkctV9cH358iX29vY0b96c9evXq2xdkUiVxHduUYF9V7MKyq5F1Pq/dURlT+PGjYmJiWHIkCGMHDmSAQMGkJaWVqxn3r17F3Nzc759cYF5fZpQQUe70Hcqy2lrUUFHm2V2rRlj0rhY8ZR0d+7cQSKR0K1bN1avXq3ucAqlQYMGHD16lKlTpzJ9+nQsLS15+lSxAxreRxAEhgwZwtOnT5FKpWLBoajUEqu8RYWi7CrvhjUrEzXFRGnPF5UMbxtV16lTh3379hXpvtnTp0/p2rUreXl5+ZNbklMzmOV/geM3n1FOW+ujLYXeft2ocS2W2LYu88fcaWlpdOnShYyMDGJjY6lZs6a6QyqygwcP4ubmRvny5fH29sbIyKjQz0jPyuVuSjrZuXLK62jzXc0q7+1Lunr1an755Rf8/f2xsbFRQPQikWYSE0pRoYi9/USqcuPGDRwdHbl69Srr1q1j2LBhBe7X9/r1a0xMTEhOTiY6Opoffvjh3Wc/TmNvbBKR15+QlJLxTrGZFv80LTdp+jWuBg3KfDU3gFwuRyKRcPjwYU6ePEnLliX/d/T+/fv079+fEydOsGDBAmbOnPnJHpr5PzfXnpCU+p6fmxqVMWn2NQP0G9CkdlVOnDhB9+7dmTx5MsuXL1fq/49IpG5iQikqFLG3n0iV3rx5w6RJk9iyZQv9+/fnzz///GR7muzsbCwtLTl16hRRUVGfHMNX0J2msmzu3LksWrSIwMBArKys1B2OwuTm5rJgwQIWLVpEr169cHd3f+8M8qLsbOs1qMqJNWNpXKc6R44cEed0i0o9MaEUFZpSZnlrgeEPtd6Z5S0SveXl5cXw4cP59ttv8fX1pU2bNu/9PrlcjqurKzKZjIMHD2JiIl6fKC5fX1+cnJz4/fffmTFjhrrDUYqIiAhcXV3R0tJi79699OjRI/9r3vFJzAu6RK5cKNxrniBHyMtlVu/GjDAV20yJSj+xKEdUaIru7ScIAnm5OfzUqqLCnikqXVxcXDh9+jQVKlRAX1+f7du3/6cKXBAEJk+ejLe3N3v37hWTSQVITExk8ODB9O/fn+nTp6s7HKXp1asXZ8+epWXLlvTq1Yv58+eTl5fHhsgbzPC7QFauvPAfoLW00dIpz+9HktgQeUM5gYtEGkTcoRQViXd8EjP8LijseRXOSrl/fB/btm3DxcVFYc8VlS6ZmZlMnDiRrVu34urqyubNm/OPwJcuXcrMmTPZtGkTo0aNUnOkJd/jx4/p1KkTdevWJSoqqkxUJ+fl5bFkyRLmz59Pe8kYnv1gprBnL7NrXeZbTolKNzGhFBXZhsgbrAy/XuznTO3djMF6dRk5ciQeHh6MGTOGVatWUaFCBQVEKSqN9u7dy4gRI6hfvz779u0jPj6eIUOGMG/ePObPn6/u8Eq8rKwsTExMuHv3LvHx8Xz77bfqDkmlpAci+eXICyj3WYELwT6lgo42EZOMy3y3AFHpJSaUomIp6v2ictpa6GhrscC6Zf6ndkEQ2LJlCxMnTqRdu3bs27ePBg3ET/Si97t27RoODg5cu3aN3Nxchg0bxpYtWxSWAJRVb/smenl5ERUVhb5+2bvX7LYjlphbz8hT4LtjOW0tDL+vKd4TF5Va4h1KUbE46zYgYpIxht//05PuU02j337d8PuaREwyfucISEtLi1GjRnHixAkePXpEhw4dCAsLU17wohKtWbNmrF27lry8PORyORkZGWRkKK9Halmxdu1a/vrrL7Zv314mk8kbj9M4flOxySRAnlzg+M1n3HxSvGb9IpGmEhNKUbHVr1EZ96H6HJrYDTf9hjSsWfk/E3W0+KdpuZt+QyImdcN9qP4Hj350dXVJTExEV1eXPn365F+QF4n+7eLFi0gkEoyMjNixYwf+/v7o6upy6dIldYdWYoWFhTFlyhSmTZuGq6urusNRi72xSYWeplRQ5bS18DiVpJRni0TqJh55i5RCEb395HI5ixcvZt68eZiamrJ3715q1aqlpIhFJcm9e/cwNDTkq6++IioqimrVqnH16lUcHBy4desWmzZtYvDgweoOs0S5fv06enp6dOnShaCgIMqVK6fukNRCnAYmEhWNmFCKNN6hQ4dwcXGhcuXK7Nu3r0wew4n+v2fPntG1a1eys7OJjo6mbt26+V/LyMhg/Pjx7Nixg8GDB7NhwwaqVBFnw3/Kixcv0NfXp1y5cpw8eZJq1aqpOyS1eJ2VS+v5YSjzTVELuDjfTGyeLyp1xCNvkcYzNTXlzJkzfPvttxgZGbFx48b/9CAUlQ3p6elYWFiQmppKeHj4O8kkQOXKldm+fTu7d+/G19cXPT09Ll++rKZoS4a8vDycnZ15+vQpQUFBZTaZBLiXkq7UZBJAAO6mpCt5FZFI9cSEUlQi1K9fn6ioKEaOHMnYsWMZMGAAr1+/VndYIhXKycnB3t6ey5cvc+DAARo3bvzB7x04cCDx8fHAP3dy9+zZo6owS5zp06cTERGBr6/vR/9Oy4LsXHmpWkckUiUxoRSVGOXLl2fdunV4eXkRFBSEnp4eV65cUXdYIhWQy+UMGTKEw4cPExAQQMeOHT/5Z3788Ufi4uJwdHRk0KBBDB06VKwC/x+7d+9m1apVwCzW6wAAGQ5JREFUrF69ml69eqk7HLUrr6Oat0RVrSMSqZL4Uy0qcZydnd/ZffLx8VFzRCJlEgSBqVOnsnfvXjw8POjZs2eB/2yVKlXYtWsXu3btwsvLC319fa5evarEaEuOkydPMnz4cIYNG8a4cePUHY5G+K5mlf90qFA0rf9bRyQqbcSEUlQitWjRgri4OKytrXF2dmb8+PFkZ2erOyyREqxcuZLVq1ezbt06HB0di/SMwYMHEx8fT15eHp06dcLDw0PBUZYsycnJ2Nraoqenx8aNG8t8M/iUlBR27tyJo10/cl48VOpaDWpWFgtyRKWSmFCKSqzPP/+cvXv3smHDBrZs2YKxsTHJycnqDkukQLt372batGn8+uuvjB07tljPatmyJfHx8UgkEtzc3Pj555/JzMxUUKQlR0ZGBjY2NlSoUAGZTEb58uXVHZJaPHr0iM2bN9OrVy9q167NsGHDSEtLo9M3lSinpPy6nLYWJk2/Vs7DRSI1E9sGiUqF2NhYHBwcyMzMxNPTE1NTU3WHJCqm0NBQ+vXrx5AhQ/jzzz8Vuou2a9cuxowZQ+PGjdm3bx/NmjVT2LM1mSAIuLi4EBwcTHR0NO3atVN3SCqVlJSEn58fMpmM6OhotLW1MTExQSKRYGNjQ506dbjxOA3TtceUFkPEpG40/rqq0p4vEqmLuEMpKhX09fVJTEykQ4cOmJmZsXDhQuRysZKypDp58iQODg5YWVmxadMmhR/J/vTTT8TFxZGTk0PHjh3x9PRU6PM11ZIlS/Dx8WHPnj1lJpm8efMmy5YtQ09Pj4YNGzJ9+nSqVavGjh07ePz4MYcOHWLkyJHUqVMHgCa1q2LUuJbCp+WU09bCqHEtMZkUlVriDqWoVMnLy2PhwoUsWLAAc3Nz3N3dqVmzprrDEhXC5cuX6dq1K61atSIsLIxKlSopba3Xr18zatQoPDw8+Pnnn/njjz+Uup46BQYGYmNjw7x585g/f766w1EaQRC4fPkyMpkMmUzG+fPnqVSpEn379kUikWBhYcEXX3zx0Wckp2bQa00UWQps71NBR5uIScYfHDkrEpV0YkIpKpXCwsLo378/n3/+OVKpFF1dXXWHJCqA5ORkDA0N+fLLLzl27BjVq1dX+pqCILBz507Gjh1L06ZN2bdvH02bNlX6uqp04cIFDA0NMTMzw9fXF23t0nU4JQgCiYmJyGQy/Pz8uHbtGlWrVsXKygqJRIK5uTmVKxcukfOOT2KG3wWFxbjMrjVOug0U9jyRSNOICaWo1EpKSsLBwYGzZ8+ydu1aRo4cWearWTVZSkoKRkZGZGZmEh0dzTfffKPS9S9cuICDgwP3799n27ZtODs7q3R9ZXn27Bm6urpUq1aN6OjoUjOKUi6Xc+rUqfwk8u7du9SoUYN+/fohkUjo1asXFSpUKNYaGyJvsDL8erFjndq7GWNMynbTeFHpJyaUolItKyuLX375hY0bN+Lq6sqWLVtKzRtqaZKenk6vXr24efMm0dHRatshTEtLY+TIkXh6ejJy5EjWrFlDxYoV1RKLIuTk5GBqasrly5eJj4+nYcOG6g6pWHJzczl+/DgymQx/f38ePHhA7dq1sbW1RSKRYGxszGeffabQNb3jk5gXdIlcuUCevOBvl+W0tdDR1mKBdUtxZ1JUJogJpahM8PT05Oeff6ZRo0bIZLIyU9VbEuTk5GBjY0NUVBSRkZFqv54gCALbt29n3LhxNG/enH379tGkSRO1xlRUo0aNYseOHRw5coSuXbuqO5wiyc7O5siRI8hkMgICAnj27Bn169fHzs4OiUSCoaEh5cqVU2oMyakZzPK/wPGbzyinrfXRxPLt140a12KJbWvxzqSozBATSlGZcfnyZSQSCX///Te7du3C3t5e3SGVeYIgMHjwYLy8vAgNDdWodk/nzp3D0dGRhw8fsm3bNpycnNQdUqFs3ryZ0aNHs23bNoYNG6bucAolMzOT8PBwZDIZQUFBvHz5ksaNGyORSJBIJHTq1Ekt11duPE5jb2wSkdefkJSSwb/fPLX4p2m5SdOvcTVoIFZzi8oeQSQqQ169eiU4OTkJgDBx4kQhOztb3SGVaVOnThUAwdPTU92hvNerV68EZ2dnARBGjRolZGZmqjukAjly5Iigo6MjjB8/Xt2hFFhaWprg7e0tODo6ClWqVBEAoWXLlsLcuXOFc+fOCXK5XN0hvuP1mxzh4v0XQuK9VOHi/RfC6zc56g5JJFIrcYdSVOYIgsCGDRuYPHkyenp6+Pr68u2336o7rDJn1apVTJkyhT/++IPx48erO5wPEgSBbdu2MX78eH788Ud8fX1p3FhzCyxu376Nrq4uHTp04MCBA+joaO6Yv+fPnxMcHIxMJiMsLIysrCw6dOiQvxMpXk0RiUoOMaEUlVknT57E0dGRrKwsvLy86Nmzp7pDKjM8PDxwc3Nj5syZLFmyRN3hFMjZs2dxcHDg8ePH7NixAwcHB3WH9B9paWl07tyZrKwsYmNjqVGjhrpD+o+nT58SEBCATCbj8OHD5Obm0rlzZyQSCXZ2djRq1EjdIYpEoiIQE0pRmfb06VP69+/PkSNHWLBgATNnzix1Pfo0zYEDB7C2tmbgwIFs3769RLVyevXqFcOHD8fHx4cxY8awatWqYremURS5XI6trS2RkZHExsbSokULdYeU7/79+/j7+yOTyTh27J+xht26dUMikWBrayueEIhEpYCYUIrKvLy8PH777TcWLlyIhYUFe/bs0cidndIgNjaWHj160LNnT/z8/DT6OPZDBEFgy5YtTJw4kVatWuHr68sPP/yg7rCYPXs2v//+O8HBwVhYWKg7HO7cuZM/N/vkyZN89tln9OzZE4lEQr9+/fjqq6/UHaJIJFIgMaEUif7PgQMHcHV15YsvvkAqldKxY0d1h1SqXL16la5du9K8eXPCw8MLPblE05w5cwYHBweePn3Kzp07kUgkaovFy8uL/v37s2zZMqZNm6a2OK5evZqfRCYmJlKxYkXMzMyQSCRYWVmpZPKRSCRSDzGhFIn+5d69e9jb23P+/HnWr1/Pzz//XKKOZDXV33//jaGhIV988QXHjx/nyy+/VHdICvHq1SuGDRvGvn37GDduHCtWrFD5Efjp06fp2rUr9vb27NmzR6U/r4IgcP78+fy52ZcvX6ZKlSpYWFggkUjo27cvn3/+ucriEYlE6iMmlCLR/8jKymLSpEls3ryZgQMHsnnz5hK/m6ZOqampdOvWjbS0NGJiYkrdfTlBENi8eTOTJk2iTZs2+Pj48P3336tk7YcPH6Krq8u3335LVFSUSqb6CIJAfHx8fhJ569YtqlWrhrW1NRKJhN69e1OpUiWlxyESiTSLmFCKRB/g4eHB8OHDady4MVKpVG3jAEuyjIwMevfuzdWrVzlx4gTNmzdXd0hKc/r0aRwdHUlJSWHXrl3Y2toqdb03b97QvXt3kpOTiY+PV+rs87y8PGJiYvLnZicnJ1OrVi1sbGyQSCT06NGD8uXLK219kUik+cSEUiT6iIsXLyKRSHj48CF//fUXdnZ26g6pxMjNzcXW1pYjR45w5MgR9PX11R2S0r18+ZKhQ4cik8mYMGECy5cvL1SilZ6Vy92UdLJz5ZTX0ea7mlWoUuG/hUvC/00Y8vHx4fjx40oZV5mTk0NUVFT+3OzHjx/zzTff5I887Nq1a4ksqhKJRMohJpQi0Se8evWKoUOHIpVKmTx5MkuXLuWzzz5Td1gaTRAEhg4diru7O8HBwZibm6s7JJURBIGNGzcyefJk2rVrh6+vL999990Hvz9/nN+1JySlvmecX43KmDT7mgH6DWhS+59xfm+bwnt4eDBgwACFxZ6VlcWhQ4fyRx6mpqby3Xff5Tca19fXF9tqiUSi9xITSpGoAARB4I8//mDq1KkYGBjg4+Oj1CPGkm7mzJksXbpU4QlPSZKQkICjoyPPnz9n165d2NjYvPP15NQMZvlf4PjNZ5TT1iJP/uGX4rdfN2pci95fpjDYwYqpU6eydOnSYseZnp7OwYMHkclkhISEkJaWRrNmzfKTyPbt24uFaSKR6JPEhFIkKoTo6GgcHR3Jzc3F29sbExMTdYekcdauXcukSZNYvXo1kyZNUnc4avXixQuGDBmCv78/kyZNYunSpZQvXx7v+CTmBV0iVy58NJH8X+W0IDcnm3qPYzi2aynlypUrUlyvXr0iJCQEmUzGgQMHyMzMpE2bNvlJ5I8//igmkSKRqFDEhFIkKqQnT57g4uLC0aNHWbx4MdOmTROPAf/P236I06ZNY9myZeoORyMIgsD69euZMmUKHTp0wHLaerbHPynOA0FLiym9mzLWpEmB/1hKSgpBQUHIZDIOHTpEdnY2enp6+SMPNXk+uUgk0nxiQikSFUFeXh7z5s1j8eLFWFlZsXv37lLTW7GowsPDsbS0pH///uzatUvc4fofcXFxOM5cC3qKuwKwzK41TroNPvj1R48e5c/NjoyMRC6X07Vr1/wksn79+gqLRSQSlW1iQikSFUNISAhubm58+eWXyGQy2rdvr+6Q1CI+Ph4TExO6d++Ov7+/WLT0HsmpGfRaE0VWTh4oKNmuoKNNxCRj6tf4/31Sk5KS8PPzw8/PjxMnTqCtrY2JiQkSiQQbGxvq1KmjkLVFIpHo38SEUiQqpjt37mBvb8+lS5fYsGEDQ4cOLVO7c9euXaNr1640adKEiIgIsQn8B7jtiCXmdkqh7kx+SjltLQy/r8k845r5jcbj4+MpX748pqamSCQSrK2tqVmzpsLWFIlEovcRE0qRSAHevHnDhAkT2Lp1K4MHD2bjxo1lIrF68OABhoaGVK5cmRMnTlCjRg11h6SRbjxOw3TtMaU9//62kXyWkULfvn2xs7PD0tKSL774QmnriUQi0f8SE0qRSIH27NnDyJEjadKkCTKZrFQXOrx48YJu3brx/PlzYmJixPt4HzE/6BLusfcUujuZT5DTtbacrSNMy8SHGJFIpJnE0lSRSIEGDhzIqVOnyMzMpGPHjgQEBKg7JKXIzMzE2tqa+/fvEx4eLiaTnxB57YlykkkALW2S874Qk0mRSKRWYkIpEilYmzZtiI+Pp1evXtja2jJt2jRyc3PVHZbC5Obm4uLiQkJCAiEhIbRo0ULdIWm011m5JKVmKHWNpJQM0rNKz8+YSCQqecSEUiRSgmrVqiGVSlm1ahWrV6+mZ8+ePHz4UN1hFZsgCIwaNYqQkBCkUimdO3dWd0ga715KOsq+VyQAd1PSlbyKSCQSfZiYUIpESqKlpcXkyZOJjIzkxo0btG/fnqioKHWHVSxz5sxh+/bt7Ny5k759+6o7nBIhO1deqtYRiUSi9xETSpFIyYyMjEhMTKRFixb07NmT5cuXUxJr4davX8/ixYtZsWIFAwcOVHc4Gi8vL4/z588TEhSgkvXK64gv5yKRSH3EKm+RSEVyc3OZM2cOS5cupV+/fvz1119Ur15d3WEViI+PDy4uLkyePJmVK1eqOxyN9OjRI06dOkVsbCynTp0iISGB169fo1OxCt9O8FZYM/P30QIuzjejSgUdpa0hEolEHyMmlCKRigUFBTFw4EBq1aqFVCqlXbt26g7poyIiIujbty9OTk7s3r1bnFvOP31Hz5w5w6lTp/KTyHv37gHwzTffYGBggL6+PgYGBnTs2JG+m+K4p8TCnIY1KxM1xURpzxeJRKJPERNKkUgNbt++jb29PVeuXGHTpk389NNP6g7pvU6fPk337t0xMjIiMDCwTI5UFASB27dvv5M8nj17lpycHCpWrEinTp3yk0cDAwPq1av3n2cosw9lOW0t3PQbMt+6pcKfLRKJRAUlJpQikZpkZmYyfvx4tm/fztChQ1m/fj2VKlVSd1j5bty4QZcuXfj+++85fPgwVapUUXdIKvHy5Uvi4uLyk8fY2FiePXsGQNOmTfOTR319fdq0aVOgJFvZk3IiJnWj8ddVlfZ8kUgk+hQxoRSJ1GzXrl2MHj2a5s2bI5PJ+P7779UdEg8fPqRLly5UqFCBEydOlNpZ0Lm5uVy6dOmdu49XrlwBoHr16u/sPOrp6RVrtKQyZ3m7D9VX2DNFIpGoKMSEUiTSAGfPnsXe3p5nz56xZ88erK2t1RbLy5cvMTY25tmzZ8TExNCgQQO1xaJoDx8+/E/hTHp6OuXKlaNNmzbv3H1s0qSJQu+LJqdm0GtNFFkKbO9TQUebiEnG1K8hTskRiUTqJSaUIpGGePHiBT/99BMBAQFMnz6dRYsWoaOj2qrdN2/eYG5uzrlz5zhx4gQtW5bce3mZmZkkJibmJ4+x/6+9+wup8o7jOP55zjkz1G1hyik0D12YNsxiUhnE2ZBtwS4SlEjBhjdjBG4Xa4uWNzIHUSQxKGgMsm6iumhGAxkjCByCVkLTGqUGdUrD8E/QPIfao88uWq6DrbTfc07nOXu/bo/8nscL8X3Oeb6/X0+PIpGIJKmgoGDO4Ewyji48dSmib37qd229/TVlql2fPsEPwLsISiCFOI6j1tZW7dmzR+FwWCdPntSyZcuScu3p6Wlt27ZNHR0dOn/+vDZt2pSU67rBcRwNDQ3FxeOVK1dk27YyMzPjBmcqKiqeOziTLIcvDKr11wHjdXZtLlFjZZELdwQA5ghKIAV1dnaqtrZWlmXp9OnTCofDC15j6pGtW+NTemzPKCPg04rc7P/cp9BxHO3YsUNHjx5Ve3u7tmzZYvorJNSDBw/mDM6Mj49LkkpKSuLisaysLOWm009diqj53DXZM86Cnqn0+ywFfJZaqkr5ZBJASiEogRR179491dXVqaurS/v379fOnTtlvWRz7MHRhzrRE9GFG/cVmYjGnSFtSQotyVJlSVD1FSGtXPrvVHBzc7NaWlrU1taWclsY2batq1evxj37eP36dUlSTk5OXDyaDs4k052JqJra+/Xb0Jj8PuuFYfn09XBRnvZWl/HMJICUQ1ACKcy2bTU1NenAgQOqqalRW1ubFi9ePOfnTOLk51PH1djYqH379mn37t2J/HXmZWRkZM7gTDQald/v19q1a+cMzrwsslPd7JuAgfuKjD/nTUBuliqLg9q+McTWQABSFkEJeMDZs2fV0NCgYDCoM2fOaM2aNbOvmXx9ajkzGu04rE8r39HBgweTHmexWEy9vb2z8djd3a27d+9KkpYvXx4Xj+Xl5UkZnHmdFvKYAgCkEoIS8IihoSFt3bpVAwMDOnLkiBoaGowHPBzHkWVZ+urDlfrig2IX7/b51xocHIyLx76+vrjBmad7PlZUVKigoCCh9wMAcA9BCXhILBZTY2Ojjh07po8//05/vPmua2u7vQXN5OTk7OBMd3e3Ll68qImJCUlPBmeejcfVq1en3OAMAGD+CErAg1p/OK5DN9+W5c+QXPqa2mSTbNu21d/fH3fe9Y0bNyQ9GZx5Nh43bNignJwcV+4ZAJAaCErAgz452qOum2Ny8RS/BR3jNzw8HBePly9fViwWUyAQmDM4U1RU5PnBGQDAixGUgMcMjj7UR993Jmz981++FzdNHI1G1dvbGzd5PTw8LEkqLCycMziTmZmZsHsDAKQmxgcBjznRE3np1kCvyu+zdOiX31Xu3JyNx76+Pk1PTysrK0vr1q1TfX39bETm5+e7fg8AAO/hE0rAY94/cEG3J6IJW/+viRGN/PiZVq1aNWdwJtlniwMAvIH/DoCH/PnIViSBMSlJbyzJ1/DomPKDuQm9DgAgffhe9w0AmL/b41NKxlcKkzbvNQEA80dQAh7y2J5Jq+sAANIDQQl4SEYgOX+yyboOACA98F8D8JAVudlK9I6O1j/XAQBgvghKwEOyFwUUeoWTbBYilJul7EU8QwkAmD+CEvCYypKg/L7EfE7p91mqLA4mZG0AQPoiKAGPqa8IJWRTc0mannG0fWMoIWsDANIXQQl4zMqlbylclOf6p5R+n6VwUV7csYsAAMwHQQl40N7qMgVcDsqAz9Le6jJX1wQA/D8QlIAHFS7J0rdVpa6u2VJVqsIED/wAANITQQl4VN36kL7eXOzKWrs2l6h2Pc9OAgBejeU4TjJOcgOQIKcuRdR87prsGWdBwzp+n6WAz1JLVSkxCQAwQlACaeDORFRN7f36bWhMfp/1wrB8+nq4KE97q8v4mhsAYIygBNLI4OhDneiJ6MLAfUXGo3r2j9vSk03LK4uD2r4xxDQ3AMA1BCWQpqYe2bo1PqXH9owyAj6tyM3mBBwAQEIQlAAAADDClDcAAACMEJQAAAAwQlACAADACEEJAAAAIwQlAAAAjBCUAAAAMEJQAgAAwAhBCQAAACMEJQAAAIwQlAAAADBCUAIAAMAIQQkAAAAjBCUAAACMEJQAAAAwQlACAADACEEJAAAAIwQlAAAAjBCUAAAAMEJQAgAAwAhBCQAAACMEJQAAAIwQlAAAADBCUAIAAMAIQQkAAAAjBCUAAACMEJQAAAAwQlACAADACEEJAAAAIwQlAAAAjBCUAAAAMEJQAgAAwAhBCQAAACMEJQAAAIwQlAAAADBCUAIAAMAIQQkAAAAjBCUAAACM/A2gCOSEz4zBPgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -165,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -252,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -278,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -313,7 +322,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -348,7 +357,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -365,7 +374,7 @@ "source": [ "hexagon_graph = hexagonal_lattice_graph(3,3)\n", "pos = nx.get_node_attributes(hexagon_graph, 'pos')\n", - "assign_hexagon_labels(hexagon_graph)\n", + "assign_hexagon_labels(hexagon_graph, 'X', 'Y', 'Z')\n", "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in hexagon_graph.edges(data=True)]);\n", "nx.draw(hexagon_graph, pos)\n", "nx.draw_networkx_edge_labels(hexagon_graph, pos,edge_labels = edge_labels);" @@ -383,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -404,7 +413,7 @@ "\n", "def generate_kitaev_hamiltonian(lattice_size:int, weight_prob:float=1):\n", " graph = hexagonal_lattice_graph(lattice_size,lattice_size)\n", - " assign_hexagon_labels(graph)\n", + " assign_hexagon_labels(graph, 'X', 'Y', 'Z')\n", " graph = flatten_nx_graph(graph)\n", " H = nx_kitaev_terms(graph, weight_prob)\n", " return H\n" @@ -412,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -442,7 +451,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -459,7 +468,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -484,7 +493,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -523,7 +532,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -565,7 +574,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -625,7 +634,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -647,7 +656,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -658,7 +667,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 21, "metadata": {}, "outputs": [ { @@ -704,7 +713,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -718,7 +727,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -743,7 +752,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -768,7 +777,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -793,7 +802,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -818,7 +827,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 27, "metadata": {}, "outputs": [ { diff --git a/notebooks/RuClExample.ipynb b/notebooks/RuClExample.ipynb new file mode 100644 index 0000000..e378ef0 --- /dev/null +++ b/notebooks/RuClExample.ipynb @@ -0,0 +1,989 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c375a2e9-f691-4aba-8f0f-ac466ce86f33", + "metadata": {}, + "source": [ + "# RuCl Full Scale Example\n", + "We can now implement a full scale example, with details described here https://www.nature.com/articles/s41535-019-0203-y" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6770f6e2-191d-417c-b971-2fc509e2e0bf", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/zain/anaconda3/lib/python3.11/site-packages/attr/_make.py:918: RuntimeWarning: Running interpreter doesn't sufficiently support code object introspection. Some features like bare super() or accessing __class__ will not work with slotted classes.\n", + " set_closure_cell(cell, cls)\n" + ] + } + ], + "source": [ + "import os\n", + "import time\n", + "import random\n", + "import pandas as pd\n", + "\n", + "from openfermion import count_qubits\n", + "from openfermion.circuits import trotter_steps_required, error_bound\n", + "from openfermion.circuits.trotter_exp_to_qgates import trotterize_exp_qubop_to_qasm\n", + "\n", + "import networkx as nx\n", + "from networkx.generators.lattice import hexagonal_lattice_graph\n", + "\n", + "import cirq\n", + "from cirq.contrib import qasm_import\n", + "\n", + "from pyLIQTR.circuits.qsp import generate_QSP_circuit\n", + "from pyLIQTR.utils.Hamiltonian import Hamiltonian as pyH\n", + "from pyLIQTR.utils.utils import open_fermion_to_qasm, count_T_gates\n", + "from pyLIQTR.utils.qsp_helpers import circuit_decompose_once, circuit_decompose_once, print_to_openqasm\n", + "from pyLIQTR.gate_decomp.cirq_transforms import clifford_plus_t_direct_transform\n", + "from pyLIQTR.phase_factors.fourier_response.fourier_response import Angler_fourier_response\n", + "\n", + "from qca.utils.utils import count_gates, get_T_depth_wire, get_T_depth, plot_histogram\n", + "from qca.utils.hamiltonian_utils import flatten_nx_graph, assign_hexagon_labels, pyliqtr_hamiltonian_to_openfermion_qubit_operator" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f09ad0d9-4f64-4951-aad4-85f22ac9ee84", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "t_init = time.perf_counter()\n", + "def estimate_qsp(pyliqtr_hamiltonian, timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n", + " timestep_of_interest=1 #for magnus like argument\n", + " t0 = time.perf_counter()\n", + " random.seed()\n", + " angles_response = Angler_fourier_response(tau=timestep_of_interest*pyliqtr_hamiltonian.alpha, eps=energy_precision, random=True, silent=True)\n", + " angles_response.generate()\n", + " angles = angles_response.phases\n", + "\n", + " qsp_circuit = generate_QSP_circuit(pyliqtr_hamiltonian, angles, pyliqtr_hamiltonian.problem_size)\n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\" Time to generate high level QSP circuit: \" + str(elapsed) + \" seconds\")\n", + " \n", + " if not os.path.exists(outdir):\n", + " os.makedirs(outdir)\n", + " \n", + " subcircuit_counts = dict()\n", + " t_counts = dict()\n", + " t_depths = dict()\n", + " t_depth_wires = dict()\n", + " clifford_counts = dict()\n", + " gate_counts = dict()\n", + " subcircuit_depths = dict()\n", + " \n", + " outfile_data = outdir + hamiltonian_name + \"_high_level.dat\"\n", + " \n", + " for moment in qsp_circuit:\n", + " for operation in moment:\n", + " gate_type = type(operation.gate)\n", + " if gate_type in subcircuit_counts:\n", + " subcircuit_counts[gate_type] += 1\n", + " \n", + " else:\n", + " outfile_qasm_decomposed = f'{outdir}{str(gate_type)[8:-2]}.decomposed.qasm'\n", + " outfile_qasm_cpt = f'{outdir}{str(gate_type)[8:-2]}.cpt.qasm'\n", + " \n", + " t0 = time.perf_counter()\n", + " decomposed_circuit = circuit_decompose_once(circuit_decompose_once(cirq.Circuit(operation)))\n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\" Time to decompose high level \" + str(gate_type)[8:-2] +\" circuit: \" + str(elapsed) + \" seconds\")\n", + " \n", + " t0 = time.perf_counter()\n", + " cpt_circuit = clifford_plus_t_direct_transform(decomposed_circuit)\n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\" Time to transform decomposed \" + str(gate_type)[8:-2] + \" circuit to Clifford+T: \" + str(elapsed) + \" seconds\")\n", + " \n", + " if write_circuits:\n", + " with open(outfile_qasm_decomposed, 'w') as f:\n", + " print_to_openqasm(f, decomposed_circuit, qubits=decomposed_circuit.all_qubits())\n", + " \n", + " with open(outfile_qasm_cpt, 'w') as f:\n", + " print_to_openqasm(f, cpt_circuit, qubits=cpt_circuit.all_qubits())\n", + " \n", + " subcircuit_counts[gate_type] = 1\n", + " subcircuit_depths[gate_type] = len(cpt_circuit)\n", + " t_counts[gate_type] = count_T_gates(cpt_circuit)\n", + " gate_counts[gate_type] = count_gates(cpt_circuit)\n", + " t_depths[gate_type] = get_T_depth(cpt_circuit)\n", + " t_depth_wires[gate_type] = get_T_depth_wire(cpt_circuit)\n", + " clifford_counts[gate_type] = gate_counts[gate_type] - t_counts[gate_type]\n", + " \n", + " total_gate_count = 0\n", + " total_gate_depth = 0\n", + " total_T_depth = 0\n", + " total_T_depth_wire = 0\n", + " total_T_count = 0\n", + " total_clifford_count = 0\n", + " for gate in subcircuit_counts:\n", + " total_gate_count += subcircuit_counts[gate] * gate_counts[gate] * timesteps / timestep_of_interest\n", + " total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate] * timesteps / timestep_of_interest\n", + " total_T_depth += subcircuit_counts[gate] * t_depths[gate] * timesteps / timestep_of_interest\n", + " total_T_depth_wire += subcircuit_counts[gate] * t_depth_wires[gate] * timesteps / timestep_of_interest\n", + " total_T_count += subcircuit_counts[gate] * t_counts[gate] * timesteps / timestep_of_interest\n", + " total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate] * timesteps / timestep_of_interest\n", + " with open(outfile_data, 'w') as f:\n", + " total_gate_count \n", + " f.write(str(\"Logical Qubit Count:\"+str(len(qsp_circuit.all_qubits()))+\"\\n\"))\n", + " f.write(str(\"Total Gate Count:\"+str(total_gate_count)+\"\\n\"))\n", + " f.write(str(\"Total Gate Depth:\"+str(total_gate_depth)+\"\\n\"))\n", + " f.write(str(\"Total T Count:\"+str(total_T_count)+\"\\n\"))\n", + " f.write(str(\"Total T Depth:\"+str(total_T_depth)+\"\\n\"))\n", + " f.write(str(\"Maximum T Count on Single Wire:\"+str(total_T_depth_wire)+\"\\n\"))\n", + " f.write(str(\"Total Clifford Count:\"+str(total_clifford_count)+\"\\n\"))\n", + " f.write(\"Subcircuit Info:\\n\")\n", + " for gate in subcircuit_counts:\n", + " f.write(str(str(gate)+\"\\n\"))\n", + " f.write(str(\"Subcircuit Occurrences:\"+str(subcircuit_counts[gate]*timesteps)+\"\\n\"))\n", + " f.write(str(\"Gate Count:\"+str(gate_counts[gate])+\"\\n\"))\n", + " f.write(str(\"Gate Depth:\"+str(subcircuit_depths[gate])+\"\\n\"))\n", + " f.write(str(\"T Count:\"+str(t_counts[gate])+\"\\n\"))\n", + " f.write(str(\"T Depth:\"+str(t_depths[gate])+\"\\n\"))\n", + " f.write(str(\"Maximum T Count on a Single Wire:\"+str(t_depth_wires[gate])+\"\\n\"))\n", + " f.write(str(\"Clifford Count:\"+str(clifford_counts[gate])+\"\\n\"))\n", + " return qsp_circuit\n", + "\n", + "\n", + "def find_hamiltonian_ordering(of_hamiltonian):\n", + " \"\"\"\n", + " Function to generate a near optimal term ordering for trotterization of transverse field Ising Models.\n", + " This would need to be modified if there were multi-qubit interactions that were not just ZZ\n", + " \"\"\"\n", + " #ordering hamiltonian terms by performing edge coloring to make optimal trotter ordering\n", + " #assuming that any 2 body interactions are ZZ\n", + " sorted_terms = sorted(list(of_hamiltonian.terms.keys()))\n", + " sorted_terms.sort(key=lambda x: len(x) * 100 + ord(x[0][1])) #Z and X get translated to 90 and 88 respectively, multiplying by 100 ensures interacting term weight is considered\n", + " one_body_terms_ordered = list(filter(lambda x: len(x) == 1, sorted_terms))\n", + " two_body_terms = list(filter(lambda x: len(x) == 2, sorted_terms))\n", + " \n", + " #assigning edge colorings to order two body terms\n", + " g = nx.Graph()\n", + " for term in two_body_terms:\n", + " edge = (term[0][0], term[1][0])\n", + " g.add_edge(*edge)\n", + " edge_coloring = nx.greedy_color(nx.line_graph(g))\n", + " nx.set_edge_attributes(g, edge_coloring, \"color\")\n", + "\n", + " for (i,term) in enumerate(two_body_terms):\n", + " n1,n2 = (term[0][0], term[1][0])\n", + " color = g.edges[n1,n2]['color']\n", + " term = (*term, color)\n", + " two_body_terms[i] = term\n", + " \n", + " two_body_terms.sort(key=lambda x: x[2])\n", + " two_body_terms_ordered = list()\n", + " for (i,term) in enumerate(two_body_terms):\n", + " new_item = (term[0],term[1])\n", + " two_body_terms_ordered.append(new_item)\n", + " return one_body_terms_ordered + two_body_terms_ordered\n", + "\n", + "def estimate_trotter(openfermion_hamiltonian,timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False):\n", + " t0 = time.perf_counter()\n", + " bounded_error = error_bound(list(openfermion_hamiltonian.get_operators()),tight=False)\n", + " nsteps = trotter_steps_required(trotter_error_bound = bounded_error,\n", + " time = timesteps, \n", + " energy_precision = energy_precision)\n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\" Time to estimate Number of steps required: \" + str(elapsed) + \" seconds\")\n", + " \n", + " t0 = time.perf_counter()\n", + " term_ordering = find_hamiltonian_ordering(openfermion_hamiltonian)\n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\" Time to find term ordering: \" + str(elapsed) + \" seconds\")\n", + " \n", + " t0 = time.perf_counter()\n", + " trotter_circuit_of = trotterize_exp_qubop_to_qasm(openfermion_hamiltonian, trotter_order=2, evolution_time=timesteps/nsteps, term_ordering=term_ordering)\n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\" Time to generate trotter circuit from openfermion: \" + str(elapsed) + \" seconds\")\n", + " \n", + " qasm_str_trotter = open_fermion_to_qasm(count_qubits(openfermion_hamiltonian), trotter_circuit_of)\n", + " trotter_circuit_qasm = qasm_import.circuit_from_qasm(qasm_str_trotter)\n", + " \n", + " t0 = time.perf_counter()\n", + " cpt_trotter = clifford_plus_t_direct_transform(trotter_circuit_qasm)\n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\" Time to decompose trotter to Clifford + T: \" + str(elapsed) + \" seconds\")\n", + " \n", + " #writing the the higher level trotter circuit to a file as well as the clifford + T circuit\n", + " if not os.path.exists(outdir):\n", + " os.makedirs(outdir)\n", + " \n", + " if write_circuits:\n", + " outfile_qasm_decomposed = outdir + \"trotter_circuit_\" + hamiltonian_name + \".qasm\" \n", + " outfile_qasm_cpt = outdir + \"trotter_cpt_\" + hamiltonian_name + \".qasm\"\n", + " with open(outfile_qasm_decomposed, 'w') as f:\n", + " print_to_openqasm(f, trotter_circuit_qasm, qubits=trotter_circuit_qasm.all_qubits())\n", + " with open(outfile_qasm_cpt, 'w') as f:\n", + " print_to_openqasm(f, cpt_trotter, qubits=cpt_trotter.all_qubits())\n", + " \n", + " t0 = time.perf_counter()\n", + " outfile_data = outdir + \"trotter_\" + hamiltonian_name + \".dat\"\n", + " gate_count = count_gates(cpt_trotter)\n", + " t_count = count_T_gates(cpt_trotter)\n", + " t_depth = get_T_depth(cpt_trotter)\n", + " t_depth_wire = get_T_depth_wire(cpt_trotter)\n", + " with open(outfile_data, 'w') as f:\n", + " f.write(\"Logical Qubit Count:\"+str(len(cpt_trotter.all_qubits()))+\"\\n\")\n", + " f.write(\"Number of Trotter Steps Required (Loose Upper Bound):\"+ str(nsteps) +\"\\n\")\n", + " f.write(\"Total T Depth:\"+str(t_depth * nsteps)+\"\\n\")\n", + " f.write(\"Maximum T Count on a Single Wire:\"+str(t_depth_wire * nsteps)+\"\\n\")\n", + " f.write(\"Single Step Gate Count:\"+str(gate_count)+\"\\n\")\n", + " f.write(\"Single Step Gate Depth:\"+str(len(cpt_trotter))+\"\\n\")\n", + " f.write(\"Single Step T Count:\"+str(t_count)+\"\\n\")\n", + " f.write(\"Single Step T Depth:\"+str(t_depth)+\"\\n\")\n", + " f.write(\"Single Step Maximum T Count on a Single Wire:\"+str(t_depth_wire)+\"\\n\")\n", + " f.write(\"Single Step Clifford Count:\"+str(gate_count - t_count)+\"\\n\")\n", + " \n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\" Time to enumerate resource estimates: \" + str(elapsed) + \" seconds\")\n", + " \n", + " return cpt_trotter" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "21cec969-e59e-4136-b417-20877db4eb09", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def assign_hexagon_labels_rucl(g):\n", + " \n", + " assign_hexagon_labels(g, 'X1', 'Y1', 'Z1')\n", + " \n", + " #Adding next nearest and next-next nearest neighbor edges and labels\n", + " for n in g.nodes:\n", + " r,c = n\n", + " \n", + " #next nearest neighbors\n", + " if (r, c+2) in g:\n", + " g.add_edge(n, (r, c+2), label = 'Z2')\n", + " if (r+1, c+1) in g:\n", + " g.add_edge(n, (r+1, c+1), label = \"Y2\")\n", + " if (r-1, c+1) in g:\n", + " g.add_edge(n, (r-1, c+1), label = \"X2\")\n", + " \n", + " #next-next nearest neighbors\n", + " if (r+1, c) in g and not ((n, (r+1, c)) in g.edges):\n", + " g.add_edge(n, (r+1,c), label = \"Z3\")\n", + " if (r+1, c+2) in g and (r + c)%2 == 0:\n", + " g.add_edge(n, (r+1, c+2), label=\"X3\")\n", + " if (r-1, c+2) in g and (r + c)%2 == 1:\n", + " g.add_edge(n, (r-1, c+2), label=\"Y3\")\n", + "\n", + "g_rucl = hexagonal_lattice_graph(3,3)\n", + "pos = nx.get_node_attributes(g_rucl, 'pos')\n", + "assign_hexagon_labels_rucl(g_rucl)\n", + "edge_labels = dict([((n1, n2), d['label']) for n1, n2, d in g_rucl.edges(data=True)]);\n", + "nx.draw(g_rucl, pos, with_labels=True)\n", + "nx.draw_networkx_edge_labels(g_rucl, pos,edge_labels = edge_labels);" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2e8216d9-90b9-4174-8c0f-6b6d13aa2e25", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
referencemethodJ1K1Gam1Gam_prime1J2K2J3K3
0Winter et al. PRBAb initio (DFT + exact diag.)-1.70-6.706.60-0.900.000.002.70000.00
1Winter et al. NCAb initio-inspired (INS fit)-0.50-5.002.500.000.000.000.50000.00
2Wu et al.THz spectroscopy fit-0.35-2.802.400.000.000.000.34000.00
3Cookmeyer and MooreMagnon thermal Hall (sign)-0.50-5.002.500.000.000.000.11250.00
4Kim and KeeDFT + t=U expansion-1.53-6.555.25-0.950.000.000.00000.00
5Suzuki and SugaMagnetic specific heat-1.53-24.405.25-0.950.000.000.00000.00
6Yadav et al.Quantum chemistry (MRCI)1.20-5.601.20-0.700.250.000.25000.00
7Ran et al.Spin wave fit to INS gap0.00-6.809.500.000.000.000.00000.00
8Hou et al.Constrained DFT + U-1.87-10.703.800.000.000.001.27000.63
9Wang et al.DFT + t=U expansion-0.30-10.906.100.000.000.000.03000.00
10Eichstaedt et al.Fully ab initio (DFT + cRPA + t=U)-1.40-14.309.80-2.230.00-0.631.00000.03
11Eichstaedt et al.Neglecting non-local Coulomb-0.20-4.503.00-0.730.00-0.330.70000.10
12Eichstaedt et al.Neglecting non-local SOC-1.30-13.309.40-2.300.00-0.671.00000.10
13Banerjee et al.Spin wave fit-4.607.000.000.000.000.000.00000.00
14Kim et al.DFT + t=U expansion-12.0017.0012.000.000.000.000.00000.00
15Kim and KeeDFT + t=U expansion-3.504.606.42-0.040.000.000.00000.00
16Winter et al.Ab initio (DFT + exact diag.)-5.507.608.400.200.000.002.30000.00
17Ozel et al.Spin wave fit/THz spectroscopy-0.951.153.800.000.000.000.00000.00
18Ozel et al.Spin wave fit/THz spectroscopy0.46-3.502.350.000.000.000.00000.00
\n", + "
" + ], + "text/plain": [ + " reference method J1 K1 \\\n", + "0 Winter et al. PRB Ab initio (DFT + exact diag.) -1.70 -6.70 \n", + "1 Winter et al. NC Ab initio-inspired (INS fit) -0.50 -5.00 \n", + "2 Wu et al. THz spectroscopy fit -0.35 -2.80 \n", + "3 Cookmeyer and Moore Magnon thermal Hall (sign) -0.50 -5.00 \n", + "4 Kim and Kee DFT + t=U expansion -1.53 -6.55 \n", + "5 Suzuki and Suga Magnetic specific heat -1.53 -24.40 \n", + "6 Yadav et al. Quantum chemistry (MRCI) 1.20 -5.60 \n", + "7 Ran et al. Spin wave fit to INS gap 0.00 -6.80 \n", + "8 Hou et al. Constrained DFT + U -1.87 -10.70 \n", + "9 Wang et al. DFT + t=U expansion -0.30 -10.90 \n", + "10 Eichstaedt et al. Fully ab initio (DFT + cRPA + t=U) -1.40 -14.30 \n", + "11 Eichstaedt et al. Neglecting non-local Coulomb -0.20 -4.50 \n", + "12 Eichstaedt et al. Neglecting non-local SOC -1.30 -13.30 \n", + "13 Banerjee et al. Spin wave fit -4.60 7.00 \n", + "14 Kim et al. DFT + t=U expansion -12.00 17.00 \n", + "15 Kim and Kee DFT + t=U expansion -3.50 4.60 \n", + "16 Winter et al. Ab initio (DFT + exact diag.) -5.50 7.60 \n", + "17 Ozel et al. Spin wave fit/THz spectroscopy -0.95 1.15 \n", + "18 Ozel et al. Spin wave fit/THz spectroscopy 0.46 -3.50 \n", + "\n", + " Gam1 Gam_prime1 J2 K2 J3 K3 \n", + "0 6.60 -0.90 0.00 0.00 2.7000 0.00 \n", + "1 2.50 0.00 0.00 0.00 0.5000 0.00 \n", + "2 2.40 0.00 0.00 0.00 0.3400 0.00 \n", + "3 2.50 0.00 0.00 0.00 0.1125 0.00 \n", + "4 5.25 -0.95 0.00 0.00 0.0000 0.00 \n", + "5 5.25 -0.95 0.00 0.00 0.0000 0.00 \n", + "6 1.20 -0.70 0.25 0.00 0.2500 0.00 \n", + "7 9.50 0.00 0.00 0.00 0.0000 0.00 \n", + "8 3.80 0.00 0.00 0.00 1.2700 0.63 \n", + "9 6.10 0.00 0.00 0.00 0.0300 0.00 \n", + "10 9.80 -2.23 0.00 -0.63 1.0000 0.03 \n", + "11 3.00 -0.73 0.00 -0.33 0.7000 0.10 \n", + "12 9.40 -2.30 0.00 -0.67 1.0000 0.10 \n", + "13 0.00 0.00 0.00 0.00 0.0000 0.00 \n", + "14 12.00 0.00 0.00 0.00 0.0000 0.00 \n", + "15 6.42 -0.04 0.00 0.00 0.0000 0.00 \n", + "16 8.40 0.20 0.00 0.00 2.3000 0.00 \n", + "17 3.80 0.00 0.00 0.00 0.0000 0.00 \n", + "18 2.35 0.00 0.00 0.00 0.0000 0.00 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rucl_references = [\"Winter et al. PRB\", \"Winter et al. NC\", \"Wu et al.\", \"Cookmeyer and Moore\", \"Kim and Kee\", \"Suzuki and Suga\", \n", + " \"Yadav et al.\", \"Ran et al.\", \"Hou et al.\", \"Wang et al.\", \"Eichstaedt et al.\", \"Eichstaedt et al.\", \n", + " \"Eichstaedt et al.\", \"Banerjee et al.\", \"Kim et al.\", \"Kim and Kee\", \"Winter et al.\", \"Ozel et al.\", \"Ozel et al.\"]\n", + "\n", + "rucl_methods = [\"Ab initio (DFT + exact diag.)\", \"Ab initio-inspired (INS fit)\", \"THz spectroscopy fit\",\n", + " \"Magnon thermal Hall (sign)\", \"DFT + t=U expansion\", \"Magnetic specific heat\", \"Quantum chemistry (MRCI)\",\n", + " \"Spin wave fit to INS gap\", \"Constrained DFT + U\", \"DFT + t=U expansion\", \"Fully ab initio (DFT + cRPA + t=U)\",\n", + " \"Neglecting non-local Coulomb\", \"Neglecting non-local SOC\", \"Spin wave fit\", \"DFT + t=U expansion\",\n", + " \"DFT + t=U expansion\", \"Ab initio (DFT + exact diag.)\", \"Spin wave fit/THz spectroscopy\", \"Spin wave fit/THz spectroscopy\"]\n", + "\n", + "rucl_J1 = [-1.7, -0.5, -0.35, -0.5, -1.53, -1.53, 1.2, 0, -1.87, -0.3, -1.4, -0.2, -1.3, -4.6, -12, -3.5, -5.5, -0.95, 0.46]\n", + "rucl_K1 = [-6.7, -5.0, -2.8, -5.0, -6.55, -24.4, -5.6, -6.8, -10.7, -10.9, -14.3, -4.5, -13.3, 7.0, 17., 4.6, 7.6, 1.15, -3.5]\n", + "rucl_Gam1 = [6.6, 2.5, 2.4, 2.5, 5.25, 5.25, 1.2, 9.5, 3.8, 6.1, 9.8, 3.0, 9.4, 0, 12., 6.42, 8.4, 3.8, 2.35]\n", + "rucl_Gam_prime1 = [-0.9, 0, 0, 0, -0.95, -0.95, -0.7, 0, 0, 0, -2.23, -0.73, -2.3, 0, 0, -0.04, 0.2, 0, 0]\n", + "rucl_J2 = [0, 0, 0, 0, 0, 0, 0.25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n", + "rucl_K2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -0.63, -0.33, -0.67, 0, 0, 0, 0, 0, 0]\n", + "rucl_J3 = [2.7, 0.5, 0.34, 0.1125, 0, 0, 0.25, 0, 1.27, 0.03, 1.0, 0.7, 1.0, 0, 0, 0, 2.3, 0, 0]\n", + "rucl_K3 = [0, 0, 0, 0, 0, 0, 0, 0, 0.63, 0, 0.03, 0.1, 0.1, 0, 0, 0, 0, 0, 0]\n", + "\n", + "d_rucl = {'reference': rucl_references, 'method': rucl_methods, 'J1': rucl_J1, 'K1': rucl_K1,\n", + " 'Gam1': rucl_Gam1, 'Gam_prime1': rucl_Gam_prime1,\n", + " 'J2': rucl_J2, 'K2': rucl_K2, 'J3': rucl_J3, 'K3': rucl_K3}\n", + "df_rucl = pd.DataFrame(d_rucl)\n", + "df_rucl" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "21f84759-41b2-4ba7-9e86-a87268967dee", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def nx_rucl_terms(g, data_series):\n", + " H = []\n", + " n = len(g.nodes)\n", + " for (n1,n2,d) in g.edges(data=True):\n", + " label = d['label'][0]\n", + " distance = int(d['label'][1])\n", + " \n", + " #Heisenberg and Kitaev terms\n", + " if distance == 1:\n", + " weight_J = data_series.J1\n", + " elif distance == 2:\n", + " weight_J = data_series.J2\n", + " else:\n", + " weight_J = data_series.J3\n", + " \n", + " if distance == 1:\n", + " weight_K = data_series.K1\n", + " elif distance == 2:\n", + " weight_K = data_series.K2\n", + " else:\n", + " weight_K = data_series.K3\n", + " \n", + " if not (weight_J == 0 and weight_K == 0):\n", + " string_x = n*'I' \n", + " string_y = n*'I' \n", + " string_z = n*'I'\n", + " \n", + " weight_x = weight_J\n", + " weight_y = weight_J\n", + " weight_z = weight_J\n", + " for i in [n1,n2]:\n", + " string_x = string_x[:i] + 'X' + string_x[i+1:]\n", + " string_y = string_y[:i] + 'Y' + string_y[i+1:]\n", + " string_z = string_z[:i] + 'Z' + string_z[i+1:]\n", + " if label == 'X':\n", + " weight_x += weight_K\n", + " elif label == 'Y':\n", + " weight_y += weight_K\n", + " else:\n", + " weight_z += weight_K\n", + " if weight_x != 0:\n", + " H.append((string_x, weight_x))\n", + " if weight_y != 0:\n", + " H.append((string_y, weight_y))\n", + " if weight_z != 0:\n", + " H.append((string_z, weight_z))\n", + " \n", + " #Gamma Terms\n", + " if distance == 1 and data_series.Gam1 != 0:\n", + " string_gam1_1 = n*'I'\n", + " string_gam1_2 = n*'I'\n", + " #unwrapping loop since there is no ordering guarantee\n", + " labels=['X', 'Y', 'Z']\n", + " labels.remove(label)\n", + " l1,l2 = labels\n", + " string_gam1_1 = string_gam1_1[:n1] + l1 + string_gam1_1[n1+1:]\n", + " string_gam1_1 = string_gam1_1[:n2] + l2 + string_gam1_1[n2+1:]\n", + " \n", + " string_gam1_2 = string_gam1_2[:n1] + l2 + string_gam1_2[n1+1:]\n", + " string_gam1_2 = string_gam1_2[:n2] + l1 + string_gam1_2[n2+1:]\n", + " \n", + " H.append((string_gam1_1, data_series.Gam1))\n", + " H.append((string_gam1_2, data_series.Gam1))\n", + " \n", + " #Gamma' Terms\n", + " if distance == 1 and data_series.Gam_prime1 != 0:\n", + " #unwrapping inner loop since there is no ordering guarantee\n", + " labels=['X', 'Y', 'Z']\n", + " labels.remove(label)\n", + " for label_offset in labels:\n", + " string_gam1_1 = n*'I'\n", + " string_gam1_2 = n*'I'\n", + " l1 = label\n", + " l2 = label_offset\n", + " \n", + " string_gam1_1 = string_gam1_1[:n1] + l1 + string_gam1_1[n1+1:]\n", + " string_gam1_1 = string_gam1_1[:n2] + l2 + string_gam1_1[n2+1:]\n", + " string_gam1_2 = string_gam1_2[:n1] + l2 + string_gam1_2[n1+1:]\n", + " string_gam1_2 = string_gam1_2[:n2] + l1 + string_gam1_2[n2+1:]\n", + " H.append((string_gam1_1, data_series.Gam_prime1))\n", + " H.append((string_gam1_2, data_series.Gam_prime1))\n", + " return H\n", + "\n", + "def generate_time_varying_terms(g, s, x = lambda s: 0, y = lambda s: 0, z = lambda s: 0):\n", + " assert callable(x)\n", + " assert callable(y)\n", + " assert callable(z)\n", + " \n", + " weight_x, weight_y, weight_z = x(s), y(s), z(s)\n", + " n = len(g)\n", + " H = []\n", + " if not (weight_x == 0):\n", + " for node in g.nodes:\n", + " string_x = n*'I'\n", + " string_x = string_x[:node] + 'X' + string_x[node+1:]\n", + " H.append((string_x, weight_x))\n", + " if not (weight_y == 0):\n", + " for node in g.nodes:\n", + " string_y = n*'I'\n", + " string_y = string_y[:node] + 'y' + string_y[node+1:]\n", + " H.append((string_y, weight_y))\n", + " if not (weight_z == 0):\n", + " for node in g.nodes:\n", + " string_z = n*'I'\n", + " string_z = string_z[:node] + 'z' + string_z[node+1:]\n", + " H.append((string_z, weight_z))\n", + " return H\n", + "\n", + "#using normalized time s = t_current / t_total to allow for more variation of total time\n", + "def generate_rucl_hamiltonian(lattice_size, data_series, s=0, field_x=lambda s: 0, field_y=lambda s: 0, field_z=lambda s: 0):\n", + " g = hexagonal_lattice_graph(lattice_size,lattice_size)\n", + " assign_hexagon_labels_rucl(g)\n", + " g = flatten_nx_graph(g)\n", + " H_constant = nx_rucl_terms(g, data_series)\n", + " H_time_varied = generate_time_varying_terms(g, s, x=field_x, y = field_y, z = field_z)\n", + " H = H_constant + H_time_varied\n", + " return H" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6be24969-cd04-435b-a3ce-5bead1bd680d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimating RuCl row 13 using Trotterization\n", + " Time to estimate Number of steps required: 14.89695408300031 seconds\n", + " Time to find term ordering: 0.021428124979138374 seconds\n", + " Time to generate trotter circuit from openfermion: 1.0419171303510666e-06 seconds\n", + " Time to decompose trotter to Clifford + T: 87.22412741708104 seconds\n", + " Time to enumerate resource estimates: 7.514046208932996 seconds\n", + "Total time to estimate RuCl row 13: 146.24839045794215 seconds\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Commenting out range, to avoid long runtimes. This still takes ~20-30 minutes as written\n", + "for i in [13]:\n", + "#for i in range(19):\n", + " #defining precision required for the trotterized circuit\n", + " energy_precision = 1e-3\n", + "\n", + " figdir=\"Trotter/Figures/\"\n", + " if not os.path.exists(figdir):\n", + " os.makedirs(figdir)\n", + " widthdir = \"Trotter/Widths/\"\n", + " if not os.path.exists(widthdir):\n", + " os.makedirs(widthdir)\n", + "\n", + " timesteps=1000\n", + " H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i])\n", + " H_rucl_pyliqtr = pyH(H_rucl)\n", + " openfermion_hamiltonian_rucl = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_rucl_pyliqtr)\n", + " \n", + " print(\"Estimating RuCl row \" + str(i) + \" using Trotterization\")\n", + " t0 = time.perf_counter()\n", + " cpt_trotter_rucl = estimate_trotter(openfermion_hamiltonian_rucl, timesteps, energy_precision, \"Trotter/RuCl_circuits/\", hamiltonian_name=\"rucl_\" + str(i), write_circuits=True)\n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\"Total time to estimate RuCl row \" + str(i) + \": \" + str(elapsed) + \" seconds\\n\")\n", + " \n", + " plot_histogram(cpt_trotter_rucl,\n", + " f'trotter RuCl, row{i}',\n", + " figdir,\n", + " widthdir,\n", + " 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fc6129fc-d5d5-465b-b686-4085883228f6", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Estimating RuCl row 13 using QSP\n", + " Time to generate high level QSP circuit: 96.58290741604287 seconds\n", + " Time to decompose high level cirq.ops.pauli_gates._PauliX circuit: 0.00010220904368907213 seconds\n", + " Time to transform decomposed cirq.ops.pauli_gates._PauliX circuit to Clifford+T: 2.1459069103002548e-05 seconds\n", + " Time to decompose high level cirq.ops.common_gates.Rx circuit: 5.8333040215075016e-05 seconds\n", + " Time to transform decomposed cirq.ops.common_gates.Rx circuit to Clifford+T: 0.006496042013168335 seconds\n", + " Time to decompose high level pyLIQTR.circuits.operators.hamiltonian_encodings.UnitaryBlockEncode circuit: 0.4555914159864187 seconds\n", + " Time to transform decomposed pyLIQTR.circuits.operators.hamiltonian_encodings.UnitaryBlockEncode circuit to Clifford+T: 114.45711995789316 seconds\n", + " Time to decompose high level cirq.ops.common_gates.Ry circuit: 0.0047991249011829495 seconds\n", + " Time to transform decomposed cirq.ops.common_gates.Ry circuit to Clifford+T: 0.4593636669451371 seconds\n", + " Time to decompose high level cirq.ops.raw_types._InverseCompositeGate circuit: 11.808722625020891 seconds\n", + " Time to transform decomposed cirq.ops.raw_types._InverseCompositeGate circuit to Clifford+T: 122.48608425003476 seconds\n", + " Time to decompose high level pyLIQTR.circuits.operators.reflect.Reflect circuit: 0.016667624935507774 seconds\n", + " Time to transform decomposed pyLIQTR.circuits.operators.reflect.Reflect circuit to Clifford+T: 0.5113535419804975 seconds\n", + "Time to estimate RuCl row 13: 384.14998012501746 seconds\n", + "\n", + "\n" + ] + } + ], + "source": [ + "#Commenting out range, to avoid long runtimes. This still takes ~20-30 minutes as written\n", + "for i in [13]:\n", + "#for i in range(19):\n", + " #defining precision required for the trotterized circuit\n", + " energy_precision = 1e-3\n", + " figdir=\"QSP/Figures/\"\n", + " if not os.path.exists(figdir):\n", + " os.makedirs(figdir)\n", + " widthdir = \"QSP/Widths/\"\n", + " if not os.path.exists(widthdir):\n", + " os.makedirs(widthdir)\n", + " timesteps=1000\n", + " H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i])\n", + " H_rucl_pyliqtr = pyH(H_rucl)\n", + " \n", + " print(\"Estimating RuCl row \" + str(i) + \" using QSP\")\n", + " t0 = time.perf_counter()\n", + " #change to Clifford+T dictionary in future revision\n", + " qsp_high_level_rucl = estimate_qsp(H_rucl_pyliqtr, timesteps, energy_precision, \"QSP/RuCl_circuits/\", hamiltonian_name=\"rucl_\" + str(i))\n", + " t1 = time.perf_counter()\n", + " elapsed = t1 - t0\n", + " print(\"Time to estimate RuCl row \" + str(i) + \": \" + str(elapsed) + \" seconds\\n\")\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "2ff5148f-2d2a-41c8-b71c-a787f82f8d32", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total time to run notebook (only using the fastest row): 533.9890611250885\n" + ] + } + ], + "source": [ + "t_end = time.perf_counter()\n", + "print(\"Total time to run notebook (only using the fastest row): \" + str(t_end - t_init))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "09c39464-1b86-4369-8f06-b12f4db46772", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/qca/utils/hamiltonian_utils.py b/src/qca/utils/hamiltonian_utils.py index 904c909..2da67e8 100644 --- a/src/qca/utils/hamiltonian_utils.py +++ b/src/qca/utils/hamiltonian_utils.py @@ -188,7 +188,7 @@ def pyliqtr_hamiltonian_to_openfermion_qubit_operator(H:Hamiltonian) -> QubitOpe open_fermion_operator += term[1] * open_fermion_term_op return open_fermion_operator -def assign_hexagon_labels(graph:Graph): +def assign_hexagon_labels(graph:Graph, x:str='X', y:str='Y', z:str='Z'): for n1, n2 in graph.edges: # start by making sure that the edges are ordered correctly r1,c1 = n1 @@ -200,12 +200,12 @@ def assign_hexagon_labels(graph:Graph): # now that they are ordered correctly, we can assign labels label = '' if c1 == c2: - label = 'Z' + label = z # You can differentiate X and Y labels based off nx's node label parity elif (((r1 % 2) + (c1 % 2)) % 2 == 0): - label = 'Y' + label = y else: - label = 'X' + label = x graph[n1][n2]['label'] = label From 04e0eb3a691c3b68b387c917364a1804018b6fea Mon Sep 17 00:00:00 2001 From: zmorrell <66835471+zmorrell@users.noreply.github.com> Date: Tue, 5 Mar 2024 08:45:00 -0700 Subject: [PATCH 09/11] RuCl documentation update (#7) * Add documentation to RuCl notebook, Pin pyLIQTR to version 1.0.0, add local field term for resource estimates * Add explanation of terms in table. Fix appearance of Heisenberg terms in VSCode * Add Zeeman terms to Hamiltonian in RuCl, fix typos --- notebooks/EmbeddedFigures/RuClLattice.jpg | Bin 0 -> 63556 bytes notebooks/RuClExample.ipynb | 133 ++++++++++++++++++---- pyproject.toml | 2 +- 3 files changed, 115 insertions(+), 20 deletions(-) create mode 100644 notebooks/EmbeddedFigures/RuClLattice.jpg diff --git a/notebooks/EmbeddedFigures/RuClLattice.jpg b/notebooks/EmbeddedFigures/RuClLattice.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3a891d74b7d10eebeb00b036b6b0f75cde44e96a GIT binary patch literal 63556 zcmd421z1(xwl}^u4HA;lpfp=RxFmr*udolG5;P zd|y51p7)%4?|1(9`#*Q`%r$?EHRs%G%r)njV~jc0&D6~za92)BRtf+ifIt8U0Dzli zECX2yiKi-R%2Kilk^r0xU?~_oI@%)K1pqsHS7$Y8acUi1J!;eq00AHX&;c@l%h=S# zQA|Ze0p0=dtGva3OFt%lb`OlQ-1hZ1`hN@InVGwo0szPWUfaaX#ncXtKf?2_siU(i z03g1D(`npY9dGd%91}Rh9}tc=Zn5Pb`0^H;{KQCbPT+Mk)Fc1^i539RFpZ6!Edc=Y z5u8r#W@-uV2U7)(AK9B(+rx1H9E+G*8JofJM>u|HXXkK>ci@;2Uf&TuMg(xoXYzM_ zTK*k2Ha7X)zp=69Z~O;e@Rsn0cw+71Xlv~G^Pm68i=8bLK6XD7J^YGkN7L!d6fj&0pBmMFKvqf3!6-ej@)1+uJJLzWbkjT3AcT{=(L- zvKqgzxr?OwFYN4~_WQRioF&A5(T$zq=+Azj5Y69oD|6Z3{d-wyX#c9?X04_43%fwn ze?O0xmBeqlGgR&O^PAgCi~p)`;Vku=cRLq2_0Qk6vX=eb*40Ww<`>=6_;1f|ZZGz? zK3#NvKbx8P6Ukro&FwXR^Xup;{`z)tt)(T{_4lkRps{> z+8E2-&dZ-|fhT|@paB1)22=n}fD7ON*a7&+xSD&w=Pv+AI5>JbTU%PWQj5V?oH@0u zy(#NMYK})7TmW#pesAjlz@ggDbqON+@Hd)6E_^EgfUlpJztK$M0iZ4v0EnmmMx)ID z0Gwa|sBJTaI=lVRAJT1s3}65_aM?ftPy#dnBftWGHXc9_cnp7HIY1fE0CWK(z!b0o z>;PxL9q<931EIhx;5Co{qyU*f4p0b`0aZX9&;+ysT|gf&1dIbSz#^~;Yy*4158wg> z0-=JiK=>dM5EY0H1O{<{_&_2cNst0a4WtWt2C@X%gPE3g$^sREDna$2 zR!|RU81x0S1lj~0fX)#R5ik)55GWAn5!ev;5X2DV5i}4C5iAj$5WEnA5uy;@AY>zy zBGe+ZBJ?4QBP=3pBOD_Fh<6Z)5bqwAdMm|A?+buBV!?xBZH9z zkY$l|kS&qjkwcLak@JyZ$eqaJ$g9XdP*6~aP#92nQDjhbQEX7WQ6f;%Q7TYAq70*~ zpd6#3qLQG3QH4>JQH@buQA1IaQA<%bfnkI39ODf}IYuYOEXLuT zJ9i%3;lHDL$NEmdoi}&h-T8E9>CPD@9wsxU1f~Hd6f+950P`c}7tBK}EG&Ag$5?t; zu2@l6MOf`v^H`_Y_}Hx2ve;(W{@AJ5wb&!ryEy1LbU0!-MmSzLi8$3bgE%{P(eKjV zmAGqs*Y9rX-TJ$ecaL%LaoKT|aqVy;aEoz!a5wN!@#yg+@yzgo@pACm@mBB=@oDfS z@J;c9@N@Ay@mC2@2p9-t32X>n5tI=O5bP1+5poe~5qc1&5;hYq5+M@N6Uh?U5=9eL z5ls-C-=nxEcF+9Y%X{VbM(&*ulMz2AHYW}zt{@&KJ}03jktBhT#E{gH%#k9IGLx#3 zx|3#*c9QOp5s(RznUaN*Rgq1TBakzbtC4$?=a7FUKc=9hkfv~?NTz6~*r6n%d`xLW z8Bh6va+3<5N`%UqDxRu^YKxkXT8!G3`VDml_1=B*`!e^T_p|N~+`o9h@IdoH;Dd?> zb2Jz~K-N0eT{c=aJ+>IOZno=3+>dM@srby09J&>}LDv{cg=9c!B{wRYiBQFypGbu|UYbskLyC=sh=PTDCk14M%pCZ4k zz^ve`(4dH*D5n^wIIBdbWUo}G3@FPg$0^ULFsL}GG^(Pgs;H)_uBoxB`KWcPCVZG3DZYm#QNXDVTu zWV&tk*eu>`(_Gj*)_mPU*do?q!&2BX&T`XA)GE z+g8}2**&wXx5u-G*mpQkI(Rq?JAxfU9T%MhoD!V&oaLSKT|h2|F7I6l;EK{`C?hlk zy5uI}mg;uuuH|0sf$L%K@!6Bv^QGsymy}nYHs0O^3j=NQi+&-()(1;z#*1!)I01XBbD1h0fhhm?e3hdPH&h6#pczCe0m{bJxH z=gZ`m*WqU2y{{gtyO@5txnPQbPo+_SNkw%{OGVLVYEPW*7 zaYlJ2Mdqu_^S9P-r?RB8YP0FH6LU~<+;Y}(wQ{@j`0|SKN%LRjUlrIFEEcL2b`Hy5E%AOxPU#0pmmPhnp6!mgA3(A9q?U zTUXkiw#~Hbw2yVDb_{gNcYf-U>T2&6>u&iZ{Hdu&pr^iXtqY`^SJyG>ur z1k57OhR@xdOPnX4&t70!s95A#Y+ib@^m$o*d1l3QW&5kk*UQ!5HLSJ7b*lBE4UUbb zO{vYHE&Z+4ZO844ozQQ%-_mv&cWb^s{{DGSXK!`idH?1h;*jL9;E3y}?O5e_{)gR< zi<9tElGDO7zO(Lg?ep~u_e<2vH&;wo4cGG5vp04(H;%^6#y@odMEDiK!U6ye3gG&& zE&$*U0RV>nANuvr8h@A^w-EGa{wMek9sKqNT!#R1CILXh8vqpg0U$XA0O;ZUk47cgQLpFGN z$SWu)c$@!Bx1E5n?%ct?gN=)WgGY>ui;H)UjF^Dn9_2k^YT|p8bd*069S!4cqIviT zp8i=U2>+iu`3T^mA<`jvAOa5n5H1J-7vZJ@pn|_%WVpTtPrrr`gn)>IjDm`Wj&TQG z0d^Na03jkGAR!_nBf%9&kT3i`fP{;Tcb{Dh1z*(|^??%s$McvhG#c^BRzkJmJz7o^ z=RkA}qI<+7q;&KQj7-d2+&sK|`~nhBB&DQfWaZQ~G_|zhnyRUpxrL>bwT+7_)Xm+) z(<>-ABsA>B%kbE^_=LoyH_0j4Ik|cH1%*Y$Rn;}H+Pe4k4Q=fmon76ZdU{7j$Hpfn zr@l-tEw6lCU0dJS+}b}lJUaeya(Z@t%NGbh{DZCEoc#k|xNyD@kdP3OP;dDHA-Kac zA}$j0eRdQ)F;!G!C;SH-&(R3PW3nn+(P=o<_6SX!hcSp~xt8emZ&~}v*?*6*z<-Og z-;Di@uW0}iKAAzd2)KYKa4g4|9f0wd{B{T=FT?m2IXj#Y`2Qup9``QUco=FCqrPQ@ z&`;QBTR2&KW%1D0C~9cJoq$NV zoF2fK9sV;jVX+VZqbkBzO^UFuD$=&&K?c0hT>K~wiwqH{K<3Bsk-)Ul1(x$T20NvZ zJB8>M6^SNaMBRPM;dtk#2BSviAgh{CZNM`Eo)MyMQ_(NK@}s4%pQg-R1s~stn{o zXb*E+URnUEnoYx&TUmr$fiQnLxZ98VaA8NKvh8a<#iwr?mn2yqN}SevbtFlUFf){m z^-Bdbu5#0xUaU7(ZklGq*91M6*CApdh*v=vmLvdF|1QUerps6%X6|EMt);Zd)JH`5 zMrsW=DbgOIt#^@Sos>uIeqp1rnl-~U@-Li{%~$G~axR#zFOhTon&K`^`9PCNR#DXX zg7O8n^?2A)*|VpTtMz9?&n}|%W*7*Y%<|*(DY({(C1q_pVkWpBb_3cp{>w#8%hZU^ z_)sVE_eEe6(=^v-#UkV*SVtcq(Q{ef$5PsIXY+cnux-Zk1j5sKw+2$5#IAYx^hF?e z;fU#JjFWj#6parh#BM=5xnk{in5-G|*{%M38NXi2KP&(F)ca@C@$YF|HUD9_{(k8G zC$SnSmW!X@KHpw{kW9<=Q!w#Kw;qtS;_%|psUtDVK3yw?K*;%I!n}?9`BA9;OY~V; z3;~Qj>#xlT1<9`jd1OV7^BkND839t62=fq0mK4)G{Wvuh_LLka@5VepBSw!>WifoC ziF+UK1`vlzJMf5b;LzgOtgR-w>y^%CFd}Xm-Z6shV>Qg`^U<7!K}AAqO4eJDJc^%U z8s)(49BP^7ciz{8-+xTv&OM3kat9Yup9jqc&}YXc{$9^`$wKl19DKd+T2Y5aH{Rmh z-=_?prdxR;b}&QFIfHuYm(vV20`^g-O?lMc&1P<0OjW0QWcSQthsgX5|W#PuRkrH;KPpL zR9jJ~DoOa!fOBD_xo=6N6iPwU>(Gq2b14wMcfePnddkFUu`9at$)P(B@XBMMBLHet zB>{rl9GVyoNElE>UkZ7QQ9nK3LfsgjSErA(kdh|RLc-lbTPshHRsYuSixTxWvd zS0m)HUU-5S+b~5AVe#3{05mG5Bkq1uwc@lNJC0Jp`{-jCSGaLYc4nVN`k2lF&Xfy} zF2Q+(YYKFgZ*UrEZT$tlyDF+eWe{(GyGvnNWsDjv4JT5kdIPef8L=;OBnh;|CT@q3 zg+TQ&@_&)h{~4$MHSIr&=ywLfwp-NB@s|Nj<=0I2Y z!Ifw?X=L)*l$b(xIqP(DLbXw~+U7M9%@1J= z2PM!~iuR>i%fqt&J!byOtlI6Xj9QXX1Xxgt3~g$EwjZuBaUnVR!)ycZ!D5-gu^8j2aScW5qw-)aAM1G`{=9xNjP4FVCjdJBIC_U^T zdtbj=XCw_K3p>UA^o3hbE>>l`l{g=eEr9GuXnB?Bz>Mwfb+rj+JRmAbZ9838X{z{7qgNJl1C z4irfjWh^xc)^Ih2ZL8vmhJ@yg&m1LJI7cPiL0WSlLJSL{VO4g_j+F` zzw+Z-%w}(GLuLf&1=|p+iT9}xPbf(nw(iWD=tM0P>yG-Eh4oWQ29UesJ(%sO_Y(m< zPT3$DD9z}*a%(B5xkVX);{YK$x9zCPOMj(GMG?Z6C;<6I3QUFx;u@(CC@ysx9&Q@q@fl9BkbM>(1;nCZ%Gr0URg&wz}Z7gz0L5qMlwR zm<0<#g!q9?$V45)I(--Yh&+WnhoWnhcz4H2)u3!WLRto2WUWg2rGrEmTbGyHxt0Si z($QF(N3Ww>^A*nHx0-e$-yGh`YUf~7fi*_8rN!N4%TkEK8S@|g3mqTy&(ya6ipF#+ z2>*UxlaQCO0^uMuiRz7|tgF0_8QgzI^}PG2!ciDJaJ&#UT63Ui7pg`3ZKGXiQVH8J zIFl3hgWhIiMQwxhwH#&ap+tS93Ej)djFs?Q&7l?UO({8j8Y7r-oQ}rp6jQ6oee9*^pL>1wF97U~(GYLuNTHh{6 z=Y*!Inlw#^3mGB*7B-fPGV;B>Mo)rb?)qEMP z$Q&WFJ+1nJ&?4+4E_H?Njbb-FSlRh*pr-Nh`f*9%JL|IX@Y%m?>+qctIXjMe`0<@z z!c$gW7A}3&*b&PB7D6RowRvokE=hBP(>#8i__*!q>I5BWwS|HF zqw_t>yL)vXR)cJv7L& zC<2<8&+0yR`I3GtFHUG*^F^Z38qD^{)80=*iuMBcd{Vl=gK}8~vxE9*3!+Ilj7_jE z8p<}FX2uiJFp(Y=BHTl1pdjV75`F~6!O)#LkUHF&o#=3)HDG>zL|mfr^<-!>6h&Dt zwk}pkx~qYEB9UeR7l>}+Cwy-CprtSKy4m-hyEWF49l<9G9cQ#p6?~H)@UrFXAJSpu z#754vpw!ecTV_e68TV0)4}aGCSjo7OQX~5yM}s}KppZ{gRaqDuYIn%_?cJC$Df_Sw zJtYj`{X|E=UMxXmTD>%_vZvaGf^zktIx3P0Bff$+MSWku?Z9tyBw4#wBNx^U6F&BBeTwCe` zDbl@5(eXkclze5|AVqGowP<3`5+z&1RCv5AkFIhv#lHg#PJ8&VYvIl1c23 zTv^Oipg;4zSpsEl$o$+%JI#I6%1#$$qy|BvVt3)%*ON(`*F0mkGT3dJCse%ahDzxx z+u(OdA3NqRqX+(&?2=6M+Ww(GqCU?0 zsc@8y&45dMS$|m|6H7>LUUqI4W8R$hBhNo-6Sn_d>Q zTu*o1CE^^hUp~#Wk#2x}ZfZEcI)sG2UVniEzXLtmMJGwGb9{0k{`m%$`9txi81;kd zWJ+Wu7*>p9(D7SL8^IUA9R_S*Z>=Zi{2CvWc6P0PC z?Yb6?c7=EFJU%ju{>wrn1-LdQLj|q+Q$9z|}hZ~*euKD?t zvvqUHN{91%%z#c*!l>4!F2!&(vkY81B#Zr$1OHGW{5v+R+VG!>@t+DZ9YKu>f+}3< zBJdkWIcknQ5`OWiR9L!I0D3K>{P4Vja7a~?q?c{Z4W-;OKW}e(nfwj8j4%%BLAl8d z@VH@gfG%WmZ{@JUnVbBbv_JwB6UVgQRf2@?dy&wKJ>hZz*F5|xXobO;5LUs{ufdG- z#U7U>Nn;<#3}#l}I#C}Dj2dd}yRLqS2t#p}hjz-*Ve;oS5AE72(Y;KXjS>~e){Oh$ zpJ1DtS8NrfPl~pRz3N<0iHcHdD`Z-vv*<9NQ|)5VFiTi8vZ0p1I0$uYO6<3{5xdwJ~l*T9UDnH58i>RCVDBBW=s%~KE3KO(Q$=RW!ppTZK9Mp zowtQ-4)@=^%ujE75D}|{Om}spXN%*+Y4=1;w&KpddxU+HrsF4c9YkXd*Y2WRRKp4% zBaAK<0hZIPZ=-vJy>lLuPg_K}TUGo+JP5_xMz~az_>W4eXl?l3VzkUObYP-2_z%=P z^kdj|!xZYqd)`ItayDUmfO!|p>b@2roY}U3w*zZ?ka@Q+4Nyk9f>f!Yed-b}S?#h5 zbKVoHP&$RItXmk0oE=W{3O5%bju#d(G=|T)a{}zgrLQsx+TOl+&M@nw%KR>L=cN++ zTxvmh;PN?{YBDj#*K$~6Nq{>~>jszu^0BEA|8$aTA7TZ5qkNBe2g>__USpYXZr4kT zd!o|C*?Gi{GAPgG5F$^70T%GplipOl*lKK~fo~6LGkd&iO_CSgnFfctC!|Bs_mNGw zs$^W^l%o1GGpvi5AS?=WyexAs3&zdk$0*HWGrd~ua(e`UqBuj8%ti0y0JdO~?-Mnu z@@BXNOqc8qpT8z{rmb!rXGB@@J+U}iZpLnJtxbGyNjBv*G0Rh_AMxP%5ur_5rapyA z>wx^cPvK(C07EZ15ioT{33!rAuvvS~e-9N1SW#Y4{Z-0;LqRlgf(V?>-X z$t9@K%(IJWkhLv^8$awJ5}q9#{_p)06jkQ^i{h@@FN=heRZerZqDfw7a^C<84(oDW zYVy~xpHSN7Ft7f{k$-SAhV-?_x0dZHe}NM#zvUaCK{UZb`LcP&f6~0dEo_(JBIiuo z94q=we@lc&IAd8f7ZVQGmc(O{x@*eHvFC?bYRWz?1`}C((+|*V65?+FXgyWB+mY7m zGCtd>dUc^7mA$g-4D>|2kM625Iu$m}Xw1G?-mSnMMBoN!{~_>N#FbgOkeGWE)8#2% zOEPQ9hDWNtkiY9_q9=YJcnB&Q2J(Y2$=m?u4SvwiHk1@CqXYB-F;}Z+A+Bvr4Aqm> z_d9c#98mKVs&X*O_gEeIxJjN*zJ_STjU`&o%*tD}X2raYme8*?5*&N@5zj>R`$?ri z;K1;4k=h<5mZiX>jLk=CR>u^g-HE*3PwFEwzq^(P&hL_CH85ZcM?pF@$G3D?>0ypT zy**Ju?nmX;i*aA3Mz{qtCM7-dGgoFV#EBfMDk|onteM=M@PnUYa{=DXZZ@$hVi z`iqan3CLA=`=X@d%L_fn^`uS12)xjRy{q-Ei}8Vx(2`#hF3msOhfao<%g$;c^F5)= z$gi65MR995>HHe)>gA)Kn*U?-7@;0qL9u-@XUT|TekN)0Wh(o?=0Yl*j{u~6;jbO> z)lkF_mSeonrawB1PIvftr~Q1wY(^txAT7`eajHppU#?pNOfhiZ8PyQR*^);?2N;`k%{AXzt8%C&ODE)X^81Kypc7#qO}U^vJ`vTkJ9amyVH6>Nk}(9 zm5bUsTsK!JfM0CX4cjo|3=-BO%={Ax5N9V?Cdyn~{XOq@PZGvgqT3bq!?!U37Tp;` zkHC?!*JeoP*bwZ)E~PJbsVUdXoJVFKK!vVhYKAJ(^Hor0Wjk!$6`QdUj88KSZSeq)1eLq~{!uVHFdei6TqLV^@b(QGbxc(6DdQFoGb-eb_FL+X9A zU1gE8ufW7^^4^KoxLo3^KJ~dMQMnPWSOKQRY*=Ex*?BdugeH+}`HTseT_lKmi&VKy zpHBo*j~ThaM>uJHP5Ew=0PUG-)M-x{0rne}2si0y>lU2jNQEMHPsr9R>CRC_aIGUS zsm2w#flbu7-%S8BC>*AZ=of8o@Jj>&k)HaPO}vJC0x=o06W_G`Cmt@Oe_@{dXGaqt ztAF8vW@55>iE%3nH32YfUCuB01& zT=BGJPbt+qmgZpU#0Z=;E<$ENuQ&gA(M^bVq`^2MxXvfv9&<%)tpJ~i!g_KVc|ODG z;lmcyP8D{U4=oAyDX|Ui^{fwvqz^u^SE_FbOu)ikakGdL$G;zxJ}XJq4X3nmZRlre zVxb87Qo9dvh-CS-?T2e z<0CPV_&R}JDQs}qFuh|Z2gG5g^do)-tXlxrrBSF<&N02h%pg<8eN!W4S=T$I&aR;P z9Y|Iru&z{y2I}gp{p^H%oQ^P8tBXB2|LB#UC2Q@#B}_j|p2O58Q6#V#Re4Y2Zh!?{ z^rn98G_<*}!|C}^u}XZy)MhA#^MrEzqU(2*+1Uiv#(QHoK!_`k2wH8O-AL?LN|_EAvx06^tcGa<~9hDXV^f zpeDWsNI*Wh^zOS}@n^2ogwfB~G2H<9c9%u+mKz$}@xH1nY$pp>E0>!ylZ2R&Nv2y} zaoit|MF!H1bn?E6`>*WITsJZt-b#J8TdDs-jOc9fM}qRU(E_OVCq;?MbiMioOpE1M zVk0|z_Mr2pZ(dH1@ej2(WsCe-#AxALOker7X}^NcF~HPC-$CX`eds4Be{@lWcvUv z=L>g%WqdH><5HD>Yhw;|kSm;co0)W`E>stR$GrO{ykT`LJaATS#^uB%=1fb$_U?M# zJ+)-=^@(f-gr<}cwN#7Y=18>fa_+fFDlEGB>N4o`Rg5(!3O4uRVPxpJRvQRB{8_|V znAm6=Rx||hppA3X7v5S^8gKOYKj<|(0Z5RR=2nYEAZ@oCP}V_uMo$Lca~}r}drL_JF`@t%aO4{OqK2hDrs0+&r?;7#NY8C^xcos z190UfRb_R4nmBTLasZPxlhuDFm2U6-TTYd~cohEL!SW9nZcudsJTi%@p+L}7!~{{! zVj0g3K->K;W4qH~SW!v!%M=dZ*fnWCrD91KWn^o)zRKS5d}ho;g=S9*@GMj8lh_D> zK;bS(HeXMto?h&7^1-){Gc<@>HUgU;s5c6v#w}DHMY*%B7z`Oq3Z>8Z_D+dS6d2Wv zhi7oq1iULmE1Z)q<2U0gG>Z)-y6;z0d1WoKznotA+7ii+0B!T~POfa3;hUU~ZC~Ry zjq)rPWlX0ne5ZBZReTUi3r=TEeUk5P~HvSz2x*|%`qhyy=(Zq-_tiCZ8~k!;V$yj zfj8h)S)n~#Gd^NxS|=`}I(B|i++N>PJ2y`=s{tEx{O5fcl}cp5hG zHc&s}sC(0(>g~C^a05v*H}W8rC)j#y#fLXnzGR;Iu{aHaejP>0q^fuTsSV~Q09+iMWbJ((<3{Z3`Sw`u5kNRD~wTXL~ZCVhao>bTih$UD8z_6Qr2TCC`5US z-vm|rh-=xe>CXJ+R$=~Oym!0$Av~7|j-hY44($G|!@69qns`v_ zrPf|YN@vQPczx_$XJM@-3-(Nd^=4o3E%LkV)KM-YO^w}Dn1<=!xmqU^UqDYD1PC2~ zCFt4p5ATLfV)TstSN^Wn%z*@fvRx&okb;ohVll|n@Q{zF9YSb4s)NKd z?7M3te+vWQ7bOL^(S>$>A(u+Qo2?zONh*n(oi^9n){|Cr{% z(eX+78|~;;#~&lKm1!LBS}Szly_ppw4=bUjuPflCv+&X(m#-koYw}8jtBo*0gul}p zk#f0UgyX$>QX`)ni#cSo8nNi-5_by9w)QtB201expGg<(fP2e#ce&+*XjXIG7Ja?g zmb9A0%H_)k3@$5++SqKpuDQof+1jZrJ6C%nPtOQ$05stnfOI7--BZ_x@uYAxR6Xp+ zICq(Fk^_x$TL!ry5ygQEXMn*uyeIu5485&DRV{r=3cczwUjD|OW*xN=RgK4LyaBpYWt>cG(PEF1gsp37%DhbS!@G-k=X7beTx;MvS*oCpyGYo4W6Tw}O*7nR=C0Gl*K6qR>$L35 zACgejxOk|$h&M+Lsb)%`s^RN%#%vg$c;deZ<$?R?0`OjsOz^&f@r=}L<|#KvzCFiR z0w?FqJ#X`om&a1uWeMYuLUR_NvRPM~C;q6Z8Xi&2-iIgKlZO?4T%;25AaS=_Se9Q@ zJnuLd^&z0HqO;Mp7r}$fn#CT??cW|{C`x*G2v(QvmKg0VY{%73^vW;iI(>$-vZ?Dn zEw7Kc`-$)i<#AXE&RohN(?pziMi&EX9;sTqR*7lSW-B*qW`2Ls!0X3($)6AjO%;b7 zxQm)ftiHSy4e{oEeu;W7)D*8jEWI-Bi*E?DEIQpkrgF&;SxC^BuxjPLbNATEWr<0+ zp2_b;`LD*|Kd~|XpYPcJa9kq$m|VI;k!OMtZ`A}rosk5QWVv2m^CnVv=^2l?E!=R>@=JG z+EwvJDVexWL8^nZn^?yH z>BJ$=OlAbuLo{6c21Gfh`y5|qp}y*{%Gv9@wnz%P9!wekQFx zhTv^lU#ebyn#k9&MhG5D^Ai@-QY$0)*5XYOe{eodoqzT$uZ|OTg(KN7>3&_Te1daO zN`-m)LD=?;gSF=|31y4iT;mO(&TtWVSv(e>Jv}LbKAetGjIZUcN6E`}{zdfG)nr{2 zJ>PQi?Q&B;&+}mRLXWCFI!m_Ymx%%W)5Hkjz4X2HG{KkpyQ|I{z}265C#&+1q-8&B zSdy@E?f2o*e{?Fx!vm)7^O0}?FlqhKt|CkB7B`9L3LEW-(j4DN4wR#QeQj)z8rm_z zab)`QlAN|(yRS6~*$Ixlj#B)~ITfZ8KJ4aY6r&7-QN-k=t9hp;7a!!K<1<#$d?CXH z5kc~)QZW%lb(QU6+5HuR6iwiTxGBs7h?F9q)g+4z|CCe4_?8IO-s*?vBsymnTis=z z-^20yCd?_DCez<&YT8e{_`#v<*4)w{4xv%)8qP=!^-CyU7^#AZ9@`n2iO~8ILNAIc zXeOI@3ubh`h(C*<-x!NUWeA@T(y|QA#oMecy8#r`&$N;&Bwde0IK1SHN-LcF9c&&a zYDipQqH7?m7joBPT zzj9rFZodJBH2e|A;FY5!5a`Yp=LbfXl#f~sL8rL#>DuLRnSQYQpLhaY(GbGBGSk#;YdFtS&j*mR~|V?{=ZiFxRsZ11tc_pPxK{DGE34H zB>jccsn&Xj)SNrQIm2y`0ic0#!qXUy{~zKM%* zgP%IC6F#M79F53)C8yHsN^zZW=VMwf7PrwpJ`|3WG45os@Nl!pXhZR96crdP?<_B9 zBypj=c$*!L#St)p^9tIYJ-v!LaHjd=)eDm@84C!c zxC7qEf3fJHX(Nlv{lh+=tOm6)UNt52OS+|3O+ z-BefbpKV$gh(9XKqZPcU%-!-I4z_A4(|L=I3~RQbq@Ti=d(lMo66+TLq3CQq z&wxOh6_MoS2Id30oKZ+>h^Ipo%>guhzB1^1vdFE1=QM7u2d#tks7 zox`C#cRpcv+RJT?9ki*z*8Qn{`h8CQ(J?gm3P)v6A={9C>ISHc?yW0%bLx6g^WrMK zq@Y4dkWFHRc~i}=lnJdsO`X~v+4MB-sUjZc^JKD+r&~7HMTMPtk4JkQ3H&TansPM8 z=_l+J4iIACBlaU%cwR&Tr4Xj+e{c(Oisl=EipEU1XtuRVnB0n`Uk|50W zrR4w~o>DgW@PEG)6q@Xg{XRA>OhYwLP2dA_=wfTpaWF?HhI{Om37`}c;kPF}6%WUwrZSpcTAj}HB;UdvkdG%$eWN)A{f<=YZbS8!V+>}> z#_Y%<0>RJsMMCHTuv<7{J&%4=h<8f6*eA)D#z-)2VM)r_*j%ZG(%_Kp*AC2Nh@%N( zyJ*$)^B8KGhjXupvhSd}7&dyacJwr&Qq2t#R+<;I7UWNVhJjP(pTm zY1|ZtWSu-}xgva+Ya(4ShmOv5H}Gdn5j;v0?qg>J@*9!WWIs}DjuU=z!7sc z)av;I4fbErJC;4TiVu{uhw zv3q^ucgZcQ3aJmj8>J$N6OW_r6;iz}%KI*7XH8@mpjQJg^Yqjz83}xjjDwo{t)LVut zY(;H<5jXd-Pks#*v7;Ixf{0eQ}76I&GqsQIa-M**+HU89S83 zRU_E=o@k5VWtRjKN|UMX2*WTdB}o#AiN-OqA8bd@FAKW>qwfxi`u9&ia>uy(d=+_= ziJhW2_z5+@0(kD)%C1;UG##MtdKqMUK^_^KW{z5nGi$=pFn8&tf%G-|zHisNkeqjw zVM;F~5s+1<{Ph-aUq#9sbmF6N?aJEOC&rYjMldr1-WoNk28=`C!4EX$tagJJ^vwwG z{a-p=zT>@kI#OM>$63wd*70#oeV0Y!gAvY1X`6Gow=`P%nJ&TKIRbsqWz#6-)jMSPS7Qk8auf%YavOHMJVTj@Z6N64y$kqP z$OvhC*|80YVJ~i9*}u@U|9M<6To?bhf;xUjJO3Hf@iX%Izk@@=B{~65<(E|b7!ysW%_hKi~r9YCnB)RTsAmtGKi~6!ndw27= zIOpgu+=aP$Wzj0X0uh;T2;gcc)550Kbjr^A2)>h2r$rV<9-pjerSTCpT(u>l-SK|o z7bS{%`0%fMz&e|?=gw%~R?t2Kmbt!FH+vQ?yTi266q9Oi|E->PL6tVagv10mflKb` z#4p_`_2-i*r>{Ejw~~}_d%Fq%?9=bM4|M{0>qL%&_lewKgO)fky=B}?$_X%U%8{rl z%p%lHr3%Kq?r@6{2h%{^JCgUia7?_kOAv5G#%t&X%01tt3AQVCZm+Sh&=E@g<@=w| z`W8};hz+e)cr1=S!<`*rNUo4}x{ngfiHj2+OV*zm<)UZ2oTo~!aHO!3;U1Hm{E{|S z_L%F7#eHim?lF$nzTn9(qBM8rwpgDp%evZ0G2srhEpn^}Wq{|FUdx5AWT{B6Jmt4` zz^VSb`WSA>z8OjF_X9yR)Z>04=PHnV)sFp4-H?LHR?lwf+sRb|Y3XdK> zfm%iy@eK+(LI%hE59nl23?&Au<${*lE zY014R1>rIOZ-_?0kk8k|pQN&!Gk0*-z{9&=*~NDRLTLRo7nEhFXddr8>!B}$V?MVmxCF;i{tIvy22LRL;WY&q4@_Mg=gT{1Sj z0i68hHqJY_vxUOqO=)MG6zgV>lo+|!{rBFL-vIAh^7MzBTwDsDirMZ*R>kuDAjz-9 zwf_{JtVEw?kVg=&Io}+$7O#e(H?;`YQ~s~M()b@e)Bd#*{#7Yw8-~$6HChbLsbvs( zvCtdJx7)0IKe=h9XJ$gH$dXS&Gs|v-A0F2TH!dn29bxP8?pwa;jMHiNPE>=u?#w>U zsFo7dJ1NxelYASCQ&%+j2B7dWELl6uu32LL^r=J6T&ZK}-iQex7i0sXiuO zcqzoi_PP%ho4?zloTBC;-Z?|veo#TXT%Cv2CA?Q7&Rvfjy2rIGpSom;vjjhwk$w1z zdt^xpO<8YORXhTFEIYfgL7wk(EICLc`)y>AN+_j(^<12)f%*6F_4l-52Nk9Z+X|zX z>Q0bH`f(q4gzB8W9~GW=u$hR|DW^;d+A#Cw>c$JC1#)1?fX!jUL+PDxtCjdyh@A$n zkN6F+OSP&trtQCFb^|!VCog5E#By}8kj2yED*q1)1EJY}f}oM6$v;DYo>&~fkAB$> zD}MQ9f-_GqYj1$^zRT^otczFI8`qj&Buv*h9aeB|zx3%R3YTL9S>@)zCx{#)z@=r; zQYM+L&s7mQbw+T)y`Ch(JouUESzPe7y(J&P&KDD_ws9AT>=g`b2v8Y!5gwqrH3QAX+3HSvgWPv-mFC|;)fyz z3ftTf7Fkh?F$uXt#5aJA>>UwP8iWa=3^vnn)NO}kG7-9L0OcW3NvtJCUmL6&-+Un3 zi_CvcdN-hdtbRMqtvmplomfwvmg-PsEJ>gSKe*0)i%?(j0{8n!u1ExyD=cUw06WGh zQ|xlfa<4_gKqLWfjJ~9FvOGZ@Qsq_ditXF=LrC;*fDF{F`NkWL9C3+I$gXY;h&Gc{ zs3meI$nlClg7gSsUvPI&W`%7UH5(pX6Zn*ymA!}=^l!t;k5y{#VW=ph+6%G{J0-h5 zFAt5)tO`5Gp(0iNQzP9KUf~cNa8@Y=(y_2) z+L$bug)s6PQ|z`DOq2g=8SbZ<{$Lj9X=|>VZ9;*qaZY;Vk8x@6a2q8b1sjNwUh0RS z9h8vsrAc%Qrk8MzGubfa=_VMWF~g6b#89(}Y$6bT3CPzY@Xvw3gV*M8?kwMRF9;=waBakbSyoNZ??n3;{98B{kQH zjj2l7xc&MH2!3GvN8n$vP2k0~@K^X=(2~GV%}hlAkNi-+u2nvnIUC7{pX76g&#jhp zCgbqKT$spwLIU@On&|$S1KhO`b{qY1rRRSe1Sq@w5Ah(sqX6MDu^%rS9`$kiVFX@Q z<9m6T3~fG5HAO{D7+B2L?jg(YQ1o7Y8PvBNH5wu?-c{!~D(BII(HwwMgpMOeA5xa< zk!GCmf@Ytq)#&qscr|_U(dJ|3t$Sor;88z*vwO|#I@6iZ|Y z08faJdDtCc3DvaYDZnjnu_rvcbjJmgGOn#|HPv3u@zH@qOr53rXp!pcGZ=@9s!zxo^TMY% zXgeir-lj`xOIhS6cGeB(XuRI;Xv(PiL%_3)B47M`-`6h|V?TrYZ55vNkJGUK5~GIv zg)v)iXfb3Swd%NarG~8uTm}Cy05SoF`K0M*a{0REwEFJEASbIQNH0D|fnMvZ;_ar^ z-@joV8MrO!p+{w&!}_PT3WFocX)ZrTlIlv-Moz8WtQ%{u&zOrr9`ZVL$uIDI><9WC zpUZXMlLT#mQ%+N=20Ft{mM~|a^4BbzrK?7^KifKGW_M$cIc$fljz_iUx4^QX^*34U z4KJwNhj87Ei6#T4$!or!(4UI-6y=-D2!l+mS4iYtP*y*;tn>8sH-*msWLpnlGZBAl zwm!5#^@|+oPnNuZa$sJ7Y2q{#+eW%MhK8BJ;@eeu!3sz$+va7aDwb29edG`iV+o0@hL2|9caD*~FCT%{^Jyvjk!-kuemx!e zrTn?9O4E`4NY0KzzqwL=Uz~K+(aUtdJ460QgHu+tLsjthihDhbG#&29{vXD#ed}V= zU0gq1*Dxo>Er~0jn~A2ozY9kat#8_1!QqQ<4d$IM zCy~L5dSjhh1tqAn=RwIE_)GYhsj_6?KK|lMqU+|3g@#Yk_jB^)wfsiMZ5XS7Z?Nc} znGh2Oht*EX03}J@SIugYd);-r;*>4M;zwadHv73{GM8qCW#^*e3K*-XgJ%m~$x8*b zj$fUpnv#5QUNJ~BfRYkie{`zUNV8z(5O(DhE3>VlZ5l1f2j86#Eqr{X%Ax-4=jb@& z>dy!0Ne#U|rijRjv>;({qZel9*0O;_#p{z?H7cLqgI>=N!`M6aS=(wu_r{S<>WUR{`6+l+y(t@BNu~;87H-q#Lg%Et|ZvY zNeR(BjmRHke)a|11Y9t)Tmdp{B3s#<+NS!SZgbZQqj7hrt0es%Zl%5LgI>!v>>1Ln7& zbi#wet!vfDS~-~KFE|1Mtg{Ct0xuI`DUb> zv1Smvyap6os!AabSryPH{vc;F9{Q2T-3V(8Y^W40@WUbI z5>0l)4#9h~?|p`h{R=~@dJOD#%;pc_xg#>-65shqQ!8+%jh~1>x~pe!NSzzrG#gL~ zImAQqIj0z&bTil8*q&)ujB}h3|9TL)GBp9qcSydZI&pFFn_S=VZv*O=a%$GV@(GUE zHIm6qQA(fa`U&>B*oV2RoQ)AH=_F?m!VymM@O|~2ZT7xc$<_x1t-}Z(U1l;|e(s`g z-DXv{>=dOIkrrN4aQ5hDa-#lln^fzU^??uk#K>Iyo6qE;m*VjQrBul{<*s7mwywvWKR?E8gqm#os-NE)BQSNU}2(VA-a z?^OE2jO4n-8(;X}qi?Fe?kM}HLsc!qGX;+Is+3F~(y67&i&pWqtc>vz)Du;@EitTf zaK%_o(@nt{)k#gkd1EX6)+PdtkV(4tIDA~`8+;dP{4NV;J)_V8KbyP&3Ia9aI?ZaC z|E58y8xGC?xMFBMr?nZirxg@aSg)3L62m)k&-iYJn?Gb`PR@9WL=UUiw5T2SA@Q?w zv^H?jLG>K!^3rmD&R+jt+Q|R@{{PR)i#))2_Gh~)@BoG>4WduloG3+K)#jB=K@g|9 z!6q|f&CfcyZjzyei$YXA(Z1I$`^y83jFa_*x6MEHNTQFlR&pkP_IZWN4s1K1;0C6W zP6j_|Ae0*&$F=lKPxgH##hK>R-37&(wqv>~ikxs=>(5{b+u!X|79S>XS{%^Pow6m$8De2tP(bL6 zPFCcjhG9PEz+k9W=1Y;pirxs8AUpj$kp0cs=#2{gg$`dlm4@sA*m(Nqns+G}m$*2W zGEU=CJINJn=k7bt-95cwVX~hgd9#D-K!HtP5V>oXf>w*JnNrXZZsK1S#+vrVrv0Uo z33b;G41eV=Arg_4xxayZTuQGu(X{16zOSKm6&!4cdhPtRy)fH0ciY$cZ(prtem(}t z%>-@R+{O_yQ~4sw%8A$z{%&K|C9bOu_Ms5(tFd(POZRb<{^-?{iC<467XhD4r4IWO z1Ai=F2Sj49#TMta!ez|9yB>gxawdr)6DlWo5~F_bEgc_o8@JUzr{=>2-GBQ@;uP*S zZ77o;@dFdYMi5)g6GG{RTp@1kJFhvMqVqPO-N^r-yuv6W%)l6c>fWwjO-Y|^pvrQ2 z=7GuE;vh}l<%RTtS`Aw7I-v(B6QkYAH)nK8@eni@7YwkBoYKhSD0>aaU$%hWgTEyF6J0n5=pP97-lQJ)sgy|S`sR%xb+@|R%<`Rwi2^_9f&K^3uK zpxq)V3|Z%t!{EO#Xgz+NO#{~XDskt)d6G%V>%xKc5rw8*u`eTraj||{GYV01;%K=- zj@ywt(8wd9gtdqbehU|W*KWQUtx)o>gU*w*Zrbcz5wGPg>cYDUF8~sT{>g!8YJ#Bn z_p_I&ui9;TXyX)4N%5%a59YdOgfD5<99>D~AdE`Xx=xZkppX(T`gYww-r(ow<}2dr zhWzcr#G)Bl)tu9@A3jqD`+^aZ#7RY}^MO1j5w_0Nw73Yw8lf_~JgNfQv8&=O4wAP6irsRZdAu4#z-DF3M;AL)W2GETY z9x4KEi>Vf}BHB%>pEqXjmWPtqa6aF2t1X z2wkDg&%ex`XJGfP!JoYn8_#mJr)W1Sd!qPIm7~(()AXa$lEqT;ErqYbK9jCN0hVB4 zT;Xp0knoPF@BXUTC&*kSpe5$V%|LE2azXJMv`#RGb)aEk=!R96L74V?uXNb z?UbGS{>M2sh{+3;zcv_*Rr5XR%6#P*nW%CR;feKd+*Cq5!b|+ia-CIhn#V){6KjDF z$NjRZU*uaeU!T0}It@&&UUC0oA;&OIH7Sy_Qg59%Mhm13p#ae8zoI|>r=wBQf6~bK zZ-2u<99q0hi9jZ&?pw-rU(06pedHW5l*vA_lBpCn8x-r27uz-m&3=Q zA)d6x69a<+c2%*uSBcs$Cm5o#OPC_kmFb95y!!34Yn)5wRq)nv@bfL@g_vIf=6%W? zeaj(s!Tr^wGY}3`zM=Of)@GTB1I1r}W-wetTMU&Q{D2uNCHRd0oZ9d5L6_&M&=laQ zsDcCOvD4RhpLjDOW@&Maj9lWKw`Cr>)q8%@!kFYr+-x+hlHVhS;DFftxNC~rI}0-e zm^XP0W;{P5OEK&lu!|Qby)AO|_56D##qwOiHap~CT>47ppvIA9Y0DUxP;4_H|L2X7-#sIhB3%Mnc zHfD=B-)0_@C zOhgnr%s!d?<12}Ui?tXCI9|hVlwYA$Uhen-1v5#yd+E$9=E*)o1zICbXTQxQ+S7yg zL|xI9ih=WoKjdru(Yr~icMYP$`n@SjYfSkr-3xUaQIVr;yIo%2y6sg`b~>MRDRe!_ zR39yOaBpZxiQMAKu>v&rI>Wp5F)< zN#hP>@bw85T3-21CJXfz^qFS7iGJJzIz^a60!YWs&gj=km@Dsv-fSmScfYOB(Wjv% z>62rvsCa+OUOOJ})FPs?enuD@`$`9LLp#y?BZKH5nfS-j8bg|^cEsE~`^aANlZDDS zvF#U4ze8U(;1VrmKyyi4LcvsPmlQx%4RbLw%u~NTe{km8BDR1CDXqdOAQBC$=6@2d z_)g-i=LTM^jq{rO)9h$^WYLh?g;9uEKS~^Po6_smN2T2Q!$7tT=9-yV^S5C?qrvs2 zFk>5?`j7Np(39=PJNGeF3YHuFFN+!7VW96+#RU;GVz@rW#fR&U?;x_=nfuiWchG)Y z8p81s)dRYP+>6BcOR$lMvQWC+O^@5^`))UE{d7y6qO}?|xfjK!^w|(gl~9z9zXQ8& zt-1-qsC?p}Y81C|7h~6(7Haw`j#fXNOV&r@vqf`}t+Jh`Phf{<+!OD|;(N@r`R;&}g#%2tVP|{SIZ3FSY3jD<4 z$XB-heZ^z?VGj!6BkMafn8BlGh7$bo#i1D1>i?{N{-?#@e-?lNL10+qqe16D!W%=k z=c@GcM=r_|_Q{ zdxx7KGxhHtVlWD6WUU6q2%fIqM~IG^!j!#4t?z&SosFv#x^6&$*~&mi6@2o_nZ>_2w{qOepum9LoLyl54!sVB^k?3H{o6lC<4rJi!A7VSD(J|oWrqSya=J>i`F z=m5^`pt|hQVk(cqP86B26G?~5j49fvkWj?g{fUVW=7#tcKhxZ#Oa!_=6mm&Dr~j2I z$XLZOj*bb90_{AEeB*!AyEPu8MevVV2rB6wyw5nZa zJ{nADI6oeC*#=N1YH!!^AZPi`(BP_nstvQDb~`*R-bL+q!9una6{U5$`jtNy0@bEJ zrN4VDoqvkr8Y2>q6@l8`pFH+Y&PwudFpb|FL*c#eyrIVI2<@TwTSFw!ibU=cl;Ip1o$M zeg2iEj!MUDCZlL#j6%j&_{)lYf7F{AeYIRzLg6?Shd zMcs;L6o`vrq$}0C1lPKVgFRhtJ<*YQ215TKTNbj+lU=9X=ZX-y-_RtX!j}88ngr=_M|!kcFVf%i zJ!gpeF*86rZA$4o7QWE%iq#%}23dcx3a-3ipHQm*5GzX_zUXr`p_P)dJ{@J&U=H5C zcNIOR!Lob}BiqCP&I3fPc<&_YZrMps3>q4`2g|IoR?d*}%h|YG9u{neu|peru0^fZ zJPe;MPA+vo2a(RlKk9n6A!*6d*qqa1>o8SV_p=uShQ}S_#fR)v6WqzOQYyYXQHkFf z1x{fuhO&5oiwa?CxV<~i7X8&les28wv8o9TxhH6;NH-M&9s&ep6Z5CBWbzB>qxSxr&<%X z&^u;VSO(4$J==kF@pcana<-3U``(Cmz=>U5pQUIwwy5p3jvSypv3SVwN9?93jqy(c z(Lb<6z>_2lHK6&)1LDG;+Ri;cEEcP6rMV>Ow>80|a6!BJll+Cz)zHT-r;{$4*`vam z!C!O{aIPfm@Im~5Wv(UNLKMb7zjy_16k?Bl{lJF?LJElIg*>toe(ssg2bcgng_t`F zAUpSuqk?$TZ`$ZAmSQ!;$S%!~3#Tkd(gQ}Bn}WKiK{j88YA*^=;J#txgi!GnuAtIq z?RM6Lhmz>+MY$A;D?}f}p{qs`Mgm@|2Q!d}g8xIS@dD~MgC zL8WcI^@S&;%I0mgJljQL7<@5xEYLhbCZmCJ74Fl>71}n*QnFVSn#;+GX7yy|3$X8O9fIt3T$D z=gH42T25!CkbNo|4(h*odt`k$pD`8t^2@X4g)?X<_^72rz)uLbshMUmuGN3gn`Cco zy@f~7l|k?y;YOR%hI7@1(R4tbG1F(f!a`l;hcr#B#GuUY4+5RGsh#@yu1+P&FL*3b zvpq$74jW^6gspTMcrJLj%CA13!4hipG0rkEZ`2f7h#ST+dKr?2Y+;9|H0#LF{M0k&2Z1jBX*}x9depDUlc@16MmCxf!`*n~fTnAWNryeSmj?RoDLOwnj%n^gyGE)! zB!7_Zt@~_@xcAhldvi2>o&B_$Yf7PWNzQ4>qtBa>g=L*D-tLk#Oy18|*}vL$HhoiK z&$z}r&M?{2;0$ZnAW>dR(C`LXJ|{@?M5K$io%4StiT(r}!tLrzo5sE4Ra8cz5(Uqy zEmtRsc&n45@B4oobo1o%5TlMaYZyRE2pE6V?sufL`EB-W=FKg}@JaqqspX}=sv>^; z3Zzptao#^t$TQdhS*G_E|96-GGNHYduX@Tx-bI`Zj@==wXCW8u&@jcqO#Wa}H=5ks z6Om1>I54AUH9@KUe!Qho`eB+*`=d_*K?PJAXq|>qsqA-*Ux*SvJ~aMf6ps>eNlSWx zTKn z1Zi*oyNfIQBV?g+i?YIl^f#DKqsL<8hOL}++R#~v#n{hx^|Mmgnr>&New>I)Q-BO8 z7*|IPDty@E0NO{Ko%ge5v82qyazvP}$#KcNt|tIPs^ktl*-D2psgIz%P~RRL-M@DR zKg;n13o?;mtuWbeMziEu&OAOvYV0gOL{*j2CT~EVIk8y?bT9MfhQY(@3(43W%}RJJ zYgdjaf8BZYUgFIE1Z}!sM3>*k5D=sqjgjkr*N+G;eJe8YV!5GGBUqXaF4&e_=P%o> z^P8v)*@@Tx<6pMqUgV4!c*Ihz`2TklKP^yVKepV9;bA+~VoF-Tc^PK$0} zU9qB#Fd10=4ar`Lap*tyE_hXvX4>FLcHz)2)7~~zvihY-r|#{8?|qBcINPC|Ni|>D zPdMK1^obk=C;5es9-s>iJ}#W;D>_QpGCc1#kWni>tQy!>hceqRldT)ond_!Vbzwo` zzYoOfCb;-REblyzb#?C9f$>1wIoiBRrIAU7B-FMUSNxW>QLj*~qFW)o2kIe(;U^ML zJ(hEe=egC&Ix$4CAccq07pPh6Qa_V+Z z0^_||zLEF>vRhjz2Z03*bVp_P*epCy4|e($G${|so7MeD4@9CtBbZNh7H@-9Eqi)y zzI8S^WEKv}5B;nkZRYW7phnu6VOfYE^Tj9-*Sb`A9%G86{m$RZMh(kebCG^MoSs#) zeJ%`bh+r~~&KjS9d4dIIoIU)>lTcKn;p%CpYRWEF%N*5m1cI#$A|Ay_xzzJ9)=RKu zuHCFP`&|!WoE6m$$cNsDzc3WG-LA*S>Esi0pN>$*Cl9!nLCdy;zBnsyxeQ`O$_UFS ztADHlGrJyPp&wI=R5R(uio&=qbkTodoB)1PI=yRM&IW4d{&EelRt8+EJg3}^marAM zPY{%^`T{*@Xr2%A6ohG}vkDCIPRbBhK?iKb1gpn3yl}W#oSYRj)#hNlY+#Q<8q1pU zadkt_e{CPAt+g0iu%Sl`aj_b{*eO)EcUn{rp@c`Dge=&@ij>lE<+cV5Zr}0N zj5<7h8r^~6bq+HD?g@WkY((8j-9Y$t9v?uc)qa@TN-OZrsuoY-=xD?Qc!oYB8yDfq^#VW6<9N9Md2Nt7BVrP zRte(Ja8Q9aR+D2VWqNWtIhp!nen9Sh57cH$xW)e>)h&Tx65~GphCw%Xp|A3E>R3M< z9SIc>ls*&8(dYT3V$fxrgZ$RJ_|gBhV9{!g`uH>dPIt`?O~j$RTvsz;H8ryi9{-f? z{^wwX_?km5NO=!mU7q%PdhQuKEn7uo)Wc|?cm!&5ENRpnK3?8bH#$2IWU2ZdAUmcW zi8Z*E&Ry2LdTf$(@5jna^@Mr1K#888FmFhv(`urz12d82EVN(f-w4YeedDpD8ik z!|O$_ZN54U6+Sl#d=)*x#)7&1{CR#;kYLj48_diiI7#0Ps1_1KirX#l0B5`CKW+~H zOU?PFQIjB5v0j?u<;&7k3MVI@AXgI&L)rDNt=lz*6Y|nj5y?WauYn?jPYDrnxNL`*e4KbjMZS1;h7>Ro)m; zY$sFVrhmlZrRdgp19``y{v%)gqgWEyR!84MOj%miJbo>JqlIW&0|~j2Mj}`&aqV#UHGDK zUQ&j`Y(+3(kQl=Bm-P4%%Pn6QW{RICe%9nc(cCBmG~}0-Aqz_O1os*)s7nwAkAZqL%^DOhHu|UMARC7{7>IS6n@qn9>5JGqc$EylEEa}m zBry$>Fip8=7yW>JG%WzLJ>-r{!YPp`Hvf_m`Vm9$ewE$nB_`Y~I?@5^P^t994LfD) zp5c2llF6`kw(`d4ZN==Ln|EZX>S{e;N2>LDIPHVkx8nZE;`!basI|dFtRO2T5A3)O zuyTQ)RL0bU#<+n~3!rxmv)C8vUXUR!(f~W^^anoU$Q~Bqh*k85TJHb7<8a$%I!pAp!x9NzM2%Gk-6T__d4f{NTkx zkY@n2RvzEEHyDkKvRo?cpIHLp%f9ms`^L=ul%rslr*nT{5C!r8+XDdix9syDm*S+= ze7m^24isu9cwXgG2LdaADCeh|$DX>EsvRmij4=rAL%N>`0G|Ga!&8F1&P+{(&l>Rs zjz;MG=ZHMF2~~i@J)`_$yS$thY5?23a|@^+xvo1K;cmB6r*a3))V+65`i%?7PxwFpX()d}Lf~4ukGqGu z&ZiUawA%u@-qMQDKBs8^dw1F^^)c;=uCHPy(g68;q=R}G!0!P^+HRXBON)BeoRl1K z*Bcia%QKPb7->i_whlpZ4j*KhlnrYm8F`Kd-NkX+#R?OraV=C><$cnp1{5=BoFTcQ zmMI(7FVk2{`!chU3mXH-uz1KM*7BXr^Xm@$w#tEzCn@F2Ox8$C4Z($ph~(v3Z_fGa zOp~XwmH8^H{-53NaFPOTUko3noUt7p+;i|ZeeKICp6`q6Hlh<{Y!#fUIs?|&c`wR7 zDB}1cQBCAj()b%>z|S_rIA>uKSA}6odbL_N`Rce5bAUL=wB*q?Il(2`Ep|3m)FveF zRjp{}`<#+EmjaIKz8SsT`KoFz2ocRD{)Wz#HZ_s>hnnG=W0N&7yaF(cui6R^8JCPyt}U?pAe@dH92^lY%C1`RX9ASSWI||t&Q1?^Yp0J#eE!T1 zrJcBSgaK>xBIf1f7aneEfA;AcDx58y>sn!ULm?-J8JYlRlUdCW^g#Q#7}Yx$bVAap z=GX~RQEg&k*M-`3v!_A zlmb|Xat!)kK zuFzf@yChihi+Fi=Bom~orE`bQ#1m`@k<+*)nnul^mW&jxdYR=Sbgt|6MIoxKv`B>#os`x6Xr$1%w1CdYxj#@J*@(yIC(OTb3B9=nkc*hT@Pc}h~cKegR-Sgtf8hiHyH4 zrDBcQnMM4-jjk3|w$+GaP?nx^KSFU6s6i8&PH_f~UZ%M#KF-2?1zrQbS(MFB+mw32 zTxNhy&eI(h40?@0x)ICr2Slj7=Kz^vh44#?6*~S-cj%YGY^^t}*AAEeil?INsGc^8 zj&Ol9#OBTG2{x^EDUw4e@MSc_g^r_sJ+vhlei4bqLbWS4v7@DtMtsiOzRVoj!ll_A z7woPSSY*53_&9es-$1a|2)WmD1y+?-VwK_CL{|&tdkHA?@;dwdNOxvH8w{ zBIO-=Miq}r{=&GB0-0PcLZ*t@nPoWU_ChUmSQ&Fhja0~f1UzpT<77-(;=9SZcQNU% zC=Vtt+Klx%%QrSWt_YBTL>*;*c0l##WndXTz;WGmH9{~6N-N4JvsL6W3GBylisPYZ z4`dA%a1Z^v!raD&BroO2&yhoLqwUvv(LLMT2ZOSVW~F96bs>7KT{`jzw^yfmo;Yt* zxDA^QqQmItdG1Dl@cX1mWBsU-Ju^$#mMJ`PRH(8K9#e=**4W$VGXi<@_Jxy&!;ly% z*fCF%YycQc=A)fUpRbjwu6r`*TEiB-kzo~HOlyVRPrLs$itQ-|MiI>}hneB_oco?$ z$jdLc6H*>BDCux6IE8>jHV-9F4^^5${t#wPPERz zy|0*EOQn_IWvr#4U1@-3cpPV&?0%{2HPkRUe&w~MMG2m$a;njZvkP#TfXI&g(((gF zs%h$+Y1!oIcDqK-j7``Rs0&~OfZ#=QZgZDu%Zix%atM;E|vTGO=c(>i~jZ0kjN?te?)jUruD%H#{5lvDV-lM$QJ160VGmRl~KLvim zfV-)KS7T-7QXM^{UCA=V)Akb{O+i_l29B_do*>nkIqdUht7z^!1f>PPSGzx1wg(53);{?XV zsEt*HE94p!3GeNtlmf_!(d#=O=AAo|tyAdN@`%~nd=q7z$XTk=U=e1nuo?N6P6Kn! zVHKste2x-1wKhC+D%u38o_0bocrLLf^F$W`$SekX(j(ZJM zRc-u%6PM=MAFRcpXRzf@s|1@lJ_(Gc%MC=*Oe(DNlv>@|aI(kx!#xk_@^ebot)46g zV$N+(#yDdZJ;jnNDZS9~{B<%SZgNM7~<8%t*pnvD^QAaLGMp_vd2?j z{p=%|z{VkRlD7(K%f>E+gUZ)89GhcLJ~9bmLg(qde_t9+b&7;VY62o&98lp~!$S`n z8k0Xu2a?!+t#e@UqM7XmNg4bp(kvy9F-2Q&PE**l$#Zk`LTvWY%~Av+C>&u7aW?1t zJcKZnr{FJAFZ;7jnedO>_{;_D3F5ep5rXl8SHO~e{HfWfS!z7oHM`OI4^=o^x*-{s znNLe8Cf$m#WPDDCN1JFy=kz<`xun&wmoy^vor6NV+{;1iv*~+N3T;QSVM8^9m*&_S zPQYzdYhui(CtpLWpb&Rt9eW9JO{f%q*RrI2a7X)Vs_g`~!v4V?Mei;9#MYx>tjgcq zLdIrB`;&8i-E=lgE78f{P-(35% z2j!PGB+o-Ej0`}PAK*3dUPy>x_}8}R#4U6|j1|8ntJ<8x!LF7A>?5Oh0n-5D|*rm~&F9{XQbdS=WCZ?Ru-|vIy{#v-V?PHp}J5W61FgFJS zsaQeL;%oyeIbHazZT?VkReZ)-#|mqc(Zn#JCR|5_V?ISgg|KM2n0QN%j56EdER*A! zvUXHv{Lp@fLBn4<&Sxm)ENyW@9JDSFP0E~wk+ON}7?y&pX#MV&x3UggMqQ8g3g5oo zbWJcM9Y*PvS0$@1R8VJ1#T}OF{=6gIn(?4nyd2(tjcP%71w6Ta%wZ}Wy?5zRv=|FT zvA=b8G#{*cRVCsTZTjU%!_c7DioIP3>L&2wyxRvrbX2F(D;cbtH7Gcwt_$)+Iz3% z3C_(voq;j~3lvSSnUrf+1m5GXKXf-H8!;bufPR;YeS^2mooF25Y=Jwvmkjz4yGXg$ zIte8{s1!A9PRhkv_$oq?gZaf({lHuV4BP&N_v+xWujO&-80=2FbGsR@W$Ydoo|e_R zu`6)f9_tv(7#c30S{`^;C%WC?`MiEY_H*!$n=V|CCx=7z!YZ%L>g)WN40;+qHpyKl zh$!bH&<6(@R&g(#^3kmYvF6dpys7W}_l6fX7Mg@+oSiAUD`RBSX&-tpy(}92n@=3yk3%vO`#cop=pB{ zlMsqz$-DQ*|M|D}>EA}s|Dav_ua@p(J)vJAr@&M+&eEF=O26ZAEJZ*>Gyvlm;M+@6pmv898tE3HM#dL!LYtr^|&nYzQzD~ z+`+j~k2f_ZNI%7M4N<=YGPs~eBnLhe_x(2GrDNp$w`HDFq^Fjj%rAwFPz23{x65ea zzK?8Mlq0*`3I0(}_aVs)&W}T;+UgMmv1gok1gOPm=bc}Otar^i@Bx&*{I9G~e>;}` z&_y7xja~I>n(3-4d$rVtZNrt|ELU{Mt4zfWyIaoW?q*Mp#wwDBzo2sYs`0g^G(1rm;VQ$6zqXOALCT zkA#xKA4jVGILE5<4Gh(>f1SKF(4g8Ugx^)6R_PzhvXsVN#}$&HXi;cv8&|Oa*yirt zp{6!}J=))oY}(DxKUePu!=|^;XdJ>vP>j1xlJ}8SCGJJvD4B!Y2Jx|2YWUAH*BLg2 zwfAIA%0}f3BA}{;npc{jTNi4)`8<~=D{F?ws z{X#bZ)l`>-mL)||KZh^&iR5^Vl$j@G^H(^lf_mM|_8GThqJP?R?VLRJi z4vl&>c%I%2l)rbhj6t+V?5T%{nYN?Co1nrgoT0q5MEm(FNZ4qect;#xxuB$`q5n*n zDxhW-gMzwoAOpTFn!A&43qpY2T)z~+%zEgn$l@HtW6Ye_^0h=S^U5ywtkj-r(w+A6 zW%P8wZCZ8qqP2sC4gHsbefUfi?frJlu~PR{k}xDx&&q! zd0{ywf=^F}tU^bloBN`;H0e@!9Jh3l2 zyOj4Lv$)c*-ByTgUtF_O87E-W26H-XZJ_JQGDEX&YBlBOn4fHs^^Md^@O5cV$)kN| z&HNvtkO`NV59A(Ee;~m`aH1wt(Y*gS?(5}5KDB-vd z^k3N2(nTjGUFCY^CUZWzN}H=yY5YH+{QsBr@b6sbzkvJYY;0KWXCSa=>|e%RkCffA z_t=fU8^{Qwh5CxX>&ShIOP|-ORxS)v?6C(5ZFIo%d<7X1tld2s>cM(n1KD!}-N)}_ zP)rmhJ7<@;F75JMnzJQ!Tk_sK(^b9iewPc}F=}3E!@3V+x@X)PJWeIV*``XRh4VN4 z?4@l$>ut%AtO@@s!O)-e$V(I7Q`AfCsZ76Ra9lH1HtRLp?znT`GJaEgEtbl4E#}>k2(`DJDG5)~(OBI`HbEY$BdL|FdUwpGmG#e}t|6`FJBsBd3}kCiitww_K2;N^i}d&8AUG}sJ6q>OKKP$v%>V0kCOX*p z`N-DKs?jvINsho33g#cxMljzD`J!}b+yU5R2v@|;)Q)9c?3~3Eo^VQQ^HKD(AUchW zW0Kyvc}16L==bKr$kJCk3QLh_u z2J0qjMaGX6e5ze%5LSr6@1?maXPIIpg7?dr$N4GqIi|%5s$zI!BX!v!K>Daw-9OfR1{#C}OMm7_i+@({KKa#O3&2r)@Vijza=Rhq-R9nirlz5sR{Iqz z=8E8yGp1GyrBm9@weNg9=(lO^VWF3>manqy#Lq7@5;6O@OsfIr$~%#p z0RM#3V0ug~%~W8DxaYdV7tF_T4EF>T_}mg#fm5uRK3t65NxI&$dz9VS#O>Cd+|GQz z;rfXVJNj_P=#9+0EAeMD$ZSxX@^Afj{?n6@DEB6TKk zQX8PbEh+g-tNO`Mp>aQTdl=T`AJo3zch%THf|G$HFELAqj?oISMXX zeuaX|^&^JZpX^f<+gWJYiYd-PzYuO3Ev);C`K%)<22p!mWW5KTZ&QsikMWW4uy);nA)AU=Szy?r^C^ zXa(dL>VniCRc^nInLI&WdG#nRpX;TDR10Wlk_Z_FYiv`BTtSF|S+b%P;zC(w4Dm*+ z#q5P{QW05|m@4Ew3_vgGM<8nyEM&I#@h1t=;JrErV=;O zZdaZidWa;BRo@>gE=Pa{*)_EMJU-9%r4KcS_Six0c$WOKpbiCzWu1OyIYb@UtHAv6 z|Lno~hge!ld-UMtEVvfCA^B#|_o26E9Nn?I(Z%&9JLS&2DAoU=?5(4s?ANy8krWV6 z2?6Pl5|J1>RazKwfFYEU7`hoG1OY+11f**iV218cx}-a$q&uX!zsq|+dq4Z#>wUiU zynnD}n6+SCu&(R;o#$~Lk#AW0*+Y&}JlG~}dCyR%>K9j4m-321&gQOX4}IXlk<+up z0wDZHOcltq;7h zPhasGvYA+MVA#HTaKDG*qOZgR?q8tr7+(Xoo>K|mgoi~`d#3_vo?7#1^49P{za^HY z<5&4=AxK+@K-lA?WrLX2k$pE00yvozL|x>@x|6Uo-m$FQjyUo3(|{i=h(;y&&K+k6$b9{% zM0U9OzVZ+H+qd}mHZJG1lRi0~Zy>|uM4q~gKFfD(s>m?UHHKMwDy4(#^Gk($K52~~ zXY@7^y*Rha-((alcoOYLh8@*gzlE#wSuv7|rN$^GQ-=;jMZv~H-udTDBT@v6B(TWB z%qJhrVlHSo=z2O7e7s3A$W#Szb*NV-6V3zM$+qJt-*Hn(b79YpO;lPb7mdozCHKEN z<+f9vIasFFDcf*?QrY9sd%Kp9Dp--MI_J^`5a5GnJ%ziT?8%ii*>?MlcYDt7z?EzD zwG8{TIaDRP->V$lYH=It-Pc}C8Z^AprRK@~y#rND)}xoj4?9yfYoX2XBEOLl++6;J zYgr&>ovySrNMyKO@qwBABW=Zl@Ricb$>LdqE^C?&njjrR5FV~#Ss?&+pI~F9=|hXR z#hadL8a4oq4ctsYZ_ih5Wwm@MnhgH}MMesue2cWCgDz=+2JkcKAwv8j~XXQ%=jQ1T`m+ z>1^hnA+L;#vB*ujUXE0A5K$mxwXN_(LcDKrwi z%cwxQ1(g8!;w5|OZ#^rs*< zxrcZ>Rrqtc)p%DHHAYwG+|Ak}v06$C;r6DtfskuS)AhGI5xsDcCjfh^u>S}LD4$-k zj1y!p6bib={KPKr_?rX>=*^UT+ySe5$Wufea)53V#vzYK;A@{8B@EWIAO->4l|b&G zkwL)39;?RG!FczAb%nmrw3&tIEh8L5VWOqI_wqA^B|iFT?8E0=nGx|5&7t{9h4Wol z_paNVcJL8(N^(M%%$no$S&Mz{HKR<#bC$>G-pB=tng}xu|3c6uVQiy*Ga$Ei<+-n+ zG*ahB?U}Tx$g?Qjr7iC&w^XcM_@_osb-2}AwiAh$KU}0r zI@`)fgG=xz!t0M7rdaCAy>xJ+7}*bPi&A&y($IrXzNn#0{4@Xl|5eJr^W}-X_S-kY z`t2C^0nJ<17UbbZw|297|XZT!Cix(c7)oCP!U2YL{0Rh9k5|p$TEnW_(%oHn9*Wy=kXMa( zn*L|}^WPT~4`?nl6m2;7maC~_zSFP8CDc&t)`7vPysXQ0v-?zX)Xd~O`$M{tUKpb{ zWX&(g0mwZT*FxfzSv3-DXd#ARcXt=QWvVJ;c+Yo2J1Ok9-1jy5m0trx^7S@uF3@Ru z?GJlT@T0`i6_-)rD2*AhM*vl>O`KAy*hOcxUJBg&RraS+Ta=J@(jj3bMFm?hjNvhg;-m&}wtFcP>gulijg56|y*EwzM`9cqJ z>?{ljFcO!U;Qb^aN?)FgZyT6nT8-kcmh4HTkh8Xl=hqXz6X%4?oB9@b5t(FDgUZ5OT{%icf(&Ph~kBpkDZ)u<5_`2TtMbCGLQ(rX~ z!@Wi|ONjq6@^mnS83TtB=Nk`VV;|MEoZ_dBKdagq)(C$XIU%}UJDaQ=i7+isyjZRc z(;J{R*Ch3=D&o5M)HXF9g#*~9-Ji#gesIs0NEn4LLXpVzKIW7wd3Pe*JXlEbwGCt$ zS5-9v$A;V$MB1BXtY7*s)eOL6!?*$k)Ckw*7I^fdwZ8#2yRA3GfH`SL$a&1VnBQd? z(2n|U7T8KHUTOp09g}IdmebFI?bB!7;D0~>fWTK`J$-4||XY@9z=#3BLc|YAj)M2N8U(_v!6AoI6sO3ND`ejW1 z`|!ssg{o@#yR!^04aA++9$y4@6AQ>vnEPSB%Itb8|Ra zLdtM-pJs7bvzfgb-BOZcqhR^(7V!VH8OG@V?vffZYt6W8HpsRS?mN%eJ5ESLCV&BG zd9s!dupb4pFKlFg$4V4I91`;rZ1PheYU6Gf;PoB`OV!Ost6}c3U*T7}ba@oJ@LgjD z=T6~>5DjJ^Ap`HtdWgh9L{Z>8DxMGpWp~7lnn(A3Y)H1xgimYi^!3#*GpxCQ7s;#UFW_(Tw29&-- zFnSUvDVtDt9w4G{VmHTqwQV&KhPRm+9##Ojx8(PSGWss;^nran#XslGa^+uRB) z_@Zo)E`x~P;$OH(t++>_t`E!Sw)Pv}2-fMzw`}>In)JJ{weWH$O63Bq`YiAfJ5~V% zbu|e_3KvOSXrtdWB^R-^BDJ(F$3YTMp3eNPCiU2ZYA-a49L;D;&o&Ee9cqf0a6Q|Z z-^%s1TlpBOKYNqzr@U3k8w`sqd^va({}%|p@2gYzVH!e8|2G>$Nz#uWz zOhEw*%Zwi`QcitHmj)7YOv1b{(xHHQp#IacUND6W{r5Z2Z2KGsmcdGfkBJjgu{VvK z_4D3`J`u9`M2-bd)Dpr4E! zC!5G$77VWIDv)ntpqS`9oKp!{YpTat^N#7~P>4%b+sL}Bi5@%y5i)c1+sK}*(E%&hU`;q*7E9!hyI z`Pq-08D|RTI?M&!$#7{~|E9-z30!L9R_lA#;s7g=mg5j;#FTHXHH)_d%A6 zio%n+)e%np6kMHYG2>z-2NXMK@$A_Q9|-NX;0T`C(Dumgx0%emcL?2rQeH zw`{S48ew^}-#Ym2S*&zBO&Io+4>q)C1^2+L!YLy)fDSZ5`}RT+|>ai+X2(rF-u9V?4gC&wc!8E;(lh6m*IRKm}) zT2$Pe^xO9ZOFnf4HGO8-MY0@X>f3ay#>T*nh0{BL5rF4l3Lk9Yt|d*QECDFEdpB$a z9Tf06b{G>J{S`r9mjc73_-^wLXCtLQU0uBTznoyT9}QoWDmE9iouD=`{C9t6Z3*s- z9!qG>zfVq=-m7Ck8%MjS+o<1s(W-@9+Ni3{O=f`i1$}}k4No$!!}|_{*hgcGYnI>{ zRh!lOKl?zF@$(q%8-NG@^4!g7-P)$^DjZtV<}NXJ^hhISY-B`pQfcx3$*n+BbCg~# zoYE9Tr?jY!UBu84cR^#jKJIieZuF)rMJ*=!IK*p~8yaj7>%*yH zxnV7vr^&OE8#dz!BK)HMovQfpn}_IT>?iWL`d`}b8%2Iqb*$HfU1UJ+`A~!RZTTmD z?xrME8kd)BxESvQT47J=hIxt*?b`pO4Knpp{$0Nf3{MjGTC-95m3u*Xx!IK>fWeo# z6(~E!kfR5j?6=Hq@Qlb_DljEkNx{R^LZl74V?(CB@229-ds=Qbi@M>C9h1;yGTuNI*g1NPXhxugqref$#8_U?BS~~0$#$b7WMRjn})76 zHmPJlEe=<$Be~1CzNtm6ZNCnd(9u`BdFCy$mRKPnj*5VFa$Y60T!xKeisnwW>LIn^ z{CvhH%SM8mXR)B?#m>zMo2Nm`X=GPW;%;frgXKjVPx2xCNG2CHC=SCM_Rx10B(l{a55i@9^H0xQvF3JPx*|Kw`C_hzVq(^$cZJ zaVh0Nh52a<_Az*F8;U;$6%x!`Hnhp$PN7;aQ;6_IPi+4ZVlwzJ4*>2I{a3=;`zp3f8oFDnQmSAz{*^uN@2%ge6PhPxGAy>!z1QdaY| zOo4S#2l|E8S60==JEZN#`m~9QJ#HV_4KZA<*D$PUOM7C(qWmh!B<=Icwvl297p&SI zD36-|et}rJ;wwKdaFuQWUJh(yJN0n=IsiCGz5LLx0V+B?wdB10k&Wc1W7%G&9*2@J%v~EWL0Z zUY^cRHe$TZ)`5;Be8TEtwBBaKQ5kFed=abY2L3g$?a{t7Ph%oZX-^l`o{Mos?q=Dh zP>%!Eca6ciJsT&tFT78UX33fN-HkGbWfyhRZOlBs7#oqymA1r`Q~05sgp8%f7Ne7^ z6?0FpfqCLD5EYzVV=NbR9dlhYNb6Rd#leC`2s)Ono+TFdYIzKu@(6U%_}q?r9Hjzc zWWNYk0_JXhB+FDFkk|(76RuMlOweyOKT=t~m9F>F($K5+YQ1f+_9AkE->F}Sz&6FJ|L$9&I@mj1sguxSA zr|U=NL`{2A*qhl}TEX{MsVP05_Xrn@Gx$#RZO2LvzP&(y?`E#w4}K&Pw*2!7^Z0nV zPAN`w75cMHsoi7p!TNsoq7PT;ndT|~0J+7Bn+%tc4)XZy21v^P1mpha=akXII{W)( zqnWYGT0wHGDWDSccH#_i1H^F=BtpGPc zIa0^`yj{L-kucAi%1|9^cC+Kc-nYupIt*XAjyw#PWe#u&uA!7g=nyb-c<#bH9?49Y zkJt-_^qVe(V&*)3e?7}?;qpH2@Q(U;Z3bWd`ztq zR8q0ep<%HKauN?=-D4S=PZ1OE&w?7pfmCEfeyvOZS>W~Sy9~*gvsdSG4);mlUkw@+ zeW#yBn_*+f&FErWmU!lBXly?%F0r=8Z5oa1jGkQi@G}wD46P=+=m)o}&M(kw}=eJB*pYbMYs zz|6VX!ZK3l!>bYZI>Ev)+L78NKw)&IPBc&6_qg76X+4o1ox6{R0JAALh|P7DGj*Fp z+t4YfN2vwnxr}D+LGs*OxZh+=%~V~&elgtNmYy!N3%@O41OC(e3HtL^F+Bu>4>UJt9$5V9#+Gza z`;)I}^`~3?*I@L|_rZZWU}9xreip$U3YkG;Kdy&%(|7EnkB#4ddtiB`M)RC$z6&D> z&nrJnPxIqyjWzk2@5!J%q0LU=UTKbc;_~K!E44(6-+eZB|HXSTk*95w4N5eQDTRn?G?7*4Y zG>`V0W{%XRwzMWJEcXvnW_d!Rs#*b7bJn#D=%GMpy=)Z$R+5`{tCS`CHjL*TY9upd z`ne5-pzWcX!8ZY}*=>H}pSzn4pznm`&zi63o+EVC?o z;xDzyPDdXnVvtZFLiV#9pn%a zuZ;$~cB8zlho%nln{FDcidPA=Lh-+yH3wIJFQGqJt9cUQTEW3)5c)`@`}A6D5;HsS zMWZ+-wFo48iWjcRYr*aiv~xct_V`tNkCCb7jwAU)NGXzLxzT%>m(#Ze+vMww8A%&0 zX=eozUsIXG-Y{RNVkJV}8wnR}tW~%xgdHvYnSBz-*~YC#y4d|rdtrC`w)fdkEj@DE z@XbdFDYu5yZoYf3C{Nf+877)^$T>jwKq3^?Os$k3p+)Yh;?=W{Y}Q4nfw^lil=YI7*u2H5Ym*3E!jjpv7K)VYN>`$NNbz#on9$=*_LdweuZj*e zXXgg3WCP@1ND_4Y(uWHzTglJSR`Y_Z^r?2+_|_cK7g>@{Gdx)#N<)Bbu4!;F{p3 zocNDUozC+Wdiv-SZWps<%g|z^rzSqh#@x!`z9GOVwWLxLyBdEiF2Kin+;82LUqC0W zUCUl1#uQehMjPWU_hj6Dz_}ASBBA1yHBXeJ$a?R-cbI;r&T^s3ee5tBPS+Do(*c$~Lc;+LxM& z$LigL_S`hK^*w0v{XR=f7|h2yrBorUJTCkEa$0xyU*tz?waT+<8OI`0f|IWW{JNVJSjfQN8-0pv#%R>k$1=%tTeetXJ?&Ff1Jz^7Ve! z>9%oT*0tEEU_^1>S}isZLrl1JD9@*3rgATm{G**5p(N-#a#-c{KeiXaiLw6o!d6lYNhHp<03e_u!-4-D!1ck^b3XTrz(En}30=%CMI*4~*vW zav_2tgkgHOw3CBUPY<6iJZbhyZkB16Zwgpz(ptvUx;6>yY@Q)SuJK`qxVCPYL=(AK z0@*1Dy0osJqU15RBC(51QNm{8p30<(C(hn&})Hn9J`P++O| zw<>^>HV7vL7PhIiXV48YHbn$A`B=vc5lXAx{+q-qt z;6yAZgPqfW)X+iEfU@013a=xNp$gHiqceBy!Tu+f@nuk|q6o`G<7`~N@z9>}#P26B zuVu_8FkcZ0cJ7{Ztj4l-bhumt73tzq`k`uLk5m z!~;nRw{7)o3VUpShK{{{YvE*#&0A@xadmOoj3A@+1%af|@{Y`cebUkylpj z$TMX=&ZlZ(K8PqYqp{U8!8(QxGRitOw+cyvHxp#9D!hZYhw+`eGD|pvxzn7F-}b3+ z$7Q@uSM$L&I^_LiKFJnwp%dY0+8HwOefOs60pYq_U9LO(k@ ze@awN%?-O2RKm4uqOv2^#A;m5$1geIq1CevsDk)PjsFraJjZe7$jiJJ0cjHwD`3`( zCj(GCicXuK#26;F;-5d>?A0ukC}md#A>w}{+)bV87SApXf0LG5CEq>8L&ci_+J>!8 zq7G)g@sL`EfjS=DrH-l|%Syke8B1GLlaR;M)?iawhL=BZ!kcV7_u#tFgUGDh_4jgL zuKK!*jgl61U%x|E)H8L}xv>*N#1+@`-dW^;nNmNBo)jXOoa0YbHRXOh=34HH9@zuz&2w1DaCSz)-!lT;gB!ol(naK;JWlT ztcJ&MMY~6~iUpD&tlF=jPiQ==VJ zx%h%r$pH2s_xxYWq<=)QF|>^GpvMj399}-ost8MtN7pO!U=H zu~~-BDC}$Luyw@@XAN!)(tScV{5l)j-!9&FzKaP1OXfO^)46hUl^q*=mbZD_SFn?9 zZ7xE{?*oq$+siBb(P#CI*S_6HReOuWt7gcJtI&Jv=PP%w?An@fa0FG6VZM6$y2nz= zmSB^zq~-%Ib9cs5{E>JYPI22S94=IY?G^to9&%`K)*s+ZLq%0W9czT9_1j_kS7cp8 z-dr1II8|p}+^Aw)Vb218DwUxZH5#i6mu2@w@*XnCd9{0#p~Ua#eqX1H@Y+~wT2`FU z;rM=E{;tGYZG^*8cZz&$ugr%!j=AtFUE{|Ov*?vv1=7T~ylzyGp6(Dbqg)Maf9Ksu z5GH$esp=%wR9{244m)M95<)t&p|SJ9i_xAv7J@crd4T^|0os~MV_q*5gBNO>c<_uu zK`Qrhe2Y)cYYn(`K)D1Mm*W0WIB?`k6jAljLf!tDyPgx*UJ@p&@y$+_#vmQ$$R6mNp)`xO6AP=87^VR zF8v7haI?s*LB{KDIj{NjZW|oK4#=HMU4>Wa+KcY+9dKVKvBg zywGJxGmeodjJ+d6+-WV7rN-3}ZtPkpxs^lj{>4%9XA8~PBbY_KV9^>E=zA*7rfk3G zM@O!=ogEO`ND?`_&2-)|*K%y>l)wV}+RMq;2X^pBM{L@!Phs5gqf(4h^Cp&flqV8V z1NC~(vg?e7>q{k{%VMmx;-%P3<6ftPaiH#4{d3Wrd90#ng&lV&6m-;h_)MPQt=Ns6 z<2lRa?-ElBlIQT42??^_p|7idJd)I&c$hzGNAE6hckLqUjMms`qFRC{PpM#mWpO9` zSLAbo-LTP$1KPZnw9X+fY+$`nT2>kYk%@VR`yhXItdICZ27mmCQe27bNnXAR*NePl zf9$&A=|)uxBDl6(9o86Jgc%9xY&&K__ky*BwT7#Fw` z6|F!RhGn6zcl8{|O;xW*YqxK>YcUGT3fG=(z;deV2#ledDYkw6+mdH-UQAL;n}FlO z3?e`$yH2sy3)(ccIM}~^G58nA82QI4WHY<6Q>niC=t=CETz1$?!_I)UIB?r}R2La* z=Ojd3QC#J;=LD-_{#wWOo7LM6nE@ipzd&^89NEgRHo`Nj$CytisX(|$kc9P3@$$sx zi@vEy@+-56`eFS65|TkDq!Z9IjfMYdO8x}E-=V^zVqrNh<}qlQpvg2VWyx69h#ILW z5L^)kT#t@+-z<&KNAqHPwQT}M(y`;VYh_S@LrABN1^XuOuB53fhFYr?rA~F z0}_|cBRn~qV|v9Zq4czSmK+N1p56hufeXn7Gl0+btO~2Ya;zi#Zj^E>m_qJHeaZ_P zxNL5UGO;Kwe@Lzu@w5}~-4o5co3tJ_Iht*u`W>nvg89~VNqn1UWf44=K-ax}LNOZT z6#g~wMM}=3S{jB^m8#Wp=29PZ-hIefr42i=&s#IwvU&QUfS@Xn<-UTG ze#{*Ifz6l)XlTVzOp><~7Mv&(eK8z3bPC+nBiC?~f+ZCyz|(~Y=tRA;Rnsf^p9WUB zjJ3T$%>2j`in384;lC@bW<9=gX%J+%mT@O?y#?{{`}NuIkYu z7O|<44^v7@qk#5lR*&hve^?Y{1`RSDHQ4wgT^PB;iCMbyP6R6z&TClJ&=k^B!-eg$ z#=5>4rfJ7+*YRY;&SpUO&4hH-6DG)B^dhO&HmsR^xLX>YWOfz!t**fKnu)(R-AjvR zMPv((j-Y%_ArAuG+2Kx46XvYzLD0rq_3F?me?58eK{XK^Ls*LQAV6Ge1CxkxmxM@8 zoK)lus7J+=YhU_R7^G87c$7@%Nkr8uZAo&Q>5h_V`*+UK7kUS78~*SmYYt6F7~)Tj zRJ_&svBc%l2n}C$Mat)G79s0~w(HHdCYD)!kd6{3A~`PsW505As}RxZ-dj@XG{fp+ ziK=56(nzQ7!ppIm=dcFYGxOeEszI%O+mUaQRb?Y9kB_U+pMaK?QZuAe=vETW(sHLv zNT5aBo@(;-_^X)E3O>@}S7_)T5C$eU<{8#w6oYo>`cO*GYRk=W-5c_PDo zN6Cf>w#l%wUvDAp6WHk;*YG7YK#uCXS1C2Y8}0sQ;#8@n(B{HnT8-S)N3( zxG2qx!M)<$x7gRmmt%zjsN(eXr$u#=kA47*G)=yacZN25KV2uBc-fnj=*n#0RRvMW z4D1xaqIvBIQopGtIsQ+vL(*IJ?A;{wL^O;qC??FqyR!CCp)mWYcSeJvLU$USI1X=nive7hPB^+DO0@ zI!=HR{S*I9j~$|nw1Hh?A2t#f5i=avAu<@VmEM&zER$UiG5ojLnBxw2%sF6~MbGCq zX>whJ0e@H_e(2*q&g@@c5iR_~k+0u~GDoB)8{(v7Bu*RBR&qfkedEor#yu+Ml>YD_ zVJ*~mk}RIfWJV}8b=6z<9oHe5R>6$Ns}{j3%A8vHSRow|*89Xta;ExS=N>Kmn~(Zk zBx1U2MHbgt*Ch^(;AYekh)c~Htj2Aa--DlCEiu>8yFqet|QxW{1lEetB+XTi#m07Iv^TC|qAw%~!v{~Y-Ew9338*T=~S{fojF!Iwc zRG80>f%`KL#r6zDfI(%H#P8y-5pPB+EStPkA7pXDpE%c-C+wb8sOZ*3?vYWqtb{GT z3+Z)#gV>@l>Nnde{q(B~?WSRvLI;>}o6b+ioAomqRRKB|5)Qb~33}kDyqe2FEa{M9 zS7VpipN=I^C$wL2oH~=#>YV%EXF3F~qck8qSS6N{UjN6CH}*eD7XBS^{xkOR>&04d zY*8z=;Fv$yH+ET$3gUL{mrB2SoDqE>jcpull}Vbxd%~mp%C3fT_rtswLz-oEP7PCh z;2!tpqX=_cJuFgFer_=cv2|?qTIHt$v6?m| z1oEOjpr0AARX6Dns=42>8E1fn|9?59C#AeTlvH_DH>!vJfva#9ta!r} zIP0NhyzAsZ*GnFQjXie%F2(_RK%BNQ?{Jm>`|4YQ+h}J=WwW`MWqc@WWWGv8B-~H) zzS@O=rNclim%XZHe#lju6e)DBQkjMfnwWW5uQ_Ch(w-lOTaTHw;#(?^W{dL5^U z4gP9h6B8Zjt0{9GPjwPI37S&aVQjs58BM4++%dxI`$8peT@_8aMt?{Ddtd4fXQ zn>9vQMAUFQ6I*&lsn{vc-sRttrAN{!tmug`eDW*T-8m!tj(4)T#m%mj=T6RDl{%Od?4z=?#b(LYD3M~Do>sNd=PQ^XTk>n*wdL0*!=PWFQ zq;JlOM88>!6r9W_kJ+FVo#A#fVp(eWYw@~D6Ff{gdE|FOR(LqJ>TL@GpXE4T9**fo zFGi9Yha8l6y(NVmXOMeRdggh5W}EvM+bwoWF&$W(<=JOhmL}&CUO1T;{q8LY zO*x852)H1Pn*~%K=Z{)T>^qP4Bxv7eE>+##u~Tq;sUe^IFBncSR$GLtY>ZB~^@SouIw^7)xJQcpeLZ)tbak zsI8IY<~0Wg4HWM#punSjbEC1-vuL=Ur}NtWV`fuQ=jYrOR9&w^HJrUgsfviYZGKg! zyc3aoC%PH7doqYscz^O9=@rX0Jil@TT^tO!EH4T`vpBuz1P|g8%g;1gteXkyY8mTy z@F(hvNb#qq7fTm>Aj%6=0Aen^umWP_;s{y?&W^)4A8NpJbLQ0AW9?qs^-Yj(& zCsyN&>-q47ZHBK%CKDUD>MONrb?a{Hw<|H_wzjO*VWsYzdM->*rCzr=F7&{aad zf6-9$_KQY{#`u>&L&RJNDlnLKxh#ze;;Q*op~%|!>FB9F%NOFCi3?R*&hEvv##fA6 zNCxH6(f6t-Ycm2qx50Urn5cCiXcX!Zc-5!FTeqE@T}RBjOo#3qtJivrI5nJvSo`4~ z?FGv@?Z~;PrDmQ&1y%X`6(m&nDeOPK9c{@R!`2--_PcNGXXXK=BYBAk)Jy78K2?3A z9HsLi$5CMFj3L6Se=WqzgefBX-Fg9V@C)QGPp_<$mWP*+&%H5?usauj}$mD?()DL(c@8#s3N4Dv^N6x(cg;;!Wy{+7s zEnVfwuEnqTv4kaj>5GKRwvpDg!srCgm0`8ip6Fnnofxrx+rsN0aE0h!pik~j`ak6l ziSu9GYn$U+Yr>aH#ynkg-!e12)mbZJn+$h*z?x%Y$yU!*uuePaE!6}^W_La64+5DX zX|+1E!#P{|t$TR7wUnyoW6IUI5*A7vEY7AZhg=N%*XrE7qN%bkNvcxj`(hzYUT%D! zt+LreRm|MaI{1~^i9T$>X{>YWL=$=n%NG==wz$RC_3)YClv~iBubc)S&LZZ4pTC3l#q6bN{L4J&%R$JT2CP1scBYTrQ2GF%bte|6FJyXyR(;w zFlZSEWxc11`Q1~XjPJ+ehbmDRaeYkpKnT`~+LBql6}+R+;!8tMG1`II{V_sK`xmHE zM;q{b1vmZMcKzS`p8tIRe}%vQ*}>mgD+fb}rfiaVsqXoOdV))2^K(}!O6i>n-%He0 zwmgzWk8=3V-$Z#zU4MqM#4iqJpUVP!H!o@ z2|A&=b^TE(Uj_AkXkDKhh=Z-Aw=ln%akwqOaWcs8nx@Yn)dk8@H{Z`GD>>f!Tii%s zSwNwRmwB*=_ZU1m1&1P1_5v*I#VqkpOPC&V-=hJxRSrR6H3dLAc%K#lHJpw}M?8I6 z&MP>1CGDl!ohLU(Q5wP5+a)87)+Po1)a|x@L6OoxUqYWNW<;5rJfxwjOM=bWE!onI zgv#M@C9K83eSQq%{RNU5cS>Spi^O+U!*#snIsa;%9Y~x-rn=jUeiApQ#-*a;f~*;` zeL8Rws(qPp+azY>0I3l-US{jEYi$(PI!vrU#~Qoq4Bqk8xP+>}R5|B%+B38ixD0Si zbIQw31bvxDEkq0oqOR|1BQieiR8G-oaaH5J2<~C8QNH-KlkA;BxopLEoGxY_r$c1) z#w0xu0UGgiL$R;ldF@m^=cz)p+EgTvmNC5<(R_MyCcR|tEEJa z3(N$k_U=hPHSr_KBkacxk*9qC71K?)W}8TUmR~CE_Qm-UOKh^BhrgY_{mveIuppjw z{6zlCs79wCySTh>K>Q+*c@)YN`03W=5-K_I&CSsf`SygOUyJOnTU~0AJUhe%H9Hen z*EQN?W_+Gn%Wa>_pmj^}fdxxNlr?>=NXd`(B{fEWxe%hr&61MOc~*w-4z;gK=(&+r zE*|N+zs3DzMQ@9Ixgx(g=4vfAM|7LLu8(WLz-MQ^Zd^lrLZ`F%hiCClV_KnS@r-P0 z#yU(soblb>na2rBtVi_fP-#Va$N@S+xXnYjYxUEO;&)7m>H#x`X6f4-SL*Rwh*3?@cT5*8bZ!l^+TTZl;y%fG`M!b#r)+k}U9Y}VihKjk{i&X0(R$z6k@i&nBx62aSf4PW}{{iTMwd0?! zyH=Tyy|_3o#w$H<@$oEQl46pt>V+<^ zoB5Ea(u0^LDw;E8lvm#Dn}8>wZ=`ZE2GMR>oxRcz>zPIsf~zVNMxw=$8pd&`Ytf*i z35QZ33+ecBk_F|7I8zmW_c7ylJS8BP8Ew}}A6R%LB50o1y|0zKcvb)#vIOGWx78I( z2+%dtu_uC3(A|{S8U5niW1dy3!LpU3;;Fs6v?=N0nKl*_JXDzBDQjQphRRkWWRk#H z2=Oh&r1dTL=qW93JU7FVJ+aq|USd2!mzb7Q!0_OCbYhV_3}rWHk0Z>u7La*Lv5N2u z1ru{bJ=5%!4ywbeZvxa-{7Vijd}Vv0uvJu0s?b>kd7SwDO!v&gerV-5kAwg7-jWj* zpspUO9#2gv53f5>(N}#e!PzS&QRZy!E-Lh_eynL0vTicA{z31NSjVs7IaZ53(57MI zBUX9{d&xxc99(^hegCdmr2izHf+l3%^2<{>ScSD!z22@XFS%&6th*!RPCenqyRlun zZxaxj8$-ea9!UG-qyDRsc#@=T{iCm68>x*3>3T3J%F0rQ8|qr&b^;rab0yawE4xm9 zKVP6_QLuTxqU6ULt<7*DyM5)jIsH<;-d=^A2T)rd5z*{M_Lt`gMb`IlO4jAYf?GrY z!L_GDCsc|xoGO>-iRcSQ*-YX~fD??HE2yR4N}_rXUy}wf_(Y>WJZ@nrE$06Da1PS0 zC%ZpUmge~q{o@zx!M2MxREVt8tl@6o2I3Yl3*r8%`apV253|?h;_IU-%VZt7X}~^_ z9lOR+pR%6FUo`SarF#_>3hAy`7f>iQ(H(kA=wIJ8HsRBW!E>K5pZO{+TAaX@V6-;f zFV?@2(2qLR4mT}dAOCELSCImZOSe9pNmc`G8_36-tXUMDXY^ptRaQ}j&Yht91=@sx z2Q54bXynnO5(M`|;DK=)B4|yY2UQXh$b%xUilFl0{CZpYj~OOL&@YSDso3In^nr0k zd6*31*xgX9sEOi8AkJ?*&Go<S6f?smehA=- zCgD>y(_P0tDjw!m=;X56D^Ol?k4O_Y7;`nd z3e}GjotX>U7X0?<_pzNyC106H_b+&WQcEGCe=71RNq*h7M*fO>@zob>q>DK>sh`S=b|wqc600|UG#{kQ2GK^<@r-~)2Tyff$xGP8Gzdk*iihGk*HDeU zVn;JRsn;$}R_sCL*Uv8$^zaITI+rsZSIhJZh-T7r#iziqCGlH?*p(e>xUqgI(vOd* zx`8KNV-!zz4M~H*6BTA;si+nP*v2!r0N-7&^B`#MOmj%ur-ID}@e2L*NT!~`FEr)s zps<$2-%0{;mt&&*zrlQMc@1^_qP;NV&X1R0`4-2ipLmf9o>Z{M-THA&j$R8pA@I5f zBo)!w*$J^vp4)ADQH4G*8>Dbv=vWhZ_0%UAUOy^9MDuoz_KGAU&D9-YRQ0J{qww|{ z8U|#~Mkc*om$b;06-@Js($7F3X%GAqs9L*o>c6mdK(@F7t!I{}hJ#Y3+hfF8NMyCb zCZ(P>C1MkIveHG0V!WQc94m2TdeJpfQ6&G+_~>zCoKbg`of;L((^S3<0mI=K%vYDV z!6u=j#kp?CB>Bc;2k`1ZstJ2vnd?SpdY_i^$gmT?W8PH9&z=0vY`1g1lzY|=ua1Uso6t$8tX{d!$ECzXP9jL z6@QB<(#~dwVX#sqJh%2kY2Rh|Br@-6%c*#8HJG~VxEQYUTg8lP+~>>7!iK|F4+5C` zGPo%OACe`KBHocuZGed>Fjy?1UR?}kyE@70&5L!)*;;^GpevCsfl=CC2d zf)|YMCp{>54;0yWzLeQUbsA4Z6#r7A_jo-Xay$9-D9WI!*>odq$g$#p8RBZ3lSm<{ zxJkUqD1zrqNe^KMQd&XKzY znehA)OU;Hvq>7o4c6>VeZM;H;v(XBqCFao8t+7!f-iV?}^QB!!@G*8N@W}#eYuvY; zN)VY4#zjcHhq%`i-;;HqrOS%b7)l9coRq2XIyXbeqtbZp&RSZb+xx0Go+h8R057ZJ z+{`&$woW7Zirc_jF_L3S!X{c3$JBJFre@`N5!mdk22(J_g*WNGhQudc+;9}XMEeQF z6PH9Ed2T3G+XH}xxe1qHJCFS<%@z@`O38>T0NtLUlPsV$WnN^R$&_#VN>z8` zR{%s6XH?ShVKyx5k8W-X8whlBX%8Xd)z|TLLat6(TgtZ{U6#%<1_T;<)Fbgumx$C) zmvW@%^B&y!EkbW%Gl!FHP$?E2jN@h9iBiwj+s04yXF6y@ zn@;kJL_hB6lDQYD$QURfm5vbNV{fGjSad+#dx(E%>hP1C42+kWF*`|ELYZKQ4k0E! zI7j0+pz26JP~SbioKcfkR|dy-Tra$mfeCt1k4w;;yRbNfSz}(#vbFQ$w3QJH&4V^; zU*sM&>Ic{uV_Hg>hn-n)D_V24sj*Us@y?=c6fP~j5=4Wi2Bd=%e;^g${hV-?0zxl%LpIk@6kr&p5)vD z6qJgklF;;*>GisS+tj+MxyLP-kBR?_i9?`Y{8v;CaBg=<^+%rJAro`{HXdTujr=QO zNUpkG;!1KH*E)RyFuteL_$z+*mB8Wl7!3I zuAnoyh*L)96f^F%T4N1?F9>DXm+J}}A?F0%Anrntn$DGPUMth93MmSs9YXC4reCaT z7!GDLdWw}b`HJCahKoL2f^3NLX{$Ic*qgwgvScJnx;LL`JfvPVB`6;4LZ``o3>)O~ zGC!mbGFHnbexi~RJjqG9dW+YAkCgQ6@Po@OX6sK8B?)3nH!G@kKnLPDY4dxJKm;oF z<);8%sp$#^G-!mS603W1k7?{P$mLhl+}EyC2+};D;`B8DER1&b=@3&ZuDs(Qzo5G8 zF@|**5B+#hS9wThUK%*yRzV!4Fm3%h@sV?K<-LCP@RUH-%i`4nEhGWTqqdq$j2<0o zMy~=c%f_M&M>Hr>n(7AYgQ#m<8f!KomnHGPOJ+hfLbKkzzCEHLv^;?%TZ4dO>ejtJc`<)5??e+;!z?De>-4SWiBcvuP1>P<|@zK0)2(jig3))V33cD^%> z(0Mv(!*mr@{7D>>`(q;?zO1-Qq{`)!9yjqfvl{&tZwAU;M~=hwdKVW3;UcYo;sHP( zQ>|8jzMO;*O-kbyfiGTeF(;dfmNL$MwiHY3kE6Jrs)3O3;FY|lAVWSY5gBde(fi-&CcWI4#VUNjU-e(rn;LCcj#&^+!*(!Zq#SYl?)sAxm%x%$^K0v4Njso| zgoX%*uGBf1-{+4Oyl_~Dsc^Kgfy0wptT4N%YTBqDx$AEhPhTmrfJ!d7l?uk=sIAZq z9)Shqlk~Q`w^1LCiKV!*&X+-DOWr=*xcQ>SCJ4#vSsHSRVWd4I5^pa)xdWxH<3XW~T_XUuSa^q~LsgT7W6Lc}k~iX3%a26Df5ZVPI9~U#aj5`z z-c(L9m>L12tWMkPLjj%YK*K8>?SXs`#yXPKD}@wjr;1e&tz=|z3!EV-SRXwl@Ayx+BmJ)F z%N@N>?GL-LS-q7(rdjZ0;&0NhyDQADRuyEx?^$78-v~#ELS$h_f-)u-gqy_#Wran$ zmt!2J20h#iFq2TnhYNVkn@driagKTu&fO_?Os=gM2Es)z`Knmq7i+krw(qF+KE=+k zJ;uo&t@`%!F#t0}mYXHgFHy0RG)itrXNwUad>k&y2R!z5ReYQ=gWd&H#k}-rCbyY+S8KIld^QT z_plA{WsLaV-@C)(pq#Vw8MXvuf0;&UM_t=YId!KsE1*0%F-AXDwG?}V_iSt*0^qLK%8nK4_&55{k->3x zULP6}xuT0wwSXii!OBX>?8wH!8MX6S?rJ`!`pa4Fmr>yC6D_~-ICG8+rOWn7bXH6P zaqp3GGv|l*xpYF_5Kb)eGK4r{7($kC9@wnk`jlQ^C(V=RsziiU zFHQ44T+R_DJUPB4Of2WB9i5n?)dj%Sc@pv#65(TuGBN^503+Y+f506Dj{>CoX2=@n zf=g^J>@Z8S$Qs_J=mc`bn z1UQChqY{x;qfEti{`z+1(CsNSNxv}DO^2{viZP|7RfeWENMUJg>d>{EVPr8dPdHCk z*{do&|GZ449gvp68tf7B@klRv1wtWPCg16PG6;~3X6#Y37;{jY-E0ExI$!qnKe3h{ zosuN$%DJ)6oweBI^?bBlM+*5PVWebL2@D__9c$Fj{`n!8J9=@{9dp`w)9+4rj7x=J zHuHp)-?)%fdhBX_Keg*z2%<~;^vVq!xpZW3Gohqdha5&sCOS&UE5F36y9B5(K!5Vv zV~6-@cjIq+Y4<7Fet8UI6=WIIrH)t~hOEc>w9<|lqZPBc7`6Ec<2)PhwuFVHajemA z6HL858hqvGB<3N(4`%hEwQeSdO@*7^d4L+?Yjt_Cjhc12_5ttZ*}<{{TB0*&lq*q} zRrG980WL5FyksG^F?c8!PuRFM-;Pd$0L;O4u|J&5zv}^p=~9@O3qaQ0s<%Sn_=KEu z(?9Kidck6=$V3dYRWKm&9Hc6wtC)80u3AxY_AmIggd5t}Gq5E7n^g9OzZ1DrQ(w*w zws9QF6tUzqNM2Pt*BFzwWyrcrXAYg~^JvOYNUk%_5YCS&mN#Id)_$c0#N8~?f1JMx zvRtPFHV&Kz{I9yYE2Dl<8c4|2&C!`h`VtX(yv8PxiG!3g)`9W|yOip>y;taKw~S$D zCQI@|Z?#<&CEQXMY&aic)QMSpX2{wHsH~m_>fQw8W&raJh#4Y(sLOL4z=?6!0-U@A zS7|3t`}TQf&$SKO&7+=CQK{ABfJR43UO?bE$MW$NfP8EF#GL75yL-l*$0C=|=<$lD z+$D4fhHJxk*)t8L!ksG|1eZj>>j^{uP?HnlMT5=aQNJaV_Et0&+MuRe83bo7_X&8V z^Ga6IQuRvTJyzk|d0Ovt@13G+FJ-caHQ;DF{Q=EKWmLi%u!B+$%#qBa>V)pjw4`DJ z6Q%g4RL?c4@jjNJ_$j+(RT-SHMh5pAZ@v3WR4qX!Q10#aazcu=M2g|gTZg~GOx z^Yh4BpQVr;kQkDpayD&NFB~c@mq`%jsV=5+Vc>*6&ZTs9i6-JQ>_-EG;_G0>=w{6; d0CjPuwDKOyu1}@eUR&R=1.0.0" + "pyLIQTR ==1.0.0" ] requires-python = ">=3.9" description = "Documentation of Applications for Quantum Computers" From 89b78c77b4633d00e773cc5865fa2801b1889051 Mon Sep 17 00:00:00 2001 From: zmorrell <66835471+zmorrell@users.noreply.github.com> Date: Wed, 13 Mar 2024 13:22:56 -0600 Subject: [PATCH 10/11] State preparation ru cl (#13) * Add state preparation documentation and fix RNG seeding * fixed time varying terms and added approprimate terms for rucl lattice * Add resource estimate for state preparation and measurement * Add state prep and measurement resource estimates section, attempt to fix figures * Reduce image size of Figure 1 * Remove unused variable from prepare_measurement_rucl --------- Co-authored-by: Jonhas Colina --- .../EmbeddedFigures/RuCl3_spinstructure.jpeg | Bin 0 -> 53712 bytes notebooks/RuClExample.ipynb | 401 +++++++++++++++--- 2 files changed, 353 insertions(+), 48 deletions(-) create mode 100644 notebooks/EmbeddedFigures/RuCl3_spinstructure.jpeg diff --git a/notebooks/EmbeddedFigures/RuCl3_spinstructure.jpeg b/notebooks/EmbeddedFigures/RuCl3_spinstructure.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..8f3959850c737eae31b2612594baab089d86872c GIT binary patch literal 53712 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 CbZ_+l literal 0 HcmV?d00001 diff --git a/notebooks/RuClExample.ipynb b/notebooks/RuClExample.ipynb index b15efba..505b28b 100644 --- a/notebooks/RuClExample.ipynb +++ b/notebooks/RuClExample.ipynb @@ -14,15 +14,15 @@ " &+ \\Gamma_z' \\sum_{ij} (S^{x}_{i} S^{z}_{j} + S^{z}_{i} S^{x}_{j}) + (S^{x}_{i} S^{y}_{j} + S^{y}_{i} S^{x}_{j}) \\\\\n", " &+ \\Gamma_y' \\sum_{ij} (S^{y}_{i} S^{x}_{j} + S^{x}_{i} S^{y}_{j}) + (S^{y}_{i} S^{z}_{j} + S^{z}_{i} S^{y}_{j}) \\\\\n", " &+ \\Gamma_x' \\sum_{ij} (S^{z}_{i} S^{x}_{j} + S^{x}_{i} S^{z}_{j}) + (S^{z}_{i} S^{y}_{j} + S^{y}_{i} S^{z}_{j}) \\\\\n", - " &+ A \\sum_{i} (S^{z}_i)^{2} + \\sum_{i} \\bf{S_i \\cdot H_i}\n", + " &+ A \\sum_{i} (S^{z}_i)^{2} \n", "\\end{split}\n", "\\end{equation}\n", "\n", - "The terms $S^{x}_{i}$, $S^{y}_{i}$, and $S^{z}_{i}$ represent the Pauli operators acting on site $i$. The terms $K_{x}$, $K_{y}$, and $K_{z}$ represent the strength of the Kitaev interaction between two sites in a given direction. The bold terms $\\bf{S_i}$ $ = [S^x_i, S^y_i, S^z_i]$ are useful for defining the Heisenberg interaction terms with strength $J$. The terms $\\Gamma$ represent the strength of off-diagonal symmetric exchange interactions between nearest neighboring sites, and the terms $\\Gamma'$ represent the effect of trigonal distortion. Lastly, the term $A$ represents the effect of single-ion anisotropy. Finally, $\\bf{H}$ is a vector representing the strength of the Zeeman energy.\n", + "The terms $S^{x}_{i}$, $S^{y}_{i}$, and $S^{z}_{i}$ represent the Pauli operators acting on site $i$. The terms $K_{x}$, $K_{y}$, and $K_{z}$ represent the strength of the Kitaev interaction between two sites in a given direction. The bold terms $\\bf{S_i}$ $ = [S^x_i, S^y_i, S^z_i]$ are useful for defining the Heisenberg interaction terms with strength $J$. The terms $\\Gamma$ represent the strength of off-diagonal symmetric exchange interactions between nearest neighboring sites, and the terms $\\Gamma'$ represent the effect of trigonal distortion. Lastly, the term $A$ represents the effect of single-ion anisotropy. \n", "\n", - "The connectivity of the Hamiltonian is defined directionally, as shown in Figure 1 (obtained from [[1]](https://doi.org/10.1038/s41535-019-0203-y)). As a result of the experiment being performed on the material, we need to include a time-varying Hamiltonian component, corresponding to the time-varying transverse field of the magnet operating on the material. This Hamiltonian is\n", + "The connectivity of the Hamiltonian is defined directionally, as shown in Figure 1 (obtained from [[1]](https://doi.org/10.1038/s41535-019-0203-y)). As a result of the experiment being performed on the material, we need to include a time-varying Hamiltonian component, corresponding to the time-varying Zeeman terms operating on the material. This Hamiltonian is\n", "\\begin{equation}\n", - " H_{field}(t) = t \\sum_i S^x_i\n", + " H_{field}(t) = f_x(t) \\sum_i S^x_i + f_y(t) \\sum_i S^y_i + f_z(t) \\sum_i S^z_i \n", "\\end{equation}\n", "\n", "We can then construct the complete time-varying Hamiltonian we want to simulate with \n", @@ -30,9 +30,9 @@ " H(t) = H_{material} + H_{field}(t)\n", "\\end{equation}\n", "\n", - "##### Figure 1\n", + "\"RuCl\n", "\n", - "![RuCl_Lattice](EmbeddedFigures/RuclLattice.jpg)" + "##### Figure 1" ] }, { @@ -48,6 +48,8 @@ "import time\n", "import random\n", "import pandas as pd\n", + "import numpy as np\n", + "from math import sqrt\n", "\n", "from openfermion import count_qubits\n", "from openfermion.circuits import trotter_steps_required, error_bound\n", @@ -109,7 +111,8 @@ "def estimate_qsp(pyliqtr_hamiltonian, timesteps, energy_precision, outdir, hamiltonian_name=\"hamiltonian\", write_circuits=False, numsteps=1000):\n", " timestep_of_interest=timesteps/numsteps #for magnus like argument\n", " t0 = time.perf_counter()\n", - " random.seed()\n", + " random.seed(0)\n", + " np.random.seed(0)\n", " angles_response = Angler_fourier_response(tau=timestep_of_interest*pyliqtr_hamiltonian.alpha, eps=energy_precision, random=True, silent=True)\n", " angles_response.generate()\n", " angles = angles_response.phases\n", @@ -323,7 +326,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd1hUV/PHv7tUUekqGFCwN7D3Aoi9AKKCspvEWGJiEt/kjVGDMSavKRbUNKPGgomsjaJoQI1KEbElKKKAJkZpAiIdBXaX3fn94W9XkbqVBc/neXzU22buzp25c885cw6HiAgMBoPBYDAYDIaScJtaAQaDwWAwGAxG84YllAwGg8FgMBgMlWAJJYPBYDAYDAZDJVhCyWAwGAwGg8FQCZZQMhgMBoPBYDBUgiWUDAaDwWAwGAyVYAklg8FgMBgMBkMlWELJYDAYDAaDwVAJllAyGAwGg8FgMFSCJZQMBoPBYDAYDJVgCSWDwWAwGAwGQyVYQslgMBgMBoPBUAmWUDIYDAaDwWAwVIIllAwGg8FgMBgMlWAJJYPBYDAYDAZDJVhCyWAwGAwGg8FQCZZQMhgMBoPBYDBUgiWUDAaDwWAwGAyVYAklg8FgMBgMBkMlWELJYDAYDAaDwVAJllAyGAwGg8FgMFSCJZQMBoPBYDAYDJVgCSWDwWAwGAwGQyVYQslgMBgMBoPBUAmWUDIYDAaDwWAwVIIllAwGg8FgMBgMlWAJJYPBYDAYDAZDJVhCyWAwGAwGg8FQCZZQMhgMBoPBYDBUgiWUDAaDwWAwGAyVYAklg8FgMBgMBkMlWELJYDAYDAaDwVAJllAyGAwGg8FgMFSCJZQMBoPBYDAYDJVgCSWDwWAwGAwGQyVYQslgMBgMBoPBUAmWUDIYDAaDwWAwVEK/qRVgMBgtg6fCKqQVPIWoSgpDfS4crFqjtRELMboGsxODwdAELIowGAyl+edRGQRXMxB9Nw8ZheWgF/ZxAHSyNIFbz/bgDe+E7h3aNpWarzzMTgwGQ9NwiIgaPozBYDCek1lYDv9jtxB3Lx96XA4k0rrDiGz/2G7W+GaWE+wtTbSo6asNsxODwdAWLKFkMBgKcfjPDKw7kYwqKdWboLyMHpcDfS4HX3r0xbyhnTSoIQNgdmIwGNqFJZQMBqPR/BT9DwL++Fvl66yY1APvu3VXg0aM2mB2YjAY2oZVeTMYDGzatAm9evWCVCqt85jDf2aoJUkBgIA//saRPzPq3H/69Gm0adMGjx8/Vou8lgKzE4PB0FVYCyWD8YpTWloKR0dHBAQE4K233pJvP3LkCE6ePImrV6/i3r17aNXJCe39vlVJVvqGGXXumzBhAs6ePSv//4ABAzB+/Hhs3bpVJZkthdrsVFBQgH379uHkyZNITU2FSCSGqK0N2gzxROve45SWxezEYDAUhVV5MxivOPv27UNVVRXmz59fbfuOHTuQkJCAoUOHIiM7D+r48rSa8bH831wu0L1dGwxtU4zvv/8ekyZNqnbs0qVLsWLFCnz55Zdo25ZVHtdmp8uXL2PNmjWYNm0aPvvsMwiuZeFW/B/ID98EcX4mzMfylJLF7MRgMBSFdXkzGK84gYGB8PDwgLGxcbXtBw4cQElJCXYdCgeZmEMdnRlt+rnJ/5j0ccPDdkOR/bgIHA6nRkI7e/ZsCIVCBAcHqyy3PmJiYsDhcOr84+bmBgBYvnw5Bg8eDCMjIwwYMECjOtVGbXbq27cv/vnnHxw/fhzT5i1EXidXtJ/3NYw7O6PkSgikokqlZOminRgMhm7DEkoG4xXmwYMHSEpKwoQJE2rss7e3B5fLheBqBp7NVqh+uNIqnAw/DhcXF9jZ2VXb1759ezg7OyM8PFwjsmWMGjUKOTk5Nf7s2rULHA4Hy5Ytkx+7cOFC+Pr6alSf2qjLTo6OjujcuTMAQHA1A3rcZ0lwq+4jAYkYVcW5apGvC3ZiMBi6DevyZjBeYS5dugQAGDRoUJ3HRN/NA9TS4V2TJ/9cQ+XTUvB4tXfNDh48GMePH9eIbBmGhoawsbGpti01NRUrVqyAv78/5s6dCwD44YcfAACPHz9GUlKSRnV6mcbaSTY9kORpEQCAa2KqFvm6YCcGg6HbsBZKBuMV5s6dOwCetXTVxhNhFTIKyzUm/2lKDKBngKkzvWrd36VLF+Tn5yMvL09jOrxMcXExPD094erqivXr12tNbn0oYidJRRme3PwDRnZ9od/GUi3yddFODAZDt2AtlAzGK0xBQQH09fXRpk2bWvenFzzVUNskIBWWo+Lfv9Cq6xBcSf4Xjg9rTk9TVlYGALhw4QK6dOmikjwul9vg2EepVAo/Pz/o6+tDIBCAw1Gtqz8xMbHeKX4ay507d6Cnp4e//659OqAHxWIQACIp8k8GQCp8AsuJS1WWC1S3U7HEAK/VcoyFhQUAID8/H+3bt1eLXAaD0bxgCSWDwagTUZXqyVBdlN+NB1WJ0LqPK/z4b0CUU/fcibJuZ1Vo3bo1njx5Uu8x/v7+uHz5Mq5du6aWiuUxY8bg6dOnKl9HxuDBg2vdbmjbA7ZvbkXh2V2ovJ8Aqxn/hWEH1RJwGS/aqa7nQVawpWoCzmAwmi8soWQwXmGsrKxQVVWFsrKyWhMoQ33NjYp5mhwDjlFrmHQbhp0feMLR3KDGMfv27cP27dtx7tw5eSuYsnC59d/L4cOHERAQgIiICHTvrp7VYS5evKiWFsqff/4Ze/fuxYULF9C6desa+x8Ui7Fo3Q94cj0C5q4L0KbfeJVlynjRTnU9D0VFz8ZsWltbq00ug8FoXrCEksF4henVqxeAZ1XEzs7ONfY7WLXWSH131ZNCVGbcQmsnd3D1DTBl9GC0NqoZjnbs2AFra2u4u7trQIvnJCYmYtGiRdiwYQMmT56stuuqa3ohNzc37N27F2ZmZrXaKeb7H1By8SDaDvGE2Yg5apEJ1LSTg1XNZBZ49vxYW1ujXbt2apPNYDCaF6woh8F4hRk5ciQA4K+//qq2nYhw6dIlfPLRckhKHqldbnnKBYCkaN3HFYbiUpw/EwmRSFTjuISEBLmOmiI/Px9eXl5wdXUFn89Hbm5utT+yZQXv3buHxMRE5ObmoqKiAomJiUhMTKxVb3VTl51EIhE++eQTrPjoQ7TqPhwW7ovVKvdFO7WSPMXNhGu1zkeqDTsxGAzdhrVQMhivMF26dEG/fv1w7tw5LFy4EHfu3IFAIIBAIMCDBw9gamoK6/4PISkvhVQsRHH8YQCAsX0/GHfqJ79O+oYZMLLvBxvehkbJfZoSA702lmjVuR8o/So8Pb+BpaUlfHx8wOfzMWrUKPn0PO+9955G7l1GREQE0tPTkZ6eDltb2xr7O3fujLS0NCxevBixsbHy7QMHDgTwrHXOwcFBozq+aKcFCxbg0qVLEAgEOHjwIEpLS6Gnp4cevfshOyUG0hfyPSO73jAwfz4lktJ26tQXT/6+gNGjfeHo6Agejwcej4devXohLy9PK3ZiMBi6DVvLm8F4xfnyyy/x7bffonfv3khMTISZmRnmzp0LsViMX3/9tdZzzEbPly/rJxVVIHPrXJj0Hod2nisblCcuyEL27nfQdqgXLN0X49xH41DxKE2eyGZlZcHBwQG9evVCbGwsHj16xJb0A7B69Wps27YNNjY2yMjIgL29PZycnBAZGVnnOVbTPkQb52eToatqpz/+MxbZd64jKCgIISEhKCkpweDBg+Ho6IiIiAhmJwbjFYcllAzGK0hZWRnCwsIgEAhw7tw5EBEGDhyIzz77DNOmTauxDOPre6/i0v0C+cTZL1Lx75/IC/4fbBf+CMP2Do3WQY/LwaguVjiwaLh8m1QqRVxcHAQCAfbt2weJRIJBgwaBx+Nh3rx56Nixo9L33BzJzs7G4cOHERQUhBs3boDD4WDMmDFYv349xo4dW6PQSFt2qqysREREBAQCAY4fPw4iwsSJE8Hn8zFr1iyWWDIYryBsDCWD8YogFovx+++/Y968eejQoQMWLFgAkUiEX375BevWrUN5eTm8vLxqJJMA8M0sJ+hzay/PqUy/BZM+4xRKUgBAn8vBN7Ocqm3jcrlwcXGBt7c3jI2NsW/fPjg4OODTTz+Fvb09Jk6ciP3796O0tFQhWc2J0tJS7N+/HxMmTICdnR0+/fRTdOnSBWFhYVi/fj3y8vJqTSaBF+1UM6FUp52MjY0xe/ZsvP322zAxMUFAQABEIhHefPNNdOjQAfPmzcPvv/8OsViskCwGg9F8YS2UDEYLhohw+fJlBAUF4ejRoygoKICTkxN4PB7mz5+PTp06NfpaAccu46drhWrTbaO3E3yHNk5+cXExQkNDERQUhNjYWBgZGcHDwwM8Hg9TpkyBoaGh2vRqCkQiEU6fPg2BQIATJ05AKBTC1dUVPB4Ps2fPhrm5eaOv9cnOYwhOV9/voYidMjIycOjQIQQFBeH27duwsrKCr68veDweRo4cyeapZDBaMCyhZDBaIC8X19jZ2cHPzw88Hq/WaWca4t9//8WYMWNgPnoeKrpPUFm/0rggHP78LUyaNEnhczMzM3Ho0CEIBAIkJSXVKOZpLkmLVCqVF9ccPXoUhYWFcHZ2Bp/Px/z582FnZ6fwNc+cOYOZM2di5KIvkG7eX2Udq64fw4Ud/kqtUpSUlCQvHMrKyqpRzMNgMFoWLKFkMFoIOTk58vF2169flxfX8Hg8jBs3rsGJvesiOzsbY8aMgYGBAeLi4hCVXol1J5JRJaVax+rVhR6XA30uB+um98Khr5cjKioKZ8+exahRo5TSCwBu3bolT1oyMzPh4OAAPz8/8Pl89O7dW+nrapKUlBS5zmlpabC3t5cn+05OTg1foA4uXbqEiRMnwt3dHaGhoQhNzFHJTivcOiHgXW+IxWJcvHhR6fGrUqkUFy5cqFHMIxsXW1tlPYPBaH6whJLBaMa8WFxz/vx56OvrY/r06eDz+bUW1yhKQUEBxo0bh7KyMly8eFHeRZ5ZWA7/Y7cQdy8felxOvQmLbP/Ybtb4ZpYT7C1NUFFRgalTp+LmzZuIjY1VqtX0RV4s5gkODkZxcTEGDhwIPp+vE8U8LxfXmJuby5P9usZDKsLNmzfh4uKCAQMG4NSpU2jVqhUA1e2UkZGBMWPGwNTUFLGxsbCyslJJzxeLeSIiIlBVVQV3d3dWzMNgtABYQslgNDPEYjHOnDmDoKAgnDhxAhUVFXBxcQGfz8fs2bNVXqJQRllZGdzd3ZGWloaLFy+iR48eNY7551EZBFczEP13HjIKyquVgnAAdLIygVuP9uCP6IRu7asnC6WlpRg/fjyysrIQFxentuUOhUIhIiMjERQUhN9//x1VVVUYP348eDwevL29YWpqqhY5DVFaWoqwsDAEBQUhKioKBgYGmDlzJng8HqZNmwYjIyO1yPnnn38wZswYdOrUCefPn6/1/lSx0927dzF27Fg4Ojri3Llzakv6ioqKEBISAoFAgNjYWLRq1QoeHh7g8/mYPHkyDAxqLsXJYDB0GGIwGDqPVCql+Ph4evfdd8nKyooAkJOTE23YsIHS09PVLq+iooLc3NzI1NSUrl+/3qhznlSKKeT8FTK07UEh56/Qk0pxg+c8fvyYevXqRZ07d6bMzExV1a5BUVER7dmzh1xdXYnD4ZCxsTH5+PhQeHg4CYVCtcsTCoUUHh5OPj4+ZGxsTBwOh9zc3GjPnj1UVFSkdnmZmZnUqVMn6t27Nz1+/LhR5yhjp+vXr5OpqSmNHz+eKioqVFW7Bunp6bRhwwbq168fASArKytatmwZxcfHk1QqVbs8BoOhflhCyWDoMKmpqfTZZ5+Ro6MjASA7OztauXIl3bx5U2MyxWIxeXp6UqtWrSguLk6hcxMSEggAJSQkNPqczMxM6ty5s0JJkTJkZGTQxo0bydnZmQCQpaUlvfPOO3Tx4kWVkhaJREJxcXH0zjvvkKWlJQEgZ2dn2rRpk0aSZBl5eXlKJ+PK2OnChQtkbGxMXl5eJBY3nIQqy82bN2nlypVkZ2dHAMjR0ZE+++wzSk1N1ZhMBoOhOiyhZDB0jOzsbNq6dSsNGjSIAJCZmRktXryYoqOjSSKRaFS2RCKhN954g/T19SkiIkLh85VJVIiI/v77b2rfvj0NGTKESkpKFJarKElJSbRq1Sqyt7cnAOTg4ED+/v6UkpLS6GskJyeTv78/OTg4EACyt7enVatWUVJSkgY1f0ZJSQkNHjyYOnToQP/884/C5ytrp4iICNLX16c333xTK89idHQ0LVq0iMzMzAgADR48mLZu3UrZ2dkalc1gMBSHJZQMhg5QUlJC+/fvp4kTJxKXyyVDQ0OaNWsWhYaGaqSLsTakUiktX76cOBwOHT58WKlrKJuoEBElJiaSmZkZubq6Unl5uVLyFUUikVBMTAwtWbKEzM3NCQANHDiQtmzZQg8fPqxx/MOHDykgIIAGDhxIAMjc3JyWLFlCMTExGk+wZJSXl5OLiwuZm5tTYmKiUtdQxU6HDh0iDodD//nPf7TWHV1RUUEhISE0a9YsMjQ0JC6XSxMnTqT9+/dTaWmpVnRgMBj1wxJKBqOJEAqFdOLECfL19SVjY2MCQC4uLrR7924qLCzUuj4lJSXUtWtX2rVrl9LXUCVRISK6ePEitWrVimbOnEkikUhpPZShsrKSwsLCyNvbmwwNDYnD4ZC7uzv9/PPP9PPPP5O7uztxOBwyNDSk2bNnU1hYGFVWVmpVR5FIRDNmzCATExOKj49X+jqq2mnnzp0EgAIDA5XWQVkKCwvpl19+IRcXFwJArVq1Il9fXzp58qTWnxkGg/EcllAyGFpE28U1iiASiejp06cqXUPVRIWI6OzZs7Rw4UJKTk5usoKMR48e0fvvv0/t2rUjPFvHkNq3b0/vv/8+PXr0qEl0kkqldPv2bVq4cCGdPXtWpWupw07BwcEkFAq11jJbG6yYh8HQHdi0QQyGFlD3yjW6yvXr1zF48GAkJCRg0KBBSl+HiCCRSKCvr69G7eqnrpVrZsyYAQD4/fffm3xlnqqqKujp6aksU112kkql9c6hGRgYiOnTp6N9+/ZKy2gsbGUeBqNpYQklg6EhNLVyjbJIJBLo6elpVIa6EhVtUtvKNbJEpF+/ftWOVefKPA0lY5pEW3by8vKCjY0Ndu7cqTEZLyNbmUc2yb2qK/M0pZ0YjGZFk7aPMhg6jqJzFepCcc3L7N+/X/7vqqoqjcpSR1eqMihqp7qKa2JjYxvVhatoMU9t/PjjjzRv3rwm6ULXtJ2kUikVFhZSt27daM+ePRqR0RgqKiooNDRUpWKeprQTg9GcYAklg/ESYrGY9uzZQ2PHjqUZM2bQl19+We/LRCqV0unTp3WmuOZFXn/9deJwOLRgwQJ50qXJpFKbCaWidpJIJBQYGKj24pq6inmuXbtW7zi+vLw8MjExoUuXLhGR4kmxKmjDTunp6dSuXTuKjY0lImryMY11FfM8fPhQZ+3EYDQnWDs+g/H/xMbGIiEhAVOmTMEPP/yAiRMnYuLEiQgICMCnn36K/Pz8Ws8jIpw4cQIpKSn44osvkJ6ejpiYGCxevFhtyyAqw08//YQbN25g+fLlSElJgZ+fH0pLS6GnpweJRNJkeqmKsnbicrnYvn07pFIpdu/ejUePHiEkJASzZs1SaRlEIyMjzJo1C6GhoXj06BF2794NiUQCIyMjUD0jioyNjdG/f39cunQJAGBoaIisrCy4uLjgxx9/hFAoVFqnpkQqlQIA4uPjYWtri3HjxgEAOBxOvb+HprGwsMCSJUsQExOD9PR0rFu3DmlpabCysqp3TGpLtRODoW60N+KdwdAhiKjaS0QgEGD58uV4//330bdvXyxbtgw9e/YE8OxFtH37diQlJWH8+PG1Xm/z5s0wMTHRiu6NpaioCBMnTsTKlSvxxx9/YMeOHZg/fz727duHDh06NIuxYeq0k1QqRVRUlNrWoq4Nc3NzLFq0CIsWLar3OIlEgrZt26Jv3764ePEiPv74YwQGBmLDhg1o164dnJ2dcenSJYSGhsLa2hrz58+X36cuQ0TyZyolJQVEhLS0NCQkJKCkpATXrl1Dq1atsG3btibVs1OnTli1ahVWrVpVb5LbUu3EYGgC3X6bMBga4PHjx/IkRdZSd/jwYSxYsADvv/8+vvjiC/Ts2VO+r1u3brh37x66du1a6/W4XK5OJZOBgYH4888/sWbNGrzzzjuwsbHB/PnzsXz5cpSVlWH+/Pl48OCB/MWfm5vbxBrXjibspMlkUhFkxVEzZ85Ebm4uxo0bh6+//ho8Hg/nz5/H6NGjERcXB6FQiISEBAwbNgx+fn549OhRE2teNy8m/1evXkVkZCRu374NX19ffPTRR/j+++9RWVmJsrIylJSUNLG2z6mvdbIl2onB0BhN1tnOYDQBmzdvJhsbG1q3bh2VlZUREVF+fj4NGzaMtm/fXu1Y2biqPXv20JAhQ6ioqEjb6iqEVCqlkpISsrCwoB07dsi3v1hkEhoaShMmTKBRo0ZRcnIyhYSEUPv27RtdSNIQ6hqb19LtRPSsYOTo0aPE4XCof//+tRYEPXnyhIiI7t69SwMGDKDvvvuu2jWURd1jKF/U548//iBPT08aMmQIBQcH082bN0kqlcrHqRYWFtKqVavol19+UYtsTaELdmIwmhOsy5vxSrFs2TI4OjpizZo1iIqKwvHjx1FcXIzk5GTMmjULwPOWFlnLxe7du+Hp6Qlzc/MaXbC6BBHB1NQUEydORFpamnwbl8uV6+3t7Q1jY2Ps2rULU6dORU5ODtatW4eOHTs2rfIv0VLtJJu6qbS0FB988AHu3r0LAJg4cSLGjRsnH38o079169YAgB49eqBnz56IiYnBwoULdaalVYbstw4PD8fevXuRk5OD7du3Y9iwYfJjDAwMADybTksoFOLbb79FQUEBVq9e3SQ610dLtRODoUlYlzfjlcLExASzZ8/GmTNnIJFIMHHiRCxfvhxTp06VvxReTETCw8ORlpaGxYsX19ina8h069q1K44fP44nT57It71YEDFt2jSMHj0amZmZ2LBhA9asWdNkOtdFS7WTnp4e7ty5g3HjxuGvv/7C9u3b8dZbb+HBgwcQi8XyYQgy/WWJS0ZGBvT19UFEOpukZGdnY/PmzcjOzsavv/6KYcOGVRufyOVyIZVK0adPHyxevBiOjo7YuHEjEhMTm07pOmjJdmIwNAVLKBmvHFKpFJ07d0ZkZCT8/Pxw6tQpVFVVwdTUtFr1s0gkwubNm+XjEAGguLgYjx8/birVa+XBgwdITU3F06dPAQDu7u4wMTGBSCSSHyOVSsHhcCCRSHD79m1s3LgRH374If773/82ldoN0tLsJJVKsXr1akybNg12dnaIiorC4MGD4efnhz/++AOVlZU1zuFyuUhKSsKiRYvw77//YunSpfJr6RodO3bE2rVrcfToUfTp00f+zL0Il8vF/fv38dNPP0EoFOLjjz/GgAEDmkbhOmjpdmIwNAVLKBmvHLIuYDMzM3zwwQdYt24dsrKyUFFRAT09PXmryrVr11BVVYWZM2fi+PHjGDt2LOzs7BAcHNzEd/Cchw8fYurUqRg4cCDGjRuHMWPGYM+ePUhMTMTPP/+M9PR05OTkyFtU9PT0UFxcjCVLlmDr1q1NrH39tCQ7ybCysoK/vz9CQkLQoUMHAICtrS06dOiA2NhY+XFEhHv37uHtt9+Gm5sb2rdvj19++QVTp04FAJ2tzp88eTK6dOlSrRXvRVJSUrB+/XokJiZi7ty5+OyzzwDoXuLV0u3EYGgELY/ZZDC0imywfH2EhoZSnz596MiRI0T0bOJvqVRKfn5+xOFwyNjYmKytrem///0vpaWlaVplhbl16xbdvHmTjh07Rh9++CF9+umnxOFwiMPhUNeuXcnc3Jzc3NzIy8uL3n33XY1Otq5ssUdxcXGDK9Q0dzvVhuye+/XrR1999RUREUVFRdGbb75J9vb2NHPmTPnE4HWhTOGHtiagLy4ulv/7r7/+ovnz59OoUaNo165d8u2NWZmoqVHVTlKpVOOrVDEYTQ0rymG0OEQiEc6cOQOBQIATJ07g77//hp2dXY3j6P8H1A8YMAC9evXCyZMn4ePjAz09PYhEIrRt2xarVq2Cr6+vznXLvUjfvn3B4XDg7OwMLy8vAEB6ejr69u0LT09P3L9/H//++y8uXboEfX39Jp1s/UVKS0sRFhaGoKAg3LlzBxkZGbUe11LsVBuyFqzFixfj1KlT2LRpE1avXg1XV1ecPHkS/fv3lx9b27yhYrEYkZGR+PHHH8Hn8+Ht7Q1TU1Ot3kNtEBGSkpLA5/MRHh6OvLw8BAQE4NGjR1i2bBl4PB6A5rNOtqp2kkql+OKLL/DPP/+Az+dj8uTJ8iIlBqPF0MQJLYOhFqRSKV28eJHeffddsrKyIgDk5OREGzdupJKSkgbP9ff3p3bt2jXr9XpfbOn5+OOPadCgQVpfP7yhli+hUEjh4eE0d+5cMjY2Jg6HQ25ubrRnzx4SiUT1Xrul2Kk+rl+/TpMmTSI9PT0aMWIEbdmyhR4/flzvOefOnSNXV1d5K62Pjw+Fh4fXu0SgtlooZ8yYQZaWljRhwgQaP348hYWFyfc1h5bJulDGTj///DP169ePAJCVlRW9++67FB8fz6YWYrQYWELJaNakpKTQmjVryNHRkQCQnZ0drVy5km7evNmo82XB/Pr16xQdHV1tW3NEpvupU6eoe/fuVF5eTkSaXb/7RWpLVCQSCcXFxdE777xDlpaWBICcnZ1p06ZNlJmZ2ajrtjQ7NURpaSlt3LiRevbsSRwOh9avX9/gORkZGbRx40ZydnYmAGRpaUnvvPMOxcXF1UjetLnmure3N3E4HDpw4IB8W3NOJl9EGTvdvHmTVq5cSXZ2dgSAHB0d6bPPPqPU1FQtaMxgaA4OURMurspgKEFOTg4OHToEgUCA69evw8zMDHPnzgWPx8O4ceOaRReapikuLkbv3r2xf/9+TJ48WWtyr1+/jsGDByMhIQHGxsYQCAQQCARIT0+Hvb09eDweeDwe+vXrpzWdmjtpaWl4+vQp+vbt2+gu4lu3bkEgEODgwYPIzMyEg4MD/Pz8wOPx0KdPn2p2GjRokMbvwcXFBaWlpThz5gzatWuns9M6qYKidpJKpbhw4QIEAgGCg4NRUlKCQYMGgc/nY968ebC1tdWS5gyGmmjqjJbBaAwlJSW0f/9+mjBhAnG5XDI0NCRvb28KDQ3VereuriOVSkkoFFLnzp3phx9+0Krs06dPEwDq2bMnASBzc3NasmRJrauLaBpZ0Y6u0BSFGRKJhGJiYmjJkiVkbm5OAGjgwIH04Ycfaq2FUoaTkxPduHGjTj1fZSoqKig0NJRmzZpFhoaGxOVyaeLEibR///4Gh+wwGLoCSygZOotQKKQTJ06Qr68vGRsbEwBycXGh3bt3a7RSuTlRWFhY58t4y5YtWql2LikpoX379pG7uztxOBwCQO7u7nTs2DH5cntNwf3792nhwoXVulqbit9++40WLlxIDx48aDIdKisrKSwsjGbPnk36+voEgIYOHUqBgYFaSVpkyf3LSX5VVRWlpKRoNbnVZQoLC2n37t3k4uJCAMjY2Jh8fX3pxIkT9Y6LZTCaGpZQMnSK+oprMjIymlo9nSIpKYnatWtHZ8+erbUlTpOtc3UV16xdu1brLV91IZVKadmyZcTlcik4OLjJ9AgODiYul0vvvfeezrSYxsTEEAAaPHiwQsU8mqCqqoqmTJlCFhYWdOvWLa3K1nXS09Npw4YNrJiH0SxgCSVDJ1C1uOZV4969e2RjY0MDBgygoqIirchsTHGNNos9GoNEIiE/Pz8yMDCgM2fOaF3+6dOnycDAgHg8nk51675oJ0WKeTRFUVERDRgwgGxtbenff//ViszmBivmYeg6LKFkNBnZ2dm0ZcsWGjRoEAEgMzMzWrx4MUVHR+vUy1fXePjwITk6OlKPHj20Mn1OcnIy+fv7U+fOnQkA2dvb0+rVq2ttTdK1hJKISCQS0YwZM8jExITi4+O1Jjc+Pp5MTExo5syZDU6JpG3qslNSUhKtWrWK7O3tCQA5ODiQv78/JScna1yn3Nxc6t69Ozk6OtLDhw81Lq+5IpFIKDo6mhYvXkxmZmYEgAYNGkRbt26l7OzsplaP8QrDEkqGVmHFNaqRn59Pffr0IXt7e0pPT9eYnIcPH1JAQAANHDhQoeIaXUwoiYjKy8vJxcWFzM3NtdLqnZiYSGZmZuTi4iKfukmXaMhOdRXzBAQEaDTZS09PJzs7O+rbty/l5+drTE5LgRXzMHQJllAyNI6suMbHx4cV16hAaWkpDR06lNq1a0d37txR+/WLi4urFdcYGRnR7NmzFSquKSwspCNHjuikXUtKSmjw4MHUoUMH+vvvvzUm5++//6b27dvTkCFDdPalroidXizmMTQ0JA6HQ+7u7hor5klNTSVra2saNmwYlZaWqv36LRVWzMNoatg8lC2Mp8IqpBU8hahKCkN9LhysWqO1kfZX2CQiXLp0CQKBAEeOHEFhYSGcnJzA5/Mxf/582Nvba10nXUJRO1VWVmLatGlISEhATEwMBg4cqBY9RCIRTp8+jaCgIJw8eRJCoRCurq7g8XiYPXs2zM3NFboeEcnn4NPFuQYfP36McePGoaKiAhcvXqx1SU5VyMrKwujRo2FiYoK4uDhYW1ur9frqQlk7FRcXIzQ0FAKBADExMTAyMoKHhwd4PB6mTJkCQ0NDteh3/fp1uLm5YciQIYiIiICxsXG9x+tK3NMVMjIy5HP13rp1C1ZWVvDx8QGfz8fIkSObzDeZnVo2LKFsAfzzqAyCqxmIvpuHjMJyvGhQDoBOliZw69kevOGd0L1DW43qkpqaKp9Q+cGDB7Czs5NPqOzs7KxR2bqOsnaqqqrCnDlzcObMGfzxxx8YO3asSnpIpVJ5sn/06FEUFhbC2dlZnuyrO8nSNTIzMzF9+nRMnz4da9euhYmJiVqu+/TpU6xfvx6RkZGIjIxs8b9jVlYWDh06hKCgICQlJcHS0hI+Pj7g8XgYNWqUygsMXLhwAZMnT8aUKVMQHBwMff3qiYcuxT1dJikpSR6Ts7Ky4OjoKF9goFevXhqXz+z06sASymZMZmE5/I/dQty9fOhxOZBI6zalbP/Ybtb4ZpYT7C3V8xIF2Mo1DaGKnV4zN8aCBQtw6NAhhIeHY9q0aUrrkZKSwlau+X9kYa+qqgr6+voqt9gQkfxaAHSydVaTNLQyj7JERkbC09MTfn5+CAwMBJfL1Zm419zQ9so8zE6vHiyhbKYc/jMD604ko0pK9Trqy+hxOdDncvClR1/MG9pJafmlpaU4duwYgoKCEBUVBX19fcyYMQM8Hg/Tpk1rsIvqVUFVO/V6moST332KQ4cOwdfXV2H52dnZ8mT/xo0bMDc3x9y5c8Hn8zFmzJhXPtlnqBepVIq4uDh50lJcXIyBAweCx+Nh/vz56Nixo8LXPHz4MPz8/PDBBx9gBO9jfHGy6eJeS6GyshKRkZEICgpCREQEqqqq4O7uDh6Ph1mzZsHU1FSl6zf1+4nRNLCEshnyU/Q/CPjjb5Wvs2JSD7zv1r3Rx4tEIpw5cwZBQUE4ceIEKisr4eLiAj6fj9mzZ8PCwkJlnVoSqtuJAHDgYlGCX1f6NfqskpIShIWFQSAQICoqCoaGhpgxYwb4fD6mTp0KIyMjFXRiMBqHUChEZGQkBAIBTp48CbFYjPHjx4PP58Pb21uhpGXXrl1Y+WsULFzeUFkvReNeS6eoqAihoaEICgpCbGwsjI2N4enpCR6Ph8mTJys8Lrap3k+Mpoc1T+gQmzZtQq9evSCVSus85vCfGWpxVgAI+ONvHPkzo879O3fuRKdOnRAdHY1ly5bB1tYWHh4eSE1NxZdffomMjAzExMRg8eLFr1QyqT07Pes2jS0yq9dOp0+fRps2bfDbb7/Bx8cHNjY2WLRoEaRSKXbv3o3c3FyEhITAy8uLJZNKEBgYiLy8vKZWo9lhZGSEWbNmISQkBI8ePcLu3bshlUqxcOFCdOjQAT4+PliwYAF69uxZry8BgNmgqWpJJoH6457Mlx4/fqwWWc0BCwsLLF68GDExMUhPT8cXX3yBlJQUeHh4oGPHjli2bBmWLVvWYMwDtPd+ehXt1BxgLZQ6QmlpKRwdHREQEIC33nqr2r4TJ07InVxiZIrWThNgNnoeOFw9peWRRIzSq8fwNDkK3CePYWZmhiFDhmDXrl2ws7NDamoqfv31VwQEBEAikbDimv+nLjsdOXIEJ0+exNWrV3Hv3j206uSE9n7fqiyPSIonN07j6c3TQEk2WpuYoH///ti2bRucnJxw6dIlBAUFYc+ePZBIJOjfv7+8e7GlF4VoCy8vL9jY2GDnzp1NrUqLQFbM8+uvvyI5ORmtW7fG66+/Dh6Ph549e2L//v04efIkUlNTIRaL0aVbD+R2Gg/DnqoVo8l8qSzxFKoKH8KsbRsMHPDMl/r37y8/bsCAARg/fjy2bt2q6q02a2TFPEFBQcjOzoa1tTWWLl0KPp+PXr164aOPPkJsbCzS0tJQWVmJ1+w6odBmMFoPnQWuYSul5TI7NV9YQqkjfPfdd1i3bh0ePXpUbfzhqVOnMH36dLi6uqLcfjhSU5JRmhCBNgMmw2rye0rJIkkV8oK/gPBhKtoOmII+ffthTj8LxMbGolevXjh//ry8uKZz58549OgRHj58CD095RPYlkJddnJ1dUVCQgKGDh2K+KsJ4Fp3Rgc1JJT5v2/D05QYtHUajz79h2D+oA6Ijo6GiYkJLl26JC+u6d27N+Li4vDo0SO0bcsqJdUBEaG4uBjDhg3D6tWrsWjRoqZWqUXx3XffYe3atVi6dCmOHj2KzMxMtG/fHvn5+XB1dYWHhwf09fWx/qdAPLqTALPR82E+lqe0PJkvte43Hq3sesPBVA99jQrB4/EwceJE+XE7duzAihUrkJuby3wJwLZt27B27VrMnTsXx44dkxfzFBUVYfz48ejfvz+MjY0RcPA0/ok7CUPb7ujA2wAOR7kOUGan5gvr8tYRAgMD4eHhUaOYZcWKFXB2dsb2A6HI7TgGFhOWwnTkXDy5cRrigkylZJX+eRyVGbfRYf43sHBfghybkTgRcxURERH4/vvv4eDggNDQUOTm5mLfvn149OgRYmNj1XGb9RITEwMOh1PnHzc3NwDA8uXLMXjwYBgZGWHAgAEa1+tF6rLTgQMHUFJSgl2HwkEm5lDHd9rT1Dg8vX0e7TxXwXLqf5DbcTT2hUQiPDwcp06dwqRJk+QtBAcOHIBIJEJwcLDKchXh559/xoQJE+Dj44Pz589X25efn48uXbpoVR91wuFwUFZWhpKSEnTv/mwsV3P9/tZFOwUGBsLLywsBAQFIS0tDTEwM3Nzc0KZNG0RFReHXX39F9hMpjDy/gHFnZ5RcCYFUVKmUrBd9yXraf9DaeRIeO7jjs00/VktSAGD27NkQCoVa8aXmEPP279+PWbNmITAwELm5uQgNDUXnzp3x8OFDBAYG4uTJkyimVhCOWAjzca9DmJUCUbZy3d66aidG42AJpQ7w4MEDJCUlYcKECdW2p6SkICUlBW+//TaOJGRDj/tsTF3bgdMAEJ7eiVdYFpEUZX+dgEmPkTDq2BMklUAiLEehVT/s2rVLHjC8vb1hbGyMwYMHw9LSEuHh4eq41XoZNWoUcnJyavzZtWsXOBwOli1bJj924cKFSlU9q0JddgIAe3t7cLlcCK5mQDb2UVVK/zwOQ9seMOk5CkRSSCqfwqjfBBw7dgy5ubn45Zdf5NMytW/fHs7Ozlqxk4wffvgBn3zyCXr16gUjIyNMmzYN3377vFVWIpEgPT1da/qoE9lYsfj4eNja2mLcuHEAniWZDY0j0zV00U4v+xKXy4WLiwsOHz6MvLw8hIWFoUuXLvglOhUgKVp1HwlIxKgqzlVK3su+JBVVQo/LQdCVmmP0tOlLzS3mGRsbw9vbG2FhYcjNzcWuXbsgEonwbXAcSCqBnlkHAIBU+FQpebpqJ0bjYFPU6wCXLl0CAAwaNKja9hs3bgAAhgwZgk9i8+TTL+i3tYJeW2uIH91XWJY4PwOSJ4UwbO+AglM/4snt84CkCkU2XdD1zT21FtcMGjQI8fGKJ6+KYmhoCBsbm2rbUlNTsWLFCvj7+2Pu3LkAnr0ggWerniQlJWlcLxl12elFou/mAVC9FUsqLIco+2+0HTQNRbG/oizhd5CoAvmWthC5fVdrcc3gwYNx/PhxlWU3ll27dmH37t3w83tWgf7uu+/Cy8sLFRUV+N///qc1PdQNEcmnU0pJSQERIS0tDQkJCSgpKcG1a9fQpk0bBAQENLGmjUMX7VSfL8mKeWbNmoUxG88jq7gSkqdFAACuieLT2dTlS/pmHXA0Yym+8Piyxjna8qXmHPMsLCywYMECeHl5YcqWc8h8cBPFcQfAMWwFQ9seCsvSZTsxGgdLKHWAO3fuAAAcHR2rbc/JyQEAmFq2Q0Zh9Wo2vTYWqHpSoLCsqsJsAEDpn+HgGreB1eT3AQAll49iypQp+PPPP2sU3XTp0gUHDhxQWJaqFBcXw9PTE66urli/fr3W5b9MXXaS8URYhYzCcrXIqirKAUB4mhoHcLmwcH0LXCMTlP51AvPmzYOpqSmmTJlS7ZwuXbogPz8feXl5aN++vVr0qI8HDx5g1KhR8v+PGjUKUVFRmDBhAsRiMT788EON66BuiEg+KfnVq1cRGRmJ27dvw9fXFzk5ObCwsMDQoUORkZGBe/fuoVu3bk2sccPoop0a8iXgmT89LK6EpKIMT27+ASO7vtBvY6mwrPp8KTVoPY77DIPXzOnVztG2L8lobjHvr7/+wsiRI+X/17e0Q/vZa6HXSvExjc3JTozaYQmlDlBQUAB9fX20adOm2vaKigoAQF65pEabF0fPEFKR4smLVPxsDJJUVA7bt76Hvmk7AIBxZ2c82v02Vq9eja+++qraOUKhEBUVFYiPj0erVspX78no1q1bg3PQSaVS+Pn5QV9fHwKBQKWVR9LS0lBYWKj0+TLu3LkDPT09/P137eODHhSL1dA2+Qyp+JntpRWlsHljC4w69gQAtOo+HCV7l2D16tU1AmhZWRmAZ0vWqXNMXI8ePWo8mwBgbW0tXxVFRr9+/RAVFYXx48cjOzu7wWtLpVIkJiaqTde6GDhwYIPP0IvJ5NmzZ7F9+3ZwuVwcPXoUPXr0gJOTE4RCIYyNjfHPP/9g48aNsLe3x+eff96g/Lt37+LpU+W6ARvLgAEDap2oXh12evLkSZ3PvTI05EvAM3+SkhT5JwMgFT6B5cSlSsmqz5ce7liET/390em16qvEqNuXLC0tq/3+teqpxphXWlqKe/fuKX2+jIbsJBKJ8PmmH7DjSh6ED1NRmZYof8coSkN2+t/6r2oklLIetfz8fJZQ6gAsodRhZMnb0/KKGvtIIgJHX7EJZwHIzzF6rY88mQQAfbP2kHANcOrUKZw6darWc8eMGaOwvNo4e/ZsreMQX8Tf3x+XL1/GtWvXVK7gW7duHX777TeVrvEigwcPrnW7oW0P2L6pniksOPrPurT1zTrIAysAcA1b4YlIips3b9aph6ybTF3ExcXVavsxY8YgLCysxtriffr0wfnz5+UFBfVRVVVV532oC2NjYxQVFcHIyKjel7RsX3h4OPbu3YucnBxs374dw4YNkx9jYGAA4NmLbOzYsfj8888hEolqfITJICKUlZVpZc1koVBY6yTU6rBTYmKiymvI10Z9tje07QFD2+6ovJ8Aqxn/hWEH5RK7+nypVbdhuHPrnMZ96Y033sCvv/5a7zHqjHnXrl2rUcSiCg3ZyfbNrTDpMQJPk2PwOPQr2C74TmF7NWSnW4mx1ZY3BZ4Xyb1qS53qKiyh1AGsrKxQVVWFsrKyaoFEtrZqSUHNyVslT4pgpMQ4Fb02Vs/+bm1eY9/IUaNxK+EqYmJiqm3/6quvcOrUKbWNo2yom/Dw4cMICAhARESEvLpWFb788kv85z//Ufk6P//8M/bu3YsLFy6gdevWNfY/KBbj47P5KssBAL3/79rj1mInD09PHD98ADExMdWel3379mH79u04d+6cWiea79Gj9uds9erVSEhIqHVf3759ER0djdDQ0Hqvra+vX+c11IW5uXmjlwLNzs7G5s2bUVlZid9++w19+vSRt1wSkXzqLGtra7zxxhvo0aMHPDw84OzsDB8fnxrX43A4aNu2rcbvEUC1F+2LqMNOAwYMUOs9NORLALDxhx04+usemLsuQJt+45WWVZ8vyeKgpn3J0rL+rnp1x7xhw4apxV6NsdOLcc+k5yjg9614mnpB4YSyITtVicV4+vQpzMzM5NuLip6NrbW2tlZIFkMzsIRSB5C1Xjx48KDa+EXZ9BA5/yaDgy7y7tSqsgJIyvJhMGCywrIM23UGuPqQlFUff8kBAHElbGxsagzALisrQ9++festRlEXiYmJWLRoETZs2IDJkxW/v9pwcHBosLupMbi5uWHv3r0wMzOrdXL3nsIqrDh7RmU5wP8XXrW2gORJ9a56DoBWXCmMjY0xduzYal2cO3bsgLW1Ndzd3dWiQ0N89NFHeO+9uudC7dChA/bv319vlzCXy9XKc9VYOnbsiLVr16J79+7yrk5Z64fs771792LBggXQ09PDiBEj4OHhgbi4OPj4+FTrNpfB4XCa9B7VYac2bdqo9R4a8qXt27fj6K97YDrEE2Yj5qgkqy5fAgBJWUGT+5ImYp6pqala7NWQnYDncY8AUJUYICmkQsWHYzXGTi+33D548ADW1tZo165djXMY2odNG6QDyAY1//XXX9W29+3bF7169cKv+/bC3vx5Ve+TG5EAOGjdU/EuaK6RCVp1HQLhw9Rq81iaC3Nx9crlWrtJrl+/Xm1Qv6bIz8+Hl5cXXF1dwefzkZubW+2PbJmte/fuITExEbm5uaioqEBiYiISExMhEok0ql9ddpLRyoCLdibqcymT3mMhKX2Migc35Ns6GAoR8ftJjB8/vsZ4uYSEhGoD5DVNdHQ0fHx8sG7dulr3N9dpgyZPnlxt3NyL42/FYjEiIyPlv/Pdu3dx//7z2RZ0setNF+1Uny8dOXIEy5cvx9y5c+E4eYFa5NXmS5LyElT+e61Jfam5xrzi4mKIxWIAQMGjbLTlCgEAT24++6A2slGuWE1X7cRoHKyFUgfo0qUL+vXrh3PnzmHhwoXV9m3evBkeHh5woM/w9LVhEOaloex6BNr0nwQDa3v5cVXFj/Bw5yK07ucO6xkf1SvP3OUNVKbfxKNDa9B28EwQSZFxJRT6XC4cHBxQXFwMc3NzAM8ctrCwEJ6enmq/75eJiIhAeno60tPT5d39L9K5c2ekpaVh8eLF1SZaHzhwIIBnX6vqaImsi7rslJKSgm+//RYnT56E0Ko7JOUlkIqFKI4/DAAwtu8H40795Menb5gBI/t+sOFtqFee2ci5KL9zEY+PfQPToV7gGLZC1tVQQPgU7u7uEAqF8umD8vLykJSUVG9LlCaQrVaRlJSEoKCgOrvFmitXr17F9evX8frrr6NNmzYwMDDAjh07MHr0aAwfPhzFxcVo1aqVzr/UdM1OdfnSxYsXwefzYWBggLCwMBj3yoex4wDI2j6M7HrDwPz5NDvK+hLXqDXKbkRCKhbC1tYWKSkp6NOnDwDt+lJzjXm///47li9fDhMTEzx8+BCte40GSQnlf1+GoU13tO5XfVyuKnZ6kngKHKkE33zzTbVjmyrmMeqGLb2oI2zbtg2ff/458vLyalRSHz9+HP5r1yE1NRV6JmZo4+QOs9HzwdF7/j0gepyGnL3vw3TEHFi4LmhQnjD3Hopj9kP48A7A4aBP794wa22MK1euQF9fH9OnTwefz8elS5cQHByMtLQ0nWx90TYyOyUmJuL48eMQCAS4ceMGjIyMIBQKaz3nxSXjpKIKZG6dC5Pe49DOc2WD8sTFuSiK2ovK9JuARIJOnTvDSA/4+++/YW5ujrlz54LH4yE5ORmffPKJVpch43K5yM3NRUFBATw9PWFkZITw8HB5696jR4/QsWNHSCQSreijCSIjI7Fu3Tr88ssv8pc4ACxZsgQcDgdLliyBUChUW8GaJtBVO8l8KTc3F3/99Zd83WjZ7Ba1YTXtQ7RxflbQp6ovGb3WE+MG98W1qFMoLi7GwIEDwePxIBaLsX79erak3/8js1NGRgaioqIgEAjw+++/QywWo1WrVpBIJOBwuJC2bQ+TnqNhOnw2uIbPxyyrw06CXd/De7JrteN27tyJjz/+mNlJh2AtlDrCwoUL8dVXX+HgwYM11gz28vKCl5cXXt97FZfuF8gnOH8RYWYyOAbGMB3auJZEI5tu6DDvK+hxORjVxQoHFg0H8Gzuy8OHDyMoKAizZ88Gh8PB8OHDERsbK1+V5VWlpKQEhoaGqKysRLdu3WBkZIQZM2bg888/x9SpU+WthfXb6TYADsxG1izgqA0Dcxu0915Tw04pKSkQCAQQCATYvXs3DAwM0L9/f6Snp6Nfv34NXFW99O7dG3/++Sfmz5+PoUOH4siRIw1W8TcXpk2bhoMHD2LBggU4ffq0vBVJLBbDysoKQ4cOlR9b2/hJXULX7DR8+HBUVVXB3t4eRUVFcHBwwEcffQQejydvLQTq9idlfQlANX8SCoWIjIyEQCCAv78/RCIR7O3t5SuGNTTFWUtGKpWie/fuEIvFeO2111BRUYHBgwdj48aNmDdvXrVWVU3ayXvy8BrH7dq1C2+//TZLJnUI1kKpQ2zcuBGBgYFISUmpNXHLLCzHhG2xEFbVXPrt8bFvoW/ZERYubyok00ifi3MfucDe0qTGvnXr1uG7776DhYUF0tPTYWdnBz8/P/B4vDoHaLc0RCIRTp06BYFA8KxLWyiEo6MjysvLkZycXGv1Zn12Korah6onBWjn8YlCetRlJ6lUim3btmH16tVo06YNiouL4ezsDB6PBz8/P9jZ2Sl2wwoga/mSzf9GRPj000+xdetWbNy4EX5+fs2+hVLGjBkzUFxcDAcHBxARDh06hCNHjqh9iiZNoEt2yszMxKFDhyAQCJCUlIRWrVrByMgIJ06cwJgxY2pNyOvyJ2V9Cajbn0JCQsDn8zFkyBBcunQJRkZGmDlzJvh8PqZMmVLrtEwtEdnQiEOHDiErKwsWFhbgcrm4cOFCtWT/RbRpp9OnT2POnDm4f/8+m39Sh2AJZTPj8J8ZWB12S23X2+jtBN+hneo9hohw+fJlBAUF4ejRoygoKICTk5M8abG3t6/3/OaGVCrFpUuXEBQUhODgYBQWFqJ///7g8XiYP39+o5K0prCTSCTC6dOnIRAIcOLECQiFQri4uIDP52P27NnycbHqQk9PDzk5OTUC+uHDh7F48WK4ubkhMjKyRSSUAPDdd9/h5s2byMrKwqJFizBv3rymVqlRNLWdiouLERoaiqCgIMTGxsLIyAgeHh7g8XiNTtJ+i7+Hz3+/qzadGuNPWVlZOHToEIKCgpCUlARLS0v4+PiAx+Nh1KhRLa63JjMzEwcPHkRQUBBu374NKysr+Pr6gsfjYeTIkY1qff/p1A0EXGh4ovzG0hg7MXQHllA2M1JSUuC+fBOMhqreMsK9/Tsu7/kCHTp0aPQ5IpEIZ86cgUAgQHh4OIRCIcaNGwc+n485c+aoPWnRJi92I6enp8Pe3h48Hg88Hk/hbuRjx47hrYAjMB/3usp6tc+5gou/rFWodaS0tBRhYWEICgpCVFQUDA0NMWPGDPB4PEybNq3WtcAV5eWWrxdJTEyEl5cXMjMzW0xCKaOiokItK0Zpi6awk6wbOSgoCBERERCJRHB3dwePx1O4G1kkEsHLywt/lluh9UgVkngigMPBdDsJtr/nodCpt27dgkAgwMGDB+WrDsl6a+pqsWsOFBUVISQkBAKBALGxsTA2Noanpyf4fD4mTZqkUMzJzc3F2LFjIek5AVKnGcor9f92enOABb701fzsIgz1wRLKZsSDBw8wZswYWFtbY/n3R7Dp/ANUSanWsXp1ocflQJ/LwQejOuCbRTPQvn17xMTEKJUIlpaW4tixY/Kk5cVinmnTpjV6MummJDs7W94Fd+PGDXmhC5/Px5gxY5RqhTh37hymT5+OWbNmweOjDfjy91Sl7eTbjYONb3vC29sbQUFB8om1FeHhw4c4fPhwjXvk8Xg15t9ThNjYWIwePbrOCbULCgoQERGBN954Q6nr6yq6PlbyZbRlJ6lUiri4OAgEAgQHB8sLXfh8PubNm4eOHTsqfE2JRAIej4djx44hIiIC+WY9sO5EstL+1DHnIi4dCEBkZKRSc0zWdY+y3gtl7lHbVFZWIiIiAgKBABEREaiqqpIn+7NmzVJqzGhRURFcXV2Rn5+Pixcv4mq+nkp24lwPxpObf+DixYsarWJnqBeWUDYTcnJyMHbsWHA4HMTFxcHGxgaZheXwP3YLcffyocfl1Ou4sv1ju1njm1lOsLc0QXJyMsaNG4devXrhjz/+UGkqkReLea5fvw4zMzN50qJrxTwlJSUICwuDQCCo1nrH5/OrFdcow5UrVzBhwgSMGzcOx48fh6Ghocp2CgsLw9y5c7FkyRLs2LFDpWSmtlZYPz8/8Pl8rRfzNCUZGRmwtbWVL6WoLsRiMXJyctCp06vTTaep1jsiwjvvvIM9e/YgODgY3t7eAKCSP3Voow9PT0/ExcXh/PnzGD68ZrFHY3mxmOfkyZMQi8UYP348+Hy+zhXzSKVSXLhwAUFBQQgJCUFJSQkGDx4MHo9Xo7hGUZ4+fYqJEyfi7t27uHDhAvr27QtANTsZiErlMydcvHgRNjY2dZ7L0B1YQtkMKCwshKurKwoLC2v9YvvnURkEVzMQ/XceMgrK8aJBOQA6WZnArUd78Ed0Qrf21Svirl27Bnd3d4wePRonTpxQy6Dz1NRUedKSlpamE8U8tRXXuLq6gsfjqW184a1bt+Di4oK+ffvizJkzMDGpPpBcFTsFBgZi4cKFWL16Nb799luVdZWNExUIBDh69CgKCwu1VszT1ISEhMDX1xcffvghAgIC1NbaSET4+OOP8f333+PIkSOYM0e1FV50mZeLa2TjC/l8PkaNGqWW33T16tXyQsUFCxbU2K+sP5WXl2PSpElISUnBhQsX1PIhJRsnKhAIEBMTozPFPC8X1zg6OsqH8ahjfXmhUAgPDw9cunQJUVFR1WY9kKGsndLS0jB69GhYWVkhNjZWrcvJMjQEMXSasrIyGjFiBFlZWVFKSkqDxz+pFFPI+StkaNuDQs5foSeV4gbPOX/+PBkZGdHcuXOpqqpKHWoTEZFUKqX4+Hh69913ycrKigCQk5MTbdiwgTIyMtQmpy4kEgnFxcXR0qVLydLSkgBQ//79adOmTZSZmalWWffu3SMbGxsaMGAAFRUVNXi8MnbaunUrAaCNGzeqQePnCIVCCg8PJx8fHzI2NiYOh0Ourq60Z8+eRt1Lc+L06dNkYGBAPB6PJBKJ2q8vkUjIz8+PDAwM6MyZM2q/flNSVFREe/bsIVdXV+JwOGRsbEw+Pj4UHh5OQqFQrbI2bNhAAGjbtm2NOl5RfyoqKqIBAwaQra0t/fvvv2rQ+DmZmZm0adMmcnZ2JgBkaWlJ77zzDsXFxWnkmXuZjIwM2rBhA/Xr148AkJWVFS1btozi4+NJKpWqTU5VVRXNmTOHjIyMKCoqqlHnKGqn5ORksrKyopEjR9KTJ0/UoTZDg7CEUoeprKykiRMnUtu2benPP/9s9HkJCQkEgBISEhp9zvHjx0lPT48WLVqk1qAjQygU0okTJ8jX11eetLi4uNDu3bvVnrQkJyeTv78/de7cmQCQvb09rV69mm7duqVWOTIePnxIjo6O1KNHD3r06FGjz1PGTmvXriUAtGvXLmVUbZCSkhIKDAwkd3d34nA4ZGRkRLNnz6awsDCqrKxs8Px79+6Rh4cH3bt3TyP6qUJ8fDyZmJjQzJkzSSQSaUyOSCSiGTNmkImJCcXHx2tMjio01k6VlZUUFhZG3t7eZGRkRBwOhyZMmECBgYFUUlKiEd127txJAOjzzz9X6DxF/Sk3N5e6d+9Ojo6O9PDhQ2VUbZCkpCRatWoV2dvbEwBycHAgf39/Sk5OVqucwsJC+uWXX8jFxYUAkLGxMfn6+tLJkyfVnuwTPWssWLRoEenp6VF4eLhC5ypqp2vXrlGbNm1o4sSJjYpBjKaDJZQ6ilgslgfx6Ohohc5VJlEhIvr1118JAK1YsUIjSaWMkpIS2r9/P02YMIG4XC4ZGhrSrFmzKDQ0lCoqKpS65sOHDykgIIAGDhxIAMjc3JyWLFlCsbGxGm0VyM/Ppz59+pC9vT2lp6crdK4ydpJKpfTBBx8Qh8Ohw4cPK6quQmRlZdX6m8bExNT5myr77GmaxMREMjMzIxcXFyovL9e4vPLycho3bhyZm5vTzZs3NS5PUeqzk0QioZiYGFqyZAmZm5sTABo4cCBt2bJFY4mXjEOHDhGHw6EPPvhA4RikzLOXnp5OdnZ21LdvX8rPz1dU3UZT128aEBCg9G9aUVFBISEhNGvWLDI0NCQul0sTJ06k/fv3ayzZJ3oWgz7++GMCQAcOHFD4fGXsFB0dLf+4FYsb7s1hNA0sodRBJBIJvfXWW6Snp0cnTpxQ+HxVXuo//PADAaCvv/5a4XOVITs7m7Zu3UqDBg0iAGRmZkaLFy+m6OjoBhPB4uJi2rdvX43WtGPHjmnlS7a0tJSGDh1K7dq1ozt37ih8vrJ2kkgk9Prrr5O+vj5FRkYqLFcZamv1XbVqVY1WX11MKP/++29q3749DR48WKMv2pcpKSmhQYMGUYcOHejvv//WmtzGUJudtNWaVhcRERGkr69Pb7zxhlIfgco+e6mpqWRtbU3Dhg2j0tJSheUqiqzVd/bs2WRoaEgcDofc3d0b1eorkUgoOjqaFi1aRGZmZgSABg8eTFu3bqXs7GyN605E9NVXXxEA+vHHH5U6X1k7nThxgvT09GjhwoUabfBgKA9LKHUMqVRK//3vf4nD4VBQUJBS11D1pf7ll18SAPr555+VOl9ZUlJSaM2aNeTg4EAAyM7OjlauXElJSUnyY2Tj/ebOnSvvOndzc9P6eL+Kigpyc3MjU1NTun79ulLXUMVOIpGIPDw8qFWrVnThwgWl5CuDbFzqO++8Ix+X6uzsLB+XqmsJZWZmJnXq1Il69epFjx8/1rr8vLw86tWrF3Xu3Fnt43ZVQWanyMhI2rhxY43xfhcvXtTqS/vq1atkbGxMnp6eSrdAqfLsJSQkkKmpKY0fP17pXhJlkI1LdXNzq3dc6s2bN2nlypVkZ2dHAMjR0ZE+++wzSk1N1ZquREQ//fQTAaD//e9/Sl9DFTsdOHCAANB///tfllTqICyh1DGkUikdPXqUduzYofQ1VH2pS6VS+vDDD4nD4dChQ4eU1kNZaivm6dKlCw0fPlz+Va6p4prGIBaLydPTk4yNjVVK5lS1kyyp9fT01Mpg/5eprZhnyJAhBIBiYmK0rs/L5Ofn60Qyl5GRQZ06daLevXtTQUFBk+kho6ioSD4WVzbeTlPFNY1BKpVSTk4Ovfnmmyolc6r6U2xsLBkbG5OXl1eTdKu+XMxjbm5Ow4cPpy5dumi0uKaxHDx4kADQRx99pJJ8Ve30008/kZWVFeXk5CitA0MzsIRSB1E1OVBHK5FEIqGoqCgqLi5WSRdVSE5OplWrVlG7du0IAHE4HAJAQ4YM0UgxT2OQBdKUlBSVWwfUYafy8nISi8Vqrc5XBlkxz7BhwwgAGRoaKlTMo26kUilJJBKKj4+n3Nxcrct/mdzcXLp06RJJJJImSQZeLq6RJZPr1q3T6jCAuhCLxSr/Lurwp9TUVLlfN4WdZMU1gwcPltsIALVv355WrVqlteEHtVFcXExRUVE6Yaf8/Hw2llIH0Z3ZphlydGEScC6XC1dXV5iZmWlVbnZ2NrZs2YJBgwahb9++2LVrF7y8vBAbG4vCwkLs378f5ubmWLp0KTp06ABvb2+EhYWhsrJSKXlSqVSh42Xz6/Xq1Ust87ipSqtWraCnp9fgCjqBgYHIy8vTmB6mpqZYsGABduzYAQBYtmwZ7t+/D29vb9jY2ODtt99GbGyswr+3DGXsxOVyMXLkSIWWFtUUHTp0wIgRI8DlcrW2yo5UKkVsbCzefvtt2NjYwNvbGw8ePMA333yD06dPAwA8PDx0YgJufX19nVh9qFevXujZsycAaE2fyspKhIaGyn3lnXfegaWlJfbv34+ioiLExMTA09MTu3btQt++fTFo0CBs2bIF2dnKr5mtjB+amZnB1dVVJ+xkaWlZ58pPMjQd8xi10NQZ7auGNlqSmmocm7LdZcoU16hSzPMiP/74I82bN0+h6X7UhTbt5OnpSUuXLtW4nJfvqbHFPA3RlHZqKpT1p8YU12jz2dNW63lTxD1lbaRMcY0qxTwv8yrEPW3FPMZzWEKpJfbv3y//t6YDrDYDq1gspj179tDYsWNpxowZ9OWXXzYqSKmzuKYxxTx1kZeXRyYmJnTp0iW5XtpCG3aSSqVUWFhI3bp1oz179mhMjoy67qmhYp6GaEo7aRNl/SkzM1Oh4hptPHvajHlE2ot7ytqISH3FNY0t5qmLlhz3tB3zGM9hCaUWeP3114nD4dCCBQvkjqvJAKuNwBoTE0N//fUXubu7k7OzM/3vf/+j77//ntq2bUsLFy6st6L2xx9/1MjKNbUV8yxYsKDec0pLS2nkyJEUEBAg35aZmUnjxo2jH374QaPj/7T1AkxPT6d27dpRbGwsEWl2bFhj7qm2Yp6dO3fWq1dT2kkbKONPUqmUSktLlVq5RtPPnrZjHpHm70nZmCeVSun27dvk5OSkkeKal4t5rKysGvwob+lxT5sxj/Gcph+s18L56aefcOPGDSxfvhwpKSnw8/NDaWkp9PT0IJFImlq9RkEvLfcuEAjg7e2NEydOoG/fvjh69CjWrl2L5cuXY/v27UhOTkZSUlKt1xKLxbCzs8Pbb7+NW7duITExEZ988ola1o7mcDgYNWoUfv75Z2RnZ+PEiRPg8/kQi8W1Hi+RSNC2bVv07dsXFy9eBPBs3I27uzskEgmcnZ1x6dIlvP/++/jiiy9w9+5dlXXUJrJxUvHx8bC1tcW4ceMAPPudXrapNjE0NISHhweOHDmCR48eYd++fZg8eXKdOrU0O6nLnzgcDtq2bYt+/fph3759ePToEY4cOQIPD48mWzsaYDHvZTgcDrp27YqBAwfi5MmTyM7Oxvbt29W25rmdnR0++eQT3Lx5E0lJSfj6669hbm5e5/EtzZ9eRFdj3qtC/aNaGSpTVFSEiRMnYuXKlfjjjz+wY8cOzJ8/H/v27UOHDh0glUp1oginLh4/fox27doBeBaI9PT0cPjwYSxYsADvv/8+9PX1YWFhId/XrVs33Lt3D127dq31egYGBvD09ISXl5dG9TY0NMTMmTPrPUZWyDJz5kx8++23GDduHLKzs/HGG29g1apV0NPTwzfffAOhUIiEhARs27YN06dPx7Zt23Si0KM+iEj+XKWkpICIkJaWhoSEBJSUlODatWto1aoVtm3b1qR6yop56qMl2Und/kRE+PHHH7V5Cw3CYl5NjI2N8euvv2pcdycnJzg5OYGI6kxWW5I/vUhziXktmqZpGG357Nu3j65du0YSiYTu3r1LRM8moz548CCNHTuW3Nzc6P79+/Lj1Tmnlrq6FDZv3kw2Nja0bt06KisrI6Jn0zUMGzaMtm/fXu1YWZfCnj17aMiQIU0ypY8iyPStqKigo0ePEofDof79+9e6VOOTJ0+IiOju3bs0YMAA+u6776pdQ1k01fXzol5XrlyhQYMGEYfDoWHDhpG9vT05OzvTm2++SYsWLVL7tFDqviddsJO60CV/0sSz15Qxj0g996RLNtIEuuBPmnj2mjLmMZ7DEko1I5VKqaSkhCwsLKpNTv6is4aGhtKECRNo1KhRlJycTCEhIdS+fXu1rZOrLod9+vQphYSEUM+ePWns2LFUUFBA9+7do9atW8srEV8OLsOHD6f169fXuk9XkI3lKikpoTfeeIOGDx9OHA6HVqxYQUTPbVWb/r6+vuTl5aWWJdo0HVj/+OMP8vT0pCFDhlBwcDDdvHmTpFKpfHxUYWEhrVq1in755Re1yVfnPemKndSFLvmTOu2kCzGPSD33pEs2Uje64k+a+ugkapqYx3gO6/JWM0QEU1NTTJw4EWlpafJtXC5X3g3h7e0NY2Nj7Nq1C1OnTkVOTg7WrVuHjh07Nq3yL2FiYoLZs2djyJAh8PPzw8SJE2FjY4OpU6eidevWAKrP1RYeHo60tDQsXry4xj5dQk9PD3fu3MG8efMgFovx22+/4eeff8aDBw8gFothYGAA4Ln+si66jIwM6Ovro7KyEm3btm3KW6gTmc7h4eHYu3cvcnJysH37dgwbNkx+jOz+cnJyIBQK8e2336KgoACrV69uEp3roqXZqaX6E4t5um8joOX5k4yWFPOaPU2ZzbZEZF9Ln376KfXs2VPebfLyfiKijRs3EofDoS1btqhVB3V+Acq+WouLiykgIIA4HA55eXkRUfWqTaFQSKNHj6Z169bJtxUVFVFeXp7KOqgTiURCq1atIkdHR5o+fbp8FZVz585R27Zt6/wCv3nzJk2YMIFGjBhBkZGR8mupgqa6vB8+fEijR4+mwYMHy+cefLnVQab77du3afz48WRubk43btxQWba67kmX7KROdMWf1N1CSdS0MY9Ivc8eUdPbSJ3okj9pIu41ZcxjPEd3R0Y3Mx48eIDU1FQ8ffoUAODu7g4TExOIRCL5MVKpFBwOBxKJBLdv38bGjRvx4Ycf4r///W9Tqd0gslYGMzMzfPDBB1i3bh2ysrJQUVEBPT09eeXctWvXUFVVhZkzZ+L48eMYO3Ys7OzsEBwc3MR3UBMrKyv4+/sjJCREPsjc1tYWHTp0QGxsrPw4IsK9e/fw9ttvw83NDe3bt8cvv/yCqVOnAtCNFY1qo2PHjli7di2OHj2KPn36yJ+7F+Fyubh//z5++uknCIVCfPzxxxgwYEDTKFwHLdFOLcmfWMzTfRu9SEv0JxktJeY1e5oslW1BZGVlUc+ePcnIyIgGDhxIo0ePpnnz5hGHw6H169dTWlpajdUP4uLiaNWqVRrRR5PzfIWGhlKfPn3oyJEjRPTsi10qlZKfn598Ljxra2v673//S2lpaWqXrwlkX679+vWjr776ioiIoqKi6M033yR7e3uaOXOmfD4zdaKN+dhEIlGt25OTk2nBggU0YsQI+WB7It1sfZDRVHbSJE3lT6raSddiHpHmnr2WGPOIWm7c03bMYzyHjaFUA6+99hpCQkIglUpx//59xMbGolWrVgCAzz//HPv370dBQQEGDhwIMzMz2Nra4uuvv8aYMWOaWPPniEQinD17FpMmTZKPN3kR+v+xUAMGDECvXr1w8uRJ+Pj4QE9PDyKRCG3btsWqVavg6+vb7L76ZF/cixcvxqlTp7Bp0yasXr0arq6uOHnyJPr37y8/tr4pT+7fv48uXbpoRefGIrNlSUmJfF32hIQEbNmyBenp6Xjrrbfw9ttvA6j/3nQBddhJIpEgNzcXr732mkZ1zcrKwt27d+Hm5larHs3dn1pCzAOApKQkSKVS9O3bt0bca+42aghV/amqqgpZWVno2LFjk857+jItKeY1O5o4oW0x1FYZ5+fnR19//TXdvn2bTpw4Qdu2baO5c+fSBx98oFFdGvsFWNtyeJGRkfWuaCGVSsnf35/atWvXYtdVvn79Ok2aNIn09PRoxIgRtGXLlnpX/iF6NgUKh8MhJycn2rBhA2VkZDQoR1tLLyYmJlK/fv3o33//pcuXL9Ps2bNpzJgxFBQUJD9OXV/p2lz2U1E7VVVV0fHjx1Va5rM+ZMvhyVau6dy5c4O/a1P5kzrspEsxj6jx95SRkUEbNmyQr1wzf/78eo9/FWIekXJxb9y4cfJlPuPi4hoVR7Sx9KI2Yx7jOSyhVDMvPqQff/wxDRo0iCoqKrSqQ0MOm5ycTP7+/tS5c2cCQPb29rR69Wq6detWvdeVvUCuX79O0dHR1ba1REpLS2njxo3Us2dPeVdeXVRVVdGJEyfI19dXvpygi4sL7d69u86kRZvJ14wZM8jS0pImTJhA48ePp7CwMPk+dQZWbd6TDEXs9OTJE9q3bx+5u7sTh8MhIyMjmj17NoWFhSm13FxlZSWFhYWRt7c3GRkZEYfDIXd3dwoMDKSSkpJ6z21Kf9JE4R5R08U8ovrvqbCwkH755RdycXEhAGRsbEy+vr504sSJepepfNViHpFi/pSUlESrVq0ie3t7AkAODg7k7+8vL4ypDW3FCG3FPMZzWEKpAWQB59SpU9S9e3cqLy8nIs2vZSujNod9+PAhBQQE0MCBAwkAmZub05IlS2qd0JZRkwcPHtDt27eJqOFgVFJSQvv376cJEyYQl8slQ0ND8vb2ptDQ0GpJi7aTL29vb+JwOHTgwAH5NnXbvikSyhdRxE5ZWVlK+YREIqGYmBhasmQJmZubEwAaOHAgbdmyRa3zKmoSTc0F2FQxj6jmPVVUVFBoaCjNmjWLDA0Nicvl0sSJE2n//v0NJvuMZzTWnxTxCW3GCG3EPMZzWEKpQYqKisjGxoZOnz6tVbkyh42NjaXAwMAarTHHjh1TqjWGoTjZ2dm0detWGjRokDxpWbx4MUVHR9Off/6p9eRr3LhxNGDAAHr06JFGWlqaOqFUlpdb7Tt16lSj1f7WrVsKt8boKpqyU1PFPKLn97Rr1y5avHgxmZmZEQAaPHgwbd26tUaREEMzyFrtZ8+eTYaGhjVa7bUdIzQd8xjPYQmlmnj5q0cqlZJQKKTOnTvTDz/8oDU9hEIhbd26lQDIu+A0MV6ssYjFYiIinUlgZXpos+VERkpKCq1Zs4YcHBwIAHXo0IEA0OHDh7Wqh5OTU63zr4nFYpV/F3WNzROLxSSVSrXemlDbuGJbW1uysbEhAPLxYhcvXtT6y0kikZBUKiWRSKQTy9+9rENTxTyiZ/MlvvnmmwSAAJCjoyN99tlnlJqaqlU9iJ7HFl2JebLhB7JYrE1k44rd3NzkFfETJ04kAHTlyhWt6VFXzKuqqmItlmqEJZRq4NatW5SXl1erw27ZskXjU0nU9hIEQP/5z38oMzNTo7Ibory8nLy8vOi1115r8ik1AgMDycDAgPbv39+kekilUoqPj6c5c+bIbaVIMY865L/4t+zfSUlJNGPGDHr69KnS11Y1UZFKpbRs2TIyNzena9euKa2HKsheguPGjSMAxOVySU9PjzgcDrm6ujbZxxkR0dWrV8nMzIzee+89lZJKVe309OlTunDhQq0vY23EPKKaxTWyFsl9+/Y1eUuUrsSaBw8e0GuvvUbe3t5NMq71RTIzM2nTpk3UrVs3AkCmpqYKFfOoQl0xTygUkqenJ/35558alf+qwBJKFUlOTiZLS0uaM2dOrU6hycBWV3HNkSNHdKrbMTs7m7p27UrdunWTr9CgbcLCwojL5dLSpUub/GUjQ/ZS37Ztm0LFPJri2rVr1Lp1a5o2bVq9hQr1oWqismbNGgJAe/bsUep8ZWmouKa4uFitxTyqsHv3bgJAn332mdLXUMVOQqGQpk6dSqamprWuCqNJ/6qvuObKlSs6E/ekUim9/fbbpKenR8eOHWsSHXJycqhbt27UtWtXysnJaRIdakP27Mnmu2zK4SPl5eU0cuRIsrKyapZDV3QNllCqwP3796ljx47k7OxMhYWFWpHZmOIaXRzHdv/+fbK1taX+/ftrPVE6e/YsGRoakq+vb5N0ddfFy3ZqbDGPJpH9VvPmzVPqt1Ll2QsICCAAFBAQoPC5yqBscY2yxTzqZPPmzQRA6SUMlbVTVVUV+fr6kqGhIZ07d04p2YrS2OIaXYt7VVVV5OPjo9XfSkZhYSE5OztTx44d6f79+1qV3RAv2kkXCtxkv9Vrr71GDx480IrMlgpLKJVEm61uJSUlChXX6FpglXH79m2ytLSkUaNG0ZMnT7Qi8/Lly9S6dWuaOnWq0q1umqI+O9VXzKPppCU0NFTp1lxln709e/YQAFqzZo1C5ymDOotrGlPMoyn8/f0JAO3du1fhc5Wxk6zVjcvlVpuCRRNIJBKKjo5WqLhGF+OeUCikKVOmUOvWrbU2ZvDJkyc0cuRIsrS0lFdo6xJ12amhYh5NkpOTQ127dtW51tzmBksolaCgoICcnJw0+kUjFAopPDyc5s6dK+8KbWxxjS4GVhlXr16lNm3a0OTJkzWe4CUlJZGFhQWNGTNGpXGBmqKxdnq5mMfe3p5WrlxJSUlJGtNt3759BIBWr16t0HnKPHvBwcHE5XJVHhdYH5mZmbRx40ZydnbWSHFNbeOYnZ2dadOmTRobxywbb8rlcik4OFihc5Wx06pVqwgABQYGKqhp47l58yatXLmS7OzsFC6u0dW49/TpUxo9ejRZWFho/EOjsrKSJk2aRG3atGmyMcgN0Rg71VbM4+PjQ+Hh4Rp7bzx48IA6duxITk5OWutxbGmwhFJBysrKaMSIEWRlZUUpKSlqvba6Xkqy6lhdGSv4MufPnycjIyOaO3euxrqg7927RzY2NjRgwIAmK6BoCEXtJCvmeffdd8nKykrjxTyy2QI2btzY6HMUfamfPn2aDAwMyM/PT+0tr8XFxdVWrtHGS4lItY9BRZFIJOTn50cGBgZ05syZRp+nqJ02bNggH++rbl4urrGysqJ3332X4uPjFYphuhz3ioqKaMCAAWRra0v//vuvRmRUVVXRnDlzyMjIiKKiojQiQx0oaidZMc/LH4OaKOZJTk4mKysrGjlypNZ60VoSr3xC+aRSTLcfFtP19EK6/bCYnlTWPbVCZWUlTZw4kdq2bavWqjBlV65pzhw/fpz09PRo0aJFan8BPHz4kBwdHalHjx4tdqk0oVCo8Mo8yrB27Vr53H4N8aRSTCHnr5ChbQ8KOX+lXl8iIoqPjycTExOaMWMGiUQitej7YreZoivXaIK6innUOResSCSi6dOnk4mJCcXHxzd4vKJ22rlzJwGgzz//XC36Ej1LsHbv3q3wyjXNmdzcXOrevTs5OjqqfXygVCqlRYsWkZ6eHoWHh6v12rpEXSvzqLNx59q1a9SmTRuaOHFigz6qSP7wKsAhIsIrxj+PyiC4moHou3nIKCzHiz8AB0AnSxO49WwP3vBO6N6hLQCgqqoKvr6+iIiIwOnTp+Hq6qqSDtnZ2Th06BAEAgFu3LgBc3NzzJ07F3w+H2PGjHklFqw/c+YM0tPT4eXlhXbt2oHD4ah8TYlEgpSUFJw+fRp+fn547bXX1KCpblNaWopjx44hKCgIUVFR0NfXx4wZM8Dj8TB9+nQYGRkpfW0iwn/+8x/89NNPOHToEHx9favtV8aXAODmzZtwcXHBgAEDcOrUKbRq1UppHaVSKeLi4iAQCBAcHIzi4mIMHDgQfD4f8+bNQ8eOHZW+tjp5+PAhDh8+rBGfr6iowJQpU5CUlITY2Fg4OztX26+snQ4fPgw/Pz+8//77+P7771Xy0crKSkRGRiIoKAgRERGoqqqCu7s7eDweZs2aBVNTU6Wv3Vx4+PAhDh48iClTpqBPnz7Q09NT+ZpEhMePH+P48eNwcHDApEmT1KCpbqNpn4+JicGUKVMwY8YMHD58GPr6+vJ9yvrSq8ArlVBmFpbD/9gtxN3Lhx6XA4m07luX7R/bzRpfefbFlyuX47fffsOxY8cwc+ZMpeSXlpYiLCxM/uI3NDTEjBkzwOfzMXXqVJVe/M0ViUSilqD6IlKpFBwORy0JanMjJycHhw8fRlBQEK5fvw5zc3PMmTMHPB4P48aNUyppkUqlWLBgAQ4dOoQTJ05g6tSpSvvSN7OcUFnwEGPGjIG9vT2ioqKUTiRu376NoKAgHDx4EJmZmXBwcICfnx94PB769Omj1DW1RUpKCgQCAQQCAdLT09GpUye57v369VPqmqWlpXBzc8PDhw8RFxeH7t27q2SnW1di4OnpCT8/PwQGBir97Fy4cEH+4i8pKcHgwYPB4/Ewb9482NraKnWvzRl61jOo9kYDTcTS5oBQKERkZCQEAgFOnjwJsViM8ePHg8/nw9vbW+n4cvLkScyaNQtvvvkm9uzZg6yiCqV9yd7SRNnba1a8Mgnl4T8zsO5EMqqkVO+D8DJ6XA5IUoXHp3/Gzk9eB4/HU0iuSCTC6dOnERQUhJMnT0IoFMLV1RU8Hg+zZ8+Gubm5gnfCYDSO1NRUedKSlpYGe3t7zJ8/H3w+H05OTgpdSywWY86cOTh79iw+3XMSQakipXxJjwMILx2ASU4i4uLiYG1trZAeWVlZOHjwIAQCAZKSkmBpaQkfHx/w+XyMGjWq2X1ESKVSXLp0CQKBAEePHkVhYSGcnZ3B5/Mxf/582NnZKXS9x48fY9y4caioqMCqX8LxXVy2UnbiglBwZgfG2ekjJCSkWgtNY0hKSoJAIMDBgweRlZUFR0dH8Hg88Hg89OrVS6FrMRiNpbi4GKGhoRAIBIiJiYGRkRE8PDzA4/EwZcoUGBoaKnS9oKAgvP7665i1YjOSjfsq5Uv6XA6+9OiLeUM7KXo7zY5XIqH8KfofBPzxt9LnExE4HA5WTOqB9926N3i8ul8SDCAwMBDTp09H+/btm1qVZgcR4fLlywgKCsLRo0dRUFAAJycn+fNob2/fqOtUVlZi5OIvUWQ/RhVlAA4HS4bbYI3X4EadIntJBAUFITY2VuWXhK6iro/PzMxMjFn6FTj9PZTWRRbzPnTrgg8n9W60XFmyf+vWLVhZWcmT/ZEjRza7ZF8XYHFPebKysnDo0CEEBQWp9PHJ/zYIF0st8GxRM+Wf4cbmD82ZZptQbtq0Cfv27UNKSkq9XQeH/8zA6rBbapO70dsJvrV8aezcuRNffvkl3njjDRw9elTeIiT7Kle2G4vxDC8vL9jY2GDnzp1NrUqzRiQS4cyZMxAIBAgPD4dQKISLiwusrKyQlJSEO3fu1OlP2vIl4Fl3k4+PDyZMmICzZ89CJBKppRuruVBSUoKwsDAIBIJqw2Nat26NK1euIDU1VSfsFBISAj6fj0GDBuHKlSswMjKCp6cneDweJk+e3GKS/aaCxT31cOvWLXmLuWx4jKOjI9LS0nDv3j2d8KXTp09jzpw5ePDgAdq1a6c2mdqkWSaUpaWlcHR0REBAAN56661q+06cOIEvvvgCKSkpsLJuh8ou49BmpC84XOXGluQKVkOYebvG9smTJ+P06dPy4poDBw7g5s2baNWqFfh8/itVXKNJiAjFxcUYNmwYVq9ejUWLFjW1Si0GWTHP/v37ERMTAz09PXkyMH36dBw/fhwnT57E1atXce/ePbTq5IT2ft+qJDP/9214evt8je09e/ZESkpKjYH27dq1w+rVq3WquEbbyIp5fvvtNyQlJVWLMb1798b+/ftx8uRJpKamQiQSQ9TWBm2GeKJ173FKy6zPTomJidWKa0QiETp16oT//e9/r0xxjaZhcU8zyIp5AgMD8dtvv4GIqhXzbN68GbGxsUhLS0NFZSWkJtZo1WsMTId7g2uoXOFgfb50586datsGDBiA8ePHY+vWrUrJamoUGxijI+zbtw9VVVWYP39+te2nTp2Cl5cXXF1d8eOPP2LL4bPIjj4M0ZMiWE1+T2l5em2tYe7yJgCAywW6WpnA2boSEyZMqNZ60KVLFyQkJGDXrl2se0dNcDgclJWVoaSkBN27P+sukHXHMVTD1NQUb775JoqKipCQkIDPPvsMR44ckXevGhsbo6SkBCNGjEBGdh7U9uWpZwCrqcvB5QLd27XBjK5GSEhIgIODg7z1YNmyZdDT08OWLVuwZMkStG37alVLvshrr72Gjz/+GHp6eli7di2WLVuGI0eOYPfu3WjXrh0KCgrg4uKCzz77DIJrWbgV/wfywzdBnJ8J87GKjfmuxkt2cu0gxp9//gkbGxt5cc2GDRsgFAqxfv16eHt7v9J2Uics7mkGLpcLFxcX3LhxA8eOHcMvv/yC4OBgfPrpp1ixYgVMTU0xdOhQzJ8/H6G3C5F6OwklV0JQmX4THXgbwOEo2UD0ki+969oNZmZmNQ5bunQpVqxYgS+//LJZ+lKzbD4LDAyEh4cHjI2Nq21fsWIFnJ2d8ccff8DVYx4qh70J05Fz8eTGaYgLMpWWxzUyQZt+bmjTzw0mfdyQ02E4vgs8DKlUit27dyM3NxchISFYs2YNMjIyEB0dreotKsTPP/+MCRMmwMfHB+fPV/8Sys/PR5cuXbSqj7qQSqUAgPj4eNja2mLcuGctLhwOR76vOaGrdgoMDISnpydWrlyJhIQEpKSk4L333oO+vj4qKipwL+8JyMQc6urM4HD15L70sN1QfL7lZ0RHR2P69Om4ePEi7t+/j6+//hrvv/8+hEIhgoOD1SK3LmJiYuSzAtT2x83NDQCwfPlyDB48GEZGRhgwYIBGdaqNwMBAeHl5YePGjbh//z7i4uIwceJEtG3bFtHR0dh99HfkdXJF+3lfw7izM0quhEAqqlRa3st22rTrN9y7dw8ffPABUlNT8ddff+Gjjz7CwoULtWKnF9FVX1IHLSnu6aqdZDmEr68vQkJC8OjRI+zevRuDBg3C+fPn8eV3vyC34xhYTFoGi3GvQ5iVAlG28nUYL/vSiEmetc4WM3v2bK37kjppdgnlgwcPkJSUhAkTJlTbnpKSgpSUFLz99tvQ19eH4GoG9LgctB04DQDh6Z14leSSVAKpqAIAwAFh+ffBiIqKwqJFi+SD5QcPHgxLS0uEh4erJEsRfvjhB3zyySfo1asXjIyMMG3aNHz77fNuSYlEgvT0dK3poy5enFYjJSUFRIS0tDSEhoZi3759WLZsGVasWNHEWjYeXbVTbf7Uu3dvfPXVV8jIyEB8fDwcJ72hdrkklUAqLAdIivlrf0ZOTg527NiB0aNHy1th2rdvD2dnZ43706hRo5CTk1Pjj6ynYdmyZfJjFy5cWGMuTm3wsp24XC7GjBkDgUCAvLw8hIeHo7XzZJBUAg6Hg1bdRwISMaqKc1WSK7MTh6RY+E0g/v33X6xfv75apba27CRDV31JHbSkuKerdqot5pmbm2PRokWIiopCRkYG3JasBaQSAICeWQcAgFT4VCW5Ml/S43IQdCWj1mO07Uvqptl1eV+6dAkAMGjQoGrbb9y4AQAYMmQIACD6bh4kUoJ+WyvotbWG+NF9pWWKC7ORsWU2IKkCt7U52vafjKvmtY9pGTRoEOLjVUteFWHXrl3YvXs3/Pz8AADvvvsuvLy8UFFRgf/9739a00OdvNi1c/XqVURGRuL27dvw9fVFTk4OLCwsMHToUGRkZODevXvo1q1bE2vcMLpqp7r8CXjWIjJq1CggXqhWmSQWInObD0gsBNe4Dc4NdIdokVutBRyDBw/G8ePH1Sr/ZQwNDWFjY1NtW2pqKlasWAF/f3/MnTsXwLMXJPBsap6kpCSN6vQy9dnJ0NAQHh4e2HI3GpzCcgCA5GkRAIBrovx4xpftdHKgO7b4jUCbNm1qHKsNO8nQVV9SlZYW93TVTvX5EgDY2NigAKaoeloMcX46iuMOgGPYCoa2PZSW+bIv/TLQHSvGBzW5L6mbZpdQygaxOjo6Vtuek5MDALC1tcUTYRUy/j+wAoBeGwtUPSlQSp6+hS2MOzvDsJ0DpOJKlN+JR8mlI7hemI2nH7qhtVH1n7BLly44cOCAUrKU4cGDB89e+v/PqFGjEBUVhQkTJkAsFuPDDz/Umi7q4MWgevbsWWzfvh1cLhdHjx5Fjx494OTkBKFQCGNjY/zzzz/YuHEj7O3t8fnnnzex5vWjq3aqy59kvOxLqqLXxgKmI2bDsENXgKSouH8dOZfDMWnSZFy4EFtjvsMuXbogPz8feXl5Wps6pbi4GJ6ennB1dcX69eu1IrMhFLGTpKIMT27+ASO7vtBvY6mUPF22k676kiq0xLinq3ZqyJcuXLqCy1/Okv9f39IO7WevhV4r5cY06rIvqZtml1AWFBRAX1+/RmZfUfGsO9rIyAjpBU+rL4ekZwipSLmXovW0/1T7f5t+41Fw6kc8uXkGP+z+FZNHDay2XygUoqKiAvHx8SotJ/cy7dq1g52dXY1B2dbW1vJCBhn9+vVDVFQUxo8fj+zs7EZd/969eygtLVWbvrXRpUuXBufSk91feHg49u7di5ycHGzfvh3Dhg2TH2NgYAAAsLCwwNixY/H5559DJBLhq6++qvO6RITMzEzk5+erfiP14ODgAAsLC43Z6ebNm5BIJGrT986dO9DT08Pff9c+PuhBsVh9xTgALFwXVPt/6z4uMLB8DZcv/IbNmzdj8uTJ1faXlZUBAC5cuKDyeCsul9vg2EepVAo/P79nw2YEApWLIBITE9Uy7q2xdiKSIv9kAKTCJ7CcuFRpeU1pJxl6enro379/je3q8CUiQlFREdLS0tSia12YmJg0aiJ3TcQ9IkJ5eTnu3r2rhjupG1NT01pbS9Vlp6ysLDx+/Fht+jbkSw9LRGg/7yuQqBLCh6moTEuEVKz8WOT6fCkkJATz5s2rfryFBYBnY0xZQtlEyJI3oVAIERlU20cSETj66psPzXTYLDy5eQZrP10F/zpaPseMUWHy51r44IMPsG3bthpLa40ZMwZhYWEYO3Zste19+vTB+fPn5QUFDbF8+XKcOnVKbfrWxo0bN9C/f/8GX9LZ2dnYvHkzKisr8dtvv6FPnz7yL3gikv8G1tbWeOONN9CjRw94eHjA2dkZPj4+tV6Tw+Fg/vz58u4OTREUFARfX98aX53qstP48eNRWFioNn1lDB5c+yTjhrY9YPumZqewaDvUE8UXfoO/vz/8/f1rPUbW7awKrVu3xpMnT+o9xt/fH5cvX8a1a9fUUmU5ZswYPH2q2tirF2nIToVnd6HyfgKsZvwXhh3UW/CgLTvJsLS0REFBzfiqDl+SSCQ4deoU+Hy+2vStjWXLluGnn35q1IeJuuMeh8PBmTNnMHv2bLXf14tMnToVkZGRNbarw05SqRSbN2/Gjz/+qDZ9ZTQm5pn0GIGnyTF4HPoVbBd8pzafajvUE6UXg3Du3LkaCaWs+LE5VvQ3u4TSysoKVVVVKCsrqxbwZWvC5uTkoLVdz2rnSJ4UwUiF8Q8vo2f6bLm4qZMn4kv/T6rt++qrr3Dq1Cm1j6Ns165drXNarl69GgkJCbWe07dvX0RHRyM0NLTB6//www8abaFsTOuQjI4dO2Lt2rXo3r27vLVD5lyyv/fu3YsFCxZAT08PI0aMgIeHB+Li4uDj41Pn9Bq//fYbSkpK1HNDdeDg4FDrerrqslNUVJRaWyh//vln7N27FxcuXEDr1q1r7H9QLMbHZzXbqss1MIKpuQUGDxyAgICAavv27duH7du349y5c/Ivd6XlNDAn7OHDhxEQEICIiAj5VC2qcvHiRbW0UDbGTovW/YAn1yNg7roAbfqNV1nmy2jLTjLqWpdaHb6kp6eHqVOn1nkdddG1a9dGH6vuuEdEcHNz0/g91jXvqDrsxOVy8cknn2DBggWqqilH0Zhn0nMU8PtWPE29oLaEkmtgBHMLy1obB4qKno1/VnRZWl2g2SWUsu6DBw8ewNnZWb5dlqz89ddfeLP/IHDwbKGkqrICSMryYTBgcs2LKYmscnJI/341BvaWlZWhb9++dQ74VTcfffQR3nuv7jk2O3TogP379zc41kbXBni/3KVWWFgIS8tn48HEYjEiIyOxa9cuXLt2DXfv3sX9+/fRt29fAHV/2SkS3NWNuuxUWxegKri5uWHv3r0wMzOr5k8yegqrsOLsGbXKfBkSlqOspBjdu3ev4Tc7duyAtbU13N3dNapDYmIiFi1ahA0bNtR49lRBXdMLNWSnmO9/QMnFg2g7xBNmI+aoRebL6IKdAPX4EofDgaWlpTym6ArqjHscDgcWFhZqS/AVRV12sre3b/TysI2hsTFPNtSHqsQASZ/NSqEmSFiOosKCWlfEefDgAaytrZvlajnNbtqgkSNHAniWOL5I37590atXL/zyyy8w1uegk6UJAODJjUgAHLTuqXgXtFRY/uxhegEiQsmlIwCAmdOn1jjn+vXr1QYia5ro6Gj4+Phg3bp1te5vzlNoyLh69SqOHDki7640MDDAjh07UFRUhOHDh8PDwwOFhYXyZ0MX0VU71eVPwLPupr+uxMNYUn83cWOhKlGtQVl49RCICFOmTKmxLyEhQeN2zc/Ply+IwOfzkZubW+2PbPzWvXv3kJiYiNzcXFRUVCAxMRGJiYkQiUQa1Q+o304HDhzAJ//9CG17jYaF+2KVZdVlJ9G1I01qJxm66kvqprnHPV21U12+VFxcDLFYjPzch2jLeT6zxZObzz6ojWwUb3Spy5ek10N1wpfUTbNroezSpQv69euHc+fOYeHChdX2bd68GR4eHpg0aRJMe49D0dXrKE34HW36T4KB9fMvnKriR3i4cxFa93OH9YyP6pQlyr2H/BObYdJnHAwsOoLEQpT/cwXCrBQYvtYLH374IXg8HubOnQtLS0skJCSgsLAQnp6eGrv/2tixYwdWrFiBpKQkBAUF1dqM35wpKCjAvn37MGLECAwc+KwIqn379nB1dQWHw8GSJUsgFArVPm5V3eiinWrzp9u3byMoKAj79u3D48ePYdZnNCTlpZCKhSiOPwwAMLbvB+NOz9enT98wA0b2/WDD21CnLMmTIuQELodJHxcYWNkBACrvJ6DifgL09fUREREBCwsLjBs3DlwuF3l5eUhKSqq3lUMdREREID09Henp6fKhMy/SuXNnpKWlYfHixYiNjZVvlz2LDx48qFZ4oAletpNUKsWFCxewbds2nDhxAgDQ2swC5cnRIDxvqTKy6w0D8+dTIqlqJ2NjY1y9ehXdu3dHv37P7K8tO72ILvqSumkJcU8X7VRbzCssLMSaNWsQGBgIoVCINn1cYGDbHcKsFJTfvQxDm+5o3a/6mE+lfenBdVT8+xemTJlSI1doCl9SJ81yLe9t27bh888/R15eXo1K6uPHj+PLL79ESmoqJIZt0cbJHWaj54Oj9zx3Fj1OQ87e92E6Yk6NCqwXERfnojhmP4Q5/0D6tAjgcGBgZY82/SfDf85InA05gLNnz0JPTw/Tpk0D8KyFMj09XWsDarlcLnJzc1FQUABPT08YGRkhPDxcPgbn0aNH6Nixo1rH3TUFfD4ft27dwunTp+Uv/QULFsDKygpbtmyRH6ery5Ppsp22bduGtWvXwt/fH0eOHEFSUhIsLS3h6OhY5xgos9Hz5cv6SUUVyNw6Fya9x6Gd58o65Ugrn6Dw7C4Is+9A8qQQJJXCwMIWvDmesDFvjcOHDyMtLQ329vaYP38+DA0NsXXrVuTm5jbLZcjUzbZt2/DZZ59h6dKlCA4ORlZWFqysrGotXJFhNe1DtHF+NoGzqnaaPX0y2hoCISEhKCoqQv/+/cHj8VBVVYWvvvpKa3bSZV9SN8057umynWQ5xM6dOxEcHIzIyEhUVVXB1tYWVVVVKC0tg7BKAn1zG5j0HA3T4bPBNXy+Mp+qvrT87bfw7Rdr5JX7Mnbu3ImPP/642ca8ZplQlpSUoEuXLti0aRMWLap9gnEAeH3vVVy6XwCJtPotll2PQFF0IF57Zzf0Wis2vkSPy8GoLlY4sGg4ACA3NxdHjhzBgQMHkJCQACMjI/j5+YHP58PFxaXOgeXqQua07du3R0lJCebPny/vKpkwYUKLCq4zZsxAcXExHBwcQEQ4dOgQjhw5otbKUk2hi3YqLi5GaGgofv31V8TFxUFfXx/e3t7g8XiYMmVKtYnG6/IlAKj490/kBf8Ptgt/hGF7h0bLf9mXiAiXLl2CQCDAkSNHUFhYCCsrK6xcuRLz589X6ziq5kRmZiYOHjyI3377DSkpKWjdujXeeOMN8Pl8jBw5sloioQ07iUQinD59GkFBQTh58iQqKythZ2eHL774Qr4OvCbRRV/SJM017uminSQSCWJjY7Fv3z4cPHgQRIShQ4eCz+fD19cXHTp0kB+rDV96mYEDB8LV1RXbtm1T+N50gWY3hhIAzMzMsHLlSmzevLneCspvZjlBn1vzq60yPQlth8xUOJkEAH0uB9/McpL/38bGBv/5z3+wePFi2Nra4uOPP8aFCxfg7u6OTp064ZNPPkFiYqLa1kGuDzMzM0RERGDJkiWYNm1as30o6+L333/HnDlzYGBggLy8PBw8eFDng2ptNKWdhEIhjh07hjlz5sDGxgZLliyBoaEh5syZA0dHRxw6dAgeHh41Vq2py5cAoDL9Fkz6jFMosAI1fYnD4WD06NH4+eefsX//fhgbG2PMmDFYt24dOnfuDDc3N+zZswfFxcWK3nazo7i4GHv27IGrqys6d+6ML774Ak5OTnjzzTfx2muv4aeffsKoUaNqtEppw06ylXmOHj2KoKAgGBkZwdHREUuWLIGNjQ3mzJmD48ePQyhU7wpLtdHSYx7QMuJeU9qJiJCYmIgVK1agU6dOcHd3x5UrVzB+/Hg4OjriypUrWL58ebVkEtCOL73I6dOn8c8//+DTTz9V6Jq6RLNsoVSEw39mYHXYLbVdb6O3E3yHdqr3GCLC1atXIRAIcPjwYeTn56NPnz7g8/nw8/ND586d1aaPnp4ecnJyakyAevjwYSxevBhubm6IjIxsMV/rMioqKtQ6cbymaUo7SaVSxMXFQSAQIDg4GMXFxRg4cCD4fD7mzZuHjh07Nuo6v8X/i89/v6M2vRrjSwBQWlqKY8eOISgoCFFRUdDX18eMGTPA4/Ewffp0GBkZqU2npqSyshKRkZEICgpCREQEqqqq4O7uDh6Ph1mzZtU5PcvL/Hw6EZtiH6pNr8ba6eHDhzh8+DAEAgFu3LgBc3NzzJ07F3w+H2PGjGlw2qbG8qrGPKB5xb2mtlN6ejoOHjyIoKAgpKSkoF27dvD19QWfz8ewYcMaNUSgKfKH5kyLTygB4KfofxDwR+2z4jcKIoDDgXu7cuz9r2JfhmKxGGfPnkVQUBCOHz+OiooKjB07tloxjyq82K3wMomJifDy8kJmZmaLC666OGaoPprCTrLimoMHDyIzMxOdO3cGj8cDj8dDnz59FLqWWCzGrFmzcLXMHK1HzVdZN73kCFze84XCK0Hk5OTg8OHDCAoKwvXr12Fubo45c+aAx+PJi3maE7LiGlmyX1JSgkGDBsmT/dqKhOojLy8PY8eOhaibG8h5psr6dXh0FRd3ra0x1qshUlJSIBAIIBAIkJ6ejk6dOsHPzw88Hk9ezKMsr2rMA5pX3GsKOxUWFiI4OBhBQUG4ePEiWrVqhVmzZoHH42HixIkKP8e//vorlu+KhIXLGyrr9smknnjPTbem51M3r0RCCTz70lh3IhlVUqp1TERd6HE50Ody0LUoAX/s/AKhoaFKV3GXlZXh+PHjEAgE1Yp5+Hw+ZsyYAWNj44Yv8hKxsbEYPXp0jZVZZBQUFCAiIgJvvKG6Q2gCiUSi9nGmUqkUHA5HpwKvtuyUlZWFQ4cOISgoSF5c4+PjAx6Ph1GjRimVcEmlUrz++usIDg7GyZMnUWTZWyVfen9ke3yzaAZsbW0RHR0NMzMzhXUCgNTUVHnS8mIxD5/Ph5NT7d1KusKtW7fkyX5WVhYcHBzkyX7v3r2VumZxcTHc3NyQm5uLixcv4s9CA5Xs5NMV2Pi2J+bOnYsDBw4o/excunQJQUFBOHr0aLVinvnz58POzk7hazb3mEdEICK1f/xoIpaqgrbsVFFRgd9//x0CgUDe4jlx4kTw+Xx4eXnVWKa5sRw/fhxz5szBwoUL4bb4M3xxUnlf+p9H3xbdMinjlUkoASCzsBz+x24h7l4+9Liceh8M2f6x3azxzSwndDQzwvz58xEeHo5Tp05h/HjVVqKQFfMIBAL8+eefMDU1xezZs7VWzKMLyKZr8fb2ho2NTcMnNAKJRIJbt27Jl1V7FQo5ZMU1AoEAMTExMDIygoeHR63FNYpCRHjvvfewa9cuHDlyBHPmPJs0WxVfsrc0wa1bt+Di4oJ+/frh9OnTMDExUUnHl4t5nJycwOfzdaqYR1ZcIxAIcOvWLVhZWcHHx6fW4hpFKS8vx+TJk5GcnIwLFy7IWwFVtVNwcDDmzZuHd955p9FLCNbFy8U8QqEQrq6u4PF4Winm0QUyMzMRFBSEqVOnwsnJSW1xPjc3F2FhYXBwcJDPONKSkRXXBAUFITQ0FKWlpXUW1yjD+fPnMW3aNHh5eeHgwYPQ09NT2ZdeBV6phFLGP4/KILiagei/85BRUI4XfwAOgE5WJnDr0R78EZ3Qrf3z0n2RSAQPDw9cvHgRUVFRGDZsmFr0+fvvv+UtLf/++y86duwo7x5qzNrXzZGwsDDMnTsXS5YswY4dO9R6jzk5ORg7diw4HA7i4uLUlqzqEkKhEJGRkRAIBPj9998hEokwfvx48Pl8eHt7N3q8XUN89tln+Prrr7Fnz55aZ1RQ1pcA4MqVK5gwYQJcXFxw7NgxlRJfGSKRCGfOnIFAIEB4eDiEQiFcXFzA4/EwZ84crSctxcXFCAkJQVBQEC5cuAAjIyN4enqCx+Nh8uTJartnLy8vXLhwAefPn8fw4TUrSFWx0549e7BkyRJ89tlnWL9+vcr6As9m6ggLC4NAIEBUVBQMDQ0xY8YM8Pl8TJ06tcWMi32R3Nxc+ZyRFy9eVGtcIiK888472LNnD0JCQjBr1iy1XVtXICLcvHkTQUFBOHToELKzs9G1a1d5y36PHupZXvnq1atwd3fH2LFjER4eXsNHVfGlFg+94jypFFPI+StkaNuDQs5foSeV4vqPf/KERo8eTZaWlnT79m216iKVSuny5cv0/vvvk7W1NQGgPn360DfffENpaWkKXUcsFpNUKlWrfuri7NmzZGhoSL6+vlRVVaURGffv36eOHTuSs7MzFRUVaUSGqihqJ4lEQjExMbRkyRIyNzcnADRw4EDasmULPXz4UO36BQQEEAAKCAho1PGK+hLR82dh3rx5an8WSkpKaP/+/TRhwgTicrlkaGhI3t7eFBoaSpWVlWqV9SIVFRUUGhpKs2bNIkNDQ+JyuTRx4kTav38/lZaWqlVWVVUV+fr6kqGhIZ07d65R5yhjp82bNxMA2rJli6oq1yArK4sCAgJo4MCBBIDMzc1pyZIlFBsbSxKJpNHX0eW4V1hYSM7OztSxY0d68OCBRmQo8yw0BYraKS0tjb755hvq06cPAaB27drR+++/T1euXFG7rW/dukWWlpY0evRoevr0aYPHK+NLLZlXPqEkIkpISCAAlJCQ0Kjji4qKqH///tSxY0e6f/++RnQSiUQUERFB8+fPp1atWhEAGjt2LO3cuZMKCgrqPVfR+9Emly9fptatW9PUqVNJKBRqVNbt27fJ0tKSRo0aRU+ePNGoLGVorJ1u3bpFq1atInt7ewJAnTt3Jn9/f0pOTtaYbnv27CEAtGbNGoXOU+bZCw0NJS6XS0uXLtVYMpCdnU1bt26lQYMGyZOWxYsXU3R0tEJJS11IJBKKjo6mxYsXk5mZGQGgQYMG0datWyk7O1sNd1ATqVRKb7/9NnG5XAoLC1PoXGXs5O/vTwBo7969iqraaJKTk8nf3586d+5MAKhTp060evVqunXrVoPn6mrce/LkCY0cOZKsrKw06rNEREKhkKZOnUqtW7emK1euaFSWsjTGTgUFBbRz504aM2YMAaBWrVqRn58fRUREkEgk0ohe//77L9na2tKAAQMUaoTQ1eeuKWAJJSn3QOTm5lK3bt2oS5cuGnthyCgtLaXffvuNJk+eTFwulwwMDMjT05OCg4OpoqKixvG6+oAnJSWRhYUFjRkzplFff+rg6tWr1KZNG5o8ebLGE1hFqc9OmZmZtGnTJnJ2diYAZGlpSe+88w7FxcWpJQGqj+DgYOJyubRs2TKFEzxln719+/YRAFq9erVC5ylDSkoKrVmzhhwcHAgA2dvb08qVKykpKUnhayUlJdHKlSvJzs6OAJCDgwOtWbOGUlJSNKB5dVatWkUAKDAwUOFzlbGTVCqld999l7hcLgUHByssUxEkEgnFxcXR0qVLycLCggBQ//79adOmTZSZmVnrOboY9yorK2nSpEnUpk0bunbtmlZkPn36lEaPHk0WFhaNSsS1TV12Ki8vp6NHj5KnpycZGBgQl8ulyZMn04EDB6isrEyjOmVnZ1OXLl2oe/fulJubq9C5uvjcNRUsoSTlH4i0tDR67bXXqF+/fg22GqqLnJwc+u6772jo0KEEgExNTemtt96i8+fPy7sMdfEBv3fvHtnY2Cj89acOzp8/T0ZGRjR37lyNdbErw8t2Kioqoj179pCbmxtxOBwyNjYmHx8fCg8P11oyfPr0aTIwMCA/Pz+lEldVnr2tW7cSANq4caPC5yqDVCqlixcv0rvvvkuWlpYEgJycnGjjxo2UkZFR53kZGRm0YcMGcnJyIgBkZWVF7777LsXHx2utu3XDhg0EgLZt26bU+craSSKR0Pz588nAwIDOnDmjlGxFEQqFFB4eTnPnziVjY2PicDjk5uZGe/bsqRZLdC3uVVVV0Zw5c8jIyIiioqK0KruoqIgGDBhAtra29O+//2pVdkO8aKeqqio6f/48vfXWW2RqakoAaOjQofT9998rnNgpS0FBAfXr14/s7OwUGlomQ9eeu6aEJZSk2gORkpJC1tbWNHz4cK21usm4e/cuff7559S1a1cCQB07dqQVK1bQwYMHdeoBf/jwITk6OlKPHj3o0aNHTaLD8ePHSU9PjxYtWqQzY6xkz93mzZtp9uzZZGRkRBwOh9zd3SkwMJBKSkq0qs+jR4/I1NSUZsyYoXS3kqrBde3atQSAdu3apdT5yiIUCunEiRPk6+srT1pcXV1p9+7dVFRUREVFRbR7925ycXGRJ/u+vr504sQJrbd879y5kwDQ559/rvQ1VLGTSCSi6dOnk4mJida7VYuLi2nfvn3k7u5OHA6HjIyMaPbs2XTs2DG6fPmyzsQ9qVRKixYtIj09PQoPD28SHXJzc6l79+7k6OiokTHWyvLXX38RAOLz+dSxY0cCQF27dqXPP/+c7t69q1VdJBIJeXt7k7W1NaWmpip1DZZQPocllKT6A/HXX3/RnDlzSCQSNUmyUlsxDwB67733lPriUifl5eXk7e1N9vb2lJ6e3qS6/Prrr2RoaEj79+9v0qRSVlwza9Ysua0GDhxIAQEBlJWV1aR6xcfHU3l5udLXUNWXpFIpffDBB2Rubq61LsKXkRXzjB8/nrhcLnG5XOJwOPJkf//+/VpP9mVcvXqVzM3N6YMPPlDpGVbVTuXl5eTp6UnJyclN5ksvF/O0bduWANDu3bs1PiykPqRSKQUGBpKhoSEdOHCgyfQgIkpPTyc7Ozvy9vZWya/Vgay4xtHRUT6O+f3336fLly832TMkFovp8ePHKhXYsoTyOSyhJPU8EFKpVCe6U0UiEX3//fcEgIyMjBQq5tEEYvGzqjdNVtUqgqw1qSls9XJxjY2NDQHQ+Hg0RVA1sKvLl8RiMUkkEq2/aGorrnnttdfkYyTVXcyjqG4SiUQtlczqsJNMF10gOTmZFi5cKP9AU6SYR93IYouujNmWxd6msFVtxTVTpkwhAHT16lWt61MbuuBLLYXmtU6ZDsPhcBqcpDYwMBB5eXka1cPAwEA+19nZs2fx22+/wcTEBMuWLYONjQ28vLwQEhKCyspKha8tlUoVPke2SoKuzCsnm1NMWxPHZ2VlYfPmzejfvz+cnJywe/duTJ8+HXFxcTh58iQAoEuXLlrRpTHowpynHA4H+vr64HK5WtPn1q1bWLVqFTp37gw3NzecO3cO77//PlJSUpCVlYXMzEykpKTgvffew7lz5+Dm5gYHBwesWrUKt24pt9avov7E5XLB5XKhr6+vE3aS6VIf2oh5ANCnTx+89957AJ7Nmzl16lTs2rULTk5OGDBgADZv3oysrCylrq2onWSxRR1zjKoDWextyFbqoqKiAsHBwfDy8oKNjQ2WLVuG1q1b48CBA8jLy8PXX3+tVX0aQhd8qcXQ1BmtLqCtLwxPT09aunSpRmUQ1X4/jSnmaYgff/yR5s2b12TjIJsCZVoZGltco+0vW220yjbV17oydlK2uEbZYp6XaUp/amkxj6jmPTW2mKchXrW4p4wvKVJco80Y0ZJjni7CEkrS/AMhlUqpsLCQunXrRnv27NGIjBdp6H7qKua5ceNGvS/SvLw8MjExoUuXLhGR7nTpqBuxWEx79uyhsWPH0owZM+jLL79s8GVSWVlJYWFhChXXaCsQ7d+/X/5vTQdYbQZXZeyk7uKa+op5Gpr7tCn9qaXFPKL676m+Yp6GuoJfhbinjC9JpVK6ceMGffzxxwoV12gjRrTUmKfrsISStPNApKenU7t27Sg2NpaIVB+3UR+NvZ+Xi3lcXV3rPb60tJRGjhxZbeWUzMxM+j/2zjssqqP749/dpSMgCFIUe8WuEVEQGxZsIBaEXRUTNTGxa2KieUVjj93EFnvcRVCxUxTsFRW72FCwIr1K3b3n9we/3YDU7QvyeR6f983ee2fOcOace+7MnBlnZ2favHmzxqyTlJWLFy/SnTt3qF+/ftS+fXv6448/aNOmTWRkZETffvstJSYmlvmsp6en1Mk1quh348aNIxaLRT4+PipZP6qKNsmqJ5FIRLa2tsVOrlFkcs2XJ/OcOHGi3L+1Ou2puvk8osq3qWgyD5vNrjBwqs5+T1ZbEgqFFBQURADI3NxcquQaZfe96ujzqgo1ASUpt0OIF+77+flR+/bti11TloOVpT35+fn09u3bMg1P/PukSZPI3d2diAo3o27RogU5OjrSxYsX6fz58/TTTz+Rr68vPXv2TP6GKJEv//Z8Pp/MzMxo0aJFNGPGjGLy//vvv9StWzc6d+5cqWUVFBTQgwcPpD4FQ9mO6K+//qK2bdvSzJkzyd7enkaOHCkJoJTlYBXdJkXqSZxwo+yDCIgKN0ou72+sbnuqbj6PSLY2VXQMorr1pEgUaUtEhe+M0NBQqbcYU2bfqw4+rypTk5SjRIgIbHbhnzgqKgpEhNjYWAQGBmLPnj2YOnUqZs+erWYpC9HW1oatrW2ZySri34cNG4ZPnz7B2dkZy5cvB5fLxblz5+Do6IgrV64gLy8PkZGRsLe3h7e3N+Lj41XZjEqRmJgoWYgtEokAAP7+/vDx8cG0adOwePFitGzZUnKtWbNmiI6ORtOmTUstT0tLC+3bt4ednZ1qGlBJUlNT0b9/f/z666/46aef8OHDB3h5eSE+Ph4cDkemJCtVomg9sdls9O7dG9bW1kqX3drautzEr+pkT0WpSj4PABo1alTu9eqiJ0XbElD4zhg4cCC0tbWV34BKUtV9XlWnJqBUEkQkMeCIiAgEBwfj8ePH8PT0xOzZs7Fp0ybk5uYiMzMT6enpapa2fIgIAJCbm4u8vDxEREQgIyMDe/bswe+//w5dXV1oaWlh0aJF2LhxI06dOoXbt2/j6dOn8Pf3L1aGulm7di3at2+PxYsXIysrCxwOB8nJyUhISEDTpk1hYWEBU1NTACj2YmzcuDFMTEzUKXql2bt3L27fvo2FCxfihx9+gJWVFby8vDBjxgxkZmbCy8sLMTExkvZ9+vRJzRKXpDrrqTrZU1Gqk88Dqo+eqrMtiakOPq9aoJ6BUc1CmdN0Z8+eJTc3N/rmm2/o8OHD9ODBA2IYRrLuJiUlhebPn0///POPQuomUmx7xNME6enpNH78eOrWrRuxWCyaN28eEf03vVXaVJanpye5u7tTRkaG3HIois+fP9ORI0eoZcuW1LNnT0pOTqbo6GgyNDSUTIV+2ZZu3brR0qVLS70mD8rod+np6WRqakrbtm2T/F50v8TAwEBycXGhHj160JMnT+jIkSNUt25dhZ2koag2aZKeFImm2FN183lENX6vLDTNlhSpp+rk86oDmrERVDVD/JV+4sQJ7N69G3FxcdiyZQvs7e0l94inCeLi4pCXl4eVK1ciOTkZv/76q1pkLgsOh4Nnz55h7NixKCgowL///outW7ciJiYGBQUFknaI28wwDNhsNt6+fQstLS3k5ubCyMhInU0ohoGBAUaOHIlvvvkG3t7e6N+/P6ysrODq6gpDQ0MAxfclO3HiBGJjYzFp0qQS1zQNIoKxsTH69++P2NhYyW9sNlsyeuTh4QE9PT3s2LEDrq6uiIuLg6+vL2xsbNQr/BdUVz1VN3sSU518HlC99FRdbQmoXj6vWqDOaFZTUMYXxocPH8jR0ZG6dOkiSdb48ktP/BX1+PFj6tu3L9WuXZvu3bsnd92Kao9IJKL58+dT48aNaciQIZL9xMLDw8nIyKjML/AHDx6Qi4sLOTg4UHBwsKQsTUEsS1paGq1du5ZYLJZkwX3Rhdt5eXnk6OhIvr6+kt9SU1MpISFBIXIoa5Tot99+o5YtW1JmZmap14mIVq9eTSwWi9atW6eQusUosk2aoidFoUn2VN18HlGN3ysPTbIlRY9QElUfn1fVqVlDqSRsbGzwv//9D4cOHYKdnR0Yhinxpcdms/H69Wv8/fffyMvLw9y5c9GxY0f1CFwGderUwYIFC3DkyBFYWloCKEw4sLS0xKVLlyT3ERGio6MxZcoU9OnTB3Xr1sU///wDV1dXAP+tzdEExF+vJiYmmD59Onx9ffH+/Xvk5OSAw+FI1j3dunULQqEQw4YNw/Hjx9GzZ0/Ur18fhw8fVnMLihMTE4OnT5/i8+fPAIB+/frBwMAA+fn5knvE/U8kEuHx48dYvXo1Zs2ahTlz5qhL7AqpbnoCqqc9iakuPg+ofnqqbrZUXX1elUdtoawGoewvjLK2VXjy5An5+PiQg4MDbdy4UfK7Jo4+iBHL1rZtW1q2bBkREZ0/f54mTJhAtra2NGzYMMm+c2WhaevbAgMDyc7OjgICAoio8IudYRjy9vaWbH5tbm5Oc+bModjYWIXVqwg9vX//nlq2bEm6urrUqVMncnR0pLFjxxKLxaKlS5dSbGxsiW1yrly5QvPnz5dX/FKRp00V9Qt16UmZKMKeZKG6+Twizfd7qkSTbUlePVUnn1fdqFlDqQLE623S09MlWXORkZFYt24d3rx5g4kTJ2LKlCkA/luLo6mIZZs0aRJCQkLw559/4tdff0Xv3r1x6tQpdOjQQXJvWW1hsVjYunUrevTogQ4dOihljU5eXh6Cg4MRGBiIXbt2QU9Pr8Q99P9rbDp27IhWrVrh1KlTGDNmDDgcDvLz82FkZIT58+fD09NTI0dRAKBevXo4cuQIGIbB69evcenSJejr6wMAFi1ahH379iE5ORmdOnWCiYkJrK2tsXz5csl57+omLS0NR44cQWRkJLZt21bqPdVBT2Uhrz0xDIPY2FicP38eo0aNQu3atVUpfplUJ58HyK+ngoICXLhwAdnZ2XB1dZWcr61IiAgPHjwAn8+Ho6Mjhg4dWmJLn+pgS1Xd51Vr1BvPagaqOIbs/v371LZtW3r16hXduHGDRo4cSU5OTsTn8yX3KWq9jSq/mO7evUsDBgwgDodDDg4OtG7dunJPlCEqXJNjYWFBAMjOzo5WrFihkK9gkUhEFy9epMmTJ1Pt2rUlJ9c8efKkwrOZFyxYQBYWFio9r1dReiqtbd7e3rR8+XJ6/PgxnTx5kjZs2ECjR4+m6dOny1VXRVSmTTk5ORQYGEgjRowgHR0dYrPZ5OLiQhkZGRqpJ1UirT0xDEPbt28nNptNOjo65OHhQYGBgRWe3lLdfB6R5vs9Hx8fAkC1a9emyZMn06VLlxTS/tjYWFqxYgXZ2dlJTq7ZunVruc+o05YUoaeq5vO+FmoCSlJdhxg6dCiZmZmRi4sL9e3bl44ePSq5VlUdq5iMjAxavXo1tWzZUjL1UB75+fkUFBREXl5epK+vTwCoZ8+etH37dkpOTpaq7kePHtH8+fPJ1taWAFDDhg1pwYIFlTq5RuyY7t69SxcuXCj2m7JRtJ6K9qG5c+dS586dKScnRyFlV5ay2iQ+pWbSpElkYmJCAKhz5860fv36Sp1co049qQNp7enDhw+0bt066ty5syRomTRpEl28eLFU31LdfB5R1fB7T548oQULFlDDhg0JADVo0IB+/fVXevTokVT1Jicn0/bt28nJyYkAkL6+Pnl7e1NQUFCFJ9eo25aUkbhHpHk+72ukJqAk1XYIDw8PYrFYdODAAclv1cGxFiUmJoYeP35MRJVrW0ZGBv377780cOBAYrPZpK2tTW5ubnT48OEyncO7d+/ozz//pPbt2xMAMjMzox9++IGuXLmiMZmVFaEMPYlfDCEhIdS8eXPKzs4mIuWeZVuUL9v08OFD+uWXXyTBfqNGjWjhwoUUFRWlEnmqA9LaU1RUFC1cuJAaNWpEAMjW1pbmz59PDx8+lNxT3XweUdXyeyKRiK5cuULff/89mZqaEgDq0KED/fnnn/Tu3btSn8nOzqZDhw6Rm5sbaWtrE5vNpoEDB9KBAwdKZDdrMsra3UJTfN7XTE1ASarvEM7OztSxY0eKj48v9ctQ3q9FZU6lKpu4uDjauHEjde3alQCQsbExTZw4kc6dO0dJSUm0a9cu6tOnj2Th+OjRo+nEiROUl5enUjkV8bdRZr9LTU0lKysrCg0NVXjZ5SFu0/Tp06ldu3YEgOrUqUNTp06la9euqbxPadIopjrafvXqVZo6dSqZmZkRAGrXrh2tXr2agoKCqpXPI6q6fi8vL49OnDhBo0ePJl1dXWKxWNSnTx/atWsXJSUl0blz52jixIlkbGxMAKhr1660ceNGiouLU6mcRJqlpy9Rt8+rCShrAkoiUk+HaNeuXan7r+Xn58u955ci2iMSiejs2bOUkpIilyzy8OzZM1qwYAFZWloSAMk/e3t72r17N6WlpalcJrFDffDgQaWm1MtDUXoqKCgoIWNeXh41bNiQNm/eLJeMlSU1NZV27txJXbp0IQCkq6tLnp6edPLkSZUH+0SFfwORSESXL1+u1JS6svn48SNdvnyZRCKRWoLcvLw8OnnyJI0ZM4b09PQktvT7779TamqqSmQoy+cJhUIqKCigz58/y1W+Iuzp8ePH9ODBAyJSz8dIWloa7d69m+zt7Yv5PCsrK1qwYAE9f/5c5TKJSUlJobNnz2rELiRfyqAOnyemJqD8j5qAktTTIcTO6kun9eHDBzI1NaVNmzbJXLa87WEYhqZPn04sFkuyrYQqKS25pkWLFtSjRw/JSIsik3mkpaCggDw8PEhPT48uXrwoczny6ik7O5u4XC59/Pix1JffunXrlPr3KS25plu3bgRAI7ZQSU5OJjs7O7K1taW3b9+qTY43b96Qra0ttWnTRur1wcogPT2dFi9eTACIxWJJlcwjD2X5PJFIRMOGDaNevXpJpitlQV57unDhAunq6pKHh0eJjzRV8GVyjampKTk6OlLz5s2VkswjLf7+/sRisWjGjBlyBdvy6mnz5s3k7++vFp9XGjUB5X/UBJSkWR2CYRiaN28eAaD9+/fLVIa87Vm0aBEBoB07dsj0vKxUJrlGkck88pCbm0suLi5kZGREt2/flqkMefSUn59PQ4YMIQMDgzLrV8YIS0XJNZpkS0SFe9Y1atSIWrZsqZbM8Pj4eGrRogU1btxYYWcHKwKxnkJDQ6VK5lEWV69eJX19fRo6dGiFSSVlIU/fu337NtWqVYv69++v1KD6SyqbXKOoZB552b59OwEodpKOtMijp3379hEA+uWXX5S2dEJaNM3nqZOagJI0r0MwDEOTJk0iDodDx48fl/p5edqzYcMGAkCrVq2S+llZkCe5RpZkHkWSmZlJDg4OVKdOHZmSTGTVk0gkIm9vb9LW1lbZeqHKJtdomi0REUVHR5OVlRV16tRJpcsk0tLSqFOnTmRlZUXR0dEqq7cylKanyiTzKJPQ0FDS1tYmb29vmYJZWfvekydPqE6dOuTg4KCS5BZ5kmtkSeZRNCtXriQAxTamlwZZ9XTs2DHicDg0efJkjVobrYk+T13UBJSkmR1CKBTS6NGjSUdHh86dOyfVs7K2Z8+ePQRAaScKiElNTVV4ck15yTzKzPZLTk6mtm3bUr169SgmJkaqZ2XRE8MwNHXqVGKz2XT48GEppZWOt2/f0qpVq6RKrtFEWyIqDIhNTU2pZ8+ecq/VqwyfP38mJycnMjU1VfkoUmUoT0/lJfMoe+nAoUOHiM1m048//ih10CBL34uJiaF69epRu3btlLpeXCgUKjy5prxkHmWvi/3ll18IAO3du1fqZ2XRU3h4OOno6NCYMWNUlr1dWTTV56mDmoCSiF69ekUjRoygV69eqVuUYuTl5dHAgQPJ0NCQIiIiKv2cLB08MDCQ2Gw2ff/990r5+svNzaWjR4/SyJEjJc6vX79+tGfPHoWPGj179owWLVpETZo0IQBkY2ND8+bNo3v37imlbR8/fqSmTZtSs2bNpHo5yKKnBQsWEADatWuXLKJWiDi5plevXpJgX5rkGk21JSKiGzdukKGhIQ0ePFipiUJ5eXnk6upKhoaGdPPmTaXVIw+V1dOXyTwsFot69+5NO3fuVFrQsnPnTgJACxculOo5ae0pLi6OmjZtSk2bNlVKxjTDMHTv3j2aO3cu2djYEABq2rQpLVq0SOHJNWlpabRnzx7q168fsVgs0tXVpZEjR9KxY8eUMoXPMAxNmTKF2Gx2sb1FK4O0erp58yYZGhrSoEGD1JLgVxGa7PNUTU1AqeFkZWWRo6MjmZmZVXqkQ1qDDQsLIx0dHfL09FTo119ZJ9esXbuW3r9/r7B6yoJhGLpx4wb99NNPZG5urtRkntevX5ONjQ21b9++0iMd0uppzZo1BIDWrl0rj6glKOvkmn379lF6erpC61I34r4+duxYpYx0CIVC8vT0JB0dHQoPD1d4+eokPT2d9u3bRy4uLlKfzCMtsvR1aewpJSWF2rVrRzY2NlLPLFREaSfXTJs2jW7cuKGSqdr379/T2rVrqWPHjkpN5ina18PCwir9nDR6evTokSQ5SRUzCzXIR01AWQVITU2lDh06kLW1Nb1+/brce7NyC+jIuZukY92Cjpy7SVm55WcrikdtXF1dFfb1J8/JNcpCFck8jx8/JjMzM+rRowdlZWWVe6+0epJ11KYs5D25piojHo2fOXOmQl/wDMPQjBkzZBq1qWpIezKPLEgzGi+NPWVlZVH37t2pTp06CvNJ8pxco0yUncwj7Wi8NHp69eoVWVtbU8eOHVW2tVUN8sEiIkINGk98fDx69uwJkUiEq1evwtraWnLtZXwmBBFvceF5At6mZKOoQlkAGpgZoE/LuuB2a4DmlkaSa48ePUKvXr3Qtm1bhIaGwsDAQGb53r9/j4MHD4LP5+Phw4cwNTWFp6cnuFwuevToATabLXPZiiYzMxPHjx+HQCBAWFgYOBwOBg8eDB6Ph6FDh0JPT0/msm/fvo2+ffvC0dERJ0+ehI6OjuSarHo6cuQIPD09MXXqVPz1119gsVgyy/fo0SPw+XwcPHgQ7969Q6NGjcDlcsHlctG6dWuZy61qvH//HpaWltDW1lZouQUFBYiPj0f9+vUVWq4m8/TpUwgEAggEAsTGxsLW1hbe3t7gcrlo166dzOUSEaZNm4bt27cjICAAo0aNKnZdFnvKy8vD8OHDcf36dZw/fx5du3aVWb6cnBycPn0aAoEAwcHBEIlE6N+/P3g8Htzd3VGrVi2Zy1Y0DMPg+vXr4PP5OHToEFJTU9GhQwdwuVx4eXnJ1V+zs7MxcOBAPHnyBJcvX0bbtm2LXZdFT3FxcXBycgKHw8GVK1dgaWkps3w1qI6agLIK8ebNGzg6OsLU1BSXLl3CZ+hhwbFHuBKdBA6bBRFTtirF13s2M8eKEe2Qn1posFZWVrh48SJMTEyklictLQ2BgYEQCAS4ePEidHV1MWzYMPB4PAwaNKhYMKWpfPr0CQEBAeDz+bhz5w6MjY0xcuRI8Hg89OrVCxwOR+oyL1y4AFdXVwwfPhwHDx7Ex/Q8mfUUdfsKhg0bhtGjR+PAgQMyBebv3r2Dn58fBAIBHj16BDMzs2LBvjwBag01iCEiXL9+HQKBAAEBAUhJSUG7du3A4/Hg5eUFW1tbqctkGAbjxo3D4cOHcfr0aQwYMADvUrJlsqelw+3w84/f4tSpUwgJCUGfPn2klkckEuHSpUvg8/kIDAxERkYGunbtCi6XC09PT1hZWUldpqrJz89HSEgIBAIBTp48ifz8fPTu3RtcLhcjR45E7dq1pS4zLS0Nffr0QXx8PK5evYomTZrIrKdf+tjC220g0tLScPXqVTRs2FCO1tagSmoCyirG06dP4ezsDGunkchr6wYhQ+Ua6pdw2CxwWEDBTQF03t3BlStXULdu3Uo/n5eXh+DgYAgEApw+fRr5+fno27cvuFwuPDw8ZApMNYXnz5/Dz88PfD4fr1+/ho2NjWSkpUOHDlIFXidOnMDIkSPR/wdfvDb9RiY9sUFICduOHpbA0aNHpRpNS0tLw5EjR8Dn83H58mXo6urCzc0NXC4XAwcOrBLBfg1Vl/z8fJw5cwZ8Ph8nT55EXl4eevXqBS6Xi1GjRkkVtBQUFGDEiBG4cOECFuw6jX+jcmWyJxIJkXRmG/hLpmL48OGVfpaI8ODBA8nI/sePH9G0aVPJyH6LFi0qXZamkZ6ejqNHj0IgEOD8+fPQ0dHB0KFDwePx4OrqCl1d3UqXJZ5FEwqF+GXHcWy4/EF6PbEAkbAAedcP4MKu5WjVqpUszapBTdQElFWQ3/iXcPBJFkAEyDK69P/PTbK3xO8jvqnwdoZhcOXKFQgEAhw+fBhpaWno1KkTuFwuxo4di3r16snQCs2FiBAREQE+n4+AgAAkJSXBzs4OPB4P3t7elf5i/m79YZxLNJBZT0QEFouFmX2aYPaAiqejc3NzERwcDD6fj6CgIAiFQvTt2xc8Hg8jRoyAsbGx1DLUAOzduxdDhgyR6sOrhv/IyMjAsWPHwOfzcf78eWhpaWHo0KHgcrkYMmRIpYKWnJwcdP9uMdIaOsssh9ie5g1ogWl9mld4/5s3byQfmFFRUTA3N8fYsWPB5XLRrVu3ajey/+HDB/j7+4PP5+P+/fuoXbs2Ro8eDR6PBycnp0rNjrx9+xZO3y8Du6ObzHJIq6caNIeagFKD+PPPP7Fnzx5ERUWVabz+t9/i16OPFFbnao928OzaoNRrixYtwsaNG2FiYoL379+jYcOGkq9yOzs7hcmgyRQUFCAsLAx8Ph/Hjx9HTk4OGjVqhJycHDx+/Bjm5ualPqcqPTEMg7Vr12LhwoXQ19dHZmYmOnfuDB6Ph7FjxxZba1uDbLi7u8PKygrbt29XtyhVno8fP8Lf3x8CgQB3796Fnp4edHV1cezYMfTq1Uvtfu/w4cMYN24cOnbsiIiICOjr68Pd3R08Hg/9+/dX+JpbTSUqKkqyLvbNmzeoXbs22Gw2Lly4gPbt25f5nKr0FBoailGjRiEmJgYWFhYKq68G+agJKDWEjIwMNG7cGGvXrsXEiROLXTt58iQWL16MqKgoiHSNYdjOBSaOY8FiS7++70u0hNlI2/cjkpOScPjwYTg4OBRLrmGxWOjevTtWr16tcck1qiYzMxMHDx7EtGnTIBQKoaWlJUnmycnJwZkzZxAREYHo6GjoN2iHut4rFVa3DosBBf6C6BfPsGbNGgwcOLBYco22tjY6deqEffv2fVXJNcqEiJCWlgZ7e3v8+uuv+O6779QtUrXi9u3b6NWrFwwMDJCcnAxbW1uMGDECHA4Hd+7cwdOnT1FQUIAmzVrgU4O+0GnZUyH1kkiIT3unIz/pHdasWYOffvqpWHJNQUEBGjZsiKVLl8Ld3R1GRkYVF1pNYRgGYWFhcHNzA4fDQXZ2tiSZ5/nz57h79y5iY2ORm5uLevUbIMWqCwy7jgBbR1/uur/U07x584pd79ixI/r27Yv169fLXVcNiuHrjQ40jD179kAoFMLLy6vY7yEhIXB3d0ft2rXR0XM2DFo4IP16AFLCFDNaknjxANIzPwMAFi9ejAYNGmDRokVo2bIlTpw4gTlz5uDDhw9wdHT8qoNJADAyMkJ2djb09fXx+vVrrFmzBh8+fMDo0aMxceJEBAQEoFatWtAxMIKiv9KSb51ETGwsAGDdunVo3749du3ahaFDh+Lq1avYuHEjHj9+/FVlFysbFouFzMxMpKeno3nzwqm3mu9vxXHt2jVoa2vj3bt3uHr1KoYOHYo9e/Zgw4YNePDgAbp374558+bh42cGccdWI+2KQCH1ZkaeQkF6IgAgICAAVlZWGDNmDD5+/Ig1a9Zg1apVSExM/OqDSQBgs9l4+vQpdHV1ERcXh+PHj6NFixb43//+h927dyMxMRGDBg3CypUrwa7XBqnXDyPhkC+IGLnrLqqn0vj++++xY8cOZGZmyl1XDYrhq4sQtm7dChcXF4wZMwbnzp0rdi0pKQlNmjRRi1x79+7F8OHDS2xZM2/ePLRv3x5bDgTik40TTF2+h3H30ci6F4qC5Hdy1ZmfGIuMu8EwtPcAUPgC3b17Nz59+oRDhw5h+PDh8PLywps3b3DhwgW56qoMFy9eBIvFKvOfOCtzxowZ6NKlC3R1ddGxY0ely1UUsZ4aNWqEmTNn4vbt23j27BmmTZsGW1tbPHmXDDIwVWjgIfqchtSrB1Gr20gAgKWlJU6ePIm4uDhs3boVjo6OGDVqFPLy8nD48GGF1VsZNNWe5IVhCl+I165dg7W1NZydC9fusVgsybWqhCbqSWxL+vr6cHR0xNatW3Hnzh3s2rULgwYNQlhYGP7YtBO6bouh17A90m8eAZOfK1edos9pSLvmD2OHQlt6/TERs2bNwvPnz3Hr1i3MnDkTEydOVJktVSWfZ2xsDDc3Nxw6dAjx8fHYs2cPWrZsCX9/fyxY/RfyHL5FbedxyHsfhfyPL+Sq80s9JWXllbhn5MiRNT5Pw/iqAsrNmzfj559/RqtWraCrq4vBgwdj5cr/piVFIhHevHmjcrliYmLw8OFDuLi4FPs9KioKUVFRmDJlCgIiP4LDLlwEbtRpMADC52fX5Ko3NfwfGLToDr36bQAAvr6+mDhxYrFM7S5dusDMzAwnTpyQq67K0KNHD8TFxZX4t2PHDrBYLPz444+Se7/99lt4enoqXaailKWnli1bYuPGjXj16hW+XbFX4fWmXtwHbbN6MGrTGwDA4/EwbNiwYpnadevWRfv27VWiJzGaak/yQkSS0fioqCgQEWJjYxEYGIg9e/bgxx9/LDH9psloop7Ks6XvvvsOAQEBiI+Px4if14EFgn7z7oCoAMK0T3LVK7YlwzaFgVrnAaOwZMmSYpnaqrSlqurzTExMMHHiRISHh+Pdu3fo970vwIjAMSncL5LJ+yxXvV/q6e6b1BL31Pg8zUNL3QKokh07dmDnzp3w9vYGAEydOhXu7u7IycnBH3/8oTa5rl+/DgDo3Llzsd/v3bsHAPjmm2/w86UEyfYLWkZ1wDEyR0H8a5nr/PzsKvI+PIPNpG0QpseXe2/nzp1x7Zp8wWtl0NHRKbGP29OnTzFv3jwsWLAAo0ePBlBo1ACQmJiIhw8fKl0uMWXpSQyLxcLTdMV+o+V9fI7Pj8/DircaVMH3X5cuXXD8+HGF1l8emmpP8iDOMAWAiIgIBAcH4/Hjx/D09ERcXBxMTU3RtWtXvH37FtHR0WjWrJmaJa4YTdRTRbYEAMbGxvjEqgOwsiH6XBhQsA1k36mgqC2xUKjjV4lZpd6rKluq6j5PKBRCV1cXCQV6yHnzAGlXDoClow8da9m3UipNT9Fq1pMYTbQlTeKrCihjYmLQo0cPyX/36NED58+fh4uLCwoKCjBr1iy1yPXs2TMAQOPGjYv9HhcXBwAwNrPA25Tia0k4tUwhzEqWqT6mIA+p53fDqKsbtGpbSgLK3AJRqfc3adIEBw4ckKkueUhLS4Obmxt69+6NpUuXqrz+LylLT2Ky8oR4m5KtsPqICClhO2DQuid067WGMK1QT/nC0qdcmzRpgqSkJCQkJKhkixtNtSdZKRpMhoWFYcuWLWCz2Th06BBatGiBdu3aIS8vD3p6enj58iVWr14NW1tbLFq0SM2Sl48m6qkiWwL+sydRTiayHpyFbv020KplJlN9ZdlSWnYBPucJYahb/FWoalsSU9V83p07d9C9e3fJf2uZ1Ufdkf8DR1+2taearidNtCVN4qsKKM3NzSXHzYlp27Ytzp8/j759++Ljx49qkSs5ORlaWloljurKyckBACRki0okebA4OmDyZQteMm4eARgRTLqPKfb7/WevYXf3bon78/LykJOTg2vXrkFfX/7svWbNmlW4JyLDMPD29oaWlhYEAoFce77FxsYiJSVF5ufFPHv2DBwOBy9elL4+KCatQKHJOJ8fhaMg8Q0sRvxWXI7Y97hbip7Ei9MvX76s0HU8LVq0KPUYOUXYE8MwuH//vsJkLYsOHTqAzWaX24/E106cOIHdu3cjLi4OW7Zsgb29veQe8bYxpqam6NmzJxYtWoT8/HwsW7as1DKJSLIxtrITejp27Fhq4pwi9JSVlVVmv5eFimwJKLQnhhgknVoLJi8LZv2/l7m+smyJAIRei0Tj2sW3A1K0LZmZmRX7+5eGIn1eRkYGoqOjZX5eTEV6ys/Px6I/N2PbzQTkfXiK3Nj7YApkX+danp5ikz+jjU3xgzNMTU0BFK5dVEVAqakxhKbwVQWUTk5OOHr0KHr2LL79hJ2dHc6dOyfTUVzKRBy8fc7OKXGNRPlgaUl/2okwLR4ZEUdhNuCHEls7bNr8F9b9saDMZ52cnKSurzTCwsJKrMn5kgULFuDGjRu4deuW3JmWvr6++Pfff+UqoyhdunQp9Xcd6xawnqCYLSyYvGykXtoP424e0DIuvs+an99BHNjxV5nPiqfJFMWVK1dK1b0i7EkoFJb591QUTk5OuHLlSqXuFWf65ubm4t9//4WdnZ1k5JKIJEdxmpubY/z48WjRogWGDx+O9u3bY8yYMSXKY7FYEAqF5U7tKoq8vLxST0BShJ7u379f4nlFUJ7udaxbQMe6OXJfR6LO0DnQsZQtsCvPlgDAmzce+XGlB0yKsqXx48dj//795d6jSJ9369Yt9O/fX64yilKRnqwnrIdBCwd8fnIRiYHLYO2zUWp9VaSn0mZmxB9pqtpkvqrFEKrmqwoof/31V0RGRpZ6rU2bNrhw4QICAwNVLBVQp04dCIVCZGZmFnMk4k2p05NLbp0gykqFrgzrVNKu8MExMoNug3aS6QTx+qSJE3gY7uIMKyurYiMdy5YtQ0hIiMLWUVa07szf3x9r165FUFCQZLsWeViyZAlmzpwpdzlbt27F7t27cfnyZRgaGpa4HpNWgLlhSXLXAwAZEUcBkRAGrXtK9CTMLCzbbdgQTPQaBQsLi2IbLe/ZswdbtmxBeHi45MtdEZR1tJwi7ElLS6vMMhSFmVnlp0ltbGzwv//9D82bN5eMTIlfVuL/3b17N3x8fMDhcODg4IDhw4fjypUrGDNmTLFpczEcDkfpbQQK/5aloQg9dezYUaFtqMiWAGD15m04tH8Xavf2Qa22fWWuqzxbYnKzsHHtKnRuaqNUW6qoDyra59nb2ytEX5XRU1G/Z9CyB3B6PT4/vSx1QFmRnhLj3iHfyrDYR1NqauG7q6wDJhSNpsYQmsJXFVDOnj0bP/30U5nXLS0tsW/fPpWviRKfVxoTE1PsFALx9hBxr56AhSaS6VRhZjJEmUnQ7jhQ6rqEGYkQpsbh4/ZJJa7t3LQGOzetQWpqarGzdjMzM9GmTRuVjLLcv38f3333HVatWoWBA6VvX2k0atSowummytCnTx/s3r0bJiYmpZ4W0TJPiHlhZ+SuByjUE5ObhbhdP5a4dtRvP4767ce9e/eKbSGybds2mJubo1+/fgqRoSIUYU9sNlsl/Uoavux3KSkpkoCgoKAAwcHB2LFjB27duoXnz5/j9evXaNOmcKeE0kZK1N1GReipVq1aCm1DRba0ZcsWHNq/C8bfuMHEYZRcdZVnSxk3DuHHG4fUakvK8HnGxsYK0VdFegIK/d7c//d7JCwAiAGTJ/1yrIr0NNChpJ5iYmJgbm6ustNyNDWG0BS+qoDywoULuHTpEhYuXIglS5aUuK6ulH/xouY7d+4UM9o2bdqgVatW2L9nN2y91uJtWuFeXFn3ggGwYNhS+ino2s7jwORkFPstP/EN0q/wMWDAAPB4vBJfonfv3gWXy5W6LmlJSkqCu7s7evfuDR6Ph0+fim8RwuFwYGFhgejoaGRlZeHTp0/IycmRrMGzs7MrdcpPUZSlJwB49OgR+Hw+mM+tFFKX0TfDYNDCodhvoux0pIT+jd69e2Pq1KklFspHRkYWWyCvbDTVnhRJREQE7t69i3HjxqFWrVrQ1tbGtm3b4OjoiG7duiEtLQ36+voq/btLiybqqTxbOnDgAKZPn4769euD6TxE7rrKs6XabXtj8SR3tdlSVfV5aWlpyM3NxfHjx8Hn81HQdgK0TW2Q9aAwsNS1kn73g/L0ZPnNQGxf+EONz9NwvqqAEij88pw3bx4ePnwIPp9f5jC+KmnSpAnatm2L8PBwfPvtt8WurVmzpnAjbfodn+vZIy8hFpl3g1CrwwBom9tK7hOmxePD9u9g2LYfzIfOLrMuPds2JX7j6BoiHUB4eDguXLiAI0eOgMvlYtiwYYiKikJKSgrc3NwU1t6yCAoKwps3b/DmzZtSz6Bu2LAhYmNjMWnSJFy6dEnye6dOnQAUfq0qYiSyLL7U07t37+Dn5weBQIBHjx5BX18fdTv1hSg7A0xBHtKu+QMA9GzbQq9BW0k5b1YNha5tW1hxV5VZl65VM+ALpyzeg+/ixYu4e/cuRo4cCR6Ph169eiE5ORkPHz4s9+tZGWiiPSmS5ORk7NmzBw4ODpJ+VrduXfTu3RssFguTJ09GXl6ewtYXKwtN09OXtiQSiXDp0iVs2LABp0+fBlA4hW+WfBfv4p7j/3dMg2791tCu/d82O7Lb0v8v9xEJMWvWLOzevRs8Hg9eXl7Q1dVVmS1VNZ+Xk5ODU6dOYc2aNbhz5w5YLBZat24Ny7gbeHHxOT4/vwEdq+YwbFt8LaG8emrfti3c3d2LXUtISKjxeRrGV7WxOQC4ubnh5s2bePLkCRwcHPD6tex7OSqSb7/9FqdOnZJkdosZOnQojh49Cj0mB0lntyP7xQ2YdB8NswFTi93HFBQ+x6kl/Xof8VT6jh07sHbtWnz69Amenp6wtLSEj48P6tati169esnULmmYMGGCJCu2tH+x/3/04MWLF0u9rkzHKsbLy0uyKLthw4ZYvHgx7OzsMHbsWOTk5ODN9SAw2WkQpccj/Qof6Vf4yH3zQPI8ky/WkyzbnxROp/7888+YNWsWLl26hH79+qFBgwbgcrnQ1tZWeEJORWiqPSmKwYMHo2XLlvDx8ZFs4wUUTn0bGRmha9eukmBSk49l1EQ9TZw4ESdOnMDMmTPRoEED9OvXDxEREZLrsbGxuBu4HYmn1iH5dOG/vLePJdfls6VCvh/ZHydPnkTr1q3h6+uLhg0bwsnJCRwOBwMGDJC9cZWkKvg8Hx8fHD9+HOPGjYOlpSU8PT2Rn58Pe3t7NGjQADExMYg6exD5ye9h4jgWlt4rweL8tx5VEXrq3LDke+3o0aPQ1dUtNRlOmWiiLWkKLNJkL6hg2Gw2Pn36hLp16yI9PR1eXl6IiIhAQEAAXFxcEB8fDxsbG4hEpe/HqEzS09PRpEkT/Pnnn/juu+9KvWfc7ghcf50s2eC8KJl3g5B6YS/q/bATHMPKB5UcNgs9mtTBge+6Ffv95cuX2L9/P1atWgWRSARra2t4eXmBx+OhY8eOKsuq0wRyc3MRHBwMPp+P06dPo6CgAK1bt8b8+fMxYsSIElsglaennFe3kXD4D1h/+xd06jaqtAyl6YmIEBERAT6fj+3bt0MkEsHOzg48Hg/e3t5o2LChzG2uDJpsT4pm6NChSEtLQ6NGjUBEOHjwIAICAlQewMuCpunpzZs38PPzw/79+/H8+XPUqlULPj4+4HK56NatWwnfUpY9yWpLQOn2lJGRgWPHjmHatGnIysqCjo4Ohg4dCi6XiyFDhkBXV1fmNlc1iAj37t2DQCCAQCBAfHw86tati6lTp4LL5ZaaOKQqPYnp1KkTevfujQ0bNkhVpjxomi1pGl/dCKUYExMTBAUFYfLkyRg8eLBKO2VZ8vzyyy9Ys2ZNmWcFrxjRDlrs0gO53DcPYfTNMKmCSQDQYrOwYkS7Er83b94c9evXh42NDS5fvoxRo0bhwIED6Ny5M9q0aYPly5cjJiZGqrqqEgzD4OLFi5g8eTKsrKwwcuRIvHnzBqtXr8aCBQvAMAzGjRtX6n6a5evpEQzsnKV2rKXpicViwcHBAUOHDoWenh4EAgE6dOiApUuXolGjRnB2dsaOHTsUsgdnRWiaPSma06dPY9SoUdDW1kZCQgL8/PyqRDD5JerSU0pKCnbs2IGePXuiUaNGWLp0Kbp06QIfHx/Y2Nhg06ZNcHBwKPVD9T97Kh6oyGpLQOn2ZGxsDEtLS8m+oStXrkRsbCxGjhwJKysrTJ48GRcvXqySZ7lXlpiYGCxfvhxt2rRBly5dcODAAYwZMwY//fQTTE1NsWjRojKz0CV6IuXqCQBCQ0Px8uVL/Pbbb6U8pRqqu8+Tha9qhJLD4SAuLq7EBqj+/v6YNGkS+vTpg+DgYI3+ujhw/RX+d+qZwspbOaItvOwrN5JVUFCA8PBw8Pl8HD9+HNnZ2XB0dASPx8Po0aNRp04dhcmlLsTJNX5+fnj//j0aNWoELpcLLpeL1q1bV7qcbWcfYPWF9wqTa7VHO3h2bVCpezMzM3H8+HEIBAKEhYWBw+Fg8ODB4PF4kuBTEVQHe5KFnJwchWzwryrUpaecnBycPn0aAoFAUn7//v3B4/Hg7u5e6mb5ZfH9n/txJlVxW8NIY09Pnz6VjNTFxsbC1tZWMlvTrl3JYKeqkZycjMOHD4PP5+PatWswMDDAiBEjwOVy4eLiUmw7pfJgGAaDflqKF7W/UZhs0uhJFXytPq+yfFUBZdHh6i+5f/8+3N3d8e7dO43tDEKhEKNGjcLVFEPUcvSWu7y0S/9iYjcbrF+/Xuop7KysrGJBC5vNhqurqySZpyq9cL9MrjEzM4Onpye4XC569Ogh9d8mMTERzs7OyGnsDHQYLrd8aZf+xdZpbpLzY6Xh06dPCAgIAJ/Px507d2BsbFwsmUe8UbcsVHV7kpXS9prUZFSpJ3FyDZ/PR2BgIDIyMtC1a1dwuVx4enqWOLe6MggEAvB4PLjO24QoraZyy6gdFYIbuxdLvXchEeH69esQCAQICAhASkoK2rVrJ0nmsbW1rbgQDUGcXMPn8xEaGgqGYSTBvpubm1TBPlD4t5k9ezY2b96MSesP42y8/B+t1om3cWX772Xur6oOvlafV1m+qoDy0qVLcHR0LLODJicnIygoCOPHj1exZBXDMAx8fHxw8OBBnDhxAhkWbeF78gmEDJW6Vq8sOGwWtNgs/DG8DVLuBOHHH3/EkiVL5No3Kz4+HgEBARAIBJJTHkaOHAkul4s+ffrIFbQoi7S0NBw5cgR8Ph+XL1+Grq4u3NzcwOVyMXDgQJm34sjIyEDfvn3x/v17XLlyBZFpunLpafEwO5zdthgHDhzA8ePHMXToUJnkAoDnz5/Dz88PfD4fr1+/ho2NDby9vcHlctGhQwepg6SqbE/ioFAoFILD4cgdIBIRhEIhtLW1NS7gVLaexFPEfD4fBw8exMePH9G0aVPJyH5ZG+NXhlOnTmHEiBEYP348du/ejYA77+Syp58cLLD82yGwtbXF+fPnKzwCtizy8/Nx5swZ8Pl8nDx5Enl5eejVqxe4XC5GjRpVbB9fTUEkEuHChQsQCAQIDAxEZmYm7O3twePxMGbMGFhaWspc9pIlS7B48WJs27YNP/zwA/xvv5VLT6MaM/jze3d4e3tj7969pR4pqg6qss9TBV9VQFlVISLMnDkTf//9Nw4ePAhPT08AwLuUbCw49ghXopPAYbPKNVzx9Z7NzLFiRDvYmhkAAFasWIGFCxdi06ZNmDFjhtyyvnz5UjI9FB0drVHJPEWTa4KCgiAUCtG3b1/weLxSk2ukJScnB4MGDcLDhw9x8eJFdOjQAYD8ehIKhfD09ERwcDBCQ0PlzrgvmswTEBCApKQklSbzqJu3b99i8ODBGDp0KBYtWgQDAwOFlJudnY0lS5bg9OnTCA0NrVIjVrIgTq7h8/mIioqCubk5xo4dW2ZyjbRcvHgRgwYNwpAhQxAQECB5ictrTw8ePECvXr3QsWNHhISEyD2bIk7m4fP5OH/+PLS0tDQmmadocs3BgwcRFxeHZs2aSYJ9RZzKs2nTJsyaNQsrVqwotqZRXj35+/vD29sb06dPx8aNGzXqI62G0qkJKFFodAzDgM1ma2Sn9fX1xR9//IEdO3ZgypQpJa6/jM+EIOItLrxIwNvk7GJL11kAGtQxQJ8WdcFzaIBmdYufEUtE+OWXX7B27Vrs379fYV9WRIRbt25BIBDA398fiYmJaN26NbhcLry9vUtsUKssGIbB5cuXIRAIcPjwYaSnp6Nz587g8XgYO3ZsqXu/yUJBQQFGjBiBCxcuICwsDD169Chxjzx6ysvLw9ChQxEREYHz58/jm28Us06poKAAYWFhknWxOTk56NmzJ7hcLkaPHi3VsYWA5ttSQkICevbsiYKCAly9ehU2NjYKLf/Dhw9wcnKCrq4uLl++XOrUmCYgq55SUlIk6+2uXr0KfX19yXq7/v37V3q9XUXcuXMHffr0Qffu3XHq1KlSgzJ57OnatWvo378/+vXrh6NHjypM7o8fP8Lf3x8CgQB3795F7dq1MWrUKHC5XDg7O6tspC0mJkayjOfp06ewsLDA2LFjwePx0LVrV4XZ5v79++Hj44Off/4Zq1evLrVcefS0Y8cO/PDDD/D19cXixYsVIrOi0XSfp1KoBkpOTiY/Pz9KTk5Wtygl2LBhAwGgVatWVer+rNwCOnLuJulYt6Aj525SVm5Bhc8wDEOTJk0iDodDx48fl1fkEuTn51NwcDBxuVwyMDAgAOTo6Ejbtm2jpKQkhddHRPTw4UP65ZdfqH79+gSAGjVqRAsXLqSoqCiF1yUSicjb25u0tbUpNDS0Us/IoqfMzExycHCgOnXqKKUdGRkZ9O+//9LAgQOJzWaTtrY2ubm50eHDhyknJ6dSZWiyLaWlpVGnTp3IysqKoqOjlVZPdHQ0WVlZUadOnSgtLU1p9ciDNHrKzs6mQ4cOkZubG2lraxObzaaBAwfSgQMHKDMzU+GyPXnyhOrUqUMODg6VLl8WewoNDSVtbW3y9vYmkUgkr9gliIqKooULF1KjRo0IANna2tIvv/xCDx8+VHhdRERJSUm0bds2cnR0JABkYGBAXC6XgoODKT8/X+H1HTt2jDgcDk2ePJkYhqnUM7LoaeXKlQSANm7cKK/ISkGTfZ6qqQkoiSgyMpIAUGRkpLpFKcbevXsJAM2fP1+q52Rpj1AopNGjR5OOjg6dO3dOWlErTWZmJvH5fBo0aBBxOBzS1tam4cOHU0BAAGVnZ8tV9tu3b2nVqlXUrl07AkB16tShqVOn0rVr1yrt8KSFYRiaOnUqsdlsOnz4sFTPyqKn5ORkatu2LdWrV49iY2OlFbfSxMXF0caNG6lr164EgIyNjWnixIl07tw5EgqFZT6nqbb0+fNncnJyIlNTU3r06JHS63v48CGZmppSz5496fPnz0qvT1oq0pNQKKRz587RxIkTydjYmABQ165dadOmTfTp0yelyRUTE0P16tWjdu3aUUpKilTPytL3Dh06RGw2m3788Uel+oirV6/S1KlTyczMjABQu3btaPXq1fT27Vu5ys7OzqaAgAAaNmwYaWtrE4fDIVdXV+Lz+UoJ9sWEh4eTjo4OjRkzplx/UBqy6OmXX34hALRv3z5pRVU6murz1EFNQEma2SGOHj1KbDabvv/+e6kdnaztycvLo4EDB5KhoSFFRERI9awsfPr0iTZt2kT29vYEgIyMjMjHx4fCwsIq7aRSU1Np586d1KtXL2KxWKSnp0eenp508uRJysvLU3ILiBYsWEAAaNeuXVI/K6uePn78SE2bNqVmzZop9eUu5vnz57Ro0SJq0qQJASAbGxuaN28e3bt3r0Tf1ERbysvLI1dXVzI0NKSbN2+qrN4bN26QoaEhDR48WCV9URpK0xPDMHTv3j2aO3cu2djYEABq2rQpLVq0iJ4/f650meLi4qhZs2bUtGlTiouLk/p5Wfvezp07CQAtXLhQ6jqlJS8vj06ePEmenp6kp6dHLBaLevfuTTt37qTU1NRKlSEUCiksLIx8fHzIyMiIAJC9vT1t3ryZ4uPjldsAIrp58yYZGhrSoEGDZOrXsuiJYRiaMmUKcTgcOnbsmNR1KhNN9HnqoiagJM3rEGFhYaSjo0Oenp5Sf/0RydeerKwscnR0JDMzM5WM5Ih58eIF+fr6UrNmzQgAWVtb05w5c+ju3bslgpacnBwKDAykESNGkI6ODrHZbHJxcaF9+/ZRenq6ymRes2YNAaC1a9fK9Lw8enr9+jXZ2NhQhw4dKv0ikheGYejGjRv0008/kbm5OQEgOzs7WrFihWS0VNNsSSgUkqenJ+no6FB4eLjK6xfb8tixY2WyZWVRVE+xsbG0YsUKsrOzIwBkbm5O06ZNoxs3biht1O5LUlJSqH379mRjY0MxMTEylSFP35PXlmUhPT2d9u3bRy4uLsRms0lHR4c8PDwoMDCQcnNzi93LMAxFRkbSnDlzyNramgBQs2bNyNfXl168eKEymR89ekSmpqbk6Ogo88i7rHpSty2Xhab5PHVSE1CSZnUIhmFowoQJ5OrqKvOohrztSU1NpQ4dOpC1tTW9evVKpjJkhWEYunnzJk2fPp0sLCwIALVu3ZqWLl1Kfn5+NGnSJDIxMSEA1LlzZ1q/fj19/PhRpTISKWZUQ149PX78mMzMzGjQoEEqD1by8/MpKCiIvLy8SF9fnwBQz549JSO2mmJLU6ZMITabTUePHlWbHIGBgTLPNiiL8+fPEwDq2LEjASB9fX3y9vamoKAgpay3Kw+GYSg8PJysrKzoyZMnMpcjrz3JM9sgLx8+fKB169ZR586dCQDVrl2bJk2aRH5+fvTHH39Q69atCQBZWFjQ9OnTKSIiQuV96dWrV2RtbU0dO3aU6yNWHj0VnW149+6dzDIoEk2KH9RNTUBJmtUhRCIRMQwj1xSZItrz6dMn8vb2Jn9/f6UsWK8M+fn5tGXLFrKzsyMWi0UASFdXlwYNGkTXr19Xi0xEhckrCxcupP/9739yOXVF6OnevXv07NkztY5+fZnMA4B69epFhw4dkntdrDzExsbSlClTyM/PT20yiBEIBDRlyhSlrnutiKLJNVpaWgSAunfvrrTkGmkQCoVyJzDJa08Mw9Dvv/9OCxcupIyMDLlkkYfr16/ToEGDSFdXlwAQi8UiOzs72rJli8qDfTEikYgOHjxIXC5X7mU28urp8+fPUq9XVyaaFD+om5qAkqpfh1Bke9ThwEpLrpk0aRItWrRIKck80iISiRQSZCtKT5WRZc+ePSpZX3XmzBkCQG3atJEqmUcZCIVCjRkRJCoMWNTxNwgPDy+RXDNv3rxq5fOIFGtPqv6ILppco6WlRRwOhwYNGkSLFi2iSZMmKTyZRxYU9S5QhJ4qY9eq8nnVLX6QB83Yfv4roqodyaSo/dkqIi0tDbt27ULv3r3RsGFDLF68GHZ2djh58iQ+fvyInTt3YsmSJQgJCcGHDx+wbt06fPr0CZ6enrC0tMTEiRMRHh4u9d+XYRipZWWz2RpzcgOASsly4sQJuU5Dqizi4+z+/fdfPH/+HLNmzcLly5fRr18/NGjQAD///DPu378PknL7W1n0pIgTcBQJi8VSyalRRIT79+9j3rx5aNCgAVxcXHD58mXMmjULz58/x61bt+Dl5aV0OcRUNZ+nKvsWiUQIDw/HxIkTYWlpCU9PTyQkJGD9+vX4+PEjQkJCsGTJEuzcuRNxcXE4efIk7Ozs4Ovri4YNG6JPnz7YtWsX0tLSpK5bFntS1bugMlTGrlXl82r4D815K1Zz9u/fD6DwJVfVHGxlyc/Pl+r+3NxcHD16FB4eHrC0tMT3338PHR0d7N27F/Hx8fD398ewYcNKHINoaWmJ6dOnIyIiAi9evMCcOXNw9epV9O/fH7a2tpg7dy7u3btXqaBl69at8PLyQkJCglSyVxWICKmpqXjy5Am6du2q0rpbtGiBJUuW4OXLl7hx4wY8PDywb98+dOrUCW3btsXKlSvx5s2bSpVV3fVUGtLa05s3b7By5Uq0bdsWnTp1wv79++Hh4YEbN27g5cuXWLJkiVzHIEpLjc8rCRHh7t27mDt3LmxtbdG/f39cvXoVc+fOxYsXL3Dz5k1Mnz69xIb4Ojo6GDZsGPz9/REfH4+9e/dCS0sL33//PSwtLTFy5EgcPXoUeXl5lZKjOtuTOn3eV486h0c1BWUPWY8bN45YLBb5+PhI1kYqc+pLlUPwBQUFtGvXLurZsycNHTqUlixZUuE0Q0REhMKTa8pK5vnrr7/KfS4hIYEMDAwkazJVub2LqvT05s0bsrCwoEuXLhFR5aaLZKWiNpWVzHP27Nlyy1WnnlSJtPaUn59P27dvJycnJ6mSa6qbzyNSnT3J4vNSU1Np2bJlCk+uKSuZJy0trdxyq7vf0ySf9zVRM0KpZP7++2/cu3cPM2bMQFRUFLy9vZGRkVHlv9ovXbqEyMhIDBo0CJs3b0b//v3Rv39/rF27Fr/99huSkpJKfU4oFCI8PBzh4eGYNm0aoqKiEBkZidmzZ8t1DCKLxUK3bt2wefNmfPjwAcHBwejcuTMSExMhFArLfE5PTw8dOnTA9evXARSOBLx//x69evXCX3/9Vekvfk1EPK117do1WFtbw9nZGUDh34rUdOKqtrY2Bg8eDD8/P8THx+Pff/+FgYEBcnNzv1o9AbLbE4fDwbJly2BoaIgDBw4gISEBAoEAgwcPVtsUZY3PK0lWVhZWrlyJzp07Izg4GB8+fMDmzZthb28v17IMGxsbzJkzB5GRkYiKisJPP/2EZ8+ewcTEpNxyq6s9aaLP+5rQUrcA1Z3U1FT0798fv/zyC86ePYtt27bBy8sLe/bsgaWlpeQMUE2GiIo5J4FAgBkzZmDatGlo06YNfvzxR7Rs2RIAYGpqii1btuDhw4fo27dvibK0tLQwd+5c/Pbbb0pb36atrQ1XV1e4urqCYZgy6xGJRDAyMkKbNm0k00579+7FqlWrYGFhgfbt2+P69esIDAyEubk5vLy8JO3UdIhI0q+ioqJARIiNjUVkZCTS09Nx69Yt6OvrY8OGDWqT0cjICOPGjcO4ceNK9LGiVDc9KdKeWCwWoqKiYGRkVOKauqjxeSWpX78+EhISYGBgoDSZW7dujWXLloEKk22/GnsSUxV8XnVHs626CrN3717cvn0bCxcuxA8//AArKyt4eXlhxowZyMzMhJeXF2JiYiQG8OnTJzVLXDqJiYkSxyQeXfD394ePjw+mTZuGxYsXo2XLlpJrzZo1Q3R0NJo2bVpmmbq6uipLlmCz2WXWJU6QGDZsGD59+gRnZ2csX74cXC4X586dg6OjI65cuYK8vDxERkbC3t4e3t7eiI+PV4nsslL0ZRIREYHg4GA8fvwYnp6emD17NjZt2oTc3FxkZmYiPT1dzdIWUl5/qE56UrQ9sVgsjQkma3xe2T4PgFKDyaKwWKyvxp7EVEWfVy1Rxzy7pqHINRAMw1B6ejqZmprStm3bJL8X3YYiMDCQXFxcqEePHvTkyRM6cuQI1a1blz58+CB3/USKa8+aNWvIysqKfH19JfvUJSUlkb29PW3ZsqXYveI1Krt27aJvvvlGZae3yIpY3pycHDp06BCxWCzq0KEDXbp0qcSWIVlZWURUeARhx44daePGjcXKkBVlrL0pKtPZs2fJzc2NvvnmGzp8+DA9ePCAGIaRnMKRkpJC8+fPp3/++Udh9Su6TZqgJ0WhSfZU3XwekWLapEk6UgaaYE/K8hFE1cPnVWVqprwVDBHB2NgY/fv3R2xsrOQ3Npst+Yry8PCAnp4eduzYAVdXV8TFxcHX1xc2NjbqFf4LfvzxRzRu3BgLFy7E+fPncfz4caSlpeHJkycYMWIEgP++DMVfhzt37oSbmxtq165d7rSLOhGJROBwOMjIyMD06dPx/PlzAED//v3h7OwsWYcjlt/Q0BBAYdZyy5YtcfHiRXz77bcaMzJUFPHf+8SJE9i9ezfi4uKwZcsW2NvbS+4Rr62Li4tDXl4eVq5cieTkZPz6669qkbksqpueqqs91fg8zdcRUP3sSUx18nlVnZopbwUj7txNmzbF8ePHkZWVJfmt6MLgwYMHw9HREe/evcOqVauwcOFCtclcFgYGBhg5ciTOnDkDkUiE/v37Y8aMGXB1dZU4m6LO88SJE4iNjcWkSZNKXNMkOBwOnj17BmdnZ9y5cwdbtmzBxIkTERMTg4KCAsmUnFh+saN9+/YttLS0QEQa51SL8vHjR6xZswYfP37E/v37YW9vX2xBOpvNBsMwsLOzw6RJk9C4cWOsXr0a9+/fV5/QpVDd9FRd7anG52m+joDqZ09FqS4+r8qjyuFQTUURQ9avX7+mqKgoyTRJeHg4derUiZKTkyX3iKcUhEIhPXr0iMzMzGj27NnyCV8KihyCF8uclpZGa9euJRaLRe7u7kRUfBuQvLw8cnR0JF9fX8lvqamplJCQILcMikQkEtH8+fOpcePGNGTIEMkxYuHh4WRkZFTmkWsPHjwgFxcXcnBwoODgYElZ8qDMqZLQ0FDJOexlyfnq1Sv64YcfyNHRkZYuXaqQehV5Womm6EmRaIo9VTefR6T4k6fUrSNFokn2pCy/V9V9XnWgZoRSAXz48AGurq7o1KkTnJ2d4eTkhF27duH+/fvYunUr3rx5g7i4OMkXIIfDQVpaGiZPnoz169erWfryEU9bmZiYYPr06fD19cX79++Rk5MDDocj+Qq8desWhEIhhg0bhuPHj6Nnz56oX78+Dh8+rOYWlKROnTpYsGABjhw5AktLSwCAtbU1LC0tcenSJcl9RITo6GhMmTIFffr0Qd26dfHPP//A1dUVQOVOqFEXAwcORJMmTYqNPBQlKioKS5cuxf379zF69Gj8/vvvAGQ7QUNZVEc9VRd7qvF5mq+jL6mO9lSU6uDzqjxqC2U1CEV8YTx69IgePHhAx44do1mzZtFvv/1GLBaLWCwWNW3alGrXrk19+vQhd3d3mjp1KqWkpCiwBcWRtT3ihcvlERgYSHZ2dhQQEEBE/52X7O3tTSwWi/T09Mjc3JzmzJlDsbGxMsmvasRfs23btqVly5YREdH58+dpwoQJZGtrS8OGDZNskFse0i5WV+WXbVpamuT/37lzh7y8vKhHjx60Y8cOye+adD55aShKT6oiPT29ws281WVP1c3nEcnWJoZhKCsrq9y+Xx19HpH89iTrmeeq8nvVwedVNWqSchREmzZtwGKx0L59e7i7uwMoPAqtTZs2cHNzw+vXr/Hq1Stcv34dWlpaMDU1Va/A/w/DMLh8+TIEAgEOHz6MM2fO4Jtvvilx5jD9/0Ltjh07olWrVjh16hTGjBkDDoeD/Px8GBkZYf78+fD09ETHjh3V0xgZEX/NTpo0CSEhIfjzzz/x66+/onfv3jh16hQ6dOggubesPfRyc3Ph5OSEESNGwNvbG40bN1aZ/OVBRHj48CF4PB5OnDiBhIQErF27FvHx8fjxxx/B5XIBlN0uTUJePTEMg4cPH2LGjBngcrkYPXo0zMzMFCpjSkoKDh8+DD6fj5ycHNy5c6fU+6qDPVVVnwcAMTEx8PPzg0AgQJ8+ffDXX3+VuKc66Kg85LUnNpuNH374ASKRCFwuF87OzhrhQ6qTz6tyqDWc1RCUseaQiGju3LnUuXNnysnJkbtcaahMex48eEC//PIL1a9fnwBQ48aN6ffff6e4uLhyy2YYhhYsWEAWFhYVHjdWVbl79y4NGDCAOBwOOTg40Lp16ygxMbHM+xmGoQ8fPhCXyyUDAwMCQI6OjrRt2zZKSkoq8zlVftkOHTqUzMzMyMXFhfr27UtHjx6VXFPkGkNVtkkWPd2+fZsGDhxIbDabtLW1yc3NjQ4dOkTZ2dkyy5GdnU2HDh0iNzc30tbWJjabTYMGDaIDBw5U+LdVlz1VN59HVHGbkpKSaOvWreTo6EgAyMDAgLhcLoWHh5c7u/A1+Dwi6e1JJBLRkiVLqFGjRgSAbG1t6ZdffqGHDx+WW4+qfER19HmaTk1AScrbFyskJISaN28ueVkp+yxbMWW15+3bt7Rq1Spq164dAaA6derQ1KlT6dq1a5WarhXfc/fuXbpw4UKx36ojGRkZtHr1amrZsiWxWKxKLeLOzMwkPp9Prq6uxOFwSFtbm4YNG0YBAQElghZVOyIPDw9isVh04MAByW+KTlhRh3OVRU9xcXG0ceNG6tq1KwEgY2NjmjhxIp07d65SdioUCik8PJwmTpxIxsbGBIC6du1KmzZtkiQ8VIQ67am6+Tyi0tuUnZ1NAQEBNGzYMNLS0iIOh0Ourq7E5/MlyUTl8bX5PCLp7YlhGLp27RpNnTqV6tSpQwCoXbt2tGrVKnr79m2J+1XpI6qrz9NUagJKUl6HSE1NJSsrKwoNDVVouRVRtD0pKSn0zz//UK9evQgA6enpkaenJ508eZLy8vJUKldVJiYmhh4/fkxElXdInz59os2bN5O9vT0BICMjI/Lx8aGwsDASCoVqcUTOzs7UsWNHio+PV8qLUd3OVRY9PX/+nBYtWkRNmzYlAGRjY0Nz586le/fuFfsbMQxDd+/epblz55KNjQ0BoKZNm9KiRYvo+fPnSmmPsqhuPo/ovzbdunWLwsLCaMKECWRkZEQAqFu3brR58+ZqPcKoDKS1p7y8PDp58iR5enqSnp4esVgs6tWrF+3cuVOy8buqfUR193maRE1ASco7sSQvL48aNmxImzdvVli5leH69esEgPr06UM6OjrEZrOpf//+tG/fPkpPT1epLESqHaWoDPn5+Sqv88WLF+Tr60vNmjUjAGRtbU1cLpcA0J07d1QqS7t27ejevXslfheJRBp1CkZBQYHcZUgDwzB048YNmjZtGpmbmxMAsrOzo59//pnmzZtHdnZ2BIAsLCxo2rRpdPPmTZWPVinqb6IIPX3ZdnX6PIZhiM/nEwCJ7po1a0aLFy+mFy9eqFQWIvX4mPJQhw9OT0+nffv2kYuLC7HZbNLR0SEPDw9as2aNygOwsnwekead/FOVqQkoSf4OIV4vVFrHXLdunUoy/0QiEV24cIEmTZpEtWrVIgDUunVrWr9+PX38+FHp9ZdFTk4OrVixgqZNm6byAOFLXrx4QWPHjqXg4GC1TVsxDEMRERE0ffp0ql27NgGgRo0a0bJly+j169cqk6Ho/xIV9p+cnBw6ePCgXGUrwrmGhobShAkT6NGjR2rT06dPn+inn34iCwsLAlAskKzslLaiYRiGHj58SOPHj6ezZ8/KVZYi9JSVlVVq4KQqn0dUuBfmsmXLqHXr1hI9jR07liIiItRq40FBQTR27Fi1BLNFKSgooGnTptHKlSsrtYuHsvj48SOtX7+eOnfuLNGTu7s7XbhwQSX7xJbm88QEBgaWuQ9nZagJKP+jJqAk+TpETk4O9enTh3744YdSO6uynVppyTXfffedRnXwU6dOkZaWFvn4+Khtk+l3795RgwYNqFWrVuUuNFclERERBIBcXV2lSuZRFnv37iUAtHXrVpnLkNe5Xr58mfT19cnNzU3lHyBlJdfs3LmTdu7cqfBkHlnIz8+n4cOHk76+Pl25ckXmcuTV099//01NmjQptjWLGGX7vLKSa/766y+N8XsJCQnUqlUratiwIb17904tMohEIpowYQJpaWnR6dOn1SJDaRw5ckQySyNNMo8yiIuLI2NjY+rbt6/MiWQ1AeV/1ASUJHuHKCgoIDc3N9LT06PLly8rSbqSlJZc8+OPP0qSazSxgwsEAmKxWDRr1iyVjxxognMvjaJ6kiaZR1kwDEOzZs0iFotFAoFApjLk6Xt3796V27lLi7TJNZ8+faJNmzbJnMyjCMQfsSYmJmVO41WEPHoSTy3Pnj1bZbZcVnKNQCCgrKwsItK8F/vbt2+pQYMG1Lp1a5V/xDIMQzNnziQWi0V+fn4qrbsixHq6c+eOVMk8yuLSpUukp6dH7u7uMn3Ealq/Uyc1ASXJ1iFEIhGNHz+etLS0KCgoSInSFVJWcs2pU6dKJNdoagffunUrAaAlS5aorM709HTq0qULWVpaqn366UvK0lN8fHy5yTzKRCQSkY+Pj8yjGrL2vWfPnpGFhQXZ29vLNf1UGcpKrvH19ZUquaayyTzKICMjg7p27UoWFhYyJQTJqqdTp04Rh8OhiRMnKr2NQqFQquQaTfR7L168oLp161KXLl1Uun598eLFBIC2bdumsjorS2l6qkwyjzIJCgoiLS0tmjBhgtSzaJrY79RFTUBJ0ncIhmFoxowZxGKxyN/fX2ly5eTk0JEjR2jEiBFSJddocgdfvnw5AaBNmzYpva7s7Gxydnam2rVr0/3795Ven7RURk+lJfPMmTOHIiMjlfZCLygoIA8PD9LT06OLFy9K9awsfe/Nmzdka2tLbdq0UepUf0xMDC1fvlzhyTVlJfOsWLFCqWsJk5KSyM7OjmxtbaUe0ZFFTxcvXiQ9PT3y8PBQ2nIE8QzLnDlzJFOilU2u0VS/d//+fTIxMaFevXqpZLZh48aNBIBWrFih9LpkoSI9lZbMM2LECAoMDFTqzMXBgweJxWLRzJkzpfIHmtrv1EFNQEnSdwhfX18CUOwIJ0UhTq757rvvyMTEhABQly5dpEquSU5OJj8/P0pOTla4fPLCMAzNmzePAND+/fuVVk9+fj4NGTKEDAwM6Nq1a0qrRx6k0VPRZB5xokjr1q2VlsyTm5tLLi4uZGRkJFUWurS2FB8fTy1atKDGjRvThw8fZBW3TJKTk2n79u3k5OQkWW/n7e1NQUFBSsnEzc/Pp6CgIPL29iZ9fX0CQE5OTrR9+3al2OP79++pUaNG1LJlS6m2xJFWT7dv3yYjIyPq37+/UpI7xMk1rVq1kgT7M2bMkCq5RpP93tWrV0lfX5+GDh2q1Azwffv2EQD6+eefNXa/TGn09GUyj4mJCU2aNElpyTzbt28nALR48eJKP1MTUP7HVx9QZuUW0JFzN0nHugUdOXeTsnLL//IWf/2tWrVKoXKUdXLN06dPpS6LYRjJebOaCMMwNGnSJOJwOHT8+HGFly8Sicjb25u0tbXVsh9eZZFVT/n5+RQcHCz1yTzSkpmZSQ4ODmRubl6pfiitLaWlpVGnTp3IysqKoqOjFSV2uSfXVGYza0WRmZlJBw4cUHoyT3R0NFlZWVGnTp1KTZL5Emn1FBUVRXXq1CEHBweF/v3KSq4JCQmRaQRU0/1eaGgoaWtrk7e3t1KCoWPHjhGHw6HJkydr7N+ASHY9RUVF0cKFC6U+mUdaVq5cSQBo48aNFd4rrS1Vd1hERPjKeBmfCUHEW1x4noC3Kdko+gdgAWhgZoA+LeuC260BmlsaSa7t27cPEydOxPz587Fq1Sq55Xj37p3kPNlHjx6hTp068PT0BJfLRffu3cFiseSuQ1MRn/+alpaGrVu3okmTJgopl4hw5MgR/P7771i+fDlGjRqlkHI1laysLJw4cQICgQBnz54Fm83GoEGDwOPxMGzYMOjr68tVfkpKCnr16oW0tDRcvXoVDRs2LHZdVlvKzs7GwIED8eTJE1y+fBlt27aVS06RSISLFy9CIBAgMDAQGRkZ6Nq1K3g8Hjw9PWFpaSlX+fISHx+PgIAA8Pl83L59G8bGxhg5ciR4PB569eoFDocjV/mPHj1Cr1690LZtW4SGhsLAwKDYdVn1FBsbCycnJ5iZmeHSpUtyn8edk5ODU6dOgc/nIyQkBESEAQMGgMfjwc3NDYaGhnKVr+kcPnwYv//+O5YtW4ZRo0YpzMe/evUKP/30E0xNTcHn8+XuT5oMEeHGjRvg8/k4dOgQkpOT0a5dO3C5XHh7e8PW1lbuOubPn48///wT+/btw4QJE4pdk9WWvga+qoDyXUo2Fhx7hCvRSeCwWRAxZTddfL1nM3OsGNEOdy6dwahRozB58mRs27ZNZkeQmpqKI0eOQCAQ4NKlS9DT04Obmxt4PB4GDBgAHR0dWZtX5SAisFgsFBQUgMPhgM1my12mSCQCgGrtUMsiISEBAQEBEAgEiIiIgJGREUaOHAkul4s+ffrI/DeJi4tDz549wWKxcPXqVVhaWsplS5a1tODu7o7Lly/j3Llz6Natm0xyERHu378PgUCAgwcP4uPHj2jatCl4PB68vb3RokULmcpVNi9evIBAIIBAIMCrV69gY2MDLy8v8Hg8dOjQQWbfcvPmTbi4uKBXr144duwYdHR05NKTdn4GevbsCSLC1atXYWVlJZNcIpEIFy5cAJ/Px9GjR5GZmYlu3bqBy+XC09MTdevWlancqowi/RQRQSQSQUtLS+JTvxby8/Nx5swZCAQCnDhxAnl5eXB2dgaPx8OoUaNQu3ZtmcolIvzwww/YvXs3jhw5And3d7lsydbMoMx7qxNfTUDpf/stfE8+gZChcjvCl3DYLLBBSAzdikHNjSAQCKR2Arm5uQgKCoJAIEBQUBCEQiH69esHHo+HESNGwMjo6/qKqUH5vHz5En5+fuDz+YiOjoa1tTW8vLzA5XLRqVMnqV86MTExcHJygoWFBWZs8sfq8BiZbEmLzUK9uGu4dmANgoOD0a9fP2mbhtjYWMnIflRUFCwsLODp6Qkejwd7e/sq80IlIkREREAgEMDf3x9JSUmws7OTBMRfjgZXhvDwcAwZMgQeHh4YNmsllpx+KrOe2HePION+KK5du4ZGjRpJJQcR4d69e5JgPy4uDs2aNZO0rXnz5lK2rIYayicjIwPHjh2DQCDAuXPnoKWlhSFDhoDH42Hw4MHQ09OTqjzxLNqxY8fw686T8H/JyGxLS4a3wdiuDaRtUpXjqwgo/77wEmvPvpD5efFX3+y+TTGzf6tKPcMwDC5fvgw+n48jR44gPT0dXbp0AZfLxdixY2FtbS2zPDXUUFmICLdv3wafz4e/vz8SExPRunVryfRQ48aNK13WkydP4DJzDXS7jpZHIIDFwuD6Qmz9ya3SjyUnJ+Pw4cMQCAS4evUqDAwM4O7uDi6Xi/79+0NbW1t2mTSAgoIChIWFQSAQ4NixY8jJyYGTkxN4PB5Gjx4NMzOzSpd19OhRfLvuEGo7j5NdoP/X0/iOpvjDs0elH4uJiZF8yDx79gwWFhaSD5muXbtWmWC/hqpNXFwc/P39wefzcffuXZiYmGD06NHgcrlwdnau9GxYfn4+HKcsRaK1g9wyzRvQAtP6VO8PqSobUP7555/Ys2cPoqKiyu0c/rff4tejjxRW72qPdvAs5UsjNDQUo0aNwunTpxESEgI/Pz+8f/8ejRs3BpfLBZfLRatWlQtGayjJ3r17MWTIkK9yekxRFBQUIDw8XBK0ZGdnw9HRETweD3FxcQgICCjXnlRlSwAQFRWF9u3bY/Xq1bh8+TJCQkIgEokwYMAAcLlcuLu7o1atWgqTRZPIysrC8ePHwefzERYWBg6Hg8GDB4PL5eLFixc4cOCAxunpt99+w4ULF3Dt2jUYGBhgxIgR4PF4cHFxgZaWlsJk+dqo8Xvy8/TpU8kSk9jYWNSvXx/e3t7Iz89HSEiIxtnS/fv35V5Tri6qZECZkZGBxo0bY+3atZg4cWKxaydPnsTixYsRFRWFOuYWyG3ijFrdPcFiy7ZWJf36IWRHR0CYGgcmPwfaxhYYN8Ydq5YuhoWFBYD/kmsWL16M3Nzcryq5RlW4u7vDysoK27dvV7co1YKiyTxnzpwBwzDo0KEDFixYIEnmCQgIwKlTpxAREYHo6GjoN2iHut4r5ao3834oPj+5iILk96C8LNSvVw/9+vaBr68vGjVqVCy55sCBAxAKhRqVXKNqvkzmYbFYcHR0xJIlSyTJUnv27MGpU6fw9OlT5OcXIN/ICrW+cYNha2eZ661IT0WTa06fPg0igqur61eTXKMqavye4iiazOPv74/U1FTUq1cP06dPlyTzzJ49G5cuXUJsbCxycnPBGJhDv5UTjLt5gK0jW4JjRbZUFDc3N3A4HBw9elQBLVY9VTKg3LhxI3x9fREfH19sXURISAiGDBmC3r17w8vLC+v8w/D8QiBqdRyIOgN/kqmuxKMrwDYwhnYdW7B09CFKeYfsh2dha22J2bNn48iRI5LkmjZt2uDx48f48OED6tSpo6jmftUQEdLS0mBvb49ff/0V3333nbpFqnYsXboUK1asQLt27XD79m1JMs/du3fx+vVrdO3aFdciIsE2bwhLOQPK5DNbQQV50LFoCI6BEaxYGUi8HYy8vDx4enri1KlTkuSabt26wc/PD9HR0WjatKmCWlt1WbBgAdavXw8bGxvExMTAxsYG9vb2OH36NIYMGYI+ffpAcOs9Hl07i9w3D2Hi6IXaPbky1VWWnnJzczFgwACEhoZKkms6deqE7du31+hJgdT4PeWydu1a+Pr6YvDgwTh9+rQkmefDhw/o168f2rRpA8Gdj3j6+CEyHoRB17o5LLmrwGJJnzhali2JRCI8ePAANjY2kntDQkIwePDgKmtL8qfVqoG9e/di+PDhJRbZzps3D+3bt8fZs2fRe/hY5NpPgHH30ci6F4qC5Hcy1WXhsQB1Bk2DcVc3GHUYgNp9voPJwBl4/fo1ZsyYAR0dHezfvx8JCQkIDg6GUCjEiRMnFNHMSrN161a4uLhgzJgxOHfuXLFrSUlJCtuSRx2wWCxkZmYiPT1dspC/Cn4DAdBcPR05cgSjRo3CrVu38OLFC8ydOxdXr17Fw4cPUatWLTTt5AgyqK2Qv3udgT/CfOhsGHfzgGG7/shsOxL65vWRlpYGPp8PDw8P3Lx5Ey9fvsS+fftgamqK/fv3K6CVZXPx4kWwWKwy//Xp0wcAMGPGDHTp0gW6urro2LGjUmUqjaCgIIwePRqvXr3CzZs34eHhgcuXL0MoFOLly5f4kClCQoPeqDt2OfQatkf6zSNg8nNlqqs0PYn0ayM9PR3nz5/H3Llz8eLFC9y8eRObN29WiZ6Koqm2pCiqi9/TVD0dOHAAHh4eOHz4MOLj47F3717o6Ojg9evX2Lt3L4Kv3cMnGyeYDvgRps7jkPc+CvkfZcvDKM2Wth84hKSkJPz777/F7nVxcVG5LSmSKhdQxsTE4OHDh3BxcSn2e1RUFKKiojBlyhRoaWlBEPEWHDYLRp0GAyB8fnZNYTJoGZsDAFauXImzZ89i/PjxMDIyQt26ddG+fXuVBpSbN2/Gzz//jFatWkFXVxeDBw/GypX/jSKJRCK8efNGZfIoEoZhAADXrl2DtbU1nJ0Lp/BYLJbkWlVBU/X0pT01b94cvr6+ePHiBSIiIjBmzBgEv8xUWv3EiFDHoTA5Z+rUqfjrr7/QrVs3sFgsaGtro3fv3kq3px49eiAuLq7Evx07doDFYuHHH3+U3Pvtt9/C09NTqfKURlE9sVgsdOvWDX/99Rc+ffqEoKAgdOzYEfuuvQYxIrBYLOg37w6ICiBM+6SQ+okRoeXgbwEA3333HXx9fSWBjqr0JEZTbUlRVBe/p6l6+tLnGRsbY8KECTh79izev3+PVatWIYZTD8T8/9ZOJoXLbJi8zwqpn8Nm4Xp84RK8tLS0YtdUbUuKpsqtlr5+/ToAoHPnzsV+v3fvHgDgm2++AQBceJ4AEUPQMqoDjpE5CuJfy1wnEYHJyQAYBgWpH5B2cT/AZsPNrWSWapcuXXD8+HGZ65KWHTt2YOfOnfD29gZQ+FJ2d3dHTk4O/vjjD5XJoWiISLJQOioqCkSE2NhYREZGIj09Hbdu3UKtWrWwdu1aNUtaOTRVT2XZE4vFgr29Pezt7XFvzXkk3jim0HpF/29PwoxExNwOAQAMGDCgxH1dunTBiRMnkJGRAWNjY4XKIEZHR6fEHotPnz7FvHnzsGDBAoweXZjVvnnzZgBAYmIiHj58qBRZyqIsPWlra2Pw4MEYPHgwev55Du9SC0ckRZ9TAQBsA/n+ZkX19PT2cQAo8TEPqEZPYjTVlhRBdfJ7mqqnsmwJAKytrTF9+nQcXnYab5PSUJD0BmlXDoClow8da/n2tRXbUl5GInYfPwQApW6bpkpbUjRVLqB89uwZAJTY7iQuLg5AYYfIyhPibUq25BqnlimEWcky18l8TsP7v//bgoNjZA6LYT/DtnGzEvc2adIESUlJSEhIUElmXkxMDHr0+G9bjx49euD8+fNwcXFBQUEBZs2apXQZFE3RzXkjIiIQHByMx48fw9PTE3FxcTA1NUXXrl3x9u1bREdHo1mzknrQNDRVT2XZk5isPCHepeQovN73f08ARAUAALa+Mdas34D+/fuXuK9JkyZgGAbPnj2Dvb29wuUojbS0NLi5uaF3795YunSpSuqsiMro6b04mMzJRNaDs9Ct3wZatSq/3VBpaKKeNNWW5KW6+T1N1VNFtnT5+k3cWDJC8t9aZvVRd+T/wNGXb79oTbQlRVPlAsrk5GRoaWmV2DIkJ6fwpaerq4s3yZ+LH4fE0QGTnw1ZYevXQt2xy0DCfOTHv0L28xtg8nMQei0SjWsX3/8uM7NwevDy5csKXR9iYWGB+vXrl8gYNzc3x7t374pli7Vt2xbnz59H37598fHjx0qVHx0djYyMDIXJWxpNmjSBiYlJuVnvRZ1qWFgYtmzZAjabjUOHDqFFixZo164d8vLyoKenh5cvX2L16tWwtbXFokWLyq2biJCQkIAPHz4otE1f0qhRI5iamipNTw8ePJCcsqEInj17Bg6HgxcvSl8fFJNWAGWs3LIcswQkzEdB8jt8fnIR96Ne4u7duyXuS04u/BC8efOm3NvPsNnsCtc+MgwDb2/vwmUzAoHcOzTcv39fIdOUldUTEYOkU2vB5GXBrP/3cterDj2J4XA46NChQ4nfFWFLRITU1FTExsYqRNayMDY2rlTgpwy/R0QQCoV49Ehx296URlltVJSe3r9/j8TERIXJW5EtfUjPL3zf5+ci78NT5MbeB1Mg21rkonxpSx8S00q9T3y8aVJSktx1qpoqF1CWhfjM4ry8PORT8SCPRPlgacl+pCGLow39Rh0BAAbN7KHXsCPi+T9j7M0jEKaWbhTiaTJFMX36dGzYsKHEKT1OTk44evQoevbsWex3Ozs7nDt3TpJQUBEzZsxASEiIwuQtjZCQEAwaNKjce8RO9cSJE9i9ezfi4uKwZcuWYl9q4k2sTU1N0bNnTyxatAj5+flYtmxZuWUPHToUd+7ckbMV5cPn8+Hp6VnipaooPfXt2xcpKSkKk1dMly5dSv1dx7oFrCesV3h9eg3bAwD0m34D/eYOEOyYAsGurWXeP3PmTLnrNDQ0RFZWVrn3LFiwADdu3MCtW7cUcoKVk5MTPn9WzNoroGI9pYTtQO7rSNQZOgc6lvJ/0KpDT2LMzMwkgWpRFGFLIpEIISEh4PF4CpO3NAYMGIAzZ85UeJ+y/N7p06fh4eEhZyvKx9XVFcHBwSV+V4SeGIbBmjVr8NdffylMXjGV8XkGLRzw+clFJAYug7XPRrls6ktb2rZ+OpramGPatGnF7hMnX1XF7QarXEBZp04dCIVCZGZmFnP44pNn4uLiYFi/ZbFnRFmp0JVz/UNR9Oq3BqeWGbp1bIPNa08Vu7Znzx5s2bIF4eHhki8NRWBhYVHq5qu//vorIiMjS32mTZs2uHDhAgIDAyssf/PmzUodoWSxWJXOjP348SPWrFmD3Nxc/Pvvv7Czs5N8wRORJKg2NzfH+PHj0aJFCwwfPhzt27fHmDFjyqzf398f6enpimpSqTRq1KjUozkVpafz588rdIRy69at2L17Ny5fvlzq3oExaQWYG6bcL2VtU2u0sGsLXQ6wb9++YtdCQkLw+++/499//0WbNm3kqqei0zH8/f2xdu1aBAUFKexowKtXrypkhLIyevrOdzOy7gahdm8f1GrbV+46v0RVehJT1hG3irAlDocDV1fXMstRFI0aNar0+drK8Hu9e/dWehvLWuenCD2x2Wz8/PPP8PHxkVdMCdL6PIOWPYDT6/H56WWFfKQBhbbUqm17CASCEgFlamrh+mdzc3OF1KVKqlxAKT5tJiYmBu3bt5f8Lg5W7ty5gwkdOoMFgAAIM5MhykyCdseBCpWDhPkw1OGUWNi7bds2mJuby3RGsSzMnj0bP/1U9h6blpaW2LdvX4VTwpq0HsfGxgb/+9//0Lx5c8myAbFDFv/v7t274ePjAw6HAwcHBwwfPhxXrlzBmDFjynTg6tzXS1F6Km0KUB769OmD3bt3w8TEpJg9iWmZJ8S8sIpHWOSBBUBPm42C/PwS9hQSEgI2m43hw4fDxMREaTLcv38f3333HVatWoWBAxXnKxS1vVBFerq4aTPSr/rB6Bs3mDiMUkidX6IJegIUY0ssFgtmZmZSHWmpbBTt91gsFkxNTRU6sCENitKTra0tbG1tFSZXZX2eeKkPCQsAYsDkyb5s7ktYAEiYh/Ts/BLXYmJiwGaz0aKF4gbBVEWV2zaoe/fuAFBi6rJNmzZo1aoV/vnnH+hpsdDAzAAAkHUvGAALhi2dpK6Lyc8tde3E52fXwORmoZt91xLXIiMjJTKqggsXLmDMmDHw9fUt9XpV3UJj4MCBxdagFp3mLSgoQHBwsOTv/Pz5c7x+/V8WvyZOFWiqnsqyJzF6WiyYy3ZARAmIEUGUW3LKuXbWGzx5/FiyQ0NRIiMj0aZNG6UGKUlJSXB3d0fv3r3B4/Hw6dOnYv/E67eio6Nx//59fPr0CTk5Obh//z7u37+P/PySLwVFU56eAgIC8POc2TBt1wum/SbJXZem6kmMptqSIqhOfk9T9VSWLaWlpaGgoACGulqwNvpv2VzWg8IPal0r6QddyrSlz5phS4qmyo1QNmnSBG3btkV4eDi+/fbbYtfWrFmD4cOHY8CAATBu7YzUiLvIiDyNWh0GQNv8vy8cYVo8Pmz/DoZt+8F86Owy6xKmfkS8/+8waN0T2maFCTF5n6Lx+ckFaBvWhqGhIRITEyVHMCYkJODhw4flfpUpg23btmHevHl4+PAh+Hx+tTv2LCIiAnfv3sW4ceNQq1YtaGtrY9u2bXB0dES3bt2QlpYGfX19lQbysqCJeirNnogI9+/fx+rVqxEcHIwCi5YQZaeDKchD2jV/AICebVvoNfjvvNk3q4ZC17YtrLiryqyL8nPwYYsPDFr3hI55A7C09ZCfEIM3D89CV0sLffv2hUgkkkztFRQU4NKlS8X2gVQGQUFBePPmDd68eSNZOlOUhg0bIjY2FpMmTcKlS5ckv3fq1AlA4YjCl0eoKZrS9CQSibBt2zbMnDkTRIQ8EcB+fB4ocpqHbv3W0K7935ZI8ujp7cOz0NXWxsiRI4uNhqlKT0XRRFtSNNXB72minsqKIU6cOIHZs2dDV1cXGbWbQcemFfI/RCH7+Q3oWDWHYdviaz5ltSVh0ht8fHwOJiYm+N///lfsfnXYkiKpkkcvbtiwAYsWLUJCQoIkGUfM8ePHsWTJEkQ9fQqRjhFqtesHE0cvsDj/xc75ibGI2z0Nxg6jYNrbp8x6RNnpSLt8ALnvHkOUkQRihNAyrgv9pl3RyUob10OPAyj8quRyuUhMTMRvv/2GT58+KWRBf2Vgs9n49OkTkpOT4ebmBl1dXZw4cULylRsfHw8bGxuFrrtTNcHBwfD19cU///wjeYkDwOTJk8FisTB58mTk5eXByUn6UWhVocl6EtvT7du3cfToUQgEAkRFRcHAwADZ2aVP8xQ91o/Jz8G79aNh0NoZFm6/lFkPiQqQemEvct88hDAjAVSQD04tM7Rq2gBZKYmSgM7LywtcLhfx8fEYPHgwXr58qVFLMtSFWE9nzpxBYGAgDh48KNkurSzqDJ6FWu0L942UV09N6lsh+dN7pKSkwM7ODjweD97e3nj69ClcXV1VpidNtiVFUtX9nibrSWxLMTExCAsLA5/PR2hoKIgI+vr6KBAKIWQArdpWMGjpCONuI8HW+e9kPnltyWPoIPy5fEmJD9HQ0FCV2pKiqXIjlEDhaRXLli2Dn59fiTNO3d3d4e7uDgAYtzsC118nQ8QUj5nz3j0BS1sPxl1LbkxeFI6BCeoMKr5glsNmoUeTOjjwXTckJSXh0KFD4PP58Pb2lqx7uH79Ovr166ew7TMqQ+vWrXH79m14eXmha9euCAgIKHUD4qrI4MGD4efnBx8fH4SGhkpGkQoKClCnTh107frf0oPKLoBXF5qmJ3EWbW5uLlq3bg0DAwO4u7tj7dq1cHFxkWSWlmVLAJD37jEAFky6l54YIIbF0YaZyxTJfxe1JSLC7du3IRAIcODAAaxfvx61atVC69aty0zO+JqIiYlBSkoKsrOz4ejoiLp162Ls2LHgcrno2rWrpM8rW08FBQUICwuDQCDAsmXLsGDBApiZmaFDhw4qX4+oabakaKqL39M0PQmFQjRs2BD5+fmoV68e8vPz0aNHD/z1118YM2aMJBlG2bZUGtu3b4e7u3uVDCaBKjpCCQCrV6/G3r17ERUVVWb25ruUbLhsuIQ8YfEsy8RjK6FlZgPTXhOkrldXi43w2b1g+/9rNMXs2bMHU6dOha2tLV69egVLS0uMHTsWPB4PXbp0UZqxi78CxZuoExF+++03rF+/HqtXr4a3t3e1+FoHCrf9SUtLk2ROHjx4EAEBAQrfokkZaJKecnJycPr0afD5fISEhEAkEqFZs2bIzMzEs2fPSs3aLMuWACD1/B4Is5JhMfxnqeQoy5aEQiH27NmDH374Abq6usjNzYWjoyN4PB5Gjx6NOnXqSNfgKkpycjIOHToEgUCAa9euwcDAAC1btkRiYiJevXoFHZ2SW6GpUk9ZWVnYsmULfvvtNwCAlpYWBg8eDC6Xi6FDh5aYPVIUmmRLqqCq+j1N0hMR4c6dOxAIBPD390d8fLwkcLxx40apAZwqbQkoPJ2rXbt2uH//Ptq2bVvK05pPlQ0oK4v/7bf49ajiNnZd7dEOnl0blHmdiBAZGQmBQICDBw8iPj4eLVq0kEwPKTrTmMPhIC4ursSpPP7+/pg0aRL69OmD4ODgauNcN27ciAcPNguKdwAAuJVJREFUHuD9+/f47rvvMHbsWHWLVCnUrSeRSISLFy9CIBAgMDAQGRkZ6Nq1K3g8Hjw9PWFpaVlhGaq2JaAwaDlx4gQEAgHOnj0LNpuNQYMGgcfjYdiwYUoLWtRFTk4OTp06JQn2iQgDBgwAj8eDm5tbpdag+UXEYsHxJwqTqTJ6io+PR0BAAPh8Pm7fvg1jY2OMHDkSPB4PvXr1Uugos7ptSR1URb+nCXp69eoVBAIBBAIBXrx4ASsrK8lAT+fOnSsc6FGHz6vKVPuAEgD+vvASa8+Wvit+pSACWCx828Uci0aVPlRdGkKhEOfPn4dAIMDRo0eRlZUFBwcH8Hg8jBkzRpLMIw9ffgUW5f79+3B3d8e7d++qlXMFCl+8VSmYUIeexMk14o+bjx8/omnTppKPG2m3pdixYwd+2X8epr3GyyMVABaafn6C8E0/SzVyn5CQgICAAAgEAkRERMDIyAgjR44El8tFnz59quzUuEgkwoULF8Dn83H06FFkZmaiW7du4HK58PT0lOoIVyLC5MmTEfjsM0x6yrNpd6GeepmmY/8v3lI9+eLFC8lL/NWrV7CxsYGXlxd4PB46dOgg92zN1+rzgKrl99Slp8TERImfuHnzJmrVqgUPDw/weDz06dNHqqVo0dHR6PXjSmh3kX9z+J8HtMRPfarmVHZl+SoCSqDwS8P35BMIGSp1TURZcNgsaLEA0W1/iF5cwdWrV1GvXj2p68/OzsbJkychEAgQGhoK4L9kHjc3NxgYlBwCrwyXLl2Co6NjmUaSnJyMoKAgjB8vTxCgeVS0ZkjT1hSpUk+xsbHw8/OTJNdYWFjA09MTPB4P9vb2Mv1d/P394e3tjenTp8OBOxeLT8loS2wWXOtmYtMMT8ybNw9//vmnTPK8fPkSfn5+4PP5iI6OLpbM06lTJ43SfWkQEe7duycJ9uPi4tC8eXNwuVx4e3vLtLE6EeHnn3/GunXrcODAAWi1dJbd57FZaPX5IU5t/A0HDx6Ep6enTPLcunULfD4fAQEBSExMLJbM07BhQ6nLBKq+z5PHN2maXysPVerp8+fPOHnyJPh8Ps6cOQMWi4VBgwaBy+Vi+PDhMr1fP3z4AEdHR+jp6WHu1kCsvfBWZlv6Y3ibaj0yKearCSiBwjURC449wpXoJHDYrHI7hvh6z2bmWDGiHSgrCU5OTjAyMsLly5flWsdVNJnnxo0bMDQ0hIeHB7hcrsqTedRJWloaAKB27doKL/vt27eoV69elR21kpbk5GQcPnwYAoEAV69elSTX8Hi8Ysk1shAcHAw3Nzd4e3tj7969YLPZctmSrZkB/v77b0yfPh0rVqyQrMGTBXEyD5/Ph7+/PxITE9G6dWtJYNa4cWOZy1YGMTExkkD42bNnsLCwkATCRZNrZGHFihVYuHAh/v77b8nWZfLoqV5tPfj4+ODgwYM4efIkXF1dZZataDLPsWPHkJOTAycnJ8m6WE3aYFyZiEQifPjwAQ0aKD64UKY/1USEQiHOnTsHPp+PY8eO4fPnz+jRowe4XG6x5BpZSEpKgrOzMz5//oyrV6/C1tZWbp/3NfBVBZRiXsZnQhDxFhdeJOBtcjaK/gFYABrUMUCfFnXBc2iAZnX/2/7nxYsXcHJyQqNGjXDu3DmFbA306tUryWjS8+fPVZbMo27ev38PR0dHGBkZ4cqVKwo9zSE8PByurq7g8XjYvXt3hUfuVVVKS64ZMGAAuFwu3N3dUatWLbnruHLlCgYMGICBAwfiyJEjJT52ZLUlAFi6dCkWLVqErVu3YurUqXLLWlBQgPDwcEnQIs6IVncyT2nJNSNGjJAE+4r4gNy2bRt+/PFHLF26FL///nuJ67LqqaCgAKNGjUJYWBjOnDlT4lxmWcjKysLx48fB5/MRFhYGDoejkmQedcMwDL799lsIBAKEhIQoNNM5JSUFzs7OyMrKwtWrV1G/fn2Fla1JlJZc07JlS8mod9FN4WUlIyMD/fr1w9u3b3HlypUSS4Pk8XnVHvrKycotoCPnbpKOdQs6cu4mZeUWlHv/3bt3ydjYmPr06UM5OTkKk4NhGLp9+zbNmjWLLC0tCQC1aNGC/vjjD4qOjlZYPZpAQkICtWrViho2bEjv3r1TSh0CgYBYLBbNmjWLGIZRSh3qQCgUUnh4OE2cOJGMjY0JAHXt2pU2bdpEnz59UmhdkZGRZGxsTH379q1UX5fWlhiGoVmzZhGLxSI/Pz9FiU1ERJmZmcTn88nV1ZU4HA5pa2vTsGHDKCAggLKzsxVaV2lkZ2dTQEAADRs2jLS0tIjD4ZCrqysJBALKyspSaF3ivj579uxK9XVp9ZSTk0N9+vQhY2Njunv3rqLEJiKiT58+0aZNm6hr164EgIyNjWnixIl07tw5EgqFCq1LnTAMQzNnzlRKXxfz9u1batCgAbVu3ZoSExOVUoe6iI6OpiVLllCLFi0IAFlZWdGsWbPozp07CvXv2dnZ1Lt3bzIxMaF79+5VeL+0tlTd+eoDSqLCFycAioyMrNT9V65cIX19fRo+fDgVFCi+AxUUFNCZM2do/PjxVKtWLQJADg4O9Pfff1NCQkKFz7969YpGjBhBr169Urhs8pKenk5dunQhS0tLevHihVLr2rp1KwGgJUuWKLUeWamsnhiGobt379LcuXPJxsaGAFDTpk3J19eXnj9/rhTZnj17RhYWFmRvb08ZGRmVfk5aWxKJROTj40NaWlp0+vRpWcUtl/j4eNq8eTN169aNAJCRkRH5+PhQWFiYQoMWoVBIYWFhNGHCBDIyMiIA1K1bN9q8eTPFx8crrJ6inDp1ijgcDk2cOFGqF6u0esrIyKCuXbuShYWF0vrc8+fPadGiRdS0aVMCQDY2NjR37ly6d+9epdqmyX5v8eLFBIC2bdum1HpevHhBdevWpS5dulB6erpS65KVyuopISGB/vrrL3JwcCAAVKtWLRo/fjydPXtWKe/d/Px8GjZsGOnr69PVq1cr/Zy0tlSdqQkoSbYOERwcTFpaWjRu3DgSiURKk+3z58908OBBGjp0KGlpaZGWlhYNGTKE/Pz86PPnz6U+o6kdPDs7m5ydnal27dp0//59ldS5fPlyAkCbNm1SSX3SUJGeYmJiaPny5WRnZ0cAyMLCgqZNm0Y3b95U6qjrmzdvyNbWltq0aUNJSUlSPStL3ysoKCAPDw/S09OjixcvSiuuVLx48YIWL15MzZo1IwBkbW1Nc+bMocjISJn+pgzDUGRkJM2ZM4esra0JADVv3pwWL16s9A+mixcvkp6eHnl4eEj9gpVFT0lJSWRnZ0e2trb09u1bacWtNAzD0M2bN2natGlkYWFBAMjOzo5WrFhBsbGxZT6nqX5v48aNBIBWrFihkvru379PJiYm1KtXL5WMxktLeXrKysoiPz8/Gjx4MHE4HNLS0qKhQ4fSwYMHy3zfKQKRSEQ8Ho+0tbUpJCREqmc1td+pg5qAkmTvEP7+/sRisWj69OkqmVZNTEykLVu2UPfu3QkAGRoa0rhx4yg0NLTYC0UTO3h+fj4NGTKEDAwM6Nq1ayqrl2EYmjdvHgGg/fv3q6zeylCanpKSkmjbtm3k5OREAMjAwIC8vb0pODiY8vPzlS5TfHw8tWjRgho3bkwfPnyQ+nlZ+15ubi65uLiQkZER3blzR+p6pYVhGIqIiKDp06dLgpbWrVvTsmXL6PXr1xU+//r1a1q2bBm1atVKEuzPmDGDIiIiVOILbt++TUZGRtS/f3/Kzc2V+nlZ9fT+/Xtq1KgRtWzZUmmjrkXJz8+noKAg8vb2Jn19fQJATk5OtH37dkpOTi52ryb6vX379hEA+vnnn1W69Obq1aukr69PQ4cOVYnfkIYv9VRQUEChoaHE4/HI0NCQAFCPHj1oy5YtKpm6ZxiGpk2bRiwWiwICAqR+XhP7nbqoCShJvg7xzz//EABatGiREiQrm+joaPrjjz+oZcuWBIAsLS1p5syZdPv2bbpz545GdXCRSETe3t6kra1NoaGhKq+fYRiaNGkScTgcOn78uMrrLwtxv7t27RodOnSIhg8fTtra2sRms2nQoEF04MAByszMVJk8WVlZ1KlTJ7KyspJ53a48tpSZmUkODg5kbm5OT58+lal+WcjPz6fg4GDicrlkYGBAAMjR0ZG2bdtWbIQ2KSmJtm7dSo6OjpJgn8vlUkhIiFKm4MoiKiqK6tSpQw4ODjL3D3n0FB0dTVZWVtSpUydKS0uTqX5ZyMzMpAMHDtDAgQOJzWaTtrY2ubm50aFDhyg7O1vjXuzHjh0jDodDkydPVss67tDQUNLW1iZvb2+lzqJJi1hP//77L82cOVOSM9CyZUtaunSpypcs+Pr6EgD6559/ZHpe0/qdOqkJKEn+DrF69WqysLCo1PpGRVNaMk/Dhg0JgEYETwzD0NSpU4nNZtPhw4fVJodQKKTRo0eTjo4OXbhwQW1yFJVn27ZtkpFmZSbXVAaGYUgkEtHUqVPp0aNHMpcjry0lJydT27ZtqX79+kqdVi2L0pJ5unTpQl26dCEOh6PU5JrK8ObNG6pXrx61a9eOUlJSZC5HXj09fPiQTE1Nic/nyyyDPJSWzDN8+HACQLdu3VKLTEU5f/486ejo0OjRo9WaXHTo0CFisVj0448/akRyYnR0NH3//feEwp3zlZZcU1kYhqHjx4/TunXrZC6jJqD8j5qAkhTTIZKSktQ+tSBO5hkyZIjEYKVJ5lEW0dHRdPv2bbXVLyYvL49CQ0PVEggQlZ5cA4CmTJmitEQHaeWTF0XYUkpKiiTLVx0vGXFyzZgxY0hXV1eiJ11dXRo7dqzCk3kqC8MwVFBQQOHh4ZSamipXWYrQkzo+fEpDnMxTv359yfIDaZJ5lEFWVhaFhoaq/Z1AVLg8Qp07hXyZXCNeurBlyxaVjuyXhbyjtzUB5X/UBJSkmA5RGce1Z88elaw7ErdnxYoVNGTIkEon81SErIanCV/GYtQhS1nJNeL1VdXJESnKuapaT6Ul1zRr1kySXKPoZB4i9dqTql6CqvJ5RCRZ6uPp6Unm5uaVTuapiBq/Jz3lJddcvXq1Wvm9moDyP2oCSlJdh3Bzc6Pvv/9eqXUQlWxPQkIC/f333xUm81TEX3/9RWPHjlXZC0ITyMvLk+m5spJrgoKCJKMWqnZEqhhVU5dzlVVP0ibXyJvMUxR12lN183lExdskTTJPRXxtfk9WWyotuaZ79+4lkmtU6SOqs8/TRGoCSlJ+h2AYhlJSUqhZs2a0a9cupdRRlPLaU14yT0VfsQkJCWRgYEDXr18nItkdj6ZTUFBAu3btop49e9LQoUNpyZIllXqZZGdnS5VcoypHtG/fPsn/V7aDVaVzlVVPikquqWwyT1mo056qm88jKrtNFSXzVMTX4PdktSWGYejWrVtSJdeowkdUV5+n6dQElKSaDvHmzRuysLCgS5cuEZFypyAq057Sknn69etXbrkZGRnUvXt3Wrt2reS3d+/ekbOzM23evFmm7Us0iYsXL9KdO3eoX79+1L59e/rjjz9o06ZNZGRkRN9++225W1j8/vvvUp9co4p+N27cOGKxWOTj4yN5ESrTwaqiTbLqKT8/n0aMGKGUk2tKS+Y5ceJEudOl6rSn6ubziCrXptKSeV69elWubNXZ78lqSwzD0NWrV2U6uUbZfa86+ryqQvU85FiDYBgGAHDt2jVYW1vD2dkZAMBisUBqPEadxWLhm2++wYYNG/D+/XucOXMGU6dOhVAoLPV+kUgEIyMjtGnTBlevXgUA7N27F/369YNIJEL79u1x/fp1TJs2DYsXL8bz589V2Ryp+fJvLxAI4OHhgZMnT6JNmzY4dOgQ/ve//2HGjBnYsmULnjx5gocPH5ZallAoRP369TF79mw8f/4ct27dwowZM2BpaamKppTJ33//jXv37mHGjBmIioqCt7c3MjIywOFwIBKJ1CpbZVGknrS1tdG8eXOsX78eHz9+RHBwMLy9vWFoaCi3nLVq1QKXy0VwcDA+fvyI9evXw9nZucxz5KubPRVFU30eAFhaWmLGjBm4desWnj9/jiVLlqBJkyZgsVil3l+d9KRIW2KxWGjSpAm6d++Os2fP4t27d9iwYQO6dOlS5t9SFVQHn1eV0VK3ANUZIpK8UKKiokBEiI2NRWRkJNLT03Hr1i3o6+tjw4YNapVTS0sLAwYMAFDS6YjhcDgAgGHDhmHlypVwdnbGx48fMX78eMyfPx8cDgcrVqxAXl4eIiMjsWHDBgwZMgQbNmxQe2D1JYmJibCwsABQ+MLgcDjw9/eHj48Ppk2bBi0tLZiamkquNWvWDNHR0WjatGmp5WlpaWHKlClqdaSlkZqaiv79++OXX37B2bNnsW3bNnh5eWHPnj2wtLQEwzBlBjyagKL1RERYvXq10uWuW7cupk2bVu491cmeilJVfB4AtGjRAi1atAARlWm71UVPirYlALC2tsa+fftU1ILKUdV9XlWn5i+rJIo6qYiICAQHB+Px48fw9PTE7NmzsWnTJuTm5iIzMxPp6elqlvY/SnOs4iAzNzcXeXl5iIiIQEZGBvbs2YPff/8durq60NLSwqJFi7Bx40acOnUKt2/fxtOnT+Hv71+sDHWzdu1atG/fHosXL0ZWVhY4HA6Sk5ORkJCApk2bwsLCAqampgBQ7MXYuHFjmJiYlFmuJgWTe/fuxe3bt7Fw4UL88MMPsLKygpeXF2bMmIHMzEx4eXkhJiZG0r5Pnz6pWeKSKENPmqKj6mRPRalOPg+oPnpSls/TJKqDz6sWqHaGXTNR9BqIomtIzp49S25ubvTNN9/Q4cOH6cGDB8QwjGTdTUpKCs2fP1/mXfpLQ5HtEa89SU9Pp/Hjx1O3bt2IxWLRvHnziOi/LTVKWzfj6elJ7u7ulJGRIbcciuLz58905MgRatmyJfXs2ZOSk5MpOjqaDA0N6ePHj0RUsi3dunWjpUuXlnpNHpTR79LT08nU1JS2bdsm+b3oOr7AwEBycXGhHj160JMnT+jIkSNUt25dmY5ZLA1FtUmT9KRINMWeqpvPI6rxe2WhabakSD1VJ59XHaiZ8lYC4i/eEydOYPfu3YiLi8OWLVtgb28vuUdbWxsAEBcXh7y8PKxcuRLJycn49ddf1SJzWXA4HDx79gxjx45FQUEB/v33X2zduhUxMTEoKCiQtEPcZvGUwtu3b6GlpYXc3FwYGRmpswnFMDAwwMiRI/HNN9/A29sb/fv3h5WVFVxdXSVr6YqOWJw4cQKxsbGYNGlSiWuaBhHB2NgY/fv3R2xsrOQ3NpstGT3y8PCAnp4eduzYAVdXV8TFxcHX1xc2NjbqFf4Lqqueqps9ialOPg+oXnqqrrYEVC+fVy1QZzSrKSjjC+PDhw/k6OhIXbp0oSdPnhBRyS898VfU48ePqW/fvlS7dm26d++e3HUrqj0ikYjmz59PjRs3piFDhkiylsPDw8nIyKjML/AHDx6Qi4sLOTg4UHBwsKQsTUEsS1paGq1du5ZYLBa5u7sTUfFswLy8PHJ0dCRfX1/Jb6mpqQo7dUhZo0S//fYbtWzZssRWRUX73+rVq4nFYsl15FhpKLJNmqInRaFJ9lTdfB5Rjd8rD02yJUWPUBJVH59X1alZQ6kkbGxs8L///Q+HDh2CnZ0dGIYp8aXHZrPx+vVr/P3338jLy8PcuXPRsWNH9QhcBnXq1MGCBQtw5MgRySJza2trWFpa4tKlS5L7iAjR0dGYMmUK+vTpg7p16+Kff/6Bq6srAGjUQmjx16uJiQmmT58OX19fvH//Hjk5OeBwOJJ1T7du3YJQKMSwYcNw/Phx9OzZE/Xr18fhw4fV3ILixMTE4OnTp/j8+TMAoF+/fjAwMEB+fr7kHnH/E4lEePz4MVavXo1Zs2Zhzpw56hK7QqqbnoDqaU9iqovPA6qfnqqbLVVXn1flUVsoq0Eo+wujrPNcnzx5Qj4+PuTg4EAbN26U/K6Jow9ixLK1bduWli1bRkRE58+fpwkTJpCtrS0NGzZMsu9cVSEwMJDs7OwoICCAiEhyhrS3tzexWCzS09Mjc3NzmjNnjlxHuH2JIvT0/v17atmyJenq6lKnTp3I0dGRxo4dSywWi5YuXUqxsbGSdVJirly5QvPnz5dX/FJRZt9Tl56Uibrsqbr5PKIavycN6rQlefX0Nfm8qkbNGkoVIF5vk56eLsmai4yMxLp16/DmzRtMnDgRU6ZMAQCN39ZALNukSZMQEhKCP//8E7/++it69+6NU6dOoUOHDpJ7y2vL69ev0bhxY6Wuz8nJycH58+cxZMiQUq/T/6+x6dixI1q1aoVTp05hzJgx4HA4yM/Ph5GREebPnw9PT0+NHEUBgHr16uHIkSNgGAavX7/GpUuXoK+vDwBYtGgR9u3bh+TkZHTq1AkmJiawtrbG8uXL4eTkpGbJ/yM5ORmRkZGSrau+pDroqSwUYU+5ubn4/Pkz6tSpozK5K6I6+TxAfj2JRCIkJibCxMREYp/KgIhw584dWFhYwNbWVrLtUdHrVd2WqoPPq7aoN57VDFRxDNn9+/epbdu29OrVK7px4waNHDmSnJyciM/nS+5T1HobVX4x3b17lwYMGEAcDoccHBxo3bp15Z4oQ0SUk5NDhoaG1KJFC/rjjz8oOjpaYfIIhUIKDw+niRMnSk6uefjwYbl/W4ZhaMGCBWRhYaHS83oVpafSsjC9vb1p+fLl9PjxYzp58iRt2LCBRo8eTdOnT5erroqobJuys7MpICCAhg0bRlpaWmRoaEg5OTnlPqMuPakSae2poKCANm/eTNra2jRs2DAKCAio1HGC1c3nEWm+3/P29iZjY2OaOHEinTt3TqGnt0RHR9OSJUskJ9f88ssv5WZnq9OWFKGnqujzvgZqAkpSXYcYOnQomZmZkYuLC/Xt25eOHj0quVZVHauYjIwMWr16NbVs2VIy9VAWIpGIzpw5Q+PGjaNatWoRAHJwcKC///5bpsXfDMPQ3bt3ae7cuWRjY0MAqGnTprRo0SJ6/vx5hc8SFb4gLly4UOw3ZaNoPRXtQ3PnzqXOnTtXGKQpmvLaJBQKKSwsjCZMmEBGRkYEgLp160abN2+u8KWmTj2pA2nsKSkpiTZv3kz29vYEgIyMjMjHx4fCwsLKDFqqm88j0ny/9+LFC1q0aBE1bdqUAJCNjQ3NnTuX7t27J1NfTkhIoL/++oscHBwIANWqVYvGjx9PZ86cKfdMenXbkjIS94g00+d9bdQElKTaDuHh4UEsFosOHDgg+a06ONaixMTE0OPHj4mo4rZ9/vyZDh48SEOGDCEtLS3S0tKiIUOGkJ+fH33+/LnCepYvX052dnYEgCwsLGjatGl08+bNKhFsKENP4naHhIRQ8+bNJaNVyjzLtihftolhGIqMjKQ5c+aQtbU1AaBmzZrR4sWL6cWLFyqRqaojjT29ePGCfH19qVmzZgSArK2tac6cORQZGVnMJqqbzyOqOn6PYRi6ceMGTZs2jczNzQkA2dnZ0YoVKypcr5iVlUV+fn40ePBg4nA4pKWlRUOHDqWDBw9W6C81BWXtbqEpPu9rpiagJNV3CGdnZ+rYsSPFx8crJfCpqh08ISGB/v77b+revTsBIENDQxo3blyxL+7k5GTavn07OTk5EQAyMDAgb29vCgoKKjMRQFNRpp5SU1PJysqKQkNDFV52eYjbdPLkSVq2bBm1atVKEuzPmDGDIiIiqkSwX9VhGIYiIiJo+vTpZGFhQQCodevWtGzZMnr9+nW183lEVdPv5efnU1BQEHl7e5O+vj4BICcnJ9q+fTslJycTUeGyhtDQUBo37v/YO++4Jq/vj3+SMJTlYlr3APdWRMC9cABqFSFx1VZbrbO2Wr91j7qq1m1b0WrCEBcOwIVaJyqKCwdTtLJBtpDkOb8//CUVASHJkwHyfr14teYZ9zw5zzk5995z7p1AxsbGBIAcHBxo586d5U6z6yLq0pO2fV5leu/URXVASdp5Idq3b1/q+msSiURnqrxlO1toqqf3IdHR0bRy5Uqys7MjAFSrVi1q1qwZ8Xg84nA4NHToUDp06FCJdcfUDcMw8uC2sLBQpXup671jGIYKCwupcePGtG3bNlbv/SnS0tJo0aJFBEAe7PP5fAoODv7kFJw6YBiGpFKp/E/bfCiLpgPqoqIiCgoKIj6fT0ZGRgSAOnbsSADo4sWLGpOjLJ9HxM6UKxv2JLNpWdWzJsnJyaFDhw7RkCFDiMvlkp6eHjVr1oxq1apFAMjOzo5WrVpFMTExGpWL6L/fANlvgiqwoaePbVpbPo+oOqD8EN0uravCPHjwAJ06dSq21ysRQSKRYPTo0Xj06JEWpQNCQkJQu3ZtrFu3TisVmE2aNEGvXr3g4OAAY2NjZGVlISEhAVKpFM2aNZMfMzEx0ahcHA4Hubm5cHZ2RteuXZGRkaHR9j/m7NmzYBim2HvE4XBgYGCA2bNnw9XVVa3tFxQU4PDhw3B1dYW1tTU2btwIAFi1ahWSk5MhFAoxdOhQ6OlpdkEJDoeD6OhoNG7cGOPHj4dUKtVo+x8ilUrh4eGBJk2aICYmRuM7j+jr68PFxQVCoVCuE9kOKUOGDIGrqysOHz6MgoICtcpRms+TsW3bNmzYsEGt7ZdHeno6unTpgj59+iAnJ0fjejIxMYGDgwN69eqFJk2aQCKRICEhAVlZWTA2NpYfa9y4sUblAt5Xuf/666+oXbs2zp49q/H2P+T58+dISUmBRCKRf6ZJn1fNJ9BuPKsb6FIPIycnhzp37kzW1tYUFRWl1D1UfZ5r165RzZo1acSIERqdRi6vuEYsFrNazKMKkZGRZG5uTvb29kqPkqqqpz179hAAOnz4cKnH1TXC8qnimvPnz+uMLRERBQYGEo/Ho6lTp2plqp1hGJo6dSrxeDw6efKkxtsvC9m79+OPPypUzKMulixZQgBo7969St9DFXvKzs6mHj16kLm5OT19+lRpGZShvOKa58+fs1rMoyxFRUU0fPhwMjIyouvXryt9H1X0FBUVRVZWVjRs2LBS31Ft2LguxQ/apjqgJN17IZKTk8nW1paaNGlCr1+/Vvh6VZ7n/v37VKtWLerTp0+Flh9hA2WKa1Qp5mGLu3fvkqmpKQ0YMECpykJV9OTr60scDodmzZqlESda0eIaXbMlIqJDhw4RAFqwYIFGf3AYhqEffviBABQrSNEFPtZTRYt51AXDMDRr1izicDjk5+en1D2UffcKCgqof//+ZGpqSnfv3lWqbUVRprhGlWIetsjPz6fevXtTrVq1KCIiQql7KKun169fU+PGjcnOzk6ntlXVRZ+nLaoDStLNF+Lly5fUsGFDatOmDaWlpSl0rbLP8+LFC7K0tKSuXbtSVlaWQtcqCpvFNRUp5lEXly9fpho1apC7u7vCbSmrpzNnzpCenh5NnDhR7fmBsbGxChXX6KItERFt376dANDatWs11uaaNWsIAO3YsUNjbVaUsvRUXjGPOpFKpTRhwgTS09OT74WtCMq8e2KxmNzd3alGjRpq3+mGzeKaihTzqIusrCzq0qULWVlZKbVSgzJ6Sk1NpdatW1OjRo0oISFB4TbVia76PG1QHVCS7r4Qz58/JwsLC+revTtlZ2dX+DplnufVq1fUqFEjatWqldoqB/Pz8+nw4cPk5uZG+vr6xOVyaciQIawW18iKeWQL/FpZWdGcOXPozp07ahtpOXXqFOnp6dHkyZMVCvCU0dM///xDNWrUIDc3N7UFy2lpabRr1y5ydHRUuLhGV22JiGjlypUEgHbt2qX2tnbt2kUAPrkuoTapiJ5KK+ZxdHSk3bt3K9zJrShFRUXk6upKNWvWpH/++UehaxV996RSKU2aNIn09PTo9OnTyohbLgzD0O3bt2nOnDlkZWUlL65hc0OHj4t59PX1yc3NjQ4fPqy2WaaUlBRq1aoVNW7cmF69eqXQtYrqKSsri7p160aWlpblriusDXTZ52ma6oCS/qvc1cXlTO7du0dmZmbUr1+/Ck+rKvqCq+IcyqO0nWu6d+9Ov//+OyUlJbHa1ocwDEN37tyhuXPnyh25OnbmkSESiYjD4dDcuXMr/B4pqqfw8HAyMzOj/v37s75478c71/B4PHJxcSGhUKhQsK/LtsQwDM2bN484HA75+PiorR3ZuzB//nyd/B6IFNdTTk4OCYVCGjp0KPF4PIV35lGEgoIC6tevH5mZmdG9e/cqfJ0i9sQwDM2ZM0dt78LHO9dYWVnR3Llz1dqxJSJKTEykrVu3Uvfu3QmA2nbmISJKSEigRo0aUevWrRUahFBET/n5+dS3b1+qVatWmSsEaBtd9nmapjqgrARcvXqVatasSa6uruVOB+e+E9ORi7fIwMaWjly8RbnvPj2ilJWVRV27dlV6+qI0VNm5Rh1oqphHNiq1YsWKcs9VVE/Pnj0jCwsL6tGjh0Kj1Z9ClZ1rKitSqZQmT56stlGpU6dOEY/HoylTplTZH5ikpCSFd+ZRlOzsbOrevTtZWFjQs2fPyj1fUXtavnw5AaDdu3ezIi+R8jvXqAtNFPMomialiJ6Kiopo5MiRVLNmTbp27Ror8lajXjhEpazhUI3OERwcDFdXV4wfPx5///13saV8opJzIApLwKXnKUjIyMeHCuUAaFTXCP3sLMG3b4SWVqbyYwUFBRg6dCgePHiAK1euoGPHjirJGB8fDx8fH4hEIkRGRsLCwgIeHh4QCATo0aOHxpfhKI38/HycPHkSQqFQvvzFkCFDwOfz4ebmBiMjI5Xuv3btWvzvf//D77//jtmzZxc7pqyeEhIS4OTkBDMzM1y5cgX16tVTWj4iwv379yESieDr64vExES0aNECAoEAXl5eaNmypdL3rixIJBLs2rULzZs3R//+/VGzZk1W7ltQUIDQ0FDExMRgxowZGl8qSRtERUVBJBJBJBIhOjoaNjY28PT0BJ/PR+fOnVWy+fT0dPTu3Rs5OTm4du0aGjVqVLxtJe3p999/x9y5c7F27Vr8/PPPSssHAHl5ecX8CYfDwdChQ8Hn8+Hq6qqyP2EDIkJYWBhEIhH8/PyQlpaGNm3ayG1e1WWIIiIi0LdvX3Tq1AnBwcEl7EkZPTEMg0mTJsHf3x8nT57E0KFDVZKxGs1QHVBWIvz9/eHp6YmZM2di27ZteJ1ZgMXHH+FqdBp4XA6kTNmqlB13bmGOtaPaw9pUH6NGjUJoaCjOnz8PR0dHpWTKyMhAQEAAhEIhrl27BiMjI7i7u4PP52PQoEHQ19dX9nHVTmpqKg4fPgyRSISbN2/C2NgYo0ePhkAgQP/+/ZUKCIgIP/74I3777Tf8/fffmDhxIl5l5CutJ0PJ+zUvxWIxrl27hvr16yv1rHFxcfDx8YFQKMSzZ89gYWEh/+Hv3r27TgT7mkYqlYLH4+n8PSsDRIQ7d+5AKBTCz88PqampaN26Nfh8Pry8vNC0aVOl7vvvv//CyckJBgYGuHr1KiwtLVWyp9BTAZg8eTIWLFiADRs2KPXeSyQSXLx4ESKRCMeOHUNeXh4cHBwgEAgwbtw4mJubK/WsmkAsFuP8+fMQiUQ4fvw4CgoK4OTkBIFAgLFjx6Ju3bpK3ff69esYNGgQBgwYgGPHjkFfX19pPa1xb4cNyxZi165d8PPzw7hx45R93Go0THVAWcn4448/MH36dIz/3zbc47SAhKFPGurH8Lgc6HE5aJB8E1cPrMOpU6cwZMgQhWQoKCjA6dOnIRKJEBQUBKlUikGDBkEgEMDd3V3ji42zQUxMjDzgevHiBaysrDB+/HgIBAJ07dpVoR8eIsI333yDAwcOYMHuYzieoK+0nngRR5F59wyuXbuG5s2bK/RM6enp8oD5+vXrMDIywqhRoyAQCDBw4MDPYgStGs0jFotx4cIFedCSn58PR0dHedCi6Ah7TEwMnJycYGNjg1lbfbHufKxS9sQlBsnBO+HRrQH++OMPhW367t278lG+5ORk2NnZyQNmRW1TF8jNzcWJEycgFApx/vx58Hg8DBs2DHw+HyNGjFB45D4kJASurq4YO3YsRsxei+WnI5XSExgJUoJ2YvP3X+Kbb75R9LGq0SLVAWUlZNwKb9x+Z4X3O9wpMbJEBHA4GGpThD2zR1XoEqlUisuXL0MkEuHo0aPIzs5G9+7dIRAI4OHhASsrK8Xl0EGICOHh4fIp4eTkZNja2sqnhyr6wyGVStH7u7X4t14XVYQBOBwIOtTCak+nCl1SUFCAU6dOQSgUIjg4GESEwYMHy6f0K2Owr23279+P4cOHw9LSUtuiVDpyc3MRGBgoD1q4XC6GDh0KgUCAkSNHVjhoefjwIQbP+w01eig/WkVE4HA4mD+wJWYPsK3QNTExMfIpfVlHUzayr2hHU5dJSkqCv78/RCIR7ty5AzMzM4wZMwYCgQB9+vSp8Kj74cOHMe33Y6jde4LSssj0tGCwLb7vV/VTcKoS1QGlDrFhwwZ4e3sjMjKyzO0O/e4kYNEx9rZlXD+6PTy6Nyr1WHBwMMaMGYPJkycjMDAQb968QfPmzcHn88Hn82FrWzGnXFmRSCQIDQ2FUCjE8ePHkZubi549e8LKygpPnjzB8+fPdUJPjx49QqdOnTBixAhcunQJOTk5sLe3B5/Ph4eHR3UgpCLu7u6wtrbGnj17tC1KpSY5ORmHDx+GUCjE7du3YWpqCltbW6SkpCAmJuaT6TGasqfIyEh06NABP/30Ey5duoRbt27BxMQEo0ePBp/PVzoVpjLx4sULeRAdExOD+vXro3nz5nj16hWio6M/GVxqWk8RERFo164da+1VoxrVAaWOkJ2djaZNm2LTpk2YMmVKsWMnT57E8uXLERkZCamhGYzbD0Qtx/HgcBXP1WLE75D38ALyo8IgTo0HI36HNnYtMfO7bzFt2jTweLwSxTU1a9bE1KlTdaq4RtPIinn279+Pc+fOgcvlwsXFRT7yd+rUKZw6dQphYWGIjo5GzUbtYen1q9LtETHIexSK/Bc3UJQcC+ZdDlo2b4YJfC8sWLAAhoaGJYprjI2N8eOPP342xTXqhojw9u1b9OjRA4sWLcLUqVO1LVKVISoqCt7e3tiwYQMYhpEX8wwfPhx3797F6dOn8fTpU4jFYjRrYYukRv1hYOesVFul2ZJ+bWvM/noSVi39GTVq1ChWXBMUFAQOh4Phw4frVHGNppEV8+zfvx9//vkniKhYMc/WrVtx5coVxMfH4927d/iiQSNkWHeFcfdR4BooXuhWET19iJubG3g8Ho4dO8bWI1ejItUBpY6wdetWLFu2DMnJycUMJzg4GMOHD0ffvn2R39AeTyOfIDv8DEw6DUG9ITMVbqcoNR6J+2ahRpOOqNG0M/QMjVEz+RFe3b+Cnj17Qk9PD9euXUPNmjUxatQo1K5dGwcOHEBSUhJMTU3Lb6CKs3XrVixduhQrV67E4cOH5cU8JiYmyM7Ohr29PW7cvgeueWNYqRBQMkUFeLV5LAzq28GoRQ/oGddGrew4xN0MQuPGjWFgYIDnz5/DwsIC48ePR7NmzTBv3jxER0dXynwuXSUhIQHdunXDkSNH0Lt3b/l0XDWqI/N5p0+fRkBAgLyYBwBat26NL7/8ElZWVli1Yz+Sn4WjlqMnajvzFW7nY1viGtVC0ZvnyHt0Ee3bt0OHDh1w/PhxeXFN586dsWvXrmpb+n9kevr7779x+PBhnDhxAgUFBTAzM0PXrl0xePBg1KtXD5t8QhB19RQMbFrCir8OHE7pszdl8Sk99enTG6GhocVsLzg4GMOGDavWkw7x2QWUu3btwrFjx1C3bl1Mnz4dAwYMkB9LS0tDjx49EBsbq3G5OnbsiA4dOuDQoUPFPm/bti309fXhe+YSXHbcAABk/nMI2TcOo/43u6Bfr6FC7UjzsyDNewsDi+JLRbzeOh7Sd7lwcnLC9OnT5cU1KSkpqF+/Pv744w989dVXqj1kOVy+fBn9+vUr83jfvn1x6dIlzJ49G9evX8fjx4/RunVrREREqFWuD/lYT7Jinv379yMuLg7Wtp2QnpEBbk0zWPPXKd0OScUoTIxGjQati33+6ncvMAXZ6N+/PxYsWICBAwdCX18fYrEYVlZW+P7777Fy5UqVnlERdNWeVIVhGHC5XPj6+mLdunV48OBBiWOVCV3U08e2JBaLIRQKERgYiPPnzyM/Px89Brkiqcs3SPH7H969foqGc3zBNahRzp2LU5Ytvb3mi6xrIjRo0ADTpk2T50hr0pYqo8/LycnBiRMnIBKJ5MU8/d298Kz5WGSHHUPmJW9YT9gEwy9aKdROeXo6f/48Bg4cKP+82ufpHpXLK6rItm3b8OOPP6JVq1YwNDTEsGHD8Ouv/40iSaVSvHz5UuNyxcXF4eHDh8WMBXifJxIZGYlp06bBP/zN+wo4AKadhwEg5D27rnBbPKNaJYJJMFJ0Gz0NAPDTTz9BIBDIizcsLS3RoUMHBAYGKv5gCtKrVy8kJiaW+Nu7dy84HA5mzJghP/err76Ch4eH2mX6kNL01Lx5cyxZsgQxMTG4c+cOWrtOY6UtDk+/hGMFMRj87XIA7/P6XFxc5Hln+vr66Nu3r0b0JENX7UlViEgeMEZGRoKIEB8fj6NHj8Lb2xszZszAggULtCxlxdFFPZVmS/r6+pgyZQpOnDiB5ORkCIVCFDWyB4hBzZYOgFQMydskhdsq1ZYAGNvaAwB+/PFHLFmyRD7KpUlbqow+z9TUFBMmTEBISAj+/fdfbNy4ES8NGoEYKXi13hdnMoV5CrdVlp5MW/UCADx9+rTY59U+T/eo2tnFH7F37178+eef8PLyAgB89913cHd3R0FBgUZ7OB9z48b7kccuXYpXBN+/fx8A0K1bN/x4JUW+/IKeaT3wTM0hTmapF8TlIaPo/f+WtoZa165dceLECXba+gQGBgawtrYu9tnTp0+xYMECLF68GGPHjgXw3qiB9+tIPnz4UO1yyShLTwDA4XDQrVs3SC/lqE8ADhf/5koAlK2nwMBAZGdnw8zMTH1y/D+6ak+q8OGUdlhYGIKCgvD48WN4eHggMTERderUQffu3ZGQkIDo6Gi0aNFCyxKXjy7q6VO2BAAmJibg8/n4480lZGbkQ5qXCQDgGrH3XkvysgAAFhYWJY5pypYqs88D3vshPp8P39RLyIh+gLdXD4FjUBMGNuwVbBblZMjb+phqn6dbfFYBZVxcHHr16iX/d69evRAaGoqBAwdCLBZj7ty5WpHr2bNnAFBi8d/ExEQAgFldCyRkpBY7xjOpA0luOivtk1SM+MtH0KRJU3Tv3r3E8WbNmiEtLQ0pKSkarRh++/Yt3Nzc0LdvX6xatUpj7ZZFWXqSkVsoQUJGvlpliDrvAzMzM7i4uJQ41qxZMzAMg2fPnqFHjx5qlQPQXXtSlg+DyfPnz2Pnzp3gcrk4fPgwbG1t0b59exQWFqJGjRqIiorC+vXr0bBhQyxdulTLkn8aXdRTebYE/GdP0oIc5D44B8MGbaFnotzC26WRHXYUHEMj9O4/qMQxTduSjMrm8+7evQsHBwf5v/XqNoDlmCXg1WQv316X9KSLtqRLfFYBpbm5OV69eoUmTZrIP2vXrh1CQ0PRv39/vHnzRitypaenQ09Pr8QagQUFBQCAlHwpPk505fAMwBSxE7xknNsDcVoCvOZvLrX3m5PzftTtn3/+QbNmzVRur0WLFuX2JhmGgZeXF/T09CASiVQqhIiPj0dGRobS18t49uwZeDweXrx4UerxuLfiEnpik6wbh/EuPgIT5vxYao5Oevr7DsatW7dYXdrE1ta21PUr2bAnhmE0kg/WsWNHcLncT75HsmOBgYHYt28fEhMTsXPnzmI/VLIUgzp16sDZ2RlLly5FUVERVq9eXeZ9iQiPHz+GWCxm6WlKp1OnTqXmdrKhp9zc3DLfe2Uoz5aA9/bEEIO0U5vAFOai7qDprLUvs6W6g2fg1pMYNP03odhxtm2pbt26xb7/0mDT52VnZyM6Olrp62WUp6eioiIs3bANu2+loPDfp3gXHwFG/E7ldmV8qKe3Un188dHxOnXqAHifu6gJdDWG0BU+q4DSyckJx44dg7Nz8eUn2rRpg4sXL34yOVobyBb9zcsvKHGMpEXg6Bmo3EZW2FHkPjiLWs4CbNq+B2sXzy/zXNn0i6p8nFxdGosXL8bNmzfl69WpwrJly3Dw4EGV7vEhXbt2LfVzAxtb2EzazFo7H5L39B+8/ecQTDoMxt+HA/Hn7xvLPHfOnDmstn316lU4OZVcWJ0Ne5JIJGV+n2zRoEEDxMfHV+gH+s2bN9i4cSPevXuHgwcPok2bNvKRSyKSr8Fnbm6OiRMnwtbWFq6urujQoUOpW8QREfLy8tChQwfWn+tjCgsLYWBQ0iewoaeIiIgS17PBp3RvYGMLA5uWeBcbjnoj5sPASvXOLFDclky7DIOXYCKKEksPmNiypYkTJ+Lvv//+5Dls+rzbt29j0KCSI3rKUp6ebCZthpFtT+Q9uYzUo6thM3mryvr6WE9FEqbEObKaYk2tvFDZYghN81kFlIsWLUJ4eHipx9q2bYtLly7h6NGjGpYKqFevHiQSCXJycoo5EhsbGwBAVnpqiWukuZkwVDFPJffhBby9dAAmnV1Q23E89i3/Hk1rl1xc2NvbGzt37sSFCxfkPUJVKC/vzM/PD5s2bcKZM2dYWU9xxYoVrPww7Nq1C/v27cM///wDY2PjEsfj3orxw3n2e8oFcfeRdnozajbvhrpDZ2LzEKtS9RQcHIxffvkFBw8eRNu2bVlrv6wF7NmwJz09vTLvwRZ169at8E4f9evXx5IlS9CyZUv5aLzsx0r233379mHy5Mng8Xjo2bMnXF1dcfXqVYwbN67EskIcDgfGxsZqf0YAZY6ksaGnTp06sfoM5dkSAKzfthuH//4LtftOhkm7/qy0+7EtAYCP8GAJe2LblsrbI5ttn9ejRw9W9FURPX3o94zsegGnNyPv6T8qBZSl6clAr+Toe2bm+9xaTe2frqsxhK7wWQWU8+bNw8yZZa/daGVlhQMHDmg8J6pVq/fLK8TFxRUbyejUqRMAIDHmCThoJp9OleSkQ5qTBv1Oiu3B/SH5L24hPXgbjOwcUHfwd+AAGOrYFcaGJV+J3bt3w9zcvNjyCOoiIiICU6dOxbp16xTeY7wsmjRpUu50U0Xo168f9u3bh1q1apU64mRXKMGC82dVbudDCt88R+qxNTC0bglz90Xgcnll6ik4OBhcLheurq6oVasWq3KUBhv2xOVyy0z41xYfv3cZGRnygEAsFiMoKAh79+7F7du38fz5c8TGxsqDjtJGSjgcjlafkQ09mZiYsPoM5dnSzp07cfjvv2DWzQ21en7JSpsf2xKHyyvT72nSltTh88zMzFjRV3l6Av7zewSAJGKAGDCFyqdjlaWnJvVK6cTHxYHL5Wps1zZdjSF0hc9q2aBLly5h3LhxWLZsWanHtVXyL0tqvnv3brHP27Zti1atWuFv731oWNtQ/nnu/SAAHBjbVWx/5495l/AYaSc3wLBhO5iP/BEcDhe1eGLkZ2eWen54eHixxGt1kZaWBnd3d/Tt2xcCgQBJSUnF/mSLHkdHRyMiIgJJSUkoKChAREQEIiIiUFRUpFb5ytIT8H7q5fmThzAi9opyxGmvkBKwAnq1LGExdhm4+oaoayAFR1r6c4aHh6Nt27YaCSYB3bUnNgkLC4O/vz9yc3MBvM+h3L17NzIzM2Fvbw9XV1dkZGRoxD6URRf19Clb8vf3x+zZs+Ho6AgLJ3bSbEqzJQCwNuHByKDk6LWmbKmy+ry3b99CLBYjJSUF3n/sBjf/fY567oP3HWpDa+VWPyhLT43qGZXaia72ebrFZxVQAu9H27Zu3YpRo0YhL0/xtbLUQbNmzdCuXTtcuHChxLGNGzfi4cOHeO3zC/IenEXG+b3IuhkAk46DoW/+36LmkrfJeLluBNJOb/lkW5KsFKQcXQWAA+NWjsh7dg25jy8iJnA7rKys4OzsDB8fH/l3k5KSgocPH8LNzY3VZy6NM2fO4OXLlwgKCoKNjU2JP1kF+tdff43OnTtj7969ePHiBTp37ozOnTurPSG6ND3FxcVhzZo1aNq0Kbp27YpXJ7ZAmp8FSXYq3l73w9vrfniX8LjYfV6uG4Ek0aJPtsUU5iP58FIw73Jh3K4/CqLvIPfRRTw7uhV169aFi4sLzp07B4nk/TJCYrEYV65c0YiePkQX7YlN0tPT4e3tjaioKPlnlpaW6Nu3Lzp27AihUIgdO3bIlxHRVXRNT6XZkkQiwbZt2+Dl5QWGYXD9+nUU3D6KvMehyH18CbmPL0H80TqUStvS40vIfXQRD303oGnTplizZg3i4uIAaNaWKqPPy8vLw8qVK2FmZgZra2vMnTsXRXcOI/X4WmRe2g8D65Ywblc8l1AVPeVHXkK9N2G4efNmsfOrfZ7u8VntlMPlcpGUlIT09HS4ubnB0NAQgYGB8lyp5ORk1K9fH1KpVOOybdmyBUuXLkVKSoq8GEfGiRMnsHjJMjx9+hQ8o1owaT8AtRw9weH912N7v6Xi9zDr+SXq9J1cZjvvXj5Esu/iMo83aNAAr1+/hrGxsXzrRW9v7+qtF/+fLVu2YMmSJVizZg0CAgJw/fp1GBkZoXnz5nj06FGp13y4ZZxsezGj1r1h4fZTme1I3ibj3z1l7x1tZmaG7OxsWFlZybdenDNnDqKiojS2NqIu2xObCAQCPHr0CCEhIfK85smTJ6NevXr47bff5Ofp6raMuqonmc8LCgrC0aNH4efnh+Tk5E9eU2/YXJh0eF/Qx5YtNWvWDElJScjPz4ejoyM6d+6MHTt2aNSWdBmZnoRCIQICAnDixAnk5eXBwsJCXnTGEIExsYSRnSPM7McU282ILT1NmjQJBw4ckP87JCQELi4u1T5Ph/gsA0pLS0tkZWXB09NTPqU1cOBArb4MWVlZaNasGTZs2ICpU0s3qgn7wnAjNl2+wPmH5Nw7g8xL+/HFt3+CZ1zxwhkel4Nezerh0FR7+WexsbHw8fGBSCTCs2fPULNmTXzzzTfg8/no3r27Tv5oqpuCggKcOnUK+/fvR0hICDgcDoYOHQo+nw83N7diy+p8Sk8FMXeQErASNl9th4Flkwq3/7GeiAjh4eEQiUTw9fVFcnIyjI2NsXDhQvkWcupGl+2JbUaMGIG3b9+iSZMmICL4+vrC39+ftZUP1Iku6ikmJgb79u3D+vXrwTAMrKys4OnpCT6fj65duxbzMWXZk7K2BJS0p9zcXAQGBkIoFMrte8SIERAIBBg5cmSJTv7nABHhzp078Pb2xh9//AEiQqtWrSAQCODl5VVibUpN6OlD3N3dweFwcPz4cYWfTVl00ZZ0ic82oATeG8zPP/+MzZs3Y/369fDy8tLqy7B+/Xrs378fkZGRpa4n9yojHwO3XEFhKcsnpB7/FXp166NOn0kKtWmox8WFeX3QsK5RiWPBwcEYM2YMJk6ciMDAQCQlJaFly5bg8/ng8/lVvvculUpx6dIliEQiHD16FDk5ObC3t4elpSWePn2K58+fK6ynzFBvSHLTYeH6o0KyfEpPjx49QqdOnTBs2DBcvnwZubm5cHBwAJ/Px7hx40rdCYQNdN2e2Gbr1q148OABXr9+jalTp2L8+PHaFqlC6IqeUlNTcfjwYQiFQty6dQsmJiawtbVFSkoKYmJiSl3yCCjbnpS1JaBse3r69Cnat2+PH3/8EaGhofIlfMaMGQM+n49+/fpVeMWAykp0dDREIhFEIhGioqJgbW2NFi1a4NWrV4iJiSnz+f/TkxTAfx0CdeopIiIC7dq1U/i+yqIrtqSrfFYBJY/HQ2JiYondXvz8/PD111+jX79+CAoK0umXwe9OAhYdK31qVRnWj24Pj+6Nyj1PKpUiNDRUHlzl5ubC3t4eAoEAHh4eagtaNA0R4f79+/KRv8TERLRo0ULeK6/okh4+YfFYfOIJa3JVVE/5+fk4efIkhEIhzp59nyA/ZMgQ+UiqkVHJgFRZqoI9KUNBQUGlGrHSpp7y8/MRGBgIkUhU7H0UCARwdXWt8Pv424mb2B6m+uYEMipqT1FRUfLgKjo6GjY2NvD09IRAIECnTp2qzGxNSkoK/P39IRKJEBYWBhMTE4wZMwYCgUChIPrHPccR8FL19ZFlVFRPmuJz9XkV5bMKKD/uXXxIREQE3N3d8erVK51+Gf766y/84H0edfpMVPle2ddE8F86ReEFcPPz83Hq1Cn59BARFQtaylqvTJeJi4uTT/M/ffoUFhYWGD9+PAQCgcLT/ESE6dOn4/CTbNTuPUFl2ST3juOf3YsV3qVINiIkEolw8+ZNmJiYYNSoURAIBOjfv7/KO4BUBXtSBl3NlSwLTetJIpHg4sWLEIlEOHbsGPLy8lQaMY+NjYWTkxPMHMbhna0qi3UTAA5a5j/Fua0/KGzTt2/fhkgkgp+fH1JTU9G6dWvw+fxSp38rA3l5efJp/nPnzoHD4cDFxQV8Ph8jR45UuPN57tw5jBgxAvZfLcOrOp1UkOy9nvrVzcH+H3VrFuBz9XkV5bMKKK9cuQJHR8cyf0jT09Nx5swZTJyoerCmDgICAuDh4YHvvvsOTpMWYvmpJ5AwVGquXlnwuBzocTlYOqwVRKtm4sqVK7hw4YLSy56kpaUhICAAQqEQN27ckBfz8Pl8DBw4kNUtANkmPT1dHnDJims+lF22zZ6iLFy4EBs2bMD+/ftRo21/LDupvJ4W9G2IDd+OAsMwuHbtmrwoRFFiYmLg4+MDoVCIFy9eyIt5BAJBiZy1ilKZ7YmIwDAM69OXUqm03C0eNY0m9EREuHv3rjzgSk5Ohp2dnTzgUjan982bN3BycoKenh6uXr2KSwmFKtnT4HpvsWOeFxYuXIh169YpJZNYLMaFCxcgEolw/PhxeTGPQCDA2LFjUa9ePaXuqwkkEgkuXLgAoVAoL67p1auXXHZlFwi/ceMGBg0ahL59++LEiRM4GpGokp5ssyMQtOMX+Pv748sv2VmHlA0qs8/TBJ9VQFmZCQkJgaurK8aOHYtDhw6By+XiVUY+Fh9/hKvRaeBxOZ80XNlx5xbmWDuqPRrWNUJ+fj6GDh2KR48e4cqVKypvD/dxMY+lpSXGjx+vU8U8suIaoVCI4OBgEBEGDx5canGNMqxbtw4///wztmzZgrlz5wKAynp6+fIlHB0dUadOHVy5cqXcXTc+RWnFPLa2tvIpfU0U82gbqVSKPXv2oFmzZujbty9r09cFBQW4fPkyYmNj8e2331b5XDvgfUdFNiUs66iUVVyjKOnp6ejTpw+ysrJw7do1NG7cGIDq9rRlyxbMnz8f69atw8KFC5WWDyhezHP+/HlwuVwMHTpUp4p5ZMU1smA/JSXlk8U1ivLw4UP06dMH7du3R0hIiHxkUxU9fVG7BgQCAY4cOYJTp06xtuB7NeqlOqCsBFy/fh2DBg3CgAEDcOzYsRIjZ1HJORCFJeDSixQkpOfjQ4Vy8H5R2H62lhD0bIQWlsWX/snKykK/fv3w5s0bXLt2jZVCG1keolAohK+vr9aLecoqruHz+fDw8Ch1+kIZ9uzZg++++w5Lly7FihUrShxXRU9Pnz5F79690bx5c1y4cEHlwBd4P1oRGhoKoVCI48ePa6yYR5sQEb755hscOHAAx48fx8iRI1m9/8mTJzF69GhMnjwZf/75p050otimtOKa0aNHg8/ns5JKAbwP1AYMGIDY2FhcvXpVvpvYh6hiT0uXLsWqVauwZ88eTJ8+XWV5gfdLxsi+F10o5imtuEaW/9m5c2dW3s2oqCg4Ozvjiy++QGhoaKkLjCurJ7FYjFGjRuHSpUs4f/48evXqpbK81agZqoYYhiGpVEoMw2hblBJERERQrVq1qE+fPpSfn1/u+bnvxHTk4i0ysLGlIxdvUe47cbnXJCcnk62tLTVp0oRev37NhthyJBIJnTt3jiZNmkQmJiYEgOzt7Wn79u2UkpLCalsfwjAMhYeH0/z588nGxoYAUIsWLWj58uUUFRXFenu+vr7E4XBo1qxZFXqPlNHT3bt3ydTUlAYMGEDv3r1jQ2w5eXl55OvrS8OHDyc9PT3S09Oj4cOHk4+PD+Xl5VX4PrpsSwzD0A8//EAA6NChQ2pr59ChQwSAFixYoJPfA5HiesrLyyMfH58S74evr69C70dFKCgooAEDBpCpqSndvXu3Qtcoak8Mw9CsWbOIw+GQn58fG2IX48WLF7Rs2TJq0aIFASAbGxuaP38+3bt3T63vRHJyMm3bto3s7e0JAJmYmNCkSZPo/PnzJJFIWG3r9evX1LhxY7Kzs6uwL1dUT/n5+dS7d2+qXbs2PXjwgA2xWUeXfZ6mqQ4oiSg8PJwAUHh4uLZFKcaLFy/I0tKSunbtSllZWRW+TpnnefnyJTVs2JDatGlDaWlpyohbLnl5eeTn50cjRowgPT094vF4NGzYMBKJRJSbm8tKG7GxsbR69Wpq3bo1ASALCwuaNWsWhYWFqc3gz5w5Q3p6ejRx4kSSSqUVvk4ZPV2+fJlq1KhBo0aNIrG4/CBUGVJSUmjHjh3k4OAg/1GaMGECnT17ttw2ddWWiIhWr15NAGjHjh1qb2v79u0EgNasWaP2tpShInoSi8UUEhJCEyZMIGNjYwJADg4OtGPHDrV1BsViMbm7u1ONGjXoypUrCl2r6LsnlUppwoQJpKenR0FBQcqIWy4Mw9CtW7do1qxZZGFhQQCodevWtHr1aoqNjWWljdzcXBKJROTi4kI8Ho/09PRo5MiR5Ofnx3qwLyM1NZVat25NjRo1ooSEBIWuVVRPWVlZ1KVLF7KysqIXL14oI65a0WWfp2mqA0rSzRfi1atX1KhRI2rVqhWlpqYqdK2yz/P8+XOysLCg7t27U3Z2tkLXKkpqairt2rWLevXqRQDI2NiYBAIBBQcHKxwopaWl0a5du8jR0ZEAkJGREfH5fAoKCqKioiI1PcF7/vnnH6pRowa5ubkpLLeyejp16hTp6enR5MmTFQpglSE6OppWrlxJtra2BICsrKxozpw5dOfOnVIDdF20JSKiHTt2EABatWqVxtpcuXIlAaBdu3ZprM2KUpaeGIah27dv05w5c8jKyooAkJ2dHa1cuZKio6PVKpNUKqVJkyaRnp4enT59WuHrlXn3ioqKyNXVlWrWrEn//POPwm0qQlFREQUFBRGfzycjIyMCQI6OjrR7926FO/FisZiCg4OJz+fLg/1evXrRrl27FP69UJSsrCzq1q0bWVpa0vPnzxW+Xhk9paSkUKtWrahx48b06tUrhdtUJ7rq87RBdUBJuvdCqGo8qjzPvXv3yMzMjPr160cFBQUKX68MMTExtGrVKmrVqhUBIEtLS5o9ezbdvn27zFHF/Px88vf3p5EjR8pHO11cXEgoFFJOTo5G5A4PDyczMzPq37+/Ut+VKnoSiUTE4XBo7ty5GplqYRiG7ty5Q3PnzpUHGra2trRy5UqKiYmRn6drtkREJBQKCQDNnz9fo9NSDMPQvHnziMPhkEgk0li7FeFjPUVHR9OKFSuKdRzmzp1bZseBbRiGoTlz5hCHwyEfHx+l7qHsu1dQUED9+vUjMzMzunfvnlJtK0pOTg4JhUIaOnQo8Xg80tfXJ1dXV/L39y8ztYlhGAoLC6PZs2eTpaUlAaBWrVqxOtpZHvn5+dS3b1+qVasW3b9/X6l7KKunhIQEatSoEbVu3VrtQbMi6KLP0xbVASXp1gshkUho2LBhKg3vq/o8V69epZo1a5Krq6vaR/g+RJb3OG/ePLK2tiYA1LJlS1qxYgVFR0eTRCKh8+fP0+TJk8nU1FSej7lt2zZKTk7WmJxERM+ePSMLCwvq0aOH0qO5qupp165dBIBWrFih1PXKIhaL6ezZszRhwgR5XqxsKvTChQs6Y0tE70dzeTweffXVV1rJcWIYhqZMmaL0qJu6kL17CxcupJ49e8pTGyZOnFih1Aa2CQgIIAC0e/dupe+hij1lZ2dT9+7dycLCgp49e6a0DMqQlJRE27Ztox49ehAAMjU1pcmTJ8vzHqOiomj58uXUsmVLAkDW1tY0b948Cg8P1+g7XVRURCNHjqSaNWvStWvXlL6PKnr6MA2MrTQpVdGl+EHbVAeUpFsvhFgspjdv3lBkZKTS92DjeYKCgsjAwIB+/fVXrfwQf1jMI5se0tfXJwDUtGlTWr58udbyaTIzM8nJyUnlfFM29LRmzRrasmWL0terysfFPDweT547qK78rYry4sULatCgAY0ZM4b1ggRFEIvFNHr0aGrQoIHWc8BkxTVOTk4EgHg8ntqKayqKrKjhzJkzKt1HVXtKS0ujNm3akJOTE2VmZqoki7LIinmaNm1azOfVrFmTJk6cqJbimorAMAz9+uuvZGhoSMHBwSrdS1U9RURE0MiRI+ndu3c6UQijS/GDtqkOKEn3XghVjYSt55FN42rDgX1cXGNqakpNmjQhHo+nlmKeisIwjPz7KCwsVOlebOiJYRidcKpE71M1Fi5cSHi/1YVCxTxsIwtSpFKpVoNJGRKJhCQSiVaqQUsrrmnfvj0BoAsXLmhUlrJg4zthw55kNi2RSDSupw+La7hcLvF4PGratCmZmZmppZhHEWQ2xEYaFBt60hW7JtK9+EGbcCu8vlA1GkNX1q6rUaMGAGhs/bT09HTs3r0bTk5OaNasGdauXYsuXbogKCgI6enpiIuLQ1JSErZv3463b9+Cz+fDysoKEyZMQEhICCQSicJtMgyj0PkcDkf+fRgYsLdnrbJwOJwKvS/79+9HSkqKWmWxsLDAuHHjAAAnTpzATz/9hLCwMAwZMgQNGjTA3LlzcffuXZASS98qoyculwsul6sTC4zzeDzweDyN7aJD/7+Y9dy5c9GgQQMMHToUt2/fxsKFCxEdHY0DBw4AAOrUqaN2WSqCrvg8mU3zeDyNyCSRSBASEgKBQAArKyvw+XxkZWVhx44dSEpKQmxsLNLS0hAUFIQuXbpg7dq1aNasGZycnLBnzx6kp6cr1a6i9iSzIdlvgrapiF1rwudV8xHajmh1AU32MDTRq9JWj0mZETtVimuUKeb5mO3bt9P48eM1noNJpFk9ubm50fTp09XezsfPVNFinvLQpp60hTL2VNHimqrm84i04/eU0ZEqxTXKFPOUxufg97Tl8z5nqgNK0swLceDAAfn/q9vBavIFF4vF9Ndff5GzszONGDGCVqxYUa6TYru45lPFPOUFLSkpKWRkZEQ3btwgItWnsRVBE3piGIYyMjKoRYsW9Ndff6mtHRmfeqZPFfNkZGR88r7a1JMmUcaeZOuGKlJcU9V8HpHm/J4yOiIi1otrPlXMU95yYlXZ7+mSz/vcqA4oSf0vxIQJE4jD4dDkyZOL5eioC0284JcvX6a7d+/SgAEDqEOHDrRy5Ur6/fffydTUlL766qsyl3VgGIZ+/PHHYjvXsFmo8PHOPF5eXp88Pzs7mxwcHGjTpk3yz169ekW9e/embdu2sb4jzYdoyhG9fPmSLCws5AtFqzM3rKLP9HExz/bt2z+ZZ6lNPWkCZe0pPz+fjI2NFd65pqr5PCL1P5OyOpJKpfTgwQO17lzz4c48xsbG5eY6VnW/p4s+73OgOqAk9b4Q27dvp3bt2tGcOXOoR48eNGbMGPmuN+pysGw/z8fGKBQKqW7durR06VKaPXt2sWU2Dh48SPb29nTx4sVS7yWRSCgmJkatO9fIyMvLozdv3pT5Pcs+//rrr8nd3Z2IiLy9vcnW1pYcHR3p8uXLFBoaSjNnzqRly5axvpyIuh2RbJTCx8eHOnToUOyYur57ZRct/tQPoLb1xDZs2hMRUXBwsMI711Q1n0fE7jOxrSMiopMnT6q9kp5hmHK3ltW2Panz3assPq+qUl2Uo2YyMzMxaNAgLFq0CDNnzsS///4LT09PJCcng8fjKZwcrWlSU1PlyelSqRQA4Ofnh8mTJ+P777/H8uXLYWdnJz/WokULREdHo3nz5qXej8fjoVmzZujRo4fak96NjIxgY2NTZvK27PORI0ciKSkJvXv3xpo1a8Dn83Hx4kU4Ojri6tWrKCwsRHh4OHr06AEvLy8kJyerVW42ICJwue/NOzIyEkSE+Ph4HD16FN7e3vjuu+8wb948LUv5HgsLi08m+1clPbFtTwAwdOhQWFhYqF/4ClLt80pn5MiRMDIyUqvsHA4HLVq0+OQ5VcmePqQy+byqSnVAqSb279+PO3fu4H//+x++/fZbWFtbw9PTE7Nnz0ZOTg48PT0RFxcnN4CkpCQtS1ySTZs2oUOHDli+fDlyc3PB4/GQnp6OlJQUNG/eHBYWFvIq0Q8NuWnTpqhVq5Y2RS8X+v9K43fv3qGwsBBhYWHIzs6Gt7c3fvnlFxgaGkJPTw9Lly7F1q1bcerUKdy5cwdPnz6Fn59fsXvoGkQk/0EMCwtDUFAQHj9+DA8PD8ybNw+///473r17h5ycHGRlZWlZ2k9TlfRUle0JqPZ5lUFHVcmePqQq+bxKjXYGRnULtqdKsrKyqE6dOsV2ffgwSfro0aM0cOBA6tWrFz158oSOHDlClpaW9O+//6rcPhF7z5OXl0dHjhwhOzs7cnZ2pvT0dIqOjiZjY2N68+YNEZWcRrC3t5fvl6wr6yN+jGzKJysriyZOnEj29vbE4XBowYIFRPSfrkqT38PDg9zd3VnZ61wdUyUfynzu3Dlyc3Ojbt26UUBAAD148IAYhpHnR2VkZNDChQvpjz/+YK19Np9JV/TEFrpkT1XN5xGx80y6pCO20RV7UmdKVmX3eZUdPe2FslUTIoKZmRkGDRqE+Ph4+WdcLlfeixo9ejRq1KiBvXv3wsXFBYmJiVi2bBnq16+vXeE/wsjICGPGjEG3bt3g5eWFQYMGwdraGi4uLjA2NgZQfP24wMBAxMfH4+uvvy5xTJfg8Xh49uwZxo8fD7FYjIMHD2LXrl2Ii4uDWCyGvr4+gP/kZxgGXC4XCQkJ0NPTw7t372BqaqrNRygTmcyBgYHYt28fEhMTsXPnTvTo0UN+juz5EhMTUVhYiF9//RXp6elYtGiRVmQui6qmp6pqT9U+T/d1BFQ9e5JRlXxepUeb0ayuoI5k7p9//pns7OxKrKX4YW9q/fr1xOFw6LffflO53Q9h83lkvda3b9/Spk2biMPhyBO5P0ywLywsJEdHR1q2bJn8s8zMTIWLBdSNVCqlhQsXUtOmTWn48OGUlJREREQXLlwgU1PTMnvgDx48oIEDB1LPnj0pKChIfi9VUFfP9t9//yVHR0fq2rUrPXnyhIhKjjrIZH/8+DH179+fateuTffv31e5bbaeSZf0xCa6Yk9VzecRsfvuEWlfR2yiS/akDr9XFXxeVaA6h5Il4uLi8PTpU+Tl5QEABgwYACMjIxQVFcnPYRgGHA4HUqkUjx8/xvr16zF37lzMnz9fW2KXi2yUoVatWpg1axaWLVuG169fo6CgADweT55Pc/v2bUgkEowcORInTpyAs7MzGjRogICAAC0/QUnq1auHxYsX48iRI7CysgIA2NjYwMrKCleuXJGfR0SIjo7GtGnT0K9fP1haWuKPP/6Ai4sLgP9yqHSN+vXrY8mSJTh8+DDatGkjf+8+hMvlIjY2Fjt27EBhYSF++OEHdOrUSTsCl0FV1FNVsqdqn6f7OvqQqmhPMqqKz6v0aC2U1SFU7WG8fv2a7OzsyNDQkDp37kyOjo40fvx44nA4tGrVKoqPj5fn38i4evUqLVy4kA3xS6DOHtPRo0epTZs25O/vT0T/7Xnr5eVFHA6HatSoQebm5jR//nyKj49nvX11IOu5tmvXjlavXk1ERKGhoTRp0iRq2LAhjRw5Ur6eWVkokzuliZ5tUVFRqZ8/efKEJk+eTD179qStW7fKP9fF0QcZbOhJ05T3XmjLnqqazyNS/pl0VUfqRlV7UjZfVN1+ryr5vMpGdQ4lC3zxxRc4cuQIGIZBbGwsrly5gpo1awIAli5digMHDiA9PR2dO3dGrVq1YGNjgzVr1sDJyUnLkr9HKpXi0qVL8PHxwdq1a2FtbV3iHPr/XKhOnTqhVatWOHXqFMaNGwcej4eioiKYmppi4cKF8PDwqHS9PlmP++uvv0ZwcDA2bNiARYsWoW/fvjh16hQ6duwoP1eWV/QxHA4H27dvx7Bhw8pdPkSTyHKHsrKy5FWo4eHh+O233/Dy5UtMmTIF06ZNA1D2s+kKbOjp7du38PHxwdixY9W21E5qaioOHz6M169f49dffy31nMpuT5Xd5wFAdHQ0RCIR6tevj8mTJ8ttRUZl11F5qGpPUqkUJ0+ehJmZGfr161fu3tqaoir5vEqHlgNanYCNHkZpvTUvLy9as2YNPX78mE6ePElbtmyhsWPH0qxZs1QRt1wq8jyy7Qrnz59PNjY28p1rrl279smeJ8MwtHjxYrKwsKiy+yrfu3ePBg8eTDwej3r27Em//fZbmbtgEL3/TmJiYuTbCdrb29P27dvLzaXS1NaLERER1K5dO4qJiaGbN2/SmDFjyMnJiYRCofw8tvIMNdlbV1RPUqmUTpw4QTweT76zjI+PDyuLTefl5ZGPj4985x89PT1yd3cvc7REhrbsqar5PKKKPVNycjJt27aN7O3t5TvX/PLLL5+87+fg84gUtyciov79+xMAsrGxofnz59O9e/fKHbnUxNaLVdXn6TrVASWpp4iFiOiHH36gLl26lLsNFtt86nliY2Np9erV1Lp1awJAFhYWNGvWrArtXCM7fu/ePbp06VKxz6oi2dnZtH79erKzs5NP5X2KvLw88vPzoxEjRpCenh7xeDwaNmwYiUQiys3NLXG+Jh3RiBEjqG7dujRw4EDq378/HTt2TH6MzaIVbThXRfUk2/vawcFBHlRMmDDhk3tfl8aHe5MbGxsX25u8IoUZ2rSnqubziMp+ptzcXBKJROTi4iLvTIwcOZL8/PzK7Ux8bj6PSDF7YhiGbt26RbNmzSILCwsCQK1bt6Y1a9ZQXFxcqddoykdUZZ+nq1QHlKS+dbGCg4OpZcuWlJ+fT0Tq38tWxsfPk5aWRrt37yZHR0cCQEZGRsTn8ykoKKjcEZRq3hMXF0ePHz8mooo5o9TUVNq1axf16tWLAJCxsTEJBAIKCQmRBy2adkSjR48mDodDhw4dkn/GdgW0tp2ronqKjo6mlStXkq2tLQEgKysrmjt3Lt25c6fUwIFhGLpz5w7NmTOHrKysCADZ2dnRypUrKTo6mvXnURdVzecRFX8msVhMwcHBJBAI5MF+r169aNeuXeWOulXzH4rYU1FREQUFBRGfzycjIyMCQE5OTrR7925KS0uTn6dJH/E5+DxdojqgJPW9EJmZmWRtbU0hISGs3rc8ZM/z66+/0siRI0lfX594PB65uLiQUCgssayHutGlHr02ZImJiaFVq1ZRq1atCABZWlrS7Nmz6eDBgxp3RL1796ZOnTpRcnKyWr4LtmxJ03qSBYpz584tESjGxMQoHHiqW1ZVqWo+j4jo7t27BIDGjx9PlpaWBIBatWpFq1evptjYWI3L8zn7vZycHBIKhTR06FDi8Xikr69Prq6u5O/vT9evX9eo3yvP56n63VQHlP9RHVASOy/Ex70ehmGosLCQGjduTNu2bVNVxAohkUjo/PnzNHLkSAJAAKhHjx60bds2reb+xMbG0r1797TWvoyioiI6d+4cKzlzysAwDN29e5fmzZtH1tbWch1Nnz5do6Nb7du3L3P9NVXfEzZsKTMzky5duiSvptU0sqnssWPHkoGBgVxPBgYGNG7cOIWnxtmCYRiSSCR06dIlyszMVOle6gj8teHziIiioqJo+fLl1KhRIwJA9erVo3nz5lF4eLjWgrq8vDw6d+6cTswA3bt3TysBtYykpCT6/fffqUePHvIZMgC0a9cujY1gl+XzioqKKD09XaV7VweU/1EdUJLqL8TWrVvp1KlTpTqv3377Ta1LSZRWXNOwYUMCQMePH1dbu4rIN336dOJyuXTkyBGtySGRSGjcuHFkYGBAFy9e1JocH8qzc+dOAkA1a9ZUqJhHVWTv6cfvq1AopLp168qnuJRBVVvKyMigDh06UP369enly5dKy6EsHxfX8Hg86tSpE3Xu3FktxTyKEh8fT/Xr16eOHTuqFFSqqqdHjx7R999/T1KptMR7pG6fR1R6cc2IESMIAN2+fVutbVeECxcukIGBAXl4eGh02v9jAgICiMvl0rfffqsTI6YvXrygadOmyTtpihTzqEJZPi8lJYUsLS1VWmi/OqD8j+qAklR7If766y8CQEuWLCn1uLqM5FPFNbKpH115wSUSCXl4eJCBgQGdO3dO4+0zDEPffPMNcblcOnr0qMbbLwvZe3ft2jWFinnURWZmJnXs2JHq16+v9IiGKraUm5tLDg4OVK9ePfluF5qgosU1bBXzqMrjx4+pbt261KtXL6XfD1X0FBMTQzY2NtSpU6dS21eXzyuvuEbXftiPHj1KXC6Xpk2bppVg7uzZs6Svr0/jx4/XalD7MTI9HThwQKFiHnWxePFiAkD79u1T6npde++0SXVAScq/ELLe38yZMzXiMCpaXKOLL3hhYSG5uLiQkZER3bhxQ6Nt//TTTwSA9u/fr9F2y6M0PVWkmEedJCUlUcuWLalZs2YlFqauCMq+e+/evaPBgweTiYmJRkaYVC2u0XZO5e3bt8nExISGDBlChYWFCl+vrJ7evHlDzZo1o5YtW8q371MnihTX6KLf8/b2JgBqXdC9NK5fv05GRkY0bNgwnZh2/5CP9VTRYh51wTAMzZgxg7hcLgUEBCh8vS6+d9qiOqAk5V6IkJAQ0tfXJz6fr9a9gvPz88nf31+h4hpdfcHz8vLI2dmZateuTQ8ePNBIm+vWrSMAtGXLFo20pwjl6amsYp7bt2+rNWiJj4+nBg0aULt27RTOL1Lm3ZNIJPTll1+SoaGhfGkWdcF2IFheMY86CQ0NJUNDQxo7dqzCI1DK6Ck9PZ3atWtHDRo0UGs6AsMwFBYWRrNnz1aouEZX/d7mzZsJAK1bt04j7T148IBq165Nzs7OWssX/xSf0tOninlkKweoA6lUSl5eXqSvr09nz55V6Fpdfe+0QXVASYq/ELLe38iRI9XS+5MV10yePJlMTU0VLq6Jjo4mV1dXnVzG5O3bt9S5c2eytramqKgotba1Z88eAkBLly5VazvKUlE9lVbM07JlS1qxYoXadPz06VMyNzcne3t7hVYFUNSWGIahqVOnEo/Ho5MnTyor7ieRTVX37NlTPlU9ceJE1qeqVV2XUhkCAwOJx+PR1KlTFQqIFdVTTk4O2dvbk7m5OT19+lRZcT+JrLimZcuWBICsra0VKq7RZb+3ZMkSAkB79+5VaztRUVFkZWVFXbp0obdv36q1LWWpqJ4+LuYxNTWlyZMn0/nz59UyhV9UVEQjRowgIyMjun79eoWvqw4o/6M6oCTFXoiIiAiqVasW9enTh9UeE8MwdO/evRI71yxbtoxevHjBWju6QHJyMtna2lKTJk3o9evXamnD19eXOBwOzZo1SyeS0dlCIpHQuXPnaNKkSQrvzKMod+/eJVNTUxowYAC9e/euQtcoYksMw9APP/xAAIqtE8cGpe1cM3z4cPL19dXIqE1ubq68/Q+LedTR/qFDhwgALViwoMLvuiJ6KigooAEDBpCZmRnrP5opKSm0ffv2YsU1kyZNonPnzulU3p+qMAxDs2bNIg6HQ35+fmpp4/Xr19S4cWOys7NTe2Gfpnnx4gUtW7aMWrRoodZinvz8fOrTp49Cs2jVAeV/fPYBZe47MR25eIsMbGzpyMVblPuu7BGLFy9ekKWlJXXr1o2ysrJYaV+VnWsqMy9fvqSGDRtSu3btKCMjg9V7nz9/nvT09GjixIlqTUfQNoruzKMMV65coRo1atCoUaPKHc1TxJaIiFavXk0AaMeOHazI+uEIoSzYVvcIYUUorZiH7RHS7du3EwBas2ZNuecqoiexWEzu7u5Uo0YNunLlCiuyyoprhg0bpvDONZUZqVRKEyZMID09Pbpw4QKr905PT6e2bdtSo0aNKCEhgdV76xLK7MyjKFlZWdS1a1eysrIqdzBHUZ9X1eEQEeEzIyo5B6KwBFx6noKEjHx8+AVwADSqa4R+dpbg2zdCSytTAMDr16/h6OgIY2Nj/PPPPzA3N1e6/fT0dAQEBEAoFOL69eswMjLCqFGjwOfzMXDgQPnm9lWdzMxMEBHq1q3L+r3j4uLQqFEj8Hg81u+ti6SlpcnfqRs3bsDY2BijRo2CQCDAgAEDoKenp/S9z5w5A3d3dwgEAuzbtw9cLld+TBlbAoCdO3fi+++/x6pVq/DLL78oLRsRITw8HEKhEH5+fkhOToadnR34fD68vLzQvHlzpe+tDmJiYuDj4wOhUIgXL17AysoKnp6e4PP56Nq1KzgcjtL3XrVqFZYuXYpdu3bhu+++K3ZMGT0xDIOvvvoKIpEIgYGBGDZsmNKySSQSXLhwASKRCMePH0deXh569eoFgUCAsWPHquRPKxMSiQSvXr1C06ZNWb93RkYGOBwO6tSpw/q9dRGxWFzsncrPz4eTkxP4fD7Gjh2LevXqKX3vtLQ0ODs7o6CgANeuXUODBg3kx5T1eZ8Dn1VA+SojH4uPP8LV6DTwuBxImbIfXXbcuYU5fujzBTxHDir15aooBQUFOHXqFIRCIUJCQsAwDAYPHgw+nw83NzeYmJio8mjVfAQRqfTjXJmJjY2Fj48PRCIRnj17BktLS4wfPx4CgQDdunVT6nvx9fUFn8/HnDlzsHnzZrzOLFDKltaOao9/go9DIBBg/vz52LRpk1LyqDMw0wSyQFgkEsHX17dYIMzn89GsWTOl7vnDDz9g69atEAqF8PLyUtrnrXFvh82r/odt27ZBJBLB09NTKXnu3LkDkUgEPz8/pKSkoFWrVhAIBPDy8lJLUFUZ+Jx9k7rIzc1FYGAghEIhzp8/Dy6XCxcXF/D5fIwcORI1a9ZU+J4fDyIVcI2U9nkN6xqp8niVhs8moPS7k4BlJ59AwtAnX4SP4XEAqUQM8U0RLnuvRcuWLSt8rVQqxaVLlyASiXD06FHk5OSgR48eEAgE8PDwgKWlpTKPUk01FYKIcO/ePXnQkpSUhJYtW0IgEIDP5ys8erd7927MmDEDXkt24C41U9yWuBxwwSA5aCfGdqmPv/76S6Ef1tTUVBw+fBgikQg3b96EiYkJRo8eDT6fj/79+6s0CqtNJBIJQkNDIRQKcezYMeTl5cHBwQF8Ph/jxo2DhYVFhe9FRJg6dSoOHjyIn/acwNGXPKX0BEaKlKAd2PjdKHz77bcKPU90dDREIhFEIhGioqJgbW0NT09PCAQCdO7cuTqYqkatJCcnw9/fHyKRCLdv34apqSnGjBkDgUCAvn37KjRrFRUVBScnJ1j0dIO4wyilbEmPy8EK17YY372RMo9TqfgsAsodl6Kw6dwLpa+X9SgXDLbF9/0+HVASESIiIiAUCuHr64vExES0aNFCPvKgSEBazX/s378fw4cPrw7ClUQqlSI0NFTeucnNzUXPnj3B5/Ph4eFR4aDly2V/4W6RDd5vdKF4YCCzpfkDW2L2ANtyz8/Pz0dgYCBEIhHOnj0LABgyZAgEAgFcXV1hZFS1ev55eXk4efIkRCIRQkJCwOFwFH5eiUSC3t+txRvzrkrLoYjPA94H+/7+/hAKhQgLC4OJiQnGjBkjD/Y/l9QTtqn2e6oRFRUl79xER0ejfv368pmMTp06Vahz8z+fqxA9ygaIABU6QxW1pcpMpQ0oN2zYAG9vb0RGRhbL6foYvzsJWHTsEWvtrh/dHh6l9DQOHDiA6dOno3HjxoiKioKFhYV8mrF79+7VvXIVcXd3h7W1Nfbs2aNtUSo9+fn5xdIviAgtWrRAdnY2nj9/DlPT0vN+NGVLEokE+/fvx/Tp01GjRg0UFBQoPWJXmSltRNbW1hYpKSmIiYmBgYFBqddpSk95eXnYuXMnFi1aBA6HU2KasaoF+9qg2u+xAxHh9u3b8vSL1NRUWFpagmEYhIWFlZlioilbAoDIyEh06NABERERaNeuHWttapJKGVBmZ2ejadOm2LRpE6ZMmVLs2MmTJ7F8+XJERkainrkF3jXrDRMHD3C4yvWQC+LuIe/pVRS9eQ5x+mvomZkjNjYODesalSiu4XA4sLOzw+bNmz+r4hp1QkR4+/YtevTogUWLFmHq1KnaFqlKkZaWhoMHD2LhwoWQSCTFinnS09MRFBSEsLAwREdHo2aj9rD0+lWl9grfPEfuo4soevMcRanxACMFvV9tokRxjYmJCRo2bIhTp07pXHGNpomJiYG3tzfWrVsHhmHkOaPDhw/HvXv3cPr0aTx9+hRFRWIUmVrDpJsbjFv3Vrq9svRUWnFNnTp10KhRI1y4cOGzKa5RN9V+T32IxWKcPHkSXl5eAICioiJ5MU9ERARu376N+Ph4FLx7B8bIHDVbOcHMfjS4BornYQJl21JpuLm5gcfj4dixY8o+nlYpe2hPh/H29oZEIimRKB4cHAx3d3fUrl0b27dvh6mdAzKu+SHjvPK9u7wnV5AfeQVcQ2PwTN5XI3+15zxcXV1hY2OD77//HmZmZhAKhdi8eTMSEhLg5ORUHUyyBIfDQU5ODrKysuTpApWwD6SzmJubg8vlwsjICJGRkVi0aBHu3r2LoUOHYvLkyTh8+DBq1aoFAyMzsPGtF8TcRe6DcwCHA/3a1gDeVye3atUK3bt3h5+fHzw9PXHnzh34+/vj6dOnLLRa+WnevDksLCxgYmKCa9euwdPTE76+vhg0aBAWLlyI1NRUfPvtt7Ab8Q2gZ4i0wA14e1WkdHul6WnOnDn44osv4OLigrt37+Lnn39GbGwsRCIRHjx4gKysLLYe97On2u+pD319fbx69Qo1atTAv//+C6FQCBMTE3z//ff4448/8PbtW7i5uaH9l7NRo3F7ZN06gpTDy0DEKNVeabZUFt9++y2OHz+OmJgYpdrSNpUyoNy/fz9cXV1Ro0aNYp8vWLAAHTp0wLlz59DXdTze9ZgEM4exyL0fAnH6K6Xaqt1nIhrOOwzrCRthYNkUREBUjh7+zZHit99+w5s3bxAUFCRfpqSwsBABAQFsPGaF2bVrFwYOHIhx48bh4sWLxY6lpaUpVTGqCzDMewO+fv06bGxs0Lv3+xEXDocjP1aZ0FU9yeypdevW+OWXXxAZGYm7d+9i0qRJqFu3Lh7Gp4CMarPyg2baZRgazvOHzeStqNGkEwDgtz+F6NmzJ86ePYvXr19jy5Yt6NatGwYNGoQ6derg77//VrndT3H58mVwOJwy//r16wcAmD17Nrp27QpDQ0N06tRJrTKVhkxPjo6O2LJlC16/fo2///4bo0aNwqtXr7B+999IadQXluPXoEbjDsi6dQRM0Tul2ipNTwFnr4LP5yM8PByRkZH43//+h6ZNm2LgwIEa0dOH6KotsUFV8nu6qieZLZmbm4PP5yM4OBj//vsvtm7dCgsLC4hOXUTKF86oM3gG6vSegMLXkSh6o1wdRmm2FJ2SU+q52rAlNql0AWVcXBwePnyIgQMHFvs8MjISkZGRmDZtGvT09CAKSwCPy4Fp52EACHnPrivVnp5pPXB4xatHeRxg5LwNmDVrVrFkaUtLS3To0AGBgYFKtaUM27Ztw48//ohWrVrB0NAQw4YNw6+//jctKZVK8fLlS43JwxZEJM+NjYyMBBEhPj4eR48ehbe3N2bMmIEFCxZoWcqKo6t6Ks2eOBwOunbtij///BP//vsvBCv2stYez7gOuPqGxT6budUff//9NwYPHlysUltfXx99+/ZVuz316tULiYmJJf727t0LDoeDGTNmyM/96quv4OHhoVZ5SqM0Penp6WHixIk4duwYkpOTMWbRVoAYcDgc1GzpAEjFkLxNUqq90vT09fq/sXnzZnTp0qVYTrim9CRDV22JDaqS39NVPZUVQ1hZWWH27NkICwvDjC2+4Pz/nAyvlhUAgCnMU6q90mxJeCuh1HM1bUtsU+nW2bhx4wYAoEuXLsU+v3//PgCgW7duAIBLz1MgZQh6pvXAMzWHODmWNRmkBFx6kYLlaFviWNeuXXHixAnW2iqPvXv34s8//5Tng3z33Xdwd3dHQUEBVq5cqTE52OTDddrCwsIQFBSEx48fw8PDA4mJiahTpw66d++OhIQEREdHo0WLFlqWuHx0VU9l2ZMMHo+HmPwapR5ji2uxmWUe69q1KwIDA5GdnQ0zMzO1tG9gYABr6+JTUU+fPsWCBQuwePFijB07FsD7H0jgfbHMw4cP1SJLWZSnJ2NjY7yhOgAnHwAgzXv/nXKN2PvOrkSllXlME3qSoau2pCpVze/pqp7KsyWJRILbMakQ52RDnPYSb68eAsegJgxsyl+VoqKUFT8AmrUltql0AeWzZ88AoMSiuImJiQAAGxsb5BZKkJCRLz/GM6kDSW46q3IkpOcjr1ACY8PiX2GzZs2QlpaGlJQUjSz1EBcXh169esn/3atXL4SGhmLgwIEQi8WYO3eu2mVgkw+d6vnz57Fz505wuVwcPnwYtra2aN++PQoLC1GjRg1ERUVh/fr1aNiwIZYuXaplyT+NruqpLHuS8bEtqYOybAl4b08Mw+DZs2fo0aOHWuWQIcuh6tu3L1atWqWRNstDET1JC3KQ++AcDBu0hZ4Je7tQ6YqedNWWVKEq+j1d1VN5tvTPjVu4uWKU/N96dRvAcswS8Gqyt+uNrtgS21S6gDI9PR16enoldpYpKCgAABgaGuJlel7x7ZB4BmCK2P1RJAAh18PRtHbx4pucnPe5Ef/88w+r+SEWFhZo0KBBieWHzM3N8erVKzRp0kT+Wbt27RAaGor+/fvjzZs3Fbp/dHQ0srOzWZO3NJo2bYratWt/cgkl2bHAwEDs27cPiYmJ2LlzZzHDkhU81alTB87Ozli6dCmKioqwevXqT7YfFRUl14+6aNKkCerUqaM2PT148ABSqZQ1eZ89ewYej4cXL0rPD4p7K2alGOdTlGVLwHt7B4Bbt26pvHA5l8stN/eRYRh4eXm9T5sRiVRe7isiIoKVvLeK6omIQdqpTWAKc1F30HSV2/0QTelJBo/HQ8eOHUt8zoYtEREyMzMRHx/PiqxlYWRkBDs7u3LfI3X5vaysLLUXeJiZmZU6WsqWnl6/fo3U1FTW5C3Plv7NKoLl+NWgonco/Pcp3sVHgBErl4tcFgQgPj0PbevXKnFMtnVmWlrZMwK6SqULKMtCtrVSYWEhiqi4wyNpETh6pa/ZpgpegokoSiz9pZRNk7HFrFmzsGXLlhILBDs5OeHYsWNwdnYu9nmbNm1w8eJFeUFBecyePRvBwcGsyfsxenp6eP36dYXOffPmDTZu3Ih3797h4MGDaNOmjbwHT0Ty78Dc3BwTJ06Era0tXF1d0aFDB4wbN67M+86ePRshISGsPE9ZCIVCeHh4lPhRZUtP/fv3R0ZGBmvyyujatfRFsA1sbGEzaTPr7X3Mp2wJeF9hrCrGxsbIzc395DmLFy/GzZs35TtsqIqTkxPy8pTLvSqN8vSUcX4v3sWGo96I+TCwYr/gQRN6klG3bl15oPohbNiSVCpFcHAwBAIBa/KWxm+//QZbW9sKdUzY9ntEhEuXLmHUqFEljrGJi4sLgoKCSnzOhp4YhsHGjRuxfft21uSVURGfZ2TbE3lPLiP16GrYTN7Kqk0VSUrvaMqKHyvj2tWVLqCsV68eJBIJcnJyijl8GxsbAO+nvo0b2BW7RpqbCUMW8x9k+AgPluite3t7Y+fOnbhw4YK8p8EGFhYWpS7gvmjRIoSHh5d6Tdu2bXHp0iUcPXq03Ptv27ZNrSOUXC4XVlZWFTq3fv36WLJkCVq2bCkf5ZUZl+y/+/btw+TJk8Hj8dCzZ0+4urri6tWrGDduXJl75W7fvl3to7BNmjQpdVcQtvQUGhrK6gjlrl27sG/fPvzzzz8wNjYucTzurRg/nFd/T7k0WwLeLwX2yy+/4ODBg2jbtvSco4ryqQ0QAMDPzw+bNm3CmTNnWNvR6tq1a6yMUFZET1OXbUPuvTOo3XcyTNr1V7nN0tCEnmSUtbsOG7bE4/Hg4uJS5n3YolmzZuW+dzLU4fd69+6t9mcsK8+PDT1xuVz8+OOPmDx5sqpiylHU5xnZ9QJOb0be039YDSgN9Ep/LzIz3+c/V8Y1XStdQNmqVSsA7/MzOnToIP9cNpV19+5dTOrYBRy8H1aW5KRDmpMG/U5DWJWDA2CoY9cSORC7d++Gubk5BgwYwGp7ZTFv3jzMnDmzzONWVlY4cOBAubk2upbgPWRIcX1lZGSgbt33+WBisRhBQUHYu3cvbt++jefPnyM2Nlb+Q1ZWz06bz8iWnkqbAlSFfv36Yd++fahVq1Yxe5JhVyjBgvNnWW3zY8qyJeB9oMLlcuHq6opatUpOD7FFREQEpk6dinXr1pV491SBreWFytPT5d+3IeuaD0y7uaFWzy9ZafNjdEFPADu2xOFwULduXblP0RXY9Hvafka29NSwYUM0bNiQNbkq6vNkqT4kEQPEgClkL22OA6BJvZLBLPA+tuFyubC1ZX8QTN1UumWDHBwcALwPHD+kbdu2aNWqFf744w/U0OOgUd33237l3g8CwIGxnROrctTiFSH3bcnpmPDwcLmMmuDSpUsYN24cli1bVurxyryEhoywsDD4+/vLpyv19fWxe/duZGZmwt7eHq6ursjIyNDo964ouqqnsuyJiHD37l38b+ECSLNT1CqDoTgH1y5fhEQiKXEsPDwcbdu2VWuQkpaWBnd3d/Tt2xcCgQBJSUnF/mT5W9HR0YiIiEBSUhIKCgoQERGBiIgIFBUVqU02GWXpSSKR4Oeff8aCeXNh1NIedQZ8rTYZjJh8PH0UUep6pJrQkwxdtSW2qex+T1f1VJYtvX37Fq9fv8Zfe3aCk/9fWlHug/cdakNr9gYkGtUzKrVjBmjWltim0o1QNmvWDO3atcOFCxfw1VdfFTu2ceNGuLq6YvDgwTBr3RuZYfeQHX4aJh0HQ9/8vx6O5G0y/t0zFcbtBsB8xLxPtleUEof8qDAAgDgzEVSYh7fXfZGS+AL1fw3HoEGDwOfzMWrUKOTn5+Phw4ef7JWpg927d2PBggV4+PAhhEJhqcP4lZn09HR4e3ujZ8+e6Ny5M4D3a3727dsXHA4H33zzDQoLC+HkxG6ngW10UU8f21NMTAx8fHwgFArx4sULGBsbw7JTf0jzs8GIC/H2uh8AoEbDdqjR6L/9Zl+uGwHDhu1gzV/3yfYkWSnIfRwKAChMigYApITswtDfrsLU1BRTpkyBQCBAt27dIJFIcOXKlWLrQKqDM2fO4OXLl3j58qU8deZDGjdujPj4eHz99de4cuWK/HPZuxgXF1es8EAdfKinKVOm4M6dOxCJRDh06BAyMzPB4/HQvFVbJEVeBvNBvGfYoHWx3TlU0dOrk1vQfcNNWFtbY8aMGeDz+WjWrBnEYrFG9PQhumhLbFMV/J4u6uljn5ebm4vjx49j8+bNiIiIAJfLRYNersg1tMC710+Q//wmDKxbwrhd8ZxPVWyJF3Ecq1dfR+PGjTFhwgT5udqwJTaplHt5b9myBUuXLkVKSoq8GEfGiRMnsGLFCkQ+fQqpgSlM2g9ALUfPYouTF6XGI3Hf9zDr+SXq9J38ybZyH15AetDWUo/17NkT+vr6uHr1KoyMjNCmTRs8evQIb9680dg0A5fLRVJSEtLT0+Hm5gZDQ0MEBgbKc3CSk5NRv359VvPutIFAIMCjR48QEhIi/9GfPHky6tWrh99++01+Xln5k9pGl/W0atUqrFmzBh07dsTt27dhYmKC0aNHg2EYCIXCUq+p5eiJ2s58AABTVIBXm8fCqHVvWLj99Mm23r18iGTfxaUea9CgASQSCZKSktCyZUvY29tDKBQiKipK51IytMH//vc/bNq0CQ0bNkRMTAysra3lO4OVRb1hc2HS4f0CzmzpycrKCrm5ucjLy4ODgwM6d+6MXbt2aUxPumxLbFOZ/Z4u62nTpk1YunQpRowYgdOnT6OgoADdunWDnp7e+5mJ5GQUiqXQq20NIztHmNmPAdfgv/V42bKlPn364PLly/J/h4SEwMXFpdL6vEoZUGZlZaFZs2bYsGEDpk6dWuZ5E/aF4UZsOqRM8UfMuXcGmZf244tv/wTPWLHCGR6Xg17N6uHQVHv5Z/Hx8fD19cXKlSvx7t07mJubY/z48eDz+bC3t1erocuM1tLSEllZWfD09JRPlQwcOLBKOdcRI0bg7du3aNKkCYgIvr6+8Pf3Z72iXh3omp7y8/MRGBgIkUiEkJAQSKVStG/fHosXL4arqyuMjIyKnV+WLQFAQcwdpASshM1X22Fg2aTCMpRmS1KpFKGhoRCJRBAKhZBKpbC3t4dAIICHhwcsLCyUfubKSGpqKvz9/SEUChEW9n6mpFevXli+fDn69+9fonBFU3rKy8vDyZMnIRKJcObMGXA4HAwbNgwCgaDU94dNdM2W1E1l9Xu6piciQlhYGIRCIXx9fZGRkQEbGxvMmjULXl5eaNy4cbHzNWVLH+Lu7g4Oh4Pjx48r9Gy6QqXLoQSAWrVq4aeffsLGjRs/WUG5dlR76HFLBnPvXj6EabeRCgeTAKDH5WDtqPbFPmvSpAk6d+4MHo+HixcvYvLkyTh27BgcHBzQsmVLLFu2rMw1r9ikVq1aOHPmDL755hsMGzYMW7ZsUXubmuT06dP48ssvoa+vj5SUFPj4+Oi8Uy0NbelJIpHg3LlzmDhxIqysrODl5YWMjAz8/vvv+OWXX1BUVIRx48aVGgyUZUsA8O7lIxi16a2QYwVKtyUej4dBgwZh4cKFAN6nsVhYWGDevHmwsbHB8OHD4ePjw+pSPLpGXl4efHx8MHz4cNjY2GDevHmwtLSEn58fVq5cifT0dAwYMKDUKmhN6cnY2Bienp7YuHEjeDwefv75Z2RkZMDT0xNWVlaYNGkSzp07V2peLJtUdZ8HVA2/p009vXjxAsuWLUPLli3h4OCA48eP46uvvsLs2bNhZmaGhQsXlggmAc3ZkoynT5/i9OnTOrOZgjJUyhFKRfC7k4BFxx6xdr/1o9vDo3ujcs+TSqW4cuUKhEIhjh49iuzsbHTv3h18Ph/jx4+v8BI65cHj8ZCYmFhiVx4/Pz98/fXX6NevH4KCgqpMb11GQUFBiXQHXUZbeiIihIeHQygUws/PD8nJybCzswOfz4eXlxeaN29e4XttORmG32+yt4RQRW0JeF84ExAQAKFQiBs3bsDY2BijRo2CQCDAgAEDWFtMW1tIJBJcuHABIpEIx48fR15eHnr16gWBQICxY8cqtISItnwegBI5uFZWVvD09ASfz0fXrl1Zma35XH0eULn8njb1lJycDD8/PwiFQty9exdmZmb48ssvwefz0adPnzKXpPoY0a04/C8wkjW5FLGlykiVDygBYMelKGw6p/oIYaO3Ebi88+cKrysmo6CgAGfOnIFQKERQUBAYhsHAgQPlxTwf7/qjCB9OK3xMREQE3N3d8erVqyrnXHUxZ+hTaFpPbP+wx8fHw8nJCcY9RqPQTvVldX4cbIeZ/ZTLEYqNjYWPjw9EIhGePXsGS0tLjB8/Xl7MU1neCyKSF9f4+fkhJSUFrVq1gkAggJeXV5lbw1UEtnwec/8Eru79pdQRnE8h68iIRCL4+voW68jIinmU5XP1eUDl8nua1pOsuEYkEuH8+fPg8XgYPnw4+Hw+hg8frnAgLpVKMWHCBJx9BZg68VWWTxWfV1n4LAJK4H2vfdnJJ5AwVGpORFnwuBzocTlw+6IQv80cg+nTp2Pnzp1KG3VGRgYCAgIgEonkxTxubm4QCAQYNGiQfHutinLlyhU4OjqWOUKTnp6OM2fOYOLEiUrJq05kzlEsFkNPT48VRymRSMDhcCrcA9UUmtBTamoqDh8+DKFQiFu3bsmLa/h8Pvr376/0KF5SUhKcnZ1BRLh27RouvypSyZZWurZlpZdORLh//748J0pWzCMQCMDn8xUafdUk0dHREIlEEIlEiIqKgrW1NTw9PSEQCNC5c2fWAgZVfd78Pg2w8dtR4HA4uHbtmtKzKhKJBKGhoRAKhTh+/Dhyc3Ph4OAAPp+PcePGKZwXW5l9ngxZEMWGn2IYBlKpFPr6+joVcGpCT2KxGOfOnYNIJMKJEydQUFAAZ2dnCAQCfPnll0oXxxIRZsyYgT/++AMBAQEoathNJ3yervPZBJQA8CojH4uPP8LV6DTwuJxPvhiy484tzLF2VHs0rGsEb29vTJ06FYsXL8aaNWtUlufly5fyUaTIyEiYm5vDw8MDAoFA7cU82kbW+3v79i22b9/O2o8/EeHIkSNYunQpVq9ejTFjxrByX13lw+Kas2ffr5c2ZMgQ1oojMjMz0bdvX6SlpeH69evy5XFUtSW2+bCY5+jRo8jNzdWpYp6UlBT4+/tDJBIhLCwMJiYmGDNmDAQCAfr166e2DpCqeoqLi4OTkxMsLCxw+fJl1K5dWyV58vPzcfLkSQiFwmLvK5/Ph5ubm1qLeXSBI0eOYMmSJVi1ahXGjBnDmo+PiYnBrFmzUKdOHRw8eFDnOtRs8mFxjb+/P9LS0tCmTRv5yL6io+mlsXjxYvz666/w9vbGlClTAOiez9NFPquAUkZUcg5EYQm49CIFCen5+PAL4OD9oqP9bC0h6NkILSyL7+e7efNm/PDDD9i4cSMWLFjAijxEhAcPHkAkEsHHxwdv3rxB8+bN5dNDiq6YT0RgGAZcLlcng1Iiwrfffou//voLAQEBGD16NKv3l0ql4PP5OH78OE6fPo1Bgwaxen+2UFZPH474HDt2TL58i7IjPmWRl5eHQYMG4cWLF/jnn3/Qpk2bEueoYkvqIj8/H6dOnYJQKERISAiIqFjQoqm18PLy8hAYGAihUIhz586Bw+HAxcUFfD4fI0eO1GjwpIqenjx5gt69e6NVq1Y4d+4ca9+fbERdJBLh5s2bMDExkefFKjOirut+7/z58xg+fDjGjBkDoVDIetB37NgxjB07Ft988w12796tk98BoLyeXrx4IR/Zj4mJQf369eHl5QU+n4+OHTuy9rwbN27ETz/9hM2bN2PevJLrVOuiz9MZ6DMn952YHv/7lu69zKDH/76l3Hficq/55ZdfCAD9+eefrMsjkUjo4sWLNGXKFDIzMyMA1L17d9q6dSslJSVV6B4ZGRnk7+9PGRkZrMvHBgsXLiQAtH//frW1UVhYSC4uLmRsbEw3b95UWzuqoIieGIahO3fu0Jw5c8jKyooAkJ2dHa1cuZKio6NZl+3du3c0ePBgMjExodu3b1foGmVsSd2kpqbSrl27qFevXgSAjI2NSSAQUEhICInF7MsnFospODiYBAIBGRsbEwDq1asX7dq1i1JTU1lvTxmU0dPt27fJxMSEhgwZQoWFhazLFB0dTStXriRbW1sCQFZWVjR37ly6c+cOMQxToXvost+7ceMGGRkZ0bBhw6ioqEht7Xh7exMAWrRokdraUBVF9JSUlERbt26lbt26EQAyMzOjr776ii5evEgSiYR12f744w8CQEuWLKnQ+bro87TJZx9QKgPDMPT9998Th8Ohw4cPq62d/Px8CggIIDc3N9LX1ycej0dDhgyhgwcPUk5OTpnXhYeHEwAKDw9Xm2zKsm7dOgJAW7ZsUXtbeXl55OzsTLVr16aHDx+qvT1FqYie2PihVRSJREJffvklGRoa0qVLl9TShjaIiYmhVatWUatWrQgAWVpa0uzZs+n27dsqfZcMw1BYWBjNnj2bLC0tCQC1atWKVq9eTbGxsSw+gXYJDQ0lQ0NDGjt2rFp+zIn+6zjNnTu3RMcpJibmk9fqqt978OAB1a5dm5ydnSkvL0/t7W3evJkA0Pr169XeljKUp6ecnBw6ePAgDRkyhLhcLunr65O7uzsFBARQfn6+2uTy9/cnDodDs2bNUptvrepUB5RKIpVKSSAQkL6+PgUHB6u9vfT0dNqzZw85OzsTADIyMiJPT086c+ZMiR6vrjrWPXv2EABaunSpxtp8+/Ytde7cmaytrSkqKkpj7VaEsvSUkpJCO3bsoJ49exIAMjExoYkTJ9LZs2fVMqr2IQzD0NSpU4nH49HJkyfV2pa2YBiGwsPDad68eWRtbU0AqGXLlrRixQqFRnujoqJo+fLl1LJlSwJA1tbWNG/ePAoPD6+yP0iBgYHE4/Fo6tSpan9GsVhMZ8+epQkTJpCJiQkBIAcHB9qxYwelpKSUOF8X/V5UVBRZWVlRly5d6O3btxprd8mSJQSA9u7dq7E2K0ppeioqKqLTp0+Tp6cn1axZkwCQs7Mz7d27l9LT09UuU3BwMOnr69OECRNIKpWqvb2qSnVAqQJFRUU0cuRIqlmzJl27dk1j7cbHx9PatWupTZs2BIDMzc1p5syZdPPmTfmPpa45Vl9fX631/pKTk8nW1paaNGlCr1+/1mjbn+JDPeXl5ZGPjw8NHz6c9PT0SE9Pj0aMGEG+vr4aGdUgeh9o/fDDDwSADh06pJE2tY1EIqFz587RpEmT5EGLvb09bd++vdSgJTk5mbZt20b29vYEgExNTWnSpEl0/vx5tY3a6RqHDh0iALRgwQKN2XJeXh75+voWs4/hw4eTj4+P3D50ze+9fv2aGjduTHZ2dqW+S+qEYRiaNWsWcTgc8vPz02jb5SHT0927d+nmzZs0c+ZMMjc3JwDUtm1b+vXXXyk+Pl5j8ly9epVq1qxJrq6uak1H+ByoDihVpKCggPr27Uu1atWqcI4jWzAMQ/fv36cFCxZQ/fr1CQA1b96cvvnmG51yrGfOnCE9PT2aOHGi1np/L1++pIYNG1KbNm0oLS1NKzJ8TFhYGAGgYcOGyfPtHBwcaOfOnVrJt8vMzKQmTZrQjh07NN62LpCXl0d+fn40YsQI0tPTIx6PR8OGDSNvb2/at28fubi4EI/HIz09PRo5ciT5+flpLNjXNbZv304A6O+//9Z427IRfAcHB/kI/oQJE2jHjh064/dSU1OpdevW1KhRI0pISNCKDFKplCZMmEB6enoUFBSkFRlK4+jRowSAGjRoQACofv36tGDBAoqIiND4YAPDMDRt2jTq168fFRQUaLTtqkh1QMkC2dnZFBAQoFUZPizmkQUnbdq0UaiYRx0UFBTQ6tWr6bvvvlP7dG15PH/+nMaOHUtnzpzR2pQkwzB0+/ZtmjNnDtWtW5cAUOPGjdVWXKMIRUVFlJubq1UZdIXExMRiIycAyMLCgmbOnEmJiYnaFk8nEIlEVFBQoNUpwo9zjAGQp6enWnOMy4NhGDp9+jSNHTuWnj9/rhUZZBQVFdG3335La9as0WrAlJiYWKy4BgC5urqqrbimosje3epgkh2qA0qWqIjz8vb2puTkZLXLcv36dQJAffr0IX19feJyuRUq5lEHDMPo3FSgNqY1oqOjacWKFcWKa7y8vORTP7pCVc39qwhlFdfMnz+f5s+fz3oxT2WHYZhyg0lN+TyGYeRT8fXq1SMAZGtrW6FiHnWga1OnEolE4++qrLhm8ODBxYpr1q9frzMjydWwS3VAqUHc3Nxo+vTpam/nw1wiRYp5yqM6WVkxyiuu0XTOl64F9rpCRYtr2CrmkfE52JOmfB7Rf34vLCxMoWKe8vgc9MQWFSmu0aTfq/Z5mqU6oNQADMNQRkYGtWjRgv766y+1t1eWwZZXzFMe27dvp/Hjx2tkxEFXUHTNPUWKazTlWA8cOCD//6rqYBXVk6rFNYoW85RGVbYnTfs8otLtqSLFPOVRlfVUGoraEsMwChXXaMLvfQ4+TxepDig1xMuXL8nCwoKuXLlCROqdWizPYMsq5lm9evUne+MpKSlkZGREN27cICLFHU9lQSwW019//UXOzs40YsQIWrFixSd/TBiGoYsXL9KECRMUKq7RhGOdMGECcTgcmjx5slxfVcXBKqonqVRKIpGI9eKasop57t69+0k7r+r2pEmfR1S+PZVVzPPmzZvPWk9EitsS0ftFx5csWULNmzdXqLhG3X6vKvs8XYdboe10qlEahmEAANevX4eNjQ169+4NAOBwOCAt7XrJ4XDQqVMnbNy4EQkJCbh48SJ69+6NhIQEcLllvxI1atRAx44dcePGDQCAgYEBXr9+jT59+mD79u0oLCzU1COohStXriA8PBxDhw7Ftm3bMGjQIAwaNAibNm3Czz//jLS0tFKvIyIEBATg9u3bWLhwIaKjo3Hjxg3MmDED5ubmGn6K/9ixYwfu37+P2bNnIzIyEl5eXsjOzgaPx4NUKtWaXKqirJ64XC42bdqErKwsbN++HYmJiTh58iQ8PDxU2gbRyMgIHh4eOHXqFBITE7F9+3a8ffsWPB7vkzZeVe1JF30eAFhYWGDmzJm4ceMGoqOj8dNPP+Hx48eoU6fOJ7ftq6p6ApS3JalUitjYWPz+++/o06cPLl68iISEBGzcuJHVbRAVpar6vMqCYpulVqMQRCQP0CIjI0FEiI+PR3h4OLKysnD79m3UrFkTW7Zs0ZqMPB4P/fv3R//+/SGVSuV7rH6MVCqFqakp2rZti2vXruGHH37A/v37sW7dOlhYWKBDhw64ceMGjh49CnNzc3h6esLOzk4LT1QxiKiY0xOJRJg9eza+//57tG3bFjNmzJDLX6dOHezcuRMPHz5E//79S73fxo0bYWxsrFP752ZmZmLQoEH46aefcO7cOezevRuenp7w9vaGlZVVmbrWJdjUk1QqxaVLl1CrVi21yWtubo7vvvsO33333SfPq2r2JKMy+DwAaN68OZYsWYJffvnlkzZblfTEpi3xeDw4ODggOTkZNWrU0NgzlEdV8HmVGi2NjFZ5Phzyv3XrFnXp0oU4HA716NGDGjZsSB06dKBJkybR1KlTWd9BQZ1TCoGBgdSzZ09ydnam5s2b04oVK+jdu3ckFotpxYoV9PXXX9OIESPIzMyMPD09tbpkUVl8mOMmmwoZMWIEzZ8/n1JSUuR7zMqO3bhxg+rVq8f6Yrvq0pO3tzfdvn2bpFKpfNmSoqIi8vHxIWdnZ+rXr1+xLQF1dRkcXdGTOqkK9iRDmz6PqNrvfQpdsiV16Kmq+LzKTnVAqQY+dKznzp0jNzc36tatGwUEBNCDBw+IYRh69+4dERFlZGTQwoUL6Y8//mCtfbYNVvY8BQUFdPjwYeJwONSxY0e6cuVKiZxL2TqGz58/p06dOtHWrVuL3UPbbNy4kaytrWnZsmXyJZTS0tKoR48etHPnzmLnymT+66+/qFu3bpSZmcmqLOrQU1ZWFtWpU4d2794t//xDHR09epQGDhxIvXr1oidPntCRI0fI0tKS/v33X1ZkYAtd0hPbVCV7kqFtn0dU7ffKQtdsiU09VSWfVxWoDijVyIkTJ2jkyJHUrVs3CgsLK3ZM9sI/efKE5s6dS02bNqVff/2VlXbZNFhZjzUrK4smTpxI9vb2xOFwaMGCBUT033OU5jg9PDzI3d2dsrOzVZaDLfLy8ujIkSNkZ2dHzs7OlJ6eTtHR0WRsbExv3rwhopLPYm9vT6tWrSr1mCqw/QMo08W4ceNo4cKFRPSfvB/KfebMGXJ1daVGjRqRvr4+rV69mpX22USX9MQmVc2ePkZbPo+o2u+Vha7ZEpt6qko+rypQnUygJt68eYONGzfizZs3+Pvvv9GjR49iCelcLhcMw6BNmzb4+uuv0bRpU6xfvx4RERHaE7oUeDwenj17ht69e+Pu3bvYuXMnpkyZgri4OIjFYnk+iiw3R5aQn5CQAD09PRARTE1NtSb/xxgZGWHMmDE4e/YspFIpBg0ahNmzZ8PFxQXGxsYAUCzPKDAwEPHx8fj6669LHNM1ZLI1b94cJ06cQG5urvyzDwsihg0bBkdHR7x69Qrr1q3D//73P63JXBZVVU9VzZ4+pKr4PKBq6amq2hJQtXxelUCLwWyVJyQkRL5LQ1nL8cTExNC3335Ljo6O8h6hqrDVA5RKpbRw4UJq2rQpDR8+XJ4XdOHCBTI1NS2zB/7gwQMaOHAg9ezZU76HrC4tDiyT5e3bt7Rp0ybicDjk7u5ORMWXlygsLCRHR0datmyZ/LPMzEylFkcuDbb0FBsbS5GRkfLprAsXLlDnzp3lCwkT/ffMEomEHj16RHXr1qV58+ap1K660RU9sUVVtacP0ZbPI6r2e59Cl2yJDT1VVZ9X2akOKDVAWTvSPHnyhCZPnkw9e/aU59wQqe6E2HSsGzZsoD///LPYXqdPnjyhFi1a0KlTp+SfMQxDUVFR9M0331DdunXJy8uLHj58qFL76kQ2HVJYWEjLly+nbt26UX5+frFjV69eJXt7e7p79y4dP36cnJycyNjYuETekbKwoafXr1+TnZ0dGRoaUufOncnR0ZHGjx9PHA6HVq1aRfHx8fJpLRlXr16VTw/pOrqgJ7aoyvb0MZr2eUTVfq88dMWWVNVTVfd5lZnqgFKDfFjZePfuXfL09KRevXrR3r175Z/rkmMtDZl87dq1k+ehhIaG0qRJk6hhw4Y0cuRI+ULGZcEwjMZy3D78QSiLo0ePUps2bcjf35+I/tv31svLizgcDtWoUYPMzc1p/vz5rFY9sqWnR48e0YMHD+j48eM0d+5c+vnnn4nD4RCHw6HmzZtT7dq1qV+/fuTu7k7fffedvKJTl8jJySn33deWntQJW/akq2jK5xHptt+ryL7nbMEwTLmLr2vTltjQU1XweVWR6nUoNQAR4eHDhxAIBAgMDERKSgo2bdqE5ORkzJgxA3w+HwAqxRpZMvm+/vprBAcHY8OGDVi0aBH69u2LU6dOoWPHjvJzy3oeDoeDvn37ok+fPuDz+bC1tWVVRolEgosXL0IkEuH48eN4/vw56tevX+I8+v912Tp16oRWrVrh1KlTGDduHHg8HoqKimBqaoqFCxfCw8MDnTp1YlVGNmnbti04HA46dOgAd3d3AMDLly/Rtm1buLm5ITY2FjExMbhx4wb09PRQp04d7Qr8/+Tl5SEwMBBCoRBPnjxBXFxcqedVFT2Vhqr2JJFIEBwcjD179oDP58PNzU2eF6dNqpLPA1TXE8MwWL16NWJiYiAQCNC/f3/o6bH78/v8+XOIRCL4+Pjg66+/xoIFC0q0UVVsqbL6vCqPVsPZz4wRI0ZQ3bp1aeDAgdS/f386duyY/BibvVdN7RFNRHTv3j0aPHgw8Xg86tmzJ/3222+f3G6QYRh6+/YtffXVV2RmZkYAqFu3brR161aV1m5jGIZu375Nc+bMISsrKwJAdnZ2tGrVqnJ7pwzD0OLFi8nCwkKj+/Wqq8qbiOiHH36gLl26VGiEVpOIxWIKDg4mPp8v36bS0dGRdu3aVe6oirb0pEkUtSciorNnz1KvXr0IABkbG5NAIKDg4GASi8UakrpsNOXziHTb7xER/f7772RnZ0cAyMrKiubMmUN37txRaYQ5MTGRtm7dSt26dSMAZGZmRl999VWJCvuP0aYtqaPKm0h3fd7nRHVAqWFGjx5NHA6HDh06JP+sMjtWGdnZ2bR+/Xqys7OT57KUR35+PgUEBJCbmxvp6+sTl8ulIUOG0MGDB+XJ1uURHR1NK1asIFtbW7mjnjt3brn7KMuQnXPv3j26dOlSsc/UjTr0JJM9ODiYWrZsKc+R0uZetgzDUFhYGM2ePZssLS0JALVq1YpWr15dbLHh8u5BpB09aQNl7Ck2NpZWr15NrVq1IgBkaWlJs2fPprCwMK1+V5rweUSVw+8xDEN37tyhuXPnyju+tra2tHLlSoqOjq5wmwcPHqTBgwcTl8slfX19cnd3p4CAgAoFU9q2JXWtF6pLPu9zpTqg1AK9e/emTp06UXJysloMWRuO9UPi4uLo8ePHRFTxH4709HTas2cPOTs7EwCqWbMmeXp60unTp0sk+KekpND27dupZ8+eBIBMTExo4sSJdPbsWZ0Ylako6tRTZmYmWVtbU0hICOv3rihRUVG0fPlyatmyJQEga2trmjdvHoWHh1fpYJBtFLUnhmEoPDyc5s2bR9bW1gSAWrZsScuXL6eoqCh1i1sq6vZ5RJXP74nFYjp79ixNmDCBTExMCAD17NmTduzYUaKquqioiE6fPk2enp5Us2ZNAkDOzs60d+/eYpXNlQF16UkXfN7nTnVAqSXat29P9+/fL/WYqg6XTYMtq1pTncTHx9PatWupTZs2BIDMzc1p2rRptGLFCnJxcSEej0d6eno0YsQI8vX1pby8PI3Kx1aCvbocqywpv3HjxrRt2zZW710eycnJtG3bNrK3tycAZGpqSpMmTaLz589XjxhoAYlEQufOnaNJkybJgxZ7e3vatm2bxqc6P+XzdMmeZAUqmiQvL498fX1p+PDhpKenR3p6ejR8+HBavnw5TZs2jczNzQkAtW3bln799VetFJ2x9VugrpkZbfm8av6jOqDUEqWt5i/j6NGj8mF7ZWDDYJOTk2nixInk7++vtbXUioqKaOfOndS6dWvicDgEgAwNDcnFxYVu3rypFZmI3k85/fLLL7Rs2TKVfnjY0NPbt2/LDNR+++03jfzw5ObmklAoLBbsjxw5kvz8/DQe7FdTNnl5eeTn50cjR44kPT094vF45OLiQiKRSL51oDopy+dJJBKKioqiiIgIle6vqj0xDEPLli2jJUuWVDjlRh3cuHGDhg4dSoaGhgSAOBwOtWnThnbt2qWVDj7R+4Dfz8+PJkyYoHJHRFU9yXKtS/td0pTPq6Z0qgNKHePVq1dkZGREw4cPV9p5qGqwmZmZ1KlTJ7K2tq5wXg9blFVcs2LFCjp06BDrxTzK8scffxAAWrJkidL3UFVPkZGRZGNjQ6GhoaUGtuocZflUcU15xQnVaJ/U1FTatWuXThTzSCQSGjJkCNWrV48iIyOVvo+q9vTLL78QANb3GK8IiYmJtGXLlhLFNYcOHaLly5ezXsyjDNHR0WRtbU2dO3cuthyUoqiip6KiIho2bBhNmTJF4z6vmvKpDih1kHPnzpG+vj55eXkpNTqoisHm5eWRk5MT1alThx49eqTw9cqiSHENG8U8bLB+/XoCQJs3b1bqelX0FBcXR1988QW1b99eY2ussVFcU43uoQvFPOnp6dSuXTtq0KCB0iNMqtjTb7/9RgBow4YNSrWtDIoU17BRzMMGDx8+pDp16pCTk5PSsw/K6kkikZCnpycZGBjQuXPnlGq7GvVSHVDqKEeOHCEul0vfffedwk5dWYMtLCwkFxcXMjY21siUMhvFNYoU86iDRYsWEQDy9vZW+Fpl9ZSYmEgtWrSg5s2bU2JiosLtKkp1cc3ngbaLed68eUPNmzenFi1aKDXroKw97du3jwDQzz//rHCbisJGcY0ixTzq4ObNm2RkZEQuLi7lLvVVGsroiWEY+vbbb4nL5dLRo0cVbrMazVAdUOowMke3ePFiha5TxmAlEgl5eHiQgYEBnT9/XlFRK0xubi75+PjQsGHDWC+uKa2YZ+bMmXTz5k21BT4Mw9D06dOVcnTK6CkjI4M6dOhA9evXp7i4OAWlrTjVxTWfN9oq5omNjaX69etTx44dKTMzU6FrlbEnWcf922+/VauPuHHjBs2cOZP14pqyinl8fHzUmr987tw5MjAwoPHjxyvsD5TR088//6x0x70azVEdUOo4sqmYjRs3VvgaRQ2WYRiaNm2a2np/YrGYQkJCSCAQyPPtHBwcaOfOnWrJt2MYhu7fv08LFiyg+vXrEwBq3rw5LVmyhJ49e8Z6e8oG44rqKTc3lxwcHKhevXr05MkTZcX95P2ri2uq+RhNF/M8fvyY6tatS7169VLo/orakypBUUV49uwZLVmyhJo1a0YA6IsvvqAFCxZQRESEWoLXlJQU2rFjBzk4OMjzYidMmEAhISFqyYs9evQocblcmj59ukLPo6ieNmzYoFJqUTWaozqgrATIksX//PPPcs/NfSemIxdvkYGNLR25eIty35XvSBYuXEgAaP/+/SxI+55P7VwTExPDWjvlIZFI6OLFi6UW87A5XaxouoCienr37h0NHjyYTExM6Pbt22yJTWKxmIKCgqqLa6qpEKUV8/D5fNaLecLCwsjExISGDBlSoWlVRe3pxo0bZGRkRMOGDWM1Naas4prQ0FCNjuxHR0fTypUrSxTz3L59m9Vg1tvbmwDQokWLKnS+onpio/ixGs3BISIqa1vGanQDIsKsWbOwa9cu+Pv7Y+zYscWORyXnQBSWgEvPU5CQkY8PFcoB0KiuEfrZWYJv3wgtrUyLXbt+/XosWrQIW7Zswdy5c1WWNSYmBiKRCCKRCC9evIC1tTXGjx8PgUCALl26gMPhqNyGshQUFODMmTMQiUQ4c+YMpFIpBg4cCIFAgFGjRsHExESl++fn52Po0KF49OgR/vnnH7Rv377YcWX1JJVKMX78eJw6dQrBwcHo16+fSnISEe7cuQOhUAh/f3+kpKSgVatWEAgE8PLyQtOmTVW6fzWfB3FxcfDx8YFQKMSzZ89gaWmJ8ePHg8/no3v37irbemhoKIYNGwZXV1f4+vqCx+MVO66sPT18+BB9+vRB+/btERISAiMjI5XkzMnJwYkTJyAUCnHhwgXweDwMHz4cfD4fI0aMQI0aNVS6vyoQEcLDwyESieDr64vk5GTY2tqCz+eDz+ejefPmKrexZcsWzJ8/H+vXr8dPP/1U4riyejp8+DDGjx+PmTNnYtu2bVr97aimYlQHlJUEhmEwceJEHD58GCdPnsTQoUPxKiMfi48/wtXoNPC4HEiZslUpO+7cwhxrR7VHw7pG2Lt3L7799lssXboUK1asUFq21NRU+Pv7QyQS4datWzAxMcHo0aMhEAjQr18/6OnpKX1vdZGRkYEjR45AKBTi6tWrqFmzJtzd3cHn8zF48GDo6+srdd+srCz069cPiYmJuHr1Klq0aKGSnhrUqYlvvvkGBw4cwLFjx+Dq6qrsIyM6Oloe7EdFRcHa2hpeXl7g8/no3LlztcOuRimICPfv34dQKISvry+SkpLQsmVLedDSokULpe8dGBiIMWPGYPLkyfjzzz/B4XBUsqfCjDdwcnLCF198gdDQUNSqVUspucRiMc6dOweRSIQTJ06goKAAzs7OEAgE+PLLL1G3bl1lH1ltSCQShIaGQiQS4dixY8jNzUXPnj0hEAgwbtw4WFhYKH3vpUuXYtWqVdi7dy+mTZsGACrp6cntf+Dq6goPDw/8/fff4HK5SstWjeaoDigrEWKxGGPGjMGFCxeweN9pHIoshIShTxrqx/C4HOhxORhunY+ts8bi+++/x++//65wMJGXl4eTJ09CKBTi7Nmz4HA4GDp0KPh8PlxdXVXu9WuSly9fykdaIiMjYW5uDg8PDwgEAtjb2yv83aSkpMDZ2RlFRUX4aW8gtl79V2k9tXsXiWObFuDQoUMQCASKPhpSUlLkwX5YWBhMTU2LBfsfj/pUU40qSKVSedBy9OhR5Obmwt7eHnw+Hx4eHrC0tFT4ngcPHsSkSZOwYMECdBk7C8tPPVHKnngcoOiGEDXe3MPVq1cVDqCICLdu3YJIJIK/vz/S0tLQtm1bCAQCeHp6onHjxoo+mtbIz88v5r8BYMiQIeDz+XBzc1PYfxMR5syZgx07dsDX1xfUzAHLTiqnJy4I6ed2w8mGi6NHjyrdua9G81QHlJWMgoICOHy9Am8bOat8rybZjxC6/acK9/4kEgkuXrwIoVCI48ePIy8vDw4ODvIerrm5ucoyaRMiwoMHDyASieDj44M3b96gefPm8lE8Ozu7Ct8rISEBTtNXg9vJTRWJAHDgZJYB4c8TKnxVXl4eTpw4AZFIhHPnzoHD4cDFxQV8Ph8jR46sVMF+NZWX/Px8nDp1CiKRCMHBwSAiDB48GAKBAG5ubjA2Nq7wvbZv345ffK+hTp+JygtEBHA4+KaHFf43qluFL3v+/Ll8ZD82NhZffPEFPD09IRAI0KFDh0o/sp+amorDhw9DJBLh5s2bMDY2xujRo8Hn8zFgwIAKzzAxDIPJkyfjVKwYtZwV7/zKICJwOBzM7dcMcwe3Vvo+1Wie6oBSh9iwYQO8vb0RGRlZZpDndycBi449Yq3N9aPbw6N7o1KP7dmzB2vXroWvry8CAgLg5+eH5ORk2NnZyfPtmjVrxposuoRUKsWVK1cgEolw5MgRZGdno1u3bhAIBEhLS0NAQIDO6CkkJARffvkl/vrrL5w+fRonTpxAXl4eHB0dwefzMXbs2Eof7FdTuZHZjFAoxI0bN2BsbAx3d3cYGhri+vXrn7QlQHP2JLOlW7du4cKFCxCJRLh79y7MzMzw5ZdfQiAQoHfv3lV2ZD8mJgY+Pj4QiUR4/vw5rKysMH78eEilUpw/f75cPYluxeF/gZGsyVOenuLi4lSaqq+GXaoDSh0hOzsbTZs2xaZNmzBlypRix06ePInly5cjMjISUkMzGLcfiFqO48HhKu/U3r1+ireX96MoKQbmdWthvIcH1q5dKy9MiYmJwYEDB/Drr79CKpXqVHGNpvmwmOf06dOQSCRo27YtFi5cCHd3d5iamsLf3x+nTp1CWFgYoqOjUbNRe1h6/apy2+K0V8i4+CcKX0fCzLgmRo4Yjs2bN8PCwqJYcc3u3bshkUiqi2uq0XlkxTx///03oqKiYGpqiilTpoDP56NZs2bYv38/Tp06hadPn0IsFqNZC1skNeoPAzvVZmU+tCUOTw9uI0dg785t8oAkJycHx48fx/fff4+cnBzo6+vrTHGNpvmwmEckEiE1NRVWVlaYMWOGvJhn3rx5uHLlCuLj4/Hu3Tt80aARMqy7wrj7KHANairddnl6ktGpUyf0798fmzdvVvVxq2GJ6oBSR9i6dSuWLVuG5OTkYo4rODgYw4cPR9++fZHf0B5PI58gO/wMTDoNQb0hM5Vqqyg5FkmHFkC/XkOYdR4Ka14eoi74wtHREaNGjSpWXNO4cWOkpaXh1atX1bksANauXYtVq1aha9euuH79uryY59GjR4iPj0f37t1xPSwcXPPGsFIxoJRkpyFx/2xwDY1Rq7srGppw8PKyP6ysrPDll1/Cz88P0dHRsLGxQZs2bXD9+nUkJyfDzMyMpaetphr1sWXLFixZsgRfffUVAgICkJSUBBsbGyQnJ6N///4YMWIE9PT0sGrHfiQ/C0ctR0/UduYr1daHtmTabSQgfoe8OyfQqkUTrFixAv7+/ggMDERBQQFatGiBhIQEvHjxolLlRaqL3377DUuXLsWoUaMQGBgoL+ZJSUnBgAED0L59e9SoUQObfEIQdfUUDGxawoq/DhyO4oU0ZempdcumuH37NgwMDOTn7t69GwsWLEBSUhJMTU0/cddqNEV16ZSOsH//fri6upboBS9YsAAdOnTAzkNHkVTfCXUGToeZw1jk3g+BOP2VUm1lXvkb3BomsPL6FcadXJDT/ks0bdMJoaGhmDNnDszNzeVLTPz9999ITk7G1atX2XjMT3L58mVwOJwy/2TL5cyePRtdu3aFoaEhOnXqpHa5PsTf3x9ffvklrl27hvj4eCxZsgQPHjzA48ePYWhoiIbteoCMaoONflrWzcMgcSGsPNfApOtIZNqNQL2GLfHs2TNs3LgRjo6OOH/+PF69egUfHx+IxWIcOXKEhaf8/KjIu5eeno6hQ4eifv3673XdsCG+//57ZGdna1v8SsmBAwcwatQobNu2Da9fv8b58+fh4OCAGjVq4MKFC/D19UVqIQ+GbstRo3EHZN06AqbonVJtfWhLZt1cYeYwDrVdf8LDhw8xatQoPHr0CEuXLkV8fDyuX78OqVSKixcvsvzEJakMPu/gwYMYPXo0hEIhkpOT4evri3r16iEhIQHe3t4ICQlBnp4ZCnt+hdq9J6DwdSSK3rxQqq2y9PTgwQMcOHCg2LljxoxBYWEhAgICWHjKatigOqDUAeLi4vDw4UMMHDiw2OeRkZGIjIzEtGnT4B/+Bjzu+2lm087DABDynl1XuC2mMB/v4iNg3LYvuIbvizOIkYLTahAMDQ3h6emJU6dOYfz48TAyMkLXrl1Rt25dBAYGqvyc5dGrVy8kJiaW+Nu7dy84HA5mzJghP/err76Ch4eH2mX6kI/11LhxY/z88894/Pgx7t+/jylTpiA0oYi19vKf30DNFt2hV+t9ZSwxUpjZj4KNjQ0cHBxw4MABDBw4EDweD5aWlujQoYNG9FQVqci7x+Vy4ebmhpMnT+LFixc4cOAALly4gG+//Vbb4lc6PrYlHo+HgQMH4ujRo0hNTYWfnx8sLS2x4+wDgBjUbOkASMWQvE1Sqr2PbQkAajRqD6M6VrC3t8ejR4+waNEiNG7cWKO2VNl8npGREcaPH4/Tp0/jzZs3+P3335GZmYmVPqEgRgpeLSsAAFOYp1R7penJpFln1KvfBIcPHy52brXP0z10b4HAz5AbN24AALp06VLs8/v37wMAunXrhh+vpMiXX9AzrQeeqTnEybEKt1WUGg8wUhhYt5R/xuHyYNGlP+q9uoynT5+WuKZLly64fl3x4FVRDAwMYG1tXeyzp0+fYsGCBVi8eLF8Qfdt27YBeF+d+PDhQ7XLJaMsPXE4HHTq1AmdOnVC2MZQJF8/qnJbkpw0MPlvYWD93xp+HC4PJrb2GDBgAIKCgkpc07VrV5w4cULltj9HKvrufffdd/LjjRs3xowZM7Bx40aNyloVKMuWgPdBi4eHBzw8POC07gJeZxVCmpcJAOD+X3v3GtTUmcYB/B+IiQIS5aLQVqQsKF2M2xmtrbc16lj3gtpa673iyAf9srrrth21o4yt01Xr1k531HYXpNS1o3UWdSv2oksV3WpBKK6VUsASaRXKTTSBmBCS/RATibnnHDCB/2/GGefknPMGnvO8POec97wnzPfhHM5yCbiXT48rUV1d5jAmvLdyKVj7PACIjY3F6tWrsWjRIvxm1yn8qL6MtnMHIJENgix+lM9tuYpTl8mM0LhkfPNNmcM27PMCC69QBoDKykoAcHiIor6+HgAQGRWLutYOu89CI4bCqG3xua0ubatt++7qWjoQOzwON2/edNgmKSkJFRXiPbnnrba2NsybNw8qlQpvvPFGr7f/IFdxstLqjfixVSdKW11ayx/Q0Aj7CZLrWjoQM2w4Wltbodfr7T5LSkpCc3MzGhsbRfkO/Zk3x97NmzeRn5+PadOm9fK3C36ecgmw5NON23p06TTQXv4C8sfSII3wfcJwV7kEAHcHRAZULgVbn3fp0iXExsaidMdSNB7eApiBYS9sRugg38c0BlOcyDleoQwALS0tkEqlDq/+0+ksxUljRxceHJEnCZXBZOiAr8xGw73t7R+wMQNoudMOrVaLsjL7M0G9Xg+dTmd7CEWo5ORkjw+OmEwmLF26FFKpFAcPHhT0VLlarUZra6vf21tVVlYiNDQUVVXOxwfVtnU6xMlfZqOl43QWp58aLR3vxYsX7QajazQaAEBRUVGfnc5JKG/eCOTp2FuyZIntAY45c+YgOzvb6X6sb5AhR55yCbDkk8lsQvMnu2DSaxE1a7VfbbnKJcsyy0MePZ1LUVFRSExMdLuOmH3enTt3UFNT4/f2Vp7iZDAYsGXnu9h3sRH6G9/hrrocpk7/xrl6EyedTge5XG5bPnSo5cJIc3OzX5Pmk7hYUAYwa/HW3uF41cvcZYBEKnNY7ol1G3NXp8Nn58+dg+muFuPGjXO67ZQpU3xuz5lTp045jBd90KZNm3DhwgUUFxcLfoIvKysLH374oaB9dOfq9yOLH4X4DHGmsJBILZ2mszjlHz0KAFCpVE63ffBd73Sf0Wj0OIegp2Nv9+7dyMrKQlVVFTZu3Ij169dj7969DuuZTCaXxwpZuPv9yOJHQRafgrs/lCI6fT1kw/0r7NzlkrnLcoLd07m0YsUK5OXluV1HzD6vuLgYs2bNErSP7jzFKT7jbYSNegbtV8+g6V/bEL/yHZ/j5U2cHrygYX34sT9NYxfIWFAGgOjoaBiNRmg0GruOJD4+HgBwu6XJYZsu7S3I/RinYr2dYL290N2o5F8ARj0OHjxot3zbtm349NNPRRtH6endvocOHcKuXbtQUFCAlJQUt+t6Y+vWrVi3bp3g/ezduxc5OTkoKipy+paP2rZO/PlUs+B2gPtDEqxDFLqbMvFpXC65gMLCQrvl+/fvx549e3D69GnbmTvZ8/RWKG+Ovbi4OMTFxSE1NRVRUVGYOnUqNm/ebMvX7m2VlpaK9t37Ek+5BAA73t2Hj/OyMUS1EhFjZvjdlrtc6tLeQsTgSJw986XdcrFzydO7vcXu8yZMmCDKsedNnLr3e2GjJwEn3kb7d0U+F5Se4qQYMtTu6iQA3Lpl+TvGFzcEBhaUASA1NRWA5Ym6sWPH2pZbp4eov3YVEiTZbqcaNS3o0jRjwJOzfW5LFjMSCAmFoaEa4U90myi4qxM/qa9h4cKFDgOwNRoN0tLSnA7MFlt5eTkyMzOxfft2zJ7t+8/nTGJiosfbTd6YPn06cnJyoFAo7OJkNVpvxMunPhfcDgBIB8cgJEwBQ4P9bSsJgPrrP2DcuHEO8di3bx9iYmIwc+ZMUb5Df+PPsWcymQDAYWwXYLlq0hs5E4w85dKePXvwcV42IsfPg+KZBYLacpVLAKCvr8Lkh5xLPdHnRUZGinLseYoTcL/fMwMwGzsBswkmve/DsTzFabyT6ZJqa2sRExPDt+UECD6UEwAmTpwIwDLAubu0tDSkpqYib38ORgy5f2am/eYkAAnCR/t+CzpkYDgGJj6J9qtn7JJepv4vtFqt01s8ZWVlmDRpks9t+aq5uRnPPfccVCoVli9fjoaGBrt/TU2WK7U1NTUoLy9HQ0MDdDodysvLUV5eDoNBvCl7nHEVJ6twuRQJUeK9Jzts9CToakpgvHP/CvXg1kpUV1c5jVNpaantO5JvvDn2Tp48idzcXHz77bdQq9UoKCjAmjVrMHnyZFFOWPoTd7l0+PBhrF27FsuWLcOvXlwrSnvOckmnLoex9QYWL1rosH5v5VKw9nltbW3o7LTcmu7e72kvW06o5XHu70K5EqhxIu/wTTkBQqlUQqlU4qOPPrJbfuLECcydOxeJygnQPDoB+kY1NGUFiBg7C9G//YNtPWPbz7jxXibCx8xETPqf3Lalb6hBw4FXIItJQMSTs2HStEB76RhmqKbh88/tr7CVlpZi/PjxOH36dI+frefl5WHlypUuPx85ciTUajVUKhXOnj3r8HltbW2P/2F3FaeioiIUFRWhsLIRRUcPAAPkiBhrGcM0cMQYDEwYY1v3+vZ0yEeMQdyy7W7bMt5pQn3uuntvjZgLGO9Cd+koUh4fiZKSErvbP42NjXjkkUfw/vvvIzMzU8SfuH/w5tjLzc3Fa6+9hoqKCuj1eowYMQLz58/Hhg0bMGTIkF77rn2Fs1wqLi7G1KlToVAosGPHDnxy5Wecv9aMexeCIX/sCQwYcn+aHX9zydypw52v8xEzPB513195aLkUrH3esWPHsHbtWixYsAApKSk4XnYd58+dR/v3X0EWl4y4l3baPVwT7HEi7/CWd4BYtWoVtmzZAp1OZzfwOD09Hfn5+di0OQu1X7yH0DAFFBNfhGLyErvtTZ2WB3cenA7IGXlcMoYv3oa2Mx/g1n+yIZENwtLlK7D3nb86rHvkyBEkJCRgxgz/xzB5KyMjAxkZGR7XO3PmTI9/F1dcxamwsBBbt261W/f2uX9a/jN5ia2gNBmscfI8/Yk0MhbDl/4Ftwqz0Xb2A0hCpEhP/z3+vuddh7FE+fn5kMvlWLjQ8SyePPP22LPOy0fCOculiooKGAwGNDU1YdWqVQ7bRP/uj7aCUmguDUp+CscPZT/UXArWPk+pVGL69Ok4fvw46uvrYTKbYYoYBsXkxYh8+gW7YrIvxIm8wyuUAeL27dtISkrCzp07XZ5tvZTzNb76ocU2wXl3mrIC3PoyF4+u+QdCw70fRB4aIsGkpGgcyHza4TO9Xo/ExERs2LBBlIda+gKhcdJdK0HjkdcRv+pvkA1L9Lpdd3ECLNPhqFQq7N692+t9Ej1M3uQS4Dqf/M0lwH0+MZfsMU7kLY6hDBAKhQKvvvoq3nrrLdtA/we9+bwS0hDn0yPcvf4/DB4/x6diEgCkIRK8+bzS6We5ubkYMGAAXy3XjfA4XUHYL3/tc8fqLk6fffYZqqursXHjRp/2SfQweZNLgOt88jeXANf5xFxyxDiRt3iFMsgcKqnDhvwrou1vx3wlFj2VINr+yIJxIhIP8yk4ME79G69QBpnFTyXg5Wd9n3/SmVeeHc1k7SGME5F4mE/BgXHq33iFMkgdKqlD1r+vwmgyOx2r50poiATSEAlen5vGZO0FjBOReJhPwYFx6p9YUAaxH1s7sOnoFZyraUZoiMRt4lo/n5ocgzefV2KEiPMlknuME5F4mE/BgXHqf1hQ9gHVP2tw8Os6fFnViLqWDnQPqARAQnQYpo8ahuXPJCB5mLB3xJL/GCci8TCfggPj1H+woOxj2vVGqFvaYTCaIJOGIDE6HOFyTjcaaBgnIvEwn4ID49S3saAkIiIiIkH4lDcRERERCcKCkoiIiIgEYUFJRERERIKwoCQiIiIiQVhQEhEREZEgLCiJiIiISBAWlEREREQkCAtKIiIiIhKEBSURERERCcKCkoiIiIgEYUFJRERERIKwoCQiIiIiQVhQEhEREZEgLCiJiIiISBAWlEREREQkCAtKIiIiIhKEBSURERERCcKCkoiIiIgEYUFJRERERIKwoCQiIiIiQVhQEhEREZEgLCiJiIiISBAWlEREREQkCAtKIiIiIhKEBSURERERCcKCkoiIiIgEYUFJRERERIKwoCQiIiIiQVhQEhEREZEgLCiJiIiISBAWlEREREQkCAtKIiIiIhKEBSURERERCcKCkoiIiIgEYUFJRERERIKwoCQiIiIiQVhQEhEREZEg/wd8vVh3u46aoAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -370,6 +373,8 @@ "id": "3e1528a0-de81-4807-820f-d273871e7cfe", "metadata": {}, "source": [ + "##### Figure 2\n", + "\n", "With the connectivity defined, we can construct a variety of Hamiltonians using the terms defined in [[1]](https://doi.org/10.1038/s41535-019-0203-y). Some of the models contain more terms and thus take longer to run. For the purposes of demonstration, row 13 tends to have the shortest runtime, so we use that for demonstration purposes here. To run all rows, simply loop over all indices rather than just the 13th index. The number after the terms in the following graph indicate how far away the interactions are. For example J1 represents the nearest neighbor Heisenberg interactions, J2 represents the next-nearest neighbor Heisenberg interactions, and J3 represents the next-next-nearest neighbor Heisenberg interactions. Any terms not present in the table that appear in the generic Hamiltonian defined above are treated as 0." ] }, @@ -861,12 +866,12 @@ " if not (weight_y == 0):\n", " for node in g.nodes:\n", " string_y = n*'I'\n", - " string_y = string_y[:node] + 'y' + string_y[node+1:]\n", + " string_y = string_y[:node] + 'Y' + string_y[node+1:]\n", " H.append((string_y, weight_y))\n", " if not (weight_z == 0):\n", " for node in g.nodes:\n", " string_z = n*'I'\n", - " string_z = string_z[:node] + 'z' + string_z[node+1:]\n", + " string_z = string_z[:node] + 'Z' + string_z[node+1:]\n", " H.append((string_z, weight_z))\n", " return H\n", "\n", @@ -883,15 +888,167 @@ }, { "cell_type": "markdown", - "id": "7969824d-de0c-4e29-9572-89d6fa55612d", + "id": "e4e4af32-97ae-4c67-893e-b9c15db9803d", "metadata": {}, "source": [ - "Finally, it is time to implement the circuit for simulating the time dynamics of $H$, parameterized by the rows of Table 1. First we perform the simulation using the second order Trotter expansion. We choose an energy precision of 1e-3, which is believed to be sufficiently low to allow for lower circuit depths while still getting empirically accurate results. We construct a lattice of size 32x32 honeycomb cells to hopefully have a sufficiently large mass to mitigate finite size effects. This is believed to be the lower end of what lattice size would be useful, and larger may be better in some cases. Finally, we plot the a histogram of the T-widths that occur on each layer of the circuit. The x-axis representing the number of parallel T-gates and the y-axis representing the number of layers where that T-width is found. This is done to determine the value of the parallelizability of T factories on a theoretical Fault Tolerant Device using a Clifford + T gateset." + "Next, we need to implement a circuit to prepare an initial estimate for the ground state of RuCl with a high degree of overlap with the actual ground state. It has been observed experimentally that at low temperatures $\\alpha-RuCl_3$ corresponding to a zig-zag spin structure, seen in Figure 3. In the presence of an external magnetic field, this state is non-degenerate and can be prepared by implementing local rotations on individual sites. \n", + "\n", + "The change of basis matrix from the $\\hat{x}$, $\\hat{y}$, $\\hat{z}$ axis to the $\\hat{a}$, $\\hat{b}$, $\\hat{c}$ axis is as follows:\n", + "\n", + "\\begin{equation}\n", + "\\begin{bmatrix} \\hat{a} \\\\ \\hat{b} \\\\ \\hat{c} \\end{bmatrix} = \\begin{bmatrix} \\frac{1}{\\sqrt{6}} & \\frac{1}{\\sqrt{6}} & -\\frac{2}{\\sqrt{6}}\\\\\n", + " \\frac{1}{\\sqrt{2}} & \\frac{1}{\\sqrt{2}} & 0 \\\\\n", + " \\frac{1}{\\sqrt{3}} & \\frac{1}{\\sqrt{3}} & \\frac{1}{\\sqrt{3}}\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix} \\hat{x} \\\\ \\hat{y} \\\\ \\hat{z} \\end{bmatrix}\n", + "\\end{equation}\n", + "\n", + "This state may be prepared by initializing the spins in the $\\hat{z}$ eigenbasis $|0...0\\rangle$ then applying $\\sigma^x$ operations on the appropriate sites to form the zig-zag pattern. Next, the sites are rotated about the $\\hat{c}$ axis until the state has maximum overlap with the $\\hat{a}$ direction. The angle of rotation required in this instance is a rotation of $\\theta = \\pi$ about the $\\hat{c}$ axis. This rotation can be achieved by performing a sequence of rotations evaluated from right to left): $R^z_i(- \\pi/4) \\cdot R^x_i(- \\pi/4) \\cdot \\sigma^z_i \\cdot R^x_i(\\pi/4) \\cdot R^z_i(\\pi/4)$. We show below how one may construct this initial state below. This ground state is biased in the presence of a uniform magnetic field, representing the Zeeman terms in the $\\hat{a}$ direction, making the Zeeman terms \n", + "\\begin{equation}\n", + "H_{field}(t) = t \\sum_i \\left(\\frac{1}{\\sqrt{6}}\\sigma^x_i + \\frac{1}{\\sqrt{6}}\\sigma^y_i - \\frac{2}{\\sqrt{6}}\\sigma^z_i \\right)\n", + "\\end{equation}\n", + "\n", + "Once all of this has been done, the state has been prepared and the dynamics may be executed.\n", + "\n", + "\"RuCl_Spin_Structure\"\n", + "\n", + "##### Figure 3" ] }, { "cell_type": "code", "execution_count": 6, + "id": "2a1e7584-5f7c-458b-92db-d73bafb10a6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: ────Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "1: ────Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "2: ────Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "3: ────Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "4: ────Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "5: ────Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "6: ────Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "7: ────X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "8: ────X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "9: ────X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "10: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "11: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "12: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "13: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "14: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "15: ───Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "16: ───Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "17: ───Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "18: ───Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "19: ───Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "20: ───Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "21: ───Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "22: ───Rz(0.25π)───Rx(0.25π)───Z───────────Rx(-0.25π)───Rz(-0.25π)────────────────\n", + "\n", + "23: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "24: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "25: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "26: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "27: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "28: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n", + "\n", + "29: ───X───────────Rz(0.25π)───Rx(0.25π)───Z────────────Rx(-0.25π)───Rz(-0.25π)───\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def assign_spin_labels_rucl(lattice_size):\n", + " #We may omit NN and NNN couplings for the purposes of clarity in state prep\n", + " g = hexagonal_lattice_graph(lattice_size, lattice_size)\n", + " spin_labels = dict([(node, pow(-1, node[0])) for node in g])\n", + " nx.set_node_attributes(g, spin_labels, name=\"spin\")\n", + " return g\n", + "\n", + "def prepare_initial_state_rucl(g):\n", + " #site labels are assumed to be the same as for hamiltonian with NN and NNN couplings\n", + " #because they come from the same base generator\n", + " g = flatten_nx_graph(g)\n", + " spins = nx.get_node_attributes(g,\"spin\")\n", + " qubits = [cirq.LineQubit(i) for i in g.nodes]\n", + " \n", + " #generating layers of operations to initialize state\n", + " layer_zig_zag = [cirq.X(qubits[i]) for i in range(len(g)) if spins[i] == -1]\n", + " layer_rz = [cirq.Rz(rads = np.pi/4).on(qubit) for qubit in qubits]\n", + " layer_rx = [cirq.Rx(rads = np.pi/4).on(qubit) for qubit in qubits]\n", + " layer_z = [cirq.Z(qubit) for qubit in qubits]\n", + " layer_rx_neg = [cirq.Rx(rads=-np.pi/4).on(qubit) for qubit in qubits]\n", + " layer_rz_neg = [cirq.Rz(rads=-np.pi/4).on(qubit) for qubit in qubits]\n", + "\n", + " #appending layers to a circuit to return\n", + " circuit = cirq.Circuit()\n", + " circuit.append(layer_zig_zag)\n", + " circuit.append(layer_rz)\n", + " circuit.append(layer_rx)\n", + " circuit.append(layer_z)\n", + " circuit.append(layer_rx_neg)\n", + " circuit.append(layer_rz_neg)\n", + " return circuit\n", + " \n", + "g_spins = assign_spin_labels_rucl(3)\n", + "circuit_state_prep = prepare_initial_state_rucl(g_spins)\n", + "pos = nx.get_node_attributes(g_spins, 'pos')\n", + "spin_labels = nx.get_node_attributes(g_spins, \"spin\")\n", + "nx.draw(g_spins, labels = spin_labels, pos=pos, with_labels=True)\n", + "print(circuit_state_prep)" + ] + }, + { + "cell_type": "markdown", + "id": "7969824d-de0c-4e29-9572-89d6fa55612d", + "metadata": {}, + "source": [ + "Finally, it is time to implement the circuit for simulating the time dynamics of $H$, parameterized by the rows of Table 1. First we perform the simulation using the second order Trotter expansion. We choose an energy precision of 1e-3, which is believed to be sufficiently low to allow for lower circuit depths while still getting empirically accurate results. We construct a lattice of size 32x32 honeycomb cells to hopefully have a sufficiently large mass to mitigate finite size effects. This is believed to be the lower end of what lattice size would be useful, and larger may be better in some cases. Finally, we plot the a histogram of the T-widths that occur on each layer of the circuit. The x-axis representing the number of parallel T-gates and the y-axis representing the number of layers where that T-width is found. This is done to determine the value of the parallelizability of T factories on a theoretical Fault Tolerant Device using a Clifford + T gateset. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, "id": "6be24969-cd04-435b-a3ce-5bead1bd680d", "metadata": { "tags": [] @@ -902,18 +1059,18 @@ "output_type": "stream", "text": [ "Estimating RuCl row 13 using Trotterization\n", - " Time to estimate Number of steps required: 14.89695408300031 seconds\n", - " Time to find term ordering: 0.021428124979138374 seconds\n", - " Time to generate trotter circuit from openfermion: 1.0419171303510666e-06 seconds\n", - " Time to decompose trotter to Clifford + T: 87.22412741708104 seconds\n", - " Time to enumerate resource estimates: 7.514046208932996 seconds\n", - "Total time to estimate RuCl row 13: 146.24839045794215 seconds\n", + " Time to estimate Number of steps required: 103.04612716300016 seconds\n", + " Time to find term ordering: 0.07268580199979624 seconds\n", + " Time to generate trotter circuit from openfermion: 3.1399999897985253e-06 seconds\n", + " Time to decompose trotter to Clifford + T: 586.144736452 seconds\n", + " Time to enumerate resource estimates: 41.98660919099984 seconds\n", + "Total time to estimate RuCl row 13: 993.6296226879999 seconds\n", "\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -937,7 +1094,7 @@ " os.makedirs(widthdir)\n", "\n", " timesteps=1000\n", - " H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i], field_x=lambda s: 1)\n", + " H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i], field_x=lambda s: 1/sqrt(6), field_y=lambda s: 1/sqrt(6), field_z=lambda s: -2/sqrt(6))\n", " H_rucl_pyliqtr = pyH(H_rucl)\n", " openfermion_hamiltonian_rucl = pyliqtr_hamiltonian_to_openfermion_qubit_operator(H_rucl_pyliqtr)\n", " \n", @@ -965,7 +1122,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "fc6129fc-d5d5-465b-b686-4085883228f6", "metadata": { "tags": [] @@ -976,20 +1133,20 @@ "output_type": "stream", "text": [ "Estimating RuCl row 13 using QSP\n", - " Time to generate high level QSP circuit: 96.58290741604287 seconds\n", - " Time to decompose high level cirq.ops.pauli_gates._PauliX circuit: 0.00010220904368907213 seconds\n", - " Time to transform decomposed cirq.ops.pauli_gates._PauliX circuit to Clifford+T: 2.1459069103002548e-05 seconds\n", - " Time to decompose high level cirq.ops.common_gates.Rx circuit: 5.8333040215075016e-05 seconds\n", - " Time to transform decomposed cirq.ops.common_gates.Rx circuit to Clifford+T: 0.006496042013168335 seconds\n", - " Time to decompose high level pyLIQTR.circuits.operators.hamiltonian_encodings.UnitaryBlockEncode circuit: 0.4555914159864187 seconds\n", - " Time to transform decomposed pyLIQTR.circuits.operators.hamiltonian_encodings.UnitaryBlockEncode circuit to Clifford+T: 114.45711995789316 seconds\n", - " Time to decompose high level cirq.ops.common_gates.Ry circuit: 0.0047991249011829495 seconds\n", - " Time to transform decomposed cirq.ops.common_gates.Ry circuit to Clifford+T: 0.4593636669451371 seconds\n", - " Time to decompose high level cirq.ops.raw_types._InverseCompositeGate circuit: 11.808722625020891 seconds\n", - " Time to transform decomposed cirq.ops.raw_types._InverseCompositeGate circuit to Clifford+T: 122.48608425003476 seconds\n", - " Time to decompose high level pyLIQTR.circuits.operators.reflect.Reflect circuit: 0.016667624935507774 seconds\n", - " Time to transform decomposed pyLIQTR.circuits.operators.reflect.Reflect circuit to Clifford+T: 0.5113535419804975 seconds\n", - "Time to estimate RuCl row 13: 384.14998012501746 seconds\n", + " Time to generate high level QSP circuit: 260.67342953499974 seconds\n", + " Time to decompose high level cirq.ops.pauli_gates._PauliX circuit: 0.002152371000192943 seconds\n", + " Time to transform decomposed cirq.ops.pauli_gates._PauliX circuit to Clifford+T: 0.00031345399975180044 seconds\n", + " Time to decompose high level cirq.ops.common_gates.Rx circuit: 0.0003783030001613952 seconds\n", + " Time to transform decomposed cirq.ops.common_gates.Rx circuit to Clifford+T: 0.033978495999690495 seconds\n", + " Time to decompose high level pyLIQTR.circuits.operators.hamiltonian_encodings.UnitaryBlockEncode circuit: 2.523002811000424 seconds\n", + " Time to transform decomposed pyLIQTR.circuits.operators.hamiltonian_encodings.UnitaryBlockEncode circuit to Clifford+T: 705.2394592869996 seconds\n", + " Time to decompose high level cirq.ops.common_gates.Ry circuit: 0.03965041799983737 seconds\n", + " Time to transform decomposed cirq.ops.common_gates.Ry circuit to Clifford+T: 1.4947827959995266 seconds\n", + " Time to decompose high level cirq.ops.raw_types._InverseCompositeGate circuit: 119.76022209099938 seconds\n", + " Time to transform decomposed cirq.ops.raw_types._InverseCompositeGate circuit to Clifford+T: 969.662417947 seconds\n", + " Time to decompose high level pyLIQTR.circuits.operators.reflect.Reflect circuit: 0.29181723300007434 seconds\n", + " Time to transform decomposed pyLIQTR.circuits.operators.reflect.Reflect circuit to Clifford+T: 2.2939369510004326 seconds\n", + "Time to estimate RuCl row 13: 2225.9231700839996 seconds\n", "\n", "\n" ] @@ -1008,7 +1165,7 @@ " if not os.path.exists(widthdir):\n", " os.makedirs(widthdir)\n", " timesteps=1000\n", - " H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i], field_x=lambda s: 1)\n", + " H_rucl = generate_rucl_hamiltonian(32, df_rucl.iloc[i], field_x=lambda s: 1/sqrt(6), field_y=lambda s: 1/sqrt(6), field_z=lambda s: -2/sqrt(6))\n", " H_rucl_pyliqtr = pyH(H_rucl)\n", " \n", " print(\"Estimating RuCl row \" + str(i) + \" using QSP\")\n", @@ -1021,9 +1178,165 @@ " print()" ] }, + { + "cell_type": "markdown", + "id": "b3f749cc-92d6-40fd-89ef-961f914a1a5d", + "metadata": {}, + "source": [ + "The final observable being measured is net magnetization, which can be obtained by simply measuring all of the qubits in the desired basis (in this case, the $\\hat{a}$, $\\hat{b}$, $\\hat{c}$ basis), and summing the spins on all of the sites. Since the computational basis is in the $\\hat{z}$ direction, we will need to implement a change of basis operation. For the purposes of this demonstration, we will use the measure in the $\\hat{c}$ direction, for which the transformation $R^x_i(\\pi/4) \\cdot R^z_i(\\pi/4)$ applied on each qubit before measurement is sufficient. This resource requirement, like the requirement for running the state preparation is constant, both in the sense that it needs to be performed for every circuit and in the sense that depth added to the circuit is $\\mathcal{O}(1)$. For this reason, we perform the resource estimates for the state preparation and observable measurement separately from the dynamic circuits which are implemented based on Hamiltonian parameterizations. Below, we provide the resource estimates for both the state preparation and measurement (the state preparation circuit generator is defined above)" + ] + }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, + "id": "bbdbb4eb-996f-4843-8831-fd18606d38ac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "1: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "2: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "3: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "4: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "5: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "6: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "7: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "8: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "9: ────Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "10: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "11: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "12: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "13: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "14: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "15: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "16: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "17: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "18: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "19: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "20: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "21: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "22: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "23: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "24: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "25: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "26: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "27: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "28: ───Rz(0.25π)───Rx(0.25π)───M───\n", + "\n", + "29: ───Rz(0.25π)───Rx(0.25π)───M───\n" + ] + } + ], + "source": [ + "def prepare_measurement_rucl(g):\n", + " #site labels are assumed to be the same as for hamiltonian with NN and NNN couplings\n", + " #because they come from the same base generator\n", + " g = flatten_nx_graph(g)\n", + " qubits = [cirq.LineQubit(i) for i in g.nodes]\n", + " \n", + " #generating layers of operations to initialize state\n", + " layer_rz = [cirq.Rz(rads = np.pi/4).on(qubit) for qubit in qubits]\n", + " layer_rx = [cirq.Rx(rads = np.pi/4).on(qubit) for qubit in qubits]\n", + " layer_measurement = [cirq.measure(qubit) for qubit in qubits]\n", + " #appending layers to a circuit to return\n", + " circuit = cirq.Circuit()\n", + " circuit.append(layer_rz)\n", + " circuit.append(layer_rx)\n", + " circuit.append(layer_measurement)\n", + " return circuit\n", + "\n", + "#example instance for clear printing and verification of the correct operators\n", + "circuit_measurement = prepare_measurement_rucl(g_spins)\n", + "print(circuit_measurement)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cca64bb2-0c8b-49a4-96e9-fc2a42ebc602", + "metadata": {}, + "outputs": [], + "source": [ + "g_spins = assign_spin_labels_rucl(32)\n", + "circuit_state_prep_and_measurement = prepare_initial_state_rucl(g_spins) + prepare_measurement_rucl(g_spins)\n", + "circuit_state_prep_and_measurement_cpt = clifford_plus_t_direct_transform(circuit_state_prep_and_measurement)\n", + "\n", + "def get_cpt_estimate(cpt_circuit, circuit_name=\"cpt_circuit\"):\n", + " t_count = count_T_gates(cpt_circuit)\n", + " gate_count = count_gates(cpt_circuit)\n", + " estimate = {'num_qubits': len(cpt_circuit.all_qubits()),\n", + " 't_count': t_count,\n", + " 't_depth': get_T_depth(cpt_circuit),\n", + " 't_depth_wire': get_T_depth_wire(cpt_circuit),\n", + " 'gate_count': gate_count,\n", + " 'clifford_count': gate_count - t_count,\n", + " 'circuit_depth': len(cpt_circuit),\n", + " 'circuit_name': circuit_name}\n", + " return estimate\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "77b46dea-f938-47d4-948e-beeffadcb0c3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'num_qubits': 2176,\n", + " 't_count': 13056,\n", + " 't_depth': 11,\n", + " 't_depth_wire': 6,\n", + " 'gate_count': 31520,\n", + " 'clifford_count': 18464,\n", + " 'circuit_depth': 15,\n", + " 'circuit_name': 'state preparation and measurement'}" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_cpt_estimate(circuit_state_prep_and_measurement_cpt, circuit_name = \"state preparation and measurement\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, "id": "2ff5148f-2d2a-41c8-b71c-a787f82f8d32", "metadata": { "tags": [] @@ -1033,7 +1346,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Total time to run notebook (only using the fastest row): 533.9890611250885\n" + "Total time to run notebook (only using the fastest row): 3250.381975843\n" ] } ], @@ -1050,19 +1363,11 @@ "### References\n", "[1] Laurell, P., Okamoto, S. Dynamical and thermal magnetic properties of the Kitaev spin liquid candidate α-RuCl3. npj Quantum Mater. 5, 2 (2020). https://doi.org/10.1038/s41535-019-0203-y" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4b08c06a-c632-41f9-a4cd-843b0108599c", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1076,7 +1381,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.11.5" } }, "nbformat": 4, From 2f154afa0ee7a35b88632bb2e3fa896bdf9dc6b9 Mon Sep 17 00:00:00 2001 From: Jonhas Colina <159941307+JonhasSC@users.noreply.github.com> Date: Wed, 13 Mar 2024 13:24:17 -0600 Subject: [PATCH 11/11] fixed gsee issue where it wasn't counting the current number of gates and depth for GSEE in the fermihubbard notebook (#12) --- ...HighTemperatureSuperConductorExample.ipynb | 63 ++++++++++++++----- src/qca/utils/utils.py | 63 +++++++++---------- 2 files changed, 77 insertions(+), 49 deletions(-) diff --git a/notebooks/HighTemperatureSuperConductorExample.ipynb b/notebooks/HighTemperatureSuperConductorExample.ipynb index b070443..55d81f7 100644 --- a/notebooks/HighTemperatureSuperConductorExample.ipynb +++ b/notebooks/HighTemperatureSuperConductorExample.ipynb @@ -29,9 +29,18 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jonhas/anaconda3/lib/python3.11/site-packages/attr/_make.py:918: RuntimeWarning: Running interpreter doesn't sufficiently support code object introspection. Some features like bare super() or accessing __class__ will not work with slotted classes.\n", + " set_closure_cell(cell, cls)\n" + ] + } + ], "source": [ "import time\n", "import numpy as np\n", @@ -43,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -67,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -155,7 +164,7 @@ "-1.0 [15^ 15]" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -171,7 +180,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -189,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -224,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -232,8 +241,8 @@ "output_type": "stream", "text": [ "starting\n", - "current limit time to generate high level: 0.16728520899778232\n", - "ideal time to generate high level: 0.9127594170131488\n" + "current limit time to generate high level: 0.17232737501035444\n", + "ideal time to generate high level: 0.9439791250042617\n" ] } ], @@ -282,30 +291,50 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Estimating Ideal\n", - "Time to estimate Ideal: 266.92374454200035\n", - "Estimating Current Limit\n", - "Time to estimate Current Limit: 55.14061645799666\n" + "Estimating Ideal\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[7], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mEstimating Ideal\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 2\u001b[0m t0 \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter()\n\u001b[0;32m----> 3\u001b[0m estimate_gsee(gse_circuit_ideal, outdir\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mGSE/\u001b[39m\u001b[38;5;124m'\u001b[39m, circuit_name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mideal\u001b[39m\u001b[38;5;124m'\u001b[39m, write_circuits\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m 4\u001b[0m t1 \u001b[38;5;241m=\u001b[39m time\u001b[38;5;241m.\u001b[39mperf_counter()\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mTime to estimate Ideal: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mt1\u001b[38;5;241m-\u001b[39mt0\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[0;32m~/qc-applications/src/qca/utils/utils.py:100\u001b[0m, in \u001b[0;36mestimate_gsee\u001b[0;34m(circuit, outdir, circuit_name, write_circuits)\u001b[0m\n\u001b[1;32m 98\u001b[0m subcircuit_counts[gate_type] \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 100\u001b[0m decomposed_circuit \u001b[38;5;241m=\u001b[39m circuit_decompose_once(circuit_decompose_once(Circuit(operation)))\n\u001b[1;32m 101\u001b[0m cpt_circuit \u001b[38;5;241m=\u001b[39m clifford_plus_t_direct_transform(decomposed_circuit)\n\u001b[1;32m 103\u001b[0m \u001b[38;5;66;03m# outfile_qasm_decomposed = outdir+str(gate_type)[8:-2]+\".decomposed.qasm\"\u001b[39;00m\n\u001b[1;32m 104\u001b[0m \u001b[38;5;66;03m# outfile_qasm_cpt = outdir+str(gate_type)[8:-2]+\".cpt.qasm\"\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/pyLIQTR/utils/qsp_helpers.py:382\u001b[0m, in \u001b[0;36mcircuit_decompose_once\u001b[0;34m(circuit, debug)\u001b[0m\n\u001b[1;32m 380\u001b[0m \u001b[38;5;28;01mcontinue\u001b[39;00m\n\u001b[1;32m 381\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 382\u001b[0m tmp_gates \u001b[38;5;241m=\u001b[39m cirq\u001b[38;5;241m.\u001b[39mdecompose_once(op)\n\u001b[1;32m 383\u001b[0m decomp_gates \u001b[38;5;241m=\u001b[39m []\n\u001b[1;32m 385\u001b[0m \u001b[38;5;66;03m# Note: If this decomposes into a MatrixGate, \u001b[39;00m\n\u001b[1;32m 386\u001b[0m \u001b[38;5;66;03m# lets decompose it once more so its not \u001b[39;00m\n\u001b[1;32m 387\u001b[0m \u001b[38;5;66;03m# a MatrixGate\u001b[39;00m\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/cirq/protocols/decompose_protocol.py:384\u001b[0m, in \u001b[0;36mdecompose_once\u001b[0;34m(val, default, flatten, context, *args, **kwargs)\u001b[0m\n\u001b[1;32m 381\u001b[0m decomposed \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mNotImplemented\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m method \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m method(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m 383\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m decomposed \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mNotImplemented\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m decomposed \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 384\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mlist\u001b[39m(ops\u001b[38;5;241m.\u001b[39mflatten_to_ops(decomposed)) \u001b[38;5;28;01mif\u001b[39;00m flatten \u001b[38;5;28;01melse\u001b[39;00m decomposed\n\u001b[1;32m 386\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m default \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m RaiseTypeErrorIfNotProvided:\n\u001b[1;32m 387\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m default\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/cirq/ops/op_tree.py:112\u001b[0m, in \u001b[0;36mflatten_to_ops\u001b[0;34m(root)\u001b[0m\n\u001b[1;32m 110\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m root\n\u001b[1;32m 111\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(root, Iterable) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(root, \u001b[38;5;28mstr\u001b[39m):\n\u001b[0;32m--> 112\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m subtree \u001b[38;5;129;01min\u001b[39;00m root:\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01myield from\u001b[39;00m flatten_to_ops(subtree)\n\u001b[1;32m 114\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/pyLIQTR/PhaseEstimation/pe_gates.py:117\u001b[0m, in \u001b[0;36mTrotter_Unitary._decompose_\u001b[0;34m(self, qubits)\u001b[0m\n\u001b[1;32m 115\u001b[0m jw_ham_trotterized_generator \u001b[38;5;241m=\u001b[39m trotterize_exp_qubop_to_qasm(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mjw_ham\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m(\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moperator_power, evolution_time\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mev_time, trotter_number\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrot_num, trotter_order\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtrot_ord)\n\u001b[1;32m 116\u001b[0m jw_ham_trotterized_circuit \u001b[38;5;241m=\u001b[39m open_fermion_to_qasm(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnum_qubits(), jw_ham_trotterized_generator, reg_name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mreg\u001b[39m\u001b[38;5;124m'\u001b[39m) \n\u001b[0;32m--> 117\u001b[0m tmp_circuit \u001b[38;5;241m=\u001b[39m qasm_import\u001b[38;5;241m.\u001b[39mcircuit_from_qasm(jw_ham_trotterized_circuit)\n\u001b[1;32m 119\u001b[0m \u001b[38;5;66;03m# Apply control operations on the z-rotations:\u001b[39;00m\n\u001b[1;32m 120\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m2\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprec_order):\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/cirq/contrib/qasm_import/qasm.py:29\u001b[0m, in \u001b[0;36mcircuit_from_qasm\u001b[0;34m(qasm)\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcircuit_from_qasm\u001b[39m(qasm: \u001b[38;5;28mstr\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m circuits\u001b[38;5;241m.\u001b[39mCircuit:\n\u001b[1;32m 20\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Parses an OpenQASM string to `cirq.Circuit`.\u001b[39;00m\n\u001b[1;32m 21\u001b[0m \n\u001b[1;32m 22\u001b[0m \u001b[38;5;124;03m Args:\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[38;5;124;03m The parsed circuit\u001b[39;00m\n\u001b[1;32m 27\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m---> 29\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m QasmParser()\u001b[38;5;241m.\u001b[39mparse(qasm)\u001b[38;5;241m.\u001b[39mcircuit\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/cirq/contrib/qasm_import/_parser.py:538\u001b[0m, in \u001b[0;36mQasmParser.parse\u001b[0;34m(self, qasm)\u001b[0m\n\u001b[1;32m 536\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mqasm \u001b[38;5;241m=\u001b[39m qasm\n\u001b[1;32m 537\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlexer\u001b[38;5;241m.\u001b[39minput(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mqasm)\n\u001b[0;32m--> 538\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparsedQasm \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparser\u001b[38;5;241m.\u001b[39mparse(lexer\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlexer)\n\u001b[1;32m 539\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparsedQasm\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/ply/yacc.py:333\u001b[0m, in \u001b[0;36mLRParser.parse\u001b[0;34m(self, input, lexer, debug, tracking, tokenfunc)\u001b[0m\n\u001b[1;32m 331\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparseopt(\u001b[38;5;28minput\u001b[39m, lexer, debug, tracking, tokenfunc)\n\u001b[1;32m 332\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 333\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparseopt_notrack(\u001b[38;5;28minput\u001b[39m, lexer, debug, tracking, tokenfunc)\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/ply/yacc.py:1063\u001b[0m, in \u001b[0;36mLRParser.parseopt_notrack\u001b[0;34m(self, input, lexer, debug, tracking, tokenfunc)\u001b[0m\n\u001b[1;32m 1061\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m lookahead:\n\u001b[1;32m 1062\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m lookaheadstack:\n\u001b[0;32m-> 1063\u001b[0m lookahead \u001b[38;5;241m=\u001b[39m get_token() \u001b[38;5;66;03m# Get the next token\u001b[39;00m\n\u001b[1;32m 1064\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 1065\u001b[0m lookahead \u001b[38;5;241m=\u001b[39m lookaheadstack\u001b[38;5;241m.\u001b[39mpop()\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/cirq/contrib/qasm_import/_lexer.py:124\u001b[0m, in \u001b[0;36mQasmLexer.token\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 123\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mtoken\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Optional[lex\u001b[38;5;241m.\u001b[39mToken]:\n\u001b[0;32m--> 124\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlex\u001b[38;5;241m.\u001b[39mtoken()\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/ply/lex.py:350\u001b[0m, in \u001b[0;36mLexer.token\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 347\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlexmatch \u001b[38;5;241m=\u001b[39m m\n\u001b[1;32m 348\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlexpos \u001b[38;5;241m=\u001b[39m lexpos\n\u001b[0;32m--> 350\u001b[0m newtok \u001b[38;5;241m=\u001b[39m func(tok)\n\u001b[1;32m 352\u001b[0m \u001b[38;5;66;03m# Every function must return a token, if nothing, we just move to next token\u001b[39;00m\n\u001b[1;32m 353\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m newtok:\n", + "File \u001b[0;32m~/anaconda3/lib/python3.11/site-packages/cirq/contrib/qasm_import/_lexer.py:110\u001b[0m, in \u001b[0;36mQasmLexer.t_ID\u001b[0;34m(self, t)\u001b[0m\n\u001b[1;32m 107\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"==\"\"\"\u001b[39;00m\n\u001b[1;32m 108\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m t\n\u001b[0;32m--> 110\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mt_ID\u001b[39m(\u001b[38;5;28mself\u001b[39m, t):\n\u001b[1;32m 111\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"[a-zA-Z][a-zA-Z\\d_]*\"\"\"\u001b[39;00m\n\u001b[1;32m 112\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m t\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ "print('Estimating Ideal')\n", "t0 = time.perf_counter()\n", - "estimate_gsee(gse_circuit_ideal, outdir='GSE/', circuit_name='ideal')\n", + "estimate_gsee(gse_circuit_ideal, outdir='GSE/', circuit_name='ideal', write_circuits=True)\n", "t1 = time.perf_counter()\n", "print(f'Time to estimate Ideal: {t1-t0}')\n", "\n", "print('Estimating Current Limit')\n", "t0 = time.perf_counter()\n", - "estimate_gsee(gse_circuit_current_limit, outdir='GSE/', circuit_name='current_limit')\n", + "estimate_gsee(gse_circuit_current_limit, outdir='GSE/', circuit_name='current_limit', write_circuits=True)\n", "t1 = time.perf_counter()\n", "print(f'Time to estimate Current Limit: {t1-t0}')" ] diff --git a/src/qca/utils/utils.py b/src/qca/utils/utils.py index 25ea43a..4f617ec 100644 --- a/src/qca/utils/utils.py +++ b/src/qca/utils/utils.py @@ -82,42 +82,41 @@ def estimate_gsee( write_circuits: bool = False) -> None: if not os.path.exists(outdir): os.makedirs(outdir) - - t_counts = {} - gate_counts = {} - clifford_counts = {} - subcircuit_counts = {} - subcircuit_depths = {} - + + subcircuit_counts = dict() + t_counts = dict() + clifford_counts = dict() + gate_counts = dict() + subcircuit_depths = dict() + outfile_data = f'{outdir}{circuit_name}_high_level.dat' - for moment in circuit: for operation in moment: gate_type = type(operation.gate) if gate_type in subcircuit_counts: subcircuit_counts[gate_type] += 1 else: - decomposed_circuit = circuit_decompose_once( - circuit_decompose_once(Circuit(operation))) - cpt_circuit = clifford_plus_t_direct_transform( - decomposed_circuit) - + decomposed_circuit = circuit_decompose_once(circuit_decompose_once(Circuit(operation))) + cpt_circuit = clifford_plus_t_direct_transform(decomposed_circuit) + + outfile_qasm_decomposed = f'{outdir}{str(gate_type)[8:-2]}.decomposed.qasm' + outfile_qasm_cpt = f'{outdir}{str(gate_type)[8:-2]}.cpt.qasm' + if write_circuits: - outfile_qasm_decomposed = f'{outdir}{str(gate_type)[8:-2]}.decomposed.qasm' - outfile_qasm_cpt = f'{outdir}{str(gate_type)[8:-2]}.cpt.qasm' QasmOutput( decomposed_circuit, decomposed_circuit.all_qubits()).save(outfile_qasm_decomposed) + QasmOutput(cpt_circuit, cpt_circuit.all_qubits()).save(outfile_qasm_cpt) - + subcircuit_counts[gate_type] = 1 subcircuit_depths[gate_type] = len(cpt_circuit) t_counts[gate_type] = count_T_gates(cpt_circuit) gate_counts[gate_type] = count_gates(cpt_circuit) - clifford_counts[gate_type] = gate_counts[gate_type] - \ - t_counts[gate_type] - + clifford_counts[gate_type] = gate_counts[gate_type] - t_counts[gate_type] + + total_gate_count = 0 total_gate_depth = 0 total_T_count = 0 @@ -127,17 +126,17 @@ def estimate_gsee( total_gate_depth += subcircuit_counts[gate] * subcircuit_depths[gate] total_T_count += subcircuit_counts[gate] * t_counts[gate] total_clifford_count += subcircuit_counts[gate] * clifford_counts[gate] - with open(outfile_data, 'w', encoding='utf-8') as file: - file.write(f'Logical Qubit Count: {len(circuit.all_qubits())}\n') - file.write(f'Total Gate Count: {total_gate_count}\n') - file.write(f'Total Gate Depth: {total_gate_depth}\n') - file.write(f'Total T Count: {total_T_count}\n') - file.write(f'Total Clifford Count: {total_clifford_count}\n') - file.write('Subcircuit Info:\n') + with open(outfile_data, 'w') as f: + f.write(str("Logical Qubit Count:"+str(len(circuit.all_qubits()))+"\n")) + f.write(str("Total Gate Count:"+str(total_gate_count)+"\n")) + f.write(str("Total Gate Depth:"+str(total_gate_depth)+"\n")) + f.write(str("Total T Count:"+str(total_T_count)+"\n")) + f.write(str("Total Clifford Count:"+str(total_clifford_count)+"\n")) + f.write("Subcircuit Info:\n") for gate in subcircuit_counts: - file.write(f'{gate}\n') - file.write(f'Subcircuit Occurrences: {subcircuit_counts[gate]}\n') - file.write(f'Gate count: {gate_counts[gate]}\n') - file.write(f'Gate depth: {subcircuit_counts[gate]}\n') - file.write(f'T Count: {t_counts[gate]}\n') - file.write(f'Clifford Count: {clifford_counts[gate]}\n') + f.write(str(str(gate)+"\n")) + f.write(str("Subcircuit Occurrences:"+str(subcircuit_counts[gate])+"\n")) + f.write(str("Gate Count:"+str(gate_counts[gate])+"\n")) + f.write(str("Gate Depth:"+str(subcircuit_depths[gate])+"\n")) + f.write(str("T Count:"+str(t_counts[gate])+"\n")) + f.write(str("Clifford Count:"+str(clifford_counts[gate])+"\n")) \ No newline at end of file