diff --git a/.internal/pre_commit_tools/notebook_pre_commit_collection.py b/.internal/pre_commit_tools/notebook_pre_commit_collection.py index d074e25a5..bd7918387 100755 --- a/.internal/pre_commit_tools/notebook_pre_commit_collection.py +++ b/.internal/pre_commit_tools/notebook_pre_commit_collection.py @@ -84,7 +84,9 @@ def _add_file_to_timeouts(file_name: str) -> None: def validate_unique_names() -> bool: all_files = PROJECT_ROOT.rglob("*.ipynb") base_names = [ - file.name for file in all_files if ".ipynb_checkpoints" not in file.parts + file.name + for file in all_files + if ".ipynb_checkpoints" not in file.parts and ".git" not in file.parts ] duplicate_names = [name for name, count in Counter(base_names).items() if count > 1] diff --git a/applications/optimization/kidney_exchange/kidney_exchange_problem.ipynb b/applications/optimization/kidney_exchange/kidney_exchange_problem.ipynb new file mode 100644 index 000000000..34ac70823 --- /dev/null +++ b/applications/optimization/kidney_exchange/kidney_exchange_problem.ipynb @@ -0,0 +1,737 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Kidney Exchange QAOA Example\n", + "\n", + "Author: Bill Wisotsky \n", + "\n", + "---\n", + "\n", + "What is the Problem? \n", + "Currently there are more than 100,000 patients on the waitling list in the United States for a kidney transplant from a deceased donor. This is addressed by the a program called the Kidney Exchange Program. This program won the Nobel Prize in Economics for Alvin E. Roth and Lloyd S. Shapley's contributions to the theory of stable matchings and the design of markets on 2012.\n", + "In summary, in a donor pair there is a recipient who needs a kidney transplant and a donor who is willing to give their kidney to the recipient. About $\\frac{1}{3}$ of those pairs are not compatible for a direct exchange. This is tackled by considering two incompatible pairs together: donor 1 may be compatible with recpient 2 and donor 2 may be compatible with recpient 1. In this example a two-way swap becomes feasible. This is the core of the kideny exchange program. \n", + "\n", + "This is consdered an NP-Hard combinatorial optimization problem that becomes exponetially more difficult as the size of the pool increases. The longest chain in history involved 35 tranplants in the United States in 2015." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.173790Z", + "start_time": "2025-06-18T12:16:11.167811Z" + } + }, + "outputs": [], + "source": [ + "import warnings\n", + "from itertools import product\n", + "from typing import List, Tuple, cast # noqa\n", + "\n", + "import networkx as nx # noqa\n", + "import numpy as np\n", + "\n", + "from classiq import *\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create the pyomo model for a simple kidney exhange problem \n", + "\n", + "In this very simple example, patients and donors represent sets of patients that receive a kidney from a donor. Compatibility is a dictionary mapping of patient-donor paris to their compatibilty scores. Binary decision variables are defined for each patient-donor pair x[donor,patient]. The objective is to maximize the total compatibility score. $ Maximize \\sum_{d,p\\in A}^{} \\sum_{m\\in M}c_{dp}x_{dpm}$ where d=donors, p=patients and c=compatability score. The contraints are added to ensure that each donor donates only once $\\sum_{d,p\\in A}^{}x_{dpm} = y_{dm}$ and each patient receives once $\\sum_{d,p\\in A}^{}x_{dpm} = y_{pm}$. We are creating a PYOMO model that gets fed into Classiq, as illustrated in Classiq documentation. We also solve initially with a classical solver to get inital results which can be compared to the QAOA results in the end." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.231412Z", + "start_time": "2025-06-18T12:16:11.182325Z" + }, + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m\u001b[4mOptimal solution:\u001b[0m\n", + "\n", + "\u001b[1m\u001b[4mModel Details\u001b[0m\n", + "5 Set Declarations\n", + " donor_constraint_index : Size=1, Index=None, Ordered=Insertion\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 1 : Any : 3 : {1, 2, 3}\n", + " patient_constraint_index : Size=1, Index=None, Ordered=Insertion\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 1 : Any : 3 : {1, 2, 3}\n", + " x_index : Size=1, Index=None, Ordered=True\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 2 : x_index_0*x_index_1 : 9 : {('donor1', 'patient1'), ('donor1', 'patient2'), ('donor1', 'patient3'), ('donor2', 'patient1'), ('donor2', 'patient2'), ('donor2', 'patient3'), ('donor3', 'patient1'), ('donor3', 'patient2'), ('donor3', 'patient3')}\n", + " x_index_0 : Size=1, Index=None, Ordered=Insertion\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 1 : Any : 3 : {'donor1', 'donor2', 'donor3'}\n", + " x_index_1 : Size=1, Index=None, Ordered=Insertion\n", + " Key : Dimen : Domain : Size : Members\n", + " None : 1 : Any : 3 : {'patient1', 'patient2', 'patient3'}\n", + "\n", + "1 Var Declarations\n", + " x : Size=9, Index=x_index\n", + " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", + " ('donor1', 'patient1') : 0 : None : 1 : False : True : Binary\n", + " ('donor1', 'patient2') : 0 : None : 1 : False : True : Binary\n", + " ('donor1', 'patient3') : 0 : None : 1 : False : True : Binary\n", + " ('donor2', 'patient1') : 0 : None : 1 : False : True : Binary\n", + " ('donor2', 'patient2') : 0 : None : 1 : False : True : Binary\n", + " ('donor2', 'patient3') : 0 : None : 1 : False : True : Binary\n", + " ('donor3', 'patient1') : 0 : None : 1 : False : True : Binary\n", + " ('donor3', 'patient2') : 0 : None : 1 : False : True : Binary\n", + " ('donor3', 'patient3') : 0 : None : 1 : False : True : Binary\n", + "\n", + "1 Objective Declarations\n", + " obj : Size=1, Index=None, Active=True\n", + " Key : Active : Sense : Expression\n", + " None : True : maximize : 0.9*x[donor1,patient1] + 0.7*x[donor1,patient2] + 0.6*x[donor1,patient3] + 0.8*x[donor2,patient1] + 0.75*x[donor2,patient2] + 0.65*x[donor2,patient3] + 0.85*x[donor3,patient1] + 0.8*x[donor3,patient2] + 0.7*x[donor3,patient3]\n", + "\n", + "2 Constraint Declarations\n", + " donor_constraint : Size=3, Index=donor_constraint_index, Active=True\n", + " Key : Lower : Body : Upper : Active\n", + " 1 : -Inf : x[donor1,patient1] + x[donor1,patient2] + x[donor1,patient3] : 1.0 : True\n", + " 2 : -Inf : x[donor2,patient1] + x[donor2,patient2] + x[donor2,patient3] : 1.0 : True\n", + " 3 : -Inf : x[donor3,patient1] + x[donor3,patient2] + x[donor3,patient3] : 1.0 : True\n", + " patient_constraint : Size=3, Index=patient_constraint_index, Active=True\n", + " Key : Lower : Body : Upper : Active\n", + " 1 : -Inf : x[donor1,patient1] + x[donor2,patient1] + x[donor3,patient1] : 1.0 : True\n", + " 2 : -Inf : x[donor1,patient2] + x[donor2,patient2] + x[donor3,patient2] : 1.0 : True\n", + " 3 : -Inf : x[donor1,patient3] + x[donor2,patient3] + x[donor3,patient3] : 1.0 : True\n", + "\n", + "9 Declarations: x_index_0 x_index_1 x_index x obj donor_constraint_index donor_constraint patient_constraint_index patient_constraint\n" + ] + } + ], + "source": [ + "from pyomo.environ import *\n", + "\n", + "# Sample data: patient-donor pairs and compatibility scores\n", + "donors = [\"donor1\", \"donor2\", \"donor3\"]\n", + "patients = [\"patient1\", \"patient2\", \"patient3\"]\n", + "N = len(patients)\n", + "M = len(donors)\n", + "# Parameters\n", + "compatibility_scores = {\n", + " (\"donor1\", \"patient1\"): 0.9,\n", + " (\"donor1\", \"patient2\"): 0.7,\n", + " (\"donor1\", \"patient3\"): 0.6,\n", + " (\"donor2\", \"patient1\"): 0.8,\n", + " (\"donor2\", \"patient2\"): 0.75,\n", + " (\"donor2\", \"patient3\"): 0.65,\n", + " (\"donor3\", \"patient1\"): 0.85,\n", + " (\"donor3\", \"patient2\"): 0.8,\n", + " (\"donor3\", \"patient3\"): 0.7,\n", + "}\n", + "\n", + "# Create Pyomo model\n", + "model = ConcreteModel()\n", + "\n", + "# Variables\n", + "model.x = Var(donors, patients, within=Binary)\n", + "\n", + "# Objective\n", + "model.obj = Objective(\n", + " expr=sum(\n", + " compatibility_scores[donor, patient] * model.x[donor, patient]\n", + " for donor in donors\n", + " for patient in patients\n", + " ),\n", + " sense=maximize,\n", + ")\n", + "\n", + "# Constraints\n", + "model.donor_constraint = ConstraintList()\n", + "for donor in donors:\n", + " model.donor_constraint.add(\n", + " sum(model.x[donor, patient] for patient in patients) <= 1\n", + " )\n", + "\n", + "model.patient_constraint = ConstraintList()\n", + "for patient in patients:\n", + " model.patient_constraint.add(sum(model.x[donor, patient] for donor in donors) <= 1)\n", + "\n", + "# Install \"glpk\" and unommente for runing this part\n", + "# Solve\n", + "# solver = SolverFactory(\"glpk\")\n", + "# solver.solve(model)\n", + "\n", + "# Output\n", + "print(\"\\033[1m\\033[4mOptimal solution:\\033[0m\")\n", + "for donor in donors:\n", + " for patient in patients:\n", + " if model.x[donor, patient].value == 1:\n", + " print(f\"{donor} donates kidney to {patient}\")\n", + "\n", + "print(\"\\n\\033[1m\\033[4mModel Details\\033[0m\")\n", + "model.pprint()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Start Generatng the QAOA Process\n", + " \n", + "### Create the inital parameters for the quantum circuit. These can me modified as needed.\n", + "1. Defining the number of layers (num_layers) of the QAOA Ansatz. \n", + "2. Define the penalty_energy for invalid solutions, which influences the convergence rate. Smaller positive values are preferred, but shoudl be tweaked. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.236055Z", + "start_time": "2025-06-18T11:56:57.027157Z" + } + }, + "outputs": [], + "source": [ + "from classiq import (\n", + " Preferences,\n", + " construct_combinatorial_optimization_model,\n", + " set_preferences,\n", + ")\n", + "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", + "\n", + "qaoa_config = QAOAConfig(num_layers=5, penalty_energy=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create the classical optimizer part of the QAOA. These parameters can be modified.\n", + "1. opt_type is the classical optimizer type. Choices include, COBYLA, SPSA, ADAM, L_BFGS_B, and NELDER_MEAD\n", + "2. The max_iterations is the maximum number of optimzer iterations and is set to 100. \n", + "3. The alpha_cvar is a parameter that describes the quantile considered in the CVAR expectation value. See https://arxiv.org/abs/1907.04769 for more information." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.236298Z", + "start_time": "2025-06-18T11:56:57.033873Z" + } + }, + "outputs": [], + "source": [ + "optimizer_config = OptimizerConfig(\n", + " # opt_type='COBYLA',\n", + " max_iteration=200,\n", + " alpha_cvar=1,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Combine everthing together to form the entire QAOA model as a QMOD.\n", + "1. PYOMO Model \n", + "2. QAOA quantum circuit \n", + "3. Clasical optimizer " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.236524Z", + "start_time": "2025-06-18T11:56:57.051678Z" + } + }, + "outputs": [], + "source": [ + "qmod = construct_combinatorial_optimization_model(\n", + " pyo_model=model,\n", + " qaoa_config=qaoa_config,\n", + " optimizer_config=optimizer_config,\n", + ")\n", + "\n", + "# defining cosntraint such as computer and parameters for a quicker and more optimized circuit.\n", + "preferences = Preferences(transpilation_option=\"none\", timeout_seconds=300)\n", + "\n", + "qmod = set_preferences(qmod, preferences)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Wite out the QMOD and preferences to a JSON file \n", + "2. Synthesize the model in Classiq interface \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.236719Z", + "start_time": "2025-06-18T11:56:57.104384Z" + } + }, + "outputs": [], + "source": [ + "write_qmod(qmod, \"kidney_exchange_problem\") # optional" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Sythesize the quantum model\n", + "2. Show the quantm model in the Classiq platform" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.237069Z", + "start_time": "2025-06-18T11:56:57.121952Z" + } + }, + "outputs": [], + "source": [ + "qmod = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", + "qprog = synthesize(qmod)\n", + "# show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Execute the quantum model and store the result." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.237242Z", + "start_time": "2025-06-18T11:57:03.218746Z" + } + }, + "outputs": [], + "source": [ + "from classiq import execute\n", + "\n", + "res = execute(qprog).result()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "View the convergence graph \n", + "Important to remember that this is a maximization problem when looking at the graph" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.237389Z", + "start_time": "2025-06-18T11:57:22.960612Z" + } + }, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAIAAAC6s0uzAADwbklEQVR4AeydB4BcV3X+3/Tdme1Nvdtyb7hhgzHG2BRjML05DiUQQq9xEgiEHkIPBIc/DqH33osDNu42uAnLtmRbsvpqe50+8/+de2bezq5W0u5qpZ3VnqvR2/tuOffe783c751zW6BYLHrmDAFDwBAwBAwBQ+DIIhA8ssVZaYaAIWAIGAKGgCEgCBgB2/fAEDAEDAFDwBCYAwSMgOcAdCvSEDAEDAFDwBAwArbvgCFgCBgChoAhMAcIGAHPAehWpCFgCBgChoAhYARs3wFDwBAwBAwBQ2AOEDACngPQrUhDwBAwBAwBQ8AI2L4DhoAhYAgYAobAHCBgBDwHoFuRhoAhYAgYAoaAEbB9BwwBQ8AQMAQMgTlAwAh4DkC3Ig0BQ8AQMAQMASNg+w4YAoaAIWAIGAJzgIAR8ByAbkUaAoaAIWAIGAJGwPYdMAQMAUPAEDAE5gABI+A5AN2KNAQMAUPAEDAEjIDtO2AIGAKGgCFgCMwBAkbAcwC6FWkIGAKGgCFgCBgB23fAEDAEDAFDwBCYAwSMgOcAdCvSEDAEDAFDwBAwArbvgCFgCBgChoAhMAcIGAHPAehWpCFgCBgChoAhYARs3wFDwBAwBAwBQ2AOEDACngPQrUhDwBAwBAwBQ8AI2L4DhoAhYAgYAobAHCBgBDwHoFuRhoAhYAgYAoaAEbB9BwwBQ8AQMAQMgTlAwAh4DkC3Ig0BQ8AQMAQMASNg+w4YAoaAIWAIGAJzgIAR8ByAbkUaAoaAIWAIGAJGwPYdMAQMAUPAEDAE5gABI+A5AN2KNAQMAUPAEDAEjIDtO3BUIZB3jibxl2sul+NaKBTUMzo6qq1Np9Pq0WTFYjGVSmWzWQ3UK7eaS9MQqLd4fDn4fVGai+vw8DAl4kECDg/CNVZv1U/GkZER9VMBPIRQFmn0VqP2vWpz/DSkz2QyJCO8UmAymfQrTGKtsx+iYrWe+P1wv4ZEadO08jTKrwkhPia+h1jFUEMoUbNXJtCCCPdL0Vy+ZDy0hSzURxtINXCawBflV8b3+GiQ2Pf76Svlm98QqB4EAv6XtXrqZDUxBGaMAB13OBwmO51vKBSaIAdOooMmvKamhijoKpFIEBIMlt5EYSliI5GIJgsEAiqKn4mKRQKBZIdsNCUJ8CNBu/7a2lotlCyanVstgrpRq1gsBgNRhBaKnxDNUnklJRJUCAUNDQ2RLBqN+jKJolwtDg+3+ClI+ZvEfuXJrhWgdfF4nCYgh0AtjloRy5UoDUEUHs3uV0+xGhgYaGxsJJYsXEmJHMRSKC1SCeqHGuvq6kjT399PFqSR2K884TSQNGQhI7e7d+9etGgRmFQmo1ZEqVP8aSnga3MIJwHhflmaXkvxG1gWYH8NgapDwAi46h6JVehQEIBd6KDpgpUGEEWXTR9N10zgpFRH9w11kZ6MZPcZVKsBT+DICzfo1e/uCddeHg+JK3t86ArqamlpGRwcbGho0Gogv5JdVH5PT09raytqHzWEjUgPIVUSpCbzr7AdNUGUhlBh0is5+WnUI/V2jhb51VAeJQEeKgNHKqX5WQik5rTFL0JpWxMo4elVhfAGQyGk56oY9vX1NTc3a3qfv7mFNXGKAOkBU9OQEb863jPq6+sJdxXPg4Om4YpwGq4gI4c6EMithpCeQOVyzQKkpJ8UGV+meQyBuUXACHhu8bfSDwsCPs9VkgclEb5z587ly5fjr+zr6cQreQg9j44btiYcYtAq0r/Ty9PFIwT2grpUOIHKASSDb7itVCU1O/xHGriKNCQgO6wMQ1AKJOHLVxLSW+qjjEJGspAM51eGNDAQDprs7e2F6Qnp7u5uampCJuFcK9uurdNXDb+2Gkg14DmInMpTK0rRCnDV1xF94SAxDdc3FYT7NaFuyrt+LkIogsSEawORTBF+FqJoGukJoTj/pYdw6gxKPoWTDEe4nxhRKlNboVG0F1H49ZbEiCWZXyXzGALVicDYj60662e1MgSmhQB0AlXQHXP9xje+gVUTv++ggTPPPPNnP/sZMlXTwkMsVzp6rnTlXDGZQgNKM4QQhVjoBPbVvh7awwPR0uMrQZKLEuFsAmEU0hOikvfu3QuxIZAE5CI9t8hU2iMZfKPqHQm0GgRSBI4S4RKuWgrcRhQO+YSQAD/11OLa2tqUdbRcEhCLBRixmpKXBgJ5vdizZw9RBFIfqkEIzAp5K/tCcjSBphFIlFqSaRq3WjTyiYUstfkqhyZQDcqiCArlFskIpAjykoXKk4Bb/KTBaXF4EEvDkaY1pyDqQCAJCKH5OJrGLVEaSKw6cmksV0rEkUVxUCHlhPbXEKg6BOwlseoeiVXoUBCg/9XseOh/0TX/8R//8ayzzqKbhhvouyGAJz/5yZABPT5dNjxBf024qq2kISXcTDixcAzSiEKaUiMUQgJ19PIUAf0ohSgLcqtERUZlPohNq0QUGTWQEglUnRiDLfWkODJSPepGLI4Ska90UsmsZESOMhx+6By/iqXCpNcKkAVRWjqioHls3aTn9QKneielaAjlkp4mkJJ6EohMSiEl/s7OTl5lKIKWUmc1HviIIcSHncQkg7ORhgftmdZp3ciLIwFl4bRdRCkIlEsWZFIHrQAp1RFCEbSFxNSHlGClUQjRR4AZADmEk6ycz4P4fb95DIEqRMAIuAofilXpkBCgv4YPIA+kcH3xi1/8uMc9Dr+Og/rMSl9Ph06XDStoIF25antI0OykUQ+EQSC3OBIr32zfvn3FihVIJgSdr729HT9UqoxCRiUSlUAUJmKUVAKRBosQgpyHH374mGOOIQuV4VZZk1hqhR9HMnX4yQjFksynFrUPk17L4gpXdXV1kQau0hLJTqCaqfGryZrmqDYJE1MWmi71Jxf1L5Xnqocf4bAvHmJpiz+cTIjairVKSKBEWqE18c3ICIcmSUzlcQDumlVqFw1XgQRu3bp19erVPAUtiBoqCFzJTgJttbIvLwGI5XlpcX7raCmJEcLVRwm/OUOgChGQL6s5Q+DoQ4CO2O+aYUcaqDSgHTQ8+uCDD8JA11xzzX/8x3/A0HTWZ5xxxl/+8hdSkgYOwHPzzTe//OUvp3Mn9tnPfva3v/1tenYIAE76yle+csIJJ/zqV796zWtes27dOvKqXfe///u/16xZA1tcfPHFv/71r5/whCc84xnPUIY+99xzr7rqKsTCKAihCLKcdtppH/rQh9DbqK3WDb9yzK5duz71qU+hvpOeCpCX+sBYZGTq1kc+8pG1a9cuXryY4t7znvdAnDAWEvBceOGFr3zlK//whz9ceumlJF6/fv3XvvY1mg//3XXXXejBX/3qVyFL0lMZEtx44428BGCx5xb5f/3rX9/4xjd2dHQQdeyxx379618nHEJF+A033EDG73znO+9617t4+WA0Hdakbn/84x9POukk8DzvvPNA5vWvf/2pp56qryBqkKe2T3nKU0gAl7/zne+8//77kamOjJdddhmSr7zySmwPjBF86UtforY4YCTN5s2byUIzCaHy1O2xxx4jJezLGwZtp5JE8RT++Z//+dFHHyULVVIwS2XYH0OgOhHgR2LOEDhqEIAaUcJoDpwHF8IijPjSTUN1KGqYUlnuoo2FAyCY008/He757Gc/Cw1De5AKsehkXO+44w6yn3322f/6r//6uc997klPehI/4e9+97tEoXdCxvDiqlWr4NcPfOADEAx89r//+7+kgXpJD2fAFitXruQW5qM+f/u3f4sGDEEigVuu73//+0kP0ZKAW5xWnqrif+lLX0rsc57znM985jP/9V//9cxnPvPTn/404ZQOv0JOV1xxBVGvetWrSPY3f/M35IW8SbB06VI4admyZe9+97v/8z//8/zzzyfBli1btGj4+KKLLiIZTst94QtfCJFTf0KACBBwV199NVR6+eWXk/eLX/yixvJKQbm0+uSTT6aN//7v/87LjQYCFG8SH/zgB2njKaecAl9qK5BJDSFI3lR4nyANHE92Kd45yoKDqQC1/cIXvsALByVu2LCBSG0OLzqEvOENb+AxgRgcf+eddxJLe5XU3/72t9PMv/u7v4OVL7nkEhWrCKvfroZAdSIgNjpzhsBRgwAE7Pf78Acdtw58qhmTW9Qm+BVFFibmln7/kUceoaOHin7zm9+gNkEnoAHfoD5CYz4yWG7p7qEZEsNkP/jBD8hOd68cprOWUKxRcyFIcpEMPoZs4D8Vct1115EFLRbmQD4MgaoKF1KfSrZQP6oqid/ylreoZHgOIZRFA9FQKQhW8+v25je/mcRKSzQNzRjCoyGIIjsEDx2+4x3voEpkQXmFI5kNrq1GMhT4vOc9jyj80Bix2JO5pZIU94IXvABGp/mE3HPPPRSkICBZBaIHkwAVmQRYhtGnSQP9qwQUcd5svv/973OLQ84vfvELQniV0bcNnZT+05/+FGlUGDmARm1pCBWgtkj7v//7P83OVfEhiueLpvuTn/zEj7r22mtJzJsTeQmk8n6UeQyBKkTATND8YM0dPQhAPHTu9Ox0wfS/zABCS4P5oAGu2DlhWdgLoiUlyhzGT+gKQoWhn/a0p5GFQVkYFCL5/e9/D7GhinGLQPp9+BKSw8iJBLKA2vOf/3wyYhDGgAyzQiGYrOEPomCaV7ziFSjZ5FV8yQ63qZZMJZFMfTAso7f5D4AKUCtKR31H5vve9z6uBGL4JQ0eikCn5yUDtY8Q+hSu6OhUAzszxKklnnjiiU9/+tMRRfiSJUuw/d599920muzUCpMAlMYtsfAlg9kYjbWU66+/HlUbOajCkDQooc5C4cBCAjzkoiGEa8UQRUuxHjPbiwS832B1x4xMMhCjmd/61rf0vYRGoYWTAHM9eX/84x9Dn9SfXNirsfCTBbHIQcPGsk042f/0pz8dd9xxvPogTVHicUDSRP3yl7+E5rEQYJHmofAew6MEqN/97nc0k8RI0yx2NQSqE4HSVIjqrJzVyhCYLgKwHQxE/05GlCRuMQJjPaa/1hBit23bRiD9NQolOi7JlAK1i+cKYUAVcMOb3vQmckEMkAEe6IorfMOV7MhkBJf0qmSjScP60A9iYT4CkcCsImiG9DhSwnMf/ehHMd5yiwqIQFgfv08VlAW5Uh9IBSLnBQIhONIglmRIpv6EI1kzEg6vk5i5V9APiiltpF0UBw+RngSwmlYDUXAzzWccF6s1ElDlsbSjiFM0hnqIFsfLClwLjABIZcjLLYov2fHjgQUJ56q2fTgSUTjApHQGeqkGteXKmwqOQklMe6kS4UgmUOdtEQKPkpeGgzyWCQgYXteHiLr/rGc9i1jQpkUgrPO6CWHAHt6lgUgAEFhZKwwOvHD4AvGYMwSqEwEj4Op8LlarGSKgvbb28sqaqFz03TABnTKdPgwB/SBdOQ/W0ZKgFiVp+nECYVkyvvrVr2YSNYZZ+ndkKoWcc845MAeJEUhKPLAU5SrDIR9uZt6Wykc4crgiH/547Wtfy4AxU5YYGIaAUftQT4n1q6GVOfQrLaViOBVF9fS9Qd8hULs/+clPQnWQJQbhl7zkJVRAKZOaM+6LHk9DIHUlYJYyM/KKKGZKk4yFT/rKAt/zNkA4reN6gFbQWLgTnmbuG2ACDjxKdn05QCYFwb4IARCKxuEnC6D5YmmOFkQu0iMBXZyhZXR0XpioLS89vD2gT+vjVoHIMWcIVCcCRsDV+VysVjNEgA6azl2tl0rGKkipiK5fb5VK8dNHQ0LoXvT4qlrBo3TuUAVp4BuIBxoglnCYAH2LWJgDnoBoYWWEUBAenSzNACQMTaByADN4YQXqQ63gLRwGWMiPW3RcVYW1SlypPI4qYa1FC8RAzduA0hWxFA0bwT28QBCOkZa5S6QnHH0RxqW2qlNSW9hI66ZX6kyJCOFKLIzLpDMGiXk5wH7OKC9RtBdNmljaS6uJQiatRj6xQMRVYSScFpGMVxAcZIz2TywOMKkS5muagIdYaoJjaBwcQAxVmGTUh7ZQN5qDB42ZgpBJZbQV+iwIgU2ZLgeY5EKaPiyqRPVIiRKs7wok05YCr9TDOdpC+vKd/TUEqg4BGwOuukdiFToUBJRm6NYRQi9Px41fWQrCIIRwaIDuG77ED3URC+dpj08IHAPRMjnruc99LktcGAeFG+AYunKlOiWkHTt2kBg7MP0+HT2aJcZnivj5z3+upcMWTFEmhFhSwiVccUxgZtj1y1/+Mnmf+tSnKm1oFDWhaLJT3Ote9zpqy6RfrgTCrKTBQ0HozVSYGcWEaHuZe4wc9FreDCiOFwJKR3EnMdWmRdperQmBTISGYpnExEAs46ZMPAYo+AxpL3rRi9BWN23ahHCIk8ZSK0BACE3AQ9FaE2gYD9mxYDPQi+GXW1icsXB4kcRkgVxf9rKXQd4f//jHidUstIVY2shVVXOSEUXrqAPJKELbSysY/YWAGbHGT3oqw+OgUXioKo+PVpCdXPpugUe5H4+xLyCYq2YETAOu5qdjdZs2AnCMUgU5YSOut99+O2ZS+m5uURzplC+66CKoBbMqPT4qqXIYPT5+enkGO7XjZlHpvffee/zxxzPfGF2T9DfddBMMxOQppJGG9BAV2ht+yoU2WCfDvGWGdZlBDf+x3BZtFcKjIAgSZoXPiKIUJhDBvtAP5EECBHKlthA2BAMdosmxDAmBaLpUmEaRhUnXb33rW2FuDONMucKqzK5e9913H3TOgC6WWK0YnA2fUT0EUjGqh0AqgMcviLnZjEazdhb2hZ5JCaWR68Mf/jDznojFWo5aiZmaNjJFmbcW0qCOw6YI4RZ1mfS06P/9v/+HRZ26UQcKos7UBCbGT0upPOEf+9jHABNkQB4AEcj8MoClqvA3Kakb8rmlnsBFQUBB4L/927+RGKs4E830gTJojTTG9XmVYXI1Qpguh4bNcwQKXikwqrO6DGwRaM4QqGoE+NWZMwSOJgTowWkO3TdrZ1WjotPnRwhVaC/PPGQSoKXRoZMGpvSbTzJoyb+FM5gIje2UcFQ9aIC5S8Si7X3zm99EOHOGNbFquvgx7bKuhixs7kEsTIYORzhEq7o4KVHdEMhoqAZquOptpISEVCZK9ic+8QnkQC0wGcuIMUpDfsTyNoDWi5maFsHxrDmGC+FaoiBIVtlSVUK4BQ24EKVZ1w4RQgW4oqeSF5ZiQFor4Je7cePGt73tbTpSzvWJT3zi5z//ebKQAE0UywF8zy2syRVHK1BDaSnECfOhQLNAmRcXLUhrBc7IgVZxrIn6l3/5F96KNC+tYCYzQpwwMV8zDZuJV7wtaQjzvFgcRS7eUSid6d+8BmkU7wGswGahMA3hNQIaRtVmZpbG+jL11q6GQLUhIJuq0xeYMwSODgTgEhw9NSqjtohvOAQGvUHA0BgsQmdNGm6hEJLhgaXw04NDWvhJQF5la/3FQi2EQH5kJwuOWyhEWYqOnhDlG83LWKbSNoTBCCs6IulJgHaLwAsuuICCfvvb36JEItmvDNUjGbek0SK4rXTUTSugdVNNFOO5qrmkJASBful+uBbti0KOKtwKjuYiDUCpZD9lZUYgooYMXUOZkDpwaQjNJyNlYQPQtjAHGxs+lnaiEMWVKMzFXHFaHOEI12YqvH6hJOCtCOjISD2J1Wpw5ZbKAyNpKBSnTSAv4ZROlMrhltgJkv0izGMIVAMCNgZcDU/B6jBrCMCmUCDdOoqg9v70wvAEI44EQhJKkHjozaET0uOnW4dO0L3QlbHcQkLKQ/TyJKOL1/pxC3/Qy+st7Kt+sqOu0fVTFjRDrLIvWjLhKKMkw0EJRDEti5m6TB1CgSY9ISqfmuAnGVdog0D80C1OM1I64dSQumk42dUqqxRFRlqKo3QSa3pap+PcxJJLLclIJpkWx6uJshT1RzJRNJkrGUns85mCSRbYl3Dgwq8VA1gk69sDedH7QZIF1iQgCgdo+HkE6qE4Mipx4tdbgOKREU7RhMC+ZMFPGylaqwFEONLgSKNRvAqQktqSmAeBH6d+0uitXQ2B6kTANODqfC5WqxkiABPQC9Ppa356au2UCSeQKwSmXT8J1AMDwQ3c0mur4gV14VeqJo3qYSoH7tGxVdIgjTTEkkYTswUE87Z0cw9GIr/3ve+xJQU2XuQjkCFb9tD44Q9/iO6LmRcjLYEwil6VL/26+dXThnClLVCOkgo8R3PUT5UgNuT4KRFI3ZQj/UDVWf1bPJAWV33VQKCSnI+YpqRW8CJRCikj5VA+GTELM3ZLqymIpbqYrB//+Mdj+saujhGeKAaS0YMRgrleBwJoGhm5giRXBNIcEmBOh24r668gKLwkAGGqQQI8ijOBVJir/36Av9LRChKQawIIlWnMbwjMPQJ8180ZAkcTAvS8OvxJo/DjJrQOKkL/89MQyy3dPR6oiyuUNiELt8iBnpVuK/Pq2K2Wgq7JylRWKMETWIY5NkC1T5gASmD8mB88ZmemDhGCTC2UqH2LIwrmoz6kpFCtWGUyyIwEhMDrGg6TaTWU52gFTiusCbQ4BlAnlIvJWhNQCukRgtNCtZ4ai1huJ9SEWyrArlu8T9A6CI8RXB2jpT6acdIrdUAajK6x+HkuWjENAVgaCNRaB20IeE6oAInRnrlSZ9Jz1fQqxK6GQDUjYBrw3L8DWQ1mHQF+cqpdVUqG5yAkJgHRlaN+0Y+jQdJfq+0UdiGQvhuPhpCAWCSgZlXqZ4SQhljVHdHnfE0OzY9SCFG2QBpMDG1DxlSJXMhR/U+zEIIQra1eqSHVIJBklZX3/XAM1fYVQfiJxGTxE/geFc4t/EqrVV32Y6kbeWkaBeGoMCGVCiXZyTKh4WRXJZjmEwX1+rZibv0SSQb7ggaECoZqJyeQBDSzshStD0XDvmpaIIRcfgOJ0pqDDNYLqqoJFDcE6sNSOb40cu1b88o05jcEqgEBI+BqeApWh1lDAFKhm1ZxcKHvqez3leqI0o5ek9Gz+xQIE/hpVAIdPRSFH+Lx6YQ0hEClykZ+FqiC3l/HO0mA0obWq3nR6uBC/L7TvNwqc2s4orjlioN+cPATvAXrVL5YoLgr/UBypIS0IB4EIkRI1XGVnwYJJHAii8jxyZK8PiNSqMonmWZHFAmU54gikDcAmqZXra1K0PorJVMHJPivBZWEqlmoJ+mBFFG8oAA4bSQQB3TadmVQhZ1wbTtikUDp+pRplI4pUAefiUmjICDTb4WWa1dDoKoQMAKuqsdhlZkdBJQMkEXHTS+sQrVbp0eWbt6tuyUKfqJnJ1CJUK+qs5IeRxSusloEwij0+8phmsanMZ/wIAkohIKgPQJhBZ+S/UIRixCICm6DafBQAbKQUauNnyhcZQUIxCk/EU7RJCYvRfjMRLiObROo2X0WhLR0ZFTrr3SFhAnNRAKlUB/w0dIRjp9ytap61fYCAmlUAu8fyEcgL0OE+3qtCuFKhamtNtAPxINAhFc2Vh9HZRPIRR18tCckoDhFplJIZRHmNwSqCoF5Q8D8rvxfrP78fF2HnoXfLU6R5efKL1l7DXLhKqP4ZWoHxE+XvkNn35DGF15Vj8cqYwgYAoaAITBFBCa86U4x1xwmmzcEDEYwK/jClLw++2/r/uu8KiJQL57KASQlV3KRHeZmPIw0vJVjSEQIsSgKxJJrDh+DFW0IGAKGgCGwPwTovVWPoqPGr/oSfubfsZsbLIB5hjkHmn0eKVTzhoDRd6FVn3fV8KVXQFfEfdx9VuZREYjWi8Pghq7MdBh28mMzAaL8h41tkFj/1jyGgCFgCBgC1YMA3TidP904lktqpQoVBMySd476Zs9UrarPCNVT8wPXZGzt4IHTzXmsTrWAQXX0SC3MTLvQcSyqxxPieaDdMqOEISj41dFu6UICJWOi2FqWzQLJi+OBIZAxP32lmvNmWgUMAUPAEDAEJiDgK1d4iKK7xkNvv3TpUp2Hr+npzPH4UwQmCKnC23mjAftEC4i8BMG1OnUTD29GXHkkkK2Pvv/AfNB5Wpgp0IDxYM2AyzULz0yF+CnNYwgYAoaAIVDlCEAK7HjKKgN6e/p2f7rfPCLgebNVmz+piu8ERAv7orbih31ZmMg4LoE8D/xEVZqX/e8QdKsWbAgYCucWmTquoMztpzSPIWAIGAKGQPUg4HfpqgFTMbQmenLGgFn5Rjeu7Kt9u+pm1VP5A9Rk3hCwtgGLMR54FP2V008Zfgd6Dm7jqDJ2xodQcSSAhuFXzeI/OW4hWgaSUXkJVGMFITwzP7FmsashYAgYAoZA9SDg60i+R+sG7zKSiF/HhunVfYaunsofoCbzZgwYCwNTpcAa7mShIXOYOVuUs1GPO+44Th97zWtew5WNdkng73ugzSa9PjMeDA7mxkCBKD/8AOhY1OFEQMZyxlwx6I1f7FqOOqzviFoHvWpBwbG5ea4GrlKVVd1vfSZkJLfk1dAAf0UI/8nvwp2ccixBmsAVN7EIUrlwV6FxF5VX8AS9ykq6RKUKVYQHaF2wXAcNJy/Si14xUC5DSieZlhNw1RZ/xQMqCdYUlXWTCMSOK7Gcir+TtMvFao0Ofh2rTIVQ551E8n4Qm5hzwv2EpmmsE1XRqHF5JhY9LnIWbvZX7v5EH+b6TArQ/uoi3+rKb8PEdH5dZ/iwHBdADcwQQhODg/WqatjEwqryvurGgP2xXiwMAOobEyrDVQNGl0V55ZWHKI4pZQdaOFU3H1CoodsJqq0yN1cIWM3R+6apysd09FRKf7/SkxbpWfylX/wSQ44A9CepsS5tgE0w/N/prOOQ84rUIecFKELq4PhJiivXk9CC6/c1gJiJ9fEj9u0pEVfqfkKFvMdHZt6Tn6YGimGJ0sxSuCSABiWq3F6fBUkodSq7Ch7SGEfAYx2dCnXMKlnK9SI4GM4HIswidXXIBQR/krkrJUgvKK0reqG8F1bR4SIQFaVSUgVJgxiitAztN7Vu4ueZFrMeWbS+BJWAJQ6CdxLKecs1Q5gWdfCrexaAVHCiEDTupUHK13LLEgmZrvObRkZtHcKodxnzMrYlucRENGi6BU05PWBOvQSqXAJ5yvKnkVAAASAcNeJmCtdMkF/XREcVcQjQ6vrXienG3/szdfxO+yjozxWK8Q2d0zslVJRUuBP2hYNx1EhfamBc3ne4ZVWSmqMZCYZKr7nmmuc973mEq4qsLVDFF1ZWCQSSXaPsOicI8IPV3+9Y6ULDzvErLPeepZAj9KdcgYrixtdzSr8RXwp5caUrjVKfa5rzukmc3HLjfyTHRM27lK+MGPIrivCrhIdPWAgpoFduIVEKhspdrESVPy7IsS8pqENI9Fq58oFiSrdECQ87Qa6SBfdu4KoAF5ej1EMy9Gf8pZbywhSISmWC1AcDm6uMBJKw5CSxc2NB5ZAp/HUwKDoUXHI+NnKvN666pWgtcSrXUoaKP0FBQp1fXDlA/kppU5Hst7oy82z7tYY+AKXqVUByiCGuqbREnvoUrkF5/AwK8uGroN8G/Wr5fm7dV4RXN171+Mw2JNUtDxyqzlUaEDApaP146+EENCadw9BwsJ63+t73vpejzjl89PTTT0cJ5oVIh+JJDNeq9owHtRhihtHRlauutQuvQnQPIX7B/ID5sUm/XNKNuNOegy6PY/fcHT9Ll/JwoUQp/jEGJfOs9gBEqKNKQS9cVoAI82PKKdxfP9Sll4aUQvjjtEb6nxBr5aTBBLlG+XlKCUr3qsYpFOPKKOPjKiGJSeOD5tciKD29u/h/XJzADFMWnG4rIa4a0itO4pAhESKqogRU9ABqvHuzLQpJuwQuiaIWCGYCQSwGfozzSkl49CpxcltqH0Jce6U5LsmBripNmlEq2E8sHq0CPt+VS5RvUYCWH/wqlZzgXKHlYCmDmkvTS06U8KlILqeREpAw3Wu5uIP/LQFb/rLo7excGSXJBvI6VnLwishXqCCmH3nJpr185/VbQNYyngIFyOij48fBixqxk38np1LivEvjA1EtNVdtFU69+uqr2SeS3zoOazODvhwvih99lyPNqS40/PrXv/7OO+9k6Bc+fuUrX4lhWZuBsULZlwlyH/vYx5irxSABHIynWtq5sOvhfnD8IPnwk+P3Jr0nv0Wuvsf9StGiDitSVCBc5OPxKf0WKND/ULaGElvBE/utEhnpm/0rHtEw+eMcmmVEaFhEEihR+nF0RKxopS5W+8tStsn+HCCB69JKSGJcrvxITXyUEcstH1cH9ZRCpH7lDw8oGBOVWJ6UZsAIrE9Ji6LfVFFB5GOt4iUXQxMeiubqP9BSnbmXPtf/SKudDn3wqwMHiDDt6yPjinx5NCJ1cueK1QHyg18LUhP90CbnKUOhMFE6X9fKjyv14JIRpwBM97pviZWl7+snPW66pUwxvTxMR8BTugblK8CQhH4yzkOIe/RSQy3UEbN8tfjpaOVdCxbGperGgP0dnnfv3o3CCnESsn37djbQgH11Fe8xxxyDjottGTLWJV8ox8uWLbv++uvZEgWqJhAOhnHJghCVA2Fv3bqVM8NtDHgOv9uTdpT6Q6yM4ueorkLXKAfN3l9KpD9QR4mVv36/ApW1KqcVxpnM0bPQm2hrND4IA3GvXQsdujqIyvVD0rdruVy1pYSQvrImkxUkYZrMVyVdslI+FetnLBfrqo0Szj07s7o6UA0+fnrqwEdoDUfKYFAHirV6SJeGl8SVq1kxKkyQfrQektgJxFPKq/EiQaUQA4WUa0AYAQe8Um2K2J8rtb8i2iU/QI6KpOLVFyIXqDXx47md4LSe8rinLn+CiIPe0iCqdNBk5QSlSh6++iCZly+xcRzwKZViBRkdcqEVYtPiKj8F8moVK1uGzPKXpNyc8X+PyjFg9+0f3865vYNxtQJs7MkoLwzKUW6rVq3yawWPwqDwMeyrmi7DwHigZDRg2FcPIkWTJi+5uBLFFclMmfblmGdOECh1Ee4HPKGf8KO0YpW/8MNXVa2D33FLHcZ6BSKdLbdkIj5ALcpN0e7Yl8BXr0xnwr764TvpehruID8tWuzgToZaqLk7INEgSZfZkadc9LjajdMI/RRSbFCpP6SmaK0RCbQa3OLPB6DhHDOxih4ztoKos/SaRCk9u1+VY3FJKwWpRDw4GqKiKp6mX77LJXplua6aZ+pXB4omL4sYE+aHOI8awv0wKqWtPPDVT1/xNdDaUmq52rwECBxcxf48Rclj5ToNcoq5HJZ+cVroAa6l6rtcFU2ZLa80Vp8eV1erA18Fc/lFuBo7Ata3PYJwhPoOYThC+I6p3486uj1VR8Doteiv8CU2ZFhW0SeQEFRhhoRhWZYS3XvvvRs2bMCkvH79+rvvvvuzn/3sCSecgB/ehblJT0p4l3FfxoxxKqerq+vofpxV3zq6YP31lWzL+iPUnxzdhv87pCGa7nC3SDtCSimVToWoIb1GZfdQHlKVnncS52oq6Sur7OdHB4YsnR6j3Q8laf8l6fkIlUrXprnp06XPqpTmiyKwVAMfKIyxlUnxk1rzq9+/4iEXqV1JzOylNlI0T0IqQbQ4aSIJdJyPFFplrQFRUq7Oi6YQuQlRczWqkxLhocKIV0yX5aHxkMa1j2vJr0XJjbyJINp55XZqzm9duc6SrULoBPR4RRArtyvnINdS+fvUR0BxgSpa0HC3XFy5U5VPRqwKrpSpX11yV1wJqAP7S204LH+otHxX+OhTO+hVvvg8d34CJYcEcsOyvlMgKl43NcCPP8o9VUfA6LKM+IK6KrXKnUykgk1RYWFWokgAv1577bUbN26Eldvb25/+9Kd/7nOfY8yYLThQgrE5w99KwKSHlXUyFxZsbs3NKQJ01PyO+ZlJb8ivUX9wXOVH6OhZepiA/Hblr6Q+jA75dAdSunyz6FlcB4NfJ4YoF3IrFS7N/tGELvX+L8gtKUrok464ZbzXpXdXVme4UWAUNadwEkiCMaednNaHgkGmHOtqosg5cKR3UwqcACkipBbu6gvOy7IZWFNmPDMpzMkplyXJKUU+ebciK+8eQUnx1X5T2Jcn6NYmiVDycoKvVIDMrmOVlki4lu0kSEJu+ZRu8fnNQcLUneQq53TySreq76ooSlfHraaVbxr+g16lggJ1GTLFXEKlnTgV7dcY6a6Mg0vW0pV9eSFwwqZydQmr5kJj5RFTcYXoYFfwcy96JZZR9LQ1+g1w0PIc+Q671WWIliBFpmqafTgrUnVjwLPYWCgcMzUCfSY+CtaNzSI+cyBKum8sml42nQ/X1uHjNzk8nGmqiwoZZNGc6Pkxf+Zz+WK4NnHgnyJvYzxifbXCg8NMwhsbjxuHX5/+QZuZTecQFY1FSuzLwZTUgaBUKlDLuyBsVcimZcW5F3EKpHYb4+TKSSCUKK8NJSeUSZNGciPxSC2NDgdri4PpQCKGvHRqJFYfzXu5tJehDfFQIlCMeKMFkR9B/cwV8llIMhBCmuvthfPcBFEZwYXu0Fo5XjNQLLCJG1F0XlonOJ5RN/3CIyos4cQUA4zQyJCNJ2PSODFA84fEpQkyrpRM1gtEvJo6hJMsX35hQAC/Ija/Dxayso1Had2wy0L/ClZMo5NKB8KAX8wFS68IhEmaoEyyE8e7ctwNMA2PDNclGggpFnK5bDoak93rAJAXZUBWDLll51jJhuNZ0FrBlrrAdiyalm+Re77Uh2AQIMBVSdrPbV6MpIxh58OhsMhXV66S/5gkOF+QZ0e1nR7GrF1s744smDXtCuXG506isF9QHzg/IJaCPPvZOpTlMeD85peKrPiTLeRDQVkcnqcIprAE5SETT0b1VKR1zSCNDJpO4qRKIoTvCO0UIbgcZ5+7b2BWvtFYAdkfX2PGrlRZXWUUYaUXzrIskol5ufwqolnAN83/oAw0uL+lK19B0iKEuvrhhDAdT75ILrNWhAR4QF++2QUvxgIDYgv5IF8b+bbjSDLu6bhAufADP/r689Jvw2+keQyBw4pAamAAA0aktiGZLYxkA/F4IFoLFWHXLARzGVnawu84LF053XMmQ+8s+8zt6zByQL3Kvhrrr15j3AGngXRD9K37Zi+FFOHAZCQak9tCPpdOhyKU7W7RhKKx1GiqBs5gIKMGmqFmanfdt4Ngn/GxQOifTgQHVdZFarP5LOxLxxOojxWSXjDuxRKJbG6UfrvWC+XkpZ+8QemN0AUYe41IzyllFQvJoRHkxOI1Xj7nQSSEQ73QSIFlQGHpwL00NRcqRYKIEaOf61ulPtBEOpWuqU3Qc1H7rr6R2uYE3WJNUJZmxgrBYjrIwiJW2Ut3C9QQMO8HQW8k7/UPePWNQtCRoFdL64PBcJAqQk/ZYi4bikVYX8/7DkWmMtlItIaes2s0F41H4cZM3gMwpZfRtNfX3ZvPZY9ZtYiiR9PZRKKBMpPpNGaqdCzM7rLULRCKIAG/dNnCqpHkcJanzGNt4P3MPUMkA20m7VE+jzUaCUSjQaonkdgTHDeG3SuBPFAnamd/JlNIhUOhuvpIXRSik43AhpPeQP8I0zijkUhDYwzxUgGqlAvGwsEwIKhzhVJVysWLh7y82vGGJle+C8VANlXgOfIKEYl6UeZxs8OKEKE0KUcGrA1hL+benQjPeKFNm/cwi4WFkQy08e1l2SRmOYbVGhrisZg8F5zUMOX19ydl3uhjW4RLy45Y9WIU5JkCIHkxDXLl3SUUDD/00OZ0OssgHcn4oSEfiyCxFAeYhPOWQ0ZCsBeqKRFi0yjS4NTcSBq+xkSRXh1+XuMyXiFdyOR42wogn2rXNTY2x+M1Q0Mj6TQVZp9BniFbOETi8bpoLFGTaM1jauEdJ8/vIMc6Jnm5LGRHB3sT0dDxx6w+blU73+N8EQrORXjdKL+96RM46q9GwEf9I66mBgaCNU3NwizoRREvGpGujZ8n1zjdWCjOr1t0F0xXMDFEHHFcOFkLfLqlm6DXoI+gMyKQXoK+ozIHPdF+OThQCEuHSU8pfW0QJg6HsgVvNCWKYl2c/jlKP5ujsysWwtHIcH9vXXOL6yFdT+mKIT+OjotyYU78HBdOIN0or/NhLx8N1RaKkTSbS6FX19F2IZhAALVJUkEiKBtiQg156awXinojmWI6lWxIJOi4axu0OConXW82V+DVBN0U4emiN5rMNMZr/S4LcZl8kQ4UEOoTsWQ2H6VPro2mPO+xHXseeeSR7uFCePFJ9S0ty1q9loRXF/Jq4hAHFMYeNW43jqC3s9e7+a5No8VIfcvioeG+5ppiXW24pbmxtakGmuE1ox7SDcn2T7wlZYpeFLUxGuvs8x7Y+FCornnNaR3UjZojExAffDB58/W/v//eu08+bt1b33Al7NcYi2DoEDUnEhvxvJt3epv3DDNxEg7gObKPLEsH8XCkNw0BQfiJE2+YicnD5VFufWTr8OAQW/CTBuJZvmLp2lWrGYRasWJRfcJrbvYwMYykvM2bM0wN2fzo1r39Q2ACR8frEo31DbzcpEaTw6MjPHau2XSmvrFh3Zq1x6w/dtmSRYk6YXeogumfWMt6enr2dnf19PRBhLTXMV8gx+uPO2UcFRgPDRU1NBDk61HD94f3mWwum88V8wXsGGiplBiLRIPhUCEHBfFVyuq30UmTb6a8qbktCmggjKjNhCkpFMasqeUnICXK96riyiP2v9Xuhc+9d6Euo1fzCuFeOrUI+Ro6p2VxxWkUV4r2Y/30frifTD2FQC4U5U0wK23nVyPaPv/D8k7IHYq9MwvI71e+0XJ+b4iF4dwW0XHFMsGACwauIFikhha1NFxy4RMaF7W31vBiFAiHI+6FR3/6pTof9X/MBD1xu8qj/pHPaQNFq0MrGMgEbrl7Y1378mXLGxqkh/Hq2MWM7hkNkV5G3rVDxXANhKa/yUnrTL9DvzCBbungCNEuxnU1IoBk+CcTQolZD5UOU1+4Jh+U6SJ8HHdK8t27BpctaaBjoJeSd1U1bIpH1S5JQ9eo6aWPdM7PTq4QdsIAhuYQI71Ixg0Oe611YgSOiTIm3J8tskOkvIVwn0P1c2ZAKEoUhnw2hqobppdHB5XspIH2siRzJuJR9+5A2/zm4amsSe+Qd9Mtd3JoeVdXT6KlfSCfwIpYzKQWtzU95YlnX3rRKc3oha51VOWmu3b/4Gc/39ufTBdDqSwsXhcppLKpUd5vKBpuWLJkyVlnnXXGGetXtouBUW27P/3NxltvvXV0eKRnODkaaz793CeeecaJ2WT2z7ffunHD3V4m2dFUN9Lf9ZQLznvdK57O06ZpaHiNNd4N927/z+/+tj8fwQ4PgfDYMKLSJeGPYYvmhSYYRCNDceOdAksvFcilslx52eKBUitoOJ/N8H3hEVND6EQUQdR9XlayjBvkGlta4Ud9S4NW8Wh2eB0J3MJzkD30L3nRtMWsLEsqkIbiGkB3DopAkpGeR0kyPDi+AVzQ8zJpqYa+LhBERslbfgukJr4jHABRPVuamiDbXCbTx0luAwPDo6PpZFL0Sg5aLRZpe6y2tj6RiNRE1q1eBSJUS/Hhe4yfK9sagBUSBoeHR1A/k0kw5L1u5bLVSK6rrUOlTI2k+gb7hvqHRtOjECKmJsLDMXYXLQ6NDg0PDA8nh9FIsSHURmtjcflHbJR3wJAYobhGghHolRDSyL9QLhLLh8Kc/RrmNSWVygwO9g8ODieTI/X1jar1cuU5qDacTaYDmVyoyHMU3MKhQESecj4SKNQEA4ma0CnHrzvtuMX8svhq60+MzP432QE5duEpK6o8HaQRcRQMKRoBGwGPfcUPt48+ciSVpVvZuG3gg5/4XDDRcukzL3/KE1c0BLxI3qtjbCmfkjE+7ISF4HCadWWoUpP/IP0foV9nekC6UbQiQojVn6v+UOmpK43VfhZh23zGzR9CmQtjDYYF4RU+927s+8N1v9+44Z4XXHHZ8y97QhYVqJBqjteGhDX5ODJ0VxrFvV7RnqXrpgtxVkeaUhvwduzpbVrcAlP2572vfPW3q1YsfsElp8VRE0klrOGlA153yts15GGWb4gHWxrEFIkYEmjHlMEcHvRSedFTmaFIFDXccP/eezdtueGezRn6SDf4nUjUNzU1NDe21MZjKIWsg9+1a9ctt9zC8veWlqZ1645tbm7o79uTTo/2dHd3du4Gk1NPPuWiiy467fgGKvL9n97+5z/flcqIZnn88Sdyzvn2rTsSsZqRweGBoZHh0SQ9OVdsxbWJuvPOO+85z1mfGvW+/90b7//rBkabmxrqFy1bfse9G0MxetdiLp2CqVYtW3LW48445cS1X7n2yz3de1/yguc+66LjFLv7Huj+0Y9/yBJ/1jKsXb0GDRUNsqWttbW5JVZb09KESiQvYz193q4du7p6unMZOcZ7+dLFJOjoiADRQMrbtq3vscceQ29mLSKOZQ6wKfZVZJ506iksXzxudZ0+7kEs4X18EXKJRE19vZj6Gd/n29U76D3yyHbMA+SFR2O1Ub4zkDRLMJobm6hPc7OYcJuboo4EIRLJRROgDff0RDyPI53BCiJPH+al5pgJMHiQkjeXVMqNLMBnWH1CXsy9YJHXf1XigZJyNO8N8x1IMWodiqPNx0U+X0iuihhpcPgJ0exIQL7uTcW7KlG8RZGMj6YhljR8tLZaYuWV9Lh9Yyctl4w+QSKfasuH9zkMIe4LTwLfaQIq4DtiqSFXPry68aaD+YTJH24yIBUpZFOZSE19ubl+vpLHCHgiIlV+f1Q+sCrH/MDV40dGV8Vv+6b79nz8C//bNZxdsnT5WWec8sJnnr2m0YOTgpkU5qlQTRwlqD9VjNfIBB7td/YnGdJVfqXTrEzD06cnVY2ENBNiyylzXmZU+sVAbLQYzAa8Ic/784ODt/3lvnvu3TA8NJQa7D31hGP/7soXnLS6ka6HykgZTCUrmX1Lpmb6GjRXOmjtdPRKQmpeSHmRGm9vzhsJe2977/+kctmu7dv/41+vfuL6BhoJHOgbowHv1gd7v/HL6x7dsQteYR2eV8gt6mi98LzzLrrwNDRFujnk01uRY/POzHV/uOmue+9F64nUNQ2yN2BYOIOWorzpmweaOroCRj8YhYafeOKJT77owhOO9ejb6KwTTs7G7aM/+Omvb7z9ziVLV5z/xCc+8siWPbt2ZDPJpz/lSS979rlwf7Lg1bthZeniXYc+WPQe2Fy86dY7/rrxgf6hwURNbUN9PDU8VFcTfs7lz7jo8cuSOWGaP9+15e6/3MXsIDaIPeP0NS1xeeh/unXHj3/842Qq8/a3v/341YG+pPfef/uvoc6df/e8S8897bi1q5YAVzrnxYB4Pw4E6OvljazsQEMd+PiO0YNUSsyz8TimWHkEdPckQD3kK0EysMJE4osRCnHPjhAESgqXRYWTV29JIx5HckqHXMmbKRTDYC+RkhclFvmQNDp5aeAaApYxgTwPgrcoyUVDAMoZqNEKYxEZBUECj0aG15kRRn0YzuWZunF0ja28Um4uWxDjNdmokiueS2WaCX6pHpZzDOjMusfwjIbrlEg/FzIlTkzn8pcR6UoJxCKdr7vM3hfDE5EyLUDeRw7g5Jsmb6zq1CM5hXT5emLKZr5lGh8auBSA3Zpt1+R3NokDQ9OAJ8GlaoOOygdWtWhPpWJ05Yz/9eW9b//8Lzf8+f5o0+K+waGdjzz4tAvOvvLyi05eBlV5KTdXFpJOOmMsP0e/r6wsAqbhlitdrW/ug28wFTLxZMIP1f8mVEpwfmqULdA/husyqKqj3k13b/nDLfdsfGRrtDb+xPPOrw17N/zul+ecsv4db3heguIyXhPTlSYjYKWo0ZzX1TPaNzBIBRYtbm9OeGHmfYe9Rwa9D17zna19Q9H6+uzAwNJ45AP/8Kr1HUyDkkVI24a8L/7gNz+88baG9sXFkWQdY4HhAB0T4+InHLfu0osvOmGtzETb3etdf+Ofb7rt9m079jI1bOXaY1ctW3Tpk87ClE1XTBtHh2VwtL+3d3h4EIPw0GA/atzpp596yinHN9RI1887RB39ZqGYDQYYGN7S4/3fzXfdcPvdW7fvbG5qXdTedNnFFzzt/JUUxkf2w8qnvXCMZwGryaRod7JNf9bbuTv705//YvtjWwd69z7u1JOf+6ynrVnRhg4Ud9oh4lNpRgoDjKnTPwMxnyHP++q3rr/vgYeH09m3/uM/fPXrv965a8+pa5a8/cVPXds6scPF9k4PzwgDD5e3IyUYfXaOa4SreP5M9YWCKILA0VQ+WiNmX7+7Jz1NRrRsKrKPY8IWiEEkQMdsZI3PFZk1DT1hKRWZOL0iRz0uTEtA7yM4D18Kn1fGu0T+xGaZGeboipqKEMc/LknFxX2ZJyczHeyQXLSZP3KVOdPMLkAcAXotQJxSGezMPGAdhZVrMZfPMPacqYnXjwsnDWwn32S3DlxKoV2oseW8fKF9P7FwL1eCmGetM+LK1edFAuN3CUns46SiXnyxGREuZKIyW4AZg7yjIJwp+0TLa6ukKaPqvo88A8iftxm+pJM7/1fMr17ecY4KE/TEr/7kTbfQ+YuAftld/6FebYoLcD8C7ks3GiP9i7zpur6sIrcEuYQTujjNpcn1KnnLzvnLBWtHRU+9o290KF284vFnHbO65ctf+vo999zT07nrH1754jNX1sqsY9d1Yp4d63mRIB2EuNI7tfsJBmUysCgQO7v7fvOHm264+bY3v/mNy6ONrQmhbZ2nQm/FQDH9CQt8WLjjejGk0YfR9bB+JpjKZojDRHznA9u/+YMf9Q+lzjrz7CuvvHRJvbe737vxjz97aOsjmx9LLe+o6aiV/l37H6qBTG754OGzq6fw53s23HDTzZseeaSpufVJT3ry+Wefe/zKEJbSL375J1g4mdH9T295yVev/cnuRx752e9vvPKKC1rqxAT66+vv/uONtxyz5piPvO+qevfC0T3o3XvvVs4X+cP1f3ps+87zzz8fKv3zn/8MUNiHr3jW0y688Pxli4Vdmsv6AiBg8A56HSUycRgqYv41kE3LLGDebBh2LYaPafVWPPtxp60/9o9/uhmqe/ZlT1u3VOzegSQrWFjGk5UB8pFh5rMyL5uhbCYJ14aDNRGvfWXkcW947uYtXdnk6LFrV9TXCIMFi26YO8c8b+aPgy1h6MO8gYgGzPfgb1745Pd/ZDPjuf/xoc+OZopr1q77+797+jJmdhcx3sq6GYZv9ewVyMW58pdUSMw9MR6lfBOKEbR9LLru+0gAjgFFrqrLkk1zckUXFTUMpzOn3GwAvju0t2KZk/CHkH0A6/G4LrFcAyQKbs6VvofuycsYMZIZ/SCKt66SzNKcgyJziCW8JNM1g6oxPZpmQCGORUSmrnxTGubWEbaE4wCOcoUggcDRpIwC8/bhvnSEyzQJWYbNCHZUvoZ8w93Rl6SXA6k8VOyQcKcL5/vPPAaEEsADEtVdpI/FOu1bQrRu2n65UjrJAEl2d8PJD8jF8uz9JQBU3I91c6pYdMf7mwydk0NyCTUjR7zJVCoSq+HXxAtPyi1qYIRYynDRC+RiY8BH9RgwX2e+8Dg3YYe1jP73W7oriXXfc77ypV6Kt2JJz4xdfqZ0Hn486fm4zqkcLO/hwTzr95jGnMkwt4JZGqW3ZpHKHBkW6br1LUhhdu7ISKS+IZkvjESCr/nEbzY9svWL//r3Jy4N7B30Pv/l7z3QmT3zcaf+4wtPaUDfGuhpaGwYSWZrauPUuPyD5JfMLJMgbEkVueHdmuMq4dB8INxT8K76p88M5lgVWXzmE8979XPObmItzWA2Eo/kwt6wV6gT21YqziRXnWVNI2SiCpqmh+W5O+R15r1/+fAXd27f8cZXXHX5E47VsS5S/eD3N37vx79uSCy+5uNvRn9vZzEwE5CDUXQHYul3h5k1nfV+dd3dN91517Yde1o6FtcmGru6e1iR0VBXf97ZZ3Xu3L7h3jvOPevUZz79klOOqd874r39HR+K1jReedWrnvC4xG9u2Puzn34fffe97377mkVCqBzZRVdKAx/uzH/7Bz+5d+PD0Zo4Hd9gf/f6Nate8vzLzz6+zbGNDBWLZz99Fn3eBCdIovSIk67ZdeETvgUiUGTKg9eUKh1h8uUBef1KiAznkKkFuceE6opUHN8EAuRbxIdcXMGqa8D7x395byabX7Fq7Vve9urWuNfkhrpdluldJlTDz0xZviv1+u4r7QcezLMvbOUcWmT5RbAcekT+CgHDXFO4SnXAgFYcjivC94/P5EhQDa2JRsu36ADOfYsmjzcNeHJcLLSqEeD7Ll2G/Gzwqq/0LR//U3BRXKQD5b1a/rj07tbdlALK2USKDFNBxGG3l0KaIcRkqrY2hloAE4ZlIwheiZECi4Yi8Toy1EaCI57XMzgaikSbo/k6lho1eOedffrN37vpkT1YNyV5Q0M91t5ETYSfnDualqpDvcRACfIOgA+SQD92rw1yQNreAa+/UJuta4wU0r+55fbObY+94aoXLGsWc9ZIzqtjcacM38rMD2kfrwU1YeZm9o0UG2sDWbcr45e/+buBoeHTTz353FOPjZMkW2CV1J6RvhdccsFtt9/V3Vf8/q92v/CZSzChw/tJaJtNIMNeX9q7/ub7f3/9Tbt6+picdMLJJz/xggvPPbMpVfB+/vMHf/bzX/z2TzeEC/l1a1Y96+InnXNMvdBbwrvyRVd8/Ye/+cYPfti66qpv/eQnnJR51Uuev6zBa6WS2XR9lH0wpObHLgpd/Ybn/+GOHd/9wY/Rsf7ub//mGResQ0MlDhNxKJjNJVMH3a4EOeMcLyxlJ5Up+yf+lYc7llJjCdtv+lJ+vmau6y+NkZd6a4LY5KM24jVGvbe+5m8f3LT5lFNOaYmIPfxgAifWy78vfYf9+7JnMoHy5Z8FVypylqRNq0JSNOw7hauI1RoejqtIn6ajGuMQ29+Dm6bYoyT5xN/YUdIsa0YlAmKAGufkXmlUrnCbxBIofCZbI4n2EpWBMLGy4oinX3Mzc/0AHc6RuOFkPhgTK1chQqZo0jEEJBFhvgZmK9mvqhiKckI7621EFGtGB/v7mhsbGxpk2SwpzzpzfeRHt+zasb1n1GuE/aT7FhXKDfaUe1ThYKkMcRokV1GzgkwS3rW3J5svdrQ2P+28E6775Y9u23jvwBdH3vr3f7uo1ltcIyfg5lP5UCSUj8SzTrmEwnHhRGDAWcTuvL/7z7fdyjKXV77oRcvrxQzLhgwoi621cTj/WZc+9Zqv/uh3N/3+Kc+4KhXwEoAXEn3u5tse+/3v/++RLY+inrIV+aVPvfi80xdJhXiLCXqvfcbxL7zg+Gu/+0vePZ505onnnNCGWN4VmAP1nKecfN+GB+564NHPf/xaL9l/4snHPeX8VQ2uXSzV4G0jHGCrgmw6GGPO8yXnLD/9pDcx/3lxk7xB4GHWTogRWrFtaDtcY6r7whxmVtcwC+mc09etWLakoz0u09bcV6u6K261MwQOIwJGwIcR3CoUDTc4FqPjhmDK3Tc07EKlwtqtO/MyXw43eCOM4laxKvtyJ+zLjeaL1oYg3aGi15/0tu0YyGdGH3/yEpQbFtdGCmxuFQyxhYJb54qpFlW5s6uP2Y/LFrfHZUqxlNxS461YtvjRrdu3PDaw6gS28s5Fse9GmKdJWc6J/a3sdVnENC3VIbcs9N+xZy8Ev3r5ksvPWXnWsa+95qvf27hpy3s/9plP/vNbl8DwKbcuk0nOAa+flSc5NoP0WP7fjIoe9B7rzv/i17+oi0aedN4TT1wUoFIs0pVXkeRobSLe2df35HNO+sNNf75nS9f/fufOVYvae/buYd1LX0/P7p07WIl51hlnXnTBeeedvlhwcWojRMvLAdOb21q8d7z2Mta8LkkIqefSudooqrWMr73hVS98/dv+tTgaXNXR+IZXPAdSF7TzTG1lcigLjvKsfYH7U6jbAW8Z0a6pWASYjY35GJM1OzuE3a7pElctztlIKyojj8e9JtQxFpCXrVdAZmm7TADnTSPH94GnY84QWKgIGAEf7U++NCtR+m/Gd5XFZKBXyHOM1bh1UyrKlCyaK6OcdJca4m7FTw8rpEhubmBAeljsxrtHvOvv2Lxhy8577/sriu/rX/WSi09dzLgl8xplaiq7GzIvBFlh2Wtwb28vmtCS9iaFXirieetXr2RB50ObNl94wlmZnJvMSY1kIo9zUu9y3Ry9sVI4wGQTenEqE/Ae27UXLl27FKbzjmuOv+utr/jQJ/5n16Pb//fbP3nfK69gsjELP9B9hzzv9xuGf33D9UO9e89eu/xxJ68/5uTVv73pD7t3bD9u9bq/fcEFKLaQhEwAzmQonom2ixqbRzzvBc+57JGvfusPN/9fXaCGpbFsusdmVetWrXzGJU95wjnLsCxD2+ACywqhsPYoOcJ9bU1DSyjCDk2E88YQK2ZYSgTq7MS8rN67+o2v/sZ3vv/ON72at5V8ulgTo7UZJtewl4TsEyb72MuEU5rNvDAmKDHPiAkvggjTndiSir0bIeRwFTIY73ZqL6WuJUdDeEzUOpnKyX6fzs+8KDcdqJzI/hoCCwwBI+CF9cDpz4U/cY4HHA3rvV7pD/VMArQsEgq9OWUQqlb+44opWFREPhBwf8r74y13/fGODZu2763vWB6ua9z12CM/+dV1px135RI25gsxZ1aEsFdkLBTGqI3lFnNxoJhd2t4qkz2dig2pHLNqxfUB7+FHt+a9syLRuEzhYkklnE1PLewr/5X7+Ss1Q/+V+RwBN/XW27q9kwHjFYvaUczjIW+R5/3L2179/vd/6ra7/vyFaOI1V14Cow0UvevuHvr+r35+/4MPNNXG7uobuOeOP0eaI117dzWG65755Cc3UQ/ddJ8qM4Cdkk2HKSmUD5++ru3Zz7h4y669sVRo7dIVS5csqkvUtjYGFjUII4INFmvhYMg1OyrrT9nYlxHrQi4aioyMFuviQMb+yQyYZ4P5Qlg2jg4es6ztv/79XT39GaFt2JdtOGXmtyLPAhcG1JNsxsn2hO31EDdZZF1vOptmhw0hYJmWCjxV6cZXS6ru9hKhriwaHk2zb6j0POxFPT5hVbbFKmUIHDYEjIAPG7RVJXhiP4dG6+qn4egjMvyrS+aFMYmEX6WPF3VTB18rTNYuiliSPbB179d+9IvugZHjTj7j/AsvXrai/frrbrzzlj/97oYNL7r0lFgowCRhnayrmhqTmLbt2sPpQquWdsAqOOTAYSceW8+w6569Xd2j3qq4FMviDuql1SxjCb0KHTsNnqWpnK1XwxJV9rjYubeXlSUrFnkJZI3kGxNCdm/825d84rNfvG7jAzW3n3LxBYt/d2vXD3/2fSjwLX/zgjNOPG3bA1uuv+G6nX1b25ubzjv+9CedvhTFlwUwjE1SAHv3CsEx0WskWVNXDxrPOu+kYe+kJWj8bGyU9ZrqpeY49HDYd3Q4F2OuFxXn7UFoW7a8ZTPfaENtQw1rf/Ih3nig5HxO7MxeNJPMLG+vo6glTeKvYcUxa37go2CEHf4Y/GaD+7p6DPmyP5AowpgQvCL7/DnqCrDrPVHs0OTwk2pUjVNUxqrjHjLvKDmW9TI5j4hokDF05zRuLK35DIGFhYAR8MJ53hCAuImkJgFiMNRhXcYd/cFdoUEZm0Qp1s1+iFQHhQjXIPHB7Z0s/nn+i1/y3GedARvgkqcd98Ddt/7+jzc86UmnLGJnDWeV5eCaEDs8ZbEDx/Z0DQRz6eVtwr8yPxpeynvLG7x4NDQ0PLSzc3jFmjqs0KzTLNUYEcJeKLws5xXzsCx7pHBO8wvXpTJeKugNj6Q5Mqg9IdOu62pCQwPD8ca6c9YtffnLXvTZr//0yz/76b2dj7/vL3cGRvovv+gJV1xwWlutd+byNZdf8pqtvZltWx5+xpknYqZmYJglSRxclKTVhSwbOop5HU7Oy3FA9Sw2dR8ZeHXtymRYPlqMyxFBHOInPyVKl5cGziqAu2NRNjtkgWuMYyZopS6QZIMjInO5utraVK6YzGTqamP1tdFCPo1RHUWYpxCpYUMLHPta5TDis1mSIM1jkHchZnGx5DNUG68DEZ4UKQGw6h1HBgVTyWSotpY9QtmteWS4nzORZAcLc4bAAkZg4uvqAobi6G36pL2c2yJAVodwRmxOlvukCkXsw/0okGxW5Xnf+NVfbt3Y1ZmW2VWorSib7GshlEta9g8CLUePO3qG6ztWsH0BdlQoqtHzzl3fce7J6znV5lfX3T/KFkVuLyRGNb1kTzxaYH3Onq4e5iItaZXDBuiB4RjUP0jmcaedDL2wWRL7LgcxV4fCOmQ9NAQh4oKjBVnVr68IohqzuyDDrnHv/k3QdWjt8mXUQYICXn1dXSxTgCWf8viTnvvcy7uHuv5w03WRcOaKiy94+dMvXF3rxdFRM0Kjx7ZEn3bmiTUQXEEO0onWinz5BCM5cKOdspiKY2CkdQ2s/4Fi4UX3iYXzYmGX8wNEW5YP7AtIGAs4gc0ttGW4U+qO4zWGJUB8wjFWaBEQDQc4g05eZIhkQJeyeUtxZ/HSTJ4IR+zIQK+Ld1XhwskzrBALjuHgoqvnwmPhM965L0qRXaxjICnbJxYLibqEPCud8Tc+td0ZAgsHASPghfOsaWl5ABivKmvRGrZ+LQYjSY5ad2cBEbNj2PvY53/x+5vufPdHPvXwDljPG+JkeTIzrxcWcZOqmAfEAZ4k7h5Kj+ZDi9rYe0oURChqRdy77ClPaG6ov+Hm2+98WPQzx5/0tpwlmu3sRsuMtjc3kFhUO1Fus/zls37tKja43bpzt3AYw8ac0+LIqb6eVa9s8JuGpngV4DNMbRiirpVDdtECd3T2QkurFsv2FFAgS4DIz6wrlGVKOffk46+84tJldYErL7/01VdcsCjuRbGKh7wEc7IGU4jmU9K1XXEIdBzMjh/onDpJCHEFVOQaoReqpiyDGR8PyQlhAwqufKS9lK+/KydP2sgbhQtDE9a2arxEkcZJJATremnninIBLhct9T9iBpChb/8jRc5HRwP2Zer52BCrsyFwCAiMdQSHIMSyVjcC2ltPqCNLg7JsNyiLaNmsmMm7kNpI0btn08j7P/z/tmzbsbu7v3XJio//5zVDog7K5CmMwgUxpkIhMkUINQ/PcCrHubMQMDQWTg9E84NxL3v62vYnnHPWtsd23HDLXyAzhmllbpPj2y07ulDgVixdhGaHcugYRkYEqcIpJyxid45Nj24fYbsqcrnjYNG3haMYecVEzLm2g97OYTk2XhTMQIQL1X7o4ceYKXXi2uXIISMh7H6V4TAC9mZkkfHiyCsvOudTb371C845Bj4uprzBAfRw3kWSixqKcKqQnjRFCuIvVaJAPKDD/oRi7ZYKsJTYbeIhx5tG+DjDPEqtWJedwzDAh3HcLFPM2C86JJ/SG49SLEW5j5CoEmcpa5mD/Yq48saI2dWItDJHi4xOWumqZVf31XUyVL/0GqGVlfvqrrbVzhA47AgYAR92iOe+AOnrpMPnYWvf7fo+LJzsE8n4r6h/fNgi8Y83bvyvz39uoGdPe0vLZz7zT6tWr+GAvP/+n9+RFx6FHjJyUgtcKV0nA3gIHE0mmRDUWC/rOWPs8gz9pYZCOe9pF11wygnH//Xev96zWXaMgnTFmhqMbNnVheF5+eJ2pEh95AhvCJg1Sl57ncfxb129Azt2D8B/nPnKNSJb7QofBmriEPDnvvyda7720+19WHrJHWJ1ExXbsn0n9Vm3Qkacg0LTWKRlGS4Oxqv3vFUx79SOxnieTS45lMarb6rBhp4tDoVIjOZK45UOHNVSMbIy5Oq2A+Ov8yKLlG7uGu8iwvEESC6qwYcq4hCEKqwfmBjAqMgYByvOetVs/lUzc0UkgTi94ilrz0LbLkb+aDKu88RRZVd5GbuoUOhL6M2TRlg1DYHZRsD9KmZbqMmrIgQm6aRd740mx/bN8EPYURZHBN5+309/9vNoMfnsi85/3z++qD3uveC5z2hvbbnrnnt/ef2mlFIOQ5tCCaUtMjjafaC/v5DNcMCqfJNgJGGiAGO6azq8Z13ylP6uPb/59e+IGoKyvHjGq31sbx8zmZe0t1IJ+YiKSVQe/oaDV69ZyxDpgw9thqVQmNOo55KGTpupSOE+z7vtvs233PPQxi17vAj28DDDtNi3+4eTbCDVURdJeIWYqOs0qzQWy8ziYCoT4pTDkaFYPsM5SWw8yUwrSBKOZqmTsKbIlw+rejiwIe4VUJTjbu4YxctIMLOcsUXLGC9nxQkChAu7ChTaDP6UPaT3PxLKG8aY5V+JmtIIdB/E8xlLAAi8Aeg7jgDjHNQ7gX01DYn9NOW0c/xXm15ZCZpc/shcvxLWinjVVb+y4uY3BA47AtX2+z3sDV6wBUjXV3ZKA/SGWFWxocJCA1nvjrs37Ny58+XPu+zK5z61he9Fzjthqfe8Z1+WSo3+/Be/3Lx1xCce6EfVsoGBTGZ0qLGhrtmdwyIzjDBr06ticS545z2ubVlHy6aN93ePeNBeLtwwJEcGjXCS2uJF7Yw9O/5wnXM+hx93/IkncQADBIwVGsdqHJ0rBmEht3/Eq29fWtvc8cCjO4TQUVhD3t5uWhFs4vQGplDls5FiOIqh3C3npRHMdgqil8PP8RpmPUGfHOA6yHhyNh0L1EXC9TIDnHSsE5KzFRwp8oLgDvFhqBhHKCqvvB2QrGxIAEwCypC6dEotOs0KE3npg/5O5nEcLELFORJX7d4lIEjFsiDJmQSUoUmmH8mitK2xJONTroNIrH4HGPrWotfS97D66201NAQODwJ0KuaOagQcwTka8JsphENwxnElHjrxvz7Yvb1z77pj1rKdMZsnM0O4LSyW2PPOXvzEx587MjL8u9//37a9MipLJq4ZmfkbHBwcRBVra2pCdAb9sRhJJwtq/GWvK1j5nFNPigQKt9y6CbJlRnRfztvTPxIMR5csbiNBhZP5zlDascdyinpk286dyaQwMGteWeeDh6NOOWp3w0M9w9nAQDJ/3Q03D47K2wPU9OjWUczRHR1tdcyBxuqbjniZcCiXjOSGWMPLvGk2w0yzuDYQGfCKI16ak3Pra8KJSE0xzfFIHJcmBMz0MMZv5b2CiuhoM43MCedqe5kA5iiX4XKUbPmwYJhToNwYtNRQQJSdryNsocnqqJQXHmWTanIRLrZo4U5NhUznJxfk7uzVUrQowS6KghVmyeWTrlKvhrhKab00jZRf5U5fIrhKU8tX9VR5za16hsDhQ4CfvLmjFwHVj+RKXwdhwbsst5HJxehyqWEmXYkJF66776FHRoeSpx5/fH04zByiuqhsqciQarPnvfSKpy9Z3PH7W//ywLYuaBGaZNluKi8qaTqd9ALpeDQPVYcw9rL2tb6NA0gpCWLmu3XCumVNicgNN98E+2LE7hv1hoeHoeT2BtmNgWrI2DDnBKKlFooQ6IoGhlBTPUPp/lx4GP7DPpsT/TMYiHKaw0AyFayJxxvbc8H49u7+oYzMd969YysD0w1tHfJVRqTso4FMmI8hW1FquecPmyq7NT3MY8q4idIYtd1zF5My4OAEJndVS2npRkNLUVKGUimtVyrRvJKRNxJu+GgEVz4l53zkFgG+0wHRijAl6bFsY/n9PBVCJ42tSFhVXr/hPspVVT2rjCEwJwj4v4s5Kd0KPbwI0EXTyQvRBSDZNLdKD/JnuK+xQeb/Qk57Pe8Pt/+lsTZxwePOYXS3mHM5yJTMNDAu2+pd+pQLw4vW/999j6JlRlEW2SiqJtSfzHcP9IRrUm0toTpH1cKxXjjDNpIsnYWSi97TnrAql+7fumvrrgEO5fW2by80xqJrFjWhJzJbuJgvUqcRlEUOUQpkG7xCMzr3qcfm6hf/4rYHIUhSxWplKhanpw+lve7eHgzI6WwsE0j88pZbIrUh5jCnu7d78dqWFWuSpKalNQF5d5DlUolQgH2xWMYrbxJ17A6JNC9Y47F2l5PXHRkSJGPQpTnNjAoLc7NhJi8UfGTvC80l7xMug1qiCcbDh5J08FrCkUSEBrmyyrnEHE2Me+9xdSyJ8i3VIkpix8JVfmmOkuQd+0igK53sLqPkq2JHu/RT0Yax9rhWV3HtrWqGwOFEgB+FuaMZgbKNUsm3rFxxxy5NGdGAoa3b/9odrqltiCeOW9PCjKei8K+QR6yYZlA3WvQaGusHs4F+Ny4rGqNqasHQ8CiKJQf3BlgjK7ZaxPE3IKOpfLHybO2R984/9yz488bbNpJkb98Q1Ly4pYFZWkwqDgakKDRcyVdk16dkXDaFXpIJRrZ2DyifisC8rLFl0tXuzi4mbZ1+6hm5QuHBbdv7eBMIeNu2bR0Y6Fu2Mo6K7GWchi50Rvncy0InR1buRviKW2FKqajSQumvBhLuTM1kFSGShL9659rkEkj2ST8lkX6JeCpSyk2F21eCRu4briHEThpVIbK6vYr3hGt1V9lqZwgcXgT4SZs7mhGgvys/Y/kr3Z+jSYKLrAFyBPyXO+/Ip1OnnnwiE5WEDMU06rjH7dwLNbW3t3P+DyO+kGyeUwaRAjNxHP3AYKAYbG5sLqnM5OPjFvPwF66FvJ983hMjocjNt95O3oe3b+d04NUrlqu6B5tWVE9kkuvEE05grvG2bduGM64uEizlobTu3rk9Usg99YKOpkSss7v3kT0DA0VvV/9wuJhdvUiYki0eJbk5Q8AQMATmAwL0eOYWAgKOMysbylrZ2rpkITeU83bu2JYcHbrogvOVm4tKj1CsI2BytrdGWbI0MtQ/wmbOonaKussM5J7eAY5HWNTSIZzOVwkOlC8UC4GYvpxtqAlxMNHa5Q1tTc1dXb07U97DO7Zns2mO/pWKMDjrjhskr1TObZWMgJUdXiwU7O/tGRopjc1SCyLTOS85NBgu5k5Z4R2/bgVbY96zacej/V4u1rC8o6nRbWbJWmGRbM4QMAQMgfmAgBHwfHhKM60jxFZ+wPwVmuNPKUS2cOLI+/CG+zYO9fcvX9K+epmXxRwsI5kyR9qlxtaMkuzVRz32jsykkv2D6QIDpi6WNN29g8F8aEnbYlkNg1w23JBs6MNuo0rW8+S9+rB38rEnMrx63Y079/T3cdz84jYU7TEnOUpOyoWDmxobCrl8d/8gs4HlIGFMyzmvp48DhQLxSLGOceIzTk7lw7dtfOyurflkIL66o6WB+cukLu2cXJZnfw0BQ8AQqGIESr1xFdfQqnZICKDUKsPpTg74SyboaGy0gPrq3XjLrdifn/zEx8N8MoxKAoZJladdUkiR26VtLcxP3t3V4+zTEgJZ9w6MBgqBxW1NpGFGMh88bsFMjuMZZAurrExiOv/Mszk47zc3/CGZz8Zrwm0NrkWOLElPmWIKl1FbcfxZu3IZVu7Htu+ieiIR4QFvz549SFza0ojAU4+vyxUCDz3Wc8em3V3D2SXNtWwDLbOtzBkChoAhMH8QKPV686fCVtNpIuDot7z6qLzjEjOt2EMq523eM7Bl67aW5vrHn3kCXwVoT/ZedpwnpIjDmuwofPmiVs7L29XVL6ToNGC2wRoazsDhrXVikZYNqGSWtazSwWbsSLXIvGiU4JOOrVuyaFFXX28mkG9trmtk1w4RLjVDwZZ3ArmjTlI9/MetW8NZCpseeVToGa2a1bVRb8/e7lwquWbpolrPW5Rgz6xjBzLBvz62hxLWLWpGLaZcoXyRZc4QMAQMgXmAgBHwPHhIh1RFYVOhOV8DFmnMXYbbot59GzflvMDyJR1L6mT9DBTqTM6ihjKKK3yKadeN+DbXx1mf1Dc4QqhyMMbh0XQhVAiyaJhC9EMWGFC+VZmUBOEreo013opF7U1NDYVCpq2hBk1VSmEvTLZWzsku0HykcHf6AtmXL20v5DPbdu2hIGQMDjP+y3UkNTK6rK1R1/mcdsqpoUjt3v7Bmrr4ysUt7IzhsWLY2NchaRdDwBCYFwjMGwJOpVIAmhcFzUsmk1yz2aze+kC7rX29np4eDeFWE8igZrFIet1WyU9/9HugLyFQoTGnarpbCZTNllhV9Mebbh1Npi9/xqWQIucWsOFxJCLKMXTNCeqSjXBW/XpeR3M9e1d19shaJLX1dvUziFzDHpB8h9j9Qlm5UEQTpix24mCMuSCrafNy/N/Tn3x+sJDkwF1WGfH0sHXnHN3GokGIXnbFyudDQVmey16Wxyz3ErWxzq6efnao4pTD+hgEvGnLY02JxHGrV2Qy8q5w7mnLcyMjDfW1yeH+lR2trCpOp9muCiv1vPlKC7jmDAFDYAEjMG96q5qaGjiYdSsshqnlIFjO4RkdZZouFJvJZEZGRgjBw7W1tVUfKMfp6DxeumZ2FY5EInV1dRq1UK6yd7F83B5YjLKicgofi7k24D24Iz+YzNY1NurhgKihBdhVHUwoKWFtSc+3pKW+NlDM9w3La5CGDIwUUvlioq4WOiwtKxIWdzOn5U0HldsZhNmJueitaPGWNCbS/Z3rlrbLnpFwdl7O+qOcIMPIFES+EC8AcvwRrF2fiOeKwe7+Eq/zutA7OFLMZlrrErGoaMzHtHjHr1g0tHfb0tZER5PsPh1LJDKsAzYlWNA1ZwgYAvMAgXlDwGi9cDC6bENDA6QLDTc2NirjRqNRwgGbmT4wcW9vL37SqEKMnwTKxL5yPA+ezGxV0VGhI0N91u5EPfjP8+66fxMbLK9Ze0wrBtySkbpCZRb9t5QYUlva3hQoZNGAyaijwl19g+wI3dzcRE0RTRqYOCysKocHYeAuQt6EsjdGQUZtn/uU8zln6aS1y2pdRQoSLY5Dc4XpnVMhyFm6ZAlzqHfs6aYs4kZlE4+BYCDQ2sSgsEhlIvXj1i6KZ3pOXN1OehkoZidIlHdzhoAhYAjMEwS0U54HlYV9qSU7CXNVGsYDy8K4p59+en19/S233EJIIpFobm4mHMZ12zwQxvwe6ZcxQaMHy/3CcY5DMSjzt9xy/ooXHn3o0R0ZL3zSqaehUObSI4JKtILANG8Zq8VtMXTTrr4BlGRha8/j4N5iMNzc3Ihf2A+cRTYTsIA7ws7QzJB2nCzbQMcL3jPPOfbVz71kRZMcGkwVAhxUVGJusmHCLo0/E8uHzTo4qHjL9l0YwBHeNeINpwuNdfUNtSWdGBvIxacdc9n5x1181nHIkcMbAsGY+5KUq2x/DQFDwBCoagTmDQFDoui72JDRfZVQoV5s0R/84AeXLl0K43Z0dAwNDUGxODVNw7iKPbE4TNCLFy+u6qdxOCrn9ExHcUgXhuQDpWFK3tM7kMoW1q09FgaNx2RUdlz5ZHSMSiDfElb/1NfWDCczHFyormdguBCONbbUMfqLUKFuotBB82HYlZPuB7KZIscTYFBmY+aM18jogNtaGX4VimbLZZJjpWbAGSWYoBCWbBnCRdTyFUtRZ7ds3UGaXMHbviebD8WWLFpMXjWTJzzvCcc1vOaKCy48bTlpoonGLO8U5gwBQ8AQmD8IzBsChk1laannYYLmumvXLpTda6+99mc/+xkcDLl2d3ejB6Mcy2QctKhQSJVm9RPOEHJnZye3C8kp41a2mBD4F13WGxxJRqLx1jaJrWGPZHiPgVk/Lb6xG1Flm9kfIxDe3VVK0Tc4jC2iqaVJJUKNopwqGzvizYYgyzKLp0ZqvVwNhwKje7s9nEmOeHaLDsoAMoPU7LzMMqgSAcO1HDK4a/ce0lCnx3Z3BmI1y5Ys8U0Y4VyO03/XJAIc4aD7d2TzEllRZb8l5jEEDAFDoBoRmDcEDMVCojq+C5DsTgybfvrTn/7Od76DH3puaWlh0Lerq4uRYBLo8DAe5mox9EsUEhbcLGjaDyOx6bOvpMotod6DD/WOZvIr161pcAquzM+CB90kcxdPEuhszBGJbZ/R9F2dA2LR9rz+weFssYAJmu+QKLUEKftydZOiY6F6lNJMapgpyl4gGylma9GR82kvL3PlJLkcRkg+NOBymS4cgR0dXk2sdiSZ7usX3XhvD39CzY1NojFLzQrF4T4vNxgY3RXxBkiQYwOvMGPALr9dDAFDwBCYDwjMGwLWpUewLMyKkRk2fdnLXnbllVeeccYZqLbovqrdKhmrEgz+/f39H/3oR4855hiYA7dkyZL58FBmsY4QnHwwHcCRTGvi5F2mHWeD3oZHHgXHU9at5m2FWcmZNPOcOLFPBoGFEvnPlpMBYlhOVED9xZDMcUkcx9s9NAp/QrIjydFiPteQqCERsfJNQhXljxORK2YoiQP9gjK9mTixMxehXtldS6hd/hRycrYe6Qv5IsuPEFuQKwFNYa+uNoZa3jmYTAe90eGhUCETjckxENIQdOj6Ok42ChSKbIFFlkxWKoouTQJzhoAhYAjMCwSqjoCVaFFkr776ahYUMdyrDoMzHgzLDANv3rwZ3ReW/ed//mdQJgscDCVjo8aPh2TQLVovxPze9753+/btzN7q6+vjjJ158VRmr5JB0Q2LoWA+B0eO5oOsoR1hT2fPu2/b7mzRO2/d4hbOyvVSsSiLe9yBBkWZRoURP+WF80G4lcHh/rg3yIHC69ccm/ICG3fuYZB30PN2790dCeZXtdYHs1nSCfPVurN4KSngtQSidTL4G+SgQ9miub4eOg+E4sLrsmmkbHoVjYSdls2U6ZqCHBvIsb/CpuyxRYpjlzYXMqm7dvaMUNbWhwMje48/fiUsS4o6kgVrvXBDoG550YtTdJxhZuHmcVr77MFokgwBQ8AQmH0E6Oiqy0GfVAhF9s1vfvNLX/pSeBSTMqZjZlGhzmIFhWKXL19+33333XzzzUzCgnpJADdfeOGFV1111Ze+9CVszmqFxmSNg4z1Wl3tPGK1kcnGAXaRFIIKBGWiUk28c9Tb1d1VX59Y1gIxYtBlXJatN0QrDciiII7xlW2iVd10c6uy8UhDU2NjKpftH00z12okCVsGOCOJPTQ4cxDZ4jBkB1iHJFxc8cVyJ+w6DVl1X2Jl4a84UZmd2bgQDIfwuJMXsCVL9IpFzfdtLD7a2XeytzyVGq0NeYkaoW7aQ3Hu1AdInE9JNHZoJ9MPKN/ZX0PAEDAEqhKBin6yOuqHeVmVYGYsL1u2TCtFICRaWcF3vvOdH/rQh9igHy15w4YNz3nOc7773e+effbZULVSsnI2ZKBO8+o0rko5R79fTL6wosx0Yt4x3BkKBDdu2pJPja5et7qhQeY6C32ClyScFA+HfIBx2VZ2i+Q1CG7uG5LFYImaMApyuDj2LQLtSUUcNNDtvsWbQJ5VxFAsVu5j167x/njL1u17ugdPGUrnmxqa65vQtMUVcgUOcsLjyNsF2cUQMAQMgfmGwFjXWSU1R+WtrAlmZHRftFj6fQaA4WbdBmvt2rV4mpqaVNmFPVCaV69ejfpLMl+CYxUPIVAvfn9mlp9gQXhk5pIomjxs9ozMBryNDz3aFI8et2YZMTLcy9kIzEXmeIZMUfa1kmlPwsVlLi29+jQ3i413ZIANIr2egRQM2FiXEL16pqSr4LsJ0HjRwYVPKVTLW7VyEbedfQN7ur1MPtjY0Y6dGe6HhN0+1fLVZeoV1zINa75SbQk3ZwgYAoZANSNQdb0VDArjAhlXRnnp3NlREvpUWtWRXeY8Kw3rwDAJSH/CCSegKONHAkRLRqzZaGl41AqNB1fND+Mw1Q1YYFmMujSeWUzQ55YdnZFC+tgVi9n7kZFgWe/rZkqXtpR0FFj6Zghg/A+wFige81oSiWwyNcDpvAPDgNna3DSbgBaLkDoCKZpKNTd4LCTjxMPNWwdGssWG5jYC1TAue0ZjKsdSXsTsLMc/4Cp2+3L3djEEDAFDoLoRqDoChlnhS0Dj6m/mDBnDqaz0pdOHjDUBadiLA72WmVZccaQhCr5RNRqPgq+8uxBHgt1OGiAjk42FSEXd3Tnk7ekZ8FLDa5fI2bpimya6mEMbZhqW6p8Spj7JR2aW3cq0qaXtLWzI3NntdfUPF/OFdkhy5k5Hf0v5Vf0NBWU7aIqmIlhCOtrbWSt174ObOP23qaWdxymDxiSQ/bFgXwJkcjUcPPNaWE5DwBAwBOYIAXqz6nKOSeXi0yf1g4Dh1La2Nh0JJlaNybA15KpHLLATlu68wS0TnjUXKfH4ovS2uhp8+GvDpstKUEx/xvPojpGB4ezi5oa1rc6AKxWQeKzTZSekLC9BOAmEDYOBsAzCL2tvYz7Xzq4sBFzIZVubZBEwDoQrsa30u/h9L5N88dB+lfixiOtMq1XLl4Uj0Ue3bmcqdccisUhLzeSZispu1LsvrBZiCBgC8wiBSfrBua09FKvdNx66dYiWK+yru0BjfEbrRc1VAlY+ZioWdVY/VmuyMzZMCLqyr/tqo6ZADJrwKLrCWGWXzgrJov6iVh67ajnqbybnDbtdlIGvnEo8/FcudNZpvMwkl/iOhkSgkO/pHxlMZZgw1eDWDU9gX5JNHWdfdZUVvFJV7MnFQlbONOQNYFFHWyJey6OvSyQYg9DAQj5bpl44WGrlO1+aH2IeQ8AQMASqFgHXrVZZ7aBSnzihXmVWVXMZ1mXcl/rqrVa8codnrNbk1ewQQ5W1bG6qE5KjfYWqOMuABb633/3XeKLh8WefOTKcrw97jbUxj807A2L89XeSggorvhmsTwoTRWB7U30iHN62e2/3cLImGmlqiJOMB8QrkWKuLdRHNnlrsYKLIXyCC2LxcEEcfpRPxFju66WT3knHHZtNDjc11OazqSUdMbKNjOZoTjlzRR3LQfbXEDAEDIH5goB1YfPlSc2snjJmyjApFn0oLVP0hlLe8EiKAy1WLF3WEGeDDGdqjkRZiwRDiz4Jy+k4a4mD0TLJGlLSlFOBC/nO3sH+ETTgTGtjw8yqVZlrvBJL6XnK43sZj3rNdYFoIFtIDkS8bEujVLUhztsAOYT3ncY87gs87qayDPMbAoaAIVB9CFiXVX3PZPZqBFOxyEdmK2WTsBc7TG3vSo2MJOviicUdgRh7aAjhZr0QBOzmX4lqKpook7eEkJ0f9dcdkSB8t6S1OVQsbu/s6RkcxQTd0ZKQHDNx4754Tvl1IejZzMcu5KhtLOS113tLm+OhzFB7XbSVnSbd64FbJh50NnPqzBkSBKs0xDhJM6mP5TEEDAFD4EgjoD3XkS7VyjtiCLBuB7IKFRk9H2W3x42bt8oJyqeezIMXg3M2JacjiJYcgrvKbFr6Vri1S8LDOMflXkdztCYU6eIchnQWO3NTnZ9FU838KsPGjvLZjpJDFSBgPrWcS9iSiGWGljcneFegWuWaUVOot8S+pSqO1X/m1bCchoAhYAgcMQRKHdoRK88KOpIIwKkQMPwUjobTySRrZu/+66bkyOiZp51GuIy6FmFfDkgIcZYBFRv3bRBac9TmLpKWU4FrMALXZgqBTCCUqI2xD+WhOGT6bmzeFjJFrKx6ok7HLW9b1VJz3Kp2auv0dS/Ksm/Rejl1OIhhnIaoc68LiKyUWo6zv4aAIWAIVB8C0u2aO4oRSGfzEfatKOai4WDS8x7ZtisWCa1aKRPZZKaTrKYVJRlu5m7MQbaiDkNmQobqxOAb8hob6kKZcDEUbWpoYptLWRd0CM6Ru+R387ZUCXbiOB+Jv4Hgk889vSaSP/f0kxIo8rxP5LLRsDtWskI9H1dLl9suhoAhYAhUPwJGwNX/jA6phhwNVZBTCvKxmppb790zksqtXb12Sbuos6IqCvuyNslnWWivcrewMW2S9CRiMVJTfUNkSPYqY10Q+2HMlsPw7CqDPHanpmLsXl3kzWFNR7zpwvNaa2Xqs7wiuC1FMtk8Or2v+5ZfHXw2n61KmRxDwBAwBA4jAn7PexjLmNei6dTH+nXx6dpTmEmOrh1xH/jNpZHA6Td28lwIRD4fhLN5JJZi/XDrf0oMxHaMnHjvNmX0c2l9eLrwVl6UyUg+mLjt7vs5pvHEdcub3bGBDPx6hbCXDXK8LhwmNFYobetYboVwrg7zasPIUVsTSnjpWG6Y9WBUYAYNVhKlCKQrd5a/hU6rlfIoVLbl0Pq3ldk3OSpLwMkYjcqLo+Yq5yVg0gVOhJszBAwBQ6AaETAN+EBPRRjKxdPLy6lCwr4uQM6Wz2bDtZ2OetuZspsvxGQakyQqU4PzHuRCFi2BrOOohFCIFoaDffHjSRc9VsKyewbTldBSRUvMenUcec+fkQEvzgH1kUIgRi4cNBUuFgIBzvcrcjhy2ov0e96dD24dSY489dzjmuVIA0mYjzVTY74EYa0G07SoBkFIlwIicg3K2X8sWOIkJSrT3p5YvPmRvpHRlvaTh908KSlvqm5s7VBFa6UQR7rUozJYNv9g3FcdfiZvq99VSrzK33jGJJR4WRPa1RAwBAyB6kWgsr+r3lpWWc2EMgOhMCrpD27s/cYf9vbnGByFtwiXqJk7mM8xOJeM7M0sJEkp6Nkpz9u4xbvm63+6+4FuiJBABnRZxitKcGrUq4Wn0INlXjMhfFw9GFLNxYJysi/Z7354kFN+Vyxh6VBI2LdAWBY5fMTpzo6udLl1hCakCB87f4ZSXfCKpe2J3EA8N9TQ0EDI9Btc+soh1f+IaHFEVX4kARSrH1cLTSZXP696XITmHUtjPkPAEDAEqhkB04Cn9HSc+jsxJf39r371q2Q2f8WpVy1uCyTT6dqamomJDnYP5U2gFlVAOW+gfyQbS0Sgnwce6vnd/9208YGH+7s7H7nvtitf/uLTT1+l9CyjsEHmA3PnzLaTFZcrePmgd9sddxay6dNOOq2xMcx2U06FRuGV0mBoDglW7hcBYxWCXmmluJqIvA1wv7SjvZhP10aCS9ubCS9FuzR2MQQMAUPAEJg6AkbAU8fKkZVPTmibIa9/cChbCPQPDhTbmmRMuIK7pi53Ige7kVDKSSQif310109++dsNGx4eSedXLF99+klPuvPG6772jW/2J1983nnrMAuT14sxJjvkRcZRobsR7VTmKQe94aJ3/wMPBfOps049jlzszhFyO2/w+Kk1Qtx0ZtKPMW65/ljd2RpU0iCTWrU01GaHhwrBUGNNhOw+HuX09tcQMAQMAUNgSggYAR8cJiEzeEa4Th0B7NYku0XEauOJWHzXnr3FtU34XTrHfeWkM/tLUaibybz3gx/++Pqbbjvn3CeccfpZxx938vHran6xovUrX/vG/3z1G6OZl178pPXMEw7mAtEgg7VUUYqeUDxcC6k+tGWwf3CwNZ44YXVChYcCEDFzr1huG3TWZR0Gdo0c11jahLocHB5Oxutq+bp0NAUXtSRSuUBjLaUaAc/sCVsuQ8AQMARk/o25/SJQ4jSNl1Pr/ZQczxcVkyxhgdC27TsK3nq0ymw+F5EDbafq0DsrVM6Sl0LQSvnc/+DW+x/afNrpp7/tLa9rSXjZvMyEuuwZ58Gpv/i/m776re/kci943sUnFvKBaAzTtyjg6qg2H+dkgS8R9254CEX2xGNWtkZEyXVFYH+m9tmA7PMsS3rcV4HISV2hsa42nSuGwgFmgV3xzEuz+cCKVskyjdZOKtgCDQFDwBBYqAhY/zmzJw9uwSRrf7imMp1dfVAaVMfMrDGOnqpg4eAxh/3Z2XudwGB9c1vbosXMBmawti7kjQx5tUHvisvOfenLXt43NPrr667f1uPFahj9VSoULbiCfbmRpUb9Ge+eBzax08UFZ53CZC1YXFlZ2FMWLwlzu2rv58vgJn6LXTwvWzRT0iVPOvvSJ58lw915n+nHWmA+Q8AQMAQMgakgsJ8+dypZF0wameGkH5RgcTIxmBnGoTDkF88WCqMpjjnwhkYhs5m5cU+BopDG5OQ779rQ1Tt48imnNdXKgYEQJ4cTQIGkPu20xWedc/5wKtvZM4QBOSv8WVJ69Y+TyIU9Jr3+EW/nrj0w6Enr1yCEUKZlUQRvD24nrIpqy5xnbSPyyh5kyxxpZm5lKB00WA0VyBbh8rg7IGFmbbZchoAhYAgscARcR73AMTho80vUNi4da3GzBW80LRspb9u5B7KqjY/tzTQu6QFvKlhuLB06KWXe+8BD0Vi8rWMxEfGYrPpF++STSnt1EaZosQ9GaPfeHiSIDiu7Vojjj/9QodhRz7v+tntqampOXH9MU60M/OLGTdgqyskHronyYoEbY3Nux2i4WFNbC4sz6kz6REyUbjzmDAFDwBAwBGaGgN9Xzyz7AswliEFRcB7TnlEec16AnaaGs6pTynVaDo4TwlPSxFcUyfwdLniMuUbj9Y3NzRQJ28GdHBEoHkeUEDCjzijBpGczSZEg2zmOc1JJz7vn/ocymcw5jzuNvHImkktCuKuq3AnPlvLp33LkhNY4WzT5UIKhXv2UM44r124MAUPAEDAEDorAhB77oOkXXIJJCMYFYZEVQ25RyChfDO3tTcFaEN50nWNBlwmJfBz7Eri7qzicytQ1NbW3iZ7J/zAqcCELB9eG5La5uTlfDPQMQP2lYWMtuqLCor2ybcf9m7aybPfxZ63jYRfzBfISXnrwsqUWp/oVRDMmp1ubVJZQrpqEE00Ot1ZY6ujmo+ERvzlDwBAwBAyBmSBgBDwF1PahGaEmDsKTkVQMsmEWyu7p7FE+2iftFORDZMK+yBSi4z/ebTv2jKbz7R1LmXWVKQjjirJdzHCAYMzNyWpraSoUCj29fWjhIcmHk52ceaKlO0e0mx/Lp4uBZYvaG8NeMp3kSAYSZOVkQseeAUZyoVXmQosWXX6BoH1l9nVyJ7uUE8yswZNJtDBDwBAwBBYUAkbAB3vcPsH4HpeDvSlYgwT9BkMRViLtZinwFFhr0sIclSHL502hxq3bdrLB5aJly4nNMNBMTqZLowQXs2KL9rzW5gZeAXp7e2X/SXV4yn6RGZBNKB/ZubemoWXJombsz0XR1+X8wFi0fI6RnmlfEN2aHBUCVCJfjwN8NI1dDQFDwBAwBGaCgBHw1FArDX+OS4zOKDs6OuLcvXdvWSUcl+bAN2RRzhMNWAzGIoMQiHPbjp2hcGTVmrXcUoI8J44OzKMB88lx295cyyKjgYGBXMUs5oo5U1Iycnb3DYYiNW1NDdA2O2VS53QqWRMSRnelK7/KeUrcljVgyjRnCBgChoAhcHgRMAKeMr7l+cBKmUJX0JbQI6cgBbp7xAQt/HmIDltw3ktlvZ27O6O18WUrEsirialVGQ2Y043gWyHK5mYvEomMjo4m0+PKHdOjHZf39A1nC8UlbaIBE8XRhMzUUtZFiAhCCUasLAiu1J/HOBilWRYskdn/kLQitd7Z1RAwBAwBQ2BaCBgBHwyuEqFBUXBSWM6JL08AFo20UMgEgqOBmt6kG39Fjz2YvMp40MeY7J5BWM4dYvVvIYOKy6rfnuFkIFq7pF7O45MjCCFZRAvfk6xACGO6gUg0lcvns8LZjkohWf6KfuxkyqW/rydQyLe0tssbQ7EYDgdj0Vgun0MY0VLbknIviV3l8ZRiKqs6id+lnl6DJ5FiQYaAIWAILFAEpNs1tz8E4LuyJijH8mYCciAuymKgmAxxPG4hi/05F6nbnal9rC+DjTeel60qpu4YR04N9bI7JOQ7MpLyAsNeYCCSS29+aGeqtmnxuuNa2QArJxycKbAzB3tPs/QI8g1Gs7IqadGKFblo7OGHHmVeNBUbFRLOFVL96OocBKyVH+remU8NdyxrR8OVEWA5MiLI/G0cVQ2h+MroL1tJy9rgcuX5qzQsV3hWqXasXRo0ScRYEvMZAoaAIWAIHBgBI+AD4+OsuzCNqL9MulJFkxnLomgyIhsKcapQTaiuNeVFsBsLK4+zBx9EONF19fV9fQMDI16sPu5lUxzRW5OI7di1l3lXi5ctlYHbAmt/YVT+RIV95Y1AjhGElWsTdcVQKJVKESQVEp7MB5V7XT1kb65MKh6NhEKu5jJmLa0IcIKh0qqwL/tJYmEOQ88iQJzPvnprV0PAEDAEDIHZR8AIeKaYMhrL6iAsupFQc1NDPpvt7R/lVINpimN4NZRobg4nZOcNL9ZSDCbSQe/+LVuK6fSJa1dDtGFZ9ZsPi+VZttpg5bHwpJuW1dbSyAKk/oFB2BdeliRElGdTE9Lbn8pmsw31dRwcSGSoHDVxww5kFoNymWbtLbkhYAgYAobAjBEwAp4adFCX47dyaggwxOQmltBGg8WOlqZ8Nt3Z1RMIiX24nObgfyE89tHY2Z/ZM+oNi307kY00d+e8HT0DgWzuuGUiK8Bxg0XODRSq5hykQCjCAUxKlW0tzWi03b19zqJcLpiqChuLytvZ1ZvP59ubm2IMGFdUR8zK6sY1qhxofw0BQ8AQMAQOPwLTYIvDX5l5UILgpXoiymiBTRnz4WBxaXtTPpfZ092LPXdaSiQc2T9a+OQ1X/nEF3+YD3hdKW/E8zb3eP3pQmMssowBX4oLsPZXRnTzXjDNts2Yn0uqrreopYEJVl09JQIusSrqrZuwjfl5594expfbW1swZQuXFwsMWmsNK+pZUqnnAfpWRUPAEDAEjiIEjIAP8jDLAPHX1xtlQjK7MmdzBfivNlhc1t4cLOQ6u2VTKlVGDyK0HE3ivQPJO/66+b5Ht33zN5uDNd4orDns9SSTqxZ11JdmRTkCducXQdJ52Q1ahqSpUEdrIljMd/X1VxA/7MuyIqkFldnd1cMJvu2tTeVWiGbMZGgt3/0ZiylXyv4aAoaAIWAIHAkErP+dGsplU23ZdiubTEHAQS9fGy4ua4uGgoW9/cPMhiJ86g6e3NEzXLd4Vby145s/+vlODNFowHt6M17wpDUrMWeHS9tPyt7LSIYyueYYB3Zaa3uTFw5k+wYH02V9VtLxnuC0XAi4e3CYtcItTRwlLMyLvZq6objLdayWfAfsazAGh/kMAUPAEDgyCFjPeyCcy3SraSrv2BbSy+TzLOOpCedbGrxIoDiYzIy4HZ0PJHF8HEJYQDycD3b19jW3d3zrB/ftTXubt++KJxKrlrTHGPKFcNnpCo0W2pS1wI6D0X8dATdGPQzgo6kcxxETxbOUHLiyBjyczIVCwXgs6tiXTFI/2XXLObL4M7YcQWuwXQ0BQ8AQMASOBALVS8C5XI5D9LgqDMPDKIcl7U0D165dy4gmjsNuuX74wx8mATtDqYaHf4xpnM5HCOog1xk5TLv8k486x16hWDhU4+WXtsj62gce3soOy2VdtJyu4i8VY0pURYCos539I7lgzRmPO21wqHfDAw899LC3Y+duRpRPPm5ZMUlxBS8SVeLVExcoNxRyc5rzXg0bUjIROhbfsqNSKuqu1I7/m7duT42MnnDsIjk3gt06pPYSNc6VlftxgXZjCBgChoAhcJgRqDoChmiVOFliG41Gw+Ewt/39/XV1dUAxMsIsJfZTzJOMBTZf+MIXuru7N23alEwmX/va1xIej8d9xILl1TYI0UDk+LHT9MBdglUJL2ZgYYJmZ6l8JhrI1YW9prpazk7oYVuL/cvlLYEq0Rx18DGJ+5PZTCFw2sknvvz5V3R27vrfr3x7oHdvdqi/OeHFsEFLgWySJaXznw8EL0UwI8stBW6qjzOxqnsoqcRf2i7L6bi8sGS9cKwmUhvzOFIpIgRO1gI7SPOH9C6LNkheL0SsOUPAEDAEDIEjhUCJUI5UcQcvB6KFqNB94VQolgzcNjU1ac76+no8sViMZCi7g4ODra2ttbWcMlDT3t6u/ArJsTcFWrISMEJIptlJo56pX2EtcaImClbuVhkQAs4FhIDziZDX1tqUC0R2dR1IA6YhOIQI9ZYHYnf1DrIvVVsi/OwLV5539sk9ndvb49FT1q5sTKDpkpazevnDAYSSs1QZUe4ZfpbpWB0tjflAeG93P3XCViDMKrwqRNzZ72UDoTrM2W4race/on/77yX4xVXINQ5WSOxqCBgChsARQEBIpQodui+6LBZj6FN3eqKSabZIdk6JmQTXXHNNIpF4yUte8u53v5sYyBhWhnrhYygcRZNArqp3oj0/9NBDKmHaV/apUAYu5ZRpTth14cZYoMCmVO3NDTkvuKcnuT8O08r45cLESoS9A0OtHS3R9BAK/qUXnr2krbZ3y0NLG2sgV7fcN1xkn8gQe2CJOi+M7FiWzKis3LY11ReCoT29g9JUIdOQaMuOqDu7cnkIuK6O6rmMBUwHvCCEgyE9wdBVlZXM7uNeL5wMuxgChoAhYAgcCQRKttkjUdTUysCMjINiYSx4FA7GkdXXGuFjwiHj973vfUuWLGlra7vjjjs+/elP9/T0YJEmFwZnTsltaWkhF57/+q//+uQnP8mxfdyiK0+tFvukcpRGqP/Cgi7JB7tuJCjHMLQ0o4n27u0bKnqTF0H9MaojQam3pAp73q6enoaGunUdDXUF75RjG5541gkP3vvXJ5x2AgWh0bIAOBKIyg4cUCulMxdaa8JiYARyJlJTfSAY6R3A3iy062iYv8Kte7q7WbOE8QBRLhOTuKhy6Q2BlCqJlOYMAUPAEDAEjjwCPqEc+aInLxHNFfUXiv3MZz4DuUJUOELQbuFU/CeccMJf//pXrNBXXnnlZZdddu6557785S9/85vf/I1vfANuVrYmparLeK6++upHHnkE9RebNp7JS51+qGjA+TzbWjD/GRWTTalYANTZ06+a6AHk8YpAKzRBOu9lctm9e/esbm1oDmbZL+Nlz3/qG//2pZecux6ezBZFU3WnLDFGy4pf1FvJVyoigK6bb21uLAYDbIY1Fq6ihYD7KKm9vbX0jBn5pdzyFOix9OXKlPPZX0PAEDAEDIEjgUDVacC+qfZlL3vZFVdc0dDQgO7Y1dUFua5bt67PuZNPPhkVGZIGIYgWln3uc5/7tre9jZlZEDPpUYLxKNVByY2NjToPCyKfNqjQnaPLkuZYyi+kls8VC/lsKCjHBULAsOXurm7PWz9pET7p+gSMqXwoGY4n6kf6k3VM6iokw8FIW8xbtn4R85+DtSi7wrGUjyqM8hosBsMhtsUa02EZH25tboL493bLacR8nJLMX6lsT18/88IWLVqEouzOQCISa7OkEiKWxOYMAUPAEDAE5gyBqiNgRnahKKy1rDICFVgK/+rVq9W/dOlS9aB9wqxqjuZ6zz33EA7LwrUQMI5bpTqYT9mXENWP8UzDlay3kgOvmywM+8qc5EIuk2cuVFBIXWeHDQz0YeSF21wmvxBZwYsG63gxyN6QGLK5SebzI6l8crB7UUtjmMMAs8FQkK0mA3EWGYXZFzoXpkHsOS2ZwYFcEkvZGbaykt02WI2UaU3IrO++oWExLrMKGCJnaDoQ5uTEodF0MV9or49jwS8WGKGmqmySJbVCCH+5SkXFxx+5k//mDAFDwBAwBI4IAlVHwLTaVxbx+9zp7L3Ca9AqE5I2bNhw8803X3jhhYxx4kH9feUrX9nc3EwC2FclkJJbDdEZT3o7rSv0B5kLZ8qsYxmWZUoT/2HdYi4zlC0E4k1sgLVqTVswmNuzZxspOCcJbZUMuWwxHA2kc8kwE58IlvpEc6lsNFGXpSmx2M6ex+oDo6vbl/dlvbZwXS3xkCiHGhbToQCsmAsVWYMkQ8ChaBjJHPqL2JpQQHRiBngL2WV1TYlYdDRf3NHjndRKrbBThzJpbyTkbdm+K1QsrF3c7KWYlcaDZpusiByu5BowZnjWdcDawomvDtOCyhIbAoaAIWAITAOBeaPz6AwmWga/wqaM6X7zm9+86KKLUJQZ/X3d6173kY98BN7FNA1n+4mngcTkSZ0mLdyljn2k8MoiYNEZC/liMFqIxISTw15tTSQQyA+wP1Y5rUxVhoaLaK+FVC6ZSadg02hNLVeywKaDQ0PhYroOckUBDkCoXrjILKtcwJ2mIM+G4hwrc1XdmkA+UoRQqAw/1yfqaHLvgNuPksTFQD4YZb54JpuLBLz6mlBt6SikYCGIMuxeuTiVYYxrncjx24xoC+xqCBgChoAhcPgQqEYNeNLW6tIjmFWN0k9+8pNvvPFGHQaGkoll0Fd3zsLOrDO5JpUzg0Bh0UpXvldTeSjE6QfMVfaaG+r3do10dvWtWMbcMYjQac1wbxE6DUbCcUga3Zg3CKfTCpGOjqZYz8Q4N+nd/s0Elui1XCC3JedECh0TJFfYndOYWHzV0rR7MLV3797s2hW6XjkQifYMe9lMpi4er4+PWRF804JvGyjLtr+GgCFgCBgCRxqBsf79SJc8zfLgDKUNJlLBr+RW9sUDAcO+eNCMdScsJjxPU/xMkufyGczFYdbkOos0REhN9nb1lNXlksxQMMriWwzGaL+ithLNppAM7rINVv8giZhIxVgvOrVOkBIddsIgcrl2LlXpRjjeUXxHW3Mxn+vu63URhMoz7eljS858U12Ck4DVgZ5PwKUg+2MIGAKGgCEwdwhIZz0vHLyL+qvKLletM0zMDCyfV+AY9GO0YaZizVajSoRWEgczglhpPhUFMSuKtbqkQQnuaGlGIe3s6hX7MJopH6qJHhyuYTVvygulSVVgZlUkwDQroU+vc08XGnFba7NqwCUlWLhYouVkBZdMkiLNOQ1Q2aSghEWtTcVceqCfJcgsauISogJdPf1Mme5oa9IHDGI4fYNBzIxHxEuVsD+GgCFgCBgCh4xAWT86ZEGHW4ASLZquLiVSfc5fVgTvMktL9WD23JhFAtZ2TfqeovPC/H2k2psbYeY9Xf2ltwPh4ZKTOVMywuu0UyZjce/mI+sJE20tTTIzquzkvCLx+9xbjnB/SzVBlviCmLPbW5qChWxPnxB/Vpg5wIjy3p5etOolHW0krKReleW/sowTbTeGgCFgCBgCRxCBeUPAanAeGhqCPPDrNCs0YG4Z9EWl8ydezTr7VjwOSA/KE71T6ZFFwKit+GHQ1sYGlM7O7gFdqusOLyJtAF5kSlTfSKEtEcRQTng277HLdSHiDY2MBorFhvoo2YVPSS6zrlF9J2FfEiAKepbxYlLigrJDNNtBhwN5GFcIPhxBH6cCe7p7mXe9qK1RxJJQzOTiVAk2AlY07GoIGAKGwBwiUOqX57AGUyxad7ZiuS3bSTLpVykEjy7t5RbHRtBopQjEM0WxB0sm+Ljh2skTUigaMPTJp74mwmqjvqERoUkIVDhU/qPujnje93/x29vv2947JGHRGEQpNMkGGmwpGXeHJQj7Otp1HCkTrfd1Es+cLsfWQsHBCMmaEl5tyOvrH0QgEgjH0zc4ysBwU6JGqJ35WmW3rza8bykWYggYAoaAIXAEEJg3BKzmZRDxNV38vmIHv3DLDCyN1alYswAfbOY+jhnxA5dQI2FcU+l0Lp2qT9SyMQYJzjixeWRocLfTgOUYpzTMy/xs9sXw/vLXnTffdf//+9q34w2sDirRZO8wQpiTVWxJiFotK4+Qkk2HQrL3NY5S9nEFTkkeC2Qw2fMWt3iFbHpkNMVLB9yPeK7bd++tCQfamupKNS/nAR8ftHKY/TUEDAFDwBCYAwTmDQHPATbjixQmc2ympMydb85lDRJMyJLchrr6dCHYzygviieHEHNoIOumMAj3jYwUIqPFMIclsd5X+XskDVOGeVcgIxKwZotzbxIQs1vEVPF0ZF6WrGFys6hZCS1vAMiBa8ne2hRn782tO7zBjJi7UbhRxHPZzKqlNRUinHy7GAKGgCFgCFQHAtY/H+w5OD1U5j2X3BhipUlYnMfgTNCM73a0tqWLoW17HVXDwdBoSEzQW/f0DOeDo8Xozh7RohmmhTgHhlOo8C1NDdD6mJ5aHqwtFzfxr+ivSHUsjmT0a7h/cUtzNFbbO5Sq4dxCzxuG5guBUDFXL4uzzBkChoAhYAhUIwJjdFKNtauSOo2xb0l5Ve2zUMwzWSrI1phCwKinXnt7eyBc+9ieQRmnxeWgSOHa7Xt7UH8zgfC23X0ox7LZFUt1BwZRkPW4wLHHIAubSo5Sxly5DiG3lyThzMPSMNK3Ndd3d/fudkuQybV1J4PQYdYlc1qFL21MlPkMAUPAEDAEqgCBsZ6/CipTlVUoMx+Vq/BKVZnQJPObGBaWG+zOXntbG1tNbu/sEuIlIp+BifF3DY7mw7WZAFbi3RiRVU4PRxQHOT2iHsoUmiR0HOUSNNGVkpGOHSqVgJmGXfBYAdXQ1DQ4nEIAfN8zkGMAurmhUZTwiTLs3hAwBAwBQ6AqEDACnt5jgOEgSv0IATNm6/ZVZrgXezMaMLtC7+7pKzGp29N5iD2fR9OBaDwfijy6fReTpIjlIxqwV2xqaKQGJZrEoIxo979UrYn8STTsy2kTEi9pGWsOesuXLeE14N77Ntz8lx3dSY5LCgRCoeamBhdvF0PAEDAEDIFqRGDerAOeS/AguolEKNVxY8BFzhmUtxgWIge8tra2TCHQ3TcoG2KQJRxmTW/fsDeazgbijdlcfldnZzbnuSOOOIlhJMdukU1NpZcgKQL1FR6XzEzCmqxMKVfInjhWDGPkLnjMszpmzWoORX740S3f+u7DZ551zmP51kAwvG7dWnu9cnjZxRAwBAyBakTAuuiDPRUW+urOkOWEcB8fyI+JToSVB20LzEZuqouwTEhWIRONC8dTRRYlF3PZVMgdcNQzmMy4KDh2JJPJ5osN8RpGasceAwZqWdTkFjw5GVKY+5BGquL0Xv5wyxUDN9dlLcGPv/sFL3nO0wvJ0dtv/tN9t10fSPYtX9SW4RRgFWJXQ8AQMAQMgSpDwPrnAz4QyE0/bp4z+inEGfEKjK1iSR4thNggs621MZ0jRpYDrV2KEpse7O0NMvCb89gScjDv7di2rTGaP/2ENS0NiaHR7J5uKREJW7btjsbi65a0eUn2lHYFRYJu1wwWMMla4FKgI14XL1O+YHU5+9ArRINSYl1UkuFp97xXX3bC2173qjOPP6Z28LGawe3NsQgHEZozBAwBQ8AQqE4ErIc+2HMRNVOsvu6PvK+4NUSyHUfeUWRphZIzC8OaLY31qYGBocFsW3MkhyYb9npkW+ZCe2NtsqVh+8693QNeYbFouKl0PhgM10ejNSE3aRq5rAZ2KmtRpne5Al15ZZ/+JUIqw4JgEvNCwA1PkXeA+pB3yvHLO1ovP+3kE7q7u9etaJBNQHw546XYnSFgCBgChsDcImDd88zx1404ZCK0zolySuzittZcNr27ux/mYyCXAdptu3bni8EVHe1rli8hy7ZdezFdJzMeZyaSpK4uqrtpEuXLke2gp+lk0NiTPSlXLk5cfMFpT3nyhYmIbO6h7w/TFGbJDQFDwBAwBA47AkbAM4QY1XMCATN2izWYoxFYktTZO4j6y3wr8N29pzuTzq1c3Lxu2eJMPrdl+y5YMZ32GAJmY8iaCBOphSUrCdhn4n0q5xi1glTxUgRXPfeXEqkDCjEHNOCZfEfpfYRagCFgCBgChsCRR8BM0DPEXGy/Tk+FLIUvuXejth0NiWg4tLtvaJRZyowER7zegdFCMbS0yYvnG5kzvb1zLyPGw0nRkGujMWgSp1wucpyr3O9aQ8Zf3RGIFTSssSjBgXyenTpQn2vdmxWzvIKlEsYLsDtDwBAwBAyBuUbACHiGT2C8BgwbowDLDpGLWhpioeCOnv5kwOMootG0l0zn6uJ1rbVevNmrqYl29Q+wY3M3A8PhcGN9g1+8z75+yIE849kXtuVlQKZwcR6TU4g1b22MGpkzBAwBQ8AQqEYEnKJUjRWr9jqNI2Aqiw7rTNArOtqCxcKOrv4UJzREvV27+jO54uL2xY1sGJnwGhrqhtPpvX3ejj1dDP22tbZqO0WJLhuiVRvef/t5ZOOeGhTLR4d7mZmFP5dOQ8PFXE7V6/2LshhDwBAwBAyBOUNgXFc+Z7WYnwXvy5SQ3+KGmlAuu3eAs45kW42unm7262htaeFYhARnBtcl0vlc71Bub99AJBhpqm8gi+8QSGIs2/tK9tPsx1PIZlKowe5IpUJY9F7WI48Qsp/0FmwIGAKGgCEwxwgYAc/wAaBcsuEGU6AZr0UbZv0uRmACl7dBvLm+kXQ/JwJ73q7OPfXxxOKWFqIw969c3hGrjW7csrUvlc5kMq2NTZXFowRjl0agasOVUb5fNG//puQRlo1Eom6tFPtoFTjzl1Tx+oQLMQ6eiJfdGwKGgCFQDQgYAc/wKaBj6iQsOR/QOUzIBMYDXnM8zgrfPQNehg2f+4cChfzi5ibYFw5eurg1l093Dg71chZhIdDcUH+4HoCw9D5MPcO2WjZDwBAwBAyB2UfgcPX/s1/T6pOYc6cN+jOWIWDQhGjbWxsLwQinAmMU3rGnE4v0qsUdhEPP61cvz2WT2/b27O4bxs68pKWFwEN27iEiSHbN9Ff+yv0hSzYBhoAhYAgYAocLASPgmSOrBBzmNCLn0IRhPDbDWiynAod2dssw8K6unoiXX94qUczSWr0sUiykd3b3dw4mWTXEmuFZegCIcZJ0D+kSEzs+nq0SZo6T5TQEDAFDwBCYBIFZ6v8nkXz0B2WzbAjNiUfCrDg0YP5Cq8sWdQRCwd09PQOe159MxyOBlrjYgzkyuLnGi9eEu0dHh7My3FvHOQzTdBA5n0pHoeWPqr9Kxv61Mq35DQFDwBAwBKoFASPgmT+JsgY8JqGYZ/GPt2TxYszLnT09DAPnCoHW+kQcvRiadMcntLc1ZorhVDHEJtDx2EQ2HZM1Ix9MrCdG6JVbc4aAIWAIGALViYAR8MyfC0uGIFo0YHFOC+YSCXsdba0ox53dPY/tyXnhWHtLI1s045ibzN+VS5cEIpFcMBSLxdiHcrYcc531A+ni0at6ZqsIk2MIGAKGgCEwiwgYAR8MTKiMT4BzhzgNUBVWzMyO4TizyCsQyi0JfJtvQ12skE4P94/u6Unlw3V19W6qs1ukBAF3tDTVBgPhYjYWkQHb2XK+KDVQTzBTz1YpJscQMAQMAUNgthDw++3ZEni45OiAK1cOEdIyent7NVBvNXxGu1gcoM4FL5D1AjLdGaNuSE4AxBvEzyfAob3ZdCLmZdA0g6IIow3DfB2tXksikRnJ3ffgnv5czdJ1a4mPhgoxd5DwaccfHx3pjgzvPeaYZaOOyA9Q/FSi9LWAq/8GUOkxJp4KhpbGEDAEDIEjj8C8IWA2bhweHuZaW1s7MjLCLhYtLS3cptNpHYutqanRbaQAkdhZg1JOApb/MK4ad9F3JUhumW0sR/m643wFSW4LgSJ7MjfE48V8gWMY8l60qblZsmQGOAMpk/cWNbFBRrYpmq+NImY2nc/ElZ7ZLMBkGQKGgCFgCMweAvOGgFOpVF1dHQ0fGBhIJBLRaBTq3bZtGyOp0C1+do9iSS4OD7GzB9F+JTEATFmy+qhCzZSBYbZ9bm6KBgND/T2BQnb5snZEBCOM9xYYDF7V4tXH2CW62NZYz+Toiqz7LcgiDAFDwBAwBI4+BOYNAaPggj5c29DQgAeDM9S7cuVK1OJ4PI6/p6eHcN3EEZI+3I8KhVgJuJJ9pQIhmXDV1t5UWxPKjA5EAsWONtmdI59kWw45oBfGTYQD2eG+REiMxkbAh/tJmXxDwBAwBKoTgXlDwMDHoC/6JRQL6Sqa3/3ud5/2tKexoBa79Otf/3oNhBcbGxsPN9xqPp6gAbtAmaLVysznMGPFaRYa1bqqhGIRGBvrNIrwk8993Fknrj9x9Qr88+kBHG5MTb4hYAgYAgsJAV1DMw9arIO+OscKlZcdmL/1rW9dffXVn/jEJ4499lhszvfccw9jw4RDxkegPaoBB53G7Wux7AZNeLrIZlhNKLkxL9/eVIdGLAk4qLfoxTgv0PNe8MxzHjvlhONW1GMo9/MegTpbEYaAIWAIGALVg8C8IWC1LcOvTLlC5d2+fTvU+w//8A/PfvazYV+Gfk8++WRgZTAYkvYPSDh8QHP2UWkMeDyJwq8cBrhicWMxPVQTiq5b1lHScclQ4LTBZDBSy7mEJ6yoB3rOUZK1TeYMAUPAEDAEFh4C88YCyoRnHdmFiWHZ/v7+u+++e9myZRdffPHixYuf8Yxn3H///axKYjAYM7XOiz6sT1O3n9y3COzPHP27uNULZofjgczyjiY04Hw+6zE3Kxji1SHM7h05MUSnh1JwsPHvvhhaiCFgCBgCCwGBqiNg1EqcD71MKna36LWM7HIELyGwLAZn0vzHf/zH2972tuuuuw6j9EUXXQQxDw4OQtUoxKTnShqma8HWROFhFNmXfIgeUWj5XzGIy0m83GayOTi1NeQ1xQL9Ox593AnHECrDwpzXK/O1CuFgMR4WAm7QnaDH2nqINbLshoAhYAgYAvMJgaojYMZx0XG5/tM//VNzczMaI+SqRmbCUXlh3w0bNtSzvVQw+OpXv/p5z3veaaed9sMf/hD195vf/CZzpPGgAasVeteuXZ/85CdPPPFEJlEjZ+3atbP1cBz5liZdV8qMhMLQfi7vnbB66SnHrIgW0oEC+1PqdCvWCZOWpcKOkiuzmd8QMAQMAUNggSFQdWPAOtbLSt83vOENL3nJS3RFL9OeV6xYsXPnThh0y5Yt+GFoFNALLrgAooVxUXBPOumkhx56iMeHBHRfQqDqpUuX/uM//uPrXvc6ZmbB5RixFy1aNCuPOM9sK9TfoIzhViqx0aDsldUY8q56/rNRx49ZwcaTWmBIzM2l3SdRncuvPgSaMwQMAUPAEFh4CFQdAUO9cCckCsvisD8rJWM9PuusszAjn3nmmTymU089let999139tlnY3PGPfDAA6985SuxUcO1ZFHmJg2epqYm2Bd/pXGb20Nxsjsls6jY96NCCqSazuUDwRA0vH5pnbe0Loey6xTiEEcxQNRijMa55cCQcWXmCjnmNQQMAUPAEDjqESjrYdXUUDRXWJOtr1BY/U0l2XiSOhKl47jYk9/0pje9973v/dOf/rRp06YXvehFUC8WaSVscjFUrG0ixJ+T1dbWNlsNhYBV1UagkiprkKSG4VAk4OXTOVlilPOKyRwWaSKYgiU7V1ZQLhtYVqrOs1Uxk2MIGAKGgCEwLxCoOg0Y27JueoV1199PAyZm0BeLLrosTKybQv/nf/4nPH3llVeyJOnyyy+//fbb0Y9RoJlyRTLQx0YtJuJAQAVCw2xdOVtPxdeAJwiEa/kkomHYNRz0YrVhWBaudUZnKiP10iz6ZxwnT5Blt4aAIWAIGAJHLwL0/9XlYFDsujjIlcFdSBdahYnxQ6uQK9VlU2hUYfj1Qx/60KOPPoqO+7Of/Qx7NcZndF+lW2VfbRsSSIMVevXq1Rpy6Fd/DBhR/qxt6DWbzmVGRiF/j8VGhRz4QtWjoxlo2DEuAYI5t2joJSX90GtjEgwBQ8AQMATmGwJVR8AACNfi8DCyy6xm3dkKxiVEVVsIFT82Z7gWWlWjNFOmoWdom0Cyo/tihYaGoV5CdCB5aGiIjNN0QCR6q3NjcO13FnQ0TNGauliQVqAMN9SVDoco25wlAf/HxGkGuxoChoAhYAgsGASqzgQN8vDugfFXStbDkUipw8N4lJ4rJSgXQsNKwHo9sPDJYiuIEmuyDOXKml7E1sZjHHwYxl/M5QteOBTmeKRwrZwbAWsHojFUXdjbz++Y3GWX04U1lftjF0PAEDAEDIEFhkA1EnCVPQJf/cVwDHeWRnDV7Ayja7T7W9ZvSzkc7Tp/hYixxk0aOBZtPkPAEDAEDIGjGgFfNzuqW3kYGqezrH1r82EowUQaAoaAIWAIHM0ImAY8w6frE7AqstibS7rwDOVZNkPAEDAEDIGFhYBpwDN83hMIGCnGwDOE0rIZAoaAIbAgETACnuFj1809jHRnCJ9lMwQMAUNgwSNgBDzDrwBToMnJGLA/l8rIeIZQWjZDwBAwBBYkAkbAM3zsLC8m5wTS1RMJZyjRshkChoAhYAgsJARmk4BRCnWLDPa78LdfPlrBZAwY9mUbEBCEigtF2fFDt4M+Wpts7TIEDAFDwBCYRQRmjYDZn5lq6X5VbCSppw9xoMIs1rWqRE3QgCeowlVVVauMIWAIGAKGQBUiMGsEzL5UDIjqMb0cVURToWTdlrkKm33oVdJZ0Ma7h46kSTAEDAFDYGEiMGsEDCHBvpxZBA1z6BC6L5TMKUZHK6z+MiRtoFsH7M/HOlobbe0yBAwBQ8AQmDUEZm0jDszObNEMLTEAvHLlSq2gf57grNW3agTpIHflTlhwMJOwjISr5hFZRQwBQ8AQqGoEZk0D5mwiziCChtX+TKP1kKKqbv0hVI5XDezPlQSMMB0YPgSpltUQMAQMAUNgoSAwawQM7y5fvvypT30qB/TCxJwM6B9SdFRiqeuAbQz4qHy41ihDwBAwBI4AArNGwNT1k5/85IoVK0444YS1a9d+5Stf2bFjx/zXCMFHPvyX0wMDBf9o4LQXzHP8oFfEiO+DKAuRzBkChoAhYAgYAlNAwOeOKaQ9WJIrr7zyf//3f7u6ut7ylrdcc801p5xyyqWXXvqDH/xA5ytV5t43pDK2evws8C0Gglxh2bCXK59FKJtgJQPxTCDanIhAylFXY2zSoaAe8ls9LbCaGAKGgCFgCFQpArNJwAyIMu25qanp7W9/+0MPPfTOd77zjjvueOELX7hu3bo3vOEN2KWVd1mexFBxleKxT7XyyrrFnFfEq04IOFMM5APwbRH2FbXX7Yslu1OaMwQMAUPAEDAEpoDArBGwWpthVqYHf+pTn2I8+P3vf/8ll1xy3333vfGNb9y8efO5556rvMvypPmiAR8AQG3CPHqTOEBbLMoQMAQMAUPgyCMwa8uQmI707W9/G4Pzj3/84xNPPPGDH/wgFulIJNLT04Mq/PSnP/2cc86heawVRlFmwdKRb+rslugvQ5LxYefsPODZRdikGQKGgCFwdCMwawSMhRlN9wUveMEtt9xy+umnswfW7t27Fy1a1NraCoKrV69+97vfzVKlRCLBLeryfJ8/DAHTBDRgm3Z1dP9CrHWGgCFgCBwmBGaNgNn8mQVIuvMGREt1lyxZonZabjE7v+td72LpjlLvfGdfWqcasBKwNEpORnIDwYfpQZlYQ8AQMAQMgaMLgVkjYDgVrZe5V3BwNBplPyw8qMVsTqknNBAIdByXRDLC9Xb+gqnvFpjTTQOevw/Ram4IGAKGwBwiMGsETBtg1ra2tsHBwUwmg8rLdtCovLgzzjjj8ssvx0Dd3t7OqLBabuewzbNSNO1CjqryTq2fFakmxBAwBAwBQ2ChIDCbBPzFL37xQx/60Gtf+1omPMNJ99xzz5e+9CUszyi7//qv/4oh+qMf/SiWahYKw8TzHWCoFw5Guc8VvZpgMJ9OBWNhWYtkzhAwBAwBQ8AQmAICs0bAsBF0+5nPfOZ5z3uelvuc5zznpJNO+vrXv87uHA0NDddeey1pMEGjJU+hYtWehDcMraJOfi6pwtVea6ufIWAIGAKGQLUgUF5Dc8j1wezc3d3tn4PEjhyEsC3lr3/9azaFPvXUU6+//npUYVRGuIq1SYdc4BwL8MeA57geVrwhYAgYAobA/ERg1giYAWC0229+85vgAPvqVKyvfvWr7MhBCHOG2ZkSStbjg3Rt0vxErFRrn4B1ElZ5MHhet8kqbwgYAoaAIXDkEJg1EzQm2f/5n/+56qqrfvvb355//vnpdPrmm2/u7Oz87ne/y4xo9sPioCQIGCWYKBxG6SPXysNQkr8Rh0/AmKTFLG2zog8D2ibSEDAEDIGjD4FZ04BRAS+77LIbb7zxWc96FmouGz4zBsxeHNyyEoldsdiZkqnR7ISFFXq+sy/fA18DPvq+E9YiQ8AQMAQMgSOAwKxpwDDui170ov/+7//+p3/6J/8kYGzRtIFVv6w+gobx65pglirNdw5WAua1o6Txur/liVlH4MFZEYaAIWAIGALzG4FZ04DRbm+77Ta4ltOQgIRFwFwZCcbaDPsSzi2kpacXzHf2pS2lza9K/GvHIAGJOUPAEDAEDIFpIDBrBEyZL3vZy9CAsT8z6MucLN2qApUXs7PyLjSMxoiufIAKai4SMMjqL/VBAiFM8qrMqKOwkDpDy4TjUZpX7idQC0WgJiCNL7BSzpT8AX+JL4gJaOzDEQyEZVcvJd9gsFAshOfNKYtTarQlMgQMAUPAEDh8CMyaCRr+i8fjrANmGPiss85S8mPbDTTgz3/+8zQAFoSu8KArw51ETdoq+BsGJTt6M9wJW5OeIxxYucTcaagdP9n/+Mc/MrqMh1uIWWmbop/4xCdq0cz2UoUbgVouxc2cgMfVVQlYd8IKlXRgGNrn6HGJ7cYQMAQMAUPAEJgEgclZcJKEUwi66aabLr300l27dm3ZsgWqQx9lrBcrNFnZBgta9ceGIcUDyENpVqYkGSPH8CjZYV88OpAMuT7taU/buXOnRpGe/bYeeeSR8847D7GUC3njIRY5yvQwtMy9TqcPUO60ohCONk8Ny4PA08ptiQ0BQ8AQMAQWOgKzRsDonaw7gvxgR1VbdaZVf38/GKMc45Qa0WKVRyfFXpVjuA2yVAUXyZqeKV1QuGaH/zo6OqBV5fLf/e53b37zm/GjZ1MQ4cqO5CUl5aIEcwjxLJ5DTN2oP/KZhAXNGw1P+jQt0BAwBAwBQ2B/CBxIE91fnknDsQPDebDv5s2b//SnP6HvKjUyJ0tHcMmlo7OTZvcD1WqNNPRaPTxYmZgEqkBDxmy5BfPBtRQB137ve9/r7e19zWteoxUgJeH4EcUVpoSDSQZ//+Uvf/ELOkRPJQGrKMo6RJmW3RAwBAwBQ2DhIDBrBIxyCc8x+rt+/fqXv/zlDz74IGO3f/M3f/P2t78droIs4VRVQA+g/oI7JA31qjQ0V0K4hW7xQOSIgo91N2kCUbLhWjYAYc3x0qVLdXoXZWkyskDMH/nIRxYvXkxiToB45jOfSeCsuEoCVoP5rIg1IYaAIWAIGAILBIFZI2BUzGc/+9mYhfv6+jA744GPWRn8ox/9SLelhFNRSZVTfZ14X5TJRSAS3v3ud0O0qJU4xnTJiwaMB7V4w4YNcB5Ey3ImxptRuK+44grGiZXg0cKJhZiRQ5b3vOc9jBZD25DxDTfcsG+JMwuBgKmYlqISArYJ1sygtFyGgCFgCCxIBGZtDBg6hAu//OUvQ7fNzc0QHuR08sknY/hF92UIFtVW9VpIlGHa/aGt86cwXL/1rW9lY0s0V+SoWgzFolUTgnzID2mw4Ne+9jWkveIVr0AghTJCrAuRVQ6B6uEKMa9YsWJ/5U43XLVeqkFG04Cni56lNwQMAUPAEJg1AoZiIWDMy3ASjIsii4cZ0dAnTKnToIBbVwQRi0Y7KfrQpIZjN8b5aSA5BJIRAiYQSkYUtz/84Q8Z/dVklFXJvn5izUIaQnyBh+ihMvB9IlGDxBqqVMzli3kvaAuBDxFXy24IGAKGwEJBYNZM0AB2xhlnMBsZey8sCI+innIYMAtziUIBha4UVAZu98e+B0AdAsbKTQJIFFFK5Lfeeivm6Be/+MWEUxylaBq/rAMIPMSosgZcFmMzsMpI2F9DwBAwBAyBqSAwuRo6lZwT0sCLHHz0uMc9jtOQ9uzZ8453vIMTkB5++OHHHnsMOkQ39Ul3ZmooEvwS4VqIduvWrd///veZfgXxY51mrhYJULUpSP1++sPhUaavpF10YtuK43BAbTINAUPAEDgqERhjtUNsHmZe5iHDuBdddNFLX/pS1FxmYEG9nAeMH90UXtRZyozgMlI73eJgVmZmaUbUa/h47dq173vf+xgDRhS3VACtlKiZEfx066Ol8Fbgrz2CgKcrxNIbAoaAIWAILFgEZk0DBkEoEJa9+uqr8TMnCy6EepmozPof6BMOZjAYVZU5UzPQUMmOZRtG18Fg5lEzHZq51pTFvGtIHQ/CCaRc/IfbQcAwbiXn2izow425yTcEDAFD4GhCYNYIGJOszlL+6U9/ip6Kf9GiRWzgDFO+6U1vgoBBDRKFsnT+1HRB3Lt3r259hSgoFi5Hn1Z9V9kXuzTsq6uNYUd/4tV0C5piel8DJr17J5hiPktmCBgChoAhYAgIArNGwDDfXXfd9dznPpfltsxehibxrFmzhmVIr3rVq6BGCtOVSOrRWVRShak5VXZhXOVyMrEkyc8K0ysNKy8ebval3H3HgAmU84DNDu0/FfMYAoaAIWAI7B+BWRsDhmJZtouDibdt27Z7924oCkpm20iimJZFHdAU1U2XfcmLggv1okCTFyFwOYHQrU54hn0ZBkbbrmTl/bd6GjHwaQmjAH/lw1RseJZzHrxAgfeXoByDJKubJKXNwpoGtJbUEDAEDIEFjcAMCVhpD+QY68UphEx4ZlYURIhjMBia1KOQiNUVvXAnJEr4DCBHIBZsJJMXGtatPNB0dThZw1XPnoHw/WURTs0Ls3Lh7AWOfqDqeFhQlcpxZmIwEfY4YbEYoEmyRIqVwOYMAUPAEDAEDIGpIDBtAlb6hPkY5aUAbMJQI8ou476vfOUrWfhLCLFwJA5t2LcYo8ISQixk6fP3VKo4l2nQcqFcd9RvEfW37IeDi0F4uRBxIXi0khJmzhAwBAwBQ8AQmAIC0x4DxuoL4yrpqnzYFE5lD6xzzjnn4x//OLtfPfWpT8UEzTwpDMLwLguTSO+PyxIyg1nQU2jL4UlSwan+nGflW/eOcXgKNamGgCFgCBgCRzsC0yZgqBSlFmswuizg6KxjPEy5YvMN9GM4+N///d8xPjP9Cg6Ga1kmRIKuri7WI+FBdWZtEp556lB6fQKu2B1EWuMz9DxtmlXbEDAEDAFD4IghMG0CpmZoflwZ+oWGVa9lphUnF2GF7uzsZLoygcQqQ0PMJOaqq4FRf2FfVhDN+mypIwAZ7VaTsw71mgZ8BDC3IgwBQ8AQOFoRmPYYMAyKEqxw6JguWu/b3vY29F103CVLlnz605/G/qzsy77QLEwiMccCkgzztYbrdX5gWjZBu4FgqbJowE4FpvmmAc+Ph2i1NAQMAUOg+hCYNgH7c559EmXxzze+8Q20YXbeoIHvete7GBXG4WeuMof14oe2oSvM0bp81s9bfYBMXiOffYmWGc9lAlabs05MmzynhRoChoAhYAgYApMhMG0C1vU/uiczAhkPVmMyVmWUYEJYccQoL1yLvqtToPGr0gwHw9Ok0VW8k9VnnoVNHPQtq8vzrBlWXUPAEDAEDIEjjsC0CRhdlkoy51lJFEKFaAlBtdVVv+y5oat+GQlmihZRmgCPz7u+EZvAanc64YoFwWzBUaAtXjjAPLICWi8vFpUEPKPlzdXeequfIWAIGAKGwGFCYNoEDHeqxRUzspqjdR6WcipK8Pr16xkMZuYzvAtPU29N4E/LIvt8ImAHvJqgfbr1bc6m8R6m76WJNQQMAUPgqEdgJrOg0WsxRLP2V1Vb7MxsccUmlEyEZjx406ZN73znO6FnTaC7X6mirEO/mn2eIqscjLqPOR2nrfA987RRVm1DwBAwBAyBI4/ATAgYZtWK4oGKINeXv/zlLDRCr+XEQI4Bbm1tZRgYNZErUSQgWWWuI9/OQyxxTAN2Pp+ATQM+RGAtuyFgCBgCCxaBmRAwSi0jwThsy2qM/dCHPqTjvj6OanAmlpXBBOKBgBkDhqTJ7iebBx7HsdLMMtm6ZUiiAU9SeeImC54kpQUZAoaAIWAILGwEpk3AqsvCprAvqi00DIA++xKrIXgIh7c0Cg+JCVE9WIXMR+SVdrG9iwG6zMEBY935+CytzoaAIWAIzCkCMyFg2BT2VSpFo2VJEscQKSER6K/xVZblysCwzsZSDoa9kKDZ57Tt0yicCvskK5thuRnPPgFPQ5AlNQQMAUPAEDAEHAIzmQWtc6/IrsuKlFyVk5RcFVtWBqtHE/hrkEgzn2ZBy3FIUC5ABYWDnYW5WET5DWnrXAix5dtSqP0xBAwBQ8AQMAQOhMC0CRhhvo7rj+aizqpGi2bs64V64oKGk8tP7Gc/UL2qJC5QkDN+A4VIKEaNcrmMEm86lc9k8s3NzVLNfDrghYtKwDYAXCUPzqphCBgChkDVIzATAq76Rs1qBVUDVpHwsSdj3qLucyBwwGm9koCjgo17ZxV2E2YIGAKGwNGOgBHwlJ6wM0OXjoEiAwPbvqI/pfyWyBAwBAwBQ8AQGI+AEfB4PKZ2pwRc4uDyXOipZbVUhoAhYAgYAoaAIGAEPKXvgZv1XNKAMUOPI+ApCbBEhoAhYAgYAobAOASMgMfBMcmNU3ArCZg0EDDXSg3Y1OBJoLMgQ8AQMAQMgf0jYAS8f2z2E8N4sGnA+8HGgg0BQ8AQMASmioAR8JSQUg3YT6qLnv1b8xgChoAhYAgYAtNFYD4RMOc90Dy0T7by0JMQ1RSsdMh+WxrL1d/0Y7pwTJqe8sIhr8DKo2KxUCyw9ohDJthxk5MnZHZ0sZgvyInIYoWeQNSTirNAQ8AQMAQMAUNgfk3CamlpgVnZ2cM/BEJ3+dCxWLbD5IESoscjHqaHq2XBxKUBYIqx4d/DhLWJNQQMAUPgqEZg3mjAnCLMg9DttFQV5hY1FFXY14YHBgYIZMdp9cz6g/NJV3Vu/3bWCzKBhoAhYAgYAkc9AvOGgGtra/v7+3kenP2A7TcWi2F/RiFmY0s9exjdt7GxEfWXNHhm8ckp3VZal7GBw77iZrEYE2UIGAKGgCGwkBCYNwTMQ0H9hQs5yAGuhYbT6XRdXR1cCB9DhdAwaUgAT+uRiLP+HDl2UE8e1FnQJfllIq5k6Fkv2gQaAoaAIWAIHGUIzBsC1pFdyA5VGHM0dIvn0UcfZTyYKFTheDze3d2NQgwfH9bTlmwZ0lH2G7DmGAKGgCEwJwjMGwJmZJexXqgX7RPdd9GiRffee+8HPvCB5cuXc9zhc57znN/85jdtbW3EohzrgPFsAaomaF+aEbAPhXkMAUPAEDAEZozAvCFgOBXtFq0X9kXHpcFPecpTmI31ox/96KGHHjr99NOf8Yxn9PT0oCJD1SSbMSITMwYEIsZ63XBvkR2wWHJUKAaDXi7kZSRxkTOSggQGsEFzdqGsTDJnCBgChoAhYAgcBIGqI2Cd0kytGdyFa/3qw6m6uhcPKmlfXx/s+973vveMM85YtWrVO9/5TqZlXX/99RCwrk0iI9ZpzY4o9fghvtiDeYJFLxgKR0NFLxqEfNPZYo4/I6liITfS1lhDAfmcVwjIIYWiKAtRE2/OEDAEDAFDwBA4CAJVR8BqaoZ64VE4lelU/owqZVZ4F5bF7Lxy5cprr72W9Fu3bv3a176GUfrSSy+luSjKbMqh06G5xYP2DK8PDw9v3779IHiMj1ZtVngVn2i/RbhWNGAvFPTyaMAOPlF/RQMmGGca8HgM7c4QMAQMAUNgUgTCk4bObSAM6legcjqV+tmOQych33rrrVdccQX7b8DQkPHXv/51WBmWhacJVO0Ztv7sZz/7qU99inCourm52Zd8KB6UXV4CcIcixPIaAoaAIWAILGQEqk4DVn23s7Pz6quvhlCV51iAhKe1tVVvN23aBMu++c1vZtbVT37ykzvuuOMJT3jCVVddtXfvXhYmqe6L9sxzha3/5V/+Zc+ePVihu7q6fvWrX83gYVesLyotQ0Ka1gRpeGYg07IYAoaAIWAILHAEqk4DxlaMqoo9+a1vfevrX/96dFnsyZiO16xZgyWZAWBGf48//vibbrrphz/8IeuOCGEB0le+8pX169djkX7jG9/ILhzshNXQ0ABNMuiL3ozCCmETfuaZZ87K81YV3Kh3VsA0IYaAIWAILEwEqo6AdUtnHkZHRweMC8mh5jLNihDMyHDqsmXL0JLZbQNmhVPVLs38Z2gbRRneZRmS7oQFTZKLBNAwfozSg4ODM3zMjOw6RXffjTiMhmcIqWUzBAwBQ2BhI1B1BIy2ClPCatiQsSfr09ExV3hUQyBgbM6YlxkD/tjHPgZP//rXv964ceOFF15Ien8ImfQ4lYAGjK6sA8PTfeKUXqLfck6ldqPeMh721xAwBAwBQ2DaCFQdAaPj6okLeOA59FraxLAutzAoG2BhcIZicT/96U8/+MEPwsSwLNtx/OEPf6i0MGPKJg15EYJfZc4WZeoLwbTBtgyGgCFgCBgChkAZgaojYDUpUz2nvpb0V6VSAmFfrqizXB//+Mf/8pe/xDPB6fQrssDZCCGxn30GBIwZOxRyK4xkmW8x6EnRMDrKNIZuUY1dpITKbCwCzBkChoAhYAgYAgdHQIjD3HQRcEZpm/88XdgsvSFgCBgChsAYAkbAY1hM6kOtrVyGRBqUXMzaM1CmJ5VvgYaAIWAIGAILEwEj4Gk/d5+A4WCZGa0To6ctxjIYAoaAIWAILGgEjICn/fghYEaXhX0d/047v2UwBAwBQ8AQMASYz2QgHBiBMRN02RKtGjC5jIAPDJ3FGgKGgCFgCBwAASPgA4BTEQXrlh1EbGPAZTDsryFgCBgChsAMETACPhBwusuzDvQW5WBgvME8ByJxEyiGy4uOiBAcx1IfSKbFGQKGgCFgCBgCIGAEfLCvQb7AqmPW/3pB9pTmTOAgPDuUTgWy2ZZEHD97XLJXiMORVcvMmTZIDwapxRsChoAhYAgYAR/0O6Cn/LKpNJ+AJxuDyHnAUHHRg5Bd9qLoxSpIleCDCrUEhoAhYAgYAgseAVPXZvIVsDHgmaBmeQwBQ8AQMAQqEDACrgBjUq9ba1Sag1We96wErHflsEkzW6AhYAgYAoaAITA5AkbAk+MyIbS8BKkUXEnAE1LarSFgCBgChoAhMBUEjICnglLlbpSSvpKATQOeEoKWyBAwBAwBQ2A8AkbA4/HY926f7a78jTj2TWshhoAhYAgYAobAFBEwAp4iUGPJIGA9D3hf3VdPSRpLaj5DwBAwBAwBQ2A/CBgB7weY8cEhh1M+l4N98XIYMK65Oc7aJJ90C2wQ7Q4qHp/V7gwBQ8AQMAQMgUkQMAKeBJT9BaHy6kLf8nnAkrActr9MFm4IGAKGgCFgCEyCgBHwJKDsG1RahuQidAzYeHdflCzEEDAEDAFDYOoIGAFPHauSsusTMOqwKMT7zNKahkRLaggYAoaAIbBQETACPviTx+BcuQ4YAi6fB1w6f+HgIiyFIWAIGAKGgCEwHgEj4PF47OdOCVjNzpUa8H6SW7AhYAgYAoaAIXAQBIyADwLQpNFoxJCx2Z4nBccCDQFDwBAwBKaCgBHwVFAq74TlKBcNeJxJekoCLJEhYAgYAoaAITAOASPgcXDs7yYs5xCWXDLjhUKhXC5XH5cQlv9qRDAUKhN1KaX9MQQMAUPAEDAE9oeAEfD+kNlveOV48H4TWYQhYAgYAoaAIXBABIyADwhPRSSWZ1/BLY0BV8Sa1xAwBAwBQ8AQmBYCRsDTgksSowFDwMFgUHfFmnZ+y2AIGAKGgCFgCLiNjQ2GqSKgc6+UgCefBG0To6eKpaUzBAwBQ2ChI2Aa8FS/ATr0S2pfAzbspoqdpTMEDAFDwBDYBwEjkX0gOViAMrGtAj4YThZvCBgChoAhcCAEjIAPhM6EOH/5r++ZkMBuDQFDwBAwBAyBKSJQdQQMtxUKrK0V57chm83i5wheDclkMkqBLMYlhNtkMonH58VUKsUtsSqECVNEIcRPoHKmeCUXU6D9OVf9/flwOFxbW6v1k+W/npeVk4LNGQKGgCFgCBgCU0Wg6ggY065MMA4E2OwCJh4dHYVEI5HI4OBgLBZTro1Go7QPPoYIoVVuiYJ0yUV60tTU1JCAQIRoSkQhpK6ubqrATJZO+VuvZoKeDCELMwQMAUPAEJgqAlVHwDAlVAqJ0gKYOB6PK4kmEgkNUW2YNBs3brz44ovb29tbW1tf+9rXwtAkID2KL7HQturHBMLQKqSnp4fbQ3dw8IRlSMbHh46qSTAEDAFDYEEhUHUEDHGiv+JgYv9JDA8PqzEZrbehoQEOhm5h3+OPP/6OO+74yU9+smnTpquvvppwbNFwsDKuT4rqIbZSpi98uh7YVwm4MmNp/ZE/VboyzvyGgCFgCBgChsA+CFQdAcNtfiXRg1WLxXSsZmfVjDEmQ7ok+/znP79+/foLLrjgAx/4wLe//e0dO3aopquGa9WVSQZ548i1ePFiX/gMPFo3od9JNOAZyLMshoAhYAgYAgsXgaojYIgWsoQ7sfHi54pSCw2r/trc3MyzQiHu6+tD/cXUDBdybWtrg3p/9rOfKU9D2NyiRuuDxY8cknV2dh76o3b8WzJBV+5PeeiSTYIhYAgYAobAwkGg6ggYIzMWY2ZXQbo4iJP5xtyiv+LnwcDEGJlf9rKX3Xrrrd/4xjd0ctaHP/xhtF6ScdWHp7oyfkIY+kUUEuDOGTxa35St2fWqlfGl2RZYPhTmMQQMAUPAEJgKAlVHwKi/cNvIyMh73vMeJlhBfuivXH3HbKxt27ah8n7nO99597vfvWLFCtJzra+vJxfc7FMv7e/v7//oRz96zDHHoBnjlixZMhVQxtI4vg4UPVYcqZeofJDbIhO1S0cUBgqAGCI64BULAa7mDAFDwBAwBAyBgyIQmJlSeFC5h5gAEh1yDrsxopSSly5dCqFifz7zzDPxNDU1wbgkYGoV1ubVq1d/7nOfQzMmPWo0a5DQeqFtYlWrhtoHBgZWrlyJ0gxPw+ukJHaCLju+5gVSeIFAyrFtTdFLBbwf/LXrv7/+g5OWrfi3Nz+r1StEvWQhj6k8IgQsLGzOEDAEDAFDYJYRoAOf0GnTkzc2Nk6nP5/lKh26uPChi5hdCcqIaKsgq0uPMB2DO2xKQQTqG4OyLwkwUMOgX/ziFyHXJz3pSaoEw74kJhxHXr3OsJ5O80Wz9V3OC+S8YrioGjBTtYvBYgHuLQY8bkpqsZ/aPIaAIWAIGAKGwGQIVB0BQ5ZaTwZ0cX6d8UO9GoLWi2r7/e9/f/ny5UzL+stf/vLP//zPH/zgB7klvXIwHt6YfMO1L9MXeIge6llByiVhjqwPUbBlNwQMAUPAEFgQCIwxXBU2FwbFUTF4FD0YUwOmZrRbnd583XXX/elPf2KO1Zo1az7+8Y+/+tWvhpjRd1GL8agSrOoy2rPyd+Xw8Izbi0zcpAQ8Y5mW0RAwBAwBQ2ChIVB1BAxZwm04ngRXqFcfCeHYn/FDorAylucvfelLWKoZKSYZu3MQxQRp5Wa9wtmaV63QGLd9aRo+rauv3U5CwOVKTkugJTYEDAFDwBBYyAhU3SzoSo7EL1TsHCos/Ipqiwf25ZlxhVkZDIZ9dY9JJkLDslCyPlH86lGZiCH9oT9sn4D3FTWjVU77irEQQ8AQMAQMgaMfgaojYNVWK4GH8JRKuaLawqN4ent7CScZM5y5sh0086LxYKaGhtmmAz+KsqbxmVhviToUhxAc1SiPAfu68aFItbyGgCFgCBgCCwuBqjNBK/xKmWiuvoPzdAYWCWDWlpYWPJijGevllt2yUIUJ4cqosG6YRXqyEwhZcsUhRD2HflXJhy7HJBgChoAhYAgsTASqTgPWxwBl4ipJDr9vQPYHdxkDJj3hlecMssZXhfiK7yE9WjjbsThMXnAnALPeiRKpQ5nM2XxDlgBj8PaV4kMq0TIbAoaAIWAILAAEqpSAqx/5ypeD6q+t1dAQMAQMAUOg2hCoUhN0tcGk9VEDtowAF4sQcHkMWJZJVWeFrVaGgCFgCBgCVYuAacAHezT7kKsSsNrD2f/qYPkt3hAwBAwBQ8AQmAQBI+BJQNlfENRLlBIwQ9QTku3D1BPi7dYQMAQMAUPAEBhDYCKLjMWYbz8IVBKw04BNCd4PUhZsCBgChoAhsH8EjID3j80+MaoBa/C+GvA+yS3AEDAEDAFDwBDYLwJGwPuFphThFhKzgZbbQyvH3lq5YqRQ5IziPCHAJ2bpQJBjCFmDZGgeDE2LNwQMAUPAECghYJRxwK9CEXyEgZWAI9EgK4G7B1LhWEOiNsgMcuICgZqcF8xAwywY9uTMRHOGgCFgCBgChsBBETACPiBEQrAheNUpuxCsqLuFYrTI5h+qATuGlkFgSSmnAhN/QIkWaQgYAoaAIWAICAJGwNP+HoybhKVLg6ctwzIYAoaAIWAILHQEjICn/Q2oJGA/s61B8qEwjyFgCBgChsBUEDACngpKkqZyCjT+0kYcZQ1YBorNGQKGgCFgCBgCU0bACHjKUJUT7qsBG/uWsbG/hoAhYAgYAlNFwAh4qkj56VQVtnXAPiDmMQQMAUPAEJgBAkbA0wGtbHD2zdG+ZzpSLK0hYAgYAoaAIWCzoKfwHXA2Z/bZKL2s9PX1hcPhRCKRLXiRcEQFZFkAXKbnKYi0JIaAIWAIGAILHQHTgKfzDaigWP80QjsQaToIWlpDwBAwBAyBEgJGwAf/Kvhcq0mdQlxkDLhy6VGl/+ASLYUhYAgYAobAgkfACHjaX4EJBDw2DGwkPG0sLYMhYAgYAgsXASPg6Tz7sgka0hUNuCJriXzLCSpizGsIGAKGgCFgCEyCgBHwJKAcOMjXgDWZasCm/R4YNIs1BAwBQ8AQmICAEfAEQA50q1yr18k14APltjhDwBAwBAwBQ2AMASPgMSym7oOD/ZlZysdTz2spDQFDwBAwBAwBEKg6AobPcrlcoVA61C+fz/v+VCqlz4xA35NOp9Xve0jvp9SoQ7wiUC3MgRDHEnojIyOsA45Go1rFcIhzgb1yjQ6xKMtuCBgChoAhsFAQqDoCRrOE3rhCw5lMhitOGbempoYQngyxsCAeTkSIxWJ4stkszK1UjXGYlIfvAarK62vAh68gk2wIGAKGgCFwFCNQdQQ8MDAwOjoKlaqWCb+ia8J2/f39PAb8XImNx+N4hoaG8EPPkUgE0oV6CYSw4WM8h8/BwTYGfPjgNcmGgCFgCCwEBMR8WlWusbFR64OyqzTMLRTb1NSEh0A4GG4mBPW3vr6eQOhWVWTSayyBh8Wxyigg5xLuS8CHpTgTaggYAoaAIXD0IlB1GrBSKYBDpSi1cC0OPRiWZWSXQB3fhX3RlTUx6i/hOOVF8vrjwbPy4CZYmx3/7kcDtnXAs4K4CTEEDAFDYAEgUHUaMFosDgMvFAu/Yk/mKcDBsCwOfzKZxEMsxyFwxV4NN9fV1eGHGvWRQcaz/uzY8zng5CsBU5wWoXtB2zrgWQfcBBoChoAhcHQjUHUaMOQK+8LB4A7Jofvi8KDvEsKgb3NzM7ccSaSKKYPBmoBY/PAxHs2O53A4JeAJavHhKMhkGgKGgCFgCBzFCFQdAYM19KnK7q5duz796U+fe+65UOyJJ57IPCwGfZVcoeE9e/Y87WlPQ9ldvnz51Vdf3dnZSV6dnHUE2NEvQtXuym0pj+KvizXNEDAEDAFDYLYQmEsTNFQKjUFgmJqVcQlB/dW1Rpidly5dumPHjte+9rX333//9773PYaEUXChWJ2Kdfnll0PDN9xwA9kvvfRSmPiDH/wg0pCJAyC94kHmoeDlKDbA9CtUchRzBqGRXFvr6WJkLaVQZKZYLhQ6pIIOpZKW1xAwBAwBQ2B+ITCXBKy8CIGpB57DA8UyuKsgEvLJT34S/7XXXrtz505d3csKYBL88pe/vPvuu1GRlyxZQgKSve9973vnO9/JJGplcQKVGhECQ0PnhBz68qTSIDOykO+uQs+ws6nADg27GAKGgCFgCEwRgTnT2JQLuaq+C2uqh/HdwcFBaq+KJh7mYUGl69atGx4exg/7kvLee+895ZRTYF/4mLwvetGLurq69u7dS3rollnQOCVgitC1xQjUIqYIzaTJIGBhXNGqJ8ZrcRND7d4QMAQMAUPAEJgMgX1oZLJEhyNMbc5clYnRfSFXqJThXh3HhYm1XJRX/Nu3b2eqsybG2rxly5Zly5ZBqPAxjEgIHizVJEAmQnBk7+3t/djHPgZ5E1tbW4tnZm1BwXU2aK+SgMc04LI2PDPhlssQMAQMAUNgASIwZwQM1tu2bXv3u98NKaI74uBXHB4YFL586KGHSIM6y4RnuFOVVxhaH5IuT4J39/fMMGVDzC0tLczPYiCZjCjQd9555/7STzGc8lUD5vXArM5TBM2SGQKGgCFgCOyLwFyOAa9cufItb3nLs571LAZ3GbuFa9FfIeDFixc/8sgjxx13HFSH7stMKxj0mGOOgUFhaNoAGZP3tttuw48JWukZz0knnaQqNXQLNyOKBFy55QqpI3NfCA4SUnHwESl9AvZN0MrHWtBBRFm0IWAIGAKGgCFQRmDOCBi6hVw7nCtXRv5CrnDnWWedhQfWZK0RfLx69Wo4WNmXoVwI+8wzz/zABz7AJCxmSpOLOdLt7e0Iw49YaBgPvItlG7/eEsI4MdeZO8iWfTec8wl45tIspyFgCBgChsACRmDOTNDQJFZiOBLwYTSdYOU/CCzM0DAKMddbb711w4YNpOF61113wdy4Zz/72ZD0K17xCmJvuummd7zjHX//93+PGk0ySJcrolQ4HrVX49ENpf1SpuIpOkNzabjXC7H0iJBQ0QvqmLCrPLF8CPMC4DlnkE6lOZbGEDAEDAFDoEoQmDMNmPbrZCs8aLqq3eJXbRV6xo+y+573vOeaa67BD62eeuqpTK36zne+c8UVV0Cuv/jFL6688spLLrmE7G984xvf+ta3kgw/V7RnUqpf83LF6Rwu9U/xmi+gUiMzl88V8uFoquhlM4VYOMQpEGBHRCSMti37ZRaDYegZ+pUamDMEDAFDwBAwBA6IwFwS8KQVY/kQFmZlSva9+sIXvvDxj3+c4VuUWhRfmBXahn0Z8V20aNFvf/tbiBk/CZBGOAnI7lPvpEVMPVD06JJzKjWTwtwtjAzLjqm6xTy6L7p8RfpyPvtrCBgChoAhYAhMhsAYiUwWOwdhqgFjecZurKZjliFxAINyqirNStLox/A07AvvkpIrt7AvlfYHfQ+9AT6Xq0cnYfmBhy7fJBgChoAhYAgsTASqTgPG+IwWCwH7Bmpd0QvFwruQMUTLtGeeFh6iNJZb9GNi9SlW+mfrufoEjEC1kM+WZJNjCBgChoAhsAARqDoNmGeAtVl1XygWBRc+xgO5qp1ZlV2fYvGQBW5GIda8mni2nmXlHpNYmFUDxu49W/JNjiFgCBgChsDCRKDqiARCRb9UXRaeg3TRhpWJeUJMluaWcNLgOJ2QKMLRg0lJCHoqhmgNnJUnCgHLib/l1cBGwLOCqgkxBAwBQ8AQqEYTNE8FBmWREkSrhmj4WKdl6WRp9F3UYqZo4fQRkl5VYTjYN0rP7tNVE7SuAzYNeHaxNWmGgCFgCCxABKpOA/b1V7jWn3LFg2HcVykWAzUsq9QL75KeEBhRJ14pNTJp6zA9S7fAuLTY6TAVYWINAUPAEDAEFgICVacB7zuB2ddo4V0eCZqoP9kKulXG1Ufl59VZWrPy/LA5y+4abiiYv/39SWzgfgVmpQgTYggYAoaAIbAAEag6DXhePAM1R8+LqlolDQFDwBAwBKoTASPg6T0Xnd6luvj0clpqQ8AQMAQMAUOgAgEj4AowJvPKLGgd+HWxRsCTgWRhhoAhYAgYAtNGwAj4IJBNSsA2BnwQ1CzaEDAEDAFD4GAIGAEfDCGNLyvBpgFPDS9LZQgYAoaAIXAQBIyADwIQ0b4Jmp2w8OMqp14fPL+lMAQMAUPAEDAE9kGg6pYh7VPDuQzgyCNINyAbYclZv3LeEapwoBAKFtybSyHPMYlyNLBEuDVSc1lbK9sQMAQMAUNgHiFgGvBBHlYhWwiHwoViKMv+XJ6XzCRDxWwkkIV0uSUwg4BA2CsGvHzWy2W9omyNac4QMAQMAUPAEDgwAkbAB8Sn6AXdGb+ovWJ/FtIVpg250KIczSAnBEsSVGTZJzrnePmAMi3SEDAEDAFDwBCoPFTe0JgEAdYgYWCGch0NkwCjM648Blx6fXE6L373gYnNGQKGgCFgCBgCB0PAxoAPhhDxjn2Vgoui9HosQ8IErSPEpfx6LxxszhAwBAwBQ8AQODgCRhgHwygYwOisq5Dg4EmXIZXUY5YMl2j4YDIt3hAwBAwBQ2DBI2AEfJCvAJSKk8nPThMu/v/27gNKr6KKA3hCCAREFBVsgIJYQEUUQYqIigpKsYBSLKhYwIpgASWiR1DPATT2I0HNQQFBQMHOsXdUVJBmQVGwYleakOBv8w/Dxya7S77Nft/Let/Z83bevJl59/5n5v7nzsz33k0LQTZ71qxe4JZsu/LRhsXfbFico06FQCFQCBQChcB4CPTyyHjp/m/vcX/xq/OSY9HCmTctWm2VEaaFXYteHBKRv5sT1/9CoBAoBAqBQmAMBIqAxwDm5uj4tDzgcO0qixbOusmPgEe2WqHmwMc7HnGQpbiFkG/OX/8LgUKgECgECoFlIVAEvCxUbh0HozmrrWL31ewZM6675uqF11+39pprLAZuyeKv5IuWUG/heWvs6qoQKAQKgUJgDASKMMYA5uboRTctuuGGxeu+q8zwrqtF3rax8IYbrr1m5L1XI65wj9NbHvDNoNX/QqAQKAQKgQkRKAKeAKJZM1exDzq/PsKwc1ZdZd111l5z9dmzRt7JcSP4bsXBExRWtwuBQqAQKAQKgSUI1O+AJ2wKi1YdAYkf/N9Zs+c8YOONH/+YtTa//0Yjr5xc/P5nb+aoUcyEIFaCQqAQKAQKgVEIFAGPAmTU5aKFN/531qoj882r3LTIv03vs946G623NspddD0P2AsqZy1e/V3CwTOxctHxKAzrshAoBAqBQmAZCBRbLAOU3iiOL7L1t+rIT49GFn3XWrwYvPijCyPxt1r5vWVXVm8ZFS4ECoFCoBAoBEYjUAQ8GpFR13PWWCMEPNMXGBbduMinCWfMuPpaqUamoF1A0N9iN3jJCzlGlVCXhUAhUAgUAoXA0ggUAS+NyVIxC29adP2NONZ+rNkzZ8yZMWMdpIx2Z/pdUh2FQCFQCBQChUA/CHSOgG8w5/vfkW/sXnfddTfe6Ot+I4fIBK655hqBhQsX5p3MLV5kYtxKSuebv1nUIvoIwGfWjFlzVln9dl5AqUhr5sh39ZHSZ8+YtQZO7pmClhgr9/GUylIIFAKFQCHwf4dA5wh49uIDB8+ZM8dHh1TItddeO2vWrL///e/Cq6++OtJ1iVwFpA1J//vf/xbjfVWh4VSjW3mHc4uc2c+7mhfT6pKZ5hG6Xc3XkDxg5qojHnAv3fZQcQSocyFQCBQChUAhMBYCnSPg//znP2iy+b7kXmONNZDrHe94R2HUi03/8Y9/CGNf/u71118vfPvb395ZrnjPwg6Jw7jNFe6LgFNYnQuBQqAQKAQKgRWJQOcIGK3Sb80110SlZqH/9a9/hVPDnTxdTnDI+IorrkCxt7vd7a6++mpZJJbXpXCyNN5tfnDvBPWKRLHKKgQKgUKgECgElhOBzhEwfsWyGHS11VYzC/3e97535513Xmutte585zvjUZ5uloGpOXfu3Mc85jFrr732jjvu6FJiZzTMh5ZXYnPU3GWBrBkLOJYTn0peCBQChUAhUAhMCQKdexFHpqAxKHX/8pe/INHddttt8803X7BgATZ1cI5FImmUvOWWW971rne94IILJLZIvM4666DhXpblNzusJccbTrFTAmQVWggUAoVAIVAILA8CnSNgzm6WcjnBd7nLXY488kjqzJ8/3/Qybr7DHe7gEg3f6U53OvbYY5HrX//618suu0wk9o2nm0lst9oacKPk3qXl5UGp0hYChUAhUAgUAisYgc5NQdMPX3JVMbGANWAxLnmxYoSt+JqmFkCxCBUZm3bmEItBwCIFxDi7JYa7bB+1XIr65z//Kb6OQqAQKAQKgUJg6AgMmYC5ufzaoIAmBcRwYcOgdjhb4hUpRphHK3G2WSUBVnYr89KhbVPNLk1EK8ddyebNm2eaGnlzkTfccEOlWUh2V7I8zrm5yMJLH03CJMujW5aUk1wtculCuhnTpgSajt2Uc5lSNZmnX7001VoFLROBDkb2doHWNZZZQU3HDmoxlkhN5qqXsSCauni2nUOlLWU9URWw8PG40tKy6WfqBJiKkodJwLYxH3300ZtssgkQHRZ3EaezMKY877zzsq9Ko7fxKnuv8Gi82DjB1n0lxsFqRQBA6gaR48gs92Lrl770pRdddBEPWOX9+c9/lkDi/LRJ+jwifvYy8ZUrnvff/va3VHOyNOMiV+xLb2CZRXUqsg0jEqCjQUnCnZJzLGGmcb2oiDQ51ZGmtRLVyzL7wqiOoyupVjqqxLHqt2vxqqDqZbiVomnl6BVDTPgY+yIClKyaHL1puhwe5hrwBhts8OpXv3qvvfZClggVceqQ2WOF5O51r3vhWh6wjgpiq7/mmTnBuBOgoVtOrVwSqAY9RHaMq7c7i3FLsQr0IBnlwuKK+v73v3+/+93PI5SfRwuPxcGY23qzkmV0ti9M7fodlPrO+CvGJeVLEMG6XOWRDYy///3v4QMrBpGagILkWDh0TaPpWi9qRDvXUNWLGlEd5n7WXXfdlaVe9LvWF7QZvUYMZ4Vx9PN93U2fFUlByTQ8anataS1TnqqXZcIysEh2laXVlgS0nDQq7col6y0mpMsC6y95LcTAZJvUg2gyxANHZpjfK4POqa+KASVYBU466aSwrLAYjiygc+uQQw55+MMfnrpJIeJlTLjFKJPJ/uMf/wis9ddfv0EWR5lFaDGjAm2WQ3wsi61hLU2jW4EWbndXigDLSM4oRdmVQmZCTtd6SRWkOlI1K0uNNDl7+0Jvp4hS6UQSu7VytTcyV720Wh5ioLdR6SM//OEPmfdm8I1fW7j7gaEZ3DiOBi+tIpGxDglQzpkDjgYyf/rTn37961//6Ec/Ev/1r3+dH7zFFltwCOQysawQ/ZlzcPHFF6NkE9ecBpwqr7MCVYBHyOuQxd2f//znBt1cWGHVpgTEjN2bGKMCxgfyyoLXDbg87pJLLtl6660J5hEEDvejcM1CuLdxjCqqU5cR2EDn7ne/u53kjvve977OvTXSKYFHCTNd64Vefl/3i1/8wtnxhz/8QVvVjDWtUQh085KomlYE1heE9Rp9xz6ML3zhC5tuuql+qtfoO/qdaaSVqL2pjqqXIbY6jcqhUTkSdmb841BxujQtVn0cYz5E4cd69IgmY90bTLx+SIZe1PCibqnr6p9777335z//eT0WvuQR89nPfvZJT3qS2eNnPOMZ55xzTq+QV1555T3veU82C6m0eIWrMHXjEMCmAsphFzxChUmpcBahZekNyJKpbOXIYiZKXrksPxOSYBKHd9MsevN2OUwpWiBgE+yqwIiHtAIBpMuSR7bpWi8af2ZlVZCASVoELDIV1P16IWE6gv6if7nUa4wqzDzTQu/T1/QaaQQoJdlKoVTVSzeriTU2vNOuWOaYenKqrJXFjg3NA4ZaOI+VAWJqN24N7HCkGLCeeeaZLJEAcJ0xRJxRrjAmDv/pydBPCXZshX2NjJA6E6CruyWQuS/x1pUT9jiPVqwjyVJI7zkGIqZELr41eeKOtCwCCefcm72zYSAbxBAYkhxfWDH0Mf2dlblXsOlaL6kCAyMtWdWoINUk0Kt798O9HSFhXcaYFeP2rs81i9l9japeullHSCQ8QjxEwFAjhZWFfck85trnVMMNNXg1ohX2RD5luC2XzFAiYYoj8WW6gX6LOEUmO/ZNSpfxpNEkllUZSktRrECmwsSLQaK9jxMe65ArzodRlTTMRx5BBkdy9YbHKqeD8cw6yY1pBLAvTQN+B0VdWqTpWi+qgGqqQ6WoGhUksLT6HY/p7REtrOOEfdOVdCuadlyRJl7VS4Ni6IHWokiSlUEBjQp9oBU0MXQJb7sAQyNgIiLOeKIJR2hEK5AhDDMk3EbT8E0aGZOsZU/KdtlG2Ti4OccIO2MlMeFUpeVuHNwUPursQcjeQSTMzSYKHHHEER6hQE1BesRPyPYbwVElDPdSA40Azdhl8CGSUrSzEZ1GWi11Gg4Z2TTJR122+MEEYq/JEMkjTOqFABk00EXtv+Utb1GhSUBfteOu0dhg5Fzep2RoGBUiqjDhVYQARd785jfnFzujUrqbhifQtUNFEInX3tqSrqGzHH744elBdBEgvwpKL+6UCuRP+yFVdBEgs4aUekkzc5lBf5qfLAnQq+XqlF6E0RHUhXphE9LfaaSNxSqSPFaRss3kdk2FyEO8JiHhUy8aVe62QDeFHyXV8NeARwnUtUu0qstpmvpYCJ7h0IhN29oSmXagZTMlxgcYolF7RxRpU/3kYRo0VjKbDNTN7na3uyUydjDT+xlIxnrSVJaha8S0NWvetEgkLfRAd4M8ZSmYxG5ldCVLB+uFvdOiiEoR7aoZFNI61AI7Av8YFzEqQhrpHYuTjHDwqFyJH+4Z7DRKm8nkuZ6CgGPlW2tM7XSwXqDX2+UzSgjmeo2VbJ2dOgFZl9HGWh015JutaDHdCfQ2KjWlXVGhLXOkW3VH2mkvSRHwxFWsjaKo8JPUfgS13nrrJZveaFZc/5RG220Wf+JCB5iC1SM820FIVjumMM/PinjMfa9Evf1QFuayTT/0JhtAOAadzETKQCGy5ZyBPAlzK8bFOTH0pRoycNm1qiES+qSFQAZ2wHRJ5ohKNZgz5erOukkv1EvXY+/doYcRmH5hK0bqqMnTqCuqiW92v6UZemCZ3DlKcuOGyJlxhv4lVwurzVahQ1enCRDMtRytzohBH6GFkUT01QglEJmxRTcHRk2X6RQoAr5NtRnLrvnig7gmzKKmnKnvjOszqL9NxQ0wka5FPF0uRoFNpIsjisTWt/4mkmhSZlAvmcAyTdIANVjyqIjhTFqDHuA3wNUL86FemuFLjYTkBi/qbXliyKlJSC+5In8iDR0MO8S3oQOlHEZ7bZItmNyWxw0sjYnZdApPVC8EVlkh2qic0Z54YyaVODDBbvuDNHvNiXiQb2PT1tjSKVJaq752KUYFjYq/7Y+eupTqIoPUUY/I2KJXYOOnbHMZlbIupwKBYa4BT4U+K7xMDVeZYSYtWNPUwRg+DqX+yYN0V5N1dsmsrHABJlkgG0cwlp2QsQ5iWPDIH+Hj3bKPUjooKJ7ioWHpGZ1JitF39jCT7CEnZ1VAJFA7i48pN3JPAjEY2vBIQAJKSZAKEtOdQ10QpjUYFr/JH73UkbuqQzIg4DB8TPewr+wpoTsaRRLsmy6ja+gv2NfMrX1kmKy1KynpQruscHdKBS1Hs4dztEgXIHwqhajE1qgCPvYyH5aUYtyKjjELndKrsS/M1UhkI6eOw7hpfpQSqe9obN1sWp3Cc0UJUwQ8AZI6lRTsSN6ipe1eddVVppu8k9I5zOSntBqudsysTFDcMG6TjY0Ib7Ev1uRIQVo9jTri0/diR9zKpbOMuYwZGobsIx+2AnJoOGdicLOIF7QjJOGZQrfYFPVieCGXSAZRSjoORfhxHhq6jaVzDtHGMrpEt/KmItSUQPZCQ4C+LvGBY4gDo3FUi63PtDldoqlxQ6oviqAuKus445QzlFuNqBLQ/IhB+DQ2FSSsUaExloGOVqNUh4pQHTTNUC86DkX+sR5KQofqgLneIRD5paejLkMpCQQIT5exyqn4FYtAEfAEeKJedlxjzcTa+9///p133llvfPzjH//FL35Ra04X1XC7yb7UY+nCUl/96lef+9znkl8HE2YvdEUJRIqhgrNjv/32+93vfieXGHeHO5yHP/qPEaeFwxjCO9F22GGHSLvvvvt+4hOfYC6ZQrz1+te/3uY4wntPy29/+9uhy0+AcY42shGg2kc+8hFKebtqRgy77767Sz4K1QRe9rKXeX23SmErVYqGR81xCh/WrXPPPXf//ffXNcj84Ac/+De/+U0kMZKgmiZHuxe96EXf/OY3hyXhOM/ViwFrhAdb59bM6OKg1Ny5c7GX7h8FRZpAevnLXy6xSqRaGyaO85TB3yIV8S6//HK/evA+Mh3qCU94wre//W3GDeMaN4i/973vTZ3ddtvtpz/96eAl/D99osZUxzgIZNgogZZ62mmn4YPjjz/+ggsueNWrXqXjeSGlW3qsUbBAzuOUNvhbLLWHGkA4n3322UcddRT5WZmPfvSjYkZGxTfeeMABBzzucY/jQXKOacTFd8u0W/JS3OWwDpBipsjPgkcM7wb3Gha14INahx12GMviAxtSHnTQQRtvvLFXp3ld6IMe9CAmRl5ZWsZhabH0c7MiwCw28Xz+i/AY68ADD0z6bbbZRtWolMsuu8xb3tRI4pNLWN0lpjtn76F72MMeZvSDhg3jjPPUBYG1ouOOO87G+5NPPlmtPfrRj37gAx9owNQdySMJHk3AOE/A+27NdekadPnGN75h6POlL31JvFGscSpl+cTelcuhF8kOpLN0sL0Rj0bPf/7z73//++sgNDr44IO9N5Dwbh1zzDHC3np0/vnn+zqOt9KKrGMACIz8mKGO8RGIEWffd9ppp+c85zlJrLN59fS73vWuGBFTUuKHy1Xja+EumZPGYJPXGDOhKz7rWc/ikUQRxBCznsGENFF/wsKnNEGAJVJ4K7Ix6w7czEE0M0F+TGyQFEl+9rOfUdOL2rtpDaMCUakGcHbf57++/OUve824X5m76+Bmca3YTeEoLj2VUyPdbGxmIIwbwl69EgrrL+95z3vaiJCzxeJPabPpu3AgyxvM1U6akLowPMowyADCd057y2+dS2RvuDfNEMNUUAUGEDp+xDCw22qrrdSXS1Xz9re/PVobf0uWAXqvwLInQW9khSeJQE1BTzzzkT1KXEP20dwaQ588u+yyyxlnnGFNSBc1Qa2JI4CJixt4Ck0kFiQzlsy3tSsvx48d92ULc1DcYp9ofMADHvCmN71JT5OefcRtfGXqU3DgUi95IBmEAiyRzEC4FMBJzARLx4iT1lShwbtIrjy9pLnPfe5jPvB73/seFbK2uqTEbvyjAqeWLFQTPvLII5/2tKc94hGPMENr5lwMoqI7D1IFbbfddoZ66kUkrYOGM327oc0tUpxyyinbbrstciIeV/iEE05AY24z6/TSwNoPXR71qEd95StfuSVn90KgJpTuowlpVHz3XXfdNesyaXh6vWb2ute9jo46V6pDY+vg0kBUIKHmZLRHL/2anGahfWFC1ey5557GFuJNrWtvXH866vjUFymjCg0gLutYUQh0kTBWlG4rpBxWz3qJoR+bqO/5dSMLomlqvpqyrzBplwyls2QSt00cK+Tpky9Ez9Ft9CID3nxMDV2x41YTDecp5RHWhD71qU8xlz/4wQ9e+cpXMouGGjonpbgyWYWdvCT9lZDVX3lTEXRhCsl26aWXkt+Uprp43/vet9lmmzH9lEVgKouO0pjkZEfkzVJ3fwJMUS5tJl9xMZ4Dvv0E1kRBTWxmnVJGRfvssw/7boSHqg899NCzzjpLvZBHvUQqydydIgn7KxbRWiAwQ3vhhRdaIzCzoqeYYsl6PG7WFLU6Q0ArjqZw+3vK1OWKeGEdOAuEdXQKaOsdHq112Tah1+AqqwNWTw3+fOtJSm0vu8+mTsL+Sia8pvXEJz7xjW9846mnnqr5mSuycHOPe9xDH1emPqL5xVxYClFful5raXqf7P09unKNg0AR8DjgjNwKoTIZAkw/s6LjsSlarYGk/qYpG11KqbG6nKC4gd+OjSawJ8e4sO/UYbgF0t/4KwLMypOf/GTrpkYYdmGYnpIrfVLemKGBi7/k10eeS0IWgQpG5UZCzPcvf/lLH5f88Y9//IpXvMI3oYFPYGsBzKKwlCoo1CtLMyWDV2GZT4w81hfJNm/evNNPPz0GDtcyfxRRHRaDqcCgAx9bP/KRj6SXQ5ODhqrpGvvSlC/4kIc85MQTTxQm8zOf+UxzmwhYfzH++9WvfmXY5JbfFKigDtr09BFnQqojgbR8WliByp5nYr/4xS82otWDLJeqBb3mu9/9ruFFxosMRRxlhXTkYL7IZn7LLhBehAZmumWPPfYwgMiUHnV8b5ETrF0ZnQsv7Utoe1GwI0pNAzFqCnriSmQKMVYspi4ngxjNVM/UFcO+dmEwix1snawDacmsy7H1+JicLoktnn1xdtCFyXBLgGq2ZiS9lKxJbJDwUA6jbz0f1MRQEZnDpBcO5mnZhGVfiRlaa6hoCV1Rk3ZSWt7GAbILD0XycR4aSHGSHd0/+clPbBkjPzmNJ6xnA5++6Dnsq15M3rr7uc99ThtTU+oI1aUqx3nK4G/Rwhqw52ZfkmGc9qOZ2eNjbJQOwtabujDzmd40eCHHeWKaSjunmuwn+Na3vmUXuks9SANTAoqijmracccdxRv2qQ6VohF2jX1JmyGF4YKdmGoE+Fx2FKuDaGyaE5kNkiK57maooeOwDMKyh4xTfeOgV7eWF4Ei4IkRi5nTRq0var5Z79EP/Wjk6U9/uvzaaFghrXziEgebQudJL9J/dDbkRE7WkO0Q464AicxL636WusUwLtSM9RHJpgxW5Fs9jTwxeS3W/BhyalLRSNgstJr6+Mc/nqGS1V+Xm2++OWW7aTiMD2hkw/B3vvMdM7fIlUNvIcBiMHfKLfSsCtyioOlcZGz2RTy96JuqbJh0JLD99tubUSeMHuFAXVoXPjNaoo696yTXulh2OloG7ojYTQyikjANJt0ZD3360582ADLLoh1qjRqY3iFL9haksmyTFmPbAXprpXUnQGbjnkwIaTn4lXY42OiBK6xpfeADH2DiKMsC2O+tamgKh4xFtEPpHd3RaJpIEljrPBYCiLbdmj9/vhZsfyCzYvegFsBTZEoy2JdM/2yJOxJgrEniTDZWw6oPc8/z4DKaTjf7hAboYoCP1fw+wc5bM1RmopghGQ2KkXfCQ9GIRfDceFG0IIwaecc73mG5GjMR27Ic7+pjH/uYZC984QsZSgulyMyEIeMSmU3kJtCdM0UIo1ICr9VQl9oSw6c6xJuttVxnE5bfbqoX1n+jjTaSprc6OtjeLF6YnCA5H+vDH/4wW4+PyexQa0y8S16+OVsz1QiMRl070mVIlQBmNYyzzJH9z+JVjblc8xYGTPYAbrLJJmotWmioKrFrGpFHUyGb6Rak66cBzltssYXRnlvG4iZdWDNbSrVDs0qmlJiFpkWaWbMJLb4Ck0dgZGqijvERYPFbp3rrW9+aSRu+iO7HrCRveGL8coZyNxKGQe30MZJlBHW2DGx58PoV0rUp2hiZieeQ4Wmi5hzFm0kavAqGCB4aAg7IzIGfYFoopYWxgrdV5JcVIzZ+4cIXvOAF+NgI46lPfSpDKW/vEGrw8i/vEw0aTHXKZTxk0dceGd6JCVvjDNqJT130hpf3EVOaXrPhP9lRj4bNSXzwgx+MwDm/9rWv1dLc4uXbdDalkvRdeGswaXXmHrQ0wyCdKDFeLcJrVClmJky5+6KfJe3ewdAQ+8tYWqfBLFiwQB83p8WI+R2wSa9YBj3rbW97m5kJmj72sY/lYCin2bRo3dyMsR5R8X0gMFMeoNdRCBQChUAhUAgUAoNEoNaAB4l2PasQKAQKgUKgEFiCQBFwNYVCoBAoBAqBQmAICBQBDwH0emQhUAgUAoVAIVAEXG2gECgECoFCoBAYAgJFwEMAvR5ZCBQChUAhUAgUAVcbKAQKgUKgECgEhoBAEfAQQK9HFgKFQCFQCBQCRcDVBgqBISDgdQe+gZEHexmCgDeiOHsLhHPvr/PzvkOvJBPvNRfOOfIO/YRbLhm9BSKR3r3gFWAJe+/KZz7zmYSdpfF2hXaZ7C694NNZxrxKQrhJ4rUMudViXNZRCBQCk0GgCHgy6FXeQqBPBLyz2qsZvWjMBwe9CBD7ej+Ut/V6d6MS0W14FMt6+6m3LOX9ZXlrt3cSSeN7hUmJSpPLi40QrdczzZ07d4MNNvAiX+88kjileZml9OFaRO6WS+/bcpY9ZXpdc0YDClEU7s+wQMlelIZ6ldkIXsY6CoFCYDIIrDqZzJW3ECgE+kMgb8OXl2eJ1RzC3gXI+8SF+UwQ2gvLIj93MZ+ASFSNJr1VNN9edAtNokyJBRy+guAlneIRdjhb2Od6nHEt1k/YgzbccEORGFoW5StEsejZIwiWd/e3p0hJPAVyrCOhmDoKgUKgbwTKA+4buspYCPSPgPdvH3TQQXvuuecVV1zxkpe8BF/yOHEnJvYm3u22287lQx/6UJ+X8HUaj8F8Pll4+OGH+84B1tx33335o+9+97u92hdrbr311kcccQR3GXH6OM8b3vAGH6tQgssPfehDGBTv+hJRZo99L8F3vTwIiT772c/Gu0gXox9wwAH77LOP1zV7z7YPDLzmNa/BxNxrbM1H51JLJrz33nsX+/Zf8ZWzEOhBoAi4B4wKFgKDQgDh4VTEhkGPO+44HwjiVqJM397ZZZdd0LPP0Vi1FX/00UfzUPGlBJ/85CdRoPhjjz2WK8wZNZV96aWX+jiPrwx5nz7xffH+wAMPdPaFAKWhWFl4vZnE9q31/ffff9111/W5Rt+SQsY+yGE6Grl6xKmnnoqzfUvK9+dPOumkE0880S1pLFf7fJaPEJx33nmmspU2KJzqOYXAdEagpqCnc+2Wbp1FAKf6nI5JY14pMuZf8jWx3WGHHbbrrrv6wE68YUT7lKc8xSVu9h0hjqnv4jUHlENMQTPJe+21l08/oWeXvrybBNJbPM7mKQ/KFw99q5GHfe655/pyrcR8Zd+/wso+u+SSJ33ooYeajsayp5xyCpJ+3vOeh8g50L4uRQZS8YwNHSSuoxAoBCaJQBHwJAGs7IVAPwhYXjW3jHHNAONIDigP1ZSvXVG8XlSHnlGybxGaWHagVR6wrx0jV5fok8N6+umn28l10UUXYUS7qxRCFGGeMUcWxytT4dJzl2WUwMf1zG/LLpkStt12W9x88cUXk8dQQBoZc8tXHX3yloRY2QdiudF77LHHDjvsYAoaQ/ejc+UpBAqBWyNQU9C3xqOuCoGBIIBcs7WKk4plOcEOvMjd5M5ySX07nbf6ta99Le5pdkhxlPmgKFMun1U3e+zL9vxUM8NmqtGteIeiJEPDwhhU+nCzSHxszViCaGkuGj0jVMnE8HSxssPjxAiIRMmY+LTTTrNHjEfui8XmogcCUj2kEJjmCJQHPM0ruNTrJgLYl5tLNiTH48SUeBE7brnlliaT7clyJB6P8k0l5gHj0ZCiW7ZZcYut/qJVHGkzF5c3xeJODrEwHvUIiR0KkcxOrvnz51vElcb5nHPOEfAsYQlSuDltlEwkBco+e/Zsdy1LO4466ig0f+GFF/oQfTeBLakKgZUIgfKAV6LKKlGnDwJmmzErfWw5tm8Zw9lLher8hNcU9MEHH2yZ1hz12Weffcghh6BPKaVHq8mFSv2Q6fLLLz/rrLNkPPnkkxcsWMDTlYxvbfqaJ80tzs98Q6sy4mMTyNaGTSZfcsklXGdrwMK2VburTJ4xGuYHkwflm4V2aXvX8ccff/7559uNJcAPln761ERpUggMD4Ei4OFhX0/+P0bAmmumhY855hgOpVlo+5ax3aabbnrmmWfaJ8XdxH/urr/++ngRGfNKzVELX3XVVZDzEybcbG/Ufvvtd8IJJ9i3jJ7FS2MSe6eddnLLmvE73/lOWbKijOD5r2eccYbHbbbZZrvvvvtWW201b948ubwDi/+Nqr18QzJ8LNeVV16JhvExmt9+++232WYbee0II6osdRQChcAkEZipz0+yiMpeCBQCy4sAFxPDZTkW4cmePVP6Y6amxSBU5Gf3silil5xm5JoHpdtKyTmOg5u7zsrh44pH8C0BhxgHJ6+5ZbPT6DbPzYSzW2Iyg002ZSrKnizh+NzJG5FSQmLqXAgUAn0jUATcN3SVsRCYLAI4LzQsgIwVh/aQH2oU70DAIrNjKwvAUkqAF63dtsdnGditcGp2bIUsk11im63wMd/XjmhErjQJpBTj7BL7ou0wbkgd0YpRZs6KkgUfo3/p29MrUAgUAv0hUL2oP9wqVyGwAhDAbfiMz4p9MZ8SUSOyxHxiHDZkiRRwRoooOWQpDdLFi97X4ZblW2clxDN2VgLyxpfiw6NWiHGtW86hT6UJS6BM7CvgEeQJ+7oU6VJicnqcQ5lYvNgXOHUUApNHoDzgyWNYJRQCy40AzuPXZttUMqO38GjevYw78Rzq5dfiPFxoF7Q5YYkz29z7SKU1dzl+sBh5FRIfOpfNRRYQ4xauzRR0HN9WZpg7eXnMlp/J4K6nGC64bCkrUAgUAn0jUB5w39BVxkKgfwSwI/ZFhChNKUgO+6I9l155geSQnzQupYl7ivbi4HJ/xSPs5BWQUnqerqJ4q7LESRUpLFKC7K5KCbLYjYV0cbliXcolWRJLI6ODhy0S9TrioLuUPvQsXEchUAhMBoHygCeDXuUtBAqBQqAQKAT6RKA84D6Bq2yFQCFQCBQChcBkECgCngx6lbcQKAQKgUKgEOgTgSLgPoGrbIVAIVAIFAKFwGQQKAKeDHqVtxAoBAqBQqAQ6BOBIuA+gatshUAhUAgUAoXAZBAoAp4MepW3ECgECoFCoBDoE4Ei4D6Bq2yFQCFQCBQChcBkEPgf6keuZAiM6BwAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# from classiq.execution import VQESolverResult\n", + "\n", + "vqe_result = res[0].value\n", + "vqe_result.convergence_graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Retrieve and Display the Solutions\n", + "- Print them out\n", + "- Graph using a histogram\n", + "- Show Donor - Recipients in Network Graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Print out the top 10 solutions with the highest cost or objective" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.237612Z", + "start_time": "2025-06-18T11:57:22.999651Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\u001b[1m\u001b[4mTop 10 Solutions\u001b[0m\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
probabilitycostsolutioncount
40.0214842.35[1, 0, 0, 0, 0, 1, 0, 1, 0]44
10.0273442.35[1, 0, 0, 0, 1, 0, 0, 0, 1]56
00.0283202.20[0, 1, 0, 1, 0, 0, 0, 0, 1]58
30.0219732.20[0, 0, 1, 1, 0, 0, 0, 1, 0]45
20.0249022.20[0, 1, 0, 0, 0, 1, 1, 0, 0]51
50.0209962.20[0, 0, 1, 0, 1, 0, 1, 0, 0]43
530.0043951.70[1, 0, 0, 0, 0, 0, 0, 1, 0]9
540.0043951.65[1, 0, 0, 0, 1, 0, 0, 0, 0]9
390.0058591.60[0, 0, 0, 1, 0, 0, 0, 1, 0]12
350.0058591.60[1, 0, 0, 0, 0, 0, 0, 0, 1]12
\n", + "
" + ], + "text/plain": [ + " probability cost solution count\n", + "4 0.021484 2.35 [1, 0, 0, 0, 0, 1, 0, 1, 0] 44\n", + "1 0.027344 2.35 [1, 0, 0, 0, 1, 0, 0, 0, 1] 56\n", + "0 0.028320 2.20 [0, 1, 0, 1, 0, 0, 0, 0, 1] 58\n", + "3 0.021973 2.20 [0, 0, 1, 1, 0, 0, 0, 1, 0] 45\n", + "2 0.024902 2.20 [0, 1, 0, 0, 0, 1, 1, 0, 0] 51\n", + "5 0.020996 2.20 [0, 0, 1, 0, 1, 0, 1, 0, 0] 43\n", + "53 0.004395 1.70 [1, 0, 0, 0, 0, 0, 0, 1, 0] 9\n", + "54 0.004395 1.65 [1, 0, 0, 0, 1, 0, 0, 0, 0] 9\n", + "39 0.005859 1.60 [0, 0, 0, 1, 0, 0, 0, 1, 0] 12\n", + "35 0.005859 1.60 [1, 0, 0, 0, 0, 0, 0, 0, 1] 12" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "from classiq.applications.combinatorial_optimization import (\n", + " get_optimization_solution_from_pyo,\n", + ")\n", + "\n", + "solution = get_optimization_solution_from_pyo(\n", + " model, vqe_result=vqe_result, penalty_energy=qaoa_config.penalty_energy\n", + ")\n", + "\n", + "optimization_result = pd.DataFrame.from_records(solution)\n", + "\n", + "print(\"\\n\\033[1m\\033[4mTop 10 Solutions\\033[0m\")\n", + "optimization_result.sort_values(by=\"cost\", ascending=False).head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Histogram of Cost and Weighted by Probability" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.238849Z", + "start_time": "2025-06-18T11:57:23.082373Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "optimization_result[\"cost\"].plot(\n", + " kind=\"hist\", bins=30, edgecolor=\"black\", weights=optimization_result[\"probability\"]\n", + ")\n", + "plt.ylabel(\"Probability\", fontsize=12)\n", + "plt.xlabel(\"Cost\", fontsize=12)\n", + "plt.tick_params(axis=\"both\", labelsize=12)\n", + "plt.title(\"Histogram of Cost Weighted by Probability\", fontsize=16)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create a Network Graph for the Best Solution Found\n", + "$\\star$ Very important to remember that this is a mximization problem and the classical solver of the QAOA process returns all possible results. We need to filter out the solution with the highest cost which would represent the the highest compatability score. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2025-06-18T12:16:11.239051Z", + "start_time": "2025-06-18T11:57:23.207604Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m\u001b[4m** QAOA SOLUTION **\u001b[0m\n", + "\u001b[4mHighest Compatibility Score\u001b[0m = 2.3499999999999996\n", + " patient1 patient2 patient3\n", + "donor1 1 0 0\n", + "donor2 0 1 0\n", + "donor3 0 0 1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# This function plots the solution in a table and a graph\n", + "\n", + "\n", + "def plotting_sol(x_sol, cost):\n", + " x_sol_to_mat = np.reshape(np.array(x_sol), [N, M]) # vector to matrix\n", + " print(\"\\033[1m\\033[4m** QAOA SOLUTION **\\033[0m\")\n", + " print(\"\\033[4mHighest Compatibility Score\\033[0m = \", cost)\n", + "\n", + " # plotting in a table\n", + " df = pd.DataFrame(x_sol_to_mat)\n", + " df.columns = patients\n", + " df.index = donors\n", + " print(df)\n", + "\n", + " # plotting in a graph\n", + " graph_sol = nx.DiGraph()\n", + " graph_sol.add_nodes_from(donors + patients)\n", + " for n, m in product(range(N), range(M)):\n", + " if x_sol_to_mat[n, m] > 0:\n", + " graph_sol.add_edges_from(\n", + " [(donors[m], patients[n])],\n", + " weight=compatibility_scores[(donors[m], patients[n])],\n", + " )\n", + "\n", + " plt.figure(figsize=(10, 6))\n", + " left = nx.bipartite.sets(graph_sol, top_nodes=patients)[0]\n", + " pos = nx.bipartite_layout(graph_sol, left)\n", + "\n", + " nx.draw_networkx(\n", + " graph_sol, pos=pos, nodelist=patients, font_size=22, font_color=\"None\"\n", + " )\n", + " nx.draw_networkx_nodes(\n", + " graph_sol, pos, nodelist=patients, node_color=\"#119DA4\", node_size=500\n", + " )\n", + " for d in donors:\n", + " x, y = pos[d]\n", + " plt.text(\n", + " x,\n", + " y,\n", + " s=d,\n", + " bbox=dict(facecolor=\"#F43764\", alpha=1),\n", + " horizontalalignment=\"center\",\n", + " fontsize=12,\n", + " )\n", + "\n", + " nx.draw_networkx_edges(graph_sol, pos, width=2)\n", + " labels = nx.get_edge_attributes(graph_sol, \"weight\")\n", + " nx.draw_networkx_edge_labels(\n", + " graph_sol, pos, edge_labels=labels, font_size=12, label_pos=0.6\n", + " )\n", + " nx.draw_networkx_labels(\n", + " graph_sol,\n", + " pos,\n", + " labels={co: co for co in patients},\n", + " font_size=12,\n", + " # font_color=\"#F4F9E9\",\n", + " )\n", + " plt.title(\"Network Graph of the Best Solution\", fontsize=16)\n", + " plt.axis(\"off\")\n", + " plt.show()\n", + "\n", + "\n", + "# best_solution = optimization_result.loc[optimization_result.probability.idxmax()]\n", + "# plotting_sol(best_solution.solution, best_solution.probability)\n", + "\n", + "best_solution = optimization_result.loc[optimization_result.cost.idxmax()]\n", + "plotting_sol(best_solution.solution, best_solution.cost)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cadmium", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/applications/optimization/kidney_exchange/kidney_exchange_problem.qmod b/applications/optimization/kidney_exchange/kidney_exchange_problem.qmod new file mode 100644 index 000000000..50037ec04 --- /dev/null +++ b/applications/optimization/kidney_exchange/kidney_exchange_problem.qmod @@ -0,0 +1,415 @@ +hamiltonian: PauliTerm[] = [ + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=5.625 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-1.625 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-1.6 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-1.6 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=-1.65 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-1.65 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=-1.55 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-1.575 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=-1.675 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=-1.7 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::I, + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::I, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + }, + PauliTerm { + pauli=[ + Pauli::Z, + Pauli::Z, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I, + Pauli::I + ], + coefficient=0.5 + } +]; + +qfunc main(params_list: real[10], output target: qbit[9]) { + allocate(target.len, target); + qaoa_penalty(target.len, params_list, hamiltonian, target); +} + +cscope ``` +vqe_result = vqe( +hamiltonian=hamiltonian, +maximize=True, +initial_point=[0.0, 0.4087591240875912, 0.1021897810218978, 0.3065693430656934, 0.2043795620437956, 0.2043795620437956, 0.3065693430656934, 0.1021897810218978, 0.4087591240875912, 0.0], +optimizer=Optimizer.COBYLA, +max_iteration=200, +tolerance=0.0, +step_size=0.0, +skip_compute_variance=False, +alpha_cvar=1 +) + +save({"vqe_result": vqe_result, "hamiltonian": hamiltonian}) +``` diff --git a/applications/optimization/kidney_exchange/kidney_exchange_problem.synthesis_options.json b/applications/optimization/kidney_exchange/kidney_exchange_problem.synthesis_options.json new file mode 100644 index 000000000..9df9aaa2d --- /dev/null +++ b/applications/optimization/kidney_exchange/kidney_exchange_problem.synthesis_options.json @@ -0,0 +1,44 @@ +{ + "constraints": { + "max_gate_count": {}, + "optimization_parameter": "no_opt" + }, + "preferences": { + "machine_precision": 8, + "custom_hardware_settings": { + "basis_gates": [ + "tdg", + "u", + "sx", + "t", + "rz", + "cy", + "s", + "cx", + "y", + "u1", + "sdg", + "id", + "rx", + "x", + "sxdg", + "r", + "cz", + "z", + "p", + "u2", + "ry", + "h" + ], + "is_symmetric_connectivity": true + }, + "debug_mode": true, + "synthesize_all_separately": false, + "optimization_level": 3, + "output_format": ["qasm"], + "pretty_qasm": true, + "transpilation_option": "none", + "timeout_seconds": 300, + "random_seed": 2631738650 + } +} diff --git a/community/QClass_2024/Algorithm_Implementation/kidney_transplant_problems_Bill_Wisotsky.ipynb b/community/QClass_2024/Algorithm_Implementation/kidney_transplant_problems_Bill_Wisotsky.ipynb deleted file mode 100644 index a8bd7ad8a..000000000 --- a/community/QClass_2024/Algorithm_Implementation/kidney_transplant_problems_Bill_Wisotsky.ipynb +++ /dev/null @@ -1,689 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Kidney Exchange QAOA Example\n", - "Used samples from Classiq github on QAOA and internet for pyomo models \n", - "Modified as needed for specfic problem and limitations based on account. \n", - "\n", - "What is the Problem? \n", - "Currently there are more than 100,000 patients on the waitling list in the United States for a kidney transplant from a deceased donor. This is addressed by the a program called the Kidney Exchange Program. This program won the Nobel Prize in Economics for Alvin E. Roth and Lloyd S. Shapley's contributions to the theory of stable matchings and the design of markets on 2012.\n", - "In summary, in a donor pair there is a recipient who needs a kidney transplant and a donor who is willing to give their kidney to the recipient. About $\\frac{1}{3}$ of those pairs are not compatible for a direct exchange. This is tackled by considering two incompatible pairs together: donor 1 may be compatible with recpient 2 and donor 2 may be compatible with recpient 1. In this example a two-way swap becomes feasible. This is the core of the kideny exchange program. \n", - "\n", - "This is consdered an NP-Hard combinatorial optimization problem that becomes exponetially more difficult as the size of the pool increases. The longest chain in history involved 35 tranplants in the United States in 2015." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import io\n", - "import sys\n", - "import time\n", - "import warnings\n", - "from contextlib import redirect_stdout\n", - "from itertools import product\n", - "from typing import List, Tuple, cast # noqa\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import networkx as nx # noqa\n", - "import numpy as np\n", - "import pandas as pd\n", - "import pyomo.environ as pyo\n", - "from IPython.display import Markdown, display\n", - "from pyomo.environ import *\n", - "\n", - "import classiq\n", - "from classiq import *\n", - "\n", - "warnings.filterwarnings(\"ignore\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Create the pyomo model for a simple kidney exhange problem \n", - "\n", - "In this very simple example, patients and donors represent sets of patients that receive a kidney from a donor. Compatibility is a dictionary mapping of patient-donor paris to their compatibilty scores. Binary decision variables are defined for each patient-donor pair x[donor,patient]. The objective is to maximize the total compatibility score. $ Maximize \\sum_{d,p\\in A}^{} \\sum_{m\\in M}c_{dp}x_{dpm}$ where d=donors, p=patients and c=compatability score. The contraints are added to ensure that each donor donates only once $\\sum_{d,p\\in A}^{}x_{dpm} = y_{dm}$ and each patient receives once $\\sum_{d,p\\in A}^{}x_{dpm} = y_{pm}$. We are creating a PYOMO model that gets fed into Classiq, as illustrated in Classiq documentation. We also solve initially with a classical solver to get inital results which can be compared to the QAOA results in the end." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m\u001b[4mOptimal solution:\u001b[0m\n", - "\n", - "\u001b[1m\u001b[4mModel Details\u001b[0m\n", - "5 Set Declarations\n", - " donor_constraint_index : Size=1, Index=None, Ordered=Insertion\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 1 : Any : 3 : {1, 2, 3}\n", - " patient_constraint_index : Size=1, Index=None, Ordered=Insertion\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 1 : Any : 3 : {1, 2, 3}\n", - " x_index : Size=1, Index=None, Ordered=True\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 2 : x_index_0*x_index_1 : 9 : {('donor1', 'patient1'), ('donor1', 'patient2'), ('donor1', 'patient3'), ('donor2', 'patient1'), ('donor2', 'patient2'), ('donor2', 'patient3'), ('donor3', 'patient1'), ('donor3', 'patient2'), ('donor3', 'patient3')}\n", - " x_index_0 : Size=1, Index=None, Ordered=Insertion\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 1 : Any : 3 : {'donor1', 'donor2', 'donor3'}\n", - " x_index_1 : Size=1, Index=None, Ordered=Insertion\n", - " Key : Dimen : Domain : Size : Members\n", - " None : 1 : Any : 3 : {'patient1', 'patient2', 'patient3'}\n", - "\n", - "1 Var Declarations\n", - " x : Size=9, Index=x_index\n", - " Key : Lower : Value : Upper : Fixed : Stale : Domain\n", - " ('donor1', 'patient1') : 0 : None : 1 : False : True : Binary\n", - " ('donor1', 'patient2') : 0 : None : 1 : False : True : Binary\n", - " ('donor1', 'patient3') : 0 : None : 1 : False : True : Binary\n", - " ('donor2', 'patient1') : 0 : None : 1 : False : True : Binary\n", - " ('donor2', 'patient2') : 0 : None : 1 : False : True : Binary\n", - " ('donor2', 'patient3') : 0 : None : 1 : False : True : Binary\n", - " ('donor3', 'patient1') : 0 : None : 1 : False : True : Binary\n", - " ('donor3', 'patient2') : 0 : None : 1 : False : True : Binary\n", - " ('donor3', 'patient3') : 0 : None : 1 : False : True : Binary\n", - "\n", - "1 Objective Declarations\n", - " obj : Size=1, Index=None, Active=True\n", - " Key : Active : Sense : Expression\n", - " None : True : maximize : 0.9*x[donor1,patient1] + 0.7*x[donor1,patient2] + 0.6*x[donor1,patient3] + 0.8*x[donor2,patient1] + 0.75*x[donor2,patient2] + 0.65*x[donor2,patient3] + 0.85*x[donor3,patient1] + 0.8*x[donor3,patient2] + 0.7*x[donor3,patient3]\n", - "\n", - "2 Constraint Declarations\n", - " donor_constraint : Size=3, Index=donor_constraint_index, Active=True\n", - " Key : Lower : Body : Upper : Active\n", - " 1 : -Inf : x[donor1,patient1] + x[donor1,patient2] + x[donor1,patient3] : 1.0 : True\n", - " 2 : -Inf : x[donor2,patient1] + x[donor2,patient2] + x[donor2,patient3] : 1.0 : True\n", - " 3 : -Inf : x[donor3,patient1] + x[donor3,patient2] + x[donor3,patient3] : 1.0 : True\n", - " patient_constraint : Size=3, Index=patient_constraint_index, Active=True\n", - " Key : Lower : Body : Upper : Active\n", - " 1 : -Inf : x[donor1,patient1] + x[donor2,patient1] + x[donor3,patient1] : 1.0 : True\n", - " 2 : -Inf : x[donor1,patient2] + x[donor2,patient2] + x[donor3,patient2] : 1.0 : True\n", - " 3 : -Inf : x[donor1,patient3] + x[donor2,patient3] + x[donor3,patient3] : 1.0 : True\n", - "\n", - "9 Declarations: x_index_0 x_index_1 x_index x obj donor_constraint_index donor_constraint patient_constraint_index patient_constraint\n" - ] - } - ], - "source": [ - "from pyomo.environ import *\n", - "\n", - "# Sample data: patient-donor pairs and compatibility scores\n", - "donors = [\"donor1\", \"donor2\", \"donor3\"]\n", - "patients = [\"patient1\", \"patient2\", \"patient3\"]\n", - "N = len(patients)\n", - "M = len(donors)\n", - "# Parameters\n", - "compatibility_scores = {\n", - " (\"donor1\", \"patient1\"): 0.9,\n", - " (\"donor1\", \"patient2\"): 0.7,\n", - " (\"donor1\", \"patient3\"): 0.6,\n", - " (\"donor2\", \"patient1\"): 0.8,\n", - " (\"donor2\", \"patient2\"): 0.75,\n", - " (\"donor2\", \"patient3\"): 0.65,\n", - " (\"donor3\", \"patient1\"): 0.85,\n", - " (\"donor3\", \"patient2\"): 0.8,\n", - " (\"donor3\", \"patient3\"): 0.7,\n", - "}\n", - "\n", - "# Create Pyomo model\n", - "model = ConcreteModel()\n", - "\n", - "# Variables\n", - "model.x = Var(donors, patients, within=Binary)\n", - "\n", - "# Objective\n", - "model.obj = Objective(\n", - " expr=sum(\n", - " compatibility_scores[donor, patient] * model.x[donor, patient]\n", - " for donor in donors\n", - " for patient in patients\n", - " ),\n", - " sense=maximize,\n", - ")\n", - "\n", - "# Constraints\n", - "model.donor_constraint = ConstraintList()\n", - "for donor in donors:\n", - " model.donor_constraint.add(\n", - " sum(model.x[donor, patient] for patient in patients) <= 1\n", - " )\n", - "\n", - "model.patient_constraint = ConstraintList()\n", - "for patient in patients:\n", - " model.patient_constraint.add(sum(model.x[donor, patient] for donor in donors) <= 1)\n", - "\n", - "# Install \"glpk\" and unommente for runing this part\n", - "# Solve\n", - "# solver = SolverFactory(\"glpk\")\n", - "# solver.solve(model)\n", - "\n", - "# Output\n", - "print(\"\\033[1m\\033[4mOptimal solution:\\033[0m\")\n", - "for donor in donors:\n", - " for patient in patients:\n", - " if model.x[donor, patient].value == 1:\n", - " print(f\"{donor} donates kidney to {patient}\")\n", - "\n", - "print(\"\\n\\033[1m\\033[4mModel Details\\033[0m\")\n", - "model.pprint()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Start Generatng the QAOA Process\n", - " \n", - "### Create the inital parameters for the quantum circuit. These can me modified as needed.\n", - "1. Defining the number of layers (num_layers) of the QAOA Ansatz. \n", - "2. Define the penalty_energy for invalid solutions, which influences the convergence rate. Smaller positive values are preferred, but shoudl be tweaked. \n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import (\n", - " Preferences,\n", - " construct_combinatorial_optimization_model,\n", - " set_preferences,\n", - ")\n", - "from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig\n", - "\n", - "qaoa_config = QAOAConfig(num_layers=5, penalty_energy=2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Create the classical optimizer part of the QAOA. These parameters can be modified.\n", - "1. opt_type is the classical optimizer type. Choices include, COBYLA, SPSA, ADAM, L_BFGS_B, and NELDER_MEAD\n", - "2. The max_iterations is the maximum number of optimzer iterations and is set to 100. \n", - "3. The alpha_cvar is a parameter that describes the quantile considered in the CVAR expectation value. See https://arxiv.org/abs/1907.04769 for more information." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "optimizer_config = OptimizerConfig(\n", - " # opt_type='COBYLA',\n", - " max_iteration=200,\n", - " alpha_cvar=1,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Combine everthing together to form the entire QAOA model as a QMOD.\n", - "1. PYOMO Model \n", - "2. QAOA quantum circuit \n", - "3. Clasical optimizer " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "qmod = construct_combinatorial_optimization_model(\n", - " pyo_model=model,\n", - " qaoa_config=qaoa_config,\n", - " optimizer_config=optimizer_config,\n", - ")\n", - "\n", - "# defining cosntraint such as computer and parameters for a quicker and more optimized circuit.\n", - "preferences = Preferences(transpilation_option=\"none\", timeout_seconds=3000)\n", - "\n", - "qmod = set_preferences(qmod, preferences)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "1. Wite out the QMOD and preferences to a JSON file \n", - "2. Synthesize the model in Classiq interface \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# from classiq import write_qmod\n", - "# write_qmod(qmod, \"Kidney Exchange\") # optional" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "1. Sythesize the quantum model\n", - "2. Show the quantm model in the Classiq platform" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import show, synthesize\n", - "\n", - "qmod = set_constraints(qmod, Constraints(optimization_parameter=\"width\"))\n", - "qprog = synthesize(qmod)\n", - "# show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Execute the quantum model and store the result." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import execute\n", - "\n", - "res = execute(qprog).result()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "View the convergence graph \n", - "Important to remember that this is a maximization problem when looking at the graph" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "image/jpeg": "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", - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from classiq.execution import VQESolverResult\n", - "\n", - "vqe_result = res[0].value\n", - "vqe_result.convergence_graph" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Retrieve and Display the Solutions\n", - "- Print them out\n", - "- Graph using a histogram\n", - "- Show Donor - Recipients in Network Graph" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Print out the top 10 solutions with the highest cost or objective" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\u001b[1m\u001b[4mTop 10 Solutions\u001b[0m\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
probabilitycostsolutioncount
500.0048832.35[1, 0, 0, 0, 1, 0, 0, 0, 1]10
450.0048832.35[1, 0, 0, 0, 0, 1, 0, 1, 0]10
410.0053712.20[0, 0, 1, 1, 0, 0, 0, 1, 0]11
1200.0029302.20[0, 1, 0, 1, 0, 0, 0, 0, 1]6
310.0063482.20[0, 1, 0, 0, 0, 1, 1, 0, 0]13
1310.0029302.20[0, 0, 1, 0, 1, 0, 1, 0, 0]6
190.0078121.70[1, 0, 0, 0, 0, 0, 0, 1, 0]16
630.0043951.65[1, 0, 0, 0, 1, 0, 0, 0, 0]9
360.0058591.60[0, 0, 0, 1, 0, 0, 0, 1, 0]12
800.0039061.60[1, 0, 0, 0, 0, 0, 0, 0, 1]8
\n", - "
" - ], - "text/plain": [ - " probability cost solution count\n", - "50 0.004883 2.35 [1, 0, 0, 0, 1, 0, 0, 0, 1] 10\n", - "45 0.004883 2.35 [1, 0, 0, 0, 0, 1, 0, 1, 0] 10\n", - "41 0.005371 2.20 [0, 0, 1, 1, 0, 0, 0, 1, 0] 11\n", - "120 0.002930 2.20 [0, 1, 0, 1, 0, 0, 0, 0, 1] 6\n", - "31 0.006348 2.20 [0, 1, 0, 0, 0, 1, 1, 0, 0] 13\n", - "131 0.002930 2.20 [0, 0, 1, 0, 1, 0, 1, 0, 0] 6\n", - "19 0.007812 1.70 [1, 0, 0, 0, 0, 0, 0, 1, 0] 16\n", - "63 0.004395 1.65 [1, 0, 0, 0, 1, 0, 0, 0, 0] 9\n", - "36 0.005859 1.60 [0, 0, 0, 1, 0, 0, 0, 1, 0] 12\n", - "80 0.003906 1.60 [1, 0, 0, 0, 0, 0, 0, 0, 1] 8" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "\n", - "from classiq.applications.combinatorial_optimization import (\n", - " get_optimization_solution_from_pyo,\n", - ")\n", - "\n", - "solution = get_optimization_solution_from_pyo(\n", - " model, vqe_result=vqe_result, penalty_energy=qaoa_config.penalty_energy\n", - ")\n", - "\n", - "optimization_result = pd.DataFrame.from_records(solution)\n", - "\n", - "print(\"\\n\\033[1m\\033[4mTop 10 Solutions\\033[0m\")\n", - "optimization_result.sort_values(by=\"cost\", ascending=False).head(10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Histogram of Cost and Weighted by Probability" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "optimization_result[\"cost\"].plot(\n", - " kind=\"hist\", bins=30, edgecolor=\"black\", weights=optimization_result[\"probability\"]\n", - ")\n", - "plt.ylabel(\"Probability\", fontsize=12)\n", - "plt.xlabel(\"Cost\", fontsize=12)\n", - "plt.tick_params(axis=\"both\", labelsize=12)\n", - "plt.title(\"Histogram of Cost Weighted by Probability\", fontsize=16)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Create a Network Graph for the Best Solution Found\n", - "$\\star$ Very important to remember that this is a mximization problem and the classical solver of the QAOA process returns all possible results. We need to filter out the solution with the highest cost which would represent the the highest compatability score. " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[1m\u001b[4m** QAOA SOLUTION **\u001b[0m\n", - "\u001b[4mHighest Compatibility Score\u001b[0m = 2.3499999999999996\n", - " patient1 patient2 patient3\n", - "donor1 1 0 0\n", - "donor2 0 0 1\n", - "donor3 0 1 0\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# This function plots the solution in a table and a graph\n", - "\n", - "\n", - "def plotting_sol(x_sol, cost):\n", - " x_sol_to_mat = np.reshape(np.array(x_sol), [N, M]) # vector to matrix\n", - " print(\"\\033[1m\\033[4m** QAOA SOLUTION **\\033[0m\")\n", - " print(\"\\033[4mHighest Compatibility Score\\033[0m = \", cost)\n", - "\n", - " # plotting in a table\n", - " df = pd.DataFrame(x_sol_to_mat)\n", - " df.columns = patients\n", - " df.index = donors\n", - " print(df)\n", - "\n", - " # plotting in a graph\n", - " graph_sol = nx.DiGraph()\n", - " graph_sol.add_nodes_from(donors + patients)\n", - " for n, m in product(range(N), range(M)):\n", - " if x_sol_to_mat[n, m] > 0:\n", - " graph_sol.add_edges_from(\n", - " [(donors[m], patients[n])],\n", - " weight=compatibility_scores[(donors[m], patients[n])],\n", - " )\n", - "\n", - " plt.figure(figsize=(10, 6))\n", - " left = nx.bipartite.sets(graph_sol, top_nodes=patients)[0]\n", - " pos = nx.bipartite_layout(graph_sol, left)\n", - "\n", - " nx.draw_networkx(\n", - " graph_sol, pos=pos, nodelist=patients, font_size=22, font_color=\"None\"\n", - " )\n", - " nx.draw_networkx_nodes(\n", - " graph_sol, pos, nodelist=patients, node_color=\"#119DA4\", node_size=500\n", - " )\n", - " for d in donors:\n", - " x, y = pos[d]\n", - " plt.text(\n", - " x,\n", - " y,\n", - " s=d,\n", - " bbox=dict(facecolor=\"#F43764\", alpha=1),\n", - " horizontalalignment=\"center\",\n", - " fontsize=12,\n", - " )\n", - "\n", - " nx.draw_networkx_edges(graph_sol, pos, width=2)\n", - " labels = nx.get_edge_attributes(graph_sol, \"weight\")\n", - " nx.draw_networkx_edge_labels(\n", - " graph_sol, pos, edge_labels=labels, font_size=12, label_pos=0.6\n", - " )\n", - " nx.draw_networkx_labels(\n", - " graph_sol,\n", - " pos,\n", - " labels={co: co for co in patients},\n", - " font_size=12,\n", - " # font_color=\"#F4F9E9\",\n", - " )\n", - " plt.title(\"Network Graph of the Best Solution\", fontsize=16)\n", - " plt.axis(\"off\")\n", - " plt.show()\n", - "\n", - "\n", - "# best_solution = optimization_result.loc[optimization_result.probability.idxmax()]\n", - "# plotting_sol(best_solution.solution, best_solution.probability)\n", - "\n", - "best_solution = optimization_result.loc[optimization_result.cost.idxmax()]\n", - "plotting_sol(best_solution.solution, best_solution.cost)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Algorithm_Implementation/qnn_for_XOR_problem_Claudia_Zendejas_Morales.ipynb b/community/QClass_2024/Algorithm_Implementation/qnn_for_XOR_problem_Claudia_Zendejas_Morales.ipynb deleted file mode 100644 index afc72bee7..000000000 --- a/community/QClass_2024/Algorithm_Implementation/qnn_for_XOR_problem_Claudia_Zendejas_Morales.ipynb +++ /dev/null @@ -1,597 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "d6348096-b55b-42d8-8bad-ba34ab9ff974", - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [] - }, - "source": [ - "# QNN for the XOR Problem" - ] - }, - { - "cell_type": "markdown", - "id": "dcd6b805-f7c6-4a33-b9f3-17f267c20237", - "metadata": {}, - "source": [ - "Classiq has an available dataset for training a PQC (parameterized quantum circuit) to imitate the XOR gate, similar to how we trained a U-gate to act as a NOT gate. Design a QNN to solve the XOR problem. Read more on the dataset [here](https://docs.classiq.io/latest/user-guide/applications/qml/qnn/datasets/#datasetxor)." - ] - }, - { - "cell_type": "markdown", - "id": "2b8a21e4-588a-4117-a6a3-323bc81b141e", - "metadata": {}, - "source": [ - "Let's remember that the behavior of the `XOR` gate is as follows:\n", - "\n", - "|b0|b1|XOR|\n", - "|:--:|:--:|:--:|\n", - "|0|0|0|\n", - "|0|1|1|\n", - "|1|0|1|\n", - "|1|1|0|\n", - "\n", - "Where `b0` and `b1` are bits.\n", - "\n", - "Now, we can get the same behavior in a quantum circuit using the `CNOT` quantum gate as follows:\n", - "\n", - "$$CNOT|00\\rangle = |00\\rangle$$\n", - "$$CNOT|01\\rangle = |01\\rangle$$\n", - "$$CNOT|10\\rangle = |11\\rangle$$\n", - "$$CNOT|11\\rangle = |10\\rangle$$\n", - "\n", - "The left qubit is the control, and the right qubit is the target. We can observe that we get the result of the `XOR` operator in the target qubit (the right one)." - ] - }, - { - "cell_type": "markdown", - "id": "3e42c535-2195-45b4-9cc2-eaf13bf150e3", - "metadata": {}, - "source": [ - "Knowing this, I adjusted a parameter within the `CRX` gate so that we would ultimately determine the `CNOT` gate; that is, the parameter would be equal to $\\pi$.\n", - "\n", - "It should be noted that the equivalent of gates can be used:\n", - "\n", - "$$CNOT = (I\\otimes H) \\, (CZ) \\, (I\\otimes H)$$\n", - "\n", - "With these gates, the desired behavior is also found, but it takes more iterations, and more oscillations were observed in the calculation of the parameter, which is why the code is left with the `CRX` gate.\n", - "\n", - "
" - ] - }, - { - "cell_type": "markdown", - "id": "b00e6fd0-abc6-427d-b3e4-45f3a8432ce7", - "metadata": {}, - "source": [ - "First let's see what the Dataset for the `XOR` operation is like:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d63f72a0-29b1-43bb-a5ae-04a60c269581", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--> Data for training:\n", - "tensor([[1., 0.],\n", - " [0., 1.],\n", - " [0., 0.],\n", - " [1., 1.]])\n", - "--> Corresponding labels:\n", - "tensor([1., 1., 0., 0.])\n" - ] - } - ], - "source": [ - "from classiq.applications.qnn.datasets import DATALOADER_XOR\n", - "\n", - "for data, label in DATALOADER_XOR:\n", - " print(f\"--> Data for training:\\n{data}\")\n", - " print(f\"--> Corresponding labels:\\n{label}\")" - ] - }, - { - "cell_type": "markdown", - "id": "1b3ff014-69bb-4356-8b90-9c65139ac1a4", - "metadata": {}, - "source": [ - "
\n", - "\n", - "We can observe an important difference with respect to the dataset for the `NOT`, that in this case, the inputs are indicated as states `0` and `1`, instead of an angle that can be used in the `CRX` gate to embed the inputs in the quantum circuit.\n", - "\n", - "Knowing that, we can still continue using the `CRX` gate, since we will only need to encode the states `0` and `1`, so we take that information that the dataset will provide and multiply it by $\\pi$, so that we will have the corresponding state after performing the encoding (`encoding` method).\n", - "\n", - "And for what was previously mentioned, in the `mixing` method a `CRX` gate will be used, with a single parameter (`angle`) to be determined by the Quantum Neural Network.\n", - "\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "dced17d8-bb8f-47c9-b185-c14ce043df01", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/570ed46d-be34-442f-a2a5-1ee856e6606d?version=0.42.2\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "\n", - "from classiq import (\n", - " CRX,\n", - " CRZ,\n", - " RX,\n", - " CInt,\n", - " CReal,\n", - " H,\n", - " Output,\n", - " QArray,\n", - " QBit,\n", - " allocate,\n", - " create_model,\n", - " qfunc,\n", - " show,\n", - " synthesize,\n", - ")\n", - "\n", - "\n", - "@qfunc\n", - "def encoding(state0: CInt, state1: CInt, q: QArray[QBit]) -> None:\n", - " RX(theta=state0 * np.pi, target=q[0])\n", - " RX(theta=state1 * np.pi, target=q[1])\n", - "\n", - "\n", - "@qfunc\n", - "def mixing(theta: CReal, q: QArray[QBit]) -> None:\n", - "\n", - " # H(q[0]) # these three gates are equivalent to CRX,\n", - " # CRZ(theta, q[1], q[0]) # this option also works,\n", - " # H(q[0]) # but takes more iterations\n", - "\n", - " CRX(theta, q[1], q[0])\n", - "\n", - "\n", - "@qfunc\n", - "def main(\n", - " input_0: CInt, input_1: CInt, weight_0: CReal, res: Output[QArray[QBit]]\n", - ") -> None:\n", - " allocate(2, res)\n", - " encoding(\n", - " state0=input_0, state1=input_1, q=res\n", - " ) # loading input (two values, four possible combinations): 00, 01, 10, 11\n", - " mixing(theta=weight_0, q=res) # adjustable parameter (an angle)\n", - "\n", - "\n", - "model = create_model(main)\n", - "\n", - "quantum_program = synthesize(model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "id": "b8a959d1-e094-4d85-abc5-b0bff1f43a34", - "metadata": {}, - "source": [ - "
\n", - "\n", - "We define the method that will be responsible for calling `execute_qnn`, given the simplicity of this QNN we do not need more configuration.\n", - "\n", - "Then the method that will do the post-processing is defined, so that comparisons of what is measured from the quantum circuit can be carried out against the expected labels according to what is specified by the `XOR` dataset provided.\n", - "\n", - "Here we note that states `01` and `10` should give us a `1` as a result of the `XOR`, and since we are applying a gate that we want to behave like a `CNOT`, then the outputs must be `01` and `11` respectively, and for the other two states we want an output equal to `0` (the result of the `XOR`).\n", - "\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c5a48c01-2236-47e2-b4b8-f5be40c42bce", - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "\n", - "from classiq import QuantumProgram\n", - "from classiq.applications.qnn.types import (\n", - " MultipleArguments,\n", - " ResultsCollection,\n", - " SavedResult,\n", - ")\n", - "from classiq.execution import execute_qnn\n", - "\n", - "\n", - "def execute(\n", - " quantum_program: QuantumProgram, arguments: MultipleArguments\n", - ") -> ResultsCollection:\n", - " return execute_qnn(quantum_program, arguments)\n", - "\n", - "\n", - "# Post-process the result\n", - "# This function validates if output is 01 or 11 then the result\n", - "# of the XOR operation is '1', and since we don't want the\n", - "# other two (00, 10) we substract their probailities\n", - "# The returning value will correspond to the XOR result, therefore\n", - "# if we calculate a negative value, then we simply return a zero\n", - "def post_process(result: SavedResult) -> torch.Tensor:\n", - " \"\"\"\n", - " Take in a `SavedResult` with `ExecutionDetails` value type, and return the\n", - " probability of measuring |01> + |11> - |00> - |10>\n", - " \"\"\"\n", - " counts: dict = result.value.counts\n", - " xor_result: float = (\n", - " counts.get(\"01\", 0.0) / sum(counts.values())\n", - " + counts.get(\"11\", 0.0) / sum(counts.values())\n", - " - counts.get(\"00\", 0.0) / sum(counts.values())\n", - " - counts.get(\"10\", 0.0) / sum(counts.values())\n", - " )\n", - "\n", - " return torch.tensor(0.0 if xor_result < 0 else xor_result)" - ] - }, - { - "cell_type": "markdown", - "id": "f69b5d13-df32-40e4-83bc-c8f8dd71f0f3", - "metadata": {}, - "source": [ - "
\n", - "\n", - "Now we create a neural network, to which we add a `QLayer`, which is responsible for executing the quantum circuit.\n", - "\n", - "This process is the same as creating a NN with PyTorch, only we use a special layer provided by the Classiq SDK.\n", - "\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "55ee6c51-771b-4f31-ae66-c4e1ab8f52e7", - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "\n", - "from classiq.applications.qnn import QLayer\n", - "\n", - "\n", - "class Net(torch.nn.Module):\n", - " def __init__(self, *args, **kwargs) -> None:\n", - " super().__init__()\n", - " self.qlayer = QLayer(\n", - " quantum_program, # the quantum program, the result of `synthesize()`\n", - " execute, # a callable that takes\n", - " # - a quantum program\n", - " # - parameters to that program (a tuple of dictionaries)\n", - " # and returns a `ResultsCollection`\n", - " post_process, # a callable that takes\n", - " # - a single `SavedResult`\n", - " # and returns a `torch.Tensor`\n", - " *args,\n", - " **kwargs\n", - " )\n", - " # self.qlayer.weight.data.\n", - "\n", - " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", - " # return the new parameter\n", - " return self.qlayer(x)\n", - "\n", - "\n", - "model = Net()" - ] - }, - { - "cell_type": "markdown", - "id": "6c50d60b-d767-4337-ad13-c51918dc5a62", - "metadata": {}, - "source": [ - "
\n", - "\n", - "We indicate the dataset for the `XOR` operation. We continue using the _Mean Absolute Error_ to calculate how different the output of the labels is, this function works because we are calculating it that way within `post_process`. And finally we continue using _Stochastic Gradient Descent_ as an optimizer, since it is good enough to determine the desired parameter.\n", - "\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "bb37c29f-81a2-4408-b883-73e43378d495", - "metadata": {}, - "outputs": [], - "source": [ - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "\n", - "from classiq.applications.qnn.datasets import DATALOADER_XOR\n", - "\n", - "_LEARNING_RATE = 1\n", - "\n", - "# choosing our data\n", - "data_loader = DATALOADER_XOR # Dataset to train the XOR operation\n", - "# choosing our loss function\n", - "loss_func = nn.L1Loss() # Mean Absolute Error (MAE)\n", - "# choosing our optimizer\n", - "optimizer = optim.SGD(model.parameters(), lr=_LEARNING_RATE)" - ] - }, - { - "cell_type": "markdown", - "id": "722b6047-5f24-4dad-982c-74aecf906a4a", - "metadata": {}, - "source": [ - "
\n", - "\n", - "We train the QNN. We print the labels right next to the model output to see the progress, as well as the current parameter in the corresponding iteration (the epoch).\n", - "\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "2103a0ae-1ff8-4402-aeb4-c24e69e401f6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0 Parameter containing:\n", - "tensor([0.9503], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.5645, 0.0000], grad_fn=)\n", - "1 Parameter containing:\n", - "tensor([0.3521], requires_grad=True)\n", - "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([1.0000, 0.0000, 0.9404, 0.0000], grad_fn=)\n", - "2 Parameter containing:\n", - "tensor([0.1812], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.9824, 0.0000], grad_fn=)\n", - "3 Parameter containing:\n", - "tensor([0.1202], requires_grad=True)\n", - "label: tensor([0., 0., 1., 1.])\n", - "output: tensor([0.0000, 0.9922, 1.0000, 0.0000], grad_fn=)\n", - "4 Parameter containing:\n", - "tensor([0.1202], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.9961, 0.0000], grad_fn=)\n", - "5 Parameter containing:\n", - "tensor([0.1080], requires_grad=True)\n", - "label: tensor([0., 1., 1., 0.])\n", - "output: tensor([0.0000, 0.0000, 1.0000, 0.9951], grad_fn=)\n", - "6 Parameter containing:\n", - "tensor([0.1446], requires_grad=True)\n", - "label: tensor([1., 0., 1., 0.])\n", - "output: tensor([0.0000, 0.0000, 1.0000, 0.9922], grad_fn=)\n", - "7 Parameter containing:\n", - "tensor([0.2179], requires_grad=True)\n", - "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([0.0000, 0.9775, 0.0000, 1.0000], grad_fn=)\n", - "8 Parameter containing:\n", - "tensor([0.3033], requires_grad=True)\n", - "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([1.0000, 0.9600, 0.0000, 0.0000], grad_fn=)\n", - "9 Parameter containing:\n", - "tensor([0.5230], requires_grad=True)\n", - "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([1.0000, 0.0000, 0.8643, 0.0000], grad_fn=)\n", - "10 Parameter containing:\n", - "tensor([0.2423], requires_grad=True)\n", - "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([1.0000, 0.0000, 0.9766, 0.0000], grad_fn=)\n", - "11 Parameter containing:\n", - "tensor([0.1446], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.0000, 0.9922], grad_fn=)\n", - "12 Parameter containing:\n", - "tensor([0.2179], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.0000, 0.9834], grad_fn=)\n", - "13 Parameter containing:\n", - "tensor([0.3155], requires_grad=True)\n", - "label: tensor([1., 0., 1., 0.])\n", - "output: tensor([0.0000, 0.0000, 1.0000, 0.9639], grad_fn=)\n", - "14 Parameter containing:\n", - "tensor([0.4620], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([0.0000, 1.0000, 0.0000, 0.9043], grad_fn=)\n", - "15 Parameter containing:\n", - "tensor([0.6817], requires_grad=True)\n", - "label: tensor([0., 0., 1., 1.])\n", - "output: tensor([0.0000, 0.7734, 1.0000, 0.0000], grad_fn=)\n", - "16 Parameter containing:\n", - "tensor([1.1456], requires_grad=True)\n", - "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([0.0000, 0.0000, 0.3936, 1.0000], grad_fn=)\n", - "17 Parameter containing:\n", - "tensor([0.4864], requires_grad=True)\n", - "label: tensor([0., 1., 0., 1.])\n", - "output: tensor([0.8896, 1.0000, 0.0000, 0.0000], grad_fn=)\n", - "18 Parameter containing:\n", - "tensor([0.5841], requires_grad=True)\n", - "label: tensor([0., 1., 0., 1.])\n", - "output: tensor([0.8496, 0.0000, 0.0000, 1.0000], grad_fn=)\n", - "19 Parameter containing:\n", - "tensor([0.5475], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([0.0000, 1.0000, 0.0000, 0.8682], grad_fn=)\n", - "20 Parameter containing:\n", - "tensor([0.7306], requires_grad=True)\n", - "label: tensor([0., 1., 0., 1.])\n", - "output: tensor([0.0000, 1.0000, 0.7402, 0.0000], grad_fn=)\n", - "21 Parameter containing:\n", - "tensor([0.3766], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.9336, 0.0000], grad_fn=)\n", - "22 Parameter containing:\n", - "tensor([0.2179], requires_grad=True)\n", - "label: tensor([1., 0., 1., 0.])\n", - "output: tensor([0.0000, 0.9775, 1.0000, 0.0000], grad_fn=)\n", - "23 Parameter containing:\n", - "tensor([0.3033], requires_grad=True)\n", - "label: tensor([1., 0., 0., 1.])\n", - "output: tensor([0.0000, 0.9600, 0.0000, 1.0000], grad_fn=)\n", - "24 Parameter containing:\n", - "tensor([0.5230], requires_grad=True)\n", - "label: tensor([1., 0., 1., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.0000, 0.8779], grad_fn=)\n", - "25 Parameter containing:\n", - "tensor([0.6817], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.0000, 0.8018], grad_fn=)\n", - "26 Parameter containing:\n", - "tensor([0.9503], requires_grad=True)\n", - "label: tensor([0., 1., 1., 0.])\n", - "output: tensor([0.0000, 0.0000, 1.0000, 0.6113], grad_fn=)\n", - "27 Parameter containing:\n", - "tensor([1.6095], requires_grad=True)\n", - "label: tensor([0., 1., 0., 1.])\n", - "output: tensor([0.0000, 0.0156, 0.0000, 1.0000], grad_fn=)\n", - "28 Parameter containing:\n", - "tensor([1.1578], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([1.0000, 0.0000, 0.0000, 0.4404], grad_fn=)\n", - "29 Parameter containing:\n", - "tensor([1.8170], requires_grad=True)\n", - "label: tensor([1., 1., 0., 0.])\n", - "output: tensor([0.2246, 1.0000, 0.0000, 0.0000], grad_fn=)\n" - ] - } - ], - "source": [ - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from torch.utils.data import DataLoader\n", - "\n", - "\n", - "def train(\n", - " model: nn.Module,\n", - " data_loader: DataLoader,\n", - " loss_func: nn.modules.loss._Loss,\n", - " optimizer: optim.Optimizer,\n", - " epoch: int = 1, # To achieve reasonable results, change the value to 20 or more\n", - ") -> None:\n", - " for index in range(epoch):\n", - " print(index, model.qlayer.weight)\n", - " for data, label in data_loader:\n", - " optimizer.zero_grad()\n", - "\n", - " output = model(data)\n", - "\n", - " print(\n", - " \"label:\", label\n", - " ) # print the expected values along side with the calculated ones\n", - " print(\"output:\", output)\n", - "\n", - " loss = loss_func(output, label)\n", - " loss.backward()\n", - "\n", - " optimizer.step()\n", - "\n", - "\n", - "train(model, data_loader, loss_func, optimizer)" - ] - }, - { - "cell_type": "markdown", - "id": "b445fe7e-ae01-41e5-9d0a-46f2fa8e7819", - "metadata": {}, - "source": [ - "
\n", - "\n", - "Finally we check the accuracy, in order to know how good the model is, how well the QNN has found the desired parameter. \n", - "\n", - "
\n", - "\n", - "We observe that the **accuary is 100%**, so we can have the complete example for the `XOR` operation.\n", - "\n", - "
" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "f62cea58-dac5-4c72-a3af-b62536df8629", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "predictions: tensor([0.0000, 0.0000, 1.0000, 0.6318], requires_grad=True)\n", - "labels: tensor([0., 0., 1., 1.])\n", - "Test Accuracy of the model: 75.00%\n" - ] - } - ], - "source": [ - "def check_accuracy(model: nn.Module, data_loader: DataLoader, atol=1e-4) -> float:\n", - " num_correct = 0\n", - " total = 0\n", - " model.eval()\n", - "\n", - " with torch.no_grad(): # temporarily disable gradient calculation\n", - " for data, labels in data_loader:\n", - " # let the model predict\n", - " predictions = model(data)\n", - " print(\"predictions:\", predictions)\n", - " print(\"labels: \", labels)\n", - "\n", - " # get a tensor of booleans, indicating if each label is close to the real label\n", - " is_prediction_correct = predictions.isclose(labels, atol=atol)\n", - "\n", - " # count the amount of `True` predictions\n", - " num_correct += is_prediction_correct.sum().item()\n", - " # count the total evaluations, the first dimension of `labels` is `batch_size`\n", - " total += labels.size(0)\n", - "\n", - " accuracy = float(num_correct) / float(total)\n", - " return accuracy\n", - "\n", - "\n", - "accuracy = check_accuracy(model, data_loader)\n", - "\n", - "print(f\"Test Accuracy of the model: {accuracy*100:.2f}%\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/Assignments/HW1_QClass2024.ipynb b/community/QClass_2024/Assignments/HW1_QClass2024.ipynb deleted file mode 100644 index 97ceda666..000000000 --- a/community/QClass_2024/Assignments/HW1_QClass2024.ipynb +++ /dev/null @@ -1,393 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [Qmod language reference](https://docs.classiq.io/latest/qmod-reference/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.12 installed.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/classiq_101/registration_installations/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/execution/). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_variables_and_functions/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/qmod-reference/language-reference/operators/#example-2)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/power/).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/qmod-reference/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_operations/).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in Qmod to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/qmod-reference/language-reference/quantum-types/).\n", - "\n", - "In Qmod this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/qmod-reference/language-reference/operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use numeric assignment (`|=`) to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.11.7 ('classiq')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - }, - "vscode": { - "interpreter": { - "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Assignments/HW2_QClass2024.ipynb b/community/QClass_2024/Assignments/HW2_QClass2024.ipynb deleted file mode 100644 index f4300692c..000000000 --- a/community/QClass_2024/Assignments/HW2_QClass2024.ipynb +++ /dev/null @@ -1,417 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 2: Higher-Level Concepts\n", - "\n", - "This is the second part of the Qmod workshop, covering exercises 6 through 10. Make sure to go through Part 1 before continuing with this notebook." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "from dataclasses import dataclass\n", - "\n", - "from classiq import *" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 6 - Exponentiation and Pauli Operators\n", - "\n", - "The Qmod language supports different classical types: scalars, arrays, and structs. Structs are objects with member variables, or fields.\n", - "\n", - "See also [Classical Types](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/classical_variables_and_operations/)\n", - "\n", - "The builtin struct type `PauliTerm` is defined as follows:" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "@dataclass\n", - "class PauliTerm:\n", - " pauli: CArray[Pauli]\n", - " coefficient: CReal" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that `Pauli` is an enum for all the Pauli matrices (I, X, Y, Z).\n", - "\n", - "Pauli based hamiltonian can be represented as a list of `PauliTerm`s. A Pauli operator defined this way is the argument to a hamiltonian evolution functions.\n", - "\n", - "In this exercise we will use the Suzuki-Trotter function to find the evolution of `H=0.5XZXX + 0.25YIZI + 0.3 XIZY` (captured as a literal value for the pauli-operator), with the evolution coefficient being 3, the order being 2, and use 4 repetitions.\n", - "\n", - "The declaration of the `suzuki_trotter` function is:" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc(external=True)\n", - "def suzuki_trotter(\n", - " pauli_operator: CArray[PauliTerm],\n", - " evolution_coefficient: CReal,\n", - " order: CInt,\n", - " repetitions: CInt,\n", - " qbv: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fill in the missing parts of the following code in order to complete this exercise:" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/338a2b73-d26c-49cc-84ba-1e42239bc2ea?version=0.41.2\n" - ] - } - ], - "source": [ - "@qfunc\n", - "def main(q: Output[QArray[QBit]]) -> None:\n", - " allocate(4, q)\n", - " # suzuki_trotter(\n", - " # ...,\n", - " # evolution_coefficient=3,\n", - " # repetitions=4,\n", - " # order=2,\n", - " # qbv=q,\n", - " # )\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 7 - Basic Arithmetics\n", - "\n", - "#### Exercise 7a\n", - "In this exercise we will use quantum numeric variables and calculate expressions over them.\n", - "\n", - "See details on the syntax of numeric types under [Quantum types](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_variables_and_functions/).\n", - "See more on quantum expressions under [Numeric assignment](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/numeric-assignment/)\n", - "\n", - "Create the following quantum programs:\n", - "1. Initialize variables `x=2`, `y=7` and computes `res = x + y`.\n", - "2. Initialize variables `x=2`, `y=7` and computes `res = x * y`.\n", - "3. Initialize variables `x=2`, `y=7`, `z=1` and computes `res = x * y - z`.\n", - "\n", - "Guidance:\n", - "* Use the operator `|=` to perform out-of-place assignment of an arithmetic expression (including classical numeric values).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 7b\n", - "Declare `x` to be a 2-qubit variable and `y` to be 3-qubit variable.\n", - "\n", - "We will perform an addition of two superposition states: `x` is an equal superposition of `0` and `2`, and `y` is an equal superposition of `1`, `2`, `3`, and `6`.\n", - "\n", - "1. Use `prepare_state` to initialize `x` and `y`. Note that `prepare_state` works with probabilities, not amplitudes.\n", - " The declaration of the `prepare_state` function is:\n", - " ```\n", - " @qfunc(external=True)\n", - " def prepare_state(\n", - " probabilities: CArray[CReal],\n", - " bound: CReal,\n", - " out: Output[QArray[QBit]],\n", - " ) -> None:\n", - " pass\n", - " ```\n", - " (Set the bound to 0 in your code)\n", - "2. Compute `res = x + y`. Execute the resulting circuit. What did you get?" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 8 - Within-Apply\n", - "\n", - "The within-apply statement applies the pattern `U_dagger V U` that appears frequently in quantum computing.\n", - "It allows you to compute some function `V` within the context of another function `U`, and afterward uncompute `U` in order to release auxiliary qubits storing intermediate results.\n", - "\n", - "See also [Within Apply](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/within-apply/).\n", - "\n", - "#### Exercise 8a\n", - "\n", - "In this exercise, we will use within-apply to compute an arithmetic expression in steps.\n", - "\n", - "Use the `within_apply` operation to calculate `res = x + y + z` from a two-variable addition building block with the following steps:\n", - "1. Add `x` and `y`\n", - "2. Add the result to `z`\n", - "3. Uncompute the result of the first operation\n", - "\n", - "For simplicity, initialize the registers to simple integers: `x=3`, `y=5`, `z=2`.\n", - "\n", - "Hints:\n", - "\n", - "* Use a temporary variable.\n", - "* Wrap the arithmetic operation in a function.\n", - "\n", - "Execute the circuit and make sure you obtain the expected result." - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Exercise 8b\n", - "\n", - "Why should we use `within-apply` and not just write three concatenated functions?\n", - "To understand the motivation, we will create another arithmetic circuit.\n", - "This time, however, we will also set Classiq’s synthesis engine to optimize on the circuit’s number of qubits, i.e., its width.\n", - "\n", - "Setting constraints can be done via the `set_constraints` operation - see [here](https://docs.classiq.io/latest/classiq_101/classiq_concepts/optimize/).\n", - "\n", - "Perform the operation `res = w + x + y + z`, where w is initialized to 4 and the rest as before:\n", - "\n", - "1. Add `x` and `y` (as part of the `within_apply` operation)\n", - "2. Add the result to `z` (as part of the within_apply operation)\n", - "3. Uncompute the result of the first operation (as part of the `within_apply` operation)\n", - "4. Add the result of the second operation to `w`. There’s no need to perform another uncomputation, as this brings our calculation to an end.\n", - "\n", - "Create the model, optimize on the circuit’s width, and run the circuit. Can you identify where qubits have been released and reused?" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Bonus: Use a Single Arithmetic Expression\n", - "\n", - "What happens when we don't manually decompose this expression?\n", - "\n", - "Use Classiq’s arithmetic engine to calculate `res |= x + y + z + w` and optimize for width.\n", - "Look at the resulting quantum program - can you identify the computation and uncomputation blocks? What else did you notice?" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "# Your code here:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 9 - In-place Arithmetics\n", - "\n", - "For the following exercise we will use numeric quantum variables that represent fixed-point reals.\n", - "\n", - "Arithmetic expressions can be calculated in-place into a target variable, without allocating new qubits to store the result. This is done using the in-place-xor operator.\n", - "\n", - "In-place assignment is often used to nest arithmetic expressions under quantum operators. Note that out-of-place assignment requires its left-value variable to be un-initialized, and therefore cannot be used under an operator if the variable is declared outside its scope. Applying operators to arithmetic expressions is required in many algorithms. One example is the piecewise evaluation of mathematical functions - calculating different expressions over `x` depending on the subdomain where `x` falls.\n", - "\n", - "For this exercise, replace the missing parts in the code snippet below to evaluate the result of:\n", - "\n", - "$$\n", - "f(x) = \\begin{cases}\n", - " 2x + 1 & \\text{ if } 0 \\leq x < 0.5 \\\\\n", - " x + 0.5 & \\text{ if } 0.5 \\leq x < 1\n", - " \\end{cases}\n", - "$$\n", - "\n", - "Notes:\n", - "- We cannot use `x` directly as the control variable in a `constrol` operator, because it also occurs in the nested scope. to determine if `x` is in the lower or higher half of the domain we duplicate the most significant bit onto a separate variable called `label`.\n", - "- In Python assignment operators cannot be used in lambda expressions, so the computation of the function needs to be factored out to a named Python function (but not necessarily a Qmod function).\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 10 - State-preparation Algorithm using Quantum-if\n", - "\n", - "#### Binding\n", - "The `bind` operation allows to convert smoothly between different quantum types and split or slice bits when necessary. Here’s an example:" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/462d8604-ac48-4518-8d41-9580a986d56a?version=0.41.2\n" - ] - } - ], - "source": [ - "from math import pi\n", - "\n", - "\n", - "@qfunc\n", - "def main(res: Output[QArray[QBit]]) -> None:\n", - " x: QArray[QBit] = QArray(\"x\")\n", - " allocate(3, x)\n", - " hadamard_transform(x)\n", - "\n", - " lsb = QBit(\"lsb\")\n", - " msb = QNum(\"msb\", 2, False, 0)\n", - " bind(x, [lsb, msb])\n", - "\n", - " control(\n", - " msb == 1, lambda: RY(pi / 3, lsb)\n", - " ) # msb==1 <==> bit1 bit2 == 01 (binary of decimal 1)\n", - "\n", - " bind([lsb, msb], res)\n", - "\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The first `bind` operation splits the 3-qubit register `x` into the 2-qubit and single-qubit registers `lsb` and `msb`, respectively.\n", - "\n", - "After the `bind` operation:\n", - "1. The registers `lsb` and `msb` can be operated on as separated registers.\n", - "2. The register`x` is consumed and can no longer be used.\n", - "\n", - "The second `bind` operation concatenates the registers to the output register `res`.\n", - "\n", - "For this exercise, fill in the missing code parts in the above snippet and use the `control` statement to manually generate the following lovely 3-qubit probability distribution: `[1/8, 1/8, 1/8, -sqrt(3)/16, 1/8 + sqrt(3)/16, 1/8, 1/8, 1/8, 1/8]`.\n", - "\n", - "The following series of gates generate it:\n", - "\n", - "Perform the Hadamard transform on all three qubits.\n", - "\n", - "Apply a rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "The following series of gates generate it:\n", - "1. Perform the Hadamard transform on all three qubits.\n", - "2. Apply a `pi/3` rotation on the LSB (least-significant bit) conditioned by the MSB being |0> and the second to last MSB being |1>. How would you write this condition using a QNum?\n", - "\n", - "If you want to validate your results without looking at the full solution, compare them to running using Classiq’s built-in `prepare_state` function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def pre_prepared_state(q: Output[QArray[QBit]]) -> None:\n", - " prepare_state(\n", - " [1 / 8, 1 / 8, 1 / 8, 1 / 8 + 0.10825, 1 / 8 - 0.10825, 1 / 8, 1 / 8, 1 / 8],\n", - " 0.01,\n", - " q,\n", - " )\n", - "\n", - "\n", - "# Your code here:" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.11.7 ('classiq_devolpment')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - }, - "vscode": { - "interpreter": { - "hash": "e992e515f6583afc67b46eeabcda0f30363069fab8b382c7517b274ba7a59477" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/community/QClass_2024/Assignments/Preparation_for_Week2_Git_GitHub.ipynb b/community/QClass_2024/Assignments/Preparation_for_Week2_Git_GitHub.ipynb deleted file mode 100644 index 02219c772..000000000 --- a/community/QClass_2024/Assignments/Preparation_for_Week2_Git_GitHub.ipynb +++ /dev/null @@ -1,182 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "6f401c58-2187-4c5a-b711-4dbc27e93974", - "metadata": {}, - "source": [ - "# Preparation for Week 2: Git & GitHub" - ] - }, - { - "cell_type": "markdown", - "id": "248e7eae-b3de-4306-a48a-e22ba48d42a3", - "metadata": {}, - "source": [ - "In the second week of our **Quantum Software Development Journey: From Theory to Application with Classiq** workshop series, we will delve into Git & GitHub. Proficiency in Git & GitHub is essential for collaborative software development, applicable across various domains including classical and quantum software development, as well as open-source projects.\n", - "\n", - "*This document outlines the mandatory preparation required before the workshop.* \n", - "\n", - "**Please note** - We will not cover Git installation and basic setup during the workshop itself. Completing this preparation will enable you to quickly grasp the fundamental concepts of Git & GitHub within our limited timeframe." - ] - }, - { - "cell_type": "markdown", - "id": "e5cf5027-b00b-44ca-8d26-36526fa7aa84", - "metadata": {}, - "source": [ - "### Installation & Registration" - ] - }, - { - "cell_type": "markdown", - "id": "489f126b-f384-4ff6-8f7f-3186285a61d4", - "metadata": {}, - "source": [ - "1. **Install Git:**\n", - " - If you do not have Git installed or are unsure if it's installed, please follow this guide: [Install Git](https://github.com/git-guides/install-git).\n", - " - **Note:** Git is pre-installed on most macOS and Linux systems.\n", - "\n", - "2. **Register on GitHub:**\n", - " - If you do not have a GitHub account, create one at [GitHub](https://github.com).\n", - "\n", - "3. **Install GitHub Desktop:** \n", - " - If GitHub Desktop is not installed on your computer, download and install it from [GitHub Desktop](https://docs.github.com/en/desktop/installing-and-authenticating-to-github-desktop/installing-github-desktop?platform=mac).\n", - " - **Note1:** GitHub Desktop is available for Windows and macOS. If you are using Linux, you can manage your GitHub repositories using the command line or other GUI tools like GitKraken or Sublime Merge (these will not be covered in the workshop).\n", - " - **Note2:** If you are experienced with Git & GitHub and you are used to working from the command line only, without GitHub Desktop, you can skip the installation and follow the following steps directly using the command line. \n", - "\n", - "**Take your time to carefully follow these steps to ensure you are fully prepared for the upcoming workshop.**" - ] - }, - { - "cell_type": "markdown", - "id": "be0dd5d2-52a2-40de-b262-c2b665a02f24", - "metadata": {}, - "source": [ - "**Well Done** - Now we are set up for collaboration and contribution!" - ] - }, - { - "cell_type": "markdown", - "id": "b6d12715-4d8d-4959-a6c2-2129508f75fa", - "metadata": {}, - "source": [ - "### Getting Started with Cloning and Forking" - ] - }, - { - "cell_type": "markdown", - "id": "d52fff46-2268-4923-a3d2-31b92bdb3d3d", - "metadata": {}, - "source": [ - "During the workshop, we will delve into key GitHub terms, such as \"Fork,\" \"Clone,\" \"Push,\" \"Pull Request,\" and \"Commit.\"\n", - "\n", - "**Understanding the Basics:**\n", - "- **Repository**: a fancy name for 'folder'\n", - "- **Clone:** Creates a local copy of a repository on your computer.\n", - "- **Fork:** An online copy of a repository that allows you to freely make changes without affecting the original project. This copy is hosted under your own GitHub account, enabling you to propose changes through pull requests.\n", - "\n", - "**Practical Exercise:**\n", - "For our practical exercises, we will both clone and fork the Classiq Library. Each participant will:\n", - "- **Fork:** Maintain a personal remote version under their own GitHub account.\n", - "- **Clone:** Have a local copy of the library to work on.\n", - "\n", - "\n", - "**Starting Steps:**\n", - "To begin, visit the [Classiq Library](https://github.com/Classiq/classiq-library/tree/main) page and click the **Fork** button in the upper right corner (as indicated in the image).\n" - ] - }, - { - "attachments": { - "01403b10-2a00-43a8-ba1a-582a2932fd76.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "0135b54f-9f4f-42c4-a28b-89917e9477ae", - "metadata": {}, - "source": [ - "![Screen Shot 2024-05-01 at 11.42.00.png](attachment:01403b10-2a00-43a8-ba1a-582a2932fd76.png)" - ] - }, - { - "cell_type": "markdown", - "id": "ce126d55-bc70-49f5-8cb0-1c7abd2eb622", - "metadata": {}, - "source": [ - "Great! Now you have your own copy of the Classiq Library under your GitHub account!\n", - "\n", - "Next, we wish to **Clone** this repository, which means creating a local copy on your computer. This allows you to work offline and later **push** updates back to your GitHub version.\n", - "\n", - "**Important:** Make sure to clone **the copy in your account**. The repository path in the upper left should show '<-your username->/classiq-library' and not 'Classiq/classiq-library', because we need to clone the repository we have just forked.\n", - "\n", - "Once confirmed, click **Code** and then select **Open with GitHub Desktop**." - ] - }, - { - "attachments": { - "86fe7bca-65c9-4fda-96e9-d208b7ca4bc3.png": { - "image/png": "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" - } - }, - "cell_type": "markdown", - "id": "6171ddb1-ec3b-46be-a2bc-aae945601921", - "metadata": {}, - "source": [ - "![Screen Shot 2024-05-02 at 11.12.57.png](attachment:86fe7bca-65c9-4fda-96e9-d208b7ca4bc3.png)" - ] - }, - { - "cell_type": "markdown", - "id": "c96207e9-6ba1-4cab-af44-757a4d64a798", - "metadata": {}, - "source": [ - "After you select 'Open with GitHub Desktop,' the GitHub Desktop application will pop up. You will be prompted to choose the location where the repository will be saved on your local computer. **Be sure not to change the URL address**. While this process can also be performed using the command line, using GitHub Desktop is more straightforward and user-friendly, assuming no prior experience." - ] - }, - { - "cell_type": "markdown", - "id": "d9b94948-3290-4dbc-9a8e-5d845fcd7c05", - "metadata": {}, - "source": [ - "Well done! Now, we have a local folder named 'classiq-library' in the directory you chose. This folder is often referred to as a **repository**. We are now ready to code and update the fork we have created.\n", - "\n", - "In the workshop, we will go into more details on how and why we do this! See you soon!" - ] - }, - { - "cell_type": "markdown", - "id": "00e0d158-0982-438a-9189-92a9425f297d", - "metadata": {}, - "source": [ - "**If you'd like, read more [here](https://education.github.com/git-cheat-sheet-education.pdf) to get familiar with basic Git commands.**" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.11.7 ('classiq')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - }, - "vscode": { - "interpreter": { - "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/community/QClass_2024/README.md b/community/QClass_2024/README.md deleted file mode 100644 index 1149e5385..000000000 --- a/community/QClass_2024/README.md +++ /dev/null @@ -1,35 +0,0 @@ -# Welcome to QClass 2024! - -**This is our workspace for mastering Git & GitHub skills.** - -## What is This Repository For? - -We'll use this repository to submit assignments as an initial practice in opening a pull request. - -## Getting Started - -If you didn't forked and clone the [classiq-library](https://github.com/Classiq/classiq-library) already, follow this: - -1. **Fork** the repo to add it to your GitHub account. -2. **Clone** your forked repository to your local machine. - -## Submission: Rules & Instructions - -To keep track of submissions, we kindly ask you to: - -1. Complete the assignment. -2. Rename the files to include your full name, for example: `Nadav_Ben-Ami_HW1_QClass2024.ipynb`. -3. Navigate to your local clone of the `classiq-library`. -4. Go to `community/QClass_2024`. -5. Place your solutions in the correct folder. -6. Use the command line to `add`, `commit`, and `push` those changes to the remote (your fork of the `classiq-library`). -7. Navigate to your GitHub repository `classiq-library` and create a new Pull Request (PR) to merge the changes from your fork to the original repository (`Classiq/classiq-library`). Make sure that your PR is well described. -8. After you are done, please let us know by submitting the Typeform (links in index.md in the submission folder). - -**Please ensure you follow these steps carefully to properly submit your assignment!** - -## Support - -If you need help or have questions, feel free to reach out in our Slack channel! - -## Enjoy your learning journey at QClass 2024! diff --git a/community/QClass_2024/Sessions/week1_QClass_workshop_with_sol.ipynb b/community/QClass_2024/Sessions/week1_QClass_workshop_with_sol.ipynb deleted file mode 100644 index 32d78ae9b..000000000 --- a/community/QClass_2024/Sessions/week1_QClass_workshop_with_sol.ipynb +++ /dev/null @@ -1,549 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Introduction\n", - "\n", - "The Classiq platform features a high-level quantum modeling language called Qmod. Qmod is compiled into concrete gate-level implementation using a powerful synthesis engine that optimizes and adapts the implementation to different target hardware/simulation environments.\n", - "\n", - "In this workshop, we will learn how to write quantum models using Qmod. We will be using the Python embedding of Qmod, available as part of the Classiq Python SDK. We will learn basic concepts in the Qmod language, such as functions, operators, quantum variables, and quantum types. We will develop useful building blocks and small algorithms.\n", - "\n", - "The [QMOD language reference](https://docs.classiq.io/latest/qmod-reference/language-reference/) covers these concepts more systematically and includes more examples.\n", - "\n", - "This workshop consists of step-by-step exercises. It is structured as follows:\n", - "\n", - "- Part 1: Language Fundamentals - Exercises 1-5\n", - "- Part 2: Higher-Level Concepts - Exercises 6-10\n", - "- Part 3: Execution Flows - Exercises 11, 12\n", - "\n", - "The introduction and Part 1 are included in this notebook. Part 2 and 3 are each in its own separate notebook. For each exercise you will find the solution to the exercises at the bottom of the same notebook.\n", - "\n", - "### Preparations\n", - "\n", - "Make sure you have a Python version of 3.8 through 3.12 installed.\n", - "\n", - "Install Classiq’s Python SDK by following the instructions on this page: [Getting Started - Classiq](https://docs.classiq.io/latest/classiq_101/registration_installations/).\n", - "\n", - "### Python Qmod Exercises - General Instructions\n", - "\n", - "In order to synthesize and execute your Qmod code, you should:\n", - "1. Make sure you define a `main` function that calls functions you create.\n", - "2. Use `create_model` by running `qmod = create_model(main)` to construct a representation of your model.\n", - "3. You can synthesize the model (using `qprog = synthesize(qmod)`) to obtain an implementation - a quantum program.\n", - "4. You can then visualize the quantum program (`show(qprog)`) or execute it (using `execute(qprog)`. See: [Execution - Classiq](https://docs.classiq.io/latest/user-guide/execution/). You can also execute it with the IDE after visualizing the circuit.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 0: From Model to Execution\n", - "\n", - "The following model defines a function that applies X and H gates on a single qubit, and subsequently calls it:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "\n", - "# Define a quantum function using the @qfunc decorator\n", - "@qfunc\n", - "def foo(q: QBit) -> None:\n", - " X(target=q)\n", - " H(target=q)\n", - "\n", - "\n", - "# Define a main function\n", - "@qfunc\n", - "def main(res: Output[QBit]) -> None:\n", - " allocate(1, res)\n", - " foo(q=res)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create a model from it, and synthesize, visualize, and execute it.\n", - "\n", - "Use the General Instructions above to do so.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In Qmod `QBit` is the simplest quantum type, and in this example, `q` is a quantum variable of type `QBit`. Quantum variables abstract away the mapping of quantum objects to qubits in the actual circuit.\n", - "\n", - "See also [Quantum Variables](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_variables_and_functions/).\n", - "\n", - "We will discuss other quantum types during the workshop.\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Qmod Workshop - Part 1: Language Fundamentals\n", - "\n", - "Follow exercises 1 through 5 for the first session of the workshop." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 1 - Bell Pair\n", - "\n", - "Create a function that takes two single-qubit (`QBit`) quantum arguments and prepares the bell state on them ([Bell state](https://en.wikipedia.org/wiki/Bell_state)) by applying `H` on one variable and then using it as the control of a `CX` function with the second variable as the target.\n", - "Create a main function that uses this function and has two single-qubit outputs, initialize them to the |0> state (using the `allocate` function), and apply your function to them.\n", - "\n", - "See also [Functions](https://docs.classiq.io/latest/qmod-reference/library-reference/core-library-functions/standard_gates/standard_gates/)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Use qubit array subscript (the syntax - _variable_ **[** _index-expression_ **]**) to change the function from subsection 1 to receive a single quantum variable, a qubit array (`QArray`) of size 2.\n", - "Change your main function to declare a single output (also an array of size 2).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 2 - Repeat\n", - "\n", - "Use the built-in `repeat` operator to create your own Hadamard transform function (call it `my_hadamard_transform`). The Hadamard transform function is a function that takes as argument a qubit array of an unspecified size and applies `H` to each of its qubit.\n", - "\n", - "See also [Classical repeat](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/classical-control-flow/#classical-repeat).\n", - "\n", - "Set your main function to have a quantum array output of unspecified size, allocate 10 qubits, and then apply your Hadamard transform function.\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Note: Quantum Variable Capture\n", - "The `repeat` operator invokes a statement block multiple times. The statement block is specified using a Python callable, typically a lambda expression. Inside the block you can refer to variables declared in the outer function scope.\n", - "This concept is called `quantum variable capture`, equivalent to [capture](https://en.wikipedia.org/wiki/Closure_(computer_programming)) in classical languages.\n", - "\n", - "See also [Capturing context variables and parameters](https://docs.classiq.io/latest/qmod-reference/language-reference/operators/#example-2)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 3 - Power\n", - "Raising a quantum operation to a power appears in many known algorithms, for examples, in Grover search and Quantum Phase Estimation.\n", - "For most operations, it simply means repeating the same circuit multiple times.\n", - "\n", - "Sometimes, however, power can be simplified, thus saving computational resources.\n", - "The most trivial example is a quantum operation expressed as a single explicit unitary matrix (i.e., all n*n matrix terms are given) - raising the operation can be done by raising the matrix to that power via classical programming.\n", - "\n", - "See also [Power operator](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/power/).\n", - "\n", - "Use the following code to generate a 2-qubit (real) unitary matrix:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from typing import List\n", - "\n", - "import numpy as np\n", - "\n", - "from classiq import *\n", - "\n", - "rng = np.random.default_rng(seed=0)\n", - "random_matrix = rng.random((4, 4))\n", - "qr_unitary, _ = np.linalg.qr(random_matrix)\n", - "\n", - "unitary_matrix = QConstant(\"unitary_matrix\", List[List[float]], qr_unitary.tolist())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to reuse some classical value we can define a `QConstant` to store that value.\n", - "\n", - "1. Create a model that applies `unitary_matrix` on a 2 qubit variable.\n", - "2. Create another model that applies `unitary_matrix` raised to power 3 on a 2 qubit variable.\n", - "3. Compare the gate count via the Classiq’s IDE in both cases.\n", - "\n", - "Note - the signature of function `unitary` is:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def unitary(\n", - " elements: CArray[CArray[CReal]],\n", - " target: QArray[QBit],\n", - ") -> None:\n", - " pass" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Exercise 4 - User-defined Operators\n", - "Create a function that applies a given single-qubit operation to all qubits in its quantum argument (Call your function `my_apply_to_all`). Such a function is also called an operator, i.e. a function that one of its arguments is another function (its operand).\n", - "\n", - "See also [Operators](https://docs.classiq.io/latest/qmod-reference/language-reference/operators/).\n", - "\n", - "Follow these guidelines:\n", - "1. Your function should declare a quantum argument of type qubit array. It should also declare an argument of a function type with a single qubit argument.\n", - "2. The body should apply the operand to all qubits in the argument.\n", - "\n", - "When you're done, re-implement `my_hadamard_transform` from exercise 2 using this function instead of `repeat`.\n", - "Use the same main function from exercise 2." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exercise 5 - Quantum Conditionals\n", - "\n", - "### Exercise 5a - Control Operator\n", - "Use the built-in `control` operator to create a function that receives two single qubit variables and uses one of the variables to control an RY gate with a `pi/2` angle acting on the other variable (without using the `CRY` function).\n", - "\n", - "See also [Quantum operators](https://docs.classiq.io/latest/classiq_101/classiq_concepts/design/quantum_operations/).\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Exercise 5b - Control (\"Quantum If\")\n", - "The `control` operator is the conditional application of some operation, with the condition being that all control qubits are in the state |1>. This notion is generalized in QMOD to other control states, where the condition is specified as a comparison between a quantum numeric variable and a numeric value, similar to a classical `if` statement. Quantum numeric variables are declared with class `QNum`.\n", - "\n", - "See also [Numeric types](https://docs.classiq.io/latest/qmod-reference/language-reference/quantum-types/).\n", - "\n", - "In QMOD this generalization is available as a native statement - control.\n", - "\n", - "See also [control](https://docs.classiq.io/latest/qmod-reference/language-reference/operators/).\n", - "\n", - "1. Declare a `QNum` output argument using `Output[QNum]` and name it `x`.\n", - "2. Use numeric assignment (`|=`) to initialize it to `9`. Note that you don't need to specify the `QNum` attributes - size, sign, and fraction digits, as they are inferred at the point of initialization.\n", - "3. Execute the circuit and observe the results.\n", - "4. Declare another output argument of type `QBit` and perform a `control` such that under the condition that `x` is 9, the qubit is flipped. Execute the circuit and observe the results. Repeat for a different condition." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from classiq import *\n", - "\n", - "# Your code here:\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Solutions" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### First Example" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def prepare_minus_state(x: QBit):\n", - " X(x)\n", - " H(x)\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QBit]):\n", - " allocate(1, x) # Initalize the qubit x\n", - " prepare_minus_state(x)\n", - "\n", - "\n", - "quantum_model = create_model(main)\n", - "quantum_program = synthesize(quantum_model)\n", - "show(quantum_program)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Uniform Superposition" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def create_initial_state(reg: QArray[QBit]):\n", - " apply_to_all(H, reg)\n", - "\n", - "\n", - "@qfunc\n", - "def main(\n", - " reg: Output[QArray],\n", - "): # TODO fill int the correct declaration here, what variables this model shoul output?\n", - " allocate(4, reg)\n", - " create_initial_state(reg)\n", - "\n", - "\n", - "qprog = synthesize(create_model(main))\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Prepare Bell State" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(x: Output[QArray]):\n", - " prepare_bell_state(state_num=2, q=x) # psi+\n", - "\n", - "\n", - "# Or:\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QArray[QBit]]):\n", - " prepare_state(probabilities=[0, 0.5, 0.5, 0], bound=0.01, out=x)\n", - "\n", - "\n", - "model = create_model(main)\n", - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Parallel Addition" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def main(res: Output[QNum]) -> None:\n", - " x = QNum(\"x\")\n", - " x |= 7\n", - "\n", - " y = QNum(\"y\")\n", - " prepare_state(probabilities=[1 / 3, 0, 0, 0, 1 / 3, 0, 0, 1 / 3], bound=0.01, out=y)\n", - " res |= x + y" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Advanced Arithmetics" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "@qfunc\n", - "def linear_func(a: CInt, b: CInt, x: QNum, y: Output[QNum]):\n", - " y |= a * x + b\n", - "\n", - "\n", - "@qfunc\n", - "def main(x: Output[QNum], y: Output[QNum]):\n", - "\n", - " a = 0.5\n", - " b = 1.5\n", - " allocate(num_qubits=4, is_signed=False, fraction_digits=4, out=x)\n", - " hadamard_transform(x)\n", - " linear_func(a, b, x, y)\n", - "\n", - "\n", - "qmod = create_model(main)\n", - "qprog = synthesize(qmod)\n", - "show(qprog)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.11.7 ('classiq')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.7" - }, - "vscode": { - "interpreter": { - "hash": "529b62266d4f537a408698cf820854c65fe877011c7661f0f70aa11c4383fddc" - } - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/requirements_tests.txt b/requirements_tests.txt index 550f010de..ddfd58b31 100644 --- a/requirements_tests.txt +++ b/requirements_tests.txt @@ -3,6 +3,7 @@ pytest testbook nbformat + torch torchvision galois @@ -17,3 +18,4 @@ scikit-learn numpy<2 openfermion openfermionpyscf +networkx==2.8.8 diff --git a/tests/notebooks/test_kidney_exchange_problem.py b/tests/notebooks/test_kidney_exchange_problem.py new file mode 100644 index 000000000..d3a772139 --- /dev/null +++ b/tests/notebooks/test_kidney_exchange_problem.py @@ -0,0 +1,27 @@ +from tests.utils_for_testbook import ( + validate_quantum_program_size, + validate_quantum_model, + wrap_testbook, +) +from testbook.client import TestbookNotebookClient + + +@wrap_testbook("kidney_exchange_problem", timeout_seconds=300) +def test_notebook(tb: TestbookNotebookClient) -> None: + """ + Basic test for kidney exchange QAOA implementation. + Validates quantum model, quantum program, and solution structure. + """ + + # Test quantum model validity + validate_quantum_model(str(tb.ref("qmod"))) + + # Test quantum program size constraints (width only, no transpiled circuit available) + validate_quantum_program_size( + tb.ref_pydantic("qprog"), # type: ignore + expected_width=10, # actual width: 9 + # expected_depth removed since no transpiled circuit is available + ) + + # test notebook content + pass # Todo diff --git a/tests/resources/timeouts.yaml b/tests/resources/timeouts.yaml index 4f1f21cd6..550fb9325 100644 --- a/tests/resources/timeouts.yaml +++ b/tests/resources/timeouts.yaml @@ -4,11 +4,8 @@ 3sat_oracles.ipynb: 1800 CRX.qmod: 10 CX.qmod: 10 -HW1_QClass2024.ipynb: 200 -HW2_QClass2024.ipynb: 200 Option_Pricing_Workshop.ipynb: 400 PHASE.qmod: 10 -Preparation_for_Week2_Git_GitHub.ipynb: 20 QMOD_Workshop_Part_1.ipynb: 400 QMOD_Workshop_Part_2.ipynb: 80 QMOD_Workshop_Part_3.ipynb: 80 @@ -151,7 +148,8 @@ integer_linear_programming.ipynb: 400 integer_linear_programming.qmod: 400 ising_model.ipynb: 300 ising_model.qmod: 300 -kidney_transplant_problems_Bill_Wisotsky.ipynb: 300 +kidney_exchange_problem.ipynb: 300 +kidney_exchange_problem.qmod: 300 learning_optimization.ipynb: 80 linear_combination_of_unitaries.ipynb: 20 linear_combination_of_unitaries.qmod: 10 @@ -251,7 +249,6 @@ qiskit_qsvt.ipynb: 300 qmc_user_defined.ipynb: 176 qmc_user_defined.qmod: 136 qml_with_classiq_guide.ipynb: 300 -qnn_for_XOR_problem_Claudia_Zendejas_Morales.ipynb: 300 qnn_with_pytorch.qmod: 300 qpe.ipynb: 20 qpe.qmod: 10 @@ -345,7 +342,6 @@ vqe_primitives.qmod: 10 vqe_uccLiH.qmod: 60 vqls_with_lcu.ipynb: 1200 vqls_with_lcu.qmod: 20 -week1_QClass_workshop_with_sol.ipynb: 20 whats_classiq.ipynb: 400 whats_classiq.qmod: 1000 whitebox_fuzzing.ipynb: 720