From 7a4e12cea55f773cf54a92301a3082cde73f5cd4 Mon Sep 17 00:00:00 2001 From: axif Date: Thu, 12 Feb 2026 22:37:14 +0600 Subject: [PATCH 01/11] feat: add Harrow-Hassidim-Lloyd (HHL) algorithm --- README.md | 1 + .../advanced_algorithms/HHL_Algorithm.ipynb | 739 ++++++++++++++++++ .../experimental/algorithms/hhl/__init__.py | 18 + src/braket/experimental/algorithms/hhl/hhl.md | 7 + src/braket/experimental/algorithms/hhl/hhl.py | 718 +++++++++++++++++ .../experimental/algorithms/hhl/test_hhl.py | 211 +++++ 6 files changed, 1694 insertions(+) create mode 100644 notebooks/advanced_algorithms/HHL_Algorithm.ipynb create mode 100644 src/braket/experimental/algorithms/hhl/__init__.py create mode 100644 src/braket/experimental/algorithms/hhl/hhl.md create mode 100644 src/braket/experimental/algorithms/hhl/hhl.py create mode 100644 test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py diff --git a/README.md b/README.md index d234ca0d..0ee4200d 100644 --- a/README.md +++ b/README.md @@ -31,6 +31,7 @@ Running notebooks locally requires additional dependencies located in [notebooks | Quantum PCA | [Quantum_Principal_Component_Analysis.ipynb](notebooks/advanced_algorithms/Quantum_Principal_Component_Analysis.ipynb) | [He2022](https://ieeexplore.ieee.org/document/9669030) | | QMC | [Quantum_Computing_Quantum_Monte_Carlo.ipynb](notebooks/advanced_algorithms/Quantum_Computing_Quantum_Monte_Carlo.ipynb) | [Motta2018](https://wires.onlinelibrary.wiley.com/doi/10.1002/wcms.1364), [Peruzzo2014](https://www.nature.com/articles/ncomms5213) | | Adaptive Shot Allocation | [2_Adaptive_Shot_Allocation.ipynb](notebooks/advanced_algorithms/adaptive_shot_allocation/2_Adaptive_Shot_Allocation.ipynb) | [Shlosberg2023](https://doi.org/10.22331/q-2023-01-26-906) | +| HHL Algorithm | [HHL_Algorithm.ipynb](notebooks/advanced_algorithms/HHL_Algorithm.ipynb) | [Harrow2009](https://arxiv.org/abs/0811.3171) | | Auxiliary functions | Notebook | diff --git a/notebooks/advanced_algorithms/HHL_Algorithm.ipynb b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb new file mode 100644 index 00000000..e9a1cda6 --- /dev/null +++ b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb @@ -0,0 +1,739 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Harrow-Hassidim-Lloyd (HHL) Algorithm\n", + "\n", + "This notebook demonstrates the **HHL algorithm** for solving systems of linear equations $A\\vec{x} = \\vec{b}$ on a quantum computer using the Amazon Braket SDK.\n", + "\n", + "The HHL algorithm, introduced by Aram Harrow, Avinatan Hassidim, and Seth Lloyd in 2009 [1], is one of the fundamental quantum algorithms alongside Shor's factoring algorithm and Grover's search algorithm. It can provide an **exponential speedup** over classical methods for certain classes of problems.\n", + "\n", + "## Overview\n", + "\n", + "Given an $N \\times N$ Hermitian matrix $A$ and a unit vector $\\vec{b}$, the HHL algorithm prepares a quantum state $|x\\rangle$ whose amplitudes are proportional to the entries of $\\vec{x} = A^{-1}\\vec{b}$. The algorithm cannot efficiently output the full solution vector $\\vec{x}$ directly, but allows one to efficiently estimate summary statistics such as $\\vec{x}^T M \\vec{x}$ for some operator $M$.\n", + "\n", + "### Algorithm Steps\n", + "\n", + "The HHL algorithm consists of four main steps:\n", + "\n", + "1. **State Preparation**: Encode the vector $\\vec{b}$ into a quantum state $|b\\rangle$\n", + "2. **Quantum Phase Estimation (QPE)**: Decompose $|b\\rangle$ in the eigenbasis of $A$ and estimate the eigenvalues $\\lambda_j$\n", + "3. **Controlled Rotation**: Apply a rotation conditioned on each eigenvalue to encode $C/\\lambda_j$ into an ancilla qubit\n", + "4. **Inverse QPE**: Uncompute the eigenvalue register\n", + "\n", + "After post-selecting on the ancilla qubit measuring $|1\\rangle$, the remaining state is proportional to:\n", + "\n", + "$$|x\\rangle = A^{-1}|b\\rangle = \\sum_{j=1}^{N} \\beta_j \\lambda_j^{-1} |u_j\\rangle$$\n", + "\n", + "where $|u_j\\rangle$ are the eigenvectors of $A$ and $\\beta_j$ are the coefficients of $|b\\rangle$ in the eigenbasis.\n", + "\n", + "### Complexity\n", + "\n", + "For sparse, well-conditioned matrices, HHL runs in $O(\\log(N) \\kappa^2)$ time, where $\\kappa$ is the condition number of $A$. This is an exponential speedup compared to the best classical algorithm, which runs in $O(N\\kappa)$.\n", + "\n", + "### Caveats\n", + "\n", + "- $A$ must be Hermitian (if not, it can be embedded in a larger Hermitian system)\n", + "- $\\vec{b}$ must be efficiently preparable as a quantum state\n", + "- The exponential speedup only applies when summary statistics of $\\vec{x}$ are needed, not the full solution\n", + "- The matrix should be sparse and well-conditioned for optimal performance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "[[1] A. W. Harrow, A. Hassidim, S. Lloyd, \"Quantum algorithm for linear systems of equations\", Phys. Rev. Lett. 103, 150502 (2009)](https://arxiv.org/abs/0811.3171)\n", + "\n", + "[[2] Wikipedia: HHL Algorithm](https://en.wikipedia.org/wiki/HHL_algorithm)\n", + "\n", + "[[3] S. Barz et al., \"A two-qubit photonic quantum processor and its application to solving systems of linear equations\", Scientific Reports 4, 6115 (2014)](https://arxiv.org/abs/1302.1210)\n", + "\n", + "[[4] X.-D. Cai et al., \"Experimental Quantum Computing to Solve Systems of Linear Equations\", Phys. Rev. Lett. 110, 230501 (2013)](https://arxiv.org/abs/1302.4310)\n", + "\n", + "[[5] J. Pan et al., \"Experimental realization of quantum algorithm for solving linear systems of equations\", Phys. Rev. A 89, 022313 (2014)](https://arxiv.org/abs/1302.1946)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "First, let's import the necessary libraries and the HHL module from the Braket Algorithm Library." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from braket.circuits import Circuit\n", + "from braket.devices import LocalSimulator\n", + "\n", + "from braket.experimental.algorithms.hhl import (\n", + " hhl_circuit,\n", + " run_hhl,\n", + " get_hhl_results,\n", + ")\n", + "\n", + "# magic word for producing visualizations in notebook\n", + "%matplotlib inline\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1: Solving a Simple Diagonal System\n", + "\n", + "Let's start with a simple example. Consider the system $A\\vec{x} = \\vec{b}$ where:\n", + "\n", + "$$A = \\begin{pmatrix} 1 & 0 \\\\ 0 & 2 \\end{pmatrix}, \\quad \\vec{b} = \\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix}$$\n", + "\n", + "The classical solution is trivially $\\vec{x} = \\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix}$.\n", + "\n", + "This diagonal case is instructive because the eigenvalues are simply the diagonal elements, making it easy to understand how QPE encodes them and how the controlled rotation inverts them." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrix A:\n", + "[[1.+0.j 0.+0.j]\n", + " [0.+0.j 2.+0.j]]\n", + "Vector b: [1.+0.j 0.+0.j]\n", + "Eigenvalues of A: [1. 2.]\n", + "Condition number: 2.00\n", + "\n", + "Classical solution: [1.+0.j 0.+0.j]\n" + ] + } + ], + "source": [ + "# Define the system\n", + "A1 = np.array([[1, 0], [0, 2]], dtype=complex)\n", + "b1 = np.array([1, 0], dtype=complex)\n", + "\n", + "# Print eigenvalues\n", + "eigenvalues, eigenvectors = np.linalg.eigh(A1)\n", + "print(f\"Matrix A:\\n{A1}\")\n", + "print(f\"Vector b: {b1}\")\n", + "print(f\"Eigenvalues of A: {eigenvalues}\")\n", + "print(f\"Condition number: {max(abs(eigenvalues)) / min(abs(eigenvalues)):.2f}\")\n", + "print(f\"\\nClassical solution: {np.linalg.solve(A1, b1)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Build and Visualize the HHL Circuit" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HHL Circuit for Example 1:\n", + "Number of qubits: 4\n", + " - Clock qubits: q0, q1 (QPE register)\n", + " - Input qubit: q2 (encodes |b>)\n", + " - Ancilla qubit: q3 (for eigenvalue inversion)\n", + "Circuit depth: 48\n", + "Number of instructions: 63\n" + ] + } + ], + "source": [ + "# Build the HHL circuit\n", + "hhl_circ1 = hhl_circuit(A1, b1, num_clock_qubits=2)\n", + "\n", + "print(\"HHL Circuit for Example 1:\")\n", + "print(f\"Number of qubits: {hhl_circ1.qubit_count}\")\n", + "print(f\" - Clock qubits: q0, q1 (QPE register)\")\n", + "print(f\" - Input qubit: q2 (encodes |b>)\")\n", + "print(f\" - Ancilla qubit: q3 (for eigenvalue inversion)\")\n", + "print(f\"Circuit depth: {hhl_circ1.depth}\")\n", + "print(f\"Number of instructions: {len(hhl_circ1.instructions)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run on the Local Simulator" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running HHL Algorithm...\n", + "HHL Run Complete!\n", + "Matrix A:\n", + "[[1.+0.j 0.+0.j]\n", + " [0.+0.j 2.+0.j]]\n", + "\n", + "Vector b: [1.+0.j 0.+0.j]\n", + "\n", + "Classical solution x = A^(-1)b: [1.+0.j 0.+0.j]\n", + "Classical solution (normalized): [1.+0.j 0.+0.j]\n", + "Classical probabilities |x_i|^2: [1. 0.]\n", + "\n", + "Total measurement shots: 10000\n", + "Post-selection success shots: 984\n", + "Success probability: 0.0984\n", + "\n", + "Post-selected counts: {'0': 984}\n", + "Quantum solution probabilities: {'0': 1.0}\n", + "\n", + "Fidelity with classical solution: 1.0000\n" + ] + } + ], + "source": [ + "# Run on local simulator\n", + "device = LocalSimulator()\n", + "print(\"Running HHL Algorithm...\")\n", + "task1 = run_hhl(hhl_circ1, device, shots=10000)\n", + "print(\"HHL Run Complete!\")\n", + "\n", + "# Get and display results\n", + "results1 = get_hhl_results(\n", + " task1, A1, b1, num_clock_qubits=2, verbose=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the Results\n", + "\n", + "Let's compare the quantum solution (from post-selected measurements) with the classical solution." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_hhl_comparison(results, title=\"HHL Algorithm Results\"):\n", + " \"\"\"Plot comparison between quantum and classical solutions.\"\"\"\n", + " fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n", + " \n", + " # Plot 1: Raw measurement counts\n", + " counts = results['measurement_counts']\n", + " sorted_counts = dict(sorted(counts.items()))\n", + " axes[0].bar(sorted_counts.keys(), sorted_counts.values(), color='steelblue', alpha=0.8)\n", + " axes[0].set_xlabel('Bitstring (clock | input | ancilla)')\n", + " axes[0].set_ylabel('Counts')\n", + " axes[0].set_title('Raw Measurement Counts')\n", + " axes[0].tick_params(axis='x', rotation=90)\n", + " \n", + " # Plot 2: Post-selected solution probabilities vs classical\n", + " quantum_probs = [\n", + " results['solution_state_probabilities'].get('0', 0),\n", + " results['solution_state_probabilities'].get('1', 0),\n", + " ]\n", + " classical_probs = list(results['classical_probabilities'])\n", + " \n", + " x = np.arange(2)\n", + " width = 0.35\n", + " axes[1].bar(x - width/2, quantum_probs, width, label='Quantum (HHL)', color='coral', alpha=0.8)\n", + " axes[1].bar(x + width/2, classical_probs, width, label='Classical', color='steelblue', alpha=0.8)\n", + " axes[1].set_xlabel('Solution Component')\n", + " axes[1].set_ylabel('Probability |x_i|²')\n", + " axes[1].set_title(f'Solution Comparison (Fidelity: {results[\"fidelity\"]:.4f})')\n", + " axes[1].set_xticks(x)\n", + " axes[1].set_xticklabels(['|0⟩', '|1⟩'])\n", + " axes[1].legend()\n", + " \n", + " # Plot 3: Success probability pie chart\n", + " success_rate = results['success_probability']\n", + " axes[2].pie(\n", + " [success_rate, 1 - success_rate],\n", + " labels=['Success\\n(ancilla=|1⟩)', 'Failure\\n(ancilla=|0⟩)'],\n", + " colors=['mediumseagreen', 'lightcoral'],\n", + " autopct='%1.1f%%',\n", + " startangle=90,\n", + " )\n", + " axes[2].set_title('Post-Selection Success Rate')\n", + " \n", + " fig.suptitle(title, fontsize=14, fontweight='bold')\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "plot_hhl_comparison(results1, \"Example 1: Diagonal Matrix A = diag(1, 2), b = [1, 0]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 2: Solving a Non-Diagonal Hermitian System\n", + "\n", + "Now let's try a more interesting example with off-diagonal elements:\n", + "\n", + "$$A = \\begin{pmatrix} 2 & 1 \\\\ 1 & 2 \\end{pmatrix}, \\quad \\vec{b} = \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}$$\n", + "\n", + "This matrix has eigenvalues $\\lambda_1 = 1$ and $\\lambda_2 = 3$, with condition number $\\kappa = 3$.\n", + "\n", + "The classical solution is:\n", + "$$\\vec{x} = A^{-1}\\vec{b} = \\frac{1}{3\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Matrix A:\n", + "[[2.+0.j 1.+0.j]\n", + " [1.+0.j 2.+0.j]]\n", + "Vector b: [0.70710678+0.j 0.70710678+0.j]\n", + "Eigenvalues of A: [1. 3.]\n", + "Condition number: 3.00\n", + "\n", + "Classical solution: [0.23570226+0.j 0.23570226+0.j]\n" + ] + } + ], + "source": [ + "# Define the system\n", + "A2 = np.array([[2, 1], [1, 2]], dtype=complex)\n", + "b2 = np.array([1/np.sqrt(2), 1/np.sqrt(2)], dtype=complex)\n", + "\n", + "# Print eigenvalues\n", + "eigenvalues2, eigenvectors2 = np.linalg.eigh(A2)\n", + "print(f\"Matrix A:\\n{A2}\")\n", + "print(f\"Vector b: {b2}\")\n", + "print(f\"Eigenvalues of A: {eigenvalues2}\")\n", + "print(f\"Condition number: {max(abs(eigenvalues2)) / min(abs(eigenvalues2)):.2f}\")\n", + "print(f\"\\nClassical solution: {np.linalg.solve(A2, b2)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running HHL Algorithm for Example 2...\n", + "HHL Run Complete!\n", + "Matrix A:\n", + "[[2.+0.j 1.+0.j]\n", + " [1.+0.j 2.+0.j]]\n", + "\n", + "Vector b: [0.70710678+0.j 0.70710678+0.j]\n", + "\n", + "Classical solution x = A^(-1)b: [0.23570226+0.j 0.23570226+0.j]\n", + "Classical solution (normalized): [0.70710678+0.j 0.70710678+0.j]\n", + "Classical probabilities |x_i|^2: [0.5 0.5]\n", + "\n", + "Total measurement shots: 10000\n", + "Post-selection success shots: 7312\n", + "Success probability: 0.7312\n", + "\n", + "Post-selected counts: {'1': 3733, '0': 3579}\n", + "Quantum solution probabilities: {'1': 0.5105306345733042, '0': 0.48946936542669583}\n", + "\n", + "Fidelity with classical solution: 0.9999\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABroAAAHvCAYAAAALjw9CAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XdYFFfbBvB76R1UqohUG4gNe0NsqFhjN1GwxthijbH32FusSYxg7CX2XjEqdkVFRBF7oYg06bDz/cG787EsICCwoPfvuvZKZubMmWeGkTnMs+cciSAIAoiIiIiIiIiIiIiIiIhKGRVlB0BERERERERERERERERUEEx0ERERERERERERERERUanERBcRERERERERERERERGVSkx0ERERERERERERERERUanERBcRERERERERERERERGVSkx0ERERERERERERERERUanERBcRERERERERERERERGVSkx0ERERERERERERERERUanERBcRERERERERERERERGVSkx0EREREREREVGhGzt2LCQSCXr06KHsUIpNREQENDQ0IJFIEBAQoOxwiIiIiL4JTHQREREREX0hX19fSCQS8fPixQtlh/RNy/rzkH26du0qlvHx8cm2zNixY5UWd078/f2zjbVFixZ5rsPLyyvbOg4ePFhkcRfUqlWrso119uzZYhlZAiXrx8fH54uPX9r+PZfUezk1NRXbt29Hw4YN8dNPPyk1luK0bds2pKam4rfffoOlpWWB6zEyMsr250pEREREipjoIiIiIqJc5ZQ0yPrx8vJSdqjfhODgYKxcuRJdu3aFo6MjypYtCw0NDVhYWKBTp044fPhwkR6/evXqcj93CwsLpKWlFekxlaWorvVff/2FQYMGwdnZGWpqauK1tLGxKdwTyKfo6GgsXrwYPXv2hI2NTaH8+75y5QpmzZqFVq1awcHBAXp6etDW1oa9vT0GDhyIe/fuFe5JUI6+9L774YcfIJFIsHjx4jyVP3LkCD58+IAJEyagVatWAIr/fnj06BGmT5+Odu3awdjYON9J0adPn0IikcDQ0BApKSl5Oqa3tzecnJwwZcoUlClTBh8/foS3tzc8PT1Rq1YtmJubQ11dHWXLlkXTpk2xZs2aPNdNRERERNlTU3YARERERESUd8uXL8cff/yhsD40NBRHjx7F0aNHMWLECKxbt67Qj33z5k08fPhQ4bgnT55Ex44dC/14hWXp0qUAgEqVKmW7vUyZMpg6dSoAwMXFRVxfVNd60qRJiImJyXN5S0tL8RxOnz6NM2fO5Ot4WdWtWxe9e/cGkJG4lHnx4gV+/fXXL6o7q8GDB+Px48cK6589e4Znz55h27Zt+Oeff9C3b19xW/PmzcXz3bBhA549e6awf5cuXVChQgUAwG+//YaoqKhCjbu0yuleBvJ/32WWmpqKY8eOAYBcz8jceHt7o2zZsujcubO4riD3w5c4deoUFixYUOD9Dxw4AADo0KEDNDQ0Plv+9u3bePDggXj/Ahn/ZgcNGqRQNioqCleuXMGVK1ewbds2nDt3Dnp6euL2+fPnIykpCSEhIdi4cWOBz4GIiIjoW8BEFxERERHlS+/evVG3bl2F9ZlfmFPRs7W1Rbt27VC+fHkEBgZiz549SE9PBwCsX78e3bp1Q+vWrQv1mDn1gPDx8SnRia6JEyfmut3AwCDXMoV9rVVVVVGtWjXUrVsXDx48gL+/f67lTUxMxPg+ffr0xYkuJyenHM9XS0sLNWrUQN26dbFz585CSyDVq1cPLVq0gK6uLi5cuICLFy8CANLS0jBs2DC0b98eRkZGAIA6deqgTp06AICjR49mm+hyc3ODm5sbAGDt2rVMdP1Pbvdyfu+7zHx9fREdHY2qVauiSpUqny0vS4APHz482wRRfu6HL1WmTBnUqVMH9vb2+PPPP/O1r2xoz/wk99TU1NC/f/9s42jfvj2qVauGsLAwbN26VUw83rhxA4sWLcL8+fPF8qNGjQKQce2Z6CIiIiLKHYcuJCIiIqJ8adeuHSZOnKjwadeuHYCMF/EODg7i8FDdu3eX23/YsGFyw95FREQAAJ4/f46xY8eiWbNmsLKygq6uLjQ1NWFpaYlOnTrhyJEjCrFknZsmJiYGY8aMgYWFBXR1deHm5oYbN24AyOgx0KNHD5QpUwb6+vpo164dAgIC5Op78eKFXH2+vr7YunUrXFxcoK2tDVNTUwwaNAhhYWH5umZSqRRbt25F27ZtYWpqCg0NDZiYmMDDwwPHjx/PV13Vq1fHkSNHEBISgvXr12P69OnYsWMH/vrrL7lyJ06cyPVa5XfeoeTkZOzcuVNcrly5svj/R44cQWRkZL7qKw0Keq0/582bNwgMDMQ///yDmjVrFmbIX8TJyQlxcXG4fv061q1bBwMDgy+us2PHjrh37x5u3LiBJUuWYNasWfD19YWnp6dY5tOnT7h06dIXH6uoCIKAdevWoXr16tDS0oKlpSXGjx+PuLg4ZYeWL19y3+U34bN161akpaUpDHlZ3PfDjz/+iI8fP+Ls2bOYMmVKvvYNCwvDtWvXoKGhgQ4dOny2fHJyMnbs2IF27drBzMxMXG9sbIw1a9bg7du32L59O6ZPn441a9bg2rVr0NTUFMvl9/cIEREREf0/JrqIiIiIqFDp6elhx44dUFPLGDxg//792LVrF4CMYaRkSQKJRIJ//vkHJiYmAICHDx9i9erVuHz5Mt68eYOEhASkpKTg3bt3OHr0KDp37oy5c+fmeuxWrVphzZo1CA0NRUJCAnx9feHq6orDhw+jXr16+PfffxEdHY1Pnz7h1KlTaNGihZhoy868efMwYMAA3LlzB0lJSYiIiIC3tzcaN26c636ZJSYmwt3dHQMGDMCZM2cQERGB1NRUfPjwAcePH4eHhwcmTJiQp7qAjG/5d+zYERKJRG59z5495ZYLe86XQ4cOyfWa2bJlC9TV1cVj7dixI9915mXut6yJx+JUVNdaW1v7i2MrCurq6uK/28KybNky1KhRQ2F9jx495JZL8hxFo0ePxqhRo/Dw4UMkJyfj3bt3WLlyJVq1aoWkpKQ81ZE1iZ6XT36T0Z9T0PtOEAQcOnQIANCtWze5bUlJSbhw4YLCPt7e3nB2dlYYPrG474cv+bd2+PBhSKVStGrVCvr6+nLbHj9+rNDTUPY7Mmtyr3Xr1hg1apRCLFWrVpXrCV2S/w0QERERlXRMdBERERFRvpw8eRLLli1T+Lx+/VosU79+fbmk1KhRo/D48WMMHjxYXDd+/Hi0adNGXFZTU0OtWrUwZMgQTJkyBQsXLsT06dPF4cmAjMTT27dvc4zt7t27GDp0KMaNGycmYZKSktClSxfExsZixIgRGDJkiFg+MjISf//9d471nT9/Hm5ubpg5cyZatWolrn/27BkmT578uUsFABg3bhzOnj0LANDQ0MCAAQMwb9489OrVS0ygrFixokCJosyCgoLkluvXr/9F9WWVedjCOnXqoGHDhnLD9eU0rOHXqKiv9bcg8zVUUVFRSIiUJMeOHUOXLl0wc+ZM1KtXT1x/8+ZNLFmyRImRFY+bN2/i7du3sLS0FM/fz88PP/zwA0xNTdGqVSu8evVKLH/9+nU8evRIIeGTm5J4P8jm55L1YktKSsKiRYtQq1YtVK1aFb/99ptceW9vb5QrVw6dOnXKU/3JyclyyUz+HiEiIiIqOM7RRURERET5snv3buzevVthfd26dWFlZSUuT548GadPn4avry8iIyNRt25dfPr0CQBQu3ZthZeE7dq1Q7t27fDkyRPcvXsXERERUFdXR4cOHXD9+nUkJCQgLS0N58+fz3b+EwCYO3cupk2bBiBjjpjMQ+0tXLhQnLsmICAA165dA5DxEjcnbdu2xcmTJyGRSCAIAtq1a4fTp08DALZv3461a9dCR0cnx/0/fvwol0jbuHEjBg4cKC4bGxtj/fr1ADJ6OvTr1y/HunLz6dMnjBgxQlyuWrUqevXqVaC6svP+/XvxvAGgb9++4n9lw23duXMHDx48gLOzc57rXbp0ab7isLe3z1f5olDU1/pbEBQUJPfvf8CAAbCxsVFeQJ8xdOhQcW6n6dOno3bt2nj48CEA4K+//sLMmTM/W0fZsmXzfb+XLVs2/8EWAdmwhZ07dxaT8w8ePEBaWhr09PQQFxeH7du3i0MDyuap+uGHH/JUf0m8H+Li4nD+/HmoqKigc+fOADK+qHD06FHY2dnh3r172LdvH9auXQstLS28ffsWp0+fxsiRI7Odkyw748aNE4d81dbWxqRJk4rsfIiIiIi+dkx0EREREVGRUFFRwdatW1GzZk18/PhRTHLp6Ohg586dCi8DX7x4ge+//x5+fn651vvmzZsct2V+sZr1RWnmZIS9vb2Y6Mo8HF929cle7EokEnz//fdiwiclJQUPHjxAgwYNctz/+vXrSEtLE5cHDRqEQYMGZVvW398fCQkJuSbOshMaGorOnTuLCbvy5cvjyJEjcnO/AICXl1e+elhktnXrVqSnpwPIuA69e/cGkNHTQUtLSxy+zdvbGytWrMhzvbLEY2mR12tNObt69Sq6dOki/rtzdXUVk70lVebEurq6Onr16oVZs2YByPh9FBYWJjcnU3YMDAxK3f0uk938XD/++CN+/PFHTJkyBYsWLcK2bdswZcoUJCUlYffu3ejQoQNMTU0/W3dJvR9OnDiB5ORkNGrUCObm5gAynmmXL19GTEwMTpw4gZiYGBw5cgQ9e/bE1q1bIZVK5b7IkJPU1FQMHz4cmzdvBpBxT+3cuRNVq1Yt0nMiIiIi+pox0UVERERE+eLt7Z3nhEmFChXQtWtX8YUekDFfSZUqVRTKdu3aFffu3ftsncnJyTluK1++vPj/WRNpmbdlnodIKpXmWF/WF7VZX2ZHR0fnGuvHjx9z3Z6ZIAiIjIzMV6LrwYMH6NixozhsmL29PU6dOlXoPZ8yD0vYuHFjseeevr4+PDw88O+//wLI6OW2ZMmSPM/ztGzZsnzF0bt3b7leg8WpuK7112z37t3w8vISE6MdOnTA3r17S+ycZTJ5+T3wuURXbGys2Cssr4YNGwYDA4N87VPYnjx5gkePHsHIyEhuGFkZLy8vLFq0CIGBgbhz5w4eP36M6OjoPD0jSvL9IEvuZZ2TDAAMDQ3RtWtX7Nq1C1u3bkXPnj3h4+ODGjVqoHbt2rnWGx0dje7du+P8+fMAMr74sWfPHnh4eBT6ORARERF9S5joIiIiIqIic/HiRYW5mw4fPoyDBw/K9Q54/PixXJKrX79+WLJkCcqXLw+JRAJTU1NERER89niyebmyk9fkS2bh4eFyy2FhYXLLRkZGue6fdeixcePGySXcsjI0NMxzbCdPnkSvXr0QFxcHAGjYsCEOHz4MExOTPNeRF7L5dmSuXLki9nLLKjw8HMePHxeH+vqc/A7VlXV4zOJSXNf6a7ZgwQLMmDEDgiAAyEjirFu3rkD/LotbeHi4XHI+v78HgIykd37v9x49eig90SWbp6pDhw7Z/n6tUqUKGjRogOvXr2Pbtm0ICAiAsbExOnbsmGu9Jfl+SE1NxfHjxwHI92LLzNPTE7t27cLJkydx5MgRPH78GCtXrsy13mfPnsHDw0Ocj8zMzAxHjhyRm/eNiIiIiApGRdkBEBEREdHXKSoqCv379xd7TFWrVk3cNmTIELx7905cls1TItOjRw9YWlpCIpHA19c3T0muorBt2zbxRawgCNi+fbu4TUND47PzUTVo0ACqqqrisrq6OiZOnKjw6dGjB5ydnfP8Unv9+vXo2LGjmHiR9RDILfHi4+MDiUQifl68eJGnY2VNVBZ2+ZKuINd69uzZ4nUuzrmGvLy8xOO2aNGi2I7bokUL8bhZe/KkpKTAy8sL06dPhyAIkEgkWLRoEf74449iSWpkvucLem9u3bpV/P/U1FTs2bNHXLa0tPxsb67SLLthC7Py9PQEAGzZsgXnzp3D999/n+OXDgp6P+R2jxW28+fPIyYmBo6OjqhUqVK2Zdq0aYPy5csjNTUVgwYNgrq6Or7//vsc67xy5QoaNGggJrkcHR1x/fp1JrmIiIiIConyvy5FRERERKXKyZMn8eHDB4X1hoaGGDp0qLg8bNgwvH79GgDg5OSE69evo1WrVrh+/ToiIyMxYMAAnDlzBhKJBA4ODlBRURGTYj///DP8/f0RGRkJb2/v4jmxbJw+fRqtWrVC8+bNcfnyZZw7d07c1q9fv88OM1i2bFkMGjQIf/31FwBgyZIluHXrFho3bgwtLS28ffsW165dw927d+Hp6Ql3d/fPxrR8+XK5uX4sLS3RoEEDrFu3Tq6clZWVOJdWQSUlJWHXrl3isq2tLerXr69Q7sGDBwgMDAQAHD16FB8+fICxsfFn65clEUuqorrWv/32mzis5a1bt8T1UVFRcsebNm0aypQpU9Dw8y0qKgoLFiyQW5a5deuWGFvZsmUxderUPNXZvXt3HD16VFxu0qQJVFVVFYatbNy4MRo3bvwl4ReZv/76CxEREahRowZOnDiBhw8fitsy/87LjY2NjdLv9/zed6Ghobh+/To0NTXRvn37HOvt06cPxo0bJ9ad2zxVxX0/3Lp1S/wdFhsbK7dt9+7dCAgIAADUq1dP/Decl+SeqqoqfvjhByxZsgQfPnxA165dc0x++/n5oVWrVuKwuxoaGujWrRv27t2rULa0zuNGREREpGxMdBERERFRvuzevRu7d+9WWG9tbS2+9N28eTP27dsHIKMX0z///ANdXV38888/qF27NhISEnDu3DksW7YMkyZNgqmpKYYNG4aNGzcCAF6/fo25c+cCAFq1aoWgoCC8ffu2mM7w/3l4eODYsWO4cOGC3HobGxssXrw4T3WsWrUKz58/x9mzZwFk9BaQzc9SEA8ePJBbfvv2LX755ReFcq6url+c6Dp48KDcPGTz5s3LttfC+fPn0apVKwAZPV62b9+On3/++YuOXRIU1bX+888/8fLlS4X1sbGxWL58ubg8atSoYk10xcTEyB0/s4cPH4oJHmtr6zwnurJew8uXL+Py5csK5WbNmlViE10tWrTAwYMHxQSIjIuLS7b3Q0mV3/vu0KFDEAQBrVu3hp6eXo71lilTBp07d8bevXtRq1Yt1KxZM8eyxX0/BAQE5HhPnzx5EidPngSQ0Sutd+/eEAQBhw8fBpD9/FyZeXp6YsmSJQCQay+zJ0+eyM0tmZKSIpdQzoyJLiIiIqKC4dCFRERERFSonj59ijFjxojL06ZNQ506dQAAlStXlksQTZ8+HXfu3AEArFmzBnPnzoW1tTXU1dVRsWJFTJo0CUeOHFHavC0TJ07Ezp074eLiAi0tLZQrVw6enp7w8/ODqalpnurQ0dHBqVOnsGPHDnTo0AFmZmZQU1ODtrY27O3t0aNHD/z5559YsWJFEZ9N/mUe6s3Q0BDfffddtuXc3Nzkhuj72oYvzK/Mc7s1aNCAx1WSzHGpqqrCxcWlQPVs2rQJK1asQLVq1aCpqQkLCwv8/PPPOH/+PLS1tQsr3BJHNj9Xbj2bZGTDFxbVsILFdY9dv34d7969Q4UKFVC3bt1cyzo6OqJu3bowMTFBhw4diiwmIiIiIvo8iaDs8ROIiIiIiEqIFy9ewNbWVly+cOFCsc51RIXD19cXbm5u4vLSpUsBAJUqVUKXLl0AZCTjZEOslSlTRuyh5OLiIrdvQTg6OuLRo0fQ1dVFUFAQKlSo8EX1RUREYMuWLQAyhtM8c+YMgIyeZL6+vgCA9PR0lClTBnFxcbC0tERQUJBcLxwvLy+xjrp164o90Lp27QoHB4cCxxYeHi7OUVW7dm3cunULKipf9n3KO3fuiL0eN2zYgGfPngHI6OUze/ZsABn/Nm/fvg0gY0g+2TCL3t7eYrJlz5494nmOGTMGq1ev/qK4SqqiuJdjY2NhYmKCtLQ0vH///rOJ/fT0dJw5cwZNmjSBvr5+gY6Zk6K4x3Ly66+/YvHixRg5ciTWrl372fKPHz9GQkICateuXeixrF27FklJSQgJCRF7OwMlf8hXIiIiImXg0IVERERERPRVmzRpEgCgS5cuYqIrs6ioKLHMzz///EWJrvDwcDx69AgAMGPGjC9OcgEZQybK4svJnTt3EBcXByBjbrHchpq7deuWOEeTg4PDFyW6Ll68CACQSCRYv359oSQg/vvvv8+e76FDhz6buJLFZmZmJg6F+rUrrHv5+PHjSElJQZMmTfLUe1VVVRXt2rUr0LE+pyjusZzkZX6uzKpUqVJksUyfPh0xMTFFVj8RERHR14SJLiIiIiIiokLy33//AQCqVq2K8ePHF9txZcmAVq1affHcbAU57sCBA9GwYcNiO25eyGJbunQpDA0NlRxN6dKnTx/06dNH2WEAKN57LCgoqEjrJyIiIqKiwaELiYiIiIj+h0MXEhEREREREZUuTHQRERERERERERERERFRqVR0g1sTERERERERERERERERFSEmuoiIiIiIiIiIiIiIiKhUYqKLiIiIiIiIiIiIiIiISiUmuoiIiIiIiIiIiIiIiKhUYqKLiIiIiIiIiIiIiIiISiUmuoiIiIiIiIiIiIiIiKhUYqKLiIiIiIiIiIiIiIiISiUmuoiIiIiIiIiIiIiIiKhUYqKLiIiIiIiIiIiIiIiISiUmuoiIiIiIiIiIiIiIiKhUYqKLiIiIiIiIiIiIiIiISiUmuoiIiIiIiIiIiIiIiKhUYqKLiIiIiIiIiIiIiIiISiUmuoiIiIiIiIiIiIiIiKhUYqKLiIiIiIiIiIiIiIiISiUmuoiIiIiIiIiIiIiIiKhUYqKLiIiIiIiIiIiIiIiISiUmuoiIiIiIiIiIiIiIiKhUYqKLiIiIiIiIiIiIiIiISiUmuoiIiIiIqEBatGiBFi1aFGqdL168gEQigY+PT6HWS3nj6+sLiUQCX19fZYeSo9evX0NLSwtXrlzJ8z4+Pj6QSCR48eLFZ8va2NjAy8urQLFJJBLMnj27QMel/EtNTYWVlRXWr1+v7FCIiKgYfMkz+kvweU5U8jHRRVRCyB6aso+amhosLS3h5eWFt2/fKjs88aWTRCLB/Pnzsy3z/fffQyKRQE9Pr5ijo6z8/Pwwe/ZsREdH52s/X19ffPfddzA3N4eGhgZMTU3RqVMn7N+/v2gCzaeEhATMnj27RL98IyIqyR48eIAePXrA2toaWlpasLS0RJs2bbBmzZpij2XHjh1YtWpVsR83L0r68/BbN3fuXDRo0ABNmjQR13l5ecm1pTN/Tp48qcRoFa1fv77YErlv375Fr169YGRkBAMDA3Tp0gXPnj3L076pqamYM2cO7OzsoKmpCTs7O8yfPx9paWkKZW/fvo127drBwMAA+vr6aNu2Lfz9/Yu8TnV1dYwfPx4LFixAUlJSns6LiOhrkPUdkpaWFipXroxRo0YhLCys0I9X0L/Fjxw5AldXV5iamkJHRwd2dnbo1atXiXs2y/z22284ePCgssOQk5KSgtWrV6N27dowMDCAkZERnJycMGzYMAQFBSk7PKXL2gbU1NRE5cqVMXPmzAK3DQIDAzF79mwmNksZNWUHQETy5s6dC1tbWyQlJeHatWvw8fHB5cuXERAQAC0tLWWHBy0tLezcuRPTp0+XWx8fH49Dhw6ViBgpI9E1Z84ceHl5wcjIKE/7zJo1C3PnzkWlSpXw448/wtraGpGRkTh+/Di6d++O7du3o1+/fkUb+GckJCRgzpw5AFDoPQiIiL52fn5+cHNzQ8WKFTF06FCYm5vj9evXuHbtGlavXo3Ro0cXazw7duxAQEAAxo4dK7fe2toaiYmJUFdXL9Z4ZErD87AoNW/eHImJidDQ0FB2KNmKiIjAli1bsGXLFoVtmpqa2LRpk8L6mjVrok2bNujTpw80NTWLI0xR//79FY67fv16GBsbF/k30j99+gQ3NzfExMRg6tSpUFdXx8qVK+Hq6gp/f3+UK1cu1/1/+OEH7N27F4MGDULdunVx7do1zJgxA69evcKff/4plrtz5w6aNm0KKysrzJo1C1KpFOvXr4erqytu3LiBKlWqFGmdAwcOxK+//oodO3Zg0KBBhXgFiYhKvszvkC5fvowNGzbg+PHjCAgIgI6OTqEdpyB/iy9btgyTJk2Cq6srpkyZAh0dHTx9+hRnz57Frl270K5du0KLr7D89ttv6NGjB7p27Sq3PrvneXHp3r07Tpw4gb59+2Lo0KFITU1FUFAQjh49isaNG6Nq1arFHlNJk7kNGBMTg0OHDmHevHkICQnB9u3b811fYGAg5syZgxYtWsDGxqaQo6UiIxBRieDt7S0AEG7evCm3fvLkyQIAYffu3UqKLMPz588FAMJ3330nABD8/f3ltm/fvl1QV1cXOnXqJOjq6iopysKRmJgopKenKzuML7J06VIBgPD8+fM8ld+7d68AQOjRo4eQkpKisP3kyZPCkSNHCjnK/IuIiBAACLNmzVJ2KEREpU6HDh0EExMTISoqSmFbWFhYgep0dXUVXF1dC7Svh4eHYG1tXaB9i0ppeR4WhdLS/lmxYoWgra0txMXFya339PQstDaotbW14OnpWaB989JOcXJyKvC/m/xYvHixAEC4ceOGuO7Ro0eCqqqqMGXKlFz3vXHjhgBAmDFjhtz6CRMmCBKJRLh37564rkOHDkKZMmWEDx8+iOvevXsn6OnpCd99912R1inTsWNHoVmzZrmeExHR1ySnd0jjx48XAAg7duwo1OPl92/x1NRUwcDAQGjTpk222wva9vySZ3Re6OrqFmn9+SV7di5YsEBhW1pamtxz8luVXRtQKpUKDRs2FCQSiRAaGprvOmV/E1y4cKGQoqTiwKELiUq4Zs2aAQBCQkLEdSkpKZg5cyZcXFxgaGgIXV1dNGvWDBcuXJDbt06dOvjuu+/k1jk7O0MikeD+/fviut27d0MikeDRo0efjadRo0awtbXFjh075NZv374d7dq1Q9myZbPd78SJE2jWrBl0dXWhr68PDw8PPHz4UK7M/fv34eXlBTs7O2hpacHc3ByDBg1CZGSkXLm4uDiMHTsWNjY20NTUhKmpKdq0aYM7d+6IZXIatznrXCKyeSh27dqF6dOnw9LSEjo6OoiNjQUAXL9+He3atYOhoSF0dHTg6uqqMB/E7NmzIZFI8OTJE/zwww8wNDSEiYkJZsyYAUEQ8Pr1a3Tp0gUGBgYwNzfH8uXLFeJKTk7GrFmz4ODgAE1NTVhZWeGXX35BcnKyXDmJRIJRo0bh4MGDqF69OjQ1NeHk5CTX7X/27NmYNGkSAMDW1lbsvp1bl+sZM2agbNmy2Lx5c7bfoHd3d0fHjh3F5fDwcAwePBhmZmbQ0tJCzZo1Fb5ZndMcH9nNveLl5QU9PT28ffsWXbt2hZ6eHkxMTDBx4kSkp6eL+5mYmAAA5syZI56XbB6M0NBQDBw4EBUqVICmpiYsLCzQpUsXdjUnIvqfkJAQODk5ZdvT19TUVG45LS0N8+bNg729PTQ1NWFjY4OpU6cqPJeyymn+gqzPhBYtWuDYsWN4+fKl+Ptc9m3JnOboOn/+vNiWMDIyQpcuXRTaLrJn8tOnT8VezYaGhhg4cCASEhI+e42K4nkoO59ly5Zh3bp1sLOzg46ODtq2bYvXr19DEATMmzcPFSpUgLa2Nrp06YKPHz/K1WFjY4OOHTvi9OnTqFWrFrS0tODo6KgwlOLHjx8xceJEODs7Q09PDwYGBmjfvj3u3buX7c8ju/ZPds/v4OBgdO/eHebm5tDS0kKFChXQp08fxMTEiGXyes/IzuXy5cuoX78+tLS0YGdnh3/++eezPx8AOHjwIBo0aJDvobKzuzcFQcD8+fNRoUIF6OjowM3NTaF9KhMdHY2xY8fCysoKmpqacHBwwOLFiyGVSvN1XBsbGzx8+BAXL14U7/0WLVrg2bNnkEgkWLlypUIdfn5+kEgk2LlzJxISEhAUFIQPHz589pz37duHevXqoV69euK6qlWrolWrVtizZ0+u+166dAkA0KdPH7n1ffr0gSAI2L17t1zZ1q1by/UQs7CwgKurK44ePYpPnz4VWZ0ybdq0weXLlxX+7RARfWtatmwJAHj+/DmAvD+fb926BXd3dxgbG0NbWxu2trZiL9nP/S2enQ8fPiA2NlZumOHMsrY98/pOJDt5fUZLpVKsXr0azs7O0NLSgomJCdq1a4dbt24ByHjfEh8fjy1btojnKHuvlFMbd/369XBycoKmpibKly+PkSNHKkwh0aJFC1SvXh2BgYFwc3ODjo4OLC0tsWTJks+em+xdYHbXUVVVVe456eXllW3vI1n7OKtt27ahfv360NHRQZkyZdC8eXOcPn1arsyJEyfg6uoKfX19GBgYoF69egrvA/Py3iwv7/Hy0t7MK4lEgqZNm0IQBLkhm1++fIkRI0agSpUq0NbWRrly5dCzZ0+5n6uPjw969uwJAHBzcxPvhcxt47y846Tix6ELiUo42S/bMmXKiOtiY2OxadMmsdtyXFwc/v77b7i7u+PGjRuoVasWgIwk2c6dO8X9Pn78iIcPH0JFRQWXLl1CjRo1AGT8IWliYoJq1arlKaa+ffti27ZtWLRoESQSCT58+IDTp09j69at2Y6zvHXrVnh6esLd3R2LFy9GQkICNmzYgKZNm+Lu3bvig/jMmTN49uwZBg4cCHNzczx8+BB//vknHj58iGvXrokP5uHDh2Pfvn0YNWoUHB0dERkZicuXL+PRo0eoU6dOfi8xAGDevHnQ0NDAxIkTkZycDA0NDZw/fx7t27eHi4sLZs2aBRUVFXh7e6Nly5a4dOkS6tevL1dH7969Ua1aNSxatAjHjh3D/PnzUbZsWfzxxx9o2bIlFi9ejO3bt2PixImoV68emjdvDiCjsdW5c2dcvnwZw4YNQ7Vq1fDgwQOsXLkST548URgf+vLly9i/fz9GjBgBfX19/P777+jevTtevXqFcuXK4bvvvsOTJ0+wc+dOrFy5EsbGxgAgNkyzCg4ORlBQEAYNGgR9ff3PXqvExES0aNECT58+xahRo2Bra4u9e/fCy8sL0dHR+PnnnwvwEwDS09Ph7u6OBg0aYNmyZTh79iyWL18Oe3t7/PTTTzAxMcGGDRvw008/oVu3bmISV3Yfd+/eHQ8fPsTo0aNhY2OD8PBwnDlzBq9evWJXcyIiZAwJePXqVQQEBKB69eq5lh0yZAi2bNmCHj16YMKECbh+/ToWLlyIR48e4cCBA18cy7Rp0xATE4M3b96IL/ZzS1ycPXsW7du3h52dHWbPno3ExESsWbMGTZo0wZ07dxR+z/fq1Qu2trZYuHAh7ty5g02bNsHU1BSLFy/O8RhF/Tzcvn07UlJSMHr0aHz8+BFLlixBr1690LJlS/j6+mLy5Ml4+vQp1qxZg4kTJ2Lz5s0K8fXu3RvDhw+Hp6cnvL290bNnT5w8eRJt2rQBADx79gwHDx5Ez549YWtri7CwMPzxxx9wdXVFYGAgypcvL1dndu2frFJSUuDu7o7k5GSMHj0a5ubmePv2LY4ePYro6GgYGhoCyN898/TpU/To0QODBw+Gp6cnNm/eDC8vL7i4uMDJySnHa56amoqbN2/ip59+yrFM1gSQurq6GGNWM2fOxPz589GhQwd06NABd+7cQdu2bZGSkiJXLiEhAa6urnj79i1+/PFHVKxYEX5+fpgyZQrev3+fr7nmVq1ahdGjR0NPTw/Tpk0DAJiZmcHOzg5NmjTB9u3bMW7cOLl9tm/fDn19fXTp0gU3btyAm5sbZs2alesLRqlUivv372c7lF/9+vVx+vRpxMXF5Xivy14samtry62XDYN1+/ZtubJZy8nKpqSkICAgAA0bNiySOmVcXFwgCAL8/PzkktFERN8aWWJElgDJy/M5PDwcbdu2hYmJCX799VcYGRnhxYsX4hdqPve3eHZMTU2hra2NI0eOYPTo0Tl+KRrI/zuRzPLzjB48eDB8fHzQvn17DBkyBGlpabh06RKuXbuGunXrYuvWrRgyZAjq16+PYcOGAQDs7e1zPPbs2bMxZ84ctG7dGj/99BMeP36MDRs24ObNm7hy5Yrcl6aioqLQrl07fPfdd+jVqxf27duHyZMnw9nZGe3bt8/xGNbW1gAy2gJNmjSBmlrhvMqfM2cOZs+ejcaNG2Pu3LnQ0NDA9evXcf78ebRt2xZARsJn0KBBcHJywpQpU2BkZIS7d+/i5MmT4jDeeX1v9rn3eHltb+ZHdu9Tb968CT8/P/Tp0wcVKlTAixcvsGHDBrRo0QKBgYHQ0dFB8+bNMWbMGPz++++YOnWq+K5U9t+8vuMkJVBibzIiykTW7fzs2bNCRESE8Pr1a2Hfvn2CiYmJoKmpKbx+/Vosm5aWJiQnJ8vtHxUVJZiZmQmDBg0S18m62gYGBgqCIAiHDx8WNDU1hc6dOwu9e/cWy9WoUUPo1q1brvHJhi5cunSpEBAQIAAQLl26JAiCIKxbt07Q09MT4uPjFboMx8XFCUZGRsLQoUPl6gsNDRUMDQ3l1ickJCgcd+fOnQIA4b///hPXGRoaCiNHjsw13py6s2cdYunChQsCAMHOzk7u+FKpVKhUqZLg7u4uSKVSuRhtbW3lut/PmjVLACAMGzZMXJeWliZUqFBBkEgkwqJFi8T1UVFRgra2tlxsW7duFVRUVMTrKbNx40YBgHDlyhVxHQBBQ0NDePr0qbju3r17AgBhzZo14rr8DF146NAhAYCwcuXKz5YVBEFYtWqVAEDYtm2buC4lJUVo1KiRoKenJ8TGxgqC8P/XNmtXb9m95O3tLa7z9PQUAAhz586VK1u7dm3BxcVFXM5puISoqCjx/iQiouydPn1aUFVVFVRVVYVGjRoJv/zyi3Dq1CmFIfr8/f0FAMKQIUPk1k+cOFEAIJw/f15cl/W5KmvPZH3+ZPdMyGnowuyeE7Vq1RJMTU2FyMhIcd29e/cEFRUVYcCAAeI62TM5c3tIEAShW7duQrly5XK6NIIgFN3zUHY+JiYmQnR0tFh2ypQpAgChZs2aQmpqqri+b9++goaGhpCUlCSus7a2FgAI//77r7guJiZGsLCwEGrXri2uS0pKUhh+8Pnz54KmpqbcMzan9k/mbbKf1d27dwUAwt69e3O8Fvm5Z2TnkrltFx4eLmhqagoTJkzI8RiCIAhPnz5VaPPIyNoSWT+y+zPrvRkeHi5oaGgIHh4ecm29qVOnCgDk2mrz5s0TdHV1hSdPnsgd89dffxVUVVWFV69eieuytlOy+zeR09CFf/zxhwBAePTokbguJSVFMDY2FuOR/Xw+N3SUrM2UtW0lCBltdwBCUFBQjvv/+++/AgBh69atcutl7dPq1auL65ydnYXKlSsLaWlp4rrk5GShYsWKAgBh3759RVanzLt37wQAwuLFi3O7LEREX43s3iHt2rVLKFeunKCtrS28efMmz8/nAwcOZDsMYmYFmUZg5syZAgBBV1dXaN++vbBgwQLh9u3bCuXy804k67uevD6jz58/LwAQxowZo3D8zO2AnIYuzKkd0bZtW7m219q1awUAwubNm8V1rq6uAgDhn3/+EdclJycL5ubmQvfu3RWOlTU22f5mZmZC3759hXXr1gkvX75UKOvp6Zlt21rWPpYJDg4WVFRUhG7duim0G2XXIjo6WtDX1xcaNGggJCYmZlsmP+/NPvceLy/tzZzI3kNGREQIERERwtOnT4Vly5YJEolEqF69ukJsWV29elXh55PT0IX5ecdJxY9DFxKVMK1bt4aJiQmsrKzQo0cP6Orq4vDhw6hQoYJYRlVVVfzGrVQqxcePH5GWloa6devKdfuVDXv433//AcjouVWvXj20adNGHDokOjoaAQEBYtm8cHJyQo0aNcTeYjt27ECXLl2ynej0zJkziI6ORt++ffHhwwfxo6qqigYNGsgNt5j5W5tJSUn48OGD+E3NzOdlZGSE69ev4927d3mO+XM8PT3lju/v74/g4GD069cPkZGRYtzx8fFo1aoV/vvvP4Vu8EOGDBH/X1VVFXXr1oUgCBg8eLBc7FWqVJHrOr13715Uq1YNVatWlbtGsiEHsg5J2bp1a7lvFdWoUQMGBgZydeaHbJjGvHx7HQCOHz8Oc3Nz9O3bV1ynrq6OMWPG4NOnT7h48WKB4gAyvuWTWbNmzfJ0Xtra2tDQ0ICvry+ioqIKfHwioq9ZmzZtcPXqVXTu3Bn37t3DkiVL4O7uDktLSxw+fFgsd/z4cQDA+PHj5fafMGECAODYsWPFFzSA9+/fw9/fH15eXnLfBq5RowbatGkjxptZds+TyMhI8ZmXnaJ+Hvbs2VPu26gNGjQAAPzwww9y385t0KABUlJS8PbtW7n9y5cvj27duonLBgYGGDBgAO7evYvQ0FAAGRNxq6hk/ImXnp6OyMhI6OnpoUqVKnJtKZms7Z/syGI+depUjsM/5veecXR0lGt7mpiYKLSPsiMbzjrzN3Mz09LSwpkzZ+Q+2Q0ZDWT0EpT1sMs8nM/YsWMVyu7duxfNmjVDmTJl5NpqrVu3Rnp6utjW/lK9evWClpaW3KTpp06dwocPH/DDDz8AyBj+SBCEXHtzARk9DoGMeyIrLS0tuTLZ6dChA6ytrTFx4kTs378fL1++xJ49ezBt2jSoqanJ7TtixAg8efIEgwcPRmBgIAICAjBgwAC8f/9e7jhFUaeM7J7Iy5CORERfk8zvkPr06QM9PT0cOHAAlpaWeX4+y4a1Pnr0KFJTUwsttjlz5mDHjh2oXbs2Tp06hWnTpsHFxQV16tSRG346v+9EMsvrM/rff/+FRCLBrFmzFOrIbli/z5G1I8aOHSu2vQBg6NChMDAwUGj76Onpic9yANDQ0ED9+vU/2/aRSCQ4deoU5s+fjzJlymDnzp0YOXIkrK2t0bt3b4VhEvPi4MGDkEqlmDlzplzssuMBGe/y4uLi8Ouvv4rthqxl8vPe7HPv8fLS3sxNfHw8TExMYGJiAgcHB0ycOBFNmjTBoUOH5H6+mdu9qampiIyMhIODA4yMjLJtK2eVn3ecVPyY6CIqYdatW4czZ85g37596NChAz58+JDtH6hbtmxBjRo1oKWlhXLlysHExATHjh2TG7vWzMwMlSpVEpNaly5dQrNmzdC8eXO8e/cOz549w5UrVyCVSvOV6AKAfv36Ye/evXj69Cn8/PzEbstZBQcHA8gYJ1r20JF9Tp8+jfDwcLHsx48f8fPPP8PMzAza2towMTGBra0tAMid15IlSxAQEAArKyvUr18fs2fPLnCSR0Z2nKxxe3p6KsS9adMmJCcnK4wTXLFiRbllQ0NDaGlpiUMHZl6fORkTHByMhw8fKhyncuXKACB3jbI7DpDxx31BEzwGBgYAMsZMzouXL1+iUqVKCg0iWTfuly9fFigO2RjZmeX1vDQ1NbF48WKcOHECZmZmaN68OZYsWSK++CMiogz16tXD/v37ERUVhRs3bmDKlCmIi4tDjx49EBgYCCDj97iKigocHBzk9jU3N4eRkVGBf88XlOx4VapUUdhWrVo18Q/qzLI+K2UvwXN7phT18zC7dgIAWFlZZbs+a6wODg4KL2JkbQXZ0CxSqRQrV65EpUqVoKmpCWNjY5iYmOD+/fvZzm+Qtf2THVtbW4wfPx6bNm2CsbEx3N3dsW7dOrn68nvPfGlbRhCEbNerqqqidevWch8XF5dsy8piqlSpktx6ExMThURacHAwTp48qdBWa926NQDFtlpBGRkZoVOnTnJzX2zfvh2Wlpbiy768kr3IyW5uk6SkJLky2dHS0sKxY8dQrlw5dO/eHTY2NhgwYABmzpyJsmXLyg01Onz4cEydOhU7duyAk5MTnJ2dERISgl9++QXA/w9LWhR1ysjuiYK8rCQiKs1k75AuXLiAwMBAPHv2DO7u7gDy/nx2dXVF9+7dMWfOHBgbG6NLly7w9vbO0/xYiYmJCA0Nlftk1rdvX1y6dAlRUVE4ffo0+vXrh7t376JTp07i8yi/70Qyy+szOiQkBOXLl891CMX8yKl9qqGhATs7O4W2T4UKFRSeUfl53zFt2jQ8evQI7969w86dO9GwYUPs2bMHo0aNynfsISEhUFFRgaOjY65lAOQ63Hl+3pt97j1eXtqbucn8ZSdvb29Uq1YN4eHhCm2dxMREzJw5U5zPTdZWjo6OztOx8vOOk4of5+giKmHq16+PunXrAgC6du2Kpk2bol+/fnj8+LH4B922bdvg5eWFrl27YtKkSTA1NYWqqioWLlwoPoxkmjZtinPnziExMRG3b9/GzJkzUb16dRgZGeHSpUt49OgR9PT0ULt27XzF2bdvX0yZMgVDhw5FuXLlxDF8s5J9e2Pr1q0wNzdX2J75G8y9evWCn58fJk2ahFq1akFPTw9SqRTt2rWT6z3Vq1cvNGvWDAcOHMDp06exdOlSLF68GPv37xfHNs7pj9z09HSoqqoqrM/68JMdb+nSpeKcZ1ll/QM7u3qzWwfIv6CRSqVwdnbGihUrsi2b9QVYXurMj6pVqwIAHjx4UKD9c5LbzyA7OZ1XXo0dOxadOnXCwYMHcerUKcyYMQMLFy7E+fPn831/ExF97TQ0NFCvXj3Uq1cPlStXxsCBA7F37165b7kW5IVxfn/3F5WCPCuL6nn4uZgK87n+22+/YcaMGRg0aBDmzZuHsmXLQkVFBWPHjlXoiQ7knujIbPny5fDy8sKhQ4dw+vRpjBkzBgsXLsS1a9fkRh3I6z1T0HOWzTdS3L23pVIp2rRpIyZZspK9iCsMAwYMwN69e+Hn5wdnZ2ccPnwYI0aMUEiofk7ZsmWhqakp9oDKTLYu65xtWTk5OSEgIACBgYGIioqCo6MjtLW1MW7cOLi6usqVXbBgASZOnIiHDx/C0NAQzs7OmDp1KgD561MUdQL/f09k/YIZEdHXLvM7pJx87vkskUiwb98+XLt2DUeOHMGpU6cwaNAgLF++HNeuXct1HtXdu3dj4MCBcuuye54bGBigTZs2aNOmDdTV1bFlyxZcv34drq6u+X4nkllxPqO/RGG19ywsLNCnTx90794dTk5O2LNnD3x8fKCmplbs7fD8vDfLy3u8vLY3syP7spOMu7s7qlatih9//FFu5IrRo0fD29sbY8eORaNGjWBoaAiJRII+ffpk21bO6Zzz8o6Tih+vPlEJJkteubm5Ye3atfj1118BAPv27YOdnR32798v9yDLrgt2s2bN4O3tjV27diE9PR2NGzeGiooKmjZtKia6GjdunO8kQ8WKFdGkSRP4+vrip59+yvGXuWyIPVNTU7mHTlZRUVE4d+4c5syZg5kzZ4rrZd+WyMrCwgIjRozAiBEjEB4ejjp16mDBggXiA7JMmTLZduF++fIl7OzsPnt+srgNDAxyjbsw2Nvb4969e2jVqlWhfQs1P/VUrlwZVapUwaFDh7B69epcG7FAxmSo9+/fh1QqlXvpEhQUJG4H/v/b81l/Dl/SE+Bz52Vvb48JEyZgwoQJCA4ORq1atbB8+XJs27atwMckIvrayV6OyF5+W1tbQyqVIjg4WOydBABhYWGIjo4Wf89nJz+/+/P6rJId7/HjxwrbgoKCYGxsDF1d3TzVlZuieh4WlqdPn0IQBLnr9uTJEwAQJ73et28f3Nzc8Pfff8vtGx0d/cUJAGdnZzg7O2P69Onw8/NDkyZNsHHjRsyfP/+L7pn8qFixIrS1tfH8+fMvrksWU3BwsFzbMCIiQiGRZm9vj0+fPhVamzC3e79du3YwMTHB9u3b0aBBAyQkJKB///75PoaKigqcnZ1x69YthW3Xr1+HnZ1dnobplEgkcHJyEpePHz8OqVSa7bUoU6YMmjZtKi6fPXsWFSpUEJPIRVmn7J7IfP8REX3r8vt8btiwIRo2bIgFCxZgx44d+P7777Fr1y4MGTIkx2eXu7s7zpw5k6+46tatiy1btohtzy95J5LXZ7S9vT1OnTqFjx8/5tqrqyDt08ztiJSUFDx//rzI3yOpq6ujRo0aCA4OxocPH2Bubp7re7DM7O3tIZVKERgYmGOCSvZOLCAgQKFHYNYyeX1v9rn3eEDu7c38sLCwwLhx4zBnzhxcu3ZNnBZl37598PT0lBvaOikpSeG65XQf5PUdJykHhy4kKuFatGiB+vXrY9WqVWK3bllSKvM3P65fv46rV68q7C8bknDx4sWoUaOGOBxOs2bNcO7cOdy6dSvfwxbKzJ8/H7NmzcLo0aNzLOPu7g4DAwP89ttv2Y71HBERkeM5AcCqVavkltPT0xW6E5uamqJ8+fJy3ert7e1x7do1pKSkiOuOHj2K169f5+ncXFxcYG9vj2XLluHTp085xl0YevXqhbdv3+Kvv/5S2JaYmKgwHFNeyF745XW85jlz5iAyMhJDhgxBWlqawvbTp0/j6NGjADLmVwgNDcXu3bvF7WlpaVizZg309PTEb+NaW1tDVVVVYd6K9evX5/t8ZGTzwGU9r4SEBPHfh4y9vT309fXzNNwCEdG34MKFC9l+a1Q2f4Ns6JUOHToAUHwGy75l6+HhkeMxZH/8Zf7dn56ejj///FOhrK6ubp6GCLGwsECtWrWwZcsWud//AQEBOH36tBhvYSiK52FheffuHQ4cOCAux8bG4p9//kGtWrXEb5Sqqqoq/Iz37t2rMN9XfsTGxipcC2dnZ6ioqIjP2C+5Z/JDXV0ddevWzTZ5k1+tW7eGuro61qxZI3fNsp4DkNFWu3r1Kk6dOqWwLTo6Ott7JTe6uro5ttHU1NTQt29f8Rvazs7OqFGjhrg9ISEBQUFBeZqLqkePHrh586bc9Xr8+DHOnz+Pnj17ypUNCgrCq1evcq0vMTERM2bMgIWFhdzcdNnZvXs3bt68qTB3SVHVefv2bUgkEjRq1CjXOoiIviV5fT5HRUUptB9kCRDZsz6nv8UtLCwUhg0GMp5X2b2jAoATJ04A+P+255e8E8nrM7p79+4QBAFz5sxRKJf53HN7RmfWunVraGho4Pfff5fb/++//0ZMTEyhtX2Cg4OzfT5HR0fj6tWrKFOmjDgFhL29PWJiYnD//n2x3Pv37+Xaj0DG6FEqKiqYO3euQi8m2bm0bdsW+vr6WLhwocK7FlmZvL43y8t7vLy0N/Nr9OjR0NHRwaJFi8R12bWV16xZo9DrLad3anl9x0nKwR5dRKXApEmT0LNnT/j4+GD48OHo2LEj9u/fj27dusHDwwPPnz/Hxo0b4ejoqPBwcXBwgLm5OR4/fiyXkGrevDkmT54MAAVOdLm6un72JY6BgQE2bNiA/v37o06dOujTpw9MTEzw6tUrHDt2DE2aNMHatWthYGAgzquUmpoKS0tLnD59WuEbu3FxcahQoQJ69OiBmjVrQk9PD2fPnsXNmzflvpExZMgQ7Nu3D+3atUOvXr0QEhKCbdu2iS/gPkdFRQWbNm1C+/bt4eTkhIEDB8LS0hJv377FhQsXYGBggCNHjuT/omWjf//+2LNnD4YPH44LFy6gSZMmSE9PR1BQEPbs2YNTp059diiCrGTzUUybNg19+vSBuro6OnXqlOM33nv37o0HDx5gwYIFuHv3Lvr27Qtra2tERkbi5MmTOHfunDhfxLBhw/DHH3/Ay8sLt2/fho2NDfbt24crV65g1apV4reDDQ0N0bNnT6xZswYSiQT29vY4evToF41ZrK2tDUdHR+zevRuVK1dG2bJlUb16daSlpaFVq1bo1asXHB0doaamhgMHDiAsLAx9+vQp8PGIiL4mo0ePRkJCArp164aqVasiJSUFfn5+2L17N2xsbMRhZ2rWrAlPT0/8+eefiI6OhqurK27cuIEtW7aga9eucHNzy/EYTk5OaNiwIaZMmSJ+Y3bXrl3ZJgJcXFywe/dujB8/HvXq1YOenh46deqUbb1Lly5F+/bt0ahRIwwePBiJiYlYs2YNDA0NMXv27EK5PkDRPA8LS+XKlTF48GDcvHkTZmZm2Lx5M8LCwuDt7S2W6dixI+bOnYuBAweicePGePDgAbZv356n3uw5OX/+PEaNGoWePXuicuXKSEtLw9atW6Gqqoru3bsD+LJ7Jr+6dOmCadOmITY2VpxXrSBMTEwwceJELFy4EB07dkSHDh1w9+5dnDhxQqH326RJk3D48GF07NgRXl5ecHFxQXx8PB48eIB9+/bhxYsX+eox5+Ligg0bNmD+/PlwcHCAqamp3BxcAwYMwO+//44LFy5g8eLFcvveuHEDbm5umDVr1mfv/REjRuCvv/6Ch4cHJk6cCHV1daxYsQJmZmaYMGGCXNlq1arB1dUVvr6+4rpevXqhfPnycHR0RGxsLDZv3oxnz57h2LFjcvf3f//9h7lz56Jt27YoV64crl27Bm9vb7Rr1w4///yz3HGKok4gY3L4Jk2aiMNbEhFR3p/PW7Zswfr169GtWzfY29sjLi4Of/31FwwMDMRkWU5/i+c0h1NCQgIaN26Mhg0bol27drCyskJ0dDQOHjyIS5cuoWvXruIUA1/yTiSvz2g3Nzf0798fv//+O4KDg8UpMi5dugQ3NzdxrisXFxecPXsWK1asQPny5WFra4sGDRooHNfExARTpkzBnDlz0K5dO3Tu3BmPHz/G+vXrUa9ePfzwww9f/PMDgHv37qFfv35o3749mjVrhrJly+Lt27fYsmUL3r17h1WrVolfHO/Tpw8mT56Mbt26YcyYMUhISMCGDRtQuXJl3LlzR6zTwcEB06ZNw7x589CsWTN899130NTUxM2bN1G+fHksXLgQBgYGWLlyJYYMGYJ69eqhX79+KFOmDO7du4eEhARs2bIlz+/N8vIeLy/tzfwqV64cBg4ciPXr1+PRo0eoVq0aOnbsiK1bt8LQ0BCOjo64evUqzp49q9B+qFWrFlRVVbF48WLExMRAU1MTLVu2hKmpaZ7ecZKSCERUInh7ewsAhJs3bypsS09PF+zt7QV7e3shLS1NkEqlwm+//SZYW1sLmpqaQu3atYWjR48Knp6egrW1tcL+PXv2FAAIu3fvFtelpKQIOjo6goaGhpCYmPjZ+J4/fy4AEJYuXZprOU9PT0FXV1dh/YULFwR3d3fB0NBQ0NLSEuzt7QUvLy/h1q1bYpk3b94I3bp1E4yMjARDQ0OhZ8+ewrt37wQAwqxZswRBEITk5GRh0qRJQs2aNQV9fX1BV1dXqFmzprB+/XqFYy5fvlywtLQUNDU1hSZNmgi3bt0SXF1dBVdXV7m4AAh79+7N9nzu3r0rfPfdd0K5cuUETU1NwdraWujVq5dw7tw5scysWbMEAEJERESeroWrq6vg5OQkty4lJUVYvHix4OTkJGhqagplypQRXFxchDlz5ggxMTFiOQDCyJEjFeq0trYWPD095dbNmzdPsLS0FFRUVAQAwvPnz7M9x8zOnTsndOnSRTA1NRXU1NQEExMToVOnTsKhQ4fkyoWFhQkDBw4UjI2NBQ0NDcHZ2Vnw9vZWqC8iIkLo3r27oKOjI5QpU0b48ccfhYCAAAGAXPmcrpXs2mbm5+cnuLi4CBoaGuK98eHDB2HkyJFC1apVBV1dXcHQ0FBo0KCBsGfPns+eMxHRt+LEiRPCoEGDhKpVqwp6enqChoaG4ODgIIwePVoICwuTK5uamirMmTNHsLW1FdTV1QUrKythypQpQlJSkly5rM9VQRCEkJAQoXXr1oKmpqZgZmYmTJ06VThz5owAQLhw4YJY7tOnT0K/fv0EIyMjAYDYhpG1ObI+V86ePSs0adJE0NbWFgwMDIROnToJgYGBcmVyeibL2ll5eRYKQuE+D3NqQ+XUBsmuTWhtbS14eHgIp06dEmrUqCFoamoKVatWVdg3KSlJmDBhgmBhYSFoa2sLTZo0Ea5evZqv9o9sm+xn9ezZM2HQoEGCvb29oKWlJZQtW1Zwc3MTzp49K7dfXu8Z2blkld29lJ2wsDBBTU1N2Lp1q9z6nNoSMtndA+np6cKcOXPE69WiRQshICAg23ZVXFycMGXKFMHBwUHQ0NAQjI2NhcaNGwvLli0TUlJSxHKZ2605HTc0NFTw8PAQ9PX1BQDZnreTk5OgoqIivHnzRm697OeT+Ri5ef36tdCjRw/BwMBA0NPTEzp27CgEBwcrlMsujsWLFwtVq1YVtLS0hDJlygidO3cW7t69q7Dv06dPhbZt2wrGxsbivblw4UIhOTlZoWxR1BkdHS1oaGgImzZtytM1ISL6GuT2DimzvDyf79y5I/Tt21eoWLGioKmpKZiamgodO3aUe18jCNn/LZ7bcf/66y+ha9eu4rsrHR0doXbt2sLSpUsVfp/n9Z3Ilzyj09LShKVLlwpVq1YVNDQ0BBMTE6F9+/bC7du3xTJBQUFC8+bNBW1tbQGAeKyc2pJr164VqlatKqirqwtmZmbCTz/9JERFRcmVye4dkCAIOb7DyywsLExYtGiR4OrqKlhYWAhqampCmTJlhJYtWwr79u1TKH/69GmhevXqgoaGhlClShVh27Zt2b5XEQRB2Lx5s1C7dm3xeru6ugpnzpyRK3P48GGhcePGYvu7fv36ws6dO+XKfO69WV7e4+W1vZmd3NqAISEhgqqqqvhzjIqKEtvuenp6gru7uxAUFJTtffXXX38JdnZ2gqqqqsLfMXl5x0nFTyIIBZjlmIiIiIiIiIqFjY0NqlevLg6b+K0bPHgwnjx5gkuXLik7lCJTu3ZtlC1bFufOnVN2KCXeqlWrsGTJEoSEhEBbW1vZ4RARERGREnCOLiIiIiIiIio1Zs2ahZs3b+LKlSvKDqVI3Lp1C/7+/hgwYICyQynxUlNTsWLFCkyfPp1JLiIiIqJvGOfoIiIiIiIiolKjYsWKChOjfw0CAgJw+/ZtLF++HBYWFujdu7eyQyrx1NXV8erVK2WHQURERERKxh5dREREREREREq2b98+DBw4EKmpqdi5cye0tLSUHRIRERERUanAObqIiIiIiIiIiIiIiIioVGKPLiIiIiIiIiIiIiIiIiqVmOgiIiIiIiIiIiIiIiKiUklN2QGUBlKpFO/evYO+vj4kEomywyEiIqISRBAExMXFoXz58lBR+ba/Q8Q2ExEREWWH7SUiIiIqSkx05cG7d+9gZWWl7DCIiIioBHv9+jUqVKig7DCUim0mIiIiyg3bS0RERFQUmOjKA319fQAZDTIDAwMlR0NEREQlSWxsLKysrMT2wreMbSYiIiLKDttLREREVJSY6MoD2dA7BgYGfGlDRERE2eJQfWwzERERUe7YXiIiIqKiwIGRiYiIiIiIiIiIiIiIqFRioouIiIiIiIiIiIiIiIhKJSa6iIiIiIiIiIiIiIiIqFTiHF1EREREREREX6H09HSkpqYqOwz6Bqirq0NVVVXZYRAREdE3iokuIiIiIiIioq+IIAgIDQ1FdHS0skOhb4iRkRHMzc0hkUiUHQoRERF9Y5joIiIiIiIiIvqKyJJcpqam0NHRYeKBipQgCEhISEB4eDgAwMLCQskRERER0beGiS4iIiIiIiKir0R6erqY5CpXrpyyw6FvhLa2NgAgPDwcpqamHMaQiIiIipWKsgMgIiIiIiIiosIhm5NLR0dHyZHQt0Z2z3FeOCIiIipuTHQRERERERERfWU4XCEVN95zREREpCxMdBEREREREREREREREVGpxEQXEREREREREVEJlZKSAgcHB/j5+Skthl9//RWjR49W2vGJiIiIcqOm7ACIiIiIiIiIqBj8MbF4j/fjsnzv8vr1a8yaNQsnT57Ehw8fYGFhga5du2LmzJkoV65cEQSZuxYtWqBWrVpYtWpVsR9bZuPGjbC1tUXjxo3FdRKJBAcOHEDXrl3lynp5eSE6OhoHDx7MdlnG19cXbm5uiIqKgpGRkcJyVhMnToSdnR3GjRsHOzu7Qj5DIiIioi/DHl1EREREREREpHTPnj1D3bp1ERwcjJ07d+Lp06fYuHEjzp07h0aNGuHjx4/KDrHYCYKAtWvXYvDgwUqNw9jYGO7u7tiwYYNS4yAiIiLKDhNdRERERERERKR0I0eOhIaGBk6fPg1XV1dUrFgR7du3x9mzZ/H27VtMmzZNLCuRSBR6KRkZGcHHx0dcnjx5MipXrgwdHR3Y2dlhxowZSE1NFbfPnj0btWrVwtatW2FjYwNDQ0P06dMHcXFxADJ6Q128eBGrV6+GRCKBRCLBixcv4OPjo9Dr6eDBg5BIJAp1b968GRUrVoSenh5GjBiB9PR0LFmyBObm5jA1NcWCBQtyvSa3b99GSEgIPDw88nk1C1+nTp2wa9cuZYdBREREpIBDF9I3ZdSmy0Va/9ohTYu0fiIiIiIiKmTFPZxfUdPSB6q1AT5qAepZ/uRPSyneWCJe57noR1VdnDp1CgsWLIC2trbcNnNzc3z//ffYvXs31q9fL5dQyo2+vj58fHxQvnx5PHjwAEOHDoW+vj5++eUXsUxISAgOHjyIo0ePIioqCr169cKiRYuwYMECrF69Gk+ePEH16tUxd+5cAICJiUmezykkJAQnTpzAyZMnERISgh49euDZs2eoXLkyLl68CD8/PwwaNAitW7dGgwYNsq3j0qVLqFy5MvT19fN83KJSv359vHnzBi9evICNjY2ywyEiIiISMdFFREREREREREoVHBwMQRBQrVq1bLdXq1YNUVFRiIiIgKmpaZ7qnD59uvj/NjY2mDhxInbt2iWX6JJKpfDx8RETSf3798e5c+ewYMECGBoaQkNDAzo6OjA3N8/3OUmlUmzevBn6+vpwdHSEm5sbHj9+jOPHj0NFRQVVqlTB4sWLceHChRwTXS9fvkT58uWz3da3b1+oqqrKrUtOTlbo/XX06FHo6enJrUtPT8/3+cjiePnyJRNdREREVKJw6EIiIiKir9S6detgY2MDLS0tNGjQADdu3MixrI+Pjzgsk+yjpaVVjNESERFlzEmVGw0NjTzXtXv3bjRp0gTm5ubQ09PD9OnT8erVK7kyNjY2cr2lLCwsEB4enr+gc5C1bjMzMzg6OkJFRUVuXW7HS0xMzPF5vHLlSvj7+8t9OnfurFDOzc1NodymTZvyfT6ynnYJCQn53peIiIioKDHRRURERPQV2r17N8aPH49Zs2bhzp07qFmzJtzd3XN9mWZgYID379+Ln5cvXxZjxERE9C1zcHCARCLBo0ePst3+6NEjmJiYiHNjSSQShaRY5vm3rl69iu+//x4dOnTA0aNHcffuXUybNg0pKfLDN6qrq8stSyQSSKXSXGNVUVHJ9di51Z3f4xkbGyMqKirbbebm5nBwcJD7ZDfEoa6urkI5S0vLHI+Zk48fPwLI3/CNRERERMWBiS4iIiKir9CKFSswdOhQDBw4EI6Ojti4cSN0dHSwefPmHPeRSCQwNzcXP2ZmZsUYMRERfcvKlSuHNm3aYP369UhMTJTbFhoaiu3bt8PLy0tcZ2Jigvfv34vLwcHBcj2N/Pz8YG1tjWnTpqFu3bqoVKlSgb7AoaGhoTDMn4mJCeLi4hAfHy+u8/f3z3fdeVG7dm0EBQV9tqdbcQgICIC6ujqcnJyUHQoRERGRHCa6iIiIiL4yKSkpuH37Nlq3bi2uU1FRQevWrXH16tUc9/v06ROsra1hZWWFLl264OHDh8URLhEREQBg7dq1SE5Ohru7O/777z+8fv0aJ0+eRJs2bVC5cmXMnDlTLNuyZUusXbsWd+/exa1btzB8+HC53lKVKlXCq1evsGvXLoSEhOD333/HgQMH8h2TjY0Nrl+/jhcvXuDDhw+QSqVo0KABdHR0MHXqVISEhGDHjh3w8fEpjEugwM3NDZ8+fSq2Z/KDBw/khji8d++euO3SpUto1qyZOIQhERERUUnBRBcRERHRV+bDhw9IT09X6JFlZmaG0NDQbPepUqUKNm/ejEOHDmHbtm2QSqVo3Lgx3rx5k+NxkpOTERsbK/chIiIqqEqVKuHmzZuws7NDr169YG1tjfbt26Ny5cq4cuUK9PT0xLLLly+HlZUVmjVrhn79+mHixInQ0dERt3fu3Bnjxo3DqFGjUKtWLfj5+WHGjBn5jmnixIlQVVWFo6MjTExM8OrVK5QtWxbbtm3D8ePH4ezsjJ07d2L27NmFcQkUlCtXDt26dcP27duLpP6smjdvjtq1a4sfFxcXcduuXbswdOjQYomDiIiIKD8kQkno/17CxcbGwtDQEDExMTAwMFB2OPQFRm26XKT1rx3StEjrJyKikqckthPevXsHS0tL+Pn5oVGjRuL6X375BRcvXsT169c/W0dqaiqqVauGvn37Yt68edmWmT17NubMmaOwviRdCyp8Rd2eos9jm7OQ/TFR2REUqiQtfTyv1ga2FSygpa6m7HDy7BWMsl2/YvECbNq4Dtv2HkSduvWLN6gS4tHDAPzQswv+u3EPupmSfYWtooni/F4yJ06cwIQJE3D//n2oqWV/XyUlJeH58+ewtbWFlpaW3LaS2F4iIiKirwd7dBERERF9ZYyNjaGqqoqwsDC59WFhYTA3N89THerq6qhduzaePn2aY5kpU6YgJiZG/Lx+/fqL4iYiIspq/ORpmP3bEty9fRNSqVTZ4ShFNafq+HXmXLx+lf85xgpLfHw8vL29c0xyERERESkTWyhEREREXxkNDQ24uLjg3Llz6Nq1KwBAKpXi3LlzGDVqVJ7qSE9Px4MHD9ChQ4ccy2hqakJTU7MwQiYiIspRr74/KDsEpevZ53ulHr9Hjx5KPT4RERFRbpjoIiIiIvoKjR8/Hp6enqhbty7q16+PVatWIT4+HgMHDgQADBgwAJaWlli4cCEAYO7cuWjYsCEcHBwQHR2NpUuX4uXLlxgyZIgyT4OIiIiIiIiIKFdMdBERERF9hXr37o2IiAjMnDkToaGhqFWrFk6ePAkzMzMAwKtXr6Ci8v+jWEdFRWHo0KEIDQ1FmTJl4OLiAj8/Pzg6OirrFIiIiIiIiIiIPouJLiIiIqKv1KhRo3IcqtDX11dueeXKlVi5cmUxREVEREREREREVHhUPl+EiIiIiIiIiIiIiIiIqORhj65v3KhNl4u0/rVDmhZp/URERPQN+WOisiMgAFDtquwIiIiIiIiIiETs0UVERERERERERERERESlklITXRs2bECNGjVgYGAAAwMDNGrUCCdOnBC3t2jRAhKJRO4zfPhwuTpevXoFDw8P6OjowNTUFJMmTUJaWppcGV9fX9SpUweamppwcHCAj49PcZweERERERERERERERERFSGlJroqVKiARYsW4fbt27h16xZatmyJLl264OHDh2KZoUOH4v379+JnyZIl4rb09HR4eHggJSUFfn5+2LJlC3x8fDBz5kyxzPPnz+Hh4QE3Nzf4+/tj7NixGDJkCE6dOlWs50pEREREREREX87a1ACnjh8t8uNcvXIJ1qYGiImJLpT6Xr96CWtTAzx8cL9Q6iMiIiKiDEqdo6tTp05yywsWLMCGDRtw7do1ODk5AQB0dHRgbm6e7f6nT59GYGAgzp49CzMzM9SqVQvz5s3D5MmTMXv2bGhoaGDjxo2wtbXF8uXLAQDVqlXD5cuXsXLlSri7uxftCRIRERERERGVEKP+DS7W463tXqlA+4WHhWHtqqU4f+Y0wkLfoZyxCRyrO2PQsBFo2rxF4QaZC5d6DXDzQTAMDAyL7ZhERFS6JKenIjTxI2JS4hGbkoCY1ATEpSQgJjUecSkJiE1NQExKAuJSE/ApLRHpUimkghRSCEgXpFj70R5lX0cAEknGR00NEk1NSDQ0Mv6rqQnI/l9LCyr6+pAYGEDFwCDj/7W1lX0JiEoEpSa6MktPT8fevXsRHx+PRo0aieu3b9+Obdu2wdzcHJ06dcKMGTOgo6MDALh69SqcnZ1hZmYmlnd3d8dPP/2Ehw8fonbt2rh69Spat24tdyx3d3eMHTu2WM6LiIiIiIiIiPLm9auX6N6xLQwMDTF11jxUdXREWmoaLl44h5m/TsB5v9vFFouGhgZMM71vICKib1OqNA3vEiLxJv4DXn+KwJv4CLyO/4A38RGISIqBAKHglaekQkhIkFuVr9rU1cXkl2q5clAxNoaKiQlUjY2hYsgvatC3Q+mJrgcPHqBRo0ZISkqCnp4eDhw4AEdHRwBAv379YG1tjfLly+P+/fuYPHkyHj9+jP379wMAQkND5ZJcAMTl0NDQXMvExsYiMTER2tlkvZOTk5GcnCwux8bGFt4JExEREREREVG2pk8eD4lEgsMnL0BHV1dcX7lqNfTq90O2+yycOxOnjh/B+/fvYGJihq49euLnCb9CXV0dABAY8ABzZvyKB/53IZFIYGNnj4XLVqFGrTp48/oVZk6ZiJvXryE1NQUVrCpi6qx5aNnaHVevXEKfbh64H/wKhoZGAICb169h2cK58L97GxoamqhVuw7W/ukNQ6My8D1/BmtWLMWToEdQUVVBnbr1MXv+Yljb2hX5dSMiosIRmxKPh1Ev8TD6JYKiX+NVfDjCE6ORLkiVHVr2UlMh/fgR+PgR6S9eyG/T0MhIfpmYQNXcHKoVKkDVwgISNaWnBIgKndLv6ipVqsDf3x8xMTHYt28fPD09cfHiRTg6OmLYsGFiOWdnZ1hYWKBVq1YICQmBvb19kcW0cOFCzJkzp8jqJyIiIiIiIiJ50VEfcfH8WUyaOlMuySUjSzZlpaunh2W/b4SZuTkePwrEr+NHQ09XH8NHjwUA/DxiCJyq18CCJSuhqqqCwIAHUFPLSILN+HUCUlNSsPfQCejo6CD4SRB0dfWyPc7DB/fxfY9O6Nn3B8yavxhqamrwu/If0tMzXn4mxCdgyPBRqObohPj4eKxYsgDDvL7HiQtXoKKi1CnSiYgoG+mCFCGx7/Aw6iUCo1/iYdRLvI6PUHZYhSclBenv3yP9/Xuk3v/f/JAqKlA1M4OqpWVG4svSEirlykEikSg3VqIvpPREl4aGBhwcHAAALi4uuHnzJlavXo0//vhDoWyDBg0AAE+fPoW9vT3Mzc1x48YNuTJhYWEAIM7rZW5uLq7LXMbAwCDb3lwAMGXKFIwfP15cjo2NhZWVVQHPkIiIiIiIiIg+58XzZxAEAfYOlfO135jxv4j/b1XRGkNHjMGRg/+Kia53b97gxxFj4FApo15bOwex/Ls3b9C+Y2dUdcyYJ7yijW2Ox9m4bhWca9bGgiUrxXWVq1YT/79Dpy5y5ZeuWo/a1WwR/DgIVao55uuciIio8EkFKR5Fv8LV8EfwjwzBk5g3SExPUXZYxUsqFZNfuHULACDR1YWanV3Gx94eKvr6Sg6SKP+UnujKSiqVyg0bmJm/vz8AwMLCAgDQqFEjLFiwAOHh4TA1NQUAnDlzBgYGBuLwh40aNcLx48fl6jlz5ozcPGBZaWpqQlNT80tPhYiIiIiIiIjySBAKNsfJkYP/wvuvjXj14jni4+ORnp4GvUwv6YYMH4nJ40dj/97daOraAh6duorDCXoNHY7pv4zDf77n0bR5C7Tv2AXVnKpne5zAgAfw6NQ1xzieP3uKFYsX4O7t24j6GAmpNKOn19u3r5noIiJSkk+pibgZ8Rh+4YG4Fh6E6JRPyg6pxBHi45H64AFSHzwAAKiYmPx/4svWFpL/DQVMVJIpNdE1ZcoUtG/fHhUrVkRcXBx27NgBX19fnDp1CiEhIdixYwc6dOiAcuXK4f79+xg3bhyaN2+OGjVqAADatm0LR0dH9O/fH0uWLEFoaCimT5+OkSNHiomq4cOHY+3atfjll18waNAgnD9/Hnv27MGxY8eUeepERERERERElImtnT0kEglCnj7J8z63b17Hzz8NwbhfpsLVrRX0DQxw+MC/2LRhrVhm3C9T0aV7T5w/cwq+585g5ZLfsOYPb7Tz6IS+P3jC1a0Vzp85hf98z2P97yswbc4CDBwyXOFYWlrZjwojM/iH3rCsYIVFK36HmbkFBKkUbZo3QGpKat4vAhERfbFXn8LhFxaIq+GBuP/xOdKEdGWHVKpIIyKQEhGBlOvXAXV1qDk4QN3REeqVK0OioaHs8IiypdREV3h4OAYMGID379/D0NAQNWrUwKlTp9CmTRu8fv0aZ8+exapVqxAfHw8rKyt0794d06dPF/dXVVXF0aNH8dNPP6FRo0bQ1dWFp6cn5s6dK5axtbXFsWPHMG7cOKxevRoVKlTApk2b4O7uroxTJiIiIiIiIqJsGJUpi+ZurfDP5r8wcMhwhXm6YmKiFebpun3zBiwrWGH0uEniurdvXivUbWdfCXb2lTBk+CiM/nEg9u7ahnYenQAA5S0r4AevwfjBazAWz5+NXVu3ZJvoqubohCuXLmL85GkK26I+RiLkaTAWrViD+g0bAwBuXrua72tAREQF8y4+Eife3MTZd3fx5muaZ0vZUlOR9ugR0h49QqKaGtTs7f8/6aWlpezoiERKTXT9/fffOW6zsrLCxYsXP1uHtbW1wtCEWbVo0QJ3797Nd3xEREREREREVHzmL1qO7zq2Red2bhj/yzRUc3JCWlo6Ll88j60+f+P8lVty5W3t7PHu7RscPrAPNWvVwfmzp3Dq+BFxe1JiIhbMmY4OnbrCqqI13r97h3t376B9x4z5tOZMn4wWLdvA1t4BMTHRuHrlPzhUrpJtbCN+Hg9310aY9ss4/OA5GOoaGrh6+T94dO4GozJlUKZsWez4xxumpmZ4+/YNFs+fVXQXioiIkJCWjAvv7+HE6xu4//E5BBRsCFzKo7Q0pD1+jLTHj5Goqgq1SpWgUbs21BwcIFFRUXZ09I0rcXN0EREREREREdG3qaKNLY6du4S1K5diwexpCA8LRdlyxnCuWQsLlqxUKN+mXQcM/nEkZk6ZiJTkFLRs0xZjxv+CVUsXAQBUVFURHfUR40f9iA8R4ShTthzaeXTCuF+mAgDS09Mx49cJCH3/Dnr6+nB1a42Z8xZmG5udfSVs3XMQSxbMQZd2btDU0kbtOi7o/F0PqKioYO0f3pg17Re0dW0IO/tKmP3bEvTu2qHoLhYR0TdIEATcjXyKE29u4uL7+0hMT1F2SN+m9HSkBQUhLSgIEn19aNSsCfXataFatqyyI6NvlEQo6Gyv35DY2FgYGhoiJiYGBgYGyg6nUI3adLlI6187pGmR1p9f39r5EhFR0fua2wn5VeTX4o+JhV8n5dso1a7KDuGbxzZnIfvKfrckaenjebU2sK1gAS310vPd1lcwUnYI37yKJvpftH9SUhKeP38OW1tbaGUZzortJSL6UuGJ0Tjy6hpOvbmF94kflR1Oodn6sRrKPH+n7DAKjaqNDTRq14a6oyMkaqWnHUKlH+82IiIiIiIiIiIiIipxQmLfYUfIBZx/5480IV3Z4dBnpL94gcQXL5B0+jQ06taFRr16UMky5yZRUWCii4iIiIiIiIiIiIhKjNsfgrEj5DxuRDxWdihUAEJ8PJIvXkTy5ctQd3aGZuPGUDUxUXZY9BVjoouIiIiIiIiIiIiIlCpdkML3/T3sDLmAxzFvlB0OFYb0dKT6+yPV3x9qlStDs0kTqFWsqOyo6CvERBcRERERERERERERKUVyegqOvrqO3c8v4n3C1zP/FslLe/IEaU+eQM3ODppublCrUEHZIdFXhIkuIiIiIiIiIiIiIipWUkGK469vYPOTU4hIilF2OFRM0p49Q9qzZ1CrVAlabm5QtbBQdkj0FWCii4iIiIiIiOhrIQgABEgFQdmR0DdGKpUqOwQiKkWuhT/ChkdH8CwuVNmhkJKkBQfjU3Aw1KpVg1aLFlA1NVV2SFSKMdFFRERERERE9JXQSEmASnIC3kXGwMRIHxqqqpBIlB3V56UhRdkhfPOSkpIKtJ8gCEhJSUFERARUVFSgoaFRyJER0dfkccwbbHh0BLc/BCs7FCoh0h49wqegIKjXrAmtVq2goqen7JCoFGKii4iIiIiIiOgroSJIYRv8H95b1sC7BHNARQVAyc90fUS0skP45iXHaH3R/jo6OqhYsSJUVFQKKSIi+pqEJnzEn4+P4+zbuxDAXseUhSAg1d8fqY8eQat5c2g0aACJqqqyo6JShIkuIiIiIiIioq+IRmoiKr64jjQ1TaSrapSGPBe2qbRWdgjfvBk9qxV4X1VVVaipqUFSGroPElGxSkhLgs+TM/j3xSWkSNOUHQ6VdMnJSDpzBil37kDL3R3qlSopOyIqJZjoIiIiIiIiIvrKSACopyVDPS1Z2aHkSYwqv92vbFpaX9aji4goq/9CH2B1wAGEJ0UrOxQqZaSRkUjYsQNqlSpBy90dquXKKTskKuGY6CIiIiIiIiIiIiKiQhGRGI2VAftxKSxA2aFQKZcWHIxPz59Dy9UVGo0bQ8LhcSkHvDOIiIiIiIiIiIiI6IsIgoCDL/3Q/+ISJrmo8KSlIencOcT//TfSw8OVHU2R8PHxgZGRkbg8e/Zs1KpVS2nxlEZMdBERERERERERERFRgb1P+Iix1zZi+YN9iE9LUnY49BVKf/cOn/78E0m+vhDS05UdTra8vLwgkUgUPk+fPs11v969e+PJkyfFFOXXiUMXEhEREREREREREVG+CYKAAy+vYOOjY0hMLx3zQlIplp6O5IsXkRoUBJ0uXaBqYaHsiBS0a9cO3t7ecutMTExy3UdbWxva2tqFGkdKSgo0NDQKtc6SjD26iIiIiIiIiIiIiChfopI/YcKNP7EyYD+TXFSspGFh+LRpE5L9/CAIgrLDkaOpqQlzc3O5z+rVq+Hs7AxdXV1YWVlhxIgR+PTpk7hP1qELs2rRogXGjh0rt65r167w8vISl21sbDBv3jwMGDAABgYGGDZsGADg8uXLaNasGbS1tWFlZYUxY8YgPj6+ME+5RGCii4iIiIiIiIiIiIjyzD8yBIP+W4abEY+VHQp9q6RSJJ05g4QdOyAt4YkbFRUV/P7773j48CG2bNmC8+fP45dffin04yxbtgw1a9bE3bt3MWPGDISEhKBdu3bo3r077t+/j927d+Py5csYNWpUoR9b2Th0IRERERERERERERF9liAI2Pr0HDY/OYl0QarscIiQ9vQpPm3cCJ1u3aBmZ6fscHD06FHo6emJy+3bt8fevXvFZRsbG8yfPx/Dhw/H+vXrC/XYLVu2xIQJE8TlIUOG4Pvvvxd7g1WqVAm///47XF1dsWHDBmhpaRXq8ZWJiS4iIiIiIiIiIiIiylVMSjzm392OaxFByg6FSI7w6RPit22DZpMm0HRzg0RFeQPZubm5YcOGDeKyrq4uzp49i4ULFyIoKAixsbFIS0tDUlISEhISoKOjU2jHrlu3rtzyvXv3cP/+fWzfvl1cJwgCpFIpnj9/jmrVqhXasZWNiS4iIiIiIiIiIiIiytGDj88x+85WhCdFKzsUouwJApIvX0baq1fQ6dULKrq6SglDV1cXDg4O4vKLFy/QsWNH/PTTT1iwYAHKli2Ly5cvY/DgwUhJSclToktFRUVhLrLU1NRsj53Zp0+f8OOPP2LMmDEKZStWrJjXUyoVmOgiIiIiIiIiIiIiIgWCIGDnswv4M+g4hyqkUiH91St8+usv6PbpA1Vzc2WHg9u3b0MqlWL58uVQ+V9Psz179uSrDhMTE7x//15cTk9PR0BAANzc3HLdr06dOggMDJRLvH2tlNeHj4iIiIiIiIiIiIhKpOT0VMy88w82PDrKJBeVKkJMDD5t3ozUwEBlhwIHBwekpqZizZo1ePbsGbZu3YqNGzfmq46WLVvi2LFjOHbsGIKCgvDTTz8hOjr6s/tNnjwZfn5+GDVqFPz9/REcHIxDhw5h1KhRBTybkouJLiIiIiIiIiIiIiISRad8wthrG+D7/p6yQyEqmNRUJOzdi6QLFxSG/StONWvWxIoVK7B48WJUr14d27dvx8KFC/NVx6BBg+Dp6YkBAwbA1dUVdnZ2n+3NBQA1atTAxYsX8eTJEzRr1gy1a9fGzJkzUb58+YKeToklEZT5Uy4lYmNjYWhoiJiYGBgYGCg7nEI1atPlIq1/7ZCmRVp/fn1r50tEREXva24n5FeRX4s/JhZ+nZRvo1S7KjuEbx7bnIWMv1tKBP5uUb6i/N3C9hJR6fI2/gMm3vgLb+IjlB3KV2/rx2oo8/ydssP46qlVrQqdbt0g0dBQdihURNiji4iIiIiIiIiIiIjwMOoFfryymkku+qqkBQUhfssWSBMSlB0KFREmuoiIiIiIiIiIiIi+cRff38fPVzcgJiVe2aEQFbr0d+8Qv3kzpHmY24pKHya6iIiIiIiIiIiIiL5he55dxMzbW5AsTVV2KERFRhoZiU+bNyM9PFzZoVAhY6KLiIiIiIiIiIiI6BskCAJ+f3gQawIPQQpB2eEQFTkhLg6fvL2R9uqVskOhQsREFxEREREREREREdE3RhAELH+wD3uf/6fsUIiKV1IS4rduRerjx8qOhAoJE11ERERERERERERE35iVAftx6NVVZYdBpBxpaUjYswepQUGFWm1kZCRMTU3x4sWLQq03J76+vpBIJIj+39xjPj4+MDIyErfPnj0btWrVKtIYbGxs4Ovrm+fySUlJWLRoERISEuTW//rrrxg9enSBYmCii4iIiIiIiIiIiOgbsjJgPw68vKLsMIiUSypFwr59SH3ypNCqXLBgAbp06QIbG5tCqzM3jRs3xvv372FoaFgsx8urdevWwcbGBlpaWmjQoAFu3LghbtPS0oK3tzfOnDkjt8/EiROxZcsWPHv2LN/HY6KLiIiIiIiIiIiI6BuxOuAA9r+4rOwwiEqG9PSMnl3BwV9cVUJCAv7++28MHjy4EALLGw0NDZibm0MikRTbMT9n9+7dGD9+PGbNmoU7d+6gZs2acHd3R3h4uFimS5cuOHz4sNx+xsbGcHd3x4YNG/J9TKUmujZs2IAaNWrAwMAABgYGaNSoEU6cOCFuT0pKwsiRI1GuXDno6emhe/fuCAsLk6vj1atX8PDwgI6ODkxNTTFp0iSkpaXJlfH19UWdOnWgqakJBwcH+Pj4FMfpEREREREREREREZUYvz88iH0vLik7DKKSJT0dCbt3I/Xp0y+q5vjx49DU1ETDhg3/V206Bg8eDFtbW2hra6NKlSpYvXq13D5eXl7o2rUrli1bBgsLC5QrVw4jR45EamqqWCY5ORmTJ0+GlZWVmOP4+++/ASgOXfg5N2/eRJs2bWBsbAxDQ0O4urrizp07X3TeWa1YsQJDhw7FwIED4ejoiI0bN0JHRwebN28Wy3Tu3BlHjx6FVCqV27dTp07YtWtXvo+p1ERXhQoVsGjRIty+fRu3bt1Cy5Yt0aVLFzx8+BAAMG7cOBw5cgR79+7FxYsX8e7dO3z33Xfi/unp6fDw8EBKSgr8/PywZcsW+Pj4YObMmWKZ58+fw8PDA25ubvD398fYsWMxZMgQnDp1qtjPl4iIiIiIiIiIiEgZ1gYewt7n/yk7DKKSSZbsCgkpcBWXLl2Ci4uLuCyVSlGhQgXs3bsXgYGBmDlzJqZOnYo9e/bI7XfhwgWEhITgwoULYo4jc2edAQMGYOfOnfj999/x6NEj/PHHH9DT0ytQjHFxcfD09MTly5dx7do1VKpUCR06dEBcXJxYpn379tDT08vx4+TklGP9KSkpuH37Nlq3bi2uU1FRQevWrXH16v/PCdi4cWNIpVJcu3ZNbv/69evjzZs3+Z7jTC1fpQtZp06d5JYXLFiADRs24Nq1a6hQoQL+/vtv7NixAy1btgQAeHt7o1q1arh27RoaNmyI06dPIzAwEGfPnoWZmRlq1aqFefPmYfLkyZg9ezY0NDSwceNG2NraYvny5QCAatWq4fLly1i5ciXc3d2L/ZyJiIiIiIiIiIiIitP6wCPY/eyissMgKtnS0pCwezd0BwyAWoUK+d795cuXKF++vLisrq6OOXPmiMu2tra4evUq9uzZg169eonry5Qpg7Vr10JVVRVVq1aFh4cHzp07h6FDh+LJkyfYs2cPzpw5IyaP7OzsCnyKslyLzJ9//gkjIyNcvHgRHTt2BABs2rQJiYmJOdahrq6e47YPHz4gPT0dZmZmcuvNzMwQFBQkLquoqKBjx444fPgwGjduLK6XXb+XL1/ma56zEjNHV3p6Onbt2oX4+Hg0atQIt2/fRmpqqlzmr2rVqqhYsaKY+bt69SqcnZ3lLpq7uztiY2PFXmFXr16Vq0NWJnP2kIiIiIiIiIiIiOhrtPvZRex8dkHZYRCVDqmpSNixA+kREfneNTExEVpaWnLr1q1bBxcXF5iYmEBPTw9//vknXr16JVfGyckJqqqq4rKFhYU4n5W/vz9UVVXh6upagJNRFBYWhqFDh6JSpUowNDSEgYEBPn36JBeTpaUlHBwccvxYW1sXSiwdOnTA8ePH5dZpa2sDyJjvLD+Unuh68OAB9PT0oKmpieHDh+PAgQNwdHREaGgoNDQ0YGRkJFfezMwMoaGhAIDQ0NBsM4OybbmViY2NzTErmZycjNjYWLkPERERERERERERUWlyKTQA6wMPKzsMolJFSExE/LZtkOYzL2BsbIyoqChxedeuXZg4cSIGDx6M06dPw9/fHwMHDkRKSorcfll7SEkkEnHuKlnip7B4enrC398fq1evhp+fH/z9/VGuXDm5mL5k6EJjY2OoqqoiLCxMbn1YWBjMzc3l1j1//lyh19bHjx8BACYmJvk6L6UOXQgAVapUgb+/P2JiYrBv3z54enri4kXldqNduHChXJdCIiIiIiIiIiIiotLkcfRrzLu7DVIIyg6FqNQRYmMRv2MH9AYOhERTM0/71K5dG9u2bROXr1y5gsaNG2PEiBHiupB8zgHm7OwMqVSKixcvKoxcVxBXrlzB+vXr0aFDBwDA69ev8eHDB7kyXzJ0oYaGBlxcXHDu3Dl07doVQMZcZefOncOoUaPkyh4+fBheXl5y6wICAqCurp5rMi07Sk90aWhowMHBAQDg4uKCmzdvYvXq1ejduzdSUlIQHR0t16src+bP3NwcN27ckKtPlinMXCa77KGBgUGO2dApU6Zg/Pjx4nJsbCysrKy+7ESJiIiIiIiIiIiIikFYYhQm3/wbiekpny9MRNmShoUhYe9e6PTrB4nK5wfHc3d3x5QpUxAVFYUyZcqgUqVK+Oeff3Dq1CnY2tpi69atuHnzJmxtbfMcg42NDTw9PTFo0CD8/vvvqFmzJl6+fInw8HC5eb7yqlKlSti6dSvq1q2L2NhYTJo0SSFPYmlpme96Mxs/fjw8PT1Rt25d1K9fH6tWrUJ8fDwGDhwolomIiMD169fx77//yu176dIlNGvWLN892ZQ+dGFWUqkUycnJcHFxgbq6Os6dOydue/z4MV69eoVGjRoBABo1aoQHDx6I41UCwJkzZ2BgYABHR0exTOY6ZGVkdWRHU1MTBgYGch8iIiKi0mbdunWwsbGBlpYWGjRooPAFoZzs2rULEolE/PYVERERERGVHglpSfjlxiZEJnM6FqIvlRYSgsSjR/NU1tnZGXXq1MGePXsAAD/++CO+++479O7dGw0aNEBkZKRc76682rBhA3r06IERI0agatWqGDp0KOLj4/NdDwD8/fffiIqKQp06ddC/f3+MGTMGpqamBaorJ71798ayZcswc+ZM1KpVC/7+/jh58qTcFFNHjx5F3bp1Faad2rVrF4YOHZrvY0oEQVBa39UpU6agffv2qFixIuLi4rBjxw4sXrwYp06dQps2bfDTTz/h+PHj8PHxgYGBAUaPHg0A8PPzAwCkp6ejVq1aKF++PJYsWYLQ0FD0798fQ4YMwW+//QYgY5zH6tWrY+TIkRg0aBDOnz+PMWPG4NixY3B3d89TnLGxsTA0NERMTMxXl/Qatelykda/dkjTIq0/v7618yUioqJXUtsJu3fvxoABA7Bx40Y0aNAAq1atwt69e/H48eNcG7EvXrxA06ZNYWdnh7Jly+LgwYN5PmaRX4s/JhZ+nZRvo1S7KjuEbx7bnIWMv1tKBP5uUb6i/N1SUttLRF+jNGk6Jt/chBsRj5UdCuXB1o/VUOb5O2WHQXmg1aEDNOvV+2y5Y8eOYdKkSQgICIBKHnqBfQ1sbGzg4+ODFi1a5Hmfbt26oX79+pgyZYq47sSJE5gwYQLu378PNbX8DUao1CsdHh6OAQMGoEqVKmjVqhVu3rwpJrkAYOXKlejYsSO6d++O5s2bw9zcHPv37xf3V1VVxdGjR6GqqopGjRrhhx9+wIABAzB37lyxjK2tLY4dO4YzZ86gZs2aWL58OTZt2pTnJBcRERFRabRixQoMHToUAwcOhKOjIzZu3AgdHR1s3rw5x33S09Px/fffY86cObCzsyvGaImIiIiIqDCseniASS6iIpB08iTSXr36bDkPDw8MGzYMb9++LYaoSqekpCScOXMGnTt3llsfHx8Pb2/vfCe5ACXP0fX333/nul1LSwvr1q3DunXrcixjbW2N48eP51pPixYtcPfu3QLFSERERFTapKSk4Pbt23LfjFJRUUHr1q1x9erVHPebO3cuTE1NMXjwYFy6dKk4QiUiIiIiokLy7/NLOPTST9lhEH2dpFIk7NkDvWHDoPKZ3sljx44tnphKKS0tLXz69ElhfY8ePQpcp1ITXURERERU+D58+ID09HSFsa7NzMwQFBSU7T6XL1/G33//DX9//zwfJzk5GcnJyeJybCznACAiIiIiUobH0a+x7tFhZYdB9FUT4uORsGcPdAcOhERVVdnhlBhjx46FjY2NUmP4NgaJJCIiIqIcxcXFoX///vjrr79gbGyc5/0WLlwIQ0ND8WNlZVWEURIRERERUXYS0pIw+85WpErTlR0K0Vcv/e1bJB47puwwSpSSkOhijy4iIiKir4yxsTFUVVURFhYmtz4sLAzm5uYK5UNCQvDixQt06tRJXCeVSgEAampqePz4Mezt7RX2mzJlCsaPHy8ux8bGMtlFRERERFTMltzfizcJH5QdBtE3I/XuXaRYWUGjdm1lh0L/wx5dRERERF8ZDQ0NuLi44Ny5c+I6qVSKc+fOoVGjRgrlq1atigcPHsDf31/8dO7cGW5ubvD3988xeaWpqQkDAwO5DxERERERFZ/DL6/i3Lu7yg6D6JuTeOIE0iMjlR0G/Q97dBERERF9hcaPHw9PT0/UrVsX9evXx6pVqxAfH4+BAwcCAAYMGABLS0ssXLgQWlpaqF69utz+RkZGAKCwnoiIiIiISoZnse/x+8ODyg6D6NuUmorE/fuhO2gQ5+sqAZjoIiIiIvoK9e7dGxEREZg5cyZCQ0NRq1YtnDx5EmZmZgCAV69eQUWFnfuJiIiIiEqjpPQUzLrzD5KlqcoOheiblf7uHZIvXIBW69bKDuWbx0QXERER0Vdq1KhRGDVqVLbbfH19c93Xx8en8AMiIiIiIqJCsTJgP158Cvt8QSIqUsl+flBzcICajY2yQ/mm8Wu8RERERERERERERKXEhXf+OP76hrLDICIAEAQkHDgAITFR2ZF805joIiIiIiIiIiIiIioF4lISsOrhAWWHQUSZCLGxSDx+XNlhfNOY6CIiIiIiIiIiIiIqBdY9OoKPyXHKDoOIskgNCEBqcLCyw/hmMdFFREREREREREREVMLd/fAUx15fV3YYRJSDxGPHIKSkKDuMbxITXUREREREREREREQlWHJ6KpY+2KvsMIgoF0JMDJLOnVN2GN8kJrqIiIiIiIiIiIiISrB/gs/gdXyEssMgos9IuXkTaW/eKDuMbw4TXUREREREREREREQlVEjsO+wIuaDsMIgoLwQBiUeOQEhPV3Yk3xQmuoiIiIiIiIiIiIhKIKkgxZL7e5Am8KU5UWkhDQ9H8tWryg7jm8JEFxEREREREREREVEJdODFFQRGv1J2GESUT8mXLkH66ZOyw/hmMNFFREREREREREREVMJ8Sk3E5ienlB0GERVESgqSzp9XdhTfDCa6iIiIiIiIiIiIiEqYbU/PITY1QdlhEFEBpfr7Iz0sTNlhfBOY6CIiIiIiIiIiIiIqQT4kxWDf80vKDoOIvoQgIPEUe2UWBya6iIiIiIiIiIiIiEqQzU9OIVmaquwwiOgLpT9/jtTHj5UdxlePiS4iIiIiIiIiIiKiEuLVp3Acf31D2WEQUSFJOnMGglSq7DC+akx0EREREREREREREZUQfwQdQ7rAl+JEXwtpZCRS/f2VHcZXjYkuIiIiIiIiIiIiohLgYdQL/Bf6QNlhEFEhS7p0ib26ihATXUREREREREREREQlwIZHR5UdAhEVASE6Gqn37ik7jK8WE11ERERERERERERESnYt/BHufXym7DCIqIgks1dXkVFTdgBERERERERERERE37qtT88qOwSibK24dAlHHj1C8IcP0FJTQ30rK8xp0waVjI3lyt14/Rrzzp3D7bdvoSqRoLq5Ofb37w9tdfVs641LTsaC8+dxNCgIH+LjUcPcHIvat0cdS0uxzJorV7D6yhUAwM9Nm2J048bitltv3mDCsWM4N2QI1FRVi+DMC5c0Kgqp9+5Bo3ZtZYfy1WGii4iIiIiIiIiIiEiJHnx8jvsfnys7DKJsXXnxAkPq1UMdS0ukSaWYd+4cum3diusjR0JXQwNARpKrx7ZtGNe0KZZ06AA1FRUEhIZCRSLJsd4xhw/jUXg4/ujWDRb6+th9/z66/vMPro0cifIGBggIDcVvFy5gV79+AIDeO3agpb09nMzMkJaejnFHj2J1p06lIsklk3zpEtRr1oREhYPtFSZeTSIiIiIiIiIiIiIl2hFyXtkhEOXo3/798X3t2qhmagpnc3Os79oVb2Ji4P/unVhm6smTGNagAcY1a4ZqpqaoZGyMbtWrQ1Mt+742iampOBwYiDlt2qCJjQ3sypXDFDc32JYti803bwIAgj98gJOZGVzt7OBqZwcnMzMEf/gAAPjdzw+Nra3len+VBtKoKKQ+eKDsML46THQRERERERERERERKcmLuDBcCQtUdhhEeRablAQAKKOtDQCI+PQJt96+hYmuLtpu2oRKS5eig7c3rr58mWMdaVIp0gUBWlkSYdpqarj66hUAwNHMDE8jI/E6OhqvoqPxNDIS1UxN8fzjR2y/exfTW7YsojMsWsnXrys7hK8OE11ERERERERERERESrL7mS8ECMoOgyhPpFIpppw8iYZWVnA0MwMAvIiKAgAs8vXFABcX7PvhB9S0sECXf/5BSGRktvXoa2qifoUKWHLxIt7HxiJdKsXue/dw480bhH36BACoYmKCma1aodvWrfhu61bMatUKVUxMMPbIEcxp0wbnnz5Fo3Xr0GzjRlx58aJYzr8wSN+/R9r/knlUODhHFxEREREREREREZESxKTE48zbO8oOgyjPJh4/jsDwcJwcNEhcJxUyErUDXVzwQ+3aAICaFha4+OwZtt29i1mtW2db1x/ffYeRhw6h2ooVUJVIUNPCAj2qV4f/+/dimUH16mFQvXri8g5/f+hpaqK+lRXqrlmDC8OG4W1sLAbv24d7Y8fmOFRiSZN8/TrUKlZUdhhfjdLxUyciIiL6SqWmpuLZs2eoUqUKAODq1ato1KiRkqMiIiIiIqLicOjlVSRLU5UdBlGeTDp2DKeePMGxgQNhaWgorjfT1weQ0QMrsyomJngTE5NjfbZly+L4wIGIT0lBXHIyzPX1MXDvXtiUKZNt+cj4eCz29cXxgQNx680bOJQrB/v/fVKlUjyNjITT/3qZlXRpjx5BGhMDlUzXkQqOQxcSERERKZGnpyc6deqEqVOnAgAmTJig5IiIiIiIiKg4pEnTcfDlFWWHQfRZgiBg0rFjOBoUhMOengqJKGsjI1jo6yM4yzCFTyMjYZWHRI6uhgbM9fURnZiIc0+fosP/vgia1ZRTpzCiUSNYGhoiXRCQKpWK29KkUqRnWi7xBAHJN24oO4qvBhNdREREREoUEBCAJ0+eQF1dHevWrVN2OEREREREVEwuht5HRFLOvV2ISoqJx45h9/37+Kt7d+hpaCAsLg5hcXFITM3ojSiRSDC6cWP8ef06Dj18iGeRkZh//jyCP3xA/zp1xHo6b9mCP69fF5fPPX2Ks8HBeBEVhQshIejo44PKxsb4/n/DH2Z2ISQEIZGRGPq/YQzrlC+P4A8fcCY4GD63bkFVIkElY+MivhKFK/XOHQip7NFZGJSa6Fq4cCHq1asHfX19mJqaomvXrnj8+LFcmRYtWkAikch9hg8fLlfm1atX8PDwgI6ODkxNTTFp0iSkpaXJlfH19UWdOnWgqakJBwcH+Pj4FPXpEREREX2WhYUFAGDOnDm4cuUKnj9/ruSIiIiIiIioOBx7zd4cVDr8fesWYpOT0dHHB1WWLxc/+wMCxDIjGjXCuKZNMfXUKTTduBH/PXuGA/37w7ZsWbHM848fEZmQIC7HJiVh4vHjqL92LYYfOIBGFSvi3/79oa6qKnf8xNRUTDp+HCs7doSKSkZKw9LQEEvat8fIgwex7NIlbOjWDdrq6kV8JQqXkJSE1IcPlR3GV0Gpc3RdvHgRI0eORL169ZCWloapU6eibdu2CAwMhK6urlhu6NChmDt3rriso6Mj/n96ejo8PDxgbm4OPz8/vH//HgMGDIC6ujp+++03AMDz58/h4eGB4cOHY/v27Th37hyGDBkCCwsLuLu7F98JExEREWXRpEkTpKWlQU1NDRs3bsSAAQOUHRIRERERERWxD0kxuPMhWNlhEOVJ9OzZeSo3rlkzjGvWLMftD8aNk1vuVr06ulWv/tl6tdXVcWv0aIX1A1xcMMDFJU+xlVQp/v7QqFVL2WGUekpNdJ08eVJu2cfHB6amprh9+zaaN28urtfR0YG5uXm2dZw+fRqBgYE4e/YszMzMUKtWLcybNw+TJ0/G7NmzoaGhgY0bN8LW1hbLly8HAFSrVg2XL1/GypUrmegiIiIipZo5c6b4/wYGBjh48KDygiEiIiIiomJx5u0dpAulaD4hIioS6S9fQhodDRUjI2WHUqqVqDm6YmIyxqQtm6k7IwBs374dxsbGqF69OqZMmYKETN0br169CmdnZ5iZmYnr3N3dERsbi4f/6/Z39epVtG7dWq5Od3d3XL16Nds4kpOTERsbK/chIiIiIiIiIiIiKgwn39xSdghEVEKk+PsrO4RST6k9ujKTSqUYO3YsmjRpguqZuiv269cP1tbWKF++PO7fv4/Jkyfj8ePH2L9/PwAgNDRULskFQFwODQ3NtUxsbCwSExOhra0tt23hwoWYM2dOoZ8jERERUWa2traQSCT53m/s2LEYM2ZMEURERERERERF7WnsWzyLe6/sMIiohEi9fx+arq4Fej9AGUpMomvkyJH/x959h0dVrW0cfmbS6yQB0iAQkBpagFACSpFAKKIIKiCHJoIiwRJFD0ek2EBEKYJgg9iwKyJ4QAwiiDTBgPQiGBSS0EMCpM73B4f5HCFAwoSd8ruva66T2WvNfp+daM44b9ba2rZtm3766Se748OHD7d93bBhQ4WEhKhjx47av3+/brrppmLJMmbMGMXHx9uep6enKywsrFhqAQCA8ishIaFIrwsPD3doDgAAAAA3Dqu5APxd/smTyktOlnO1akZHKbVKRKMrLi5Oixcv1qpVq1SlSpUrzm3ZsqUkad++fbrpppsUHBysDRs22M1JTU2VJNt9vYKDg23H/j7H19f3ktVckuTm5iY3N7ciXw8AAMC1aNeundERAAAAANxAedZ8Lf9rs9ExAJQw2UlJNLqug6H36LJarYqLi9NXX32lFStWqHr16ld9TdL/9qsMCQmRJEVHR+u3335TWlqabc7y5cvl6+uriIgI25zExES78yxfvlzR0dEOuhIAAAAAAAAAuLJfju7WiawzRscAUMLk7Nola16e0TFKLUNXdI0cOVILFizQ119/LR8fH9s9tSwWizw8PLR//34tWLBA3bp1U4UKFbR161Y99thjatu2rRo1aiRJ6ty5syIiIjRgwABNmTJFKSkpGjt2rEaOHGlblfXggw9q1qxZevLJJ3XfffdpxYoV+vTTT7VkyRLDrh0AAKBXr15KSEiQr6+vevXqdcW5F+9PCgAAAKD0WvbnJqMjACiJzp9X7oEDcqlZ0+gkpZKhja45c+ZIktq3b293fP78+Ro8eLBcXV31/fffa/r06crMzFRYWJh69+6tsWPH2uY6OTlp8eLFGjFihKKjo+Xl5aVBgwbp2Weftc2pXr26lixZoscee0wzZsxQlSpV9Pbbbys2NvaGXCcAAMDlWCwW281mLRaLwWkAAAAAFKec/Fz9lLrd6BgASqicHTtodBWRoY0uq9V6xfGwsDD9+OOPVz1PtWrV9O23315xTvv27fXrr78WKh8AAEBxmj9//mW/vpI1a9YoKiqK+4kCAAAApcyWE7/rXF6W0TEAlFC5u3fLarXa/iAW187Qe3QBAACgcLp27aq//vrL6BgAAAAACml92i6jIwAowaxnzyrv0CGjY5RKNLoAAABKkautiAcAAABQMq1L22l0BAAlXM7u3UZHKJVodAEAAAAAAABAMUo5e0IHM1KNjgGghMvds8foCKUSjS4AAAAAAAAAKEbrjrJtIYCryz92TPmnTxsdo9Sh0QUAAAAAAAAAxWg92xYCuEa5Bw4YHaHUodEFAABQiphMJqMjAAAAACiEnPxcbTq2z+gYAEoJGl2FR6MLAACgFLFarUZHAAAAAFAIW078rnN5WUbHAFBK5B48aHSEUodGFwAAQAmwa1fBe/YvW7bM9vWZM2dUo0aNGxEJAAAAgAOsT+P+XACunTU9XXnHjxsdo1Sh0QUAAFACNG3aVLNnz7Y7lpWVpbi4ON1xxx0GpQIAAABwvbadPGh0BAClDNsXFg6NLgAAgBIgISFB48aNU7du3ZSamqqkpCQ1adJE33//vVavXm10PAAAAABFkJufp72n/zI6BoBSJo/tCwuFRhcAAEAJcM8992jLli3KyclR/fr1FR0drXbt2mnz5s1q3ry50fEAAAAAFMHvZ44oKz/H6BgASpnc5GSjI5QqNLoAAABKkOzsbOXl5SkvL08hISFyd3c3OhIAAACAItp16pDREQCUQtYzZ5SfkWF0jFKDRhcAAEAJ8PHHH6thw4ayWCzas2ePlixZojfffFO33HKLfv/9d6PjAQAAACiCHadYlQGgaPIOHzY6QqlBowsAAKAEGDp0qF588UUtWrRIlSpVUqdOnfTbb7+pcuXKioyMNDoeAAAAgCLYRaMLQBHlHTlidIRSw9noAAAAAJA2b96sOnXq2B3z9/fXp59+qvfff9+gVAAAAACK6nxetg5mpBodA0ApxYqua8eKLgAAgBLgn02uvxswYMANTAIAAADAEXaf+lN51nyjYwAopVjRde1odAEAABgkOTm5SI/09PRrOv/s2bMVHh4ud3d3tWzZUhs2bChw7pdffqmoqCj5+fnJy8tLkZGRrCQDAAAArsPO02xbCKDorGfOKD8jw+gYpQJbFwIAABgkPDxcJpNJVqv1ml9jMpk0fvx4jRs37orzPvnkE8XHx2vu3Llq2bKlpk+frtjYWO3evVuBgYGXzA8ICNDTTz+tunXrytXVVYsXL9aQIUMUGBio2NjYQl8bAAAAUN7tOf2n0REAlHJ5KSky16xpdIwSj0YXAACAQfLzi28bk1dffVXDhg3TkCFDJElz587VkiVLNG/ePP373/++ZH779u3tnj/yyCN699139dNPP9HoAgAAAIrgz8xjRkcAUMrlHz8u0ei6qiJtXbh582b99ttvtudff/21evbsqf/85z/Kzs52WDgAAAAUXnZ2tjZt2qSYmBjbMbPZrJiYGK1du/aqr7darUpMTNTu3bvVtm3bAudlZWUpPT3d7gEAAADggsNnjxsdAUApl3+c3yPXokiNrgceeEB79uyRJP3+++/q27evPD099dlnn+nJJ590aEAAAAAUzrFjx5SXl6egoCC740FBQUpJSSnwdadPn5a3t7dcXV3VvXt3vfbaa+rUqVOB8ydNmiSLxWJ7hIWFOewaAAAAgNIsM+e8TmdnGh0DQCmXf+KE0RFKhSI1uvbs2aPIyEhJ0meffaa2bdtqwYIFSkhI0BdffOHIfAAAALhBfHx8lJSUpI0bN+qFF15QfHy8Vq5cWeD8MWPG6PTp07bHoUOHblxYAAAAoAT76yzbFgK4fnms6LomRbpHl9Vqtd1T4vvvv9dtt90mSQoLC9OxY/wSBwAAMFLFihXl5OSk1NRUu+OpqakKDg4u8HVms1k1/7f3d2RkpHbu3KlJkyZdcv+ui9zc3OTm5uaw3AAAAEBZ8VcmH04DuH7W06dlzc2VyblIrZxyo0gruqKiovT888/r/fff148//qju3btLkg4cOHDJFjkAAAC4sVxdXdWsWTMlJibajuXn5ysxMVHR0dHXfJ78/HxlZWUVR0QAAACgTDvMii4AjmC1Kv/kSaNTlHhFanRNmzZNmzdvVlxcnJ5++mnbX/5+/vnnat26tUMDAgAAlAc//PCDQ88XHx+vt956S++++6527typESNGKDMzU0OGDJEkDRw4UGPGjLHNnzRpkpYvX67ff/9dO3fu1CuvvKL3339f//rXvxyaCwAAACgPDp9lRRcAx+A+XVdXpPVujRs31m+//XbJ8ZdfflnOLKEDAAAotC5duqhKlSoaMmSIBg0apLCwsOs6X58+fXT06FGNGzdOKSkpioyM1NKlS22r75OTk2U2///fPGVmZuqhhx7Sn3/+KQ8PD9WtW1cffPCB+vTpc105AAAAgPLoLxpdABwk/8wZoyOUeEVa0VWjRg0dv8xN0M6fP6/atWtfdygAAIDy5q+//lJcXJw+//xz1ahRQ7Gxsfr000+VnZ1d5HPGxcXpjz/+UFZWltavX6+WLVvaxlauXKmEhATb8+eff1579+7VuXPndOLECf388880uQAAAIAiOsw9ugA4iDUjw+gIJV6RGl0HDx5UXl7eJcezsrL0559/XncoAACA8qZixYp67LHHlJSUpPXr16t27dp66KGHFBoaqocfflhbtmwxOiIAAACAa2C1WpV2/pTRMQCUETS6rq5Q+wwuWrTI9vWyZctksVhsz/Py8pSYmKjq1as7Lh0AAEA51LRpUwUHB6tChQqaPHmy5s2bp9dff13R0dGaO3eu6tevb3REAAAAAAU4m5ulPGu+0TEAlBH5mZlGRyjxCtXo6tmzpyTJZDJp0KBBdmMuLi4KDw/XK6+84rBwAAAA5UlOTo6+/vprzZs3T8uXL1dUVJRmzZqlfv366ejRoxo7dqzuvvtu7dixw+ioAAAAAAqQkXvO6AgAyhBWdF1doRpd+fkX/hKhevXq2rhxoypWrFgsoQAAAMqbUaNG6aOPPpLVatWAAQM0ZcoUNWjQwDbu5eWlqVOnKjQ01MCUAAAAAK7mTA6NLgCOk0+j66oK1ei66MCBA47OAQAAUK7t2LFDr732mnr16iU3N7fLzqlYsaJ++OGHG5wMAAAAQGGcyTlrdAQAZQgruq6uSI0uSUpMTFRiYqLS0tJsK70umjdv3nUHAwAAKE/Gjx+v1q1by9nZ/u1Zbm6ufv75Z7Vt21bOzs5q166dQQkBAAAAXIuMnPNGRwBQluTmypqXJ5OTk9FJSixzUV40ceJEde7cWYmJiTp27JhOnjxp97hWkyZNUvPmzeXj46PAwED17NlTu3fvtptz/vx5jRw5UhUqVJC3t7d69+6t1NRUuznJycnq3r27PD09FRgYqNGjRys3N9duzsqVK9W0aVO5ubmpZs2aSkhIKMqlAwAAFIsOHTroxIkTlxw/ffq0OnToYEAiAAAAAEWRwdaFABwtJ8foBCVakVZ0zZ07VwkJCRowYMB1Ff/xxx81cuRINW/eXLm5ufrPf/6jzp07a8eOHfLy8pIkPfbYY1qyZIk+++wzWSwWxcXFqVevXlqzZo0kKS8vT927d1dwcLB+/vlnHTlyRAMHDpSLi4tefPFFSRe2WuzevbsefPBBffjhh0pMTNT999+vkJAQxcbGXtc1AAAAOILVapXJZLrk+PHjx23viwAAAACUfGxdCMDRrDk5Mrm7Gx2jxCpSoys7O1utW7e+7uJLly61e56QkKDAwEBt2rRJbdu21enTp/XOO+9owYIFuvXWWyVJ8+fPV7169bRu3Tq1atVK3333nXbs2KHvv/9eQUFBioyM1HPPPaennnpKEyZMkKurq+bOnavq1avrlVdekSTVq1dPP/30k6ZNm0ajCwAAGKpXr16SJJPJpMGDB9vdnysvL09bt251yPsuAAAAADcGK7oAOJqVFV1XVKStC++//34tWLDA0Vl0+vRpSVJAQIAkadOmTcrJyVFMTIxtTt26dVW1alWtXbtWkrR27Vo1bNhQQUFBtjmxsbFKT0/X9u3bbXP+fo6Lcy6e45+ysrKUnp5u9wAAACgOFotFFotFVqtVPj4+tucWi0XBwcEaPny4PvjgA6NjAgAAALhGGbk0ugA4GI2uKyrSiq7z58/rzTff1Pfff69GjRrJxcXFbvzVV18t9Dnz8/P16KOPqk2bNmrQoIEkKSUlRa6urvLz87ObGxQUpJSUFNucvze5Lo5fHLvSnPT0dJ07d04eHh52Y5MmTdLEiRMLfQ0AAACFNX/+fElSeHi4nnjiCbYpBAAAAEq583l8IA3AsVjRdWVFanRt3bpVkZGRkqRt27bZjV3u3hLXYuTIkdq2bZt++umnIr3ekcaMGaP4+Hjb8/T0dIWFhRmYCAAAlHXjx483OgIAAAAAByjap6MAcAU0uq6oSI2uH374waEh4uLitHjxYq1atUpVqlSxHQ8ODlZ2drZOnTplt6orNTVVwcHBtjkbNmywO19qaqpt7OL/Xjz29zm+vr6XrOaSJDc3N7v7YwAAABSHpk2bKjExUf7+/mrSpMkV/2Bo8+bNNzAZAAAAgKIymYp0txgAKJA1L8/oCCVakRpdjmK1WjVq1Ch99dVXWrlypapXr2433qxZM7m4uCgxMVG9e/eWJO3evVvJycmKjo6WJEVHR+uFF15QWlqaAgMDJUnLly+Xr6+vIiIibHO+/fZbu3MvX77cdg4AAAAj3HHHHbY/runZs6exYQAAAAA4hBNrugA4mMlMA/1KitTo6tChwxX/4njFihXXdJ6RI0dqwYIF+vrrr+Xj42O7p5bFYpGHh4csFouGDh2q+Ph4BQQEyNfXV6NGjVJ0dLRatWolSercubMiIiI0YMAATZkyRSkpKRo7dqxGjhxp++DowQcf1KxZs/Tkk0/qvvvu04oVK/Tpp59qyZIlRbl8AAAAh/j7doVsXQgAAACUDUW9tQvKn1EB+1WngkU3Wb0UluemoBwn+Z+XfM7lyDXjnMwZmVJ+vtExURLwe+WKitTounh/rotycnKUlJSkbdu2adCgQdd8njlz5kiS2rdvb3d8/vz5Gjx4sCRp2rRpMpvN6t27t7KyshQbG6vXX3/dNtfJyUmLFy/WiBEjFB0dLS8vLw0aNEjPPvusbU716tW1ZMkSPfbYY5oxY4aqVKmit99+W7GxsYW7cAAAAAAAAAC4AjMfSOManVK21luPar2OSk668HCX5Hdh3EVm1TD5qJZ8VC3PQyG5LqqYJVnO58kjM0vOZzKl7GzjLgA3Diu6rqhIja5p06Zd9viECROUkZFxzeexWq1XnePu7q7Zs2dr9uzZBc6pVq3aJVsT/lP79u3166+/XnM2AACA4ubv73/Nf+154sSJYk4DAAAAwBFM4gNpOEaO8rXbelq7dVoyS3L938NHUqULcwLlrjomi6rneyosz02B2U7yy8qX99kcuWaclSnzrHQNn8OjhKPRdUUOvUfXv/71L7Vo0UJTp0515GkBAADKpOnTpxsdAQAAAICDsaILN1KazivNel6rTbrwab+zJE9J/hfG3axOqu3kq5r53qqa76GQHGdVyJJ8z+fJPeO8nDIypZwc4y4A14bfK1fk0EbX2rVr5e7u7shTAgAAlFmF2fIZAAAAQOlgEh9Io+TIMuXpt/yT+k0nL6wKc/vfw1dS4IU5lU1eqiNfVbd6qnKuiyplm+V33iqvzGy5ZJyV6exZ4y4AF7Ci64qK1Ojq1auX3XOr1aojR47ol19+0TPPPOOQYAAAAGVdenq6fH19bV9fycV5AAAAAEo2VnShtPnLmqm/lHnhyd9XhQVcOOQlZ9Ux+ammvBSW66bgXGcFZEk+Z3PlnnlO5jOZUl6eQenLBxONrisqUqPLYrHYPTebzapTp46effZZde7c2SHBAAAAyjp/f38dOXJEgYGB8vPzu+z9uqxWq0wmk/L4jwYAAACgVHBzcjE6AuBQmcrVZusxbdYxyUkXHhdXhUkyWU0KN3urtnwUnu+p0P+tCrOcy5Pn2Wy5nMmUzp838ApKPxM76V1RkRpd8+fPd3QOAACAcmfFihUKCLjwJ3I//PCDwWkAAAAAOIKfq7fREYAbymqy6oD1jA7ojGSS5PK/h9f/z/GXm+qYfFXD6qWwPDcF5TjL/3y+fM7lyjXjnMwZmVJ+vkFXUPKZPDyMjlCiXdc9ujZt2qSdO3dKkurXr68mTZo4JBQAAEB50K5du8t+DQAAAKD0srh6XX0SUM6cVJbWWY9qnY7+/6owd0l+F8ZdZFYNk49qyUfV8jwUkuuiilmS5XyePDKz5HwmU8rONu4CjGQySa6uRqco0YrU6EpLS1Pfvn21cuVK+fn5SZJOnTqlDh066OOPP1alSpUcmREAAKBcOHnypN555x3bHxJFRERoyJAhtlVfAAAAAEo+PxpdQKHlKF+7rae1W6clsyTX/z18JP2v3RBo8lAdXVgVViXXVYHZTvLPypfX2Ry5ZpyVKfOsZLUadxHFxOTuftlbHeD/FanRNWrUKJ05c0bbt29XvXr1JEk7duzQoEGD9PDDD+ujjz5yaEgAAICybtWqVerRo4csFouioqIkSTNnztSzzz6rb775Rm3btjU4IQAAAIBrwYouoHikWc8pTee0WrrQ2XCW5CnJ/8K4h5xU0+SrmvJWtTwPBec4q0K25Hs2V+6ZWXI6kyHl5hqWv6i4P9fVFanRtXTpUn3//fe2Jpd04S+OZ8+erc6dOzssHAAAQHkxcuRI9enTR3PmzJGTk5MkKS8vTw899JBGjhyp3377zeCEAAAAAK6FhXt0AYY4pzz9Zj2p33Tywqowt/89fP5/ThWTl+rIV+H5nqqc56LAbCf5ncuT59kcuWSclensWYPSF4z7c11dkRpd+fn5cnFxueS4i4uL8rlhHAAAQKHt27dPn3/+ua3JJUlOTk6Kj4/Xe++9Z2AyAAAAAIXB1oVAyfWnNVN/KlMyyX5VWIUL415yVl2Tn26yeiksz03Buc4KOC/5nsuVW8Y5mTMypby8G5qZFV1XV6RG16233qpHHnlEH330kUJDQyVJf/31lx577DF17NjRoQEBAADKg6ZNm2rnzp2qU6eO3fGdO3eqcePGBqUCAAAAUFjOZid5O7srI/e80VEAFFKmcrXJekybdExy0oWHmyTLhXGT1aTqZh/Vlreq5XsqNNdFlbLM8jufJ4/MLLlknJXOO/bffZOPz9UnlXNFanTNmjVLt99+u8LDwxUWFiZJOnTokBo0aKAPPvjAoQEBAADKqq1bt9q+fvjhh/XII49o3759atWqlSRp3bp1mj17tiZPnmxURAAAAABF4OfqTaMLKIOsJqt+t6brd6VfWBXm8r+Ht6SKF+YEmNxUW762VWGB2c4KyLLK+2yOXDPPyXwmQ7Jar7mmmUbXVRWp0RUWFqbNmzfr+++/165duyRJ9erVU0xMjEPDAQAAlGWRkZEymUyy/u0N7pNPPnnJvHvvvVd9+vS5kdEAAAAAXAeLq5f+PHvM6BgADHDCmqV1Oqp1OnphRZjH/x5+F8ZdZNZNJh/Vko+q5XkoJNdZFbPN8j2bK4+zWXI+kyllZ9vOZ/L1NeAqSpdCNbpWrFihuLg4rVu3Tr6+vurUqZM6deokSTp9+rTq16+vuXPn6pZbbimWsAAAAGXJgQMHjI4AAAAAoBhU8vCTTv1hdAwAJVCO8rXLelq7dFoyS3L938P7/+cEmTxUx+Sr6vle6hRiUTWDspYWhWp0TZ8+XcOGDZPvZTqIFotFDzzwgF599VUaXQAAANegWjXeqgIAAABlUWXPCkZHAFCKpVrPKdV6TqskdbSwoutqCtXo2rJli1566aUCxzt37qypU6dedygAAIDyaseOHUpOTlb237YpkKTbb7/doEQAAAAACquyV0WjIwAoI0I8A4yOUOIVqtGVmpoqFxeXgk/m7KyjR49edygAAIDy5vfff9edd96p3377ze6+XSaTSZKUl5dnZDwAAAAAhVCFRhcABwhw85G7k6vRMUo8c2EmV65cWdu2bStwfOvWrQoJCbnuUAAAAOXNI488ourVqystLU2enp7avn27Vq1apaioKK1cudLoeAAAAAAKoYonjS4A1y/Eg9Vc16JQja5u3brpmWee0fnz5y8ZO3funMaPH6/bbrvNYeEAAADKi7Vr1+rZZ59VxYoVZTabZTabdfPNN2vSpEl6+OGHjY4HAAAAoBAqefjJw8nN6BgASrkqXpWMjlAqFGrrwrFjx+rLL79U7dq1FRcXpzp16kiSdu3apdmzZysvL09PP/10sQQFAAAoy/Ly8uTj4yNJqlixog4fPqw6deqoWrVq2r17t8HpAAAAABRWuHegdp4+ZHQMAKVYTUuo0RFKhUI1uoKCgvTzzz9rxIgRGjNmjN29I2JjYzV79mwFBQUVS1AAAICyrEGDBtqyZYuqV6+uli1basqUKXJ1ddWbb76pGjVqGB0PAAAAQCGF+wTT6AJwXWr7VjY6QqlQqEaXJFWrVk3ffvutTp48qX379slqtapWrVry9/cvjnwAAADlwtixY5WZmSlJevbZZ3XbbbfplltuUYUKFfTJJ58YnA4AAABAYYX7sCAAwPWpZalidIRSodCNrov8/f3VvHlzR2YBAAAot2JjY21f16xZU7t27dKJEyfk7+8vk8lkYDIAAAAARVHdO9joCABKsRDPAPm4eBgdo1QocqMLAAAAxePQoQvbm4SFhRmcBAAAAEBR1WYlBoDrwLaF185sdAAAAABIubm5euaZZ2SxWBQeHq7w8HBZLBaNHTtWOTk5RscDAAAAUEgV3H0V4hlgdAwApRTN8mvHii4AAIASYNSoUfryyy81ZcoURUdHS5LWrl2rCRMm6Pjx45ozZ47BCQEAAAAUVgP/cB05e8LoGABKoVqs6LpmNLoAAABKgAULFujjjz9W165dbccaNWqksLAw9evXj0YXAAAAUAo19K+u5X9tNjoGgFKoFiu6rhlbFwIAAJQAbm5uCg8Pv+R49erV5erqeuMDAQAAALhuDfzDjY4AoBQKcPNRRXdfo2OUGjS6AAAASoC4uDg999xzysrKsh3LysrSCy+8oLi4OAOTAQAAACiqGr4h8nR2MzoGgFImwq+a0RFKFbYuBAAAMEivXr3snn///feqUqWKGjduLEnasmWLsrOz1bFjRyPiAQAAALhOTiazIvyq6Zdje4yOAqAUiapYy+gIpQqNLgAAAINYLBa7571797Z7HhYWdiPjAAAAACgGDfzDaXQBKJTmleoYHaFUodEFAABgkPnz5xsdAQAAAEAx4z5dAAoj0N1PVb0DjY5RqtDoAgAAKEGOHj2q3bt3S5Lq1KmjSpUqGZwIAAAAwPVo4B8us0zKl9XoKABKgahKtY2OUOqYjSy+atUq9ejRQ6GhoTKZTFq4cKHd+ODBg2UymeweXbp0sZtz4sQJ9e/fX76+vvLz89PQoUOVkZFhN2fr1q265ZZb5O7urrCwME2ZMqW4Lw0AAKBQMjMzdd999ykkJERt27ZV27ZtFRoaqqFDh+rs2bNGxwMAAABQRF4u7qrPqi4A16h5RRpdhWVooyszM1ONGzfW7NmzC5zTpUsXHTlyxPb46KOP7Mb79++v7du3a/ny5Vq8eLFWrVql4cOH28bT09PVuXNnVatWTZs2bdLLL7+sCRMm6M033yy26wIAACis+Ph4/fjjj/rmm2906tQpnTp1Sl9//bV+/PFHPf7440bHAwAAAHAdbg6ub3QEAKWASSY1o9FVaIZuXdi1a1d17dr1inPc3NwUHBx82bGdO3dq6dKl2rhxo6KioiRJr732mrp166apU6cqNDRUH374obKzszVv3jy5urqqfv36SkpK0quvvmrXEAMAADDSF198oc8//1zt27e3HevWrZs8PDx0zz33aM6cOcaFAwAAAHBdbg5qoDk7FxsdA0AJd5NviPzdvI2OUeoYuqLrWqxcuVKBgYGqU6eORowYoePHj9vG1q5dKz8/P1uTS5JiYmJkNpu1fv1625y2bdvK1dXVNic2Nla7d+/WyZMnb9yFAAAAXMHZs2cVFBR0yfHAwEC2LgQAAABKuaregQrz4v67AK4sitVcRVKiG11dunTRe++9p8TERL300kv68ccf1bVrV+Xl5UmSUlJSFBgYaPcaZ2dnBQQEKCUlxTbnnx8aXXx+cc4/ZWVlKT093e4BAABQnKKjozV+/HidP3/eduzcuXOaOHGioqOji3TO2bNnKzw8XO7u7mrZsqU2bNhQ4Ny33npLt9xyi/z9/eXv76+YmJgrzgcAAABQOG2C2L4QwJU1r1TH6AilkqFbF15N3759bV83bNhQjRo10k033aSVK1eqY8eOxVZ30qRJmjhxYrGdHwAA4J+mT5+uLl26qEqVKmrcuLEkacuWLXJ3d9eyZcsKfb5PPvlE8fHxmjt3rlq2bKnp06fbVrX/8w+FpAur6Pv166fWrVvL3d1dL730kjp37qzt27ercuXK1319AAAAQHl3c1ADffz7SqNjACihfFw81KTCTUbHKJVK9Iquf6pRo4YqVqyoffv2SZKCg4OVlpZmNyc3N1cnTpyw3dcrODhYqampdnMuPi/o3l9jxozR6dOnbY9Dhw45+lIAAADsNGzYUHv37tWkSZMUGRmpyMhITZ48WXv37lX9+oX/y89XX31Vw4YN05AhQxQREaG5c+fK09NT8+bNu+z8Dz/8UA899JAiIyNVt25dvf3228rPz1diYuL1XhoAAAAASQ0CwmVx9TI6BoASql1wI7mYS/TapBKrVH3X/vzzTx0/flwhISGSLmzxc+rUKW3atEnNmjWTJK1YsUL5+flq2bKlbc7TTz+tnJwcubi4SJKWL1+uOnXqyN/f/7J13Nzc5ObmdgOuCAAAQMrJyVHdunW1ePFiDRs27LrPl52drU2bNmnMmDG2Y2azWTExMVq7du01nePs2bPKyclRQEBAgXOysrKUlZVle852zwAAAEDBnExmRQdGaOmfG42OAqAEiqnc1OgIpZahK7oyMjKUlJSkpKQkSdKBAweUlJSk5ORkZWRkaPTo0Vq3bp0OHjyoxMRE3XHHHapZs6ZiY2MlSfXq1VOXLl00bNgwbdiwQWvWrFFcXJz69u2r0NBQSdK9994rV1dXDR06VNu3b9cnn3yiGTNmKD4+3qjLBgAAsOPi4mJ3b67rdezYMeXl5V32PqUF3aP0n5566imFhoYqJiamwDmTJk2SxWKxPcLCwq4rNwAAAFDW3cx9ugBcRoCbD9sWXgdDG12//PKLmjRpoiZNmkiS4uPj1aRJE40bN05OTk7aunWrbr/9dtWuXVtDhw5Vs2bNtHr1arvVVh9++KHq1q2rjh07qlu3brr55pv15ptv2sYtFou+++47HThwQM2aNdPjjz+ucePGafjw4Tf8egEAAAoycuRIvfTSS8rNzTU6iiZPnqyPP/5YX331ldzd3Qucx3bPAAAAQOG0qFRHHk7sJAXA3q0hkTKbStWdpkoUQ7cubN++vaxWa4Hj13Lj9YCAAC1YsOCKcxo1aqTVq1cXOh8AAMCNsnHjRiUmJuq7775Tw4YN5eVlv3f/l19+ec3nqlixopycnC57n9KC7lF60dSpUzV58mR9//33atSo0RXnst0zAAAAUDgezm66NbSxlhzaYHQUACVITOUmRkco1WgRAgAAlAB+fn7q3bu3YmNjFRoaarcloMViKdS5XF1d1axZMyUmJtqO5efnKzExUdHR0QW+bsqUKXruuee0dOlSRUVFFflaAAAAABSsW1hLoyMAKEFCPAJU3z/c6BilmqErugAAAHDB/PnzHXq++Ph4DRo0SFFRUWrRooWmT5+uzMxMDRkyRJI0cOBAVa5cWZMmTZIkvfTSSxo3bpwWLFig8PBw2728vL295e3t7dBsAAAAQHnWKKC6qnkH6o+MNKOjACgBbg2NNDpCqUejCwAAwED5+fl6+eWXtWjRImVnZ6tjx44aP368PDw8ruu8ffr00dGjRzVu3DilpKQoMjJSS5cuVVBQkCQpOTlZZvP/L+6fM2eOsrOzddddd9mdZ/z48ZowYcJ1ZQEAAABgr2uVFpq7a7HRMYpk49B3lJWWfsnxkG6NddOIW7Vv1vc6tSVZ2ScyZHZ3lW+9EIUPukWeYQEFnvPYz3uV8t+tytifptwz5xU5o7+8awTazfn97R+VlrhdZncXhQ+6WYHt6/3/63/ao9QVO1R/XE+HXSdwo8RUbmp0hFKPRhcAAICBXnjhBU2YMEExMTHy8PDQjBkzlJaWpnnz5l33uePi4hQXF3fZsZUrV9o9P3jw4HXXAwAAAHBtuoY111u7v1WeNd/oKIUW+Wo/WfOttudn/zimbc98qQo315IkedcMVKX2deVWyUe5Z84r+aN12j7uS0W9fZ9MTpe/k07++Rz5RlRWxZtra9+s7y8ZP75hv47+uEv1n+2l84dPae/M7+TfJFwuFg/lZmbp4Ptr1OC53sVzwUAxquVbWTV9Q42OUepxjy4AAAADvffee3r99de1bNkyLVy4UN98840+/PBD5eeXvv/gBQAAAHBtAtx8FB1Y7+oTSyAXi6dc/b1sjxMbD8g9xCJLgyqSpOAujWRpUEXuQRZ51wxStX+1VtaxMzp/mVVgFwXeGqGq/VrJL7LqZcfPHTohS8Mq8qkVrErt6srJ003nU09Lkg7OX62Qro3lHujr+IsFilnv8JuNjlAm0OgCAAAwUHJysrp162Z7HhMTI5PJpMOHDxuYCgAAAEBx6x7W0ugI1y0/J09pP+xUUEwDmUymS8bzzuco9fvtcgvylVtFnyLX8apeSRn7UpWbcV4Z+1KVn5Urj1A/nd7+lzL2pym0R+R1XAVgDIurF9sWOghbFwIAABgoNzdX7u7udsdcXFyUk5NjUCIAAAAAN0KrwHoKcPPRiawzRkcpsuPr9ik3M0uBHSPsjh9ZskUHElYr/3yOPCr7q8FzvWV2cSpyHf+m4arUvp6S4hfI7OqsWo/Fyuzmov1zElX70Vgd+e9WHVmcJGdfd9UcGSOvahWv99KAYtejaiu5ObkYHaNMoNEFAABgIKvVqsGDB8vNzc127Pz583rwwQfl5eVlO/bll18aEQ8AAABAMXE2O6lrleb6cP8Ko6MUWery7fJvFi63Ct52xyu1ryu/JlWVfSJTf321SbteWqLGU/rI7Fr0j6Or3RutavdG254nf7RWfo2ryuRk1qFP1qvprAE6sfGA9kxbpibT+xe5DnAjOJnMurNaG6NjlBlsXQgAAGCgQYMGKTAwUBaLxfb417/+pdDQULtjAAAAAMqeu6q3lau5dK5FOJ+WrlNbkhXcueElY85ebvII9ZelQRXV/fdtOvfnCR1fu89htc8eOqG0H3ap2r9a6/Rvf8pSv7JcLJ6qeHNtZe5PU+7ZbIfVAorDLcENFejhZ3SMMqN0/hYFAAAoI+bPn290BAAAAAAGqejuq86Vm2nxofVGRym01O+3y8XioYDm1a8y0ypZL9zPyxGsVqv2zf5e1e9vKycPV1nzrcrPy78wlvu/Gvn5DqkFFJe7wm8xOkKZwoouAAAAAAAAADDIvTfdKrNMRscoFGu+VWnfb1fQrREyOf3/R8znU07p0GcblLEvVefT0pW+87B2TV4is5uz/KP+vyG26cEEHfvbCq+cM+eV8Xuazh46IUk699dJZfyepuyTmZfUTv1um1wsHqrQ4iZJkm9EqE5vPaT0XUf019eb5RkWIGdv90teB5QUtXwrq3GFGkbHKFNY0QUAAAAAAAAABgnzrqR2IY30w5EtRke5ZqeSkpV19IyCOjWwO25ycVb69r90eNGvys04Lxc/T1nqV1GjKX3k6udpm3fur5PKy8yyPT+xfr/2zvjO9nz3lG8lSWH9Wtndlyv7ZKYOfbpBjab0sR3zqR2syj2bacezC+Vi8VTtx2Idfr2AI/WuzmouR6PRBQAAAAAAAAAG6l+zY6lqdPk3raabv3nskuNuFbxVf8KdV339P18bFFNfQTH1r/o6V38vNX9n6CXHq/Zrpar9Wl319YDRKrj5Kia0idExyhy2LgQAAAAAAAAAA9WxVFHzirWNjgGgmA2sFSM3JxejY5Q5NLoAAAAAAAAAwGD/qtnR6AgAilGwh796VGXlYXGg0QUAAAAAAAAABmtasZYi/KoaHQNAMRlUq5NczNxNqjjQ6AIAAAAAAACAEmBAzRijIwAoBlW8KqlLleZGxyizaHQBAAAAAAAAQAlwc3ADNQ6oYXQMAA52X+3OcjY7GR2jzKLRBQAAAAAAAAAlxMiI22WSyegYABykhk+wOoY2MTpGmUajCwAAAAAAAABKiHp+VRVTmQ/FgbLivtpdZDbRiilOfHcBAAAAAAAAoAR5oG53uZldjI4B4DrVsVRRu5BGRsco82h0AQAAAAAAAEAJEuThr3tqtDM6BoDrNKJeD6MjlAs0ugAAAAAAAACghPlXzVsV4OZjdAwARdQptKmaVaxldIxygUYXAAAAAAAAAJQwns7uGlq7i9ExABSBt7O7RkbcbnSMcoNGFwAAAAAAAACUQN2rtlR1n2CjYwAopPvrdFUFd1+jY5QbNLoAAAAAAAAAoARyMpn1aP07jY4BoBBqW6rozvA2RscoV2h0AQAAAAAAAEAJ1bRiLd1etZXRMQBcA7NMerxBb5lNtF5uJL7bAAAAAAAAAFCCPVTvdgW6+xkdA8BV9KgWrQj/akbHKHdodAEAAAAAAABACebl4q4nG91tdAwAV+Dv6q0H6nY3Oka5RKMLAAAAAAAAAEq4loH11KVKc6NjACjAQxG3y8fFw+gY5RKNLgAAAAAAAAAoBR6OuEMV3HyNjgHgH9oFN1SXKlFGxyi3aHQBAAAAAAAAQCng4+qpJxreZXQMAH8T6O6nJxvdY3SMco1GFwAAAAAAAACUEjcHN1BMaBOjYwCQZJZJT0f2k6+rl9FRyjUaXQAAAAAAAABQijzaoJcC3HyMjgGUe31vaq+mFWsZHaPcM7TRtWrVKvXo0UOhoaEymUxauHCh3bjVatW4ceMUEhIiDw8PxcTEaO/evXZzTpw4of79+8vX11d+fn4aOnSoMjIy7OZs3bpVt9xyi9zd3RUWFqYpU6YU96UBAAAAAAAAQLGwuHppQtMBcjKxjgEwSh1LFQ2r083oGJDBja7MzEw1btxYs2fPvuz4lClTNHPmTM2dO1fr16+Xl5eXYmNjdf78educ/v37a/v27Vq+fLkWL16sVatWafjw4bbx9PR0de7cWdWqVdOmTZv08ssva8KECXrzzTeL/foAAAAAAAAAoDg0qVBTw+p0NToGUC55OLlqXJN/ydnsZHQUSHI2snjXrl3VtevlfxlbrVZNnz5dY8eO1R133CFJeu+99xQUFKSFCxeqb9++2rlzp5YuXaqNGzcqKipKkvTaa6+pW7dumjp1qkJDQ/Xhhx8qOztb8+bNk6urq+rXr6+kpCS9+uqrdg0xAAAAAAAAAChN7r3pVm07eVA/pW43OgpQroyq31NVvQONjoH/KbFrWw8cOKCUlBTFxMTYjlksFrVs2VJr166VJK1du1Z+fn62JpckxcTEyGw2a/369bY5bdu2laurq21ObGysdu/erZMnT162dlZWltLT0+0eAAAAAAAAAFCSmEwm/SfyXoV6VjA6ClButAtuqB5VWxkdA39TYhtdKSkpkqSgoCC740FBQbaxlJQUBQbad02dnZ0VEBBgN+dy5/h7jX+aNGmSLBaL7REWFnb9FwQAAAAAAAAADubj4qHnmg2Sq9nQzbuAcqGad6DGNO5ndAz8Q4ltdBlpzJgxOn36tO1x6NAhoyMBAAAAAAAAwGXVtlTRI/XvNDoGUKZ5O7vrxaj75OXibnQU/EOJbXQFBwdLklJTU+2Op6am2saCg4OVlpZmN56bm6sTJ07YzbncOf5e45/c3Nzk6+tr9wAAAAAAAABQuhw9elQjRoxQ1apV5ebmpuDgYMXGxmrNmjVGR3O426tFq0uVqKtPBFBoZpk0rsm/uC9XCVViG13Vq1dXcHCwEhMTbcfS09O1fv16RUdHS5Kio6N16tQpbdq0yTZnxYoVys/PV8uWLW1zVq1apZycHNuc5cuXq06dOvL3979BVwMAAAAAAADgRuvdu7d+/fVXvfvuu9qzZ48WLVqk9u3b6/jx40ZHKxZPNLxLtXwrGx0DKHPur9tV0UERRsdAAQxtdGVkZCgpKUlJSUmSpAMHDigpKUnJyckymUx69NFH9fzzz2vRokX67bffNHDgQIWGhqpnz56SpHr16qlLly4aNmyYNmzYoDVr1iguLk59+/ZVaGioJOnee++Vq6urhg4dqu3bt+uTTz7RjBkzFB8fb9BVAwAAAAAAAChup06d0urVq/XSSy+pQ4cOqlatmlq0aKExY8bo9ttv18GDB2UymWyfTV58jclk0sqVK23Htm/frttuu02+vr7y8fHRLbfcov3799vG582bp/r168vNzU0hISGKi4uzO9/999+vSpUqydfXV7feequ2bNliG9+yZYs6dOggHx8f+fr6qlmzZvrll18kSX/88Yd69Oghf39/eXl5qX79+vr222+veM1uTq56qflQVXK3XOd3D8BFXapEaUDNGKNj4AoMvUPhL7/8og4dOtieX2w+DRo0SAkJCXryySeVmZmp4cOH69SpU7r55pu1dOlSubv//x6YH374oeLi4tSxY0eZzWb17t1bM2fOtI1bLBZ99913GjlypJo1a6aKFStq3LhxGj58+I27UAAAAAAAAAA3lLe3t7y9vbVw4UK1atVKbm5uhT7HX3/9pbZt26p9+/ZasWKFfH19tWbNGuXm5kqS5syZo/j4eE2ePFldu3bV6dOn7bZFvPvuu+Xh4aH//ve/slgseuONN9SxY0ft2bNHAQEB6t+/v5o0aaI5c+bIyclJSUlJcnFxkSSNHDlS2dnZWrVqlby8vLRjxw55e3tfNXMlDz9NaXG/Rv48S2dzswp9zQD+X+OAGnqy0T1Gx8BVGNroat++vaxWa4HjJpNJzz77rJ599tkC5wQEBGjBggVXrNOoUSOtXr26yDkBAAAAAAAAlC7Ozs5KSEjQsGHDNHfuXDVt2lTt2rVT37591ahRo2s6x+zZs2WxWPTxxx/bGlC1a9e2jT///PN6/PHH9cgjj9iONW/eXJL0008/acOGDUpLS7M12aZOnaqFCxfq888/1/Dhw5WcnKzRo0erbt26kqRatWrZzpOcnKzevXurYcOGkqQaNWpc87XX9K2sZ5sO1FMb31GeNf+aXwfg/1XxrKgXoobIxWxoGwXXoMTeowsAAAAAAAAArkfv3r11+PBhLVq0SF26dNHKlSvVtGlTJSQkXNPrk5KSdMstt9iaXH+Xlpamw4cPq2PHjpd97ZYtW5SRkaEKFSrYVpd5e3vrwIEDtq0P4+Pjdf/99ysmJkaTJ0+22xLx4Ycf1vPPP682bdpo/Pjx2rp1a6GuvWVgPT3R8K5CvQbABRZXL73U4n5ZXL2MjoJrQKMLAAAAAAAAQJnl7u6uTp066ZlnntHPP/+swYMHa/z48TKbL3w0+vcdp3Jycuxe6+HhUeB5rzQmSRkZGQoJCVFSUpLdY/fu3Ro9erQkacKECdq+fbu6d++uFStWKCIiQl999ZUk6f7779fvv/+uAQMG6LffflNUVJRee+21Ql37bVVbaVidboV6DVDeebt46NWWD6iqd6DRUXCNaHQBAAAAAAAAKDciIiKUmZmpSpUqSZKOHDliG0tKSrKbe/GWKP9sgEmSj4+PwsPDlZiYeNk6TZs2VUpKipydnVWzZk27R8WKFW3zateurccee0zfffedevXqpfnz59vGwsLC9OCDD+rLL7/U448/rrfeeqvQ1zuwVozuCr+l0K8DyiMPJzdNbTFMtS1VjI6CQqDRBQAAAAAAAKDMOX78uG699VZ98MEH2rp1qw4cOKDPPvtMU6ZM0R133CEPDw+1atVKkydP1s6dO/Xjjz9q7NixdueIi4tTenq6+vbtq19++UV79+7V+++/r927d0u6sCLrlVde0cyZM7V3715t3rzZtuoqJiZG0dHR6tmzp7777jsdPHhQP//8s55++mn98ssvOnfunOLi4rRy5Ur98ccfWrNmjTZu3Kh69epJkh599FEtW7ZMBw4c0ObNm/XDDz/Yxgrr4fo9FRPa5Dq+m0DZ52Z20Usthqq+f7jRUVBI3EUNAAAAAAAAQJnj7e2tli1batq0adq/f79ycnIUFhamYcOG6T//+Y8kad68eRo6dKiaNWumOnXqaMqUKercubPtHBUqVNCKFSs0evRotWvXTk5OToqMjFSbNm0kSYMGDdL58+c1bdo0PfHEE6pYsaLuuuvCfbFMJpO+/fZbPf300xoyZIiOHj2q4OBgtW3bVkFBQXJyctLx48c1cOBApaamqmLFiurVq5cmTpwoScrLy9PIkSP1559/ytfXV126dNG0adOK9L0wmUx6OvJe5VrztfLIluv5tgJlkovZSS9EDVGTCjWNjoIiMFn/vgktLis9PV0Wi0WnT5+Wr6+v0XEcKu7tn4r1/LPuv7lYz19Y5e16AQDFryy/TyisYv9evPGE48+JQotz6ml0hHKP95wOxu+WEoHfLcYrzt8tvF8CSo48a76e//VDfX/4V6OjACWGk8ms55oN1i3BDYyOgiJi60IAAAAAAAAAKAecTGY906S/ulRpbnQUoEQwy6RnmvSnyVXK0egCAAAAAAAAgHLCbDLrP437qkfVVkZHAQxllklPNe6jjty/rtTjHl0AAAAAAAAAUI6YTCaNbni3nE1O+uqPNUbHAW44V7Ozxkbeqw6hkUZHgQPQ6AIAAAAAAACAcsZkMim+YW+5mJ316YEfjY4D3DBezu56MWqImlasZXQUOAiNLgAAAAAAAAAop0bVv0MuZid9uH+F0VGAYhfg5qOpLYarlqWy0VHgQNyjCwAAAAAAAECxOn78uAIDA3Xw4MEbUm/lypUymUw6deqUJCkhIUF+fn628QkTJigyMrJYM4SHh2vlypWFes20adN05MgRu2Nz585Vjx49HJjsUg/Wu02jIu6QWaZirQMYqYpXJc1p8zBNrjKIRhcAAEAZNXv2bIWHh8vd3V0tW7bUhg0bCpy7fft29e7dW+Hh4TKZTJo+ffqNCwoAAIAy74UXXtAdd9yh8PDwG1KvdevWOnLkiCwWyw2pdy1WrVqlHj16KDQ0VCaTSQsXLrxkztKlS/Xpp5/aHbvvvvu0efNmrV69uljz3VOjnSY1HypPZ7dirQMYoZ4lTK+3HqVQzwpGR0ExoNEFAABQBn3yySeKj4/X+PHjtXnzZjVu3FixsbFKS0u77PyzZ8+qRo0amjx5soKDg29wWgAAAJRlZ8+e1TvvvKOhQ4fesJqurq4KDg6WyVRyVihlZmaqcePGmj17doFz7rjjDi1atMjumKurq+69917NnDmzuCOqdVCEXm89SsEe/sVeC7hRWlSqoxnRD8nfzdvoKCgmNLoAAADKoFdffVXDhg3TkCFDFBERoblz58rT01Pz5s277PzmzZvr5ZdfVt++feXmxl9wAgAAwHG+/fZbubm5qVWrVpKkvLw8DR06VNWrV5eHh4fq1KmjGTNm2L1m8ODB6tmzp6ZOnaqQkBBVqFBBI0eOVE5Ojm1OVlaWnnrqKYWFhcnNzU01a9bUO++8I+nSrQuvZuPGjerUqZMqVqwoi8Widu3aafPmzY75BvxP165d9fzzz+vOO+8scM7tt9+u1atXX5K7R48eWrRokc6dO+fQTJdzk2+o3rj5UdX3q1bstYDi1j2shV5qfr88WKlYptHoAgAAKGOys7O1adMmxcTE2I6ZzWbFxMRo7dq1BiYDAABAebR69Wo1a9bM9jw/P19VqlTRZ599ph07dmjcuHH6z3/+c8mWfT/88IP279+vH374Qe+++64SEhKUkJBgGx84cKA++ugjzZw5Uzt37tQbb7whb++irdg4c+aMBg0apJ9++knr1q1TrVq11K1bN505c8Y2p2vXrvL29i7wUb9+/SLV/rsqVaqoQYMG+vbbb+2OR0VFKTc3V+vXr7/uGtciwM1HM6IfUkxokxtSD3A0V7OzRje8W/9u3FfOZiej46CYORsdAAAAAI517Ngx5eXlKSgoyO54UFCQdu3a5bA6WVlZysrKsj1PT0932LkBAABQdvzxxx8KDQ21PXdxcdHEiRNtz6tXr661a9fq008/1T333GM77u/vr1mzZsnJyUl169ZV9+7dlZiYqGHDhmnPnj369NNPtXz5ctsfeNWoUaPIGW+99Va752+++ab8/Pz0448/6rbbbpMkvf3221dcUeXi4lLk+n93cfvCe++913bM09NTFotFf/zxh0NqXAs3JxeNbzpAVb0DNW/PshtWF7heQR7+er7ZYNX1CzM6Cm4QGl0AAAAokkmTJtl9QAEAAABczrlz5+Tu7m53bPbs2Zo3b56Sk5N17tw5ZWdnKzIy0m5O/fr15eT0/ysxQkJC9Ntvv0mSkpKS5OTkpHbt2jkkY2pqqsaOHauVK1cqLS1NeXl5Onv2rJKTk21zKleu7JBaV9OtWzdNmzZNVqvV7h5jHh4eOnv27A3J8HdDascq3DtIL239VJm55294faAwoirW1vim/5KfK/fjKk/YuhAAAKCMqVixopycnJSammp3PDU1VcHBwQ6rM2bMGJ0+fdr2OHTokMPODQAAgLKjYsWKOnnypO35xx9/rCeeeEJDhw7Vd999p6SkJA0ZMkTZ2dl2r/vnCimTyaT8/HxJF5o+jjRo0CAlJSVpxowZ+vnnn5WUlKQKFSrYZboRWxdK0oEDB1S1alW7JpcknThxQpUqVXJIjcLqEBqpebc8rnp+VQ2pD1yNSSb9q2ZHvdJyOE2ucogVXQAAAGWMq6urmjVrpsTERPXs2VPShfsgJCYmKi4uzmF13Nzc5ObGDX0BAABwZU2aNNEHH3xge75mzRq1bt1aDz30kO3Y/v37C3XOhg0bKj8/Xz/++KPdvWmLas2aNXr99dfVrVs3SdKhQ4d07Ngxuzk3auvCRYsW6fbbb7c7tn//fp0/f15Nmhh3z6xQrwp6vfUovbX7W320f6WsshqWBfg7b2d3PR15r24ObmB0FBiERhcAAEAZFB8fr0GDBikqKkotWrTQ9OnTlZmZqSFDhki6cOPuypUra9KkSZKk7Oxs7dixw/b1X3/9paSkJHl7e6tmzZqGXQcAAABKv9jYWI0ZM0YnT56Uv7+/atWqpffee0/Lli1T9erV9f7772vjxo2qXr36NZ8zPDxcgwYN0n333aeZM2eqcePG+uOPP5SWlmZ3n69rVatWLb3//vuKiopSenq6Ro8efcmqsevdujAjI0P79u2zPT9w4ICSkpIUEBCgqlUvrJTKzc3Vt99+q2XL7O+JtXr1atWoUUM33XTTdWW4Xs5mJ42o10NRFWvr+aQFOpF1xtA8QC3fynq22UBV8TJmtSNKBrYuBAAAKIP69OmjqVOnaty4cYqMjFRSUpKWLl2qoKAgSVJycrKOHDlim3/48GE1adJETZo00ZEjRzR16lQ1adJE999/v1GXAAAAgDKiYcOGatq0qT799FNJ0gMPPKBevXqpT58+atmypY4fP263uutazZkzR3fddZceeugh1a1bV8OGDVNmZmaRMr7zzjs6efKkmjZtqgEDBujhhx9WYGBgkc5VkF9++cX2nlu68MdpTZo00bhx42xzVq9eLQ8PD0VFRdm99qOPPtKwYcMcmud6NK9URwltR6tVpbpGR0E55Wxy0n21Y/XmzY/S5IJMVquVNaZXkZ6eLovFotOnT8vX19foOA4V9/ZPxXr+WfffXKznL6zydr0AgOJXlt8nFFaxfy/eeMLx50ShxTn1NDpCucd7Tgfjd0uJwO8W4xXn7xbeL0GSlixZotGjR2vbtm0ym8vH396Hh4crISFB7du3v+bXPPbYYzp79qzeeOMN27Ht27fr1ltv1Z49e2SxWIohadFZrVZ9cuBHvblriXLy84yOg3LiJp8QPR15r2pZrm+VJcoOti4EAAAAAAAAUKy6d++uvXv36q+//lJYWJjRcUqsb775RjNmzLA7duTIEb333nslrsklSSaTSX1rtFezCrX00tZPtPv0n0ZHQhnmZDLrXzU7anCtznI2OxkdByUIjS4AAAAAAAAAxe7RRx81OkKJ9/d7eF0UExNjQJLCqWWprDduflRfHvhJb+/5r87mZhkdCWVMDZ9g/adxP9Xxo1GOS9HoAgAAAAAAAAAHe/TRRxUeHm50jBvGyWTW3TXaqn1II03f/pVWpfxmdCSUAU4ms/rd1EH31Y6Vi5l2Bi6PfzIAAAAAAAAAwMHK6wq2Sh5+eiFqiNakbte0bV8q9dxJoyOhlGocUEMP1++p2pYqRkdBCUejCwAAAAAAAADgUG2C6qtphZqat2eZPjuwSnnWfKMjoZQI8QzQQ/V6qH1IY6OjoJSg0QUAAAAAAAAAcDgPZzeNjLhdsVWaafq2r7TlxO9GR0IJ5unspgE1Y3RP9XZydaJ1gWvHPy0AAAAAAAAAgGJT07eyZrWO0/q0nXpj17fam/6X0ZFQgphlUtew5hpWp5squPsaHQelEI0uAAAAAAAAAECxaxlYTy0q1dUPR7bo7d3/1aHMo0ZHgsEaB9TQqPo9VYf7cOE60OgCAAAAAAAAANwQJpNJt4ZGqm1wQ/33z41K2POd0s6fMjoWbrCG/tU1sFaMWgXWMzoKygAaXQAAAAAAAACAG8rZ7KQeVVupc+Vm+urgGn2wL1GnczKNjoVi1rxibQ2oFaMmFWoaHQVliNnoAFcyYcIEmUwmu0fdunVt4+fPn9fIkSNVoUIFeXt7q3fv3kpNTbU7R3Jysrp37y5PT08FBgZq9OjRys3NvdGXAgAAAAAAAAD4BzcnF/W9qb0+ufVpjax3u4I9/I2OBAczyaSbgxrozZsf1autHqTJBYcr8Su66tevr++//9723Nn5/yM/9thjWrJkiT777DNZLBbFxcWpV69eWrNmjSQpLy9P3bt3V3BwsH7++WcdOXJEAwcOlIuLi1588cUbfi0AAAAAAAAAgEt5ubir703tdXeNtlp1ZKs+PbBK204eNDoWroNZJnUIjdSAmh11k2+o0XFQhpX4Rpezs7OCg4MvOX769Gm98847WrBggW699VZJ0vz581WvXj2tW7dOrVq10nfffacdO3bo+++/V1BQkCIjI/Xcc8/pqaee0oQJE+Tq6nqjLwdAGRT39k/Fev5Z999crOcHAAAAAAAoKZxMZnUIjVSH0EjtOPmHPjuwSj8c2aI8a77R0XCNfFw81LlyM/UOv0Vh3pWMjoNyoERvXShJe/fuVWhoqGrUqKH+/fsrOTlZkrRp0ybl5OQoJibGNrdu3bqqWrWq1q5dK0lau3atGjZsqKCgINuc2NhYpaena/v27QXWzMrKUnp6ut0DAAAAAAAAAHDjRPhX0/imA/TZrWPV/6Zb5eviaXQkXEHjgBoaG3mvvoqZoEcb9KLJhRumRK/oatmypRISElSnTh0dOXJEEydO1C233KJt27YpJSVFrq6u8vPzs3tNUFCQUlJSJEkpKSl2Ta6L4xfHCjJp0iRNnDjRsRcDAGUEK9gAAAAAAMCNVMnDTw/Wu02Da3fWyiNb9N1fm7X52F5WeZUAfq7e6lIlSj2qtlJV70Cj46CcKtGNrq5du9q+btSokVq2bKlq1arp008/lYeHR7HVHTNmjOLj423P09PTFRYWVmz1AAAAAAAAAABX5u7kqi5VmqtLleY6fj5dKw4naflfm7Tz9CGjo5UrJpnUrGIt9ajaSrcEN5CLuUS3GVAOlKp/Av38/FS7dm3t27dPnTp1UnZ2tk6dOmW3qis1NdV2T6/g4GBt2LDB7hypqam2sYK4ubnJzc3N8RcAAAAAAAAAALhuFdx9dXeNtrq7RlslZ6Rp+V+btfyvTfrr7HGjo5VJJpnUwD9c7UMaqV1IIwV5+BsdCbApVY2ujIwM7d+/XwMGDFCzZs3k4uKixMRE9e7dW5K0e/duJScnKzo6WpIUHR2tF154QWlpaQoMvLBscvny5fL19VVERIRh1wEAAAAAAAAAcIyq3oEaWqeLhtbpou0n/1Di4V+1NnWH/jx7zOhopZqzyUmNK9RQ2+CGahvcUBXdLUZHAi6rRDe6nnjiCfXo0UPVqlXT4cOHNX78eDk5Oalfv36yWCwaOnSo4uPjFRAQIF9fX40aNUrR0dFq1aqVJKlz586KiIjQgAEDNGXKFKWkpGjs2LEaOXIkK7YAAAAAAAAAoIyp719N9f2r6eH6PZWckaZ1aTu1Lm2ntpz4Xdn5uUbHK/F8XTzVKrCe2gTVV4tKdeTtUny3EAIcpUQ3uv7880/169dPx48fV6VKlXTzzTdr3bp1qlSpkiRp2rRpMpvN6t27t7KyshQbG6vXX3/d9nonJyctXrxYI0aMUHR0tLy8vDRo0CA9++yzRl0SADhM3Ns/Fev5Z91/c7GeHwAAAAAAoDhV9Q5UVe9A3VOjnbLysrXlxAFtOrZHvxzbq32n/1K+rEZHNFyAm48a+ldX44AaahRQXTUtleVkMhsdCyiUEt3o+vjjj6847u7urtmzZ2v27NkFzqlWrZq+/fZbR0cDAAAAAAAAAJQSbk6ualGpjlpUqiNJSs/O1G8nD2rXqUPaffpP7T59SCeyzhicsvhV8aqkRgHV1Sighhr5V1eYdyWjIwHXrUQ3ugAAAAAAAAAAcDRfVy+1CaqvNkH1bceOnjul3af/1K7T/2t+nTqkk9kZBqYsOlezs8K8KqmaT5DCvYNUwydEDQOqK8DNx+hogMPR6AIAlAps1QgAAAAAAIpTJQ8/VfLw083BDWzH0s6dUnJGmo6cO6EjZ08o5ewJ29cnss7IavD2h97O7grzDlQ17yCFewcq3CdY1bwDFeJZgS0IUW7Q6AIAAAAAAAAA4DICPfwU6OF32bGsvBylnjupI2eP68i5kzqdnanMnPM6m3tembnnlZmb9bevz+tsbpbO5WbJKqucTE5yNpnlZHKSk9ksZ5OTnEzmCw/zhTGLq5f83XwU4OYtP9cL/+vv5iN/V28FuPnI381Hbk4uN/YbApRANLoAAAAAAAAAACgkNycXVfUOVFXvQKOjAOUaaxcBAAAAAAAAAABQKtHoAgAAAAAAAAAAQKlEowsAAAAAAAAAAAClEo0uAAAAAAAAAAAAlEo0ugAAAAAAAAAAAFAq0egCAAAAAAAAAABAqUSjCwAAAAAAAAAAAKUSjS4AAAAAAAAAAACUSjS6AAAAAAAAAAAAUCrR6AIAAAAAAAAAAECpRKMLAAAAAAAAAAAApRKNLgAAAAAAAAAAAJRKNLoAAAAAAAAAAABQKtHoAgAAAAAAAAAAQKlEowsAAAAAAAAAAAClEo0uAAAAAAAAAAAAlEo0ugAAAAAAAAAAAFAq0egCAAAAAAAAAABAqUSjCwAAAAAAAAAAAKUSjS4AAAAAAAAAAACUSjS6AAAAAAAAAAAAUCo5Gx0AF8S9/VOxnn/W/TcX6/kLi+t1rJJ2vQAAAAAAAAAA3Ag0ugA4HI09AAAAAAAAAMCNwNaFAAAAAAAAAAAAKJVodAEAAAAAAAAAAKBUYutCoAwrb1sIlrfrBQAAAAAAAIDyjhVdAAAAAAAAAAAAKJVodAEAAAAAAAAAAKBUotEFAAAAAAAAAACAUqlcNbpmz56t8PBwubu7q2XLltqwYYPRkQAAAIpNYd/7fPbZZ6pbt67c3d3VsGFDffvttzcoKQAAAAAAQNGUm0bXJ598ovj4eI0fP16bN29W48aNFRsbq7S0NKOjAQAAOFxh3/v8/PPP6tevn4YOHapff/1VPXv2VM+ePbVt27YbnBwAAAAAAODalZtG16uvvqphw4ZpyJAhioiI0Ny5c+Xp6al58+YZHQ0AAMDhCvveZ8aMGerSpYtGjx6tevXq6bnnnlPTpk01a9asG5wcAAAAAADg2jkbHeBGyM7O1qZNmzRmzBjbMbPZrJiYGK1du9bAZACAki7u7Z+K9fyz7r+5WM+P8qko733Wrl2r+Ph4u2OxsbFauHBhcUYFAAAAAAC4LuWi0XXs2DHl5eUpKCjI7nhQUJB27dp1yfysrCxlZWXZnp8+fVqSlJ6eXmwZs89lFtu5pYKzU5e61KUudUtm3SfeLd4/xJg6KJq6DnLxZ2i1WoutRmEV9r2PJKWkpFx2fkpKSoF1bvh7pnNZV5+DYpftVLy/F3F1xfnfJeUSv1tKBH63GK84f7eUxPdLAACg7DBZy8G7jMOHD6ty5cr6+eefFR39/x90Pfnkk/rxxx+1fv16u/kTJkzQxIkTb3RMAABQih06dEhVqlQxOoakwr/3kSRXV1e9++676tevn+3Y66+/rokTJyo1NfWydXjPBAAACqMkvV8CAABlR7lY0VWxYkU5OTld8iFNamqqgoODL5k/ZswYu6178vPzdeLECVWoUEEmk6nY815Nenq6wsLCdOjQIfn6+lKXutSlLnWpS10DWa1WnTlzRqGhoUZHsSnsex9JCg4OLtR8qeS/Z4LjlbR//wCUDfxuKftK4vslAABQdpSLRperq6uaNWumxMRE9ezZU9KFD2ISExMVFxd3yXw3Nze5ubnZHfPz87sBSQvH19fXkP8IoC51qUtd6lK3PNe9HIvFYnQEO4V97yNJ0dHRSkxM1KOPPmo7tnz5crsVYf9UWt4zwfFK0r9/AMoOfreUbSXt/RIAACg7ykWjS5Li4+M1aNAgRUVFqUWLFpo+fboyMzM1ZMgQo6MBAAA43NXe+wwcOFCVK1fWpEmTJEmPPPKI2rVrp1deeUXdu3fXxx9/rF9++UVvvvmmkZcBAAAAAABwReWm0dWnTx8dPXpU48aNU0pKiiIjI7V06dJLbroOAABQFlztvU9ycrLMZrNtfuvWrbVgwQKNHTtW//nPf1SrVi0tXLhQDRo0MOoSAAAAAAAArqrcNLokKS4ursDtekoTNzc3jR8//pKtgqhLXepSl7rUpS7+7krvfVauXHnJsbvvvlt33313MadCaca/fwCKA79bAAAAcD1MVqvVanQIAAAAAAAAAAAAoLDMV58CAAAAAAAAAAAAlDw0ugAAAAAAAAAAAFAq0egCAAAAAAAAAABAqUSjCwAAAIDNypUrFR4efs3zN27cqM8++6z4AgEoEwr7u2XPnj16++23iy8QAAAAygwaXaVMVlaWsrKyjI4BAACAcuLEiRPq37+/fH195efnp6FDhyojI8M2npubq4ceekh5eXkGpgRQ2rzwwgtq3bq1PD095efnd8m4t7e3RowYoRMnTtz4cAAAAChVaHSVAsuXL1e3bt3k7+8vT09PeXp6yt/fX926ddP3339vdLxic/r0ae3evVu7d+/W6dOnjY5T7MrT9ebm5mrLli1atmyZli1bpi1btignJ8fQPMnJyYbVBwCgJOvfv7+2b9+u5cuXa/HixVq1apWGDx9uG2/ZsqWcnJz0888/G5gSQGmTnZ2tu+++WyNGjLjseGhoqJo0aaIlS5bc4GQAAAAobWh0lXDvvvuuunXrJovFomnTpmnx4sVavHixpk2bJj8/P3Xr1k3vv//+Dc+1c+dO1ahRo1jO/fbbbysiIkIBAQGKiIiw+/qdd94plppXs2XLFjk5ORXLucvT9ebn52vs2LGqVKmSmjRpoq5du6pr165q0qSJAgMD9cwzzyg/P9/hda9m+/btql69erHXoZlZdpuZ5e16U1JS9PXXX+uNN97QG2+8oa+//lopKSnFVu9qMjMztWrVKsPqA2XZzp07tXTpUr399ttq2bKlbr75Zr322mv6+OOPdfjwYUmS2WzWbbfdpq+//trgtABKk4kTJ+qxxx5Tw4YNC5xz++2387sFAAAAV+VsdABc2QsvvKDp06dr5MiRl4wNHjxYN998s5599lkNGDDghubKzs7WH3/84fDzvvzyy5owYYIefvhhxcbGKigoSJKUmpqq7777To888ohOnjypJ554wuG1r8ZqtTr8nOXtev/9738rISFBkydPvuz1PvPMM8rOztZLL73k8NpGevvtt/Xqq69q9+7ddsfr1Kmjxx9/XEOHDr3hmbZs2aKmTZs6fJup/Px8jRs3TrNnz76kmWexWBQXF6eJEyfKbL6xf2exfft2rtcBMjMz9cADD+jjjz+WyWRSQECApAvbmlmtVvXr109vvPGGPD09HVr3avbt26cOHTqwbRpQDNauXSs/Pz9FRUXZjsXExMhsNmv9+vW68847JV34MHr06NGaOnWqUVEBlEG33367pkyZouzsbLm6uhodBwAAACUUja4SLjk5WTExMQWOd+zYUY8//rjD68bHx19x/OjRow6vKUmzZs3S/Pnzdc8999gdr1evntq3b6/GjRtr9OjRDm/89OrV64rjp0+flslkcmhNqfxd73vvvaf3339fsbGxdsfDw8M1fPhwVatWTQMHDnR4o6tp06ZXHD937pxD6/0dzcyy3cwsb9f7yCOPaMOGDVqyZIliYmJsKz/z8vKUmJioUaNG6ZFHHtFbb71lcFIAjpKSkqLAwEC7Y87OzgoICLBbydmpUyf9+eef2rVrl+rWrXujYwIooxo1aqQKFSpoxYoV6tKli9FxAAAAUELR6Crh6tevr3feeUdTpky57Pi8efMUERHh8LozZsxQZGSkfH19Lzv+9xuQO1JaWtoVt65o2LChjh075vC633zzjTp16mT7kPqfimuVQHm73jNnzig0NLTA8ZCQEGVmZjq87o4dO9S3b98Ctyc8cuSI9uzZ4/C6Es3Mi8pqM7O8Xe8XX3yhJUuWqHXr1nbHnZyc1LlzZ82bN0+33XabwxtdF1eOFYSVXIDxPDw81L59e3377bc0ugA4VLdu3fTtt9/S6AIAAECBaHSVcK+88opuu+02LV26VDExMXarBRITE/X7778Xy815a9asqccee0z/+te/LjuelJSkZs2aObxu8+bNNXnyZL3zzjtydrb/xzMvL08vvfSSmjdv7vC69erVU+/evQvcQi4pKUmLFy92eN3ydr3t27fXE088oQ8//FAVK1a0Gzt27JieeuoptW/f3uF1GzRooJYtWxZ4o+ukpKRiW4FCM9NeWWtmlrfrzc/Pv+K2Qa6ursVyn72srCyNGDGiwH+X/vjjD02cONHhdQFIwcHBSktLszuWm5urEydOKDg42O74gQMHFB4efgPTASgPDhw4cMVdTgAAAAAaXSVc+/bttW3bNs2ZM0fr1q2zbRETHBysrl276sEHHyyWDxSioqK0adOmAhtdJpOpWLY9mzVrlmJjYxUcHKy2bdvaNfZWrVolV1dXfffddw6v26xZM23evLnAxo+bm5uqVq3q8Lrl7Xrnzp2rbt26KSQkRA0bNrS73t9++00RERHF0mBr06bNJffH+jsfHx+1bdvW4XUlmpl/VxabmeXtem+77TYNHz5c77zzjpo0aWI39uuvv2rEiBHq0aOHw+tGRkYqLCxMgwYNuuz4li1baHQBxSQ6OlqnTp3Spk2bbH/ktGLFCuXn56tly5a2efv27dPvv/9+yQpXALgemZmZWrFihWbOnGl0FAAAAJRgNLpKgfDw8Bt+f5dXXnlFWVlZBY43bty4WP5qv1GjRtqzZ48++OADrVu3Tr///rukC429559/Xvfee2+B2ylej7lz515xhUu9evV04MABh9ctb9cbFhamLVu2aNmyZXaN2xYtWujFF19U586dZTabHV53xowZVxy/6aab9MMPPzi8rkQzs6w3M8vb9c6aNUv33nuvmjVrJn9/f9t9e9LS0nTq1CnFxsZq1qxZDq/bvXt3nTp1qsDxgIAADRw40OF1AVx4T9ClSxcNGzZMc+fOVU5OjuLi4tS3b1+7Fa2LFi1Sx44d5eXlZWBaAKVJcnKyTpw4oeTkZOXl5SkpKUnShd1FvL29JUnLli3TTTfdpJo1axqYFAAAACWdyVocy3LgcLm5udq+fbutMRASEqJ69erJxcXF4GQArubMmTO2ZubfV2VGR0cXWzMzKytLeXl58vT0dPi5ryY/P/+SZubF6y2uZqaRytv1StKuXbu0du3aS66X+/IAZcPKlSs1ePBgHTx4UJJ04sQJxcXF6ZtvvpHZbFbv3r01c+ZM2wfRktSuXTvde++9euCBBwxKDaCk++fvlsGDB+vdd9+9ZN4PP/xgWxE/aNAghYaGatKkSTcwKQAAAEobGl0lXH5+vsaNG6fZs2fr9OnTdmMWi0VxcXGaOHFisX2Q+s8GW3BwsCIiIgxrsOXk5OjIkSPFshLlSnJzc3X48OFiq5uSkqL169fbNTJbtGhxyb0virtucHCwWrZsWex1C5KZmalNmzYV2zaCJa0uAAAl0T8/jL6aEydOKCgoSH/88ccV71sIoHwr7O+WvLw8BQcHa9GiRYqOji7ecAAAACjV2LqwhPv3v/+thIQETZ48WbGxsXbbYn333Xd65plnlJ2d7fCtDY1usBVkx44datq06RW33SsO27dvL5a6mZmZeuCBB/Txxx/LZDIpICBA0oUPjKxWq/r166c33njD4atyjKp7Nfv27VOHDh1u+M/3RtSlmXlBWW1mbtiw4ZIVTq1bty6W+69drW50dLRatGhRrHULcvLkSX3zzTc3fBtBo+oCuGDJkiWKjIykyQXAoX7++WeZzWa7+wECAAAAl8OKrhIuODhY7777boE39l62bJkGDhyo1NRUh9Z98sknlZCQoOeee67ABtvgwYNv+L3DtmzZYkijq7jq3n///Vq1apVee+01xcTEyMnJSdKFv15MTEzUqFGj1LZtW7311ltlou7VlLWfr0Qz85/K2s84LS1NvXv31po1a1S1alW735XJyclq06aNvvjiC9u9rEp73aspaz9foLwq7KoLALgW/G4BAABAcaHRVcJ5eXlp3bp1atiw4WXHt27dqtatWysjI8OhdY1qsDVt2vSK4+fOndOePXsc/mGmUXX9/f21ZMkStW7d+rLja9as0W233aaTJ0+WiboXmy0FycvLU0ZGhsO/z0bVlWhm/lNZa4TcddddOnz4sObPn686derYje3evVv33XefQkND9dlnn5WJuunp6Vcc37p1q9q1a+fw77NRdYHy6uDBg1q4cKEeffRRo6MAKEP43QIAAIDiQqOrhOvevbtyc3P14YcfqmLFinZjx44d04ABA+Tk5KTFixc7tK5RDTZ3d3f17dtX1atXv+z4kSNH9NZbbzn8w0yj6losFiUmJioqKuqy4xs3blRMTMwl20eW1rpeXl4aMWJEgf9c/fHHH5o4caLDv89G1ZVoZv5TWWtm+vj4aNWqVWrSpMllxzdt2qT27dvrzJkzZaKu2WyWyWQqcNxqtcpkMjn8+2xUXQAAAAAAAJR83KOrhJs7d666deumkJAQNWzY0G57qt9++00REREOb3JJUvv27fXEE08U2GB76qmn1L59e4fXbdCggVq2bKkRI0ZcdjwpKalYVqAYVfe2227T8OHD9c4771zygfWvv/6qESNGqEePHmWmbmRkpMLCwjRo0KDLjm/ZskUTJ04sM3WlC/e7c3V1LXDc1dVV+fn5ZaZuVlbWNTUVy0pdNze3K642OnPmjNzc3MpMXR8fHz399NMF3itj7969euCBB8pMXQAAAAAAAJR8NLpKuLCwMG3ZskXLli3TunXrlJKSIklq0aKFXnzxRXXu3Flms9nhdY1qsLVp00a7d+8ucNzHx0dt27YtM3VnzZqle++9V82aNZO/v7/tfjppaWk6deqUYmNjNWvWrDJTt3v37jp16lSB4wEBARo4cGCZqSvRzPynstbM7NOnjwYNGqRp06apY8eO8vX1lXRhq73ExETFx8erX79+ZabuxW1e27Vrd9lxPz8/FcdCcaPqAgAAAAAAoORj60IUKD8//5IGW3BwsKKjo4utwVZe7dq1S2vXrr3k+1y3bt0yWbc8OXnypO69914tW7aswKbiggUL5OfnVybqvvjii8rJydH48eMvO37o0CGNGzdO8+fPLxN1s7Ky9Oijj2revHnKzc21raLLzs6Ws7Ozhg4dqmnTpjl8dZVRdd966y2dO3dODz/88GXHU1NTNXfu3AJ/DqWtLgAAAAAAAEo+Gl2lxIYNGy5pSLRu3VrNmzc3OBmAa7Fz587LNo2Lu6loVN3yJj09XZs2bbL7Pjdr1sy20qqs1QUAAAAAAABKChpdJVxaWpp69+6tNWvWqGrVqnZbCCYnJ6tNmzb64osvbKs1HM2oBtvl6kZHR6tFixZlsm5BTp48qW+++abYttWjrrF1AQAALpowYYIWLlyopKSk6zpPQkKCHn300Stu2wwAAAAAZQmNrhLurrvu0uHDhzV//nzVqVPHbmz37t267777FBoaqs8++8yhdY1qsJW3ulezZcsWNW3aVHl5edQtxXWzs7O1cOHCyzaN77jjDtu2c9QtnXWvJDU1VW+88YbGjRtH3TJYFwAuOnr0qMaNG6clS5YoNTVV/v7+aty4scaNG6c2bdpc0zmK0ugKDw/Xo48+qkcffdR27Ny5czpz5swNed+6b98+vfDCC1q+fLmOHj2q0NBQtWrVSo8//riioqKKvX5p0b59e0VGRmr69OlGRwEAAADKJG6yVMItW7ZMs2fPvqTJJUl16tTRzJkztXTpUofXfeihh5SXl6edO3fq4MGDWr9+vdavX6+DBw9q586dys/P18iRI6l7ndLT06/4OHPmjMNrUvfG1ZUufABUr149DRo0SL/++qvy8/OVn5+vX3/9VQMHDlT9+vW1b98+6pbSuleTkpKiiRMnUreM1gWAi3r37q1ff/1V7777rvbs2aNFixapffv2On78+A3P4uHhcUOaXL/88ouaNWumPXv26I033tCOHTv01VdfqW7dunr88ceLvT4AAAAAXMSKrhKuYsWK+uKLL9SuXbvLjq9cuVJ33XWXjh075tC6Pj4+WrVqlZo0aXLZ8U2bNql9+/YObxCUt7pms1kmk6nAcavVKpPJ5PCVRtS9MXUlqVOnTvLy8tJ77713yX2T0tPTNXDgQJ07d07Lli2jbimsu3Xr1iuO79q1S/369XP4P1vUvTF1AeBanDp1Sv7+/lq5cmWB79klKTk5WaNGjVJiYqLMZrO6dOmi1157zbaTwD9XdF1uFVDPnj3l5+enhIQEtW/fXj/++KNdDavVetmtC+fMmaOpU6fq0KFDql69usaOHasBAwbYxk0mk9566y0tWbJEy5YtU+XKlfXKK6/o9ttvv+y1WK1WNWzYUO7u7tqwYYPMZvu/nzx16pT8/PwkSb/99pseeeQRrV27Vp6enurdu7deffVVeXt7S5IGDx6sU6dOqUWLFpoxY4aysrIUHx+v//znPxozZozeeecdeXp66rnnntOQIUMkSQcPHlT16tX10UcfaebMmdq8ebNq1qyp2bNn2/0MfvzxR40ePVpbtmxRQECABg0apOeff17Ozs6273GjRo3k7u6ut99+W66urnrwwQc1YcIEu2t54okn9PXXXysrK0tRUVGaNm2aGjdubPdze/zxx/XMM8/o5MmT6tq1q9566y35+Pho8ODBevfdd+2+PwcOHFB4ePhlv7cAAAAACs/Z6AC4sj59+mjQoEGaNm2aOnbsaPsANz09XYmJiYqPj1e/fv0cXtfNzU3p6ekFjp85c0Zubm7UvU4+Pj56+umn1bJly8uO7927Vw888AB1S2ldSVqzZo02bNhwSfNFknx9ffXcc88VmIu6Jb9uZGSkTCaTLvc3IxePX6nJSt2SXRcAroW3t7e8vb21cOFCtWrV6rLvGfPz83XHHXfI29tbP/74o3JzczVy5Ej16dNHK1euLFLdL7/8Uo0bN9bw4cM1bNiwAud99dVXeuSRRzR9+nTFxMRo8eLFGjJkiKpUqaIOHTrY5k2cOFFTpkzRyy+/rNdee039+/fXH3/8oYCAgEvOmZSUpO3bt2vBggWXNLkk2ZpcmZmZio2NVXR0tDZu3Ki0tDTdf//9iouLU0JCgm3+ihUrVKVKFa1atUpr1qzR0KFD9fPPP6tt27Zav369PvnkEz3wwAPq1KmTqlSpYnvd6NGjNX36dEVEROjVV19Vjx49dODAAVWoUEF//fWXunXrpsGDB+u9997Trl27NGzYMLm7u9s1st59913Fx8dr/fr1Wrt2rQYPHqw2bdqoU6dOkqS7775bHh4e+u9//yuLxaI33nhDHTt21J49e2zfm/3792vhwoVavHixTp48qXvuuUeTJ0/WCy+8oBkzZmjPnj1q0KCBnn32WUlSpUqVrv4DBgAAAHDNaHSVcK+++qry8/PVt29f5ebm2u4xk52dLWdnZw0dOlRTp051eF2jGmzlrW7Tpk0lqcC//vXz87vsB7vULR11L5774MGDatCgwWXHDx48aPswiLqlr25AQICmTJmijh07XnZ8+/bt6tGjB3VLaV0AuBbOzs5KSEjQsGHDNHfuXDVt2lTt2rVT37591ahRI0lSYmKifvvtNx04cEBhYWGSpPfee0/169fXxo0b1bx580LXDQgIkJOTk3x8fBQcHFzgvKlTp2rw4MF66KGHJEnx8fFat26dpk6datfoGjx4sO397osvvqiZM2dqw4YN6tKlyyXn3Lt3rySpbt26V8y4YMECnT9/Xu+99568vLwkSbNmzVKPHj300ksv2VazBQQEaObMmTKbzapTp46mTJmis2fP6j//+Y8kacyYMZo8ebJ++ukn9e3b13b+uLg49e7dW9KFVWtLly7VO++8oyeffFKvv/66wsLCNGvWLJlMJtWtW1eHDx/WU089pXHjxtkadI0aNdL48eMlSbVq1dKsWbOUmJioTp066aefftKGDRuUlpZma2BOnTpVCxcu1Oeff67hw4dLutDITEhIkI+PjyRpwIABSkxM1AsvvCCLxSJXV1d5enpe8ecEAAAAoOhodJVwbm5umjNnjl566SVt2rRJKSkpkqTg4GA1a9bssqsXHMGoBlt5q3vvvffq7NmzBY4HBwfb/sObuqWvriTdf//9GjhwoJ555hl17NjR9oFOamqqEhMT9fzzz2vUqFHULaV1mzVrpsOHD6tatWqXHT916lSxNFGpe2PqAsC16t27t7p3767Vq1dr3bp1+u9//6spU6bo7bff1uDBg7Vz506FhYXZmlySFBERIT8/P+3cubNIja5rtXPnTltD5qI2bdpoxowZdscuNuUkycvLS76+vkpLS7vsOa/1d+7OnTvVuHFjW5PrYu38/Hzt3r3b9v/X9evXt1sZFhQUZPfHK05OTqpQocIleaKjo21fOzs7KyoqSjt37rTVjo6Otlvx26ZNG2VkZOjPP/9U1apVL7luSQoJCbHV2bJlizIyMlShQgW7OefOndP+/fttz8PDw21Nrn+eAwAAAEDxo9FVChw7dkzz5s3T2rVr7RpdrVu31uDBg4tl6wujGmzlre6VtpmRLvxHfnE0YKh7Y+pK0rPPPisvLy+9/PLLevzxx20ftlitVgUHB+upp57Sk08+Sd1SWvfBBx9UZmZmgeNVq1bV/PnzqVtK6wJAYbi7u6tTp07q1KmTnnnmGd1///0aP368Bg8eXKTzmc3mSxpKOTk5Dkh6eS4uLnbPTSaT8vPzLzu3du3aki7cI7Gge9xeb+3C5HF07Yt1MjIyFBISctntJf++UvxGZQUAAABweTS6SriNGzcqNjZWnp6eiomJsf1HZWpqqmbOnKnJkydr2bJlioqKcnhtIxps1KVuWasrSU899ZSeeuopHThwwK529erVi60mdW9M3TvvvPOK4/7+/ho0aBB1S2ldALgeERERWrhwoSSpXr16OnTokA4dOmRb1bVjxw6dOnVKERERl319pUqVdOTIEdvzvLw8bdu2zW67QVdXV+Xl5V0xR7169bRmzRq735Nr1qwpsO61iIyMVEREhF555RX16dPnkvt0nTp1Sn5+fqpXr54SEhKUmZlpW9W1Zs0a2xaF12vdunVq27atJCk3N1ebNm1SXFycpAvX/cUXX9jdx3HNmjXy8fGxu8/XlTRt2lQpKSlydnZWeHh4kXNey88JAAAAQNFdeudglCijRo3S3XffrUOHDikhIUEvvfSSXnrpJSUkJCg5OVl33XVXsWzHtXHjRtWuXVszZ86UxWJR27Zt1bZtW1ksFs2cOVN169bVL7/8Ql3qUrcQqlevrujoaEVHR9uaL4cOHdJ9991H3TJQ93KoW7brAoAkHT9+XLfeeqs++OADbd26VQcOHNBnn32mKVOm6I477pAkxcTEqGHDhurfv782b96sDRs2aODAgWrXrl2Bf7B26623asmSJVqyZIl27dqlESNG6NSpU3ZzwsPDtWrVKv311186duzYZc8zevRoJSQkaM6cOdq7d69effVVffnll3riiSeKfM0mk0nz58/Xnj17dMstt+jbb7/V77//rq1bt+qFF16wXXf//v3l7u6uQYMGadu2bfrhhx80atQoDRgwwLZt4fWYPXu2vvrqK+3atUsjR47UyZMnbf9/8NBDD+nQoUMaNWqUdu3apa+//lrjx49XfHz8JY25gsTExCg6Olo9e/bUd999p4MHD+rnn3/W008/Xaj3juHh4Vq/fr0OHjyoY8eOsdoLAAAAcDQrSjR3d3frzp07CxzfuXOn1d3d3eF1W7ZsaR0+fLg1Pz//krH8/Hzr8OHDra1ataIudal7nZKSkqxms5m61KVuKawLAFar1Xr+/Hnrv//9b2vTpk2tFovF6unpaa1Tp4517Nix1rNnz9rm/fHHH9bbb7/d6uXlZfXx8bHefffd1pSUFNv4+PHjrY0bN7Y9z87Oto4YMcIaEBBgDQwMtE6aNMl6xx13WAcNGmSbs3btWmujRo2sbm5u1ov/aTd//nyrxWKxy/j6669ba9SoYXVxcbHWrl3b+t5779mNS7J+9dVXdscsFot1/vz5V7z23bt3WwcOHGgNDQ21urq6WqtVq2bt16+fdfPmzbY5W7dutXbo0MHq7u5uDQgIsA4bNsx65swZ2/igQYOsd9xxh91527VrZ33kkUfsjlWrVs06bdo0q9VqtR44cMAqybpgwQJrixYtrK6urtaIiAjrihUr7F6zcuVKa/Pmza2urq7W4OBg61NPPWXNycm5Yp1/fo/T09Oto0aNsoaGhlpdXFysYWFh1v79+1uTk5OtVuulPzer1WqdNm2atVq1anbfp1atWlk9PDyskqwHDhwo+JsKAAAAoNBMVit3by/JqlevrokTJ2rgwIGXHX/vvfc0btw4HTx40KF1PTw89Ouvv6pu3bqXHb+4H/+5c+eoS13qXsGiRYuuOP7777/r8ccfd/h2NtSlLnUBAGXVwYMHVb16df3666+KjIw0Og4AAAAAg3GPrhLuiSee0PDhw7Vp0yZ17NjRtsVHamqqEhMT9dZbb2nq1KkOrxscHKwNGzYU2BjYsGGDQ7YboS51y3JdSerZs6dMJtMlN5P/u4v3jaAudalbsuoCAAAAAACg5KPRVcKNHDlSFStW1LRp0/T666/b/lrdyclJzZo1U0JCgu655x6H1zWqwUZd6palupIUEhKi119/3Xavin9KSkpSs2bNqEtd6pbAugAAAAAAACj5aHSVAn369FGfPn2Uk5Nju8l0xYoV5eLiUmw1jWqwUZe6ZamuJDVr1kybNm0q8AP6q61SoS51qWtcXQBAyRQeHs7vfQAAAAA23KMLV3UjG2zUpW5Zq7t69WplZmaqS5culx3PzMzUL7/8onbt2lGXutQtYXUBAAAAAABQ8tHoAgAAAAAAAAAAQKlkNjoAAAAAAAAAAAAAUBQ0ugAAAAAAAAAAAFAq0egCAAAAAAAAAABAqUSjCwAAAAAAAAAAAKUSjS6gFDl48KBMJpOSkpJuSL2EhAT5+fndkFqS1LZtWy1YsOCa5jo6W1HOl5CQoPbt219xTnh4uKZPn17kXMVt5cqVCg8PNzqG2rdvr0cffdT2/J/fN5PJpIULF17z+ebOnasePXo4LiAAAAAAAACAEolGF1BCDB48WCaTyfaoUKGCunTpoq1bt9rmhIWF6ciRI2rQoIGkC00Kk8mkU6dOFapOz549r2lunz59tGfPnsJcRpEtWrRIqamp6tu37w2pd6Ns3LhRw4cPv+F1C/NzLgm+/PJLPffccw4733333afNmzdr9erVDjsnAAAAAAAAgJKHRhdQgnTp0kVHjhzRkSNHlJiYKGdnZ9122222cScnJwUHB8vZ2bnYs+Tk5MjDw0OBgYHFXkuSZs6cqSFDhshsLlu/lipVqiRPT0+jY5R4AQEB8vHxcdj5XF1dde+992rmzJkOOycAAAAAAACAkqdsfaIMlHJubm4KDg5WcHCwIiMj9e9//1uHDh3S0aNHJdlvXXjw4EF16NBBkuTv7y+TyaTBgwdLkj7//HM1bNhQHh4eqlChgmJiYpSZmakJEybo3Xff1ddff21bObZy5UrbeT/55BO1a9dO7u7u+vDDDy/Zzm/ChAmKjIzU+++/r/DwcFksFvXt21dnzpyxzTlz5oz69+8vLy8vhYSEaNq0aZdsS/dPR48e1YoVKy7Zau7UqVN64IEHFBQUJHd3dzVo0ECLFy8u8Dxz5szRTTfdJFdXV9WpU0fvv/9+kc939OhRRUVF6c4771RWVlaBNa/mclvwvf3227rzzjvl6empWrVqadGiRbbxi6v0lixZokaNGsnd3V2tWrXStm3bbHMu/hz+bvr06bYtCAv6ORfV0qVLdfPNN8vPz08VKlTQbbfdpv3799vGL/7z8+WXX6pDhw7y9PRU48aNtXbtWrvzrFmzRu3bt5enp6f8/f0VGxurkydPSrp068Kreeqpp1S7dm15enqqRo0aeuaZZ5STk2M3p0ePHlq0aJHOnTtX5GsHAAAAAAAAULLR6AJKqIyMDH3wwQeqWbOmKlSocMl4WFiYvvjiC0nS7t27deTIEc2YMUNHjhxRv379dN9992nnzp1auXKlevXqJavVqieeeEL33HOP3cqx1q1b287573//W4888oh27typ2NjYy+bav3+/Fi5cqMWLF2vx4sX68ccfNXnyZNt4fHy81qxZo0WLFmn58uVavXq1Nm/efMVr/emnn+Tp6al69erZjuXn56tr165as2aNPvjgA+3YsUOTJ0+Wk5PTZc/x1Vdf6ZFHHtHjjz+ubdu26YEHHtCQIUP0ww8/FPp8hw4d0i233KIGDRro888/l5ub2xXzF9bEiRN1zz33aOvWrerWrZv69++vEydO2M0ZPXq0XnnlFW3cuFGVKlVSjx49LmnkFORqP+fCyszMVHx8vH755RclJibKbDbrzjvvVH5+vt28p59+Wk888YSSkpJUu3Zt9evXT7m5uZKkpKQkdezYUREREVq7dq1++ukn9ejRQ3l5eUXK5OPjo4SEBO3YsUMzZszQW2+9pWnTptnNiYqKUm5urtavX1+0CwcAAAAAAABQ4hX//mcArtnixYvl7e0t6UJzISQkRIsXL77sdn5OTk4KCAiQJAUGBtpWXu3fv1+5ubnq1auXqlWrJklq2LCh7XUeHh7KyspScHDwJed89NFH1atXrytmzM/PV0JCgm2buQEDBigxMVEvvPCCzpw5o3fffVcLFixQx44dJUnz589XaGjoFc/5xx9/KCgoyO46v//+e23YsEE7d+5U7dq1JUk1atQo8BxTp07V4MGD9dBDD0m60HBbt26dpk6dqg4dOlzz+Xbv3q1OnTrpzjvv1PTp02Uyma6YvSgGDx6sfv36SZJefPFFzZw5Uxs2bFCXLl1sc8aPH69OnTpJkt59911VqVJFX331le65556rnt/b2/uKP+fC6t27t93zefPmqVKlStqxY4ftfnHShQZb9+7dJV1o5tWvX1/79u1T3bp1NWXKFEVFRen111+3za9fv36RM40dO9b2dXh4uJ544gl9/PHHevLJJ23HPT09ZbFY9McffxS5DgAAAAAAAICSjRVdQAnSoUMHJSUlKSkpSRs2bFBsbKy6du1aqA/qGzdurI4dO6phw4a6++679dZbb9m2h7uaqKioq84JDw+3u5dSSEiI0tLSJEm///67cnJy1KJFC9u4xWJRnTp1rnjOc+fOyd3d3e5YUlKSqlSpYmtKXc3OnTvVpk0bu2Nt2rTRzp07r/l8586d0y233KJevXppxowZxdLkkqRGjRrZvvby8pKvr6/te3hRdHS07euAgADVqVPHdi032t69e9WvXz/VqFFDvr6+ti0Sk5OT7eb9/bpCQkIkyXZdF1d0Oconn3yiNm3aKDg4WN7e3ho7duwleaQLjd2zZ886rC4AAAAAAACAkoVGF1CCeHl5qWbNmqpZs6aaN2+ut99+W5mZmXrrrbeu+RxOTk5avny5/vvf/yoiIkKvvfaa6tSpowMHDlxT/atxcXGxe24ymS7Zwq6wKlaseEkzzsPD47rO+U/Xcj43NzfFxMRo8eLF+uuvvxxa/++u93toNptltVrtjl3rtoZF0aNHD504cUJvvfWW1q9fb9sKMDs7227e36/rYpPw4nU58ue5du1a9e/fX926ddPixYv166+/6umnn74kjySdOHFClSpVclhtAAAAAAAAACULjS6gBDOZTDKbzTp37txlx11dXSXpkvscmUwmtWnTRhMnTtSvv/4qV1dXffXVV7bXFPW+SFdTo0YNubi4aOPGjbZjp0+f1p49e674uiZNmiglJcWu2dWoUSP9+eefV33tRfXq1dOaNWvsjq1Zs0YRERHXfD6z2az3339fzZo1U4cOHXT48OFrql0c1q1bZ/v65MmT2rNnj+0eZpUqVVJKSopdsyspKcnu9Y76OR8/fly7d+/W2LFj1bFjR9WrV++aVwj+XaNGjZSYmHjdeSTp559/VrVq1fT0008rKipKtWrVuuyqx/379+v8+fNq0qSJQ+oCAAAAAAAAKHlodAElSFZWllJSUpSSkqKdO3dq1KhRysjIUI8ePS47v1q1ajKZTFq8eLGOHj2qjIwMrV+/Xi+++KJ++eUXJScn68svv9TRo0dtTZLw8HBt3bpVu3fv1rFjxxy6EsjHx0eDBg3S6NGj9cMPP2j79u0aOnSozGbzFbcBbNKkiSpWrGjXqGrXrp3atm2r3r17a/ny5Tpw4ID++9//aunSpZc9x+jRo5WQkKA5c+Zo7969evXVV/Xll1/qiSeeKJP2OSAAAAOaSURBVNT5nJyc9OGHH6px48a69dZblZKS4oDvTOE9++yzSkxM1LZt2zR48GBVrFhRPXv2lCS1b99eR48e1ZQpU7R//37Nnj1b//3vf+1e76ifs7+/vypUqKA333xT+/bt04oVKxQfH1/o84wZM0YbN27UQw89pK1bt2rXrl2aM2eOjh07Vuhz1apVS8nJyfr444+1f/9+zZw509bI/bvVq1erRo0auummmwpdAwAAAAAAAEDpQKMLKEGWLl2qkJAQhYSEqGXLltq4caM+++wztW/f/rLzK1eurIkTJ+rf//63goKCFBcXJ19fX61atUrdunVT7dq1NXbsWL3yyivq2rWrJGnYsGGqU6eOoqKiVKlSpUtWQV2vV199VdHR0brtttsUExOjNm3aqF69epfcg+vvnJycNGTIEH344Yd2x7/44gs1b95c/f6vvTsEiSyKwgB8VgarBoNgsAn6BIUBwehgVutiGRCboFNsdsExGBQM4mB5RsVmGhAMguMYDArCYHGaybybdmFX3N1xx5En35fvPffwXvy593z9GiMjI7G6uvrqLaW5ubnY2tqKcrkcSZLE7u5u7O/v//Lt/rVeLpeLNE0jSZIoFAov5md1wvr6eiwvL0c+n49msxknJyc/b/ANDw/Hzs5ObG9vx9jYWFxcXPwM9H5o13/u6uqKw8PDuLy8jNHR0SiVSrGxsdFynaGhoTg9PY3r6+uYmJiIycnJOD4+jlwu13KtmZmZKJVKsbS0FOPj43F+fh5ra2sv1qVpGouLiy3XBwAAAACy48u33we9ALTR8/NzDAwMxObmZiwsLLy6rtlsRpIkUavVYnBwsIMdvl2lUolKpRLVarVtNavVakxNTcXT01P09va2re6fzisWi9FoNN79rE66ubmJQqEQd3d30dPT89HtAAAAAADvxI0uoK2urq4iTdO4v7+PWq0W8/PzERExOzv7x339/f2xt7cXDw8PnWiTT+7x8TEODg6EXAAAAADwybX+ZhTAX5TL5bi9vY3u7u7I5/NxdnYWfX19f933YwYV/K/p6emPbgEAAAAA6ABPFwK8Ub1ej3q9HsVi8aNbebNGoxFHR0exsrLy0a0AAAAAALRM0AUAAAAAAEAmmdEFAAAAAABAJgm6AAAAAAAAyCRBFwAAAAAAAJkk6AIAAAAAACCTBF0AAAAAAABkkqALAAAAAACATBJ0AQAAAAAAkEmCLgAAAAAAADLpOxDjK0SVUHpJAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Build and run HHL\n", + "hhl_circ2 = hhl_circuit(A2, b2, num_clock_qubits=2)\n", + "\n", + "print(\"Running HHL Algorithm for Example 2...\")\n", + "task2 = run_hhl(hhl_circ2, device, shots=10000)\n", + "print(\"HHL Run Complete!\")\n", + "\n", + "results2 = get_hhl_results(\n", + " task2, A2, b2, num_clock_qubits=2, verbose=True\n", + ")\n", + "\n", + "plot_hhl_comparison(results2, \"Example 2: A = [[2,1],[1,2]], b = [1/√2, 1/√2]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 3: Effect of the Condition Number\n", + "\n", + "The condition number $\\kappa = \\lambda_{\\max}/\\lambda_{\\min}$ is a key parameter affecting HHL performance.\n", + "Let's explore how different condition numbers affect the success probability and solution quality.\n", + "\n", + "We'll use the matrix:\n", + "$$A = \\begin{pmatrix} \\lambda_1 & 0 \\\\ 0 & \\lambda_2 \\end{pmatrix}$$\n", + "\n", + "with $\\lambda_1 = 1$ and varying $\\lambda_2$ to change the condition number." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Condition Number Analysis\n", + "============================================================\n", + "κ = 1: Fidelity = 0.9999, Success Prob = 0.8049\n", + "κ = 2: Fidelity = 0.5256, Success Prob = 0.4306\n", + "κ = 3: Fidelity = 0.2032, Success Prob = 0.3694\n", + "κ = 4: Fidelity = 0.1002, Success Prob = 0.2024\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Test with different condition numbers\n", + "b_test = np.array([1/np.sqrt(2), 1/np.sqrt(2)], dtype=complex)\n", + "condition_numbers = [1, 2, 3, 4]\n", + "fidelities = []\n", + "success_probs = []\n", + "\n", + "print(\"Condition Number Analysis\")\n", + "print(\"=\" * 60)\n", + "\n", + "for kappa in condition_numbers:\n", + " A_test = np.array([[1, 0], [0, kappa]], dtype=complex)\n", + " circ = hhl_circuit(A_test, b_test, num_clock_qubits=2)\n", + " task = run_hhl(circ, device, shots=10000)\n", + " results = get_hhl_results(task, A_test, b_test, num_clock_qubits=2)\n", + " \n", + " fidelities.append(results['fidelity'])\n", + " success_probs.append(results['success_probability'])\n", + " \n", + " print(f\"κ = {kappa}: Fidelity = {results['fidelity']:.4f}, \"\n", + " f\"Success Prob = {results['success_probability']:.4f}\")\n", + "\n", + "# Plot\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))\n", + "\n", + "ax1.plot(condition_numbers, fidelities, 'o-', color='coral', linewidth=2, markersize=8)\n", + "ax1.set_xlabel('Condition Number κ')\n", + "ax1.set_ylabel('Fidelity')\n", + "ax1.set_title('Solution Fidelity vs Condition Number')\n", + "ax1.grid(True, alpha=0.3)\n", + "ax1.set_ylim([0, 1.05])\n", + "\n", + "ax2.plot(condition_numbers, success_probs, 's-', color='steelblue', linewidth=2, markersize=8)\n", + "ax2.set_xlabel('Condition Number κ')\n", + "ax2.set_ylabel('Success Probability')\n", + "ax2.set_title('Post-Selection Success vs Condition Number')\n", + "ax2.grid(True, alpha=0.3)\n", + "ax2.set_ylim([0, 1.05])\n", + "\n", + "plt.suptitle('Effect of Condition Number on HHL Performance', fontsize=14, fontweight='bold')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Understanding the Circuit Components\n", + "\n", + "Let's walk through each component of the HHL circuit in more detail.\n", + "\n", + "### 1. State Preparation\n", + "\n", + "The vector $\\vec{b}$ is encoded as a quantum state $|b\\rangle$ on the input qubit. For a 2-element vector $\\vec{b} = (b_0, b_1)^T$, this is done using an $R_y$ rotation:\n", + "\n", + "$$|b\\rangle = \\cos(\\theta/2)|0\\rangle + \\sin(\\theta/2)|1\\rangle$$\n", + "\n", + "where $\\theta = 2\\arccos(b_0)$ for real vectors.\n", + "\n", + "### 2. Quantum Phase Estimation (QPE)\n", + "\n", + "QPE decomposes $|b\\rangle$ in the eigenbasis of $A$ and estimates eigenvalues. It uses:\n", + "- Hadamard gates on clock qubits to create superposition\n", + "- Controlled $U^{2^k} = e^{iAt \\cdot 2^k}$ operations (Hamiltonian simulation)\n", + "- Inverse QFT on the clock register\n", + "\n", + "After QPE, the state is approximately:\n", + "$$\\sum_j \\beta_j |u_j\\rangle|\\tilde{\\lambda}_j\\rangle$$\n", + "\n", + "### 3. Controlled Rotation\n", + "\n", + "For each eigenvalue $\\lambda_j$ stored in the clock register, we perform a controlled $R_y$ rotation on the ancilla qubit with angle $\\theta_j = 2\\arcsin(C/\\lambda_j)$:\n", + "\n", + "$$|\\tilde{\\lambda}_j\\rangle|0\\rangle_a \\rightarrow |\\tilde{\\lambda}_j\\rangle\\left(\\sqrt{1 - \\frac{C^2}{\\lambda_j^2}}|0\\rangle_a + \\frac{C}{\\lambda_j}|1\\rangle_a\\right)$$\n", + "\n", + "### 4. Inverse QPE\n", + "\n", + "The inverse QPE uncomputes the clock register, returning it to $|0\\rangle^{\\otimes n}$.\n", + "After post-selecting on the ancilla measuring $|1\\rangle$, the input qubit is in the state $|x\\rangle \\propto A^{-1}|b\\rangle$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 4: Varying the Input Vector\n", + "\n", + "Let's fix the matrix and explore how different input vectors $\\vec{b}$ affect the solution." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "A4 = np.array([[2, 1], [1, 2]], dtype=complex)\n", + "\n", + "# Different b vectors (all normalized)\n", + "test_vectors = [\n", + " (np.array([1, 0], dtype=complex), \"|0⟩\"),\n", + " (np.array([0, 1], dtype=complex), \"|1⟩\"),\n", + " (np.array([1/np.sqrt(2), 1/np.sqrt(2)], dtype=complex), \"|+⟩\"),\n", + " (np.array([1/np.sqrt(2), -1/np.sqrt(2)], dtype=complex), \"|−⟩\"),\n", + "]\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(14, 10))\n", + "\n", + "for idx, (b_vec, label) in enumerate(test_vectors):\n", + " ax = axes[idx // 2][idx % 2]\n", + " \n", + " circ = hhl_circuit(A4, b_vec, num_clock_qubits=2)\n", + " task = run_hhl(circ, device, shots=10000)\n", + " results = get_hhl_results(task, A4, b_vec, num_clock_qubits=2)\n", + " \n", + " quantum_probs = [\n", + " results['solution_state_probabilities'].get('0', 0),\n", + " results['solution_state_probabilities'].get('1', 0),\n", + " ]\n", + " classical_probs = list(results['classical_probabilities'])\n", + " \n", + " x = np.arange(2)\n", + " width = 0.35\n", + " ax.bar(x - width/2, quantum_probs, width, label='Quantum', color='coral', alpha=0.8)\n", + " ax.bar(x + width/2, classical_probs, width, label='Classical', color='steelblue', alpha=0.8)\n", + " ax.set_xlabel('Component')\n", + " ax.set_ylabel('Probability |x_i|²')\n", + " ax.set_title(f'b = {label} (F={results[\"fidelity\"]:.3f})')\n", + " ax.set_xticks(x)\n", + " ax.set_xticklabels(['|0⟩', '|1⟩'])\n", + " ax.legend()\n", + " ax.set_ylim([0, 1.1])\n", + "\n", + "plt.suptitle('HHL Solutions for A = [[2,1],[1,2]] with Different Input Vectors',\n", + " fontsize=14, fontweight='bold')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Practical Considerations and Limitations\n", + "\n", + "### When Does HHL Provide a Speedup?\n", + "\n", + "The HHL algorithm provides an exponential speedup when:\n", + "1. The matrix $A$ is **sparse** (few non-zero entries per row)\n", + "2. The matrix is **well-conditioned** (small condition number $\\kappa$)\n", + "3. Only **summary statistics** of the solution are needed (not the full vector)\n", + "4. The state $|b\\rangle$ can be **efficiently prepared**\n", + "\n", + "### Current Limitations\n", + "\n", + "- **Qubit count**: For an $N \\times N$ system, the algorithm requires $O(\\log N)$ qubits for the input register plus additional qubits for QPE and ancilla\n", + "- **Circuit depth**: The QPE and Hamiltonian simulation steps can require deep circuits\n", + "- **Post-selection**: The success probability depends on the condition number, requiring $O(\\kappa)$ repetitions\n", + "- **Noise**: Current NISQ devices have limited coherence times and gate fidelities\n", + "\n", + "### Applications\n", + "\n", + "Despite these limitations, HHL has been proposed for many applications:\n", + "- **Machine Learning**: Linear regression, support vector machines, principal component analysis\n", + "- **Computational Finance**: Portfolio optimization, options pricing via PDEs\n", + "- **Scientific Computing**: Solving differential equations, finite element methods\n", + "- **Quantum Chemistry**: Solving coupled cluster equations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## [Optional] Run on a QPU or Managed Simulator\n", + "\n", + "The following cells demonstrate how to run the HHL algorithm on an Amazon Braket managed simulator or QPU.\n", + "\n", + "Note: Running on a QPU will incur costs. Use the [Braket cost tracker](https://docs.aws.amazon.com/braket/latest/developerguide/braket-pricing.html#real-time-cost-tracking) to estimate costs." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Use Braket SDK Cost Tracking to estimate the cost to run this example\n", + "# from braket.tracking import Tracker\n", + "\n", + "# tracker = Tracker().start()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# from braket.aws import AwsDevice\n", + "\n", + "# # Define the system\n", + "# A_qpu = np.array([[1, 0], [0, 2]], dtype=complex)\n", + "# b_qpu = np.array([1/np.sqrt(2), 1/np.sqrt(2)], dtype=complex)\n", + "\n", + "# # Build the circuit\n", + "# hhl_circ_qpu = hhl_circuit(A_qpu, b_qpu, num_clock_qubits=2)\n", + "\n", + "# # Run on managed simulator (uncomment the QPU line to run on a real device)\n", + "# # qpu = AwsDevice(\"arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-2\")\n", + "# managed_device = AwsDevice(\"arn:aws:braket:::device/quantum-simulator/amazon/sv1\")\n", + "\n", + "# print(\"Running HHL on managed simulator...\")\n", + "# task_qpu = run_hhl(hhl_circ_qpu, managed_device, shots=10000)\n", + "# print(\"HHL Run Complete!\")\n", + "\n", + "# results_qpu = get_hhl_results(\n", + "# task_qpu, A_qpu, b_qpu, num_clock_qubits=2, verbose=True\n", + "# )\n", + "\n", + "# plot_hhl_comparison(results_qpu, \"HHL on Managed Simulator\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# print(\"Task Summary\")\n", + "# print(f\"{tracker.quantum_tasks_statistics()} \\n\")\n", + "# print(\n", + "# f\"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost():.2f} USD\"\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.2" + }, + "vscode": { + "interpreter": { + "hash": "5904cb9a2089448a2e1aeb5d493d227c9de33e591d7c07e4016fb81e71061a5d" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/src/braket/experimental/algorithms/hhl/__init__.py b/src/braket/experimental/algorithms/hhl/__init__.py new file mode 100644 index 00000000..c9c62c45 --- /dev/null +++ b/src/braket/experimental/algorithms/hhl/__init__.py @@ -0,0 +1,18 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). You +# may not use this file except in compliance with the License. A copy of +# the License is located at +# +# http://aws.amazon.com/apache2.0/ +# +# or in the "license" file accompanying this file. This file is +# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF +# ANY KIND, either express or implied. See the License for the specific +# language governing permissions and limitations under the License. + +from braket.experimental.algorithms.hhl.hhl import ( # noqa: F401,E501 + hhl_circuit, + run_hhl, + get_hhl_results, +) diff --git a/src/braket/experimental/algorithms/hhl/hhl.md b/src/braket/experimental/algorithms/hhl/hhl.md new file mode 100644 index 00000000..c28f4781 --- /dev/null +++ b/src/braket/experimental/algorithms/hhl/hhl.md @@ -0,0 +1,7 @@ +The Harrow-Hassidim-Lloyd (HHL) algorithm is a quantum algorithm for solving systems of linear equations of the form Ax = b. Given an N×N Hermitian matrix A and a unit vector b, the algorithm produces a quantum state |x⟩ whose amplitudes encode the solution vector x = A⁻¹b. The HHL algorithm is one of the fundamental quantum algorithms expected to provide an exponential speedup over classical methods: for sparse, well-conditioned matrices, HHL runs in O(log(N) κ²) time versus O(Nκ) classically, where κ is the condition number of A. Applications include machine learning, computational finance, solving differential equations, and quantum chemistry. + + diff --git a/src/braket/experimental/algorithms/hhl/hhl.py b/src/braket/experimental/algorithms/hhl/hhl.py new file mode 100644 index 00000000..67ea7560 --- /dev/null +++ b/src/braket/experimental/algorithms/hhl/hhl.py @@ -0,0 +1,718 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). You +# may not use this file except in compliance with the License. A copy of +# the License is located at +# +# http://aws.amazon.com/apache2.0/ +# +# or in the "license" file accompanying this file. This file is +# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF +# ANY KIND, either express or implied. See the License for the specific +# language governing permissions and limitations under the License. + +"""Harrow-Hassidim-Lloyd (HHL) Algorithm for Solving Linear Systems of Equations. + +The HHL algorithm is a quantum algorithm for solving systems of linear equations +of the form Ax = b. Given an N x N Hermitian matrix A and a unit vector b, the +algorithm produces a quantum state |x> proportional to A^{-1}|b>. + +The algorithm achieves an exponential speedup over classical methods for certain +classes of problems (sparse, well-conditioned matrices) when only summary statistics +of the solution are needed (e.g., for some operator M). + +This implementation provides a simplified version of HHL suitable for small systems +(2x2 matrices), illustrating the core concepts: +1. State preparation: encode |b> into a quantum state +2. Quantum Phase Estimation (QPE): decompose |b> in the eigenbasis of A +3. Controlled rotation: apply the eigenvalue inversion C/lambda +4. Inverse QPE: uncompute the eigenvalue register +5. Measurement: post-select on the ancilla qubit + +References: + [1] A. W. Harrow, A. Hassidim, S. Lloyd, "Quantum algorithm for linear systems + of equations", Phys. Rev. Lett. 103, 150502 (2009). arXiv:0811.3171 + [2] Wikipedia: https://en.wikipedia.org/wiki/HHL_algorithm +""" + +import math +from typing import Any, Dict, List, Optional, Tuple + +import numpy as np + +from braket.circuits import Circuit, Instruction, circuit +from braket.circuits.gates import Unitary +from braket.circuits.qubit_set import QubitSetInput +from braket.devices import Device +from braket.tasks import QuantumTask + + +def _validate_hermitian_2x2(matrix: np.ndarray) -> None: + """Validate that the input is a 2x2 Hermitian matrix. + + Args: + matrix (np.ndarray): The matrix to validate. + + Raises: + ValueError: If the matrix is not 2x2 or not Hermitian. + """ + if matrix.shape != (2, 2): + raise ValueError(f"Matrix must be 2x2, got shape {matrix.shape}") + if not np.allclose(matrix, matrix.conj().T, atol=1e-10): + raise ValueError("Matrix must be Hermitian (A = A†)") + + +def _compute_eigendecomposition(matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: + """Compute eigenvalues and eigenvectors of a Hermitian matrix. + + Args: + matrix (np.ndarray): A Hermitian matrix. + + Returns: + Tuple[np.ndarray, np.ndarray]: eigenvalues and eigenvectors. + """ + eigenvalues, eigenvectors = np.linalg.eigh(matrix) + return eigenvalues, eigenvectors + + +def _compute_rotation_angles( + eigenvalues: np.ndarray, + num_clock_qubits: int, + scaling_factor: float, +) -> Dict[int, float]: + """Compute the rotation angles for the controlled rotation step. + + For each eigenvalue lambda_j, the rotation angle is: + theta_j = 2 * arcsin(C / lambda_j) + + where C is a normalization constant chosen so that C/lambda_j <= 1 + for all eigenvalues. + + Args: + eigenvalues (np.ndarray): Eigenvalues of the matrix A. + num_clock_qubits (int): Number of clock qubits in QPE. + scaling_factor (float): Scaling factor for eigenvalue encoding. + + Returns: + Dict[int, float]: Mapping from clock register state (int) to rotation angle. + """ + # The QPE maps eigenvalues to phases: lambda_j -> 2*pi*phi_j + # For a 2x2 system with 2 clock qubits, we have 4 possible states (0,1,2,3). + # The eigenvalue lambda_j is encoded as phi_j = lambda_j * t0 / (2*pi) + + num_states = 2**num_clock_qubits + rotation_angles = {} + + for eigenval in eigenvalues: + # Map eigenvalue to the corresponding clock register integer + # Phase = eigenval * scaling_factor / (2 * pi) + phase = (eigenval * scaling_factor) / (2 * np.pi) + # Wrap to [0, 1) + phase = phase % 1.0 + clock_state = int(round(phase * num_states)) % num_states + + if clock_state == 0: + continue # Skip the zero eigenvalue case + + # C / lambda relationship + # Reconstruct the eigenvalue from the clock_state + reconstructed_eigenval = (2 * np.pi * clock_state) / (scaling_factor * num_states) + + # Rotation angle: theta = 2 * arcsin(C / lambda) + # C is chosen as the minimum eigenvalue magnitude (in absolute value) + c_value = min(abs(ev) for ev in eigenvalues if abs(ev) > 1e-10) + ratio = c_value / abs(reconstructed_eigenval) + ratio = min(ratio, 1.0) # Clamp to prevent arcsin domain errors + + theta = 2 * np.arcsin(ratio) + rotation_angles[clock_state] = theta + + return rotation_angles + + +@circuit.subroutine(register=True) +def _qpe_for_hhl( + clock_qubits: QubitSetInput, + input_qubit: int, + matrix: np.ndarray, + scaling_factor: float, +) -> Circuit: + """Quantum Phase Estimation subroutine for HHL. + + Applies the QPE circuit to estimate eigenvalues of the Hermitian matrix A. + Uses Hamiltonian simulation via e^{iAt} for a 2x2 system. + + Args: + clock_qubits (QubitSetInput): Clock register qubits. + input_qubit (int): The input qubit encoding |b>. + matrix (np.ndarray): The 2x2 Hermitian matrix A. + scaling_factor (float): Time parameter for Hamiltonian simulation. + + Returns: + Circuit: QPE circuit. + """ + circ = Circuit() + num_clock = len(clock_qubits) + + # Apply Hadamard to clock qubits + circ.h(clock_qubits) + + # Apply controlled-U^(2^k) operations + # U = e^{iA * scaling_factor / num_states} + # For clock qubit k, apply U^(2^k) + for k, clock_qubit in enumerate(reversed(clock_qubits)): + power = 2**k + # Compute U^power = e^{i * A * scaling_factor * power / (2^num_clock)} + t = scaling_factor * power / (2**num_clock) + unitary = _compute_hamiltonian_simulation(matrix, t) + + # Apply controlled unitary + # Construct explicit Controlled-Unitary (CU) to workaround simulator limitations + # with Instruction(..., control=...) + cu_matrix = _construct_controlled_unitary_matrix(unitary) + + # Apply CU to [clock_qubit, input_qubit] + # The control qubit is the first qubit in the 'targets' list + circ.unitary(matrix=cu_matrix, targets=[clock_qubit, input_qubit], display_name="CU") + + # Apply inverse QFT to clock register + circ = _add_inverse_qft(circ, clock_qubits) + + return circ + + +def _compute_hamiltonian_simulation(matrix: np.ndarray, t: float) -> np.ndarray: + """Compute the unitary e^{iAt} for the Hamiltonian simulation. + + Args: + matrix (np.ndarray): The Hermitian matrix A. + t (float): The time parameter. + + Returns: + np.ndarray: The unitary matrix e^{iAt}. + """ + # Use eigendecomposition for exact computation + eigenvalues, eigenvectors = np.linalg.eigh(matrix) + # e^{iAt} = V * diag(e^{i*lambda_j*t}) * V† + phases = np.exp(1j * eigenvalues * t) + unitary = eigenvectors @ np.diag(phases) @ eigenvectors.conj().T + return unitary + + +def _construct_controlled_unitary_matrix(unitary: np.ndarray) -> np.ndarray: + """Construct the Controlled-U matrix from U for a single control and single target. + + Args: + unitary (np.ndarray): The 2x2 unitary matrix U. + + Returns: + np.ndarray: The 4x4 Controlled-U matrix. + """ + if unitary.shape != (2, 2): + raise ValueError("Only 2x2 unitaries supported for explicit control construction") + + # Projector onto |0> (P0) and |1> (P1) for control qubit + p0 = np.array([[1, 0], [0, 0]], dtype=complex) + p1 = np.array([[0, 0], [0, 1]], dtype=complex) + + # Target identity + eye = np.eye(2, dtype=complex) + + # CU = P0 (x) I + P1 (x) U + # This assumes the control qubit is the first qubit in the register + return np.kron(p0, eye) + np.kron(p1, unitary) + + +def _add_inverse_qft(circ: Circuit, qubits: QubitSetInput) -> Circuit: + """Add inverse Quantum Fourier Transform to the circuit. + + Args: + circ (Circuit): The circuit to add inverse QFT to. + qubits (QubitSetInput): The qubits to apply inverse QFT on. + + Returns: + Circuit: Circuit with inverse QFT appended. + """ + num_qubits = len(qubits) + + # SWAP to reverse qubit order + for i in range(math.floor(num_qubits / 2)): + circ.swap(qubits[i], qubits[-i - 1]) + + # Apply inverse QFT gates + for k in reversed(range(num_qubits)): + for j in reversed(range(1, num_qubits - k)): + angle = -2 * math.pi / (2 ** (j + 1)) + circ.cphaseshift(qubits[k + j], qubits[k], angle) + circ.h(qubits[k]) + + return circ + + +def _add_qft(circ: Circuit, qubits: QubitSetInput) -> Circuit: + """Add forward Quantum Fourier Transform to the circuit. + + Args: + circ (Circuit): The circuit to add QFT to. + qubits (QubitSetInput): The qubits to apply QFT on. + + Returns: + Circuit: Circuit with QFT appended. + """ + num_qubits = len(qubits) + + for k in range(num_qubits): + circ.h(qubits[k]) + for j in range(1, num_qubits - k): + angle = 2 * math.pi / (2 ** (j + 1)) + circ.cphaseshift(qubits[k + j], qubits[k], angle) + + # SWAP to reverse qubit order + for i in range(math.floor(num_qubits / 2)): + circ.swap(qubits[i], qubits[-i - 1]) + + return circ + + +@circuit.subroutine(register=True) +def _controlled_rotation( + clock_qubits: QubitSetInput, + ancilla_qubit: int, + eigenvalues: np.ndarray, + num_clock_qubits: int, + scaling_factor: float, +) -> Circuit: + """Apply controlled rotations to encode C/lambda into the ancilla qubit. + + For each eigenvalue lambda_j, performs a controlled-Ry rotation on the + ancilla qubit conditioned on the clock register containing |lambda_j>. + After rotation, the ancilla is in state: + sqrt(1 - C^2/lambda_j^2)|0> + C/lambda_j|1> + + Measuring |1> on the ancilla post-selects the desired solution. + + Args: + clock_qubits (QubitSetInput): Clock register qubits. + ancilla_qubit (int): The ancilla qubit for post-selection. + eigenvalues (np.ndarray): Eigenvalues of matrix A. + num_clock_qubits (int): Number of clock qubits. + scaling_factor (float): Scaling factor for eigenvalue encoding. + + Returns: + Circuit: Circuit with controlled rotations. + """ + circ = Circuit() + num_states = 2**num_clock_qubits + + # Compute the constant C (normalization) + abs_eigenvalues = np.abs(eigenvalues[np.abs(eigenvalues) > 1e-10]) + if len(abs_eigenvalues) == 0: + return circ + c_value = np.min(abs_eigenvalues) + + # For each possible clock register state, apply a controlled rotation + for clock_state in range(1, num_states): + # Reconstruct the eigenvalue from the clock state + reconstructed_eigenval = (2 * np.pi * clock_state) / (scaling_factor * num_states) + + # Compute rotation angle + ratio = c_value / abs(reconstructed_eigenval) + ratio = min(ratio, 1.0) + theta = 2 * np.arcsin(ratio) + + if abs(theta) < 1e-12: + continue + + # Apply multi-controlled Ry rotation + # Condition on clock register being in state |clock_state> + # Convert clock_state to binary to determine which clock qubits are |0> vs |1> + binary_rep = format(clock_state, f"0{num_clock_qubits}b") + + # Apply X gates to select the correct clock state + for i, bit in enumerate(binary_rep): + if bit == "0": + circ.x(clock_qubits[i]) + + # Apply multi-controlled Ry + # For 2 clock qubits, this is a Toffoli-like construction + if num_clock_qubits == 1: + # Simple controlled-Ry + _add_controlled_ry(circ, clock_qubits[0], ancilla_qubit, theta) + elif num_clock_qubits == 2: + # Use both clock qubits as controls + _add_doubly_controlled_ry( + circ, clock_qubits[0], clock_qubits[1], ancilla_qubit, theta + ) + else: + # General case: use multi-controlled approach + _add_multi_controlled_ry(circ, clock_qubits, ancilla_qubit, theta) + + # Undo X gates + for i, bit in enumerate(binary_rep): + if bit == "0": + circ.x(clock_qubits[i]) + + return circ + + +def _add_controlled_ry( + circ: Circuit, control: int, target: int, theta: float +) -> None: + """Add a controlled-Ry gate to the circuit. + + Decomposition: C-Ry(theta) = Ry(theta/2) . CNOT . Ry(-theta/2) . CNOT + + Args: + circ (Circuit): The circuit. + control (int): Control qubit. + target (int): Target qubit. + theta (float): Rotation angle. + """ + circ.ry(target, theta / 2) + circ.cnot(control, target) + circ.ry(target, -theta / 2) + circ.cnot(control, target) + + +def _add_doubly_controlled_ry( + circ: Circuit, control1: int, control2: int, target: int, theta: float +) -> None: + """Add a doubly-controlled Ry gate (CCRy) to the circuit. + + Uses the decomposition: CCRy(theta) via two CRy(theta/2) and a CNOT. + + Args: + circ (Circuit): The circuit. + control1 (int): First control qubit. + control2 (int): Second control qubit. + target (int): Target qubit. + theta (float): Rotation angle. + """ + # Decompose CC-Ry using standard decomposition + _add_controlled_ry(circ, control2, target, theta / 2) + circ.cnot(control1, control2) + _add_controlled_ry(circ, control2, target, -theta / 2) + circ.cnot(control1, control2) + _add_controlled_ry(circ, control1, target, theta / 2) + + +def _add_multi_controlled_ry( + circ: Circuit, controls: QubitSetInput, target: int, theta: float +) -> None: + """Add a multi-controlled Ry gate to the circuit. + + For simplicity, this uses a recursive decomposition. + + Args: + circ (Circuit): The circuit. + controls (QubitSetInput): Control qubits. + target (int): Target qubit. + theta (float): Rotation angle. + """ + if len(controls) == 1: + _add_controlled_ry(circ, controls[0], target, theta) + elif len(controls) == 2: + _add_doubly_controlled_ry(circ, controls[0], controls[1], target, theta) + else: + # Recursive decomposition for more controls + _add_controlled_ry(circ, controls[-1], target, theta / 2) + # Apply multi-controlled NOT with remaining controls + for i in range(len(controls) - 1): + circ.cnot(controls[i], controls[-1]) + _add_controlled_ry(circ, controls[-1], target, -theta / 2) + for i in range(len(controls) - 1): + circ.cnot(controls[i], controls[-1]) + _add_multi_controlled_ry(circ, controls[:-1], target, theta / 2) + + +@circuit.subroutine(register=True) +def _inverse_qpe_for_hhl( + clock_qubits: QubitSetInput, + input_qubit: int, + matrix: np.ndarray, + scaling_factor: float, +) -> Circuit: + """Inverse QPE subroutine to uncompute the clock register. + + Args: + clock_qubits (QubitSetInput): Clock register qubits. + input_qubit (int): The input qubit. + matrix (np.ndarray): The 2x2 Hermitian matrix A. + scaling_factor (float): Time parameter for Hamiltonian simulation. + + Returns: + Circuit: Inverse QPE circuit. + """ + circ = Circuit() + num_clock = len(clock_qubits) + + # Apply forward QFT to clock register (inverse of inverse QFT) + circ = _add_qft(circ, clock_qubits) + + # Apply inverse controlled-U^(2^k) operations (in reverse order) + for k, clock_qubit in enumerate(reversed(clock_qubits)): + power = 2**k + t = scaling_factor * power / (2**num_clock) + # Inverse unitary: (e^{iAt})† = e^{-iAt} + unitary_inv = _compute_hamiltonian_simulation(matrix, -t) + + # Construct explicit Controlled-Unitary + cu_matrix_inv = _construct_controlled_unitary_matrix(unitary_inv) + + # Apply CUinv + circ.unitary(matrix=cu_matrix_inv, targets=[clock_qubit, input_qubit], display_name="CU†") + + # Apply Hadamard to clock qubits + circ.h(clock_qubits) + + return circ + + +def _prepare_state_b(circ: Circuit, input_qubit: int, b_vector: np.ndarray) -> Circuit: + """Prepare the quantum state |b> on the input qubit. + + For a 2-element vector b = [b0, b1], prepares the state: + |b> = b0|0> + b1|1> + + The vector must be normalized (|b0|^2 + |b1|^2 = 1). + + Args: + circ (Circuit): The circuit to add state preparation to. + input_qubit (int): The qubit to prepare the state on. + b_vector (np.ndarray): The normalized 2-element vector b. + + Returns: + Circuit: Circuit with state preparation. + + Raises: + ValueError: If b_vector is not a normalized 2-element vector. + """ + if len(b_vector) != 2: + raise ValueError(f"b_vector must have 2 elements, got {len(b_vector)}") + + norm = np.linalg.norm(b_vector) + if not np.isclose(norm, 1.0, atol=1e-10): + raise ValueError(f"b_vector must be normalized, got norm={norm}") + + # Compute the rotation angle to prepare |b> = cos(theta/2)|0> + sin(theta/2)|1> + # For real b_vector: b0 = cos(theta/2), b1 = sin(theta/2) + theta = 2 * np.arccos(np.clip(np.real(b_vector[0]), -1, 1)) + + # Handle the phase if b_vector has complex components + if np.isreal(b_vector).all(): + if np.real(b_vector[1]) < 0: + theta = -theta + circ.ry(input_qubit, theta) + else: + # General state preparation for complex amplitudes + # |b> = cos(theta/2)|0> + e^{i*phi}*sin(theta/2)|1> + phi = np.angle(b_vector[1]) - np.angle(b_vector[0]) + circ.ry(input_qubit, theta) + circ.rz(input_qubit, phi) + + return circ + + +def hhl_circuit( + matrix: np.ndarray, + b_vector: np.ndarray, + num_clock_qubits: int = 2, + scaling_factor: Optional[float] = None, +) -> Circuit: + """Construct the full HHL circuit for solving Ax = b. + + The circuit uses: + - 1 input qubit for encoding |b> + - num_clock_qubits clock qubits for QPE + - 1 ancilla qubit for eigenvalue inversion (post-selection) + + Qubit layout: + - Clock qubits: 0 to num_clock_qubits - 1 + - Input qubit: num_clock_qubits + - Ancilla qubit: num_clock_qubits + 1 + + Args: + matrix (np.ndarray): A 2x2 Hermitian matrix A. + b_vector (np.ndarray): A normalized 2-element vector b. + num_clock_qubits (int): Number of clock qubits for QPE (default: 2). + scaling_factor (Optional[float]): Scaling factor for Hamiltonian simulation. + If None, automatically computed from the eigenvalues. + + Returns: + Circuit: The complete HHL circuit. + + Raises: + ValueError: If matrix is not 2x2 Hermitian or b_vector is invalid. + """ + _validate_hermitian_2x2(matrix) + + # Normalize b_vector + b_norm = np.linalg.norm(b_vector) + if b_norm < 1e-10: + raise ValueError("b_vector must be non-zero") + b_normalized = b_vector / b_norm + + # Compute eigenvalues for scaling + eigenvalues, _ = _compute_eigendecomposition(matrix) + + # Determine scaling factor if not provided + if scaling_factor is None: + # Choose scaling_factor so eigenvalues map to distinct QPE states + max_eigenval = max(abs(ev) for ev in eigenvalues) + num_states = 2**num_clock_qubits + # Scale so that the largest eigenvalue maps close to the Nyquist limit + scaling_factor = 2 * np.pi * (num_states - 1) / (max_eigenval * num_states) + + # Define qubit registers + clock_qubits = list(range(num_clock_qubits)) + input_qubit = num_clock_qubits + ancilla_qubit = num_clock_qubits + 1 + + # Build the circuit + circ = Circuit() + + # Step 1: State preparation - encode |b> on the input qubit + circ = _prepare_state_b(circ, input_qubit, b_normalized) + + # Step 2: Quantum Phase Estimation + qpe_circ = _qpe_for_hhl(clock_qubits, input_qubit, matrix, scaling_factor) + circ.add(qpe_circ) + + # Step 3: Controlled rotation (eigenvalue inversion) + rotation_circ = _controlled_rotation( + clock_qubits, ancilla_qubit, eigenvalues, num_clock_qubits, scaling_factor + ) + circ.add(rotation_circ) + + # Step 4: Inverse QPE (uncompute clock register) + inv_qpe_circ = _inverse_qpe_for_hhl(clock_qubits, input_qubit, matrix, scaling_factor) + circ.add(inv_qpe_circ) + + return circ + + +def run_hhl( + circuit: Circuit, + device: Device, + shots: int = 1000, +) -> QuantumTask: + """Run the HHL circuit on the specified device. + + Args: + circuit (Circuit): The HHL circuit to run. + device (Device): Braket device backend. + shots (int): Number of measurement shots (default: 1000). + + Returns: + QuantumTask: Task from running HHL. + """ + task = device.run(circuit, shots=shots) + return task + + +def get_hhl_results( + task: QuantumTask, + matrix: np.ndarray, + b_vector: np.ndarray, + num_clock_qubits: int = 2, + verbose: bool = False, +) -> Dict[str, Any]: + """Post-process results from an HHL run. + + Extracts the solution state by post-selecting on the ancilla qubit + measuring |1>. The solution |x> is proportional to A^{-1}|b>. + + Args: + task (QuantumTask): The task containing HHL results. + matrix (np.ndarray): The original 2x2 matrix A. + b_vector (np.ndarray): The original vector b. + num_clock_qubits (int): Number of clock qubits used (default: 2). + verbose (bool): If True, prints detailed results (default: False). + + Returns: + Dict[str, Any]: Dictionary containing: + - measurement_counts: Raw measurement counts + - post_selected_counts: Counts post-selected on ancilla=1 + - solution_state_probabilities: Probabilities of solution components + - classical_solution: The exact classical solution for comparison + - fidelity: Fidelity between quantum and classical solutions + - success_probability: Probability of ancilla measuring |1> + """ + result = task.result() + measurement_counts = result.measurement_counts + total_num_qubits = num_clock_qubits + 2 # clock + input + ancilla + + # Compute classical solution for comparison + b_norm = np.linalg.norm(b_vector) + b_normalized = b_vector / b_norm + classical_solution = np.linalg.solve(matrix, b_normalized) + classical_solution_normalized = classical_solution / np.linalg.norm(classical_solution) + + # Post-select: keep only measurements where ancilla (last qubit) = 1 + # and clock qubits are all 0 (indicating successful uncomputation) + post_selected_counts = {} + total_shots = sum(measurement_counts.values()) + success_shots = 0 + + for bitstring, count in measurement_counts.items(): + # Bit ordering: clock_qubits | input_qubit | ancilla_qubit + ancilla_bit = bitstring[-1] # Last qubit is ancilla + clock_bits = bitstring[:num_clock_qubits] + + if ancilla_bit == "1" and all(b == "0" for b in clock_bits): + input_bit = bitstring[num_clock_qubits] + if input_bit in post_selected_counts: + post_selected_counts[input_bit] += count + else: + post_selected_counts[input_bit] = count + success_shots += count + + # Compute solution state probabilities from post-selected counts + solution_state_probs = {} + if success_shots > 0: + for state, count in post_selected_counts.items(): + solution_state_probs[state] = count / success_shots + else: + solution_state_probs = {"0": 0.0, "1": 0.0} + + success_probability = success_shots / total_shots if total_shots > 0 else 0.0 + + # Compute fidelity between quantum result and classical solution + quantum_probs = np.array([ + solution_state_probs.get("0", 0.0), + solution_state_probs.get("1", 0.0), + ]) + classical_probs = np.abs(classical_solution_normalized) ** 2 + + # Fidelity F = (sum sqrt(p_i * q_i))^2 + fidelity = (np.sum(np.sqrt(quantum_probs * classical_probs))) ** 2 + + aggregate_results = { + "measurement_counts": measurement_counts, + "post_selected_counts": post_selected_counts, + "solution_state_probabilities": solution_state_probs, + "classical_solution": classical_solution, + "classical_solution_normalized": classical_solution_normalized, + "classical_probabilities": classical_probs, + "fidelity": fidelity, + "success_probability": success_probability, + "total_shots": total_shots, + "success_shots": success_shots, + } + + if verbose: + print(f"Matrix A:\n{matrix}") + print(f"\nVector b: {b_vector}") + print(f"\nClassical solution x = A^(-1)b: {classical_solution}") + print( + f"Classical solution (normalized): {classical_solution_normalized}" + ) + print(f"Classical probabilities |x_i|^2: {classical_probs}") + print(f"\nTotal measurement shots: {total_shots}") + print(f"Post-selection success shots: {success_shots}") + print(f"Success probability: {success_probability:.4f}") + print(f"\nPost-selected counts: {post_selected_counts}") + print(f"Quantum solution probabilities: {solution_state_probs}") + print(f"\nFidelity with classical solution: {fidelity:.4f}") + + return aggregate_results diff --git a/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py new file mode 100644 index 00000000..6a0f01d2 --- /dev/null +++ b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py @@ -0,0 +1,211 @@ +# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"). You +# may not use this file except in compliance with the License. A copy of +# the License is located at +# +# http://aws.amazon.com/apache2.0/ +# +# or in the "license" file accompanying this file. This file is +# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF +# ANY KIND, either express or implied. See the License for the specific +# language governing permissions and limitations under the License. + +import numpy as np +import pytest +from braket.devices import LocalSimulator + +from braket.experimental.algorithms.hhl import hhl as hhl_module + + +# Test with a simple diagonal 2x2 matrix +def test_hhl_diagonal_matrix(): + """Test HHL with a diagonal Hermitian matrix.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) + + assert circ is not None + assert circ.qubit_count == 4 # 2 clock + 1 input + 1 ancilla + + +# Test with a symmetric 2x2 matrix +def test_hhl_symmetric_matrix(): + """Test HHL with a symmetric Hermitian matrix.""" + matrix = np.array([[2, 1], [1, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) + + assert circ is not None + assert circ.qubit_count == 4 + + +# Test validation: non-Hermitian matrix should raise error +def test_hhl_non_hermitian_raises(): + """Test that a non-Hermitian matrix raises ValueError.""" + matrix = np.array([[1, 2], [3, 4]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + with pytest.raises(ValueError, match="Hermitian"): + hhl_module.hhl_circuit(matrix, b_vector) + + +# Test validation: wrong-sized matrix should raise error +def test_hhl_wrong_size_matrix_raises(): + """Test that a non-2x2 matrix raises ValueError.""" + matrix = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=complex) + b_vector = np.array([1, 0, 0], dtype=complex) + + with pytest.raises(ValueError, match="2x2"): + hhl_module.hhl_circuit(matrix, b_vector) + + +# Test validation: unnormalized b_vector should raise error +def test_hhl_zero_b_vector_raises(): + """Test that a zero b_vector raises ValueError.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([0, 0], dtype=complex) + + with pytest.raises(ValueError, match="non-zero"): + hhl_module.hhl_circuit(matrix, b_vector) + + +# Test state preparation +def test_state_preparation_basic(): + """Test that state preparation works for basic vectors.""" + from braket.circuits import Circuit + + circ = Circuit() + b_vector = np.array([1, 0], dtype=float) + circ = hhl_module._prepare_state_b(circ, 0, b_vector) + assert circ is not None + + +# Test state preparation with superposition +def test_state_preparation_superposition(): + """Test state preparation for a superposition vector.""" + from braket.circuits import Circuit + + circ = Circuit() + b_vector = np.array([1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=float) + circ = hhl_module._prepare_state_b(circ, 0, b_vector) + assert circ is not None + + +# Test Hamiltonian simulation +def test_hamiltonian_simulation(): + """Test that the Hamiltonian simulation produces a unitary matrix.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + t = 1.0 + unitary = hhl_module._compute_hamiltonian_simulation(matrix, t) + + # Check unitarity: U @ U† = I + identity = unitary @ unitary.conj().T + assert np.allclose(identity, np.eye(2), atol=1e-10) + + +# Test Hamiltonian simulation at t=0 gives identity +def test_hamiltonian_simulation_t0(): + """Test that e^{i*A*0} = I.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + unitary = hhl_module._compute_hamiltonian_simulation(matrix, 0) + assert np.allclose(unitary, np.eye(2), atol=1e-10) + + +# Test eigendecomposition +def test_eigendecomposition(): + """Test eigendecomposition of a known matrix.""" + matrix = np.array([[2, 1], [1, 2]], dtype=complex) + eigenvalues, eigenvectors = hhl_module._compute_eigendecomposition(matrix) + + # Known eigenvalues for [[2,1],[1,2]] are 1 and 3 + assert np.allclose(sorted(eigenvalues), [1, 3], atol=1e-10) + + +# Test HHL circuit with identity matrix (trivial case) +def test_hhl_identity_matrix(): + """Test HHL with identity matrix: solution should be b itself.""" + matrix = np.array([[1, 0], [0, 1]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) + + assert circ is not None + + +# Test run_hhl function +def test_run_hhl(): + """Test running HHL on local simulator.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) + device = LocalSimulator() + task = hhl_module.run_hhl(circ, device, shots=100) + + result = task.result() + assert result is not None + assert result.measurement_counts is not None + + +# Test get_hhl_results function +def test_get_hhl_results(): + """Test post-processing of HHL results.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) + device = LocalSimulator() + task = hhl_module.run_hhl(circ, device, shots=1000) + + results = hhl_module.get_hhl_results( + task, matrix, b_vector, num_clock_qubits=2, verbose=True + ) + + assert "measurement_counts" in results + assert "post_selected_counts" in results + assert "solution_state_probabilities" in results + assert "classical_solution" in results + assert "fidelity" in results + assert "success_probability" in results + + # Classical solution for Ax=b with A=diag(1,2), b=[1,0] is x=[1,0] + classical_sol = results["classical_solution"] + assert np.allclose(classical_sol, [1, 0], atol=1e-10) + + +# Test validation of b_vector length +def test_hhl_b_vector_wrong_length_raises(): + """Test that a b_vector with wrong length raises ValueError.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0, 0], dtype=complex) + + with pytest.raises(ValueError): + hhl_module.hhl_circuit(matrix, b_vector) + + +# Test with custom scaling factor +def test_hhl_custom_scaling(): + """Test HHL with a custom scaling factor.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit( + matrix, b_vector, num_clock_qubits=2, scaling_factor=np.pi + ) + assert circ is not None + + +# Test with a matrix having negative eigenvalues +def test_hhl_negative_eigenvalues(): + """Test HHL circuit creation for a matrix with negative eigenvalues.""" + # This matrix has eigenvalues -1 and 3 + matrix = np.array([[1, 2], [2, 1]], dtype=complex) + + # For now just test circuit construction + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) + assert circ is not None From a314a20760582ed62d7c482929f77d6fdb9d22b2 Mon Sep 17 00:00:00 2001 From: axif Date: Mon, 16 Feb 2026 01:46:48 +0600 Subject: [PATCH 02/11] Add cell IDs, clear execution counts, and update notebook format --- .../advanced_algorithms/HHL_Algorithm.ipynb | 82 ++++++++++++------- 1 file changed, 54 insertions(+), 28 deletions(-) diff --git a/notebooks/advanced_algorithms/HHL_Algorithm.ipynb b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb index e9a1cda6..f89d01f3 100644 --- a/notebooks/advanced_algorithms/HHL_Algorithm.ipynb +++ b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb @@ -39,7 +39,8 @@ "- $\\vec{b}$ must be efficiently preparable as a quantum state\n", "- The exponential speedup only applies when summary statistics of $\\vec{x}$ are needed, not the full solution\n", "- The matrix should be sparse and well-conditioned for optimal performance" - ] + ], + "id": "46327740-1403-42ca-be4c-452ec15137df" }, { "cell_type": "markdown", @@ -56,7 +57,8 @@ "[[4] X.-D. Cai et al., \"Experimental Quantum Computing to Solve Systems of Linear Equations\", Phys. Rev. Lett. 110, 230501 (2013)](https://arxiv.org/abs/1302.4310)\n", "\n", "[[5] J. Pan et al., \"Experimental realization of quantum algorithm for solving linear systems of equations\", Phys. Rev. A 89, 022313 (2014)](https://arxiv.org/abs/1302.1946)" - ] + ], + "id": "819903ab-f718-46fb-b315-ce39d68ade09" }, { "cell_type": "markdown", @@ -65,7 +67,8 @@ "## Setup\n", "\n", "First, let's import the necessary libraries and the HHL module from the Braket Algorithm Library." - ] + ], + "id": "79d70716-f526-4c12-bf6f-ac4922a4d254" }, { "cell_type": "code", @@ -88,7 +91,8 @@ "%matplotlib inline\n", "%load_ext autoreload\n", "%autoreload 2" - ] + ], + "id": "193335f0-8584-49c7-b214-25cb04ed8993" }, { "cell_type": "markdown", @@ -103,7 +107,8 @@ "The classical solution is trivially $\\vec{x} = \\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix}$.\n", "\n", "This diagonal case is instructive because the eigenvalues are simply the diagonal elements, making it easy to understand how QPE encodes them and how the controlled rotation inverts them." - ] + ], + "id": "48e440ee-c0aa-4ba1-b5be-c9fd4ea10fc3" }, { "cell_type": "code", @@ -137,14 +142,16 @@ "print(f\"Eigenvalues of A: {eigenvalues}\")\n", "print(f\"Condition number: {max(abs(eigenvalues)) / min(abs(eigenvalues)):.2f}\")\n", "print(f\"\\nClassical solution: {np.linalg.solve(A1, b1)}\")" - ] + ], + "id": "d0552d6b-f73a-410d-8250-d678e0838412" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Build and Visualize the HHL Circuit" - ] + ], + "id": "2fb16e34-8c8a-4f0d-b3f5-46928e2e84b4" }, { "cell_type": "code", @@ -176,14 +183,16 @@ "print(f\" - Ancilla qubit: q3 (for eigenvalue inversion)\")\n", "print(f\"Circuit depth: {hhl_circ1.depth}\")\n", "print(f\"Number of instructions: {len(hhl_circ1.instructions)}\")" - ] + ], + "id": "12cab98f-3905-4507-9962-2ad30a420c93" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Run on the Local Simulator" - ] + ], + "id": "2fd6b070-9ff1-4e3d-b057-e454d125c7e6" }, { "cell_type": "code", @@ -228,7 +237,8 @@ "results1 = get_hhl_results(\n", " task1, A1, b1, num_clock_qubits=2, verbose=True\n", ")" - ] + ], + "id": "34ca956d-5750-4ed1-9dd1-c84a7c7550dd" }, { "cell_type": "markdown", @@ -237,7 +247,8 @@ "### Visualize the Results\n", "\n", "Let's compare the quantum solution (from post-selected measurements) with the classical solution." - ] + ], + "id": "0b79bf43-5d36-4ea0-bf51-5171bb5592c2" }, { "cell_type": "code", @@ -303,7 +314,8 @@ " plt.show()\n", "\n", "plot_hhl_comparison(results1, \"Example 1: Diagonal Matrix A = diag(1, 2), b = [1, 0]\")" - ] + ], + "id": "c13cf144-dec2-4425-9812-280723977963" }, { "cell_type": "markdown", @@ -319,7 +331,8 @@ "\n", "The classical solution is:\n", "$$\\vec{x} = A^{-1}\\vec{b} = \\frac{1}{3\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}$$" - ] + ], + "id": "fc50a6b5-4499-4842-8a91-d9f232f2a163" }, { "cell_type": "code", @@ -353,7 +366,8 @@ "print(f\"Eigenvalues of A: {eigenvalues2}\")\n", "print(f\"Condition number: {max(abs(eigenvalues2)) / min(abs(eigenvalues2)):.2f}\")\n", "print(f\"\\nClassical solution: {np.linalg.solve(A2, b2)}\")" - ] + ], + "id": "38f2a703-76c1-470a-8cbe-e8ee235c147e" }, { "cell_type": "code", @@ -410,7 +424,8 @@ ")\n", "\n", "plot_hhl_comparison(results2, \"Example 2: A = [[2,1],[1,2]], b = [1/√2, 1/√2]\")" - ] + ], + "id": "2694eec7-1db9-4f7b-8f2d-1415f03f4258" }, { "cell_type": "markdown", @@ -425,7 +440,8 @@ "$$A = \\begin{pmatrix} \\lambda_1 & 0 \\\\ 0 & \\lambda_2 \\end{pmatrix}$$\n", "\n", "with $\\lambda_1 = 1$ and varying $\\lambda_2$ to change the condition number." - ] + ], + "id": "92b305d0-61de-41e7-af0b-75596a32214e" }, { "cell_type": "code", @@ -497,7 +513,8 @@ "plt.suptitle('Effect of Condition Number on HHL Performance', fontsize=14, fontweight='bold')\n", "plt.tight_layout()\n", "plt.show()" - ] + ], + "id": "f820a731-4ad3-467b-b7ca-97c84b78188c" }, { "cell_type": "markdown", @@ -535,7 +552,8 @@ "\n", "The inverse QPE uncomputes the clock register, returning it to $|0\\rangle^{\\otimes n}$.\n", "After post-selecting on the ancilla measuring $|1\\rangle$, the input qubit is in the state $|x\\rangle \\propto A^{-1}|b\\rangle$." - ] + ], + "id": "339d0d20-7afd-4210-8630-38b3b561dea7" }, { "cell_type": "markdown", @@ -544,7 +562,8 @@ "## Example 4: Varying the Input Vector\n", "\n", "Let's fix the matrix and explore how different input vectors $\\vec{b}$ affect the solution." - ] + ], + "id": "063cca65-3ba7-4d48-a887-293eae9d2613" }, { "cell_type": "code", @@ -604,7 +623,8 @@ " fontsize=14, fontweight='bold')\n", "plt.tight_layout()\n", "plt.show()" - ] + ], + "id": "40d94b2a-036a-4ae1-bb84-0fd375d9b6eb" }, { "cell_type": "markdown", @@ -634,7 +654,8 @@ "- **Computational Finance**: Portfolio optimization, options pricing via PDEs\n", "- **Scientific Computing**: Solving differential equations, finite element methods\n", "- **Quantum Chemistry**: Solving coupled cluster equations" - ] + ], + "id": "8e843473-e2ac-4a9e-a438-ce82300a522a" }, { "cell_type": "markdown", @@ -645,7 +666,8 @@ "The following cells demonstrate how to run the HHL algorithm on an Amazon Braket managed simulator or QPU.\n", "\n", "Note: Running on a QPU will incur costs. Use the [Braket cost tracker](https://docs.aws.amazon.com/braket/latest/developerguide/braket-pricing.html#real-time-cost-tracking) to estimate costs." - ] + ], + "id": "9531bd33-121e-4ec7-9dbf-d79718b97fee" }, { "cell_type": "code", @@ -657,7 +679,8 @@ "# from braket.tracking import Tracker\n", "\n", "# tracker = Tracker().start()" - ] + ], + "id": "a037c8a6-6de2-456e-a38d-014259d68759" }, { "cell_type": "code", @@ -687,7 +710,8 @@ "# )\n", "\n", "# plot_hhl_comparison(results_qpu, \"HHL on Managed Simulator\")" - ] + ], + "id": "feee56a0-e6d3-41eb-8929-88fa8a311857" }, { "cell_type": "code", @@ -700,14 +724,16 @@ "# print(\n", "# f\"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost():.2f} USD\"\n", "# )" - ] + ], + "id": "b4a7a045-69bb-4f6a-be0c-c5ec56c2d9b9" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2)." - ] + ], + "id": "19fa3987-afd7-4665-8652-d1e990b5a421" } ], "metadata": { @@ -735,5 +761,5 @@ } }, "nbformat": 4, - "nbformat_minor": 4 -} + "nbformat_minor": 5 +} \ No newline at end of file From a8ca022214e3d35a5c09dc0178567c23d39abb90 Mon Sep 17 00:00:00 2001 From: axif Date: Wed, 18 Feb 2026 16:32:20 +0600 Subject: [PATCH 03/11] Refactor notebooks and scripts for improved readability and consistency. --- .../advanced_algorithms/HHL_Algorithm.ipynb | 240 ++++++++--------- .../1_Shot_Allocation.ipynb | 243 ++++++++++++------ .../2_Adaptive_Shot_Allocation.ipynb | 208 ++++++++++----- .../adaptive_allocation_notebook_helpers.py | 7 +- notebooks/textbook/CHSH_Inequality.ipynb | 2 +- .../adaptive_allocator.py | 179 +++++++------ .../adaptive_allocator_braket_helpers.py | 52 ++-- .../experimental/algorithms/hhl/__init__.py | 2 +- src/braket/experimental/algorithms/hhl/hhl.py | 30 +-- .../test_adaptive_allocator.py | 91 ++++--- .../experimental/algorithms/hhl/test_hhl.py | 8 +- 11 files changed, 624 insertions(+), 438 deletions(-) diff --git a/notebooks/advanced_algorithms/HHL_Algorithm.ipynb b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb index f89d01f3..d053365a 100644 --- a/notebooks/advanced_algorithms/HHL_Algorithm.ipynb +++ b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "46327740-1403-42ca-be4c-452ec15137df", "metadata": {}, "source": [ "# Harrow-Hassidim-Lloyd (HHL) Algorithm\n", @@ -39,11 +40,11 @@ "- $\\vec{b}$ must be efficiently preparable as a quantum state\n", "- The exponential speedup only applies when summary statistics of $\\vec{x}$ are needed, not the full solution\n", "- The matrix should be sparse and well-conditioned for optimal performance" - ], - "id": "46327740-1403-42ca-be4c-452ec15137df" + ] }, { "cell_type": "markdown", + "id": "819903ab-f718-46fb-b315-ce39d68ade09", "metadata": {}, "source": [ "## References\n", @@ -57,22 +58,22 @@ "[[4] X.-D. Cai et al., \"Experimental Quantum Computing to Solve Systems of Linear Equations\", Phys. Rev. Lett. 110, 230501 (2013)](https://arxiv.org/abs/1302.4310)\n", "\n", "[[5] J. Pan et al., \"Experimental realization of quantum algorithm for solving linear systems of equations\", Phys. Rev. A 89, 022313 (2014)](https://arxiv.org/abs/1302.1946)" - ], - "id": "819903ab-f718-46fb-b315-ce39d68ade09" + ] }, { "cell_type": "markdown", + "id": "79d70716-f526-4c12-bf6f-ac4922a4d254", "metadata": {}, "source": [ "## Setup\n", "\n", "First, let's import the necessary libraries and the HHL module from the Braket Algorithm Library." - ], - "id": "79d70716-f526-4c12-bf6f-ac4922a4d254" + ] }, { "cell_type": "code", "execution_count": 1, + "id": "193335f0-8584-49c7-b214-25cb04ed8993", "metadata": {}, "outputs": [], "source": [ @@ -91,11 +92,11 @@ "%matplotlib inline\n", "%load_ext autoreload\n", "%autoreload 2" - ], - "id": "193335f0-8584-49c7-b214-25cb04ed8993" + ] }, { "cell_type": "markdown", + "id": "48e440ee-c0aa-4ba1-b5be-c9fd4ea10fc3", "metadata": {}, "source": [ "## Example 1: Solving a Simple Diagonal System\n", @@ -107,12 +108,12 @@ "The classical solution is trivially $\\vec{x} = \\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix}$.\n", "\n", "This diagonal case is instructive because the eigenvalues are simply the diagonal elements, making it easy to understand how QPE encodes them and how the controlled rotation inverts them." - ], - "id": "48e440ee-c0aa-4ba1-b5be-c9fd4ea10fc3" + ] }, { "cell_type": "code", "execution_count": 2, + "id": "d0552d6b-f73a-410d-8250-d678e0838412", "metadata": {}, "outputs": [ { @@ -142,20 +143,20 @@ "print(f\"Eigenvalues of A: {eigenvalues}\")\n", "print(f\"Condition number: {max(abs(eigenvalues)) / min(abs(eigenvalues)):.2f}\")\n", "print(f\"\\nClassical solution: {np.linalg.solve(A1, b1)}\")" - ], - "id": "d0552d6b-f73a-410d-8250-d678e0838412" + ] }, { "cell_type": "markdown", + "id": "2fb16e34-8c8a-4f0d-b3f5-46928e2e84b4", "metadata": {}, "source": [ "### Build and Visualize the HHL Circuit" - ], - "id": "2fb16e34-8c8a-4f0d-b3f5-46928e2e84b4" + ] }, { "cell_type": "code", "execution_count": 3, + "id": "12cab98f-3905-4507-9962-2ad30a420c93", "metadata": {}, "outputs": [ { @@ -183,20 +184,20 @@ "print(f\" - Ancilla qubit: q3 (for eigenvalue inversion)\")\n", "print(f\"Circuit depth: {hhl_circ1.depth}\")\n", "print(f\"Number of instructions: {len(hhl_circ1.instructions)}\")" - ], - "id": "12cab98f-3905-4507-9962-2ad30a420c93" + ] }, { "cell_type": "markdown", + "id": "2fd6b070-9ff1-4e3d-b057-e454d125c7e6", "metadata": {}, "source": [ "### Run on the Local Simulator" - ], - "id": "2fd6b070-9ff1-4e3d-b057-e454d125c7e6" + ] }, { "cell_type": "code", "execution_count": 4, + "id": "34ca956d-5750-4ed1-9dd1-c84a7c7550dd", "metadata": {}, "outputs": [ { @@ -234,25 +235,23 @@ "print(\"HHL Run Complete!\")\n", "\n", "# Get and display results\n", - "results1 = get_hhl_results(\n", - " task1, A1, b1, num_clock_qubits=2, verbose=True\n", - ")" - ], - "id": "34ca956d-5750-4ed1-9dd1-c84a7c7550dd" + "results1 = get_hhl_results(task1, A1, b1, num_clock_qubits=2, verbose=True)" + ] }, { "cell_type": "markdown", + "id": "0b79bf43-5d36-4ea0-bf51-5171bb5592c2", "metadata": {}, "source": [ "### Visualize the Results\n", "\n", "Let's compare the quantum solution (from post-selected measurements) with the classical solution." - ], - "id": "0b79bf43-5d36-4ea0-bf51-5171bb5592c2" + ] }, { "cell_type": "code", "execution_count": 5, + "id": "c13cf144-dec2-4425-9812-280723977963", "metadata": {}, "outputs": [ { @@ -270,55 +269,60 @@ "def plot_hhl_comparison(results, title=\"HHL Algorithm Results\"):\n", " \"\"\"Plot comparison between quantum and classical solutions.\"\"\"\n", " fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n", - " \n", + "\n", " # Plot 1: Raw measurement counts\n", - " counts = results['measurement_counts']\n", + " counts = results[\"measurement_counts\"]\n", " sorted_counts = dict(sorted(counts.items()))\n", - " axes[0].bar(sorted_counts.keys(), sorted_counts.values(), color='steelblue', alpha=0.8)\n", - " axes[0].set_xlabel('Bitstring (clock | input | ancilla)')\n", - " axes[0].set_ylabel('Counts')\n", - " axes[0].set_title('Raw Measurement Counts')\n", - " axes[0].tick_params(axis='x', rotation=90)\n", - " \n", + " axes[0].bar(sorted_counts.keys(), sorted_counts.values(), color=\"steelblue\", alpha=0.8)\n", + " axes[0].set_xlabel(\"Bitstring (clock | input | ancilla)\")\n", + " axes[0].set_ylabel(\"Counts\")\n", + " axes[0].set_title(\"Raw Measurement Counts\")\n", + " axes[0].tick_params(axis=\"x\", rotation=90)\n", + "\n", " # Plot 2: Post-selected solution probabilities vs classical\n", " quantum_probs = [\n", - " results['solution_state_probabilities'].get('0', 0),\n", - " results['solution_state_probabilities'].get('1', 0),\n", + " results[\"solution_state_probabilities\"].get(\"0\", 0),\n", + " results[\"solution_state_probabilities\"].get(\"1\", 0),\n", " ]\n", - " classical_probs = list(results['classical_probabilities'])\n", - " \n", + " classical_probs = list(results[\"classical_probabilities\"])\n", + "\n", " x = np.arange(2)\n", " width = 0.35\n", - " axes[1].bar(x - width/2, quantum_probs, width, label='Quantum (HHL)', color='coral', alpha=0.8)\n", - " axes[1].bar(x + width/2, classical_probs, width, label='Classical', color='steelblue', alpha=0.8)\n", - " axes[1].set_xlabel('Solution Component')\n", - " axes[1].set_ylabel('Probability |x_i|²')\n", - " axes[1].set_title(f'Solution Comparison (Fidelity: {results[\"fidelity\"]:.4f})')\n", + " axes[1].bar(\n", + " x - width / 2, quantum_probs, width, label=\"Quantum (HHL)\", color=\"coral\", alpha=0.8\n", + " )\n", + " axes[1].bar(\n", + " x + width / 2, classical_probs, width, label=\"Classical\", color=\"steelblue\", alpha=0.8\n", + " )\n", + " axes[1].set_xlabel(\"Solution Component\")\n", + " axes[1].set_ylabel(\"Probability |x_i|²\")\n", + " axes[1].set_title(f\"Solution Comparison (Fidelity: {results['fidelity']:.4f})\")\n", " axes[1].set_xticks(x)\n", - " axes[1].set_xticklabels(['|0⟩', '|1⟩'])\n", + " axes[1].set_xticklabels([\"|0⟩\", \"|1⟩\"])\n", " axes[1].legend()\n", - " \n", + "\n", " # Plot 3: Success probability pie chart\n", - " success_rate = results['success_probability']\n", + " success_rate = results[\"success_probability\"]\n", " axes[2].pie(\n", " [success_rate, 1 - success_rate],\n", - " labels=['Success\\n(ancilla=|1⟩)', 'Failure\\n(ancilla=|0⟩)'],\n", - " colors=['mediumseagreen', 'lightcoral'],\n", - " autopct='%1.1f%%',\n", + " labels=[\"Success\\n(ancilla=|1⟩)\", \"Failure\\n(ancilla=|0⟩)\"],\n", + " colors=[\"mediumseagreen\", \"lightcoral\"],\n", + " autopct=\"%1.1f%%\",\n", " startangle=90,\n", " )\n", - " axes[2].set_title('Post-Selection Success Rate')\n", - " \n", - " fig.suptitle(title, fontsize=14, fontweight='bold')\n", + " axes[2].set_title(\"Post-Selection Success Rate\")\n", + "\n", + " fig.suptitle(title, fontsize=14, fontweight=\"bold\")\n", " plt.tight_layout()\n", " plt.show()\n", "\n", + "\n", "plot_hhl_comparison(results1, \"Example 1: Diagonal Matrix A = diag(1, 2), b = [1, 0]\")" - ], - "id": "c13cf144-dec2-4425-9812-280723977963" + ] }, { "cell_type": "markdown", + "id": "fc50a6b5-4499-4842-8a91-d9f232f2a163", "metadata": {}, "source": [ "## Example 2: Solving a Non-Diagonal Hermitian System\n", @@ -331,12 +335,12 @@ "\n", "The classical solution is:\n", "$$\\vec{x} = A^{-1}\\vec{b} = \\frac{1}{3\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}$$" - ], - "id": "fc50a6b5-4499-4842-8a91-d9f232f2a163" + ] }, { "cell_type": "code", "execution_count": 6, + "id": "38f2a703-76c1-470a-8cbe-e8ee235c147e", "metadata": {}, "outputs": [ { @@ -357,7 +361,7 @@ "source": [ "# Define the system\n", "A2 = np.array([[2, 1], [1, 2]], dtype=complex)\n", - "b2 = np.array([1/np.sqrt(2), 1/np.sqrt(2)], dtype=complex)\n", + "b2 = np.array([1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=complex)\n", "\n", "# Print eigenvalues\n", "eigenvalues2, eigenvectors2 = np.linalg.eigh(A2)\n", @@ -366,12 +370,12 @@ "print(f\"Eigenvalues of A: {eigenvalues2}\")\n", "print(f\"Condition number: {max(abs(eigenvalues2)) / min(abs(eigenvalues2)):.2f}\")\n", "print(f\"\\nClassical solution: {np.linalg.solve(A2, b2)}\")" - ], - "id": "38f2a703-76c1-470a-8cbe-e8ee235c147e" + ] }, { "cell_type": "code", "execution_count": 7, + "id": "2694eec7-1db9-4f7b-8f2d-1415f03f4258", "metadata": {}, "outputs": [ { @@ -419,16 +423,14 @@ "task2 = run_hhl(hhl_circ2, device, shots=10000)\n", "print(\"HHL Run Complete!\")\n", "\n", - "results2 = get_hhl_results(\n", - " task2, A2, b2, num_clock_qubits=2, verbose=True\n", - ")\n", + "results2 = get_hhl_results(task2, A2, b2, num_clock_qubits=2, verbose=True)\n", "\n", "plot_hhl_comparison(results2, \"Example 2: A = [[2,1],[1,2]], b = [1/√2, 1/√2]\")" - ], - "id": "2694eec7-1db9-4f7b-8f2d-1415f03f4258" + ] }, { "cell_type": "markdown", + "id": "92b305d0-61de-41e7-af0b-75596a32214e", "metadata": {}, "source": [ "## Example 3: Effect of the Condition Number\n", @@ -440,12 +442,12 @@ "$$A = \\begin{pmatrix} \\lambda_1 & 0 \\\\ 0 & \\lambda_2 \\end{pmatrix}$$\n", "\n", "with $\\lambda_1 = 1$ and varying $\\lambda_2$ to change the condition number." - ], - "id": "92b305d0-61de-41e7-af0b-75596a32214e" + ] }, { "cell_type": "code", "execution_count": 8, + "id": "f820a731-4ad3-467b-b7ca-97c84b78188c", "metadata": {}, "outputs": [ { @@ -473,7 +475,7 @@ ], "source": [ "# Test with different condition numbers\n", - "b_test = np.array([1/np.sqrt(2), 1/np.sqrt(2)], dtype=complex)\n", + "b_test = np.array([1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=complex)\n", "condition_numbers = [1, 2, 3, 4]\n", "fidelities = []\n", "success_probs = []\n", @@ -486,38 +488,40 @@ " circ = hhl_circuit(A_test, b_test, num_clock_qubits=2)\n", " task = run_hhl(circ, device, shots=10000)\n", " results = get_hhl_results(task, A_test, b_test, num_clock_qubits=2)\n", - " \n", - " fidelities.append(results['fidelity'])\n", - " success_probs.append(results['success_probability'])\n", - " \n", - " print(f\"κ = {kappa}: Fidelity = {results['fidelity']:.4f}, \"\n", - " f\"Success Prob = {results['success_probability']:.4f}\")\n", + "\n", + " fidelities.append(results[\"fidelity\"])\n", + " success_probs.append(results[\"success_probability\"])\n", + "\n", + " print(\n", + " f\"κ = {kappa}: Fidelity = {results['fidelity']:.4f}, \"\n", + " f\"Success Prob = {results['success_probability']:.4f}\"\n", + " )\n", "\n", "# Plot\n", "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))\n", "\n", - "ax1.plot(condition_numbers, fidelities, 'o-', color='coral', linewidth=2, markersize=8)\n", - "ax1.set_xlabel('Condition Number κ')\n", - "ax1.set_ylabel('Fidelity')\n", - "ax1.set_title('Solution Fidelity vs Condition Number')\n", + "ax1.plot(condition_numbers, fidelities, \"o-\", color=\"coral\", linewidth=2, markersize=8)\n", + "ax1.set_xlabel(\"Condition Number κ\")\n", + "ax1.set_ylabel(\"Fidelity\")\n", + "ax1.set_title(\"Solution Fidelity vs Condition Number\")\n", "ax1.grid(True, alpha=0.3)\n", "ax1.set_ylim([0, 1.05])\n", "\n", - "ax2.plot(condition_numbers, success_probs, 's-', color='steelblue', linewidth=2, markersize=8)\n", - "ax2.set_xlabel('Condition Number κ')\n", - "ax2.set_ylabel('Success Probability')\n", - "ax2.set_title('Post-Selection Success vs Condition Number')\n", + "ax2.plot(condition_numbers, success_probs, \"s-\", color=\"steelblue\", linewidth=2, markersize=8)\n", + "ax2.set_xlabel(\"Condition Number κ\")\n", + "ax2.set_ylabel(\"Success Probability\")\n", + "ax2.set_title(\"Post-Selection Success vs Condition Number\")\n", "ax2.grid(True, alpha=0.3)\n", "ax2.set_ylim([0, 1.05])\n", "\n", - "plt.suptitle('Effect of Condition Number on HHL Performance', fontsize=14, fontweight='bold')\n", + "plt.suptitle(\"Effect of Condition Number on HHL Performance\", fontsize=14, fontweight=\"bold\")\n", "plt.tight_layout()\n", "plt.show()" - ], - "id": "f820a731-4ad3-467b-b7ca-97c84b78188c" + ] }, { "cell_type": "markdown", + "id": "339d0d20-7afd-4210-8630-38b3b561dea7", "metadata": {}, "source": [ "## Understanding the Circuit Components\n", @@ -552,22 +556,22 @@ "\n", "The inverse QPE uncomputes the clock register, returning it to $|0\\rangle^{\\otimes n}$.\n", "After post-selecting on the ancilla measuring $|1\\rangle$, the input qubit is in the state $|x\\rangle \\propto A^{-1}|b\\rangle$." - ], - "id": "339d0d20-7afd-4210-8630-38b3b561dea7" + ] }, { "cell_type": "markdown", + "id": "063cca65-3ba7-4d48-a887-293eae9d2613", "metadata": {}, "source": [ "## Example 4: Varying the Input Vector\n", "\n", "Let's fix the matrix and explore how different input vectors $\\vec{b}$ affect the solution." - ], - "id": "063cca65-3ba7-4d48-a887-293eae9d2613" + ] }, { "cell_type": "code", "execution_count": 9, + "id": "40d94b2a-036a-4ae1-bb84-0fd375d9b6eb", "metadata": {}, "outputs": [ { @@ -588,46 +592,49 @@ "test_vectors = [\n", " (np.array([1, 0], dtype=complex), \"|0⟩\"),\n", " (np.array([0, 1], dtype=complex), \"|1⟩\"),\n", - " (np.array([1/np.sqrt(2), 1/np.sqrt(2)], dtype=complex), \"|+⟩\"),\n", - " (np.array([1/np.sqrt(2), -1/np.sqrt(2)], dtype=complex), \"|−⟩\"),\n", + " (np.array([1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=complex), \"|+⟩\"),\n", + " (np.array([1 / np.sqrt(2), -1 / np.sqrt(2)], dtype=complex), \"|−⟩\"),\n", "]\n", "\n", "fig, axes = plt.subplots(2, 2, figsize=(14, 10))\n", "\n", "for idx, (b_vec, label) in enumerate(test_vectors):\n", " ax = axes[idx // 2][idx % 2]\n", - " \n", + "\n", " circ = hhl_circuit(A4, b_vec, num_clock_qubits=2)\n", " task = run_hhl(circ, device, shots=10000)\n", " results = get_hhl_results(task, A4, b_vec, num_clock_qubits=2)\n", - " \n", + "\n", " quantum_probs = [\n", - " results['solution_state_probabilities'].get('0', 0),\n", - " results['solution_state_probabilities'].get('1', 0),\n", + " results[\"solution_state_probabilities\"].get(\"0\", 0),\n", + " results[\"solution_state_probabilities\"].get(\"1\", 0),\n", " ]\n", - " classical_probs = list(results['classical_probabilities'])\n", - " \n", + " classical_probs = list(results[\"classical_probabilities\"])\n", + "\n", " x = np.arange(2)\n", " width = 0.35\n", - " ax.bar(x - width/2, quantum_probs, width, label='Quantum', color='coral', alpha=0.8)\n", - " ax.bar(x + width/2, classical_probs, width, label='Classical', color='steelblue', alpha=0.8)\n", - " ax.set_xlabel('Component')\n", - " ax.set_ylabel('Probability |x_i|²')\n", - " ax.set_title(f'b = {label} (F={results[\"fidelity\"]:.3f})')\n", + " ax.bar(x - width / 2, quantum_probs, width, label=\"Quantum\", color=\"coral\", alpha=0.8)\n", + " ax.bar(x + width / 2, classical_probs, width, label=\"Classical\", color=\"steelblue\", alpha=0.8)\n", + " ax.set_xlabel(\"Component\")\n", + " ax.set_ylabel(\"Probability |x_i|²\")\n", + " ax.set_title(f\"b = {label} (F={results['fidelity']:.3f})\")\n", " ax.set_xticks(x)\n", - " ax.set_xticklabels(['|0⟩', '|1⟩'])\n", + " ax.set_xticklabels([\"|0⟩\", \"|1⟩\"])\n", " ax.legend()\n", " ax.set_ylim([0, 1.1])\n", "\n", - "plt.suptitle('HHL Solutions for A = [[2,1],[1,2]] with Different Input Vectors',\n", - " fontsize=14, fontweight='bold')\n", + "plt.suptitle(\n", + " \"HHL Solutions for A = [[2,1],[1,2]] with Different Input Vectors\",\n", + " fontsize=14,\n", + " fontweight=\"bold\",\n", + ")\n", "plt.tight_layout()\n", "plt.show()" - ], - "id": "40d94b2a-036a-4ae1-bb84-0fd375d9b6eb" + ] }, { "cell_type": "markdown", + "id": "8e843473-e2ac-4a9e-a438-ce82300a522a", "metadata": {}, "source": [ "## Practical Considerations and Limitations\n", @@ -654,11 +661,11 @@ "- **Computational Finance**: Portfolio optimization, options pricing via PDEs\n", "- **Scientific Computing**: Solving differential equations, finite element methods\n", "- **Quantum Chemistry**: Solving coupled cluster equations" - ], - "id": "8e843473-e2ac-4a9e-a438-ce82300a522a" + ] }, { "cell_type": "markdown", + "id": "9531bd33-121e-4ec7-9dbf-d79718b97fee", "metadata": {}, "source": [ "## [Optional] Run on a QPU or Managed Simulator\n", @@ -666,12 +673,12 @@ "The following cells demonstrate how to run the HHL algorithm on an Amazon Braket managed simulator or QPU.\n", "\n", "Note: Running on a QPU will incur costs. Use the [Braket cost tracker](https://docs.aws.amazon.com/braket/latest/developerguide/braket-pricing.html#real-time-cost-tracking) to estimate costs." - ], - "id": "9531bd33-121e-4ec7-9dbf-d79718b97fee" + ] }, { "cell_type": "code", "execution_count": 10, + "id": "a037c8a6-6de2-456e-a38d-014259d68759", "metadata": {}, "outputs": [], "source": [ @@ -679,12 +686,12 @@ "# from braket.tracking import Tracker\n", "\n", "# tracker = Tracker().start()" - ], - "id": "a037c8a6-6de2-456e-a38d-014259d68759" + ] }, { "cell_type": "code", "execution_count": 11, + "id": "feee56a0-e6d3-41eb-8929-88fa8a311857", "metadata": {}, "outputs": [], "source": [ @@ -710,12 +717,12 @@ "# )\n", "\n", "# plot_hhl_comparison(results_qpu, \"HHL on Managed Simulator\")" - ], - "id": "feee56a0-e6d3-41eb-8929-88fa8a311857" + ] }, { "cell_type": "code", "execution_count": 12, + "id": "b4a7a045-69bb-4f6a-be0c-c5ec56c2d9b9", "metadata": {}, "outputs": [], "source": [ @@ -724,16 +731,15 @@ "# print(\n", "# f\"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost():.2f} USD\"\n", "# )" - ], - "id": "b4a7a045-69bb-4f6a-be0c-c5ec56c2d9b9" + ] }, { "cell_type": "markdown", + "id": "19fa3987-afd7-4665-8652-d1e990b5a421", "metadata": {}, "source": [ "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2)." - ], - "id": "19fa3987-afd7-4665-8652-d1e990b5a421" + ] } ], "metadata": { diff --git a/notebooks/advanced_algorithms/adaptive_shot_allocation/1_Shot_Allocation.ipynb b/notebooks/advanced_algorithms/adaptive_shot_allocation/1_Shot_Allocation.ipynb index c8a78f33..8de2d2e2 100644 --- a/notebooks/advanced_algorithms/adaptive_shot_allocation/1_Shot_Allocation.ipynb +++ b/notebooks/advanced_algorithms/adaptive_shot_allocation/1_Shot_Allocation.ipynb @@ -104,11 +104,14 @@ ], "source": [ "# Create a parameterized circuit with random angles\n", - "random_state = (Circuit()\n", - " .ry(angle = np.random.rand()*np.pi, target=0).ry(angle = np.random.rand()*np.pi, target=1)\n", - " .cnot(control=0, target=1)\n", - " .ry(angle = np.random.rand()*np.pi, target=0).ry(angle = np.random.rand()*np.pi, target=1)\n", - " )\n", + "random_state = (\n", + " Circuit()\n", + " .ry(angle=np.random.rand() * np.pi, target=0)\n", + " .ry(angle=np.random.rand() * np.pi, target=1)\n", + " .cnot(control=0, target=1)\n", + " .ry(angle=np.random.rand() * np.pi, target=0)\n", + " .ry(angle=np.random.rand() * np.pi, target=1)\n", + ")\n", "\n", "print(random_state)" ] @@ -159,29 +162,30 @@ "# Set up local simulator device\n", "device = LocalSimulator()\n", "\n", + "\n", "def compute_expectation_value_approximation(state, shot_configuration):\n", " \"\"\"Compute approximate expectation value using specified shot allocation.\n", - " \n", + "\n", " Args:\n", " state (Circuit): Quantum circuit representing the state\n", " shot_configuration (list): Number of shots for each Pauli term\n", - " \n", + "\n", " Returns:\n", " float: Approximated expectation value\n", " \"\"\"\n", - " assert (len(shot_configuration)==len(paulis))\n", + " assert len(shot_configuration) == len(paulis)\n", " expectation_value = 0.0\n", - " \n", + "\n", " for i, term in enumerate(paulis):\n", " # Define a circuit measuring the specific term on the given state\n", " circuit = state.copy().sample(term)\n", - " \n", + "\n", " # Execute measurements and get results (±1)\n", - " measurements = device.run(circuit, shots = shot_configuration[i]).result().values[0]\n", - " \n", + " measurements = device.run(circuit, shots=shot_configuration[i]).result().values[0]\n", + "\n", " # Calculate term's contribution: mean of measurements × coefficient\n", - " expectation_value += coeffs[i]*np.mean(measurements, dtype=float)\n", - " \n", + " expectation_value += coeffs[i] * np.mean(measurements, dtype=float)\n", + "\n", " return expectation_value" ] }, @@ -201,25 +205,26 @@ "source": [ "def get_exact_expectation_value(state):\n", " \"\"\"Compute exact expectation value using state vector simulation.\n", - " \n", + "\n", " Args:\n", " state (Circuit): Quantum circuit representing the state\n", - " \n", + "\n", " Returns:\n", " float: Exact expectation value\n", " \"\"\"\n", " expectation_value = 0.0\n", - " \n", + "\n", " for i, term in enumerate(paulis):\n", " # Calculate exact expectation for each term\n", " circuit = state.copy().expectation(term)\n", - " normalized_expectation = device.run(circuit, shots = 0).result().values[0]\n", - " \n", + " normalized_expectation = device.run(circuit, shots=0).result().values[0]\n", + "\n", " # Add term's contribution: exact expectation × coefficient\n", - " expectation_value += coeffs[i]*normalized_expectation\n", - " \n", + " expectation_value += coeffs[i] * normalized_expectation\n", + "\n", " return expectation_value\n", "\n", + "\n", "# Calculate exact expectation value for reference\n", "exact_expectation = get_exact_expectation_value(random_state)\n", "print(f\"Exact expectation value: {exact_expectation:.6f}\")" @@ -252,12 +257,16 @@ "uniform_shot_allocation = [400, 400, 400]\n", "\n", "# Run multiple trials to get statistics\n", - "uniform_values = [compute_expectation_value_approximation(random_state, uniform_shot_allocation) for _ in range(1000)]\n", + "uniform_values = [\n", + " compute_expectation_value_approximation(random_state, uniform_shot_allocation)\n", + " for _ in range(1000)\n", + "]\n", "uniform_mean = np.mean(uniform_values)\n", "uniform_std = np.std(uniform_values)\n", "\n", - "print(f\"Uniform allocation ({uniform_shot_allocation}):\\n\"\n", - " f\"Mean: {uniform_mean:.6f} ± {uniform_std:.6f}\")" + "print(\n", + " f\"Uniform allocation ({uniform_shot_allocation}):\\nMean: {uniform_mean:.6f} ± {uniform_std:.6f}\"\n", + ")" ] }, { @@ -284,30 +293,47 @@ } ], "source": [ - "def plot_histograms(data, labels, colors, exact_expectation, title, y_max = 150):\n", + "def plot_histograms(data, labels, colors, exact_expectation, title, y_max=150):\n", " num_sets = len(data)\n", - " assert (len(labels) == num_sets)\n", - " assert (len(colors) == num_sets)\n", - " \n", + " assert len(labels) == num_sets\n", + " assert len(colors) == num_sets\n", + "\n", " plt.figure(figsize=(10, 6))\n", " for i in range(num_sets):\n", - " plt.hist(data[i], alpha=0.5, bins=np.arange(exact_expectation-1, exact_expectation+1, 0.025),\n", - " color=colors[i], label=labels[i])\n", - " \n", + " plt.hist(\n", + " data[i],\n", + " alpha=0.5,\n", + " bins=np.arange(exact_expectation - 1, exact_expectation + 1, 0.025),\n", + " color=colors[i],\n", + " label=labels[i],\n", + " )\n", + "\n", " if not y_max:\n", " y_max = int(np.ceil(plt.ylim()[1]))\n", - " \n", - " plt.ylim(0,y_max)\n", - " ev_line_height = (2*y_max//3)\n", - " plt.plot([exact_expectation]*ev_line_height, np.arange(ev_line_height), color=\"black\", label=\"Exact value\")\n", - " \n", + "\n", + " plt.ylim(0, y_max)\n", + " ev_line_height = 2 * y_max // 3\n", + " plt.plot(\n", + " [exact_expectation] * ev_line_height,\n", + " np.arange(ev_line_height),\n", + " color=\"black\",\n", + " label=\"Exact value\",\n", + " )\n", + "\n", " plt.xlabel(\"Expectation Value\")\n", " plt.ylabel(\"Frequency\")\n", " plt.legend()\n", " plt.title(title)\n", " plt.grid(True, alpha=0.3)\n", "\n", - "plot_histograms([uniform_values], [\"Uniform shot allocation\"], [\"red\"], exact_expectation, \"Distribution of Results with Uniform Shot Allocation\")" + "\n", + "plot_histograms(\n", + " [uniform_values],\n", + " [\"Uniform shot allocation\"],\n", + " [\"red\"],\n", + " exact_expectation,\n", + " \"Distribution of Results with Uniform Shot Allocation\",\n", + ")" ] }, { @@ -342,12 +368,17 @@ "weighted_shot_allocation = [100, 100, 1000]\n", "\n", "# Run multiple trials to get statistics\n", - "weighted_values = [compute_expectation_value_approximation(random_state, weighted_shot_allocation) for _ in range(1000)]\n", + "weighted_values = [\n", + " compute_expectation_value_approximation(random_state, weighted_shot_allocation)\n", + " for _ in range(1000)\n", + "]\n", "weighted_mean = np.mean(weighted_values)\n", "weighted_std = np.std(weighted_values)\n", "\n", - "print(f\"Coefficient-weighted allocation ({weighted_shot_allocation}):\\n\"\n", - " f\"Mean: {weighted_mean:.6f} ± {weighted_std:.6f}\")" + "print(\n", + " f\"Coefficient-weighted allocation ({weighted_shot_allocation}):\\n\"\n", + " f\"Mean: {weighted_mean:.6f} ± {weighted_std:.6f}\"\n", + ")" ] }, { @@ -367,8 +398,13 @@ } ], "source": [ - "plot_histograms([uniform_values, weighted_values], [\"Uniform allocation\", \"Coefficient-weighted allocation\"], [\"red\", \"blue\"], \n", - " exact_expectation, \"Comparison of Shot Allocation Strategies\")" + "plot_histograms(\n", + " [uniform_values, weighted_values],\n", + " [\"Uniform allocation\", \"Coefficient-weighted allocation\"],\n", + " [\"red\", \"blue\"],\n", + " exact_expectation,\n", + " \"Comparison of Shot Allocation Strategies\",\n", + ")" ] }, { @@ -425,7 +461,9 @@ ], "source": [ "# Prepare uniform superposition state\n", - "uniform_superposition_state = Circuit().h(0).h(1) # Apply Hadamard gates to create uniform superposition\n", + "uniform_superposition_state = (\n", + " Circuit().h(0).h(1)\n", + ") # Apply Hadamard gates to create uniform superposition\n", "print(uniform_superposition_state)\n", "\n", "exact_expectation = get_exact_expectation_value(uniform_superposition_state)\n", @@ -458,14 +496,24 @@ ], "source": [ "# Compare uniform and weighted allocations\n", - "uniform_values = [compute_expectation_value_approximation(uniform_superposition_state, uniform_shot_allocation) for _ in range(1000)]\n", - "weighted_values = [compute_expectation_value_approximation(uniform_superposition_state, weighted_shot_allocation) for _ in range(1000)]\n", - "\n", - "print(f\"Uniform allocation ({uniform_shot_allocation}):\\n\"\n", - " f\"Mean: {np.mean(uniform_values):.6f} ± {np.std(uniform_values):.6f}\\n\")\n", + "uniform_values = [\n", + " compute_expectation_value_approximation(uniform_superposition_state, uniform_shot_allocation)\n", + " for _ in range(1000)\n", + "]\n", + "weighted_values = [\n", + " compute_expectation_value_approximation(uniform_superposition_state, weighted_shot_allocation)\n", + " for _ in range(1000)\n", + "]\n", + "\n", + "print(\n", + " f\"Uniform allocation ({uniform_shot_allocation}):\\n\"\n", + " f\"Mean: {np.mean(uniform_values):.6f} ± {np.std(uniform_values):.6f}\\n\"\n", + ")\n", "\n", - "print(f\"Coefficient-weighted allocation ({weighted_shot_allocation}):\\n\"\n", - " f\"Mean: {np.mean(weighted_values):.6f} ± {np.std(weighted_values):.6f}\")" + "print(\n", + " f\"Coefficient-weighted allocation ({weighted_shot_allocation}):\\n\"\n", + " f\"Mean: {np.mean(weighted_values):.6f} ± {np.std(weighted_values):.6f}\"\n", + ")" ] }, { @@ -485,8 +533,14 @@ } ], "source": [ - "plot_histograms([uniform_values, weighted_values], [\"Uniform allocation\", \"Coefficient-weighted allocation\"], [\"red\", \"blue\"], \n", - " exact_expectation, \"Comparison for Uniform Superposition State\", y_max = 250)" + "plot_histograms(\n", + " [uniform_values, weighted_values],\n", + " [\"Uniform allocation\", \"Coefficient-weighted allocation\"],\n", + " [\"red\", \"blue\"],\n", + " exact_expectation,\n", + " \"Comparison for Uniform Superposition State\",\n", + " y_max=250,\n", + ")" ] }, { @@ -541,12 +595,16 @@ "source": [ "optimal_shot_allocation = [600, 599, 1]\n", "\n", - "optimal_values = [compute_expectation_value_approximation(uniform_superposition_state, optimal_shot_allocation) for _ in range(1000)]\n", + "optimal_values = [\n", + " compute_expectation_value_approximation(uniform_superposition_state, optimal_shot_allocation)\n", + " for _ in range(1000)\n", + "]\n", "optimal_mean = np.mean(optimal_values)\n", "optimal_std = np.std(optimal_values)\n", "\n", - "print(f\"Optimal allocation ({optimal_shot_allocation}):\\n\"\n", - " f\"Mean: {optimal_mean:.6f} ± {optimal_std:.6f}\")" + "print(\n", + " f\"Optimal allocation ({optimal_shot_allocation}):\\nMean: {optimal_mean:.6f} ± {optimal_std:.6f}\"\n", + ")" ] }, { @@ -566,8 +624,14 @@ } ], "source": [ - "plot_histograms([uniform_values, optimal_values], [\"Uniform allocation\", \"Optimal allocation\"], [\"red\", \"cyan\"], \n", - " exact_expectation, \"Comparison with Optimal Shot Allocation\", y_max = 250)" + "plot_histograms(\n", + " [uniform_values, optimal_values],\n", + " [\"Uniform allocation\", \"Optimal allocation\"],\n", + " [\"red\", \"cyan\"],\n", + " exact_expectation,\n", + " \"Comparison with Optimal Shot Allocation\",\n", + " y_max=250,\n", + ")" ] }, { @@ -586,36 +650,40 @@ "metadata": {}, "outputs": [], "source": [ - "def compute_grouped_expectation_value_approximation(state, observable_index_groups, shot_configuration):\n", + "def compute_grouped_expectation_value_approximation(\n", + " state, observable_index_groups, shot_configuration\n", + "):\n", " \"\"\"Compute expectation value using grouped measurements where possible.\n", - " \n", + "\n", " Args:\n", " state (Circuit): Quantum circuit representing the state\n", " observable_index_groups (list): Groups of observable indices that can be measured together\n", " shot_configuration (list): Number of shots for each group\n", - " \n", + "\n", " Returns:\n", " float: Approximated expectation value\n", " \"\"\"\n", - " assert (len(shot_configuration)==len(observable_index_groups))\n", + " assert len(shot_configuration) == len(observable_index_groups)\n", " expectation_value = 0.0\n", - " \n", + "\n", " for i, group in enumerate(observable_index_groups):\n", " if isinstance(group, int): # Allow single indices to be passed directly\n", " group = [group]\n", - " \n", + "\n", " # Set up circuit to measure all observables in this group\n", " circuit = state.copy()\n", " for term in group:\n", " circuit.sample(paulis[term])\n", - " \n", + "\n", " # Get measurements for all observables in the group\n", - " measurements = device.run(circuit, shots = shot_configuration[i]).result().values\n", - " \n", + " measurements = device.run(circuit, shots=shot_configuration[i]).result().values\n", + "\n", " # Process each observable's measurements\n", " for idx_in_group, idx_global in enumerate(group):\n", - " expectation_value += coeffs[idx_global]*np.mean(measurements[idx_in_group], dtype=float)\n", - " \n", + " expectation_value += coeffs[idx_global] * np.mean(\n", + " measurements[idx_in_group], dtype=float\n", + " )\n", + "\n", " return expectation_value" ] }, @@ -635,14 +703,20 @@ ], "source": [ "# Group ZI and IZ together, measure XX separately\n", - "grouped_optimal_values = [compute_grouped_expectation_value_approximation(uniform_superposition_state, [[0,1], 2], [1199, 1]) \n", - " for _ in range(1000)]\n", + "grouped_optimal_values = [\n", + " compute_grouped_expectation_value_approximation(\n", + " uniform_superposition_state, [[0, 1], 2], [1199, 1]\n", + " )\n", + " for _ in range(1000)\n", + "]\n", "\n", "grouped_mean = np.mean(grouped_optimal_values)\n", "grouped_std = np.std(grouped_optimal_values)\n", "\n", - "print(f\"Grouped optimal allocation ([1199, 1] shots for [[ZI,IZ], XX]):\\n\"\n", - " f\"Mean: {grouped_mean:.6f} ± {grouped_std:.6f}\")" + "print(\n", + " f\"Grouped optimal allocation ([1199, 1] shots for [[ZI,IZ], XX]):\\n\"\n", + " f\"Mean: {grouped_mean:.6f} ± {grouped_std:.6f}\"\n", + ")" ] }, { @@ -662,8 +736,14 @@ } ], "source": [ - "plot_histograms([optimal_values, grouped_optimal_values], [\"Optimal allocation (separate terms)\", \"Optimal allocation (grouped terms)\"],\n", - " [\"cyan\", \"green\"], exact_expectation, \"Comparison of Optimal Strategies\", y_max = 250)" + "plot_histograms(\n", + " [optimal_values, grouped_optimal_values],\n", + " [\"Optimal allocation (separate terms)\", \"Optimal allocation (grouped terms)\"],\n", + " [\"cyan\", \"green\"],\n", + " exact_expectation,\n", + " \"Comparison of Optimal Strategies\",\n", + " y_max=250,\n", + ")" ] }, { @@ -732,14 +812,15 @@ " run_adaptive_allocation,\n", ")\n", "\n", - "estimator = AdaptiveShotAllocator(['IZ', 'ZI', 'XX'], [1.0, 1.0, 10.0])\n", + "estimator = AdaptiveShotAllocator([\"IZ\", \"ZI\", \"XX\"], [1.0, 1.0, 10.0])\n", "\n", "adaptive_values = []\n", "\n", "for _ in tqdm(range(1000)):\n", " estimator.reset()\n", "\n", - " adaptive_values.append(estimator.expectation_from_measurements(\n", + " adaptive_values.append(\n", + " estimator.expectation_from_measurements(\n", " run_adaptive_allocation(device, uniform_superposition_state, estimator, 100, 12)\n", " )\n", " )" @@ -771,8 +852,14 @@ } ], "source": [ - "plot_histograms([grouped_optimal_values, adaptive_values], [\"Optimal allocation\", \"Adaptive allocation\"], [\"green\", \"cyan\"], \n", - " exact_expectation, \"Comparison of Optimal and Adaptive Shot Allocation Strategies\", y_max = 250)" + "plot_histograms(\n", + " [grouped_optimal_values, adaptive_values],\n", + " [\"Optimal allocation\", \"Adaptive allocation\"],\n", + " [\"green\", \"cyan\"],\n", + " exact_expectation,\n", + " \"Comparison of Optimal and Adaptive Shot Allocation Strategies\",\n", + " y_max=250,\n", + ")" ] }, { diff --git a/notebooks/advanced_algorithms/adaptive_shot_allocation/2_Adaptive_Shot_Allocation.ipynb b/notebooks/advanced_algorithms/adaptive_shot_allocation/2_Adaptive_Shot_Allocation.ipynb index 4938fcb3..86c37259 100644 --- a/notebooks/advanced_algorithms/adaptive_shot_allocation/2_Adaptive_Shot_Allocation.ipynb +++ b/notebooks/advanced_algorithms/adaptive_shot_allocation/2_Adaptive_Shot_Allocation.ipynb @@ -123,9 +123,15 @@ "\n", "estimator = AdaptiveShotAllocator(paulis, coeffs)\n", "\n", - "print(\"Identified commuting groups:\", [ [paulis[p] for p in commuting_group] for commuting_group in estimator.cliq])\n", + "print(\n", + " \"Identified commuting groups:\",\n", + " [[paulis[p] for p in commuting_group] for commuting_group in estimator.cliq],\n", + ")\n", "\n", - "print(\"Proposed allocation (shots per group) w/o prior measurement knowledge: \", estimator.incremental_shot_allocation(1200))" + "print(\n", + " \"Proposed allocation (shots per group) w/o prior measurement knowledge: \",\n", + " estimator.incremental_shot_allocation(1200),\n", + ")" ] }, { @@ -178,20 +184,21 @@ " # To that end, we keep track of the measurements in a 2-D array, recording the number of different outcomes.\n", " # DETAILS: `measurements[i][j][(-1,1)]`, for example, records the number of times observables `i` and `j`\n", " # were measured together and recorded values of `-1` adn `1` respectively.\n", - " measurements = [[{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0}\n", - " for _ in range(hamiltonian_terms)]\n", - " for _ in range(hamiltonian_terms)]\n", + " measurements = [\n", + " [{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0} for _ in range(hamiltonian_terms)]\n", + " for _ in range(hamiltonian_terms)\n", + " ]\n", "\n", " # STEP 2: Perform the measurements ()\n", " for shot_id in range(shots[0]):\n", " state = np.random.randint(4)\n", - " measurement_IZ = 1 - 2*(state%2)\n", - " measurement_ZI = 1 - 2*(state//2)\n", + " measurement_IZ = 1 - 2 * (state % 2)\n", + " measurement_ZI = 1 - 2 * (state // 2)\n", " measurements[0][0][(measurement_IZ, measurement_IZ)] += 1\n", " measurements[1][1][(measurement_ZI, measurement_ZI)] += 1\n", " measurements[0][1][(measurement_IZ, measurement_ZI)] += 1\n", - " measurements[1][0][(measurement_ZI, measurement_IZ)] += 1 \n", - " \n", + " measurements[1][0][(measurement_ZI, measurement_IZ)] += 1\n", + "\n", " for shot_id in range(shots[1]):\n", " measurement_XX = 1\n", " measurements[2][2][(measurement_XX, measurement_XX)] += 1\n", @@ -225,7 +232,9 @@ } ], "source": [ - "print(f\"Estimated expectation value: {estimator.expectation_from_measurements():.6f} ± {estimator.error_estimate():.6f}\")" + "print(\n", + " f\"Estimated expectation value: {estimator.expectation_from_measurements():.6f} ± {estimator.error_estimate():.6f}\"\n", + ")" ] }, { @@ -333,15 +342,64 @@ ], "source": [ "# Note that, as would be the case in practice, we have removed the IIII term and its cofficient from the calculations below\n", - "paulis = ['IIII', 'XXXI', 'XXXZ', 'XYYI', 'XZXI', 'XZXZ', 'YXYI', 'YXYZ', 'YYXI', 'YZYI', 'YZYZ', 'ZIII',\n", - " 'ZXZI', 'ZXZZ', 'ZXIZ', 'ZZII', 'ZZZI', 'ZZZZ', 'ZIZI', 'ZIZZ', 'IXII', 'IXZI', 'IXIZ', 'IZII',\n", - " 'IZZZ', 'IZIZ', 'IIZI'][1:]\n", - "coeffs = [-14.440090444958097, 0.01396784712709576, 0.0050449972385411684, 0.008922759379312662, 0.004572316311895031, \n", - " 0.004572316311895031, 0.01396784712709576, 0.0050449972385411684, -0.008922759379312662, 0.004572316311895031, \n", - " 0.004572316311895031, 0.37322478932293823, 0.01396784712709576, 0.0050449972385411684, -0.008922759379312663, \n", - " 0.37322478932293823, 0.06754531038829523, 0.06754531038829523, 0.0629729940764002, 0.0629729940764002, \n", - " -0.0050449972385411684, 0.008922759379312663, -0.01396784712709576, 0.1377331477309217, 0.18592768458263145, \n", - " 0.10062930161995226, 0.18592768458263148][1:]\n", + "paulis = [\n", + " \"IIII\",\n", + " \"XXXI\",\n", + " \"XXXZ\",\n", + " \"XYYI\",\n", + " \"XZXI\",\n", + " \"XZXZ\",\n", + " \"YXYI\",\n", + " \"YXYZ\",\n", + " \"YYXI\",\n", + " \"YZYI\",\n", + " \"YZYZ\",\n", + " \"ZIII\",\n", + " \"ZXZI\",\n", + " \"ZXZZ\",\n", + " \"ZXIZ\",\n", + " \"ZZII\",\n", + " \"ZZZI\",\n", + " \"ZZZZ\",\n", + " \"ZIZI\",\n", + " \"ZIZZ\",\n", + " \"IXII\",\n", + " \"IXZI\",\n", + " \"IXIZ\",\n", + " \"IZII\",\n", + " \"IZZZ\",\n", + " \"IZIZ\",\n", + " \"IIZI\",\n", + "][1:]\n", + "coeffs = [\n", + " -14.440090444958097,\n", + " 0.01396784712709576,\n", + " 0.0050449972385411684,\n", + " 0.008922759379312662,\n", + " 0.004572316311895031,\n", + " 0.004572316311895031,\n", + " 0.01396784712709576,\n", + " 0.0050449972385411684,\n", + " -0.008922759379312662,\n", + " 0.004572316311895031,\n", + " 0.004572316311895031,\n", + " 0.37322478932293823,\n", + " 0.01396784712709576,\n", + " 0.0050449972385411684,\n", + " -0.008922759379312663,\n", + " 0.37322478932293823,\n", + " 0.06754531038829523,\n", + " 0.06754531038829523,\n", + " 0.0629729940764002,\n", + " 0.0629729940764002,\n", + " -0.0050449972385411684,\n", + " 0.008922759379312663,\n", + " -0.01396784712709576,\n", + " 0.1377331477309217,\n", + " 0.18592768458263145,\n", + " 0.10062930161995226,\n", + " 0.18592768458263148,\n", + "][1:]\n", "\n", "print(\"4-qubit BeH Hamiltonian (electronic, Bravyi-Kitaev mapping).\")\n", "print(f\"Number of qubits: {len(paulis[0])}\")\n", @@ -500,7 +558,9 @@ "print(f\"Estimated expectation: {e_estimated:.6f}\")\n", "print(f\"Estimated standard error: {error_estimate:.6f}\")\n", "\n", - "print(f\"Actual difference: {abs(e_exact - e_estimated):.6f} ({100*abs(e_exact - e_estimated)/abs(e_exact):.2f}%)\")\n", + "print(\n", + " f\"Actual difference: {abs(e_exact - e_estimated):.6f} ({100 * abs(e_exact - e_estimated) / abs(e_exact):.2f}%)\"\n", + ")\n", "print(f\"Final shot allocation: {estimator.shots}\")\n", "print(f\"Total shots used: {sum(estimator.shots)}\")" ] @@ -592,34 +652,29 @@ "\n", "# Run comparison\n", "num_runs = 50\n", - "results = {\n", - " 'Random': [],\n", - " 'Uniform': [],\n", - " 'Weighted': [],\n", - " 'Adaptive': [] \n", - "}\n", + "results = {\"Random\": [], \"Uniform\": [], \"Weighted\": [], \"Adaptive\": []}\n", "\n", "print(f\"Running {num_runs} trials for each strategy...\")\n", "for i in tqdm(range(num_runs)):\n", " # Reset the allocator every time so that we don't take advantage of prior measurement knowledge\n", " estimator.reset()\n", - " \n", - " results['Adaptive'].append(\n", + "\n", + " results[\"Adaptive\"].append(\n", " estimator.expectation_from_measurements(\n", " run_adaptive_allocation(device, circuit, estimator, shots_per_round, num_rounds)\n", " )\n", " )\n", - " results['Uniform'].append(\n", + " results[\"Uniform\"].append(\n", " estimator.expectation_from_measurements(\n", " run_fixed_allocation(device, circuit, estimator, uniform_shots)\n", " )\n", " )\n", - " results['Random'].append(\n", + " results[\"Random\"].append(\n", " estimator.expectation_from_measurements(\n", " run_fixed_allocation(device, circuit, estimator, random_shots)\n", " )\n", " )\n", - " results['Weighted'].append(\n", + " results[\"Weighted\"].append(\n", " estimator.expectation_from_measurements(\n", " run_fixed_allocation(device, circuit, estimator, weighted_shots)\n", " )\n", @@ -693,14 +748,9 @@ "# Plot results with separate subplots (squashed aspect ratio)\n", "fig, axes = plt.subplots(4, 1, figsize=(10, 6), sharex=True)\n", "\n", - "colors = {\n", - " 'Random': 'red', \n", - " 'Uniform': 'orange',\n", - " 'Weighted': 'blue',\n", - " 'Adaptive': 'green' \n", - "}\n", + "colors = {\"Random\": \"red\", \"Uniform\": \"orange\", \"Weighted\": \"blue\", \"Adaptive\": \"green\"}\n", "\n", - "strategies = ['Random', 'Uniform', 'Weighted', 'Adaptive']\n", + "strategies = [\"Random\", \"Uniform\", \"Weighted\", \"Adaptive\"]\n", "\n", "# First pass: calculate all histograms to find the maximum bar height\n", "bins = np.arange(0.0, 0.05, 0.001)\n", @@ -716,35 +766,44 @@ "for i, strategy in enumerate(strategies):\n", " values = results[strategy]\n", " errors = np.abs(np.array(values) - e_exact)\n", - " \n", + "\n", " # Plot histogram in the corresponding subplot\n", - " axes[i].hist(errors, bins=bins, \n", - " color=colors[strategy], alpha=0.7, edgecolor='black', linewidth=0.5,\n", - " label=strategy)\n", - " \n", + " axes[i].hist(\n", + " errors,\n", + " bins=bins,\n", + " color=colors[strategy],\n", + " alpha=0.7,\n", + " edgecolor=\"black\",\n", + " linewidth=0.5,\n", + " label=strategy,\n", + " )\n", + "\n", " # Add statistics as legend\n", " mean_error = np.mean(errors)\n", " std_error = np.std(errors)\n", - " \n", - " axes[i].set_ylabel('Frequency')\n", + "\n", + " axes[i].set_ylabel(\"Frequency\")\n", " axes[i].grid(True, alpha=0.3)\n", - " \n", + "\n", " # Set aspect ratio and y-axis limits\n", - " axes[i].set_aspect(aspect='auto')\n", + " axes[i].set_aspect(aspect=\"auto\")\n", " axes[i].set_ylim(0, max_height * 1.05) # Add 5% padding at top\n", - " \n", + "\n", " # Set integer y-ticks\n", " axes[i].yaxis.set_major_locator(MaxNLocator(integer=True))\n", - " \n", + "\n", " # Add legend with strategy name and statistics\n", - " axes[i].legend([f'{strategy} (Mean: {mean_error:.6f}, Std: {std_error:.6f})'], \n", - " loc='upper right', framealpha=0.9)\n", + " axes[i].legend(\n", + " [f\"{strategy} (Mean: {mean_error:.6f}, Std: {std_error:.6f})\"],\n", + " loc=\"upper right\",\n", + " framealpha=0.9,\n", + " )\n", "\n", "# Set common x-label only on the bottom subplot\n", - "axes[-1].set_xlabel('Absolute Error')\n", + "axes[-1].set_xlabel(\"Absolute Error\")\n", "\n", "# Add overall title with more space\n", - "fig.suptitle('Distribution of Estimation Errors by Strategy', fontsize=16, y=0.98)\n", + "fig.suptitle(\"Distribution of Estimation Errors by Strategy\", fontsize=16, y=0.98)\n", "\n", "plt.tight_layout()\n", "plt.subplots_adjust(top=0.93) # Add space between suptitle and subplots\n", @@ -767,35 +826,46 @@ "def visualize_shot_allocation_comparison(strategies, allocations, total_shots):\n", " \"\"\"\n", " Visualize different shot allocation strategies for comparison.\n", - " \n", + "\n", " Args:\n", " strategies (list): Names of the strategies to compare\n", " allocations (list): List of shot allocations for each strategy\n", " total_shots (int): Total number of shots used\n", " \"\"\"\n", " plt.figure(figsize=(12, 6))\n", - " \n", + "\n", " # Create a bar chart for each strategy\n", " x = np.arange(len(allocations[0]))\n", " width = 0.8 / len(strategies)\n", - " \n", + "\n", " for i, (strategy, allocation) in enumerate(zip(strategies, allocations)):\n", - " plt.bar(x + i*width - 0.4 + width/2, allocation, width, \n", - " label=strategy, alpha=0.7, color = colors[strategy])\n", - " \n", - " plt.xlabel('Measurement Group')\n", - " plt.ylabel('Number of Shots')\n", - " plt.title(f'Comparison of Shot Allocation Strategies (Total: {total_shots} shots)')\n", - " plt.xticks(x, [f'Group {i+1}' for i in x])\n", + " plt.bar(\n", + " x + i * width - 0.4 + width / 2,\n", + " allocation,\n", + " width,\n", + " label=strategy,\n", + " alpha=0.7,\n", + " color=colors[strategy],\n", + " )\n", + "\n", + " plt.xlabel(\"Measurement Group\")\n", + " plt.ylabel(\"Number of Shots\")\n", + " plt.title(f\"Comparison of Shot Allocation Strategies (Total: {total_shots} shots)\")\n", + " plt.xticks(x, [f\"Group {i + 1}\" for i in x])\n", " plt.legend()\n", " plt.grid(True, alpha=0.3)\n", - " \n", + "\n", " # Add percentages on top of each bar\n", " for i, (strategy, allocation) in enumerate(zip(strategies, allocations)):\n", " for j, shots in enumerate(allocation):\n", " percentage = 100 * shots / total_shots\n", - " plt.text(j + i*width - 0.4 + width/2, shots + 5, \n", - " f'{percentage:.1f}%', ha='center', fontsize=8)" + " plt.text(\n", + " j + i * width - 0.4 + width / 2,\n", + " shots + 5,\n", + " f\"{percentage:.1f}%\",\n", + " ha=\"center\",\n", + " fontsize=8,\n", + " )" ] }, { @@ -815,7 +885,11 @@ } ], "source": [ - "visualize_shot_allocation_comparison([strategy for strategy in results.keys()], [random_shots, uniform_shots, weighted_shots, estimator.shots], sum(uniform_shots))" + "visualize_shot_allocation_comparison(\n", + " [strategy for strategy in results.keys()],\n", + " [random_shots, uniform_shots, weighted_shots, estimator.shots],\n", + " sum(uniform_shots),\n", + ")" ] }, { diff --git a/notebooks/advanced_algorithms/adaptive_shot_allocation/adaptive_allocation_notebook_helpers.py b/notebooks/advanced_algorithms/adaptive_shot_allocation/adaptive_allocation_notebook_helpers.py index dd2299e8..f1f3858a 100644 --- a/notebooks/advanced_algorithms/adaptive_shot_allocation/adaptive_allocation_notebook_helpers.py +++ b/notebooks/advanced_algorithms/adaptive_shot_allocation/adaptive_allocation_notebook_helpers.py @@ -1,4 +1,3 @@ - from typing import List import numpy as np @@ -15,6 +14,7 @@ _localSim = LocalSimulator() + def create_random_state(num_qubits: int = 4) -> Circuit: """ Generate a quantum circuit with random rotations and entanglement. @@ -33,7 +33,7 @@ def create_random_state(num_qubits: int = 4) -> Circuit: # Entangling layer for i in range(num_qubits - 1): - circ.cnot(control=i, target=i+1) + circ.cnot(control=i, target=i + 1) # Second layer of rotations for i in range(num_qubits): @@ -73,10 +73,12 @@ def get_exact_expectation(circuit: Circuit, paulis: List[str], coeffs: List[floa e_exact += c * result.values[0] return e_exact + """ Utilities for allocating measurement shots across different measurement groups. """ + def get_uniform_shots(num_groups: int, total_shots: int) -> List[int]: """ Generate uniform shot allocation across measurement groups. @@ -132,4 +134,3 @@ def get_weighted_shots(cliq: List[List[int]], coeffs: List[float], total_shots: for i in range(remainder): shots[i] += 1 return shots.tolist() - diff --git a/notebooks/textbook/CHSH_Inequality.ipynb b/notebooks/textbook/CHSH_Inequality.ipynb index eeffbfee..b19944d0 100644 --- a/notebooks/textbook/CHSH_Inequality.ipynb +++ b/notebooks/textbook/CHSH_Inequality.ipynb @@ -455,7 +455,7 @@ ], "source": [ "print(\n", - " f\"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost() :.2f} USD\"\n", + " f\"Estimated cost to run this example: {tracker.qpu_tasks_cost() + tracker.simulator_tasks_cost():.2f} USD\"\n", ")" ] }, diff --git a/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator.py b/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator.py index f1fd03b8..0780e281 100644 --- a/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator.py +++ b/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator.py @@ -33,7 +33,7 @@ def commute(a: str, b: str, qwc: bool = True) -> bool: Raises: ValueError: If the Pauli strigns are of different length. """ - if len(a)!=len(b): + if len(a) != len(b): raise ValueError("Pauli strings must be of the same length.") count = 0 for i in zip(a, b): @@ -42,15 +42,17 @@ def commute(a: str, b: str, qwc: bool = True) -> bool: # Partial functions for specific commutation checks -qwc_commute = partial(commute, qwc=True) # Qubit-wise commutation -gen_commute = partial(commute, qwc=False) # General commutation +qwc_commute = partial(commute, qwc=True) # Qubit-wise commutation +gen_commute = partial(commute, qwc=False) # General commutation # BAYESIAN STATISTICS (closed formulas from Appendix B of arXiv:2110.15339v6) -def term_variance_estimate(term_idx: int, measurements: Union[MeasurementData, None] = None) -> float: +def term_variance_estimate( + term_idx: int, measurements: Union[MeasurementData, None] = None +) -> float: """ - Estimate variance for a single Pauli term. + Estimate variance for a single Pauli term. See Eq 14 in Appendix B of "Adaptive Estimation of Quantum Observables (arXiv:2110.15339v6) Args: @@ -64,10 +66,12 @@ def term_variance_estimate(term_idx: int, measurements: Union[MeasurementData, N if measurements: x0 = measurements[term_idx][term_idx][(1, 1)] x1 = measurements[term_idx][term_idx][(-1, -1)] - return 4*((x0+1)*(x1+1))/((x0+x1+2)*(x0+x1+3)) + return 4 * ((x0 + 1) * (x1 + 1)) / ((x0 + x1 + 2) * (x0 + x1 + 3)) -def terms_covariance_estimate(i: int, j: int, measurements: Union[MeasurementData, None] = None) -> float: +def terms_covariance_estimate( + i: int, j: int, measurements: Union[MeasurementData, None] = None +) -> float: """ Estimate covariance between two Pauli terms. See Eq 25-6 in Appendix B of "Adaptive Estimation of Quantum Observables (arXiv:2110.15339v6) @@ -93,14 +97,17 @@ def terms_covariance_estimate(i: int, j: int, measurements: Union[MeasurementDat xy11 = measurements[i][j][(-1, -1)] # Calculate prior probabilities - p00 = 4*((x0+1)*(y0+1))/((x0+x1+2)*(y0+y1+2)) - p01 = 4*((x0+1)*(y1+1))/((x0+x1+2)*(y0+y1+2)) - p10 = 4*((x1+1)*(y0+1))/((x0+x1+2)*(y0+y1+2)) - p11 = 4*((x1+1)*(y1+1))/((x0+x1+2)*(y0+y1+2)) + p00 = 4 * ((x0 + 1) * (y0 + 1)) / ((x0 + x1 + 2) * (y0 + y1 + 2)) + p01 = 4 * ((x0 + 1) * (y1 + 1)) / ((x0 + x1 + 2) * (y0 + y1 + 2)) + p10 = 4 * ((x1 + 1) * (y0 + 1)) / ((x0 + x1 + 2) * (y0 + y1 + 2)) + p11 = 4 * ((x1 + 1) * (y1 + 1)) / ((x0 + x1 + 2) * (y0 + y1 + 2)) # Return Bayesian covariance estimate - return 4*((xy00+p00)*(xy11+p11) - (xy01+p01)*(xy10+p10)) / \ - ((xy00+xy01+xy10+xy11+4)*(xy00+xy01+xy10+xy11+5)) + return ( + 4 + * ((xy00 + p00) * (xy11 + p11) - (xy01 + p01) * (xy10 + p10)) + / ((xy00 + xy01 + xy10 + xy11 + 4) * (xy00 + xy01 + xy10 + xy11 + 5)) + ) class AdaptiveShotAllocator: @@ -156,11 +163,10 @@ def __init__(self, paulis: List[str], coeffs: List[float]) -> None: raise ValueError("Number of Paulis must match coefficients") # Validate Pauli strings - valid_chars = set('IXYZ') + valid_chars = set("IXYZ") for pauli in paulis: if not set(pauli).issubset(valid_chars): - raise ValueError( - f"Invalid Pauli string: {pauli}. Must only contain I, X, Y, or Z") + raise ValueError(f"Invalid Pauli string: {pauli}. Must only contain I, X, Y, or Z") self.paulis = paulis self.coeffs = coeffs self.graph = self._generate_graph() @@ -179,9 +185,10 @@ def reset(self): - Updates graph weights to initial values """ # Initialize measurement counts for all term pairs - self.measurements = [[{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0} - for _ in range(self.num_terms)] - for _ in range(self.num_terms)] + self.measurements = [ + [{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0} for _ in range(self.num_terms)] + for _ in range(self.num_terms) + ] self.shots = None # Clear shot allocation history self._update_graph_weights() # Reset graph weights @@ -201,7 +208,9 @@ def _generate_graph(self, commute: Callable[[str, str], bool] = qwc_commute): Edges are added between terms that commute according to the provided function. """ if commute != qwc_commute: - warnings.warn("Braket only supports simultaneous measurement of qubit-wise commuting operators.") + warnings.warn( + "Braket only supports simultaneous measurement of qubit-wise commuting operators." + ) # Create graph and add nodes with Pauli string labels self.graph = nx.Graph() @@ -229,8 +238,9 @@ def _partition_graph(self): _, cliq = approximation.clique_removal(self.graph) self.cliq = [sorted(i) for i in cliq] # Sort cliques for consistency - def visualize_graph(self, node_size: int = 1230, font_size: int = 10, - show_cliques: bool = True) -> None: + def visualize_graph( + self, node_size: int = 1230, font_size: int = 10, show_cliques: bool = True + ) -> None: """ Visualize the graph with colored edges based on clique membership. @@ -242,15 +252,17 @@ def visualize_graph(self, node_size: int = 1230, font_size: int = 10, """ # Generate random colors for each clique - cliq_colors = ["#"+"".join([hex(random.randint(0, 255))[2:].zfill(2) - for _ in range(3)]) for _ in self.cliq] + cliq_colors = [ + "#" + "".join([hex(random.randint(0, 255))[2:].zfill(2) for _ in range(3)]) + for _ in self.cliq + ] # Build edge list and colors if show_cliques: el = [] ec = [] for e in self.graph.edges: - for i,c in enumerate(self.cliq): + for i, c in enumerate(self.cliq): if (e[0] in c) and (e[1] in c): el.append(e) ec.append(cliq_colors[i]) @@ -258,23 +270,32 @@ def visualize_graph(self, node_size: int = 1230, font_size: int = 10, else: el = list(self.graph.edges) # Use gray for all edges when showing full graph - ec = ['gray' for _ in el] + ec = ["gray" for _ in el] # Create layout pos = nx.circular_layout(self.graph) # Draw the graph plt.figure(figsize=(10, 10)) - nx.draw(self.graph, pos=pos, with_labels=False, - node_color='white', node_size=node_size, - edgelist=el, edge_color=ec) + nx.draw( + self.graph, + pos=pos, + with_labels=False, + node_color="white", + node_size=node_size, + edgelist=el, + edge_color=ec, + ) # Add labels - nx.draw_networkx_labels(self.graph, pos, - labels=nx.get_node_attributes( - self.graph, 'label'), - font_size=font_size, font_color="black", - font_family="Times") + nx.draw_networkx_labels( + self.graph, + pos, + labels=nx.get_node_attributes(self.graph, "label"), + font_size=font_size, + font_color="black", + font_family="Times", + ) # Set edge colors ax = plt.gca() @@ -299,9 +320,12 @@ def _update_graph_weights(self) -> None: # Base weight from coefficients weight = self.coeffs[i] * self.coeffs[j] # Multiply by variance/covariance estimate - weight *= (term_variance_estimate(i, measurements) if i == j - else terms_covariance_estimate(i, j, measurements)) - self.graph[i][j]['weight'] = weight + weight *= ( + term_variance_estimate(i, measurements) + if i == j + else terms_covariance_estimate(i, j, measurements) + ) + self.graph[i][j]["weight"] = weight def incremental_shot_allocation(self, num_shots: int) -> List[int]: """ @@ -337,13 +361,14 @@ def incremental_shot_allocation(self, num_shots: int) -> List[int]: current_shots = self.shots if self.shots else [0 for c in self.cliq] # Calculate weighted covariance matrix for error estimates - weighted_covariance = nx.adjacency_matrix( - self.graph, weight="weight").toarray() + weighted_covariance = nx.adjacency_matrix(self.graph, weight="weight").toarray() # Initialize error estimates for each clique using current shots # Error = sqrt(sum of covariances) / number of shots - clique_error = [np.sqrt(weighted_covariance[c, c].sum())/(current_shots[e] or not current_shots[e]) - for e, c in enumerate(self.cliq)] + clique_error = [ + np.sqrt(weighted_covariance[c, c].sum()) / (current_shots[e] or not current_shots[e]) + for e, c in enumerate(self.cliq) + ] # Allocate shots one at a time for _ in range(num_shots): @@ -356,8 +381,7 @@ def incremental_shot_allocation(self, num_shots: int) -> List[int]: # Update error estimate for the chosen clique # New error = Old error * (n/(n+1)) where n+1 is the updated shot count. total_shots = current_shots[cliq_id] + proposed_allocation[cliq_id] - clique_error[cliq_id] *= ((total_shots-1) - or not (total_shots-1))/(total_shots) + clique_error[cliq_id] *= ((total_shots - 1) or not (total_shots - 1)) / (total_shots) return proposed_allocation @@ -379,18 +403,23 @@ def error_estimate(self) -> float: ValueError: If graph weights have not been properly initialized """ # Get weighted covariance matrix - weighted_covariance = nx.adjacency_matrix( - self.graph, weight="weight").toarray() + weighted_covariance = nx.adjacency_matrix(self.graph, weight="weight").toarray() # Sum variance contributions from each clique - variance_estimate = sum([(weighted_covariance[c, c].sum())/(self.shots[e] or not self.shots[e]) - for e, c in enumerate(self.cliq)]) + variance_estimate = sum( + [ + (weighted_covariance[c, c].sum()) / (self.shots[e] or not self.shots[e]) + for e, c in enumerate(self.cliq) + ] + ) return np.sqrt(variance_estimate) - def expectation_from_measurements(self, measurements: Union[MeasurementData, None] = None) -> float: + def expectation_from_measurements( + self, measurements: Union[MeasurementData, None] = None + ) -> float: """ - Calculate the energy expectation value from measurement results + Calculate the energy expectation value from measurement results for the different Pauli string observables. For each Pauli term, computes

= (N++ - N--)/N_total where: @@ -414,17 +443,15 @@ def expectation_from_measurements(self, measurements: Union[MeasurementData, Non expectation = 0.0 for i in range(len(self.coeffs)): # Verify no invalid measurements - assert measurements[i][i][( - 1, -1)] == 0, "Invalid measurement detected: (+1,-1)" - assert measurements[i][i][(-1, 1) - ] == 0, "Invalid measurement detected: (-1,+1)" + assert measurements[i][i][(1, -1)] == 0, "Invalid measurement detected: (+1,-1)" + assert measurements[i][i][(-1, 1)] == 0, "Invalid measurement detected: (-1,+1)" # Calculate expectation for this term - term_shots = measurements[i][i][( - 1, 1)] + measurements[i][i][(-1, -1)] + term_shots = measurements[i][i][(1, 1)] + measurements[i][i][(-1, -1)] if term_shots: term_expect = ( - measurements[i][i][(1, 1)] - measurements[i][i][(-1, -1)]) / term_shots + measurements[i][i][(1, 1)] - measurements[i][i][(-1, -1)] + ) / term_shots expectation += self.coeffs[i] * term_expect return expectation @@ -447,13 +474,11 @@ def _validate_measurements(self, measurements: MeasurementData) -> bool: Raises: AssertionError: If any validation check fails """ - assert len( - measurements) == self.num_terms, "Wrong number of measurement records" + assert len(measurements) == self.num_terms, "Wrong number of measurement records" for c in self.cliq: # Get total shots for this clique - m_cliq = (measurements[c[0]][c[0]][(1, 1)] + - measurements[c[0]][c[0]][(-1, -1)]) + m_cliq = measurements[c[0]][c[0]][(1, 1)] + measurements[c[0]][c[0]][(-1, -1)] # Check consistency within clique for i in c: @@ -463,25 +488,31 @@ def _validate_measurements(self, measurements: MeasurementData) -> bool: assert v >= 0, "Measurement counts should not be negative" # Measurements should be symmetric - assert measurements[i][j][(1,1)]==measurements[j][i][(1,1)],\ - "Measurement should be symmetric" - assert measurements[i][j][(-1,-1)]==measurements[j][i][(-1,-1)],\ - "Measurement should be symmetric" - assert measurements[i][j][(1,-1)]==measurements[j][i][(-1,1)],\ - "Measurement should be symmetric" - assert measurements[i][j][(-1,1)]==measurements[j][i][(1,-1)],\ - "Measurement should be symmetric" + assert measurements[i][j][(1, 1)] == measurements[j][i][(1, 1)], ( + "Measurement should be symmetric" + ) + assert measurements[i][j][(-1, -1)] == measurements[j][i][(-1, -1)], ( + "Measurement should be symmetric" + ) + assert measurements[i][j][(1, -1)] == measurements[j][i][(-1, 1)], ( + "Measurement should be symmetric" + ) + assert measurements[i][j][(-1, 1)] == measurements[j][i][(1, -1)], ( + "Measurement should be symmetric" + ) # All pairs in clique should have same total measurements - assert m_cliq == sum(measurements[i][j].values()), \ - (f"The number of times {i} and {j} were measured together should be " - "equal to the number of measurements of their clique.") + assert m_cliq == sum(measurements[i][j].values()), ( + f"The number of times {i} and {j} were measured together should be " + "equal to the number of measurements of their clique." + ) # Diagonal elements should not have invalid combinations if i == j: - assert measurements[i][i][(1, -1)] == measurements[i][i][(-1, 1)] == 0, \ - ("A measurement of a single term can only contribute to the " - "(1,1) or (-1,-1) counts.") + assert measurements[i][i][(1, -1)] == measurements[i][i][(-1, 1)] == 0, ( + "A measurement of a single term can only contribute to the " + "(1,1) or (-1,-1) counts." + ) return True def shots_from_measurements(self, measurements: MeasurementData) -> List[int]: diff --git a/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator_braket_helpers.py b/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator_braket_helpers.py index 6cb8017a..ea8f2125 100644 --- a/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator_braket_helpers.py +++ b/src/braket/experimental/algorithms/adaptive_shot_allocation/adaptive_allocator_braket_helpers.py @@ -1,5 +1,5 @@ """ -Helper functions to handle quantum measurements and adaptive shot allocation +Helper functions to handle quantum measurements and adaptive shot allocation experiments on Amazon Braket. """ @@ -13,6 +13,7 @@ MeasurementData, ) + def observable_from_string(pauli_string: str) -> Observable: """ Convert Pauli string to Braket observable. @@ -23,15 +24,15 @@ def observable_from_string(pauli_string: str) -> Observable: Returns: Observable: Corresponding Braket observable """ - gates = {"I": Observable.I, "X": Observable.X, - "Y": Observable.Y, "Z": Observable.Z} + gates = {"I": Observable.I, "X": Observable.X, "Y": Observable.Y, "Z": Observable.Z} return Observable.TensorProduct([gates[i[1]](i[0]) for i in enumerate(pauli_string)]) + def run_fixed_allocation( device: Union[LocalSimulator, AwsDevice], circuit: Circuit, estimator: AdaptiveShotAllocator, - shot_allocation: List[int] + shot_allocation: List[int], ) -> MeasurementData: """ Run experiment with a specific shot allocation. @@ -45,7 +46,7 @@ def run_fixed_allocation( Returns: MeasurementData: Measurement outcomes for each term pair """ - + # Step 1. Submit all tasks. tasks = {} for c_idx, c in enumerate(estimator.cliq): @@ -54,41 +55,40 @@ def run_fixed_allocation( measurement_circ = circuit.copy() for p in c: - measurement_circ.sample( - observable_from_string(estimator.paulis[p])) + measurement_circ.sample(observable_from_string(estimator.paulis[p])) + + tasks[c_idx] = device.run(measurement_circ, shots=shot_allocation[c_idx]) - tasks[c_idx] = device.run( - measurement_circ, shots=shot_allocation[c_idx]) - # Step 2. Post-process results. - measurements = [[{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0} - for _ in range(len(estimator.paulis))] - for _ in range(len(estimator.paulis))] - - while(tasks): + measurements = [ + [{(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0} for _ in range(len(estimator.paulis))] + for _ in range(len(estimator.paulis)) + ] + + while tasks: task_to_process = None - + for c_idx in tasks: # Check task status state = tasks[c_idx].state() - assert state in ["CREATED", "QUEUED", "RUNNING", "COMPLETED"], \ + assert state in ["CREATED", "QUEUED", "RUNNING", "COMPLETED"], ( f"Encountered quantum task failure (status: {state})." + ) if state == "COMPLETED": task_to_process = c_idx break - + if task_to_process is None: continue - + # Task is ready for post-processing result = tasks[task_to_process].result() c = estimator.cliq[task_to_process] for i_idx, i in enumerate(c): for j_idx, j in enumerate(c): for s in range(len(result.values[i_idx])): - measurements[i][j][(result.values[i_idx][s], - result.values[j_idx][s])] += 1 + measurements[i][j][(result.values[i_idx][s], result.values[j_idx][s])] += 1 # Remove task from the queue tasks.pop(task_to_process) @@ -101,7 +101,7 @@ def run_adaptive_allocation( estimator: AdaptiveShotAllocator, shots_per_round: int, num_rounds: int, - verbose: bool = False + verbose: bool = False, ) -> MeasurementData: """ Run adaptive shot allocation process. @@ -118,14 +118,12 @@ def run_adaptive_allocation( MeasurementData: Final measurement outcomes """ if verbose: - print( - f"Running {num_rounds} rounds with {shots_per_round} shots each:") + print(f"Running {num_rounds} rounds with {shots_per_round} shots each:") for i in range(num_rounds): if verbose: - print(f"Round {i+1}/{num_rounds}...") + print(f"Round {i + 1}/{num_rounds}...") shots_to_run = estimator.incremental_shot_allocation(shots_per_round) - new_measurements = run_fixed_allocation( - device, circuit, estimator, shots_to_run) + new_measurements = run_fixed_allocation(device, circuit, estimator, shots_to_run) estimator.update_measurements(new_measurements) return estimator.measurements diff --git a/src/braket/experimental/algorithms/hhl/__init__.py b/src/braket/experimental/algorithms/hhl/__init__.py index c9c62c45..1012284c 100644 --- a/src/braket/experimental/algorithms/hhl/__init__.py +++ b/src/braket/experimental/algorithms/hhl/__init__.py @@ -12,7 +12,7 @@ # language governing permissions and limitations under the License. from braket.experimental.algorithms.hhl.hhl import ( # noqa: F401,E501 + get_hhl_results, hhl_circuit, run_hhl, - get_hhl_results, ) diff --git a/src/braket/experimental/algorithms/hhl/hhl.py b/src/braket/experimental/algorithms/hhl/hhl.py index 67ea7560..09a9ac8f 100644 --- a/src/braket/experimental/algorithms/hhl/hhl.py +++ b/src/braket/experimental/algorithms/hhl/hhl.py @@ -36,12 +36,11 @@ """ import math -from typing import Any, Dict, List, Optional, Tuple +from typing import Any, Dict, Optional, Tuple import numpy as np -from braket.circuits import Circuit, Instruction, circuit -from braket.circuits.gates import Unitary +from braket.circuits import Circuit, circuit from braket.circuits.qubit_set import QubitSetInput from braket.devices import Device from braket.tasks import QuantumTask @@ -340,9 +339,7 @@ def _controlled_rotation( _add_controlled_ry(circ, clock_qubits[0], ancilla_qubit, theta) elif num_clock_qubits == 2: # Use both clock qubits as controls - _add_doubly_controlled_ry( - circ, clock_qubits[0], clock_qubits[1], ancilla_qubit, theta - ) + _add_doubly_controlled_ry(circ, clock_qubits[0], clock_qubits[1], ancilla_qubit, theta) else: # General case: use multi-controlled approach _add_multi_controlled_ry(circ, clock_qubits, ancilla_qubit, theta) @@ -355,9 +352,7 @@ def _controlled_rotation( return circ -def _add_controlled_ry( - circ: Circuit, control: int, target: int, theta: float -) -> None: +def _add_controlled_ry(circ: Circuit, control: int, target: int, theta: float) -> None: """Add a controlled-Ry gate to the circuit. Decomposition: C-Ry(theta) = Ry(theta/2) . CNOT . Ry(-theta/2) . CNOT @@ -458,7 +453,7 @@ def _inverse_qpe_for_hhl( # Construct explicit Controlled-Unitary cu_matrix_inv = _construct_controlled_unitary_matrix(unitary_inv) - + # Apply CUinv circ.unitary(matrix=cu_matrix_inv, targets=[clock_qubit, input_qubit], display_name="CU†") @@ -640,7 +635,6 @@ def get_hhl_results( """ result = task.result() measurement_counts = result.measurement_counts - total_num_qubits = num_clock_qubits + 2 # clock + input + ancilla # Compute classical solution for comparison b_norm = np.linalg.norm(b_vector) @@ -678,10 +672,12 @@ def get_hhl_results( success_probability = success_shots / total_shots if total_shots > 0 else 0.0 # Compute fidelity between quantum result and classical solution - quantum_probs = np.array([ - solution_state_probs.get("0", 0.0), - solution_state_probs.get("1", 0.0), - ]) + quantum_probs = np.array( + [ + solution_state_probs.get("0", 0.0), + solution_state_probs.get("1", 0.0), + ] + ) classical_probs = np.abs(classical_solution_normalized) ** 2 # Fidelity F = (sum sqrt(p_i * q_i))^2 @@ -704,9 +700,7 @@ def get_hhl_results( print(f"Matrix A:\n{matrix}") print(f"\nVector b: {b_vector}") print(f"\nClassical solution x = A^(-1)b: {classical_solution}") - print( - f"Classical solution (normalized): {classical_solution_normalized}" - ) + print(f"Classical solution (normalized): {classical_solution_normalized}") print(f"Classical probabilities |x_i|^2: {classical_probs}") print(f"\nTotal measurement shots: {total_shots}") print(f"Post-selection success shots: {success_shots}") diff --git a/test/unit_tests/braket/experimental/algorithms/adaptive_shot_allocation/test_adaptive_allocator.py b/test/unit_tests/braket/experimental/algorithms/adaptive_shot_allocation/test_adaptive_allocator.py index 3d02a80a..c361e45b 100644 --- a/test/unit_tests/braket/experimental/algorithms/adaptive_shot_allocation/test_adaptive_allocator.py +++ b/test/unit_tests/braket/experimental/algorithms/adaptive_shot_allocation/test_adaptive_allocator.py @@ -3,9 +3,12 @@ import unittest from braket.experimental.algorithms.adaptive_shot_allocation.adaptive_allocator import ( - commute, qwc_commute, gen_commute, - term_variance_estimate, terms_covariance_estimate, - AdaptiveShotAllocator + commute, + qwc_commute, + gen_commute, + term_variance_estimate, + terms_covariance_estimate, + AdaptiveShotAllocator, ) from unittest.mock import patch @@ -30,14 +33,15 @@ def mock_measurements_2terms(): return [ [ {(1, 1): 5, (1, -1): 0, (-1, 1): 0, (-1, -1): 5}, - {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 4} + {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 4}, ], [ {(1, 1): 3, (1, -1): 1, (-1, 1): 2, (-1, -1): 4}, - {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4} - ] + {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4}, + ], ] + # 1. Tests for Helper Functions @@ -77,13 +81,12 @@ def test_partial_commute_functions(): def test_term_variance_estimate(): # Test with no measurements (prior only) # With no measurements, the formula gives 4*(1*1)/(2*3) = 4/6 = 2/3 - assert abs(term_variance_estimate(0) - 2/3) < 1e-10 + assert abs(term_variance_estimate(0) - 2 / 3) < 1e-10 # Test with mock measurements mock_measurements = [[{(1, 1): 10, (1, -1): 0, (-1, 1): 0, (-1, -1): 5}]] - expected_variance = 4 * ((10+1) * (5+1)) / ((10+5+2) * (10+5+3)) - assert abs(term_variance_estimate( - 0, mock_measurements) - expected_variance) < 1e-10 + expected_variance = 4 * ((10 + 1) * (5 + 1)) / ((10 + 5 + 2) * (10 + 5 + 3)) + assert abs(term_variance_estimate(0, mock_measurements) - expected_variance) < 1e-10 def test_terms_covariance_estimate(): @@ -94,19 +97,18 @@ def test_terms_covariance_estimate(): # Test with mock measurements mock_measurements = [ [{(1, 1): 5, (1, -1): 0, (-1, 1): 0, (-1, -1): 5}], - [{(1, 1): 7, (1, -1): 0, (-1, 1): 0, (-1, -1): 3}] + [{(1, 1): 7, (1, -1): 0, (-1, 1): 0, (-1, -1): 3}], ] # Add cross-measurements - mock_measurements[0].append( - {(1, 1): 4, (1, -1): 1, (-1, 1): 2, (-1, -1): 3}) - mock_measurements[1].insert( - 0, {(1, 1): 4, (1, -1): 2, (-1, 1): 1, (-1, -1): 3}) + mock_measurements[0].append({(1, 1): 4, (1, -1): 1, (-1, 1): 2, (-1, -1): 3}) + mock_measurements[1].insert(0, {(1, 1): 4, (1, -1): 2, (-1, 1): 1, (-1, -1): 3}) # Calculate covariance result = terms_covariance_estimate(0, 1, mock_measurements) assert isinstance(result, float) assert -1.0 <= result <= 1.0 # Covariance should be in this range + # 2. Tests for AdaptiveShotAllocator Class @@ -139,9 +141,11 @@ def test_reset_method(simple_allocator): # Reset and check state simple_allocator.reset() assert simple_allocator.shots is None - assert all(all(outcome == 0 for outcome in simple_allocator.measurements[i][j].values()) - for i in range(simple_allocator.num_terms) - for j in range(simple_allocator.num_terms)) + assert all( + all(outcome == 0 for outcome in simple_allocator.measurements[i][j].values()) + for i in range(simple_allocator.num_terms) + for j in range(simple_allocator.num_terms) + ) def test_generate_graph(): @@ -163,8 +167,7 @@ def test_generate_graph(): def test_partition_graph(): # Create a simple graph with known clique structure - allocator = AdaptiveShotAllocator( - ["II", "IX", "IZ", "ZI"], [1.0, 1.0, 1.0, 1.0]) + allocator = AdaptiveShotAllocator(["II", "IX", "IZ", "ZI"], [1.0, 1.0, 1.0, 1.0]) # II, IX, ZI should form one clique (all commute with each other) # IZ should be in a separate clique @@ -195,8 +198,7 @@ def test_error_estimate(simple_allocator): simple_allocator.shots = [10, 15] # Mock measurements to update graph weights - mock_measurements = [ - [{(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4}] * 2] * 2 + mock_measurements = [[{(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4}] * 2] * 2 simple_allocator.update_measurements(mock_measurements) # Calculate error estimate @@ -228,12 +230,12 @@ def test_expectation_from_measurements(): mock_measurements = [ [ {(1, 1): 8, (1, -1): 0, (-1, 1): 0, (-1, -1): 2}, - {(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0} + {(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0}, ], [ {(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0}, - {(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0} - ] + {(1, 1): 0, (1, -1): 0, (-1, 1): 0, (-1, -1): 0}, + ], ] # Expected: 0.5 * 0.6 + (-0.3) * (0.0) = 0.3 + 0.0 = 0.0 @@ -250,22 +252,18 @@ def test_validate_measurements(): valid_measurements = [ [ {(1, 1): 5, (1, -1): 0, (-1, 1): 0, (-1, -1): 5}, - {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 4} + {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 4}, ], [ {(1, 1): 3, (1, -1): 1, (-1, 1): 2, (-1, -1): 4}, - {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4} - ] + {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4}, + ], ] assert allocator._validate_measurements(valid_measurements) == True # Invalid measurements (wrong size) - invalid_measurements = [ - [ - {(1, 1): 5, (1, -1): 0, (-1, 1): 0, (-1, -1): 5} - ] - ] + invalid_measurements = [[{(1, 1): 5, (1, -1): 0, (-1, 1): 0, (-1, -1): 5}]] with pytest.raises(AssertionError): allocator._validate_measurements(invalid_measurements) @@ -274,12 +272,12 @@ def test_validate_measurements(): invalid_measurements = [ [ {(1, 1): 5, (1, -1): 0, (-1, 1): 0, (-1, -1): 5}, - {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 3} # Sum is 9, not 10 + {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 3}, # Sum is 9, not 10 ], [ {(1, 1): 3, (1, -1): 1, (-1, 1): 2, (-1, -1): 4}, - {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4} - ] + {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4}, + ], ] with pytest.raises(AssertionError): @@ -289,12 +287,12 @@ def test_validate_measurements(): invalid_measurements = [ [ {(1, 1): 5, (1, -1): 0, (-1, 1): 0, (-1, -1): 5}, - {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 4} + {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 4}, ], [ {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 4}, - {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4} - ] + {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4}, + ], ] with pytest.raises(AssertionError): @@ -304,12 +302,12 @@ def test_validate_measurements(): invalid_measurements = [ [ {(1, 1): 5, (1, -1): 0, (-1, 1): 0, (-1, -1): 5}, - {(1, 1): 3, (1, -1): 4, (-1, 1): -1, (-1, -1): 4} + {(1, 1): 3, (1, -1): 4, (-1, 1): -1, (-1, -1): 4}, ], [ {(1, 1): 3, (1, -1): -1, (-1, 1): 4, (-1, -1): 4}, - {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4} - ] + {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4}, + ], ] with pytest.raises(AssertionError): @@ -323,20 +321,21 @@ def test_shots_from_measurements(): mock_measurements = [ [ {(1, 1): 5, (1, -1): 0, (-1, 1): 0, (-1, -1): 5}, # 10 shots - {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 4} + {(1, 1): 3, (1, -1): 2, (-1, 1): 1, (-1, -1): 4}, ], [ {(1, 1): 3, (1, -1): 1, (-1, 1): 2, (-1, -1): 4}, - {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4} # 10 shots - ] + {(1, 1): 6, (1, -1): 0, (-1, 1): 0, (-1, -1): 4}, # 10 shots + ], ] shots = allocator.shots_from_measurements(mock_measurements) assert len(shots) == len(allocator.cliq) assert shots[0] == 10 # First clique should have 10 shots + class VisualizationTest(unittest.TestCase): - @patch('matplotlib.pyplot.show') + @patch("matplotlib.pyplot.show") def test_graph(*args): paulis = ["XX", "IZ", "ZI", "YY", "XI"] coeffs = [0.5, 0.3, -0.2, 1.0, 2.0] diff --git a/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py index 6a0f01d2..2d693dee 100644 --- a/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py +++ b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py @@ -160,9 +160,7 @@ def test_get_hhl_results(): device = LocalSimulator() task = hhl_module.run_hhl(circ, device, shots=1000) - results = hhl_module.get_hhl_results( - task, matrix, b_vector, num_clock_qubits=2, verbose=True - ) + results = hhl_module.get_hhl_results(task, matrix, b_vector, num_clock_qubits=2, verbose=True) assert "measurement_counts" in results assert "post_selected_counts" in results @@ -192,9 +190,7 @@ def test_hhl_custom_scaling(): matrix = np.array([[1, 0], [0, 2]], dtype=complex) b_vector = np.array([1, 0], dtype=complex) - circ = hhl_module.hhl_circuit( - matrix, b_vector, num_clock_qubits=2, scaling_factor=np.pi - ) + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2, scaling_factor=np.pi) assert circ is not None From f5adce4362dcc8a34e79d0e5daf1391532add933 Mon Sep 17 00:00:00 2001 From: axif Date: Wed, 18 Feb 2026 23:24:40 +0600 Subject: [PATCH 04/11] refactor: remove `_compute_rotation_angles` from HHL implementation --- src/braket/experimental/algorithms/hhl/hhl.py | 52 ----- .../algorithms/hhl/test_hhl_coverage.py | 192 ++++++++++++++++++ 2 files changed, 192 insertions(+), 52 deletions(-) create mode 100644 test/unit_tests/braket/experimental/algorithms/hhl/test_hhl_coverage.py diff --git a/src/braket/experimental/algorithms/hhl/hhl.py b/src/braket/experimental/algorithms/hhl/hhl.py index 09a9ac8f..f7fe8b73 100644 --- a/src/braket/experimental/algorithms/hhl/hhl.py +++ b/src/braket/experimental/algorithms/hhl/hhl.py @@ -74,59 +74,7 @@ def _compute_eigendecomposition(matrix: np.ndarray) -> Tuple[np.ndarray, np.ndar return eigenvalues, eigenvectors -def _compute_rotation_angles( - eigenvalues: np.ndarray, - num_clock_qubits: int, - scaling_factor: float, -) -> Dict[int, float]: - """Compute the rotation angles for the controlled rotation step. - - For each eigenvalue lambda_j, the rotation angle is: - theta_j = 2 * arcsin(C / lambda_j) - - where C is a normalization constant chosen so that C/lambda_j <= 1 - for all eigenvalues. - - Args: - eigenvalues (np.ndarray): Eigenvalues of the matrix A. - num_clock_qubits (int): Number of clock qubits in QPE. - scaling_factor (float): Scaling factor for eigenvalue encoding. - - Returns: - Dict[int, float]: Mapping from clock register state (int) to rotation angle. - """ - # The QPE maps eigenvalues to phases: lambda_j -> 2*pi*phi_j - # For a 2x2 system with 2 clock qubits, we have 4 possible states (0,1,2,3). - # The eigenvalue lambda_j is encoded as phi_j = lambda_j * t0 / (2*pi) - - num_states = 2**num_clock_qubits - rotation_angles = {} - - for eigenval in eigenvalues: - # Map eigenvalue to the corresponding clock register integer - # Phase = eigenval * scaling_factor / (2 * pi) - phase = (eigenval * scaling_factor) / (2 * np.pi) - # Wrap to [0, 1) - phase = phase % 1.0 - clock_state = int(round(phase * num_states)) % num_states - - if clock_state == 0: - continue # Skip the zero eigenvalue case - - # C / lambda relationship - # Reconstruct the eigenvalue from the clock_state - reconstructed_eigenval = (2 * np.pi * clock_state) / (scaling_factor * num_states) - - # Rotation angle: theta = 2 * arcsin(C / lambda) - # C is chosen as the minimum eigenvalue magnitude (in absolute value) - c_value = min(abs(ev) for ev in eigenvalues if abs(ev) > 1e-10) - ratio = c_value / abs(reconstructed_eigenval) - ratio = min(ratio, 1.0) # Clamp to prevent arcsin domain errors - - theta = 2 * np.arcsin(ratio) - rotation_angles[clock_state] = theta - return rotation_angles @circuit.subroutine(register=True) diff --git a/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl_coverage.py b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl_coverage.py new file mode 100644 index 00000000..baa0c5bf --- /dev/null +++ b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl_coverage.py @@ -0,0 +1,192 @@ + +import numpy as np +import pytest +from unittest.mock import MagicMock +from braket.devices import LocalSimulator +from braket.experimental.algorithms.hhl import hhl as hhl_module +from braket.circuits import Circuit + +def test_prepare_state_b_complex_vector(): + """Test state preparation with complex amplitudes.""" + circ = Circuit() + # Normalized complex vector: [1/sqrt(2), i/sqrt(2)] + b_vector = np.array([1/np.sqrt(2), 1j/np.sqrt(2)], dtype=complex) + circ = hhl_module._prepare_state_b(circ, 0, b_vector) + + # Check if Rz gate is applied (indicates complex path taken) + assert any(instruction.operator.name == "Rz" for instruction in circ.instructions) + +def test_prepare_state_b_negative_component(): + """Test state preparation with negative real component.""" + circ = Circuit() + # Normalized vector with negative component: [0, -1] + # This triggers the `if np.real(b_vector[1]) < 0` branch + b_vector = np.array([0, -1], dtype=float) + circ = hhl_module._prepare_state_b(circ, 0, b_vector) + + # We can check specific rotation angle if needed, + # but mainly we care that it runs without error. + assert circ is not None + +def test_prepare_state_b_unnormalized_raises(): + """Test that unnormalized b_vector raises ValueError.""" + circ = Circuit() + b_vector = np.array([1, 1], dtype=float) # Norm is sqrt(2) + + with pytest.raises(ValueError, match="normalized"): + hhl_module._prepare_state_b(circ, 0, b_vector) + +def test_hhl_1_clock_qubit(): + """Test HHL with 1 clock qubit.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=1) + + # Check controlled rotation structure usage + # With 1 clock qubit, it uses _add_controlled_ry + # We can inspect the circuit instruction count or similar + assert circ is not None + # 1 clock + 1 input + 1 ancilla = 3 qubits + assert circ.qubit_count == 3 + +def test_hhl_3_clock_qubits(): + """Test HHL with 3 clock qubits (triggering multi-controlled logic).""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=3) + + # With 3 clock qubits, it uses _add_multi_controlled_ry + assert circ is not None + # 3 clock + 1 input + 1 ancilla = 5 qubits + assert circ.qubit_count == 5 + +def test_construct_controlled_unitary_invalid_shape(): + """Test _construct_controlled_unitary_matrix with invalid shape.""" + invalid_unitary = np.eye(3) + with pytest.raises(ValueError, match="Only 2x2 unitaries"): + hhl_module._construct_controlled_unitary_matrix(invalid_unitary) + +def test_get_hhl_results_no_success(): + """Test get_hhl_results when no shots succeed (no post-selection).""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + # Mock task and result + mock_task = MagicMock() + mock_result = MagicMock() + # All measurements have ancilla=0 (failure) + # Format: clock(2) | input(1) | ancilla(1) + # e.g., "00" + "0" + "0" + mock_result.measurement_counts = {"0000": 100} + mock_task.result.return_value = mock_result + + results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=2) + + assert results["success_shots"] == 0 + assert results["success_probability"] == 0.0 + # Should handle empty dict locally + assert results["solution_state_probabilities"] == {"0": 0.0, "1": 0.0} + +def test_get_hhl_results_multiple_post_selection(): + """Test get_hhl_results aggregating counts correctly.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + # Mock task and result + mock_task = MagicMock() + mock_result = MagicMock() + # Success cases: ancilla=1, clock=00 + # "00" + "0" + "1" -> input 0 + # "00" + "1" + "1" -> input 1 + mock_result.measurement_counts = { + "0001": 30, # input 0, success + "0011": 20, # input 1, success + "1100": 50 # fail + } + mock_task.result.return_value = mock_result + + results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=2) + + assert results["success_shots"] == 50 + assert results["post_selected_counts"]["0"] == 30 + assert results["post_selected_counts"]["1"] == 20 + assert results["solution_state_probabilities"]["0"] == 0.6 + assert results["solution_state_probabilities"]["1"] == 0.4 + +def test_post_selected_counts_accumulation(): + """Test accumulation of post-selected counts for same input bit.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + num_clock = 2 + + mock_task = MagicMock() + mock_result = MagicMock() + # To hit line `post_selected_counts[input_bit] += count`, + # we need multiple bitstrings mapping to same input_bit. + # Standard format: clock(2) | input(1) | ancilla(1) + # If we have extra "hidden" bits at the end, get_hhl_results relies on indices. + # bitstring is opaque. + # Ancilla is bitstring[-1]. + # Clock is bitstring[:num_clock]. + # Input is bitstring[num_clock]. + + # Let's say we have bitstrings "0001A" and "0001B" where both pass. + # This requires string length > 4. + mock_result.measurement_counts = { + "00010": 10, # "00" clock, input "0", ancilla "0" (fail) + "00011": 20, # "00" clock, input "0", ancilla "1" (success) + # We need another string that is "00" + "0" + ... + "1" + # Since logic is by index, we can construct arbitrary string. + # "00" (clock) + "0" (input) + "X" + "1" (ancilla) + # Length 5. clock=0:2, input=2, ancilla=-1. + "000X1": 30, # "00" clock, input "0", ancilla "1" + } + mock_task.result.return_value = mock_result + + results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=num_clock) + + # Both "00011" and "000X1" map to input "0". + # Total count for "0" should be 20 + 30 = 50. + assert results["success_shots"] == 50 + assert results["post_selected_counts"]["0"] == 50 + +def test_controlled_rotation_zeros(): + """Test controlled rotation with zero eigenvalues.""" + circ = Circuit() + # If eigenvalues are all "zero" (filtered by 1e-10) + eigenvalues = np.array([0.0, 1e-11], dtype=float) + + # Should return empty circuit immediately (line 308) + res_circ = hhl_module._controlled_rotation( + [0, 1], 2, eigenvalues, 2, 1.0 + ) + + assert len(res_circ.instructions) == 0 + +def test_add_multi_controlled_ry_base_case(): + """Test _add_multi_controlled_ry with 1 control to hit base case.""" + circ = Circuit() + controls = [0] + target = 1 + theta = np.pi + + # Directly call the internal function + hhl_module._add_multi_controlled_ry(circ, controls, target, theta) + + # Should produce instructions (calls _add_controlled_ry) + assert len(circ.instructions) > 0 + +def test_hhl_small_ratio_skip(): + """Test skippng of small rotation angles (ratio < 1e-12).""" + # Matrix with huge condition number: min=1e-8, max=1e8 -> ratio ~ 1e-16 + # Both eigenvalues > 1e-10 so c_value is valid. + matrix = np.array([[1e-8, 0], [0, 1e8]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + # This should trigger the continue statement in _controlled_rotation + # for the max eigenvalue component (reconstructed ~ 1e8, c ~ 1e-8) + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) + assert circ is not None + From d3f307af60af4d5c49f87da286f1b2d0f5d27b0b Mon Sep 17 00:00:00 2001 From: axif Date: Wed, 18 Feb 2026 23:27:41 +0600 Subject: [PATCH 05/11] Update test covarage --- .../experimental/algorithms/hhl/test_hhl.py | 198 ++++++++++++++++++ .../algorithms/hhl/test_hhl_coverage.py | 192 ----------------- 2 files changed, 198 insertions(+), 192 deletions(-) delete mode 100644 test/unit_tests/braket/experimental/algorithms/hhl/test_hhl_coverage.py diff --git a/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py index 2d693dee..dc6c2f12 100644 --- a/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py +++ b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl.py @@ -16,6 +16,8 @@ from braket.devices import LocalSimulator from braket.experimental.algorithms.hhl import hhl as hhl_module +from unittest.mock import MagicMock +from braket.circuits import Circuit # Test with a simple diagonal 2x2 matrix @@ -205,3 +207,199 @@ def test_hhl_negative_eigenvalues(): circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) assert circ is not None + + +def test_prepare_state_b_complex_vector(): + """Test state preparation with complex amplitudes.""" + circ = Circuit() + # Normalized complex vector: [1/sqrt(2), i/sqrt(2)] + b_vector = np.array([1/np.sqrt(2), 1j/np.sqrt(2)], dtype=complex) + circ = hhl_module._prepare_state_b(circ, 0, b_vector) + + # Check if Rz gate is applied (indicates complex path taken) + assert any(instruction.operator.name == "Rz" for instruction in circ.instructions) + + +def test_prepare_state_b_negative_component(): + """Test state preparation with negative real component.""" + circ = Circuit() + # Normalized vector with negative component: [0, -1] + # This triggers the `if np.real(b_vector[1]) < 0` branch + b_vector = np.array([0, -1], dtype=float) + circ = hhl_module._prepare_state_b(circ, 0, b_vector) + + # We can check specific rotation angle if needed, + # but mainly we care that it runs without error. + assert circ is not None + + +def test_prepare_state_b_unnormalized_raises(): + """Test that unnormalized b_vector raises ValueError.""" + circ = Circuit() + b_vector = np.array([1, 1], dtype=float) # Norm is sqrt(2) + + with pytest.raises(ValueError, match="normalized"): + hhl_module._prepare_state_b(circ, 0, b_vector) + + +def test_hhl_1_clock_qubit(): + """Test HHL with 1 clock qubit.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=1) + + # Check controlled rotation structure usage + # With 1 clock qubit, it uses _add_controlled_ry + # We can inspect the circuit instruction count or similar + assert circ is not None + # 1 clock + 1 input + 1 ancilla = 3 qubits + assert circ.qubit_count == 3 + + +def test_hhl_3_clock_qubits(): + """Test HHL with 3 clock qubits (triggering multi-controlled logic).""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=3) + + # With 3 clock qubits, it uses _add_multi_controlled_ry + assert circ is not None + # 3 clock + 1 input + 1 ancilla = 5 qubits + assert circ.qubit_count == 5 + + +def test_construct_controlled_unitary_invalid_shape(): + """Test _construct_controlled_unitary_matrix with invalid shape.""" + invalid_unitary = np.eye(3) + with pytest.raises(ValueError, match="Only 2x2 unitaries"): + hhl_module._construct_controlled_unitary_matrix(invalid_unitary) + + +def test_get_hhl_results_no_success(): + """Test get_hhl_results when no shots succeed (no post-selection).""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + # Mock task and result + mock_task = MagicMock() + mock_result = MagicMock() + # All measurements have ancilla=0 (failure) + # Format: clock(2) | input(1) | ancilla(1) + # e.g., "00" + "0" + "0" + mock_result.measurement_counts = {"0000": 100} + mock_task.result.return_value = mock_result + + results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=2) + + assert results["success_shots"] == 0 + assert results["success_probability"] == 0.0 + # Should handle empty dict locally + assert results["solution_state_probabilities"] == {"0": 0.0, "1": 0.0} + + +def test_get_hhl_results_multiple_post_selection(): + """Test get_hhl_results aggregating counts correctly.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + # Mock task and result + mock_task = MagicMock() + mock_result = MagicMock() + # Success cases: ancilla=1, clock=00 + # "00" + "0" + "1" -> input 0 + # "00" + "1" + "1" -> input 1 + mock_result.measurement_counts = { + "0001": 30, # input 0, success + "0011": 20, # input 1, success + "1100": 50 # fail + } + mock_task.result.return_value = mock_result + + results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=2) + + assert results["success_shots"] == 50 + assert results["post_selected_counts"]["0"] == 30 + assert results["post_selected_counts"]["1"] == 20 + assert results["solution_state_probabilities"]["0"] == 0.6 + assert results["solution_state_probabilities"]["1"] == 0.4 + + +def test_post_selected_counts_accumulation(): + """Test accumulation of post-selected counts for same input bit.""" + matrix = np.array([[1, 0], [0, 2]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + num_clock = 2 + + mock_task = MagicMock() + mock_result = MagicMock() + # To hit line `post_selected_counts[input_bit] += count`, + # we need multiple bitstrings mapping to same input_bit. + # Standard format: clock(2) | input(1) | ancilla(1) + # If we have extra "hidden" bits at the end, get_hhl_results relies on indices. + # bitstring is opaque. + # Ancilla is bitstring[-1]. + # Clock is bitstring[:num_clock]. + # Input is bitstring[num_clock]. + + # Let's say we have bitstrings "0001A" and "0001B" where both pass. + # This requires string length > 4. + mock_result.measurement_counts = { + "00010": 10, # "00" clock, input "0", ancilla "0" (fail) + "00011": 20, # "00" clock, input "0", ancilla "1" (success) + # We need another string that is "00" + "0" + ... + "1" + # Since logic is by index, we can construct arbitrary string. + # "00" (clock) + "0" (input) + "X" + "1" (ancilla) + # Length 5. clock=0:2, input=2, ancilla=-1. + "000X1": 30, # "00" clock, input "0", ancilla "1" + } + mock_task.result.return_value = mock_result + + results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=num_clock) + + # Both "00011" and "000X1" map to input "0". + # Total count for "0" should be 20 + 30 = 50. + assert results["success_shots"] == 50 + assert results["post_selected_counts"]["0"] == 50 + + +def test_controlled_rotation_zeros(): + """Test controlled rotation with zero eigenvalues.""" + circ = Circuit() + # If eigenvalues are all "zero" (filtered by 1e-10) + eigenvalues = np.array([0.0, 1e-11], dtype=float) + + # Should return empty circuit immediately (line 308) + res_circ = hhl_module._controlled_rotation( + [0, 1], 2, eigenvalues, 2, 1.0 + ) + + assert len(res_circ.instructions) == 0 + + +def test_add_multi_controlled_ry_base_case(): + """Test _add_multi_controlled_ry with 1 control to hit base case.""" + circ = Circuit() + controls = [0] + target = 1 + theta = np.pi + + # Directly call the internal function + hhl_module._add_multi_controlled_ry(circ, controls, target, theta) + + # Should produce instructions (calls _add_controlled_ry) + assert len(circ.instructions) > 0 + + +def test_hhl_small_ratio_skip(): + """Test skippng of small rotation angles (ratio < 1e-12).""" + # Matrix with huge condition number: min=1e-8, max=1e8 -> ratio ~ 1e-16 + # Both eigenvalues > 1e-10 so c_value is valid. + matrix = np.array([[1e-8, 0], [0, 1e8]], dtype=complex) + b_vector = np.array([1, 0], dtype=complex) + + # This should trigger the continue statement in _controlled_rotation + # for the max eigenvalue component (reconstructed ~ 1e8, c ~ 1e-8) + circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) + assert circ is not None diff --git a/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl_coverage.py b/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl_coverage.py deleted file mode 100644 index baa0c5bf..00000000 --- a/test/unit_tests/braket/experimental/algorithms/hhl/test_hhl_coverage.py +++ /dev/null @@ -1,192 +0,0 @@ - -import numpy as np -import pytest -from unittest.mock import MagicMock -from braket.devices import LocalSimulator -from braket.experimental.algorithms.hhl import hhl as hhl_module -from braket.circuits import Circuit - -def test_prepare_state_b_complex_vector(): - """Test state preparation with complex amplitudes.""" - circ = Circuit() - # Normalized complex vector: [1/sqrt(2), i/sqrt(2)] - b_vector = np.array([1/np.sqrt(2), 1j/np.sqrt(2)], dtype=complex) - circ = hhl_module._prepare_state_b(circ, 0, b_vector) - - # Check if Rz gate is applied (indicates complex path taken) - assert any(instruction.operator.name == "Rz" for instruction in circ.instructions) - -def test_prepare_state_b_negative_component(): - """Test state preparation with negative real component.""" - circ = Circuit() - # Normalized vector with negative component: [0, -1] - # This triggers the `if np.real(b_vector[1]) < 0` branch - b_vector = np.array([0, -1], dtype=float) - circ = hhl_module._prepare_state_b(circ, 0, b_vector) - - # We can check specific rotation angle if needed, - # but mainly we care that it runs without error. - assert circ is not None - -def test_prepare_state_b_unnormalized_raises(): - """Test that unnormalized b_vector raises ValueError.""" - circ = Circuit() - b_vector = np.array([1, 1], dtype=float) # Norm is sqrt(2) - - with pytest.raises(ValueError, match="normalized"): - hhl_module._prepare_state_b(circ, 0, b_vector) - -def test_hhl_1_clock_qubit(): - """Test HHL with 1 clock qubit.""" - matrix = np.array([[1, 0], [0, 2]], dtype=complex) - b_vector = np.array([1, 0], dtype=complex) - - circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=1) - - # Check controlled rotation structure usage - # With 1 clock qubit, it uses _add_controlled_ry - # We can inspect the circuit instruction count or similar - assert circ is not None - # 1 clock + 1 input + 1 ancilla = 3 qubits - assert circ.qubit_count == 3 - -def test_hhl_3_clock_qubits(): - """Test HHL with 3 clock qubits (triggering multi-controlled logic).""" - matrix = np.array([[1, 0], [0, 2]], dtype=complex) - b_vector = np.array([1, 0], dtype=complex) - - circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=3) - - # With 3 clock qubits, it uses _add_multi_controlled_ry - assert circ is not None - # 3 clock + 1 input + 1 ancilla = 5 qubits - assert circ.qubit_count == 5 - -def test_construct_controlled_unitary_invalid_shape(): - """Test _construct_controlled_unitary_matrix with invalid shape.""" - invalid_unitary = np.eye(3) - with pytest.raises(ValueError, match="Only 2x2 unitaries"): - hhl_module._construct_controlled_unitary_matrix(invalid_unitary) - -def test_get_hhl_results_no_success(): - """Test get_hhl_results when no shots succeed (no post-selection).""" - matrix = np.array([[1, 0], [0, 2]], dtype=complex) - b_vector = np.array([1, 0], dtype=complex) - - # Mock task and result - mock_task = MagicMock() - mock_result = MagicMock() - # All measurements have ancilla=0 (failure) - # Format: clock(2) | input(1) | ancilla(1) - # e.g., "00" + "0" + "0" - mock_result.measurement_counts = {"0000": 100} - mock_task.result.return_value = mock_result - - results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=2) - - assert results["success_shots"] == 0 - assert results["success_probability"] == 0.0 - # Should handle empty dict locally - assert results["solution_state_probabilities"] == {"0": 0.0, "1": 0.0} - -def test_get_hhl_results_multiple_post_selection(): - """Test get_hhl_results aggregating counts correctly.""" - matrix = np.array([[1, 0], [0, 2]], dtype=complex) - b_vector = np.array([1, 0], dtype=complex) - - # Mock task and result - mock_task = MagicMock() - mock_result = MagicMock() - # Success cases: ancilla=1, clock=00 - # "00" + "0" + "1" -> input 0 - # "00" + "1" + "1" -> input 1 - mock_result.measurement_counts = { - "0001": 30, # input 0, success - "0011": 20, # input 1, success - "1100": 50 # fail - } - mock_task.result.return_value = mock_result - - results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=2) - - assert results["success_shots"] == 50 - assert results["post_selected_counts"]["0"] == 30 - assert results["post_selected_counts"]["1"] == 20 - assert results["solution_state_probabilities"]["0"] == 0.6 - assert results["solution_state_probabilities"]["1"] == 0.4 - -def test_post_selected_counts_accumulation(): - """Test accumulation of post-selected counts for same input bit.""" - matrix = np.array([[1, 0], [0, 2]], dtype=complex) - b_vector = np.array([1, 0], dtype=complex) - num_clock = 2 - - mock_task = MagicMock() - mock_result = MagicMock() - # To hit line `post_selected_counts[input_bit] += count`, - # we need multiple bitstrings mapping to same input_bit. - # Standard format: clock(2) | input(1) | ancilla(1) - # If we have extra "hidden" bits at the end, get_hhl_results relies on indices. - # bitstring is opaque. - # Ancilla is bitstring[-1]. - # Clock is bitstring[:num_clock]. - # Input is bitstring[num_clock]. - - # Let's say we have bitstrings "0001A" and "0001B" where both pass. - # This requires string length > 4. - mock_result.measurement_counts = { - "00010": 10, # "00" clock, input "0", ancilla "0" (fail) - "00011": 20, # "00" clock, input "0", ancilla "1" (success) - # We need another string that is "00" + "0" + ... + "1" - # Since logic is by index, we can construct arbitrary string. - # "00" (clock) + "0" (input) + "X" + "1" (ancilla) - # Length 5. clock=0:2, input=2, ancilla=-1. - "000X1": 30, # "00" clock, input "0", ancilla "1" - } - mock_task.result.return_value = mock_result - - results = hhl_module.get_hhl_results(mock_task, matrix, b_vector, num_clock_qubits=num_clock) - - # Both "00011" and "000X1" map to input "0". - # Total count for "0" should be 20 + 30 = 50. - assert results["success_shots"] == 50 - assert results["post_selected_counts"]["0"] == 50 - -def test_controlled_rotation_zeros(): - """Test controlled rotation with zero eigenvalues.""" - circ = Circuit() - # If eigenvalues are all "zero" (filtered by 1e-10) - eigenvalues = np.array([0.0, 1e-11], dtype=float) - - # Should return empty circuit immediately (line 308) - res_circ = hhl_module._controlled_rotation( - [0, 1], 2, eigenvalues, 2, 1.0 - ) - - assert len(res_circ.instructions) == 0 - -def test_add_multi_controlled_ry_base_case(): - """Test _add_multi_controlled_ry with 1 control to hit base case.""" - circ = Circuit() - controls = [0] - target = 1 - theta = np.pi - - # Directly call the internal function - hhl_module._add_multi_controlled_ry(circ, controls, target, theta) - - # Should produce instructions (calls _add_controlled_ry) - assert len(circ.instructions) > 0 - -def test_hhl_small_ratio_skip(): - """Test skippng of small rotation angles (ratio < 1e-12).""" - # Matrix with huge condition number: min=1e-8, max=1e8 -> ratio ~ 1e-16 - # Both eigenvalues > 1e-10 so c_value is valid. - matrix = np.array([[1e-8, 0], [0, 1e8]], dtype=complex) - b_vector = np.array([1, 0], dtype=complex) - - # This should trigger the continue statement in _controlled_rotation - # for the max eigenvalue component (reconstructed ~ 1e8, c ~ 1e-8) - circ = hhl_module.hhl_circuit(matrix, b_vector, num_clock_qubits=2) - assert circ is not None - From d8be0eeb337f3e7087649cfdce5392b23a9c9853 Mon Sep 17 00:00:00 2001 From: axif Date: Sat, 21 Feb 2026 02:52:49 +0600 Subject: [PATCH 06/11] refactor: Restructure HHL notebook for improved clarity, add circuit component explanations, and fix unicode characters. --- move_cell.py | 23 + move_refs.py | 23 + .../advanced_algorithms/HHL_Algorithm.ipynb | 204 ++++-- .../experimental/algorithms/hhl/__init__.py | 13 - src/braket/experimental/algorithms/hhl/hhl.md | 2 +- src/braket/experimental/algorithms/hhl/hhl.py | 617 +++++++----------- .../experimental/algorithms/hhl/test_hhl.py | 84 +-- 7 files changed, 460 insertions(+), 506 deletions(-) create mode 100644 move_cell.py create mode 100644 move_refs.py diff --git a/move_cell.py b/move_cell.py new file mode 100644 index 00000000..3d512ecb --- /dev/null +++ b/move_cell.py @@ -0,0 +1,23 @@ +import json + +with open("notebooks/advanced_algorithms/HHL_Algorithm.ipynb", "r") as f: + nb = json.load(f) + +# Find "Understanding the Circuit Components" cell +idx_to_move = -1 +for i, cell in enumerate(nb["cells"]): + if cell["cell_type"] == "markdown": + source = "".join(cell["source"]) + if "## Understanding the Circuit Components" in source: + idx_to_move = i + break + +if idx_to_move != -1: + cell = nb["cells"].pop(idx_to_move) + nb["cells"].insert(1, cell) + + with open("notebooks/advanced_algorithms/HHL_Algorithm.ipynb", "w") as f: + json.dump(nb, f, indent=1) + print("Moved cell successfully.") +else: + print("Cell not found.") diff --git a/move_refs.py b/move_refs.py new file mode 100644 index 00000000..eb69c09a --- /dev/null +++ b/move_refs.py @@ -0,0 +1,23 @@ +import json + +with open("notebooks/advanced_algorithms/HHL_Algorithm.ipynb", "r") as f: + nb = json.load(f) + +# Find "References" cell +idx_to_move = -1 +for i, cell in enumerate(nb["cells"]): + if cell["cell_type"] == "markdown": + source = "".join(cell["source"]) + if "## References" in source: + idx_to_move = i + break + +if idx_to_move != -1: + cell = nb["cells"].pop(idx_to_move) + nb["cells"].append(cell) + + with open("notebooks/advanced_algorithms/HHL_Algorithm.ipynb", "w") as f: + json.dump(nb, f, indent=1) + print("Moved References cell to bottom successfully.") +else: + print("References Cell not found.") diff --git a/notebooks/advanced_algorithms/HHL_Algorithm.ipynb b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb index d053365a..5a429523 100644 --- a/notebooks/advanced_algorithms/HHL_Algorithm.ipynb +++ b/notebooks/advanced_algorithms/HHL_Algorithm.ipynb @@ -44,20 +44,41 @@ }, { "cell_type": "markdown", - "id": "819903ab-f718-46fb-b315-ce39d68ade09", + "id": "339d0d20-7afd-4210-8630-38b3b561dea7", "metadata": {}, "source": [ - "## References\n", + "## Understanding the Circuit Components\n", "\n", - "[[1] A. W. Harrow, A. Hassidim, S. Lloyd, \"Quantum algorithm for linear systems of equations\", Phys. Rev. Lett. 103, 150502 (2009)](https://arxiv.org/abs/0811.3171)\n", + "Let's walk through each component of the HHL circuit in more detail.\n", "\n", - "[[2] Wikipedia: HHL Algorithm](https://en.wikipedia.org/wiki/HHL_algorithm)\n", + "### 1. State Preparation\n", "\n", - "[[3] S. Barz et al., \"A two-qubit photonic quantum processor and its application to solving systems of linear equations\", Scientific Reports 4, 6115 (2014)](https://arxiv.org/abs/1302.1210)\n", + "The vector $\\vec{b}$ is encoded as a quantum state $|b\\rangle$ on the input qubit. For a 2-element vector $\\vec{b} = (b_0, b_1)^T$, this is done using an $R_y$ rotation:\n", "\n", - "[[4] X.-D. Cai et al., \"Experimental Quantum Computing to Solve Systems of Linear Equations\", Phys. Rev. Lett. 110, 230501 (2013)](https://arxiv.org/abs/1302.4310)\n", + "$$|b\\rangle = \\cos(\\theta/2)|0\\rangle + \\sin(\\theta/2)|1\\rangle$$\n", "\n", - "[[5] J. Pan et al., \"Experimental realization of quantum algorithm for solving linear systems of equations\", Phys. Rev. A 89, 022313 (2014)](https://arxiv.org/abs/1302.1946)" + "where $\\theta = 2\\arccos(b_0)$ for real vectors.\n", + "\n", + "### 2. Quantum Phase Estimation (QPE)\n", + "\n", + "QPE decomposes $|b\\rangle$ in the eigenbasis of $A$ and estimates eigenvalues. It uses:\n", + "- Hadamard gates on clock qubits to create superposition\n", + "- Controlled $U^{2^k} = e^{iAt \\cdot 2^k}$ operations (Hamiltonian simulation)\n", + "- Inverse QFT on the clock register\n", + "\n", + "After QPE, the state is approximately:\n", + "$$\\sum_j \\beta_j |u_j\\rangle|\\tilde{\\lambda}_j\\rangle$$\n", + "\n", + "### 3. Controlled Rotation\n", + "\n", + "For each eigenvalue $\\lambda_j$ stored in the clock register, we perform a controlled $R_y$ rotation on the ancilla qubit with angle $\\theta_j = 2\\arcsin(C/\\lambda_j)$:\n", + "\n", + "$$|\\tilde{\\lambda}_j\\rangle|0\\rangle_a \\rightarrow |\\tilde{\\lambda}_j\\rangle\\left(\\sqrt{1 - \\frac{C^2}{\\lambda_j^2}}|0\\rangle_a + \\frac{C}{\\lambda_j}|1\\rangle_a\\right)$$\n", + "\n", + "### 4. Inverse QPE\n", + "\n", + "The inverse QPE uncomputes the clock register, returning it to $|0\\rangle^{\\otimes n}$.\n", + "After post-selecting on the ancilla measuring $|1\\rangle$, the input qubit is in the state $|x\\rangle \\propto A^{-1}|b\\rangle$." ] }, { @@ -168,8 +189,8 @@ " - Clock qubits: q0, q1 (QPE register)\n", " - Input qubit: q2 (encodes |b>)\n", " - Ancilla qubit: q3 (for eigenvalue inversion)\n", - "Circuit depth: 48\n", - "Number of instructions: 63\n" + "Circuit depth: 29\n", + "Number of instructions: 36\n" ] } ], @@ -204,7 +225,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Running HHL Algorithm...\n", + "Running HHL Algorithm...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "HHL Run Complete!\n", "Matrix A:\n", "[[1.+0.j 0.+0.j]\n", @@ -217,10 +251,10 @@ "Classical probabilities |x_i|^2: [1. 0.]\n", "\n", "Total measurement shots: 10000\n", - "Post-selection success shots: 984\n", - "Success probability: 0.0984\n", + "Post-selection success shots: 4818\n", + "Success probability: 0.4818\n", "\n", - "Post-selected counts: {'0': 984}\n", + "Post-selected counts: {'0': 4818}\n", "Quantum solution probabilities: {'0': 1.0}\n", "\n", "Fidelity with classical solution: 1.0000\n" @@ -256,7 +290,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "

" ] @@ -382,7 +416,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Running HHL Algorithm for Example 2...\n", + "Running HHL Algorithm for Example 2...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "HHL Run Complete!\n", "Matrix A:\n", "[[2.+0.j 1.+0.j]\n", @@ -395,18 +442,18 @@ "Classical probabilities |x_i|^2: [0.5 0.5]\n", "\n", "Total measurement shots: 10000\n", - "Post-selection success shots: 7312\n", - "Success probability: 0.7312\n", + "Post-selection success shots: 4662\n", + "Success probability: 0.4662\n", "\n", - "Post-selected counts: {'1': 3733, '0': 3579}\n", - "Quantum solution probabilities: {'1': 0.5105306345733042, '0': 0.48946936542669583}\n", + "Post-selected counts: {'1': 2372, '0': 2290}\n", + "Quantum solution probabilities: {'1': 0.5087945087945088, '0': 0.49120549120549123}\n", "\n", "Fidelity with classical solution: 0.9999\n" ] }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABrwAAAHvCAYAAAAGkX8FAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA/S1JREFUeJzs3XdYFFf7N/Dv0kGaShWVZgPsDUsUiQXsvSVG7DGWxJrEEruxl8SamEcw9hJj7zUqdkVBBRWxS1Fp0hZ25/2Dd+fHsoCAwIB8P9e1z5OdOXPmnmFkDnPPOUcmCIIAIiIiIiIiIiIiIiIiohJKS+oAiIiIiIiIiIiIiIiIiD4FE15ERERERERERERERERUojHhRURERERERERERERERCUaE15ERERERERERERERERUojHhRURERERERERERERERCUaE15ERERERERERERERERUojHhRURERERERERERERERCUaE15ERERERERERERERERUojHhRURERERERERERERERCUaE15EREREREREVODGjRsHmUyGXr16SR1KkYmKioKenh5kMhmCgoKkDoeIiIioVGHCi4iIiIjoE507dw4ymUz8PH36VOqQSrXMPw/Vp1u3bmIZPz+/LMuMGzdOsrizExAQkGWsrVq1ynUdgwYNyrKOffv2FVrc+bVy5cosY501a5ZYRpVIyfzx8/P75P2XtH/PxfVaTk1NxdatW9GkSRN89913ksZSlLZs2YLU1FT8+uuvsLOzy3c95ubmWf5ciYiIiCh7THgRERERUY6ySx5k/gwaNEjqUEuFR48eYcWKFejWrRtcXV1Rrlw56OnpwdbWFp07d8aBAwcKdf81a9ZU+7nb2toiLS2tUPcplcI61xs2bMCQIUNQq1Yt6OjoiOfSwcGhYA8gj2JiYrBo0SL07t0bDg4OBfLv+9KlS5g5cyZat26NKlWqwNjYGIaGhnB2dsbgwYNx586dgj0IytanXncDBgyATCbDokWLclX+4MGDePv2LSZOnIjWrVsDKPrr4cGDB5g+fTq8vb1hYWGR5+To48ePIZPJYGZmBrlcnqt9+vr6ws3NDVOmTEHZsmXx/v17+Pr6wsfHB3Xr1oWNjQ10dXVRrlw5fPHFF1i1alWu6yYiIiKinOlIHQAREREREeXesmXL8Mcff2gsDw8Px6FDh3Do0CGMGjUKa9asKfB9X79+Hffu3dPY77Fjx9CpU6cC319BWbJkCQCgatWqWa4vW7Yspk6dCgBo0KCBuLywzvXkyZMRGxub6/J2dnbiMZw4cQInT57M0/4ya9iwIfr27QsgPYGp8vTpU/z888+fVHdmQ4cORUhIiMbyJ0+e4MmTJ9iyZQv+/vtv9O/fX1zXsmVL8XjXrVuHJ0+eaGzftWtXVKxYEQDw66+/Ijo6ukDjLqmyu5aBvF93GaWmpuLw4cMAoNZTMie+vr4oV64cunTpIi7Lz/XwKY4fP4758+fne/t///0XANChQwfo6el9tPzNmzcRGBgoXr9A+r/ZIUOGaJSNjo7GpUuXcOnSJWzZsgWnT5+GsbGxuH7evHlITk5GaGgo1q9fn+9jICIiIipNmPAiIiIiojzp27cvGjZsqLE844NzKnyOjo7w9vZGhQoVcP/+fezatQsKhQIAsHbtWnTv3h1t2rQp0H1m1yPCz8+vWCe8Jk2alON6U1PTHMsU9LnW1taGi4sLGjZsiMDAQAQEBORY3tLSUozvw4cPn5zwcnNzy/Z4DQwMULt2bTRs2BDbt28vsERSo0aN0KpVK5QpUwZnz57F+fPnAQBpaWkYMWIE2rdvD3NzcwBA/fr1Ub9+fQDAoUOHskx4eXp6wtPTEwCwevVqJrz+v5yu5bxedxmdO3cOMTExqFGjBqpXr/7R8qpE+MiRI7NMFOXlevhUZcuWRf369eHs7Iw///wzT9uqhvzMS5JPR0cH33zzTZZxtG/fHi4uLoiIiMDmzZvFBOS1a9ewcOFCzJs3Tyw/ZswYAOnnngkvIiIiotzhkIZERERElCfe3t6YNGmSxsfb2xtA+gP5KlWqiMNG9ezZU237ESNGqA2HFxUVBQAICwvDuHHj0KJFC1SqVAllypSBvr4+7Ozs0LlzZxw8eFAjlsxz18TGxuL777+Hra0typQpA09PT1y7dg1Aeg+CXr16oWzZsjAxMYG3tzeCgoLU6nv69KlafefOncPmzZvRoEEDGBoawsrKCkOGDEFERESezplSqcTmzZvRrl07WFlZQU9PD5aWlujYsSOOHDmSp7pq1qyJgwcPIjQ0FGvXrsX06dOxbds2bNiwQa3c0aNHczxXeZ2XKCUlBdu3bxe/V6tWTfzvgwcP4t27d3mqryTI77n+mJcvX+L+/fv4+++/UadOnYIM+ZO4ubkhPj4eV69exZo1a2BqavrJdXbq1Al37tzBtWvXsHjxYsycORPnzp2Dj4+PWObDhw+4cOHCJ++rsAiCgDVr1qBmzZowMDCAnZ0dJkyYgPj4eKlDy5NPue7ymvjZvHkz0tLSNIbCLOrr4dtvv8X79+9x6tQpTJkyJU/bRkRE4MqVK9DT00OHDh0+Wj4lJQXbtm2Dt7c3rK2txeUWFhZYtWoVXr16ha1bt2L69OlYtWoVrly5An19fbFcXn+PEBEREZEmJryIiIiIqEAZGxtj27Zt0NFJH0xg79692LFjB4D04aVUyQKZTIa///4blpaWAIB79+7ht99+w8WLF/Hy5UskJiZCLpfj9evXOHToELp06YI5c+bkuO/WrVtj1apVCA8PR2JiIs6dOwcPDw8cOHAAjRo1wj///IOYmBh8+PABx48fR6tWrcSEW1bmzp2LgQMH4tatW0hOTkZUVBR8fX3RrFmzHLfLKCkpCV5eXhg4cCBOnjyJqKgopKam4u3btzhy5Ag6duyIiRMn5qouIP2t/06dOkEmk6kt7927t9r3gp4TZv/+/Wq9aDZt2gRdXV1xX9u2bctznbmZGy5zArIoFda5NjQ0/OTYCoOurq7477agLF26FLVr19ZY3qtXL7XvxXkOo7Fjx2LMmDG4d+8eUlJS8Pr1a6xYsQKtW7dGcnJyrurInEzPzSevSemPye91JwgC9u/fDwDo3r272rrk5GScPXtWYxtfX1/UqlVLY1jFor4ePuXf2oEDB6BUKtG6dWuYmJiorQsJCdHoeaj6HZk5ydemTRuMGTNGI5YaNWqo9Ywuzv8GiIiIiEoKJryIiIiIKE+OHTuGpUuXanxevHghlmncuLFacmrMmDEICQnB0KFDxWUTJkxA27Ztxe86OjqoW7cuhg0bhilTpmDBggWYPn26OGwZkJ6AevXqVbax3b59G8OHD8f48ePFZExycjK6du2KuLg4jBo1CsOGDRPLv3v3Dv/73/+yre/MmTPw9PTEjBkz0Lp1a3H5kydP8NNPP33sVAEAxo8fj1OnTgEA9PT0MHDgQMydOxd9+vQREynLly/PV8Ioo+DgYLXvjRs3/qT6Mss4nGH9+vXRpEkTtWH8shvu8HNU2Oe6NMh4DrW0tDQSI8XJ4cOH0bVrV8yYMQONGjUSl1+/fh2LFy+WMLKicf36dbx69Qp2dnbi8fv7+2PAgAGwsrJC69at8fz5c7H81atX8eDBA43ET06K4/Wgmr9L1astOTkZCxcuRN26dVGjRg38+uuvauV9fX1Rvnx5dO7cOVf1p6SkqCU1+XuEiIiI6NNxDi8iIiIiypOdO3di586dGssbNmyISpUqid9/+uknnDhxAufOncO7d+/QsGFDfPjwAQBQr149jYeF3t7e8Pb2xsOHD3H79m1ERUVBV1cXHTp0wNWrV5GYmIi0tDScOXMmy/lRAGDOnDmYNm0agPQ5ZDIOwbdgwQJxbpugoCBcuXIFQPrD3Oy0a9cOx44dg0wmgyAI8Pb2xokTJwAAW7duxerVq2FkZJTt9u/fv1dLqK1fvx6DBw8Wv1tYWGDt2rUA0ns+fPXVV9nWlZMPHz5g1KhR4vcaNWqgT58++aorK2/evBGPGwD69+8v/r9qGK5bt24hMDAQtWrVynW9S5YsyVMczs7OeSpfGAr7XJcGwcHBav/+Bw4cCAcHB+kC+ojhw4eLcz9Nnz4d9erVw7179wAAGzZswIwZMz5aR7ly5fJ8vZcrVy7vwRYC1XCGXbp0EZP0gYGBSEtLg7GxMeLj47F161ZxyEDVPFYDBgzIVf3F8XqIj4/HmTNnoKWlhS5dugBIf2Hh0KFDcHJywp07d7Bnzx6sXr0aBgYGePXqFU6cOIHRo0dnOWdZVsaPHy8OBWtoaIjJkycX2vEQERERlRZMeBERERFRodDS0sLmzZtRp04dvH//Xkx2GRkZYfv27RoPBZ8+fYqvv/4a/v7+Odb78uXLbNdlfMCa+YFpxqSEs7OzmPDKOExfVvWpHvDKZDJ8/fXXYuJHLpcjMDAQ7u7u2W5/9epVpKWlid+HDBmCIUOGZFk2ICAAiYmJOSbQshIeHo4uXbqIibsKFSrg4MGDanPDAMCgQYPy1OMio82bN0OhUABIPw99+/YFkN7zwcDAQBzWzdfXF8uXL891vaoEZEmR23NN2bt8+TK6du0q/rvz8PAQk77FVcYEu66uLvr06YOZM2cCSP99FBERoTZnU1ZMTU1L3PWuktX8Xd9++y2+/fZbTJkyBQsXLsSWLVswZcoUJCcnY+fOnejQoQOsrKw+WndxvR6OHj2KlJQUNG3aFDY2NgDS72kXL15EbGwsjh49itjYWBw8eBC9e/fG5s2boVQq1V5oyE5qaipGjhyJjRs3Aki/prZv344aNWoU6jERERERlQZMeBERERFRnvj6+uY6cVKxYkV069ZNfLAHpM9nUr16dY2y3bp1w507dz5aZ0pKSrbrKlSoIP535oRaxnUZ5ylSKpXZ1pf5gW3mh9oxMTE5xvr+/fsc12ckCALevXuXp4RXYGAgOnXqJA4n5uzsjOPHjxd4T6iMwxU2a9ZM7MlnYmKCjh074p9//gGQ3utt8eLFuZ4HaunSpXmKo2/fvmq9CItSUZ3rz9nOnTsxaNAgMUHaoUMH7N69u9jOaaaSm98DH0t4xcXFib3EcmvEiBEwNTXN0zYF7eHDh3jw4AHMzc3VhpdVGTRoEBYuXIj79+/j1q1bCAkJQUxMTK7uEcX5elAl+TLPWQYAZmZm6NatG3bs2IHNmzejd+/e8PPzQ+3atVGvXr0c642JiUHPnj1x5swZAOkvgOzatQsdO3Ys8GMgIiIiKo2Y8CIiIiKiQnP+/HmNuZ0OHDiAffv2qfUWCAkJUUt2ffXVV1i8eDEqVKgAmUwGKysrREVFfXR/qnm7spLbJExGkZGRat8jIiLUvpubm+e4feYhycaPH6+WeMvMzMws17EdO3YMffr0QXx8PACgSZMmOHDgACwtLXNdR26o5uNRuXTpktjrLbPIyEgcOXJEHALsY/I6hFfmYTOLSlGd68/Z/Pnz8csvv0AQBADpyZw1a9bk699lUYuMjFRL0uf19wCQnvzO6/Xeq1cvyRNeqnmsOnTokOXv1+rVq8Pd3R1Xr17Fli1bEBQUBAsLC3Tq1CnHeovz9ZCamoojR44AUO/VlpGPjw927NiBY8eO4eDBgwgJCcGKFStyrPfJkyfo2LGjOF+ZtbU1Dh48qDYvHBERERF9Gi2pAyAiIiKiz1N0dDS++eYbsQeVi4uLuG7YsGF4/fq1+F01j4lKr169YGdnB5lMhnPnzuUq2VUYtmzZIj6QFQQBW7duFdfp6el9dL4qd3d3aGtri991dXUxadIkjU+vXr1Qq1atXD/cXrt2LTp16iQmYFQ9BnJKwPj5+UEmk4mfp0+f5mpfmROWBV2+uMvPuZ41a5Z4notyLqJBgwaJ+23VqlWR7bdVq1bifjP37JHL5Rg0aBCmT58OQRAgk8mwcOFC/PHHH0WS3Mh4zef32ty8ebP436mpqdi1a5f43c7O7qO9u0qyrIYzzMzHxwcAsGnTJpw+fRpff/11ti8f5Pd6yOkaK2hnzpxBbGwsXF1dUbVq1SzLtG3bFhUqVEBqaiqGDBkCXV1dfP3119nWeenSJbi7u4vJLldXV1y9epXJLiIiIqICJv3rU0RERERUohw7dgxv377VWG5mZobhw4eL30eMGIEXL14AANzc3HD16lW0bt0aV69exbt37zBw4ECcPHkSMpkMVapUgZaWlpgc++GHHxAQEIB3797B19e3aA4sCydOnEDr1q3RsmVLXLx4EadPnxbXffXVVx8dfrBcuXIYMmQINmzYAABYvHgxbty4gWbNmsHAwACvXr3ClStXcPv2bfj4+MDLy+ujMS1btkxtLiA7Ozu4u7tjzZo1auUqVaokzrWVX8nJydixY4f43dHREY0bN9YoFxgYiPv37wMADh06hLdv38LCwuKj9auSicVVYZ3rX3/9VRzu8saNG+Ly6Ohotf1NmzYNZcuWzW/4eRYdHY358+erfVe5ceOGGFu5cuUwderUXNXZs2dPHDp0SPzevHlzaGtrawxn2axZMzRr1uxTwi80GzZsQFRUFGrXro2jR4/i3r174rqMv/Ny4uDgIPn1ntfrLjw8HFevXoW+vj7at2+fbb39+vXD+PHjxbpzmseqqK+HGzduiL/D4uLi1Nbt3LkTQUFBAIBGjRqJ/4Zzk+TT1tbGgAEDsHjxYrx9+xbdunXLNgnu7++P1q1bi8Px6unpoXv37ti9e7dG2ZI6zxsRERFRccGEFxERERHlyc6dO7Fz506N5fb29uLD340bN2LPnj0A0ns1/f333yhTpgz+/vtv1KtXD4mJiTh9+jSWLl2KyZMnw8rKCiNGjMD69esBAC9evMCcOXMAAK1bt0ZwcDBevXpVREf4fzp27IjDhw/j7NmzassdHBywaNGiXNWxcuVKhIWF4dSpUwDSew+o5m/Jj8DAQLXvr169wo8//qhRzsPD45MTXvv27VObp2zu3LlZ9mI4c+YMWrduDSC9B8zWrVvxww8/fNK+i4PCOtd//vknnj17prE8Li4Oy5YtE7+PGTOmSBNesbGxavvP6N69e2Kix97ePtcJr8zn8OLFi7h48aJGuZkzZxbbhFerVq2wb98+MRGi0qBBgyyvh+Iqr9fd/v37IQgC2rRpA2Nj42zrLVu2LLp06YLdu3ejbt26qFOnTrZli/p6CAoKyvaaPnbsGI4dOwYgvZda3759IQgCDhw4ACDr+bsy8vHxweLFiwEgx15nDx8+VJt7Ui6XqyWWM2LCi4iIiOjTcEhDIiIiIipQjx8/xvfffy9+nzZtGurXrw8AqFatmlqiaPr06bh16xYAYNWqVZgzZw7s7e2hq6uLypUrY/LkyTh48KBk87pMmjQJ27dvR4MGDWBgYIDy5cvDx8cH/v7+sLKyylUdRkZGOH78OLZt24YOHTrA2toaOjo6MDQ0hLOzM3r16oU///wTy5cvL+SjybuMQ8CZmZmhR48eWZbz9PRUG7rvcxvWMK8yzv3m7u7O/UokY1za2tpo0KBBvur566+/sHz5cri4uEBfXx+2trb44YcfcObMGRgaGhZUuMWOav6unHo6qaiGNSys4QaL6hq7evUqXr9+jYoVK6Jhw4Y5lnV1dUXDhg1haWmJDh06FFpMRERERJR7MkHqcRWIiIiIiIqJp0+fwtHRUfx+9uzZIp0LiQrGuXPn4OnpKX5fsmQJAKBq1aro2rUrgPSknGrotbJly4o9lho0aKC2bX64urriwYMHKFOmDIKDg1GxYsVPqi8qKgqbNm0CkD7M5smTJwGk9yw7d+4cAEChUKBs2bKIj4+HnZ0dgoOD1XrlDBo0SKyjYcOGYo+0bt26oUqVKvmOLTIyUpzDql69erhx4wa0tD7tvcpbt26JvSDXrVuHJ0+eAEjv9TNr1iwA6f82b968CSB9qD7V8Iu+vr5i0mXXrl3icX7//ff47bffPimu4qowruW4uDhYWloiLS0Nb968+WiCX6FQ4OTJk2jevDlMTEzytc/sFMY1lp2ff/4ZixYtwujRo7F69eqPlg8JCUFiYiLq1atX4LGsXr0aycnJCA0NFXs/A8V/KFgiIiIiKXFIQyIiIiIi+qxNnjwZANC1a1cx4ZVRdHS0WOaHH374pIRXZGQkHjx4AAD45ZdfPjnZBaQPpaiKLzu3bt1CfHw8gPS5x3Iagu7GjRviHE5VqlT5pITX+fPnAQAymQxr164tkETEf//999Hj3b9//0cTWKrYrK2txSFSP3cFdS0fOXIEcrkczZs3z1VvVm1tbXh7e+drXx9TGNdYdnIzf1dG1atXL7RYpk+fjtjY2EKrn4iIiOhzxIQXERERERFRAfnvv/8AADVq1MCECROKbL+qpEDr1q0/ee62/Ox38ODBaNKkSZHtNzdUsS1ZsgRmZmYSR1Oy9OvXD/369ZM6DABFe40FBwcXav1EREREVLg4pCERERER0f/HIQ2JiIiIiIiISiYmvIiIiIiIiIiIiIiIiKhEK7zBr4mIiIiIiIiIiIiIiIiKABNeREREREREREREREREVKIx4UVEREREREREREREREQlGhNeREREREREREREREREVKIx4UVEREREREREREREREQlGhNeREREREREREREREREVKIx4UVEREREREREREREREQlGhNeREREREREREREREREVKIx4UVEREREREREREREREQlGhNeREREREREREREREREVKIx4UVEREREREREREREREQlGhNeREREREREREREREREVKIx4UVEREREREREREREREQlGhNeREREREREREREREREVKIx4UVEREREREREREREREQlGhNeREREREREREREREREVKIx4UVEREREREREREREREQlGhNeREREREREREREREREVKIx4UVEREREREREREREREQlGhNeRERERESlQKtWrdCqVasCrfPp06eQyWTw8/Mr0Hopd86dOweZTIZz585JHUq2Xrx4AQMDA1y6dCnX2/j5+UEmk+Hp06cfLevg4IBBgwblKzaZTIZZs2bla7+Ud6mpqahUqRLWrl0rdShERJQHn3Kv/RS8LxNRfjDhRVSEVDdr1UdHRwd2dnYYNGgQXr16JXV44kMrmUyGefPmZVnm66+/hkwmg7GxcRFHR5n5+/tj1qxZiImJydN2586dQ48ePWBjYwM9PT1YWVmhc+fO2Lt3b+EEmkeJiYmYNWtWsX54R0RUFAIDA9GrVy/Y29vDwMAAdnZ2aNu2LVatWlXksWzbtg0rV64s8v3mRnG/r5V2c+bMgbu7O5o3by4uGzRokFqbOOPn2LFjEkarae3atUWW0H316hX69OkDc3NzmJqaomvXrnjy5Emutk1NTcXs2bPh5OQEfX19ODk5Yd68eUhLS9Moe/PmTXh7e8PU1BQmJiZo164dAgICCr1OXV1dTJgwAfPnz0dycnKujouIqDjJ/EzHwMAA1apVw5gxYxAREVHg+8vv38YHDx6Eh4cHrKysYGRkBCcnJ/Tp06fY3WNVfv31V+zbt0/qMNTI5XL89ttvqFevHkxNTWFubg43NzeMGDECwcHBUocnucxtOX19fVSrVg0zZszI9z3+/v37mDVrFhOc9Ml0pA6AqDSaM2cOHB0dkZycjCtXrsDPzw8XL15EUFAQDAwMpA4PBgYG2L59O6ZPn662PCEhAfv37y8WMVJ6wmv27NkYNGgQzM3Nc7XNzJkzMWfOHFStWhXffvst7O3t8e7dOxw5cgQ9e/bE1q1b8dVXXxVu4B+RmJiI2bNnA0CB90QgIiop/P394enpicqVK2P48OGwsbHBixcvcOXKFfz2228YO3Zskcazbds2BAUFYdy4cWrL7e3tkZSUBF1d3SKNR6Uk3NcKU8uWLZGUlAQ9PT2pQ8lSVFQUNm3ahE2bNmms09fXx19//aWxvE6dOmjbti369esHfX39oghT9M0332jsd+3atbCwsCj0N9s/fPgAT09PxMbGYurUqdDV1cWKFSvg4eGBgIAAlC9fPsftBwwYgN27d2PIkCFo2LAhrly5gl9++QXPnz/Hn3/+KZa7desWvvjiC1SqVAkzZ86EUqnE2rVr4eHhgWvXrqF69eqFWufgwYPx888/Y9u2bRgyZEgBnkEioqKT8ZnOxYsXsW7dOhw5cgRBQUEwMjIqsP3k52/jpUuXYvLkyfDw8MCUKVNgZGSEx48f49SpU9ixYwe8vb0LLL6C8uuvv6JXr17o1q2b2vKs7stFpWfPnjh69Cj69++P4cOHIzU1FcHBwTh06BCaNWuGGjVqFHlMxU3GtlxsbCz279+PuXPnIjQ0FFu3bs1zfffv38fs2bPRqlUrODg4FHC0VKoIRFRkfH19BQDC9evX1Zb/9NNPAgBh586dEkWWLiwsTAAg9OjRQwAgBAQEqK3funWroKurK3Tu3FkoU6aMRFEWjKSkJEGhUEgdxidZsmSJAEAICwvLVfndu3cLAIRevXoJcrlcY/2xY8eEgwcPFnCUeRcVFSUAEGbOnCl1KEREkunQoYNgaWkpREdHa6yLiIjIV50eHh6Ch4dHvrbt2LGjYG9vn69tC0tJua8VhpLSjlm+fLlgaGgoxMfHqy338fEpsLakvb294OPjk69tc9PecHNzy/e/m7xYtGiRAEC4du2auOzBgweCtra2MGXKlBy3vXbtmgBA+OWXX9SWT5w4UZDJZMKdO3fEZR06dBDKli0rvH37Vlz2+vVrwdjYWOjRo0eh1qnSqVMnoUWLFjkeExFRcZTdM50JEyYIAIRt27YV6P7y+rdxamqqYGpqKrRt2zbL9fltQ37KvTY3ypQpU6j155XqHjh//nyNdWlpaWr3u9Iqq7acUqkUmjRpIshkMiE8PDzPdara9mfPni2gKKm04pCGRMVAixYtAAChoaHiMrlcjhkzZqBBgwYwMzNDmTJl0KJFC5w9e1Zt2/r166NHjx5qy2rVqgWZTIa7d++Ky3bu3AmZTIYHDx58NJ6mTZvC0dER27ZtU1u+detWeHt7o1y5cllud/ToUbRo0QJlypSBiYkJOnbsiHv37qmVuXv3LgYNGgQnJycYGBjAxsYGQ4YMwbt379TKxcfHY9y4cXBwcIC+vj6srKzQtm1b3Lp1SyyT3TjSmecoUc1vsWPHDkyfPh12dnYwMjJCXFwcAODq1avw9vaGmZkZjIyM4OHhoTHPxKxZsyCTyfDw4UMMGDAAZmZmsLS0xC+//AJBEPDixQt07doVpqamsLGxwbJlyzTiSklJwcyZM1GlShXo6+ujUqVK+PHHH5GSkqJWTiaTYcyYMdi3bx9q1qwJfX19uLm5qQ0/MGvWLEyePBkA4OjoKHYjz6nr9y+//IJy5cph48aNWb6J7+XlhU6dOonfIyMjMXToUFhbW8PAwAB16tTReEM7u7lDsprTZdCgQTA2NsarV6/QrVs3GBsbw9LSEpMmTYJCoRC3s7S0BADMnj1bPC7V/Brh4eEYPHgwKlasCH19fdja2qJr167s8k5En53Q0FC4ubll2YPXyspK7XtaWhrmzp0LZ2dn6Ovrw8HBAVOnTtW4v2SW3bwImX+3t2rVCocPH8azZ8/E38uqty6zm8PrzJkzYpvA3NwcXbt21WiDqO6tjx8/Fnsrm5mZYfDgwUhMTPzoOSqM+5rqeJYuXYo1a9bAyckJRkZGaNeuHV68eAFBEDB37lxUrFgRhoaG6Nq1K96/f69Wh4ODAzp16oQTJ06gbt26MDAwgKurq8YQi+/fv8ekSZNQq1YtGBsbw9TUFO3bt8edO3ey/Hlk1Y7J6j786NEj9OzZEzY2NjAwMEDFihXRr18/xMbGimVye82ojuXixYto3LgxDAwM4OTkhL///vujPx8A2LdvH9zd3fM8FHZW16YgCJg3bx4qVqwIIyMjeHp6arQzVWJiYjBu3DhUqlQJ+vr6qFKlChYtWgSlUpmn/To4OODevXs4f/68eO23atUKT548gUwmw4oVKzTq8Pf3h0wmw/bt25GYmIjg4GC8ffv2o8e8Z88eNGrUCI0aNRKX1ahRA61bt8auXbty3PbChQsAgH79+qkt79evHwRBwM6dO9XKtmnTRq3HmK2tLTw8PHDo0CF8+PCh0OpUadu2LS5evKjxb4eIqKT68ssvAQBhYWEAcn+fvXHjBry8vGBhYQFDQ0M4OjqKvV8/9rdxVt6+fYu4uDi1YYQzytyGzO0ziqzk9l6rVCrx22+/oVatWjAwMIClpSW8vb1x48YNAOnPPxISErBp0ybxGFXPebJrq65duxZubm7Q19dHhQoVMHr0aI2pHlq1aoWaNWvi/v378PT0hJGREezs7LB48eKPHpvq2VxW51FbW1vtfjdo0KAseyOp2rmZbdmyBY0bN4aRkRHKli2Lli1b4sSJE2pljh49Cg8PD5iYmMDU1BSNGjXSeD6Xm+dYuXmulpt2Y27JZDJ88cUXEARBbUjmZ8+eYdSoUahevToMDQ1Rvnx59O7dW+3n6ufnh969ewMAPD09xWshYxs3N88ciQAOaUhULKh+yZctW1ZcFhcXh7/++kvsPh0fH4///e9/8PLywrVr11C3bl0A6cmy7du3i9u9f/8e9+7dg5aWFi5cuIDatWsDSP9D1NLSEi4uLrmKqX///tiyZQsWLlwImUyGt2/f4sSJE9i8eXOW4z5v3rwZPj4+8PLywqJFi5CYmIh169bhiy++wO3bt8UGwMmTJ/HkyRMMHjwYNjY2uHfvHv7880/cu3cPV65cERsEI0eOxJ49ezBmzBi4urri3bt3uHjxIh48eID69evn9RQDAObOnQs9PT1MmjQJKSkp0NPTw5kzZ9C+fXs0aNAAM2fOhJaWFnx9ffHll1/iwoULaNy4sVodffv2hYuLCxYuXIjDhw9j3rx5KFeuHP744w98+eWXWLRoEbZu3YpJkyahUaNGaNmyJYD0Rl6XLl1w8eJFjBgxAi4uLggMDMSKFSvw8OFDjfGqL168iL1792LUqFEwMTHB77//jp49e+L58+coX748evTogYcPH2L79u1YsWIFLCwsAEBsEGf26NEjBAcHY8iQITAxMfnouUpKSkKrVq3w+PFjjBkzBo6Ojti9ezcGDRqEmJgY/PDDD/n4CQAKhQJeXl5wd3fH0qVLcerUKSxbtgzOzs747rvvYGlpiXXr1uG7775D9+7dxWSu6jru2bMn7t27h7Fjx8LBwQGRkZE4efIknj9/zi7vRPRZsbe3x+XLlxEUFISaNWvmWHbYsGHYtGkTevXqhYkTJ+Lq1atYsGABHjx4gH///feTY5k2bRpiY2Px8uVL8QF/TgmMU6dOoX379nBycsKsWbOQlJSEVatWoXnz5rh165bG7+s+ffrA0dERCxYswK1bt/DXX3/BysoKixYtynYfhX1f27p1K+RyOcaOHYv3799j8eLF6NOnD7788kucO3cOP/30Ex4/foxVq1Zh0qRJ2Lhxo0Z8ffv2xciRI+Hj4wNfX1/07t0bx44dQ9u2bQEAT548wb59+9C7d284OjoiIiICf/zxBzw8PHD//n1UqFBBrc6s2jGZyeVyeHl5ISUlBWPHjoWNjQ1evXqFQ4cOISYmBmZmZgDyds08fvwYvXr1wtChQ+Hj44ONGzdi0KBBaNCgAdzc3LI956mpqbh+/Tq+++67bMtkTgTp6uqKMWY2Y8YMzJs3Dx06dECHDh1w69YttGvXDnK5XK1cYmIiPDw88OrVK3z77beoXLky/P39MWXKFLx58yZPc9GtXLkSY8eOhbGxMaZNmwYAsLa2hpOTE5o3b46tW7di/Pjxatts3boVJiYm6Nq1K65duwZPT0/MnDkzxweUSqUSd+/ezXKIv8aNG+PEiROIj4/P9lpXPZg0NDRUW64aVuvmzZtqZTOXU5WVy+UICgpCkyZNCqVOlQYNGkAQBPj7+6slpYmISipVgkSVCMnNfTYyMhLt2rWDpaUlfv75Z5ibm+Pp06fiCzIf+9s4K1ZWVjA0NMTBgwcxduzYbF9WBvL+jCKjvNxrhw4dCj8/P7Rv3x7Dhg1DWloaLly4gCtXrqBhw4bYvHkzhg0bhsaNG2PEiBEAAGdn52z3PWvWLMyePRtt2rTBd999h5CQEKxbtw7Xr1/HpUuX1F6Cio6Ohre3N3r06IE+ffpgz549+Omnn1CrVi20b98+233Y29sDSL+nN2/eHDo6BfP4fPbs2Zg1axaaNWuGOXPmQE9PD1evXsWZM2fQrl07AOmJnyFDhsDNzQ1TpkyBubk5bt++jWPHjonDdOf2OdbHnqvltt2YF1k937x+/Tr8/f3Rr18/VKxYEU+fPsW6devQqlUr3L9/H0ZGRmjZsiW+//57/P7775g6dar47FL1/7l95kgEgEMaEhUlVff3U6dOCVFRUcKLFy+EPXv2CJaWloK+vr7w4sULsWxaWpqQkpKitn10dLRgbW0tDBkyRFym6vJ7//59QRAE4cCBA4K+vr7QpUsXoW/fvmK52rVrC927d88xPtWQhkuWLBGCgoIEAMKFCxcEQRCENWvWCMbGxkJCQoJG1+X4+HjB3NxcGD58uFp94eHhgpmZmdryxMREjf1u375dACD8999/4jIzMzNh9OjROcabXbf6zEM2nT17VgAgODk5qe1fqVQKVatWFby8vASlUqkWo6Ojo9owADNnzhQACCNGjBCXpaWlCRUrVhRkMpmwcOFCcXl0dLRgaGioFtvmzZsFLS0t8XyqrF+/XgAgXLp0SVwGQNDT0xMeP34sLrtz544AQFi1apW4LC9DGu7fv18AIKxYseKjZQVBEFauXCkAELZs2SIuk8vlQtOmTQVjY2MhLi5OEIT/O7eZu5yrriVfX19xmY+PjwBAmDNnjlrZevXqCQ0aNBC/ZzdsQ3R0tHh9EhF97k6cOCFoa2sL2traQtOmTYUff/xROH78uMbQfQEBAQIAYdiwYWrLJ02aJAAQzpw5Iy7LfH9UtUsy30ey+t2e3ZCGWf2+r1u3rmBlZSW8e/dOXHbnzh1BS0tLGDhwoLhMdW/N2K4RBEHo3r27UL58+exOjSAIhXdfUx2PpaWlEBMTI5adMmWKAECoU6eOkJqaKi7v37+/oKenJyQnJ4vL7O3tBQDCP//8Iy6LjY0VbG1thXr16onLkpOTNYYlDAsLE/T19dXuldm1YzKuU/2sbt++LQAQdu/ene25yMs1ozqWjG20yMhIQV9fX5g4cWK2+xAEQXj8+LFG20VF1SbI/FFdn5mvzcjISEFPT0/o2LGjWptt6tSpAgC1NtfcuXOFMmXKCA8fPlTb588//yxoa2sLz58/F5dlbm9k9W8iuyEN//jjDwGA8ODBA3GZXC4XLCwsxHhUP5+PDUWlavtkbiMJQnobHIAQHByc7fb//POPAEDYvHmz2nJVO7NmzZrislq1agnVqlUT0tLSxGUpKSlC5cqVBQDCnj17Cq1OldevXwsAhEWLFuV0WoiIip2snuns2LFDKF++vGBoaCi8fPky1/fZf//9N8vhETPKz3D/M2bMEAAIZcqUEdq3by/Mnz9fuHnzpka5vDyjyPzsJbf32jNnzggAhO+//15j/xnv59kNaZhde6Bdu3ZqbajVq1cLAISNGzeKyzw8PAQAwt9//y0uS0lJEWxsbISePXtq7CtzbKrtra2thf79+wtr1qwRnj17plHWx8cnyzayqp2r8ujRI0FLS0vo3r27RvtPdS5iYmIEExMTwd3dXUhKSsqyTF6eY33suVpu2o3ZUT0XjIqKEqKiooTHjx8LS5cuFWQymVCzZk2N2DK7fPmyxs8nuyEN8/LMkUgQOKQhkSTatGkDS0tLVKpUCb169UKZMmVw4MABVKxYUSyjra0tvrmrVCrx/v17pKWloWHDhmrdj1XDIf73338A0ntyNWrUCG3bthWHIomJiUFQUJBYNjfc3NxQu3ZtsffYtm3b0LVr1ywnYD158iRiYmLQv39/vH37Vvxoa2vD3d1dbRjGjG9/Jicn4+3bt+IbnxmPy9zcHFevXsXr169zHfPH+Pj4qO0/ICAAjx49wldffYV3796JcSckJKB169b477//NLrjDxs2TPxvbW1tNGzYEIIgYOjQoWqxV69eXa0L9+7du+Hi4oIaNWqonSPV0AeZh6ps06aN2ltNtWvXhqmpqVqdeaEavjE3b8EDwJEjR2BjY4P+/fuLy3R1dfH999/jw4cPOH/+fL7iANLfMsqoRYsWuTouQ0ND6Onp4dy5c4iOjs73/omISoK2bdvi8uXL6NKlC+7cuYPFixfDy8sLdnZ2OHDggFjuyJEjAIAJEyaobT9x4kQAwOHDh4suaABv3rxBQEAABg0apPZWce3atdG2bVsx3oyyui+8e/dOvHdlpbDva71791Z7q9Xd3R0AMGDAALW3fN3d3SGXy/Hq1Su17StUqIDu3buL301NTTFw4EDcvn0b4eHhANIn+tbSSv9zTKFQ4N27dzA2Nkb16tXV2kQqmdsxWVHFfPz48WyHhczrNePq6qrWhrS0tNRo52RFNVx1xjd8MzIwMMDJkyfVPlkNCQ2k9xpU9bjLODzQuHHjNMru3r0bLVq0QNmyZdXaXG3atIFCoRDbzJ+qT58+MDAwUJuU/fjx43j79i0GDBgAIH04JUEQcuzdBaT3QATSr4nMDAwM1MpkpUOHDrC3t8ekSZOwd+9ePHv2DLt27cK0adOgo6Ojtu2oUaPw8OFDDB06FPfv30dQUBAGDhyIN2/eqO2nMOpUUV0TuRnqkYioOMr4TKdfv34wNjbGv//+Czs7u1zfZ1XDVh86dAipqakFFtvs2bOxbds21KtXD8ePH8e0adPQoEED1K9fX2146bw+o8got/faf/75BzKZDDNnztSoI6vh/j5G1R4YN26c2IYCgOHDh8PU1FSjDWNsbCzekwFAT08PjRs3/mgbRiaT4fjx45g3bx7Kli2L7du3Y/To0bC3t0ffvn01hk/MjX379kGpVGLGjBlqsav2B6Q/W4uPj8fPP/8s3v8zl8nLc6yPPVfLTbsxJwkJCbC0tISlpSWqVKmCSZMmoXnz5ti/f7/azzdj+zU1NRXv3r1DlSpVYG5unmWbN7O8PHMkAgAmvIgksGbNGpw8eRJ79uxBhw4d8Pbt2yz/wN20aRNq164NAwMDlC9fHpaWljh8+LDaWLrW1taoWrWqmNy6cOECWrRogZYtW+L169d48uQJLl26BKVSmaeEFwB89dVX2L17Nx4/fgx/f3+x+3Rmjx49ApA+brXqZqf6nDhxApGRkWLZ9+/f44cffoC1tTUMDQ1haWkJR0dHAFA7rsWLFyMoKAiVKlVC48aNMWvWrHwne1RU+8kct4+Pj0bcf/31F1JSUjTGLa5cubLadzMzMxgYGIhDCmZcnjEp8+jRI9y7d09jP9WqVQMAtXOU1X6A9IcD+U30mJqaAkgfwzk3nj17hqpVq2o0xFTdyZ89e5avOFRjdmeU2+PS19fHokWLcPToUVhbW6Nly5ZYvHix+OCQiOhz06hRI+zduxfR0dG4du0apkyZgvj4ePTq1Qv3798HkP77WEtLC1WqVFHb1sbGBubm5vn+fZ1fqv1Vr15dY52Li4v4B3lGme95qofhOd0bCvu+ltX9HgAqVaqU5fLMsVapUkXjQY7qnq8a6kWpVGLFihWoWrUq9PX1YWFhAUtLS9y9ezfLeRMyt2Oy4ujoiAkTJuCvv/6ChYUFvLy8sGbNGrX68nrNfGqbRBCELJdra2ujTZs2ap8GDRpkWVYVU9WqVdWWW1paaiTUHj16hGPHjmm0udq0aQNAs82VX+bm5ujcubPanBpbt26FnZ2d+LAwt1QPgrKaMyU5OVmtTFYMDAxw+PBhlC9fHj179oSDgwMGDhyIGTNmoFy5cmpDkI4cORJTp07Ftm3b4Obmhlq1aiE0NBQ//vgjgP8brrQw6lRRXRP5edhJRFQcqJ7pnD17Fvfv38eTJ0/g5eUFIPf3WQ8PD/Ts2ROzZ8+GhYUFunbtCl9f31zNn5WUlITw8HC1T0b9+/fHhQsXEB0djRMnTuCrr77C7du30blzZ/G+ktdnFBnl9l4bGhqKChUq5Di0Yl5k187U09ODk5OTRhumYsWKGveavDx/mDZtGh48eIDXr19j+/btaNKkCXbt2oUxY8bkOfbQ0FBoaWnB1dU1xzIAchzOPC/PsT72XC037cacZHx5ydfXFy4uLoiMjNRosyQlJWHGjBnifG+qNm9MTEyu9pWXZ45EAOfwIpJE48aN0bBhQwBAt27d8MUXX+Crr75CSEiI+Afhli1bMGjQIHTr1g2TJ0+GlZUVtLW1sWDBAvEmqPLFF1/g9OnTSEpKws2bNzFjxgzUrFkT5ubmuHDhAh48eABjY2PUq1cvT3H2798fU6ZMwfDhw1G+fHlxTOHMVG+PbN68GTY2NhrrM74J3adPH/j7+2Py5MmoW7cujI2NoVQq4e3trdabqk+fPmjRogX+/fdfnDhxAkuWLMGiRYuwd+9ecazl7P5IVigU0NbW1lie+aar2t+SJUvEOdEyy/wHelb1ZrUMUH/Ao1QqUatWLSxfvjzLspkfoOWmzryoUaMGACAwMDBf22cnp59BVrI7rtwaN24cOnfujH379uH48eP45ZdfsGDBApw5cybP1zcRUUmhp6eHRo0aoVGjRqhWrRoGDx6M3bt3q70tm58Hx3n9HV5Y8nPPK6z72sdiKsj786+//opffvkFQ4YMwdy5c1GuXDloaWlh3LhxGj3MgZwTHhktW7YMgwYNwv79+3HixAl8//33WLBgAa5cuaI2mkBur5n8HrNqHpOi7pWtVCrRtm1bMdmSmepBXkEYOHAgdu/eDX9/f9SqVQsHDhzAqFGjNBKrH1OuXDno6+uLPaIyUi3LPKdbZm5ubggKCsL9+/cRHR0NV1dXGBoaYvz48fDw8FArO3/+fEyaNAn37t2DmZkZatWqhalTpwJQPz+FUSfwf9dE5hfGiIhKiozPdLLzsfusTCbDnj17cOXKFRw8eBDHjx/HkCFDsGzZMly5ciXH+VJ37tyJwYMHqy3L6r5samqKtm3bom3bttDV1cWmTZtw9epVeHh45PkZRUZFea/9FAXVbrO1tUW/fv3Qs2dPuLm5YdeuXfDz84OOjk6Rt6fz8hwrN8/VcttuzIrq5SUVLy8v1KhRA99++63aiBRjx46Fr68vxo0bh6ZNm8LMzAwymQz9+vXLss2b3THn5pkjEcCEF5HkVEksT09PrF69Gj///DMAYM+ePXBycsLevXvVbqBZdQVv0aIFfH19sWPHDigUCjRr1gxaWlr44osvxIRXs2bN8pxsqFy5Mpo3b45z587hu+++y/Ymohp6z8rKSu1ml1l0dDROnz6N2bNnY8aMGeJy1dsamdna2mLUqFEYNWoUIiMjUb9+fcyfP1+8MZctWzbLruTPnj2Dk5PTR49PFbepqWmOcRcEZ2dn3LlzB61bty6wt1nzUk+1atVQvXp17N+/H7/99luOjWcgfZLWu3fvQqlUqj20CQ4OFtcD//cWfuafw6f0KPjYcTk7O2PixImYOHEiHj16hLp162LZsmXYsmVLvvdJRFRSqB6uqB6C29vbQ6lU4tGjR2JvJQCIiIhATEyM+Ps6K3n5HZ7be45qfyEhIRrrgoODYWFhgTJlyuSqrpwU1n2toDx+/BiCIKidt4cPHwKAOKn2nj174Onpif/9739q28bExHxyIqBWrVqoVasWpk+fDn9/fzRv3hzr16/HvHnzPumayYvKlSvD0NAQYWFhn1yXKqZHjx6ptfGioqI0EmrOzs748OFDgbXtcrr2vb29YWlpia1bt8Ld3R2JiYn45ptv8rwPLS0t1KpVCzdu3NBYd/XqVTg5OeVq+E6ZTAY3Nzfx+5EjR6BUKrM8F2XLlsUXX3whfj916hQqVqwoJpMLs07VNZHx+iMi+lzk9T7bpEkTNGnSBPPnz8e2bdvw9ddfY8eOHRg2bFi29yAvLy+cPHkyT3E1bNgQmzZtEtuQn/KMIrf3WmdnZxw/fhzv37/PsZdXftqZGdsDcrkcYWFhhf5cR1dXF7Vr18ajR4/w9u1b2NjY5PhcKiNnZ2colUrcv38/20SV6hlVUFCQRg/BzGVy+xzrY8/VgJzbjXlha2uL8ePHY/bs2bhy5Yo4fcmePXvg4+OjNnR1cnKyxnnL7jrI7TNHIhUOaUhUDLRq1QqNGzfGypUrxe7lquRUxjdPrl69isuXL2tsrxqqcNGiRahdu7Y4vE6LFi1w+vRp3LhxI8/DGarMmzcPM2fOxNixY7Mt4+XlBVNTU/z6669Zjj0dFRWV7TEBwMqVK9W+KxQKjW7NVlZWqFChglr3fmdnZ1y5cgVyuVxcdujQIbx48SJXx9agQQM4Oztj6dKl+PDhQ7ZxF4Q+ffrg1atX2LBhg8a6pKQkjeGdckP1wDC340fPnj0b7969w7Bhw5CWlqax/sSJEzh06BCA9HkbwsPDsXPnTnF9WloaVq1aBWNjY/GtXnt7e2hra2vMh7F27do8H4+Kap64zMeVmJgo/vtQcXZ2homJSa6GfSAiKknOnj2b5dunqnkhVEO5dOjQAYDmvVT1tm7Hjh2z3Yfqj8eMv8MVCgX+/PNPjbJlypTJ1ZAjtra2qFu3LjZt2qT2ezwoKAgnTpwQ4y0IhXFfKyivX7/Gv//+K36Pi4vD33//jbp164pvpmpra2v8jHfv3q0xH1hexMXFaZyLWrVqQUtLS7xXfso1kxe6urpo2LBhlkmcvGrTpg10dXWxatUqtXOW+RiA9DbX5cuXcfz4cY11MTExWV4rOSlTpky2bS0dHR30799ffNO7Vq1aqF27trg+MTERwcHBuZqrqlevXrh+/bra+QoJCcGZM2fQu3dvtbLBwcF4/vx5jvUlJSXhl19+ga2trdrcdVnZuXMnrl+/rjEnSmHVefPmTchkMjRt2jTHOoiISqLc3mejo6M12gGqRIjqnp3d38a2trYawwID6fedrJ4ZAcDRo0cB/F8b8lOeUeT2XtuzZ08IgoDZs2drlMt47DndazNq06YN9PT08Pvvv6tt/7///Q+xsbEF1oZ59OhRlvfZmJgYXL58GWXLlhWnanB2dkZsbCzu3r0rlnvz5o1aOxBIH91JS0sLc+bM0ejVpDqWdu3awcTEBAsWLNB49qEqk9vnWLl5rpabdmNejR07FkZGRli4cKG4LKs276pVqzR6wWX3jCu3zxyJVNjDi6iYmDx5Mnr37g0/Pz+MHDkSnTp1wt69e9G9e3d07NgRYWFhWL9+PVxdXTVualWqVIGNjQ1CQkLUElMtW7bETz/9BAD5Tnh5eHh89CGQqakp1q1bh2+++Qb169dHv379YGlpiefPn+Pw4cNo3rw5Vq9eDVNTU3HepdTUVNjZ2eHEiRMab/7Gx8ejYsWK6NWrF+rUqQNjY2OcOnUK169fV3sjZNiwYdizZw+8vb3Rp08fhIaGYsuWLeIDvI/R0tLCX3/9hfbt28PNzQ2DBw+GnZ0dXr16hbNnz8LU1BQHDx7M+0nLwjfffINdu3Zh5MiROHv2LJo3bw6FQoHg4GDs2rULx48f/+iQCJmp5rmYNm0a+vXrB11dXXTu3DnbN+f79u2LwMBAzJ8/H7dv30b//v1hb2+Pd+/e4dixYzh9+rQ4D8WIESPwxx9/YNCgQbh58yYcHBywZ88eXLp0CStXrhTfMjYzM0Pv3r2xatUqyGQyODs749ChQ580hrKhoSFcXV2xc+dOVKtWDeXKlUPNmjWRlpaG1q1bo0+fPnB1dYWOjg7+/fdfREREoF+/fvneHxFRcTR27FgkJiaie/fuqFGjBuRyOfz9/bFz5044ODiIw9jUqVMHPj4++PPPPxETEwMPDw9cu3YNmzZtQrdu3eDp6ZntPtzc3NCkSRNMmTJFfPN2x44dWSYEGjRogJ07d2LChAlo1KgRjI2N0blz5yzrXbJkCdq3b4+mTZti6NChSEpKwqpVq2BmZoZZs2YVyPkBCue+VlCqVauGoUOH4vr167C2tsbGjRsREREBX19fsUynTp0wZ84cDB48GM2aNUNgYCC2bt2aq17q2Tlz5gzGjBmD3r17o1q1akhLS8PmzZuhra2Nnj17Avi0ayavunbtimnTpiEuLk6cdy0/LC0tMWnSJCxYsACdOnVChw4dcPv2bRw9elSjN9zkyZNx4MABdOrUCYMGDUKDBg2QkJCAwMBA7NmzB0+fPs1TD7oGDRpg3bp1mDdvHqpUqQIrKyu1OboGDhyI33//HWfPnsWiRYvUtr127Ro8PT0xc+bMj177o0aNwoYNG9CxY0dMmjQJurq6WL58OaytrTFx4kS1si4uLvDw8MC5c+fEZX369EGFChXg6uqKuLg4bNy4EU+ePMHhw4fVru///vsPc+bMQbt27VC+fHlcuXIFvr6+8Pb2xg8//KC2n8KoE0iffL558+bisJdERJ+T3N5nN23ahLVr16J79+5wdnZGfHw8NmzYAFNTUzFplt3fxtnN8ZSYmIhmzZqhSZMm8Pb2RqVKlRATE4N9+/bhwoUL6NatmzgVwKc8o8jtvdbT0xPffPMNfv/9dzx69EicyuLChQvw9PQU58Jq0KABTp06heXLl6NChQpwdHSEu7u7xn4tLS0xZcoUzJ49G97e3ujSpQtCQkKwdu1aNGrUCAMGDPjknx8A3LlzB1999RXat2+PFi1aoFy5cnj16hU2bdqE169fY+XKleIL3f369cNPP/2E7t274/vvv0diYiLWrVuHatWq4datW2KdVapUwbRp0zB37ly0aNECPXr0gL6+Pq5fv44KFSpgwYIFMDU1xYoVKzBs2DA0atQIX331FcqWLYs7d+4gMTERmzZtyvVzrNw8V8tNuzGvypcvj8GDB2Pt2rV48OABXFxc0KlTJ2zevBlmZmZwdXXF5cuXcerUKY12QN26daGtrY1FixYhNjYW+vr6+PLLL2FlZZWrZ45EIoGIioyvr68AQLh+/brGOoVCITg7OwvOzs5CWlqaoFQqhV9//VWwt7cX9PX1hXr16gmHDh0SfHx8BHt7e43te/fuLQAQdu7cKS6Ty+WCkZGRoKenJyQlJX00vrCwMAGAsGTJkhzL+fj4CGXKlNFYfvbsWcHLy0swMzMTDAwMBGdnZ2HQoEHCjRs3xDIvX74UunfvLpibmwtmZmZC7969hdevXwsAhJkzZwqCIAgpKSnC5MmThTp16ggmJiZCmTJlhDp16ghr167V2OeyZcsEOzs7QV9fX2jevLlw48YNwcPDQ/Dw8FCLC4Cwe/fuLI/n9u3bQo8ePYTy5csL+vr6gr29vdCnTx/h9OnTYpmZM2cKAISoqKhcnQsPDw/Bzc1NbZlcLhcWLVokuLm5Cfr6+kLZsmWFBg0aCLNnzxZiY2PFcgCE0aNHa9Rpb28v+Pj4qC2bO3euYGdnJ2hpaQkAhLCwsCyPMaPTp08LXbt2FaysrAQdHR3B0tJS6Ny5s7B//361chEREcLgwYMFCwsLQU9PT6hVq5bg6+urUV9UVJTQs2dPwcjISChbtqzw7bffCkFBQQIAtfLZnSvVuc3I399faNCggaCnpydeG2/fvhVGjx4t1KhRQyhTpoxgZmYmuLu7C7t27froMRMRlTRHjx4VhgwZItSoUUMwNjYW9PT0hCpVqghjx44VIiIi1MqmpqYKs2fPFhwdHQVdXV2hUqVKwpQpU4Tk5GS1cpnvj4IgCKGhoUKbNm0EfX19wdraWpg6dapw8uRJAYBw9uxZsdyHDx+Er776SjA3NxcAiG0RVdsh8/3h1KlTQvPmzQVDQ0PB1NRU6Ny5s3D//n21MtndW1Xtpdzc0wShYO9r2bWFsmtLZNW2s7e3Fzp27CgcP35cqF27tqCvry/UqFFDY9vk5GRh4sSJgq2trWBoaCg0b95cuHz5cp7aMap1qp/VkydPhCFDhgjOzs6CgYGBUK5cOcHT01M4deqU2na5vWZUx5JZVtdSViIiIgQdHR1h8+bNasuzaxOoZHUNKBQKYfbs2eL5atWqlRAUFJRl+yg+Pl6YMmWKUKVKFUFPT0+wsLAQmjVrJixdulSQy+ViuYztz+z2Gx4eLnTs2FEwMTERAGR53G5uboKWlpbw8uVLteWqn0/GfeTkxYsXQq9evQRTU1PB2NhY6NSpk/Do0SONclnFsWjRIqFGjRqCgYGBULZsWaFLly7C7du3NbZ9/Pix0K5dO8HCwkK8NhcsWCCkpKRolC2MOmNiYgQ9PT3hr7/+ytU5ISIqTnJ6ppNRbu6zt27dEvr37y9UrlxZ0NfXF6ysrIROnTqpPT8RhKz/Ns5pvxs2bBC6desmPksyMjIS6tWrJyxZskTj93Jun1F8yr02LS1NWLJkiVCjRg1BT09PsLS0FNq3by/cvHlTLBMcHCy0bNlSMDQ0FACI+8quTbh69WqhRo0agq6urmBtbS189913QnR0tFqZrJ7JCIKQ7TO1jCIiIoSFCxcKHh4egq2traCjoyOULVtW+PLLL4U9e/ZolD9x4oRQs2ZNQU9PT6hevbqwZcuWLJ9zCIIgbNy4UahXr554vj08PISTJ0+qlTlw4IDQrFkzsR3duHFjYfv27WplPvYcKzfP1XLbbsxKTm250NBQQVtbW/w5RkdHi21wY2NjwcvLSwgODs7yutqwYYPg5OQkaGtra/w9kptnjkSCIAgyQcjHDMtERERERESkwcHBATVr1hSHUyzthg4diocPH+LChQtSh1Jo6tWrh3LlyuH06dNSh1LsrVy5EosXL0ZoaCgMDQ2lDoeIiIiIPjOcw4uIiIiIiIgKxcyZM3H9+nVcunRJ6lAKxY0bNxAQEICBAwdKHUqxl5qaiuXLl2P69OlMdhERERFRoeAcXkRERERERFQoKleurDHx+ucgKCgIN2/exLJly2Bra4u+fftKHVKxp6uri+fPn0sdBhERERF9xtjDi4iIiIiIiCgP9uzZg8GDByM1NRXbt2+HgYGB1CEREREREZV6nMOLiIiIiIiIiIiIiIiISjT28CIiIiIiIiIiIiIiIqISjQkvIiIiIiIiIiIiIiIiKtF0pA6gJFAqlXj9+jVMTEwgk8mkDoeIiIgKgSAIiI+PR4UKFaClVbrfCWLbh4iI6PPGdg8RERF9jpjwyoXXr1+jUqVKUodBREREReDFixeoWLGi1GFIim0fIiKi0oHtHiIiIvqcMOGVCyYmJgDSG4KmpqYSR0NERESFIS4uDpUqVRLv+6UZ2z5ERESfN7Z7iIiI6HPEhFcuqIbyMTU15UMfIiKizxyH8GPbh4iIqLRgu4eIiIg+JxyomYiIiIiIiIiIiIiIiEo0JryIiIiIiIiIiIiIiIioRGPCi4iIiIiIiIiIiIiIiEo0zuFFREREREREVASUSiXkcrnUYVApoKurC21tbanDICIiIipSTHgRERERERERFTK5XI6wsDAolUqpQ6FSwtzcHDY2NpDJZFKHQkRERFQkmPAiIiIiIiIiKkSCIODNmzfQ1tZGpUqVoKXF2QWo8AiCgMTERERGRgIAbG1tJY6IiIiIqGgw4UVERERERERUiNLS0pCYmIgKFSrAyMhI6nCoFDA0NAQAREZGwsrKisMbEhERUanA18qIiIiIiIiICpFCoQAA6OnpSRwJlSaq5GpqaqrEkRAREREVDSa8iIiIiIiIiIoA51KiosTrjYiIiEobJryIiIiIiIiIiIiIiIioRGPCi4iIiIiIiIgol+RyOapUqQJ/f3/JYvj5558xduxYyfZPREREVBzpSB0AERERERERUan0x6Si3d+3S/O8yYsXLzBz5kwcO3YMb9++ha2tLbp164YZM2agfPnyhRBkzlq1aoW6deti5cqVRb5vlfXr18PR0RHNmjUTl8lkMvz777/o1q2bWtlBgwYhJiYG+/bty/K7yrlz5+Dp6Yno6GiYm5trfM9s0qRJcHJywvjx4+Hk5FTAR0hERERUMrGHFxERERERERFpePLkCRo2bIhHjx5h+/btePz4MdavX4/Tp0+jadOmeP/+vdQhFjlBELB69WoMHTpU0jgsLCzg5eWFdevWSRoHERERUXHChBcRERERERERaRg9ejT09PRw4sQJeHh4oHLlymjfvj1OnTqFV69eYdq0aWJZmUym0WvJ3Nwcfn5+4veffvoJ1apVg5GREZycnPDLL78gNTVVXD9r1izUrVsXmzdvhoODA8zMzNCvXz/Ex8cDSO8ddf78efz222+QyWSQyWR4+vQp/Pz8NHpB7du3DzKZTKPujRs3onLlyjA2NsaoUaOgUCiwePFi2NjYwMrKCvPnz8/xnNy8eROhoaHo2LFjHs9mwevcuTN27NghdRhERERExQaHNKQiNeavi4VW9+phXxRa3UREREREJLGiHv6vIBmYAC5tgfcGgG6GP8PT5EUbR9SLXBd9Hx2D48ePY/7UyTA0NFRbZ2Njg6+//ho7d+7E2rVr1RJLOTExMYGfnx8qVKiAwMBADB8+HCYmJvjxxx/FMqGhodi3bx8OHTqE6Oho9OnTBwsXLsT8+fPx22+/4eHDh6hZsybmzJkDALC0tMz1MYWGhuLo0aM4duwYQkND0atXLzx58gTVqlXD+fPn4e/vjyFDhqBNmzZwd3fPso4LFy6gWrVqMDExyfV+C0vjxo3x8uVLPH36FA4ODlKHQ0RERCQ59vAiIiIiKubWrFkDBwcHGBgYwN3dHdeuXcu2rJ+fn/jWu+pjYGBQhNESEdHn4NGTMAiCAJeqVbNc7+LigujoaERFReW6zunTp6NZs2ZwcHBA586dMWnSJOzatUutjFKphJ+fH2rWrIkWLVrgm2++wenTpwEAZmZm0NPTg5GREWxsbGBjYwNtbe1c71+pVGLjxo1wdXVF586d4enpiZCQEKxcuRLVq1fH4MGDUb16dZw9ezbbOp49e4YKFSpkua5///4wNjZW+2zdulWj3KFDhzTKtW/fPtfHoaKK49mzZ3neloiIiOhzxB5eRERERMXYzp07MWHCBKxfvx7u7u5YuXIlvLy8EBISAisrqyy3MTU1RUhIiPg9t2/eExERZSYIQo7r9fT0cl3Xzp078fvvvyM0NBQfPnxAWloaTE1N1co4ODio9Z6ytbVFZGRk3oLORua6ra2toa2tDS0tLbVlOe0vKSkp2xdJVqxYgTZt2qgt++mnn6BQKNSWeXp6asy9dfXqVQwYMCDXxwJA7HmXmJiYp+2IiIiIPlfs4UVERERUjC1fvhzDhw/H4MGD4erqivXr18PIyAgbN27MdhuZTCa++W5jYwNra+sijJiIiD4HVRwdIJPJ8ODR4yzXP3jwAJaWluLcWTKZTCM5lnF+rsuXL+Prr79Ghw4dcOjQIdy+fRvTpk2DXK4+rKOurq7ad5lMBqVSmWOsWlpaOe47p7rzuj8LCwtER0dnuc7GxgZVqlRR+2Q19GGZMmU0ytnZ2WW7z+y8f/8eQN6GdSQiIiL6nLGHVzFQmPNaAZzbioiIqKSSy+W4efMmpkyZIi7T0tJCmzZtcPny5Wy3+/DhA+zt7aFUKlG/fn38+uuvcHNzK4qQiYjoM1G+XFm09WiBtb5/Y/z0WWrzeIWHh2Pr1q0YPXq0uMzS0hJv3rwRvz969Eit55G/vz/s7e0xbdo0cVl+huLT09PT6DFlaWmJ+Ph4JCQkoEyZMgCAgICAPNedG/Xq1cO6desgCILkPaiDgoKgq6vLezwRERHR/8ceXkRERETF1Nu3b6FQKDR6aFlbWyM8PDzLbapXr46NGzdi//792LJlC5RKJZo1a4aXL19mu5+UlBTExcWpfYiIiFYvnIsUuRxeXl7477//8OLFCxw7dgxt27ZFtWrVMGPGDLHsl19+idWrV+P27du4ceMGRo4cqdZ7qmrVqnj+/Dl27NiB0NBQ/P777/j333/zHJODgwOuXr2Kp0+f4u3bt1AqlXB3d4eRkRGmTp2K0NBQbNu2DX5+fgVxCjR4enriw4cPuHfvXqHUn1lgYCACAgLEz507d8R1Fy5cQIsWLdSSkURERESlGXt4EREREX1GmjZtiqZNm4rfmzVrBhcXF/zxxx+YO3dultssWLAAs2fPLqoQSUKFPbIAZY+jLlBJVNXJEdePH8TkJWvQq1dvvH0bBUEQ4N2xC1au+RPvkwS8T4oHAEyYOhuTvv8OX3zRAtY2Npg5fxFu3LiJd/HJeB4Vj7pNPTH029EYNXo05ClyfNm2HcaMn4yVSxbieVR6HbEJKUhNU4rfASD6QzIUSkFc9tWQkbgxZiRcXF2RnJSEizcCUamyPVas2YBfZ0/Hnxs2oHkLD3w/8Wf8PPH7HOtOSE5FUkqa2rKUVAXik+Rqy9TpwatDZ6zb4Iufps9SWxMVm6SxXeZ9ZLVPAIiISe8N9+JtPOJStcXvLVu2VCunra2NtLQ0AMCOHTswa5Z6DERERESlmUz42Ay0hLi4OJiZmSE2NlZjQt2CUJqGNCzMYy1Ox0lERCVPYd/v80Mul8PIyAh79uxBt27dxOU+Pj6IiYnB/v37c1VP7969oaOjg+3bt2e5PiUlBSkpKeL3uLg4VKpUqVidCyoYTHhJh23VAvDHJKkjyLdkAxOEubSFY0VbGOiWvPdOn8Nc/O/li+bjr/VrsGX3PtRv2Fi6oCT04F4QBvTuiv+u3UEZY+NC3VdlS805wADg6NGjmDhxIu7evQsdnayvqeTkZISFhcHR0REGBgZq64pju4eIiIjoU3FIQyIiIqJiSk9PDw0aNMDp06fFZUqlEqdPn1brxZUThUKBwMBA2NraZltGX18fpqamah8iIqKsTPhpGmb9uhi3b16HUqmUOhxJuLjVxM8z5uDF87zPQVZQEhIS4Ovrm22yi4iIiKg0YsuIiIiIqBibMGECfHx80LBhQzRu3BgrV65EQkICBg8eDAAYOHAg7OzssGDBAgDAnDlz0KRJE1SpUgUxMTFYsmQJnj17hmHDhkl5GERE9Bnp03+A1CFIrne/ryXdf69evSTdPxEREVFxxIQXERERUTHWt29fREVFYcaMGQgPD0fdunVx7NgxWFtbAwCeP38OLa3/67QfHR2N4cOHIzw8HGXLlkWDBg3g7+8PV1dXqQ6BiIiIiIiIiKjQMeFFREREVMyNGTMGY8aMyXLduXPn1L6vWLECK1asKIKoPkEJnoenxNPuJnUERERERERERIWCc3gRERERERERERERERFRiSZpwmvBggVo1KgRTExMYGVlhW7duiEkJEStTKtWrSCTydQ+I0eOVCvz/PlzdOzYEUZGRrCyssLkyZORlpamVubcuXOoX78+9PX1UaVKFfj5+RX24REREREREREREREREVERkDThdf78eYwePRpXrlzByZMnkZqainbt2iEhIUGt3PDhw/HmzRvxs3jxYnGdQqFAx44dIZfL4e/vj02bNsHPzw8zZswQy4SFhaFjx47w9PREQEAAxo0bh2HDhuH48eNFdqxERERERERERERERERUOCSdw+vYsWNq3/38/GBlZYWbN2+iZcuW4nIjIyPY2NhkWceJEydw//59nDp1CtbW1qhbty7mzp2Ln376CbNmzYKenh7Wr18PR0dHLFu2DADg4uKCixcvYsWKFfDy8iq8AyQiIiIiIiIiIiIiIqJCV6zm8IqNjQUAlCtXTm351q1bYWFhgZo1a2LKlClITEwU112+fBm1atWCtbW1uMzLywtxcXG4d++eWKZNmzZqdXp5eeHy5ctZxpGSkoK4uDi1DxERERERERERERERERVPxSbhpVQqMW7cODRv3hw1a9YUl3/11VfYsmULzp49iylTpmDz5s0YMGCAuD48PFwt2QVA/B4eHp5jmbi4OCQlJWnEsmDBApiZmYmfSpUqFdhxEhEREREREX1O7K1McfzIoULfz+VLF2BvZYrY2JgCqe/F82ewtzLFvcC7BVIfEREREUlL0iENMxo9ejSCgoJw8eJFteUjRowQ/7tWrVqwtbVF69atERoaCmdn50KJZcqUKZgwYYL4PS4ujkkvIiIiIiIiKlBj/nlUpPtb3bNqvraLjIjA6pVLcObkCUSEv0Z5C0u41qyFISNG4YuWrQo2yBw0aOSO64GPYGpqVmT7JCKi4ilFIce7lHi8z/hJjsN7+Yf0/0+JR0JaMtIEJRSCAgqlEgoh/TM9yRkuIRGAlhYgkwHa2pDp60OmpweZvj6Q4b9lBgbQMjGBzMQEWqamkJmYQGZkBJlMJvUpIKIsFIuE15gxY3Do0CH8999/qFixYo5l3d3dAQCPHz+Gs7MzbGxscO3aNbUyERERACDO+2VjYyMuy1jG1NQUhoaGGvvQ19eHvr5+vo+HiIiIiIiI6HPw9PkLdOrUC6ZmZpg6cy5quLoiLTUN58+exoyfJ+KM/80ii0VPTw9WmUZvISKiz1d44ns8inuNx3Gv8DQ+Au9S4v5/kisOiWkp+a5XSE2FkGnULyEvFWhriwkwrXLloG1hAS0LC2hZWkLL3BwyrWIzqBpRqSNpwksQBIwdOxb//vsvzp07B0dHx49uExAQAACwtbUFADRt2hTz589HZGQkrKysAAAnT56EqakpXF1dxTJHjhxRq+fkyZNo2rRpAR4NERERERER0edl1E/TIZPJcODYWRiVKSMur1bDBX2+GpDlNgvmzMDxIwfx5s1rWFpao1uv3vhh4s/Q1dUFANwPCsTsX35GYMBtyGQyODg5Y8HSlahdtz5evniOGVMm4frVK0hNlaNipcqYOnMuvmzjhcuXLqBf9464++g5zMzMAQDXr17B0gVzEHD7JvT09FG3Xn2s/tMXZuZlce7MSaxavgQPgx9AS1sL9Rs2xqx5i2Dv6FTo542IiHIvVZmGsPhwPIp7jdC4V3gU+xqh8a8Rn6o5FU2xoFBAiImBIiYGiufPkZpxnbY2tMqXT0+C2dhAp2JFaFeokN5zjIgKnaQJr9GjR2Pbtm3Yv38/TExMxDm3zMzMYGhoiNDQUGzbtg0dOnRA+fLlcffuXYwfPx4tW7ZE7dq1AQDt2rWDq6srvvnmGyxevBjh4eGYPn06Ro8eLfbSGjlyJFavXo0ff/wRQ4YMwZkzZ7Br1y4cPnxYsmMnIiIiIiIiKs7eR8fg2JlzmDx1hlqyS0WVdMqsjLExlv6+HtY2Ngh5cB8/TxgL4zImGDl2HADgh1HD4FazNuYvXgFtbS3cDwqEjk56MuyXnyciVS7H7v1HYWRkhEcPg1GmjHGW+7kXeBdf9+qM3v0HYOa8RdDR0YH/pf+gUCgBAIkJiRg2cgxcXN2QkJCA5YvnY8Sgr3H07CVo8e17IiJJKAQlHsQ8R9D7p3gU9wqP417j+YdIpAkKqUMrGAoFlJGRUEZGAvfvIwUAZDJoWVhA284O2hUqQKdiRWhZW7MnGFEhkDThtW7dOgBAq1at1Jb7+vpi0KBB0NPTw6lTp7By5UokJCSgUqVK6NmzJ6ZPny6W1dbWxqFDh/Ddd9+hadOmKFOmDHx8fDBnzhyxjKOjIw4fPozx48fjt99+Q8WKFfHXX3/By8urSI6TiIiIiIiIqKR5HPYUgiDAuUq1PG33/YQfxf+uVNkew0d9j4P7/hETXq9fvsS3o75Hlarp9To6VRHLv375Eu07dUENVzcAQGWH7EeCWb9mJWrVqYf5i1eIy6rVcBH/u0Pnrmrll6xci3oujngUEozqLq55OiYiIsq/t8mxuBoZjKtRwbjx9mHx7blVWAQByqgoKKOikPr/Ry+Dvj50HB3TP87O0C5fXtIQiT4Xkg9pmJNKlSrh/PnzH63H3t5eY8jCzFq1aoXbt2/nKT4iIiIiIiKi0upjf7Nn5+C+f+C7YT2ePw1DQkICFIo0GJuYiOuHjRyNnyaMxd7dO/GFRyt07NxNHGZw0PCRmP7jePx37gy+aNkK7Tt1hYtbzSz3cz8oEB07d8s2jrAnj7F80XzcvnkT0e/fQalM7/n16tULJryIiApRmlKBwPdhuBL1AFcjgxEa/0bqkIqflBSkBQcjLTgYACAzMxOTX7rOzpAZGkocIFHJJGnCi4iIiIiIiIiKp6pOjpDJZAh9/DDX29y8fhU/fDcM43+cCg/P1jAxNcWBf//BX+tWi2XG/zgVXXv2xpmTx3Hu9EmsWPwrVv3hC++OndF/gA88PFvjzMnj+O/cGaz9fTmmzZ6PwcNGauzLwCDnh4FDB/SFXcVKWLj8d1jb2EJQKtG2pTtS5ak5bkdERHkXnvgeV6OCcSUyGLfePUJiWorUIZUoQmwsUgMCkBoQgCQtLeg4OkLXxQU6NWpAK4thhYkoa0x4EREREREREZGGcmXN4eXpgb83bsDgYSM15vGKjY3RmMfr5vVrsKtYCWPHTxaXvXr5QqNuJ+eqcHKuimEjx2Dst4Oxe8cWeHfsDACoYFcRAwYNxYBBQ7Fo3izs2Lwpy4SXi6sbLl04jwk/TdNYF/3+HUIfP8LC5avQuEkzAMD1K5fzfA6IiCh7MfIPOPHyJo6+vI7Hca+lDufzoVQiLTQUaaGhwOHD0La3h66LC3RdXKCVocc0EWliwouIiIiIiIiIsrRm4Vw06dQLXbw9MeHHaXBxc0NamgIXz5/BZr//4cylG2rlHZ2c8frVSxz4dw/q1K2PM6eO4/iRg+L65KQkzJ89HR06d0OlyvZ48/o17ty+hfad0ufbmj39J7T6si0cnasgNjYGly/9hyrVqmcZ26gfJsDLoymm/TgeA3yGQldPD5cv/oeOXbrDvGxZlC1XDtv+9oWVlTVevXqJRfNmFt6JIiIqJRSCEtcig3H4xTX4R95DqlIhdUifN0GA4ulTKJ4+RfLRo9B2dIRevXrQdXGBTIeP9oky478KIiIiIiIiIsqSk4M9Dp++gNUrlmD+rGmIjAhHufIWqFWnLuYvXqFRvq13Bwz9djRmTJkEeYocX7Zth+8n/IiVSxYCALS0tRET/R4TxnyLt1GRKFuuPLw7dsb4H6cCABQKBX75eSLC37yGsYkJPDzbYMbcBVnH5lwVm3ftw+L5s9HV2xP6BoaoV78BuvToBS0tLaz+wxczp/2Idh5N4ORcFbN+XYy+3ToU3skiIvqMvUp4i8MvruHYy+uISo6VOpxSSxEWhqSwMCQZGECvZk3o1asH7QoVpA6LqNiQCfmdhbYUiYuLg5mZGWJjY2Fqalrg9Y/562KB15nR6mFfFGr9eVGYx1qcjpOIiEqewr7flySFfi7+mFTwdVKujNHuJnUIpRbbqgWgBP/uSDYwQZhLWzhWtIWBbsl77/Q5zKUOodSqbJn/oauSk5MRFhYGR0dHGBgYqK1ju4eIciNZIcfZ13dw+MVV3H0fBgGfx2PkJcmucLn3SuowCoyWtTX06tWDXt26kOnrSx0OkaRKXkubiIiIiIiIiIiIiArF47jX2Pv0Is68DkBCWrLU4dBHKCMikHzsGJLPnIFenTrQa9IE2uXKSR0WkSSY8CIiIiIiIiIiIiIq5UJiX8Lv4Qlcirj32fTmKlXkcsivX4f8+nXoVK8O/aZNoWNvL3VUREWKCS8iIiIiIiIiIiKiUup+9DP4PTqJy5H3pQ6FCkhaSAjSQkKgbWcH/S++gG6NGlKHRFQkmPAiIiIiIiIiIiIiKmUC34fB79EJXIsKkToUKiSKV6+QuHMntGxtYdCqFXSrVZM6JKJCxYQXffbG/HWx0Orm5ONERERERERERFSSBLwLhe/DE7j17pHUoVARUb55g8Tt29N7fLVqBd0qVaQOiahQMOFFREREREREVJiE9P8ROB0KFSGlUil1CERUzNx4+xB+D0/gzvsnUodCElG8eoXErVuhXbkyDFq1go6jo9QhERUoJryIiIiIiIiICpFuahJkqSmIik+EpYkRZDKpI8qbNMilDqHUSk5OzvM2giBALpcjKioKWlpa0NPTK4TIiKgkeRL3BiuC9iLgfajUoVAxoXj+HAl//w2dqlVh4OUF7fLlpQ6JqEAw4UVERERERERUiLSVaagYdhUv4Y6ncfoASlbG6z1ipA6h1EqJNcj3tkZGRqhcuTK0tLQKMCIiKkkS01Lg+/A4dof9B4XAXp+kKe3RI3wIDYWeuzsMPDwg09eXOiSiT8KEFxEREREREVEhM054h6r3TyBV17Ck5buwRauN1CGUWr/0dsnXdtra2tDR0YGspHUnJKICc+7NHay6tx+RyTFSh0LFnVIJ+eXLSL17FwZffgndevV4/6ASiwkvIiIiIiIioiKgrUyDdkq81GHkWaw2Jx+TioFB/nt4EVHp9DrhHVYE/YMrUcFSh0IljJCQgKSDB5Fy/ToMO3aETsWKUodElGdMeBERERERERERERGVYHJFGraGnsaWx6chV6ZJHQ6VYMrwcCRs3Ai9xo1h8OWXkHEuSCpBmPAiIiIiIiIiIiIiKqFuRD3E8qB/8CIhSupQ6HMhCJBfvYrUkBAYde4MHScnqSMiyhUmvIiIiIiIiIiIiIhKmHfJcfj9/j6ceR0gdSj0mRJiYpCweTN069WDYbt2kHGoXSrmmPAiIiIiIiIiIiIiKkGuRj7A3IBtiJUnSB0KlQKpt28j7fFjGHbuDN2qVaUOhyhbTHgRERERERERERERlQBpSgX+CjmKbaFnIUCQOhwqRYT4eCRu2wY9d3cYtG0Lmba21CERaWDCqxQb89fFQqt79bAvCq1uIiIiIiIiIiKi0iYiKRqzbm1GUPRTqUOhUkx+9SrSnj2DUc+e0LawkDocIjVaUgdARERERERERERERNm7FHEPQ/5bxmQXFQvK8HB8+PNPyG/fljoUIjXs4UVERERERERERERUDKUpFVj34BB2hZ2XOhQidampSDpwAGlPnsCwUyfI9PWljoiICS8iIiIiIiIiIiKi4uZ14jvMuvk3HsS+kDoUomylBgVBER4Oo379oF2+vNThUCnHIQ2JiIiIiIiIiIiIipFzb+5g6H/LmOyiEkH59i0+bNiA1EePpA6FSjkmvIiIiIiIiIiIiIiKAYWgxO/3/sUvNzfhQ1qy1OEQ5V5KChK3b0fKxYtSR0KlGIc0JCIiIiIiIiIiIpJYUloKZt3aDP/I+1KHQpQ/goDk06ehiIiAYZcukOnqSh0RlTJMeBERERERERERERFJ6F1yHH66/hdCYl9KHQrRJ0sNCoLi3TuU6d8fWiYmUodDpQiHNCQiIiIiIiIiIiKSSFh8OEZe+o3JLvqsKN+8wYeNG6F4907qUKgUYcKLiIiIiIiIiIiISAK33z3GKP9VCE+KljoUogInxMQgYeNGpL16JXUoVEow4UVERERERERERERUxC6EB2HS1T/xITVJ6lCICo2QmIiETZuQ+uiR1KFQKcCEFxEREREREREREVEROvriOn656Qe5Mk3qUIgKX2oqEnfsgDwgQOpI6DOnI3UARERERERERERERKXFrifnsfr+AQgQpA6FqOgolUjavx9CcjL0mzSROhr6TDHhRURERERERERERFQE/go5ik2PTkodBpFkko8fBwAmvahQMOFFREREREREREREVMj+DD6CzY9PSR0GkeSY9KLCwjm8iIiIiIiIiIiIiArRjifnmOwiyiD5+HGkXL0qdRj0mWHCi4iIiIiIiIiIiKiQHHlxDWvvH5Q6DKJiJ/nYMSa9qEAx4UVERERERERERERUCP4LD8Tiu7sgQJA6FKJiKfnYMaRcvy51GPSZYMKLiIiIiIiIiIiIqIDdevsIs29thkJQSh0KUbGWfOQI5EFBUodBnwEmvIiIiIiIiIiIiIgKUEjMC0y5sRFyZZrUoRCVCEn//ovUx4+lDoNKOCa8iIiIiIiIiIiIiArI8w+RmHRtAxLTUqQOhajkUCqRuGsXFK9fSx0JlWBMeBEREREREREREREVgIikaIy/sh4x8g9Sh0JU8qSmImHbNiijo6WOhEooJryIiIiIirk1a9bAwcEBBgYGcHd3x7Vr13K13Y4dOyCTydCtW7fCDZCIiIiIiBAj/4CJV/9AZHKM1KEQlVhCQgIStm6FMjFR6lCoBGLCi4iIiKgY27lzJyZMmICZM2fi1q1bqFOnDry8vBAZGZnjdk+fPsWkSZPQokWLIoqUiIiIiKj0SlGk4serG/DsQ87tdCL6OOW7d0jcvRuCUil1KFTCMOFFREREVIwtX74cw4cPx+DBg+Hq6or169fDyMgIGzduzHYbhUKBr7/+GrNnz4aTk1MRRktEREREVDqtDNqLB7EvpA6D6LOhePoUycePSx0GlTBMeBEREREVU3K5HDdv3kSbNm3EZVpaWmjTpg0uX76c7XZz5syBlZUVhg4dWhRhEhERERGVakdfXMehF1elDoPosyO/dg3ygACpw6ASREfqAIiIiIgoa2/fvoVCoYC1tbXacmtrawQHB2e5zcWLF/G///0PAXn4oyAlJQUpKSni97i4uHzFS0RERERU2jyOe41lgXukDoPos5V06BC0LCygU7Gi1KFQCcAeXkRERESfifj4eHzzzTfYsGEDLCwscr3dggULYGZmJn4qVapUiFESEREREX0eElKT8cvNTUhRpkodCtHnS6FA4q5dUMbHSx0JlQBMeBEREREVUxYWFtDW1kZERITa8oiICNjY2GiUDw0NxdOnT9G5c2fo6OhAR0cHf//9Nw4cOAAdHR2EhoZmuZ8pU6YgNjZW/Lx4wbkHiIiIiIg+ZsGdHXiZECV1GESfPSE+Hom7dkFQKqUOhYo5JryIiIiIiik9PT00aNAAp0+fFpcplUqcPn0aTZs21Shfo0YNBAYGIiAgQPx06dIFnp6eCAgIyLbnlr6+PkxNTdU+RERERESUvZ1PzuN8+F2pwyAqNRQvXyLlzBmpw6BijnN4ERERERVjEyZMgI+PDxo2bIjGjRtj5cqVSEhIwODBgwEAAwcOhJ2dHRYsWAADAwPUrFlTbXtzc3MA0FhORERERET5c/d9GNY9OCh1GESlToq/P3ScnKDj5CR1KFRMSdrDa8GCBWjUqBFMTExgZWWFbt26ISQkRK1McnIyRo8ejfLly8PY2Bg9e/bUGNbn+fPn6NixI4yMjGBlZYXJkycjLS1Nrcy5c+dQv3596Ovro0qVKvDz8yvswyMiIiL6ZH379sXSpUsxY8YM1K1bFwEBATh27Bisra0BpLeD3rx5I3GURERERESlQ3TKB8y69TcUAodWIypygoDEf/+FMjFR6kiomJI04XX+/HmMHj0aV65cwcmTJ5Gamop27dohISFBLDN+/HgcPHgQu3fvxvnz5/H69Wv06NFDXK9QKNCxY0fI5XL4+/tj06ZN8PPzw4wZM8QyYWFh6Nixozicz7hx4zBs2DAcP368SI+XiIiIKD/GjBmDZ8+eISUlBVevXoW7u7u47ty5czm+yOPn54d9+/YVfpBERERERJ85paDEnNtbEJUcK3UoRKWW8OEDkvbvlzoMKqYkHdLw2LFjat/9/PxgZWWFmzdvomXLloiNjcX//vc/bNu2DV9++SUAwNfXFy4uLrhy5QqaNGmCEydO4P79+zh16hSsra1Rt25dzJ07Fz/99BNmzZoFPT09rF+/Ho6Ojli2bBkAwMXFBRcvXsSKFSvg5eVV5MdNREREREREREREJcumRydx4+1DqcMgKvXSHj5EytWr0M/wMigRIHEPr8xiY9PfjihXrhwA4ObNm0hNTUWbNm3EMjVq1EDlypVx+fJlAMDly5dRq1YtcVgfAPDy8kJcXBzu3bsnlslYh6qMqg4iIiIiIiIiIiKi7ITFh+PvR6ekDoOI/r/kkyehiIyUOgwqZopNwkupVGLcuHFo3ry5OKl6eHg49PT0xMnWVaytrREeHi6WyZjsUq1XrcupTFxcHJKSkjRiSUlJQVxcnNqHiIiIiIiIiIiISh9BELD47i6kCQqpQyEiFYUCSQcOQBAEqSOhYqTYJLxGjx6NoKAg7NixQ+pQsGDBApiZmYmfSpUqSR0SERERERERERERSWD/88sIin4qdRhElIni1SvIr1yROgwqRopFwmvMmDE4dOgQzp49i4oVK4rLbWxsIJfLERMTo1Y+IiICNjY2YpmIiAiN9ap1OZUxNTWFoaGhRjxTpkxBbGys+Hnx4sUnHyMRERERERERERGVLG+T4/DHg0NSh0FE2Ug+exbK6Gipw6BiQtKElyAIGDNmDP7991+cOXMGjo6OausbNGgAXV1dnD59WlwWEhKC58+fo2nTpgCApk2bIjAwEJEZxus8efIkTE1N4erqKpbJWIeqjKqOzPT19WFqaqr2ISIiIiIiIiIiotJlZdBefEhLljoMIspOaioSDx6UOgoqJiRNeI0ePRpbtmzBtm3bYGJigvDwcISHh4vzapmZmWHo0KGYMGECzp49i5s3b2Lw4MFo2rQpmjRpAgBo164dXF1d8c033+DOnTs4fvw4pk+fjtGjR0NfXx8AMHLkSDx58gQ//vgjgoODsXbtWuzatQvjx4+X7NiJiIiIiIiIiIio+LoUcQ/nw+9KHQYRfYQiLAzyW7ekDoOKAUkTXuvWrUNsbCxatWoFW1tb8bNz506xzIoVK9CpUyf07NkTLVu2hI2NDfbu3Suu19bWxqFDh6CtrY2mTZtiwIABGDhwIObMmSOWcXR0xOHDh3Hy5EnUqVMHy5Ytw19//QUvL68iPV4iIiIiIiIiIiIq/hLTUrA88B+pwyCiXEo6eRLKDx+kDoMkpiPlzgVB+GgZAwMDrFmzBmvWrMm2jL29PY4cOZJjPa1atcLt27fzHCMRERERERERERGVLhuCjyAyOUbqMIgot5KTkXz6NIy6dpU6EpKQpD28iIiIiIiIiIiIiIqTBzHPsffpRanDIKI8Sr1zB4o3b6QOgyTEhBcRERERERERERERgDSlAkvu7oYSHx+ZioiKGUFA0rFjUkdBEmLCi4iIiIiIiIiIiAjA/mf+eBT3SuowiCifFM+fQx4UJHUYJBEmvIiIiIiIiIiIiKjUS1HI8ffjU1KHQUSfKPnUKQipqVKHQRJgwouIiIiIiIiIiIhKvX+f+uN9SrzUYRDRJxJiY5Hi7y91GCQBJryIiIiIiIiIiIioVEtKS8HW0DNSh0FEBSTF3x/KxESpw6AixoQXERERERERERERlWr/PL2IGPkHqcMgooIilyPl0iWpo6AixoQXERERERERERERlVoJqcnYHnpW6jCIqIDJr1+HMiFB6jCoCDHhRURERERERERERKXWrrDziEvl0GdEn53UVKRcvCh1FFSEmPAiIiIiIiIiIiKiUilenohdT85LHQYRFRL5jRtQfuBwpaUFE15ERERERERERERUKu14cg4f0pKlDoOICktaGlIuXJA6CioiTHgRERERERERERFRqRMrT8Cep3wQTvS5k9+8yV5epQQTXkRERERERERERFTqbAs9g8S0FKnDIKLCplBAfv261FFQEWDCi4iIiIiIiIiIiEqVWHkC9j69JHUYRFRE5DduQEhLkzoMKmRMeBEREREREREREVGpcvTldSQr5FKHQURFREhMROqdO1KHQYWMCS8iIiIiIiIiIiIqVQ4+uyJ1CERUxFKuXoUgCFKHQYWICS8iIiKiApCamoqQkBDx++XLlyWMhoiIiIiIsnP77WM8T4iUOgwiKmLKqCikhYZKHQYVIia8iIiIiAqAj48POnfujKlTpwIAJk6cKHFERERERESUlQPP+XIaUWkl58upnzUmvIiIiIgKQFBQEB4+fAhdXV2sWbNG6nCIiIiIiCgLMfIP+C88UOowiEgiaU+eQPH+vdRhUCFhwouIiIioANja2gIAZs+ejUuXLiEsLEziiIiIiIiIKLNjL25ArkyTOgwiklDq7dtSh0CFhAkvIiIiogLQvHlzpKWl/+G8fv16uLu7SxwRERERERFlxuEMiUh+5w4EQZA6DCoETHgRERERFYAZM2ZAR0cHAGBqaop9+/ZJGxAREREREam5/fYxXiRESR0GEUlMiI9H2uPHUodBhYAJLyIiIiIiIiIiIvrs7WfvLiL6/+QBAVKHQIVAR+oAiIiIiEo6R0dHyGSyPG83btw4fP/994UQERERERERZRQj/4D/wu9KHQYRFRNpISFQJiZCy8hI6lCoADHhRURERPSJ/Pz88rWdg4NDgcZBRERERERZO/riOlKVCqnDIKLiQqFAamAg9Dn/9meFCS8iIiKiT+Th4SF1CERERERElINjL69LHQIRFTNMeH1+OIcXERERERERERERfbbeJL7Hk/hwqcMgomJG8eoVlLGxUodBBYg9vIiIiIg+UY8ePeDn5wdTU1P06NEjx7J79+4toqiIiIiIiAgALkXckzoEIiqmUu/fh37TplKHQQWECS8iIiKiT2RmZgaZTCb+NxERERERFR/+kfelDoGIiikmvD4vTHgRERERfSJfX98s/zsnly5dQsOGDaGvr19YYRERERERlXqJaSkIePdY6jCIqJhSvHwJ5YcP0DI2ljoUKgCcw4uIiIhIAu3bt8erV6+kDoOIiIiI6LN2PSoEqUqF1GEQUTGWGhwsdQhUQJjwIiIiIpKAIAhSh0BERERE9Nnj/F1E9DFpISFSh0AFhAkvIiIiIiIiIiIi+uwIgoArkQ+kDoOIirm0p08hpKVJHQYVACa8iIiIiIiIiIiI6LNzP+Y5ouUfpA6DiIq7tDQonj+XOgoqAEx4ERERERERERER0WfHn8MZElEupT15InUIVACY8CIiIiKSgEwmkzoEIiIiIqLPmn/kfalDIKISggmvzwMTXkREREQSEARB6hCIiIiIiD5bEUnReBz3WuowiKiEUISHQ5mUJHUY9ImY8CIiIiIqQMHBwdmuO378uPjf8fHxcHJyKoqQiIiIiIhKnWtRIVKHQEQliSBAERYmdRT0iZjwIiIiIipA9evXx5o1a9SWpaSkYMyYMejatatEURERERERlS4PYp5LHQIRlTAc1rDkY8KLiIiIqAD5+flhxowZ6NChAyIiIhAQEIB69erh1KlTuHDhgtThERERERGVCsExL6QOgYhKmLQX/L1R0jHhRURERFSA+vTpgzt37iA1NRVubm5o2rQpPDw8cOvWLTRq1Ejq8IiIiIjoMxMVFYXvvvsOlStXhr6+PmxsbODl5YVLly5JHZpk5Io0hMWHSx0GEZUwyqgoCHK51GHQJ9CROgAiIiKiz5FcLodCoYBCoYCtrS0MDAykDomIiIiIPkM9e/aEXC7Hpk2b4OTkhIiICJw+fRrv3r2TOjTJhMa/RpqgkDoMIippBAGKN2+gY28vdSSUT+zhRURERFSAduzYgVq1asHMzAwPHz7E4cOH8eeff6JFixZ4wvHAiYiIiKgAxcTE4MKFC1i0aBE8PT1hb2+Pxo0bY8qUKejSpQuePn0KmUyGgIAAtW1kMhnOnTsnLrt37x46deoEU1NTmJiYoEWLFggNDRXXb9y4EW5ubtDX14etrS3GjBmjVt+wYcNgaWkJU1NTfPnll7hz5464/s6dO/D09ISJiQlMTU3RoEED3LhxAwDw7NkzdO7cGWXLlkWZMmXg5uaGI0eOfPJ5CYl9+cl1EFHppHj1SuoQ6BMw4UVERERUgIYOHYpff/0VBw4cgKWlJdq2bYvAwEDY2dmhbt26UodHRERERJ8RY2NjGBsbY9++fUhJSclXHa9evULLli2hr6+PM2fO4ObNmxgyZAjS0tIAAOvWrcPo0aMxYsQIBAYG4sCBA6hSpYq4fe/evREZGYmjR4/i5s2bqF+/Plq3bo33798DAL7++mtUrFgR169fx82bN/Hzzz9DV1cXADB69GikpKTgv//+Q2BgIBYtWgRjY+NPPCucv4uI8i+NCa8SjUMaEhERERWgW7duoXr16mrLypYti127dmHz5s0SRUVEREREnyMdHR34+flh+PDhWL9+PerXrw8PDw/069cPtWvXzlUda9asgZmZGXbs2CEmoqpVqyaunzdvHiZOnIgffvhBXKaam/bixYu4du0aIiMjoa+vDwBYunQp9u3bhz179mDEiBF4/vw5Jk+ejBo1agAAqlatKtbz/Plz9OzZE7Vq1QIAODk5fcLZ+D8P2cOLiPKJPbxKNvbwIiIiIipAmZNdGX3zzTf5qnPNmjVwcHCAgYEB3N3dce3atWzL7t27Fw0bNoS5uTnKlCmDunXrMtFGRERE9Bnr2bMnXr9+jQMHDsDb2xvnzp1D/fr14efnl6vtAwIC0KJFCzHZlVFkZCRev36N1q1bZ7ntnTt38OHDB5QvX17sbWZsbIywsDBxSMQJEyZg2LBhaNOmDRYuXKg2VOL333+PefPmoXnz5pg5cybu3r2b9xOQiVyRhrD48E+uh4hKJyE2FsoPH6QOg/KJPbyIiIiIPtHz58/ztZ25uTlMTU1zLLNz505MmDAB69evh7u7O1auXAkvLy+EhITAyspKo3y5cuUwbdo01KhRA3p6ejh06BAGDx4MKysreHl55StOIiIiIireDAwM0LZtW7Rt2xa//PILhg0bhpkzZ+LChQsAAEEQxLKpqalq2xoaGmZbb07rAODDhw+wtbVVmw9MxdzcHAAwa9YsfPXVVzh8+DCOHj2KmTNnYseOHejevTuGDRsGLy8vHD58GCdOnMCCBQuwbNkyjB07NpdHrulx3CukCYp8b09EpIyMhFYBDK9KRY89vIiIiIg+kYODAxwdHeHg4JDrj6OjI1auXPnRupcvX47hw4dj8ODBcHV1xfr162FkZISNGzdmWb5Vq1bo3r07XFxc4OzsjB9++AG1a9fGxYsXC/ioiYiIiKi4cnV1RUJCAiwtLQEAb968EdcFBASola1duzYuXLigkQgDABMTEzg4OOD06dNZ7qd+/foIDw+Hjo4OqlSpovaxsLAQy1WrVg3jx4/HiRMn0KNHD/j6+orrKlWqhJEjR2Lv3r2YOHEiNmzY8CmHjhAOZ0hEn0jx9q3UIVA+MeFFRERE9ImUSiUUCgWUSmWuPwqFAjNmzMixXrlcjps3b6JNmzbiMi0tLbRp0waXL1/+aFyCIOD06dMICQlBy5YtP/k4iYiIiKh4effuHb788kts2bIFd+/eRVhYGHbv3o3Fixeja9euMDQ0RJMmTbBw4UI8ePAA58+fx/Tp09XqGDNmDOLi4tCvXz/cuHEDjx49wubNmxESEgIgvYfWsmXL8Pvvv+PRo0e4desWVq1aBQBo06YNmjZtim7duuHEiRN4+vQp/P39MW3aNNy4cQNJSUkYM2YMzp07h2fPnuHSpUu4fv06XFxcAADjxo3D8ePHERYWhlu3buHs2bPiuvwKiX3xSdsTESmjoqQOgfIpX0Ma3rp1C7q6uuKEkvv374evry9cXV0xa9Ys6OnpFWiQRERERKXR27dvoVAoYG1trbbc2toawcHB2W4XGxsLOzs7pKSkQFtbG2vXrkXbtm2zLZ+SkoKUlBTxe1xc3KcHT0RERESFztjYGO7u7lixYgVCQ0ORmpqKSpUqYfjw4Zg6dSoAYOPGjRg6dCgaNGiA6tWrY/HixWjXrp1YR/ny5XHmzBlMnjwZHh4e0NbWRt26ddG8eXMAgI+PD5KTk7FixQpMmjQJFhYW6NWrFwBAJpPhyJEjmDZtGgYPHoyoqCjY2NigZcuWsLa2hra2Nt69e4eBAwciIiICFhYW6NGjB2bPng0AUCgUGD16NF6+fAlTU1N4e3tjxYoVn3RO2MOLiD6V4t07qUOgfMpXwuvbb7/Fzz//jFq1auHJkyfo168funfvjt27dyMxMTFXw/MQERERUeEwMTFBQEAAPnz4gNOnT2PChAlwcnJCq1atsiy/YMEC8aEDEREREZUc+vr6WLBgARYsWJBtGRcXF/j7+6styzinF5A+rOHx48ezrePbb7/Ft99+m+U6ExMT/P777/j999+zXL99+/Zs61X1FCsogiDg+YfIAq2TiEofJYc0LLHyNaThw4cPUbduXQDA7t270bJlS2zbtg1+fn74559/CjI+IiIiolLLwsIC2traiIiIUFseEREBGxubbLfT0tJClSpVULduXUycOBG9evXK8SHIlClTEBsbK35evOAwMERERERU8rxPiYdcmSZ1GERUwgnx8RAyjIJCJUe+El6CIECpVAIATp06hQ4dOgBIn2TybR6yn//99x86d+6MChUqQCaTYd++fWrrBw0aBJlMpvbx9vZWK/P+/Xt8/fXXMDU1hbm5OYYOHYoPHz6olbl79y5atGgBAwMDVKpUCYsXL87HURMREREVLT09PTRo0EBtknClUonTp0+jadOmua5HqVSqDVmYmb6+PkxNTdU+REREREQlTXhStNQhENFnQsFeXiVSvoY0bNiwIebNm4c2bdrg/PnzWLduHQAgLCxMY46JnCQkJKBOnToYMmQIevTokWUZb29v+Pr6it/19fXV1n/99dd48+YNTp48idTUVAwePBgjRozAtm3bAKTPQdGuXTu0adMG69evR2BgIIYMGQJzc3OMGDEir4dOREREVKQmTJgAHx8fNGzYEI0bN8bKlSuRkJCAwYMHAwAGDhwIOzs7sQfXggUL0LBhQzg7OyMlJQVHjhzB5s2bxfYaEREREdHnKoIJLyIqIMroaMDOTuowKI/ylfBasWIFBgwYgH379mHatGmoUqUKAGDPnj1o1qxZrutp37492rdvn2MZfX39bIfsefDgAY4dO4br16+jYcOGANLH/u3QoQOWLl2KChUqYOvWrZDL5di4cSP09PTg5uaGgIAALF++nAkvIiIiKnBnz56Fp6dngdXXt29fREVFYcaMGQgPD0fdunVx7Ngx8SWj58+fQ0vr/zrtJyQkYNSoUXj58iUMDQ1Ro0YNbNmyBX379i2wmIiIiIiIiqM3ie+lDoGIPhNCfPz/a+/Ow6Iq+z+Of2bYN1lEBRRFc8UFXFLR3DFc07JS80kxUx/TykxbzaXVzNzKpUzF9j0zLc3ILfdUtNw1t1JcQVxBYH5/+HMeJ0AFBw4D79d1ccWcc+b+fg4o4Xznvm+jIyAP8tTwioiI0B9//JHl+FtvvSVn5zwNmaPly5erdOnS8vf3V+vWrfXqq6+qZMmSkqS1a9fKz8/P2uySpOjoaJnNZq1fv1733nuv1q5dq+bNm8vV1dV6TUxMjN58800lJSXJ39/frnkBAEDx1q5dO5UrV059+/ZVnz59FBoaettjDhkyREOGDMn23PLly20ev/rqq3r11VdvuyYAAADgaJjhBcBeMlNSjI6APMjTHl6VKlXS6dOnsxy/fPmyqlatetuhrmnXrp0+/PBDxcfH680339SKFSvUvn17ZWRkSJISExNVunRpm+c4OzsrICBAiYmJ1mv+vczitcfXrvm31NRUpaSk2HwAAADcin/++UdDhgzR119/rUqVKikmJkZffvml0tLSjI4GAACAfHL69GmVLl1aBw8eLJB6y5cvl8lkUnJysiQpLi5Ofn5+1vNjxoxRZGRkvmYICwvL8uarm5k0aZKOHTtmc2zmzJnq3LmzXTKduJxsl3Hs7chXG/Rb50n6a9Zym+Mpu47qjxe/1pr739HaB6dp23NfKiM1/YZjpZ4+r91v/6R1D83Qmm5TtXnIhzq393+vcf797e9a/5+ZWv+fmfr7u002zz23+5i2DP1EloxMu90bUFRZzp83OgLyIE8Nr4MHD1qbTtdLTU3V33//fduhrunRo4fuuece1a5dW127dtXChQu1cePGXP/PNLfeeOMN+fr6Wj/s8c5sAABQPAQGBuqpp55SQkKC1q9fr6pVq+qxxx5TSEiInnjiCW3dutXoiAAAALCz1157TV26dFFYWFiB1GvSpImOHTsmX1/fAql3K1auXKnOnTsrJCREJpNJ8+fPz3LN4sWL9eWXX9oce+SRR7R582atWrXqtjOcuVz43rR+bk+iEhf/Ic+wQJvjKbuOavvo7+QXWV4Rb/dUxMSeCu4YIdMNXq1NP39Z2575QiYns2qOuVf1pvVRxUdayNnbXZJ04cBJHf5kraqN6KBqIzro8MerdeHgKUmSJSNT+6bHq/JjbWRyytNLwkCxwgwvx5Sr9QcXLFhg/XzJkiU2/1PNyMhQfHy8KlasaL90/1KpUiUFBgZq3759atOmjYKCgnTixAmba9LT03XmzBnrvl9BQUE6fvy4zTXXHue0N9jzzz+vYcOGWR+npKTQ9AIAALlWr149BQUFqWTJkho3bpzmzJmj6dOnKyoqSjNnzlTNmjWNjggAAIDbdPHiRc2ePVtLliwpsJqurq45vq5llAsXLigiIkKPPPKI7rvvvmyv6dKli7755hs9+eST1mOurq566KGHNHXqVDVr1uy2MpxJK1wzMjIupWn32z+pyuPROvzFBptzBz5YoZDOdRX6QEPrMc9yATcc7++vN8ot0FtVh8ZYj7kH/e/12Yt/n5FXxUD5RZS/Ol5YKV36+4y8wgL197e/q0TNsvKpWrj+3ACFFXt4OaZctfO7du2qrl27ymQyqU+fPtbHXbt2VY8ePbR06VK9/fbb+ZVVf//9t06fPq3g4GBJUlRUlJKTk7Vp0/+m5/7666/KzMxUo0aNrNesXLlSV65csV6zdOlSVatWLcf9u9zc3FSiRAmbDwAAgFt15coVff311+rQoYMqVKigJUuW6N1339Xx48e1b98+VahQQQ888IDRMQEAAGAHP/74o9zc3NS4cWNJV98U3q9fP1WsWFEeHh6qVq2apkyZYvOc2NhYde3aVRMmTFBwcLBKliypwYMH27x+lZqaqmeffVahoaFyc3NT5cqVNXv2bElZlzS8mY0bN6pt27YKDAyUr6+vWrRooc2bN9vnC/D/2rdvr1dffVX33ntvjtfcc889WrVqVZbcnTt31oIFC3Tp0qXbypCUWrheoN4/81cFNKgov8gKNsfTki/q3O5Eufh6aOuIz7X+4fe07bkvdXb7Pzcc7/SGv+RduYx2jluo9f+ZqS1PfqzEJX9Yz3uFBerSP0m6fCJFl0+k6NI/SfKsUFKXjiXr+C/bVeE/TfPlPoGiKJOGl0PKVcMrMzNTmZmZKl++vE6cOGF9nJmZqdTUVO3evVudOnW65fHOnz+vhIQEJSQkSJIOHDighIQEHT58WOfPn9eIESO0bt06HTx4UPHx8erSpYsqV66smJir72KoUaOG2rVrp/79+2vDhg1avXq1hgwZoh49eigkJESS9NBDD8nV1VX9+vXT9u3b9cUXX2jKlCk2M7gAAADs5fHHH1dwcLAGDhyoqlWrasuWLVq7dq0effRReXl5KSwsTBMmTNCuXbuMjgoAAAA7WLVqlerXr299nJmZqXLlyumrr77Sjh07NGrUKL3wwgtZlvJbtmyZ9u/fr2XLlmnevHmKi4tTXFyc9Xzv3r312WefaerUqdq5c6fee+89eXt75ynjuXPn1KdPH/32229at26dqlSpog4dOujcdS/otm/fXt7e3jl+2GN1gnLlyqlWrVr68ccfbY43aNBA6enpWr9+fZ7HPnflktIyb7z/VUE6uXK3zu8/obA+d2U5dznxrCTp8GfrFBRTWzXH3CvvO0rrz5Hf6NLRpBzHvJx4Vsd+2iaPED/VHHufgtvX0V/vL9Px+O2SJM/QkqrQu6m2j/pW20d9q7A+TeUZWlL7pv2iirHNlLzloDYP/lBbnvxYZ/+037Y0QJGUni5LaqrRKZBLuVrS8JoDBw7Ypfjvv/+uVq1aWR9fa0L16dNHM2bM0LZt2zRv3jwlJycrJCREd999t1555RW5ublZn/PJJ59oyJAhatOmjcxms7p166apU6daz/v6+urnn3/W4MGDVb9+fQUGBmrUqFEaMGCAXe4BAADgejt27NA777yj++67z+Z3lusFBgZq2bJlBZwMAAAA+eHQoUPWN15LkouLi8aOHWt9XLFiRa1du1ZffvmlHnzwQetxf39/vfvuu3JyclL16tXVsWNHxcfHq3///tqzZ4++/PJLLV26VNHR0ZKubvWRV61bt7Z5/P7778vPz08rVqywvnn9gw8+uOEMKxcXlzzXv16XLl20YMECPfTQQ9Zjnp6e8vX11aFDh/I8bmGa3ZV68pz+mrVctV6+T2bXbF5+tVgkSUHtaqtM9NVGovcdpZW87YiOL92ebZPs2vO8K5dRWO+7rM+5cOi0En/6Q2XaXB0nuH2EgttHWJ9yPH67nDxc5VM9WJsGzVPkxJ5KPXVeu9/6UQ0+eERmlzy9PAwUC5bUVJly+Hc9Cqc8/0SLj49XfHy8dabX9ebMmXNLY7Rs2VKW//8Bn51bWfs4ICBAn3766Q2vqVOnjl02vgQAALiZ0aNHq0mTJnJ2tv01Kz09XWvWrFHz5s3l7OysFi1aGJQQAAAA9nTp0iW5u7vbHJs2bZrmzJmjw4cP69KlS0pLS1NkZKTNNTVr1pSTk5P1cXBwsP744+rydAkJCXJycrLb74zHjx/XyJEjtXz5cp04cUIZGRm6ePGiDh8+bL2mbNmydql1Mx06dNCkSZNksVhkMpmsxz08PHTx4sU8j5uUWnj27zq/77iuJF/UlqGf/O9gpkUp2//W0YUJqj8zVtLVGVnX8ywXoNSTOTfuXP29sj4nNECn1+zN9vorZy/p8GfrVGfcgzq3J1EeIX7yCPGXR4i/MtMzdemfZHmFBebtJoFigBlejidPDa+xY8fq5ZdfVoMGDRQcHGzzPycAAIDirFWrVjp27JhKly5tc/zs2bNq1aqVMjIyDEoGAACA/BAYGKikpP8tQ/f5559r+PDhevvttxUVFSUfHx+99dZbWZbr+/eMKZPJZH1TuYeHh10z9unTR6dPn9aUKVNUoUIFubm5KSoqSmlpadZr2rdvf8M3jFeoUEHbt2+/7SwHDhxQ+fLls7yeeObMGZUqVSrP46ZmXrn5RQXEN6K86r77sM2xvZN/lkc5f5W7/065B/nKNcBLl/6xXb7w0tEk+dcPy3HcEjVCdOmfM7bP+SdJbqVLZHv9Xx8sV9ku9eQW6KNze4/LkvG/SQuWjExZ/jWJAYAty3U/I+EY8tTwmjlzpuLi4vTwww/f/GIAAIBi5N/vVL3m9OnT8vLyMiARAAAA8lPdunX18ccfWx+vXr1aTZo00WOPPWY9tn///lyNWbt2bWVmZmrFihXWJQ1vx+rVqzV9+nR16NBBknTkyBGdOnXK5pqCWtJwwYIFuueee2yO7d+/X5cvX1bdunXzPG5GZuF5Y5mzp6ucK9jOnDK7u8ilhIe8/v942fsa6PCna+VVMVBeFUvrxK87dOnvM6r+XCfrc/548WuVjKqskE6RkqSQLvW07ZkvdOTLDQq8q6rO7UlU4pI/VHlI1j8jSVsO6dLRZFV9qp0kyadKGV36+4zO/H5AaafOyWQ2yaNsQD59BYAighleDidPDa+0tDQ1adLE3lkAAAAc1n333Sfp6jtzY2NjbfbvysjI0LZt2/j9CQAAoAiKiYnR888/r6SkJPn7+6tKlSr68MMPtWTJElWsWFEfffSRNm7cqIoVK97ymGFhYerTp48eeeQRTZ06VRERETp06JBOnDhhsw/YrapSpYo++ugjNWjQQCkpKRoxYkSWWWS3u6Th+fPntW/fPuvjAwcOKCEhQQEBASpfvrykq8t8//jjj1m2MVm1apUqVaqkO+64I8/1M5XztimFUdku9ZSZlq6/Plih9HOX5VWxlGq+3E0ewX7Way4nntWVlP81IX2qBqnGC5118MPfdPjzdXIv46tK/VuqdMsaNmNnpKbrr/eWqdozHWQyX30znlugjyoNaKW9U36W2cVJVZ+KkZMb+3cBN8IML8eTp59qjz76qD799FO99NJL9s4DAADgkHx9fSVdneHl4+Nj8wKCq6urGjdurP79+xsVDwAAAPmkdu3aqlevnr788ksNHDhQAwcO1JYtW9S9e3eZTCb17NlTjz32mH766adcjTtjxgy98MILeuyxx3T69GmVL19eL7zwQp4yzp49WwMGDFC9evUUGhqq119/XcOHD8/TWDn5/fff1apVK+vjYcOGSbq6nGJcXJykq40tDw8PNWjQwOa5n3322W3/rlyYZnhlp84bD2Q5FvpAQ4U+0DDH59w5u1+WYwENKymgYaUb1nJyc7buE3a9oJjaCoqpffOwACSxh5cjylPD6/Lly3r//ff1yy+/qE6dOlmmNE+cONEu4QAAABzF3LlzJV19N+7w4cNZvhAAAKAYGTVqlEaMGKH+/fvLzc1Nc+fOtf5+eM0bb7xh/fxaA+h6kydPtnns7u6uiRMnZvs6W8uWLWWx/G9GU2xsrGJjY62Px4wZozFjxlgf161bVxs3brQZ4/7777+FO7t1/86UnQULFqhTp042S4Bv375dCQkJ+vLLL2+rfsZNagNAbjHDy/HkqeG1bds2RUZGSpL+/PNPm3PZ7VkBAABQXIwePdroCAAAAChgHTt21N69e/XPP/8oNDTU6DiF1g8//KApU6bYHDt27Jg+/PBD64oJeZVhybyt5wNAFjTSHU6eGl7Lli2zdw4AAACHVa9ePcXHx8vf319169a94RuANm/eXIDJAAAAUFCGDh1qdIRC7/o9vq6Jjo62y9iZNLwAoNhjZ0IAAIDb1KVLF7m5uUmSunbtamwYAAAAoAAMHTpUYWFhRsewYoYXACBPDa9WrVrd8J3Lv/76a54DAQAAOJrrlzFkSUMAAAAUB4VtRhszvHCr/NmWCbeK7ZscjjkvT4qMjFRERIT1Izw8XGlpadq8ebNq165t74wAAAAAAAAAkCNmeOFWBZ65aHQEIEdxcXHy8/OzPh4zZowiIyMNy+No8jTDa9KkSdkeHzNmjM6fP39bgQAAAByNv7//DWe/X+/MmTP5nAYAAAAofmh44VYEmNzkfCbZ6BgoBmJjYzVv3rwsx/fu3avKlSvn+Lzu3burQ4cO+RmtSLPrHl7/+c9/1LBhQ02YMMGewwIAABRqkydPNjoCAAAAUKzR8MKtaGUJkizJRscwzBvLlunNFStsjlUpWVIbH39ckjT0hx+0/K+/lHjunLxcXdUwNFRjo6NVtVSpWxr/qR9+0NxNm/R6TIwei4qSJKWmp+vxBQv0065dKu3trbc7dlTLO+6wPmfq6tU6cvas3iqCTZ527dpp7ty5NsdK3eRr6eHhIQ8PD7vmSEtLk6urq13HLKzs2vBau3at3N3d7TkkAABAodenTx+jIwAAAAAAbqJempekZKNjGKpGqVKa37u39bGz+X+7HkUGB+uB2rVVztdXSZcuadzy5brvo4+0dehQOZlvvDvSDzt3auPffyvYx8fmeNymTdp69Kh+fvRR/bJ3rx795hvtHTFCJpNJB5OSNG/TJi0bMMC+N2knJheX23q+m5ubgoKCbI5NnDhRc+fO1V9//aWAgAB17txZ48ePl7e3t6SrSxoOHTpUycnJ2Y7ZsmVLRUZG2rzxtmvXrvLz81NcXJwkKSwsTP369dPevXs1f/583XfffYqLi9Nvv/2m559/Xr///rsCAwN177336o033pCXl9dt3WdhkqeG13333Wfz2GKx6NixY/r999/10ksv2SUYAACAo0hJSVGJEiWsn9/ItesAAAAA2I+Pi31nRKBoCjvHTEAns1ll/tWUuia2QQPr5xX8/TWydWvdNXOmDicnq2JAQI5jHk1J0bM//qhvHn5YD37yic25PSdPqn21aqpRurTC/P310tKlOn3xogK9vPT0woUa07atShTSSTSmfJgVZTabNXXqVFWsWFF//fWXHnvsMT3zzDOaPn26XetMmDBBo0aN0ujRoyVJ+/fvV7t27fTqq69qzpw5OnnypIYMGaIhQ4ZkmYXmyPLU8PL19bV5bDabVa1aNb388su6++677RIMAADAUfj7++vYsWMqXbq0/Pz8st3Py2KxyGQyKSMjw4CEAAAAQNHm51p0Zigg/5Q4edboCIb768wZVZ8wQW7OzmoYGqpRbdoo1M8vy3UX0tL0SUKCKvj5qewN3riZmZmpgd9+q8ebNlWN0qWznK8VFKQvtm7VpStXFL9vn4K8vVXS01NfbtsmN2dnda5Rw563Z19ubrf19IULF1pnbklS+/bt9dVXX1kfh4WF6dVXX9V///tfuze8Wrduraefftr6+NFHH1WvXr00dOhQSVKVKlU0depUtWjRQjNmzCgyK/flqeFVlDp+AAAAt+vXX39VwP+/223ZsmUGpwEAAACKH19X75tfhGIt3OQn04WLRscwVINy5TS9a1dVLllSx8+f15vLl6v93Lla+9hj8vn/5s4HGzZo9NKlunDliqqULKn5vXvL1TnnNsLk1avlbDbrv40aZXv+P3Xravvx42o0bZpKenpq7gMPKPnSJb2+bJkWxsbq1fh4ffPnn6oYEKB3u3RRSCFaFcV0mw2vVq1aacaMGdbHXl5e+uWXX/TGG29o165dSklJUXp6ui5fvqyLFy/K09PzdiNbNbhutp4kbd26Vdu2bdMn183As1gsyszM1IEDB1SjMDcec+G29vDatGmTdu7cKUmqWbOm6tata5dQAAAAjqRFixbZfg4AAACgYPgywws30TwzUNJJo2MYqm2VKtbPa0mqX7as6kyerO+2b1fvevUkSQ/UqaNWd9yhxHPn9M6aNYr96isteeQRuWezn1XC0aOauW6dVgwcmO1KJ5Lk4uSkCR072hx7bP58DWzUSNuOHdOiXbv026BBmrJ6tZ796Sd91L27/W74Nt1uw8vLy0uVK1e2Pj548KA6deqkQYMG6bXXXlNAQIB+++039evXT2lpabfU8DKbzbJYLDbHrly5km3t650/f14DBw7UE088keXa8uXL3+otFXp5anidOHFCPXr00PLly+X3/9Mdk5OT1apVK33++ecqVaqUPTMCAAA4lKSkJM2ePdv6xqDw8HD17dvXOgsMAAAAgH3R8MLN1Lx0e82LosjPw0N3lCypA2fOWI/5urvL191dd5QsqTvLlVPYm29q4a5dur927SzPX3PokE5euKBakyZZj2VYLBr588+asW6d/njqqSzPWXnggHadOKF37rlHL/38s9pWqSIvV1fdW7OmZm3YkD83mke32/D6t02bNikzM1Nvv/22zGazJOnLL7/M1RilSpXSsWPHrI8zMjL0559/qlWrVjd8Xr169bRjxw6bBlxRZM7Lkx5//HGdO3dO27dv15kzZ3TmzBn9+eefSklJybZDCAAAUFysXLlSYWFhmjp1qpKSkpSUlGTdkHblypVGxwMAAACKJE9nN7mab2sxKxRxwcmpRkcodM6npurAmTMq4539kqAWXV32LjU9PdvzPSIitHrQIK3673+tH8E+PnqiSRN9+/DDWa6/fOWKRixapEmdO8vJbFaGxaIrmZmSpCsZGcr4/88LC3s3vCpXrqwrV67onXfe0V9//aWPPvpIM2fOzNUYrVu31qJFi7Ro0SLt2rVLgwYNUnJy8k2f9+yzz2rNmjUaMmSIEhIStHfvXn3//fcaMmRIHu+mcMpTw2vx4sWaPn26zbqO4eHhmjZtmn766Se7hQMAAHA0gwcPVvfu3XXgwAF9++23+vbbb/XXX3+pR48eGjx4sNHxAAAAgCKLWV7IiYvMcj+ZZHQMw41cskS/HTyoQ0lJWn/4sP7zxRdyMpt1f+3aOnjmjCauWqWEo0d1JDlZ6w8fVp8vv5S7i4vuvm4pxDvfeUc//P9qJgGengovU8bmw9lsVmlvb1UJDMxS/62VK9W2ShVFBAdLkhqHhuqHnTv1Z2KiZm3YoMaFaWk9s1lydbXrkBEREZo4caLefPNN1apVS5988oneeOONXI3xyCOPqE+fPurdu7datGihSpUq3XR2lyTVqVNHK1as0J49e9SsWTPVrVtXo0aNUkhISF5vp1DK09seMjMz5ZLNmp0uLi7KLGRdWAAAgIK0b98+ff3113JycrIec3Jy0rBhw/Thhx8amAwAAAAo2nxdvXTy8lmjY6AQustcRkq/aHQMwx1NSdGjX3+tM5cuKdDTU43Ll9cvjz6qQC8vXcnI0NpDhzRj3TolX7qk0t7ealKhgn7u10+lrpsBtvf0aaVcvpzr2juOH9d327dr1X//az3WJTxcvx08qA5z56pyyZL6oFs3u9ynPZi8vXPcl+xWxMXFZXv8qaee0lP/Wurx4etmw8XGxio2Ntb6eMyYMRozZoz1sYuLi6ZPn67p06fnWPvgwYPZHr/zzjv1888/3zS7I8tTw6t169Z68skn9dlnn1k7gP/884+eeuoptWnTxq4BAQAAHEm9evW0c+dOVatWzeb4zp07FRERYVAqAAAAoOgr4cIML2SvcZqvJBpecx54IMdzwSVK6Kv//OemYyRf13zJTnb7dklSeJky2vyv7ZDMZrPe7tRJb3fqdNO6Bc3s42N0BORBnhpe7777ru655x6FhYUpNDRUknTkyBHVqlVLH3/8sV0DAgAAFHbbtm2zfv7EE0/oySef1L59+9S4cWNJ0rp16zRt2jSNGzfOqIgAAABAkefHkobIQZULedrZB8WYKYd9zVC45anhFRoaqs2bN+uXX37Rrl27JEk1atRQdHS0XcMBAAA4gsjISJlMJlksFuuxZ555Jst1Dz30kLp3716Q0QAAAIBigz28kJOSpy8YHQEOxlyihNERkAe5anj9+uuvGjJkiNatW6cSJUqobdu2atu2rSTp7NmzqlmzpmbOnKlmzZrlS1gAAIDC6MCBA0ZHAAAAAIo9Gl7ITmmTh5ySko2OAQdj9vU1OgLyIFcNr8mTJ6t///4qkU1309fXVwMHDtTEiRNpeAEAgGKlQoUKRkcAAAAAir0yHn5GR0Ah1EplJCUZHQMOxsQML4eUq8VLt27dqnbt2uV4/u6779amTZtuOxQAAICj27FjhxYvXqwFCxbYfAAAAADIHxV9goyOgEKo7mVPoyPAAZn9/G57jNOnT6t06dI6ePDgbY91K5YvXy6TyaTk5GRJUlxcnPyuu48xY8YoMjIyXzOEhYVp+fLlt3z95cuXNW7cOF28eNHm+HPPPafHH3881/VzNcPr+PHjcnFxyXkwZ2edPHky1yEAAACKir/++kv33nuv/vjjD5t9vUwmkyQpIyPDyHgAAABAkUXDC9mpkMK/wZB7TqVK3fYYr732mrp06aKwsLDbD3QLmjRpomPHjsm3kC3HOG3aNL311ltKTExURESE3nnnHTVs2FCS5O7urrlz56pGjRrq0qWL9TnDhw9XpUqV9NRTT6lSpUq3XCtXM7zKli2rP//8M8fz27ZtU3BwcG6GBAAAKFKefPJJVaxYUSdOnJCnp6e2b9+ulStXqkGDBrl6lxMAAACA3PF0dlcZD3+jY6CQ8T551ugIcDAmb2+Z3N1va4yLFy9q9uzZ6tevn51S3Zyrq6uCgoKsb7gtDL744gsNGzZMo0eP1ubNmxUREaGYmBidOHHCek2XLl2yrIgTGBiomJgYzZgxI1f1ctXw6tChg1566SVdvnw5y7lLly5p9OjR6tSpU64CAAAAFCVr167Vyy+/rMDAQJnNZpnNZt11111644039MQTTxgdDwAAACjSmOWF60WYAmS6dMnoGHAw5sDA2x7jxx9/lJubmxo3bizp6mov/fr1U8WKFeXh4aFq1appypQpNs+JjY1V165dNWHCBAUHB6tkyZIaPHiwrly5Yr0mNTVVzz77rEJDQ+Xm5qbKlStr9uzZkrIuaXgzGzduVNu2bRUYGChfX1+1aNFCmzdvvu17v97EiRPVv39/9e3bV+Hh4Zo5c6Y8PT01Z84c6zX33HOPFi5cqMzMTJvndu7cWZ9//nmu6uWq4TVy5EidOXNGVatW1fjx4/X999/r+++/15tvvqlq1arpzJkzevHFF3MVAAAAoCjJyMiQj4+PpKvvSDp69KgkqUKFCtq9e7eR0QAAAIAir6I3DS/8T7OMkkZHgANyskPDa9WqVapfv771cWZmpsqVK6evvvpKO3bs0KhRo/TCCy/oyy+/tHnesmXLtH//fi1btkzz5s1TXFyc4uLirOd79+6tzz77TFOnTtXOnTv13nvvydvbO08Zz507pz59+ui3337TunXrVKVKFXXo0EHnzp2zXtO+fXt5e3vn+FGzZs0cx09LS9OmTZsUHR1tPWY2mxUdHa21a9dajzVp0kSZmZlat26dzfMbNmyov//+O1d7oOVqD68yZcpozZo1GjRokJ5//nmbPSliYmI0bdo0lSlTJjdDAgAAFCm1atXS1q1bVbFiRTVq1Ejjx4+Xq6ur3n///VytOw0AAAAg9yqVoOGF/wm/5GJ0BDggsx327zp06JBCQkKsj11cXDR27Fjr44oVK2rt2rX68ssv9eCDD1qP+/v7691335WTk5OqV6+ujh07Kj4+Xv3799eePXv05ZdfaunSpdYm0u28ztC6dWubx++//778/Py0YsUK60p+H3zwgS7dYJaki0vOf8dOnTqljIyMLD2jMmXKaNeuXdbHZrNZnTp10oIFC9SkSRPr8Wtfv0OHDt3yPmi5anhJV9+d/OOPPyopKUn79u2TxWJRlSpV5O/P+rgAAAAjR47UhQsXJEkvv/yyOnXqpGbNmqlkyZL64osvDE4HAAAAFG0VfYKNjoBCJCgp1egIcED2mOF16dIluf9rH7Bp06Zpzpw5Onz4sC5duqS0tDRFRkbaXFOzZk05OTlZHwcHB+uPP/6QJCUkJMjJyUktWrS47XySdPz4cY0cOVLLly/XiRMnlJGRoYsXL+rw4cPWa8qWLWuXWjfToUMHvfLKKxo3bpz1mIeHh6Sr+6Hdqlw3vK7x9/fXnXfemdenAwAAFEkxMTHWzytXrqxdu3bpzJkz8vf3L1QbxwIAAABFUZh3aZllUqYsRkeBwTzlLNdTSUbHgAOyxwyvwMBAJSX978/f559/ruHDh+vtt99WVFSUfHx89NZbb2n9+vU2z/v3jCmTyWTd2+paA8he+vTpo9OnT2vKlCmqUKGC3NzcFBUVpbS0NOs17du316pVq3Ico0KFCtq+fXu25wIDA+Xk5KTjx4/bHD9+/LiCgmxn4x44cCDLLK4zZ85Ikkrl4vuR54YXAAAAbuzIkSOSpNDQUIOTAAAAAMWDm5OrQjxL6u+Lp4yOAoM1M5WWMi4YHQMOxuTjI/P/78t9O+rWrauPP/7Y+nj16tVq0qSJHnvsMeux/fv352rM2rVrKzMzUytWrLDZFyuvVq9erenTp6tDhw6Srr6GceqU7c/O21nS0NXVVfXr11d8fLy6du0q6epeZvHx8RoyZIjNtQsWLFBsbKzNsT///FMuLi433Cfs38y3fCUAAABuKj09XS+99JJ8fX0VFhamsLAw+fr6auTIkbpy5YrR8QAAAIAir6IP+3hBanjF1+gIcEBOdlrCLyYmRtu3b7fO8qpSpYp+//13LVmyRHv27NFLL72kjRs35mrMsLAw9enTR4888ojmz5+vAwcOaPny5fryyy/zlLFKlSr66KOPtHPnTq1fv169evXKMousbNmyqly5co4fFSpUuGGNYcOGadasWZo3b5527typQYMG6cKFC+rbt6/1mpMnT2r9+vXq3LmzzXNXrVqlZs2a5WpmGw0vAAAAO3r88cf1/vvva/z48dqyZYu2bNmi8ePHa/bs2XriiSeMjgcAAAAUeTS8IEmVzxudAI7I2U4Nr9q1a6tevXrWZtTAgQN13333qXv37mrUqJFOnz5tM9vrVs2YMUP333+/HnvsMVWvXl39+/e37iOeW7Nnz1ZSUpLq1aunhx9+WE888YRKly6dp7Fy0r17d02YMEGjRo1SZGSkEhIStHjxYpUpU8Z6zcKFC9WgQQObY9LVZSD79++fq3osaQgAAGBHn376qT7//HO1b9/eeqxOnToKDQ1Vz549NWPGDAPTAQAAAEXfHSVCjI6AQsD/FB0v5J5TuXJ2G2vUqFEaMWKE+vfvLzc3N82dO1dz5861ueaNN96wfh4XF5dljMmTJ9s8dnd318SJEzVx4sQs17Zs2VIWy//2L4yNjbVZJnDMmDEaM2aM9XHdunWzzDK7//77b+HOcmfIkCFZljC83oIFC3TPPffYHPvpp59kNptznYcZXgAAAHbk5uaWZaNVSapYsaJcXV0LPhAAAABQzESWvMPoCDBYOZOXzGdTjI4BR2MyySnEfg3zjh07asCAAfrnn3/sNmZRc/nyZS1dujRLw+vChQuaO3eunJ1zN2eLhhcAAIAdDRkyRK+88opSU1Otx1JTU/Xaa6/d8B1NAAAAAOwjwM1HlXyCjY4BA7WylLn5RcC/mEuVksnOb1QdOnSoQkND7TpmUeLu7q7z58+rZs2aNsfvv/9+NWrUKNfjsaQhAADAbbrvvvtsHv/yyy8qV66cIiIiJElbt25VWlqa2rRpY0Q8AAAAoNhpEFhVf507ZnQMGCTisrvREeCAnOy0f1dxNnTo0GxXvSkoNLwAAABuk6+vr83jbt262Tzm3VwAAABAwWoQWEVfHlhhdAwYJPRsutER4ICcK1Y0OoLDGzp0qKH1aXgBAADcpn9vOgsAAADAWJEl75CzyUnplgyjo6CAmSwmeZ1MNjoGHJBzpUpGR8BtouEFAACQD06ePKndu3dLkqpVq6ZSpUoZnAgAAAAoPjyc3VTTv4K2nvnL6CgoYHc6lZSu21MZuBXmMmVk9vIyOgZuk9noAAAAAEXJhQsX9Mgjjyg4OFjNmzdX8+bNFRISon79+unixYtGxwMAAACKjfqBVYyOAAM0SQ8wOgIcELO7igYaXgAAAHY0bNgwrVixQj/88IOSk5OVnJys77//XitWrNDTTz9tdDwAAACg2GgQWNXoCDBA9YsuRkeAA3K+4w6jI8AOWNIQAADAjr755ht9/fXXatmypfVYhw4d5OHhoQcffFAzZswwLhwAAABQjNTwKy8vZ3ddSL9sdBQUoDJJl4yOAEfj7CznChWMTgE7YIYXAACAHV28eFFlypTJcrx06dJ5XtJw2rRpCgsLk7u7uxo1aqQNGzbkeO2sWbPUrFkz+fv7y9/fX9HR0Te8HgAAACiqnM1OiizJrI3ixEcucjmVZHQMOBjn8uVlcmZuUFFAwwsAAMCOoqKiNHr0aF2+/L93kV66dEljx45VVFRUrsf74osvNGzYMI0ePVqbN29WRESEYmJidOLEiWyvX758uXr27Klly5Zp7dq1Cg0N1d13361//vknz/cEAAAAOCqWNSxeWprKSJmZRseAg3GuVs3oCLAT2pYAAAB2NHnyZLVr107lypVTRESEJGnr1q1yd3fXkiVLcj3exIkT1b9/f/Xt21eSNHPmTC1atEhz5szRc889l+X6Tz75xObxBx98oG+++Ubx8fHq3bt3Hu4IAAAAcFx3lqLhVZw0SPORdM7oGHAwLjVqGB0BdkLDCwAAwI5q166tvXv36pNPPtGuXbskST179lSvXr3k4eGRq7HS0tK0adMmPf/889ZjZrNZ0dHRWrt27S2NcfHiRV25ckUBAQG5qg0AAAAUBRW8y6iST5D+OpdodBQUgEr0upBLTqGhMvv4GB0DdkLDCwAAwE6uXLmi6tWra+HCherfv/9tj3fq1CllZGRk2ROsTJky1mbazTz77LMKCQlRdHR0jtekpqYqNTXV+jglJSVvgQEAAIBC6O6yDTRz10KjY6AA+J2m44XccQkPNzoC7MjQPbxWrlypzp07KyQkRCaTSfPnz7c5b7FYNGrUKAUHB8vDw0PR0dHau3evzTVnzpxRr169VKJECfn5+alfv346f/68zTXbtm1Ts2bN5O7urtDQUI0fPz6/bw0AABRDLi4uNnt3GW3cuHH6/PPP9d1338nd3T3H69544w35+vpaP0JDQwswJQAAAJC/7i5bT2aZjI6BfFbJVEKmFBpeyB2WMyxaDG14XbhwQREREZo2bVq258ePH6+pU6dq5syZWr9+vby8vBQTE2PzQlKvXr20fft2LV26VAsXLtTKlSs1YMAA6/mUlBTdfffdqlChgjZt2qS33npLY8aM0fvvv5/v9wcAAIqfwYMH680331R6evptjxUYGCgnJycdP37c5vjx48cVFBR0w+dOmDBB48aN088//6w6derc8Nrnn39eZ8+etX4cOXLktrMDAAAAhUUpDz/VC6xidAzks5aZgUZHgINxKltWZl9fo2PAjgxd0rB9+/Zq3759tucsFosmT56skSNHqkuXLpKkDz/8UGXKlNH8+fPVo0cP7dy5U4sXL9bGjRvVoEEDSdI777yjDh06aMKECQoJCdEnn3yitLQ0zZkzR66urqpZs6YSEhI0ceJEm8YYAACAPWzcuFHx8fH6+eefVbt2bXl5edmc//bbb295LFdXV9WvX1/x8fHq2rWrJCkzM1Px8fEaMmRIjs8bP368XnvtNS1ZssT6O9KNuLm5yc3N7ZZzAQAAAI4mplwD/X5qj9ExkI9qX87dnskAyxkWPYbO8LqRAwcOKDEx0Wa/CV9fXzVq1Mi6SfvatWvl5+dn80JOdHS0zGaz1q9fb72mefPmcnV1tV4TExOj3bt3KykpKdvaqampSklJsfkAAAC4FX5+furWrZtiYmIUEhJis1Sgbx7eOTZs2DDNmjVL8+bN086dOzVo0CBduHBBffv2lST17t1bzz//vPX6N998Uy+99JLmzJmjsLAwJSYmKjExMcuSzwAAAEBx0iKotjyceJNXUVbu7BWjI8CRmM1yuclqKHA8hs7wupHExERJynaT9mvnEhMTVbp0aZvzzs7OCggIsLmmYsWKWca4ds7f3z9L7TfeeENjx461z40AAIBiZe7cuXYdr3v37jp58qRGjRqlxMRERUZGavHixdbfZw4fPiyz+X/vYZoxY4bS0tJ0//3324wzevRojRkzxq7ZAAAAAEfh4eymFsG1tfjv342OgnzgZDHJ42T2kxuA7DhXqSKzt7fRMWBnhbbhZaTnn39ew4YNsz5OSUlh83YAAHBDmZmZeuutt7RgwQKlpaWpTZs2Gj16tDw8bn9ZjSFDhuS4hOHy5cttHh88ePC26wEAAABFUUzZBjS8iqjG5lJSWqrRMeBAXCMjjY6AfFBolzS8thH7jTZpDwoK0okTJ2zOp6en68yZMzbXZDfG9TX+zc3NTSVKlLD5AAAAuJHXXntNL7zwgry9vVW2bFlNmTJFgwcPNjoWAAAAgP9XL7CySrv7GR0D+SAqPesqXkBOTN7ecq5a1egYyAeFtuFVsWJFBQUFKT4+3nosJSVF69evV1RUlCQpKipKycnJ2rRpk/WaX3/9VZmZmWrUqJH1mpUrV+rKlf+t4bp06VJVq1Yt2+UMAQAA8uLDDz/U9OnTtWTJEs2fP18//PCDPvnkE2VmZhodDQAAAIAks8mstmXrGR0D+aDaRSejI8CBuNSpI5O50LZGcBsM/a6eP39eCQkJSkhIkCQdOHBACQkJOnz4sEwmk4YOHapXX31VCxYs0B9//KHevXsrJCREXbt2lSTVqFFD7dq1U//+/bVhwwatXr1aQ4YMUY8ePRQSEiJJeuihh+Tq6qp+/fpp+/bt+uKLLzRlyhSbJQsBAABu1+HDh9WhQwfr4+joaJlMJh09etTAVAAAAACuF1OugdERkA9KnblkdAQ4ENe6dY2OgHxi6B5ev//+u1q1amV9fK0J1adPH8XFxemZZ57RhQsXNGDAACUnJ+uuu+7S4sWL5e7ubn3OJ598oiFDhqhNmzYym83q1q2bpk6daj3v6+urn3/+WYMHD1b9+vUVGBioUaNGacCAAQV3owAAoMhLT0+3+R1FklxcXGxmmQMAAAAwVkWfIFX3DdWus0eMjgI78ZebnE8nGR0DDsKpQgU5BQYaHQP5xNCGV8uWLWWxWHI8bzKZ9PLLL+vll1/O8ZqAgAB9+umnN6xTp04drVq1Ks85AQAAbsZisSg2NlZubm7WY5cvX9Z///tfeXl5WY99++23RsQDAAAA8P+6V2qhsVs+NjoG7KSVqbRkSTE6BhyEW+PGRkdAPjK04QUAAFBU9OnTJ8ux//znPwYkAQAAAHAjrUIi9cHun/TPxdNGR4Ed1Ev1kUTDCzdnDgiQc7VqRsdAPqLhBQAAYAdz5841OgIAAACAW+BkMqvnHa004Y+vjY4CO6h4LtPoCHAQro0ayWQyGR0D+chsdAAAAAAAAAAAKEjtyzVUSbcSRseAHZQ4xewu3JzJ3V2udesaHQP5jIYXAAAAAAAAgGLF1clZD1ZqbnQM3KZqJl+Zzl8wOgYcgGv9+jK5uBgdA/mMhhcAAAAAAACAYqdrhSbycfEwOgZuQ4vMUkZHgCMwm+XaqJHRKVAAaHgBAAAAAAAAKHY8nd11X9hdRsfAbah1yc3oCHAALpGRMvv4GB0DBYCGFwAAAAAAAIBi6f6KzeTu5Gp0DORRSHKa0RFQ2Dk5yb05y5cWFzS8AAAAAAAAABRLfq7e6lyepc4ckYvMcj95xugYKORc69WT2dfX6BgoIDS8AAAAAAAAABRb3Su1lLPJyegYyKWmptJSerrRMVCYOTvLrVkzo1OgANHwAgAAAAAAAFBslfHw193l6hsdA7nUON3P6Ago5Fzr12fvrmKGhhcAAAAAAACAYq1P5bZyNTsbHQO5UOU8L23jBlxc5HbXXUanQAHjpwIAAAAAAACAYi3Eq6R6VGppdAzkQuCZC0ZHQCHm1rChzN7eRsdAAaPhBQAAAAAAAKDYe7hKtEq7+xkdA7egtMlDTmeSjY6BQsrk5cXeXcUUDS8AAAAAAAAAxZ67k6sGh99jdAzcglaW0kZHQCHm1rKlTG5uRseAAWh4AQAAAAAAAICk1iGRqleyitExcBN107yMjoBCyly6tFzr1TM6BgxCwwsAAAAAAAAA/t/QWvfKycTLpoVZ+bMZRkdAIeXRvr1MZv7+Fld85wEAAAAAAADg/1X0CdJ9YU2NjoEb8Dl51ugIKIRcataUc1iY0TFgIBpeAAAAAAAAAHCdR6q2k7+rt9ExkI06pgCZLl0yOgYKGxcXud99t9EpYDAaXgAAAAAAAABwHW8XDw2s0cnoGMhGs8ySRkdAIeTeurXMJUoYHQMGo+EFAAAAAAAAAP/SodydCvcrb3QM/Ev4RVejI6CQcQoNlWujRkbHQCFAwwsAAAAAAAAA/sVkMumpWt1klsnoKLhOUNJloyOgMHFyksc998hk4u8paHgBAAAAAAAAQLaq+4XqvrC7jI6B/+chJ7mdSjI6BgoRtxYt5BQYaHQMFBI0vAAAAAAAAAAgB/+t0VEVvMsYHQOSmpnKSBkZRsdAIWEOCpJb06ZGx0AhQsMLAAAAAAAAAHLg5uSqUXV7ydnkZHSUYq/hlRJGR0BhYTbL8557ZDLT4sD/8KcBAAAAAAAAAG6gqm85PVItxugYxV7l87ycjavcWraUU3Cw0TFQyPATAgAAAAAAAABuotcdrVUnoKLRMYq1gNPnjI6AQsCpYkW53cXeesiKhhcAAAAAAAAA3ITZZNbIyF7ydnY3OkqxVNbkJXNyitExYDCTp6c8771XJpPJ6CgohGh4AQAAAAAAAMAtCPYM0LMR3Y2OUSy1tJQ2OgIKAY+uXWX28TE6BgopGl4AAAAAAAAAcItaBkfovjCWUytokakeRkeAwVwbN5ZLlSpGx0AhRsMLAAAAAAAAAHJhcI17VNW3nNExipXQsxlGR4CBzMHBco+ONjoGCjkaXgAAAAAAAACQC65Oznq5Xm95sZ9XgTBZTPI+mWx0DBjE5OkprwcflMnJyegoKORoeAEAAAAAAABALpX1CtSzdbrLJJPRUYq8+uaS0uXLRseAEcxmeT7wgMx+fkYngQOg4QUAAAAAAAAAedAqJEL9q7c3OkaR1zQjwOgIMIh7TIycw8KMjgEHQcMLAAAAAAAAAPLo4crRuqd8Y6NjFGk1LroYHQEGcKlXT24NGxodAw6EhhcAAAAAAAAA3IZhte9X41LVjY5RZJVJumR0BBQwp9BQeXToYHQMOBgaXgAAAAAAAABwG5xMZo2t30dVfcsZHaXI8ZKzXE4lGR0DBcjk6yvPBx+UycnJ6ChwMDS8AAAAAAAAAOA2eTq76c07H1UZD3+joxQpLU1BUmam0TFQQEyenvL6z39k9vY2OgocEA0vAAAAAAAAALCDQPcSeqthf3m7eBgdpci484qP0RFQUFxc5Nmzp5wCA41OAgdFwwsAAAAAAAAA7KSiT5Beqx8rFzPLsdlDpXNGJ0CBMJvl+eCDci7HsqDIOxpeAAAAAAAAAGBH9QKr6Lk6PYyOUST4naLjVRx43HOPXCpXNjoGHBwNLwAAAAAAAACws7vL1Vf/au2NjuHQwkw+MqfQ8Crq3KOj5RoRYXQMFAE0vAAAAAAAAAAgH/Su0lbdK7UwOobDamUpZXQE5DO3li3l1rSp0TFQRNDwAgAAAAAAAIB8MiS8i2Kr3G10DIdU+7KH0RGQj9xatpR7CxrCsB8aXgAAAAAAAACQj/pVa6dBNToZHcPhlEu+YnQE5BO3Vq1odsHuaHgBAAAAAAAAQD576I7WGlarm0wyGR3FIThZTPI8mWR0DOQDt1at5N68udExUATR8AIAAAAAAACAAnBvWFO9ENlDTiZelr2Zhk6lpLQ0o2PAztxat6bZhXzDT1YAAAAAAAAAKCDtyt2p0XUflrPJyegohVqTK35GR4A9mUxyb9dO7s2aGZ0ERZiz0QEAAAAAAAAAoDhpFRIhdycXjdwUp7TMdKPjFErVLvLSdZHh5CTPe++VS82aRidBEccMLwAAAAAAAAAoYFFlwjWh4QB5OLkZHaVQKn3mktERYA9ubvL6z39odqFA0PACAAAo5KZNm6awsDC5u7urUaNG2rBhQ47Xbt++Xd26dVNYWJhMJpMmT55ccEEBAAAA5ErdwMqa1HigvF08jI5SqPjJVc6nk4yOgdtk8vGRd9++cg4LMzoKigkaXgAAAIXYF198oWHDhmn06NHavHmzIiIiFBMToxMnTmR7/cWLF1WpUiWNGzdOQUFBBZwWAAAAQG7V9A/Te02fVAXvMkZHKTRaKkiyWIyOgdtgDgyUd79+cirDn2sUHBpeAAAAhdjEiRPVv39/9e3bV+Hh4Zo5c6Y8PT01Z86cbK+/88479dZbb6lHjx5yc2NpFAAAAMARlPcurffvGqoWQXWMjlIo1L/iZXQE3AbnKlXk3a+fzL6+RkdBMVOoG15jxoyRyWSy+ahevbr1/OXLlzV48GCVLFlS3t7e6tatm44fP24zxuHDh9WxY0d5enqqdOnSGjFihNLT2QgSAAAUfmlpadq0aZOio6Otx8xms6Kjo7V27VoDkwEAAACwN09nN73aIFYDq3eUWSaj4xiqYgqzuxyV2113ybNnT5nc3Y2OgmLI2egAN1OzZk398ssv1sfOzv+L/NRTT2nRokX66quv5OvrqyFDhui+++7T6tWrJUkZGRnq2LGjgoKCtGbNGh07dky9e/eWi4uLXn/99QK/FwAAgNw4deqUMjIyVOZfS0CUKVNGu3btslud1NRUpaamWh+npKTYbWwAAAAAufOfym1Uzbecxm7+WGevXDA6jiF8T/FvEofj4iLPLl3kUrOm0UlQjBXqGV7S1QZXUFCQ9SMwMFCSdPbsWc2ePVsTJ05U69atVb9+fc2dO1dr1qzRunXrJEk///yzduzYoY8//liRkZFq3769XnnlFU2bNk1paWlG3hYAAECh8cYbb8jX19f6ERoaanQkAAAAoFi7s1Q1zWr2lKqUKGt0lAJXzeQr0/ni2ehzVCY/P3n360ezC4Yr9A2vvXv3KiQkRJUqVVKvXr10+PBhSdKmTZt05coVmyV+qlevrvLly1uX+Fm7dq1q165t867omJgYpaSkaPv27TnWTE1NVUpKis0HAABAQQsMDJSTk1OWJZuPHz+uoKAgu9V5/vnndfbsWevHkSNH7DY2AAAAgLwJ9gzQjKaPK6ZsA6OjFKjmmYFGR0AuOFeuLO8BA+T0r5VJACMU6oZXo0aNFBcXp8WLF2vGjBk6cOCAmjVrpnPnzikxMVGurq7y8/OzeU6ZMmWUmJgoSUpMTMx2CaBr53LCu5wBAEBh4Orqqvr16ys+Pt56LDMzU/Hx8YqKirJbHTc3N5UoUcLmAwAAAIDx3JxcNbLuQxpa8145m5yMjlMgal1m7yeHYDbLPTpang89JLOHh9FpAEmFfA+v9u3bWz+vU6eOGjVqpAoVKujLL7+URz7+JXr++ec1bNgw6+OUlBSaXgAAwBDDhg1Tnz591KBBAzVs2FCTJ0/WhQsX1LdvX0lS7969VbZsWb3xxhuSpLS0NO3YscP6+T///KOEhAR5e3urcuXKht0HAAAAgLzrVrGZqviW1ahNH+p0atFejapsMlvRFHYmPz95dusm53LljI4C2CjUDa9/8/PzU9WqVbVv3z61bdtWaWlpSk5Otpnldf0SP0FBQdqwYYPNGNeWBLrRMkBubm5yc3Oz/w0AAADkUvfu3XXy5EmNGjVKiYmJioyM1OLFi62z1g8fPiyz+X+T9o8ePaq6detaH0+YMEETJkxQixYttHz58oKODwAAAMBO6gRU0kctntHUHd9r8d8bjY6TL1xklvvJJKNj4AZc6tSRR4cOMvH6OQqhQr2k4b+dP39e+/fvV3BwsOrXry8XFxebJX52796tw4cPW5f4iYqK0h9//KETJ05Yr1m6dKlKlCih8PDwAs8PAACQF0OGDNGhQ4eUmpqq9evXq1GjRtZzy5cvV1xcnPVxWFiYLBZLlg+aXQAAAIDj83H11IuRPTWhYX+VdvczOo7dNTGVlq5cMToGsmFyd5dHt27yvPdeml0otAp1w2v48OFasWKFDh48qDVr1ujee++Vk5OTevbsKV9fX/Xr10/Dhg3TsmXLtGnTJvXt21dRUVFq3LixJOnuu+9WeHi4Hn74YW3dulVLlizRyJEjNXjwYGZwAQAAAAAAAHBIjUrX0Ectn1HXCk1kksnoOHbTON3P6AjIhnN4uLwHD5ZrrVpGRwFuqFAvafj333+rZ8+eOn36tEqVKqW77rpL69atU6lSpSRJkyZNktlsVrdu3ZSamqqYmBhNnz7d+nwnJyctXLhQgwYNUlRUlLy8vNSnTx+9/PLLRt0SAAAAAAAAANw2T2d3PV37frUOidT4rV/q74unjI5026peKNTzM4odk7e3PDp2lEv16kZHAW5JoW54ff755zc87+7urmnTpmnatGk5XlOhQgX9+OOP9o4GAAAAAAAAAIarW7Ky4loM1we7F+urAyuVYck0OlKeBZ6+YHQE/D+XunXlcffdMrm7Gx0FuGWFuuEFAAAAAAAAALgxNydXDQ6/R62CIzRu2xc6cC7R6Ei5VkrucjqTbHSMYs8cECCPTp3kXLGi0VGAXGOOKAAAAAAAAAAUAeH+FTS72TDFVrlbrmbHmuvQylTG6AjFm5ub3Nu2lfdjj9HsgsNyrJ96AAAAAAAAAIAcuZid1a9aO3Uq30hz9/ysxX9vdIhlDuumeklKNjpG8WMyybVuXbm1bi2zl5fRaYDbQsMLAAAAAAAAAIqYMh7+ei6iu3re0VKzdv2kFYnbjI50QxVSCn9TrqhxCguTR0yMnIKCjI4C2AUNLwAAAAAAAAAooip4l9GrDWK1M/mw3tu1SJtO7TU6UrZ8Tp41OkKxYS5dWu6tWsmlenWjowB2RcMLAAAAAAAAAIq4Gn7lNbnxIP1+ao/e37lIO88eMTqSVW2zv0wXLxodo8gzlyol9xYt5BweLpPJZHQcwO5oeAEAAAAAAABAMdEgsKoaNKuq5ce26oPdP+nQ+RNGR9JdGYGSjM9RVJkDA+XWvLlcatWi0YUijYYXAAAAAAAAABQzLYMj1CyothYf2aiP98Xr74unDMtS86KrYbWLMnOpUnK76y651K5NowvFAg0vAAAAAAAAACiGnExmdSzfSB1CG2rDyV369uBqrTuxU5myFGiO4OTUAq1X1DlXrizXxo3lcscdRkcBChQNLwAAAAAAAAAoxkwmkxqVrqFGpWvo6MXTmn9wjX48skFnr1zI99oecpLbqaR8r1PkOTvLpU4duTVuLKdSpYxOAxiChhcAAAAAAAAAQJIU4llSj4V3Vr9q7RR/dIu+O7hau84eybd6d5nKSOn531grqkx+fnKtW1eu9evL7OVldBzAUDS8AAAAAAAAAAA23Jxc1CG0oTqENtSOpEP67tBq/Xo0QWmZ6Xat0/BKCUk0vHLF2Vku4eFyjYyUU1gY+3MB/4+GFwAAAAAAAAAgR+H+FRTuX0GDw+/RosMbFH90i/am/GOXsSufN9tlnOLAqWxZuURGyrVWLZnc3Y2OAxQ6NLwAAAAAAAAAADfl5+qtXpVbq1fl1jp28YxWJf6hVYl/6o+kA8qwZOZpzIAz5+2csmgxBwfLpXp1uYSHyykw0Og4QKFGwwsAAAAAAAAAkCvBngF6sFILPViphZLTzmv18R1alfiHNp7cfcvLHgabPOWUdDafkzoep9BQudSoIZcaNWT28zM6DuAwaHgBAAAAAAAAAPLMz9VbHUMbqmNoQ11KT9X6k7u0KvFPrTmxQ+evXMrxea0spSUlFVzQQsrk4SGnsDA5V6okl2rVZPbxMToS4JBoeAEAAAAAAAAA7MLD2U0tgyPUMjhC6ZkZSji9XxtP7dYfZw5q99kjNrO/6qZ6qlg2vJyd5RQaKudKleRcqZKcgoNlMpmMTgU4PBpeAAAAAAAAAAC7czY7qUGpqmpQqqokKS0jXbvOHtEfZ/7SH0kHFbrbbHDCgmHy9JRTuXJyKldOzuXKySk0VCZnXpoH7I2/VQAAAAAAAACAfOfq5Kw6ARVVJ6Di1QN3SplJSco4elTpR48q88QJZZw8KctZx93Xy1SihJxKlZJTcPDVj5AQ9uECCggNLwAAAAAAAACAIcz+/jL7+8ulZk3rMUtamjJPnVLGqVPKPHny6n+TkmRJSZHlUs57ghUYd3eZfX3lVLKkzIGBMgcGyikwUOaSJWVydTU6HVBs0fACAAAAAAAAABQaJldXOYWEyCkkJMs5S3q6MlNSZElJUea5c1f/e/68LKmpUmqqLP/+SEuTLJarH9ZB/ve5ydlZcnOTydX16oebm3Ttc09PmX18ZPLxsf2vi0tBfBkA5BINLwAAAAAAAACAQzA5O8spIEAKCDA6CoBCpnjsCggAAAAAAAAAAIAii4YXAAAAAAAAAAAAHBoNLwAAAAAAAAAAADg0Gl4AAAAAAAAAAABwaDS8AAAAAAAAAAAA4NBoeAEAAAAAAAAAAMCh0fACAAAAAAAAAACAQ6PhBQAAAAAAAAAAAIdGwwsAAAAAAAAAAAAOjYYXAAAAAAAAAAAAHBoNLwAAAAAAAAAAADg0Gl4AAAAAAAAAAABwaDS8AAAAAAAAAAAA4NBoeAEAAAAAAAAAAMCh0fACAAAAAAAAAACAQ6PhBQAAAAAAAAAAAIdGwwsAAAAAAAAAAAAOjYYXAAAAAAAAAAAAHBoNLwAAAAAAAAAAADg0Gl4AAAAAAAAAAABwaDS8AAAAAAAAAAAA4NBoeAEAAAAAAAAAAMCh0fACAAAAAAAAAACAQ6PhBQAAAAAAAAAAAIdGwwsAAAAAAAAAAAAOjYYXAAAAAAAAAAAAHBoNLwAAAAAAAAAAADg0Gl4AAAAAAAAAAABwaDS8AAAAAAAAAAAA4NCKVcNr2rRpCgsLk7u7uxo1aqQNGzYYHQkAAOCmcvs7zFdffaXq1avL3d1dtWvX1o8//lhASQEAAAAAAIxRbBpeX3zxhYYNG6bRo0dr8+bNioiIUExMjE6cOGF0NAAAgBzl9neYNWvWqGfPnurXr5+2bNmirl27qmvXrvrzzz8LODkAAAAAAEDBcTY6QEGZOHGi+vfvr759+0qSZs6cqUWLFmnOnDl67rnnDE4HACgOhnzwW76N/e6jd+Xb2LmVn/cpFa57LQi5/R1mypQpateunUaMGCFJeuWVV7R06VK9++67mjlzZoFmBwAAAAAAKCjFouGVlpamTZs26fnnn7ceM5vNio6O1tq1aw1MBgBA/qL55Njy8jvM2rVrNWzYMJtjMTExmj9/fn5GBQAAAAAAMFSxaHidOnVKGRkZKlOmjM3xMmXKaNeuXVmuT01NVWpqqvXx2bNnJUkpKSn5ki/t0oV8GfeanHLnZ93iXnP4vPxtpE7oE1UoauZ3XWry56io1SxqPwNzqmvU/9fsNa7FYsmX8fMit7/DSFJiYmK21ycmJuZYp6B/99Gl1Jtfg3yR5pS/fz+Rs3z7+1Sc8LPDMPzsME5x+r0HAADgdpksxeC3m6NHj6ps2bJas2aNoqL+9yLkM888oxUrVmj9+vU2148ZM0Zjx44t6JgAAKAQOHLkiMqVK2d0DEm5/x1GklxdXTVv3jz17NnTemz69OkaO3asjh8/nm0dfvcBAKB4Kky/9wAAANyuYjHDKzAwUE5OTlle5Dl+/LiCgoKyXP/888/bLAWUmZmpM2fOqGTJkjKZTPme90ZSUlIUGhqqI0eOqESJEkW2plF1qVm0ahpVl5rUdNS6xaVmTiwWi86dO6eQkBBDc1wvt7/DSFJQUFCurpcK9+8+sJ/C9PcNgOPgZ0fRVBh/7wEAALhdxaLh5erqqvr16ys+Pl5du3aVdPWFnPj4eA0ZMiTL9W5ubnJzc7M55ufnVwBJb12JEiUK/B8bRtQ0qi41i1ZNo+pSk5qOWre41MyOr6+v0RFs5PZ3GEmKiopSfHy8hg4daj22dOlSmxli/+YIv/vAfgrL3zcAjoWfHUVPYfu9BwAA4HYVi4aXJA0bNkx9+vRRgwYN1LBhQ02ePFkXLlxQ3759jY4GAACQo5v9DtO7d2+VLVtWb7zxhiTpySefVIsWLfT222+rY8eO+vzzz/X777/r/fffN/I2AAAAAAAA8lWxaXh1795dJ0+e1KhRo5SYmKjIyEgtXrw4y6buAAAAhcnNfoc5fPiwzGaz9fomTZro008/1ciRI/XCCy+oSpUqmj9/vmrVqmXULQAAAAAAAOS7YtPwkqQhQ4bkuPyPo3Bzc9Po0aOzLDtU1GoaVZeaRaumUXWpSU1HrVtcajqiG/0Os3z58izHHnjgAT3wwAP5nAqOhr9vAPKCnx0AAABwFCaLxWIxOgQAAAAAAAAAAACQV+abXwIAAAAAAAAAAAAUXjS8AAAAAAAAAAAA4NBoeAEAAAAAAAAAAMCh0fACAAAAiojly5crLCzslq/fuHGjvvrqq/wLBMAh5PZnx549e/TBBx/kXyAAAAAgD2h4OZDU1FSlpqYaHQMAAAAO4syZM+rVq5dKlCghPz8/9evXT+fPn7eeT09P12OPPaaMjAwDUwIobF577TU1adJEnp6e8vPzy3Le29tbgwYN0pkzZwo+HAAAAJADGl6F3NKlS9WhQwf5+/vL09NTnp6e8vf3V4cOHfTLL78YHc/uzp49q927d2v37t06e/as0XHyVXG41/T0dG3dulVLlizRkiVLtHXrVl25csWwLIcPHzakNgAARunVq5e2b9+upUuXauHChVq5cqUGDBhgPd+oUSM5OTlpzZo1BqYEUNikpaXpgQce0KBBg7I9HxISorp162rRokUFnAwAAADIGQ2vQmzevHnq0KGDfH19NWnSJC1cuFALFy7UpEmT5Ofnpw4dOuijjz4q0Ew7d+5UpUqV7D7uBx98oPDwcAUEBCg8PNzm89mzZ9u93q3YunWrnJyc7D5uYbvX/LjPzMxMjRw5UqVKlVLdunXVvn17tW/fXnXr1lXp0qX10ksvKTMz0641b2b79u2qWLFivtYoDk1Mqfg0MovLfSYmJur777/Xe++9p/fee0/ff/+9EhMT86XWrbhw4YJWrlxpWH2gKNm5c6cWL16sDz74QI0aNdJdd92ld955R59//rmOHj0qSTKbzerUqZO+//57g9MCKEzGjh2rp556SrVr187xmnvuuYefHQAAAChUnI0OgJy99tprmjx5sgYPHpzlXGxsrO666y69/PLLevjhhwssU1pamg4dOmTXMd966y2NGTNGTzzxhGJiYlSmTBlJ0vHjx/Xzzz/rySefVFJSkoYPH27XurfCYrHYdbzCeq/2vs/nnntOcXFxGjduXLb3+dJLLyktLU1vvvmmXesa5YMPPtDEiRO1e/dum+PVqlXT008/rX79+hVonq1bt6pevXp2X54qMzNTo0aN0rRp07I09Hx9fTVkyBCNHTtWZnPBvZdi+/btdr/X4nKfFy5c0MCBA/X555/LZDIpICBA0tXlzywWi3r27Kn33ntPnp6edqt5K/bt26dWrVqxvBpgB2vXrpWfn58aNGhgPRYdHS2z2az169fr3nvvlXT1ResRI0ZowoQJRkUF4IDuuecejR8/XmlpaXJ1dTU6DgAAAEDDqzA7fPiwoqOjczzfpk0bPf3003atOWzYsBueP3nypF3rSdK7776ruXPn6sEHH7Q5XqNGDbVs2VIREREaMWKE3ZtA99133w3Pnz17ViaTya41jbhXI+7zww8/1EcffaSYmBib42FhYRowYIAqVKig3r1727XhVa9evRuev3Tpkt1qXa+4NDGl4tPILC73+eSTT2rDhg1atGiRoqOjrTM9MzIyFB8fr8cff1xPPvmkZs2aZXBSAHmVmJio0qVL2xxzdnZWQECAzUzOtm3b6u+//9auXbtUvXr1go4JwEHVqVNHJUuW1K+//qp27doZHQcAAACg4VWY1axZU7Nnz9b48eOzPT9nzhyFh4fbteaUKVMUGRmpEiVKZHv++k3O7eXEiRM3XCqjdu3aOnXqlN3r/vDDD2rbtq31xex/y4/ZBUbcqxH3ee7cOYWEhOR4Pjg4WBcuXLBrzR07dqhHjx45Llt47Ngx7dmzx641peLTxJSKTyOzuNznN998o0WLFqlJkyY2x52cnHT33Xdrzpw56tSpk90bXtdmkuWEmV1AwfPw8FDLli31448/0vACkCsdOnTQjz/+SMMLAAAAhQINr0Ls7bffVqdOnbR48WJFR0fbzDKIj4/XX3/9ZfdNgitXrqynnnpK//nPf7I9n5CQoPr169u15p133qlx48Zp9uzZcna2/SOZkZGhN998U3feeadda0pXGxLdunXLcbm5hIQELVy40K41jbhXI+6zZcuWGj58uD755BMFBgbanDt16pSeffZZtWzZ0q41a9WqpUaNGuW4sXZCQkK+zFQpLk1Mqfg0MovLfWZmZt5w+SFXV9d82WsvNTVVgwYNyvHvzaFDhzR27Fi71wWKo6CgIJ04ccLmWHp6us6cOaOgoCCb4wcOHFBYWFgBpgNQFBw4cOCGq5IAAAAABYmGVyHWsmVL/fnnn5oxY4bWrVtnXXomKChI7du313//+1+7vzDRoEEDbdq0KceGl8lksvtSae+++65iYmIUFBSk5s2b2zT2Vq5cKVdXV/388892rSlJ9evX1+bNm3NsBLm5ual8+fJ2rWnEvRpxnzNnzlSHDh0UHBys2rVr29znH3/8ofDwcLs32Zo2bZplD63r+fj4qHnz5natKRWfJqZUfBqZxeU+O3XqpAEDBmj27NmqW7euzbktW7Zo0KBB6ty5s11rSlJkZKRCQ0PVp0+fbM9v3bqVhhdgJ1FRUUpOTtamTZusb1j69ddflZmZqUaNGlmv27dvn/76668sM1sB4EYuXLigX3/9VVOnTjU6CgAAACCJhlehFxYWVqD7xLz99ttKTU3N8XxERITd3/Ffp04d7dmzRx9//LHWrVunv/76S9LVxt6rr76qhx56KMclFm/HzJkzbzgTpkaNGjpw4IBdaxpxr0bcZ2hoqLZu3aolS5bYNGsbNmyo119/XXfffbfMZrNda06ZMuWG5++44w4tW7bMrjWl4tPElIpPI7O43Oe7776rhx56SPXr15e/v791n58TJ04oOTlZMTExevfdd+1aU5I6duyo5OTkHM8HBASod+/edq8LFEc1atRQu3bt1L9/f82cOVNXrlzRkCFD1KNHD5uZrAsWLFCbNm3k5eVlYFoAhcnhw4d15swZHT58WBkZGUpISJB0dUUQb29vSdKSJUt0xx13qHLlygYmBQAAAP7HZLH3dB3YXXp6urZv325tGgQHB6tGjRpycXExOBkA6eoSeNeamNfPxIyKisqXJmZqaqoyMjLk6elp13FvRWZmZpZG5rV7zY9GplGKy31K0q5du7R27dos98k+PoBjWr58uWJjY3Xw4EFJ0pkzZzRkyBD98MMPMpvN6tatm6ZOnWp9wVqSWrRooYceekgDBw40KDUAo/37Z0dsbKzmzZuX5bply5ZZZ7r36dNHISEheuONNwowKQAAAJAzGl6FWGZmpkaNGqVp06bp7NmzNud8fX01ZMgQjR07Nl9eeP13ky0oKEjh4eGGNNmuXLmiY8eO5cuMlRtJT0/X0aNH86VuYmKi1q9fb9PEbNiwYZb9NPKzZlBQkBo1apSvNXNy4cIFbdq0KV+WGCxMNQEAKGj/ftH6Zs6cOaMyZcro0KFDN9y/EEDRltufHRkZGQoKCtKCBQsUFRWVv+EAAACAW8SShoXYc889p7i4OI0bN04xMTE2y2r9/PPPeumll5SWlmbXJQ+NbLLlZMeOHapXr94Nl+XLD9u3b7d73QsXLmjgwIH6/PPPZTKZFBAQIOnqi00Wi0U9e/bUe++9Z9eZO0bUvJl9+/apVatWBfo9ze+axb2JKRW9RuaGDRuyzHxq0qSJ3fdku1nNqKgoNWzYMN9q5iQpKUk//PBDgS8vaFRdoLhatGiRIiMjaXYByJU1a9bIbDbb7AcIAAAAGI0ZXoVYUFCQ5s2bl+MG4kuWLFHv3r11/Phxu9V85plnFBcXp1deeSXHJltsbGyB7iu2detWQxpe+VH30Ucf1cqVK/XOO+8oOjpaTk5Okq6+QzI+Pl6PP/64mjdvrlmzZjl0zZsx4nuaXzVpYv5PUfm+njhxQt26ddPq1atVvnx5m5+Dhw8fVtOmTfXNN99Y97xy1Jo3U5R+9gLFSW5naQCAxM8OAAAAFA00vAoxLy8vrVu3TrVr1872/LZt29SkSROdP3/ebjWNaLLVq1fvhucvXbqkPXv22P3FTyPq+vv7a9GiRWrSpEm251evXq1OnTopKSnJoWtea8DkJCMjQ+fPn7fr19aImhJNzOsVlYbX/fffr6NHj2ru3LmqVq2azbndu3frkUceUUhIiL766iuHrpmSknLD89u2bVOLFi3s/v00qi5QXBw8eFDz58/X0KFDjY4CwIHwswMAAABFAQ2vQqxjx45KT0/XJ598osDAQJtzp06d0sMPPywnJyctXLjQbjWNaLK5u7urR48eqlixYrbnjx07plmzZtn9xU8j6vr6+io+Pl4NGjTI9vzGjRsVHR2dZTlJR6vp5eWlQYMG5fjn6NChQxo7dqxdv7ZG1JSKTxNTKj6NTB8fH61cuVJ169bN9vymTZvUsmVLnTt3zqFrms1mmUymHM9bLBaZTCa7/50xqi4AAAAAAACKNvbwKsRmzpypDh06KDg4WLVr17ZZ4uqPP/5QeHi4XZtdktSyZUsNHz48xybbs88+q5YtW9q1Zq1atdSoUSMNGjQo2/MJCQn5MlPFiLqdOnXSgAEDNHv27CwvbG/ZskWDBg1S586dHb5mZGSkQkND1adPn2zPb926VWPHjnX4mtLVfe9cXV1zPO/q6qrMzEyHrylJqampt9RUdPSabm5uN5yFdO7cObm5uTl8TR8fH7344os57r2xd+9eDRw40K41jawLAAAAAACAoo2GVyEWGhqqrVu3asmSJVq3bp0SExMlSQ0bNtTrr7+uu+++W2az2a41jWiyNW3aVLt3787xvI+Pj5o3b27XmkbVfffdd/XQQw+pfv368vf3t+7Hc+LECSUnJysmJkbvvvuuw9fs2LGjkpOTczwfEBCg3r17O3xNqfg0MaXi08js3r27+vTpo0mTJqlNmzYqUaKEpKtL8cXHx2vYsGHq2bOnw9e8tqxrixYtsj3v5+en/JgEblRdAAAAAAAAFG0saYgsMjMzszTZgoKCFBUVlS9NtuJo165dWrt2bZavb/Xq1YtUzeIgKSlJDz30kJYsWZJjQ/HTTz+Vn5+fQ9eUpNdff11XrlzR6NGjsz1/5MgRjRo1SnPnznXomqmpqRo6dKjmzJmj9PR062y6tLQ0OTs7q1+/fpo0aZJdZ1wZUXPWrFm6dOmSnnjiiWzPHz9+XDNnzszxa+9odQEAAAAAAFC00fByABs2bMjSqGjSpInuvPNOg5MBuGbnzp3ZNonzs6FoRM3iJCUlRZs2bbL5+tavX986+6qo1AQAAAAAAACKAhpehdiJEyfUrVs3rV69WuXLl7dZXvDw4cNq2rSpvvnmG+vsDnsyosmWXc2oqCg1bNgw32oaWTc7SUlJ+uGHH/Jl6T1qFnxNAABQdI0ZM0bz589XQkLCbY0TFxenoUOH3nBpZgAAAADAzdHwKsTuv/9+HT16VHPnzlW1atVszu3evVuPPPKIQkJC9NVXX9mtphFNNqMae0Y2FHOydetW1atXTxkZGdR0oJppaWmaP39+tk3iLl26WJenc/SaRtU16l5zcvz4cb333nsaNWoUNYtQXQDFy8mTJzVq1CgtWrRIx48fl7+/vyIiIjRq1Cg1bdr0lsbIS8MrLCxMQ4cO1dChQ63HLl26pHPnzhXI75z79u3Ta6+9pqVLl+rkyZMKCQlR48aN9fTTT6tBgwb5Xt9RtGzZUpGRkZo8ebLRUQAAAADkApsxFWJLlizRtGnTsjS7JKlatWqaOnWqFi9ebNeajz32mDIyMrRz504dPHhQ69ev1/r163Xw4EHt3LlTmZmZGjx4sMPXNKpuSkrKDT/OnTtn13rUzN+a0tUXjmrUqKE+ffpoy5YtyszMVGZmprZs2aLevXurZs2a2rdvn8PXNKquUfd6I4mJiRo7diw1i1hdAMVLt27dtGXLFs2bN0979uzRggUL1LJlS50+fbrAs3h4eBRIs+v3339X/fr1tWfPHr333nvasWOHvvvuO1WvXl1PP/10vtcHAAAAgPzGDK9CLDAwUN98841atGiR7fnly5fr/vvv16lTp+xW08fHRytXrlTdunWzPb9p0ya1bNnSrs0DI2oaVddsNstkMuV43mKxyGQy2XUWEjXzr6YktW3bVl5eXvrwww+z7LOUkpKi3r1769KlS1qyZIlD1zSqrhE1t23bdsPzu3btUs+ePe36Z6m41DSyLgBck5ycLH9/fy1fvjzH37Ml6fDhw3r88ccVHx8vs9msdu3a6Z133rGuCvDvGV7ZzQrq2rWr/Pz8FBcXp5YtW2rFihU2NSwWS7ZLGs6YMUMTJkzQkSNHVLFiRY0cOVIPP/yw9bzJZNKsWbO0aNEiLVmyRGXLltXbb7+te+65J9t7sVgsql27ttzd3bVhwwaZzbbve0xOTpafn58k6Y8//tCTTz6ptWvXytPTU926ddPEiRPl7e0tSYqNjVVycrIaNmyoKVOmKDU1VcOGDdMLL7yg559/XrNnz5anp6deeeUV9e3bV5J08OBBVaxYUZ999pmmTp2qzZs3q3Llypo2bZrN92DFihUaMWKEtm7dqoCAAPXp00evvvqqnJ2drV/jOnXqyN3dXR988IFcXV313//+V2PGjLG5l+HDh+v7779XamqqGjRooEmTJikiIsLm+/b000/rpZdeUlJSktq3b69Zs2bJx8dHsbGxmjdvns3X58CBAwoLC8v2awsAAACg8HA2OgBy1r17d/Xp00eTJk1SmzZtrC/2pqSkKD4+XsOGDVPPnj3tWtPNzU0pKSk5nj937pzc3NwcvqZRdX18fPTiiy+qUaNG2Z7fu3evBg4cSE0HqSlJq1ev1oYNG7I0YySpRIkSeuWVV3LM5Eg1japrRM3IyEiZTCZl936Qa8dv1FylZuGsCwDXeHt7y9vbW/Pnz1fjxo2z/X0vMzNTXbp0kbe3t1asWKH09HQNHjxY3bt31/Lly/NU99tvv1VERIQGDBig/v3753jdd999pyeffFKTJ09WdHS0Fi5cqL59+6pcuXJq1aqV9bqxY8dq/Pjxeuutt/TOO++oV69eOnTokAICArKMmZCQoO3bt+vTTz/N0uySZG12XbhwQTExMYqKitLGjRt14sQJPfrooxoyZIji4uKs1//6668qV66cVq5cqdWrV6tfv35as2aNmjdvrvXr1+uLL77QwIED1bZtW5UrV876vBEjRmjy5MkKDw/XxIkT1blzZx04cEAlS5bUP//8ow4dOig2NlYffvihdu3apf79+8vd3d2moTVv3jwNGzZM69ev19q1axUbG6umTZuqbdu2kqQHHnhAHh4e+umnn+Tr66v33ntPbdq00Z49e6xfm/3792v+/PlauHChkpKS9OCDD2rcuHF67bXXNGXKFO3Zs0e1atXSyy+/LEkqVarUzb/BAAAAAAxHw6sQmzhxojIzM9WjRw+lp6db96lJS0uTs7Oz+vXrpwkTJti1phFNNiNqGlW3Xr16kpTju4n9/PyyfRGYmoWz5rVxDx48qFq1amV7/uDBg9YXkRy5plF1jagZEBCg8ePHq02bNtme3759uzp37kxNB6sLANc4OzsrLi5O/fv318yZM1WvXj21aNFCPXr0UJ06dSRJ8fHx+uOPP3TgwAGFhoZKkj788EPVrFlTGzdu1J133pnrugEBAXJycpKPj4+CgoJyvG7ChAmKjY3VY489JkkaNmyY1q1bpwkTJtg0vGJjY62/q77++uuaOnWqNmzYoHbt2mUZc+/evZKk6tWr3zDjp59+qsuXL+vDDz+Ul5eXJOndd99V586d9eabb1pntwUEBGjq1Kkym82qVq2axo8fr4sXL+qFF16QJD3//PMaN26cfvvtN/Xo0cM6/pAhQ9StWzdJV2exLV68WLNnz9Yzzzyj6dOnKzQ0VO+++65MJpOqV6+uo0eP6tlnn9WoUaOsjbo6depo9OjRkqQqVaro3XffVXx8vNq2bavffvtNGzZs0IkTJ6yNzAkTJmj+/Pn6+uuvNWDAAElXG5pxcXHy8fGRJD388MOKj4/Xa6+9Jl9fX7m6usrT0/OG3ycAAAAAhQ8Nr0LMzc1NM2bM0JtvvqlNmzYpMTFRkhQUFKT69etnO+PhdhnRZDOiplF1H3roIV28eDHH80FBQdZ/wFOz8NeUpEcffVS9e/fWSy+9pDZt2lhfCDp+/Lji4+P16quv6vHHH3f4mkbVNaJm/fr1dfToUVWoUCHb88nJyXZvnhaXmkbWBYDrdevWTR07dtSqVau0bt06/fTTTxo/frw++OADxcbGaufOnQoNDbU2uyQpPDxcfn5+2rlzZ54aXrdq586d1sbMNU2bNtWUKVNsjl1rzkmSl5eXSpQooRMnTmQ75q3+XN25c6ciIiKsza5rtTMzM7V7927r/4dr1qxpM1OsTJkyNm9OcXJyUsmSJbPkiYqKsn7u7OysBg0aaOfOndbaUVFRNrN8mzZtqvPnz+vvv/9W+fLls9y3JAUHB1vrbN26VefPn1fJkiVtrrl06ZL2799vfRwWFmZtdv17DAAAAACOi4ZXIXfq1CnNmTNHa9eutWl4NWnSRLGxsXZfXsOIJpsRNY2qe6Pla6SrLxbYuylDzfyrKUkvv/yyvLy89NZbb+npp5+2vkhjsVgUFBSkZ599Vs8884zD1zSqrhE1//vf/+rChQs5ni9fvrzmzp1LTQerCwD/5u7urrZt26pt27Z66aWX9Oijj2r06NGKjY3N03hmszlLY+nKlSt2SJo9FxcXm8cmk0mZmZnZXlu1alVJV/dJzGn/2tutnZs89q59rc758+cVHByc7bKT188IL6isAAAAAAoWDa9CbOPGjYqJiZGnp6eio6Ot/1A9fvy4pk6dqnHjxmnJkiVq0KCBXesWdJPNqJpG1aVm0aopSc8++6yeffZZHThwwKZuxYoV86WeUTWNqlvQNe+9994bnvf391efPn2o6WB1AeBmwsPDNX/+fElSjRo1dOTIER05csQ6y2vHjh1KTk5WeHh4ts8vVaqUjh07Zn2ckZGhP//802YZQldXV2VkZNwwR40aNbR69Wqbn4WrV6/Ose6tiIyMVHh4uN5++2117949yz5eycnJ8vPzU40aNRQXF6cLFy5YZ3mtXr3aunTh7Vq3bp2aN28uSUpPT9emTZs0ZMgQSVfv+5tvvrHZy3H16tXy8fGx2QfsRurVq6fExEQ5OzsrLCwszzlv5fsEAAAAoPDJumMxCo3HH39cDzzwgI4cOaK4uDi9+eabevPNNxUXF6fDhw/r/vvvt/tSXhs3blTVqlU1depU+fr6qnnz5mrevLl8fX01depUVa9eXb///rvD1zSqLjWLVs1/q1ixoqKiohQVFWVtxhw5ckSPPPJIkappVF2j7vXfqFk06wIoPk6fPq3WrVvr448/1rZt23TgwAF99dVXGj9+vLp06SJJio6OVu3atdWrVy9t3rxZGzZsUO/evdWiRYsc32zWunVrLVq0SIsWLdKuXbs0aNAgJScn21wTFhamlStX6p9//tGpU6eyHWfEiBGKi4vTjBkztHfvXk2cOFHffvuthg8fnud7NplMmjt3rvbs2aNmzZrpxx9/1F9//aVt27bptddes953r1695O7urj59+ujPP//UsmXL9Pjjj+vhhx+2Lmd4O6ZNm6bvvvtOu3bt0uDBg5WUlGT9mf/YY4/pyJEjevzxx7Vr1y59//33Gj16tIYNG5alQZeT6OhoRUVFqWvXrvr555918OBBrVmzRi+++GKufg8MCwvT+vXrdfDgQZ06dYrZXwAAAICjsKDQcnd3t+zcuTPH8zt37rS4u7vbtWajRo0sAwYMsGRmZmY5l5mZaRkwYIClcePGDl/TqLrULFo1b0VCQoLFbDYX+ZpG1aVm0appZF0Axcfly5ctzz33nKVevXoWX19fi6enp6VatWqWkSNHWi5evGi97tChQ5Z77rnH4uXlZfHx8bE88MADlsTEROv50aNHWyIiIqyP09LSLIMGDbIEBARYSpcubXnjjTcsXbp0sfTp08d6zdq1ay116tSxuLm5Wa79U2zu3LkWX19fm4zTp0+3VKpUyeLi4mKpWrWq5cMPP7Q5L8ny3Xff2Rzz9fW1zJ0794b3vnv3bkvv3r0tISEhFldXV0uFChUsPXv2tGzevNl6zbZt2yytWrWyuLu7WwICAiz9+/e3nDt3znq+T58+li5dutiM26JFC8uTTz5pc6xChQqWSZMmWSwWi+XAgQMWSZZPP/3U0rBhQ4urq6slPDzc8uuvv9o8Z/ny5ZY777zT4urqagkKCrI8++yzlitXrtywzr+/xikpKZbHH3/cEhISYnFxcbGEhoZaevXqZTl8+LDFYsn6fbNYLJZJkyZZKlSoYPN1aty4scXDw8MiyXLgwIGcv6gAAAAACg2TxcLO8IVVxYoVNXbsWPXu3Tvb8x9++KFGjRqlgwcP2q2mh4eHtmzZourVq2d7/tq6/5cuXXLomkbVpWbRqilJCxYsuOH5v/76S08//bRdl8UxoqZRdalZtGoaWRcAYJyDBw+qYsWK2rJliyIjI42OAwAAAKCIYg+vQmz48OEaMGCANm3apDZt2liXETl+/Lji4+M1a9YsTZgwwa41g4KCtGHDhhybBhs2bLDLciZG1zSqLjWLVk1J6tq1q0wmU5ZN6q93bR8KR65pVF1qFq2aRtYFAAAAAABA0UbDqxAbPHiwAgMDNWnSJE2fPt36bncnJyfVr19fcXFxevDBB+1a04gmmxE1japLzaJVU5KCg4M1ffp0694X/5aQkKD69es7fE2j6lKzaNU0si4AAAAAAACKNhpehVz37t3VvXt3XblyxbqxdWBgoFxcXPKlnhFNNiNqGlWXmkWrpiTVr19fmzZtyvHF+5vNZHGUmkbVpWbRqmlkXQCAccLCwvjZDgAAACDfsYcXclRQTTajaxpVl5pFo+aqVat04cIFtWvXLtvzFy5c0O+//64WLVo4dE2j6lKzaNU0si4AAAAAAACKNhpeAAAAAAAAAAAAcGhmowMAAAAAAAAAAAAAt4OGFwAAAAAAAAAAABwaDS8AAAAAAAAAAAA4NBpeAAAAAAAAAAAAcGg0vIBC5uDBgzKZTEpISCiQenFxcfLz8yuQWpLUvHlzffrpp7d0rb2z5WW8uLg4tWzZ8obXhIWFafLkyXnOld+WL1+usLAwo2OoZcuWGjp0qPXxv79uJpNJ8+fPv+XxZs6cqc6dO9svIAAAAAAAAACHRcMLKECxsbEymUzWj5IlS6pdu3batm2b9ZrQ0FAdO3ZMtWrVknS1WWEymZScnJyrOl27dr2la7t37649e/bk5jbybMGCBTp+/Lh69OhRIPUKysaNGzVgwIACr5ub73Nh8O233+qVV16x23iPPPKINm/erFWrVtltTAAAAAAAAACOiYYXUMDatWunY8eO6dixY4qPj5ezs7M6depkPe/k5KSgoCA5Ozvne5YrV67Iw8NDpUuXzvdakjR16lT17dtXZnPR+tFTqlQpeXp6Gh2j0AsICJCPj4/dxnN1ddVDDz2kqVOn2m1MAAAAAAAAAI6paL3qDDgANzc3BQUFKSgoSJGRkXruued05MgRnTx5UpLtkoYHDx5Uq1atJEn+/v4ymUyKjY2VJH399deqXbu2PDw8VLJkSUVHR+vChQsaM2aM5s2bp++//946k2z58uXWcb/44gu1aNFC7u7u+uSTT7Is8zdmzBhFRkbqo48+UlhYmHx9fdWjRw+dO3fOes25c+fUq1cveXl5KTg4WJMmTcqyXN2/nTx5Ur/++muWJeiSk5M1cOBAlSlTRu7u7qpVq5YWLlyY4zgzZszQHXfcIVdXV1WrVk0fffRRnsc7efKkGjRooHvvvVepqak51ryZ7Jbm++CDD3TvvffK09NTVapU0YIFC6znr83aW7RokerUqSN3d3c1btxYf/75p/Waa9+H602ePNm6NGFO3+e8Wrx4se666y75+fmpZMmS6tSpk/bv3289f+3Pz7fffqtWrVrJ09NTERERWrt2rc04q1evVsuWLeXp6Sl/f3/FxMQoKSlJUtYlDW/m2WefVdWqVeXp6alKlSrppZde0pUrV2yu6dy5sxYsWKBLly7l+d4BAAAAAAAAOD4aXoCBzp8/r48//liVK1dWyZIls5wPDQ3VN998I0navXu3jh07pilTpujYsWPq2bOnHnnkEe3cuVPLly/XfffdJ4vFouHDh+vBBx+0mUnWpEkT65jPPfecnnzySe3cuVMxMTHZ5tq/f7/mz5+vhQsXauHChVqxYoXGjRtnPT9s2DCtXr1aCxYs0NKlS7Vq1Spt3rz5hvf622+/ydPTUzVq1LAey8zMVPv27bV69Wp9/PHH2rFjh8aNGycnJ6dsx/juu+/05JNP6umnn9aff/6pgQMHqm/fvlq2bFmuxzty5IiaNWumWrVq6euvv5abm9sN8+fW2LFj9eCDD2rbtm3q0KGDevXqpTNnzthcM2LECL399tvauHGjSpUqpc6dO2dp6OTkZt/n3Lpw4YKGDRum33//XfHx8TKbzbr33nuVmZlpc92LL76o4cOHKyEhQVWrVlXPnj2Vnp4uSUpISFCbNm0UHh6utWvX6rffflPnzp2VkZGRp0w+Pj6Ki4vTjh07NGXKFM2aNUuTJk2yuaZBgwZKT0/X+vXr83bjAAAAAAAAAIqE/F8zDYCNhQsXytvbW9LVJkNwcLAWLlyY7TJ/Tk5OCggIkCSVLl3aOhNr//79Sk9P13333acKFSpIkmrXrm19noeHh1JTUxUUFJRlzKFDh+q+++67YcbMzEzFxcVZl597+OGHFR8fr9dee03nzp3TvHnz9Omnn6pNmzaSpLlz5yokJOSGYx46dEhlypSxuc9ffvlFGzZs0M6dO1W1alVJUqVKlXIcY8KECYqNjdVjjz0m6Wrjbd26dZowYYJatWp1y+Pt3r1bbdu21b333qvJkyfLZDLdMHtexMbGqmfPnpKk119/XVOnTtWGDRvUrl076zWjR49W27ZtJUnz5s1TuXLl9N133+nBBx+86fje3t43/D7nVrdu3Wwez5kzR6VKldKOHTus+8lJVxttHTt2lHS1qVezZk3t27dP1atX1/jx49WgQQNNnz7den3NmjXznGnkyJHWz8PCwjR8+HB9/vnneuaZZ6zHPT095evrq0OHDuW5DgAAAAAAAADHxwwvoIC1atVKCQkJSkhI0IYNGxQTE6P27dvn6gX7iIgItWnTRrVr19YDDzygWbNmWZeNu5kGDRrc9JqwsDCbvZaCg4N14sQJSdJff/2lK1euqGHDhtbzvr6+qlat2g3HvHTpktzd3W2OJSQkqFy5ctbm1M3s3LlTTZs2tTnWtGlT7dy585bHu3Tpkpo1a6b77rtPU6ZMyZdmlyTVqVPH+rmXl5dKlChh/RpeExUVZf08ICBA1apVs95LQdu7d6969uypSpUqqUSJEtalEw8fPmxz3fX3FRwcLEnW+7o2w8tevvjiCzVt2lRBQUHy9vbWyJEjs+SRrjZ4L168aLe6AAAAAAAAABwPDS+ggHl5ealy5cqqXLmy7rzzTn3wwQe6cOGCZs2adctjODk5aenSpfrpp58UHh6ud955R9WqVdOBAwduqf7NuLi42Dw2mUxZlrbLrcDAwCxNOQ8Pj9sa899uZTw3NzdFR0dr4cKF+ueff+xa/3q3+zU0m82yWCw2x251ucO86Ny5s86cOaNZs2Zp/fr11iUC09LSbK67/r6uNQuv3Zc9v59r165Vr1691KFDBy1cuFBbtmzRiy++mCWPJJ05c0alSpWyW20AAAAAAAAAjoeGF2Awk8kks9msS5cuZXve1dVVkrLsg2QymdS0aVONHTtWW7Zskaurq7777jvrc/K6b9LNVKpUSS4uLtq4caP12NmzZ7Vnz54bPq9u3bpKTEy0aXrVqVNHf//9902fe02NGjW0evVqm2OrV69WeHj4LY9nNpv10UcfqX79+mrVqpWOHj16S7Xzw7p166yfJyUlac+ePdY9zkqVKqXExESbpldCQoLN8+31fT59+rR2796tkSNHqk2bNqpRo8Ytzxi8Xp06dRQfH3/beSRpzZo1qlChgl588UU1aNBAVapUyXYW5P79+3X58mXVrVvXLnUBAAAAAAAAOCYaXkABS01NVWJiohITE7Vz5049/vjjOn/+vDp37pzt9RUqVJDJZNLChQt18uRJnT9/XuvXr9frr7+u33//XYcPH9a3336rkydPWpslYWFh2rZtm3bv3q1Tp07ZdWaQj4+P+vTpoxEjRmjZsmXavn27+vXrJ7PZfMPlAevWravAwECbhlWLFi3UvHlzdevWTUuXLtWBAwf0008/afHixdmOMWLECMXFxWnGjBnau3evJk6cqG+//VbDhw/P1XhOTk765JNPFBERodatWysxMdEOX5nce/nllxUfH68///xTsbGxCgwMVNeuXSVJLVu21MmTJzV+/Hjt379f06ZN008//WTzfHt9n/39/VWyZEm9//772rdvn3799VcNGzYs1+M8//zz2rhxox577DFt27ZNu3bt0owZM3Tq1Klcj1WlShUdPnxYn3/+ufbv36+pU6daG7rXW7VqlSpVqqQ77rgj1zUAAAAAAAAAFB00vIACtnjxYgUHBys4OFiNGjXSxo0b9dVXX6lly5bZXl+2bFmNHTtWzz33nMqUKaMhQ4aoRIkSWrlypTp06KCqVatq5MiRevvtt9W+fXtJUv/+/VWtWjU1aNBApUqVyjIr6nZNnDhRUVFR6tSpk6Kjo9W0aVPVqFEjyx5d13NyclLfvn31ySef2Bz/5ptvdOedd6pnz54KDw/XM888k+Ospa5du2rKlCmaMGGCatasqffee09z5861+drd6njOzs767LPPVLNmTbVu3TrL/loFYdy4cXryySdVv359JSYm6ocffrDO6KtRo4amT5+uadOmKSIiQhs2bLA29q6x1/fZbDbr888/16ZNm1SrVi099dRTeuutt3I9TtWqVfXzzz9r69atatiwoaKiovT999/L2dk512Pdc889euqppzRkyBBFRkZqzZo1eumll7Jc99lnn6l///65Hh8AAAAAAABA0WKy/HuTGADIpQsXLqhs2bJ6++231a9fvxyvS0xMVM2aNbV582ZVqFChABPmXVxcnOLi4rR8+XK7jbl8+XK1atVKSUlJ8vPzs9u4N6oXGxurgwcP5nutgrR9+3a1bt1ae/bska+vr9FxAAAAAAAAABiIGV4Acm3Lli367LPPtH//fm3evFm9evWSJHXp0uWGzwsKCtLs2bN1+PDhgoiJIu7YsWP68MMPaXYBAAAAAAAAUO7XmQIASRMmTNDu3bvl6uqq+vXra9WqVQoMDLzp867tUQXcrujoaKMjAAAAAAAAACgkWNIQAG4gISFBCQkJio2NNTpKnh08eFDz58/X0KFDjY4CAAAAAAAAAPmChhcAAAAAAAAAAAAcGnt4AQAAAAAAAAAAwKHR8AIAAAAAAAAAAIBDo+EFAAAAAAAAAAAAh0bDCwAAAAAAAAAAAA6NhhcAAAAAAAAAAAAcGg0vAAAAAAAAAAAAODQaXgAAAAAAAAAAAHBoNLwAAAAAAAAAAADg0P4PGlRAPZuFM2UAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -455,16 +502,50 @@ "output_type": "stream", "text": [ "Condition Number Analysis\n", - "============================================================\n", - "κ = 1: Fidelity = 0.9999, Success Prob = 0.8049\n", - "κ = 2: Fidelity = 0.5256, Success Prob = 0.4306\n", - "κ = 3: Fidelity = 0.2032, Success Prob = 0.3694\n", - "κ = 4: Fidelity = 0.1002, Success Prob = 0.2024\n" + "============================================================\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "κ = 1: Fidelity = 0.9999, Success Prob = 0.5346\n", + "κ = 2: Fidelity = 0.9012, Success Prob = 0.4814\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n", + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "κ = 3: Fidelity = 0.8049, Success Prob = 0.4716\n", + "κ = 4: Fidelity = 0.7210, Success Prob = 0.1649\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -519,45 +600,6 @@ "plt.show()" ] }, - { - "cell_type": "markdown", - "id": "339d0d20-7afd-4210-8630-38b3b561dea7", - "metadata": {}, - "source": [ - "## Understanding the Circuit Components\n", - "\n", - "Let's walk through each component of the HHL circuit in more detail.\n", - "\n", - "### 1. State Preparation\n", - "\n", - "The vector $\\vec{b}$ is encoded as a quantum state $|b\\rangle$ on the input qubit. For a 2-element vector $\\vec{b} = (b_0, b_1)^T$, this is done using an $R_y$ rotation:\n", - "\n", - "$$|b\\rangle = \\cos(\\theta/2)|0\\rangle + \\sin(\\theta/2)|1\\rangle$$\n", - "\n", - "where $\\theta = 2\\arccos(b_0)$ for real vectors.\n", - "\n", - "### 2. Quantum Phase Estimation (QPE)\n", - "\n", - "QPE decomposes $|b\\rangle$ in the eigenbasis of $A$ and estimates eigenvalues. It uses:\n", - "- Hadamard gates on clock qubits to create superposition\n", - "- Controlled $U^{2^k} = e^{iAt \\cdot 2^k}$ operations (Hamiltonian simulation)\n", - "- Inverse QFT on the clock register\n", - "\n", - "After QPE, the state is approximately:\n", - "$$\\sum_j \\beta_j |u_j\\rangle|\\tilde{\\lambda}_j\\rangle$$\n", - "\n", - "### 3. Controlled Rotation\n", - "\n", - "For each eigenvalue $\\lambda_j$ stored in the clock register, we perform a controlled $R_y$ rotation on the ancilla qubit with angle $\\theta_j = 2\\arcsin(C/\\lambda_j)$:\n", - "\n", - "$$|\\tilde{\\lambda}_j\\rangle|0\\rangle_a \\rightarrow |\\tilde{\\lambda}_j\\rangle\\left(\\sqrt{1 - \\frac{C^2}{\\lambda_j^2}}|0\\rangle_a + \\frac{C}{\\lambda_j}|1\\rangle_a\\right)$$\n", - "\n", - "### 4. Inverse QPE\n", - "\n", - "The inverse QPE uncomputes the clock register, returning it to $|0\\rangle^{\\otimes n}$.\n", - "After post-selecting on the ancilla measuring $|1\\rangle$, the input qubit is in the state $|x\\rangle \\propto A^{-1}|b\\rangle$." - ] - }, { "cell_type": "markdown", "id": "063cca65-3ba7-4d48-a887-293eae9d2613", @@ -574,9 +616,19 @@ "id": "40d94b2a-036a-4ae1-bb84-0fd375d9b6eb", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n", + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n", + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n", + "This program uses OpenQASM language features that may not be supported on QPUs or on-demand simulators.\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -740,6 +792,24 @@ "source": [ "Note: Charges shown are estimates based on your Amazon Braket simulator and quantum processing unit (QPU) task usage. Estimated charges shown may differ from your actual charges. Estimated charges do not factor in any discounts or credits, and you may experience additional charges based on your use of other services such as Amazon Elastic Compute Cloud (Amazon EC2)." ] + }, + { + "cell_type": "markdown", + "id": "819903ab-f718-46fb-b315-ce39d68ade09", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "[[1] A. W. Harrow, A. Hassidim, S. Lloyd, \"Quantum algorithm for linear systems of equations\", Phys. Rev. Lett. 103, 150502 (2009)](https://arxiv.org/abs/0811.3171)\n", + "\n", + "[[2] Wikipedia: HHL Algorithm](https://en.wikipedia.org/wiki/HHL_algorithm)\n", + "\n", + "[[3] S. Barz et al., \"A two-qubit photonic quantum processor and its application to solving systems of linear equations\", Scientific Reports 4, 6115 (2014)](https://arxiv.org/abs/1302.1210)\n", + "\n", + "[[4] X.-D. Cai et al., \"Experimental Quantum Computing to Solve Systems of Linear Equations\", Phys. Rev. Lett. 110, 230501 (2013)](https://arxiv.org/abs/1302.4310)\n", + "\n", + "[[5] J. Pan et al., \"Experimental realization of quantum algorithm for solving linear systems of equations\", Phys. Rev. A 89, 022313 (2014)](https://arxiv.org/abs/1302.1946)" + ] } ], "metadata": { @@ -768,4 +838,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/src/braket/experimental/algorithms/hhl/__init__.py b/src/braket/experimental/algorithms/hhl/__init__.py index 1012284c..ff2f6bbf 100644 --- a/src/braket/experimental/algorithms/hhl/__init__.py +++ b/src/braket/experimental/algorithms/hhl/__init__.py @@ -1,16 +1,3 @@ -# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"). You -# may not use this file except in compliance with the License. A copy of -# the License is located at -# -# http://aws.amazon.com/apache2.0/ -# -# or in the "license" file accompanying this file. This file is -# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF -# ANY KIND, either express or implied. See the License for the specific -# language governing permissions and limitations under the License. - from braket.experimental.algorithms.hhl.hhl import ( # noqa: F401,E501 get_hhl_results, hhl_circuit, diff --git a/src/braket/experimental/algorithms/hhl/hhl.md b/src/braket/experimental/algorithms/hhl/hhl.md index c28f4781..ea0ba2c3 100644 --- a/src/braket/experimental/algorithms/hhl/hhl.md +++ b/src/braket/experimental/algorithms/hhl/hhl.md @@ -1,4 +1,4 @@ -The Harrow-Hassidim-Lloyd (HHL) algorithm is a quantum algorithm for solving systems of linear equations of the form Ax = b. Given an N×N Hermitian matrix A and a unit vector b, the algorithm produces a quantum state |x⟩ whose amplitudes encode the solution vector x = A⁻¹b. The HHL algorithm is one of the fundamental quantum algorithms expected to provide an exponential speedup over classical methods: for sparse, well-conditioned matrices, HHL runs in O(log(N) κ²) time versus O(Nκ) classically, where κ is the condition number of A. Applications include machine learning, computational finance, solving differential equations, and quantum chemistry. +The Harrow-Hassidim-Lloyd (HHL) algorithm is a quantum algorithm for solving systems of linear equations of the form Ax = b. Given an N×N Hermitian matrix A and a unit vector b, the algorithm produces a quantum state |x⟩ whose amplitudes encode the solution vector x = A⁻¹b. For sparse, well-conditioned matrices, HHL runs in O(log(N) κ²) time versus O(Nκ) classically, where κ is the condition number of A. However, the overall speedup depends on the efficiency of state preparation and readout, which can be problem-dependent. Applications include machine learning, computational finance, solving differential equations, and quantum chemistry.