diff --git a/.github/workflows/Internal-automatic-deployment.yml b/.github/workflows/Internal-automatic-deployment.yml index 936acfa73..a3abce596 100644 --- a/.github/workflows/Internal-automatic-deployment.yml +++ b/.github/workflows/Internal-automatic-deployment.yml @@ -11,14 +11,14 @@ on: jobs: deploy-prod: if: github.event.pull_request.merged == true && github.event.pull_request.base.ref == 'main' - uses: ./.github/workflows/deployment-qmod.yml + uses: ./.github/workflows/Utils-deployment-qmod.yml with: deploy-mode: production secrets: inherit deploy-dev: if: github.event.pull_request.merged == true && github.event.pull_request.base.ref == 'dev' - uses: ./.github/workflows/deployment-qmod.yml + uses: ./.github/workflows/Utils-deployment-qmod.yml with: deploy-mode: staging secrets: inherit diff --git a/.github/workflows/Test-CI-dev-daily.yml b/.github/workflows/Test-CI-dev-daily.yml index 18c07ed5f..833f0e138 100644 --- a/.github/workflows/Test-CI-dev-daily.yml +++ b/.github/workflows/Test-CI-dev-daily.yml @@ -32,13 +32,6 @@ jobs: - name: Debug run: git status - - name: Install dependencies - run: | - set -e - python -m pip install -U pip - python -m pip install --extra-index-url https://pypi.org/simple --pre -U -r requirements.txt - python -m pip install --extra-index-url https://pypi.org/simple -U -r requirements_tests.txt - # Configure AWS credentials - name: Configure AWS Credentials uses: aws-actions/configure-aws-credentials@v4.0.2 @@ -47,6 +40,30 @@ jobs: aws-region: us-east-1 mask-aws-account-id: true + - name: Install dependencies + run: | + set -e + python -m pip install -U pip \ + --extra-index-url https://pypi.org/simple + # Install "classiq" separately + export CODEARTIFACT_AUTH_TOKEN="$( \ + aws codeartifact get-authorization-token \ + --domain ${{ secrets.CODEARTIFACT_DOMAIN }} \ + --domain-owner ${{ secrets.CODEARTIFACT_OWNER }} \ + --region ${{ secrets.CODEARTIFACT_REGION }} \ + --query authorizationToken \ + --output text \ + )" + python -m pip install -U --pre \ + --extra-index-url "https://aws:$CODEARTIFACT_AUTH_TOKEN@${{ secrets.CODEARTIFACT_DOMAIN }}-${{ secrets.CODEARTIFACT_OWNER }}.d.codeartifact.${{ secrets.CODEARTIFACT_REGION }}.amazonaws.com/pypi/${{ secrets.PYPI_NIGHTLY_NAME }}/simple/" \ + --extra-index-url https://pypi.org/simple \ + classiq + # Install everything from the requirements, other than "classiq". + python -m pip install -U $(grep -ivE "classiq" requirements.txt) \ + --extra-index-url https://pypi.org/simple + python -m pip install -U -r requirements_tests.txt \ + --extra-index-url https://pypi.org/simple + # Set authentication with M2M token - name: Set authentication run: .github/scripts/get_m2m_token.sh diff --git a/.github/workflows/Test-CI-dev.yml b/.github/workflows/Test-CI-dev.yml index abb4fd695..aee576ca4 100644 --- a/.github/workflows/Test-CI-dev.yml +++ b/.github/workflows/Test-CI-dev.yml @@ -81,15 +81,6 @@ jobs: with: python-version: "3.11" - - name: Install dependencies - if: steps.cache-pip.outputs.cache-hit != 'true' - run: | - set -e - python -m pip install -U pip - # The `--pre` allows the installation of pre-release versions of packages (needed for Dev) - python -m pip install --extra-index-url https://pypi.org/simple --pre -U -r requirements.txt - python -m pip install --extra-index-url https://pypi.org/simple -U -r requirements_tests.txt - # # Setup Environment # @@ -101,6 +92,30 @@ jobs: aws-region: us-east-1 mask-aws-account-id: true + - name: Install dependencies + run: | + set -e + python -m pip install -U pip \ + --extra-index-url https://pypi.org/simple + # Install "classiq" separately + export CODEARTIFACT_AUTH_TOKEN="$( \ + aws codeartifact get-authorization-token \ + --domain ${{ secrets.CODEARTIFACT_DOMAIN }} \ + --domain-owner ${{ secrets.CODEARTIFACT_OWNER }} \ + --region ${{ secrets.CODEARTIFACT_REGION }} \ + --query authorizationToken \ + --output text \ + )" + python -m pip install -U --pre \ + --extra-index-url "https://aws:$CODEARTIFACT_AUTH_TOKEN@${{ secrets.CODEARTIFACT_DOMAIN }}-${{ secrets.CODEARTIFACT_OWNER }}.d.codeartifact.${{ secrets.CODEARTIFACT_REGION }}.amazonaws.com/pypi/${{ secrets.PYPI_NIGHTLY_NAME }}/simple/" \ + --extra-index-url https://pypi.org/simple \ + classiq + # Install everything from the requirements, other than "classiq". + python -m pip install -U $(grep -ivE "classiq" requirements.txt) \ + --extra-index-url https://pypi.org/simple + python -m pip install -U -r requirements_tests.txt \ + --extra-index-url https://pypi.org/simple + # Set authentication with M2M token - name: Set authentication run: .github/scripts/get_m2m_token.sh diff --git a/algorithms/algebraic/hidden_shift/hidden_shift.ipynb b/algorithms/algebraic/hidden_shift/hidden_shift.ipynb index 5f106413b..c67139271 100644 --- a/algorithms/algebraic/hidden_shift/hidden_shift.ipynb +++ b/algorithms/algebraic/hidden_shift/hidden_shift.ipynb @@ -63,9 +63,7 @@ { "name": "stdout", "output_type": "stream", - "text": [ - "" - ] + "text": [] } ], "source": [ @@ -253,8 +251,7 @@ "output_type": "stream", "text": [ "f_dual: (((((((((x[5]) & (y[0])) ^ ((x[2]) & (y[1]))) ^ ((x[7]) & (y[2]))) ^ ((x[0]) & (y[3]))) ^ ((x[6]) & (y[4]))) ^ ((x[3]) & (y[5]))) ^ ((x[1]) & (y[6]))) ^ ((x[4]) & (y[7]))) ^ ((((((((x[5]) & (x[2])) & (x[7])) & (x[0])) & (x[6])) & (x[3])) & (x[1])) & (x[4]))\n", - "g: (((((((((x[0]) & (y[3])) ^ (((x[1]) ^ 1) & (y[6]))) ^ ((x[2]) & ((y[1]) ^ 1))) ^ (((x[3]) ^ 1) & (y[5]))) ^ ((x[4]) & (y[7]))) ^ ((x[5]) & (y[0]))) ^ ((x[6]) & (y[4]))) ^ ((x[7]) & (y[2]))) ^ ((((((((y[0]) & ((y[1]) ^ 1)) & (y[2])) & (y[3])) & (y[4])) & (y[5])) & (y[6])) & (y[7]))\n", - "" + "g: (((((((((x[0]) & (y[3])) ^ (((x[1]) ^ 1) & (y[6]))) ^ ((x[2]) & ((y[1]) ^ 1))) ^ (((x[3]) ^ 1) & (y[5]))) ^ ((x[4]) & (y[7]))) ^ ((x[5]) & (y[0]))) ^ ((x[6]) & (y[4]))) ^ ((x[7]) & (y[2]))) ^ ((((((((y[0]) & ((y[1]) ^ 1)) & (y[2])) & (y[3])) & (y[4])) & (y[5])) & (y[6])) & (y[7]))\n" ] } ], @@ -389,8 +386,7 @@ "output_type": "stream", "text": [ "f: (((((((((x[0]) & (y[3])) ^ ((x[1]) & (y[6]))) ^ ((x[2]) & (y[1]))) ^ ((x[3]) & (y[5]))) ^ ((x[4]) & (y[7]))) ^ ((x[5]) & (y[0]))) ^ ((x[6]) & (y[4]))) ^ ((x[7]) & (y[2]))) ^ ((((((((y[0]) & (y[1])) & (y[2])) & (y[3])) & (y[4])) & (y[5])) & (y[6])) & (y[7]))\n", - "g: (((((((((x[0]) & (y[3])) ^ (((x[1]) ^ 1) & (y[6]))) ^ ((x[2]) & ((y[1]) ^ 1))) ^ (((x[3]) ^ 1) & (y[5]))) ^ ((x[4]) & (y[7]))) ^ ((x[5]) & (y[0]))) ^ ((x[6]) & (y[4]))) ^ ((x[7]) & (y[2]))) ^ ((((((((y[0]) & ((y[1]) ^ 1)) & (y[2])) & (y[3])) & (y[4])) & (y[5])) & (y[6])) & (y[7]))\n", - "" + "g: (((((((((x[0]) & (y[3])) ^ (((x[1]) ^ 1) & (y[6]))) ^ ((x[2]) & ((y[1]) ^ 1))) ^ (((x[3]) ^ 1) & (y[5]))) ^ ((x[4]) & (y[7]))) ^ ((x[5]) & (y[0]))) ^ ((x[6]) & (y[4]))) ^ ((x[7]) & (y[2]))) ^ ((((((((y[0]) & ((y[1]) ^ 1)) & (y[2])) & (y[3])) & (y[4])) & (y[5])) & (y[6])) & (y[7]))\n" ] } ], @@ -589,7 +585,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/algorithms/algebraic/shor/shor_modular_exponentiation.ipynb b/algorithms/algebraic/shor/shor_modular_exponentiation.ipynb index 30dbe04b2..203ed5548 100644 --- a/algorithms/algebraic/shor/shor_modular_exponentiation.ipynb +++ b/algorithms/algebraic/shor/shor_modular_exponentiation.ipynb @@ -175,7 +175,7 @@ "metadata": {}, "outputs": [], "source": [ - "from classiq.qmod import QNum, bind, control, within_apply\n", + "from classiq import *\n", "from classiq.qmod.builtins.classical_functions import qft_const_adder_phase\n", "\n", "\n", @@ -256,7 +256,7 @@ }, "outputs": [], "source": [ - "from classiq.qmod import QNum, inplace_prepare_int\n", + "from classiq import *\n", "\n", "modulo_num = 15\n", "reg_len = math.ceil(math.log(modulo_num, 2)) + 1\n", @@ -441,7 +441,7 @@ "metadata": {}, "outputs": [], "source": [ - "from classiq.qmod import SWAP, free\n", + "from classiq import *\n", "from classiq.qmod.symbolic import min, mod_inverse\n", "\n", "\n", @@ -535,7 +535,7 @@ "metadata": {}, "outputs": [], "source": [ - "from classiq.qmod import hadamard_transform\n", + "from classiq import *\n", "\n", "modulo_num = 6\n", "reg_len = math.ceil(math.log(modulo_num, 2)) + 1\n", diff --git a/algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.ipynb b/algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.ipynb index f54391b9e..5b88ac02b 100644 --- a/algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.ipynb +++ b/algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.ipynb @@ -5,9 +5,9 @@ "id": "456a591a-6383-45cf-ac3e-cca3014edf6b", "metadata": {}, "source": [ - "# Introducing quantum functions with Quantum Monte Carlo Integration\n", + "# Introducing Quantum Functions with Quantum Monte Carlo Integration\n", "\n", - "In this tutorial we introduce how to write custom quantum functions with Classiq, and subsequently use them for more complex functions/algorithms. This will be illustrated on a specific use-case of Quantum Monte Carlo Integration (QMCI). The example below demonstrates how we can exploit various concepts of modeling quantum algorithms with Classiq when building our own functions." + "This tutorial explains how to write custom quantum functions with Classiq and subsequently uses them for more complex functions or algorithms. This is illustrated on a specific use case of Quantum Monte Carlo Integration (QMCI). The example below demonstrates how we can exploit various concepts of modeling quantum algorithms with Classiq when building our own functions." ] }, { @@ -25,7 +25,7 @@ "\\tag{1}\n", "E_{p}(x) = \\int f(x)p(x) dx.\n", "\\end{equation}\n", - "Such evaluations appear in the context of option-pricing or credit risk-analysis.\n", + "Such evaluations appear in the context of option pricing or credit risk analysis.\n", "\n", "The basic idea of QMCI assumes that we have a quantum function $A$, which, for a given $f$ and $p$, loads the following state of $n+1$ qubits:\n", "\\begin{align}\n", @@ -33,18 +33,18 @@ "A|0\\rangle_n|0\\rangle = \\sum^{2^n-1}_{i=0} \\sqrt{f_i} \\sqrt{p_i}|i\\rangle_n|1\\rangle + \\sum^{2^n-1}_{i=0} \\sqrt{1-f_i} \\sqrt{p_i}|i\\rangle_n|0\\rangle = \\sqrt{a}|\\psi_1\\rangle+\\sqrt{1-a^2}|\\psi_0\\rangle,\n", "\\end{align}\n", "where it is understood that the first $2^n$ states represent a discretized space of $x$, and that $0\\leq f(x)\\leq 1$.\n", - "Then, by applying Amplitude Estimation (AE) algorithm for the \"good-state\" $|\\psi_1 \\rangle$, we can estimate its amplitude\n", + "Then, by applying the amplitude estimation (AE) algorithm for the \"good-state\" $|\\psi_1 \\rangle$, we can estimate its amplitude:\n", "$$\n", "a = \\sum^{2^n-1}_{i=0} f_i p_i.\n", "$$\n", "\n", "The QMCI algorithm can be separated into two parts:\n", - "1) Constructing a Grover operator for the specific problem--- this will be done here almost from scratch.\n", - "2) Applying AE algorithm based on the Grover operator [[1](#AE)]--- this will be done by calling Classiq's Quantum Phase Estimation (QPE) function.\n", + "1) Constructing a Grover operator for the specific problem. This is done here almost from scratch.\n", + "2) Applying the AE algorithm based on the Grover operator [[1](#AE)]. This is done by calling the Classiq Quantum Phase Estimation (QPE) function.\n", "\n", - "### Specific use-case for the tutorial\n", + "### Specific Use Case for the Tutorial\n", "\n", - "For simplicity we will consider a simple use-case. We take a probability distribution on the integers\n", + "For simplicity we consider a simple use case. We take a probability distribution on the integers\n", "$$\n", "\\tag{3}\n", "p_i = \\frac{i}{\\mathcal{N}} \\text{ for } i\\in \\{0,\\dots 2^3-1\\},\n", @@ -54,7 +54,7 @@ "\\tag{4}\n", "f(x) = \\sin^2(0.25x+0.2).\n", "$$\n", - "Therefore, the value we want to evaluate is:\n", + "Therefore, the value we want to evaluate is\n", "$$\n", "a= \\frac{1}{\\mathcal{N}} \\sum^7_{k=0} \\sin^2(0.25k+0.2) k \\approx 0.834.\n", "$$" @@ -65,16 +65,16 @@ "id": "c810e0d5-6fda-4868-aab9-ff036ff8974e", "metadata": {}, "source": [ - "## 1. Building the corresponding Grover Operator \n", + "## 1. Building the Corresponding Grover Operator \n", "\n", "### Quantum Functions\n", "\n", - "The following example will demonstrate how to define QMOD functions by writing a Python function decorated with the `@qfunc` decorator.\n", + "This example demonstrates how to define Qmod functions by writing a Python function decorated with the `@qfunc` decorator.\n", "The typical workflow for defining a quantum function:\n", - "1. Specifying the function signature: The `@qfunc` decorator relies on Python's type-hint mechanism to extract the signature of the QMOD function from the argument list of the Python function.\n", - "2. Specifying the function body: A function decorated with `@qfunc` is executed by the Python interpreter to construct the body of the QMOD function. Inside it, you can do one of the following:\n", - " - Call other `@qfuncs` to insert the corresponding quantum function calls into the body of the resulting QMOD function\n", - " - Introduce local quantum variables, by instantiating a quantum type\n", + "1. Specifying the function signature: The `@qfunc` decorator relies on Python's type-hint mechanism to extract the signature of the Qmod function from the argument list of the Python function.\n", + "2. Specifying the function body: To construct the body of the Qmod function, the Python interpreter executes a function decorated with `@qfunc`. Inside, you can do one of these:\n", + " - Call other `@qfuncs` to insert the corresponding quantum function calls into the body of the resulting Qmod function\n", + " - Introduce local quantum variables by instantiating a quantum type\n", " - Use arithmetic and in-place assignment operators to insert special quantum statements into the function\n", " " ] @@ -84,7 +84,7 @@ "id": "d259adad-9b69-4602-932b-97d98b546503", "metadata": {}, "source": [ - "We can start with relevant imports" + "We can start with relevant imports:" ] }, { @@ -106,7 +106,7 @@ "id": "c2be12ee-3d17-49df-a69f-efab41b60b29", "metadata": {}, "source": [ - "### Grover operator for QMCI\n", + "### Grover Operator for QMCI\n", "\n", "The Grover operator suitable for QMCI is defined as follows:\n", "$$\n", @@ -114,7 +114,7 @@ "$$\n", "with $S_0$ and $S_{\\psi_1}$ being reflection operators around the zero state $|0\\rangle_n|0\\rangle$ and the good-state $|\\psi_1\\rangle$, respectively, and the function $A$ is defined in Eq. ([2](#mjx-eqn-2)).\n", "\n", - "In subsections (1.1)-(1.3) below we build each of the quantum sub-functions, and then in subsection (1.4) we combine them to define a complete Grover operator. On the way we introduce several concepts of functional modeling which allow Classiq's Synthesis Engine to reach better optimized circuits. " + "In subsections (1.1)-(1.3) below we build each of the quantum sub-functions, and then in subsection (1.4) we combine them to define a complete Grover operator. On the way we introduce several concepts of functional modeling, which allow the Classiq synthesis engine to reach better optimized circuits. " ] }, { @@ -122,9 +122,9 @@ "id": "a2c31065-077a-475a-ba06-af9b10a396d5", "metadata": {}, "source": [ - "#### 1.1) The state loading $A$ function\n", + "#### 1.1) The State Loading $A$ Function\n", "\n", - "We start with constructing the $A$ operator in Eq. ([2](#mjx-eqn-2)). We define a quantum function and give it the name `state_loading`" + "We start with constructing the $A$ operator in Eq. ([2](#mjx-eqn-2)). We define a quantum function and give it the name `state_loading`." ] }, { @@ -133,7 +133,7 @@ "metadata": {}, "source": [ "The function's signature declares two arguments: \n", - "1. A quantum register `io` declared as `QArray[QBit]` (an array of qubits with an unspecified size): will be used to represent the discretization of space\n", + "1. A quantum register `io` declared as `QArray[QBit]` (an array of qubits with an unspecified size) that is used to represent the discretization of space.\n", "2. A quantum register `ind` of size 1 declared as `QBit` to indicate the good state. " ] }, @@ -143,19 +143,19 @@ "metadata": {}, "source": [ "Next, we construct the logic flow of the `state_loading` function. \n", - "The function body consists of 2 quantum function calls: `load_probabilities` followed by `amplitude_loading`\n", + "The function body consists of two quantum function calls:\n", "\n", - "- As can be seen from Eq. ([2](#mjx-eqn-2)), the `load_probabilities` function is constructed using Classiq's `inplace_prepare_state` function call on $n=3$ qubits with probabilities $p_i$ \n", - "- The `amplitude_loading` body consists of a function call to Classiq's `linear_pauli_rotations`. The `linear_pauli_rotations` is used to load the amplitude of the function $ f(x) = sin^2(0.25 x + 0.2) $.\n", + "1. As can be seen from Eq. ([2](#mjx-eqn-2)), the `load_probabilities` function is constructed using the Classiq `inplace_prepare_state` function call on $n=3$ qubits with probabilities $p_i$. \n", + "2. The `amplitude_loading` body calls the Classiq `linear_pauli_rotations` function. The `linear_pauli_rotations` loads the amplitude of the function $ f(x) = sin^2(0.25 x + 0.2) $.\n", "\n", - " *Note: the amplitude should be $sin$ so the probability would be $sin^2$.*\n", + " *Note: The amplitude should be $sin$ so the probability is $sin^2$.*\n", "\n", - " The function uses an auxiliary qubit that is utilized so that the desired probability will reflect on the auxiliary qubit if it is in the `|1>` state.\n", + " The function uses an auxiliary qubit that is utilized so that the desired probability reflects on the auxiliary qubit if it is in the `|1>` state.\n", "\n", - " We will use the function with the Pauli Y matrix and enter the appropriate slope and offset to achieve the right parameters.\n", + " We use the function with the Pauli Y matrix and enter the appropriate slope and offset to achieve the right parameters.\n", "\n", "\n", - "We will define the probabilities according to our specific problem described by Eqs. ([3](#mjx-eqn-3)-[4](#mjx-eqn-4))" + "We define the probabilities according to the specific problem described by Eqs. ([3](#mjx-eqn-3)-[4](#mjx-eqn-4))." ] }, { @@ -200,7 +200,7 @@ "id": "d06ba0e3-bbac-45d4-8ff5-46158b4038c8", "metadata": {}, "source": [ - "To examine our function we define a quantum `main` function from which we can build a model, synthesize and view the quantum program created:" + "To examine our function we define a quantum `main` function from which we can build a model, synthesize, and view the quantum program created:" ] }, { @@ -214,9 +214,7 @@ { "name": "stdout", "output_type": "stream", - "text": [ - "" - ] + "text": [] } ], "source": [ @@ -237,9 +235,9 @@ "id": "59b38acb-9ca9-4cfd-b87a-4208c75c63ca", "metadata": {}, "source": [ - "#### 1.2) $S_{\\psi_1}$ function - The good state oracle\n", + "#### 1.2) $S_{\\psi_1}$ Function - The Good State Oracle\n", "\n", - "The next quantum function we define is the one which reflects around the good state: any $n+1$ state in which the `ind` register is at state $|1\\rangle$. This function can be simply constructed with a ZGate on the `ind` register. \n" + "The next quantum function we define is the one that reflects around the good state: any $n+1$ state in which the `ind` register is at state $|1\\rangle$. This function can be constructed with a ZGate on the `ind` register. \n" ] }, { @@ -261,13 +259,13 @@ "id": "fcc22b6c-8c2d-4ac9-ba63-c66416d40af9", "metadata": {}, "source": [ - "#### 1.3) $S_{0}$ function - The Grover Diffuser\n", + "#### 1.3) $S_{0}$ Function - The Grover Diffuser\n", "\n", - "In order to implement the Grover Diffuser we aim to perform a controlled-Z operation on the $|0>^n$ state.\n", + "To implement the Grover Diffuser we aim to perform a controlled-Z operation on the $|0>^n$ state.\n", "\n", "We can define a `zero_oracle` quantum function with the `io` and `ind` registers as its arguments. \n", "\n", - "The `within_apply` operator takes two function arguments - compute and action, and invokes the sequence compute(), action(), and invert(compute()). Quantum objects that are allocated and prepared by compute are subsequently uncomputed and released.\n", + "The `within_apply` operator takes two function arguments—compute and action—and invokes the sequence `compute()`, `action()`, and `invert(compute())`. Quantum objects that are allocated and prepared by compute are subsequently uncomputed and released.\n", "\n", "The `control` condition is a logical expression over a quantum variable. Currently, expressions are restricted to the form ` == `, where both `` and `` are integer types." ] @@ -295,7 +293,7 @@ "id": "a8a9636f-0007-4ca8-98d5-6a1ce7002820", "metadata": {}, "source": [ - "One can verify that:\n", + "We can verify that\n", "\\begin{eqnarray}\n", "|00\\dots0\\rangle \\xrightarrow[{\\rm ctrl(-Z)(target=q_0, ctrl=q_1\\dots q_n)}]{} -|00\\dots0\\rangle, \\\\\n", "|10\\dots0\\rangle \\xrightarrow[{\\rm ctrl(-Z)(target=q_0, ctrl=q_1\\dots q_n)}]{} |10\\dots0\\rangle, \\\\\n", @@ -311,12 +309,12 @@ "id": "52d45da1-8090-4e60-beed-9e4b3c57d929", "metadata": {}, "source": [ - "#### 1.4) $Q$ function - The Grover operator\n", + "#### 1.4) $Q$ Function - The Grover Operator\n", "\n", - "We can now define a complete Grover operator $Q\\equiv -S_{\\psi_1} A^{\\dagger} S_0 A$. We will do this in a single code block that will call the following:\n", + "We can now define a complete Grover operator $Q\\equiv -S_{\\psi_1} A^{\\dagger} S_0 A$. We do this in a single code block that calls the following:\n", "1. The good state oracle (`good_state_oracle`)\n", "2. THe inverse of the state preparation (`state_loading`)\n", - "3. The Diffuser (`zero_oracle`)\n", + "3. The diffuser (`zero_oracle`)\n", "4. The state preparation (`state_loading`)\n", " \n", "*Note:*\n", @@ -352,7 +350,7 @@ "id": "0f4ffdde-0c92-436a-a28c-65cf843162de", "metadata": {}, "source": [ - "##### Let us look at the `my_grover_operator` function we created" + "##### Let us look at the `my_grover_operator` function we created:" ] }, { @@ -366,9 +364,7 @@ { "name": "stdout", "output_type": "stream", - "text": [ - "" - ] + "text": [] } ], "source": [ @@ -394,14 +390,14 @@ "source": [ "## 2. Applying Amplitude Estimation (AE) with Quantum Phase Estimation (QPE)\n", "\n", - "Below we apply a basic AE algorithm which is based on QPE. The idea behind this Algorithm is the following:\n", + "Here we apply a basic AE algorithm that is based on QPE. The idea behind this algorithm is the following:\n", "\n", "The state $A|0\\rangle_n|0\\rangle$ is spanned by two eigenvectors of our Grover operator $Q$, with the two corresponding eigenvalues\n", "\\begin{equation}\n", "\\tag{5}\n", "\\lambda_{\\pm}=\\exp\\left(\\pm i2\\pi \\theta \\right), \\qquad \\sin^2 \\left(\\pi \\theta\\right)\\equiv a.\n", "\\end{equation}\n", - "Therefore, if we apply a QPE on $A|0\\rangle_n|0\\rangle$ we will have these two eigenvalues encoded in the QPE register, however, both give the value of $a$, so there is no ambiguity here." + "Therefore, if we apply a QPE on $A|0\\rangle_n|0\\rangle$, we have these two eigenvalues encoded in the QPE register. However, both give the value of $a$, so there is no ambiguity." ] }, { @@ -409,7 +405,7 @@ "id": "225566be-8c41-4d7a-abc6-ef3bb83a885b", "metadata": {}, "source": [ - "To find $a$ we are going to build a simple quantum model: we apply $A$ on a quantum register of size $n+1$ initialized to zero, and then apply Classiq's QPE with the `my_grover_operator` we defined." + "To find $a$ we build a simple quantum model, applying $A$ on a quantum register of size $n+1$ initialized to zero, and then applying the Classiq QPE with the `my_grover_operator` we defined." ] }, { @@ -417,7 +413,7 @@ "id": "e0605069-5062-4f01-92f8-a6b599c7e4bd", "metadata": {}, "source": [ - "Below is the `main` function from which we can build our model and synthesize it. In particular, we define the output register `phase` as `QNum` to hold the phase register output of the QPE. We choose a QPE with phase register of size 3, governing the accuracy of our Phase-, and thus Amplitude-, Estimation. " + "Below is the `main` function from which we can build our model and synthesize it. In particular, we define the output register `phase` as `QNum` to hold the phase register output of the QPE. We choose a QPE with phase register of size 3, governing the accuracy of our phase-, and thus amplitude-, estimation. " ] }, { @@ -429,9 +425,7 @@ { "name": "stdout", "output_type": "stream", - "text": [ - "" - ] + "text": [] } ], "source": [ @@ -463,7 +457,7 @@ "id": "14f3bf9f-4740-4849-896d-b9cb0dd064cb", "metadata": {}, "source": [ - "We can simply export our model to a `.qmod` file:" + "We can export our model to a `.qmod` file:" ] }, { @@ -481,9 +475,9 @@ "id": "94b452a3-7a47-440d-9c9a-bf88c9f5d3fd", "metadata": {}, "source": [ - "### Finally, we execute the circuit and measure the approximated amplitude\n", + "### Executing the Circuit and Measuring the Approximated Amplitude\n", "\n", - "We start with a simple execution on a simulator" + "We execute on a simulator:" ] }, { @@ -525,7 +519,7 @@ "id": "cee12720-1205-40d6-970f-eb36e76911ad", "metadata": {}, "source": [ - "Plotting the resulting histogram we see two phase values with high probability (however, both corresponds to the same amplitude $a$)" + "Upon plotting the resulting histogram we see two phase values with high probability (however, both correspond to the same amplitude $a$):" ] }, { @@ -565,7 +559,7 @@ "id": "e75fe2d0-3e27-48e6-b8ee-0b9a33b7eb12", "metadata": {}, "source": [ - "Recall the relation in Eq. ([5](#mjx-eqn-5)), we can read the amplitude $a$ from the phase with max probability, and compare to the expected amplitude:" + "Recalling the relation in Eq. ([5](#mjx-eqn-5)), we can read the amplitude $a$ from the phase with maximum probability and compare to the expected amplitude:" ] }, { diff --git a/algorithms/differential_equations/discrete_poisson_solver/discrete_poisson_solver.qmod b/algorithms/differential_equations/discrete_poisson_solver/discrete_poisson_solver.qmod index dbe6fd199..2b8392dd1 100644 --- a/algorithms/differential_equations/discrete_poisson_solver/discrete_poisson_solver.qmod +++ b/algorithms/differential_equations/discrete_poisson_solver/discrete_poisson_solver.qmod @@ -3,10 +3,6 @@ qfunc qsct_2d(xy_variable: qnum[2]) { qct_type2(xy_variable[1]); } -qfunc powered_hamiltonian_evolution(hamiltonian: PauliTerm[], scaling: real, p: int, qba: qbit[]) { - suzuki_trotter(hamiltonian, p * ((-6.28318530718) * scaling), 1, 1, qba); -} - qfunc inverse_amplitude_load(prefactor: real, phase: qnum, ind: qbit) { ind *= prefactor / phase; } @@ -22,6 +18,10 @@ qfunc matrix_inversion_HHL(prefactor: real, my_unitary: qfunc (int, qbit[]), sta } } +qfunc powered_hamiltonian_evolution(hamiltonian: PauliTerm[], scaling: real, p: int, qba: qbit[]) { + suzuki_trotter(hamiltonian, p * ((-6.28318530718) * scaling), 1, 1, qba); +} + qfunc main(output x_variable: qnum<3, False, 0>, output y_variable: qnum<3, False, 0>, output phase: qnum, output indicator: qbit) { xy_variable: qnum<3, False, 0>[2]; prepare_amplitudes([ diff --git a/algorithms/differential_equations/time_marching/time_marching.ipynb b/algorithms/differential_equations/time_marching/time_marching.ipynb new file mode 100644 index 000000000..6190757c8 --- /dev/null +++ b/algorithms/differential_equations/time_marching/time_marching.ipynb @@ -0,0 +1,1066 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0ab83a69-09e2-4df1-a7ee-3a5b45e590cf", + "metadata": {}, + "source": [ + "# Time-Marching based Quantum Solvers for Time-dependent Linear Differential Equations" + ] + }, + { + "cell_type": "markdown", + "id": "b94080f2-e474-462d-8b54-b107026f4bca", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "In the following demonstration we will follow the paper [[1](#TimeMarching)]. The notebook was written in collaboration with Prof. Di Fang, the first author of the paper.\n", + "\n", + "Time marching is a method in which in order to solve differential equations in time, the solution vector is integrated through time by small discrete steps, where each timestep depends on some previous timesteps. In this paper, an evolution matrix is applied sequentially on the state and make it to evolve through time, as done in time-dependent hamiltonian simulation. \n", + "\n", + "Now let's deffine the problem first:\n", + "\n", + "* **Input:** a system of linear homogenous linear equations (ODEs)\n", + "$$\\frac{d}{dt} |\\psi(t)\\rangle = A(t) |\\psi(t)\\rangle, \\quad |\\psi(0)\\rangle = |\\psi_0\\rangle$$ Notice that $A$ can vary on time. The matrix $A$ is assumed to be with bounded variation. The input model of $A(t)$ is a series of time dependent block encodings, that will be described next.\n", + "\n", + "* **Output:** a state that is proportional to the solution at time $T$, $|\\psi(T)\\rangle$\n", + "\n", + "### Algorithm Description\n", + "\n", + "The algorithm divides the timline into long timesteps and short timesteps. In each long timestep, some approximation of evolution of the short timesteps is done, such as Truncated Dyson series [[2](#Dyson)] or Magnus series [[3](#Magnus)]. These are applied as block-encodings on the state, where the following matrix is block encoded in each long timestep:\n", + "$$\n", + "\\mathcal{\\Xi_l} = \\mathcal{T} e^{\\int_{t_{l-1}}^{t_l} A(t) \\, dt}\n", + "$$" + ] + }, + { + "attachments": { + "f70a25b2-a625-43e0-a1d7-a54252bf1ae5.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "3634ab38-6916-44fb-b118-0d757acd4556", + "metadata": {}, + "source": [ + "![image.png](attachment:f70a25b2-a625-43e0-a1d7-a54252bf1ae5.png)" + ] + }, + { + "cell_type": "markdown", + "id": "d9a996b5-02b1-49e4-88ca-6ea425caf354", + "metadata": {}, + "source": [ + "The problem is that when this block encoding has some prefactor $s$ (for example because of the usage of some LCU to block encode the integration), the prefactor of the entire simulation is amplified by $s$ on each iteration! so that the probability to sample the wanted block decreases exponentially with the number of long timesteps.\n", + "\n", + "This is the main pain-point that the algorithm in the paper is coming to resolve. In the case of hamiltonian simulation, it is possible to wrap each timestep with oblivious amplitdue amplification [[4](#OAA)] (see [oblivious amplitude amplification](https://github.com/Classiq/classiq-library/blob/main/algorithms/oblivious_amplitude_amplification/oblivious_amplitude_amplification.ipynb)), and get rid of the pre-factor. However it is only possible in the case of a unitary block encoding. The authors address this issue by using instead Uniform singular amplitude amplification [[5](#USVA)], which is done with the qsvt framework." + ] + }, + { + "cell_type": "markdown", + "id": "89ccefce-4ec8-43eb-ba74-0c16291f612f", + "metadata": {}, + "source": [ + "## Algorithm Implementation using Classiq" + ] + }, + { + "attachments": { + "2b69dc16-89ed-4c69-84f9-5f631a9c15fc.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "950e8dbb-8874-49f3-b973-05f98f1863a5", + "metadata": {}, + "source": [ + "![image.png](attachment:2b69dc16-89ed-4c69-84f9-5f631a9c15fc.png)" + ] + }, + { + "cell_type": "markdown", + "id": "74f3ef52-7d3e-4808-b69c-a94e613790b8", + "metadata": {}, + "source": [ + "We choose an easy artificial example to demonstrate the algorithm. For simplicity, we choose $A$ which is easy to block-encode. The following matrix can be easily block-encoded using linear pauli rotations:\n", + "$$\n", + "A_{ij}(t) = \\cos(i+t)\\delta_{ij}\n", + "$$\n", + "\n", + "The matrix is hermitian and diagonal, and it will help us in several aspect:\n", + "1. The 1st order Magnus expansion will be exact.\n", + "2. The QSVT and QET (Quantum eigenvalue transform) will coincide, and we will use it to exponentiate the block encoding.\n", + "\n", + "We will simulate a 4x4 matrix using 4 timeteps, from $t=0$ to $t=2$:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "91a531e9-8d7d-42fe-85dc-ecdb82862bec", + "metadata": {}, + "outputs": [], + "source": [ + "NUM_LONG_SLICES = 4\n", + "START_TIME = 0\n", + "END_TIME = 2\n", + "\n", + "DIM_SIZE = 2" + ] + }, + { + "cell_type": "markdown", + "id": "7a8982f7-e1d4-4d75-859d-cae9fcd13268", + "metadata": {}, + "source": [ + "### Classical Simulation\n", + "This is how the evolution looks classically:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5405bcbb-08e7-4a00-8383-dcb784c3a4eb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from scipy.integrate import solve_ivp\n", + "\n", + "# Parameters\n", + "N = 2**DIM_SIZE # Matrix size\n", + "t_start = 0\n", + "t_end = END_TIME\n", + "\n", + "\n", + "# Define the time-dependent diagonal matrix A(t)\n", + "def A(t):\n", + " diagonal_elements = np.cos(np.arange(N) + t) # sin(i * t) for i=0,...,N-1\n", + " return np.diag(diagonal_elements)\n", + "\n", + "\n", + "# Define the ODE dx/dt = A(t)x\n", + "def ode_system(t, x):\n", + " return A(t) @ x # Matrix-vector multiplication\n", + "\n", + "\n", + "# Initial condition\n", + "x0 = np.ones(N) # Example: start with all ones\n", + "\n", + "# Solve the ODE\n", + "solution = solve_ivp(\n", + " ode_system, [t_start, t_end], x0, t_eval=np.linspace(t_start, t_end, 100)\n", + ")\n", + "\n", + "# Extract solution\n", + "t_vals = solution.t\n", + "x_vals = solution.y\n", + "\n", + "# Plot the solution\n", + "plt.figure(figsize=(8, 4))\n", + "for i in range(N):\n", + " plt.plot(t_vals, x_vals[i], label=f\"x{i}(t)\")\n", + "\n", + "classical_final = x_vals[:, -1]\n", + "plt.xlabel(\"Time t\")\n", + "plt.ylabel(\"x(t)\")\n", + "plt.title(r\"Solution of $\\dot{x} = A(t)x$\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "73eb6ee5-63e7-41bf-86ca-0df53928a4f2", + "metadata": {}, + "source": [ + "### Time-dependent block encoding\n", + "\n", + "The time-dependent block encoding of $A(t)$ will be:\n", + "$$\n", + "\\left( I_{n_q} \\otimes \\langle 0_m | \\otimes I_n \\right) \n", + "U_{A(t)} \n", + "\\left( I_{n_q} \\otimes | 0_m \\rangle \\otimes I_n \\right) \n", + "= \\sum_{i=0}^{2^{n_q}-1} | i \\rangle \\langle i | \\frac{A\\left((b-a)\\frac{i}{{2^{n_q}}}+a\\right)}{\\alpha}\n", + "$$\n", + "\n", + "So we get, for a given timeslice:\n", + "$$\n", + "A_{ij}(t, a, b) = \\cos((b-a)\\frac{t}{2^{n_q}} + a + i)\\delta_{ij}\n", + "$$\n", + "\n", + "this can be easily accomplished be a sequence of 2 pauli rotations." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "06b08b94-38a9-4f28-8c1e-2bbd8c34e3b8", + "metadata": {}, + "outputs": [], + "source": [ + "from classiq import *\n", + "\n", + "SHORT_INTERVALS_TIME_SIZE = 2\n", + "\n", + "\n", + "class TimeDependentBE(QStruct):\n", + " index: QNum[DIM_SIZE]\n", + " time: QNum[SHORT_INTERVALS_TIME_SIZE]\n", + " block: QBit\n", + "\n", + "\n", + "@qfunc\n", + "def block_encode_time_dependent_A(a: CReal, b: CReal, qbe: TimeDependentBE):\n", + " # a factor 2 is applied on the slopes and offsets as RY rotates at half of the angle\n", + " linear_pauli_rotations(\n", + " [Pauli.Y], [(b - a) * 2 / (2**qbe.time.size)], [2 * a], qbe.time, qbe.block\n", + " )\n", + " linear_pauli_rotations([Pauli.Y], [2], [0], qbe.index, qbe.block)" + ] + }, + { + "cell_type": "markdown", + "id": "c375c120-3fc7-406a-a4ef-c12091675e7a", + "metadata": {}, + "source": [ + "### Short-time Evolution\n", + "\n", + "We will use a 1st order Magnus expansion, which is exact in this case. \n", + "$$\n", + "\\overline{\\Xi} = e^{\\frac{b-a}{M}} \\sum_{k=0}^{M-1} A\\left(a + k \\frac{b-a}{M}\\right)\n", + "$$\n", + "It will be built in 2 steps:\n", + "#### 1. Riemannian Summation of short timesteps" + ] + }, + { + "cell_type": "markdown", + "id": "0e31d376-692b-4b89-8708-e9743dc08ddd", + "metadata": {}, + "source": [ + "Wrapping the time variable with the haddamard transform, we get exactly a block encoding of the Reimann sum of the input block encoding." + ] + }, + { + "attachments": { + "62c02cd8-3279-4bb6-aa64-9b89246fdf95.png": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAACAQAAAJ0CAYAAACPj2PTAAAMPmlDQ1BJQ0MgUHJvZmlsZQAASImVVwdYU8kWnluSkEBooUsJvQkiNYCUEFroHcFGSAKEEmNCULGXRQXXLipgQ1dFFDsgdsTOotiwLxYUlHWxYFfepICu+8r35vvmzn//OfOfM+fO3HsHAI2THJEoH9UEoEBYKE4IC6KPTkunk7oBGVCBKqABfQ5XImLGxUUBWAbbv5d3NwEia685ybT+2f9fixaPL+ECgMRBnMmTcAsgPggAXsUViQsBIMp4y8mFIhmGFeiIYYAQL5ThbAWukuFMBd4rt0lKYEHcAoCKGocjzgZA/Qrk6UXcbKih3gexi5AnEAKgQYfYv6BgIg/iDIjtoI0IYpk+I/MHney/aWYOaXI42UNYMRd5UQkWSET5nKn/Zzr+dynIlw76sIFVLUccniCbM8zbrbyJkTKsBnGvMDMmFmJtiD8IeHJ7iFFKjjQ8WWGPGnMlLJgzoAexC48THAmxMcShwvyYKCWfmSUIZUMMVwg6RVDIToLYAOKFfElIotJmk3higtIXWp8lZjGV/HmOWO5X5uuBNC+ZqdR/ncNnK/Ux9eKcpFSIKRBbFQlSYiBWh9hZkpcYqbQZVZzDihm0EUsTZPFbQZzAF4YFKfSxoixxaILSvrRAMjhfbFOOgB2jxPsLc5LCFfnBWrgcefxwLtgVvpCZPKjDl4yOGpwLjx8copg71s0XJicqdT6ICoMSFGNxiig/TmmPW/Dzw2S8BcTukqJE5Vg8pRAuSIU+niUqjEtSxIkX53Ii4hTx4MtAFGCBYEAHUlgzwUSQCwRtvQ298E7REwo4QAyyAR84KZnBEanyHiG8JoJi8CdEfCAZGhck7+WDIsh/HWIVVyeQJe8tko/IA08hLgCRIB/eS+WjhEPeUsATyAj+4Z0DKxfGmw+rrP/f84Psd4YJmSglIx30SNcYtCSGEIOJ4cRQoj1uhPvjvngUvAbC6oozcO/BeXy3JzwltBMeEW4QOgm3Jwjmin+KMhp0Qv1QZS4yf8wFbgM1PfAg3A+qQ2VcDzcCTrg79MPEA6BnD8iylHHLskL/SftvM/jhaSjtyC5klKxPDiTb/TxS3UHdY0hFlusf86OINXMo36yhnp/9s37IPg+2kT9bYguxA9g57BR2ATuKNQA6dgJrxFqxYzI8tLqeyFfXoLcEeTx5UEfwD3+DT1aWSYlLrUuPyxdFXyF/iuwdDVgTRVPFguycQjoTfhH4dLaQ6zyc7uri6g6A7PuieH29iZd/NxC91u/cvD8A8DsxMDBw5DsXcQKAfV5w+x/+ztkx4KdDFYDzh7lScZGCw2UXAnxLaMCdZghMgSWwg/NxBZ7AFwSCEBABYkESSAPjYfQ5cJ2LwWQwHcwBJaAMLAOrQQXYCLaAHWA32A8awFFwCpwFl8AVcAPchaunC7wAfeAd+IwgCAmhIjTEEDFDrBFHxBVhIP5ICBKFJCBpSAaSjQgRKTIdmYeUISuQCmQzUoPsQw4jp5ALSDtyG3mI9CCvkU8ohqqhOqgJaoOOQBkoE41Ek9BxaDY6CS1G56NL0LVoNboLrUdPoZfQG2gn+gLtxwCmiulh5pgTxsBYWCyWjmVhYmwmVoqVY9VYHdYEn/M1rBPrxT7iRJyG03EnuILD8WSci0/CZ+KL8Qp8B16Pt+DX8Id4H/6NQCUYExwJPgQ2YTQhmzCZUEIoJ2wjHCKcgXupi/COSCTqEW2JXnAvphFzidOIi4nriXuIJ4ntxMfEfhKJZEhyJPmRYkkcUiGphLSOtIt0gnSV1EX6oKKqYqbiqhKqkq4iVJmrUq6yU+W4ylWVZyqfyZpka7IPOZbMI08lLyVvJTeRL5O7yJ8pWhRbih8liZJLmUNZS6mjnKHco7xRVVW1UPVWjVcVqM5WXau6V/W86kPVj2raag5qLLWxalK1JWrb1U6q3VZ7Q6VSbaiB1HRqIXUJtYZ6mvqA+kGdpu6szlbnqc9Sr1SvV7+q/lKDrGGtwdQYr1GsUa5xQOOyRq8mWdNGk6XJ0ZypWal5WLNDs1+LpjVSK1arQGux1k6tC1rd2iRtG+0QbZ72fO0t2qe1H9MwmiWNRePS5tG20s7QunSIOrY6bJ1cnTKd3TptOn262rruuim6U3QrdY/pduphejZ6bL18vaV6+/Vu6n3SN9Fn6vP1F+nX6V/Vf28wzCDQgG9QarDH4IbBJ0O6YYhhnuFywwbD+0a4kYNRvNFkow1GZ4x6h+kM8x3GHVY6bP+wO8aosYNxgvE04y3Grcb9JqYmYSYik3Ump016TfVMA01zTVeZHjftMaOZ+ZsJzFaZnTB7TtelM+n59LX0FnqfubF5uLnUfLN5m/lnC1uLZIu5Fnss7ltSLBmWWZarLJst+6zMrKKtplvVWt2xJlszrHOs11ifs35vY2uTarPApsGm29bAlm1bbFtre8+OahdgN8mu2u66PdGeYZ9nv97+igPq4OGQ41DpcNkRdfR0FDiud2wfThjuPVw4vHp4h5OaE9OpyKnW6aGznnOU81znBueXI6xGpI9YPuLciG8uHi75Lltd7o7UHhkxcu7IppGvXR1cua6VrtfdqG6hbrPcGt1euTu68903uN/yoHlEeyzwaPb46unlKfas8+zxsvLK8Kry6mDoMOIYixnnvQneQd6zvI96f/Tx9Cn02e/zl6+Tb57vTt/uUbaj+KO2jnrsZ+HH8dvs1+lP98/w3+TfGWAewAmoDngUaBnIC9wW+Ixpz8xl7mK+DHIJEgcdCnrP8mHNYJ0MxoLDgkuD20K0Q5JDKkIehFqEZofWhvaFeYRNCzsZTgiPDF8e3sE2YXPZNey+CK+IGREtkWqRiZEVkY+iHKLEUU3RaHRE9MroezHWMcKYhlgQy45dGXs/zjZuUtyReGJ8XHxl/NOEkQnTE84l0hInJO5MfJcUlLQ06W6yXbI0uTlFI2VsSk3K+9Tg1BWpnaNHjJ4x+lKaUZogrTGdlJ6Svi29f0zImNVjusZ6jC0Ze3Oc7bgp4y6MNxqfP/7YBI0JnAkHMggZqRk7M75wYjnVnP5MdmZVZh+XxV3DfcEL5K3i9fD9+Cv4z7L8slZkdWf7Za/M7skJyCnP6RWwBBWCV7nhuRtz3+fF5m3PG8hPzd9ToFKQUXBYqC3ME7ZMNJ04ZWK7yFFUIuqc5DNp9aQ+caR4mwSRjJM0FurAH/lWqZ30F+nDIv+iyqIPk1MmH5iiNUU4pXWqw9RFU58Vhxb/Ng2fxp3WPN18+pzpD2cwZ2yeiczMnNk8y3LW/Flds8Nm75hDmZM35/e5LnNXzH07L3Ve03yT+bPnP/4l7JfaEvUScUnHAt8FGxfiCwUL2xa5LVq36Fspr/RimUtZedmXxdzFF38d+evaXweWZC1pW+q5dMMy4jLhspvLA5bvWKG1onjF45XRK+tX0VeVrnq7esLqC+Xu5RvXUNZI13SujVrbuM5q3bJ1XypyKm5UBlXuqTKuWlT1fj1v/dUNgRvqNppsLNv4aZNg063NYZvrq22qy7cQtxRtebo1Zeu53xi/1Wwz2la27et24fbOHQk7Wmq8amp2Gu9cWovWSmt7do3ddWV38O7GOqe6zXv09pTtBXule5/vy9h3c3/k/uYDjAN1B60PVh2iHSqtR+qn1vc15DR0NqY1th+OONzc5Nt06Ijzke1HzY9WHtM9tvQ45fj84wMnik/0nxSd7D2Vfepx84Tmu6dHn77eEt/SdibyzPmzoWdPn2OeO3He7/zRCz4XDl9kXGy45HmpvtWj9dDvHr8favNsq7/sdbnxiveVpvZR7cevBlw9dS342tnr7OuXbsTcaL+ZfPNWx9iOzlu8W92382+/ulN05/Pd2fcI90rva94vf2D8oPoP+z/2dHp2HnsY/LD1UeKju4+5j188kTz50jX/KfVp+TOzZzXdrt1He0J7rjwf87zrhejF596SP7X+rHpp9/LgX4F/tfaN7ut6JX418HrxG8M329+6v23uj+t/8K7g3ef3pR8MP+z4yPh47lPqp2efJ38hfVn71f5r07fIb/cGCgYGRBwxR/4rgMGKZmUB8Ho7ANQ0AGjwfEYZozj/yQuiOLPKEfhPWHFGlBdPAOrg/3t8L/y76QBg71Z4/IL6GmMBiKMCkOQNUDe3oTp4VpOfK2WFCM8Bm+K/ZhZkgn9TFGfOH+L+uQUyVXfwc/svISd8WKuESysAAACKZVhJZk1NACoAAAAIAAQBGgAFAAAAAQAAAD4BGwAFAAAAAQAAAEYBKAADAAAAAQACAACHaQAEAAAAAQAAAE4AAAAAAAAAkAAAAAEAAACQAAAAAQADkoYABwAAABIAAAB4oAIABAAAAAEAAAgEoAMABAAAAAEAAAJ0AAAAAEFTQ0lJAAAAU2NyZWVuc2hvdPpuxEYAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAHXaVRYdFhNTDpjb20uYWRvYmUueG1wAAAAAAA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIiB4OnhtcHRrPSJYTVAgQ29yZSA2LjAuMCI+CiAgIDxyZGY6UkRGIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+CiAgICAgIDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiCiAgICAgICAgICAgIHhtbG5zOmV4aWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vZXhpZi8xLjAvIj4KICAgICAgICAgPGV4aWY6UGl4ZWxZRGltZW5zaW9uPjYyODwvZXhpZjpQaXhlbFlEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlBpeGVsWERpbWVuc2lvbj4yMDUyPC9leGlmOlBpeGVsWERpbWVuc2lvbj4KICAgICAgICAgPGV4aWY6VXNlckNvbW1lbnQ+U2NyZWVuc2hvdDwvZXhpZjpVc2VyQ29tbWVudD4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+Cp5r0rkAAAAcaURPVAAAAAIAAAAAAAABOgAAACgAAAE6AAABOgAC2jTydiqUAABAAElEQVR4Aey9bbCuW3YV9JybdN9EqsCCIgWUZfhBQJBCIFRFmmiBfDRYAipUoIilwg9IQIWgBAJYAWJBoEQwSBr9IQUUoYoAhWJhIjSKASwC1UAihA/zRSAhiSZ0Q77T9zjXnGuMOeZa69mn+83t7nvunW/SzxxzjLHW2nvutebz7H3eu/ez5/a6Dq9BPlPeiOdGgBujns0kvDIC0OPz67mNwriYEgZdoOLNYUSv3/XHPur91+ev+492U+mYgB67//b9p++/uG/oialPHDXDESJrRD9/9PMH9lE/f/TzRz9/aDeVjgnosZ8/+vmjnz9w39ATw2eLA8ARomREP3/08wf2UT9/9PNHP39oN5WOCeixnz/6+aOfP3Df0BPDZ4sDwBGiZEQ/f/TzB/ZRP3/080c/f2g3lY4J6PHlev54hjcEbB+2nnjeFRJs/pQMlYqkstEgxojlsaXXz46TFSTa6kVlANQVcYpIEenr+m/17P3X+w93vHK2Itn2S/HggCH2+fMKoByI3X+sLPGIve2n7j/df7r/lK6qyXZeVGRfYaMJFSkiff38s9Wz+0/3n+4/patosp0XFdlX2Gi6/4wKoByIJLr/bvup+2/33+6/patqsp0XFdlX2GhCRYpIX/efrZ7df7r/dP8pXUWT7byoyL7CRtP9Z1QA5UAk0f1320/df7v/dv8tXVWT7byoyL7CRhMqUkT6uv+gns+ev2adB2/7mUVlvSwfv0Dg2dyYypf6D5/9r0yzEEvqw507CEr1+l3/3n/4R8PljMkh1DOThysNm26ScwdBqT5/ff76/PX5G51E+0J2lkCbthBL6oOcOwhKdf/p/tP9p/vPaBjaF6Lr5HXTFmJJfaBzB0Gp7j/df7r/dP8ZDUP7QnaeQJu2EEvqg5w7CEp1/+n+0/2n+89oGNoXouvkddMWYkl9oHMHQanuP91/uv90/xkNQ/tCdp5Am7YQS+qDnDsISnX/6f7T/af7z2gY2hei6+R10xZiSX2gcwdBqbda/+FvCIjSaikGo7nicBd5UhgTbrvq75mB5/bdT+samivu9b0Ch5J0/aMovPb+299F0Ofv5t2H64HSXHH3n+4/VoHDlgAZkl27/3T/ief52TTGvrF9cXz377qhNFc8pzpQvf+iKLz2+evz1+cve89A3X+6//b9p54Jz9YbquaK59AD1fffKAqvff/t+2/ff2uv6ftv33/7/lvPRN9/rQLrA4XmimfpDhTmCMmuff/t+2/ff2uv6ftv33/7/lvPhGf25iN7B8R48bcAxA1lqLOL+J2Ftxcfhv6SbGXcpJdhHDe74xfBlF6/68+94ZvF9kvvPz9Cfsj84o+Lg6unLTT3bg+UwcZA87HGk4fc56/PH/fG2E/j1efPy+DHK87YUpl52kJzb5+/3DdRkCzLqA33mIp9/+/nn37+xLvg+/l76bLeXqPHLkr3X++2UZtstHg6lB7rhbNL918pSsLuv91/u/+ibyxd1tuLX7zfjlOjzmflmTd8ebIm8int0v1nK80guv90/+n+o11lnIqZe0uJvuJtJJV+/vNaRG1GxeJ7B9QxGNKjWt1/pSgJu/92/+3+i76xdFlvL9FjFqX7r7WQfv6NvRHdVHH2V98off95Ke6/8RsC/OsYX0zC8fVEj5Cv7R0c48bLh5QkeL1uMhedx2sz6OgzLkNKsvs3eRDP/BJNbjPsc6xMGVKS1bn9yHc+x/X6Y/d4FV5Qv72iS01fMH6TuWivz1KMIvf5P221I1f2VEl2+yaz6L3/WIpRtt5/++a5YcqeKsk+YJNZ9N5/LMUoW++/ffPcMGVPlWQfsMkseu8/lmKUrfffvnlumLKnSrIP2GQWvfcfSzHK1vtv3zw3TNlTJdkHbDKL3vuPpRhl6/23b54bpuypkuwDNplF7/3HUoyy9f7bN88NU/ZUSfYBm8yi9/5jKUbZev/tm+eGKXuqJPuATWbRe/+xFKNsvf/2zXPDlD1Vkn3AJrPovf9YilG23n/75rlhyp4qyT5gk1n03n8sxShb779989wwZU+VZB+wySx67z+WYpTtI7D/nr1mb4+r6/qHNL+K8qWbtKrDFPmNOGcZpuf2D+7P+BlilucmJRt2aJh9RPsIb5YI+kaMCX1sr6+VRo27/lqV2C6ozcgGHq/ef33+yjbwXTEusVvmntGtQ0eYuv/oSUOhuv9oVWLLoDYjG3i8uv90/ynbwHfFuMRumXtGtw4dYer+oycNher+o1WJLYPajGzg8er+0/2nbAPfFeMSu2XuGd06dISp+4+eNBSq+49WJbYMajOygcer+0/3n7INfFeMS+yWuWd069ARpu4/etJQqO4/WpXYMqjNyAYer+4/3X/KNvBdMS6xW+ae0a1DR5i6/+hJQ6G6/2hVYsugNiMbeLy6/3T/KdvAd8W4xG6Ze0a3Dh1h6v6jJw2F6v6jVYktg9qMbODx6v7zVuk/9hsCXrOvurwzw77260u3yKp9IHkZL3ssxobq12LMmW/oNLwAlfEjGS9+nqH6tRjDNq43dBpegMr4kYxXrx910FtaKdSULdzQaXgBKuO7/lGt3n9z18Tu8GvZKLmpbug0vACV8SMZr65/1KHPv28G3yNlo8zyWLih0/ACVMaPZLx6/0Udev/5ZvA9UjbKLI+FGzoNL0Bl/EjGq/df1KH3n28G3yNlo8zyWLih0/ACVMaPZLx6/0Udev/5ZvA9UjbKLI+FGzoNL0Bl/EjGq/df1KH3n28G3yNlo8zyWLih0/ACVMaPZLx6/0Udev/5ZvA9UjbKLI+FGzoNL0Bl/EjGq/df1KH3n28G3yNlo8zyWLih0/ACVMaPZLx6/0Udev/5ZvA9UjbKLI+FGzoNL0Bl/EjGq/df1KH3n28G3yNlo8zyWLih0/ACVMaPZLx6/0Udev/5ZvA9UjbKLI+FGzoNL0Bl/EjGq/df1OENtv/iTwaMD6181ebHimB/Y9z//pCF8esE+LWE/kTMaU/vxpGBaRRywl6/6z/+/lXvvz5/3X+6/+53iFsmbyt9/9nfDSply0IJOWHff/v+2/fffv7o569+/urnr37+2p8Qbpl8rOjnr37+Wn8bpGyb3ChCTtjPn/382c+f/fzZz5/9/NnPn/38uT8h3DL5WNHPn/382c+f1j7Przwou97P32+Z5+/DnwyY+8E3wcDnLfTU/vE3F2BbHYfP0RZu32DQ68/SHwv45Ps3uv7YfHfbt/efb64+f91/rL0cO0z33+6/vjGOu6PvP3e3lnHrGbcXvI7l6/tP339sY/T9t++/tg3OLcI2hwtHtfuv9ddzZUzo/ou7z02R+v7jhen+2/3Xmsixj/T3P7Mwx+r0/afvP+dzM+48ff/t+y8qcGwf/fzRzx+2Mfr5q5+/bBucW4RtDheOaj9/WH89V6bvv/38gZvv3Sa5v//yTwb4FNMn0y0HLyfy3Xjwx9gQICNy3kJIIhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKKhDeSs0MJCLMjCFARlzkmYoqEN5KzQwkIsyMIUBGXOSZiioQ3krNDCQizIwhQEZc5JmKajB/QwB4RI7eQVjujbuyMpkTASDuy5IJy71xV1YmcyIARK62g7DcG3dlZTInAkDclyUTlnvjrqxM5kQAiFxtB2G5N+7KymROBIC4L0smLPfGXVmZzIkAELnaDsJyb9yVlcmcCABxX5ZMWO6Nu7IymRMBIHK1HYTl3rgrK5M5EQDiviyZsNwbd2VlMicCQORqOwjLvXFXViZzIgDEfVkyYbk37srKZE4EgMjVdhCWe+OurEzmRACI+7JkwnJv3JWVyZwIAJGr7SAs98ZdWZnMiQAQ92XJhOXeuCsrkzkRACJX20FY7o27sjKZEwEg7suSCcu9cVdWJnMiAESutoOw3Bt3ZWUyJwJA3JclE5Z7466sTOZEAIhcbQdhuTfuyspkTgSAuC9LJiz3xl1ZmcyJABC52g7Ccm/clZXJnAgAcV+WTFjujbuyMpkTASBytR2E5d64KyuTOREA4r4smbDcG3dlZTInAkDkajsIy71xV1YmcyIAxH1ZMmG5N+7KymROBIDI1XYQlnvjrqxM5kQAiPuyZMJyb9yVlcmcCACRq+0gLPfGXVmZzIkAEPdlyYTl3rgrK5M5EQAiV9tBWO6Nu7IymRMBIO7LkgnLvXFXViZzIgBErraDsNwbd2VlMicCQNyXJROWe+OurEzmRACIXG0HYbk37srKZE4EgLgvSyYs98ZdWZnMiQAQudoOwnJv3JWVyZwIAHFflkxY7o27sjKZEwEgcrUdhOXeuCsrkzkRAOK+LJmw3Bt3ZWUyJwJA5Go7CMu9cVdWJnMiAMR9WTJhuTfuyspkTgSAyNV2EJZ7466sTOZEAIj7smTCcm/clZXJnAgAkavtICz3xl1ZmcyJABD3ZcmE5d64KyuTOREAIlfbQVjujbuyMpkTASDuy5IJy71xV1YmcyIARK62g7DcG3dlZTInAkDclyUTlnvjrqxM5kQAiFxtB2G5N+7KymROBIC4L0smLPfGXVmZzIkAELnaDsJyb9yVlcmcCABxX5ZMWO6Nu7IymRMBIHK1HYTl3rgrK5M5EQDiviyZsNwbd2VlMicCQORqOwjLvXFXViZzIgDEfVkyYbk37srKZE4EgMjVdhCWe+OurEzmRACI+7JkwnJv3JWVyZwIAJGr7SAs98ZdWZnMiQAQ92XJhOXeuCsrkznRBPYbAsbvRtMXLKDHL6YwjN/tDzlY+bUVEBB1zsRUHTBLA38nwdDGq9fv+tte6P3Ho4BDV08PMsQ4PeuVqgNmYgM34nj1+evzZ3uhzx+PQp+/6AzoFDWrbGh5peqAWRr6/m+1mD3Xq9L9t/uvnZPuv3ksxpGwV+0eyBDDs16pOmAmNnAjjlefvz5/thf6/PEo9PNPdAZ0ippVNrS8UnXALA3sakMbr+4/3X9sL3T/4VHo/hOdoXYPZIjhWa9UHTATG7gRx6v7T/cf2wvdf3gUuv9EZ0CnqFllQ8srVQfM0tDPP1aL2XO9Kt1/u//aOen+m8diHAl71e6BDDE865WqA2ZiAzfieL21zt+z56/ZGwKeoQhRgtP17ACLWEeO9xo8exYFNYT7aDnf8VU9j9fZzg6wiDrClun1u/69/+xQPLf/6/M37yPdf6xd4vmi+68dj77/jSLUm+eS3dxh57gbte+/ff/t+6+dkb7/9vNHP3/xDtPPH/38ZZvB94M/OpyfH/QR5OwAi6gjrOv280c/f/TzRz9/9PNX//ynf/6V3+Hb7bJ//tPPH/385bfG/vlf//zTNgK/O63fRMzs5juMOe5G7e8/+vuPl+z7D/8NAWU7MyE4HhAl4bT9bxtgfCMekR4YSFRQZCYE1XzI4MS6iLTCQKKCIjMhqOZDBifWRaQVBhIVFJkJQTUfMjixLiKtMJCooMhMCKr5kMGJdRFphYFEBUVmQlDNhwxOrItIKwwkKigyE4JqPmRwYl1EWmEgUUGRmRBU8yGDE+si0goDiQqKzISgmg8ZnFgXkVYYSFRQZCYE1XzI4MS6iLTCQKKCIjMhqOZDBifWRaQVBhIVFJkJQTUfMjixLiKtMJCooMhMCKr5kMGJdRFphYFEBUVmQlDNhwxOrItIKwwkKigyE4JqPmRwYl1EWmEgUUGRmRBU8yGDE+si0goDiQqKzISgmg8ZnFgXkVYYSFRQZCYE1XzI4MS6iLTCQKKCIjMhqOZDBifWRaQVBhIVFJkJQTUfMjixLiKtMJCooMhMCKr5kMGJdRFphYFEBUVmQlDNhwxOrItIKwwkKigyE4JqPmRwYl1EWmEgUUGRmRBU8yGDE+si0goDiQqKzISgmg8ZnFgXkVYYSFRQZCYE1XzI4MS6iLTCQKKCIjMhqOZDBifWRaQVBhIVFJkJQTUfMjixLiKtMJCooMhMCKr5kMGJdRFphYFEBUVmQlDNhwxOrItIKwwkKigyE4JqPmRwYl1EWmEgUUGRmRBU8yGDE+si0goDiQqKzISgmg8ZnFgXkVYYSFRQZCYE1XzI4MS6iLTCQKKCIjMhqOZDBifWRaQVBhIVFJkJQTUfMjixLiKtMJCooMhMCKr5kMGJdRFphYFEBUVmQlDNhwxOrItIKwwkKigyE4JqPmRwYl1EWmEgUUGRmRBU8yGDE+si0goDiQqKzISgmg8ZnFgXkVYYSFRQZCYE1XzI4MS6iLTCQKKCIjMhqOZDBifWRaQVBhIVFJkJQTUfMjixLiKtMJCooMhMCKr5kMGJdRFphYFEBUVmQlDNhwxOrItIKwwkKigyE4JqPmRwYl1EWmEgUUGRmRBU8yGDE+si0goDiQqKzISgmg8ZnFgXkVYYSFRQZCYE1XzI4MS6iLTCQKKCIjMhqOZDBifWRaQVBhIVFJkJQTUfMjixLiKtMJCooMhMCKr5kMGJdRFphYFEBUVmQlDNhwxOrItIKwwkKigyE4JqPmRwYl1EWmEgUUGRmRBU8yGDE+si0goDiQqKzISgmg8ZnFgXkVYYSFRQZCYE1XzI4MS6iLTCQKKCIjMhqOZDBifWRaQVBhIVFJkJQTUfMjixLiKtMJCooMhMCKr5kMGJdRFphYFEBUVmQlDNhwxOrItIKwwkKigyE4JqPmRwYl1EWmEgUUGRmRBU8yGDE+si0goDiQpU3v5kQIhqGf9903j/zOS21erke5ZzObIL3524m+taU48Z5jy9/vJui0MRCzXrZpwju3T9x34+v6JaWbPhKlzvv95//q6v8/7Z2dxLjuzS56/PX/ef/aQMpvTaaSlc99/uv91/z4fnyMbpGZIju/T9p+8/ff85Hpa+/1hZ+L3+LFHff6Um/fzRzx/9/HFunke2nz/wtNHPX1aJfv7s5297+Oznz2Oz7OdPK0s/f+Y9c+ySyCbXz5+2Qe66x+lMZS0d2aV//tH9924HxW7JPfNWO3/LGwKkEIQEfto0Q29yToXtXD4pilt8hAS9vlVAq9H1j3uD10QLIzsq4JOiuMVHSOA+zbr+Xf/xbOJ7QjeG7Kjef6MCTxZHqiU+QgL3adbnr89fn7/uP94TtDFIRwn4pChu8RESdP+xCmg1uv92/+3+2/3Xe4I2BumoAZ8UxS0+QgL3adb9p/tP95/uP94TtDFIR+n+MyrwZHGkWuIjJHCfZt1/u/92/+3+6z1BG4N0lIBPiuIWHyFB9x+rgFaj+2/33+6/3X+9J2hjkI4a8ElR3PaHPe3v7A03XzpUMQ0EoT7toXk2snQ7ypRGpRTTQBDq0x6ae30rhb7zzut2KJ5SirOSQKE+7YEXN7J0O8qURqUU00AQ6tMemvvrb6Xor3/uFkeZcqMopZgGglCf9tDc+89K0fsvd4ujTLlRlFJMA0GoT3to7v1npej9l7vFUabcKEoppoEg1Kc9NPf+s1L0/svd4ihTbhSlFNNAEOrTHpp7/1kpev/lbnGUKTeKUoppIAj1aQ/Nvf+sFL3/crc4ypQbRSnFNBCE+rSH5t5/Voref7lbHGXKjaKUYhoIQn3aQ3PvPytF77/cLY4y5UZRSjENBKE+7aG595+Vovdf7hZHmXKjKKWYBoJQn/bQ3PvPStH7L3eLo0y5UZRSTANBqE97aO79Z6Xo/Ze7xVGm3ChKKaaBINSnPTT3/rNSvAz7j28IuP/CPrcv5rPyycyvrn2Kd6Pu+LFBoCEOLtnI9Nrrd/17/2kz4RFKoAfmydOUJ63P32jReNVqgB2x+0/3n+4/3X+kQxASaMPwnqG9pYoYgxhqzXRE95/uP91/uv9IhyAk0IZh+I4fNmiIMbRmwUHp89fnr8+fnBBCAj0whu/4YYOGGENrFhyUPn99/vr8yQkhJNADY/iOHzZoiDG0ZsFB6fPX56/Pn5wQQgI9MIbv+GGDhhhDaxYclD5/ff76/MkJISTQA2P4jh82aIgxtGbBQenz1+evz5+cEEICPTCG7/hhg4YYQ2sWHJQP5/mzNwS8Zh9L/sMYP94E+tEVXD8J/OB6WopoyfzDHfg1JzlRMWa9en0rkXxdsmBEtXJd/zg4szylOL3/+vzZWbL/7/5jZShtpRyU7r8sBwH77Qqqo/tv99/xjUPff7wC5XBY0s9/ff/p+28/f1gr6OcP3CRGLI1S0oXXIRNXRz9/9PNHP3/089epOVin6Oevfv7q569+/rJW0M9f+jBVn6LycWzhdcipxdrAfv7o549+/jgdjn7+6OcvOxn9/PGGf/7gbwiQn0T4ic7bW6Ltnnhzz1xp5BH1qjPCFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEQPD+hgD8V7NlacxCq0wkmk/k+Xj7h5n5FqmxmBHznckju3v1+vGuza6/vMdS9lJAuYrW+8+K4fXo89f9xzps91+5zYyzYQUpNRF5wr7/9P1n/FcTff/t+y//Gwd5xggoV9H6+cOK4fXwA7T02qF1/+37z37PVabvv33/7ftvP3/081c/f/Xz1/xmVZ4xA8pVtH7+tGJ4Pfr5s3/+ZU+V8/jE8+XYG/39R62JPnnPKlmZ+vmrn7/6+aufv/r56y3+/PXcXvstwhh/yFJFidk6lKJV2gp1gjmv5By3gM2iRK/vrUtLwvJ1/dnWWR+C3n9eCqkH980CNosSff76/Nmjg24Jbp/uP91/5mMl9wdB918vhdSD52YBm0WJ7r/df7v/9v3Hekb5AejoIX3/7ftv33/9WPCWSdDPH14Kqcfy2MF0syjRzx/9/NHPH/38Yd2inz/YMgP081c/f/XzVz9/WTfgIxNBP396KaQeS/dkulmU6OfPfv7s588PxfPn9icD6rGbz3tK+okVwmHk4zpe+YyYPiDEcOo1FNWJCeAXwmHk4zpevX7UQe5IvDdJ5WCaMWuI+tFLgCFCOIx8XMcL43v9rBMQYlRKr6GoTkwAvxAOIx/X8er6Rx16/+U+AUJEhTKGojoxAdxCOIx8XMer91/Uofdf7hMgRFQoYyiqExPALYTDyMd1vHr/RR16/+U+AUJEhTKGojoxAdxCOIx8XMer91/Uofdf7hMgRFQoYyiqExPALYTDyMd1vHr/RR16/+U+AUJEhTKGojoxAdxCOIx8XMer91/Uofdf7hMgRFQoYyiqExPALYTDyMd1vHr/RR16/+U+AUJEhTKGojoxAdxCOIx8XMer91/Uofdf7hMgRFQoYyiqExPALYTDyMd1vHr/RR16/+U+AUJEhTKGojoxAdxCOIx8XMer91/Uofdf7hMgRFQoYyiqExPALYTDyMd1vHr/RR16/+U+AUJEhTKGojoxAdxCOIx8XMfrZd5/8ScD8EnI5+mfGX6XoyWUCNyRl5U/5iBnrEEWmdP2+ra7YnuhcvmFyNI7ogG1s5g7c9YWplp4sNvcXf+uf++/erx4WOY5Q1j5Yw5yxhq6/6E8rKkRvf96/1kFuDUIsElmXPljDnLGGmQRzGmG3n9eDFQuvxBd/1IBFgh7x2I/f2WJvD4o0ow19PlDeVC1fv7u/tv3Hz8NPBoEOCQzrvwxBzljDd1/UB6UtvtP95/uP91/rAJsDQRoEjOu/DEHOWMNsgjmNEPvPy8GKpdfiK5/qQALhL1jsb//yhJ5fVCkGWvo84fyoGr9/NP9t+8/fhp4NAhwSGZc+WMOcsYauv+gPCjtR6D/5G8IkMXx8YyIjxFRNeDUEkFDdGWThej12XxRsxFRIUTVgFNLBA3RlU0Wouvf9Z83P+yZEbFDEFUDTi0RNERXNlmI3n+9/3r/4bgw4oQgUhCQWiKRHbqyyUL0+evz1+dvPTZ9/7OKjJ+rSae4rdFTru4/VsetiEJ0/+3+2/33trfISbn1dP+5r5IrmyxE95/uP91/bnuLnJRbT/ef+yq5sslCdP/p/tP957a3yEm59XT/ua+SK5ssRPef7j/df257i5yUW0/3n/squbLJQrxB+k++IUC/zPJxOr3m9O7CztCcwEzP7adj8y/tJA+0TrLm8B1+THlr5RgDvX7Xv/dfn7/yFmJpEGsTWXNad2FnaE5gpu5/3f/7/qdv4c/jsd3Wbw/VLuyMzAvY56/7T9//+/7f9390xBrXJrrmdO/CztCcwEz9/NPPP/38088/2RQErU1kzWndhZ2hOYGZuv90/+n+0/0nm4KgtYmsOa27sDM0JzBT95/uP91/uv9kUxC0NpE1p3UXdobmBGbq/tP9p/tP959sCoHqGwK8UdgbheC6edcCZP3BfTSipR0h9Tgu1ojGjyEnD1nne26L9/qzIl3/47vWdL9gs8ReWnYUUo/j0vuvz1/3n+6/1gjsJoP24I0hmoM9KPf9p++/c0f0/bfvv4d3jWu/6OePqEb00qWjIvU4Lv381c9f/fzVz1/WCPr5q58/YxuM20K87BbRz9/9/Ud//4HzYAeinz/RHfboz5VsHXZLEWLQSD2OSz9/9vNnP3/286c1gn7+ZHv0xhjNsZ+/bF/088fcEf3zz7fc81e8IQAPTuwM+SwVlBgEiv0xiLkQZZZKSSZQ7I9BzIUos1RKMoFifwxiLkSZpVKSCRT7YxBzIcoslZJMoNgfg5gLUWaplGQCxf4YxFyIMkulJBMo9scg5kKUWSolmUCxPwYxF6LMUinJBIr9MYi5EGWWSkkmUOyPQcyFKLNUSjKBYn8MYi5EmaVSkgkU+2MQcyHKLJWSTKDYH4OYC1FmqZRkAsX+GMRciDJLpSQTKPbHIOZClFkqJZlAsT8GMReizFIpyQSK/TGIuRBllkpJJlDsj0HMhSizVEoygWJ/DGIuRJmlUpIJFPtjEHMhyiyVkkyg2B+DmAtRZqmUZALF/hjEXIgyS6UkEyj2xyDmQpRZKiWZQLE/BjEXosxSKckEiv0xiLkQZZZKSSZQ7I9BzIUos1RKMoFifwxiLkSZpVKSCRT7YxBzIcoslZJMoNgfg5gLUWaplGQCxf4YxFyIMkulJBMo9scg5kKUWSolmUCxPwYxF6LMUinJBIr9MYi5EGWWSkkmUOyPQcyFKLNUSjKBYn8MYi5EmaVSkgkU+2MQcyHKLJWSTKDYH4OYC1FmqZRkAsX+GMRciDJLpSQTKPbHIOZClFkqJZlAsT8GMReizFIpyQSK/TGIuRBllkpJJlDsj0HMhSizVEoygWJ/DGIuRJmlUpIJFPtjEHMhyiyVkkyg2B+DmAtRZqmUZALF/hjEXIgyS6UkEyj2xyDmQpRZKiWZQLE/BjEXosxSKckEiv0xiLkQZZZKSSZQ7I9BzIUos1RKMoFifwxiLkSZpVKSCRT7YxBzIcoslZJMoNgfg5gLUWaplGQCxf4YxFyIMkulJBMo9scg5kKUWSolmUCxPwYxF6LMUinJBIr9MYi5EGWWSkkmUOyPQcyFKLNUSjKBYn8MYi5EmaVSkgkU+2MQcyHKLJWSTKDYH4OYC1FmqZRkAsX+GMRciDJLpSQTKPbHIOZClFkqJZlAsT8GMReizVJ/QwCnFQe4A+WS8yISEvCdSMmsbzjAIojqnNyB6vWtAl4XKQ4hQdffyjTe9ZUVqdj3UbmocwoHyhXnRSQk4LrJ9Ppai1L6LGql7wY4LyIhQdffKtn7v5653B11m0V2UA+Ue50XkZCg91/vvz5/tgfyRFQcZ06v6pz8gXLFeREJCbhuMr2+1kIrH/igHqiuv1XA6yLFISTo/Wdl6ueP2nNyd8SJq9eDeqB8jPMiEhL0/uv91+fP9kCeiIrr2RuZOqd6oFxxXkRCAs6WzHGFudAI6pz0gXLFeREJCThbMscV5kIjqHPSB8oV50UkJOBsyRxXmAuNoM5JHyhXnBeRkICzJXNcYS40gjonfaBccV5EQgLOlsxxhbnQCOqc9IFyxXkRCQk4WzLHFeZCI6hz0gfKFedFJCTgbMkcV5gLjaDOSR8oV5wXkZCAsyVzXGEuNII6J32gXHFeREICzpbMcYW50AjqnPSBcsV5EQkJOFsyxxXmQiOoc9IHyhXnRSQk4GzJHFeYC42gzkkfKFecF5GQgLMlc1xhLjSCOid9oFxxXkRCAs6WzHGFudAI6pz0gXLFeREJCThbMscV5kIjqHPSB8oV50UkJOBsyRxXmAuNoM5JHyhXnBeRkICzJXNcYS40gjonfaBccV5EQgLOlsxxhbnQCOqc9IFyxXkRCQk4WzLHFeZCI6hz0gfKFedFJCTgbMkcV5gLjaDOSR8oV5wXkZCAsyVzXGEuNII6J32gXHFeREICzpbMcYW50AjqnPSBcsV5EQkJOFsyxxXmQiOoc9IHyhXnRSQk4GzJHFeYC42gzkkfKFecF5GQgLMlc1xhLjSCOid9oFxxXkRCAs6WzHGFudAI6pz0gXLFeREJCThbMscVfDp7Q8Brz5/b72nDb6bSQfNDeXLCkx/jIqpDMVzPr16/69/7bz8teULuf6B6OlEYt894cvf56/7T/af7z94t0EfQNRAHD4wI7x7VoRjO7j/df7r/dP+JfnDuEP38c/cP6qd6obPuFT25u/92/+3+2/137xboI+gaiIMHRoR3j+pQDGf3n+4/3X+6/0Q/OHeIfv7r57+854ydgn2CiLvJHtWhGM6+//T9p+8/ff+JfnDuEH3/6ftP3nPGTsE+QcTdZI/qUAznG+v+I78hYH6wHvQDV358Eqrhk/rAI0cbKH8vDvO6ga5cjxTBB76oODnaQK8fjS7KMyvjgVXq+pd9OSqltYnKfTBXjjbQ+6/337jRxmvuDA/cJSYpP5yqxcgP5srRBnr/9f7r/YfTo+eMpyTPGykCDPygIkcb6PPX56/PH47PPBkeeEr6/OF+z5IQoHAfVORoA91/uv90/8HxmSfDA09J95/uP7YH7JRwSxBg43xQkaMNdP/t/tv9F8dnngwPPCUmKj+8qmHsBx452kCfvz5/ff5wdvSc8ZTkeSNFgIEfVORoA33++vz1+cPxmSfDA09Jnz/c71kSAhTug4ocbaD7z95/5A0Bta4sHOilgM8tr+8qkhGAHu0dEPYNVR78MSEMmHyPm8MI/QL2+l3/3n9xbuKsyIkB9Njnr/tP99++/+g9Fg1CuYo3hxF9/80HqH7+6OePfv7o549RgeiV0jEBPfbzVz9/9fNXP3/p8xUahHIVbw4j+vmrn79wjvr5s58/+/kzemb0SumYgB77+aufv/r5C/cNPTH1iaNmOEJkjejnj37+wD7q549+/ujnD+2m0jEBPb5czx98Q8D2YeuJ510hweZPyVCpSCobDWKMWB5bev3sOFlBoq1eVAZAXRGniBSRvq7/Vs/ef73/cMcrZyuSbb8UDw4YYp8/rwDKgdj9x8oSj9jbfur+0/2n+0/pqpps50VF9hU2mlCRItLXzz9bPbv/dP/p/lO6iibbeVGRfYWNpvvPqADKgUii+++2n7r/dv/t/lu6qibbeVGRfYWNJlSkiPR1/9nq2f2n+0/3n9JVNNnOi4rsK2w03X9GBVAORBLdf7f91P23+2/339JVNdnOi4rsK2w0oSJFpK/7D+r57Plr1nnwtp9ZVNbL8udDnhtT+VL/4bP/lWkWYkl9uHMHQalev+vf+w//aLicMTmEembycKVh001y7iAo1eevz1+fvz5/o5NoX8jOEmjTFmJJfZBzB0Gp7j/df7r/dP8ZDUP7QnSdvG7aQiypD3TuICjV/af7T/ef7j+jYWhfyM4TaNMWYkl9kHMHQanuP91/uv90/xkNQ/tCdJ28btpCLKkPdO4gKNX9p/tP95/uP6NhaF/IzhNo0xZiSX2QcwdBqe4/3X+6/3T/GQ1D+0J0nbxu2kIsqQ907iAo9VbrP/wNAVFaLcVgNFcc7iJPCmPCbVf9PTPw3L77aV1Dc8W9vlfgUJKufxSF195/+7sI+vzdvPtwPVCaK+7+0/3HKnDYEiBDsmv3n+4/8Tw/m8bYN7Yvju/+XTeU5ornVAeq918Uhdc+f33++vxl7xmo+0/3377/1DPh2XpD1VzxHHqg+v4bReG17799/+37b+01ff/t+2/ff+uZ6PuvVWB9oNBc8SzdgcIcIdm17799/+37b+01ff/t+2/ff+uZ8MzefGTvgBgv/haAuKEMdXYRv7Pw9uLD0F+SrYyb9DKM42Z3/CKY0ut3/bk3fLPYfun950fID5lf/HFxcPW0hebe7YEy2BhoPtZ48pD7/PX5494Y+2m8+vx5Gfx4xRlbKjNPW2ju7fOX+yYKkmUZteEeU7Hv//3808+feBd8P38vXdbba/TYRen+6902apONFk+H0mO9cHbp/itFSdj9t/tv91/0jaXLenvxi/fbcWrU+aw884YvT9ZEPqVduv9spRlE95/uP91/tKuMUzFzbynRV7yNpNLPf16LqM2oWHzvgDoGQ3pUq/uvFCVh99/uv91/0TeWLuvtJXrMonT/tRbSz7+xN6KbKs7+6hul7z8vxf03fkOAfx3ji0k4vp7oEfK1vYNj3Hj5kJIEr9dN5qLzeG0GHX3GZUhJdv8mD+KZX6LJbYZ9jpUpQ0qyOrcf+c7nuF5/7B6vwgvqt1d0qekLxm8yF+31WYpR5D7/p6125MqeKslu32QWvfcfSzHK1vtv3zw3TNlTJdkHbDKL3vuPpRhl6/23b54bpuypkuwDNplF7/3HUoyy9f7bN88NU/ZUSfYBm8yi9/5jKUbZev/tm+eGKXuqJPuATWbRH9t/rzx7xb5vwqxjvfGFs3wGxuVDCXnxnsxmeWb/pRnW4LjxPbPxkff6Wd6lpjNNPRDrqF+rrr8VR/eSpVao3n99/t5K/cf+lGv077Vp3OQ4MaOn8Ph4sg8oXvj7559WicfuvyjhiF1/K8K2wUZl8rXJg+j9N4rgpfNSjHLdnN8hra9S05KszsOXp+vf+6/Pnx2UPn9sBaNtdP/Zm+cNU1puSfYBm8yif+T337PX7O1x9evuH938LORDn7SqwxT5jYhamPzcGk786CBHjdHKhl1XGHi87CO8WSLoGzEG+9heXys969X17/0npzKOC/bGyAYerz5/3X/KNvBdMS6xW+ae0a1DR5i6/3b/7fs/nrRwUPr5R09FtAzUZmQDj1fff/r+U7aB74pxid0y94xuHTrC1PcfPWkoVPcfrUpsGdRmZAOP1xu3/+R/2RQfabmO2418CuNnfp7O2xDzMWj814P+qzRlzODXl/nsvyLgtKtc8l6/69/7L46EnQWetz5/XhPWY2Tdf7b++/z5a7F33sD3n3G854+xo9fNvT0/8AjjvmNf7P7+D8WJqo2CaVVYrPH19pc0zzkEI6fB78Nd/5viSJF6/+lOwy7q/adVyTPX5y9rMZDV4+aIBX0jxiQ+ts+f7rQ+f76n+v73hrv/2/f28VZU36LYpzjIM97Qi+s+LeNHMl7oufpIU4xhG9cbOg0vQGV8rx/V6vrPXRO7w69lo+SmuqHT8AJUxo9kvLr+UYc+/74ZfI+UjTLLY+GGTsMLUBk/kvHq/Rd16P3nm8H3SNkoszwWbug0vACV8SMZr95/UYfef74ZfI+UjTLLY+GGTsMLUBk/kvHq/Rd16P3nm8H3SNkoszwWbug0vACV8SMZr95/UYfef74ZfI+UjTLLY+GGdsOzV2wjmWFsp+FbXysf+crmqFTGP9/YD4znP9QNfiwy3jNQXnNAjivq9nGF786tn0ev3/Xv/dfnz3rF+JOGo60EPDaYu46y8pGvbE6Zyke+/+ANAU/1//zI71EZj/49PlF/herXYoQe9xXak/6AUZl2JOPFCUP1azGGbVxv6DS8AJXxIxmvXj/qMKvrNSqFmrKFGzoNL0Bl/EjGq+sfdej6+2bwPVI2yiyPhRs6DS9AZfxIxqv3X9Sh959vBt8jZaPM8li4odPwAlTGj2S8ev9FHXr/+WbwPVI2yiyPhRs6DS9AZfxIxutm/8WfDBiGMmoQ8vL/csBmMM/4dQKcSyx3MKc9vRtNRqVRyAl7fSt617/3X5+/7j/df/v+s98i75i8rfb9V9+ju9UrC7VJ8V9O9v237799/+37b99/+/673yLumLytfGjuv/kbAsZXZaxmL4GF2PiiRrJcb4aYa1UkF1hW2PiiLiu/SFsnk1xgmWXji9rrHypwUzJzrorkAkuFN76oh9X3VdK0Tia5wLLCxhc1pxZ0M8QcqyK5wLLCxhdVVk14M8QMqyK5wLLCxhc1FxV0M8QcqyK5wLLCxhdVVk14M8QMqyK5wLLCxhc1FxV0M8QcqyK5wLLCxhdVVg04/ra5v/rnn1ZuK56Vo58/Y+dtm+WG+FA/f9wsS7rXx9frQ/P8x0LfgK5/13/cdkbz7J9/5e+o2Y5LHpRN6p//WXH6/vuWeP44/MmAeR78IXTgaCfrKXnq/ODnEj7mOHyOtnD7gNfrz9IfC+glPitW9VFevI6mrr8Xt/dfnz87H+cjYpvDhaPa58/6y7kyJnT/Qfe9KVL3Xy9M99/uv9ZEjn2kn/9mYY7V6ftP33/O52bcefr++5a5/+YbAvJTTjR6Rzxr+H9tDgE0ct9J5pv8JptPOcWc4gjgnP+1LTygkWP2yW+y+ZRTzCmOAM5ev7/+4wfi84VtgRy7a/KbbD7lFHOKI4Cz91/vvw9+/8VvCBh7aH9FV995Z7jRLTsOn6Mt9M9f70pkxfHaHQvYz993W2tswN5/owrxOm6fPn9+uLr/dP+183E+It1/+/4zWuhxd/T997YyJnwf7r/8kwGj9Kcqz1uXyzSARJxqhhAgI1IvhCQC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEAiwswYAmTERZ6pqALhrdTMQCLCzBgCZMRFnqmoAuGt1MxAIsLMGAJkxEWeqagC4a3UzEBa9D8ZADNm9L89Pf4JLn6cgkhbISQRCG+lZgYSEWbGECAjLvJMRRUIb6VmBhIRZsYQICMu8kxFFQhvpWYGEhFmxhAgIy7yTEUVCG+lZgYSEWbGECAjLvJMRRUIb6VmBhIRZsYQICMu8kxFFQhvpWYGEhFmxhAgIy7yTEUVCG+lZgYSEWbGECAjLvJMRRUIb6VmBhIRZsYQICMu8kxFFQhvpWYGEhFmxhAgIy7yTEUVCG+lZgYSEWbGECAjLvJMRRUIb6VmBhIRZsYQICMu8kxTrW/usv5tfTzVYZ8ZSERODBACZESomCZyUQXCW6mZgUSEmTEEyIiLPFNRBcJbqZmBRISZMQTIiIs8U1EFwlupmYFEhJkxBMiIizxTUQXCW6mZgUSEmTEEyIiLPFNRBcJbqZmBRISZMQTIiIs8U1EFwlupmYFEhJkxBMiIizxTUQXCW6mZgUSEmTEEyIiLPFNRBcJbqZmBRISZMQTIiIs8U1EFwlupmYFEhJkxBMiIizxTUQXCW6mZgUSEmTEEyIiLPFNRBcJbqZmBRISZMQTIiIs8U1EFwlupmYFEhJkxBMiIizxTUQXCW6mZgUSEmTEEyIiLPFNRBcJbqZmBRISZMQTIiIs8U1EFwlupmYFEhJkxBMiIizxTUQXCW6mZgUSEmTEEyIiLPFNRBcJbqZmBRISZMQTIiIs8U1EFwlupmYFEhJkxBMiIizxTUQXCW6mZgUSEmTEEyIiLPFNRBcJbqZmBRISZMQTIiIs8U1EN5m8IAI/I0TsIy71xV1YmcyIAxH1ZMmG5N+7KymROBIDI1XYQlnvjrqxM5kQAiPuyZMJyb9yVlcmcCACRq+0gLPfGXVmZzIkAEPdlyYTl3rgrK5M5EQAiV9tBWO6Nu7IymRMBIO7LkgnLvXFXViZzIgBErraDsNwbd2VlMicCQNyXJROWe+OurEzmRACIXG0HYbk37srKZE4EgLgvSyYs98ZdWZnMiQAQudoOwnJv3JWVyZwIAHFflkxY7o27sjKZEwEgcrUdhOXeuCsrkzkRAOK+LJmw3Bt3ZWUyJwJA5Go7CMu9cVdWJnMiAMR9WTJhuTfuyspkTgSAyNV2EJZ7466sTOZEAIj7smTCcm/clZXJnAgAkavtICz3xl1ZmcyJABD3ZcmE5d64KyuTOREAIlfbQVjujbuyMpkTASDuy5IJy71xV1YmcyIARK62g7DcG3dlZTInAkDclyUTlnvjrqxM5kQAiFxtB2G5N+7KymROBIC4L0smLPfGXVmZzIkAELnaDsJyb9yVlcmcCABxX5ZMWO6Nu7IymRMBIHK1HYTl3rgrK5M5EQDiviyZsMT1lWev2L/vDJyv1+y3q9T/rmKdNHMiAMScbkNhuTfuyspkTgSAuK2aRFjujbuyMpkTASDmchsKy71xV1YmcyIAxG3VJMJyb9yVlcmcCAAxl9tQWO6Nu7IymRMBIG6rJhGWe+OurEzmRACIudyGwnJv3JWVyZwIAHFbNYmw3Bt3ZWUyJwJAzOU2FJZ7466sTOZEAIjbqkmE5d64KyuTOREAYi63obDcG3dlZTInMvDso6xrD2K++CcDQIC3mG/3WkRLOSellcmcCACRY3cQlnvjrqxM5kQAiPuyZMJyb9yVlcmcCACRN62YOQAAQABJREFUq+0gLPfGXVmZzIkAEPdlyYTl3rgrK5M5EQAiV9tBWO6Nu7IymRMBIO7LkgnLvXFXViZzIgBErraDsNwbd2VlMicCQNyXJROWe+OurEzmRACIXG0HYbk37srKZE4EgLgvSyYs98ZdWZnMiQAQudoOwnJv3JWVyZwIAHFflkxY7o27sjKZEwEgcrUdhOXeuCsrkzkRAOK+LJmw3Bt3ZWUyJwJA5Go7CMu9cVdWJnMiAMR9WTJhuTfuyspkTgSAyNV2EJZ7466sTOZEAIj7smTCcm/clZXJnAgAkavtICz3xl1ZmcyJABD3ZcmE5d64KyuTOdEE9hsCxu9m1RcsoMePFgzjd0tBDlZ+8AABUedMTNUBszTwcXZo49Xrd/1tL/T+41HAoaunBxlinJ71StUBM7GBG3G8+vz1+bO90OePR6HPX3QGdIqaVTa0vFJ1wCwNff+3Wsye61Xp/tv9185J9988FuNI2Kt2D2SI4VmvVB0wExu4Ecerz1+fP9sLb9DzN94QcD0bH1/s1nHdvqVPKc/M8I9xeJihBxwm7P3f+9/2wht0/89bge1e3bfJcltPAFfYmYkN3Ijj1fu/97/thQ/D/h+/IWDuNt95+ScDPjzr+6LlHPX+7/Pf/a/7X/efD0f/7/47KjCeu/Qu2P2n+0/3nw9X/3n23P9zAhzCaEmn69kBFrGOHD+YiF+DNf4bhnjYdYfZ8Xx9/43ZMpelozXUF9ZFXNRev+tv32SNhtr7r88f+0f3n+6/thl8P/it43z/0LvJ2QEWUUdY1+n7T99/+v7T999+/ujnr/7+J79/s9tlf//3+jx/PBtvCMBr/IOSPXOMb+nHq58/+ucP/fOX/v6/f/7xcvz8x8+qb9e5Z2cf915uF/9+dSR84ftORAoOuv93/+/+3/2/+//L0f9r967ZTYc3U+zv492hf/7YP3/snz/aGenz/4H++6f/hoDSbJgQ1M50yOAcz69j/yHSCgOJCorMhKCaDxmcWBeRVhhIVFBkJgTVfMjgxLqItMJAooIiMyGo5kMGJ9ZFpBUGEhUUmQlBNR8yOLEuIq0wkKigyEwIqvmQwYl1EWmFgUQFRWZCUM2HDE6si0grDCQqKDITgmo+ZHBiXURaYSBRQZGZEFTzIYMT6yLSCgOJCorMhKCaDxmcWBeRVhhIVFBkJgTVfMjgxLqItMJAooIiMyGo5kMGJ9ZFpBUGEhUUmQlBNR8yOLEuIq0wkKigyEwIqvmQwYl1EWmFgUQFRWZCUM2HDE6si0grDCQqKDITgmo+ZHBiXURaYSBRQZGZEFTzIYMT6yLSCgOJCorMhKCaDxmcWBeRVhhIVFBkJgTVfMjgxLqItMJAooIiMyGo5kMGJ9ZFpBUGEhUUmQlBNR8yOLEuIq0wkKigyEwIqvmQwYl1EWmFgUQFRWZCUM2HDE6si0grDCQqKDITgmo+ZHBiXURaYSBRQZGZEFTzIYMT6yLSCgOJCorMhKCaDxmcWBeRVhhIVFBkJgTVfMjgxLqItMJAooIiMyGo5kMGJ9ZFpBUGEhUUmQlBNR8yOLEuIq0wkKigyEwIqvmQwYl1EWmFgUQFRWZCUM2HDE6si0grDCQqKDITgmpeMn9DAH9DQPxw8LXXxj+EiPEFUxWZCYFMdIZw4vNGpBsGEhUUmQlBNR8yOLEuIq0wkKigyEwIqvmQwYl1EWmFgUQFRWZCUM2HDE6si0grDCQqKDITgmo+ZHBiXURaYSBRQZGZEFTzIYMT6yLSCgOJCorMhKCaDxmcWBeRVhhIVFBkJgTVfMjgxLqItMJAooIiMyGo5kMGJ9ZFpBUGEhUUmQlBNR8yOLEuIq0wkKigyEwIqvmQwYl1EWmFgUQFkOMfb/OfeMY/6H8gL4zHuogcCwOJCorMhKCaDxmcWBeRVhhIVFBkJgTVfMjgxLqItMJAooIiMyGo5kMGJ9ZFpBUGEhUUmQlBNR8yOLEuIq0wkKigyEwIqvmQwYl1EWmFgUQFRWZCUM2HDE6si0grDCQqKDITgmo+ZHBiXURaYSBRQZGZEFTzIYMT6yLSCgOJCorMhKCaDxmcWBeRVhhIVFBkJgTVfMjgxLqItMJAooIiMyGo5kMGJ9ZFpBUGEhUUmQlBNR8yOLEuIq0wkKigyEwIqvmQwYl1EWmFgUQFRWZCUM2HDE6si0grDCQqKDITgmo+ZHBiXURaYSBRQZGZEFTzIYMT6yLSCgOJCorMhKCaDxmcWBeRVhhIVFBkJgTVfMjgxLqItMJAooIiMyGo5kMGJ9ZFpBUGEhUUmQlBNR8yOLEuIq0wkKhA5e1PBoSolvH+ivGQOrlttTr5nuVcjuzC/zpkN9e1ph4zzHne8Ou/dn3bX/2N17/37/7u68994/dez37oL7j+qy/+Q9dv/LHfLz63N/3nv35R59fNaEf9+b/J939//WsFev/j3at9/q0S3f+6/9k/1ui/12i/iG6RPWNohXvDP//oZ5MfPVHv/97/vf/7/K9tYual15247n9288i7B/4RaWwovC+g/kNS3kscdf/t/tv9t/tv999jBT6S959nr9hvexn3N3/ZT1yfv+aofEx9/yv3v1msJ0JUbxgc2eXN/fPntRT9+eO77f76z2fEvv/3/X9tEzOPbpE9Y9CF6/tP33/k+8+bbSR07iVHdun7L+5IUqYJy1k7cR/i87e8ISC/eLML2Ick3JLhY3NHtc1PBeFJEaY6O4cQuE+zN+T6z7/s+h9+1juuX/Hnv21+Xh99fb9f+ieuf/g//vzrB8pneoby2RESvByf//ETq5/D0bJ+dhxCsDr4myjcUW3LEk+K4hUfIUGvbxXQarwhz598NRPqR53sjsRHSOB2zfrzj2cjr4kWZivsk6K4xUdI0PW3Cmg1ev/1/vPfyGT74vjnoHmydNeQPADxERK4X7Pef73/ev/NnqwHYztZT4riFh8hQZ8/q4BWo/vPdb3yynhzwPifVWaG+oaAsW20aiO/e4mPkMAHadb17/7f/b/7v/cEbQxbe3lSFLf4CAne9P3nFTtM47PFK/r4W+fzL/cpftoEXhbN+v7T95++//T9x3uCNgY0UMYnRbq6/0idCAm6/1oFtBp9/+n7z5vt/rO8IWDZ8HYAxs8Yzq84GnpAzr5gV7fnh8FKKd7nDvVpT45a3Z4fBiulOGcCCnX1vPa3P+t6x7/2uddffT98VsOP/UXX7/vaP3r9qh88/t5jVNTHrYNNVUpxzgYU6tMeeDFvuh1lSqNSimkgCPVpD83z80q3o0xpVEoxDQShPu2hude3UvC3fBj2uh2Kp5TirCRQqE974O39t1bL80PxlFKclQQK9WkPvF3/tVqeH4qnlOKsJFCoT3vg7fqv1fL8UDylFGclgUJ92gNv13+tlueH4imlOCsJFOrTHni7/mu1PD8UTynFWUmgUJ/2wNv1X6vl+aF4SinOSgKF+rQH3q7/Wi3PD8VTSnFWEijUpz3wvnnrr78hwB/q7VPe3xDw5v383+pf//788ROVPOsntHYLzw/FU0rxPmeoT3ty1Or2/DBYKcU5E1CoT3vg7fO/VsvzQ/GUUpyVBAr1aQ+8H1j9117+mv2LQ//8NWtY0etf/zG/fj0V17XT+bQnR60freeHwUopzpmAQn3aAy8+r3Q7ypRGpRTTQBDq0x6a++evVor++WvuFkeZcqMopZgGglCf9tDc+89K0fsvd4ujTLlRlFJMA0GoT3to7v1npej9l7vFUabcKEoppoEg1Kc9NH/A+49vCLif+LlN9qx8MefsttrdqDt+fIDQEOODrllwUF6e9b/t+ju/86dcP+43/K3r/f5fa/jFTsIPvX7qH/7S63//D/6lN/nnj6/b/Vfzzf31f9k+/+++vuVrvur6J9/+2vX+b/2q6+9+/Xder77tfdfX/+2vu77p/c+vV9771deXfd13XK9+zD+/vuFvfe31jfYml7f/86++3vO133V9zKd90fVP3/Uzr1etM+yvu6//d17/n633Td9h633LV11f8fXfbeu99/rHf/sf2XqvXR/13q/x9T72Y953/eO/9XXXN9rfQn37+77qes8/NN+n/dnrve/62baevTg9wfIh3PE6uHpqptN1/3t5+i++bvdfzdw81VMzzBP7pT//vv/rw2z3HzsX3vbvTs0dH+cpBldPzfr8ZQX6/tP9t/tv91/pkIT2jG6/Zvr5+B2MflMaXcMq9Xy8G/30XD50DEYcXLKR6bX7T/ef7j/df6RfEBJow3iym2SnqWNrptO9dfrPK8/GfzA0uk1UCb8hoPtP95/uP9IhCAm0YczT088/S1FmipohBl0zHfnW6b/nHdOff99/+v7T9x/pkIQE2jAN3/HDBg0xhtYsOCgfzvNnbwiwf3XTHx7wIyPQj67g6kDjnJYiWjL/cAR+zUZOVIxZLxYunSuqI98A6z//v67/+l//6ddnful3lg913Gg+6t//o9c//JO/5Poh9kGPXzORr/pZ5Ke98DmAqDreAJ+/7SN+auWDs+St8PV/6T7/91yf98k/+frVf/m7uacIxhdyfA1vXq/6GwLeeX0M9Q9k//2N67/9Ke+4fs1f+S4bZZM/tcaijfXe+653xhsC5ppli9l80ThPYu+/Pn+2oez/39T3n5eu/4yzWk9xpgs/j7WG6ujz3/2vnz/GbdNf5XBY0s9f3f/7/vemu/+PXzNdX+MNAfa3p/v8x/cXaIbd/7r/df970/W/7H4v//M/f0PA6Fljr44fzT7xKi3eGn4///fzP89D2RyW9P2v7399/+v7n7WC+i1DaRTyfcPCH+5D1dH3n77/9v33Zb//8jcESCfwo5/HO9HWE2pHoLzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24Drme258L+MnLnwvwp5DxqP6xn2J/NuAL+GcDlqGvy/r4+Na5kUfUK0aMCFdw+VknUrfjOoTySiOPqFcOMQBXcLlqInU7rkMorzTyiHrlEANwBZerJlK34zqE8kojj6hXDjEAV3C5aiJ1O65DKK808oh6HW8IeIe9IWD8A/3pNdqb+T0ovuy/2P+i632f/87r7eyAOR7rgUH+/HrP9d/ZGxD+M38DwpwPpmPMNV/9FV9sbwj4WeUNAUvJOAPWA4E8ol7hGBGu4LLqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y5tyLNXxjNyPCfjiXr9VdOYWVcGl3NWJldNlN6J6hDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEAFzB5aqJ1O24DqG80sgj6pVDDMAVXK6aSN2O6xDKK408ol45xABcweWqidTtuA6hvNLII+qVQwzAFVyumkjdjusQyiuNPKJeOcQAXMHlqonU7bgOobzSyCPqlUMMwBVcrppI3Y7rEMorjTyiXjnEgP2M0H9DQHL1NwQkT4SJSQRYaeS6MrgcWpn8rBOld6I6hPJKI4+oVw4xAFdwuWoidTuuQyivNPKIeuUQA3AFl6smUrfjOoTySiOPqFcOMQBXcLlqInU7rkMorzTyiHrlEANwBZerJlK34zqE8kojj6hXDjEAV3C5aiJ1O65DKK808oh65RADcAWXqyZSt+M6hPJKI4+oVw4xAFdwuWoidTuuQyivNPKIeuUQA3AFl6smUrfjOoTySiOPqFcOMQBXcLlqInU7rkMorzTyiHrlEANwBZerJlK34zqE8kojj6hXDjEAV3C5aiJ1O65DKK808oh65RADcAWXqyZSt+M6hPJKI4+oVw4xAFdwuWoidTuuQyivNPKIeuUQA3AFl6smUrfjOoTySiOPqFcOMQBXcLlqInU7rkMorzTyiHrlEANwBZerJlK34zqE8kojj6hXDjEAV3C5aiJ1O65DKK808oh65RADcAWXqyZSt+M6hPJKI4+oVw4xAFdwuWoidTuuQyivNPKIeuUQA8H7GwLwX02WpTELrTKRaD6R5/bjiMKPxYyY70wc2d3rzbH+t19/53Pfcf24z/qy6/3zBzT8fMdbsp7/oOsT3/WXr7/2aT/SVWoG3hyf/1v96//h+Pzff33L//2F1x/7g190/cV/9B22cX7A9XGf/HOvX/qpP+f6xB/0NsttM9mHka8XnT99Q8AYOCawKcanYjCZikf26qf/r9d77Q0Br/oZx6ARxwx4revrevAg5mqn9T/m02w9+5MB9llez8aHyXXGGiM3ovBj3qEZT+/g9lefP5RP3uMotQwoV9GixlbTrn/vv7Ivxjkzos9f95/uv/tNR5i+/+D20fcfvsdeemlAuYrW918rhtfjrfn8V/6r0tlT4h+SRjJq08+//fwvN5sD7PtP33/i27e+/34k77/o5fj5B/p43O7lGnCe5NHjDfb337MO2uBGbfr+1/c/3RM77vsf2kf3/49k/+9/f+v91/tv/rBQnnECylU0v+l7/tb8/v91//ztoXOUc3+Vog9Zidm6lOIM0taoE8xpJOe4BWwWJd6A67/27uuz/5WffX3OP/heVmp8xPp65Wf899dXfPEvv37kK/q5qEPwZlHiDfj580N/i379P9Sf//N/dH3J5/zC6xf/tr96ff34E6H2Gq3Tv9/5Yf/29Wv+2B+8fve/8XHGfTD1/87rW77mq69v+LbXrrc9/+brq/7uN13f/r5/cH35X3v39T//qf/zes832a8e9d08Vquvt9tvCPhnx98Q8NT6tt5Xf/X1T779/ddHv/b/Xl/5977x+g6s96f/0vU3/kmcnfmZ2YL+GfrCr843BLzqWe9/f3TSlsAvz1P1N5OPOQ7kDLPEUX6yOqbr3/W3R1fdErJP+FhPnaD3n5dC6sG6LWCzKNHnr89fn7/uP9Yz5vfP2T36/v9Wuv88+yjZAHaLGNn77Vt6Z3nLIOj7r5dC6pEHp6LNokTff/v+2/ffvv9ay5D2Gw3k8fvv+PMvo8vEpDZP+dFs958sdvff7r/df7v/zlbpPROXx/svZvCo7XYjuv90/+n+0/3HGsPr+Pz3Rug/258M0D5ITIAPWQiHkY/reGWN0geEGE69hqI6MQH8QjiMfFzH6yOx/vu/9D+5fswnff719+ND4MeBj9Q/trf9O9dv//t/8vqsH/52cQHm54CPH2PjH/HgG5FK+QGPr2EqxqsPIxB1tsChqE5MgFFCOIx8XMer1486vH71/5brb/yud17/1mf99eu9VmStM/G/+M7rM//CH79+x0/4/q9D/Z9f3/0Nf+z6de/8pdfv+/LvsfXmKvaFHTeBkb366fNPBoxk3hmm64H1n1/f8w1fcP0X7/xl1+d9+Xf7+PFGh/F6ZmCsP/5EwXvfNX4jwXj5oo4CRv74+jmnzJyrKOmrCuEw8nEdr97/UQf9OqFiiHBkzBqifvQSwC2Ew8jHdbwwvtfPOgEhRqX0GorqxATwC+Ew8nEdr65/1KH3X+4TIERUKGMoqhMTwC2Ew8jHdbx6/0Udev/lPgFCRIUyhqI6MQHcQjiMfFzHq/df1KH3X+4TIERUKGMoqhMTwJ0E/6tSkwY7XvkPSekDQgynXkNRnZgAfiEcRj6u49X7P+rQ+z/3CRAiKpQxFNWJCeAWwmHk4zpevf+iDr3/cp8AIaJCGUNRnZgAbiEcRj6u4/Xo/nv2yiv+JRvjx88/XnttfWOXTz/UXOV1XH985DJzYiX9QxCi17eyRT3Gdbwe/fp3/Xv/ycnq84ezpEXxEyaEw8jHdbz6/EUd9D6BiiHCkTFriPrRSwC3EA4jH9fxwvheP+sEhBiV0msoqhMTwC+Ew8jHdby6/lGH3n+5T4AQUaGMocSfDMAmWt34XTqmUyLIqRyt/DEHOWMNssic+6VZ/33XX/tNn3h90m//SqvT8jl6Pj6fcUx/oP3ZgL9ifzbgEyyz/E3z+dunhk97fKrjdcxB1k8c7D7GlPGr0HQ6mp3Oy8ofc5Az1nD4mM3wBlj/+df//utTfux/ev2Jbx0f8N3ro69/4Rf8oevvfOEvuT5+lGx+bnR7DnLGGpYx33t98x955/Xx/+FfuOyPE2yv+g/0JmNqOI85yLpwZO+f6737uN74jQTvG28IwBRYB3HljznIGWs4fA5meAN8/ceniI88AT7xGWl4KodpxhpkEcxhhv78vRioXNffyhEteW4S7JWFZ8FUBzljDb3/UB5U9qV5/rEPePvYT/sBpvqFB7vPYUr3H98NtzXiXjnVG6JFnwCzzFjD4Wtohq6/FxGV2/YoSkzDJI45yBlr6PqjPKypEb3/ntx/eEPAuCnHY799BzruG1stbRr+Jx1TrOEwxgxd/yfrj616rjfVWVt8UWrhwe5zdP17//XPP8Ypuj0jOGI0TOKYg5yxBlkEc5jhw9j/spfH+s9fs9/Q+GFcP4v8kfn8e32ru35v3d//9f7v8+/NCJ176xGzVW08B6CXjbMFcsYaPuL9f/8c7APsr39//a0C2LkJ5r5GoGESxxzkjDXIIpjDDL3/vBio3Ju9/vkbAuThA3tsRBQCUTXg1BJBQ3Rlk4V4mdd//7uv3/Kjf/b12+zPBcRr/HCG/121HSpjx6dqr/FnA/7u//bLr0/wB783yedvn9fybat/rnrxz1Q+3dCEeJm//h/Sz/97rm/4gz/9+vhf9iXX91qRxzNNvG/cf2mP7rLretvPv/6br/kT12f8sI/W0jt+qP7/z2+5PvkTfuv1l7F/Zf3xK/zHP9CP33WRX8VE6wfwAa3/lb/1+jdtvS9ZB9u6b//l9oaAP4DfEFANuWqi6pgf4yYL0fuPN3+tHSqEqBpwaomgIbqyyUJ0/bv+8+ETe2ZE7BBE1YBTSwQN0ZVNFqL3X++/3n84Low4IYgUBKSWSGSHrmyyEH3++vz1+VuPzQvvf+s/Io0J8jcE5HR9/ux4SbuJygjR/af7T/efbBgT4YQgbgYjUku0+lzZZCH6/F3jNwTgRy2jfqOPo0KIa13dZ5cxTr8SnsrFx2+TCNH17/7X/U9OTECcEMTNYERqiVafK5ssRJ+/Pn99/tZjw7MlJ+XWoydxNfX5s+O1FVGI7j/df6z/5BsC9ATJPnF6zendhZ2hOYGZntvujP+mIWmidZI1vzU+1RI4yE2v5/rjzwX8q5/0++3PBZS3AdgGszXHx66vt73z+uwv/9PXZ/+oV980n79+erdfqsX0etZ/mdrLrtyG7YN8edb/rusrf887rk/4te/xXyOX+2luLgv4tfrPrp91/Zf/4M9cv/VHnP4khVThA/38v/73XD/3h//a63/5nrmVZT+/+mlfbL/C/2far/AfZL6+T19/X+8/t/VsFllrzP4x9hsC/in/ZADW21fbGXglmunl+frbx337Se3CzsjnDdiff3/930T3X2zrEXv/R+vUmmy4z3+f/z7//fy9PLuxT6xNdM1vjd1/b0vFmhl4Hfuv/yPS/LNaeBv66Q0Buvzruf56t/lwf/69/uv4/Rc2yfpFXHP4Dk9bt1aOMWCm/v7rzfPzr+VLe3dXSVt//Y/7P97cNX/wYeG5/ckAf90eql3YmSw7kZn6/PX5e7P8/J372kDv//WJSKszcZ//7n/9/X9//3/3pLY20TVnS9mFnaE5gZn6+eON+fxR3xDgXyi5ody8a4RfWfnqBxRimJB6HJdBjXchGBgPvBEGHS8jxt/OGo/E/nop1v/m6y/86k+8fvrnfZ1/yONjH5+Df3IWBM7k+18/8nP/4vUVv/7Hu8bPdYx+KT//8YHHp1v/AhTJKY6v9oBvtq+/f1pzLy87GqnHRz//77m+8vf+5OtHfMZ7YqG5ocq+wi575edcv+Or/qfrN3z82/SDerz+3/XHr1/5cb/4etf74mP3SefC/g/0n2//xf7cwPGpxjUWtytSj+Pygq//d33h9ekf9ynXH3ifW+dnFQtuf6IgJmOziKWwYIz/oNe34S9f/4nPtT//sRX6688DoefDyzIuLzh/Zun9LxV8KZ4//Mv6Ibz/zAYfy9SrHLeAQgwnUo/j0vuvn3/6+e/N9f2PH+vuP1aGj8Tzx7NXRn+OZ+TxlRjotXHfGq/uv1kaP3R9/+n7T99/+v5jvdEaJdqj98rZLz+S3/+sv+1F/2QAP0YF8gkEFGJ+Prw1dP/zynX/6/7X/c+Owhuw/42G/JHsv71+17/3X3zLFDdLO5CH31rh2rjI40ZAIVR3elzGkL7/vJHvP/GGgOXrqF9L/yruX/mgv69XrIso81VKMoFifwxiLkSZpVKSCXT7d/zp6zN+1C+4fu/XvWZb/WOvH/ADX7n+2bd82/V+F+sPasZh8CPxSb/r+ut/5dddP3GksIwor7qMZALF/hjEXIgyS6UkEyj2xyDmQpRZKiWZQLE/BjEXosxSKckEiv0xiLkQZRal3v83P+P6ST/p915/0/6knB/F4cO+kTGv/PjPub7kr//m6x0fJeRTEIsgitep7/7C61f+4E+53vXPTIBnRHu9+ulfdL13vCEg0seuOuf4fLDefEMAJzXt1V9h643fEIAxFL8PAHMhylSVkkyg2B+DmAtRZqmUZALF/hjEXIgyS6UkEyj2xyDmQpRZKiWZQLE/BjEXosxSKckEiv0xiLkQZZZKSSZQ7I9BzIUos1RKMoFifwxiLkSZpVKSCRT7YxBzIcoslZJMoNgfg5gLUWaplGQCxf4YxFyIMkulJBMo9scg5kKUWSolmUCxPwYxF6LMUinJBIr9MYi5EGWWSkkmUOyPQcyFKLNUSjKBYn8MYi5EmaVSkgkU+2MQcyHKLJWSTKDYH4OYC1FmqZRkAsX+GMRciDJLpSQTKPbHIOZClFkqJZlAsT8GMReizFIpyQSK/TGIuRBllkpJJnDY9R+R8C3BC39DANbBXIjgLVZKMoFifwxiLkSZpVKSCRT7YxBzIcoslZJMoNgfg5gLUWaplGQCxf4YxFyIMkulJBMo9scg5kKUWSolmUCxPwYxF6LMUinJBIr9MYi5EGWWSkkmUOyPQcyFKLNUSjKBYn8MYi5EmaVSkgkU+2MQcyHKLJWSTKDYH4OYa0bt5WPC7OMwDtL+Nxr96/HCXIgyZ6UkEyj2xyDmQpRZKiWZQLE/BjEXosxSKckEiv0xiLkQZZZKSSZQ7I9BzIUos1RKMoFifwxiLkSZpVKSCRT7YxBzIcoslZJMoNgfg5gLUWaplGQCxf4YxFyIMkulJBMo9scg5kKUWSolmUCxPwYxF6LMUinJBIr9MYi5EGWWSkkmUOyPQcyFKLNUSjKBYn8MYi5EmaVSkgkU+2MQcyHKLJWSTKDYH4OYC1FmqZRkAsX+GMRciDJLpSQTKPbHIOZClFkqJZlAsT8GMReizFIpyQSK/TGIuRBllkpJJlDsj0HMhWiz1N8QwGnFAe5AueS8iIQEfIZN5kXPteqcH8CB+siv//z6jj//H18/+mf+4etrxwfzUT/1+s1/6Mddf+4/+rzrS+0dAeNDPr7M9+u/7M9en/tjPvYoH6vzhvz87cP3j0s+OEKCN/HX/8P0+T//e9cX/MJ3XJ/6p77VFxzfD47qxsvecWXZ8+tfvn7aH/mL17s/9YfPN3W9DvWXf6CPNfP6dvsV/vkP9LkWv9gJiMRFDp+FR1vvV9kbED7f3hBQP0f7kwH2hoB/+gcOb0DwSWVmQgKulczxhMmHos5JHyhXnBeRkKDXt0Lh6znieGV1Iq/Xg3qgfIzzIhIScK1ken2tRa39yA7qger6o1RSHEICVjOZY4W9nHFR56QPlCvOi0hI0Otbobr/1D2Xu2PurxIO6oHq/WcV8LpIcQgJ+vxZmfr8fWjO37Nn4+9Ox9+axhGOf0jq/Re7LuueFUkONatRnVM5UK44LyIhQZ9/K1Sf/7rncnfUnRfZQT1Qvf+sAl4XKQ4hwUtz/sYbAvSc8De9jC90fjr+ZefFeREJCTg0mfvpYl51zpUOlCvOi0hI0OtbofTrOuqW1fEqLpeDeqB8kPMiEhJwrWR6fa3FUnxLD+qB6vqjVFIcQgJWM5ljheXLoM5JH6iuf9c/NpdsDkKC3n+2Tfr+U3tO7o7ZX0o4qAfKhzgvIiHBS7X/7A0B9thpvycDvxkiP42sEDjEoQAjpntF6lAMn/0w46Vd/5uvd//qn3j9jM/7x16RZ/Zf/r/nL33y9ed+yk+7PvNLv8sO4fKjGpzKy/5swO/8P66v+MyfcL1ilXx5P//cB/hq7lG/5orh7M//A/n6X9/6Z67P/nmfen3OXxr/uf76+iHXj/1NX3C9+3N+2vVxY4+Vl9ZcMUxP1N//gf4X+T/Q+9/5GMPna7wh4H32X+y/3fJtSZj+f/a+BFCPosi/XkIOFAMIRHFXdIEAEhQFFyGAcgnoKvgXAVfxAA8IURB3V2C9QHdFXJVDScLqyq6A7gIqeBBQA8oplyeHHOFUUAJIAkIu8v2ruvtXXd0z35f3vuSFl6QGMnV2VXd1dc/Mm/56ArQ+LQ4l45/9TZ14MM2cFx1Fu3Ej1nFTZ9HjvCPB+FQMlgBhrQmthsWhafwzq12j+wW1TR+WI7QaFoeW+x9M/mPqRK4hkoCIZhNaDYtD0+Pv8ff7H7//i/NB+wzh87/Pv+W9AfIEEFeTJrQaFoemX3/8+tP/9Sf+qhSjM81h+GRAIG3OWdzzL0XLn79X2b+/lHMyMrqENuctDi2ff33+7X/+bcsoZFaEVsPi0Mr5F+ZyuRFP8zd2CEApQCkJHBDWmtBqWBya2b9w2jX8/hdXWIFyIE6Akdt2thoWh67H3+efkTH/SEa2Z6iPfx//ZW4gTwAxmzWh1bA4NH3+8/nP57+R8vdXs0NAGqwB2IFr+TKIrQyDevBQSzNSfK8DdoOCamV/ylJk8E6NppZmZLn9p88FnMafC+iEl/w/55f8W9DvT96RXnHc7+gZexURZ6GN8eJKO3yBrr/2X+jVo1C5VLMAtJapDJdVliIoOCSopRlZ7vYPyXNUdv+p//uIf+fJ39IPvvJp+srXLqHZ9y3g58b1aOLub6P3HfVPdOz+W9G6kmLLOIYU/8XpkwHyi32pb1pnJm7kkwHygn6onwzo6X/RBXTkhukTBdIO057xH8QOAWphGS1tF2tpaQ/bzy6SJADVYiOWLzatrN1HL66WZsT9e/w9/zBa7DjTUZLHm7IUQcEhQS3NiI8/H38+/jB80sgIQEeJjz9c7zUkiiBwQ4JamhGff3z+Wd75x/6qNCYiL6DtyLfF2g/Pv5RzPv58/uHBt7zjr32Udef6+PPxF3KuZf6R3V7sUez0YhPHZK3VHwxuzfj9h49/n/8watLICEBHCQstX3StDGUHD7U0Iz7+fPz5+MPYseNMR0keb8pSBAWHBLU0Iz7+fPz5+MPwiSPDLAiAIEIdOGBXA0gWsZarGkwJoAHyCiC+gc2BF4NQgPEmbGgwww7gZ99/h574/ltps7dcSI9w9QfWeh0d++tZdNLktalzz+dp363+lX68SFrRcnAwBjrb09TrfkZn7LBOi0JLhEZc+9f0/l8D2l9/MiAMeElEorGHX0rzZ+4dFgRIlsff8adRHhkpiYcw/tMnA2bMr3bWYPvyyYC/8CcDdIcA9rFmzz/efu//eOlYYePPXIkwhJXFjJF1/fX89/z3/JcI+PhfQfcfOtkhpiXD5z+Jczye/ecvn/9l/o87BMRYpB+WEm/6FzsqTAxDuP8u0137OrD9+u/3P5JvPv7jcJAhloIRhpn9m1ZkDP3518efRgAhtIzV/fqLxV0yymTWxg4BMeH8+Wt173/NdUbWxPz39ucIeP/ne40QFQ6Ij/8cE3/+8vsvv/+M82WcK82MCTRAf/4dyvt3XRDQCJudcfJ1SrGGvkoEKXokSxpsMKREVe0R7/8B+tFh29Obz5ob2jfqdafRry87il4ui3w7v6Gv7b0LffCnT2rb9UFaEGk2rU0bf2I23f/ZnWitwFrV2l/VV5qkB/oVMAlAAmqerIr9vwa0fzH/Yn8i/2J/nnasImOPmEVPzNg3fDJAmYqggwGTACRg3f+yQ8BGaYcA1glDJY2XcfyJgnn8iQLsSNCYL9S3IHAAOEj/+ucuMSEVwKhN5Q1w/2tA/nv/m4wvUc9/z/96mWfOEMy7gEkCElDnab/+N8aTX3/8+uvXnzylVFhjvBRyTDCAq+/8gwUBtvlxhwA8aJp7WIQD0OdfDluMTyOffP71+dfnXzutFHhjvFTSOK50oolSkIA+/3Bc8vwzCjsEpKm7WBBQxLflfrmQI8CASQgS0ONfxL94nvH53+d/n/+LWcUSPv/733+K+dImh15X9EITpSABVa/leubzr8+/Pv8Wo8oSwzX/DvCvCWRmKw4dr8yVm1L80cHyiwKix/8KMxWjIkPxwGsRWNaI9T/vbHr/pPfQf82V2m5I2824mm46YovQLqKFdN/03WmLD11LcZOAdIefpAq2/BRdfvOJtJusCDDHKtF+U19BbZ2DqGJUZFZpEVjWiO3/0IJ8snXOjeshZ1Eo0yhYxvJZbT9/MmDqBgfRmU9wnUIKxzyW81h+QT+fX9CPTU1sNKNiVGQoFXhWYHYkCApp2AR/6RMF2CEguVVgzWTjKm7mJ4sa/pO6tfWsxl/q6POvX3/SjZHNy5zZEWvIKkZFhkKB1yKwLM8/v//x+z+5ApXX5cAwJztmArtiVGRWaRFYlo8/H38+/nz8yYRh54UwgfAJuSF0ul2OvyytlCsyFA+8FoFl+fzj8w9yzOZFSCBzasgqRkV6/nEEQkxaAmNZPv7WnPGHcYZhJX3v/b/m9L/2OyPxjsf//uP57/mPedFeFzFWABuyilGRoVjgtQgsy/PP88/zz5+/ZcKw8wLmHcCGrGJUZCgWeC0Cy1rZ84/uEBAbZqsiHEtbPGoX4sRCmajNZ7vPC3T4Rrf917e1D0tb/Nn2v5TmX3SAfi6AxryJTrrjO3TcS+X1aKzn0ns/T2/Y4nj68eLYVOFKLHQz9PDXm+1pGn824Kv62YC6jZa2+LPdfvcfItDSJej/KOLzqpz/i87jX+wfTDN4QUBIawZxVWAnLAiYN51/sY8nl5QSy9X+5G9m/ckA9jHu8Fm8Q8C+ukPAGhH/YoJtSbYW1nLFv/AnEbYOLJ46u4WFMlHE51U5/7393NEY4C2d3cLy/tfMD9d6z3/OH6RQmjb4r5zxpgi0wjqhLG3xVKCF5fkXg6Jnn389/3z86QwTkNVo/hkYlTsXT5fyRwQf/zLsOQo+//n8l4dInAdWo/HfuLfKI9/zfxUb/3jxkOfxpZyvSN44oxcXshaW3//qlc/zfxXLf+RuznGb4BZPGi0s2NAs8Ot/nkIQWL/+cUwwryIoAuuEsrTFU5kWFmxEEZ89/zz/6lTz8efjb4TOP2FBgF2FECc0mfBSFoeZTae3MBMivzO35KTpMgNRlMm2NQgs4QGCm+FVw/8D9INDt6f9/mcuDUiz9jqTbvvxB2kLITRuv+XPBkzhzwY8FdsuIZCDQyVq3GImxtPGn5xN9524I43R2IgNOVJMg8lot5Kky1eUxTIWj5xwDgX5pD6MjNFVL/6x/rG1ts0WN20U9mqVfyup/byF/7QND6Tp8uULubEJGceA0XGHX0KP8w4B41MW2hpF3JwHG3/sECALEORgn2EBTfB3KfvbOywISCPD859DFP7oibmi6IsQwXgabPyDdlAOlpVM81ol8fiHKElUyowMcbMnjz9Hg4Pg1x+bFYr79XdVu/+LXRdHvo9/n/98/rcjQic2IH7940gMz/VvNF9TQ3jZg2Sh4HI9KY5A8smvv0VYQPj116+/q9bfn2LmyrD2578YBRsRjGuFq8j8NxA+GSDzdGrNUsZD88KpmOdFI3P9/iNFjAFiETnhLIGSaPn1zwQlo3798+ufX/8wb4TJggcHJmFB80wro8Zq+vU3xkbigitSxM05hJRPPv+aoGTU51+ff0fK/Bt3CAhjOg5sRSVfMfPl3O2KSTk5QpGCiHx7bojVaZpeGwq2dDteFCmIpn5DLAwz6QdUinVr/yNfp0O2OJzOfZxX8HY2olfz5wKuO2JSUM/tX0IPf2sfeukhl9HTwoRTsZuOwN7ko3TRbV+k/Z4jzFWk/WiAgWhebn9ojtHIaKEr7KHGP5tSrLBZEKqiSEPs/tvznz8ZcORGB4UdAgb45Xz83VEcFmOPuJR/sR9f0Etgi5gWhIZdkYYY8ecFCFN5R4KZ86GRinBSjT88+sMnCtRYQlDC848DUgSjjlSLGPH3+SdPRRK2kEzN+LVxipAXRFO7Ifb4t88/Hv9m8nThFDlVEM0CDbHnn+ffUO5/mylVXnIaCVYWaIg9/zz/PP94kAz9+U9eIsllEvfmMtL4M4ACxFzr4eMvhkXD4/OPzz8+/4QJQ4eCDBEdIHG89DoXc0pBNEs1xOp06PMfrBc2CwIaGTbEI8R/XBAQZ3OpbWNhV25CAyvaVBAN1fJeTcQjpP39XP/QuqLJBQGNDBtib7/P/z7/8wBZs+dfb7/3v14K5HLh9z/5orkMrLimFkSzYEOsQff801BI2J6F/BtYynedpd9QpdSLpusS20pFKdJdhMmKKHX4ghu3G8+lpLTlRnXrQXA5uIZdXER2F2EsHMquOP/P0KPn7EObvGs2PS321+LPBdx5AX8uYJzWEW5p7nQ68CXT6AJR5CbIPYfUFB0d6cl0yOwr6ew91k/FUlsCFbRjgcS2UlGJdBdhsBGVVlz7tfrBuvuXeKym8ccnA+YjkRjyKj9eRRQ/GcA7BMgL+hXWftkhYCIvQJhn/CVUdiSYNxP+stzzbwXGP4Q15bLigoyk+TfUJtROTt7/3v8rbP4JWeX5n0eYxEIOH//dLvE+//j84/NPmjPt1Bknjnhmvj9/2CddBGr5n3/zLwtywBsvkjz+nn+rzd9f8t2JZHwcSWk8YVjloRAxz3/P/1Ug/8NczrfaIakFdOSTAXL4/bfffxdpELJCTj7/+fOHP3/49d9eI3RyAOL3P37/swrc/8R0TWM5EILL4fc/K+v+h9/tyc8J0iXF9kXsiXDuwjYavdGivBByyI1vOKI0nAtFyHHTk+mhYoVZIeTo2/8c+tYB29E7vxvfko7SzwVEs+V5Dn2bdd+RdOFW/jSkd/20Fj3/6EvovlP3pHWKimZLXdhZYRlYUX65278MZy1i91+lm8So7/xrCfAyWH3HP7ygP5hf0MeMlTpjN9JxR1xC89OCgGW4x1wW1Xrl38LzaRovCJgehhY+FxCdjmd/8wbpr65P3+1PhorytfFB0EX5Xu0vFLPhLuyssAysKO/+Y7RWhfGX+rXov2X0dZu4KO/97/0vEfD8T0Mljo5wLgZKEjPows4Ky8CK8kLI4fGPcbB/0iwClcQMurCzwjKworzHP0bL8y9lTcyOcC4SJSdVF3ZWWAZWlBdCjhUU/4FRbIhtijmYrhcEDKf/0JZlnNx/1d0SrxXU/8sIfRB7/Ktwe/yrgPjf/8IYKQZKHlld2FlhGVhRXgg5Wsb/KPmxBYuiCvdJWhBQlA+Fh3YqyvfwLz9QyvXKPrqws8IysKK8+4/Raul/jz+HRuOSk6rIn8weNFaU9/yLcdM4x+iEcxGoHN4u7KywDKwoL4Qc7j/GIT3dhhgVgUpiBl3YWWEZWFFeCDk8/jEOHv+QDCFHikRJ4WHQhZ0VloEV5YWQw/MvxmGE5V/8ZIBUrei1VFcAeQso3/9gINsJaF9C3gNms22/hjAFs6JhJnQk+X9kOh0UfvUvUXgh7fbN6+jyd724WefA4c8G8G4CL33X5bybgMSQmdLO6hjY5Bi68LYv8WcDukR2JLWfq9illlWrIpm7dTXp/zWp/bwgYBp/MiC+oC+7d1z1yYBSmqkh9f8S3iFgg/iJAliQXBMbsgBh3nTeIWBNij+C4OPfrz9+/fX7D54I1/j7L5///f4L18VBwCHdf8jNRtvh11+//o7Q62/eIQB3ynyNkHxNh+c/nlf9+dPuUYH8UJgTRVmK+Pzn898Inf80R7sgOa1H/vgPi7tMO3Qe9/Hn48/Hnz//82Tmz/+4nzMTZQ90VZr/uz7Y+/zv87/P/z7/r4T5v+WTAWl2DZOQ4O1/JcsTbctsLEIcrcVT6V4NHJH+l9Dcc/blF/yz6Slp39oH0/T7zuXvno9GayO07Z//TXrf5ofSWY8szWsB8t9uUrn6swHMHpHtz81MPZgZFrPtX636PzdyjWj/Yn5BvxHvEMC/2LcpK/iYtEMAfyijefTb/+Jvw4NoJvuzJsSB7BDwOO8QAH9rRPzD2GkdQCE+7RIOlg1eq1KKHoOuDxg+/6RLX2sAPf6cZu2R8fzz8cc5gKM1SXz+CaPH51+//vD4aB8inBxB0Cr16w/PL+2RYYFMLzhalVaf+ScvCECDufmy6R+O1bz9aGYBTfPbk2T16f+i3SC8/YhEl0nC+z8EhsPgz3/dUoSDE+bO1gl0WK6/9W4vcYeAlec/DxrG/Pl/pfe/x99EwPPP828lz78m+3z+8/Hn48/HH08Ja9b9l34yIEyG6TnJTowlK1FgAtoCxhDEgKpWMAxhUOiWrESBCQhlhVEAMWAlTqSRGhS6BavzG/ra3rvQB3/6ZBCv9dZz6P7vvJM2hrLCWCqe/0DfP3Q72v+/57JUkitZDCjjAY6h9Y+4iOZMfwOtX+Vf0k6WEwUmoPoFEgUQA0KKKkTaSA0K3ZKVKDABoawwCiAGrMSJNFKDQrdkJQpMQCgrjAKIAStxIo3UoNAtWYkCExDKCqMAYsBKnEgjNSh0S1aiwASEssIogBiwEifSSA0ahPyCfmp6QY+yaSN//cX+uCpfo140BHOAsNE1//iTAVP5kwGyIEAGxgDvoSb3JXKMDQsQ9uYFAewQBgGjijlHAcSAqlAwDGFQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgMqx/VSrl8CLJqIXHTNjU++fAgJYU5H/V/XzJShSYgGoYSBRADAhp6cdIDQrdkpUoMAGhrDAKIAasxIk0UoNCt2QlCkxAKCuMAogBK3EijdSg0C1ZiQITEMoKowBiwEqcSCM1KHRLVqLABISywiiAGLASJ9JIDQrdkpUoMAGhrDAKIAasxIk0UoNCt2QlCkxAKCuMAogBK3EijdSg0C1ZiQITEMoKowBiwEqcSCM1KHRLVqLABISywiiAGLASJ9JIDQrdkpUoMAGhrDAKIAasxIk0UoNCt2QlCkxAKCuMAogBK3Eis7Rc3BU/GZClop4oMAHVMJAogBgQUpiJtJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEaFLolK1FgAkJZYRRADFiJE2mkBoVuyUoUmIBQVhgFEANW4kQaqUGhW7ISBSYglBVGAcSAlTiRRmpQ6JasRIEJCGWFUQAxYCVOpJEymncIAB9QSzeRqNJdsSmpOZlWDAhg061yokp3xaak5mRaMSCA6i0jnXs/T/tscTz9ZLHw+HMB51xPl7+z+bmA0sRSmn/RW2mzt1xEj2RTBpO/wHCJDd5PZ999Jh3yvFGNP8oY5YBG+6UXq9OU1BzQC+jRe++lPz+1hJY+dg/d9qcFNH7pXLrz1ofpr6OeocV/nkO3zX2GnjfqYbr9dw/T0+MW0ON33UP3PPE82vrUa+iWoydbt4pH6x1a9Niv6Irvf4cu/vHV9Oubb6WbfjeXwrteaE7YlDbdfHOa9Ortaccd96D99t+VtluffwNe/VEK6oCw300RrYO+PkgpI2soBgSQltBf77+Wfjb7Mrry2l/RLbfeTnPuuotu+/MStSL1HBh4Ef3Nq7agzTffirbebifabded6HXbT6KJY7Pa4P1zzB69h+7809M0hvthzu/n0lOjn6FFf7qLbn94Ca29+A/0yzvn01pjF9C8OXfTfX9dSuMev5dueuDp+II+/YJem6BVqDmZVgwIoJTlTwZM5R0Czpwv2+2Vx7gjZtG8GfvqL/at1JqI/JqTacUEqT4ZEEdGXIIgCwLmFe3TktZ1wJuSmpPpiHHcH/kNXfuT2XT1jb+kX//qZnrgwXvpxtvncxZgCQT39Qsn05Ybv5A2+ftX06tf9Rraa8/X0c6Tnk9FV3MNsnVUreZkWjEggCjaAqNKd8WmpOZkWjEggC1+wYoq3RWbkpqTacWAAMJZC4wq3RWbkpqTacWAALb4BSuqdFdsSmpOphUDAghnLTCqdFdsSmpOphUDAtjiF6yo0l2xKak5mVYMCCCctcCo0l2xKak5mVYMCGCLX7CiSnfFpqTmZFoxIIBw1gKjSnfFpqTmZFoxIIAtfsGKKt0Vm5Kak2nFgADCWQuMKt0Vm5Kak2nFgAC2+AUrqnRXbEpqTqYVAwIIZy0wqnRXbEpqTqYVAwLY4hesqNJdsSmpOZlWDAggnLXAqNJdsSmpOZlWDAhgi1+wokp3xaak5mRaMSCAcNYCo0p3xaak5mRaMSCALX7BiirdFZuSmpNpxYAAwlkLjCrdFZuSmpNpxYAAtvgFK6p0V2xKak6mFYfUXUUAAEAASURBVAMCCGctMKrE86iBUXy/KXg+lvIq2vIRqjaaacWAAGZzDSyqdFdsSmpOphUDAtjwmhlRpbtiU1JzMq0YEMDsroFFle6KTUnNybRiQAAbXjMjqnRXbEpqTqYVAwKY3TWwqNJdsSmpOZlWDAhgw2tmRJXuik1Jzcm0YkAAs7sGFlW6KzYlNSfTigEBbHjNjKjSXbEpqTmZVgwIYHbXwKJKd8WmpOZkWjEggA2vmRFVuis2JTUn04oBAczuGlhU6a7YlNScTCvGyMBonrWFkQ79ZAAY4DPk5QLhXIkC2ZTUnEwrBgSwzXDiRZXuik1Jzcm0YkAA3X/XCMQQdQ9UU1JzMq0YEMCu3vH3re6KTUnNybRiQADdf9cIxBB1D1RTUnMyrRgQwK7evf9jiLoHqimpOZlWDAigx79rBGKIugeqKak5mVYMCGBX757/MUTdA9WU1JxMKwYE0OPfNQIxRN0D1ZTUnEwrlhDeIQC/wYV/qAiUI76W073FIGaJQQ1VcsWCPVQaEKWMCngC5Rgp/hfRfTN3p0lHXkuLuUoD4w+mr/DnAqbp5wJsvaXO5ph3Nn824D30jUdim8LnQNA8UQtN3JT2u/Aaumj/iWAkA8PZ/pvo9F12pqOvWRg7s/KcKtAEAxNo8inX0u+O3jpUPSqg/YvpyTsupG/8x7/RyWf9lh58pqU4N6nIutREGr0JTf7H99NHjzuKDp08IdkezvajzqaOT/6GZv33f9L/fee79L2f/alcwAA1rhL/eD09uxVE0Bh44Wvo9W8/lD4w9e10wBbrmhiZMRNc1/4X0t2n7kSbHfMreGqHhctIjDscL+hrm6UJlbb6F11oMOQFAfhkQGGFXY4//BL6C7+gH68CU65osSoEBFrRjVJRif1N2+ggml6sGomicexv3kz+ZIApYlBWAgUYy9VnlQpCj9KdF3+dvvbNb9A537mDHuJc5aalfq1LGlrjvzZN2PYNtP+7DqEj3rkvTXnh2qm0WGk/Cv+SRI1YgRcqmOSMY29HiFliUEOVXBYUh0oDopTRAU+gHCki7l9DgS5DpGKcQAFGbn1WaUCUMmrgCZTD4x8y3fNPU8HzL44MjJSSKrlRls8qDYhSWUFnVZHJ4ePPxx/ngs8/OhR8/okzQzl7gAKMOvVZpQFRyqiBJ1CO3vOPLAgwDyOhROORPnDjCdbjNKdUi8bg/Evt4gFbgOCXUKUBUcoogSdQjt7td/8xSvlpAPEDv4QqDYhSRgk8gXJ4/P36x7ng1z8dCsN1/ZMdAtJoCyMPO714/nn++fjjkYHBIZAPXKlKquRGWT6rNCBKZQW1KjI5klOf/zQUwzX/xXijTzz+MR6ef37947Hg84/PPyvh+jfA3xvknxNgEo5TUNu5XQNcwLKk/GEiboMlv2GIN7tBg9WR393/MFHZYjLdBxgB/AIaEaMr1H/nt/y5gCl0+E//GpysdcC36P4L3s6fC6h6yVQh+3+Avn/Y9rT/We2fDYgLBNai5x76Hbr/G/vR840NoF1ayOLB+O8W/1/S6TtPoY9cu5BjlewEYG2K5/qYwDsE/IJ3CNiKBUZ38T10+Zc+SEd9bjbd/CSX4/8HXrgDvW7f3WinHbelV24wNqTauLXm0Z9uvZGu+eH5dM4vHqWlbKLwP2pLmvJvX6PvHbsrTRTzfAxP+2GYrS+8k2Z/9RN04pe+R1fKm2H1KJ7lWI82euVraLuXT6QJi9alTbfs0Nzb/kwLxy6kx++5ix76wz30ywcWcvuifgjnwItpm/cdT1888VDae+PxOX9ZpT3/F9Kc06bQ5h+RBQFiB7EV//VRysaZX9BDM+dft/5nzeAGvlAywbAg4CCa0faC/ohL+Rf7r49b+Gtdy/JD9i/++JMBM+ahbYD4ZAAvCChcoN6AhbDH+F9Mj/1qOp141GfpjKtN/o3mX//v8Tra9RXb0BabbkpbTRyj/TmO5tJ9v7mGLv/JT2j29Q/zQpFct+B1wra027Rj6aR/PpB2fP5agTXk9pfVL6guLWQd1ENgebj/1ej6w13b0sOJ2yU7Vqfrr7ff+7+c3phC3gOWCj7/+fy32jx/+Pzn8185vYX5b0AWBOCQF0p8zZdHejl8/vP5z+e/+Hy0yv/9icez3/+Hac2ccN8HaESMrmrzXxirIV1TzqZ5XFrVpYUsibqt2eHPf6vP359TT0su5ANZAZglgq1q+V/WvqS6tJCVPP+7zg4+/n38y8slvnr4/c8q/v4xzXTts2KX2dHHv4//IY7/sENAkU5KKFLmYAsFTbl/jS+3I1RVKCijRAqxEoqUyi0UNIfTv3wuYN8tj6cfL5IK4Nf8Lwi1GYz/py97N71sr7PpvlR/3MYkMoIN+bMBd/JnA9aTP/LAaqHRSkBz6O3nBQG7TKGjr+YdAsxR101pRSbQy069lm7lHQLkEP/02E/ptPe9l/7pwj/SUhpN4172/+h9xx1NH30r/+L9uaPbnle44KN06zkfpvd++H/phnnBilhKt3gTaZuP/y/N/uzuuiggCFtO/bdfjD1ND15xMn3syC/Qubc8HaxrM0M73kLvPvIwOvStr6UdX7ROy0M5emoJPfHQrXTzjVfRNVfMou+dcwld/af4eYFRG7+Rjvj6V+nLb/y76oV2bAzqz6sSaM4pU2jSR38ZYxrFesubkSiI9eQzL+iRX9A/Pp1/sc8k8iAVRwWVrJHsnyVKMLLoAt4h4CCayQsChG39ywKE+bxDgGyXjyLwCyhFwgEF0BVUsSwI2JD9PZH8JT1pp/1kQFV8aP47f6CrTz6E3vOJn9OcsHvF+vQ3+3+APvSut9KB+7za5KrWqnK3gBcTnEOnnvhvdPpF99E8CYpuF8H4i15Ph33py3TKwZNpglRcjm6morQUq64iSas7gCbiDqgloKCMEinESihSKrdQ0IRfQFWFgjJKpBAroUip3EJBE34BVRUKyiiRQqyEIqVyCwVN+AVUVSgoo0QKsRKKlMotFDThF1BVoaCMEinESihSKrdQ0IRfQFWFgjJKpBAroUip3EJBE34BVRUKyiiRQqyEIqVyCwVN+AVUVSgoo0QKsRKKlMotFDThF1BVoaCMEinESihSKrdQ0IRfQFWFgjJKpBAroUip3EJBE34BVRUKyiiRQqyEIqVyCwVN+AVUVSgoo0QKsRKKlMotFDThF1BVoaCMEinESihSKrdQ0IRfQFWFgjJKpBAroUip3EJBE34BVRUKyiiRQqyEIqVyCwVN+AVUVSgoo0QKsRKKlMotFDThF1BVoaCMEinESihSKrdQ0IRfQFWFgjJKpBAroUip3EJBE34BVRUKyiiRQqyEIqVyCwVN+AVUVSgoo0QKsRKKlMoVFRYE2PtPvptculRehBvFZZgqxEooYgy1o9BEuwFVGwrKKJFCrIQipXILBU34BVRVKCijRAqxEoqUyi0UNOEXUFWhoIwSKcRKKFIqt1DQhF9AVYWCMkqkECuhSKncQkETfgFVFQrKKJFCrIQipXILBU34BVRVKCijRAqxEoqUyi0UNOEXUFWhoIwSKcRKKFIqt1DQhF9AVYWCMkqkECuhSKncQkETfgFVFQrKKJFCrIQipXILBU34BVRVKCijRAqxEoqUyi0UNOEXUFWhoIwSgTgu3sl/ZpEXuoM5UB5+AbUsFJRRIoVYCUVK5RYKmvALqKpQUEaJFGIlFCmVWyhowi+gqkJBGSVSiJVQpFRuoaAJv4CqCgVllEghVkKRUrmFgib8AqoqFJRRIoVYCUVK5RYKmvALqKpQUEaJFGIlFCmVWyhowi+gqkJBGSVSiJVQpFRuoaAJv4CqCgVllEghVkKRUrmFgib8AqoqFJRRIoVYCUVK5RYKmvALqKpQUEaJFGIlFCmVWyhowi+gqkJBGSVSiJVQpFRuoaAJv4CqCgVllEghVkKRUrmFgib8AqoqFJRRIoVYCUVK5RYKmvALqKpQUEaJFGIlFCmVWyhowi+gqkJBGSVSiJVQpFRuoaAJv4CqCgVllEghVkKRUrmFgib8AqoqFJRRIoVYCUVK5RYKmvALqKpQUEaJFGIlFCmVWyhowi+gqkJBGSVSiJVQpFRuoaAJv4CqCgVllEghVkKRUrmFgib8AqoqFJRRIlbc+GRAFFoVvM9KvIa30niTyrYCxif9dXRTOb0cy2VEJVKJ96z4X0B3nboLbXPMTRTWA/CL+2/OOZPeNcH8OqOlLZGV6v30hfSRLQ+g0x5YqpryNxuR6jGwGb35e1fT9/WzAVEyfO1fQI/eew/9ib9FH75Zf8fD9NS8O+nmG35C3//eNfTLP/ML7fDHpljTXN91aevTrqFbjkoLAh77AZ3wlnfSZ698gjqjt6I9/u10mnnMXjRpHEoITP3IjSn7fzE9evF7acp+36I74lYBsdHyonX0ZNr/OxfTd/d/McmXMsOj0ors/0V302VfPIw+8Kmf093ychirWaQGE15F+55wGp35oV3oxWNkddkQ/S96iG75yVfppGO/zAsNFnBbtqZ9v/UD+tGBmwY3MSLiqDwWPnY33fXQUzR6rYX06Jx76bGn/kR3XH8pfffsi+naPz2T8oVLS7/IkcC4qfyCnhcE1N+zT1FXVXRnN/+xlamtsiBg4oH6i30pE90N0Lips7r4C67MKdlKZXv6X3w+TZUFAWFHglTDVGDsERfTEzP2pbHL0/+dP9JVn3gTvflzv+YX+WvTejt/gD7+H8fSh3d6kS7UKNqfWlHw1P+jdJssZvnQ/9L1spgldUnUnUibf/B0+u5XDqJtQofEtgQZn8r8N6FCjJBrPf2X5bpTsUYid/9x2Hj8Q7q2pkzMlpwzmjfISc3/1uItzGzL88/zr+f8z9nj+SdjM48ZH39VTvj8wwmS7o1aZtsmK+eSz7+r3/yLl0j2/rN8keT9LzOqzqMcDr//Q0S6zRY5ZzRuuCb5/Ovzr19/mgOnKyePpYD1mH8GRvHfE2V8hYPvAjvxb4XRQjw3f+3R1XESpHJMBYxPPv/5/NftDjJmS84ZSaKC5/O/z/8+/6e5dTAgj6WA8cnnX59/ff5tHzvFtSapFDy//gzr9adaEBBDH/pBUUVKNlPom6BRqqWuBOgphJJY5H9pqCiqSNCz1Erzv/QX9B877k4fu0F+ST+at/b/Lj3AW/uvx5UJ75Cl1rZioab2JMJH6LKPbEd7nfYHbiW3MRRgtojSIS0ffcC5/CmCd9DGak+RoGWp4Wt/hxY9+G362D6H0uk3L7JVTDWdQJNPu5Z+9+GtaWDRL+msd7yBDvvuw0Tr70FHnvc/9OW9/lZfsMYCttbJRAEepEuO+Ht645kPNnwNvOi99LUb/5Pet/GYUMJaWq72L/o1nXvom+g93/ojhR+Ks3WJf7C/6QF07FnT6XOvncg867HI0O75v/B2+ulXP0czzr6ILvrNfLYvNvhY/010wpXfpk9PXifSjbPxpWhCHr2IjnvD2+nkG3hxAR8h75JZqfm4w2fRvJn1lvpwoMbA6AKNnqD8gn4a7xAwveWTAeN5AcJfzkg7ErDqsvM/jesungN70Xm8I8HBxScK0CeyA4K0T96vw9LQ+n8h3XfWG2m7wy6nx2gtGr/r8fTNcz5Gb9vE7vpQtT84Mjz2balOZzH95cqjaN+9zqQbFrMElQ2NeS5NfMcMmv2Nd9E242ypIOxyMnqKKhLKWGpo7UfUuriurasjRWqN7vnfcFHaaIiVYfQUVcT9cwRsNLz/echxWoeY2MBoPgHpKYRSGV0tokjQs5TH3+Pv+efjL8wJdmIwM0pEewqNttFTVBGffzgCNho+/xKNGiX3denGM4FyQYCkjY2a0N0Oo6eoIqGQpTz+fv3z659f/8KcYCeGxvTSU2i0jZ6iiqz2888oHkzSWhxxHl9z2l9cp7TZioSwWMqvP3798euPX3/CnGAnBkygCnsKVcvnHxMnRRXx+ZcjYKPh1x+//qxu159qQUCV8DwA5G8M7UccGnaAtOtFbq0d6JbClmXxpu0o7a2TS9XagW4pbFnAO7f+K+30ipPoOlmw29mU9r/wGrow/YofOtlTOyZfcVkwWz4bcE7zswHpDzmh5NoH0xn3n8tbp48uJp+m1eh58P6lL7N2wDKp5jNrEf3xrL1p0mE/5031yz84DZB8MoB3CDj6RfTLz+9Nex5/Iz0uiwEu/BZ99bUvaM2ZaDdbD1gmaektx9OUV3w+xtjGg31tcfIVdNvHtuVdAuxRW7SyJl5oL/w1ncOLAQ799h8pbOpv/a1/AJ103f/QcZOea6LVtIeRYpoQlRZdRzPf8ib60KxHGgsN+M939JwDvkm3nv9O2oR9tr1Et/YsLv4eP+8f6G8PnkVPsSeR2UN2CJjHOwSMs0yDR1vZYsAyqZqW1ZEFAfyL/Rnz6/6XLfx5AYL8Yp9LinRZR7SbrQcsk7E4fzJgqnyigD8ZUDaQFzzwJwrmzdjbtK+22LsGSx88g96+zYfogr9k0wO8S8CEHf+Rpn7yE/Rp/pzD+OQW7amrV3qA//l02yn70s7/dC09LqzieAG9/PPfp+uP3SHUe2jjL9YTdSnMBgL+V2D82a5ts8Xdfx0Bj395RanjU9J1tALdkmCWZfHSmlBR2lsnl6q1A91S2LIsni0Bi9LeOtBt1jaUaylsWRbPloBFaW8d6Lr/OlqBbgmeZVk8RxJYlPbWga7Hv45WoFuCZ1kWz5EEFqW9daDr8a+jFeiW4FmWxXMkgUVpbx3oevzraAW6JXiWZfEcSWBRancIwD1zc0GAxz9GK0c0YJlEUP3+lyOBZ46W8GicmhllRC1otJUtBiyTWsKyLK4KikRpbx1VbtwthnIthS3L4tkSsCjtrQPdZrRCuZbClmXxbAlYlPbWga77r6MV6JbgWZbFcySBRWlvHegOLv71XL6U3zhgLGZLwFa8f7Fs22NxeM3Q/fvzr/2LVs6MNqzOlkC3JJhlWbxpM0p76+RStXagWwpblsWzJWBR2lsHuhhXWTtgmVRFy7K4KigSpb11VNmvfxwKm60hbi3BsyyL50gCi9LeOtD1/q+jFeiW4FmWxXMkgUVpbx3oevzraAW6JXiWZfEcSWBR2lsHuh7/OlqBbgmeZVk8RxJYlPbWge7g48+/8owH33x2OZZ2osxoKKpIVbYbX9QgA4xFS8qae7b9P9G5+fPbdkbHmHZoo/d3zv4Lagto6yt4F/5T3+t85MUDnbQQmPsyvBKu4Mad3c++3xh89tq/9JbjOjuEdqOefF8RrqrrdiafemtnwU0f7ew4lnmjX9k56Ed/NK3u0v7QKsgAY1OXLr2i89lXjJX8lh11AhQ8/Nvy053Llxh9RRUx8RK0G19E93cuO3qz1J9oV4KpHaWxocR/Qee+/9q9s57UO8Qp2bX4mP07p/xxcaOO3Wts/N/56c4uyRZ/xCDGKtH8wryzQCve3VqOTalTUsnQwvM6UydIHyBOuV3jj7iU/bWWarRNqxUQlAGM0kAlf43+Z//jjpiV26dFFSldNOr1ZOcWM4Yb42/05M6+/zen80xlBTWLXowvRROy4MedT7485q7GCn2+3n6dk+7MPTOk+IcKmP5H/Wr/4CtUBeVkBDLAKCmprC31jTKjoagioUAcry05j1ik8dyIv+ZXymmMe4XN/KvzX+cK2LI+Lc423X+aVxGrCraNP41viqXHP+VqlVuN8S85XOl4/nn+FXOlj790v+fzv+SFz7+YHwD9+j+U62++x7T3ccBxzwYY+SUFXYGDv//Lpbpby3UrdUoqW3L/Hv+YGyZDFFXEJkzI2YphSJQBjKKSMuqe/4N+/stR6x5NH/+IDWDOPzw7+PUf131Av/4P5fofdO0zp8X97x/+95+QDzK2MK5K6PMP5h1AxIfpNJb8718xJvFvWSY+yCk751jc5x+ff0b4/JPvYwVbs56/eEFAeWOayYpfRilQpQYClxQLIROJXlrwRbdiKKlIMtgEpcYw+X/mms4Xdgh7fvMFdHTnOYde1Hk0VWXo/ud3rvvXzfOFWAcGLjwRrnXAuZ0H67g0m19pDEP77+QX0PJCo/FvQmfrL53fmbHXBJat09nkqEs6f+aOLeJRE4nu3v9zO7OPCh9KiP6K2Lyuc9wt9qVqDEbhgr0XdE0EekHnnq/v0Vm/uGihfWM66x96YechfStcGGiJfp254v+2zllvfF4jXnqDNSAXzs06B178F2Ov8qOkIln34TM6B6yN+pZQXpg/nTWryrGtZK57/FNhdcuILggofUk+yAKEwt+g4s/VUPuorGEs/L/O1OclX0X/R391BpiSbKxX//+mc+Yea/PNnMQf/9iP9bHJRzoXPcUW1agiqGgDZo2FnT/+12s7vMNAsm/jtXZn43+5vCOm5ejZ/qAQ1EQTSFdYavRqP2sOs/88R9ibwxiHMv+7xL+eY2zf1LKetPvPfeHxl1h4/qX5qNf8V48pH3+N63g9rtppn3/quPj48/EXcsLnn+73nytw/g03jMXN4fDf/8kNZu0y37i6fwRndb3/9/73/Pfxn2c8jPfIGdz8V9w3+f2333/X9wSDov35oxhHHDN//vDnD3/+4Bzw56+V8vzl80+ab9L1alWbf/WezdzOtaHF/e5q8vyrOwToG6PU8vx4k7FGUMqIqLhmg47QnrUII9CKvOw1Y1Y74GURFdds0BHasxZhBFqRB6/P3HxsZ4e1JMHlRmty55DLHsuFyiLKr9mgBS65bmpnyzBQmjduOpGsfXDnqw/Lr8jlQE0iVZxhuGDWLcl0VLdnW7A0FrwuPD/+Qjw8nKT6Bvy5nRf9/badTaQdLzq08/UHUddor7Q0WP9Pd+46ZbvqIQA+X9LZ78K5trLtjpJGN//P3PHvnX3XxWRVxX/M3p1P355fceeoZ6xRgdpR56bOaTtj8UjpB5PiAP1d58BZj1XZJpZLY9lrxsILeq2/udHl3JQX9AuX0f7owZ5ti1r8d+3/+IJ+YVlEjdVs0BHasxZhhPmNBQjof/EnOxJUBwwvg72U7R4ZdjooY6bjLYzH7TpHXveEWspRz5gKgVj/vFjjwNbFGtyGLT/V+dkS9HCP9sMuw+w1Y0YcUevfCGs2aOsZvFys5GSvGcu6CTNFJJbI8TKusQ8hA8yrkzFO2mDuf9U3fyipbWXa2nL/tm9yjFJsQ+7beFnc4x9yuXH9izGqY5npZgwhA9R89vhX1/xm7LAqP/eFx9+OaeRSzq1mDCEDRJkQ06456OM/55yNheef55+934m5kcfWszv+zG1ZuFEDHaE92zs6aEVevuvLmNUuDFeC0hLuewHdv4SrjlHNyVHPWBXmuoiKa9ugbeTB00JVjbLXjGXdhDWNBEHNBh2hPVuL0Iq87DVjVrvVUVIoLeUwWc+1TtZy/xKBHPWMpfBm0AxikNVs0BHaczbl8V/ach9s7zks7vcffv8xcu8/ymeK8t4o3yOlfO767CE5bnPe4p7/nv+e//VYyvSz+/zh49/jn3Ng1Zv/5a403/VmzN6tBhw3tpWgZoO2d77g5aIlJ3vNWNZNWFlExTUbdIT2rEUYifywIACr1gvXsKKqxpCRBUPZgPUQSxa6lTiRubhRbqCREc5GNrz+53Wu//im4UY9TLabHNO58KnYrNwSrkxuQGYHTGQVa8lPO5+atFb3m3++QRoY2LCz/fTbtWA0Yc6FTSaG4l+tZiQXN4YFNS9oy4sND/LwkmSdzks/e31ncTaQjQZM6laxWkgUX3Dx2zoTQvvrG74J/ImCm2Gxsik+kpOGL5Elh0t/3zn3gOe3xF188e4A/Av7R1WZy6CcopERzkYWFNX/bztn7sm/RMeNLG52w8o8XCS26hwy+/FUqQi0eNNpUFDP3B9HYAt/82JUJt/wyYCiXlKUGQ1e9GnPXf336P9xU/GJAvGRnDR8icx6ase1uOwQwO3Dlto258Zz/8iCh2CusCk+EqPgiy+RMViETx+gD9rgZp23XYy9P+BIbCSfqSHBReFHfAiDd4d4wzopv9LDi/b/bq07XATjYj/ZW5Xn33wDILGt21/RiEsBs05b/9tcCPar/Hf/NqdzLENcivnH6lk8l/H4x7jYnLO45x/nio+/NNfbMQQ8jyUffxwTn3965EozZ3z+jTGxc67Fff7tPf/ivjLcuRb3qllisdXh/jO0p9FWZjR4tuUR9/anONhgmbhF1JyNLOZYYhR8scmMBi/6smePf4zGqvz8F1rQ6Gvv/6HkP55h/frv13/JBXvPY3G//+l9/xPiY/+25M8f/vxh86EVz8/sPv/6/Ovz75p7/anvZeNtrTkX97lyj5sYBV+siCxY63nKxY1yA42McDay6CMxCn5//s0OAVWd24yrSnp0aejESii7iaQAqUAtNpCGimWsJP9LZpuX92t11j/6p50nQ0WXx/+8zg1pkQEeAALkP7Dnm76Bzqg9z+zcbptcZNby+I991Ih3zRDf+IV46wWU67vWmzqfuxe/S4eBVDchtf6K9Oz/RRcfGBYE5Bs6XKTHdDb4l593FsEFGw4WjVkVQVb4f6bz1BXv72wZdnqwccYfY6udH4qysGyddfM/v/Prz2zVGcXxyn0JHwzlJcp67+7819xyRwV4KKB1FwTMMC/o9YIlNvmffUGvRZtIz/g3/Pfo/7GyI4HatyX77//cPvQ7oCx4mGV2COgWf6lHi/8lP4njWGLVtW+270wzOwTEBCvblak2/491rvznl2i/l/3Pu0JcnHYWCTFrDVw2L1hDxTLa/KN4S/utsWH0b2Nbtj/GHS8Ru8kyH/0OmMpX81DQT/lf2862TNme/W/HLPwCGhumDu6f4+LxzzEwc4vnX8uY8fHX4/rj808eM5h3AVtyCWPN5x+ff5ADyAkDw7MV0wGuIfOP3ik2kaHd/+OWMkA1Fm5Ou99GPnv3n7G67l97qol4/3dP3CLb7SMT8iorjMznL9Sz2e3K8f4fwf3v9z+4z8N9HyD4JfTnb44H7n2qe5ucSyZmlU59b5TLIO6AxgbupXCP5f5zHyAmBtYxFjrH2cSV45j5iDug0ePysBn0Pf4ef+SAya2cSzlf6r+RIo8C9Pzz8adzC+YdQJNDqpPmK+SewNUk/8J9tLllxn31mnD/PyCN5I6UvuR/sVd5MglH5DCqSBJYRpDlsqKB8rYgTADCUobZBsqrriLQNoyARlrOcqD88vpffMM0esUOM+j3ob2T6ZDLrqSzd1+fPSyf/84tx9OUbU+m62SXMJmG2F44RzTiY99En7vjO3T8S8YW7qR9BSNUJdZHznKsqPZ3Fp9PH9rwYJo+P1lmwzJFwM+YN59Fd1z4XnrpKOHE3Fke/4suOZg2fMP59CQbCWERq4x0+D/+BTzNm7EPjRMHoQaplcH1svzfTue+bQod8p3HQul4QmMYvuRjdOldJ9Heay1//nce+RZ9eMf30vQ5i2M/sjOpaYzZC2ibz/+Arj/272ltU5OI5jakluVWRhER98e0DQ/i/oglsl2i8Ryfv6T4oLyNE0wANtwnb1beq/95AQLNn74PjQ0FYik5y9G3/8UX0FRu35ncvhXb/4/SdZ/cmXb+t9vpmVjFWMuQzDGKo175Gbripk/SFF7NgfprLBRBYcMIqJwW0V2nTqFJx/wSStrvAzSBtjrtWrr1qK1zn6oWkGjTWM66lhnUDSOgkZazHKj/cvc/bBl3wUGuWXLh/iXqHv+YHZ5/MQ4+/vLEAQwQEcowSqxccUWgbRgBjbSc5fD8i3Hw/Mt5AgwQEcowSqxccUWgbRgBjbSc5fD8i3Hw/Mt5AgwQEcowSqxccUWgnRkD/HMmOeQsXDn0kd7cp6EEYNS05yixcsUVgb5hBDTScpbD8z/GwfM/5wkwQEQowyixcsUVgbZhBDTScpbD8y/GwfMv5wkwQEQowyixcsUVgbZhBDTScpaj3/wbGCU/JUlzORvhX45FW9F8NB7OhhHQSMtZjn79S0ljOeOWGTwYRkAjLWc53H+Mg4+/nCfAABGhDKPEyhVXBNqGEdBIy1kOz78YB8+/nCfAABGhDKPEyhVXBNqGEdBIy1kOz78YB8+/nCfAABGhDKPEyhVXBNqGEdBIy1kOz78YB8+/nCfAABGhDKMkLAhQJUWSmqwVSH9wUJEi2VTAan4rDWaCJbD9F40/q/7n0w0ffxXt8Lm7Y102OYYu+v2XaL/xPNzyiMtBQNPAaaUTc+k19B877UEfu35hCG9ckiFGRY5jQ9p++lV0w9Qtgzs1pwj0Eqz5rTSYCZagGf+F59GREw+mGekFdOlxPdrmlKvptx/ZOoYDpqHUSoNZOgaX7jyBdt3iRLoKNgzkX6TTfHnhrcpGKGjNN/RSWYDxirQAoyo2MDCannP4j+hPbDts+G77tq/869DC+86nLx39MTr5ovtpfurTgY33oHd85mQ65X2vpo3Cwit2lOqoVVUkVbL2v+h8OpJfmM94omoEk+MOv5Tmz9ybePlIPBq2mA2/lWNVVSTZ6NH/5QIN1q/LttJgJlgCooXcvoncvpZ8W57+l9Z05n6bPrTTu3mhxpLUuAhkeuusuwdNu+hb9JVdX4DpLgrr+AsXTYga+dxZTPed+VrabOoveNEBxjLgBNr6lF/QLR/ZivXBE8eRVJOKJLND8p9Mp6KwDTLScFA6BrdZhiVr7PzPkfP4e/97/ocppOscgQlGFRKjlQYzwRLofAiTPv44QJ5/nn8cAYycjOgoiYgqJH4rDWaCJTBOYIMVPP9CMBC5kRZ/LAjgjkp3lrx8Wu5btMLoS4ZDvf/3+x/Pfx//I3r8p9HdZbyrNMkxKSRYghYbrOD9v9L6P8/lsd94K1qPv+ffSsu/5j2Dj3+f/+TvlebSkK4ZgWlPNb+VBjPBEhgnybDff/r87/N/GAwYOY05GmNQFTB2GMahGxlBDqUES+DjD+HRmDJjDcu/vEOAmXwRD4GIEaCVAc+yjEEGGCQNsWGMNP8LZ9Fx2+xHJ9/FLxAHxtD6H55FD5y2Jz0XDTIwtyJjRhzQIFHxX+nWk6fQK477rfnFciyB14VCjdrrTLr1xx+kLfO7w6hUndWs9lalwGTpH/Jc0v7xHVLiF9BTNzqIZsoL6KQqf1OK65ZfQe+/4kr62q7PgygrqYGMDMr/nBPptZNOpCtzsYhx+8d+kBcEzMQOAaVCbkXGsgbH+gtT6OXH/pb48arlmEg7ff0XdM1hL9XBb5VgEdDKgGdZxiRKix67h+586GmiMc+nv520Ma0rBewkbSLXGn9Wh8UAdYeAmCXyJ0DZPUGO+IJ+b95BoXAQZHIK5WGs5Eaqbfz16H/ewj8s0JAFCNlsxtRFQgbln3cImMb5hh0Q1MZy9X+0Iv7p0dk089hP0hk/vIFu+TOP69Eb02ZvfR/90/FH0xGv3IDn/mbs0CJArZNBIFs060Da6I0X8CIQ2zOsODCBXnZK3CGg7B6UZJ22+AtbihvIaOOATtZuqPTX/2wGtgGblrOOxWq9UL5hxDC8/St4/il7wOPP4TXpFqNjGJ5/nn/LOf/7/GfGUzn9+PWH4+HzjwTBJobJF59/+5p/W+9ZJZbVESJtwh3FhuHx7yv+EsccxYxV4ff5jwPi858EwWaGyRcff2v8+JMdAvCsL1kiC7uQIYA2e4BnWcYgAwyShtgwPP/W+PzDyw/kjEBkCKCVAc+yjEEGGCQNsWF4/nn++fM3hotCjBBAFRgkyzJmxAENkobYMHz8+fjz8VcPmzXu+pcXBNhQmHkizyZWAXitmG8goNEKuViHnw7jbxpaNGqzNa1FmoImR5Uzwkq9/Xfo6cvfQ1vteTbdH0q9il9+X84vv8Mr3WxH0yWzBuv/mduOo11e8QX6xTNSgg99EkiIgLX2oU/ffCGdMGl8lAdFe2p6a3KsfsJZqXf7WU/8yy/S+QWt/GI71CpVLVgZ8//oS/f8H330b8YkoxEsl/+7eIeASZ/hHQLYivXFpmVL/Mf1kwFw2fTW4HRuoq+8dhc66qoFKBQh24+fI9iOjrzuZ3TGDutkeW2kplWzKWhyVDkjrDSo+KMEjPKCgCM3wA4BKUCpHWPTC3rpDZH0PAbrv0f/jzviUv6Ew+sbCxBQ1b78B3+yIwVbSc2Dnb77HwYsHGz7UaZro0rB4lkH0wZvPI90AwdtA+8QwJ8MuIU/GRCOYfIvtssaRXeNs/vvb/y1BbIabR7/FTj/IN5dg9oUNDkwYiAr9TX/GhMRbXprchqFwiB1/yP5/o/7zF5Eu3ZqU9DkeP83IsBB8vz3/B+5z3+rzvgPL5HSZ9WwDDV/MqAx8iLDx5/PPyP67y+rzvgrbxT8+cvvf+qMaJmDu8y/cXFX+qMBg458UlSOrkFtCpqcaKI4s5Lff/n9l99/2Yc8M0LqQVTTqtoUNDmqnBFW8vHn48/Hn4+/PCkYrJ5EalpVm4ImR5Uzwko+//j80zb/lAsCQqKYG9ouq4Y0s0z2RdQwRAlkgHISFlcj8SEOgijkRB0J/ufSZUdvR3ud/odQX9ryk3T5LSfSbqO1phExDYioYaT26IvN0GjT/s619IUpu9Ox1y0MtqRz8GtveBmg59Gkk6+k2z62LfHXxZqHcTdk//LAwRaLKZkZRfzDlvFvjy9o4V0KsN7AhKn0fw9PpwPHRcEK8X/nCbQLfzLg6uQruornxhb1ohOdBu2u/h/hOm4yjS6Q9QCp7ooIPf4gOuO+b/HCB+5cNlK0f6Tlv7wwly3152kLQtuFigsCqh0CEJ8A5SRNHML469H/4QX9dN6xQWIY7Eot4DDylBysf/5kwFRu38z0yYDYXfHcd//H4ly5Pto/xP5fzDsETOQdAubBJ4chorwg4NRr6Jajtx5a/Ifof7njzyEa0fmf0kqBSbeIGoYogQxQTkPMf48/J7BkcJcD8WVxRA1DioAMUE4e/yHNv55/nn8+/sK80XrC/BLmFbnWGoYUABmgnHz+8flnCPe/q8D8OzBKrs/5hlOwpVJvOTz/c2hWwv2/zz9IuJh+nn8cBwxNz7+QFH796X79qXd7sZ8MSCOqBGa4RdQwRBNkgHLy+x/Pv+75J/nif/+JU3YcLBwQf/4KoWg9hXklSiJqGMIGGaCcfP7x+cfnn3AryPeFGB5hYMTB4fMvx0VumcOxCjx/o7KxL6seBRmgnEb+/BcXBKDiocrxVLIMZVCj3h8KW4DGSskylEGNen8obAHCytMX0ke2PIBOe0A2mV+bXvjJ2fTAZ3aitURe66LMkOFCum/67jRp2rW0WLJKZgmxXR0Dr/kCXX/tP9OrcWOywvyzI9gCNL4DC78QN58M0DquO5XOkwUB+tF6U3iwKPwChh0CTuQdAqqDwzPu8Ev4F+n8Ahq6lUo38pnL3kV/s+c59DAryMUYQVaMFzaEdqSFDbBTujGUQaHbN4QtQGOoZCXK7hCgDYiF5IX5fI7PkLoDTgBr/z36f9xU7g9ZEGDKDBmFX0D4SwsC1N5y9L/aaEPgF9DolCxDGZQWzaV773yYFoxeQI/dfQ89dsOX6e0nXEt/VTvopAk0+dRr6WZeEFAcsAVohCXLUAY16v2hsAVorJQsQxnUqPeHwhagsVKyDGVQo94fCluAxkrJMpRBjXp/KGwBGisly1AGNer9obAFaKyULEMZ1Kj3h8IWoLFSsgxlUKPeHwpbgMZKyTKUQY16fyhsARorJctQBjXq/aGwBWislCxDGdSo94fCFqCxUrIMZVCj3h8KW4DGSskylEGNen8obAEaKyXLUAY16v2hsAVorJQsQxnUqPeHwhagsVKyDGVQo94fCluAxkrJMpRBjXp/KGwBGisly1AGNer9obAFaKyULEMZ1Kj3h8IWoLFSsgxlUKPeHwpbgMZKyTKUQY16fyhsARorJctQBhV1+xIJd5vL3CEAfmALEHyGJctQBjXq/aGwBWislCxDGdSo94fCFqCxUrIMZVCj3h8KW4DGSskylEGNen8obAEaKyXLUAY16v2hsAVorJQsQxnUqPeHwhagsVKyDGVQo94fCluAxkrJMpRBjXp/KGwBGisly1AGNer9obAFaKyULEMZ1Kj3h8IWoLFSsgxlUKPeHwpbCdq5XAzmeRyKwuR/MtGviAO2AI3NkmUogxr1/lDYAjRWSpahDGrU+0NhC9BYKVmGMqhR7w+FLUBjpWQZyqBGvT8UtgCNlZJlKIMa9f5Q2AI0VkqWoQxq1PtDYQvQWClZhjKoUe8PhS1AY6VkGcqgRr0/FLYAjZWSZSiDGvX+UNgCNFZKlqEMatT7Q2EL0FgpWYYyqFHvD4UtQGOlZBnKoEa9PxS2AI2VkmUogxr1/lDYAjRWSpahDGrU+0NhC9BYKVmGMqhR7w+FLUBjpWQZyqBGvT8UtgCNlZJlKIMa9f5Q2AI0VkqWoQxq1PtDYQvQWClZhjKoUe8PhS1AY6VkGcqgRr0/FLYA2Uq5Q4CaNRrgtbCCKPCNUFFF9B42c5Z1X2s1UwVaWMPjnz8XMPvd9LK9zqH70HaG8Y8t9gwhr3jiFkr17BE1LafCKwWQNaTRu9Fxv7mYTtp67fYHgRAXExxFFek//uYFbayXOe9yGt185VE0eUX65wUBr510Il3JoUIcELXxvCDg8ZktL6B7+l9Ec06dQpsf80uYyRAO0I4sYSzHTtktrCDr6V+cZGvWhMWDUnFqkQpr8QW8k8GB4Rf0QsYj5t9YXhBQLpjINoABSjmLJ0MGJGmP/i/9GWuKKqK+MqeLf/Y3jT9RMR2fqDA16q//lzf+S+jJh26nO27/Df32V7+jW26+mx56aA7d8fCf6Q+//gM99IxUcDDjX3YIiAsCYo26tF/bayOVmC2sIAl8I1RUkcHH3/13D3YOp0bJ488RCHExwVFUEc8/DhMuNz7+4/DJ2RHp8twibWGFMoFvhIoq4vnHgfL8K6+5OTvKzItUi7SF5fnHEQhxMcFRVBEffxym4Rp/AwPy3eny+TO+SPL4x6jncZ8jknlxvNdnq5lkLawgCXwjVFQRz38O1HDlv88/Etyca5psGVHMaCkvZXcFrGYStbCCJPCNUFFF1Ffm+PizsUDwZUGAHSe604sotBVQvhEqqogWzZzu5mJdrGbkqJFEKgiqRl9RRbRo5rh/GwuNpSIt0hZWUA98I1RUEY8/B8qOK4lbjk6IYnVqkbawQqHAN0JFFVFfmeP+bSyq4DPZIm1hefwRKhMcRRXRaGZOa4RNN1jNxG5hefw9/jG5THIoqojnH6fJqnL94QUBfNvJ+wT1+gE6uhZQJgLggMJrP6yGxaHNf8wYUf4focuPfhXtyZ8LkE6UrpRad/sFv4hyd0cK58arQmQFFAxUkXRE2vIx+l+XNj/5Z/T7j70y1CfyVlL8wwvag8ML2kb704t0+c0z6mSaY1Db5xaHiul/XhCwyxafoauL9sf4j5s6ix7nX6SPT8VgCRDWSvg4XfUv29KuX7w/sqWiUsAeu5xKv7viaNomNaLNHniAUhw4oDVZ4lbD4tAy7Td2IRWIUp30wnxG/Qt67oFxR8yKCwJswYCjtLVklXr479H/siAAOxKssP5nf1MnHkwz50mdkVfL0/9iZWjtX/rXu+iGSy6kS39+Of3ip1fRT257gpaEyrCdWC2hqqMtsaT++FNtXBBwy9Ev43J1tHrEP3lBCwCFDRwwqbYAq2FxqLr/kXX9acuQyLO9BxwQvdmEVsPi0PT+9/73+z+//43zQfsM4fMPrvC4eiNOgJhNm9BqWByaPv/6/Nv//Bt/VYrsTGM4PT8likGdtcg9gZ5/nn/951/bjGazKz+pxFzLuQgtzz/PP88/uf8Mc7n5+x92CMAYA7QjyfIwokpoNSwOLR9/Pv58/PnzX5wP2mcIf/7DHXZ9J90WL8yszYi2afv86/Ovz78+/zZnC8wjmDUAhQ8cELpNaDUsDs1y/jE7BCTlAGxByxcjVgajg4dampHie0WwGxRUK/tTliKDd2o0tTQjrf4fP5veN+nd9I1HuBBmf0FFPzDiWVD83QUXi+jGUEADBJEvrqIfBkKwHUsXZynCh3w24Iar/oW258/cSy2iBcGHfmhp8cn2kws2lCQBJFy2qOdfbMsL6Eb7dz2NX6TzDgFDrEKyHNw1/N91Iu06yXwyIFeOxn8QOwSohUF4nkuXTJ1MbzhzbmxsaGNss1iRY9Tr/5Nu//EHaPO29geN5E/dKhKkQz1paUYa7Q9JxRbtin9bL7NDQJ1/Y4+4lBcE7L3MLfyH5L9H/8snA2SBxlA/GdDT/yLeAWFDzjf5RIUcy93/0Yw9t/rvPEZ3zf4mnfvfZ9PZF/2K5jwpWnwY/zH/n0MTttyett9uO3rVKzalzTb7O/rbF72UNl9vPE14yWY08cq300ZvvIDmpzwL5YNDXhBwyi9IFgS0+g/OkiQA1WKJ5YuilYWCQzppaUaGnH8hHmphSH6hrKXdv8ef8ykPsZQZAWiWcNpYvmSRlSGrBg+1NCOe/x5/zz+MHTvOdJTk8aYsRVBwSFBLM+Ljz8efjz8MnzQyAtBRsszxZ39VGi3xItSOfOqu/VDLjPj48/Hn4w/jJI2MAHSUsNDyRdfKUHbwUEsz4uPPx58df7Lbiz2KnV5s4pinJqs/GNya8fzz/LP5F6IREkSzhFMq4cpSZDDp1tDR0ox4/nn+ef5hiKSREYCOEh9/Pv9wDvAo0ZRQBIkzJKilGfH51+ffev41CwLKvNLEAbtKIHkZXq7qMCWABsgrEDihs2MxCAUYb8KGBjNsAg+P/6X0xPcPoM32v4jmSh1H70JHXnImHbkxt4DJpaOkHVIR/p8rE9sf2zdqYGnghZawnFiXljLCBRvtZ94Alxe1cQsuoGN2PYF++HSMQYwTflkceUTb07Rf/Iy+8pp1NI7D0374Sz3Ev9jWBQEs6tjVCzufTjdf9eGwIEDaEVuTejkykpGW9oeWlxkRPKdPBlwVrImRfMiW8X/hTwboDgEsXnb+8YKAI7emN8yU1R3mYNfxBS/Hv8uLdDRBSzFj+PNPvTUjJP6XXMBb6h9IM+aJnsRPahmP8WEHhX3jC3pUPsAhxB/GGIaiPfp/7OGX0vyZcQFCdAenKAw4BP9hRwJZgFLnP1F//c91aBt/iC4vBLjz4q/Qlz93On3tmsdIvgAQs9L4H/0i2uwfDqCD3rIf7bfvTvSajZ8bI8/NrfNv0ayDeUHA+bwgQAyxJawYIuwQIPtpyGFiFRmNc0ODGc96/sm4STVdKfOPjYq33/vf88/Hn88/IQI+/zavv3p1wsUzwCHcf5jrDUwoy68/fv0ZgdefuENAebvJm/7FoeD5z3Hw8d/4+4M/f/C0jicZneELxOf/KkJ+/Rv26x8Wd0nkZdbCDgEhMT3+wx5/OwH4+PfxX1whfPz5+BuB9/8yZ8W5ysxYQAP0+1+//11V3r/mKzBSWDnM8Pcf+Zo8XH//0wUBjWnDetReyUhDP4sYQ3cCJiFIQNWTEtWwfVb8/5F+cOh2tN//yC/KeT3A606jX11+FL28uDOIbWnUt+/2303fOmA7eud3zT7w4o/9BxBOa9PGn7iM7v/sjrSWhrKKV9/+Y+Ma7ZH4yy/SJ/IL2vACunBAxFvt33Ll0YRXnKUUHQyolU6NYjq4zfLgHzsEhDbb9suL+0uKLfEb9S0qALsP8w4B2/CCgLn6+C+TisQWx9jDvk+P/NebaZ0RkX+xL0Ld2vJ/0Xm8QOPgsGOD6Nh3zmV80H7A1FqQgCEQ0Wcjnsvo/7H8iYInZuxLY5PpEsAB4CD9yw4BsiOF7BDARUNXpf4q2yfi5cn/BfTQlV+mzxz/RV4I8JewEKCoP/sceOHr6G3TptKR7/9/tNsLmq1s879o1kF5QUCsfTI7gSafei3dfBSPltSemJA5Pg17bf1vKtnQN7KY4IWjKIU7wGX1P1Y8FLZhannizzakeu4fgWjms/c/50hIEkmUxuH57+OvfszJSYIJDjBJQAL6/MOBiWOsMZ58/vH5x+ffPKVUWGO8FHJMMIBJCBJwBcw/WBBg3ccdAvz+z95fhvgg7oArIP427hmHA8AkAQno/jkwfv2R7GjMJ379XeOuv6OwQ0CauosFAWkKAWjkCwQBYoIBTEKQgD7/cGB8/pHsaOSTzz9r3PxTPE97/3v/+/NfunA2QWO+LFRwgQVMQpCAfv3lwPj1V7KjkU/P0vw7wL8mkL8sF4fmq1RUxGlisPyigOjxv8JMxajIUDzwWgSWtVL9z+PPBWyePhdAG9L2M6+m6z84iX/sj6St2miCYOucG5cVGnIWBV5nCc09d1966bsuo6cCJ5cJAWUl8d7Z6lN02c0n0u7hswFGJ6EN+xWjIkOpwGsRKIu3jJ+6wUF0Jr+gjS/SQ01ifXY5jRcEHKULArQMqlYxKrLdP+8Q0PhkABcUr2PTFvXYIQBuABv2AyN9MiDsECCMlmPn03ing/LTB9bWSs2/VL2u/vmFuewQMJPXjgQdDozMG3KM5QUTT8zYJ7+gt0ZYXpGhTOC1CJTVo//F33zjT8sEy02HDTlUrMDsSBDMxHRbjv5HZUz7F/6OLvzXw2jaaTfSg7IlQDrkZlgmZRo9iXb82In05X8+kHZ6/lpDmP8W0f0zX0ubTb2OnkG9tX/WpZedeg3denS5fCY03bY/1cWyRlT+cf2kaW2HrXOQV4yKzCotAsvy9q9B19+UWN7/eZx5/nv+rzH33z7+83URsViTnr/QZoa4z/D5r/f8h7lBQpduO+MvS+1FlGUVKeqR1yKwLI9/7/iHQCKWIATaIDbJoBlUKr26qMff448x3pIqIY/qnMnJpeI6HbNKi1HL8vxbefmHfkavSew9/isv/hp3Rvz+I0bD88/zD/OSvS5grAA2ZBWjIkOxwGsRWJbnn+ef51+8GtlxgXEH2JBVjIr08ccRCDFpCYxlrWnzj+4QEBPLhkI4lrZ41C7EiYUyUZvPdp8H6MhbzNbVR7UPS1t8OPwvpfkXvZU2e8tF9CjfDnbG/AOddMcFdNxL8ZX0YfQ/XxYivIe+MVd8yM2o2bI8MjiO29GR1/2czthhnaATTi1VWqHxxy/S0y+2Y1Xin506vCDg5iv4RTrunLVWsVJ6Hkr/3/VpXhDwGbq6pf3jDp/FOwSkLfHha5ntf4QuO2pb2uurD4ZUlVzUyMZm8E4H3A5e2DC5NaDWgcVTBVpYKzT+xQBjZ2FBgOwQEF5dIwoByi/o4wv6WCk9DyX+hT8226P/ZUHAvOn70LgV2f/J38z6kwHso7/+5yiY9nce+yGduP876MSrOKHR/4gi0wObHkyfOud0OmHHiYkboxgJi7eIaSHdfcrOtNlHb4JFhQMDE3hBwLV0i+wQIMeInP9CxfhkO9S22eKiy0cLC8wo4rOJfywk5Zg/4ub/tgbZBlo8taSF5e2PQdGz9385pEKacXQ8/9MgsqAeUJa2uI+/EIGWkPj8E4OiZ59/fP6xtzQycFaj+48B+TRdOvB0I3/E8PyXtOco+Pj38Z+HSBwpq9H4Lx7XQut05Hv+r2LjHy8+8jy+lHsUyRv7NU31KY+NWAXe/2nm9/xfxfIfzy6ayukupmuytwwJ2NBR4Nf/PIUgsH7945hgXkVQBNYJZWmLpzItLNiIIj57/nn+1anm48/H3widf8KCALsKIk5oMuGlLA4zm05vYSZEfmduyUnTZQaiKJNtaxBYwgMEN8PPnv976YJ/3IEO/F/+3jw3Z9ReZ9Jtl36QtpCqywfn4+2lUIhMunxEWRA0LiiRG9g92/8A/eiw7enN/y3fupc4oVx6NBC68xx64Sdmh88GjIGYYfijRy4QOEmcgVSxp/8u8ZcX0BseSNOflOKhEtGmoPzL+t/xi/RtQuO0wiwAHlXDebD+wycDTqCrYIJ9hhf4TI/jb9Y/PiN+s17FwVuv+C+kOadBhUOfAABAAElEQVTuTJsfY17ScmHpTm4xl2bklZ+lq2/8OE0Zba1KrRMdzEcfcpbDag5r/MWZ9Z9+QT8TCzS4IrEt8kmFS3lBwOt5hwDUTgqnI1ScT0Mdfz36f9zhl3B/7EPjV2T/Y4cAaZ8cy93/0YxUsfPYhXT8vv9IJ9+0oOx/CVdnFK29yyfo2+d9nPbfGKMrxdHGP5lDhINI27+I7j51R9rsmF/FBJFwi+lwfh5tfco1dMtH4rKTZEbByJj/bKukakNtv5SJERGsOIQtsqHmXyo2/PNvl/nP/acujf0aupFjYjNlpc5/0h98uP8Yh9wrZUSi1JxDx/HJx58JSkZ9/vX579l//rBjWHIz0WGQ55FuJOlqG2Uxmy0eOeEsbL/+rpbz32ie00P3cg9Lxggu81lxeP/HyPj1r0gLEH798+ufX/+e/evvQPhkAE/WuPQvZVzm7mH/+6Pnv+f/s5//8XoUblYk6TPp+R/iUUUmTg3pbIIVUXsOBfnk9z82Kor7/Y/P/z7/+/wfJ4RqlhVyDbr+xB0CqkaH9kt0kCMxUj3PRRgLolmsIR4J/h89gw7c5EN0wdPS6BfSbt+8ji5/14uble/CKdpUEM0CDXGHdyf4Ae9OsP9F9Ij+WceU4yoN8MvRzhbH0iW//Rzt0/xZdrgtkBKhyxoOjC1GG2JhmKTX/uct4/FN9+A/lRQfnV1O51/Wfzj9sr6y2XAwSP+8IGCXsEMADKRy7HA8LwiYxwsCml9zjzooUbc/fNf9H84n/lF94wjtmHAknfcw9/04UUivt6AbjDWKtTKKIgXRVG+IhdEW/9o/FgSETwawUMqEl+ZEY46QHRTkBT0fDQdlHRribv579P9YXoAg/WH3zxAvocoNB4P0zwsQpm50MH8SAQZSOTbab/8HC3/9Mf37vm+jT8jOAOaQuvKtEA1M+jD977VfpIM2GBNCp/kfGmMK9EA7vEPAnFOn0KRjfsla0TIA8Q4BW5/COwSkTwagdWq+W/xVoYfjJCpsFkSzbEPs/gc3/pqhVE4R04JQFUUaYo+/x38w879mUBMpcqoglqErYs8/zz/PPx4II/z+rzmUlVMM+YJQFUUaYh//q+z4l5dI8W4TvcrTubxIkqPL/SM0Vez9v8r2f+zo6pGv0cHQirAh9v73/vfrf5gwdSjIUNEJMo6bXudiTBVEs1RDnJzGBQFxNpdSjYVdTVPKKWwWhKoo0hAn/9JgRUV7Jbff/Xv8Pf94FDQGqA7drkhRpCCaRRpiYfj8L0Hw+Q+pIGnj879EYVBHMaYKolm8Ifbx5/PPCJl/B5byXWc57kN2piw2qZvYVipKke4ixFhgcYcbLL/3jgesyNaGmVvKhBI9ObhcFxeR3UUYC4eyvf0vobnnvoFecshPKawHGH8wnXHfufwyfFSyMNz+2c38c+h9m72bvvEot0Wa03pMpndedhWds/t6Kl0x7VdzjKRYCgtbxvMLaD14lSGvIuEFAXGrfdkEPV1Gi6KqL4g0aTD9f9cJtOsWJ9JVLe2XX6TPm7lPWBCALEqme/u/7/O096bH00/Ypoy5YDoZiPTr6dN3/pBO2BxLDUQDHoJ2pBPbSgflPykNqv2ia+Mfa8u8lH/8gn7qxIPpzHntnwxo38I/muzLf4/+D58M4AUIErUV1v+y4GHiQTRjHhutjr77nx6iy4+awp+NuDfsFBt61Pb/mNfRMb/4Pn15uwnJo+3hoM38FP8MtHZRW86LaM4pU2jzj8qCgHSIn2CCPxlw2jV061HYISCWEuHImP9QYYGoG3CBueFWCo0V1v9i0P1zDCRx5AjJw9Djj7Tw/MvZgQzx8Zeyok4OCZAczO/r+ufjL8bP5x+9LNUpFunErYUpep5/Pv6Ga/7Jv2xBsnGsW3YIGC7/nv9yPfbxb+9RcyYmjMPj+Wef9HCh8Oc/G5WYLYiNUILLsWY8/4S5XB79UrM7/EOheKwZ7Y9tXXP739svEfD+z0/4a9b85/nv+e/j3+c/n//kJhBzgcCVd//H73bl5wTpkdbmYqhQPHVhG43eaFFeCDnQ5nQDEHQKxagm5y7srLAMrCgvhByF/7vp3AO2o0O+Oz+wRx9wLt1/wTto46i5EvxL/B+kSw//e3rjf6bv3XNNhNuRbX7kkwqhzmNo/aNm0f2n7knPTXUbDFh2+7v0f3hBy9+s5xfQ0X+oSnTJCwJu4U8GpK+i96zGoP3feQK9lhcEXBmsle0fL9+sTy+gezqrhc/Mpk+9bF/67J1LklXJJ2kNEmFLOmT2dfTNPdbFIsnaQtAM7W9IBscYdPsLxWxb2fKL/Q35hXmxQIP1WEHiI1v44xf7uXRsqdZfjMlRMIbe/+PY3/xB9ofWX/z28r/wfJrGCwKmh/atiP7n3+1f92HaYecz6LfPiPPY7Nz/69EWn7mEfv3J14SdFWSBSI5LUA+nLuysEDDeIaBeEMD8mGm8Q8CpaYeAXu3v4qgLu/LfnSzKu/8YqMHkfwppEb/uYe4qKcp7/D3+EgHPvzRe4ugI52KgJDGDLuyssAysKC+EHB7/GIcU3RCjIlBJzKALOyssAyvKCyGHxz/GweMfkiHkSJEoKTwMurCzwjKworwQcqwm+TcwihvCbZLmoGn1goDVuf2hL5dx8vZX6S7xWk3yfxldH8Te/1V3e/9XAeny94+UXEX+DCbhKp2ivBBytIy/UfJjGxZFFa5TWhBQlA+Fh3Yqyvfwv3x//+heJ/dfdbeEqqX/Pf42LjmfivzJ7EFjRXnP/xg3z7+UPzE7wrlIlJxeXdhZYRlYUV4IOTz+MQ7p6S7EqAhUEjPows4Ky8CK8kLI4fGPcfD4h2QIOVIkSgoPgy7srLAMrCgvhBwjNP/iJwOkgkWthWEO+cVBeDHNatwQbYtR6YZms22roU2prGiYCR1u/3On8+cCptEFC8TfprTfhdfQRfu/INdjuP2LJ/bx9OXvoa32PJvuz55DrCU0emxyDF30+y/RfmsPrhdyWPuIPy8ImLYRXtBqDSJSfTKgkio5JP938w4Bm/MOAVo65prYkBfQ8gv4sUPOv/l04ye2px3+/a5szNgnXlrx0s9cQXM+sR3J39Zaj5XS/+x5Wf75hflUfmE+M70wj4M21nhctYU/2jGk+Nf+e/R/N3/wCzgk/0t4wcMGvODB7OwvVeq7/zu307kHTqFDvvOXaAXGULkXT6Pzbj6dDpzAO4HkikKa4aD6n3cIOHUn2lw+GVD7oXV5QcDVdPPRk9u7+LGf0Vmn/YzuG/V8mvyOD9CBk9bOvgUblP+yCKjcrD7GvxphK6vz/C/tzIFCqzP0+Hv/e/6HMbJa3v/5+Pf5z+f/Zd9/cox8/HcPU75hyFhOq+G5/8o7BOSbTrsgYLj955a2Y+4f+TI8/d8e9cz1+Hv8ZWaQC7wshI94zg/FcqIoSxF//uEk4shxjIbz+hcWd2nQ2ZfEXQ6P/0qJf9fB4fH3+K+E8e/5F6e7xtnHn48/H3/Dfv/h809j5omMNWj+aflkQApKCILg7Y8QvZ4fwsuVZKa9eCrd6wZ7pflfSPfP2J0mHXktLZambvB+OvuuM+mQCUyEpq/E9i+4kI7Z4gA67YGlRQjRC/HxYDK9a/aV9D97rN8eWlGOioJ16b5Bxj98Q553COAX0BIFmA14+mQANkEPvnCCotCt4evif05cEHA1F7MmxEz9C/hkQUTNwxZm/0uu/xC9/DVn0O+haRvDvFH/cBbd/cP30ksgFzgs+beE/vrQHLr3iefRiye9iGST+q4PmG3+ZccGXqAhCwJsE6W6YcEEdgiwwqHEXwzhEP89+n9M2iGgbUeConJD8Z92QGhrXz/937nlX2mnV55E1z2TdhtA20L/j6Hn824b9522J60DvoVt8TdyCXHZtLYdAoIj1lyXJp96DS8IwH4aqTSD0P93nUi7TjqBrhrYlA780Y103hvWH6b8QwMq/2BbOOT2m8JiHkcZpMR1/yF70P+IlYUe/zTAWhMoTDHtEg6i51/OpNYg+fjz8ceJ4fPP0O6/8qjy+Ydj0Tq1SIx8/s2Z0hqkFTf/5gUB2WXY9A/kMPuHmwJ6/+dwePxzLBRbcfmvJi3i+Zej4fmXY6HYyMy/ereXuENAawf6/Qf3ZXtkWODjXzO9PUgjM/9zpaUPuY6hg9t7ObWgKKKE97+Gwvs/hyJjnv/+9w+eVzgNhvT+JSeQX385Fu0zMwt8/s2Z0hqkkTv/6CcDQgtSPXNrYt/mNuWGhGxo0Y9lowBiQLVbMAxhUOiWrESBCQhlhVEAMWAlTuRv6D9fvzMd/tO/Mj2annPod+n+b+xHGyRpWTZRYAKqYSBRADEgpOVsYqSduXTZR7ajPU//A6vyS0zeQ0rui+wxwF9tX/+oi+l+fpH5XFPU6qDXIAZUnYJhCIMGXX5BO5W3qI+/SI+l9dWqLAi44iianJNDzfft/84TaBf+ZIAsCKjbL9+snz9jb94Snx2inoDGc0SjAOLO0hvpK7u9lo6+UraASFypN246xx9MZ9x3Lm/HP7oxy8GGtQsTCqPQnCv/LAnu7vsy7b/tP9MP5r2YdjvnSrr8nZuwxHgwKIwVrEXn8Y4Nb+ct9YVbHsWCgGQTZQG1RMEwhEGDbo/+x44N41Zk/1c7INj8H3r/L6Q7T92Ftj7mJoofi5AWhV6IcGBbet/Pf05f3/V5ic+gbn+DlRSgB8h6RLwg4NQpYYeAsJhRZHxEj+aTAcIsyjERFgTIzhib0tsuvpHOlwUB6ShUURBMQCgrjAKIAStx00NDsaqq++eYcY8iToAaWCBRADEgpFo+MIzUoNAtWYkCExDKCqMAYsBKnEgjNSh0S1aiwASEssIogBiwEifSSA0K3ZKVKDABoawwCiAGrMSJNFKDQrdkJQpMQCgrjAKIAStxIo3UoNAtWYkCExDKCqMAYsBKnEgjNSh0S1aiwASEssIogBiwEifSSA0K3ZKVKDABoawwCiAGrMSJNFKDQrdkJQpMQCgrjAKIAStxIo3UoNAtWYkCExDKCqMAYsBKnEgjNSh0S1aiwASEssIogBiwEifSSA0K3ZKVKDABoawwCiAGrMSJNFKD/n/2vgXstqOosv8/hCQQEgQS0NEAhqAkETQ4QngJgrwfKgbkNSL4SIICoiIzo8MM6KCD8iZBBvEFjIAK8gowijN5gaCASBAhAQJIGBFCEkAuSe6d6q5eq6q69/7vzZ+beJPU/pKuVatWd51Tu7v3/s859xxoI9U9kLAQ02oAYdgh3F0XdRDaSHUPJCzEtBpAGHYId9dFHYQ2Ut0DCQsxrQYQhh3C3XVRB6GNVPdAwkJMqwGEYYdwd13UQWgj1T2QsBDTagBh2CHcXRd1ENpIdQ+k2PFfldZ+eCPJydp9KMbM+w+pBP9uQZVq4Tyv1YpU90DCqtS1GkAYloJAOMdBaCPVPZCwENNqAGHYIdxdF3UQ2kh1DyQsxLQaQBh2CHfXRR2ENlLdAwkLMa0GEIYdwt11UQehjVT3QMJCTKsBhGGHcHdd1EFoI9U9kLAQ02oAYdgh3F0XdRDaSHUPJCzEtBpAGHYId9dFHYQ2Ut0DCQsxrQYQhh3C3XVRB6GNVPdAwkJMqwGEYYdwdy0aP9ylPxlg0SrvHkhYDgygAYRhEcUw6ruog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qED7hgDwsOw9A5WsC+fIyJhPBAA7pyWjknXhHBkZ83d+6jfLA277jPLOS2X4je8sJ7zl9PK6Bx7GXEtAe9sYo2aOjIz5RA3Izwb8hfxswA/qzwbom4l8C97S3Kx+i8HLymMPlTewFw6OydjImE8EAFv7yr9IP+mwR5bfkTegKx2Ou72gfPiMp5SlbwjwQ2ifkTGfqILhJwP8869vCF/U/wW89mHP8LCqM0d2lAte9dByzOPeWeqXx8ejZrlFuecf/nX5q8d921LnKBfviuevPb4ub1Dfoxzz839TLq35/ui95a8e+232WPGgYaesQvRvCKjf2NAOeegb8hG3enb8BwLmIUbGfCIA2Jpgi/N/wImnyfm4v3xAYz78EBodGfOJKhh+MuDKnf/zy5885nvKCa+Zz3h7TAfph0BOOmw/fW0QDwR2flpkVDIKLyxn/tL3lLv/1vmqqw++HlVWbiQ/GfCecs74DQE9vHGufDPGUfKBgPoNAW+Rbwh4oH0goPYej+X8phofGWbskoJaAFgTT0gl68I5MjLmEwHATlmNUMm6cI6MjPlEALCWbkIqWRfOkZExnwgAdspqhErWhXNkZMwnAoC1dBNSybpwjoyM+UQAsFNWI1SyLpwjI2M+EQCspZuQStaFc2RkzCcCgJ2yGqGSdeEcGRnziQBgLd2EVLIunCMjYz4RAOyU1QiVrAvnyMiYTwQAa+kmpJJ14RwZGfOJAGCnrEaoZF04R0bGfCIAWEs3IZWsC+fIyJhPBAA7ZTVCJevCOTIy5hMBwFq6CalkXThHRsZ8IgDYKasRKlkXzpGRMZ8IANbSTUgl68I5MjLmEwHATlmNUMm6cI6MjPlEALCWbkIqWRfOkZExnwgAdspqhEq03dzYbPf/Fi1lp3zQGbefyo+Dmk8EAOsHHLBK1oVzZGTMJwKAHXJ6VyXrwjkyMuYTAcD6hANWybpwjoyM+UQAsENO76pkXThHRsZ8IgBYn3DAKlkXzpGRMZ8IAHbI6V2VrAvnyMiYTwQA6xMOWCXrwjkyMuYTAcAOOb2rknXhHBkZ84kAYH3CAatkXThHRsZ8IgDYIad3VbIunCMjYz4RAKxPOGCVrAvnyMiYTyRgYz/ZtSvRD/5kAAjwYuurPrVdOubIyJhPBAC7NHDnVLIunCMjYz4RAGzmX62Almi9UHNkZMwnAoBdzY5Xk9aFc2RkzCcCgM38qxXQEq0Xao6MjPlEALCr2fP8a4nWCzVHRsZ8IgDYrP9qBbRE64WaIyNjPhEA7Gr2nP9aovVCzZGRMZ8IADbrv1oBLdF6oebIyJhP1IF8Q8D4b9AhqbYe9aZTML5bA2Fl3S0pArC173ww2gA9JwRXbT2uyvxfL+ef+gPlqCfJzwXUdEf8fHnTR3+rPOQg+U1x3plflfnxXOvz7MeOt5ZnHPtD5TfPtX/XjBCtvHH4sDecXd7wsJtftfVvb0DrTwYwdwVSko27vrB86Iwnl2MZwHOBZSAARhugpxp5Y/Qe8sboGaGHOgf8jHwg4GX3Kwe4Lg6KCB7sMMiOd5b/8u8fUp7999/Qn4OrMhzyfDbv8cLywXc9uXzXJvpDsJfO/853l+cef6/y9PfuKBvXf3D57x/90/KMW+8vj6CO748t8vev1D/1K9JLZPoI68mQDwT8DN6gR38/pmFGG6BnAl/HLc7/gXI+LpQPaBzInhgLloEAGG2Anmok35PkJxFOwQceXM8rfv7fX150t7uUp5y1w42isP0L/oNPKq/7l5eWE65/BerfpwJOWXz055ZXP/yO5bF/tvDg5cchjn7Bu9sHAtjHP//+Uxn1GwIe8bb3ldc+4CbyQKugHj3ptXL/ZTX0qbYWXD5/LUqe/7YWcv5zK1jef/y6Gfc0W15Q6TZPzwR+/29szr+cfzJPcv3l+utbQe4/ul3G3RMerNtSHWS0AXoLihqrx9b7b/1AgPtjoPWY/qRvrDbMuJfy25UGI8O6pA4ymvn1vGExsUaoULX12Pr8Z/21Svr3Uq/VVFNoTJX3P3VqYa5ZfaxCOf+0Klff+qvfEIAZXHPjm17aOcn7L26FWN5x9sKD9XPaMKMN0DNB/v0jtfCz8Oqb/3oScE6qrUfmz/UvcyH3Py6F3P90Z8BOEb3IasxaRhugZ4Lc/6UWuf+3PbfNiuvW9WdDfm9Q/jnB0sJwa0TgsgIs7NCnDl3ffZPe9d8sVNQOkWN/14GX+0Ne7bICLKzvIX12l3/X35QX3eMe5aln/ator1cOPvEt5QJ5k3PpN8VXMkhCLB4+Oz6I3eavyjawH/3i8t5fuWO506+f68bmkB3sV274E2+QnzZ4cLnJXs/vcrU3hB9R+C/SXajc7UXyDQE/K98QsBeff/2X0vKTAWfWycEzXmtTin5lvHwgoHloUDdY8Gpj/XeVS057dDn2ga8rn8HYLU2do5Jt8/hy8lmnlZfe6dA4SPdWMkjUP9bY1fLvLF971+PL7e5dv/lho1zvwa8sH3vT48ut2XV5dD9aU4Tzgc6q8t8QgH6Wf5vrL+TDqMj3DvmGgB/Un3BAPaNk9+uv6tsT68+/5jtc5ttFeG6w2zn/7y8vvOvx5alnywdAahoO1cEtn1Heft5zyv3qZ3/2xv534SvLY4/4qfKar9Tn4vPVGXKj8p0vfE/5yJOPbrH6nMP+94lnlrvf5tnykwG3LiecJt8QcP/5GwJ6hbQ/W7CwDDRwpc+/G24lgyhQ2Grjkfn38etfPV3txC6fXX82lxVgYX0PGXp319/Mn/VvU2d5/vjZtKwAC+t75PzL9Zf77z7991fu/1d6/9+oHwjAIX/IyCf82zcEtNLm9Xfffv2hnSRp9sbfH+0+HBNBbe7/uf/n/q9/n8pMsBUit4vh7+99ZP21c9Uebn/Msn/jWLnDlbBq1UKtNtd/rv9c/9ec9R9Xb/Ry/S/ucFKk3P/6HxFxwoiX+3/u/7n/5/5f94c9vf9t3xAQLjZ0CKaNZiSgrPev7c3VbqmDgEQEIUyHIIoXPCivWP5dZccZP11uf49XlI+1Mfu/4q1v2tU5pO+ULGSbqe3lt3HQvzHiXP6+J5Vj7nRK+ccuwSWP177Ky88GvOrc3ymPObR+ZWS/LArYq/X/xp+Uk+VfbL9M/tFzzRHy3+2F5Rz5hoD6Fudey9+/Ov2sPmZNWY/6/P1PBjTSNXucf9d55U1PuGf5kd//bNkp/dtzcuNsfr98S8BfyrcEtF9iwKhOsAKhXJ1/l3+4/P4P3aM84S0XSk75WYq3yc9SPMB+lgL92/B0CCwrviGg/yN0nRfSyh+09V/Qf/kU+Rf74uJxsOPCUIwJCGE6ArY4//UDCBfLh2eu7/ojLyxzcEwyATBcPxBwM5lvl8Rzs73zb98QUF8K0C3Rxt045KTy2i+cIt8QsMXzbzMvPNRFZ1e5rHzx9Q8rRz3itPLlaVbV+Xtoud0LznY/GRCHufyDTyt3/J7nl7+Tbwg44a34yQBWJYoXPChRd1hKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoHrz2gYD6hlaVt/tV+UDAzvpCmBPuZqgQpkPgBlqGUOJ5w1INAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQgQ1hfvsYvLll4H2oMD/ZEXll0hIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARgQ9PPxmgQS/BG2adm7LFwWfPxmpIGn46dxb3NyetT5Wo17m9lX/HWeW37vOD5ZfO/Nf+KA4q3/yr7yrnP+vOZf+eEQ/vKsmPwQfbcl3+F+WZt3tgedbH5WcD2os99dWd+hkPrUX7k2Hj1uVhbzy7vPGhNx9GGN1et94Xw/nXi3yP8Fy/9uryxFs8trzykoX8d39BOed0/UCA7z/jPc+/6x/+U7nT0c8p72uD9EfYH/D1T3xbuUR+s/76V/L8ly+8pjzp+B8vp553matnf9QbR5S7vOJ/lzOecFTZbFHlQ02ucP4d5fOvO6Hc8ZFvLp8r+5UD7/Pi8t53nCQ/TTBXqjIhV5eQq2/Qyxvmp9bzUetSj24OOEneoJcPBNQ36OOhvSvXkDR7vP5qvsNP4L/Y11lQR9ooB5x02kq+GvfHFcgvH3g4qX4goH3g4cqe//PKa370uPKYP+2fnvAPqeHjy9M+8Bflt7/7BiGij9Yecw0Gbun8y17y3B/8wfLLZxxQDjv8q+UL/3ypnhYW7OBy1G+eXT769O8q9Rcpxvp/47RHlMMe+Ppy8caR5Uff+r7y+gfcWLL2578n+euDXD3suTS0kN93VbX1qbHALT1/P8CEbayGpBmfv+8ScvVA4DK/TA2bG752y1irV2MNSZP196srVi3MtR4KXM6/nH+5/uKi2dLT1VMlDUmT+0/uP2tXsLDX9nkVuNx/w/6LN5Hq7WL7U6mus1ojHlq96jYkTa6/XH+5/rhAAtDVYmuG66b/FTR/2j50X3BsrIakyfWX629p/W1syotC3LvlHzHsqv9spe/bOf+kElK1vP5LGZZmT5sqC03uP9htcv+VSuT1J6+/sn2s7SC6W9ieUTeUwOX+m/tvXn8WrrNrlK2lhqTZl+//hw8E2IPH/Se2Azxdp+C9GZ7o6i5jg2GYFetGJyRofbyHvalxPjCNPgR3fa6c8Yz7lHs/9x/KpTXUj83b/5fyF+/9r+VeB9QbTyHbrknQVN7bdn4knCxG/0J5+4nHlAf8zhfaQ6jseNQ1ufnDry6f+dNHl1tIsL0/vLbL25MZhxl85Be6Qvlt83sc9d/KGYOquhuHnlT++P+dUh4h3+Hfermus3zLIOWXnnZCudkD/6T4t3DrU6q98Rvy9Q1vPM3t1V++GeKcZ5WH3u2/lXdeJCPXwfvRct34fuUZ73pdec53H7JXzv/O819SHnX8k8vrLpBE1//+8rR3v6n89nEy9uJRH0x/doQEpXzu+eXBt3paeeulohJZff56bJT9H/X6csFrHl5uCipYN0bgR8fpKrzg+eWhku/Nkm889nvw75Vz5WcPblUfhwT3yvz73PPKQ271C+UtLl87JzL+5gN/r3zirY8vR9Rc/cFsff53lPNPvVc56uT3lP72fOuoL5rKCBs3LLd69l+Vj//n7y3X6+P1Z6IeS0HQeO9p/q+XT73yQeW4J76rXHT8r5QXH/9H5UnPO58j6qOVb3CQb1S4SL5RIf7kRZXtLF9+3YPLtz7ytPK1cvvyhNPPKK+4u8wPJiJYyb8X629JMz/LTpD1lwr4amy9/lq5euN7eX7ETkdI0MTey/yyu8hW1mriCzOWNZy1KegINwghQdZfKuCrkfMv51+uv9x/2p7gNwa3oyrcMujUTkdI0HTeq/vP5ma9G67/i9NN/EBA7eZ7VX/tcDpCgtbJe7n/5f6X+1/uf21P8BvDtL1sGXRqpyMkuNbvP5uymOqzxaH7+HXn+YfrFJ82QSuL9/L6k9efvP7k9aftCX5jwAZKu2WQqtx/XJ0ICXL/lQr4auT1J68/17brz/CBgGHCywKorzEsH7o0/AJZ1ik7qpu/0NlTHs9ja3RrjfWieseHy5//4mPKj7/k79sbz5XHCyml3Ljc5pf+tJz1P36gHC701mNzxC1qtJC/q1vvhQRKfVz+dfO/l3/dfFEfIL7g071S9rtzOenMt5dT7rz8u/eWHc/FEm6dX3te+t4nle9qP12wkP+gR5SXnv+actJh++2l539Z+cIf3b8c8R/+snydTxDPQIjv+x/lb//6F8txoPrZsWfEwCJQHdSXli+e/ovl4Q95cfm/Fws35Nu4zU+UF7/tJeXko26wxXOLIy4l3fWlN5f/+rDHlGefeYk82puX7/qNN5X3/vL3lQNF3Hrj4bjOnvK4Si6T83GsnI/6Exc1Fo47Pbf8zbt/sdyxPpeFQ8eyERsylz08ZV9l3wvkzR2eXc5+/6+UO8uH2ldScswKdFwbvSFzm3bnB55Wvue455cP9Tw2gBA13wf+czmeycYRTU108WvLycc8urzssztZLz/0xo0fXV5yzu+Xk79lf3bxD8ljCghqdFe55D1PLw++//PK6V+9Q3nMaW8vz7/gMeWWMofxvSNV3nLe4dekXv+pHN9ewPXn/+Lyvl89rnzfr51XyoGPLC/59KvLk2RN1WP3+fUFBJak9VpudCwbsSFz2clTHlNAoNGtNRTv0fmvaj+exzYSUOavM2vrGqFWqKupGzKXQk95TAGBRrfWUJznX0rhz1ar20LxPOWxVRJIo1troM3zP1ar+QvF85THVkkgjW6tgTbrP1ar+QvF85THVkkgjW6tgTbrP1ar+QvF85THVkkgjW6tgTbrP1ar+QvF85THVkkgjfpvCGgXWQnPHwjI+mu1rKINmYuihvuphTB1c0VdaAHqWDZiQ+ayh6c8poBAo1trKM77LylF3n/ZbGnIXE4UT3lMAYFGt9ZQnPNPSrG7+Tfu5TvlHYf1v+2z/rGiNteW0Fit5i9MXk95PI+p0a011mtUN3+hs6c8tpGANLq1Btr5atX6LXT2lMc2EpBGt9ZAm/nHajV/oXie8tgqCaTRrTXQZv3HajV/oXie8tgqCaTRrTXQZv3HajV/oXie8tgqCaTRrTXQZv3HajV/oXie8tgqCaTRrTXQZv3HajV/oXie8tgqCaTRrTXQ7nn9+YGA9YH117f9zaz91bzWa42vDxAxWH3Q0bMnUvX1tvjK5t/1lY+Xs/7sBeX5v/HK8oaPfr3/62q8PejtYeW2P/Xr5WXPely51y3qv+fdO/ntGeGZwg7P/xvnl/e9/KTyqKeeVs67HL3w+MRvsNZDH9nmbR5ffuuNLyhPPebQxg2jYQBnkRd2pceuT5d3nHT3cv/f+bQIlvIfXo57/jvLWU+9/cK/eo5ju+QCEYPt+Xe8t7z4QfcpT/nLS3y23lXy73/n8pP/+43l5d9/uPvX6HEMy7PGVwVi3yhfOv3p5Ycf+qJyevvcBfj+R9iRP1b+y6teWJ5558OkzxWdfzvLNz7/hvJrJzxBPgwg33cg/xr98Ee/opz5hz9WjqrfGc9nWOuqB1j4Zvv82/WZ8q6n3qvc98XnlcvlO0dw/tsnlOp3kOx/n/KM97+hPOfYG0rX9dEsFjXRq0N8VvLds9z3RZKPj1f4lljy73fH8th3vLn84b3r91OMxzSaEyAGq6Fdku+v6vN70bnyb+b1UVonSbrf95THveNt5Q/uffMrcP4vlZ9reHi544/JzzXUGrW6yFMQWD/dJ1/ZUA59+KnlzFc/oRwjS70q5mNt/V9WLvzAc8vP/egzy6s/cWA54smvL+97wf3K4f9yajnhlieXP/m6jIScdeDN48vJZ51WXnqn+u0QeCxid7ytPOPYHyq/ee6lZfM+Ly//8M6fKrcND2Qtf32ksYaV0WONr1HEYHfXI/PvjeuPVjnrn/MP6w42159fFbZOgHL/yf3nit5/xbWFmaQWMdjIRm31cv7l/Nt359+mfM30Ltxntskrfynvqn84hpvIFtEG8x42sk7YYc7/nP/77vxfnudxbsc5jRhszv9agVgNX7Fc/1fX+t/cqL8jWbPp+cA3BFxd+ZevGHn+s/65/1/Z9x9sR8VOC6uR6Jk6//7I/Sf3n9x/cv9xOyQhgd8wBa/xVYYYrHaNnnKIXJfWn3wgYKfUwt0KsjIEvjoBRwU27i4JQXHqixbyH75mwwYKQjtfPHGmHFHsifw7ypfOP6d89MOfKF/82j+XT557bvnMB95V3nDah8p5X5URaqd2CKhPm36nYQ69bTnuwT9SHnLv7y3H3PxbypFH3brc5ja3KIcslaqPpxOnDxAenDjh+ctj/NQnygVf21n2/9pnykc+fWH513/+x/Kxvzu9vOOt7y7v/oy8m7jVY8NjhN3viHL0j/xIue9d7lDueMublENufuty5CH2T7c3bniLcuQtb1raLyHUp83n8HV9HF+tpLynvHlR+adzPlsuvPic8u43/X55+Rs/Hb6+H+loJe+xj39iefw9b1+OuMnh5duPvEk58DJ9O3fzm25ZvvNbDm5PoxW5Pf9Lyuc++plyYfugw66y/64vlE987HPly//vb8r/edUflFec/SV587kfS8//kO8qxz/2EeXhxx9bjjjo0PLvjvl35dDL6/fLX68c+M23LN9+kwN7PqG2rD+SXFa+8uGXlaf/+H8sp77/KyDV1vybty13+dUXlD94xv3LbWrxhiOkkITt/O+6sJz7588qT3vKS8ubP10f2w3LzR99SvmL331cOfbA+mKdr38d0I8i5+OTn5J5IVWQ77bff/OS8k8fkXpdJOfjz/+gvPzPz9/6fNz4+8r9fvpR5aHfe+ty2A0OL0ce+U3lgMsvL/vd5IjyHbe4Ed8I32vn/5A7lHs+8T+UE44/shx+028t3/HNB5XN9rN3+5UDb3GrcuRN8QX58hzb+d9RvvjJT5bPy7yvz3v/610s8+3T8vw+IvNNnt8b3fNbPP93KN8v+R7R8n2bPKcDy2Z7Z3+L87/rn8qZv/qg8pBf/7vy5fZJgFrzetQTUc0N5MMaLypve/njyx1vKP8yn6eDoKlDs+vz5QO/+5TyM78oHwK4aLMc9JBTyl+//ifLsQdsypAXyM99fK/83Mfn2EWfyn7loIeeWt7z2p8qt69fEdGOS8rHTn1wufPJp5cLyy3L/V53Znn7j36rPi57IBBPNj5C7H9dFoLihP3HDxWEe/b8l1LI493z/S/zWwWy/n3Ca0lYDgIr1YCiIudfrr/6h2M/wuQQJ/e/tsy2vv+Q2rFuBKjoZKMi11+uv1x/V/f+U79mOh71bwy5vw6LU5zc/3L/k6mS+79Mg7BkwkJx62bg4yJrXlTk9S+vf1fu+sdvCKizq67V+tLsFkfOv1amXqFcf7n+rtz6axOJi4pgdQVGRc6/nH85/3hrFRaHOPn3R/79kX9/7PN/f/EbAtxfQv26iO19uND5y2NY9BYYafhqfWt99l7+95cX3u0u5aln7eiD1y2qPhfLUB+B3koqau5i03tVc6OTy+u+8NJyQv0Rexz6VODRjjR8tbX9gDzGu8pjrP+MeKvD5a8ban2Vp5vay6Ai8/2Ywt7tBeWcM55cbtf62KPYKO8vL5JaPYW18v0q7iM247HqOkOd+SX8ZrpmlEf/jdeXnz3sEeUU+UfzHFuHWml9To9VbvkOLUe/4OxyzlOObgHkw6Dw/TMHVzW7vnRWec2vPaU8/UV/Wz7HTyTUSM2wUa5/9IPKI3/iCeXEx96/3EXehObhBvnGlz5c3vv2V5VXvfR/lv8pH2xo74vLzwQc/XMvLa997o/Im8X4jJd/FBxJQOU/MJwP/5w91n72/BWZ78eVx3/iaeUS+f36+sX48VFcVef/EDkf757Oxy6Zby+52/HlyWd9oz0Sfc7+sY7YP2ePVWfPdzfnX97A/9DLTiyP/eU3lXMuqftZPay3fP1AOeDYR5Vf+I1fKU9/4HeUQyVku54hmSjl46e9qDzv11/cz/ENy2GPel55w0ueWO5yE/2a/zryzk/9Vvnh455e3nQhJgj2H/mmiAf8XPmPTzuh3P+bPlPO/pPnll9/7lnlE5fLByju87xy5lt+rtyxf/DEshqqY4cDwwdSq1qfHQ7I1PoWimqhUs6yGvLqhmMXhkcavlrfsosAqJSzrIa8uuHYheGRhq/Wt+wiACrlLKshr244dmF4pOGr9S27CIBKOctqyKsbjl0YHmn4an3LLgKgUs6yGvLqhmMXhkcavlrfsosAqJSzrIa8uuHYheGRhq/Wt+wiACrlLKshr244dmF4pOGr9S27CIBKOctqyKsbjl0YHmn4an3LLgKgUs6yGvLqhmMXhkcavlrfsosAqJSzrIa8uuHYheGRhq/Wt+wiACrlLKshr244dmF4pOGr9S27CIBKOctqyKsbjl0YHmn4an3LLgKgUs6yGvLqhmMXhkcavlrfsosAqJSzrIa8uuHYheGRhq/Wt+wiACrlLKshr244dmF4pOGr9S27CIBKOctqyKsbjl0YHmn4an3LLgKgUs6yGvLqhmMXhkcavlrfsosAqJSzrIa8uuHYheGRhq/Wt+wiACrlLKshr244dmF4pOGr9S27CIBKOctqyKsbli4b7Seo9F4Wd7TjV01jZJ8ZnI0ZGctqyLQdxS4MjzR8tb5lFwFQKWdZDXl1w7ELwyMNX61v2UUAVMpZVkNe3XDswvBIw1frW3YRAJVyltWQVzccuzA80vDV+pZdBEClnGU15NUNxy4MjzR8tb5lFwFQKWdZDXl1w7ELwyMNX61v2UUAVMpZVkNe3XDswvBIw1frW3YRAJVyltWQVzccuzA80vDV+pZdBEClnGU15NUNxy4MjzR8tb5lFwFQKWdZDXl1w7ELwyMNX61v2UUAVMpZVkNe3XDswvBIw1frW3YRIK8RtG8IMC5+Q4DxRBiYhIKRhu8zg7OukbFnbci0HcUuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFAFTKWVZDXt1w7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQRApZxlNeTVDccuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFAFTKWVZDXt1w7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQRApZxlNeTVDccuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFAFTKWVZDXt1w7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQRApZxlNeTVDccuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFAFTKWVZDXt1w7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQRApZxlNeTVDccuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFAFTKWVZDXt1w7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQQo3z4QgE+Nh9QYhVI3kIu1gZrf3kXT99mYRwL9k0GkFsDezV/f5LyrvMnt3mxv/zK4PsitDrycIk+hPhWRGyP4kBPLa79wavlR+UCA/ONtDbbh6nOs/hV5/ktvxFq2xfySoqbRQ7T1QRiBgMV98O4vKh8+/efKMYOqhA8E7N38B8ib0Bedet9ygD//8oGAk+UDAae2DwSMD+bK5L+RvAH9nnLOk+UDAXUYHrVGtVYkFoHOv6+Xz7/nJeU5v/Cccsq7v1Quk672iIBvXG723Xcqdzz25uXQbzqsfNtXPlP++bIvly986P3l7L/7F/ev9+WTgt/+sPLUF/92+e8P+PYiXwyw5WHz/2/Li+sHRc7eMc8/GcFOd31O9bmtDesfuXw446R3lItOkXMxyf08tD5Xfv7hDXr5CEqov883Ppgrk39Pzv9l5asf+7Ny6jOfUZ79x5905wqPo+Y/oBxyh/uV+9337uWe33ubcviGfHBhY2fZuPjc8uEPnlnOePP/KX/5qbqviPZ6R5W7POvU8r9+4Z7liP3FD+t/Rzn/tY8s937Mn+vPfqCgSDXab/+J8pK3v7ScfFT9hov6OOSo5zZAJVrrYk3YfBEHvg8S6l+5+bD5hw+BicaNpdC1Lpb5pRitHll/P2d0ltXaSF36PJ5nXleJTJdPzr9c/32ytDXFWSRTSInWuljuP1KMVo/cf3L/kfUS9to6N4QI3LwL5/X/mnv9Cf+qtJ9afSOpOnn+c/7n+s/9b97zPZP7/76x/2Mvx8sF2Mfb7V3e/8qU7X8FaEH6FK7XuBqSfS7wNVxjuf/l/tenyorJ/Q/LJ19/yddf+h+Lbi9V6FoX0z1WFlbuv3n9CfOibrZC5PW33rZseexT1x+56ayncT6WTi6fWf/owKSpw7iPFTBO0BeN8+fMykwST2yV/2/bv77/eflX77WHHTcuh93+qHLYpV+VvUv7W0yQnLQDr//18uVzP1k+cUmNIF8fpX8g4BHtGwK2yr8nz/9v+4cW6rcYyL9OvuXty5EH73Dv8cqDqV/72H9TTB+JG7fXuP4c/S75ZYAbHCRfvf7Bz5YLLtO5Nzzy9g0BHz7jKfqBgBaEwj0OSWnvMYtzI/nK99vIV87v+HqvxJz/oFqvT9R61fHkECM9m/7AE99evnzK/drPFCgjkUvlAwE3fUR5mdS392jdarPxzceU291UNDvrv60Xu/D8DzpIfnKgPs/+r/hbrtqU/i/S6wcCZGTe1uBptmxN2B8KA7VzPORfgZ/7l68qr/69l5eXv/Yj8o0B4yM1ueXv3C75l963uld5yM8+rTzzp+9bjjlY/tV4S+vyNeh8G04Q3jCv/4IemmplmFscXb7jZpvylfy1Pvoccf6boDYiPWS/fy7n/P2/lPoDCNqzfltD/XDG/fUDAW3Y1ohi/fxv3Px25TsP20/eD7+8PxJX157/4AMvLp/9kJ2PKmw1kfNxjHxDwIf5AQ3kk+d3V/n2jvqBh/p43XH1nX/5YMDH31j+8Hf/qPzp697Z3+CXByIPPMz//qytiv3B1p/neNRPlqc948nliUcfqk/YPQ+cm41ySTn3j08sjznxf5X3XtSfrRan16h2km8YeMCvllf87lPLQ795+LgGSsaxPdHPhaec7krNf4wzje2JzN9q7EuCuvW1EZe9EzbofPYbwCTxRNY/6y9/uvopwenj9mnGCXQ7W+7IERpwXTTgiZx/Of9y/i0vo1x/ef/RX1bklkmw1/ffjf3anQa36OpdLn/S5/2HFIJlJ9jr9ddCa/lxEnL+X33zP+vv517Fef25pq6/+vMvdafCqyjxpVm3h+Ece6r1q02e/2vq+ecp1NM4vLbkT3b+/dXOsS8Ji5fzP+d/3n/k/X+7FPY91G0UDTqf+8YAJokncv/N/ffa+frX9JMBcdrP60mXjVM1qH5t62EvUZgOCFaVvtWIjxMTQO+IBtWvbSk7yiUXb5RDDqnv3JsOCLZJQ6MRHyeWF1gu/eIXy7/e7GbyVmc9GOnQ+tbo7p//pWXHjuuVA8Lv0tsY6M8sBHX0ejiiQfVrWw/0V93l5atfuLjsd9hNSv2ye9dTvB3l4os3pVb1y+RtDPSnlkBk7XBEg+rXth4b5bLylUu+UQ6+0UHNq5zKvlou+uqB5dD6Rvl02BhXPP/X5ZxvloPbOR+fv46mo+NZTsmFGPPvKjsu/Ej54LveXt7+f88of/P+fyznnXdu+ejnL2vKOsKGfJjj+kfcoRxzzNHluOPuWu7xoAeUh975lu0r5zUDsmJ0sxr3bdVeWi6Sb084tD8P9iaA3hENql/beqB+mk3Ov5yLg250gyKfHenPssmkuarOv4x7iazBG+mPFNRs+gh3yPPb4PPDo1BrzwGPXxl2dnJG+sDbPf8Xlws+cFY5/a/PKh94/4fK33/kvHLBZz5RPvhp+RBMfxAbu25QbnTb28s5vlO5y33vWR7ywHuXexxxsNS4C9pDscdeHyQev3y6pXzjU28pr3zhS8sfvOH08p7z9VtLNm7x3eX7fuBB5Ycf87hy4gP0JwpQIffM7Fx5slXBEQ2qX9t6WH7TAcGq0rca8XFiAugd0aD6ta1H5tc64JxWDxWDhcKs1RD1o5YAakc0qH5t64H+ltWQ66litjYG+lNLALEjGlS/tvVAf8tqyPVUMVsbA/2pJYDYEQ2qX9t6oL9lNeR6qpitjYH+1BJA7IgG1a9tPdDfshpyPVXM1sZAf2oJIHZEg+rXth7ob1kNuZ4qZmtjoD+1BBA7okH1a1sP9LeshlxPFbO1MdCfWgKIHdGg+rWtB/pbVkOup4rZ2hjoTy0BxI5oUP3a1gP9Lash11PFbG0M9KeWAGJHNKh+beuB/pbVkOupYrY2BvpTSwCxIxpUv7b1QH/Lasj1VDFbGwP9qSWA2BENql/beqC/ZTXkeqqYrY2B/tQSQOyIBtWvbT3Q37Iacj1VzNbGQH9qCSB2RIPq17Ye6G9ZDbmeKmZrY6A/tQQQO6JB9WtbD/S3rIZcTxWztTHQn1oCiB3RoPq1rQf6W1ZDrqeK2doY6E8tAcSOaFD92tYD/S2rIddTxWxtDPSnlgBiI/ivSiVU2XrYG0mmA4JVpW814uPEBNA7okH1a1sPPH571oZcTxWztTHQn1oCiB3RoPq1rQf6W1ZDrqeK2doY6E8tAcSOaFD92tYD/S2rIddTxWxtDPSnlgBiRzSofm3rgf6W1ZDrqWK2Ngb6U0sAsSMaVL+29UB/y2rI9VQxWxsD/aklgNgRDapf23qgv2U15HqqmK2Ngf7UEkDsiAbVr2090N+yGnI9VczWxkB/agkgdkSD6te2HuhvWQ25nipma2OgP7UEEDuiQfVrWw/0t6yGXE8Vs7Ux0J9aAogd0aD6ta0H+ltWQ66nitnaGOhPLQHEjmhQ/drWA/0tqyHXU8Vs5SX2TXmFRgS1f339YefO+rJ7deR/GzQSLaaC2tbDpNYRCFaVvtWIjxMTQO+IBtWvbT0yv9bBnzhUDBYKs1ZD1I9aAqgd0aD6ta0H+md+qxMQrFbKtxrxcWIC6B3RoPq1rUfWX+uQ88/mCRAsKmRWIz5OTAC1IxpUv7b1yPmndcj5Z/MECBYVMqsRHycmgNoRDapf23rk/NM6XBPnn/5kAE6iO8/tKckb4e2rQMRhiABPutuRX/RBdhuNS4IxRVC/ikQO9DTQNTAUdGLRB9ltNC4JxhBB5m/FQOWy/lIO2/H6RBHDAnVq0QfZbTQLY4gg518rKCo31RlngIJ9uP7yvQ0Xf/WgcsjB9aMZMony/PsysB44pfq7Gbn/13pwehOwSgpGftEH2W00LkkfO6//uf/m9actBqwcW4i5/kIFWCDsHWL9fVKLQ9RtNLn/oDwobO6/uf/uZv/FMPIMNAAAQABJREFUBwLqYqvLrf7blfaBgGku1fUIMi48sNPelvMv599u5h+2qnnu1PnGaN/bMdNy/rXixDLk9Q/TA9PmOrb/2F6uBdhVvw0y118rBqcGASZJtyO/6IPsNppcfygPSnsdW3/zNUwKkusv159UgEuDAIuk25Ff9EF2G41LgjFFkPOvFQOVsxOR9Q8VYIEwd8Tm/beVqNUHReo2mlx/Ug/7hgB38bcqWo1QSh8DtpghxGBbZAo7IvNz80fNqkWFYH0M2GKGEINtkSnsiKx/1r/ffGDOVIsZAutjwBYzhBhsi0xhR+T8y/mX8w/LhRYrBJYBByxmyIUbbJEp7Ihcf7n+cv2Nyyavf1IRfaNR7VQgIWwXMTTqWmQKOyL3n9x/cv8Zlw3XllspQTO+iVSD9g0BJs31J8trKqIjcv/J/Sf3H9swOsIKgZ0EQljM0KhrkSnsiFx/7RsCcK9V61f3cVQIdqxr00mjr/2vq1pkCjsi65/7X+5/0/LCCoGdBEJYzNCoa5Ep7Ihcf7n+cv2Ny4Zry62UVY1fiaMo158sr6mIjsj9J/cf2X/sAwF+Bbl50ujRp3YOzAzFBkS0S2Ynv3bbIorGQUaf+jkwMxQbEFHmz/rn/PMfIbPlwaswqNVFNQdmBoM4m+sv95/c//P611/GcjuDwnETGX12mAMzQ7EBEeX1P6//ef3P679tCg6Nm8joUzoHZoZiAyLK/Sf3n72x/9Svmd6Q75fuv2rZ7NIHAmzyCcr5l+sv77/z/jvvv8O2SGe8iI/+qrBtrWtVZa+1/Vc/3NU/EiBml/xkQDuupvx8gGO+0V8VXrnnvzps5pc3K1gdB+bCzIyTA4oo7z/z/nNv3H+OEzPn31gRLDpnc/3l/pP333n/vXxRn2+iVjfVOTAzbt8B3GL/iR8IaEK3oa18agTj1htbPCeFjqgiuM3WplJyGeo8wi2gQdkoOKSIRbHwqSmvz/xaDa3lUFG4zdYm65/zL9df7j+yEdQXHNTUbUEPIXL/zesPX3vI62/ef+T9F3bH2boNVKEjqhpus7XJ+6+8/8r7r7z/ko1gL91/bWzWq3X9X/eXinbW63Y92r4Dm/uPliTXX64/mQl7af21pYclxgVXZ5ocuf5sa2qTLu9/trr/Gb/txf9kgE6oocX84lRzRJXCbbY2Wf+t6l/rla9/6JLVySIFyb//WikWm7auNKLQEZWG22xtcv3l+sv7z7z/lI0g7z+5PbaNUTfHvP7KvKh/w7fj3+D1d/1AAC5ceCBiI+U8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B518exBjwbpRIuU8B6vcv4lUX0io4d1+Q0DtWA+MBatsCCnlBA46+fYgxoJ1o0TKeQ46+fYgxoJ1o0TKeQ46+fYgxoJ1o0TKeQ46+fYgxoJ1o0TKeQ46+fYgxoJ1o0TKeQ46+fYgxoJ1o0TKeQ46+fYgxoJ1o0TKeQ46+fYgxoJ1o0TKeQ46+fYgxoJ1o0TKeQ46+fYgxoJ1o0TKeQ46+fYgxurW7+V1QNvHIayk/M9XjKvqShwYC9YNFSnnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC9aNEinnOejk24MYC1ZGid8QwGGdAtwC1UKNd0FCAt7DGrO7+1qv7A9ggcr8UoFWF1ccQoKsv5QJL5bhbymrTp9fwSxEF6jWpfEuSEiQ9c/65/yTOWArIuKw9GxRRdp39pHGuyAhAfMak/l9LXw5FS9EF6imbbwLEhJk/aVQef2Ja85mxzz7orLH1zo03gUJCXL+5fzL9SdzwFZExPMK9Mpcf60CCyUx3gUJCVh3Y/Ze/Tc25CcDJEMdG4e+kWTZgGCrzmP0M7sQXaCavvEuSEjAXMZkfl8LqzvQQnSByvpLBVpdXHEICXL+SZny/jPuOTY7sOa8XYguUK1H412QkGCP51/9QIA/T/yml5rIhvMPNOd/q4srDiEBS2fMejm1uF7Zy71AtUjjXZCQIPNLofy8rnWz6rQqDs1CdIFqnRrvgoQEzGVM5ve1GIov7kJ0gcr6o1SuOIQErKYxixV2p8ErO71AZf2z/jq53OQgJMj5J9Mkrz9xz7HZ0feXbuQDAXLbKd+ThG8GWhKCg619gWHjsN7zCo+hkRczMn/Wv65YOZZnyPqCXtLrSGi9wmOL5/zL9Z/7n66H5RWS62/thmKpXthZ5oouqfP6l/tv7r+5/867BfYR7BqwlQeGhXa2XuExlLn/5P6T+881df/Rf1WKuxNd0/YvS6vv17zHuf57tfL1h3z9JV9/yddf2nawvENePX//tr28Xoj6T75gH8djgq0PFBhW97Kl1is8hjbv//L+L+//rqn3f0srGitbrVd4DFWu/1z/uf5z/c+7he0QV8/9T823vENlfvyF32/TWaeleuG8qfUKj6GK+7/7hoAubsZ39HwdxMcw6J5b9hYQfq8J4zYBVZaPFMGeJ3VK9haQ+XWhaXl6ZZphlbL+YV7WSvnaaOWuSMveAnL+5fzDBs951SYIZ4nNN1IEV2TaUcveAnL+5fzL+Yel0VdGM1wluf5wvWNJCFC4K2TZW0DuP7n/5P6D5dNXRjNcJbn/5P4jc0BWCacEQZs4/l+V6kyS7wvYtVPhQsveAnL/zf03918skr4ymuEqkaDnq9bH0HfPLXsLyPWX68+vv/ptL/4I3/TiJ077925euefYD5PzL+efn392n8FZIhOrY1IEez7pnJK9BeT8y/mX8w+Lo6+MZrhKcv3l/iNzQFYJpwQBJs4VsuwtIPff3H/H/dd9ICDOK04c0MMEqh9ijZ+qcT0Am5VPIMiEtsR1QAgw+GwnhRB+Amf+rH/OP103ulbcigFsNtdf7j+5/+b1x19jsUF4LuJJIURef+0GMu8/8v4j7z/y/qNWQPdKt2MCNpv3X3n/ddXdf+k3BOhe3P9haZEv/dMLVc4/qUOuv1x/V936y/0/r396ude23REBXsH9Fx/uqpt33bXwDQEYM//+0staW3NS27z/bjMj7z+lDHXFcHYAXsH1p9X0NXWMjJXrjxVuX2KS68/PFUw64QBz/smEyfvvvP/O++9ryvsP/EDAtGz9K97uugg46RFoNuyIFploEHUPHZZN5pfNNE4jK+RCvXwwXpEsgnLDUrcwXtY/65/zz9bOgKb9KsSxwGB7EC5srj8pjO5xUz1z/8n9J/efsKt4Z1ovPsh9hRuNRuHCUpfX/6meuf/k/pP7T9hVvDOtFx/kvsKNJvefWgGUA5bE9vdffCDAl1+/IaDeVzGRhuHCuvh0PnP/y/0v9z+/rAKe1ssQ1b9ruNBy/dUKoBywJLa//4Wy00EC2B6AC7uP5d/ENwT0rTt8IIDPTUHOv+H14lAfnGDYa8b5D2+b5PU3r795/Q2r2ju5/+X+F/ZLPzl4Xc/9X+9D8/rXKoDpAMt5kvef2E835F8T1J0lHKyXsPWmFC86eD50qDr5PwwzEIPbujduIeCpzJ/1z/mnK8uvi1x/sQJTbQZicHP/kQq0miwUxlO5/+b+m/tv7r91w/T7QttAXTPFBmJwW8/GLQQ8lftP7j+5/+T+UzcMvy+4rcf2Ek8O4sG1PgsBT+3r+w/WRn1CdZbUx14f81gs/5yqth6NWwh4al9//vpMpqc7Ef45hT4LAU/l88/rD9aYnxeYQ7BTbCAGt3Vr3ELAUzn/rjvzD/OMc0r28Tz/153zz/MuQO/45DKWr7/n+w/9gwH+uoC5AjvFBmJwW7fGLQQ8lfMv9x9cl/y8wLyDnWIDMbg5/6QCrSYLhfFUrr9cf1fn+uM3BOjC9lOxMt73WNUh3Cn0UbW0/nt2oKkvWCx++m3M4X2PM3+rwEJJsv5aFLY5/+yvi1x/WoHcf3L/zesPdgNnxwuK9z3uXRaovP5oUdjm9SevP3h1Dystrz95/cnrD1aDs+MFxfse5/WnVUBKsrFpm0v9FzP1k/71RSStlrR5/cnrj00RXTh5/cnrT15/3HUHcLzGeN/jrl+grszfP3jh1/bxnZIIi3ch2QJ1ZfKjL6oR/YVkCxT6aEjavP7YKURhc//N/Tf3X6wGZ8cNxfse9y4LVO4/WhS2uf/m/otbCKy0vP7k9Wfl+tM+EOA/haIbap05fRa1nYXbS5tSmF/GRgbzjrYK60sUiw9CIjJBcTOc+VuxpF5Z/zZ/2iRrTXuRq3JxtmmsafvLYIpd20oqTc4/VxSDuf5y/8n91+8qdW3k/tt2iLa96h7btlGrjL3pgFrl/uuq06qnTSucNHn9cUUxmNefvP7k9SevP26zFJjX31aPdultzeLfP/vJNaVdXnrFKq77aTiaK01ef0JZ4OT1J68/ef3J64/uB9g7r/7rz0b7yYC6T/dHslNwfTjyO8yVrG09/JkKv52uYhX5tnWUJvd/XxXi3P9z/8/93+8qdWlgE6ow959aj9x/dcv0MyWvP7o2tDIeK9PaNnGkyeuvK4rBvP7uO9df/YaANo91MhPW84WVb+duFdV+9WhdgqO8b6cwk/btZRL43ss4dAnOrJ/ClXAXvQZrt3z+c/FWmFDT4MwdpnDWP+dfrr+24XAp1GWT+8+8eawwYU8JztxhCrPoef1hKWrZcv7Nk2eFCXMqOHOHKcyi5/xjKWrZcv7Nk2eFCXMqOHOHKcyi5/xjKWrZcv7Nk2eFCXMqOHOHKcyi5/xjKWrZ9mD+1TeRqky/E0BrLT8DqGClf9Z/KA+LnvOPpaglWpk/Wr3YhjkVnKir3hRm0qw/S1ELlfWvVdijI8yp4MzdpzCL/m87//QDAbqb10c9fbBrfipkwnMKDiUEU3gfef51wvOh1Eeb85/nbHcgnNPgzD2nMIue9Wcpatly/s2TZ4UJcyo4c4cpzKLn/GMpatly/s2TZ4UJcyo4c4cpzKLn/GMpatly/s2TZ4UJcyo4c4cpzKL/28+/jZ1y1xnPe3t0/Vm4h95pH60i9VeCqIWEd8kbfvWrsPTAKPVlDGNjrHpVVw/pt5JC6ZWgdm59M7+vdK+XFNWzWi7EqldxPbL+Of/CNGizojY6W/qc8VOHChXl+vMrDYXK9eerolMGtalexfXI/Sf3nzAN2qyojc6WPmf81KFCRbn/+JWGQuX+46uiUwa1qV7F9cj9J/efMA3arKiNzpY+Z/zUoUJFuf/4lYZC5f7jq6JTBrWpXsX1WN9/7F+2qbK20xtJMkzOP19p1Djnn6+KziDUps0kpbaYf6rufXzX3rMZ4XP++UqjUDn/fFV0yqA21au4Huv7n6p7H99VO2or/DVh/rW9XJ4qnvauXfUnA+px3Xj++lz9Say4Hvn8+40mjJZFWq1Wr5kvHRUquibMf33I/klUXI88/zjxvjq1Mup3dgxWQT2Ez/PvrzQoVF5/fVU4Wep6a0etUz1y/eX6C9OgzYra6Erq6wnLitEOhM/9x680FGrf23/kGwLqPydwn0zAXuBOKh6+o64QDP2rUw/m0Whrg1BltV2hTbAbFPpXpx6ZX+vgl3QoVA+LWaFNsBsU+mf9tVo5//qs0dnR2jBRbFKt0CbYDQr9q1OPrL/WIdd/mwxtjoSJ0ssjZoU2wW5Q6F+deuT80zrk/GuToc2RMFF6ecSs0CbYDQr9q1OPnH9ah5x/bTK0ORImSi+PmBXaBLtBoX916pHzT+uQ869NhjZHwkTp5RGzQptgNyj0r049riXzb2NTnog8p/p08NTGDwRcm59/O5e7afL5D9O91utaMv93c+pbOM//cLrz/A8F2Tde/9yUrxS2fVweU/9AQJi/ezLhB03oX5165PrXOuT9V5sMbY6EidLLI2aFNsFuUOhfnXrk/NM65Pxrk6HNkTBRennErNAm2A0K/atTj5x/Woecf20ytDkSJkovj5gV2gS7QaF/deqR80/rkPOvTYY2R8JE6eURs0KbYDco9K9OPVbmn/5kQBWEXpVwR/1Nwvr7F2Lq1wlwLCdZgzbs0qchXC8TOrLDzJ/1z/mX6y/3n9x/8/qT19/5DmGVsduKvP/wn1GdCmaFmkLyymTef+T9R95/5P1H3n/sY/cf9g0B9a/yuolLW/frflSkf6/n9S+vf+O3MWKWiLWJ4sgO8/qf9z95/3OV3/+0D3e51cd9PNdfrr9cf1f5+lt9YSXXX66/XH+5/uQeOd//xN+T7kZlC2h/VuTfn9eEvz8XfjLA/xFYsb6cMJ5zO9FjRPwaxLHYvfcWs7rA2kW4DrI4wJZ/v2Z+FH+tfFn/Nq9y/uX6k+1lcYfJ/acXZrE6uf+uba11663bK47F8uX+m/uvTIy8/uT1R6bB8hYhk6MFFqO5/8r+ulwZCeT+i6vPSpHy+tMKcy3Yf+0DAXbK25f+wV1cJHn+ry3nH6c52Nz/rBw5/60WRLn+98X1P37bi35DwOIEzvs/mcvLlZFA7n9c6ctFyvW/L65/O2l1Dss5ahN8eZb3Mxi60Mn5z1Lk/LdSGMr1n+tf9hWZBvn+68p9xHV0/+VPBrTNYuEqEynbSNpGG4O23/TbVYRhKQiEcxyENlLdAwkLMa0GEIYdwt11UQehjVT3QMJCTKsBhGGHcHdd1EFoI9U9kLAQ02oAYdgh3F0XdRDaSHUPJCzEtBpAGHYId9dFHYQ2Ut0DCQsxrQYQhh3C3XVRB6GNVPdAwkJMqwGEYYdwd13UQWgj1T2QsBDTagBh2CHcXRd1ENpIdQ8kLMS0GkAYdgh310UdhDZS3QMJCzGtBhCGHcLddVEHoY1U90DCQkyrAYRhh3B3XdRBaCPVPZCwENNqAGHYIdxdF3UQ2kh1DyQsxLQaQBh2CHfXRR2ENlLdAwkLMa0GEIYdwt11UQehjVT3QMJCTKsBhGGHcHdd1EFoI9U9kLAQ02oAYdgh3F0XdRDaSHUPJCzEtBpAGHYId9dFHYQ2Ut0DCQsxrQYQhh3C3XVRB6GNVPdAwkJMqwGEYYdwd13UQWgj1T2QsBDTagBh2CHcXRd1ENpIdQ8kLMS0GkAYdgh310UdhDZS3QMJCzGtBhCGHcLddVEHoY1U90DCQkyrAYRhh3B3XdRBaCPVPZCwENNqAGHYIdxdF3UQ2kh1DyQsxLQaQBh2CHfXRR2ENlLdAwkLMa0GEIYdwt11UQehjVT3QMJCTKsBhGGHcHdd1EFoI9U9kLAQ02oAYdgh3F0XdRDaSHUPJCzEtBpAGHYId9dFHYQ2Ut0DCQsxrQYQhh3C3XVRB6GNVPdAwkJMqwGEYYdwd13UQWgj1T2QYsd/VVr74Y0kJ4uviyLQkjjHwT3NHweOvTAcLKLx3SwXdRDaSHUPJCzEtBpAGHYId9dFHYQ2Ut0DCQsxrQYQhh3C3XVRB6GNVPdAwkJMqwGEYYdwd13UQWgj1T2QsBDTagBh2CHcXRd1ENpIdQ8kLMS0GkAYdgh310UdhDZS3QMJCzGtBhCGHcLddVEHoY1U90DCQkyrAYRhh3B3XdRBaCPVPZCwENNqAGHYIdxdF3UQ2kh1DyQsxLQaQBh2CHfXRR2ENlLdAwkLMa0GEIYdwt21aPxwl/5kgEWrvHsgYTkwgAYQhkUUw6jvog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IC7RsCwMOy9wxUsi6cIyNjPhEA7JyWjErWhXNkZMwnAoBlthmoZF04R0bGfCIA2DktGZWsC+fIyJhPBADLbDNQybpwjoyM+UQAsHNaMipZF86RkTGfCACW2WagknXhHBkZ84kAYOe0ZFSyLpwjI2M+EQAss81AJevCOTIy5hMBwM5pyahkXThHRsZ8IgBYZpuBStaFc2RkzCcCgJ3TklHJunCOjIz5RACwzDYDlawL58jImE8EADunJaOSdeEcGRnziQBgmW0GKlkXzpGRMZ8IAHZOS0Yl68I5MjLmEwHAMtsMVLIunCMjYz4RAOycloxK1oVzZGTMJwKAZbYZqGRdOEdGxnwiANg5LRmVrAvnyMiYTwQAy2wzUMm6cI6MjPlEALBzWjIqWRfOkZExnwgAltlmoJJ14RwZGfOJAGDntGRUsi6cIyNjPhEALLPNQCXrwjkyMuYTAcDOacmoZF04R0bGfCIAWGabgUrWhXNkZMwnAoCd05JRybpwjoyM+UQAsMw2A5WsC+fIyJhPBAA7pyWjknXhHBkZ84kAYJltBipZF86RkTGfCAB2TktGJdpubmzK+zsV27FT/nVD/Hdl46DmEwHA2nATUsm6cI6MjPlEALBTViNUsi6cIyNjPhEArKWbkErWhXNkZMwnAoCdshqhknXhHBkZ84kAYC3dhFSyLpwjI2M+EQDslNUIlawL58jImE8EAGvpJqSSdeEcGRnziQBgp6xGqGRdOEdGxnwiAFhLNyGVrAvnyMiYTwQAO2U1QiXrwjkyMuYTAcBaugmpZF04R0bGfCIBG/vpv9pDQv5kAIhutQ97DlF+bMDxo9Z8IgBY13uEKlkXzpGRMZ8IAHZM6nyVrAvnyMiYTwQA6/KNUCXrwjkyMuYTAcCOSZ2vknXhHBkZ84kAYF2+EapkXThHRsZ8IgDYManzVbIunCMjYz4RAKzLN0KVrAvnyMiYTwQAOyZ1vkrWhXNkZMwnAoB1+UaoknXhHBkZ84kAYMekzlfJunCOjIz5RACwLt8IVbIunCMjYz4RAOyY1PkqWRfOkZExnwgA1uUboUrWhXNkZMwnAoAdkzpfJevCOTIy5hMBwLp8I1TJunCOjIz5RACwY1Lnq2RdOEdGxnwiAFiXb4QqWRfOkZExnwgAdkzqfJWsC+fIyJhPBADr8o1QJevCOTIy5hMBwI5Jna+SdeEcGRnziTqQbwio343gD0hA15cWBOO7JRBW1r3wgACsH9Mwow3QMwE/vlpj9cj8WX+ZCzn/uBSw6OLqgQerq2dsGW2AnpOBq7Yeuf5y/clcyPXHpZDrT3cG7BTRi6zGrGW0AXomyOu/1KLvua0quf/m/ivrJPdfWxZ1ScgRdw94sKoZW0YboOdk4KqtR66/XH8yF/bR9Vc/EFA26uPT2Vrb6U96C9maqfraDzcz1IDDgDn/c/7LXNhH53+/FMjs9fPWWE7rDqBSOT0nA1dtPXL+5/yXuXA1zP/6DQF9trWZh296yfpfPfVvRQ/7SK7/3P9y/8/9J/efq+P6l/tvrUC97/R3Abn/5P5z9e0/G/J7g/LPCTAJdUkutcsKsLCxZ31hQr8Gq/4bBr3ZbQqR4/56/Q+zYSxx69KIB/LCDtHMn/WXP7LqhpLzL9cf94/cf3L/lcnQ5kO7dCxfP/zVZFkBFtb3kF0nrz95/cnrT15/8/4j77/y7x/7+00ul/n33965/9ioHwjAUd9QknuO+id9PfL+I19/yNdf8u//fP3jmvH6T1urbbr2Odv38baXS9P+Xq0OD/zdCctAA7n/5/6f+3/u/7n/XzP2/7h7R29lhxeRzu/Fq0O+/pivP+brj7JGcv3v6fuf7RsCwmZDhyDuTAselPX+tc4/WEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOIFD0rkhaUUAhIRhDAdgihe8KBEXlhKISARQQjTIYjiBQ9K5IWlFAISEYQwHYIoXvCgRF5YSiEgEUEI0yGI4gUPSuSFpRQCEhGEMB2CKF7woEReWEohIBFBCNMhiOLBax8I4DcE6IuDO3fWN0KccDdDhTAdAjfQMoQSzxuWaghIRBDCdAiieMGDEnlhKYWARAQhTIcgihc8KJEXllIISEQQwnQIonjBgxJ5YSmFgEQEIUyHIIoXPCiRF5ZSCEhEEMJ0CKJ4wYMSeWEphYBEBCFMhyCKFzwokReWUghIRBDCdAiieMGDEnlhKYWARAQhTIcgihc8KJEXllIISEQQwnQIonjBgxJ5YSmFgEQEIUyHIIoXPCiRF5ZSCEhEgLC+eWtv8dQ39PfkQH/khWVfCEhEEMJ0CKJ4wYMSeWEphYBEBCFMhyCKFzwokReWUghIRBDCdAiieMGDEnlhKYWARAQhTIcgihc8KJEXllIISEQQwnQIonjBgxJ5YSmFgEQEIUyHIIoXPCiRF5ZSCEhEEMJ0CKJ4wYMSeWEphYBEBCFMhyCKFzwokReWUghIRBDCdAiieMGDEnlhKYWARAQhTIcgihc8KJEXllIISEQQwnQIonjBgxJ5YSmFgEQEIUyHIIoXPCiRF5ZSCEhEEMJ0CKJ4wYMSeWEphYBEBCFMhyCKFzwokReWUghIRBDCdAiieMGDEnlhKYWARAQhTIcgihc8KJEXllIISEQQwnQIonjBgxJ5YSmFgEQEIUyHIIoXPCiRF5ZSCEhEEMJ0CKJ4wYMSeWEphYBEBCFMhyCKFzwokReWUghIRODD008GaNBL6ucr6k1q56ZscfDZs7Eakob/OmQWx1w9riP0cTK/fupioXbLVK+bBBuSJuuvf3Qt1UurZTWrmsDl/Mv5F15tXZpFnrO51JA0uf5y/fnX6+fZYnOmxtTrXO4/uf/k/uOXzG6wraWGpMn9N/ff3H+Xl42uFlszVRW4vP7sU9cfvIlU/6EQPhcQ30iyc9mQNLn/5f6X+1/uf0sVCHt9FwQu9/+rbP/f2JRve6n1bYe84rprZ0NZ/7pfaxXmf23Wy7Vqej+JNyRNXv/y+pfXv+UFo6vF1kxVBS73/6ts/59q3U9R1j/3/7z+9T0p95+rdP8ZPhDgLgSEBG178h7OTeN8oG9kZrYMmgw3fZVhF4Km817m17nRauIL4yqqcMugUzsdIUHWXyrgq5HzL+df+0YUmRdb/+qKnzVuuU3Q6QgJmtp7Of9y/uX863uyXxhbrasp5gk3CCFBrj+pgK9G7j+5/+T+k/tP2xP8xuC31GnXnIKOcIMQEkwj5f5TyuZmfWm7/i916iZ+IKCWLdawMsuH0xEStC7ey/rn/p/7f+7/bU/wG8O0uWwZdGqnIyS41u8/m7KY6rPFofv4def5h+sUnzZBK4v38vqT15+8/uT1p+0JfmPABkq7ZZCq3H9cnQgJcv+VCvhq5PUnrz/XtuvP8IGAYcLLAlj7JB2UfoG4nXWCqjN1Q+ZS7ymPKSDQ6NYaivtCNnVD5lLoKY8pINDo1hqKM7+Ugp9yEtzqtlA8T3lslQTS6NYaaOfZ2votdPaUxzYSkEa31kCb+cdqNX+heJ7y2CoJpNGtNdBm/cdqNX+heJ7y2CoJpNGtNdBm/cdqNX+heJ7y2CoJpNGtNdBm/cdqNX+heJ7y2CoJpNGtNdBm/cdqNX+heJ7y2CoJpNGtNdBm/cdqNX+heJ7y2CoJpNGtNdBm/cdqNX+heJ7y2CoJpNGtNdBm/cdqNX+heJ7y2CoJpNGtNdBedfX33xDQ/qiSlPMHAq66/P/Wzz/zb/UazVU//7L+Wf/11whz/qECuk5stTRkbpONe/lOecdhvbbjiMi0bEf1Uv7a0z8kj+dRxxFnhWdGdfMXEnjKYz+WYo1urbFeo7r5C5095bGNBKTRrTXQoq6mbshcCj3lMQUEGt1aQ3G+/iylyNefbbY0ZC4niqc8poBAo1trKM75J6XI+WezpSFzOVE85TEFBBrdWkNxzj8pRc4/my0NmcuJ4imPKSDQ6NYaiq8x848fCFh/YrvkyWyEydSfnTzbtV5rfC0QYrBatOgph0jmz/r7zYxTyICfMILXZ5PFoiZ6fric/7n+cv3l+nM7BCGB3zBy/8n9V+bA2kt5mDOwOnWi56dTXn/y+pPXn7z+uB2CkMBvGILX+CpDDFa7Rk85RHL97bvrb1O+ZnpX/Q7kdl7rGZOVsuvyZqs3HzjTsKqInu+V15+c//vu/F++z1qfzbn/oTawuf5rBWI1/m32v80N+ckAeSTYzfENAbn/5P6T979uhRIS+AW75Wq2lR77Rs8Pl/c/uf/k/pP7j9shCAn8hpH7zxZ3U7n/Ys7A6tSJnp9OV+/1Rz4QsFMei3vxmo+MwD+6gKMCD7xLQlCc/sNN+JoNGygIbb5sOam0d+yZ+fXCnfVvFQiTI+dfrj/Z4+S/3H+kDG67dxvusKmGBdQ3lWiiIvff3H/rH079CJMj99/cf3P/zetPXn/z/iPvP/bm/Vf9mul41A8EyG9P5/XXvayR9x95/5H3H3n/sW/ff/AbAuqGLtO1vTQbN/fghS1eNvz8+zP//uTdQJgcef3L619e//L6t29f/9rFjfsWQbjmeScq8vqX1/+8/l/Z6z+/IWB4BcHdXg4LbX1FMhIXqo2svG/ZRUDsZVkNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNxy7MDzS8NX6ll0EQKWcZTXk1Q3HLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNxy7MDzS8NX6ll0EQKWcZTXk1Q3HLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNxy7MDzS8NX6ll0EQKWcZTXk1Q3HLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNxy7MDzS8NX6ll0EQKWcZTXk1Q3HLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNxy7MDzS8NX6ll0EQKWcZTXk1Q3HLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNxy7MDzS8NX6ll0EQKWcZTXk1Q3HLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNxy7MDzS8NX6ll0EQKWcZTXk1Q3HLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNyxdNjbrSwD1//pykI4yftU0RvaZwbVxWhMZy2rItB3FLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNxy7MDzS8NX6ll0EQKWcZTXk1Q3HLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEAlXKW1ZBXNxy7MDzS8NX6ll0EQKWcZTXk1Q3HLgyPNHy1vmUXAVApZ1kNeXXDsQvDIw1frW/ZRQBUyllWQ17dcOzC8EjDV+tbdhEg+3f7hgDj4jcEGE+EgUkoGGn4PjM46xoZe9aGTNtR7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQRApZxlNeTVDccuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFAFTKWVZDXt1w7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQRApZxlNeTVDccuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFAFTKWVZDXt1w7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQRApZxlNeTVDccuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFAFTKWVZDXt1w7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQRApZxlNeTVDccuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFAFTKWVZDXt1w7MLwSMNX61t2EQCVcpbVkFc3HLswPNLw1fqWXQRApZxlNeTVDccuDI80fLW+ZRcBUClnWQ15dcOxC8MjDV+tb9lFgPLtAwH4VyshNUah1A3kYm2g5svLEYGvyYTo3wxQvbUj88tLOq187jM+rpYKXetiWX8pRqtHzr9cf7LD1FdFedS5IUTgGCTI/Sf3n9x/6zaa1x9+xtRdYxW61sXy+ivFaPXI629ef+WSGq61dW7k9TfWhLcdBHn/kfcf273/CP+qtM8ofSOpOrn+cv/J/Tf3X15qFkFef/aN6w/28nYtqFt3PTFy1BZf2dywEi2me3wV5P133n+3idLnRTUyUfL+uy6eLY/c/7B95Os/+fpPXyzuGqPQtS6W1x8pRqtHXn/z+iuXmXCtqXNDiMDNl6J96vojN511Os9Hm+Se9kR/68BTlLq3FRgn6IvH+ew3gEniiczfLt2+JCxf1p+3NawPQc6/VgpXD86bAUwST+T6y/Unt85+SnD65P6T+0//s4rzgyD331YKVw+umwFMEk/k/pv7b+6/ef2RPWP6YzOvv9el6+/Gfm4CyCWiepfLn/SN5SWDIK+/rRSuHsNll+4k8URef/P6m9ffvP7u3etv/fmXusvoLi57THhpNvcfu9nJ/Tf339x/c//du/tv23rR+O22cZ7I/Sf3n9x/cv+59u0/008GxG2v34J5ctwcW0wFta2HvURhHYFgVelbjfg4MQH0jmhQ/drWI/NrHfqrP81BxWChMGs1RP2oJYDaEQ2qX9t6oH/mtzoBwWqlfKsRHycmgN4RDapf23pk/bUOOf9sngDBokJmNeLjxARQO6JB9Wtbj5x/WoecfzZPgGBRIbMa8XFiAqgd0aD6ta1Hzj+tQ84/mydAsKiQWY34ODEB1I5oUP3a1iPnn9Yh55/NEyBYVMisRnycmABqRzSofm3rkfNP63BdmH/8V6XylHH+7Y0knRe1GkCwqJBZjfg4MQHUjmhQ/drWI+ef1sGqbshVDqJurYaoH7UE6OKIBtWvbT3Q37Iacj1VzNbGQH9qCSB2RIPq17Ye6G9ZDbmeKmZrY6A/tQQQO6JB9WtbD/S3rIZcTxWztTHQn1oCiB3RoPq1rQf6W1ZDrqeK2doY6E8tAcSOaFD92tYD/S2rIddTxWxtDPSnlgBiRzSofm3rgf6W1ZDrqWK2Ngb6U0sAsSMaVL+29UB/y2rI9VQxWxsD/aklgNgRDapf23qgv2U15HqqmK28xbK52YS1f/2HZTt31rddqiP/26CRaDEV1LYeJrWOQLCq9K1GfJyYAHpHNKh+beuR+bUO/sShYrBQmLUaon7UEkDtiAbVr2090D/zW52AYLVSvtWIjxMTQO+IBtWvbT2y/lqHnH82T4BgUSGzGvFxYgKoHdGg+rWtR84/rUPOP5snQLCokFmN+DgxAdSOaFD92tYj55/W4Zo4//QnA3AS3XluTwnfZSAOQwR40t2O/KIPsttoXBKMKYL6VVhyoKeBroGhoBOLPshuo3FJMIYIMn8rBiqX9Zdy2I7XJ4oYFqhTiz7IbqNZGEMEOf9aQVG5qc44AxRk/WPBfD1QpG6jyfmH8nBOCZHrL06nsUaslQC/L4665oPsNpqcfygPaypEzr+cf1IBTg0CTJJuR37RB9ltNC4JxhRBzr9WDFTOTkTWP1SABcLcETtdDyDqNpqcfygPCrsHf3/jAwG12LXc9d8utQ8ETGPV8wEyFh7sNLf3ID8e6ty35mO0n1tkyvytOLEMOf8xPTBtcv7JNNFFxNIQoEjdjvyiD7LbaHL+oTwo7dU8/2wv1wewa+fOPP85/9tk4NQkwCTtduQXfZDdRpPrH+VBaa/m9T/fQ8kDyvmf818qwKlJgEna7cgv+iC7jcYlwZgiyPnXioHK2YnI+ocKsECYO2Lz7z8rUasPitRtNPvE+rNvCHAXP3sW9hjxVHwM2GKGEINtkSnsiMzPzRc1qxYVgvUxYIsZQgy2RaawI7L+Wf9+8cecqRYzBNbHgC1mCDHYFpnCjsj5l/Mv5x+WCy1WCCwDDljMkAs32CJT2BG5/nL95fobl01e/6Qi+kaj2qlAQtguYmjUtcgUdkTuP7n/5P4zLhuuLbdSgmZ8E6kG7RsCTJrrT5bXVERH5P6T+0/uP7ZhdIQVAjsJhLCYoVHXIlPYEbn+2jcE4F6r1q/u46gQ7FjXppNm+NjIJGv9p0EckfXP/S/3v+V1I6xbKauarVS5/vL+K+8/Zen4N4n9qsrrT15/8vqzem25uq4/9oEA/1DG7KNP7RyYGYoNiGiX7I76bxqMJhoHGf1V4VaXZHZqosyf9c/5F67OtkDG9Tb6VM6BmaHYgIhy/eX6y/WX6882BYfGTWT0KZ0DM0OxARHl/pP7T+4/uf/YpuDQuImMPqVzYGYoNiCi3H9y/9kb+0/9mukN+X7p/qumzS59IMAmn6Ccf7n+8vWXfP0pvjr//9k7A/U4bpzZrv2//yNf55IET6FAdsvZ2STrZDFf0igUiqSEAcHWaDzKFnEeYqcv5R24GYkTDFGff/f5F2/umvdkI0HD/Db+ZMB6vCb1DtxMpl1oiDr/d/49P2VrvCb1DtyMZk3Q+e/66/O3z9/SZLI9zPZfQqcv6R24GYkTDFH3/+7/f8TPn7VQ151LKd0sOkNdf7/s/qtvCFhPlD3FL+/a0VNr3SegEVOEu+y8TGqU4eYJr0AER6J6fb1M2/kfxaBsqEwErIACGrHraXWnRc9L11/vv+4/3X9HI5gvuISZbSEeg+jzp89fnTh9/vb52/cfdMfbWgMNaMRU4y47L33/1fdfff/1R95/ffs+T6v5f+yviX7Mc2s+1r7D9v6LlHT9/ZH1t0qPElPBzUyPR9dfbs2V9D7/+vx77z/np734nwyIDXVc2V/aakZMKe6y89L11/X3Xn+zXvr1j379o1//WK1ybIaxIfrn/52MB7POleADGjFp3GXnpc+fPn/6/PmVf/6KNwSwcdeWjUulzDNo8s8gc2FtlkqZZ9Dkn0HmwtoslTLPoMk/g8yFtVkqZZ5Bk38GmQtrs1TKPIMm/wwyF9ZmqZR5Bk3+GWQurM1SKfMMmvwzyFxYm6VS5hk0+WeQubA2S6XMM2jyzyBzYW2WSpln0OSfQebC2iyVMs+gyT+DzIW1WSplnkGTfwaZC2uzVMo8gyb/DDIX1maplHkGTf4ZZC6szVIp8wya/DPIXFibpVLmGTT5Z5C5sDZLpcwzaPLPIHNhbZZKmWfQ5J9B5sLaLJUyz6DJP4PMhbVZKmWeQZN/BpkLa7NUyjyDJv8MMhfWZqmUeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZNPlnkLmwNkulzDNo8s8gc2FtlkqZZ9Dkn0HmwtoslTLPoMk/g8yFtVkqZZ5Bk38GmQtrs1TKPIMm/wwyF9ZmqZR5Bk3+GWQurM1SKfMMmvwzyFxYm6VS5hmccv8lEm8L+OknBLAOc2Hhh62UeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZNPlnkLmwNkulzDNo8s8gc2FtlkqZZ9Dkn0HmwtoslTLPoMk/g8yFtVkqZZ5Bk38GmQtrs1TKPIMm/wwyF9ZmqZR5Bk3+GWQurM1SKfMMmvwzyFxYm6VS5hk0+WeQubb1Xj4nzD6OcJLjf/3Gbqr+gwdzYW2qSpln0OSfQebC2iyVMs+gyT+DzIW1WSplnkGTfwaZC2uzVMo8gyb/DDIX1maplHkGTf4ZZC6szVIp8wya/DPIXFibpVLmGTT5Z5C5sDZLpcwzaPLPIHNhbZZKmWfQ5J9B5sLaLJUyz6DJP4PMhbVZKmWeQZN/BpkLa7NUyjyDJv8MMhfWZqmUeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZNPlnkLmwNkulzDNo8s8gc2FtlkqZZ9Dkn0HmwtoslTLPoMk/g8yFtVkqZZ5Bk38GmQtrs1TKPIMm/wwyF3bMUj8hQNOaAu6BWqHFW1BQQPewyfzsvtaV+wt4oHr9kYGVF0uOoEDnf6SJF8v4WSqzs+urmIfoA7WGLN6CggKd/85/19+ogdwRFZetl5uq0j7YI4u3oKCA1k2m1/dceDoDP0QfqKVdvAUFBTr/I1F9/tQ9l9VxV19V7vjbgMVbUFCg66/rr/ffqIHcERXfO9CVvf9WBh5SkrwFBQWU92T+uPx/+zb+ZMBYYc7NI36RlKuBsFPnmHFpH6IP1NIv3oKCAlormV7fc5F5Bz1EH6jO/8jAyoslR1Cg62+kqe8/a8/J6mDPuX2IPlBrxOItKCjwu+tvviHAnyd90stcKKfzL7Trf+XFkiMooNQl857OSK4rd7ofqBVZvAUFBXr9kSiv65m3zM7K4nF5iD5Qa9DiLSgooLWS6fU9F0fyh/sQfaA6/6TKkiMooGwm85hhexpcuekHqvPf+Y/isuIQFOj6G2XS50/tOVkdu79sM94QMG47x+cE8ckoT0I47BwLxtZp3XOFYzTjxYxev/M/d+x4PFfI+4Z+0sdMXF3hOONdf73/u//FfnjeIb3/3m4onvJFZ7kz+qTu86/7b/ff7r93t6CP0DWwkwdj0d7WFY5Rdv/p/tP95+/af+JflXJ3Ens6/2Xp9H3PO+79v7PVrz/06y/9+ku//rLawXOH/Gt+/l29fB5E+0++0Mf5mrDzCwVjo5c9XV3hGG3f//X9X9///V3v/552NDs7rCsco+r93/u/93/v/7tbZIf4a+5/5nrPHarX5yf8fZuuPD3li+ctrCsco6r93z4hYIuX8YHOz0k8xqS/32r0AOXvFTHvEkiV64kS+P2LmlKjB+j1Y6NFenZmllGWOv+lLmemPDeRuX/nqtEDdP11/dHgVVerQFQlWW+iBP6dspNWowfo+uv66/pja+ydsYx2Se8/zjulRIDE/VtWowfo/tP9p/sP22fvjGW0S7r/dP8ZNTB2iUpCYBWO/6vSqKTxeQG//Qj4cNXoAbr/dv/t/ssm2TtjGe2SEXR+aj3G2N9vNXqA3n+9/3z/zU978Uf5pBcvnPXv3Vz5+7FP0/XX9ef1l/cZqpJRWBuLEvj9RWdKjR6g66/rr+uPzbF3xjLaJb3/uv+MGhi7RCUhQOH8W1ajB+j+2/337L/2hoBaVyoc6KOA5ptY67tqbARw2fEOhFHQufCcEAGT3/ZSDMILuNfv/Hf9xb6JvWI7Brhs77/uP91/+/zxM5YG4VzFl2IQff7mDWTff/T9R99/9P3HzED0SuuYwGX7/qvvv/68+6/4hIDoxfsflv5rfOhfHFRdfyMPvf96//15+6/7f59/cdzHdd0RAf/N/subu2bznl2LTwhgzv75K461tedGbvv+e1VG33+ONMwdo+oA/pv7L7LpOTVmzNX7TxleH2LS+89rhaIbHLDrbxRM33/3/Xfff/9dfv+gNwRc29Zf8bZzEXjpCSxbOmJGLhpi9tBj2/T6o5nWMspEPuTLg/VEygjpxkr3MF/nv/Pf9Zd750BXvypxNhh2B3Gxvf9GYqLHXfns/tP9p/tP6SruXPvFg+orajQRxcVK1+f/lc/uP91/uv+UruLOtV88qL6iRtP9Z2aAdGBFfN5/eUOApz8+IWDeV2mhCONiLX49n93/uv91//NtVfC1X45o/Fyjjdb7b2aAdGBFfN7/StrlsAB2B3Cxv9j63/mEgN26yxsC9L0F6Po7Xi8u+eEJxv49nv/ya5M+f/v87fO37Gp3uv91/yv90otD53r3/7gP7fNvZYBywKpO+v6Tfvpt/GuC2VnKQ/ka7Lwp5UUH58uAqRv/l2kO4nDX8MU9BJzq9Tv/XX+xs3xf9P6rGbhycxCH2/1nZGDl5CExTnX/7f7b/bf772yY3hdWA7XLFTuIw10jF/cQcKr7T/ef7j/df2bD8L5grSd7iZOH+HBzzEPAqV+9/7A35jc0q2R+7fNrPpPl39PUzsfiHgJO/erff3wn17d7Ef49lTEPAaf6++/zhz3mdUENYa/YQRzuGra4h4BTXX//O/VHnammRh/v5/9/5/nX8z5A3PGNY6xff+/fP+w3Bvi5QK1gr9hBHO4atriHgFNdf91/OJe8Lqg77BU7iMPt+hsZWDl5SIxTvf96//2V+0+fEBAb20txMu47DnUJb4oxoR5X/5wdNPMFi8d3v51ruO+4118ZeEhJ5z+SomvXX/500fsvMtD9p/tvnz90A7PngeK+4z3kgerzJ5Kia58/ff7w6h47rc+fPn/6/GE3mD0PFPcd9/mzMjBS8u17Npf5L2bmO/3ni0iRrXHt86fPnyyR2Dh9/vT50+ePnTvA84xx3/HWP1D/yc8/vPCbffzHWIjN+7DYA/WfrM9YslH9h8UeKMZEaFz7/MmnkMR2/+3+2/2X3WD2bCjuO95DHqjuP5EUXbv/dv/lFoKd1udPnz8v5896Q4C/CyUa6qycXUWrs6i9rJKivpKtDHUnO4XzJYrHL2JERoFyM9zrr2SNfHX+V/2sIluX9SLX5Gq1RWxp98tgge26UjouXX+WlIS9/7r/dP/1rjL3RkChWnkAAEAASURBVPff1SFWe40eu9poZiZ/6UCuuv9adlb24rISNy59/lhSEvb50+dPnz99/lizHLDP35WPdfSuy+PPP/83zpR1vOyMTTz7aXksd1z6/Clpwenzp8+fPn/6/Il+QO/868+fb+tPBsw+vb+SHwPPL2f8HeZJzut8+DNV/nZ6iEPk1zVwXLr/e1aEu/93/+/+711lbg2a0ITdf2Y+uv9Gy/RK6fMn9kZkxnEw67oKZ1z6/LWkJOzz99c5f+MTAlYdRzELzueLnZ/P3Sua4+ZjDSlO8H69wlp0t5dL4KOfcRlSnFt/hSdhh96Cc1h//3fyXpiS0+LcA65w57/rr/ffajjaCnPbdP+5m8cLU3pKce4BV1hJ7/NHqZhp6/q7i+eFKTVVnHvAFVbSu/6Uipm2rr+7eF6YUlPFuQdcYSW960+pmGnr+ruL54UpNVWce8AVVtK7/pSKmbbfUX/zl0hTFp8JELkefwYwwMv4zv+RHiW960+pmCl6qZ/IXr2WmipO1U3vCmvRzr9SMRPV+Z9Z+F2PUlPFuYdfYSX9v1t/8YaA6Obzq77e2HV/K2LK91QcSQSu8C/y/c+C15cyv9qufz1nPwPlOS3OPfIKK+mdf6Vipq3r7y6eF6bUVHHuAVdYSe/6Uypm2rr+7uJ5YUpNFececIWV9K4/pWKmrevvLp4XptRUce4BV1hJ/+/X37cf466zPu/rq9vfhX3pm/boFIX/EiQXI/zb+IXf/CiseDDLfBkj2Rqb3tTNxxj3skTQL8EYvMb2+p7pna+RVGcjXcSmN/F8dP67/koZrKqYl6iWXTNeOlKEqPef7zQS1fvPsxIlQ26mN/F8dP/p/lPKYFXFvES17Jrx0pEiRN1/fKeRqO4/npUoGXIzvYnno/tP959SBqsq5iWqZdeMl44UIer+4zuNRHX/8axEyZCb6U08H+/9J/9lWyjn9fpF0pim688zTY67/jwrUUHkZlVSUF/UX6j3GB+6Ry4z+K4/zzSJ6vrzrETJkJvpTTwf7/0v1HuMD42BcR3836H+Vi8f3yrf9m+/zT8ZMB//G99/fK/+JE48H/397xtNTKRlXCNbO2eeOilC9Heo//iS/ZuYeD76+eeJ9+zMzIS/2TM4BfMx+H7+/aQhUX3+elZULHO/rcfM03z0/uv9V8pgVcW8xE7a+4ltpegGg+/+4zuNRP16/Wd8QsD85wT2zgR6gT2pfPlG/VuwjJ/OfGidiK5rEYZsXl/oFPwElfHTmY9eP/LgW7okaoeHeaFT8BNUxnf+I1tdf7tqojrWtRRKFtULnYKfoDJ+OvPR+Y889P5fxbBqpBTKTs8wL3QKfoLK+OnMR9df5KHrbxXDqpFSKDs9w7zQKfgJKuOnMx9df5GHrr9VDKtGSqHs9AzzQqfgJ6iMn858dP1FHrr+VjGsGimFstMzzAudgp+gMn468/EPqb9v38c3Mr6n+e3wrZ1vCPgnf//rufzJpb//o9xnvv4h9f+Tp36F+/k/nu5+/o+E/Bqvf34fHymcfXx8TfsNAaV+f0/BH5oyfjrz0fs/8tD3X6sYVo2UQtnpGeaFTsFPUBk/nfno+os8dP2tYlg1Ugplp2eYFzoFP0Fl/HTmo+sv8tD1t4ph1UgplJ2eYV7oFPwElfHTmY+uv8hD198qhlUjpVB2eoZ5oVPwE1TGT2c+Xuov/mTAFJRRk7DH/JuE8+9fDDM/TkBzmeQN5rRP74awUSk0csNev/Pf9df7r/tP998+f/r8ve8QXpm8rej7D3+P6pWwTNQVGq9M9v1H33/0/Ufff/T9xy92/5GfEDB/Kp9NfFxnv96PieLn9T7/+vw7P42RKhk2C8XIDfv87/ufvv/50+9/1pu7bPepj/f+6/3X++9P33+vL6z0/uv91/uv99+4R+7ff/LzpN2ofAHzx4r++fPv8PPnw58M8B8CJ46XE87nPJ/oMzL8GeTxOHyPHuZ1g61DeE7yOMGXP7/2+iT/LX2d/1VXXX+9/0Z7eeww3X92Yh6z0/33rbXO1jvbK4/H9HX/7f47CqPPnz5/Rhk8t4hRHCvwGO3+O/rrc2ZGoPsvp89Lkvr8WYn5B/TffENAPuXrQ/9wHzdJP///lOefp7nY7n+Zjq7/zIVQ7/9fcf+fn/YSnxDwWMB9/zdq+TkzI9D9Tzv9OUm9/3/F/Z9P2qzh8RytAn+u8v0MliFyuv6Viq7/TEWi3v+9/0dfGWXQv399uY/4H+2/+pMBq1k8nDKVykayGm0NZr/Zt6uEsRIUwhyDaCu1PUgsYtkIEMYe4e1a1CDaSm0PEotYNgKEsUd4uxY1iLZS24PEIpaNAGHsEd6uRQ2irdT2ILGIZSNAGHuEt2tRg2grtT1ILGLZCBDGHuHtWtQg2kptDxKLWDYChLFHeLsWNYi2UtuDxCKWjQBh7BHerkUNoq3U9iCxiGUjQBh7hLdrUYNoK7U9SCxi2QgQxh7h7VrUINpKbQ8Si1g2AoSxR3i7FjWItlLbg8Qilo0AYewR3q5FDaKt1PYgsYhlI0AYe4S3a1GDaCu1PUgsYtkIEMYe4e1a1CDaSm0PEotYNgKEsUd4uxY1iLZS24PEIpaNAGHsEd6uRQ2irdT2ILGIZSNAGHuEt2tRg2grtT1ILGLZCBDGHuHtWtQg2kptDxKLWDYChLFHeLsWNYi2UtuDxCKWjQBh7BHerkUNoq3U9iCxiGUjQBh7hLdrUYNoK7U9SCxi2QgQxh7h7VrUINpKbQ8Si1g2AoSxR3i7FjWItlLbg8Qilo0AYewR3q5FDaKt1PYgsYhlI0AYe4S3a1GDaCu1PUgsYtkIEMYe4e1a1CDaSm0PEotYNgKEsUd4uxY1iLZS24PEIpaNAGHsEd6uRQ2irdT2ILGIZSNAGHuEt2tRg2grtT1ILGLZCBDGHuHtWtQg2kptDxKLWDYChLFHeLsWNYi2UtuDHPb8V6VzHL9IMll9XZTAWsQcg793/TpxHcV0WKL1t1kWNYi2UtuDxCKWjQBh7BHerkUNoq3U9iCxiGUjQBh7hLdrUYNoK7U9SCxi2QgQxh7h7VrUINpKbQ8Si1g2AoSxR3i7FjWItlLbg8Qilo0AYewR3q5FDaKt1PYgsYhlI0AYe4S3a1GDaCu1PUgsYtkIEMYe4e1a1CDaSm0PEotYNgKEsUd4uxY1iLZS24PEIpaNAGHsEd6uRQ2irdT2ILGIZSNAGHuEt5vR+uau+JMBGZ3y7UFiNTEgAoSxRJkmfIsaRFup7UFiEctGgDD2CG/XogbRVmp7kFjEshEgjD3C27WoQbSV2h4kFrFsBAhjj/B2LWoQbaW2B4lFLBsBwtgjvF2LGkRbqe1BYhHLRoAw9ghv16IG0VZqe5BYxLIRIIw9wtu1qEG0ldoeJBaxbAQIY4/wdi1qEG2ltgeJRSwbAcLYI7xdixpEW6ntQWIRy0aAMPYIb9eiBtFWanuQWMSyESCMPcLbtahBtJXaHiQWsWwECGOP8HYtahBtpbYHiUUsGwHC2CO8XYsaRFup7UFiEctGgDD2CG/XogbRVmp7kFjEshEgjD3C27WoQbSV2h4kFrFsBAhjj/B2LWoQbaW2B4lFLBsBwtgjvF2LGkRbqe1BYhHLRoAw9ghv16IG0VZqe5BYxLIRIIw9wtu1qEG0ldoeJBaxbAQIY4/wdi1qEG2ltgeJRSwbAcLYI7xdiw6YnxAAj9XoG4TkXXhHTiZ9IQD2XlZMSN6Fd+Rk0hcCYLXaDULyLrwjJ5O+EAB7LysmJO/CO3Iy6QsBsFrtBiF5F96Rk0lfCIC9lxUTknfhHTmZ9IUAWK12g5C8C+/IyaQvBMDey4oJybvwjpxM+kIArFa7QUjehXfkZNIXAmDvZcWE5F14R04mfSEAVqvdICTvwjtyMukLAbD3smJC8i68IyeTvhAAq9VuEJJ34R05mfSFANh7WTEheRfekZNJXwiA1Wo3CMm78I6cTPpCAOy9rJiQvAvvyMmkLwTAarUbhORdeEdOJn0hAPZeVkxI3oV35GTSFwJgtdoNQvIuvCMnk74QAHsvKyYk78I7cjLpCwGwWu0GIXkX3pGTSV8IgL2XFROSd+EdOZn0hQBYrXaDkLwL78jJpC8EwN7LignJu/COnEz6QgCsVrtBSN6Fd+Rk0hcCYO9lxYTkXXhHTiZ9IQBWq90gJO/CO3Iy6QsBsPeyYkLyLrwjJ5O+EACr1W4QknfhHTmZ9IUA2HtZMSF5F96Rk0lfCIDVajcIybvwjpxM+kIA7L2smJDE9fu37+P3OxPn48f41w3135Wdk6YvBMDmdBcKybvwjpxM+kIA7LVqEiF5F96Rk0lfCIDN5S4UknfhHTmZ9IUA2GvVJELyLrwjJ5O+EACby10oJO/CO3Iy6QsBsNeqSYTkXXhHTiZ9IQA2l7tQSN6Fd+Rk0hcCYK9VkwjJu/COnEz6QgBsLnehkLwL78jJpC8EwF6rJhGSd+EdOZn0hQDYXO5CIXkX3pGTSV9ogG//F/9qjwX1JwMgto0xGnlE9bYB409t+kIArI0+YUjehXfkZNIXAmDPRc0PybvwjpxM+kIArK13wpC8C+/IyaQvBMCei5ofknfhHTmZ9IUAWFvvhCF5F96Rk0lfCIA9FzU/JO/CO3Iy6QsBsLbeCUPyLrwjJ5O+EAB7Lmp+SN6Fd+Rk0hcCYG29E4bkXXhHTiZ9IQD2XNT8kLwL78jJpC8EwNp6JwzJu/COnEz6QgDsuaj5IXkX3pGTSV8IgLX1ThiSd+EdOZn0hQDYc1HzQ/IuvCMnk74QAGvrnTAk78I7cjLpCwGw56Lmh+RdeEdOJn0hANbWO2FI3oV35GTSFwJgz0XND8m78I6cTPpCAKytd8KQvAvvyMmkLwTAnouaH5J34R05mfSFNhifEDA/G8EfSKDnSwsD89kShIO1Fx4IYH3OxIouIC8FevvqjM1Hr9/5H7XQ9aetwKaruwcPG7vnvCq6gDyTwU07H73/ev+NWuj9p63Q+y86A52iepWNWF4VXUBeCvr8H7nYPXdlpftv99+xT7r/5raYW2I8avfAw4bmvCq6gDyTwU07H73/ev+NWvhF9998Q8C/vs2vL6p1Xq8f6TOUe2bq5zhuZqSBY8Ku/67/UQu/aP3vo2BUr9dtsirrDVCFXJ7J4Kadj67/rv9RC39B/c9PCNjVtiqPT3rp/P81+V9JL32k93/3v+7/3X+6//wV51/335mBed/pdwHdf7r//HX959v4e4PjnxNQhLEln67PClhsHTlfmIiPwZr/hiFudpdiyLm/fv/B7JhruHNr1AfrYo9or9/5Hz9kzYbS9df7T/2j+0/331EMqx7W0fF8fvhp8qyAxfqI0XX6/Onzp8+fPn/7/qPvv/rnn/z5bRyX/fPfH3P/8W2+IYDH/IXSuOeYP9LPR99/9OsP/fpL//zfr3/8PV7/WXt1leuu2d3HVy8fl/Xz6nT04OdOrAILdP/v/t/9v/t/9/+/R/+v3bt6Lx1+iKK+H0+Hfv2xX3/s1x/HHun9/3t//7k+IaA0GzkCtTM9eCjn/eusP6ykCERUUMJyBKr4wUPJulhJEYiooITlCFTxg4eSdbGSIhBRQQnLEajiBw8l62IlRSCighKWI1DFDx5K1sVKikBEBSUsR6CKHzyUrIuVFIGICkpYjkAVP3goWRcrKQIRFZSwHIEqfvBQsi5WUgQiKihhOQJV/OChZF2spAhEVFDCcgSq+MFDybpYSRGIqKCE5QhU8YOHknWxkiIQUUEJyxGo4gcPJetiJUUgooISliNQxQ8eStbFSopARAUlLEegih88lKyLlRSBiApKWI5AFT94KFkXKykCERWUsByBKn7wULIuVlIEIiooYTkCVfzgoWRdrKQIRFRQwnIEqvjBQ8m6WEkRiKighOUIVPGDh5J1sZIiEFFBCcsRqOIHDyXrYiVFIKKCEpYjUMUPHkrWxUqKQEQFJSxHoIofPJSsi5UUgYgKSliOQBU/eChZFyspAhEVlLAcgSp+8FCyLlZSBCIqKGE5AlX84KFkXaykCERUUMJyBKr4wUPJulhJEYiooITlCFTxg4eSdbGSIhBRQQnLEajiBw8l62IlRSCighKWI1DFDx5K1sVKikBEBSUsR6CKHzyUrIuVFIGICkpYjkAVP3goWRcrKQIRFZSwHIEqPrz1hgB9QkC8OPjjx/xFiAl/MlUJyxGwiZ4hSr5vrNQIRFRQwnIEqvjBQ8m6WEkRiKighOUIVPGDh5J1sZIiEFFBCcsRqOIHDyXrYiVFIKKCEpYjUMUPHkrWxUqKQEQFJSxHoIofPJSsi5UUgYgKSliOQBU/eChZFyspAhEVlLAcgSp+8FCyLlZSBCIqKGE5AlX84KFkXaykCERUUMJyBKr4wUPJulhJEYiooITlCFTxg4eSdbGSIhBRAeH45W3+imf+Qv/3PBjPuliNRSCighKWI1DFDx5K1sVKikBEBSUsR6CKHzyUrIuVFIGICkpYjkAVP3goWRcrKQIRFZSwHIEqfvBQsi5WUgQiKihhOQJV/OChZF2spAhEVFDCcgSq+MFDybpYSRGIqKCE5QhU8YOHknWxkiIQUUEJyxGo4gcPJetiJUUgooISliNQxQ8eStbFSopARAUlLEegih88lKyLlRSBiApKWI5AFT94KFkXKykCERWUsByBKn7wULIuVlIEIiooYTkCVfzgoWRdrKQIRFRQwnIEqvjBQ8m6WEkRiKighOUIVPGDh5J1sZIiEFFBCcsRqOIHDyXrYiVFIKKCEpYjUMUPHkrWxUqKQEQFJSxHoIofPJSsi5UUgYgKSliOQBU/eChZFyspAhEVlLAcgSp+8FCyLlZSBCIq8PD1JwMi6JL5/op5k7q5a7U6+e3lXAuNi/51yC2ua+14zLDn6fXjXRcPuXumdt5GcKFx6fzHD11P+YpsZc6mpnBdf11/5dXWpypyLmtpoXHp/df7z1+vv6sla2bGwttc95/uP91/fMv8BOdeWmhcuv92/+3++7xtYrfknpmqwvX580udP/wSaf5DId4XUH+RlM/lQuPS/a/7X/e/7n9PGSi9fgsK1/3/T+v/376PT3uZ+V2P8Yrrbz8W6vzPfh1ZuP+12U7Xq9njRnyhcenzr8+/Pv+eN0zsltwzU1W47v9/Wv+/cr2fos5/9/8+/3ZP6v7zp/af4w0BdhAICqz25B7PzeI8sBtZmi+DKeOmbzIaIrB07vX6URsrJ54Yy2jAL4OmNp2gQOd/ZMCz0fXX9bc+EWXUxdd/dcWrxrbbBU0nKLDU7nX9df11/e2e7Bvjq311xZywSQQFev+NDHg2uv90/+n+0/1n9QRvDN5Sr655BY2wSQQFrpm6//zrX9+/z5e25/8jT9vUNwTMtNUcTub5YTpBgTXEvc5/9//u/93/V0/wxnA1ly+DpjadoMA/vv98H5tpfrc8oo//73z/5ZzSty2w0uJenz99/vT50+fP6gneGGigsl8Gper+Y3kSFOj+OzLg2ejzp8+ff9r5c7wh4Cj4sQHe3kmH0jeIddYLhi7VC6UrvVOOJRCI6NcaifdGTvVC6UrolGMJBCL6tUbiXn+kQu9yGnjl7SF5TjnOTIIi+rUG7V2ta9zDYKcc50ygiH6tQdvrn9la/kPynHKcmQRF9GsN2s7/ma3lPyTPKceZSVBEv9ag7fyf2Vr+Q/KccpyZBEX0aw3azv+ZreU/JM8px5lJUES/1qDt/J/ZWv5D8pxynJkERfRrDdrO/5mt5T8kzynHmUlQRL/WoO38n9la/kPynHKcmQRF9GsN2s7/ma3lPyTPKceZSVBEv9ag/fPy758QsH6oGkvebwj489b/b3//vf5Xr9H8+fXX+e/8v79G2PVHBmKf5G5ZKN0lO3v5j/Ebh/fcnjOy0rM91U/rz5H+JTm+Zz1nvBXOnOrlPyzglGOfK3BEv9bkqFO9/IfBTjnOmUAR/VqDlrymeqF0JXTKsQQCEf1aI3G//jxS0a8/Z7UslK4KxSnHEghE9GuNxF1/IxVdf1ktC6WrQnHKsQQCEf1aI3HX30hF119Wy0LpqlCcciyBQES/1kj8t6k/vSHg/Rv7bXwz30ox7e9ufLdvo974mSBi2Eha9YIj0ut3/r2ZqYQSeMEM/F5NGaua6vl0Xf+9/3r/9f6zDiEo4A2j+0/331EDby/lUTPYKJ3qeTn1+dPnT58/ff5YhxAU8IYx8Bs/ZcSwMbR6wRHp/ffr7r/v42Omf5ufgbye1/mMjZ3y2/9bdnr3g2caG4rq+ag+f7r+f936f77Peq/m7n/kBtv7f2agZuO/0/++fxt/MmB8JXRzPiGg+0/3n77/tR0qKOAb9svdnDu9jq2eT9f3P91/uv90/7EOISjgDaP7zxd3U91/qRlslE71vJz+2vNnvCHgx/ha7MVrfWUC/tUVXBV84VtSgsPZf7iJj9nIiYow6+XLoorRdWSvHwd3539loBRH11/vv9Hjxn/df0YarN1bwz2aatlAu6lUUxXdf7v/zh+c9qMUR/ff7r/df/v86fO37z/6/uOPvP+aHzNdH/MNAeNvT/f5ay9r9P1H33/0/Ufff/za9x/6hIDZ0Ee5rpdma3MvXmnxo+H3z5/986fuBkpx9PnX51+ff33+/drn3zrc1LcEypnnTlX0+dfnf5///+n5r08IOF5BsNvLY6O970hF6kbNmYP3q4YMUEflqolcvXAdovBJ44f1q4YMgCq4XDWRqxeuQxQ+afywftWQAVAFl6smcvXCdYjCJ40f1q8aMgCq4HLVRK5euA5R+KTxw/pVQwZAFVyumsjVC9chCp80fli/asgAqILLVRO5euE6ROGTxg/rVw0ZAFVwuWoiVy9chyh80vhh/aohA6AKLldN5OqF6xCFTxo/rF81ZABUweWqiVy9cB2i8Enjh/WrhgyAKrhcNZGrF65DFD5p/LB+1ZABUAWXqyZy9cJ1iMInjR/WrxoyAKrgctVErl64DlH4pPHD+lVDBkAVXK6ayNUL1yEKnzR+WL9qyACogstVE7l64TpE4ZPGD+tXDRkAVXC5aiJXL1yHKHzS+GH9qiEDoAouV03k6oXrEIVPGj+sXzVkAFTB5aqJXL1wHaLwSeOH9auGDIAquFw1kasXrkMUPmn8sH7VkAFQBZerJnL1wnWIwieNH9avGjIAquBy1USuXrgOUfik8cP6VUMGQBVcrprI1QvXIQqfNH5Yv2rIAKiCy1UTuXrhOkThk8YP61cNGQBVcLlqIlcvXIcofNL4Yf2qIQOgCi5XTeTqhesQhU8aP6xfNWQAVMHlqolcvXAdovBJ44f1q4YMgCq4XDWRqxeuQxQ+afywftWQAVAFl6smcvXCdYjCJ40f1q8aMgCq4HLVRK5euA5R+KTxw/pVQwZAFVyumsjVC9chCp80fli/asgAqILLVRO5euE6ROGTxg/rVw0ZAFVwuWoiVy88hnz7Pl8CmP/Pl4NilvOjppnZV4Zb86xLZXLVRKndqA5R+KTxw/pVQwZAFVyumsjVC9chCp80fli/asgAqILLVRO5euE6ROGTxg/rVw0ZAFVwuWoiVy9chyh80vhh/aohA6AKLldN5OqF6xCFTxo/rF81ZABUweWqiVy9cB2i8Enjh/WrhgyAKrhcNZGrF65DFD5p/LB+1ZABUAWXqyZy9cJ1iMInjR/WrxoyAKrgctVErl64DlH4pPHD+lVDBkAVXK6ayNUL1yEKnzR+WL9qyACogstVE7l64TpE4ZPGD+tXDRlg9O/1CQHJ1U8ISF6IiUUEOGl8Xxkuh1Ymv+tEqd2oDlH4pPHD+lVDBkAVXK6ayNUL1yEKnzR+WL9qyACogstVE7l64TpE4ZPGD+tXDRkAVXC5aiJXL1yHKHzS+GH9qiEDoAouV03k6oXrEIVPGj+sXzVkAFTB5aqJXL1wHaLwSeOH9auGDIAquFw1kasXrkMUPmn8sH7VkAFQBZerJnL1wnWIwieNH9avGjIAquBy1USuXrgOUfik8cP6VUMGQBVcrprI1QvXIQqfNH5Yv2rIAKiCy1UTuXrhOkThk8YP61cNGQBVcLlqIlcvXIcofNL4Yf2qIQOgCi5XTeTqhesQhU8aP6xfNWQAVMHlqolcvXAdovBJ44f1q4YMgCq4XDWRqxeuQxQ+afywftWQAVAFl6smcvXCdYjCJ40f1q8aMgCq4HLVRK5euA5R+KTxw/pVQwZAFVyumsjVC9chCp80fli/asgAqILLVRO5euE6ROGTxg/rVw0ZAFVwuWoiVy9chyh80vhh/aohAwS/3hDAv1opSzOLpDaRxdZEyx8vRxR+LjaI/ckA03t79PrjJZ2VPnuPj+UyoF0t1vkfyVj56Prr/Tc6zHxVVI9ZG4MonIIC3X+6/3T/nW20zx+9x9TO2IB2tVifvyMZKx99/vb5O47UctbO2ujzt+ZEtx0Cff/R9x+f3n+Uf1W6Kyp+kTSd3n/df7r/dv/VUfMI+vz5Nc4fevk6C2brnk/MeMwrH9m8cBArFj1+Cvr+u++/V6HsuphmFErff8/N8+Wj+x/to1//6dd/9maxMyagXS3W589IxspHn799/o5jppw1szYGUbj7KPqlzp9x0znL+X6sInfaif2rA6cktV8rKC6wN4/5GneAS+JEr7+Obk+J0tf5122N8iPQ9bdSYflQ3RzgkjjR+6/337h19pJQ+XT/6f6zf6xSfQh0/12psHxo3xzgkjjR/bf7b/ffPn9Gz7h+2Ozz93/p/P32f1YA44iY3v8bP9IvVkeGQJ+/KxWWj+PYlXtJnOjzt8/fPn/7/P1jz9/5519ml4kuPnpMeWm2+0/e7HT/7f7b/bf77x/bf1fr5eLtdnFOdP/p/tP9p/vPP6//XH8yoLa9fQvm5NkcVywE8zof+RJFDgRhQ+nXiHhcWAC9EQuGP6/z0etHHvarP8shY1gUaTOH5E9aAdRGLBj+vM4H43v9zBMIG5nya0Q8LiyA3ogFw5/X+ej8Rx66/rJOQFgylDYiHhcWQG3EguHP63x0/UUeuv6yTkBYMpQ2Ih4XFkBtxILhz+t8dP1FHrr+sk5AWDKUNiIeFxZAbcSC4c/rfHT9RR66/rJOQFgylDYiHhcWQG3EguHP63x0/UUe/hfqT/+qdHzLPP/5i6Soi5kNEJYMpY2Ix4UFUBuxYPjzOh9df5GHzHoiyxyibTOH5E9aAYYYsWD48zofjM9VE9nIEOuaczBeWgHERiwY/rzOB+Nz1UQ2MsS65hyMl1YAsRELhj+v88H4XDWRjQyxrjkH46UVQGzEguHP63wwPldNZCNDrGvOwXhpBRAbsWD48zofjM9VE9nIEOuaczBeWgHERiwY/rzOB+Nz1UQ2MsS65hyMl1YAsRELhj+v88H4XDWRjQyxrjkH46UVQGzEguHP63wwPldNZCNDrOv4Fcv370s4x89/WPbjx/y1y3TG/zlpJVYsBPM6HynNgSBsKP0aEY8LC6A3YsHw53U+ev3Igz9xZAyLIm3mkPxJK4DaiAXDn9f5YHyvn3kCYSNTfo2Ix4UF0BuxYPjzOh+d/8hD11/WCQhLhtJGxOPCAqiNWDD8eZ2Prr/IQ9df1gkIS4bSRsTjwgKojVgw/Hmdj66/yMPfsf7iTwbwJNrzvL4lPstgOAoJ8E1ve/KPPuS21dgizDkE86OwxoORCbYGI8EmHn3IbauxRZhjCHr9lQwy1/kf6ciOtwtlGCVoU48+5LbVPMwxBF1/K6Fk7sozz4AEnf+aMM8HSdq2mq4/0qOaGkTvv1pOZ46UqwG8L5665UNuW03XH+lRTgfR9df1NzKg0hCgSLY9+UcfcttqbBHmHIKuv5UMMpdPROe/ZEAJonaGvc4DRNtW0/VHekjs7/j5mzcEzGTPdM9/u7TeEHDNNZ8PyJp42Ku2f8f6fKn32Lmeovu5ZaVefyWnpqHrn/KgbLr+RpnEJlJqBEjStif/6ENuW03XH+khtX9x/WUvjy/gtx8/+vnv+l/FoNIUoEi3PflHH3Lbanr/kx5S+xfv//seanxBXf9d/yMDKk0BinTbk3/0IbetxhZhziHo+lvJIHP5RHT+SwaUIGpn2P75L1O08kOStq3ml9h/+QkBdvjld5FfI9+Kx8AZS0QMuyJX2IheX82XnE1LhrAeA2csETHsilxhIzr/nf99+FMz01IhWI+BM5aIGHZFrrARXX9df11/bBdZdghWAQMZS2ThBVfkChvR+6/3X++/c9v0+TcyEr9oDHslaBDZRRKduhW5wkZ0/+n+0/3n3DbaW7ZTiub8JdIM5icEpLT339heVxKN6P7T/af7TzaMjdgh2EswiIwlOnUrcoWN6P23PiGAe62Zv9nHyRD2zOvSjcvxtpFLtsZfkxjR+e/+1/3ved8M1nbKq+YrVe+/vv/q+8+xdfyXxL6r+vzp86fPn9ez5a86f/INAf6lnKufvrR34GYkTjBEv43uGP+mIWmhc5LTfxV+dSRr0BL1+p3/rr9yOucGOffb6Ut5B25G4gRD1Puv91/vv95/2RQMnU3k9CW9AzcjcYIh6v7T/af7T/efbAqGziZy+pLegZuROMEQdf/p/vNH9J/5MdPfxudL779quuzTGwKy+Abq+uv916+/9OtP9dX5bBHnIXb6Ut6Bm5E4wRD1+Xeff/HmrnlPNhI0zG/jTwasx2tS78DNZNqFhqjzf+ff81O2xmtS78DNaNYEnf+uvz5/+/wtTSbbw2z/JXT6kt6Bm5E4wRB1/+/+/0f8/FkLdd25lNLNojPU9ffL7r/6hoD1RNlT/PKuHT211n0CGjFFuMvOy6RGGW6e8ApEcCSq19fLtJ3/UQzKhspEwAoooBG7nlZ3WvS8dP31/uv+0/13NIL5gkuY2RbiMYg+f/r81YnT52+fv33/QXe8rTXQgEZMNe6y89L3X33/1fdff+T917fv87Sa/8f+mujHPLfmY+07bO+/SEnX3x9Zf6v0KDEV3Mz0eHT95dZcSe/zr8+/9/5zftqL/8mA2FDHlf2lrWbElOIuOy9df11/7/U366Vf/+jXP/r1j9Uqx2YYG6J//t/JeDDrXAk+oBGTxl12Xvr86fOnz59f+eeveEMAG3dt2bhUyjyDJv8MMhfWZqmUeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZNPlnkLmwNkulzDNo8s8gc2FtlkqZZ9Dkn0HmwtoslTLPoMk/g8yFtVkqZZ5Bk38GmQtrs1TKPIMm/wwyF9ZmqZR5Bk3+GWQurM1SKfMMmvwzyFxYm6VS5hk0+WeQubA2S6XMM2jyzyBzYW2WSpln0OSfQebC2iyVMs+gyT+DzIW1WSplnkGTfwaZC2uzVMo8gyb/DDIX1maplHkGTf4ZZC6szVIp8wya/DPIXFibpVLmGTT5Z5C5sDZLpcwzaPLPIHNhbZZKmWfQ5J9B5sLaLJUyz6DJP4PMhbVZKmWeQZN/BpkLa7NUyjyDJv8MMhfWZqmUeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZNPlnkLmwNkulzDNo8s8gc2FtlkqZZ9Dkn0HmwtoslTLPoMk/g8yFtVkqZZ7BKfdfIvG2gJ9+QgDrMBcWfthKmWfQ5J9B5sLaLJUyz6DJP4PMhbVZKmWeQZN/BpkLa7NUyjyDJv8MMhfWZqmUeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZNPlnkLmwNkulzDNo8s8gc2FtlkqZZ9Dkn0HmwtoslTLPoMk/g8yFtVkqZZ5Bk38GmWtb7+VzwuzjCCc5/tdv7KbqP3gwF9amqpR5Bk3+GWQurM1SKfMMmvwzyFxYm6VS5hk0+WeQubA2S6XMM2jyzyBzYW2WSpln0OSfQebC2iyVMs+gyT+DzIW1WSplnkGTfwaZC2uzVMo8gyb/DDIX1maplHkGTf4ZZC6szVIp8wya/DPIXFibpVLmGTT5Z5C5sDZLpcwzaPLPIHNhbZZKmWfQ5J9B5sLaLJUyz6DJP4PMhbVZKmWeQZN/BpkLa7NUyjyDJv8MMhfWZqmUeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZNPlnkLmwNkulzDNo8s8gc2HHLPUTAjStKeAeqBVavAUFBXQPm8zP7mtdub+AB6rXHxlYebHkCAp0/keaeLGMn6UyO7u+inmIPlBryOItKCjQ+e/8d/2NGsgdUXHZermpKu2DPbJ4CwoKaN1ken3Phacz8EP0gVraxVtQUKDzPxLV50/dc1kdd/VV5Y6/DVi8BQUFuv66/nr/jRrIHVHxvQNd2ftvZeAhJclbUFBAeU/mj8v/t2/jTwaMFebcPOIXSbkaCDt1jhmX9iH6QC394i0oKKC1kun1PReZd9BD9IHq/I8MrLxYcgQFuv5Gmvr+s/acrA72nNuH6AO1RizegoICv7v+5hsC/HnSJ73MhXI6/0K7/ldeLDmCAkpdMu/pjOS6cqf7gVqRxVtQUKDXH4nyup55y+ysLB6Xh+gDtQYt3oKCAlormV7fc3Ekf7gP0Qeq80+qLDmCAspmMo8ZtqfBlZt+oDr/nf8oLisOQYGuv1Emff7UnpPVsfvLNuMNAeO2c3xOEJ+M8iSEw86xYGyd1j1XOEYzXszo9Tv/c8eOx3OFvG/oJ33MxNUVjjPe9df7v/tf7IfnHdL77+2G4ilfdJY7o0/qPv+6/3b/7f57dwv6CF0DO3kwFu1tXeEYZfef7j/df/6u/Sf+VSl3J7Gn81+WTt/3vOPe/ztb/fpDv/7Sr7/06y+rHTx3yL/m59/Vy+dBtP/kC32crwk7v1AwNnrZ09UVjtH2/V/f//X939/1/u9pR7Ozw7rCMare/73/e//3/r+7RXaIv+b+Z6733KF6fX7C37fpytNTvnjewrrCMara/+0TArZ4GR/o/JzEY0z6+61GD1D+XhHzLoFUuZ4ogd+/qCk1eoBePzZapGdnZhllqfNf6nJmynMTmft3rho9QNdf1x8NXnW1CkRVkvUmSuDfKTtpNXqArr+uv64/tsbeGctol/T+47xTSgRI3L9lNXqA7j/df7r/sH32zlhGu6T7T/efUQNjl6gkBFbh+L8qjUoanxfw24+AD1eNHqD7b/ff7r9skr0zltEuGUHnp9ZjjP39VqMH6P3X+8/33/y0F3+UT3rxwln/3s2Vvx/7NF1/XX9ef3mfoSoZhbWxKIHfX3Sm1OgBuv66/rr+2Bx7ZyyjXdL7r/vPqIGxS1QSAhTOv2U1eoDuv91/z/5rbwiodaXCgT4KaL6Jtb6rxkYAlx3vQBgFnQvPCREw+W0vxSC8gHv9zn/XX+yb2Cu2Y4DL9v7r/tP9t88fP2NpEM5VfCkG0edv3kD2/Ufff/T9R99/zAxEr7SOCVy277/6/uvPu/+KTwiIXrz/Yem/xof+xUHV9Tfy0Puv99+ft/+6//f5F8d9XNcdEfDf7L+8uWs279m1+IQA5uyfv+JYW3tu5Lbvv1dl9P3nSMPcMaoO4L+5/yKbnlNjxly9/5Th9SEmvf+8Vii6wQG7/kbB9P1333/3/fff5fcPekPAtW39FW87F4GXnsCypSNm5KIhZg89tk2vP5ppLaNM5EO+PFhPpIyQbqx0D/N1/jv/XX+5dw509asSZ4NhdxAX2/tvJCZ63JXP7j/df7r/lK7izrVfPKi+okYTUVysdH3+X/ns/tP9p/tP6SruXPvFg+orajTdf2YGSAdWxOf9lzcEePrjEwLmfZUWijAu1uLX89n9r/tf9z/fVgVf++WIxs812mi9/2YGSAdWxOf9r6RdDgtgdwAX+4ut/51PCNitu7whQN9bgK6/4/Xikh+eYOzf4/kvvzbp87fP3z5/y652p/tf97/SL704dK53/4/70D7/VgYoB6zqpO8/6affxr8mmJ2lPJSvwc6bUl50cL4MmLrxf5nmIA53DV/cQ8CpXr/z3/UXO8v3Re+/moErNwdxuN1/RgZWTh4S41T33+6/3X+7/86G6X1hNVC7XLGDONw1cnEPAae6/3T/6f7T/Wc2DO8L1nqylzh5iA83xzwEnPrV+w97Y35Ds0rm1z6/5jNZ/j1N7Xws7iHg1K/+/cd3cn27F+HfUxnzEHCqv/8+f9hjXhfUEPaKHcThrmGLewg41fX3v1N/1JlqavTxfv7/d55/Pe8DxB3fOMb69ff+/cN+Y4CfC9QK9oodxOGuYYt7CDjV9df9h3PJ64K6w16xgzjcrr+RgZWTh8Q41fuv999fuf/0CQGxsb0UJ+O+41CX8KYYE+px9c/ZQTNfsHh899u5hvuOe/2VgYeUdP4jKbp2/eVPF73/IgPdf7r/9vlDNzB7HijuO95DHqg+fyIpuvb50+cPr+6x0/r86fOnzx92g9nzQHHfcZ8/KwMjJd++Z3OZ/2JmvtN/vogU2RrXPn/6/MkSiY3T50+fP33+2LkDPM8Y9x1v/QP1n/z8wwu/2cd/jIXYvA+LPVD/yfqMJRvVf1jsgWJMhMa1z598Ckls99/uv91/2Q1mz4bivuM95IHq/hNJ0bX7b/dfbiHYaX3+9Pnzcv6sNwT4u1Cioc7K2VW0Oovayyop6ivZylB3slM4X6J4/CJGZBQoN8O9/krWyFfnf9XPKrJ1WS9yTa5WW8SWdr8MFtiuK6Xj0vVnSUnY+6/7T/df7ypzb3T/XR1itdfosauNZmbylw7kqvuvZWdlLy4rcePS548lJWGfP33+9PnT5481ywH7/F35WEfvujz+/PN/40xZx8vO2MSzn5bHcselz5+SFpw+f/r86fOnz5/oB/TOv/78+bb+ZMDs0/sr+THw/HLG32Ge5LzOhz9T5W+nhzhEfl0Dx6X7v2dFuPt/9//u/95V5tagCU3Y/Wfmo/tvtEyvlD5/Ym9EZhwHs66rcMalz19LSsI+f3+d8zc+IWDVcRSz4Hy+2Pn53L2iOW4+1pDiBO/XK6xFd3u5BD76GZchxbn1V3gSdugtOIf1938n74UpOS3OPeAKd/67/nr/rYajrTC3Tfefu3m8MKWnFOcecIWV9D5/lIqZtq6/u3hemFJTxbkHXGElvetPqZhp6/q7i+eFKTVVnHvAFVbSu/6Uipm2rr+7eF6YUlPFuQdcYSW960+pmGn7HfU3f4k0ZfGZAJHr8WcAA7yM7/wf6VHSu/6Uipmil/qJ7NVrqaniVN30rrAW7fwrFTNRnf+Zhd/1KDVVnHv4FVbS/7v1F28IiG4+v+rrjV33tyKmfE/FkUTgCv8i3/8seH0p86vt+tdz9jNQntPi3COvsJLe+VcqZtq6/u7ieWFKTRXnHnCFlfSuP6Vipq3r7y6eF6bUVHHuAVdYSe/6Uypm2rr+7uJ5YUpNFececIWV9P9+/X37Me466/O+vrr9XdiXvmmPTlH4L0FyMcK/jV/4zY/CigezzJcxkq2x6U3dfIxxL0sE/RKMwWtsr++Z3vkaSXU20kVsehPPR+e/66+UwaqKeYlq2TXjpSNFiHr/+U4jUb3/PCtRMuRmehPPR/ef7j+lDFZVzEtUy64ZLx0pQtT9x3caier+41mJkiE305t4Prr/dP8pZbCqYl6iWnbNeOlIEaLuP77TSFT3H89KlAy5md7E8/Hef/JftoVyXq9fJI1puv480+S468+zEhVEblYlBfVF/YV6j/Ghe+Qyg+/680yTqK4/z0qUDLmZ3sTz8d7/Qr3H+NAYGNfB/x3qb/Xy8a3ybf/22/yTAfPxv/H9x/fqT+LE89Hf/77RxERaxjWytXPmqZMiRH+H+o8v2b+Jieejn3+eeM/OzEz4mz2DUzAfg+/n308aEtXnr2dFxTL323rMPM1H77/ef6UMVlXMS+ykvZ/YVopuMPjuP77TSNSv13/GJwTMf05g70ygF9iTypdv1L8Fy/jpzIfWiei6FmHI5vWFTsFPUBk/nfno9SMPvqVLonZ4mBc6BT9BZXznP7LV9berJqpjXUuhZFG90Cn4CSrjpzMfnf/IQ+//VQyrRkqh7PQM80Kn4CeojJ/OfHT9RR66/lYxrBophbLTM8wLnYKfoDJ+OvPR9Rd56PpbxbBqpBTKTs8wL3QKfoLK+OnMR9df5KHrbxXDqpFSKDs9w7zQKfgJKuOnMx//kPr79n18I+N7mt8O39r5hoB/8ve/nsufXPr7P8p95usfUv8/eepXuJ//4+nu5/9IyK/x+uf38ZHC2cfH17TfEFDq9/cU/KEp46czH73/Iw99/7WKYdVIKZSdnmFe6BT8BJXx05mPrr/IQ9ffKoZVI6VQdnqGeaFT8BNUxk9nPrr+Ig9df6sYVo2UQtnpGeaFTsFPUBk/nfno+os8dP2tYlg1Ugplp2eYFzoFP0Fl/HTm46X+4k8GTEEZNQl7zL9JOP/+xTDz4wQ0l0neYE779G4IG5VCIzfs9Tv/XX+9/7r/dP/t86fP3/sO4ZXJ24q+//D3qF4Jy0RdofHKZN9/9P1H33/0/Ufff/xi9x/5CQHzp/LZxMd19uv9mCh+Xu/zr8+/89MYqZJhs1CM3LDP/77/6fufP/3+Z725y3af+njvv95/vf/+9P33+sJK77/ef73/ev+Ne+T+/Sc/T9qNyhcwf6zonz//Dj9/PvzJAP8hcOJ4OeF8zvOJPiPDn0Eej8P36GFeN9g6hOckjxN8+fNrr0/y39LX+V911fXX+2+0l8cO0/1nJ+YxO91/31rrbL2zvfJ4TF/33+6/ozD6/OnzZ5TBc4sYxbECj9Huv6O/PmdmBLr/cvq8JKnPn5WYf0D/zTcE5FO+PvQP93GT9PP/T3n+eZqL7f6X6ej6z1wI9f7/Fff/+Wkv8QkBjwXc93+jlp8zMwLd/7TTn5PU+/9X3P/5pM0aHs/RKvDnKt/PYBkip+tfqej6z1Qk6v3f+3/0lVEG/fvXl/uI/9H+qz8ZsJrFwylTqWwkq9HWYPabfbtKGCtBIcwxiLZS24PEIpaNAGHsEd6uRQ2irdT2ILGIZSNAGHuEt2tRg2grtT1ILGLZCBDGHuHtWtQg2kptDxKLWDYChLFHeLsWNYi2UtuDxCKWjQBh7BHerkUNoq3U9iCxiGUjQBh7hLdrUYNoK7U9SCxi2QgQxh7h7VrUINpKbQ8Si1g2AoSxR3i7FjWItlLbg8Qilo0AYewR3q5FDaKt1PYgsYhlI0AYe4S3a1GDaCu1PUgsYtkIEMYe4e1a1CDaSm0PEotYNgKEsUd4uxY1iLZS24PEIpaNAGHsEd6uRQ2irdT2ILGIZSNAGHuEt2tRg2grtT1ILGLZCBDGHuHtWtQg2kptDxKLWDYChLFHeLsWNYi2UtuDxCKWjQBh7BHerkUNoq3U9iCxiGUjQBh7hLdrUYNoK7U9SCxi2QgQxh7h7VrUINpKbQ8Si1g2AoSxR3i7FjWItlLbg8Qilo0AYewR3q5FDaKt1PYgsYhlI0AYe4S3a1GDaCu1PUgsYtkIEMYe4e1a1CDaSm0PEotYNgKEsUd4uxY1iLZS24PEIpaNAGHsEd6uRQ2irdT2ILGIZSNAGHuEt2tRg2grtT1ILGLZCBDGHuHtWtQg2kptDxKLWDYChLFHeLsWNYi2UtuDxCKWjQBh7BHerkUNoq3U9iCxiGUjQBh7hLdrUYNoK7U9yGHPf1U6x/GLJJPV10UJrEXMMfh7168T11FMhyVaf5tlUYNoK7U9SCxi2QgQxh7h7VrUINpKbQ8Si1g2AoSxR3i7FjWItlLbg8Qilo0AYewR3q5FDaKt1PYgsYhlI0AYe4S3a1GDaCu1PUgsYtkIEMYe4e1a1CDaSm0PEotYNgKEsUd4uxY1iLZS24PEIpaNAGHsEd6uRQ2irdT2ILGIZSNAGHuEt2tRg2grtT1ILGLZCBDGHuHtWtQg2kptDxKLWDYChLFHeLsZrW/uij8ZkNEp3x4kVhMDIkAYS5RpwreoQbSV2h4kFrFsBAhjj/B2LWoQbaW2B4lFLBsBwtgjvF2LGkRbqe1BYhHLRoAw9ghv16IG0VZqe5BYxLIRIIw9wtu1qEG0ldoeJBaxbAQIY4/wdi1qEG2ltgeJRSwbAcLYI7xdixpEW6ntQWIRy0aAMPYIb9eiBtFWanuQWMSyESCMPcLbtahBtJXaHiQWsWwECGOP8HYtahBtpbYHiUUsGwHC2CO8XYsaRFup7UFiEctGgDD2CG/XogbRVmp7kFjEshEgjD3C27WoQbSV2h4kFrFsBAhjj/B2LWoQbaW2B4lFLBsBwtgjvF2LGkRbqe1BYhHLRoAw9ghv16IG0VZqe5BYxLIRIIw9wtu1qEG0ldoeJBaxbAQIY4/wdi1qEG2ltgeJRSwbAcLYI7xdixpEW6ntQWIRy0aAMPYIb9eiBtFWanuQWMSyESCMPcLbteiA+QkB8FiNvkFI3oV35GTSFwJg72XFhORdeEdOJn0hAFar3SAk78I7cjLpCwGw97JiQvIuvCMnk74QAKvVbhCSd+EdOZn0hQDYe1kxIXkX3pGTSV8IgNVqNwjJu/COnEz6QgDsvayYkLwL78jJpC8EwGq1G4TkXXhHTiZ9IQD2XlZMSN6Fd+Rk0hcCYLXaDULyLrwjJ5O+EAB7LysmJO/CO3Iy6QsBsFrtBiF5F96Rk0lfCIC9lxUTknfhHTmZ9IUAWK12g5C8C+/IyaQvBMDey4oJybvwjpxM+kIArFa7QUjehXfkZNIXAmDvZcWE5F14R04mfSEAVqvdICTvwjtyMukLAbD3smJC8i68IyeTvhAAq9VuEJJ34R05mfSFANh7WTEheRfekZNJXwiA1Wo3CMm78I6cTPpCAOy9rJiQvAvvyMmkLwTAarUbhORdeEdOJn0hAPZeVkxI3oV35GTSFwJgtdoNQvIuvCMnk74QAHsvKyYk78I7cjLpCwGwWu0GIXkX3pGTSV8IgL2XFROSd+EdOZn0hQBYrXaDkLwL78jJpC8EwN7LiglJXL9/+z5+vzNxPn6Mf91Q/13ZOWn6QgBsTnehkLwL78jJpC8EwF6rJhGSd+EdOZn0hQDYXO5CIXkX3pGTSV8IgL1WTSIk78I7cjLpCwGwudyFQvIuvCMnk74QAHutmkRI3oV35GTSFwJgc7kLheRdeEdOJn0hAPZaNYmQvAvvyMmkLwTA5nIXCsm78I6cTPpCAOy1ahIheRfekZNJXwiAzeUuFJJ34R05mfSFBvj2f/Gv9lhQfzIAYtsYo5FHVG8bMP7Upi8EwNroE4bkXXhHTiZ9IQD2XNT8kLwL78jJpC8EwNp6JwzJu/COnEz6QgDsuaj5IXkX3pGTSV8IgLX1ThiSd+EdOZn0hQDYc1HzQ/IuvCMnk74QAGvrnTAk78I7cjLpCwGw56Lmh+RdeEdOJn0hANbWO2FI3oV35GTSFwJgz0XND8m78I6cTPpCAKytd8KQvAvvyMmkLwTAnouaH5J34R05mfSFAFhb74QheRfekZNJXwiAPRc1PyTvwjtyMukLAbC23glD8i68IyeTvhAAey5qfkjehXfkZNIXAmBtvROG5F14R04mfSEA9lzU/JC8C+/IyaQvBMDaeicMybvwjpxM+kIA7Lmo+SF5F96Rk0lfaIPxCQHzsxH8gQR6vrQwMJ8tQThYe+GBANbnTKzoAvJSoLevzth89Pqd/1ELXX/aCmy6unvwsLF7zquiC8gzGdy089H7r/ffqIXef9oKvf+iM9ApqlfZiOVV0QXkpaDP/5GL3XNXVrr/dv8d+6T7b26LuSXGo3YPPGxozquiC8gzGdy089H7r/ffqIVfdP/NNwT869v8+qJa5/X6kT5DuWemfo7jZkYaOCbs+u/6H7Xwi9b/PgpG9XrdJquy3gBVyOWZDG7a+ej67/oftfAX1P/8hIBdbavy+KSXzv9fk/+V9NJHev93/+v+3/2n+89fcf51/50ZmPedfhfQ/af7z18EMVfaAABAAElEQVTXf76Nvzc4/jkBRRhb8un6rIDF1pHzhYn4GKz5bxjiZncphpz76/cfzI65hju3Rn2wLvaI9vqd//FD1mwoXX+9/9Q/uv90/x3FsOphHR3P54efJs8KWKyPGF2nz58+f/r86fO37z/6/qt//smf38Zx2T///TH3H9/mGwJ4zF8ojXuO+SP9fPT9R7/+0K+/9M///frH3+P1n7VXV7numt19fPXycVk/r05HD37uxCqwQPf/7v/d/7v/d///e/T/2r2r99Lhhyjq+/F06Ncf+/XHfv1x7JHe/7/395/rEwJKs5EjUDvTg4dy3r/O+sNKikBEBSUsR6CKHzyUrIuVFIGICkpYjkAVP3goWRcrKQIRFZSwHIEqfvBQsi5WUgQiKihhOQJV/OChZF2spAhEVFDCcgSq+MFDybpYSRGIqKCE5QhU8YOHknWxkiIQUUEJyxGo4gcPJetiJUUgooISliNQxQ8eStbFSopARAUlLEegih88lKyLlRSBiApKWI5AFT94KFkXKykCERWUsByBKn7wULIuVlIEIiooYTkCVfzgoWRdrKQIRFRQwnIEqvjBQ8m6WEkRiKighOUIVPGDh5J1sZIiEFFBCcsRqOIHDyXrYiVFIKKCEpYjUMUPHkrWxUqKQEQFJSxHoIofPJSsi5UUgYgKSliOQBU/eChZFyspAhEVlLAcgSp+8FCyLlZSBCIqKGE5AlX84KFkXaykCERUUMJyBKr4wUPJulhJEYiooITlCFTxg4eSdbGSIhBRQQnLEajiBw8l62IlRSCighKWI1DFDx5K1sVKikBEBSUsR6CKHzyUrIuVFIGICkpYjkAVP3goWRcrKQIRFZSwHIEqfvBQsi5WUgQiKihhOQJV/OChZF2spAhEVFDCcgSq+MFDybpYSRGIqKCE5QhU8YOHknWxkiIQUUEJyxGo4sNbbwjQJwTEi4M/fsxfhJjwJ1OVsBwBm+gZouT7xkqNQEQFJSxHoIofPJSsi5UUgYgKSliOQBU/eChZFyspAhEVlLAcgSp+8FCyLlZSBCIqKGE5AlX84KFkXaykCERUUMJyBKr4wUPJulhJEYiooITlCFTxg4eSdbGSIhBRQQnLEajiBw8l62IlRSCighKWI1DFDx5K1sVKikBEBSUsR6CKHzyUrIuVFIGICkpYjkAVP3goWRcrKQIRFRCOX97mr3jmL/R/z4PxrIvVWAQiKihhOQJV/OChZF2spAhEVFDCcgSq+MFDybpYSRGIqKCE5QhU8YOHknWxkiIQUUEJyxGo4gcPJetiJUUgooISliNQxQ8eStbFSopARAUlLEegih88lKyLlRSBiApKWI5AFT94KFkXKykCERWUsByBKn7wULIuVlIEIiooYTkCVfzgoWRdrKQIRFRQwnIEqvjBQ8m6WEkRiKighOUIVPGDh5J1sZIiEFFBCcsRqOIHDyXrYiVFIKKCEpYjUMUPHkrWxUqKQEQFJSxHoIofPJSsi5UUgYgKSliOQBU/eChZFyspAhEVlLAcgSp+8FCyLlZSBCIqKGE5AlX84KFkXaykCERUUMJyBKr4wUPJulhJEYiooITlCFTxg4eSdbGSIhBRQQnLEajiBw8l62IlRSCiAg9ffzIggi6Z76+YN6mbu1ark99ezrXQuOhfh9ziutaOxwx7nl4/3nXxkLtnaudtBBcal85//ND1lK/IVuZsagrX9df1V15tfaoi57KWFhqX3n+9//z1+rtasmZmLLzNdf/p/tP9x7fMT3DupYXGpftv99/uv8/bJnZL7pmpKlyfP7/U+cMvkeY/FOJ9AfUXSflcLjQu3f+6/3X/6/73lIHS67egcN3//7T+/+37+LSXmd/1GK+4/vZjoc7/7NeRhftfm+10vZo9bsQXGpc+//r86/PvecPEbsk9M1WF6/7/p/X/K9f7Ker8d//v82/3pO4/f2r/Od4QYAeBoMBqT+7x3CzOA7uRpfkymDJu+iajIQJL516vH7WxcuKJsYwG/DJoatMJCnT+RwY8G11/XX/rE1FGXXz9V1e8amy7XdB0ggJL7V7XX9df19/uyb4xvtpXV8wJm0RQoPffyIBno/tP95/uP91/Vk/wxuAt9eqaV9AIm0RQ4Jqp+8+//vX9+3xpe/4/8rRNfUPATFvN4WSeH6YTFFhD3Ov8d//v/t/9f/UEbwxXc/kyaGrTCQr84/vP97GZ5nfLI/r4/873X84pfdsCKy3u9fnT50+fP33+rJ7gjYEGKvtlUKruP5YnQYHuvyMDno0+f/r8+aedP8cbAo6CHxvg7Z10KH2DWGe9YOhSvVC60jvlWAKBiH6tkXhv5FQvlK6ETjmWQCCiX2sk7vVHKvQup4FX3h6S55TjzCQool9r0N7VusY9DHbKcc4EiujXGrS9/pmt5T8kzynHmUlQRL/WoO38n9la/kPynHKcmQRF9GsN2s7/ma3lPyTPKceZSVBEv9ag7fyf2Vr+Q/KccpyZBEX0aw3azv+ZreU/JM8px5lJUES/1qDt/J/ZWv5D8pxynJkERfRrDdrO/5mt5T8kzynHmUlQRL/WoO38n9la/kPynHKcmQRF9GsN2j8v//4JAeuHqrHk/YaAP2/9//b33+t/9RrNn19/nf/O//trhF1/ZCD2Se6WhdJdsrOX/xi/cXjP7TkjKz3bU/20/hzpX5Lje9ZzxlvhzKle/sMCTjn2uQJH9GtNjjrVy38Y7JTjnAkU0a81aMlrqhdKV0KnHEsgENGvNRL3688jFf36c1bLQumqUJxyLIFARL/WSNz1N1LR9ZfVslC6KhSnHEsgENGvNRJ3/Y1UdP1ltSyUrgrFKccSCET0a43Ef5v60xsC3r+x38Y3860U0/7uxnf7NuqNnwkiho2kVS84Ir1+59+bmUoogRfMwO/VlLGqqZ5P1/Xf+6/3X+8/6xCCAt4wuv90/x018PZSHjWDjdKpnpdTnz99/vT50+ePdQhBAW8YA7/xU0YMG0OrFxyR3n+/7v77Pj5m+rf5GcjreZ3P2Ngpv/2/Zad3P3imsaGono/q86fr/9et/+f7rPdq7v5HbrC9/2cGajb+O/3v+7fxJwPGV0I35xMCuv90/+n7X9uhggK+Yb/czbnT69jq+XR9/9P9p/tP9x/rEIIC3jC6/3xxN9X9l5rBRulUz8vprz1/xhsCfoyvxV681lcm4F9dwVXBF74lJTic/Yeb+JiNnKgIs16+LKoYXUf2+nFwd/5XBkpxdP31/hs9bvzX/Wekwdq9NdyjqZYNtJtKNVXR/bf77/zBaT9KcXT/7f7b/bfPnz5/+/6j7z/+yPuv+THT9THfEDD+9nSfv/ayRt9/9P1H33/0/cevff+hTwiYDX2U63pptjb34pUWPxp+//zZP3/qbqAUR59/ff71+dfn3699/q3DTX1LoJx57lRFn399/vf5/5+e//qEgOMVBLu9PDba+45UpG7UnDl4v2rIAHVUrprI1QvXIQqfNH5Yv2rIAKiCy1UTuXrhOkThk8YP61cNGQBVcLlqIlcvXIcofNL4Yf2qIQOgCi5XTeTqhesQhU8aP6xfNWQAVMHlqolcvXAdovBJ44f1q4YMgCq4XDWRqxeuQxQ+afywftWQAVAFl6smcvXCdYjCJ40f1q8aMgCq4HLVRK5euA5R+KTxw/pVQwZAFVyumsjVC9chCp80fli/asgAqILLVRO5euE6ROGTxg/rVw0ZAFVwuWoiVy9chyh80vhh/aohA6AKLldN5OqF6xCFTxo/rF81ZABUweWqiVy9cB2i8Enjh/WrhgyAKrhcNZGrF65DFD5p/LB+1ZABUAWXqyZy9cJ1iMInjR/WrxoyAKrgctVErl64DlH4pPHD+lVDBkAVXK6ayNUL1yEKnzR+WL9qyACogstVE7l64TpE4ZPGD+tXDRkAVXC5aiJXL1yHKHzS+GH9qiEDoAouV03k6oXrEIVPGj+sXzVkAFTB5aqJXL1wHaLwSeOH9auGDIAquFw1kasXrkMUPmn8sH7VkAFQBZerJnL1wnWIwieNH9avGjIAquBy1USuXrgOUfik8cP6VUMGQBVcrprI1QvXIQqfNH5Yv2rIAKiCy1UTuXrhOkThk8YP61cNGQBVcLlqIlcvXIcofNL4Yf2qIQOgCi5XTeTqhesQhU8aP6xfNWQAVMHlqolcvXAdovBJ44f1q4YMgCq4XDWRqxeuQxQ+afywftWQAVAFl6smcvXCY8i37/MlgPn/fDkoZjk/apqZfWW4Nc+6VCZXTZTajeoQhU8aP6xfNWQAVMHlqolcvXAdovBJ44f1q4YMgCq4XDWRqxeuQxQ+afywftWQAVAFl6smcvXCdYjCJ40f1q8aMgCq4HLVRK5euA5R+KTxw/pVQwZAFVyumsjVC9chCp80fli/asgAqILLVRO5euE6ROGTxg/rVw0ZAFVwuWoiVy9chyh80vhh/aohA6AKLldN5OqF6xCFTxo/rF81ZABUweWqiVy9cB2i8Enjh/WrhgyAKrhcNZGrF65DFD5p/LB+1ZABRv9enxCQXP2EgOSFmFhEgJPG95Xhcmhl8rtOlNqN6hCFTxo/rF81ZABUweWqiVy9cB2i8Enjh/WrhgyAKrhcNZGrF65DFD5p/LB+1ZABUAWXqyZy9cJ1iMInjR/WrxoyAKrgctVErl64DlH4pPHD+lVDBkAVXK6ayNUL1yEKnzR+WL9qyACogstVE7l64TpE4ZPGD+tXDRkAVXC5aiJXL1yHKHzS+GH9qiEDoAouV03k6oXrEIVPGj+sXzVkAFTB5aqJXL1wHaLwSeOH9auGDIAquFw1kasXrkMUPmn8sH7VkAFQBZerJnL1wnWIwieNH9avGjIAquBy1USuXrgOUfik8cP6VUMGQBVcrprI1QvXIQqfNH5Yv2rIAKiCy1UTuXrhOkThk8YP61cNGQBVcLlqIlcvXIcofNL4Yf2qIQOgCi5XTeTqhesQhU8aP6xfNWQAVMHlqolcvXAdovBJ44f1q4YMgCq4XDWRqxeuQxQ+afywftWQAVAFl6smcvXCdYjCJ40f1q8aMkDw6w0B/KuVsjSzSGoTWWxNtPzxckTh52KD2J8MML23R68/XtJZ6bP3+FguA9rVYp3/kYyVj66/3n+jw8xXRfWYtTGIwiko0P2n+0/339lG+/zRe0ztjA1oV4v1+TuSsfLR52+fv+NILWftrI0+f2tOdNsh0Pcfff/x6f1H+Velu6LiF0nT6f3X/af7b/dfHTWPoM+fX+P8oZevs2C27vnEjMe88pHNCwexYtHjp6Dvv/v+exXKrotpRqH0/ffcPF8+uv/RPvr1n379Z28WO2MC2tViff6MZKx89Pnb5+84ZspZM2tjEIW7j6Jf6vwZN52znO/HKnKnndi/OnBKUvu1guICe/OYr3EHuCRO9Prr6PaUKH2df93WKD8CXX8rFZYP1c0BLokTvf96/41bZy8JlU/3n+4/+8cq1YdA99+VCsuH9s0BLokT3X+7/3b/7fNn9Izrh80+f/+Xzt9v/2cFMI6I6f2/8SP9YnVkCPT5u1Jh+TiOXbmXxIk+f/v87fO3z98/9vydf/5ldpno4qPHlJdmu//kzU733+6/3X+7//6x/Xe1Xi7ebhfnRPef7j/df7r//PP6z/UnA2rb27dgTp7NccVCMK/zkS9R5EAQNpR+jYjHhQXQG7Fg+PM6H71+5GG/+rMcMoZFkTZzSP6kFUBtxILhz+t8ML7XzzyBsJEpv0bE48IC6I1YMPx5nY/Of+Sh6y/rBIQlQ2kj4nFhAdRGLBj+vM5H11/koesv6wSEJUNpI+JxYQHURiwY/rzOR9df5KHrL+sEhCVDaSPicWEB1EYsGP68zkfXX+Sh6y/rBIQlQ2kj4nFhAdRGLBj+vM5H11/k4X+h/vSvSse3zPOfv0iKupjZAGHJUNqIeFxYALURC4Y/r/PR9Rd5yKwnsswh2jZzSP6kFWCIEQuGP6/zwfhcNZGNDLGuOQfjpRVAbMSC4c/rfDA+V01kI0Osa87BeGkFEBuxYPjzOh+Mz1UT2cgQ65pzMF5aAcRGLBj+vM4H43PVRDYyxLrmHIyXVgCxEQuGP6/zwfhcNZGNDLGuOQfjpRVAbMSC4c/rfDA+V01kI0Osa87BeGkFEBuxYPjzOh+Mz1UT2cgQ65pzMF5aAcRGLBj+vM4H43PVRDYyxLqOX7F8/76Ec/z8h2U/fsxfu0xn/J+TVmLFQjCv85HSHAjChtKvEfG4sAB6IxYMf17no9ePPPgTR8awKNJmDsmftAKojVgw/HmdD8b3+pknEDYy5deIeFxYAL0RC4Y/r/PR+Y88dP1lnYCwZChtRDwuLIDaiAXDn9f56PqLPHT9ZZ2AsGQobUQ8LiyA2ogFw5/X+ej6izz8Hesv/mQAT6I9z+tb4rMMhqOQAN/0tif/6ENuW40twpxDMD8KazwYmWBrMBJs4tGH3LYaW4Q5hqDXX8kgc53/kY7seLtQhlGCNvXoQ25bzcMcQ9D1txJK5q488wxI0PmvCfN8kKRtq+n6Iz2qqUH0/qvldOZIuRrA++KpWz7kttV0/ZEe5XQQXX9dfyMDKg0BimTbk3/0IbetxhZhziHo+lvJIHP5RHT+SwaUIGpn2Os8QLRtNV1/pIfE/o6fv3lDwEz2TPf8t0vrDQHXXPP5gKyJh71q+3esz5d6j53rKbqfW1bq9Vdyahq6/ikPyqbrb5RJbCKlRoAkbXvyjz7kttV0/ZEeUvsX11/28vgCfvvxo5//rv9VDCpNAYp025N/9CG3rab3P+khtX/x/r/vocYX1PXf9T8yoNIUoEi3PflHH3LbamwR5hyCrr+VDDKXT0Tnv2RACaJ2hu2f/zJFKz8kadtqfon9l58QYIdffhf5NfKteAycsUTEsCtyhY3o9dV8ydm0ZAjrMXDGEhHDrsgVNqLz3/nfhz81My0VgvUYOGOJiGFX5Aob0fXX9df1x3aRZYdgFTCQsUQWXnBFrrARvf96//X+O7dNn38jI/GLxrBXggaRXSTRqVuRK2xE95/uP91/zm2jvWU7pWjOXyLNYH5CQEp7/43tdSXRiO4/3X+6/2TD2Igdgr0Eg8hYolO3IlfYiN5/6xMCuNea+Zt9nAxhz7wu3bgcbxu5ZGv8NYkRnf/uf93/nvfNYG2nvGq+UvX+6/uvvv8cW8d/Sey7qs+fPn/6/Hk9W/6q8yffEOBfyrn66Ut7B25G4gRD9NvojvFvGpIWOic5/VfhV0eyBi1Rr9/57/orp3NukHO/nb6Ud+BmJE4wRL3/ev/1/uv9l03B0NlETl/SO3AzEicYou4/3X+6/3T/yaZg6Gwipy/pHbgZiRMMUfef7j9/RP+ZHzP9bXy+9P6rpss+vSEgi2+grr/ef/36S7/+VF+dzxZxHmKnL+UduBmJEwxRn3/3+Rdv7pr3ZCNBw/w2/mTAerwm9Q7cTKZdaIg6/3f+PT9la7wm9Q7cjGZN0Pnv+uvzt8/f0mSyPcz2X0KnL+kduBmJEwxR9//u/3/Ez5+1UNedSyndLDpDXX+/7P6rbwhYT5Q9xS/v2tFTa90noBFThLvsvExqlOHmCa9ABEeien29TNv5H8WgbKhMBKyAAhqx62l1p0XPS9df77/uP91/RyOYL7iEmW0hHoPo86fPX504ff72+dv3H3TH21oDDWjEVOMuOy99/9X3X33/9Ufef337Pk+r+X/sr4l+zHNrPta+w/b+i5R0/f2R9bdKjxJTwc1Mj0fXX27NlfQ+//r8e+8/56e9+J8MiA11XNlf2mpGTCnusvPS9df1915/s1769Y9+/aNf/1itcmyGsSH65/+djAezzpXgAxoxadxl56XPnz5/+vz5lX/+ijcEsHHXlo1LpcwzaPLPIHNhbZZKmWfQ5J9B5sLaLJUyz6DJP4PMhbVZKmWeQZN/BpkLa7NUyjyDJv8MMhfWZqmUeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZNPlnkLmwNkulzDNo8s8gc2FtlkqZZ9Dkn0HmwtoslTLPoMk/g8yFtVkqZZ5Bk38GmQtrs1TKPIMm/wwyF9ZmqZR5Bk3+GWQurM1SKfMMmvwzyFxYm6VS5hk0+WeQubA2S6XMM2jyzyBzYW2WSpln0OSfQebC2iyVMs+gyT+DzIW1WSplnkGTfwaZC2uzVMo8gyb/DDIX1maplHkGTf4ZZC6szVIp8wya/DPIXFibpVLmGTT5Z5C5sDZLpcwzaPLPIHNhbZZKmWfQ5J9B5sLaLJUyz6DJP4PMhbVZKmWeQZN/BpkLa7NUyjyDJv8MMhfWZqmUeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZnHL/JRJvC/jpJwSwDnNh4YetlHkGTf4ZZC6szVIp8wya/DPIXFibpVLmGTT5Z5C5sDZLpcwzaPLPIHNhbZZKmWfQ5J9B5sLaLJUyz6DJP4PMhbVZKmWeQZN/BpkLa7NUyjyDJv8MMhfWZqmUeQZN/hlkLqzNUinzDJr8M8hcWJulUuYZNPlnkLm29V4+J8w+jnCS43/9xm6q/oMHc2FtqkqZZ9Dkn0HmwtoslTLPoMk/g8yFtVkqZZ5Bk38GmQtrs1TKPIMm/wwyF9ZmqZR5Bk3+GWQurM1SKfMMmvwzyFxYm6VS5hk0+WeQubA2S6XMM2jyzyBzYW2WSpln0OSfQebC2iyVMs+gyT+DzIW1WSplnkGTfwaZC2uzVMo8gyb/DDIX1maplHkGTf4ZZC6szVIp8wya/DPIXFibpVLmGTT5Z5C5sDZLpcwzaPLPIHNhbZZKmWfQ5J9B5sLaLJUyz6DJP4PMhbVZKmWeQZN/BpkLa7NUyjyDJv8MMhd2zFI/IUDTmgLugVqhxVtQUED3sMn87L7WlfsLeKB6/ZGBlRdLjqBA53+kiRfL+Fkqs7Prq5iH6AO1hizegoICnf/Of9ffqIHcERWXrZebqtI+2COLt6CggNZNptf3XHg6Az9EH6ilXbwFBQX+P3vvAu7bVdWHzr1PXhhJCI+U4IOQhFdAkIePBLyKVgHtlSshIlbbK2gh+l2tei1Ub02ltvhoFayKtF7b8visaFX81Iigfld5CCgKJEAgJOENgYBJeOQkOXvd8Zi/MceYc63/2XufvffZZ5+xkrPGb4zxm3OuNeaYc661/mv//xl/ClSuP3HMtewYsy8yq3+pgNid06CBzL/Mvxx/lANtREQ8jkDPzPEnEZgJSbM7p0EDFvdm2bn4r63RTwZQC1w3Nv0gqbUGBMk8j1GuyRnvjEn4YndOgwasrWbJ9n0sWtyBZrwzpow/RUDi4oJj0EDmH4Uprz/jnNOyA2POyxnvjElKiN05DRrYdP7xCwG+n+ybXrihVp0/0Mx/iYsLjkEDFrpmWQ6nBtcza7hnTOIRu3MaNJDtU6B8XnPcWnQkit1uxjtjkkJid06DBqytZsn2fSy64JM6450xZfwRKhccgwYsms0yG2HXDZ5ZzTOmjH/GX5PLJYdBA5l/lCa5/sQ5p2VHnV+qoBcC6LKTvicI34wyR4QNkssCQ8ZqveYZHoNDDzOy/Yw/j1ja5jNkeUDP8bUm7D3D4+bP/Mvxn/Ofjof5EZLjb+mCYi5emFnGiM6xc/3L+Tfn35x/x9kC8whmDUi2A0OCO0rP8BjMnH9y/sn550Sdf/SvSnF1omO6/WUp637Me5zjv0Yrnz/k85d8/pLPX2Q6mJ8h9+b+V+ZyXojqT75gHscxQfKBAkPqXDa39wyPwc3rv7z+y+u/E/X6b25EY2Sr9AyPwcrxn+M/x3+O/3G2aDPE3lz/cHvzM1S2jzv8eplucZqLF/pNpWd4DFac/903BFSyCF/Q27kS70Olm5dWmkD4vSLUKwRjtfbMZGDzjTqmlSaQ7etA0/DUyIiwKGX8Q15ypHxsNHJb2VtpApl/mX+Y4C2vJEEsS1q+mcnAVtLOuFaaQOZf5l/mH4ZGHRkibJTk+MN6ZyExgMBtSVppAjn/5PyT8w+GTx0ZImyU5PyT8w/lAI0SSwkDkjj+r0o1k+j7AqYNhTN7K00g59+cf3P+xSCpI0OEjRJyejtzvQ9lNy+tNIEcfzn+/Pjjb3vxW/imF5848vdunrl57KvJ/Mv88/nXrjMsSyixKjaTgc0nnWNaaQKZf5l/mX8YHHVkiLBRkuMv5x/KARollhIGkDhbklaaQM6/Of/28697ISDmlSUOzF0C8Uus8a0aVwJQJL2BQAndGuYKQUDloxwYZPAJnO1n/DP/dNzoWHEjBlBkjr+cf3L+zfXHr7GYILwt4oFBhlx/2wVkXn/k9Udef+T1B0dA50o3YwKKzOuvvP7avesv/YYAnYvrH5YW+tI/Xagy/ygOOf5y/O3e+Mv5P9c/Xe51L1dEgFucf/FyF0/ePGvhGwJQZ95/6bImY45im9ffkhl5/Ulh4BFj2QG4xfGn0fQxdRaqK8efRVi+xCTHn88VJB3ZADP/KGHy+juvv/P6+0T5/MFeCBiGrX/i7dZFwIEPh8gwIzbPYIaB59Bu2GT7NJnGNGqBnImXd8YVqXkQbkjjzdSX8c/4Z/61sdOhYb4KfgwwyOqECpnjjwKjc9wQz5x/cv7J+SfMKl4Zxot32rxiE416oUIaL9f/IZ45/+T8k/NPmFW8MowX77R5xSaanH84AggHpBm2P//ihQAffv2GAL6usobUDRXS+Yf+zPkv57+c//ywCngYL51X72tsoOX44wggHJBm2P78F8JuChqArA6okPus/XV8Q0CdusMLAXZuCjL/uufFIT7oYMgTo//Dxya5/ub6m+tvGNVeyfkv578wX/rksHU953+9Ds31TyKAdIC0PMnrT8yna/TXBDyzhM3iRVa+KMVDB28PBZhH/0I1naFTpbjYZhzelO1n/DP/dGT5cZHjL0ZgiE1n6NScfygCEpOZwHhTzr85/+b8m/MvT5h+XpAJ1O0GX2foVCkpthmHN+X8k/NPzj85//CE4ecFN/W0ucQbO3KntjIzDm/a7/MPxgafEGcJHzsfcx8sf07M5U1sMw5v2u/nr2cynO5g8OcUysw4vCnPP9cfjDGfF8ghyMHXGTpVioltxuFNmX8nT/4hzyynaB7P/j95+t/6nYBe8dEyls/f8/OH+mKAXxeQK5CDrzN0qhQT24zDmzL/cv7BuuTzAnkHOfg6Q6dm/lEEJCYzgfGmHH85/vZy/Nk3BOjA9qnIFq97rOzgriaUUTbt/ffsgMMPLGbffuvb8LrH2b5EYCYkGX8Niu0z/9rdRY4/jUDOPzn/ngTrz3o9RxY8H/JarF9GSRifHuiICLpjqddx9a1cfp9w3IZylZLtZ/wz/2gw5PjL+YdmThkLbk6VadLpwzza+Xg22S/zLz+wiBvr+AJXwnn9rWurD9IOXn+urXNy6Ia84T6xXsj472r85ToKHSDSIq+jIOOf8W9DVDNlB8d/5l8YfKScuOMPD37bPL5B54Pk0fMKZztjOpHPH8feztGfoMeVMWNCHeqi/THOv2v8rQ37+PqrxYoP0+7uvVketXM88v7DRcj1qQTL6Y6lcex8nGMST/XafihXPfn8Q0dl5p/LEJdTkiZOdyzNoM6X+Xewxl+7h9ZVyyaUei2jeu8j64wJRnXR/hjXv7z+4MHH20ywZ0zgnajxlxcC/FsoekIcgBoIOTM7PXbAU0Pko+KxUHXHZmbXDyicR2C2396CyfhLslBeZP7p4OBQ6LjqIpPjT7JEYyOxmpu02SGBo13OPxqmbp/z78Gbf/nhkt5H6N66nFSeTuiMdWAE4RQuQBeT8ohBzNXHdkCSWhcbmxl+pYGsHPZl+xn/zL86LoJwCg+XHH85/9BMzff0daeTaE2TNpdG817Ov9PGUT604EPL6y8Nwi5cfx6iOiW81ALSoj1g4uDTlvHXIOxC/PHqi8RZAs290G0ZfwoIBSHj3yWGqnn/dfDuv0JHb3L8y4fPMk5qXmxQQS6bz384CBIKjgxmWAmNBojNtKlFsduzmX1bnH+4P/L+d39ff+bzB816znBc/wGoblamCCmfv3DMalyCcArHKu+/c/6jTNnt+++NIxu0NHHu8SaLFcmqy5Imu94jet5/aGwkdDUiit1eQko7i7HzEczr73b9rd8QIDHVwBrkmCFHY/xmNS7HmxQJitr9fnBbozW9B4IvPY9DkaCM/MHNBnfRLZCL5fmPwVuwhJgGZSwwuDP+mX85/mTCsaHAwybnn3HyWLCEOSUoY4HBbUE/OOuP/OUg54+cW5VdKNRdSeBK0iFCtQD51uiqGO/lWjm5s8SLB75MV6fVHQ/A6uGDNI6BRiZTtp/xz/zTMWbjJsdffWjD01zOP2HC9HPqzJTKXMsjz20Tcahu1fzLv1mP6HOdUWnVAAUu+Hn9R5HY+vWHfmgR859+BlBDLZ2BqDeZ8e/CwwHJ/OMgyNCVUHCIFvKHXf0WciooPXNmesj4Z/7l+KPn1fTX6G79HV7sGoeSWcKQC4pRDAzuHH+z48++fYfmwVXXPzxN5vUnsorTTCMCYdIyUIGyOu4cmSgZ/7z/xxizvOE1Qz60z/GH2PiRZUOpDrFu+FV3jj+5IrUYGWjhItNuzj/yUn1e/1C88/7DLsU4+zgVN7lh9ZUiQRkrGNzWKD3L36CrztiueGstrmg1ey+TVF9w4ljIPVHC60cHrZRO482qdN8CY97oCBeaUPOCUwtL2Ww/498yreaLXMY3q6YLfKwx5i3zL8dfSAPJCt5pttSc8aljDCXl/JPzT5tpkCh8Gd+smjLwscaYt63PP/LGKS/srgq5f6rViSAf3PL2pHyVqSvDpH6jtyzpLcJWrvd7PdtvAaZYZPxrODgvaLN4iELGzD8Z6isHV46/nH/22fzLLwT4NYqHc9h4ncn7P7fS86qri+Oxrv/tL0taxIcPkjL+mX85/nZl/OlIruMZw7oNRUU5/nL8bWL89fdsuq5yCvG1cRCaV7RX84ITrMy/beXf3NrK98l5/5v3/zzijrrpJZ7SCNv9LttpM10UHuNUqy8jrG6X+Zfjb5/d/3UZ2lSfy4Qt39lOm+mikPEkzf94v1bXcokQZhmODQfMhHh5p+YFJ1jkzvtvf6dd40XR81YNF3yILssWeO8Fo77GgM5gc9xOoPjTtQ3/OYF7M4POvd/6IPT+o+mhPCu8WTvqlX0gKo33C+ZGOAoK5VnhLdvXOPgpJQSqukksmBvhKCiUz/hrtDL/atZodsg+JEpLqgVzIxwFhfKs8Jbx1zjk+JdkkBwJiVLDQ2LB3AhHQaE8K7ztcv7hYQY3gybRLF8ERSt7dGseflGBLpjoBpQv1NnOO75mD1stUEVwsdLbVe+trVjzZPsZ/8y/HH80I+T8s6/nX/uL9DaNB3Q81j9/AAe5ffkrRjrBtm7ycImL9EE+f9/PSzjPv7vc5EBxwsim0ZF9CBT8lE8Ejd7Mm0ahPCu8WYXqlX0gKo33C+ZGOAoK5VnhLdvXONToSoxCoKqbxIK5EY6CQnlWeMv4axxc/Nf5wz6yaojo6l9etMv4h/ypUduKCOW3kH/cH3n9TRmZ1986XWkoYurVAdvG7azbjMpbYuu0iPGf9/95/5/zD42VAz7/8P2arFFhobIpI6+/KBQ8Y253C2HVydVVqF7ZB2JrbcHcCEdBoTwrvNkJqVf2gag03i+YG+EoKJRnhbeF9vUnA5gQSrHBbfyAQT4YIBpVZHU5yhJs1XLS6wXvLLcRR3e2n/HP/JMxmuMv55+cf8clYsnSlpWTa/3BCwEaF86YqdC3AS2v3S1QYyhz/c31N9ffXH9pjsjrj5P7+sO+RldWEl40KCd4fVjY2rJycq2/CMdun39b53WN53Z9f+x2+zjPJZntY77I/M/nP/n8a/HetU0U41Ryktx/tLVVQ2Dz+Ely/os3p8fp/Hltbasqrav0t3N5/Yv1bBymc5Y2rHP9y/Uv179c/+ZmCbK1iWIkHKf53w5kh9tv92zagqzzJ9H5W1w9yPNfXlh3OP982A3X+M/8ZEClyEEwnp/CVvWfDG60NFu8liaxeIGV7dfQzwZw5fyZ8UfyLaVv5p8kV46/nH9oepmdYXL+PaHnX324xD2rcx2/bc4vBOiW81/Of5QbOf/n/J/zf65/dVUIYmH97x+Scxn74AIVYJlhff7iQh05/xzz/NM/XOKQh29syPhzSLotr3/y+ievf/L6j+bKfXT903/bi/0UTzd7sVpnsBlPdcKT8z8i4eTm5v+19XUrw2Fs988Z/8y/hUtbzhgODrYcf4iEk5sbf3rvMBvAnP8omvORIUfmX8u12SAd3/zDOo+DHO6f2bFw/21lCMyempQFa4l0fM/fVk86jP10/eWidtLG334yQIJR88QHJppaIkk2Rqcrpg64IY0QDE5xENxoqhqMkCCbVAfckJ27qs7rILjRVDUYIUE2qQ64ITt3VZ3XQXCjqWowQoJsUh1wQ3buqjqvg+BGU9VghATZpDrghuzcVXVeB8GNpqrBCAmySXXADdm5q+q8DoIbTVWDERJkk+qAG7JzV9V5HQQ3mqoGIyTIJtUBN2TnrqrzOghuNFUNRkiQTaoDbsjOXVXndRDcaKoajJAgm1QH3JCdu6rO6yC40VQ1GCFBNqkOuCE7d1Wd10Fwo6lqMEKCbFIdcEN27qo6r4PgRlPVYIQE2aQ64Ibs3FV1XgfBjaaqwQgJskl1wA3ZuavqvA6CG01VgxESZJPqgBuyc1fVeR0EN5qqBiMkyCbpXfQ1fZjBF41M480uPEM5pzioJbRsu/CsBPAgQTapDrghO3dVnddBcKOpajBCgmxSHXBDdu6qOq+D4EZT1WCEBNmkOuCG7NxVdV4HwY2mqsEICbJJdcAN2bmr6rwOghtNVYMREmST6oAbsnNX1XkdBDeaqgYjJMgm1QE3ZOeuqvM6CG40VQ1GSJBNqgNuyM5dVed1ENxoqhqMkCCbVAfckJ27qs7rILjRVDUYIUE2qQ64ITt3VZ3XQXCjqWowQoJsUh1wQ3buqjqvg+BGU9VghATZpDrghuzcVXVeB8GNpqrBCAmySXXADdm5q+q8DoIbTVNZXztE6wlb22bripm0FMpCdu6qOq+D4EZT1WCEBNmkOuCG7NxVdV4HwY2mqsEICbJJdcAN2bmr6rwOghtNVYORZP9XpVwOHyQ5Wnx4BIc04hQHN9t+rDiWQnWQ8Er62EWF8zoIbjRVDUZIkE2qA27Izl1V53UQ3GiqGoyQIJtUB9yQnbuqzusguNFUNRghQTapDrghO3dVnddBcKOpajBCgmxSHXBDdu6qOq+D4EZT1WCEBNmkOuCG7NxVdV4HwY2mqsEICbJJdcAN2bmr6rwOghtNVYMREmST6oAbsnNX1XkdBDeaqgYjJMgm1QE3ZOeuqvM6CG40VQ1GSJBNqgNuyM5dVed1ENxoqhqMkCCbVAfckJ27qs0bX+7SnwxoXqZXDUZIqxhAHXBDwotqVHdeB8GNpqrBCAmySXXADdm5q+q8DoIbTVWDERJkk+qAG7JzV9V5HWTn+jr3gZWyddXi1/EdkyC/gq8f2kCaPxic4iC40VQ1GCFBNqkOuCE7d1Wd10Fwo6lqMEKCbFIdcEN27qo6r4PgRlPVYIQE2aQ64Ibs3FV1XgfBjaaqwQgJskl1wA3ZuavqvA6CG01VgxESZJPqgBuyc1fVeR0EN5qqBiMkyCbVATdk566q8zoIbjRVDUZIkE2qA27Izl1V53UQ3GiqGoyQIJtUB9yQnbuqzusguNFUNRghQTapDrghO3dVnddBcKOpajBCgmxSHXBDdu6qOq+D4EZT1WCEBNmkOuCG7NxVdV4HwY2mqsEICbJJdcANCbc8m5UHs+QhaS9w90QqEE1VgxESFZtUB9yQnbuqzusguNFUNRghQTapDrghO3dVnddBcKOpajBCgmxSHXBDdu6qOq+D4EZT1WCEBNmkOuCG7NxVdV4HwY2mqsEICbJJdcAN2bmr6rwE2zcEwA5ppUeglGXi6OktTTcEADk2axalLBNHT29puiEASGttBEpZJo6e3tJ0QwCQY7NmUcoycfT0lqYbAoC01kaglGXi6OktTTcEADk2axalLBNHT29puiEASGttBEpZJo6e3tJ0QwCQY7NmUcoycfT0lqYbAoC01kaglGXi6OktTTcEADk2axalLBNHT29puiEASGttBEpZJo6e3tJ0QwCQY7NmUcoycfT0lqYbAoC01kaglGXi6OktTTcEADk2axalLBNHT29puiEASGttBEpZJo6e3tJ0QwCQY7NmUcoykT38MEM2VurWPrhpZQ0BQKLQjFTKMnH09JamGwKAnGkXJqUsE0dPb2m6IQBINDYjlbJMHD29pemGACBn2oVJKcvE0dNbmm4IABKNzUilLBNHT29puiEAyJl2YVLKMnH09JamGwKARGMzUinLxNHTW5puCABypl2YlLJMHD29pemGACDR2IxUyjJx9PSWphsCgJxpFyalLBNHT29puiEASDQ2I5WyTBw9vaXphgAgZ9qFSSnLxNHTW5puCAASjXUyfGhBS8waveK/UX/rGNSxit7SdEMAkKhsRiplmTh6ekvTDQFAzrQLk1KWiaOntzTdEAAkGpuRStH9Or3417+gMf40UF9p0w0BQM60C5NSlomjp7c03RAAJBqbkUpZJo6e3tJ0QwCQM+3CpJRl4ujpLU03BACJxmakUpaJo6e3NN0QAORMuzApZZk4enpL0w0BQKKxGamUZeLo6S1NNwQAOdMuTEpZJo6e3tJ0QwCQaGxGKmWZOHp6S9MNAUDOtAuTUpaJo6e3NN0QACQam5FKWSaOnt7SdEMAkDPtwqSUZeLo6S1NN0Rg7RB/OoBWCPpPo5u5fkhgJZ1H4ejpLU03BAA51NoMSlkmjp7e0nRDAJCtuQEpZZk4enpL0w0BQFKr6/STAfo177rCoj+U4ojdEY6e3tJ0QwCQXZ1eVcoycfT0lqYbAoD0DXZYKcvE0dNbmm4IALJr06tKWSaOnt7SdEMAkL7BDitlmTh6ekvTDQFAdm16VSnLxNHTW5puCADSN9hhpSwTR09vabohAMiuTa8qZZk4enpL0w0BQPoGO6yUZeLo6S1NNwQA2bXpVaUsE0dPb2m6IQBI32CHlbJMHD29pemGACC7Nr2qlGXi6OktTTcEAOkb7LBSlomjJ1rCPTS/OMb3z6BAdm16VSnLxNHTW5puCADSN9hhpSwTR09vabohAMiuTa8qZZk4enpL0w0BQPoGO6yUZeLo6S1NNwQA2bXpVaUsE0dPb2m6oQroGwL6q05QWPLGHywQxnc7wK1W8TJrsxltxQWYplUM9bAh28/4U55k/tlQwKCLowcapBtSDppXgGkzDPbxluMvxx/lQo4/GwonwviLF506knmptxEvwDQlyB42lrzl+M/xT7mQ49+Gwokw/nXsjnuMbp0ITHNE2FjyluM/xz/lQh3/sq5QSqyxqeaH/kU6azVXMEDEH3dgZf5xuCwaLkiwseRt9fjjFwJcZ0iJ4ZZerLpD7Rl/Dq1FYyZCm4s/945uqAsS9ijNK8A0R4KNJW+r+z/b1yjpbFRjlfMPgjJIZFeOfx5aFg0XJ9j2fvzx2ooM5gPCN71Ibuf1t02FGN7oKe08aJCuSx00rwDTZhjtW/bglHXVFXGQKNAgUSpK8wowzZFgY8lbzv+Z/5QLOf5tKOzV+M/xl/OPJd0Ojr9DwzfPYK7neOf8bzGXAZjr316uf2v0dRV05YMklB6Y3c0zYIWMRfkCSj+Y4A8i9GJXGETH+Fq+MenqIpVTI25oF7LzZvsZf7rJ4gGV+Zfjz+aPnH9y/qVkkHyQpWN+/fCryTwDVkhfgmad47j++N+pkhmQdv6rqXL9Pdj9z5l4PPMv28/4Z/4dvPuf9qKZrCqy4LUPLkS1Xfb/7vc/fhpIgs4fKNE1B37rOOO/+/FvD6/katJyn0HGP+Ofz790naBMaM/v6HYp7z/G+w/JFQlXjRnN5dgW7jDJrdxaG+gic/45tvlH11bXB64/NNDoFcgQ/pz/j+PzD+6JzP9jy3+fzQsZTpScfyjTahx8xDL/cvzNjz+9JqRxI0OHPpuSb9hjZXlbyDAqkOMvx99Cdmxj/ZVvCAjVmWJgOUurB0y+XuLPXyGtIAhmiCC4TTEQyTMamGgX0qggmCGC4DbFQCTPaGCiXUijgmCGCILbFAORPKOBiXYhjQqCGSIIblMMRPKMBibahTQqCGaIILhNMRDJMxqYaBfSqCCYIYLgNsVAJM9oYKJdSKOCYIYIgtsUA5E8o4GJdiGNCoIZIghuUwxE8owGJtqFNCoIZogguE0xEMkzGphoF9KoIJghguA2xUAkz2hgol1Io4JghgiC2xQDkTyjgYl2IY0KghkiCG5TDETyjAYm2oU0KghmiCC4TTEQyTMamGgX0qggmCGC4DbFQCTPaGCiXUijgmCGCILbFAORPKOBiXZZ2k8GEJ8fxfErUXyBPrehvPhMMTBXJNjA9O3Le1hggQC9k8FtioGOPapgZvt5/ZXXn3n9jXnAZgpMEGaIILhNMRDJMxqYaBfSqCCYIYLgNsVAJM9oYKJdSKOCYIYIgtsUA4HcXgjAowj9yYD6bCPv//b4/ld/j5L6irurPhza2OAHUa7b5rvSCMFtigHjLQEwkXeQxgfBDBEEtykGInlGAxPtQhoVBDNEENymGIjkGQ1MtAtpVBDMEEFwm2Igkmc0MNEupFFBMEMEwW2KgUie0cBEu5BGBcEMEQS3KQYieUYDE+1CGhUEM0QQ3KYYiOQZDUy0C2lUEMwQQXCbYiCSZzQw0S6kUUEwQwTBbYqBSJ7RwES7kEYFwQwRBLcpBiJ5RgMT7UIaFQQzRBDcphiI5BkNTLQLaVQQzBAB3FhbZS0lytL9WiytU3+uv+26d7vxl7iiM2hBxct2R+sPFEG7kNZPIJghguA2xUAkz2hgol1Io4JghgiC2xQDkTyjgYl2IY0KghkiCG5TDETyjAYm2oU0KghmiCC4TTEQyTMamGgX0qggmCGC4DbFQCTPaGCiXUijgmCGCILbFAORPKOBiXYhjQqCGSIIblMMRPKMBibahTQqCGaIILhNMRDJMxqYaBfSqCCYIYLgNsVAJM9oYKJdSKOCYIYIgtsUA5E8o4GJdiGNCoIZIghuUwxE8owGJtqFNCoIZogguE0xEMkzGphoF9KoIFQDr/NYU9gUfuLNuAasmiUAJtqFND4IZogguE0xEMkzGphoF9KoIJghguA2xUAkz2hgol1Io4JghgiC2xQDkTyjgYl2IY0KghkiCG5TDETyjAYm2oU0KghmiMC7h58MUKen4IKz2obWYuWj1uoSRDt7O3gky3MN/vhCH24oQbVqy/b1qf9M7OZNLZaCaJfx99kVo6bRajFjb7Bl/mX+haetMX9GreWSINrl+MvxxxeEc1uYayoh2DY5/8jDJX/VSXXhy4Ay/zL/djv/Wm5r9rIuiHaZf5l/mX9thHgU5vrqCLZNzv+tTi3NuiDaHcv40w8tqPfkW+W00tUfXOxs++Pb5u1M59HBbh8fIvETJu4SPtvYHwf7/Of73Fvz/LHaSCRodyzjP8cfBTDv//wAOwrO8bfZ8be2Tj//wuu7bPW3hQlrBGscj/P6fzKN//ayHV+t1hfqM/45/+X8r1PUpvY5/292/udwhrm+xjfYcv454ecf+fZW6ltdVXjJ5x7WLfT1nC37/4Tv//18/9W9EKDpKHlo0EA0k4bcFEak1VSGWOkEiWukfzxMaDNoIJqZQi5em4URacJtu5XORmuNZvsWMgMSJ69l/DP/cvzl/CNzgp8Y3IyqcKXTsR3PoIGcfygCPhqr5l/7oMAuO6ksF1i5udoNGpCSXlvVfmzGl4qeqDmeQQPZPkXARyPjn+tvrr+5/sqc4CeGOKl2s8bgdAZXiUEDwsO6InnHLtrwohlu3dTq97EO74nY8QwaEKrXcv7DNwHVR0tVjOu8j1qMeNQcz6CBjD9FwEcj8y/X31x/c/2VOcFPDHFS7WaNwWmGdUomrgabzuOxYq/l/LO78w9/cFOXVOkS7o+MP8W8Jmjm3+7mnwbaZ1xef/hoZP5l/p2I11/2ohnPo5TQ7X7NZbdBA7oG0T7nXwlFfv5LqbHT+d+9ENAtOC75tAv8XhM1pqv3R9yzRZ8p7E0ex9pYU+9qTivVs0WfKexNHreagNS7mgPueLRSbqawN3ncagJS72oOuNl+Hy3RZ4LnTR63SAKpdzUH3Ix/Hy3RZ4LnTR63SAKpdzUH3Ix/Hy3RZ4LnTR63SAKpdzUH3Ix/Hy3RZ4LnTR63SAKpd4mDD26YjYca/reqpNxMYW/yGK02qd7VnGW2lJsp7E0et5qA1LuaA27mXx8t0WeC500et0gCqXc1B9yMfx8t0WeC500et0gCqXc1B9yMfx8t0WeC500et0gCqXc1B9yDE39eV7Ce4OzaAw1YRtlHS/SZ4HmTx0evcWR4i9bVahTUVKN6k8dGMKDe1RwjD3erUm6msDd53GoCUq+t865T5vpD2a1GQU1FpfEDD7Li4ZMRDPQ1mmMW9Oxsn2Kb8R8SzIfE4zGp1Lua00r1bNFnCnuTx60mIPWu5oB7cOb/5TNqnjnUR0v0meB5k8djnepdzWmlerboM4W9yeNWE5B6V3PA3Vz/93N5+CrhVlVFO98+V+zPx+Oh+WFFGxne0h+t6DMNeJPHvi7F6l3NaaV6tugzhb3J+qNe8cR1ta+xtTWHerbovrFayJs8HutU72pOK9WzRZ8p7E0et5qA1LuaAy7yqrEFNdWI3uSxEQyodzXHyEO2SrmZwt7kcasJSL2rOeDm+ffREn0meN7kcYskkHpXc8DN+PfREn0meN7kcYskkHpXc8DN+PtoYV3BLZtfV3w8PW6RBPI1wrYse7boMw14k8djzepdzWmlerboM4W9yeNWE5B6V3PAzfzroyX6TPDshYAZX40mvxWpv0Jsd29GNtAiL2jJzk74ILVo1NQGT7af8Q8/I2HJYsAnDOElO9Pgg9SiUVMbPJl/mX+Zf26EGDTgBwzhJTvT4IPUolFTGzw5/rY+/vTrJ+slpwh8BSUiDYko2+rug0841//Mv63n31I25fjHuIPM8ccRiNHQmCAyOf72z/iTrzuk77zTlYV6hgD/Zn3clnuz9XTkRM3XluvPqvxfp6+Znvg7CGUEcdx4nT8ikrVxQ6QhlRE1Xyrjvyr+8+vccjQz/xEbyMw/jkCMRo6/FoGTZ/5ZX6OfDKBMwGyuHxScPOfP5z1ux+/88cGNzvF0HPwnybzZYDWgdtsv2X3hyImaVUTg+J2/HkW2n+v//rn/kJy0wWLADxgZM/PXZUxDGUgtGjW1wZP9n/2/k8//9Z6Ns0tXel5XMv+WRmyuP3s5/9ALAfw0x12KWWYa8LNjwJGBjquU4CSl/nACvualVRSIbb5eMURQNpbM9jVxMv4SgZAcmX85/miOo/9z/qEwuOneTbg6cdi4MYDpdpCRkfPvfpp/28MMXd25r+TCk0D2v0/lmMXtsqOz+yIVR0bm/37K/9aP3FnUU3n9metfrv/HfP3j1xVMifGDi7nJMcffbs0//DXTcasv/oXFKeO/W/Fv0c/1P9d/fVFKxmOOP73xQDDy+uuo119hbeVrleFFuzjThxSja9wcfzs7/uSrnV3I7YWAasv4uyGe+Zfjjx6w2vVQGByk5Px/1PkfS6UGMQTQzUINRkbO/yfK+scvBMgzKR4sPDTwohl3rXWqAbbObpGR/X+i9H+8ZY+9eLz7374hwGWiJF9Lr4aGrOzOBf7eDF2l36MES7DU1lptyLMFxyLm7s3QVfq9FSEAltpaqw15tuBYxNy9GbpKv7ciBMBSW2u1Ic8WWrIJpAAAQABJREFUHIuYuzdDV+n3VoQAWGprrTbk2YJjEXP3Zugq/d6KEABLba3VhjxbcCxi7t4MXaXfWxECYKmttdqQZwuORczdm6Gr9HsrQgAstbVWG/JswbGIuXszdJV+b0UIgKW21mpDni04FjF3b4au0u+tCAGw1NZabcizBcci5u7N0FX6vRUhAJbaWqsNebbgWMTcvRm6Sr+3IgTAUltrtSHPFhyLmLs3Q1fp91aEAFhqa6025NmCYxFz92boKv3eihAAS22t1YY8W3AsYu7eDF2l31sRAmCprbXakGcLjkXM3Zuhq/R7K0IALLW1VhvybMGxiLnZ3D4o0KtO3h+hC0+86ToWjZbWakPWAEAsAmt3Ju3MlO73VoRArKy12pBnC45FzN2boav0eytCACy1tVYb8mzBsYi5ezN0lX5vRQiApbbWakOeLTgWMXdvhq7S760IAbDU1lptyLMFxyLm7s3QVfq9FSEAltpaqw15tuBYxNy9GbpKv7ciBMBSW2u1Ic8WHIuYuzdDV+n3VoQAWGprrTbk2YJjEXP3Zugq/d6KEABLba3VhjxbcCxi7t4MXaXfWxECYKmttdqQZwuORczdm6Gr9HsrQgAstbVWG/JswbGIuXszdJV+b0UIgKW21mpDni04FjF3b4au0u+tCAGw1NZabYg9+g0ByqnPM+IDDXLFmpruW+45jaV1t1YbUo/bj5WIszdDV+n3rq7uqFurDXn2bEOVgPbAh+5bhg2c7Z6/9Ic8QeS1XWvpv2oabe1G+/rwsp0FI7QHK/Rsn58J+yggQmPUWtY15NmCEdjO0Zuh+5Zha0WjpbXaUONWFIuYuzdDV+n3VoQAWGprrTbk2YJjEXP3Zugq/d6KEABLba3VhjxbcCxi7t4MXaXfWxECYKmttdqQZwuORczdm6Gr9HsrQgAstbVWG/JswbGIuXszdJV+b0UIgKW21mpDni04FjF3b4au0u+tCAGw1NZabcizBcci5u7N0FX6vRUhQPO3fENAs82+aNfc/SGbB+3BAN23DBs4fWXtrBtq3IrGSsTRm6Gr9HtfI1hqa6025NmzDVVCrKmdmW+55zRWa3997RApxJSFtb5oV9sQMVYyawZNpd8vV9bOuiHPnm2oEtAe+NB9y7CBM3f++vFuth8+aGoB60Nmnj620DP+ef2T139+FNiQIYBRorY26zTk2YJjEXP3Zugq/d6KEABLba3VhjxbcCxi7t4MXSXWedytUcvyQgBYu99+G4V2yASyfV3oT+74ywsB+KvZkPouP5DIlkjOJ4kkOiV4sHNgyVDfDNMwz++zfYqshM9derhYKnR758v4UzAkHpl/Of5ofuF11jbODTIEmzkN5PyT889Bm3/jX5vw3EirOyf6zJb5n/l/0PJf0zzn/1z/cv3fyesfXVc4pjy26ijb2MAEStIvMDn+dnv8hXW+hr6t8xn/3Y6/DAIeB7qAZv7n+HcTYI6/HH+bv/7AXC5TCadOvV+T6aU+3BGsBsz2ug7n/FPj4IYfx+wYnv+sr+vHd1wjT2v8ol3Gn2KR+efWec4xThDKkBAXzhr2bX785+cv+fmHfceCyyWFbu98mmOZfyfS+MM6zzMEb/yTezp9ZP5n/vOVBm1ujLuRr2bn2/HxTxedXP24hUbZ7Q116fImq8Eta+Y3UKtxupXrwEDxhmxfpg4fEgtfxt+mVYuPgcw/CYWLh+VNBwaKN+T4y/FHS7dPCUufnH/2w/xziK4wuXv8Jku99Nlsx3lqXO7F48vk+M/xn+M/5z+aGOr9S5s8cv7fD/O/dItN2QaO+frXP8zgNvh5Z/xq4+z/vez/tUNuAFI3s6bfBMSdQ//EbeCY+59qpC3X/1z/c/3P9Z+mAjf9yNSAuUGniZx/tjD/8re68UytQaM5NjyadXM4YuxNUo53uf7u1Pq7hq92rrFt/ZHrX65/uf7l+kcTQ65/dXaEyPXnaOuPf9GMo9bWFcSQjfQv5JY35PqT68/urD/DTwbEtBuv5zVlHUug6rznreVx4wFBKtPv1eP9hg2A7wwCVec9b9m+xsHPKogYJBhNthgifsY1ALYzCFSd97yhfLbf4gQEqZHye/V4v2ED4DuDQNV5z1vGX+OQ+dfyBAgSEWpSPd5v2ADYziBQdd7zlvmncTie+ccf3HA/oKdY8oUndBxhk+rxfsMGwHYGgarznrfsf41Di35DLnIgVdliiPgZ1wCKOINA1XnPG8q3VhtyJZVs+1YHyhvXAMjOIFB13vOG8q3VhlxJJdu+1YHyxjUAsjMIVJ33vKF8a7UhV1LJtm91oLxxDYDsDAJV5z1vKN9abciVVLLtWx0ob1wDIDuDQNV5zxvKt1YbciWVbPtWB8ob1wDIziBQdd7zhvKt1YZcSSXbvtWB8sY1ALIzCFSd97yhfGu1IVdSybZvdaC8cQ2A7AwCVec9byjfWm3IlVSy7VsdKG9cAyA7g0DVec8byrdWG3IllWz7VgfKG9eA/hQNq7wxj/E00TcEkObtZKCtFQSCVL/fq8f7DRsA3xkEqs573nD8J0P7eEEDfcHn3x4wtTgBQTIvburxfsMGUMIZBKrOe95Opvhriuf55/jP+S/H/7HNf/IBNAVR5nLayV8OcpU6vWjlsncGgarznrecfzUOPnCIGCQYTbYYIn78czxr9Maj3jXPr6s5/3PCtdhxPBG/Y42/9ZUB9JYzCFSd97xl+xqHjH/LEyBIRKhJ9Xi/YQNgO4NA1XnPW+afxiHzr+UJEEv9OVfKEp43eX2R+2dlgMcRNGxgjGuuPxSTXH84CJIKnCHHMv/oTwagkj7x+A1V/i4L2sxlQMxt19tndRirjMI1UqvN9jP+mX8yGDBy2kBsQy8SMHZItpmhji3UEgcerEPdOf5y/OX4i8PLBksdZxC9fVaHscoodnT90w8KeALgRnjjC88jIq2hXWx/nEu46dognNm+zNGICsLCvSVbzr85/+b8q0OB9nI5Y4NFh4jte/usDmOVUdi02OokQsZfwoHI4QNoixEB+QAaBDhmdRirjCLjj/BYDMlwlPxr/YEXAOnjC143hrqo0lx/OQj0rwYnCjMj/BTIo8a/cWvVMGT8NdQhHghKDDys6BYUyfhTZI4y/lusCA33++atuY1IZ/wlWDEMx338t7lc+23CT/GQip5rwPUtQyNU+6wOY5VRzNRBhJM4/4b+mFtX0Q0I7UodpBh4WMc+JM9JHP+c/7P/M/91UV+cI1bON3CSlApQS5VR5PyP8CBsu3T979cVnt6P8E8GcJt71L41lP3vLwMtLOj+k3H9ad8Q4JLfAuJytM/VOc4Y0caS8kMlzpDt28Vfi1qLqIuUdwtuvoZ6kngGtzNk/DP+9ebD5w4yBNL7gJuvIfggxTO4nSHzL/Mv8w/DxSRGCKQ5HGi+htrXTxKRrzbJJV/trPcXtXTj+4sfV7VdozqmdwtuvoZ6kngGtzPk+M/xn+O/HzY5/igidfoKn3f4QLVZpCHvZyyewe0MOf9sav7RdUV7hD+C5r+e49/W1WXFxbPrgIw/hXcIjzNsM//8wyWEvH1DACyZ/5l/u5N/nGEtixtqmaco45/x34357yDlH39DAK515LxoTcCIguzH1UE6f3z4588R5w3pfcDN1xB8kOIZ3M4ws/7a2lo7ZW5d5fpbLQ2hXUjxDG5nmGnf1+2YqNJk8zVkzgrEM7idIdvf1PVvH1fWWxQb6nniGdzOkPHP+Ofzj37Y2NhyI2WR40diT9pP48/WlXqQ+gI3HWH2f99tB7L/20m6rN4n8397IaAd5Tiu3HF72kics8QSolF9E90d6N80zPvrEyZ1Zvs0WczEyYZL8y2GqlGkkzL+mX85/mYH1TiJLQ6q0TFa/MCrmEg5/nL87eb4k4tO/3SJUs8eaGT+5fjL66+8/py/qMz1r1/Ee92W9NExWozcAJFO1PW/PcyoiwsJedGsnt1BP//WiYzGsx0tsYRoO9j/8iFS/VpjvKBh6/xM0zvdfn9jutfnn+3He5iMf58RM4NgB8df31rGv49Ixn+IwEL+6do6s64uJtXoGC1D67JsnajXH/FsxrMdLbGEaETazPm3ax3NaX7xMW5ja6MllthK+1ZysdLRMVqslgaItJnztwKLlY6O0WK1NJDtZ/zz+UM+fzhJnz/g2Sx+jma4X+sn0V63mXR0jBYjN0CknP/z84e5zx/iCwGSKO6CfuGtBcssl30KnYFJUEXyjk10GNUOtzjUSYma7dstfsafksGiYWliwCWQQmeo+SRrjph5l/mX4y/nn5x/aSKgaaWbLcRwUNYfPMzg2VNnPpL0W1U5/nP85/g/+OOfzrBNcHn9Q/N9Xv9pShzb/Me/q8sLSlxX8JeMkmiSerKDKpJ3XPTY2pdKsEP9Ui8fkzMwB6pI3h289qU/XG9wv9gHFyfB+cupS7+enP2f58+jGkMdCa+2k2H8Z/9rX2vPn9j9j3u2mr30ot0GTWo8oy9s7nQPwvnzeN1P99/+25C4B1Z9cJPxz/X3ZLz+zPVH5+Yc/zn+Nzv+19fWeTXhgImwdWWfrX9L3xqrGa/HnuNfo3FQxr++EKBnY/3MIJqc5mAosB0FdUG6OqLJaQ46+vYg6oJ0tUST0xx09O1B1AXpaokmpzno6NuDqAvS1RJNTnPQ0bcHURekqyWanOago28Poi5IV0s0Oc1BR98eRF2QrpZocpqDjr49iLogXS3R5DQHHX17EHVBulqiyWkOOvr2IOqCdLVEk9McdPTtQdQF6WqJJqc56Ojbg6gL0tUSTU5z0NG3B1EXpKslmpzmoKNvD6IuSFdLNDnNQUffHkRdkK6WaHKag44+QH241D62CR8UgI26IGEnGU1Oc9DRtwdRF6SrJZqc5qCjbw+iLkhXSzQ5zUFH3x5EXZCulmhymoOOvj2IuiBdLdHkNAcdfXsQdUG6WqLJaQ46+vYg6oJ0tUST0xx09O1B1AXpaokmpzno6NuDqAvS1RJNTnPQ0bcHURekqyWanOago28Poi5IV0s0Oc1BR98eRF2QrpZocpqDjr49iLogXS3R1DT70KItLeODclfPSohqIR05mpzmoKNvD6IuSFdLNDnNQUffHkRdkK6WaHKag0y3/mBM/9htD5gIr9xQF6QjR5PTHHT07UHUBelqiSanOejo24OoC9LVEk1Oc9DRtwdRF6SrJZqc5qCjbw+iLkhXSzQ5zUFH3x5EXZCulmhymoOOvj2IuiBdLdHkNAcdfXsQdUG6WqLJaQ46+vYg6oJ0tUST0xx09O1B1AXpaokmpzno6NuDqAvS1RJNTnPQ0bcHUVeVfi7nCts8DiIb6R9P9DuxoS5IV2c0Oc1BR98eRF2QrpZocpqDjr49iLogXS1s4hcCZKsLq/THDNcV2xpEXZCudDQ5zUFH3x5EXZCulmhymoOOvj2IuiBdLdHkNAcdfXsQdUG6WqLJaQ46+vYg6oJ0tUST0xx09O1B1AXpaokmpzno6NuDqAvS1RJNTnPQ0bcHURekqyWanOago28Poi5IV0s0Oc1BR98eRF2QrpZocpqDjr49iLogXS3R5DQHHX17EHVBulqiyWkOOvqWIK/zuFfjguNPufbLvGvUwS01OkdGXZCOE01Oc9DRtwdRF6SrJZqc5qCjbw+iLkhXSzQ5zUFH3x5EXZCulmhymoOOvj2IuiCplvgNAVatY8A2YxKX2J3ToAG7hm2WPuHRCKRnVtuMKdunCEhcXHAMGsj4U5gwAddLfItJza5OtNiZY8YkPrE7p0ED1lazZP77WFiMDcx4Z0wZf4qAxMUFx6CBzD8K08k2/vWvG2xACWi/9ZzzTxsdMUaqzXhnTMIVu3MaNJDjjwJ1so0/P8KQCZCcNx5LHoXdjHfGJEXE7pwGDVhbzZLt+1iE0LegRvNSAbE7p0EDByr+/cMMHtnTdIRiVa+s7bQNHKjzj0lBmpxmO1c72QYMOZbZhvrE4JmVMWNizxr9tQn/ZQq7sekHSa0AECTzPEa5Jme8Mybhi905DRqwtpol2/exaHEHmvHOmDL+FAGJiwuOQQOZfxSmvP6Kc07LDow5L2e8MyYpIXbnNGhg0/nn11buL/umF26oVSfN2k7szmnQgBVtluXqtF7PrC3NmMQjduc0aOCEbd+/oDH0BzrgAJ8/TrH1c7CokudPk2vLdUv2Bgw5ltlmIkomz6yMGZN4xO6cBg1Ybc0y24I7FM/M9lucXYgAJVQuXgYNZPwpVnn90cacrCsICMWmvfgXkgqKypZOM3bnNGgg848ihnCz5K1FR/W4n/HOmKSM2J3ToAFrq1n2b/v0QgBddtL3NOFlSH/QCBJskGwHhgR3lJ7hMZj0MCPbz/jXkTqfIcsDeo6PzFLpGR6DlfmX4y/nv5z/x9mizRAn3vyjD5fiRwX8kwF6Jjgzljn/5fyX81/OfzonzF8hnXjzX5vh/Bl5DEbOf1uZ/+yv5hA+kuMDDee0O0W2Zfx3ev3VDy3wuEPjHvvDx9xj9FHm/1byv3+gNBdRRLb2Bom+lGdk/DP+ef2V1180S3AQ+F/9rXrM45hjIHn2AIb0M0rEnuExWDn/LM0/eq2jXwTNH/pubPAPHumGSEIimqP0DI/BzPgvxb9FSFdQHz1gSHBH6Rkeg5nxz/jn+pvrr84H8zPEzs4/es+G+Yde/ON1pS4se9F+a5lRzn85/7X5z31DQE1FET4tvV0TSIdHTKvNalYzgfB7UbjEFYKxJGGlPTMZ2GyTgWelCWT7vidrZERYlDL+IS85lXxsQmptSrHSBDL/Mv9wg2l5JQliWdLyzUwGNpVvPclKE8j8O7j5pw+XWvpwZ/MLAdn/tc8z/3P80+Sb8y9WiDoziLBZok0gZjKAgluSVppArj8nXv7xuiJjhnb1c4ujvBAQ0yP7f2fXH/QHx1U3Xeeh9TLjv7Px7+N7ND3jn/GX+ZMSIde/E2/9o16jId6uGo823nu/lZ7pf/62F7/pCwG1hC+4S+3LeUk71hgdzsnb/tp662f+I3D9xgYfG99bm8NWmkCOfz+SamREWJRO6vzTjPJxYYuPjTK2srfSBDL/Mv/aDOfzzLKk5ZuZDGwl7YxrpQmcrPl3iO6hOQ688YsA/EKAjWsJkOzEH+1s8r5K2YKw0gRO1vhLzuf5z/a/eyEgZpUlDsxdAPlhUHyrxZUAFElvoNAFbJt4uEIQUPkoBwYZfAJn+xn/zD8dNzpW3IgBFJnjL+efnH9PtvVn7RA9XMInNnV5xV+c5PqLCXK87oBlYJAhrz/aDXRef52I118b5TNv+vHy1G/7j+W1H6Wveb/f08pPv/p/lB9/+Bcg7U1m/rdcl6Dk+Jf5b50fknNyyB2dAHlQro846iqL5BGZ15+7ef2JvzbheyEs9/ablBl/StPMv93MP54JdLhj0JuhOjYb/7o2/R//qbz2Y0fKdL/Lyr9/9X+ntelMbkLqyuuvtibl9RfFIiw3x5p/mmbYu9rURIbdzj+83MW9zKOm3a9l/vMks9vxR9+z5P7334bEqXaEBl1NOVlrD1r+8XljOx75j7ZZZvttrpe4HIf8R65n+5qQOv/odcq3PeUXyms/fmdZo3vof0f30D/x8LsRKSxINYk3e/0jUbZd5r9FU2NygPKfXzTjF8y4j2Wtl29u1dPEPvv/4Pb/zOqGbjd5vPrfXggYpi1/x2GH2cDAby5COB3I6oQKaTwu0d22Zvs0IsKS3EW4i1fn1eFkgVYvVMiMP8VFY5z51+VTjr8cfzn/hFnVK8N84Z02r9pEq16okMbb+fVvbe0QtckN6caznLyJymAP2s/1JwRaOwFxh2wdQSjn3/DaUq4/O7/+bLy9/JcnXVqe/ZrPaj6W9XLm9/xe+cBvfGs5J/OPrgT1WlCCk/k3m3/4AJpjxJcHHKbwwYUGj730zyY6sZpqZgPkyvlvO/nn+0ODzP2BnwZq8RUfVEjrEO6pjP924o+YR4kAQ1YvVMiMPwVG59xpelv5r9/0uPLs19LaJFPHevlCWpveT2vTPWNwRRvyNXAQYMjqhAqZ8afA1Pjn+KdIaCw0wShJ9vj+dx3fECD5P7eutiTP/O/WqxYaQhjgkNUJFdJ48+vf+vq6vIQgNK6VL3asqt1vf6/z73jnf7Z/fOefjP8m4j/RPfQ30T00Xafo/c8huof+XbmHbtcpmGAgbdKo1zakS1PNP8znef+55+vvXuV/f8/G60r2f7eeZv4fl/xfo78m4J4IW5um9CIICeztoQApg68zdKoUF9uMw5t4sGT72kE+Lhn/GIEhNp2hUzP/KAISk5nAeFOOv5x/cv498eZf7jN8YIO7EP9AgyfAHP8UGT/ZyaoQr2Vy/sv576DMf9M1zyuXPvJny5voywFsO+Pp5Vc+8Iry/ffhF4h080Mi8z/z3+c//9Ucr4aSIwT4vp1zxOeMZFFn6NRGmXF4U+bf6vxD33BA0S8cs75DfEwl+LQT24zDmzL+q+MfYgmFpQ/iqAoz49+uv6Zrfrxc8sgXxLXpC55efvmGl5cfOPeUFi9B464Ld8a/C0intnjOOLwpx//ejX8/l3MHcewz/nsXf8wqyH/5yQBSZF2lnfzWM0idRBkzd4ZOFZrYZhzelP1//PqfOynjn/HHvMzjcrrmX5fHPfJnyl/TPbQ9X7sbXae8/xXlB9w9dF7/UbB44qybn9OCbcbhTQdx/CGfLA58v+a2g37+OFU5T3+y1eFNB7H/9/P52zcE6EH6rmCL1z2upzRjQhl10d5/z1MtRquszqbQTfYVet3jbF8iMBOSjL8GxfaZf2Fh1ryh6PDVzLD1CeV1j2vBGVPmnwbF9pl/mX/9UNuD9c9fdMqNCw1Z+SphHrp70H7mP6c9ReHAj/+NcvjwRjn9dH1ov1fz/3T4cLnztNPLaf3Yqtesmn93lMO3n1JOPyP+Nuvu5v9GuePwkXLK6afS39/vp/7/bHnnzz6uPPJ5byt38RzAceMglfPK173sTeUvvutLqsEHVKPILPSr4rr3bnOo0fbbzv+p3PGp68t7P3p7PVatER9Hs1a72lpm31T4r6M58vwgi1gbZOVfTxG+Mvgmk74PVowSBrkWIhvbqY7KIqy6xorxqeVu5z2gXHDP07g2c6uCvZax/bbPv2+gHgua6d1mt5YlGjs9/+hfMeoLAGhS4gmlxsyO4oCdv50mg5kugXGvzj/8zrH0uH6ItFfty9iYCcpOtD995oPlPe+/tdwlg1Rr5LHJMWatj7+O237805j9ovPLBeec3o7yhLv+ubV89NoPlE9RILZ+/lQC89+he5UvfdB9y905cPvq/u9z5Z0/d0l5xHPfXvhdNe1H7uH70tr05oW1aex/7WDNE9sf0/xDa/mnbizv/djnKde0xmOKPx2LfBn8ttcfLr/V/KcS6P9Ntn/onueXB593phyrLr4cWT1/jXHdz5jA25n4+wY8Ppjt456tZgmlHL7phc/34J//eI7+nD3em/5Hf9QhR/3Bx+C2mUPCOaiL9sc0//gGPK7HMGPK9jUotj8h4j+Vw3ccKaefxi9l8/yOzXewx9U/Y9pK//M99F2nn053Ndj6Clm/i47tEB0bH5c/NlJ7ulSjRttvM/53HL6jnEr30LreccUzjc2YwDvW9uVUQptc4+fKu+ge+hG4h1YS7eke+qV0D/3d7R56d9rfavzp+uXmG8t1H/+8nAnPRcf/+oNy6b73Lxfe6wyLXgN9h3rd41pixrS7/b/V+NMBzuS/rCtcFR8/C1tX+hPyusdaLqRnNZ0I508nTFNJF0s5/v4cve5xnv9suJxRo0X7mfxbFX95IYAT0i5+kKWY/KVmq16aRFc2a7TU7mqCiVzvbBLogMj2fQw5XlWXILdIO0+dD9THdkwGit2eKRn/zL8cf25QNJjzX87/B2394fPhFYR6Vud+3tuFZ8t9Rpn/mf/bz/+byp9c8fDy5F/7hGbaWReUCy86u5x+++GWf5J3dBHC6w//T1Dyku38sHpjkt/rlMsUuU7hrCQi38ASZ1pnP30ce+sN5e8+UD8gftyLyjv+6gfLw5kvLXEZj1l/a/mlxz+u/NDrqQw1dPr9H1ku/EI6LqJttX0+Fj0+ao2OhRW+1l6n4zvlVLrx/tj7yrs/fpdwTr/iT8otv/rEYh9BSUHaHc/1d+MN5ecv/fryr97izp+Pls7h0Le9vHzof/1T+viFNzlYknyStLFav0aj86ir7oUbsFpkLwVpt6Xzv6O874WPKw/84b+VONedVlrjz4eofRnNcujcHJn9/CcsK1MrCcIpTOb8oxq4n8f271bu/pBHlAc94MLy0Ic+qlxyyVeUS57wVeVRcw86tnX+3Ci3S/+OS/zn25ff1a1hQvz5S+Z0k4Ot2IkDdP58VjUyNdv9OXu8N+d/iMaUhLceF+NhnRcC7bY0/ub7n89qr87/jqueXs795leWWyTfZMfN6wHwOZFps+N/7bxvLFe89H+UX/7H59nxS12027fXP9P15Q+e/U3lu3/9feVWnYT0kBGKLZy/FDzrivLKT/5qubx9AiDm437+R95Q/hOtTT/25ju4N1yCrZVTn/ry8v7/9Qx65B7znA9cU6Amgp4J7Tk43cYUqXfGxx6av+avfz5b3v78x5ZH/tt3EwlBpwKAJDebf3wEslmZWkkQTmHyyvWH/FaX1GyHBaC11TqV4sq4tmrIsVae+k9/u3z05U8r9+IyEl6NsYSRTFySt2aNFvW6vRSk3Qk2/8gZyEm2M2VbPFv16dl6rBbZs3kT+bcmPxlA5NqAvMAtVWq9Ug3VtFvty7FKrzLCQTA8Odvn/vDXfxv1t54z/i1TdFaOEVGv20vi0i7HvwtKg9N0U/nT7394edKvfZKMFKezH1AuvPAedA99Bw09vf/ltUDCSAwJIym8JPH9p87bPGIr5u7gcIugvVyf0z00vW9w2m10D/3+27XM415Yrn7dD5aLF9c/roDuof+3S8oPve5OUtbLafd/RLmI7qG5/q22LwdOh6NrZj2uev9/+mn0hwUfu7686+PUDrlOf069h+aT3i/zz8Yby89f8oTyXLqH5vPn48T6f8plrygf/J1n0D00GfuNudIhMz72rIw/EbZ9/oflHvoiuoe2zY6Zj4UOLAincIFdv/44o5xF99AXnn9hefjFjypfTffQX0330I++Fz854WOhbT/1vx4RjqymQE2EdrCV5UTX/3wPjWstrmzjyAYNjXq+UiuXPbjn7yIjcPfyv7bUxT/bjxHw8ddvCOgGncw/XAY5GsvPahJzFAnKSB/c2T7FWoLQ5j8OW8Z/TJ4FS8ipoIwFBreEXnYZf067IUBjDHtLKBKUnqlrPFstvSX0ssv4c1yOEr8xol1Mj1J+cEvoZZfxPyDxl78c5AGm3SqSF37edJ/jL+cfSYeaI9sd/58sr77iYfQw46ZaGYuaeF3+OYJAdXdclPVkoqzJAxHNXCnx+F8qV//V/1UeVnkhp035W30h4A31Bt7XSfiY2ufSPFHLTTOHEI3Sw4xnv7rc8uJvKqdzAzMbmOZmwy5f/23QVx1eSl916H8uwM7/jG8vv/LBl5fvv/cpOl0MBzhzEp0pFAlKRyR1cLNhOH96IeBFl5SLfvit0lFD/6+IvxTgVvQEm+wOxc7fc62QIxNxc+3fo5z7hKeUp33b08szn/H15TH3tldCXGWbPX+OSSi2UgkxDcpYbHCzYYg/28ay4UWzmv/8l4yhzqCMdQzuLbQ/1qaWUGdQxhKD+wRuXz+0iPOPfRPQTP9xNE6U87/jT7693Oebf7vcuunxh77mE6ezrAJy7RFXlj9785Xl6+rEbOHZp/1/5O9/pDz2K36x/D39ofDm5p/V51/4hYBP/Gp5Wv2Ck/1y/htX09r0KFqb4lfX6MnQ1/H+Cn0dr/9JG5yllyGng+JZigf3Yv9/gl52fFh58kvoZcf++oOTqs5/mmaoldtQC4TJ7lCU1XHnyETZ0/b5gyJ62fJhfGib3HD2UiQoYwWDmw2bXH/G2tQS6gzKWGJw75P29YWAmg902LhfG89gtIRzCspRuOzeJ+fP48YOhY/rOOefffsOHQePP7wQwIfWbyHkQemZJ876e7zjf/K0T+vMD1xcnvxifiGgjX/LnJp/uMdUhhgpmfCHH0g6LlXrqAKq1VfB2uP1pfqH2aCbG3/0QsDXXFr+5evuoLGpbexY+3Qc/oNRrV5rl3voX6N76P6gF3ScPZeuh7k4fwQu+JtYf/jnAi6he+g309cYyXH79f9u395+NmBoIB704GbDJtqPtUQt1GkKvxBwabnoR+geGjZXzPqRnarwgdC/jkymvbv+OKec+3XfWp72VLqH/k66h5aXA9xBL0AcMR+9Hb4oY4HABX9X4j+2zRZ8+K+RpjG3IRf47JFDl0MRIu82t4VzCspYfnCzYQ/PP9vXPrH03EfxX6O/7qAlxW9ydNXguq6avZdJqi84US25J0o4XbpaKS7trUr3LTDmjY5woQk1Lzi1sJTN9n2ka7wy/pl/blTqcEFusMaYtxx/Of+ENJCs4J1mS80ZnzrGUFLOv3s7/8pFJy/sfgjTX2Lrho7K9df3SowNa4hXzn/L898n6IUAepghf92gEbR9l398zyERZTttpovCMSavLyOsbkdvUstfTdDDDH5ofTHXs3Rw8g0Bl9I3BNALAVSvtbcT7XeH5VX+64ZbX/zEUj93kZM+vvPfZ8s19JXMX/68d7SfC+C4oT/Kvctjfu0N5S3PfmCLpZyQ9BYzteOasNNlxnL8K43boca2dv3PDzP4hYC/s7YEoP+jdV7jfnanYOe7y/0vB3PWg8ujv+M55Xk/+j3l8geevY3z51rcwWugkenSBBi7E3/UzrJ1/No6/dUcjVMcmbDw1cb1GNkWNrJvvf+5BrTS2u+bUL1aeycOguwHtX08XMKpStTqi39mO0HP/46rLqcXAn6n3GonQuCYxv8F5X///TeUVz3lXK6I/u3n65+byp//0KPLN/zSh/3ZH9v53/2K8lv0QsDlp2Gg7Ifz56/hvbQ84l+/oxyZXf/vVR7zYl6bHiR/YIgjR1BUr9be6UjbG/83lt/5zkeVy3/zH1DTscWfjo8PUVKPBXSx8RxHBk1Ltsxvx5T/m2z/ET9d3vDWnyiX0Dcz6Zbzr3RcC4P1DUdop9bf/p5NfzKAm2oNa3vWfD2sau2doJF9e/nPFfJ2crbfr638gkYfYtWrtXdq8GTQZfy3ev3PweOA8nbQ849eCKBvCHjyi+mlejpVO2059263k/M/vfj19r/6IfqWPb/5JGaMb9mje2jedrJ9qh49rIs7afX85RsC+KV6bVSJLQ3Eyjsuv1Pzr1aqNTbMiBumn9z7uUvLl9F1CuYB5WBP99C/+vrylivoOgUmSKry+Iz/+kKAvVSv8cIB7tvrD+4C3s56UHnM059Tnvt/P7M8je6hKfVqf6ub93vX/9TYDrWPF80Q//ji31L+7Vz7iBpLPytzPJsPmGU7cX90YOzN+AuHwU3LdiL2f4vx/os/PdvhTwlql/a9HYJelW2IUC0rvNmsqV7ZB6LSeL9gboSjoFCeFd6yfY2Dn1JDoKqbxIK5EY6CQvmMv0Yr869mjWaH7EOitKRaMDfCUVAozwpvGX+NQ45/SQbJkZAoNTwkFsyNcBQUyrPC2y7nHx5mcDNoUi48oexy+3KOdXc8zj/bbxHY3fjfVT7z0feVD3xKvy6fW11fP1I+R7YP3vqZcusNbytve+NV5X/+7jvLR+jNes1Hn5XtOBmp55zyxU+6vDzlcY8qj/qyLyp3P/Xe5aILzilnbByRZ+ZS4szzygPPv2f70D1WU7Xby6dvvKF8+LP0lWzVcsr67eWT199Ybr7zH8rHr/7b8jev+8PyP1/9QfvQqR0Zf3xNF+xyF8q3TbTRblr/0nLxUy8rT7z0keXR9797OeMe55eH/KMz6lc3aiPr59y/POR+X2ht7m7864mtENORPyv/9qFPKs9/711yTHo2mAi04No/fkl596v/RXkQfYVjv4Xj752b0EN5NIsOWbH+3Pmp68t7PkZfb0ll1om3Rh9QHPnUDeU9H/9MOXzTNeUdb/mz8ge/86Zyza1zZ6QH1vrzzHKfJ11RfvS7vqY89Hz6WYt7kEecenSypx0eOrAT/c/tn75xU7nu2k+UO2//ULn2nVeXq9/+1+V1f/mucv1nyMnlqDkSw7Z2iPLlmc8r//GnnlmedB493gKJC8jGhhPn/gvrSj14OXH7i3QzRqBnWG0n+PnHM9uctpvnLw+XqAGff/EBk6ZcSDc+7GDYp/n3GRprH7i13Ennx+Ofj/mUz32oXH3jLaXc+t7y9rf9ZXntb/95ef1HMa+N/eHjQj+OUr7gGb9ZrnvF5eW8/X7+t7ysPOuif15+4+ZzywMfeEe57j2f1rHGyeS3eoJr5W7lrK96Srns67+6PObLzy/3OXRW+eKHfVE5+8idxX6J/JR7li994Hnl7lxmv5z/kdeWKx/6ZFmb+LTq6QjC/Lv2DS8p1/7p95UH2jEzc/Mbh8yKIn7BsJT//NeR9JNDr7tdy1MZXgvCxvVMh8oZ939MedSXP7xc/LCLypd+EV0TnEu/fzx9YTn3IQ8o91rX/ORy+hCYfgrhlFvKh9/5wfKpW64uf/2ql5aXvOr95Tb2c3VMJITz50blcNfOLPd+4hXlR777ceXC08+W/j1rg75imQq0cvTTSoduLR++5kPlZiq3fssN5b0f+kC58V3vLO/++7eW1117K70U6NnSmO3EU79J4vL6RiMfj7RvrK2BUF5PzlWoXtkHYmtjwdwIR0GhPCu82QmpV/aBqDTeL5gb4SgolGeFt5n2+auEJf6VgBcCQnnxbW0Xyq9on3OzHVdrY8HcCEdBofwJ1L58tbO7/m8/jXSUE+7cJ+r54zTC8cO4BRnKn0D9j1MMxw/jFmQoP3v+R8ptfA99M83MNAEwZX19g+6hrysfvO2z5R+u//tyzRv/uPzm772rfFi+Rcc1XieMNm/A1+6hv/zh9ytnn3afciHfQ99F99A8yHmw0z30ReefQx+6L61/XNfhcvONN5SPf1Zv3nn9O3To9vKp628oN99xS/mY3EP/UfmtV3+g0FXZsPXHJfr6/cvFlz1V7qEfRffQdzv7/PLg+9I9NH0UZed/z/PLQ887U+rjeHC57W6hPCu8WYXqlX0gKo33YuZ76IufVH7qPV0H1BNkwdcp73oN3UNb3VpHqJYV3oyjXtkHotJ4v2BuhEU0lTvpfvnaj37emuPr6COfvrG856bbyuFP0D30m+ke+rfpHvo2bkUPC2j5+uNrysXnP6BcdDbV5s5fy8WDYTeuP0/d+ER537voHvrwh8u173pHufoddA/9/72zXM8XPnWr1ZHmrn/Wv6R8Gd1D//zzn1meeN/NfmcEauzih4Pck/jrMXCTvjl+qV6PqvppUAknENXH+wVzIxwFhfKs8OYPiBThBKLSeL9gboSjoFCeFd6yfY1Dja7EKASqukksmBvhKCiUZ4W3pfjTwwPd+KsClraN6iSxijZXvPHpC5fmCLCtcmb7GiWK0aowIZReNn7Gv8XCR6jiVc7MPw0SxWhVmGai6viZfytjt8qZ+Zf5xxHYwvijJZ+X/vpPHvW4sTgzUjP/ZoJSTTn+NBBbyD8EU9Pqrum2q18wXXY/+ZMzl5ean3Rt2mynXDo9808/ON2OCljuavw/N330Nf9i+kr9tvx2HPWYwrGd9x3TC67+9Opx5I+bD93047f+3fmmH5gezOej933z53jKP5lecMNhO9oAdjX+taUWqNC0KIvtb0yHP/zK6V899gw6J53jZM4bzpO+8PArfnp63eEVjaxwLebf4Y9M17z6V6b/8MzHThfe3eX2TPvl7K+envbrfzPdtNTOkp0DsHj+Y6h6S6t2Z/KvX1NYX7XtdPutvlWtNl/j78z5t/paG6tQ4+9O+0frj91uf9W5s2+329+47XXTf/6Wc9r4//InTF//pW4syjxe5wYel6cuzHPtQMdT2vPxd+f0iVd+83QOHfval3zv9Is/+Yhhzg7zXblgesKL/376h/HIdz3+M00GUwvrfP7f+abvnx4ifeSuAZwu6+8p36JrE1XW6gvNLCqNP9++FWxEM00bfzn99CNOnYk9HyutKff7uulp/+6l06vecVO8Xmk1uONd0f7Gu6dXPPWes+2E648HPm+66va5A3UNdrCxuf07p9ve/xfT7/3n752e+tC7WXuhDY79md89/fqn6fsasO15/qPhKk+S9ttcrmPBonCSnL+dbw+O0/lzf/ixwYO5jaf+IOf1xl8x/rloI44VHafztwPJ9jUUx7X/ae5+x89Ml52Haxt3vyPrpdNPu3R6Vr2Hbmm1m/n3uekjr3n29JWn1jV87v6Hj5Ht9/uO6Wfm7qHbgVraGdgH+cfXKXIPLbHm83TxRvxnri3bae1m/C1SAzh6+xvTHR+he+jH8D107T8n/fy39hX/fnrdMV1/DIc3TXQP/U66h37B9/A9dB/TOP+Wsy+ZnvZfV9xDz1R/9POvhRpxrGWH86+PszS4h+2PJ0iWbH82LNo3NTgkVoVproLG36/jvx51PVD6XaSFTQbBond1YLgY/s1WX+slUdHIyvZrEMfQsGUxbnAyYZFUHSSWKexZ9K7w1GIri9d6SSy2kP2f8V/OjhWezD8JTo6/VZMLJYnmyUGdf/SiExfY/Atg/oObetYkDur52xjQnu72ef4SkD3t/1umN//EhXrTueKBwSmXvWL6CB/cnq7/76MH8mfZB+b+Jhg3b/QXmNN5/88b6ZG6bovjRo6dj7/+U3q338v847hfFB5sji8G8Dxx7+kxv3ZtO849jX9r1tCm279zuull3zDdzT3EQJ+1hzZr0xnP+RP3oc1Ox59eTPjon08ve+4TpoeFhxpx/qU/yZnu8+SfnV71kc/radJh1COx0zaw6fO3Eg1wpfjXrA7VVklU5HwVLrTPse3Hx1AYbS9XrkW20T7aWqyaCSdR+y3X28O8k+n8ubvDw9rH/4fplT/1UPqbbf/QVq9/NFZnTQ/62bdO8nHnfs2/jbdNL/mGL6A5+Yzpvj/2munqX3x0GHP9+CsP/snpL+7iSNTthMn/W6Y3yTVBnSfrdcFwfrQ2PfbF14a5ak/G/+Hfmq44S8eVP6a1cu500ff9xvT6m3E1gMBvN/6Hp+uoj7Eu+7YwvtlGX6Nsa9gxn//t75quuvJrpgcccuPE4v+N05Xv4Vcyl1tZ9tRiTFgkVQeJZQp7Fr0rPCdu+33/n2znTz3XtoXrDxCWM4MYSJ1FUnWQWKbI7+vZh2Q8/vy2WI5J7MQ/X8hwLU2iIvMY2Afnv+Lolo+bTwDnvnxyepp5/stxnO1/vYeeWx+wTrA85al0D40+sITyoHbMjsb/uukV30b30HLdhWvR/v4H99C70b47P5x7bcZ5Ktxq+7dMb8GzCzq/5fjTPTRfp+x4+4tnMDrYsuX279J7aFv/0X9N7vj1Rz3O1kV0D/0xuod+3hOmh4d7aD2GFvMzp3PpHvr3PxL+ZCTGYcvnH4uLZp044yNTO+4Z/1HaxzqPsTJTAzWASma9x9S+HT01sXge2f7KXl6MG3cXum6RVB0klinsWfSu8Bxb+3SV4xp1kM+Lt2iqGoyQSnV7dcANaYRgcIqD4EZT1WCEBNmkOuCG7NxVdV4HwY2mqsEICbJJdcAN2bmr6rwOghtNVYMREmST6oAbsnNX1XkdBDeaqgYjJMgm1QE3ZOeuqvM6CG40VQ1GSJBNqgNuyM5dVed1ENxoqhqMkCCbVAfckJ27qs7rILjRVDUYIUE2qQ64ITt3VZ3XQXCjqWowQoJsUh1wQ3buqjqvg+BGU9VghATZpDrghuzcVXVeB8GNpqrBCAmySXXADdm5q+q8DoIbTVWDERJkk+qAG7JzV9V5HQQ3mqoGIyTIJtUBN2TnrqrzOghuNFUNRkiQTaoDbsjOXVXndRDcaKoajJAgm1QH3JCdu6rO6yC40VQ1GCFBNtkeZrQLafdAI5RzioOoKpqqBiMkyCbVATdk566q8zoIbjRVDUZIkE2qA27Izl1V53UQ3GiqGoyQIJtUB9yQnbuqzusguNFUNRghQTapDrghO3dVnddBcKOpajBCgmxSHXCrvJ0eej+mPjCgBwVr8UMA3Byd5h56c3WoQ6uuGoyQ1i6AOuCGhDdWyt6bpquec5/hYQZ9faGznTVd/MKrtQpUCGkVA6gDbkh4x/arZyDuwPnf9drp3zzwlBZ3eWAzH//1b3jJdG13DFGtGoyQdmIA6oAbEt6dPv87//JZ0/3dgyjfbzr/cd9dY83vdPu+4sMf+aPpRc84fzqrHo+ff/GCwtoFz5iu/Oub6mG46DiIOqOpajBCgmxSHXBDdu6qOq+D4EbTBj0Mw0O+NjbAbVJLoSyk+YPBKQ6CG01VgxESZJPqgBuyc1fVeR0EN5qqBiMkyCbVATdk566q8zoIbjRVDUaSmDe9xKzhaKhOJRyiOcVBFIimqsEICbJJdcAN2bmr6rwOghtNVYMR8sYXTN8oH2xSTj7+RdN7rnnu9FVVnx1/j/zp6fX2B9CohFp0cEvtg2xSK0J1kJ27qs5b4ZGrn0fHTy8xnPJ103Ov/gf9sNjmk3H8rX/Lf5tutMoZaEWoGdIoweAUB8GNpqrBCAmySXXADdm5p4nWpp980KHZHJa/wHfrL/2kDa1NtSZUCGkVA6gDbkh4Yz87r4PC/dzLpu/5wjbP8RhbK/edHv7jfz59jLk9v2sAbsjOXVX2Hpk+/VtPnugLkl0sqP/d+fPLZPd//t9ok6gQ0ioGUAfckPC24751eu/L/sl0IcaOtf+10/Ou0W8LimWrBiOkVQygDrgh4W3ts8V5HQQ3mqoGIyTIJtUBN2TnrqrzOghuNFUNRkiQTaoDbsjOXdXm9XM45z9vzes0GCGF6XfqgBvSGMHgFAfBjaaqwQgJskl1wA3ZuavqvA6CG01VgxESZJPqgBuyc1fVeR1kZxx/fP9cCeBB1pqaUAfckOYPBqc4CG40VQ1GSJBNqgNuyM5dVed1ENxoqhqMkCCbVAfckJ27qs7rILjRVDUYIUE2qQ64ITt3VZ3XQXCjqWowQoJsUh1wQ3buqjqvg+BG0+en99k9tF8rIj7jiqvkxTGUhUSdSGPVnddBcKOpajBCCrndQ/txE6+/ztb7sFDOKQ5uvX2UYKkVoTpIYwSDUxwEV0zuHnru/sfP2+t0nfKenW4fB4OOw3FCmh9AHXBDwotqVFdvfw/dX3+VslfPP+jFALqHfuF3XDCdHa5/NMcR/7ULv2O68g0fi6fSnSDOG7JzV9V5HQQ3mqoGIyTIJtUBNyTc8hzAPf+Cfe5kYtmqwQhpFQCoA25IeGM7zusguNFUNRghQTapDrghO3dVnddBcKOpajBCgmxSHXBDdu6qOq+D4EZT1WCEBNmkOuCG7NxVdV4HwY2mqsEICbJJdcAN2bmr6rwE2zcEwA5ppUeglGXi6OktTTcEADk2axalLBNHT29puiEASGttBEpZJo6e3tJ0QwCQY7NmUcoycfT0lqYbAoC01kaglGXi6OktTTcEADk2axalLBNHT29puiEASGttBEpZJo6e3tJ0QwCQY7NmUcoycfT0lqYbAoC01kaglGXi6OktTTcEADk2axalLBNHT29puiEASGttBEpZJo6e3tJ0QwCQY7NmUcoycfT0lqYbAoC01kaglGXi6OktTTcEADk2axalLBNHT29puiEASGttBEpZJo6e3tJ0QwCQY7NmUcoykT3yFmp3QW0VuCtCqwUAspEHpJRl4ujpLU03BAA5tNoMSlkmjp7e0nRDAJCtuQEpZZk4enpL0w0BQA6tNoNSlomjp7c03RAAZGtuQEpZJo4etRz+48vtg9J2E+0+4Fijm85fdB/cDi2rYbvtt+raESqilxV+of2FHo5NH2bgr0svmC7/409JFTvfPlWLQ4JsBzugrbQf/nrWHvj7B0gu/qc9cbry3fWv14dWm2Er7Wup/qSabggAsjU3IKU44nuvnB7fnxvPfTb/3T2+EGDBbmE3k6t2aLgahvY74sbGJ6drXvaM6Svv4WLbH989njB97x9dP30OZdEuJOwz8qjtD2X6SptuCAByqEMNGBsiKb78gKbfxip6S9MNAUD2lTpdKcvE0dNbmm4IANK110OlLBNHT29puiEAyL5RpytF93hA5vtlrKK3NN0QAKRrr4dKWSaOnt7SdEMAkH2jTleKIx5+pf0lN78QcM3G26eXfOOZbvz7+Y7xxdN3/Zmfy6lyVAfp2uvh0H5HGKvoLU03BLDRvknn0Ne+aHr7kTvoQwBam/r5g/U6/vxfjvOhoKp2WL2l6YYAIFvhASllmTh6eovqvDY9yL9gZPO19ldYf0+ltelaXZu0dF9nO8zR01uabggAkqt775XT4+j42ocaZ073fc4f6l9fzkQZR+CrUFtvaTrQ4T+ia6NV5y8P5PXaSMugJFptcvT0lqZvTLdOV//CJdM9aj5pnrVrnVZrQ1q61dE8ikZPb2m6IQDIvlKnK2WZOHp6S9MNAUC69nqolGXi6OktTTdEoF2vaP737ULXMlYSZpOjp7c03RAApNU2AqUsE0dPb2m6IQDIsVmzKGWZOHp6S9MNAUBSa2H+ofGBTSmOCEeVo6e3NN0QAGRXp1eVskwcPb2l6YYAIH2DHVbKMnH09JamGwKA7Nr0qlKWiaOntzTdEACkb7DDSlkmjp7e0nRDAJBdm1D5HvruuBao63+8NjhreugL3wl6lX2lTTcEANnV4FWl9ER+4d9dp/Ba1q1nhX7aSO+hW1lDAJC+wQ4rZZk4enpL0w0BQLo278JP7iHukHPxp+uUn7y2/+v1vtKmGwKAdO33UCnLxNHTW5pu6D10D931V5z/2kv1WsZK9oc3c2XUc5tuCMDkJ6d3vvQZ01ecve6uv3RdtHw/5wnT9/3RDVP/xAJVtAPrLU03BADZCg9IKcvE0RMtdvySR/X+GRTIodVmUMoycfT0lqYbAoBszQ1IKcvE0dNbmm4IAHJotRmUskwcPb2l6YYAIFtzA1LKMnH09JamGwKAHFptBqUsE0dPb2m6oQraVY61BwpLhx0EFSbVoUGCFaV5BZjmSLCxdNhBkGFSHRokWFGaV4BpjgQbS4cdBBkm1aFBghWleQWY5kiwsXTYQZBhUh0aJFhRmleAaY4EG0uHHQQZJtWhQYIVpXkFmOZIsLF02EGQYVIdGiRYUZpXgGmOBBtLhx0EGSbVoUGCFaV5BZjmSLCxdNhBkGFSHRokWFGaV4BpjgQbS4cdBBkm1aFBghWleQWY5kiwsXTYQZBhUh0aJFhRmleAaY4EG0uHHQQZJtWhQYIVpXkFmOZIsLF02EGQYVIdGiRYUZpXgGmOBBtLhx0EGSbVoUGCFaV5BZjmSLCxdNhBkGFSHRokWFGaV4BpjgQbS4cdBBkm1aFBghWleQWY5kiwsXTYQZBhUh2aynjR2R4wgaVVm4YqY5vH0L6rMEBrUYBpjgMbS4cdBBkm1aFBghWleQWY5kiwsXTYQZBhUh0aJFhRmleAaY4EG0uHHQQZJtWhQYIVpXkFmOZIsLF02EGQYVIdGiRYTeJhhv8LAslTuxE9a3oY/gpf2kZdJB1EjTBttn3mWRkB0NrDjPbwv7v5xMMMFPF1yQHAASnGYWdeAaY5HmwsHXYQZJhUhwbJ1pumP/vBLx4+TFoV/wfj67T3NP44I5Y4fpYOOwg2TNN1My8E4KGNyP5hBqq2GlAlHFXCT9JBkGFSHRrkndPNb7hyuuwB429QW/wPPXR60kvf1T3QQHmWDju4ufbBihLVaNWmORJsLB2uEPkNMD4AAEAASURBVOO1jRO8EOC4rrYegrXd9u2Q3NFpG6gZsm85sg5K+/rXJnGumj/zg3n+clZ3+BcCXjhdPd01feKV3zydE+aAFqO1tUPTmf/nq6abfTJZ0JA/LB12EFSYVIcGCVaU5hVgWiN97nenf/kl/DvB506X/r/X0RHw2vSoOIfLg2icz9p0+hX8VfKoC7JV6ZF5BZjmKLCxdNhBkGFSHRokWFGad4PXpi/S87L1f9XX8fJPPfzddMQqaEe3vfa5lKvMDhM2+s1P+qaJr/Q5dM53Tr/yofYzAWDuRPt4WbLNq+hfyLqGuUYddOcSrXZaFZhXQNUOv3r6N192mvSFtn//6Vt//+OxThSEdF6tGg7I2mAnzCvANMeCjaXDDoIMk+rQIMGK0rwCTHMk2Fg67CDIMKkODRKsKM0rwDQh8drq+3+v2x/PA8dH0kGcEUxjOTBGaWUEmOaIsLF02EGQYVIdGiRYUZpXgGmOBFv7lj3cSwsJblIcdFq0uopjcaHNcWFj6bCDqBMm1aFBghWleQWY5kiwsXTYQZBhUh0aJFhRmleAaY4EG0uHHQQZJtWhQYIVpXkFmOZIsLF02EGQYVIdGiRYUZpXgGmOBBtLhyvEi2NtnqCXjt36WUr/8rOr2tWoVaN+z4GNpcMOgg2T6p+PLwT4ddPwBdPT/vhmpUvhWINzEGQf/CQdVF4zjeXAGCWq0fpMc0TYWPI/d52C8+iuv/r483UKanEVCzS7ANMcDTaWDjsIMkyqQ4MEK0rzCjBNXn7kl+pbXuG6A3IXrz/CIeKYWB6ebn4j30PjGw7rsfj4H3rY9KSX8T20LxcqDApYSjfNcWBj6bCDIMOkOjRIsKJkr93/13waGWxhJuoi6SD4MKkODRKsKM0rwDRHgo2lww6CDJPq0CDBitK8AkxzJNhYOuwgyDCpDg0SrCjNK8A0R4KNpcMOggyT6tAgwYrSvAJMcyTYWDrsIMgwqQ4NEqwozSvANCOtcZv6kjZNBSs2vlsYGbBCxgqoFfpmWC410X/0twxwE51nHtGl6Hx50FnOM2CF9CWoTLaf8c/8k9GT4y/nn5x/6/pAy8VBX3/W1qm3eVmkjftdrvTlGQcrB//8S7m93HzDe8qNN7yvfOQjN5S3ve/WcpfEg+NC1yO0LqytnVXOfegF5R/d54vLQx7ykHLxeWe2axQOnNu4qI0fs8MKaQ4Bef0Rr//uvOrby32++XfKrbiak8RkDncJK3cvF7/ojeWaH7w4BpK0hQiTRyqpMhbbfPxvL+974ePLRT/8t22wWIvcMm8XlMv/+G/KK59MHzPZhqOCNIeAzbc/X97XNs+AFdKXoJh97vfKjzzkaeVFH9ygfL9bucc56+W2T32uHMG5DfGnvvjqnytvfv2Plceud3WRyvS4oV3IzrtX19/XXVm+5oHPL6/jMU1t8ibppJCO++7lIS/66/JO5BXZ92b+3yh3XvfL5VlP/NHy8hvv0iT2+coBXXt0+Wev+cPy37/+vjPxlVOR3UKEuQL6t+Ddhfjr/RwfEtql1qeNqrO9bcc9/3fh/NvZMULcITvvHrS/tuYGas1/vqWXo9uD9lsezMwOe9X+Ha8s33+fp5cX30bj/3EvLFf/1Q+Wi299WXnmBf+s/Leb6xFaulZwzj8vv/7e3yjPuifFT77IYzx+35sLPUwUVDyW33r+b5Rb/+CycuFTXlU+ee9nlZdd91/Kd519B61Nl9La9FZ/OK7dUk5/zlXllhc/qZzeMbbefleBU3f8/G9/Fa1Nl5UXfuAIrf9nlLPPOYXWps+UIxJOH1PNZT6Uta/6ufKWN/xYeYylPI4K0h0wwWM9/zuuejpdr7ySrld4u1u5749dVa7/ua8lhA3tQsKu8v9n70vgNCuqe7+ehUVkUxZBA4FRERAwoBhFBQVFjIoRcEOioIkDPlE0JsYFcHnBJWFJBGMi5smgeSyJgIHRF3BBBTdABVQYFFQWBVFgFKYHpuudpf6nzqm639fLfN3TM3T/fn3PWufUObfurar73Vs1Gf8rl75KffWNf5PeLqfS2OitfmwEv4BT9T/au/3TL+w9/g1f7T0g/jclX1cEX308kEN/rqbqv9u6t9atAS6gL7H6599b6+OBVIYXv/St7vxz+8HfTPiHry74cPSvfas7B+58aI6QFcCYuclc/9qOYnlP9fFAKsNrf96f4qO9395yY+/mn93Uu/X2W3rX3XRv70FTYr887tust9WuO/S2evR2vZ133qm3K82h8bf2x49IykivcBjDWQGspNMw/lkpc+jzqE/CeXc+ZfxHc2jqJ66jfmJm88/jlH16T+A5NP3F+RdonkNf1Tv3hZvN0PwrPn/gjMkfna4Jz/8euKB33E40TqE5NI8BNqPx4vLf/oHm0P3yTz5pnPKdK9/Z25Pax1rz+9dNH6A59Ik0h6Yw7eT5GKdz/NF9/eBkrVz2z70jD/zr3uduLnefct8jrfl79o740iW9z+y/tZwVLUdhTMP1B9uoW6kH5yr+9fOvbYL0Jb30LLLP/Nlb684QuIC+xOyNn2+bE77+ckh9IiQp2ujE8z/nf0D+qdHaewiMF6J9e0DkHQdo2hZvYEC3psHPMIiNMKTSbklozvnX3CAPlikkyBgRCWIjDInKHRQ04RfQVKFgjIgEsRGGROUOCprwC2iqUDBGRILYCEOicgcFTfgFNFUoGCMiQWyEIVG5g4Im/AKaKhSMEZEgNsKQqNxBQRN+AU0VCsaISBAbYUhU7qCgCb+ApgoFY0QkiI0wJCp3UNCEX0BThYIxIhLERhgSlTsoaMIvoKlCwRgRCWIjDInKHRQ04RfQVKFgjIgEsRGGROUOCprwC2iqUDBGRILYCEOicgcFTfgFNFUoGCMiQWyEIVG5g4Im/DKkkZL9889kTPf7Q3mRG2FIv2LGh6b3b0JGoBCYhQhiIwwpin0w0aSldm+76sL0mY8cnd7woj3SzluXt4oRPw0ZXU4Krrman9bffu/0jJe9Nf31GZ9PX77hN7IPXx+XgY2artH4qUaz3f9Kt2WAPxelrdJb6LZlALIaUt1JQHPq8ZcVArgudd2UpuUOl+oy03UlVt+/swhj4100HUVi/GPp/kuPSNtJPHT9z98vve/sY/vsre2uhXn7pb+7jheyt4o4T90oNKN/pwsFx/JoEBthiFftxMdshQC9z5X2pHGN9PLelZ2lq0jNrSF9ShU2NLvjpz0Rrz0xvWBTv/R01cY2OzC96+p71SCMzdL8+9zqdSHvlEvdu+MnkcVUcuaxIDbCEK/aiUPz4eifHojQU0dcv9r+kQdLFhJkjIgEsRGGROUOCprwC2iqUDBGRILYCEOicgc1ZisEUPy0ZcC1UrSsjtLd/2+R9vrEDdI0gycjDOnwGFnQRNyApgUFY0SkiG9Kn/3zTaj/WZg2X3xx0t5mRdkywM4z7msMR9J6skLA7O//S9Rj6YHcN8n9hPqm9362f99k/fGC/dK7pG8qlhhD/pB3QNOCgjEiEsRGrEp/uODg9EiMB6iO77q+XpxW7aAI/AKaFygYIyIsxgoB/ccfNDY6rV4KWu3APPwCmhcoGCMiIr7nrHTUFnr/GOk9Mj3hIz+wvEbtloJ5+AU0TSgYIyJBbIQhUbmDgib8ApoqFIwRkSA2wpCo3EFBE34BTRUKxogIxOhb0d6jVn8K5eEX0EpAwRgRCWIjDInKHRQ04RfQVKFgjIgEsRGGROUOCprwC2iqUDBGRILYiLJCwHjnA0XgF9C8QMEYEQliIwyJyh0UNOEX0FShYIyImJjm0LdfdUFa8pFj0hv/bHebQyP+Ms6I/U/hL0jrbf+09Kc0h36HzKHv1jm0OYh+QQWxEYZArS+EJuIGtAJQMEZEgtgIQ6JyBwVN+AU0VSgYIyJBbIQhQbntJ+rx38ZpZ5tD56LdpsxuEBthiOn1Q1RzRVp28l72fAX3Mu3P0K/wlgF5hQBnLHgywhCn2Y1CE3kHNG0oGCMiQWwEIzqH3p7GABIPjT/acUqdf9KlOXQYp5jN6BdUEBthCNT6QmgibkArAAVjRETEy8oqe3a957iVnubxB6pkdTWEJLRO1nUnpBdUW/BpvXL+aQ79t1fdJ1amFP9A/xB2Q9QUfgFNGwqZoddEblOU4yA2whAz0w+BJvwCmj4UjBGRIDbCkKjcQUETfgFNFQrGiEgQG2FIVO6goAm/gKYKBWNEJIiNMCQqd1DQhF9AU4WCMSISxEYYEpU7KGjCL6CpQsEYEfHi5lcCFXoVTLgyr/EWjbdUsSUYHQqnn3bUUCrz5vy3SRvIKbkUjA6F0xZUWdQIvLn8t0kbyCm5FIwOhdMWVFnUCLy5/LdJG8gpuRSMDoXTFlRZ1Ai8ufy3SRvIKbkUjA6F0xZUWdQIvLn8t0nr4MgEpnqALHmkQ8xuLBxynUWBN6vy/2BafuNF6cz3HZz232ED+yHXJjRV/JITTO4Imh54IzpxVb1HpI33OCQd8Q//lb5xB+8Jl7M2q+KP566bKmdbMDoUTltCZVEj8FYj/hXuhYB6UqTtdVPa/5D3yZ0e/2KVDtE65yC/EBDOP7cFTPYZ3yG94hL6iWY14u/vv5wHrVusYeBN2D/9IPbWsl0AfbWQrn7wivTRp62vDzf6tn9emvnqtKpUKecr12nC/mGgxCIYHQoHOgWqLGoEXpf/Zbr/Ia5nwPKgUpc7FDt0iNaLb8aCrywKvC7/0URFcemV6TcXvyY9YX55CFC3/5FFi9NZdzw4Tf61ShIHHTSeqpqZVFnU8Dy9N+brIt9fuy2BW2wJRofCgU6BKosagTel/Kt9sUOHaL34Ziz4yqLAm2X+9XxQu6JzgXbfFZHFto7FL7GO0pYBm+b46YUA3Wk9pYeuOS49pbrmLF90/5tH98Tv+hsdGQvnOicy8Kbx/I/dclJ6/kK+RzwlveHy/IIQ9U3LTtEH7Ti/1i/l62/9xbxlQL8/rT1LBaND4bRlVBY1Am8o8f9atrJBPNw3XcN909M3sL5JYgz9L59f6ps+HPumNoKaU2IRjA6FU+tCxhqjtAQy5V1yTPe7nd6XvvoQsYcSf+tXfugZOP7YmLZTopY9Tf5TopdRDtnU8r/+0V+yNqX5ylmbNv+ak+Arpynw1mH/9Dmp5Z/bP/4eLvFzvCHWnIDAm8Hzb/dZvg9RfyF/M+g/hx9zMnT/fg69YWh/dfy4Xxs/9z/Sp7rxh+mNbJg22ePP0xEf+6/0zTvyot50MvV8IroIw7nOosAbevxrl//Riw9Nm6Bf7Mw/b7uHERDHVrItGB0KJ8ZetKOGUpnXN//84qJubVTOf5zv0Cp76bCLfztN/ttYlFNiEYwOhdOWURk07spzaL3+ebx4zcpvpo/uTeMUzn1n/vM4hbc3EvOwlf0SWTjj+fcR5FJ989/a8qUZFwv9/C/jOXTsf+w6l/vfdI8/fG1jhpSi7QNoDv3EedymqJ4d+Z/Hc+jbV6ohOxZbgtGhcEzJEJVFjcAbQv4xB8F1Ys4JCb6yIPCG4D9G573P+Q+5fhjmv3ohwDUVQw2R9HgKbVN4XhDbGFEDhU7b6RlqyCzzf2+69SZ9A1JqGKvpYmJ0oNDpOj1BV6T77o1Tfadhc0PheYGzqOhAodN2eoYaInqeeniffzqrORkCfGJcRufyzxkYmByXLadnqCGi56m5/GvqJCc+MS6jTqPhtgxnxFBDRN1Tc/l32fWJaRI7UOi0nZ6hhkwq/xh0yuA5/+DtHPVBnS9DDZmU/+gg2ogyTzk9Qw1x/penX37t1PTul25Pk+M8QWCICdr8bdJ2B7wqHf6OD6WTPnV+Ou+y76Vrr78+XXf9T9JP7/5DWn7bDYRfl274yRXpK5//XPrcGSek9x37svTne2+Z7bFN/ZdB+/zt0pPfeHJact3d8YfSXDUBsZo+KMIHCp2u0zPUEBe/Flnbrr/RpYelTXG+6gkd8Wlp97QLHmZY2IZMY/z6QgAmaDj3DAtPVwjwtZnV+b//83kvap7kb6z7L6ffpx99ePc0v2tC7WLlH2i+xz9+NBmPLXnWxL/sxMT7H9r1z7j9a/zWrhBWJ3Rn11BDmmxMLv7fpqs/uFtaT+rV8UCjNz894iVnphvwA6W5NWQ1/XcGXDGdL0MNEV3klVYntRyLRlTrb7eSRNIZMdQQUfXU5PIfPXVTzrqhhsxK/3o+uI2X9t/GFmNo5eA4PUMNmZXxc6XG+IWAjXP89ELAdQhnFf3IzA9vcS+gNqv383z9LXhmOu7q30ObLRXcUENE5qnhtj++N+9G92aqY7j/du/N66+/9RbTj7e+YiWKjA0UOm2nZ6ghw4v//gvS27abl+/X/AIaPzwv8dv54lzg3AFybvI9crj55/BcrGP3y/lQ/wvTo//6cnqtK2gMdf7PLwTo2KjcVzkPJX79Qs/VcKj++aW12898VlqY87zekRel/L2dnHccps8/e3DWDTVEquCp6T3/XRGHGg45/7JpVrlX0XnQPx/x9PoP1s2tIet8/uv44/Wn58NnY+1uf8vTLy4/Nb3nYMyh/b2G7kHzdA792nd8kObQ59Ec+qp07Y9+RPPon6SbaA79+9t/kq69lubQP74ifZnn0KfTHPqtL0sv23urag6dxyY8h/6rk9PZ197tr3JcZG1bt0Qb8rBrf5qUGP8KmkPzMw/f/9szHhmT68vPMbHRRpR5yukZaogoeiq2f5pDn7pnuH9pP57PP/crIzvqS/XeZcCddUMNGcd/MFQR0UYldKTTY1Tm0Ki/jlMeonHK9TSHXuDmPzH/2n/LGA5zuQEt3jkntPIvQseLGsPtf5adkJ6d+/7u8dd0jz84WBeroYaQ/Lfpqg/sJmOU7vY/P234kk+XOTSblD9vA7wu6PQMNaSxFNt/lz3woo36hQZojR9/0Bju+a+jsyobUmvM+c+pERDTVE5pk7VKFEhnxFBDGktTbX/BZSBoVaRAE+Hde7zWg+ZgnVJK9Yq2YIU0Rc/yuCkYotLBOqac4yraghXSFAvrwXTfbd9JXz375PTR97wxHfWyZ6SnP/VxaRv64qBM0jB5o+WG//hP0q7POywd/vaT0slnfyVd9ZuuH/KL9XH9r7gmLXn1Y+kBwfbpwHNvs/oVRG0Vi0XShdXa4/onI4Nt1xa7vBZerT3nvzvBPuceL5kEVmcU/G5Yawvd4cCzPN5aVelgnVKq1ha6o7BnebxYAqbSwTrQRVsu2oIV0hQ9y+OmYIhKB+uY8hTuP6hzsRGxOf+cj7n8x1YBqmtQ77MleetInmd5HHYLVOlgnf7aUq6jsGd5XC3dn3515enpve4hBuIc2WbvtO/ik9LpX/p++vly+zXTKqC2ikXBCpn1aGmyu69LV/7nSendh++ZdtwYk8EMF9BDjb88JZ17wz3U7mqL5qoTqbW7/fszFPHWaG2x1fCcWntN+B+95NDw0NvGUTa53iSvEKA11zr7KDxeR+RlLV5rx/jzCgGYEFt9ML7j819vGVBbbH16Tq0d/RdN1VPa40UDWG0RfIar0r0XvCxtkeMZmb9f+ltsA3DzSekF8hWqG8fW8Y7slY759vJx7q2D/Pu6KF5rC63MoOxZHg9KQqhUjst0hQDcC2rIX5bWK09IuQ4HnuXxgf5bYcMRWysuS//b/UDZtv9t0p6nfD9hYeqh+3dnVGx3OPAsjyMgzq3VO7cvyAZBtVUsClZIK+pZHjcFQ1Q6WMeUm7u1lOso7FkeL5aAqXSwDnRxLy/aghXSFD3L46ZgiEqtrbtr2FQcotrFomCFNE3P8rgpGKLSwTqmPL35zysESC72cS8E0DfOt5zxp/klnPygFvd4accL06Peeik94i1/Ph6PFw1gQ45/xcXpbxfxNke0lcG/+K0M+Mu7vBRvPsf19Td4hQCtb11boTsC9CyPI+oCVTpYp0tb+6ZH4z5CfdO7ructaugaob5JVkhwbVnbdx5/CX+v9OZvLWdtLuLuaEL2PdTaQndUvrDuTJcs3jL/wLFt2m/JLyrbtcVKXJG1ttDFWdgyoH2xjePnB/Ltl5/OROUxkuP5Z+0Hv3VMeiJfH5xn3nojmqio2mIlrshaW2hlBk3P8nhQEkKlg3VKqVpb6I7CnuXxYgmYSgfrQBfttGgLVkhRrO/llbgYE0ylg3VKkVpb6I7CnuXxYgmYSgfrQHdi8bO2t+fxYgnY9Pu38yFfyNaPyqff//TEr3Pod9Mc2l5Ayvfbka3zHPr/6Rx6av5piyyeQ5+vc+hFNIf2/dUIvxhAc+hzaA4dTnY+rd6nx3HWC1TpYJ3+2lKuo7BnebxYAqbSwTrQRahFW7BCmqJneRwKvO2enTc3lil9RtcLAcPzj3q0Fqs5tKtbOf95lT0yMtX4+/svki5Mc1kyOr7/VemeCzGHpv53fhmnJDeHtntEvoaM7ukcGnWZvH9kGBZqWFus5ZGutZv4l5UtA0pb8s8/pn/8wTXWemrdPa4cOq74cvqQm0Nbvi3/26S93Bwa5caNPyt6nx6HnQJri0XShXlt1BnXhdf3Pj3udRT3Fltpzam1he5w4Fker+3hTA3WKaVUr2gLVkhT9CyPm4IhKh2sY8q5XRVtwQppip7lcVMwRKWDdUx5rfFvo5z+gXU8+jZlQ0rkgvXjsxAyQC0aKeVBojKnYaghvgDh/fisBhmgFhWK9lD6+RVL0hl/c3B64c6byNv6evHmCSkmSzRAtH0J5Ubk5Hnw2FuwbVp02N+lD3/h2vTrld4XcEDnX1E60tdE+U0o/rpr51N57zinb6ghVlKRfnyWQgY4XomH0fnXVFTHufi1pbj2YqghTc4qhiNRBlBFkXLq1F5V5jQMNcQXILwfn9UgA9SikVIeJCpzGoYa4gsQ7vkPpLtv/lG6nr5IvvYbF6Vzzj0nXfT5T6UzPnR8ev/7T0gffPsR6bDDXpFee8SBaf/dd01PfvLOaa/t9KsmfdC3tsdfpcZy43MUMxZLzMWvmXL5MtSQmDLKsQ7qc7+U+yhVQhnAyK0METk78j9299fSmW/eI227gCcp6H83TVvvf3Q6/vyr0i9HfTweryOCDLB//GP3XZsu+9dj0188/dFlLMC53Pgp6XkfWJpuXGGvgFdOou0ohAywv39IVNPpG2pIdGHXWMUWEmUA4aVLl3nDO//Y/7C83Y1xE2DXXu/D8x8j9fGP0rLM/HWD1gMTNUzclL8D7X+ouzqX9HobPn/9+JrPWI8uKtpSa86moYb4AoT/Il10JP+YofHM2++09EM01bHvp399/kYk0+uoC470NkzbvPfK9KBYnYn8r+b9HysE+Jj8uHyEH5Jh/2XkDFBTFymfzmHGvyotv/wv0+5yD+uT/80PS6fc7F8mHqZ/jguRAk4ufvQrfv7jszWetdX1L/at6oZUVejHZzXIALVopLy52ZV/qZlVdix/KYb7p7apEqOPAzgKAyo/UtBlOLvjl5qOnpeO3oRjp/9n/ROtEOCiuevf0uGP4vyUHIX+Z4s3piX3IEYfN3DInE1DDYFyhv34LIYMUIv84dIj0nZcxw0PSafc6pc9fcC2DJD48n3NX3/r8woB2bOCaDuI+vjvX2LY8f8ifUH6Jm2r8/bVvkn8j/0wffKAjcIPSLF/ojK0DPU277ky6Suf/Wrdj8+ZgAywX8Zuoz700bmfpJUkrnGvjVhRQ2KKzUfFFhJlAFVHt1PSNto9/hh/9aTiLdoufMYgA1SpUL87Mx2+UX7ha++PpauEOezzD7+Azr+i1fHh4x/3KJx/ZEYz5fJlqCFNziqGI1EGEF6cSkAfPvkPYROh9x69TzFuf5Y6Q0ykSD8+SyEDHK/E8PI/dvflNIfePT02jD83S1s975j0vvO/R3NorUs8rp5/mUP/21vT69wcWvrfTXZPz5U5tOYhZsPXYPX8e0uKwxNg5HbpNzW0ooZUxfrxWQ0yQC0aKW8uxs+r7PGWAb7/x31D2yvPoW2NJG8o4/AEODn/om1FDSE2XgjI46ww/8I1RC/VX3J3VY9h+c9mBfh6eT7jkAGqPFLM+2W66PV4IXAkzdv31DKHXvXD9K8HPFLuDzqWLGNLOxc8Tnnvt/IcWn1ET9FjpKK+ypyGoYb4AoT347MaZIBadGwZvxCwhscfWpXqGNs/f+yw/Gt/lXafn+vq2xnm/5sfmk6+JY6Ii1HEDaiSSBVtzpfKnIahhvgChPfjsxrmbLgmtF/pX2L4/rWy0WOkVAN6KnMahhriCxDej89qkAFq0UgpDxKVOQ1DDfEFCO/HZzXIALVopJQHicqchqGG+AKE9+OzGmSAWjRSyoNEZU7DUEN8AcL78VkNMkAtCopaI1AVFLLiZ7EHUQMNt7bDNGlmZSxzUOxEK9CzAkWxwWLJqfpflUZ/89108T8ekV6yc1xesAwI+eKd6L/vHLjM/LTBzoekN//faxO9E2nLbJRgYhQc/4qr3pGevh78db/xx+VjyanGH60UoxW/VNiwqDHnP+SjJjI9+9p/qKhrVBXfznpBosbc+Q/5MOKq9E/7rKf3D9mjie8P+R4hgxlc5xUk2Xhf/pgLOSVz+Q/5qIlMP1yuP99f+QdMa1/896fb/+dv0ku2X+j64I3Sli98d/r4lbe5B+HT2P7H7k7L/vuEtPiZj0rzbBxAqwI99S3p9Gt/l7vMafRfbrkBC02cahHompgF7X906SvSxnLv63f/o4fep9Q/3IaQAxFCXK348TDD3YObezM/zMgvBORaDM+/C8uMGuKEEY0a7vzfc1Y66tEYh26RnvqJn9i4c2xslL6afaYuDdzE6OJ/0vvSV9qFNkIF+vpnrSAkItPTcv9Z5r5uQN9q1yn/wMHtSr+unBb/khWX/0Hxr7qB9mrOPzR15p+WPTzk7HQLEia2uw8hxavV/p19M2qIE/qH5KWtqMIE42/MVgwjDQn+PRE1Hp7+fT+veN57OiSHiEyv8fYf6sVns2IYaYg/5QE3DV4hILwQ4M3+Mn3h9VsMGH9vRyvw3VrsmlFDiqzCosbqtD88fJ6XNnr9RUkfmcM6rxDQtRRvuf7ii8O5kiguJBGZXuPn/3dL0lFb0HYBfH8eodUQuG+yvNKKDqc/Y/y+aafjpW8q5djA6uTfKmB5Sul76bR91td6bnREOvN3eKOu6A7T/+hS3hu6nNP2K732OdAw/UtUY19LH9wtj7M3XZzO7fyBcHriN6sWlCEmqpGoMezzH63XvpmOGqvvP9zLaWww3t+w/Ys/M2pI32pEjdWPf7b5D+eDrs36b+2J/w/p9v9Hc+g/5udQeP70iLTlQe9Op195q5tDU4QWlCF12EZHjXHO/6q7040Xn5je9Ax+uR7zP3o2/tT/5ebQ0+g/V3aN938xaT5gzavJDbF8M4KX6uu2Wej8Un0oTkSmpy9+fnGxvFRf6uNWFBtZlA69+HchHqsYuFZvQyBpYNQYp/1NNv57P0PjlDKH3usTumqTVoJXnnpGWuD7a8NRhvryPE6RGCfrHyesibowhhr/TX4OzWMzNxaR2GZg/MGhWVCGlICBjf2E5tCP0rGZ5R315fzTHPrlNIc2E4RkfPra/8TbX/38H2EJ9HUOgpYw1Vww0DWR6dkQf4wkVNTOk0OiuqNiyYnn35kgNFopZMWPhYSKGuuGfzfK6RdeFahPTCxikpoNWqE/WhFCoKW84rVgXlvwWMTENRu0wnIcvePLacm7npt2taWBcVMBxMCF6Pnbpsftc3A6+Nj3pRPO+Fw657yl6as/+Em67jraR+mHX01L//Nz6T9oL+IT3vKidGDH6gIjvY3SFi98X/r09foDAupklUb8YUkU9k8rBISl4koJFHEcQWvboEvkdba5GLTUWsl6wVTijrGICWo2aIX+aEUIgZbyiteCeW3BYxET12zQCv3RihACLeUVrwXz2oLHIiau2aAV+qMVIQRayiteC+a1BY9FTFyzQSv0RytCCLSUV7wWzGsLHouYuGaDVuiPVoQQaCmveC2Y1xY8FjFxzQat0B+tCCHQUl7xWjCvLXgsYuLIviqdSg+W8KMsoA0KmgEN7j38QgB/+bO6/ktkPvJYR6565BSvBbMAgcQi4FaWiuU5/5winwVLmfHBKVkvGGQGB+S/TMi0D+N25z23RSOneC2Y+QUSi4A7vPM/dlv6xknPSTvkVQE4ppFFL03HnEMv17Hv6fYvEbn4R29J3/7MUemAx/DSvnmiu9kz0ivOyvXJGairBVqhP1rKmmCK14J5bcFhuBLUbNDeM3ilaOQUrwUruhmLRUxcs0HzV3BlucM8tgr3vzLpLF4LZg6AwDDoDGs2aIX+iIL8QsCfdEww3fivt6h5IWDG2x+qC4jAQAukpQ7ddgG9hS9Jf3+zPtlH5Lo0c1f+S9/T6+1J2wbwV5EzkX+ueAymeC2YhOcPKJJXCCh9q4+D49wk7Xrq9dkDsuANMQ5jyi9eC1aXqIqYOFoqlpX/ULp36SvT4/BQNLT/XO/5e6ejLv9Ntjds/6sXv39QhHxb4FbjyEE+vGfwimbklKgLVnT7OOrDhuV10b/283ot43wgXuQL9LoYv8SYVwiQ+DuWOuev77fP1xly5Mff8w74ZLqhelJWWl3BkE+DSKwxFKnZoPvlf+zWk9NLNuRrf9f02sv0pbPitXrQ7h7UIpZ6hQD4Q7VA9/PfVeviv2CwZxCGjdFlyd//VqX7Ljw4b2VDbXbhi9NJuW+CFvdN2NLGzpHEnPsrwfNyvJP2z/XzWfAVj8bG5IWA/IHIk/QFBK8teCxi4poNWqE/WhH6oad6IUDaq4+5Y/UkGC5mOqsFNe8ZvFKUOTelz758Ex0HbYIXAoZ5/tmbr0XxDj44xWvBIDPYBiGimg3aewbPbFWdefFasKKbsdbIavkvczYdB6iXmfPv4yteC+blnYFmhTotoBX6o7cILeUVrwXz2oLHIiau2aAV+qMVIQRaymOv9f3Hawsei5i4ZoNW6I9WhBBoKa9EXTCvLXgsYuLAHrs1ff2kfdMi2uoWc9aRHV+ajj7nOp1Dd5ei2sBKwUwVCFRAZ1izQQtceXP69v85Ku3/GPeCv8yhfxDqU7wWrHJTp8zE8AcGaIX+CA2G0FJe8Vowry14LGLimg1aoT9aEUKgpbzitWAs0RUCyrlsx3/YHk3t8BGWvWfwWi3lFK8FK7oZC0b6vbjox6Y7plcsja87FpvBGNUZdMGKbpf/IkVJcEAr9EdoMISW4vdcwOOU3P+ux+MUv2oTadM45cCw0oZ78cHmdLS9Ec2hYdl7Bo+96V/klKgLBk2DsUhfNtQU+qMVSWnZ8bRCgLar0g/N9Pij1KdEXbAipW2nLnklraiF+vo2lnk0h37D5bGt+ciRk2IzcorXghXdjMUiJq7ZoBVyv8J1zLklXP+gBQr08P2zB1hXby2neC1Y0c1Ya0QENRu0Qn/0FqGlvOK1YF6701FWiJZKrN5zrVO0Ht7+pTViLhxS7zLWJNLJJJHFQHXOSDHoVmKcwKwzY/5X/CRd+pGD0m7hRYBygWJJwZFNdkp7Hv536e/P/1b66XIsoEqVDjFxjBZAjmhFuvvaC9KZ73tx2mdr+vFAvgzONyoa/Bx21g/j4MeK3y1bBayXJ/064Y9bBohq1ldnRDT+czW4okEX/AhLcafcoMqQo5OJg2IgGp7zP5f/0Faq5pHJ0nyccoMqQ45ONvvb31XptGe5lUdsEIPBDGB7/9lg8Rfl7W0XuV7Oa1X83efcc9ft8+8j7canI/4yqKf2lfufbu90BeX2NGP9b1WRTv8PXJ0+++rH2lL9I70t0xP+8t/TN+6mz5bXcPsfve2SdOqrd3BfdG2VnvyeL6WfrwgVoyiJrllV7Ex2xu/KKeqOTqY+MiPwxfKs8s/7H4av4MK9kO9/XcviIoTpjH+UXgjI+zRTnWz85+o30tMtA6QWIc9ElBNYnV2WVawOshR3yg2qDDk6mTgoBsg6f226VZ509tK8/enHrtrn2A9kaeZwj3ATVI1/g7Rt3jbAedZwBvr3zkgx6HpZwUv1nXKDKkOOTiYObqwfZpS+VGIc6fgxpbh3p88ZblBlyNHJ2vw7wxx80M2yh76aPrRHXjXI2lipM+d/3nNoD+f8UaqacMdgk4iSQO+ccJZVrA6yFHfKDaoMe5iR5yhMz6R/qYWrm8aYGYHPgRKj4bUJmEz8Yi7YZB+ZEfgz4z9ewzqWLBFy3QrVDyvVd8oNqgw5OpnmODMCf2biF/8rznErBJxGWwbgjyrEdVrVdb1h3E1wHu0Pe90DpOoCaFBlyNHJVj/++9MNJz+Vvoqn638ntyqL+VghX97hx/+u62/9Ny3VrzytTBU/yD5w5s4/VkLQ3OuLGJTBXG/JP/VN2NLGx+zxXu8RaZv3lS1tnIEqQjLc5KRSITL4h5ja1DFYdeKAf03LsiExF2yyj8wIfDbEMhjsD7n46CW8epLmpXv8wWOjH6m5YJN9ZEbgT86/at+VLjt22zz+OSCduCy+SJgtVjEN078LoEGVIUcn0xxnRuBPJX5noEGVIUcnG6Z/3Mtx/jkC/nOep/n8u8Aa1NXCyYYZ/5q5/1IEOZ7av7/nMG7nYm2Jf8XV6exX0Rzanj9vRXPoT9McWp9lS0DcvvrEb3JBVEmOqx3/WBq9/eJ06qv8HPoxadf3fDH9HFv/OR/O88O+/dvWMm78jfuGQn6p3q2y5/KI81nD4Zx/eqn+ZKxkVOYyUidrf+0qe1yX4fhnQ01kHbxap8s/jVNet0X5iIv6/xtzJcWFHLrm0BhTIv4NZHujeLVNxH+MRcNyR0WzISJKAivjLKtYHaQUp5fq91nj4w9X2QZVhhz5MHBMr/mXbR7GWeWQ01HS1ziVbDnPQ7n/xOuVPtTKbuv+R5xz/epauGqKtBhAkQxJMehWYmhlnTn/LlkNqgw5Otm6ln+8ntK2lBA0iz0jNx3PMguuWZnckGzG0VauQhoVz5iqf1p++KsnpNfu2vEDHXWwGACObPvcdNjH/jt97zd+zbSp+R9b/oN0yccOTntvSjep3ImP9LZKu7zl/HRd+AFhVfr9lW9Jey/kTgUdCkO88Tc1/5pVV1ZQR1dpN7JR8Yyp5p+sz/lHEizVnYhPtyh4xlz++zej2Xb/eSDdffP1tJLI9emGa7+SLjn3nPRfZ34wnbh4v7QnvyyUB2F8b8D9B9d//PJn7vyX62Su/Y/X/ktbwiQld/X9C5b0Muabm0g8Y3rzP3b3F9Lx+/Aebbkf3GzfdMR/3ZAesBpOr/8m3IZB/sfuSNecfnDabZPcr49slLZ6zVnUp68qqbOUGfKw7v/wdUNX29T7X1khoCQRJ93lkIRCeRbUIGPa5Ib0yb9uGVDq5cdfuH52SIfalgHD9m+VL4irsjI9Y4D/u/41vWZz3mOS681LMvNSh66soCvTnUv2Txui72HY0f/0tnt7uvB+lAXk2gzwD5mqadUb/95WVqlBo+IZlX9e7tDG1nq+yrlkWn9MERdixtuqHWe6UfGMyn8w4bJtRQzJ7W95uv7Du9vLTvrQrO7/n0JfONzrLDsbyLFnmeZE/HcWNAuCNCrKsPEKtRnJMeU9/k2vf/W1uvlvgoshMNWoeMbs8S9zSm77rv1bTVukz/2vDX9tiV9qvpK2DNg0X/fPOjVdi3Asfr7e9qAfRrruDcx7ZPrjD34370ufC1vZxhgxhnj+V30zfXRvWpp+ZJO000euoR1Sa//aN/nrDjiuv/WP1heHteQsvv7u+rd0+GZ134SAAR+kvumA3DehH9bzhrgFbndcuugPzUkiI0OKX14yUf/ryYvZ3tcQz38Om8dG7epJPn7+MES3vbEYfZWQvtWKH22N/R6QTljmv4r0zoYfv1UfiHcnPM9YN/2XMYued6RC4boff4jXh7uGzr/NP/M4udRvLWh/d19Ec+iN6TrO987N9qM59I3pAclrk9wSGrBGxTOGFP/Y7emaM2gOzR/mUd/Mq+jyHPpa3v7bu5M6ecaQ/CPWLujdzSL/fssA9P82BpQxuesnLAZDcl4d3RU78xoVz+jKf5xDl3uZ67tH6IWAi3kFJG+rTwUaFc/o8g87WcakFTFkYvHf9Skap3C9+T68RdqznkOT4bFE45SzaA6NsXc1trT4aZxy4f02qpuY/1D3EhcwNiIRubAaWbDhFPsVpDn0s3GvwHM3g5wL166mw38JQDFX5ZbB8f8+/egkmkMPzP+f0BxaNuou1vvFXzRad8LxFVq9/FvbaPoVVwnvbsj+3YXhHFbonP8BCVm98z+b8++e5mgL8O3AcEOQI8cQVGk+OkmgwAeEpQJV4uWGGwJtxxBUaT46SaDGRn+clp747LRDXjpJbvZyE9fBt1ykmz4l7feBi9J19+lrRWbLkKn6H0sr8huReAucH0Jsdfin0veW585i+YXpnbvpV0NSl3yjG+nR1015/1N4D1FK3bSCfIxVLRQwwGILmEq83HBDoq5QIlMFPkbVQgEDhKUCVeLlhhsCbccQVGk+OkmgwAeEpQJV4uWGGwJtxxBUaT46SaDAB4SlAlXi5YYbAm3HEFRpPjpJoMAHhKUCVeLlhhsCbccQVGk+OkmgwAeEpQJV4uWGGwJtxxBUaT46SaDAB4SlAlXi5YYbAm3HEFRpPjpJoMAHZEujd3w2vfXJuk+lXfMyqKcBGF3/69GDPnklyRfigt6LyFSBj1G1UMAAxUw4qMTLDTcEBRxDUKX56CSBAh8QlgpUiZcbbgi0HUNQpfnoJIECHxCWClSJlxtuCLQdQ1Cl+egkgQIfEJYKVImXG24ItB1DUKX5CAk/CMDAE5BLQw5LBRYb4JmuIY0kGyxlo2qhgAHCUoEqWUUPMk54Fj3IyP3fvEVHppOvjXu3hyikmJblo2KwWihggNAoUCVebrgh0AZjZbr7ihPSITssyLneKG0pDzQgByz1KhzYAlSJlxtuSNQVSmSqwMeoWihggLBUoEq83HBDoO0YgirNRycJFPP5YUYZ/+hDIDx00/sfXn5UP2bLEOUHLyJTBT5G1UIBA4QlhbzcIW0ZIOPB8kMn0yM2KaaHGUvRDp0VQZXmo5MECnzA6J8plXi54YaglGMIqjQ/pPi1+6F/ZOGfVdsFwAvZufOMdOgj8NDDxYz7hlx/u6YjLqM9H507rYFjBP+1atEDBohIClSJlxtuCLQdg9Flx7uHGRyT/uO+N8Iv1eZtt1xJGMtQJV5uuCEo4hiCKs1HJwkU+ICrrnl72kPam5t/hPZH+6sefm76FbtEIcblzzEEVZqPThIo8AHVjj+qxMsNNyRZn+L7F3hlNacaKPABvWfFVeLlhhuCUo4hqNJ8dJJAgQ8ISwWqxMsNNwTajiGo0nx0kkCBDwhLBarEyw03BNqFUbd1pstf0QMGWHSAqcTLDTck6golMlXgY1QtFDBAWCpQJV5uuCHQdgxGR93X3LRlQFghIBdZFZaiz/c9f/1t97Z0Ib1x6CwX3DPFnmMIqjQfnSRQ4ANqtei5wOV/mZ7I91y+V9+yMpRX3dH005PzdjZUX9zT/PW3/uKlMk9g/dq++in8KIeUoUq83HBDoO8YgirNRycJlDxAp75pg3xv5q1sTrql/eBCyv/6dO2bJF69P0o7D/FT3/Rl6o+lgHrlo2JtPcEHhEaBKjE5PSDfR/w9Mm3//u/1tTss/ytpy4CNyZ+dV8bFP+KnlyVPc19+ouJS4VJ3q7/ICwUMEMULZMlY+u05B6VH8jmiH28OxXinKeQYgirNRycJFPiAxS8wlXi54YZEXaFEpgp8jKqFAgYISwWqxMsNNwTajiGo0nx0kkCBDwhLBdJSwtX5N11DoO0YgirNRycJFPiAsFSgSrzccEOg7RiCKs1HJwkU+ICwVKBKvNxwQ6DtGIIqzUcnCRT4gLBUoEq8PF5/3f2qOixlfXlfG/ABi19gxUbkENUUcgxBS1nGxvhlAJpDo6+Yt+j16R/7blUbvTnLxa1nirpjCKo0H50kUOADwmuiOcvdV56QDqU5tLb/jdLWPIemlQJM1xCUcgxBleajkwQKfEBYKlAlXm64IdB2DEGV5qOTBAp8QFgqUCVebrghKflV9nB+rc+QvtW9VO9qAxOAxS8wlXi54YZEXaFExgddyUj66dzHo36AvR71KfZSPWwBqhPvynBDoq5QIlMFPkbVQgEDhKUCVcLjlLvcD/0jPE75mR+ncIls5U4ap2zg+uwcN3KgcfM45W6UMFj8AoN/0ObFIZC5KAQtZZ2ElAsFDBCWDC47XsY71pbWyPjD19jhTaWVMXbNcWmPqq0h9xrHvLTha3QODROAFrch2abR4/sXVSlWykb7hQLGUOtYnn+pS9WAHvMMN0Q1nSSjpWxULRQwQFgqUCVebrgh0HYMQZXmo5MECnxAWCpQJV5uuCHQdgxBleajkwQKfEBYKlAlXm64IdB2DEGV5qOTBAp8QFgqUCVebrgh0HYMQZXmo5MECnxAWCpQJTLKMSVDshqWovCmax1YrPmdNJgZRlBHQzT0naiw4FlhzXf02N2XpI8etE38Igc3EhmE08O3Z7wzfera38WEDsm/VJDrQ/s5fesfD7D9nHq9+WnDZ78/XXL3r9LX3/nEzvrxCgG72P6nbEPDbY41v5MGM8MIWtvDjt8qHx2jViZGcHP+kYmSGkuWiRSp+Z00mBlGMHf+kR6kdtrbH71lejYekuHBjw4wedBgS4FSfaxqhqCSGdb8ThrMDCNwTmAT+k5UWLECNb+TBjPDCJyTOf+SgdVofzbotEnKCJmc5flfcUU6bf+8h6nU+zFpr1O+LysDoOYWQmx9JTTwrUBmCA1mhhF02IC+ExWWGl5xVfr3l29Jg3z+8o2v4Y3SYxZfnO5wL4WLopRD4QwjcE5QZ+g7UWFlJehGssmTlEPhDCNwTmAT+k5UWNFhze+gu/bJxfKo+mKAf5hB5lej/U8ufv66oWwZoNdOuQ8rnZc7rONCFmp+Jw1mhhG4JE81/z/NewBrXzKPljq8Ibj0BO0X/Oeb2PYIeDEjxr4gPeqtl9K7+K5qMIG4AWt+Jw1mhhE4J5OMfxmtEGDXH5839KWA1K5O4R9Tpsk/VxemGee/ThpMgg9dmo5/PL1IlH8EKHV27W7Bn9ke2yjZ2FVvffxBiPrASoYRdNiAfhHF9qF1FS9FVZ120mBmGEFxgmrP2PWfHaJ6a5H/cj7Q/+QfLppYOCgwY+LBNfFaFL9UdZRWCKCvDKX/xQsBFlQOZuzmdN6rHpUfxpVrrFx/i9JLPy+v3yB6SlcxYpghRU2wmt9Jg5nh2G3pi4u3lTotOOSz6XaIYVr846vtUudyzpW3Pn/B3pSFkQxFDqUMIyjNA0WHGj/3TeWLVdkuII+RUKvS/txe9jZ+reNfaH2TVNeM+HgRCEGRQynDCGL8y7hPYZ8z8/yFtwzov51SqUfJkYuNUYQGdicNZgwcXLZRvkDlrzl1D95g3pThKMOa30mDmWEEHTFA34kKK1ag5nfSYGYYgXOCmKDvRIU1dP/1dT399x8NwUIyZM3E37bhUiHDDInpb8t2yVE4wwjcSdayzflgNkxU5ht+rSc0mBlG0Nqeyv139Js0h94093M8/t1G59Az5R95QaiBBjMGPiZz6LLNmc6h/5vm0NB3qSksWFZY8ztpMDOMwDnJpqeSf9QKrgINZnQMbtuGTGKi0Yv7bbuH8R/3VzTXKUVdfsDMMIKOMtB3osJCZNk+vbhoc2jMuwC5/2Jct90za0P1H6sz9fjj2MO2NYL5EL/XRf4RK2Aep0g5FI6Bg9vW2SRFVFioUc5/JEuBzJdyKJyhB7RlgI53uN5d//nZDExU7rr9OSUph8LesbUGh6DO0HeiwtI59BOwym6f/C98sc6hpRwKZxiBczJB/y68ycTv88vzD9SqINPr3wJdQ/HP+Y+Jn03nv7z26Dq/rnZulfZCtFvj9dcSSSN2jGnxT3sV3XhaOnzHhX1ucnzj21qX73+gfoKvQaGGgBaqQ4qsYE4sqEjkcF+66ayXhJcCNnjSk9IO8/QmXN6mw02ZbsT0dVN/y3Z5kZ/+WsW/r5nTn5b8F19z/rtOT5v/hy57bdpaOmT9AQIagCWjBSuyghWpYiJpxI4xd/7rlAmNDAF2KRVZwWo9kTRiYizDg6f2+ucHfVgmvSnqHBRZwZxYUJE0YseYO/91ykreCHOZavSKrGC1kkgasWMMOf+hH8k/OrVBTJ//Sce/alm68PWPSwvqycj8XdILl/w43V8bdHSJomBOLKhIGrFjTCX/K65JZ7/6sWleXefeY9LuH/5OqPO0+M9BligKNiPxT9J//4cZZayzqy2Lq8YREWAdF9NFVrBaTySNGAz60SV/hRmuG5xXuX78CgHROqz4mkSNLCmKWewYU2l/tZU7P54O3ZBzyZPjbdJ+S35h1RBPzh1/mXPnkufFbQMo3iZ+XvKQ1hkNRc2qIkVWsEpFyzdix1id+JcdXz3M4PjRpgjSctyy3LJzV9fcP3z3dUcRQC8DXmQFgwxQJEF8W7royI4fKH296ceoJ+RlxENRGM2wyApWqQwt/5pXfdCH1TOK14JNl//aLtPFa8FqPZE0YsdYnfZnzpw94ykyXf79wyXglWshp8s/Gy9RF6yuw7T6pxUCjsZ+73ghoKrAGC3Gf+/Fr0yPC9eXu0cQX36Ub8opo39kqxE/be9yOG3vwl/OvfTzd1Se4Zf6plPz3rzUD3Vdf7qkPev3r+W05t9qPsC/+5qOf6TSvsnph+svrnSDL6f1i13t37itj+QtbYqVglmVMiKSRuwYwX/1wzh9Ke80a9NO1l9LJI24MEYvPlReCAj9FtqqjD/0OVDjnBjFSsFqPZE0YsdA/Ne/K+0tfvUHAGgA1naZLrKC1XoiacSOAf9VQWgAVmIhi6xgtZ5IGrFjzAL/0qZxzgnyH2oIWMfldYp2qyXlGyOOMQvib2tdInI1bdSKrGC1kkgasWN0xI/+FPef2iboYqVgkAGKpBE7Rod/LgsNQNjz0GRjPId+LH1YVo1/F+ySDjzrx3m7gM6S5MiseIXJ+TftYEIIsd64IEaeQ8/P7b7c/7ZOu9Ec+g/ZVFPUuSiygjnxYP9QXFPxT9K/rhAQx9/WTiWHbns02CYomWnS4xirHT+/uJhXMqrbX37+1K4QMEz/HKyz52I3SSN2DMTPqxPJHJrHGdukffMc2mk6yw/J1nu26pHdu6vrb/vj0gW89V5jxDHg31m3ehPiNCsNL+uvJZJG7Bg36hy6XH9ubDyT448qOtQQMIp5Dv1oOk+uroL7/G+SnvjRa3Q7sMaIY8xg/uv6Skwz6L/kcM3EP+cfGZh9+S8vBKCODF09hV3TptsKWo4pF4SUBj5irI3UtFlqBYVDy/l+/R3p+Y/BG0TVTYMn1/N3TQee8Z10ZymklsejJ+TflFpk7P502yVHpN3na8cuNwjrNDPPaJqYNVsGwGRd0fbUQTNAKjb9+Q8eIzHnv2/+7UsB3m8Jyyu1pznnsxW0nJh6oeby3zf/yE/IWt+ktoKWEywp4fN/28npxQvp3mTXe7n+11/8JVqIi/76Gm0FLWcc/x3ixl9fo62g5XQ4IKW5+8+ATNWimraUtgJwYp+ifZ8vNrvyf1+64RP7ps0xmH/yW9In//lF5aW5ebukg/iBhgUABNGCHnCpFBVRWu34V3w/LXn1trKHGf8wNrLoL9Kpn35Tevam+fqdv0d6xSW3NZeSVIOqvdr+YcjHRXibkUqByTXkv3x9pvc7/KBY2io/hO73dUNHHB3RTi1+96MLnctSnzJmHKEfbcqWAahL663lQNfBack/LXVIey/bw4kNX5lOv0u3vnKeFYX/e5ako7ao463pXdNrL8VWCbWlNtqWU5chGv47RMKqjdS0lcuC/HVDaE98L7E+tfoxZdj+rT4Dds7cAABAAElEQVSTuf5G0+1nPictxMMMq2vM/8jTP5q+1+c0dnnrmypXx9XJv1wb+T6N66Qy7clufFbkf0CmalFNW1StoOWYckFIaVj3f/2RVNsM2n9x1Acbov/aw0zHL/55hQB6IUDi7/NCgOjd//n0tj+aZ/d35AvtuCdfE9G+6XUQNW1Bt4KWY8oFISXaLICu//30haz80pUpBCP8stqe+iKA3SO4Xyr3iQ1onoBFbUNRM1gh4n+AZi2qaTPXCloOK/PLZ7TfLu51G7wyffzOB81Kg7CRe88qfROVkwfVTfy7pNfytgHur9u/U2CUlMa7/kaX4ktM6vdl3+PKhpCtt5bTUa7Df/FXzmu513L8VR82ZP9WS3wpSC/RyViMBX2DagUtxywXpCP+Iuzw19doK2g5wbISs9S/nu9y/q3mfYNqBS3HrBRklsZvFayDqOm+igOaqpUhZILxx+uv61F5W7GW4x1nfIL+rWRfo15wX7rxjP3SZvkeO7JbNYfmF+sxh54W/1pbXyOrf43AP82h+YV6eRmA7u08hz6F5tDP2YSuAb7X8xz6YppD9zXaClpO7Zxo+O8QCas2UtNWrhW0HFMuCCmN1/8UZcKc0TKHLvcJjGMU8n37+lC8IVbDf7TlKkbjmbJCQJ43h/6aeXkOPS3+tWa+RrGujurrn8cpB+g4hevOc+g7afLV1ygJZJyiY0qcB7tvWPw0h/bjlL7+cx1rfzVtobSClmPKBSGlpv3RFkm6QkBpVxaHjL9maPzBtayDqGmLZDTd9ulnp/XyWLhf/mUO7W10xW82J+PfG1UDLccbVlzySm0D9W00aiM1bQVaQcsx5YKQUnP+i3QS+W+9tRxvOONz/mdt/uMoR06UO4H9e2JVcmdfUcdgDZAC+ZCbYeZDrMZUP/Cm7H9VWv6td8jAIrzxZDdouunRAOlA+vIw/MhAzofjP0cEYwL54OOnAdyZL0jbYgCHCX6m+aahdd+0fwcP+5o6O2bvJZhO/0Xs9Z1JUgiUqRnixIo6BiuBFMgHH38Re3soIryHof8VtM+yLh24Iw2Gy5J9liOPuGQp6hisB1IgH+byb6lw6eFUyR8JRW50oMAt0IkVdQzWAimQDx35z183YXDgB2EbvGmpvhBQPEYM9s2VY7AmSIF86PDPevgjFRQR1sPw+ltX4kc78v3f7Dz/9Gj8qrenP12YJyKbvTidcN1yan60ks5nXkwvBWQ+P9D4TNtfu6ZLaDh7hRQ2H4bU/umrhs/iQQb304uOSv98I3/LMJp+c/Fr0hMX5AnxNkemM2/HDwxD9B+DFkoj1yPElg5hr3n/o0tpn1wZ37STTr3/5S+5EcCM3X86HmbY+CvXlR9m4AU9qx8QNLU1mP+xH6RP7v8I++EkLEHd9/z/Ml30+i3kB7Ku/kfvHeulzRdfkuLPLjluF66ijsEqIAXyYUjXX3Zv9ulHjH2kXeUxs43zMYbmh2S8s/g0+bdQEXCuIMg+8a/8+hvS9lZvtLN870D7m39gOuFGeS0QURcI+1P074qrTWIEXsf1h5csYr+CcqE0mBmybHblv6qt1DPwOuIvybekC0vLhdIzEr/286Xt8HmxP1RHIB/W0fzTCwGL8woBI/6FgCb+e9PVH9hZvqCUvIX7BOewrMihJxUGLKMRcWJFHYM1QQrkg8v/qu+mU5+zIfncKP3xB79jXzChiDiS9jdKX97lFQL4XpHr7K8/fnFYn2OE0oP9u+qJLz5Q8WBhWO1/FfVNBzzC6r7g5bQ9wrj+f5m+8Drum0rb9udM419ofZPWO9S+BCNsPrj8j+ufFSp7xAp/TqyoY7AiSIF86O9/ZceWARoj4u/4oQf2zZVjTNI/q3N9g4UZjH/OP/YWLv3/TLa/ufy37T9ef65flWSpfkTD1VMuJmHzof/1L3ZIJViYxPX3wFXvSE+neafUefM8hx7Lq9Hm1Wd7C3YOKwUEX1yB1fCvtiqLIAXywcVPc+glr8kvA1C/No/m0B+/4Q+ksVLn0PNzLNselT7Fc+iuP9gXy6zgGJ7s8t9qz2z8U/SPF8e0beJegT6Cc+Z+uEU6ZiR+fnHxT2z+2fX8qTeyQzqU59C5Xqgenyr5I0bgTaL9a7lQuhgTNh9c+xNK3dqRxin/csBGNObQvC58+dkyTjF5jYhdnkOX7S7kvIRxJdviccrFNIcexz/ZE5PwM5Px40XAHDvnIN7/Zuf448HLeQ7t2z/lu87/vBfQHJpHyLMj/zamzfXE6eaTv8bOP1dizv/DPv86ygmtUJtnZDnKodaQp4rAFqCzE1mOcqhTd2jeJmAH3iagulEYTcsRvf8b6R7YAgxWHOGbSYeu15wUvuqWdMni7fUBhbuJoUNSSA/JT+OHmflvmP5hCxA+CEaWoxzq1KeGwhagsxJZjnKoU58aCluAzkpkOcqhTn1qKGwB0g9Kt3zi6frGbPgBwhTqEzM1vygFs4DgE4wsRznUqU8NhS1AZyWyHOVQpz41FLYAnZXIcpRDnfrUULaV9z/1gxhc/7I3qFh2Th06NaeuFGwBdoiU5RQc6tSnhsIWoLMSWY5yqFOfGgpbgM5KZDnKoU59aihsATorkeUohzr1BtU2FPu/Rgm2AJ1CZDnKoU59aijbWvHl9KGn0YNx7v9oxZ6DP/8Lufeom/vSMtpeZ0f8wE5LHzYvBUzNs5ZCLIDOVmQ56gHdJmB+7q9HFh2ZPi4vA6Dwb+lHh93yl78L0oaHnJ1udsWhJRB8QCeMLEc51KlPDYUtQGclshzlUKc+IdRWv7HJpk68ZZwm+SyTzujGUQ6dkNNBSrA1Rj+6YFlmNyHGfVjvzTumQ2np4KpjHGR9fJn5b1UhUomjHOpLjd18UjqQV5qR+mNJZq/RgY/RMtoXvCxtwePivuNPsrnlG9KSe+oNnzvsTZaFWABd+chylENNfZl+3RAfknEucP/bJNVbUUhZ2AI0g/VpdgoOdepTQ2/NqwMNzP9W6U/P/GmxP0z/sAVYvFTNvCjEa0Lbmys2ORRmAV3pyHKUQ5361FDYAnRWIstRDnXqU0NhC9BZiSxHOZTV7Xy4e6ozMxiFLUCnHVmOcqhTnxoKW4DOSmQ5yqGmbisEUHv0LwSYQkFW3XBC2pfuk/Fe4e5/Ox2fvtJ8FOacOrRYnTy26urj0lP4h5r5+6V3XRs+SxBjxQ2vXpOX4vX3aIeXecIk6wEngK54ZDnKoU59IFr6Jr4fP6ZsZQNbgM6KbPEgfRPlCLECch8HfIs3lr7JlZ8QCr+ArlBkOcqhTn1qKGwRxA89/no2XGLl50D05SfKTM1jLAVbgE4aWY5yqFOfGgpbgM5KZDnKoU59aihsATorkeUohzr1qaGwlaGd7zwGLUahSByHFvkUMdgCdGYiy1EOdepTQ2EL0FmJLEc51KlPDYUtQGeFWXY+8r1GxB26rtjkUNgCdKUjy1EONXWeQ++9gfZpeQ5tMnqxnufQj6cf2GU8PH9nWSkgrDzZYTOyHOXQ4mOSWP1C/Y70MsAybA7Atn6brrI59Py0waFL0i3wCzhJl53qsAXolCLLUQ516lNDYQvQWYmsQtm2e+j/8r2C26qOacoc2pnrRmEW0GlFlqMc6tQJ5Zfq3YuLUi/Mv1C3RfRSvfvIDbYAncHIcpRDnfrUUNjKkMcpL+icQ0OR3DhUnWIOjRj5OsO/i1/GKVVhkIAuishylEOd+tRQ2GJoKwSg7g7O5vEHVti19u/qbfP/rdIzP/WzNkc+/koKkbId5dCqyITJcq1qXds2VTcz59ShE3bYTxG2AJ1eZDnKoU59aihsATorkeUohzr1qaGwBeisRJajHOrUp4bCFqCzElmOcqhTnxoKW4BkpeO1R7btNOCqgyUi4TuhoYaYtcLp9ABPq+V/7Dfnprc9eb1qwu9vEhulrQ7/XLrBV8Z5VrRD2MESXeE7oaGGDI5/+UXpna6+eFAByF8tyBJAxVysrfCd0FBDBvuP1jJVypq4gyUy4TuhoYbM+e/IasmOZZiQe9N337NIBhSyRLH/IrG7QL6QnNBQQ+byP+H841yU3IFjSTSGN+r0DTXEihaOu//lr5twvXsYHvT5wr4OwndCQw0Z7N/bMryUHcQSmag6fUMNmfOfk1gy4s6/JdgjXrOjcKPq9DOKdlQmJz07D1zclfDWMt4h7WCJsvCd0FBDzFfhwL/+eL5ABvMbpccs/u/0K1HymvmBhnzlQBMsWikgbB9Q61tRQwb47wi9BBWFbC4vccj1lUH9InoZ4Ib7SVB8CTp6Rfqn/TfOE8NF6cBzbha20/Iloh+hvGYWd7CKqhMaaoj5KpxQ4xnzX1a/ofxVDzS0veKHW1/TmYi/PMzAdQOI60f749+1uZKquvoaasgM5P+BdMsZzyjLz9NSh2e4JZlRE0AOwvB7zkpH0rYBiLeGGv+O9KLOr9rYzZBZc4YLDxigFeu2SFyvmZU6WCJh/jLd/xDnSq5NeyjD16qOob0Jj2cPDnRIO1jm39fX9AwxaeHkCFdekN62tT40qvMOmmNZ+Jrz0298YVdTNe6EhhrS37+3E/BS1tiZ1eZ2hFScvqGGmLRwQglzURCvmbkdLJEI3wkNNWSd9s8P+X1b4fOjfw+P+OXk5lW2OPbePqclfX2+T/y8kgp/BdbZ//BDXVre9TL30Dpn0xoRaEBxU3wVvcIDBpjSnenStz5OxgfzDvhkx7OIoskP2nmFAD3H8V4h8dL532CxW0nMihpiVSqcmbz+VqSbq76Jl+H1dUEqC8xS6puwpU3/+Belgy+4oynqI4QvQFb2eCkMrEPawRJt4TuhoYaYr8Jp/eve0OVHhfqali8/eTul+k+MOsuGGjIh/9FsKWv8DpbIhO+Ehhoy5z8nsWSkPf+s4vtWPv/hzxf2AuE7oaGGzOU/56tkpDv/Ja2qqffXPNerzweURdVZNtSQac7/79I1H3hyHvvTHPpN/51ur+o0ll8K2FFeCqB4ulbHRTwCS92N3cEqqk5oqCExfnoZgLcJmJf73xGeQ4cX6tkqlaU59Gn7b2Jz6IPOucXsWJ2yajib5tYQK1c4oUQwp4TXzOIOlkiE74SGGjJU/7xlwKY8zrH/evzHq+xxPzE9/nM2ChA3fNBxCupV91/KL6vsldoVUwXrkHawRF/4TmioIZaJwvHZgdcVModeL+d1BNsFQOwLg8eQ+fd8xsYp/ePfMb3kgjKH7mdOTXdIO1iiK3wnNNSQicW/LL5UX5+/WTv+GL0wHbe1vx7K/RrngiHPoe/S5Ja0OTqiJXfG72AVQ05oqCFN/qVebv5hPgwpZQexpuqfy3V4MFed0n4FhO+Ehhpivgqn08Ocf8uAz1RmdrBEInwnNNSQSeWfRp20jEYpa4WtboRADMgy4IBeP+Jew+PQGqL/Fd9Nn/izza2zbJZBpYtw5InHpnPu8vvXDdE/QgrQx+xxKD2U7vvaX6XdMVgbcW+V0Y1spLdp7uBLzrkkLAHCWgu9hsehuabjn/Nfrr+b0tmHbJrbL20ZkF8IwFkD5DMHHBBns4Vew+PQnMt/yX/JK7LDEFkD7MfzZQreVapIEz3MXLxxeRDUc9f/Bou/KHuDwgLgUP1TdGs0/jn/05J/HnTW/V9pya79rcH8j938D+mlm+cB/B+9KS2hftm3cdRyLC1Py5bQSgHoI/mBRt4PsUsf5RR6DY9Da4Ltf5SWOHTbBPTyg4wui5zn0WvfTV8i5gf4u707LV3OX1h3aU/Qf1UalgARTQu9hsehOXP+V9KWAbodTr8JHH8F1z70Rq0BuebAARFNC72Gx6HJ8ZcXAvz9lyfFeg3ReRyhFQLcC3qwBAhrLfQaHofmMPL/Q/2Ri+rL1z1vF3AbzFummNHl/xfpwtdtmX9wovKu/ynxL0gbHXVh+o3ZLJa6LDq1ymeX9hDiv+nEvP9hbFfl/oevZqbJfwy4orxPj7PaVem0fdaTc2YPYLryv9MJ6St0+/ClgQNWTh3pNTwOlcnlXx5m5HYGHJa6offpcWhPzn8ppViXRei0Gl3aa7d/PQdlzsh0/PMxexxaa3f8EtHK89LRecuAdoUAHzPjD6a7zn1R2rxqw+X6o3vdkRcm/0oALABy5oADIpst9BoZv/f/pqMfx+ds+3Tgub8cZ/w3mpadslfzAgOuPYbrH/2lAVuLdfgPlZzm8z/2/dI30fMX2cpmwv5p2wBZjpf733hvL/HPp/N1UThfwbydKeb6XEBrmuMPPvv7xwsB3f0vx88/9JS9oWEJENG00Gt4HJqzI/5SG2AFotaALAEOWLRrzGt4HHqzJ35p067/LzVUzNceOCB0W+g1PA7N2RM/16i7hlpXLwMOiGha6DU8Ds3+8Zfxr95/fGnggLDWQq/hcWj29180FPOlga+SObTuYd7Lc2iUi6Vo+4AlvAVfvo/mlQIeoIzP2POf0avlZYD5ue/VlwF+38c/bR5gc2j60Xv3d6dLZA4do0IeYsye8hoeh84Mxt+ndU8m//xCQDuH5rEE+kfMdUp8wPpdXZPxD1vIJGD9QgDXp8y/ct1Gdmi33ZvJ9jco//aiqOaSxyl4zRAxAnIOgCu81bbeK+ehjp/GKUdd0DFOmSXtb5m+ELD2jT94Dr2Ba/+4Dqr888pfq3DW0Ir1TA6n/XubHvc+FfdthPGZ9u9rxy15zn/JiD9b4IIHyHzggNBtodfwODRnV/7d04NcWQG+4p7PQXgZgpo4tNKEGC7FMyXASzyfFb3M+6WvDT/81LQZvTFvFxwmkQKJP/8p6fD/ye8JkZloyfvxEs8f5N/XpT9ulgkp+M3pwtc/ptQbnTvXe2TjtEtYKs5K9XcyQGKlvX/RzxIBpkUSz2dFL5OCkzpYaUIMFwuZEuAlns+KXjYp196LmImWvB8v8fxp9v/Qpen4xy/I7YDepuQlihGvVcmQyQdfrM3O+C29PsYZzP+a8L/y3HQMHmbius9w/aO/SA/61vH4rRX7OB9G53+a4pc+sOr/rHlnxGc53me8xJ+XYMFqPhnELI/dli5507ZphOo40tsuPXfJz7Sli4JpkWn4p5UCPvNSeaAhD2p4+4D8UsDU/JvlXBx+mKz9/zJ9+S2LbO/hefQywOlhicOuGtydvv3enXT7l5HN0270MDe8EkAuvBejhOklGTeWIV1Ox+VZaUIMl1KZEuAlns+KXjauu6DADzM2pnub/fjCuJx/TOLoYcYp/NDb+xief66MWSbEcPm6IS/L7O/BMv7iMRjXmb9u4BUCSim2N9k/Kx38s5UsEWBaFd/pMYo/XuoQ22r0FqWX+i8moZOhWSYE+AOXHpG283ED9/E/mpdm5hIoVRmeIGmlCTFcymZKgJd4Pit6WXa6LD/MkHp3jf/5IZm+aGKlCTFczGRKgJd4Pit6mRSc1MFKEzKWbknnv2bzcD3Y3IVjQf7Xe1k6+Va8xGwWJuUXylZa/IPLMEsEmFbFL18x8nWLunor4+FmmRDDpVCmBHiJ57Oil43nrZVbaUIMF7VMCfASz2dFL2vtj8ex0oQYLoUyJcBLPJ8VvaycD5wLXjFg0J+VJsRwKZApAV7i+azoZYM8dcusNCGGi2qmBHiJ57Oil2Ufsu1Wbo/P+qe8QkCWVUBK8w/yj9UfUWL/k21s+IrEX7Hr3wT8Vz4GkWP+hYQ/enM67z7E4/2Ax5YekO1stM/Ue5uMf9z1xy8OyxLQgxxnmVkmxHCRZUqAl3g+K3pZNjoAyDK863Feue7uKzkyEy15P5CMpfsve23ajmIdFP9I13K8feoEy+zccNHNlAAv8XxW9LI+TgawrTQhhpP+6CUdL0vi/i/xow/zpQY46iOy0pV/q40omBZZybixDOnjYTDbShNiuBTJlAAv8XxW9LLBvrqkVpoQw0UxUwK8xPNZ0cu6PAzmWWlCDJciY9af4l6ulrKWKRsy2FEfqZUmxPDsvwAvybixDOnjYTDbShNieHGcmV6ScWMZMthRH6mVJsTwPv5t/JXvP2oylurjpi/bSk/Af/DnC5r129JSnkPLuJfn0DdXMZliRu5LN9L2AeWlAFptb8lPct+RHQgwZ1TO89mMl2WzEwFjt6bLjl2U5lFdpf/a8cj0z2FlAO8HPngO/cTE2/ON9DCHhmwiTlsdK02I4aKWKQFe4vms6GWt/fE4VpoQw6VQpgR4iedrP8ErBPjxt55/jMc31RWF+1TELBNi+CT816WKG9p2T7YM6Jp/lf7fXqofuv9Sk0GYxVz5H7v57912ATvQHBpf8+cSvmDjgMYpNoceED+NU85yW++ZSbHn/XiJ57OilzUVGZdhpQkxnEsta1fZi/e/2Tr+uCWd9+ryEbCOM/O1wOMnzKMX/nk6+Tb3wVEdP7IhSfGZybixDBk3110KXNpfr3wd65/34314Pmt6WS46CWClCTFcymdKgJd4Pit62SQcZ1UrTYjhIsuUAC/xfFb0smx0EsBKE2K4lM+UAC/xfFb0skk4zqpWmhDDRZYpAV7i+azoZdnoJICVJsRwKa8UWmNjMiqTuDLQvlXiSgAVSG9AjG99fA0y4u3U/kevfnt6uu3/QjcC96atDrAXps2PvCDdkevUOKwY3peIxvEfaofC2RfI4qLl+L0N45t1fCPWveN8qTr+1fVf6qaY9zUT8c/5pwzQfjgvkf0t9eHJYe6LxNl+/c21P3fFABU4zv0v73+KhwAyWcovNdVbBsAsXytz13+5Y2heXHaAChwn/8VMwGDCmMTwvNme/7b/8129j8QiDEijMeT4x/JevjyAn/ecf0zfXRE9RoqqJv51pQB9oEH3SFopgF8KuF9q7koAFbia558eZHztPU/RLwp5TLH589NxV/52Qtff2G2fTK/dJk8Q6eH/uffyKwH8hwoq1XVsNIjhebO9/UlMUuGSf/u6IT9g03tezo881KItA/jlR/rzsYLhecONvyx36O+/uCcz5BcCDl1atgwYrn+JMBx8rIPjvz/dcMrT0nqY/PKPI7/L7azKf3FQWb//8+ltf5R/IJNY/TnRSTXH/5ILf20mZk/81FaWnZiejfilHdXj/zyGLrU3rB9SZUgapOcNJ/4709LFW4UfArrb3x7pjV+7N1wTw/HfL/r+1588JJIclzaieXHZASqwXP/FGxQKp8YaDWJ43pqKH/WcLf5xj/IPiC1RkrCHQf5pDH3Mpvnh37NoywA0lL7x/zp9+Vhdsj88QJR7H9/rt0x7fuIGS6Occ7IFs0xP+fzzl2jPfwT5WJge9dZL0+/RoCpYfLktA3j8Yfe5cv2tt/hLtJJYKWGosNbk+b8/3UirG2CLpZ78cB9ei6yiLqRFk/smeYjaJ35+0eDgC/E9H9lA4TUeP8czsfxjbNR9/+c2GVdPmnL7kxQjQUJ0HhoNYnjenP+SNs2Lyw5QgRM7/2xNx5l8rvXaLh4II1swy/y5/JfsaF5cdoAKnHj+i0XNNfpWnBeYnS35xzNjrt/8ff+hzKFR0c746cV6Wing8bZSwK6dL9bDhOWEGJ43qfZHc+jLaQ69Gcbmmx+Q3k5z6EF/8DV2O8+h59E1Qf37dv8rnXufzm0m5b9xBOuNwBiNBjE8b035H12KFQJK/y/t08YFNNeRl+opFKnw1Nu/JYORceOnFxflhYA8Dmt+f2E+tgzwmQxejGg0xvXvSgAVOJH4eZzyVNl2Q/rfLf6y/HCPGo3n/4H/sjm03Df6xK8vGqCCMN7CRmM8/751orDAicRP/peVLQPQ/0gc+ZqdveOPX6dLFtMKh9b++7W/PdIbLr83JxoJavMOTqNBDM9bneufx/ByP5Pcdr/A7X1JnYboP0aCiCOc8x/zMf79z2UMqMAJXn+tu8ghWzDLgtVpf9FSdGO/EjTV9h5jGaEa/aCDqgNmIUhAF2JjbzL+V3w5fWjvetmQqsNceGA68ScPaEWG7T/EzgQcAGYFkICmxyVulbc9tTPRm5rcNGipOHkhoPLR5CvI4QBwIv5r3YoO9rm+g+SQAc75lwwgHYAuh2PpofTbcw5KG3EnIZ3bDrZlQJX6bMqMdIghA8wqIAGDf2Oq8mSuv6YGsAU4518ygHQAcv6rFwL89T/oy5+568+S2LS+qd1/K3trefvvetBtl7uFagiJCq5ttaKrLDf6QY6ygFkIcuw36evv3CH/EPYk+vL6zkn4pwca9JUDbx8gk4D8UkDu2WtHoVYWIuphjI7+jM8/P8h4r3uQsdnz0pu/doeUmlj8y9P1H95dVgkY6W2d9vnUT9XjRP3H2gdqYv7NkZYFCThe/MFjJKbif+XF9DCjnrjlCadOPmmsk18ICCPe6Fqoqfi3cJv4V9CyzG6FgFxHHX/lCaY8zCgLSQ/Xf5/21xE3WOZ/1RXpo3uvn68lXj6Zl7tGgIC5FEhA06M9rY99bLaB8UeetLrzteCQs9PtZsqMoEoOQgZohRQxtiFUk4KL0mTuv8v8CgE4X378Ty+a5Jdq1bZWo/QTq5F/mAoQsQBmIUhA2tv1+x94Usk7roWm/W2T9lvyi8qDGQl8JSAD7Oe/yCea//CQKNezrQDsAg7PP3w19YVAIPwCrrv+/fkAXtr1uh+/nFk/huYXAuxe0j/+VVcfl56CH0Vw3QFSux7Z+yPpKry/F9qWElNtf6uuf1d6+jy6R81/Zjru6uVmubFn9z98eYf7WoF4CBpeHBaLiBswuwEJaHmapvvfqm9a3zTSm58e+fq8FcOk/N9JX5bi5Y0SO7d1xM943IoADgDXUPwuv92npdRvhV8hoLn/c9zxOVDTXnKICmAXcPbH38Rj7T8EZkSjbxJGEDdgFoIENL1pav/OvtQAfgGdnOPB/Rsv/eRad4J1Mf4Q6Cw4/3H8b4/K86m0kxiqrQRkgFkFJGB1/oOhceO/K33jb+IcupSHA8Da//J0U7VSwIFn/YjWonF/4/qvbLui4frLLwPwFj2Sz81pDv3V6utrKtu0Z/P/B5tD92gO/cwzdQ7d6Pfz7/moMuBq5d+MeA8ZhwywH7vIm3gs/mgeL47V/Z/dO6SfuK5yWJHm1pAB+Y/+QTX1lVX29iz3sPxSE+rF515W2eNVb82tIUPwj5oxhF3ALAMJCD2aQ39kb926rUfjFNker0/+4aWNvx6n+Pmntn3OwYJDP5tur/1LjY2pLibtHzVjCFuAWQYS0PSoxDK3QsBaNf5Y3j2HbtrfNum5Z+U5dFf8LheSrWnMP64JQD1jVik9WdPov4RafDbtec5/vmi6QZOvoIa8AmYhSMByIggzpiqvofyPcD1oABr++K4OFtWOPjZUyvNDASIaWcWoSCkuvA6BZ43v/4HeslOf09vluO/1VuV6SOXJCFdb3rvtrdfbbPEFvZ994qAeDUzsbzj+1Zyvs3AqRkUWFSdYdc3be0992im973Mg/Mdpp0V2dz31W73r3rpLm2NR0oMz08lo5Gya/qXbwsnWksHP+PnvdNc0iDn/5ZrKaa7yf2vvC0fu2Xvp/7kri3fsHbb0e71zDqRNMGb19Td3/jkDTfuuGBUpSRPe6Hm9Y7Z6Re9f7uNRGHPKH20Z0Lvn9Bf0Npg7/5KUrhwiW42sYlRksdch8Ky19f7H94zS/0lHwk80kK41G/+9S3pvePzrep/+DY0tdjuhd9l3T+g9d/3SCY2f/+W9m5Yc3jvoqC/0bnqIQpm/S+/Af//P3oVHPKm3PiL0RohXkePHn27rff34F/de8qHv9+7j8ps/r3fM5/+j9/F9t7KxEVwxbOxnRrr99N4rn3xs77zfjfVGnv6R3nev+JveXrRuopVpCkZba2v7qxPCYT649LDeli86X/KpGShHaq1UZKPeovec37vg1Y/THFOToPFpbx41ZHmaRAfW0tbsx3eaM04r+xGFMQK8PmVm8L21tDBVEh7J5y94sPcrak/P/fsfsaD8ZUcCRnbsHXrxVb3zDqLvXDr+2E2wXzEqUiwIr0PgWeOd/7Hr/673zD0+3Ps2jRnpgUvvJRdc0bvw4K01Ea5C3iaqX/yn3orLXt/b6YCzer+AkGGIn+gNXtU7/edn947ZknYBrf4a+xWjIqV08R+Ned3x4peSN53Ye9YT3t+7gggua/Wm+uv537S386lX9H5EY2j/NzT/ZNTXWXxUjIrMKqO9n53yzN7j3341Vbnt/y2O3ia9nU+7snfdsbsIy8cAvLFfMSqyVLFD4Fl1/vlazM3C+hfW8WWKcdSuIz8kkjJNwahb+3dNuhiHLc+p7FakaK4L/jE34IBwXjhn9QlZV+OXE7nyvN7RW76i90nqqNOzTutd9/Vje7tWAVdkrzf2vd5p+z2n97avPyAm2utvr94x3/lq7+NP3WiI86/lve9/8Om9px7/417a959613z5Lb3d+aRVjdrXlfbm7d186j69Re+4moLTM4zzjPEdvRDQu+cTB/Y2kEjywRshVkWKkvA6BJ61Otdf+vHf9Z6xO/dNXOMdei+94JvUNz0mVzDXyTvLEs+iR9W90S9T3/T8Jb1f9Ilfim34yt4ZP/8stYPcN3kjpFCRUkR4HQLPWp34/Xn1NnOY4f734NJX9rZ40blxbJRPtIAR6gNO+Rb1YTujeICN/YpRkbMufh+Mr+tM5X82+Pf3cq4Px/5wih/nYLac/5F5dOVRZfT6oy6D5iKMd/35Oou8YlRkUekQeFbf809z6Dc+4XW9M++iOu1+Qu/S75zQe56bQ9c3PG9T6//73rIlr+kd9Pov9H7Kc6X5u9Ic+vze5/McGnH29V8lobEvDJpDv/fFvZf+7x/07uEKbfbc3psv/I/ePz9na80p2ZjQ8+fbz+i9Yve39M77LenLHPqdNodGNbr9Qzr77/+lprGudf4fXPqK3lYvOq93L+eOmycHnv+knfYe2Vv03vN7F76S5tATnP/yyfDjH8sl25/g/Hve/Ad7v6b29Ny//zEbkyBK/TKDxgCHXXJV79yD9FcY8WPOEMXg+NlS119jpmJUpJgQHh3GfvR3vX32+EjvW6uYswPNoa/sXcRzaPqr89/ff+qNXvY6mkPTOKVv/GSQximn0ziF59DwL/kSb3oQfqYn7l/Tbma8EWJWpKgF/ze9v/fsJ5zY+4YZIARxcPlZO/4Y7f30VJpDH8dzaI0TSGx/G/d2OfXK3vXuGUCI38XtczUd+e/q5537cK6mwz98ran45/xrBmZl/qnBub/qLYXw1kIto2IdLDBVRMcunb5vP9TKnvZ4rjKxdFleLHca38qitHPO08iC/dK7rteFhaXkEP275JVKEaa15Qq2Gn2/flv1nXTaszfkx95Sb60/vprrMNTBgkMV0bFLZ7bG31TWV97jIdVVglXPjh3F+uZ/Tfq/96x01Ba5vcr55+WVyheJnSeyK7Ycw1oXv5zFOiBPe3wdOv/4uol/D8D9Kl//6y9e6vYGXUfjD1dvHaOnPb4Onf9pih9tSfo//RW1eFqj9/8H0520Esrm0t43T7ufel0qH+LV59jTHudQaKWAz7j9EOfRfoif+Ql95aB6dqyLcdHx4h+7rVrisKwMwMXtr8t24/+29MXF2/KTJLq+n5re/G36KnA8/50OOpx1sNBPqIiOXTpryP/oJa9IvP+htE13v6vpOP4hfafLMpr42b0ytPMwbio6NDHMNlxZZ3Ni/neg/rha5rIrt835t5NZkKHl//fp+pN0BQqOYUSWOtS9ryd9/h/gbQN03Nk///SW/ZJfujgKWjDzTCzCu3I0tPiz12VY7tCPm/35xxg66w/bfzarYDLxr0g/xTKbrj125T+OBRBHcByYVosh57/r+ou1MM/EJnzI/oOvLtvZodWiS2fWnP8QjeYrsHzlPZ6ViNV1/2OpatOxo9g61//wGHpj/rmcrv9nnUorBCDsQfGvSLec8QxZJrb7/s9L+v+PW9K/I5EdLOdZa+F17r8gHSdbszw67fUv1ZYEfNKak8WFacuAU8uXd13XX1whQB3a0fsXH+ymi8nCmu9pj2dDHSzYGKPMXf/h3XR1JL63bUlb2dyTC0zWf9U3dff//AUY903qw45ddZysfwm3w1AHa6r+y1LQuR37MY70DRu3K0UO0b+e0dqgpz0+kfPPOlSmo9jMtL+1zz/u5ej/Y/I6EtnBQhkV0bFLZxa2f21RdWU97XHV7owtM1Wbjh3FJtr+cD4w/8heC+iyPUT/sfLe2YPprnNfpNvY9TZPu3XMoVWbjr4Yam7n/z5ZKYBX25MY5+8s2wesgF4o3GGogwWHY7IywB6yTYDMv3hlgK/lLcfMvznKSG0Q9G20eu42MtYZwRyaS0AczCjTjl06k/bfx1mX7Wk+/yv9HNr3ETz/m9b5r86nusYfuE7G979IV72dVfnncQrNoTH/om2NzsY4JTSwjpNds2h8hzk0csIwPn/YJu171s9Diy1EbdDTHs8lOli4KFRExy6drvzfVFbZa87jrB5/+O0e+83/9f62vmytRbnril9SWifL0x5fvfxL20B7o/ZR/mofnvb46vlf0/HP+e84l3JKa76nPT59519a41i4QNixcy6o0pUkdH1aRVcu11mAFOwjY29T9n93+s57niiTTrnxooPMF5tOHGmP4v0/mW5YNR3+OTpv1+MSuR6YHWJ0MhGh3Cg9pPjTtJDrLzHwA2x+mKlLAIkZV1RLoSwLPF4pTsg/bDg7girNRyeZBecf9UWsvnbg5UrP6vhXpDuWvIAG+LlDk/PPLwTQnsUSksbFRx9h4SJWLwVvbYjf15txRwuqdCVZN9rfynPSYnmYyQNuf/57SQYw63r8fLbDtVmd5bn47XqoMjOw/Zf+sAySyVDn38zm/6b02Zdvom19g0PSybeuXI3zzw80XpwW5aV/R+iBxkFn/TgufcgRS+KkIY0f/9gvaZsAepCB/ndTepBxObYJCHemgfn3jlZ87Y3piTI22TBt874raXOY+Dez+Y++mZop/7LcIeUV4zI/MWp4yD/nLeOib7Ty/Y8Dhot+5ceNDRtfJGt4jf8d06H0QoBvRYq3nCbDrBLucVFjyvkfuyJ9zC11+MgjL6DtAjr+JuT/XhpLL9IfGDn2Jn69j8w/hJY8zC7WePxSD6rFMrwQwH0o6u7PKY2hT8Eymm1+ppx/+DeTmhEjgTC78/z7hxlc99j/My3tks4FjwV4SVfvQfGWA7cG+/pXjcnE7/PLbYTrV/58XQp3UvdfVS6FxaTalTCKJOfC+/R4pdiZf9WZTPzeg+Itx3nODghMk3+9b2m7Bz6T/rta5Iz7zy/VSvyyZUBVAz5FXfm/89/S4Y/Sa05zV11/9ILVkt+VPe/FjDM9ufP/ULr3gpelLfia2fwv0qfucq9BhrpVXsb4hQDezibXzd3fcP2VFwK0Rq6KiorJPjJJjZeJcjEhIpVXksHXHy3D+zHZyobrTcvwvr5P3zQh//eUvqkjfowLFrotbUoA7ECcBJYnZsP1v/IS3hu6an/u/t/rbZp2pm1v9Exo7ctZQTReCh7BtSD+UlupbCRdS/MRKt5ySuGMiUmvFzVmw/nnGtk1zmMv+pc/qbbWXcJQbhF1tAinoqgUVBuNjBizJX5X2VJNqbbWXcIoEtcqwOwToxTsI6Oi/eL34y/GZ9q/RCXV1roX/3kOzX3Jhi+XObRmQPWQDYNSsI+MXqy/8TMvTo+XOTTdf/ilgCVu+wAppmXFjBnV2wqO0T9ttfeep+QXFsgmz6G/qnNoV9zQfvkXBXG9KvEc+gl87+/xHPqK9CAJS61gSjmgDErF+8jYzsD+l60UT95K4cKTl4KXiwcfTsbiIGMbzo6gSvNxBfcTfH/I/SDGfEwbnuVhTCO50/tK4HfpMk/4Zf5h96bsd2r+6Zk2bxlQ/U0mfpcZd1Zg0EvBI8jskGMv+2b6yNPWy7lbQFvu8TjF2RFUaTHjiwrudFMep3Tl1OV/oZtDs4k1Gj/8L+M59No4/ngg3ZRfqh+v/ZdxMme9/M10/uvrb6b9l8gVm/Pvr+HqKheRyivJcO4/dApmU/511FkFrTfQutkMpkOyAtGWa8RT9S9fVc+jm3m+keGmC1puzLT/5tn1/pvaR1jNpurfDKg9McO8JkCn2CV2/lfd/OH0ggW5w5d4qq+boimjgstAmIohjdj5N1QQKzIuEmwGoi3aiMWXHPQiaxRaGzUnFAlErdlxesS1HNaM/4doH+CnYw8jtGV+IaAdPLXRKCeEHIi2RCOW0OWwZuJ/OPsfPU++btIBOF/3OP/8I8AX3QoB7Xn0nHBOA+G1FG/ED+f8c0rWwfgxYfMQLWGNnv/ffSq9ZiPt32xitFr55/0QX5rkKwfuL+fvkl7IKwWITUQcYd/46auGr73nT+SrBsnbZvxVw6+0eUQTDRVsBoJUV12ajn/CAp3E73R8+jK9ERCqJ4RyDA0KjbuGwepWJBCNquiZLouFUI6hQaG1UXNY3YoEomj6/Q85v/XESHLu7n9K0zmlcZwf41k5e2hR7pnBRp6Yl3urtjvYNTvcbqDb1/+igf1xCDkQJX5gjZgZOXuGCoIS3VD2o57PD204/l3T4Zfl8ULjIJZvxNnpg98+hl5cqXNZ5X/DV6Yz7qxfadHaW5UbBxPzz1q5KkhHLNiPWnZi2kfGyji/OQac0xEaQ9OPKfhrqmdOp+ifDAebgYDXAouYXwjYyx7uhbbr46E4NsDXDcVMwIpNYgciqAnRiJkxwfbHdbTrRvI70tpsHIiKHRrxJPybkQoJNgNRKRLZiNdi//qjRbxm2wBjDtal+CUyGkMv3iRf+/xCQBNgv/j5y8PHDrj+6NnBkvjsIFoqVHAZCOjgRciFabPFl8QXt1i/7/WnLw0N6v/43hBeFur0j3rMTPtfde270t54jjGya3ot+qYcqYSMKg2MX5Ue+vab05PyPbG+/1huqG86nfumWRB/Pp2IMMCmesQYXXoovRDAbThey9In0H12hF4I8H1YMEhEsBmIWrPSZTHr5wobKgjzJ/YXXAaiLd+IxZccSlWUbAv34QSbgWgLNGLxJYc16r/u/9ua9+eEmALRlmnEEroc1mj8XFOrilanrXwfDqtbkUC0BRqxFNTShhKi56OMf1tLhcPl1EJGjCg6wIIuM0VXCxiqJIpESHPowzei+wTdFxYc8rl0RzZhRRgxIhZlqhGP0Wp7S/BiPdml1fZkDt0W7csxm7wywLvzHJrHhzyHvjzOoU0X1qSuciipUBIaKT10WTohz6FHaA79lWoKEmwGopgA1ojFlxz6+0fhPjDYDERboBGLazn8f/beBM6zoroX76ZngBHZ3FgSIA4CQUREjahAkAiaRCCJgEuMSRATAROFFxeihtHoPyh5Ihgl5okSQPPiYAyQB5gHiGCCGEVeZIZlGkWFGQKCOhBgepjp+p9Tp75nqbr31/vMAN2fT9+zn1Pbrbp1f3WrJozPc2jZZU/qv+v5T8eQ/Hwu7VfbsptX6DjKPOj2jj82LqldtsH8k3yo76ILn4BD8k57JvlvS1M4wWcgWgsvXr/sz9MBmyH/PIcuH+Gx0hT+4JPn0HuhDJFvQJQPPad8ys+hcywJqKiQk04Bq6tJIFoXjZgZd5xGCwK4Dq2etT4p/Zvu88cY7bJX5tAoX+QB5V4g3qd35r+UHssympG27Po4wWcgWguUK+4ju+lLHU5g33qskjyBfSNmxgbM/3x8lHapyU2o/IdyWkIL8xxXdYXtpVUzqnLpnJLReGlwwoWXyI0yeI+BYZnSI2nFJ16cFmgn4AekgnNHwC8w7103B/F9amMaReKuJI45RS4iVyy+nT550JZucC1bxfWEEHaPEEkgcYxU9CuuqEPGFOOFjkBUVdojhBaJ5+OXMsplApxLZSyt4t0BhquHqCHeopi/94tlC0tXtI0OZArJaL78fckBj6Ui5QUZU4wXOgJRVWmPEFokjpGKPnP1yIC6/nlBAB8ZEH3D0rnWVEAVMoWD4qsSEB+B8UJHAOUi7RFCi8S9+YeOwuIr04xH317KKkJHnWzqLyR+ssXPD514IOYxknD7QynGUhE5ZEwxXugIRFWlPUJokVgijaeHacu7Z3G6hp+VXn7u9+EdmupRGOw3+i6U6gu9Oo1eQMcH8MSO80qLAsJOAaQUcwovnluOCUCZbXcoLQbgrxqKbgRV/B4htMbvS1e98xfkh7SRV6Ulo/z6nv/Uu5CFZwT7jb4LpSpCRx0VAiFxjAQvkSvqkDHFeKEjEFWV9gihRWKOJF/BSVvk9igTolJnefyz3ZDElP1G34WC5yKNOioEQuKYU3gBl7/CrH+YLenS50t7mQG3DMXTTOO3HoXDfqPvQhHffdHPadz1lHTJwyb1HtkFcmp+GYvctI4Wruw54p496zIgeviZ6cV/a9tdS8QStyf8pOPnxHknjEffXio5oOsoXmZU6cW9TLts7V122coh4JNg7U/jZcVJxoeX1pmGi5GgOC5f/OT+uR3/8eKA4RZvk8WBsBTHSG3h1kKn1Be/NfEcxgtdAB1cGu9bSlutg7AKyXa24pdkeNdP6vi+jQDXwgHyRC//sS+lE/2CAOQbsDf/69PDV7057Trg/tvssM+k27nRlYZXADwXdo8QWiRef+dfpVct5P5p/3T8dfTSOf/FuwK8IiTAfu0LqFy/HfefHidSJw6OiB8jQTFyRR0yphgvdASiqtJaWMYm9L+7nJIuftR2RFCfVarEafGVCcYL/VhZVNmRf7T7oaFnpBe5sUn8iYuYU8SIXNGHjCkXv7C9FBqaxlooDrM4RoKicceueJ0sCECZcZsM/7KoDZbOdUmnAcgUkpFFYi68RK7oQwa9QkcgquqpRwgtEsdIRb/ipvRQ+uGVH0vvOe516dhj35yO//++km58kL8Fpr+eEMLuEYpltp1cfBco27Lf6LtQ8FykUUeFQEg8mfhyf1u9S+zoey7jS3J9BMafvPHj/ee+nUO9aunEMnJiQUk8mfpXZXXQXf6P8Bw69w3PSi899wekPRvxH5I5NBZx5eMDeKeA6LtQIYUaf73sDLAd+q18TMB/ZfHM839fuvodv0jzD3r+5Dn0CjnYQNIT06iJA0LimccXZwPzXwvnIP4aGif02D2Uc4Bx8XNOwgbJP82hz7Sjjeq+TOb7+MgNBRVrpS1h1iu6EaBki7RHCC0Sx0hFn77o/5buikfzL55DN88p0TcsneuYRp5D4+MPP5YTru87huXIqDpV4tNHYHyK8ZEwD8lFd/4d944PyoIAn+aOduVTxyGEjmn0oTM+mfhq5CMwHn17KZswPXY5FlPa2NnV/rbUD+zgxeWfneU/yJhgvNARZE1o1DoqBEK2PlJefOPaA9QElkCZYDwG9lJWETrqZFN/IbGPD6uaKyY+AuPRt5eyvtBRR/y4K4nn4/uSAx5LRUoMMqYYL3QEoqrSHiG0SBwjFf2Ky+r0lCPCfIUeHBXYw660+slgz0TDKKzAN3+d7HVfTx/Zj76qLh2YdrahExtKI685L91priRQcChEvga+GfWwTWECLNgz0TB8/vGit7x4G+at4m6ZIMJgcROuYfj4ra+g3oon5AR7JhrGkzf++E++kE7afaFO/q0d2xeJobgmLO1WIdjPl/+m1f78y0zqu6z+h+mrwO4fAdoaHsyZr39XPk+S9o+XGdaeyoKAjZr/1enb7+NtyWnylX8Y50m9tM58FdRVlqA97EqPvnI4nxYFlOMD8k4BdHyARSjq7Cw4JCLvDPACOe+Qnx/KzgAIENTBnAIcT+vTz770G2mrfH/TV4f5rFs4EO/52hOohw0HE8Jgz0TDKKzAN7c9bFOYAIN9+Lqhek6T9rpN2sd9yQ23sAc9VRjsmWgYa9Jove0ctdF879ALKE7b8NCz0+s6tjucTFqacA1jGuWPFw/5+Xdhevo7r3LnXcdUNeEaBuLj2ZMn1nX+qQzKs/Zmh9ERXMFHjFdTQZWJhoH4taXQQb1LZXRJOrizPWE8dS/J5iJ+V5ocL6Q/xF+b7v7cQXaOeW5neKkRy5+fBcacz6mg/fHZi0jzNShaBM/GuKKQ2sREf94+h2sYM6z/CRLQhGsYj9/4XfPfujia7DaMx2/+c15pUe1JAxYENNn1jHXXyHuE0n/Y81K5/xYcmt67DAv46pKdHD1OPXM+p5ZibLbfh9O/ld84xVoSk68+Xep6LI9NnC70v3rvcZrp/uMvnwb1DcEtEw1jlusfYxOneWhh2t6PTdOOT8+OHyhH2nC+8V/GJNRb19jUZLdhzHL+te58DRdmT/7zVtC5vJC32P8PD22d9jnbdrmpQgwkm+w2jI2f/3zm+PuwzTiXAed/JC066rx0m19LMjCn3cImuw1jE8g/JZ3bNNox5x9/IblgTgEGeyYaxqaR/5guy2BIrrEnjQX7KeQ/14U+/0/8nNOXoOnGh79g7xcCjxxOi8vlh3HodsFgPzD/fAQf5tB0//FuexfeRp/eTeIv7wwgc+jcN7s59OTjd8cR+/Xp50tlDj00NPmde9jj7MTvTttkuLMZv95lr33+c3OdkrjZjN+f344FAaE/4z59cXrdZbSLXZOgjdT/5J0bsQB+YXraO65KD3dkMCS3Qx5Zfg7t+3MZ16V/p2OseQ6dDcV7vvYE6mHHsAOoYM9EwyDWaHXsXjP/31SfP9amlZ87OG2O58EK2nhanpP78s/lF8qFGfLXw4Z4QhjsicjvP1062UHWCYrmtodtChNgwZ6JhjEfPxdJKBcr1B62KUyABXsmGsamU/72lBMSWeUQ56+QziC1yiqTph/XKDS6ptiI9PwXF/8x2kJuL3dThZusTBKH6MugPT72XXodz3+zG79NZDfHsjXZ+OUrypK3YcqDnn/q8t8dreVOPX7ro6v8O7Q6WfPxUSwd9b/mxnTea5/pJoF4GSAPT3pkwCZ4/yFXE8H5+kcJddQ/i/zLzNCfuRd98/UvhTjf/016/NUXprlNyY+adi+iTTo4SDhr7e/WdN5vPjW/+Bra7b3pq/7F+KzEp0UB9EJjsX7l8Nz0aloUIK/ze+4/epHxDTrvUL9q4PMO62MCZiP/d388vWZz7tfpx9t3X5fWuqLP6Kzkv3bqn9d68g+TDRB/zRV8Tq4f4wS3SVv7MkPKpiSOwKBkIisemv6g/He/zIgvaOnrBnqZYf58lH7c9AfFJ3tTbJ11tL/4/MtbMuOr02hubicXf/0y2uoZi2qorqxuXL0tPCKdfmfTgmPgQk01freT4oWA+XOao+78Q25f+vyPNPN2y8u6beGm03ERdpQ/zCaC5rar/Knd0UKUzjIu9wlkebvDvvwPSMTg+M7QFB2zoC7/Nq7ImML0oD9z25V/Z2mKjllQF3+QWmvo28sTM/5E9WHl9cTMf67zvMtWaY98ZIBrCBPn/xH6wf3FYVGOlSn3f4vSju+6Rn4UIWfmzwUZgGZ92u74tOfQi+fh7dO+1A91/r7Z65jHpv3lman0CZI+u/+wFWpXMszthqv/x/6Dt81F3/vcMjbNPH4+hkDHJst/KA8am/7qh7Y8YmPk39fDZOOPXTaJZ6NPLJ9e+8sJmnn5c3DLj89lP276g+KPpXv+8ci0s7YZtB2+/w5Jp2JBzpzFp/RbQtvMbKDxx/c7jOvfBoqv8WrkSRqf6wDPX7k+Non2hzk09X/1HLquN6KtWQ+6/7yizKGxsD4vCjifdwoQHfPHjPLHiwH8UXtlZwDWNf3JxodTB9H+7j4zvSbvssNz6G+0c2hnAnRW45Mz84cIg6Hpz0L+yRkWjoXfO3K/ifGQd0OzhWOzHd/81fke07Pc2/lXSdswdgiobYnud0yyIiQwSK3Dq9Nvy/+xG+Q5Re5xmkN/reeI3inGl6P8bAzTuvLz0jyHtucUl9A2G1OM7x1YebX593pphSwIqMcg6//4d6hN8flD5tBaxnwv+HJ298bmJw44gtcKKhRLJma5/OsylhhtUrHNsAAAQABJREFUWOXMcnz165ENmH8fVvH5+FoUDbIB67/jyICSnJyI/lrql5A9C/Hf5I4ZxZpAwVqtgfFX21Yv+Yb3na/HX0Db861ufSPqtOMPSDeyxxnrz5ykqS/+D09Ph2P7Y14QMNWv5hB7uvFzHuBEklpfe11nW7oMNC/WBHr9DKz/AXaPl/hlRa2eB+UGMhmEcWRAXfJC95bb4yX/JZ29+Xii1z/y719mlgcZPITpVqBS5eHaW27F7/z9RwXRW0hFQKBfhSW90gGSYjbQvPgl0Bthhu1fHjoxSZSvjbhpyN/cx88ZqzO39uJ08g6UJmrnC47+Ylo1J/kvOwXk8ZNi8VcOF9yWdwpA7rXU19+Vrs2LAUo5YYtDVpxh+Tf591/N0TbEK3IMTYklDdhsx4ffDDdO/evXDT0TtiF/1vsGzX95mVH1v37iNlzOP0Qx1k0bfC1eVuhVmmn5V8+/vNXhIy4YYjtWSB8SRvJGZf316YyXbNH8AIUxictkmLZmfmHX1swIMpP46gNOwIgwpHu0+2WGvSTYttp5olgTCH58iA3S/rAzRel/BrQ/7BaEJPammxVYiH8YBFisCRQsSDPRk3+pfz/Hcj9cwAti9zsXzWnE9yGAN/BJFN/3UcC17p8s5Z+foUub5AUBU6z/8TtPl+38++4/6l8v9f0rNbjeouXGGOKPp0eu+v20G8/vFh2dzrybF1IVawK9fvT+axcN+b6Y67xZEBDic4Lqv6nEr22F7k03f8Gad4Hi+qB+LY9NtY9pxi9jU51/tHuBdGzAOXSkDcqgDp3pacZ3vvrzT0qI3avUxs/PRn3tL4+58T1Qr2tO4zTiu6wJOrgA+9vttOLfJguFO/P/snTKTe13m0+s/EuR44cMtO8BvcMsl39T+xQajahDRqwnYvmHnFL+fb/CdeL/Nlr+116STuE5NKUnz6F9ooCj6noTWQQEulV4Dn1E2G0vHMFHcdQuLwZwC+p5Z4Cv/9cEzWei+ByAdTSK5KzMofP9QV9Y5zm0SOIVppW5KRUBgX4VlvRKB0iK2UDz4pdAb4Su/JNr22UvPoNbW5UfbrPjfudSFNOIL4Zd6eaFi9WRATz+Uzvl5wDp07AgoCRsVuMjZQTZPf4d21AW8nPKYk2fHBfA/PLXU/4qBtIF19Ec+ld4Dl3nv9RZHufkOaVzcSj7nEl85N1lJyazCAioyijNoTvHX0lz/jDV/Q6ldtGxUCzEf5ccUUmn18+k848FAV33Qyx/20mrRJ2V+B0ZZPf47xBjnMc926FC9gMcFPeddsyEKcPOvyIg0K/Ckl7pAEkxG2he/BLojTCf/41S/vSU46rEoWhHkVUoMAGhrFAEEANW4kI6qUOhG1mFwnlyebBpOwLdWm/R69I5963zORS3wakjHDowPvQAoaxQBBADVuJCOinQ/MPJZmWLQD8RLArQA1THQEQAMSCksUCc1KHQjaxCgQkIZYUigBiwEhfSSR0K3cgqFJiAUFYoAogBK3EhndSh0I2sQoEJCGWFIoAYEOLx1d9K5x23+wRnBu6etyiOtoUCExCOFYoAYsBKXEgndSh0I6tQYAJCWaEIIAasxIV0UodCN7IKBSYglBWKAGLASlxIJ3UodCOrUGACQlmhCCAGrMRCrnXnn4b+jI4MoBWNcbPS4gkOAdUxEBFADAjp/P2vJUGIKx2HQiOyCgUmIJQVigBiwEpcSCd1KHQjq1BgAkJZob3MwMslfvjUv2DnCIdCN7IKBSYglBWKAGLAtPIT6Yi8wv8paae/uCHJBgEqDVUBV05KrEKBCQhlhatlpwD6miznPy8KwE4BcLOSvmqgFxllEpSPCeAXGepDkEgXCkzAygbphFjgHemLr91WJqC7npq+ug5G0CLaoR1SU4AeIJQVigBiwEpcSCd1KHQjq1BgAkJZoQggBhyjsy9lhwCaqJWtOOPkiL5ucJNOdgdbcV0oMAE1LhARQAwIaXTK0q5JJb3EQNvI/fLidMzlD4gLOARUx0BEADEgpG38ImkUe/L/6GXpPc9ZUF5m0FaHfkvm7Gom8bG9dZ1/vBiQSXbe8rD/bYZLRZ0HEoV8OsKhpUSiKijoAY7GBQG+3qT/88/QcxAfiVUoCUPyACsxkdTuzur6+pfL2pc/7oviCQ4B1TEQEUAMCCmKUWgndSh0I2uc+lO8ZLF5F3QNihVsAVUeGI5wKHQjq1BgAkJZoQggBqzEhXRSh0I3sgoFJiCUFYoAYsBKXEgndSh0I6tQYBLESyUPcYM5NbgTCEGmHOFQGERWocAEhLJCEUAMWIkL6aQOhW5kFQpMwGpBAL5jghgQPtv2/4N00RueXpWlv/8WpyMvprOQYQiHgOoYiAjkele65A+fSb5H0lbHXZruZ5Vg5wiHmqc4NnXdf82CgBIA7gDhc2rx1coSDoeAXmXNZenUPWwbXj7K5iEvZzzYOcKhMImsh9ItH90vjYR5kvVDuAdGDv9MPtIGtoDwOf34xRMcAqpjICKAGBDSrvi6WFLz5tsf55HHsLL3BRwCqmMgIoAYENKu+FnWKFZVBUPoAapjICKAGBBSuBGapTemsw+sFyGW/O91arpCF+MUT3AIqI6BiABiQEjb+EXSKG6o/Et8tF+BcmRATFKhwATUjAERAcSAkG6q+Y/pktTGtBcKTEDNGBARQAwIaYzjpA5lXf8cyXWirQF6gOoYiAggBoR0svFZP9oSxXPovAPeorTT+68vc2j1XBCxgi2gagWGIxyaqNe+40LabQ87suQ59C2ysB56tKA+z6HRZ+kxAaIANcCpxRftaDua/gFzaN4doXeTsrmKX1KDRAFqxoDMXfy1Ooduxz3pN+jYvbNlnEDyAJG62Kic1KHQjaxCgQmYle05xd83/v3T0NDuNIfuPjIguwj+JAWRVSgwAZFYhSKAGDCIxy5P7+U5dJ7jlzl0o9hx/7ET6AGqYyAP5SOiNqP7IuYfcyd5/yHHBjgnDoWnyCoUmIBQVigCiAErcSGLdDTOoeP8c1N+/rB2h/Gzu/3x81M5ejsUiCMcirKKrEKBCQhlhSKAGBDivFDEvf8CX9uVMqypCat4gkNAp+/1IAZUtcBwhEOhG1mFAhMQygpFADFgJS6kkzoUupFVKDABoaxQBBADVuJCOqlDoRtZhQITEMoKRQAxYCUupJM6FLqRVSgwAaGsUAQQA1biQjopobZDAPiAat0iotKv2EpqjtGKAQFswypnHW1regA/qFBn3jVBzh0Dd/QH/HW6MfurnRqtGBBAjdYiotKv2EpqjtGKAcnwe+nvfm1RGUz466bSkZWkiCoM+tLn+bWu0YyNPbAsffOST6e/ftfvpmMP3Te9cNct88sRGcxoYkYvM7bYbf/0vF87Nr3pz05PH7/o+rTsgfhT5aBodbfmaU1JRh5ND/zglrR8+c3p5m9cmi5aujRduvScdOaSD6a//MsPpA+c9MZ0zLHHpj94/SvSy5+7d9r/hYvT7k/drEyWu7ZJQqrY+Xgau/876crz3pdOeeMh6dB9n2k/TuCBdlvy98LD06v/+M/TkvOuTN+9v/t8LkmzphxBFLaSwhlbmZb905+lo/eW8pUBDA8J0p4xqA0N7Zp+/dwb07Jly9Ny+l+2bJn+35zxm9Oy5cuijGjWW77qv6uxpU6R0OMP/TjdSr5vv/X69LWLlqZ/+so/pC9+6sNpyZIl6WMfPCkdT2X9u286Kh3x0n3Tc5/73PTSvbaRlzF5W87aJ7I/ntbcc036xzNOSG8+fM+0eGvL3/CO+6YXHPGOtOTL30l3jZU0mJlgfW6hR7CydBJzMfZTatP/Qm36z6hN/9rztE1b+Uqb3ufQ1+U2feZSatM/pfqepfgxUbVTo8fHLkon4vzT8APUUKq/CoTPyeQfulYinuPigw0WIPgdcD4+F0p/QbWSmmO0YkAAO8odLFHpV2RJnuhU7Qn2Pu3qBQigKTeYqPQrthLhrL/plLRf7mu3oy+MZX2/6gIBbKIaQ1T6FUVCXznQCw1sfSg7BZRFAeP+RQb1T/iqgUP0u9UETC6+qhen96er37FzHleHtvq9dO7PcJBR0UNcQG9e4dOL751YEMWAAHr1CheVfsVWIpz2pTdPNG18yDsE0LZ0E/1NN775tRQKRpNK/rqhul/s+YfTia8b0ETMh/kVrJXUHKMVAwJYO1WajpS66s1pV76PKL3DQy9Mb7nu5yplpHVRc4xWDAhBPjbgANphI+afy8D9L3xVWrKi+xkQrixRNcdoxYAAmnGDiYpTHK1fZkjZWH1uXe2yZbaKAQFsohpDVPoVW0nNAf1IWn76861ce9tfPDNVrOHD0gWsldQcoxUDAghnFQxtILc/O+sYqq2LmmO0YkAA4awDikq/YiupOUYrBgSwIy5YotKv2EpqjtGKAQFEsA4oKnLtmv+2LmqO0YoBAeyIC5ao9Cu2kppjtGJAABGsA4qKU6wWBNzc2DjdLDNasPVp9WWvT7v03n/0NeaR56U7i5kA81GH85Jx2ub4yEXcb/5yOvbye4uqaSgGBFCdjqXv07Ei4b5DP1zuv3pBQOOiGRFMQzEggBq/RUSlS5F3Q3hz2qWMTUPD+9MOjTw21bpGKwYEsA2bOeFIm5L/pmwWvroam2qnRisGBLAnPrNFpV+xldQco4HlIwMGtD9ZECDPRmIDyzahraTmGK0YEMDWrXJEpV+xldQcowV7MN30ob3TSJ3/kRel37sK94yGn5Py1yZqSbOAFSYq/YqtpOYYrRgh9rwiz1lVWCXFRi2VD6SV1ByjFQMCCGcdUFT6FVtJzTFaMSCAHXHBEpV+xVZSc4xWDAggBauffzd0fMTzkOfQz8/9P82hP9P9jbzLQjGtOUYrBgQwW/LxAUel54RFAbeW43NoDv2BF6TtMX8riwHYPLjIfmqO0YoBASwpj6CaQ/+8e0Vy66LmGK0YEMAYOFCi0q/YSmqO0YoBAQwRjeA59NbV+B/HP148HH8vaGvEgigGBNBCNpio1IrVD7Pcl1f9uc2hzVYxIIBNVGOISr9iK6k56/NzSp5D5/ZLzynXljl0rWphFROVfkWW5GMDcHQl6quGNIc+7fbyGwPcAWq0FhGVfsVWUnOMVmyF7RCA9hT7P1tULzZq2SSwldQcoxUDAth4NYaoQPFRWiS6b/t83LQ/nkP/qDiBrbszwAK0cA0mKv2KrSRyUL4Cy/wZKoBNVGOISr9iK6k5RisGBNDCNZio9Cu2kppjtGJAAJuoxhCVfsVWUnOMVgwIoIVrMFHpV2wlNcdoxYAANlGNISr9iq2k5hitWEHcZ4MICBWGDndorSl0hwIUHYSWuFaqQ4NlkBNU9LG08vMHp821c6UXys3AIw/Um7/l0vSg88wo3Ew/vjlUX5kFCtD0PKbSjCjlVJj30/SNd+1aOrnt6cHvdku4M3Eo2YACdC4dqtL1D6QV/+ej6f1vel7a2Q1cMghI+cWOy/GovIdHdk6Ljz01ffT/3J5kKIVnQBfUoSrNiFJF48b0yQM3bzt3reuSBo6vPK5/t3peywFBH0sP3b40nfXW56edy4OtX0GW8+jaj/mlWCO7pOf+3ofT55b/THZwYZcuyQ51Ascduy/d+e2vpn9Z+qn08XcflV75S2WhhYs3ML7m0ZU985r8R7ltjYMyMKipI2Ts8mOaXQpC/vviH3x24lcT6iu7pzOKHvx2Wnrqy21VcY/98PBI2vKl70oXjDbfjjiv7B0RCDo0h3NSoVnHtWlMYjrS0Fv/1Kafc+x7qU3fln4etqyZZPycECQUqYxQpRmhC7/M3Nbqz5e/HRlAejAEJLcOdVTkxujOJqt16YLH0OEOhU+whAYFCK0IVZoRpZwSeAwd7lAogyU0KEBoRajSjCjllMBj6HCHQhksoUEBQitClWZEKacEHkOHOxTKYAkNSmBX38160BJEKbh0GiyDnKBDoQyW0KAAoWUQk9lhPkuOzmM3p6ZjPPYDXwQdCm2whAYFyFx+oREXBbz677+WrqYXGduhX+AXGdf5nQFgz9DhDpV4JhW6QwGKGdqEeXj4cHphzefHwcYrgsfQ4Q6FNlhCgwKEVoQqzYhSTgk8hg53KJTBEhoUILQMWv1bfxfHP/q6AV/B5djwRdCh8AjWZOOzntpkBJSrG7SLBpYFATDxvnICIADMzOai0owo5fTAY+hwRe9LV7/zF+35Z68l6Zr8XkwVnK8WhZa4VsopEi9vzTzgOSw/f2yT9vjYTe48bPgCdC4dqtKMKNWhwTLICToUymClOzoWBIT6q19mwLV6gEsICoScoEOhDJbQoAChFaFKM3JvuuIE+nrYPQ/68d/68OfTC6ty9Jk6sCRNP75zpskEj6HDC4r71dKJBQFOV321CLTEtVJOETyGDncolMESGhQgtCJUaUaUckrgMXS4Q6EMltCgAKEVoUozopRTAo+hwx0KZWbJ1yaxP4W8C8LNE6r819IzNBbVHnRWKt9Rd2VfS7TJP33Zzl+MWbuOZTq04Ih0+p00ZmsBBpRiQQDI4dekH57zsrSQ+6I9aVcgv944q3ldJBc8hvzPY1O1i0g1/9sin43q7eCrhdBq8q+q0GDocIdCFSyhmaKx6R2/YPP3vU5L1+hOSKaVsWwcPUQNlkFOEChvx3vAFq6eut7/bJP2DGOTeOYr3AiilCmoBssgJ+hQKIMlNChAaEWo0owolbeC5t2Tetsfjo40E03SbMS3VCIAQ4c7FLpgzUr8sf+XvvT2/dIv5Hn7dulZv3ZSOv2b95YUUCQEA3Spm5X4yFQIhGAbJj6Prb7+Q6ZdUpBUsJ4o+W/zgRxumPKv49vzl4wFWY4kEeFQR0Wu+LSrSjOilCmoV5ZBTrCgWDjER5jlr63V0ukqr0WgJf6UcorgMeR/nkPT8QE4wnYzOoKP59C0u54ed5qP2runJBH2zqVDVZoRpTo0WAY5wYzSWFgWbg8PHZ5OG3VnsHtd561G4VHUlXJq4DF0uEOhDJbQoAChFaFKM6KUUwKPocMLavWP55N6/KsXPzvXzuPs5/9Rek7pWbioc7F6lz3kz6cRPIYOdyi0wRIaFCC0IhQpPaf86S/ac8ov++cU2DN0uEPhESyhQRVYjjeq+5Dcx+t8b+uO5xTvx+EOnVR8KFUQbpr6H5U5tB9/YtrLHFodWOlICAgAq8CFVGlGlHLK4DF0uEOhLKz70hUn8g5cuB/64H60OPVB9djkH05VY7LxYdiRQIgcZK369wcnJtT7cbhDoQ+W0KAAoRWhSjOilFMCj6HDHQplsIQGBQitCFWaEaWcEngMHe5QKIMlNChAaEWo0owo5ZTAY+hwh0IZLKFBAUIrQpVmRCmnBB5DhzsUymAJDQoQWhGqNCNKqdKQxGwFqlGQbg1wAaPVeP5RjXn0Y6EXEaF0RpTyWgE3jZ+UL+1oIKw7AdqGgzu03KkNb5V2/dB3ygvL2Yzvk4VUAXoZ5XEG+R9/cFm65stL09LLbspfU/dEKAF7pF3xx3+aVvzLkvS2lz+dVmRLGUoHRTj9ILr7kX+UTvrg36RPL704LaUv9Pn/0qWfTmd/8MT0R6/ZI+2kP7Si/BelbQ/847Tk//6g2t58OvmnreMOimfvNHWsdY74PAB0PwSNr7kjXX36Yel5W5NOGYSHdzwgHfIH701//rf/O33pyxelpV+i/F382fS/PnJC+oMDnlZWqcN3gSN7ppedfl26tylmMACr+l9xWjpI2yMGKue7Ln/OW06n09H8wh4QOqDZVto/viyfqP2NXSFbOGv9TzZ+3iGA84p8r09jKz6Vjt/nKXb/bbtveulxp6Yln/9yuuTic9OZb/iFstUj0k1pfc5b0qduf9j5ieXnKUTyPI0/fj8tblmSTqA2vaAub/6R/4i3phM/9MnSpi9KX6I6v4R2nvjkh05Kf/Sbe5QFMSVdufyfQm36bdSm79Q2PTC+lkOVuq77j1XImfpbszSdlBcE+PiCb3HCv8oWbWISnWcKXgCjykT1by667b23bg1wAb0F5XEy+c+m3fbeW7cGuIDe4skdH/0d958yHrq1f1RcWmIZUSoWoKO6NcAFdAaE1vUvX4hz2+aJ4c9EOZt223tv3RrgAnoLxH8w3UEvNBbrordyn/HK8O1fmc87dKURHTiqJ0LR6JGG9o8fnTk+v8wo+x1m0257F97qyzOV221fl7+akrpaZEQpVamRbg1wAaNVHd/qn8csKodm/KNJ59ndOwT0RCgBe6Sh/F3aSF0tMsIvM15EaeIxtKSNcXz9knHbIcA8wQugSRir869SUleLjCilKjWiGo98JZ28C++KxO1oy7TTB75J24aqNJhNP/5Y+SGLY3A5dP3T+H3Ax9J3wmKEEH5u8h9ClHyPynMWnn/Q3yHdw/R8uLdvV2SmJZYRpYJ3T3RrgAvoLSZT/yvTpX/49PKCoJR1V/tb+Nvp4yvlgJUqQiGnG5/Ms2m3vY8FDZSpvzdcaXqTDVf/VptPuvhWH3SPlud/FML07394MIj6Nw5j4AJW0kn3v9323lu3RuGOlWO3OP80N8EIMrX8P5Ru+kt8pYx+D5D7v64fmZEqQJ9iKp11/57OeAn/eL112uOM79riKVJXi4woFR1kCs8NdR9sabOFw9F8avmPtjXVnUJwC3z04nQKjU3S/y5KO+qW1rP5/gWLLCz/eg+U9s/xh196Rvr2OksfsJwvIpTOiFJ1tpXu1gAXUNUlzBTavx6n1NX/5/HXFrVZFMQFNAljG7z+Y/j5+FOofy663I5d/fvi7KnhotIjnWJ8H6/GeyI8oeP7Zxyum/YPpQIYNebi/pM5FI8Fu9OOM+UIM+vNQgJmL/6DaYVfWJ/7o9L/5p0BsBgghJ+D+9+PhbRD2Wj5unrO8+/Gi5BF1DtgEM5B/vkjrmPbnW1zfeD5jxfVyxPQ7NX/ZPLPdfMie/+b+zF5ZrH5GM+h6b0PFZeWWEaUigXoqG4NcAGdAaG9+X/4n9M7d6FjjfL7h0Vp57/oO3rD/PVEKApd0jXpzk+/NC8GtfxzeeC5hSA/r7zkDNrFusveYjPWrQEuYGWjfifx/DX6wfxbRf/7j031+YPm0Mc9rYydVJ50L8TyLvTmv53OxByaiktLLCNKxQJ0VLcGuIDOgNC+9ifPq1L/Mq5023tv3RrgAnqL/vgb/f6j5GqKM6JUzICjujXABXQGhPaV/3z++8s/P+WE4lRCkVjKHRQ00f8AqioUlBGRIFZCkUr5hvTXvyJfL+UbP79YloHHOlumn5Vedu6dYtvjCo6DWAlFoNYLoYl8A6oBFJQRkSBWQpGo3EFBE3EBVTUrjKe1Ky9LZ73h2fmBQsqulNvOr0jHnvGV9O+raAtYODNE3TAyds+/pa+ccWw6eEd8TcEdG/vZPu3y+rPTFavW0I0YTJzPil9IU6cFAS/3q/8lfZpW95DBHanVvwxWiJvhA1ems35n5/wj9PDQgrTF3sekt//9N9IdD1WfLFAaND79sLz8/DemA7bFoO3j75Ce94FrOhYFmH2Iz3kbxao78af50LSX8scDXYFez/JJur35hx+Js/nbvpr82lnLICfK/uzhEvYCJ4yvCwLE15rRs9Obnr1QHnZG9kgvPfWidOODKOextOorx+atu71fwWmngMPPSd/zO39ZZVhCezE6BmLV5ekTb5Q27e//YbTpe3yb7nLERxxYmw7lTW161zeclb5KbXrQH5Lc1D+MoADaQ9oh4AR83VTVf70VqDfzONxPKz45gn32qYQiPlQnDs35+FI8KActLBSQMiISxEooEpU7KGgiLkNux/jHtsIdppkF+0gEbp9pMPHxg0FxtVYns/ult15XvnglxRBJCUWCqy4Cmv3xH8o7BTwHXzlQ2Qz3bXEIZzFVXWGVB5P++Ky6Nq363MHytSAtCPig+7oB9tmhEoponD4EmoPj91lviPKX2Fb/GLutjUpbpXFcjwxArvrTDQk0p59//6KpTZuMVfQy4wre1aL9m3l85xPOetofb8ksWx0inXj+4rKMzy31/d+Ov3X5C+312IfS9fPHyCvSqcse1ZROv/wnn3+nqei47hDQl/9tqyMD1DQjWuRMKaFIVO6goDn1/HednezKG88D+30kXe+fkao0TD++OIJ9ppRQJERDm7J2MaxFNvX8Tz1+SEwhkNInY/x8z+t9Ke0f5aBlhQJSRkSCWAlFonIHBU3EBVRVKCgjIkGshCJRuYMa1x0CKP80N7m5Nq3pygfE629fkg6hhYPa3+H+K3CIzjP/6hpomxNwkG+BNK+47q1pT+4/FxwpuwuYScBgn5lKAFljRwZoPft+ejhtnncIoK6rmABqELhSRkSCWAlFonIHJZp0lM2Vvy/HBaC8tPykXfpy9bjvU6xfsbFJdXvyb/Ni1/+XsSknd4KsBLESinTkOLKgiXIHVC0oKCMiLPZzcc2vlh+XBT0bnV1vBS1+4B5xATUKFJQRkSBWQpGo3EFBE3EBVRUKyohIECuhSFTuoKCJuICqCgVlRCSIlVAkKndQ0ERcQFWFgjIiAjHuA9R/1OqnYI+4gGoBBWVEJIiVUCQqd1DQRFxAVYWCMiISxEooEpU7KGgiLqCqQkEZEQliJcbd/Fn6omhlFEwQF1A1oKCMiASxEooEZesnbA4NTcQFVEMoKCMiQayEIkW5OoKPx7U8h75XF7ohLqBGqV2pQJAgVkIRp027A3fMoaGJuIBqCAVlRCSIlVAkKndQ0ERcQFWFgjIiEsRKKBKUrf7xnEJjno6LPP7R4medQxfTblfqN4iVUET1+hDRXJNGzyyL6nvHf14QgEUs5i1EUkIRU+zBoIlyB1R1KGSGHGu0W5VG9L2z9vzh/OP9G/r1EIOeU9677BFNqk6mDDFZD4bsId+Aqg4FZUQki0dtlz2fTkvrpvr88d10Vv6IlPto9/xXlz/Nob/ZM4cOxaOEIrGwOihootwBVRUKhWFlKuNKECuhiLrpQ6CJuICqDwVlRCSIlVAkKndQ0ERcQFWFgjIiEsRKKBKVOyhoIi6gqkJBGREJYiUUicodFDQRF1BVoaCMiASxEopE5Q4KmogLqKpQUEZEvLhZ9ihCr4J3ZIXXRIvOW8p8ZYwuxunTjhpCFd4a/hqgDII6ENKNRTg6MoF4gWu+MkYX40wj/sbO/7TiP5JWXXlyOox+xOfOCP/DtGhij7d+Nn3tHvvBU8omllDglfhj91yVPvfHv2xbL5fyH158dDr1yrv0y2Zf2tkPXaJ3Xwdr0v133pKWLbs53X7zNelyPtf+8x9JS044NO2/w4jWr74E0/rnwQrfhZC/By5Npx20tTwojeyVDj39/6YV9CJn4victrXp/svemPYc4cGltLMy0AyP7JN+6ys/GpB+nxfC19KRAZSXZcuW5f+bGd68LGVI+G233pS+9r69tT5kxSLqZ7f0qnO/m5YtZ/3luUyWZ3v2RzTxl9M/fGe6xLl11UMujVbaTf4fuivdRja33PKf6TtXf4W+5P9c+ruPvC39wSt2pEUjHflH2znok7ot5/iqz6e38GIAqovNdn9DWkLb/IW/ddekj+zXvf2w3KcvSid9y44OkNRamtlX4Gn7pzZ91cnpcLRpvf+flfb8I9+mzVfG6GIcn1JaXPBfV6fP/hHatMv/4mPSe678sSyy0PjedhBu0Trj85EBWBCQV6yi/ulFX9khQDwUP7Mdv0p6iFVkgTcfvyqxichSb6SWMboYp7UVWdQIvEmWf+7jtX+UNpX90CV6j2kIsYoo8CYZ37xatDVuQcDxbkGA6SJtZsOymceXowMW6+42VB70MuNPrvVHBUgqQqySsMCbdv7Xprv1ZcZh9HVDWLJVIlV5ndX4xTdlRvKjIQMS8jrL8a3+pT3ieQ3PI0PD29L5hzyOxxSGNE27/AflvywIqPrfOP4/O73ucloQMCfxrQpCXpvy560OeUvm8lzi728d/+w52F4UYUyJsC1/HvOg48Y/PP94Gcemo5r6tmauc8R0zhtdJI+m4bHB+WcnHdaj9DJjYP7p+ZDaVbakS4cHTYLIokbgdcVX6y7EfGWMLspZe3E6eQdX5p3tbyRtRc8B+kQ3m/E7kitp0xRmDc+T9hHbX4cbxzJfGaOLcZxaQUUWNQJvI+e/s/212XAcy0vG6GIcpzbN/Ov96tp/9GrR5iJ+jNVFbYD45dit3J+5HQIkNVOJf2v6/Gto3pj7ua7+bx8607x9od2V65RW0nEgO2dfC448L91JyZhe+dOL9rJ7jfXX8f4bvHB4KvlH2zQbzptQhdd7/92XvlaOC9B08hihY0aLqx50Ovs/tpM+0vRj/nMM1/5Fj8amM/hIG8tLxuhinLbmRBY1Aq83/60v4ZivjNHFOGaTf+gZmP+t5cvPOYqPlEjaYgoDbz4+imqS0MoyY3QxTnQR3//gKB7oF6v58o+FNiFlpZ0xuhinNRaZXPU5u/Q/WXsjl//YZXzMJ/d/tAX2N2xRfZsTcCy3GaOLcaBjUGRRQ6jVtNMeHb+XF9WX/jcfFdDOoc0bY+YrY3QxTtQ07aghFF/XppXnHkSL6jk+Laq/o3sOHb2ar4zRxThRc+L4pLHJ1D/Pv9yYquOf7RAgubPczm3+eeGiHG2k47RPXx7j6TcZOirSUrQxyv++dFX9nDInzx9V/SCGg/qc4o43krKJJRR4c9X+RnkOTfeVpo/xcp/n/m8Tff7AHFrbf9f7j5H01BO+KseHU2HG0o1tMJR1EQXeLJQ/yhj3iU9BiDVH8Td2/ufj+xqP+Mau/2pBgKsqRRXJKfcU7o3M84KYR6IGCp2201NUEYlfvgaK53CUjiwMQPRD4w34oTH6cAEr1OkpqojEdxYbJf9Tjs9fR9IZUPxjiHaaVF4L6Cyoz/8nnZXuHPp6Ur4ibf7Xr0w3fPwwOjO+Kv8R8n3+rbrd+szrn3c3+GJ65772w3Ksf/oCDKsi19yYznttOVOGfvQ56cq7aXFCzIPPccShRy9z/lhe5qDTRic+tPNx6dxVst3zzOt/0JeJvJqyPWcbKeR0zzx+zL3WE+2UsOwTB6ft6eGgyT8/MJSXbuPrvpfOO2J7eXDY7uh0+or/rh3SLgllKyK28+2P79V8v26fXvi3K4qdy52iimQdoXgb8CPTYv3it7Q/btOfq9s0m0UfJVgHIL1xadM4M03zz2enXXBbcms5Z6f83YIAjVUeyvhF31iVdp+TOav/UGQ+YizJ+fjShHIJxWKq2tZAodN1eooqkvU8Naj8tb/KD/N0r1GbmvjPeVdUkSnFj7HEx9gVx5ZzB2m7w86vrV0sRRWZZvye8Y/7nuaFhoulqCLTjM9m7IP6+rNeWPpT2u6w82WGi6WoIjOMn80nuLhYiioy4/hW/9Rfa/8vbZPbJ2+tzD/cxkCzF78/8zIO1/2vpAnpkwWmPjWD7r8Yy1tFSaScnqKKpLT6gnTcM2Ssi88/1fNXGT+kDygy5lGZSx77yh95NdhVJrlc8thN/g6grZl55b1LZswTUwOFTt3pKapI1vOUlj+eMUqaJN/IA+fftSsXrUWdd0UV6Y/PkqhWue4R/uj0dLhbpNRV1sNDO6ZXXPhj9ec9af6nG1+9AnHeFVUkK6FsffvLGlENDgscKHS6Tk9RRbKepzZG/je1+OEeL+3fFeiTo/z5GRrHwtHcZFlTAL7WGqFjrE0/Wfqbed6j7Tz0pSPpKcddkrAkYGD7+/kF6S25r949HXXxPS7GINSlU9Hus3n9/ZcXDqt+l/+BQmfg9BRVJOt5KuT/Z5TfZ7qxRsvN8eZg/Olq/1p3NDYNOtLGZbygLneKKjI4/1Gtcj1QmHV5QYCcyY1xS6CNCfKFnvcUyt8LqugTDE5O2zlRVJGs56n5+FJ0uUx8wbgSdRoNt2ZYXUvdd9n6MPPl70rIF0xdsIMfzpy2c0Io9yO+TljRaczO+x8XPXjXQIpkzTU0h96G0zVMx+7Rj6v8lzWiWubbZaDQ1Hzu1IQRet92Pi0G8M+qeNbmd6y8sF71nTtFBwpVa+L8j9HiODmnfpgWBJy2QhYEZO8DQwwUTiF+SKHmeUPGt/r340QZY3OdyOJnlylCN0T+5f0Gxl6DfvxfLIvqY+Ic5dKpqCJZz1Noc5nnBc6joE6Yn8voyD0uK7Th8qzi73Wkv4uX+4Vg68vf1wvjPv/oT4jn4vMcunlO0SQrMjv5b8qmMEaXpIP1mc3yYPnfRJ8/fnh6Oqz+/Snkg8s/zqH7iiDcJ1rsimQzT02r/ZEXXWhR2pClx3lXVJFZi2/xaszFUlSR+fhUAr40plv/dakb7bwrqsgGKf/mVwIf3uOWaGAiHawDXRSkaWfMSFX0LI9DYfymU9ILwg1fOq/QQTPv8PAVnvgyjxkzEu5jhSu3C6k9dukYr9beIPHzj5uvTM/xD3JcdvSD/asvuDV17H44jfzTw+K5r0o71+U/smd6+cdvSD8vRTDz/NPq0M8fkhZR+m2QwsDFgxX/kPDT9N3TXyy7FuTtrGz16lTjr192anqJlpsf8LdJe33UvjwQv1bPfVh3/LIgoC67TNMDf+ePZohQewS/G9bamRZmMFDWuqvSX+yBHSV8/qn880s3OgrgwldJWY/sRw96K0PbUaej8UHD153gqDux0PhEelz9cZv+n4eFyUl+eKPFANym6YCAzj/xZR4zZqTaCIu+KKY2vZP2MyX/C6RNy7ps0exwob48Umtnmi/l6yY8gGZY2sPmtCDA9u7w3hivPdbySNfaGj+qhTIXm0pBydqjCjqRWns+PhVTRwF7lsfbQhVpn45vT7jnfMBs12HsWR6favxan32NXX5MeelJfVv+2rrW8imMeJ/m4DTKzgA6/o3snX7j77+Wrnr/C3I6crl0jhMSbbBvkQ7WsVTTBsJ0xt7+Zeyilxm8Q0CHsWd53DwBE+lgHegilGlnzEhV9CyPq4IiIh2so8o5q1b/Mm6jXdrEfJuyQ4DYDfY99fgoBfaerTVAGYfR39fjcZ7UY8cp5Gk248OnT2HEmVp9yW+nZ+D5Z+RAWuy4PO82lHcO8rsFlZ2CsHvQctpRSHYlujllXZIzvZx2K8o6zjbrFXrFd5akIxZxXVXjP8opwxelt7sdfiwnEatLK5a/6WqVEMvjpgHMeRyVHQJ8n+fxYdpuud55YlbjI0kDoEtt1mJ63VW/l3bgMqzbm6cXvT6dc1/XXoe1xwHBSVRrZ1qYwdCzPA4lLle9b0s7gGwQFF/mMWNGqqlneVwVFBHpYB1VnrX893s0SRdWpzbTHYn3LI+3PkWq7dy1mVZ39urffEv8wWns1852Hcae5XHzBEyk+eqfoQ/sWhAwhfyv/sd04i70wri0bYGu/1t0dDrzLl4Q7uIjSQrHaGtjmasO7XpyupRWEdfamRamWjHiWYLzl3dlK95Sx/X9N3iHAHEvvsx7xozUNHiWx1VBEZHKdX0em56OMhs5KI9NMx1/bi7j0PLlvENe2RWPxy36H/3OaWVsKu8AXPu3urPd53xqOQuZFqbmSPmF0yF2urVHJ+pAa+1MuwB+K+hmPMjjb5wno6U4Fx1RjTVRfGh6fx6H3GDt0SRdWK2d6Y4AnuXx1qdIB+uYVa2d6Q5jz/K4eQIm0sE60G1rK9tVxtpuS1uuxOYsYyIdrGMmtXamO4w9y+PmCZhIB+tAd3L5Z23vz+PmCdjcx9f6KM+/iCxw7uN35Z+PXZOFQ8/OHwx16cR0dqc223UYe5bg/PHNUfpBGb87/o3zeA69n+0Oy3Po6+xd6+zG997k+BwZ/2SXPZ9er1njomfaGTNS1T3L46qgiEgH66jyDMZ/88GY1X8Z9zDm6vhH4wQW1TvTOrWZ7ki8Z3ncuSqoSE2nmkMjXQTteaXsskcesp0Zq3vP8rgqKCLSwTqqXMp/XXrwYplD8709vFl5TumZ/w56/uBdjPn5Js+jCfIOvXje8XCU5tBH5jm01JeVhSuX4fo5RdI9OG/Tyb95zJiRerxx7vO0LaGN8fPvpvn8sfbqnjm0b380h/7UfXyEsWW4yX9pKqbhta0dGSaaXt9kLea1Ma6gLXht78/jXkdw77GV1pxaO9MdATzL47U/lM5gHbMSPdPOmJGq6FkeVwVFRDpYR5Vnrf/t92iSLqxObaY7Eu9ZHm99inSwjlnV2pnuMNYFAR2y4q1ste5uJkP7rPr47BIyQAkTqRI6gxifvzLjLZP0XJbceZUJe+4EMHnnBQHyJbf3NtP4JUnFZV+q+/hsBhmguIpUcZ9BzH9hFYU+K+bzjyHuQQ4vdemYgOd/9D/oS+doG6nivgQTmdNQtCDjd6er37F7GgnlT4MJbbH/682PtDAGlFiR6o4/vpx+pC/1Hetfzohdc+OfpQMWUv2PPL//B2rNd4wYKYo/fl368PNpK3yfJ8Y5/p5L0td5fFFfPr2D+F7GEcfoRyJe8Yr2K1AGCtshQNLmUqioIlUC+vh1fDNrLe6jLS/LTguavpL/Az+ZRlf/Uzp59wW0UnmrtOMJl6V7ggNH/Ozc9Kankp3zYV+3cH4X0xc09/aWJJexeOOr/MC3+2b1/b9j2vd0btP4c/HBUggZoAgiRbzxu9o2zfXPuxCcf1v5ob6xKlH6+CyGrMC8Q0BX/Q8ledHn81+7h6/CV9DHZwXIAMUoUuoo64vMaSiqSDYI94rvlz1OZRjr37cN3/6Zj3+UD9Gd97+To535mB5/EsePNR3rLlLTq3+z6va2nhbz7ZfLn3cFud3UCeu2YJXptv9q/NOxiCPdna7LLzRKu9nulfKVA4dr/qYbv3b0APUnZdeZp745nfuzPICo0uznX11XCCIBijhS3mS28m/n5Pbf/11nvc9e/JhTn2N8eTKo/5EXcNmHmiriC4zwPj6rQQYoppESHiQi+3G69A9pPC592cghn0zfW99n1cdnj5ABIorAeL0jffG1vIW261+b/ndR2ukDN6THgmH0HURTis+Wk6h/7BCQx4uSVt/n09EGzz3rlpIMpA1Q2JEqqhlMIr5XLzYNSxmI9HC65aPPL2McyrdtfwuO/Hz6QTaBHTlSVBH1Lkgfn6WQAU5kEfOP9hefv5F+N5aH8nf8J/H4i+eZ/v6vrf/wTMXtu7n/YtnyvWp1LHUbr6h3wKnVf9ZWU0ViCG1jFTsYR9tIebvY/oILxBm7yI7dOoiPM+v3ZmUTdYy6P/3bu5/tnj2r8h1+RnrROR07mvkkr/+PdPavLiIfT0k7vvsaNy9hJUQCFMNIeWeP6pEBuS101P8W5Wgxs+r3NvX4kyh/ep7KY1Ppfzc75Kz0vd4kQAA4Uf774n8/j01yL/X1P0+hsen6nrFppvE53dHHTMpfjlMadP+7XW40rCIWOmN9fBZCBiimkRIeJCJzGooq4g0I7+OzGmSAYhop4UEiMqehqCLegPA+PqtBBiimkRIeJCJzGooq4g0I7+OzGmSAYsoUnrPwQwHGC/D77v8gx7Pa/Pir5YkxE+U53fFXaspVodalSgoS6zZKIQMUaaS8Rez/ZA7N77+e1syhzarf26D2Z/bAeA59hO0Am3fJpI9u2D19mMNz6O3RzsLC+tmKz+nw+b8/Xf1OnkNT/rf6/WYOjVRbHo1jGNIGKJJImXaMX/iqrIg3ILyPz2qQAYpppIQHicjkOvHvHzyHbvdIMo+IBIgophExX/5FoqaKkAALAspYjHbhnln5Xe+xl+v+SiGM9xQEof4HxfdWfd7uoueUZ+j7x83yHFrs+ixmXv88h97G+qLO+Q89J37gm9VzCvIz2fKHPsP+3Jgs6oyP0qL6MnZ0jz+b4vPHw+nWj+0bylbHQtf+Fhx1XrpTswsEkMvLSkUof5398p/u+DM//k9u/uvLqcE77z/MH+yYJmsBs1//4nvjtb9B8WlBQEyYkRXfSkixqIGCK+IgJKLQ2GZBnUAAhtopAkmGYSV1noDyhN3/o3L9DgGzF98nJqZww+R/cvHXp4eu/9P0koVSLtrBDy9IW7zyb9J3wmfHMRdWHRXfBy540HjokvTuvKU/yr/UychL0luvu3926n90STow1DXqnV74fnxp+tvDeODdOu36jq+me8NHVZTSktjJt7+f6A84sX1xzEPSqcvrgwimU//y1Wjrn2IMux8gOsqeWaH8iQp0TUw5/w+kb7xrt+reKuV90MfTtfQFzJZcF9v/bvr0Svlipg4pyV5FZ0vuJotF8hlF3D5KG6FBe3jfP09XPOQqS50oUnJPbfqbf5p+pbRpK7ORtOVhn6Q27U+LrAuHfBV3k69/Mnjo0vSe59kxFRqT2vTx1z0AlyV90yz/sS/Zy0zftqlsJvryJ5bQNONXuTAyei+ZDMBraNmgbl1erP9B3Vv9m11pW7DLD3QVD7KBsPh2OvPxpRy58qbU/kNtt4Svf77BAl0TTK/6RHrNAq4f/6I2KOp96pA2cOFESx+fXmS4LQ6HaWcAHGGj+acFP9d94AXuK4dD09uvvceVT/TelYio4eOTdhASMU4Tw6O3lb5vt1PTV/UX1KDo7Cp+RwKixkTxxYHmX/1FL5buiq/6hkSNieOPXfG6tHXuH/ruf5p0fqL+4dbi1dhU47N9d/7xMsP1N03/gwV6lorZi28+e8tft6DmNNKPUrSgxo2anDMzZXchcUQUujv/ffEfS/dd+Mq8K1NvP8397F6npWvWzUV8l64OVLM4yi8zUHdd/T+3KzmKYmr57wjqWBo/86aaf7woQrormNvfTuG4ABe6RPScqcaHbcwF2ok2GKgVOLAd5DroKv+St47nv15/zf1XlY/Wd82fj5+rKlQrEYXedNo/GlZIqKbTIVBsoFrmRbWlHeQFAaSqQjYjotCTyf+679IuhAvqdmU0tngNISgA6GzPx5mNvCKduoyXKU8tPqdYE0wv2r9ftknuu1fiwmGx1sTA1xTyLx6Qm+KvA6hGHptQPs/MY1Ms55nkvyNwZj2W7u0cm6r7n8amr9PYhPKI6WJHmgsJpKQiwu+4Rg2r/6wahEQUui/+2BV8NjjKkGDT/7VffoYQFCDQNTFBfM2e2imiohqJGvPxQ3nURKH76p/LNtzfTf27tuHbSYNX7Z/k8/PfUnYzfP7YJNr/yjPTEfkd2KLqR8TZvv9W02IAd0wAHwNbfdw1Th+CXUe77W2HNpgXBZSPe6bR/nP5qp0irtjvSF/IP65Sfe723nSFzqFZZbbz3xXfJSVH9PSGiT/x7x9lUX1IPhGFHtT/5NyonSI+kwGPGrxw0X/cZv2V9T+70zEXPws+NGHgqlNFIGlg1JhE+a++MB33dN79ifvIp6cXfeb2utW45ETvTXBiRI2++I+ln1z4azKHHtT/5Dm0dxq9Tz8+W5Kv4q63/stR3DoGNePPpvj80TWHrse/ndKhF/5o4vyjgLXYFYGkgVGjr/7ZjDSLMpe///1Dyxt9KGBT/nY/9dpk2zr/8+O/9T9cNvin8uwpY6noWLtN5UutOvbk698ZNV7QTrTBROVAxRTOTnzdIaBOgLk3LKSGiZgiFdds0AL9VU0aZxbVMNaWFXJyc2hFlx+hjCb5VvwVnrwync34PsUbI/+Tib/+J19IJ+0ev26XstmffpyXARllYv4ix0rdMNMtWDBZnx68/PVpF3RoCukG3PMdaelPHivFJUbBNLuLHItqWL29utX3U9POv7Jf2pVj7nxc+uyquDMEPPvI4FmeImecNp+/I2zVWDra3InsRl+13zcL7b/jhwgtN14QwHXl8m+JFSwmWaU1G7RAf1UTQqAF1wPy/7I3peNesgVNNJ+adnv/v1VfwNSeiF7zrfS5o3dOm1HerM5occrz/jh9esXDJRF1fNCS//Gf/IO0adeJo00ff51s4o/cwLKmhe+v0GAYrUrUtPry16VfzDF9/VM+uE3fF2Yk6ix6Ms8+sur4l5la99K/yZc/G6v+kcLJxeeHFKtbSb88uEi5QQaoD0VVnuPDji9zj4v/2pfR8/GtHK38O9tfT6u1WjdMVYGgiYAusGaDHl97cTplB6mbkaP/Ia0KdtASpkU1LKgzEU2K+MG0onqRkY/HUXUxytfOFxqy9aFFNawEMNAZv01WVitHsHAbHT7s71LcH4FdRmcW1TALXLBoouKaDVqgv6oJIdASnkU1zGtnPJqouGaD5q/g7Jzccj+H+98mnRbVMA0ABI5BF1izQQv0Vxj2Lczzfc7ueYtOWGQIx4FZl6TRPnJrGjmWa8ZoS+aLfycfF5AnMQuPSKff2X3kBCclejJ6WvF/fn46Lp8N7cui7n9fnE5yxwbManzKTe1PixuCskNAf/+/TdqHttGcVv4nE18TJAiSBTboEP/nF5Yzxv1YVeG7/ElaunrdxPlHoAIRD2zQIT6ECqElDCt1w1jiJ9FW3jbG2LiDvERZbdPqw46hb3MeF53al9GtD8gA1Xfof7zd4zd+rMkZ3v9z1f613QGJqbZWZxg0FcKk7BCQ65aOM7tZFQSBmkB/9YrQIt76b6ezDt5yQPvbnxYE02F4zsQ83Z+ue/cvke1Q2ozG+RWkAzWB/mpWpiU8y3X1or2Z//DC4X8tO5bB1vs1zz4y0mSakWPxDTPdgmUTG5ty+dPY9Fc8Nrk/eBbor05JS0l4FtUwr53xn11Q+tDYx8Q+5UXpxDI2+chIk/mMHItqmOkWLJqouGaDFuivapKP0woLAnK/5Pu8jt2T4NjcZKxmg/aRwTPTyLFcG2a6BYsmKq7ZoAX6q5oQAi3hWVTDvHbGo4mKazZogf6qJoRAS3gW1TCvnfFoouKaDVqgv6oJIeO5z4ht19e/x2Wcqscyo/04Fu8N0yn+noDjX1cZIt+A0xn/fW1lHBVbCWo2aF/z4Jlp5FirMyzrPnZxOnkHqbuFr/1iNYcWb9GTtezJx3+I5tBH0DEBpY3wrpgX3NYex8kO8xx6/7woIJctLQo4iRfWW8YUn3x8TjM8GEZnbKXT9pRjTHkOPQoVF4vRmg1aoL96Q2gJz6Ia5rUzHk1UXLNBC/RXNSEEWsKzqIaxZOLfP3A8mvjhKzz7yOC1WsKxqIaZbsGCk76Fi77/WZxed4XsEBBMs7vIsaiGDY5v0ugJ+V+ffk7HBTwT/d3CI2UOrWbRyqIapqpAogm4Wt5gjNOCyeOf4cvBzS2QnqEXVnNoOJ+F+CUh4tFfkUKCo6e5RfUYP8r9n585N8Hnj8k8/9Ec+kur/e+APfmvas1K3TBXWoKiiipBzQaNyDI+lbLV+keZe+jL3+OiU49lRrc+IAOczviX090x/4Av8/34js/VabVuWFXN6FgmZNf1L/5rM2gJ36IaVltUTVbF0ZMlE+2PFWsdcPKCAKwaCqGdRePIybIjc6CJEoQUg24lLqSZO+UGFYZureYaZnwA5MZIN89T35IufJg6AuenOzqpFJ3HQ/5zUkOeiLAMUBZX0Zftzy7b95cbM69MoxcUh5xN28y2pWDmznGDCiNfnSwXMBysuz6dQT8Uo4PQehnePG1/3MXVtvKWDphPWP704+kJ25T67az/p6Zf+vC33dY7lNCQVovpsb74fF4TJumxs6PB8Wz54izkv4k1UXy/IMAGCNlSpjpvqWQkhwhxOEZhBD7nkGU+p924mTvl8fiAF/NPaeXyzz9M0HYT5qAK4OKP/zz96PovpHM+siQtWXJ6OvOi76S7xiSemfv45mqc2rTuMpAH0BKf8Lw9JX8Bwn/OXBkNTyT+OjD++n9PH8uLH8q9pPEXljZNAcyBd0s4yypWTXKb3rq06fJwgC2Ftjzhq/lFn7hw1+CTiJnE51QWfxPef5KjKk8SX+91lE/JizxEWNuOelWZVvn3bc7juX/pvP/hr4pX+r/+2N3l72N6/PEav256oGej/rOv0C6Zw20DURjems77zafKiy9a4Y+v5GcvfjlSBC8y3M4APhUBp0672OcAABl8SURBVBca176Pv3IobYZeaPzJtbQowKVbUHd1MsljYQQ+RyEGePRlx5H5y46F6envvi75JWuINZP7L+cJsTSDLr7yWmRDxffjaXsvcvl3bUuHIpTM5WvIJ+exMAKf88myNr81Z3ycj+4p5zRTH4T+19/zw0PuzM7gk2MURuBPJb6kqL/+70xffsPT5L6h9G32yv/lFpTMdfwfp0voqAJfFm3/tyVtzUxbHs5Z/ktZEsghQhwiVtQvM+r+v+NlhhR5vlr1OccNKox8dTJpY4UR+CXNDY/5/COanWUp94KlWdrfVumXymJLceGuwScRloGcH7uwzKg+zMydcoMKQ9M6P/7q/djdl+FZhOAGfv6weqY6c/Vo/IhNpf6zu+CTYxRG4HMMlsVYXZSZO+UGFUa+OlkOsMbtskULAmzDXFIMul3RSaXoWP87llae+6vpKe4ZNvZ/m6ennXxV+u/sjmOog5RW/2M68RdHqG3sSLt72JdJ3ZGFa+YusYquyV/exfjUV7j7b4u3XSELAtQG0YjR8CAzODg+XIijfA0+v58uer0bm3ixo8oJUdzi1dj048sWwIPvPzrS5i/6tuOVlEw/PttzHksmm7yyrM5tS7P5GC0833rg/IefjW4Rd8EnxyiMwEfa2ng1x8ydgwYVRr462WzlX1LrHDeoMPLVyZ5I8dGOu58/3XjCcxV3/8POoD1LZN4GHn/a939Vely/2pXmTTX/5Y6q7mlqjHYDVbcWyypWB2nmTrlBhTGebkvn/QYd48X1n+fQxDcHlXeWVawO0sxZ+cF0By+opx1u8phDc+hX02IA7Iea3QWfRKyn3fbCTgGvlN32OHjQ7QhOrBi/6Dg7QelKc+jX5Dn05unp78EcmvjmoArAsorVQZq5U25QYeSrk+UA5qDyTopBtxIX0sydcoMKY+LfP3hRvdtlz/npju6Lzyk3qDDy1cks//Qu+0zeIYD7qep+1/6n3WWP0zSV/PfHZ0d1DomhvB+ki97wdH1m58WaeE6Z+/j8nILjd30/7nE+NsAdb6TpRhaEka9OlqWWgaoASDHoVuJCZnNaVI/dl7v7303t+aNrDo3yRPvbKu32vvaDxboUrPhcYTWoMPLVyaZT/jbmIb0Mkea+90+V7vz4r/dyW55Wllmm/Y8vwxo3m9w+XB27mpfbycmmU/8bu/0Niu92CKjUQqZZ5hll6uxZam7TajNxihl1tNpVSKMiDL9lTn5g4RsD/zQYYeI8PERHBqzASnXnLKOOrsIq2ah4xsbLv6SvL/54WnPDSen5I1YOdrPQNrO8Rc6c5v+RfN7hAlcPGn/kpemkG/BVhS9LLfGINCrEqL6mbuqffqD+6J14dCV36kORwnN0jGoUh6NJOhYEaD7yA8+C9DT6Uad9Ac7mU2n/bkEAtWG0XRkcsEMAkuTT3Ff/U40P3x2QFgT4H0li/qUzXXjEeenOxnQq+W+MjaHZpb0abnh72o/adJ2GYd46OW/7ZGZTK39vV+Ea/5G04hMvTgtzvcc0DG9Gbfpb1KbD3xTzjyMDmvqvv/zRBFG0DVH/IVM5pnG643P9oA0Dhjrjftrp1DKzweAMGMsddlkffX/l23w520oHfjIkmdkgLqDz4drB4y1+rr/cjHxbsloNWKPiGd31L/aD2v/q9B/v272U88vSKTdhd5AQGW4q5kTxZTHAc0o/McxbHJ5P5x1mL842o45mOX/lQMcHbI+63Y5eaHw9fuXA95z9TTX/6+QHwNz+yhZm5qwb8+GyhmdMNb6zzaiju6PH7M5SfHzdYPeZu6/y/Wc7BITinqX45qbOv4zDli7c94CczmenYy7/aSmtDVz+9306HbMIZcXbyP9IiqfORsmgsluk1KsKSn46gKr0T7xD/7cXHYOxho0G3f9ZjEtHUMfS+OB5RlX+vN1h1bdbXXK5ycuM7Cm78b7gv4KNimdU8YPpZPL/4/YFUT3+bPdGOorJ70A0m/G9r5B4IxoVYfgxM9T/wPIvbbfS8b54Dmd1hvsOEG0/wvn4VB5cpvgvz1ZadS0yjfsfTUKdEWOm7d/7gv8KNiqeUcVfuzSduK20jeGDzrIdAtREkcnn/77Ppjdtz9vLxjan9DPemi4sOxBayh9L9y/9DflaMsinEV9N3ByxSgva/xYnysJhScdk+h91bkmvsUbFM1z5/4TGpqeUNjgkzzaq2SKTL3+1RcI8A/FpbLqEFlZV7Z/ryPoSStuetPgUxyRmN94X/FewUfEMxK9sMjm98udno3b3JN//bZ32pl1u5G/24zc58dkt+TKd+fi5eJoy4hKaXv2zpbVZ1Dtgdx+E+7/u/5v2j36D75P63nCy+fgoZ5Q7oPC5juRvY7Z/mkO/f3GpR5pD/796Dj399seLAeSYgJLvkX3cMQG+sXflX44PwBx6mI8P+Lrstlc6fRQdQe+rFGkNGpUyh87tdcd0yIU/7nEzk/y7RDTxPaMr/7Cd2/gT//7hxglNsiKlzByNZNewUfGMrvzHObT1JbinCA7TgoDLeA7tfdWBC92oeEZXfPjpKf/7zpHnlNz/8WJNaj+D/ny4rOcZU43v3/9Uzya+/90Tc2gK6MPNOL5zllFHowxoDn0w0qI/Tvv+z7UrjHEdbjjhym6RWWx/d6V/+QNaZIFnv2psy+1vOzvOGNmUxGnClN0gjYpnTLX+nS2h3feGbxcod0B3D2kdFf1B+Xe6ed5SlVHmQYdkli7EBXxyxc9twVWZtA3PmFn9d9zcTfOzmwiiDRPfLQiQgDFsSYxnZpZjZFRovjpJoMAHLJ4dEImXK65ISv4rM2vAvjGj8R6ePjiKWaCly7lysRkViZcrrghMHCOjQvPVSQIFPiA8GRSJlyuuCLQdI6NCj4/fkj7/Glo9Wm5ylE+GI6+iBRLux3K4Ulh8KO3y4sKJ2DEyarbrbjol7dcVn3gLjjwv/cCZulCEmg/wVRUIvfg5Ke8QIHWM/GGSM9L4hyG8G0QMg238NXmS7jpF12nyS5i83CSbma1FZM9GAQOUuPaje86L77Dp4emYK8oPENEo+JUQosDXqGoUMECJ768iMTl9mXLWC2mQ6M7/0NCz0ss/94MS0GzNnn0bBQzQRxZcJF6e8XH3VbEr/1zn3KZv53vcbL09+OwffECJ6a/mA1zojn/3ZGnTdXxu07wooiwxZH3YiA+jgAEiRvLbnYb6H0qbhzamFjFKdihe+Rr9GwUM0HsTXCRerrgisHKMjArNVycJFPiA8GRQJF6uuCLQdoyMCs1XJwkU+IDwZFAkXq64ItB2jIwKzVcnCRT4gPBkUCRerrgi0HaMjArNV0jQJ3rI1pDDk0HzAZ7qKtJIikOzjapGQeO/aZHVs/L4QGfNhsU80EAMl1ZzU4SOkdHV+auGxVg0VM479KMdLAAtClzela6lRQH8Ujb3xdvT1ofX/ZcIGyPHyKjQfHUSRz2QrnvXbjIul3G4RHXAfICpvhRpJFX504LA+29MV573vnTKaw9Iv7Ir79ZT8jOyU9r1sDelt/zPy9PND66DIwc5yKNp5VWnpmN+eau0Je0m9G3sJjTp+H35Fz6/zMBXcHnRW+7vZHyR8S9ud6hhFUFyHSOjQvPVSQIFPiA8CeTdcPaXySXKi9OW+3uMf/QyA+Oxj5Idile+Rv9GAQOM8ZkSiZcLvi7ddwHOIKS6XPT69Ol73Q/FWclsvT18mnfPqVNgPiBRXz87X7ZmzuWB5+v4zD08tE9609U/nYP8a9EgWZHBiRw9zb3MaNM3PETtquzopHly3gQdkP/GyDEyarZOEtIJPsPxu2m3kEXUrpr2j+daOorpA/+W9FUvjDXNjpFRofnqJIECH1BdKSISL1dckfgyA8/fiMpqTjVQ4ANqWEVE4uWKKwJlx8io0Hx1kkCBDwhPBkXi5YorAm3HyKjQfHWSQIEPCE8GReLliisCbWNw/659fMGh5VMDC0DTASYSL1dckaibqSwTBb5GVaOAAcKTQZF4ueKKQNsxGKVFtTovrHcIKCawAIQngyIx+cp0+Qk7D5j/7JAO/Pz3wwL78fH/TJ85bCuqj4Xpae+8iu5f8wYM0OICE4mXCz6Wvn8mjU1ctz397xYnXJHnoqzv7T0FPiCiGhSJlyuuCLTBeIzGplfm83FzX0Bj06fu888W0LOUGAe+AEXi5YorEnUzlbeNjWNRfU/kselrMpduXMFlKTkvV1wRKDtGRoXmq5MECnxAeAJce/kxaes8HpS8MJ7rG88ftFjybPflJwyzQ/HK1+jfKGCAMDcoEi9XXBFoO0ZGhearkwRqfO2qtOxfPpb+/I0vSfvswNt+y/g3vOP+6YDX/o/0wX/6z3RvsHC+otOolWWiwNeoahQwQFKt/kTi5YorAhPHyKjQfHWSQIEPCE8G6ciAqv5VVxFoO0ZGhearkwQKfEB4MigSL1dcEWg7RkaF5quTBAp8QHgyKBIvV1wRaDtGRoXmq5MECnxAeDIoEi+P9597Ve6jZAOz9fY+NeADWlxg5iNyiApG4+lhmkfxHDp/EHOOnYPOakHVUeADIobB1Wn0wqMSz6FzX07HBLz6wlv7d56BYXYoXsd5tz23U8DwdofSTgEyh0ZcQJgbLD6MYanPop/SUTy7SdpG6GM/vNvPMrMVDE6MAgYIDYMi4Z961v5E5tAnH81z6EUy9vL4u2CntBvNoY//68vSzQ+VcS6bwZbL/5G0iubQR9McetGvnpW+7dUo2MTx6xRFo4l//3CL6l00xAW0KMAsD5ET44vMeckoX2QnI4y9/pkU84ShIXqnrYvqEQVwpvGlbF3KyDGox9K9F8pzSk4fz6Hvw8uNDRGfUrIaxxvJ8zrGP/n4D2O+zKFjilw2INB8QWZlhxyLqlHAANUVkNHT0oHV+BP7v03r+YPn0EfpRxKl/Mr8R9og7Rb9/m/occbINyCybVAkXq64ItB2jIwKzVcnCRT4DCV9Nv8Xr6IBPeYprohoOklBzTaqGgUMEJ4MisTLFVcE2o6RUaH56iSBAh8QngyKxMsVVwTajpFRofnqJIECHxCeDIrEyxVXBNqOkVGh+eokgQIfEJ4MisTLFVcE2o6RUaH56iSBAh8QngyKJD/lqJIiRQ17aXjXtQ481vxOGswCI6hzQzT0TbT+u/aDs9xY1sHaj5c8ieKHBrcxb3YFfzEwuFVpdsZvdDZw/gfFX3PDn5QvqTGJBKQy2nNJugZbq8NJLAYrZM2TlgwsWh3VLchjl6f37sZbJnK9uPiMjxwguwTA21Tj8w4BeXt11LmH26d9P1G21OOkWNIlYZkGMwYGt7FZUW9Fa/G2KNu5l1z3xFNpkSMS4tMPEfSje1tWHIdXU8p5S+wFloY430Gh8NXA02AivsjAjb5psQJeRIWBtpRB/cOWOvHxCs4gy6FUYAQuk/Cxvnd3gFxme51GbRq6BQIgVKDBjIHBjfknQ/Q/1Kbfs1vP10Jh5wsEY1uHM5ppMAtkQItc9BiMqpx1K1CYqx9Gqj+4BruTBrPACDrSDH0nMhYiCaz5nTSYBUbgghTXKH8iYWlIDN/w1QC+GIIZA4OrYrh+HMdv+5ThTSP/7mvnBeUMxJmVf/mqYbNheXmfFwPQeYfqtFRmpsEsMALa+lC+ctgO9+G28kKD1WBpCBqJ9+94akA8PvvwOQuln9/vI+n69TGwqioCn8ZQTBEXixK15s6L09lvPyjtszWPuRh3AbnPNnx48W+lUy77gZaRuHwojZ5PW0ViUcUOJ6dLypEuHEnDKuLje4XCr/WIHqOX3vWOO9ieTtLnX2awT3OimCJTj2+5KE4U2MI8uW9snDe6bHc4J/H7yoyD3ZG++NptpO1Qu+R7ZmWV9UzW6eqkwSwwAise+Nfypx/H3razpsHKxJcTbeP5zqvLNtrkAKHUFyNgxsDgqlhtVGIiY0GLFgTQDgHUvuPzv2/z1K7o2XDO4nNK6nR10sx8IH3r/XvqkV6x/Zfy3Pm4dO4qmrto+Tv3tV+OzX81v5MGs8AIOnxA30Rddb8h4zf5zME3XP43tfhWH9b+++sD9RkrHtwmb5tg+2vSyJnN88KSfywI0Ezl0igNGMzJ5J/G1GuPT3viWaAD+m1nOV3jt38wHcJbGo8cmE65UQ4UKNGnEZ8sc/nLl3dWz77PFTzPRZE1BOykwSwwgpJGOEB8oWEZy9+PTcNp4dH/YGdaq0Hxl2kwC4xgGvHZ98p0RR6brP3bsw6eeWiBxjt4bJqL+D5/BWeAUGBlGswCHejfjRD1XZ6N4AJ+AWt+Jw1mgRF0pBn6TmQsRBZY85WmH8iu/Uh6y/72oYpvyzb+PSVte+ip6YJRd988XvofLgHNbymWThrMAiNonq82xfG/yWfJbsNHVoMczJhxcFsfKjGRseBZYM3vpMEsMIKmDn07ZTz/wUWM3thagotitoNxDAxua6MSEzHLz6GP/qL0uaYqATtpMAtUwHPoo/IxATnPZUH9o9O5/8b5+ID98y45uR/mnQL0CL6++L6MCs7Ax+c59B68kIj6wzyHdnpZdzL04Phr7vzndNbbDyxzaPS73XB48W/LHBphs2uaQ/NxCziycIdT0iX4CSLLB8e3Si5Off4La+wyO8Y2tk+MfzxO0FwHoUL6wCwwgg4b6DuRseBZIB279309dg/jLiCXIeNy7J56m9X4MTkx//Sc8jvbav+64OgvhHtGs6RI8dVR/tGvi9nYOhmj46voOWUnTQPqzsY/Lh9ZSKoj4KzGz4koiYoFnyk6MuCgjmdcpHOIFtU/l3coqvNZPDb8Wi/TYBYYQeu7N/88h95L59CSRrT/0tZ24jl094cTGmja8ZFpB5E1sDppYVqZ0kIGWoShqooUJ735RxAHG1snYzTLoVRgBFosajkf34oCGIoQNGDN76TBLDCCTaL8bdmjq3zkkWGVBS9SHDqmrSJFso4pFr5jTDb+D09Ph5UB114A1oM2dw5xS+JZi685MsRyYZhJBZv7+DwxxoDD+XdlQp3Ogt/9crq/SZ5jTLb864wRbV4Y45cE2zbxpRNcmLY74fJUvnsPlv7hz4eA7wx1hwB50Ij1v186/rp6+3bzlO3hTNmO0ZX/0SVyrk5ZOScr5mTA4Zcw7YEUzp/GEKQ7/qO0LT8WBEh9Wb3JDxDwCFi5zaTJDKv1sqQRO0aTfz5XuaStI/98ftm/lvHWvBg28/jsofwQ0RWf2vfm3KZJy6IaNjvx4fuO9IXfoR9lKB1SP779+TY9jfhdx2CUe5fbmGx5jnTUuRLaohpWa2ZJI3aMpv6jb6dZu94A5T+f/6mWv/Uj1K+U+8dVVKlD53WD1b97ibzotenMu9GJuLS4FgYuoBMRKhNw2xlgb7fFYdTM9o0Tx0D++fgA+spBt2/lFxq0U0C9ntx7Ny+GmZx+WPjGW9Me+Z5eROfEfTNhDVNo1YhvhhmDR8BKTAvzb0tXfuzX0755IQDG/AVpy72PTm/9m39OX/vebWnZ8mXptu9cnC788NHp4B3LS5X80ueW0r/QC6Hzj8iLAdBuRsqLJsQFbOITw2SG1Xos6X+ZgXRvk/bRbXHFAzwC1n6ZNplhtV6WNGIwbPEb8u8nbXL/+B0Cond48SmJGkViikXsGH31zy//eEtmbj+0a9BvXVx2rXABzIthTpzRLGnEjtEXv1g/fNWb066d4x/qjuCutIikWYkjKZlZ/EElS7LReuFm/fxbdp5w2XWpKmgjLDlvNIXhrmZpmBNnNEvoMr7yU+nY7eX5IbSxMuYPD+2SDvzc7drfwCNg7ZdpkxlW62VJI3aMgfVvMdrnH/dCw6VkruLXfpm2XBhW62VJI3aMSea/9rux43e1od40uuyKjmM8TvOfyx/HbvE9hAUBVSHknLrsTir/676ePrzf5vr81Dz/jxyaTl32SGl/D6ab/vKX80vK4QPOSDdWDwzTik+JpKeHdAcWjff0v5vr4vQmg1oK04/flJT6TLwNr36ltTgddfE9JquwOYmfY9AXs1f9Xtq19J9yP9T9P49N9OPMw3X5OHojt/+xy2SxZP/zB72QL7vcVEW76fZ/9Cz9jQ8dkHZeUJ4Rtt4vveKUT6UL//3mtHz5zWnZ9eek9xwUFwpstviEdAEvhit/qCFA8D00mWFezniWNGLH2Mj1z++/uO36+td0I/3M6PizXBhWq2VJI3aMTSD/dZqZRgoBB+mYdquV7RsnjtGRfx1bMX9u3WaOeTGsVs2SRuwYHfHZBzQAxe/38yLh/P5z0dHp43fjfolaPg1Z0oiZUX7E3kzu0XzU3gU4aq8vvvdsOorxfe92Chji3fZ0UYC3dQkamH86NvTat6Y98/i3KO1Ec2j3U5+Wkcb3IQren39SoDn0VR+VObTdfyNpC5pDH89z6JtvSzcvW5Zupzn0Fz7Cc2hZ3D9cjlR4JMfgRRUyh+Yfv9nPAizWIPnA+Gw/MP+WM9khwL9/LH2rjn/ueLScLrnMVnznUlGpRV64WHYyKvmv7592hwCxzI4mmX8N6hDzYpgTp0THGh3tnlNsDu305zI+JYZ3nnjkSppDaz3V9VbuP35OecTSBQww5KsQJjOs1suSRuwYK2QObe3fpS/3f5vO88f4yk/nOXT8/celd2jXdJCbQ3NZTJj/Oa9/JAI7BFh6c11twPg5ngR1qGsLxpVyI7pbKoomM8y5yGiWNGLHmM9/XWRWboS5kmr0TGZYrZQljdgxSvn//wAAAP//NpFZLQAAQABJREFU7H0JvF5FkW/f3KyEbEDCIhAgbEICElR2BxQUFFDZfAL6HHVGEhxncEQd4BHUcXvjsKjAOAPDCOgM4IygksATVBZlEVAhIORmBQJCCJAESG5Cbr+qrv5XV/c557tL7g0B893f/Wrtqq7qPr2c7yzO1326CmZJq7gqqHJUOSGk1EV/jZ9SZOnOa/200c4710b/BNucb4s4YOC7nfyJs56vd7Eu/jOLtmIiqHKyAqrU5/gzc8bbi1f6T2wxSHLCeYm5kVyM9BO/fL9fi7IDGv8yf+/Zkwr/sT5cpy0+6a96YW3f2n81tf0o2Craf8gH/AWLX23VqxA9d76e+e+Y4Q+OuWzL8un8sNNu9qtqvJkWSf5KTP13+rkXTC1yhbio/86M/bfRaFVQ5ZTOiVb/NTJmBSOrUt0o9jL+ISf/t1+yzvG38k8y6tMf30LyUfp3blM/8Uv3pT4dTfVf/KZuXcv8b7lP01gjxxNDtBPlhvv0i3J09do/xjO1nexKH6N6NBqtCqocEwdQUur38Sfa3ugfSW4B10P+8/Ff+q3WaD34V18VZI1/9sp3+eFh3t7MT7lwduUYrvT32k61wnd8/2g/aXCc/9v38Edd+ah/peKvhtFd/Guf9Lef8xY/No79bsw7/adv+1OlWnUHZrWqi/2sT20j40b7gf6MB14Kxfrj+Ouc8+/+zMM294Pt+mf0Pv7I82/zizqrNWHHqxb+wH/hoFGybhp7pP/iA8/7pbed5t8+FGMbjz9j/eQLH07x1pkKaa0KqpyU/86ZJ/rRyKlZt6W+OtrvceEj1bQ2Gq0KqpzkXzFSyvNPc92FcR4243oa67mP1a0nq96qHPWakIr/JAqYGun0Cy85wA/B/Ds+zTNSQhXVQJWjooT02H8swkZf+bH/u+3t+jLNU1h3t7nJ/pRbG9bcyXu/9X/tKB3nhXUa6qHtpnMq9auLHk416Ev8qbTBqtmucqz6An/Dx7aWsaC2/7f7Ecdc4R971ZRhtNFoVVDlFLaivbz/FzqlEUNrbs1xYksbVcvOcVLqq/+KoZzRnCqr9wbyX7f/taHW4m+g+EN8cQ0djv+DL/Kza4M2zB7Hv9LPueCtafzV8QTr/+F+q8//yq9k0zQ+nrFdOx3bW/h9L32sdT/ssX82THPT+VMr+y+7/xhOe9FOVqUPme7+0yv/TUY7/YJL9vdDMI7RHujqF1se1ale/eKfzcVoeW7abpCeB9IxKmuvPf2pmJv623+KDDUynBq0xn/nLKyN0ryqcYT5v5jDgtkYv3FR5Rgh0Br/EAVYGilpVa4KlNP1hP/FmXvE9d5IP+GDF/hZT62SkqSEnrLqgb/3b2+n40nbarAfcdzVfqH6IESNWibjVUGVU5aRYvBfI62abTRaFVQ5NR5Iqc6/tHdqfy3ZaLQqqHLUSkIa/KtCaaSkGxWrqVNVi7xO/OfHn7MRRLyamCqnvlhd+6tmaaSkPe2hrzrcj+C9VNs4v5fZq1VU1ahBSEn80x76ymP8JBx/tIc+kvbQK0sjJa2mqgLldBV76LHv9KdjD01KvYt/sb+J99A8RgyKe+hQB/XWokYqSojx3znnCn/moZv7dh1/6PgbRXvoC3gPHYtkbngPfbX/wsGjZR0/7j3+H+Ieer8h8dgNe9xiD528h4Okd/GnwmkPncYJ7HsE8h7a7HVS0YSZ+BPTYFm8xC9pVbWCVX7eBftKTkL8dkwnPPDiHnpA/EulbI2Es0r30KEO6/L7g8YNpOqtyoEuwbhOCfWg/oZ2Ay05muxPvaXYQzcarQqqHOMfKClV+t9c/NaR+pXUR9quzW0g648u7KFTPZFHgbyH/nf/mP7YhaANrIvfiCv9vTGpVUGVYw0LjvZGvSsapZGS1gJVQZWjygkhpUr7J2n1eG80WhVUOdZwxDf632Dzn69yQkOZBuzqpnmNWFDDYDMgA+Sv2A0jH2L1SIyMV+v/fn/RQcNkg4yJByeniE4/HE7wB/zbfDEdjPJXf/jX2maVlXrLt2qADJC/Bs7/SzNP8hOy+DGQMxznp9JJioH0L6Hytz25HtsD7RQWXbv6E298LqRIygRUvoiR8cr25xM/Y2xcgoeTI6On+WvKH0FgLED+6mX+55xLJ5rtIo/8xYXj8NNu8qtgP1jmEAzDko3++Uf3fcJiCZNDmoR38ifduJStNH+MO0ENg0uBDJC/ehM/LfDO57rVxT/Cb3POXX4N7Ksrw1hn/13+lRtPpD5d55/7FfXpS+awl/ARz/3pn8xq/+N2yi/cCOMM+rXbzZ8wk/t0H/x3XhMucKq2v/PDPzWLjqYWH+NuYONvqMNG/5qYDS3/GEdsP+3d8U+haf/XMHOkr+3/QrzQhzdFe53rf4GBlOwZky38L/dz+UTGoDj+t+/p33PlH+nEfFY6GQts/urF+EcnNO44a2+6KCCOP3xC41fFRQHGnaCGwZlicvF3/YljxUbb/t/0v+WNSlQrtAM/4zXmf7V//q4Z/vgdhsSNdqzjmMPyCxdgLED+kvjXLviOP2lr+nGX8j/ogKP9ByYNzjenbl8//Z4VpA4DVLTuY8SCGgbrgwywy3fOOsGPCmNmrG+cS7mvyvg32r/ZnszoZ/+IH/VC9XjNUjmZEerE/SvWlS8IwAV6yEUyEE0aRk38zf6jQSqeWVj7e/+9wzeNbdzuR/7lDT5bERhlQQ2jP/xn+X/W3/qZbXX9Y8eVlKPBfvO/vcXTJS/yQXUC5K9eHH9sIfMvJrNv2KcLAg6Kc3Fa/8vYIPXkk2T8M+EA+Q+WuWaoEOP0ARlgp39u5of9LnzyFX2q7P9jT/T/vMDM+D2NX13BYfBe+GfZuseP9a9tf/Ymngfef4xMgHH35+pf5nmMUbLf0hwhPwHy17q3v9pmBPYVNQwrH2j/tC88LdwkQPHbCwJQnXXw3/XkBf6YEXGdwWNMPGa1/293ur922av+xes/4LfgOWPcR/1lz8UrevrBv6ef+nXvUeefeHzhcLgowTbIQOe/6w/+e+8aGeemwX4TmpueW5/+bXz+WX8Lz02cf5MjpZnnBvvN/u7nnlY12m/RPMwKH2JkvPU4/q6m8zd6sWSob4wFcwWfkLdrI66wqayghmHlgc1f6+v4f9LfdrZcUNvmtvSTz7qZflyTha9WBdWv2/+2H+q/OJsu7V2P+ed0cT5D/QLBdEaBm6ARC2oYrAUyQP5qnX8Zy9NYs779v9bxb2j+ZYxPc2tq+IihfbWpDYNVQAbIX63bv1fx880ym0vd2vY6z98a9tBwyM7pA7LW/3I/56p4MQCPm7SHPvL7f8wvqF/X/s8X1sdxIPTtcYf56XxRQKwXqieVlfpmvKjYxXvocTHW/f+vvw8/9hllQQ2j2/hX++fupj30joPjvBHbObtwobCnFaXULvy2P2kruUB60AHH+vdPkr14mn9oD313mG1iO7CtdW9/XDim648wV6Q+mv1wi+oH2D/+TQpS/wqR0TlSOl+c4pdxLKtn2450npR+7I71QvXUJjEyHjqKKhSIURbUMFiVSbtOaRsU1ilLo1qhHfQzXn/4Rz1CZZ6J65TYXuX+L7TlEL8Z9tD97r9F/4sX1ds5SNoOfWtDWH/QMTvzZL8r7aGzfqVrJOKPoz30wnThIadfOlXoDAkFOyjEL1IZ2PaX/Jf7f63CevKPILNYuRIb/SM10iTr8/jbQPIvFwRUekZxYNg01ehK9vrwDVuAxkTOMlTXc3RiMl4tGDdOGMTyQWJTv8s3HzIWa1CYBTQqOctQBjXqfUNhC9BYyVmGMmhSf97f8bmJxSDJEzIGc/pxuTyZzYVhCzAZVJGwjIJBjXqGVq5i5AWnLlzopPGZt9M1rvSBLUBjJWdFyj4hwEymof3pgoDrcEWnsdMShRNAoxxYHfGqOfgCpFiGTaMLAox+n9Au/NBM7WRsS3+2P0CYChq0Tz5tIdgCNDK6DjadiELdAPnH+H9JP8abYr1D4RfQlO7y0qdDLuAXkPtSm82PKdgbFH4BTdmcRT9m0d2tozL/aePu3JDUp42NblF2whe5jKprfz7Rhz5mamPQbu13pwBbgEY/ZxnKoEa9byhsARorOctQBjXqfUNhC9BYyVmGMqhR7xsKW4DGSs4ylEGNegWVMQTjv4y/FSXYAjQKOctQBjXqvUSf83eeuWPYiDu3O10gtqRSPndjqK7lclcDPRkgxBjuauCLAfrwgVlAYyKw+C4HOqExBsf9uJqLAkyZKvqyf+Qbe/n2MP9t6Q+8fL5OeUEXfgGNgZxlqK7VdEf/Z/w74kUG0s6UCzqRUf8UA2NU0ZV+0eWH+XFhTuY8FuPPhOn+mpeNT1try1Z7PUM6zUnvfK0G/2nTmbsxlEF75rWFFmx10Y8u+oQAO65HPLT/Tv4EfuIUyrQw22MRbAGagszqWvB1/+4hVIfgf3fy/+x69Z+qE2rjX7n1I3579BkcE6BDH6e6mqflpPINGOIGNGo5y1AGVfUOWaflfYrbDuPfaL9n+WMKF4YtQDWYRMIyCgY16t2jS37gp08aGsc8rIdj/+J6Dt6bLgBd3FAl49Sg3TvtRgO2AI16zkqUjjem/U2x3qEwC2hK5yxDGdSo9w2FLUBjJWcZyqBGvW8obAEaKznLUAZldW0PHH8Ee/yBLUBTMGcZyqBGvW8obAEaKznLUAZVdV5D0wUB4fi3FwSoQgMCW4BGLbHm+2s/vJnk2fT5tF/byR97/X3+uv+1OfmvuWjL2KygcAJoFBKL9mEXykXjySfmBBk/0j7BGOgJCieApkzOMlREdW4K4z+t4WbS3NTbD8wCmvI5y1AGTep08fgtH/ETQ10wpjLE+B/7xhZ/pU9yC2VhCzAZ1HFYWEbBoEa9byhsEcQPPfZ4Vjz0O7pYkp9ygzJ985iXgi1AI81ZhjKoUTfoSr/wqiP9NqEtRvntP3OT/1NTGeZ33e3/6a3DivMfE/z+l803No0BgxqFvqGwBWis5CxDGdSo9w2FrQi1vWM/TkahSByDJnkfMdgCNGZylqEMatT7hsIWoLGSswxlUKPeNxS2AI0VZml7xHE/iGt0TbHeobAFaErnLEMp+py/w+6hezX+FhfUD6KLAa7K99Dqpgw6F5gaN6C0h+aLg2SvSePx2MPCkwIyszU2E+sl//A3p4Q9tGujPfRl8/rhEKAL6nkPPRrzA0FuY3MxQPLPNTWUojTOZXvoYk1Pe+hrX27ICdiwBQh+7jGjOukmqXDhmF2LxPFC9j9pD23M1aPwC2i0cpahDGrUCeWL6vGUPczByC9yM4nWCeaSdtgCNAZzlqEMatSb0biHlty8mfw/k3RhCzBJbIsT1ygY1Kj3GOV1Cu+h871q7H+xHXkPfWV84qwYNk4N2mOnTYqwxXAunhCAtjNwA1l/dD1He+id4k0wdf2/Pd9DN4WtfBu/MgWBqELlgqJUz0ieV2z72+4FC7kbQxkUun2GsAVoDOUsQxnUqPcNhS1AYyVnGcqgRr1vKGwBGis5y1AGNep9Q2EL0FjJWYYyqFHvGwpbgGSl4eyB0YCrGlYQBb4RKqqI9vfEyYZYeDDQaka2stb4JVe9Sx6XFAbQtuzgwiKOD7ihH/+JX07FURSQLVo8ejCgRlrDCgUC3wgVVUR9JU5/++er9UekBWwx4Lh4d9vA+TeWCeUfT8eEtjGTiqHbDv+e5+cVNH+MPSgxq/O6dOJH7cX2x4kgLapI3/PfkSZJGcBlgcO4noQJbpIvdZYQxYxW5KUf3TFBJFj84G0LIycM18m/NWRxNprqliYwxM91iwu7AfP/YNany/w7tyPVAT/QmOQoqkiL/NuYLZ7Kgrs6LMQRv+3X0v+4T4dLJLSoIq39x7ubUruLbaa1j3ElkjlUSWDgG6GiimjRxGk2Z4zW+MlZgQpGjWVFFdnoP6YtZWTg84/+hPmQ4fr0byOEX0BOx6tzZvi/4B87qV5t+33N34mnBKROFbMWQSgsjzjcOdxlS2X5YoDvP0ojlbGsqCIqTRxbu9yNUEYzXhSQTmgUP7wHVasPe3Q18FPf86fynfgUo6M7Ca9ZhlsbeuE/mQvYqtkz/HvGyDgkbcvjz47+nVd1yKsXtCqK1Me//L/8tG3TI+DRXxgOPv5q/xT8AiZz4AgMfCNUVBH1v6p4ZYDUP413ju6Ckx9uU1l1VsMKssA3QkUVUf+JU+Y/ncywecjrx3PeC1odRYJRY1lRRXrgX61FhMvmjzps2+4Mf0Pd+zCCm+RLnSVEMaOlvNKz0FbTVmmm/8LO/DQJabPU/yzNP5D9iQolG8AA2aLFowcDaqQ1rFCA+R38JCdbh3zDzf2K7660JixuHEe0RlrDUv/Wsuop4rs6f+0veld8xCjqmZ3Q2NLv9Y17zd1ZqazWrYbVY/81UTWZE9UaaWRxm5ftn7WmFlVEs5M4WQkNMSFWs6bySTEaMvqKKvKG9s8/eubtgS39n0f8oXHjXcZhPDoIrwzor/jX+mUzPxQvhKpf/w/Zex//lrCWocfS34IT3v3lX/Zh0sb1/oefZp4kpm4VGYD+z3MTvS4gjGXU/7b/O5qboj91q8gA+DcDQHBDX6tuDHMT5uzymBA+5qYNb/xZHddGqDdgiofnMHqdUvlB/OBr2hVZP/mP/rvm/5M/lu7mbXOD6NG93/MP0roeNQFkVcVr97+jqhfwaQEECoeZNWM4FQAGWJQoDDZIbWFbIvCNUFFFNNbEMdU0trit0e4Ms48tbAWBb4SKKtJj/8lsKqu8GlaQBb4RKqrI69Y/jj20i+bCIq9h/Gsfoz30YJn/B2EPrWlXpMi/XFC/k7mgnp+ul9/clMpqqDWsHrc/vT4kXFgf5gtap9MP79NvL562p44YSc6whw7HxXafpqfxpD10j/1H22KVbnWiPfQRxQX1/Eo43kNDJxZJIFUp8ZbRHvpN7XrM2v4yhPbQizO/NqocTwaB1TiLrOq59XL9x0/Z43ki2QAGyF4sDq8J1khrWEE/8Pmr7nxxvifD7xBcrslcsFknbSqg/qVkKip14lfuDUa/25730GKoyVz/+s+tBZ9Yp2T7v3zc53Pb7w976BgTg6YKB74RKqqIFk2cGnMd+UX1mIfQp8OTJ17L9ceq39AeeoycL0R7Boj+v6WfwntoDVKRnsVvUl2TnVpWKBLcJF/qLCGKQSvk1LR/5joZzdkonHNjvYxQUUUq/tlEkpYGG6RNBQLfCBVVRH0lzkb/NhfVFqiR1rBCucA3QkUV6VX+adVJC/ZUVgvbSkIMaLuM5dkyCbcaFodG7/2vnf1Fee+YDgz2BHmahNre/i1/vw2uITqrUl9DqauVAQdENFVoNSwOzYb4195Pj4sdTY9y2t0f82NZWtjSwANcLT+UY/AGTI8hx4/LKAXfDBv8GxWUApRSomB5KBLupqa2Sf5jm2AQpLv5r9W7+XvhP94JgvgSpPbHBQGohEJbQ4tDoYX/jhn+kHCXAdlH3WOfGxrv3q6zCMsCrYbFWcqLKLwyADlCX05PdUApQC4JHJB59R+rYXFoN8UvP5JIG5bx092S8YkTdRZhWaDVsDi0GvxTW08Pd/1wPkr/nCvp03UWYXmd/Bsj7IPv4JDHXafxJet/WZ82hbWlmFdTWzqZedqotCB0bWh/emUA9TE+TFAK0FqyPOZXP1bD4tBsyD/EBFEKkEXAAY16gVoNi0Nto/+BmH+4b5bjb2o15J7ha5X/J/0sfi9gGE+3p834gtCn6nsI15MecYj3HYYy2/kDL51tfkRjnbqPtWhx6PYgfr4o4Bx6UkAc+8MJjfg+xDqLYvk5f+/Zu8udDfRElSn0yHLyBKcG9sB/1F4b7jLGawIwDg3xY0651i+qMx3KWYHFn6L8bxXzb8efcX7yBfU/ntrSwAFNQAWaNFbTKwPKx+JiDJUNKN8FVz3pDQuA7AA4YOHUkFbD4lDh/KcLAuz4y3VK81+a87gkLAHCWhVaDYtDs6H91/7Wf/uQEdH/YL8pPZGIL27FB5YAwa9Cq2FxaDb4h5ggSnX5ZdSnJ2mfQdvZOzFdvEtWXgrFRlC6xJnmT2/8SwkpJXiwPve8ygUB+fiHu2ZsXWCrH/zDVB1c9YC/+sNvinc44Zi1cILf86xf+Gdj1epraGKNPqAHWOe6uZTV7l38qc1TDNZaFbc1tDg0e+c/lRKsziJ0qhp12q9v/9Ieac3IdP6xMVscWq/v+ENEiy/wR8eLC93EL/ibwuPnUnzA8rEI3B7Ev4ouhNpFHi1c1/8x/rW95Sv+1/FtAbCe++xL/jt9B7+bt9h/2noMm3Zz8YNO8r7u/pMFrT3NTRfS3CR1aKe56WZ5FL91q7iWIo7FodCD/EdVWxo4oK+Zm8r1r6NHBldeu9Mf8w9CqYWphq3ixwUBzeuP/HVKsApY6zowrYbFUaK/8k/2uh71Pzg+Pk1j3An+ggV298r+avwv/Jo/nF79pT9AhP0v5mupI0oBWkuWJ9rlt9WwOPT6MX6YzKD1aXEoJf/heDL7/6QhmC0NHBC6VWg1LA7N5J859Rqia2XAAWGtCq2GxaG54frP1//1F9TXRYTIBFoNi0NrXeJf7GeGPTTP/9v7w+IeGpar/pfJ0/VwQb3jPfRD5ke0AWz/sIfmV/DFdWN8UgBF3+L3h6VhDz0onP+jfSntoXE5ADIJmMdsKatBvhr20GNPvibsoa02rIAHyHzBn6b88x46X385N9bvSXto+VRLRYHKe3P+h8+tV/fQ1n8+dqKm1bqgFq3yn5eqiyTx8gsCeCyrzr/xJi64DrC//GdGhVh7n7/okOFmnTKrZp0ygP5jfKlmnK36PXQ+/8mTpuh2t/BBjgGZCRxQNOu+rYbFoRvj74g3P5r5Jx//XsP1x6rf+atPfpMfhLGjArfyk8/+hX+mLjzNFMdbp7C+2988eSbG0ZvjP7WaYHURQaeqUae9/uMv67cx/pSR+hZqbsk6/WSNMathcWjl7W/OHkTlAGxByy8dwGjPoVomRPFQ3PqxEsuP/l+9xc/YNW3QdTANB5iZHDf9iL/sBSwhpI5qmRDFe+tfTPXpW3125/+Fy/wpm9LiqW2U3yN7VJxaSP4Xn++PxhWfdnGCkwhtf+G/+LD8Aq+lu/Ov1mMJW1Bl9UjXw3TBBreF+udFYGqXtiEf8Oc/uab3+TdPCGiDbfIT2v+gb3t+S2x3HxuG4qGQjTPi/Bgd9kP/0sckBsaH9/GVAeqTEH4s/zx6VHHefzlX/E8/ePMjipElW7C7IFvIrRnFa+OnBR4/Rrk2/gP8Z3/f3fOw6iuhPglRvM4/9+mhkvu6/LeFPp1f11zvMeeqz+78a7FYgi9Cin2Y26vS/wZTn16cnYlUCxap+KfXYPCFD9LmOZTXUsQStqA12EvcmlE82LB+rMTyWdHKeuncliYzuSXrx0osf6P/MmtNLSAnl2J/CmNlW1DVzBKiuJUEppVEXFmKNLluydfShKxd8C3//s3iFb7b/bW/agkdP0FBtcgW4/SIw+/z+w4x/tLVwOc0bQBauk8xk1nrRanAtJKIh/ch7hNOaITjn18fEC8KqHqkV4w8dJZ/B49fPFbsdZaftULsqGVCFA8GIhWAlUR87Rz/o5O3FHt2/Bl3sr9k8epqFRo4arnrFf/wN6aEcSyff+jdh/fU/PScCjZY7p6dLhRM4xyPo8k/ncwIJ1LUGRmNuLIU6d5hjYaWJkRxc2FeNg7HuU/mHzwhIJWqMd8tS0tn/rlYlASw1q+6/ZN+V/VPT06oPcHUrbuKQs/8q1ZRL+/X3DPN7277H+P0n/JGx+gWn8gfzWxqoZYJUTzIIxWAlVg+K1pZNNyRnuRk15lh7cJ1a+OTZHKhiZYmRPFgJlIBWInls6KVhYKNX13P/9T/4zs39+1x/EWOUr629HueebN/0vq0eLDcd/91FdPaE6J4xY+VRDyCMJ4V7V/np4mnlglRvBf+y1JNfpr46vMN4h/tgb7F/b/V540Wf4gV+00+1jf9pL8qe91Nno2+xf+Sf+Tr/OofrD9q1v/xor/8bEPum6ne+18Z9mEyZtT75wuHe7oT6r3/WEILrvWdNDftFsY0HvfxVJ9qrHUcNUOI4kExUgFYieWzopXlHtbcM93vZs4zpPGf6ym501fakJnckvVjJZbf2n9em3pKLROiOKl2zqy5WFLnf55jMYfZUvU+WnG1dOFfaxMUVItMRVxZihRu6HJBepLGdiHPW/m3XvqI/nhnFbU0IXQq0r9ywwdqLrTfyh961eOxWCxhC1qDvcStGcWDDevHSiyfFa2sl85taTKTW+oyayjurzg1u/78h2iCO1uzP1//YfyIxyCPv/KxuYmsXgAtTYjioXykArASy2dFKyOK99D0RI4w/2/3KdpDV65IC9Y9/RTaQRfU76Tv36a1J/2Ill70Yv1YH5Zf9R+N9wxkrw+gPs6vuaMnBcjH+mGc9tCz4x6a2mDQZOyhbd165la1uub4606ekO1Xwv6T9tAXL453qAXz1kfElaUImX2F1gW0h+Z1h/5zW0ylPfQKdWsRLU2I4kEhUgFYieXLPME3JlTOP6r/MeFpaNanxdUyIYr3wn9ZKtmm1+6FVwbEvsj1wRohQOabi+r73X+qiWB0dv0O2kNrPSQvGvOA+y/rg1rR0zHDOkX6TH7+w/QjfvVeeBpGrLGteL3pHnGtGcW5ZEf1KXv5+PfarD+6nv+J/8d3bR6f8iB9i4+31P9pHPvcTf6JLJjmVKgaIYoH9UgFYCWWz4pW1uynScKl7XjBccjH+rE+LJ81rSwW7QXQ0oQoHspHKgArsXxWtLJeOI6qWpoQxYMsUgFYieWzopVFo70AWpoQxUP5SAVgJZbPilbWC8dRVUsToniQRSoAK7F8VrSyaLQXQEsTongoLxR6Y8VkrkziwkD1qg5TAmiAvOwvP1VOtxpUJJVa5u85a2czCdsBIg6q4Uqnvf0nbn/RlIOXZAmcElY0Mv9UF6MgaIURK9zH+DtwkpMHYnl3nPGQ++84zx+CyRcLA3Oll3NH+BkdccETArWWysiFrmgQw/Jaxj+Hf0g3CwPUCbDtcH9eVp9qHawvVLmLn4QwBpNmbr/tkAvTBQEoHGAf889OO9AGvCEnvxxTzPPQT6W7MsQdnFI5oAG28s9XVdLdH8gLwTDZhU01nurAFaEP2YLZQBpC0AojFmjlP1iu/eKLFWSBJ/nO4z/Cnzsn/Qg1IP47Uu45P7l/rtO7qU9LHQbEf5mVOTP8Qab99QRTbLs26tN6jKEpAuwm/8VTL1L7V18ZALNctZbHHxR74r+MM9IwoWJiWN5G/5qZmBeTHaABdtP+yUyGwYQyiWF53eXf3mmE8UVtZZYS12LWV+D30j/KcK0rtpTzvH/gy3vFR8+O9Fud9jP/dKxEKiOPONyZ7iKS8XfLcDXwn8yZd9FNJdR8YLXybyPOcWNNBMTooocA8pMC5C4HmgvCOwefjic+TQl+vNnh8ngz3gS/59qFWiU1lrurUMYayTr901e+24+tjD+b+oln3+Hl0ixTAmiATfHP9T84jh9jXsyj8d2HMKEVI4blddf/QrnCv97dQHNoGM/D2Gn9048LfPEjfawvMCyvL/6DHRhLBGFprrPjL44bmX/oZMas9MqA/vWfVYaq82v/zYNxBybPdSP8Nmff5dOMS/kxyRC0wohJbGr/wmdBGmsiIUbgrb3FnxvulrXtRu2ZrT/p0cw30Im+UKCf/cd6ZvF3u/6Na2iNsRKdSoBUNIhheZn/UMhIu1b7pXef54/foXyah6yleA3Z5mQcq7+rIfcF88bDa9b+WP/acUPqZWoHNMD10P5IUNl4fwb+MUbZ40876p9B/Dw3Pnn5oX4THX/28Z+47UXpCf0Yf9ejM+gCPxrz1E8x/g19n/96uCOaXAe/gOva/2Vuqu5/kv+hp91MWYBT+AVcV/9khz9kPnjovNP/3zA3wf8Iv9U5d/lX15d/qU39+Ec3isjcFNeKcW+GY0Qgz01YZUZjNcBkU6SIv5V/2EHhAHuS/7X+hWuO8iPjPrdyZ2Xgj/Tbf+UB/ZG99fyDSjLsiX9UPEGEoJzu4u+6l+7GlDVL25QZ/hf6cIBW/vluyeI8Hsfa/h46v1Bc4tKd/w2h/yFZSF6AreJHAYGyzuS1gRxbmfTPIH4bL1KovNcgfjtu8Phr67ThHH9L/f20hx4a5qW4h8beOFSY+5/soSfhyQBtE/yUxjtqJeM21sDpr/zHJwXIK/honA576OrrA7o6+RHheM3WJH/UNQt17OP69D7/nf6pq97tg9+w/o5rcTeK9tB3Vp402LP458U9dLH/GT/dX/sKVzLUNOs3zIkCQRu+m/zzk0rlCQGYfyWOtP6jvQ4uHh8A/6huNf904WK4ICDmtfb8P85pV6KDWYUVDWJYXtW/kTLK65SD8j301rROkVu2jK56zJGKBjEsr1v/bC4UqBn/1/7cz9AnThXtGOZ65qXXG4Wa9af/LJIYd4ecb28+/5E/vXGd4q/zH6sB0EVnO5beNcMfv6PsoevXv/FcYMwzyqr5pvyrgpaoIKGo5fZj/mX/j/Gn/gLugfSf92QbZMI3+k+5CFg/tv+GnH+9IKAybNkjvsgNkxX9TAfdCTAKQQKaA7Nirxv/q/lOJd2c4+CykAfVUX7Xb/4uLSTgF3Ad/Ffq28/xr7nt434Hmhzk7iY5SW5dZP478h9PZSFrJ5oj5Ad4xA04UPF3nBsftZ/aQyYajod5uEBBK0I1SXiIs6797bsieeK07Z+9MgC2AGPmQAIan7X+Oa/WB7dH/B9K7220l1hED02OhA+/gL5YRMF+8LmjPyk+lj+3DVNqpEYMGWBUAQnYMv6Vfh4v8GrjpwsCOooNe1YLOADsg/853IfQX1LekX/n6KKSuU0tAL+AffBf9r+O6jGW9T/t0+wLfgFb+C8uCAjxxZy3uvOn0l+jCwHwC9jCv4pK3YLO7L/24//G+Fu1D99tYsd/PslEUz2KACqjpj3L/j9Q7b/qZv9/pgyVcbV9T//+Hz8utQr+6UTGVcfSkwFw/Kcf0V6z9jfvQwzHf+WEBl3k8I196aIBzv9gPyY+ijCkD3kH7Gn++V2F2w7SuQdjYNsmx9OTduzPxGgkOACMfJAMX77GTxuPvCY4+Pgf+KdYvd/bn56Gc37TfJL8D8Pdjv3un2PiwOgDqMizfuZpW6T8xvFXNqGoW/6j8sD1P3o9xeffHC6Ssf7b9qKT7PQ+XnwGzn/00Jj/Z/ys08aHXOXzH/IkcPDxP6R+lOobrIIENPJKPI3+pX5Wf83tn/ATsXZSaMe/eBcr/AL2k3+0CcOu5b/3N5x3MN2JZf3L+KvtOWqqf//lf/AvmhhtPMGekVn7wCv6EEjhSGmgQoME7EP8GHsYov0z1wPsH75eq/g3NP+2PYCnAU4bWqoNErAP7b+hxe/t+iEc++1+xPFX+YUhRg103ePvesRf8b5RaY4w/Z9fkzLi5Gv1Ysb+zf/z/vbPTcz8op1x/A163xV+IRomQMQNGIUgAXvb/rz2OVPmJnv8l3NT/8afBaZE/fH/rM5NdetfjL+Dj4trnN7Gr945Qk2i4QKFDDDyQQKqjVX0Wgh5dWBo29r1R36BeP/6r4mnl/PPqw+c4d8S1ulb+gMvn1sEXJCIv4tei3QwHuls1g+7n+t/uQZKyGkON7T4y9oJXcQAElDbX/KP4xrnXHKbOfVGjD+LsJf9LyuredVEixgkoOrV93+MF2gX62ODyr+dA8MeelGsKgcaL6jHkwHaaA991i/j47U1EZSJhIfCA5n/8LQ9XFhPxz3toaff9rSpAV3k8PV944/39Eo8u4fWyIr6Rr4AyACJS3vo6W+iPXR5PnME7aGfWN23+F/hPXS+zue+Mvj4q2UPbSIK9UJ1AI28Z/lPF66zH8z/6J+Aw/TctDpqSEuS98y/mOHvij49awL7QqlHnhc+lsJTbviVgOpWkaq9del/YZ2yR7zRROYV9j8ou1BNokBElXjWxb8GmOILfkB2PetvintotFkGYx8dgnMxqKSBlfoaWUowHEYhSECtp/erb/942kPXrj/W1/kPqv0K2kPPOFjO+5XHK7VjyNXoffwH/v0PfpnGYhMAJmD38VfyOYDtn7U1xcOf9ek/NXvKz0b/KRfSIAUdmOmrkq8kIgxlAaMQJKDqbTjtn1/2WNSbyS5zYGgcUc+CiqxgFGQoGng1Astq9P/qr/xX3xJ/SIiDRFjAMY4BjSA2y9Ym6r1O/mEkwor9glGQ3cS/xj971bv8iBDHtv7Ia8IpetN9CucddPcyxV0Xvww+76YfcKs/ng5Y/HPj1WY6mOeLA7kggBdh9KlJjGVl7W9eGcBxZQsiuiAgu2zCGql3071/ikPzGmKRODjP/MOFzWjhrhJXRR7qRAs8/pEktF2ZI3llQBY/56vhU7FfMAoyWAm8GoGwqG78ygD0qyx+XNCRKlMxUzAKsnv/HelijNCvM/+8KKCLXMwFARX7BaMgu/cfQ9P8h76Q2r/S/7g+9hgrHBZk8r/qWj+NXhmAuwLYLv75lQErN9TxN+YHoBJfwSjIFH+NwLI0/1TC8uEXsCIrGAX5hvef90/pt8gVYMhJTWIsa+DzT88iuf/v/f5D4vg37jj/tcdeoiryxQD0iEO8X5ROZOx5Nk5kIIIEbZ0Dt2AUZFKpEVhWbfx8l8PZb/HjML+FExr86MPV/rkbT/a7xtf3tL3pL/1lT9mnmKT6Mhb8WGdRbFldXcv877/05uyx4zLP07t7P36DX1pTJrCsEfiKugzW3HO6PE4vjjcy/oz1k+nuAtxgwnq18bOg+BTuKgdrl3/O33HmDjq2YYwDxPjHJ1MWG9v9598YjWioM3/Rjz3/8T7cjZLGX11Hco7a+E7Iu+MdBg22LLtISEEGTfWPcqse9Nd/erLnR0KGvMT+JfPfWL/zmc2vyajYLxgFWe8/1sPqVvJPj938wXHy9Its/UV1ln7JuaL/Qfv70++Jd+qSXWsT4QZejcCyKv5RWKGslYeX/pnG8UkX5wzFhSZaLtbJOosyy+revxRau+IPfta3TvSHbEWvMkO7Gf/Szwf5YZM/6r901zMhH8GPdbYO/itmCkZBBk+BVyOwrDJ+jgPtjPyyMVsmGQ9YHZl4lYK5rdJ/sphjFTMFoyDfMP4xftp2ScGlHL0h4++kd4t++E30KH8ZL9EvXfjRwz4OOe9TyErISU1iLCv1v7X+xes/6Leo6f/O7e5PmJkevty/+e/wP+Qn+YSxpGH/sdu5/hflk6JtEFShgkxVrBFYlsbf+aD/8af30lcmhf6m4xvPTbfm73C1RvrDf4ONEAhkPDcdT3NT4/gb59X2/f30u5dJTop6sj3L0vgLPuvZjy0T+AWjIJNKEDzhf/qxCdW1EeLg/s34fv/k77OLM1OBiv2CUZCFf2OIUKvb0/hX3z3dv5l/dNz1s/765VRJa6SwCW9dz17sTxiOYzeu/90gP5Lmajxwu6f+C3c9888VqRTMWevTvx3LGQ/V27j/D3kIuVCsilSasWAUZDAQeDUCsHQciccf+FXveZ9JxpNmXdnAqxFYVs/6X5dfGfbQcXzb7Hj/9UfjHppeE4BX7Tk3IXvXdv/570P88fUB8rQ9GjfGviu+gm+1X8J7aL64iMe8rT/mL4+vxLN5SZkVrCLLGCvoSYS0h+Z2zP7pXe0fS3to2LRFW+X/1Xv5FTXJpqw/aA9NT/Q1h20wa21mfmoElpX7X0p76B0r62/EhPXP4BPogjdrhBwWZKpTjcCycv+oeRV22QsmMW9FmC7OG+7TXfqxTtZZNGtZPfaPKvEe+m+myDql4n+M38WsU4If66w//KMehd2MDOuUsVlfxPkPtGWAg/f30+4yTyWE7RqY2Wd5wSjIYCHwwtcav+Sqw/0I05eDf7Qj8wnnJ1GtqvFd466X/sVoF+2hZ37rBH8w76GjT4ahX4e68Bqh3Q+Pe2hblUp8BaMgQ9HAqxFYVq/7HypljRDPkiE2k2sUAbS6A+E/82OdRYFlbfSfspEwZDDBiqxgFGQoGHg1Asta3/mXVafGZavCTEtbPBaoYaGMiOi7TqecLfvk/xU/5/y3FleBYVORJmk3/EP+kvK9Sv3iv0hPEcO6xb+cHqU2KU4Y9E7fe3l7VJNIsDriD/DFXaEYeNra5MflVEUUVE5ESr6lLd6gHtj07qeZJ2bvhQsnDuOALosWery6+TE31aL0YWnC6W7q6aPjO6fNgBriPAgXBEgZ/bYm4Kin7d8R36sTJ0aZnMR/uJOxznZsp575p7sm8Zilwgc/MujEmfi5hyte46yGBb2e+UdCAK1Bvho13rVQ1K0Nd8NbdZjoVfxaKCLGYIe5I7/in49vys+Nz5cGiNbIBTcmVbmn7W9yjnc88sINC28cXwL5ggD+8a+X/vGEgCJGtslX+qYFWE0gNaxe+9ekMFIatLTFY6EaFmyIiL7rdPqQ/1pDdbZ7m/83aPy2b2L81VA3uPwv97MvOCA+it/59red6a/49nvTkwH4BP/ZxQlnDua1bH++Cv0sc5fDGLrL4fJ/8MeMi2uP9n39R26lux7q6ljLrAuICvPTAbZLTwdI4w89Uu7HeP+itqwmRdzSd63/V+iOtH3zEyRh/CnffWgLWzz6q2HBoYjoOyBr/IrZX6bcDEpjpxnvQl8FzXm78Yk47lkHFu+tf5sfTpG19YpfPPN/+ynxIg6uS2VzjrqN+4D/8kPLkjFrRrnC1O86ncw/VeelOf6OK6f7494sd8s1+qcTerv+1WX+l0/HWaHO9kCOf50L/b3fea/fOdwJaNbYcS1W1rtt0v/25z+UTmikFNVWnBtGVQSxtMWjGuWxc/G1/vNvbcgb6kXt17bfV/2vMZkW+U9OSx+WtngsseoZ33HnVf7iMw73UycMrvYb498NnuinfvY6/8By+uWuv/zXVAk5FBF91+msg/80/qT2T/ljTD0L3s/+M191tv/M/GfzfNz/Za1Ql6N1aP8NIv+dT/nZPz3Xf3yfTeMeWfpiPv6M9OOP/Ad/8a8W0KWFxaev8fNdhtu2pzksHt9u1y/6m/TpLf3Z/1/2T/38r/3bh6Zjre74473QYZf+Lt4t1Z/+6T6YFY9V5qb6/Q/NTZ+8zP/i6ZUh2VqL9dX/4tzE78i2x0SYz3n+DnN42ru17fwxf/7scm4qK2tpi8f+VMPq9fhH9b77u7TW7cn6g14zM+XM6/1snkP40x/+xVL8Lg1a2uJ16iv98wse9XOX9rT95TUJm+IYwhrLbe0Pu+qJGgfd+UcgoqffNcU21PkX/RbjWN7ANYHUsFDm9Rg/6o6WzOmaYGtYKNMf8aM9cGFAqldN91SheiYO4XV17Ov8oz7q/C/zD//zgXoxcdvbPuev+M5RfhJfUB/GP95D/9I/y/UZEP+oXC/ijxfWh4sCuI5jD/PTLv+iP5b2iSH37VP9R27B6wRqElnDQsK1Fowsxx46jf/Spjv5919v99ClQUtbnGNd6TvOz/fQctzyHvqltAoti3HRPuV/tV/x0JdDburnX7NvpT30KTc+Tntoct5v/msMKesV/9SNH/V7FU9Fw/GD8098YUAb7aHPe/CF2mpVK6sOOGmcufxjWLxOufM/TvcfjHto+GaY+ac99M6f/Fdap2AzaE0ag4FtaYvHMjUs1FNE9F3q8Hz/7SOz+T7UVec/045c90m0TnmY81UaojrUsMAUEX3X6WT9j/bQT9Ee+m3pST2YfzSHsW5tb/+q/41NW53t6LDH/jtpD/1r2kN/lvbQW7aH477Jv2uf6PelPfT9G+T6B/1II5cGqslR2d4oWW0sW9jisUQNCzZERN91Oln7J+9VZVvY4hv9hwzUpAQ5FBF91+lswPnHCyzo9bw0zYQPH5P8iTST4Xd2GRWMJOy8hGvLAmfN+Akm6Ut9QCCQkts3/89d5j6661+5q18QO+w5uIqIgG3coVfe7X556rb975/8DUz8D7l/PWJ/96lbVrm2TU51//bUFe4TY2Sny5Eiw6FpOOIll7oTJ57u/ntlXfysvaM78cbfumvfuxkXr3z6nH+yVBf/6ptOcuOPus6tIDnvxGOtxC+RbcM/5L676Idu+vhBgddj/6uvozInuX8RwyER3DVDmx/8bffwHZ92e2h2xJ044G/S6m3/m/sl945dznN3hBBMHIQO+9RN7sVL3+PkAneW8YdrAjww5CtUsM5/p5t34YFu5zMeiFmKPoKJnajN7nfXHknL5dfk+FtNdTvI7XLG/bxCodBi3TiitiPcjDk/czN2Hkr1tjFbXEIP343xi05t+z9HfXr7T1Of9jX+qZzfyZ0w6z53HedHc96P/mEzmPRu9awPuS3eK306NlZwq/1vxIfcJYuudtPGD5ag7Her+Ndc66Zt/iH3PerTeqyE9uc+drNbfsm7Hb+6lJ0FM5VoRSbuLG4qEArSV2/7P5sIJsVuMEOsWL3Y8iITbxYXTvgOBelro3+TlITW9n9kOaRU8hrSSMV6kn+ez+WIlW/2xn7qPgPhP/MT3NJXq/Z3891PPn6YO+4/nnBrNUCOYYLb85wfulu//E43PvJVTE4GbPwJ2SMHXPfG42+x+/U573PHfPUP7sVQF1GnOxTdlK//1N37hbfR/BBtsKFW8assJCtaW+OeuvwIt/Nf3eZWZuMviTf/pLty3vfcR0ZzNvKMECP/BJPW/zz3w+P3daf8zzIpyiIq4bc/w93w6LfcsfRoIrXJZRvjZ6017qWn57tFz68lvCuUa2tf6155ap57cvlL7sUFD7qHfjPT/ef/POKeEnEwl4118C+1IKNj3bZHnuSOPXCq23fPrd2o4Vu4STtu7oaufZXsk5irt8nWbtIOm3Uz/65yzy9c6J5+aS0VkPjbBxNv3gL33Orl7pmH7nP3/fpG9583P+5eChohCxyUfCjn3L+y+a99e7fH8ce79xywt9tn4mi3yZjt3W5bjQgxafybTXS7b72pmgl9KPjvdM8//oh7dPZ8t/TlJW5BR4d7/Pe/dD+e9Xu3gCqQ5YRrUOef+WN2c1OP/qA7+vC3uikTtnY77bKT23nnrRxdK0lCVJ4V44fZwX+NjCXZ+nule37RAvf0y94NeWWxe2TRUrdyyaNuzh/udDfN/I27+/FV4iK6YpfBPNmJ2VMk0O0T3R4fPM6958C93NQdxrnRW1FdR9NZSmiP3MpNmkjtWOn/zq1+fqGb+9Qr9JgvdkJrxbYu1/XCAtfx7ArX+cwj7sH7fuF+du1dbjavB5v8w4/bxI0/crr77EcPcjtvub3bPbQZdUiqJG3a3CDyL3USngj41AS1P/kfMmiFe/LhJ92KlU+6OX+c7Wb/4W53xx1/dAuXk1zcqycgko/N3LbHTndnzfiMO23q+CCK6gry/FtrpMJky+MvKERbFlfzsYFIpjk2MkJ745/zhPgYctVoz7ve/LMjzit/JFr5thzBzXeoHn31Q/xsdUPy3x76rcTK9eJQuT2zz+s0fv/SYtex6AW3etl8N/eZZe6FRY+4xx76tfv5zLvcA3+iuSD2P0SL+EMDEVPowW7YxEPcYcce4vZ78+5ujwmburETd3FvGrGJm7DLdm48v3w5G/+stZhQPf6Wujs//zb3jm8tQOej/j/STfzKr1zHOW918psuey0+wSRXyMpoLlg43z39SpeOP4PaaW6aP989t2aZe2b2A+6+O2a6a25e5JaFQCSaYBkowTT+jnBj9z/WHXfYAW7ffXZw4weNdtvt+SY3iufM0B/I/5DN3Xa7be3oHcTZR+Kn+lB+H314nlv6yrNuwdx57vEHfuVuoLlpLs0F+f6PinNMmf+Y79E0Nx37QXfMO9/qJm+5jcxNk7aUuSmLP1Wh5/nn+XyB+xPlbMgrT7qHH3+e5oFH3WMP3ulujnMTVytvfyQr+tM6EzJouzCXv/uAvdxbaW4ateUkN4kezxPK89cm27hdJo7r+f7LL3NPz3nS0VIo5Ec80zflf9CgV90rf5rv5j//qhu+6kn36BNPuj/Nvtf96hd3h76supxYJvjTav5/1zvdfnvt4CZuu6PbiRt05LZu553GumFrqT+JsZgG9j9S+vowOd8SbJuvnudfCmn1iOz7+vtFd+fn3uIOOX9Rnqv2w92MR3/izts5rJyDbEOa/zgD/RO/5JK/kf+2Nm6f1P68LpHjjHu1ZJr1B8o/2xaHDKOX4PrP0z+3B2cd63/6UY4Tg8xI08TvIMhw4YRvTh/L1nn8E5uN7e/nup9+/DD3we8/6dayu+CVvye4yWfRHvof3+kmoLCYCt/of8IKlSU0KjKp859owEQQZTELR7TMdzBJX7XxP+luP/to94Gv/cG9EGssrnkP/TN37+ffSnuD5Imt9s5/3EN/kvbQsbDMmWRl80+4q+Z/z50yitb5WrdQ2eQluK7zP8/94ISp7iP/vTxkAPUKe+jH/tkdOxy1JEkwSV/qg7XTh57XF+aGhWHikP3HoEFdtIee755YtsItW/R72kPf5H5Ie+ineW5h01IlM/8ntsjHue2OPNEdc9BUN5X20KOH0h560mZuWBft06ls2OuM3NLtvAPtq1uuf2jOfZzWKWF/GgJxgwfTHnHeQrdk9TK3ZPZ97rd3znT/RXtonJZH/aSaqGyMl8i2Qdu7Nx93Au2hp9CecLQbNpr2iFvH+9P5HALpDNpsB9qj0R46xCnBivdV7oXHH6Y9NO3hX37WLZrb4Rb97lfu+pv+4OaviHux6FJAJJBuIkP8o3d3U4/5gDvm8H3dHuNpnt91JzdJ99CszOXoU/GvktgEUjejTGhcp7zc5QavjHtoWqfMeYjWKbNoD71oleSfLcTqCTBE8B3PPwymdcoHT3DvPnBvN3XiWDeG9tCTeA9N6oOo7fzIbagdqW1jjaQuwUDYQ3fQHjoEQv2vjfaydOWee+yZl13ns7PdQ7/9hbuB9tB/7NH5h03cFkdOc3//UfrNYsuJbreth7v2LlpvhCC4rjw+0ohpwgiyuP4cMniFW/zIk+4lWrs9+sjDbvaDd7k7aQ89n/bQLePn80HH/o37B95D77OFwypGMl+X/5SBgLFKyDV7qX7W9/iXzjVI+3fRmq3340/smlmb21yYODew+E3NArq+87/Rf56BLP9ExKsY9JoGoeuubAjK9V+srkUyoqpfEYeCUlpRIauFM85Sf8/Zu/vBMm1wt4//YRrhUSbQg474nn/M2GPUkBte/M+kR6kNOpzqnsVcQ6y+wf/tljFmGfkkDzF+x08IMO+jH+j4O288ydMeVfOPdtD2mfgFP2uNiSM0hrSIokIaJULj3dQ0rFN8FG+Ij6/6JJxeGfAQtLlsXfkor4iDrhRQlJGOeJd6mONSftn/sOLxOaweyrKPjGBG/klivgt/37yttC/nbZZbqFKwyU9nGB1sHOHPrX0KQ031QsXDl8QQjHVS3eSVAZznkOOQd8bpCQ/hbvhUD/gPnIxIOsAqYmbE7CnaeYP/O/Tpin9u/0n+xFnpCQGZzYyA1wQrYnUaa1FRoIeBz4x9mnJQ2/9sn64pn7wX+efXYIwyx4q2f/7OSFu+Ds9cZkRVuyJmRpn/wKuWbeJkNjOiWqIiDr7Cl+l/1XKtOJnNjKiWqoiD6/D1hvEfxtowPqa+hUxssPF3/sZf+C55HLnMFWPDI97sNfyIoYRZTBlRahbHH4tD04evhApZLVxyuhbRu/N24J8rZRx3I/1Wn7rRP93waFe4y8w3+e/6g//e4SPDPJePv84POfm/6SH86cMm1GZGJB1gXS9f408bb8Yxrjv1lSEn/8gvYaVuysOOwCX0Przycbdxriz6n87/Oo9wzgpd0JpPqVsZvzv42362qUhWZSXu8xcdNCytQ6xNwnUcZz7q2lP/rOo2VO8AAEAASURBVBfKxPWHsU0Xcnm9YdTU0fv7pT5Rt9/8j57ur6H3F3HY4aPxg5HDijgUlNJd/gF/0YGUMxNPdf6P7dYQf6VNNbdcLv2H+LkdM/9U11DBVuuPfvSP9tY6pnWe1pVklf7Xov1D/IO28TuddI6/+K7F5ik/0g4hPNsktfFbhe7xzGZGVMtWxL3wzznRfhvbnz1kNjOif/1XrQknc5kR1RIVMTPi0aNoQKplmziZzYyolqiIg6/wJbWoKFRtgMN9zfZNbp+8MaCZYMX8OviH1cxmRkAjwYq4wb/sZehY78vxx+MMjmlAM/Y42sPoK74a/KcaJ2zt7C/6/cO1+XH8H3KkP++xcC9e7EGkWwkwlWdMxPf5b/PcNFDjT138o6f5a+M8EUJGtQIR50rUx+ZqXfLPPuWtSfBWTU/wLzVSVEgtI4jMn+X4U/b/Sk5r29+MYzZXNn46p2DXGEVlMpKr24WnvcEG/ALanBKucTT5h/665D/Yzl/xF+pqa69Jl75ZbSCrXI9nNjOiqh/EXbf5r+w1pNr/d5vhf8nnhkKdqmWbOJnLjKiWqIiDr/AlbisKVRslJyuSEaUmjn/DD6751/+4rontbjS6RTOXGVEtWhFH/6ypaECqZZs4mc2MqJaoiIOv8LVB+S/Xf9VIEieLKSOSDrCKOIQevtY9ftpDX/TOuIcO4w7toT+fP11vQP1zkBUHiFxgRbx2oZ85bfv4xDpef8c9tKQkL9xAZTYtwXvoI2gPjbHUwKG03w176OBHnCkqZIM3Yr9Mr/qcwHXN11+8h36Oy7YoXxHTO+VnTduicvxrndd5/Odxpfrfhvkt1FUqrKiQFAjNuQcPy9aYOm+F/pXHL37iHirIzTqsqIPaYT5049wZ9tC12b+f1k38qui4/iry32f/Y07TtVF3/beuWpwuTVlX3EMjJsBexJ+1F5W3axzNW7BL+ac9NP/2kfyD4N8X6Bz+QPuPbZbqvO7tH2y1b+MnnSh7aFq2tvzk+Uf89UUyXVYJiZPsKSpkvYEaLqtrkYyoKiNPaMf17b9SvVBxqb2iQlYr38BhdS2SEdUCFXEoKKUVFbJauIHD6lokI6oFKuJQUEorKmS1cAOH1bVIRlQLVMShoJRWVMhq4QYOq2uRjKgWqIhDQSnNd3cUH8thPNI50DLCbhBCi8T5I0+ifsEVdciYYjzSORBV+l775Hf9iXhMbzHg6kA46FD/hYdf1jJqsx/8S7UaKgePJO55/K/6F645iq7p5gl8lN/1mw/IO30bXAj7EX/Fe/PHJ4ZBRyeCCX7/y+ehNgSjsaJWogAZU4xHOgeiqlIrXO0XX36IvMpB/cuELwMg3XB19L/7hcFCnhUxGm1FeeafNtynjeEFCOem+OfFjS0qxtRk7gmKOVeVUbYjvjLA+moT/+GVAaQnlqI9mEV5QOLnnqDIj53Cj+7FJOp2jK8MyG2jpDGtteDK6Ek0fqw/Lgggfr3/nCs24cG8MqASfzrBINqxDIqicoDEzz1BMefm/v9IfbpmIR/zz+9DO+Cy+RwyfaI9mBVD6Zv4uSco5lwpABlTjPM/9enL0Kfr+9+g913hF9qiXBwf4ueeoEhcnESiuPJjFq8MiLo5gOVQO6kjsWBWpREhfqP/UjczwgZzx6ULoXOdOpMb/dvMAc+zInmDjCnGI50DUVVpVVj2JZ4L0yfqk21gVRlzWJrbLvWFznWSrYiROPcEKzmXtbuW3uDPPXhUHN8H+eEH/L2/soPeh9jgQtgNQlSExLmnqF9wRR2yUBuuUca2Uu/pcfM/P92/YwzmopF+wslX+ofKX4OpUJ/8L/5nf/QQ2I4wjH8y9qGGZR2lwua78L/mnml+N+oP2TxKr2Xg8VRtheIcLf9XgPACm05mnIaTGWVdDW398brA0jy/1Ix/lTk+6oV6x5MZUru8jlo5+wO89dcf/u2cWOC8Nsg2sFQ9af94QUB/+x8tJzPQVCn+iKl/SGK+il4pUvwwZNrOxqfzb4M80zU6TfnHSSlUTYNotf4wdq2/Euc8g9fkX+XV+VfLQodhy/jH+vH7HedP/ccf+v+3aIVGwkifjv9gIbZVDopsNQih1Y/+6+Ivxwi4VdiP/mOk1jTh6y/+Dc1/XR/V5AB5neYfr+nKYmx5/JnjPRyrhq4c//yKL/khH2kSaFuY8UgreND/K1+kF8eE9mOu8AvwCEhb1BolfvX4x4ntWMfezn92TGrCy/EvXhCgMWW1opPYLS6eQ7x1x7/Kynqwf/ZJj5mtxs8JyrmSMptExiMdwP3+woOH5+uW0qely/ghYz795+ufmvH/4AvpggDrX2sjVdXaRZ1V9CPR6LzPaW6sv576R30t7FP/55sD6p7129v8dxN/TIMmBwjxc0/EeOp8f4xd24b+3+43nTbL8wsy5cMGo9EcQCFKG4TQInHFf5DlXFGPtqJ8ffoPfYX7Rmxv8Z3HZmvHVRQ615E4zDeJ80hhJedKCciYYjzSORBVlTYIoUXi3FPUL7iiDhlTjEc6B6Kq0gYhtEjcF/9oB0A2Fz3BcqQHxn9f4+9a+hM/g/fQoS/RO7f3/5z//tx0VKUo8qxIUDZCxvPYrJT1hc51xI75JnHuCVaYS4+b5z302PiagLZNzB6a9XLbKAnrQuc6kAW4mMYZfnRPZfyd4A+8bB6smyLWA+O5bUjX3DPd72bH5YCnfbkxGEw0x8+afEFAvKjeHP/odxns0/hfFz/NfzS/6U10WmFEyAzGi/1gf/q3+Qvjv9ST45Xz6+w/1kfBA/FCyjROZvnJbBqdSvsX8/+Y6eGCAPXH4Qff6lg5AYlfIs11+CKKcLGnbcvu/BfxN8dUc/45rFNidW3l6FL0/Ka+mA+ul60P52xd/NucW7xP8Y+Je+gf+JsXLacWyHMbKY2yPv8qFoSU1E7gwErOVWUtznpRNweZRqmjQiBU1noK47LJP9QERkeBYDx3bKWsInSuE4raLxJb/yhVcqWI9cB4bttKWV/oXEfsmG8Sb/RvMwc8z4pkDDKmGI90DkRVpQ1CaJE49xT1Cy6r0xMx+cpUOXLDloh2SeWHV6g17FKtkc7KM8EfNSjS8J0pihp/N7CjwkrXceE73OQz7nOrUxHF2A098NONO+0GN+/So9w4NsaffvMv5lp9Z/Xvzr/7o/uPY/Zzf3njS66t/S/cFx6c5b62x/BU3VpHL7kHv/I2t/e5j1akEv+mbpdv/sY99vkpci0Xaw1Y/CvdH7+xn9vjHx4KdRH/qVptbqTb/kt3uPnn7hMf/SLZCd9ZolIZZa+hVwZscZK7dHmShThIga52dA/d8Rm3pxEB1fLMYII/PYl/7nnukF2/7O7kRyrFMuHpN4TTgsUtp1cGDGV+N59m//zKgAPolQG/UwspX5PciTPpNQ9HydUuWl3VrEdWz6LXNdCj7Zc7eqx/x8/o0XvyAkot3+P4V7v5VLdJn6W6VeJPtutrkXOb42c9kYbvTPFl6tNvdXvPeKzGP5czfZrJFp/MLBP8yRLS3fi3yj32zbdRn57Nqcg/ocFGuh2+fLub93+m6uOMrFJL/6uvpddgfEj7dDAXCre54afNCq+l4D6m1bWGe4i39N+Y/2Q8K5/YPcay8kzwRwMSafjOFEWNvxvYSaEbLCvPBH/e4P7xCKrUn/gwouBfB/H753/qznv/qe4rd9Lj+Pgxe1sf6U7/t4vdP793R3osWu8/A9L+/il3zwUfdad84VY3Lzy9eKQb/+FL3a1XnOomD9POFSrbN//evXjt+9y2/+smR5cySncls2H8aX+3m/FHeqzqLj3LRu5/lZt74SFu98/e5/jpg+lzgDvjgVvc+ftsklgRy8pXpEvcTdP2dO/9lyVynG61p9t9C7qenR4lxx/OhDxILpBh/RGiCYtN5on18E1f3NyMS0lhcL8dTI9QHLpiobufHrcXPjTfP0zz/R5CNXw/4L5z8IHuM7/uJHm7GzZxL7fzJp1kn5z00j8/5J4rF/Kv3oQ3ZPBat+ZP89wjz8grDXhtsIzWBmgdjofz4BzV5yCqz294pcpcfMa6Labs4ia8+nJj/COGrXTL6DGN8+jxetmHDY+a5q5bcok7oWExkvyTLopLhSLDzn8PuG9Tzv7216upzoPc0B32djttsoowKtgQfxCxpcwRMegzcsRy98Tv6fHIsbOxW+nNsSIHX+hm3/G3oR3z/Uer9UcwLV9iMOQXoRlphV/xb5UJj+YCxlkJ4w8Fxnz+Su0/wo3ejfrTpJ3dHrvv6fadur874NC3ube/ybwqgsvQJ0sLKhkMJmnQyRRD0fDVwE4K3WBZeSb400f/mFfEiNgJW0hlVJH+9F+13j3njey/bRB3SttvuY+ikSU3r9f419BeZov3/cgtrxx/MpZPGsmvLzHxZ4HSE/KH5OMyZ4O7vRzN9GjyubQ/mjQkcEPRojzr8ydne7fqdzPc+9/7dff/Vh3qzph1rTt//3Gi2PCdlWeCP20YZ2VuGhrnpqb5r6/j75i1T7p7Hlse5mD6cd5d92ycJyrHv8xNf/cbnh9DBSlXPP6Nc1tM3tltuZaeKdsw/g8busotn7vAzaNH9pafNvL5XzQ3nYS5CSoV/2SeZcpPlhI7z9mwiVPcpE1pLiWF0K5JUQszv2n9sQnNTYtpbgqPYY4lgp2A0xqG5iY+p8BrjJpqxRIGrJZXGqbzE2PdBJrXN19L83pU4xj7e/1Rxj+qfYn740NL6BxAzIs5F8C64YMKBYad/6PcgJq0Gmn3aFY++Ke17XW0tv3QLPdyVnxrd+hV99DrPbfLuFn5TNIzIisf/FO51zT+ev/8KGGullSR2iQ+oj6rf89CzrSy8htw/N0f/1lYPSb6Gn94tHMYkGXGoNPoPfZpFfvqHzay8mB2A2UPfQrtoVfIEb7NUW4a7aHPPyruoTeI/v+Uu/v8j7pTP0976LA/GOm2PPlSd8u/53vovsQv6elyy6492m1D4ww/NJ0/cnzRdzudwwyvJpGza8FHg6Mqm/fQB7vd6XWq4fWGpCB2aQ/9O9pDvyXfQ2flmeBPlv/n3Ky4hw7ssIem11XQ4/1lzqVXznArNsy/QUQmQ/dUu8FLcIP5bxBdczFs2QJ3/xO85iB7h1zkZt/+N3TOvNX4/zt30cEUF++h29rd0O33cpNGcnn+SJ166p9LNM1/g3mt9vQ89+izr7I5Or9Or0u9lF6XKl5SumgPLfvTWAdJPMlpDz15Fze+K59RWIz4hw2jdUoHrVNoKYNRlrHwoXXKtbQ2OhGbdvAJcn2KtBppHZrq2EbnHYbw2i7mrCn+4COlM3oUxojh9CoiXqdQIJUhiCt2UNO5kE46h3+gm0SvJMZH0iXf4FmYJDwXtdr/xlKxQCpnrUneODZ8RA/avIeeQq862sW9+c20h95nf3fgO2kPvU2+hw65gYE+wKw8KsNVCB+Rhu9MEfK+tH8qy1hmloi2QfHVQFGN92vr039w+xrGv9E/ZWADzT9dEBCHmKzXxp4KwCphYUSdmwLRWCBvAZNZ7vSy4K1VT4pVcXf+O3/pvvqO97lz7g1vCZIKsj39UI0HH+HOfeQG96Vd4rvJVBaRdfFf2jJ0Mtuz+LvmnOcOm/wld/saej/MX1zk/vCLz7jJPIt0k/9X7/20m7zfxe4x9s0NVMQ/7FMz3Yv/cqS809jUT9FUUWUp0l3+VZER+oFg+p7uqEuXGG6sUAD7uun3/Mpd/PZNjZzQnvjvvM5Nm3CS+5dwQUAR5MHfphPLvLjJP8lsz/KflaYLAt6xy5fcHRlTCF6wLKMFS836IdNu7Z8vCDjQ7UITNuvln53ogoD7wgUBYRXQTfujLF8QsMX76F33Xn60n0EXBHCmOMG9O/5a1Y1t30gXG/DJtNaf1vGbsklRma/ee7qbst8l7lHlWKSNFo2zsh9erBR4Mtvb+GGBoH+W+vRkdxT96JU+tv9xn76N+vTIJI5Yt/7pJNLp409yl9iLXGJZveikV8dfXoVu/UM9KYKT4Eb/3Y6/KVk5ltK6Lv2PrPTw+If3/Icb6at8QkPGAmgZmCpqmBF9Ddrfr7jH/cenjnd//Z+LXfiZld5FPvUz/+T+9UvHuX1HtVfr2MBJYfVX/j1tXGe5S07/a/e5Hy+OP6pv6Saf/V/0jsZD6W2N+afv/pe7e8+Z6vb/6rzq3DDxC+6mud9w7xmc+6qjqv7nuR8eP9Wd8j9pwAm9Y3uyOZ9s1qW2Zft3uc7OLjdsWH1lqv7rakm8pFhVqPHvO1e7NcOGdnNB3hq3qrPdDQ/vzu2v9pflVbWS4Hi3evUaN2SozLspLPa/2q1Y3uZGj8avIyhDMCkaZkRr4k9KZPW5pW7V5lvQe5oTF1gy29P411B70g9u9n3DLf3DUz1s7f9V99KSFW7oeHpPc1KMhiguetfh3KdX0vKHhJXxT8a05JVoOdsiDcT26CNmWZffrUz7j8gPwvgVLDE/36cHqchIGPzT+8i32cHtvFl3q75kXfwz3dP8p7KK1cav0pZIf/sPP0AHjyEzAcMWsq4i/e1/g9x/1gUeeQMdf5rn69tjoP23CD2I1sW/f2m5e3nkaLr0l6xUjv/uPIu80f/qFfSD6ab0bl3OG32SotD2u+74W/0SlR+Zylt9gyez5fFfjLNJ0ZSOaJ3/qlYtJ5kl/2tWu9WDh7niekUp5zvd8pdobhpVNzeRlT7l37vO555znZuPp7mpjL+obqpoISBS46f5fDXm86paHSeZ7a1/Ozf1NP6XKYfD3ehN0yKq7/5NNBo/pYK6a+yxRqEZDf5DX93EjRrK70Rv+KSKVhXW1X+waPP/grvzzH3cId9aFCRcJ3bvmi507Xf/wW3+tV7jz10HivynuVXkOq/+mcTf2Dlfo/h5btW+SU3CFz726fiLDdy782/SB6Qodw6qCYHe+Oc99BVhD/0U7VOp8GDZQ//bece5qeUemsTrL/+0tuc99PS/cp+7/qnwg613tIc+5z/drV8+zE3gpNtPn9uf99D7uP2+uoCsUYC2Mcs9dK/i5z30vrSHXmZqScYnfr6yL09m7fhnigWU9tCraA89vH4Pnea/3rU/m27l33d20h56mOyhk2JROVqnrBpEdaM5jXR60/+68585yvxT/+ikPTTt70NXyNq/s3kPnRkUIpltlX/yt4T20ONpD11jo/f5T2u7nvknp0mxWoMs/vIwlXXKENpDV3eltP4Ke2i+iaI/9r+2/e3BxFUmukf778Fu+NY7uEnlHrrP8VfTZTnJbKv2pxJJ0RYXvGX+q+qWk8wm/2nPBvOklRRtcShQbim/rMZprmo0cpLZ5L9WOSlWxf0cf9UBcTb6b27Y9Zl/PDyAFp/5JzwGr1FKa6MWHxbiv1YtliYQsapWr/yv9Svu+hv/dn40kHStCMPpP8L5MStD/JiTr/GLgsP+9l9Un83jvxAJ2eR/sb/pU9vwMU913s4fdtX8xvxEC8n6q7f4c3ce3Bz/2//J36+Fmvwnc75X+bflbvdfmcLvhuMYbP5j2+x2rv/l2j76j49Xl/wUbW0fPcvm8W+qltAe+u9IrwywPhkfSo8Ftg/hS7aN7+gmkwUC/lf5Dn7HD/IkF2rG9scrA6qlmdNk2r4y4Lw5xcsb1RT8N9vxXSvpcUP7aH/K46dHEHZkD0VWywFh8/jPJZHqiX/SefXn/txdpE/n/mPbZ33aOILv6MZIeucfWe663f9jeN+h+LV1Cf2c+/Srxktv/Ic+HY+TrP3xygBj16CNobFOb/wbmxna1+N/o/8NIv91429q39h7CDT2ow2h/Tvn+lu/9hd+J3pnrxxz7X7Y5I/4s3/2qH+hseIUJcvwn4I2WCxMIGJGFtG6+Dvn+9u/80G/H722RtcZYw/wJ/3Xo36ltQDfzcZFu6X/Dv+D4/DqBMQv4w+/+3CJ9Vfirfy/fA29+7CYO2n+Ce8+tHbq4jfyxtBYp5X/YCOWJtBoZ6P/mMiQsMpXY95Yk4X4r5SEgug02tmY/5jE2gQ291uk9w2afx73yvVPJUOIvblzSRGSN6vASMV6YDSWYymKNipFAYFmFZY0SltI1q9/nYfCfkvG9T+n+Lm5Kx80XWPzRQGBZhWWNEpbSGKxlsWjXQKNHjaOvxvz39w7WkheD/3vNv8Vs5/W8x+7m330n2H/pzP9YV+B+bXF6PA6b//Xx/hn51ZuE/tpHLdZiYX4t4UUX4/xd86jPfShfhLtoSUe2kNPOdWfRXvoF9e26GEDdfzxHvq7H/Bv73YP3TKBPez/82gPPZriLh6zTsdZ2O+Si9gS2jKKtIqf9tCnjTfnAOLaa8iHf+SfYwOoerNxcdNX/9GFGKn53ug/tUFNerTVN+a/b/1/Y/9rzhv3t26OP8zzmF/quyiM1ErXyf/G/s+5pc/G47/Sj2iVE5MTExQSZb6MVDJo9XJhpRTEgKqQMQxhUOjmrEiBCRiUn/cPfHlKeHc9XUyjJ+yxuA4HX/tb/Ik3LpbfuuFgA4p/7aMz/Dvie9Xa9jrP/7Izf/ODthXiBgyxvOQf/sZenq/jq41/xIf8xc/SCpA/WTlDGFQUC1UUhB4glBk+e7E/cZOG/Lsxftdv/s7jegApZowYFCYzVuc1fjrfamBOfiluLwiI9URZQNhEGN36nzvDH1T4iveYyTuOKobhQQQQA0Ka/NM7fi5MP7prLMHnJH/SrOeTaigcLcEgoDH88vXv96NC/08/2teoaYmshTPFTj/vQr5YIbUl4xL/EX4GXxCQ6RuTUQAxoGpkDEMYVHRf8rNjn0Y9kP9AD+c+bX+JhwcxBHOAkOb1NlKDQjewqE8fP0LykPkPuRktfRoFAhRDMAeoKpaxmn6gs++d1Hy3+eHTbsp/aETFUR5QDQMRAcSAkMKM0EZqUOjmrEiBCQhlhSKAGLAQR9JIDQrdnBUpMAGhrFAEEAMW4kgaqUGhm7MiBSYglBWKAGLAQhxJIzUodHNWpMAEhLJCfg0Q+ms6fo1Y0ewgrrGXsyIFJqCxJqgIIAZUtYxhCINCl98xuPjnn/dHT5SLzOT4G+e3ff85/uLfPNlwUZYYgjlA2Ox1/+9a6uf87Cx/yp78/lrMP/Ruxn3/xl/80Au5ueCkP/zTu/IOHqbtmNpzjN/jgocllEpgiLDZv7z7kGLI3hkX331YYy9nRQpMQLhVKAKIAQtxJI3UoNDNWZECExDKCkUAMWAhjqSRGhS6OStSYAJCWaEIIAYsxJE0UoNCN2dFCkxAKCsUAcSAhTiSRmpQ6OasSIEJCGWFIoAYsBBH0kgNCt2cFSkwAaGsUAQQAxbiSBqpQaGbsyIFJiCUFYoAYsBCHEkjNSh0c1akwASEskIRQAxYiCNppAaFbs7qMuNfzbyCQnFERFnAQtwn/6EQDAKqYSAigBgQ0nzANlKDQjdnRQpMQCgrFAHEgIU4kkZqUOjmrEiBSRDzgoWY040azAmEIFCGMCgK5KxIgQkIZYUigBiwEEfSSA0K3ZwVKTABoaxQBBADFuJIGqlBoZuzIgUmIJQVigBiwEIcSSM1KHRzVqTABISyQhFADFiII2mkBoVuzooUmIBQVigCiAELcSSN1KDQzVmRAhMQygpFADFgIY6kkRoUujkrUmACQlmhCCAGLMSRNFKDQjdnRQpMQCgrFAHEgIU4kkZqUOjmrEiBCQhlhSKAGFDFT17gjx4a19F6rq7db/qpm7x90znr52UjBSagGgYiAogBIc2NGqlBoZuzIgUmIJQVigBiwEIcySS1Yzj/iMmfJDUUmIBB036JAGJA1cgYhjAodHNWpMAEhLJCEUAMWIgjaaQGhW7OihSYgFBWKAKIAQtxJI3UoCy051G5bbQ1oAcYLSUgAogBVZ4xDGFQ6OasSIEJCGWFIoCY99BP0R76mInhOVy0ZuD932ayh77b7KFRQO1oxJETFaAHaPQFFQHEAYY99Nm0hx4R/fPxT3vot3067aFRwNjLWZECE9Do5/7vK943H8ccOg+9x0WPxFLGiEFhMmcJtebu6X43PU+HdXDcQ4eCooeygLCZH9RGalDo5qxIgQkIZYUigBiwEEfSSA0K3ZwVKTABoaxQBBADFuJIGqlBoZuzIgUmIJQVigBiwEIcSSM1KHRzVqTABISyQhFADFiII2mkBoVuzooUmIBQVigCiAELcSSN1KDQzVmRAhMQygpFADFgIY6kkRoUujkrUmACQlmhCCAGLMSRNFKDQjdnRQpMQCgrFAHEgBDL+JvWP+Dn44Jw87KRAhNQDQARAcSAkOZ+jNSg0M1ZkQITEMoKRQAxYCGOpJEaFLo5K1JgAkJZoQggBizEkTRSg0I3Z0UKTEAoKxQBxICFOJJGalDo5qxIgQkIZYUigBiwEEfSSAl1SgIB1NJVRFSaFauSkpNoxYAAVt0qR1RqFDt/6y993zg5ScIbDd1sYNKmHzR3/Yy/Zkm6c1qtAAFUb1VEVJoVq5KSk2jFXn3QX3FMrLvb3h925YKq48iRMlpS9boWf9efOC4NNHn8u/oTZ+K+wlRWMSCAarWKiEqd4lr/wjVHeXqDkuS+zP+4k/3FT3LuU1nFgABW3XofnxCgGyeyrz/QmAsCqiZKTqIVAwLI/jv4goDi6tK4EKTH1Tf8GGWjQxDWKPNA0xMCzt9X+itypgvNrekJEY/DQAalNGxYEV1gEJ44wPmnH+3n4i7+UjfRigEBpOjmxacXZBfVhPrxBQGNz0fQ6FLN1GhkJVoxIIDQXHyxPwl9WnMTj+e2Xf1JM5cmNyjTLSc5UQwIoNro8i9e815PLwNI7QSc+9/YU/zFi9N4wsUqJiqcpNHVeV26IKA4XoY3PIVCSicbWtWIVCUlJ9GKAQEsjRpaVJoVq5KSk2jFgAAafyUqKs2KVUnJSbRiQABLp4YWlWbFqqTkJFoxIIDGX4mKSrMiS8LYX/SnZCeVVQwIYFKuYKLSrFiVlJxEKwYEsPDatfR2f/npe/tt9E4HHuPG+e2O+js/40f3+yfo4jl8EtbESRqKAQHkossf8rf+6+n+f+09Jlxop/PO6L39YV++0c8xPuGJoTUh/JKTaMWAAPr748mMcv7Z3Z9y64u1XsRXK/8rw3wjD//DeMbrhQP8GQ+8XF9VGDVQqqgVNZImE6VuohUDAlixmhii0qxYlZScRCsGBDC5q2Ci0qxYlZScRCsGBLDiNTFEpVmxKik5iVYMCGByV8FEpVmxKik5iVYMCGDFa2KISrNiVVJyEq0YEMDkroKJSrNiVVJyEq0YEMCK18QQlWbFqqTkJFoxIIDJXYbpGMhroLj+zhSIqJooOYlWDAhgadTQotKsWJWUnEQrBgTQ+CtRUWlWrEpKTqIVAwJYOjW0qMi37n+wJiVYNVFyEq0YEEDjr0RFpVmxKik5iVYMCGDp1NCi0qxYlZScRCsGBND4K1FRaVasSkpOohUDAlg6NbSoNCtWJSUn0YoBATT+SlRUmhWrkpKTaMWAAJZODS0qzYpVSclJtGJAAI2/EhWVZsWqpOQkWjEggKVTQ4tKs2JVUnISrRgQQOOvREWlWbEqsRw+R3Sk2U/jR7qt/aFX0/kOq1o6jrSoNCtWJSUn0YoBAWzwzWxRaVasSkpOohUjJD9fl9+RbqsjZbSkFQW8Kik5iVYMCGDFamKISrNiVVJyEq0YEMDkroKJSrNiVVJyEq0YEEDyKue90v4LFREVowhBhFVJyUm0YkAAC5uWFJVmxaokllh6W3UP7ejCgKP+1s+4jvbQq0mvWti6Dni0VuGDYU10hT30NP+h2j30TP8YTiOiECCM1cCe+7/fX3RQ9aJ653bzp4Y9tAkXfgFr/AprpZ9zwb5yPiCuf2VNTHvo38keumqi5CRaMSCAjf5R52bFqqTkJFoxIIAb/TdmQFLUnKiqpOQkWjEggI3eN7a/pKg5UVVJyUm0YkAABzD/2R46Xvin4+568I8exCGqOyCAAxi/8brRP/KMvAOCXwNFpVmxKik5iVYsIjWrTqgwNLhBUUewhAYFCK0cqjQgShkl8Bga3KBQBktoobqWXO2nT8Ij63HS28KRfstTf+jnhBuLcwvWjviGnKBBW/lPitDKIcyIPVAr/cLLD/Pj6GROmxvkhx9xiX8o3EYPOUGDwiJYQjO11N9z9q75jxd6oqjdj/zLn8gjjbhAKJxbSHagADlBg4peYqVyT/iffGyL6g+noQ6b+oln3+njzw59888XBIzCiUi0KW0o+Yevgy/0s0NFUFHUMocqDYhSRgk8gh3plQHZIE7++Mfa7DHRdQkyVoHCuqjzY/npLnyuf2yn9OP7KL/HhRJRSBYKApJBg0aKLwjAEwfiXfxwHKGWCYhSRgu8/JUBqF+AdLHBefSEAGhKYVCAxqRBVRoQpWo0WMb/NX06LMQ5Z9Kn5ZIA2AI0Jg2q0oAoVaPBMv6v6dPqX/r0K6E0bAEakwZVaUDoi/v0mLr2t68MID0UBCSbBjVUzjWuA6rSgChl1MBjaHCDQhksoUEBQiuHKg2IUkYJPIYGNyiUwRIaFCC0cqjSgChllMBjaHCDQhksoUEBQiuHKg2IUkYJPIYGNyiUwRIalMDseI1jC+tBSxClYNJosAxyggaFMlhCgwKEVg5VGhCljBJ4DA0e0Ff8n35ziT/7AxP9GJ3XZPxv2+pt/tDTvu4vvvl3ftGKuqeGiAtYrI+/y69e+pC/60df92edso+fxHON+iG8fXs/+ZPf8dcvrNv4wzKgCcmgKg2IUjUa99HJDNzRYeuRLvTKS4MCNCYVneevpkcolne+uB2+4G9aAyWUZ2hwg5aaQtcoQNFAaNXnnxWhwdDgBoU5sIQGBQitHKo0IEoZJfAYGtygUAZLaFCA0MqhSgOilFECj6HBDQplsIQGBQitHKo0IEoZJfAYGtygUAZLaFCA0MqhSgOilFECj6HBDQplsIQGBQitHKo0IEoZJfAYGtygUAZLaFCA0MqhSgOilFECj6HBDQplsIQGBQitHKo0IEoZJfAYGjyisv7jfQrGJLmTMdM11koUFsW0UkYNPIYGNyiUwRIaFCC0cqjSgChllMBjaHCDQhksoUEBQiuHKg2IUkYJPIYGNyiUmSV3m6AtBEJeB2FmY/45O5oNkyrwGBrcoFAGS2hQgNDKoUoDopRRAo+hwQ0KZbCEBgUIrRyqNCBKGSXwGBrcoFAGS2hQgNDKoUoDopRRAo+hwQ0KZbCEBgUIrRyqNCBKGSXwGBrcoFAGS2hQgNDKoUoDopRRAo+hwQ0KZbCEBgUIrRyqNCBKGSXwGBrcoFAGS2hQgNDKYRft5+88c2K+rubzH+3v9jPm8K+DKM/Q4AaFRbCEBgUIrRyqNCBKGSXwGBrcoFAGS2hQgNDKoUoDolRQ4rk1zavmjnSuB1QBqYRBDZVzc++mTFCr0wWPocENCptgCQ0KEFo5VGlAlDJK4DE0uEGhDJbQoAChlUOVBkQpowReesoe9oBBCWIiDGqonGsM58WDWp0ueAwNblDYBEtoUIDQyiE/LeCZuy72Zx870dP70uU4jOcf27Z6uz/stK/RHvr3tIfmDSFsETQoLIIlNKi1vnPp7LiHnkp7aFzwE33RHnrKX3/bX7+A99AoA4sMwWNocINCGyyhQQEyt/6CgDa+WWoO3yxldcVK4rEMcoKK0msIjqc9NHIXnrZAsU38fNxDQxH2cqjSgChllMBjaHCDQhksoUEBQiuHKg2IUkYJPIYGNyiUwRIaFCC0cqjSgChllMBjaHCDQhksoUEBQiuHKg2IUkYJPIYGNyiUwRIaFCC0cqjSgChllMBjaHCDQhksoUEBQiuHKg2IUkYJPIYGNyiUwRIaFCC0cqjSgChllMBjaHCDQhksoUEBQiuHKg2IUkYJPIYGNyiUwRIaFCC0csjS8vxbVYM5rAlbBA0KfbCEBgUIrRyqNCBKGSXwGBrcoFAGS2hQgNDKoUr/P3vfAW9ZUaRfbx4wxBlRQVGCKDBIWBQUJOlgQlz8y4qYCOuCq4iBoKuLq4ALZkUMgLq6ugoGQCWIwqogKlFBV4LkoDKjZAYJMzDv/Lu6+quu6nPOnTeP92bevOkzvzn1VdXXXaerwwn3vnMjUM2QYGNpsIEgwyQ6NEiwvFRvBKoZEmwsDTYQZJhEhwYJlpfqjUA1Q4KNpcEGggyT6NAgwfJSvRGopqQhjsnntPBgIfzv37oZsEL68iFKeDMt19uEf+FvGeAOdD6jRj0W7S4POstuBqyQwlxww7G09+z30WlzRmIV8QjijlUGa9Pm//FdOu+Y2bR2LGrLxyKtXTcDVkhfbHTtb2jB/x1OL5/9Kbrg/nC8K72IDrn4LPrs1mu4ynoiBA4axjJsD3yfDnvuG+mzNz8qSQumyODdE/ajr17/dTrgSdMmJP/N7cfRHhsfSmc9LP0bOw3xZx1Gp1/2KXr1jGnxuMbU/wtOpYPWeh2dOC9Uqu1mHLadPkdX/erdtLlocT+6/Adq3/i/8cO088ZH0a9NnYDTDzyX7j/xZTRdjyPlH4QgRxP/odP3oKe+5gx6gBPCCYuCd6vRxp+4mK573xaDIgReKhflPXT+IVvSSz43h5o1DqBvzv0K7btayHeod/Hn33y66bgdaaNDLw/ly+1ldOQNZ9NRG60QHDa+542m/XGM9OUf1c37Ph2y9RvpczeFMa1birsmj+mv0QFP5mPx23jEb27/LL1648PimPa1h/Vsk0Poh7/5dBjTfCz832+jij//VHrHU15HJ9yf2hOFYBljLw9jLI6MrgjBk8p1eZfK+ptzMKr2x4Wte3XLNdX2d2cIVsicsaFpYVywOWwYUuFcL4YgxrT+SmmzR1xI4wpw4vr/7/TnX/43ffnYz9AXzvgTxdMBhw7XGuHjqfA9oXVovRe/iHbacnPacrNNaaN1nkYbPuuJtPJjC2naE9ejdZu5dNu9C2mlFe6nOdfcSn/927V0zR+vpCsvuZDO+80dNA9rMebW8Pq0+f6H0pHv/Rd67SYzzUxDuyHHs/1X0Od32pEOvvARX+mMt9Mpd55Ae63EZsSF9NRW/h86hQ56xhvpxDv5uiiMijgwGlpp71NpzkmvpSf54k7riSD16HG4IhPY/4iDo4KEXWSr/XAH+rI9/k1DMEbNqFRvXf+Xwv0Hsj+R6x9iYNxDwi5yIsa/3M9x/XHxiIHCjWvSo6q7iYivlUeAdkMW3uVg/A8N8fV92tL5j2/peav5XxrPH1Jf1PzX8bccrD/5PMDnA791rj/Nr+norV5MR1z5mF5/8iPCZpMj6fyrj6LZ4fVVXVvPCh+oOA+NMj5XHiqbjNd/8dwamyNt4vxhWx7aj7Z2yaXRfjm3mj4w/SHHiKOC9EfeOf6ZEuhLf/w9SH/51dfoy58+lr541m10P+55Mf6Gn0rr7zKbdt5qc9ri2bPomes8nTZ65po0fSHfQ69L69Lf6E/3LKAVhx+gOdfeQnPnXk9/vO4PdNXF4R76sjsIj7O4ubHKFdanLf7lUDrivfvTazcOX0UIRrbLrWN3/tiNrZsBKyTYIsMXAugLO+9Ih1w4P+Y7xuKoaxxI37vrBHod30PHot3lbW3KeOh76R6avWyVbcU3nUZzT97T3UNP7v5fEvmv119L/vMvjMgwOuv1x6S8/5cxkRbA0Ed998+5J9MyZQ0RY1WC9ITa/3X9Wez1Jwwa/R4C46y0vz0Q/R07MEcSgFQqCGrwwLlVUeDJHRqYiDsysqC5+4J3Ny+cKd9OxGsVwxTkmRP/D9Ezm12+dnX8K2+Uj1WroqAjojeBmeN7f85pYQ+O+dd/rnnThnijwTrNNsf+Pr2KHrWWZdo6mBJ/QXPnj97UbGJerZzbv2azxScuL/6y3XQ5V43KMmgHLCxS5O7mkg9s2sjH/TnPnO+haVs0r/5h9+vvXUin6IHkaAvCX1Ob31uX/gx9zN9wDT8ZcGUqgn7Qgh1VqS8A51YlgBuObHbi48e4Sd+k5TZND28IKF/Ij7iQGkPrVIuChb87tPkH1J8k4q20/5nNPGX2A1Q/MnJt8/VXriZjfKtjmosWpjIg9FTh3KqktxeEY8LxxDzHY/RvH0ARtBtSw4GgBg+cWxUFgbyguevsMKZXKMZVPJYnNpt/8gqZx6nI+MXntxPMasJXDSSnpv9pePNmjzCmOSSOFHEhtZUgqMGA8IaAA82YjvMlxeMxhjeqmRItiOoRF1KJIKjBA+dWRYEnd2hgIi6kUkFQgwfOrYoCT+7QwERcSKWCoAYPnFsVBZ7coYGJuJBKBUENHji3Kgo8uUMDE3FZ4jwn40nOgx1FownlveKsfUVdERvfFVhEVc6tigJXlVcebR64/qzmq0e8unnJM1YObZZ22rbb9us6FuaXxW0+z/eVmxlbvabZ91M/aC6a698F44/hcc7/UJlrqSq3NKe+UX5CSI+V15+nHNKc4X+hRMsvKv+Pmd8+1DrDVyJf8NWbc5M0voLs60FgLip+T3E9/uhHZd7aV9QVqfElTciDJk1zqhYHnFsVBY7bpYCJuJDKBUENHji3Kgo8uUMDE3EhlQqCGjxwblUUeHKHBibiQioVBDV44NyqKPDkDg1MxIVUKghq8MC5VVHgyHatlDUkfqc8chAXUgt2V9XtVq4C5fUBMBEXUvkgqMED51ZFgSd3aGAiLqRSQVCDB86tigJPLrR4ztPrUjn/Lcn4fDg4UsSF1EMFQQ0eOLcqCjy5QwMTcSGVCoIaPHBuVRR4cocGJuJCKhUENXjg3Koo8OQODUzEhVQqCGrwwLlVUeDJHRqYiAupVBDU4IFzq6LAkzs0MBEXUqkgqMED51ZFgSd3aGAiLqRSQVCDB86tigJP7tDARFxIpYKgBg+cWxUFntyhgYm4kEoFgQ23f6bZfcXy+nu4WT3c6z7AfuUqYOvADUzEhdRCIKjBA+dWRYEnd2hgIi6kUkFQgwdw49yKa3PP6tdQHnEhtQQIavDAuVVR4MkdGpiIC6lUENTggXOrosCTOzQwERdSqSCowQPnViW/IWBR/YEiiAupUUBQgwfOrYoCT+7QwERcSKWCoAYLHm3mXX9m87UP4R66nJtG1+sMeR6G67/8XLC8/14l3kPv98kfNhcOuId2h6eKAnuwnRhMtBuyaW6N99D5+Xd6jhfuoc8099AoHytXRYGL+eilBzWz0vO53P61m+3DPTTiQmrB7qq63cpVoLw+ACbiQiofBDV44NyqKPDkDg1MxIVUKghq8MC5VVHgyR0amIgLqVQQ1OCBc6uiwJM7NDARF1KpIKjBA+dWRYEnd2hgIi6kUkFQgwfOrYoCT+7QwERcSKWCoAYPnFsVBZ7coYGJuJBKBUENHji3Kgo8uUMDE3EhlQpCMsgzybQWhbXEuVVRoNX0ATARF1L5IKjBA+dWRYEnd2hgIi6kUkFQgwfOrYoCT+7QwERcSKWCoAYPnFsVBZ7coYGJuJBKBUENHji3Kgo8uUMDE3EhlQqCGjywbv4WkdvEaSm4Rk+2VjRXvEPJdUUUdtnSpovPM5xt1PHDlwJ+yV8KyBMPF9yQQ8ObNDt89JfN30w4FysdnrONOj7aliuPKOzUcvfpzfufxx9k8DGu1qy9//ebW0FC8SCFn0qNKv4dzSX/sVmzYnEBF+PM3L054qp462UiZOhiJbOzdcYfaR654j3NC8KNHsfABbRcKM5sNv63n8ccx3rCTurLMS1yscr4D36r2X81jhEuPLlttn07f6652lakOEeLKOyyRUkKxJf2Vx/ebBtjyIWutivEn/72/IUALdwJcrSIwi5bQoGHftgcst40GQND9oI64FlHNueHD/WFn0p15j8Fvu9/mv2fzL95Zm6wTbRYQ9ilmgYcLTPmh58f2CbluGx/fm11ZyXOmKNFFHbZ4ohREZ9niPa38OF8GNNxroTjsf3/hN2bI6/uG9O5rojCLlsGx3/k8vc2262Uxpsd17Rms/H7wphuF++w5Gid8fknA/CFgKL/Vzrw3PiFAKkh1TOo/zui29Z2xi/KuFjJ52w1fpGxRamp3wJtSeY/rvV2fQzjd0nGz1lZUu2/v5l7xenNNz9xUPOv/7hV8+ynrODPD3HdkPOTnG/NeSr6hpvpz9iuecE/Hdy854QfNOddf7d+GUdakNqxxMb/35vf/+ez2+vv2ge3vhCQc92FkP+5zc/etYGcZ1Iu5HyWf/uQS7u2puqcbYm1P7elxs89o0+dcnoWgdD/S3b9yQdV4yMXMRNhlzMCT5bi8wxnW8rzT9ZOf/2Vj74L5bZEFHbZ0uaLzzOcbSm3f7LNP5zL+HoY9yc+qzmXEYVdtngma+LzDGer+W8nbaAl5zKisMuWdkHxeYaz1fy3kzbQknMZUdhlS7ug+DzD2Wr+20kbaMm5HGkWNvd+d7dmVXf9ydfk6zSzvyV/MOJynep1timc//DnjOb6HD/Fg/Ga8jiF28/d7fp6Kfe/PmdMXzSPhzOl8z+vuT3eQ7+9ecvuz2k2fUr4Q7We55/u+RvP53j9Ma2ZvsG2zQ7xHvqH6R46jVv0bVCzJXWwEePb/w+Ee+hZZk6l+/+OL9XjEAbHn9v8/J3rh/r89S9RuIf+vf4YLqpKMrc2orDLloIaVPF5hrNN6fFX2+/62o2gNCZq/7cnzUBLnksRhV22tAuKzzOcbRzyj3u2rvs1F6v2f8yAy8k45N/3rh8DLtZymP941RkGaNr43BmGKW8KFXgzU/jUmEZ1vJRNRSPR7XwdzuUUw1OoIDKttuj44XX8N3yR9t/1MDr5FnlFGR8nX73INV6osnkKbfau4+mUT72GNud3cy+R9i+kv19zHB34qsPpZH61Pw3Tyjt/nM7738No+5XTKyC1oQr44HK3MA6u3vzP/z2d/C+70z9/Zw4tjKVCgdjsYZq+09H043PeT7vE18lzrdhMLIUKIslqiD9yz5n0gZe/nj5xRXi9MRN0W43WftOX6Of//SbaYrp5taX6S2BqV6iA6KYP004bHUUXhmKx3RorNCy8BuqUu8OrlMMnxu3N1NF2GovhBbjgnNfR2q88le43DMCV334O3Xv8rrRyCB1LmaLgZDnIOYfOOfD5tNuX58SRx0zdhmfT4f93Nn1083ALnTZbE/IfbeG1rfPODXne7Xv0Z1qHZn/zUjp/3/U6SqGmLmlqb+6lX7/vufTCT9/muzQW24re8stf0ld2mtE//lz1pl5nLxXDU6ggdMjv6aQ3705v/s7tNMJ5Z1fcVqCVd/ww/fjcf+8Y00wwdUiBnn3mNXefQYe/4g30yd8+UrSfx/SJdN7X96HNwjdueuefi5DrdWZW5nyWXvWMw+hHYRkITXKxpv3j1+nmH/0zbYA1KfmZx5vv/2CAI3rtbkB8S7N50iIKItNqNX5ah0JmJtv5T14VxF2WR1W4vol92L8zvatQQSxmtcnd/4/QPbfeQLfcfBPdPudmuvLGefRoSIU//8+ktTfbiNZ9+jNo4w03pGevs1rKVxDaUAVLvP2P/eYdtOV2J9C1MXLamZ8MGH3+H6bbvvdGesk+Z9DN4TLIXf+s/34658aP067xF1dMWxUqWOLtl/Wsxpc5LP1vszH6/rel7GAqseEpVFD7P2TAZmN5zD/OK/b6O9xET7rznx/Ztte8x2uGp1BBpFptMvT/NP5pIJzj06m+fZ63R+1b7DXDU6hgUrb/cV9/uwSYtipUUNsfMmCzMRnGf+3/1Ce2Y9yYZmWg07ANT6GCyLPa4vf/vXThvz2Xdvr0n+RCHIe24h507K2n0qFP498L4EUsbBpIgTczJbimUv9PC43h1mKTdXz5ab/pdAOXXvv5Z/fSKTV2CfeHPZqpNv5M0hPke+jr4z30nNtvpT/cPI/CH9bHnPC8Gwm/FDU0NJPW2nxjWu9pG9DGz9qQNn3q6pjBGMZB2qwZcwsankIFkW210eT/scveSVtsdzxdx6XDMcf7/xkH0Sl3Hd/xrNjUrhDgkXgP/eK9T6ebF6Z1h128bfDvdM4NH6NdO589MwF1MB60GZ5CBbGg1UbTfolmS9X4/RkweVKooOY/ZMBmo46/tA6EvCzO89/4UzSxgCQ036+Z7CpUUMdfHX8TP//CYHSb/faExY4Ula7vUrRZsJTsqHcEsCaLUU+W4h3MYfZIs2DOD5oPv/hJTbjd0L+i4LEVrg94toUrnOFm5ecd1Bz72zvDd5jzNrju0caX+pQ9cldz9Xff3OwQfs5A4ofYO3+4+cndj0aijWlxPiogrRGGtpx/SXPibk/OrzzXNq/WrPWmbzZXPdyOYC0WtytP8R/5XXPSG5/eDMu9jOQz5jW0a6ePNOc9IBlNbK0m6h0BrMliLojXNWm/of9Yrvr65vg7HtP6SyB15RojyqrSs+nR5m/fekmzSowRV2++Eo7ti/G3/WRzeSBnvlbRCYSX2RGl3cOXvKPZyvzEA+IQzWg2+cTvemKUNV7bnLTnEyX/a+7XfPVOn4uSneP7wxUe225sTnrNjNSfZfv5G/23xYKZ7+sptcWP35PbMKa/FMY0z+V0fhA5JGP6yke6j2ix4s+XMR2+wlK0X8b0+XFMlzWWLfZ6yY562PFPRmxVzh3o9mcffHVBK2tsEZyhZCO+I2mtYpUyJQN6WSPs3bJk1/ghTx0JtiaL21kVbx/Hzg2slzZgLNdR2JosXtz4JV/qyjVGlFWlW5PFSlAg3sEcJbdmSyzXUdiaLM41AYl3MAdcZD6zI8qqEq1pZP7Zzfs3Cm86kNuNdP55UXP41fxDIsK0fK3EgQXNPRcc3OysP5+ENU2uf8JvHzZ3Gb6tz2JDSXC08YVesqPeEcCaLK7xywxIdgbnKJcp2VHvKGxNFueagMQ7mANue7TGch2FrcniXBOQeAdzwK3xy2xFvSN51mQxMunum9L1EXyDpNSVa4woq1rUmixWggLxDuYoubVaxnIdha3J4lwTkHgHc8CduPGn53lcM4Y+6drKo416x8Fbk8XtOsU7mJNLleyodxS2JotzTUDiHcwBd+LyX+PnHA9CZW9FvSN51mRxu27xDubkUiU76h2FrcniXBOQeAdzwK3jL+Zp5ILmmH/Az2Oa52/PyT9vaPNpcc4kkHgHc8BdNvJfruWD2zb12s+9Zdtsce5JoIlvv/ZHuv9CZJETH39pt39KxH/k7Obf4z20eXZLL2rez/fQHQ20powfDT9BfHDzwifIc1A8T8H4KO+h/TjpHi2x7hxAi1iTxUpQIN7BHCVP2evf2v7cx4NQOVqi3pE8a7K4Xbd4B3NyqZId9Y7C1mRxrglIvIM54GKqZ3ZEWVWiNVmsBAXiHcxRspt/WDewjmQWjlMsg+see3yuPZbuCGBNFttjtEc3mJNLCS+zI8qqEq3JYiUoEO9gjpJd/tkay3UUtiaLc01A4h3MARf9mtkRZVWJ1mSxEhSIdzBHyaNuvz496K94pFVZMoRofaX67HyA8EHKQXtNbPCIzzAUKrAFAu6wP3Jt8+MPbNuELyE36Yu4+UE7HrgPz2q2P/zbzcXpw/lxjR8qmz/n7Oa4NzyjmakPb1ZtZr7ko+HLAI91HXFq0+PM/yNXNCe9KXxgjzaGB0bS/lWbtf/pc815HV9ESIEXGX/k7jOaI3dew+SRL7r4oinUvfc3mys7fwAdfQMpYbxmjyC1f+TW5py3htc1xdzxlynSxVnSKfwW8jaf/UP8LfnO/tcqEQmyJ/4jlzafe8nqoS1oU/ogBfFX3LF5ywV/1Vo98HV3+wxn5Lr0YX7HBefT3tz81xz+sojlo0bYRpoHLnhrs2X8UsFKzRMP/mnzd1BaMpexLljFFn4C4rqPNa9aU45HP5DiXKT2Dz//P5ofznnIVmGwr804AoQPUrxesyU6xv/Dv2tOfuO68gUf7X/un/CzG3FMmx8Is1VFjEiQPv7I3Wc2R+7EYzr1t/Y4elIqAABAAElEQVR/GNPhSzRXzg/ltKiCIkqfnWnwBTnyl+bn736WmZtF/w9v0+z7s7npS0ooZ6rQuorwvfYivilmajdW4YvPMBQqaJUpDEZFGUhxec3QQ1vEZxgKFdgCAffZmQYfpBT1mtjgEZ9hKFRgCwTcZ2cafJBS1Gtig0d8hqFQgS0QcPj9QzsvEkZ9XnZpYoNnLPFtDR7jmCERxbOytjz3/0PNDSfs0Mw0524aenKzzQnXp/T4HNqcCeYHGeFnk+KDDKzlOP/z+vaU+NuHzO2riT3iMwyFCnLoiPrsNpLneM1WV+NLbkyGFCqwCQu4z17zn3Pjc+Q1m846/iQ3ssd5xV5/22wJ7s9mzT9yA7mojA0ef3Ivl9d2vlbPOW73TPaNT/yuCDlGlxdxIYXjNVtucPstM+P+2vKxeY7Xck3MF59hKFRgCwTcZ2cafJBS1Gtig0d8hqFQgS0QcJ+dafBBSlGviQ0e8RmGQgW2QMB9dqbBBylFvSY2eMRnGAoV2AIB99mZBh+kFPWa2OARn2EoVGALBNxnZxp8kFLUa2KDR3yGoVCBLRBwn51p8EFKUa+JDR7xGYZCBbZAwD32249tdg8/K+mfv63YPOnffhV+oLBvW37mH56z+A8Klp/2d4+Apdf+/AxIzq96fDq8FahLQJ+dvfBBLqrE0ms/jkyO1ByvQgVC1X2fnQnwQUohr2lFkS8+w1CowBaIZbIh3EOfuGPzBHMPPcT30Cdeq0fC3L6a+KdT7+IvA+Cnh9OzlHz9u3a4h74lh4uov7YcyXO8Zqur/S+5MRlSqMAmLOA+O9Pgg5SiXhMbPOIzDIUKbIGA++xMgw9SinpNbPCIzzAUKrAFAu6zMw0+SCnqNbHBIz7DUKjAFgi4z840+CClqNfEBo/4DEOhAlsg4D470+CDlKJeExs84jMMhQpsgYD77EwbKa5/5CPY/hJ1/ktuTIYUKlis/AvZl/WarW75yn94ehA+PAhPeXTjj8KiqkBdJfAMfp2SvGIp8pwzKPz38HylG2C4ITCbI8rHcBMW/xGac8En6H3v+CSdfPVD0k4OX2xDT3sh7f6Wf6XD3r4XzX5q/B2BgiGqP/K+9jf06F/Pp+8ddwx9/MQL6Op5CLgWbfbuE+iUT/5T+KkC8zp9rVRBZ2w2ekZf/EBccBOd9+kD6F+P/GV8ZbBUGEpzl2z4ajrkM5+gI/eYRTNdpb52KZP2zT104xlH06GHHE8/uo1/8sBsw7Noh6NPoO8ctgutPx0dHeoaVf+HV1TdcivNfYjfydTQitMeoNuv+TPde//VdPEZ/0NfOeM2mmdCteDw+rTFm99Cb569Ja2/5lPoWc9ak6YvXBiaGUbmms+gTZ+2ekxaHn/zaO51f6J7HuNEEK248E66+fq5dN8dv6FfnPwN+uqF94afWxiwzdiSdtjndfSa7beg9VeZQU/fYl2a+Vh4JzP/BMRTn0HPehLGzqLbP3LbF+iN2x9Mp8zlvIeNUxfhijRzzy/RhSf/SxgnyGdkpP7nn8X4QvhZjPfIz2KsuTcdf9XX6aB1wvurlN4dv3nwL3T9rffRY4E4NK2hkXtuoZvvuJP++rsf0UlfPZN+NXdg64meui3N3uOV9LLnbU4bz1iR1thwFq23SniPGB8ZH/uKT6T1NlmHZvD91Kj6P7U5HjdXoA0IuNgW3Ew//8z+9NYPXRBf4ZW9oS3PDGP60x+XMY26Fhn/brrx9GPosIOPp7P+VLy/f3iTMKZPpO+8J4zplfIx+SPsm3+P0L233kxz/h7Y4RV0KwzNozk8puddRRefGcb06T1jmsNwgBlb0ewD9qPXbf8sWutJ64VXsq3Mj3yDYwWavs4zaKMn5jE2+dff0KRw6Hn+ca9xW3JOs1rYmVpsntGXfy4UmIvs/1S5VqqgiJpVz5hc8fFqZz5aDKVwmVPzHzptmRp/88+nj7zwlfTBy8LP8aRtaMsP0I8vOpp2XX2amTnF+Bu5m645+V30L+/6Lv3mfvaFjRseASuciO3p0Ct+Ssc+h38qIW3sj9NRATwt6RlFfOcMynI2/2KedVmr7a/9HwYDT78wFJap9aeY9fa8AhefV3g9qdcfS/7+l18z7bdwtxN+PqyuPyErmpq6/tb1d2qsv3au86qrQ3zSr78N3Xfaq+jpr/sJhSdvYeMTIYt1addTLqNz9lonWvO65VsnTr/3jGX//OPOrSE38dGsb7LTplr7Y+O0UQpcm63iGePf//HVziagXOdkw0THt7M7R82oxrcZGtD/88+jj+z8j/TB386X66KQwqEtD6cfX3w0vWI1XoTyKurWn/Cc+5qT5B76snAP3b2Fe+jf/SzcQ68Sii7567985APaz42q99+xm5f1+y87Buv8tzN32Rn/06bx532h93jy8tSM98+pZ7VTFdgud9gzlp32+1tW3wrOhyzHClybreIZtf3jc/4Jo1E2/x0JfC+CvzDgPeAH2eMozdBF2r2pq6gsR83IsiNGxYWjNEPXyPOvbX76iVc2W65h/7IiDkUeY/n/8AbNZvt8oPnoaRc1V93d8R1mVNwRf+SB65tLTvtY88G9t2zW4bcSpHqjfML2zV7fvLK5z5V3isn6eLV/QXPXxR9rDth6tdQ+2/ZVmpk7/mvz/q//tLn8Lvmz/hw1o/l3Xd789Bvva962wxPlr7M1V1zXcLPK897SfOSCv6S/0s9JQctE2n3myGC6vPncjtNz/vGtzvStzNg3EUsfIadhBYllsm76MPlWPvAc9/aAeBTzT2nePsNyS5xytNjxZzSbHXe1Nm507Z8vf82ZXu0s4xDxw+vwdzu6Oen6+/wsGXmomXPBh5o9N1wptX+9ZsevXdf4HwvI09RmnvH8H+/VzNA+LNvOOuKXWLg53z35n/H25pQwbUbXfrAkbXnUZaQJBRhZ0NwdxvT+W8tf9Ofj4ePjMf3WMKZ/1vxWxzQX9FmIY/rrPKbXjGPazX9aIfyUyAHNMWFMD3zZBY4nSd+Sy5vjwpjGsUFqbsec/xnN5p/NY8wego+PFkPa9veXylnPyLIjLgMlQmmGbiPDluv0lhw1o8ztCdRjRs3LU/w8jvPcXJ7ab8fKst3/C5uHr+e3tYRvbPFaEc9Fqzfrv+us5k+dP48S3u4y58fN8fvNCn8VwevgCs1KW7ykedmmOEfI2h3Xn1lHNOfryQJZkszlWZeRzWnEvoi6SzN0kXavRQIAS2w5akaWHbEvou7SDF2k3WuRAMASW46akWVH7IuouzRDF2n3WiQAsMSWo2Zk2RH7IuouzdBF2r0WCQAsseWoGVl2xL6IukszdJF2r0UCAEtsOWpGlh2xL6Lu0gxdpN1rkQDAEluOmpFlR+yLqLs0Qxdp91okALDElqNmZNkR+yLqLs3QRdq9FgkALLHlqBmxR9YfWUNwLSMl8t7XlGu2kUtOZkk9OWpGOUJC7UqiozRDF2n3tkawxJajZmTZnYESwdeUW2Yjl5zMWrz49j4B/VHWDX0i4rdyEgyIBx/0Gp8zYrOADGU7LHnUZQSfSiRWDQJKM3QbGbZc1Fty1IwyNyFfRN2lGbpIu9ciAYAlthw1I8uO2BdRd2mGLtLutUgAYIktR83IsiP2RdRdmqGLtHstEgBYYstRM7LsiH0RdZdm6CLtXosEAJbYctSMLDtiX0TdpVn0u5tfvncDvQ/W+98V92iOvb14A2KoKUfNSAMAlIGSvTRDF2n3qIglWGLLUTOy7Ih9EXWXZugi7V6LBMB/mIVrc5HiXXLx/dHkoway/oh7HKUZuki7tzWCJbbc6owse0nE1zGanv8t6fhlJmr8IgN+yKizNPMImn/dR5vdwxtPcY1EtEa8h76N3/gZN0jRHglv8z1+v03lHjr8pPD0LV7avJTvocvnz+4euqumvLJIBLsXflepPOozsuyI/SGruzRDt5Fh00KTYP3Lx7J8rv+1/TkDedRnlL0JtQdxdJRm6CLt3tYIlthy1IwsuzNQIvia2vPf3rMxls2XylEzSsQsfBG1l2boIu1eiwQAlthy1IwsO2JfRN2lGbpIu9ciAYAlthw1I8uO2BdRd2mGLtLutUgAYIktR83IsiP2RdRdmqGLtHstEgBYYstRM7LsiH0RdZdm6CLtXosEIHZ+v2DYwqVPPFOa7xjw5Wmw8SbQ7I0veqOeTrWpjJbkU7Czicful0788JfVf/0FnfK5o+ljX/wFXfN3PiJuSMpFgHzYYmE8k5683S60/bZb0nM33Yw2e8pqNHODjWndVR6Lf1l+0/V30kP33UI33XItXXHZxfSbS6+jmx+I1eUKaW3aeL8j6PMffwu9Yh38ZW+IwbFCMPcdFw6c8ibQ7I0vHmHUYwVaRiIHR5n/BbfQL//rKPr08afSWX98OB0gC7T2CbT2c7ej526+Ns18dJhWW/VBevSxeXT3lZfThb+/K/2FfuDy50wcl6bR9A1eTK9+z4foU2/d2bwVgH0d8dlcbLn9l9MXdtqRDrlovuQk8GKIIHF0UtTGLyqLqmdzcqe/7Sc078RdaSVLX3AqHbTW6+jE+NqBXCb2RQicLR5HTdtvKwSeSZsddxFdffCzQwP4WGHvlrn9C+i+K46j9/7zUfTfVz3cjj+8Dq23y8603bozwpsI7qYHb7iATr30nvQWg6fQFh/4Dv38mF1obY03OP8LfvI6WuuVp+Y+Tdl+/O1PmZtxIJ1yx4m0Vx7qnQnI7R/j+jP/FvrVVz9Mn/piGNPX8phO8RFtaE1aa6ttaest16YZC3hMP0QLH7uf7rzyCrro93d2tH+YVlp/F9ojjOlPvm1nWi+8FUDuA9KeB6XLMevB4OwcnPP/O/r8C3ekg3+d/8KXPe0tH/Po8r8GbfbZi9MYC7X1xg/16rG2o7Llcec/truv/TX+0si//2sT7ptwduGO7thq/2P6jHH9mfDx/xjd96sP0pv3PZbOjG/k4Tm1Kq2167vpA4ftSS992sq0wvAjdN/1F9Evzv0enfStsC48wG9qeQKtv+8n6QcfW5W+9tx96cQ7bf8P0+oHnk1zwzmRvyIoy8dkbT8vYTHJsheYRnJQol7Xn5QiM8M5N3X9XRrrr3TC1Mu/nFd4TKV5FxrajIS1pl5/pHXITD+ekBM8/9x5PoXO5/mJjx8bHcLU/q/nn3r+4XmwZOf/MjP/ml/RMc95CX3oD8UbJbc6hi68/D9oh2FuyfJ9/Ym1HPf/WMfj8pomV8RiwGofh0Bdf8d//Z0W3ujIqeaNp3V4ZC69UPNv1rmQjJiP8c8/1lJJt9kLjP0y+vXvUbrnV0eEe+jP0Fn6VtvVaK1XvJsOP/S19LJ1V6HhaQ/S/TdcLPfQ/3Nh/EygCffQ6+33KTr9oyuHe+j96IR4Dx3aGq9/+R76RzT3hF1p9Xr9m8ZB6pYoQkdN8PXv6PvfHpfH9flXGM5x+i7f598ldf2B8zxG4Qj/wmvNfziN1PGn75gx5zhz5pv4649w0cnx2ps5IHFaQ+o6a9IaTLeqX0E6aRhdyxWgRbGG8YzPXwy4iM4+6cv0jf8+jc6MH5KH2SmpT7I4tqRGFu+whUPsLvkEWvfV76LD//1AOmC7p9F0vpjA1Q7KlrJFsYZxaP+CP9Glp32FTv7eqXTa2TfQXH6mF0JwlL5W+ENck9Z7xT609z/vTe/Yc1tad0Uk4vH0/xX0+Z12oIMvXBBCob1yRDRjQ3rms55AK88Pr30KPl46+G8mG/NrC9NXeoTm3Xgz3RS+iIF+wDFPP/Bcuv/El1N8/wDyv+CU8IWA18sXAkIB2/6hpzybNl1rmIZGFqYjMe1K8VdfeR795Q9/IX2zfjgeiTuDNj/uYrrq3ZuJIdUQjyU2K+5waC3ZPPAH+tHnP0Sf+OJP6MK/FjfQhh1j8e4J29Nen/oCHb//NrRWaIQuqxpGQUqr6O4LAa79q9KMTZ5N667AH2JzfdwMU2/CZf6ZOHPhn+nS6x6IZZo13k6n3HUC7RX/OJUPNGyxMqlRDD37FsUa0rFYE1ez4Da67LQv07e+dxr9IIzpOeUvHsSEoY+KuLH9a9LTd9uH9tl3H3rHa55P67qfaLDBeuLHKk2eYpEwpnfcng6+KIzpIv7QUzenTZ8cTgHxgXpwBz4XiUR+7evQNFp1lfvpL7//C/21bAuFMRa+EHDVIWGMua2Mz05z7BEa3ZU1SotiDYvT/hp/aeR/OFxhco/ZLZ7qYzfavrQMg1sUa6j9H9dYmxJN3UTNv5GwvJ1Bn//399DR370lfokpLie8wxaOR5aYVWjm1m+gd3z8CPrQy55BK1x6EG3xghPpOrf+rEOzv3UJnb/P+ijtZatt1lD7f8n3f82/jG4epnX8La3xZx9mYP0JXy43a8dErX91/HeN/6FhcwIIKWJtYbilj1ZNmYJ0KWJ003MOtijWUOff0pp/0kc1/zX/4b7RTkmdvJN0/Z1zHL1qw8PoR/k2OBzxivSkf/sZzf3kCwMqtlbbrGFqjn/++RduJa7i/aPZqd9+NwJsc6PDGpZM/w/h1c7pwHJ/LJn4chJHVpZ8+6de/PCs/9bT6QuHH0b/+d1b0x8CpfyGCyb3/I2m04yt30Tv/MSH6EMvDffQlx1Em293Il2P7ghyiNahF510KZ2/93rGOknXX3RmHEZ2LJlDt7BFsYY6/uv1xzJ2/TGJxr/9ohlPuXxeMRPQTrdotoY6/+r8m5j5F98QIMNQBpwfdnJpaj9Pstw8TnNZtuVHFLk2IEipx+5zHSivXAXgG0OEovOeN5S3H8SgBKQw7Z49D9BtF59JPz49fDHgR+fT//5xXpis8lFoZLqLBoljYwJLreGh/LNn08v3fiPt9/r/R6/caGb4W3p7RMLKezky2YtVsQKwjSFC0XnP2+K1fyE9OOdyuuTc/6Vf/N/l9LvfXku33HgjXXPHY1JXan/88PJZG9KsrbelnbbbkXbaZVva7mmruwdMY4sfw4Qdl36U7g9/rT9zhvwdv7QquXKjvCGShMl73jIVNTxGDzywgFZfY9XC/yDN+/sqNCP8FjN6BiWYqFhBLG49Pe2fT/MeGKIZa/BtrhwNqoBETVmKx/pHHryBfnvOmXTOL35OF19yJf0ffzAcuoU5xG8LeMEO9KJX7EUHvOXVNDv8tny0B1e7/bkttv7mwbvo7hWfTE+O6RaP86Mua+TYOTM97Y8kor/fTw+sNpPWCAeEKiATwwjxWL9iBaAbQ4Si8563IXqM/j7nCro0jOkLfn85/f7ya+mGm26kazl5uoUFdZ3NaNMNn0mbbPN8euELdqQddtmOtl1ntThPmaZRFKCwMUQoOu958/lfEMbeUBh7K0W7KSlk3ec6UF65CkBmg9S7xuqh89KTIbbyhvKmBdqWVlVSJOzFY/2KFYBsDBGKznveanzJA3LKGjIGCUaWOYfIn3IVgG0MEYrOe964PH9wwxJMlnzhCT2oxSYe61esAEWMIULRec8bjj9Hz8iUFLLucx0or1wFIBtDhKLznjeUz1EzMiWFrPtcB8orVwHIxhCh6LznDeVz1IxMSSHrPteB8spVwOSH6W+//T6dduqZ9LMLL6VLL/6TfJmPVqHVZz2fttllN9rrNXvS3i/bOLzTiAvOp5uO24k2OfRyCl8xytvwrnTktWfQURvh9S2jjc9VmAOKMJdlL47f8lACknl+y3WgvHIVoIQxRCg673lD+Ro/5wkIUjJl9+KxfsUKwDeGCEXnPW81/5KHqTj+8ocW0s/c5+F1c7HXa/9Lvy/J8Y8vaHBM5D8/YGKLHA0QpByp3YvH+hUrAN8YIhSd97wtyfbLqajG56zX/NfxNznn3wjde8rutN7rf0IPShfJKjG0Lu36vcvonL2eGvQ8h7F+iEVdWhLcaIikXJZtKG95qAvSVJZgrgPllasApYwhQtF5zxvKL278+AF0qITL8x/Wxr8c5AqlekZpM4YIRec9b2ONzyVNzRlbY4xgDBGKznvepkr8ofCGAH7JvNw1h27Qv51bPtqvrVQg/esGZPQJgfe8Tf7+D/fQl/8w3EOfTj/99WV02SW3xT+4acJb99bY5Hn0/HAPveeee9KbXrpxeD9A2JpH6KbP7USzDgv30KGR2s7hl9MR15xJR23CD1Dr+VfzwjmLG1tkNABBJoIR4rF+xQpAN4YIRec9b5N//Mlx+n1uA45fLIGlACWMIULRec8bytuCKAEpTLvPdaC8chWAbwwRis573lC+xs95AmLJ99AxS/EbSGHdiPfPwgCP86hYAVt5M4YIRec9bzX/kgebJ2QMEowscw6RP+UqANsYIhSd97yh/LIYX34yAI0w7Ywt4wugOHhN00pOJIZdae/UYUzSi446AmGpxQ8fKt5+BV3+iwvpsmuupj9ecw1d8+c/059+F/4i3D1ZlwQMPWULenb4wHzjbbahbbd6Hu2w0wto+1lPCt8zTFtsa2owkjWp2899ujTzX+PX/Nfxt/TWvzr/luX5Jx8U8KUJn2R44wtPfs0EbEHW809MR0qD5iOmi3dT4vx3E317z61p7x/w7xdhLAQ46wg6/6oP0+wVTLM1Edz4sE2J9ktTZKyjgUl6YRKBMoGw1K4/a/7r+Jt84w8fQKcZEkV8UJ7mkto7dRiT9KLOP6QHSRzF+pv7A18ADB9fcLlWXaFS/ZNin3ilKkgHMIr4ONTueOpNx4MANb698EBW2jkMnnr+iYOoN0cYYkpIhk4dxiS96JgzgVDzPw75v5d+/d6taefP3IreErnCHnTsn06lQ9ZZQR6ionvAWs7Wn7yWSwL0p3iCqqlRgCQlWdo7dRiT9MIEQZ2BsByP/1Z/dJ1X0Q1I7UAdJJ94WHMn1/zHDEya+X8TnRzuoff5QfxtWfSw3ENfHe6hw8+dtPsu2PInQ8mPnq79H5Pj09CRw0BYjtefev87Nfvfnld4eC/knwzgVSXNB4ZxmzTrnzm08hj1WANorXdwBhnLoXCSXpggqVxt/xJf//IbAkzyTTfqGEVXWh9w9mUEH2T0tNzGsMzFf4Tu+ctDtNq6T4y/Sy9zwbQHDU9y6rU/NzC3OqPsFVTbH+Z2Kz3GsMyN/9zDuRUZZW/tf85AzEwrPcZQ+19PfnbsIEOQ1gecfRnBBxk9LbcxTLH827/kjBdqoanx1c72ok3P7iFLU6z96HfI5a3/0W56KPwszoZvoBPv4Axg498+PJvmhp/QWR1X8bX/6/qTHr5glLDECglpfcDZlxF8kNHTchtDHX/LxPiT8wqfROJL+8K+ib+tW+9/eKSb8YyBn+REjX/7cAkh818ywpKOrHV4xlDn3zIx/3KPZpR7MaPsFRQ9Lbcx1P6v/T9R5/+Rn9MRm76Cjr7BvqEvjMutjqaLrvggbR9f0BjG4kTFD6GWhfHPbwiQM2uas2FOYoZCisfvsy8jz1g22j/Z+l/PralTus6rnOec9Yxq/n0GYmZa6TGGyXz+efgUevv6b6Av3R2uecMhy8d302iNA39Mc8I99GqhqfX6l/vb9KfvfvG03MYwmft/YMtsq017avtdBmJmWukxhuWo//W8kjIkX+AOuVjOr39q++UsYicOZgik9QFnX0bwQUZPy20Maf7lLwSgJEvDi+ZSV27b0bYoOYNAasKZVf6mIZsVlZWUei+xfehKtaDGr/mv46/Ov3QZb5eGiMv1ptS1QNvRtig5g0Cq619d/yfy/BcvOu3TpTD69IFGHX/Lzfx77LJ30BbbnUDX5dUnoPDbh9+6hH6xz/rOqkq5iJV6L7Fef/WmSnMWQJ1/y838s92ueBnu//wwI51cgohfNEuNq+MfD4e1t9tgHPs/foiEn3UL17P8EZKe59uRxTKO8cvW1v4vM9LRCTX/df1fjp4/NDccRbOf/WH6Jb+gDNvQCvTk955Pcz65E/EPK7qtXERKXcltR9ui5AwCaTLef8u5teO82tuotqNtyc1WNEnbb4/PPZrpbVTb0bZorRmMsv35WkfW9BF+aO62drS2xRUQZZTxtWRvpW1H26K1ZFDjL9b8f+zSd9CWLziBrnXPU55Gs795MZ2/r7+Hrvmv1z88TAZudf4t1vxrfR6pyW3PtrZFyRks5fzj2Sx+jqZ1v1Y2otS1JW1H26LkDAJpMl7/6AGWjSj1XmJ8tOYuHZRqQW1/b//7LwTERJkFvedbO5pb01ECjYFJUKPkHZv4d5kC4AdJItgsWzDwb2fpglrjh2RoNpClLE0CBRoDs6BGybua/zr+6vyr609YCOr6q8tjXBhlcZwy5x88zOCzh6z8QYbfqqrr3/K0/qXfPjz0corPYjEYpu1KR157Bh258fR8rTXFxn+c0/X6Ry6m6/VfyEO9/pUp/vjWP/5dXT6hYCmJdYb7NJlqso9zT4JlYs1/TMt4n39jf5je4H7RDy7QHVHyrt7/jXf+cQKVVCPhMdVy4YWJUsd/HX/L5fx7jO781itog/1+Tg9jLsRJsxntfd6v6KRd1kyTJSZnytx/pcG+WOc/3LMhIfYnA2Bz0iw3df3hVJuEcKKgRsm7xTv/2bchxbLlFwJQf6x3/OP3vbWPjyVuNb7Mr5AMSYVJCCcIapS8W7z+l/wvoBuP25E2Le6hh4ZfTkdccyYdtYn8KLCEQsAYapzi86LZs5lwNX6df+O9/tX1J8yqCfj8bdpQfCWSrF0hhH4hgHGY7jrj6+efE5L/+vlPOJ+EQSbnDHNu4eEeBiOe5hhPSTZFDXQFxqKgLkhThzcZzUBDHxtEXZCmFm8ymoGGPjaIuiBNLd5kNAMNfWwQdUGaWrzJaAYa+tgg6oI0tXiT0Qw09LFB1AVpavEmoxlo6GODqAvS1OJNRjPQ0McGURekqcWbjGagoY8Noi5IU4s3Gc1AQx8bRF2QphZvMpqBhj42iLogTS3eZDQDDX1sEHVBmlq8yWgGGvrYIOqCNLV4k9EMNPSxQdQFaWrxJqMZaOhjg6gL0tTiTUYz0NBbUB4u8aUlF5CLTP2gIFrCDnVBwm5cYjIEAw19bBB1QZpavMloBhr62CDqgjS1eJPRDDT0sUHUBWlq8SajGWjoPfBm+vaez6W9w28fykhI42HWEfSL8NuHL+L7EgwRlmbzYYxmoKGPDaIuSFOLNxnNQEMfG0RdkKYWbzKagYY+Noi6IE0t3mQ0Aw19bBB1QZpavMloBhr62CDqgjS1eJPRDDT0sUHUBWlq8SajGWjoY4OoC9LU4k1GM9DQxwZRF6SpxZuyph9aYN0IZfSBhik/KohqIU0hbzKagYY+Noi6IE0t3mQ0Aw19bBB1QZpavMloBjJd+4Nx+M/uUfcH6oIMZbF5k9EMBHfMEnVBmoq8yWgGGvrYIOqCNLV4k9EMNPSxQdQFaWrxJqMZaOhjg6gL0tTiTUYz0NDHBlEXpKnFm4xmoKGPDaIuSFOLNxnNQEMfG0RdkKYWbzKagYY+Noi6IE0t3mQ0Aw29HzZ/pG+8ajva/+wHwtqEFSqsVeu9g7535edpr5nhIrSjTm8ymoH9QUfpQV2Qppg3Gc1AQx8bRF1J2rWcK8zrOIhsDP+La3XmjmlDXZCmEm8ymoGGPjaIuiBNLd5kNAMNfWwQdUGaWtjEXwiIWxq2sT86uKbY4kHUBWlKe5PRDDT0sUHUBWlq8SajGWjoY4OoC9LU4k1GM9DQxwZRF6SpJZtuopNf+1za5/sP5Ass5m16BJ1/1Ydp9rAptLgQQSBNeW8ymoGGPjaIuiBNLd5kNAMNfWwQdUGaWrzJaAYa+tgg6oI0tXiT0Qw09LFB1AVpavEmoxlo6GODqAvS1OJNRjPQ0McGURekqcWbjGagoY8Noi5IU4s3Gc1AQ18syOf5fCUUTukjodLinO7DGM3AxQraRUZdkIbjTUYz0NDHBlEXpKnFm4xmoKGPDaIuSFOLNxnNQEMfG0RdkKYWbzKagYY+Noi6IEMt/g0BWq1hwNZhiq5oN06FCvQaNlsWdV1rmekAOkw1fshAzItJjkIFNf8hTViAse7m7KTx5USHt8MUi0S7cSpUUPNf81/HXxgDeUZ47KZenlTebAtbT7Qbp0IFGjdbpn58+esGmyj5y8G6/klO7FjwWWKtw9thiuWi3TgVKtDasqUzgjkMy0zmDtMi4z90Kh30jDfQiXdyYWzDtPqBZ4ffPtyV1oCpJTuCdZhisWg3ToUKll77010WjgSSj9viVvO7vH0Fot04FSrQ2rKlxre5qPkvM9CRnQ5TLBXtxqlQwbiOv/JhBl9ZNw2/fySdWTSsgnGNX2ZKKs+xNFgGigxLba36clK9yxa2nmg3ToUKNFa2jN/8Hwp/bSI/FJAPSj5IytGAIJlpcS4J1OHtMEV2tBunQgUaK1tqfJsLZD3LDm+HqeY/ZCDmxSRHoYI6/kKaxuP5R3PvRfTt4z5F3zjjepoTfnZqoz3eRR89/NW0+co515rsBEauPpy23+rjdJn9uQBanTY45ny68T+eRyvkQW+QqQ/WDlN0RbtxKlSgh5Qtk3P9sedW7i/3BW578MgJy2g3ToUKlpn252blY1dbhyn6ot04FSoYc/vtFzRa/YEDm8D4CJHb6Syi1Phhcct9rZ2dgSLDUltHRoPJMB86Jd5DfyncQ+MLTUM0TKuFe+i54R569Zr/ic0/Osh0CUxR1vzX/E/k/MdgG8fxF88ruCAL9ecv/g0INo7xOUpfdXIEHd4OU+RGu3EqVKCxsqXGt7mQnNt9h7fDNBH5D18ICJed4T0V+DJkV1zYIPlAgCFtczy2DIvB4t88rPFr/mU8dI+Q/hvaLj5GVrvGLnYdf3X+1fWnrj/t1QLrCFYNSLYDQ4LblpZhMZgTs/7IwyX/UQH/ZICspIjNcmLi5wi2zRaDUeNP1Pq78LJ30ubbHU/XIdXxJmQdmv2tS+n8fdZL1pr/icq/JNiOeYvRKTX/Nf/LzvWH/tUchm+Q7QcaxqlnSrbV8T/e51/50MI8XWr1h825xeijuv7U9WfZWX94pPOGkQwp1q69ZVgMbh3/oxn/9Ndv0kEvPZC+dPXDSFyQq9N67z2LrvzUbJpprAqb6+nbe72A9v7+vWLCMrXe2+hbV3yR9nkyfx2g5h/5lw8KQpLSq+lxXsWoheRkAkNKgrv2lmExuDX/yD9nxGZIrnXkRdz8ofNI+EvOuv7IuEGeIDGa2tIyLAZzco8/vofebLsT6Hr+0JEPP27r0IvCPfQvwj10V4vAEmkZFoM1udvPR4mjhuyzoUVedpWyjNr+vvUHWUIGIdkODAluW1qGxWDW/C/p/Ms9G/IfvvjH55V0Yunuofr5Fy4d6/lXxg3GCWQeTSWyDIvB8/PfvCEgkaOwBa2dK7E+VDp6qaUDcL+XgXojQVk5npoUjD6oYWrpAGp8+3gqZSYKzVLNvxuXPJBsbszAGiXU0gHU8VfHH05wOq7iANFRksebmhSMcsR5mpYOoI6/qTv+5OFSHj7c2fyFgNr/qc+n/Pj/O/3fMc+n53zoWmkwT3bu/fDbh0f98Uw6cqPpdf6HlNT1F+eHtDJEkXB0WTsbrA9lRy+1dAD1/LPsjT8+r8Q5E3b4SV18cDGaUVD7f3zPP+gPzqtscp6HVsqa//HNf5nfRek1/zX/cf0MA2HZOf/NpXPf9nx6xVfmhuGdPhTF+r/B++ncGz9OL2/9qf+jdNeZb6StX/19+jM3GNef9Cza7ZSf09mv3SAOhJiLOGnSzIgi4ZadDdYXCYu109IBTLb889te7Cbn1XTE9sDNVavljwbbaiZb++OAiAeoRxmalLCaFIymuS2Olg5gUe0fmpZHJ38eLG9s0BpadY/GoKVHEV/qSyVswdr/o0l1J8emcVH9T8T30M+j5xxxXXwJgb4hINxDH3mt3EN3BhlgXLz4XFHt/7wumHwMyPEgV81/vf6Kq3oYCIue/2a82YHzONff4XAPzdXxxl8E4C8E+HmuwQo7l7A+1hdv09IBLK32L+381/hhzPT0v/lCgB9YOnBgLirgh0H+Wy2mBGCU4RsIYQLFTkBdoxjUqMIWsQO4xq/5r+NPZofMFTNjAKOs86+uP3X9Xd7OP0PD/NucvADkLX9wgwUi+0rUYgRDPf+mm6mQrEl//UEX06e224Xe95v5vmtnhd8+vOYomm0ednmCaLX/c1/HjNTxX+d/OIngPDLp5z8faJzE43v9N43XDa43ZiKC+KBcHnGk7MS4ExN/ec9/2X78tQnfC+F0r79JOQH9X8bnkSDdjU5Xw4SMvxqfMy59Xe9/Uy6CqOvPBM6/+75G+z79LXTSwzz7QhwOhfU/XE+ed/WHaZdhG7+h+Td+gvba9gN01n2RzAXCtjqt/+7T6DefezmtrWdS8ZR7U5u4gmGq33/gy10ymvkvt0zuloP22zEwGfrfvg2JR/7C0B/1/JOmY+igKX/+GQn30NuHe+jL5stqFxscGr5JWPOuCmte+hKUjFUzYgGjHN/r7zr+lqPxVyyIU/38VzRX19poD3NpqrSfv2iWXzjS/QVuLCGakynUfrmAxEqmLXSgtl+usDUpS6j/9QsBrdOWfeKlR5VBi59dAaE7IZMTKqTyuETxsV2Nn6+4XG5FaeXLcZBgyJr/mAGkA7KOv5AWWZhb46nOvzr/cMfn1hZRWuPFcTDBIJMTKmSdfyExEzP/hoaGQ92caNk4SvwmKoOa/5R2TURIyVS6/lhAd52xN229x2n0Z9P/DFc84Cy66792pzXisJuq7Ue7IFMSoELmiTDF+h8NhKztjxlAOiBr/4e0LN75Bx9Acz758oAvE90HF92JjlZNd83/uJ1/bH9Ikrk/8NNAmuiaf84A0gGpBnZNpfM/GgiZRgZUyNr+kJjFW/9SJtvjBY4okWDI5IQKuazk/8ajaOeNP0y/dm3k9T98wP+Bc+iPx+xIq6ivoQU3fJ4O2PV9dNItC9Q6RKvR2m88kX72jX1pixWDuV5/hiToQIjjaRreEMC5Ca72eVXTGfnl1/ytVxKc648+qJBFfFdfff5D06ZNix9CxTRxl3BO0tY6X8ARJRIMqYWKbsn+Vn01/7zAuKxapZUv69RxnfMb3VAhlcfTrTz/L6C7z3wTPfefwhtOmG+2lfY/k+782u40I507jCtBBIDsM2d/O37wLdX21/g1/0tz/k3d8Vfes/F5pc7/cv2duv2fTzuhjZPs/mMo/DUB94Tb8mHKRRAGsLW7AkFp+QpDocbi0dbhsCaeLDW+dJDNS82/z0ArN4WhUOv4CxmIOelIjDXV+VfXn7r+LnvrL/cZ30/ycwU8hbAPNNha53/IjF3sOClhs6bJvv41d19B5553E82f/xe66sb7aWjFR+jBa8+mb3z7KpobGmL7PzbuCdvSrm/dg16wyhDN2GgWrbfSCE1/1g70im3WoZUiYdlqfzpk12fRZjsxGAo1Uzoc1jTZ+7+2XzJg+yx3LrJT+7+Vn5CaaOtwWFM5/vmv5vhsGDnp/MIcW6bmHwmKmehKR7a1EufHapl/uRLJ9eLajC3oFy5TdkhHmDH1fxkfR9KqvzAUaiwWbR0Oa1pU+2t8yYDNWU4ustMaDpnSKui5Nf/1/m/o4VPpoA3fQCfewcNGHhfysJk26930nV99hl631gppuXmY5v7sKHrbv36Wzrr1UXP/8VTa/N/+i3549D/SxtPzChKHXh1/eCaszznj5ORM83k1/Mca35EqUMvl3k9iriv8z5mXYjX/g+//4k8GhCTF82rYxd961ox70MpvYSjUWDjaOhzWVPt/4sd/c+8V9L8/l3voK2+8j2il+fTQNeEe+ntX0ZzHcv/j2yFD4R765eEeevtVwz30M2fRuiuP0ErP3IF2M/fQ5YSzfYqRU/t/8PzjPNXxP/Hjvzwx2LFa8z/++cf5XNcBvl8zW82/rLmckjr+xn/8Yah1nX/0DQFCskMxdkfY4TKy9AVXhwlGcYW9fc+HBOFeDtWiXhhZlhVa3eJUpsOEOsQV9jV+7kKkuua/jr86/zAbjCwXFKtbXNefmIGOlNT1V5Ki+6V0/rEXnfGLAaHD4quEuePq+j9F1v+/0jlvfy7t9uW/xunIH9XJR3NR1R36n6+FlBGfciXKavvRV2//Oh0wk432usxOcItTuQ5Tnf8682Ou6/VnGE92SPHQqevPMrv+yF8x+lWGb9rzVsc/D3jNwgSf/+OHFin5WN25P5ZU/NbczpHr+se5mOD+r/nPK48gHfl1/I3b+LuHLvvg9rTDR66nkTjgQo6f9hr60Lc/Qm/YYGVa+ZG76W9Xn0unf+u/6IQzbqUHtEum0fRN96J3HfsxOnq3DWll2Ov5v/P8j3u2vI7jTS+cOBnXSGGUHSbwdBbU9WfM15/oDwx5f53T3SU1/zrylpH1N9xDHxjuob8S7qH50MOG+SdaNDgfK4mqFFp1X/raX/6H9l+TTUvu+i+OzXwUAS1r+bcHL8eeLVa3ODE6TLX9khTd1/V/zOs/xpKMto7B1mFCmUH5j+cVfibCJBZ6/1xWaHWLpVya6kmBEJ7ua/9Puv6fzM+/4hcCeEDqxQ9GKc40cWTp8IqjDs/3stVbMDRVMpHr7fwQUiZEjW9zyPlKekxyzrTxpPVAfGyXFQb1iEXNNf91/NX5ZyZFhnX9q+v/VDv/cHv4TBB6Nu55tOcLT9byVsf/sjr+76HLj55NLzniSpoXunMoPHJdY9YWtO4KD8VLAe3/eMMh118rrrSQHp17E13zt4WhBNuGafpOn6GLzj+YtuZfmYhXFSy5dNji5YVcY/Cet+QRV9qLR3iCzT4WDLt6/jFJybDOv2V1/vFcsGPe4ty/kcK7KTD+4+/qysISFwJ+wwq/ZE62qd9+budkWv+Gw5hC9tEtrfN8JITdFBh/ky3/y9v8r/mfXPN/iY2/BVfSKe96Pb31K9fS/Vhogsy/hSt5iUsNX1Nu8GLa452H0gffuittsfq0MGzq+rOo9Xco/mQA54lnWcjYSMCc0PQaM4a8Jbe40l48kSzQ7mPBsKvrv82K4r7rb+4Pnl/8mQrvRuJP8dT8T63xdzdd9p+70MuPvJLC+/VCR0+nGZtuTusOPxz7PHxAQs20MHdC/8dpFBgrhXvoBeEe+o93PJbWv2Fa+YWfpQvPe2e4h0Z2dHjJHObSdf6ZpGTYN/8ig5Ne1z9Ogo4/jLCYmmj1lpzZhOLAreNvssw/vofW57Kh60YWhq9Z6toQOyv2d+y92MlxV/s/DWc/2iU34rI4kVmwmXeaY9bzVtef/PxN3hAQ8yjJVMj5QuZz7noRl+MtFnGK2O2+5dagsujF9V8rsyX7savTKe0yLXeNHzouJiHOnZr/NGbq+G9Pnh6Lm1NOaRdouePQi7s6/kK66vxLY6bOv/bk6bG4ORWU+JeDnD+ZVlHigwLH5foiR4gK2V7zz1kY1eZy6pR28ZZbk16vfzQVnLY6/tqDp8fixpRT2gVabk16HX+aCk5bHX+tweO+aMYXKvygNDwod2PKKa0qPJfdmvQ6/jQVnJdRjD/50IJTiKQHzB8kDSgPplavQWv+NRUD8ifJ9XuXU6d4Hmsttwat+ddUcKJ0gLIyeHM5dUq7XMutQWv+NRWctlb+H6a/XXIyfeN/vkPnXngVXX7VHTQvrP9Ma2ZsSM/8hy1pmx1eQq/YbTfa84Ub0Uz+HkDHVvMvSdH0pqTLFwJiNiMB92sdKWyZXE6d0qLW9SelpMw/D/jUFZGhb98JxCHzhYB2Ros1veZfUqQJ9hlrpUeT7vPfXn98PVZzdTrFsgS33DU+D/CQnJp/HQo8VHrGr4wiv3djyimex1rLrUFr/jUVnKgpmn98+M/N4y8GNCPhTUB1/sUOXx76fzLP/6Hw1x3hUsdusUuSwRx6Mlsvk0TvcaLa4G7CgJdbh1yKS1ur0G0ExryFI+wJIeYepxSOZWt8m+mUr5r/Ov7MrJTpgrHBGmPe6vyr648bBnFU8E5GSxozdugoQ0h1/V2y62+86JQrTukJnsL4oACDOUh7VEK0nciYtzr/kTKbHc6M6MlaOpnAW7DX8W9HGhJVx5/Nig4Wnm9x4zzxVudfnX9uGMRRwTuZSWk+YVqpN4FgH6/1Z2ha+Ks5/qspE4O/EGDHqHEJHMf4ZRNFT9bSiQMJ9vFqfxlC9GQtnUsgPh4uIRTL1gdJ4bimavuXdv5rfJ75aeAnYcdixMFex5890yNR9frHZkXGDXLDGmPelo/rn/KeTc6ry0/7Y1djLYnK0u3/8tzK51U7OvkQRU/W0ikNiqS6/tmZjkTV9c9mRYYLcoPRxXL5WP9q+9Hn9f4/jwVGU2v844tm8fv0oXX+fq3O/9jfcQBwLnibWv2PqwaWk239D892+FMC880krEXSE3Fvh6gxjxq68qaPpQLxxr0j5up7zJmwCOTKs8KbtlO8ce+IQuN9jzkTFoFceVZ4q/ElD/aS2iUquYPoMWfCIpArX/Mv2arjL40aGR1x7wZKHlQ95kxYBHLlWeGt5l/yUOd/HAxxjLiBktITRI85EzoQHmbwMMOQixeeUOr4S1mT7Ma9wFY2e8wtXp/BlWeFt5p/yUOd/3EwxDHiBkpKTxA95kxYBHLlWeGtjj/JQx1/cTDEMeIGSkpPENaM84p6wzjKXzRTqwO2fKyMvXX8pRxJduLeJSqnsMccCfHhUiBwOpnHm3/A5PtPSTX/kqw0umOOexLdY07lFy1ceVZ4q/mXPNT8x8EQx4gbKCk9QfSYM2ERyJVnhbc6/iQPk2j88auE8zoensmmV9S7/ktHvTjCla/9L6kbxfiPr3bm1wyHLwIwPf800uJkv5i/Nf+jzj+y7MYvjIshXfma/5p/zsAo5j+GmBs/MC6GdOXr+JPMLcf55y/Vy1lBUqFfNHMDJQ+wHnMmLAK58nX8SbaW4/EXE9DTfvnJAGa4USM50324IIq/vxAEv05A61JCP8jVdn0bwpTLRGNMsMav+Y8X5nX81flX15+6/rZPEX2WfFpZvs4//oMbHjFNfKDRO3ZyotqprOffev6t5994jVzPv/X827uGtldOc1s1Nc4/+OsGGQV80gjTgs8PPVs+rUyN9k+2+Z/P83KO526w/VHzj/Wqjr/2X6OYSZsHijEmWK//6vVfvf6b8Ou/fG6VeafreJ1/S2X+8bk1n1VD94e/nZts5//2Yu0teVmv5796/svvaPajJGh5oLRc/IWY+vlPWAlCGur8x/V0e5h0WfKwqusP1p98zyYZi+f5nKh2Guv8q+vPErr+7vjJgDQe4yBk3P34a9D4jScXDOvO4ql0EL0LbI2fUt+ZwIHn75p/DL6+4VvHXxxcdf7V9ScsL50rTF1/l+n1Vx4ucc/KWsfvAMp/4VDXv7r+hbFR1/+6/tf1v57/zOWywp7zf/mQnPn6wQUK8+kFW/fFRfDW9Wc81t/y4RKn3b2xoeYfI9HIev1T519df8Zj/TGTKsO6/udcLMb6W77tRX+KJ9emKK1gqjtQ85/TsRj5z4UCCtc/8pecYuVq8v1zvHXqvm5kes2/JI33jyP/Urazgpjibk/Nfx1/efjV8WdyoTCdPYKon7/1LVEhOXGB6V5lUgY1ow6wE1tHcZznQWndP7Oj5/5bywTQUbW4FxFfz16BV/u/J4/Laf71JwPiSOoY5d6UNBghMUpVigNuyMKdVOM1EFxvShqMkCCrFAfckIU7qcZrILjelDQYIUFWKQ64IQt3Uo3XQHC9KWkwQoKsUhxwQxbupBqvgeB6U9JghARZpTjghizcSTVeA8H1pqTBCAmySnHADVm4k2q8BoLrTUmDERJkleKAG7JwJ9V4DQTXm5IGIyTIKsUBN2ThTqrxGgiuNyUNRkiQVYoDbsjCnVTjNRBcb0oajJAgqxQH3JCFO6nGayC43pQ0GCFBVikOuCELd1KN10BwvSlpMEKCrFIccEMW7qQar4HgelPSYIQEWaU44IYs3Ek1XgPB9aakwQgJskpxwA1ZuJNqvAaC601JgxESZJXigBuycCfVeA0E15uSBiMkyCrDw4whfi2VXOwwjTe98HTljGKglNBLx6QmAniQIKsUB9yQhdvXyVqLWJoSATxIrRhAHHBDwuvjGK+B4HpT0mCEBFmlOOCGLNxJNV4DwfWmpMEICbJKccANWbiTarwGgutNSYMREmSV4oAbsnAn1XgNBNebkgYjJMgqxQE3ZOFOqvEaCK43JQ1GSJBVigNuyMKdVOM1EFxvShqMkCCrFAfckIU7qcZrILjelDQYIUFWKQ64IQt3Uo3XQHC9KWkwQoKsUhxwQxbupBqvgeB6U9JghARZpTjghizcSTVeA8H1pqTBCAmySnHADVm4k2q8BoLrTQ1NGxoOyydb86bnFTVJKZSFLNxJNV4DwfWmpMEICbJKccANWbiTarwGgutNSYMREmSV4oAbsnAn1XgNBNebkgZjkOVflXI5fJBkaP7hERwxiFEMHG18X7Evheog4a3n35AJfZpnsmMgcuVNSYMREmSV4oAbsnAn1XgNBNebkgYjJMgqxQE3ZOFOqvEaCK43JQ1GSJBVigNuyMKdVOM1EFxvShqMkCCrFAfckIU7qcZrILjelDQYIUFWKQ64IQt3Uo3XQHC9KWkwQoKsUhxwQxbupBqvgeB6U9JghARZpTjghizcSTVeA8H1pqTBCAmySnHADVm4k5q9/std8pMB2cv0pMEIqRUDiANuSHhRjejGayC43pQ0GCFBVikOuCELd1KN10BwvSlpMEKCrFIccEMW7qQar4HsnDaN+0BL6XlV81fwDTNA/gp+vv/W5Z5JcDC2irNHp/VmLniQQjV7ccANqQRnMIqB4HpT0mCEBFmlOOCGLNxJNV4DwfWmpMEICbJKccANWbiTarwGgutNSYMREmSV4oAbsnAn1XgNBNebkgYjJMgqxQE3ZOFOqvEaCK43JQ1GSJBVigNuyMKdVOM1EFxvShqMkCCrFAfckIU7qcZrILjelDQYIUFWKQ64IQt3Uo3XQHC9KWkwQoKsUhxwQxbupBqvgeB6U9JghARZpTjghizcSTVeA8H1pqTBCAmySnHADVm4k2q8BoLrTUmDERJkleKAGxLu+GyWTwjpQ2f9AndJZEr4n88dSYMREhWrFAfckIU7qcZrILjelDQYIUFWKQ64IQt3Uo3XQHC9KWkwQoKsUhxwQxbupBqvgeB6U9JghARZpTjghizcSTVeA8H1pqTBCAmySnHADVm4k2q8AeY3BMAOqaXbQCj9xLantGRdEQBkO6xahNJPbHtKS9YVAUBqtDYQSj+x7SktWVcEANkOqxah9BPbntKSdUUAkBqtDYTST2x7SkvWFQFAtsOqRSj9xLantGRdEQCkRmsDofQT257SknVFAJDtsGoRSj+x7SktWVcEAKnR2kAo/cS2p7RkXREAZDusWoTST2x7SkvWFQFAarQ2EEo/se0pLVlXBADZDqsWofQT257SknVFAJAarQ2E0k9se0pL1hUBQLbDqkUo/cS2p7RkXREApEZrA6H0E9ue0pJ1RQCQ7bBqEUo/kT38MCNurKQtf3CTyyoCgEShDimUfmLbU1qyrggAsiMuTELpJ7Y9pSXrigAgEaxDCqWf2PaUlqwrAoDsiAuTUPqJbU9pyboiAEgE65BC6Se2PaUl64oAIDviwiSUfmLbU1qyrggAEsE6pFD6iW1Pacm6IgDIjrgwCaWf2PaUlqwrAoBEsA4plH5i21Nasq4IALIjLkxC6Se2PaUl64oAIBGsQwqln9j2lJasKwKA7IgLk1D6iW1Pacm6IgBIBCuk+9AinGKGwp8YjKTfOga1XUVpyboiAEhU1iGF0k9se0pL1hUBQHbEhUko/cS2p7RkXREAJIJ1SKHIflr44l/5BQ3+S8b8EIkrKCvNuiIAyI64MAmln9j2lJasKwKARLAOKZR+YttTWrKuCACyIy5MQukntj2lJeuKACARiGlRiQAAQABJREFUrEMKpZ/Y9pSWrCsCgOyIC5NQ+oltT2nJuiIASATrkELpJ7Y9pSXrigAgO+LCJJR+YttTWrKuCAASwTqkUPqJbU9pyboiAMiOuDAJpZ/Y9pSWrCsCgESwDimUfmLbU1qyrggAsiMuTELpJ7Y9pSXrigIYGg6rNhvSlu/XYBEpZbSkdwat7SktWVcEANmqNRuE0k9se0pL1hUBQOZwLSSUfmLbU1qyrggAMkSdFl7TK695ljMs+kMohlgcYdtTWrKuCACyqNOqQukntj2lJeuKACBtwAILpZ/Y9pSWrCsCgCxiWlUo/cS2p7RkXREApA1YYKH0E9ue0pJ1RQCQRUyrCqWf2PaUlqwrAoC0AQsslH5i21Nasq4IALKIaVWh9BPbntKSdUUAkDZggYXST2x7SkvWFQFAFjGtKpR+YttTWrKuCADSBiywUPqJbU9pyboiAMgiplWF0k9se0pL1hUBQNqABRZKP7Ht8RZ3D81fHOP7Z1Agi5hWFUo/se0pLVlXBABpAxZYKP3Etqe0ZF0RAGQR06pC6Se2PaUl64oAIG3AAguln9j2lJasKwKALGJaVSj9xLantGRdUQLhDQH2O5AcFhSWvPGjhYDxbgm4xWoePMAByWXbm3ojUM0QYWPJW41f8x/GQh1/OhUw6TBTZJ5AgxRruVdvBKoZGmwseavzr86/MBbq/NOpsCzMP3/RKTOZT/WY3QJUE0Lcw8aStzr/6/wPY6HOf50Ky8L8l7nb3mN21/nPS5tmwyQKNpa81fXPrn/xvBJSwqmTDKUHGnpmQf4ke+VevRGoZmiwseSt5t/mX9McMsMZ4i8EmM7ghIUHTMhdVN0O2ZV6VDMc2FBHzf+g/HN2ZLN5y1Z4IcGq+Q8ZqesvJwFDI0mMkDr/JCHLz/rD59bU2th0vOmlrj9hLiyF+w+8ZQ8TNJ5XMT2D0UCjeSvKQqo3AtXgLuph8/Iz/iUJyAlL3mr76/wPY2EpzP86/ur8m4j1Z7j15hmsdZzvuv5pzuMErOv/klz/h8LrKsKXIDEIYw907roZsEL6onwBJR9M8AcRcrEbGYGO9b3/xrioK6g8NPyGuJCFt8av+Q83WTyh6vir80/Xj7r+1PU3DIY4HuKpo/v8Yc8m3QxYIW2JsOosxfOP/Z2quAKGnX01VT3/Tu3+55G4NMdfjV/zX8ff1Lv/yV80i2eVeMLLH1xEVXe1/ye+/92HFvyBUrjmwG8d1/xPfP7zw6t4Naljn0HNf81/ff4l54kwEvLzu3C7VO8/2vcfcazEdKWchbUcW88dZnALN9UGepR1/Xl864+cW00fmP6QRKNXIF366/q/FJ9/cE/U8f/4xr8dzT0jPFDq+hNGWsqDzVgdf3X+dc8/uSYM8yZOnfDZVHzDHiv9W88ICwXq/Kvzr2d0jOH8G98Q4KpTRUH/KE0eMPl6iT9/hdSCIKjBA+dWRYEnd2hgIi6kUkFQgwfOrYoCT+7QwERcSKWCoAYPnFsVBZ7coYGJuJBKBUENHji3Kgo8uUMDE3EhlQqCGjxwblUUeHKHBibiQioVBDV44NyqKPDkDg1MxIVUKghq8MC5VVHgyR0amIgLqVQQ1OCBc6uiwJM7NDARF1KpIKjBA+dWRYEnd2hgIi6kUkFQgwfOrYoCT+7QwERcSKWCoAYPnFsVBZ7coYGJuJBKBUENHji3Kgo8uUMDE3EhlQqCGjxwblUUeHKHBibiQioVBDV44NyqKPDkDg1MxIVUKghq8MC5VVHgyR0amIjLUn8yIPD5URx/JYov0Ls2lI8+VRR0FXE2MG38+D0ssECAXkjnVkVBwW6rYNb49fqrXn/W62+sA7pSYIFQgwfOrYoCT+7QwERcSKWCoAYPnFsVBZ7coYGJuJBKBUENHji3KgocOX8hAI8i5CcD0rONev+3hO9/5fcoQ19xd6WHQyMj/CDKdFt3VyrBuVVRoLw+ACbGHaTyQVCDB86tigJP7tDARFxIpYKgBg+cWxUFntyhgYm4kEoFQQ0eOLcqCjy5QwMTcSGVCoIaPHBuVRR4cocGJuJCKhUENXjg3Koo8OQODUzEhVQqCGrwwLlVUeDJHRqYiAupVBDU4IFzq6LAkzs0MBEXUqkgqMED51ZFgSd3aGAiLqRSQVCDB86tigJP7tDARFxIpYKgBg+cWxUFntyhgYm4kEoFQQ0ewI1zazyXBkrf/ZovLUt/Pf/m696x5j/mFZ0RTqj4st2i+gNFEBdS+wkENXjg3Koo8OQODUzEhVQqCGrwwLlVUeDJHRqYiAupVBDU4IFzq6LAkzs0MBEXUqkgqMED51ZFgSd3aGAiLqRSQVCDB86tigJP7tDARFxIpYKgBg+cWxUFntyhgYm4kEoFQQ0eOLcqCjy5QwMTcSGVCoIaPHBuVRR4cocGJuJCKhUENXjg3Koo8OQODUzEhVQqCGrwwLlVUeDJHRqYiAupVBDU4IFzq6LAkzs0MBEXUqkgqMED51ZFgSd3aGAiLqRSQUgGPs/jnMIm9xNvylWg1fQBMBEXUvkgqMED51ZFgSd3aGAiLqRSQVCDB86tigJP7tDARFxIpYKgBg+cWxUFntyhgYm4kEoFQQ0eOLcqCjy5QwMTcSGVCoIaPLDu1k8GiNNScMGZbK1ovvK2luuKKOz028FtcnyuwR9fyMMNIYiWbDW+PPXvyF23KecyorCr+bejy2dNspVzxl5nq+Ovjj/3tNWPn7aWx1JEYVfnX51/fEHYtbm1JhGcbZTrT3y4ZK86Q114GVAdf3X8TfT4y2NbRi/rEYVdHX91/NXxl2eIRW6tTw5nG+X6n+uU0qxHFHaPZ/7Jhxah9+Jb5aTSwR9cjG/89rfNc0u70dSOjw+R+AkTfsbB98fUbn93n1trbT/ONjETYfd45n+dfyGB9f7PTrBF4Dr/Rjv/hqaFn3/h83vc8FM86byNZ6JL+fy/PM3//GU7vlpNX6iv+a/rX13/0xo1GlHX/9Gu/5xNyVbOWctW159lfv2Jb28NHStnFT7l45xf+7+Ofx4XS2/+F18IMAeiUAGvTe5QsTZFhqdFbt4NdGaarV2LKIg8q9X4sjbGnNjEmIwKHOg0bMNTqKDmP2TAZqOOvzr++N4gjgk7MMyMEjjQadiGp1BB5Fmtjr86/vrGn35QoJedYZzygBm4mdGlUEEdfyEDNht1/tX51zf//DSzo8Z7vGZ4ChVEqtXq+Kvjb0mPP5xXYlwejGHDF83iqUZMxd6O2sLlVMNTqCAyrVbHP94ElB4tJdE+z9usuYQXiuEpVFDzHzJgs1HHX11/l/T6W8dfGHNp1Zpq829aGEzcv9hkHbc9Xtcfm42J7n/+4CadUmOXcH8syfgy0G3E2v82GxPd/zX/POxtxr1W81+vf+r1T5oTfprgFJ6kd+oXzdL0yvdrhqdQQazLanX+1fk33vOv+EJAseCHIYiL7zSyjZChaQeocbZgyY56R2FrsrhVYTpRDebkUsLL7IiyqkRrslgJCsQ7mKPk1tHGch2FrcniXBOQeAdzwEW/ZnZEWVWiNVmsBAXiHcxRcm1/SIX95k/MW0fyrMninEkg8Q7mgFv7v8xW1DuSZ00W50wCiXcwB9ya/zJbUe9InjVZnDMJJN7BHHCXv/zjgxvOAB5q2N+qinnrSJ41WZwzCSTewRxwl7/855YLKrMV9Y7kWZPFZX3tjLYZ1iJ15RojyqpSrcliJSgQ72COkuv5P6Sinv/zaIkoqzpQrMliJSgQ72COkuv4C6kYj/HH5xWcT5Dd/EADlrYseyvqHZ1nTRYvusY2w1qkrlxjRFlVqjVZrAQF4h3MUfKEjT89z5tO6eqP8mij3nHw1mRxbgmQeAdzwG2frWK5jsLWZHGuCUi8gzng1vhltqLekTxrsjhnEki8gzng1vyX2Yp6R/KsyeKcSSDxDuaAW/NfZivqHcmzJotzJoHEO5gD7ujyX67l7lXCuaqExj8+V2zbY3ErfOuM1mZYS3m0Ue8IYE0W27oEi3cwJ5cq2VHvKGxN2h/pisefV8sac6wuVLKjboOlQtZkcbtO8Q7m5FIlO+odha3J4lwTkHgHc8DFuMrsiLKqRGuyWAkKxDuYo+TWaI3lOgpbk8W5JiDxDuaAW9tfZivqHcmzJotzJoHEO5gDbs1/ma2odyTPmizOmQQS72AOuDX/Nls4r+CWzZ5XbD4tzpkEsjXC1i9LdtQ7AliTxe2axTuYk0uV7Kh3FLYmi3NNQOIdzAG3jr8yW1HvSJ5+IaDDl7LJ34qUXyGWjxaCWckKcuYj6rOzEz5IKeo1scFT49f824eZOoQysAMm4P7RlH2e4zVbXR3/df7V+Vfnn1khFCqwC8akWH/k9ZPpkjOK0IPNiDk2f+xes82p619d/+r6V9c/s0IoVGAXDLPGFOaoogykcLxmy9X1ZzKtP/F1h+Gd43JmCUcWAP9mvd/6e7NefyM3kI9v/E8Lr5lu+B3w8Z6H6+Lz/MIoWWtviAspDK/ZUnX+Tab5F3tGO0uB7bCA++xMgw9SinpNbPDU9tfrn3r9Y2aIQgV2wgTcZ2cafJBSlLVpQ+EnA4Ifq7l8UFDX36W1/uCDG3nuHfqB/ySTN+06BWLXfZ/dFvYcr2lFAdT+X1r9L71Q81/zX8//9fxvVmiFCuyCHdds/ay08PB6Lvds7Eh30eG80ldTXf/r+rsk19/whQB+msMDM206MhXA05KegY4r62E9MNMP1+E1F7kyX0ueGYU9F1DkGTW+DJyUHpecoNT8x2Fex19Ig5nucW7W+a9rSl1/Qiri+HALSM6PQZ5R19/JtP7mhxnSndxX/ECjrn91/avrv1nE8oIvRl3UFFiyw55R17/JtP75bg09Va9/44ng8a7/9ryCyeA/uEhWNzlq/idq/PFrpv3GXwgIX/yr+U/XsZydOv4mavzl0VfPf/X8J18Ui+tRXX8We/1x59YwseKjWb+4O82lOKxxdfyN7/iLr3Y2GdcvBCRbzb8Z4nX81fkXHhzq9YCbHEGp91/jcv9llqMw3ur80/G2DK0//IWAeE/CB89Tg2/KsWmnKoCnJT2jnv/r9c/jX3/1DQFxZObl3EyvYqDZYelHpHpKM3SRdq9FAgBLbDlqRpYdsS+i7tIMXaTda5EAwBJbjpqRZUfsi6i7NEMXafdaJACwxJajZmTZEfsi6i7N0EXavRYJACyx5agZWXbEvoi6SzN0kXavRQIAS2w5akaWHbEvou7SDF2k3WuRAMASW46akWVH7IuouzRDF2n3WiQAsMSWo2Zk2RH7IuouzdBF2r0WCQAsseWoGVl2xL6IukszdJF2r0UCAEtsOWpGlh2xL6Lu0gxdpN1rkQDAEluOmpFlR+yLqLs0Qxdp91okALDElqNmZNkR+yLqLs3QRdq9FgkALLHlqBlZdsS+iLpLM3SRdq9FAgBLbDlqRpYdsS+i7tIMXaTda5EAwBJbjpqRZUfsi6i7NEMXafdaJACwxJajZmTZEfsi6mZz/qBArjp5vzBceOKbvu2i3pKjZqQBAHwRWIuW5JYJ3e61SAC+shz1/7N3NWpO5Lrywr7/Ix+4+nGVSrZ7BrLADqD+dq1SqWxPFNnuZEKmkKoD9y4M7zT8tNqyiwGokqtZC6k6cO/C8E7DT6stuxiAKrmatZCqA/cuDO80/LTasosBqJKrWQupOnDvwvBOw0+rLbsYgCq5mrWQqgP3LgzvNPy02rKLAaiSq1kLqTpw78LwTsNPqy27GIAquZq1kKoD9y4M7zT8tNqyiwGokqtZC6k6cO/C8E7DT6stuxiAKrmatZCqA/cuDO80/LTasosBqJKrWQupOnDvwvBOw0+rLbsYgCq5mrWQqgP3LgzvNPy02rKLAaiSq1kLeSS/ISA16/2M/oaGhfpI5evMu6ZUOXbNWigj0p6DRHCn4afVVsbafuqatZCqrxMtAeaDHr7ODA6aVx9/PB/xut3P9hxl/6ppzPUz5pe3DPhQMB8I+DO/v4GrWUCG3CJLyVXVFVJ14N6F4Z2Gn1ZbdjEAVXI1ayFVB+5dGN5p+Gm1ZRcDUCVXsxZSdeDeheGdhp9WW3YxAFVyNWshVQfuXRjeafhptWUXA1AlV7MWUnXg3oXhnYafVlt2MQBVcjVrIVUH7l0Y3mn4abVlFwNQJVezFlJ14N6F4Z2Gn1ZbdjEAVXI1ayFVB+5dGN5p+Gm1ZRcDtn/HNwQUd/2gXYX3H5kRzAcCvs4MDpp9sHrUhUq70DlIBHYaflptdUSokqtZC6n6OtES9JHqkenMu6ZUNf/nT/+YY8o4WNcH7dYcYc5BrjRkabV9HqwedSFVXydaAswHPXydGRw0t8efv16Y+dsvmiphe8oY2XMLf/I/9z9z/6ergEvGAFZJcrXrFFJ14N6F4Z2Gn1ZbdjEAVXI1ayFVB+5dGN5p+GlxzuPVms0cHwiA6ufPX6uQP7KBmT8P+r87//GBAPyrkVb6Uh8oZBaSxKKQwrcCb7wn1oj1ybBM872d+S2zkT659ZBcJpRWYpN/S0bkY+pv1p/tL37O8vLaMKJxDBLM/jP7z5+2//Z/beJ7o53uXuiXa+p/6v9Pq/8s89n/5/yb8/9H3v/kueI59bW1VtkX+xfpuYGY1QNm1t/PXn/tnF+pr3N+8v+z8x+LwNfB1H/uB7P+ZQOc9Tfr79vvP7CXx1bipbNer8X2st7cCZwEdvu17myexnvYiHn/Y7snkeWJDFqabq9/Pn/OX9+5zLc1/6BdpLjl2XPsgsn/1N8qFDN5eW18+/qf37/M7z/4b3xlj0korcRyj7dqm/1n7cNYe24tUR9w/eGcx0/qf3Lvdv7gtbQ883P+WNL8rQfkZurfa9zz8YPuP+ym04c7r5Z0Dyuxji6lOIIca4wTrGHEZ78NHBIlZv44OjUlTN/kn7cVzA/B1F+kQvLButnAIVFi1t+sP7t11ZJg+cz+8xH2n3/sBsGfHr3iqI/n7PrEqbQf9xHRPrP+Z/3P+p/9zzYGf6e0XbP/f4T9P54WbtkE//r+V9/M8Dn8/Zb+1cbz/P/K5//TP7IA7Wl2L78JyJ8c+z/CBP/6+bcR7Zrzf87/Of/n/LetQLaf2BqwN+Q2MfvPd+y//q1uvlNn0myPbW/Nyh6OHCsV/byZ8/dHnb+f8NXOK7f1fMz5N+ffnH9z/tnGMOff2h1h5vx57/zRD5p51upcQQ6dtP9bbSkx58+cPz/n/Dn+ZEAvu/N+PktWVAHT99avquPSAcGmUtuMaJyYAHohAqbvrV8zf+ZBdxVkDBaKspVD5I9aAqiFCJi+t36h/8xfeQKCzUxpmxGNExNAL0TA9L31a/KfeZj6qzoBgkWGymZE48QEUAsRMH1v/Zr6yzz8l/Xnv7jx5wHPlFu/8YSPn7BsRjROTAC1EAHT99avef4zD5X9QpI5iJatHCJ/1BKgixAB0/fWL/SvWQtJzxSzrTHQn1oCiIUImL63fqF/zVpIeqaYbY2B/tQSQCxEwPS99Qv9a9ZC0jPFbGsM9KeWAGIhAqbvrV/oX7MWkp4pZltjoD+1BBALETB9b/1C/5q1kPRMMdsaA/2pJYBYiIDpe+sX+teshaRnitnWGOhPLQHEQgRM31u/0L9mLSQ9U8y2xkB/agkgFiJg+t76hf41ayHpmWK2NQb6U0sAsRAB0/fWL/SvWQtJzxSzrTHQn1qC/FM07vrlOsfxN+vNU97jNWshGSolbDOicWICiIUImL63fuHnr1kLSc8Us60x0J9aAoiFCJi+t36hf81aSHqmmG2Ngf7UEkBcBD6g4X2c9aveYCodEGwqtc2IxokJoBciYPre+oWfvx51IemZYrY1BvpTSwCxEAHT99Yv9K9ZC0nPFLOtMdCfWgKIhQiYvrd+oX/NWkh6pphtjYH+1BJALETA9L31C/1r1kLSM8Vsawz0p5YAYiECpu+tX+hfsxaSnilmW2OgP7UEEAsRMH1v/UL/mrWQ9Ewx2xoD/aklgFiIgOl76xf616yFpGeK2dYY6E8tAcRCBEzfW7/Qv2YtJD1TzLbGQH9qCSAWImD63vqF/jVrIemZYrY1BvpTSwCxEAHT99Yv9K9ZC0nPFLOtMdCfWgKIhQiYvrd+oX/NWkh6ppitvcXtv4A2gff3D9rFvxz0+NFJiIDpe+vXq/N7Txm5sJIxgxAB0/fWrz9lfv9zPJ/sichXzfY08AMaf8fj56MkyOe3FWTEUuCtX3/K88+HTZCPbx6/JCRg+t76Nc9/5kHrBBmDhaJs5RD5o5YAaiECpu+tX+g/81eegGAzU9pmROPEBNALETB9b/16L//551xN5Z+o8fPlq33D3jptc6QY5q8/f5kLgswLchVexFLgrV/v5b/iqc+2xkA8GYsSQC9EwPS99Qv9tSN6wKZS2xoD/aklgF6IgOl76xf6vzJ//skADCLzxMh+A+RfRWAXQwRBV7PzVx/kst3IJGvYmX/yP/UXiwErpxZiLb0uwNoxWzvDWlsYpS88sMfYs/5m/c3668uLi2WtM5idv/ogl+3mh55/+YsC3wB8Er/8xvN/YTnRT5z/3Et86jUhgjN/7NHICtLiz1Zcs//O/jv7by4Fa+N2hosllwjbnb/6IJfthttijWmCyX+kA5nDL6CZIwPxRjkECFx9kMt2M/lHephDI96pv3o+8AFA+/WFnxvHWDbonL+eBPt/Jacb0ki/JfLd/Jd2DQ1i8p+pbvlAUnriweJpQZfJv2XmnfVfuTJ0vN5ndNU2Mj35j2T1NPzn67/28nzevuJP8ZiLZ66APLcOKVj81Qe5bDeXMUzwF9ff8XzczlU8DUjtmz5EPfFgz+fQIn9x/mf/n+d/6j8P9cc94s39BkGzMQBGWbab2f+RHqTtJ93/67ni2/v//E8G+Jy/aH5ONM+/3gYyLXj6/8bzp74hQIqfCZEa3Wv1pjkzWqrofwwixMzPm7/KWmVUMqXhwBUrtIsicoSFmPxP/teLD60dVAisxoArVggx2IgcYSGm/qb+pv6wXGixQmAZEFCxQvX1kyb0u00LxVc75+uL1bv0evMjQ/MeVZQaDlyxQrsoIkdYiFn/s/5n/e/LZtafZWRtX+33HZqo2kUKadxxRI6wELP/fNP+k+dKPiP+K2j/13P+t3XzWJF8bk/A5N/Se6RHiBfrT99cQsrrXzKCmfqf+vs59ecVVlVcqCov0eR/8v8z9r8/qf78GwJwrxOPy84ErCjYfV39SY8fv/zTx4jHDasx4IoVQgw2IkdYiMv5y7N1PSm3c9XHr1EKYV7YiBxhIS7z69iixJC0FSvE4AIROcJCzPzfdP+759X9ymKhXReRIyzE5H/yP+9/7MuGa0tWyqNGV+Iu+kjrj+fK+iHzA9z2E87zvz9tf+TzXw9SqvqD7P/1gYD6Kc91JT+3yk7hjek9wrPxvtqrg/w3Dff4eocpgzO/bRaXPHG5VOwxVSWJJ2nyP/U36++6qM5N7HFRnYGT0YW3sIlm/c36+5nrL2469d0lKz2+oTH1N+tv7r/m/vN+Uznn336I7z6P9DNwMhQXMNHvev7XmxnrcDETHzRbj+5Pf/z1JDo6H+3J9B7h/cDnP36JtL7WGB/Q4Dl/mfpHz7+/MP3Vj3/m769hJv97RVwWwQ9cf/tsk/89I5P/IwMP9Zdn6+VcfSyqM3Ayx+xxbP2u9x/90ZyP9mR6j/BM9C2Pv+51sqb9g4/9Omc7md7je+Znz8dBz8DJcJQCJvqWx88Oj4OegZPhKAVm/sn/vP8w7z/8pe8/4L1Z/Dma4/XavonuPnfSM3AyFBcw0ez/8/uH2+8f+gcColDkhv7hUwusLKm+hEK4CG5Yb5yyH2PxCEcgg1aoMz9f4k/+rRiYDZYJgRRQQiFWPcWZE7Q3U3+z/mb/mf3XNgLbVrbdIog/5fzBmxm+e+bOZ9b+VtWs/1n/s/7//PVvj7A2uLn/sf1+7v+yJP7d/ud/V9cPlH6u4F8yRqFF6UUDN6w33vXfzR+DoMH4Ma7/TEK4Bm5Yb/68+eP5kGfDnxf+4uIvePzx0ON5/Tuf/3n8vqqx1FHwyf0N63+e/3yu85n/vZ9/vGZb1WsftLO/LTzvfyEdp5Wn+2c8//ptSD75W7+4+RnzP31rHxPxkx//zG8JnvXHcjvA1J/fdMY163/uv7/19efnT5+tZnxvScNzxag/5f1nWRTr5txXiMN5/f+R33/NDwTkbhZPGJpOiScQ2pctxoKVgTolnkCRvwYxFqyM0inxBIr8NYixYGWUToknUOSvQYwFK6N0SjyBIn8NYixYGaVT4gkU+WsQY8HKKJ0ST6DIX4MYC1ZG6ZR4AkX+GsRYsDJKp8QTKPLXIMaClVE6JZ5Akb8GMRasjNIp8QSK/DWIsWBllE6JJ1Dkr0GMBSujdEo8gSJ/DWIsWBmlU+IJFPlrEGPByiidEk+gyF+DGAtWRumUeAJFfsB8c6l+bdN+UQA1xoIFb7ZT4gkU+WsQY8HKKJ0ST6DIX4MYC1ZG6ZR4AkX+GsRYsDJKp8QTKPLXIMaClVE6JZ5Akb8GMRasjNIp8QSK/DWIsWBllE6JJ1Dkr0GMBSujdEo8gSJ/DWIsWBmlU+IJFPlrEGPByiidEk+gyF+DGAtWRumUeAJF/hrEWLAySqfEEyjy1yDGgpVROlUef2lRR8v5RrmM8ybEsLAi7pR4AkX+GsRYsDJKp8QTKPLXIMaClVE6JZ5Al/P5cGz/e5hvMBl+88JYsCLulHgCRf4axFiwMkqnxBMo8tcgxoKVUTolnkCRvwYxFqyM0inxBIr8NYixYGWUToknUOSvQYwFK6N0SjyBIn8NYixYGaVT4gkU+WsQY8HKKJ0ST6DIX4MYC1ZG6ZR4AkX+GsRYsDJKp8QTKPLXIMaClVE6JZ5Akb8GMdayupf7gLWPQ+ik/e8b/Y+4MBasjNkp8QSK/DWIsWBllE6JJ1Dkr0GMBSujOOUfCIhrHazxfFy00u37IMaCld6dEk+gyF+DGAtWRumUeAJF/hrEWLAySqfEEyjy1yDGgpVROiWeQJG/BjEWrIzSKfEEivw1iLFgZZROiSdQ5K9BjAUro3RKPIEifw1iLFgZpVPiCRT5axBjwcoonRJPoMhfgxgLVkbplHgCRf4axFiwMkqnxBMo8tcgxoKVUTolnkCRfxf0cx6v1bzj+adc92NeJhX4XZPexBgLVjSdEk+gyF+DGAtWRumUeAJF/hrEWLAySqfEEyjy1yDGgpVROiWeQJG/BjEWrI3SvyGAw4oC3IWKUPASJCTgPWwxe8FjElhVLu5CzfyWgciLJIeQYPJvacIGvG7xmZNVXZup3DFwoSIWvAQJCThXMVP/mgvmmOASvVCTf8tA5EWSQ0gw9Wdp+tvWf/7rBi6oAPW3nmf/qdXRc5TeJXqhQhu8BAkJZv1Zov629acrDJUA63WjOOqoNZfohYouwUuQkIBzFTPzay5a6iupnX7qELwECQn+qPzvb2b4yv769X+Wq3VnzYdN8Ec9/l4U5sXDrMfKB1uASFTkjvGCUOVSXCiPfLJ/beL/MsXDuPIXSdUBCNZ1itGv7CV6oUIfvAQJCThXMTO/5qLyDnSJXqjJv2Ug8iLJISSY+rM0zf1X33OqOrDm1F6iFyp6BC9BQoJvrj89W/354je9+EQ1XEzLJngJEhKwazHPw+W4qlwzXaiIBC9BQoLfdn79gMbxfOAJ+IMfPx5iPc+NSWcev22uVess9gJEoiJ3yahRqlyKCxWR4CVISMDRirnOID+KKmf+yrOkCDBSJfkiJJj8W67m/qPWXJwrSIjlpj7414oKTtoqpwsvQUKCqT/LGNLt1q/KTvq9vUQvVPQJXoKEBJyrmI87v30gwG477Xsq8GFI/aGRJHCwzgPDQntaVSiG0t7MmPkn/2ul3ivkeUHf9KistKpQDNXU36y/2f9m/z93i9ohfr/9J99c6r8q8D8ZkI8Ej8zt7H+z/83+N/tf7gn3O6Tfb/+rHU4fkWIoZv/7nv2P/2oO6TN7vqEhQb5SdG7y/6PP3/ylBd7uyLz350NzrhjP0dT/99T//obSLaPI7Ho2zOy9VDH5n/zP/dfcf9ku4Unw/9ffqsc+jj0G1ncPYFjdUTpWhWKoZv952n/yXie/CNp/6fvli3/hcV7IJCyyeVpVKIZy8v+U/8pQnqCaPWBYaE+rCsVQTv4n/3P+zvmb+8F9h/ix+0++ZsP+Yx/883NlHSy/Yv6a2dHsf7P/1f4n3xCwSjGMlqXyWUC5PHpZfavHkQ20v5eBW9wQUBUFG/ORIvjWKZuOvQ3M/PpMrsyEYZYm/60uvZQ0N620vslhbwNTf1N/eIHJuooCYZVUvZEi+KZ620XsbWDq78+tv3xzqcrHn2z/QMA8/+s5n/qf9W+b7+y/OCHWzhCGu0RtIKQI0PG7LHsbmPPn96s/P1dizVizfm/xzgcCennM8/9jzx88H57XvPKch7fbyf+Pzf+e3/f8yf/kP/ZPK4Q5/36/88+eNVviddf43nrf4+x9ef792170yg8ErB7a8SfNH48r5uFk9uP8vfN/+lzPs/8j8PzGBs2NPlvfhtnbwKx/XUkrM2GYpb+6/rKiNC/OaG5S8T0texuY+pv6qx1O64xVUvVGiuB7yo5a9jbwt9bfP/Ya2vPgl38QwD8QwHUdCYom4p13SmNL8h2GvQ38rfmPmp/Hf33+5QMBvapYOKC3BPqbQf1TLdIDMKx9AsVuYGvj8QEhwOCnPRRGaAHP/JP/qb9cN7lWZMUAhp31N/vP7L9/2/nz6R97cwm/sVnHK/7FyZy/2CDP+w4wh8KIuf+oF9Bz/zX3X3P/9ffdf332N8l9c4xXdAHijfJ8i2Odstg8w87958+8/8S/NvG1iOOef5Ny8m9lOvX3M+vPd4Jc7lj0JFZg8j/5n9ef3/L6Ex/u8rPVV029Xss1Na8/8q4j9hzbbn72/ad+G5I/f/+zAxbP47z++fn5R679+fZDZur/19b/5D8qL5upv1l/tiCwJv7N/u8fNPMPmNl/dt0/wO0xzBWyqb+pvx9Uf+uFWZTV3vADAcfLNq34vZf5h75pUM6wKwgXNpZElv0x3sxvO0LbErYMny8zS4AEw07+IwNIB+zUn6Vl1p/Xxuw/234y++9vvf9++vRPVLXXtl84SfxFdWx7wT40SxPmDb3+EuIcqXd0z6+Z35MQqXhuVurC9DS2PpN/S+VjLnvi3PNr6s+TEKl4blbqwvQ0tj5Tf1N/vv7aLy6iQrzAUDhu13XQILwk5/6j/drsG++/8IEApNht/Wmgym/E4cLGRpDPz+R/6u+V+tO6K4wCg10RuLBTf5aYWX9eHbP/fP2/z/iGgHV0nufqWke3fFUoonP+riTyle8tLdyIrvX3+fPnN18vzP2v32u0whMH+U8qdznTd1r0ApcmzBv6yf/kf+pP1k2DfeG459esP09CpOK5WakL09PY+vyo/cfP+bn/mddfH+H11yf71wT+TLSrbpP8wLGwV75dyrcOt9gm3tzoHtwloNTMP/mf+pv15xuG7guxgUhzxDZic6NncJeAUrP/zP7zO+4//jPXDesbd7VrDfnNiN+Utmt1C1NN3C7EGjFOX5AtOd+LmvmRH2ampVedyf/U36y/2X90T8BGW1tv7iPYTWp/zV7g2c+I3J8ZacOr82/2n3xDA7/aWqPqTZRRmxui4C4Bpeb+6+37L9ybeELxLHvO9oRrTiP51gR3CSg1+X87/y2XcNxqEk83lJN/q9ktT3vqpv6m/rDHXUol1tFeM7W4GN6XY0kugyr1K+sPjxM/tc/9K+fnvAb8LPHrb54//mSAFUOcq9XwnP0o91/5TNX5jx+wfj7cGUB52n9z/4fROMsCM7+vH88OM4NUHXbyP6//5/V/LJZaG9hHjMkPMiSB1VT7S3YBj+VWcUZq7A39l+vPz1i93POf2K+/+fydx//rn39+Q0BU33Hb3ErTJCjTVB/yoLMPW1/JW7c4JX21HpfO50H1Fa+OFwp9MmTtzD/530vNN+Cpv2P1Ye1UQBeY4ll/kYFLSpDDDFk7+8/sP//B/qNvLsWNsRes1SJfdvnP5EWKS3xRZXSLeUftWkNwdFBhZ/6V6sn/1B/WjqypXCTWrkU162/bRyRXnpvZfz7W/tvf0PAi9udvtXP/81Pvf9rfOV67qz8fk/+pv1iFs/5+6vqL48j2urq48nIXnPxP/v2WRa+H95/wmg33f/VNL94560qHuVHQsQqn/l6uPzwfscY9oXbN/efcf8/rj4/1+iNXZq7N20827z/lqTDv/+FkjY18JWVVz/YeQ6ujLfaj13+9ft7PePUVr5/5QuWDmtffmRpr5/7nu+5/4gMB+imUWiXrLjYyy/RGJa5IvenAV0WpW+VaxmlXX38JaxG7QebNV4zq+pnfs5BJnvx7PUQZVWVkalYbuWo4mWin/iwNs/5m/8HOLWvDK2P23z/u/PHz1J9tO1lz7eMpNzf/ftXimxHH9XYz5buu31OtJkdZMh+6/hZWntix1cowMz+SlamrnLUkrWdJOJdP/qf+Zv3N/hPbguwjgGY/wv7rXzKXl1v/4bYrwtbM678tMen+m/uvfyynyD7Kwsdr1+Tf0jH1N+vvsjd5Zczrnz/u9c/vuP99ij8Z4PtU/vT27a2xbeFrNGIbtxCq2H289b96SDSZaKOjNXP+SlIKPq1/fz7m9e+8/p/3P2ytZBJy0eBG0+xHeP2h+2Lg9fOlwQ+71jt/5iaKPZXvVXnIr3n/Zfa/X/D+y5f/fZn7L96b6Gr2NWj/+yaz7nQMxFp1WywXrERdsa4Y0hrOgUDap/M/ojFJzeRcny1jaySJJhOtS36T15/5DQHbg478+2PAI3f8zhWP2TTRpTlnxyM881viIglV/562yf9ZPA9Mq6nmnB2OcKQ+msm/l92RoDOHO9O6NGdX5kbuLMs7Uh/N5N/z8k7+zoxuOX2n/xGO1Ecz+f+D8v/pH1th+bRWgUjx+PprL4KiMJIVWSzUT/biCJ+aZT8v1HjR5ONE59VtjYGhYNuguf5n/i1XsStqLi1pJpn8T/1hjWXFRFHM+pv9Z+0Yumdse8pyt+139du037n/xC8tbGDM7qN1Z5/1EvbO8/rHkxCp+577v/ylhecUz4Bh/0WSX/FkJNQWSoYn/1N/s/5iwXAp+ILhAtHVc8dtTTXn1B9hTvr96x+jtzGbA0XZIzzzf4j1nx8I8KLLZ+j4YFc9hQdqz2lzDilPCpb3PP/X55/fvmOJmtdf8/oL91i5QqMobKniH15g0fl6SwUM7bYUOY6vyNVFQKljqsn/5D9rjHUz77/9Eevv65cvfsDEvhFtPs25FdQu8CZqXZpzdjvCTsz8noS4N4pUeNp8oX3j1XLanHOAI/yB8v/J/nWHHWl6xU+3CPnRF61RF6X/EMSwFv5qWc6js3p5b2VTrjM49st+wocpkn4IZufoO/Nrple+Jv9Tf7Iqc7mgNtxz7Nesv9l/WhlEVXiT1bJqRkuHihTN/jv775z/uNPCQpn7H10VuWUgN+459mvOnzl/WhlEVXiT1bJqRkuHihTN+aMrDYma/UezkiWD3Ljn2K+Pu//UN+vlT+rt8YskexhT//pM4zme+tesZAUhN1FJSX3g+s+fdv3M+qOvnzyM8VP/+kwjUVP/mpUsGeTGPcd+/Zr9P/Zyf4mwps0/GfDr5veZcnL/Ifz6tY+/5pz5KxeOfk391ZyT/8rF5H/qb9ZfHAWVhlwe1uZpmS00DAJYeO6/9E5j5csSpmymCzH3HPtVideoR9Jf7B50gV/GT/4100jU5F+z4qVi3xDg/5xAPhmBewGPrgvpg/+9tvV3xy/Ok9FomzBl3j7QJXgHtf7u+DXzZx50S2mJWmEzD3QJ3kGt/+Q/szX1t6omqyPaVihVVA90Cd5Brb87fk3+Mw+z/qMYokZaoaz0mHmgS/AOav3d8WvqL/Mw9RfFEDXSCmWlx8wDXYJ3UOvvjl9Tf5mHqb8ohqiRVigrPWYe6BK8g1p/d/ya+ss8TP1FMUSNtEJZ6THzQJfgHdT6u+PXH1J/8a8Y7TH5w8FD2z8Q8Cc//ngu32nm8W/l7vn6Q+r/nac+wvP8b0/3PP9bQj7G+5+f7Sttax+3n+mr/ctBu1r9BvN9Tevvjl+z/jMPc/8VxRA10gplpcfMA12Cd1Dr745fU3+Zh6m/KIaokVYoKz1mHugSvINaf3f8mvrLPEz9RTFEjbRCWekx80CX4B3U+rvj19Rf5mHqL4ohaqQVykqPmQe6BO+g1t8dvx7qL/9kgAtaLyfk8r9J6H9/wYx/nQDHEskTrGFvn8aQXiUUcsGZf/I/9Tfrb/af2X/n/Jnz97xDeGTqtmLuP/ZPg7akVaIaHc7cf83919x/zf3X3H99uPuv+oYAf1Xum7i1vl+vq7b1Of/m/KvvaEJ90FahkCKY83/O/zn/f/r5z6+oXwuP+/isv1l/s/5++vp7fGNl1t+sv1l/s/7sHnl+/2lbAV8YvA/qZcW8/vwdXn9e/mQA70bXM39/+uuJvhSFB3Fdu6/eZh4XWBzCPsh1gDc/v7DeF8mf4Np95o+8Tv6n/mx93JeIFUcErtFZf487kwV8e8F1Td/sP7P/WGHM/jv7r5XBfYuY/XfOHz9ErtUx5+9jZiww568XTl7X8pn7jz/l/qM+EIAn3Mrfv/QP1zz/yITYqf8/pf7lSS0o5X8/Puf5n+ffNkYrg4/0/uP+bS/5DQHXDXzu/2y13zNjgVn/tRdekzT73+x/H2//q6L1NWw1GrV7LeDZ/yxF98x47iSTV9Gs/1n/VhhWBh/p/keqdtb/f7T/8U8GxJOx9gl9YjpVG0nsRj0o3TKAMCwFjRBHILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5Is/u/KvV++EWSyPqbhwjEJOII/Nb5+8C9F4aDRbS/mytRgdB2ankgYSGmzQDCsFt4uRIVCG2nlgcSFmLaDCAMu4WXK1GB0HZqeSBhIabNAMKwW3i5EhUIbaeWBxIWYtoMIAy7hZcrUYHQdmp5IGEhps0AwrBbeLkSFQhtp5YHEhZi2gwgDLuFlytRgdB2ankgYSGmzQDCsFt4uRIVCG2nlgcSFmLaDCAMu4WXK1GB0HZqeSBhIabNAMKwW3i5EhUIbaeWBxIWYtoMIAy7hZdb0f7hrvyTARV1+fJAwnJggAwgDIsohklfogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiBusbAsDDsvcJUvIsPCM7Uz4RAOw5LZmUPAvPyM6UTwQAy9lOkJJn4RnZmfKJAGDPacmk5Fl4RnamfCIAWM52gpQ8C8/IzpRPBAB7TksmJc/CM7Iz5RMBwHK2E6TkWXhGdqZ8IgDYc1oyKXkWnpGdKZ8IAJaznSAlz8IzsjPlEwHAntOSScmz8IzsTPlEALCc7QQpeRaekZ0pnwgA9pyWTEqehWdkZ8onAoDlbCdIybPwjOxM+UQAsOe0ZFLyLDwjO1M+EQAsZztBSp6FZ2RnyicCgD2nJZOSZ+EZ2ZnyiQBgOdsJUvIsPCM7Uz4RAOw5LZmUPAvPyM6UTwQAy9lOkJJn4RnZmfKJAGDPacmk5Fl4RnamfCIAWM52gpQ8C8/IzpRPBAB7TksmJc/CM7Iz5RMBwHK2E6TkWXhGdqZ8IgDYc1oyKXkWnpGdKZ8IAJaznSAlz8IzsjPlEwHAntOSScmz8IzsTPlEALCc7QQpeRaekZ0pnwgA9pyWTEqehWdkZ8onAoDlbCdIybPwjOxM+UQAsOe0ZFLyLDwjO1M+EQAsZztBSp6FZ2RnyicCgD2nJZOSbD9/+my/33Fc1xf71wX9Hwbtg5ZPBABbwx0oJc/CM7Iz5RMBwB6zFpGSZ+EZ2ZnyiQBga7oDpeRZeEZ2pnwiANhj1iJS8iw8IztTPhEAbE13oJQ8C8/IzpRPBAB7zFpESp6FZ2RnyicCgK3pDpSSZ+EZ2ZnyiQBgj1mLSMmz8IzsTPlEALA13YFS8iw8IztTPhEA7DFrESl5Fp6RnSmfCAC2pjtQSp6FZ2Rnyicy8Omf/Fd7mJB/MgDEstmHPbcoPzYg/K4tnwgAVnrvMCXPwjOyM+UTAcDuk4qfkmfhGdmZ8okAYGW+HabkWXhGdqZ8IgDYfVLxU/IsPCM7Uz4RAKzMt8OUPAvPyM6UTwQAu08qfkqehWdkZ8onAoCV+XaYkmfhGdmZ8okAYPdJxU/Js/CM7Ez5RACwMt8OU/IsPCM7Uz4RAOw+qfgpeRaekZ0pnwgAVubbYUqehWdkZ8onAoDdJxU/Jc/CM7Iz5RMBwMp8O0zJs/CM7Ez5RACw+6Tip+RZeEZ2pnwiAFiZb4cpeRaekZ0pnwgAdp9U/JQ8C8/IzpRPBAAr8+0wJc/CM7Iz5RMBwO6Tip+SZ+EZ2ZnyiQBgZb4dpuRZeEZ2pnwiANh9UvFT8iw8IztTPtEC9g0B/t0EekEC2t9aMIzvlkA4WXnjAQFYHbMwowHolYAfX/WYXzP/5N9qYeqPSwGLrq8eeLC5evaW0QD0RAbOrV+z/mb9WS3M+uNSmPWXOwN2iu51NmPVMhqAXgnm/LdcrD03sjL77+y/tk5m/61l4UvCrr57wINNzd4yGoCeyMC59WvW36w/q4UPuv78AwH/98l/vqxWb4+X9BWqNeN674ebGWrAYcCp/6l/q4UPWv/rKLDq1botlmW9AFQppycycG79mvqf+rda+AX1798QsKotKg/f9DL5/zX5j6S3fWTW/+x/s//P/jP7z684/2b/9Qz4fafeBcz+M/vPr9t/PtnfG7R/ToAizCV5a+8KsLC9p78xkV+D5f+GIW92Q2Fy3F8/vzDbxjLXl0a/MC/sFp35J//2Iss3lKm/WX/cP2b/mf3XiiHqIY6O+/mhp8ldARZWe9iuM+fPnD9z/sz5O/cfc/81r3/q9Zsdl/P678fcf3zyDwTg8l8o2T2Hv6T3a+4/5v2Hef9lXv/P+x+/x/s/sVajXFfNrn089nJr4vWqO7zwuhOWgQCz/8/+P/v/7P+z//8e+3/fvbv3sMObKOv7ejrM+4/z/uO8/2hrZNb/t/7+M74hoG02dAj6znTxoPT7V68/WEohINFBC9Mh6OKLByXmhaUUAhIdtDAdgi6+eFBiXlhKISDRQQvTIejiiwcl5oWlFAISHbQwHYIuvnhQYl5YSiEg0UEL0yHo4osHJeaFpRQCEh20MB2CLr54UGJeWEohINFBC9Mh6OKLByXmhaUUAhIdtDAdgi6+eFBiXlhKISDRQQvTIejiiwcl5oWlFAISHbQwHYIuvnhQYl5YSiEg0UEL0yHo4osHJeaFpRQCEh20MB2CLr54UGJeWEohINFBC9Mh6OKLByXmhaUUAhIdtDAdgi6+eFBiXlhKISDRQQvTIejiiwcl5oWlFAISHbQwHYIuvnhQYl5YSiEg0UEL0yHo4osHJeaFpRQCEh20MB2CLr54UGJeWEohINFBC9Mh6OKLByXmhaUUAhIdtDAdgi6+eFBiXlhKISDRQQvTIejiiwcl5oWlFAISHbQwHYIuvnhQYl5YSiEg0UEL0yHo4osHJeaFpRQCEh20MB2CLr54UGJeWEohINFBC9Mh6OKLByXmhaUUAhIdtDAdgi6+eFBiXlhKISDRQQvTIejiiwcl5oWlFAISHbQwHYIuvnhQYl5YSiEg0UEL0yHo4osHJeaFpRQCEh20MB2CLr54UGJeWEohINFBC9Mh6OLNiw8E8BsC8s3BL1/8FyEifGeoFqZDIAPdIZR43LBUQ0CigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKKDFqZD0MUXD0rMC0spBCQ6aGE6BF188aDEvLCUQkCigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKIDhPOXt/UrHv+F/rdc6I95YdkXAhIdtDAdgi6+eFBiXlhKISDRQQvTIejiiwcl5oWlFAISHbQwHYIuvnhQYl5YSiEg0UEL0yHo4osHJeaFpRQCEh20MB2CLr54UGJeWEohINFBC9Mh6OKLByXmhaUUAhIdtDAdgi6+eFBiXlhKISDRQQvTIejiiwcl5oWlFAISHbQwHYIuvnhQYl5YSiEg0UEL0yHo4osHJeaFpRQCEh20MB2CLr54UGJeWEohINFBC9Mh6OKLByXmhaUUAhIdtDAdgi6+eFBiXlhKISDRQQvTIejiiwcl5oWlFAISHbQwHYIuvnhQYl5YSiEg0UEL0yHo4osHJeaFpRQCEh20MB2CLr54UGJeWEohINFBC9Mh6OKLByXmhaUUAhIdtDAdgi6+eFBiXlhKISDRQQvTIejiiwcl5oWlFAISHWj4+JMBGVSJf77Cb1IXd8zWBz+9GiuQNfzXIae4z7XiOcIaZ+bPT11ccnenVt4sGMiayX++6LrlK7NVOXNN46b+pv7au623KlKuaimQNbP+Zv3p+/VntVTNeCy9xc3+M/vP7D+6ZN7BtZYCWTP77+y/s//el02ullozrmrcnD8f6vzBL5H8HwrhcwH9F0n1XAayZva/2f9m/5v975aBttcvQeNm//9p+/+nz/ZtL57fuOwd169fAk3+fb/OLJz/2myl69GsfhYPZM2cf3P+zfl3XzC5WmrNuKpxs///tP3/yPV6iib/s//P+bf2pNl/fur+s30gQGTJ3KYAAEAASURBVA4CQoLYntTDcxOcBtZGVubNYMlw0+cMuxCETr2ZP2sjcqKJkYwmfDMoatEREkz+LQOajam/qb/4RhSri7f/6opWjSy3A4qOkCDU6k39Tf1N/a09WRfGW+vqiCkhgxASzPqzDGg2Zv+Z/Wf2n9l/Yk/QjUG31GPXPIJCyCCEBMdIs//83/99/uxvbfv/lqdl+gcCPG09h87cL9EREkQX9Sb/s//P/j/7f+wJujEcm8ubQVGLjpDgj99/Ptti8keLK/fxv+fxt3OKD5sg0qLenD9z/sz5M+dP7Am6MWADpX0zSNXsP5InQoLZfy0Dmo05f+b8+dPOn+0DAVvB2wJ4+iQdlLpAZGc9YOpKHahc6pVSTAFBRt/WULwWcqkDlUuhUoopIMjo2xqKZ35LBT/lZDjydkmeUoork0AZfVsD7Vmt0e/SWSnFNRJQRt/WQDvz79kK/5I8pRRXJoEy+rYG2sn/nq3wL8lTSnFlEiijb2ugnfzv2Qr/kjylFFcmgTL6tgbayf+erfAvyVNKcWUSKKNva6Cd/O/ZCv+SPKUUVyaBMvq2BtrJ/56t8C/JU0pxZRIoo29roJ3879kK/5I8pRRXJoEy+rYG2sn/nq3wL8lTSnFlEiijb2ug/Xn5128IiBdVNuX5gYCfN/9//fhn/rfeo/n59Tf5n/w/v0c49YcM5Dqp1RKo3JDte/kX+43Dc273ETHT3e7q2/zeU38kxeeo+4inQpldHf5lAqUU61iJM/q2pnrt6vAvnZVSXCMBZfRtDbTIa6kDlUuhUoopIMjo2xqK5/1nS8W8/1zVEqhcFopSiikgyOjbGoqn/iwVU39VLYHKZaEopZgCgoy+raF46s9SMfVX1RKoXBaKUoopIMjo2xqKf5v64wcCnh/YV3swn1oxrUdnj/ap1xPvCUIMNpPWveQQmfkn/7qZsYQKaMEYfq6minVN93S4qf9Zf7P+Zv3JDkFIoBvG7D+z/1oNPL2Vh5qBzdLpnpbTnD9z/sz5M+eP7BCEBLphGH7iXYYYbHbtXnKIzPr7uOvvs33N9Ff/DuR4Xv0Zs5Xy9X9h3TsvPNOwqeie9przZ+r/49b//T7ruZpn/0NuYGf9ewZ6Nv6b/e/zJ/uTAfaTYDfHNwTM/jP7z9z/ygolJNAF++ZqrpXe+3ZPh5v7n9l/Zv+Z/Ud2CEIC3TBm/3njbmr2X9QMbJZO97Scfu35Yx8I+GI/i7x5zZ+MQH+6hrsCP/iStKA56w834Ws2aqAmrHp5s6iyd+858+fBPfmPDLTimPqb9Wd7nP03+4+lQbZ72XC3TbUtoLWpdNMVs//O/usvnNbVimP239l/Z/+d82fO37n/mPuPH3n/5V8z3S//QID97ek5f+Vtjbn/mPuPuf+Y+4+Pff/BbwjwDd3KNd6a7Zt789oWbxv+vP6c15+8G2jFMeffnH9z/s3597HPvzjcuG8RtDNPna6Y82/O/zn//+35z28I2N5BkNvLbaE9r0hG+kKtkZPXll0M9F41ayFVB+5dGN5p+Gm1ZRcDUCVXsxZSdeDeheGdhp9WW3YxAFVyNWshVQfuXRjeafhptWUXA1AlV7MWUnXg3oXhnYafVlt2MQBVcjVrIVUH7l0Y3mn4abVlFwNQJVezFlJ14N6F4Z2Gn1ZbdjEAVXI1ayFVB+5dGN5p+Gm1ZRcDUCVXsxZSdeDeheGdhp9WW3YxAFVyNWshVQfuXRjeafhptWUXA1AlV7MWUnXg3oXhnYafVlt2MQBVcjVrIVUH7l0Y3mn4abVlFwNQJVezFlJ14N6F4Z2Gn1ZbdjEAVXI1ayFVB+5dGN5p+Gm1ZRcDUCVXsxZSdeDeheGdhp9WW3YxAFVyNWshVQfuXRjeafhptWUXA1AlV7MWUnXg3oXhnYafVlt2MQBVcjVrIVUH7l0Y3mn4abVlFwNQJVezFlJ14N6F4Z2Gn1ZbdjEAVXI1ayFVB+5dGN5p+Gm1ZRcDUCVXsxZSdeDeheGdhp9WW3YxAFVyNWshVQfuXRjeafhptWUXA1AlV7MWUnXg3oXhnYafVlt2MQBVcjVrIVUH7l0Y3mn4abVlFwNQJVezFlJ14N6F4Z2Gn1ZbdjEAVXI1ayFVB+5dGN5p+Gm1ZRcDUCVXsxZSdeDeheGdhp9WW3YxAFVyNWshVQfuXRjeafhptWUXA1AlV7MWUnXg3oXhnYafVlt2MQBVcjVrIVUH7l0Y3mn4abVlFwNQJVezFlJ14N6F4Z2Gn1ZbdjEAVXI1ayFVB7Yunz77WwD+v78dlKPsXzWNkXVmcDFONJ2pWQuVdqHeheGdhp9WW3YxAFVyNWshVQfuXRjeafhptWUXA1AlV7MWUnXg3oXhnYafVlt2MQBVcjVrIVUH7l0Y3mn4abVlFwNQJVezFlJ14N6F4Z2Gn1ZbdjEAVXI1ayFVB+5dGN5p+Gm1ZRcDUCVXsxZSdeDeheGdhp9WW3YxAFVyNWshVQfuXRjeafhptWUXA1AlV7MWUnXg3oXhnYafVlt2MQBVcjVrIVUH7l0Y3mn4abVlFwNQJVezFlJ14N6F4Z2Gn1ZbdjFg+3d8Q0Bx/RsCiifCwCQS7DR8nRlcde1MPepCpV2od2F4p+Gn1ZZdDECVXM1aSNWBexeGdxp+Wm3ZxQBUydWshVQduHdheKfhp9WWXQxAlVzNWkjVgXsXhncaflpt2cUAVMnVrIVUHbh3YXin4afVll0MQJVczVpI1YF7F4Z3Gn5abdnFAFTJ1ayFVB24d2F4p+Gn1ZZdDECVXM1aSNWBexeGdxp+Wm3ZxQBUydWshVQduHdheKfhp9WWXQxAlVzNWkjVgXsXhncaflpt2cUAVMnVrIVUHbh3YXin4afVll0MQJVczVpI1YF7F4Z3Gn5abdnFAFTJ1ayFVB24d2F4p+Gn1ZZdDECVXM1aSNWBexeGdxp+Wm3ZxQBUydWshVQduHdheKfhp9WWXQxAlVzNWkjVgXsXhncaflpt2cUAVMnVrIVUHbh3YXin4afVll0MQJVczVpI1YF7F4Z3Gn5abdnFAFTJ1ayFVB24d2F4p+Gn1ZZdDECVXM1aSNWBexeGdxp+Wm3ZxUDy8YEA/KuVNjVGoVQGklgMFL69HdF4n8yI9c0A7j1dM7+9pRPpk8/4SC4TSiuxyb8lI/Ix9Tfrz3YYf1eUl9eGEY1jkGD2n9l/Zv/1bXTOH37GVM7YhNJKbM5fS0bkY87fOX/tSG1nrdfGnL89J7ztIJj7j7n/ePX+o/2r0lVR+Yskd2b9zf4z++/svzxqrmDOn49x/mAvj7PAt25/YuzyFl/ZHDiJiOUe74K5/5777yiUVRdurFDm/tsXz5vX7H/YPub9n3n/Zy0WOWMSSiuxOX8sGZGPOX/n/LVjpp01XhtGNO48ij7U+WM3nV7O5xVFrrQS61cHSlEqv1ZgnGAtHvHZbwOHRImZP45uTQnTN/nnbQ3zQzD1F6mQfLBuNnBIlJj1N+vPbp21JFg+s//M/rNeVrE+CGb/jVRIPrhuNnBIlJj9d/bf2X/n/LE943ixOefv33T+fvpHCsCOCPf+Zy/pg+WRQTDnb6RC8rEdu3QPiRJz/s75O+fvnL8/9vz1P//iu0zu4rbHtLdmZ/+pm53Zf2f/nf139t8fu//G1otGt9vglJj9Z/af2X9m//nz9p/jTwb0bW/dgim5b44RS4G3ftVbFNURCDaV2mZE48QE0AsRMH1v/Zr5Mw/r3Z9wkDFYKMpWDpE/agmgFiJg+t76hf4zf+UJCDYzpW1GNE5MAL0QAdP31q/Jf+Zh6q/qBAgWGSqbEY0TE0AtRMD0vfVr6i/zMPVXdQIEiwyVzYjGiQmgFiJg+t76NfWXeZj6qzoBgkWGymZE48QEUAsRMH1v/Zr6yzxM/VWdAMEiQ2UzonFiAqiFCJi+t35N/WUe/ob6478qtYeM579+kZR14dkAgkWGymZE48QEUAsRMH1v/Zr6yzxU1gtJ5iBatnKI/FFLgC5CBEzfW7/Qv2YtJD1TzLbGQH9qCSAWImD63vqF/jVrIemZYrY1BvpTSwCxEAHT99Yv9K9ZC0nPFLOtMdCfWgKIhQiYvrd+oX/NWkh6pphtjYH+1BJALETA9L31C/1r1kLSM8Vsawz0p5YAYiECpu+tX+hfsxaSnilmW2OgP7UEEAsRMH1v/UL/mrWQ9Ewx2xoD/aklgFiIgOl76xf616yFpGeK2dqvWD5/DqH3939Y9uWL/9rFHfu/Bu1ExFLgrV8lrY5AsKnUNiMaJyaAXoiA6Xvr18yfedAnDhmDhaJs5RD5o5YAaiECpu+tX+g/81eegGAzU9pmROPEBNALETB9b/2a/Gcepv6qToBgkaGyGdE4MQHUQgRM31u/pv4yD1N/VSdAsMhQ2YxonJgAaiECpu+tX1N/mYffsf7yTwbgSZTnOR4SvsvAHIYI8KCX3fmrD3LZbmQSjGkC/yosu9CzwNLAULCIqw9y2W5kEoxhgpk/koHMTf4tHbXjrUIxwwQt6uqDXLabyxgmmPqLhCJzR57xDFAw+e8J03wgSct2M/WH9LCmjJj118tpzxFzZUD3xV0XPshlu5n6Q3qYUyOm/qb+LAMsDQIUybI7f/VBLtuNTIIxTTD1F8lA5uqJmPy3DDBBqB2zx3kA0bLdTP0hPUjsN7z+xgcCPNmebv+3S/GBgGMsfz5A9sSDPWr7G+bHj3r29fkYXc8tZpr5Izk9DVP/KA+UzdSflUkuIqaGAEladuevPshlu5n6Q3qQ2l9cf7WX5w/w9cuXef6n/qMYWJoEKNJld/7qg1y2m1n/SA9S+4vX/3kPZT/Q1P/Uv2WApUmAIl12568+yGW7kUkwpgmm/iIZyFw9EZP/lgEmCLVjdl7/VYoiP0jSst18iPVX3xAgh189ivoZ8VA0BlyxQojBRuQICzHzc/NFztwiQ7AaA65YIcRgI3KEhZj8T/7X4Y+acYsKgdUYcMUKIQYbkSMsxNTf1N/UH5YLLVYILAMCKlZIwgEjcoSFmPU362/W375s5vyzjOQvGtMeCTKidpFCuy4iR1iI2X9m/5n9Z182XFuyUppm/yWSB+sbAko668+W15FEIWb/mf1n9p/aMBbCCoE9BEZUrNCui8gRFmLWX3xDAO61PH++jyNDsHteQ2fN9rGRQxb9j0GEmPzP/jf7333dGCsr5VHzlmrW39x/zf2nLR39JbGuqjl/5vyZ8+fxbPlV5099IEB/lH323af2DJwMxQVM9NV2x/w3DUUT7YPs/qPwrSOZnUI080/+p/7a6VwLZF9vu0/lGTgZiguYaNbfrL9Zf7P+alMQtG8iu0/pGTgZiguYaPaf2X9m/5n9pzYFQfsmsvuUnoGTobiAiWb/mf3nR+w//jXTn+z7pddfNQ17+0BAFZ+hqb9Zf/P+y7z/1N+dry1iP8R2n8ozcDIUFzDRnH/n+Zcf7vJ7MkuQma/2JwPiekzqGTiZSjuRiSb/Z/41P21pPCb1DJwMRy0w+Z/6m/N3zt+2ydT24Nt/C+0+pWfgZCguYKLZ/2f//xGvP3uhxp1LK90qOkFTfx92/fUPBMQTJU/xw6d2+NTK7pNQCBfBDeuNU1aGi0c4Ahm0RM38fJt28m/FwGywTAikgBIKseopdqegvZn6m/U3+8/sv7YR+BsuaXxbyMuIOX/m/OWJM+fvnL9z/4Hd8bSygSYUwtVww3oz919z/zX3Xz/y/uvTZz+t/P9cX46++LnlV6w72Fl/mZKpvx9Zf1F6KDEWnGfarqm/WpqR9Dn/5vx73n/2b3vRPxmQC2prsb641IRwKdyw3kz9Tf0915/Xy7z/Me9/zPsfsVXaYrAFMa//VzIuJs6V5BMK4TTcsN7M+TPnz5w/H/n1V34gAAs3lmw2nRJPoMhfgxgLVkbplHgCRf4axFiwMkqnxBMo8tcgxoKVUTolnkCRvwYxFqyM0inxBIr8NYixYGWUToknUOSvQYwFK6N0SjyBIn8NYixYGaVT4gkU+WsQY8HKKJ0ST6DIX4MYC1ZG6ZR4AkX+GsRYsDJKp8QTKPLXIMaClVE6JZ5Akb8GMRasjNIp8QSK/DWIsWBllE6JJ1Dkr0GMBSujdEo8gSJ/DWIsWBmlU+IJFPlrEGPByiidEk+gyF+DGAtWRumUeAJF/hrEWLAySqfEEyjy1yDGgpVROiWeQJG/BjEWrIzSKfEEivw1iLFgZZROiSdQ5K9BjAUro3RKPIEifw1iLFgZpVPiCRT5axBjwcoonRJPoMhfgxgLVkbplHgCRf4axFiwMkqnxBMo8tcgxoKVUTolnkCRvwYxFqyM0inxBIr8NYixYGWUToknUOSvQYwFK6N0SjyBIn8NYixYGaVT4gl0uf4SCR8LePcbAjAPxoIFb7ZT4gkU+WsQY8HKKJ0ST6DIX4MYC1ZG6ZR4AkX+GsRYsDJKp8QTKPLXIMaClVE6JZ5Akb8GMRasjNIp8QSK/DWIsWBllE6JJ1Dkr0GMBSujdEo8gSJ/DWIsWBmlU+IJFPlrEGPByiidEk+gyF+DGAtWRumUeAJF/hrEWMvqXu4D1j4OoZP2P39j56p/cWEsWBmqU+IJFPlrEGPByiidEk+gyF+DGAtWRumUeAJF/hrEWLAySqfEEyjy1yDGgpVROiWeQJG/BjEWrIzSKfEEivw1iLFgZZROiSdQ5K9BjAUro3RKPIEifw1iLFgZpVPiCRT5axBjwcoonRJPoMhfgxgLVkbplHgCRf4axFiwMkqnxBMo8tcgxoKVUTolnkCRvwYxFqyM0inxBIr8NYixYGWUToknUOSvQYwFK6N0SjyBIn8NYixYGaVT4gkU+WsQY8HKKJ0ST6DIX4MYC1ZG6ZR4AkX+GsRYsDJKp8QTKPLXIMaCtVH6NwRwWFGAu1ARCl6ChAS8hy3mvftaVa4f4ELN/JaByIskh5Bg8m9pwptleC1V2Vn11cwleqGiS/ASJCSY/E/+p/6sBmpFdNyWXi2qTmtnjQQvQUICzlvMzK+50HQmvkQvVGiDlyAhweTfEjXnT19zVR1n9XXlij91CF6ChARTf1N/s/6sBmpFdHyuQFXO+osMXFJSvAQJCZj3Yn5c/j99sj8ZYDP42LjyF0k1GxCs6xSjX9lL9EKFPngJEhJwrmJmfs1F5R3oEr1Qk3/LQORFkkNIMPVnaZr7z77nVHVgzam9RC9U9AhegoQE31x//oEAfZ74TS8+UQ2nP+jUf+RFkkNIwNQV85zOTK4qV7ovVESClyAhwcxvidK69rxVdiKLW3OJXqjoFLwECQk4VzEzv+ZiS765l+iFmvwjVZIcQgJms5hrhuVpUOWiL9Tkf/KfxSXFQUgw9WdlMudP33OqOtb+sox9IMBuO+17gvDNKDchOFjvCwzbh1VPFYqhsTczZv7Jv69Yu+4V8rygb/ocCa0qFFd86m/W/+x/uR7uK2TW39MNxS1f2FnOjN7Uc/7N/jv77+y/526BfQS7BqzzwLDQnlYViqGc/Wf2n9l/ftf9J/9VKe5Ock3Xvyx1X9e84ln/K1vz/sO8/zLvv8z7L7Ed3HfIX/P6N/ZyP4jWn3zBPo6fCdZ/UGDY3MturSoUQzv3f3P/N/d/v+v9321FY2WnVYViqGb9z/qf9T/r/9wtaof4Nfc/Pt99h5r58Qp/3aYzT7d84XlLqwrFUPX9X74hYInDaEflfRCNYdBvt+xtoP29IowbAqpqPlIE3z6pKNnbwMyfCy3TszIThlma/Le69ExpbjJz39Oyt4Gpv6k/bPCsqygQVknVGymC7yk7atnbwNTf1N/UH5bGWhlhuEpm/eG8Y0oIkLjvsuxtYPaf2X9m/8HyWSsjDFfJ7D+z/1gN2CphSRBE4ei/Ks1Ksu8L+Pol4aVlbwOz/87+O/svFslaGWG4SiyovGs1hr7fbtnbwKy/WX+6/vzbXvRq3/SihRP/3k2V3451mKm/qT+tv7rPYJVYYS1MiuDbi06U7G1g6m/qb+oPi2OtjDBcJbP+Zv+xGrBVwpIgQOF8l2VvA7P/zv6777/ygYBeVywc0FsB+YdY+6dqpAdgWPsEghV0TewDQoDBT3sojNACnvkn/1N/uW5yrciKAQw762/2n9l/5/zRMxYbhHIdHwoj5vytG8i5/5j7j7n/mPsPz0DulbJjAoad+6+5//p591/5DQG5F69/WPp/9qV/eVBN/VkeZv3N+vt562/2/zn/8rjPNu6IAL9z/8WHu3zz9l0L3xCAMef1Vx5rseYst3P/HZUx95+WBl8xrA7A71x/mU3NqTA21qw/Zji+xGTWn9YKis44wKk/K5i5/57777n//l1+/8APBBzLVt/xlnMR8NAjELbtiBU5aBC+h27LZua3zbSXUSXyki8N9hOpIkg3LHWX8Sb/k/+pv1o7Gzr2qxbHAoNdQbiws/4sMbnHHfmc/Wf2n9l/2q6izrFeNMh9hRtNRuHCUjfn/5HP2X9m/5n9p+0q6hzrRYPcV7jRzP7jGUA6YEm8vv/iAwGa/vyGAL+v4kQZhgsr8eP5nP1v9r/Z/3RZNXysly2ar2u40Gb9eQaQDlgSr+9/Le10MAHsCsCF/WDzf8Y3BKytu30ggI8twdTf9n5xyw+eYNjf4/lvvzaZ83fO3zl/26pWZ/a/2f/afqnFwXN99v+8D53zLzKAcoBlncz9J/bTT/avCXxnaRfzZazflOJNB+VbB9fZ/22Yjdjc6B7cJaDUzD/5n/rLlaXrYtZfz8CRm43Y3Nl/LAORk0tilJr9d/bf2X9n//UNU/eF2EClOWIbsbnRM7hLQKnZf2b/mf1n9h/fMHRfkK2n9hIlN/HmVp9LQKmPvv9gbfgD8irxn91/5j1Z+phc61dwl4BSH/3x5yM5Hu5B6GNqfS4Bpebxz/mDNaZ1gRqCPWIbsbnRLbhLQKmpv7+n/lBnrCnbx+f5/3uefz7vBvKOz46xef99fv+wPhig5wJqBfaIbcTmRrfgLgGlpv5m/8G5pHWBuoM9YhuxuVN/loHIySUxSs36m/X3K9cfvyEgF7aWojPqK051Cy8KfVJtrX7PDjT+hsX102/7HOornvkjA5eUTP4zKWyn/urVxay/zMDsP7P/zvmD3UDsfqCor3h1uVBz/mRS2M75M+cP3t3DSpvzZ86fOX+wGsTuB4r6iuf8iQxYSj59rs3F/8WMf9Lf30TKbFk758+cP1UiuXDm/JnzZ84fOXcA9zNGfcVLf6H+zesfvPFb+/gXmwiL9zLZhfo386MvstH9y2QXCn0yZO2cP/UUIrGz/87+O/svVoPYfUNRX/HqcqFm/8mksJ39d/Zf3EJgpc35M+fPw/kTHwjQT6HkhuqVs6oodhZuL1FSqK9iO4O6o3Whv0Vx/SEsYgWKm+GZP5Jl+Zr8R/1EkUUTb3I516stY6Fdb4MlljZSas3UnySl4Ky/2X9m/9VdxdfG7L+xQ8T2mntsbKOVmfqlA3I1+69kJ7KXTSTOmjl/JCkF5/yZ82fOnzl/ZLM0OOdv5COO3miur3/+sTMljpeVMce+n7YrXGvm/GlpgTPnz5w/c/7M+ZP7AfbOX3/+fIo/GeD79PpJvhj2H8f+DrOT3vqlz1T72+kpTpG20dGa2f81K8Sz/8/+P/u/7iq+NLAJOZz9x/Mx+29umVopc/7k2sjMKE4m2igca+b8laQUnPP345y/+Q0BUcdZzIT+fGHl13P3iLyfX9GlOclre4Q56dpeDoH2vuPWpTmn/gg7IYdeQO82j/9M3gPTctqcs8MRnvxP/c36iw2HS8GXzew/5+bxwLQ9pTlnhyPMpM/5w1R42qb+zuJ5YFpNNefscISZ9Kk/psLTNvV3Fs8D02qqOWeHI8ykT/0xFZ62qb+zeB6YVlPNOTscYSZ96o+p8LR9Q/35L5Fclt8JkLm2PwOY4KH/5H9LD5M+9cdUeIoe6iez19tWU83pOveOMCed/DMVnqjJv2fhm65WU805ux9hJv2/rb/8QEDu5v5THx/sOh8KmfaYmkMJwRH+II/fC54/iv+0U/98zt4D7TltztnzCDPpk3+mwtM29XcWzwPTaqo5Z4cjzKRP/TEVnrapv7N4HphWU805OxxhJn3qj6nwtE39ncXzwLSaas7Z4Qgz6f99/X36Yned/XmPn249CvnRF61RF6X/EEQuLPzVfuHnX4WVF0bxtzGK7TH3XOeX9XuYIumHYHaOvjO/Znrly5KqbKYLMfcc+zX5n/prZRBV4U1Wy6oZLR0qUjTrT1caEjXrT7OSJYPcuOfYr9l/Zv9pZRBV4U1Wy6oZLR0qUjT7j640JGr2H81Klgxy455jv2b/mf2nlUFUhTdZLatmtHSoSNHsP7rSkKjZfzQrWTLIjXuO/Xref+pftqXS2+MXSTbM1J9mGjme+tOsZAUhN1FJSb1Rf6lefbTr6hnG+Kk/zTQSNfWnWcmSQW7cc+zX8/6X6tVHu2bHbI3/Heov9nJ7qHjYX7/6nwzw6+94/PlY9Ul07Nc8/nWjCZNpsTaztXKmqaMiRb9D/eePrA/CsV/z/OOJ1+x4ZtJf7B50gV/Gz/OvJw0SNeevZoXF4ustLs+TX7P+Zv21Moiq8CZX0lpPWFaMLmD87D+60pCoj7f/2DcE+D8nkE8mYC+QJxU/vlDfBVt/d/ziPBmNtglT5u0DXYJ3UOvvjl8zf+ZBl3RL1AqbeaBL8A5q/Sf/ma2pv1U1WR3RtkKponqgS/AOav3d8Wvyn3mY9R/FEDXSCmWlx8wDXYJ3UOvvjl9Tf5mHqb8ohqiRVigrPWYe6BK8g1p/d/ya+ss8TP1FMUSNtEJZ6THzQJfgHdT6u+PX1F/mYeoviiFqpBXKSo+ZB7oE76DW3x2//pD6+/TZHog9Jn84eGj7BwL+5Mcfz+U7zTz+rdw9X39I/b/z1Ed4nv/t6Z7nf0vIx3j/87N9pXDt4/YzrQ8EtPr9loLfNK2/O37N+s88zP1XFEPUSCuUlR4zD3QJ3kGtvzt+Tf1lHqb+ohiiRlqhrPSYeaBL8A5q/d3xa+ov8zD1F8UQNdIKZaXHzANdgndQ6++OX1N/mYepvyiGqJFWKCs9Zh7oEryDWn93/Hqov/yTAS5ovZyQy/8mof/9CzP+dQIcSyRPsIa9fRpCepVQyAVn/sn/1N+sv9l/Zv+d82fO3/MO4ZGp24q5/9DPqB4Jq0QdIXtncu4/5v5j7j/m/mPuPz7Y/Ud9Q4C/KvdN3Frfr9flKF+vz/k359/+bYyoErNVKEIuOOf/3P/M/c9Pv/+JD3fJ6uM+Putv1t+sv5++/h7fWJn1N+tv1t+sP7tHnt9/4vWk3Ki8Aetlxbz+/B1ef17+ZIC+CHScbyfsz3k90XvEfA/iunZfvc08LrA4hH2Q6wBvvn6d+ZH8p/RN/qOupv5m/dn2ct1hZv9ZiblmZ/bfp63Vt17fXnFd0zf77+y/Vhhz/sz5Y2Vw3yKsOCJwjc7+a/vrPTMWmP0Xp89Dkub8icT8AftvfSCgnvL40j+410Uyz/+f8vzjaW529r9Kx9R/5YJo1v9HXP/7t73kNwRcC3ju/6yW75mxwOx/XOn3JM36/4jrv540r2F7jqLA71W+nsHWhc7UP1Mx9V+pKDTrf9a/7StWBvP714f7iL90/+WfDIjN4nLKdKo2kthoe7D2m3W7ijAsBY0QRyC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSLP7vyr1fvhFksj6+6IIxCTiCPzW+fvAvReGg0W0/zZLogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvt6L9w135JwMq6vLlgYTlwAAZQBgWUQyTvkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRA3WNwSAh2XvE6TkWXhGdqZ8IgDYc1oyKXkWnpGdKZ8IAJaznSAlz8IzsjPlEwHAntOSScmz8IzsTPlEALCc7QQpeRaekZ0pnwgA9pyWTEqehWdkZ8onAoDlbCdIybPwjOxM+UQAsOe0ZFLyLDwjO1M+EQAsZztBSp6FZ2RnyicCgD2nJZOSZ+EZ2ZnyiQBgOdsJUvIsPCM7Uz4RAOw5LZmUPAvPyM6UTwQAy9lOkJJn4RnZmfKJAGDPacmk5Fl4RnamfCIAWM52gpQ8C8/IzpRPBAB7TksmJc/CM7Iz5RMBwHK2E6TkWXhGdqZ8IgDYc1oyKXkWnpGdKZ8IAJaznSAlz8IzsjPlEwHAntOSScmz8IzsTPlEALCc7QQpeRaekZ0pnwgA9pyWTEqehWdkZ8onAoDlbCdIybPwjOxM+UQAsOe0ZFLyLDwjO1M+EQAsZztBSp6FZ2RnyicCgD2nJZOSZ+EZ2ZnyiQBgOdsJUvIsPCM7Uz4RAOw5LZmUPAvPyM6UTwQAy9lOkJJn4RnZmfKJAGDPacmk5Fl4RnamfCIAWM52gpQ8C8/IzpRPBAB7TksmJdl+/vTZfr/juK4v9q8b+r8r2wctnwgAtoY7UEqehWdkZ8onAoA9Zi0iJc/CM7Iz5RMBwNZ0B0rJs/CM7Ez5RACwx6xFpORZeEZ2pnwiANia7kApeRaekZ0pnwgA9pi1iJQ8C8/IzpRPBABb0x0oJc/CM7Iz5RMBwB6zFpGSZ+EZ2ZnyiQBga7oDpeRZeEZ2pnwiANhj1iJS8iw8IztTPhEAbE13oJQ8C8/IzpRPZODTP/mv9jAh/2QAiGWzD3tuUX5sQPhdWz4RAKz03mFKnoVnZGfKJwKA3ScVPyXPwjOyM+UTAcDKfDtMybPwjOxM+UQAsPuk4qfkWXhGdqZ8IgBYmW+HKXkWnpGdKZ8IAHafVPyUPAvPyM6UTwQAK/PtMCXPwjOyM+UTAcDuk4qfkmfhGdmZ8okAYGW+HabkWXhGdqZ8IgDYfVLxU/IsPCM7Uz4RAKzMt8OUPAvPyM6UTwQAu08qfkqehWdkZ8onAoCV+XaYkmfhGdmZ8okAYPdJxU/Js/CM7Ez5RACwMt8OU/IsPCM7Uz4RAOw+qfgpeRaekZ0pnwgAVubbYUqehWdkZ8onAoDdJxU/Jc/CM7Iz5RMBwMp8O0zJs/CM7Ez5RACw+6Tip+RZeEZ2pnyiBewbAvy7EfSCBLS/tWAY3y2BcLLyxgMCsDpmYUYD0CsBP77qMb9m/sm/1cLUH5cCFl1fPfBgc/XsLaMB6IkMnFu/Zv3N+rNamPXHpTDrL3cG7BTd62zGqmU0AL0SzPlvuVh7bmRl9t/Zf22dzP5by8KXhF1994AHm5q9ZTQAPZGBc+vXrL9Zf1YLH3T9+QcC/u+T/3xZrd4eL+krVGvG9d4PNzPUgMOAU/9T/1YLH7T+11Fg1at1WyzLegGoUk5PZODc+jX1P/VvtfAL6t+/IWBVW1Qevull8v9r8h9Jb/vIrP/Z/2b/n/1n9p9fcf7N/usZ8PtOvQuY/Wf2n1+3/3yyvzdo/5wARZhL8tbeFWBhe09/YyK/Bsv/DUPe7IbC5Li/fn5hto1lri+NfmFe2C0680/+7UWWbyhTf7P+uH/M/jP7rxVD1EMcHffzQ0+TuwIsrPawXWfOnzl/5vyZ83fuP+b+a17/1Os3Oy7n9d+Puf/45B8IwOW/ULJ7Dn9J79fcf8z7D/P+y7z+n/c/fo/3f2KtRrmuml37eOzl1sTrVXd44XUnLAMBZv+f/X/2/9n/Z///Pfb/vnt372GHN1HW9/V0mPcf5/3Hef/R1sis/2/9/Wd8Q0DbbOgQ9J3p4kHp969ef7CUQkCigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKKDFqZD0MUXD0rMC0spBCQ6aGE6BF188aDEvLCUQkCigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKKDFqZD0MUXD0rMC0spBCQ6aGE6BF188aDEvLCUQkCigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKKDFqZD0MUXD0rMC0spBCQ6aGE6BF188aDEvLCUQkCigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKKDFqZD0MUXD0rMC0spBCQ6aGE6BF188aDEvLCUQkCigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKKDFqZD0MUXD0rMC0spBCQ6aGE6BF188aDEvLCUQkCigxamQ9DFmxcfCOA3BOSbg1+++C9CRPjOUC1Mh0AGukMo8bhhqYaARActTIegiy8elJgXllIISHTQwnQIuvjiQYl5YSmFgEQHLUyHoIsvHpSYF5ZSCEh00MJ0CLr44kGJeWEphYBEBy1Mh6CLLx6UmBeWUghIdNDCdAi6+OJBiXlhKYWARActTIegiy8elJgXllIISHTQwnQIuvjiQYl5YSmFgEQHLUyHoIsvHpSYF5ZSCEh00MJ0CLr44kGJeWEphYBEBwjnL2/rVzz+C/1vudAf88KyLwQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKKDFqZD0MUXD0rMC0spBCQ6aGE6BF188aDEvLCUQkCigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKKDFqZD0MUXD0rMC0spBCQ6aGE6BF188aDEvLCUQkCigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDpoYToEXXzxoMS8sJRCQKKDFqZD0MUXD0rMC0spBCQ6aGE6BF188aDEvLCUQkCigxamQ9DFFw9KzAtLKQQkOmhhOgRdfPGgxLywlEJAooMWpkPQxRcPSswLSykEJDrQ8PEnAzKoEv98hd+kLu6YrQ9+ejVWIGv4r0NOcZ9rxXOENc7Mn5+6uOTuTq28WTCQNZP/fNF1y1dmq3LmmsZN/U39tXdbb1WkXNVSIGtm/c360/frz2qpmvFYeoub/Wf2n9l/dMm8g2stBbJm9t/Zf2f/vS+bXC21ZlzVuDl/PtT5g18i+T8UwucC+i+S6rkMZM3sf7P/zf43+98tA22vX4LGzf7/0/b/T5/t2148v3HZO65fvwSa/Pt+nVk4/7XZStejWf0sHsiaOf/m/Jvz775gcrXUmnFV42b//2n7/5Hr9RRN/mf/n/Nv7Umz//zU/Wf7QIAcBIQEsT2ph+cmOA2sjazMm8GS4abPGXYhCJ16M3/WRuREEyMZTfhmUNSiIySY/FsGNBtTf1N/8Y0oVhdv/9UVrRpZbgcUHSFBqNWb+pv6m/pbe7IujLfW1RFTQgYhJJj1ZxnQbMz+M/vP7D+z/8SeoBuDbqnHrnkEhZBBCAmOkWb/+b//+/zZ39r2/y1Py/QPBHjaeg6duV+iIySILupN/mf/n/1/9v/YE3RjODaXN4OiFh0hwR+//3y2xeSPFlfu43/P42/nFB82QaRFvTl/5vyZ82fOn9gTdGPABkr7ZpCq2X8kT4QEs/9aBjQbc/7M+fOnnT/bBwK2grcF8PRJOih1gcjOesDUlTpQudQrpZgCgoy+raF4LeRSByqXQqUUU0CQ0bc1FM/8lgp+yslw5O2SPKUUVyaBMvq2BtqzWqPfpbNSimskoIy+rYF25t+zFf4leUoprkwCZfRtDbST/z1b4V+Sp5TiyiRQRt/WQDv537MV/iV5SimuTAJl9G0NtJP/PVvhX5KnlOLKJFBG39ZAO/nfsxX+JXlKKa5MAmX0bQ20k/89W+FfkqeU4sokUEbf1kA7+d+zFf4leUoprkwCZfRtDbST/z1b4V+Sp5TiyiRQRt/WQPvz8q/fEBAvqmzK8wMBP2/+//rxz/xvvUfz8+tv8j/5f36PcOoPGch1UqslULkh2/fyL/Ybh+fc7iNiprvd1bf5vaf+SIrPUfcRT4Uyuzr8ywRKKdaxEmf0bU312tXhXzorpbhGAsro2xpokddSByqXQqUUU0CQ0bc1FM/7z5aKef+5qiVQuSwUpRRTQJDRtzUUT/1ZKqb+qloClctCUUoxBQQZfVtD8dSfpWLqr6olULksFKUUU0CQ0bc1FP829ccPBDw/sK/2YD61YlqPzh7tU68n3hOEGGwmrXvJITLzT/51M2MJFdCCMfxcTRXrmu7pcFP/s/5m/c36kx2CkEA3jNl/Zv+1Gnh6Kw81A5ul0z0tpzl/5vyZ82fOH9khCAl0wzD8xLsMMdjs2r3kEJn193HX32f7mumv/h3I8bz6M2Yr5ev/wrp3XnimYVPRPe0158/U/8et//t91nM1z/6H3MDO+vcM9Gz8N/vf50/2JwPsJ8Fujm8ImP1n9p+5/5UVSkigC/bN1Vwrvfftng439z+z/8z+M/uP7BCEBLphzP7zxt3U7L+oGdgsne5pOf3a88c+EPDFfhZ585o/GYH+dA13BX7wJWlBc9YfbsLXbNRATVj18mZRZe/ec+bPg3vyHxloxTH1N+vP9jj7b/YfS4Ns97LhbptqW0BrU+mmK2b/nf3XXzitqxXH7L+z/87+O+fPnL9z/zH3Hz/y/su/Zrpf/oEA+9vTc/7K2xpz/zH3H3P/MfcfH/v+g98Q4Bu6lWu8Nds39+a1Ld42/Hn9Oa8/eTfQimPOvzn/5vyb8+9jn39xuHHfImhnnjpdMeffnP9z/v/b85/fELC9gyC3l9tCe16RjPSFWiMnry27GOi9atZCqg7cuzC80/DTassuBqBKrmYtpOrAvQvDOw0/rbbsYgCq5GrWQqoO3LswvNPw02rLLgagSq5mLaTqwL0LwzsNP6227GIAquRq1kKqDty7MLzT8NNqyy4GoEquZi2k6sC9C8M7DT+ttuxiAKrkatZCqg7cuzC80/DTassuBqBKrmYtpOrAvQvDOw0/rbbsYgCq5GrWQqoO3LswvNPw02rLLgagSq5mLaTqwL0LwzsNP6227GIAquRq1kKqDty7MLzT8NNqyy4GoEquZi2k6sC9C8M7DT+ttuxiAKrkatZCqg7cuzC80/DTassuBqBKrmYtpOrAvQvDOw0/rbbsYgCq5GrWQqoO3LswvNPw02rLLgagSq5mLaTqwL0LwzsNP6227GIAquRq1kKqDty7MLzT8NNqyy4GoEquZi2k6sC9C8M7DT+ttuxiAKrkatZCqg7cuzC80/DTassuBqBKrmYtpOrAvQvDOw0/rbbsYgCq5GrWQqoO3LswvNPw02rLLgagSq5mLaTqwL0LwzsNP6227GIAquRq1kKqDty7MLzT8NNqyy4GoEquZi2k6sC9C8M7DT+ttuxiAKrkatZCqg7cuzC80/DTassuBqBKrmYtpOrAvQvDOw0/rbbsYgCq5GrWQqoO3LswvNPw02rLLgagSq5mLaTqwL0LwzsNP6227GIAquRq1kKqDty7MLzT8NNqyy4GoEquZi2k6sC9C8M7DT+ttuxiAKrkatZCqg5sXT599rcA/H9/OyhH2b9qGiPrzOBinGg6U7MWKu1CvQvDOw0/rbbsYgCq5GrWQqoO3LswvNPw02rLLgagSq5mLaTqwL0LwzsNP6227GIAquRq1kKqDty7MLzT8NNqyy4GoEquZi2k6sC9C8M7DT+ttuxiAKrkatZCqg7cuzC80/DTassuBqBKrmYtpOrAvQvDOw0/rbbsYgCq5GrWQqoO3LswvNPw02rLLgagSq5mLaTqwP/P3tuF2rpt2UFz7xuq8hKEQpCIpAgWlIqKFIiJQkzUilBS+CAU+CARf4hEBJ/yUloaRETQh0gEKZUCJaAPgkgSQ3wolYAaEUoq/lCViPWgYh78qdSDt/Tu7Ri9j9Z662N839r7zHvOvmvv0+a95+utt97GGGv12Ucf35pr7rn6EIZ3Gn5avXLIAFAlV6sWUnXgPoThnYafVq8cMgBUydWqhVQduA9heKfhp9Urhwww+nd8QkBx/RMCiifCxCQS7DR8XRlcDe1MfdeFSrtQH8LwTsNPq1cOGQCq5GrVQqoO3IcwvNPw0+qVQwaAKrlatZCqA/chDO80/LR65ZABoEquVi2k6sB9CMM7DT+tXjlkAKiSq1ULqTpwH8LwTsNPq1cOGQCq5GrVQqoO3IcwvNPw0+qVQwaAKrlatZCqA/chDO80/LR65ZABoEquVi2k6sB9CMM7DT+tXjlkAKiSq1ULqTpwH8LwTsNPq1cOGQCq5GrVQqoO3IcwvNPw0+qVQwaAKrlatZCqA/chDO80/LR65ZABoEquVi2k6sB9CMM7DT+tXjlkAKiSq1ULqTpwH8LwTsNPq1cOGQCq5GrVQqoO3IcwvNPw0+qVQwaAKrlatZCqA/chDO80/LR65ZABoEquVi2k6sB9CMM7DT+tXjlkAKiSq1ULqTpwH8LwTsNPq1cOGQCq5GrVQqoO3IcwvNPw0+qVQwaAKrlatZCqA/chDO80/LR65ZABoEquVi2k6sB9CMM7DT+tXjlkgOTjDQH4VyttacxCqUwksZgo/PFyROPnYoNYnwwwvbuH1x8v6UT65D0+ksuEcpWY8z+SEflw/Xn/jQ4zXxXlY9bGIBrHIIH7j/uP++9soz5/+B5TOWMTylViPn9HMiIfPn99/o4jtZ21szZ8/vac8LaDwPcfvv949v6j/avSVVH5i6TpeP+5/7j/uv/yqLkEPn9ex/mDXh5nwWzd84kZj3nFRzYHTiJi2eOnwPffvv+OQll1Mc0oFN9/z83z4sP9D+3Dr//49Z+1WeSMSShXifn8GcmIfPj89fk7jpl21szaGETjzqPoVZ0/46ZzlvP5iCJXWon1qwOlKJVfKzBOsDaP+By3gUOihNePo1tTwvQ5/7ytYX4IXH+RCskH62YDh0QJ7z/vv3HrrCXB8nH/cf9ZP1axPgjcfyMVkg/umw0cEiXcf91/3X99/oyecfyw6fP323T+vvmOFMA4Iqb3vfEjfbA8Mgh8/kYqJB/bsUv3kCjh89fnr89fn79f7/k7//zL7DLZxUePaS/Nuv/UzY77r/uv+6/779fbf6P14qLtNjgl3H/cf9x/3H++vP5z/MmA3vbWLZiSe3OMWArmdT7qJYoaCASbSr1mROPEBNALETD9eZ0Pr595WK/+hIOMwUJRtnKI/FFLALUQAdOf1/nAeK9feQKCzUzpNSMaJyaAXoiA6c/rfDj/mQfXX9UJECwyVDYjGicmgFqIgOnP63y4/jIPrr+qEyBYZKhsRjROTAC1EAHTn9f5cP1lHlx/VSdAsMhQ2YxonJgAaiECpj+v8+H6yzy4/qpOgGCRobIZ0TgxAdRCBEx/XufD9Zd5+DbUH/9V6fiW8fzXL5KyLmY2gGCRobIZ0TgxAdRCBEx/XufD9Zd5qKwXksxBtGzlEPmjlgBDhAiY/rzOB8bXqoVkZIp5rTkwnloCiIUImP68zgfG16qFZGSKea05MJ5aAoiFCJj+vM4HxteqhWRkinmtOTCeWgKIhQiY/rzOB8bXqoVkZIp5rTkwnloCiIUImP68zgfG16qFZGSKea05MJ5aAoiFCJj+vM4HxteqhWRkinmtOTCeWgKIhQiY/rzOB8bXqoVkZIp5rTkwnloCiIUImP68zgfG16qFZGSKeR2/Ynn7NoRz/PyHZe/ezV+7TGf8V5N2ImIpmNf5KGkNBIJNpV4zonFiAuiFCJj+vM6H18886BOHjMFCUbZyiPxRSwC1EAHTn9f5wHivX3kCgs1M6TUjGicmgF6IgOnP63w4/5kH11/VCRAsMlQ2IxonJoBaiIDpz+t8uP4yD66/qhMgWGSobEY0TkwAtRAB05/X+XD9ZR4+x/rLPxmAJ1Ge5/iW8FkGw2GIAN/0sjt/6YNcthtZBHMOwfworPHAyAJLA0PBIi59kMt2I4tgjiHw+pEMZM75H+mojrcKZRgmaFGXPshlu7mYYwhcf5FQZO7IM54BCpz/njDNB5K0bDeuP6SHNTUI779eTnuOmKsBtC/uuvBBLtuN6w/pYU4H4fpz/Y0MsDQIUCTL7vylD3LZbmQRzDkErr9IBjJXT4Tz3zLABKF2hj3OA4iW7cb1h/QgsR/x8zfeEDCTPdM9/+1SvCHgmGs+HyB74sEetf0R6+NLPcfO9Rhdzy1W8vqRnJ4G1z/KA2Xj+htlkpuIqSFAkpbd+Usf5LLduP6QHqT2E9df9fL8At6/e+fn3/UfxcDSJECRLrvzlz7IZbvx/kd6kNpPvP/Pe6jxBbn+Xf8jAyxNAhTpsjt/6YNcthtZBHMOgesvkoHM1RPh/LcMMEGonWH981+lKPKDJC3bzavYf/UJAXL41XdRXyO+FY0BV6wQYrAROcJCeH02X+RsWmQIVmPAFSuEGGxEjrAQzr/zvw5/1My0qBBYjQFXrBBisBE5wkK4/lx/rj9sF1rsEFgGBFSskIQDRuQIC+H95/3n/bdyIhTyAABAAElEQVRvG59/IyP5i8a0R4IGUV2k0K6LyBEWwv3H/cf9Z9823FuyU5pm/yXSDNYnBJTU+29sryOJQrj/uP+4/1TDWAg7BPYQDKJihXZdRI6wEN5/8QkBuNea+Zt9HBmC3fMaunHZ3jZyyGL8MYkQzr/7n/vf9b4ZrOyUW81LKu8/33/5/nNsHf0lse4qnz8+f3z+3J4tn+r8qTcE6Jeyr7771J6Bk6G4wBC9H90x/01D0UT7JLt/K3zpSOagEHl959/1107n2iD7ftt9Ks/AyVBcYIi8/7z/vP+8/6opCNqbyO5TegZOhuICQ+T+4/7j/uP+U01B0N5Edp/SM3AyFBcYIvcf95+vo//Mj5l+Mz5fev1V07BXbwio4hvI9ef959df/PpTf3W+WsR+iO0+lWfgZCguMEQ+/87zL9/cNe/JRoKGeT/+ZEA8bpN6Bk6m0k40RM7/mX/NT9sat0k9AyfDWQs4/64/n78+f1uTqfYw238L7T6lZ+BkKC4wRO7/7v9fx8+fvVDjzqWVbhWdINffq91//Q0B8UTJU3zzrh0+tdJ9EgoxRXDDzsukRhkuHuEIZHAkyuvzZVrnfxQDs8EyIZACSijEqqfoTkHPi+vP+8/9x/13NIL5gkua2RbyMQifPz5/eeL4/PX56/sPdMfTSgNNKMRUww07L77/8v2X77++zvuvN2/naTX/y/010bt5bs1H7DtY779Mievv66y/KD2UGAtuZno8XH+1NSPpPv98/t33n/3TXvRPBuSG2q7YX9xqQkwp3LDz4vpz/d3X36wXv/7h1z/8+ke0yrEZxobwz/8rGRcmzpXkEwoxabhh58Xnj88fnz+v+eevfEMANm5s2bx0SjyBIn8OYi5YmaVT4gkU+XMQc8HKLJ0ST6DIn4OYC1Zm6ZR4AkX+HMRcsDJLp8QTKPLnIOaClVk6JZ5AkT8HMReszNIp8QSK/DmIuWBllk6JJ1Dkz0HMBSuzdEo8gSJ/DmIuWJmlU+IJFPlzEHPByiydEk+gyJ+DmAtWZumUeAJF/hzEXLAyS6fEEyjy5yDmgpVZOiWeQJE/BzEXrMzSKfEEivw5iLlgZZZOiSdQ5M9BzAUrs3RKPIEifw5iLliZpVPiCRT5cxBzwcosnRJPoMifg5gLVmbplHgCRf4cxFywMkunxBMo8ucg5oKVWTolnkCRPwcxF6zM0inxBIr8OYi5YGWWToknUOTPQcwFK7N0SjyBIn8OYi5YmaVT4gkU+XMQc8HKLJ0ST6DIn4OYC1Zm6ZR4AkX+HMRcsDJLp8QTKPLnIOaClVk6JZ5AkT8HMReszNIp8QSK/DmIuWBllk6JJ3DK9ZdIeFvABz8hAOtgLljww3ZKPIEifw5iLliZpVPiCRT5cxBzwcosnRJPoMifg5gLVmbplHgCRf4cxFywMkunxBMo8ucg5oKVWTolnkCRPwcxF6zM0inxBIr8OYi5YGWWToknUOTPQcwFK7N0SjyBIn8OYi5YmaVT4gkU+XMQc8HKLJ0ST6DIn4OYa1nt5XPC6uMQTnL8x9/YTdX38cBcsDJVp8QTKPLnIOaClVk6JZ5AkT8HMReszNIp8QSK/DmIuWBllk6JJ1Dkz0HMBSuzdEo8gSJ/DmIuWJmlU+IJFPlzEHPByiydEk+gyJ+DmAtWZumUeAJF/hzEXLAyS6fEEyjy5yDmgpVZOiWeQJE/BzEXrMzSKfEEivw5iLlgZZZOiSdQ5M9BzAUrs3RKPIEifw5iLliZpVPiCRT5cxBzwcosnRJPoMifg5gLVmbplHgCRf4cxFywMkunxBMo8ucg5oKVWTolnkCRPwcxF6zM0inxBIr8OYi5YGWWToknUOTPQcwFO2bpnxDAaUUB7oKKUPASJCTgPWwxH7qvVeX6Ai4orz8yEHmR5BASOP8jTXixDD9LVXZWfTVzEb2gYkjwEiQkcP6df9ffqIHaER23rVebqtM6WCPBS5CQgOsW4/U1F5rOxBfRCyq0wUuQkMD5H4ny+dP3XFXHWX1dueJ3A4KXICGB68/15/03aqB2RMfnDlSl919k4CIlxUuQkIB5L+bry/+bN+NPBowV5tx45C+SajUg2KlTjHFlL6IXVOiDlyAhAdcqxutrLirvQBfRC8r5HxmIvEhyCAlcfyNNvv/sPaeqA3tO7UX0gooRwUuQkOCj62++IUCfJ37Sy1yoptMv1PUfeZHkEBIwdcXcpzOTq8qV7gsqIsFLkJDA649EaV3PvFV2Iovb5SJ6QcWg4CVISMC1ivH6most+cO9iF5Qzj9SJckhJGA2i7nMsDwNqlz0BeX8O/9ZXFIchASuv1EmPn96z6nqWP1lmfGGgHHbOT4nCJ+MciUEBzvHAsP2adVThWJoxosZXt/5nzt2PK4r5H5DX+lzJlxVobjirj/vf/e/3A/XO8T77+6G4ipf6CxnRq/UPv/cf91/3X/PboE+gq4BO3lgWGhPqwrFULr/uP+4/3yu/Sf/VSnuTnJP178snb7uecXe/ytbfv3Br7/49Re//hLt4LpDfpqff6OXz4No/ckX9HF8TbDzCwWGzV52dVWFYmh9/+f7P9//fa73f1c7Gjs7rSoUQ+X97/3v/e/9f3aL6hCf5v5nrnfdobw+fsJft+nM01W+8LylVYViqHr/l08IWOIwOlD5OYnGMOnHW44eoP29IswbAqpqPVIEH7+oKDl6AK+fGy3TszIThlly/ltdzkxpbjJzX+XK0QO4/lx/aPCsqygQVknVGymCr1J21HL0AK4/15/rD1tj7Yww3CXefzjvmBICJO4rWY4ewP3H/cf9B9tn7Yww3CXuP+4/owbGLmFJEETh6L8qzUoanxfw/l3CiytHD+D+6/7r/otNsnZGGO6SEVR+ajWGsR9vOXoA7z/vP91/89Ne9NE+6UULJ/69myo/Hus0rj/Xn9Zf3WewSkZhLUyK4OOLTpQcPYDrz/Xn+sPmWDsjDHeJ95/7z6iBsUtYEgQonK9kOXoA91/3373/yhsCel2xcEBvBTTfxNrfVSMjAMOOdyCMgq6F54QQYPLTHopBaAF7feff9Zf7JveK7BjAsN5/7j/uvz5/9IxFg1Cu40MxCJ+/dQPp+w/ff/j+w/cfMwPZK6VjAob1/Zfvv765+6/8hIDsxesflj7Gh/7lQeX6G3nw/vP+++b2n/u/z7887vMad0SAX7H/4s1ds3nProVPCMCc/vkrj7XYcyO3vv+OyvD950jD3DGsDsCvuP8ym5pTYcZc3n/McHyIifef1gqKbnCArr9RML7/9v23778/l98/8A0Bx7bVV7zlXAQ89AiEbR2xIgcNYvbQbdt4/dFMexlVIi/ypcF+IlUE6Yal7mI+59/5d/3V3tnQ0a9aHBsMdgXhwnr/jcRkjzvy6f7j/uP+07qKOsd+0SD7ChtNRuHCUufz/8in+4/7j/tP6yrqHPtFg+wrbDTuPzMDSAcsief7L94QoOnPTwiY91VcKMNwYSV+PJ/uf+5/7n+6rRo+9ssWzZ9ruNG8/2YGkA5YEs/3v5Z2OlgAdgXgwr6y9d/iEwJW625vCOD3lsD1t71e3PKDJxj283j+269NfP76/PX523a1Ou5/7n+tX2px8Fx3/8/7UJ9/kQGUAyzrxPef6Kdvxr8mmJ2lPZivwc6bUrzooHwbMHXjvzbNRmxuDA/uIqCU13f+XX+5s3RfeP/1DBy52YjNdf8ZGYicXCRGKfdf91/3X/ff2TC1L0QDlcsR24jNjZHBXQSUcv9x/3H/cf+ZDUP7grSe6iVKbuLNrTEXAaVee//B3pjf0KyS+bXPr3lPln5PUzsfwV0ElHrt339+J8e3exD6PbUxFwGl/P37/MEe07pADcEesY3Y3BgW3EVAKdfft6f+UGesqdHH/fx/e55/Pu8D5B3fOMb8+rt//7DeGKDnAmoF9ohtxObGsOAuAkq5/tx/cC5pXaDuYI/YRmyu629kIHJykRilvP+8/z7l/uMnBOTG1lKcjPqKU93Ci8KYVI+rfs4ONPMFi8t3v+1rqK/Y60cGLlLi/GdSeHX91U8X3n+ZAfcf91+fP+gGYvcDRX3Fa8gF5fMnk8Krzx+fP3h1DzvN54/PH58/2A1i9wNFfcU+fyIDIyVv3lZzmf9iZr7Tf76IlNkaV58/Pn+qRHLj+Pzx+ePzR84dwP2MUV/x0l9Q38/PP3jht/r4u7EQNu/FYhfU97M+xiIb3b9Y7ILCmAyNq8+fegqRWPdf91/3X+wGsXtDUV/xGnJBuf9kUnh1/3X/xS0EdprPH58/N+dPvCFA34WSDXVWzqqi6CxsL1FSqK9iO4O6o53C+RLF5RcxIqNAcTPs9SNZI1/Of9RPFFlc4kWuyfVqy1ho18tgieUaKR0X158kpaD3n/uP+692lbk33H+jQ0R7zR4bbbQyU790QK7cfyU7kb28ROLGxeePJKWgzx+fPz5/fP5IsxzQ52/kI47euFz+/POdcabE8bIyNvHsp+0R7rj4/GlpgePzx+ePzx+fP9kP0Ds//fnzJv5kwOzT6yt5N/D8csbfYZ7kvM6HPlPtb6enOEV6jYHj4v6vWSF2/3f/d//XrjK3BprQhO4/Mx/uv9kytVJ8/uTeyMwoTiauUTjj4vNXklLQ5+/rOX/zEwKijrOYCefzhZ1fz90tmuPmI4Y0J3m9HmEuutrLIdDR17gNac6pP8KTkEMv4Bzm7/9M3g3Tctqcc8ARdv5df95/0XC4Fea2cf85m8cN03pKc84BR5hJ9/nDVMy0uf7O4rlhWk015xxwhJl01x9TMdPm+juL54ZpNdWcc8ARZtJdf0zFTJvr7yyeG6bVVHPOAUeYSXf9MRUzbR9Rf/OXSFOWnwmQuR5/BjDBzXjnf0sPk+76Yypmim7qJ7PXr62mmtN10zvCXNT5Zypmopz/mYWPerSaas45/Agz6T/Y+ss3BGQ3n1/18cau81sh076n5lBCcIRfyfc/C55fyvxqXf98zj4E2nPanHPkEWbSnX+mYqbN9XcWzw3Taqo554AjzKS7/piKmTbX31k8N0yrqeacA44wk+76Yypm2lx/Z/HcMK2mmnMOOMJM+g++/t68G3ed/XmPr259F/KlL1qjU5T+TRC5GOH34xd+86Ow8oFZ5ssYxfbY9KZuPsa4myWSvgnm4Bjr9TXTK18jqcpmuhCb3sTz4fy7/loZRFXMS1bLqhktHSpS5P2nOw2J8v7TrGTJIDfTm3g+3H/cf1oZRFXMS1bLqhktHSpS5P6jOw2Jcv/RrGTJIDfTm3g+3H/cf1oZRFXMS1bLqhktHSpS5P6jOw2Jcv/RrGTJIDfTm3g+7vtP/cu2VM7r8YukMY3rTzONHLv+NCtZQchNVFJSL9RfqtcYHbpGhhm8608zjUS5/jQrWTLIzfQmno/7/pfqNUaH5sC8Dv5zqL/o5eNbxbf9/v38kwHz8e34/vN71Sdx4vnw979uNGEyLeOa2Vo509RRkaLPof7zS9ZvYuL58POPJ16zMzOT/mL34BTMx+D9/OtJg0T5/NWssFjmfovHzNN8eP95/7UyiKqYl9xJaz9hWzG6wODdf3SnIVGvr/+MTwiY/5xA3pmAXiBPKr58ob4SbOOnMx9cJ6NxbcKUzesNXYIPoDZ+OvPh9TMPuqVbolZ4mBu6BB9Abbzzn9ly/a2qyeqIayuUKqobugQfQG38dObD+c88eP9HMUSNtEJZ6Rnmhi7BB1AbP535cP1lHlx/UQxRI61QVnqGuaFL8AHUxk9nPlx/mQfXXxRD1EgrlJWeYW7oEnwAtfHTmQ/XX+bB9RfFEDXSCmWlZ5gbugQfQG38dObjC6m/N2/HNzK+p/nt4Fvb3xDwJX//8Vx+4OLvfyv3ma8vpP4/8NRH2M//9nT7+d8S8jpe/3w7PlK4+vj4mtYbAlr9fkzBb5o2fjrz4f2fefD9VxRD1EgrlJWeYW7oEnwAtfHTmQ/XX+bB9RfFEDXSCmWlZ5gbugQfQG38dObD9Zd5cP1FMUSNtEJZ6Rnmhi7BB1AbP535cP1lHlx/UQxRI61QVnqGuaFL8AHUxk9nPm7qL/9kwBS0UZOQx/ybhPPvXwwzP06Ac4nkDta0V++GkFElFHJBr+/8u/68/9x/3H99/vj8Pe8Qbpm6rfD9h75H9UhYJeoIjVcmff/h+w/ff/j+w/cfr+z+oz4hYP5UPpv4uM5+vR4T5c/rPv98/u2fxogqGbYKRcgFff77/sf3P9/4/U+8uUt2H/u495/3n/ffN77/bl9Y8f7z/vP+8/4b98j+/Sd+npQblRdg/Vjhnz8/h58/L/5kgP4QOHG+nLA/5/VE75HhzyAel8PX6GFuN1gcwnOSywle/PnV6yP5d+lz/qOuXH/ef6O9XHYY95+VmMvsuP/etdbZemd7xeMyfe6/7r+jMHz++PwZZXDdIkZxROAy6v47+ut1ZkbA/Renz02SfP5EYr6A/ltvCKinPD70D+7lJvHz/6U8/3iam3X/q3S4/isXRN7/r3H/75/2kp8QcFnAvv8btXydmRFw/+NOv06S9/9r3P/1pM0aHs9RFPh1la9nsA2h4/pnKlz/lYpC3v/e/6OvjDLw719v7iO+pf2XfzIgmsXFKdOpaiTRaHuw+s26XUUYloJGiCMQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tD+Sw+78qnePwiySR9ddFEYhFxBH4sev3ifsoTAeLaP9tlkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXm5F+5u78k8GVHTKlwcSlhMDZABhWEQxTfoSFQhtp5YHEhZi2gwgDLuFlytRgdB2ankgYSGmzQDCsFt4uRIVCG2nlgcSFmLaDCAMu4WXK1GB0HZqeSBhIabNAMKwW3i5EhUIbaeWBxIWYtoMIAy7hZcrUYHQdmp5IGEhps0AwrBbeLkSFQhtp5YHEhZi2gwgDLuFlytRgdB2ankgYSGmzQDCsFt4uRIVCG2nlgcSFmLaDCAMu4WXK1GB0HZqeSBhIabNAMKwW3i5EhUIbaeWBxIWYtoMIAy7hZcrUYHQdmp5IGEhps0AwrBbeLkSFQhtp5YHEhZi2gwgDLuFlytRgdB2ankgYSGmzQDCsFt4uRIVCG2nlgcSFmLaDCAMu4WXK1GB0HZqeSBhIabNAMKwW3i5EhUIbaeWBxIWYtoMIAy7hZcrUYHQdmp5IGEhps0AwrBbeLkSFQhtp5YHEhZi2gwgDLuFlytRgdB2ankgYSGmzQDCsFt4uRIdsD4hADwsR58gJffCM7Iz5RMBwJ7LkknJvfCM7Ez5RACwXO0EKbkXnpGdKZ8IAPZclkxK7oVnZGfKJwKA5WonSMm98IzsTPlEALDnsmRSci88IztTPhEALFc7QUruhWdkZ8onAoA9lyWTknvhGdmZ8okAYLnaCVJyLzwjO1M+EQDsuSyZlNwLz8jOlE8EAMvVTpCSe+EZ2ZnyiQBgz2XJpOReeEZ2pnwiAFiudoKU3AvPyM6UTwQAey5LJiX3wjOyM+UTAcBytROk5F54RnamfCIA2HNZMim5F56RnSmfCACWq50gJffCM7Iz5RMBwJ7LkknJvfCM7Ez5RACwXO0EKbkXnpGdKZ8IAPZclkxK7oVnZGfKJwKA5WonSMm98IzsTPlEALDnsmRSci88IztTPhEALFc7QUruhWdkZ8onAoA9lyWTknvhGdmZ8okAYLnaCVJyLzwjO1M+EQDsuSyZlNwLz8jOlE8EAMvVTpCSe+EZ2ZnyiQBgz2XJpOReeEZ2pnwiAFiudoKU3AvPyM6UTwQAey5LJiX3wjOyM+UTAcBytROk5F54RnamfCIA2HNZMinJ69s3b8fvdyaux7vxrxv6vyvbJy2fCAC2pjtQSu6FZ2RnyicCgD1WLSIl98IzsjPlEwHA1nIHSsm98IzsTPlEALDHqkWk5F54RnamfCIA2FruQCm5F56RnSmfCAD2WLWIlNwLz8jOlE8EAFvLHSgl98IzsjPlEwHAHqsWkZJ74RnZmfKJAGBruQOl5F54RnamfCIA2GPVIlJyLzwjO1M+EQBsLXeglNwLz8jOlE80wJvv5L/aw4L8kwEgls0xHLlF+bYB4Xdt+UQAsDJ6hym5F56RnSmfCAB2X1T8lNwLz8jOlE8EACvr7TAl98IzsjPlEwHA7ouKn5J74RnZmfKJAGBlvR2m5F54RnamfCIA2H1R8VNyLzwjO1M+EQCsrLfDlNwLz8jOlE8EALsvKn5K7oVnZGfKJwKAlfV2mJJ74RnZmfKJAGD3RcVPyb3wjOxM+UQAsLLeDlNyLzwjO1M+EQDsvqj4KbkXnpGdKZ8IAFbW22FK7oVnZGfKJwKA3RcVPyX3wjOyM+UTAcDKejtMyb3wjOxM+UQAsPui4qfkXnhGdqZ8IgBYWW+HKbkXnpGdKZ8IAHZfVPyU3AvPyM6UTwQAK+vtMCX3wjOyM+UTAcDui4qfknvhGdmZ8okWGJ8QMD8bQR+QgJ4vLQyMz5ZAOFl54QEBWJ2zMKMB6JWAb1+dsfnw+s7/qAXXH7cCNl3fPfBgc/fsV0YD0BMZuGnnw/vP+2/Ugvcft4L3X3YGdIrudTZjdWU0AL0S+PwfuVg9N7Li/uv+O/aJ+29ti7klxqN3D3iwqdmvjAagJzJw086H95/336iFV7r/5hsCHm/m15fVOq/Hj/QVqj0z9XMcbmaoAYcJXf+u/1ELr7T+11EwqlfrtliW9QJQpZyeyMBNOx+uf9f/qIVPUP/zEwJWtUXl4ZNenP9Pk/9Ieusj3v/uf+7/7j/uP5/i/HP/nRmY9516F+D+4/7z6frPm/H3Bsc/J0AR5pa8ul4rwML2kfOFifwYrPlvGPJmNxRDjvvr+x/MtrmGO7dGf2Bd2C3q9Z3/8UPWbCiuP+8/9g/3H/ffUQxRD3F0XJ8feppcK8DC6ojRdXz++Pzx+ePz1/cfvv/yzz/189s4Lv3z39dz//FmviEAj/kLpXHPMX+knw/ff/j1B7/+4p///frH5/H6T+zVKNdVs6uPRy8fl/h5dTp84OdOWAYCuP+7/7v/u/+7/38e/b937+7ddPghyvq+PB38+qNff/Trj2OPeP9/7O8/4xMCWrOhQ9A704UH5bx/nfUHSykEJDpoYToEXXzhQYl1YSmFgEQHLUyHoIsvPCixLiylEJDooIXpEHTxhQcl1oWlFAISHbQwHYIuvvCgxLqwlEJAooMWpkPQxRcelFgXllIISHTQwnQIuvjCgxLrwlIKAYkOWpgOQRdfeFBiXVhKISDRQQvTIejiCw9KrAtLKQQkOmhhOgRdfOFBiXVhKYWARActTIegiy88KLEuLKUQkOighekQdPGFByXWhaUUAhIdtDAdgi6+8KDEurCUQkCigxamQ9DFFx6UWBeWUghIdNDCdAi6+MKDEuvCUgoBiQ5amA5BF194UGJdWEohINFBC9Mh6OILD0qsC0spBCQ6aGE6BF184UGJdWEphYBEBy1Mh6CLLzwosS4spRCQ6KCF6RB08YUHJdaFpRQCEh20MB2CLr7woMS6sJRCQKKDFqZD0MUXHpRYF5ZSCEh00MJ0CLr4woMS68JSCgGJDlqYDkEXX3hQYl1YSiEg0UEL0yHo4gsPSqwLSykEJDpoYToEXXzhQYl1YSmFgEQHLUyHoIsvPCixLiylEJDooIXpEHTxhQcl1oWlFAISHbQwHYIuvvCgxLqwlEJAooMWpkPQxRcelFgXllIISHTQwnQIuvjCgxLrwlIKAYkOWpgOQRdvXrwhgJ8QkC8Ovns3fxEiwg9M1cJ0CGSiawglvm9YqiEg0UEL0yHo4gsPSqwLSykEJDpoYToEXXzhQYl1YSmFgEQHLUyHoIsvPCixLiylEJDooIXpEHTxhQcl1oWlFAISHbQwHYIuvvCgxLqwlEJAooMWpkPQxRcelFgXllIISHTQwnQIuvjCgxLrwlIKAYkOWpgOQRdfeFBiXVhKISDRQQvTIejiCw9KrAtLKQQkOmhhOgRdfOFBiXVhKYWARAcI5y9v61c88xf6H/PAeKwLy7EQkOighekQdPGFByXWhaUUAhIdtDAdgi6+8KDEurCUQkCigxamQ9DFFx6UWBeWUghIdNDCdAi6+MKDEuvCUgoBiQ5amA5BF194UGJdWEohINFBC9Mh6OILD0qsC0spBCQ6aGE6BF184UGJdWEphYBEBy1Mh6CLLzwosS4spRCQ6KCF6RB08YUHJdaFpRQCEh20MB2CLr7woMS6sJRCQKKDFqZD0MUXHpRYF5ZSCEh00MJ0CLr4woMS68JSCgGJDlqYDkEXX3hQYl1YSiEg0UEL0yHo4gsPSqwLSykEJDpoYToEXXzhQYl1YSmFgEQHLUyHoIsvPCixLiylEJDooIXpEHTxhQcl1oWlFAISHbQwHYIuvvCgxLqwlEJAooMWpkPQxRcelFgXllIISHTQwnQIuvjCgxLrwlIKAYkONHz8yYAMqmS+v2LepC7uWK1Pfno1V6Bx4b8OOcV9rRXPGdY8Xj/fdXGRu2tq5W0EA42L858/dF3lK7NVOZuaxrn+XH/t1darKlKuainQuHj/ef/p6/VntVTNzFh6i3P/cf9x/9Et8wFceynQuLj/uv+6/15vm9wttWemqnE+f17V+YNfIs1/KIT3BfRfJNVzGWhc3P/c/9z/3P+uMtB6/RI0zv3/G+v/b96OT3uZ+Y3HeMX1/btAzv/s15mF81+brXTdmjVuxAONi88/n38+/643TO6W2jNT1Tj3/2+s/x+5Xk+R8+/+7/Nv9ST3n2+0/2xvCJCDgJAg2pN6eG6C08BqZGVeDJYMN32T4RCC0Knn9bM2IieaGMlowheDohYdIYHzPzKg2XD9uf7iE1FGXbz8V1e0amS7HVB0hAShVs/15/pz/a2erBvjpX11xJSQSQgJvP9GBjQb7j/uP+4/7j/RE7QxaEs9uuYRFEImISQ4ZnL/eTzevp0vbc//Rp6W6W8ImGnrOZzM9UN0hAQxRD3n3/3f/d/9P3qCNoajubwYFLXoCAm++P7zdmym+d3ikX382/P9t3OK3zZBpEU9nz8+f3z++PyJnqCNAQ2U9sUgVe4/kidCAvffkQHNhs8fnz9f2vmzvSFgK/ixAe7eSQelbhDprAdMXakDlUu9UoopIMjoyxqK10YudaByKVRKMQUEGX1ZQ7HXH6ngu5wGjrxdJE8pxZVJoIy+rIH2rNYYdzFYKcU1E1BGX9ZA6/X3bIV/kTylFFcmgTL6sgZa53/PVvgXyVNKcWUSKKMva6B1/vdshX+RPKUUVyaBMvqyBlrnf89W+BfJU0pxZRIooy9roHX+92yFf5E8pRRXJoEy+rIGWud/z1b4F8lTSnFlEiijL2ugdf73bIV/kTylFFcmgTL6sgZa53/PVvgXyVNKcWUSKKMva6D95vKvnxAQP1SNJc83BHxz6/+gv3+v/9JrNN98/Tn/zv/9a4SuP2Qg90ntlkDlhmzv5e/Gbxzuc7vPiJWu7a6+Wn+O1C9J8TnrPuOpUGZXh3+xgFKKda7EGX1ZU6N2dfgXg5VSXDMBZfRlDbTIa6kDlUuhUoopIMjoyxqK/frzSIVff65qCVQuC0UpxRQQZPRlDcWuv5EK119VS6ByWShKKaaAIKMvayh2/Y1UuP6qWgKVy0JRSjEFBBl9WUPxZ1N/fEPA/Tf2fnwzb1oxre9ufLd3o+74mSDEYDNp3UsOEa/v/GszYwkV0IIZ+L6aKtY13dPpXP/ef95/3n/SIQgJtGG4/7j/jhq4eykPNQObpdM9LSefPz5/fP74/JEOQUigDWPgO37KEIPNod1LDhHvv9e7/96Oj5l+Pz8DOZ7X+YyNnfL+e2Gndz7wTMOmons6yueP6//11v/1fdZ9Nbv/ITew3v8zAz0bP5j+9/bN+JMB4ytBN8cnBLj/uP/4/ld2KCGBbtgXd3Pt9D62ezqd73/cf9x/3H+kQxASaMNw/3nhbsr9FzUDm6XTPS2nT3v+jDcEvBtfi7x4za+MQL+6hrsCX/iStOBw1h9uwsds1ERNWPXyYlHl6D7S6+fB7fxHBlpxuP68/0aPG/93/xlpkHYvDXdrqm0DrabSTVe4/7r/zh+c1qMVh/uv+6/7r88fn7++//D9x9d5/zU/Zro/5hsCxt+e9vkrL2v4/sP3H77/8P3H677/4CcEzIY+yjVemu3NvXmtxY+G758//fMn7wZacfj88/nn88/n3+s+/+JwY98iaGeeOl3h88/nv8//7/f85ycEbK8gyO3lttHudyQjfaPWzMnrlUMG6KNq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAY8ibt/MlgPnffDkoZ9k/ahoz68rgYp64dKZWLVTahfoQhncaflq9csgAUCVXqxZSdeA+hOGdhp9WrxwyAFTJ1aqFVB24D2F4p+Gn1SuHDABVcrVqIVUH7kMY3mn4afXKIQNAlVytWkjVgfsQhncaflq9csgAUCVXqxZSdeA+hOGdhp9WrxwyAFTJ1aqFVB24D2F4p+Gn1SuHDABVcrVqIVUH7kMY3mn4afXKIQNAlVytWkjVgfsQhncaflq9csgAUCVXqxZSdeA+hOGdhp9WrxwyAFTJ1aqFVB24D2F4p+Gn1SuHDDD6d3xCQHH9EwKKJ8LEJBLsNHxdGVwN7Ux914VKu1AfwvBOw0+rVw4ZAKrkatVCqg7chzC80/DT6pVDBoAquVq1kKoD9yEM7zT8tHrlkAGgSq5WLaTqwH0IwzsNP61eOWQAqJKrVQupOnAfwvBOw0+rVw4ZAKrkatVCqg7chzC80/DT6pVDBoAquVq1kKoD9yEM7zT8tHrlkAGgSq5WLaTqwH0IwzsNP61eOWQAqJKrVQupOnAfwvBOw0+rVw4ZAKrkatVCqg7chzC80/DT6pVDBoAquVq1kKoD9yEM7zT8tHrlkAGgSq5WLaTqwH0IwzsNP61eOWQAqJKrVQupOnAfwvBOw0+rVw4ZAKrkatVCqg7chzC80/DT6pVDBoAquVq1kKoD9yEM7zT8tHrlkAGgSq5WLaTqwH0IwzsNP61eOWQAqJKrVQupOnAfwvBOw0+rVw4ZAKrkatVCqg7chzC80/DT6pVDBoAquVq1kKoD9yEM7zT8tHrlkAGgSq5WLaTqwH0IwzsNP61eOWSA5OMNAfhXK21pzEKpTCSxmCj88XJE4+dig1ifDDC9u4fXHy/pRPrkPT6Sy4RylZjzP5IR+XD9ef+NDjNfFeVj1sYgGscggfuP+4/772yjPn/4HlM5YxPKVWI+f0cyIh8+f33+jiO1nbWzNnz+9pzwtoPA9x++/3j2/qP9q9JVUfmLpOl4/7n/uP+6//KouQQ+f17H+YNeHmfBbN3ziRmPecVHNgdOImLZ46fA99++/45CWXUxzSgU33/PzfPiw/0P7cOv//j1n7VZ5IxJKFeJ+fwZyYh8+Pz1+TuOmXbWzNoYROPOo+hVnT/jpnOW8/mIIldaifWrA6UolV8rME6wNo/4HLeBQ6KE14+jW1PC9Dn/vK1hfghcf5EKyQfrZgOHRAnvP++/ceusJcHycf9x/1k/VrE+CNx/IxWSD+6bDRwSJdx/3X/df33+jJ5x/LDp8/fbdP6++Y4UwDgipve98SN9sDwyCHz+RiokH9uxS/eQKOHz1+evz1+fv1/v+Tv//MvsMtnFR49pL826/9TNjvuv+6/7r/vv19t/o/Xiou02OCXcf9x/3H/cf768/nP8yYDe9tYtmJJ7c4xYCuZ1PuolihoIBJtKvWZE48QE0AsRMP15nQ+vn3lYr/6Eg4zBQlG2coj8UUsAtRAB05/X+cB4r195AoLNTOk1IxonJoBeiIDpz+t8OP+ZB9df1QkQLDJUNiMaJyaAWoiA6c/rfLj+Mg+uv6oTIFhkqGxGNE5MALUQAdOf1/lw/WUeXH9VJ0CwyFDZjGicmABqIQKmP6/z4frLPLj+qk6AYJGhshnRODEB1EIETH9e58P1l3n4NtQf/1Xp+Jbx/NcvkrIuZjaAYJGhshnRODEB1EIETH9e58P1l3morBeSzEG0bOUQ+aOWAEOECJj+vM4HxteqhWRkinmtOTCeWgKIhQiY/rzOB8bXqoVkZIp5rTkwnloCiIUImP68zgfG16qFZGSKea05MJ5aAoiFCJj+vM4HxteqhWRkinmtOTCeWgKIhQiY/rzOB8bXqoVkZIp5rTkwnloCiIUImP68zgfG16qFZGSKea05MJ5aAoiFCJj+vM4HxteqhWRkinmtOTCeWgKIhQiY/rzOB8bXqoVkZIp5Hb9iefs2hHP8/Idl797NX7tMZ/xXk3YiYimY1/koaQ0Egk2lXjOicWIC6IUImP68zofXzzzoE4eMwUJRtnKI/FFLALUQAdOf1/nAeK9feQKCzUzpNSMaJyaAXoiA6c/rfDj/mQfXX9UJECwyVDYjGicmgFqIgOnP63y4/jIPrr+qEyBYZKhsRjROTAC1EAHTn9f5cP1lHj7H+ss/GYAnUZ7n+JbwWQbDYYgA3/SyO3/pg1y2G1kEcw7B/Cis8cDIAksDQ8EiLn2Qy3Yji2COIfD6kQxkzvkf6aiOtwplGCZoUZc+yGW7uZhjCFx/kVBk7sgzngEKnP+eMM0HkrRsN64/pIc1NQjvv15Oe46YqwG0L+668EEu243rD+lhTgfh+nP9jQywNAhQJMvu/KUPctluZBHMOQSuv0gGMldPhPPfMsAEoXaGPc4DiJbtxvWH9CCxH/HzN94QMJM90z3/7VK8IeCYaz4fIHviwR61/RHr40s9x871GF3PLVby+pGcngbXP8oDZeP6G2WSm4ipIUCSlt35Sx/kst24/pAepPYT11/18vwC3r975+ff9R/FwNIkQJEuu/OXPshlu/H+R3qQ2k+8/897qPEFuf5d/yMDLE0CFOmyO3/pg1y2G1kEcw6B6y+SgczVE+H8twwwQaidYf3zX6Uo8oMkLdvNq9h/9QkBcvjVd1FfI74VjQFXrBBisBE5wkJ4fTZf5GxaZAhWY8AVK4QYbESOsBDOv/O/Dn/UzLSoEFiNAVesEGKwETnCQrj+XH+uP2wXWuwQWAYEVKyQhANG5AgL4f3n/ef9t28bn38jI/mLxrRHggZRXaTQrovIERbC/cf9x/1n3zbcW7JTmmb/JdIM1icElNT7b2yvI4lCuP+4/7j/VMNYCDsE9hAMomKFdl1EjrAQ3n/xCQG415r5m30cGYLd8xq6cdneNnLIYvwxiRDOv/uf+9/1vhms7JRbzUsq7z/ff/n+c2wd/SWx7iqfPz5/fP7cni2f6vypNwTol7KvvvvUnoGTobjAEL0f3TH/TUPRRPsku38rfOlI5qAQeX3n3/XXTufaIPt+230qz8DJUFxgiLz/vP+8/7z/qikI2pvI7lN6Bk6G4gJD5P7j/uP+4/5TTUHQ3kR2n9IzcDIUFxgi9x/3n6+j/8yPmX4zPl96/VXTsFdvCKjiG8j15/3n11/8+lN/db5axH6I7T6VZ+BkKC4wRD7/zvMv39w178lGgoZ5P/5kQDxuk3oGTqbSTjREzv+Zf81P2xq3ST0DJ8NZCzj/rj+fvz5/W5Op9jDbfwvtPqVn4GQoLjBE7v/u/1/Hz5+9UOPOpZVuFZ0g19+r3X/9DQHxRMlTfPOuHT610n0SCjFFcMPOy6RGGS4e4QhkcCTK6/NlWud/FAOzwTIhkAJKKMSqp+hOQc+L68/7z/3H/Xc0gvmCS5rZFvIxCJ8/Pn954vj89fnr+w90x9NKA00oxFTDDTsvvv/y/Zfvv77O+683b+dpNf/L/TXRu3luzUfsO1jvv0yJ6+/rrL8oPZQYC25mejxcf7U1I+k+/3z+3fef/dNe9E8G5Ibarthf3GpCTCncsPPi+nP93dffrBe//uHXP/z6R7TKsRnGhvDP/ysZFybOleQTCjFpuGHnxeePzx+fP6/55698QwA2bmzZvHRKPIEifw5iLliZpVPiCRT5cxBzwcosnRJPoMifg5gLVmbplHgCRf4cxFywMkunxBMo8ucg5oKVWTolnkCRPwcxF6zM0inxBIr8OYi5YGWWToknUOTPQcwFK7N0SjyBIn8OYi5YmaVT4gkU+XMQc8HKLJ0ST6DIn4OYC1Zm6ZR4AkX+HMRcsDJLp8QTKPLnIOaClVk6JZ5AkT8HMReszNIp8QSK/DmIuWBllk6JJ1Dkz0HMBSuzdEo8gSJ/DmIuWJmlU+IJFPlzEHPByiydEk+gyJ+DmAtWZumUeAJF/hzEXLAyS6fEEyjy5yDmgpVZOiWeQJE/BzEXrMzSKfEEivw5iLlgZZZOiSdQ5M9BzAUrs3RKPIEifw5iLliZpVPiCRT5cxBzwcosnRJPoMifg5gLVmbplHgCRf4cxFywMkunxBMo8ucg5oKVWTolnkCRPwcxF6zM0inxBIr8OYi5YGWWTokncMr1l0h4W8AHPyEA62AuWPDDdko8gSJ/DmIuWJmlU+IJFPlzEHPByiydEk+gyJ+DmAtWZumUeAJF/hzEXLAyS6fEEyjy5yDmgpVZOiWeQJE/BzEXrMzSKfEEivw5iLlgZZZOiSdQ5M9BzAUrs3RKPIEifw5iLliZpVPiCRT5cxBzwcosnRJPoMifg5hrWe3lc8Lq4xBOcvzH39hN1ffxwFywMlWnxBMo8ucg5oKVWTolnkCRPwcxF6zM0inxBIr8OYi5YGWWToknUOTPQcwFK7N0SjyBIn8OYi5YmaVT4gkU+XMQc8HKLJ0ST6DIn4OYC1Zm6ZR4AkX+HMRcsDJLp8QTKPLnIOaClVk6JZ5AkT8HMReszNIp8QSK/DmIuWBllk6JJ1Dkz0HMBSuzdEo8gSJ/DmIuWJmlU+IJFPlzEHPByiydEk+gyJ+DmAtWZumUeAJF/hzEXLAyS6fEEyjy5yDmgpVZOiWeQJE/BzEXrMzSKfEEivw5iLlgZZZOiSdQ5M9BzAU7ZumfEMBpRQHugopQ8BIkJOA9bDEfuq9V5foCLiivPzIQeZHkEBI4/yNNeLEMP0tVdlZ9NXMRvaBiSPASJCRw/p1/19+ogdoRHbetV5uq0zpYI8FLkJCA6xbj9TUXms7EF9ELKrTBS5CQwPkfifL50/dcVcdZfV254ncDgpcgIYHrz/Xn/TdqoHZEx+cOVKX3X2TgIiXFS5CQgHkv5uvL/5s3408GjBXm3HjkL5JqNSDYqVOMcWUvohdU6IOXICEB1yrG62suKu9AF9ELyvkfGYi8SHIICVx/I02+/+w9p6oDe07tRfSCihHBS5CQ4KPrb74hQJ8nftLLXKim0y/U9R95keQQEjB1xdynM5OrypXuCyoiwUuQkMDrj0RpXc+8VXYii9vlInpBxaDgJUhIwLWK8fqaiy35w72IXlDOP1IlySEkYDaLucywPA2qXPQF5fw7/1lcUhyEBK6/USY+f3rPqepY/WWZ8YaAcds5PicIn4xyJQQHO8cCw/Zp1VOFYmjGixle3/mfO3Y8rivkfkNf6XMmXFWhuOKuP+9/97/cD9c7xPvv7obiKl/oLGdGr9Q+/9x/3X/df89ugT6CrgE7eWBYaE+rCsVQuv+4/7j/fK79J/9VKe5Ock/Xvyydvu55xd7/K1t+/cGvv/j1F7/+Eu3gukN+mp9/o5fPg2j9yRf0cXxNsPMLBYbNXnZ1VYViaH3/5/s/3/99rvd/VzsaOzutKhRD5f3v/e/97/1/dovqEJ/m/meud92hvD5+wl+36czTVb7wvKVVhWKoev+XTwhY4jA6UPk5icYw6cdbjh6g/b0izBsCqmo9UgQfv6goOXoAr58bLdOzMhOGWXL+W13OTGluMnNf5crRA7j+XH9o8KyrKBBWSdUbKYKvUnbUcvQArj/Xn+sPW2PtjDDcJd5/OO+YEgIk7itZjh7A/cf9x/0H22ftjDDcJe4/7j+jBsYuYUkQROHovyrNShqfF/D+XcKLK0cP4P7r/uv+i02ydkYY7pIRVH5qNYaxH285egDvP+8/3X/z01700T7pRQsn/r2bKj8e6zSuP9ef1l/dZ7BKRmEtTIrg44tOlBw9gOvP9ef6w+ZYOyMMd4n3n/vPqIGxS1gSBCicr2Q5egD3X/ffvf/KGwJ6XbFwQG8FNN/E2t9VIyMAw453IIyCroXnhBBg8tMeikFoAXt959/1l/sm94rsGMCw3n/uP+6/Pn/0jEWDUK7jQzEIn791A+n7D99/+P7D9x8zA9krpWMChvX9l++/vrn7r/yEgOzF6x+WPsaH/uVB5fobefD+8/775vaf+7/Pvzzu8xp3RIBfsf/izV2zec+uhU8IwJz++SuPtdhzI7e+/47K8P3nSMPcMawOwK+4/zKbmlNhxlzef8xwfIiJ95/WCopucICuv1Ewvv/2/bfvvz+X3z/wDQHHttVXvOVcBDz0CIRtHbEiBw1i9tBt23j90Ux7GVUiL/KlwX4iVQTphqXuYj7n3/l3/dXe2dDRr1ocGwx2BeHCev+NxGSPO/Lp/uP+4/7Tuoo6x37RIPsKG01G4cJS5/P/yKf7j/uP+0/rKuoc+0WD7CtsNO4/MwNIByyJ5/sv3hCg6c9PCJj3VVwow3BhJX48n+5/7n/uf7qtGj72yxbNn2u40bz/ZgaQDlgSz/e/lnY6WAB2BeDCvrL13+ITAlbrbm8I4PeWwPW3vV7c8oMnGPbzeP7br018/vr89fnbdrU67n/uf61fanHwXHf/z/tQn3+RAZQDLOvE95/op2/GvyaYnaU9mK/BzptSvOigfBswdeO/Ns1GbG4MD+4ioJTXd/5df7mzdF94//UMHLnZiM11/xkZiJxcJEYp91/3X/df99/ZMLUvRAOVyxHbiM2NkcFdBJRy/3H/cf9x/5kNQ/uCtJ7qJUpu4s2tMRcBpV57/8HemN/QrJL5tc+veU+Wfk9TOx/BXQSUeu3ff34nx7d7EPo9tTEXAaX8/fv8wR7TukANwR6xjdjcGBbcRUAp19+3p/5QZ6yp0cf9/H97nn8+7wPkHd84xvz6u3//sN4YoOcCagX2iG3E5saw4C4CSrn+3H9wLmldoO5gj9hGbK7rb2QgcnKRGKW8/7z/PuX+4ycE5MbWUpyM+opT3cKLwphUj6t+zg408wWLy3e/7Wuor9jrRwYuUuL8Z1J4df3VTxfef5kB9x/3X58/6AZi9wNFfcVryAXl8yeTwqvPH58/eHUPO83nj88fnz/YDWL3A0V9xT5/IgMjJW/eVnOZ/2JmvtN/voiU2RpXnz8+f6pEcuP4/PH54/NHzh3A/YxRX/HSX1Dfz88/eOG3+vi7sRA278ViF9T3sz7GIhvdv1jsgsKYDI2rz596CpFY91/3X/df7Aaxe0NRX/EackG5/2RSeHX/df/FLQR2ms8fnz8350+8IUDfhZINdVbOqqLoLGwvUVKor2I7g7qjncL5EsXlFzEio0BxM+z1I1kjX85/1E8UWVziRa7J9WrLWGjXy2CJ5RopHRfXnySloPef+4/7r3aVuTfcf6NDRHvNHhtttDJTv3RArtx/JTuRvbxE4sbF548kpaDPH58/Pn98/kizHNDnb+Qjjt64XP78851xpsTxsjI28eyn7RHuuPj8aWmB4/PH54/PH58/2Q/QOz/9+fMm/mTA7NPrK3k38Pxyxt9hnuS8zoc+U+1vp6c4RXqNgePi/q9ZIXb/d/93/9euMrcGmtCE7j8zH+6/2TK1Unz+5N7IzChOJq5ROOPi81eSUtDn7+s5f/MTAqKOs5gJ5/OFnV/P3S2a4+YjhjQneb0eYS662ssh0NHXuA1pzqk/wpOQQy/gHObv/0zeDdNy2pxzwBF2/l1/3n/RcLgV5rZx/zmbxw3TekpzzgFHmEn3+cNUzLS5/s7iuWFaTTXnHHCEmXTXH1Mx0+b6O4vnhmk11ZxzwBFm0l1/TMVMm+vvLJ4bptVUc84BR5hJd/0xFTNtH1F/85dIU5afCZC5Hn8GMMHNeOd/Sw+T7vpjKmaKbuons9evraaa03XTO8Jc1PlnKmainP+ZhY96tJpqzjn8CDPpP9j6yzcEZDefX/Xxxq7zWyHTvqfmUEJwhF/J9z8Lnl/K/Gpd/3zOPgTac9qcc+QRZtKdf6Zips31dxbPDdNqqjnngCPMpLv+mIqZNtffWTw3TKup5pwDjjCT7vpjKmbaXH9n8dwwraaacw44wkz6D77+3rwbd539eY+vbn0X8qUvWqNTlP5NELkY4ffjF37zo7DygVnmyxjF9tj0pm4+xribJZK+CebgGOv1NdMrXyOpyma6EJvexPPh/Lv+WhlEVcxLs1unwQAAQABJREFUVsuqGS0dKlLk/ac7DYny/tOsZMkgN9ObeD7cf9x/WhlEVcxLVsuqGS0dKlLk/qM7DYly/9GsZMkgN9ObeD7cf9x/WhlEVcxLVsuqGS0dKlLk/qM7DYly/9GsZMkgN9ObeD7u+0/9y7ZUzuvxi6QxjetPM40cu/40K1lByE1UUlIv1F+q1xgdukaGGbzrTzONRLn+NCtZMsjN9Caej/v+l+o1RofmwLwO/nOov+jl41vFt/3+/fyTAfPx7fj+83vVJ3Hi+fD3v240YTIt45rZWjnT1FGRos+h/vNL1m9i4vnw848nXrMzM5P+YvfgFMzH4P3860mDRPn81aywWOZ+i8fM03x4/3n/tTKIqpiX3ElrP2FbMbrA4N1/dKchUa+v/4xPCJj/nEDemYBeIE8qvnyhvhJs46czH1wno3FtwpTN6w1dgg+gNn468+H1Mw+6pVuiVniYG7oEH0BtvPOf2XL9rarJ6ohrK5Qqqhu6BB9Abfx05sP5zzx4/0cxRI20QlnpGeaGLsEHUBs/nflw/WUeXH9RDFEjrVBWeoa5oUvwAdTGT2c+XH+ZB9dfFEPUSCuUlZ5hbugSfAC18dOZD9df5sH1F8UQNdIKZaVnmBu6BB9Abfx05uMLqb83b8c3Mr6n+e3gW9vfEPAlf//xXH7g4u9/K/eZry+k/j/w1EfYz//2dPv53xLyOl7/fDs+Urj6+Pia1hsCWv1+TMFvmjZ+OvPh/Z958P1XFEPUSCuUlZ5hbugSfAC18dOZD9df5sH1F8UQNdIKZaVnmBu6BB9Abfx05sP1l3lw/UUxRI20QlnpGeaGLsEHUBs/nflw/WUeXH9RDFEjrVBWeoa5oUvwAdTGT2c+buov/2TAFLRRk5DH/JuE8+9fDDM/ToBzieQO1rRX74aQUSUUckGv7/y7/rz/3H/cf33++Pw97xBumbqt8P2Hvkf1SFgl6giNVyZ9/+H7D99/+P7D9x+v7P6jPiFg/lQ+m/i4zn69HhPlz+s+/3z+7Z/GiCoZtgpFyAV9/vv+x/c/3/j9T7y5S3Yf+7j3n/ef9983vv9uX1jx/vP+8/7z/hv3yP79J36elBuVF2D9WOGfPz+Hnz8v/mSA/hA4cb6csD/n9UTvkeHPIB6Xw9foYW43WBzCc5LLCV78+dXrI/l36XP+o65cf95/o71cdhj3n5WYy+y4/9611tl6Z3vF4zJ97r/uv6MwfP74/BllcN0iRnFE4DLq/jv663VmRsD9F6fPTZJ8/kRivoD+W28IqKc8PvQP7uUm8fP/pTz/eJqbdf+rdLj+KxdE3v+vcf/vn/aSnxBwWcC+/xu1fJ2ZEXD/406/TpL3/2vc//WkzRoez1EU+HWVr2ewDaHj+mcqXP+VikLe/97/o6+MMvDvX2/uI76l/Zd/MiCaxcUp06lqJNFoe7D6zbpdRRiWgkaIIxDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0PJCzEtBlAGHYLL1eiAqHt1PJAwkJMmwGEYbfwciUqENpOLQ8kLMS0GUAYdgsvV6ICoe3U8kDCQkybAYRht/ByJSoQ2k4tDyQsxLQZQBh2Cy9XogKh7dTyQMJCTJsBhGG38HIlKhDaTi0P5LD7vyqd4/CLJJH110URiEXEEfix6/eJ+yhMB4to/22WRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZerkQFQtup5YGEhZg2AwjDbuHlSlQgtJ1aHkhYiGkzgDDsFl6uRAVC26nlgYSFmDYDCMNu4eVKVCC0nVoeSFiIaTOAMOwWXq5EBULbqeWBhIWYNgMIw27h5UpUILSdWh5IWIhpM4Aw7BZebkX7m7vyTwZUdMqXBxKWEwNkAGFYRDFN+hIVCG2nlgcSFmLaDCAMu4WXK1GB0HZqeSBhIabNAMKwW3i5EhUIbaeWBxIWYtoMIAy7hZcrUYHQdmp5IGEhps0AwrBbeLkSFQhtp5YHEhZi2gwgDLuFlytRgdB2ankgYSGmzQDCsFt4uRIVCG2nlgcSFmLaDCAMu4WXK1GB0HZqeSBhIabNAMKwW3i5EhUIbaeWBxIWYtoMIAy7hZcrUYHQdmp5IGEhps0AwrBbeLkSFQhtp5YHEhZi2gwgDLuFlytRgdB2ankgYSGmzQDCsFt4uRIVCG2nlgcSFmLaDCAMu4WXK1GB0HZqeSBhIabNAMKwW3i5EhUIbaeWBxIWYtoMIAy7hZcrUYHQdmp5IGEhps0AwrBbeLkSFQhtp5YHEhZi2gwgDLuFlytRgdB2ankgYSGmzQDCsFt4uRIVCG2nlgcSFmLaDCAMu4WXK1GB0HZqeSBhIabNAMKwW3i5Eh2wPiEAPCxHnyAl98IzsjPlEwHAnsuSScm98IzsTPlEALBc7QQpuReekZ0pnwgA9lyWTEruhWdkZ8onAoDlaidIyb3wjOxM+UQAsOeyZFJyLzwjO1M+EQAsVztBSu6FZ2RnyicCgD2XJZOSe+EZ2ZnyiQBgudoJUnIvPCM7Uz4RAOy5LJmU3AvPyM6UTwQAy9VOkJJ74RnZmfKJAGDPZcmk5F54RnamfCIAWK52gpTcC8/IzpRPBAB7LksmJffCM7Iz5RMBwHK1E6TkXnhGdqZ8IgDYc1kyKbkXnpGdKZ8IAJarnSAl98IzsjPlEwHAnsuSScm98IzsTPlEALBc7QQpuReekZ0pnwgA9lyWTEruhWdkZ8onAoDlaidIyb3wjOxM+UQAsOeyZFJyLzwjO1M+EQAsVztBSu6FZ2RnyicCgD2XJZOSe+EZ2ZnyiQBgudoJUnIvPCM7Uz4RAOy5LJmU3AvPyM6UTwQAy9VOkJJ74RnZmfKJAGDPZcmk5F54RnamfCIAWK52gpTcC8/IzpRPBAB7LksmJffCM7Iz5RMBwHK1E6TkXnhGdqZ8IgDYc1kyKcnr2zdvx+93Jq7Hu/GvG/q/K9snLZ8IALamO1BK7oVnZGfKJwKAPVYtIiX3wjOyM+UTAcDWcgdKyb3wjOxM+UQAsMeqRaTkXnhGdqZ8IgDYWu5AKbkXnpGdKZ8IAPZYtYiU3AvPyM6UTwQAW8sdKCX3wjOyM+UTAcAeqxaRknvhGdmZ8okAYGu5A6XkXnhGdqZ8IgDYY9UiUnIvPCM7Uz4RAGwtd6CU3AvPyM6UTzTAm+/kv9rDgvyTASCWzTEcuUX5tgHhd235RACwMnqHKbkXnpGdKZ8IAHZfVPyU3AvPyM6UTwQAK+vtMCX3wjOyM+UTAcDui4qfknvhGdmZ8okAYGW9HabkXnhGdqZ8IgDYfVHxU3IvPCM7Uz4RAKyst8OU3AvPyM6UTwQAuy8qfkruhWdkZ8onAoCV9XaYknvhGdmZ8okAYPdFxU/JvfCM7Ez5RACwst4OU3IvPCM7Uz4RAOy+qPgpuReekZ0pnwgAVtbbYUruhWdkZ8onAoDdFxU/JffCM7Iz5RMBwMp6O0zJvfCM7Ez5RACw+6Lip+ReeEZ2pnwiAFhZb4cpuReekZ0pnwgAdl9U/JTcC8/IzpRPBAAr6+0wJffCM7Iz5RMBwO6Lip+Se+EZ2ZnyiRYYnxAwPxtBH5CAni8tDIzPlkA4WXnhAQFYnbMwowHolYBvX52x+fD6zv+oBdcftwI2Xd898GBz9+xXRgPQExm4aefD+8/7b9SC9x+3gvdfdgZ0iu51NmN1ZTQAvRL4/B+5WD03suL+6/479on7b22LuSXGo3cPeLCp2a+MBqAnMnDTzof3n/ffqIVXuv/mGwIeb+bXl9U6r8eP9BWqPTP1cxxuZqgBhwld/67/UQuvtP7XUTCqV+u2WJb1AlClnJ7IwE07H65/1/+ohU9Q//MTAla1ReXhk16c/0+T/0h66yPe/+5/7v/uP+4/n+L8c/+dGZj3nXoX4P7j/vPp+s+b8fcGxz8nQBHmlry6XivAwvaR84WJ/Bis+W8Y8mY3FEOO++v7H8y2uYY7t0Z/YF3YLer1nf/xQ9ZsKK4/7z/2D/cf999RDFEPcXRcnx96mlwrwMLqiNF1fP74/PH54/PX9x++//LPP/Xz2zgu/fPf13P/8Wa+IQCP+Qulcc8xf6SfD99/+PUHv/7in//9+sfn8fpP7NUo11Wzq49HLx+X+Hl1Onzg505YBgK4/7v/u/+7/7v/fx79v3fv7t10+CHK+r48Hfz6o19/9OuPY494/3/s7z/jEwJas6FD0DvThQflvH+d9QdLKQQkOmhhOgRdfOFBiXVhKYWARActTIegiy88KLEuLKUQkOighekQdPGFByXWhaUUAhIdtDAdgi6+8KDEurCUQkCigxamQ9DFFx6UWBeWUghIdNDCdAi6+MKDEuvCUgoBiQ5amA5BF194UGJdWEohINFBC9Mh6OILD0qsC0spBCQ6aGE6BF184UGJdWEphYBEBy1Mh6CLLzwosS4spRCQ6KCF6RB08YUHJdaFpRQCEh20MB2CLr7woMS6sJRCQKKDFqZD0MUXHpRYF5ZSCEh00MJ0CLr4woMS68JSCgGJDlqYDkEXX3hQYl1YSiEg0UEL0yHo4gsPSqwLSykEJDpoYToEXXzhQYl1YSmFgEQHLUyHoIsvPCixLiylEJDooIXpEHTxhQcl1oWlFAISHbQwHYIuvvCgxLqwlEJAooMWpkPQxRcelFgXllIISHTQwnQIuvjCgxLrwlIKAYkOWpgOQRdfeFBiXVhKISDRQQvTIejiCw9KrAtLKQQkOmhhOgRdfOFBiXVhKYWARActTIegiy88KLEuLKUQkOighekQdPGFByXWhaUUAhIdtDAdgi6+8KDEurCUQkCigxamQ9DFFx6UWBeWUghIdNDCdAi6+MKDEuvCUgoBiQ5amA5BF29evCGAnxCQLw6+ezd/ESLCD0zVwnQIZKJrCCW+b1iqISDRQQvTIejiCw9KrAtLKQQkOmhhOgRdfOFBiXVhKYWARActTIegiy88KLEuLKUQkOighekQdPGFByXWhaUUAhIdtDAdgi6+8KDEurCUQkCigxamQ9DFFx6UWBeWUghIdNDCdAi6+MKDEuvCUgoBiQ5amA5BF194UGJdWEohINFBC9Mh6OILD0qsC0spBCQ6aGE6BF184UGJdWEphYBEBwjnL2/rVzzzF/of88B4rAvLsRCQ6KCF6RB08YUHJdaFpRQCEh20MB2CLr7woMS6sJRCQKKDFqZD0MUXHpRYF5ZSCEh00MJ0CLr4woMS68JSCgGJDlqYDkEXX3hQYl1YSiEg0UEL0yHo4gsPSqwLSykEJDpoYToEXXzhQYl1YSmFgEQHLUyHoIsvPCixLiylEJDooIXpEHTxhQcl1oWlFAISHbQwHYIuvvCgxLqwlEJAooMWpkPQxRcelFgXllIISHTQwnQIuvjCgxLrwlIKAYkOWpgOQRdfeFBiXVhKISDRQQvTIejiCw9KrAtLKQQkOmhhOgRdfOFBiXVhKYWARActTIegiy88KLEuLKUQkOighekQdPGFByXWhaUUAhIdtDAdgi6+8KDEurCUQkCigxamQ9DFFx6UWBeWUghIdNDCdAi6+MKDEuvCUgoBiQ40fPzJgAyqZL6/Yt6kLu5YrU9+ejVXoHHhvw45xX2tFc8Z1jxeP991cZG7a2rlbQQDjYvznz90XeUrs1U5m5rGuf5cf+3V1qsqUq5qKdC4eP95/+nr9We1VM3MWHqLc/9x/3H/0S3zAVx7KdC4uP+6/7r/Xm+b3C21Z6aqcT5/XtX5g18izX8ohPcF9F8k1XMZaFzc/9z/3P/c/64y0Hr9EjTO/f8b6/9v3o5Pe5n5jcd4xfX9u0DO/+zXmYXzX5utdN2aNW7EA42Lzz+ffz7/rjdM7pbaM1PVOPf/b6z/H7leT5Hz7/7v82/1JPefb7T/bG8IkIOAkCDak3p4boLTwGpkZV4Mlgw3fZPhEILQqef1szYiJ9/97uO7P/zDjx+WbBbUrBV7ItFN+PjNx2/+v7/l8UM/VB9LKQremwengWPiF4OiFh0hQejU8/Mvz78mRjKa8MWgqEVHSOD8jwxoNlx/rr/4RJxRFy//1R2tGtluBxQdIUGo1XP9uf5cf6sn68Z4aV8dMSVkEkIC77+RAc2G+4/7j/vPD7b/vH07X9qe/42duUx/Q8BsW7prp3/3EB0hQQxSz/vf+9/7/we7/53/Lyf/b8eTOfsrHtnHteP2Tu7+6/7r/f/l7P+2u7ntCaItqOf97/3v/e/9Hz1BGwNuIGhfDFLl/iN5IiT4VvTf7Q0BrSQ+8DJCJqqnS2prg7s6/IvBSinephtuRl/W1KhdHf7FYKUU10xAGX1ZA+351ca4i8FKKeZMv/Grj//qF/+Tx3/+n/3Zx3/9S//t45f//K88/sf//f/ji0Gh+85vf/w1f8uPP37sx/66x9/wE7/r8ft+z+99/OTf9qOPv0J+a/Wh9d//b7/w+Ef/jj/4+IX/6x98/Nu/8guPf+SvrDcF5NeSX93l18gvtsCu/tD6c+TLc+8z1lpXaFd7/VEyFwlWSvGZ04y+rKlRuzr8i8FKKa6ZgDL6sgZa1FKpA5VLoVKKKSDI6Msaio9uFeMuBiuluGYCyujLGmj9/e/ZCv8ieUoprkwCZfRlDbTO/56t8C+Sp5TiyiRQRl/WQOv879kK/yJ5SimuTAJl9GUNtM7/nq3wL5KnlOLKJFBGX9ZA6/zv2Qr/InlKKa5MAmX0ZQ20zv+erfAvkqeU4sokUEZf1kD75eZfPyEgbjLHt3y+IeDL/f6/7c+/v/986aN2+jXau0X4F8lTSvE5a0Zf1tSoXR3+xWClFNdMQBl9WQOt9/+erfAvkqeU4sokUEZf1kD7cfnfe/m78Ru/u3/JfM5Ya12h/asN/+KLV0rxOWdGX9bUqF0d/sVgpRTXTEAZfVkD7ZmtGHcxWCnFNRNQRl/WQOv192yFf5E8pRRXJoEy+rIGWud/z1b4F8lTSnFlEiijL2ugdf73bIV/kTylFFcmgTL6sgZa53/PVvgXyVNKcWUSKKMva6B1/vdshX+RPKUUVyaBMvqyBlrnf89W+BfJ4xsCLmIrm+/H6wxvxv9EQUhQmQ90x88gYrA5tHvJIeL1v/v4S//lv/v4hZ//+ce/9R/8N4+/+Ov4/X/+rcj38zOw8GoQ/plIUIt/853HD//o73v8vf/QH3j8k//Y3//4/b/jty19/bjR8v/+1x7/8R/6Ox8//W/82uN7j7/n8XO/+qcef+THfssYs/QUE+RTxesdPwWIweag7nGi0Pv59/5z/5EdQkigGyb2DPfqFvH+Q85gM0Hd06T5/HP/df91/5UOQUigDWPgO37KEIPNod1LDhHvP+8/7z/ZIYQEumEGvuOnDDHYHNq95BB5zfvv7fiY6f3nv/fvvze+9PrZTr+bL+37v/4+759Nf//IDSyq/DqTM1+vuf6vv+r+vbn+NQPIDayf/5mBno2er09V/2/fzH90M1fLrwefEPCp1r8+Mbz/nX/ff/v+WzokIYE2zNW9rrtJddo+tns6nfuP+4/7j/uPdAhCAm0Y7j8v3M1+qP+ONwS8G1mV5s0cE2zJLrcr0LhXvAWHs/5wEz7m5m6W+l7aBCUX1BVf4vrfe/zGr/77j3/tD//s41/+D3/tMd4HcPOYv/D/mx5//Y/8+uPX/8L//Pif/nL+7TGI8QPGY36+zJsfffzEP/0vPv7Yz/7M43f/yPwlf8/i/DsAv/Fn/4nH3/53/fzjl8cHDzweP/n45371Tzz++R/7IUxH20d+ifmXfcHvuoC/f+0cfv7zxm3VRyuO4bj/RbG4/480tLbSCkXa8cZX2yHqCu8/77/5g5P7T2SgbY7huP+6/47N4fPH58+XdP7Oj5nuj/HS0fzb0+5/0e8yN+7/Pv/GPnH/9/k3WkFvma1RSt/c+N5kw+uK7//nL35CwJx91up8afaFx9e9fizFSQluv4Ku+P6/f68/MsCkEjj/NxnoGXL9+fUPv/7Bnwba5hiOX//w/Z/vf33/O1rBS/e//IQAuRNZ92U4XraDVg/n1nQqsNPw0+q1xnh9ZClz8v79//L4c3/0Dz7+8Z/7k49f/o3BzYY+7xan+W0//viJn/4HHj/zUz/5+D2/+29+/MTv/JHHD+ewuL5//D+P//PX/vvHr/wPv/T45f/iFx9/6k//mccv/rm/9Pi/R3TN8nj81T/1+EP/5h97/Ks/9Tsfv3WNiuh3/8zj5/7Wn378C7/8m0v9dz9+7i/8yccf+WvPNwTUzWtMwEv/TuqZ1Wd+15Qqp6mqK8QFAM5JIrLT8NPqFRNNC1VytWohVQfuQxjeafhp9cohA0CVXK1aSNWB+xCGdxp+Wr1yyABQJVerFlJ14D6E4Z2Gn1avHDIAVMnVqoVUHbgPYXin4afVK4cMAFVytWohVQfuQxjeafhp9cohA0CVXK1aSNWB+xCGdxp+Wr1yyABQJVerFlJ14D6E4Z2Gn1avHDIAVMnVqoVUHbgPYXin4afVK4cMAFVytWohVQfuQxjeafhp9cohA0CVXK1aSNWB+xCGdxp+Wr1yyABQJVerFlJ14D6E4Z2Gn1avHDIAVMnVqoVUHbgPYXin4afVK4cMAFVytWohVQfuQxjeafhp9cohA0CVXK1aSNWB+xCGdxp+Wr1yyABQJVerFlJ14D6E4Z2Gn1avHDIAVMnVqoVUHbgPYXin4afVK4cMAFVytWohVQfuQxjeafhp9cohA0CVXK1aSNWB+xCGdxp+Wr1yyABQJVerFlJ14D6E4Z2Gn1avHDIAVMnVqoVUHbgPYXin4afVK4cMAFVytWohVQfuQxjeafhp9cohA0CVXK1aSNWB+xCGdxp+Wr1yyABQJVerFlJ14D6E4Z2Gn1avHDIAVMnVqoVUHbgPYXin4afVK4cMAFVytWohVQfuQxjeafhp9cohA0CVXK1aSNWBx5A3b+dPdPlTHX622z9qGjPryuBqzs7UqoVKu1AfwvBOw0+rVw4ZAKrkatVCqg7chzC80/DT6pVDBoAquVq1kKoD9yEM7zT8tHrlkAGgSq5WLaTqwH0IwzsNP61eOWQAqJKrVQupOnAfwvBOw0+rVw4ZAKrkatVCqg7chzC80/DT6pVDBoAquVq1kKoD9yEM7zT8tHrlkAGgSq5WLaTqwH0IwzsNP61eOWQAqJKrVQupOnAfwvBOw0+rVw4ZAKrkatVCqg7chzC80/DT6pVDBoAquVq1kKoD9yEM7zT8tHrlkAHG663xCQHF9U8IKJ4IE5NIsNPwdWVwNbQz9V0XKu1CfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAaBKrlYtpOrAfQjDOw0/rV45ZACokqtVC6k6cB/C8E7DT6tXDhkAquRq1UKqDtyHMLzT8NPqlUMGgCq5WrWQqgP3IQzvNPy0euWQAZKPNwTgX820pTELpTKRxGKi8MfLEY2fiw1ivTNpencPrz9e0on0rTdh/OYvPf74H/j7Hv/wv/e/PuIf6Y/ExYs93/nxx+/6w//M41/6p37m8Xt/O35BP3M8BS/l/7uP/+PP/+nHf/TH/+jjX/nX/9PHf/eX54D5+Ksef+PP/juPP/HP/v7H/8/el8DbURXp10tAcBQVBhxxQSAER8BRQFnCqiCbguOwzCiiIjOjgILo34VhSXDBZVA2WcbRcQMdwFEQSBAGkEVZQgAFVCAgOgooyhJckpfl/qvOOV+dqu6+Ly+Xl5DkVf9+r+urqu+c011dp7rvvf26X8p3FPToUbr94zvTNlPvoGGmpDEbrwxIQ6VV7iEfY8Yjjg9ut4zjj/DhJhyOk4lxhmZtfBF/DkaKx0j53513sEb+Rf65+iuJYeZYhmZtfDH/OBgpHjH/bM7k2iKx4bjIiXSEJepP1J+oP1JG4vpH/8fFnGMyNGvji/MPByPFY3yef9x/lZZzTP4hSRSJTZx/4vw7wsWHZAmnSZx/ZLbE+SfOP+ViPZ1T8rzJ0KyNL9dY5o3B91+o5akrHgN13IycT3VLafzI/5j/Mf+fvvkf8y/mX8y/mH/pqsOc4+P8L1+hmiiY2Izl9VfUX66/fNEp4W0vLujitoYSOmvSHkxY1a+gdGN0bdcALYo1rLzj9x69hE7c/2CaetXvaWH5SZ6IXwmw2dtp2tc/Sx/ZfO00OdKp04ZEwzdS/Hs0/OAMOvuDh9Nx//1AeQXBs+j5bz2LrvzKgfSye46jXbc4ka6dL0UZne9Kx/MrA07YaFW2lWLNvsHGR7foWze6DVoUa4jxI/586WRTQjNopPyP/MvTujNwGsEEWhRriPkX8y/mX9QfrhS4JNDqEfU31QaJh5ZMBXH9m0Jh4qF50wAtijXE+SfOP3H+kfPP0ERTgEXnabSQP9Inq04ZBVF/UihMPBplR9UWxRqi/kT9ifoT179cLUz5zbVj8Otfef2LVJncKffjvpqN+lODHfU36m/U36i/pVSmmonV4PUXPSRpy23LEPUn6k/Un6g/XBjG8Ppveag/5oaAXAFtHVSsAJtsDAlmXday1BhVHhBkZtp19li/YgXgG0OCWZe1LCvs+MM/pnPe+UY6+Fu/oQVlJ4Z6q9Bq2x1LF37vGNp9rVXyDtZvmt0XPKPe/94f6KfnHEEHH/Etuvlx6XICPXP7t9FBq36Xvnj1nBS/9IYCiWVvNzr+notp2mQ8kUD4Od6CMlxJ4s97bvasYmusO51Q7D+HoZwZJEyyrLDzL45/zXk+jpr2CtLhtZ6Y/yk2OUCyliXyP8fBZJDmUiuVQC0M61esAGRjSDDrspYl4p/jEPGveQIEiQhVmT3Wr1gB2MaQYNZlLUvkX45D5F/NEyBIRKjK7LF+xQrANoYEsy5rWSL/chzGQ/7pf5XyLuP41x+Scl5INIAgEaEqs8f6FSsA2xgSzLqsZYn8y3GoUa/IRA6kImsMET/lKkATY0gw67KWBe3rqBWZlpms69oH2itXAcjGkGDWZS0L2tdRKzItM1nXtQ+0V64CkI0hwazLWha0r6NWZFpmsq5rH2ivXAUgG0OCWZe1LGhfR63ItMxkXdc+0F65CkA2hgSzLmtZ0L6OWpFpmcm6rn2gvXIVgGwMCWZd1rKgfR21ItMyk3Vd+0B75SoA2RgSzLqsZUH7OmpFpmUm67r2gfbKVQCyMSSYdVnLgvZ11IpMy0zWNf/EMmFCIkp7+f5t0SL52UUU/qudekPyZYKsZanU2hAIMjPtOnusX7EC8I0hwazLWpYYP8fBHjhEDBKMKmsMET/lKgDbGBLMuqxlQfsYv8YJCDJHyq6zx/oVKwDfGBLMuqxlifjnOET+1TwBgkSEqswe61esAGxjSDDrspYl8i/HIfKv5gkQJCJUZfZYv2IFYBtDglmXtSyRfzkOK2L+5VcG4CCa45x2Cc+SY0VdCrDTRTbtnTqMRXphBkGfTJDnZ/GClhUUDoQSiqFTh7FIL8wg6IMJy2z8R+imY3amHU78Kc3HPrEcesWH6Ls/OJH24ZsBUiSwC4aTYNPeqcMocgE9es3/o3/4+9Ppmsetvdnx62kqPyFg6kbPGOPxeW/KsBgdum5B5N8yzD+Ouh6IcgQi/hH/ZVb/Iv9i/nEO1KtJrkdckCL/UjHW0qyg1GiIpr1Th7FIL6L+IzwaUzZE/kX+cQQ0NRQgSYps2jt1GIv0wgyCPpkQ+ZeCgcjVAxHxlwjghgBG6dQp/7uUbgjQgJU4JR3GIr2I/EN4kFpx/RH1J+pvmg06NRRgktj6YmxNXtJhLNKLcV9/ai3PcewtWhTzL+ZfSgbMnLj+4XDY7whQcjRAxdCpw1ikF+O+/rRyK65/ov5G/Y36yxFA5awAhXekems4qQP04gsvrK2+o/4s8/pTnxBggm8Oox4jPWjW2cqF/qzkabmNYVyPv4jmXPFOes2e36B7F+bJl0K76vZ06LXfozO3WVOPQ0f4jc/Es0Hsjv8wPXrth+jN+5xO1z4hjHytlRE64BsCZvMNAZPKDQEwG1lHrci4E0yelrtHC656O714l3Pot7QB7T99Fp2/55quKZpAOmdRqq+iJi95Wm5jWInzb8HVB9GLXncO/Y42pP2m30IXaIzHx/5LLozn4x/7H8c/8p/Pbabc5fODMazE9T/mf8z/mP8x/6P+cSV0Xyav+PW/+SNSqvVyLmssMf9j/sf850mxks1/mea1ilXUmP7x+VcOfSs8xrAcXP/LEwIkPWWrZJEbu7CFkNnj19VXkWfE9W+KTCs8xrAcHH/c/GmPHbYQ0vqAq68i+CCTp+U2hth/LhDu5JBChwhBIp5WVl9F1i84eVpuY4j4R/wj/5rTJs5/HBFcE7SrUw5XrSIVNQOZPC23MUT9ifrD9afeEGAzyORJMjd15bYdbYuSK2BSj6/O8/80VLOiZidNvS+xnHjV3wcsb+PPu5yO32pv+vhPhnmDy/Qfejat98GL6Sf/vjM9d6nu/1z65Tlvpilvv4welHF0fIZJ5xsC7rmk8coA4cnS3rC2JTPdmkk4/sMzDqB19rqA5gxtSPtfeku+IaDZSVPXztqOtkXJFTAJ41ejQc1OmrpS2462RckVMGlZjq8x5hsC9p/BMd6dbzCJ+Rf1J831mpaKmknc1PsSuyqCkitYxvlfBy4oxo/5H/Uv6l/Uv1ZpTIZmvW/q2qrtaFuUXAGT4vojPv/E578+X/E0J1FT15mUHzM9xM+XLm81TbK+MkCJHsT8i/oT1z9x/RPXP74uQmvW26YO3hh8/6VdMcg3d+H7P75G4lcGpGUZja/b0hyvqfclxuf/vqHSmDFgUlz/xvVvXP8+9evf/HtFnVwx/5oRqbFRFPUn6m9c/8f1f8f1v78hIBUKU1D63DViCwv6zIW4UY6hJikruRaSuxAY8LkA7uTITp6o4238YXrwv15Pkw+5jv6cIlKiseruNO2O79LUlz1Tw9MCJoAZGkOJZzo+ySyrPvHvPUCXHfZaeuPZDxA/oECX/NFkN35lwMU0jV8Z0FrMcBkag5ChJimr9vjzZ+zPNwR8m56kSbTfpTPpvL3WREoxmdt03DWXOsqdabLkofK65U9mWbXHd5ckTFkZ8294Ot908Qa56WIDjvEsumAPfgpDzD9NT5svK+Pxzzs6fvM/9p8zPJ10x2f9i+Mfxz/yP+q/nOfj80d8/lqZPn8OTZBPMPmTmuS3oEXyuUkWEXDF+b+EJPJ/Zcr/lN+a6kj4dKgj/xGOJGUV57/l+fzffNqLfWVAyWgvcHzTcZVSbwzChJqkrOL4L8/HX45XfP+UL1lysnJA4vvfFIrOVZrX2ZOhMYgZapKyivkf8z+uf+P6lwsBfy5EeUiFIReHOP9wXOQjc1rG4e+P+YaAVmY0k8UQDETcBpboC9J05E1GM9DQB4PoC9L04k1GM9DQB4PS1zA/HeDV+9DH75qXg156mrjvufR/334rrZt0M6iBgw1qWqEvlr3ffpHevsWhdM5D/N4yt7yejp99MZ0wabVsRRvHGVDpDdMv/2NHmnTozbRwiF8ZgCcEcHd+GKMZOOCotRn6gqyelWj8YXrg7B1p8qE30QK+6WL/6TfzUxjWynuK/YZcKfff7FQTYr8hjd+bjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGagoQ8G0Rek6cWbjGag0O2PSPjtf7FPCMA46AsSdpbeZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL6KtLVcOqx1HEQx8p9+Yy2sp7CgL0jTlTcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0jTizcZzUBDHwyiL0juxT8hQLs1DNg6TMmV7MapUIFew1bL4q5rLbNsQIdpxR+/R3+58h30sl2/Qb/mncEu9mgdmvKlm+iHh2xQdt44qyWj1AgtLa/agCClocW5o7/QvafsSJsddQuZFxewi18ZcC+/MmASPyGg64NI6sj0plCBjlUtGH8OzTx2C9rqk/dx1/n99uen99tbZt467aSoKhLV8BUq0KbVgvG1lwawzOLqMCVPshunQgVP8/hz6GaO8dYcY5JXBkzPr2WoW9fY9bpT3tGvQbIbp0IFT/P+12Ndt6ja/E5Cs8xi6zAlT7Ibp0IFsf8cKHxZjRJSo4OYW9nh7TBF/DkCKS4mOAoVRP5xmCL/fM2r2WHnHXCHt8OU2MlunAoVRP5F/sX84xyoM8JjzLoqLbNYO0zJk+zGqVCBjlstMb6NRY07UIe3w7Q8xH9oSN47nd81rVufnhBQNxgIUngWo12VHd4OU+Inu3EqVKBjVUuMb2NR4w7U4e0wRfw5AikuJjgKFUT+cZji+tfXnJodmHNWdng7TKlFshunQgWjzj+5IcAeJ33SiwxUu7MbGvmf4mKCo1CBhq5a+oczB9cyS7g7TMmT7MapUEGMz4GyeS1xq9FJUWysOrwdptQo2Y1ToQIdq1pifBuLRvBZ7fB2mCL+CJUJjkIFGs1q6YywOQyWWcwdpoh/xD8nl0kOhQoi/zhN4vzja07NjlJfiuAbAviyk59ThCfzdBFhg5S2wJC+W6tZhsXg8JcZ43b8x+j6D72KdjjpV5qw6UD0tqDDbvoBnbHVs1OQEDVIMQJDIpptaRkWg2niP+c8OnSzA+ns/8svDpBJRLQbHcc3BJyw0ao6pljRE6TYuhfLsFjY99E3992cDvzOk7z/+YaA8/iGgDxu7Q2tIMUDDFnZTWQZFoNn9t/0C69ItILsZ7NtKu5qVb3S+9LN/9kc4y05xnO4KspTGGbxEwL4lQG6LO3xn+79j/Hz6VAOuI0FEiCO/9KdfzbmFkf8cwQi/yL/4vozrr9RDerZqlbIbLPVExgS3La0DIvBjPoT9WfFrT/5v0rxdUfO6fqfpaLbnLc48r9Eayl//rIxtzjiH/GXCMT5J84/+fyTarlcCJZXvqCOo2pA5qxpXxPl+dRcd7WynMi/yL8V9/rHZrfN6ootw2IwIv8j/yP/4/uHXA+6K0T7XAseJKpJW1qGxWBG/Yn6s/zUH/OEgJKsSdjEtXZJYutDUo9eamsG7n1J6DcRlFXHU5OC0Q9qmNqawdM+Pl1HJ26+Cx334/lp7+tm7sr/lX8pTduI/yvfxUUYugeVvgRIW3fu/x/p9o9tTa+e+jNKtwSkX+bLtmyIJwRoD0swaqVqaxl/0ZV0wiZ70MfuWcB7xT9WT+cfq9P77ZXFDQtWk4La6RIgbc3gaT/+HN8U4rT9ZcuS0K186vu/8EqammIsR3QD2o+fEHCB3BAwXva/kRsa2dj/8ZH/cfxdBCL/S82N+R/zf1mcf93s06uZOP/G/Iv5F/PvKV//2/8qzaWGnxfQa772rRahOP/H+T995oz6G/U36u9Trr+1so4OjVR/5Wkvdsk3BJQWtqHZassfDbbdjIvvvxpBif2P81+c/3hS8ESI+b8Mvn+P+uMiEPU36m/U3+W3/pobAty8xc+w1dg4gchNrP6uIp3q9VvPZOI7YPgCNiWB9ma4avOgxWCDPYGtFOM/eDLtvf4H6ZL5srd5SXFa9c100i/Opw+8aBWYWyfwpbX/vZ8eTVP+7jN040JsU31lwJjH3+1/fZy97PS4OP716LbQmO3/Q5+nN3KOXTpfhkCMn8fYz8jmBozZ+EMx/6P+Rf33s601u5rTL+pfs0JxyMb8/NOKejW0jlCMH/HnSYx5vLSuv5CBkX811ikmMf9i/sX8a9Wf/ISA/FlcapIs/NC/PHlSEYnr77j+jutvnLfLDGHhLdle12nqVHWZff+CIWP8xhHigKzs1/+4uUv2XKo2nhCQcmIc7D9yX2Tk//jL/zj+NQKR/5H/7gol6v9Kf/6vsz/Of1H/np76pzcEtL42sN942kwtuMV3HBxOSG2U91LNCtIFsPvYOg7GX3DzYbTZ1mfR3S52rAzxj/B3X0zTJq/W9Ki+9OI/i07fcXs64rq56SNzT7blnkvK0wp0+Pbxqi5GOK6QxQk1yUX0+PlvoBf/42X0p+SW/16flf97XfRxcPxrnAQ1vrYak/1fyDHem2M8g/6cYsyvZZhxC52/Oz8hIF1t4IAsrfFr/2l4qJCaJzH+0jn+GugUfg23mhUspfyr/cfx5wggHJBqiPyP/F8a9V8TLea/RADhgFRDzL+YfzH/xtvnr1oQVtz5jxsCcoEvZT49IUAu8LXQFQcLZ67+mP8x/2P+m6/gx+Tzd51faQJChTTzM+ZfzL8JeEJAqdHuhoBcwXXdyhf1CECCQRYnVEjlrbjnP7fbqmAHIWP/UwQQDsg4/hyWXPNb8ynqP4fGnA91bmXQipfzI8EgixMqZOQfBybyT7KjlU8x/2L+Rf0phbMtWvPFUVBgIYsTKmRH/R3i/yaQK3G3KJ+tclGKLx2s3TUQHv+5bhqGhpqaJ1uHw5pW5vHnzTiAnr/XBcRvd+fY5buCU2BoSzrsph/QGVs9+2mI/5/ors9MoVd+9Ce0UA5ob1eaxq8vmMqvL7DHJW9nXbd8DUND5Ya/pu8dvAW96auPpE6GaBLfEDAzvd/eclfm45/20+5sCac1PbX9/zVdzDHe56u/556l1/JaBnllQLHwP/A3Jq6fy09t/DRMWnUMk/Opw2FNMX7U3zj/4ENDa6rqBLNzpmvCtfxMSrYOhzXF/Iv5F/Mv5p/UFFsXUo0xq5avYWioqWWydTisKepP1J+oP/3rD2IjEyp9XGMpc6Y5We2cSpNPeNKmw2FNMf9i/iHHbF4ghyBbvoahoaZmydbhsKbIv8i/8ZJ/2E+dU1zHI/8j/5EXti4iRyBbvoahoUb95QikmHQExppi/sX8i/nX//NH1J8cAVszanFFdFofxyql1dBzo/5E/VmW9UefENCd1jZbLS6J3mFCOmcXr+1zvjA/5AuLzrs/mh1a3eKVY/xhviFgnXJDgH6bw7s2ROvQFmddTzPfM5lxLsaIK0KYZEdIwMsuXg8Q/4U3v5c23fqM8uQCfkLAbH5CwKRV05aN2fhPnkOHTHoH/dfvZUt5GeLH2V8qNwSslfW0tjtocaF0mMZi/+sG2AEsXkHGn/N1OmTDd9JXHpX7iXjpTaID+KaL8/bgVwbE/KuHWVHzGFvd4tKgwxT5l4Oi6wHqjx4O9612R7A7TBF/jTyfORhH/OWE6pe4/oj6H+c/PyeS1iyoVre4NO0wRf3NQdF11N+ov0vx/DM0oXaOm8rlS6TIP0k7jkLMv5h/dYrkE1dc/8X133J4/YcvfmsdX8T5iuTNFb1ceZU8Nm51aOWP+hf1P85/cf6vJQQ1Is5/cf5bDs9/+O4Aaer1OP+1JnJHSBAzvQqI+tcKG99lGfO/z/xPNwTYu1ByQsmULBeiKbM0vdJc9Zeo2ZcnscXZktZilouzzo1gDx8gXAyPp/HTDQFv4CcESGhShPJalFX2/grde+E7aX0JXfk3jhRGUcXGi+jpS4+GJTntKjWUQdDSOjvi/8SX6W0v/hc694/y0WRXOn42v75g0mppPGmJXgYff5geOmcf2vSg79Nj0plsGr/ffr/p/Dj7PeX99rKUUdIgdSTjWXr7v1KMP0wPn7M3bXLQFfSYHjm+6UJeGbBHfkJA2k1ejdf5F/ufIxDHf3yefyL/I/8lAjH/Y/6Px+vvqH9R/1b0+jeRP9PJpyNZykepVM+zpawTgVej/fyXmsXnrxSG9NEzrVycxVetJVbFktrZlRDFF/G3UVEc1x9x/RHXH/xdW3plgNSJPDX46a2lyEgB8XVeGNUa9adELMUpY7OWQEX9jfNPnH/NpKgwzr9x/o3zrz2HytzASVhgPdMaT5x/U5RybCQuuCLJ2Kzj/JtjswKcf/ITAtIxrUmf8l+OJ+aIObb9YDrmaOKUdouWOw2dVnmStQjtPpoW18QpTWZOW7Hq7qWh02qZjr+AnxCw9l7f5lcG8NiyMWm7C1hld5p614U0bePV2zvQYUlNsU9OaZNbbjGYojfUu4O+uOvW9O6r/sIOPCHgGe2OjMX16RRDKrC36Ab69213po/ePMy7XPZ3iB9nf+ksOo8fZx/5VwKlCdqOYdPiQi4Kx/iz2+1MH7lp2OQW3xDAN11IjGXR7oXvjn9yG0LRRxCt8YWrA/iGjiuuGD/iH/mXJoxOBZkXfeaPuJqLm1NOaTKXn/Of7p7udLm9bTHb396jxj4tpn3LHeNH/Yn6w9Mq5p+WAikyWqC6Ko63uZriFM8TreXWQSP+GgoJVMRfojDiIj8iSZjKM8ASN/2QJKhP/CL/UphqeDTpYv5pKEbInxw9v3Y55RTPE63l1kEj/hoKCVSf+Suu5uJi6pQmM+LfCo8G/enNv3xDQK7mctTkh7rRLmCmlHFKu4eWWwxx/StBqF9FSdhi/kkURrW4nHJKu3nLHfkX8y/qD0+UqD9aCqRsRP1tF88+FldTndJu0HJr0CP/NBQStnGYf0OL+KrT73cKSckikzrFbL1CynofZ+lFSD0u+PL/5nlBL/I1RrV6n2jCk4Xb9Rkim/s4c+PUdnkcv3f7UfSqzU+hn6RdlH3k/ZAQye7QKrTmey6i+87ak/gn8mW8/4/SVUe+gnY57SHejl1p6r2X8hMC+IaAuhmygWlZ8vjL0wHeSJu+/Qp6nBunXZWehiaVVwbIEwIkCLLAWwfO42UvGKWMaYyqtyAZZ1zln8SYnw7w9stTjFMUOIRDPfsUBonx+J5/sf9x/Mfz+SfyP/I/8n/8Xn/G/I/5H/N/xZ7/9T976qee1g9J4+7zT41FQrH/4+zzbxx/F4HI/xUi/1Mtz1/L5LLVk1cGyBLff6WvAmsYclh4zanN0clrCHUCRP6vEPmfD1c5lkkRLEs98NYrnqwXa9MpBFnYPr6+/827revY/zj+4+r3D838DCL/I/8j//ksKheXsuBE2f7+i58QIM+lMneGoE1u6Zob0xJBDK+dCdBxsjetHbEO0cdcCYtBrr0osiwP4z8uj+b/Zzr3T3mTsFl5E/nwTXwNvesHl9F/bp9uCaikJURLvv/z6L5TtqPJR83iQrIbHX/PJXTCRqsu4aiV7sZ/5Jt0+DYH05n383+uu4X/e/1Sfpz9Xv5x9kJx7V2b0SmuvSiyLA/HP21I3rq0dhuanIZR9cWhHsf4vdu+k868b37aTewy8WsZDuAYpycErMT734yPCyuCEftfwpSjk9YuUDWKfcyVsBjk2osiS8Q/x8F+pHWBKm4WfcyVsBjk2kf8c7Qi/0rW5OxIa5coNan6mCthMci1F0WWiH+OQ8z/lAwpR1yilPCw6GOuhMUg114UWSL/chwi/1IypBxxiVLCw6KPuRIWg1x7UWQZo/wbmsAdcZ/SHbpu3hCwNMdP+7KYVYzfONwSrzE6/osJfXJH/Bvhjvg3AhLf/6U54iZKnVl9zJWwGOTaiyJLx/yfwI+UrXWcj0m5IcC1z62XaO3ajzA+f2dutqsO0cdcCYtBrn2Mn6PVcfwj/hwajUtNKpc/1Txq5NpH/uW4aZxzdNLaBaqGt4+5EhaDXHtRZInxcxzi81dKhpQjLlFKeFj0MVfCYpBrL4oskX85DpF/KRlSjrhEKeFh0cdcCYtBrr0osiyn+ZdfGSAb6LZaDGZJ/7nOe8AceZyA7ouh9IO12/bdCK5NJTpzUlbW8Xuz6PQdt6cjr5+bwt/ecaIJGx9B37r+JDpgHf5BfhnGf8FVB9GLdzmHfsevDDj+notp2uTVnvr4w7fR196yBx38nUfcrko+9fjH6q7326/Ux99GYazyf96t9NUDOcb/Y2OcI0xD5aaL8soAO3xKwH4Te2WdfzYAYxV/2yfj2m3Uv/Z/I5pg1UAZY4GRf3zS5cnJMYrzb1x/9CvT7YkT9aeWlai/UX/rPdKtuVITpeXKT+6K+hvnn+Xv/FufECBnBUliXsv1UllqWkf9i/oX9a/vtVOdKJg6Vcbnj/j8sQw+f6Wbu2rW1Toe+Rf5twzyr+8X+5F/kX+Rf+nyOr5/i+/f+l5DmnM3YL2sjM9f8flr+f/81fHKgJLK6SJAcHf610RH6hspTiydzUtrFn0L7LgYfw7dfNwWtPUn7+docTAkVlWUCE6k1bc/ni686N9o97VWQVTTVz+doRWGhBdLJ0kI7GDRN/5z76Frz72IZq25B73tza+gdRr9lB4wipdd4/d+Q9cd90ba55O30+PSl+WkHd/A3xAwLo7/CPEfZP9tjNMRQaClEMkJiW8ImM5PYdizvJZhpOM/yPjIAntsG3mTKUJgR4zff/5F/MuppzOBUvno9nBqRf5hJpYYVjWjmH9Rf6L+xvlnjK8/UGai/iISUX87T9Jx/hmr80+9IaCmXDzFx5AAAEAASURBVHroH9SIPyJhZOTfWOWfCWqFUf9rLGL+1VgoivnXNf+aT3vJTwjoTKD4/Mu51B0ZdkT90ZnWHaSYf13zrwZNcohjlBKsO8tKBF0TVSL/NBSRfzUUFcX8i/nHdYXToO/vb1F/ov4+DecffWVAKlYdZzlvqoUsFXrvrPWuXK7CDakEZzCKgeB6U9FghARZZXbADdlwF9V4DQTXm4oGIyTIKrMDbsiGO6kLZh5Gm211Ft2tTgD+EZefISV1gWgirfbqw+jzXzmBDtuMH6mPDiHRRGV2wA3ZcBfVeA0E15uKBiMkyCqzA+5FT95EXz/irXTkV39Bc7DxkuwoekKUH6s7XhmAPnLXRYMRMjvNOjvghlSCMxjFQHC9qWgwQoKsMjvghmy4i2q8BoLrTUWDEZLJPY7x11KM76cn5VwjPl5SmDPk9STab/pMumAPzqFUbMRhO2FV7eJz3qqhCWRi2lV2wA2pDGcwioHgelPRYIQEWWV2wA3ZcBfVeA0E15uKBiMkyCqzA27IhruoxmsguN5UNBghQVaZHXBDNtxFNV4DwfWmosEICbLK7IAbsuEuqvEaCK43FQ1GSJBVZgfckA13UY3XQHC9qWgwQoKsMjvghmy4i2q8BoLrTUWDERJkldkBN2TDXVTjNRBcbyoajJAgq8wOuCEb7qIar4HgelPRYIQEWWV2wA3ZcBfVeA0E15uKBiMkyCqzA27IhruoxmsguN5UNBghQVaZHXBDNtxFNV4DwfWmosEICbLK7IAbsuEuqvEaCK43FQ1GSJBVZgfckA13UY3XQHC9qWgwQoKsMjvghmy4i2q8BoLrTUWDERJkldkBN2TDXVTjNRBcbyoajJAgq8wOuCEb7qIar4HgelPRYIQEWWV2wA3ZcBfVeA0E15uKBiMkyCqzA27IhruoxmsguN5UNBghQVaZHXBDNtxFNV4DwfWmosEICbLK7IAbsuEuqvEaCK43FQ1GSJBVZgfckA13UY3XQHC9qWgwQoKsMjvghmy4i2q8BoLrTUWDkWXzv0qlHX5IMjR/WQ9HGsQoBo52fN+xb4XuIOG1HzncJ4wW0Xm5eSGAB6kdA2QH3JDwopusG6+B4HpT0WCEBFlldsAN2XAX1XgNBNebigYjJMgqswNuyIa7qMZrILjeVDQYIUFWmR1wQzbcRTVeA8H1pqLBCAmyyuyAG7LhLqrxGgiuNxUNRkiQVWYH3JANd1GN10BwvaloMEKCrDI74IZsuItqvAaC601FgxESZJXZATdkw11U4zUQXG8qGoyQIKvMDrghG+6iGq+B4HpT0WCEBFlldsAN2XAXtXr9zV35lQHVK/SiwQipHQNkB9yQ8KKbrBuvgeB6U9FghARZZXbADdlwF9V4DQTXm4oGIyTIKrMDbsiGu6jGayC43lQ0GCFBVpkdcEM23EU1XgPB9aaiwQgJssrsgBuy4S6q8RoIrjcVDUZIkFVmB9yQDXdRjddAcL2paDBCgqwyO+CGbLiLarwGgutNRYMREmSV2QE3ZMNdVOM1EFxvKhqMkCCrzA64IRvuohqvgeB6U9FghARZZXbADdlwF9V4DQTXm4oGIyTIKrMDbsiGu6jGayC43lQ0GCFBVpkdcEM23EU1XgPB9aaiwQgJssrsgBuy4S6q8RoIrjcVDUZIkFVmB9yQDXdRjddAcL2paDBCgqwyO+CGbLiLarwGgutNRYMREmSV2QE3ZMNdVOM1EFxvKhqMkCCrzA64IRvuohqvgeB6U9FghARZZXbADdlwF9V4DQTXm4oGIyTIKrMDbsiGu6jGayC43lQ0GCFBVpkdcEM23EU1XgPB9aaiwQgJssrsgBuy4S6q8TKsTwiAHVJbt0Gm9Ce2PU1L1RUBQLaHVUum9Ce2PU1L1RUBQOpobZAp/YltT9NS9d4ifm3AzjvQkdf9Jf8YK66y5B9z8d/dbHzO5rTHMZ+kzx66G71ijQlsaPx6W9rV3ovBfwJgY2UoAoBE0w6ZKf2J6pn/EN11yedo6jFn0P/8bG5HT2LKe0m0Hu3+5e/S57biVxOU3ar7L1ssveZFx+fHGA3xLVZDa61Hf7vus9HM7J1vAW10+9+j+X/4Mf3w+1fRDbfeSrfdegf934MP0My759BCdMQbOOH5m9HGL/wbeulrXk1bbrEN7fraHWnbjdei1cFJUiNSrFVXBADp2nslUwpx+GG669KTOMZncow5h7CUGJqwsYdj/CWO8TbPYJwJ+TEu3Jd0Jym1SF3lyEj+MdvE2I3PvuZStsyYm5aqK+otoD8+fCvdeNl0+t8bbqLbbr+H7vv5L+i+J2VLcfSfR+u8YhOaNOnvaIttt6Gdd5xCr91iMq0tu2MW7VNtTUvVFQFAats2yJT+xLanaam6IgDI9rBqyZT+xLanaam6IgBIHa0NMqU/se1pWqquCACyPaxaMqU/se1pWqquCABSR2uDTOlPbHualqorAoBsD6uWTOlPbHualqorAoDU0dogU/oT256mpeqKACDbw6olU/oT256mpeqKACB1tDbIlP7EtqdpqboiAMj2sGrJlP7EtqdpqboiAEgdrQ0ypT+x7Wlaqq4IALI9rFoypT+x7Wlaqq4IAFJHa4NM6U9se5qWqisCgGwPq5ZM6U9se5qWqisCgNTR2iBT+hPbnqal6ooAINvDqiVT+hPbnqal6ooAIHW0NsiU/sS2p2mpuiIAyPawasmU/sS2p2mpuiIASB2tDTKlP7HtaVqqrggAsj2sWjKlP7HtaVqqrggAUkdrg0zpT2x7mpaqKwKAbA+rlkzJ6wlDE/TqGIRFfDcwLv+zrdlp1RUBQKKzDpkp/YltT9NSdUUAkB3jwpQp/YltT9NSdUUAkBisQ2ZKf2Lb07RUXREAZMe4MGVKf2Lb07RUXREAJAbrkJnSn9j2NC1VVwQA2TEuTJnSn9j2NC1VVwQAicE6ZKb0J7Y9TUvVFQFAdowLU6b0J7Y9TUvVFQFAYrAOmSn9iW1P01J1RQCQHePClCn9iW1P01J1RQCQGKxDZkp/YtvTtFRdEYOhiVy1xVAW++oX2ETmNtrSuhJue5qWqisCgGz1Wg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisCgGyNWg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisCgGyNWg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisCgGyNWg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisCgGyNWg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisCgGyNWg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisCgGyNWg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisCgGyNWg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisCgGyNWg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisCgGyNWg2Z0p/Y9jQtVVcEAFmHa6FM6U9se5qWqisqgJ8QgP8lxrigiJRFvlpgjGdbwJ2t5osHOCClbXtRbwKqGSJsImVZ2cefTw+duzdt+rbL6bG6t2nP+62GXrQj7f2ut9OBe+1Ke2z9UnpO+vbHxi0ZOpuDlT9VqGa4sImUZQniP/x7euAns+jOX9xH98y8nKZfcDld+UD7RoD0OiJ0b4ZoQFG7F94kfnhC+ew0RKsdOoOeOHM3Wg3barKy2QH2ru/+9/5A907/Ev3n175M53znXnpIf/03PTXGNxvDpNXpOa/ci970trfRew7ck6as2+fWgLQhujWmc9hEytKI/7xH6IE7bqW7fjGbfs4xnnHBFXTlL/lGANBzoxHXg8R/tXdfRk+cvTuths3jEQw0mrc2N0S9CfCq9xjdO+MMOuM/vkHnX3ovPczxFteIi8afn5yx/uton385hA5715to5xdIrHWEzi7Um4BqhgubSFka8YebPQYazVulB7uoNwHVDAU2kbLE+CnScf7RVEB5Q6bkPIEGma3NtXoTUM3QYBMpS+Rf5B/nQsw/nQox/3JlQKXwmrdmX12rNwHVKkHPquKTJepP1B/Ohag/OhVs/ZEbAvznDw5V8yN9nkhprTMuAdU6GOKTJeZfzD/OhZh/OhXs/JPZkRfMJUjYvVRvAqoZEmwiZYn5N17mnzwhoBztdOTxpJfxsv9pp+P6r875FJCY/5H/fC6I86+eCuP86yul13D9kK3NtXoTUM3QYBMpS9SfqD+cC1F/dCqszPVniN83yP9OgCKQS0DXupsBK6RvKV9M5MdgyX/45ovdxGA68itf/3W3t711M2CFtC14jBVl/PnX07/vsjt9+Po/l6TDxwJIv19Zy76hF7yKtpqyI03Zfkvadhv+j+lXT6K1VxXf07D/951AO240ja6Xsc2mJ6g6AMsEJUdkW4s9iYJxMpKdaS3gEK32Hr4h4Kw9+IYAvyzZ8V9Ij936BZp2xMfpjB8+xk8BKDk18QW03mt3ou1fuSm9bMNJ9LfPXyVPF9621em39MCPb6Crr+AbH25+hObIB7ryZVzanWf/He18+EfoUx/an7Zea9W0N2kLueuB83/2NNph8gkc47r/utfN8WUXeHEh1XZsTY7Rxf8Z77mM5pzFNwTkLsu6xAixcr7F5d+f6Ff/+zn69PGn0pdufJQWuOP/V/TcbfahfXfdiaZs+UJ6zvx5NGHiAhr+3V10x/Uz6Pzv3ZaeHMAj1BGftw296ROfpdP/dXt6ydOV/3VrElqy/JOD0X9BpD0DVsiGd0Wpf3H+4QMXx99nr9f6ZHiJWx9v5H9cf8nFBZ8n4vozrr+1wnK5GPj6y5Ul1B1I51xxPn/E+becR/zxs1qfI1za9fEug/PPkNwQgKVc/8tHelni+lM+20T9j/NfnP/j+mf5v/5JtSqVq1KzSh1PtZxXev0ihrTgvAMJe/Eug/NP+RKJB+zYuhg/zj9x/uW5EeefOP8s/+cff/bwWp8zTKn7fbxR/6P+R/1foep/ekKAm86qKPCVoUMDU65f5fhDKhUENXjg3Koo8OQODUyMC6lUENTggXOrosCTOzQwMS6kUkFQgwdyuTDvpvfRNtudQT/m/5DOHwcqR3UF2ZdVXuu/yzN+zgb08u1fR6/daQfaeYcptPOWk2gd+YFUyH0Wt3mqKOjTqprB7N17Au2w8TT6YXUlJKfCfEkkl0Z5kc0BLiYVTZ/qCmwfQ/QMfkLAnDN3p2dwhwPlX+839KPPHEhvP/Yauj/Ff0160Zv+mQ4/aF/af/dX06RnT9Rt6wI9mkuP3XYOnTztk3Tq9x4gfsq9WyasuwcdfPJJ9PkDNi1Pc3DuFAfZtbQgmN4KL5HeEIA84Zb2+HdEdSziLzcEPNG6IcBvMvIeUjda96nwH72SvnjU4fTRr99NjytJwJr04n0Op387+lB61zbrlic+OEJSek/+mC7+/PvoAx+/ju5baPf/r+g5uxxD/33eh2nPv16lNmyMXx0ZObcqCpr0lg4m9htSiSCowQPnVkWBJ3doYGJcSKWCoAYPnFsVBZ7coYGJcSGVCoIaPHBuVRR4cocGJsaFVCoIavDAuVVR4MkdGpgYF1KpIKjBA+dWRYEnd2hgYlxIpYKgBg+cWxUFntyhgYlxIZUKgho8cG5VFHhyhwYmxoVUKghq8MC5VVHgyR0amBgXUqkgqMED51ZFgSd3aGBiXEilgqAGD5xbFQWe3KGBiXEhlQqCGjxwblUUeHKHBibGhVQqCGrwwLlVUeDJHRqYGBdSqSCowQPnVkWBJ3doYGJcSKWCoAYPnFsVBZ7coYGJcSGVCoIaPHBuVRR4cocGJsaFVCoIavDAuVVR4MkdGpgYF1KpIKjBA+dWRYEnd2hgYlxIpYKgBg+cWxUFntyhgYlxIZUKgho8cG5VFHhyhwYmxoVUKghq8MC5VVHgyR0amBgXUqkgqMED51ZFgSc3tHRDQOP6f9Ei+SHcEBfTlXOrosB01A3BxH5DKhsENXjg3Koo8OQODUyMC6lUENTggXOrosCTOzQwMS6kUkFQgwfOrYoCT+7QwMS4kEoFQQ0eOLcqCjy5QwMT40IqFQQ1eODcqijw5A4NTIwLqVQQ1OCBc6uiwJM7NDAxLqRSQVCDB86tigJP7tDAxLiQSgVBDR44tyoKPLlDAxPjQioVBDV44NyqKPDkDg1MjAupVBDU4IFzq6LAkzs0MDEupFJBUIMHcOebl/C9jnyPKp7FL2iPcSG1JQhq8MC5VVHgyR0amBgXUqkgqMED51ZFgSd3aGBiXEilgqAGD5xbFQWe3KGBiXEhlQqCGjxwblUUeHKHBibGhVQqCGrwwLlVUeDJHRqYGBdSqSCowQPnVkWBJ3doYGJcSKWCoAYPnFsVBZ7coYGJcSGVCoIaPHBuVRR4cocGJsaFVCoIavDAuVVR4MkdGpgYF1KpIKjBA+dWRYEnd2hgYlxIpYKgBg+cWxUFntyhgYlxIZUKgho8cG5VFHhyhwYmxoVUKghq8MC5VVHgyR0amBgXUqkgqMED51ZFgSd3aGBiXEilgqAGD5xbFQWe3KGBiXEhlQqCGjxwblUUeHKHBibGhVQqCGrwwLlVUeDJHRqYGBdSqSCowQPnVkWBJ3doYGJcSKWCoAYPnFsVBZ7coYGJcSGVCoIaPHBuVRR4cocGJsaFVCoIavDAuluvDMhOS8k/3MpPuulStTWa77yt1b4S4pX+d06bXEapbYSStWJbacd/jG777O702o/MpCdSXMo3OunLHsFyj12ORToOYpelCHHieyHlCZgg/+G+C+26zXY0ZZft6PVbbkovWWNi3/sDXKzTAEsQ/+Hf0QP3PkL8nIO8WWlDynGTTZk4nx7++lvpdZ/6WepZtzNp/H77L3+XTtpaHvzPbeQ/X1JTvpWAE2aIX26ffthOxz8/JhPdT1jrpfS36z67zz7V8Ut3Pv/4ZoDrjnsj7fPJ2+nxIf5Beco/0/EnfZjeu82L9L/hcw+ln5Hyr/d7+uk5R9C73vffdNMTzHc7+Hza6F9Po++eegBturrsSffixioUZ5vHMZ79e/oTH2zsf6KxIsc/xfgbb6XXnsgxduMLi2P8nxzjbfPLFVpu/hYx/VdRR/wnrvUSevm6a/Axkf2SlqNd8tYLu0fz6fFbP0eH73ccfesXC/zmPW9bOuD0L9J/HLgZPS/ldh3D7b+O/xd66MoP0T/teyZdW2KN/J8w6WA6bcYX6PDJf5VGzYHQdPLHv7EbbqziczYdv9Gwr2r3Px+jqH84Iu2guVhH/FMEXEwi/55C/Yn5l2okl9ZaXf0cdLkW8y/mH0fA5UTUn6g/A1//Rf0d6/qLH5GkoOP61/+QlGevFLKEeBXXn3H+i/N/OrW3Vu5cV7zOFue/OP8tpfPf0AT5zkuyTRb5LmZRQpF/KRopJk/t+yfuh4MZ5z+JZ/ficq1QnC3qHwevX/S6YpqjJ56EeBX5F/nXL4PcXIv5lyLgYhL1J+pP1N9SGUYj8uwRZkK8Gun807ghoDYu3wKiGx3ZMPTaDAP1vcqonWk/3cD0rlBBamI11IZks45W5yM6DdvwFCpY+uPPu43OPXhvese3fsOPrM+LnDhkC5qLzAn97JACz6xOsjEyHJqwLr1k5z3ojX+/D+3/pl1op5esYQ6b2VeFCtImWG3J4z+P7j9lCk066jbeEOmJlyKINqQDps+k8/Zcq9pl0xu589TGz13X9Vz65X/tRZsfcjU9RhPpmdsfTV875yO030v55gIdSEFqZrXu/Z9Pj157BO2569l083xpYuP/LPqbt5xF//tfB9Fm/tn7ZZNM7woVjHL8eXQfx3ijo24tfdrxOcaX3sIxXrP4msKMpVDBKMdv9im69LGAHr3u/9E/7H06XSN3vNjj/7zX0eEXfZO+sOPzxcF/vOiwCrxZKL359Bj3+ff7fIGue4I/PNtdnfQe+tq1p9FBL1zVdpb66L8yYylUkJpZrfv4d/VuW3X5YTM8hQpifI6AjUbEn1Oecz7FxAYG6aRyRKeyXHS1iYLEs1rEP+If+RfzL9UEWxhMRclwRKdhG55CBVF/OAI2GlF/o/5OmCAXveXCtwh/Q4BMG5s1ovdbDE+hgtTIapF/kX9x/o/zf6oJtjC0ysuITsM2PIUKVvr6M4Enk+wtllzHx8/+u/OU7raCFBarxfknzj9x/onzT6oJtjCggKoc0amsqD8mTgoVRP3lCNhoxPknzj8r2/mncUNAI+F5Ash3DN1Lnhp2gnTzsrXJTnpHY2uyuN139o7Mqa2a7KR3NLYmi2tPQNk7MgdcxLWyE6qqEnvzbqdvvuuN9I5v1psC8lFgsv/eR9skUHzemDXrcnjCerTpIUfR8R86mPab/Fx0r8e8Y/NM99k7MqfSM28u3xCwHd8QkH+s1m1JYEPaf3r+sVpUWUbue5Dxa48J/eYMOuAV76MLHmdNDGl5Jj1327fQocccS8e/YQN6JswtmfvK66ZzDt118h60/QduSI/E1/1k2hD9DW326Yvpxo+8hv6qo7E1WdwcAdFpc5o3BGjacBcb8E0Xs9INAaldu7GLeYfbbEb2jswBfQH94doP0j/scxr/cF9DneIycUs66PJL6Wuv+5sB8+9Jmn3W3rT14dfQY7Ixukyk1Xc9ma6/5L205Wr5gzbWQknb3bHx1mSxdqsge0fmKLnEtbITqqoSrcliJSjI3pE5So7xORRx/Gu2JFRVTRRrslgJCrJ3ZI6SI/84FJF/NVsSqqomijVZrAQF2TsyR8mRfxyKyL+aLQlVVRPFmixWgoLsHZmj5Mg/DkXkX82WhKqqiWJNFitBQfbaJwSkJGN/+4aA9qeF1LpjAGuyWIdVkL0jc5Qc+c+hiPyv2ZJQVTVRrMliJSjI3pE5So7841BE/tVsSaiqmijWZLESFGTvyBwljyr/mrV8Ef/igO/Cak9AYz++9Gz3x2KMWmWM72dUjUwXakYr6R0BtiaL231m78ic2qrJTnpHY2uyuPYElL0jc8BFXlV2QlVVojVZrAQF2TsyR8mjmn/Ctv1ZXHsCivEj/+0ZFXnRLZvZkvSOBLMmi9u9Zu/InNqqyU56R2Nrsrj2BJS9I3PAxbyq7ISqqkRrslgJCrJ3ZI6SY/5zKGy2prh1BM+aLK6RBMrekTngxvFvRivpHcGzJotrJIGyd2QOuKOPv3x5kBa++OyzLOpln2EoVNBo288uNPggc1Ov2e7G4fhzb+ud+84Ne8/Jx5GPefp3ajn28gkh6fzQ+aTnm4qNH9zCs20S5j5ym9xPsk18WW+boy/ozZqz0Aa+4LGM/9ze7JM3b4+ftnnD3v7TH13K40v3yLQne3d9+pW9iSnGiF+JqdgmbtLb87z7eguZn1ugnelC+2puNnPnfb933CtWc8dM47/mPr1P3fMX18j07uyyvUs2/rwUY+SJP/4S4z+U/v2IXrObsKTjS1vb26Le3HtP6u237sQcC5d/a/Y2/thNvT83WtjRR7X/c3/Y++z2zyz9l2OZ8v+FvS1Pvr3XHWm7jX6Ll3h832DEvakjrXzj5/y28e/A7vgXP2oWalqak1Kf8Ace60uj/sX4bu7wl1Am9oIj/pqLkX8pH8b0+kPzK+dZ5F/MP51vqRZF/dF4RP2J+sP1cqT6W68xWxem5tp05bv+rHvr963aBcEHmb1esy2e6ucf25dgjASZ/V6zbWL8HBsTIYUKbMBMjBvmpKINZOZ4zbaL+OfYmAgpVGADxrifXWjwQeamXss2eLLPMBQqsA0Y97MLDT7I3NRr2QZP9hmGQgW2AeN+dqHBB5mbiobPWXH9G9e/er0X1786L1JM4vo3rn8Xc/1r86SFeT61fv+I7x84p+r3fHH+ifNPzgfEYfx8/5Kvxux6fF3/8xMCFskJho9/WaQ0JFUBPC3pGfyud26oPTknK+XFBXjMRu3MEVNZivElOr+hm075V/qX42fQHU9KjEa7yBHwfLXwmbC6mKMO6Zv/o/rVh9Pp536K/nlj/+71fiP7Izea4z9Ms0+eQpM/IE8IaI4vTwiYSefvwa8MkO1KG5pAv+EbjNGMz73KsKnbO+iLu25N777yL939C+clR9FFP/8c7fPM7u0Yef+H6cGv7EYbHXINzS17o8/35ucOvOBDl9L9n92Zke+lqg17x1Z6BvZ/mF8ZsK15ZYA5zEOTaL9LbqEL9nqe6c338tTHL12j23lX04k77knH3DwvB17saeFq8cqpdOVNx9NrV+N352FBu7oh8LSkUmkRzZnxFtp0r/Pp1z6pidZ8K51551fo0HWfkQJRjz+6q70ki6oKQGxJz0D8C805WVnJ65/+d0Mz/hwOmT0Sjpr/orBFHaI3lpF8DapX2w3VMmL9872MuG0Nqld1NDWrJcYviSChieM/Yo5p0mgajRK0G6ol8i/yLxXimH9Rf6L+rqz1lz/T5zonhT8tfKxX8utP2eH4/iG+f7Epn+Z35D9HIOb/ilD/6mdoPmR60Z4SeAlW7YZqiev/fF5M0YzrnxFzTJNmCVIvUdsN1RL5F/nH0y4vMf9i/nEmaD4gL4rUotGwL1ZtN1RL1B8T75h//eZfujczJaZkTv9FUrcyVo7Pn+aVAf12r7GjNj6+iXqaZuhZ2rU2YQBWttVRK7LshH0TdTfN0LO0a23CAKxsq6NWZNkJ+ybqbpqhZ2nX2oQBWNmWR11Ef7zrq/SZYz9Op134K5ojHK1uFmajcZmOva9yKjJkovI+99P4fe4TymDuixZL9pusnqYZeo/m0S/4x+pJR93G3Ob4G/ANAbPo/PJ++xr1inQAAHQMvcimGXqWZT38bTp8nf3prDmNxk59NR1201X0ha3WMBPfENCxMQlU8yNn0v4vfS99+y8SwWoXP71sKl191zTamR9RkBdtldS61xWBqdI3KeZ5NJtjPDnFWEx55LzekA6YMZPO45su2k29pY5akY4L4JvAavp+hG46dmfa/pM/pYXsBV0k0Uvptd/4AV35tvVLbOFNTuYi6yrKHrO2TRZeQyduuRsd8+NhQxC4Bq13zAy6+xPb0WqspRuMdW2ptjPZ1iUc33Tle/L7vbKOL19mIMdNKFLEJQLwQSIvPbepFXYSFmdes6+q236yFT7IGL9GwkbL48JJwuKIv0SgRjCjqtsoel/lVGTZHhdOEhZnVu0ho6rbXryvciqybI8LJwmLY3yJQI1gRlW3UfS+yqnIsj0unCQszqzaQ0ZVt714X+VUZNkeF04SFsf4EoEawYyqbqPofZVTkWV7XDhJWJxZtYeMqm578b7KqciyPS6cJCyO8SUCNYIZVd1G0fsqpyLL9rhwkrA4s2oPGUHn/zZN24a+cD2apV2DIRKsbIvr37j+xxU9ImGzJWGfMupumqFnadfahAFY2Rb5h6jXSNhoJexDpu6mGXqWdq1NGICVbXXUiiw7Yd9E3U0z9CztWpswACvb6qgVWXbCvom6m2boWdq1NmEAVrbVUSuy7IR9E3U3zdCztGttwoCP95D5x4jksjXf4twO9R5noqrbfrMVPki0scw2LuwkLI7xJQLNWFbdRjJb4YO0rS3b48JOwuLMavZVddtLtsIHGePXSNhoeVw4SVgc8ZcI1AhmVHUbRe+rnIos2+PCScLizKo9ZFR124v3VU5Flu1x4SRhcYwvEagRzKjqNoreVzkVWbbHhZOExZlVe8io6rYX76uciizb48JJwuIYXyJQI5hR1W0Uva9yKrJsjwsnCYszq/aQUdVtL95XORVZtmC5IaBe9VXU5DUuGdWN6z0YoNsrP9jAWR6uP+WIphsC8F+zbtfNFrd2xPjSjiSdA+zssqtsKP+ZUHe8jWJ8PhQpfPgQmEOXZlyCc+mRG79Mp3/+dPrSd+6mhxcyWZ7iIfHuXBrJnjrvSy491DZDa76ODvvuufSFnV6QfNLS/ZCZDaUdK0lPOyBEs4iPDWprv9++kvm/16ffTBfsyU8IkMWMkaFZG18iJn004+eu03r4AjpsnQPMDQGykdIRb650xXCINuRt4h/QeZsG2/+f0Vf32ooOvuxPucPUO1Y70Ufv+j59apPV9KkFYzP/JMbb8RMCZmGgukO8P/tPv0VvugBh6cy/Hg3feQy9fvNP0bWSrzKIXdarT18Ym/H/TD/99BT6u6N/wjcf1GOZhlznX+gb955Nb3tu8wN33qCxGV/2kfuToXVhg8t/dTiwMow/NMHGthF/TCi3102ltgG9WnJYawaxZ2nWP+4+HRPeRIxptyVtTYxfg9M8lM35hwPa4llDjTDo1RLH38Yi8o+jEfMv5h+Ksy0jCfvZohd0LZ411DZRf+L8tyKf//N/OEhuj5/rz/IBOl8o6LSO/R8vnz/i+PP5S86HchrTJfJ/Rcp/PCEgrj/i+mNFvv7IRUiKUVmQ0NA7ZVx/5wLO0ZNSzuGrEfE4afH5F+HqyCYbOXYjoB3MaqptQK+WiL+NReQfRyPm30o7/9LnZ3MtnaFZG18KQtI5J5xdKgsbVrTff3jnZTfaS9fO6aeN8tNliyPdmJ811a+gBM3o7ZGzpUWxhvE6PtHwwzfSFTMuo+uvuIwuufJWuvORBTWCHCIUbsjqZFSM/Xy1xjFj3X+iz1/zJTpqsrw+QJaxiD//WF1eGSC9uWWIf6y+1PxYbYdLRGsYg+O/8Cqa+vI96GP3lvjxLrv9T/srTwi4ms7Y6tm8BYOM/xhd/+HNaYeTfpl3tQQ+i/KKBNwA4YLRGC75Rjv+XH5CwHa08VG3pi123UqM+ZUB56dXBshWjLDY4RLNGkYR/97d9M39ptCB33m0DqL7vzq94Nir6Vcf34ZWqV6P7HCjHH/BzYfTK7Y+k37O/DJU6XM92v38H9Fl+78o6k+Kayu4PvaitSjW0H387VMCfPxL93r8c/duUPa1519nL9oseWWFhTcRLSDhSrIY+/lifBwXRAjSRVGV5JUVloh/5B/nAiqFSLeUdOrMKjbG/Iv5l3MGGQLpskiV5JUVlqg/UX84F8Z7/VnIH+nTtEAgNCIIjjowc9qyRbGG7uu/3EnxiaJNFBSb0dsjo5t8Mad+2ybGT/86YENi4qT/VqB+BRH/FAoTD41bA7Qo1hD5F/kn/03FOWOvP1IKDV7/JvAvUdLlYj7FJoay7PjcWFRsVu5L6eoEx3iSL66/c+w0UBpNFylVUhwj/hoPSTzkFmR1MirGfr7Iv8i/XLOQIZAui1RJXllhifzDFFOJ0CRZwtkZVTbG/Iv5F/OPc0B+EpdA2NriDCvv9X/rlQE2DooVoLwYQ4JZl7UsNY6VBwSZmXadPdavWAH4xpBg1mUty/gZfw49fOcsmjXzB/TDa6+lq6+6kW78lbyxPi8SB0QKsYEvRSmdATIrrUsD4KGtT6Trf3A0TeHXr5ugml4BRxt/eZz9FH6c/a25Qzf+BrTvDH5lwB5r6lDYdt0JbpUX9ZQdHO34NR5Ej9HNx21LUz5xD/9Hef4CTW7mkbGw//Sqj9OPZh5L28o/P4tRl9GOPzf9t77sr7Twy3Npk1N/RHcdsUkx133AUDqKAvRgDAlmXdbEr2W4n2O8EY9ZdkclpSce3MJPYVgTHRlZ+3hq4+dQLfrp0bTd332abuR3BWA76mCvpEOuvY6+tMMa1VQOct6KbFasAHRjSDDrvfkX0VEveTOd+lvR67gy/sQDv00Pn7MvyfMnsH/CqUvpgw3wZwsbFIBtDAlmXdayoL1tiBaQmWnXtQ+0V64C8I0hwazLWha0j/FrnIAgc6TsOnusX7EC8I0hwazLWpaIf45D5F/NEyBIRKjK7LF+xQrANoYEsy5rWSL/chwi/2qeAEEiQlVmj/UrVgC2MSSYdVnLEvmX4xD5V/MECBIRqjJ7rF+xArCNIcGsy1qW8ZR/+l+lvN/Y/3qPf46LxAQIUmx+yR7rV6wALYwhwazLWpbxFP8c2Nh/Oepx/CP/Y/4PXv/SU/Z4Ekn9lO+iFi3K30tp8c7pJV7+K1U2wazLWpaovzkONk6IGCQYVdYYIn7KVQC2MSSYdVnLgvYxfo0TEGSOlF1nj/UrVgC+MSSYdVnLEvHPcYj8q3kCBIkIVZk91q9YAdjGkGDWZS1L5F+OQ+RfzRMgSESoyuyxfsUKwDaGBLMua1ki/3IcIv9qngBBIkJVZk9+ZQCSqMlOz63J6aUuBbWrhJr2Th3GIr2wxy93HuPz7F6S+M+jR++5gW6ZOZNuvPEHdMOVP6QrfvZEen97LhMScL/g8Tjd/mfRS4/5Pv2M37++OjdLW4JD6LvpOHZoUIipXf6BXH6sxlLHn8RPCJjJ/71ufqxeyse/98g36X1T3klnzJ5fNtbE53mvo8MvPJdO59cmyH7rbivAHhTZtCd9Pv3y7B1o0qE3tR9jT8+hTU6+ge56/yb9+x5o/+0rA7Dlso2C1+dXBvBNF3s+L+tlm3XTFQifl4HGl4aP0FVHbEG7nP4b6UQMvJhtedbb6Eu//hodIo/wZ7MOqyC3WPLx76dv7rs5P5XgSe4AnZXx1/soXXbfibT7KtiOOjCY2qQMv+Tjo6EZHqY0CEYq0ou6ydqGCUs0/9Ewxm8fS46J3ICkeRjHHzFCVKBrFg08/yP/2rGM/Iv5h5lWpBdR/xEeFKCoP3H+j+ufNBt0aijIkwQ3BMh1Tb6y5f9ekHnT4GUdxiK96GjDhIj/iPFHqeqOt3pLbCP+cf0dnz+10ET9SdMBVaHW8lw3eosWRf2N80+cfzgCmCMVmHOrQCUUe6cOY5FedPTBhMi/FFBErhXnEu6WXRvY4wFjkV5E/BEejSkbIv8i/zgCmhoKkCRFNu2dOoxFemEGQZ9MiPxLwUDk6oFYOeNfnxBgvnyzu4pAQFofcPVVBB9k8rTcxhDj6+RDzEQiQpDWB1x9FWXfAvrjw3fRnbdcS1ddfhldd8X1dMXP55QbBNDaS3xcVeuqu9PUuy6kqZNXT184qd2AOmpFxp1g8vT4x+pT83+vN/1EG5Qfq80NAUxCj5DtdpVjUZOXx2er7KAu/OXZo1fT2R8+ls64+Ga663f89vmJL6QN/+Fd9MGjj6T3bL52YiImrqn2YUdtb+XwjANonTdcQHPE5Ra+IeAUfkLAkZtm65jl/zA/lSA/hUGHxA60nhBgtnfMxufB/nIhfeBl+9LJ/8cfaGXR8bNK259Kd153BG2qR5ftYzL+EzTzuC1oq0/8goeUx7qURcafsBd9avaF9NH1V4WV5VLafzMCYBrJDJftxjAm+2/6w8BFxvichq3wGEPEfymcf2oSRv5F/sX84/kg5yJdov5oQKL+Rv0tXz7o9GCAGQJpfcDVVxF8kMnTchvDCpp/zR+RZH/rEwKw9yWOZnezxxhW0P1P+8urXFbN/tRdTyh5Wm5jiP2P+hP1pzFrov6iQkC2AsSG6quoyUueltsYuP7IEwLsVyVSx8GAbPYrevVV1OQlT8ttDFH/ov5F/WtOG51bZqb05diZ2CTF/OPp1QqiMUT9ifoT9adZNqL+cERwTeS+OjORqlWkIuNOMHlabmOI+pPqT70hwEbQxKlG0xKAm8SRTolow5Kb9fjskP+nwdgBm902dfB0uqihw1J9isbt+HPp0bu+Txd941Q66ayr6WdzzM+mmHWYfqqvSmu++yK6/+w9Sf6v3C/tA9O22Bby3+vlhgDuf4ifi6Y/28r77S/l99vL4+ybnTR17bLtaFuUXAGTllX+pRsC9uIbAuroGQ2tQZuefBPdeeTLm56nuP/1lQE4lHUAjvEMjvHuay7F/e/R3CvfQX+76zfoV5pDdQsErfbuy+jxs3fjp04IoWNpHsSmrk2ajvn0AD+RYaP0RAYmufF536fX/FpWx1831YJlmH92WMUx/lLM/5x2GusuEPGP+Mf1D5fnsa7/7VNn1/ST64uo/3H9HfkX869ffXClieuF07VR29G2KLmCMaw/6Uek8jlK8lk+T3XdEFAHZzSG4zcDs6z3P8b3czji38wIl/lZifyP65/l8Po739xVvrRg0eNXBqSl76RuO9qWyP9WBDhIcf0f1/9x/e+vHXSeNItIU+9LTJeW3ZfK2oZBzL+oP8vh+VdTtJnvTb0vMfK/b6g0ZjH/l+f6528ISIXafKDqc9eEHltz9DM0BiFBTVJWYuLTcLHDnRzZyYUyxtfT9FKM//DD0+nMD76Xpn7rF+nHanyZpMeCgWyHHC9adTeaeueFNG1jeXGAWcwBzNAYhAY1SVnNo9mnbEeTj7otO/MAwuRRJtF+/MqA8/iVActi/2UQbF7aAFmxYazzb/5lB9DauCFA91fAGvTyU2+gnx6xiQ4/NuPzEwLkKQzvz69l0CFllKENOMaz6II9+KaLpbb/T9LN/F/6W3/ivrRffnw29eRVCTfyqxJevlTiP3/GP9La5okMdfx1aNsv30g/fNeGUX9K4i+L/E+TOQ0kK5liUf/j/MeJsNTqj8z4siDBI/843jH/JCui/kT9jfrLEyHq71K5/kyBLacfHWApnn+GJsj5Tv5yfRe0SD43ypLGhcy2qH9R/6L+8ZyI+qflQUpFWrhEjPX3H1qa4vqzhLh//Wk+7cW+MqAcIS9Q39maoTEIE2qSshJT//GFH8ffnMGX4vevUX9qeqbEzMkZ+cfnJbmGS0vkHwdDo4GoVIn6xpYMjUFYUJOUlZii/sX1HydCXP/p9EgTI0+OqL/jvP7mGwJQODUzai3NJkMw0NAHg+gL0vTiTUYz0NAHg+gL0vTiTUYz0NAHg+gL0vTiTUYz0NAHg4sepJtOeQcd+KEr6T65+JC+u5ahZ9H6H/sB3Xvsq2mVpzS+PM5+G9qIbwiQ03wdTmYhvzIATwgoPuHkxQxqILwDS/QFaTryJqMZaOgVDj9CD9z7O5o3cS794f5f0KMzP0//NO0G+jMz5GIEez1Ez6GXn3wD/zDONwR09OlNRjOwDmqReQqDG0+GmcT/JX8zP4VhrdwAfUGabrzJaAYauoE/p6++4TV08PQ/ss3uL/b/b2jnb9xMV7/tJXW/O/r0JqMZaAZVuOCqg+jFu5xDv00WOz7H+xS+EcE+kQF9QWovddOyyRAMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMNPTBIPqCNL14k9EMFLr9EQlXu4t9QgDGQV+QsLP0JqMZaOiDQfQFaXrxJqMZaOiDQfQFaXrxJqMZaOiDQfQFaXrxJqMZaOiDQfQFaXrxJqMZaOiDQfQFaXrxJqMZaOiDQfQFaXrxJqMZaOiDQfQFaXrxJqMZaOiDQfQFaXrxJqMZaOiDQfQFaXrxJqMZaOiDQfQFaXrxJqMZaOiDQfRVpK3l0mGt4yCKkf+k0I/Fgr4gTZ/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4gTS/eZDQDDX0wiL4guRf/hADt1jBg6zAlV7Ibp0IFeg1bLYu7rrXMsgEdphifI5DiYoKjUMFi4v8k3XPW3rTtYdfQo9wdvlSCLNGnoY2Pp6t+egLtPBGWIpdo/P6Psx8q77dPrwzQLTZj1d0xRoZLNH79LNWvu9x5h1dNC+hPD91Nd999O/3k9jvprp/cTw8/PJt+/rvf0W9u/zU9tDD30Iyf32jWhuQ/5fmGgCPNEwKUpIOppSskyZmoht/jGwL4CQGTj7o1NakdCKqPzTctPCVpHd4OU6Ua5/BFdNR6b6ZTf6svg2j0vx7t/qXv0knbroZ/Wk1+xCvLdB+n2365q7GX7ha1t1VwU76lfWhoEXOlJb+O4KEz6R9ffyaVZ1AkW17JDQH8RIYSb7PFhgPY4e0wJXayG6dCBXroqqWkLYZrScsszg5TjM8RSHExwVGoIOLPYbLzS/KmRke05tLh7TClVslunAoV6FjVEuPbWDSj3xmdfg2S3TgVKoj4c4Aj/31W1exoZ59nFn+/BslunAoVRP5F/sX84xyoM8Lj9gy0zJHn39CQvHfaX2vnH5JqH0CQ0qPFT2X83JHpTaECHataYnwbi4h/MwId0ekwpVbJbpwKFUT+caDi+sfXnJodzdwTvcPbYUotk904FSrQ3qqlc4R0c5c9Tvqklz6bNNbjp/5qp1UVZDfeepLdOBUq0KbV0r+73LVllsE6TMmT7MapUEGMz4GyeSVxq9FJUWysOrwdptQo2Y1ToQIdq1pifBuLRvBZ7fB2mCL+CJUJjkIFGs1q6YywOQyWWcwdpoh/xD8nl0kOhQoi/zhN4vzja07NjlJfnOjwdphSk2Q3ToUKlij/+IYAvuxMP6rlLard1C2EDVI8wJCV3USWYTF48s5D+VEv692M/gnVxUfP7R672DF+b9Gv6PuH70RvPPuXtFAOhDwtgJd8SOTrJl5W2Yk+cvt0+vSmzxRtwOM/l58QsB0/ISA/zj51VFa4IeC8Pc0rA4oPRw1SzMCQhdohLMNiUBd//Bf9cTbNvPxCuuwHV9ON/3s9XfGzOVR+9y+doNyhzyw5q3k7ZcyyONoatEn5j/Wxzf/6hID2+PIUhln8hAB+ZYAui99/RA1SmgJDancPnkx7r/8BumS+5M9I+68tEtDQ9Mu/dEeAb1M1bV1NjPz4fAPGqT+iu47Y1HFkT8Y2/o3uNVJib0Ur2WJ8PlJyCFM0UHeybm02esCQld1ElmExeHH8I/8i/2L+5XrQXSFyTbI+YEhUk7a0DIvBjPoT9SfqT9SfweqPe+90KSn1P0vFYGuOxYUc179x/R/fv8Tnj/j8lQpid4VcNtd/qZab7z9Qx7FNkLaqWxsqupeWYTFYcf0Z159x/RnXn7kedFeIZVP/ZAti/Pj+s1yK4ASlOWFzAxhSyS1gGRaDGOe/OP/F+Q/nP/OEgDJZkrATx9plElkfJtXopbZmwJ9D+Uc7LHYcZbHT2oVrfWg7eqmtGcT4Jv5//B59ZNv96bN3Dtdg1oPD/829Lu30dX7U+0EvYr9xVPYo0DyafcoU2tj893pKRDkWxD9WT+cfq9P77fUocZ8Fq0nBKMZrU7Q1gxGPf+8xmn3VN+jcr36NvvG92+n+OXziSPtd/hedQ5Dvm3gmPfdlr6HNt9icNn/FhrTRRhvSi1/0Upr03NXpuetvSM+/9i20TnqnvcRMRs/R68krA8x/rPv91K0sbWSw0rAC6apjqa9lKJtbBpTxN6D9pt9CF8gNAYvbfz3GZeDRjj/7BNph8jS6XrYMu5wklGpOlGKW7luL+MqS7wfI5GTmVblvRYfJ1MxJGFDkGtvSId+5iP5zl3Xyni2t/S/b20/YMI6Yf4PGv9/AxR7j5/xbavkf8R8xApF/kX9SjmP+cQg4ECkWacaUmZGEzpIcKGGpSUFqtaQrbc0gxo/4R/5hBpWZkYTOkuV+/smPSHIMZYvzwjfh9hZBaUndMwYx/2P+x/zHFCkzIwmdJey0duFaH9qOXmprBjH/Yv7Z+SdPe7GLe9KLTRxz1Wj5o8G2m8i/yD+bfykaKUE0SzilClaTgtGkW4ujrRlE/kX+Rf5hipSZkYTOkph/UX84B3iWaEooQOIskdTWDKL+Rv1t1l9zQ4DPK00cmBsJJD/GpR9z2Z+5pgVgkvmH1DqwdAgCOm/LFoMNNoFXhvEX3jWVdt3uE3TNGofQ1247iw5auz6Pf9nv/yKaM+Ot9Iq9zqP/4wIkR80uQ7Qqrfnhq+jhz2zPiI8Fu5f8+Jf/Xv/Arelx8XkEyQxB9XH2Mq5YXM6wYdkc/0dp9qWn00knnkZf+tGj+iSAtJVph3lDJryQNtxrPzrgH/ahv99ta3rNC59NE+wWY+NZDl+2P62917fpSdkpLNzZUC/fEND9yoCnsv8c45On0EYf5Ifm4xdzjKsxfh5bXHSVAYBdgC67N6r4z57GNwScQNdLrFrjS2+vp6mzL6Zpk1bTrrvAwONLZ2icZNQfuYXFH20EqCvy2dZisGFUxz/iH/mH5Eky5l/Mv6g/UX/tuQYFwto8bjHYEOefetU22PU3YtyKLhwqW4yI/3KZf3jvtL3c5of+5URJBzHOv3H+jfNvnH+1tDNoVXfrTLjFYEOcf5fu+Rc3d8koUrXxhAAckIj/0o2/nQSR/zXWkX8cgah/Uf/5IgLXEfH5i2NRgpFrpamYgEnG54/4/BGfP1A38jUGJoi94vC4xWDDsrj+0xsCWtPWVjy/rUlr8R0HuwNZnFAhzQeTVn/jYPzhGfvTOvxj8Rzalt5/2xV08queVaP4dOz/oll02s470pHX/yVdAEkSSxKmw8RilX3PoV99+0BaN5naZY7NZcEBhoSZf6w+jX+sfn/7lQH5v9dn5f9eF/oy3/8/00PXnkIfP/pz9J838I0AvOnN/R964c6072HvpsMPeTPt9IJnsN9P87KXsvH8lwM3POMf+RhfoDcE1HjyI+xP4UfYH5kfYT92+S83XWzLr2W4vWxH3qq8pRvSfjNuofN35ycEJAO2U7a4cTwHjT9uCCj7n0cvw8kWDfENAXdfStMmp9tK2JK3bMzGTwNivyDLVkCF1OM0hvsf43MEEGDIiH93WtT4RP6PUf3pDnROQIQbUvM05n/kX+Sfu54Z9Pwf848jgAIDmctP21z9Mf9i/g0y/3BDQMmwPPvSEwLy5w9cX2cHr5058g/xifkX82+Q+WfnXcWYV5DFAxVSTwhx/Rnzr0cT8ISAUqPdDQE1uRJqxcv5kWCQkX8laHH+i/N/vTyP+svTQhIizj+tehqffzk1cm6kBGmsWvFyfpx3IIsTKmTMPw5MzD/JjlY+xfx7WubfEP83gXwSdIvOVzlQ4i6FwdpdA+Hxn+umYWioqXmydTisaWUef96MA+j5/GPxHP7P7QP4Ue7nlXe7P337P0wP/tfradIh19JcOUJyQHljkpDVdqfRnde9j5pvYReq3WbRm4bsL08I4FcGNJchmsSPs5+Z3m9v+1omx3/4Drro3w6hw06dSQ8uNFuG/Z+4MW3zkWl00gcOoCl/XZ/iYJjN3S37P0y/PHtHmnTozfykAdkru5RXBhyxSWPi+NAt+f5zjE/NN13U/xoqO0LltQw2z2ywy+ZZ0xKPLzcEbMxPCOBO2uPLAPVJEGkcO9hYjF/6aB6QjmEypcNhTUu8/zF+joANIlsaauIkW4fDmiL+cf6N6w+p391zKDm6fHYSdflha/CkP2uK+RfzL+ZfzL9mXRDdLrZmJHvD0FArpcNhTVF/Rq4/mJsSUFzlS8xcEWefjWkKPmwdDmuK+I8cfxdLKCJtENtqYiZKg9dsGvGP+GOOd6RKyqNmztTkUnczHSulo1NrivxbdvmH44yjJrGP+C+7+GvcGeQrPi7j8f13fP8fv3/U8wUmSUPac0YXueVnUrJ1OKwp5l/UP5wXbV400q99fdMgN9Saoh0Oa4r8i/wbT/mnTwjIE8xOBbFY3eLMdu5iQptza2C9AABAAElEQVTM5rV9zgE48oVFOcnClGVzDKtbXFp1mFak8Yf5hgD573G5IWB/+c/tPZqPcrc7aPFS3P8HT6F91v8gXTxfxisLvmna/lS667ojiH/CzkvHJo0c/2G6n/97fZLcEIA+0dcQx+BSuSFgLVhY2gEsLpQOE9pkF68Xl3+PXkxT33QgfeyH/FB/acSL/KeA3LGU8KR/ouPPPZWmbi3vnsfHhOTCUEWB0JGZPZcf378dTf7grbk33hbteYifEHDyDfyEAI0md5DboievN30d9NSQxzxlO35CQL3pIv0wL77eJL7xZCadJ3m2tObfLz9Fu036N7rC3FhRx5f934D25eN8wV72OKcNlw3kPxtjq1tc+B0m9JFdvF7c8cfQSTY7tLrFMX5nuIwxR4vXEX+f0hKjOP8tvfpTakjkn6RdzL+oP3w+tafUqD9Rf+P8s9Kcf4Ym1MmNTxfyJVac/+L8F+f/uP6J658V5/oHXzzXOr6Ir9ZQ33NFl8s3XTpMfHHD7jTz4/o/Pv/E9y/x/VMtISgccf3PMUFdRVBENguq1S0ubTpM6CO7eB35F/nXTLWYfzH/ltP6k24IsHfB5IImBa9kcapsWt5SJUR+V6u3lHJZhRCl2HYGgT08QXAxPJ7GTzcEvIFvCOg9j7Y862a65T2Tc5xS5J6m+PeupU9svgsd95MFfCjKRxPZFDmxbX8K3cE3BGyWti8fKXz0yKacEcVdhR7/4fTf65P5lQF8xNkvOQHBj7PnpyScv6fcFCGLOHhJXeZ+UzdsKp7sKuvEdThb0jo15FUj/3p/uIiO3vOf6DMz55bN0I3hZhNp9e2OpfPOO5r2eeEzWM97Kv2Nfnx5IoL8OD9LmuWFGw/xpvToueWVAZuMcf5zjE/hJwTwDQF5b8o+pdFx4wm/MsAsYzr/hr9Nhz3/ADrriRwnPc4Yj2/8OODS+jQMMY/p+Hp0MKAMkEbhDcKRMz5xj9P6gyjE/o/P808c/xyByP/I//F4/RnzP+a/RCDq34pb/ybyNW26vOXjiCt9OZ5uietfyfK4/o/PP25aQIn6t+LWvyX7/mn5/vw/lF4ZIHUqZyY/vTV/dyFfGLFR1rJgL6rVWzLLrFNDXsX8N0GpMOZ/zP/4/GdriMwNFCGBtdIYT6pHK1P9lX3LBVdk7L9EIR/kOP6SD+k0WjMj8j/FIueGpEpJlgztOgWOV3H9YaOieHm6/shPCEjHNB9YhbK5OEfopvcH0k6W1MQp2W7XLbcOWk4vLYJt3Y1dE6e0+S23GMxJL0FptpT3fwE/IWDtvb7NTwiYQGu8/3L6/cmvI3mz+rIaX3fP7f+v6H/e8ira/78fkwjkhYlDfENAj28IuJNvCOj3ygAhj3z8/SsDhMuXomlNQ/w4+0tnpdcmLMn+D8/4x/TahSdoVzr+3kvohI34x/vWAZYtq0ty//FyOnHP/ejY6//IDraUzQAYmnwE/fePPkcHrL1KbTgCckOqUvb3A/zf+rBpH2vwDQE35icEiG/M8o/H5KcSbPQBvgkB+wRZHtePV1OIOS2LGX/4Mn61xZ7fJonxVI7xNIlxY8HuDdGtdNp229GRP+KXTmBcyNRmTdr8rJtoFt/8MtrxG0N1qnV8djulTW+5xTBm8Y/xI/4l5zTBfQ5G/uV4aHhi/kX9ifrLk2J8Xf/G/C/nhah/Uf8GrH/yI5LMIzzRTDIq/ZAkQCeYKHWJ648cCw1PzL+YfwPOP8wqN6ecAkaVLXfkX+Qf51++ISBXc8mW1o1dNYVayOWUU1rU9sfzyL/Iv6h/PFHi85eWAikbeoHUriFNiys5TmkyO76e1UEj/hoKCVvEv508fSwu5ZzSbtBya9Aj/zQUErbIv3by9LG4nHJKu0HLrUF/+vNvaBFfdfrjnrau7IXZ9GK2XiFlvY8TsWB3Ty54NcPQi3yNUa2ZDh96F8lb2GeIbO7jzB2mtsvj+PNn7E9/zTcE8MPqaej1X6S7L/8XmowdTdsu+yXLstz/39Flh25Ge579SB7arCe84St03yXvpPWNbcniX/57XX4g50WuQbGHNDSpvDLAvjYB3v77P49vqnh+eu3C62nqPfxj9eT2j9UyiD/+D9JV79+Odj/1AeLnIORF7l5Kj3JhdZWd6Kgbv0ef32INOPOG1s0odphlOzucZG6AYLfuL2Oi59CmJ/+I7jhyU2lpltJXsix+/zPbju/H1ACn8e1TGGTU0c0/uekiv9ri9XT87EvphEly20pe2uM/Rtd/aHPa4aRfppD48WXEZ9FLP3YN3X/clnwbzOjGt7Ete4rhU/eljOJgqE/B/2fvTQB2q6ry8X0vKmgKag5ZDvVH1MRSMU2uWjik4lSmmGMpNoiloqb1q0zLSk0TwbFfDqWGiTiQCjRoCjiQhmJqDlgOOdTPHEBLQO/3X3uv/Txrrb3P+e7lAwy468A961nPevZe77vevfc57/ue77zSKL7+6CXz78nr7+6O/xx/slb0KYOZg7ml/krQiXL++ZmGKub646uiwwW1qV7Fdcvxl/MvDIM2KupOR0sfM37oUKGiXH/8TEOhcv3xVdEhg9pUr+K6XXLXH/vLNn2kdT99kSRPI8e/f6XxGuf491XREYTatJGk1CV4/Ouj7Y/ZP/T+yJsRPse/f6VRqBz/vio6ZFCb6lVct+/O+t/WckmFtBsb9ScD6vbdya+5/veef+avFcj6t/HeBsN3d/7l+Mvxl/Mv159cf+pJCNaCavP8A4dlPztQocvS909yh4B6Xyp3ZQLGQn22fRuLAH53bWhfnboxj0bbPghVVvcrtAl2gUL76tTtEpC//uX1NQ+Vnwyoj+d7HlZe+rk/L4+82vbqhS08/hDZPSe03+Xzxxe6n22jYqN/UV7LtfcRJ5evvehuZe/dS0uV5T+3/OtRO8r+T/iAxPBAIJPb2cut5I+7R7ydfY1ae2jNoobnFPmyepO/XreXe6N86/THltve/gXlTPc79+hxW7lqOeD3/6Z88Cm3KVfs5Gb50W7ZyvOV2/fvL7fvx1YfR30TWorcIeDo95SPPPaHBV+U86/eIUB+MgAXXbR8smubu12/FUQim+evF11cu150sU1qXC+6WLhDQE8gZmf52mvvVa77wJPKN1vP8ZWuaS/3oNeXLx77s+V7WyOtbtuvFHqFbq13ZxfaV6duF+D5h/ba+gLtQ/vMr7XL+vcxpKOj7cNAsSG2QptgFyi0r07dsv5ah350aTUKhephMSu0CXaBQvvq1C3rr3XI+rfB0MZIGCi9PGJWaBPsAoX21albjj+tQ46/NhjaGAkDpZdHzAptgl2g0L46dcvxp3W4kONv23YppNS0lhOlHS8IyPoPwy3H31CQzd//hfHTR+0FMaE9BmnO/15CrU7bh0JZhVdoE+wChfbVqVvWX+twIdff3smmZnfrv10+a7N1XOZkvyAgtN8003IwtM/XX4uU478PFh0dbR8Gio2lFdoEu0ChfXXqlvXXOlyC1p9+k4j+uMyE18/o3Uahfb7+Wrcc/3386Oho+zBQbHit0CbYBQrtq1O3rL/WIdefNhjaGAkDpZdHzAptgl2g0L46dbuEjj/9yYD6AMOjroTb2l9OyzMQTb2dAJ+Lk6xB63bpamTXyoSO7PAymv88+aK1/uV1vUPAhtzO/T4nvLuccJ9r/y8///8ndwg4kHcIqK91fWlKuVo56EWnl/cf4W713vjNd/ay1tf/vPYFef19e79pjuXft2+6TV5/1PDsctfy1LPeXJ62f7xDQMwvb7g2Pl6OPWxHecjrv8KHYM9RqOv+anntR44pD9jXXZixSX52sgjOLWc97+BywOM/KFF5JCHRvvKTAXJBwONuqi3tgar/lXeUVxzzjvLZcvVy0wf/YjnsRldqXex6/skFAUfLBQFH+hr3xNv6RReHzhddtBe5yha28048rFzznvWnLfSii/azDAs6Ul9+UTns+r9ajv8fMMgvfn2eN/+D8u4zfrsc7Eq8WX69c4P0IW13/fyRU62VNdef+a8hXK2sUI7scMvjX19uHVZZ/6z/eDcgN9Ry/K2fWOX8k9rk+p/Hvzz+5/nP+jLpjiaEdli5bJ5/2B0C+jm2PHN/QcBl/fnzhV4B+fwxXy6b43/lZSedr3++/peW95/t4i6OXLeO5/l/nv/n+5/2YVKe/2I9dwvFJjCPf6hXnv/k54/5+aOeCy0sGLZQzME8/9hjzj8WfjKgj4c2CCpeHkKbjZ/25R6G1WLz3lrM6gF+D8hfv2i9hnzRek6r8fbyPYe/oXz2ZfeRr4Bl+197/p8pxz/4luWw13wVr2Cz28qtyhGnv6O88DZXbv7WXv/+F/P1r9drB9zqIPmhcthJcoeAu/cvq3fz+Z8vF1VcAz8ZgDsE+L6H8bfxkf9TDr7FM8vp/K2A+iCqSBptu3y5+mNPKp973p3LlXYzf209bcwvF0AcfbDcIeADkqGekPStpZMLAo56T/nwkTddnmGffGq5w41+v5wmF4ocdqLUZfgSv/Y1PLXeub9DQH9eotT86Kv/LIN0sjvzr150UX+W4etyQcBTP/lWuUPA5dtzWc4vD2Pj38rxD7p1Oey19aILfaTh+V/pAeWFnz62PPoae+1W/v7Egll//j0l1HLZ63lf+XQ56+z9yv4/ePV+d4veejefP7rydvfz+1bAmb+N3qz/d2H8Y8x5m+Mvx5+s3jn/cv7JMFg8jl8k5z+y5ix3roEcfzn+cvytTBGZHG3uLE4gnn/bBQF2fG83/YO72DyP/3n8l4GR62+uvzIMlpeI3Vt/sMwEW5cXbMudSzTH3zj/xru96B0CFgvI9R9lDjbrb+VYLF8tUI6/cfxZ0QTl+X9fGBcHUM4/nUFhyNDJ9YelWDm4avWkTrvz+bt1ZqivYEZ4lPW3aixO3169rH+OPxkfy0NEBkcLLEYvs+s/fzKgzaA+T2w2tfeMrmA2kRq5oNe2GkAYlv0GwjkOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i0v26/p9yKvQrqts/9yp+c9ZryhB8Yf6Ndw3w10CEswrQaQBh2CHfXRSssp5an3+LO5Xc/9G35ozz5ErtxQl/jF8srz3pJedh+e/FhrM8K7RM9wxa5Q8Cn5C/mbyhfkOv4kUidb1VQv/he+MkAa1s13QMpD+6///q+5do/c0L5RvuyGrezVwFl0lKndf2L/duVm8gdCr7T8oqC+Wv/Ny+Hn3JKedkd9q1O29BH8EDCdq0ZDWyUc8u/hZ8MQDKx2+oFAe+WOwToTwZMyc76vfITN3paOXUDX+LXCyV6QuSFtcSC5KKLehHCkfVnGYanV/Yv9z/xfeV19aKL+lDa5jpx0KIb5X9OuG+5ltT4m+Uu5WmfPLE8dX8Zn+6pQGv2O+Xskx5SDrzHa8vnhazd6oZG+/e7YVxLaJfUQbSIVPdAwkJMq4G2P/v15ciDHlSO/tT3lUNedVr5h4deP6QMzkJ/keoeSFjmBdAAwrCI+qec+V11HEStItU9kLAQ02oAYdgh3F0XdRDaSHUPJCzEtBpAGHYId9dFHYQ2Ut0DCQsxrQYQhh3C3XVRB6GNVPdAwkJMqwGEYYdwd13UQWgj1T2QsBDTagBh2CHcXRd1ENpIdQ8kLMS0GkAYdgh310UdhDZS3QMJCzGtBhCGHcLddVEHoY1U90DCQkyrAYRhh3B3XdRBaCPVPZCwENNqAGHYIdxdF3UQ2kh1DyQsxLQaQBh2CHfXRR2ENlLdAwkLMa0GEIYdwt11UQehjVT3QMJCTKsBhGGHcHdd1EFoI9U9kLAQ02oAYdgh3F0XdRDaSHUPJCzEtBpAGHYId9dFHYQ2Ut0DCQsxrQYQhh3C3XVRB6GNVPdAwkJMqwGEYYdwd13UQWgj1T2QsBDTagBh2CHcXRd1ENpIdQ8kLMS0GkAYdgh310UdhDZS3QMpdvyr0toOXyQ5mZ3uN4Hsdvv830lx4rrace28bipYlSHgtCNsPnsaPLSHRZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uxaNF3fpTwZYtMq7BxKWHQNoAGFYRNGN+i7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsuKtDuEAAelq1noJJ14RwZGfOJAGDntGRUsi6cIyNjPhEALLPNQCXrwjkyMuqfd5LcIeAer5c7BFRftm1XLtd/wpvLh55zSNlPmcW9th77NOkcGRnziQA+f1S59w89obzlfP0gSG8zs71c6RFvKJ95+X3a776rFA0sL9AcAeP/eh1qfEl8nXLIq08v//Dg6/lPoCAK1vLLX+Afdbuy/xP+SeLy1+tnyQUB8pMByGaNwHxa7n5w0HD3A+QX9ZV+rrzw3/6yPPpactHDJpvl56dqQY1spXy1nPakW5Y7POczIa6O/mTAh+UnA1ovaAR71tPKTxzwe3J5xv7lAfIl/mvdHQI2z18vethRDqh3YahbFXOTGr9Savyw6wqjjx3pWDQSaFR/5qHe5aD2V+8Q8Jby1BteQVpPQjTQyMb7yzGH/ER53Cn83QDGS5G7YTzijeWzMp7qZQ6Lz9+pR6iZd5G/NdopFyY8uNxMLkz4XPE/0WBtiQBgx6TOV8m6cI6MjPlEALAu3whVsi6cIyNjPhEA7JjU+SpZF86RkTGfCADW5RuhStaFc2RkzCcCgB2TOl8l68I5MjLmEwHAunwjVMm6cI6MjPlEALBjUuerZF04R0bGfCIAWJdvhCpZF86RkTGfCAB2TOp8lawL58jImE8EAOvyjVAl68I5MjLmEwHAjkmdr5J14RwZGfOJAGBdvhGqZF04R0bGfCIA2DGp81WyLpwjI2M+EQCsyzdClawL58jImE8EADsmdb5K1oVzZGTMJwKAdflGqJJ14RwZGfOJAGDHpM5XybpwjoyM+UQAsC7fCFWyLpwjI2M+EQDsmNT5KlkXzpGRMZ8IANblG6FK1oVzZGTMJwKAHZM6XyXrwjkyMuYTAcC6fCNUie63b9su59sV27ZTLpTWs3twY6fmEwHAoumCVcm6cI6MjPlEALALeUGpZF04R0bGfCIAWCRbsCpZF86RkTGfCAB2IS8olawL58jImE8EAItkC1Yl68I5MjLmEwHALuQFpZJ14RwZGfOJAGCRbMGqZF04R0bGfCIA2IW8oFSyLpwjI2M+EQAski1YlawL58jImE8EALuQF5RK1oVzZGTMJwKARbIFq5J14RwZGfOJBGzbS1btSvTN//QLuGq1DVv6UMNzZGTMJwKAnXo1QiXrwjkyMuYTAcBaugmpZF04R0bGfCIA2CmrESpZF86RkTGfCADW0k1IJevCOTIy5hMBwE5ZjVDJunCOjIz5RACwlm5CKlkXzpGRMZ8IAHbKaoRK1oVzZGTMJwKAtXQTUsm6cI6MjPlEALBTViNUsi6cIyNjPhEArKWbkErWhXNkZMwnAoCdshqhknXhHBkZ84kAYC3dhFSyLpwjI2M+EQDslNUIlawL58jImE8EAGvpJqSSdeEcGRnziQBgp6xGqGRdOEdGxnwiAFhLNyGVrAvnyMiYTwQAO2U1QiXrwjkyMuYTAcBaugmpZF04R0bGfCIA2CmrESpZF86RkTGfCADW0k1IJevCOTIy5hN1IHcI4N+A98SQVFu3+tGCYNzbBGFl3QcPCMDWtvPGaAP0nBBctXW77OY/72T5bfZ7yG+z96fYnu3l71J+44w3lWfcTH4zvm3fzef/7fL/Xn23coOHvb3Er3FvLH+9f2o57h7XxLuR9sjwSunjhAerbNyfJ19WH1xuJF9Wh1HXniK+sMVfzO/O6y9/DS8XBNzwiXJBwMZdeDv7/hVzTN28M8rRt99RHv/ucxfyi2DfI8px/++F5bAruBfkQo2/T5Vj73dQecgbzg6Ppf0c2EZ9vvUOAQeGGAt8lvxkwAH9JwNOel857m7yQxJ4WNXKFisN71tyFwapSfsCX3W237f88PPeUz4qFyFoY7QxhfWK+ru7OtQLAj4hPxlwgN7BIraGZ/bskx7Uv4z3/cvTkMe/sd/Pl5d+8mXlkde4XAzyWSF/f9JbWn/6Txf81X9JjluVR5/+zvKC23yPrlntYeKx+ocA7qLI7/tVjN53v/4X5vln/rECWf++OrZCsBquTOCqrVuOv7Ymbmn90Qr6Paqb878OLVbDlQhcjj8tSs6/nH8yF3L94aFIT+DaqACUqeLXjTpnljeoLivrb70goK2jWC7laU9v6V0pLmvP315pPDNY96QdZLQBeguKGqtbrr9tbuX6w6GARSeOHniwOnrGPaMN0HMycNXWLcffnjL+6h0C+qvdXnnc6WVPef7tSYfjeI7/nP+5/uX8l2Nhnn9wKcjzj3ikiB7On5Qd94w2QM/JwFVbt1x/cv2RsbCHrD/b5PcG5c8JMAl0CiztlxVgYWPL+sGE3gar/g2Dnuw2hchR3/UPZoa+xK1TM27ICztEL+H5zz/558o1Dz2unCNPbKMWpBZj215lnzs/r5z2ll8tt9rbnvHKM5Q2vd1SdS7o898pf9V9x/pX3d/Sx9L73naLp5dT3/875XbTH87jUcHuqv5yi/8TflZu8f8mucW/PO720OsYqc//KuWAZ72rfPzJP7LwTFplFvgvl7c/7ublzsd8oZQrP7K86j9fWh56RXsM8/g7oxxz+9uVx72rPr8xv/g3eHI5+VPPLHebnudafjxvWMtd0cZXX1oedr1fKsd+U3B7rpUF2K/c9Oj3lI88Ri6AWJp/cocAvSDgh8phJ76/3SGgtowb8sLWaL/F/33lZxQqLVvL2HZXlhq/p3z8STfj09/1/PsvqfGPWo3/48/KQ6+ER4K8sJoP+42dHyuvecDtykNf/5WF53/18iNHn1o++Jiblu1Lzx+ddLuSQaLtiXUbG33n408td/6R3y+nyN0uNm77rPL+dz253Eo+P63POdcfrdyuX3+t6VbqP8+//vpk/XP8ybRtq0gbWMujy8/mZQVYWN9C5vgFPf7F5sFbySCa9fUn8+f5X57/6vzI8/98/9PW+7qqymKa518XzfFvW70gAFv9QkmOefUtfd3y+JPHnzz+5PGnLrh5/L3kH3/bXG3DtY/Zvo63tVx2PH5Wom14VwILvkfz/U9+/lw/XM35n+ufrB5cP/L8O99/yGBo46EdOpaPH/5osqwAC+tb5PuPfP+V778ube+/2h0CwnSmQxBn+YIHZT1/1S931VIKAYkIQpgOQRQveFBe2vKfd9ID5A4Bryvx78frQn3VcsMnHV9Oe9ady7V4FF944p26aJ7/RvnWex9Tbnu7F5YP7aynkNiuX+70qneWv3/oD9oJBUJbyL/zg08oB93yqPIhaWs5tKMrHP7X5csvvXe5ih2phkyj+7Hy5/e8TXnESeeU8qN/UN71T79ddsiX+RgHVKNApV4QsEMuCDi3PZcxf7tDwH++qBy2d23JRuxmDUCJvGq/Xb78up8uN3rAieVrkk3fkttz3ia3sK9/rf8R+Wt9tG/9d2fnBx8vdXpeObP8f/KTAXpBwO7m/84HnlBuddBR0la3eiqI/JevNX6Z1Nh1tpTfnv/Hyl/c89bl4Sd+o5Rb/EF5t9T4YPcZZO0G7ePz1wQbn/6Tct9bPrmc8LWdoeb1Jd642oPLCz/85+WI7798i7UW6Iy9aj+b7dEk5C+fLK9/6O3L/Y/9T+n7BuWQV72jvF3G8NKG9i1Gh2CpSeCgDPn9vIUgtDInhOkQmHAFQZn58/iTx19ZV2RCtM9BMF8wQeAPNoTpEAzq2YUSeWGphIBEBCFMhyCKFzwokReWUghIRBDCdAiieMGDEnlhKYWARAQhTIcgihc8KJEXllIISEQQwnQIonjBgxJ5YSmFgEQEIUyHIIoXPCiRF5ZSCEhEEMJ0CKJ4wYMSeWEphYBEBCFMhyCKFzwokReWUghIRBDCdAiieMGDEnlhKYWARAQhTIcgihc8KJEXllIISEQQwnQIonjBgxJ5YSmFgEQEIUyHIIoXPCiRF5ZSCEhEEMJ0CKJ4wYMSeWEphYBEBCFMhyCKB69dEFAvqK3yfoa9c2f9IMYJd9FVCNMhcB0tQyjxvGGphoBEBCFMhyCKFzwokReWUghIRBDCdAiieMGDEnlhKYWARAQhTIcgihc8KJEXllIISEQQwnQIonjBgxJ5YSmFgEQEIUyHIIoXPCiRF5ZSCEhEEMJ0CKJ4wYMSeWEphYBEBCFMhyCKFzwokReWUghIRBDCdAiieMGDEnlhKYWARAQhTIcgihc8KJEXllIISEQQwnQIonjBgxJ5YSmFgEQECOuHx1jF6/uYGtn1hvbIC8uWEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiMCHp58M0KCX6GcN/M3wKVvsfPasr4Zkx78OmcX9a0BrUyXqde4ylP98uSDgGv6CAHyb0+py/XLwi08qb3/UTUv9fvpir/+57yrP/qm7lief+t8tu74tkV97/8nnlPf+zRPKrfe+iOr/328qR97kZ8vRn6vXrOtr2xOWcpOnlrd/+Gnljnvt5ut/9qvKI/f/hfLyL28vVz7ireVLL7pb+R52BmB9bZRPldf8rNzC/416CcaUf9uOcuQZf1eOukW9zYB9oqY9XMDn3+r5U1LPvcu1rvXN8p//KX+mHrYrlxs9693lY8MdEZDrPLl7xDUOPV7uHvFD5f5vfX953aFX1ce0O+P/f95UHn/j+5Xn/Xu4skOz3+h3y9s/+ntS4/Bg6CA/n7/U+PD9H15e8eVSrvKoE8sXXnTXcuXwaSObroBzyxff9NByh/sfXz71nSjZVi5f9n3wq8uHXv2Acv1e7im/NAnc7jz/cp7kfEi5w2GS89syhn/iT8rpf/v4dseN9tmp5LJXNz6mkKuHArdb+X2f2royDcku17+sf44/P0cMh7nW6cDl/JPJszZ6rI6GtHrVb0h2uf7k+rM2gsJc64MocDn/cv7l+mPL6y6Rzp4qa0h2F+X6iy+R6gktrguIXyRdvPl3+fT72fvF9fwz/64qkK8/jvYXx/zbVfX7rG+yzN/XqLpWrRROR6uN2SoL3GX4/GPbdvlLi/r82iaf+G3I5zey7SnPf3qu7dnn88/Xv64XWoX5av8+SFZNbyfxhmR3UZ5/raZlIPNjtc/65/EvP3/P9SfXX6yIPEgQ6NHCjhk1ELiL+fx3uCDAPRBCgvagvYfH1jgf4NMD2DQIkVinIyRoOu9d2vOfd7LcIeBQu0NAfZNUnx+3vW5S7vjsl5W/OnIH7xRw8Tz/s8tHjrp7ucMT3lO+yuQCLv+T5fHvPaE896D9yF74/F8oJ//Kbcqhf/Z57dM94W17/WT5jTNPKs84UL6QZyKCpjdvZ/n6iQ8uP3LP15bPle8vh7zyveUfHnY9Ps4I0Orc8tkX37Hc8NHvLefXI1Pduqlwm1xOcIOnv6N88nd+rFwOTeyBVEnw1sfft8pnXn6PcstH/kP5+m2fUp6/4y/Krz73s20V0A/t9NO7vR91cvm6XMTQbkgQet9Zvvbae5XrPvCk8t/lR8vhp5xaXnqHfYOiPRZ5jO0aEnHa0+G7bKnxo25dDv1T+SmF9ta7P8madvshvcb71C6GjU+6P9Gd5ZyTHlQOvMdxUuPryF/Zny5/ZX89vplff/5jt/9eTn3Kvct9/uiD5euSol0Kwvpfp9zqqJPKaUfevOzjq8uHQtA69d5y/o1y7ieeVQ677W+VN39V1Fe9e/nNt/9VecYtbQwPj865rndCgt3M77ojjH2QnoDTERI0tfeWn//UqRC+1VIcnNMREjSR9zL/2vxDPWF91cAtWacjJGgNvJf1z/ovr//j2PKjZox53+kICXL8SQV8NXL+5fzL+dfnhJ8YfkmZVo0p6AjXCSHB1FPOP7nYdXs96a//pE7dxAsCatliDSuzvDkdIUFr4r2sf65/uf7l+tfWBL8wTIvLpkGndjpCgsv8+rNdJlN9tth0Hd9znn84TvFpE7SyeC+PP3n8yeNPHn/amuAXBiygtJsGqcr1x9WJkCDXX6mAr0Yef/L4c1k7/gwXBAwDXiZA/YxhedOp4SfIsk7ZUd38hcae8njuW6Oba6zVqG7+QmNPeWw9AWl0cw20qKupK/r2iXKHgHvKBQH9gxyqg3+tcsAvH1Ve8ycPLLe6sr9X+4XPr18in1/+66SHlx33PrZ8An/B3fJfu9zsmW8u//gbty717+Xnbav5S/nW6Y8pPy4/TfDPkq/2gg+yitxG/4BnvVP+av4WpT5TzTBnbszGx8qxh92uPER+n75c7efLSz/58vLI7135s3f2JT2efVx59IEPLi+Wv55nmQlEWG9j/5E/L4++zuU3z9+j82PcWb5x+pPLPe/23HLKN25eHnrySeWoLz20XO9hbyvfku59qm31Zw4+EG/Br/2dXd73OweV2/zhp0q54s+VF33m2HLENf1rXyugyjm/xmqN688/nCk1Djl7jT8qNR5uxFAbhue8UT5eXnP/HVJjuUyk1vgTLyuPvAZqvFn+1lXYbWx8vpz2lHuWn/7DM3nRCR/X5W5a7v7y15c3Puwm/W4Y2nT5uaHbpfwb5bxPPr8cfrdfL3/5b/WODNcrO9pdNg4sVxCPVxkLbq0XEnjKY2Q1q9HNNevq1m6hsac8tp6ANLq5Blq8rqZuyFwKPeUxBQQa3VxD8TRaW7uFxp7y2HoC0ujmGmjz+Y/Vav5C8TzlsVUSSKOba6DN+o/Vav5C8TzlsVUSSKOba6DN+o/Vav5C8TzlsVUSSKOba6DN+o/Vav5C8TzlsVUSSKOba6DN+o/Vav5C8TzlsVUSSKOba6DN+o/Vav5C8TzlsVUSSKP+DgHtJEvC8wUBWX+tllW0IXNR1OH9j753YjCAsccQnJxRnfmltln/aYD5kng8DajpHdWs8Iz2ZT02ZC6lnvKYAgKNbq6heHq0rd1CY095bD0BaXRzDbSXjvVvXMt3yjcO9TOS5e2y9/zr8/Svp8dzDfL5x0+05gp5ZqxW8xcK7CmPfV+KNbq5xlqN6uYvNPaUx9YTkEY310CLcWXqhsyl0FMeU0Cg0c01FOf6J6XIz19ttDRkLgeKpzymgECjm2sozvEnpcjxZ6OlIXM5UDzlMQUEGt1cQ3GOPynFpWH88YKA9RdWf33cPxk7a1trtcbXAYIYrA6a6CmHSD0tvizmP++kB5Zryl9fny3Pzuoif6X+S08sD/iX55Znn3ZOL8Tlyt43e2B54lFPL0+5yw+WfVgsAl8w19dANxdtqv1m+dQbH1t+4RF/Ud719Xp7Mn0c9S/lr/mIV5b3vexn5VbuF8fr/4ly7P0Pli+avyY5/eOR/N//8PKy9/9pOVy+kNdtKf9G+eZpR5SD7/in5cM7L1+u9tiTy2efdyf3cwHos3cRzLnlP447rBz0c28uXwh1R5vLlave7yXl1L98RLnZ3lqP3R9/55evfuC55dfu9zvl2E/vU67/mNeX9z3vruVaX35ROewGv1aO/5+aQ6os3dary8peB5dHv+uk8sIf349VaIJzTyy/ebOfLs8669tl+11eUj76t79Sbuw/PcFDja1aU91VQa1xvWDiv/rLqs+lxrf9wCPKn73vJeWR16lfk+vGLkEUubDh1CPKjjv+X7lw4wrl6o97q9T4LlpjignYaq23xstFAafIRQE/80dyUUBt6uu/143lbhgvl7thHMy7YaCv3av/+eUrp/5uefjDnlve/JnzpGu5oOW3/qq87emHTP2FvJpktZJ1fO5e/t5RM2t1qUHEYLVd9JRDJPNfNtd/HYd4lb2Xr79VIOdfzv+c/5fF81+/4uXxz1fDVr88/8j1f7P1f7vcZnqj3oOxnVfWcSMrxUa9srtySxtmGqxqoufbZf03q/9yndermef/qA1sjr9agViNnH9WgT1n/dm+Tf8MBqs57hCQ60+e/+f5v1shCQlsuWhoja9BxGC1afSUQyTnX86/nH9uhhAS+AkjeI2vMsRgtWn0lEMk51/Ov5x/boYQEvgJI3iNrzLEYLUpPLkgYKdg9+EBImyoDZb2lLYgTty7MgTF6T8cgdtsWH9BaI93D8g//mRArcm2Ax5b/urdf1IO2+f95c9/+f7ll17z+VI/3tHtauUHfvqI8uu/9vDyiDsfUPaVl81euQtY/3M/Vk5+5i+XX336qeVfLYGk+Z5yrQe/uLztFQ8pN7vC+FfpeBxq4yt3wfLv/Mzzy4N2HFmO+4L+Tpr1fPmyn3whf9qxD1/JP/wVeP2L/g/LX/R//+VkxNSFs2/hwQ3jTy4FOPUp95Bb2J9ZvlZ10yY1eMjzyokveYTclQF/ET+J4gjd+GI54+VHliOeeHz5x69vK1e814vK6cf/UvmRdlHB5/vPJHxRx3frShJv20t0Lyynv+6Xu04CG98on3jJvcptf/Wd8qX5DcrdjntXOfmwH5iTV6n84/MVb3z+Oz8rNT74yPK6L+5sWv6+QKk1frHUWC56aNcEWC/aqdT4rGPK4Xd9kv6lvdT4RVLjI74fF2now9lVfntwosT83/mV8i+vfkx5xGOPLf94dn8S2p3sr1SuefffLEcd89jy4AP29a8mFR5ofnmsX3pHOe6Pn1SefMw/lS9+pz6Xa8nFAK8pb/uDO/aLAVx+gfWCDNu0F/p0CRgaQVTM9V98/tIo8/tKxirq+KvxgfdNOo6KrP84/3P8YdDISMH6IzDnH+pSbZxF5g68b9JxVOT8y/m3m+dfefx1synOopx/Upo2Poa6uIoBRsWeuf7U20zHrV4QIO+pQnHEyeNfG1f5+UOe/8QpEyaKmzcDHydZ86Jiz1x/bPXJ539hz/94h4A6uqSw7aPZhXEHKsdfP1VoBcnxd2HHXy9jL2ocXRhz3kZF1j/rn+//eDwMk0OcPP/WY5qUIs+/1ldRe98WBpBvQBwVuf7m+nvh11/eIcC9E2oDzoaXIY5EgDgiwdqY7gxkav2eTQRApZxlNeTVDccmDI80fLV+zyYCoFLOshry6oZjE4ZHGr5a259/0gPkDgHykwFsuX+5+3FvKycedgNhZHhvfKmcfvQjyy8+9eTy4SaStvWIs7FX2fuH71Ee8OD7lnvf5U7lbj9+g3ZxALrRDPDsmTX+/E+Xf3zNs8szn/nn5Y3/8t8maqj+PMEx5Q3H/Fw5cG9Mr4vr+X+7fPWUJ5b73uf55ZT6w/Jh+55yjUOfXJ539JHyxfBVJIKB/j/li6c+ozzmF55ZXi+3hN9Wbwn/sr8vpxx+o/YTA+hi0+ffX+eNjf8oZ77kV8rP/8Zfl38+Z8xfe9oud2V4aHniM/9PedI9b1Kuis69bc2+Uj554vPLc//omPLSd3+lfLveXeFBzy1vesHhZcfVL9fU7fF8+jnlPgc9ubxF/jRes7UXUuKiv/tjy2894X7l0Kt/rrzr+OeUP3z2u+Qije1ln7scXU57y6PLQXtvby+7T20dT6wbyfJX86c8qfzMfY4pp0mN2+MQuea/crmm1Pioo+uX7/tJ/4hKjU95Rvm1hz+jvOHf6pUiP1B2vPxt5dRHxBrvXn59bOhZbd1/p5zzkVeVZ//6b5U/OvlL7oIX1Ze9rl8OPPxx5Tcecf/y07e9XrmKnEHwRKtLysbXy+fe8+byluNfVl740lPKR87pPwGx7y3L3X7vBeWVj9vBOwPM+e3ZojubJcrYqDdk2o7Q8RAYafhq/d43hEo5y2rIqxuOTRgeafhq/Z5NBEClnGU15NUNxyYMjzR8tX7PJgKgUs6yGvLqhmMThkcavlq/ZxMBUClnWQ15dcOxCcMjDV+t37OJAKiUs6yGvLrh2IThkYav1u/ZRABUyllWQ17dcGzC8EjDV+v3bCIAKuUsqyGvbjg2YXik4av1ezYRAJVyltWQVzccmzA80vDV+j2bCIBKOctqyKsbjk0YHmn4av2eTQRApZxlNeTVDccmDI80fLV+zyYCoFLOshry6oZjE4ZHGr5av2cTAVApZ1kNeXXDsQnDIw1frd+ziQColLOshry64diE4ZGGr9bv2UQAVMpZVkNe3XBswvBIw1fr92wiACrlLKshr244NmF4pOGr9Xs2EQCVcpbVkFc3HJswPNLw1fo9mwiASjnLasirG45NGB5p+Gr9nk0EQKWcZTXk1Q3HJgyPNHy1fs8mAqBSzrIa8uqGYxOGRxq+Wr9nEwFQKWdZDXl1w7EJwyMNX63fs4kAqJSzrIa8umFpsm17PTPW9xJ4RzHeaho9+8zgrM/IWFZDpu0oNmF4pOGr9Xs2EQCVcpbVkFc3HJswPNLw1fo9mwiASjnLasirG45NGB5p+Gr9nk0EQKWcZTXk1Q3HJgyPNHy1fs8mAqBSzrIa8uqGYxOGRxq+Wr9nEwFQKWdZDXl1w7EJwyMNX63fs4kAqJSzrIa8uuHYhOGRhq/W79lEAFTKWVZDXt1wbMLwSMNX6/dsIgAq5SyrIa9uODZheKThq/V7NhEAlXKW1ZBXNxybMDzS8NX6PZsIgEo5y2rIqxuOTRgeafhq/Z5NBMjnbe0OAcbFOwQYT4SOSSgYafg+MzhrGhl71oZM21FswvBIw1fr92wiACrlLKshr244NmF4pOGr9Xs2EQCVcpbVkFc3HJswPNLw1fo9mwiASjnLasirG45NGB5p+Gr9nk0EQKWcZTXk1Q3HJgyPNHy1fs8mAqBSzrIa8uqGYxOGRxq+Wr9nEwFQKWdZDXl1w7EJwyMNX63fs4kAqJSzrIa8uuHYhOGRhq/W79lEAFTKWVZDXt1wbMLwSMNX6/dsIgAq5SyrIa9uODZheKThq/V7NhEAlXKW1ZBXNxybMDzS8NX6PZsIgEo5y2rIqxuOTRgeafhq/Z5NBEClnGU15NUNxyYMjzR8tX7PJgKgUs6yGvLqhmMThkcavlq/ZxMBUClnWQ15dcOxCcMjDV+t37OJAKiUs6yGvLrh2IThkYav1u/ZRABUyllWQ17dcGzC8EjDV+v3bCIAKuUsqyGvbjg2YXik4av1ezYRAJVyltWQVzccmzA80vDV+j2bCIBKOctqyKsbjk0YHmn4av2eTQQo3y4IwFXzITV6odR15GKto+bLxxGBr8mE6FdGVW9t21PznxcuCLhc2efef1rOfNPh5UZ65zD9nEe+Yq5fnj7nt59WnnfCZ/vFA1Lregv5Wm/Ztl37ZuXmP3bLcqsfPbDccP/9y/777l32/aEDynWv+O1y+e3nlC98/NPli1/6SPnn951S/uat7yln/Me3taHfX3VHuf+zjy4veuSPlWvik6VqZatp8BVqw0q0mL7GVbCV119usX/GUeWJD3taecVHv9Uz9a4kx7a9rlOud8fbl1tfb99ytfP+q3zzrFPKa0//itzMvj7//lfgT5dbwtdHsqX83y7f+MQbyot/9zfLH7z201Lb+sRcfsEbZZ9ylZvfrRz6U7cvh9zmRuV7y7nt4oPt3/hE+dAH3lVOe/Pby9s+fW5rV7bfqOz4gxeX1zzxTuX67S/vpT+O/2+Vz7z2geXODzmhfCrckUGbStaWrXrtCrofenh5wckvLI8+4EoXsv5y4cUHjiq//vNPKy//yP8gmdla40PuUH78+vuWfc/7cvlvqfHx/ygXNtT6l2uXA3/7NeXvn37Hcu3+kwW1Qv7XCy7U6y8XvHzw1U8vv/9Hryhv/NjC618f5ffdrPzorW5ebnylfcq199+7fPNf/7Oc942zyj+d8eHyL1/y4/iKZb8dv1Se+vynlCMPukarpj62Olbs6S6hPXX9QS3y+eucy+MfLgKTkdEmuo4QhW7vYhdq/vcBmOMvx58evnP88dI3N8fczNNp6WI5/6QYrR5ykA91qYtLjeXxP89/+oFmxVyajz/hr0r789MvkqqT4z/nf65/uf6tLHxcL/L885Jw/om1vD2WunTXA5NsdX/xfP7Wupc8+fpfEl7//Pwh3//l+7/+Ya0uem2ByvUv1/88/rlZ4OaGvserJwj5+Ud+/tNOFPWkDivnBf38S0466/CatzDoatgT/dTFU+zBndYwTtC7cT7bDWCSeOKykT9cEHC1+5RnnH5c+c0D9tZC+KfbmHPKZ095efm/zz2qPP+Ez7QLA+qhs77e3KRN44SAZayCTsbY1cp17/uk8tyjHie/c38lk0/5PXHR1n/jnDPLm5//1PLs57+1nNa+5MUjhLWH1dBVbysXL7ygvOjwW5VrTr9qsJXxJxcGfPKE8uqXvrIcf9zf9i/48XyrXd7ao6s7+Yv2mz7ol8oTf+Mx5fAD95WZ0k/r0AXnzjnlrL96VHnoo44tp3996FP60Ws85I4Bhz61vOyljy33/v4+FpqUnYl3weu/cc4/S41/t/zxMW8t75YLQqZnxfw1mTj7/Xg57DkvLC985EF6gQifQ41f8Pw6+FpTfaJtMNa+ZDvvs+WMN7+8vPKlryivOLle9FKLiuc7PdLWpO6aattVy7Xu9KByxBMeVx5/6I3LflLE9fqjW/TNrmYwSTxxET//Obs9fcYyP8fQRT3+WGMHfLkb7Yl8/dsc8yVh6XL+5fqzdvyTQdLGzOLA4QiapttE5PzL+SdjbHEY5fqT68+es/5s26ueBfdN5kP1viNv6RvL+UGQ628rhasHajfaSeKJPP7k8SePP3n8lUXDLb+6hGz9/KP+/EtdZfonG7wgAP1aslx/cv3J9SfXn75U6ALR91tff4ZubLlpgTz/sYLk+pvrb66/uf7KwngRnv9dEtbf6ScD4rLfn68nx4NDi6mg7utmNbKGQLCq9HuN+DgxAfSOaFD9uq/bpSX/eSfLTwYcerx8Afp95ceOOrGceuQtSv0KGI+fz5KgPrv65fVJ5Y3HHVdOeN2by5vO/Hq75Xptg+dfVXUDB6ts3+97k3KrB/xCedQjf6H8/G2vU66gn9T3vWqYlgA9OKJB9eu+bnj8/ltNtIBVpd/LQfabnyqnn/ym8nfv/Ify7vd+qHzwA/9e/uPb9U2StJK/ZL/uwTvKHe9+WDn88J8uh1xnH23cOtRe675uW81fW25snF3+4wOnlXe+793yV+j/XP7lw58qX/jcWeWMz8ldAKTjugjWuwbse5Nblpv98G3KwXc5pNzrXncqh8hf2O9e/o1y/qffXF529IvLq974jvKez9S7C2yU7d938/Jjd75Xue+DHlYefY8bt5+A0GfVwv5JRaKJVLk7+Xd+45PlfX9zQvmbd0ru955Zzjzj8+WL39EPEDcud53yAz++o9yp1vgXf6b85PftrbXkA5HUbXNEg+rXfd22Xv+d5Zwv/FP5x7/5u/LOM99fPij1/+gH/618Sn4OAB1v27hiucqNb14O/OFblFvd6a7lZ+/6k2XHja8m8wZvpi9Mfu0Dj5/PkkAfhh/X7UXvR8YL//wzvy81MUHWXyvgCtKg+nVfN4xfP07RAlaVfm99oD21BNA7okH1675uaJ/5rU5AsFopv9eIjxMTQO+IBtWv+7pl/bUOOf5snADBokJmNeLjxARQO6JB9eu+bjn+tA45/mycAMGiQmY14uPEBFA7okH1675ue9L441+VyvPG87dr/LUutSZAsJWLm0Z8nJgALRzRoPp1X7c9qf55/l9f8Hz966jP8d+mf85/LYPsdV5UFwiWEgL5DGa7/HWLCOr6Wf/QZ+dO/VyGjZ2Wq2zrUHut+7rl+qt1sKob0koh7q3VEPWjlgB6RzSoft3XDe0tqyHXUsXcWx9oTy0BxI5oUP26rxvaW1ZDrqWKubc+0J5aAogd0aD6dV83tLeshlxLFXNvfaA9tQQQO6JB9eu+bmhvWQ25lirm3vpAe2oJIHZEg+rXfd3Q3rIaci1VzL31gfbUEkDsiAbVr/u6ob1lNeRaqph76wPtqSWA2BENql/3dUN7y2rItVQx99YH2lNLALEjGlS/7uuG9pbVkGupYu6tD7SnlgBiRzSoft3XDe0tqyHXUsXcWx9oTy0BxI5oUP26rxvaW1ZDrqWKubc+0J5aAogd0aD6dV83tLeshlxLFXNvfaA9tQQQO6JB9eu+bmhvWQ25lirm3vpAe2oJIHZEg+rXfd3Q3rIaci1VzL31gfbUEkDsiAbVr/u6ob1lNeRaqph76wPtqSWA2BENql/3dUN7y2rItVQx99YH2lNLALEjGlS/7uuG9pbVkGupYu6tD7SnlgBiRzSoft3XDe0tqyHXUsXcWx9oTy0BxI5oUP26rxvaW1ZDrqWKudeI/mQAOhnVuJeUxBkiYE8KRn7RB9ltNC5J7/synv87Zzyh3PrWzysfvd0fl7f/7a+XHf5qgFqCXT5/uTjgs+8t7z7ldPny+szy0Y/9SznrXz9R3vfxc+QiAV9r6esq8lMCN79pudktb13ucNvblzvebUc56OqSUEYPlAb2jPrj+f7vPv9vlq9/Y5+y35X3ci9E1r9VYJfjv9epGr6InVv0QXYbzUIfIqi34vHdo4uehmbkF32Q3UaT+VEeFDVf/xx/Of/abODUIMAk6XbkF32Q3UaT6w/Kg9Lm+pPrT64/uf5IBbg0EGCR6HbkF32Q3UbjkqBPEexi/OGCABG2DwLqxdPtggCkwsNsPshuo9lSfnRvBcJjF2ufTPS+M78WJRYeVZlrKJFdvP5Z/83GG6uT468NMoy0bqPJ+Y/yYNh8l8//bC3XB7CxU/4QIud/KwZfGgK8SN2O/KIPsttocvyjPCjtd3n85/FPCh/OmeQFyfnfRiOHJgEGabcjv+iD7DaanP8oD0qb8z/nX64/e9T6Y3cIcJMf60G1WCNgfQzYYoYQg22RKeyIPTT/xrnnl/P3vkK5wsXx/OU34f/9nKuU637v3vo6unLr6+KIiyM/XnyxLZNLl/lrBVxBsv48+OrYiCPEVcqHG7aYoVHUIlPYEVn/rH8/pPJg8QAAQABJREFU+fFjByME1seALWYIMdgWmcKOyPGX4y/HH6YLLWYILAMOWMyQCzfYIlPYETn/cv7l/BunDc9Q3UxZ1YTz2UGV80+m11RER2xx/Rm/RKpltzsE2IuQ9b946t/qLbvhsmErfEdZ/6z/xTH/c/z5o45bT4cZeGmYf/UOAXUdqY+1bnUdxzOC1UjcW8xQVPQaTWFHbPH4U/NYL4Yyf6xAq8xUHkdk/eUA4b8N1/qhQrCxqlHjR+Koa+2nThyR9c/65/gbpw3XdjdTVjU5/9ar1CJT2BG5/uT6cwlYf+yCAD/N3Tht9OhTOwdmhmIDItqQd0f6Nw1GE42djP6qcLMliY2aKPNn/XP8zSfgbZaM8230OZXmwMxQbEBEOf9y/uX8y/lni4JD4yIy+pTOgZmh2ICIcv3J9SfXn1x/bFFwaFxERp/SOTAzFBsQUa4/uf5cFOtP+xJJ7i9dvzqq/fEOATbaZpTjL+dffv6Snz9JBRa38SA2+mw0B2aGYgMiyuPffPzTi7vqayIFErMhPxnQttWizoGZsbITiSjrP9ff1ydMjdWizoGZYa8Gsv45/vL4m8ffsMjY8lCX/xAafUrnwMxQbEBEuf7n+n9RvP+MA7WduYSha4POoRx/l9j5Fy8IaC+Ue4lXrlrhS+tWH4WOqCK4zdZdpWQYdh7hFtCgFCrz821a1l8GA6vBYULgBpBCR/Tx1FanRtddjr+cf7n+5PorC0H9wEVNXRZ0EyKPP3n85REnj795/M3zD6yOs3ULqEJHVDXcZusuz7/y/CvPvy7K869t2+vRqv7T+VXRznrcqlubd7A5/7QkOf4uyvHXhh6GGAdcrbRsOf5sarai5/Evj3/r6894txf/kwE6oYY95henmiOqFG6zdZfjL8ff+vir4yU//8jPP/Lzj7ZUymSQCZHv/3sxFkw7riiv0BGVhtts3eXxJ48/efy5JL//0gsCMHHblNVdpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznoJNvDaIvWNdLpJznYJX7L5FwWcDSTwa4rg2iL1iL8LM8pZzAQSffGkRfsK6XSDnPQSffGkRfsK6XSDnPQSffGkRfsK6XSDnPQSffGkRfsK6XSDnPQSffGkRfsK6XSDnPQSffGkRfsK6XSDnPQSffGkRfsK6XSDnPQSffGkRfsK6XSDnPQSffGkRfsK6XSDnPQSffGkRfsK6XSDnPQSffGkRf3fq1vHZo6ziElZR//Mauqi7Ehr5gXVeRcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gXS+Rcp6DTr41iL5gpZd4hwB26xTgFqgWarwLEhLwHNaYXZ3XemV/AAtU5pcKtLq44hASZP2lTPiwDO+lrDp9fAWzEF2gWpPGuyAhQdY/65/jT8aAzYiIw9SzSRVp39hHGu+ChATMa0zm97Xw5VS8EF2gmrbxLkhIkPWXQuXxJ845Gx3z6IvKHl9r0HgXJCTI8ZfjL+efjAGbERHPM9Arc/61CiyUxHgXJCRg3Y256Oq/bVv93Wn9rWm8jvpFkmUDgq06j9HO7EJ0gWr6xrsgIQFzGZP5fS2s7kAL0QUq6y8VaHVxxSEkyPEnZcrzz7jm2OjAnPN2IbpAtRaNd0FCgt0ef/WCAP868U4vNZF15x9ojv9WF1ccQgKWzpj1cmpxvbKXe4Fqkca7ICFB5pdC+XFd62bVaVUcdgvRBao1arwLEhIwlzGZ39diKL64C9EFKuuPUrniEBKwmsYsVti9DF7Z6QUq65/118HlBgchQY4/GSZ5/Ilrjo2Ovr50IxcEyGmn3CcId0ZZEoKDrW2BYWO33vMKj6GRDzMyf9a/zljZlkfI+oRe0mtP2HuFxxbP8ZfzP9c/nQ/LMyTn39oJxVK9sLLMFV1S5/Ev199cf3P9nVcLrCNYNWArDwwL7Wy9wmMoc/3J9SfXn0vr+qN/VYqzE53T9pel1fdz3uOc/71a+flDfv6Sn7/k5y9tOVheIb8773/bWl4PRP0nX7CO4zHB1gcKDKtr2dLeKzyGNs//8vwvz/8ured/SzMaM1utV3gMVc7/nP85/3P+z6uFrRDfnfOfmm95hcr8eIffT9NZp6V64XVT6xUeQxXXf3eHgC5uxjf0fO3Ex9Dp7lu2FhB+rwj9NgFVlo8Uwe4ndUq2FpD5daJpeXplmmGVsv5hXNZK+dpo5S7Inq0F5PjL8YcFnuOqDRCOEhtvpAguyLCjlq0F5PjL8ZfjD1Ojz4xmOEty/uF4x5IQoHAXyLK1gFx/cv3J9QfTp8+MZjhLcv3J9UfGgMwSDgmCNnD8X5XqSKozqmpkA2wWjtFN0uneojXjrsb6Vn/3sP7+JfbtIQ1pVGp5Mn8rVy+41cWQhLqT9e8DzZtam77l+MPM01mY80/qcRlff8KdXupzbfOBAFPjAlm2FpDn372krYK9Ms2wShLxfBX6WGt4gXZsLSDrn/W3Q5wfZxwlNt5IEVygcQcxWwvI8ZfjL8ffMDPaBOEsyfmH4x1LQoDCXSDL1gJy/bnkrT/ugoD4uvKFAz28gPVkPF5V41oANitXIMiZrC08tUMI0PlsJ4UQfgBl/qx/jj+dNzpX3IwBbDbnX64/uf7m8ccfY7FAeC7iSSFEHn/tBC7PP/L8I88/8vyjVkDXSrdiAjab5195/nXxnX/pHQJ0LcYXZG1W1sUpEDpXNSZ6GZt1eOoRTRG8ytVR67d6/rTRFjw0bAwlU7qJoLSlzPxZ/xx/dU4M86hNk5x/uf5IBfz6XZddGSp1tNQt339ILXox6jpSZwyrA9hsnn/l+dfFd/7V5mKOv5x/uf7k+oujcx5/9FCcx1+pw6Xr/IMXBEwP259x1qPesE36EA8zwiITDaK+OR5OWzK/DCac/lsJgaZ6IdAs6grbg3Bh3UFs6i/rn/XP8RdmlXem+eKDnFecaBqFC0tdrn9TPXP9yfUn15+wqnhnmi8+yHWFC02uP7UCKAcsiVx/p/GU62+uv7n+hlXVO9N88UGuK1xoNAoXlrqtrz+4ICCkb05971gT6YZ3kvVLJUcjHG3XNLOJvg6Pukwsb7Fh9eqW+WsRWinWd710zcQyhjZZ/xx/Of/ClHBOnDjVq9ulaf0JFwTow+f+knL84QMKAAc42B6EC3sRHP9CWjpIAJv5WwVQDtisv5RFV4ZpPuX7n3z/k+9/uKKOYJovQYAFBrYH4cLm+iOFyfWnjo5pPOX6+7+y/m7b2CmVx9nyMG/bC1XDfWHkPO46b6bYQAxua9q4hYCn6klx5seigeXDV16xr5kV13RTXEKNWwh4Kuuf4y/nX86/upL4dcFWFkVTbCAGtzVq3ELAU7n+5PqT60+uP3XB8OuCrjq2n2IDMbitYeMWAp7K9SfXn1x/cv2pC4ZfF2zlUTTFBmJwW6PGLQQ8tav1B2OzdlhfpdoWwL4wZqRGF7f6N3T1Q5mw9WbN2A7dt+vV6+c22JgF7cRqnBFIJ5v5s/45/txkqjME80igfpGtBGaTzW+dTuDZToicf66QWqbF/SVx/alr/67WfzyZOnLq689tIAa3yRq3EPBU5s/zX5xj+HHBcdbBFBuIwc3xJxVoNVkojKdy/uX8y/mnRzY/L3L9iRWYajMQg5vrb66/i8cf3iFAh9c4bLzvcR+MC1Q/zGmyuq/vZMKZan0lhF+8+mrs0PseZ/5WgYWSZP21KNzn+Mv5l+tPXzCxbsrsyPU31mRxQfULrMeoo9hxbNmRT0LSJtefuUZ5/M/5l+tPrj9TBcY11vse5/rbKrBQkjz/16Jwvwccf/GB4eKXWjJQ2heHdcBILfi1cz1vqUXC5nyn0ugQqw19U+uCvYNqNvP3Umf9c/xh7rg5pZNE9n1S5fwb1hFXq1qbPWX92djYKc+1Pt+66RFNcd8vUNBpSPZ7wPEv1KTXKZ9/HTn5+uf4l/UDSwgmSn7+oifFqAetrhp0w5o7xkS1QIHUkOxz/c3xl/PPplRFuf5cYtefdkGAvwpNF7T6qvVR3FY2Lm81gEg49WqB5RWydyl9LH4IXMeHXQWW+Wut65b1b2XI8SdDIedfnQ/DzMj1p60SOjbaXMn119ZNLYiVpdYmjz++KsR5/M3zD3yplOdfw1GmLa+6xg6RPP7ICqJHZbzj1TpxYQFohZNdrr+oSLC5/ub6m+uvX0Pq9Mj3v22RaEuqrqttGbXK5PGn1UJr02qV73/c6NCKtH0bOLLL468risE8/ubxN4+/efzVFWE4yrbDS9u1o0vV+Erl+x+tjdUO1VGm7VtJZZfHH1cUg3n8yeNPHn+wbrTFQiZH99vy0na5/vYlw1fqoj7+6B0ChqK37x9rcmTuD2QzE17G4MytpnDml1q3Iuhb2qlAcw1HJjQJzqicPvJXIvNLofr02kX95ooONd1F+ylciax/1j/HX65/WArqIpPH31qF3drCmhqcufkUzvU3jz95/JWJkuc/XArqspHr77x4rjBhTQ3O3GAKs+g5/liKWrYcf/PgWWHCmArO3GAKs+g5/liKWrYcf/PgWWHCmArO3GAKs+g5/liKWrYcf/PgWWHCmArO3GAKs+g5/liKWrYcf/PgWWHCmArO3GAKs+g5/liKWrYcf/PgWWHCmArO3GAKs+g5/liKWrYcf/PgWWHCmArO3GAKs+g5/liKWrYcf/PgWWHCmArO3GAKs+hy/62dcnlSrHuL9l5c0077aBWpvxLEY5Hwhnzgqrf7sla1tWdV7jNUXDd5hCsplF4JauPWNvP7Svd6Zf1z/LlZqdMFY6N6Fdct51+uP2EYtFFRdzpa+pjxQ4cKFeX6m+tvHv9xpoWJkuc/flbokoHaVK/iuuXxJ48/YRi0UVF3Olr6mPFDhwoV5fHHzzQUKtcfXxUdMqhN9SquW64/uf6EYdBGRd3paOljxg8dKlSU64+faShUrj++KjpkUJvqVVy3XH9y/QnDoI2KutPR0seMHzpUqCjXHz/TUKhcf3xVdMigNtWruG65/uT6E4ZBGxV1p6Oljxk/dKhQUa4/fqahULn++KrokEFtqldx3XL9yfUnDIM2KupOR0sfM37oUKGiXH/8TEOh5vVH7hCwU6LuyhSZe+OG5iO/u35oX526MY9G2z4IVVb3K7QJdoFC++rULfNrHfyUCoXqYTErtAl2gUL7rL9WK8dfHzU6Oto+DBQbVCu0CXaBQvvq1C3rr3XI+d8GQxsjYaD08ohZoU2wCxTaV6duOf60Djn+2mBoYyQMlF4eMSu0CXaBQvvq1C3Hn9Yhx18bDG2MhIHSyyNmhTbBLlBoX5265fjTOuT4a4OhjZEwUHp5xKzQJtgFCu2rU7ccf1qHHH9tMLQxEgZKL4+YFdoEu0ChfXXqluNP65Djrw2GNkbCQOnlEbNCm2AXKLSvTt1y/Gkdcvy1wdDGSBgovTxiVmgT7AKF9tWpW44/rUOOvzYY2hgJA6WXR8wKbYJdoNC+OnXL8ad1yPHXBkMbI2Gg9PKIWaFNsAsU2lenbjn+tA45/tpgaGMkDJReHjErtAl2gUL76tQtx5/WIcdfGwxtjMhOfzKgliaMml4rmI2qlBEkpt5OgGMJ8U2sdTtfjRCamTDQzcn8Wf8cfzn/cv3J9TePP3n8nc8QVhk7rcjzD3+N6FQwK9QUKnn+ledfef6V5195/pXnX3n+ledf8xnCKmOnFXn+ledfdo+wacDYQJlCef4pxcnzrzz/yvOvPP/K8688/5qPkKuMHVbz/CvPv/L8a/W7a5so81zagz7/XPjJgF6PVoSKl0u4Wf3axQUo62Lz3lrM6gUGmb+XfrGAm16/kfXH4Fsbvjn+2uDK+ZfrjywviytMrr+5/raBsTg68vizdmiph556eMG2WL48/uTxRwZGHn/z+CvDYHmJkMHRAovRXH9lfV2ujARy/cXRZ6VIefxphcn1N9dfWUQW15F8/9MLs1idPP7k8Wd53tQjTx5/8/iLCiwuH3n+kecfMjDy/CvPv2QYLC8RMjhaYDGa5x+yvi5XJo+/ef6Bg+/aIFk//vInA1oXXee6GyaeddRG44Je22oAYVj2GwjnOAhtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy7qILSR6h5IWIhpNYAw7BDuros6CG2kugcSFmJaDSAMO4S766IOQhup7oGEhZhWAwjDDuHuuqiD0EaqeyBhIabVAMKwQ7i7LuogtJHqHkhYiGk1gDDsEO6uizoIbaS6BxIWYloNIAw7hLvrog5CG6nugYSFmFYDCMMO4e66qIPQRqp7IGEhptUAwrBDuLsu6iC0keoeSFiIaTWAMOwQ7q6LOghtpLoHEhZiWg0gDDuEu+uiDkIbqe6BhIWYVgMIww7h7rqog9BGqnsgYSGm1QDCsEO4uy4q0O4QAB6WrWegknXhHBkZ84kAYOe0ZFSyLpwjI2M+EQAss81AJevCOTIy5hMBwM5pyahkXThHRsZ8IgBYZpuBStaFc2RkzCcCgJ3TklHJunCOjIz5RACwzDYDlawL58jImE8EADunJaOSdeEcGRnziQBgmW0GKlkXzpGRMZ8IAHZOS0Yl68I5MjLmEwHAMtsMVLIunCMjYz4RAOycloxK1oVzZGTMJwKAZbYZqGRdOEdGxnwiANg5LRmVrAvnyMiYTwQAy2wzUMm6cI6MjPlEALBzWjIqWRfOkZExnwgAltlmoJJ14RwZGfOJAGDntGRUsi6cIyNjPhEALLPNQCXrwjkyMuYTAcDOacmoZF04R0bGfCIAWGabgUrWhXNkZMwnAoCd05JRybpwjoyM+UQAsMw2A5WsC+fIyJhPBAA7pyWjknXhHBkZ84kAYJltBipZF86RkTGfCAB2TktGJevCOTIy5hMBwDLbDFSyLpwjI2M+EQDsnJaMStaFc2RkzCcCgGW2GahkXThHRsZ8IgDYOS0ZlawL58jImE8EAMtsM1DJunCOjIz5RACwc1oyKlkXzpGRMZ8IAJbZZqCSdeEcGRnziQBg57RkVLIunCMjYz4RACyzzUAl68I5MjLmEwHAzmnJqGRdOEdGxnwiAFhmm4FK1oVzZGTMJwKAndOSUcm6cI6MjPlEALDMNgOVrAvnyMiYTwQAO6clo5J14RwZGfOJAGCZbQYqWRfOkZExnwgAdk5LRiXrwjkyMuYTAcAy2wxUsi6cIyNjPhEA7JyWjErWhXNkZMwnAoBlthmoZF04R0bGfCIA2DktGZWsC+fIyJhPBADLbDNQybpwjoyM+UQAsHNaMipZF86RkTGfCACW2WagknXhHBkZ84kAYOe0ZFSyLpwjI2M+EQAss81AJevCOTIy5hMBwM5pyahkXThHRsZ8IgBYZpuBStaFc2RkzCcCgJ3TklHJunCOjIz5RACwzDYDlawL58jImE8EADunJaOSdeEcGRnziQBgmW0GKlkXzpGRMZ8IAHZOS0Yl68I5MjLmEwHAMtsMVLIunCMjYz4RAOycloxK1oVzZGTMJwKAZbYZqGRdOEdGxnwiANg5LRmVrAvnyMiYTwQAy2wzUMm6cI6MjPlEALBzWjIqWRfOkZExn6gDuUNAvTea3yABXW9MIRj39kdYWXfbCgRgfZ+GGW2Angl4T4Iaq1vmz/rLWMjxx6mASRdnDzxYnT3jntEG6DkZuGrrlvMv55+MhZx/nAo5/3RlwEoRvchqzPaMNkDPBHn8l1r0NbdVJdffXH9lnuT6a9OiTgnZ4uoBD1Y1457RBug5Gbhq65bzL+efjIWcf5wKef6jKwNWiuhFVmO2Z7QBeibgqlZjdcv1J9cfGQu5/nAq5PqjK0NcPeDBqmbcM9oAPScDV23dcv3J9UfGQq4/nAq5/ujKgJUiepHVmO0ZbYCeCfL8R2rR19xWlVx/c/2VeZLrr02LOiVki6sHPFjVjHtGG6DnZOCqrdueNf+2beyUCwK2oQhagqX9sgIsbGxZrzXYtk0LKgjH0TC/9VVdbu97W1aAhfUtJE3mz/rn+JNJsSH/5fzrx5Fcf2S5xPlFrr8yPfL4V4sQD56Dt3KE7e1Wonn8zeNvHn9ljuTxN88/8vyLR5g8/8jzLxkMbTy0U4fl8wd/CrKsAAvrW8iqm+cfef6R5x95/pHnX/n5T37+Ze/w5XCZn//k+Ueef7VDY37+l59/ykDgu9P4JqJ7K+8weruVaL7/yPcfl7L3H+0OAWE40yFYnCCehFLGvwyA+kZcLTUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCEKYDkEUL3hQIi8spRCQiCCE6RBE8YIHJfLCUgoBiQhCmA5BFC94UCIvLKUQkIgghOkQRPGCByXywlIKAYkIQpgOQRQveFAiLyylEJCIIITpEETxggcl8sJSCgGJCHx4+skADXpJ/fumev1M56ZssfPZs74akh2vTpzFMVePaw+9n8w/XG2xUMRA9boJ15Dssv51PC9vWi2rWVUFLsdfjr921dfy+JlZG0sNyS7nX86/XH/mmVKZsNZ2SeBy/c31N9ff5cmzyOrsqaGGZJfHnzz+5PFncbLk8UfKwvf6vUR5/HU1yfOPPP/I84/lxXORzfMPnG3k+ZdUIs8/8/xbTj7z/HNxsczzTylLnn/aMbOOEvU6l+efMkDWVo+lOWW1bEh2+flHrr9rI0hHi42ZPW3+DRcEuEIQErTZ5j2sTY3zgWlebhp0aqcjJMj8UgFfjay/HhtaTXxh3IhSuGnQqZ2OkKDpvJf1z/rXc5M2JvzAcCMqx1+twKbFcdVyOkKCpvNezr+cfzn/cv1pa4JfGNyKonDToFM7HSFBrj9SAV+NXH9z/c31N9fftib4hcGtqAo3DTq10xESNJ33cv3J9SfXn1x/2prgFwa3ouT6UyuwaXFctZyOkKDpvJfrb66/uf7m+tvWBL8wuBVF4aZBp3Y6QoJcf6QCvhq5/ub6m+tvrr9tTfALg1tRFW4adGr5YU/5nb2q5uabekwBgUY311DcFzJTN2QuhZ7ymAICjW6uoTjzSyn8lXetbgvF85THVkkgjW6ugRYHMlM3ZC6FnvKYAgKNbq6hOF9/KUW+/jZaGjKXA8VTHlNAoNHNNRTn+JNS5Piz0dKQuRwonvKYAgKNbq6hOMeflCLHn42WhszlQPGUxxQQaHRzDcU5/qQUOf5stDRkLgeKpzymgECjm2sozvEnpcjxZ6OlIXM5UDzlMQUEGt1cQ3GOPylFjj8bLQ2Zy4HiKY8pINDo5hqKc/xJKXL82WhpyFwOFE95TAGBRjfXUJzjT0qR489GS0PmcqB4ymMKCDS6uYbiHH9Sihx/NloaMpcDxVMeU0Cg0c01FOf4k1Lk+LPR0pC5HCie8pgCAo1urqE4x5+UIsefjZaGzOVA8ZTHFBBodHMNxTn+pBSXhvHHCwLWX9gNeTG3hSfTX115imut1vg6QBCDrZyx6vl95s/65/jziwmnkAE/YTadTTbTcv7VJRpbrAbYanP9yfUn159cf9wKQUjgF4y2Zvi1JQbRBlaj0fMtcv3J9SfXn1x/3ApBSOAXDMFrfJUhBqtNo6ccIjn/cv7l/HMzhJDATxjBa3yVIQarTaOnHCI5/3L+5fxzM4SQwE8YwWt8lSEGq02jpxwiOf9y/uX8czOEkMBPGMFrfJUhBqtNo6ccIjn/cv7l/HMzhJDATxjBa3yVIQarTaOnHCI5/3L+5fxzM4SQwE8YwWt8lSEGq02jpxwi3835JxcE7JTHYl+M8fEa8I8u4Pgk8MF1l4SgOP2HO3CbE+soCK1emV9K5F4XKxhRrFzWXydOL08oTo6/nH8yl+T/XH+kDGFZCRMl11+Wg4Dr7QiiItffXH/rG4c8/rQKhMkhTp7/5fEnj795/iFLQZ5/4CBRbVgonTvwvknHUZHnH3n+kecfef61tDjISpHnX3n+ledfef4lS0Gef/mTqXgWZadjA++bLC2x0jDPP/L8I88/liZHnn/k+ZfMjDz/uMSff/AOAe6TiDaj7fBmaDomrhwzRxq+Wr/3PUKlnGU15NUNxyYMjzR8tX7PJgKgUs6yGvLqhmMThkcavlq/ZxMBUClnWQ15dcOxCcMjDV+t37OJAKiUs6yGvLrh2IThkYav1u/ZRABUyllWQ17dcGzC8EjDV+v3bCIAKuUsqyGvbjg2YXik4av1ezYRAJVyltWQVzccmzA80vDV+j2bCIBKOctqyKsbjk0YHmn4av2eTQRApZxlNeTVDccmDI80fLV+zyYCoFLOshry6oZjE4ZHGr5av2cTAVApZ1kNeXXDsQnDIw1frd+ziQColLOshry64diE4ZGGr9bv2UQAVMpZVkNe3XBswvBIw1fr92wiACrlLKshr244NmF4pOGr9Xs2EQCVcpbVkFc3HJswPNLw1fo9mwiASjnLasirG45NGB5p+Gr9nk0EQKWcZTXk1Q3HJgyPNHy1fs8mAqBSzrIa8uqGYxOGRxq+Wr9nEwFQKWdZDXl1w7EJwyMNX63fs4kAqJSzrIa8uuHYhOGRhq/W79lEAFTKWVZDXt1wbMLwSMNX6/dsIgAq5SyrIa9uODZheKThq/V7NhEAlXKW1ZBXNxybMDzS8NX6PZsIgEo5y2rIqxuOTRgeafhq/Z5NBEClnGU15NUNxyYMjzR8tX7PJgKgUs6yGvLqhmMThkcavlq/ZxMBUClnWQ15dcOxCcMjDV+t37OJAKiUs6yGvLrh2IThkYav1u/ZRABUyllWQ17dcGzC8EjDV+v3bCIAKuUsqyGvbjg2YXik4av1ezYRAJVyltWQVzccmzA80vDV+j2bCIBKOctqyKsbjk0YHmn4av2eTQRApZxlNeTVDccmDI80fLV+zyYCoFLOshry6oZjE4ZHGr5av2cTAVApZ1kNeXXDsQnDIw1frd+ziQColLOshry64diE4ZGGr9bv2UQAVMpZVkNe3XBswvBIw1fr92wiACrlLKshr244NmF4pOGr9Xs2EQCVcpbVkFc3HJswPNLw1fo9mwiASjnLasirG45NGB5p+Gr9nk0EQKWcZTXk1Q3HJgyPNHy1fs8mAqBSzrIa8uqGYxOGRxq+Wr9nEwFQKWdZDXl1w7EJwyMNX63fs4kAqJSzrIa8uuHYhOGRhq/W79lEAFTKWVZDXt1wbMLwSMNX6/dsIgAq5SyrIa9uODZheKThq/V7NhEAlXKW1ZBXNxybMDzS8NX6PZsIgEo5y2rIqxuOTRgeafhq/Z5NBEClnGU15NUNxyYMjzR8tX7PJgKgUs6yGvLqhmMThkcavlq/ZxMBUClnWQ15dcOxCcMjDV+t37OJAKiUs6yGvLrh2IThkYav1u/ZRABUyllWQ17dcGzC8EjDV+v3bCIAKuUsqyGvbjg2YXik4av1ezYRAJVyltWQVzccmzA80vDV+j2bCIBKOctqyKsbjk0YHmn4av2eTQRApZxlNeTVDccmDI80fLV+zyYCoFLOshry6oZjE4ZHGr5av2cTAVApZ1kNeXXDsQnDIw1frd+ziQColLOshry64diE4ZGGr9bv2UQAVMpZVkNe3XBswvBIw1fr92wiACrlLKshr244NmF4pOGr9Xs2EQCVcpbVkFc3HJswPNLw1fo9mwhQvl0QgL+aDanRC6WuIxdrHTW/Xv4hYl4iVZMJ0a9Mrt7alvn1qs2sv7vG0o0lhW7vYjn+pBitHjn/cv2RFTbXX3eY+f/b+xYtuXIcx/H//3N5JZKAQD3SXfecnek6hdidIAggJJtJ8cqu7PQ8G6MgrSYiF/Tzx8+f+b+a8PPXz1/+bxzkjpFQ3kXz/WMUI+oRB2ibtVPz/PXz53zmKuPnr5+/fv76/uH7l+9fvn/VH1bljplQ3kXz/XMUI+rh+6f//mvcKuv45P1y9ob//NFrojfvqtIok+9fvn/5/uX7l+9f//L71+/xOh8Rg4lLlipK1OhQilYZK9QJal3J+bkNHBYlvH+MLi0Jy+f6c6yzPgTuvyiF1IN9s4HDooTPn8/fuDpoS7B9PH88f+payf4g8PyNUkg9eG42cFiU8Pz1/PX89fNnzIz2F6Bzhvj56+evn79xLPjIJPD9I0oh9diuHUwPixK+f/j+4fuH7x9jWvj+wZGZwPcv3798//L9a0wDXpkIfP+MUkg9tunJ9LAo4fun75++f/7/uH8e/2RAP3Z131MyTqwQATOf7/O17ojLB4SYTn1PRXViAviFCJj5fJ8v7591kCcSn01SOZgqrhqifvQS4CNCBMx8vs8XPu/9V52AELNS+p6K6sQE8AsRMPP5Pl+uf9bB/bf6BAgRFVoxFdWJCeAWImDm832+3H9ZB/ff6hMgRFRoxVRUJyaAW4iAmc/3+XL/ZR3cf6tPgBBRoRVTUZ2YAG4hAmY+3+fL/Zd1cP+tPgFCRIVWTEV1YgK4hQiY+XyfL/df1sH9t/oECBEVWjEV1YkJ4BYiYObzfb7cf1kH99/qEyBEVGjFVFQnJoBbiICZz/f5cv9lHdx/q0+AEFGhFVNRnZgAbiECZj7f58v9l3Vw/60+AUJEhVZMRXViAriFCJj5fJ8v91/Wwf23+gQIERVaMRXViQngFiJg5vN9vtx/WQf33+oTIERUaMVUVCcmgFuIgJnP9/ly/2Ud3H+rT4AQUaEVU1GdmABuIQJmPt/n65/cf/lPBuA3Ib/P+J3hZzmOhBJBONbbzl9zkBV7kE1qWe8/uivbC5VbX4hV+kA0oHYjrs6s2sLUCw/2WNv1d/3df/148bDUOUPY+WsOsmIPnn8oD2s6CPef+29UgK1BgCapuPPXHGTFHmQTrDkM7r8oBiq3vhCuf6sAC4TeGdH3r1WiqA+KVLEHnz+UB1Xz/dvz18+fOA08GgQ4JBV3/pqDrNiD5w/Kg9J6/nj+eP54/owKcDQQYEhU3PlrDrJiD7IJ1hwG918UA5VbXwjXv1WABULvjOg/f60SRX1QpIo9+PyhPKia7z+ev37+xGng0SDAIam489ccZMUePH9QHpT2/2D+rJ8QIJvj1zMjfo2IqgEvbSFoiKEcshDen8MXNZsRFUJUDXhpC0FDDOWQhXD9Xf96+KFnZkSHIKoGvLSFoCGGcshCuP/cf+4/HBdGnBBECgKWtpDIAUM5ZCF8/nz+fP72Y+Pn36jI/Hs1mRTPGv3k8vwZdTyKKITnr+ev5+9ztshJeXo8f95VCuWQhfD88fzx/HnOFjkpT4/nz7tKoRyyEJ4/nj+eP8/ZIifl6fH8eVcplEMWwvPH88fz5zlb5KQ8PZ4/7yqFcshC/JfMn/UNAfplll9n0HtO7ymcDM0LDNPv8bdj9S/tLB5oX2TP4bv8NeXTys8M4P1df/efz1/7FmIZEPsQ2XNaT+FkaF5gmDz/PP/9/NNv4V/H43isPw/VKZyMrAvo8+f54+e/n/9+/mMi9rgP0T2n+xROhuYFhsn3H99/fP/x/WcNBUH7ENlzWk/hZGheYJg8fzx/PH88f9ZQELQPkT2n9RROhuYFhsnzx/PH88fzZw0FQfsQ2XNaT+FkaF5gmDx/PH88fzx/1lBI1L8hIAbF+EYhuB7ftQBZ/+I+B9E2jpBGnG9jEM2/hiwesq73e2zu/asirv/1u9a0X9As2UtbRyGNON/cfz5/nj+ev2MQjIcMxkMMhhwO46Ls54+fv9URfv76+Xv5rnGdF75/ZDVylm4TFWnE+eb7l+9fvn/5/jUGge9fvn9mG8zHQr7GI8L3b//5w3/+wHkYB8L3T0yHM8a9kqNjPFKEmDTSiPPN90/fP33/9P1zDALfPzkeYzDmcPT9a/SF7x/VEf77z3/d/Su/IQAXJ06GdZdKSgwCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLUVbplGQCxf4NYi1EWaVTkgkU+zeItRBllU5JJlDs3yDWQpRVOiWZQLF/g1gLcazSf0IAlxUHuAsVUvAiEhLwO5EWs3/DATZBVGdxF8r7jwpEXaQ4hASu/yjT/K6vVZGOo4/amzpLuFChBC8iIQH3XYz311q00q+idvr1geBFJCRw/Ucl3f/9zK3u6G2W2UW9UOENXkRCAvef+8/nb/TAOhEd55nTd3UWf6FCCV5EQgLuuxjvr7XQyie+qBfK9R8ViLpIcQgJ3H+jTL5/9JmzuiNPXH+/qBcqPhO8iIQE7j/3n8/f6IF1IjruZ29m6iz1QoUSvIiEBFxtMdcdaqMZ1Fn0hQoleBEJCbjaYq471EYzqLPoCxVK8CISEnC1xVx3qI1mUGfRFyqU4EUkJOBqi7nuUBvNoM6iL1QowYtISMDVFnPdoTaaQZ1FX6hQgheRkICrLea6Q200gzqLvlChBC8iIQFXW8x1h9poBnUWfaFCCV5EQgKutpjrDrXRDOos+kKFEryIhARcbTHXHWqjGdRZ9IUKJXgRCQm42mKuO9RGM6iz6AsVSvAiEhJwtcVcd6iNZlBn0RcqlOBFJCTgaou57lAbzaDOoi9UKMGLSEjA1RZz3aE2mkGdRV+oUIIXkZCAqy3mukNtNIM6i75QoQQvIiEBV1vMdYfaaAZ1Fn2hQgleREICrraY6w610QzqLPpChRK8iIQEXG0x1x1qoxnUWfSFCiV4EQkJuNpirjvURjOos+gLFUrwIhIScLXFXHeojWZQZ9EXKpTgRSQk4GqLue5QG82gzqIvVCjBi0hIwNUWc92hNppBnUVfqFCCF5GQgKst5rpDbTSDOou+UKEELyIhAVdbzHWH2mgGdRZ9oUIJXkRCAq62mOsOtdEM6iz6QoUSvIiEBFxtMdcdaqMZ1Fn0hQoleBEJCbjaYq47xHLjGwL++v17/Jw2/GQq/VD9Un5c8ObH5zKqQzFcv//H+7v+7r/ztKwT8v4L1duJwufOFW9unz/PH88fz59zWmCOYGogTh4YEd4zqkMxnJ4/nj+eP54/OQ/uE8L3n9d/UL/VC5P1rOjN7fnr+ev56/l7TgvMEUwNxMkDI8J7RnUohtPzx/PH88fzJ+fBfUL4/uf733rmzE5BnyDiaXJGdSiG088fP3/8/PHzJ+fBfUL4+ePnz3rmzE5BnyDiaXJGdSiG87/r+SM/IaB+sRH0F678/E2oht/Ufx756QHavxeHdcNA19qPFMF/vqk4+ekBvH8OuixPVSYCq+T6t76cldLaZOX+zjs/PYD7z/03H7T5qs6IwC4ZkvLTqVp+8u+889MDuP/cf+4/nB49Zzwl67yRIsAH/1bkpwfw+fP58/nD8amTEYGnxOcPz3uWhACF+1uRnx7A88fzx/MHx6dORgSeEs8fz5/RA+OUsCUI0Dh/K/LTA3j+ev56/uL41MmIwFMyROWnVzV89j+P/PQAPn8+fz5/ODt6znhK1nkjRYAP/q3ITw/g8+fz5/OH41MnIwJPic8fnvcsCQEK97ciPz2A5885f+QbAnpdWTjQWwF/j7x/V5F8AjDi+A6I8QeqdfDngjBg8TMejkHoF9D7u/7uvzw3eVbkxABG9Pnz/PH89fNHn7EYEMp1fDgG4efvukD5/uH7h+8fvn/MCuSslIkJGNH3L9+/fP/y/UvvVxgQynV8OAbh+5fvXzhHvn/6/un7Z87MnJUyMQEj+v7l+5fvX3hu6InpN46e4QiRHYTvH75/oI98//D9w/cPnaYyMQEj/rPuH/yGgOOXrSeeT4UFDv+SBmoVWcpBg5if2K4t3n9NnFVBoqNeVCZAXRFLRIpIn+t/1NP95/7DE6+drUyOfmkeHDBEn7+oAMqB6PkzypJX7KOfPH88fzx/2lTV5DgvKnKucNCkihSRPt9/jnp6/nj+eP60qaLJcV5U5FzhoPH8mRVAORBJeP4e/eT56/nr+dumqibHeVGRc4WDJlWkiPR5/hz19Pzx/PH8aVNFk+O8qMi5wkHj+TMrgHIgkvD8PfrJ89fz1/O3TVVNjvOiIucKB02qSBHp8/xBPX/9/mtMHnzbTxWV9Rr57ylXYyrf6j994//aMhuxpfHx4C6CUt7f9Xf/4T8abmdMDqGemXW4luHQhxTcRVDK58/nz+fP529OEp0La7IkOrSN2NL4UHAXQSnPH88fzx/PnzkwdC7k1Fnvh7YRWxofDO4iKOX54/nj+eP5MweGzoU1eRId2kZsaXwouIuglOeP54/nj+fPHBg6F3LqrPdD24gtjQ8GdxGU8vzx/PH88fyZA0Pnwpo8iQ5tI7Y0PhTcRVDK88fzx/PH82cODJ0LOXXW+6FtxJbGB4O7CEr92+YPf0JAllZLMRnNFae7yUXhM+ke7/pzZuB5fvfTvofmir1/VOBSEtc/i8J399/5XQQ+f4/vPtwPlOaKPX88f0YFLi0BMqXx7vnj+ZP3+Roas29GX1y/+3dvKM0V11IXyv2XReG7z5/Pn8/fmj0Tef54/vr5089EZPsDVXPF9dEL5edvFoXvfv76+evnb581fv76+evnbz8Tfv6OCuwXCs0VV+kuFNZIabz7+evnr5+/fdb4+evnr5+//UxENr75aHwHxHzxpwDkA2WqNUXiycLHS3wM82WxnQmTvk3jfNhdvwhD8f6uP3sjmmX0i/svjlAcsniL6+Lk+mlLLbzHhTLZ/ODwscbFQ/b58/ljb8x+mi+fvyhDHK88Y1tl6rSlFl6fv9U3WZBVllkb9piKfv77/uP7J74L3vfvbcrGeM0ZuymevzFtszZr0OJ2KDM2CjfePH+lKAt6/nr+ev5ibmxTNsZLvMW8nadGnb/anTd962QViiXHm+fPUZpJeP54/nj+6FSZp6LyGCk5V2KMLMX3v6hF1mZWLP/sgDomQ3pWy/NXirKg56/nr+cv5sY2ZWO85IzZFM/fMUJ8/83eyGmqeM3XaBQ/f/4Rz9/8CQHxdcwvJuH8emJGyNf2Befn5is+0pLk9f2QuWkdr8Ogn77j9pGWnP5DnsSveMshdxjONXamfaQlu/P4K9+6x3n/2T1RhT/U76zoVtM/fP6Quan3ZylmkX3+b6125VpPteS0HzKL7v5jKWbZ3H9n8zyY1lMtOT9wyCy6+4+lmGVz/53N82BaT7Xk/MAhs+juP5Zils39dzbPg2k91ZLzA4fMorv/WIpZNvff2TwPpvVUS84PHDKL7v5jKWbZ3H9n8zyY1lMtOT9wyCy6+4+lmGVz/53N82BaT7Xk/MAhs+juP5Zils39dzbPg2k91ZLzA4fMorv/WIpZNvff2TwPpvVUS84PHDKL7v5jKWbZ3H9n8zyY1lMtOT9wyCy6+4+lmGVz/53N82BaT7Xk/MAhs+juP5Zilu3/oP9+/TW+Pa7vG7+k+irKl65oVacp84dYq0zT7/Ef3H/xd4hVfg9psWmHhtVnHL/CxxZJP8RcMD7r/bXSqLHrr1XJdkFtZjbxfLn/fP5aG0RXzLfsluoZbR060uT5oycNhfL80apky6A2M5t4vjx/PH9aG0RXzLfsluoZbR060uT5oycNhfL80apky6A2M5t4vjx/PH9aG0RXzLfsluoZbR060uT5oycNhfL80apky6A2M5t4vjx/PH9aG0RXzLfsluoZbR060uT5oycNhfL80apky6A2M5t4vjx/PH9aG0RXzLfsluoZbR060uT5oycNhfL80apky6A2M5t4vjx/PH9aG0RXzLfsluoZbR060uT5oycNhfL80apky6A2M5t4vjx//i3zZ/yEgL/GV12+M2N87feXtsiu/Sd5+7z0WH421XhvxrXyg16GP6D2+ZnMF3+fqcZ7M6Ztvj/oZfgDap+fyXx5/6yDPtJaoUoe4UEvwx9Q+7zrn9Vy/1XXZHfEe2uU1VQPehn+gNrnZzJfrn/Wwec/miF6pDVKlWeEB70Mf0Dt8zOZL/df1sH9F80QPdIapcozwoNehj+g9vmZzJf7L+vg/otmiB5pjVLlGeFBL8MfUPv8TObL/Zd1cP9FM0SPtEap8ozwoJfhD6h9fibz5f7LOrj/ohmiR1qjVHlGeNDL8AfUPj+T+XL/ZR3cf9EM0SOtUao8IzzoZfgDap+fyXy5/7IO7r9ohuiR1ihVnhEe9DL8AbXPz2S+3EVJ/8kAABOESURBVH9ZB/dfNEP0SGuUKs8ID3oZ/oDa52cyX+6/rIP7L5oheqQ1SpVnhAe9DH9A7fMzmS/3X9bB/RfNED3SGqXKM8KDXoY/oPb5mcyX+y/r8F/Wf/lPBsxfWvuq1a8VYfwb4/HvD40wf5wAv5bQf4hr2dt348gHl1HIgt7f9Z///pX7z+fP88fz93xCPJn1WPHz5/xuUCnbKpSQBf389fPXz1/fP3z/8v3L9y/fv84bwpNZ1wrfv3z/2n8apLTNahQhC/r+6fun75++f/r+6fun75++f543hCezrhW+f/r+6fvnGJ/31zoop+7797/m/n35JwOqH6IJJr630E/9E99cgLa6frw+PcLzGwy8f5X+WsAfv3/D9UfzvdrX/RfN5fPn+TPGy3XCeP56/kZjXLvDz5/Xo2U+eubjBa9r+fz88fNnNIafv37+jja4j4jRHCFcVc/fMV/vlRmC5y+ePo8i+fkThfH89fwdQ+Q6R/znnyrMtTp+/vj5cz8388nj56+fv6jAdXz4/uH7x2gM3798/xptcB8RozlCuKq+f4z5eq+Mn7++f+Dh+2qS9/OX/2RALFE+WW47eGuh6MaLPz+bAmRErtsISQTC26nKQCLCzJgCZMRNrlRUgfB2qjKQiDAzpgAZcZMrFVUgvJ2qDCQizIwpQEbc5EpFFQhvpyoDiQgzYwqQETe5UlEFwtupykAiwsyYAmTETa5UVIHwdqoykIgwM6YAGXGTKxVVILydqgwkIsyMKUBG3ORKRRUIb6cqA4kIM2MKkBE3uVJRBcLbqcpAIsLMmAJkxE2uVFSB8HaqMpCIMDOmABlxkysVVSC8naoMJCLMjClARtzkSkUVCG+nKgOJCDNjCpARN7lSUQXC26nKQCLCzJgCZMRNrlRUgfB2qjKQiDAzpgAZcZMrFVUgvJ2qDCQizIwpQEbc5EpFFQhvpyoDiQgzYwqQETe5UlEFwtupykAiwsyYAmTETa5UVIHwdqoykIgwM6YAGXGTKxVVILydqgwkIsyMKUBG3ORKRRUIb6cqA4kIM2MKkBE3uVJRBcLbqcpAIsLMmAJkxE2uVFSB8HaqMpCIMDOmABlxkysVVSC8naoMJCLMjClARtzkSkUVCG+nKgOJCDNjCpARN7lSUQXC26nKQCLCzJgCZMRNrlRUgfB2qjKQiDAzpgAZcZMrFVUgvJ2qDCQizIwpQEbc5EpFFQhvpyoDiQgzYwqQETe5UlEFwtupykAiwsyYAmTETa5UVIHwdqoykIgwM6YAGXGTKxVVILydqgwkIsyMKUBG3ORKRRUIb6cqA4kIM2MKkBE3uVJRBcLbqcpAIsLMmAJkxE2uVFSB8HaqMpCIMDOmABlxkysVVSC8naoMJCLMjClARtzkSkUVCG+nKgOJCDNjCpARN7lSUQXC26nKQCLCzJgCZMRNrlRUgfB2qjKQiDAzpgAZcZMrFVUgvJ2qDCQizIwpQEbc5EpFFQhvpyoDiQgzYwqQETe5UlEFwtupykAiwsyYAmTETa5UVIHwdqoykIgwM6YAGXGTKxVVILydqgwkIsyMKUBG3ORKRRUIb6cqA4kIM2MKkBE3uVJRBcLbqcpAIsLMmAJkxE2uVFSB8HaqMpCIMDOmABlxkysVVSC8naoMJCLMjClARtzkSkUVCG+nKgOJCDNjCpARN7lSUQXC26nKQCLCzJgCZMRNrlRUgfB2qjKQiDAzpgAZcZMrFVUgvJ2qDCQizIwpQEbc5EpFFQhvpyoDiQgzYwqQETe5UlEFwtupykAiwsyYAmTETa5UVIHwdqoykIgwM6YAGXGTKxVVILydqgwkIsyMKUBG3ORKRRUIb6cqA4kIM2MKkBE3uVJRBcLbqcpAIsLMmAJkxE2uVFSB8HaqMpCIMDOmABlxkysVVSC8naoMJCLMjClARtzkSkUVCG+nKgOJCDNjCpARN7lSUQXC26nKQCLCzJgCZMRNrlRUgfB2qjKQiDAzpgAZcZMrFVUgvJ2qDCQizIwpQEbc5EpFHXD9hADwiPz0CdLyNp7KzqycCADx3JZMWt7GU9mZlRMBIHK3E6TlbTyVnVk5EQDiuS2ZtLyNp7IzKycCQORuJ0jL23gqO7NyIgDEc1syaXkbT2VnVk4EgMjdTpCWt/FUdmblRACI57Zk0vI2nsrOrJwIAJG7nSAtb+Op7MzKiQAQz23JpOVtPJWdWTkRACJ3O0Fa3sZT2ZmVEwEgntuSScvbeCo7s3IiAETudoK0vI2nsjMrJwJAPLclk5a38VR2ZuVEAIjc7QRpeRtPZWdWTgSAeG5LJi1v46nszMqJABC52wnS8jaeys6snAgA8dyWTFrexlPZmZUTASBytxOk5W08lZ1ZOREA4rktmbS8jaeyMysnAkDkbidIy9t4KjuzciIAxHNbMml5G09lZ1ZOBIDI3U6QlrfxVHZm5UQAiOe2ZNLyNp7KzqycCACRu50gLW/jqezMyokAEM9tyaTlbTyVnVk5EQAidztBWt7GU9mZlRMBIJ7bkknL23gqO7NyIgBE7naCtLyNp7IzKycCQDy3JZOWt/FUdmblRACI3O0EaXkbT2VnVk4EgHhuSyYtb+Op7MzKiQAQudsJ0vI2nsrOrJwIAPHclkxa3sZT2ZmVEwEgcrcTpOVtPJWdWTkRAOK5LZm0vI2nsjMrJwJA5G4nSMvbeCo7s3IiAMRzWzJpeRtPZWdWTgSAyN1OkJa38VR2ZuVEAIjntmTS8jaeys6snAgAkbudIC1v46nszMqJABDPbcmk5W08lZ1ZOREAInc7QVrexlPZmZUTASCe25JJy9t4KjuzciIARO52grS8jaeyMysnAkA8tyWTlrfxVHZm5UQAiNztBGl5G09lZ1ZOBIB4bksmLW/jqezMyokAELnbCdLyNp7KzqycCADx3JZMWt7GU9mZlRMBIHK3E6TlbTyVnVk5EQDiuS2ZtLyNp7IzKycCQORuJ0jL23gqO7NyIgDEc1syaXkbT2VnVk4EgMjdTpCWt/FUdmblRACI57Zk0vI2nsrOrJwIAJG7nSAtb+Op7MzKiQAQz23JpOVtPJWdWTkRACJ3O0Fa3sZT2ZmVEwEgntuSScvbeCo7s3IiAETudoK0vI2nsjMrJwJAPLclk5a38VR2ZuVEAIjc7QRpeRtPZWdWTgSAeG5LJi1v46nszMqJCoyfEDB/Npq+YAE9fzDFwPjZ/pCTlR9bAQFR11yYagBmy8CfSTC1+fL+rv/oBfcfjwIOXT89yBDz9OzvVAMwExu4GefL58/nb/SCzx+Pgs9fTgZMip51NrX1TjUAs2Xw83/UomZuVMXz1/N3nBPP33Us5pEYrz49kCGmZ3+nGoCZ2MDNOF8+fz5/oxd8/ngUfP/JyYBJ0bPOprbeqQZgtgycalObL88fz5/RC54/PAqePzkZ+vRAhpie/Z1qAGZiAzfjfHn+eP6MXvD84VHw/MnJgEnRs86mtt6pBmC2DL7/jFrUzI2qeP56/o5z4vm7jsU8EuPVpwcyxPTs71QDMBMbuBnn6991/n79/mt8Q8AvFCFLcHu/O8Ai9k/O7zX49SsLOhCeo+1851f1/nld7e4Ai6ifGNt4f9ff/TcOxe/x/3z+6jni+TPGJe4Xnr/jePj5N4vQH55b9njC1uceqp+/fv76+TvOiJ+/vn/4/sUnjO8fvn+NZoh+iKvD/f6gV5C7AyyifmJMXd8/fP/w/cP3D9+//Pc//vuv9Sf88bj03//4/uH7Vzwa/fd//vvP0Qj802n/Q0Rljz9h1Oceqv/84T9//MP+/BE/IaC1MxOC6wFREs7R/6MB5h/EM9IDA4kOmsyEoJsvGZzYF5FWGEh00GQmBN18yeDEvoi0wkCigyYzIejmSwYn9kWkFQYSHTSZCUE3XzI4sS8irTCQ6KDJTAi6+ZLBiX0RaYWBRAdNZkLQzZcMTuyLSCsMJDpoMhOCbr5kcGJfRFphINFBk5kQdPMlgxP7ItIKA4kOmsyEoJsvGZzYF5FWGEh00GQmBN18yeDEvoi0wkCigyYzIejmSwYn9kWkFQYSHTSZCUE3XzI4sS8irTCQ6KDJTAi6+ZLBiX0RaYWBRAdNZkLQzZcMTuyLSCsMJDpoMhOCbr5kcGJfRFphINFBk5kQdPMlgxP7ItIKA4kOmsyEoJsvGZzYF5FWGEh00GQmBN18yeDEvoi0wkCigyYzIejmSwYn9kWkFQYSHTSZCUE3XzI4sS8irTCQ6KDJTAi6+ZLBiX0RaYWBRAdNZkLQzZcMTuyLSCsMJDpoMhOCbr5kcGJfRFphINFBk5kQdPMlgxP7ItIKA4kOmsyEoJsvGZzYF5FWGEh00GQmBN18yeDEvoi0wkCigyYzIejmSwYn9kWkFQYSHTSZCUE3XzI4sS8irTCQ6KDJTAi6+ZLBiX0RaYWBRAdNZkLQzZcMTuyLSCsMJDpoMhOCbr5kcGJfRFphINFBk5kQdPMlgxP7ItIKA4kOmsyEoJsvGZzYF5FWGEh00GQmBN18yeDEvoi0wkCigyYzIejmSwYn9kWkFQYSHTSZCUE3XzI4sS8irTCQ6KDJTAi6+ZLBiX0RaYWBRAdNZkLQzZcMTuyLSCsMJDpoMhOCbr5kcGJfRFphINFBk5kQdPMlgxP7ItIKA4kOmsyEoJsvGZzYF5FWGEh00GQmBN18yeDEvoi0wkCigyYzIejmSwYn9kWkFQYSHTSZCUE3XzI4sS8irTCQ6KDJTAi6+ZLBiX0RaYWBRAdNZkLQzZcMTuyLSCsMJDpoMhOCbr5kcGJfRFphINFBk5kQdPMlgxP7ItIKA4kOmsyEoJsvGZzYF5FWGEh00GQmBN18yeDEvoi0wkCigyYzIejmSwYn9kWkFQYSHTSZCUE3XzI4sS8irTCQ6KDJTAi6+ZLBiX0RaYWBRAdNZkLQzZcMTuyLSCsMJDpoMhOCbr5kcGJfRFphINFBk5kQdPMlgxP7ItIKA4kOmsyEoJsvGZzYF5FWGEh00GQmBN18yeDEvoi0wkCigyYzIejmSwYn9kWkFQYSHTSZCUE3XzI4sS8irTCQ6KDJTAi6+ZLBiX0RaYWBRAdNZkLQzZcMTuyLSCsMJDpoMhOCbr5kcGJfRFphINGBysc/GZCiWub/vml+/0xxx2598TNbawUab/zuxNPc9yo9V6h1vP/23RaXIjaq6ja4QOPN9Z/9fH9ltVbNpqtx7j/3X3zX171/Tnb1UqDx5vPn8+f5c56UybRZW5bGef56/nr+3g/Plc3TM6VA483PHz9//Py5HhY/f0ZZ+Gf9KpGfv1IT3z98//D94z48r6zvH7ht+P41KuH7p+/f4/Lp++d1WPr+Ocri++d6Zs4uyaw43z9Hg7ymx+1MrVoGGm/++w/P31cHZbesnvm3nb/tGwKkEIQEcdo0w2wKToXjXP4oilt8hATef1RAq+H657MhaqKFkY5K+KMobvEREoRPM9ff9Z93k+gJbQzpKPffrMCPxZFqiY+QIHya+fz5/Pn8ef7ETNDBIBMl4Y+iuMVHSOD5Myqg1fD89fz1/PX8jZmgg0EmasIfRXGLj5AgfJp5/nj+eP54/sRM0MEgE8XzZ1bgx+JItcRHSBA+zTx/PX89fz1/YyboYJCJkvBHUdziIyTw/BkV0Gp4/nr+ev56/sZM0MEgEzXhj6K4xz/sOf6dvenmSz+qmAaCVH/20FyDbLkDrZRGpRTTQJDqzx6avf8ohX7nXdTtUjylFK9KAqX6swdePMiWO9BKaVRKMQ0Eqf7sodlf/1EKf/1XtwRaKRtFKcU0EKT6s4dm998ohftvdUuglbJRlFJMA0GqP3todv+NUrj/VrcEWikbRSnFNBCk+rOHZvffKIX7b3VLoJWyUZRSTANBqj97aHb/jVK4/1a3BFopG0UpxTQQpPqzh2b33yiF+291S6CVslGUUkwDQao/e2h2/41SuP9WtwRaKRtFKcU0EKT6s4dm998ohftvdUuglbJRlFJMA0GqP3todv+NUrj/VrcEWikbRSnFNBCk+rOHZvffKIX7b3VLoJWyUZRSTANBqj97aHb/jVK4/1a3BFopG0UpxTQQpPqzh2b33yjFP6H/+A0B7y/s7/HF/NV+M/XVHb/F16de/GwQaIiTW2xm+u79XX/3nw4THqEF9MD8eJrWSfP5myMar14NsDN6/nj+eP54/siEICTQgREzQ2dLF/EZxFR7pp/w/PH88fzx/JEJQUigA2PgFz9t0BDzoz1LDorPn8+fz5+cEEICPTADv/hpg4aYH+1ZclB8/nz+fP7khBAS6IEZ+MVPGzTE/GjPkoPi8+fz5/MnJ4SQQA/MwC9+2qAh5kd7lhwUnz+fP58/OSGEBHpgBn7x0wYNMT/as+Sg+Pz5/Pn8yQkhJNADM/CLnzZoiPnRniUH5X/z/I1vCPhr/FrWfxjjr3cB/dU13H8T+IvrsjRxJPUPd+DHnKyFmnHVy/uPEsnXZRWMqFfO9c+DU+VpxXH/+fyNszT+v+fPKEMbK+2geP6yHASctzvoDs9fz9/5Bwc/f6IC7XCMxPc/P3/8/PX9Y4wC3z/wkJixDUpJN14/Urg7fP/w/cP3D9+/bsNhTArfv3z/8v3L968xCnz/0stUv0Wt69jG60duI3Z80PcP3z98/7gdDt8/fP8aJ8P3j//6+8f/A9XBRA7voW4pAAAAAElFTkSuQmCC" + } + }, + "cell_type": "markdown", + "id": "2307b24a-7dbf-443f-a99a-39d2aa9e2257", + "metadata": {}, + "source": [ + "![image.png](attachment:62c02cd8-3279-4bb6-aa64-9b89246fdf95.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6a3aee07-d3ff-4d90-a321-556400fd5b0b", + "metadata": {}, + "outputs": [], + "source": [ + "from classiq.qmod.symbolic import logical_and\n", + "\n", + "\n", + "@qfunc\n", + "def short_time_summation(a: CReal, b: CReal, qbe: TimeDependentBE):\n", + " \"\"\"\n", + " Riemann summation\n", + " \"\"\"\n", + " within_apply(\n", + " lambda: hadamard_transform(qbe.time),\n", + " lambda: block_encode_time_dependent_A(a, b, qbe),\n", + " )\n", + "\n", + "\n", + "# We also define predicates for the usage later on in qsvt\n", + "def time_dependent_predicate(qbe: TimeDependentBE):\n", + " return logical_and(qbe.block == 0, qbe.time == 0)\n", + "\n", + "\n", + "@qfunc\n", + "def time_dependent_projector(qbe: TimeDependentBE, is_in_block: QBit):\n", + " is_in_block ^= time_dependent_predicate(qbe)" + ] + }, + { + "cell_type": "markdown", + "id": "d225e83e-948c-41e2-ba7c-d5638779a640", + "metadata": {}, + "source": [ + "#### 2. Block encoding of the summation Exponential" + ] + }, + { + "cell_type": "markdown", + "id": "f8698cc1-945c-4d12-9219-061c39195117", + "metadata": {}, + "source": [ + "Find polynomials for $\\cosh(ax)$ and $\\sinh(ax)$, In order to combine them to $e^{ax}$.\n", + "\n", + "For pedagogical reasons, we will do a naive thing and create a polynomial approximation for each one of the odd&even polynomials of: $P_{cosh} \\approx \\frac{\\cosh(ax)}{e^a}$ and $P_{sinh} \\approx \\frac{\\sinh(ax)}{e^a}$.\n", + "\n", + "Then combining them with LCU will result with:\n", + "$$P(x) \\approx \\frac{e^{ax}}{2e^a}$$ which is a polynomial that is bounded by $\\frac{1}{2}$.\n", + "\n", + "We could choose $P_{cosh} \\approx \\frac{\\cosh(ax)}{\\cosh(a)}$ and $P_{sinh} \\approx \\frac{\\sinh(ax)}{\\sinh{a}}$,\n", + "Then LCU with coeffiecients $[\\frac{\\cosh(a)}{\\cosh(a)+\\sinh(a)}, \\frac{\\sinh(a)}{\\cosh(a)+\\sinh(a)}]$, will get us to:\n", + "$$P(x) \\approx \\frac{e^{ax}}{e^a}$$\n", + "Which is the best we can get to, and doesn't require amplification. We will still go with the first approach, for demonstrating the singular value amplification. We will want to get rid of this redundant factor 2, which will save us a multiplicative factor of $O(2^T)$ in the success probability." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "14727fde-efb6-4d0d-8e80-25922b7fe465", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from numpy.polynomial.chebyshev import Chebyshev\n", + "from numpy.polynomial.polynomial import Polynomial\n", + "\n", + "\n", + "def get_cheb_approx(func, poly_degree):\n", + " cheb = Chebyshev.interpolate(func, poly_degree, domain=[-1, 1])\n", + " return cheb.convert(kind=Polynomial)\n", + "\n", + "\n", + "def get_sinh_poly(a: float, poly_degree: int):\n", + " normalization = np.abs(np.exp(a * 1))\n", + " return get_cheb_approx(lambda x: np.sinh(a * x) / normalization, poly_degree)\n", + "\n", + "\n", + "def get_cosh_poly(a: float, poly_degree: int):\n", + " normalization = np.abs(np.exp(a * 1))\n", + " return get_cheb_approx(lambda x: np.cosh(a * x) / normalization, poly_degree)\n", + "\n", + "\n", + "A = 2\n", + "DEGREE_EXP = 7\n", + "poly_sinh = get_sinh_poly(A, DEGREE_EXP)\n", + "poly_cosh = get_cosh_poly(A, DEGREE_EXP - 1)\n", + "x = np.linspace(-1, 1, 1000)\n", + "plt.plot(\n", + " x,\n", + " (0.5 * (poly_sinh + poly_cosh)(x)),\n", + " label=r\"$\\approx \\frac{\\sinh(ax)+\\cosh(ax)}{2e^a}$\",\n", + ")\n", + "plt.plot(x, np.exp(A * x) / (2 * np.exp(A)), label=r\"$\\frac {e^{ax}}{2e^a}$\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "id": "9391aa9e-1db9-45f1-ac34-8ea17ef092a9", + "metadata": {}, + "source": [ + "Then we transform the polynomials to qsvt phases using the `pyqsp` package:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e0a82b5c-569b-4e47-84d2-8b8fb1159ef6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAs4AAAHACAYAAACyDu7BAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABpbUlEQVR4nO3deVxU9f4/8New7/u+yCKICAiKgpAbSeaSS3q7ZpZLLmVppW3aola3rGzRsjK9LnmvZuo1lzI3XEpFQVCUfRdcBgQEBGSd8/vD35yvE6gHBGaA1/PxOA+ZM59z5n2OA7z4zOd8jkwQBAFERERERHRfWuougIiIiIioI2BwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgl01F2AplMoFLh27RpMTU0hk8nUXQ4RERER/Y0gCLh16xacnJygpdV2/cIMzg9w7do1uLq6qrsMIiIiInqA/Px8uLi4tNn+GZwfwNTUFMCd/wgzMzM1V0NEREREf1deXg5XV1cxt7UVBucHUA7PMDMzY3AmIiIi0mBtPayWFwcSEREREUnA4ExEREREJAGDMxERERGRBBzjTERERK1CEATU19ejoaFB3aVQJ6OtrQ0dHR21Tw3M4ExEREQPrba2FtevX0dVVZW6S6FOysjICI6OjtDT01NbDQzORERE9FAUCgVycnKgra0NJycn6Onpqb1nkDoPQRBQW1uLGzduICcnB97e3m16k5P7YXAmIiKih1JbWwuFQgFXV1cYGRmpuxzqhAwNDaGrq4vLly+jtrYWBgYGaqmDFwcSERFRq1BXLyB1DZrw/lJ/BUREREREHQCDMxEREVEHVFVVhYkTJ8LMzAwymQylpaVqq+X48eNqr6E9MDgTERFRlzV06FC89tpr6i5DhdSafvrpJ/z11184ffo0rl+/DnNz87YvDk3XFx4e3q41qAsvDiQiIiJ6SLW1te0+TVpWVhZ8fX3h7+/frq/bFD09PTg4OKi7jDbHHmciIiJqM5WVlS1e6urq7rnfqqqqJrdpjunTp+PEiRNYtWoVZDIZZDIZcnNz0dDQgJkzZ8LDwwOGhobw8fHBqlWrGm07fvx4fPzxx3BycoKPjw8A4PTp0wgKCoKBgQH69euH3bt3QyaT4cKFC+K2iYmJGDlyJExMTGBvb4/nnnsORUVF963p74YOHYovv/wSf/75J2QyGYYOHQoAkMlk2L17t0pbCwsLbNq0CQCQm5sLmUyGXbt2ISIiAkZGRggMDER0dLTKNqdOncLQoUNhZGQES0tLPP7447h58+Y962tqqMb//vc/+Pn5QV9fH+7u7vjyyy9VXsPd3R2ffPIJnn/+eZiamqJbt25Yu3atxP899WCPMxEREbWZFStWtHjbUaNGISQkpMnnVq9e3eTNVpYtWyZ5/6tWrUJ6ejr8/f3x4YcfAgBsbW2hUCjg4uKCHTt2wNraGqdPn8acOXPg6OiIf/7zn+L2UVFRMDMzw+HDhwEA5eXlGDNmDEaNGoWtW7fi8uXLjYY0lJaW4tFHH8WsWbPw9ddf4/bt23j77bfxz3/+E0ePHr1nTX+3a9cuLFq0CImJidi1a1eze7vfffddfPHFF/D29sa7776LyZMnIzMzEzo6Orhw4QKGDRuG559/HqtWrYKOjg6OHTuGhoaGe9b393AfFxeHf/7zn1i2bBkmTZqE06dP46WXXoK1tTWmT58utvvyyy/x0Ucf4Z133sHOnTsxd+5cDBkyRPxDRNMwOBMREVGXZG5uDj09PRgZGakMM9DW1sYHH3wgPvbw8EB0dDS2b9+uEpyNjY3x73//Wwyta9asgUwmw7p162BgYIBevXrh6tWrmD17trjN6tWr0adPH3zyySfiug0bNsDV1RXp6eno0aNHkzX9nZWVFYyMjFo8ROKNN97A6NGjAQAffPAB/Pz8kJmZiZ49e+Lzzz9Hv3798P3334vt/fz8xK+l1PfVV19h2LBheP/99wEAPXr0QHJyMlasWKESnEeNGoWXXnoJAPD222/j66+/xrFjxzQ2OHOoBhEREdHffPfddwgODoatrS1MTEywdu1a5OXlqbQJCAhQ6elNS0tD7969VW7O8fce84SEBBw7dgwmJibi0rNnTwB3xiy3l969e4tfOzo6AgAKCwsBQOxxfhgpKSl45JFHVNY98sgjyMjIQENDQ5N1yGQyODg4iHVoIvY4ExEREd1l27ZteOONN/Dll18iLCwMpqamWLFiBc6ePavSztjYuNn7rqiowJgxY/DZZ581ek4ZYB+GTCaDIAgq65oaK66rq6uyDXDn1unAnbv0tZe761DWoqxDEzE4ExERUZt58803W7zt/cbtzps3r1FAbOlr3N0DCty5MC48PFwcQgBI6w328fHBf//7X9TU1EBfXx8AEBsbq9Kmb9+++N///gd3d3fo6DQdw5qqSSpbW1tcv35dfJyRkdHkWPD76d27N6KiolSGqzS3Pl9fX5w6dUpl3alTp9CjRw9oa2s3qx5NwqEaRERE1GaMjY1bvPy9N/JuRkZGTW7TXO7u7jh79ixyc3NRVFQEhUIBb29vnDt3DgcPHkR6ejref//9RgG4Kc888wwUCgXmzJmDlJQUHDx4EF988QWA/+vVffnll1FSUoLJkycjNjYWWVlZOHjwIGbMmCGG0aZqkurRRx/F6tWrcf78eZw7dw4vvvjifc9jUxYvXozY2Fi89NJLuHjxIlJTU/HDDz+IM39Iqe/1119HVFQUPvroI6Snp+Onn37C6tWr8cYbbzSrFk3D4ExERERd1htvvAFtbW306tULtra2yMvLwwsvvIAJEyZg0qRJCA0NRXFxsUrv872YmZlh3759uHDhAoKCgvDuu+9iyZIlACCOe3ZycsKpU6fQ0NCA4cOHIyAgAK+99hosLCygpaV1z5qk+vLLL+Hq6opBgwbhmWeewRtvvAEjI6NmnZMePXrg0KFDSEhIQEhICMLCwrBnzx6xh1xKfX379sX27duxbds2+Pv7Y8mSJfjwww9VLgzsiGRCa3zO0YmVl5fD3NwcZWVlMDMzU3c5REREGqe6uho5OTnw8PBQuTCOgC1btmDGjBkoKytr17HDndH93mftldc4xpmIiIiolWzevBmenp5wdnZGQkKCOEczQ3PnwOBMRERE1ErkcjmWLFkCuVwOR0dHPPXUU/j444/VXRa1EgZnIiIiolby1ltv4a233lJ3GdRGeHEgEREREZEEDM5ERERERBIwOBMRERERScDgTEREREQkAYMzEREREZEEDM5ERERERBIwOBMRERG10PHjxyGTySCTyTB+/PhW2++mTZtgYWHR7O3ef/99zJkzR3L7oqIi2NnZ4cqVKyrrp0+fLh7X7t27m11HZ8XgTERERF3W3QFRV1cXHh4eeOutt1BdXd2s/aSlpWHTpk1N7ldPTw9eXl748MMPUV9f38pH8H/kcjlWrVqFd999V/I2NjY2mDp1KpYuXaqyftWqVbh+/Xprl9jhMTgTERFRlzZixAhcv34d2dnZ+Prrr/Hjjz82CpIPYmdn16iHWLnfjIwMvP7661i2bBlWrFjRipWr+ve//43w8HC4ubk1a7sZM2Zgy5YtKCkpEdeZm5vDwcGhtUvs8BiciYiIqEvT19eHg4MDXF1dMX78eERGRuLw4cMAAIVCgeXLl8PDwwOGhoYIDAzEzp07m7VfNzc3zJ07F5GRkdi7dy8A4ObNm5g6dSosLS1hZGSEkSNHIiMjo8n95ObmQktLC+fOnVNZv3LlSri5uUGhUAAAtm3bhjFjxqi0OXDgAAYOHAgLCwtYW1vjiSeeQFZWlkobPz8/ODk54ddff5V0XF1ZhwvO3333Hdzd3WFgYIDQ0FDExMTct31paSlefvllODo6Ql9fHz169MD+/fvbqVoiIqKuSRAEVFZWqmURBKHFdScmJuL06dPQ09MDACxfvhybN2/GmjVrkJSUhAULFuDZZ5/FiRMnmr1vQ0ND1NbWArgzlOPcuXPYu3cvoqOjIQgCRo0ahbq6ukbbubu7IzIyEhs3blRZv3HjRkyfPh1aWlooKSlBcnIy+vXrp9KmsrISCxcuxLlz5xAVFQUtLS08+eSTYthWCgkJwV9//dXsY+pqdNRdQHP88ssvWLhwIdasWYPQ0FCsXLkSjz/+ONLS0mBnZ9eofW1tLR577DHY2dlh586dcHZ2xuXLl1s02J6IiIikq6qqgomJiVpeu6KiAsbGxpLb//bbbzAxMUF9fT1qamqgpaWF1atXo6amBp988gmOHDmCsLAwAICnpydOnjyJH3/8EUOGDJG0f0EQEBUVhYMHD2L+/PnIyMjA3r17cerUKYSHhwMAtmzZAldXV+zevRtPPfVUo33MmjULL774Ir766ivo6+sjPj4ely5dwp49ewAAeXl5EAQBTk5OKttNnDhR5fGGDRtga2uL5ORk+Pv7i+udnJxw/vx5yeesq+pQPc5fffUVZs+ejRkzZqBXr15Ys2YNjIyMsGHDhibbb9iwASUlJdi9ezceeeQRuLu7Y8iQIQgMDGznyomIiEhTRURE4MKFCzh79iymTZuGGTNmYOLEicjMzERVVRUee+wxmJiYiMvmzZsbDXdoijKQGxgYYOTIkZg0aRKWLVuGlJQU6OjoIDQ0VGxrbW0NHx8fpKSkNLmv8ePHQ1tbWxxOsWnTJkRERMDd3R0AcPv2bQCAgYGBynYZGRmYPHkyPD09YWZmJrbPy8tTaWdoaIiqqipJ56sr6zA9zrW1tYiLi8PixYvFdVpaWoiMjER0dHST2+zduxdhYWF4+eWXsWfPHtja2uKZZ57B22+/DW1t7Sa3qampQU1Njfi4vLy8dQ+EiIioCzAyMkJFRYXaXrs5jI2N4eXlBeBOp1tgYCDWr18v9sj+/vvvcHZ2VtlGX1//gfuNiIjADz/8AD09PTg5OUFHp+WxS09PD1OnTsXGjRsxYcIEbN26FatWrRKft7GxAXBn7LStra24fsyYMXBzc8O6devg5OQEhUIBf39/cciIUklJicp21LQOE5yLiorQ0NAAe3t7lfX29vZITU1tcpvs7GwcPXoUU6ZMwf79+5GZmYmXXnoJdXV197xadvny5fjggw9avX4iIqKuRCaTNWu4hKbQ0tLCO++8g4ULFyI9PR36+vrIy8uTPCzjbncH8rv5+vqivr4eZ8+eFYdqFBcXIy0tDb169brn/mbNmgV/f398//33qK+vx4QJE8TnunfvDjMzMyQnJ6NHjx4q+1y3bh0GDRoEADh58mST+05MTMTQoUObfYxdTYcaqtFcCoUCdnZ2WLt2LYKDgzFp0iS8++67WLNmzT23Wbx4McrKysQlPz+/HSsmIiIidXvqqaegra2NH3/8EW+88QYWLFiAn376CVlZWYiPj8e3336Ln376qcX79/b2xrhx4zB79mycPHkSCQkJePbZZ+Hs7Ixx48bdcztfX18MGDAAb7/9NiZPngxDQ0PxOeWn8HcHY0tLS1hbW2Pt2rXIzMzE0aNHsXDhwkb7raqqQlxcHIYPH97iY+oqOkxwtrGxgba2NgoKClTWFxQU3HOeQUdHR/To0UNlWIavry/kcnmjjyiU9PX1YWZmprIQERFR16Gjo4N58+bh888/x+LFi/H+++9j+fLl8PX1xYgRI/D777/Dw8PjoV5j48aNCA4OxhNPPIGwsDAIgoD9+/dDV1f3vtvNnDkTtbW1eP755xs9N2vWLGzbtk2cMUNLSwvbtm1DXFwc/P39sWDBgibnkd6zZw+6desm9krTvXWYoRp6enoIDg5GVFSUeEtLhUKBqKgozJs3r8ltHnnkEWzduhUKhQJaWnf+RkhPT4ejo6M4zQwRERF1XXff7e9uixYtwqJFiwAAr776Kl599dVW2a+SpaUlNm/efM/np0+fjunTpzdaf/XqVQQEBKB///6NnhsxYgScnJzwyy+/YPLkyQCAyMhIJCcnq7T7+3R9q1atwpIlS+5bL93RYXqcAWDhwoVYt24dfvrpJ6SkpGDu3LmorKzEjBkzAABTp05VuXhw7ty5KCkpwauvvor09HT8/vvv+OSTT/Dyyy+r6xCIiIioE3JxcRHDaluoqKhAYmIiVq9ejfnz5zfZRiaTYe3atc26rXdRUREmTJjQqPYXX3xRbdMJajKZ8DCzhKvB6tWrsWLFCsjlcgQFBeGbb74Rp3MZOnQo3N3dVf7Ki46OxoIFC3DhwgU4Oztj5syZ951V4+/Ky8thbm6OsrIyDtsgIiJqQnV1NXJycuDh4dFoOrTO7vbt27h69SoAwMTEpM1uUz19+nT8/PPPGD9+PLZu3So5x7RUYWGhOLOYo6OjRlzoeb/3WXvltQ4XnNsbgzMREdH9deXgTO1HE4JzhxqqQURERESkLgzOREREREQSMDgTEREREUnA4ExEREREJAGDMxERERGRBAzOREREREQSMDgTERERtdDx48chk8kgk8nEOxu3hk2bNsHCwqLZ273//vuYM2eO5PZFRUWws7PDlStXVNZPnz5dPK7du3c3u47OisGZiIiIuqzp06e3SuBNS0tTuQHb3cFTT08PXl5e+PDDD5t1V7/mksvlWLVqFd59913J29jY2GDq1KlYunSpyvpVq1bh+vXrrV1ih8fgTERERPSQ7OzsGvUQjxgxAtevX0dGRgZef/11LFu2DCtWrGizGv79738jPDwcbm5uzdpuxowZ2LJlC0pKSsR15ubmbXYXxI6MwZmIiIgIwNChQzF//ny89tprsLS0hL29PdatW4fKykrMmDEDpqam8PLywh9//CFpf/r6+nBwcICbmxvmzp2LyMhI7N27FwBw8+ZNTJ06FZaWljAyMsLIkSORkZHR5H5yc3OhpaWFc+fOqaxfuXIl3NzcoFAoAADbtm3DmDFjVNocOHAAAwcOhIWFBaytrfHEE08gKytLpY2fnx+cnJzw66+/SjqurozBmYiIiFqdIACVlepZBKHldf/000+wsbFBTEwM5s+fj7lz5+Kpp55CeHg44uPjMXz4cDz33HOoqqpq9r4NDQ1RW1sL4M5QjnPnzmHv3r2Ijo6GIAgYNWoU6urqGm3n7u6OyMhIbNy4UWX9xo0bMX36dGhpaaGkpATJycno16+fSpvKykosXLgQ586dQ1RUFLS0tPDkk0+KYVspJCQEf/31V7OPqavRUXcBRERE1PlUVQEmJup57YoKwNi4ZdsGBgbivffeAwAsXrwYn376KWxsbDB79mwAwJIlS/DDDz/g4sWLGDBggKR9CoKAqKgoHDx4EPPnz0dGRgb27t2LU6dOITw8HACwZcsWuLq6Yvfu3Xjqqaca7WPWrFl48cUX8dVXX0FfXx/x8fG4dOkS9uzZAwDIy8uDIAhwcnJS2W7ixIkqjzds2ABbW1skJyfD399fXO/k5ITz589LPEtdF3uciYiIiP6/3r17i19ra2vD2toaAQEB4jp7e3sAQGFh4QP39dtvv8HExAQGBgYYOXIkJk2ahGXLliElJQU6OjoIDQ0V21pbW8PHxwcpKSlN7mv8+PHQ1tYWh1Ns2rQJERERcHd3BwDcvn0bAGBgYKCyXUZGBiZPngxPT0+YmZmJ7fPy8lTaGRoatqgXvathjzMRERG1OiOjOz2/6nrtltLV1VV5LJPJVNbJZDIAaDTUoSkRERH44YcfoKenBycnJ+jotDx26enpYerUqdi4cSMmTJiArVu3YtWqVeLzNjY2AO6Mnba1tRXXjxkzBm5ubli3bh2cnJygUCjg7+8vDhlRKikpUdmOmsbgLNHp06cxfPhwaGmxk56IiOhBZLKWD5foLIyNjeHl5dVova+vL+rr63H27FlxqEZxcTHS0tLQq1eve+5v1qxZ8Pf3x/fff4/6+npMmDBBfK579+4wMzNDcnIyevToobLPdevWYdCgQQCAkydPNrnvxMREDB06tKWHqnb36qlvbUyBEm3duhVbtmzhxxhERET0ULy9vTFu3DjMnj0bJ0+eREJCAp599lk4Oztj3Lhx99zO19cXAwYMwNtvv43JkyfD0NBQfE5LSwuRkZEqwdjS0hLW1tZYu3YtMjMzcfToUSxcuLDRfquqqhAXF4fhw4e37oG2k23btiEiIqJdXovBWaL//ve/2LZtG9asWYOrV6+quxwiIiLqwDZu3Ijg4GA88cQTCAsLgyAI2L9/f6OhIn83c+ZM1NbW4vnnn2/03KxZs7Bt2zZxGImWlha2bduGuLg4+Pv7Y8GCBU3OI71nzx5069ZN7JXuKOrq6rBgwQJMnjxZHOPd1mSC8DCTtnR+5eXlMDc3Fx/37t0bY8eOxfjx49G3b19xrBMREVFXVV1djZycHHh4eDS6OK2zO378OCIiInDz5s0W3SK7uT766CPs2LEDFy9ebPScIAgIDQ0Vw6RUAwYMwCuvvIJnnnmm0XMymQy//vprq95OvKWqq6uRnZ2NoqIi2NjY4IUXXhB72BcsWICvv/4aZWVlMDMza7Ma2OMsUUREBGQyGS5evIi1a9di06ZN2LNnT5PzLRIREVHX4uLi0qyw2lwVFRVITEzE6tWrMX/+/CbbyGQyrF27tlm39S4qKsKECRMa1f7iiy/CRF3zCd5DQ0MDKisrsXv3boSFheHkyZMwMzPDr7/+imXLlrVLDexxfgBlj/N3332HmJgY7Ny5E5WVldDX18f48eMxdOhQTJo0CZaWluoulYiISC26co/z7du3xSGcJiYmbXab6unTp+Pnn3/G+PHjsXXrVmhra7fJ6ygVFhaivLwcAODo6AhjNV/pWVNTg8LCQmRlZeH5559HTk4OXF1dcfjwYfj4+Ih5ra17nDmrhkSTJ0+Gl5cXrK2tsWPHDuTn5+OXX37BlStXUFxcjIkTJ6Jnz57qLpOIiIjakaGhYZMzZ7S2TZs2YdOmTW3+Okp2dnaws7Nrt9e7F0EQUFFRgbKyMty8eRPV1dXilHrjxo1rl+Exd2NwlkhbWxvDhw+Hi4sLLCws8Pvvv+Ps2bM4deoUrl69ipKSEgwbNgzDhw9/qHkaiYiIiOjO0IzS0lLcunULN2/eRENDAwBg4MCB6NOnD/75z3+KN6RpL0x4zdSrVy/Y2dnBysoKLi4u2Lt3L3Jzc7FmzRrI5XLk5eXhqaeegrW1tbpLJSIiIuqQampqcPPmTZSXl4tDRrS0tGBiYoJx48Zh9OjRMHqYO920EINzCyjvWW9vbw9HR0fs3LkTcrkcW7duRU5ODgoLCzF37lzegYeIiLoUXjZFD+vuoRmlpaWorq4GcOdW4sbGxpDJZHjiiSdU5rBuTwzOLaSnp4eJEyfC09MT1tbW2L9/P2JjYxEdHY3CwkI8++yzDM5ERNQlKOcerqqqUlugoY6voaEBN2/eREVFhcrQDHNzc5iamgK4cyGqnp6e2mpkcH4IMpkMffv2hYuLC2xtbeHh4YF9+/YhKysLffv2xb///W/84x//UHeZREREbUpbWxsWFhYoLCwEABgZGfE+B9Qs1dXVKC8vR2VlJSorKwHcGZphbm4OIyMjaGtro6ioCBYWFm0+o8j9cDq6B5A6vUldXR0OHDgAKysrvPXWWzh9+jSAO/MgfvXVV/wLnIiIOjVBECCXy1FaWqruUqiDqa+vx61bt1BVVSXOQa2rqwtDQ0MYGhqKUxxaWFjAwcGhyT/K2ms6OgbnB2jJf0RdXR2WLl2K5cuXA7hzb/n//ve/sLGxgbm5ucqdCImIiDqThoYG3hyMmuXQoUNYvHgxKisroaOjg4EDByI0NBTDhw+Hs7MzgDtB+n49zQzOGuJh/iMOHTqEadOmQS6XQ1dXF5GRkRg4cCDGjh0Lf3//NqqYiIiISPNVVFTg1VdfxYYNGwDcufviuHHjMGTIEIwZM6ZZN9NhcNYQD/sfUVRUhBdeeAG7du0CAHTr1g1PPvkkBg8ejFGjRnW5OywRERERnT17FlOmTEFWVhZkMhnefvttzJo1C7du3UJgYGCzx8jzzoGdhI2NDd5//300NDTgjz/+QF5eHn744QdcvnwZubm5mDBhAtzd3dVdJhEREVGbEQQB58+fh0wmw2+//YYPPvgADQ0NcHV1xX/+8x8MGTJE3SVKwuDcDnr27InnnnsObm5u+PXXX5Gfn4/du3cjPT0dBQUFGDZsGCIiIsTpfIiIiIg6i1u3bmHv3r04c+YM9u7di7y8PADA5MmT8f3337f7bbMfBoNzOzAwMMDEiRPRo0cP2NvbIyoqCsePH0dycjLy8/Nx5coVpKenY9y4cXB1dVV3uUREREQPTRAEJCYm4rfffsOJEycQFRWF+vp6GBoaYu3atXj22WfVXWKzMTi3o4CAAHTr1g1OTk7o3r07du3aheLiYmzduhVJSUm4cuUKIiIi8Oijj7L3mYiIiDqsyspK/P777zh58iT27Nkj9jJ7enpi7NixeOSRR9RcYcswOLczc3NzTJs2DT169ICDgwOOHDmC6OhoJCQkIDs7G3l5eWLvc7du3dRdLhEREZFkgiAgJSUF+/btw/HjxxEVFYW6ujro6elh+PDhGDx4MMaNGwcPDw91l9oiDM5qIJPJEB4eDm9vb7i6usLX1xd79uxBcXExfv75ZyQlJeHq1avsfSYiIqIO49atW/j9998RHR2NPXv24PLlywAADw8PjB07FoMGDcLIkSNhZGSk5kpbjsFZjWxtbTFz5kz06tULLi4uOHz4MM6cOYOLFy8iOzsb+fn56N27NxwdHdVdKhEREVGTBEFAfHw8Dhw4gFOnTuHIkSOoq6uDrq4uHnvsMQwaNAhjxoyBn5+fukt9aAzOaqalpYVHHnkEPXr0aNT7vHXrVshkMnz99dewtbVVd6lEREREKoqLi7Fv3z7ExMRg3759uHLlCgDAzc0N48aNw4ABAzBmzBiYmJioudLWwRugPEB7TagNAAqFAtHR0Th06BCio6MRFRUFhUIBKysrfPnll5g2bVqzJwQnIiIiaguJiYnYsWMHjh07hlOnTkGhUEBPTw+RkZEYPHgwRo8eDT8/v3bJLu2V17TabM9t5LvvvoO7uzsMDAwQGhqKmJgYSdtt27YNMpkM48ePb9sCH4Ky93n+/Pn4z3/+g+joaAQGBqKkpAQzZszAsGHDkJ6ejvr6epSWlqq7XCIiIurCsrOz8f333+Ovv/6CQqGAj48PXn75ZcyaNQvz58+Hv79/p+vw61A9zr/88gumTp2KNWvWIDQ0FCtXrsSOHTuQlpYGOzu7e26Xm5uLgQMHwtPTE1ZWVti9e7fk12zPHuem1NXV4euvv8ayZctw+/Zt6Ovr45lnnoGbmxsiIyMRFhYGLa0O9/cPERERdVClpaV4++23sXbtWgCAiYkJRo4ciQEDBmDs2LHw8vJq95raK691qOAcGhqK/v37Y/Xq1QDuDG1wdXXF/PnzsWjRoia3aWhowODBg/H888/jr7/+QmlpaYcKzkrZ2dmYO3cuDh06BODOhYVPPPEEQkJCMHr0aN44hYiIiNqUIAjYvn07FixYgOvXrwMAZs2aBV9fX/j6+mLYsGHQ09NTS23tldc6zMWBtbW1iIuLw+LFi8V1WlpaiIyMRHR09D23+/DDD2FnZ4eZM2fir7/+euDr1NTUoKamRnxcXl7+cIW3Ek9PT/zxxx948cUXsWXLFty4cQMbN24U538ODw/HY489BmNjY3WXSkRERJ3EjRs3cOLECXh7e2PhwoU4evQoAKBHjx5Yu3YthgwZgvr6eujodJhI+VA6zFEWFRWhoaEB9vb2Kuvt7e2Rmpra5DYnT57E+vXrceHCBcmvs3z5cnzwwQcPU2qbUSgUGD9+PCwtLXHo0CFcuHAB8fHxSElJQXJyMpKTkzFs2DD079+fwzeIiIioxWpra/Hnn3/i+PHjOH78OM6ePYv6+noYGBjgnXfewZtvvgkDAwMA6DKhGehAwbm5bt26heeeew7r1q2DjY2N5O0WL16MhQsXio/Ly8s1ZhiEjo4ORo0ahd69e8Pd3R2xsbHYv38/CgoK8PvvvyM+Ph7Z2dmIj4/HqFGj4Obmpu6SiYiIqAMRBAHJyck4ePAgzp49iwMHDoifvj/22GNYs2YNPD091Vyl+nSY4GxjYwNtbW0UFBSorC8oKICDg0Oj9llZWcjNzcWYMWPEdQqFAsCdAJqWlobu3bs32k5fXx/6+vqtXH3rcnFxwZw5cxAUFARPT0+cOnUKx44dw/Xr17F+/XrExcUhOzsbYWFhGD58eKeZO5GIiIjajlwuxx9//IH4+Hj88ccfyMrKAgCYm5tj5MiRmDhxYpcOzUAHCs56enoIDg5GVFSUOKWcQqFAVFQU5s2b16h9z549cenSJZV17733Hm7duoVVq1ZpTC9yS2lrayMsLAz+/v7o1asX/Pz8cOTIESQkJODChQtITU1FUlISkpOTMWTIEISFhXWpj1KIiIhImsrKShw9ehSnT5/Gn3/+ibNnz6KhoQHa2toIDw/HkCFDMHToUAwePFjdpapdh0pSCxcuxLRp09CvXz+EhIRg5cqVqKysxIwZMwAAU6dOhbOzM5YvXw4DAwP4+/urbG9hYQEAjdZ3ZKamppgwYQKCg4PRvXt3nDt3Dvv37xf/aoyLi0N6ejri4+Mxd+5ctV3tSkRERJqloaEBsbGxOHr0KM6cOYOjR4+isrISANC9e3eMHDkS/fr1w6hRo3gH4/+vQwXnSZMm4caNG1iyZAnkcjmCgoJw4MAB8YLBvLy8LntRnJubG1544QX07dsXnp6eOH36NI4ePYrCwkL85z//QUpKCkaMGAEfHx91l0pERERqJAgCMjMzcfDgQZw7dw4HDx6EXC4HAFhbW2P48OHo378/RowYgZ49e3a6m5g8jA41j7M6aMo8zs1RUVGBI0eOIDo6GidOnEBsbCwUCgV0dHTw0ksvYenSpbCyslJ3mURERNTObty4gf379yM+Ph6HDx9GSkoKgDvXeA0ZMgTh4eGIiIhAWFgYdHV11VytdLwBioboiMFZ6dq1azh48CB0dXWxfft27Nu3DwBgaWmJpUuX4qWXXoJMJkNDQ4PGXxBJREREDy89PR3PP/88zpw5g4aGBshkMgQHByMiIgIDBgxAZGRkh8s7AIOzxujIwRm483GMIAjQ0tLCkSNHsHDhQvGiyR49emDatGnQ1tbGkCFD0K9fP15ASERE1AnV1NTg+++/x7/+9S+UlJQAuHNztccffxxBQUEYOXJkh544gcFZQ3T04Px3DQ0NWL9+Pd5//30UFhYCAJydnREZGYmgoCA8+uijCAgI4HgmIiKiTkChUODnn3/Ge++9h9zcXACAj48P+vXrhz59+mDYsGEIDAzs8L/3GZw1RGcLzkrl5eV46aWXsH37dtTV1QEAvLy8MGzYMAQFBWHYsGHw8vLq8N9IREREXUlDQ4M4Na2TkxMWL14s3kHZyckJH374IaZNm4YrV67A2dm5Q41jvp/2ymv8XL6LMjU1xZNPPgkHBwecOHEC8fHxyMzMRGZmJnr37o3U1FQxQHfkj26IiIi6AkEQkJiYiGPHjiEpKQlHjhxBdnY2AMDMzAyLFi3Cq6++CiMjIwCAu7u7GqvtuNjj/ACdtcdZKT8/H4cPH8aFCxdw9OhRJCUlAQC0tLTQr18/DBo0CEFBQYiIiICzs7OaqyUiIqK7CYKAtLQ0HD16FJcuXcLx48eRmpoK4M7N0l566SUsWbIENjY2aq60bXGohobo7MEZuPNNl56ejqioKFy4cAFHjhxBTk4OgDu3J+/fvz8eeeQR9OnTBxEREXB0dFRzxURERF2bIAjIzs7G0aNHkZCQgBMnTiAxMVF8vnfv3hg6dChmzJiBoKAg9RXaThicNURXCM5KCoUCFy9exLFjxxAfH49jx47h6tWrAABdXV2EhIQgPDwcwcHBGDZsWKf/65WIiEjTCIKArKwsnDhxAhcvXhT/Vca5Xr16YejQoeIF/56enl3ieiWOcaZ2p6WlhaCgIPj7+yMuLg69e/fGhQsXcPz4cVy7dg2nTp1CbGwsBgwYgJ49ezI4ExERtRNBEJCRkYETJ04gKSkJf/31Fy5cuACFQgHgzkwZQ4cORe/evfHoo4/Cx8enSwTm9sYe5wfoSj3Of1dXV4fY2FicPHkS58+fx7Fjx1BQUAAAMDc3x2uvvYZXXnmFdyEkIiJqI8oxzHcH5osXL4qBuXv37oiIiEBAQAAiIiLg7+/fJQMzh2poiK4cnJVqa2sRExMj/nWbkJCAtLQ0AICJiQnmzp2LhQsXwsHBAZWVlTAyMuqS37REREStTRAEfPTRR9i5cycSExPFIRkeHh5iD/PgwYMRGBgIbW1tNVerPgzOGoLB+f/U1NQgNTUVAQEB+N///oePP/4YCQkJAAADAwPMnDkTDg4OsLe3x6BBg/gxERER0UNISEjAv/71L/zvf/8TA7O3tzcGDRokBubevXt36cCsxOCsIRic700QBPz+++/4+OOPcebMGQB3xkn37t0bAwcOhK+vLwYNGgQ/Pz9oaWmpuVoiIiLNVV1dDX19fchkMpw6dQqfffYZ9u3bJz4fFBSEkJAQ+Pv7Y/DgwQgICODv1rswOGsIBucHEwQBR48excsvvywO4ZDJZPD19UV4eDh69eqFAQMGoG/fvtDX11dztURERJqjvLwcZ86cQUxMDCwtLbFlyxZER0cDuPO7dNKkSXjnnXdgYmKCiooKdkbdA4OzhmBwlqaiogLr16/HxYsX8ddffyEjI0N8rlu3bggPD4e/vz/69++P0NBQmJubq7FaIiIi9bpx4wZOnz6NuLg4nD9/HtHR0SguLgYA6Onp4bnnnsObb74JHx8fNVfaMTA4awgGZ+kUCgUSExPx119/ITExEdHR0bh06ZJ45a+1tTXCwsIQFBSEwMBAhIeHw8nJSc1VExERtQ9BEJCZmYmzZ8/i0qVLiI2NRUxMDCorKwH83/VC7777Lm821kwMzhqCwbn5lFPnnDx5EsnJyYiJicG5c+dQU1MDADAyMkJISAj69+8PX19fhIWF8UJCIiLqtGpra3HhwgXExMQgIyMDZ86cwfnz51FXVwfgzhSvyiGNY8aMQVhYmJor7ngYnDUEg/PDyc/Px+nTp5GQkID4+HicOXMGZWVlAO7czrt3794ICQnB66+/Di8vLzVXS0RE1Hpu3ryJmJgYxMfHIyUlBWfPnkV6err4vL29PcLDwxEYGIh+/fohLCyM90ZoIQZnDcHg3DpKSkpw5swZnDt3DhcvXsTp06dx/fp18fmhQ4di3rx5GDduHHR0eENLIiLqmARBwOXLl3HmzBlcvHgRCQkJiImJQVFRkdime/fuCAsLg5+fH0JCQhAaGgpjY2M1Vt3xMThrCAbn1nX79m3ExcXhzJkzSExMRExMDNLT09HQ0AAAcHFxwdy5czF79mzY2tqirKwMxsbGDNNERNQhCIKADz74AAcPHsT58+fFYYp6enoICgpC//79xdmmAgICoKurq+aKOwcGZw3B4Nw2GhoakJiYiNjYWAwZMgSbNm3C2rVrxb/I9fT08PTTT8Pd3R0mJibo27cv+vXrx9k4iIhIIykUChw+fBjfffcdfvvtN/GGJVZWVggJCUFQUBB69+6NAQMGwN3dndf1tDIGZw3B4Nx+qqursX37dnz77bc4d+6cuN7Z2Rl9+/aFv78//Pz80LdvX/To0YN3SiIiIrWoqalBZmYm/Pz8IJfLsWHDBqxbtw65ubliG29vb7F3OTg4GCEhIRy/3IYYnDUEg7N6xMTEYNGiRThx4oQ4nZ2enh4CAgLQt29feHt7IygoCH379oW1tbWaqyUios5OEATI5XLExcXhwoULSE1Nxc2bN3Ho0CHU19cDuDM7xtSpU/Hyyy/j+vXrMDQ0RFBQEG/+1Q4YnDUEg7N6CIKAbdu2iT+gzp8/j5KSEvF5BwcHBAcHIyAgAD4+Pujbty98fX05VoyIiFpVZWUlLl26hPPnzyMrKwvnz59HfHw8SktLxTbh4eGYM2cOnnrqKRgZGamv2C6MwVlDMDirV2FhIWJjY3HhwgWkp6eLU/ooLybU1dUVh294eXkhMDAQgYGBcHJy4vgxIiJqkYaGBmRmZuL8+fNISUlBenq6+HtI+SmogYEB+vTpg9WrV6Nv375qrpgYnDUEg7NmqK2tRXJyMuLj45GamirOC3339D42Njbo3bs3evfujUceeQT/+Mc/1FgxERF1NIWFhbhw4QISEhKQlZWFhIQEXLp0SbyzHwC4uroiODgYvXr1gr+/P0aOHAkLCwv1FU0AGJw1BoOz5rlx4wbi4+Nx4cIFpKWlIT4+HklJSeIYMwDo378/5s2bhwkTJsDExESN1RIRkSarqKhAYmIiLl68iIyMDFy6dAkJCQmQy+ViG2NjYwQEBKBPnz4q19hwpifNweCsIRicNVd9fb0YnJOTk5GcnIyEhARcvnxZbGNsbIyJEydi6tSpiIiIgEwmQ05ODtzc3DgrBxER4fz58/j000+RkJCAjIwMcSiGtrY2fHx8EBgYCB8fHwQEBCAoKAgeHh4cCqiBGJw1BINzx3Dz5k0kJCQgISEBWlpaKC0txebNm5GZmSm2cXV1xZgxY9DQ0AAPDw/xYzY3NzdoaWmpsXoiImpPDQ0NOHbsGH7++Wfs2rVL5UI/JycnBAUFwd/fH97e3ujTpw/8/PxgYGCgvoLpgRicNQSDc8ciCAJqampgYGAAQRAQHR2NzZs3Y9u2bSgrKxPbWVtbw9/fH/7+/nB3d0evXr3g5+eHbt26sSeBiKiTaGhoQHZ2NpKTk9GrVy8UFRXh559/xvbt21FQUCC2s7KyQs+ePREUFARPT0/xQnNbW1s1Vk/NweCsIRicO4fq6mrs2bMHH330EVJTU8VZOQDA3t5evLmKm5ub2BPt7OzMEE1E1MHU19cjKysLycnJSE1NRV5eHi5duoT09HTcuHFDbGdlZYWnnnoKTz/9NFxcXHDp0iUEBATA09OTn0J2QAzOGoLBufMoLS3Fzp07kZWVhdTUVCQlJSErK0sczwbcuUuhn58ffH194ebmhp49e6Jnz54czkFEpMHq6uqQmZmJ5ORkpKWl4fLly0hJSUFKSorK7EsmJiYYP348Jk+ejMcee4xz/3ciDM4agsG587l58yaSkpLE4JyamorExETk5ubi7m8HR0dH+Pr6isF52LBhCA4OVmPlRESkVF1djczMTKSmpiI1NRU5OTliWL57zLK2tja8vb3h7++PN954A6GhoeormtoMg7OGYHDu3IqLi5GUlITExERxHFxycjLy8vJUQrSNjQ0mTJiAOXPmoG/fvhzCQUSkBpWVlUhMTERaWhqysrKQm5uLlJQUpKam4tatW2I7HR0deHt7w9fXF97e3uLXAQEBMDU1VeMRUFthcNYQDM5dR2FhodgTffnyZaSlpSElJQXZ2dkqwzm6deuGJ598EmPHjsWgQYNQX1+P8+fPw9vbGzY2NgzVRERtJCUlBUuXLkV6ejoyMjJQVVUlPqenpwcfHx/4+vrCy8sLXl5e6NWrF3x9ffn7uwtgcNYQDM5djyAIuHHjhtiLkZOTg8rKSsjlcuzfv1/lB7WZmRnCwsJgaGgIb29vODs7o0ePHvD29oa7uzt0dHTUeCRERB1PdXU1AIjTv+Xm5mLfvn3Yt28fjh8/jrq6OrGtoaGhGJa7d+8uhuWePXuyZ7mLYXDWEAzOVFpairq6Otja2uL27ds4dOgQfv31V+zfv1/lCm3gzlzR3t7e6NGjB1xcXNC9e3d4e3uje/fuvCUrEVETBEGAXC5HZmYmMjMzcfnyZTg6OuLy5cvYt28fEhMTVdo7OTmhW7du8PHxgYeHB7y8vMTwbGxsrKajIHVjcNYQDM50LwqFAmfPnsV7772H5ORklduzAnd6o5Wh2cPDA87OzujevTs8PT3h4eEBfX19NVVORKRet2/fRlZWlhiWr127hqysLHFR9joDdy7uGzhwIMaMGYMxY8ZAR0cHFy9ehI+PD7p37w49PT01HglpCgZnDcHgTPdTXV2Nw4cPIyMjA/n5+cjIyEBGRgays7NRX18vtpPJZGIPdPfu3eHi4oJu3bqhT58+6NOnjxqPgIio7dXW1iIvLw85OTnIzs5Gfn4+Ll++LAblwsJClfYGBgYYO3Ysxo0bhxEjRsDKykpNlVNH0V55jQMwiR6CgYEBxowZA0EQUFBQIF6wkp2djZycHPGXQnFxMfLz85Gfn4/jx4/DwMAAnp6eePzxx2FlZQU3Nzd1HwoRUasqLCxEcnIycnJykJeXh+vXr4vBOTc3V6VzAYD4qZyXlxdcXV0xc+ZMuLq6qql6oqZ1uB7n7777DitWrIBcLkdgYCC+/fZbhISENNl23bp12Lx5szg+Kjg4GJ988sk92zeFPc7UEpWVlcjMzBRD9N0fQ2ZnZ6OmpkalvYeHByIiIhAREYGhQ4fC2dkZ+/btg729Pdzd3WFnZ8fZOoiowxAEATt37sTGjRuRm5uL3Nxc3L59W6WNiYkJvLy8xCFsLi4u4mwY7u7uHIJBzcKhGk345ZdfMHXqVKxZswahoaFYuXIlduzYgbS0NNjZ2TVqP2XKFDzyyCMIDw+HgYEBPvvsM/z6669ISkqCs7OzpNdkcKaHpbzwRRmcc3JykJ+fj9zcXFRVVSE2NlblFuAA4OnpCQsLC7i7u4vB2c3NDW5ubnB3d4e9vT3vZEhEalNXV4crV64gLy8P4eHh0NHRQXZ2No4dO4ajR4/i2LFjja770NXVFX+GeXl5wdnZWby4z9vbm8Mx6KEwODchNDQU/fv3x+rVqwHcuTjL1dUV8+fPx6JFix64fUNDAywtLbF69WpMnTpV0msyOFNrq6urw+XLl1FWVobg4GCUl5fj1KlTOHbsGI4dO4b4+HiVeaMBwNraGu7u7nBzc0O3bt1gb28PV1dXcXF2dmbvDBG1maqqKnFccl5eHq5evYqCggLk5eVBV1cX8fHxyMvLU9nGwMAALi4ucHV1hYeHB1xcXODm5gYPDw/xMafspNbCMc5/U1tbi7i4OCxevFhcp6WlhcjISERHR0vaR1VVFerq6u77V21NTY3Kx+jl5eUtL5qoCbq6uvDy8hIfm5mZYeTIkRg5ciQAoKysDJ9//jmOHj2K3NxcyOVyFBcXo7i4GHFxceI2ytCsDNJOTk5wdXWFi4sL/Pz8+AuJiFpEoVDgxo0buHr1Kq5cuYL8/Hxcv34dV69eRX5+PvLy8pCfn68y8wVw52dbaGgoHn30UURERGDAgAE4c+YMampq4OnpiW7dunE2IerwOsxv1qKiIjQ0NMDe3l5lvb29PVJTUyXt4+2334aTkxMiIyPv2Wb58uX44IMPHqpWoodhbm6O5557DiEhIcjNzcW1a9dw+fJl5ObmIi8vD3K5HOXl5eJdDoE7d8xydnYWe3a++uorfuxJRJKlpqbiypUruHLlCq5du4aSkhJcvXpVDMnXrl1rNKRMV1cXLi4uCAwMxEsvvYTw8PBG8ygPHTq0HY+CqO11mOD8sD799FNs27ZNnNHgXhYvXoyFCxeKj8vLy3lVL7W7nj17omfPngDu9EArg7OyB/ruX2hXrlxBTU0NcnJykJOTgz///BObN2+Gn58f+vfvj5CQEPTv3x8BAQFITk5GdnY2nJyc4OTkBAcHBw7xIOriKioq8MMPPyAlJQVXr17F1atXUVZW1qidiYkJunXrJn7S5ejoCGdnZ3h7eyMiIkINlRO1vw4TnG1sbKCtrY2CggKV9QUFBXBwcLjvtl988QU+/fRTHDlyBL17975vW319fX6URBrF3NwcvXv3Ft+75eXlYmhW9gQVFBSIjwsLCyGXy5GYmIjExERs3LgRwJ33tqurKywtLeHs7AwnJyfY2NiIwzyUi729PXR1ddV5yETUCioqKiCXy3H9+nVcv34d9vb2CA8PR1JSEmJiYsQlKSmp0XUVAGBrayuG5G7duqk8dnNzg4uLC//wpi6nwwRnPT09BAcHIyoqCuPHjwdwZxxWVFQU5s2bd8/tPv/8c3z88cc4ePAg+vXr107VErUdMzMz+Pv7w9/fH8Cdiw2vXbsm9j73798fRkZGiImJQWxsrLjcvHkTmZmZAIDY2FgAd76vnJyc4OjoCAcHBzg4OMDGxga2trZwcHCAvb097O3t4eDgADMzM06JR6SBBEFAaWkpCgoKxJB8/fp1lJSUoKCgAHK5HHK5HCUlJbh+/XqjsckAYGdnB2trazg5OYl/WNvb28PZ2Vm8wM/R0RHa2tpqOEIizdGhZtX45ZdfMG3aNPz4448ICQnBypUrsX37dqSmpsLe3h5Tp06Fs7Mzli9fDgD47LPPsGTJEmzduhWPPPKIuB8TExOYmJhIek3OqkGdgSAISEpKwtKlS3Ht2jVx+fsNCIA7t7e9OzArA3RYWBjGjh2rhuqJSKmqqgpyuRyFhYUoKChAYWEhbty4gdLSUjEgK5eioiI09Sve3NxcHMalHMolk8lw6NAhuLi4wMXFBc7OzpJ/TxJpAk5Hdw+rV68Wb4ASFBSEb775BqGhoQDuXITg7u6OTZs2AQDc3d1x+fLlRvtYunQpli1bJun1GJyps6iursalS5fE0Kz85Xv16lXI5XKxZ6q2trbJ7V1cXBAaGoqAgAD4+fnBz88PXl5e0NXVxf79+6GtrQ1bW1vY2trCxsYGhoaG7XyERJ3f/v37sXv3bjEwFxYWorCw8J4zQBkbG4t/ADs4OOCNN95ASEgI54GnTofBWUMwOFNnVVdXB7lcLgbp69evo6CgADdv3hR7rJRh+l6/lHV1ddGjRw/IZDJxiIednR0sLS1hYWEhrrO1tYWVlRWsra1hZmbGX9pEuHNvgZKSEhQXF6OoqEhcKisr8cILLyA9PR1JSUni9QpJSUnIzs5ushcZACwtLcWArBx+ZWlpCUdHR3Hx8fGBkZFROx8pUdtjcNYQDM7UldTV1YkfAStDc0FBAUpKSjB48GCkpaWJ0+AlJyejoqKiyf1oaWnBxsYGNjY2YmBWLqamprCyshLXBwYGNppmkqizqK+vx82bN1UWZVguKSlBWVmZOE97UVGR+HVZWVmTF+wBgJGREezs7MQ/VG1tbWFvby8G57uDspWVFf9QpS6BwVlDMDhTVycIgvh9cDeFQoH8/HwcOnQI27dvx40bN8Slrq7unvszNDQUQ7SVlRXGjRuHIUOGwNPTU+V7rKGhAWfOnIGFhYW4GBkZ8QJF6hByc3Oxa9culJWVobKyslFoVobk+32vWFhYwM/PD/7+/uK/PXv2xE8//QQrKyvY29vDzs5OXExMTPj9QV0Wg7OGYHAmur8bN27g0qVLKCoqEoNzaWkpbty4IfaeKZcH3YnTyspKvB2vo6MjsrKyxGEfFhYWMDQ0VAnSFhYWMDc3h5mZGczMzGBqasqr/qlV1dbWory8HGVlZSgrK2v09XPPPQcdHR3k5OQgOzsb2dnZyMnJQXJyMhISElBaWnrfcCyTyWBpaSl+OmNjYwNra2tMnjwZw4cPbzIIC4LAgEz0NwzOGoLBmah5lOM2b9y4IYbpoqIilJSUoKKiQuxxUy6GhobIzMxEUVHRA/dtamoKCwsLWFpaimH57sXIyAgmJiYwNTXFk08+2eQQEOWPPAYPAoCamhrk5ubi1q1bqKioQEVFBcrLy8WAXFlZKa5ThuW7n6+pqZH03jU3N4elpSUsLS1hbW0tBmRLS0uYm5uL65SLk5NTo7vwEdG9MThrCAZnotYhCAIqKytRUlIihufq6mqMHj0aAHDr1i3x7oc5OTmIiYlBXFwcSktLcfPmzfv22ilpa2uLITo4OBjdu3dXmV7L3t4e2tra2LRpE4yNjSUtRkZGvCFMByAIAqqrq1FVVdVoqaysxIABA1R+hguCgLKyMqSmpmLNmjWorKxUCcXK5datW/e8GO9ulpaW8PDwgKenJzw9PeHh4YHY2FgYGxuLn4oog7OVlZXYy2xjY3Pfu9kSkTQMzhqCwZlIPVJTU3H27FmUlpaitLQUFRUVYoguLS1tFHAqKysl71tPTw8mJiYqAVn5+O5/jYyMxLuJGhgYwNDQEJMnT4aFhUWjfVZXV+PKlStiO319fejp6UFXV5e92xIpL4Zr6mK26upqxMbGqoTj27dvq3xdX1+P27dvi4uyB7miogLOzs6orKxUuei1pqZGUl0ymazJTzjMzMwwYsQIPPnkk7C0tGy0XU5ODgwNDWFpack70hK1MQZnDcHgTKR+CoUCt27dEkP03Yvy4/OamhrcunUL5eXlqK6uRnBwMK5cuSIuV69eRUFBwT3nqb4XmUwmhmFDQ0P06tVLvMuacnYQKysrKBQKnDhxAnp6emLY1tPTg7a2NnR1dcXHyuXvjwcNGtTkR/PV1dXIy8uDjo4OtLW1oaOjIy5aWlqQyWTQ0tK659fa2tr3HCf7oH8FQUBDQ4O4KBQK8WtLS8smb7dcXV2N5ORk1NXVNVpqa2sbraupqUFNTQ2qq6tRV1eHZ599FhYWFo3+MJLL5di5c6dKMFYGZ+XXUoPw3czMzKCrqwtjY2OYmpo2Csbm5ubiH1LKx8oeZHNzczg7O8PKyqrZr0tErYvBWUMwOBNpPuXH9MqP1mtra9GrV68m2x08eBC///47KioqxPGrd/+rXCoqKiQND3kQXV3dRmH67q91dXWho6ODwYMHw9LSUgzoyrBeVVWFw4cPQ0dHB7q6utDW1oa2trYYkO+1KMPyCy+8AEdHx0Z1FRYW4vvvv7/vOVUGZ2VgVigU4tcTJkyAra2tGIiVIfbGjRvYvXu3Sjiur69v9HVtba0Ymu9eGhoaHvqcK8/h3Z8gBAUFoX///uIdMZV3xzQ0NMTGjRtRX18PU1NT8c6yd4djMzOzJv9IICLNweCsIRiciTqXqqoqlJaWqoTkey01NTUqvZu1tbWIjIwUx2nfPV5beQfGmpoa1NbWtkoAfBjKHmd9fX0xRN/9414QhCb/MFAG5nvNIdxejI2NG/X+yuVyMRQbGRk1+bWBgQH09fVhZGQkrjcxMYG/vz969Oih1mMiorbTXnlNp832TESkgZSB6kEEQUBNTQ0qKytVxtA21ZMNAJcuXcKhQ4fEdvX19Sq9qvf6WtkD6+fn12iMbnV1NcrKylBQUCD21v695/defR/K3uKqqqqHOl9/pxz+oew1V/ao3x1cCwoKoKurK/am3/2v8mvl9n9fxo4di0GDBkFHp/Gvp507d0Imk4n/h3eH47u/5sWcRNRW2OP8AOxxJqLmujs019bWisv9Ho8ePbrJsJibm4vdu3eLYVy5KN3dQ3x3qFYuU6ZMgbW1tco+ZTIZiouL8Z///KfJ+pXDPe4eEqIcK63svZ4yZQq8vb0bbatQKLB+/XpxGMqDFj09PbGX2MDAAGZmZryQjoiajUM1NASDMxFpGmVvsjIwK/9VLnc/trCwaPKmMMpbQQP/N6d1U/8qL0JUjq3+e4AmItIEHKpBRERNUgbah6GjowNbW9tWqoiIqGtoPFkmERERERE1wuBMRERERCTBQwXn2tpapKWlqVyoQkRERETUGbUoOFdVVWHmzJkwMjKCn58f8vLyAADz58/Hp59+2qoFEhERERFpghYF58WLFyMhIQHHjx+HgYGBuD4yMhK//PJLqxVHRERERKQpWnRZ9u7du/HLL79gwIABKlMS+fn5ISsrq9WKIyIiIiLSFC3qcb5x4wbs7Owara+srOTcnkRERETUKbUoOPfr1w+///67+FgZlv/9738jLCysdSojIiIiItIgLRqq8cknn2DkyJFITk5GfX09Vq1aheTkZJw+fRonTpxo7RqJiIiIiNSuRT3OAwcOxIULF1BfX4+AgAAcOnQIdnZ2iI6ORnBwcGvXSERERESkdjJBEAR1F6HJ2uve50RERETUMu2V11rU4xwfH49Lly6Jj/fs2YPx48fjnXfeQW1tbasVR0RERESkKVoUnF944QWkp6cDALKzszFp0iQYGRlhx44deOutt1q1QCIiIiIiTdCi4Jyeno6goCAAwI4dOzBkyBBs3boVmzZtwv/+97/WrI+IiIiISCO0KDgLggCFQgEAOHLkCEaNGgUAcHV1RVFRUetVR0RERESkIVo8j/O//vUv/Oc//8GJEycwevRoAEBOTg7s7e1btUAiIiIiIk3QouC8cuVKxMfHY968eXj33Xfh5eUFANi5cyfCw8NbtUAiIiIiIk3QqtPRVVdXQ1tbG7q6uq21S7XjdHREREREmq298lqL7hyoVFtbi8LCQnG8s1K3bt0eqigiIiIiIk3TouCcnp6OmTNn4vTp0yrrBUGATCZDQ0NDqxRHRERERKQpWhScZ8yYAR0dHfz2229wdHSETCZr7bqIiIiIiDRKi4LzhQsXEBcXh549e7Z2PUREREREGqlFs2r06tWL8zUTERERUZfSouD82Wef4a233sLx48dRXFyM8vJylYWIiIiIqLNp0XR0Wlp38vbfxzZ3xosDOR0dERERkWbT6Onojh071tp1EBERERFptBYF5yFDhrR2HZJ99913WLFiBeRyOQIDA/Htt98iJCTknu137NiB999/H7m5ufD29sZnn32GUaNGtWPFRERERNQZtGiMMwCUlpbiyy+/xKxZszBr1ix8/fXXKCsra83aGvnll1+wcOFCLF26FPHx8QgMDMTjjz+OwsLCJtufPn0akydPxsyZM3H+/HmMHz8e48ePR2JiYpvWSURERESdT4vGOJ87dw6PP/44DA0Nxd7e2NhY3L59G4cOHULfvn1bvVAACA0NRf/+/bF69WoAgEKhgKurK+bPn49FixY1aj9p0iRUVlbit99+E9cNGDAAQUFBWLNmjaTXVI6ZuXaNY5yJiIiINFF5eTmcnDR0jPOCBQswduxYrFu3Djo6d3ZRX1+PWbNm4bXXXsOff/7ZqkUCd27vHRcXh8WLF4vrtLS0EBkZiejo6Ca3iY6OxsKFC1XWPf7449i9e/c9X6empgY1NTXiY+UsIU5OD1E8EREREXV4LRqqce7cObz99ttiaAYAHR0dvPXWWzh37lyrFXe3oqIiNDQ0wN7eXmW9vb095HJ5k9vI5fJmtQeA5cuXw9zcXFxcXV0fvngiIiIi6vBa1ONsZmaGvLy8RncOzM/Ph6mpaasUpi6LFy9W6aUuLy+Hq6srrl0DOFKDiIiISPOUl7fP6IAWBedJkyZh5syZ+OKLLxAeHg4AOHXqFN58801Mnjy5VQtUsrGxgba2NgoKClTWFxQUwMHBocltHBwcmtUeAPT19aGvr99ovbHxnYWIiIiINEt73UKkRUM1vvjiC0yYMAFTp06Fu7s73N3dMX36dPzjH//AZ5991to1AgD09PQQHByMqKgocZ1CoUBUVBTCwsKa3CYsLEylPQAcPnz4nu2JiIiIiO6lRbNqKFVVVSErKwsA0L17dxgZGbVaYU355ZdfMG3aNPz4448ICQnBypUrsX37dqSmpsLe3h5Tp06Fs7Mzli9fDuDOdHRDhgzBp59+itGjR2Pbtm345JNPEB8fD39/f0mvyTsHEhEREWk2jb5zoJKRkREsLCzEr9vapEmTcOPGDSxZsgRyuRxBQUE4cOCAeAFgXl6eeDtwAAgPD8fWrVvx3nvv4Z133oG3tzd2794tOTQTERERESm1qMe5vr4eH3zwAb755htUVFQAAExMTDB//nwsXboUurq6rV6ourDHmYiIiEizaXSP8/z587Fr1y58/vnn4njh6OhoLFu2DMXFxfjhhx9atUgiIiIiInVrUY+zubk5tm3bhpEjR6qs379/PyZPntzmt95uT+xxJiIiItJs7ZXXWjSrhr6+Ptzd3Rut9/DwgJ6e3sPWRERERESkcVoUnOfNm4ePPvpI5dbUNTU1+PjjjzFv3rxWK46IiIiISFO0aIzz+fPnERUVBRcXFwQGBgIAEhISUFtbi2HDhmHChAli2127drVOpUREREREatSi4GxhYYGJEyeqrHN1dW2VgoiIiIiINFGLgvPGjRtbuw4iIiIiIo3WojHOt2/fRlVVlfj48uXLWLlyJQ4dOtRqhRERERERaZIWBedx48Zh8+bNAIDS0lKEhITgyy+/xLhx4ziHMxERERF1Si0KzvHx8Rg0aBAAYOfOnXBwcMDly5exefNmfPPNN61aIBERERGRJmhRcK6qqoKpqSkA4NChQ5gwYQK0tLQwYMAAXL58uVULJCIiIiLSBC0Kzl5eXti9ezfy8/Nx8OBBDB8+HABQWFjIu+sRERERUafUouC8ZMkSvPHGG3B3d0dISAjCwsIA3Ol97tOnT6sWSERERESkCWSCIAgt2VAul+P69esIDAyEltad/B0TEwMzMzP07NmzVYtUp/a69zkRERERtUx75bUW9TgDgIODA0xNTXH48GHcvn0bANC/f/9OFZqJiIiIiJRaFJyLi4sxbNgw9OjRA6NGjcL169cBADNnzsTrr7/eqgUSEREREWmCFgXnBQsWQFdXF3l5eTAyMhLXT5o0CQcOHGi14oiIiIiINEWLbrl96NAhHDx4EC4uLirrvb29OR0dEREREXVKLepxrqysVOlpViopKYG+vv5DF0VEREREpGlaFJwHDRok3nIbAGQyGRQKBT7//HNERES0WnFERERERJqiRUM1VqxYgUcffRTnzp1DbW0t3nrrLSQlJaGkpASnTp1q7RqJiIiIiNSu2cG5rq4Or7zyCvbt24fDhw/D1NQUFRUVmDBhAl5++WU4Ojq2RZ1ERERERGrV7OCsq6uLixcvwtLSEu+++25b1EREREREpHFaNMb52Wefxfr161u7FiIiIiIijdWiMc719fXYsGEDjhw5guDgYBgbG6s8/9VXX7VKcUREREREmqJFwTkxMRF9+/YFAKSnp6s8J5PJHr4qIiIiIiIN06LgfOzYsdaug4iIiIhIo7VojDMRERERUVfD4ExEREREJAGDMxERERGRBAzOREREREQSMDgTEREREUnA4ExEREREJAGDMxERERGRBAzOREREREQSMDgTEREREUnA4ExEREREJAGDMxERERGRBAzOREREREQSdJjgXFJSgilTpsDMzAwWFhaYOXMmKioq7tt+/vz58PHxgaGhIbp164ZXXnkFZWVl7Vg1EREREXUWHSY4T5kyBUlJSTh8+DB+++03/Pnnn5gzZ84921+7dg3Xrl3DF198gcTERGzatAkHDhzAzJkz27FqIiIiIuosZIIgCOou4kFSUlLQq1cvxMbGol+/fgCAAwcOYNSoUbhy5QqcnJwk7WfHjh149tlnUVlZCR0dHUnblJeXw9zcHGVlZTAzM2vxMRARERFR22ivvNYhepyjo6NhYWEhhmYAiIyMhJaWFs6ePSt5P8qTKTU0ExEREREpdYgEKZfLYWdnp7JOR0cHVlZWkMvlkvZRVFSEjz766L7DOwCgpqYGNTU14uPy8vLmF0xEREREnY5ae5wXLVoEmUx23yU1NfWhX6e8vByjR49Gr169sGzZsvu2Xb58OczNzcXF1dX1oV+fiIiIiDo+tfY4v/7665g+ffp923h6esLBwQGFhYUq6+vr61FSUgIHB4f7bn/r1i2MGDECpqam+PXXX6Grq3vf9osXL8bChQvFx+Xl5QzPRERERKTe4GxrawtbW9sHtgsLC0NpaSni4uIQHBwMADh69CgUCgVCQ0PvuV15eTkef/xx6OvrY+/evTAwMHjga+nr60NfX1/6QRARERFRl9AhLg709fXFiBEjMHv2bMTExODUqVOYN28enn76aXFGjatXr6Jnz56IiYkBcCc0Dx8+HJWVlVi/fj3Ky8shl8shl8vR0NCgzsMhIiIiog6oQ1wcCABbtmzBvHnzMGzYMGhpaWHixIn45ptvxOfr6uqQlpaGqqoqAEB8fLw444aXl5fKvnJycuDu7t5utRMRERFRx9ch5nFWJ87jTERERKTZOI8zEREREZEGYXAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKAwZmIiIiISAIGZyIiIiIiCTpMcC4pKcGUKVNgZmYGCwsLzJw5ExUVFZK2FQQBI0eOhEwmw+7du9u2UCIiIiLqlDpMcJ4yZQqSkpJw+PBh/Pbbb/jzzz8xZ84cSduuXLkSMpmsjSskIiIios5MR90FSJGSkoIDBw4gNjYW/fr1AwB8++23GDVqFL744gs4OTndc9sLFy7gyy+/xLlz5+Do6NheJRMRERFRJ9Mhepyjo6NhYWEhhmYAiIyMhJaWFs6ePXvP7aqqqvDMM8/gu+++g4ODg6TXqqmpQXl5ucpCRERERNQhgrNcLoednZ3KOh0dHVhZWUEul99zuwULFiA8PBzjxo2T/FrLly+Hubm5uLi6ura4biIiIiLqPNQanBctWgSZTHbfJTU1tUX73rt3L44ePYqVK1c2a7vFixejrKxMXPLz81v0+kRERETUuah1jPPrr7+O6dOn37eNp6cnHBwcUFhYqLK+vr4eJSUl9xyCcfToUWRlZcHCwkJl/cSJEzFo0CAcP368ye309fWhr68v9RCIiIiIqItQa3C2tbWFra3tA9uFhYWhtLQUcXFxCA4OBnAnGCsUCoSGhja5zaJFizBr1iyVdQEBAfj6668xZsyYhy+eiIiIiLqUDjGrhq+vL0aMGIHZs2djzZo1qKurw7x58/D000+LM2pcvXoVw4YNw+bNmxESEgIHB4cme6O7desGDw+P9j4EIiIiIurgOsTFgQCwZcsW9OzZE8OGDcOoUaMwcOBArF27Vny+rq4OaWlpqKqqUmOVRERERNRZyQRBENRdhCYrLy+Hubk5ysrKYGZmpu5yiIiIiOhv2iuvdZgeZyIiIiIidWJwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEgCBmciIiIiIgkYnImIiIiIJGBwJiIiIiKSgMGZiIiIiEiCDhOcS0pKMGXKFJiZmcHCwgIzZ85ERUXFA7eLjo7Go48+CmNjY5iZmWHw4MG4fft2O1RMRERERJ1JhwnOU6ZMQVJSEg4fPozffvsNf/75J+bMmXPfbaKjozFixAgMHz4cMTExiI2Nxbx586Cl1WEOm4iIiIg0hEwQBEHdRTxISkoKevXqhdjYWPTr1w8AcODAAYwaNQpXrlyBk5NTk9sNGDAAjz32GD766KMWv3Z5eTnMzc1RVlYGMzOzFu+HiIiIiNpGe+W1DtH1Gh0dDQsLCzE0A0BkZCS0tLRw9uzZJrcpLCzE2bNnYWdnh/DwcNjb22PIkCE4efLkfV+rpqYG5eXlKgsRERERUYcIznK5HHZ2dirrdHR0YGVlBblc3uQ22dnZAIBly5Zh9uzZOHDgAPr27Ythw4YhIyPjnq+1fPlymJubi4urq2vrHQgRERERdVhqDc6LFi2CTCa775KamtqifSsUCgDACy+8gBkzZqBPnz74+uuv4ePjgw0bNtxzu8WLF6OsrExc8vPzW/T6RERERNS56KjzxV9//XVMnz79vm08PT3h4OCAwsJClfX19fUoKSmBg4NDk9s5OjoCAHr16qWy3tfXF3l5efd8PX19fejr60uonoiIiIi6ErUGZ1tbW9ja2j6wXVhYGEpLSxEXF4fg4GAAwNGjR6FQKBAaGtrkNu7u7nByckJaWprK+vT0dIwcOfLhiyciIiKiLqVDjHH29fXFiBEjMHv2bMTExODUqVOYN28enn76aXFGjatXr6Jnz56IiYkBAMhkMrz55pv45ptvsHPnTmRmZuL9999HamoqZs6cqc7DISIiIqIOSK09zs2xZcsWzJs3D8OGDYOWlhYmTpyIb775Rny+rq4OaWlpqKqqEte99tprqK6uxoIFC1BSUoLAwEAcPnwY3bt3V8chEBEREVEH1iHmcVYnzuNMREREpNk4jzMRERERkQZhcCYiIiIikoDBmYiIiIhIAgZnIiIiIiIJGJyJiIiIiCRgcCYiIiIikoDBmYiIiIhIAgZnIiIiIiIJGJyJiIiIiCRgcCYiIiIikoDBmYiIiIhIAgZnIiIiIiIJGJyJiIiIiCRgcCYiIiIikoDBmYiIiIhIAgZnIiIiIiIJGJyJiIiIiCRgcCYiIiIikoDBmYiIiIhIAgZnIiIiIiIJGJyJiIiIiCRgcCYiIiIikoDBmYiIiIhIAgZnIiIiIiIJGJyJiIiIiCRgcCYiIiIikoDBmYiIiIhIAgZnIiIiIiIJGJyJiIiIiCRgcCYiIiIikoDBmYiIiIhIAgZnIiIiIiIJGJyJiIiIiCRgcCYiIiIikkBH3QVoOkEQAADl5eVqroSIiIiImqLMacrc1lYYnB+guLgYAODq6qrmSoiIiIjofoqLi2Fubt5m+2dwfgArKysAQF5eXpv+R3Qm5eXlcHV1RX5+PszMzNRdTofB89Z8PGctw/PWfDxnLcPz1nw8Zy1TVlaGbt26ibmtrTA4P4CW1p1h4Obm5nwDN5OZmRnPWQvwvDUfz1nL8Lw1H89Zy/C8NR/PWcsoc1ub7b9N905ERERE1EkwOBMRERERScDg/AD6+vpYunQp9PX11V1Kh8Fz1jI8b83Hc9YyPG/Nx3PWMjxvzcdz1jLtdd5kQlvP20FERERE1Amwx5mIiIiISAIGZyIiIiIiCRiciYiIiIgkYHAmIiIiIpKgywfnjz/+GOHh4TAyMoKFhYWkbQRBwJIlS+Do6AhDQ0NERkYiIyNDpU1JSQmmTJkCMzMzWFhYYObMmaioqGiDI1CP5h5fbm4uZDJZk8uOHTvEdk09v23btvY4pDbXkvfE0KFDG52PF198UaVNXl4eRo8eDSMjI9jZ2eHNN99EfX19Wx5Ku2rueSspKcH8+fPh4+MDQ0NDdOvWDa+88grKyspU2nWm99p3330Hd3d3GBgYIDQ0FDExMfdtv2PHDvTs2RMGBgYICAjA/v37VZ6X8jOuM2jOeVu3bh0GDRoES0tLWFpaIjIyslH76dOnN3pPjRgxoq0Po10155xt2rSp0fkwMDBQacP3WmNN/dyXyWQYPXq02Kazv9f+/PNPjBkzBk5OTpDJZNi9e/cDtzl+/Dj69u0LfX19eHl5YdOmTY3aNPdnZZOELm7JkiXCV199JSxcuFAwNzeXtM2nn34qmJubC7t37xYSEhKEsWPHCh4eHsLt27fFNiNGjBACAwOFM2fOCH/99Zfg5eUlTJ48uY2Oov019/jq6+uF69evqywffPCBYGJiIty6dUtsB0DYuHGjSru7z2tH1pL3xJAhQ4TZs2ernI+ysjLx+fr6esHf31+IjIwUzp8/L+zfv1+wsbERFi9e3NaH026ae94uXbokTJgwQdi7d6+QmZkpREVFCd7e3sLEiRNV2nWW99q2bdsEPT09YcOGDUJSUpIwe/ZswcLCQigoKGiy/alTpwRtbW3h888/F5KTk4X33ntP0NXVFS5duiS2kfIzrqNr7nl75plnhO+++044f/68kJKSIkyfPl0wNzcXrly5IraZNm2aMGLECJX3VElJSXsdUptr7jnbuHGjYGZmpnI+5HK5Shu+1xorLi5WOWeJiYmCtra2sHHjRrFNZ3+v7d+/X3j33XeFXbt2CQCEX3/99b7ts7OzBSMjI2HhwoVCcnKy8O233wra2trCgQMHxDbN/X+4ly4fnJU2btwoKTgrFArBwcFBWLFihbiutLRU0NfXF37++WdBEAQhOTlZACDExsaKbf744w9BJpMJV69ebfXa21trHV9QUJDw/PPPq6yT8g3SEbX0nA0ZMkR49dVX7/n8/v37BS0tLZVfRj/88INgZmYm1NTUtErt6tRa77Xt27cLenp6Ql1dnbius7zXQkJChJdffll83NDQIDg5OQnLly9vsv0///lPYfTo0SrrQkNDhRdeeEEQBGk/4zqD5p63v6uvrxdMTU2Fn376SVw3bdo0Ydy4ca1dqsZo7jl70O9Vvtekvde+/vprwdTUVKioqBDXdfb32t2k/Kx+6623BD8/P5V1kyZNEh5//HHx8cP+Pyh1+aEazZWTkwO5XI7IyEhxnbm5OUJDQxEdHQ0AiI6OhoWFBfr16ye2iYyMhJaWFs6ePdvuNbe21ji+uLg4XLhwATNnzmz03MsvvwwbGxuEhIRgw4YNEDrBVOMPc862bNkCGxsb+Pv7Y/HixaiqqlLZb0BAAOzt7cV1jz/+OMrLy5GUlNT6B9LOWut7qaysDGZmZtDR0VFZ39Hfa7W1tYiLi1P5eaSlpYXIyEjx59HfRUdHq7QH7rxnlO2l/Izr6Fpy3v6uqqoKdXV1sLKyUll//Phx2NnZwcfHB3PnzkVxcXGr1q4uLT1nFRUVcHNzg6urK8aNG6fyc4nvNWnHuH79ejz99NMwNjZWWd9Z32st8aCfa63x/6Ck8+AmdDe5XA4AKkFF+Vj5nFwuh52dncrzOjo6sLKyEtt0ZK1xfOvXr4evry/Cw8NV1n/44Yd49NFHYWRkhEOHDuGll15CRUUFXnnllVarXx1aes6eeeYZuLm5wcnJCRcvXsTbb7+NtLQ07Nq1S9xvU+9F5XMdXWu814qKivDRRx9hzpw5Kus7w3utqKgIDQ0NTb4HUlNTm9zmXu+Zu39+Kdfdq01H15Lz9ndvv/02nJycVH4RjxgxAhMmTICHhweysrLwzjvvYOTIkYiOjoa2tnarHkN7a8k58/HxwYYNG9C7d2+UlZXhiy++QHh4OJKSkuDi4sL3moT3WkxMDBITE7F+/XqV9Z35vdYS9/q5Vl5ejtu3b+PmzZsP/T2v1CmD86JFi/DZZ5/dt01KSgp69uzZThV1DFLP28O6ffs2tm7divfff7/Rc3ev69OnDyorK7FixQqNDTNtfc7uDnsBAQFwdHTEsGHDkJWVhe7du7d4v+rWXu+18vJyjB49Gr169cKyZctUnuto7zXSHJ9++im2bduG48ePq1zs9vTTT4tfBwQEoHfv3ujevTuOHz+OYcOGqaNUtQoLC0NYWJj4ODw8HL6+vvjxxx/x0UcfqbGyjmP9+vUICAhASEiIynq+19SnUwbn119/HdOnT79vG09Pzxbt28HBAQBQUFAAR0dHcX1BQQGCgoLENoWFhSrb1dfXo6SkRNxeE0k9bw97fDt37kRVVRWmTp36wLahoaH46KOPUFNT0+b3n2+J9jpnSqGhoQCAzMxMdO/eHQ4ODo2uCi4oKACALv9eu3XrFkaMGAFTU1P8+uuv0NXVvW97TX+vNcXGxgba2tri/7lSQUHBPc+Pg4PDfdtL+RnX0bXkvCl98cUX+PTTT3HkyBH07t37vm09PT1hY2ODzMzMDh9mHuacKenq6qJPnz7IzMwEwPfag85bZWUltm3bhg8//PCBr9OZ3mstca+fa2ZmZjA0NIS2tvZDv39FzRoR3Yk19+LAL774QlxXVlbW5MWB586dE9scPHiw010c2NLjGzJkSKMZDu7lX//6l2BpadniWjVFa70nTp48KQAQEhISBEH4v4sD774q+McffxTMzMyE6urq1jsANWnpeSsrKxMGDBggDBkyRKisrJT0Wh31vRYSEiLMmzdPfNzQ0CA4Ozvf9+LAJ554QmVdWFhYo4sD7/czrjNo7nkTBEH47LPPBDMzMyE6OlrSa+Tn5wsymUzYs2fPQ9erCVpyzu5WX18v+Pj4CAsWLBAEge+1B523jRs3Cvr6+kJRUdEDX6OzvdfuBokXB/r7+6usmzx5cqOLAx/m/SvW06zWndDly5eF8+fPi1OjnT9/Xjh//rzKFGk+Pj7Crl27xMeffvqpYGFhIezZs0e4ePGiMG7cuCano+vTp49w9uxZ4eTJk4K3t3enm47ufsd35coVwcfHRzh79qzKdhkZGYJMJhP++OOPRvvcu3evsG7dOuHSpUtCRkaG8P333wtGRkbCkiVL2vx42kNzz1lmZqbw4YcfCufOnRNycnKEPXv2CJ6ensLgwYPFbZTT0Q0fPly4cOGCcODAAcHW1rbTTUfXnPNWVlYmhIaGCgEBAUJmZqbKdE319fWCIHSu99q2bdsEfX19YdOmTUJycrIwZ84cwcLCQpxp5bnnnhMWLVoktj916pSgo6MjfPHFF0JKSoqwdOnSJqeje9DPuI6uueft008/FfT09ISdO3eqvKeUvytu3bolvPHGG0J0dLSQk5MjHDlyROjbt6/g7e3dKf6IFYTmn7MPPvhAOHjwoJCVlSXExcUJTz/9tGBgYCAkJSWJbfhea3zelAYOHChMmjSp0fqu8F67deuWmMcACF999ZVw/vx54fLly4IgCMKiRYuE5557TmyvnI7uzTffFFJSUoTvvvuuyeno7vf/IFWXD87Tpk0TADRajh07JrbB/5/vVUmhUAjvv/++YG9vL+jr6wvDhg0T0tLSVPZbXFwsTJ48WTAxMRHMzMyEGTNmqITxju5Bx5eTk9PoPAqCICxevFhwdXUVGhoaGu3zjz/+EIKCggQTExPB2NhYCAwMFNasWdNk246ouecsLy9PGDx4sGBlZSXo6+sLXl5ewptvvqkyj7MgCEJubq4wcuRIwdDQULCxsRFef/11lWnXOrrmnrdjx441+T0NQMjJyREEofO917799luhW7dugp6enhASEiKcOXNGfG7IkCHCtGnTVNpv375d6NGjh6Cnpyf4+fkJv//+u8rzUn7GdQbNOW9ubm5NvqeWLl0qCIIgVFVVCcOHDxdsbW0FXV1dwc3NTZg9e3azfylruuacs9dee01sa29vL4waNUqIj49X2R/fa01/j6ampgoAhEOHDjXaV1d4r93r57jyPE2bNk0YMmRIo22CgoIEPT09wdPTUyW3Kd3v/0EqmSB0sPmXiIiIiIjUgPM4ExERERFJwOBMRERERCQBgzMRERERkQQMzkREREREEjA4ExERERFJwOBMRERERCQBgzMRERERkQQMzkREREREEjA4ExERERFJwOBMRERERCQBgzMRURdx4MABDBw4EBYWFrC2tsYTTzyBrKwsdZdFRNRhMDgTEXURlZWVWLhwIc6dO4eoqChoaWnhySefhEKhUHdpREQdgkwQBEHdRRARUfsrKiqCra0tLl26BH9/f3WXQ0Sk8djjTETURWRkZGDy5Mnw9PSEmZkZ3N3dAQB5eXnqLYyIqIPQUXcBRETUPsaMGQM3NzesW7cOTk5OUCgU8Pf3R21trbpLIyLqEBiciYi6gOLiYqSlpWHdunUYNGgQAODkyZNqroqIqGNhcCYi6gIsLS1hbW2NtWvXwtHREXl5eVi0aJG6yyIi6lA4xpmIqAvQ0tLCtm3bEBcXB39/fyxYsAArVqxQd1lERB0KZ9UgIiIiIpKAPc5ERERERBIwOBMRERERScDgTEREREQkAYMzEREREZEEDM5ERERERBIwOBMRERERScDgTEREREQkAYMzEREREZEEDM5ERERERBIwOBMRERERScDgTEREREQkAYMzEREREZEE/w/dZ40G2Ng5kwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pyqsp\n", + "from pyqsp.angle_sequence import QuantumSignalProcessingPhases\n", + "\n", + "\n", + "def get_qsvt_phases(poly, plot=False):\n", + " np.random.seed(1) # set seed as pyqsp does not allow it, and not always converges\n", + " ang_seq = QuantumSignalProcessingPhases(\n", + " poly,\n", + " signal_operator=\"Wx\",\n", + " method=\"laurent\",\n", + " measurement=\"x\",\n", + " tolerance=0.000001, # relaxing the tolerance to get convergence\n", + " )\n", + " if plot:\n", + " pyqsp.response.PlotQSPResponse(\n", + " ang_seq, target=poly, signal_operator=\"Wx\", measurement=\"x\"\n", + " )\n", + " # change W(x) to R(x), as the phases are in the W(x) conventions\n", + " phases = np.array(ang_seq)\n", + " phases[1:-1] = phases[1:-1] - np.pi / 2\n", + " phases[0] = phases[0] - np.pi / 4\n", + " phases[-1] = phases[-1] + (2 * (len(phases) - 1) - 1) * np.pi / 4\n", + "\n", + " # verify conventions. minus is due to exp(-i*phi*z) in qsvt in comparison to qsp\n", + " phases = -2 * phases\n", + "\n", + " return phases.tolist()\n", + "\n", + "\n", + "phases_sinh = get_qsvt_phases(poly_sinh, plot=True)\n", + "phases_cosh = get_qsvt_phases(poly_cosh, plot=True)" + ] + }, + { + "cell_type": "markdown", + "id": "9aa6ef81-48f0-4357-988d-0cb74a7d84fd", + "metadata": {}, + "source": [ + "Lastly, we use the phases within the `qsvt_lcu` function, which is an optimized function for implementing a linear combination of 2 qsvt sequences:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "46bf656c-15df-4435-a16e-cfd78a859b4d", + "metadata": {}, + "outputs": [], + "source": [ + "class MagnusBE(QStruct):\n", + " time_dependent: TimeDependentBE\n", + " qsvt_exp_aux: QBit\n", + " qsvt_exp_lcu: QBit\n", + "\n", + "\n", + "@qfunc\n", + "def short_time_magnus(a: CReal, b: CReal, qbe_st: MagnusBE):\n", + " # compute the coefficient of the expoenent\n", + " timeslice_duration = (END_TIME - START_TIME) / NUM_LONG_SLICES\n", + " sinh_polynomnial = get_sinh_poly(timeslice_duration, DEGREE_EXP)\n", + " cosh_polynomnial = get_cosh_poly(timeslice_duration, DEGREE_EXP - 1)\n", + "\n", + " # apply LCU to combine sinh((b-a)x)/(2exp(b-a)) and cosh((b-a)x)/(2exp(b-a)) to exp((b-a)x)/(2exp(b-a))\n", + " within_apply(\n", + " lambda: H(qbe_st.qsvt_exp_lcu),\n", + " lambda: qsvt_lcu(\n", + " get_qsvt_phases(cosh_polynomnial),\n", + " get_qsvt_phases(sinh_polynomnial),\n", + " time_dependent_projector,\n", + " time_dependent_projector,\n", + " lambda x: short_time_summation(a, b, x),\n", + " qbe_st.time_dependent,\n", + " qbe_st.qsvt_exp_aux,\n", + " qbe_st.qsvt_exp_lcu,\n", + " ),\n", + " )\n", + "\n", + "\n", + "def magnus_predicate(qbe: MagnusBE):\n", + " return logical_and(\n", + " time_dependent_predicate(qbe.time_dependent),\n", + " logical_and(qbe.qsvt_exp_aux == 0, qbe.qsvt_exp_lcu == 0),\n", + " )\n", + "\n", + "\n", + "@qfunc\n", + "def magnus_projector(qbe: MagnusBE, is_in_block: QBit):\n", + " is_in_block ^= magnus_predicate(qbe)" + ] + }, + { + "cell_type": "markdown", + "id": "04925111-04af-401b-8d10-b48b457442cc", + "metadata": {}, + "source": [ + "### Amplification of a single long timesteps" + ] + }, + { + "cell_type": "markdown", + "id": "f9c344fa-d1bf-4a1f-a7e6-466e1184822b", + "metadata": {}, + "source": [ + "As the climax of the algorithm, we wrap the magnus evolution by an amplification step. The prefactor of the exponential block-encoding is 2, so we want to approximate the function $f(x)=2x$ in the interval $[0, \\frac{1}{2}]$." + ] + }, + { + "cell_type": "markdown", + "id": "d2134523-b7be-4e06-9ad8-3099a19b8bdd", + "metadata": {}, + "source": [ + "#### singular value amplification ($\\gamma x$)\n", + "\n", + "We follow the paper's approach, and do a minmax optimization:\n", + "Complete to an odd function. To approximate an odd target function using an odd polynomial of degree $ d $, the target function can be expressed as:\n", + "$$\n", + "F(x) = \\sum_{k=0}^{(d-1)/2} c_k T_{2k+1}(x),\n", + "$$\n", + "where $ T_{2k+1}(x) $ are Chebyshev polynomials of odd degrees, and $ c_k $ are unknown coefficients.\n", + "\n", + "To formulate this as a discrete optimization problem, we discretize $[-1, 1]$ using $ M $ grid points:\n", + "$$\n", + "x_j = -\\cos\\left(\\frac{j \\pi}{M-1}\\right), \\quad j = 0, \\ldots, M-1.\n", + "$$\n", + "\n", + "The coefficient matrix is defined as:\n", + "$$\n", + "A_{jk} = T_{2k+1}(x_j), \\quad k = 0, \\ldots, \\frac{d-1}{2}.\n", + "$$\n", + "\n", + "The coefficients can then be found by solving the following convex optimization problem:\n", + "$$\n", + "\\min_{\\{c_k\\}} \\left( \\max_{x_j \\in [0, 1]} \\left| F(x_j) - (1 - \\epsilon)x_j \\right| \\right),\n", + "$$\n", + "subject to:\n", + "$$\n", + "F(x_j) = \\sum_k A_{jk} c_k, \\quad |F(x_j)| \\leq c, \\quad \\forall j = 0, \\ldots, M-1.\n", + "$$\n", + "Here, $ c $ is a relaxation parameter, chosen as:\n", + "$$\n", + "c = \\max(0.9999, 1 - 0.1\\epsilon).\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "39c61614-b9a1-41c6-8c3c-a117484933ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Polynomial in monomial basis: 0.0 + 1.7541331417527408·x¹ + 0.0·x² + 4.248403900299232·x³ + 0.0·x⁴ -\n", + "16.095040821329768·x⁵ + 0.0·x⁶ + 9.09251379092624·x⁷\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import cvxpy as cp\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from numpy.polynomial.chebyshev import Chebyshev\n", + "from numpy.polynomial.polynomial import Polynomial\n", + "\n", + "\n", + "def optimize_amplification_polynomial(gamma, degree, epsilon=0.0001, M=1000):\n", + " # Discretize [-1, 1] using M grid points (interpolants)\n", + " xj_full = np.cos(np.pi * np.arange(M) / (M - 1)) # Chebyshev nodes on [-1, 1]\n", + "\n", + " # Select grid points for the objective in [0, 1/gamma]\n", + " xj_obj = xj_full[np.abs(xj_full) <= 1 / gamma]\n", + "\n", + " # Define the Chebyshev polynomials of odd degrees\n", + " k_max = (degree - 1) // 2\n", + " T_matrix_full = np.array(\n", + " [\n", + " [np.cos((2 * k + 1) * np.arccos(x)) for k in range(k_max + 1)]\n", + " for x in xj_full\n", + " ]\n", + " )\n", + " T_matrix_obj = np.array(\n", + " [[np.cos((2 * k + 1) * np.arccos(x)) for k in range(k_max + 1)] for x in xj_obj]\n", + " )\n", + "\n", + " # Define optimization variables\n", + " c = cp.Variable(k_max + 1) # Coefficients for Chebyshev polynomials\n", + " F_values_full = T_matrix_full @ c # Values for constraints\n", + " F_values_obj = T_matrix_obj @ c # Values for the objective function\n", + "\n", + " # Relaxed constraint\n", + " c_max = max(0.9999, 1 - 0.1 * epsilon)\n", + "\n", + " # Define the optimization problem\n", + " objective = cp.Minimize(\n", + " cp.max(cp.abs(F_values_obj - (1 - epsilon) * gamma * xj_obj))\n", + " )\n", + " constraints = [cp.abs(F_values_full) <= c_max]\n", + " prob = cp.Problem(objective, constraints)\n", + "\n", + " # Solve the optimization problem\n", + " prob.solve()\n", + "\n", + " # Return coefficients, optimal value, and grid points\n", + " return c.value, prob.value\n", + "\n", + "\n", + "# Convert Chebyshev coefficients to monomial basis\n", + "def chebyshev_to_monomial(odd_coefficients):\n", + " # Create a full Chebyshev coefficient array with zeros for even terms\n", + " full_coefficients = np.zeros(\n", + " 2 * len(odd_coefficients)\n", + " ) # Double the size for even terms\n", + " full_coefficients[1::2] = (\n", + " odd_coefficients # Fill only odd indices with given coefficients\n", + " )\n", + "\n", + " # Create the Chebyshev polynomial\n", + " cheb_poly = Chebyshev(full_coefficients, domain=[-1, 1])\n", + " # Convert to monomial basis\n", + " monomial_poly = cheb_poly.convert(kind=Polynomial)\n", + " return monomial_poly\n", + "\n", + "\n", + "def plot_amplification_polynomial(gamma, epsilon, poly):\n", + " # Generate data for plotting\n", + " x_vals = np.linspace(-1, 1, 500)\n", + " xj_obj = x_vals[np.abs(x_vals) <= 1 / gamma]\n", + " target_vals = (1 - epsilon) * gamma * xj_obj\n", + " approx_vals = poly(x_vals)\n", + "\n", + " # Plot the results\n", + " plt.figure(figsize=(8, 6))\n", + " plt.plot(xj_obj, target_vals, label=\"Target Function\", color=\"blue\", linewidth=2)\n", + " plt.plot(\n", + " x_vals,\n", + " approx_vals,\n", + " label=\"Approximated Polynomial\",\n", + " color=\"red\",\n", + " linestyle=\"--\",\n", + " )\n", + " plt.xlabel(\"x\")\n", + " plt.ylabel(\"F(x)\")\n", + " plt.title(\"Target Function vs. Approximated Polynomial\")\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + "\n", + "def get_amplification_polynomial(gamma, degree, epsilon=0.0001, plot=False):\n", + " # Perform approximation\n", + " coefficients, optimal_value = optimize_amplification_polynomial(\n", + " gamma, degree, epsilon=epsilon\n", + " )\n", + " # Convert the approximated polynomial to monomial basis\n", + " poly_amp = chebyshev_to_monomial(coefficients)\n", + "\n", + " if plot:\n", + " print(\"Polynomial in monomial basis:\", poly_amp)\n", + " plot_amplification_polynomial(gamma, epsilon, poly_amp)\n", + " return poly_amp\n", + "\n", + "\n", + "DEGREE_AMP = 7\n", + "GAMMA = 2\n", + "poly_amp = get_amplification_polynomial(GAMMA, DEGREE_AMP, plot=True)\n", + "phases_amp = get_qsvt_phases(poly_amp, plot=True)" + ] + }, + { + "cell_type": "markdown", + "id": "dd0f514b-294e-448d-a258-cee175edfa84", + "metadata": {}, + "source": [ + "Then apply the phases on the magnus block encoding:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8630831a-6f13-459b-863b-fbfa5b3f4de6", + "metadata": {}, + "outputs": [], + "source": [ + "class LongSliceBE(QStruct):\n", + " magnus: MagnusBE\n", + " qsvt_amplification_aux: QBit\n", + "\n", + "\n", + "@qfunc\n", + "def long_slice_evolution(a: CReal, b: CReal, qbe: LongSliceBE):\n", + " amplification_polynomial = get_amplification_polynomial(gamma=2, degree=DEGREE_AMP)\n", + " qsvt(\n", + " get_qsvt_phases(amplification_polynomial),\n", + " magnus_projector,\n", + " magnus_projector,\n", + " lambda x: short_time_magnus(a, b, x),\n", + " qbe.magnus,\n", + " qbe.qsvt_amplification_aux,\n", + " )\n", + "\n", + "\n", + "def long_slice_predicate(qbe: LongSliceBE):\n", + " return logical_and(magnus_predicate(qbe.magnus), qbe.qsvt_amplification_aux == 0)" + ] + }, + { + "cell_type": "markdown", + "id": "dfe76a47-58bb-4df1-a5e5-ba5567859afa", + "metadata": {}, + "source": [ + "### Long time Evolution\n", + "\n", + "Last thing to do is to sequentially apply the block encodings of each timeslice. In order to have a quantum variable that will be $|0\\rangle$ when all the block encodings are applied to the state, a counter is used. A further amplitude amplification step is possible using the counter, however we won't do it here." + ] + }, + { + "attachments": { + "e824cc45-63fb-4c39-b7b5-43ab92abe80c.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "id": "4123358a-ac74-4380-bcba-f6417d115e90", + "metadata": {}, + "source": [ + "![image.png](attachment:e824cc45-63fb-4c39-b7b5-43ab92abe80c.png)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "796adad3-f936-484e-8f23-bfbc977b8d1c", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://platform.classiq.io/circuit/b49040bd-929d-4cd4-81e0-c993d7eb3e21?version=0.63.0\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "from classiq.execution import *\n", + "\n", + "\n", + "class FullBE(QStruct):\n", + " time_slice: LongSliceBE\n", + " counter: QNum[np.ceil(np.log2(NUM_LONG_SLICES + 1))]\n", + "\n", + "\n", + "@qfunc\n", + "def long_time_integrator_step(a: CReal, b: CReal, qbe_full: FullBE):\n", + " long_slice_evolution(a, b, qbe_full.time_slice)\n", + " # if in block, decrement the counter\n", + " control(\n", + " long_slice_predicate(qbe_full.time_slice),\n", + " lambda: inplace_add(-1, qbe_full.counter),\n", + " )\n", + "\n", + "\n", + "@qfunc\n", + "def long_time_integrator(\n", + " T: CReal, num_slices: CInt, qbe_full: FullBE # start from time 0\n", + "):\n", + " inplace_prepare_int(num_slices, qbe_full.counter)\n", + " repeat(\n", + " num_slices,\n", + " lambda i: long_time_integrator_step(\n", + " i * T / num_slices, (i + 1) * T / num_slices, qbe_full\n", + " ),\n", + " )\n", + "\n", + "\n", + "@qfunc\n", + "def main(qbe: Output[FullBE]):\n", + " allocate(qbe.size, qbe)\n", + "\n", + " # initial condition: uniform distribution\n", + " hadamard_transform(qbe.time_slice.magnus.time_dependent.index)\n", + " long_time_integrator(END_TIME, NUM_LONG_SLICES, qbe)\n", + "\n", + "\n", + "prefereces = Preferences(optimization_level=0)\n", + "execution_preferences = ExecutionPreferences(num_shots=1000000)\n", + "qmod = create_model(\n", + " main,\n", + " preferences=prefereces,\n", + " execution_preferences=execution_preferences,\n", + " out_file=\"time_marching\",\n", + ")\n", + "qprog = synthesize(qmod)\n", + "show(qprog)\n", + "res = execute(qprog).get_sample_result()" + ] + }, + { + "cell_type": "markdown", + "id": "718d462f-d80a-49d7-8478-0847c733c1e9", + "metadata": {}, + "source": [ + "### Compare to the naive case: without uniform amplification\n", + "\n", + "Here we don't use the amplification step. We should see that the measured amplitudes will be much smaller than in the amplified case." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c6b4387f-acdf-4bb9-877c-79da9751ce94", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://platform.classiq.io/circuit/8a6c1af8-0cd1-4e54-9807-2cdf0f08a56a?version=0.63.0\n" + ] + } + ], + "source": [ + "@qfunc\n", + "def long_time_integrator_step_naive(a: CReal, b: CReal, qbe_full: FullBE):\n", + " short_time_magnus(a, b, qbe_full.time_slice.magnus)\n", + " # if in block, decrement the counter\n", + " control(\n", + " magnus_predicate(qbe_full.time_slice.magnus),\n", + " lambda: inplace_add(-1, qbe_full.counter),\n", + " )\n", + "\n", + "\n", + "@qfunc\n", + "def long_time_integrator_naive(\n", + " T: CReal, num_slices: CInt, qbe_full: FullBE # start from time 0\n", + "):\n", + " inplace_prepare_int(num_slices, qbe_full.counter)\n", + " repeat(\n", + " num_slices,\n", + " lambda i: long_time_integrator_step_naive(\n", + " i * T / num_slices, (i + 1) * T / num_slices, qbe_full\n", + " ),\n", + " )\n", + "\n", + "\n", + "@qfunc\n", + "def main(qbe: Output[FullBE]):\n", + " allocate(qbe.size, qbe)\n", + " # initial condition: uniform distribution\n", + " hadamard_transform(qbe.time_slice.magnus.time_dependent.index)\n", + " long_time_integrator_naive(END_TIME, NUM_LONG_SLICES, qbe)\n", + "\n", + "\n", + "qmod_naive = create_model(\n", + " main, preferences=prefereces, execution_preferences=execution_preferences\n", + ")\n", + "qprog_naive = synthesize(qmod_naive)\n", + "show(qprog_naive)\n", + "res_naive = execute(qprog_naive).get_sample_result()" + ] + }, + { + "cell_type": "markdown", + "id": "67c689c9-4d32-49da-8243-ad82d9686de0", + "metadata": {}, + "source": [ + "### Post-processing" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b5e6506d-7982-4cf0-b011-332f57ef1101", + "metadata": {}, + "outputs": [], + "source": [ + "def post_process_res_statevector(result):\n", + " filtered_samples = [\n", + " s\n", + " for s in result.parsed_state_vector\n", + " if s.state[\"qbe\"][\"counter\"] == 0 and np.abs(s.amplitude) > 1e-6\n", + " ]\n", + " global_phase = np.exp(1j * np.angle(filtered_samples[0].amplitude))\n", + " amplitudes = np.zeros(2**DIM_SIZE)\n", + " for sample in filtered_samples:\n", + " index = sample.state[\"qbe\"][\"time_slice\"][\"magnus\"][\"time_dependent\"][\"index\"]\n", + " amplitudes[index] = np.real(sample.amplitude / global_phase)\n", + " return amplitudes\n", + "\n", + "\n", + "def post_process_res_samples(result):\n", + " filtered_samples = [s for s in result.parsed_counts if s.state[\"qbe\"].counter == 0]\n", + " probs = np.zeros(2**DIM_SIZE)\n", + " for sample in filtered_samples:\n", + " index = sample.state[\"qbe\"].time_slice.magnus.time_dependent.index\n", + " probs[index] += sample.shots / result.num_shots\n", + " return np.sqrt(probs)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e2277b25-c651-4795-b9b2-97616337b0eb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "amplified amplitudes: [0.18801862 0.03464102 0.00994987 0.01857418]\n", + "naive amplitudes: [0.01131371 0.00244949 0. 0.00141421]\n", + "classical: [2.48301135 0.49650918 0.18886598 0.33261086]\n" + ] + } + ], + "source": [ + "amplitudes_amplified = post_process_res_samples(res)\n", + "print(\"amplified amplitudes:\", amplitudes_amplified)\n", + "\n", + "amplitudes_naive = post_process_res_samples(res_naive)\n", + "print(\"naive amplitudes:\", amplitudes_naive)\n", + "\n", + "print(\"classical:\", classical_final)" + ] + }, + { + "cell_type": "markdown", + "id": "3a40663a-4d36-4357-a6b9-f7e4b5dff861", + "metadata": {}, + "source": [ + "And indeed we can see the the naive amplitudes are order of magnitude smaller than the amplified case (this is exactly what we expect for 4 timesteps)." + ] + }, + { + "cell_type": "markdown", + "id": "10776c12-6069-46b9-920d-34f0cb5f552a", + "metadata": {}, + "source": [ + "### Compare classical and quantum results at the final step:" + ] + }, + { + "cell_type": "markdown", + "id": "2f788f9c-dd78-4c95-9265-4feb600c6e19", + "metadata": {}, + "source": [ + "Verify that the classical and quantum solutions are equivalent:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ffe3fe23-513c-49e1-a353-08dfef276231", + "metadata": {}, + "outputs": [], + "source": [ + "expected = classical_final / np.linalg.norm(classical_final)\n", + "sampled = amplitudes_amplified / np.linalg.norm(amplitudes_amplified)\n", + "assert np.linalg.norm(sampled - expected) < 0.1" + ] + }, + { + "cell_type": "markdown", + "id": "91d3f0ef-c250-49a6-9a69-bb1ccfe439c5", + "metadata": {}, + "source": [ + "# References" + ] + }, + { + "cell_type": "markdown", + "id": "6bfaad36-6d6f-4791-b916-85730894e78d", + "metadata": {}, + "source": [ + "[1]: [Fang, Di, Lin, Lin, and Tong, Yu. Time-marching based quantum solvers for time-dependent linear differential equations. Quantum 7, 955 (2023).](https://doi.org/10.22331/q-2023-03-20-955)\n", + "\n", + "[2]: [M. Kieferov a, A. Scherer, and D. W. Berry. Simulating the dynamics of timedependent\n", + "Hamiltonians with a truncated Dyson series. Phys. Rev. A, 99(4), apr\n", + "2019](https://arxiv.org/abs/1805.00582)\n", + "\n", + "[3]: [Magnus Expansion (Wikipedia)](https://en.wikipedia.org/wiki/Magnus_expansion)\n", + "\n", + "[4]: [Berry, Dominic W., et al. \"Exponential improvement in precision for simulating sparse Hamiltonians.\" Proceedings of the forty-sixth annual ACM symposium on Theory of computing. 2014.](https://dl.acm.org/doi/abs/10.1145/2591796.2591854)\n", + "\n", + "\n", + "[5]: [A. Gily en, Y. Su, G. H. Low, and N. Wiebe. Quantum singular value transformation and\n", + "beyond: exponential improvements for quantum matrix arithmetics. In Proc. 51st Annu.\n", + "ACM SIGACT Symp. Theory Comput., pages 193{204, 2019.](https://dl.acm.org/doi/10.1145/3313276.3316366)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/algorithms/differential_equations/time_marching/time_marching.metadata.json b/algorithms/differential_equations/time_marching/time_marching.metadata.json new file mode 100644 index 000000000..7f76804fb --- /dev/null +++ b/algorithms/differential_equations/time_marching/time_marching.metadata.json @@ -0,0 +1,7 @@ +{ + "friendly_name": "Time Marching Based Quantum Solver", + "description": "Solving time-dependent linear equations using a Time-Marching based strategy and QSVT", + "problem_domain_tags": ["linear equation"], + "qmod_type": ["algorithms"], + "level": ["advanced"] +} diff --git a/algorithms/differential_equations/time_marching/time_marching.qmod b/algorithms/differential_equations/time_marching/time_marching.qmod new file mode 100644 index 000000000..a8ccaf87c --- /dev/null +++ b/algorithms/differential_equations/time_marching/time_marching.qmod @@ -0,0 +1,106 @@ +qstruct TimeDependentBE { + index: qnum<2>; + time: qnum<2>; + block: qbit; +} + +qstruct MagnusBE { + time_dependent: TimeDependentBE; + qsvt_exp_aux: qbit; + qsvt_exp_lcu: qbit; +} + +qstruct LongSliceBE { + magnus: MagnusBE; + qsvt_amplification_aux: qbit; +} + +qstruct FullBE { + time_slice: LongSliceBE; + counter: qnum<3.0>; +} + +qfunc magnus_projector(qbe: MagnusBE, is_in_block: qbit) { + is_in_block ^= ((qbe.time_dependent.block == 0) and (qbe.time_dependent.time == 0)) and ((qbe.qsvt_exp_aux == 0) and (qbe.qsvt_exp_lcu == 0)); +} + +qfunc time_dependent_projector(qbe: TimeDependentBE, is_in_block: qbit) { + is_in_block ^= (qbe.block == 0) and (qbe.time == 0); +} + +qfunc block_encode_time_dependent_A(a: real, b: real, qbe: TimeDependentBE) { + linear_pauli_rotations([Pauli::Y], [ + (((b - a) * 2) / (2 ** qbe.time.size)) + ], [(2 * a)], qbe.time, qbe.block); + linear_pauli_rotations([Pauli::Y], [2], [0], qbe.index, qbe.block); +} + +qfunc short_time_summation(a: real, b: real, qbe: TimeDependentBE) { + within { + hadamard_transform(qbe.time); + } apply { + block_encode_time_dependent_A(a, b, qbe); + } +} + +qfunc short_time_magnus(a: real, b: real, qbe_st: MagnusBE) { + within { + H(qbe_st.qsvt_exp_lcu); + } apply { + qsvt_lcu([ + 4.7085, + 3.0195, + 0.0547, + 4.7904, + 0.0547, + 3.0195, + (-17.2827) + ], [ + 4.5651, + 0.2495, + 6.6887, + (-0.1862), + 6.097, + 0.4056, + 0.2495, + (-20.5676) + ], time_dependent_projector, time_dependent_projector, lambda(x) { + short_time_summation(a, b, x); + }, qbe_st.time_dependent, qbe_st.qsvt_exp_aux, qbe_st.qsvt_exp_lcu); + } +} + +qfunc long_slice_evolution(a: real, b: real, qbe: LongSliceBE) { + qsvt([ + 4.1801, + 2.3715, + 4.6112, + 4.5273, + (-1.7559), + 4.6112, + 8.6546, + (-20.9526) + ], magnus_projector, magnus_projector, lambda(x) { + short_time_magnus(a, b, x); + }, qbe.magnus, qbe.qsvt_amplification_aux); +} + +qfunc long_time_integrator_step(a: real, b: real, qbe_full: FullBE) { + long_slice_evolution(a, b, qbe_full.time_slice); + control ((((qbe_full.time_slice.magnus.time_dependent.block == 0) and (qbe_full.time_slice.magnus.time_dependent.time == 0)) and ((qbe_full.time_slice.magnus.qsvt_exp_aux == 0) and (qbe_full.time_slice.magnus.qsvt_exp_lcu == 0))) and (qbe_full.time_slice.qsvt_amplification_aux == 0)) { + qbe_full.counter += -1; + } +} + +qfunc long_time_integrator(T: real, num_slices: int, qbe_full: FullBE) { + inplace_prepare_int(num_slices, qbe_full.counter); + repeat (i: num_slices) { + long_time_integrator_step((i * T) / num_slices, ((i + 1) * T) / num_slices, qbe_full); + } +} + +qfunc main(output qbe: FullBE) { + allocate(qbe.size, qbe); + hadamard_transform(qbe.time_slice.magnus.time_dependent.index); + long_time_integrator(2, 4, qbe); +} diff --git a/algorithms/differential_equations/time_marching/time_marching.synthesis_options.json b/algorithms/differential_equations/time_marching/time_marching.synthesis_options.json new file mode 100644 index 000000000..ee427b44a --- /dev/null +++ b/algorithms/differential_equations/time_marching/time_marching.synthesis_options.json @@ -0,0 +1,44 @@ +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "cx", + "u2", + "y", + "ry", + "t", + "rx", + "cy", + "r", + "sxdg", + "cz", + "tdg", + "x", + "sdg", + "u1", + "u", + "h", + "sx", + "z", + "p", + "id", + "s", + "rz" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "optimization_level": 0, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": 590453799 + } +} diff --git a/algorithms/dqi/dqi_max_xorsat.ipynb b/algorithms/dqi/dqi_max_xorsat.ipynb index 28032b698..fa72d8f14 100644 --- a/algorithms/dqi/dqi_max_xorsat.ipynb +++ b/algorithms/dqi/dqi_max_xorsat.ipynb @@ -5,7 +5,7 @@ "id": "9de82aaa-b542-49fa-810c-f008a28a4133", "metadata": {}, "source": [ - "# Optimizing max-XORSAT using the Decoded Quantum Interferometry algorithm" + "# Decoded Quantum Interferometry Algorithm" ] }, { diff --git a/algorithms/dqi/dqi_max_xorsat.qmod b/algorithms/dqi/dqi_max_xorsat.qmod index 1db6c3d99..10cc1b098 100644 --- a/algorithms/dqi/dqi_max_xorsat.qmod +++ b/algorithms/dqi/dqi_max_xorsat.qmod @@ -21,27 +21,15 @@ qfunc binary_to_one_hot_expanded___0(input binary: qnum<2, False, 0>, output one inplace_binary_to_one_hot_expanded___0(one_hot); } -qfunc iteration_lambda___0_0_expanded___0(qvar___3_captured__inplace_one_hot_to_unary__5: qbit, qvar___2_captured__inplace_one_hot_to_unary__5: qbit) { - CX(qvar___3_captured__inplace_one_hot_to_unary__5, qvar___2_captured__inplace_one_hot_to_unary__5); -} - -qfunc iteration_lambda___0_0_expanded___1(qvar___2_captured__inplace_one_hot_to_unary__5: qbit, qvar___1_captured__inplace_one_hot_to_unary__5: qbit) { - CX(qvar___2_captured__inplace_one_hot_to_unary__5, qvar___1_captured__inplace_one_hot_to_unary__5); -} - -qfunc iteration_lambda___0_0_expanded___2(qvar___1_captured__inplace_one_hot_to_unary__5: qbit, qvar___0_captured__inplace_one_hot_to_unary__5: qbit) { - CX(qvar___1_captured__inplace_one_hot_to_unary__5, qvar___0_captured__inplace_one_hot_to_unary__5); -} - -qfunc inplace_one_hot_to_unary_expanded___0(qvar: qbit[4]) { - iteration_lambda___0_0_expanded___0(qvar[3], qvar[2]); - iteration_lambda___0_0_expanded___1(qvar[2], qvar[1]); - iteration_lambda___0_0_expanded___2(qvar[1], qvar[0]); +qfunc inplace_one_hot_to_unary(qvar: qbit[]) { + repeat (i: qvar.len - 1) { + CX(qvar[(qvar.len - i) - 1], qvar[(qvar.len - i) - 2]); + } X(qvar[0]); } qfunc one_hot_to_unary_expanded___0(input one_hot: qbit[4], output unary: qbit[3]) { - inplace_one_hot_to_unary_expanded___0(one_hot); + inplace_one_hot_to_unary(one_hot); lsb: qbit; one_hot -> {lsb, unary}; free(lsb); @@ -165,37 +153,12 @@ qfunc prepare_dick_state_unary_input_expanded___5(qvar: qbit[6]) { prepare_dick_state_unary_input_expanded___4(qvar[1:6]); } -qfunc iteration_lambda___0_0_expanded___3(y___0_captured__vector_product_phase__3: qbit) { - Z(y___0_captured__vector_product_phase__3); -} - -qfunc iteration_lambda___0_0_expanded___4(y___1_captured__vector_product_phase__3: qbit) { - Z(y___1_captured__vector_product_phase__3); -} - -qfunc iteration_lambda___0_0_expanded___5(y___2_captured__vector_product_phase__3: qbit) { - Z(y___2_captured__vector_product_phase__3); -} - -qfunc iteration_lambda___0_0_expanded___6(y___3_captured__vector_product_phase__3: qbit) { - Z(y___3_captured__vector_product_phase__3); -} - -qfunc iteration_lambda___0_0_expanded___7(y___4_captured__vector_product_phase__3: qbit) { - Z(y___4_captured__vector_product_phase__3); -} - -qfunc iteration_lambda___0_0_expanded___8(y___5_captured__vector_product_phase__3: qbit) { - Z(y___5_captured__vector_product_phase__3); -} - -qfunc vector_product_phase_expanded___0(y: qbit[6]) { - iteration_lambda___0_0_expanded___3(y[0]); - iteration_lambda___0_0_expanded___4(y[1]); - iteration_lambda___0_0_expanded___5(y[2]); - iteration_lambda___0_0_expanded___6(y[3]); - iteration_lambda___0_0_expanded___7(y[4]); - iteration_lambda___0_0_expanded___8(y[5]); +qfunc vector_product_phase(v: int[], y: qbit[]) { + repeat (i: y.len) { + if (v[i] > 0) { + Z(y[i]); + } + } } qfunc matrix_vector_product_expanded___0(y: qbit[6], output out: qbit[6]) { @@ -208,7 +171,7 @@ qfunc matrix_vector_product_expanded___0(y: qbit[6], output out: qbit[6]) { out[5] ^= (0 ^ y[4]) ^ y[5]; } -qfunc syndrome_decode_lookuptable_expanded___0(syndrome: qnum<6, False, 0>, error: qnum<6, False, 0>) { +qfunc syndrome_decode_lookuptable(syndrome: qnum, error: qnum) { control (syndrome == 0) { error ^= 0; } @@ -277,43 +240,6 @@ qfunc syndrome_decode_lookuptable_expanded___0(syndrome: qnum<6, False, 0>, erro } } -qfunc iteration_lambda___0_0_expanded___9(target___0_captured__apply_to_all__4: qbit) { - H(target___0_captured__apply_to_all__4); -} - -qfunc iteration_lambda___0_0_expanded___10(target___1_captured__apply_to_all__4: qbit) { - H(target___1_captured__apply_to_all__4); -} - -qfunc iteration_lambda___0_0_expanded___11(target___2_captured__apply_to_all__4: qbit) { - H(target___2_captured__apply_to_all__4); -} - -qfunc iteration_lambda___0_0_expanded___12(target___3_captured__apply_to_all__4: qbit) { - H(target___3_captured__apply_to_all__4); -} - -qfunc iteration_lambda___0_0_expanded___13(target___4_captured__apply_to_all__4: qbit) { - H(target___4_captured__apply_to_all__4); -} - -qfunc iteration_lambda___0_0_expanded___14(target___5_captured__apply_to_all__4: qbit) { - H(target___5_captured__apply_to_all__4); -} - -qfunc apply_to_all_expanded___0(target: qbit[6]) { - iteration_lambda___0_0_expanded___9(target[0]); - iteration_lambda___0_0_expanded___10(target[1]); - iteration_lambda___0_0_expanded___11(target[2]); - iteration_lambda___0_0_expanded___12(target[3]); - iteration_lambda___0_0_expanded___13(target[4]); - iteration_lambda___0_0_expanded___14(target[5]); -} - -qfunc hadamard_transform_expanded___0(target: qbit[6]) { - apply_to_all_expanded___0(target); -} - qfunc dqi_max_xor_sat_expanded___0(output y: qbit[6], output solution: qbit[6]) { k_num_errors: qnum<2, False, 0>; prepare_amplitudes([ @@ -326,10 +252,10 @@ qfunc dqi_max_xor_sat_expanded___0(output y: qbit[6], output solution: qbit[6]) binary_to_unary_expanded___0(k_num_errors, k_unary); pad_zeros_expanded___0(k_unary, y); prepare_dick_state_unary_input_expanded___5(y); - vector_product_phase_expanded___0(y); + vector_product_phase([1.0, 1.0, 1.0, 1.0, 1.0, 1.0], y); matrix_vector_product_expanded___0(y, solution); - syndrome_decode_lookuptable_expanded___0(solution, y); - hadamard_transform_expanded___0(solution); + syndrome_decode_lookuptable(solution, y); + hadamard_transform(solution); } qfunc main(output y: qbit[6], output solution: qbit[6]) { diff --git a/algorithms/dqi/dqi_max_xorsat.synthesis_options.json b/algorithms/dqi/dqi_max_xorsat.synthesis_options.json index 1918752c6..f8d613bfd 100644 --- a/algorithms/dqi/dqi_max_xorsat.synthesis_options.json +++ b/algorithms/dqi/dqi_max_xorsat.synthesis_options.json @@ -7,39 +7,37 @@ "machine_precision": 8, "custom_hardware_settings": { "basis_gates": [ - "z", - "u1", - "p", + "u2", "cy", - "r", + "rx", "id", - "y", - "sdg", + "z", + "u", + "sxdg", "x", - "u2", - "s", - "ry", - "cx", "rz", - "h", - "tdg", - "cz", - "u", - "rx", - "t", "sx", - "sxdg" + "ry", + "t", + "p", + "u1", + "y", + "tdg", + "s", + "h", + "r", + "cx", + "sdg", + "cz" ], "is_symmetric_connectivity": true }, "debug_mode": true, "synthesize_all_separately": false, - "output_format": [ - "qasm" - ], + "output_format": ["qasm"], "pretty_qasm": true, "transpilation_option": "auto optimize", "timeout_seconds": 300, - "random_seed": 3679731798 + "random_seed": 2676057990 } } diff --git a/algorithms/grover/3_sat_grover/3_sat_grover.qmod b/algorithms/grover/3_sat_grover/3_sat_grover.qmod index cabfffd08..17f12c2f3 100644 --- a/algorithms/grover/3_sat_grover/3_sat_grover.qmod +++ b/algorithms/grover/3_sat_grover/3_sat_grover.qmod @@ -3,7 +3,7 @@ qfunc sat_oracle(x: qbit[], res: qbit) { } qfunc main(output x: qbit[3]) { - allocate(3, x); + allocate(x.len, x); grover_search(1, lambda(vars) { phase_oracle(sat_oracle, vars); }, x); diff --git a/algorithms/grover/3_sat_grover/3_sat_grover.synthesis_options.json b/algorithms/grover/3_sat_grover/3_sat_grover.synthesis_options.json index a20de7f23..a5609b34e 100644 --- a/algorithms/grover/3_sat_grover/3_sat_grover.synthesis_options.json +++ b/algorithms/grover/3_sat_grover/3_sat_grover.synthesis_options.json @@ -1,5 +1,44 @@ { "constraints": { - "max_width": 20 + "max_width": 20, + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "rz", + "cx", + "h", + "u1", + "r", + "sx", + "s", + "rx", + "y", + "cy", + "tdg", + "ry", + "u2", + "u", + "x", + "cz", + "z", + "sxdg", + "sdg", + "t", + "p", + "id" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": -1 } } diff --git a/algorithms/grover/3_sat_grover/3_sat_grover_large.qmod b/algorithms/grover/3_sat_grover/3_sat_grover_large.qmod index f6683d0bb..8f4a2dea4 100644 --- a/algorithms/grover/3_sat_grover/3_sat_grover_large.qmod +++ b/algorithms/grover/3_sat_grover/3_sat_grover_large.qmod @@ -3,7 +3,7 @@ qfunc sat_oracle_large(x: qbit[], res: qbit) { } qfunc main(output x: qbit[4]) { - allocate(4, x); + allocate(x.len, x); grover_search(2, lambda(vars) { phase_oracle(sat_oracle_large, vars); }, x); diff --git a/algorithms/grover/3_sat_grover/3_sat_grover_large.synthesis_options.json b/algorithms/grover/3_sat_grover/3_sat_grover_large.synthesis_options.json index b13c22eed..56d16ac17 100644 --- a/algorithms/grover/3_sat_grover/3_sat_grover_large.synthesis_options.json +++ b/algorithms/grover/3_sat_grover/3_sat_grover_large.synthesis_options.json @@ -1,5 +1,44 @@ { "constraints": { - "max_width": 24 + "max_width": 24, + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "rz", + "cx", + "h", + "u1", + "r", + "sx", + "s", + "rx", + "y", + "cy", + "tdg", + "ry", + "u2", + "u", + "x", + "cz", + "z", + "sxdg", + "sdg", + "t", + "p", + "id" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": -1 } } diff --git a/algorithms/grover/grover_max_cut/grover_max_cut.qmod b/algorithms/grover/grover_max_cut/grover_max_cut.qmod index 2285b0d20..a56250d91 100644 --- a/algorithms/grover/grover_max_cut/grover_max_cut.qmod +++ b/algorithms/grover/grover_max_cut/grover_max_cut.qmod @@ -3,7 +3,7 @@ qfunc cut_oracle(cut_size: int, nodes: qbit[], res: qbit) { } qfunc main(output nodes: qbit[5]) { - allocate(5, nodes); + allocate(nodes.len, nodes); grover_search(3, lambda(vars) { phase_oracle(lambda(vars, res) { cut_oracle(4, vars, res); diff --git a/algorithms/grover/grover_max_cut/grover_max_cut.synthesis_options.json b/algorithms/grover/grover_max_cut/grover_max_cut.synthesis_options.json index 589c0f316..bbef76503 100644 --- a/algorithms/grover/grover_max_cut/grover_max_cut.synthesis_options.json +++ b/algorithms/grover/grover_max_cut/grover_max_cut.synthesis_options.json @@ -1,5 +1,44 @@ { "constraints": { - "max_width": 22 + "max_width": 22, + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "rz", + "cx", + "h", + "u1", + "r", + "sx", + "s", + "rx", + "y", + "cy", + "tdg", + "ry", + "u2", + "u", + "x", + "cz", + "z", + "sxdg", + "sdg", + "t", + "p", + "id" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": -1 } } diff --git a/algorithms/hhl/hhl/hhl_exact.qmod b/algorithms/hhl/hhl/hhl_exact.qmod index 4d5d1f8a6..649f4e4a0 100644 --- a/algorithms/hhl/hhl/hhl_exact.qmod +++ b/algorithms/hhl/hhl/hhl_exact.qmod @@ -1,9 +1,3 @@ -qfunc unitary_with_power_logic(pw: int, matrix: real[][], target: qbit[]) { - power (pw) { - unitary(matrix, target); - } -} - qfunc load_b(amplitudes: real[], output state: qbit[], bound: real) { prepare_amplitudes(amplitudes, bound, state); } @@ -30,6 +24,12 @@ qfunc hhl(rhs_vector: real[], bound: real, precision: int, hamiltonian_evolution } } +qfunc unitary_with_power_logic(pw: int, matrix: real[][], target: qbit[]) { + power (pw) { + unitary(matrix, target); + } +} + qfunc main(output res: qnum, output phase: qnum, output indicator: qbit) { hhl([ 0.18257418583505536, diff --git a/algorithms/hhl/hhl/hhl_exact.synthesis_options.json b/algorithms/hhl/hhl/hhl_exact.synthesis_options.json index a89c3c20a..ba1113e93 100644 --- a/algorithms/hhl/hhl/hhl_exact.synthesis_options.json +++ b/algorithms/hhl/hhl/hhl_exact.synthesis_options.json @@ -7,32 +7,33 @@ "machine_precision": 8, "custom_hardware_settings": { "basis_gates": [ - "cy", "rz", - "z", - "sdg", - "t", - "s", + "cx", "h", - "u2", - "tdg", - "sx", - "ry", - "cz", "u1", - "y", "r", - "x", + "sx", + "s", "rx", - "sxdg", - "id", + "y", + "cy", + "tdg", + "ry", + "u2", "u", + "x", + "cz", + "z", + "sxdg", + "sdg", + "t", "p", - "cx" + "id" ], "is_symmetric_connectivity": true }, "debug_mode": true, + "synthesize_all_separately": false, "output_format": ["qasm"], "pretty_qasm": true, "transpilation_option": "auto optimize", diff --git a/algorithms/hhl/hhl/hhl_trotter.qmod b/algorithms/hhl/hhl/hhl_trotter.qmod index 0ee09ad5c..2a4387705 100644 --- a/algorithms/hhl/hhl/hhl_trotter.qmod +++ b/algorithms/hhl/hhl/hhl_trotter.qmod @@ -1,7 +1,3 @@ -qfunc suzuki_trotter1_with_power_logic(hamiltonian: PauliTerm[], pw: int, r0: int, reps_scaling_factor: real, evolution_coefficient: real, target: qbit[]) { - suzuki_trotter(hamiltonian, evolution_coefficient * pw, 1, r0 * ceiling(reps_scaling_factor ** log(pw, 2)), target); -} - qfunc load_b(amplitudes: real[], output state: qbit[], bound: real) { prepare_amplitudes(amplitudes, bound, state); } @@ -28,6 +24,10 @@ qfunc hhl(rhs_vector: real[], bound: real, precision: int, hamiltonian_evolution } } +qfunc suzuki_trotter1_with_power_logic(hamiltonian: PauliTerm[], pw: int, r0: int, reps_scaling_factor: real, evolution_coefficient: real, target: qbit[]) { + suzuki_trotter(hamiltonian, evolution_coefficient * pw, 1, r0 * ceiling(reps_scaling_factor ** log(pw, 2)), target); +} + qfunc main(output res: qnum, output phase: qnum, output indicator: qbit) { hhl([ 0.1825741858, diff --git a/algorithms/hhl/hhl/hhl_trotter.synthesis_options.json b/algorithms/hhl/hhl/hhl_trotter.synthesis_options.json index a89c3c20a..ba1113e93 100644 --- a/algorithms/hhl/hhl/hhl_trotter.synthesis_options.json +++ b/algorithms/hhl/hhl/hhl_trotter.synthesis_options.json @@ -7,32 +7,33 @@ "machine_precision": 8, "custom_hardware_settings": { "basis_gates": [ - "cy", "rz", - "z", - "sdg", - "t", - "s", + "cx", "h", - "u2", - "tdg", - "sx", - "ry", - "cz", "u1", - "y", "r", - "x", + "sx", + "s", "rx", - "sxdg", - "id", + "y", + "cy", + "tdg", + "ry", + "u2", "u", + "x", + "cz", + "z", + "sxdg", + "sdg", + "t", "p", - "cx" + "id" ], "is_symmetric_connectivity": true }, "debug_mode": true, + "synthesize_all_separately": false, "output_format": ["qasm"], "pretty_qasm": true, "transpilation_option": "auto optimize", diff --git a/algorithms/oblivious_amplitude_amplification/oblivious_amplitude_amplification.qmod b/algorithms/oblivious_amplitude_amplification/oblivious_amplitude_amplification.qmod index 154002cdf..a4b791895 100644 --- a/algorithms/oblivious_amplitude_amplification/oblivious_amplitude_amplification.qmod +++ b/algorithms/oblivious_amplitude_amplification/oblivious_amplitude_amplification.qmod @@ -1,3 +1,20 @@ +qfunc check_block(b: qnum, res: qbit) { + res ^= b == 0; +} + +qfunc oblivious_amplitude_amplification(reps: int, block_encoding: qfunc (qnum, qbit[]), block: qnum, data: qbit[]) { + block_encoding(data, block); + repeat (index: reps) { + grover_operator(lambda(b) { + phase_oracle(lambda(x, res) { + check_block(x, res); + }, b); + }, lambda(b) { + block_encoding(data, b); + }, block); + } +} + qfunc apply_pauli_term(pauli_string: Pauli[], x: qbit[]) { repeat (index: x.len) { switch(pauli_string[index], [lambda() { @@ -24,23 +41,6 @@ qfunc block_encode(pauli_list: Pauli[][], data: qbit[], block: qnum) { } } -qfunc check_block(b: qnum, res: qbit) { - res ^= b == 0; -} - -qfunc oblivious_amplitude_amplification(reps: int, block_encoding: qfunc (qnum, qbit[]), block: qnum, data: qbit[]) { - block_encoding(data, block); - repeat (index: reps) { - grover_operator(lambda(b) { - phase_oracle(lambda(x, res) { - check_block(x, res); - }, b); - }, lambda(b) { - block_encoding(data, b); - }, block); - } -} - qfunc main(output data: qnum, output block: qnum) { allocate(2, block); prepare_amplitudes([ diff --git a/algorithms/simon/simon.ipynb b/algorithms/simon/simon.ipynb index 65460c11d..342b2d02b 100644 --- a/algorithms/simon/simon.ipynb +++ b/algorithms/simon/simon.ipynb @@ -7,7 +7,7 @@ "source": [ "# Simon's Algorithm\n", "\n", - "The Simon's algorithm [[1](#SimonsWiki)] is one of the basic quantum algorithms that demonstrates an exponential speed-up over its classical counterpart, in the oracle complexity setting. The algorithm solves the so called Simon's problem: \n", + "Simon's algorithm [[1](#SimonsWiki)] is a basic quantum algorithm that demonstrates an exponential speed-up over its classical counterpart in the oracle complexity setting. The algorithm solves the so-called Simon's problem: \n", "\n", "* **Input:** A function $f: [0,1]^N \\rightarrow [0,1]^N$.\n", "\n", @@ -23,13 +23,13 @@ "*** \n", "\n", "\n", - "Note that the condition on $f$ implies that it is 2-to-1 if $s \\neq 0^N$, and 1-to-1 otherwise. Herefter we refer to a function $f(x)$ that satisfies the condition in Eq. ([1](#mjx-eqn-1)) as a \"Simon's function\".\n", + "Note that the condition on $f$ implies that it is 2-to-1 if $s \\neq 0^N$, and 1-to-1 otherwise. Hereafter, we refer to a function $f(x)$ that satisfies the condition in Eq. ([1](#mjx-eqn-1)) as a \"Simon's function\".\n", "\n", - "Problem hardeness: The Simon's problem is hard to solve with a classical, deterministic or probabalistic, approaches. This can be understood as follows: determining $s$ requries finding a collision $f(x)=f(y)$, as $s = x\\oplus y$. What is the minimal number of calls for measuring a collision? If we take the deterministic approach, in the worst case we will need $2^{N-1}$ calls. A probablistic approach, in the spirit of the one that solves the Birthday problem [[2](#BDWiki)], has a slightly better scaling of $O(2^{N/2})$ queries.\n", + "Problem hardness: The Simon's problem is hard to solve with classical deterministic or probabalistic approaches. This can be understood as follows: determining $s$ requires finding a collision $f(x)=f(y)$, as $s = x\\oplus y$. What is the minimum number of calls for measuring a collision? If we take the deterministic approach, in the worst case we need $2^{N-1}$ calls. A probablistic approach, in the spirit of the one that solves the birthday problem [[2](#BDWiki)], has slightly better scaling of $O(2^{N/2})$ queries.\n", "\n", - "**The quantum approach requires $O(N)$ queries, thus, introducing an exponential speedup**.\n", + "**The quantum approach requires $O(N)$ queries, thus introducing an exponential speedup**.\n", "\n", - "Next, we define the Simon's algorithm, which has a [quantum part](#The-Quantum-Part) and a [classical postprocess part](#The-Classical-Postprocess). Then, we run the algorithm on two different examples of a Simon's function: one that can be defined with [simple arithmetic](#Example:-Arithmetic-Simon's-Function), and another that has a [shallow implementation](#Example:-Shallow-Simon's-Function). A [mathematical explanation](#Technical-Notes) of the algorithm is provided at the end of this notebook." + "Next, we define the Simon's algorithm, which has a [quantum part](#The-Quantum-Part) and a [classical postprocess part](#The-Classical-Postprocess). Then, we run the algorithm on two different examples of a Simon's function: one that can be defined with [simple arithmetic](#Example:-Arithmetic-Simon's-Function) and another that has a [shallow implementation](#Example:-Shallow-Simon's-Function). A [mathematical explanation](#Technical-Notes) of the algorithm is provided at the end of this notebook." ] }, { @@ -39,8 +39,8 @@ "source": [ "
\n", "\n", - "
Figure 1. The Simon's algorithm is comprised of two quantum blocks. The main part of the algorithm\n", - "is the oracle which implements the Simon's function f(x).
\n", + "
Figure 1. The Simon's algorithm comprises two quantum blocks. The main part of the algorithm\n", + "is the oracle that implements the Simon's function f(x).
\n", "
" ] }, @@ -49,7 +49,7 @@ "id": "082e2c2c-3e14-41d7-91b8-eaea042faac7", "metadata": {}, "source": [ - "## How to Build the Algorithm with Classiq" + "## Building the Algorithm with Classiq" ] }, { @@ -57,23 +57,16 @@ "id": "29bafcd3-7bf8-4c29-82ab-0df8104683c0", "metadata": {}, "source": [ - "### The Quantum Part\n", + "### Quantum Part\n", "\n", - "The quantum part of the algorithm is rather simple, calling the quantum implementation of $f(x)$, between two calls of the hadamard transform. The call of $f$ is done out-of-place, onto a quantum variable $y$, whereas only the final state of $x$ is relevant to the classical post-process to follow. " + "The quantum part of the algorithm is rather simple, calling the quantum implementation of $f(x)$, between two calls of the hadamard transform. The call of $f$ is done out-of-place, onto a quantum variable $y$, whereas only the final state of $x$ is relevant to the classical postprocess to follow. " ] }, { "cell_type": "code", "execution_count": 1, "id": "e4307bea-48a6-4561-9325-dcc60f3e5e52", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:04.513790Z", - "iopub.status.busy": "2024-05-07T14:48:04.513297Z", - "iopub.status.idle": "2024-05-07T14:48:07.284978Z", - "shell.execute_reply": "2024-05-07T14:48:07.284234Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "from classiq import *\n", @@ -92,27 +85,20 @@ "id": "c9bb1577-fb51-43b8-8e81-ea8aed88dd14", "metadata": {}, "source": [ - "### The Classical Postprocess\n", + "### Classical Postprocess\n", "\n", - "The classical part of the algorithm includes the following post-processing steps:\n", - "1. Finding $N-1$ samples of $x$ that are linearly independent, $\\{y_k\\}^{n-1}_{1}$. It is gurenteed that this can be acheived with high probability, see the [technical details](#The-classical-part) below.\n", + "The classical part of the algorithm includes the following postprocessing steps:\n", + "1. Finding $N-1$ samples of $x$ that are linearly independent, $\\{y_k\\}^{n-1}_{1}$. It is guaranteed that this can be achieved with high probability (see the [technical details](#The-classical-part) below).\n", "2. Finding the string $s$ such that $s \\cdot y_k=0 \\,\\,\\, \\forall k$, where $\\cdot$ refers to a dot-product mod 2 (polynomial complexity in $N$).\n", "\n", - "For these steps we use the *Galois* package, which extends *numpy* to finite field operations." + "For these steps we use the *Galois* package, which extends *NumPy* to finite field operations." ] }, { "cell_type": "code", "execution_count": 2, "id": "ec2fe11a-5ecf-44cf-9f2c-b8530bf1ad3a", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:07.290106Z", - "iopub.status.busy": "2024-05-07T14:48:07.288609Z", - "iopub.status.idle": "2024-05-07T14:48:07.293547Z", - "shell.execute_reply": "2024-05-07T14:48:07.292945Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "# !pip install galois" @@ -122,20 +108,13 @@ "cell_type": "code", "execution_count": 3, "id": "2f3f89eb-dca1-410d-a4d1-441bd89cd11b", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:07.297573Z", - "iopub.status.busy": "2024-05-07T14:48:07.296517Z", - "iopub.status.idle": "2024-05-07T14:48:10.434951Z", - "shell.execute_reply": "2024-05-07T14:48:10.434360Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "import galois\n", "import numpy as np\n", "\n", - "# here we work over boolean arithmetics - F(2)\n", + "# here we work over Boolean arithmetics - F(2)\n", "GF = galois.GF(2)" ] }, @@ -151,17 +130,10 @@ "cell_type": "code", "execution_count": 4, "id": "53bb09e7-3907-4ec6-b4d5-e4c6f34e9d8d", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:10.439194Z", - "iopub.status.busy": "2024-05-07T14:48:10.438242Z", - "iopub.status.idle": "2024-05-07T14:48:10.444058Z", - "shell.execute_reply": "2024-05-07T14:48:10.443506Z" - } - }, + "metadata": {}, "outputs": [], "source": [ - "# The following function checks whether a set contains linearly independet vectors\n", + "# The following function checks whether a set contains linearly independent vectors\n", "\n", "\n", "def is_independent_set(vectors):\n", @@ -175,8 +147,8 @@ "\n", "def get_independent_set(samples):\n", " \"\"\"\n", - " The following function gets samples of n-sized strings from running the quantum part and return an n-1 x n matrix,\n", - " whose rows forms a set if independent\n", + " The following function gets samples of n-sized strings from running the quantum part and returns an n-1 x n matrix,\n", + " whose rows form a set if independent\n", " \"\"\"\n", " ind_v = []\n", " for v in samples:\n", @@ -193,22 +165,15 @@ "id": "2ffe2431-6dea-41fc-9125-00e5ab329ffd", "metadata": {}, "source": [ - "For the second step we simply need to solve a linear set of equations. We have $N-1$ equations on a binary vector of size $N$.\n", - "It has two solutions, one of them is the trivial solution $0^N$, and the other gives us the secret string $s$. The *Galois* package handles this task as follows:" + "For the second step we need to solve a linear set of equations. We have $N-1$ equations on a binary vector of size $N$.\n", + "It has two solutions, one of which is the trivial solution $0^N$, while the other gives us the secret string $s$. The *Galois* package handles this task as follows:" ] }, { "cell_type": "code", "execution_count": 5, "id": "e01d7967-0520-45d1-adda-57d7f300e0c0", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:10.446364Z", - "iopub.status.busy": "2024-05-07T14:48:10.446186Z", - "iopub.status.idle": "2024-05-07T14:48:10.449640Z", - "shell.execute_reply": "2024-05-07T14:48:10.449027Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "def get_secret_integer(matrix):\n", @@ -226,7 +191,7 @@ "source": [ "---\n", "\n", - "Next we provide two different examples of Simon's function, and run the Simon's algorithm to find their secret string.\n", + "Next, we provide two different examples of Simon's function and run the Simon's algorithm to find their secret string.\n", "\n", "---" ] @@ -244,7 +209,7 @@ "id": "76a43559-06bd-42be-af16-a85d2d80b422", "metadata": {}, "source": [ - "An example of a valid $f(x)$ function that satisfies the condition in Eq. ([1](#mjx-eqn-1)) is:\n", + "An example of a valid $f(x)$ function that satisfies the condition in Eq. ([1](#mjx-eqn-1)):\n", "$$\n", "f(x) = \\min(x, x\\oplus s).\n", "$$\n", @@ -256,7 +221,7 @@ "id": "f457af6a-897d-4aa1-a3aa-86aa49530b1c", "metadata": {}, "source": [ - "### Implementing of the Simon's Function" + "### Implementing the Simon's Function" ] }, { @@ -271,14 +236,7 @@ "cell_type": "code", "execution_count": 6, "id": "4a353a36-5da0-4a2d-a44a-1c08669ee616", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:10.451942Z", - "iopub.status.busy": "2024-05-07T14:48:10.451768Z", - "iopub.status.idle": "2024-05-07T14:48:10.455133Z", - "shell.execute_reply": "2024-05-07T14:48:10.454528Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "from classiq.qmod.symbolic import min\n", @@ -301,20 +259,13 @@ "cell_type": "code", "execution_count": 7, "id": "8ebfa471-7675-4a97-9655-8475495ac55b", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:10.457422Z", - "iopub.status.busy": "2024-05-07T14:48:10.457052Z", - "iopub.status.idle": "2024-05-07T14:48:17.406429Z", - "shell.execute_reply": "2024-05-07T14:48:17.405785Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/61cffecc-7617-4bb7-b554-4ec59239f1ae?version=0.41.0.dev39%2B79c8fd0855\n" + "Opening: https://platform.classiq.io/circuit/9a4e6522-32f2-4d6e-8f3d-f17eab1c805f?version=0.62.0\n" ] } ], @@ -331,7 +282,7 @@ "\n", "\n", "qmod = create_model(main)\n", - "qmod = update_constraints(qmod, optimization_parameter=\"width\")\n", + "qmod = update_constraints(qmod, optimization_parameter=OptimizationParameter.WIDTH)\n", "\n", "# synthesize\n", "qprog = synthesize(qmod)\n", @@ -347,25 +298,18 @@ "id": "0e8c6ff9-580c-4577-9e83-fe3c60761b08", "metadata": {}, "source": [ - "By plotting the results we can see that this is two-to-one function:" + "By plotting the results we can see that this is a two-to-one function:" ] }, { "cell_type": "code", "execution_count": 8, "id": "2f0662ee-ed60-4504-ba2c-30ba1bca8e3e", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:17.409478Z", - "iopub.status.busy": "2024-05-07T14:48:17.408936Z", - "iopub.status.idle": "2024-05-07T14:48:17.951846Z", - "shell.execute_reply": "2024-05-07T14:48:17.950842Z" - } - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -398,21 +342,14 @@ "source": [ "### Running the Simon's Algorithm\n", "\n", - "Taking $N$ number of shots gurentees getting a set of $N-1$ independet strings with high probability (assuming a noiseless quantum computer), see [technical explanation](#The-quantum-part) below. Moreover, increasing the number of shots by a constant factor provides an exponential improvment. Below we take $50*N$ shots." + "Taking $N$ number of shots guarantees getting a set of $N-1$ independent strings with high probability (assuming a noiseless quantum computer) (see [technical explanation](#The-quantum-part) below). Moreover, increasing the number of shots by a constant factor provides an exponential improvment. Here we take $50*N$ shots." ] }, { "cell_type": "code", "execution_count": 9, "id": "ee24ec02-1eef-4ae1-9905-d9722570146e", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:17.961126Z", - "iopub.status.busy": "2024-05-07T14:48:17.959565Z", - "iopub.status.idle": "2024-05-07T14:48:17.992767Z", - "shell.execute_reply": "2024-05-07T14:48:17.991839Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "from classiq.execution import ExecutionPreferences\n", @@ -426,7 +363,7 @@ "\n", "qmod = create_model(\n", " main,\n", - " constraints=Constraints(optimization_parameter=\"width\"),\n", + " constraints=Constraints(optimization_parameter=OptimizationParameter.WIDTH),\n", " execution_preferences=ExecutionPreferences(num_shots=50 * NUM_QUBITS),\n", " out_file=\"simon_example\",\n", ")" @@ -437,21 +374,14 @@ "id": "fe7d80e1-875a-494e-8fa2-ffead27178fa", "metadata": {}, "source": [ - "We Synthesize and execute to obtain the results " + "We synthesize and execute to obtain the results: " ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "1223b440-0939-444f-8042-bcae991a443d", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:18.023200Z", - "iopub.status.busy": "2024-05-07T14:48:18.022015Z", - "iopub.status.idle": "2024-05-07T14:48:24.755464Z", - "shell.execute_reply": "2024-05-07T14:48:24.754716Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "qprog = synthesize(qmod)\n", @@ -461,16 +391,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "8d1bf53a-7906-4ab6-b40b-061ac38a560b", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:24.758795Z", - "iopub.status.busy": "2024-05-07T14:48:24.758243Z", - "iopub.status.idle": "2024-05-07T14:48:24.852862Z", - "shell.execute_reply": "2024-05-07T14:48:24.852185Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "matrix_of_ind_v = get_independent_set(samples)\n", @@ -482,16 +405,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "3af79a3a-a37b-416c-9580-02392b45305f", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:24.855688Z", - "iopub.status.busy": "2024-05-07T14:48:24.855370Z", - "iopub.status.idle": "2024-05-07T14:48:24.859074Z", - "shell.execute_reply": "2024-05-07T14:48:24.858437Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -529,7 +445,7 @@ "$$\n", "The function $f$ operates as follows: for the first $N-L$ elements we simply \"copy\" the data, whereas for the last $L$ elements we apply a xor with the $N-L$ element. A simple proof that this is indeed a 2-to-1 function is given in Ref. [[3](#SimonsPaper2024)].\n", "\n", - "*Comment:* Ref. [[3](#SimonsPaper2024)] employed further reduction of the function implementation (reducing the $N$-sized Simon's problem to an $(N-L)$-sized problem), added a classical post-process of randomly permutating over the result of $f(x)$ to increase the hardness of the problem, as well as included some NISQ analysis. These steps where taken to show an algorithmic speedup on real quantum hardware." + "*Comment:* Ref. [[3](#SimonsPaper2024)] employed further reduction of the function implementation (reducing the $N$-sized Simon's problem to an $(N-L)$-sized problem), added a classical postprocess of randomly permutating over the result of $f(x)$ to increase the hardness of the problem, and also included some NISQ analysis. These steps were taken to show an algorithmic speedup on real quantum hardware." ] }, { @@ -537,23 +453,16 @@ "id": "65a1970a-ec4e-40ca-89f1-cb341d70b08a", "metadata": {}, "source": [ - "### Implementing of the Simon's Function\n", + "### Implementing the Simon's Function\n", "\n", "The first $N-L$ \"classical copies\", $|x_k,0\\rangle\\rightarrow |x_k x_k\\rangle$, can be implemented by $CX$ gates. The xor operations, $|x_k,0\\rangle\\rightarrow |x_k, x_k \\oplus x_{N-L}\\rangle$, can be implemented by two CX operations, one for a \"classical copy\" of $x_k$, followed by a $CX$ operation to apply a xor with $x_{N-L}$." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "718afafc-a0ed-49c3-a793-e8cba7eac6c1", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:24.861699Z", - "iopub.status.busy": "2024-05-07T14:48:24.861256Z", - "iopub.status.idle": "2024-05-07T14:48:24.865718Z", - "shell.execute_reply": "2024-05-07T14:48:24.865158Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "@qfunc\n", @@ -580,32 +489,25 @@ "id": "82f3f088-cb2c-4539-a29a-37e8d3d894b0", "metadata": {}, "source": [ - "Below we take a specific example, and plot $f(x)$ for all possible $x$ values: " + "Here we take a specific example and plot $f(x)$ for all possible $x$ values: " ] }, { "cell_type": "code", "execution_count": 15, "id": "7024f574-2ea3-4864-aa14-8155466a11a4", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:24.868151Z", - "iopub.status.busy": "2024-05-07T14:48:24.867723Z", - "iopub.status.idle": "2024-05-07T14:48:28.922759Z", - "shell.execute_reply": "2024-05-07T14:48:28.921998Z" - } - }, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/c9184a7a-af13-4a42-9fa9-c7457ce35f89?version=0.41.0.dev39%2B79c8fd0855\n" + "Opening: https://platform.classiq.io/circuit/58485345-c1a8-4651-986b-6e4b2b3249fd?version=0.62.0\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkYAAAG8CAYAAAA7PGqOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABW7UlEQVR4nO3de1hU1f4/8PeAyEVhAIlLiUqRGGkWomRIaRIhHj2ZlUVWmH3tYhfFLpL1Ux5Luxy7c+xmlill5SEii4NaeTmahpDlMcWMDAv1IMIgxIjD/v3hzMQwM7CBmdm39+t5ep7Ysz+sz17M7Fnuvfb66ARBEEBERERE8JI6ASIiIiK54MCIiIiIyIwDIyIiIiIzDoyIiIiIzDgwIiIiIjLjwIiIiIjIjAMjIiIiIrNeUiegNK2trfjjjz8QGBgInU4ndTpEREQkgiAIaGhowLnnngsvL+fXhTgw6qI//vgD0dHRUqdBRERE3VBVVYX+/fs7fZ0Doy4KDAwEcLZjg4KC7F5vaWlBSUkJ0tLS4OPjI/r3djdOijaZqzrimCtzZa7MVQvHaIn99NNPcdddd1m/x53hwKiLLLfPgoKCnA6MAgICEBQU1OU/eHfipGiTuaojjrkyV+bKXLVwjG1jAXQ6DYaTr4mIiIjMFDUwOn36NF555RWMGTMGoaGh8PPzQ//+/TFhwgSsXbvWYczGjRuRkZGBsLAw+Pv7Y8iQIViwYAFOnTrl4eyJiIhI7hRzK+3IkSO49tprsW/fPoSFhSE5ORl9+vRBVVUVtmzZgj59+mDatGk2MS+++CKys7Oh0+mQkpKCiIgIbN26FUuWLMG6deuwbds2hIWFSXREREREJDeKGBj9+eefuOaaa7B//34sWrQIjz/+uM39xaamJlRUVNjElJeXY968efD29kZRUREmTJhg3Xfy5MnYtGkT7rnnHnzyyScePRYiIiKSL0XcSlu6dCn279+PWbNmYeHChXaTrgICAnDppZfaxQiCgBkzZlgHRZZ9V6xYAS8vL6xbtw779+/3xCEQERGRAsh+YNTS0oLly5cDAB555BFRMadPn8b69esBAJmZmXavDxw4EMnJyQCAgoICF2VKRERESif7W2llZWWoqanBueeei9jYWPz444/417/+hT/++AMhISFISUnBhAkTbFaxrKioQFNTEwAgMTHR4e9NTEzE1q1bUV5e7pHjICIiIvmT/cDohx9+AAD0798f8+fPx3PPPQdBEKyvP/vss7jsssvw6aefYsCAAQCAyspKAEBwcLDThZwsq1db9nXGaDTCaDRafzYYDADOXslqaWmx29+yzdFrHelunBRtMld1xEnRJnOVV5wUbTJXdcRJ0aYrchVDJ7QdZcjQM888g5ycHPj4+KClpQWzZ8/Ggw8+iMjISOzatQuzZ89GRUUFhg4dirKyMvj4+CA/Px+33norzjvvPBw5csTh733rrbcwa9YsDB48GAcOHHDa/qJFi5Cbm2u3PT8/37pYFBEREclbU1MTMjMzUV9f73CBZgvZXzGyjNtaWlpwyy234LXXXrO+lpqaig0bNiAuLg579+7Fhx9+iNtuu82l7efk5CA7O9v6s8FgQHR0NNLS0pyufL1hwwZcc801XV7RsztxUrTpLM7UKqD08EkcbzAiPNAXiQND4O2lExXr6Vzl2CaPUV5tMld5xTFXz8d1dk6XU65iYgsLC0XtK/uBUdtbYXfffbfd6wMGDMDEiROxbt06bNy4Ebfddps1prGx0envtSzw2NGoEQB8fX3h6+trt93Hx6fDP0xnr7s6Too228YV761GbtE+VNc3W1+P0vth4aR4pA+NklWucm+TxyivNpmrvOKkaFMLubaP68o5XepcXU32T6Wdf/75Dv/f0T7V1dUAgEGDBgEA6urq0NDQ4DCmqqrKZl/qvuK91bh3dZnNBwgAjtY3497VZSjeWy1RZkRE1FVaP6fLfmCUkJBgLfhWU1PjcB/L9r59+wIA4uLirPN/SktLHcZYtickJLg0X60xtQrILdoHRxPVLNtyi/bB1CrrqWxERASe0wEFDIwiIyMxZswYAGfrnrXX0tKCzZs3AwBGjRoFAOjduzcmTpwI4Owk6fYOHz6M7du3AwCmTJnilry1Yldlrd2/KtoSAFTXN2NXZa3nkiIiom7hOV0BAyMAWLhwIYCzq1l/++231u1nzpzBvHnz8MsvvyAwMBAzZsywvjZ//nzodDqsXLkSxcXF1u1NTU2YOXMmTCYTpk6diiFDhnjuQFToeIPzD1B39iMiIunwnK6QgdH48eOxePFinDx5EikpKUhOTsbUqVNx4YUX4tVXX4W/vz8++OADREREWGMSEhKwbNkymEwmZGRkYNy4cZg2bRpiY2OxadMmxMXF4fXXX5fwqJTJ1CpgZ2UtdtfosLOyFmF97SemOxIe6OfmzIiIqCvan89NrYLoc7Waz+myfyrN4oknnsCoUaPw0ksvYefOnfjuu+8QGRmJrKwsPPbYYw6v/MydOxfDhg3DsmXLsGvXLjQ2NmLAgAHIyclBTk6O08UfyTHbpxS8sepgKSKDfBEc4IP6phaH96R1ACL1fhgVE+rhbImIyBlH5/MovR+enHgRovR+OFrf3Ok5vdV0xsNZe4ZiBkYAkJaWhrS0tC7FpKamIjU11U0ZaYflKYX2H5RjBqN1mw6wed2y2sXCSfF26xkREZE0nJ3Pj9Y3Y3Z+OWZdGYM3t1R2ek5vNXkmX09TxK00klZnTynoAAQH+CAiyPbSaqTeD8unJzhcx4iIiDxPzFNnn+2pRl5mAiL12jynK+qKkZxoqVbaThFPKdQ1tWBV1iXw8tLZrZLa9vcrsbaO3HPVwjFK0SZzlVecFG2qMVcx5/Pq+mYE+Xnh6+wUhytft29LbsfYUawYsq+VJhd5eXnIy8uDyWRCRUWFqmultQrAIYMOhhYgyAeoOw2s/tm707jbLzRhRBjfTkREcsHz+V/E1krjwKiLDAYD9Ho9ampqVFkr7d//PYanvtiPowajdb/QAB/UNnU+2l59ZyKSOplkrbTaOkrIVQvHyFyZK3PtehzP57axhYWF6igiK1dqrJVWvLcaD3y4x+7e88lOPkSWpxRGx4aLnmStpNo6SslVC8coRZvMVV5xUrSpxFx5Pu8+Tr4mAOIm5DnCJ8+IiOSF5/Oe4cCIAHS+DLxFaB/bUbpWnlIgIlIKns97hrfSCID45d2f/NvFOKdPL5Rs3Ym0lKQuXW4lIiL34/m8Zzgw0qi2S8H3q6xFWB9xpT0ig/yQOCAIJ34SkBQTyg8REZHE7M7nIks18XzuGAdGGuS4tIef6NIeal0GnohIaXpaqonnc3scGGmM89IezaJLe6h1GXgiIiVxRakmns/tcfK1hogp7RES4IOIINvLsJyQR0QkLyzV5D68YtRNSiwJImYp+JNNLXgvawS8OyjtocZl8uXQJo9RXm0yV3nFSdGmnHN1VakmOR+jq+K6GsOVr0VSQ0mQ3TU6rDqozaXgiYjUhOfzrmNJEDdRckmQnZW1mP5Oaae/r7Ol4JW+TL5c2+QxyqtN5iqvOOZqi+dzlgSRHSWWBBkdG44ovR+O1jd3+KSC2LUslLhMfncoJVctHKMUbTJXecVJ0aYcc+X5nCVByAW8vXRYOCkewF9PJlhwKXgiIuXg+dx9ODDSmPShUVg+PQGRej6pQESkZDyfuwdvpWlQ+tAoXBMfiR0/H+dS8ERECsbzuetxYKRR3l46JMWEcil4IiKF4/nctXgrjYiIiMiMAyMiIiIiMw6MiIiIiMw4x6iblFgSROo4KdrUQq5aOEYp2mSu8oqTok0t5KqFY+xqDFe+FkkNJUGIiIi0iiVB3ETJJUGkjmOu8opjrsyVuTJXLRyjJZYlQdxMiSVB5BInRZtayFULxyhFm8xVXnFStKmFXLVwjGJx8jURERGRGQdGRERERGYcGBERERGZcWBEREREZMaBEREREZEZB0ZEREREZhwYEREREZlxYERERERkxgUeu4m10pir0uOkaJO5yitOijaZqzripGiTtdJkhrXSyKJVAA4ZdDC0AEE+wAVBArx0UmdFRJ7Cc4AysVaam7BWmrZz/fd/j+GpL/bjqMFo3S8yyBdPZAzBtRdHSJKrlv8ecoxjrurOVcw5QC65ujNOibmyVpqbsVaa9nIt3luNBz7cg/b/kjhmMOKBD/dg+fQEpA+NkixXrf095B4nRZvM1b1xXT0HSJmrp+KkaJO10ohkwNQqILdon90JEYB1W27RPphaeQGWSI14DtAORQyMsrKyoNPpOvyvubnZYezu3btx4403IiIiAn5+foiJicEDDzyA48ePe/goSMl2Vdaiut7xeww4e2Ksrm/GrspazyVFRB7Dc4B2KOpWWnJyMmJjYx2+5u3tbbftk08+wS233IIzZ85g5MiRiImJQWlpKV577TV8/PHH2LZtm9PfR9TW8QbnJ0T7/ZzfuyYiZeraOYCUTFEDo7vuugtZWVmi9v3jjz9wxx134MyZM3jjjTcwa9YsAIDJZEJWVhZWr16NzMxM7Ny5EzodHycgW6ZWATsra7G7Rod+lbUI6+MrKi480M/NmRGRJ9idA/ryHKAVihoYdcVLL72EpqYmpKamWgdFwNkrS8uXL0dRURG+++47lJSU4Nprr5UwU5Kb4r3VyC3aZ75s7o1VB0sRGeSH4AAf1De1OJxjoAMQqffDqJhQtJrOeDhjInIlx+cAX9HnAFI2Rcwx6o6CggIAQGZmpt1rffv2xeTJkwEA//rXvzyaF8lb8d5q3Lu6zG4uwTFDM+rMJ8T21xctPy+cFA9vLmZCpGjOzwFGngM0QlFXjL7++mv8+OOPaGhoQL9+/TBq1ChkZGTA19f2EmdDQwN+/vlnAEBiYqLD35WYmIj3338f5eXlbs+blKGzp050AIIDfODby8t2DRO9HxZOird7TJeIlEXMOUAf4AO/Xt44avhr4MRzgLooamC0atUqu21RUVF45513kJ6ebt3266+/Wv9/wIABDn9XdHQ0AKCysrLDNo1GI4zGv74EDQYDAJYE6U6cFG12JW6niKdOTja14L2sEfD20uF4gxHhgb5IHBgCby+dXVtyPEap22Su8oqTok055yrmHFDX1IJVWZfAq4NzgCdylTpOijZZEqSNF198Ed7e3hg/fjwGDBiAP//8E3v27MGiRYuwfft2+Pj4oKSkBGPHjgUAbN++HcnJyQDOdkavXvbjvw0bNiAtLQ29e/e2Gfi0t2jRIuTm5tptZ0kQ9dldo8Oqg/ZPN7Z3+4UmjAiT/ceGiLqI5wB100RJEEEQMGXKFBQWFmL48OH4/vvvAbh2YOToilF0dDRLgig8V1OrgNLDJ23+xVd6+CSmv1Pa6e9cfWcikjqYYCmXY5Rjm8xVXnFaz7X9ecDUKuCOd3d3+vs6Owe4I1e5xSkxV02UBNHpdMjNzUVhYSH27NmDqqoqREdHIzAw0LpPY2Mj9Hq9XeypU6cAoMPOAQBfX1+7OUwAS4L0JE6KNtvG2T5xclaU3g9PToxHlN4PR+ubO3zqZHRsuKgJlvx7uD5OijaZq7ziXNWmo/OA2CfPxJ4DXJWrnOOkaJMlQTpx0UUXWf//yJEjAICBAwdat/32228O46qqqgAAgwYNcl9yJDvOnjg5Wt+M2fllmDz87ORJPnVCpF588ow6oviB0YkTJ6z/b7lSFBQUZF3RurTU8a0Ry/aEhAQ3Z0hyIabW0Wd7qpGXeRki9baLtEXq/RwWiCQiZRH79GlEEM8BWqXoW2kA8OGHHwI4OxiKi4uzbp8yZQqef/555OfnY8aMGTYxp06dQlFREQDg+uuv91yyJCmxtY5C+vhi22NXY8fPx1GydSfSUpK6dOmciORLzHmgrqkFa2YmQBBMPAdokOyvGH3//ff47LPPcOaM7WrCra2tWLFiBR5//HEAwIMPPmhzz3HOnDkICAjAxo0b8dZbb1m3m0wm3Hfffairq8PIkSORlpbmmQMhyXWl1pG3lw5JMaEYESYgKSaUJ0QilRB7HqhpNPIcoFGyv2L066+/YsqUKQgJCUFCQgIiIiJQV1eHvXv3WucP3XLLLVi4cKFN3Lnnnot3330Xt9xyC2bNmoUVK1Zg0KBB+O677/DLL78gIiIC+fn5rJOmYqx1RESse0hdJfuB0fDhwzFnzhyUlpZi//79+M9//gNBEBAREYEbbrgBM2bMQEZGhsPYG2+8Eeeffz6WLFmCrVu3ory8HFFRUZg9ezaefPJJREREePhoyFNY64iIWPeQukP2A6OYmBi8+OKL3Y4fMWIE1q1b58KMSO4sT5y0P+kdMxit23SAzet84oRIXZyfB5pFnwdaTW5Pk2RI9nOMiLqCT5wQkZjzQEiADyKCbG+r8TxAgAKuGMkVa6XJM1fWOuoa5ur6OCnaZK62pK572JNYpcRJ0SZrpclMXl4e8vLyYDKZUFFRwVppMsVaR0TE8wA5oolaaVIwGAzQ6/WslSbTXHdW1rqk3pkncpU6jrkyV7Xm6qrzgBb6VQvHaInVRK00KbFWmjxzHR0b7tJ6Z+7MVS5xUrTJXOUVJ0Wb7szV1ecBLfSrFo5RLE6+JlXx9tJh4aR4AKx1RKRVPA9QT3BgRKqTPjQKy6cnsN4ZkYbxPEDdxVtppErpQ6NwTXwk650RaRjPA9QdHBiRalnqnZ34ibWOiLSK5wHqKt5KIyIiIjLjwIiIiIjIjAMjIiIiIjPOMeomlgRhrkqPk6JN5iqvOCnaZK7qiJOiTZYEkRmWBCEiIlIulgRxE5YEYa5qiWOuzJW5MlctHKMlliVB3IwlQZirWuKkaJO5yitOijaZqzripGiTJUGIiIiIPIQDIyIiIiIzDoyIiIiIzDgwIiIiIjLjwIiIiIjIjAMjIiIiIjMOjIiIiIjMuI5RN7EkCHNVepwUbTJXecVJ0SZzVUecFG2yJIjMsCQIERGRcrEkiJuwJAhzVUtcR7GmVgGlh0/ieIMR4YG+SBwYAm8vnSxzlVuc1nN113vHHbm6K05JuWrhGC2xLAniZiwJwlzVEtc+tnhvNXKL9qG6vtn6epTeDwsnxSN9aJSscpVznBRtSp2rJ947rsrVE3FStMlj7DlOviYiq+K91bh3dZnNFxsAHK1vxr2ry1C8t1qizEju+N4hteDAiIgAnL0Fklu0D47urVu25Rbtg6mVd9/JFt87pCYcGBERAGBXZa3dv/bbEgBU1zdjV2Wt55IiReB7h9SEAyMiAgAcb3D+xdad/Ug7+N4hNeHkayKNMrUK2FlZi901OvSrrEVYH19RceGBfm7OjOSO7x1SMw6MiDTI9ukhb6w6WIrIID8EB/igvqnF4VwRHYBIvR9GxYSi1XTGwxmTXPC9Q2rHgRGRxlieHmr/BXbM0GzdpgNsXresQrNwUjy8vXRoNbk9TZIhvndICzjHiEhDOnt6SAcgJMAHEUG2t0Yi9X5YPj3Bbi0a0g6+d0greMWom1grjbkqMW6niKeHTja14L2sEfD20tmtXty+Lf495NGmJ3KV+r3Tk1g596tS46Rok7XSZIa10kiJWgXgkEEHQwsQ5APUnwbe/9m707jbLzRhRBhPDVrG9w6pDWuluQlrpTFXpcT9+7/H8NQX+3HUYLRuCwnwwcmmzv/ltPrORCTFhHosV3fGMteux8rxvdOTWLn0q5rilJgra6W5GWulMVc5xxXvrcYDH+6xmw/S2Reb5emh0bHhNoU/3Zmrp2KZq7hYub93ehLL94Dr46Rok7XSiKhLOpok21b7r672Tw+R9vC9Q6TggdGjjz4KnU4HnU6Hp556yul+GzduREZGBsLCwuDv748hQ4ZgwYIFOHXqlAezJfKczsozWIT06W3zM58eIr53iBR6K2379u1YtmwZdDodOpoi9eKLLyI7Oxs6nQ4pKSmIiIjA1q1bsWTJEqxbtw7btm1DWFiYBzMncj+xZReenHgRzunrg5KtO5GWkiT6FgipF987RAq8YtTU1ISsrCxERUXh73//u9P9ysvLMW/ePHh7e2P9+vXYvHkzPvroIxw6dAjjx4/HgQMHcM8993gwcyLXa1uaYWdlLUytguiyC5F6fyTFhGJEmICkmFB+sWlQ+/eP2NIefO+QminuilFOTg4OHjyI9evX46OPPnK639KlSyEIAmbMmIEJEyZYtwcEBGDFihU4//zzsW7dOuzfvx9DhgzxROpELuWoNEOU3g9PToxHlN4PR+ubWZ6BnGJpDyLHFHXF6JtvvsGrr76K22+/HRkZGU73O336NNavXw8AyMzMtHt94MCBSE5OBgAUFBS4J1kiN7KUZmg/H+RofTNm55dh8vCzcz04SZYccfb+OWZoRp15UMT3DmmVYgZGp06dwp133omIiAi89NJLHe5bUVGBpqYmAEBiYqLDfSzby8vLXZonkbt1VpoBAD7bU428zMsQqbe9rcZJssTSHkQdU8yttIcffhiVlZUoKChASEhIh/tWVlYCAIKDgxEYGOhwn+joaJt9nTEajTAa/1rkzGAwAGBJkO7ESdGmGnMVU5qhur4ZQX7e+Do7BaWHT8qmtIca/x5yaJNlYeQVJ0WbPEZxsWIoYuXrkpISXHvttbj55pvxwQcfWLdnZWXhvffew+LFi/HEE09Yt+fn5+PWW2/FeeedhyNHjjj8nW+99RZmzZqFwYMH48CBA07bXrRoEXJzc+22syQISWV3jQ6rDrI0A3UP3z+kVWJLgsj+ilF9fT1mzpyJc845B6+++qrH28/JyUF2drb1Z4PBgOjoaKSlpbEkCHOVJK5fZS1WHSzt9PelpSR1WJrBE7m6Ko65ui7OVe8f9qu82uQxdh5bWFgoal/ZD4zmzJmDI0eOYO3ataLXHLLcPmtsbHS6j2WBx45GjQDg6+sLX1/7R1hZEoS5ShU3OjZc1FNnXVlbRm7HKKc21Zarq98/7Fd5tclj7DnZT74uKChAr1698M9//hNjx461+a+4uBgAsGLFCowdOxY333wzAGDQoEEAgLq6OjQ0NDj8vVVVVTb7EimFt5cOCyfFA+CTQ9R1fP8QdUz2V4wA4MyZM9i8ebPT13/99Vf8+uuvGDhwIAAgLi4OAQEBaGpqQmlpKcaNG2cXU1p69lJyQkKCe5ImcqP0oVFYPj2hzTo0Z0Xq/bBwUjyfHKIO8f1D5JzsB0Z1dXVOX3M2+bp3796YOHEiPv74Y+Tn59sNjA4fPozt27cDAKZMmeKWvIncLX1oFK6Jj8SOn4+zNAN1Gd8/RI7J/lZad82fPx86nQ4rV6603nIDzs5KnzlzJkwmE6ZOncpVr0nRvL10LM1A3cb3D5E91Q6MEhISsGzZMphMJmRkZGDcuHGYNm0aYmNjsWnTJsTFxeH111+XOk0iIiKSEdUOjABg7ty52LBhA6699lr88MMPKCwsRN++fZGTk4PvvvtO9FNuREREpA2yn2PUkXfffRfvvvtuh/ukpqYiNTXVMwkRERGRoqn6ihERERFRVyj6ipGUWCuNuSo9Too2mau84qRok7mqI06KNlkrTWby8vKQl5cHk8mEiooK1kojIiJSELG10jgw6iKDwQC9Xo+amhrWSmOuio5jrsyVuTJXLRyjJbawsFAdRWTlirXSmKta4qRok7nKK06KNpmrOuKkaFPztdKIiIiIPIUDIyIiIiIzDoyIiIiIzDgwIiIiIjLjwIiIiIjIjAMjIiIiIjMOjIiIiIjMuI5RN7EkCHNVepwUbTJXecVJ0SZzVUecFG2yJIjMsCQIERGRcrEkiJuwJAhzVUuc1nM1tQooPXwSxxuMCA/0ReLAEHh76dyaq7valFO/Mldl5aqFY7TEsiSIm7EkCHNVS5wUbUqda/HeauQW7UN1fbP19Si9HxZOikf60Ci35OqJNqXuV0/ESdGmFnLVwjGKxcnXRKQpxXurce/qMpsBCgAcrW/GvavLULy3WhVtElH3cGBERJphahWQW7QPjuYPWLblFu2DqdV1MwykaJOIuo8DIyLSjF2VtXZXbdoSAFTXN2NXZa2i2ySi7uMcIyJSLVOrgJ2Vtdhdo0O/ylr875S4R3aPNzQDcD45U25tEpHrcGBERKpkO9nZG6sOliK0T29RseGBfoppk4hciwMjIlIdy2Tn9rN2Tjae7jBOByBS74dRMaFoNZ2RfZtE5HqcY0REqiJmsrMjltWEFk6Kt1lbSK5tEpF78IpRN7EkCHNVepwUbXoi152dTHa2CAnwwcmmv35XpN4XCyYMwfi4MJvPt5hcpWizLb4H5BUnRZs8RnGxYnDla5FYEoRIGXbX6LDqoHen+90Wa4K+N2BoAYJ8gAuCBHT3oo0UbRJR17AkiJuwJAhzVUucWnJtX2bD1Crgjnd3d/r7Vt+ZiKSY0G7lKkWbHdH6e0BucUrKVQvHaIllSRA3Y0kQ5qqWOCnadGeZjcggXwQH+KC+qcXh/B7LZOfRseGi5vW0z1WKNsXS4ntAznFStMlj7DkOjIhIkZw9BXbMYLRu08F28nNPJztL0SYReRafSiMixensKTAdgOAAH0QE2a4NFKn3w/LpCXZFW+XaJhF5Hq8YEZHiiCmzUdfUgjUzEyAIJpRs3Ym0lCTRt7Lk0iYReR6vGBGR4pwtn9G5mkYjkmJCMSJMQFJMaI8GKFK0SUSex4EREcle2/pjOytrEdbXV1Rcd8tstG/P1CqI/l0s7UGkbLyVRkSy5qj+mNinwLpb2qN9e1F6Pzw58SJE6f1wtL7Z5W0SkXzwihERyZblKbD2c3uOGYyoMw+K2t+o6slTYM7aO1rfjNn55Zg8PMqmDVe0SUTy0uMrRseOHcOmTZtQVlaGY8eO4eTJkwgJCUFERARGjBiBq6++GhEREa7IlYg0RMxTYPoAH/j18sZRQ5s1hfR+WDgpvstPgYlp77M91cjLTMDi9e3WMepmm0QkP90aGLW0tGDt2rXIy8vDrl27AACOFtDW6c7+yykpKQmzZ8/GTTfd5NZFmTyJtdKYq9LjpGjTlfXHLE+Brcq6BF5eOusq1IkDQ+DtpbNrq6c11gQA1fXNCPLzwtfZKTYrX3e3zfb4HpBXm1rIVQvH2NWYLpcEef/995GTk4Pq6moIgoBzzjkHo0ePxsUXX4x+/fohKCgI9fX1OHHiBPbu3YsdO3bgxIkT0Ol0OPfcc7F06VJMnz69ywclNdZKI/IssfXHbr/QhBFhPa9s5On2iMiz3FIrbfTo0di1axfCwsKQmZmJrKwsDB8+vNO477//HitXrsQHH3yAEydOICkpCdu3bxfbrKywVhpzVUuc3HPdWVmL6e+Udvo7XVV/zFXtdaVNqeOYK3PVwjFaYt1SK+3gwYN47rnncP/998PXV9zjsgBw6aWX4uWXX8Zzzz2HV155Bc8++2xXmpUl1kpjrmqJk6JNMXGjY8NFPQXmqvpjrm5PTJtyiZOiTeaqjjgp2nR3rbQuPZX2yy+/YN68eV0aFLXl6+uLRx55BL/88ku34olIO7y9dFg4KR6AZ54C83R7RCRPXRoYtb/0VF9f361GO7qE5ciaNWtw++23Y/jw4QgPD4ePjw/0ej1GjRqFpUuX4tSpU05jN27ciIyMDISFhcHf3x9DhgzBggULOowhInlIHxqF5dMTEKn3TP0xT7dHRPLTo8f1x40bhw0bNqBfv36uyseh5cuXY/v27bjooouQkJCA0NBQHDt2DDt27MB3332Hd955B5s3b8a5555rE/fiiy8iOzsbOp0OKSkpiIiIwNatW7FkyRKsW7cO27ZtQ1hYmFtzJ6KeSR8ahWviI7Hj5+MeqT/m6faISF56NDD6/vvvceWVV2LTpk2IjIzscN+WlpZu3xNctmwZLrzwQoSG2k54PHHiBK677jps27YN8+bNwwcffGB9rby8HPPmzYO3tzeKioowYcIEAGdnpU+ePBmbNm3CPffcg08++aRbORGR53h76ZAUE4oTP3mm/pin2yMi+ejRytePPvoofvrpJ6SkpOC3335zut/atWsxZMiQbreTlJRkNygCgH79+mHJkiUAgJKSEpvXli5dCkEQMGPGDOugCAACAgKwYsUKeHl5Yd26ddi/f3+38yIiIiJ16dHA6JlnnsHTTz+NQ4cOISUlBQcPHrR5/dtvv8UVV1yBzMxM/Prrrz1pyqlevc5e9Go7Ifz06dNYv349ACAzM9MuZuDAgUhOTgYAFBQUuCUvIiIiUp4e10rLyclBXl4ejhw5giuvvBI//vgjfv31V0ybNg3Jycn49ttvMWDAALz33nuuyNdGQ0MDFi1aBACYPHmydXtFRQWampoAAImJiQ5jLdvLy8tdnhcREREpU49rpQHAvffei6CgIMyYMQMpKSkwGo0wGo0IDQ3F448/jvvvvx+9e/fucTslJSXIz89Ha2urdfJ1Q0MD0tPTbdZGqqysBAAEBwcjMDDQ4e+Kjo622dcZy7FYGAwGACwJ0p04KdrUQq5aOEYp2mSu8oqTok0t5KqFY+xqTJdLgjjS2tqKt99+Gzk5OTh58iR0Oh2mTZuG5cuXQ6/X9/TXW7300kuYO3euzbbMzEy88MILNoVq8/Pzceutt+K8887DkSNHHP6ut956C7NmzcLgwYNx4MABp20uWrQIubm5dttZEoSIiEg5xJYE6fEVo4KCAixYsAAHDhyAIAi44oorsGPHDmzcuBGVlZW49NJLe9qE1Zw5czBnzhy0tLTgt99+Q2FhIZ566ikUFxejoKAAV155pcvassjJyUF2drb1Z4PBgOjoaKSlpbEkCHNVdBxzZa7Mlblq4RgtsYWFhaL27dHA6IorrsDOnTshCAISEhKwbNkyXHXVVVi5ciVmzZqFq6++GkVFRdaJzq7i4+ODCy64ANnZ2UhOTsbo0aMxffp0HDhwAP7+/tbbZ42NjU5/h2WBx84Wm/T19XW40jdLgjBXtcRJ0SZzlVecFG0yV3XESdGmrEqCtPftt9/ivPPOw3vvvYfS0lJcddVVAIAZM2YgPz8fjY2NuPbaa7FhwwaXJOtIUlIS4uPjUVVVhdLSswUgBw0aBACoq6tDQ0ODw7iqqiqbfYmIiIh6NDBavHgxKioqcNttt9m9duONN6KgoACtra2YPHmyWx+L79OnDwDg+PHjAIC4uDjr/B/LYKk9y/aEhAS35UVERETK0qOB0YIFC+Dn5+f09YyMDHz55Zfw8fHBzTff3JOmnKqpqcGePXsAAIMHDwYA9O7dGxMnTgRwdpJ0e4cPH8b27dsBAFOmTHFLXkRERKQ8PV7HqDNXXXUVNm7c6PSx+c7s27cPa9asQXNzs91rFRUVuPHGG2E0GnH55Zdj2LBh1tfmz58PnU6HlStXori42Lq9qakJM2fOhMlkwtSpU3u0IjcRERGpi0vWMerMqFGj8M0333Qr9vjx45g+fTruvvtuXHbZZejfvz9Onz6N3377DWVlZWhtbcVFF12EtWvX2sRZJoNnZ2cjIyMDV111FcLDw7F161ZUV1cjLi4Or7/+uguOjoiIiNTCIwMjABg6dGi34i6++GI8/fTT2Lp1K/bv34/y8nK0tLQgNDQU48ePx/XXX48ZM2Y4fHJs7ty5GDZsGJYtW4Zdu3ahsbERAwYMQE5ODnJycrp9FYuIiIjUqUsDo4ceegj/7//9P/Tr16/bDf7vf//D4sWL8corr4ja/5xzzsHjjz/e7fZSU1ORmpra7XgiIiLSji4NjF577TWsXLkSs2fPxp133okLL7xQdOyBAwfw9ttv44033sCff/4pemAkVywJwlyVHidFm8xVXnFStMlc1REnRZuyLAny/fff4/7778f27duh0+kwevRojB8/HqNHj8ZFF12Efv36oW/fvjh16hROnDiBffv2YceOHdiwYQN27doFQRCQnJyMV1991aUrYntCXl4e8vLyYDKZUFFRwZIgRERECiK2JEiXBkaPPfYYJk+ejOrqarz44ovYsWPH2V+i0zmNsfz6K664AnPnzsXUqVPFNidLBoMBer0eNTU1LAnCXBUdJ7dcTa0CSg+fxPEGI8IDfZE4MATeXjpRsZ7OVW5tOovrrE/llKsc29RCrlo4RktsYWGh62ulPf/886ipqcGKFStwww03oLS0FJ9//jm++uorlJeX25Tg6NOnDxISEjBu3Dhcd911irtC1BmWBGGuaomTos32ccV7q5FbtA/V9X8tyxGl98PCSfFIHxolq1zl3GbbuK70qdS5yr1NLeSqhWMUq0sDI29vb5hMJuvPSUlJuO+++7BlyxYAZy9T1dfXIzg4GP7+/q7NlIhUqXhvNe5dXYb2l66P1jfj3tVlWD49weEXOTnHPiXqvi4t8BgaGoojR45YfxYEweYqUUBAAKKiojgoIiJRTK0Ccov22X2BA7Buyy3aB1Or6Dv+msc+JeqZLg2MEhISsHnzZrzxxhswGo3uyomINGJXZa3NrZ72BADV9c3YVVnruaQUjn1K1DNdGhg9+uijAID77rsPISEh0Ol02L17N95++22UlZV16xE6ItKu4w3Ov8C7sx+xT4l6qksDo3HjxuGrr77C+PHjrXONfvzxR9x9990YOXIkAgMDkZiYiLvvvhtvvvkmdu/ezcESEQE4e4tnZ2UtdtfosLOyFqZWAeGBzotQtyV2Py1q369hfe2rADjCPiVyrMslQVJSUlBSUoI///wTffr0wahRo5CYmIjS0lL88MMPKCsrQ1lZGd5++20AZ2ePX3zxxRgxYgTefPNNlx8AEcmf7RNS3lh1sBRRej88OTEeUXo/HK1vdjgnRgcgUu+HUTGhaDWd8XDW8ueoXyODfBEc4IP6ppZO+5SI7HW7VpplgnV8fDxee+01AIDJZMJ///tf7N69G7t377YOlsrLy/H9999zYESkQR09ITU7vwyzrozBm1sqoQNs9rGstrNwUjy8vXRoNYHacNavxwxG67bO+pSI7PWoiOyhQ4fQ1NRk/dnb2xuXXHIJLrnkEsyYMQOA7WCJiLSlsyekdAA+21ONvMzLsHj9TzaThiM7WHNH68T0qz7AB369vHHUwD4l6ooeDYxiYmI63aftYElNWCuNuSo9zhNt7hT5hFSQnze+zk5xuEpz+7bYr+L6ta6pBauyLoGXl85pn3oiV1fFSdGmFnLVwjF2NaZLJUG0jLXSiLpud40Oqw56d7rf7ReaMCKMpyKx2K9EXeeWWmnEWmnMVT1x7mizfW0uU6uAO97t/Db66jsTkdTJZGD261/92toq4Hb2q2zjlJSrFo7REuuWWmn0F9ZKY65qiXNVm45qc4l9Qmp0bLjoycDsVyAyyI/9ylxlESdFm7KqlUZE5AifkHIP5/3azH4lcpMuLfBIRNSemCekggN8EBFku6BgpN6PxUw7IKZfQwJ8EBFku6Aj+5WoZ3jFiIh6RExtrrqmFqyZmQBBMKFk606kpSR16TaPFonp15NNLVhzVxKEVvYrkatwYEREXdK2BEW/ylr875S4x2BrGo3IuDgcJ34SkBQTyi/vduz6tVHcSt81p9ivRK7EgRERieaoBEVon96iYlmbyznH/Spucin7lci1ODAiIlGcTQQ+2Xi6wzjWO+uYs36tbez4Shz7lcg9OPmaiDrV2URgZ/iEVMc66te22vcc+5XIfXjFqJtYEoS5Kj2uK7GdlaCwCAnwwcmmv35XpN4XCyYMwfi4MJvPjJr/Hl2J7Uq/1rJfmauM4qRokyVBZIYlQUjLxJaguC3WBH1vwNACBPkAFwQJ4AUN58T26/RYE4LZr0Q9wpIgbsKSIMxVLXFdid1ZWYvp75R2+vs6K0Ghhb9HV2LZr8xVqXFKzJUlQdyMJUGYq1rixMSOjg1HlN4PR+ubXVKCQgt/DzGx7FfmqvQ4Kdp0d0kQTr4mok55e+mwcFI8AE4EdiX2K5H8cGBERKKkD43C8ukJiNSztIcrsV+J5IW30ohItPShUbgmPhI7fj7OEhQuxH4lkg8OjIioS7y9dEiKCWUJChdjvxLJA2+lEREREZlxYERERERkxoERERERkRkHRkRERERmnHzdTayVxlyVHidFm8xVXnFStMlc1REnRZuslSYzrJVGRESkXKyV5iaslcZc1RLHXJkrc2WuWjhGSyxrpbkZa6UxV7XESdEmc5VXnBRtMld1xEnRJmulEREREXmI7AdGLS0t2LRpEx555BGMHDkSwcHB8PHxQWRkJCZPnoz169d3GL9x40ZkZGQgLCwM/v7+GDJkCBYsWIBTp0556AiIiIhIKWQ/MNq8eTNSU1Pxj3/8A0eOHMGYMWNw/fXX45xzzkFRURH+9re/4e6774ajqVIvvvgirrnmGhQXF+Piiy/GpEmTUF9fjyVLliAxMRE1NTUSHBERERHJlewHRl5eXpg6dSq2bNmC6upqfP7551i7di1+/PFHfPjhh/D29sabb76J999/3yauvLwc8+bNg7e3N9avX4/Nmzfjo48+wqFDhzB+/HgcOHAA99xzj0RHRURERHIk+4HR1VdfjU8++QQpKSl2r02bNg1ZWVkAgFWrVtm8tnTpUgiCgBkzZmDChAnW7QEBAVixYgW8vLywbt067N+/3635ExERkXLIfmDUmcsuuwwAUFVVZd12+vRp69yjzMxMu5iBAwciOTkZAFBQUOCBLImIiEgJFD8wOnjwIAAgKirKuq2iogJNTU0AgMTERIdxlu3l5eVuzpCIiIiUQtHrGB09ehTvvvsuAGDq1KnW7ZWVlQCA4OBgBAYGOoyNjo622dcZo9EIo9Fo/dlgMABgSZDuxEnRphZy1cIxStEmc5VXnBRtaiFXLRxjV2MUu/L1mTNnkJ6ejk2bNmHYsGEoLS1F7969AQD5+fm49dZbcd555+HIkSMO49966y3MmjULgwcPxoEDB5y2s2jRIuTm5tptZ0kQIiIi5RBbEkSxV4zuuecebNq0Cf369cMnn3xiHRS5Wk5ODrKzs60/GwwGREdHIy0tjSVBmKtH4kytAkoPn8TxBiPCA32RODAE3l66HrfnjlzdFcdcmWtHse76jGihX7VwjJbYwsJCUfsqcmD00EMPYcWKFQgJCcGGDRswePBgm9ctt88aGxud/g7LAo8djRoBwNfXF76+vnbbWRKEuXoirnhvNXKL9qG6vtn6epTeDwsnxSN9aJTTOCly9UScFG0yV3nFtY/1xGdEC/2qhWMUS3GTr+fNm4dXXnkFwcHBKCkpsT6V1tagQYMAAHV1dWhoaHD4eyxPsVn2JZKb4r3VuHd1mc0JHwCO1jfj3tVlKN5bLVFmRPLAzwi5g6IGRo8++iheeOEF6PV6lJSUOH3iLC4uzjr/p7S01OE+lu0JCQnuSZaoB0ytAnKL9sHRBEDLttyifTC1KnKKIFGP8TNC7qKYgdH8+fPx/PPPQ6/XY8OGDRg5cqTTfXv37o2JEycCODtJur3Dhw9j+/btAIApU6a4J2GiHthVWWv3r+C2BADV9c3YVVnruaSIZISfEXIXRQyMnnjiCTz77LMIDg7udFBkMX/+fOh0OqxcuRLFxcXW7U1NTZg5cyZMJhOmTp2KIUOGuDN1IlFMrQJ2VtZid40OOytrcdTg/ITf1vEGcfsRKR0/I+Qpsp98/dlnn+Hpp58GAMTGxiIvL8/hfmFhYfjHP/5h/TkhIQHLli1DdnY2MjIycNVVVyE8PBxbt25FdXU14uLi8Prrr3vkGIg6Yjt51BurDpYitI+4iYXhgX7uTY5IBvgZIU+S/cCotvavy6ClpaVO5wwNHDjQZmAEAHPnzsWwYcOwbNky7Nq1C42NjRgwYABycnKQk5PjdPFHIk+xTB5tPwuitrHjxch0ACL1fhgVE4pW0xm35UckNX5GyNNkPzDKysqyFortjtTUVKSmprouISIX6WjyaFs6wGYfy+osCyfFw9tLh1aTe/Ijkho/IyQF2Q+M5IolQZhrT+N2djJ51CIkwAe1TX/9rki9LxZMGILxcWE270M5HqOr4qRok7lKHyf1Z0St/eqKOCnaZEkQmcnLy0NeXh5MJhMqKipYEoR6bHeNDqsOene63/RYE4J7A4YWIMgHuCBIQJtFfYlUi58RciWxJUE4MOoig8EAvV6PmpoalgRhrl2Ka1+2oLVVwO3v7u70962+MxFJMaEuz7MnsWr4ezBXeeXqqKxH6eGTmP6O43mlbbnrM6KGfnVXnBJzLSwsVHetNKmxJAhz7Uqco7IFkUF+CA7wQX1Ti8M5FJbJo6Njw23qPrk6z57EKvXv4Yk4KdpUaq7Oyno8OTEeUXo/HK1vlvQzotR+9UScFG2yJAiRwjkrW3DM0Iw686Co/Sm9/eRRIrXqqKzH7PwyTB5+tt4ZPyPkKRwYEblRZ2ULdDg7cTQiyLZQcaTeD8unJ9gVwSRSEzFlPT7bU428zMsQqbddj4ifEXIX3kojciMxZQtONrVgzV1JEFpNKNm6E2kpSaJvDRApmdiyHiF9fLHtsaux4+fj/IyQ2/GKEZEbiS1HUHPKiKSYUIwIE5AUE8oTPmmC2M/H8YZmeHvp+Bkhj+AVIyIXalvPqV9lLcL6+nYeBJYtIG3g54OUgAMjIhdxVM8pMshX1JNnLFtAatfTzweRp3BgROQCzuo5HTMYrdtYtoC0yhWfDyJP4Rwjoh4S8+RZcIAPIoL4VA1pDz8fpDS8YtRNrJXGXC06q+ckAKhrasGqrEvg5aWzWdnX20tn144cj1HqOCnaZK6uiXPV58MTuboqToo2eYziYsVgSRCRWCuNnBFbz+n2C00YEcaPG2kLPx8kF6yV5iaslcZc29tZWct6TsyVuTrhqs+HJ3J1VZySctXCMVpiWSvNzVgrjblajI4NZz0nD8VJ0SZz7Vmcqz8f7szV1XFStMlj7DlOvibqIW8vHRZOigfAek5E7fHzQUrDgRGRC6QPjcLy6Qms50TkAD8fpCS8lUbkIulDo3BNfCTrORE5wM8HKQUHRkQuZKnndOIn1nMiao+fD1IC3kojIiIiMuPAiIiIiMiMAyMiIiIiM84x6iaWBGGuSo+Tok3mKq84KdpkruqIk6JNlgSRGZYEISIiUi6WBHETlgRhrmqJY67MlbkyVy0coyWWJUHcjCVBmKta4qRok7nKK06KNpmrOuKkaJMlQYiIiIg8hAMjIiIiIjMOjIiIiIjMODAiIiIiMuPAiIiIiMiMAyMiIiIiMw6MiIiIiMw4MCIiIiIy4wKP3cRaacxV6XFStMlc5RUnRZvMVR1xUrTJWmkyw1pp8tQqAIcMOhhagCAf4IIgAV46qbMiInItnut6jrXS3IS10uST67//ewxPfbEfRw1G636RQb54ImMIrr04Qla5yjGOuTJX5qqMXN15rpPLMXoiV9ZKczPWSpM21+K91Xjgwz1oP6o/ZjDigQ/3YPn0BKQPjZJFrnKPk6JN5iqvOCnaZK7i4jx1rtPK30MMTr4mxTG1Csgt2md3ogBg3ZZbtA+mVl4MJSLl4rlOGooYGB04cACvvvoqsrKyMGzYMPTq1Qs6nQ5PPfVUp7EbN25ERkYGwsLC4O/vjyFDhmDBggU4deqUBzInd9hVWYvq+manrwsAquubsauy1nNJERG5GM910lDErbTly5fj5Zdf7nLciy++iOzsbOh0OqSkpCAiIgJbt27FkiVLsG7dOmzbtg1hYWFuyJjc6XiD8xOF/X7O7yMTEckZz3XSUMQVo6FDh+Lhhx/GmjVr8NNPP+G2227rNKa8vBzz5s2Dt7c31q9fj82bN+Ojjz7CoUOHMH78eBw4cAD33HOPB7KnnjK1CthZWYvdNTrsrKxFWF9fUXHhgX5uzoyIyHV4rpMHRVwxuuuuu2x+9vLqfDy3dOlSCIKAGTNmYMKECdbtAQEBWLFiBc4//3ysW7cO+/fvx5AhQ1yeM7lG8d5q5BbtM19O9saqg6WIDPJFcIAP6ptaHN571wGI1PthVEwoWk1nPJwxEVHX8VwnH4q4YtRVp0+fxvr16wEAmZmZdq8PHDgQycnJAICCggKP5kbiFe+txr2ry+zusR8zGFFnPlG0X8bD8vPCSfHw5iIfRKQAPNfJiyoHRhUVFWhqagIAJCYmOtzHsr28vNxjeZF4nT2NoQMQHOCDiCDbS8iRej+7x1eJiOSK5zr5UcSttK6qrKwEAAQHByMwMNDhPtHR0Tb7OmM0GmE0/rWolsFgAMCSIN2J60rsThFPY9Q1tWBV1iXw8tLheIMR4YG+SBwYAm8vnV07au5XLRyjFG0yV3nFSdGmFs51Wvt7iKHIla+zsrLw3nvvYfHixXjiiSfsXs/Pz8ett96K8847D0eOHHH4O9566y3MmjULgwcPxoEDB5y2tWjRIuTm5jpsgyVB3Gd3jQ6rDnp3ut/tF5owIkxxb2EiIgA813mS2JIgqrxi5Eo5OTnIzs62/mwwGBAdHY20tDSWBHFhrqZWAaWHT1r/NTS+VcCqg7s7/X1pKUlIign1aK5qiWOuzJW5ej7X9ue6VInPdVr6exQWForaV5UDI8vts8bGRqf7WBZ47GjUCAC+vr7w9bV/ZJIlQVyXq+3TGGeJfRpjdGy4qImHWuhXLRyjFG0yV3nFSdGme891frI412nl7yGGKgdGgwYNAgDU1dWhoaHB4Tyjqqoqm31JGpanMRzVAbJs0wE2r/NpDCJSGufnumae62RGlU+lxcXFWef/lJaWOtzHsj0hIcFjeZEtPo1BRFog5lwXEuCDiCDbuxM810lDlVeMevfujYkTJ+Ljjz9Gfn4+xo0bZ/P64cOHsX37dgDAlClTpEiRIK4OUF1TC9bMTIAgmFCydSfSUpJEX1ImIpIDMee6k00tWHNXEoRWnuukpsorRgAwf/586HQ6rFy5EsXFxdbtTU1NmDlzJkwmE6ZOncpVrz2o/XL3R+v/FBVX02hEUkwoRoQJSIoJ5YmCiGTN7lxnEFfzrOYUz3VyoIgrRmVlZbjvvvusPx86dAgA8MYbb+Dzzz+3bi8oKEBU1NlLjgkJCVi2bBmys7ORkZGBq666CuHh4di6dSuqq6sRFxeH119/3bMHomGOlrsP7dNbVCzrABGRUjg+14mbKMxznTwoYmBkMBiwc+dOu+1HjhyxWaeo7UKMADB37lwMGzYMy5Ytw65du9DY2IgBAwYgJycHOTk5Thd/JNdyNunwZOPpDuNYB4iIlMTZua62sePFBXmukxdFDIzGjh2L7q5DmZqaitTUVBdnRGJ1NunQmfZPY7Sa3JAcEZGLdHSua6uzJ894rpOeIgZGcsSSIOLiOlvu3iIkwAcnm/76fZF6XyyYMATj48Js+pr96ro4KdpkrvKKk6JNtebalXNdrYzOdWr9eziLFUORJUGkkJeXh7y8PJhMJlRUVLAkiEhil7u/LdYEfW/A0AIE+QAXBAngvEMiUgqx57rpsSYE81wnCbElQTgw6iKDwQC9Xo+amhqWBBERt7OyFtPfcbyWVFur70zkcvc8Rlm1yVzlFSf3XJV6rlPr38NRbGFhIWuluRNLgoiLGx0bjii9H47WN3O5e5nGSdEmc5VXnBRtqi1XpZ/r1Pb36AnVrmNE8uDtpcPCSfEA/ppkaMHl7olILXiuUw8OjMjt0odGYfn0BETqWdqDiNSL5zp14K008oj0oVG4Jj4SO34+zuXuiUi1eK5TPg6MyGO8vXRIignFiZ+43D0RqRfPdcrGW2lEREREZhwYEREREZlxYERERERkxoERERERkRknX3cTa6UxV6XHSdEmc5VXnBRtMld1xEnRJmulyQxrpRERESkXa6W5CWulMVe1xDFX5spcmasWjtESy1ppbsZaacxVLXFStMlc5RUnRZvMVR1xUrTJWmlEREREHsKBEREREZEZB0ZEREREZhwYEREREZlxYERERERkxoERERERkRkHRkRERERmXMeom1gShLkqPU6KNpmrvOKkaJO5qiNOijZZEkRmWBKEiIhIuVgSxE2UVBLE1Cqg9PBJHG8wIjzQF4kDQ+DtpZNlrnKLU1KuWjhG5spcmau84tzRpru+syyxLAniZnIvCVK8txq5RftQXd9sfT1K74eFk+KRPjRKVrnKOU6KNnmM8mqTucorToo2tZCr1Mfoie8ssTj5WoWK91bj3tVlNm8wADha34x7V5eheG+1RJkRERHZktt3FgdGKmNqFZBbtA+O7o9atuUW7YOplXdQiYhIWnL8zuLASGV2VdbajbrbEgBU1zdjV2Wt55IiIiJyQI7fWRwYqczxBudvsO7sR0RE5C5y/M7i5GuFM7UK2FlZi901OvSrrEVYH19RceGBfm7OjIiIyJYSvrM4MFIw21n83lh1sBSRQX4IDvBBfVOLw3u2OgCRej+MiglFq+mMhzMmIiKtUsp3FgdGCmWZxd/+jXTM0GzdpgNsXresBrFwUjy8vXRoNbk9TSIiIkV9Z3GOkQJ1NotfByAkwAcRQbaXKCP1flg+PcFuTQgiIiJ3Udp3Fq8YdZOUtdJ2ipjFf7KpBe9ljYC3l85uFdH2bbG2jjza5DHKq03mKq84KdrUQq6eOEapv7O6GsOSICJJVSutVQAOGXQwtABBPsAFQQLKT+iw6qB3p7G3X2jCiDD+eYmIyHPaf2/Vnwbe/1n67yzWSnMTT9ZK+/d/j+GpL/bjqMFo3S8yyBfTEvvj5a8Odfo7V9+ZiKSY0C612d1c3R3LXF0fx1yZK3Nlrq4+RkffWyEBPjjZ1PkVG3d9Z1liWSvNzdxdK614bzUe+HCPg4lqRrzy1SFRs/hHx4bbFOBzV67dobU6QHKOk6JN5iqvOCnaZK7qiGsb6+x7q7NBkae+s8Ti5GsZErNEumX2fvu3UPtZ/ERERO7W0fdWW0r4ztLEwOjjjz/G2LFjERISgj59+mD48OF47rnnujWByxPELJF+sqkFc1MvRKTedtErPnlGRESe1tn3lkVIn942P8vxO0v1t9LmzJmDl19+Gb169cLVV1+Nvn374quvvsJjjz2GoqIilJSUwN/fX+o0bYhd+nxQWB9se+xq7Pj5OEq27kRaSpLoS5FERESuIvZ768mJF+Gcvj6y/s5S9cDo008/xcsvv4y+ffti8+bNSEhIAADU1NTg6quvxrZt2/Dkk0/iH//4h6R52i2R3lf8EuneXjokxYTixE8CkmJCZfcGIyIi9enu91ak3h+JA4Jk/Z2l6oHRkiVLAADz58+3DooAICwsDP/85z+RkpKC1157DU8++ST0er0kOTpeIt1X9BLpREREntTT7y25l6NS7Ryj33//Hd999x0AIDMz0+71MWPGIDo6GkajEV988YWn0wPw1xLp7e/LHjMYUWd+cylhohoREWmDFr63VDswKi8vBwCEhoYiJibG4T6JiYk2+3qSmCXSgwN8EBHEydVERCQ9rXxvqfZWWmVlJQBgwIABTveJjo622dcRo9EIo/GvhaoMBgOAnpcEEbNEel1TC1ZlXQKvDpZI70qb3c3VVXFStKmFXLVwjFK0yVzlFSdFm1rItStxrvrekvLvIYZqV75esmQJFixYgOTkZGzbts3hPgsWLMCSJUuQlpaGf//73w73WbRoEXJzc+2297QkyO4alvUgIiLlUPr3ltiSIKq9YuQqOTk5yM7Otv5sMBgQHR2NtLS0HpUE6VdZi1UHSzttPy0lqcMl0rvSptRxzFVeccyVuTJX5tqVOFd9b0n19ygsLBS1r2oHRoGBgQCAxsZGp/ucOnUKADocOfr6+sLX1/4xxJ6WBBkdG44ovR+O1je7pKyHmDblEidFm1rIVQvHKEWbzFVecVK0qYVcxcS5+ntLir+HGKqdfD1o0CAAQFVVldN9LK9Z9vUkby8dFk6KB6D8GfxERKR+WvneUu3A6LLLLgMAnDhxwunk6tLSs5cE265x5EnpQ6OwfHoCy3oQEZEiaOF7S7W30vr374+RI0fiu+++Q35+PhYsWGDz+rZt21BVVQVfX19kZGRIlOXZN9k18ZEs60FERIqg9u8t1V4xAoDHH38cAPDMM8+grKzMuv3EiRO47777AAD333+/ZKteW1jKeowIk+8S6URERBZq/t5S9cDouuuuw4MPPohTp07h8ssvx4QJE3DDDTcgNjYWP/74I5KTk7F48WKp0yQiIiKZUPXACABefvllrF27FqNHj8b27dvxxRdfoH///njmmWfw1Vdfwd/fX+oUiYiISCZUO8eorZtuugk33XST1GkQERGRzGliYOQOPS0J4qo4KdpkruqIk6JN5iqvOCnaZK7qiJOiTZYEkZm8vDzk5eXBZDKhoqKixyVBiIiIyHPElgThwKiLDAYD9Ho9ampqelQSxFVxUrTJXNURx1yZK3Nlrlo4RktsYWEha6W5U09Lgrg6Too2mas64qRok7nKK06KNpmrOuKkaJMlQYiIiIg8hAMjIiIiIjPeSusiy5Qsg8Hg8PWWlhY0NTXBYDB0+d5pd+KkaJO5qiOOuTJX5spctXCMbWOBv77HneHAqIsaGhoAANHR0RJnQkRERF3V0NDQYSkwPpXWRa2trfjjjz8QGBgInc5xbRhL8dquMBgMiI6ORlVVVYez5Z3pTptSxHU3tif94+lcPR3H907H+N7pmBT9o5R+1cpnSyvvncTERHz11Vc499xz4eXlfCYRrxh1kZeXF/r379/hPt7e3t36EAFAUFBQt2K726an43oa253+kSJXKfqV752O8b3TMU/2j5L6FVD/Z0sr751evXp1+v0NcPK1W8yePVsxbXo6rqexnm5PSf3aXUo6Rr53XB/XE0p6D2ihf9g3ronlrTSZsCwc2dnCU1rF/nGOfdMx9k/H2D/OsW86ptb+4RUjmfD19cXChQvh6+srdSqyxP5xjn3TMfZPx9g/zrFvOqbW/uEVIyIiIiIzXjEiIiIiMuPAiIiIiMiMAyMiIiIiMw6MZODjjz/G2LFjERISgj59+mD48OF47rnn0NLSInVqbnXgwAG8+uqryMrKwrBhw9CrVy/odDo89dRTncZu3LgRGRkZCAsLg7+/P4YMGYIFCxbg1KlTHsjc/VpaWrBp0yY88sgjGDlyJIKDg+Hj44PIyEhMnjwZ69ev7zBe7f0DAGvWrMHtt9+O4cOHIzw8HD4+PtDr9Rg1ahSWLl3a4bFqoX/aevTRR6HT6Tr9fGmlX7Kysqz94ey/5uZmh7G7d+/GjTfeiIiICPj5+SEmJgYPPPAAjh8/7uGjcK/Tp0/jlVdewZgxYxAaGgo/Pz/0798fEyZMwNq1ax3GqOb9I5CkHnroIQGA0KtXLyEtLU24/vrrheDgYAGAMGbMGKGpqUnqFN3Gcuzt/1u8eHGHcS+88IIAQNDpdMKVV14p3HjjjUJkZKQAQIiLixP+97//eegI3GfDhg3W/oiMjBQmTpwo3HTTTcLQoUOt22fNmiW0trbaxWqhfwRBEJKTkwWdTifEx8cL1157rXDLLbcIV199teDv7y8AEGJjY4Xff//dLk4r/WPxn//8R/Dy8hJ0Ol2Hny8t9csdd9whABCSk5OFO+64w+F/p0+ftov7+OOPhV69egkAhJEjRwo33XSTcP755wsAhIiICOHgwYMSHI3rVVVVCfHx8QIAISwsTPjb3/4mTJs2TbjiiiuEgIAAYerUqXYxanr/cGAkoYKCAgGA0LdvX2H37t3W7f/73/+EYcOGCQCEefPmSZihe7311lvCww8/LKxZs0b46aefhNtuu63TgVFZWZmg0+kEb29v4YsvvrBub2xsFMaPHy8AcPihVZpNmzYJU6dOFbZs2WL32ocffih4e3sLAIT33nvP5jWt9I8gCMK3334rnDhxwm57TU2NMGbMGAGAcPPNN9u8pqX+EYSzx3XhhRcK5513nnDdddc5/XxprV8sA6OVK1eKjvn999+FgIAAAYDwxhtvWLefOXNGmD59unWw5OgfK0rS1NQkDBkyRAAgLFq0yG6A2NjYKJSXl9tsU9v7hwMjCY0cOVIAIDz11FN2r23dulUAIPj6+gp1dXUSZOd5lpNVRwOjG2+8UQAg3HXXXXav/frrr4KXl5cAQPjpp5/cmarkZs6cKQAQxo8fb7Od/XPWli1bBABCaGiozXat9c+DDz4oABDWr1/f4edLa/3SnYHRI488IgAQUlNT7V5raGgQ9Hq9AEAoLi52Yaae9+STT1qvSIultvcP5xhJ5Pfff7cWwsvMzLR7fcyYMYiOjobRaMQXX3zh6fRk6fTp09a5NY76bODAgUhOTgYAFBQUeDQ3T7vssssAAFVVVdZt7J+/9Op1tgxk24XntNY/33zzDV599VXcfvvtyMjIcLqf1vqluyzH7qiP+vbti8mTJwMA/vWvf3k0L1dqaWnB8uXLAQCPPPKIqBg1vn84MJJIeXk5ACA0NBQxMTEO90lMTLTZV+sqKirQ1NQE4K++aU8rfXbw4EEAQFRUlHUb++eshoYGLFq0CACsX1aAtvrn1KlTuPPOOxEREYGXXnqpw3211C/tff3115g3bx5mzZqFnJwcFBQUwGg02u3X0NCAn3/+GYC6+6isrAw1NTU499xzERsbix9//BG5ubm4++67MX/+fKxfvx6tra02MWp8//SSOgGtqqysBAAMGDDA6T7R0dE2+2qdpR+Cg4MRGBjocB8t9NnRo0fx7rvvAgCmTp1q3a7V/ikpKUF+fj5aW1tx7Ngx7NixAw0NDUhPT8ezzz5r3U9L/fPwww+jsrISBQUFCAkJ6XBfLfVLe6tWrbLbFhUVhXfeeQfp6enWbb/++qv1/52ds9XQRz/88AMAoH///pg/fz6ee+45CG2KYzz77LO47LLL8Omnn1r7QY3vH14xkkhDQwMAoE+fPk736du3L4CzhfqIfQYAZ86cwfTp01FfX49hw4bh7rvvtr6m1f7Zt28f3nvvPbz//vsoKSlBQ0MDMjMz8e6770Kv11v300r/lJSU4I033sDNN9+M6667rtP9tdIvbQ0fPhwvv/wy9u7dC4PBgGPHjqGkpARXXHEFqqurMXnyZHzzzTfW/S19BDjvJzX00YkTJwCcvbLz7LPP4r777sOBAwdQX1+PDRs2YPDgwSgvL8fEiROty8mo8f3DgRGRgtxzzz3YtGkT+vXrh08++QS9e/eWOiXJzZkzB4Ig4PTp0/j555+xbNkyfPnll4iPj8eWLVukTs+j6uvrMXPmTJxzzjl49dVXpU5HtubOnYsHH3wQF198MQIDAxEeHo5rrrkG27Ztw9///ne0tLRgzpw5UqfpcZarQy0tLbjlllvw2muvYfDgwQgKCkJqaio2bNgAPz8/7N27Fx9++KHE2boPB0YSsVxybGxsdLqPZVGsoKAgj+Qkd1rvs4ceeggrVqxASEiI9V9vbWm9f3x8fHDBBRcgOzsbX375JU6ePInp06fjzz//BKCN/pkzZw6OHDmC1157DWFhYaJitNAvYul0OuTm5gIA9uzZY324oe0tImf9pIY+anucba9GWwwYMAATJ04EcHYxx7Yxanr/cGAkkUGDBgGwfaqoPctrln21ztIPdXV1Npe221Jrn82bNw+vvPIKgoODUVJSYn0qrS0t9097SUlJiI+PR1VVFUpLSwFoo38KCgrQq1cv/POf/8TYsWNt/isuLgYArFixAmPHjsXNN98MQBv90hUXXXSR9f+PHDkC4OyTVRa//fabwzg19NH555/v8P8d7VNdXQ1Ane8fDowkYvliO3HihNMJaZYTekJCgsfykrO4uDgEBAQA+Ktv2lNjnz366KN44YUXoNfrUVJS4vTJD632jzOWOQ+WUg1a6Z8zZ85g8+bNdv8dO3YMwNmJxJs3b8a3334LQDv9IpZlng3w19WQoKAgxMbGAlB3HyUkJECn0wEAampqHO5j2W6ZN6TG9w8HRhLp378/Ro4cCQDIz8+3e33btm2oqqqCr69vh2uQaEnv3r2tl3Ed9dnhw4exfft2AMCUKVM8mpu7zJ8/H88//zz0ej02bNhgfc84osX+caampgZ79uwBAOstRy30T11dHYSzC/fa/XfHHXcAABYvXgxBEKxPWmmhX7rCMncmKCgIcXFx1u2WY3fUR6dOnUJRUREA4Prrr/dAlu4RGRmJMWPGAPjrVllbLS0t2Lx5MwBg1KhRAFT6/pFqZUlyXhKkpqZGEyVB2hOz8vXu3butS89/+eWX1u1KXXq+IwsWLBAACMHBwcKuXbtExWilf/773/8Kq1evFv7880+71w4cOCCMHTtWACBcfvnlNq9ppX8c6ejzpaV+KS8vFwoLC4WWlhab7SaTSXj77bcFPz8/AYDwxBNP2LzetiTIm2++ad1+5swZazkjNZQE2bhxowBACAkJEXbs2GHd3tLSIjzwwAMCACEwMFA4evSo9TW1vX84MJKYZcl+Hx8fIT09XZg6daq1iGxycrKqi8ju3r1bSEpKsv4XFhYmABD69+9vs/2PP/6wiWtbrHDs2LHCTTfdJERFRSmyWKEzhYWF1mKxiYmJTgtdOho4a6F/vv76awGA0KdPH2HMmDHCzTffLFx//fVCYmKitfzARRddJBw+fNguVgv940hn//DQSr9Y/kEaEhIijB8/XsjMzBQyMjKEAQMGWD9zt9xyi93ASRAE4aOPPrLWKUxKShKmTZumyiKyixcvFmAubn7FFVcI119/vTBo0CABgODv7y98/vnndjFqev9wYCQDa9euFa688kohKChI8Pf3F4YOHSo888wzgtFolDo1t7J8uXX2X2VlpV3shg0bhPT0dCE0NFTw9fUVLrzwQiEnJ0cwGAyePxA3WLlypai+GThwoMN4tffP8ePHhaefflpIT08XBg0aJPTp00fo3bu3EBkZKVxzzTXC8uXLhebmZqfxau8fR8RckdVCv/zyyy/CnDlzhDFjxgjnnXee4OfnJ/j6+goDBgwQbrjhBmH9+vUdxpeWlgrXX3+9cM455wi9e/cWBg4cKMyePdvmCooa/Pvf/xYmTJgghIaGCj4+PkJ0dLSQlZXVYb0ztbx/dILQZllLIiIiIg3j5GsiIiIiMw6MiIiIiMw4MCIiIiIy48CIiIiIyIwDIyIiIiIzDoyIiIiIzDgwIiIiIjLjwIiIiIjIjAMjIiIiIjMOjIiIiIjMODAiIiIiMuPAiIiIiMiMAyMiIiIiMw6MiEiznnrqKeh0Olx++eUOX58/fz50Oh0uvfRSnDx50sPZEZEUdIIgCFInQUQkhT///BODBw/GkSNH8Mknn2Dq1KnW15YuXYrHH38ccXFx2LJlC8LDwyXMlIg8hVeMiEiz/P398fTTTwMAFixYgDNnzgAAli9fjscffxwxMTHYtGkTB0VEGsIrRkSkaYIgIDExEWVlZXj99dfRt29f3HbbbTj33HOxdetWxMTESJ0iEXkQB0ZEpHnffPMNxo0bh5CQEDQ0NCAkJARbtmzBkCFDpE6NiDyMAyMiIgDJycnYvn07AgMDsWXLFlx66aVSp0REEuAcIyLSvJUrV2LHjh0AAKPRiKCgIIkzIiKpcGBERJr28ccf4//+7/8QGhqKadOm4fTp03jsscekTouIJMJbaUSkWV988QWuu+46+Pv746uvvsIFF1yACy64ALW1tfjPf/6DK664QuoUicjDeMWIiDRp8+bNuOGGG9CrVy8UFRVhxIgRCA4OxuOPPw4AyM7OljhDIpICrxgRkebs2rULqampMBqNKCwsRHp6uvU1o9GIuLg4HD58GB988AFuvvlmCTMlIk/jFSMi0pQff/wREyZMQFNTE9asWWMzKAIAX19fLF68GACQk5MDo9EoRZpEJBFeMSIiIiIy4xUjIiIiIjMOjIiIiIjMODAiIiIiMuPAiIiIiMiMAyMiIiIiMw6MiIiIiMw4MCIiIiIy48CIiIiIyIwDIyIiIiIzDoyIiIiIzDgwIiIiIjLjwIiIiIjI7P8DvdLzJKtutrQAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -627,7 +529,7 @@ "\n", "\n", "qmod = create_model(main)\n", - "qmod = update_constraints(qmod, optimization_parameter=\"width\")\n", + "qmod = update_constraints(qmod, optimization_parameter=OptimizationParameter.WIDTH)\n", "\n", "# synthesize\n", "qprog = synthesize(qmod)\n", @@ -664,16 +566,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "d1bbd003-27fc-4d1e-9ecc-f7cbdd512831", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:28.927858Z", - "iopub.status.busy": "2024-05-07T14:48:28.926609Z", - "iopub.status.idle": "2024-05-07T14:48:28.973762Z", - "shell.execute_reply": "2024-05-07T14:48:28.972878Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "@qfunc\n", @@ -692,30 +587,15 @@ "id": "4297c903-f4f8-436b-a62f-755b037012b9", "metadata": {}, "source": [ - "We synthesize and execute to obtain the results " + "We synthesize and execute to obtain the results: " ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "2b893be2-6d70-4264-a84b-38ec318f83c8", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:28.979004Z", - "iopub.status.busy": "2024-05-07T14:48:28.977800Z", - "iopub.status.idle": "2024-05-07T14:48:32.516515Z", - "shell.execute_reply": "2024-05-07T14:48:32.515714Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/af819a46-e820-471f-9c62-65af85eccd18?version=0.41.0.dev39%2B79c8fd0855\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "qprog = synthesize(qmod)\n", "show(qprog)\n", @@ -725,16 +605,9 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "a5ef7dbb-a01c-401a-9c16-d9d9d17f9a6c", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:32.521320Z", - "iopub.status.busy": "2024-05-07T14:48:32.520096Z", - "iopub.status.idle": "2024-05-07T14:48:32.536778Z", - "shell.execute_reply": "2024-05-07T14:48:32.536046Z" - } - }, + "metadata": {}, "outputs": [], "source": [ "matrix_of_ind_v = get_independent_set(samples)\n", @@ -746,26 +619,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "36311726-fb1d-40d7-b830-ab4af4e2ea84", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T14:48:32.541426Z", - "iopub.status.busy": "2024-05-07T14:48:32.540171Z", - "iopub.status.idle": "2024-05-07T14:48:32.547594Z", - "shell.execute_reply": "2024-05-07T14:48:32.546952Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The secret binary string (integer) of f(x): 60\n", - "The result of the Simon's Algorithm: 60\n" - ] - } - ], + "metadata": {}, + "outputs": [], "source": [ "s_secret = int(\"1\" * PARTITION_INDEX + \"0\" * (NUM_QUBITS - PARTITION_INDEX), 2)\n", "print(\"The secret binary string (integer) of f(x):\", s_secret)\n", @@ -782,7 +639,7 @@ "source": [ "## Technical Notes\n", "\n", - "Below we provide some technical details about the quantum and classical parts of the Simon's algorithm" + "This section provides some technical details about the quantum and classical parts of the Simon's algorithm." ] }, { @@ -790,7 +647,7 @@ "id": "1a0b7c46-89db-4f0e-8dac-df1529525ec6", "metadata": {}, "source": [ - "### The Quantum Part\n", + "### Quantum Part\n", "\n", "Following the three blocks of the algorithm:\n", "$$\n", @@ -816,9 +673,9 @@ "id": "fed2c380-c13c-4f17-b6e3-4a41d7eeadc0", "metadata": {}, "source": [ - "### The Classical Part\n", + "### Classical Part\n", "\n", - "We have a set of possible $y$ values that can be measured, each with the same probability of $1/M$, where $M$ is the set size. In the case that $s=0^N$ we have $M=2^N$, whereas for $s\\neq 0^N$ the set size is $M=2^{N-1}$. The probability to measure a set of $N-1$ linearly independent binary strings $y$ can be calculated as follows (see also the Birthday problem [[2](#BDWiki)]): For the first string we just require that we do not pick $y=0^N$, so $P(y_0)=1-1/M$. Then, for the next string, we require that it is not in $\\left\\{a_0 y_0\\,\\,\\,| a_0=0,1\\right\\}$, thus $P(y_1)=(1-2/M)$. The following string is required not to be picked out of $\\left\\{a_0 y_0+a_1y_1\\,\\,\\,| a_0, a_1=0,1\\right\\}$. We can continue with this procedure up to $y_{N-1}$ to get\n", + "We have a set of possible $y$ values that can be measured, each with the same probability of $1/M$, where $M$ is the set size. If $s=0^N$, we have $M=2^N$, whereas for $s\\neq 0^N$ the set size is $M=2^{N-1}$. The probability to measure a set of $N-1$ linearly independent binary strings $y$ can be calculated as follows (see also the birthday problem [[2](#BDWiki)]): For the first string we just require that we do not pick $y=0^N$, so $P(y_0)=1-1/M$. Then, for the next string, we require that it is not in $\\left\\{a_0 y_0\\,\\,\\,| a_0=0,1\\right\\}$, thus $P(y_1)=(1-2/M)$. The following string is required not to be picked out of $\\left\\{a_0 y_0+a_1y_1\\,\\,\\,| a_0, a_1=0,1\\right\\}$. We can continue with this procedure up to $y_{N-1}$ to get\n", "$$\n", "P_{\\rm independent} = \n", "\\left\\{\\begin{array}{l l}\n", @@ -843,7 +700,7 @@ "\n", "[2]: [Birthday problem (Wikipedia)](https://en.wikipedia.org/wiki/Birthday_problem)\n", "\n", - "[3]: [Singkanipa P., et al. \"Demonstration of Algorithmic Quantum Speedup for an Abelian Hidden Subgroup Problem.\" arXiv preprint arXiv:2401.07934 (2024).](https://arxiv.org/abs/2401.07934)" + "[3]: [Singkanipa P. et al. \"Demonstration of Algorithmic Quantum Speedup for an Abelian Hidden Subgroup Problem.\" arXiv preprint arXiv:2401.07934 (2024).](https://arxiv.org/abs/2401.07934)" ] } ], diff --git a/algorithms/simon/simon_example.qmod b/algorithms/simon/simon_example.qmod index b14ec214a..81e82fd05 100644 --- a/algorithms/simon/simon_example.qmod +++ b/algorithms/simon/simon_example.qmod @@ -1,7 +1,3 @@ -qfunc simon_qfunc_simple(s: int, x: qnum, output res: qnum) { - res = min(x, x ^ s); -} - qfunc simon_qfunc(f_qfunc: qfunc (qnum, output qnum), x: qnum) { res: qnum; hadamard_transform(x); @@ -9,6 +5,10 @@ qfunc simon_qfunc(f_qfunc: qfunc (qnum, output qnum), x: qnum) { hadamard_transform(x); } +qfunc simon_qfunc_simple(s: int, x: qnum, output res: qnum) { + res = min(x, x ^ s); +} + qfunc main(output x: qnum) { allocate(5, x); simon_qfunc(lambda(x, res) { diff --git a/algorithms/simon/simon_example.synthesis_options.json b/algorithms/simon/simon_example.synthesis_options.json index 31c9776e8..33438e123 100644 --- a/algorithms/simon/simon_example.synthesis_options.json +++ b/algorithms/simon/simon_example.synthesis_options.json @@ -1,5 +1,43 @@ { "constraints": { + "max_gate_count": {}, "optimization_parameter": "width" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "cy", + "rx", + "u", + "u1", + "p", + "z", + "cz", + "sdg", + "y", + "s", + "u2", + "tdg", + "rz", + "id", + "r", + "h", + "cx", + "sx", + "sxdg", + "t", + "x", + "ry" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": 4217120978 } } diff --git a/algorithms/simon/simon_shallow_example.qmod b/algorithms/simon/simon_shallow_example.qmod index 00268be57..903cf0120 100644 --- a/algorithms/simon/simon_shallow_example.qmod +++ b/algorithms/simon/simon_shallow_example.qmod @@ -1,3 +1,10 @@ +qfunc simon_qfunc(f_qfunc: qfunc (qnum, output qnum), x: qnum) { + res: qnum; + hadamard_transform(x); + f_qfunc(x, res); + hadamard_transform(x); +} + qfunc simon_qfunc_with_bipartite_s(partition_index: int, x: qbit[], output res: qbit[]) { allocate(x.len, res); repeat (i: x.len - partition_index) { @@ -9,13 +16,6 @@ qfunc simon_qfunc_with_bipartite_s(partition_index: int, x: qbit[], output res: } } -qfunc simon_qfunc(f_qfunc: qfunc (qnum, output qnum), x: qnum) { - res: qnum; - hadamard_transform(x); - f_qfunc(x, res); - hadamard_transform(x); -} - qfunc main(output x: qnum) { allocate(6, x); simon_qfunc(lambda(x, res) { diff --git a/algorithms/simon/simon_shallow_example.synthesis_options.json b/algorithms/simon/simon_shallow_example.synthesis_options.json index 0967ef424..0e0333520 100644 --- a/algorithms/simon/simon_shallow_example.synthesis_options.json +++ b/algorithms/simon/simon_shallow_example.synthesis_options.json @@ -1 +1,43 @@ -{} +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "cy", + "rx", + "u", + "u1", + "p", + "z", + "cz", + "sdg", + "y", + "s", + "u2", + "tdg", + "rz", + "id", + "r", + "h", + "cx", + "sx", + "sxdg", + "t", + "x", + "ry" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": 4002322088 + } +} diff --git a/algorithms/vqls/lcu_vqls/vqls_with_lcu.qmod b/algorithms/vqls/lcu_vqls/vqls_with_lcu.qmod index 8a0bb95f4..f0aeb7869 100644 --- a/algorithms/vqls/lcu_vqls/vqls_with_lcu.qmod +++ b/algorithms/vqls/lcu_vqls/vqls_with_lcu.qmod @@ -1,3 +1,11 @@ +qfunc block_encoding_vqls(ansatz: qfunc (), block_encoding: qfunc (), prepare_b_state: qfunc ()) { + ansatz(); + block_encoding(); + invert { + prepare_b_state(); + } +} + qfunc apply_ry_on_all(params: real[], io: qbit[]) { repeat (index: io.len) { RY(params[index], io[index]); @@ -60,14 +68,6 @@ qfunc prepare_ca(pauli_terms_list: PauliTerm[], system_qubits: qbit[], ancillary } } -qfunc block_encoding_vqls(ansatz: qfunc (), block_encoding: qfunc (), prepare_b_state: qfunc ()) { - ansatz(); - block_encoding(); - invert { - prepare_b_state(); - } -} - qfunc main(params: real[9], output ancillary_qubits: qnum, output system_qubits: qnum) { allocate(2, ancillary_qubits); allocate(3, system_qubits); diff --git a/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod b/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod index 9a950049f..464ad58a1 100644 --- a/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod +++ b/applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod @@ -3,8 +3,9 @@ qfunc my_sp(x: qnum, y: qnum) { hadamard_transform(y); } -qfunc my_predicate(x: qnum, y: qnum, res: qbit) { - res ^= ((x + y) < 9) and (((x * y) % 4) == 1); +qfunc my_grover_operator(oracle_operand: qfunc (), diffuser_operand: qfunc ()) { + oracle_operand(); + diffuser_operand(); } qfunc prep_minus(output out: qbit) { @@ -22,6 +23,10 @@ qfunc my_oracle(predicate: qfunc (qbit)) { } } +qfunc my_predicate(x: qnum, y: qnum, res: qbit) { + res ^= ((x + y) < 9) and (((x * y) % 4) == 1); +} + qfunc zero_predicate(x: qnum, y: qnum, res: qbit) { joined: qnum; {x, y} -> joined; @@ -43,11 +48,6 @@ qfunc my_diffuser(sp_operand: qfunc (qnum, qnum), x: qnum, y: qnum) { } } -qfunc my_grover_operator(oracle_operand: qfunc (), diffuser_operand: qfunc ()) { - oracle_operand(); - diffuser_operand(); -} - qfunc main(output x: qnum, output y: qnum) { allocate_num(6, False, 0, x); allocate_num(6, False, 0, y); diff --git a/applications/finance/option_pricing/option_pricing.ipynb b/applications/finance/option_pricing/option_pricing.ipynb index 2362ea370..64296694c 100644 --- a/applications/finance/option_pricing/option_pricing.ipynb +++ b/applications/finance/option_pricing/option_pricing.ipynb @@ -164,7 +164,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -250,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "id": "986b9ce8", "metadata": { "pycharm": { @@ -277,12 +277,11 @@ "\n", "@qfunc\n", "def payoff(asset: QNum, ind: QBit):\n", - " control(\n", - " asset\n", - " >= ceiling(\n", - " descale(K)\n", - " ), # check if asset price is 'in the money' - crossed the strike price\n", - " lambda: payoff_linear(asset, ind),\n", + " aux = QBit(\"aux\")\n", + " # check if asset price is 'in the money' - crossed the strike price\n", + " within_apply(\n", + " lambda: assign(asset >= ceiling(descale(K)), aux),\n", + " lambda: control(aux, lambda: payoff_linear(asset, ind)),\n", " )" ] }, @@ -300,7 +299,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "id": "f6e1682d-75ec-4765-945a-6d1f8501365b", "metadata": {}, "outputs": [], @@ -351,7 +350,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 12, "id": "bd2d44b5", "metadata": { "pycharm": { @@ -404,7 +403,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 13, "id": "a7fdde0f-8413-43ef-b7d5-788b86cfdc54", "metadata": {}, "outputs": [], @@ -435,7 +434,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 14, "id": "9e9e68fa-afe7-4668-b37b-1b6c385d9ce2", "metadata": {}, "outputs": [], @@ -451,14 +450,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "id": "d912597d-c196-43c8-9955-fa4ccd3cbe99", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", - "text": [] + "text": [ + "Opening: https://nightly.platform.classiq.io/circuit/8d3aaafa-a271-4384-8588-1e9499bf8cf7?version=0.64.0.dev0\n" + ] } ], "source": [ @@ -476,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "id": "486b167a-b67b-4e2f-8ea3-ed5faa9f4e9e", "metadata": {}, "outputs": [], @@ -495,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 17, "id": "7b257b85-4f48-4625-8c1f-f05895e60575", "metadata": {}, "outputs": [ @@ -503,8 +504,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Measured Payoff: 0.17755290428851778\n", - "Confidence Interval: [0.1727416 0.18236421]\n" + "Measured Payoff: 0.17567552705951653\n", + "Confidence Interval: [0.17237516 0.17897589]\n" ] } ], @@ -526,7 +527,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 18, "id": "4acddc0a-83c2-480a-bf68-975c4bd0fcc6", "metadata": {}, "outputs": [ @@ -545,7 +546,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 19, "id": "d30f73bb-feda-4043-94f2-916728d910fc", "metadata": {}, "outputs": [], diff --git a/applications/finance/option_pricing/option_pricing.qmod b/applications/finance/option_pricing/option_pricing.qmod index 64fb81c4b..6a6632e29 100644 --- a/applications/finance/option_pricing/option_pricing.qmod +++ b/applications/finance/option_pricing/option_pricing.qmod @@ -3,6 +3,13 @@ qstruct OptionPricingState { ind: qbit; } +qfunc iqae_algorithm(k: int, oracle_operand: qfunc (qbit[]), sp_operand: qfunc (qbit[]), x: qbit[]) { + sp_operand(x); + power (k) { + grover_operator(oracle_operand, sp_operand, x); + } +} + qfunc iqae_oracle(state: OptionPricingState) { Z(state.ind); } @@ -49,8 +56,13 @@ qfunc payoff_linear(asset: qnum, ind: qbit) { } qfunc payoff(asset: qnum, ind: qbit) { - control (asset >= ceiling(12.9502500662)) { - payoff_linear(asset, ind); + aux: qbit; + within { + aux = asset >= ceiling(12.9502500662); + } apply { + control (aux) { + payoff_linear(asset, ind); + } } } @@ -59,13 +71,6 @@ qfunc european_call_state_preparation(state: OptionPricingState) { payoff(state.asset, state.ind); } -qfunc iqae_algorithm(k: int, oracle_operand: qfunc (qbit[]), sp_operand: qfunc (qbit[]), x: qbit[]) { - sp_operand(x); - power (k) { - grover_operator(oracle_operand, sp_operand, x); - } -} - qfunc main(k: int, output ind: qbit) { state: OptionPricingState; asset: qbit[]; diff --git a/applications/finance/option_pricing/option_pricing.synthesis_options.json b/applications/finance/option_pricing/option_pricing.synthesis_options.json index 1b330aa64..7b26d76dd 100644 --- a/applications/finance/option_pricing/option_pricing.synthesis_options.json +++ b/applications/finance/option_pricing/option_pricing.synthesis_options.json @@ -8,36 +8,38 @@ "machine_precision": 8, "custom_hardware_settings": { "basis_gates": [ - "sx", - "rx", + "id", + "cx", "u", - "z", - "cz", - "y", - "s", - "u1", + "sdg", + "t", "p", - "r", - "cy", + "u1", "ry", - "rz", + "z", "x", - "h", - "t", - "sxdg", "tdg", - "cx", - "id", + "y", + "cz", "u2", - "sdg" + "sxdg", + "rx", + "s", + "rz", + "cy", + "sx", + "r", + "h" ], "is_symmetric_connectivity": true }, "debug_mode": true, + "synthesize_all_separately": false, + "optimization_level": 3, "output_format": ["qasm"], "pretty_qasm": true, "transpilation_option": "auto optimize", "timeout_seconds": 300, - "random_seed": -1 + "random_seed": 4290148293 } } diff --git a/applications/finance/portfolio_optimization/portfolio_optimization.ipynb b/applications/finance/portfolio_optimization/portfolio_optimization.ipynb index 938fcaaba..75687a310 100644 --- a/applications/finance/portfolio_optimization/portfolio_optimization.ipynb +++ b/applications/finance/portfolio_optimization/portfolio_optimization.ipynb @@ -56,12 +56,6 @@ "execution_count": 1, "id": "952d49b3-5dc6-41a1-8822-0622df536cf7", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:07.327339Z", - "iopub.status.busy": "2024-05-07T15:06:07.326871Z", - "iopub.status.idle": "2024-05-07T15:06:07.542423Z", - "shell.execute_reply": "2024-05-07T15:06:07.541631Z" - }, "tags": [] }, "outputs": [], @@ -77,7 +71,7 @@ "source": [ "# The Portfolio Optimization Problem Parameters\n", "\n", - "First we define the parameters of the optimization problem, which include the expected return vector, the covariance matrix, the total budget and the asset-specific budgets:" + "First we define the parameters of the optimization problem, which include the expected return vector, the covariance matrix and the total budget:" ] }, { @@ -85,12 +79,6 @@ "execution_count": 2, "id": "6212e51c", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:07.547954Z", - "iopub.status.busy": "2024-05-07T15:06:07.546656Z", - "iopub.status.idle": "2024-05-07T15:06:07.552727Z", - "shell.execute_reply": "2024-05-07T15:06:07.552195Z" - }, "pycharm": { "name": "#%%\n" }, @@ -99,17 +87,15 @@ "outputs": [], "source": [ "returns = np.array([3, 4, -1])\n", - "# fmt: off\n", "covariances = np.array(\n", " [\n", - " [ 0.9, 0.5, -0.7],\n", - " [ 0.5, 0.9, -0.2],\n", - " [-0.7, -0.2, 0.9],\n", + " [0.9, 0.5, -0.7],\n", + " [0.5, 0.9, -0.2],\n", + " [-0.7, -0.2, 0.9],\n", " ]\n", ")\n", - "# fmt: on\n", - "total_budget = 6\n", - "specific_budgets = [2, 2, 2]" + "\n", + "total_budget = 6" ] }, { @@ -127,12 +113,6 @@ "execution_count": 3, "id": "42650f31-8efe-4ca9-8ed6-f5d9d440bee4", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:07.556775Z", - "iopub.status.busy": "2024-05-07T15:06:07.555783Z", - "iopub.status.idle": "2024-05-07T15:06:07.565348Z", - "shell.execute_reply": "2024-05-07T15:06:07.564551Z" - }, "tags": [] }, "outputs": [], @@ -141,14 +121,11 @@ "num_assets = len(returns)\n", "\n", "# setting the variables\n", - "portfolio_model.w = pyo.Var(\n", - " range(num_assets),\n", - " domain=pyo.Integers,\n", - " bounds=lambda _, idx: (0, specific_budgets[idx]),\n", - ")\n", + "portfolio_model.w = pyo.Var(range(num_assets), domain=pyo.Integers, bounds=(0, 7))\n", + "\n", "w_array = list(portfolio_model.w.values())\n", "\n", - "# setting the constraint\n", + "# global budget constraint\n", "portfolio_model.budget_rule = pyo.Constraint(expr=(sum(w_array) <= total_budget))\n", "\n", "# setting the expected return and risk\n", @@ -163,102 +140,80 @@ }, { "cell_type": "markdown", - "id": "c671eeac-5b61-4ab4-9e92-cfcb2ed8170b", + "id": "ea100320-dab7-4a4c-aed9-e08e3a70fb78", "metadata": { "tags": [] }, "source": [ "## Setting Up the Classiq Problem Instance\n", "\n", - "In order to solve the Pyomo model defined above, we use the Classiq combinatorial optimization engine. For the quantum part of the QAOA algorithm (`QAOAConfig`) - define the number of repetitions (`num_layers`):" + "In order to solve the Pyomo model defined above, we use the `CombinatorialProblem` python class. Under the hood it tranlates the Pyomo model to a quantum model of the QAOA algorithm, with cost hamiltonian translated from the Pyomo model. We can choose the number of layers for the QAOA ansatz using the argument `num_layers`, and the `penalty_factor`, which will be the coefficient of the constraints term in the cost hamiltonian." ] }, { "cell_type": "code", "execution_count": 4, - "id": "c044e30f-2b4f-41ef-9bc0-11b951cb88db", + "id": "9503e674-3194-44ad-b248-fffa6fc3a9b2", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:07.570439Z", - "iopub.status.busy": "2024-05-07T15:06:07.569306Z", - "iopub.status.idle": "2024-05-07T15:06:10.280055Z", - "shell.execute_reply": "2024-05-07T15:06:10.275821Z" - }, "tags": [] }, "outputs": [], "source": [ "from classiq import *\n", - "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", + "from classiq.applications.combinatorial_optimization import CombinatorialProblem\n", "\n", - "qaoa_config = QAOAConfig(num_layers=1)" - ] - }, - { - "cell_type": "markdown", - "id": "dce2689a-d47f-42c0-9468-5faa4da21d20", - "metadata": {}, - "source": [ - "For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`max_iteration`) and the $\\alpha$-parameter (`alpha_cvar`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" + "combi = CombinatorialProblem(pyo_model=portfolio_model, num_layers=3, penalty_factor=10)\n", + "\n", + "qmod = combi.get_model()" ] }, { "cell_type": "code", "execution_count": 5, - "id": "7c4a6a91-aece-4a3b-9fa2-e7f76c90f296", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:10.287616Z", - "iopub.status.busy": "2024-05-07T15:06:10.287145Z", - "iopub.status.idle": "2024-05-07T15:06:10.292183Z", - "shell.execute_reply": "2024-05-07T15:06:10.291510Z" - }, - "pycharm": { - "name": "#%%\n" - }, - "tags": [] - }, + "id": "86d783b7-820a-40a8-90af-aedb735b7678", + "metadata": {}, "outputs": [], "source": [ - "optimizer_config = OptimizerConfig(max_iteration=60, alpha_cvar=0.7)" + "write_qmod(qmod, \"portfolio_optimization\")" ] }, { "cell_type": "markdown", - "id": "a78aeea0-246b-4a58-9d7f-94cded812348", + "id": "696f5c22-eb43-488a-a948-aa057c005bed", "metadata": {}, "source": [ - "Lastly, we load the model, based on the problem and algorithm parameters, which we can use to solve the problem:" + "## Synthesizing the QAOA Circuit and Solving the Problem\n", + "\n", + "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" ] }, { "cell_type": "code", "execution_count": 6, - "id": "d3988443-adff-4196-981f-d22307de17c9", + "id": "25bc3abe-18a1-4e41-ab3d-084cd49d463b", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:10.297071Z", - "iopub.status.busy": "2024-05-07T15:06:10.295820Z", - "iopub.status.idle": "2024-05-07T15:06:12.171845Z", - "shell.execute_reply": "2024-05-07T15:06:12.171188Z" - }, "pycharm": { "name": "#%%\n" }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://nightly.platform.classiq.io/circuit/83bbd639-d2b0-4fb6-b89b-b9a790a5bd4d?version=0.63.0.dev2\n" + ] + } + ], "source": [ - "qmod = construct_combinatorial_optimization_model(\n", - " pyo_model=portfolio_model,\n", - " qaoa_config=qaoa_config,\n", - " optimizer_config=optimizer_config,\n", - ")" + "qprog = combi.get_qprog()\n", + "show(qprog)" ] }, { "cell_type": "markdown", - "id": "0d64c135-ec3b-490e-ae60-2d72f0ff633c", + "id": "b06ce4de-2fce-4360-bade-6af4d2c0558d", "metadata": {}, "source": [ "We also set the quantum backend we want to execute on:" @@ -267,111 +222,48 @@ { "cell_type": "code", "execution_count": 7, - "id": "e0b0013d-5152-4221-a8d5-d35820c3a878", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:12.174681Z", - "iopub.status.busy": "2024-05-07T15:06:12.174351Z", - "iopub.status.idle": "2024-05-07T15:06:12.190978Z", - "shell.execute_reply": "2024-05-07T15:06:12.190335Z" - }, - "tags": [] - }, + "id": "fcddad02-a283-4812-a22e-289da66dcae7", + "metadata": {}, "outputs": [], "source": [ - "from classiq.execution import ClassiqBackendPreferences\n", + "from classiq.execution import *\n", "\n", - "qmod = set_execution_preferences(\n", - " qmod, backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", + "execution_preferences = ExecutionPreferences(\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\"),\n", ")" ] }, - { - "cell_type": "code", - "execution_count": 8, - "id": "804e8e99-2e63-43df-9168-f1cb8497bdad", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:12.193308Z", - "iopub.status.busy": "2024-05-07T15:06:12.192932Z", - "iopub.status.idle": "2024-05-07T15:06:12.333982Z", - "shell.execute_reply": "2024-05-07T15:06:12.333340Z" - } - }, - "outputs": [], - "source": [ - "write_qmod(qmod, \"portfolio_optimization\")" - ] - }, { "cell_type": "markdown", - "id": "b098aa8a-e47f-474a-b5a4-75f3b98d2628", + "id": "a22a913a-720f-4ca9-806f-3ae70a5ba57a", "metadata": {}, "source": [ - "## Synthesizing the QAOA Circuit and Solving the Problem\n", - "\n", - "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" + "We now solve the problem by calling the `optimize` method of the `CombinatorialProblem` object. For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`maxiter`) and the $\\alpha$-parameter (`quantile`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "73cccd8c", + "execution_count": 8, + "id": "ff59d10e-c215-42a2-b232-df77fd775aff", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:12.336365Z", - "iopub.status.busy": "2024-05-07T15:06:12.336172Z", - "iopub.status.idle": "2024-05-07T15:06:14.856707Z", - "shell.execute_reply": "2024-05-07T15:06:14.855692Z" - }, - "pycharm": { - "name": "#%%\n" - }, "tags": [] }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/5c17bd7f-2b65-4deb-94a5-6fb8708345d1?version=0.41.0.dev39%2B79c8fd0855\n" + "Optimization Progress: 61it [05:10, 5.09s/it] \n" ] } ], "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "45f19792-d1ec-48b4-bc15-0fe881e48cd9", - "metadata": {}, - "source": [ - "We now solve the problem by calling the `execute` function on the quantum program we have generated:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "c6607c43-7b33-44dd-9e38-b90c2db888e5", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:14.861747Z", - "iopub.status.busy": "2024-05-07T15:06:14.861264Z", - "iopub.status.idle": "2024-05-07T15:06:18.624172Z", - "shell.execute_reply": "2024-05-07T15:06:18.623365Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "result = execute(qprog).result_value()" + "optimized_params = combi.optimize(execution_preferences, maxiter=60, quantile=0.7)" ] }, { "cell_type": "markdown", - "id": "90c622a1-d8ae-47ac-a924-86d5b73bbd45", + "id": "2d0f1a15-90ac-44dc-ae1b-b3c1c62d3d92", "metadata": {}, "source": [ "We can check the convergence of the run:" @@ -379,55 +271,75 @@ }, { "cell_type": "code", - "execution_count": 11, - "id": "7cff5dd0-312b-45b3-8af3-0fd6fa04b6e9", + "execution_count": 9, + "id": "858ea131-6109-47cc-ba00-55ba0e8f09f9", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:18.628597Z", - "iopub.status.busy": "2024-05-07T15:06:18.628037Z", - "iopub.status.idle": "2024-05-07T15:06:18.667398Z", - "shell.execute_reply": "2024-05-07T15:06:18.666685Z" - }, + "scrolled": true, "tags": [] }, "outputs": [ { "data": { - "image/jpeg": "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", - "image/png": "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", "text/plain": [ - "" + "Text(0.5, 1.0, 'Cost convergence')" ] }, - "execution_count": 11, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "result.convergence_graph" + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(combi.cost_trace)\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.title(\"Cost convergence\")" + ] + }, + { + "cell_type": "markdown", + "id": "23969de4-f4b9-4e55-a09d-df4cbe4eb3ac", + "metadata": { + "tags": [] + }, + "source": [ + "# Optimization Results" ] }, { "cell_type": "markdown", - "id": "a5a26d5c-ffc0-40bc-9964-e9fb6e16f232", + "id": "9159388c-fe90-436d-b0aa-9cf6d6148c5f", "metadata": {}, "source": [ - "And print the optimization results:" + "We can also examine the statistics of the algorithm. The optimization is always defined as a minimzation problem, so the positive maximization objective was tranlated to a negative minimization one by the Pyomo to qmod translator." + ] + }, + { + "cell_type": "markdown", + "id": "93232ede-dfc9-4eba-8270-e6039af36c38", + "metadata": {}, + "source": [ + "In order to get samples with the optimized parameters, we call the `sample` method:" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "9e5789ba-f1a5-4108-a0fa-a1b90870da1f", + "execution_count": 10, + "id": "f0fb79e2-719a-42f6-a9bd-18a67d490aad", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:18.670930Z", - "iopub.status.busy": "2024-05-07T15:06:18.670670Z", - "iopub.status.idle": "2024-05-07T15:06:19.843274Z", - "shell.execute_reply": "2024-05-07T15:06:19.842574Z" - }, - "tags": [] + "scrolled": true }, "outputs": [ { @@ -451,144 +363,102 @@ " \n", " \n", " \n", + " solution\n", " probability\n", " cost\n", - " solution\n", - " count\n", " \n", " \n", " \n", " \n", - " 98\n", - " 0.003\n", + " 180\n", + " {'w': [1, 2, 1], 'budget_rule_slack_var': [0, ...\n", + " 0.000977\n", " -4.8\n", - " [1, 2, 1]\n", - " 3\n", " \n", " \n", - " 141\n", - " 0.003\n", - " -4.8\n", - " [1, 2, 1]\n", - " 3\n", + " 515\n", + " {'w': [3, 1, 2], 'budget_rule_slack_var': [0, ...\n", + " 0.000488\n", + " -4.6\n", " \n", " \n", - " 35\n", - " 0.006\n", - " -4.8\n", - " [2, 1, 1]\n", - " 6\n", + " 112\n", + " {'w': [2, 2, 2], 'budget_rule_slack_var': [0, ...\n", + " 0.001465\n", + " -4.4\n", " \n", " \n", - " 5\n", - " 0.010\n", - " -4.8\n", - " [2, 1, 1]\n", - " 10\n", + " 713\n", + " {'w': [2, 1, 2], 'budget_rule_slack_var': [1, ...\n", + " 0.000488\n", + " -4.3\n", " \n", " \n", - " 210\n", - " 0.002\n", - " -4.8\n", - " [1, 2, 1]\n", - " 2\n", + " 1285\n", + " {'w': [1, 1, 0], 'budget_rule_slack_var': [1, ...\n", + " 0.000488\n", + " -4.2\n", " \n", " \n", "\n", "" ], "text/plain": [ - " probability cost solution count\n", - "98 0.003 -4.8 [1, 2, 1] 3\n", - "141 0.003 -4.8 [1, 2, 1] 3\n", - "35 0.006 -4.8 [2, 1, 1] 6\n", - "5 0.010 -4.8 [2, 1, 1] 10\n", - "210 0.002 -4.8 [1, 2, 1] 2" + " solution probability cost\n", + "180 {'w': [1, 2, 1], 'budget_rule_slack_var': [0, ... 0.000977 -4.8\n", + "515 {'w': [3, 1, 2], 'budget_rule_slack_var': [0, ... 0.000488 -4.6\n", + "112 {'w': [2, 2, 2], 'budget_rule_slack_var': [0, ... 0.001465 -4.4\n", + "713 {'w': [2, 1, 2], 'budget_rule_slack_var': [1, ... 0.000488 -4.3\n", + "1285 {'w': [1, 1, 0], 'budget_rule_slack_var': [1, ... 0.000488 -4.2" ] }, - "execution_count": 12, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import pandas as pd\n", - "\n", - "from classiq.applications.combinatorial_optimization import (\n", - " get_optimization_solution_from_pyo,\n", - ")\n", - "\n", - "solution = get_optimization_solution_from_pyo(\n", - " portfolio_model, vqe_result=result, penalty_energy=qaoa_config.penalty_energy\n", - ")\n", - "optimization_result = pd.DataFrame.from_records(solution)\n", - "optimization_result.sort_values(by=\"cost\", ascending=True).head(5)" + "optimization_result = combi.sample(optimized_params)\n", + "optimization_result.sort_values(by=\"cost\").head(5)" + ] + }, + { + "cell_type": "markdown", + "id": "ac53b57d-8168-498e-ab04-e8dcbea1cfc1", + "metadata": {}, + "source": [ + "We will also want to compare the optimized results to uniformly sampled results:" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "05449034-19e5-4b5d-80ea-7b2ba7ccd877", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:19.845777Z", - "iopub.status.busy": "2024-05-07T15:06:19.845472Z", - "iopub.status.idle": "2024-05-07T15:06:19.849615Z", - "shell.execute_reply": "2024-05-07T15:06:19.848912Z" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "x = [2, 1, 1] , cost = -4.800000000000001\n" - ] - } - ], + "execution_count": 11, + "id": "843cff7f-5230-4855-a1dc-13cbe386fa40", + "metadata": {}, + "outputs": [], "source": [ - "idx = optimization_result.cost.idxmin()\n", - "print(\n", - " \"x =\", optimization_result.solution[idx], \", cost =\", optimization_result.cost[idx]\n", - ")" + "uniform_result = combi.sample_uniform()" ] }, { "cell_type": "markdown", - "id": "b170b0ef-1e3f-4680-a7d4-82b4e537d785", + "id": "9c96cee5-1621-41b1-ace7-b3b59104acb4", "metadata": {}, "source": [ - "And the histogram:" + "And compare the histograms:" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "f48034c6-8000-4bcf-83b0-e3a76a38d9c7", + "execution_count": 12, + "id": "b6eaa101-6f7a-4497-a208-0b6a2d33416a", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:19.851995Z", - "iopub.status.busy": "2024-05-07T15:06:19.851643Z", - "iopub.status.idle": "2024-05-07T15:06:20.087635Z", - "shell.execute_reply": "2024-05-07T15:06:20.086888Z" - }, "tags": [] }, "outputs": [ { "data": { - "text/plain": [ - "array([[]], dtype=object)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -598,7 +468,52 @@ } ], "source": [ - "optimization_result.hist(\"cost\", weights=optimization_result[\"probability\"])" + "optimization_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=40,\n", + " edgecolor=\"black\",\n", + " weights=optimization_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"optimized\",\n", + ")\n", + "uniform_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=40,\n", + " edgecolor=\"black\",\n", + " weights=uniform_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"uniform\",\n", + ")\n", + "plt.legend()\n", + "plt.ylabel(\"Probability\", fontsize=16)\n", + "plt.xlabel(\"cost\", fontsize=16)\n", + "plt.tick_params(axis=\"both\", labelsize=14)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "05449034-19e5-4b5d-80ea-7b2ba7ccd877", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x = [1, 2, 1] , cost = -4.8\n" + ] + } + ], + "source": [ + "best_solution = optimization_result.loc[optimization_result.cost.idxmin()]\n", + "print(\n", + " \"x =\",\n", + " best_solution.solution[\"w\"],\n", + " \", cost =\",\n", + " best_solution.cost,\n", + ")" ] }, { @@ -611,15 +526,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "id": "324c9a09", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:06:20.092527Z", - "iopub.status.busy": "2024-05-07T15:06:20.091284Z", - "iopub.status.idle": "2024-05-07T15:06:20.178692Z", - "shell.execute_reply": "2024-05-07T15:06:20.177959Z" - }, "pycharm": { "name": "#%%\n" }, @@ -634,20 +543,21 @@ "\n", " Variables:\n", " w : Size=3, Index=w_index\n", - " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", - " 0 : 0 : 1.9999999999999998 : 2 : False : False : Integers\n", - " 1 : 0 : 1.0000000000000002 : 2 : False : False : Integers\n", - " 2 : 0 : 1.0000000000000002 : 2 : False : False : Integers\n", + " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", + " 0 : 0 : 2.0 : 7 : False : False : Integers\n", + " 1 : 0 : 1.0 : 7 : False : False : Integers\n", + " 2 : 0 : 1.0 : 7 : False : False : Integers\n", "\n", " Objectives:\n", " cost : Size=1, Index=None, Active=True\n", " Key : Active : Value\n", - " None : True : -4.8\n", + " None : True : -4.800000000000001\n", "\n", " Constraints:\n", " budget_rule : Size=1\n", " Key : Lower : Body : Upper\n", - " None : None : 4.0 : 6.0\n" + " None : None : 4.0 : 6.0\n", + "Classical solution: [2, 1, 1]\n" ] } ], @@ -657,7 +567,11 @@ "solver = SolverFactory(\"couenne\")\n", "solver.solve(portfolio_model)\n", "\n", - "portfolio_model.display()" + "portfolio_model.display()\n", + "classical_solution = [\n", + " round(pyo.value(portfolio_model.w[i])) for i in range(len(portfolio_model.w))\n", + "]\n", + "print(\"Classical solution:\", classical_solution)" ] }, { @@ -704,7 +618,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.4" }, "vscode": { "interpreter": { diff --git a/applications/finance/portfolio_optimization/portfolio_optimization.qmod b/applications/finance/portfolio_optimization/portfolio_optimization.qmod index f5008b88e..bf1751dd0 100644 --- a/applications/finance/portfolio_optimization/portfolio_optimization.qmod +++ b/applications/finance/portfolio_optimization/portfolio_optimization.qmod @@ -1,667 +1,15 @@ -hamiltonian: PauliTerm[] = [ - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=7.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=0.8 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=0.8 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=0.8 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=0.8 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-0.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-0.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-0.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-0.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-0.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=0.65 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=0.65 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=0.65 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=0.65 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=0.9 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=0.9 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=0.9 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=0.9 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=6.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=1.45 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.45 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.45 - } -]; - -qfunc main(params_list: real[2], output target: qbit[9]) { - allocate(target.len, target); - qaoa_penalty(target.len, params_list, hamiltonian, target); +qstruct QAOAVars { + w: qnum<3, False, 0>[3]; + budget_rule_slack_var: qbit[3]; } -cscope ``` -vqe_result = vqe( -hamiltonian=hamiltonian, -maximize=False, -initial_point=[0.0, 0.2239532619279455], -optimizer=Optimizer.COBYLA, -max_iteration=60, -tolerance=0.0, -step_size=0.0, -skip_compute_variance=False, -alpha_cvar=0.7 -) - -save({"vqe_result": vqe_result, "hamiltonian": hamiltonian}) -``` +qfunc main(params: real[6], output v: QAOAVars) { + allocate(v.size, v); + hadamard_transform(v); + repeat (i: 3) { + phase (-(((((((v.w[0] * (((0.9 * v.w[0]) + (0.5 * v.w[1])) - (0.7 * v.w[2]))) - (3 * v.w[0])) + (v.w[1] * (((0.5 * v.w[0]) + (0.9 * v.w[1])) - (0.2 * v.w[2])))) - (4 * v.w[1])) + (v.w[2] * ((((-0.7) * v.w[0]) - (0.2 * v.w[1])) + (0.9 * v.w[2])))) + v.w[2]) + (360.0 * ((((((((0.1667 * v.budget_rule_slack_var[0]) + (0.3333 * v.budget_rule_slack_var[1])) + (0.5 * v.budget_rule_slack_var[2])) + (0.1667 * v.w[0])) + (0.1667 * v.w[1])) + (0.1667 * v.w[2])) - 1) ** 2))), params[i]); + apply_to_all(lambda(q) { + RX(params[3 + i], q); + }, v); + } +} diff --git a/applications/finance/portfolio_optimization/portfolio_optimization.synthesis_options.json b/applications/finance/portfolio_optimization/portfolio_optimization.synthesis_options.json index 0967ef424..8e4d13d71 100644 --- a/applications/finance/portfolio_optimization/portfolio_optimization.synthesis_options.json +++ b/applications/finance/portfolio_optimization/portfolio_optimization.synthesis_options.json @@ -1 +1,43 @@ -{} +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "p", + "cz", + "h", + "t", + "rz", + "u1", + "z", + "ry", + "sxdg", + "cx", + "rx", + "u2", + "cy", + "u", + "y", + "sx", + "r", + "s", + "tdg", + "id", + "sdg", + "x" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": 4243313233 + } +} diff --git a/applications/optimization/integer_linear_programming/integer_linear_programming.ipynb b/applications/optimization/integer_linear_programming/integer_linear_programming.ipynb index 62a5e07f8..e5dafe97a 100644 --- a/applications/optimization/integer_linear_programming/integer_linear_programming.ipynb +++ b/applications/optimization/integer_linear_programming/integer_linear_programming.ipynb @@ -42,29 +42,7 @@ "\n", "# Solving with the Classiq platform\n", "\n", - "We go through the steps of solving the problem with the Classiq platform, using QAOA algorithm [[2](#QAOA)]. The solution is based on defining a pyomo model for the optimization problem we would like to solve." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "49a9588b-e79e-4813-b7c5-ac068d7b930c", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:03.709227Z", - "iopub.status.busy": "2024-05-07T16:03:03.708726Z", - "iopub.status.idle": "2024-05-07T16:03:04.242888Z", - "shell.execute_reply": "2024-05-07T16:03:04.242261Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "import networkx as nx\n", - "import numpy as np\n", - "import pyomo.core as pyo\n", - "from IPython.display import Markdown, display\n", - "from matplotlib import pyplot as plt" + "We go through the steps of solving the problem with the Classiq platform, using QAOA algorithm [[2](#QAOA)]. The solution is based on defining a Pyomo model for the optimization problem we would like to solve." ] }, { @@ -74,19 +52,17 @@ "source": [ "## Building the Pyomo model from a graph input\n", "\n", - "We proceed by defining the pyomo model that will be used on the Classiq platform, using the mathematical formulation defined above:" + "We proceed by defining the Pyomo model that will be used on the Classiq platform, using the mathematical formulation defined above:" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "48889b21-557b-481c-80c5-3c0b5c91adb6", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:04.245996Z", - "iopub.status.busy": "2024-05-07T16:03:04.245397Z", - "iopub.status.idle": "2024-05-07T16:03:04.250669Z", - "shell.execute_reply": "2024-05-07T16:03:04.250107Z" + "ExecuteTime": { + "end_time": "2024-10-27T14:14:26.846158Z", + "start_time": "2024-10-27T14:14:26.840633Z" }, "tags": [] }, @@ -125,14 +101,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "6e5295f4-7ba6-4ff6-8782-1c4c2c7f85e4", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:04.253099Z", - "iopub.status.busy": "2024-05-07T16:03:04.252586Z", - "iopub.status.idle": "2024-05-07T16:03:04.257612Z", - "shell.execute_reply": "2024-05-07T16:03:04.257011Z" + "ExecuteTime": { + "end_time": "2024-10-27T14:14:27.078661Z", + "start_time": "2024-10-27T14:14:27.071956Z" } }, "outputs": [], @@ -142,22 +116,17 @@ "c = np.array([1, 2, 3])\n", "\n", "# Instantiate the model\n", - "ilp_model = ilp(A, b, c, 4)" + "ilp_model = ilp(A, b, c, 3)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "345330b2-9c14-41f6-b4ba-e11fb9ca1565", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:04.259676Z", - "iopub.status.busy": "2024-05-07T16:03:04.259506Z", - "iopub.status.idle": "2024-05-07T16:03:04.264367Z", - "shell.execute_reply": "2024-05-07T16:03:04.263732Z" - }, - "jupyter": { - "outputs_hidden": true + "ExecuteTime": { + "end_time": "2024-10-27T14:14:27.096276Z", + "start_time": "2024-10-27T14:14:27.091814Z" }, "tags": [] }, @@ -177,9 +146,9 @@ "1 Var Declarations\n", " x : Size=3, Index=x_index\n", " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", - " 0 : 0 : None : 4 : False : True : NonNegativeIntegers\n", - " 1 : 0 : None : 4 : False : True : NonNegativeIntegers\n", - " 2 : 0 : None : 4 : False : True : NonNegativeIntegers\n", + " 0 : 0 : None : 3 : False : True : NonNegativeIntegers\n", + " 1 : 0 : None : 3 : False : True : NonNegativeIntegers\n", + " 2 : 0 : None : 3 : False : True : NonNegativeIntegers\n", "\n", "1 Objective Declarations\n", " cost : Size=1, Index=None, Active=True\n", @@ -210,95 +179,73 @@ "source": [ "## Setting Up the Classiq Problem Instance\n", "\n", - "In order to solve the Pyomo model defined above, we use the Classiq combinatorial optimization engine. For the quantum part of the QAOA algorithm (`QAOAConfig`) - define the number of repetitions (`num_layers`):" + "In order to solve the Pyomo model defined above, we use the `CombinatorialProblem` quantum object. Under the hood it tranlates the Pyomo model to a quantum model of the QAOA algorithm, with cost hamiltonian translated from the Pyomo model. We can choose the number of layers for the QAOA ansatz using the argument `num_layers`, and the `penalty_factor`, which will be the coefficient of the constraints term in the cost hamiltonian." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "816b468f-a59f-4f2f-8337-4a9d66548425", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:04.266876Z", - "iopub.status.busy": "2024-05-07T16:03:04.266379Z", - "iopub.status.idle": "2024-05-07T16:03:06.767843Z", - "shell.execute_reply": "2024-05-07T16:03:06.767070Z" - }, "tags": [] }, "outputs": [], "source": [ "from classiq import *\n", - "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", + "from classiq.applications.combinatorial_optimization import CombinatorialProblem\n", "\n", - "qaoa_config = QAOAConfig(num_layers=3)" - ] - }, - { - "cell_type": "markdown", - "id": "db34d5ac-6877-4285-8dec-7bf7b37eb783", - "metadata": {}, - "source": [ - "For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`max_iteration`) and the $\\alpha$-parameter (`alpha_cvar`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" + "combi = CombinatorialProblem(pyo_model=ilp_model, num_layers=3, penalty_factor=10)\n", + "\n", + "qmod = combi.get_model()" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "e41d0dd3-4135-4330-9ba3-c1b30c339a74", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:06.773025Z", - "iopub.status.busy": "2024-05-07T16:03:06.771615Z", - "iopub.status.idle": "2024-05-07T16:03:06.776787Z", - "shell.execute_reply": "2024-05-07T16:03:06.776135Z" - }, - "pycharm": { - "name": "#%%\n" - }, - "tags": [] - }, + "execution_count": 5, + "id": "62ec28b3-cb49-411a-8c4a-8004fff6c105", + "metadata": {}, "outputs": [], "source": [ - "optimizer_config = OptimizerConfig(max_iteration=90, alpha_cvar=0.7)" + "write_qmod(qmod, \"integer_linear_programming\")" ] }, { "cell_type": "markdown", - "id": "214d6051-43b8-4b9d-8454-f9cdb62b4cf0", + "id": "943291f0-6a9f-4286-a69d-ef13a0a12ef6", "metadata": {}, "source": [ - "Lastly, we load the model, based on the problem and algorithm parameters, which we can use to solve the problem:" + "## Synthesizing the QAOA Circuit and Solving the Problem\n", + "\n", + "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "0243019c-6fc3-435f-b6ec-8b4355d6660c", + "execution_count": 6, + "id": "1d71e29a-5d53-49c4-84b2-45f59be4da31", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:06.781190Z", - "iopub.status.busy": "2024-05-07T16:03:06.780012Z", - "iopub.status.idle": "2024-05-07T16:03:09.997939Z", - "shell.execute_reply": "2024-05-07T16:03:09.997174Z" - }, "pycharm": { "name": "#%%\n" }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://nightly.platform.classiq.io/circuit/2d391a9b-4f75-4b90-ba76-fe6eb0cc3dec?version=0.63.0.dev2\n" + ] + } + ], "source": [ - "qmod = construct_combinatorial_optimization_model(\n", - " pyo_model=ilp_model,\n", - " qaoa_config=qaoa_config,\n", - " optimizer_config=optimizer_config,\n", - ")" + "qprog = combi.get_qprog()\n", + "show(qprog)" ] }, { "cell_type": "markdown", - "id": "1fcc3812-c9d0-421c-84bb-38047297b33f", + "id": "b119464b-9d46-4ea0-ba4a-1734f3e0e3e5", "metadata": {}, "source": [ "We also set the quantum backend we want to execute on:" @@ -306,107 +253,44 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "53bc041f-065c-44d2-b220-dafd9d0504ac", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:10.003163Z", - "iopub.status.busy": "2024-05-07T16:03:10.001962Z", - "iopub.status.idle": "2024-05-07T16:03:10.044489Z", - "shell.execute_reply": "2024-05-07T16:03:10.043733Z" - }, - "tags": [] - }, + "execution_count": 7, + "id": "7d188c69-21d1-4afe-86b1-46229e91a01e", + "metadata": {}, "outputs": [], "source": [ - "from classiq.execution import ClassiqBackendPreferences\n", + "from classiq.execution import *\n", "\n", - "qmod = set_execution_preferences(\n", - " qmod, backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", + "execution_preferences = ExecutionPreferences(\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\"),\n", ")" ] }, - { - "cell_type": "code", - "execution_count": 9, - "id": "62ec28b3-cb49-411a-8c4a-8004fff6c105", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:10.050654Z", - "iopub.status.busy": "2024-05-07T16:03:10.049516Z", - "iopub.status.idle": "2024-05-07T16:03:10.111490Z", - "shell.execute_reply": "2024-05-07T16:03:10.110833Z" - } - }, - "outputs": [], - "source": [ - "write_qmod(qmod, \"integer_linear_programming\")" - ] - }, { "cell_type": "markdown", - "id": "943291f0-6a9f-4286-a69d-ef13a0a12ef6", + "id": "07621d7c-0e54-4adb-9c47-8fd99a346e29", "metadata": {}, "source": [ - "## Synthesizing the QAOA Circuit and Solving the Problem\n", - "\n", - "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" + "We now solve the problem by calling the `optimize` method of the `CombinatorialProblem` object. For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`maxiter`) and the $\\alpha$-parameter (`quantile`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "1d71e29a-5d53-49c4-84b2-45f59be4da31", + "execution_count": 8, + "id": "62d12d20-1c80-4a9e-bb6b-b1fddc6cbe40", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:10.116541Z", - "iopub.status.busy": "2024-05-07T16:03:10.115462Z", - "iopub.status.idle": "2024-05-07T16:03:15.845871Z", - "shell.execute_reply": "2024-05-07T16:03:15.845158Z" - }, - "pycharm": { - "name": "#%%\n" - }, "tags": [] }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/183bcd6c-83c8-4610-828f-d7cd40f9fb85?version=0.41.0.dev39%2B79c8fd0855\n" + "Optimization Progress: 76%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎ | 68/90 [02:24<00:46, 2.12s/it]\n" ] } ], "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "80238cf9-d7bd-46e5-9d48-b7cf23a6b304", - "metadata": {}, - "source": [ - "We now solve the problem by calling the `execute` function on the quantum program we have generated:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "62d12d20-1c80-4a9e-bb6b-b1fddc6cbe40", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:15.848412Z", - "iopub.status.busy": "2024-05-07T16:03:15.848000Z", - "iopub.status.idle": "2024-05-07T16:03:33.645387Z", - "shell.execute_reply": "2024-05-07T16:03:33.644679Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "result = execute(qprog).result_value()" + "optimized_params = combi.optimize(execution_preferences, maxiter=90, quantile=0.7)" ] }, { @@ -419,33 +303,40 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "id": "02454398-b229-403c-824a-b1eb539fbc1f", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:33.648272Z", - "iopub.status.busy": "2024-05-07T16:03:33.647738Z", - "iopub.status.idle": "2024-05-07T16:03:33.672693Z", - "shell.execute_reply": "2024-05-07T16:03:33.672075Z" - }, "tags": [] }, "outputs": [ { "data": { - "image/jpeg": "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", - "image/png": "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", "text/plain": [ - "" + "Text(0.5, 1.0, 'Cost convergence')" ] }, - "execution_count": 12, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "result.convergence_graph" + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(combi.cost_trace)\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.title(\"Cost convergence\")" ] }, { @@ -463,22 +354,22 @@ "id": "670eddd3-2da7-4a88-b571-7884ef24f60c", "metadata": {}, "source": [ - "We can also examine the statistics of the algorithm:" + "We can also examine the statistics of the algorithm. The optimization is always defined as a minimzation problem, so the positive maximization objective was tranlated to a negative minimization one by the Pyomo to qmod translator." + ] + }, + { + "cell_type": "markdown", + "id": "c99a7e3e-5203-4893-b970-dc23739f6df2", + "metadata": {}, + "source": [ + "In order to get samples with the optimized parameters, we call the `sample` method:" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "516d78ba-2951-46eb-b1af-efe877513556", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:33.675397Z", - "iopub.status.busy": "2024-05-07T16:03:33.674963Z", - "iopub.status.idle": "2024-05-07T16:03:37.107224Z", - "shell.execute_reply": "2024-05-07T16:03:37.106517Z" - }, - "tags": [] - }, + "execution_count": 10, + "id": "9638f749-a60b-4176-a4ea-50d7c2bb986f", + "metadata": {}, "outputs": [ { "data": { @@ -501,116 +392,109 @@ " \n", " \n", " \n", + " solution\n", " probability\n", " cost\n", - " solution\n", - " count\n", " \n", " \n", " \n", " \n", - " 6\n", - " 0.019\n", - " 3.0\n", - " [0, 0, 1]\n", - " 19\n", + " 18\n", + " {'x': [0, 0, 1], 'monotone_rule_1_slack_var': ...\n", + " 0.011719\n", + " -3.000000e+00\n", " \n", " \n", - " 15\n", - " 0.015\n", - " 3.0\n", - " [0, 0, 1]\n", - " 15\n", + " 0\n", + " {'x': [0, 1, 0], 'monotone_rule_1_slack_var': ...\n", + " 0.030762\n", + " -2.000000e+00\n", " \n", " \n", - " 24\n", - " 0.011\n", - " 2.0\n", - " [0, 1, 0]\n", - " 11\n", + " 9\n", + " {'x': [0, 0, 0], 'monotone_rule_1_slack_var': ...\n", + " 0.018066\n", + " 1.527468e-150\n", " \n", " \n", - " 106\n", - " 0.002\n", - " 2.0\n", - " [0, 0, 2]\n", - " 2\n", + " 150\n", + " {'x': [0, 0, 1], 'monotone_rule_1_slack_var': ...\n", + " 0.001465\n", + " 7.000000e+00\n", " \n", " \n", - " 3\n", - " 0.025\n", - " 2.0\n", - " [0, 1, 0]\n", - " 25\n", + " 130\n", + " {'x': [0, 1, 0], 'monotone_rule_1_slack_var': ...\n", + " 0.001953\n", + " 8.000000e+00\n", " \n", " \n", "\n", "" ], "text/plain": [ - " probability cost solution count\n", - "6 0.019 3.0 [0, 0, 1] 19\n", - "15 0.015 3.0 [0, 0, 1] 15\n", - "24 0.011 2.0 [0, 1, 0] 11\n", - "106 0.002 2.0 [0, 0, 2] 2\n", - "3 0.025 2.0 [0, 1, 0] 25" + " solution probability \\\n", + "18 {'x': [0, 0, 1], 'monotone_rule_1_slack_var': ... 0.011719 \n", + "0 {'x': [0, 1, 0], 'monotone_rule_1_slack_var': ... 0.030762 \n", + "9 {'x': [0, 0, 0], 'monotone_rule_1_slack_var': ... 0.018066 \n", + "150 {'x': [0, 0, 1], 'monotone_rule_1_slack_var': ... 0.001465 \n", + "130 {'x': [0, 1, 0], 'monotone_rule_1_slack_var': ... 0.001953 \n", + "\n", + " cost \n", + "18 -3.000000e+00 \n", + "0 -2.000000e+00 \n", + "9 1.527468e-150 \n", + "150 7.000000e+00 \n", + "130 8.000000e+00 " ] }, - "execution_count": 13, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import pandas as pd\n", - "\n", - "from classiq.applications.combinatorial_optimization import (\n", - " get_optimization_solution_from_pyo,\n", - ")\n", - "\n", - "solution = get_optimization_solution_from_pyo(\n", - " ilp_model, vqe_result=result, penalty_energy=qaoa_config.penalty_energy\n", - ")\n", - "\n", - "optimization_result = pd.DataFrame.from_records(solution)\n", - "optimization_result.sort_values(by=\"cost\", ascending=False).head(5)" + "optimization_result = combi.sample(optimized_params)\n", + "optimization_result.sort_values(by=\"cost\").head(5)" ] }, { "cell_type": "markdown", - "id": "687f492b-a4a5-49c6-964c-8959b035bb93", + "id": "f08c8085-b50a-41a1-9359-46413f60739c", "metadata": {}, "source": [ - "And the histogram:" + "We will also want to compare the optimized results to uniformly sampled results:" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "31a4e74d-b2b8-42e0-826d-de7b51de1fe8", + "execution_count": 11, + "id": "25277397-d7a5-4466-af4c-fee2e17bc8b9", + "metadata": {}, + "outputs": [], + "source": [ + "uniform_result = combi.sample_uniform()" + ] + }, + { + "cell_type": "markdown", + "id": "91831ceb-ca0b-44d5-9a1d-e8c70a139592", + "metadata": {}, + "source": [ + "And compare the histograms:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "77668ce1-64f6-4086-b0fe-597ded8ad0e0", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:37.110324Z", - "iopub.status.busy": "2024-05-07T16:03:37.109906Z", - "iopub.status.idle": "2024-05-07T16:03:37.306818Z", - "shell.execute_reply": "2024-05-07T16:03:37.306110Z" - }, "tags": [] }, "outputs": [ { "data": { - "text/plain": [ - "array([[]], dtype=object)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -620,7 +504,26 @@ } ], "source": [ - "optimization_result.hist(\"cost\", weights=optimization_result[\"probability\"])" + "optimization_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=30,\n", + " edgecolor=\"black\",\n", + " weights=optimization_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"optimized\",\n", + ")\n", + "uniform_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=30,\n", + " edgecolor=\"black\",\n", + " weights=uniform_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"uniform\",\n", + ")\n", + "plt.legend()\n", + "plt.ylabel(\"Probability\", fontsize=16)\n", + "plt.xlabel(\"cost\", fontsize=16)\n", + "plt.tick_params(axis=\"both\", labelsize=14)" ] }, { @@ -633,31 +536,27 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "id": "4326e84b-26f6-4ea9-a53b-090fb3658b8c", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:37.309483Z", - "iopub.status.busy": "2024-05-07T16:03:37.308945Z", - "iopub.status.idle": "2024-05-07T16:03:37.313874Z", - "shell.execute_reply": "2024-05-07T16:03:37.313442Z" - }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ - "[0, 0, 1]" + "{'x': [0, 0, 1],\n", + " 'monotone_rule_1_slack_var': [0],\n", + " 'monotone_rule_2_slack_var': [0]}" ] }, - "execution_count": 15, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "best_solution = optimization_result.solution[optimization_result.cost.idxmax()]\n", + "best_solution = optimization_result.solution[optimization_result.cost.idxmin()]\n", "best_solution" ] }, @@ -679,15 +578,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "id": "5a7ca4b6-25a0-46dd-b5cc-de6a639a6f57", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:37.316362Z", - "iopub.status.busy": "2024-05-07T16:03:37.315830Z", - "iopub.status.idle": "2024-05-07T16:03:37.375955Z", - "shell.execute_reply": "2024-05-07T16:03:37.375336Z" - }, "pycharm": { "name": "#%%\n" }, @@ -748,7 +641,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.4" }, "vscode": { "interpreter": { diff --git a/applications/optimization/integer_linear_programming/integer_linear_programming.qmod b/applications/optimization/integer_linear_programming/integer_linear_programming.qmod index efe08cc4b..d447b9a52 100644 --- a/applications/optimization/integer_linear_programming/integer_linear_programming.qmod +++ b/applications/optimization/integer_linear_programming/integer_linear_programming.qmod @@ -1,1079 +1,16 @@ -hamiltonian: PauliTerm[] = [ - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=152.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-11.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-11.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-25.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-25.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-50.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-24.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-24.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-49.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-25.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-25.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=-51.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=4.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=4.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=4.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=4.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=4.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=4.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=5.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=10.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=10.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=10.0 - } -]; - -qfunc main(params_list: real[6], output target: qbit[11]) { - allocate(target.len, target); - qaoa_penalty(target.len, params_list, hamiltonian, target); +qstruct QAOAVars { + x: qnum<2, False, 0>[3]; + monotone_rule_1_slack_var: qbit[1]; + monotone_rule_2_slack_var: qbit[1]; } -cscope ``` -vqe_result = vqe( -hamiltonian=hamiltonian, -maximize=True, -initial_point=[0.0, 0.03762827822120867, 0.018814139110604335, 0.018814139110604335, 0.03762827822120867, 0.0], -optimizer=Optimizer.COBYLA, -max_iteration=90, -tolerance=0.0, -step_size=0.0, -skip_compute_variance=False, -alpha_cvar=0.7 -) - -save({"vqe_result": vqe_result, "hamiltonian": hamiltonian}) -``` +qfunc main(params: real[6], output v: QAOAVars) { + allocate(v.size, v); + hadamard_transform(v); + repeat (i: 3) { + phase (-(((((((((10 * v.x[0]) * v.x[1]) + ((10 * v.x[0]) * v.x[2])) - v.x[0]) + ((10 * v.x[1]) * v.x[2])) - (2 * v.x[1])) - (3 * v.x[2])) + (10 * (((((v.monotone_rule_1_slack_var[0] + v.x[0]) + v.x[1]) + v.x[2]) - 1.0) ** 2))) + (10 * (((((v.monotone_rule_2_slack_var[0] + v.x[0]) + v.x[1]) + v.x[2]) - 1.0) ** 2))), params[i]); + apply_to_all(lambda(q) { + RX(params[3 + i], q); + }, v); + } +} diff --git a/applications/optimization/integer_linear_programming/integer_linear_programming.synthesis_options.json b/applications/optimization/integer_linear_programming/integer_linear_programming.synthesis_options.json index 0967ef424..0523412fc 100644 --- a/applications/optimization/integer_linear_programming/integer_linear_programming.synthesis_options.json +++ b/applications/optimization/integer_linear_programming/integer_linear_programming.synthesis_options.json @@ -1 +1,43 @@ -{} +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "t", + "rz", + "sx", + "cy", + "rx", + "cz", + "tdg", + "u", + "ry", + "y", + "u1", + "h", + "sdg", + "cx", + "r", + "sxdg", + "x", + "id", + "p", + "z", + "u2", + "s" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": 3739250181 + } +} diff --git a/applications/optimization/knapsack_binary/knapsack_binary.ipynb b/applications/optimization/knapsack_binary/knapsack_binary.ipynb deleted file mode 100644 index 077e929aa..000000000 --- a/applications/optimization/knapsack_binary/knapsack_binary.ipynb +++ /dev/null @@ -1,642 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "13d83b59-57f7-48ee-8bff-deda7d28edc5", - "metadata": { - "tags": [] - }, - "source": [ - "\n", - "# Binary Knapsack\n" - ] - }, - { - "cell_type": "markdown", - "id": "6d56bb6d-9f3b-45db-8e98-b50f27af7505", - "metadata": {}, - "source": [ - "## Background\n", - "\n", - "Given a set of items, determine how many items to put in the knapsack to maximize their summed value.\n", - "\n", - "#### Define:\n", - "\n", - "- $x_i$ is the number of items from each type.\n", - "\n", - "- $v_i$ is the value of each item.\n", - "\n", - "- $w_i$ is the weight of each item.\n", - "\n", - "- $D$ is the range of $x$.\n", - "\n", - "Find $x$ that maximizes the value: $\\begin{aligned}\n", - "\\max_{x_i \\in D} \\Sigma_i v_i x_i\\\\\n", - "\\end{aligned}$\n", - "\n", - "and constrained by the weight: $\\begin{aligned}\n", - "\\Sigma_i w_i x_i = C\n", - "\\end{aligned}$\n", - "\n", - "## Problem Versions\n", - "\n", - "**Binary Knapsack**\n", - "\n", - "Range: $D = \\{0, 1\\}$\n", - "\n", - "**Integer Knapsack**\n", - "\n", - "Range: $D = [0, b]$\n" - ] - }, - { - "cell_type": "markdown", - "id": "fdbcef63-3c8e-4f0a-a4fb-9058807fa3a8", - "metadata": { - "tags": [] - }, - "source": [ - "## Knapsack with binary variables and equality constraint\n" - ] - }, - { - "cell_type": "markdown", - "id": "0bdc4e6a-199b-44b3-bd3f-fd24722b616b", - "metadata": {}, - "source": [ - "### Define the optimization problem" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "83ddbd07-f7ab-4d80-b357-3890622d395f", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:29.057270Z", - "iopub.status.busy": "2024-05-07T16:07:29.055577Z", - "iopub.status.idle": "2024-05-07T16:07:29.609395Z", - "shell.execute_reply": "2024-05-07T16:07:29.608466Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pyomo.environ as pyo\n", - "\n", - "\n", - "def define_knapsack_model(weights, values, max_weight):\n", - " model = pyo.ConcreteModel()\n", - " num_items = len(weights)\n", - "\n", - " model.x = pyo.Var(range(num_items), domain=pyo.Binary)\n", - "\n", - " x_variables = np.array(list(model.x.values()))\n", - "\n", - " model.weight_constraint = pyo.Constraint(expr=x_variables @ weights == max_weight)\n", - "\n", - " model.value = pyo.Objective(expr=x_variables @ values, sense=pyo.maximize)\n", - "\n", - " return model" - ] - }, - { - "cell_type": "markdown", - "id": "3496c5d6-7df6-49fb-b5b9-5ba48d2b7d62", - "metadata": {}, - "source": [ - "### Initialize the model with parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "62a98e1c-5dbe-42f9-989e-83ee1df7196b", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:29.613987Z", - "iopub.status.busy": "2024-05-07T16:07:29.613427Z", - "iopub.status.idle": "2024-05-07T16:07:29.621699Z", - "shell.execute_reply": "2024-05-07T16:07:29.621009Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "knapsack_model = define_knapsack_model(\n", - " weights=[2, 3, 2.1, 1, 1, 2], values=[3, 5, 2, 1.5, 1.2, 2.7], max_weight=5\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "c78b22a0-9420-44bf-a60d-a7ce136dcaaf", - "metadata": { - "tags": [] - }, - "source": [ - "## Setting Up the Classiq Problem Instance\n", - "\n", - "In order to solve the Pyomo model defined above, we use the Classiq combinatorial optimization engine. For the quantum part of the QAOA algorithm (`QAOAConfig`) - define the number of repetitions (`num_layers`):" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "947293d1-ac9d-41aa-a162-f60ee16608dd", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:29.626219Z", - "iopub.status.busy": "2024-05-07T16:07:29.625007Z", - "iopub.status.idle": "2024-05-07T16:07:32.195601Z", - "shell.execute_reply": "2024-05-07T16:07:32.194974Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq import *\n", - "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", - "\n", - "qaoa_config = QAOAConfig(num_layers=5)" - ] - }, - { - "cell_type": "markdown", - "id": "fdfcb551-77c3-40f4-a54e-4231c7775f19", - "metadata": {}, - "source": [ - "For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`max_iteration`) and the $\\alpha$-parameter (`alpha_cvar`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "311e4855-403b-4f3d-a64e-7147be629470", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:32.198391Z", - "iopub.status.busy": "2024-05-07T16:07:32.198019Z", - "iopub.status.idle": "2024-05-07T16:07:32.201281Z", - "shell.execute_reply": "2024-05-07T16:07:32.200682Z" - }, - "pycharm": { - "name": "#%%\n" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "optimizer_config = OptimizerConfig(max_iteration=60, alpha_cvar=0.7)" - ] - }, - { - "cell_type": "markdown", - "id": "0f153f82-829a-44df-98c3-47f693d984df", - "metadata": {}, - "source": [ - "Lastly, we load the model, based on the problem and algorithm parameters, which we can use to solve the problem:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "fb32b921-1a7d-4c79-9cb0-6993b0eb6b6c", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:32.203585Z", - "iopub.status.busy": "2024-05-07T16:07:32.203227Z", - "iopub.status.idle": "2024-05-07T16:07:32.322318Z", - "shell.execute_reply": "2024-05-07T16:07:32.321660Z" - }, - "pycharm": { - "name": "#%%\n" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "qmod = construct_combinatorial_optimization_model(\n", - " pyo_model=knapsack_model,\n", - " qaoa_config=qaoa_config,\n", - " optimizer_config=optimizer_config,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "78d21bb2-0ac5-471e-a1c9-fb77df0400e7", - "metadata": {}, - "source": [ - "We also set the quantum backend we want to execute on:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "cc69a9e9-38d5-4c91-93dd-ad43bab0ca6d", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:32.325437Z", - "iopub.status.busy": "2024-05-07T16:07:32.324838Z", - "iopub.status.idle": "2024-05-07T16:07:32.335989Z", - "shell.execute_reply": "2024-05-07T16:07:32.335376Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "from classiq.execution import ClassiqBackendPreferences\n", - "\n", - "qmod = set_execution_preferences(\n", - " qmod, backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "a0ee5250-26c9-4329-a69e-d8075d05ebc6", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:32.338229Z", - "iopub.status.busy": "2024-05-07T16:07:32.338050Z", - "iopub.status.idle": "2024-05-07T16:07:32.351757Z", - "shell.execute_reply": "2024-05-07T16:07:32.351182Z" - } - }, - "outputs": [], - "source": [ - "write_qmod(qmod, \"knapsack_binary\")" - ] - }, - { - "cell_type": "markdown", - "id": "1a47c1c9-1b39-4c3a-b291-7e2082fb592e", - "metadata": {}, - "source": [ - "## Synthesizing the QAOA Circuit and Solving the Problem\n", - "\n", - "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "10f219ca-2836-4573-9764-70f39b685fca", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:32.354433Z", - "iopub.status.busy": "2024-05-07T16:07:32.353950Z", - "iopub.status.idle": "2024-05-07T16:07:36.930198Z", - "shell.execute_reply": "2024-05-07T16:07:36.929444Z" - }, - "pycharm": { - "name": "#%%\n" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/db610424-2d79-4db4-8c6c-17734c34b003?version=0.41.0.dev39%2B79c8fd0855\n" - ] - } - ], - "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "ce31eb36-c7df-4a0d-9e89-5ef477cc1a8c", - "metadata": {}, - "source": [ - "We now solve the problem by calling the `execute` function on the quantum program we have generated:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "c862d5d4-6d4a-4251-a0e1-d2d55b3a37f3", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:36.941434Z", - "iopub.status.busy": "2024-05-07T16:07:36.941056Z", - "iopub.status.idle": "2024-05-07T16:07:43.555821Z", - "shell.execute_reply": "2024-05-07T16:07:43.555252Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "result = execute(qprog).result_value()" - ] - }, - { - "cell_type": "markdown", - "id": "d2da3c33-14fe-42c3-ac39-6d4e412ceb74", - "metadata": {}, - "source": [ - "We can check the convergence of the run:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9172ab29-cfd7-4451-a992-02e50e2ec0ff", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:43.560073Z", - "iopub.status.busy": "2024-05-07T16:07:43.559090Z", - "iopub.status.idle": "2024-05-07T16:07:43.585488Z", - "shell.execute_reply": "2024-05-07T16:07:43.584830Z" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "image/jpeg": "/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAHgAoADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD3+iiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooA5vxR4jvdDuNJtNP0uO/utSuGgRJLnyFXajOSW2N2U9qm07VNVEN3c+IdNstJtoE3+cuoecuBncWJRAoAHWud+IdtBd654Qt7m4lggfUJQ8sU7Qsv7hzw6kEfnSeINM0/Tfh74sFhqN1eeZpk28XOoSXW3EbYxvY7ep6dePSgDr7fW9KvL5rK11Synu0Xe0EVwjSKvqVBzjkUXeu6TYXkVneapY211Ljy4ZrhEd8+ik5NcJeaTp+j2vw9nsLOGCddQhh85EAdkktpd4J6ncQCc9TWBaafcanN4ttL/AFHwzbzy6hcLcpqlmXuFjJ/dsHMq/Js27SBgY9c0AeuXer6bpz7L7ULW1YxmXE8yodgIBbk9ASBn3FRyeINGia0Eur2EZu1D2we5QGdT0KZPzA+1cHDo1tc+OPB1rqE8Gqi10GV1uGUMkzAxKJMHIOQcjr60tivhyPxb40j8SLYo6GFY1uwoAshCu0Rg/wAOd+dvf3oA9Ag1bTrk2wg1G0lN0HNv5cyt5oThiuD82O+OlTC8tjfPZLcRG6WMStAHG8ISQGK9cEgjPtXkmixG0+DfhjxFArmbQ52vDx87QGV0mX/v2zH6qK7HwFjVZNZ8VMQRq12Vtj/07Q5jj/Mh2/4FQB1F9qNlpdsbnUL23tIBwZbiVY1B+pIFRrrGmPpp1FNStGsAMm6E6mID135x+tcd4h+w/wDC09E/t7yP7M/s+f7F9px5X2vemevG7y+mffFV/F39h/bPCufsP/CO/wBrP9s8vZ5PneU3l+Zjj7+M574zQB29trGmXenyahbajaT2UYZnuYplaNQBkksDgYHWm22u6Re3v2K11Wxnutok8iK4Rn2kZDbQc4wQc15vqf2L+2fHv9heT/Z3/COH7Z9mx5X2rbLjpxu8vGce2anl0mw0rwz8PbixtIYLgahZKZkQB2EkbCTLdTuyc+tAHpNvfWt1DJNb3UMsUbMjvHIGVWU4YEjoQQQR2qvNrukW2mxajPqtjFYygGO5kuEWJwemGJwfzrzXxLdz6DqfiXwvatsl8SvDLp2P4XnIhuD+GN//AAKpfEFlJZfETSNPgn0qzs7fRhDp39rW5mi3q+HCfOoEmwR++PxoA9JOq6etlHfNfWotJSqxz+cvluWOFAbODknA9TUJ8RaGbKa9/tmw+yQSeVLP9qTy434+VmzgHkcH1ry7VtDitvh/qdm+qadfW93r1qzx6amyG3Lyxb41G5tvXdjP8XvXQ+JLPSLHxv4RhvLa0t9GAutiNGqQfadiCPcPu52h9ufwoA7ez1Sw1BnFle21yUVXbyJlfarZKk4PAODj1xTLPXNI1K6ltbHVLK6uIv8AWRQXCO6fUA5FeR3fkeX8Vf8AhFtuPs9rj7J93Ox/N2Y/4HnHfPetXStJS71Hw1e2+v8AhSGK1mD2q6ZZmGWZChDRAmU5BU8jGcj2oA9Bl8SaHDKsUms6fHK0rQBHuUBMinBTGfvAkZHWreoanYaVbfadRvbazgzjzLiVY1z6ZYgV5dYaJpl14T+I11cWUE1xJqOpAyyIGYBQSoBPTByRjuc1YtJrS48YeFpvEbQvbSeG0eya8IMZuiVMpG7jfs2++M0AejjVtNbTf7RGoWhscbvtQmXysdM784/WnWGp2Oq2wudPvba7gJx5lvKsi59MqSK848dC2Nz4UGmz6PDo32+fzZJoRLZrcbDs3qjKM7t+Mn72M1seDtIez8UarenWdEuJLm3iWaz0qHylVlLbZGXe3JBIzxnHtQB3dFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFNfIRiDg4oAdRXD+GdN1rWPCuk6nceMNYSa8s4bh1jhs9oZ0DEDMBOMn1rU/4RrVv+h01z/vzZ/wDxigDpKK5v/hGtW/6HTXP+/Nn/APGKP+Ea1b/odNc/782f/wAYoA6Siub/AOEa1b/odNc/782f/wAYo/4RrVv+h01z/vzZ/wDxigDpKK5v/hGtW/6HTXP+/Nn/APGKP+Ea1b/odNc/782f/wAYoA6Siub/AOEa1b/odNc/782f/wAYo/4RrVv+h01z/vzZ/wDxigDpKK5v/hGtW/6HTXP+/Nn/APGKP+Ea1b/odNc/782f/wAYoA6Siub/AOEa1b/odNc/782f/wAYo/4RrVv+h01z/vzZ/wDxigDpKK5v/hGtW/6HTXP+/Nn/APGKP+Ea1b/odNc/782f/wAYoA6Siub/AOEa1b/odNc/782f/wAYo/4RrVv+h01z/vzZ/wDxigDpKK5v/hGtW/6HTXP+/Nn/APGKP+Ea1b/odNc/782f/wAYoA1dR0fTNYiSPVNOtL6NDuRLqBZQp9QGBwaq2nhfw/YQ3ENnoWmW8VynlzpFaRoJU/usAPmHJ4NVP+Ea1b/odNc/782f/wAYo/4RrVv+h01z/vzZ/wDxigDZlsbSVbfzLaB1tnEkAaMERMAQGX+6QCRkdiar3+g6NqlwlxqGkWF5NGMJJcWySMv0JBIrO/4RrVv+h01z/vzZ/wDxij/hGtW/6HTXP+/Nn/8AGKANlbG0FzFci1gFxFGYo5fLG5EOMqD1A4HHsK5nxPo2t6hqUc+nad4auBHGBBc6nEzTWz5OWXCkEdCBleau/wDCNat/0Omuf9+bP/4xR/wjWrf9Dprn/fmz/wDjFAGfP4Y1Sw8AW3hfQbi0JMDWtxd3hYFVYHfIqqDliSSASBz1rqNM06DSdLtNOtl2wWsKQxj/AGVAA/lWP/wjWrf9Dprn/fmz/wDjFH/CNat/0Omuf9+bP/4xQBsX2nWOqWxttQsre7gJyYriJZFJ+hBFMXR9MTTTpyabaLYEYNqIFERHpsxj9Kyv+Ea1b/odNc/782f/AMYo/wCEa1b/AKHTXP8AvzZ//GKANO20fTLPTn062060gspAyvbRQqsbAjBBUDByOtSvp9nJDbxPaW7RWzK0CGJSsTLwpUY+UjtjpWP/AMI1q3/Q6a5/35s//jFH/CNat/0Omuf9+bP/AOMUAa82nWVzeW95PZW0t1bbvInkiVnizwdrEZXPfFLqGmWGq232fUbG2vIM58u4iWRc+uGBFY//AAjWrf8AQ6a5/wB+bP8A+MUf8I1q3/Q6a5/35s//AIxQBpLomkx2K2Mem2aWiuJFgW3URhgQQwXGMggHPtVPxLYX+o6YlvZ2WkX2ZAZbfVVYxOuD0wGwc46g96h/4RrVv+h01z/vzZ//ABij/hGtW/6HTXP+/Nn/APGKAK/g/wAN3WiSaje35she6g8e6GxQpBBHGu1I0BwTgZJOByelbFt4d0SyvmvbXR9Pgu2JJnitkWQ56/MBms//AIRrVv8AodNc/wC/Nn/8Yo/4RrVv+h01z/vzZ/8AxigDYj06yjhuIFsrdYblneeNYlCys33iwx8xPcnrUd1o+mXtglhd6bZ3FnGAEt5YFeNQBgYUjAwKy/8AhGtW/wCh01z/AL82f/xij/hGtW/6HTXP+/Nn/wDGKANZdK05dN/s1dPtRY42/ZRCvlY6424xj8KTTtH0zSI2j0zTrOyRjkrbQLGD9QoFZX/CNat/0Omuf9+bP/4xR/wjWrf9Dprn/fmz/wDjFAHSUVzf/CNat/0Omuf9+bP/AOMUf8I1q3/Q6a5/35s//jFAHSUVzf8AwjWrf9Dprn/fmz/+MUf8I1q3/Q6a5/35s/8A4xQB0lFc3/wjWrf9Dprn/fmz/wDjFH/CNat/0Omuf9+bP/4xQB0lFc3/AMI1qv8A0Omuf9+bP/4xR/wjWrf9Dprn/fmz/wDjFAHSUVzf/CNat/0Omuf9+bP/AOMUf8I1q3/Q6a5/35s//jFAHSUVzf8AwjWrf9Dprn/fmz/+MUf8I1q3/Q6a5/35s/8A4xQB0lFc3/wjWq/9Dprn/fmz/wDjFH/CNar/ANDrrn/fmz/+MUAdJRXN/wDCNat/0Omuf9+bP/4xR/wjWrf9Dprn/fmz/wDjFAHSUVzf/CNar/0Omuf9+bP/AOMUf8I1q3/Q6a5/35s//jFAHSUVzf8AwjWrf9Dprn/fmz/+MUjeG9WCk/8ACa65wP8AnjZ//GKAOlorD8I3lxqXg3RL+8lM1zc2ME0shAG52QEnA4HJ7VuUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTX+430NOpr/cb6GgDn/AP/JO/DX/YLtv/AEUtdFXO+Af+Sd+Gv+wXbf8Aopa6KgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAENFJ3FcPqnie5j8dWFjbswsYpVguSo4aWQHap+mM/nVwg5OyM51Iws31O6oooqDQSlrO/tiy/tj+yvO/wBM8vzfLwfu/Xpn2rRptNbiTT2EorGtvEWnXWu3GjxSn7VbrlgR8reoB7kd/wD9dbNDTW4lJPZi0Vk6Xr9hrFxdw2cpka1cJIccHOeR6jg8+1atJpp2Y4yUldAKWuWv/FhN5Jp2i2rajfodr7eIoT/tt/T9a2NJTUUsFGqTRS3RJLGFdqqD0A9cetU4NK7IjNSdkaNNf7jfQ06mv9xvoak0Of8AAP8AyTvw1/2C7b/0UtdFXO+Af+Sd+Gv+wXbf+ilroqACiiigAooooAKKKKACiiigAooooAKKKKACiiigApr/AHG+hp1Nf7jfQ0Ac/wCAf+Sd+Gv+wXbf+ilroq53wD/yTvw1/wBgu2/9FLXRUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAlAqKaeK2geaeRI4kGWd2wFHqTSxypNGskbq6MMhlOQR6g0WC/QloqC4uYLWIyzzRwxjq8jBQPxNENzBcJuhmjlX1Rgw/Siz3FdXsTenFc/r3im10G5gt3hmuJZAZJEhGTHGOrken+Bq7rGtWmi2E11cyD92uQgYbnPYAe5rM8MaTPEs2r6oM6lf/NICP9Un8MY9MDGf/rVpGKS5pbfmZTk2+WG/5Fy516yh8PS61FMktukZZSp+8egHsc4FclfaTPYfD46hMC2om4j1GUnrvLDj8Af51sXfga1m1SOa3ne3smmWa4slGY5WXkEDt71va3afbtDvrYDJkgdVHvtOP1q4zjFrlfXX/IzcJTT51srL/MuxyLNEkiHKuoYH2NR3d1FZ2k11M22KFC7n0AGay/CN0L3wnpkxOSIQhPuvyn+VZ3ix21O9sPDcLH/S3826I/hhU5P5kY/Co5Pf5X0NXU9zmXXYwBpl6+jnxkqt/an2j7YqZ/5YdPL+m3n6V12o+Ira18LHWoSHV4g0C/3nb7q/n1+hraWKNYhEqAIBgLjgD0rg7Hwxfp4kj0+VT/YVlO15b56MzfdT/gJyfz9a1U41Pi6fl2MXCVPSOt/z7kyeEriLw5bXED7dfhc3nnHq8rcsh9iOPw+tJc+KJvEVja6VpQaHUbwFbrIObVRw5Pv2H9Diu6/GqNtpdlaXtxeQWyRz3BBlkHVsfy/DrUKsnrJXfT+uxTotaRdl1OYh0+Dwp4t0pbVdlnfQG0f3kX5lY+56fnXR69qS6RoV5fkjMMZK57seFH5kVn+NLKS58OSzwf8AHzZMt1CfRkOT+mazNVvY/Et54e06HmG5Av7hfSNRwp+rZH1FUlz2k/n8tSW/Z80F8vmbXhTTDpPh21hkB+0OvmzE9S7cnP0zj8K3KOnFFYSk5SbfU6YRUYpLoLTX+430NOpr/cb6GkUc/wCAf+Sd+Gv+wXbf+ilroq53wD/yTvw1/wBgu2/9FLXRUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFUNVvv7M0q7v8A7PNcG3iaQQwIWeQgZ2qB1J6VfooA8p8IajBL8TJJZpL2XUb/AEsNcNJY3ESLIJGOxd6DaiqAoJwCR/eJr0DVp9ciKjStPsLlCh3tdXrwFT7BYnz+Yqz/AGbaLqp1TysXhgFuZNx/1YYtjGcdSTnGatv9xvoaAOf8A/8AJO/DX/YLtv8A0UtdFXO+Af8Aknfhr/sF23/opa6KgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAOU8dOZNGg02MkPqF3FbgjqATkn9P1qu2hat4dcy+HXFxaMcvp074C+6Men0P61NqAF/8QtLtRzHY28ly/pub5R+PQ11fc5rZycIxj31ZzKCnNyfTRHJ23hafUrhb3xNOt5MOY7VMiCH6D+I+5/Wp5vAfh2Vtw0/y29YpXX9AcV02KCKj2s76O3oX7GFtVf1Oes/BXh6xlSWDTY/MQhlZ2Z8Ed+Sa6HHFFFS5SlrJ3NIwjHSKsLQelFFIo5TwR+4stS008Cyv5Y1H+wTkfzNN8L/8TTWdX19uY5JPstqf+mSdSPYnn8KxNa1J9C1vxHbwZ8/UIYWtlHUu3yEj35J/Cu20TTk0nRrSwTGIYwpI7t1Y/icmump7qcv5rf5v8Tkpe81H+W//AAPwNKiiiuY6wooooAY6LIhRgCGGCD3Fcj4O8L3GhXt/NdHcN3kWhLZIhBLfhkkce1dh2paqM5Ri4rZkSpxlJSe6CiiipLCmv9xvoadTX+430NAHP+Af+Sd+Gv8AsF23/opa6Kud8A/8k78Nf9gu2/8ARS10VABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU1/uN9DTqa/3G+hoA5/wD/yTvw1/2C7b/wBFLXRVzvgH/knfhr/sF23/AKKWuioAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKD0oAbjrRXKeHNbnv/ABT4gspZi8cEqiFP7gGVbH4gV01zMLe0mmPSNGc/gM1UotOzM4zUo8yOc8JeIJ9Zn1eOdw/2e7YRYUDEZztHHX7p5rqa8y+HsZ0/V4Y3J/4mNh9pJPdhIw/9Brvtavf7P0a9vM4MMLuPqBx+taV4JVOWJlh6jdPmkT215bXsXmWs6TIGK7o2BGR1FWK810WG58G2Wn6kzO+l3saG8Q8+RI33XHtyAf8A9Vejo6yorowZWGQQcgipqQUXo7oulUc17yszB8Y38lj4elS2J+13bLbQAHB3vxx74zVbwleXEH2nw/qMm+9sD8kh/wCWsJ+6w+nT8qZc/wDE58e29vjNtpMPnyennP8AdB+g5/OjxdbXFibfxFp6brqwyJU/56wn7wP06/ma0ilyqm93r8+n9eZlJvmdRbLT5dRfDR+2+IvEGqHlTcC0jPtGMHH1JFdZXPeCbQ2nhSyD5MsymdyepLndz+BFdDWdV3k/LT7jairQT76/eLRRRWZqFFFFABRRRQBzmp+GI9R8U6drMjrttFIMZXliCSpz7Ek10QFFLTcnJJPoTGCi211CiiikUFFFFABRRRQAUUUUAFNf7jfQ06mv9xvoaAOf8A/8k78Nf9gu2/8ARS10Vc74B/5J34a/7Bdt/wCilroqACiiigAooooAKKKKACiiigAooooAKKKKACiiigApr/cb6GnU1/uN9DQBz/gH/knfhr/sF23/AKKWuirnfAP/ACTvw1/2C7b/ANFLXRUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFIelHaquoz/ZdOurjp5cTvn6AmhK7sJuyuec+C3MfjE3pJ2aqlyR7lZM/wAhXbeLJxb+FNUkzg/Z3QH3Ybf61x+nQ/2dp/gm7xgCZ4if+u2cV0Pj4lvDLWqnDXU8UI/Fwf6V11bSqxf9aM4qTcaUl/WqM2W3OlXPgu4IwEUWcnuXjAH65rS8eOX0BLFDiS/uYrZcdeWz/Sjx3CU8LG5iX57GaK4QDttYD+RNR6rIup+MvD9sh3RRRyXrfTGEP50k+a0+1/w1Ka5U4Lrb8dDpZbOCeya0kjVoGTyyh6FcYxXKDTtd8Lgf2W7anpq/8ukxxLGP9hu/0/SuzA4ornjNrzR0SpqWuzOa8H2NxDYXGoX0TRXuoTtPIjjDIM4VT9B/OuloxRSlLmbY4QUYqKFooopFhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFNf7jfQ06mv8Acb6GgDn/AAD/AMk78Nf9gu2/9FLXRVzvgH/knfhr/sF23/opa6KgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKa/wBxvoadTX+430NAHP8AgH/knfhr/sF23/opa6Kud8A/8k78Nf8AYLtv/RS10VABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABSUtUrnUrS0ura1nmVJrpisKHPzkDJoSb2E2luXaSiuc1/WruG7i0fSIvM1O4QuGf7kEecF2/oP8A9RcYtuyFOairs2P7RszqP9n/AGmP7Xs3+Tu+bb64q1XA6n4abw9p8Ot2jyXOpWc32i5mc/NMh4cewx+QzXb2tzFeWcNzAwaKZA6N6gjIqpxSScXdEU5ybakrP9CwawvGM/2fwhqj5xmBk/76+X+tbtct4+Jfw19lHW6uYYfzYH+lFJXml5hWdoN+RR8S25svAWmygfNpxtZR7FcL/Wrnisi51Pw3ag5El+s/1CDP9a0fFFsLnwpqUIH/AC7OwHuBkfyrnbC5/tTxH4VYnJh01rhvqyhD+oraGqv2v+RhP3Xy97fmdZrVmL7RL6zAy00DoPqQcfrXGfD2d9W1CfUZAf8ARbKCyQnvgZb9R+tehGsbw9oMGgW1xBBIXE1w02SMYzjC/gBUQmlTcer/AKZrOm5VIyWy3/Q26KKKxNwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKa/3G+hp1Nf7jfQ0Ac/4B/5J34a/7Bdt/wCilroq53wD/wAk78Nf9gu2/wDRS10VABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABUU0nlQu+x32KW2oMs2Ow96lqvcT/Z7WWfy5JPLQvsiXc7YGcKO5PYUAY9h4oS71ZNNu9M1DTbmWJpoFvETEyqQG2lHYZG5eDg89K3n+430NcDpEH2nx7BqWmWms/Z2t5lvZdVjmVYyxUosPnfMuSDkJ8uAPQV1WraZeX5D22u6hp4VCClskDB/c+ZGx/IigCn4B/5J34a/7Bdt/wCilroq53wD/wAk78Nf9gu2/wDRS10VABRRRQAUUUUAFFFFABRRRQAUUUZoAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAG4rzbxTDc6v4g1G7s2IOhQRvH6GXdvP/joP4gV6JczpbW0txKdqRIXY+gAya53wTbNJoMt9cqPO1OeS5kB9GOAPpgfrWtKXInP5HPWjztQ+Zu6dex6jp1vexf6uaNZB7ZHSud8L/8AEz1nWNeblJZfstsT/wA806kexPP4VjRapJ4c0HXdFUn7RZzeXZjuUm+5j1IyTXaaHpq6RodpYLjMUYDEd26sfzJqpR9nGVuu3pv/AJEwl7SUb9N/XYvPGksbI4DKwIIPQg1y3hN30u+v/DUx/wCPVvOtCf4oWP8AQnH411ma5XWf9B8caHfDhLlJLSQ/+PKPzqKeqce/6GlTRqfb8mdX3rlPFn7/AFPw5af39QWYj1CDP9a6vvXK6p/pHxC0KHtbwTzH/gQ2/wBKKXxX7J/kFb4bd2vzOmmjWWF425VlKn6GvNvhv5k2szmUfNYWf2TP1lZv6V6bXM+GdBl0jUtbuJdoW8uvMi2nPyckfT7xH4VVOaUJRfWxNSm5VISXS509FFFYnQFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU1/uN9DTqa/3G+hoA5/wD/yTvw1/wBgu2/9FLXRVzvgH/knfhr/ALBdt/6KWuioAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACmv9xvoadTX+430NAHP+Af+Sd+Gv8AsF23/opa6Kud8A/8k78Nf9gu2/8ARS10VACYrG1/W/7Ehs5TEJBcXcductjaGzk/hitmuE+KM5h0awYdVvFcfgrf41pRgpzUWZVpuEHJdDvKKapBUEdDzQWVSASAScAE9azNR1JS1Ul1C2hvoLKSZVuJwzRxnqwXrQk3sJtLctd6483LH4qiHcdv9mbdueM791dhXnS3GfjQUz0h8v8A8hbq2oxvzejMK8rcvqj0auAl06+1TxxrklhqUtncWa26xkfNG+5MkMvccV31ct4b+fxV4nl9Z4k/75QilSbSk12/VDqpScU+/wCjLHh/WL2/u7/T9St44r6x2CUxNlHDgkEdxwOnvXQ1yujjZ8QPEY/vx27fkmK6rtSqJKWnZFUm3HXu/wAwzS1594N1Vj4y8RafIxxJcSSpn1Vyp/Qr+VegUqkHB2Y6dRTV0LRRRUGgUlGa57xlevYeF7xoSRPMBDEF6lnOOPfBP5U4pykkupM5KMXJ9BNT8W2dnc/YbOKTUdQPAt7fnH+83Raq/wDCcRWoI1XSdRsCOrtFvjP0YdfyrX0TRbTRdPjtraGNCFAkZRy7Y5JPetQD3zVuVNaWv8zNRqPVyt5WOJax1XxkplvXm0zScEw26HEsp7O/oO+P/wBdaHhvVrkTy6FqzY1K1HyuelxH2cep9f8A9eOm7VyXju3W30hNagyl7p8iPFIvXBYKVPqOelXGam+Rqye3kRKDprnTu1v5o6+imqwdAynIIyDTqwOk5jxzcSLoH2GA/v8AUJktI/8AgR5/QEfjW9a28dpaQW8QxHCixqPYDArnNUH27x9o1meUtIZbxx9flX8jXV+1aT0go/MxhrNy+RzOq+FItR8VafrBkAW2H7yMj75XJQ/gT+ldN7UUVEpSkkn0LjCMW2uoVy3jxGXQUvkGZLC5iuVx14bH9a6mqOr2Q1DSLy0I/wBdC6D6kcfrTpytJMVSN4tItRSLLGsiHKuoYH1Brmbf/SPiZdydRbackX0LPuqbwrqkcngqzu7h9i28BWVm/h8vIJP4LmofBsMlwl5r9wpWbU5N6Kf4YV4Qfl/StOXl5r9NDNy5+W3qdXRRRWJ0BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTX+430NOpr/AHG+hoA5/wAA/wDJO/DX/YLtv/RS10Vc74B/5J34a/7Bdt/6KWuioAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACmv8Acb6GnU1/uN9DQBz/AIB/5J34a/7Bdt/6KWuirnfAP/JO/DX/AGC7b/0UtdFQAled/FbL2GnRpyTJI34Bea9ENcL4+i+0ajpFtjO+C9P5Q8Vvhnaqn6/kc2KV6TXp+Z12ly+fpNlN/wA9IEb81BrlvF915finwtED966Yn81UfzNbnhSXzfCmlv6WyL+Qx/SuN8b3BHj7w/GOkTRSH2zLj/2WnSh+9a9RVp/uk+9vzR6XXE69ceV8S/Dq/wDTOQf99BhXbV5p4um8v4naCeyiEH23SsKWHV5NeT/IeJlywT81+Z6VivL4zn4tC79bx4PyhxXqGeB9K8ugOdeS87nxJLED7bQKrDac3pYnE/Z9bnqR6GuV8H/Pe+IpfXU5E/75Arqj0Ncr4H+ay1WX/nrqc7/qP8Kyj8Evkay+OPzF0/5PiNq4/v2kLflxXU1y1v8AJ8TLwf39NRvyfFdSaKu69EFLZ+rPK7XNhdnXxwsOvXEUx/6ZSbQSfpj9a9UArg9G08av4J1q1xlri6uGT/eBBX9QK6LwvqX9qeGrC6YkyGMJJnrvX5T+ozWtfXXs7f5GWH93Tur/AOZtGqOl6pa6vZLd2jl4mZlBIwcg4PFWpn8uGR/7qk/kK4j4WXHmeHLiEn/VXBx9Cqn+eayjTvBy7WNpVLVIx73O7rk/EH+n+KtB0scpHI17MMdAg+T9ciurrlND/wCJh4y1zUjylvssYj/u8uP++sfnRT0vLshVdbR7v8tTraKKKzNhKxPF0H2jwnqiYzi3Z/8Avkbv6Vt1Wv4ftWnXVvj/AFkTp+YIpxdpJkzV4tEGiT/adA0+fOfMto2P4qKv1z3gaf7R4M01/SMp/wB8sV/pW7PKkEEkrnCRqWY+gAzTnG0mvMmErwUvI5nQv9O8Za/qHVITHZxn02jLj88V1eK5jwLG48NreSjEt9PJcv8AVmx/ICun71VX4mu2n3E0fgT76/eLRRRWZsFB6UUUAeWFZ5NQvvBsO9Rcai0zsP4LcgOR/L/Jr02GOOCFIo1CoihVA6ADgCqsel2UWrTamkIF5KgjeTnlR2/QfkKvcZrSrUUrW/pmFKm4Xv8A0h1FFFZm4UUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU1/uN9DTqa/3G+hoA5/wD/yTvw1/wBgu2/9FLXRVzvgH/knfhr/ALBdt/6KWuioAKKKKACiiigAooooAKKKKACiiigAoorM1XW9P0S1W61K4+z27SCLzWRiqkgn5iB8o4PJwOnPIoA06Kr2t3bXtslxa3EVxC4ykkTh1YexHBqxQAU1/uN9DTqa/wBxvoaAOf8AAP8AyTvw1/2C7b/0UtdFXO+Af+Sd+Gv+wXbf+ilroqAEPWuS12MXPjjRIT0+z3P/AI8mK62uVvP3nxK09f8Annp8j/m2K1o6Nvyf5GNfWKXmvzJPAMhk8FafnqodD+DsK5Xxf+88V3dz/wA+YtEz6ZfdXTeBDs0e7t/+fe9mi+mDn+tcx4gBlh8Z3o5KXFog/wCAED+tdFJ2rSf9atHLV1oxX9aI9Q7CvL/GX/I3y3X/AD6R2rZ9P3n/ANevT1OQMdDXmfilPPvPF7DrDBaYPpyrVnhfj/rujXFa0/67HpvYGvLYf+QHp15/f8RiUn2LEf0r0xJg1ks/Yxh/0zXm0aFPhbpc5PzJerKT/wBtWFFFfml+Yq+tvRv8j1D+H8K5bwB83hZZf+etxK//AI+R/SukmfyraST+6hb8hXP+AE8vwTpw9Q7fm7Gso/w36r9TZ/xI+j/QiPy/FE/7Wkf+1a6k9K5a4+T4m2h/v6a6/k+a6gnCkmif2fQKf2vU5jwBz4YD/wB+4mb/AMfNJ4KHlDXLfosWqTBR6KcYFL8PR/xRVkx6s0p/8iNSeFv3eveJYfS8V/8Avpc1pPea/rczhtTfl+hu6s/l6PfSf3beQ/kprh/hon2O6vrU9Jra3uUH1U5/U12HiZ9nhfVW/wCnWX/0E1y2gJ9j8R6CegutDSPHqy4b+VOk/wB1Jd/01FV/ixfb9dDtr65Sysbi7f7sMTSH6AZ/pWJ4HtXt/C1tLLzNdlrmQ+pc5B/LFJ46uGg8I3ixn95PtgQepZgCPyzW7Z2y2djb2yfdijVB9AMVltT9X+X/AA5rvU9F+f8AwxYooorM2Cg9DRRQByvgP93olzaf8+t7NDj0w2f61Y8a3Zs/Cd+y/flTyVA6kuQv8iareFf3OteJbT+7e+dj/roM/wBKTxaPteq+H9MHInvPOceqxjJH610NXq3fr+FzlTtRsvT8bHQaZaDT9LtLQdIIUj/IAVb6UtFc7d3c6UrKyCiiigYUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU1/uN9DTqa/3G+hoA5/wD/wAk78Nf9gu2/wDRS10Vc74B/wCSd+Gv+wXbf+ilroqACiiigAooooAKKKKACiiigAooooAKwPFWqy6Tpkc0eoaTYGSYRG41SUpEoKseBkb24+7kcZOeK365TxrbvPbaUsSW1xMNRR0srkkJdlY5D5ZbBAIALgkYygzQByWnaP4ba5nn0Tx3Z/8ACSXXMTWV1DDC0g6A28fDqT13bmPrXrFeb3vhTU/EjahcXGjWGjtJYNbQJ5qyu0xdWSZii4BjwduMn5j0r0C58/7LN9lEZuNjeV5pITdjjdjnGeuKALFNf7jfQ1y9hq+s2/iuLRNXbTrkz2b3ay2UbxmHY6rh1ZmyDv4bI+6eK1NV8RaJoxWPVNYsLGSRSyLc3CRlh6gMRmgCn4B/5J34a/7Bdt/6KWuirnfAP/JO/DX/AGC7b/0UtdFQAlcr9/4oeyaTn8TLXVVytr8/xLvT/wA89ORfzfNaU+voY1fs+onhH91feIoP7upSSf8AfQB/pXPyr5/grxdOefN1GVh/uq6YroNEPk+MfFEROFzbyj8UOaydLjMvwmvpiPmnjuJj/wB9H/Ct1pLm80czV1y+T/yO4sn8yxt5P70Sn8wK4a7i+0zePH6/uoh/3xGT/Sux0J/M8P6c/wDetYj+aCua0qL7V/wmQ6+ZPJF+SEf1rOno5P0/NGtTVRXr+RsQXOfAkd1n/mGiT/yHmuZ1CExfBuHHUQwyD8ZFP9av21xn4RmT/qHvH+hWn6tb7fhYIcfcsIv0Cn+lXH3Zf9vES95f9u/mdFqsoTQL2YdBbO//AI6TVLwcnl+EdLX1gDfnz/Wo9Vn3eAbqb+/px/WP/wCvV3w4mzw1pa9xaxZ/74FYtWg15m6d6ifkZWofJ8RtIP8AftJl/LmukuW2WszeiMf0rm9W+X4geHj/AH4rlfyXNb2qNt0q7b0gc/8Ajppz15PT9WKOnP6/ojF8BLs8E6aPVXP5uxqLQ/3fjnxPH2b7M4/74Oat+C12eD9LHrDn8yTVWw/d/EfV1/562kL/AJcVb1lP5/mQtI0/l+Rb8ZSeV4P1M+sBH5kD+tY98n2O+8GXPQIfsx/4HGAP5VofEB9ngrUD3IjX85FqHxsgtvD1lddPsN3BNn0wcf1p0vhiu7a/Bf5iq/E32Sf4jvFn+lat4e00c+beeew9VjGT/OupIrlj/pnxKjHVLGwLfR3bH/oNdVWVTRKPka0tXKXn+QtFFFZmwUUUUAcrpn7j4h63F/z8W8E2P90baav+m/Elz1j0+xA+kjnP/oNLP+4+Jto/QXGnPF9Sr7qb4RP2u+13VCM/ab0xofVIxhT+tdL0XN5L/I41q1Dzf+Z1tFFFcx2BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU1/uN9DTqa/3G+hoA5/wD/yTvw1/wBgu2/9FLXRVzvgH/knfhr/ALBdt/6KWuioAKKKKACiiigAooooAKKKKACiiigArk/HUFrcaRaw3MmpiZryP7JHpjqk8kwDEKrNwOAzEkjAXrXWVzPjNrGLSrae8u7m1nhukeyltYTNL5+GACxgHflS4Ix0J6dQAZvhCe3a70+ZNU165bUtM+2wxahOkkYTcmfugHeNy+2Grrrw3Is52sRC12I28kTEhC+Pl3EAkDOM4GcVwnw/s4bW7jikfXbie0sRa20moaW9pFFApX5FyACxIUkkknb2xXotAHHeEtJ1/S5p5dYtdNkurv57vUIb2SWWVx91QhhUKgGQFDce5JNdbIoKNkA8HqKkpr/cb6GgDn/AP/JO/DX/AGC7b/0UtdFXO+Af+Sd+Gv8AsF23/opa6KgArlNL+f4ha839yC3X8xmurrldC+fxv4pf/atlH4RmtKfwy9P1RjU+KPr+hRvpvsPi/XnzjfpHn/8AfORVjTrbZ8LvJ/v6c7f99IT/AFrJ8czfY9dnmzj7Ro8kH1+f/wCvXXQW2zwlHa4+7YiPH/AMVtP4Ivvb8DCCvOS7X/Eb4Vbf4U0o+lrGPyUD+lZvg1RIuvseQ+qzj8OKteCX8zwbph9IiPyYj+lVvAp3aReS/wDPW/nf9f8A61RLTn9f1Li78np+hz0Mxi+DU6N96ItEfxm/+vXXa7b7PBN/Bj7li4x/up/9auKn48FatYemtNb4/wCBqa9E1iPzdEvo/wC9bSL+amrqOzT82/yIpK6a8kvzOa1Of/i04lz97T4gfxCiuo01PK0y0j/uQov5KK4fUZjJ8G4cdTDDGPwkUf0r0BFCoqjoBioqK0beb/Q0pO8r+SOZ175fG/hZ/e6X84xWxrzbPD+pN6Wsh/8AHDWP4kO3xT4Yf0uJV/NBWn4mO3wtqx/6dJR/44aT15P66sa05/66Ij8JLs8J6UPW2Q/mM1nj5Pigw7SaSD+IlrV8NDb4X0kf9OkX/oArKvP3fxJ05v8AnrYyJ+TZoWs5fMHpCPyF8f8APhcxf89biFP/AB8H+lW/GNv9p8H6nHjOIC//AHz839Kp+ODustLi/wCeupwJ+p/wror23F3Y3FscYljaPn3GKFLljB+bf5A480pLyS/M5HwFcHU7jVtYbJM8kUQJ/wBiMZ/nXa4rA8HaPLoXhyC0uFVbjczSBTkZJ45+mK3+lTWkpTdtiqEXGC5tx1FFFZmwUUUUAcT40vBpOtaLqp4EK3Cn3Jj+UfnWr4MtPsfhHT42+80fmtnqS5Lf1rO+Iek3OraPZxWsLySi7QEoudqkEEn2yRXWQxJDCkSDCIAqj0A4reUl7KK6/wCX/DnNCD9tJvb/AD/4YmooorA6QooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKa/wBxvoadTX+430NAHP8AgH/knfhr/sF23/opa6Kud8A/8k78Nf8AYLtv/RS10VABRRRQAUUUUAFFFFABRRRQAUUUUAFcZ4ymFxFPHbakdOu9DSPWJLlrT7QFj2zLhV3rkkI4PsfU5HZ1yHiTwfd67e301rrb2EV/p62F1Etskm+MGU5BJyD+9YcUAS6VPrNp4hgsdW1m3vxc2ctxEkGnGDbseIEljK3/AD0HGPXkYweqrmNJ8N6laa7Fqepa82otBaSW0UZtEhCh2jYnK9f9UtdPQAU1/uN9DTqa/wBxvoaAOf8AAP8AyTvw1/2C7b/0UtdFXO+Af+Sd+Gv+wXbf+ilroqAErlfDHzeIfE0nrdIv5LXVVyvg/wCa88RSeupyL+WK0j8Mv66mNT44/P8AI5/4pwNJc6OEJBmMkRx9UxXo5QGEpjjbj8K5fxhpc+pXWhNBC0ghv0aUqM7U6kn24rqz0NXOd6cF2v8AmTCFqk5d7fkcv8P2z4IsQeqmRT/38ak+H3zeD7eX/nrLK/8A4+f8Ki8GP5HhG6X/AJ4T3A/Ik1a8BJ5fgrTh6q5/N2P9adX7Xr/mTS+x6f5HIXny6ld2P9/xJCxHs4J/pXp06ebbyx/3kK/mK8z1AEfFP7J/DLe21wP+AxnP869QNOvpy+lycPvP1seZK/m/C3SI/wDnrdJF/wCRW/wr04dBXltt/wAipoVr/d11YyPbex/rXqQ6VNfR/NlYbVfJHK+LPl1nw4/pfBfzFX/FzbPCWq+9sw/MYqh4x+W58Ov6arCv55q142fb4O1M/wDTLH5sBRHXk/rqN6c/9dDQ0NdmgacvpbRD/wAdFYutfu/Hfhp+0iXKH/vgGug00bdMtF9IUH/jorn/ABL8niTwxN6XUif99LiphrN/P8ip6U18vzQeMP3l14di9dUif/vnNdVXK+J/n8SeGIvW4kf/AL5UGuqpS+GP9dR0/jl8vyFooorM2CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKa/3G+hp1Nf7jfQ0Ac/4B/5J34a/7Bdt/wCilroq53wD/wAk78Nf9gu2/wDRS10VABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU1/uN9DTqa/3G+hoA5/wD/wAk78Nf9gu2/wDRS10Vc74B/wCSd+Gv+wXbf+ilroqAENcr4HO631l/7+qzt/6DXVGuV8B/NoU0n/PS8mb/AMe/+tWkfgfyMZfxI/M6ug9KKKzNjh9Ck8nw14oHTyLy7H5Lmtvwenl+EdLHrbq358/1rnIH8nRfHCdMXFw3/fSV1XhxdnhjSk9LSL/0AVvU+F+v6HLR+JeSf5nJahb/APF4tPbHDW/mH8Ecf0r0LtWBcaJJL4ytNZ3R+VDbNEynO7cScY9vmNb/AHqas1JRt0RdKDi5X6s8tsubuwtP+efiKbj/AHQD/WvUcV5fYf8AI/w2vpq95Nj/ALZqa9QBq8R9n0/Uzwv2vWxy/jfiDRW/uarbt/6FUnj5tvgnUj/sov5uoqPx3xpVi/8Acv4G/U0vxC58F3if33iX/wAiLRT3h6/5Dqfb9P8AM6SBdltEvogH6VzPjIbLnw/L6arEn/fWf8K6odBXK+O/l03T5v8AnlqMD/qR/Ws6es0aVf4YutfvPHnhpOyLcuf++AK6muWvvn+I+lL/AM87KV/zOK6miptFeX6sKW8n5/ohaKKKzNgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACmv9xvoadTX+430NAHP+Af+Sd+Gv+wXbf8Aopa6Kud8A/8AJO/DX/YLtv8A0UtdFQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFNf7jfQ06mv9xvoaAOf8A/8AJO/DX/YLtv8A0UtdFXO+Af8Aknfhr/sF23/opa6KgBrHC1y/w9GfBlpIf+Wjyt/5Eb/Cuju38u0mf+6jH9KwfAabPBWmj/Zc/m7GtF/Dfqv1MX/EXo/0OlooorM2POL9/ItvHcf+1Gf++1rudMTy9Js0/uwIPyUV574nfyZvGqj/AJaJZEfmo/rXpcKbIY0/uqB+ldFb4V5/5I5KHxPy/wA2S0UUVznWeYafER8Y7hD0RpJAP96Mf416bXB2UH/F4tRfH/LoG/8AHYxXeV0Yh3cfRHLhVZS9Wct4/wCPDO/+5cwt/wCPCjx9z4cVf79zCv8A49TviF/yJd6w6o0Tf+RFpvjn5tKsFH/LTUIF/U0U/s+r/QKv2/RfqdUO1cv8Qfl8IXEv/PKWJ/8Ax8D+tdQO1c547j8zwXqQ9EVvydT/AErOj/EXqjWr/DfoQf6z4oL6R6Tn8TLXVd64/SJPtPjy4m67dMiH/fRDV2FOqrNLyQqLum/Ni0UUVkbBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFNf7jfQ06mv9xvoaAOf8A/8k78Nf8AYLtv/RS10Vc74B/5J34a/wCwXbf+ilroqACiiigAooooAKKKKACiiigAooooAKKKKACo5I1ljaNxlXBUjPUGpKayh1KnOCMHBxQBxngnTrPSvEPi+ysbdILaK/g2Rp0GbWIn8ySfxrf1bU7ywIS20LUNQDISXtngUJ7HzJFP5A1T0rwdo+i6i1/YpeJcycyNJf3Eoc4C5ZXchjgAAkcYFdA/3G+hoA5/wD/yTvw1/wBgu2/9FLXRVzvgH/knfhr/ALBdt/6KWuioAoay+zRL9/7tu5/8dNUfBybPCOlj/pgD+fNWPErbPC+qt6Wkv/oBpvhhQvhfSR/06RH81BrT/l38zH/l78v1NeiiiszY8t8Y/Lr+rQf8/MVp+OJAK9RFeXeN8jx/YRdp47cf+Rj/AIV6gOtdNf8Ahw9Dkw/xz9f+D+o6iiiuY6zmYdIuU8e3eqGMfZZLNYlfcOW3DIx16LXS+tFFNybtcmMFG9upzfj5d/grUh6Kh/J1NVfFrb7Lw8P+emp238jV/wAbLv8AB2qD0iz+RBrL19vNtfCQ/vXtu/5Lmt6fwr1f5I56vxS9F+Z2Q6VjeLI/M8KaoPS2dvyGf6Vs9qztej83QNSj/vWsq/mhrGLtJM3mrwa8jl/BLefruozddtjZL+cWa7kV578MH84alP8A7NtF/wB8RkV6GOla4hWqNen5GOFd6afe/wCYtFFFYHSFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU1/uN9DTqa/wBxvoaAOf8AAP8AyTvw1/2C7b/0UtdFXO+Af+Sd+Gv+wXbf+ilroqACiiigAooooAKKKKACiiigAooooAKKKKACiiigApr/AHG+hp1Nf7jfQ0Ac/wCAf+Sd+Gv+wXbf+ilroq53wD/yTvw1/wBgu2/9FLXRUAYXjB9nhHVD/wBO7D8+KvaKnl6Fp6f3baMf+Oisrx2+zwXqTf7Cj83UVuWaeXZW6f3Y1H6Vo/4a9X+SMV/FfovzZYooorM2PN/GUO74i+HXx1aIflLn+tej1xHimHf468Lt6u//AI7g129b1XeEPT9Tmoq05+v6C0UUVgdIUUUUAYni5d3hLVR/07OfyGawL1vNTwUP70kb/lGDXSeJRu8LaqP+nSX/ANANcsjb38BL6xZ/KFa6KW33/kctb4vu/M76obyPzbOeP+9Gy/mKnpD0Nc6Ol6o8++E6Y0a+k/vXGPyUf416DXE/DGHyPD10p6/bZB+SqP6V21bYh3qyMMMrUkLRRRWJ0BRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFNf7jfQ06mv9xvoaAOf8A/8AJO/DX/YLtv8A0UtdFXO+Af8Aknfhr/sF23/opa6KgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKa/3G+hp1Nf7jfQ0Ac/4B/wCSd+Gv+wXbf+ilroq53wD/AMk78Nf9gu2/9FLXRUAct8Qif+ELvVHV2iX/AMiLXTKAqgDoBisPxbptzquii0tVVnM8bMCQPlDZNbvtVtrkS83+hlFP2jfkh1FFFQamVe6RBfarp9+7uJbEuUAxg7xg5/KtSiihtuyfQlRSba6i0UUUFBRRRQBna6N3h/Ul9baQf+OmuN09hJeeAh6W05/KIf4V2+qLu0q7X1hcf+OmuC8Pt5l/4N/2LOc/oRXRR+F/P8mclb418vzR6TRRRXOdZR0zS7bSbd4LVSsbyNKQTn5mOTV3tS0UNtu7EkkrIKKKKBhRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFNf7jfQ06mv9xvoaAOf8A/8k78Nf9gu2/8ARS10Vc74B/5J34a/7Bdt/wCilroqACiiigAooooAKKKKACiiigAooooAKKKKACiiigApr/cb6GnU1/uN9DQBz/gH/knfhr/sF23/AKKWuirnfAP/ACTvw1/2C7b/ANFLXRUAFFFFABRRRQAUUUUAFFFFABRRRQBDcrvtZl9UYfpXm/g4+Zqfhv8A2LC4P/kQivTGGVINeX+Aju1rSkPWLTJv1uGrpo/w5f10ZyV/4kf66o9SooormOsKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACmv9xvoadTX+430NAHP+Af8Aknfhr/sF23/opa6Kud8A/wDJO/DX/YLtv/RS10VABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTHdY0LuwVVGSxOABT6xfFdpc6h4P1uzs1Jup7GeKFR1LtGQB+ZoAZpHivRtcuTbade+bMI/NUNE8fmR5xvQsoDrkj5lyOR61tv9xvoa880/VLDxD4m8K/2MwkGm2s7XgVSPsytGqCJ/7rFsfL1+QntXX6tpl5fkPba7qGnhUIKWyQMH9z5kbH8iKAKfgH/knfhr/sF23/opa6Kud8A/8k78Nf8AYLtv/RS10VABRRRQAUUUUAFFFFABRRRQAUUUUAIeleW/D7nxUy/88rGVP/JjP9a9SPSvMPh6hHjDWQf+Waug/wC/ldNH+FP5HJX/AIsPmeoUUUVzHWFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABTX+430NOpr/cb6GgDn/AP/JO/DX/AGC7b/0UtdFXO+Af+Sd+Gv8AsF23/opa6KgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKa/3G+hp1Nf7jfQ0Ac/4B/5J34a/wCwXbf+ilroq53wD/yTvw1/2C7b/wBFLXRUAFFFFABRRRQAUUUUAFFFFABRRRQAlec+Ao9vjLxJ/sysv/kRv8K9Grg/BEe3xb4sPpc/zeQ1vSfuT9F+ZzVlepD1f5He0UUVgdIUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFNf7jfQ06mv9xvoaAOf8A/8AJO/DX/YLtv8A0UtdFXO+Af8Aknfhr/sF23/opa6KgAooooAKKKKACiiigAooooAKKKKACiiigAooooAKa/3G+hp1Nf7jfQ0Ac/4B/wCSd+Gv+wXbf+ilroq53wD/AMk78Nf9gu2/9FLXRUAFFFFABRRRQAUUUUAFFFFABRRRQA3tXHeEI9ninxUfW5T/ANnP9a7HvWdp+kQaff6hdRO7PeyCRw2MKQMcVcJJRa7/AOZlKDcovsadFFFQahRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU1/uN9DTqa/3G+hoA5/wD/wAk78Nf9gu2/wDRS10Vc74B/wCSd+Gv+wXbf+ilroqACiiigAooooAKKKKACiiigAooooAKKKKACiiigApr/cb6GnU1huUgHGRigDn/AAD/AMk78Nf9gu2/9FLXRVx2kaD4s0fRrHS7fX9HaGzt0t4zJpEhYqihRki4HOB6Cr32Lxn/ANB7Q/8AwTy//JNAHR0VxWvT+MdE8O6jq39r6JN9itZLgxf2TKu/YpbGftBxnHXFaK2fjIqD/b2h8j/oDy//ACTQB0lFc59i8Z/9B7Q//BPL/wDJNH2Lxn/0HtD/APBPL/8AJNAHR0Vzn2Lxn/0HtD/8E8v/AMk0fYvGf/Qe0P8A8E8v/wAk0AdHRXOfYvGf/Qe0P/wTy/8AyTR9i8Z/9B7Q/wDwTy//ACTQB0dFcTNceMYfEdnpP9r6KftNrPc+b/ZUvy+W0S7cfaOc+b1zxt9+NP7F4z/6D2h/+CeX/wCSaAOjornPsXjP/oPaH/4J5f8A5Jo+xeM/+g9of/gnl/8AkmgDo6K5z7F4z/6D2h/+CeX/AOSaPsXjP/oPaH/4J5f/AJJoA6Oiuc+xeM/+g9of/gnl/wDkmj7F4z/6D2h/+CeX/wCSaAOjoridFn8Y6xYyXX9r6JDsuri22/2TK2fKmeLdn7QOuzOO2cc1p/YvGf8A0HtD/wDBPL/8k0AdHRXOfYvGf/Qe0P8A8E8v/wAk0fYvGf8A0HtD/wDBPL/8k0AdHRXOfYvGf/Qe0P8A8E8v/wAk0fYvGf8A0HtD/wDBPL/8k0AdHRXOfYvGf/Qe0P8A8E8v/wAk1ma1P4x0exjuv7X0SbfdW9tt/smVcebMkW7P2g9N+cd8Y4oA7aiuc+xeM/8AoPaH/wCCeX/5Jo+xeM/+g9of/gnl/wDkmgDo6K5z7F4z/wCg9of/AIJ5f/kmj7F4z/6D2h/+CeX/AOSaAOjornPsXjP/AKD2h/8Agnl/+SaPsXjP/oPaH/4J5f8A5JoA6Oiuc+xeM/8AoPaH/wCCeX/5JrMhuPGM3iO80n+19FH2a1gufN/sqX5vMaVduPtHGPK6553e3IB21Fc59i8Z/wDQe0P/AME8v/yTR9i8Z/8AQe0P/wAE8v8A8k0AdHRXOfYvGf8A0HtD/wDBPL/8k0fYvGf/AEHtD/8ABPL/APJNAHR0Vzn2Lxn/ANB7Q/8AwTy//JNH2Lxn/wBB7Q//AATy/wDyTQB0dFc21n4yCk/29ofA/wCgPL/8k1naDP4x1vw7p2rf2vokP221juBF/ZMrbN6hsZ+0DOM9cUAdrRXOfYvGf/Qe0P8A8E8v/wAk0fYvGf8A0HtD/wDBPL/8k0AdHRXOfYvGf/Qe0P8A8E8v/wAk0fYvGf8A0HtD/wDBPL/8k0AdHRXOfYvGf/Qe0P8A8E8v/wAk0fYvGf8A0HtD/wDBPL/8k0AdHRXE6hP4xsL/AEi2/tfRJP7Qumtt39kyjy8QyS7sfaOf9XjHHXPatP7F4z/6D2h/+CeX/wCSaAOjornPsXjP/oPaH/4J5f8A5Jo+xeM/+g9of/gnl/8AkmgDo6K5z7F4z/6D2h/+CeX/AOSaPsXjP/oPaH/4J5f/AJJoA6Oiuc+xeM/+g9of/gnl/wDkmj7F4z/6D2h/+CeX/wCSaAOjoriYbjxjN4jvNJ/tfRR9mtYLnzf7Kl+bzGlXbj7Rxjyuued3tzp/YvGf/Qe0P/wTy/8AyTQB0dFc59i8Z/8AQe0P/wAE8v8A8k0fYvGf/Qe0P/wTy/8AyTQB0dNf7jfQ1z32Lxn/ANB7Q/8AwTy//JNIbHxkQR/b2h8/9QeX/wCSaAHeAf8Aknfhr/sF23/opa6KsvQNMOieHNM0lphMbK1it/NC7d+xQucZOM49a1KACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAMnW9Y0zSLVP7TciO4bykiETTNKSCSoRQWbgHOAeKn0zUrTWNPivbGdZ7aTO1xkdDggg8ggggg8giuc8T3cGk+MfD2r6hIsOmxQ3du9xJwkMr+WULHouQjjJ9cd6l8CAy2Gq3yIy2t9qtxc2pZSu6IkAOAezEMw9Q2e9AHW0UUUAFFFFABRRRQBztv4s8PXeqxWsV1vuWd4IZTbuI3cfeRJSuxj8vQMfu+1dFXi+iXCNL4dgXUHmuU1UvJ4bKcWOWfc2ceZ+7yWy5KnsBxj2igAooooAKKKKACsa68S6VZ63baPcXDpe3LBYk8iQqzEFgN4XaDhWOCe1bNcD488Q6Pp2t+F7e91O0t5odVW4kSWUKUi8idd5B6LkgZ9TQB0V/4j0fRbkWc8rrOwMvk21rJMygk5dljUlQTnk4yc1tKQyhh0IyK8i1eW3s/E3iq+utdvrOa7hgudFFrMyi5xAFGwLxMd642HI5zj5s16npjXUmlWcl8gjvGgRp0HRZCo3D880AXKKKKACiiigClqOoW2l2Ml5eSGOCPG5gpY8kAAAAkkkgYA71U0zW9J19Z47SQyvbuhkhngeKSM9VJSRQw6ZBx246VLrutWPh3RbvVtRlMVpbLukYDJ5IAAHqSQB7muN0O+l12HW9a0jVNKuPEd5bJHDaxXSypZRKW8tXK5y2XZicYzwOByAdha69pl7rN5pNteLLe2QVriIK3yBs4+bGD0PAPGOa1a808K22p6b8RJrGfS7S2jTRoBKyX7TsR507eYSYl3Ozlt2ceuTnA9LoAKKKKACiiigDH1XxHpuiyKl69yGZd/7m0mmCj1YopCj64qpdeL/DtiyXD3e8TW6TefBbSSr5JyVZnRSFX7xyxA61X8Waxp1tELGfxV/YN4yearqIy8inIwA6nPI6LhuBXJR+L7TTfCOieGGmstE1C6sF8xryTy0s4OV34kOWdgMqhJOTluByAepQyx3EKTQuskUihkdTkMDyCD3FTVnaJBY2+hafb6ZKJbCK2jjtpFcOGjCgKQw68Ac1o0AFFFFABRRRQBlahr+l6Vf2Nje3ax3V/J5dtFtZjI34A4HI5OBzVVfFOgQamujJdos6SC2VVhcRLJjiLzAuwNj+HOfauE8RWvia11mwvrrS9PuJ7jXYfIn/ALQYZjUSeVFt8o7FwSSct8xJxzw2W5hHhe48J7j/AMJI+uM4t9p8xs3vnCf/AHPLw27pxjrQB65RRRQAUUUUAFFFYviWHVrnQriDRWiS9k2oGeUx7UJG8qwVtrbc4ODg4NAEI8VeHpo9Rn+3xMmkS7bmRlOIXwRwSOTyR8ueuParOl+ItN1p547KeQzQBTLDLBJDIgbO0lHUNg4ODjBxXlc0d9bQeMLKbRLW0tYzp6H7LcyT/ZAvlhZFARSwRcyZyOUxggk11Xg6eO58Y6pLb6s2vwtZQqdVKqPLYO/7gFAEPUtwARnknjAB6DRRRQAUUUUAFYuq+JtL0a/jsbuS6a6liMyxW1lNcNsBwWPlo2Bkgc1tVxHi3/hF4tXS41fXLjS9SW0KQtb3jwuYyxPyhf8AWHcv3cHoOKANu98QaPpn2ae5eVZruMNFGlrI87oOeY1UuAN3ORwTzg1qW9xHd20VxCWMcqB0LKVOCMjIOCPoa8jiec6zp+qeMtUvtIW70GFVljla2Lzq7llJXkPhlbZ3J6Hbgej+EJ9RuvCWlz6qHF88CmUyJsY+hZezEYJHYk0AbtFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFeVeDdT13VPEVoba406y09tKinawitZPKVftEqtsAlAVztPzYPbg45APVaK81034g6jqd5aXNvZtNYXV2IVtk0y68xIi+wSmfHlHHDEAYAz8xIrU03xDrV4muX91LpNlpmnXV3bq0qPlhESFdm3YUDAzwc4OMUAdtRXm1v4y1PUf7W0oXEDXA0qW9tbyPT7m1UbSFI2ynLfeUhlb8qm0y/wBUg0DwTJqr2GoyX1zbqkrWzh4gbWRt+5pGzL8uC/GQzcc0Aeh0VwMfi3W2tIPEDQWP9hT6gLMQBX+0KjTeQspfdtPzYOzb0PXNRXPi7xDBb63qoh0z+zNK1JrV4iknnTRhkBYNuwrAN6HOO1AHodFcVN4n1GPxfJplxc2Gm2y3EcUEd5bS77xCqktHNuEYOSyhcMcrz1rtaACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK5Ww8EWelT6fNYajqFu9pELdirRn7REJDJskDIeMs3K7TgnmuqooA5qz8Jx6ddK1jquqW9ks5mGnxyJ5CsW3EDKbwpJPyhsc9MVN/wimnNomp6RKZ5LXUpp5p9zgMGlYs20gDGCeP61v0UAcxZeDba31ZtTudS1LULp7J7FmvJEIMTMrEYRVAOV6j1Oc8YWz8H29pa6XbNqWoXMOl3CT2iztH+72xNEqZVASu1z1ycgc101FAHKr4I0+O+SQXl8bKO7N6mmmVfs6zbt+4Dbu+8d23dtB5xVifwhYXGj6rpjTXIg1O4a5mYFdysxUkL8uAPlHUGuiooA52+8Kx6ne+bd6tqctp56TmxMieRvRgy/wb8BlBxuxxXRUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB//9k=", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "result.convergence_graph" - ] - }, - { - "cell_type": "markdown", - "id": "2d1824ea-80be-4f20-b7ce-d4836483c33f", - "metadata": { - "tags": [] - }, - "source": [ - "# Optimization Results" - ] - }, - { - "cell_type": "markdown", - "id": "2736d59a-20db-4d26-9880-affa35b1e4ef", - "metadata": {}, - "source": [ - "We can also examine the statistics of the algorithm:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "8b90f0c5-da3a-467e-be89-509ce00ccaea", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:43.587793Z", - "iopub.status.busy": "2024-05-07T16:07:43.587613Z", - "iopub.status.idle": "2024-05-07T16:07:43.615672Z", - "shell.execute_reply": "2024-05-07T16:07:43.614990Z" - }, - "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", - "
probabilitycostsolutioncount
620.0038.0[1, 1, 0, 0, 0, 0]3
240.0177.7[0, 1, 0, 1, 1, 0]17
590.0077.7[0, 1, 0, 0, 0, 1]7
20.0287.5[1, 1, 0, 1, 0, 0]28
110.0247.2[0, 1, 0, 1, 0, 1]24
\n", - "
" - ], - "text/plain": [ - " probability cost solution count\n", - "62 0.003 8.0 [1, 1, 0, 0, 0, 0] 3\n", - "24 0.017 7.7 [0, 1, 0, 1, 1, 0] 17\n", - "59 0.007 7.7 [0, 1, 0, 0, 0, 1] 7\n", - "2 0.028 7.5 [1, 1, 0, 1, 0, 0] 28\n", - "11 0.024 7.2 [0, 1, 0, 1, 0, 1] 24" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "from classiq.applications.combinatorial_optimization import (\n", - " get_optimization_solution_from_pyo,\n", - ")\n", - "\n", - "solution = get_optimization_solution_from_pyo(\n", - " knapsack_model, vqe_result=result, penalty_energy=qaoa_config.penalty_energy\n", - ")\n", - "optimization_result = pd.DataFrame.from_records(solution)\n", - "optimization_result.sort_values(by=\"cost\", ascending=False).head(5)" - ] - }, - { - "cell_type": "markdown", - "id": "b5c79c0e-6be3-4a27-97dd-3da93dbae5e6", - "metadata": {}, - "source": [ - "And the histogram:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "2709135d-366d-4f27-8eff-4dd28a4545e5", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:43.618252Z", - "iopub.status.busy": "2024-05-07T16:07:43.617881Z", - "iopub.status.idle": "2024-05-07T16:07:43.813012Z", - "shell.execute_reply": "2024-05-07T16:07:43.812308Z" - }, - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[]], dtype=object)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "optimization_result.hist(\"cost\", weights=optimization_result[\"probability\"])" - ] - }, - { - "cell_type": "markdown", - "id": "2004e2d2-bcdb-43f8-b068-b8cf5b2beb95", - "metadata": {}, - "source": [ - "Lastly, we can compare to the classical solution of the problem:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "777c97cb-00c6-46e5-a145-a22f511d66c0", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:07:43.815782Z", - "iopub.status.busy": "2024-05-07T16:07:43.815309Z", - "iopub.status.idle": "2024-05-07T16:07:43.864718Z", - "shell.execute_reply": "2024-05-07T16:07:43.863986Z" - }, - "pycharm": { - "name": "#%%\n" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model unknown\n", - "\n", - " Variables:\n", - " x : Size=6, Index=x_index\n", - " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", - " 0 : 0 : 0.9999999999999998 : 1 : False : False : Binary\n", - " 1 : 0 : 1.0 : 1 : False : False : Binary\n", - " 2 : 0 : 0.0 : 1 : False : False : Binary\n", - " 3 : 0 : 0.0 : 1 : False : False : Binary\n", - " 4 : 0 : 0.0 : 1 : False : False : Binary\n", - " 5 : 0 : 2.220446049250313e-16 : 1 : False : False : Binary\n", - "\n", - " Objectives:\n", - " value : Size=1, Index=None, Active=True\n", - " Key : Active : Value\n", - " None : True : 8.0\n", - "\n", - " Constraints:\n", - " weight_constraint : Size=1\n", - " Key : Lower : Body : Upper\n", - " None : 5.0 : 5.0 : 5.0\n" - ] - } - ], - "source": [ - "from pyomo.opt import SolverFactory\n", - "\n", - "solver = SolverFactory(\"couenne\")\n", - "solver.solve(knapsack_model)\n", - "\n", - "knapsack_model.display()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - }, - "vscode": { - "interpreter": { - "hash": "a07aacdcc8a415e7643a2bc993226848ff70704ebef014f87460de9126b773d0" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/applications/optimization/knapsack_binary/knapsack_binary.metadata.json b/applications/optimization/knapsack_binary/knapsack_binary.metadata.json deleted file mode 100644 index f3da2e957..000000000 --- a/applications/optimization/knapsack_binary/knapsack_binary.metadata.json +++ /dev/null @@ -1,7 +0,0 @@ -{ - "friendly_name": "Knapsack: Binary Variables", - "description": "Solving Knapsack with Binary Variables Using the QAOA Algorithm", - "problem_domain_tags": ["optimization"], - "qmod_type": ["application"], - "level": ["demos"] -} diff --git a/applications/optimization/knapsack_binary/knapsack_binary.qmod b/applications/optimization/knapsack_binary/knapsack_binary.qmod deleted file mode 100644 index af98415ef..000000000 --- a/applications/optimization/knapsack_binary/knapsack_binary.qmod +++ /dev/null @@ -1,265 +0,0 @@ -hamiltonian: PauliTerm[] = [ - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=4.61 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-1.31 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-0.35 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-0.7 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=-0.8 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-0.85 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-0.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=4.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=2.1 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=2.1 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=4.2 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=4.2 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=6.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=6.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=6.3 - } -]; - -qfunc main(params_list: real[10], output target: qbit[6]) { - allocate(target.len, target); - qaoa_penalty(target.len, params_list, hamiltonian, target); -} - -cscope ``` -vqe_result = vqe( -hamiltonian=hamiltonian, -maximize=True, -initial_point=[0.0, 0.12820512820512817, 0.03205128205128204, 0.09615384615384612, 0.06410256410256408, 0.06410256410256408, 0.09615384615384612, 0.03205128205128204, 0.12820512820512817, 0.0], -optimizer=Optimizer.COBYLA, -max_iteration=60, -tolerance=0.0, -step_size=0.0, -skip_compute_variance=False, -alpha_cvar=0.7 -) - -save({"vqe_result": vqe_result, "hamiltonian": hamiltonian}) -``` diff --git a/applications/optimization/max_clique/max_clique.ipynb b/applications/optimization/max_clique/max_clique.ipynb index f4d1fba38..b84d89a14 100644 --- a/applications/optimization/max_clique/max_clique.ipynb +++ b/applications/optimization/max_clique/max_clique.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "13d83b59-57f7-48ee-8bff-deda7d28edc5", + "id": "10115924-81df-4877-9ef5-0bd2c7f21980", "metadata": { "tags": [] }, @@ -14,7 +14,7 @@ }, { "cell_type": "markdown", - "id": "6d56bb6d-9f3b-45db-8e98-b50f27af7505", + "id": "b6916fad-2b36-4cc7-9f4a-b9991bdcdc29", "metadata": { "tags": [] }, @@ -28,7 +28,7 @@ }, { "cell_type": "markdown", - "id": "3b5fbdb8-373b-4629-8ca1-51ef9be82edd", + "id": "cdc179ce-71f3-4269-a128-94b42b4e00a8", "metadata": {}, "source": [ "# Solving the problem with classiq" @@ -36,7 +36,7 @@ }, { "cell_type": "markdown", - "id": "0bdc4e6a-199b-44b3-bd3f-fd24722b616b", + "id": "43c06afd-0219-4c66-bbdf-8eae31ffd1bc", "metadata": {}, "source": [ "## Define the optimization problem\n", @@ -47,14 +47,8 @@ { "cell_type": "code", "execution_count": 1, - "id": "83ddbd07-f7ab-4d80-b357-3890622d395f", + "id": "e5fc6812-3e72-4415-b4ca-5e873d81041b", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:19.815355Z", - "iopub.status.busy": "2024-05-07T15:48:19.814727Z", - "iopub.status.idle": "2024-05-07T15:48:20.366172Z", - "shell.execute_reply": "2024-05-07T15:48:20.365339Z" - }, "tags": [] }, "outputs": [], @@ -92,7 +86,7 @@ }, { "cell_type": "markdown", - "id": "3496c5d6-7df6-49fb-b5b9-5ba48d2b7d62", + "id": "eba6ce0a-dd2b-4e34-8273-67cdd7706181", "metadata": {}, "source": [ "### Initialize the model with parameters" @@ -101,20 +95,14 @@ { "cell_type": "code", "execution_count": 2, - "id": "bc9871c1-224e-4206-b39e-af7e448aca70", + "id": "2144f922-842a-4d1a-9c81-b87742fbbd73", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:20.372542Z", - "iopub.status.busy": "2024-05-07T15:48:20.370932Z", - "iopub.status.idle": "2024-05-07T15:48:21.344387Z", - "shell.execute_reply": "2024-05-07T15:48:21.343460Z" - }, "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -131,102 +119,80 @@ }, { "cell_type": "markdown", - "id": "abd17e36-857b-4101-9188-1be70206177e", + "id": "17ea14ec-dbb7-487c-b4f1-cabc8d5e3c29", "metadata": { "tags": [] }, "source": [ "## Setting Up the Classiq Problem Instance\n", "\n", - "In order to solve the Pyomo model defined above, we use the Classiq combinatorial optimization engine. For the quantum part of the QAOA algorithm (`QAOAConfig`) - define the number of repetitions (`num_layers`):" + "In order to solve the Pyomo model defined above, we use the `CombinatorialProblem` python class. Under the hood it tranlates the Pyomo model to a quantum model of the QAOA algorithm [[1](#QAOA)], with cost hamiltonian translated from the Pyomo model. We can choose the number of layers for the QAOA ansatz using the argument `num_layers`." ] }, { "cell_type": "code", "execution_count": 3, - "id": "4233341d-139c-493b-b4af-210f71e3354a", + "id": "816b468f-a59f-4f2f-8337-4a9d66548425", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:21.352378Z", - "iopub.status.busy": "2024-05-07T15:48:21.350949Z", - "iopub.status.idle": "2024-05-07T15:48:23.150678Z", - "shell.execute_reply": "2024-05-07T15:48:23.150039Z" - }, "tags": [] }, "outputs": [], "source": [ "from classiq import *\n", - "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", + "from classiq.applications.combinatorial_optimization import CombinatorialProblem\n", "\n", - "qaoa_config = QAOAConfig(num_layers=20)" - ] - }, - { - "cell_type": "markdown", - "id": "e8e4f132-55d7-4a46-846c-b4d4b5edac57", - "metadata": {}, - "source": [ - "For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`max_iteration`) and the $\\alpha$-parameter (`alpha_cvar`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" + "combi = CombinatorialProblem(pyo_model=max_clique_model, num_layers=3)\n", + "\n", + "qmod = combi.get_model()" ] }, { "cell_type": "code", "execution_count": 4, - "id": "7384872d-a28f-49e3-918d-a5749c70d873", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:23.153812Z", - "iopub.status.busy": "2024-05-07T15:48:23.153151Z", - "iopub.status.idle": "2024-05-07T15:48:23.157294Z", - "shell.execute_reply": "2024-05-07T15:48:23.156687Z" - }, - "pycharm": { - "name": "#%%\n" - }, - "tags": [] - }, + "id": "62ec28b3-cb49-411a-8c4a-8004fff6c105", + "metadata": {}, "outputs": [], "source": [ - "optimizer_config = OptimizerConfig(max_iteration=1, alpha_cvar=1)" + "write_qmod(qmod, \"max_clique\")" ] }, { "cell_type": "markdown", - "id": "01c3df80-5e78-4cf6-9429-4ef0eaafed78", + "id": "943291f0-6a9f-4286-a69d-ef13a0a12ef6", "metadata": {}, "source": [ - "Lastly, we load the model, based on the problem and algorithm parameters, which we can use to solve the problem:" + "## Synthesizing the QAOA Circuit and Solving the Problem\n", + "\n", + "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" ] }, { "cell_type": "code", "execution_count": 5, - "id": "3f848bc5-1ded-440a-b426-2f40e21949aa", + "id": "1d71e29a-5d53-49c4-84b2-45f59be4da31", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:23.160101Z", - "iopub.status.busy": "2024-05-07T15:48:23.159651Z", - "iopub.status.idle": "2024-05-07T15:48:23.462012Z", - "shell.execute_reply": "2024-05-07T15:48:23.461349Z" - }, "pycharm": { "name": "#%%\n" }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://nightly.platform.classiq.io/circuit/12b0d353-e44e-4992-bcb8-deb3a88a482b?version=0.62.0.dev7\n" + ] + } + ], "source": [ - "qmod = construct_combinatorial_optimization_model(\n", - " pyo_model=max_clique_model,\n", - " qaoa_config=qaoa_config,\n", - " optimizer_config=optimizer_config,\n", - ")" + "qprog = combi.get_qprog()\n", + "show(qprog)" ] }, { "cell_type": "markdown", - "id": "4e28c1f5-d1df-4600-a364-0ef54dab8209", + "id": "b119464b-9d46-4ea0-ba4a-1734f3e0e3e5", "metadata": {}, "source": [ "We also set the quantum backend we want to execute on:" @@ -235,111 +201,87 @@ { "cell_type": "code", "execution_count": 6, - "id": "794a44cd-6d2a-47b1-9e71-fb2d05a8442b", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:23.465067Z", - "iopub.status.busy": "2024-05-07T15:48:23.464641Z", - "iopub.status.idle": "2024-05-07T15:48:23.482772Z", - "shell.execute_reply": "2024-05-07T15:48:23.482176Z" - }, - "tags": [] - }, + "id": "7d188c69-21d1-4afe-86b1-46229e91a01e", + "metadata": {}, "outputs": [], "source": [ - "from classiq.execution import ClassiqBackendPreferences\n", + "from classiq.execution import *\n", "\n", - "qmod = set_execution_preferences(\n", - " qmod, backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", + "execution_preferences = ExecutionPreferences(\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\"),\n", ")" ] }, - { - "cell_type": "code", - "execution_count": 7, - "id": "1acdcc28-3101-4a80-9b36-87cd5780abbb", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:23.485247Z", - "iopub.status.busy": "2024-05-07T15:48:23.484855Z", - "iopub.status.idle": "2024-05-07T15:48:23.511694Z", - "shell.execute_reply": "2024-05-07T15:48:23.511113Z" - } - }, - "outputs": [], - "source": [ - "write_qmod(qmod, \"max_clique\")" - ] - }, { "cell_type": "markdown", - "id": "6e3057bc-33bc-4a2c-818e-b967598c2141", + "id": "07621d7c-0e54-4adb-9c47-8fd99a346e29", "metadata": {}, "source": [ - "## Synthesizing the QAOA Circuit and Solving the Problem\n", - "\n", - "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" + "We now solve the problem by calling the `optimize` method of the `CombinatorialProblem` object. For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`maxiter`) and the $\\alpha$-parameter (`quantile`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[2](#cvar)]:" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "ad8e435d-4482-4d5f-ad53-886581d4fea0", + "execution_count": 7, + "id": "62d12d20-1c80-4a9e-bb6b-b1fddc6cbe40", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:23.514439Z", - "iopub.status.busy": "2024-05-07T15:48:23.513955Z", - "iopub.status.idle": "2024-05-07T15:48:49.929603Z", - "shell.execute_reply": "2024-05-07T15:48:49.928841Z" - }, - "pycharm": { - "name": "#%%\n" - }, "tags": [] }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/88ddbcbe-e798-4683-b7be-3052b1efec1a?version=0.41.0.dev39%2B79c8fd0855\n" + "Optimization Progress: 51it [02:27, 2.88s/it] \n" ] } ], "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "1f78ae22-4ab8-4890-ad74-227dedcbde75", - "metadata": {}, - "source": [ - "We now solve the problem by calling the `execute` function on the quantum program we have generated:" + "optimized_params = combi.optimize(execution_preferences, maxiter=50, quantile=0.7)" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "27afef0a-52a4-4930-8a3a-f509bd5956bd", + "execution_count": 8, + "id": "b52604ae-fc57-426f-8566-9e3760250e81", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:49.934524Z", - "iopub.status.busy": "2024-05-07T15:48:49.933310Z", - "iopub.status.idle": "2024-05-07T15:48:56.641053Z", - "shell.execute_reply": "2024-05-07T15:48:56.640136Z" - }, + "scrolled": true, "tags": [] }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Cost convergence')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "result = execute(qprog).result_value()" + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(combi.cost_trace)\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.title(\"Cost convergence\")" ] }, { "cell_type": "markdown", - "id": "f4f0b68a-e56f-4d11-b9f8-fe3b9bdab697", + "id": "615ed612-b835-4bf0-aa92-92d30ef8006d", "metadata": { "tags": [] }, @@ -349,25 +291,25 @@ }, { "cell_type": "markdown", - "id": "bdacb755-5cdc-45c2-95d5-037efe20f9d6", + "id": "2510a439-9181-4e39-a033-0bd53e8f87f6", + "metadata": {}, + "source": [ + "We can also examine the statistics of the algorithm. The optimization is always defined as a minimzation problem, so the positive maximization objective was tranlated to a negative minimization one by the Pyomo to qmod translator." + ] + }, + { + "cell_type": "markdown", + "id": "e06ae35f-7aac-4631-9fe9-4f46a36c8cea", "metadata": {}, "source": [ - "We can also examine the statistics of the algorithm:" + "In order to get samples with the optimized parameters, we call the `sample` method:" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "0134df1a-8894-4a1f-b6da-dc1883a49599", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:56.653630Z", - "iopub.status.busy": "2024-05-07T15:48:56.645232Z", - "iopub.status.idle": "2024-05-07T15:48:56.764591Z", - "shell.execute_reply": "2024-05-07T15:48:56.763847Z" - }, - "tags": [] - }, + "execution_count": 9, + "id": "9638f749-a60b-4176-a4ea-50d7c2bb986f", + "metadata": {}, "outputs": [ { "data": { @@ -390,105 +332,102 @@ " \n", " \n", " \n", + " solution\n", " probability\n", " cost\n", - " solution\n", - " count\n", " \n", " \n", " \n", " \n", - " 115\n", - " 0.001\n", - " 4.0\n", - " [0, 1, 1, 1, 0, 1, 0]\n", - " 1\n", + " 93\n", + " {'x': [0, 1, 1, 1, 0, 1, 0]}\n", + " 0.000488\n", + " -4.0\n", " \n", " \n", - " 90\n", - " 0.003\n", - " 4.0\n", - " [1, 1, 1, 1, 0, 0, 0]\n", - " 3\n", + " 86\n", + " {'x': [1, 1, 1, 1, 0, 0, 0]}\n", + " 0.000488\n", + " -4.0\n", " \n", " \n", - " 107\n", - " 0.001\n", - " 3.0\n", - " [0, 1, 0, 0, 0, 1, 1]\n", - " 1\n", + " 50\n", + " {'x': [0, 1, 1, 0, 0, 1, 0]}\n", + " 0.003418\n", + " -3.0\n", " \n", " \n", - " 111\n", - " 0.001\n", - " 3.0\n", - " [1, 0, 0, 1, 1, 0, 0]\n", - " 1\n", + " 41\n", + " {'x': [1, 1, 0, 1, 0, 0, 0]}\n", + " 0.004883\n", + " -3.0\n", " \n", " \n", - " 89\n", - " 0.003\n", - " 3.0\n", - " [0, 1, 1, 0, 0, 1, 0]\n", - " 3\n", + " 44\n", + " {'x': [1, 0, 1, 1, 0, 0, 0]}\n", + " 0.004395\n", + " -3.0\n", " \n", " \n", "\n", "" ], "text/plain": [ - " probability cost solution count\n", - "115 0.001 4.0 [0, 1, 1, 1, 0, 1, 0] 1\n", - "90 0.003 4.0 [1, 1, 1, 1, 0, 0, 0] 3\n", - "107 0.001 3.0 [0, 1, 0, 0, 0, 1, 1] 1\n", - "111 0.001 3.0 [1, 0, 0, 1, 1, 0, 0] 1\n", - "89 0.003 3.0 [0, 1, 1, 0, 0, 1, 0] 3" + " solution probability cost\n", + "93 {'x': [0, 1, 1, 1, 0, 1, 0]} 0.000488 -4.0\n", + "86 {'x': [1, 1, 1, 1, 0, 0, 0]} 0.000488 -4.0\n", + "50 {'x': [0, 1, 1, 0, 0, 1, 0]} 0.003418 -3.0\n", + "41 {'x': [1, 1, 0, 1, 0, 0, 0]} 0.004883 -3.0\n", + "44 {'x': [1, 0, 1, 1, 0, 0, 0]} 0.004395 -3.0" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import pandas as pd\n", - "\n", - "from classiq.applications.combinatorial_optimization import (\n", - " get_optimization_solution_from_pyo,\n", - ")\n", - "\n", - "solution = get_optimization_solution_from_pyo(\n", - " max_clique_model, vqe_result=result, penalty_energy=qaoa_config.penalty_energy\n", - ")\n", - "optimization_result = pd.DataFrame.from_records(solution)\n", - "optimization_result.sort_values(by=\"cost\", ascending=False).head(5)" + "optimization_result = combi.sample(combi.optimized_params)\n", + "optimization_result.sort_values(by=\"cost\").head(5)" ] }, { "cell_type": "markdown", - "id": "2724dafb-eb26-4756-8086-e415cecb0e78", + "id": "d2631766-717e-41d1-889d-a2c83ff479e3", "metadata": {}, "source": [ - "## Resulting Clique" + "We will also want to compare the optimized results to uniformly sampled results:" ] }, { "cell_type": "code", - "execution_count": 11, - "id": "4d99764d-8ff1-4397-9dac-c5e584862bfb", + "execution_count": 10, + "id": "ce23d35b-4780-4feb-a1fa-58e302e3feb3", + "metadata": {}, + "outputs": [], + "source": [ + "uniform_result = combi.sample_uniform()" + ] + }, + { + "cell_type": "markdown", + "id": "687f492b-a4a5-49c6-964c-8959b035bb93", + "metadata": {}, + "source": [ + "And compare the histograms:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "31a4e74d-b2b8-42e0-826d-de7b51de1fe8", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:56.769629Z", - "iopub.status.busy": "2024-05-07T15:48:56.768261Z", - "iopub.status.idle": "2024-05-07T15:48:57.012646Z", - "shell.execute_reply": "2024-05-07T15:48:57.011984Z" - }, "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -498,57 +437,71 @@ } ], "source": [ - "solution = optimization_result.solution[optimization_result.cost.idxmax()]\n", - "solution_nodes = [v for v in graph.nodes if solution[v]]\n", - "solution_edges = [\n", - " (u, v) for u, v in graph.edges if u in solution_nodes and v in solution_nodes\n", - "]\n", - "nx.draw_kamada_kawai(graph, with_labels=True)\n", - "nx.draw_kamada_kawai(\n", - " graph,\n", - " with_labels=True,\n", - " nodelist=solution_nodes,\n", - " edgelist=solution_edges,\n", - " node_color=\"r\",\n", - " edge_color=\"r\",\n", - ")" + "optimization_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=40,\n", + " edgecolor=\"black\",\n", + " weights=optimization_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"optimized\",\n", + ")\n", + "uniform_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=40,\n", + " edgecolor=\"black\",\n", + " weights=uniform_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"uniform\",\n", + ")\n", + "plt.legend()\n", + "plt.ylabel(\"Probability\", fontsize=16)\n", + "plt.xlabel(\"cost\", fontsize=16)\n", + "plt.tick_params(axis=\"both\", labelsize=14)" ] }, { "cell_type": "markdown", - "id": "d4d30ce4-f2b3-4049-b0e0-3cdc7b4897a1", + "id": "a3a890a1-c5d4-409d-b9a3-d7ffd4fdd6c0", "metadata": {}, "source": [ - "And the histogram:" + "Let us plot the solution:" ] }, { "cell_type": "code", "execution_count": 12, - "id": "c3233840-123c-4e29-8368-87ea3c135863", + "id": "4326e84b-26f6-4ea9-a53b-090fb3658b8c", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:57.016876Z", - "iopub.status.busy": "2024-05-07T15:48:57.015879Z", - "iopub.status.idle": "2024-05-07T15:48:57.334652Z", - "shell.execute_reply": "2024-05-07T15:48:57.333914Z" - }, "tags": [] }, "outputs": [ { "data": { "text/plain": [ - "array([[]], dtype=object)" + "{'x': [1, 1, 1, 1, 0, 0, 0]}" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" - }, + } + ], + "source": [ + "best_solution = optimization_result.solution[optimization_result.cost.idxmin()]\n", + "best_solution" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9b868135-e219-441c-8d98-6b43d894a130", + "metadata": { + "tags": [] + }, + "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -558,36 +511,42 @@ } ], "source": [ - "optimization_result.hist(\"cost\", weights=optimization_result[\"probability\"])" + "solution_nodes = [v for v in graph.nodes if best_solution[\"x\"][v]]\n", + "solution_edges = [\n", + " (u, v) for u, v in graph.edges if u in solution_nodes and v in solution_nodes\n", + "]\n", + "nx.draw_kamada_kawai(graph, with_labels=True)\n", + "nx.draw_kamada_kawai(\n", + " graph,\n", + " with_labels=True,\n", + " nodelist=solution_nodes,\n", + " edgelist=solution_edges,\n", + " node_color=\"r\",\n", + " edge_color=\"r\",\n", + ")" ] }, { "cell_type": "markdown", - "id": "896bd3ad-ac54-4e21-b654-ba00743ece86", + "id": "149932e1-bfa8-4c27-b5f9-037e74eba400", "metadata": {}, "source": [ - "Lastly, we can compare to the classical solution of the problem:" + "## Comparison to a classical solver" ] }, { "cell_type": "markdown", - "id": "c9b54c5b-10e5-4f9c-9e00-44ac2cf24a33", + "id": "dde1905d-aeff-4297-a9d3-ad14910e6161", "metadata": {}, "source": [ - "## Classical optimizer results" + "Lastly, we can compare to the classical solution of the problem:" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "dd5a1911-0eea-47fc-82f6-8942c8a4eac8", + "execution_count": 14, + "id": "5a7ca4b6-25a0-46dd-b5cc-de6a639a6f57", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:57.339572Z", - "iopub.status.busy": "2024-05-07T15:48:57.338409Z", - "iopub.status.idle": "2024-05-07T15:48:57.474823Z", - "shell.execute_reply": "2024-05-07T15:48:57.474130Z" - }, "pycharm": { "name": "#%%\n" }, @@ -598,28 +557,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Model unknown\n", - "\n", - " Variables:\n", - " x : Size=7, Index=x_index\n", - " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", - " 0 : 0 : 1.0 : 1 : False : False : Binary\n", - " 1 : 0 : 1.0 : 1 : False : False : Binary\n", - " 2 : 0 : 1.0 : 1 : False : False : Binary\n", - " 3 : 0 : 1.0 : 1 : False : False : Binary\n", - " 4 : 0 : 0.0 : 1 : False : False : Binary\n", - " 5 : 0 : 3.9960192291414966e-08 : 1 : False : False : Binary\n", - " 6 : 0 : 0.0 : 1 : False : False : Binary\n", - "\n", - " Objectives:\n", - " value : Size=1, Index=None, Active=True\n", - " Key : Active : Value\n", - " None : True : 4.0000000399601925\n", - "\n", - " Constraints:\n", - " clique_constraint : Size=1\n", - " Key : Lower : Body : Upper\n", - " None : 0.0 : 7.992038458282993e-08 : 0.0\n" + "Classical solution: [1, 1, 1, 1, 0, 0, 0]\n" ] } ], @@ -628,27 +566,23 @@ "\n", "solver = SolverFactory(\"couenne\")\n", "solver.solve(max_clique_model)\n", - "\n", - "max_clique_model.display()" + "classical_solution = [\n", + " int(pyo.value(max_clique_model.x[i])) for i in range(len(max_clique_model.x))\n", + "]\n", + "print(\"Classical solution:\", classical_solution)" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "5fccfe7a-4567-4c2c-8287-1cae1b75e875", + "execution_count": 15, + "id": "79666d4d-e105-4706-b44e-e5c73b928af3", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:48:57.479695Z", - "iopub.status.busy": "2024-05-07T15:48:57.478528Z", - "iopub.status.idle": "2024-05-07T15:48:57.808411Z", - "shell.execute_reply": "2024-05-07T15:48:57.807685Z" - }, "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -673,6 +607,23 @@ " edge_color=\"r\",\n", ")" ] + }, + { + "cell_type": "markdown", + "id": "e82b5953-122a-4707-8ab6-f741f14f13a5", + "metadata": { + "pycharm": { + "name": "#%% md\n" + }, + "tags": [] + }, + "source": [ + "## References\n", + "\n", + "[1]: [Farhi, Edward, Jeffrey Goldstone, and Sam Gutmann. \"A quantum approximate optimization algorithm.\" arXiv preprint arXiv:1411.4028 (2014).](https://arxiv.org/abs/1411.4028)\n", + "\n", + "[2]: [Barkoutsos, Panagiotis Kl, et al. \"Improving variational quantum optimization using CVaR.\" Quantum 4 (2020): 256.](https://arxiv.org/abs/1907.04769)\n" + ] } ], "metadata": { @@ -691,7 +642,12 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.4" + }, + "vscode": { + "interpreter": { + "hash": "a07aacdcc8a415e7643a2bc993226848ff70704ebef014f87460de9126b773d0" + } } }, "nbformat": 4, diff --git a/applications/optimization/max_clique/max_clique.qmod b/applications/optimization/max_clique/max_clique.qmod index 72f12c9ab..413e3aba9 100644 --- a/applications/optimization/max_clique/max_clique.qmod +++ b/applications/optimization/max_clique/max_clique.qmod @@ -1,755 +1,14 @@ -hamiltonian: PauliTerm[] = [ - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=30.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-6.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-6.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=-8.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-8.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-17.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-23.5 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-23.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=2.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=4.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=4.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=16.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=3.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=7.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=9.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=9.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=13.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=13.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=-2.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=-4.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-4.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-8.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-3.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=-3.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-3.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - } -]; - -qfunc main(params_list: real[40], output target: qbit[7]) { - allocate(target.len, target); - qaoa_penalty(target.len, params_list, hamiltonian, target); +qstruct QAOAVars { + x: qbit[7]; } -cscope ``` -vqe_result = vqe( -hamiltonian=hamiltonian, -maximize=True, -initial_point=[0.0, 0.0683371298405467, 0.0035966910442392997, 0.0647404387963074, 0.007193382088478599, 0.0611437477520681, 0.0107900731327179, 0.057547056707828795, 0.014386764176957199, 0.053950365663589496, 0.017983455221196498, 0.050353674619350204, 0.0215801462654358, 0.0467569835751109, 0.0251768373096751, 0.0431602925308716, 0.028773528353914397, 0.0395636014866323, 0.032370219398153696, 0.035966910442393, 0.035966910442392995, 0.0323702193981537, 0.0395636014866323, 0.028773528353914397, 0.0431602925308716, 0.025176837309675102, 0.04675698357511089, 0.021580146265435807, 0.0503536746193502, 0.0179834552211965, 0.053950365663589496, 0.014386764176957199, 0.057547056707828795, 0.010790073132717903, 0.061143747752068094, 0.007193382088478607, 0.06474043879630739, 0.0035966910442393036, 0.0683371298405467, 0.0], -optimizer=Optimizer.COBYLA, -max_iteration=1, -tolerance=0.0, -step_size=0.0, -skip_compute_variance=False, -alpha_cvar=1 -) - -save({"vqe_result": vqe_result, "hamiltonian": hamiltonian}) -``` +qfunc main(params: real[6], output v: QAOAVars) { + allocate(v.size, v); + hadamard_transform(v); + repeat (i: 3) { + phase (-((((((((-v.x[0]) - v.x[1]) - v.x[2]) - v.x[3]) - v.x[4]) - v.x[5]) - v.x[6]) + (2 * ((((((((2 * v.x[0]) * v.x[5]) + (v.x[1] * v.x[4])) + (v.x[2] * (v.x[4] + v.x[6]))) + (v.x[3] * v.x[6])) + (v.x[4] * ((v.x[1] + v.x[2]) + v.x[6]))) + (v.x[6] * ((v.x[2] + v.x[3]) + v.x[4]))) ** 2))), params[i]); + apply_to_all(lambda(q) { + RX(params[3 + i], q); + }, v); + } +} diff --git a/applications/optimization/max_clique/max_clique.synthesis_options.json b/applications/optimization/max_clique/max_clique.synthesis_options.json index 0967ef424..ba1113e93 100644 --- a/applications/optimization/max_clique/max_clique.synthesis_options.json +++ b/applications/optimization/max_clique/max_clique.synthesis_options.json @@ -1 +1,43 @@ -{} +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "rz", + "cx", + "h", + "u1", + "r", + "sx", + "s", + "rx", + "y", + "cy", + "tdg", + "ry", + "u2", + "u", + "x", + "cz", + "z", + "sxdg", + "sdg", + "t", + "p", + "id" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": -1 + } +} diff --git a/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.ipynb b/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.ipynb index 23e165fe7..6ec67e78c 100644 --- a/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.ipynb +++ b/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.ipynb @@ -42,7 +42,7 @@ "\n", "# Solving with the Classiq platform\n", "\n", - "We go through the steps of solving the problem with the Classiq platform, using QAOA algorithm [[2](#QAOA)]. The solution is based on defining a pyomo model for the optimization problem we would like to solve." + "We go through the steps of solving the problem with the Classiq platform, using QAOA algorithm [[2](#QAOA)]. The solution is based on defining a Pyomo model for the optimization problem we would like to solve." ] }, { @@ -50,12 +50,6 @@ "execution_count": 1, "id": "49a9588b-e79e-4813-b7c5-ac068d7b930c", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:01.828768Z", - "iopub.status.busy": "2024-05-07T15:49:01.828308Z", - "iopub.status.idle": "2024-05-07T15:49:02.672170Z", - "shell.execute_reply": "2024-05-07T15:49:02.671553Z" - }, "tags": [] }, "outputs": [], @@ -74,7 +68,7 @@ "source": [ "## Building the Pyomo model from a graph input\n", "\n", - "We proceed by defining the pyomo model that will be used on the Classiq platform, using the mathematical formulation defined above:" + "We proceed by defining the Pyomo model that will be used on the Classiq platform, using the mathematical formulation defined above:" ] }, { @@ -82,12 +76,6 @@ "execution_count": 2, "id": "48889b21-557b-481c-80c5-3c0b5c91adb6", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:02.675329Z", - "iopub.status.busy": "2024-05-07T15:49:02.674765Z", - "iopub.status.idle": "2024-05-07T15:49:02.679496Z", - "shell.execute_reply": "2024-05-07T15:49:02.678928Z" - }, "tags": [] }, "outputs": [], @@ -115,26 +103,19 @@ "\n", "- Index set declarations (model.Nodes, model.Arcs).\n", "- Binary variable declaration for each node (model.x) indicating whether the variable is chosen for the set.\n", - "- Constraint rule \u2013 ensures that the set is of size k.\n", - "- Objective rule \u2013 counts the number of edges not covered; i.e., both related variables are zero." + "- Constraint rule – ensures that the set is of size k.\n", + "- Objective rule – counts the number of edges not covered; i.e., both related variables are zero." ] }, { "cell_type": "code", "execution_count": 3, "id": "439b4081-cb00-4a59-bc23-20a21a291f67", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:02.681807Z", - "iopub.status.busy": "2024-05-07T15:49:02.681487Z", - "iopub.status.idle": "2024-05-07T15:49:03.007232Z", - "shell.execute_reply": "2024-05-07T15:49:03.006530Z" - } - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -158,12 +139,7 @@ "execution_count": 4, "id": "345330b2-9c14-41f6-b4ba-e11fb9ca1565", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:03.009901Z", - "iopub.status.busy": "2024-05-07T15:49:03.009417Z", - "iopub.status.idle": "2024-05-07T15:49:03.015488Z", - "shell.execute_reply": "2024-05-07T15:49:03.014894Z" - }, + "scrolled": true, "tags": [] }, "outputs": [ @@ -210,102 +186,80 @@ }, { "cell_type": "markdown", - "id": "17ea14ec-dbb7-487c-b4f1-cabc8d5e3c29", + "id": "b85b6a8c-d327-4043-b082-44d82135b51b", "metadata": { "tags": [] }, "source": [ "## Setting Up the Classiq Problem Instance\n", "\n", - "In order to solve the Pyomo model defined above, we use the Classiq combinatorial optimization engine. For the quantum part of the QAOA algorithm (`QAOAConfig`) - define the number of repetitions (`num_layers`):" + "In order to solve the Pyomo model defined above, we use the `CombinatorialProblem` python class. Under the hood it tranlates the Pyomo model to a quantum model of the QAOA algorithm, with cost hamiltonian translated from the Pyomo model. We can choose the number of layers for the QAOA ansatz using the argument `num_layers`, and the `penalty_factor`, which will be the coefficient of the constraints term in the cost hamiltonian." ] }, { "cell_type": "code", "execution_count": 5, - "id": "816b468f-a59f-4f2f-8337-4a9d66548425", + "id": "9709fd60-fb81-4af0-882b-efa216477fec", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:03.018150Z", - "iopub.status.busy": "2024-05-07T15:49:03.017651Z", - "iopub.status.idle": "2024-05-07T15:49:05.001488Z", - "shell.execute_reply": "2024-05-07T15:49:05.000681Z" - }, "tags": [] }, "outputs": [], "source": [ "from classiq import *\n", - "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", + "from classiq.applications.combinatorial_optimization import CombinatorialProblem\n", "\n", - "qaoa_config = QAOAConfig(num_layers=3)" - ] - }, - { - "cell_type": "markdown", - "id": "db34d5ac-6877-4285-8dec-7bf7b37eb783", - "metadata": {}, - "source": [ - "For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`max_iteration`) and the $\\alpha$-parameter (`alpha_cvar`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" + "combi = CombinatorialProblem(pyo_model=mvc_model, num_layers=3, penalty_factor=10)\n", + "\n", + "qmod = combi.get_model()" ] }, { "cell_type": "code", "execution_count": 6, - "id": "e41d0dd3-4135-4330-9ba3-c1b30c339a74", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:05.006362Z", - "iopub.status.busy": "2024-05-07T15:49:05.005049Z", - "iopub.status.idle": "2024-05-07T15:49:05.009888Z", - "shell.execute_reply": "2024-05-07T15:49:05.009276Z" - }, - "pycharm": { - "name": "#%%\n" - }, - "tags": [] - }, + "id": "133ddfff-b7f4-436a-b656-81a32a236a98", + "metadata": {}, "outputs": [], "source": [ - "optimizer_config = OptimizerConfig(max_iteration=60, alpha_cvar=0.7)" + "write_qmod(qmod, \"max_k_vertex_cover\")" ] }, { "cell_type": "markdown", - "id": "214d6051-43b8-4b9d-8454-f9cdb62b4cf0", + "id": "411eeb04-f598-4585-87bf-a168787714f3", "metadata": {}, "source": [ - "Lastly, we load the model, based on the problem and algorithm parameters, which we can use to solve the problem:" + "## Synthesizing the QAOA Circuit and Solving the Problem\n", + "\n", + "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "0243019c-6fc3-435f-b6ec-8b4355d6660c", + "execution_count": 8, + "id": "69d7c8ac-29c6-42b7-9111-fcf88a4e816a", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:05.014101Z", - "iopub.status.busy": "2024-05-07T15:49:05.012999Z", - "iopub.status.idle": "2024-05-07T15:49:05.454332Z", - "shell.execute_reply": "2024-05-07T15:49:05.453564Z" - }, "pycharm": { "name": "#%%\n" }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://nightly.platform.classiq.io/circuit/6cb47285-352a-47be-8371-154272108ce1?version=0.62.0.dev9\n" + ] + } + ], "source": [ - "qmod = construct_combinatorial_optimization_model(\n", - " pyo_model=mvc_model,\n", - " qaoa_config=qaoa_config,\n", - " optimizer_config=optimizer_config,\n", - ")" + "qprog = combi.get_qprog()\n", + "show(qprog)" ] }, { "cell_type": "markdown", - "id": "1fcc3812-c9d0-421c-84bb-38047297b33f", + "id": "7300af19-c7c4-4e93-a01b-fa7305a60b4d", "metadata": {}, "source": [ "We also set the quantum backend we want to execute on:" @@ -313,112 +267,49 @@ }, { "cell_type": "code", - "execution_count": 8, - "id": "53bc041f-065c-44d2-b220-dafd9d0504ac", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:05.459516Z", - "iopub.status.busy": "2024-05-07T15:49:05.458347Z", - "iopub.status.idle": "2024-05-07T15:49:05.490549Z", - "shell.execute_reply": "2024-05-07T15:49:05.489834Z" - }, - "tags": [] - }, + "execution_count": 9, + "id": "c052e252-745c-4b93-8df7-992d3c5d3277", + "metadata": {}, "outputs": [], "source": [ - "from classiq.execution import ClassiqBackendPreferences\n", + "from classiq.execution import *\n", "\n", - "qmod = set_execution_preferences(\n", - " qmod, backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", + "execution_preferences = ExecutionPreferences(\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\"),\n", ")" ] }, - { - "cell_type": "code", - "execution_count": 9, - "id": "91fea2e9-0ce2-43cb-850c-3ba65a8a76c4", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:05.495462Z", - "iopub.status.busy": "2024-05-07T15:49:05.494337Z", - "iopub.status.idle": "2024-05-07T15:49:05.546829Z", - "shell.execute_reply": "2024-05-07T15:49:05.546110Z" - } - }, - "outputs": [], - "source": [ - "write_qmod(qmod, \"max_k_vertex_cover\")" - ] - }, { "cell_type": "markdown", - "id": "943291f0-6a9f-4286-a69d-ef13a0a12ef6", + "id": "62a5d189-4c7d-42d9-8c8b-5a24d0ed2271", "metadata": {}, "source": [ - "## Synthesizing the QAOA Circuit and Solving the Problem\n", - "\n", - "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" + "We now solve the problem by calling the `optimize` method of the `CombinatorialProblem` object. For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`maxiter`) and the $\\alpha$-parameter (`quantile`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" ] }, { "cell_type": "code", "execution_count": 10, - "id": "1d71e29a-5d53-49c4-84b2-45f59be4da31", + "id": "066869ce-6c80-4e8a-9943-77ceabe74388", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:05.552136Z", - "iopub.status.busy": "2024-05-07T15:49:05.550905Z", - "iopub.status.idle": "2024-05-07T15:49:10.398718Z", - "shell.execute_reply": "2024-05-07T15:49:10.398036Z" - }, - "pycharm": { - "name": "#%%\n" - }, "tags": [] }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/308cc52e-d608-47d6-9ccb-ceb9f2e932a2?version=0.41.0.dev39%2B79c8fd0855\n" + "Optimization Progress: 77%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▊ | 69/90 [04:58<01:30, 4.32s/it]\n" ] } ], "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" + "optimized_params = combi.optimize(execution_preferences, maxiter=90, quantile=0.7)" ] }, { "cell_type": "markdown", - "id": "80238cf9-d7bd-46e5-9d48-b7cf23a6b304", - "metadata": {}, - "source": [ - "We now solve the problem by calling the `execute` function on the quantum program we have generated:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "62d12d20-1c80-4a9e-bb6b-b1fddc6cbe40", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:10.401335Z", - "iopub.status.busy": "2024-05-07T15:49:10.400809Z", - "iopub.status.idle": "2024-05-07T15:49:20.990694Z", - "shell.execute_reply": "2024-05-07T15:49:20.990084Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "result = execute(qprog).result_value()" - ] - }, - { - "cell_type": "markdown", - "id": "620ea6a0-cd05-41a9-a2ed-9631c680d2e6", + "id": "ab153f29-2a25-422f-aed8-69283f6691e0", "metadata": {}, "source": [ "We can check the convergence of the run:" @@ -426,33 +317,40 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "02454398-b229-403c-824a-b1eb539fbc1f", + "execution_count": 11, + "id": "be6bc7ec-c1f8-4925-be2b-0dceb20d73cc", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:20.993567Z", - "iopub.status.busy": "2024-05-07T15:49:20.993008Z", - "iopub.status.idle": "2024-05-07T15:49:21.013136Z", - "shell.execute_reply": "2024-05-07T15:49:21.012480Z" - }, "tags": [] }, "outputs": [ { "data": { - "image/jpeg": "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", - "image/png": "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", "text/plain": [ - "" + "Text(0.5, 1.0, 'Cost convergence')" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "result.convergence_graph" + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(combi.cost_trace)\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.title(\"Cost convergence\")" ] }, { @@ -467,25 +365,17 @@ }, { "cell_type": "markdown", - "id": "670eddd3-2da7-4a88-b571-7884ef24f60c", + "id": "0e49c243-8621-4893-9033-ddb45087f30d", "metadata": {}, "source": [ - "We can also examine the statistics of the algorithm:" + "We can also examine the statistics of the algorithm. In order to get samples with the optimized parameters, we call the `sample` method:" ] }, { "cell_type": "code", "execution_count": 13, - "id": "516d78ba-2951-46eb-b1af-efe877513556", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:21.015680Z", - "iopub.status.busy": "2024-05-07T15:49:21.015305Z", - "iopub.status.idle": "2024-05-07T15:49:21.093102Z", - "shell.execute_reply": "2024-05-07T15:49:21.092387Z" - }, - "tags": [] - }, + "id": "778d3344-c84e-47cd-89b6-55d1df980813", + "metadata": {}, "outputs": [ { "data": { @@ -508,59 +398,53 @@ " \n", " \n", " \n", + " solution\n", " probability\n", " cost\n", - " solution\n", - " count\n", " \n", " \n", " \n", " \n", - " 0\n", - " 0.058\n", + " 289\n", + " {'x': [1, 1, 0, 0, 1, 0, 1, 0, 1, 0]}\n", + " 0.000977\n", " 1.0\n", - " [1, 1, 0, 0, 1, 0, 1, 0, 1, 0]\n", - " 58\n", " \n", " \n", - " 2\n", - " 0.024\n", + " 399\n", + " {'x': [1, 1, 0, 1, 1, 0, 0, 0, 1, 0]}\n", + " 0.000977\n", " 1.0\n", - " [1, 1, 0, 1, 1, 0, 0, 0, 1, 0]\n", - " 24\n", " \n", " \n", - " 272\n", - " 0.001\n", + " 665\n", + " {'x': [1, 1, 0, 1, 1, 1, 0, 0, 0, 0]}\n", + " 0.000488\n", " 2.0\n", - " [0, 1, 1, 0, 1, 0, 1, 0, 1, 0]\n", - " 1\n", " \n", " \n", - " 220\n", - " 0.001\n", + " 325\n", + " {'x': [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]}\n", + " 0.000977\n", " 2.0\n", - " [1, 1, 0, 1, 1, 1, 0, 0, 0, 0]\n", - " 1\n", " \n", " \n", - " 156\n", - " 0.002\n", + " 436\n", + " {'x': [1, 1, 1, 0, 0, 0, 1, 0, 1, 0]}\n", + " 0.000977\n", " 2.0\n", - " [1, 1, 0, 0, 1, 1, 0, 0, 1, 0]\n", - " 2\n", " \n", " \n", "\n", "" ], "text/plain": [ - " probability cost solution count\n", - "0 0.058 1.0 [1, 1, 0, 0, 1, 0, 1, 0, 1, 0] 58\n", - "2 0.024 1.0 [1, 1, 0, 1, 1, 0, 0, 0, 1, 0] 24\n", - "272 0.001 2.0 [0, 1, 1, 0, 1, 0, 1, 0, 1, 0] 1\n", - "220 0.001 2.0 [1, 1, 0, 1, 1, 1, 0, 0, 0, 0] 1\n", - "156 0.002 2.0 [1, 1, 0, 0, 1, 1, 0, 0, 1, 0] 2" + " solution probability cost\n", + "289 {'x': [1, 1, 0, 0, 1, 0, 1, 0, 1, 0]} 0.000977 1.0\n", + "399 {'x': [1, 1, 0, 1, 1, 0, 0, 0, 1, 0]} 0.000977 1.0\n", + "665 {'x': [1, 1, 0, 1, 1, 1, 0, 0, 0, 0]} 0.000488 2.0\n", + "325 {'x': [1, 0, 1, 0, 1, 0, 1, 0, 1, 0]} 0.000977 2.0\n", + "436 {'x': [1, 1, 1, 0, 0, 0, 1, 0, 1, 0]} 0.000977 2.0" ] }, "execution_count": 13, @@ -569,54 +453,47 @@ } ], "source": [ - "import pandas as pd\n", - "\n", - "from classiq.applications.combinatorial_optimization import (\n", - " get_optimization_solution_from_pyo,\n", - ")\n", - "\n", - "solution = get_optimization_solution_from_pyo(\n", - " mvc_model, vqe_result=result, penalty_energy=qaoa_config.penalty_energy\n", - ")\n", - "optimization_result = pd.DataFrame.from_records(solution)\n", - "optimization_result.sort_values(by=\"cost\", ascending=True).head(5)" + "optimization_result = combi.sample(optimized_params)\n", + "optimization_result.sort_values(by=\"cost\").head(5)" ] }, { "cell_type": "markdown", - "id": "687f492b-a4a5-49c6-964c-8959b035bb93", + "id": "b97b9f81-4d6d-4f65-947f-a8465643f442", "metadata": {}, "source": [ - "And the histogram:" + "We will also want to compare the optimized results to uniformly sampled results:" ] }, { "cell_type": "code", "execution_count": 14, - "id": "31a4e74d-b2b8-42e0-826d-de7b51de1fe8", + "id": "98d47d34-e05b-43c7-8f3d-bd407fe81342", + "metadata": {}, + "outputs": [], + "source": [ + "uniform_result = combi.sample_uniform()" + ] + }, + { + "cell_type": "markdown", + "id": "655de6d1-0a33-4b2b-ab35-053684a4a6d0", + "metadata": {}, + "source": [ + "And compare the histograms:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "cb86cd46-9c67-4a2d-9acd-5bf90921e9db", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:21.095943Z", - "iopub.status.busy": "2024-05-07T15:49:21.095378Z", - "iopub.status.idle": "2024-05-07T15:49:21.326954Z", - "shell.execute_reply": "2024-05-07T15:49:21.326200Z" - }, "tags": [] }, "outputs": [ { "data": { - "text/plain": [ - "array([[]], dtype=object)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGzCAYAAAD9pBdvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAnnUlEQVR4nO3df1Rc9Z3/8dcAwyBGTCIKCUGJP2qCWaBCoeOPY3clsG2ObbTdQxvPhqXdeNbAMe3sqmG38mO1JdUU6Q9Wqt1UT9s0WdNV202aSFFobTAYYjYmmmjUBJsESLQwCTTDLHO/f/jNKAXCzATuB8jzcc6c5n7u59553zeDvHrvnRmHZVmWAAAADIkyXQAAADi/EUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAFPK9u3bVVVVpZ6eHtOlABgnhBEAU8r27dtVXV1NGAGmEcIIAAAwijACYFwcOXJEX/va1zR37ly5XC7Nnz9fd999twYGBiRJ77zzjv7u7/5Os2fPVnx8vD796U9r8+bNw/bzgx/8QNddd53i4+M1a9Ys5eTkaP369ZKkqqoq3XvvvZKk+fPny+FwyOFw6NChQ7YdJ4DxF2O6AABT39GjR5Wbm6uenh7dddddWrBggY4cOaJNmzapv79ff/rTn3TDDTeov79f99xzjy655BI99dRT+vznP69Nmzbp9ttvlyQ98cQTuueee/SlL31Jq1at0unTp7Vnzx7t2LFDy5Yt0x133KE333xTv/jFL/Too48qMTFRknTppZeaPHwA58hhWZZluggAU1txcbF+9rOfaceOHcrJyRmyzrIseTwe1dXV6fe//71uuukmSdKpU6eUkZEhy7L09ttvKyoqSkuXLtXBgwe1d+/eUZ9r7dq1uvfee/Xuu+8qLS1tIg8LgE24TAPgnAQCAT377LO67bbbhgURSXI4HNqyZYtyc3ODQUSSZsyYobvuukuHDh3S66+/LkmaOXOm/vjHP+qVV16xrX4A5hFGAJyT48ePy+v1atGiRaPOOXz4sK699tph4wsXLgyul6T7779fM2bMUG5urq655hqVlpbqD3/4w8QUDmDSIIwAmDQWLlyoAwcOaMOGDbrpppv0y1/+UjfddJMqKytNlwZgAhFGAJyTSy+9VAkJCWe9z+OKK67QgQMHho3v378/uP6MCy+8UEVFRfrJT36ijo4OLVmyRN/61rd0+vRpSR9e9gEwvRBGAJyTMzee/vrXv9bOnTuHrbcsS5/73OfU1tam1tbW4HhfX58ef/xxpaWlKT09XZL0/vvvD9k2NjZW6enpsixLfr9f0odhRRIfegZMI7ybBsA5O3LkiHJycuT1enXXXXdp4cKFOnbsmJ5++mm99NJL8vl8yszM1OnTp3XPPfdo9uzZeuqpp/S///u/+uUvfxl8a292draSk5N14403KikpSW+88YZ++MMfqqCgQL/61a8kSa+88opyc3P1uc99Tl/+8pfldDp12223BUMKgKmHMAJgXHR0dOiBBx7Qb37zG3m9XqWkpOizn/2samtrFRsbq3feeUf333+/fvvb3+r06dPKyMhQRUWFlixZEtzH448/rp///Ofat2+fTp06pXnz5umOO+7QN7/5TSUkJATnPfTQQ2poaNCxY8cUCAR4my8wxRFGAACAUdwzAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjYkwXEIpAIKCjR4/qoosu4qOgAQCYIizL0smTJzV37lxFRY1+/mNKhJGjR48qNTXVdBkAACAC7733nubNmzfq+ikRRi666CJJHx7Mxz+F8Wz8fr+ef/55FRQUyOl0TmR5EP22G/22F/22F/2210T22+v1KjU1Nfh3fDRTIoycuTSTkJAQVhiJj49XQkICL2Yb0G970W970W970W972dHvsW6x4AZWAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYFWO6ANPSVm82XULYDq1ZYroEAADGDWdGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAURGFkfr6eqWlpSkuLk55eXlqa2s76/yenh6VlpZqzpw5crlc+sQnPqEtW7ZEVDAAAJheYsLdYOPGjfJ4PGpoaFBeXp7q6upUWFioAwcO6LLLLhs2f2BgQIsXL9Zll12mTZs2KSUlRYcPH9bMmTPHo34AADDFhR1GamtrtWLFCpWUlEiSGhoatHnzZq1bt06rV68eNn/dunX64IMPtH37djmdTklSWlrauVUNAACmjbDCyMDAgNrb21VeXh4ci4qKUn5+vlpbW0fc5le/+pXcbrdKS0v13HPP6dJLL9WyZct0//33Kzo6esRtfD6ffD5fcNnr9UqS/H6//H5/SLWemTfWfFe0FdL+JpNQe2CnUPuN8UG/7UW/7UW/7TWR/Q51n2GFkRMnTmhwcFBJSUlDxpOSkrR///4Rt3nnnXf0wgsv6M4779SWLVt08OBBrVy5Un6/X5WVlSNuU1NTo+rq6mHjzz//vOLj48MpWY2NjWdd/3BuWLubFCbz/TZj9Rvji37bi37bi37bayL63d/fH9K8sC/ThCsQCOiyyy7T448/rujoaGVnZ+vIkSN65JFHRg0j5eXl8ng8wWWv16vU1FQVFBQoISEhpOf1+/1qbGzU4sWLg5eHRrKoalt4BzQJ7K0qNF3CMKH2G+ODftuLftuLfttrIvt95srGWMIKI4mJiYqOjlZXV9eQ8a6uLiUnJ4+4zZw5c+R0Oodcklm4cKE6Ozs1MDCg2NjYYdu4XC65XK5h406nM+xGjbWNb9AR1v4mg8n8yxnJzwiRo9/2ot/2ot/2moh+h7q/sN7aGxsbq+zsbDU1NQXHAoGAmpqa5Ha7R9zmxhtv1MGDBxUIBIJjb775pubMmTNiEAEAAOeXsD9nxOPx6IknntBTTz2lN954Q3fffbf6+vqC765Zvnz5kBtc7777bn3wwQdatWqV3nzzTW3evFnf/va3VVpaOn5HAQAApqyw7xkpKirS8ePHVVFRoc7OTmVlZWnr1q3Bm1o7OjoUFfVRxklNTdW2bdv0jW98QxkZGUpJSdGqVat0//33j99RAACAKSuiG1jLyspUVlY24rrm5uZhY263Wy+//HIkTwUAAKY5vpsGAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGBVRGKmvr1daWpri4uKUl5entra2Uec++eSTcjgcQx5xcXERFwwAAKaXsMPIxo0b5fF4VFlZqV27dikzM1OFhYXq7u4edZuEhAQdO3Ys+Dh8+PA5FQ0AAKaPsMNIbW2tVqxYoZKSEqWnp6uhoUHx8fFat27dqNs4HA4lJycHH0lJSedUNAAAmD5iwpk8MDCg9vZ2lZeXB8eioqKUn5+v1tbWUbc7deqUrrjiCgUCAV1//fX69re/reuuu27U+T6fTz6fL7js9XolSX6/X36/P6Raz8wba74r2gppf5NJqD2wU6j9xvig3/ai3/ai3/aayH6Huk+HZVkh/zU+evSoUlJStH37drnd7uD4fffdp5aWFu3YsWPYNq2trXrrrbeUkZGh3t5erV27Vr/73e+0b98+zZs3b8TnqaqqUnV19bDx9evXKz4+PtRyAQCAQf39/Vq2bJl6e3uVkJAw6rywzoxEwu12DwkuN9xwgxYuXKgf/ehHevDBB0fcpry8XB6PJ7js9XqVmpqqgoKCsx7Mx/n9fjU2Nmrx4sVyOp2jzltUtS3EI5k89lYVmi5hmFD7jfFBv+1Fv+1Fv+01kf0+c2VjLGGFkcTEREVHR6urq2vIeFdXl5KTk0Pah9Pp1Cc/+UkdPHhw1Dkul0sul2vEbcNt1Fjb+AYdYe1vMpjMv5yR/IwQOfptL/ptL/ptr4nod6j7C+sG1tjYWGVnZ6upqSk4FggE1NTUNOTsx9kMDg7qtdde05w5c8J5agAAME2FfZnG4/GouLhYOTk5ys3NVV1dnfr6+lRSUiJJWr58uVJSUlRTUyNJ+vd//3d9+tOf1tVXX62enh498sgjOnz4sP7xH/9xfI8EAABMSWGHkaKiIh0/flwVFRXq7OxUVlaWtm7dGny7bkdHh6KiPjrh8qc//UkrVqxQZ2enZs2apezsbG3fvl3p6enjdxQAAGDKiugG1rKyMpWVlY24rrm5ecjyo48+qkcffTSSpwEAAOcBvpsGAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGBVRGKmvr1daWpri4uKUl5entra2kLbbsGGDHA6Hli5dGsnTAgCAaSjsMLJx40Z5PB5VVlZq165dyszMVGFhobq7u8+63aFDh/Qv//IvuvnmmyMuFgAATD8x4W5QW1urFStWqKSkRJLU0NCgzZs3a926dVq9evWI2wwODurOO+9UdXW1fv/736unp+esz+Hz+eTz+YLLXq9XkuT3++X3+0Oq88y8sea7oq2Q9jeZhNoDO4Xab4wP+m0v+m0v+m2viex3qPt0WJYV8l/jgYEBxcfHa9OmTUMutRQXF6unp0fPPffciNtVVlZqz549euaZZ/QP//AP6unp0bPPPjvq81RVVam6unrY+Pr16xUfHx9quQAAwKD+/n4tW7ZMvb29SkhIGHVeWGdGTpw4ocHBQSUlJQ0ZT0pK0v79+0fc5qWXXtJ//ud/avfu3SE/T3l5uTweT3DZ6/UqNTVVBQUFZz2Yj/P7/WpsbNTixYvldDpHnbeoalvIdU0We6sKTZcwTKj9xvig3/ai3/ai3/aayH6fubIxlrAv04Tj5MmT+vu//3s98cQTSkxMDHk7l8sll8s1bNzpdIbdqLG28Q06wtrfZDCZfzkj+RkhcvTbXvTbXvTbXhPR71D3F1YYSUxMVHR0tLq6uoaMd3V1KTk5edj8t99+W4cOHdJtt90WHAsEAh8+cUyMDhw4oKuuuiqcEgAAwDQT1rtpYmNjlZ2draampuBYIBBQU1OT3G73sPkLFizQa6+9pt27dwcfn//85/XXf/3X2r17t1JTU8/9CAAAwJQW9mUaj8ej4uJi5eTkKDc3V3V1derr6wu+u2b58uVKSUlRTU2N4uLitGjRoiHbz5w5U5KGjQMAgPNT2GGkqKhIx48fV0VFhTo7O5WVlaWtW7cGb2rt6OhQVBQf7AoAAEIT0Q2sZWVlKisrG3Fdc3PzWbd98sknI3lKAAAwTXEKAwAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGBURGGkvr5eaWlpiouLU15entra2kad+9///d/KycnRzJkzdeGFFyorK0s//elPIy4YAABML2GHkY0bN8rj8aiyslK7du1SZmamCgsL1d3dPeL82bNn69/+7d/U2tqqPXv2qKSkRCUlJdq2bds5Fw8AAKa+sMNIbW2tVqxYoZKSEqWnp6uhoUHx8fFat27diPM/85nP6Pbbb9fChQt11VVXadWqVcrIyNBLL710zsUDAICpLyacyQMDA2pvb1d5eXlwLCoqSvn5+WptbR1ze8uy9MILL+jAgQP6zne+M+o8n88nn88XXPZ6vZIkv98vv98fUq1n5o013xVthbS/ySTUHtgp1H5jfNBve9Fve9Fve01kv0Pdp8OyrJD/Gh89elQpKSnavn273G53cPy+++5TS0uLduzYMeJ2vb29SklJkc/nU3R0tP7jP/5DX/3qV0d9nqqqKlVXVw8bX79+veLj40MtFwAAGNTf369ly5apt7dXCQkJo84L68xIpC666CLt3r1bp06dUlNTkzwej6688kp95jOfGXF+eXm5PB5PcNnr9So1NVUFBQVnPZiP8/v9amxs1OLFi+V0Okedt6hq6t27sreq0HQJw4Tab4wP+m0v+m0v+m2viez3mSsbYwkrjCQmJio6OlpdXV1Dxru6upScnDzqdlFRUbr66qslSVlZWXrjjTdUU1MzahhxuVxyuVzDxp1OZ9iNGmsb36AjrP1NBpP5lzOSnxEiR7/tRb/tRb/tNRH9DnV/Yd3AGhsbq+zsbDU1NQXHAoGAmpqahly2GUsgEBhyTwgAADh/hX2ZxuPxqLi4WDk5OcrNzVVdXZ36+vpUUlIiSVq+fLlSUlJUU1MjSaqpqVFOTo6uuuoq+Xw+bdmyRT/96U/12GOPje+RAACAKSnsMFJUVKTjx4+roqJCnZ2dysrK0tatW5WUlCRJ6ujoUFTURydc+vr6tHLlSv3xj3/UBRdcoAULFuhnP/uZioqKxu8oAADAlBXRDaxlZWUqKysbcV1zc/OQ5YceekgPPfRQJE8DAADOA3w3DQAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADAqojBSX1+vtLQ0xcXFKS8vT21tbaPOfeKJJ3TzzTdr1qxZmjVrlvLz8886HwAAnF/CDiMbN26Ux+NRZWWldu3apczMTBUWFqq7u3vE+c3NzfrKV76iF198Ua2trUpNTVVBQYGOHDlyzsUDAICpL+wwUltbqxUrVqikpETp6elqaGhQfHy81q1bN+L8n//851q5cqWysrK0YMEC/fjHP1YgEFBTU9M5Fw8AAKa+mHAmDwwMqL29XeXl5cGxqKgo5efnq7W1NaR99Pf3y+/3a/bs2aPO8fl88vl8wWWv1ytJ8vv98vv9IT3PmXljzXdFWyHtbzIJtQd2CrXfGB/021702170214T2e9Q9+mwLCvkv8ZHjx5VSkqKtm/fLrfbHRy/77771NLSoh07doy5j5UrV2rbtm3at2+f4uLiRpxTVVWl6urqYePr169XfHx8qOUCAACD+vv7tWzZMvX29iohIWHUeWGdGTlXa9as0YYNG9Tc3DxqEJGk8vJyeTye4LLX6w3ea3K2g/k4v9+vxsZGLV68WE6nc9R5i6q2hX4Ak8TeqkLTJQwTar8xPui3vei3vei3vSay32eubIwlrDCSmJio6OhodXV1DRnv6upScnLyWbddu3at1qxZo9/+9rfKyMg461yXyyWXyzVs3Ol0ht2osbbxDTrC2t9kMJl/OSP5GSFy9Nte9Nte9NteE9HvUPcX1g2ssbGxys7OHnLz6ZmbUT9+2eYvPfzww3rwwQe1detW5eTkhPOUAABgmgv7Mo3H41FxcbFycnKUm5ururo69fX1qaSkRJK0fPlypaSkqKamRpL0ne98RxUVFVq/fr3S0tLU2dkpSZoxY4ZmzJgxjocCAACmorDDSFFRkY4fP66Kigp1dnYqKytLW7duVVJSkiSpo6NDUVEfnXB57LHHNDAwoC996UtD9lNZWamqqqpzqx4AAEx5Ed3AWlZWprKyshHXNTc3D1k+dOhQJE8BAADOE3w3DQAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMi+m4amJW2erPpEoZxRVt6OFdaVLVNvkHHsPWH1iwxUBUAYCrgzAgAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwijACAACMIowAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKMIIwAAwCjCCAAAMIowAgAAjCKMAAAAowgjAADAKMIIAAAwKqIwUl9fr7S0NMXFxSkvL09tbW2jzt23b5+++MUvKi0tTQ6HQ3V1dZHWCgAApqGww8jGjRvl8XhUWVmpXbt2KTMzU4WFheru7h5xfn9/v6688kqtWbNGycnJ51wwAACYXsIOI7W1tVqxYoVKSkqUnp6uhoYGxcfHa926dSPO/9SnPqVHHnlEX/7yl+Vyuc65YAAAML3EhDN5YGBA7e3tKi8vD45FRUUpPz9fra2t41aUz+eTz+cLLnu9XkmS3++X3+8PaR9n5o013xVtRVglPs4VZQ35378U6s8NoQn19Y3xQb/tRb/tNZH9DnWfYYWREydOaHBwUElJSUPGk5KStH///nB2dVY1NTWqrq4eNv78888rPj4+rH01Njaedf3DuWHtDmN4MCcw4viWLVtsruT8MNbrG+OLftuLfttrIvrd398f0rywwohdysvL5fF4gster1epqakqKChQQkJCSPvw+/1qbGzU4sWL5XQ6R523qGrbOdeLD8+IPJgT0AM7o+QLOIat31tVaKCq6SvU1zfGB/22F/2210T2+8yVjbGEFUYSExMVHR2trq6uIeNdXV3jenOqy+Ua8f4Sp9MZdqPG2sY3OPwPJyLnCzhG7Cn/QZkYkfxOIHL02170214T0e9Q9xfWDayxsbHKzs5WU1NTcCwQCKipqUlutzu8CgEAABTBZRqPx6Pi4mLl5OQoNzdXdXV16uvrU0lJiSRp+fLlSklJUU1NjaQPb3p9/fXXg/8+cuSIdu/erRkzZujqq68ex0MBAABTUdhhpKioSMePH1dFRYU6OzuVlZWlrVu3Bm9q7ejoUFTURydcjh49qk9+8pPB5bVr12rt2rW65ZZb1NzcfO5HAAAAprSIbmAtKytTWVnZiOv+MmCkpaXJsnj7LAAAGBnfTQMAAIyalG/txfSTtnqz6RIicmjNEtMlAMC0x5kRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFExpgsAJrO01ZtNlzAiV7Slh3OlRVXb5Bt0DFl3aM0SQ1UBQGQ4MwIAAIwijAAAAKO4TAPAuMl6OeyMkS6LcTkMGD+cGQEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABGEUYAAIBRhBEAAGAUYQQAABhFGAEAAEYRRgAAgFExpgsAAGA6SVu92XQJYXFFW3o412wNhBEAiMBU+4MjSYfWLDFdAjAiLtMAAACjCCMAAMCoiMJIfX290tLSFBcXp7y8PLW1tZ11/tNPP60FCxYoLi5Of/VXf6UtW7ZEVCwAAJh+wg4jGzdulMfjUWVlpXbt2qXMzEwVFhaqu7t7xPnbt2/XV77yFX3ta1/Tq6++qqVLl2rp0qXau3fvORcPAACmvrDDSG1trVasWKGSkhKlp6eroaFB8fHxWrdu3Yjzv/e97+lv//Zvde+992rhwoV68MEHdf311+uHP/zhORcPAACmvrDeTTMwMKD29naVl5cHx6KiopSfn6/W1tYRt2ltbZXH4xkyVlhYqGeffXbU5/H5fPL5fMHl3t5eSdIHH3wgv98fUq1+v1/9/f16//335XQ6R50X8399Ie0PZxcTsNTfH1CMP0qDAYfpcqa9s/X7/fffN1RV5Cb77+F0eX1PlddGqP/9nqwm++v5L515fU9Ev0+ePClJsizr7DWEs9MTJ05ocHBQSUlJQ8aTkpK0f//+Ebfp7OwccX5nZ+eoz1NTU6Pq6uph4/Pnzw+nXNhsmekCzjOj9Tvxu7aWcd6YDq9vXhsYzUS/vk+ePKmLL7541PWT8nNGysvLh5xNCQQC+uCDD3TJJZfI4Qjt/5V4vV6lpqbqvffeU0JCwkSViv+PftuLftuLftuLfttrIvttWZZOnjypuXPnnnVeWGEkMTFR0dHR6urqGjLe1dWl5OTkEbdJTk4Oa74kuVwuuVyuIWMzZ84Mp9SghIQEXsw2ot/2ot/2ot/2ot/2mqh+n+2MyBlh3cAaGxur7OxsNTU1BccCgYCamprkdrtH3Mbtdg+ZL0mNjY2jzgcAAOeXsC/TeDweFRcXKycnR7m5uaqrq1NfX59KSkokScuXL1dKSopqamokSatWrdItt9yi7373u1qyZIk2bNignTt36vHHHx/fIwEAAFNS2GGkqKhIx48fV0VFhTo7O5WVlaWtW7cGb1Lt6OhQVNRHJ1xuuOEGrV+/Xt/85jf1r//6r7rmmmv07LPPatGiReN3FCNwuVyqrKwcdrkHE4N+24t+24t+24t+22sy9NthjfV+GwAAgAnEd9MAAACjCCMAAMAowggAADCKMAIAAIwijAAAAKOmbRipr69XWlqa4uLilJeXp7a2NtMlTQu/+93vdNttt2nu3LlyOBzDvvDQsixVVFRozpw5uuCCC5Sfn6+33nrLTLFTXE1NjT71qU/poosu0mWXXaalS5fqwIEDQ+acPn1apaWluuSSSzRjxgx98YtfHPaJxwjNY489poyMjOCnULrdbv3mN78JrqfXE2vNmjVyOBz6+te/Hhyj5+OnqqpKDodjyGPBggXB9aZ7PS3DyMaNG+XxeFRZWaldu3YpMzNThYWF6u7uNl3alNfX16fMzEzV19ePuP7hhx/W97//fTU0NGjHjh268MILVVhYqNOnT9tc6dTX0tKi0tJSvfzyy2psbJTf71dBQYH6+j76RtBvfOMb+vWvf62nn35aLS0tOnr0qO644w6DVU9d8+bN05o1a9Te3q6dO3fqb/7mb/SFL3xB+/btk0SvJ9Irr7yiH/3oR8rIyBgyTs/H13XXXadjx44FHy+99FJwnfFeW9NQbm6uVVpaGlweHBy05s6da9XU1BisavqRZD3zzDPB5UAgYCUnJ1uPPPJIcKynp8dyuVzWL37xCwMVTi/d3d2WJKulpcWyrA9763Q6raeffjo454033rAkWa2trabKnFZmzZpl/fjHP6bXE+jkyZPWNddcYzU2Nlq33HKLtWrVKsuyeH2Pt8rKSiszM3PEdZOh19PuzMjAwIDa29uVn58fHIuKilJ+fr5aW1sNVjb9vfvuu+rs7BzS+4svvlh5eXn0fhz09vZKkmbPni1Jam9vl9/vH9LvBQsW6PLLL6ff52hwcFAbNmxQX1+f3G43vZ5ApaWlWrJkyZDeSry+J8Jbb72luXPn6sorr9Sdd96pjo4OSZOj12F/HPxkd+LECQ0ODgY/nv6MpKQk7d+/31BV54fOzk5JGrH3Z9YhMoFAQF//+td14403Br9KobOzU7GxscO+0Zp+R+61116T2+3W6dOnNWPGDD3zzDNKT0/X7t276fUE2LBhg3bt2qVXXnll2Dpe3+MrLy9PTz75pK699lodO3ZM1dXVuvnmm7V3795J0etpF0aA6ai0tFR79+4dco0X4+/aa6/V7t271dvbq02bNqm4uFgtLS2my5qW3nvvPa1atUqNjY2Ki4szXc6099nPfjb474yMDOXl5emKK67Qf/3Xf+mCCy4wWNmHpt1lmsTEREVHRw+7C7irq0vJycmGqjo/nOkvvR9fZWVl+p//+R+9+OKLmjdvXnA8OTlZAwMD6unpGTKffkcuNjZWV199tbKzs1VTU6PMzEx973vfo9cToL29Xd3d3br++usVExOjmJgYtbS06Pvf/75iYmKUlJREzyfQzJkz9YlPfEIHDx6cFK/vaRdGYmNjlZ2draampuBYIBBQU1OT3G63wcqmv/nz5ys5OXlI771er3bs2EHvI2BZlsrKyvTMM8/ohRde0Pz584esz87OltPpHNLvAwcOqKOjg36Pk0AgIJ/PR68nwK233qrXXntNu3fvDj5ycnJ05513Bv9NzyfOqVOn9Pbbb2vOnDmT4/Vty22yNtuwYYPlcrmsJ5980nr99detu+66y5o5c6bV2dlpurQp7+TJk9arr75qvfrqq5Ykq7a21nr11Vetw4cPW5ZlWWvWrLFmzpxpPffcc9aePXusL3zhC9b8+fOtP//5z4Yrn3ruvvtu6+KLL7aam5utY8eOBR/9/f3BOf/0T/9kXX755dYLL7xg7dy503K73Zbb7TZY9dS1evVqq6WlxXr33XetPXv2WKtXr7YcDof1/PPPW5ZFr+3w8XfTWBY9H0///M//bDU3N1vvvvuu9Yc//MHKz8+3EhMTre7ubsuyzPd6WoYRy7KsH/zgB9bll19uxcbGWrm5udbLL79suqRp4cUXX7QkDXsUFxdblvXh23sfeOABKykpyXK5XNatt95qHThwwGzRU9RIfZZk/eQnPwnO+fOf/2ytXLnSmjVrlhUfH2/dfvvt1rFjx8wVPYV99atfta644gorNjbWuvTSS61bb701GEQsi17b4S/DCD0fP0VFRdacOXOs2NhYKyUlxSoqKrIOHjwYXG+61w7Lsix7zsEAAAAMN+3uGQEAAFMLYQQAABhFGAEAAEYRRgAAgFGEEQAAYBRhBAAAGEUYAQAARhFGAACAUYQRAABgFGEEAAAYRRgBAABG/T/FCmH5W+4hYQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -626,7 +503,26 @@ } ], "source": [ - "optimization_result.hist(\"cost\", weights=optimization_result[\"probability\"])" + "optimization_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=40,\n", + " edgecolor=\"black\",\n", + " weights=optimization_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"optimized\",\n", + ")\n", + "uniform_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=40,\n", + " edgecolor=\"black\",\n", + " weights=uniform_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"uniform\",\n", + ")\n", + "plt.legend()\n", + "plt.ylabel(\"Probability\", fontsize=16)\n", + "plt.xlabel(\"cost\", fontsize=16)\n", + "plt.tick_params(axis=\"both\", labelsize=14)" ] }, { @@ -639,34 +535,11 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "id": "4326e84b-26f6-4ea9-a53b-090fb3658b8c", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:21.329517Z", - "iopub.status.busy": "2024-05-07T15:49:21.329322Z", - "iopub.status.idle": "2024-05-07T15:49:21.332804Z", - "shell.execute_reply": "2024-05-07T15:49:21.332219Z" - }, "tags": [] }, - "outputs": [], - "source": [ - "best_solution = optimization_result.solution[optimization_result.cost.idxmin()]" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "2449caf6-d3c2-49b1-81cd-0e33e248cc18", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:21.335350Z", - "iopub.status.busy": "2024-05-07T15:49:21.334887Z", - "iopub.status.idle": "2024-05-07T15:49:21.339246Z", - "shell.execute_reply": "2024-05-07T15:49:21.338598Z" - } - }, "outputs": [ { "data": { @@ -680,6 +553,7 @@ } ], "source": [ + "best_solution = optimization_result.solution[optimization_result.cost.idxmin()][\"x\"]\n", "best_solution" ] }, @@ -687,18 +561,11 @@ "cell_type": "code", "execution_count": 17, "id": "fed415f4-67ed-4a85-9138-553c75972ac8", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:21.341589Z", - "iopub.status.busy": "2024-05-07T15:49:21.341144Z", - "iopub.status.idle": "2024-05-07T15:49:21.493854Z", - "shell.execute_reply": "2024-05-07T15:49:21.493175Z" - } - }, + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -747,12 +614,6 @@ "execution_count": 18, "id": "5a7ca4b6-25a0-46dd-b5cc-de6a639a6f57", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:21.496514Z", - "iopub.status.busy": "2024-05-07T15:49:21.496111Z", - "iopub.status.idle": "2024-05-07T15:49:21.561467Z", - "shell.execute_reply": "2024-05-07T15:49:21.560785Z" - }, "pycharm": { "name": "#%%\n" }, @@ -771,14 +632,7 @@ "cell_type": "code", "execution_count": 19, "id": "1894641b-b166-47da-a3b8-5851d9042054", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:21.564260Z", - "iopub.status.busy": "2024-05-07T15:49:21.563927Z", - "iopub.status.idle": "2024-05-07T15:49:21.568416Z", - "shell.execute_reply": "2024-05-07T15:49:21.567758Z" - } - }, + "metadata": {}, "outputs": [ { "data": { @@ -800,18 +654,12 @@ "execution_count": 20, "id": "a7524894-b5c5-42d4-8f92-a019bef5e7da", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:49:21.570739Z", - "iopub.status.busy": "2024-05-07T15:49:21.570457Z", - "iopub.status.idle": "2024-05-07T15:49:21.725756Z", - "shell.execute_reply": "2024-05-07T15:49:21.724890Z" - }, "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -861,7 +709,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.4" }, "vscode": { "interpreter": { diff --git a/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.qmod b/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.qmod index e66df54a8..98196497f 100644 --- a/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.qmod +++ b/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.qmod @@ -1,863 +1,14 @@ -hamiltonian: PauliTerm[] = [ - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=10.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.5 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=0.75 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=0.75 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=0.75 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=0.75 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=0.75 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=1.25 - } -]; - -qfunc main(params_list: real[6], output target: qbit[10]) { - allocate(target.len, target); - qaoa_penalty(target.len, params_list, hamiltonian, target); +qstruct QAOAVars { + x: qbit[10]; } -cscope ``` -vqe_result = vqe( -hamiltonian=hamiltonian, -maximize=False, -initial_point=[0.0, 0.4, 0.2, 0.2, 0.4, 0.0], -optimizer=Optimizer.COBYLA, -max_iteration=60, -tolerance=0.0, -step_size=0.0, -skip_compute_variance=False, -alpha_cvar=0.7 -) - -save({"vqe_result": vqe_result, "hamiltonian": hamiltonian}) -``` +qfunc main(params: real[6], output v: QAOAVars) { + allocate(v.size, v); + hadamard_transform(v); + repeat (i: 3) { + phase (-(((((((((((((((((((((((1 - v.x[0]) * (1 - v.x[1])) + ((1 - v.x[0]) * (1 - v.x[5]))) + ((1 - v.x[0]) * (1 - v.x[6]))) + ((1 - v.x[0]) * (1 - v.x[7]))) + ((1 - v.x[0]) * (1 - v.x[8]))) + ((1 - v.x[1]) * (1 - v.x[2]))) + ((1 - v.x[1]) * (1 - v.x[4]))) + ((1 - v.x[1]) * (1 - v.x[5]))) + ((1 - v.x[1]) * (1 - v.x[6]))) + ((1 - v.x[1]) * (1 - v.x[9]))) + ((1 - v.x[2]) * (1 - v.x[3]))) + ((1 - v.x[2]) * (1 - v.x[4]))) + ((1 - v.x[3]) * (1 - v.x[6]))) + ((1 - v.x[3]) * (1 - v.x[8]))) + ((1 - v.x[4]) * (1 - v.x[6]))) + ((1 - v.x[4]) * (1 - v.x[7]))) + ((1 - v.x[4]) * (1 - v.x[8]))) + ((1 - v.x[4]) * (1 - v.x[9]))) + ((1 - v.x[5]) * (1 - v.x[6]))) + ((1 - v.x[7]) * (1 - v.x[8]))) + ((1 - v.x[8]) * (1 - v.x[9]))) + (20 * (((((((((((v.x[0] + v.x[1]) + v.x[2]) + v.x[3]) + v.x[4]) + v.x[5]) + v.x[6]) + v.x[7]) + v.x[8]) + v.x[9]) - 5) ** 2))), params[i]); + apply_to_all(lambda(q) { + RX(params[3 + i], q); + }, v); + } +} diff --git a/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.synthesis_options.json b/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.synthesis_options.json index 0967ef424..ba1113e93 100644 --- a/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.synthesis_options.json +++ b/applications/optimization/max_k_vertex_cover/max_k_vertex_cover.synthesis_options.json @@ -1 +1,43 @@ -{} +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "rz", + "cx", + "h", + "u1", + "r", + "sx", + "s", + "rx", + "y", + "cy", + "tdg", + "ry", + "u2", + "u", + "x", + "cz", + "z", + "sxdg", + "sdg", + "t", + "p", + "id" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": -1 + } +} diff --git a/applications/optimization/set_partition/set_partition.ipynb b/applications/optimization/set_partition/set_partition.ipynb index 2e21044d2..a08237c9a 100644 --- a/applications/optimization/set_partition/set_partition.ipynb +++ b/applications/optimization/set_partition/set_partition.ipynb @@ -34,12 +34,6 @@ "execution_count": 1, "id": "49a9588b-e79e-4813-b7c5-ac068d7b930c", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:41.367157Z", - "iopub.status.busy": "2024-05-07T16:03:41.366691Z", - "iopub.status.idle": "2024-05-07T16:03:42.091526Z", - "shell.execute_reply": "2024-05-07T16:03:42.090734Z" - }, "tags": [] }, "outputs": [], @@ -47,7 +41,6 @@ "import networkx as nx\n", "import numpy as np\n", "import pyomo.core as pyo\n", - "from IPython.display import Markdown, display\n", "from matplotlib import pyplot as plt" ] }, @@ -58,7 +51,7 @@ "source": [ "## Building the Pyomo model from a graph input\n", "\n", - "We proceed by defining the pyomo model that will be used on the Classiq platform, using the mathematical formulation defined above:" + "We proceed by defining the Pyomo model that will be used on the Classiq platform, using the mathematical formulation defined above:" ] }, { @@ -66,12 +59,6 @@ "execution_count": 2, "id": "48889b21-557b-481c-80c5-3c0b5c91adb6", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:42.097597Z", - "iopub.status.busy": "2024-05-07T16:03:42.095951Z", - "iopub.status.idle": "2024-05-07T16:03:42.103326Z", - "shell.execute_reply": "2024-05-07T16:03:42.102649Z" - }, "tags": [] }, "outputs": [], @@ -98,12 +85,6 @@ "execution_count": 3, "id": "69359e3e-ed85-4b56-9afb-9dd4b9997ada", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:42.107922Z", - "iopub.status.busy": "2024-05-07T16:03:42.106745Z", - "iopub.status.idle": "2024-05-07T16:03:42.115540Z", - "shell.execute_reply": "2024-05-07T16:03:42.114863Z" - }, "tags": [] }, "outputs": [ @@ -111,7 +92,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "This is my list: [4, 8, 11, 7, 1, 8, 8, 5, 7, 11]\n" + "This is my list: [8, 8, 8, 5, 5, 6, 5, 6, 8, 11]\n" ] } ], @@ -127,12 +108,7 @@ "execution_count": 4, "id": "4a985b32-0670-42f3-ba50-5c0097eb75f5", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:42.121294Z", - "iopub.status.busy": "2024-05-07T16:03:42.120080Z", - "iopub.status.idle": "2024-05-07T16:03:42.128345Z", - "shell.execute_reply": "2024-05-07T16:03:42.127656Z" - }, + "scrolled": true, "tags": [] }, "outputs": [ @@ -162,7 +138,7 @@ "1 Objective Declarations\n", " cost : Size=1, Index=None, Active=True\n", " Key : Active : Sense : Expression\n", - " None : True : minimize : ((2*x[0] - 1)*4 + (2*x[1] - 1)*8 + (2*x[2] - 1)*11 + (2*x[3] - 1)*7 + 2*x[4] - 1 + (2*x[5] - 1)*8 + (2*x[6] - 1)*8 + (2*x[7] - 1)*5 + (2*x[8] - 1)*7 + (2*x[9] - 1)*11)**2\n", + " None : True : minimize : ((2*x[0] - 1)*8 + (2*x[1] - 1)*8 + (2*x[2] - 1)*8 + (2*x[3] - 1)*5 + (2*x[4] - 1)*5 + (2*x[5] - 1)*6 + (2*x[6] - 1)*5 + (2*x[7] - 1)*6 + (2*x[8] - 1)*8 + (2*x[9] - 1)*11)**2\n", "\n", "3 Declarations: x_index x cost\n" ] @@ -174,102 +150,83 @@ }, { "cell_type": "markdown", - "id": "17ea14ec-dbb7-487c-b4f1-cabc8d5e3c29", + "id": "0b790906-3951-49e9-b8f7-3e692255563b", "metadata": { "tags": [] }, "source": [ "## Setting Up the Classiq Problem Instance\n", "\n", - "In order to solve the Pyomo model defined above, we use the Classiq combinatorial optimization engine. For the quantum part of the QAOA algorithm (`QAOAConfig`) - define the number of repetitions (`num_layers`):" + "In order to solve the Pyomo model defined above, we use the `CombinatorialProblem` python class. Under the hood it tranlates the Pyomo model to a quantum model of the QAOA algorithm, with cost hamiltonian translated from the Pyomo model. We can choose the number of layers for the QAOA ansatz using the argument `num_layers`, and the `penalty_factor`, which will be the coefficient of the constraints term in the cost hamiltonian." ] }, { "cell_type": "code", "execution_count": 5, - "id": "816b468f-a59f-4f2f-8337-4a9d66548425", + "id": "2c26a32e-1035-482c-a5f4-d8dcb428b0a8", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:42.132929Z", - "iopub.status.busy": "2024-05-07T16:03:42.131750Z", - "iopub.status.idle": "2024-05-07T16:03:44.605811Z", - "shell.execute_reply": "2024-05-07T16:03:44.605152Z" - }, "tags": [] }, "outputs": [], "source": [ "from classiq import *\n", - "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", + "from classiq.applications.combinatorial_optimization import CombinatorialProblem\n", "\n", - "qaoa_config = QAOAConfig(num_layers=3)" - ] - }, - { - "cell_type": "markdown", - "id": "db34d5ac-6877-4285-8dec-7bf7b37eb783", - "metadata": {}, - "source": [ - "For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`max_iteration`) and the $\\alpha$-parameter (`alpha_cvar`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" + "combi = CombinatorialProblem(\n", + " pyo_model=set_partition_model, num_layers=3, penalty_factor=10\n", + ")\n", + "\n", + "qmod = combi.get_model()" ] }, { "cell_type": "code", "execution_count": 6, - "id": "e41d0dd3-4135-4330-9ba3-c1b30c339a74", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:44.608883Z", - "iopub.status.busy": "2024-05-07T16:03:44.608215Z", - "iopub.status.idle": "2024-05-07T16:03:44.611547Z", - "shell.execute_reply": "2024-05-07T16:03:44.610977Z" - }, - "pycharm": { - "name": "#%%\n" - }, - "tags": [] - }, + "id": "4192e734-85ed-47f3-a8a3-b463f0dadcea", + "metadata": {}, "outputs": [], "source": [ - "optimizer_config = OptimizerConfig(max_iteration=60, alpha_cvar=0.7)" + "write_qmod(qmod, \"set_partition\")" ] }, { "cell_type": "markdown", - "id": "214d6051-43b8-4b9d-8454-f9cdb62b4cf0", + "id": "a5c8e5a9-8fe8-4ca8-a31c-89c9e9b75fc2", "metadata": {}, "source": [ - "Lastly, we load the model, based on the problem and algorithm parameters, which we can use to solve the problem:" + "## Synthesizing the QAOA Circuit and Solving the Problem\n", + "\n", + "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" ] }, { "cell_type": "code", "execution_count": 7, - "id": "0243019c-6fc3-435f-b6ec-8b4355d6660c", + "id": "d6bcc87b-7504-41ee-8412-c1161256d0ba", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:44.613782Z", - "iopub.status.busy": "2024-05-07T16:03:44.613487Z", - "iopub.status.idle": "2024-05-07T16:03:44.714090Z", - "shell.execute_reply": "2024-05-07T16:03:44.713444Z" - }, "pycharm": { "name": "#%%\n" }, + "scrolled": true, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://nightly.platform.classiq.io/circuit/aec5c205-9edc-4e25-9812-ce23575c5542?version=0.62.0.dev9\n" + ] + } + ], "source": [ - "qmod = construct_combinatorial_optimization_model(\n", - " pyo_model=set_partition_model,\n", - " qaoa_config=qaoa_config,\n", - " optimizer_config=optimizer_config,\n", - ")" + "qprog = combi.get_qprog()\n", + "show(qprog)" ] }, { "cell_type": "markdown", - "id": "1fcc3812-c9d0-421c-84bb-38047297b33f", + "id": "34c6ac30-97f4-4cc1-9eb3-c32a79b23c66", "metadata": {}, "source": [ "We also set the quantum backend we want to execute on:" @@ -278,111 +235,48 @@ { "cell_type": "code", "execution_count": 8, - "id": "53bc041f-065c-44d2-b220-dafd9d0504ac", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:44.717234Z", - "iopub.status.busy": "2024-05-07T16:03:44.716619Z", - "iopub.status.idle": "2024-05-07T16:03:44.733981Z", - "shell.execute_reply": "2024-05-07T16:03:44.733405Z" - }, - "tags": [] - }, + "id": "2b2c8aea-0228-41a6-88c7-bddea1e29eba", + "metadata": {}, "outputs": [], "source": [ - "from classiq.execution import ClassiqBackendPreferences\n", + "from classiq.execution import *\n", "\n", - "qmod = set_execution_preferences(\n", - " qmod, backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", + "execution_preferences = ExecutionPreferences(\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\"),\n", ")" ] }, - { - "cell_type": "code", - "execution_count": 9, - "id": "7738571f-3a9f-498f-9a15-9c874f3c3dfd", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:44.736412Z", - "iopub.status.busy": "2024-05-07T16:03:44.735967Z", - "iopub.status.idle": "2024-05-07T16:03:44.761670Z", - "shell.execute_reply": "2024-05-07T16:03:44.761038Z" - } - }, - "outputs": [], - "source": [ - "write_qmod(qmod, \"set_partition\")" - ] - }, { "cell_type": "markdown", - "id": "943291f0-6a9f-4286-a69d-ef13a0a12ef6", + "id": "edbf9187-9329-487d-abed-1a3640aa25ad", "metadata": {}, "source": [ - "## Synthesizing the QAOA Circuit and Solving the Problem\n", - "\n", - "We can now synthesize and view the QAOA circuit (ansatz) used to solve the optimization problem:" + "We now solve the problem by calling the `optimize` method of the `CombinatorialProblem` object. For the classical optimization part of the QAOA algorithm we define the maximum number of classical iterations (`maxiter`) and the $\\alpha$-parameter (`quantile`) for running CVaR-QAOA, an improved variation of the QAOA algorithm [[3](#cvar)]:" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "1d71e29a-5d53-49c4-84b2-45f59be4da31", + "execution_count": 31, + "id": "5dcfa7ce-09e6-41ac-be81-298a281ba051", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:44.764221Z", - "iopub.status.busy": "2024-05-07T16:03:44.763821Z", - "iopub.status.idle": "2024-05-07T16:03:49.214351Z", - "shell.execute_reply": "2024-05-07T16:03:49.213612Z" - }, - "pycharm": { - "name": "#%%\n" - }, "tags": [] }, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Opening: https://platform.classiq.io/circuit/0ff868cf-2ccd-47e7-b5f7-4500845af8c3?version=0.41.0.dev39%2B79c8fd0855\n" + "Optimization Progress: 70%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▌ | 56/80 [02:08<00:55, 2.29s/it]\n" ] } ], "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "id": "80238cf9-d7bd-46e5-9d48-b7cf23a6b304", - "metadata": {}, - "source": [ - "We now solve the problem by calling the `execute` function on the quantum program we have generated:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "62d12d20-1c80-4a9e-bb6b-b1fddc6cbe40", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:49.217154Z", - "iopub.status.busy": "2024-05-07T16:03:49.216634Z", - "iopub.status.idle": "2024-05-07T16:03:58.972236Z", - "shell.execute_reply": "2024-05-07T16:03:58.971471Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "result = execute(qprog).result_value()" + "optimized_params = combi.optimize(execution_preferences, maxiter=80, quantile=0.7)" ] }, { "cell_type": "markdown", - "id": "620ea6a0-cd05-41a9-a2ed-9631c680d2e6", + "id": "c2cd6e58-981a-47c8-8fd7-5f2a9bebbc31", "metadata": {}, "source": [ "We can check the convergence of the run:" @@ -390,38 +284,43 @@ }, { "cell_type": "code", - "execution_count": 12, - "id": "02454398-b229-403c-824a-b1eb539fbc1f", + "execution_count": 32, + "id": "6542ba4a-9493-4b01-8eea-8202d70b1f2c", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:58.977492Z", - "iopub.status.busy": "2024-05-07T16:03:58.976250Z", - "iopub.status.idle": "2024-05-07T16:03:59.020166Z", - "shell.execute_reply": "2024-05-07T16:03:59.019553Z" - }, "tags": [] }, "outputs": [ { "data": { - "image/jpeg": "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", - "image/png": "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", "text/plain": [ - "" + "Text(0.5, 1.0, 'Cost convergence')" ] }, - "execution_count": 12, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "result.convergence_graph" + "plt.plot(combi.cost_trace)\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.title(\"Cost convergence\")" ] }, { "cell_type": "markdown", - "id": "615ed612-b835-4bf0-aa92-92d30ef8006d", + "id": "d96714fd-2d11-4d13-9d21-4fc111a95670", "metadata": { "tags": [] }, @@ -431,24 +330,18 @@ }, { "cell_type": "markdown", - "id": "670eddd3-2da7-4a88-b571-7884ef24f60c", + "id": "96ea8543-29cb-4570-8741-7199dea8a948", "metadata": {}, "source": [ - "We can also examine the statistics of the algorithm:" + "We can also examine the statistics of the algorithm. In order to get samples with the optimized parameters, we call the `sample` method:" ] }, { "cell_type": "code", - "execution_count": 13, - "id": "516d78ba-2951-46eb-b1af-efe877513556", + "execution_count": 33, + "id": "bbc7c2ca-1d3a-4342-9a37-5b8fc8980fbe", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:59.023922Z", - "iopub.status.busy": "2024-05-07T16:03:59.023674Z", - "iopub.status.idle": "2024-05-07T16:03:59.177765Z", - "shell.execute_reply": "2024-05-07T16:03:59.177036Z" - }, - "tags": [] + "scrolled": true }, "outputs": [ { @@ -472,117 +365,102 @@ " \n", " \n", " \n", + " solution\n", " probability\n", " cost\n", - " solution\n", - " count\n", " \n", " \n", " \n", " \n", - " 525\n", - " 0.001\n", - " 0.0\n", - " [0, 1, 1, 1, 1, 0, 1, 0, 0, 0]\n", - " 1\n", + " 139\n", + " {'x': [0, 0, 1, 1, 1, 1, 1, 1, 0, 0]}\n", + " 0.001953\n", + " 1.183052e-271\n", " \n", " \n", - " 29\n", - " 0.004\n", - " 0.0\n", - " [1, 1, 1, 0, 0, 0, 0, 1, 1, 0]\n", - " 4\n", + " 278\n", + " {'x': [1, 1, 0, 0, 0, 0, 1, 1, 1, 0]}\n", + " 0.000977\n", + " 1.183052e-271\n", " \n", " \n", - " 511\n", - " 0.001\n", - " 0.0\n", - " [1, 1, 0, 0, 0, 1, 1, 0, 1, 0]\n", - " 1\n", + " 545\n", + " {'x': [1, 0, 1, 0, 0, 0, 0, 0, 1, 1]}\n", + " 0.000488\n", + " 1.183052e-271\n", " \n", " \n", - " 494\n", - " 0.001\n", - " 0.0\n", - " [0, 1, 0, 0, 0, 1, 1, 0, 0, 1]\n", - " 1\n", + " 515\n", + " {'x': [0, 0, 1, 0, 1, 0, 1, 1, 0, 1]}\n", + " 0.000488\n", + " 1.183052e-271\n", " \n", " \n", - " 424\n", - " 0.001\n", - " 0.0\n", - " [0, 0, 0, 1, 1, 1, 1, 0, 0, 1]\n", - " 1\n", + " 438\n", + " {'x': [0, 0, 0, 1, 1, 1, 0, 0, 1, 1]}\n", + " 0.000488\n", + " 1.183052e-271\n", " \n", " \n", "\n", "" ], "text/plain": [ - " probability cost solution count\n", - "525 0.001 0.0 [0, 1, 1, 1, 1, 0, 1, 0, 0, 0] 1\n", - "29 0.004 0.0 [1, 1, 1, 0, 0, 0, 0, 1, 1, 0] 4\n", - "511 0.001 0.0 [1, 1, 0, 0, 0, 1, 1, 0, 1, 0] 1\n", - "494 0.001 0.0 [0, 1, 0, 0, 0, 1, 1, 0, 0, 1] 1\n", - "424 0.001 0.0 [0, 0, 0, 1, 1, 1, 1, 0, 0, 1] 1" + " solution probability cost\n", + "139 {'x': [0, 0, 1, 1, 1, 1, 1, 1, 0, 0]} 0.001953 1.183052e-271\n", + "278 {'x': [1, 1, 0, 0, 0, 0, 1, 1, 1, 0]} 0.000977 1.183052e-271\n", + "545 {'x': [1, 0, 1, 0, 0, 0, 0, 0, 1, 1]} 0.000488 1.183052e-271\n", + "515 {'x': [0, 0, 1, 0, 1, 0, 1, 1, 0, 1]} 0.000488 1.183052e-271\n", + "438 {'x': [0, 0, 0, 1, 1, 1, 0, 0, 1, 1]} 0.000488 1.183052e-271" ] }, - "execution_count": 13, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import pandas as pd\n", - "\n", - "from classiq.applications.combinatorial_optimization import (\n", - " get_optimization_solution_from_pyo,\n", - ")\n", - "\n", - "solution = get_optimization_solution_from_pyo(\n", - " set_partition_model,\n", - " vqe_result=result,\n", - " penalty_energy=qaoa_config.penalty_energy,\n", - ")\n", - "optimization_result = pd.DataFrame.from_records(solution)\n", - "optimization_result.sort_values(by=\"cost\", ascending=True).head(5)" + "optimization_result = combi.sample(optimized_params)\n", + "optimization_result.sort_values(by=\"cost\").head(5)" + ] + }, + { + "cell_type": "markdown", + "id": "a55201b4-31b1-4477-a9fd-06a35352f0a1", + "metadata": {}, + "source": [ + "We will also want to compare the optimized results to uniformly sampled results:" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "acc7cbeb-b7a8-41a4-8922-0280d29b58af", + "metadata": {}, + "outputs": [], + "source": [ + "uniform_result = combi.sample_uniform()" ] }, { "cell_type": "markdown", - "id": "687f492b-a4a5-49c6-964c-8959b035bb93", + "id": "ccca8f9a-b252-4aeb-a92f-96deb4109d87", "metadata": {}, "source": [ - "And the histogram:" + "And compare the histograms:" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "31a4e74d-b2b8-42e0-826d-de7b51de1fe8", + "execution_count": 35, + "id": "8b0f949c-015a-4bbe-8bc1-8feb0e6c4480", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:59.182649Z", - "iopub.status.busy": "2024-05-07T16:03:59.181402Z", - "iopub.status.idle": "2024-05-07T16:03:59.666268Z", - "shell.execute_reply": "2024-05-07T16:03:59.665547Z" - }, "tags": [] }, "outputs": [ { "data": { - "text/plain": [ - "array([[]], dtype=object)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -592,7 +470,26 @@ } ], "source": [ - "optimization_result.hist(\"cost\", weights=optimization_result[\"probability\"])" + "optimization_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=50,\n", + " edgecolor=\"black\",\n", + " weights=optimization_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"optimized\",\n", + ")\n", + "uniform_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=50,\n", + " edgecolor=\"black\",\n", + " weights=uniform_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"uniform\",\n", + ")\n", + "plt.legend()\n", + "plt.ylabel(\"Probability\", fontsize=16)\n", + "plt.xlabel(\"cost\", fontsize=16)\n", + "plt.tick_params(axis=\"both\", labelsize=14)" ] }, { @@ -600,20 +497,14 @@ "id": "a3a890a1-c5d4-409d-b9a3-d7ffd4fdd6c0", "metadata": {}, "source": [ - "Let us plot the solution:" + "Let us plot the best solution:" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 36, "id": "4326e84b-26f6-4ea9-a53b-090fb3658b8c", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:59.669215Z", - "iopub.status.busy": "2024-05-07T16:03:59.668565Z", - "iopub.status.idle": "2024-05-07T16:03:59.672400Z", - "shell.execute_reply": "2024-05-07T16:03:59.671836Z" - }, "tags": [] }, "outputs": [], @@ -623,15 +514,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 37, "id": "f349d9fb-132e-4ca0-8433-db1e2d61efa1", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:59.674917Z", - "iopub.status.busy": "2024-05-07T16:03:59.674535Z", - "iopub.status.idle": "2024-05-07T16:03:59.679208Z", - "shell.execute_reply": "2024-05-07T16:03:59.678640Z" - }, "tags": [] }, "outputs": [ @@ -639,15 +524,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "P1= [7, 1, 8, 8, 11] , total sum: 35\n", - "P2= [4, 8, 11, 5, 7] , total sum: 35\n", + "P1= [5, 6, 5, 8, 11] , total sum: 35\n", + "P2= [8, 8, 8, 5, 6] , total sum: 35\n", "difference= 0\n" ] } ], "source": [ - "p1 = [mylist[i] for i in range(len(mylist)) if best_solution[i] == 0]\n", - "p2 = [mylist[i] for i in range(len(mylist)) if best_solution[i] == 1]\n", + "p1 = [mylist[i] for i in range(len(mylist)) if best_solution[\"x\"][i] == 0]\n", + "p2 = [mylist[i] for i in range(len(mylist)) if best_solution[\"x\"][i] == 1]\n", "print(\"P1=\", p1, \", total sum: \", sum(p1))\n", "print(\"P2=\", p2, \", total sum: \", sum(p2))\n", "print(\"difference= \", abs(sum(p1) - sum(p2)))" @@ -663,15 +548,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 38, "id": "5a7ca4b6-25a0-46dd-b5cc-de6a639a6f57", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:59.682282Z", - "iopub.status.busy": "2024-05-07T16:03:59.681909Z", - "iopub.status.idle": "2024-05-07T16:03:59.740657Z", - "shell.execute_reply": "2024-05-07T16:03:59.739961Z" - }, "pycharm": { "name": "#%%\n" }, @@ -687,16 +566,16 @@ " Variables:\n", " x : Size=10, Index=x_index\n", " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", - " 0 : 0 : 1.0 : 1 : False : False : Binary\n", - " 1 : 0 : 1.0 : 1 : False : False : Binary\n", - " 2 : 0 : 1.0 : 1 : False : False : Binary\n", - " 3 : 0 : 0.0 : 1 : False : False : Binary\n", + " 0 : 0 : 0.0 : 1 : False : False : Binary\n", + " 1 : 0 : 0.0 : 1 : False : False : Binary\n", + " 2 : 0 : 0.0 : 1 : False : False : Binary\n", + " 3 : 0 : 1.0 : 1 : False : False : Binary\n", " 4 : 0 : 1.0 : 1 : False : False : Binary\n", - " 5 : 0 : 0.0 : 1 : False : False : Binary\n", - " 6 : 0 : 0.0 : 1 : False : False : Binary\n", - " 7 : 0 : 0.0 : 1 : False : False : Binary\n", - " 8 : 0 : 0.0 : 1 : False : False : Binary\n", - " 9 : 0 : 1.0 : 1 : False : False : Binary\n", + " 5 : 0 : 1.0 : 1 : False : False : Binary\n", + " 6 : 0 : 1.0 : 1 : False : False : Binary\n", + " 7 : 0 : 1.0 : 1 : False : False : Binary\n", + " 8 : 0 : 1.0 : 1 : False : False : Binary\n", + " 9 : 0 : 0.0 : 1 : False : False : Binary\n", "\n", " Objectives:\n", " cost : Size=1, Index=None, Active=True\n", @@ -719,17 +598,9 @@ }, { "cell_type": "code", - "execution_count": 18, - "id": "2e5c1b07-6060-455d-81ed-e48a2207c81b", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:59.743360Z", - "iopub.status.busy": "2024-05-07T16:03:59.742870Z", - "iopub.status.idle": "2024-05-07T16:03:59.746421Z", - "shell.execute_reply": "2024-05-07T16:03:59.745852Z" - }, - "tags": [] - }, + "execution_count": 40, + "id": "4a8215b7-1a7c-4f6c-ad8f-24754816038c", + "metadata": {}, "outputs": [], "source": [ "classical_solution = [pyo.value(set_partition_model.x[i]) for i in range(len(mylist))]" @@ -737,15 +608,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 41, "id": "a7524894-b5c5-42d4-8f92-a019bef5e7da", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T16:03:59.748666Z", - "iopub.status.busy": "2024-05-07T16:03:59.748361Z", - "iopub.status.idle": "2024-05-07T16:03:59.752921Z", - "shell.execute_reply": "2024-05-07T16:03:59.752289Z" - }, "tags": [] }, "outputs": [ @@ -753,15 +618,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "P1= [7, 8, 8, 5, 7] , total sum: 35\n", - "P2= [4, 8, 11, 1, 11] , total sum: 35\n", + "P1= [8, 8, 8, 11] , total sum: 35\n", + "P2= [5, 5, 6, 5, 6, 8] , total sum: 35\n", "difference= 0\n" ] } ], "source": [ - "p1 = [mylist[i] for i in range(len(mylist)) if classical_solution[i] == 0]\n", - "p2 = [mylist[i] for i in range(len(mylist)) if classical_solution[i] == 1]\n", + "p1 = [mylist[i] for i in range(len(mylist)) if round(classical_solution[i]) == 0]\n", + "p2 = [mylist[i] for i in range(len(mylist)) if round(classical_solution[i]) == 1]\n", "print(\"P1=\", p1, \", total sum: \", sum(p1))\n", "print(\"P2=\", p2, \", total sum: \", sum(p2))\n", "print(\"difference= \", abs(sum(p1) - sum(p2)))" @@ -804,7 +669,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.4" }, "vscode": { "interpreter": { diff --git a/applications/optimization/set_partition/set_partition.qmod b/applications/optimization/set_partition/set_partition.qmod index 98a0674fb..c24de2ab4 100644 --- a/applications/optimization/set_partition/set_partition.qmod +++ b/applications/optimization/set_partition/set_partition.qmod @@ -1,713 +1,14 @@ -hamiltonian: PauliTerm[] = [ - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=324.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=18.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=24.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=24.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=24.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=24.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=24.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z - ], - coefficient=30.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=30.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=30.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=30.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=30.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=36.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=36.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=36.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=36.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=36.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=40.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=48.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=54.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=54.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=54.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=54.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=54.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=60.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=66.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=66.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=66.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=66.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=66.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=72.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=88.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=90.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=108.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=110.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=132.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=198.0 - } -]; - -qfunc main(params_list: real[6], output target: qbit[10]) { - allocate(target.len, target); - qaoa_penalty(target.len, params_list, hamiltonian, target); +qstruct QAOAVars { + x: qbit[10]; } -cscope ``` -vqe_result = vqe( -hamiltonian=hamiltonian, -maximize=False, -initial_point=[0.0, 0.006952841596130592, 0.003476420798065296, 0.003476420798065296, 0.006952841596130592, 0.0], -optimizer=Optimizer.COBYLA, -max_iteration=60, -tolerance=0.0, -step_size=0.0, -skip_compute_variance=False, -alpha_cvar=0.7 -) - -save({"vqe_result": vqe_result, "hamiltonian": hamiltonian}) -``` +qfunc main(params: real[6], output v: QAOAVars) { + allocate(v.size, v); + hadamard_transform(v); + repeat (i: 3) { + phase (-((((((((((((4 * v.x[0]) + (16 * v.x[1])) + (14 * v.x[2])) + (18 * v.x[3])) + (16 * v.x[4])) + (16 * v.x[5])) + (12 * v.x[6])) + (4 * v.x[7])) + (10 * v.x[8])) + (20 * v.x[9])) - 65) ** 2), params[i]); + apply_to_all(lambda(q) { + RX(params[3 + i], q); + }, v); + } +} diff --git a/applications/optimization/set_partition/set_partition.synthesis_options.json b/applications/optimization/set_partition/set_partition.synthesis_options.json index 0967ef424..ba1113e93 100644 --- a/applications/optimization/set_partition/set_partition.synthesis_options.json +++ b/applications/optimization/set_partition/set_partition.synthesis_options.json @@ -1 +1,43 @@ -{} +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "rz", + "cx", + "h", + "u1", + "r", + "sx", + "s", + "rx", + "y", + "cy", + "tdg", + "ry", + "u2", + "u", + "x", + "cz", + "z", + "sxdg", + "sdg", + "t", + "p", + "id" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": -1 + } +} diff --git a/applications/physical_systems/ising_model/ising_model.ipynb b/applications/physical_systems/ising_model/ising_model.ipynb index 75dc17651..1aa183609 100644 --- a/applications/physical_systems/ising_model/ising_model.ipynb +++ b/applications/physical_systems/ising_model/ising_model.ipynb @@ -29,12 +29,6 @@ "execution_count": 1, "id": "c6bb59fb-285b-439d-871e-7952c2df8db2", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:22:54.176458Z", - "iopub.status.busy": "2024-05-07T15:22:54.174237Z", - "iopub.status.idle": "2024-05-07T15:22:54.375957Z", - "shell.execute_reply": "2024-05-07T15:22:54.375173Z" - }, "tags": [] }, "outputs": [], @@ -50,7 +44,7 @@ "source": [ "## 1. Define the Optimization Problem\n", "\n", - "We created a python pyomo model to describe an Ising model as optimization problem over the configuration of spins. We take a simple manifestation of the 1d Ising model, described as [6]:\n", + "We created a python Pyomo model to describe an Ising model as optimization problem over the configuration of spins. We take a simple manifestation of the 1d Ising model, described as [6]:\n", "\n", "$H(\\sigma) = -\\sum\\limits _{i,j}J\\sigma_{i}\\sigma_{j}-\\sum\\limits _{i} h\\sigma_{i}$\n", "\n", @@ -64,12 +58,6 @@ "execution_count": 2, "id": "37e95f02-075e-45f6-94f1-6951ea81b0a4", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:22:54.381762Z", - "iopub.status.busy": "2024-05-07T15:22:54.380282Z", - "iopub.status.idle": "2024-05-07T15:22:54.389802Z", - "shell.execute_reply": "2024-05-07T15:22:54.389106Z" - }, "tags": [] }, "outputs": [], @@ -114,12 +102,6 @@ "execution_count": 3, "id": "c053de5b-bbb4-4c8e-b86a-840d792c407f", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:22:54.394509Z", - "iopub.status.busy": "2024-05-07T15:22:54.393412Z", - "iopub.status.idle": "2024-05-07T15:22:54.399755Z", - "shell.execute_reply": "2024-05-07T15:22:54.399079Z" - }, "tags": [] }, "outputs": [], @@ -136,124 +118,79 @@ "source": [ "## 3. Optimize Using to Quantum Optimization Algorithm\n", "\n", - "We will now create a QAOA model for the optimization problem. The results of the model is the sequance of qubit values giving the minimized energy for the protein. In order to optimize the results, we recommend the user to explore the number of repatitions for the model (`num_layers`) and the number of iterations for the optimizer (`max_iteration`)." + "We will now create a QAOA model for the optimization problem. The results of the model is the sequance of qubit values giving the minimized energy for the protein. In order to optimize the results, we recommend the user to explore the number of repatitions for the model (`num_layers`) and the number of iterations for the optimizer (`maxiter`)." ] }, { "cell_type": "code", "execution_count": 4, - "id": "0cad145c-b78a-4c9e-945a-fffb7e4fef45", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:22:54.404600Z", - "iopub.status.busy": "2024-05-07T15:22:54.403259Z", - "iopub.status.idle": "2024-05-07T15:22:57.272833Z", - "shell.execute_reply": "2024-05-07T15:22:57.262051Z" - }, - "tags": [] - }, + "id": "b2c6406f-8aa3-4674-870e-13b5a36b50dc", + "metadata": {}, "outputs": [], "source": [ "from classiq import *\n", - "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", + "from classiq.applications.combinatorial_optimization import CombinatorialProblem\n", "\n", - "qaoa_config = QAOAConfig(num_layers=5)\n", + "combi = CombinatorialProblem(pyo_model=ising_model, num_layers=5, penalty_factor=10)\n", "\n", - "optimizer_config = OptimizerConfig(\n", - " max_iteration=100,\n", - " alpha_cvar=0.7,\n", - ")\n", - "\n", - "qmod = construct_combinatorial_optimization_model(\n", - " pyo_model=ising_model,\n", - " qaoa_config=qaoa_config,\n", - " optimizer_config=optimizer_config,\n", - ")" + "qmod = combi.get_model()\n", + "write_qmod(qmod, \"ising_model\")" ] }, { "cell_type": "markdown", - "id": "ae3233b3-9805-4c8a-b115-d4fa9defcd92", + "id": "5f476b81-ce50-4cc5-a8d7-13c7b5033e0e", "metadata": {}, "source": [ - "We also set the quantum backend we want to execute on:" + "Now we can create a quantum circuit using the `get_qprog` command and show it" ] }, { "cell_type": "code", "execution_count": 5, - "id": "4f779a6a-dae4-4235-92be-f90820fbfbeb", + "id": "0b28f2dc-26ec-4975-9e1f-41adfdd75cb4", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:22:57.280659Z", - "iopub.status.busy": "2024-05-07T15:22:57.280120Z", - "iopub.status.idle": "2024-05-07T15:22:57.308215Z", - "shell.execute_reply": "2024-05-07T15:22:57.305665Z" + "pycharm": { + "name": "#%%\n" }, "tags": [] }, - "outputs": [], - "source": [ - "from classiq.execution import ClassiqBackendPreferences\n", - "\n", - "qmod = set_execution_preferences(\n", - " qmod, backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "2425da2e-35c9-49a7-8479-c1856ee34f75", - "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:22:57.312667Z", - "iopub.status.busy": "2024-05-07T15:22:57.312406Z", - "iopub.status.idle": "2024-05-07T15:22:57.344678Z", - "shell.execute_reply": "2024-05-07T15:22:57.343993Z" + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://nightly.platform.classiq.io/circuit/40d4cb3e-8ee4-4b6e-be8b-bd120647f993?version=0.62.0.dev9\n" + ] } - }, - "outputs": [], + ], "source": [ - "write_qmod(qmod, \"ising_model\")" + "qprog = combi.get_qprog()\n", + "show(qprog)" ] }, { "cell_type": "markdown", - "id": "5f476b81-ce50-4cc5-a8d7-13c7b5033e0e", + "id": "b2ae85bb-2625-47ea-a112-5bbbd37fd6d5", "metadata": {}, "source": [ - "Now we can create a quantum circuit using the `synthesize` command and show it" + "We also set the quantum backend we want to execute on:" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "0b28f2dc-26ec-4975-9e1f-41adfdd75cb4", + "execution_count": 6, + "id": "4f779a6a-dae4-4235-92be-f90820fbfbeb", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:22:57.347982Z", - "iopub.status.busy": "2024-05-07T15:22:57.347558Z", - "iopub.status.idle": "2024-05-07T15:23:01.963192Z", - "shell.execute_reply": "2024-05-07T15:23:01.962520Z" - }, - "pycharm": { - "name": "#%%\n" - }, "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/e1a07618-2899-4a95-9d21-8eeb100cb053?version=0.41.0.dev39%2B79c8fd0855\n" - ] - } - ], + "outputs": [], "source": [ - "qprog = synthesize(qmod)\n", - "show(qprog)" + "from classiq.execution import *\n", + "\n", + "execution_preferences = ExecutionPreferences(\n", + " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator\")\n", + ")" ] }, { @@ -261,7 +198,7 @@ "id": "8ce840ba-1d3e-461c-99f2-5045d8cb8e29", "metadata": {}, "source": [ - "We now solve the problem by calling the `execute` function on the quantum program we have generated:" + "We now solve the problem by calling the `optimize` function:" ] }, { @@ -269,17 +206,19 @@ "execution_count": 8, "id": "6daf89c6-2e5c-41b5-b162-dfd048014919", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:23:01.965793Z", - "iopub.status.busy": "2024-05-07T15:23:01.965322Z", - "iopub.status.idle": "2024-05-07T15:23:09.428158Z", - "shell.execute_reply": "2024-05-07T15:23:09.427541Z" - }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Optimization Progress: 101it [03:14, 1.92s/it] \n" + ] + } + ], "source": [ - "result = execute(qprog).result_value()" + "optimized_params = combi.optimize(execution_preferences, maxiter=100, quantile=0.7)" ] }, { @@ -295,30 +234,37 @@ "execution_count": 9, "id": "370e71c6-764e-4296-882a-d5daa14d3176", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:23:09.430991Z", - "iopub.status.busy": "2024-05-07T15:23:09.430811Z", - "iopub.status.idle": "2024-05-07T15:23:09.458569Z", - "shell.execute_reply": "2024-05-07T15:23:09.457962Z" - }, "tags": [] }, "outputs": [ { "data": { - "image/jpeg": "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", - "image/png": "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", "text/plain": [ - "" + "Text(0.5, 1.0, 'Cost convergence')" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "result.convergence_graph" + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(combi.cost_trace)\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.title(\"Cost convergence\")" ] }, { @@ -328,7 +274,7 @@ "source": [ "## 4. Present Quantum Results\n", "\n", - "We hereby present the optimization results. Since this is a quantum solution with probabilistic results, there is a defined probability for each result to be obtained by a measurement (presented by an histogram), where the solution is chosen to be the most probable one.\n", + "We call the `sample` method to get samples with the optimzied parameters. We hereby present the optimization results. Since this is a quantum solution with probabilistic results, there is a defined probability for each result to be obtained by a measurement (presented by an histogram), where the solution is chosen to be the most probable one.\n", "\n", "We remind that in the notation of the solution \"0\" indicate \"-1\" spin value, and \"1\" indicates \"1\" spin value." ] @@ -336,15 +282,9 @@ { "cell_type": "code", "execution_count": 10, - "id": "da738964-b1ba-4b94-997a-ae7a46254f6c", + "id": "2c35bcde-2d6e-4ed0-aa70-325dbf5a7846", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:23:09.461338Z", - "iopub.status.busy": "2024-05-07T15:23:09.460808Z", - "iopub.status.idle": "2024-05-07T15:23:09.487645Z", - "shell.execute_reply": "2024-05-07T15:23:09.487039Z" - }, - "tags": [] + "scrolled": true }, "outputs": [ { @@ -368,59 +308,53 @@ " \n", " \n", " \n", + " solution\n", " probability\n", " cost\n", - " solution\n", - " count\n", " \n", " \n", " \n", " \n", " 0\n", - " 0.189\n", + " {'z': [0, 0, 0, 0, 0, 0]}\n", + " 0.589355\n", " -180.0\n", - " [0, 0, 0, 0, 0, 0]\n", - " 189\n", " \n", " \n", - " 7\n", - " 0.033\n", + " 1\n", + " {'z': [0, 0, 0, 0, 0, 1]}\n", + " 0.045410\n", " -100.0\n", - " [0, 0, 1, 0, 0, 0]\n", - " 33\n", " \n", " \n", - " 8\n", - " 0.032\n", + " 2\n", + " {'z': [0, 0, 1, 0, 0, 0]}\n", + " 0.041992\n", " -100.0\n", - " [0, 1, 0, 0, 0, 0]\n", - " 32\n", " \n", " \n", - " 9\n", - " 0.030\n", + " 3\n", + " {'z': [0, 0, 0, 1, 0, 0]}\n", + " 0.038574\n", " -100.0\n", - " [0, 0, 0, 0, 0, 1]\n", - " 30\n", " \n", " \n", - " 10\n", - " 0.030\n", + " 4\n", + " {'z': [0, 1, 0, 0, 0, 0]}\n", + " 0.038086\n", " -100.0\n", - " [0, 0, 0, 0, 1, 0]\n", - " 30\n", " \n", " \n", "\n", "" ], "text/plain": [ - " probability cost solution count\n", - "0 0.189 -180.0 [0, 0, 0, 0, 0, 0] 189\n", - "7 0.033 -100.0 [0, 0, 1, 0, 0, 0] 33\n", - "8 0.032 -100.0 [0, 1, 0, 0, 0, 0] 32\n", - "9 0.030 -100.0 [0, 0, 0, 0, 0, 1] 30\n", - "10 0.030 -100.0 [0, 0, 0, 0, 1, 0] 30" + " solution probability cost\n", + "0 {'z': [0, 0, 0, 0, 0, 0]} 0.589355 -180.0\n", + "1 {'z': [0, 0, 0, 0, 0, 1]} 0.045410 -100.0\n", + "2 {'z': [0, 0, 1, 0, 0, 0]} 0.041992 -100.0\n", + "3 {'z': [0, 0, 0, 1, 0, 0]} 0.038574 -100.0\n", + "4 {'z': [0, 1, 0, 0, 0, 0]} 0.038086 -100.0" ] }, "execution_count": 10, @@ -429,56 +363,105 @@ } ], "source": [ - "import pandas as pd\n", - "\n", - "from classiq.applications.combinatorial_optimization import (\n", - " get_optimization_solution_from_pyo,\n", - ")\n", - "\n", - "solution = get_optimization_solution_from_pyo(\n", - " ising_model, vqe_result=result, penalty_energy=qaoa_config.penalty_energy\n", - ")\n", - "optimization_result = pd.DataFrame.from_records(solution)\n", - "optimization_result.sort_values(by=\"cost\", ascending=True).head(5)" + "optimization_result = combi.sample(combi.optimized_params)\n", + "optimization_result.sort_values(by=\"cost\").head(5)" + ] + }, + { + "cell_type": "markdown", + "id": "242936e1-23e9-44c0-ae34-62dfbf61ce4b", + "metadata": {}, + "source": [ + "We will also want to compare the optimized results to uniformly sampled results:" ] }, { "cell_type": "code", "execution_count": 11, - "id": "81d6f1dd-7e65-4118-bc8b-9ee662c72a68", + "id": "a26c4460-f73e-436e-ae26-26eaa485930e", + "metadata": {}, + "outputs": [], + "source": [ + "uniform_result = combi.sample_uniform()" + ] + }, + { + "cell_type": "markdown", + "id": "70a99eba-a999-40c4-8030-b84cde4c5d0a", + "metadata": {}, + "source": [ + "And compare the histograms:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "67b0d5fa-49ee-4245-9953-3b4a937a3c08", "metadata": { - "execution": { - "iopub.execute_input": "2024-05-07T15:23:09.490132Z", - "iopub.status.busy": "2024-05-07T15:23:09.489947Z", - "iopub.status.idle": "2024-05-07T15:23:09.702616Z", - "shell.execute_reply": "2024-05-07T15:23:09.701922Z" - }, "tags": [] }, "outputs": [ { "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkYAAAG7CAYAAAAmOVo2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABGwklEQVR4nO3deVxVdf7H8fdFNlnFJXEDxHCpcWmR3HLJn2LOVNNoolao46jVVGNqzUAqWo1m2UyLjlmWkOZPLc1qfimaiqapg1urC5ILJeSC3CuorOf3h5c7EaJcLhcu+Ho+Hvfx6J7zPd/zOUeSt+d8z/maDMMwBAAAALnVdAEAAACugmAEAABgRTACAACwIhgBAABYEYwAAACsCEYAAABWBCMAAAAr95ouoDYpLi7WyZMn5e/vL5PJVNPlAACACjAMQ+fPn1fz5s3l5nb1a0IEIzucPHlSrVq1qukyAABAJaSnp6tly5ZXbUMwsoO/v7+kyyc2ICCghqsBAAAVYbFY1KpVK9vv8ashGNmh5PZZQEAAwQgAgFqmIsNgGHwNAABgRTACAACwIhgBAABYufQYo5SUFMXHx+vLL79UQUGBOnbsqEmTJmnYsGF29XPq1CnNnj1b//73v5Weni5fX1+1bdtWMTExevTRR51UPQDAlRUVFamgoKCmy0AV8fT0vOaj+BXhssFo8+bNioqKkre3t4YPHy5/f3+tWrVK0dHRSk9P1+TJkyvUz/79+zVw4ECdO3dOv/3tbzV06FDl5OTowIED+vTTTwlGAHCdMQxDmZmZys7OrulSUIXc3NzUunVreXp6OtSPyTAMo4pqqjKFhYVq3769fvzxR+3cuVNdunSRJJnNZkVGRurYsWM6fPiwQkNDr9qPxWJRx44ddfHiRX3++efq1KlTmf24u1c8G1osFgUGBspsNvNUGgDUUhkZGcrOztYNN9wgHx8fXthbB5S8gNnDw0MhISFl/kzt+f3tkleMNm3apLS0NI0ZM8YWiiQpMDBQcXFxGj16tBITEzV9+vSr9vOvf/1LJ06c0DvvvFMmFEmyKxQBAGq/oqIiWyhq1KhRTZeDKtSkSROdPHlShYWF8vDwqHQ/LpkMkpOTJUkDBw4ssy4qKkqStGXLlmv2s2LFCplMJg0ZMkSHDh3S+vXrdfHiRbVv316DBg265uW2vLw85eXl2b5bLBY7jgIA4GpKxhT5+PjUcCWoaiW/04uKiupeMEpNTZUkRURElFkXHBwsPz8/W5vy5Ofn65tvvlGTJk30xhtvKD4+XsXFxbb14eHhWrNmjTp27FhuH7Nnz9bMmTMreRQAAFfF7bO6p6r+TF3ycX2z2Szp8q2zKwkICLC1KU9WVpaKiop09uxZPffcc3rppZf0888/68cff9S0adN09OhR3XPPPbp06VK5fcTGxspsNts+6enplT8oAADg8lzyilFVKLk6VFRUpMcff7zUU2zPPfecDh06pJUrV+rDDz/UQw89dMU+vLy85OXlVS31AgBqVlZWlnJycqptf35+fmrYsGG17e9qwsLCNHHiRE2cOLHSfcyYMUNr1qzR/v37q6yuX+vbt6+6dOmiV1991Wn7cMlgVHKlqLyrQhaLRUFBQRXqQ5LuvffeMuvvvfderVy5Urt37y43GAEArg9ZWVma+EycsiwXqm2fDQN89OpLs6o1HCUkJGjixIllXlWQkpIiX19fh/qeMmWKnnjiCYf6cAUuGYxKxhalpqbqtttuK7UuMzNTOTk5ioyMvGofvr6+atGihX766Sc1aNCgzPqSZRcvXqySmgEAtVdOTo6yLBfU6NYo+QY1cfr+cs+d1tm9ScrJyXGJq0ZNmjh+zH5+fvLz86uCamqWS44x6tOnjyRp/fr1ZdYlJSWVanM1d911lyTp+++/L7OuZFlYWFhlywQA1DG+QU0U2KSZ0z+VDV95eXl68skndcMNN8jb21u9evVSSkqKpMtPdJtMJv3f//2fOnXqJG9vb3Xr1k3ffvutbf2YMWNkNptlMplkMpk0Y8YMSZd/F/7y9pTJZNLChQv1u9/9Tj4+PurQoYN27NihI0eOqG/fvvL19VWPHj2UlpZm22bGjBmlXrFTso9ffn75O/fbb7/V3XffLT8/PzVt2lQPP/ywzpw5Y1ufm5urmJgY+fn5qVmzZnrllVcqdc7s5ZLBqH///goPD9eyZctK3as0m82aNWuWPD09FRMTY1uekZGhgwcPlrn19sgjj0iSXnzxxVKXDTMzM/Xaa6/Jzc1NQ4YMceqx2CMrK0snTpyo1CcrK6umywcAONkzzzyjVatWKTExUXv37tWNN96oqKioUr8Dnn76ab3yyitKSUlRkyZNdM8996igoEA9evTQq6++qoCAAGVkZCgjI0NTpkwpd1/PP/+8YmJitH//frVv314jR47UhAkTFBsbq927d8swDD3++OPlbl+yj4yMDB05ckQ33nijevfuLUnKzs7WXXfdpVtuuUW7d+/WunXr9PPPP5ea8uvpp5/Wli1b9PHHH2v9+vVKTk7W3r17q+AsXp1L3kpzd3fXokWLFBUVpd69e5eaEuT48eOaO3duqdQZGxurxMRELV68WKNHj7Yt79GjhyZNmqR//OMf6tSpk+2H4+OPP9apU6c0a9YstW3btvoP8Aocvb9dE/eqAQDVJzc3VwsWLFBCQoLuvvtuSdLbb7+tDRs26J133lHXrl0lSfHx8RowYIAkKTExUS1bttRHH32kYcOGKTAwUCaTScHBwdfc35gxY2xB5a9//au6d++uadOm2d4n+Je//EVjxowpd/uSfRiGoSFDhigwMFALFy6UJM2bN0+33HKLZs2aZWv/7rvvqlWrVjp8+LCaN2+ud955R0uXLlX//v1LHYuzuWQwkqR+/fpp27Ztio+P14oVK2yTyM6ZM0fR0dEV7ueVV15Rx44dNX/+fCUkJMhkMumWW27Rm2++qfvvv9+JR2AfR+5vu9q9agBA1UtLS1NBQYF69uxpW+bh4aHIyEgdOHDAFoy6d+9uW9+wYUO1a9dOBw4csHt/v5wxomnTppJU6t1/TZs21aVLl2SxWK46zUZcXJx27Nih3bt3q379+pKkr776Sps3b77imKS0tDRdvHhR+fn5uuOOO8oci7O5bDCSpMjISK1du/aa7RISEpSQkFDu+tGjR5e6kuTKSu5v2+usE2oBAFy/fvn26JKXJ15p2S9fnvxrS5cu1T//+U8lJyerRYsWtuU5OTm65557NGfOnDLbNGvWTEeOHHG4/spyyTFGAACgtDZt2sjT01Pbt2+3LSsoKFBKSopuuukm27KdO3fa/vvcuXM6fPiwOnToIOnytBlFRUXVUu+OHTv0pz/9SQsXLlS3bt1Krbv11lv13XffKSwsTDfeeGOpj6+vr9q0aSMPDw/t2rWrzLE4G8EIAIBawNfXV48++qiefvpprVu3Tt9//73GjRunCxcuaOzYsbZ2zz33nDZu3Khvv/1Wo0ePVuPGjfX73/9e0uWnz3JycrRx40adOXNGFy44571NmZmZuv/++zV8+HBFRUUpMzNTmZmZOn36tCTpz3/+s7KysjRixAilpKQoLS1NSUlJGjNmjIqKiuTn56exY8fq6aef1qZNm2zH4ubm/Nji0rfSAACoTrnnTrv0fl588UUVFxfr4Ycf1vnz53X77bcrKSmp1EuPX3zxRf3lL39RamqqunTpok8//dQ2wWqPHj30yCOPKDo6WmfPnlV8fLztkf2qdPDgQf38889KTExUYmKibXloaKiOHTum5s2ba/v27frrX/+qgQMHKi8vT6GhoRo0aJAt/Lz88su2W27+/v6aPHnyNacDqwomwzAMp++ljrBYLAoMDJTZbL7qQLPKOHHihB6bMlUh/R+ye4yR+XSGTmxcqn/NfUEhISFVWhcA1CWXLl3S0aNH1bp1a3l7e9uW14U3XycnJ6tfv346d+7cFV9sXNeV92cr2ff7mytGAIDrXsOGDfXqS7Ou27nS8F8EIwAAdDkcEVRAMAIAoA7o27evGB3jOJ5KAwAAsCIYAQAAWBGMAAAArAhGAAAAVgQjAAAAK4IRAACAFY/rAwCgy2+/rssveLzSm7HXrFmjKVOm6OjRo3riiSf06quvVls9ropgBAC47mVlZSn+mYnKP3+m2vbp6d9YM196tdrCUY8ePZSRkaHAwEDbsgkTJmjMmDF68skn5e/vXy11uDqCEQDgupeTk6P882f0x67+atbQ1+n7y8jK1bspZ5STk1NtwcjT01PBwcG27zk5OTp16pSioqLUvHnzSvebn59vm6S2LmCMEQAAVs0a+iqkib/TP5UJX2FhYWVudXXp0kUzZsyQJJlMJi1atEj333+/fHx8FBERoU8++cTWNjk5WSaTSdnZ2UpOTrZdIbrrrrtkMpmUnJwsSVq1apVuvvlmeXl5KSwsTK+88kqZOp5//nnFxMQoICBA48ePV0JCgho0aKB///vfateunXx8fDR06FBduHBBiYmJCgsLU1BQkJ588kkVFRXZfezViWAEAEAdMXPmTA0bNkxff/21Bg8erAcffFBZWVll2vXo0UOHDh2SdDkIZWRkqEePHtqzZ4+GDRum4cOH65tvvtGMGTM0bdo0JSQklNp+7ty56ty5s/bt26dp06ZJki5cuKDXX39dy5cv17p165ScnKz7779fn332mT777DMtWbJECxcu1Icffuj08+AIbqUBAFBHjB49WiNGjJAkzZo1S6+//rr+85//aNCgQaXaeXp66oYbbpB0efLcklts//jHP9S/f39b2Gnbtq2+//57vfzyyxo9erRt+7vuukuTJ0+2ff/iiy9UUFCgBQsWqE2bNpKkoUOHasmSJfr555/l5+enm266Sf369dPmzZsVHR3ttHPgKK4YAQBQR3Tq1Mn2376+vgoICNCpU6cqvP2BAwfUs2fPUst69uyp1NTUUrfAbr/99jLb+vj42EKRJDVt2lRhYWHy8/MrtcyeemoCwQgAgFrAzc1NhmGUWlZQUFDqu4eHR6nvJpNJxcXFVV6Lr2/ZMVJX2nd11VOVCEYAANQCTZo0UUZGhu27xWLR0aNHq3QfHTp00Pbt20st2759u9q2bat69epV6b5cFcEIAIBa4K677tKSJUv0xRdf6JtvvtGoUaOqPKxMnjxZGzdu1PPPP6/Dhw8rMTFR8+bN05QpU6p0P66MwdcAAFhlZOW67H5iY2N19OhR/e53v1NgYKCef/75Kr9idOutt2rlypWaPn26nn/+eTVr1kzPPfdcqYHXdZ3J+PUNS5TLYrEoMDBQZrNZAQEBVdr3iRMn9NiUqQrp/5ACmzSza1vz6Qyd2LhU/5r7gkJCQqq0LgCoSy5duqSjR4+qdevW8vb2ti2/Ht58XdeV92cr2ff7mytGAIDrXsOGDTXzpVfr9FxpqBiCEQAAuhyOCCpg8DUAAIAVwQgAAMCKYAQAuO7w3FHdU1V/pgQjAMB1o+RNzBcuXKjhSlDV8vPzJcnhdzsx+BoAcN2oV6+eGjRoYJuvy8fHRyaTqYargqOKi4t1+vRp+fj4yN3dsWhDMAIAXFdKZpJ39clMYR83NzeFhIQ4HHQJRgCA64rJZFKzZs10ww03lJmEFbWXp6en3NwcHyFEMAIAXJfq1at33UyMiopj8DUAAIAVwQgAAMCKYAQAAGBFMAIAALAiGAEAAFgRjAAAAKwIRgAAAFYEIwAAACuCEQAAgJVLB6OUlBQNHjxYDRo0kK+vr7p166aVK1dWePuEhASZTKZyP8nJyc4rHgAA1DouOyXI5s2bFRUVJW9vbw0fPlz+/v5atWqVoqOjlZ6ersmTJ1e4r/vuu09dunQpszwsLKzqCgYAALWeSwajwsJCjRs3Tm5ubtq6dast1EyfPl2RkZGKi4vT0KFDFRoaWqH+fv/732v06NHOKxgAANQJLnkrbdOmTUpLS9PIkSNLXekJDAxUXFyc8vPzlZiYWHMFAgCAOsklrxiVjP0ZOHBgmXVRUVGSpC1btlS4v3379uns2bMqLCxUWFiY/ud//keNGjWqkloBAEDd4ZLBKDU1VZIUERFRZl1wcLD8/PxsbSri9ddfL/W9fv36io+P11//+terbpeXl6e8vDzbd4vFUuF9AgCA2sclb6WZzWZJl2+dXUlAQICtzdW0bt1ab7zxhg4fPqwLFy7oxx9/1HvvvaeGDRvqb3/7m954442rbj979mwFBgbaPq1atbL/YAAAQK3hksGoqvTp00ePP/64IiIiVL9+fbVo0UIPP/ywkpKS5O3trRkzZqiwsLDc7WNjY2U2m22f9PT0aqweAABUN5cMRiVXisq7KmSxWMq9mlQRN998s3r16qWsrCwdOHCg3HZeXl4KCAgo9QEAAHWXSwajkrFFVxpHlJmZqZycnCuOP7JH48aNJUm5ubkO9QMAAOoOlwxGffr0kSStX7++zLqkpKRSbSqjqKhIu3fvlqQKvwsJAADUfS4ZjPr376/w8HAtW7ZM+/fvty03m82aNWuWPD09FRMTY1uekZGhgwcPlrn1tmfPnjJ9FxUV6W9/+5uOHDmifv36qVmzZk47DgAAULu45OP67u7uWrRokaKiotS7d+9SU4IcP35cc+fOLTWdR2xsrBITE7V48eJSb7i+/fbb1alTJ3Xq1EktWrRQVlaWtmzZosOHD6tly5ZatGhR9R8cAABwWS4ZjCSpX79+2rZtm+Lj47VixQoVFBSoY8eOmjNnjqKjoyvUx+TJk7Vz505t2LBBWVlZ8vT01I033qipU6dq0qRJCgoKcvJRAACA2sRlg5EkRUZGau3atddsl5CQoISEhDLL586d64SqAABAXeWSY4wAAABqAsEIAADAimAEAABgRTACAACwIhgBAABYEYwAAACsCEYAAABWBCMAAAArghEAAIAVwQgAAMCKYAQAAGBFMAIAALAiGAEAAFgRjAAAAKwIRgAAAFYEIwAAACuCEQAAgBXBCAAAwIpgBAAAYEUwAgAAsCIYAQAAWBGMAAAArAhGAAAAVgQjAAAAK4IRAACAFcEIAADAimAEAABgRTACAACwIhgBAABYEYwAAACsCEYAAABWBCMAAAArghEAAIAVwQgAAMCKYAQAAGBFMAIAALAiGAEAAFgRjAAAAKwIRgAAAFYEIwAAACuCEQAAgBXBCAAAwIpgBAAAYEUwAgAAsCIYAQAAWLl0MEpJSdHgwYPVoEED+fr6qlu3blq5cmWl+zt37pxatGghk8mkQYMGVWGlAACgLnCv6QLKs3nzZkVFRcnb21vDhw+Xv7+/Vq1apejoaKWnp2vy5Ml29/n444/LbDY7oVoAAFAXuOQVo8LCQo0bN05ubm7aunWr3nrrLb3yyiv66quv1LZtW8XFxen48eN29blq1SotW7ZMc+bMcVLVAACgtnPJYLRp0yalpaVp5MiR6tKli215YGCg4uLilJ+fr8TExAr3d/r0aT366KN6+OGH9dvf/tYJFQMAgLrAJYNRcnKyJGngwIFl1kVFRUmStmzZUuH+HnnkEdWrV0+vvfZaldQHAADqJpccY5SamipJioiIKLMuODhYfn5+tjbXsnTpUq1evVpr1qxRUFCQXWOM8vLylJeXZ/tusVgqvC0AAKh9HLpidO7cuaqqo5SS8BIYGHjF9QEBARUKOCdPntSTTz6pESNG6L777rO7jtmzZyswMND2adWqld19AACA2sOhYNSyZUuNGzdO+/fvr6Jyqtaf/vQneXh46PXXX6/U9rGxsTKbzbZPenp6FVcIAABciUPBKD8/X++8845uu+023XnnnVqxYoUKCwsdLqrkSlF5V4UsFku5V5NKJCYmau3atZo/f74aN25cqTq8vLwUEBBQ6gMAAOouh4LRiRMnNG3aNDVt2lTbt2/XyJEjFRISopkzZyozM7PS/ZaMLbrSOKLMzEzl5ORccfzRL+3bt0+S9MADD8hkMtk+rVu3liQlJSXJZDKVeuoNAABc3xwKRs2aNdPMmTN14sQJLVu2TD169FBmZqaee+45hYaGasSIEdq2bZvd/fbp00eStH79+jLrkpKSSrUpT/fu3TV27Ngyn+joaEmXbwOOHTtWf/jDH+yuDwAA1E0mwzCMquzwm2++0bx587Rs2TLl5ubKZDKpU6dOevzxx/Xggw/K29v7mn0UFhaqXbt2+umnn7Rz507bVR2z2azIyEgdO3ZMhw4dUlhYmCQpIyNDZrNZzZo1u+YttmPHjql169aKiorSunXr7Dq2klt4ZrO5ym+rnThxQo9NmaqQ/g8psEkzu7Y1n87QiY1L9a+5LygkJKRK6wIAoLaz5/d3lb/HqGPHjlq4cKF+/PFHTZkyRYZh6Ouvv9b48ePVokULTZs27ZqPvbu7u2vRokUqLi5W7969NX78eE2ePFmdO3fW4cOHNWvWLFsoki4Pku7QoYM++uijqj4cAABwHXHKCx6/+OILjR8/3vZCRU9PT0VGRio7O1uzZs3STTfdpO++++6qffTr10/btm1Tz549tWLFCi1YsEBNmzbV8uXLKzVPGgAAwLVU2QseL168qCVLlmj+/Pn69ttvZRiGmjVrpkcffVQTJkxQkyZNlJqaqmnTpmnlypWaPHnyNW9lRUZGau3atdfcd0JCghISEipUZ1hYmKr47iEAAKgjHA5GR44c0fz585WYmCiz2SzDMBQZGaknn3xSw4YNk7v7f3cRERGh5cuX6/jx49q5c6ejuwYAAKhSDgWju+++Wxs2bFBxcbE8PDw0fPhwPfnkk7rjjjuuut1NN92k//znP47sGgAAoMo5FIySkpLUpEkTjR8/Xo899piaNavY01S///3veXoKAAC4HIeC0bvvvquRI0fK09PTru3uuece3XPPPY7sGgAAoMo59FRaeHi4jh07ds12qamp2rp1qyO7AgAAcDqHglG/fv00Z86ca7Z76aWX1K9fP0d2BQAA4HQOBSPDMHj0HQAA1BlOecHjr507d65CU4EAAADUJLsHX584caLU95ycnDLLShQWFuq7777T+vXr1aZNm8pVCAAAUE3sDkZhYWEymUy276tWrdKqVauuuo1hGHrooYfsrw4AAKAa2R2MQkJCbMHoxIkT8vHxUePGja/Y1tPTUy1bttSQIUP06KOPOlYpAACAk9kdjH75eL6bm5seeOABvfvuu1VZEwAAQI1w6AWPixcv1o033lhVtQAAANQoh4LRqFGjqqoOAACAGlctj+sDAADUBnZdMQoPD5fJZNLnn3+u1q1bKzw8vMLbmkwmpaWl2V0gAABAdbErGB07dkwmk0kFBQW27xX1y0f8AQAAXJFdwejo0aOSpBYtWpT6DgAAUBfYFYxCQ0Ov+h0AAKA2Y/A1AACAFcEIAADAyq5baX/84x8rvSOTyaR33nmn0tsDAAA4m13BKCEhodI7IhgBAABXZ1cwWrx4sbPqAAAAqHF2BSOmAAEAAHUZg68BAACsCEYAAABWdt1Ke++99yRJ999/v/z9/W3fKyomJsau9gAAANXJrmA0evRomUwmdevWTf7+/rbvFUUwAgAArsyuYBQTEyOTyaTAwMBS3wEAAOoCh95j5Mh7jQAAAFwNg68BAACsCEYAAABWVRKMvv/+ez3yyCNq3769/Pz85Ovrq3bt2umRRx7Rt99+WxW7AAAAcDqHg9H8+fN1yy236O2339bhw4d14cIFXbx4UampqXrrrbd022236fXXX6+KWgEAAJzKoWC0du1aPfHEEyosLNQf/vAHffLJJ/rmm2/0zTff6NNPP9XQoUNVVFSkp556SmvXrq2qmgEAAJzCrqfSfu2ll16SyWTS8uXL9cADD5Rad/PNN+u3v/2tPvzwQw0bNkwvvfSS7r77boeKBQAAcCaHrhjt2bNHkZGRZULRLw0dOlR33HGH9uzZ48iuAAAAnM6hYGQymdSmTZtrtmvTpg0vggQAAC7PoWDUqVMnpaamXrNdamqqOnbs6MiuAAAAnM6hYDRp0iSlpKRo+fLl5bZZsWKFUlJS9NRTTzmyKwAAAKeza/D1iRMnSn2/7bbb9NRTT+mhhx7Shx9+qJiYGLVu3VqSdPToUS1ZskQfffSRnnrqKXXt2rXqqgYAAHACu4JRWFjYFccKGYahjz76SB999NEV17366qt67bXXVFhYWPlKAQAAnMyuYBQSEsIgagAAUGfZFYyOHTvmpDIAAABqnktPIpuSkqLBgwerQYMG8vX1Vbdu3bRy5coKb7927VoNHz5c7du3V4MGDeTj46P27dtr7NixOnz4sBMrBwAAtZFDb752ps2bNysqKkre3t4aPny4/P39tWrVKkVHRys9PV2TJ0++Zh+fffaZdu7cqTvuuEN33323PDw8dODAASUmJur999/XZ599prvuuqsajgYAANQGVRqMzGazLBaLDMO44vqQkJAK9VNYWKhx48bJzc1NW7duVZcuXSRJ06dPV2RkpOLi4jR06FCFhoZetZ+XX35Zb7zxRpnlGzdu1P/8z//or3/9q1JSUipUEwAAqPscDkbnzp3T9OnT9cEHH+j06dPltjOZTBV+Km3Tpk1KS0vTmDFjbKFIkgIDAxUXF6fRo0crMTFR06dPv2o/3t7eV1zev39/BQUF6ciRIxWqBwAAR2RlZSknJ6dS2/r5+alhw4ZVXBHK41AwMpvN6tatm44cOaJ69eqpfv36unDhgpo1a6bMzEwZhiGTyVThK0UlkpOTJUkDBw4ssy4qKkqStGXLlkrXvWPHDp07d069evWqdB8AAFREVlaW4p+ZqPzzZyq1vad/Y8186VXCUTVxKBi9/PLLSk1N1ahRo/Svf/1Ljz76qJYsWaKffvpJFy5c0JIlSxQXF6c+ffooISGhwv2WTDMSERFRZl1wcLD8/PwqNBVJifXr1+vLL79UXl6eUlNT9e9//1uNGzfWP//5z6tul5eXp7y8PNt3i8VS4X0CACBJOTk5yj9/Rn/s6q9mDX3t2jYjK1fvppxRTk4OwaiaOBSMPvnkEzVu3FgLFiyQt7d3qXcc+fj4aMKECercubN69eqlHj16aPz48RXq12w2S7p86+xKAgICbG0qYv369XrllVds32+88UYtX75ct91221W3mz17tmbOnFnh/QAAUJ5mDX0V0sS/Eluer/JaUD6HHtf/4YcfdNttt9nG8pQEo6KiIlubbt26qXv37nrnnXcc2ZVD5s6dK8MwdP78ee3atUvt2rVTz549tWzZsqtuFxsbK7PZbPukp6dXU8UAAKAmOPweo6CgINt/+/j4SLo8IPuXQkJCdPDgwQr3WXKlqLyrQhaLpdyrSVfj5+enyMhIrVmzRu3bt9f48eOvOmDcy8tLAQEBpT4AAKDucigYNW/eXD/99JPte8kg66+//rpUux9++EHu7hW/a1cytuhK44gyMzOVk5NzxfFHFeXu7q5+/fopNzdXu3fvrnQ/AACgbnEoGHXs2FGHDh2yfb/zzjtlGIbi4+N1/vzle6JLly7Vrl27dNNNN1W43z59+ki6PDbo15KSkkq1qayTJ09Kkjw8PBzqBwAA1B0OBaNBgwbp1KlT2rx5sySpe/fu6tmzp7Zv366GDRuqUaNGGjVqlEwmk5555pkK99u/f3+Fh4dr2bJl2r9/v2252WzWrFmz5OnpqZiYGNvyjIwMHTx4sMytt/KuBiUlJemjjz5SgwYN1L17dzuOGAAA1GUOPZU2YsQI3XTTTQoLC7MtW716tcaOHau1a9fq3LlzCgoK0vTp03XPPfdUvCh3dy1atEhRUVHq3bt3qSlBjh8/rrlz55baZ2xsrBITE7V48WKNHj3atrxr1676zW9+o06dOqlly5bKzc3V119/rS+++EIeHh5699135etr36OTAACg7nIoGPn5+alnz56lljVp0kSffPKJLly4ILPZrKZNm8rNzf4LU/369dO2bdsUHx+vFStWqKCgQB07dtScOXMUHR1doT5mzZqlzZs3a8uWLTp9+rTc3NwUEhKi8ePHa+LEierQoYPddQEAgLrLaZPI+vj42J5Sq6zIyEitXbv2mu0SEhKu+ALJ2NhYxcbGOlQDAAC4flRpMMrMzNSPP/4owzDUsmVLNWvWrCq7BwAAtUBtnhuuSoLR22+/rVdeeaXM4/URERF66qmnNGHChKrYDQAAcHG1fW44h4JRcXGxRowYoQ8//FCGYUiSGjVqJEk6e/asDh8+rMcee0yff/65VqxYUamxRgAAoPao7XPDOZRU5s2bpw8++ECNGzfWG2+8IYvFotOnT+v06dOyWCyaN2+ebrjhBq1evVrz5s2rqpoBAICLK5kbzp6PvUHKGRwKRu+88468vLyUnJysP//5z/Lz87Ot8/Pz02OPPaZNmzbJw8NDixYtcrhYAAAAZ3IoGKWmpqpv375Xfey9Q4cO6tevn44cOeLIrgAAAJzOoWDk5+dXahLZ8gQFBZW6mgQAAOCKHApGvXr10q5du1RcXFxum+LiYu3atUs9evRwZFcAAABO51AwmjFjhjIyMjRx4kTl5+eXWV9QUKCJEycqMzNTM2fOdGRXAAAATmfX4/rvvfdemWVjxozR/PnztXr1ag0bNkytW7eWJB09elQffPCBTp48qUceeURfffWVOnfuXDVVAwAAOIFdwWj06NEymUxllhuGoZMnT+q1114rs1yS3nzzTb355puKiYlxoFQAAADnsisYxcTEXDEYAQAA1AV2BaMrTdQKAABQVzBHBwAAgFWVTCJbwjAMnT17VpLUsGFD5kYDAAC1SpUkl40bN2rQoEHy8/NT06ZN1bRpU/n7++vuu+/Wxo0bq2IXAAAATudwMHruuec0cOBArV+/XhcvXpRhGDIMQxcvXlRSUpIGDhyoF154oSpqBQAAcCqHgtHnn3+uGTNmyMPDQ48//rj27dsni8Uii8Wi/fv364knnpCnp6fi4+O1adOmqqoZAADAKRwKRq+//rpMJpM+/vhjvf766+rcubP8/Pzk5+enTp066bXXXtPHH38sSWXecQQAAOBqHApGJXOgRUVFldtm4MCB6tGjh3bs2OHIrgAAAJzOoWCUnZ2t0NDQa7YLDQ2V2Wx2ZFcAAABO51Awaty4sQ4ePHjNdgcPHlTjxo0d2RUAAIDTORSMevbsqX379mnZsmXltnn//fe1d+9e9erVy5FdAQAAOJ1DL3h8+umntXr1asXExGjNmjUaNWqUWrduLUn64YcflJCQoDVr1qhevXqaMmVKlRQMAADgLA4Fo65du2rBggX685//rA8//FCrVq0qtd4wDLm7u2v+/Pnq2rWrQ4UCAAA4m8MveBw3bpz27t2rP/7xjwoPD5eXl5e8vLwUHh6usWPHau/evRo3blxV1AoAAOBUDl0xOnHihEwmk37zm99o0aJFVVUTAABAjXDoilFYWJiGDx9eVbUAAADUKIeuGAUEBNgGWwNwTVlZWcrJyanUtn5+fmrYsGEVVwQArsuhYHTTTTcpPT29qmoBUMWysrI08Zk4ZVkuVGr7hgE+evWlWYQjANcNh4LRuHHjNG7cOKWkpPDUGeCCcnJylGW5oEa3Rsk3qIld2+aeO62ze5OUk5NDMAJw3XAoGI0ZM0b79u3TwIED9fTTT2vIkCEKCwuTl5dXVdUHoAr4BjVRYJNmdm931gm1AIArcygY1atXz/bf06ZN07Rp08ptazKZVFhY6MjuAAAAnMqhYGQYhlPaAgAA1ASHglFxcXFV1QEAAFDjKhWMjhw5otWrV+vYsWPy8vLSLbfcogceeED169ev6voAAC6I10CgrrI7GL366qt65plnVFRUVGr51KlT9dlnn+k3v/lNlRUHAHA9WVlZin9movLPn6nU9p7+jTXzpVcJR3BJdgWjbdu2afLkyTIMQ76+vmrXrp0sFot++OEH/fjjjxoyZIgOHDggNzeHp2ADALionJwc5Z8/oz929Vezhr52bZuRlat3U87wGgi4LLuC0bx582QYhkaNGqV58+bJ1/fy/xBff/21hgwZoiNHjmjdunUaPHiwU4oFALiOZg19FdLEvxJbnq/yWoCqYtelnR07dqhly5ZauHChLRRJUqdOnfTaa6/JMAzt3LmzyosEAACoDnYFo59//lm33367PD09y6zr1auXJOnUqVNVUxkAAEA1sysY5efnq0GDBldcFxAQYGsDAABQGzFKGgAAwMrux/WPHDmi9957r1LrY2Ji7N0dAABAtbE7GG3fvl3bt2+/4jqTyVTuepPJRDACAAAuza5gFBISIpPJ5KxaykhJSVF8fLy+/PJLFRQUqGPHjpo0aZKGDRt2zW0Nw9C6dev0ySefaPv27Tp+/LgKCgoUERGh6OhoTZo0Sd7e3tVwFAAAoLawKxgdO3bMSWWUtXnzZkVFRcnb21vDhw+Xv7+/Vq1apejoaKWnp2vy5MlX3T4vL0+DBw+Wl5eX+vbtq6ioKF26dElJSUl69tlntWbNGiUnJ8vHx6eajggAALg6hyaRdZbCwkKNGzdObm5u2rp1q7p06SJJmj59uiIjIxUXF6ehQ4cqNDS03D7q1aunF154QY899piCgoJsywsKCjRkyBB9+umnmj9/vp5++mlnHw4AAKglXPKptE2bNiktLU0jR460hSJJCgwMVFxcnPLz85WYmHjVPjw8PPTss8+WCkUly2NjYyVJW7ZsqfLaAQBA7eWSV4ySk5MlSQMHDiyzLioqSpJjocbDw0OS5O5+9cPPy8tTXl6e7bvFYqn0PgEAgOtzyStGqampkqSIiIgy64KDg+Xn52drUxnvvvuupCsHr1+aPXu2AgMDbZ9WrVpVep8AAMD1uWQwMpvNki7fOruSgIAAWxt7rV27VgsXLlSHDh00duzYq7aNjY2V2Wy2fdLT0yu1TwAAUDu45K00Z0lJSVF0dLQCAwP1wQcfyMvL66rtvby8rtkGAADUHS55xajkSlF5V4UsFku5V5PKs3v3bg0cOFBubm5KSkrSzTff7HCdAACgbnHJYFQytuhK44gyMzOVk5NzxfFH5dm9e7cGDBig4uJiJSUlqWvXrlVWKwAAqDtcMhj16dNHkrR+/foy65KSkkq1uZaSUFRUVKR169bpjjvuqLpCAQBAneKSwah///4KDw/XsmXLtH//fttys9msWbNmydPTs9S8axkZGTp48GCZW2979uzRgAEDVFhYqLVr16p79+7VdQgAAKAWcsnB1+7u7lq0aJGioqLUu3fvUlOCHD9+XHPnzlVYWJitfWxsrBITE7V48WKNHj1akpSVlaUBAwYoOztbgwYN0oYNG7Rhw4ZS+2nQoIEmTpxYfQcGAABcmksGI0nq16+ftm3bpvj4eK1YscI2ieycOXMUHR19ze0tFovOnTsnSVq3bp3WrVtXpk1oaCjBCAAA2LhsMJKkyMhIrV279prtEhISlJCQUGpZWFiYDMNwUmUAAKAucskxRgAAADWBYAQAAGBFMAIAALAiGAEAAFgRjAAAAKwIRgAAAFYEIwAAACuCEQAAgBXBCAAAwIpgBAAAYEUwAgAAsCIYAQAAWBGMAAAArAhGAAAAVgQjAAAAK4IRAACAFcEIAADAimAEAABgRTACAACwIhgBAABYEYwAAACsCEYAAABWBCMAAAArghEAAIAVwQgAAMCKYAQAAGBFMAIAALAiGAEAAFgRjAAAAKwIRgAAAFYEIwAAACuCEQAAgBXBCAAAwIpgBAAAYEUwAgAAsCIYAQAAWBGMAAAArAhGAAAAVgQjAAAAK4IRAACAFcEIAADAimAEAABgRTACAACwIhgBAABYuXQwSklJ0eDBg9WgQQP5+vqqW7duWrlyZYW3T0tL04wZM3TvvfeqRYsWMplMCgsLc17BAACgVnOv6QLKs3nzZkVFRcnb21vDhw+Xv7+/Vq1apejoaKWnp2vy5MnX7OOLL77QzJkzVa9ePXXo0EGZmZnVUDkAAKitXPKKUWFhocaNGyc3Nzdt3bpVb731ll555RV99dVXatu2reLi4nT8+PFr9tO7d2/t2LFD58+f1zfffCMPD49qqB4AANRWLhmMNm3apLS0NI0cOVJdunSxLQ8MDFRcXJzy8/OVmJh4zX7Cw8PVrVs31a9f34nVAgCAusIlg1FycrIkaeDAgWXWRUVFSZK2bNlSnSUBAIDrgEuOMUpNTZUkRURElFkXHBwsPz8/WxtnysvLU15enu27xWJx+j4B1JysrCzl5ORUals/Pz81bNiwiisCUN1cMhiZzWZJl2+dXUlAQICtjTPNnj1bM2fOdPp+ANS8rKwsTXwmTlmWC5XavmGAj159aRbhCKjlXDIYuYrY2FhNmjTJ9t1isahVq1Y1WBEAZ8nJyVGW5YIa3Rol36Amdm2be+60zu5NUk5ODsEIqOVcMhiVXCkq76qQxWJRUFCQ0+vw8vKSl5eX0/cDwDXk5+ep2DDs3q7YMJSfn3fthgBcnksGo5KxRampqbrttttKrcvMzFROTo4iIyNrojQAdVR2drZ+OrBbF08dlbunff8gKszPU9bZs8rOzlZISIiTKgRQHVwyGPXp00ezZ8/W+vXrNXz48FLrkpKSbG0AoKrk5uaqvvL00K2+Cm5s3xXpzDPn9PaGk8rNzXVSdQCqi0sGo/79+ys8PFzLli3Tk08+aXuXkdls1qxZs+Tp6amYmBhb+4yMDJnNZjVr1qzcAdsAUBGN/L0V3NDXrm0K8i46qRoA1c0lg5G7u7sWLVqkqKgo9e7du9SUIMePH9fcuXNLzXkWGxurxMRELV68WKNHj7YtP3PmjKZMmWL7XlBQoDNnzpRqM3fuXDVu3LgajgoAALg6lwxGktSvXz9t27ZN8fHxWrFihQoKCtSxY0fNmTNH0dHRFeojJyenzBuyc3NzSy2bMWMGwQgAAEhy4WAkSZGRkVq7du012yUkJCghIaHM8rCwMBmVeMIEAABcn1xyShAAAICa4NJXjAA4Lj8/T+ezTtm93fmsU7ybB8B1h2AE1GG8mwcA7EMwAuow3s0DAPYhGAHXAd7NAwAVw+BrAAAAK4IRAACAFcEIAADAimAEAABgRTACAACwIhgBAABYEYwAAACsCEYAAABWBCMAAAAr3nwNALBbQUG+cnJzdb6+ya7tcnJzVVCQ76SqAMcRjAAAdsnOztaBQ6lKafCjjvt72rXtqfP5OnDoIpMTw2URjAAAdsnNzVVBYZG8gprLr6l9kxObfz6ngsLDTE4Ml0UwAgBUirunlzy9fezc5oKTqgGqBoOvAQAArAhGAAAAVgQjAAAAK4IRAACAFcEIAADAimAEAABgRTACAACwIhgBAABYEYwAAACsCEYAAABWBCMAAAArghEAAIAVwQgAAMCKYAQAAGBFMAIAALAiGAEAAFgRjAAAAKwIRgAAAFYEIwAAACuCEQAAgBXBCAAAwIpgBAAAYEUwAgAAsCIYAQAAWLnXdAH4r/z8PJ3POmX3duezTik/P88JFQEAcH0hGLmI7Oxs/XRgty6eOip3Ty+7ti3Mz1PW2bPKzs5WSEiIkyoEAFRWQUG+cnJzdb6+ya7tcnJzVVCQ76SqcCUEIxeRm5ur+srTQ7f6KrhxkF3bZp45p7c3nFRubq6TqgMAVFZ2drYOHEpVSoMfddzf065tT53P14FDF/mHbzVy6WCUkpKi+Ph4ffnllyooKFDHjh01adIkDRs2rMJ95OXlac6cOVqyZInS09PVsGFD/e53v9MLL7ygG264wYnVV04jf28FN/S1a5uCvItOqgYA4Kjc3FwVFBbJK6i5/Jra9w9f88/nVFB4mH/4ViOXDUabN29WVFSUvL29NXz4cPn7+2vVqlWKjo5Wenq6Jk+efM0+iouLdd999ykpKUndunXTkCFDlJqaqkWLFmnjxo3auXOnmjRpUg1HAwC43rl7esnT28fObS44qRrnqs23Dl0yGBUWFmrcuHFyc3PT1q1b1aVLF0nS9OnTFRkZqbi4OA0dOlShoaFX7ScxMVFJSUkaMWKE3n//fZlMl/+A3nzzTT366KOaOnWqFi5c6OzDAQDgulHbbx265OP6mzZtUlpamkaOHGkLRZIUGBiouLg45efnKzEx8Zr9vP3225Kk2bNn20KRJE2YMEHh4eF6//33dfEit6EAAKgqpW4dtoiw6+MV1FwFhUU1euvQJYNRcnKyJGngwIFl1kVFRUmStmzZctU+Ll26pF27dqldu3ZlriyZTCYNGDBAubm52r17d9UUDQAAbEpuHdrzsfepbKfUXdMFXElqaqokKSIiosy64OBg+fn52dqUJy0tTcXFxVfs45d9p6am6s4777xim7y8POXl/ff9QGazWZJksViufRB2ys3NVVFRsY5nZOlCXqFd257OsigvP1//+c9/GKCHUr777jvlFxbwc1UBnKuK41zZ53o7X44eb1FRsXJzc6v0d21JX4ZhXLux4YIGDBhgSDJSU1OvuL558+ZGQEDAVfvYvn27Icl48MEHr7j+rbfeMiQZ//jHP8rtIz4+3pDEhw8fPnz48KkDn/T09GtmEJe8YuQqYmNjNWnSJNv34uJiZWVlqVGjRqXGLOHaLBaLWrVqpfT0dAUEBNR0OdcNznvN4LzXDM57zagN590wDJ0/f17Nmze/ZluXDEaBgYGS/nvr6tcsFouCgq7+LoiK9PHLdlfi5eUlL6/S9zsbNGhw1f3i6gICAlz2f5y6jPNeMzjvNYPzXjNc/bxf7ff9L7nk4Otfjv/5tczMTOXk5JQ7dqhEeHi43Nzcyh2LdLVxTAAA4PrkksGoT58+kqT169eXWZeUlFSqTXnq16+vyMhIHTp0SMePHy+1zjAMbdiwQb6+vrr99turqGoAAFDbuWQw6t+/v8LDw7Vs2TLt37/fttxsNmvWrFny9PRUTEyMbXlGRoYOHjxY5rbZ+PHjJV0eK2T8YiT6woUL9cMPP+jBBx9U/fr1nXswkHT5tmR8fHyZW5NwLs57zeC81wzOe82oa+fdZBgVeXat+pU3Jcjx48c1d+7cUlOCjB49WomJiVq8eLFGjx5tW15cXKzBgwfbpgTp06ePjhw5otWrVyssLEy7du1iShAAAGDjkleMJKlfv37atm2bevbsqRUrVmjBggVq2rSpli9fXqF50iTJzc1NH3/8sWbMmKHTp0/rn//8p7Zv366xY8dqx44dhCIAAFCKy14xAgAAqG4ue8UIAACguhGMAAAArAhGcNj+/fsVFxenqKgoNWnSRCaTSX379i23/bFjx2Qymcr9zJgx44rbZWRkaOzYsWrWrJm8vb3Vrl07/f3vf1dBQYFzDqwWsPfcl3j//fcVGRkpX19fBQUF6Xe/+5327t1bbvuUlBQNHjxYDRo0kK+vr7p166aVK1dW4ZHUDTNmzLjqz/axY8euuF1SUpL69Okjf39/BQQEqF+/ftq4cWP1Fl+L8fPpPGFhYeX+PF/p75q8vDw999xzioiIkLe3t5o3b67x48fr1KlT1V98Jbnkm69Ru6xZs0azZ8+Wp6en2rZtqzNnzlRou86dO+v3v/99meVX+p8tMzNTd9xxh3788Ufdf//9ioiI0JYtWzR16lT95z//0Zo1a67LaVoqc+7//ve/a+rUqQoNDdUjjzyi8+fPa/ny5erRo4c2btyonj17lmpf3hOi0dHRSk9Pr/DDENeTUaNGKSwsrMzyK705f+nSpXr44YfVpEkT21O1K1as0IABA7Ry5UoNHTrUucXWcvx8Ol9gYKAmTpxYZvmvf8aLi4t133332Z4EHzJkiFJTU7Vo0SJt3LhRO3furB0PPV1zNjXgGr799ltjz549Rn5+vpGRkWFIMvr06VNu+6NHjxqSjFGjRlV4HzExMYYkY8GCBbZlxcXFxvDhww1JxrJlyxw4gtrL3nN/+PBhw93d3Wjbtq2RnZ1tW75v3z7Dy8vL6NChg1FUVGRbXlBQYLRp08bw8vIy9u3bZ1uenZ1ttG3b1vD09DSOHTvmjEOrlUomnt68eXOF2mdlZRkNGjQwGjduXGpyy/T0dKNx48ZG48aNDYvF4qRqaz9+Pp0vNDTUCA0NrVDbd99915BkjBgxwiguLrYtX7BggSHJGD9+vJOqrFrcSoPDbr75Zt16663y8PBwSv/nz5/XihUrFB4ergkTJtiWm0wmvfjii5Kkt99+2yn7dnX2nvvFixersLBQzz77bKl5g7p06aIRI0bowIED2rZtm235pk2blJaWppEjR6pLly625YGBgYqLi1N+fr4SExOr7HiuNx988IGys7P1xBNPqGXLlrblLVu21OOPP64zZ87oo48+qsEKXRs/n66l5O/h2bNnl7qCP2HCBIWHh+v999/XxYsXa6q8CiMYocacPHlS8+fP16xZs/TOO+8oLS3tiu127NihvLw8DRgwoMztstDQULVr107bt29XUVFRdZRdqyUnJ0uSBg4cWGZdVFSUJGnLli2Vbo/Ltm7dqjlz5ujll1/WmjVrlJOTc8V2nF/HcP6qR15enhISEjRr1izNmzdPu3btKtPm0qVL2rVrl9q1a6fQ0NBS60wmkwYMGKDc3Fzt3r27usquNMYYocZs2LBBGzZssH03mUx68MEH9eabb8rX19e2/FoT/kZERNjmxAsPD3du0bVcamqq/Pz8FBwcXGbdlSZvvtq5Dw4Olp+fX7kTNV/P4uPjS31v0KCBXnvttVJTGUlXP79Xm0wbl/HzWT0yMzM1ZsyYUsu6du2q//3f/1WbNm0kSWlpaSouLr7q39PS5T+zO++807kFO4grRqh2Pj4+mjZtmvbs2aPs7GxlZWXp888/V2RkpJYuXVrml0fJHHi/vPXzSwEBAaXaoXxms9mu81iRc895/6/OnTvr3Xff1Q8//KCLFy/q6NGjeuONN2QymTR69Gh98sknpdpf7fzyc31t/Hw635gxY7Rx40b9/PPPys3N1b59+/Twww8rJSVF/fv31/nz5yXVrb+nuWIESdLkyZOVl5dX4fZ/+ctfyv2XwbXccMMNeu6550ot69+/v7p3765bb71Vq1ev1t69e3XrrbdWqv/apjrPPa7NkT+P+++/v9S6sLAwPf744+rQoYMGDBigqVOn6t57763SegFn+vXVzy5duui9996TJC1ZskRvv/22Jk2aVBOlOQ3BCJKkhQsXKjc3t8Lthw4dWuW/nH18fPTwww9r6tSp2r59uy0YlfwLpLx/aVgsllLtapvqPPeBgYF2nceKnPugoKBK1eKqnPHn0b9/f7Vp00bffPONLBaL7V/Pvzy/jRo1KrVNbf+5rg7X48+nq5gwYYKWLFmi7du3a9KkSXXq72lupUGSlJOTI8MwKvypyEsEK6Nx48aSVOoX07XGWqSmpsrT01MhISFOqcnZqvPcR0REKCcnR5mZmWXWXWm8xtXOfWZmpnJycurc1Stn/XmU/GxfuHDBtuxq5/daY+twff58uopf/10dHh4uNze3q/49LdWOn2eCEVxKydMOv3xxWLdu3eTp6akNGzbI+NWcx8ePH9ehQ4fUs2dPubtzAfRa+vTpI0lav359mXVJSUml2lSmPa4sNzdX3333nXx9fW2/UCTOr6M4fzXn139X169fX5GRkbYHYX7JMAxt2LBBvr6+uv3226u7VPs5+T1JuM5U5CWDe/fuLfXyrxKrVq0y3NzcjKCgoFIvHzSM8l/wOGLEiOv6BY+/VJFzf+jQIbtf8BgeHn7VF+gdPXrUCUdT+1gsFuPQoUNlll+4cMH2czpmzJhS67KysozAwEBe8FhJ/Hw614EDB4zc3NwrLg8ODjYkGVu2bLEtrysveDQZxq/+CQ7Y6eDBg7YXLV68eFErV65U06ZNNWjQIFubhIQE23/37dtXaWlp6t69u1q2bKmioiLt3btX27Ztk5eXl1auXFlmgGpGRoZtSpA//OEPuvHGG7Vlyxbt3LlT99xzjz7++OPrckoQe8+9VHpKkCFDhtimBMnPz7drSpDjx49r7ty5TLlgdezYMYWHh6tr167q0KGDgoOD9fPPP+vzzz/Xjz/+qI4dO2rz5s1lxhL9ckqQ6OhoSZenBDlz5oxWrFihBx54oCYOp9bg59N5ZsyYoX/84x/q3bu3QkND5evrq8OHD+uzzz5TQUGBYmNjNWvWLFv74uJiDR482DYlSJ8+fXTkyBGtXr1aYWFh2rVrF1OC4PqwefNmQ9JVP7/09ttvG4MGDTJatWpl1K9f3/Dy8jLCw8ONP/3pT8aBAwfK3c/JkyeNP/7xj0bTpk0NT09PIyIiwnj++eeNvLw8Zx+iy7L33JdYunSpcfvttxv169c3AgMDjcGDBxt79uwpdz+7du0yBg0aZAQEBBj169c3IiMjjeXLlzvrsGols9ls/PnPfza6du1qNGnSxHB3dzf8/f2NyMhI46WXXjIuXLhQ7rZr16417rzzTsPX19fw8/Mz+vTpY2zYsKEaq6/d+Pl0juTkZGPYsGFGRESEERAQYLi7uxvBwcHGfffdZyQlJV1xm0uXLhkzZsww2rRpY3h6ehrBwcHGn/70JyMzM7Oaq688rhgBAABYMfgaAADAimAEAABgRTACAACwIhgBAABYEYwAAACsCEYAAABWBCMAAAArghEAAIAVwQgAAMCKYAQAAGBFMAKAKpCQkCCTyaTRo0fXdCkAHEAwAgAAsCIYAQAAWBGMANRaFy5c0KuvvqpevXopKChIXl5eCg0N1T333KNly5aVafviiy/q1ltvlb+/v3x8fHTzzTdr6tSpOnfu3BX737Nnj6Kjo9WyZUt5enoqICBA4eHhGjJkiD7++GNbu7CwMI0ZM0aSlJiYKJPJZPv07dvXaccPoOqZDMMwaroIALBXenq6Bg0apO+//14+Pj7q2bOnGjVqpJ9++klff/21GjRooGPHjkmSsrKy1L9/f+3fv18BAQHq27evPDw8tGXLFp05c0atW7fWpk2bFBYWZut/48aNuvvuu1VQUKDOnTsrIiJCRUVF+umnn/TVV19p0KBBWrNmjSRpypQp2rlzp7Zv3642bdqoV69etn7at2+vv/3tb9V4ZgA4xACAWqaoqMi4/fbbDUnGwIEDjVOnTpVaf/HiReP//u//bN+jo6MNScYdd9xhnDlzxrb8/Pnzxt13321IMnr06FGqj379+hmSjKVLl5bZf3Z2trFjx45SyxYvXmxIMkaNGlUFRwigpnArDUCt8+mnn2r37t1q1qyZVq1apSZNmpRa7+3trcGDB0uSTpw4oQ8++EAmk0lvvfWWGjVqZGvn5+ent99+W97e3vryyy/15Zdf2tb9/PPPkmTr55cCAwPVrVs3ZxwagBpGMAJQ66xbt06SNHLkSPn5+V217datW1VcXKxbbrlFnTp1KrO+RYsWioqKkiRt3rzZtjwyMlKS9OCDD2rbtm0qLCysqvIBuDCCEYBa5/jx45Iuj9+5lp9++kmS1Lp163LbtGnTplRbSZo9e7ZuvfVWrV27VnfeeacCAgLUq1cvTZ06VQcOHHCkfAAujGAEAFcQHBys3bt3a/PmzXr22Wd1xx13aO/evfr73/+um2++WXPmzKnpEgE4AcEIQK0TEhIiSTp48OA127Zo0UKS9MMPP5TbpmRdSdsSJY/bv/DCC9q8ebOysrK0YMECmUwmxcXFKS0trbKHAMBFEYwA1DqDBg2SJP3v//6vcnNzr9q2d+/ecnNz0/79+/XVV1+VWZ+RkWEbs9SvX7+r9uXt7a1HHnlEnTp1UnFxsb7++mvbOk9PT0liLBJQyxGMANQ69957r2655RadPHlSDzzwgM6ePVtq/aVLl7R27VpJl68uPfDAAzIMQxMmTCjVNjc3V+PHj9elS5fUo0cP9ejRw7Zu7ty5OnHiRJl9Hzx4UKmpqZKk0NBQ2/KWLVtKkr7//vuqO1AA1Y4XPAKolY4fP66oqCgdOnRIPj4+6tWrl+0Fj1999VWpFzyePXtW/fv311dffaXAwED169dP7u7u2rJli06fPn3FFzw2aNBAZrNZ7du3V4cOHVS/fn2dPHnS9oRaTEyMEhMTbe3z8/PVunVrnTx5Urfccos6duwoDw8PtWvXTk8//XQ1nx0AlUUwAlBr5eTk6F//+pc+/PBDHTx4UPn5+QoODlbnzp01cuRIRUdH29peuHBBr7/+ulasWKHDhw+ruLhYrVu31v33368pU6YoKCioVN/vv/++Nm7cqJSUFJ08eVK5ubkKDg7WTTfdpPHjx+u+++6TyWQqtc23336rZ599Vjt27NDZs2dVXFysPn36KDk5uTpOB4AqQDACAACwYowRAACAFcEIAADAimAEAABgRTACAACwIhgBAABYEYwAAACsCEYAAABWBCMAAAArghEAAIAVwQgAAMCKYAQAAGBFMAIAALD6f3zcGa69KPCtAAAAAElFTkSuQmCC", "text/plain": [ - "array([[]], dtype=object)" + "
" ] }, - "execution_count": 11, "metadata": {}, - "output_type": "execute_result" - }, + "output_type": "display_data" + } + ], + "source": [ + "optimization_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=30,\n", + " edgecolor=\"black\",\n", + " weights=optimization_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"optimized\",\n", + ")\n", + "uniform_result[\"cost\"].plot(\n", + " kind=\"hist\",\n", + " bins=30,\n", + " edgecolor=\"black\",\n", + " weights=uniform_result[\"probability\"],\n", + " alpha=0.6,\n", + " label=\"uniform\",\n", + ")\n", + "plt.legend()\n", + "plt.ylabel(\"Probability\", fontsize=16)\n", + "plt.xlabel(\"cost\", fontsize=16)\n", + "plt.tick_params(axis=\"both\", labelsize=14)" + ] + }, + { + "cell_type": "markdown", + "id": "06d70826-8ba1-4705-ae87-1a3c4ba5d69a", + "metadata": {}, + "source": [ + "Best Solution:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "1b2775b1-7b12-4a0a-9931-eacdee4e5127", + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "{'z': [0, 0, 0, 0, 0, 0]}" ] }, + "execution_count": 13, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "optimization_result.hist(\"cost\", weights=optimization_result[\"probability\"])" + "optimization_result.sort_values(by=\"cost\").iloc[0].solution" ] }, { @@ -518,7 +501,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.4" }, "vscode": { "interpreter": { diff --git a/applications/physical_systems/ising_model/ising_model.qmod b/applications/physical_systems/ising_model/ising_model.qmod index aeea9aad6..b2e4dca01 100644 --- a/applications/physical_systems/ising_model/ising_model.qmod +++ b/applications/physical_systems/ising_model/ising_model.qmod @@ -1,155 +1,14 @@ -hamiltonian: PauliTerm[] = [ - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-20.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I - ], - coefficient=-20.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-20.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-20.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-20.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-20.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z - ], - coefficient=-10.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z - ], - coefficient=-10.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I - ], - coefficient=-10.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I - ], - coefficient=-10.0 - }, - PauliTerm { - pauli=[ - Pauli::I, - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-10.0 - }, - PauliTerm { - pauli=[ - Pauli::Z, - Pauli::Z, - Pauli::I, - Pauli::I, - Pauli::I, - Pauli::I - ], - coefficient=-10.0 - } -]; - -qfunc main(params_list: real[10], output target: qbit[6]) { - allocate(target.len, target); - qaoa_penalty(target.len, params_list, hamiltonian, target); +qstruct QAOAVars { + z: qbit[6]; } -cscope ``` -vqe_result = vqe( -hamiltonian=hamiltonian, -maximize=False, -initial_point=[0.0, 0.027272727272727275, 0.006818181818181819, 0.020454545454545454, 0.013636363636363637, 0.013636363636363637, 0.020454545454545454, 0.006818181818181819, 0.027272727272727275, 0.0], -optimizer=Optimizer.COBYLA, -max_iteration=100, -tolerance=0.0, -step_size=0.0, -skip_compute_variance=False, -alpha_cvar=0.7 -) - -save({"vqe_result": vqe_result, "hamiltonian": hamiltonian}) -``` +qfunc main(params: real[10], output v: QAOAVars) { + allocate(v.size, v); + hadamard_transform(v); + repeat (i: 5) { + phase (-(((((((((((((40.0 * v.z[0]) + (40.0 * v.z[1])) + (40.0 * v.z[2])) + (40.0 * v.z[3])) + (40.0 * v.z[4])) + (40.0 * v.z[5])) + ((10 - (20 * v.z[0])) * ((2 * v.z[1]) - 1))) + ((10 - (20 * v.z[0])) * ((2 * v.z[5]) - 1))) + ((10 - (20 * v.z[1])) * ((2 * v.z[2]) - 1))) + ((10 - (20 * v.z[2])) * ((2 * v.z[3]) - 1))) + ((10 - (20 * v.z[3])) * ((2 * v.z[4]) - 1))) + ((10 - (20 * v.z[4])) * ((2 * v.z[5]) - 1))) - 120.0), params[i]); + apply_to_all(lambda(q) { + RX(params[5 + i], q); + }, v); + } +} diff --git a/applications/physical_systems/ising_model/ising_model.synthesis_options.json b/applications/physical_systems/ising_model/ising_model.synthesis_options.json index 0967ef424..ba1113e93 100644 --- a/applications/physical_systems/ising_model/ising_model.synthesis_options.json +++ b/applications/physical_systems/ising_model/ising_model.synthesis_options.json @@ -1 +1,43 @@ -{} +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "rz", + "cx", + "h", + "u1", + "r", + "sx", + "s", + "rx", + "y", + "cy", + "tdg", + "ry", + "u2", + "u", + "x", + "cz", + "z", + "sxdg", + "sdg", + "t", + "p", + "id" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "auto optimize", + "timeout_seconds": 300, + "random_seed": -1 + } +} diff --git a/built_in_apps/option_pricing/option_pricing.ipynb b/built_in_apps/option_pricing/application_option_pricing.ipynb similarity index 99% rename from built_in_apps/option_pricing/option_pricing.ipynb rename to built_in_apps/option_pricing/application_option_pricing.ipynb index ace23709e..762e4dff5 100644 --- a/built_in_apps/option_pricing/option_pricing.ipynb +++ b/built_in_apps/option_pricing/application_option_pricing.ipynb @@ -165,7 +165,7 @@ }, "outputs": [], "source": [ - "write_qmod(qmod, \"option_pricing\")" + "write_qmod(qmod, \"application_option_pricing\")" ] }, { diff --git a/built_in_apps/option_pricing/option_pricing.metadata.json b/built_in_apps/option_pricing/application_option_pricing.metadata.json similarity index 100% rename from built_in_apps/option_pricing/option_pricing.metadata.json rename to built_in_apps/option_pricing/application_option_pricing.metadata.json diff --git a/built_in_apps/option_pricing/option_pricing.qmod b/built_in_apps/option_pricing/application_option_pricing.qmod similarity index 100% rename from built_in_apps/option_pricing/option_pricing.qmod rename to built_in_apps/option_pricing/application_option_pricing.qmod diff --git a/applications/optimization/knapsack_binary/knapsack_binary.synthesis_options.json b/built_in_apps/option_pricing/application_option_pricing.synthesis_options.json similarity index 100% rename from applications/optimization/knapsack_binary/knapsack_binary.synthesis_options.json rename to built_in_apps/option_pricing/application_option_pricing.synthesis_options.json diff --git a/community/QClass_2024/Submissions/HW4/Hisham_Mansour_HW4_qpe_for_molecules.ipynb b/community/QClass_2024/Submissions/HW4/Hisham_Mansour_HW4_qpe_for_molecules.ipynb index df5cc39bf..4108a8bdf 100644 --- a/community/QClass_2024/Submissions/HW4/Hisham_Mansour_HW4_qpe_for_molecules.ipynb +++ b/community/QClass_2024/Submissions/HW4/Hisham_Mansour_HW4_qpe_for_molecules.ipynb @@ -864,28 +864,7 @@ }, "outputs": [], "source": [ - "from classiq import molecule_problem_to_qmod\n", - "from classiq.qmod import (\n", - " CInt,\n", - " Output,\n", - " QArray,\n", - " QBit,\n", - " QCallable,\n", - " QNum,\n", - " allocate,\n", - " allocate_num,\n", - " control,\n", - " invert,\n", - " qfunc,\n", - " repeat,\n", - ")\n", - "from classiq.qmod.builtins import (\n", - " H,\n", - " apply_to_all,\n", - " exponentiation_with_depth_constraint,\n", - " molecule_hartree_fock,\n", - " qft,\n", - ")\n", + "from classiq import *\n", "from classiq.qmod.symbolic import log, pi\n", "\n", "# this constant will be multipled be a linear factor for each qbit of the qpe, so the\n", @@ -1410,19 +1389,6 @@ "plt.show()" ] }, - { - "cell_type": "markdown", - "id": "9797b512-d41f-47c1-8c0f-4134f0500b80", - "metadata": { - "id": "9797b512-d41f-47c1-8c0f-4134f0500b80" - }, - "source": [ - "## References\n", - "\n", - "[1]: [Michael A. Nielsen and Isaac L. Chuang. 2011. Quantum Computation and Quantum Information: 10th Anniversary Edition, Cambridge University Press, New York, NY, USA.\n", - "](http://mmrc.amss.cas.cn/tlb/201702/W020170224608149940643.pdf)\n" - ] - }, { "cell_type": "markdown", "id": "ttDDvHfPDI4y", diff --git a/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.ipynb b/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/hamiltonian_evolution_exponentiation.ipynb similarity index 98% rename from functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.ipynb rename to functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/hamiltonian_evolution_exponentiation.ipynb index 9f898d515..dd6d57046 100644 --- a/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.ipynb +++ b/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/hamiltonian_evolution_exponentiation.ipynb @@ -96,7 +96,7 @@ " )\n", "\n", "\n", - "qmod = create_model(main, out_file=\"exponentiation\")\n", + "qmod = create_model(main, out_file=\"hamiltonian_evolution_exponentiation\")\n", "qprog = synthesize(qmod)" ] }, diff --git a/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.metadata.json b/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/hamiltonian_evolution_exponentiation.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.metadata.json rename to functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/hamiltonian_evolution_exponentiation.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.qmod b/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/hamiltonian_evolution_exponentiation.qmod similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.qmod rename to functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/hamiltonian_evolution_exponentiation.qmod diff --git a/built_in_apps/option_pricing/option_pricing.synthesis_options.json b/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/hamiltonian_evolution_exponentiation.synthesis_options.json similarity index 100% rename from built_in_apps/option_pricing/option_pricing.synthesis_options.json rename to functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/hamiltonian_evolution_exponentiation.synthesis_options.json diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.metadata.json b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_amplitudes.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.metadata.json rename to functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_amplitudes.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.qmod b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_amplitudes.qmod similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.qmod rename to functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_amplitudes.qmod diff --git a/functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.synthesis_options.json b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_amplitudes.synthesis_options.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.synthesis_options.json rename to functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_amplitudes.synthesis_options.json diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.metadata.json b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_state.metadata.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.metadata.json rename to functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_state.metadata.json diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.qmod b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_state.qmod similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.qmod rename to functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_state.qmod diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.synthesis_options.json b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_state.synthesis_options.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.synthesis_options.json rename to functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/example_prepare_state.synthesis_options.json diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state_and_amplitudes.ipynb b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state_and_amplitudes.ipynb index 749d2aad1..e8f3788b1 100644 --- a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state_and_amplitudes.ipynb +++ b/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state_and_amplitudes.ipynb @@ -129,7 +129,7 @@ " prepare_state(probabilities=probabilities, bound=0.01, out=x)\n", "\n", "\n", - "qmod = create_model(main, out_file=\"prepare_state\")" + "qmod = create_model(main, out_file=\"example_prepare_state\")" ] }, { @@ -211,7 +211,7 @@ " num_shots=1,\n", " backend_preferences=ClassiqBackendPreferences(backend_name=\"simulator_statevector\"),\n", ")\n", - "write_qmod(qmod, \"prepare_amplitudes\", decimal_precision=15)" + "write_qmod(qmod, \"example_prepare_amplitudes\", decimal_precision=15)" ] }, { diff --git a/requirements_tests.txt b/requirements_tests.txt index 54d71fdd5..c16ed58b1 100644 --- a/requirements_tests.txt +++ b/requirements_tests.txt @@ -1,7 +1,8 @@ pytest testbook - torch torchvision galois +cvxpy +pyqsp==0.1.6 diff --git a/tests/internal/test_notebook_timeouts.py b/tests/internal/test_notebook_timeouts.py index 70aa64dd5..75a4dd125 100644 --- a/tests/internal/test_notebook_timeouts.py +++ b/tests/internal/test_notebook_timeouts.py @@ -39,7 +39,7 @@ def test_notebook_timeouts(timeouts: dict[str, float]) -> None: relative_path = file_path.relative_to(ROOT) if _can_skip(relative_path): continue - if str(relative_path) not in timeouts: + if relative_path.name not in timeouts: missing_notebooks.append(file_path) assert ( @@ -50,8 +50,7 @@ def test_notebook_timeouts(timeouts: dict[str, float]) -> None: def test_unused_timeouts(timeouts: dict[str, float]) -> None: unused_timeouts: list[str] = [] for notebook in timeouts: - full_notebook_path = ROOT / notebook - if not full_notebook_path.exists(): + if not list(ROOT.rglob(notebook)): unused_timeouts.append(notebook) assert ( diff --git a/tests/internal/test_notebook_unique_name.py b/tests/internal/test_notebook_unique_name.py new file mode 100644 index 000000000..5c58620a5 --- /dev/null +++ b/tests/internal/test_notebook_unique_name.py @@ -0,0 +1,22 @@ +from collections import Counter +from pathlib import Path +from typing import Iterable + +ROOT = Path(__file__).parents[2] + + +def test_unique_notebook_name(): + all_notebooks = ROOT.rglob("*.ipynb") + assert not duplicate_base_names(all_notebooks) + + +def test_unique_qmod_name(): + all_qmods = ROOT.rglob("*.qmod") + # exclude `functions/` + qmods = [path for path in all_qmods if "functions" not in path.parts] + assert not duplicate_base_names(qmods) + + +def duplicate_base_names(files: Iterable[Path]) -> bool: + base_names = [f.name for f in files] + return [name for name, count in Counter(base_names).items() if count > 1] diff --git a/tests/resources/timeouts.yaml b/tests/resources/timeouts.yaml index 1f2ad0289..a9ee07abb 100644 --- a/tests/resources/timeouts.yaml +++ b/tests/resources/timeouts.yaml @@ -1,329 +1,337 @@ -algorithms/dqi/dqi_max_xorsat.ipynb: 200 -algorithms/dqi/dqi_max_xorsat.qmod: 200 -algorithms/algebraic/discrete_log/discrete_log.ipynb: 600 -algorithms/algebraic/discrete_log/discrete_log.qmod: 300 -algorithms/algebraic/discrete_log/discrete_log_large.qmod: 600 -algorithms/algebraic/hidden_shift/hidden_shift.ipynb: 272 -algorithms/algebraic/hidden_shift/hidden_shift_complex.qmod: 100 -algorithms/algebraic/hidden_shift/hidden_shift_no_dual.qmod: 92 -algorithms/algebraic/hidden_shift/hidden_shift_simple.qmod: 20 -algorithms/algebraic/shor/doubly_controlled_modular_adder.qmod: 100 -algorithms/algebraic/shor/shor.ipynb: 104 -algorithms/algebraic/shor/shor.qmod: 88 -algorithms/algebraic/shor/shor_modular_exponentiation.ipynb: 300 -algorithms/algebraic/shor/shor_modular_exponentiation.qmod: 300 -algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.ipynb: 176 -algorithms/amplitude_estimation/qmc_user_defined/qmc_user_defined.qmod: 136 -algorithms/amplitude_estimation/quantum_counting/quantum_counting.ipynb: 300 -algorithms/amplitude_estimation/quantum_counting/quantum_counting_iqae.qmod: 200 -algorithms/amplitude_estimation/quantum_counting/quantum_counting_qpe.qmod: 200 -algorithms/bernstein_vazirani/bernstein_vazirani.ipynb: 32 -algorithms/bernstein_vazirani/bernstein_vazirani_example.qmod: 32 -algorithms/deutsch_jozsa/complex_deutsch_jozsa.qmod: 32 -algorithms/deutsch_jozsa/deutsch_jozsa.ipynb: 48 -algorithms/deutsch_jozsa/simple_deutsch_jozsa.qmod: 16 -algorithms/differential_equations/discrete_poisson_solver/discrete_poisson_solver.ipynb: 300 -algorithms/differential_equations/discrete_poisson_solver/discrete_poisson_solver.qmod: 300 -algorithms/differential_equations/hhl_jungle/hhl_jungle.ipynb: 450 -algorithms/grover/3_sat_grover/3_sat_grover.ipynb: 36 -algorithms/grover/3_sat_grover/3_sat_grover.qmod: 48 -algorithms/grover/3_sat_grover/3_sat_grover_large.qmod: 10 -algorithms/grover/grover_max_cut/grover_max_cut.ipynb: 220 -algorithms/grover/grover_max_cut/grover_max_cut.qmod: 188 -algorithms/hhl/hhl/hhl.ipynb: 312 -algorithms/hhl/hhl/hhl_exact.qmod: 100 -algorithms/hhl/hhl/hhl_trotter.qmod: 100 -algorithms/oblivious_amplitude_amplification/oblivious_amplitude_amplification.ipynb: 20 -algorithms/oblivious_amplitude_amplification/oblivious_amplitude_amplification.qmod: 10 -algorithms/qml/hybrid_qnn/hybrid_qnn_for_subset_majority.ipynb: 120 -algorithms/qml/qgan/qgan_bars_and_strips.ipynb: 360 -algorithms/qml/qsvm/qsvm.ipynb: 204 -algorithms/qml/qsvm/qsvm.qmod: 104 -algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.ipynb: 68 -algorithms/qml/qsvm_pauli_feature_map/qsvm_pauli_feature_map.qmod: 60 -algorithms/qml/quantum_autoencoder/quantum_autoencoder.ipynb: 120 -algorithms/qpe/qpe_for_matrix/qpe_for_matrix.ipynb: 748 -algorithms/qpe/qpe_for_matrix/qpe_for_matrix.qmod: 760 -algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.ipynb: 376 -algorithms/qsvt/qsvt_fixed_point_amplitude_amplification/qsvt_fixed_point_amplitude_amplification.qmod: 340 -algorithms/qsvt/qsvt_matrix_inversion/qsvt_matrix_inversion.ipynb: 180 -algorithms/qsvt/qsvt_matrix_inversion/qsvt_matrix_inversion.qmod: 156 -algorithms/simon/simon.ipynb: 40 -algorithms/simon/simon_example.qmod: 30 -algorithms/simon/simon_shallow_example.qmod: 20 -algorithms/swap_test/swap_test.ipynb: 40 -algorithms/swap_test/swap_test.qmod: 40 -algorithms/vqls/lcu_vqls/vqls_with_lcu.ipynb: 1200 -algorithms/vqls/lcu_vqls/vqls_with_lcu.qmod: 20 -applications/benchmarking/quantum_volume/quantum_volume.ipynb: 516 -applications/benchmarking/randomized_benchmarking/randomized_benchmarking.ipynb: 60 -applications/chemistry/molecular_energy_curve/molecular_energy_curve.ipynb: 1200 -applications/chemistry/molecular_energy_curve/molecular_energy_curve.qmod: 90 -applications/chemistry/molecule_eigensolver/molecule_eigensolver.ipynb: 84 -applications/chemistry/molecule_eigensolver/molecule_eigensolver.qmod: 60 -applications/chemistry/protein_folding/protein_folding.ipynb: 240 -applications/chemistry/protein_folding/protein_folding.qmod: 240 -applications/chemistry/qpe_for_molecules/qpe_for_molecules.ipynb: 1332 -applications/chemistry/qpe_for_molecules/qpe_for_molecules.qmod: 1292 -applications/chemistry/second_quantized_hamiltonian/second_quantized_hamiltonian.ipynb: 44 -applications/chemistry/second_quantized_hamiltonian/second_quantized_hamiltonian.qmod: 40 -applications/cybersecurity/link_monitoring/link_monitoring.ipynb: 76 -applications/cybersecurity/link_monitoring/link_monitoring.qmod: 88 -applications/cybersecurity/patching_management/patch_min_vertex_cover.qmod: 52 -applications/cybersecurity/patching_management/patching_managment.ipynb: 36 -applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.ipynb: 720 -applications/cybersecurity/whitebox_fuzzing/whitebox_fuzzing.qmod: 720 -applications/finance/credit_card_fraud/credit_card_fraud.ipynb: 1084 -applications/finance/credit_card_fraud/credit_card_fraud.qmod: 1064 -applications/finance/option_pricing/option_pricing.ipynb: 140 -applications/finance/option_pricing/option_pricing.qmod: 140 -applications/finance/portfolio_optimization/portfolio_optimization.ipynb: 96 -applications/finance/portfolio_optimization/portfolio_optimization.qmod: 112 -applications/logistics/facility_location/facility_location.ipynb: 1656 -applications/logistics/facility_location/facility_location.qmod: 1592 -applications/logistics/task_scheduling_problem/task_scheduling_problem.ipynb: 840 -applications/logistics/task_scheduling_problem/task_scheduling_problem.qmod: 64 -applications/logistics/task_scheduling_problem/task_scheduling_problem_large.qmod: 688 -applications/logistics/traveling_salesman_problem/traveling_saleman_problem.qmod: 1088 -applications/logistics/traveling_salesman_problem/traveling_salesman_problem.ipynb: 1068 -applications/optimization/electric_grid_optimization/electric_grid_optimization.ipynb: 996 -applications/optimization/electric_grid_optimization/electric_grid_optimization.qmod: 1152 -applications/optimization/integer_linear_programming/integer_linear_programming.ipynb: 296 -applications/optimization/integer_linear_programming/integer_linear_programming.qmod: 340 -applications/optimization/knapsack_binary/knapsack_binary.ipynb: 72 -applications/optimization/knapsack_binary/knapsack_binary.qmod: 52 -applications/optimization/knapsack_integer/knapsack_integer.ipynb: 116 -applications/optimization/knapsack_integer/knapsack_integer.qmod: 116 -applications/optimization/max_clique/max_clique.ipynb: 276 -applications/optimization/max_clique/max_clique.qmod: 260 -applications/optimization/max_cut/max_cut.ipynb: 36 -applications/optimization/max_cut/max_cut.qmod: 32 -applications/optimization/max_independent_set/max_independent_set.ipynb: 60 -applications/optimization/max_independent_set/max_independent_set.qmod: 64 -applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.ipynb: 1028 -applications/optimization/max_induced_k_color_subgraph/max_induced_k_color_subgraph.qmod: 1008 -applications/optimization/max_k_vertex_cover/max_k_vertex_cover.ipynb: 184 -applications/optimization/max_k_vertex_cover/max_k_vertex_cover.qmod: 148 -applications/optimization/min_graph_coloring/min_graph_coloring.ipynb: 1800 -applications/optimization/min_graph_coloring/min_graph_coloring.qmod: 1800 -applications/optimization/minimum_dominating_set/minimum_dominating_set.ipynb: 620 -applications/optimization/minimum_dominating_set/minimum_dominating_set.qmod: 588 -applications/optimization/rectangles_packing/rectangles_packing.qmod: 1800 -applications/optimization/rectangles_packing/rectangles_packing_grid.ipynb: 1800 -applications/optimization/set_cover/set_cover.ipynb: 1440 -applications/optimization/set_cover/set_cover.qmod: 1216 -applications/optimization/set_partition/set_partition.ipynb: 152 -applications/optimization/set_partition/set_partition.qmod: 160 -applications/physical_systems/ising_model/ising_model.ipynb: 48 -applications/physical_systems/ising_model/ising_model.qmod: 48 -built_in_apps/chemistry/chemistry.ipynb: 48 -built_in_apps/chemistry/chemistry.qmod: 48 -built_in_apps/grover/grover.ipynb: 48 -built_in_apps/grover/grover.qmod: 48 -built_in_apps/option_pricing/option_pricing.ipynb: 48 -built_in_apps/option_pricing/option_pricing.qmod: 48 -community/QClass_2024/Assignments/HW1_QClass2024.ipynb: 200 -community/QClass_2024/Assignments/HW2_QClass2024.ipynb: 200 -community/QClass_2024/Assignments/Preparation_for_Week2_Git_GitHub.ipynb: 20 -community/QClass_2024/Sessions/week1_QClass_workshop_with_sol.ipynb: 20 -community/QClass_2024/Submissions/HW3/Amon_Koike_HW3_VQE.ipynb: 30 -community/QClass_2024/Submissions/HW3/Claudia_Zendejas-Morales_HW3_VQE.ipynb: 30 -community/QClass_2024/Submissions/HW3/Hisham_Mansour_HW3_VQE.ipynb: 30 -community/QClass_2024/Submissions/HW3/Mohammadreza_Khodajou_Masouleh_HW3_QClass2024.ipynb: 30 -community/QClass_2024/Submissions/HW3/Noah_Nzeki_William_HW3_VQE.ipynb: 30 -community/QClass_2024/Submissions/HW3/Otmane_Ainelkitane_HW3_VQE.ipynb: 30 -community/QClass_2024/Submissions/HW3/Samyak_Jain_HW3_VQE.ipynb: 30 -community/QClass_2024/Submissions/HW3/Yasir_Mansour_HW3_VQE.ipynb: 30 -community/QClass_2024/Submissions/HW3/bogachan_arslan-HW3_QClass2024.ipynb: 30 -community/QClass_2024/Submissions/HW4/Claudia_Zendejas-Morales_HW4_QClass2024.ipynb: 300 -community/QClass_2024/Submissions/HW4/HW_4_Bill_Wisotsky.ipynb: 300 -community/QClass_2024/Submissions/HW4/Hisham_Mansour_HW4_qpe_for_molecules.ipynb: 300 -community/QClass_2024/Submissions/HW4/Priyabrata_Bag_HW4.ipynb: 40 -community/QClass_2024/Submissions/HW4/Yasir_Mansour_HW4_molecule_eigensolver.ipynb: 600 -community/basic_examples/entanglement/bell_state_of_2_qubits.qmod: 10 -community/basic_examples/entanglement/entanglement.ipynb: 20 -community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod: 10 -community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod: 10 -community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb: 20 -community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod: 10 -community/basic_examples/superposition/equal_superposition_3_qubits.qmod: 10 -community/basic_examples/superposition/superposition.ipynb: 20 -community/basic_examples/vqe/vqe.ipynb: 20 -community/basic_examples/vqe/vqe_primitives.qmod: 10 -functions/function_usage_examples/arithmetic/arithmetic_expression/arithmetic_expression_example.ipynb: 20 -functions/function_usage_examples/arithmetic/arithmetic_expression/arithmetic_expression_example.qmod: 10 -functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_2vars_example.qmod: 10 -functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_example.ipynb: 20 -functions/function_usage_examples/arithmetic/bitwise_and/bitwise_and_integer_example.qmod: 10 -functions/function_usage_examples/arithmetic/bitwise_invert/bitwise_invert_example.ipynb: 20 -functions/function_usage_examples/arithmetic/bitwise_invert/bitwise_invert_example.qmod: 10 -functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_2vars_example.qmod: 10 -functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_example.ipynb: 20 -functions/function_usage_examples/arithmetic/bitwise_or/bitwise_or_integer_example.qmod: 10 -functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_2vars_example.qmod: 10 -functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_example.ipynb: 20 -functions/function_usage_examples/arithmetic/bitwise_xor/bitwise_xor_integer_example.qmod: 10 -functions/function_usage_examples/arithmetic/comparator/comparator_2vars_example.qmod: 10 -functions/function_usage_examples/arithmetic/comparator/comparator_example.ipynb: 20 -functions/function_usage_examples/arithmetic/comparator/comparator_integer_example.qmod: 10 -functions/function_usage_examples/arithmetic/extremum/extremum_example.ipynb: 20 -functions/function_usage_examples/arithmetic/extremum/maximum_float_example.qmod: 10 -functions/function_usage_examples/arithmetic/extremum/maximum_integer_example.qmod: 10 -functions/function_usage_examples/arithmetic/extremum/minimum_2vars_example.qmod: 10 -functions/function_usage_examples/arithmetic/modular_exp/modular_exp_example.ipynb: 100 -functions/function_usage_examples/arithmetic/modular_exp/modular_exp_example.qmod: 100 -functions/function_usage_examples/arithmetic/modulo/modulo_example.ipynb: 20 -functions/function_usage_examples/arithmetic/modulo/modulo_example.qmod: 10 -functions/function_usage_examples/arithmetic/multiplication/multiplication.ipynb: 20 -functions/function_usage_examples/arithmetic/multiplication/multiplication_2vars_example.qmod: 10 -functions/function_usage_examples/arithmetic/multiplication/multiplication_float_example.qmod: 10 -functions/function_usage_examples/arithmetic/negation/negation_example.ipynb: 20 -functions/function_usage_examples/arithmetic/negation/negation_example.qmod: 10 -functions/function_usage_examples/arithmetic/subtraction/subtraction_2vars_example.qmod: 10 -functions/function_usage_examples/arithmetic/subtraction/subtraction_example.ipynb: 20 -functions/function_usage_examples/arithmetic/subtraction/subtraction_float_example.qmod: 10 -functions/function_usage_examples/mcx/mcx_example.ipynb: 20 -functions/function_usage_examples/mcx/mcx_example.qmod: 10 -functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator.qmod: 10 -functions/qmod_library_reference/classiq_open_library/hadamard_transform/hadamard_transform.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/hadamard_transform/hadamard_transform.qmod: 10 -functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations.qmod: 10 -functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst.ipynb: 30 -functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type1.qmod: 20 -functions/qmod_library_reference/classiq_open_library/qct_qst/qct_qst_type2.qmod: 20 -functions/qmod_library_reference/classiq_open_library/qct_qst/qct_type2.qmod: 20 -functions/qmod_library_reference/classiq_open_library/qct_qst/qst_type2.qmod: 20 -functions/qmod_library_reference/classiq_open_library/qft/qft.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/qft/qft.qmod: 10 -functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/qpe/qpe.qmod: 10 -functions/qmod_library_reference/classiq_open_library/qpe/qpe_flexible.qmod: 10 -functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/qsvt/qsvt.qmod: 10 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/inplace_prepare_int.qmod: 10 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_bell_state.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_bell_state.qmod: 10 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_exponential_state.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_exponential_state.qmod: 10 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_ghz_state.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_ghz_state.qmod: 10 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_int.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_int.qmod: 10 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_partial_uniform_state.ipynb: 20 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_uniform_interval_state.qmod: 10 -functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_uniform_trimmed_state.qmod: 10 -functions/qmod_library_reference/classiq_open_library/variational_data_encoding/encode_in_angle.qmod: 10 -functions/qmod_library_reference/classiq_open_library/variational_data_encoding/encode_on_bloch.qmod: 10 -functions/qmod_library_reference/classiq_open_library/variational_data_encoding/variational_data_encoding.ipynb: 20 -functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.ipynb: 20 -functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/exponentiation/exponentiation.qmod: 10 -functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/qdrift/qdrift.ipynb: 20 -functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/qdrift/qdrift.qmod: 10 -functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/suzuki_trotter/suzuki_trotter.ipynb: 20 -functions/qmod_library_reference/qmod_core_library/hamiltonian_evolution/suzuki_trotter/suzuki_trotter.qmod: 10 -functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_amplitudes.qmod: 10 -functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.qmod: 10 -functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state_and_amplitudes.ipynb: 20 -functions/qmod_library_reference/qmod_core_library/standard_gates/CRX.qmod: 10 -functions/qmod_library_reference/qmod_core_library/standard_gates/CX.qmod: 10 -functions/qmod_library_reference/qmod_core_library/standard_gates/PHASE.qmod: 10 -functions/qmod_library_reference/qmod_core_library/standard_gates/R.qmod: 10 -functions/qmod_library_reference/qmod_core_library/standard_gates/RZ.qmod: 10 -functions/qmod_library_reference/qmod_core_library/standard_gates/RZZ.qmod: 10 -functions/qmod_library_reference/qmod_core_library/standard_gates/SWAP.qmod: 10 -functions/qmod_library_reference/qmod_core_library/standard_gates/U.qmod: 10 -functions/qmod_library_reference/qmod_core_library/standard_gates/X.qmod: 10 -functions/qmod_library_reference/qmod_core_library/standard_gates/standard_gates.ipynb: 20 -functions/qmod_library_reference/qmod_core_library/unitary/unitary.ipynb: 20 -functions/qmod_library_reference/qmod_core_library/unitary/unitary.qmod: 10 -research/glued_trees/glued_trees.ipynb: 500 -research/glued_trees/glued_trees_example.qmod: 200 -research/rainbow_options/rainbow_options_bruteforce_method.ipynb: 1000 -research/rainbow_options/rainbow_options_bruteforce_method.qmod: 1000 -research/rainbow_options/rainbow_options_direct_method.ipynb: 1000 -research/rainbow_options/rainbow_options_direct_method.qmod: 1000 -research/rainbow_options/rainbow_options_integration_method.ipynb: 1000 -research/rainbow_options/rainbow_options_integration_method.qmod: 1000 -tutorials/advanced_tutorials/discrete_quantum_walk/discrete_quantum_walk.ipynb: 90 -tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_circle.qmod: 25 -tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod: 25 -tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_hypercube.qmod: 30 -tutorials/advanced_tutorials/high_level_modeling_flexible_qpe/high_level_modeling_flexible_qpe.ipynb: 100 -tutorials/advanced_tutorials/linear_approximation_of_tanh/tanh.qmod: 20 -tutorials/advanced_tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.ipynb: 20 -tutorials/advanced_tutorials/linear_combination_of_unitaries/linear_combination_of_unitaries.qmod: 10 -tutorials/documentation_materials/classiq_101/classiq_concepts/analyze/analyze.ipynb: 20 -tutorials/documentation_materials/classiq_101/classiq_concepts/analyze/analyze.qmod: 10 -tutorials/documentation_materials/classiq_101/classiq_concepts/design/classical_variables_and_operations/classical_variables_and_operations.ipynb: 20 -tutorials/documentation_materials/classiq_101/classiq_concepts/design/classical_variables_and_operations/classical_variables_and_operations.qmod: 10 -tutorials/documentation_materials/classiq_101/classiq_concepts/design/design/design.ipynb: 20 -tutorials/documentation_materials/classiq_101/classiq_concepts/design/design/design.qmod: 10 -tutorials/documentation_materials/classiq_101/classiq_concepts/design/quantum_operations/quantum_operations.ipynb: 20 -tutorials/documentation_materials/classiq_101/classiq_concepts/design/quantum_operations/quantum_operations.qmod: 10 -tutorials/documentation_materials/classiq_101/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.ipynb: 20 -tutorials/documentation_materials/classiq_101/classiq_concepts/design/quantum_variables_and_functions/quantum_variables_and_functions.qmod: 10 -tutorials/documentation_materials/classiq_101/classiq_concepts/execute/execute.ipynb: 30 -tutorials/documentation_materials/classiq_101/classiq_concepts/execute/execute.qmod: 10 -tutorials/documentation_materials/classiq_101/classiq_concepts/optimize/optimize.ipynb: 20 -tutorials/documentation_materials/classiq_101/classiq_concepts/optimize/optimize.qmod: 10 -tutorials/documentation_materials/classiq_101/getting_started/part1_arithmetic.ipynb: 30 -tutorials/documentation_materials/classiq_101/getting_started/part2_state_preparation.ipynb: 30 -tutorials/documentation_materials/classiq_101/getting_started/part3_deutsch_jozsa.ipynb: 20 -tutorials/documentation_materials/classiq_101/getting_started/part4_ghz_state.ipynb: 60 -tutorials/documentation_materials/classiq_101/getting_started/part5_grover.ipynb: 60 -tutorials/documentation_materials/classiq_101/hello_many_worlds/hello_many_worlds.ipynb: 60 -tutorials/documentation_materials/classiq_101/hello_many_worlds/hello_many_worlds.qmod: 10 -tutorials/documentation_materials/classiq_101/phase_kickback/phase_kickback.ipynb: 1000 -tutorials/documentation_materials/classiq_101/phase_kickback/phase_kickback.qmod: 1000 -tutorials/documentation_materials/classiq_101/whats_classiq/whats_classiq.ipynb: 400 -tutorials/documentation_materials/classiq_101/whats_classiq/whats_classiq.qmod: 1000 -tutorials/documentation_materials/user_guide/qml_with_classiq_guide/qml_with_classiq_guide.ipynb: 300 -tutorials/documentation_materials/user_guide/qml_with_classiq_guide/qnn_with_pytorch.qmod: 300 -tutorials/documentation_materials/user_guide/qml_with_classiq_guide/vqe_primitive.qmod: 300 -tutorials/popular_usage_examples/basic_tutorials/add_bell_states/add_bell_states.qmod: 10 -tutorials/popular_usage_examples/basic_tutorials/bernstein_vazirani/bernstein_vazirani_tutorial.ipynb: 30 -tutorials/popular_usage_examples/basic_tutorials/bernstein_vazirani/bv_tutorial.qmod: 30 -tutorials/popular_usage_examples/basic_tutorials/prepare_state/prepare_state.ipynb: 20 -tutorials/popular_usage_examples/basic_tutorials/prepare_state/prepare_state.qmod: 20 -tutorials/popular_usage_examples/exponentiation/exponentiation.ipynb: 216 -tutorials/popular_usage_examples/exponentiation/exponentiation.qmod: 92 -tutorials/popular_usage_examples/exponentiation/exponentiation_minimize_error.qmod: 20 -tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/exponentiation.qmod: 300 -tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide.ipynb: 1000 -tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/qdrift.qmod: 300 -tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/trotter.qmod: 300 -tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qsvt.qmod: 300 -tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qubitization.qmod: 300 -tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_with_block_encoding.ipynb: 600 -tutorials/popular_usage_examples/mcx/mcx.ipynb: 236 -tutorials/popular_usage_examples/mcx/mcx_14_ctrl_cx.qmod: 28 -tutorials/popular_usage_examples/mcx/mcx_14_ctrl_depth.qmod: 28 -tutorials/popular_usage_examples/mcx/mcx_14_ctrl_hardware.qmod: 724 -tutorials/popular_usage_examples/mcx/mcx_50_ctrl.qmod: 140 -tutorials/popular_usage_examples/optimization/learning_optimization.ipynb: 80 -tutorials/technology_demonstrations/approximated_state_preparation/approximated_state_preparation.ipynb: 800 -tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_12_qubits.qmod: 24 -tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_demo_9_qubits.qmod: 24 -tutorials/technology_demonstrations/arithmetic_expressions/arithmetic_expressions.ipynb: 40 -tutorials/technology_demonstrations/auxiliary_managment/auxiliary_management.ipynb: 40 -tutorials/technology_demonstrations/discrete_quantum_walk_circle/discrete_quantum_walk_circle.ipynb: 400 -tutorials/technology_demonstrations/hamiltonian_evolution/hamiltonian_evolution.ipynb: 1200 -tutorials/technology_demonstrations/hardware_aware_mcx/hardware_aware_mcx.ipynb: 56 -tutorials/technology_demonstrations/hardware_aware_mcx/hardware_aware_mcx_all_to_all.qmod: 36 -tutorials/technology_demonstrations/hardware_aware_mcx/hardware_aware_mcx_linear.qmod: 44 -tutorials/technology_demonstrations/hhl/hhl.ipynb: 800 -tutorials/technology_demonstrations/oracle_generation/3sat_oracles.ipynb: 1800 -tutorials/technology_demonstrations/qaoa/qaoa.ipynb: 450 -tutorials/technology_demonstrations/qpe/qpe_for_grover_operator/qpe_for_grover_operator.ipynb: 1000 -tutorials/technology_demonstrations/qpe/qpe_for_unitary_matrix/qpe_for_unitary_matrix.ipynb: 600 -tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_1.ipynb: 400 -tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_2.ipynb: 80 -tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_3.ipynb: 80 -tutorials/workshops/Womanium_Global_Quantum_AI_2024/Session1.ipynb: 20 -tutorials/workshops/grover_workshop/grover_workshop.ipynb: 1000 -tutorials/workshops/grover_workshop/grover_workshop.qmod: 20 -tutorials/workshops/hhl_workshop/hhl_workshop.ipynb: 300 -tutorials/documentation_materials/classiq_101/hadamard_test/hadamard_test.ipynb: 44 -tutorials/documentation_materials/classiq_101/hadamard_test/hadamard_test.qmod: 20 +3_sat_grover.ipynb: 36 +3_sat_grover.qmod: 48 +3_sat_grover_large.qmod: 10 +3sat_oracles.ipynb: 1800 +add_bell_states.qmod: 10 +Amon_Koike_HW3_VQE.ipynb: 30 +analyze.ipynb: 20 +analyze.qmod: 10 +application_option_pricing.ipynb: 48 +application_option_pricing.qmod: 48 +approximated_state_preparation.ipynb: 800 +arithmetic_demo_12_qubits.qmod: 24 +arithmetic_demo_9_qubits.qmod: 24 +arithmetic_expression_example.ipynb: 20 +arithmetic_expression_example.qmod: 10 +arithmetic_expressions.ipynb: 40 +auxiliary_management.ipynb: 40 +bell_state_of_2_qubits.qmod: 10 +bernstein_vazirani.ipynb: 32 +bernstein_vazirani_example.qmod: 32 +bernstein_vazirani_tutorial.ipynb: 30 +bitwise_and_2vars_example.qmod: 10 +bitwise_and_example.ipynb: 20 +bitwise_and_integer_example.qmod: 10 +bitwise_invert_example.ipynb: 20 +bitwise_invert_example.qmod: 10 +bitwise_or_2vars_example.qmod: 10 +bitwise_or_example.ipynb: 20 +bitwise_or_integer_example.qmod: 10 +bitwise_xor_2vars_example.qmod: 10 +bitwise_xor_example.ipynb: 20 +bitwise_xor_integer_example.qmod: 10 +bogachan_arslan-HW3_QClass2024.ipynb: 30 +bv_tutorial.qmod: 30 +chemistry.ipynb: 48 +chemistry.qmod: 48 +classical_variables_and_operations.ipynb: 20 +classical_variables_and_operations.qmod: 10 +Claudia_Zendejas-Morales_HW3_VQE.ipynb: 30 +Claudia_Zendejas-Morales_HW4_QClass2024.ipynb: 300 +comparator_2vars_example.qmod: 10 +comparator_example.ipynb: 20 +comparator_integer_example.qmod: 10 +complex_deutsch_jozsa.qmod: 32 +credit_card_fraud.ipynb: 1084 +credit_card_fraud.qmod: 1064 +CRX.qmod: 10 +CX.qmod: 10 +design.ipynb: 20 +design.qmod: 10 +deutsch_jozsa.ipynb: 48 +discrete_log.ipynb: 600 +discrete_log.qmod: 300 +discrete_log_large.qmod: 600 +discrete_poisson_solver.ipynb: 300 +discrete_poisson_solver.qmod: 300 +discrete_quantum_walk.ipynb: 90 +discrete_quantum_walk_circle.ipynb: 400 +doubly_controlled_modular_adder.qmod: 100 +dqi_max_xorsat.ipynb: 200 +dqi_max_xorsat.qmod: 200 +electric_grid_optimization.ipynb: 996 +electric_grid_optimization.qmod: 1152 +encode_in_angle.qmod: 10 +encode_on_bloch.qmod: 10 +entanglement.ipynb: 20 +equal_superposition_3_qubits.qmod: 10 +example_exponentiation.ipynb: 216 +example_exponentiation.qmod: 92 +example_exponentiation_minimize_error.qmod: 20 +example_prepare_amplitudes.qmod: 10 +example_prepare_state.qmod: 10 +execute.ipynb: 30 +execute.qmod: 10 +extremum_example.ipynb: 20 +facility_location.ipynb: 1656 +facility_location.qmod: 1592 +glued_trees.ipynb: 500 +glued_trees_example.qmod: 200 +grover.ipynb: 48 +grover.qmod: 48 +grover_max_cut.ipynb: 220 +grover_max_cut.qmod: 188 +grover_operator.ipynb: 20 +grover_operator.qmod: 10 +grover_workshop.ipynb: 1000 +grover_workshop.qmod: 20 +hadamard_test.ipynb: 44 +hadamard_test.qmod: 20 +hadamard_transform.ipynb: 20 +hadamard_transform.qmod: 10 +hamiltonian_evolution.ipynb: 1200 +hamiltonian_evolution_exponentiation.ipynb: 20 +hamiltonian_evolution_exponentiation.qmod: 10 +hamiltonian_simulation_guide.ipynb: 1000 +hamiltonian_simulation_guide_exponentiation.qmod: 300 +hamiltonian_simulation_guide_qdrift.qmod: 300 +hamiltonian_simulation_guide_trotter.qmod: 300 +hamiltonian_simulation_qsvt.qmod: 300 +hamiltonian_simulation_qubitization.qmod: 300 +hamiltonian_simulation_with_block_encoding.ipynb: 600 +hardware_aware_mcx.ipynb: 56 +hardware_aware_mcx_all_to_all.qmod: 36 +hardware_aware_mcx_grid.qmod: 10 +hardware_aware_mcx_linear.qmod: 44 +hardware_aware_mcx_star.qmod: 10 +hello_many_worlds.ipynb: 60 +hello_many_worlds.qmod: 10 +hhl.ipynb: 312 +hhl_exact.qmod: 100 +hhl_example.ipynb: 800 +hhl_jungle.ipynb: 450 +hhl_trotter.qmod: 100 +hhl_workshop.ipynb: 300 +hidden_shift.ipynb: 272 +hidden_shift_complex.qmod: 100 +hidden_shift_no_dual.qmod: 92 +hidden_shift_simple.qmod: 20 +high_level_modeling_flexible_qpe.ipynb: 100 +Hisham_Mansour_HW3_VQE.ipynb: 30 +Hisham_Mansour_HW4_qpe_for_molecules.ipynb: 300 +HW1_QClass2024.ipynb: 200 +HW2_QClass2024.ipynb: 200 +HW_4_Bill_Wisotsky.ipynb: 300 +hw_aware_synthesis.ipynb: 20 +hybrid_qnn_for_subset_majority.ipynb: 120 +inplace_prepare_int.qmod: 10 +integer_linear_programming.ipynb: 400 +integer_linear_programming.qmod: 400 +ising_model.ipynb: 300 +ising_model.qmod: 300 +knapsack_integer.ipynb: 116 +knapsack_integer.qmod: 116 +learning_optimization.ipynb: 80 +linear_combination_of_unitaries.ipynb: 20 +linear_combination_of_unitaries.qmod: 10 +linear_pauli_rotations.ipynb: 20 +linear_pauli_rotations.qmod: 10 +link_monitoring.ipynb: 76 +link_monitoring.qmod: 88 +max_clique.ipynb: 300 +max_clique.qmod: 300 +max_cut.ipynb: 36 +max_cut.qmod: 32 +max_independent_set.ipynb: 60 +max_independent_set.qmod: 64 +max_induced_k_color_subgraph.ipynb: 1028 +max_induced_k_color_subgraph.qmod: 1008 +max_k_vertex_cover.ipynb: 600 +max_k_vertex_cover.qmod: 600 +maximum_float_example.qmod: 10 +maximum_integer_example.qmod: 10 +mcx.ipynb: 236 +mcx_10_ctrl_depth.qmod: 10 +mcx_14_ctrl_cx.qmod: 28 +mcx_14_ctrl_depth.qmod: 28 +mcx_14_ctrl_hardware.qmod: 724 +mcx_50_ctrl.qmod: 140 +mcx_example.ipynb: 20 +mcx_example.qmod: 10 +min_graph_coloring.ipynb: 1800 +min_graph_coloring.qmod: 1800 +minimum_2vars_example.qmod: 10 +minimum_dominating_set.ipynb: 620 +minimum_dominating_set.qmod: 588 +modular_exp_example.ipynb: 100 +modular_exp_example.qmod: 100 +modulo_example.ipynb: 20 +modulo_example.qmod: 10 +Mohammadreza_Khodajou_Masouleh_HW3_QClass2024.ipynb: 30 +molecular_energy_curve.ipynb: 1200 +molecular_energy_curve.qmod: 90 +molecule_eigensolver.ipynb: 84 +molecule_eigensolver.qmod: 60 +multiplication.ipynb: 20 +multiplication_2vars_example.qmod: 10 +multiplication_float_example.qmod: 10 +negation_example.ipynb: 20 +negation_example.qmod: 10 +Noah_Nzeki_William_HW3_VQE.ipynb: 30 +oblivious_amplitude_amplification.ipynb: 20 +oblivious_amplitude_amplification.qmod: 10 +optimize.ipynb: 20 +optimize.qmod: 10 +option_pricing.ipynb: 140 +option_pricing.qmod: 140 +Otmane_Ainelkitane_HW3_VQE.ipynb: 30 +part1_arithmetic.ipynb: 30 +part2_state_preparation.ipynb: 30 +part3_deutsch_jozsa.ipynb: 20 +part4_ghz_state.ipynb: 60 +part5_grover.ipynb: 60 +patch_min_vertex_cover.qmod: 52 +patching_managment.ipynb: 36 +PHASE.qmod: 10 +phase_kickback.ipynb: 1000 +phase_kickback.qmod: 1000 +portfolio_optimization.ipynb: 400 +portfolio_optimization.qmod: 400 +Preparation_for_Week2_Git_GitHub.ipynb: 20 +prepare_bell_state.ipynb: 20 +prepare_bell_state.qmod: 10 +prepare_exponential_state.ipynb: 20 +prepare_exponential_state.qmod: 10 +prepare_ghz_state.ipynb: 20 +prepare_ghz_state.qmod: 10 +prepare_int.ipynb: 20 +prepare_int.qmod: 10 +prepare_partial_uniform_state.ipynb: 20 +prepare_state.ipynb: 20 +prepare_state.qmod: 20 +prepare_state_and_amplitudes.ipynb: 20 +prepare_uniform_interval_state.qmod: 10 +prepare_uniform_trimmed_state.qmod: 10 +Priyabrata_Bag_HW4.ipynb: 40 +protein_folding.ipynb: 240 +protein_folding.qmod: 240 +qaoa.ipynb: 450 +qct_qst.ipynb: 30 +qct_qst_type1.qmod: 20 +qct_qst_type2.qmod: 20 +qct_type2.qmod: 20 +qdrift.ipynb: 20 +qdrift.qmod: 10 +qft.ipynb: 20 +qft.qmod: 10 +qgan_bars_and_strips.ipynb: 360 +qmc_user_defined.ipynb: 176 +qmc_user_defined.qmod: 136 +qml_with_classiq_guide.ipynb: 300 +QMOD_Workshop_Part_1.ipynb: 400 +QMOD_Workshop_Part_2.ipynb: 80 +QMOD_Workshop_Part_3.ipynb: 80 +qnn_with_pytorch.qmod: 300 +qpe.ipynb: 20 +qpe.qmod: 10 +qpe_flexible.qmod: 10 +qpe_for_grover_operator.ipynb: 1000 +qpe_for_matrix.ipynb: 748 +qpe_for_matrix.qmod: 760 +qpe_for_molecules.ipynb: 1332 +qpe_for_molecules.qmod: 1292 +qpe_for_unitary_matrix.ipynb: 600 +qst_type2.qmod: 20 +qsvm.ipynb: 204 +qsvm.qmod: 104 +qsvm_pauli_feature_map.ipynb: 68 +qsvm_pauli_feature_map.qmod: 60 +qsvt.ipynb: 20 +qsvt.qmod: 10 +qsvt_fixed_point_amplitude_amplification.ipynb: 376 +qsvt_fixed_point_amplitude_amplification.qmod: 340 +qsvt_matrix_inversion.ipynb: 180 +qsvt_matrix_inversion.qmod: 156 +quantum_autoencoder.ipynb: 120 +quantum_counting.ipynb: 300 +quantum_counting_iqae.qmod: 200 +quantum_counting_qpe.qmod: 200 +quantum_operations.ipynb: 20 +quantum_operations.qmod: 10 +quantum_variables_and_functions.ipynb: 20 +quantum_variables_and_functions.qmod: 10 +quantum_volume.ipynb: 516 +quantum_walk_circle.qmod: 25 +quantum_walk_circle_balanced_coin.qmod: 25 +quantum_walk_hypercube.qmod: 30 +R.qmod: 10 +rainbow_options_bruteforce_method.ipynb: 1000 +rainbow_options_bruteforce_method.qmod: 1000 +rainbow_options_direct_method.ipynb: 1000 +rainbow_options_direct_method.qmod: 1000 +rainbow_options_integration_method.ipynb: 1000 +rainbow_options_integration_method.qmod: 1000 +randomized_benchmarking.ipynb: 60 +rectangles_packing.qmod: 1800 +rectangles_packing_grid.ipynb: 1800 +RZ.qmod: 10 +RZZ.qmod: 10 +Samyak_Jain_HW3_VQE.ipynb: 30 +second_quantized_hamiltonian.ipynb: 44 +second_quantized_hamiltonian.qmod: 40 +Session1.ipynb: 20 +set_cover.ipynb: 1440 +set_cover.qmod: 1216 +set_partition.ipynb: 350 +set_partition.qmod: 350 +shor.ipynb: 104 +shor.qmod: 88 +shor_modular_exponentiation.ipynb: 300 +shor_modular_exponentiation.qmod: 300 +simon.ipynb: 40 +simon_example.qmod: 30 +simon_shallow_example.qmod: 20 +simple_deutsch_jozsa.qmod: 16 +standard_gates.ipynb: 20 +subtraction_2vars_example.qmod: 10 +subtraction_example.ipynb: 20 +subtraction_float_example.qmod: 10 +superposition.ipynb: 20 +suzuki_trotter.ipynb: 20 +suzuki_trotter.qmod: 10 +SWAP.qmod: 10 +swap_test.ipynb: 40 +swap_test.qmod: 40 +tanh.qmod: 20 +task_scheduling_problem.ipynb: 840 +task_scheduling_problem.qmod: 64 +task_scheduling_problem_large.qmod: 688 +traveling_saleman_problem.qmod: 1088 +traveling_salesman_problem.ipynb: 1068 +U.qmod: 10 +unitary.ipynb: 20 +unitary.qmod: 10 +variational_data_encoding.ipynb: 20 +vqe.ipynb: 20 +vqe_primitive.qmod: 300 +vqe_primitives.qmod: 10 +vqls_with_lcu.ipynb: 1200 +vqls_with_lcu.qmod: 20 +week1_QClass_workshop_with_sol.ipynb: 20 +whats_classiq.ipynb: 400 +whats_classiq.qmod: 1000 +whitebox_fuzzing.ipynb: 720 +whitebox_fuzzing.qmod: 720 +X.qmod: 10 +Yasir_Mansour_HW3_VQE.ipynb: 30 +Yasir_Mansour_HW4_molecule_eigensolver.ipynb: 600 +classiq_discrete_quantum_walk.ipynb: 300 +qiskit_discrete_quantum_walk.ipynb: 300 +tket_discrete_quantum_walk.ipynb: 300 +pennylane_catalyst_discrete_quantum_walk.ipynb: 300 +tket_qsvt_example.ipynb: 300 +classiq_qsvt.ipynb: 300 +pennylane_cat_qsvt_example.ipynb: 300 +qiskit_qsvt.ipynb: 300 +time_marching.ipynb: 500 +time_marching.qmod: 400 \ No newline at end of file diff --git a/tests/test_links.py b/tests/test_links.py index facec93a9..609853f35 100644 --- a/tests/test_links.py +++ b/tests/test_links.py @@ -12,6 +12,9 @@ URL_REGEX = r"https?:\/\/[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b[-a-zA-Z0-9@:%_\+.~#?&//=]*" # urls come in `[title](url)` URL_IN_MARKDOWN_REGEX = re.compile(r"(?<=\]\()%s(?=\s*\))" % URL_REGEX) +SKIPPED_URLS = [ + "https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.69.607", # From date: 19.12.24, notebook: hamiltonian_simulation_guide.ipynb +] def test_links() -> None: @@ -34,6 +37,8 @@ def iterate_links_from_notebook(filename: str) -> Iterable[tuple[int, str]]: def _test_single_url(url: str, retry: int = 3) -> bool: + if url in SKIPPED_URLS: + return True if retry == 0: return False diff --git a/tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod b/tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod index 6695b65b9..34d7eb0df 100644 --- a/tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod +++ b/tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_circle_balanced_coin.qmod @@ -1,13 +1,3 @@ -qfunc quantum_step_clockwise(x: qbit[]) { - within { - qft(x); - } apply { - repeat (i: x.len) { - PHASE(((2 * pi) * (2 ** i)) / (2 ** x.len), x[i]); - } - } -} - qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfuncs: qfunc[] (), coin_state: qnum) { power (time) { coin_flip_qfunc(coin_state); @@ -19,6 +9,16 @@ qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfun } } +qfunc quantum_step_clockwise(x: qbit[]) { + within { + qft(x); + } apply { + repeat (i: x.len) { + PHASE(((2 * pi) * (2 ** i)) / (2 ** x.len), x[i]); + } + } +} + qfunc main(t: int, output x: qnum) { coin: qbit; allocate_num(floor(log(128, 2)), True, 0, x); diff --git a/tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_hypercube.qmod b/tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_hypercube.qmod index a47414f8a..5f78eec55 100644 --- a/tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_hypercube.qmod +++ b/tutorials/advanced_tutorials/discrete_quantum_walk/quantum_walk_hypercube.qmod @@ -1,7 +1,3 @@ -qfunc moving_one_hamming_dist(pos: int, x: qbit[]) { - X(x[pos]); -} - qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfuncs: qfunc[] (), coin_state: qnum) { power (time) { coin_flip_qfunc(coin_state); @@ -13,6 +9,10 @@ qfunc discrete_quantum_walk(time: int, coin_flip_qfunc: qfunc (qnum), walks_qfun } } +qfunc moving_one_hamming_dist(pos: int, x: qbit[]) { + X(x[pos]); +} + qfunc main(t: int, output x: qbit[]) { allocate(4, x); coin: qbit[]; diff --git a/tutorials/popular_usage_examples/exponentiation/exponentiation.ipynb b/tutorials/popular_usage_examples/exponentiation/example_exponentiation.ipynb similarity index 98% rename from tutorials/popular_usage_examples/exponentiation/exponentiation.ipynb rename to tutorials/popular_usage_examples/exponentiation/example_exponentiation.ipynb index 275b353a4..4b2430d82 100644 --- a/tutorials/popular_usage_examples/exponentiation/exponentiation.ipynb +++ b/tutorials/popular_usage_examples/exponentiation/example_exponentiation.ipynb @@ -157,7 +157,7 @@ " custom_hardware_settings=CustomHardwareSettings(basis_gates=[\"cx\", \"u\"])\n", " ),\n", ")\n", - "write_qmod(qmod, \"exponentiation\")\n", + "write_qmod(qmod, \"example_exponentiation\")\n", "\n", "qprog = synthesize(qmod)\n", "circuit = QuantumProgram.from_qprog(qprog)\n", @@ -248,7 +248,7 @@ "qmod = create_model(main)\n", "\n", "\n", - "write_qmod(qmod, \"exponentiation_minimize_error\")\n", + "write_qmod(qmod, \"example_exponentiation_minimize_error\")\n", "\n", "qprog = synthesize(qmod)\n", "show(qprog)" diff --git a/tutorials/popular_usage_examples/exponentiation/exponentiation.metadata.json b/tutorials/popular_usage_examples/exponentiation/example_exponentiation.metadata.json similarity index 100% rename from tutorials/popular_usage_examples/exponentiation/exponentiation.metadata.json rename to tutorials/popular_usage_examples/exponentiation/example_exponentiation.metadata.json diff --git a/tutorials/popular_usage_examples/exponentiation/exponentiation.qmod b/tutorials/popular_usage_examples/exponentiation/example_exponentiation.qmod similarity index 100% rename from tutorials/popular_usage_examples/exponentiation/exponentiation.qmod rename to tutorials/popular_usage_examples/exponentiation/example_exponentiation.qmod diff --git a/tutorials/popular_usage_examples/exponentiation/exponentiation.synthesis_options.json b/tutorials/popular_usage_examples/exponentiation/example_exponentiation.synthesis_options.json similarity index 100% rename from tutorials/popular_usage_examples/exponentiation/exponentiation.synthesis_options.json rename to tutorials/popular_usage_examples/exponentiation/example_exponentiation.synthesis_options.json diff --git a/tutorials/popular_usage_examples/exponentiation/exponentiation_minimize_error.metadata.json b/tutorials/popular_usage_examples/exponentiation/example_exponentiation_minimize_error.metadata.json similarity index 100% rename from tutorials/popular_usage_examples/exponentiation/exponentiation_minimize_error.metadata.json rename to tutorials/popular_usage_examples/exponentiation/example_exponentiation_minimize_error.metadata.json diff --git a/tutorials/popular_usage_examples/exponentiation/exponentiation_minimize_error.qmod b/tutorials/popular_usage_examples/exponentiation/example_exponentiation_minimize_error.qmod similarity index 100% rename from tutorials/popular_usage_examples/exponentiation/exponentiation_minimize_error.qmod rename to tutorials/popular_usage_examples/exponentiation/example_exponentiation_minimize_error.qmod diff --git a/functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.synthesis_options.json b/tutorials/popular_usage_examples/exponentiation/example_exponentiation_minimize_error.synthesis_options.json similarity index 100% rename from functions/qmod_library_reference/qmod_core_library/prepare_state_and_amplitudes/prepare_state.synthesis_options.json rename to tutorials/popular_usage_examples/exponentiation/example_exponentiation_minimize_error.synthesis_options.json diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide.ipynb b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide.ipynb index fc6f93492..09ae1e071 100644 --- a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide.ipynb +++ b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide.ipynb @@ -187,7 +187,7 @@ "\n", "qmod = create_model(main)\n", "qprog = synthesize(qmod)\n", - "write_qmod(qmod, \"trotter\")\n", + "write_qmod(qmod, \"hamiltonian_simulation_guide_trotter\")\n", "show(qprog)" ] }, @@ -232,7 +232,7 @@ "\n", "\n", "qmod = create_model(main)\n", - "write_qmod(qmod, \"exponentiation\")\n", + "write_qmod(qmod, \"hamiltonian_simulation_guide_exponentiation\")\n", "qprog = synthesize(qmod)\n", "show(qprog)" ] @@ -327,7 +327,7 @@ "\n", "\n", "qmod = create_model(main)\n", - "write_qmod(qmod, \"qdrift\")\n", + "write_qmod(qmod, \"hamiltonian_simulation_guide_qdrift\")\n", "qprog = synthesize(qmod)\n", "show(qprog)" ] diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/exponentiation.metadata.json b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_exponentiation.metadata.json similarity index 100% rename from tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/exponentiation.metadata.json rename to tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_exponentiation.metadata.json diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/exponentiation.qmod b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_exponentiation.qmod similarity index 100% rename from tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/exponentiation.qmod rename to tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_exponentiation.qmod diff --git a/tutorials/popular_usage_examples/exponentiation/exponentiation_minimize_error.synthesis_options.json b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_exponentiation.synthesis_options.json similarity index 100% rename from tutorials/popular_usage_examples/exponentiation/exponentiation_minimize_error.synthesis_options.json rename to tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_exponentiation.synthesis_options.json diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/qdrift.metadata.json b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_qdrift.metadata.json similarity index 100% rename from tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/qdrift.metadata.json rename to tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_qdrift.metadata.json diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/qdrift.qmod b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_qdrift.qmod similarity index 100% rename from tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/qdrift.qmod rename to tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_qdrift.qmod diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/exponentiation.synthesis_options.json b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_qdrift.synthesis_options.json similarity index 100% rename from tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/exponentiation.synthesis_options.json rename to tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_qdrift.synthesis_options.json diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/trotter.metadata.json b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_trotter.metadata.json similarity index 100% rename from tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/trotter.metadata.json rename to tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_trotter.metadata.json diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/trotter.qmod b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_trotter.qmod similarity index 100% rename from tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/trotter.qmod rename to tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_trotter.qmod diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/qdrift.synthesis_options.json b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_trotter.synthesis_options.json similarity index 100% rename from tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/qdrift.synthesis_options.json rename to tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/hamiltonian_simulation_guide_trotter.synthesis_options.json diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/trotter.synthesis_options.json b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/trotter.synthesis_options.json deleted file mode 100644 index 0967ef424..000000000 --- a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_guide/trotter.synthesis_options.json +++ /dev/null @@ -1 +0,0 @@ -{} diff --git a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qubitization.qmod b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qubitization.qmod index d08a6fbee..08fa45d93 100644 --- a/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qubitization.qmod +++ b/tutorials/popular_usage_examples/hamiltonian_simulation/hamiltonian_simulation_with_block_encoding/hamiltonian_simulation_qubitization.qmod @@ -1,3 +1,18 @@ +qfunc lcu_cheb(coef: real[], generalized_signs: int[], walk_operator: qfunc (qnum, qbit[]), walk_block: qnum, walk_data: qbit[], cheb_block: qnum) { + within { + inplace_prepare_state(coef, 0.0, cheb_block); + } apply { + repeat (k: generalized_signs.len) { + control (cheb_block == k) { + U(0, 0, 0, (pi / 2) * generalized_signs[k], walk_data[0]); + power (k) { + walk_operator(walk_block, walk_data); + } + } + } + } +} + qfunc apply_pauli_term(pauli_string: PauliTerm, x: qbit[]) { repeat (index: x.len) { switch(pauli_string.pauli[index], [lambda() { @@ -52,21 +67,6 @@ qfunc my_walk_operator(block: qbit[], data: qbit[]) { RY(2 * pi, block[0]); } -qfunc lcu_cheb(coef: real[], generalized_signs: int[], walk_operator: qfunc (qnum, qbit[]), walk_block: qnum, walk_data: qbit[], cheb_block: qnum) { - within { - inplace_prepare_state(coef, 0.0, cheb_block); - } apply { - repeat (k: generalized_signs.len) { - control (cheb_block == k) { - U(0, 0, 0, (pi / 2) * generalized_signs[k], walk_data[0]); - power (k) { - walk_operator(walk_block, walk_data); - } - } - } - } -} - qfunc main(output ham_block: qnum, output data: qnum, output exp_block: qnum) { allocate(4, exp_block); allocate(2, ham_block); diff --git a/tutorials/technology_demonstrations/hhl/hhl.ipynb b/tutorials/technology_demonstrations/hhl/hhl_example.ipynb similarity index 100% rename from tutorials/technology_demonstrations/hhl/hhl.ipynb rename to tutorials/technology_demonstrations/hhl/hhl_example.ipynb diff --git a/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_2.ipynb b/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_2.ipynb index eedb222d9..dd84a742e 100644 --- a/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_2.ipynb +++ b/tutorials/workshops/QMOD_workshop/QMOD_Workshop_Part_2.ipynb @@ -324,19 +324,7 @@ " \\end{cases}\n", "$$\n", "\n", - "Notes:\n", - "- You cannot use `x` directly as the control variable in a `control` operator because it also occurs in the nested scope. To determine if `x` is in the lower or upper half of the domain, duplicate the most significant bit (MSB) onto a separate variable called `label`.\n", - "- In Python, assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n", - "\n", - "\n", - "
\n", - " Hint\n", - " dup_msb(x, label)
\n", - " control(label, ...) # 0.5 <= x < 1.0
\n", - " X(label)
\n", - " control(label, ...) # 0.0 <= x < 0.5
\n", - "
\n", - "\n" + "Note: in Python, assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function.\n" ] }, { @@ -421,7 +409,7 @@ "\n", "The second `bind` operation concatenates the variables back to the `res` output variable.\n", "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", + "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the 3-qubit probability distribution: `[1/8, 1/8, 1/8, 1/8 - sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", "\n", "The following sequence of operations generates it:\n", "1. Perform the Hadamard transform on all three qubits.\n", @@ -452,7 +440,7 @@ " 1 / 8,\n", " 1 / 8,\n", " 1 / 8,\n", - " -sqrt(3) / 16,\n", + " 1 / 8 - sqrt(3) / 16,\n", " 1 / 8 + sqrt(3) / 16,\n", " 1 / 8,\n", " 1 / 8,\n", @@ -690,18 +678,24 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2024-10-07T13:39:26.331226Z", "start_time": "2024-10-07T13:39:26.326156Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Opening: https://nightly.platform.classiq.io/circuit/6fec16d5-72a1-49bf-ab24-3287255c3391?version=0.64.0.dev0\n" + ] + } + ], "source": [ "# Solution to Exercise 9:\n", - "\n", - "\n", "from classiq import *\n", "\n", "\n", @@ -711,10 +705,14 @@ " allocate(3, x)\n", " hadamard_transform(x)\n", "\n", - " control(\n", - " x < 0.5,\n", - " stmt_block=lambda: inplace_xor(2.0 * x + 1.0, res),\n", - " else_block=lambda: inplace_xor(1.0 * x + 0.5, res),\n", + " aux = QBit(\"aux\")\n", + " within_apply(\n", + " lambda: assign(x < 0.5, aux),\n", + " lambda: control(\n", + " aux,\n", + " stmt_block=lambda: inplace_xor(2.0 * x + 1.0, res),\n", + " else_block=lambda: inplace_xor(1.0 * x + 0.5, res),\n", + " ),\n", " )\n", "\n", "\n", @@ -785,7 +783,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.11.4" }, "vscode": { "interpreter": {