From 21c39ed8b1046fac5525cf8811e085fb3ecd850f Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 15 Jan 2026 15:42:03 +0100 Subject: [PATCH 01/20] Sketch of first implementations --- qbraid_algorithms/qaoa/__init__.py | 17 +++ qbraid_algorithms/qaoa/cost.py | 21 ++++ qbraid_algorithms/qaoa/mixer.py | 0 qbraid_algorithms/qaoa/qaoa.py | 0 qbraid_algorithms/qaoa/test.ipynb | 160 +++++++++++++++++++++++++++++ 5 files changed, 198 insertions(+) create mode 100644 qbraid_algorithms/qaoa/__init__.py create mode 100644 qbraid_algorithms/qaoa/cost.py create mode 100644 qbraid_algorithms/qaoa/mixer.py create mode 100644 qbraid_algorithms/qaoa/qaoa.py create mode 100644 qbraid_algorithms/qaoa/test.ipynb diff --git a/qbraid_algorithms/qaoa/__init__.py b/qbraid_algorithms/qaoa/__init__.py new file mode 100644 index 0000000..51e2e46 --- /dev/null +++ b/qbraid_algorithms/qaoa/__init__.py @@ -0,0 +1,17 @@ +# Copyright 2025 qBraid +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# from .qaoa + +# __all__ = ["generate_program", "save_to_qasm"] diff --git a/qbraid_algorithms/qaoa/cost.py b/qbraid_algorithms/qaoa/cost.py new file mode 100644 index 0000000..e1c125d --- /dev/null +++ b/qbraid_algorithms/qaoa/cost.py @@ -0,0 +1,21 @@ +from qbraid_algorithms.qtran import GateLibrary, std_gates + + +def bit_driver(builder, qubits, b): + std = builder.import_library(lib_class=std_gates) + + name = f"qaoa_cost_{len(qubits)}" # BUG FIX: Include depth in name + + qubit_list = "{" + ",".join([str(q) for q in qubits]) + "}" + + qubit_array_param = f"qubit[{len(qubits)}] qubits" + + std.begin_subroutine( + name, [qubit_array_param] + ) + + for i in qubits: + std.z(i) + + std.end_subroutine() + diff --git a/qbraid_algorithms/qaoa/mixer.py b/qbraid_algorithms/qaoa/mixer.py new file mode 100644 index 0000000..e69de29 diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py new file mode 100644 index 0000000..e69de29 diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb new file mode 100644 index 0000000..df0e380 --- /dev/null +++ b/qbraid_algorithms/qaoa/test.ipynb @@ -0,0 +1,160 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 9, + "id": "aba58bd7", + "metadata": {}, + "outputs": [], + "source": [ + "import qbraid_algorithms\n", + "from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "afc9ad5b", + "metadata": {}, + "outputs": [], + "source": [ + "qubits = range(3)\n", + "\n", + "builder = QasmBuilder(3)\n", + "\n", + "b=0\n", + "\n", + "std = builder.import_library(lib_class=std_gates)\n", + " \n", + "name = f\"qaoa_cost_{len(qubits)}\" # BUG FIX: Include depth in name\n", + "\n", + "qubit_list = \"{\" + \",\".join([str(q) for q in qubits]) + \"}\"\n", + "\n", + "qubit_array_param = f\"qubit[{len(qubits)}] qubits\"\n", + "\n", + "std.begin_subroutine(\n", + " name, [qubit_array_param]\n", + ")\n", + "\n", + "for i in qubits:\n", + " std.z(i)\n", + "\n", + "std.end_subroutine()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "18ff0ac8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "qaoa_cost_3\n" + ] + } + ], + "source": [ + "print(name)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "f9157c73", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{0,1,2}\n" + ] + } + ], + "source": [ + "print(qubit_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "3f709bd4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'qubit[3] qubits'" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qubit_array_param" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "4f079fbd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning (QasmBuilder): built qasm has unclosed scope, string will fail compile in native\n", + "OPENQASM 3;\n", + "include \"stdgates.inc\";\n", + "qubit[3] qb;\n", + "bit[3] cb;\n", + "def qaoa_cost_3(qubit[3] qubits) {\n", + "\trz(0.45) qb[0];\n", + "\trz(0.45) qb[1];\n", + "\trz(0.45) qb[2];\n", + "\n" + ] + } + ], + "source": [ + "program = builder.build()\n", + "print(program)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df258b64", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 508a88eefc457d5780583405a732a7dda2d1af28 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Tue, 20 Jan 2026 21:48:04 +0100 Subject: [PATCH 02/20] Implementation of QAOA maxcut functions --- examples/evolutions.ipynb | 121 +++++------- qbraid_algorithms/qaoa/__init__.py | 4 +- qbraid_algorithms/qaoa/qaoa.py | 110 +++++++++++ qbraid_algorithms/qaoa/test.ipynb | 238 ++++++++++++++++++++---- qbraid_algorithms/qtran/gate_library.py | 10 + 5 files changed, 371 insertions(+), 112 deletions(-) diff --git a/examples/evolutions.ipynb b/examples/evolutions.ipynb index 9d31ad8..cc3ae85 100644 --- a/examples/evolutions.ipynb +++ b/examples/evolutions.ipynb @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "21685242", "metadata": {}, "outputs": [], @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "d8527d79", "metadata": {}, "outputs": [ @@ -97,7 +97,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "5714c87f", "metadata": {}, "outputs": [ @@ -115,7 +115,7 @@ "include \"stdgates.inc\";\n", "qubit[4] qb;\n", "bit[4] cb;\n", - "gate TFIM_3q_J100_h70(time) aa,ab,ac{\n", + "gate TFIM_3q_j100_h70(time) aa,ab,ac{\n", "\tcnot aa, ab;\n", "\trz(2.0 * time) ab;\n", "\tcnot aa, ab;\n", @@ -132,7 +132,7 @@ "\n", "gate GQSP_1_TFIM(θa,θb,θc) aa,ab,ac,ad{\n", "\try(θa) aa;\n", - "\tctrl(1) @ TFIM_3q_J100_h70(0.1) aa, ab, ac, ad;\n", + "\tctrl(1) @ TFIM_3q_j100_h70(0.1) aa, ab, ac, ad;\n", "\tp(θb) aa;\n", "\try(θc) aa;\n", "}\n", @@ -149,7 +149,7 @@ "include \"stdgates.inc\";\n", "qubit[4] qb;\n", "bit[4] cb;\n", - "gate TFIM_3q_J100_h70(time) aa,ab,ac{\n", + "gate TFIM_3q_j100_h70(time) aa,ab,ac{\n", "\tcnot aa, ab;\n", "\trz(2.0 * time) ab;\n", "\tcnot aa, ab;\n", @@ -166,13 +166,13 @@ "\n", "gate GQSP_3_TFIM(θa,θb,θc,θd,θe,θf,θg) aa,ab,ac,ad{\n", "\try(θa) aa;\n", - "\tctrl(1) @ TFIM_3q_J100_h70(0.1) aa, ab, ac, ad;\n", + "\tctrl(1) @ TFIM_3q_j100_h70(0.1) aa, ab, ac, ad;\n", "\tp(θb) aa;\n", "\try(θe) aa;\n", - "\tctrl(1) @ TFIM_3q_J100_h70(0.1) aa, ab, ac, ad;\n", + "\tctrl(1) @ TFIM_3q_j100_h70(0.1) aa, ab, ac, ad;\n", "\tp(θc) aa;\n", "\try(θf) aa;\n", - "\tctrl(1) @ TFIM_3q_J100_h70(0.1) aa, ab, ac, ad;\n", + "\tctrl(1) @ TFIM_3q_j100_h70(0.1) aa, ab, ac, ad;\n", "\tp(θd) aa;\n", "\try(θg) aa;\n", "}\n", @@ -288,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "7c651bcd", "metadata": {}, "outputs": [ @@ -300,13 +300,13 @@ "Trotter Decomposition - Two vs Multi-Hamiltonian\n", "----------------------------------------------------\n", "Configuration 1: Two-Hamiltonian Trotter (Suzuki)\n", - "Two-Hamiltonian: 1858 characters\n", + "Two-Hamiltonian: 1864 characters\n", "\tMethod: Suzuki-Trotter, Depth: 2\n", "OPENQASM 3;\n", "include \"stdgates.inc\";\n", "qubit[3] qb;\n", "bit[3] cb;\n", - "gate TFIM_3q_J100_h70(time) aa,ab,ac{\n", + "gate TFIM_3q_j100_h70(time) aa,ab,ac{\n", "\tcnot aa, ab;\n", "\trz(2.0 * time) ab;\n", "\tcnot aa, ab;\n", @@ -321,7 +321,7 @@ "\trx(1.4 * time) ac;\n", "}\n", "\n", - "gate HeisenbergXYZ_3q_Jx100_Jy120_Jz80(time) aa,ab,ac{\n", + "gate HeisenbergXYZ_3q_j_x100_j_y120_j_z80(time) aa,ab,ac{\n", "\try(pi/2) aa;\n", "\try(pi/2) ab;\n", "\tcnot aa, ab;\n", @@ -360,9 +360,9 @@ "\n", "def trot_suz_3_TFIM_HeisenbergXYZ_2(qubit[3] qubits,float time,int recursion_depth) {\n", "\tif (recursion_depth < 2){\n", - "\t\tTFIM_3q_J100_h70(time/2) qb[qubits[0]],qb[qubits[1]],qb[qubits[2]];\n", - "\t\tHeisenbergXYZ_3q_Jx100_Jy120_Jz80(time) qb[qubits[0]],qb[qubits[1]],qb[qubits[2]];\n", - "\t\tTFIM_3q_J100_h70(time/2) qb[qubits[0]],qb[qubits[1]],qb[qubits[2]];\n", + "\t\tTFIM_3q_j100_h70(time/2) qb[qubits[0]],qb[qubits[1]],qb[qubits[2]];\n", + "\t\tHeisenbergXYZ_3q_j_x100_j_y120_j_z80(time) qb[qubits[0]],qb[qubits[1]],qb[qubits[2]];\n", + "\t\tTFIM_3q_j100_h70(time/2) qb[qubits[0]],qb[qubits[1]],qb[qubits[2]];\n", "\t\treturn;\n", "\t}\n", "\tfloat suzuki_coeff = 1.0/(4.0 - pow(4.0, 1.0/(2.0*recursion_depth - 1.0)));\n", @@ -377,16 +377,16 @@ "\n", "\n", "Configuration 2: Multi-Hamiltonian Trotter\n", - "Multi-Hamiltonian: 3342 characters\n", + "Multi-Hamiltonian: 3351 characters\n", "\tHamiltonians: 3, Depth: 2\n", "\n", "Configuration 3: Linear Trotter Decomposition\n", - "Linear Trotter: 1769 characters\n", + "Linear Trotter: 1784 characters\n", "Method: First-order, Steps: 4\n", "Trotter Configuration Comparison:\n", - "\tTwo-Hamiltonian (Suzuki): 1858 chars\n", - "\tMulti-Hamiltonian: 3342 chars\n", - "\tLinear decomposition: 1769 chars\n" + "\tTwo-Hamiltonian (Suzuki): 1864 chars\n", + "\tMulti-Hamiltonian: 3351 chars\n", + "\tLinear decomposition: 1784 chars\n" ] } ], @@ -492,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "4b4b3bff", "metadata": {}, "outputs": [ @@ -508,19 +508,13 @@ "[('Z', np.complex128(1+0j))]\n", "Pauli-Z: 508 characters\n", "Testing Random 4x4 matrix (4, 4)...\n", - "[('II', np.complex128(0.4604637367120007+0.838946781387169j)), ('XI', np.complex128(0.5655598377382944+0.588833075307832j)), ('XX', np.complex128(0.4238844968885312+0.3326317061016123j)), ('IX', np.complex128(0.33106499350145013+0.33007330113196753j)), ('XY', np.complex128(-0.06002262495215413+0.2992097507618375j)), ('IY', np.complex128(-0.1797796889495182+0.20356340119461624j)), ('YI', np.complex128(-0.13521719508002197+0.19794667244217146j)), ('ZX', np.complex128(0.02442078075316162-0.23360780554666702j)), ('XZ', np.complex128(-0.18057751029366081-0.148700172760367j)), ('ZY', np.complex128(0.2184605953247674+0.03821255057383305j)), ('IZ', np.complex128(-0.095147349933698+0.07351264181838879j)), ('ZI', np.complex128(-0.11616413227155017+0.02567510247519522j)), ('YY', np.complex128(-0.05126587163767765+0.10703189572053626j)), ('YZ', np.complex128(-0.09614107149005136-0.02889548280897075j)), ('YX', np.complex128(-0.0870637778551501+0.04327330864487838j)), ('ZZ', np.complex128(0.0896637111235748-0.035398963079813106j))]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Random 4x4: 2019 characters\n", + "[('IX', np.complex128(0.6312692451983448+0.7062795340748755j)), ('II', np.complex128(0.3312704466731056+0.6543110856138611j)), ('XX', np.complex128(0.48885549810002155+0.46708079988828466j)), ('XI', np.complex128(0.5064276643525388+0.42560849024074227j)), ('YI', np.complex128(-0.2209432140524214-0.32680593560317794j)), ('XY', np.complex128(0.3051770998894734-0.08729195918180288j)), ('YY', np.complex128(0.22903059831001216-0.17048096768847246j)), ('ZZ', np.complex128(-0.12674613849154037+0.09991843038070033j)), ('ZI', np.complex128(-0.14733787825849548+0.023772954678058178j)), ('IY', np.complex128(-0.13339759254293293-0.04272733136592735j)), ('IZ', np.complex128(-0.018907216413733607-0.13091360941091704j)), ('ZX', np.complex128(0.007991339043142087-0.10180140392762566j)), ('ZY', np.complex128(-0.05995761592784832-0.0542893312281765j)), ('XZ', np.complex128(-0.016121493337997672+0.07795486151092063j)), ('YZ', np.complex128(0.06407397205381465+0.006693388785256826j)), ('YX', np.complex128(0.03553879879197233-0.04432680229575253j))]\n", + "Random 4x4: 2023 characters\n", "\n", "Configuration 2: Operator Chain Input\n", "Testing Single Pauli chain (3 operators)...\n", "[('X', 0.5), ('Z', 0.3), ('Y', 0.2)]\n", - "\tSingle Pauli: 719 characters\n", + "\tSingle Pauli: 717 characters\n", "\tOperators: ['X', 'Z', 'Y']\n", "OPENQASM 3;\n", "include \"stdgates.inc\";\n", @@ -545,7 +539,7 @@ "\ty aa;\n", "}\n", "\n", - "gate SEL_8998145479025848162 aa,ab,ac,ad{\n", + "gate SEL_247308947824619046 aa,ab,ac,ad{\n", "\tctrl(2) @ X aa,ab,ac,ad;\n", "\tx aa;\n", "\tctrl(2) @ Z aa,ab,ac,ad;\n", @@ -555,13 +549,13 @@ "\tx ab;\n", "}\n", "\n", - "gate PS_2_8654309695166846104 aa,ab,ac,ad{\n", + "gate PS_2_8139876655021836051 aa,ab,ac,ad{\n", "\tPREP_3905172865891942725 aa,ab;\n", - "\tSEL_8998145479025848162 aa,ab,ac,ad;\n", + "\tSEL_247308947824619046 aa,ab,ac,ad;\n", "\tinv @ PREP_3905172865891942725 aa,ab;\n", "}\n", "\n", - "PS_2_8654309695166846104 qb[3],qb[4],qb[0],qb[1];\n", + "PS_2_8139876655021836051 qb[3],qb[4],qb[0],qb[1];\n", "cb[{3, 4}] = measure qb[{3, 4}];\n", "cb[{0, 1, 2, 3}] = measure qb[{0, 1, 2, 3}];\n", "\n", @@ -573,9 +567,9 @@ "Prep-Select Configuration Comparison:\n", "Matrix inputs:\n", "\tPauli-Z: 508 chars\n", - "\tRandom 4x4: 2019 chars\n", + "\tRandom 4x4: 2023 chars\n", "Operator chains:\n", - "\tSingle Pauli: 719 chars\n", + "\tSingle Pauli: 717 chars\n", "\tTwo-qubit Pauli: 756 chars\n" ] } @@ -681,7 +675,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "a44b4a64", "metadata": {}, "outputs": [ @@ -698,10 +692,10 @@ " Step 2: Applying GQSP...\n", " Step 3: Applying prep-select...\n", "[('Z', np.complex128(1+0j))]\n", - "Integrated pipeline: 2465 characters\n", - " Contains Trotter: True\n", - " Contains GQSP: True\n", - " Contains PrepSelect: True\n" + "Integrated pipeline: 2471 characters\n", + "\tContains Trotter: True\n", + "\tContains GQSP: True\n", + "\tContains PrepSelect: True\n" ] } ], @@ -789,40 +783,19 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "id": "22dfb86d", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "OPENQASM 3;\n", - "include \"stdgates.inc\";\n", - "qubit[3] qb;\n", - "gate Z_on_two3 aa,ab,ac{\n", - "\tx ac;\n", - "\tctrl(2) @ z aa, ab, ac;\n", - "\tx ac;\n", - "}\n", - "\n", - "def Grover3Z_on_two3(qubit[3] reg) {\n", - "\th reg;\n", - "\tfor int i in [0:2] {\n", - "\t\t//Za\n", - "\t\tZ_on_two3 reg[0], reg[1], reg[2];\n", - "\t\th reg;\n", - "\t\t//Z0\n", - "\t\tx reg;\n", - "\t\tctrl(2) @ z reg[0], reg[1], reg[0];\n", - "\t\tx reg;\n", - "\t\th reg;\n", - "\t}\n", - "}\n", - "\n", - "input angle[32] theta ;\n", - "Grover3Z_on_two3(qb[{0 ,1 ,2}]);\n", - "\n" + "ename": "TypeError", + "evalue": "GateLibrary.add_var() got an unexpected keyword argument 'type'. Did you mean 'qtype'?", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 51\u001b[39m\n\u001b[32m 47\u001b[39m \u001b[38;5;28mself\u001b[39m.controlled_op(\u001b[38;5;28mself\u001b[39m.name, (qubits[-\u001b[32m1\u001b[39m], [control] + qubits[:-\u001b[32m1\u001b[39m]))\n\u001b[32m 50\u001b[39m \u001b[38;5;66;03m# Define input parameter\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m51\u001b[39m theta = \u001b[43mprogram\u001b[49m\u001b[43m.\u001b[49m\u001b[43madd_var\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mtheta\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mtype\u001b[39;49m\u001b[43m=\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43minput angle[32]\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 53\u001b[39m \u001b[38;5;66;03m# Apply Grover with custom gate\u001b[39;00m\n\u001b[32m 54\u001b[39m ampl.grover(Za, reg, \u001b[32m3\u001b[39m)\n", + "\u001b[31mTypeError\u001b[39m: GateLibrary.add_var() got an unexpected keyword argument 'type'. Did you mean 'qtype'?" ] } ], @@ -901,7 +874,7 @@ ], "metadata": { "kernelspec": { - "display_name": "venv", + "display_name": "Python 3", "language": "python", "name": "python3" }, @@ -915,7 +888,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.8" + "version": "3.13.9" } }, "nbformat": 4, diff --git a/qbraid_algorithms/qaoa/__init__.py b/qbraid_algorithms/qaoa/__init__.py index 51e2e46..ee875be 100644 --- a/qbraid_algorithms/qaoa/__init__.py +++ b/qbraid_algorithms/qaoa/__init__.py @@ -12,6 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -# from .qaoa +from .qaoa import * -# __all__ = ["generate_program", "save_to_qasm"] +#__all__ = ["qaoa", "cost", "mixer"] diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index e69de29..bae498d 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -0,0 +1,110 @@ +from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder +from matplotlib import pyplot as plt +import networkx as nx + +def qaoa_maxcut(builder : QasmBuilder, graph : nx.Graph) -> tuple[str, str] : + std = builder.import_library(lib_class=std_gates) + + cost_name = f"qaoa_maxcut_cost_{builder.qubits}" + + qubit_array_param = f"qubit[{builder.qubits}] qubits" + + gamma = "float gamma" + + # cost hamiltonian \sum_{E(graph)} Z_i @ Z_j + std.begin_subroutine( + cost_name, [qubit_array_param , gamma] + ) + + for i,j in graph.edges: + std.cnot(i,j) + std.rz("2 * gamma", j) + std.cnot(i,j) + + std.end_subroutine() + + + # mixer hamiltonian \sum_{i} X_i + mixer_name = f"qaoa_maxcut_mixer_{builder.qubits}" + + alpha = "float alpha" + + std.begin_subroutine( + mixer_name, [qubit_array_param, alpha] + ) + + for i in range(builder.qubits): + std.rx("-2 * alpha", i) + + std.end_subroutine() + + return mixer_name, cost_name + +def layer(builder : QasmBuilder, cost_ham : str, mixer_ham : str) -> str : + std = builder.import_library(lib_class=std_gates) + + name = f"qaoa_layer_function_{builder.qubits}" + + qubit_array_param = f"qubit[{builder.qubits}] qubits" + gamma = "float gamma" + alpha = "float alpha" + + std.begin_subroutine( + name, [qubit_array_param , gamma, alpha] + ) + + std.call_subroutine(cost_ham, ["qubits", "gamma"]) + std.call_subroutine(mixer_ham, ["qubits", "alpha"]) + + std.end_subroutine() + + return name + +def cost_function(builder : QasmBuilder, layer : str, depth : int, params : list[tuple[float, float]]) -> str : + std = builder.import_library(lib_class=std_gates) + + name = f"qaoa_cost_function_{layer}" + + qubit_array_param = f"qubit[{builder.qubits}] qubits" + + std.begin_subroutine( + name, [qubit_array_param, "float value"], "float" + ) + + for i in range(builder.qubits): + std.h(i) + + for i in range(depth): + std.call_subroutine(layer, parameters=["qubits", params[i][0], params[i][1]]) + + std.end_subroutine() + + return name + + +def calculate_gradient_function(builder : QasmBuilder, hamiltonian : str, delta : float = 0.1) -> str : + std = builder.import_library(lib_class=std_gates) + + name = f"qaoa_compute_gradient_{hamiltonian}" + + qubit_array_param = f"qubit[{builder.qubits}] qubits" + + std.begin_subroutine( + name, [qubit_array_param, "float value"], "float" + ) + std.add_var(name="frac", qtype="float") + std.add_var(name="val1", qtype="int") + std.add_var(name="val2", qtype="int") + std.call_subroutine(hamiltonian, [qubit_array_param, f"value + {delta}"]) + std.measure(range(builder.qubits), range(builder.qubits)) + std.classical_op(f"val1 = cb[0:{builder.qubits}]") + std.call_subroutine(hamiltonian, [qubit_array_param, f"value - {delta}"]) + std.measure(range(builder.qubits), [i + builder.qubits for i in range(builder.qubits)]) + std.classical_op(f"val2 = cb[{builder.qubits}:{builder.qubits*2}]") + std.classical_op(operation=f"frac = (val1 - val2)/(2* {delta})") + + std.classical_op(operation="return frac") + + std.end_subroutine() + + return name \ No newline at end of file diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb index df0e380..cbf1475 100644 --- a/qbraid_algorithms/qaoa/test.ipynb +++ b/qbraid_algorithms/qaoa/test.ipynb @@ -2,49 +2,134 @@ "cells": [ { "cell_type": "code", - "execution_count": 9, + "execution_count": 1, "id": "aba58bd7", "metadata": {}, "outputs": [], "source": [ - "import qbraid_algorithms\n", - "from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder" + "from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder\n", + "from matplotlib import pyplot as plt\n", + "import networkx as nx" ] }, { "cell_type": "code", "execution_count": null, - "id": "afc9ad5b", + "id": "765b9ec9", "metadata": {}, "outputs": [], "source": [ - "qubits = range(3)\n", + "def qaoa_maxcut(builder : QasmBuilder, graph : nx.Graph) -> tuple[str, str] : \n", + " std = builder.import_library(lib_class=std_gates)\n", + " \n", + " cost_name = f\"qaoa_maxcut_cost_{builder.qubits}\"\n", "\n", - "builder = QasmBuilder(3)\n", + " qubit_array_param = f\"qubit[{builder.qubits}] qubits\"\n", + "\n", + " gamma = \"float gamma\"\n", + "\n", + " # cost hamiltonian \\sum_{E(graph)} Z_i @ Z_j\n", + " std.begin_subroutine(\n", + " cost_name, [qubit_array_param , gamma]\n", + " )\n", + "\n", + " for i,j in graph.edges:\n", + " std.cnot(i,j)\n", + " std.rz(\"2 * gamma\", j)\n", + " std.cnot(i,j)\n", + "\n", + " std.end_subroutine()\n", + "\n", + "\n", + " # mixer hamiltonian \\sum_{i} X_i\n", + " mixer_name = f\"qaoa_maxcut_mixer_{builder.qubits}\"\n", + "\n", + " alpha = \"float alpha\"\n", + "\n", + " std.begin_subroutine(\n", + " mixer_name, [qubit_array_param, alpha]\n", + " )\n", + "\n", + " for i in range(builder.qubits):\n", + " std.rx(\"-2 * alpha\", i)\n", + " \n", + " std.end_subroutine()\n", + "\n", + " return mixer_name, cost_name\n", + "\n", + "def layer(builder : QasmBuilder, cost_ham : str, mixer_ham : str) -> str :\n", + " std = builder.import_library(lib_class=std_gates)\n", + "\n", + " name = f\"qaoa_layer_function_{builder.qubits}\"\n", + "\n", + " qubit_array_param = f\"qubit[{builder.qubits}] qubits\"\n", + " gamma = \"float gamma\"\n", + " alpha = \"float alpha\"\n", + "\n", + " std.begin_subroutine(\n", + " name, [qubit_array_param , gamma, alpha]\n", + " )\n", + "\n", + " std.call_subroutine(cost_ham, [\"qubits\", \"gamma\"])\n", + " std.call_subroutine(mixer_ham, [\"qubits\", \"alpha\"])\n", + "\n", + " std.end_subroutine()\n", + "\n", + " return name\n", + "\n", + "def cost_function(builder : QasmBuilder, layer : str, depth : int, params : list[tuple[float, float]]) -> str :\n", + " std = builder.import_library(lib_class=std_gates)\n", + "\n", + " name = f\"qaoa_cost_function_{layer}\"\n", + "\n", + " qubit_array_param = f\"qubit[{builder.qubits}] qubits\"\n", + "\n", + " std.begin_subroutine(\n", + " name, [qubit_array_param, \"float value\"], \"float\"\n", + " )\n", "\n", - "b=0\n", + " for i in range(builder.qubits):\n", + " std.h(i)\n", "\n", - "std = builder.import_library(lib_class=std_gates)\n", + " for i in range(depth):\n", + " std.call_subroutine(layer, parameters=[\"qubits\", params[i][0], params[i][1]])\n", " \n", - "name = f\"qaoa_cost_{len(qubits)}\" # BUG FIX: Include depth in name\n", + " std.end_subroutine()\n", "\n", - "qubit_list = \"{\" + \",\".join([str(q) for q in qubits]) + \"}\"\n", + " return name\n", "\n", - "qubit_array_param = f\"qubit[{len(qubits)}] qubits\"\n", "\n", - "std.begin_subroutine(\n", - " name, [qubit_array_param]\n", - ")\n", + "def calculate_gradient_function(builder : QasmBuilder, hamiltonian : str, delta : float = 0.1) -> str :\n", + " std = builder.import_library(lib_class=std_gates)\n", "\n", - "for i in qubits:\n", - " std.z(i)\n", + " name = f\"qaoa_compute_gradient_{hamiltonian}\"\n", "\n", - "std.end_subroutine()" + " qubit_array_param = f\"qubit[{builder.qubits}] qubits\"\n", + "\n", + " std.begin_subroutine(\n", + " name, [qubit_array_param, \"float value\"], \"float\"\n", + " )\n", + " std.add_var(name=\"frac\", qtype=\"float\")\n", + " std.add_var(name=\"val1\", qtype=\"int\")\n", + " std.add_var(name=\"val2\", qtype=\"int\")\n", + " std.call_subroutine(hamiltonian, [qubit_array_param, f\"value + {delta}\"])\n", + " std.measure(range(builder.qubits), range(builder.qubits))\n", + " std.classical_op(f\"val1 = cb[0:{builder.qubits}]\")\n", + " std.call_subroutine(hamiltonian, [qubit_array_param, f\"value - {delta}\"])\n", + " std.measure(range(builder.qubits), [i + builder.qubits for i in range(builder.qubits)])\n", + " std.classical_op(f\"val2 = cb[{builder.qubits}:{builder.qubits*2}]\")\n", + " std.classical_op(operation=f\"frac = (val1 - val2)/(2* {delta})\")\n", + "\n", + " std.classical_op(operation=\"return frac\")\n", + "\n", + " std.end_subroutine()\n", + "\n", + " return name\n" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 32, "id": "18ff0ac8", "metadata": {}, "outputs": [ @@ -52,17 +137,32 @@ "name": "stdout", "output_type": "stream", "text": [ - "qaoa_cost_3\n" + "qaoa_maxcut_mixer_3\n", + "qaoa_maxcut_cost_3\n", + "stdgates: subroutine qaoa_maxcut_cost_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", + "stdgates: subroutine qaoa_maxcut_mixer_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", + "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", + "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", + "qaoa_cost_function_qaoa_layer_function_3\n" ] } ], "source": [ - "print(name)" + "builder = QasmBuilder(3)\n", + "builder.claim_clbits(3)\n", + "edges = [(0, 1), (1, 2), (2, 0), (2, 3)]\n", + "graph = nx.Graph(edges)\n", + "\n", + "mixer_name, cost_name = qaoa_maxcut(builder=builder, graph=graph)\n", + "print(mixer_name)\n", + "print(cost_name)\n", + "layer_name = layer(builder=builder, cost_ham=cost_name, mixer_ham=mixer_name)\n", + "print(cost_function(builder=builder, depth=2, layer=layer_name, params=[[0.5, 0.5], [0.5, 0.5]]))" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 33, "id": "f9157c73", "metadata": {}, "outputs": [ @@ -70,54 +170,120 @@ "name": "stdout", "output_type": "stream", "text": [ - "{0,1,2}\n" + "OPENQASM 3;\n", + "include \"stdgates.inc\";\n", + "qubit[3] qb;\n", + "bit[6] cb;\n", + "def qaoa_maxcut_cost_3(qubit[3] qubits,float gamma) {\n", + "\tcnot qb[0],qb[1];\n", + "\trz(2 * gamma) qb[1];\n", + "\tcnot qb[0],qb[1];\n", + "\tcnot qb[0],qb[2];\n", + "\trz(2 * gamma) qb[2];\n", + "\tcnot qb[0],qb[2];\n", + "\tcnot qb[1],qb[2];\n", + "\trz(2 * gamma) qb[2];\n", + "\tcnot qb[1],qb[2];\n", + "\tcnot qb[2],qb[3];\n", + "\trz(2 * gamma) qb[3];\n", + "\tcnot qb[2],qb[3];\n", + "}\n", + "def qaoa_maxcut_mixer_3(qubit[3] qubits,float alpha) {\n", + "\trx(-2 * alpha) qb[0];\n", + "\trx(-2 * alpha) qb[1];\n", + "\trx(-2 * alpha) qb[2];\n", + "}\n", + "def qaoa_layer_function_3(qubit[3] qubits,float gamma,float alpha) {\n", + "\tqaoa_maxcut_cost_3(qubits, gamma);\n", + "\tqaoa_maxcut_mixer_3(qubits, alpha);\n", + "}\n", + "def qaoa_cost_function_qaoa_layer_function_3(qubit[3] qubits,float value) -> float{\n", + "\th qb[0];\n", + "\th qb[1];\n", + "\th qb[2];\n", + "\tqaoa_layer_function_3(qubit[3] qubits, 0.5, 0.5);\n", + "\tqaoa_layer_function_3(qubit[3] qubits, 0.5, 0.5);\n", + "}\n", + "\n" ] } ], "source": [ - "print(qubit_list)" + "program = builder.build()\n", + "\n", + "print(program)" ] }, { "cell_type": "code", - "execution_count": 30, - "id": "3f709bd4", + "execution_count": 6, + "id": "df258b64", "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "'qubit[3] qubits'" + "
" ] }, - "execution_count": 30, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "qubit_array_param" + "edges = [(0, 1), (1, 2), (2, 0), (2, 3)]\n", + "graph = nx.Graph(edges)\n", + "positions = nx.spring_layout(graph, seed=1)\n", + "\n", + "nx.draw(graph, with_labels=True, pos=positions)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0d1cf38b", + "metadata": {}, + "outputs": [], + "source": [ + "for i,j in graph.edges:\n", + " std.cnot(i,j)\n", + " std.rz(2, j)\n", + " std.cnot(i,j)" ] }, { "cell_type": "code", - "execution_count": 31, - "id": "4f079fbd", + "execution_count": 10, + "id": "e0a2c6c0", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Warning (QasmBuilder): built qasm has unclosed scope, string will fail compile in native\n", "OPENQASM 3;\n", "include \"stdgates.inc\";\n", "qubit[3] qb;\n", "bit[3] cb;\n", "def qaoa_cost_3(qubit[3] qubits) {\n", - "\trz(0.45) qb[0];\n", - "\trz(0.45) qb[1];\n", - "\trz(0.45) qb[2];\n", + "\tz qb[0];\n", + "\tz qb[1];\n", + "\tz qb[2];\n", + "}\n", + "cnot qb[0],qb[1];\n", + "rz(2) qb[1];\n", + "cnot qb[0],qb[1];\n", + "cnot qb[0],qb[2];\n", + "rz(2) qb[2];\n", + "cnot qb[0],qb[2];\n", + "cnot qb[1],qb[2];\n", + "rz(2) qb[2];\n", + "cnot qb[1],qb[2];\n", + "cnot qb[2],qb[3];\n", + "rz(2) qb[3];\n", + "cnot qb[2],qb[3];\n", "\n" ] } @@ -130,7 +296,7 @@ { "cell_type": "code", "execution_count": null, - "id": "df258b64", + "id": "afbf2ca4", "metadata": {}, "outputs": [], "source": [] diff --git a/qbraid_algorithms/qtran/gate_library.py b/qbraid_algorithms/qtran/gate_library.py index ba114b4..ab743e9 100644 --- a/qbraid_algorithms/qtran/gate_library.py +++ b/qbraid_algorithms/qtran/gate_library.py @@ -407,6 +407,16 @@ def add_var(self, name, assignment=None, qtype=None): call = f"{qtype if qtype is not None else 'let'} {name} {f'= {assignment}' if assignment is not None else ''};" self.program(call) return name + + def classical_op(self, operation): + """ + simple stub for programatically perform a classical operation + + Args: + operation: operation string + """ + call = f"{operation};" + self.program(call) def merge(self, program, imports, definitions, name): """ From 7cec9d463dfcf32b91f9636fcaf02715627ede6d Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Wed, 21 Jan 2026 00:34:13 +0100 Subject: [PATCH 03/20] Organized code inside QAOA class Added missing functionalities (reset, cswap, input and output variables) to std_gates class --- qbraid_algorithms/qaoa/qaoa.py | 178 ++++++++++++--------- qbraid_algorithms/qaoa/test.ipynb | 197 ++++++++++++++++++++++-- qbraid_algorithms/qtran/gate_library.py | 40 +++++ 3 files changed, 325 insertions(+), 90 deletions(-) diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index bae498d..8214780 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -1,110 +1,140 @@ from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder -from matplotlib import pyplot as plt import networkx as nx +import pyqasm +from pyqasm.modules.base import QasmModule -def qaoa_maxcut(builder : QasmBuilder, graph : nx.Graph) -> tuple[str, str] : - std = builder.import_library(lib_class=std_gates) - - cost_name = f"qaoa_maxcut_cost_{builder.qubits}" +class QAOA: - qubit_array_param = f"qubit[{builder.qubits}] qubits" + builder : QasmBuilder + mixer_hamiltonian : str + cost_hamiltonian : str + layer_circuit : str - gamma = "float gamma" + def __init__(self, num_qubits : int): + builder = QasmBuilder(num_qubits) - # cost hamiltonian \sum_{E(graph)} Z_i @ Z_j - std.begin_subroutine( - cost_name, [qubit_array_param , gamma] - ) + def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : + std = self.builder.import_library(lib_class=std_gates) + + cost_name = f"qaoa_maxcut_cost_{self.builder.qubits}" - for i,j in graph.edges: - std.cnot(i,j) - std.rz("2 * gamma", j) - std.cnot(i,j) + qubit_array_param = f"qubit[{self.builder.qubits}] qubits" - std.end_subroutine() + gamma = "float gamma" + # cost hamiltonian \sum_{E(graph)} Z_i @ Z_j + std.begin_subroutine( + cost_name, [qubit_array_param , gamma] + ) - # mixer hamiltonian \sum_{i} X_i - mixer_name = f"qaoa_maxcut_mixer_{builder.qubits}" + for i,j in graph.edges: + std.cnot(i,j) + std.rz("2 * gamma", j) + std.cnot(i,j) - alpha = "float alpha" + std.end_subroutine() - std.begin_subroutine( - mixer_name, [qubit_array_param, alpha] - ) - for i in range(builder.qubits): - std.rx("-2 * alpha", i) - - std.end_subroutine() + # mixer hamiltonian \sum_{i} X_i + mixer_name = f"qaoa_maxcut_mixer_{self.builder.qubits}" - return mixer_name, cost_name + alpha = "float alpha" -def layer(builder : QasmBuilder, cost_ham : str, mixer_ham : str) -> str : - std = builder.import_library(lib_class=std_gates) + std.begin_subroutine( + mixer_name, [qubit_array_param, alpha] + ) - name = f"qaoa_layer_function_{builder.qubits}" + for i in range(self.builder.qubits): + std.rx("-2 * alpha", i) + + std.end_subroutine() - qubit_array_param = f"qubit[{builder.qubits}] qubits" - gamma = "float gamma" - alpha = "float alpha" + return mixer_name, cost_name + + def setup_maxcut(self, graph : nx.Graph): + self.mixer_hamiltonian, self.cost_hamiltonian = self.qaoa_maxcut(graph=graph) + self.layer_circuit = self.layer(self.cost_hamiltonian, self.mixer_hamiltonian) - std.begin_subroutine( - name, [qubit_array_param , gamma, alpha] - ) + def layer(self, cost_ham : str, mixer_ham : str) -> str : + std = self.builder.import_library(lib_class=std_gates) - std.call_subroutine(cost_ham, ["qubits", "gamma"]) - std.call_subroutine(mixer_ham, ["qubits", "alpha"]) + name = f"qaoa_layer_function_{self.builder.qubits}" - std.end_subroutine() + qubit_array_param = f"qubit[{self.builder.qubits}] qubits" + gamma = "float gamma" + alpha = "float alpha" - return name + std.begin_subroutine( + name, [qubit_array_param , gamma, alpha] + ) -def cost_function(builder : QasmBuilder, layer : str, depth : int, params : list[tuple[float, float]]) -> str : - std = builder.import_library(lib_class=std_gates) + std.call_subroutine(cost_ham, ["qubits", "gamma"]) + std.call_subroutine(mixer_ham, ["qubits", "alpha"]) - name = f"qaoa_cost_function_{layer}" + std.end_subroutine() - qubit_array_param = f"qubit[{builder.qubits}] qubits" + return name - std.begin_subroutine( - name, [qubit_array_param, "float value"], "float" - ) + def cost_function(self, layer : str, depth : int, params : list[tuple[float, float]]) -> str : + std = self.builder.import_library(lib_class=std_gates) - for i in range(builder.qubits): - std.h(i) + name = f"qaoa_cost_function_{layer}" - for i in range(depth): - std.call_subroutine(layer, parameters=["qubits", params[i][0], params[i][1]]) - - std.end_subroutine() + qubit_array_param = f"qubit[{self.builder.qubits}] qubits" + + for i in range(self.builder.qubits): + std.h(i) + + for i in range(depth): + std.call_subroutine(layer, parameters=["qubits", params[i][0], params[i][1]]) - return name + return name + def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsilon : float = 0.01) -> QasmModule: + std = self.builder.import_library(lib_class=std_gates) -def calculate_gradient_function(builder : QasmBuilder, hamiltonian : str, delta : float = 0.1) -> str : - std = builder.import_library(lib_class=std_gates) + layer = self.layer_circuit if layer == "" else layer + + num_qubits = self.builder.qubits + self.builder.claim_qubits(self.builder.qubits) + self.builder.claim_qubits(1) - name = f"qaoa_compute_gradient_{hamiltonian}" + repetitions = int(round((1.0/epsilon)**2)) + + for i in range(depth): + std.add_input_var(f"gamma_{i}", qtype="float") + std.add_input_var(f"alpha_{i}", qtype="float") + + std.add_var(name="measure_0", qtype="int") + std.add_output_var("expval", qtype="float") + std.begin_loop(repetitions) + + for q in range(self.builder.qubits): + std.reset(q) + + for q in range(self.builder.qubits): + std.h(q) - qubit_array_param = f"qubit[{builder.qubits}] qubits" + for i in range(depth): + std.call_subroutine(layer, parameters=[f"qb[0:{num_qubits}]", f"gamma_{i}", f"alpha_{i}"]) + std.call_subroutine(layer, parameters=[f"qb[{num_qubits}:{num_qubits*2}]", f"gamma_{i}", f"alpha_{i}"]) - std.begin_subroutine( - name, [qubit_array_param, "float value"], "float" - ) - std.add_var(name="frac", qtype="float") - std.add_var(name="val1", qtype="int") - std.add_var(name="val2", qtype="int") - std.call_subroutine(hamiltonian, [qubit_array_param, f"value + {delta}"]) - std.measure(range(builder.qubits), range(builder.qubits)) - std.classical_op(f"val1 = cb[0:{builder.qubits}]") - std.call_subroutine(hamiltonian, [qubit_array_param, f"value - {delta}"]) - std.measure(range(builder.qubits), [i + builder.qubits for i in range(builder.qubits)]) - std.classical_op(f"val2 = cb[{builder.qubits}:{builder.qubits*2}]") - std.classical_op(operation=f"frac = (val1 - val2)/(2* {delta})") + std.call_subroutine(cost_ham, [f"qb[0:{num_qubits}]", "1"]) + std.h(self.builder.qubits - 1) + for q in range(num_qubits): + std.cswap(control=f"qb[{self.builder.qubits - 1}]", targ1=f"qb[{q}]", targ2=f"qb[{q+num_qubits}]") + + std.measure(f"qb[{self.builder.qubits - 1}", "cb[0]") - std.classical_op(operation="return frac") + std.begin_if("cb[0] == 0") + std.classical_op("measure_0 = measure_0 + 1") + std.end_if() + + std.end_loop() - std.end_subroutine() + std.classical_op(f"expval = measure_0/{repetitions}") + std.classical_op("expval = 2*(expval - 0.5)") + std.classical_op("expval = sqrt(expval)") + std.classical_op("expval = log(expval)") - return name \ No newline at end of file + return pyqasm.load(self.builder.build()) diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb index cbf1475..7ba4d74 100644 --- a/qbraid_algorithms/qaoa/test.ipynb +++ b/qbraid_algorithms/qaoa/test.ipynb @@ -9,7 +9,9 @@ "source": [ "from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder\n", "from matplotlib import pyplot as plt\n", - "import networkx as nx" + "import networkx as nx\n", + "from qbraid.runtime import QbraidProvider\n", + "import pyqasm" ] }, { @@ -84,17 +86,11 @@ "\n", " qubit_array_param = f\"qubit[{builder.qubits}] qubits\"\n", "\n", - " std.begin_subroutine(\n", - " name, [qubit_array_param, \"float value\"], \"float\"\n", - " )\n", - "\n", " for i in range(builder.qubits):\n", " std.h(i)\n", "\n", " for i in range(depth):\n", " std.call_subroutine(layer, parameters=[\"qubits\", params[i][0], params[i][1]])\n", - " \n", - " std.end_subroutine()\n", "\n", " return name\n", "\n", @@ -124,12 +120,82 @@ "\n", " std.end_subroutine()\n", "\n", - " return name\n" + " return name\n", + "\n", + "def generate_algorithm(builder : QasmBuilder, layer : str, cost_ham : str, depth : int, epsilon : float = 0.01) :\n", + " std = builder.import_library(lib_class=std_gates)\n", + "\n", + " num_qubits = builder.qubits\n", + " builder.claim_qubits(builder.qubits)\n", + " builder.claim_qubits(1)\n", + "\n", + " repetitions = int(round((1.0/epsilon)**2))\n", + " \n", + " for i in range(depth):\n", + " std.add_input_var(f\"gamma_{i}\", qtype=\"float\")\n", + " std.add_input_var(f\"alpha_{i}\", qtype=\"float\")\n", + " \n", + " std.add_var(name=\"measure_0\", qtype=\"int\")\n", + " std.add_output_var(\"expval\", qtype=\"float\")\n", + " std.begin_loop(repetitions)\n", + " \n", + " for q in range(builder.qubits):\n", + " std.reset(q)\n", + " \n", + " for q in range(builder.qubits):\n", + " std.h(q)\n", + "\n", + " for i in range(depth):\n", + " std.call_subroutine(layer, parameters=[f\"qb[0:{num_qubits}]\", f\"gamma_{i}\", f\"alpha_{i}\"])\n", + " std.call_subroutine(layer, parameters=[f\"qb[{num_qubits}:{num_qubits*2}]\", f\"gamma_{i}\", f\"alpha_{i}\"])\n", + "\n", + " std.call_subroutine(cost_ham, [f\"qb[0:{num_qubits}]\", \"1\"])\n", + " std.h(builder.qubits - 1)\n", + " for q in range(num_qubits):\n", + " std.cswap(control=f\"qb[{builder.qubits - 1}]\", targ1=f\"qb[{q}]\", targ2=f\"qb[{q+num_qubits}]\")\n", + " \n", + " std.measure(f\"qb[{builder.qubits - 1}\", \"cb[0]\")\n", + "\n", + " std.begin_if(\"cb[0] == 0\")\n", + " std.classical_op(\"measure_0 = measure_0 + 1\")\n", + " std.end_if()\n", + " \n", + " std.end_loop()\n", + "\n", + " std.classical_op(f\"expval = measure_0/{repetitions}\")\n", + " std.classical_op(\"expval = 2*(expval - 0.5)\")\n", + " std.classical_op(\"expval = sqrt(expval)\")\n", + " std.classical_op(\"expval = log(expval)\")\n" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 3, + "id": "06a3e05a", + "metadata": {}, + "outputs": [], + "source": [ + "def expectation_value(builder : QasmBuilder, cost_ham : str, params : list[tuple[float, float]], epsilon : float = 0.01) -> str :\n", + " repetitions = int(Math.round(Math.pow(1/epsilon, 2)))\n", + " std = builder.import_library(lib_class=std_gates)\n", + " original_qubits = builder.qubits\n", + " builder.claim_qubits(builder.qubits)\n", + "\n", + " name = f\"qaoa_compute_expectation_value_{cost_ham}\"\n", + "\n", + " qubit_copy_array_param = f\"qubit[{original_qubits}] qubits_copy\"\n", + "\n", + " std.begin_subroutine(\n", + " name, [qubit_copy_array_param], \"float\"\n", + " )\n", + "\n", + " for i in range(repetitions):\n", + " std.call_subroutine(cost_ham, [\"qubits_copy\", \"1\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "18ff0ac8", "metadata": {}, "outputs": [ @@ -143,7 +209,12 @@ "stdgates: subroutine qaoa_maxcut_mixer_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "qaoa_cost_function_qaoa_layer_function_3\n" + "qaoa_cost_function_qaoa_layer_function_3\n", + "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", + "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", + "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", + "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", + "stdgates: subroutine qaoa_maxcut_cost_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n" ] } ], @@ -157,12 +228,14 @@ "print(mixer_name)\n", "print(cost_name)\n", "layer_name = layer(builder=builder, cost_ham=cost_name, mixer_ham=mixer_name)\n", - "print(cost_function(builder=builder, depth=2, layer=layer_name, params=[[0.5, 0.5], [0.5, 0.5]]))" + "print(cost_function(builder=builder, depth=2, layer=layer_name, params=[[0.5, 0.5], [0.5, 0.5]]))\n", + "\n", + "generate_algorithm(builder=builder, layer=layer_name, cost_ham=cost_name, depth=2)" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "id": "f9157c73", "metadata": {}, "outputs": [ @@ -172,7 +245,7 @@ "text": [ "OPENQASM 3;\n", "include \"stdgates.inc\";\n", - "qubit[3] qb;\n", + "qubit[7] qb;\n", "bit[6] cb;\n", "def qaoa_maxcut_cost_3(qubit[3] qubits,float gamma) {\n", "\tcnot qb[0],qb[1];\n", @@ -197,13 +270,49 @@ "\tqaoa_maxcut_cost_3(qubits, gamma);\n", "\tqaoa_maxcut_mixer_3(qubits, alpha);\n", "}\n", - "def qaoa_cost_function_qaoa_layer_function_3(qubit[3] qubits,float value) -> float{\n", + "h qb[0];\n", + "h qb[1];\n", + "h qb[2];\n", + "qaoa_layer_function_3(qubits, 0.5, 0.5);\n", + "qaoa_layer_function_3(qubits, 0.5, 0.5);\n", + "input float gamma_0 ;\n", + "input float alpha_0 ;\n", + "input float gamma_1 ;\n", + "input float alpha_1 ;\n", + "int measure_0 ;\n", + "output float expval ;\n", + "for int i in [0:9999] {\n", + "\treset qb[0];\n", + "\treset qb[1];\n", + "\treset qb[2];\n", + "\treset qb[3];\n", + "\treset qb[4];\n", + "\treset qb[5];\n", + "\treset qb[6];\n", "\th qb[0];\n", "\th qb[1];\n", "\th qb[2];\n", - "\tqaoa_layer_function_3(qubit[3] qubits, 0.5, 0.5);\n", - "\tqaoa_layer_function_3(qubit[3] qubits, 0.5, 0.5);\n", + "\th qb[3];\n", + "\th qb[4];\n", + "\th qb[5];\n", + "\th qb[6];\n", + "\tqaoa_layer_function_3(qb[0:3], gamma_0, alpha_0);\n", + "\tqaoa_layer_function_3(qb[3:6], gamma_0, alpha_0);\n", + "\tqaoa_layer_function_3(qb[0:3], gamma_1, alpha_1);\n", + "\tqaoa_layer_function_3(qb[3:6], gamma_1, alpha_1);\n", + "\tqaoa_maxcut_cost_3(qb[0:3], 1);\n", + "\th qb[6];\n", + "\tcswap qb[qb[6]],qb[qb[0], qb[3]];\n", + "\tcswap qb[qb[6]],qb[qb[1], qb[4]];\n", + "\tcswap qb[qb[6]],qb[qb[2], qb[5]];\n", + "\tcb[{b[0}] = measure qb[{b[}];\n", + "\tif (cb[0] == 0){\n", + "\t\tmeasure_0 = measure_0 + 1;\n", + "\t}\n", "}\n", + "expval = measure_0/10000;\n", + "expval = sqrt(expval);\n", + "expval = log(expval);\n", "\n" ] } @@ -214,6 +323,62 @@ "print(program)" ] }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d27b0782", + "metadata": {}, + "outputs": [ + { + "ename": "ResourceNotFoundError", + "evalue": "Failed to authenticate with the Quantum service.", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mHTTPError\u001b[39m Traceback (most recent call last)", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\sessions.py:187\u001b[39m, in \u001b[36mSession.request\u001b[39m\u001b[34m(self, method, url, *args, **kwargs)\u001b[39m\n\u001b[32m 186\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._raise_for_status:\n\u001b[32m--> \u001b[39m\u001b[32m187\u001b[39m \u001b[43mresponse\u001b[49m\u001b[43m.\u001b[49m\u001b[43mraise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 189\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m requests.RequestException \u001b[38;5;28;01mas\u001b[39;00m err:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\requests\\models.py:1026\u001b[39m, in \u001b[36mResponse.raise_for_status\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 1025\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m http_error_msg:\n\u001b[32m-> \u001b[39m\u001b[32m1026\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m HTTPError(http_error_msg, response=\u001b[38;5;28mself\u001b[39m)\n", + "\u001b[31mHTTPError\u001b[39m: 400 Client Error: Bad Request for url: https://api.qbraid.com/api/identity", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[31mRequestsApiError\u001b[39m Traceback (most recent call last)", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\sessions.py:365\u001b[39m, in \u001b[36mQbraidSession.get_user\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 364\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m365\u001b[39m metadata = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m/identity\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m.json()\n\u001b[32m 366\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m RequestsApiError \u001b[38;5;28;01mas\u001b[39;00m err:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\requests\\sessions.py:602\u001b[39m, in \u001b[36mSession.get\u001b[39m\u001b[34m(self, url, **kwargs)\u001b[39m\n\u001b[32m 601\u001b[39m kwargs.setdefault(\u001b[33m\"\u001b[39m\u001b[33mallow_redirects\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m--> \u001b[39m\u001b[32m602\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mGET\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\sessions.py:203\u001b[39m, in \u001b[36mSession.request\u001b[39m\u001b[34m(self, method, url, *args, **kwargs)\u001b[39m\n\u001b[32m 201\u001b[39m message = \u001b[38;5;28mself\u001b[39m._mask_sensitive_data(message, \u001b[38;5;28mself\u001b[39m.auth_headers)\n\u001b[32m--> \u001b[39m\u001b[32m203\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m RequestsApiError(message) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01merr\u001b[39;00m\n\u001b[32m 205\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m response\n", + "\u001b[31mRequestsApiError\u001b[39m: 400 Client Error: Bad Request for url: https://api.qbraid.com/api/identity.", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[31mUserNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\client.py:51\u001b[39m, in \u001b[36mQbraidClient.session\u001b[39m\u001b[34m(self, value)\u001b[39m\n\u001b[32m 50\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m51\u001b[39m user = \u001b[43msession\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_user\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 52\u001b[39m \u001b[38;5;28mself\u001b[39m._user_metadata = {\n\u001b[32m 53\u001b[39m \u001b[33m\"\u001b[39m\u001b[33morganization\u001b[39m\u001b[33m\"\u001b[39m: user.get(\u001b[33m\"\u001b[39m\u001b[33morganization\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mqbraid\u001b[39m\u001b[33m\"\u001b[39m),\n\u001b[32m 54\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mrole\u001b[39m\u001b[33m\"\u001b[39m: user.get(\u001b[33m\"\u001b[39m\u001b[33mrole\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33muser\u001b[39m\u001b[33m\"\u001b[39m),\n\u001b[32m 55\u001b[39m }\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\sessions.py:367\u001b[39m, in \u001b[36mQbraidSession.get_user\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 366\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m RequestsApiError \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m--> \u001b[39m\u001b[32m367\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m UserNotFoundError(\u001b[38;5;28mstr\u001b[39m(err)) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01merr\u001b[39;00m\n\u001b[32m 369\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m metadata:\n", + "\u001b[31mUserNotFoundError\u001b[39m: 400 Client Error: Bad Request for url: https://api.qbraid.com/api/identity.", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[31mAuthError\u001b[39m Traceback (most recent call last)", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid\\runtime\\native\\provider.py:140\u001b[39m, in \u001b[36mQbraidProvider.client\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 139\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m140\u001b[39m \u001b[38;5;28mself\u001b[39m._client = \u001b[43mQuantumClient\u001b[49m\u001b[43m(\u001b[49m\u001b[43mapi_key\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_api_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 141\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m AuthError \u001b[38;5;28;01mas\u001b[39;00m err:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\services\\quantum\\client.py:31\u001b[39m, in \u001b[36mQuantumClient.__init__\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 30\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, *args, **kwargs):\n\u001b[32m---> \u001b[39m\u001b[32m31\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[34;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\client.py:29\u001b[39m, in \u001b[36mQbraidClient.__init__\u001b[39m\u001b[34m(self, api_key, session)\u001b[39m\n\u001b[32m 28\u001b[39m \u001b[38;5;28mself\u001b[39m._user_metadata: Optional[\u001b[38;5;28mdict\u001b[39m[\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;28mstr\u001b[39m]] = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m29\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43msession\u001b[49m = session \u001b[38;5;129;01mor\u001b[39;00m QbraidSession(api_key=api_key)\n\u001b[32m 30\u001b[39m check_version(\u001b[33m\"\u001b[39m\u001b[33mqbraid-core\u001b[39m\u001b[33m\"\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\client.py:58\u001b[39m, in \u001b[36mQbraidClient.session\u001b[39m\u001b[34m(self, value)\u001b[39m\n\u001b[32m 57\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m UserNotFoundError \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m---> \u001b[39m\u001b[32m58\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m AuthError(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mAccess denied due to missing or invalid credentials: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00merr\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01merr\u001b[39;00m\n", + "\u001b[31mAuthError\u001b[39m: Access denied due to missing or invalid credentials: 400 Client Error: Bad Request for url: https://api.qbraid.com/api/identity.", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[31mResourceNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m provider = QbraidProvider()\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m device = \u001b[43mprovider\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_device\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mqbraid_qir_simulator\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 3\u001b[39m \u001b[38;5;28mprint\u001b[39m(provider.get_devices())\n\u001b[32m 4\u001b[39m module = pyqasm.load(program)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid\\_caching.py:75\u001b[39m, in \u001b[36m_cached_method_wrapper..decorator..wrapper\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 73\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m os.getenv(\u001b[33m\"\u001b[39m\u001b[33m_QBRAID_TEST_CACHE_CALLS\u001b[39m\u001b[33m\"\u001b[39m) == \u001b[33m\"\u001b[39m\u001b[33m1\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m 74\u001b[39m _ = func(\u001b[38;5;28mself\u001b[39m, *args, **kwargs)\n\u001b[32m---> \u001b[39m\u001b[32m75\u001b[39m result = \u001b[43mcached_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 76\u001b[39m cached_func.cache[key] = (result, time.time())\n\u001b[32m 77\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid\\runtime\\native\\provider.py:299\u001b[39m, in \u001b[36mQbraidProvider.__hash__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 297\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__hash__\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 298\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33m_hash\u001b[39m\u001b[33m\"\u001b[39m):\n\u001b[32m--> \u001b[39m\u001b[32m299\u001b[39m user_metadata = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mclient\u001b[49m._user_metadata\n\u001b[32m 300\u001b[39m organization_role = \u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00muser_metadata[\u001b[33m\"\u001b[39m\u001b[33morganization\u001b[39m\u001b[33m\"\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m-\u001b[39m\u001b[38;5;132;01m{\u001b[39;00muser_metadata[\u001b[33m\"\u001b[39m\u001b[33mrole\u001b[39m\u001b[33m\"\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m\n\u001b[32m 301\u001b[39m hash_value = \u001b[38;5;28mhash\u001b[39m(\n\u001b[32m 302\u001b[39m (\u001b[38;5;28mself\u001b[39m.\u001b[34m__class__\u001b[39m.\u001b[34m__name__\u001b[39m, \u001b[38;5;28mself\u001b[39m.client.session.api_key, organization_role)\n\u001b[32m 303\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid\\runtime\\native\\provider.py:142\u001b[39m, in \u001b[36mQbraidProvider.client\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 140\u001b[39m \u001b[38;5;28mself\u001b[39m._client = QuantumClient(api_key=\u001b[38;5;28mself\u001b[39m._api_key)\n\u001b[32m 141\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m AuthError \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m--> \u001b[39m\u001b[32m142\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m ResourceNotFoundError(\n\u001b[32m 143\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mFailed to authenticate with the Quantum service.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 144\u001b[39m ) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01merr\u001b[39;00m\n\u001b[32m 145\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._client\n", + "\u001b[31mResourceNotFoundError\u001b[39m: Failed to authenticate with the Quantum service." + ] + } + ], + "source": [ + "provider = QbraidProvider()\n", + "device = provider.get_device(\"qbraid_qir_simulator\")\n", + "print(provider.get_devices())\n", + "module = pyqasm.load(program)\n", + "module.unroll()\n", + "qasm_str = pyqasm.dumps(module)\n", + "job = device.run(qasm_str, shots=500)\n", + "results = job.result()\n", + "counts = results.data.get_counts()" + ] + }, { "cell_type": "code", "execution_count": 6, diff --git a/qbraid_algorithms/qtran/gate_library.py b/qbraid_algorithms/qtran/gate_library.py index ab743e9..4f8deef 100644 --- a/qbraid_algorithms/qtran/gate_library.py +++ b/qbraid_algorithms/qtran/gate_library.py @@ -408,6 +408,34 @@ def add_var(self, name, assignment=None, qtype=None): self.program(call) return name + def add_input_var(self, name, assignment=None, qtype=None): + """ + simple stub for programatically adding a variable + + Args: + name: variable name + Assignment: whatever definition you want as long as it resolves to a string + """ + if name in self.gate_ref: + print(f"warning: gate {name} replacing existing namespace") + call = f"input {qtype if qtype is not None else 'let'} {name} {f'= {assignment}' if assignment is not None else ''};" + self.program(call) + return name + + def add_output_var(self, name, assignment=None, qtype=None): + """ + simple stub for programatically adding a variable + + Args: + name: variable name + Assignment: whatever definition you want as long as it resolves to a string + """ + if name in self.gate_ref: + print(f"warning: gate {name} replacing existing namespace") + call = f"output {qtype if qtype is not None else 'let'} {name} {f'= {assignment}' if assignment is not None else ''};" + self.program(call) + return name + def classical_op(self, operation): """ simple stub for programatically perform a classical operation @@ -476,6 +504,7 @@ class std_gates(GateLibrary): "swap", "ccx", "cswap", + "reset" ] name = "stdgates.inc" # Standard library file name @@ -540,6 +569,10 @@ def rz(self, theta, targ): """Apply rz gate""" self.call_gate("rz", targ, phases=theta) + def reset(self, targ): + """Apply reset command""" + self.call_gate("reset", targ) + # ═══════════════════════════════════════════════════════════════════════════ # Two-QUBIT GATES # ═══════════════════════════════════════════════════════════════════════════ @@ -550,3 +583,10 @@ def cnot(self, control, targ): def cry(self, theta, control, targ): """Apply controlled ry gate""" self.call_gate("cry", targ, controls=control, phases=theta) + + # ═══════════════════════════════════════════════════════════════════════════ + # Three-QUBIT GATES + # ═══════════════════════════════════════════════════════════════════════════ + def cswap(self, control, targ1, targ2): + """Apply controlled swap gate""" + self.call_gate("cswap", f"{targ1}, {targ2}", controls=control) \ No newline at end of file From a6c97fd052ec6fccea7af3f3fb596beb7e018690 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Wed, 21 Jan 2026 02:09:26 +0100 Subject: [PATCH 04/20] Added xy_mixer, x_mixer Added min_vertex_cover_cost, max_clique_cost Added comments --- qbraid_algorithms/qaoa/qaoa.py | 220 ++++++++++++++++++++++++++---- qbraid_algorithms/qaoa/test.ipynb | 6 +- 2 files changed, 196 insertions(+), 30 deletions(-) diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index 8214780..c40fc98 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -11,32 +11,59 @@ class QAOA: layer_circuit : str def __init__(self, num_qubits : int): - builder = QasmBuilder(num_qubits) - - def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : + self.builder = QasmBuilder(num_qubits) + + def xy_mixer(self, graph : nx.Graph) -> str: + """ + Generate XY mixer Hamiltonian subroutine. + + xy_mixer_hamiltonian = $$\frac{1}{2}\sum_{(i,j)\in E(G)} X_iX_j + Y_iY_j$$ + Args: + graph : nx.Graph + Graph that describes the problem + Returns: + mixer Hamiltonian subroutine name + """ std = self.builder.import_library(lib_class=std_gates) - cost_name = f"qaoa_maxcut_cost_{self.builder.qubits}" + mixer_name = f"qaoa_xy_mixer_{self.builder.qubits}" qubit_array_param = f"qubit[{self.builder.qubits}] qubits" - gamma = "float gamma" + alpha = "float alpha" - # cost hamiltonian \sum_{E(graph)} Z_i @ Z_j std.begin_subroutine( - cost_name, [qubit_array_param , gamma] + mixer_name, [qubit_array_param, alpha] ) for i,j in graph.edges: std.cnot(i,j) - std.rz("2 * gamma", j) + std.rx("-alpha", j) std.cnot(i,j) - + std.cnot(i,j) + std.ry("-alpha", j) + std.cnot(i,j) + std.end_subroutine() + return mixer_name + + def x_mixer(self, graph : nx.Graph) -> str: + """ + Generate X mixer Hamiltonian subroutine. + + x_mixer_hamiltonian = $$\sum_{i} X_i$$ + Args: + graph : nx.Graph + Graph that describes the problem + Returns: + mixer Hamiltonian subroutine name + """ + std = self.builder.import_library(lib_class=std_gates) + + mixer_name = f"qaoa_x_mixer_{self.builder.qubits}" - # mixer hamiltonian \sum_{i} X_i - mixer_name = f"qaoa_maxcut_mixer_{self.builder.qubits}" + qubit_array_param = f"qubit[{self.builder.qubits}] qubits" alpha = "float alpha" @@ -49,13 +76,151 @@ def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : std.end_subroutine() + return mixer_name + + def min_vertex_cover_cost(self, graph : nx.Graph) -> str: + """ + Generate min vertex cover cost Hamiltonian subroutine. + + cost_hamiltonian $$3\sum_{(i,j)\in E(G)} (Z_i \otimes Z_j + Z_i + Z_j)-\sum_{i \in V(G)} Z_i$$ + Args: + graph : nx.Graph + Graph that describes the problem + Returns: + Cost Hamiltonian subroutine name + """ + std = self.builder.import_library(lib_class=std_gates) + + cost_name = f"qaoa_min_vertex_cover_cost_{self.builder.qubits}" + + qubit_array_param = f"qubit[{self.builder.qubits}] qubits" + + gamma = "float gamma" + + # cost hamiltonian $$3\sum_{(i,j)\in E(G)} (Z_i \otimes Z_j + Z_i + Z_j)-\sum_{i \in V(G)} Z_i$$ + std.begin_subroutine( + cost_name, [qubit_array_param , gamma] + ) + + for i,j in graph.edges: + std.cnot(i,j) + std.rz("3 * 2 * gamma", j) + std.cnot(i,j) + std.rz("3 * 2 * gamma", i) + std.rz("3 * 2 * gamma", j) + + for i in graph.nodes: + std.rz("-2 * gamma", i) + + std.end_subroutine() + + + return cost_name + + def max_clique_cost(self, graph : nx.Graph) -> str: + """ + Generate max clique cost Hamiltonian subroutine. + + cost_hamiltonian $$3\sum_{(i,j)\in E(\bar{G})} (Z_i \otimes Z_j - Z_i - Z_j)+\sum_{i \in V(G)} Z_i$$ + Args: + graph : nx.Graph + Graph that describes the problem + Returns: + Cost Hamiltonian subroutine name + """ + std = self.builder.import_library(lib_class=std_gates) + + cost_name = f"qaoa_min_vertex_cover_cost_{self.builder.qubits}" + + qubit_array_param = f"qubit[{self.builder.qubits}] qubits" + + gamma = "float gamma" + + # cost hamiltonian $$3\sum_{(i,j)\in E(\bar{G})} (Z_i \otimes Z_j - Z_i - Z_j)+\sum_{i \in V(G)} Z_i$$ + std.begin_subroutine( + cost_name, [qubit_array_param , gamma] + ) + + graph_complement = nx.complement(graph) + + for i,j in graph_complement.edges: + std.cnot(i,j) + std.rz("3 * 2 * gamma", j) + std.cnot(i,j) + std.rz("-3 * 2 * gamma", i) + std.rz("-3 * 2 * gamma", j) + + for i in graph.nodes: + std.rz("2 * gamma", i) + + std.end_subroutine() + + + return cost_name + + + + def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : + """ + Generate cost hamiltonian and mixer hamiltonian subroutines. + + cost_hamiltonian = $$\sum_{E(graph)} Z_i \otimes Z_j$$ + + mixer_hamiltonian = $$\sum_{i} X_i$$ + Args: + graph : nx.Graph + Graph that describes the problem + Returns: + (mixer, cost) : tuple[str, str] mixer and cost hamiltonian subroutine names respectively + """ + std = self.builder.import_library(lib_class=std_gates) + + cost_name = f"qaoa_maxcut_cost_{self.builder.qubits}" + + qubit_array_param = f"qubit[{self.builder.qubits}] qubits" + + gamma = "float gamma" + + # cost hamiltonian $$\sum_{E(graph)} Z_i \otimes Z_j$$ + std.begin_subroutine( + cost_name, [qubit_array_param , gamma] + ) + + for i,j in graph.edges: + std.cnot(i,j) + std.rz("2 * gamma", j) + std.cnot(i,j) + + std.end_subroutine() + + + # mixer hamiltonian $$\sum_{i} X_i$$ + mixer_name = self.x_mixer(graph) + return mixer_name, cost_name def setup_maxcut(self, graph : nx.Graph): + """ + Perform the setup for a Max Cut problem with the given graph. + + Args: + graph : nx.Graph + Graph that describes the problem + """ self.mixer_hamiltonian, self.cost_hamiltonian = self.qaoa_maxcut(graph=graph) self.layer_circuit = self.layer(self.cost_hamiltonian, self.mixer_hamiltonian) def layer(self, cost_ham : str, mixer_ham : str) -> str : + """ + Create layer circuit. + Args: + cost_ham : str + Name of cost Hamiltonian subroutine + mixer_ham : str + Name of mixer Hamiltonian subroutine + Returns: + Name of layer subroutine + """ std = self.builder.import_library(lib_class=std_gates) name = f"qaoa_layer_function_{self.builder.qubits}" @@ -75,26 +240,27 @@ def layer(self, cost_ham : str, mixer_ham : str) -> str : return name - def cost_function(self, layer : str, depth : int, params : list[tuple[float, float]]) -> str : - std = self.builder.import_library(lib_class=std_gates) - - name = f"qaoa_cost_function_{layer}" - - qubit_array_param = f"qubit[{self.builder.qubits}] qubits" - - for i in range(self.builder.qubits): - std.h(i) - - for i in range(depth): - std.call_subroutine(layer, parameters=["qubits", params[i][0], params[i][1]]) - - return name - def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsilon : float = 0.01) -> QasmModule: + """ + Load the Quantum Approximate Optimization Algorithm (QAOA) ansatz as a pyqasm module. + + Args: + cost_ham : str + Name of the cost Hamiltonian subroutine + depth : int + Depth of the circuit (i.e. number of layer repetitions) + layer : str + Name of the layer circuit subroutine + epsilon : float + Error for expectation value calculation + + Returns: + (PyQasm Module) pyqasm module containing the QAOA ansatz circuit + """ std = self.builder.import_library(lib_class=std_gates) layer = self.layer_circuit if layer == "" else layer - + num_qubits = self.builder.qubits self.builder.claim_qubits(self.builder.qubits) self.builder.claim_qubits(1) diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb index 7ba4d74..ba7b14f 100644 --- a/qbraid_algorithms/qaoa/test.ipynb +++ b/qbraid_algorithms/qaoa/test.ipynb @@ -381,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "df258b64", "metadata": {}, "outputs": [ @@ -397,8 +397,8 @@ } ], "source": [ - "edges = [(0, 1), (1, 2), (2, 0), (2, 3)]\n", - "graph = nx.Graph(edges)\n", + "graph = nx.Graph([(0, 1), (1, 2)])\n", + "# graph = nx.Graph(edges)\n", "positions = nx.spring_layout(graph, seed=1)\n", "\n", "nx.draw(graph, with_labels=True, pos=positions)\n", From 264b367ec336297f7e669e1d969e5e5f4a8f9c4d Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Wed, 21 Jan 2026 16:31:22 +0100 Subject: [PATCH 05/20] Removed two consecutive CNOTs that resulted in an identity --- qbraid_algorithms/qaoa/qaoa.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index c40fc98..894b8f1 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -39,8 +39,6 @@ def xy_mixer(self, graph : nx.Graph) -> str: for i,j in graph.edges: std.cnot(i,j) std.rx("-alpha", j) - std.cnot(i,j) - std.cnot(i,j) std.ry("-alpha", j) std.cnot(i,j) @@ -158,8 +156,6 @@ def max_clique_cost(self, graph : nx.Graph) -> str: return cost_name - - def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : """ Generate cost hamiltonian and mixer hamiltonian subroutines. From 8d9780596a7beb3907b830c32b9bd42c836532e6 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 22 Jan 2026 19:43:29 +0100 Subject: [PATCH 06/20] Small fixes to module inclusion and measurement in algorithm generation --- qbraid_algorithms/qaoa/__init__.py | 4 +- qbraid_algorithms/qaoa/cost.py | 21 --- qbraid_algorithms/qaoa/mixer.py | 0 qbraid_algorithms/qaoa/qaoa.py | 13 +- qbraid_algorithms/qaoa/test.ipynb | 233 +++++++++++++++++++---------- 5 files changed, 165 insertions(+), 106 deletions(-) delete mode 100644 qbraid_algorithms/qaoa/cost.py delete mode 100644 qbraid_algorithms/qaoa/mixer.py diff --git a/qbraid_algorithms/qaoa/__init__.py b/qbraid_algorithms/qaoa/__init__.py index ee875be..57d3529 100644 --- a/qbraid_algorithms/qaoa/__init__.py +++ b/qbraid_algorithms/qaoa/__init__.py @@ -12,6 +12,6 @@ # See the License for the specific language governing permissions and # limitations under the License. -from .qaoa import * +from .qaoa import QAOA -#__all__ = ["qaoa", "cost", "mixer"] +__all__ = ["QAOA"] diff --git a/qbraid_algorithms/qaoa/cost.py b/qbraid_algorithms/qaoa/cost.py deleted file mode 100644 index e1c125d..0000000 --- a/qbraid_algorithms/qaoa/cost.py +++ /dev/null @@ -1,21 +0,0 @@ -from qbraid_algorithms.qtran import GateLibrary, std_gates - - -def bit_driver(builder, qubits, b): - std = builder.import_library(lib_class=std_gates) - - name = f"qaoa_cost_{len(qubits)}" # BUG FIX: Include depth in name - - qubit_list = "{" + ",".join([str(q) for q in qubits]) + "}" - - qubit_array_param = f"qubit[{len(qubits)}] qubits" - - std.begin_subroutine( - name, [qubit_array_param] - ) - - for i in qubits: - std.z(i) - - std.end_subroutine() - diff --git a/qbraid_algorithms/qaoa/mixer.py b/qbraid_algorithms/qaoa/mixer.py deleted file mode 100644 index e69de29..0000000 diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index 894b8f1..b9637b8 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -9,9 +9,12 @@ class QAOA: mixer_hamiltonian : str cost_hamiltonian : str layer_circuit : str + use_subroutines : bool + + def __init__(self, num_qubits : int, use_subroutines : bool = False, qasm_version : int = 3): + self.builder = QasmBuilder(num_qubits, version=qasm_version) + self.builder.claim_clbits(num_qubits) - def __init__(self, num_qubits : int): - self.builder = QasmBuilder(num_qubits) def xy_mixer(self, graph : nx.Graph) -> str: """ @@ -236,7 +239,7 @@ def layer(self, cost_ham : str, mixer_ham : str) -> str : return name - def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsilon : float = 0.01) -> QasmModule: + def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsilon : float = 0.01) -> str: """ Load the Quantum Approximate Optimization Algorithm (QAOA) ansatz as a pyqasm module. @@ -286,7 +289,7 @@ def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsi for q in range(num_qubits): std.cswap(control=f"qb[{self.builder.qubits - 1}]", targ1=f"qb[{q}]", targ2=f"qb[{q+num_qubits}]") - std.measure(f"qb[{self.builder.qubits - 1}", "cb[0]") + std.measure([self.builder.qubits - 1], [0]) std.begin_if("cb[0] == 0") std.classical_op("measure_0 = measure_0 + 1") @@ -299,4 +302,4 @@ def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsi std.classical_op("expval = sqrt(expval)") std.classical_op("expval = log(expval)") - return pyqasm.load(self.builder.build()) + return self.builder.build() diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb index ba7b14f..fd4a11a 100644 --- a/qbraid_algorithms/qaoa/test.ipynb +++ b/qbraid_algorithms/qaoa/test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "id": "aba58bd7", "metadata": {}, "outputs": [], @@ -10,13 +10,14 @@ "from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder\n", "from matplotlib import pyplot as plt\n", "import networkx as nx\n", - "from qbraid.runtime import QbraidProvider\n", + "# from qbraid.runtime import QbraidProvider\n", + "from qbraid_algorithms.qaoa import QAOA\n", "import pyqasm" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "765b9ec9", "metadata": {}, "outputs": [], @@ -170,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 8, "id": "06a3e05a", "metadata": {}, "outputs": [], @@ -195,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "18ff0ac8", "metadata": {}, "outputs": [ @@ -203,39 +204,44 @@ "name": "stdout", "output_type": "stream", "text": [ - "qaoa_maxcut_mixer_3\n", - "qaoa_maxcut_cost_3\n", "stdgates: subroutine qaoa_maxcut_cost_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "stdgates: subroutine qaoa_maxcut_mixer_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "qaoa_cost_function_qaoa_layer_function_3\n", + "stdgates: subroutine qaoa_x_mixer_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", "stdgates: subroutine qaoa_maxcut_cost_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n" ] + }, + { + "data": { + "text/plain": [ + "'mixer_name, cost_name = qaoa_maxcut(builder=builder, graph=graph)\\nprint(mixer_name)\\nprint(cost_name)\\nlayer_name = layer(builder=builder, cost_ham=cost_name, mixer_ham=mixer_name)\\nprint(cost_function(builder=builder, depth=2, layer=layer_name, params=[[0.5, 0.5], [0.5, 0.5]]))\\n\\ngenerate_algorithm(builder=builder, layer=layer_name, cost_ham=cost_name, depth=2)'" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "builder = QasmBuilder(3)\n", - "builder.claim_clbits(3)\n", "edges = [(0, 1), (1, 2), (2, 0), (2, 3)]\n", "graph = nx.Graph(edges)\n", - "\n", - "mixer_name, cost_name = qaoa_maxcut(builder=builder, graph=graph)\n", + "algo = QAOA(3)\n", + "algo.setup_maxcut(graph=graph)\n", + "module = algo.generate_algorithm(algo.cost_hamiltonian, 2)\n", + "'''mixer_name, cost_name = qaoa_maxcut(builder=builder, graph=graph)\n", "print(mixer_name)\n", "print(cost_name)\n", "layer_name = layer(builder=builder, cost_ham=cost_name, mixer_ham=mixer_name)\n", "print(cost_function(builder=builder, depth=2, layer=layer_name, params=[[0.5, 0.5], [0.5, 0.5]]))\n", "\n", - "generate_algorithm(builder=builder, layer=layer_name, cost_ham=cost_name, depth=2)" + "generate_algorithm(builder=builder, layer=layer_name, cost_ham=cost_name, depth=2)'''" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "id": "f9157c73", "metadata": {}, "outputs": [ @@ -261,26 +267,21 @@ "\trz(2 * gamma) qb[3];\n", "\tcnot qb[2],qb[3];\n", "}\n", - "def qaoa_maxcut_mixer_3(qubit[3] qubits,float alpha) {\n", + "def qaoa_x_mixer_3(qubit[3] qubits,float alpha) {\n", "\trx(-2 * alpha) qb[0];\n", "\trx(-2 * alpha) qb[1];\n", "\trx(-2 * alpha) qb[2];\n", "}\n", "def qaoa_layer_function_3(qubit[3] qubits,float gamma,float alpha) {\n", "\tqaoa_maxcut_cost_3(qubits, gamma);\n", - "\tqaoa_maxcut_mixer_3(qubits, alpha);\n", + "\tqaoa_x_mixer_3(qubits, alpha);\n", "}\n", - "h qb[0];\n", - "h qb[1];\n", - "h qb[2];\n", - "qaoa_layer_function_3(qubits, 0.5, 0.5);\n", - "qaoa_layer_function_3(qubits, 0.5, 0.5);\n", - "input float gamma_0 ;\n", - "input float alpha_0 ;\n", - "input float gamma_1 ;\n", - "input float alpha_1 ;\n", - "int measure_0 ;\n", - "output float expval ;\n", + "input float gamma_0;\n", + "input float alpha_0;\n", + "input float gamma_1;\n", + "input float alpha_1;\n", + "int measure_0;\n", + "output float expval;\n", "for int i in [0:9999] {\n", "\treset qb[0];\n", "\treset qb[1];\n", @@ -305,12 +306,13 @@ "\tcswap qb[qb[6]],qb[qb[0], qb[3]];\n", "\tcswap qb[qb[6]],qb[qb[1], qb[4]];\n", "\tcswap qb[qb[6]],qb[qb[2], qb[5]];\n", - "\tcb[{b[0}] = measure qb[{b[}];\n", + "\tcb[{0}] = measure qb[{6}];\n", "\tif (cb[0] == 0){\n", "\t\tmeasure_0 = measure_0 + 1;\n", "\t}\n", "}\n", "expval = measure_0/10000;\n", + "expval = 2*(expval - 0.5);\n", "expval = sqrt(expval);\n", "expval = log(expval);\n", "\n" @@ -318,65 +320,140 @@ } ], "source": [ - "program = builder.build()\n", + "program = module\n", "\n", - "print(program)" + "print(program)\n", + "\n", + "module = pyqasm.loads(program)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 31, "id": "d27b0782", "metadata": {}, + "outputs": [], + "source": [ + "import pennylane as qml\n", + "from qiskit_qasm3_import import parse\n", + "from qiskit import qasm3" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "5e8714c7", + "metadata": {}, "outputs": [ { - "ename": "ResourceNotFoundError", - "evalue": "Failed to authenticate with the Quantum service.", + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR:pyqasm: Error at line 48, column 1 in QASM file\n", + "\n", + " >>>>>> qaoa_layer_function_3(qb[0:3], gamma_0, alpha_0)\n", + "\n" + ] + }, + { + "ename": "ValidationError", + "evalue": "Undefined variable 'gamma_0' used for function call 'qaoa_layer_function_3'\n\nUsage: qaoa_layer_function_3 ( qubit[3] qubits , float gamma , float alpha )\n", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mHTTPError\u001b[39m Traceback (most recent call last)", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\sessions.py:187\u001b[39m, in \u001b[36mSession.request\u001b[39m\u001b[34m(self, method, url, *args, **kwargs)\u001b[39m\n\u001b[32m 186\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._raise_for_status:\n\u001b[32m--> \u001b[39m\u001b[32m187\u001b[39m \u001b[43mresponse\u001b[49m\u001b[43m.\u001b[49m\u001b[43mraise_for_status\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 189\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m requests.RequestException \u001b[38;5;28;01mas\u001b[39;00m err:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\requests\\models.py:1026\u001b[39m, in \u001b[36mResponse.raise_for_status\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 1025\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m http_error_msg:\n\u001b[32m-> \u001b[39m\u001b[32m1026\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m HTTPError(http_error_msg, response=\u001b[38;5;28mself\u001b[39m)\n", - "\u001b[31mHTTPError\u001b[39m: 400 Client Error: Bad Request for url: https://api.qbraid.com/api/identity", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[31mRequestsApiError\u001b[39m Traceback (most recent call last)", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\sessions.py:365\u001b[39m, in \u001b[36mQbraidSession.get_user\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 364\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m365\u001b[39m metadata = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m/identity\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m.json()\n\u001b[32m 366\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m RequestsApiError \u001b[38;5;28;01mas\u001b[39;00m err:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\requests\\sessions.py:602\u001b[39m, in \u001b[36mSession.get\u001b[39m\u001b[34m(self, url, **kwargs)\u001b[39m\n\u001b[32m 601\u001b[39m kwargs.setdefault(\u001b[33m\"\u001b[39m\u001b[33mallow_redirects\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m--> \u001b[39m\u001b[32m602\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mGET\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\sessions.py:203\u001b[39m, in \u001b[36mSession.request\u001b[39m\u001b[34m(self, method, url, *args, **kwargs)\u001b[39m\n\u001b[32m 201\u001b[39m message = \u001b[38;5;28mself\u001b[39m._mask_sensitive_data(message, \u001b[38;5;28mself\u001b[39m.auth_headers)\n\u001b[32m--> \u001b[39m\u001b[32m203\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m RequestsApiError(message) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01merr\u001b[39;00m\n\u001b[32m 205\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m response\n", - "\u001b[31mRequestsApiError\u001b[39m: 400 Client Error: Bad Request for url: https://api.qbraid.com/api/identity.", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[31mUserNotFoundError\u001b[39m Traceback (most recent call last)", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\client.py:51\u001b[39m, in \u001b[36mQbraidClient.session\u001b[39m\u001b[34m(self, value)\u001b[39m\n\u001b[32m 50\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m---> \u001b[39m\u001b[32m51\u001b[39m user = \u001b[43msession\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_user\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 52\u001b[39m \u001b[38;5;28mself\u001b[39m._user_metadata = {\n\u001b[32m 53\u001b[39m \u001b[33m\"\u001b[39m\u001b[33morganization\u001b[39m\u001b[33m\"\u001b[39m: user.get(\u001b[33m\"\u001b[39m\u001b[33morganization\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33mqbraid\u001b[39m\u001b[33m\"\u001b[39m),\n\u001b[32m 54\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mrole\u001b[39m\u001b[33m\"\u001b[39m: user.get(\u001b[33m\"\u001b[39m\u001b[33mrole\u001b[39m\u001b[33m\"\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33muser\u001b[39m\u001b[33m\"\u001b[39m),\n\u001b[32m 55\u001b[39m }\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\sessions.py:367\u001b[39m, in \u001b[36mQbraidSession.get_user\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 366\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m RequestsApiError \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m--> \u001b[39m\u001b[32m367\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m UserNotFoundError(\u001b[38;5;28mstr\u001b[39m(err)) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01merr\u001b[39;00m\n\u001b[32m 369\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m metadata:\n", - "\u001b[31mUserNotFoundError\u001b[39m: 400 Client Error: Bad Request for url: https://api.qbraid.com/api/identity.", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[31mAuthError\u001b[39m Traceback (most recent call last)", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid\\runtime\\native\\provider.py:140\u001b[39m, in \u001b[36mQbraidProvider.client\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 139\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m--> \u001b[39m\u001b[32m140\u001b[39m \u001b[38;5;28mself\u001b[39m._client = \u001b[43mQuantumClient\u001b[49m\u001b[43m(\u001b[49m\u001b[43mapi_key\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_api_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 141\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m AuthError \u001b[38;5;28;01mas\u001b[39;00m err:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\services\\quantum\\client.py:31\u001b[39m, in \u001b[36mQuantumClient.__init__\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 30\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, *args, **kwargs):\n\u001b[32m---> \u001b[39m\u001b[32m31\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[34;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\client.py:29\u001b[39m, in \u001b[36mQbraidClient.__init__\u001b[39m\u001b[34m(self, api_key, session)\u001b[39m\n\u001b[32m 28\u001b[39m \u001b[38;5;28mself\u001b[39m._user_metadata: Optional[\u001b[38;5;28mdict\u001b[39m[\u001b[38;5;28mstr\u001b[39m, \u001b[38;5;28mstr\u001b[39m]] = \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m29\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43msession\u001b[49m = session \u001b[38;5;129;01mor\u001b[39;00m QbraidSession(api_key=api_key)\n\u001b[32m 30\u001b[39m check_version(\u001b[33m\"\u001b[39m\u001b[33mqbraid-core\u001b[39m\u001b[33m\"\u001b[39m)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid_core\\client.py:58\u001b[39m, in \u001b[36mQbraidClient.session\u001b[39m\u001b[34m(self, value)\u001b[39m\n\u001b[32m 57\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m UserNotFoundError \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m---> \u001b[39m\u001b[32m58\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m AuthError(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mAccess denied due to missing or invalid credentials: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00merr\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01merr\u001b[39;00m\n", - "\u001b[31mAuthError\u001b[39m: Access denied due to missing or invalid credentials: 400 Client Error: Bad Request for url: https://api.qbraid.com/api/identity.", - "\nThe above exception was the direct cause of the following exception:\n", - "\u001b[31mResourceNotFoundError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m provider = QbraidProvider()\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m device = \u001b[43mprovider\u001b[49m\u001b[43m.\u001b[49m\u001b[43mget_device\u001b[49m\u001b[43m(\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mqbraid_qir_simulator\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[32m 3\u001b[39m \u001b[38;5;28mprint\u001b[39m(provider.get_devices())\n\u001b[32m 4\u001b[39m module = pyqasm.load(program)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid\\_caching.py:75\u001b[39m, in \u001b[36m_cached_method_wrapper..decorator..wrapper\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 73\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m os.getenv(\u001b[33m\"\u001b[39m\u001b[33m_QBRAID_TEST_CACHE_CALLS\u001b[39m\u001b[33m\"\u001b[39m) == \u001b[33m\"\u001b[39m\u001b[33m1\u001b[39m\u001b[33m\"\u001b[39m:\n\u001b[32m 74\u001b[39m _ = func(\u001b[38;5;28mself\u001b[39m, *args, **kwargs)\n\u001b[32m---> \u001b[39m\u001b[32m75\u001b[39m result = \u001b[43mcached_func\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 76\u001b[39m cached_func.cache[key] = (result, time.time())\n\u001b[32m 77\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid\\runtime\\native\\provider.py:299\u001b[39m, in \u001b[36mQbraidProvider.__hash__\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 297\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m__hash__\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[32m 298\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mhasattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33m_hash\u001b[39m\u001b[33m\"\u001b[39m):\n\u001b[32m--> \u001b[39m\u001b[32m299\u001b[39m user_metadata = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mclient\u001b[49m._user_metadata\n\u001b[32m 300\u001b[39m organization_role = \u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00muser_metadata[\u001b[33m\"\u001b[39m\u001b[33morganization\u001b[39m\u001b[33m\"\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m-\u001b[39m\u001b[38;5;132;01m{\u001b[39;00muser_metadata[\u001b[33m\"\u001b[39m\u001b[33mrole\u001b[39m\u001b[33m\"\u001b[39m]\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m\n\u001b[32m 301\u001b[39m hash_value = \u001b[38;5;28mhash\u001b[39m(\n\u001b[32m 302\u001b[39m (\u001b[38;5;28mself\u001b[39m.\u001b[34m__class__\u001b[39m.\u001b[34m__name__\u001b[39m, \u001b[38;5;28mself\u001b[39m.client.session.api_key, organization_role)\n\u001b[32m 303\u001b[39m )\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qbraid\\runtime\\native\\provider.py:142\u001b[39m, in \u001b[36mQbraidProvider.client\u001b[39m\u001b[34m(self)\u001b[39m\n\u001b[32m 140\u001b[39m \u001b[38;5;28mself\u001b[39m._client = QuantumClient(api_key=\u001b[38;5;28mself\u001b[39m._api_key)\n\u001b[32m 141\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m AuthError \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m--> \u001b[39m\u001b[32m142\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m ResourceNotFoundError(\n\u001b[32m 143\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mFailed to authenticate with the Quantum service.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 144\u001b[39m ) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01merr\u001b[39;00m\n\u001b[32m 145\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m._client\n", - "\u001b[31mResourceNotFoundError\u001b[39m: Failed to authenticate with the Quantum service." + "\u001b[31mValidationError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[36]\u001b[39m\u001b[32m, line 72\u001b[39m\n\u001b[32m 70\u001b[39m module = pyqasm.loads(program)\n\u001b[32m 71\u001b[39m \u001b[38;5;66;03m#loaded_circuit = qml.from_qasm(module.unroll())\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m72\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[43mmodule\u001b[49m\u001b[43m.\u001b[49m\u001b[43munroll\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\modules\\base.py:60\u001b[39m, in \u001b[36mtrack_user_operation..wrapper\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 57\u001b[39m log_message = \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mrebase(\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtarget_basis_set\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m)\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 59\u001b[39m \u001b[38;5;28mself\u001b[39m._user_operations.append(log_message)\n\u001b[32m---> \u001b[39m\u001b[32m60\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\modules\\base.py:624\u001b[39m, in \u001b[36mQasmModule.unroll\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m 622\u001b[39m \u001b[38;5;28mself\u001b[39m.num_qubits, \u001b[38;5;28mself\u001b[39m.num_clbits = -\u001b[32m1\u001b[39m, -\u001b[32m1\u001b[39m\n\u001b[32m 623\u001b[39m \u001b[38;5;28mself\u001b[39m._unrolled_ast = Program(statements=[], version=\u001b[38;5;28mself\u001b[39m.original_program.version)\n\u001b[32m--> \u001b[39m\u001b[32m624\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m err\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\modules\\base.py:619\u001b[39m, in \u001b[36mQasmModule.unroll\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m 617\u001b[39m \u001b[38;5;28mself\u001b[39m._consolidate_qubits = consolidate_qbts\n\u001b[32m 618\u001b[39m visitor = QasmVisitor(module=\u001b[38;5;28mself\u001b[39m, scope_manager=ScopeManager(), **kwargs)\n\u001b[32m--> \u001b[39m\u001b[32m619\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvisitor\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 620\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m (ValidationError, UnrollError) \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m 621\u001b[39m \u001b[38;5;66;03m# reset the unrolled ast and qasm\u001b[39;00m\n\u001b[32m 622\u001b[39m \u001b[38;5;28mself\u001b[39m.num_qubits, \u001b[38;5;28mself\u001b[39m.num_clbits = -\u001b[32m1\u001b[39m, -\u001b[32m1\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\modules\\qasm3.py:51\u001b[39m, in \u001b[36mQasm3Module.accept\u001b[39m\u001b[34m(self, visitor)\u001b[39m\n\u001b[32m 45\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34maccept\u001b[39m(\u001b[38;5;28mself\u001b[39m, visitor):\n\u001b[32m 46\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Accept a visitor for the module\u001b[39;00m\n\u001b[32m 47\u001b[39m \n\u001b[32m 48\u001b[39m \u001b[33;03m Args:\u001b[39;00m\n\u001b[32m 49\u001b[39m \u001b[33;03m visitor (QasmVisitor): The visitor to accept\u001b[39;00m\n\u001b[32m 50\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m51\u001b[39m unrolled_stmt_list = \u001b[43mvisitor\u001b[49m\u001b[43m.\u001b[49m\u001b[43mvisit_basic_block\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_statements\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 52\u001b[39m final_stmt_list = visitor.finalize(unrolled_stmt_list)\n\u001b[32m 54\u001b[39m \u001b[38;5;28mself\u001b[39m._unrolled_ast.statements = final_stmt_list\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3140\u001b[39m, in \u001b[36mQasmVisitor.visit_basic_block\u001b[39m\u001b[34m(self, stmt_list)\u001b[39m\n\u001b[32m 3138\u001b[39m result = []\n\u001b[32m 3139\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m stmt \u001b[38;5;129;01min\u001b[39;00m stmt_list:\n\u001b[32m-> \u001b[39m\u001b[32m3140\u001b[39m result.extend(\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvisit_statement\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstmt\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[32m 3141\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3120\u001b[39m, in \u001b[36mQasmVisitor.visit_statement\u001b[39m\u001b[34m(self, statement)\u001b[39m\n\u001b[32m 3118\u001b[39m result.extend(ret_stmts)\n\u001b[32m 3119\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m3120\u001b[39m result.extend(\u001b[43mvisitor_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstatement\u001b[49m\u001b[43m)\u001b[49m) \u001b[38;5;66;03m# type: ignore[operator]\u001b[39;00m\n\u001b[32m 3121\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 3122\u001b[39m raise_qasm3_error(\n\u001b[32m 3123\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mUnsupported statement of type \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(statement)\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m,\n\u001b[32m 3124\u001b[39m error_node=statement,\n\u001b[32m 3125\u001b[39m span=statement.span,\n\u001b[32m 3126\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:2216\u001b[39m, in \u001b[36mQasmVisitor._visit_forin_loop\u001b[39m\u001b[34m(self, statement)\u001b[39m\n\u001b[32m 2214\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m statement_block != statement.block:\n\u001b[32m 2215\u001b[39m statement_block = copy.deepcopy(statement.block)\n\u001b[32m-> \u001b[39m\u001b[32m2216\u001b[39m result.extend(\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvisit_basic_block\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstatement_block\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[32m 2217\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 2218\u001b[39m result.extend(\u001b[38;5;28mself\u001b[39m.visit_basic_block(statement.block))\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3140\u001b[39m, in \u001b[36mQasmVisitor.visit_basic_block\u001b[39m\u001b[34m(self, stmt_list)\u001b[39m\n\u001b[32m 3138\u001b[39m result = []\n\u001b[32m 3139\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m stmt \u001b[38;5;129;01min\u001b[39;00m stmt_list:\n\u001b[32m-> \u001b[39m\u001b[32m3140\u001b[39m result.extend(\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvisit_statement\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstmt\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[32m 3141\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3117\u001b[39m, in \u001b[36mQasmVisitor.visit_statement\u001b[39m\u001b[34m(self, statement)\u001b[39m\n\u001b[32m 3114\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m visitor_function:\n\u001b[32m 3115\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(statement, qasm3_ast.ExpressionStatement):\n\u001b[32m 3116\u001b[39m \u001b[38;5;66;03m# these return a tuple of return value and list of statements\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m3117\u001b[39m _, ret_stmts = \u001b[43mvisitor_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstatement\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# type: ignore[operator]\u001b[39;00m\n\u001b[32m 3118\u001b[39m result.extend(ret_stmts)\n\u001b[32m 3119\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3102\u001b[39m, in \u001b[36mQasmVisitor.visit_statement..\u001b[39m\u001b[34m(x)\u001b[39m\n\u001b[32m 3081\u001b[39m logger.debug(\u001b[33m\"\u001b[39m\u001b[33mVisiting statement \u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m'\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28mstr\u001b[39m(statement))\n\u001b[32m 3082\u001b[39m result = []\n\u001b[32m 3083\u001b[39m visit_map = {\n\u001b[32m 3084\u001b[39m qasm3_ast.Include: \u001b[38;5;28mself\u001b[39m._visit_include, \u001b[38;5;66;03m# No operation\u001b[39;00m\n\u001b[32m 3085\u001b[39m qasm3_ast.QuantumMeasurementStatement: \u001b[38;5;28mself\u001b[39m._visit_measurement,\n\u001b[32m 3086\u001b[39m qasm3_ast.QuantumReset: \u001b[38;5;28mself\u001b[39m._visit_reset,\n\u001b[32m 3087\u001b[39m qasm3_ast.QuantumBarrier: \u001b[38;5;28mself\u001b[39m._visit_barrier,\n\u001b[32m 3088\u001b[39m qasm3_ast.QubitDeclaration: \u001b[38;5;28mself\u001b[39m._visit_quantum_register,\n\u001b[32m 3089\u001b[39m qasm3_ast.QuantumGateDefinition: \u001b[38;5;28mself\u001b[39m._visit_gate_definition,\n\u001b[32m 3090\u001b[39m qasm3_ast.QuantumGate: \u001b[38;5;28mself\u001b[39m._visit_generic_gate_operation,\n\u001b[32m 3091\u001b[39m qasm3_ast.QuantumPhase: \u001b[38;5;28mself\u001b[39m._visit_generic_gate_operation,\n\u001b[32m 3092\u001b[39m qasm3_ast.ClassicalDeclaration: \u001b[38;5;28mself\u001b[39m._visit_classical_declaration,\n\u001b[32m 3093\u001b[39m qasm3_ast.ClassicalAssignment: \u001b[38;5;28mself\u001b[39m._visit_classical_assignment,\n\u001b[32m 3094\u001b[39m qasm3_ast.ConstantDeclaration: \u001b[38;5;28mself\u001b[39m._visit_constant_declaration,\n\u001b[32m 3095\u001b[39m qasm3_ast.BranchingStatement: \u001b[38;5;28mself\u001b[39m._visit_branching_statement,\n\u001b[32m 3096\u001b[39m qasm3_ast.ForInLoop: \u001b[38;5;28mself\u001b[39m._visit_forin_loop,\n\u001b[32m 3097\u001b[39m qasm3_ast.WhileLoop: \u001b[38;5;28mself\u001b[39m._visit_while_loop,\n\u001b[32m 3098\u001b[39m qasm3_ast.AliasStatement: \u001b[38;5;28mself\u001b[39m._visit_alias_statement,\n\u001b[32m 3099\u001b[39m qasm3_ast.SwitchStatement: \u001b[38;5;28mself\u001b[39m._visit_switch_statement,\n\u001b[32m 3100\u001b[39m qasm3_ast.SubroutineDefinition: \u001b[38;5;28mself\u001b[39m._visit_subroutine_definition,\n\u001b[32m 3101\u001b[39m qasm3_ast.ExternDeclaration: \u001b[38;5;28mself\u001b[39m._visit_subroutine_definition,\n\u001b[32m-> \u001b[39m\u001b[32m3102\u001b[39m qasm3_ast.ExpressionStatement: \u001b[38;5;28;01mlambda\u001b[39;00m x: \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_visit_function_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m.\u001b[49m\u001b[43mexpression\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[32m 3103\u001b[39m qasm3_ast.IODeclaration: \u001b[38;5;28;01mlambda\u001b[39;00m x: [],\n\u001b[32m 3104\u001b[39m qasm3_ast.BreakStatement: \u001b[38;5;28mself\u001b[39m._visit_break,\n\u001b[32m 3105\u001b[39m qasm3_ast.ContinueStatement: \u001b[38;5;28mself\u001b[39m._visit_continue,\n\u001b[32m 3106\u001b[39m qasm3_ast.DelayInstruction: \u001b[38;5;28mself\u001b[39m._visit_delay_statement,\n\u001b[32m 3107\u001b[39m qasm3_ast.Box: \u001b[38;5;28mself\u001b[39m._visit_box_statement,\n\u001b[32m 3108\u001b[39m qasm3_ast.CalibrationDefinition: \u001b[38;5;28mself\u001b[39m._visit_calibration_definition,\n\u001b[32m 3109\u001b[39m qasm3_ast.CalibrationStatement: \u001b[38;5;28mself\u001b[39m._visit_calibration_statement,\n\u001b[32m 3110\u001b[39m qasm3_ast.CalibrationGrammarDeclaration: \u001b[38;5;28mself\u001b[39m._visit_calibration_grammar_declaration,\n\u001b[32m 3111\u001b[39m }\n\u001b[32m 3113\u001b[39m visitor_function = visit_map.get(\u001b[38;5;28mtype\u001b[39m(statement))\n\u001b[32m 3114\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m visitor_function:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:2331\u001b[39m, in \u001b[36mQasmVisitor._visit_function_call\u001b[39m\u001b[34m(self, statement)\u001b[39m\n\u001b[32m 2328\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m actual_arg, formal_arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(statement.arguments, subroutine_def.arguments):\n\u001b[32m 2329\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(formal_arg, (qasm3_ast.ClassicalArgument, qasm3_ast.ExternArgument)):\n\u001b[32m 2330\u001b[39m classical_vars.append(\n\u001b[32m-> \u001b[39m\u001b[32m2331\u001b[39m \u001b[43mQasm3SubroutineProcessor\u001b[49m\u001b[43m.\u001b[49m\u001b[43mprocess_classical_arg\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2332\u001b[39m \u001b[43m \u001b[49m\u001b[43mformal_arg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mactual_arg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfn_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstatement\u001b[49m\n\u001b[32m 2333\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2334\u001b[39m )\n\u001b[32m 2335\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 2336\u001b[39m quantum_vars.append(\n\u001b[32m 2337\u001b[39m Qasm3SubroutineProcessor.process_quantum_arg(\n\u001b[32m 2338\u001b[39m formal_arg,\n\u001b[32m (...)\u001b[39m\u001b[32m 2346\u001b[39m )\n\u001b[32m 2347\u001b[39m )\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\subroutines.py:144\u001b[39m, in \u001b[36mQasm3SubroutineProcessor.process_classical_arg\u001b[39m\u001b[34m(cls, formal_arg, actual_arg, fn_name, fn_call)\u001b[39m\n\u001b[32m 140\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(formal_arg.type, ArrayReferenceType):\n\u001b[32m 141\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m._process_classical_arg_by_reference(\n\u001b[32m 142\u001b[39m formal_arg, actual_arg, actual_arg_name, fn_name, fn_call\n\u001b[32m 143\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m144\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_process_classical_arg_by_value\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 145\u001b[39m \u001b[43m \u001b[49m\u001b[43mformal_arg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mactual_arg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mactual_arg_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfn_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfn_call\u001b[49m\n\u001b[32m 146\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\subroutines.py:190\u001b[39m, in \u001b[36mQasm3SubroutineProcessor._process_classical_arg_by_value\u001b[39m\u001b[34m(cls, formal_arg, actual_arg, actual_arg_name, fn_name, fn_call)\u001b[39m\n\u001b[32m 187\u001b[39m \u001b[38;5;66;03m# 2. as we have pushed the scope for fn, we need to check in parent\u001b[39;00m\n\u001b[32m 188\u001b[39m \u001b[38;5;66;03m# scope for argument validation\u001b[39;00m\n\u001b[32m 189\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mcls\u001b[39m.visitor_obj._scope_manager.check_in_scope(actual_arg_name):\n\u001b[32m--> \u001b[39m\u001b[32m190\u001b[39m \u001b[43mraise_qasm3_error\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 191\u001b[39m \u001b[43m \u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mUndefined variable \u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mactual_arg_name\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[33;43m used\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\n\u001b[32m 192\u001b[39m \u001b[43m \u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m for function call \u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mfn_name\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m\"\u001b[39;49m\n\u001b[32m 193\u001b[39m \u001b[43m \u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mUsage: \u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mfn_name\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m ( \u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mformal_args_desc\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m )\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 194\u001b[39m \u001b[43m \u001b[49m\u001b[43merror_node\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfn_call\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 195\u001b[39m \u001b[43m \u001b[49m\u001b[43mspan\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfn_call\u001b[49m\u001b[43m.\u001b[49m\u001b[43mspan\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 196\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 198\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(formal_arg, ExternArgument):\n\u001b[32m 199\u001b[39m formal_arg_type = formal_arg.type\n", + "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\exceptions.py:137\u001b[39m, in \u001b[36mraise_qasm3_error\u001b[39m\u001b[34m(message, err_type, error_node, span, raised_from)\u001b[39m\n\u001b[32m 135\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m raised_from:\n\u001b[32m 136\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m err_type(message) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mraised_from\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m137\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m err_type(message)\n", + "\u001b[31mValidationError\u001b[39m: Undefined variable 'gamma_0' used for function call 'qaoa_layer_function_3'\n\nUsage: qaoa_layer_function_3 ( qubit[3] qubits , float gamma , float alpha )\n" ] } ], "source": [ - "provider = QbraidProvider()\n", - "device = provider.get_device(\"qbraid_qir_simulator\")\n", - "print(provider.get_devices())\n", - "module = pyqasm.load(program)\n", - "module.unroll()\n", - "qasm_str = pyqasm.dumps(module)\n", - "job = device.run(qasm_str, shots=500)\n", - "results = job.result()\n", - "counts = results.data.get_counts()" + "program = \"\"\"\n", + "OPENQASM 3;\n", + "include \"stdgates.inc\";\n", + "input float gamma_0;\n", + "input float alpha_0;\n", + "input float gamma_1;\n", + "input float alpha_1;\n", + "qubit[7] qb;\n", + "bit[3] mid;\n", + "def qaoa_maxcut_cost_3(qubit[3] qubits,float gamma) {\n", + "\tcnot qb[0],qb[1];\n", + "\trz(2 * gamma) qb[1];\n", + "\tcnot qb[0],qb[1];\n", + "\tcnot qb[0],qb[2];\n", + "\trz(2 * gamma) qb[2];\n", + "\tcnot qb[0],qb[2];\n", + "\tcnot qb[1],qb[2];\n", + "\trz(2 * gamma) qb[2];\n", + "\tcnot qb[1],qb[2];\n", + "\tcnot qb[2],qb[3];\n", + "\trz(2 * gamma) qb[3];\n", + "\tcnot qb[2],qb[3];\n", + "}\n", + "def qaoa_x_mixer_3(qubit[3] qubits,float alpha) {\n", + "\trx(-2 * alpha) qb[0];\n", + "\trx(-2 * alpha) qb[1];\n", + "\trx(-2 * alpha) qb[2];\n", + "}\n", + "def qaoa_layer_function_3(qubit[3] qubits,float gamma,float alpha) {\n", + "\tqaoa_maxcut_cost_3(qubits, gamma);\n", + "\tqaoa_x_mixer_3(qubits, alpha);\n", + "}\n", + "for int i in [0:9999] {\n", + "\treset qb[0];\n", + "\treset qb[1];\n", + "\treset qb[2];\n", + "\treset qb[3];\n", + "\treset qb[4];\n", + "\treset qb[5];\n", + "\treset qb[6];\n", + "\th qb[0];\n", + "\th qb[1];\n", + "\th qb[2];\n", + "\th qb[3];\n", + "\th qb[4];\n", + "\th qb[5];\n", + "\th qb[6];\n", + "\tqaoa_layer_function_3(qb[0:3], gamma_0, alpha_0);\n", + "\tqaoa_layer_function_3(qb[3:6], gamma_0, alpha_0);\n", + "\tqaoa_layer_function_3(qb[0:3], gamma_1, alpha_1);\n", + "\tqaoa_layer_function_3(qb[3:6], gamma_1, alpha_1);\n", + "\tqaoa_maxcut_cost_3(qb[0:3], 1);\n", + "\th qb[6];\n", + "\tcswap qb[qb[6]],qb[qb[0], qb[3]];\n", + "\tcswap qb[qb[6]],qb[qb[1], qb[4]];\n", + "\tcswap qb[qb[6]],qb[qb[2], qb[5]];\n", + "\tmeasure qb[{6}] -> mid[0];\n", + "\tif (mid[0] == 0){\n", + "\t\tmeasure_0 = measure_0 + 1;\n", + "\t}\n", + "}\n", + "out = measure_0/10000;\n", + "out = 2*(out - 0.5);\n", + "out = sqrt(out);\n", + "out = log(out);\n", + "\n", + "\"\"\"\n", + "\n", + "\n", + "module = pyqasm.loads(program)\n", + "#loaded_circuit = qml.from_qasm(module.unroll())\n", + "print(module.unroll())" ] }, { @@ -397,8 +474,8 @@ } ], "source": [ - "graph = nx.Graph([(0, 1), (1, 2)])\n", - "# graph = nx.Graph(edges)\n", + "edges = [(0, 1), (1, 2), (2, 0), (2, 3)]\n", + "graph = nx.Graph(edges)\n", "positions = nx.spring_layout(graph, seed=1)\n", "\n", "nx.draw(graph, with_labels=True, pos=positions)\n", @@ -407,7 +484,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "0d1cf38b", "metadata": {}, "outputs": [], @@ -420,7 +497,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "e0a2c6c0", "metadata": {}, "outputs": [ From 49bbc5c332dd010bc5fe02f3ee58ca7cf5cc7fb6 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Fri, 23 Jan 2026 16:47:20 +0100 Subject: [PATCH 07/20] Fixed SWAP-test --- qbraid_algorithms/qaoa/qaoa.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index b9637b8..490a3bf 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -288,7 +288,7 @@ def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsi std.h(self.builder.qubits - 1) for q in range(num_qubits): std.cswap(control=f"qb[{self.builder.qubits - 1}]", targ1=f"qb[{q}]", targ2=f"qb[{q+num_qubits}]") - + std.h(self.builder.qubits - 1) std.measure([self.builder.qubits - 1], [0]) std.begin_if("cb[0] == 0") From 5c20d910a56417724f9c6944bf06b91130d9bd9d Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Mon, 26 Jan 2026 20:06:56 +0100 Subject: [PATCH 08/20] Modification after testing against qiskit QAOA tutorial --- qbraid_algorithms/qaoa/qaoa.py | 71 +-- qbraid_algorithms/qaoa/test.ipynb | 739 ++++++++++-------------- qbraid_algorithms/qtran/gate_library.py | 8 +- qbraid_algorithms/qtran/qasm_builder.py | 2 + 4 files changed, 361 insertions(+), 459 deletions(-) diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index 490a3bf..96a821a 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -10,10 +10,11 @@ class QAOA: cost_hamiltonian : str layer_circuit : str use_subroutines : bool + use_input : bool - def __init__(self, num_qubits : int, use_subroutines : bool = False, qasm_version : int = 3): + def __init__(self, num_qubits : int, qasm_version : int = 3, use_input : bool = True): self.builder = QasmBuilder(num_qubits, version=qasm_version) - self.builder.claim_clbits(num_qubits) + self.use_input = use_input def xy_mixer(self, graph : nx.Graph) -> str: @@ -38,13 +39,15 @@ def xy_mixer(self, graph : nx.Graph) -> str: std.begin_subroutine( mixer_name, [qubit_array_param, alpha] ) + old_call_space = std.call_space + std.call_space = "qubits[{}]" for i,j in graph.edges: std.cnot(i,j) std.rx("-alpha", j) std.ry("-alpha", j) std.cnot(i,j) - + std.call_space = old_call_space std.end_subroutine() return mixer_name @@ -71,10 +74,11 @@ def x_mixer(self, graph : nx.Graph) -> str: std.begin_subroutine( mixer_name, [qubit_array_param, alpha] ) - - for i in range(self.builder.qubits): - std.rx("-2 * alpha", i) - + old_call_space = std.call_space + std.call_space = "qubits[{}]" + for i in graph.nodes: + std.rx("2 * alpha", i) + std.call_space = old_call_space std.end_subroutine() return mixer_name @@ -102,7 +106,8 @@ def min_vertex_cover_cost(self, graph : nx.Graph) -> str: std.begin_subroutine( cost_name, [qubit_array_param , gamma] ) - + old_call_space = std.call_space + std.call_space = "qubits[{}]" for i,j in graph.edges: std.cnot(i,j) std.rz("3 * 2 * gamma", j) @@ -112,7 +117,7 @@ def min_vertex_cover_cost(self, graph : nx.Graph) -> str: for i in graph.nodes: std.rz("-2 * gamma", i) - + std.call_space = old_call_space std.end_subroutine() @@ -141,7 +146,8 @@ def max_clique_cost(self, graph : nx.Graph) -> str: std.begin_subroutine( cost_name, [qubit_array_param , gamma] ) - + old_call_space = std.call_space + std.call_space = "qubits[{}]" graph_complement = nx.complement(graph) for i,j in graph_complement.edges: @@ -153,7 +159,7 @@ def max_clique_cost(self, graph : nx.Graph) -> str: for i in graph.nodes: std.rz("2 * gamma", i) - + std.call_space = old_call_space std.end_subroutine() @@ -184,12 +190,13 @@ def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : std.begin_subroutine( cost_name, [qubit_array_param , gamma] ) - + old_call_space = std.call_space + std.call_space = "qubits[{}]" for i,j in graph.edges: std.cnot(i,j) - std.rz("2 * gamma", j) + std.rz("-2 * gamma", j) std.cnot(i,j) - + std.call_space = old_call_space std.end_subroutine() @@ -239,7 +246,7 @@ def layer(self, cost_ham : str, mixer_ham : str) -> str : return name - def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsilon : float = 0.01) -> str: + def generate_algorithm(self, depth : int, layer : str = "", param : list[float] = []) -> str: """ Load the Quantum Approximate Optimization Algorithm (QAOA) ansatz as a pyqasm module. @@ -261,18 +268,16 @@ def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsi layer = self.layer_circuit if layer == "" else layer num_qubits = self.builder.qubits - self.builder.claim_qubits(self.builder.qubits) - self.builder.claim_qubits(1) - - repetitions = int(round((1.0/epsilon)**2)) + #self.builder.claim_qubits(self.builder.qubits) + #self.builder.claim_qubits(1) for i in range(depth): - std.add_input_var(f"gamma_{i}", qtype="float") - std.add_input_var(f"alpha_{i}", qtype="float") - - std.add_var(name="measure_0", qtype="int") - std.add_output_var("expval", qtype="float") - std.begin_loop(repetitions) + if self.use_input: + std.add_input_var(f"gamma_{i}", qtype="float") + std.add_input_var(f"alpha_{i}", qtype="float") + else: + std.classical_op(f"float gamma_{i} = {param[i]}") + std.classical_op(f"float alpha_{i} = {param[i+1]}") for q in range(self.builder.qubits): std.reset(q) @@ -282,24 +287,22 @@ def generate_algorithm(self, cost_ham : str, depth : int, layer : str = "", epsi for i in range(depth): std.call_subroutine(layer, parameters=[f"qb[0:{num_qubits}]", f"gamma_{i}", f"alpha_{i}"]) - std.call_subroutine(layer, parameters=[f"qb[{num_qubits}:{num_qubits*2}]", f"gamma_{i}", f"alpha_{i}"]) - std.call_subroutine(cost_ham, [f"qb[0:{num_qubits}]", "1"]) - std.h(self.builder.qubits - 1) - for q in range(num_qubits): + #std.call_subroutine(cost_ham, [f"qb[0:{num_qubits}]", "1"]) + #std.h(self.builder.qubits - 1) + std.measure(list(range(num_qubits)), list(range(num_qubits))) + """for q in range(num_qubits): std.cswap(control=f"qb[{self.builder.qubits - 1}]", targ1=f"qb[{q}]", targ2=f"qb[{q+num_qubits}]") std.h(self.builder.qubits - 1) std.measure([self.builder.qubits - 1], [0]) std.begin_if("cb[0] == 0") std.classical_op("measure_0 = measure_0 + 1") - std.end_if() - - std.end_loop() + std.end_if()""" - std.classical_op(f"expval = measure_0/{repetitions}") + """std.classical_op(f"expval = measure_0/{repetitions}") std.classical_op("expval = 2*(expval - 0.5)") std.classical_op("expval = sqrt(expval)") - std.classical_op("expval = log(expval)") + std.classical_op("expval = log(expval)")""" return self.builder.build() diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb index fd4a11a..62ed6c2 100644 --- a/qbraid_algorithms/qaoa/test.ipynb +++ b/qbraid_algorithms/qaoa/test.ipynb @@ -2,471 +2,304 @@ "cells": [ { "cell_type": "code", - "execution_count": 6, + "execution_count": 1, "id": "aba58bd7", "metadata": {}, "outputs": [], "source": [ - "from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder\n", "from matplotlib import pyplot as plt\n", "import networkx as nx\n", - "# from qbraid.runtime import QbraidProvider\n", "from qbraid_algorithms.qaoa import QAOA\n", - "import pyqasm" + "import pyqasm\n", + "\n", + "from qiskit_qasm3_import import parse\n", + "from qiskit_ibm_runtime import Session, Sampler as Sampler, Estimator\n", + "from qiskit_aer import AerSimulator\n", + "from scipy.optimize import minimize\n", + "from qiskit.visualization import plot_histogram\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "import numpy as np\n", + "from typing import Sequence" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "765b9ec9", + "execution_count": 2, + "id": "18ff0ac8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "def qaoa_maxcut(builder : QasmBuilder, graph : nx.Graph) -> tuple[str, str] : \n", - " std = builder.import_library(lib_class=std_gates)\n", - " \n", - " cost_name = f\"qaoa_maxcut_cost_{builder.qubits}\"\n", - "\n", - " qubit_array_param = f\"qubit[{builder.qubits}] qubits\"\n", - "\n", - " gamma = \"float gamma\"\n", - "\n", - " # cost hamiltonian \\sum_{E(graph)} Z_i @ Z_j\n", - " std.begin_subroutine(\n", - " cost_name, [qubit_array_param , gamma]\n", - " )\n", + "edges = [(0, 1), (0, 2), (0, 4), (1, 2), (2, 3), (3, 4)]\n", + "graph = nx.Graph(edges)\n", + "positions = nx.spring_layout(graph, seed=1)\n", "\n", + "nx.draw(graph, with_labels=True, pos=positions)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cb51638b", + "metadata": {}, + "outputs": [], + "source": [ + "objective_func_vals = []" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9d2812e8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost Function Hamiltonian: SparsePauliOp(['IIIZZ', 'IIZIZ', 'ZIIIZ', 'IIZZI', 'IZZII', 'ZZIII'],\n", + " coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])\n" + ] + } + ], + "source": [ + "def build_max_cut_paulis(graph: nx.Graph) -> list[tuple[str, float]]:\n", + " \"\"\"Convert the graph to Pauli list.\n", + " \n", + " This function does the inverse of `build_max_cut_graph`\n", + " \"\"\"\n", + " pauli_list = []\n", " for i,j in graph.edges:\n", - " std.cnot(i,j)\n", - " std.rz(\"2 * gamma\", j)\n", - " std.cnot(i,j)\n", - "\n", - " std.end_subroutine()\n", - "\n", - "\n", - " # mixer hamiltonian \\sum_{i} X_i\n", - " mixer_name = f\"qaoa_maxcut_mixer_{builder.qubits}\"\n", - "\n", - " alpha = \"float alpha\"\n", - "\n", - " std.begin_subroutine(\n", - " mixer_name, [qubit_array_param, alpha]\n", - " )\n", - "\n", - " for i in range(builder.qubits):\n", - " std.rx(\"-2 * alpha\", i)\n", - " \n", - " std.end_subroutine()\n", + " pauli_list.append((\"ZZ\", [i, j], 1))\n", + " return pauli_list\n", "\n", - " return mixer_name, cost_name\n", - "\n", - "def layer(builder : QasmBuilder, cost_ham : str, mixer_ham : str) -> str :\n", - " std = builder.import_library(lib_class=std_gates)\n", - "\n", - " name = f\"qaoa_layer_function_{builder.qubits}\"\n", - "\n", - " qubit_array_param = f\"qubit[{builder.qubits}] qubits\"\n", - " gamma = \"float gamma\"\n", - " alpha = \"float alpha\"\n", - "\n", - " std.begin_subroutine(\n", - " name, [qubit_array_param , gamma, alpha]\n", - " )\n", - "\n", - " std.call_subroutine(cost_ham, [\"qubits\", \"gamma\"])\n", - " std.call_subroutine(mixer_ham, [\"qubits\", \"alpha\"])\n", - "\n", - " std.end_subroutine()\n", - "\n", - " return name\n", - "\n", - "def cost_function(builder : QasmBuilder, layer : str, depth : int, params : list[tuple[float, float]]) -> str :\n", - " std = builder.import_library(lib_class=std_gates)\n", - "\n", - " name = f\"qaoa_cost_function_{layer}\"\n", - "\n", - " qubit_array_param = f\"qubit[{builder.qubits}] qubits\"\n", - "\n", - " for i in range(builder.qubits):\n", - " std.h(i)\n", - "\n", - " for i in range(depth):\n", - " std.call_subroutine(layer, parameters=[\"qubits\", params[i][0], params[i][1]])\n", - "\n", - " return name\n", - "\n", - "\n", - "def calculate_gradient_function(builder : QasmBuilder, hamiltonian : str, delta : float = 0.1) -> str :\n", - " std = builder.import_library(lib_class=std_gates)\n", - "\n", - " name = f\"qaoa_compute_gradient_{hamiltonian}\"\n", - "\n", - " qubit_array_param = f\"qubit[{builder.qubits}] qubits\"\n", - "\n", - " std.begin_subroutine(\n", - " name, [qubit_array_param, \"float value\"], \"float\"\n", - " )\n", - " std.add_var(name=\"frac\", qtype=\"float\")\n", - " std.add_var(name=\"val1\", qtype=\"int\")\n", - " std.add_var(name=\"val2\", qtype=\"int\")\n", - " std.call_subroutine(hamiltonian, [qubit_array_param, f\"value + {delta}\"])\n", - " std.measure(range(builder.qubits), range(builder.qubits))\n", - " std.classical_op(f\"val1 = cb[0:{builder.qubits}]\")\n", - " std.call_subroutine(hamiltonian, [qubit_array_param, f\"value - {delta}\"])\n", - " std.measure(range(builder.qubits), [i + builder.qubits for i in range(builder.qubits)])\n", - " std.classical_op(f\"val2 = cb[{builder.qubits}:{builder.qubits*2}]\")\n", - " std.classical_op(operation=f\"frac = (val1 - val2)/(2* {delta})\")\n", - "\n", - " std.classical_op(operation=\"return frac\")\n", - "\n", - " std.end_subroutine()\n", - "\n", - " return name\n", - "\n", - "def generate_algorithm(builder : QasmBuilder, layer : str, cost_ham : str, depth : int, epsilon : float = 0.01) :\n", - " std = builder.import_library(lib_class=std_gates)\n", - "\n", - " num_qubits = builder.qubits\n", - " builder.claim_qubits(builder.qubits)\n", - " builder.claim_qubits(1)\n", - "\n", - " repetitions = int(round((1.0/epsilon)**2))\n", - " \n", - " for i in range(depth):\n", - " std.add_input_var(f\"gamma_{i}\", qtype=\"float\")\n", - " std.add_input_var(f\"alpha_{i}\", qtype=\"float\")\n", - " \n", - " std.add_var(name=\"measure_0\", qtype=\"int\")\n", - " std.add_output_var(\"expval\", qtype=\"float\")\n", - " std.begin_loop(repetitions)\n", - " \n", - " for q in range(builder.qubits):\n", - " std.reset(q)\n", - " \n", - " for q in range(builder.qubits):\n", - " std.h(q)\n", - "\n", - " for i in range(depth):\n", - " std.call_subroutine(layer, parameters=[f\"qb[0:{num_qubits}]\", f\"gamma_{i}\", f\"alpha_{i}\"])\n", - " std.call_subroutine(layer, parameters=[f\"qb[{num_qubits}:{num_qubits*2}]\", f\"gamma_{i}\", f\"alpha_{i}\"])\n", - "\n", - " std.call_subroutine(cost_ham, [f\"qb[0:{num_qubits}]\", \"1\"])\n", - " std.h(builder.qubits - 1)\n", - " for q in range(num_qubits):\n", - " std.cswap(control=f\"qb[{builder.qubits - 1}]\", targ1=f\"qb[{q}]\", targ2=f\"qb[{q+num_qubits}]\")\n", - " \n", - " std.measure(f\"qb[{builder.qubits - 1}\", \"cb[0]\")\n", - "\n", - " std.begin_if(\"cb[0] == 0\")\n", - " std.classical_op(\"measure_0 = measure_0 + 1\")\n", - " std.end_if()\n", - " \n", - " std.end_loop()\n", - "\n", - " std.classical_op(f\"expval = measure_0/{repetitions}\")\n", - " std.classical_op(\"expval = 2*(expval - 0.5)\")\n", - " std.classical_op(\"expval = sqrt(expval)\")\n", - " std.classical_op(\"expval = log(expval)\")\n" + "n = 5\n", + "max_cut_paulis = build_max_cut_paulis(graph)\n", + "cost_hamiltonian = SparsePauliOp.from_sparse_list(max_cut_paulis, n)\n", + "print(\"Cost Function Hamiltonian:\", cost_hamiltonian)" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "06a3e05a", + "execution_count": 5, + "id": "5e8714c7", "metadata": {}, "outputs": [], "source": [ - "def expectation_value(builder : QasmBuilder, cost_ham : str, params : list[tuple[float, float]], epsilon : float = 0.01) -> str :\n", - " repetitions = int(Math.round(Math.pow(1/epsilon, 2)))\n", - " std = builder.import_library(lib_class=std_gates)\n", - " original_qubits = builder.qubits\n", - " builder.claim_qubits(builder.qubits)\n", - "\n", - " name = f\"qaoa_compute_expectation_value_{cost_ham}\"\n", - "\n", - " qubit_copy_array_param = f\"qubit[{original_qubits}] qubits_copy\"\n", - "\n", - " std.begin_subroutine(\n", - " name, [qubit_copy_array_param], \"float\"\n", - " )\n", - "\n", - " for i in range(repetitions):\n", - " std.call_subroutine(cost_ham, [\"qubits_copy\", \"1\"])\n" + "def cost_function_res(params):\n", + " qaoa = QAOA(5, use_input=False)\n", + " qaoa.setup_maxcut(graph=graph)\n", + " program = qaoa.generate_algorithm(3, param=params)\n", + " module = pyqasm.loads(program)\n", + " module.unroll()\n", + " loaded_circuit = parse(pyqasm.dumps(module))\n", + " aer_sim = AerSimulator()\n", + " with Session(backend=aer_sim):\n", + " sampler = Sampler()\n", + " sampler.options.dynamical_decoupling.enable = True\n", + " sampler.options.dynamical_decoupling.sequence_type = \"XY4\"\n", + " sampler.options.twirling.enable_gates = True\n", + " sampler.options.twirling.num_randomizations = \"auto\"\n", + " result = sampler.run([loaded_circuit], shots=10000).result()\n", + " return result[0].data.cb.get_counts(), result[0].data.cb.get_int_counts()" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "18ff0ac8", + "execution_count": 6, + "id": "76eec508", + "metadata": {}, + "outputs": [], + "source": [ + "def cost_function(params):\n", + " qaoa = QAOA(5, use_input=False)\n", + " qaoa.setup_maxcut(graph=graph)\n", + " program = qaoa.generate_algorithm(3, param=params)\n", + " module = pyqasm.loads(program)\n", + " module.unroll()\n", + " loaded_circuit = parse(pyqasm.dumps(module))\n", + " aer_sim = AerSimulator()\n", + " with Session(backend=aer_sim) as session:\n", + " sampler = Estimator(mode=session)\n", + " sampler.options.default_shots = 20000\n", + " pub = (loaded_circuit, cost_hamiltonian, [])\n", + " result = sampler.run([pub]).result()\n", + " cost = result[0].data.evs\n", + " objective_func_vals.append(cost)\n", + " return cost" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "df258b64", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "stdgates: subroutine qaoa_maxcut_cost_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "stdgates: subroutine qaoa_x_mixer_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "stdgates: subroutine qaoa_layer_function_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n", - "stdgates: subroutine qaoa_maxcut_cost_3 is not part of visible scope, make sure that this isn't a floating reference / malformed statement, or is at least previously defined within untracked environment definitions\n" + " message: Return from COBYLA because the trust region radius reaches its lower bound.\n", + " success: True\n", + " status: 0\n", + " fun: -3.2509\n", + " x: [ 2.869e+00 2.624e+00 1.241e+00 3.187e+00 4.219e+00\n", + " 3.169e+00]\n", + " nfev: 41\n", + " maxcv: 0.0\n" ] - }, + } + ], + "source": [ + "initial_gamma = np.pi\n", + "initial_beta = np.pi / 2\n", + "init_params = [initial_beta, initial_beta, initial_beta, initial_gamma, initial_gamma, initial_gamma]\n", + "result = minimize(\n", + " cost_function,\n", + " init_params,\n", + " method=\"COBYLA\",\n", + " tol=1e-2,\n", + " )\n", + "print(result)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e8596cb2", + "metadata": {}, + "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "'mixer_name, cost_name = qaoa_maxcut(builder=builder, graph=graph)\\nprint(mixer_name)\\nprint(cost_name)\\nlayer_name = layer(builder=builder, cost_ham=cost_name, mixer_ham=mixer_name)\\nprint(cost_function(builder=builder, depth=2, layer=layer_name, params=[[0.5, 0.5], [0.5, 0.5]]))\\n\\ngenerate_algorithm(builder=builder, layer=layer_name, cost_ham=cost_name, depth=2)'" + "
" ] }, - "execution_count": 9, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "edges = [(0, 1), (1, 2), (2, 0), (2, 3)]\n", - "graph = nx.Graph(edges)\n", - "algo = QAOA(3)\n", - "algo.setup_maxcut(graph=graph)\n", - "module = algo.generate_algorithm(algo.cost_hamiltonian, 2)\n", - "'''mixer_name, cost_name = qaoa_maxcut(builder=builder, graph=graph)\n", - "print(mixer_name)\n", - "print(cost_name)\n", - "layer_name = layer(builder=builder, cost_ham=cost_name, mixer_ham=mixer_name)\n", - "print(cost_function(builder=builder, depth=2, layer=layer_name, params=[[0.5, 0.5], [0.5, 0.5]]))\n", - "\n", - "generate_algorithm(builder=builder, layer=layer_name, cost_ham=cost_name, depth=2)'''" + "plt.figure(figsize=(12, 6))\n", + "plt.plot(objective_func_vals)\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "f9157c73", + "execution_count": 9, + "id": "103981ed", "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "OPENQASM 3;\n", - "include \"stdgates.inc\";\n", - "qubit[7] qb;\n", - "bit[6] cb;\n", - "def qaoa_maxcut_cost_3(qubit[3] qubits,float gamma) {\n", - "\tcnot qb[0],qb[1];\n", - "\trz(2 * gamma) qb[1];\n", - "\tcnot qb[0],qb[1];\n", - "\tcnot qb[0],qb[2];\n", - "\trz(2 * gamma) qb[2];\n", - "\tcnot qb[0],qb[2];\n", - "\tcnot qb[1],qb[2];\n", - "\trz(2 * gamma) qb[2];\n", - "\tcnot qb[1],qb[2];\n", - "\tcnot qb[2],qb[3];\n", - "\trz(2 * gamma) qb[3];\n", - "\tcnot qb[2],qb[3];\n", - "}\n", - "def qaoa_x_mixer_3(qubit[3] qubits,float alpha) {\n", - "\trx(-2 * alpha) qb[0];\n", - "\trx(-2 * alpha) qb[1];\n", - "\trx(-2 * alpha) qb[2];\n", - "}\n", - "def qaoa_layer_function_3(qubit[3] qubits,float gamma,float alpha) {\n", - "\tqaoa_maxcut_cost_3(qubits, gamma);\n", - "\tqaoa_x_mixer_3(qubits, alpha);\n", - "}\n", - "input float gamma_0;\n", - "input float alpha_0;\n", - "input float gamma_1;\n", - "input float alpha_1;\n", - "int measure_0;\n", - "output float expval;\n", - "for int i in [0:9999] {\n", - "\treset qb[0];\n", - "\treset qb[1];\n", - "\treset qb[2];\n", - "\treset qb[3];\n", - "\treset qb[4];\n", - "\treset qb[5];\n", - "\treset qb[6];\n", - "\th qb[0];\n", - "\th qb[1];\n", - "\th qb[2];\n", - "\th qb[3];\n", - "\th qb[4];\n", - "\th qb[5];\n", - "\th qb[6];\n", - "\tqaoa_layer_function_3(qb[0:3], gamma_0, alpha_0);\n", - "\tqaoa_layer_function_3(qb[3:6], gamma_0, alpha_0);\n", - "\tqaoa_layer_function_3(qb[0:3], gamma_1, alpha_1);\n", - "\tqaoa_layer_function_3(qb[3:6], gamma_1, alpha_1);\n", - "\tqaoa_maxcut_cost_3(qb[0:3], 1);\n", - "\th qb[6];\n", - "\tcswap qb[qb[6]],qb[qb[0], qb[3]];\n", - "\tcswap qb[qb[6]],qb[qb[1], qb[4]];\n", - "\tcswap qb[qb[6]],qb[qb[2], qb[5]];\n", - "\tcb[{0}] = measure qb[{6}];\n", - "\tif (cb[0] == 0){\n", - "\t\tmeasure_0 = measure_0 + 1;\n", - "\t}\n", - "}\n", - "expval = measure_0/10000;\n", - "expval = 2*(expval - 0.5);\n", - "expval = sqrt(expval);\n", - "expval = log(expval);\n", - "\n" + "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", + " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "program = module\n", - "\n", - "print(program)\n", - "\n", - "module = pyqasm.loads(program)" + "res_bin, res_int = cost_function_res(init_params)\n", + "plot_histogram(res_bin)" ] }, { "cell_type": "code", - "execution_count": 31, - "id": "d27b0782", + "execution_count": 10, + "id": "0d1cf38b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", + " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{9: 0.1756, 20: 0.1849, 11: 0.1806, 10: 0.0331, 18: 0.0266, 5: 0.0517, 22: 0.1818, 13: 0.0322, 21: 0.0282, 27: 0.0054, 14: 0.0025, 26: 0.0474, 0: 0.0019, 3: 0.0026, 24: 0.0044, 12: 0.0024, 1: 0.0056, 2: 0.0011, 23: 0.0005, 28: 0.0021, 31: 0.0033, 19: 0.003, 8: 0.0009, 17: 0.0024, 4: 0.0042, 7: 0.0063, 6: 0.0013, 16: 0.0008, 15: 0.0011, 30: 0.0042, 25: 0.0015, 29: 0.0004}\n" + ] + } + ], "source": [ - "import pennylane as qml\n", - "from qiskit_qasm3_import import parse\n", - "from qiskit import qasm3" + "res_bin, res_int = cost_function_res(result.x)\n", + "shots = 10000\n", + "final_distribution_bin = {key: val / shots for key, val in res_bin.items()}\n", + "final_distribution_int = {key: val / shots for key, val in res_int.items()}\n", + "print(final_distribution_int)" ] }, { "cell_type": "code", - "execution_count": 36, - "id": "5e8714c7", + "execution_count": 11, + "id": "ec6a816c", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "ERROR:pyqasm: Error at line 48, column 1 in QASM file\n", - "\n", - " >>>>>> qaoa_layer_function_3(qb[0:3], gamma_0, alpha_0)\n", - "\n" - ] - }, - { - "ename": "ValidationError", - "evalue": "Undefined variable 'gamma_0' used for function call 'qaoa_layer_function_3'\n\nUsage: qaoa_layer_function_3 ( qubit[3] qubits , float gamma , float alpha )\n", - "output_type": "error", - "traceback": [ - "\u001b[31m---------------------------------------------------------------------------\u001b[39m", - "\u001b[31mValidationError\u001b[39m Traceback (most recent call last)", - "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[36]\u001b[39m\u001b[32m, line 72\u001b[39m\n\u001b[32m 70\u001b[39m module = pyqasm.loads(program)\n\u001b[32m 71\u001b[39m \u001b[38;5;66;03m#loaded_circuit = qml.from_qasm(module.unroll())\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m72\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[43mmodule\u001b[49m\u001b[43m.\u001b[49m\u001b[43munroll\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m)\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\modules\\base.py:60\u001b[39m, in \u001b[36mtrack_user_operation..wrapper\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 57\u001b[39m log_message = \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mrebase(\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtarget_basis_set\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m)\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 59\u001b[39m \u001b[38;5;28mself\u001b[39m._user_operations.append(log_message)\n\u001b[32m---> \u001b[39m\u001b[32m60\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\modules\\base.py:624\u001b[39m, in \u001b[36mQasmModule.unroll\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m 622\u001b[39m \u001b[38;5;28mself\u001b[39m.num_qubits, \u001b[38;5;28mself\u001b[39m.num_clbits = -\u001b[32m1\u001b[39m, -\u001b[32m1\u001b[39m\n\u001b[32m 623\u001b[39m \u001b[38;5;28mself\u001b[39m._unrolled_ast = Program(statements=[], version=\u001b[38;5;28mself\u001b[39m.original_program.version)\n\u001b[32m--> \u001b[39m\u001b[32m624\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m err\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\modules\\base.py:619\u001b[39m, in \u001b[36mQasmModule.unroll\u001b[39m\u001b[34m(self, **kwargs)\u001b[39m\n\u001b[32m 617\u001b[39m \u001b[38;5;28mself\u001b[39m._consolidate_qubits = consolidate_qbts\n\u001b[32m 618\u001b[39m visitor = QasmVisitor(module=\u001b[38;5;28mself\u001b[39m, scope_manager=ScopeManager(), **kwargs)\n\u001b[32m--> \u001b[39m\u001b[32m619\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43maccept\u001b[49m\u001b[43m(\u001b[49m\u001b[43mvisitor\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 620\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m (ValidationError, UnrollError) \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m 621\u001b[39m \u001b[38;5;66;03m# reset the unrolled ast and qasm\u001b[39;00m\n\u001b[32m 622\u001b[39m \u001b[38;5;28mself\u001b[39m.num_qubits, \u001b[38;5;28mself\u001b[39m.num_clbits = -\u001b[32m1\u001b[39m, -\u001b[32m1\u001b[39m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\modules\\qasm3.py:51\u001b[39m, in \u001b[36mQasm3Module.accept\u001b[39m\u001b[34m(self, visitor)\u001b[39m\n\u001b[32m 45\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34maccept\u001b[39m(\u001b[38;5;28mself\u001b[39m, visitor):\n\u001b[32m 46\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\"\"\"Accept a visitor for the module\u001b[39;00m\n\u001b[32m 47\u001b[39m \n\u001b[32m 48\u001b[39m \u001b[33;03m Args:\u001b[39;00m\n\u001b[32m 49\u001b[39m \u001b[33;03m visitor (QasmVisitor): The visitor to accept\u001b[39;00m\n\u001b[32m 50\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m51\u001b[39m unrolled_stmt_list = \u001b[43mvisitor\u001b[49m\u001b[43m.\u001b[49m\u001b[43mvisit_basic_block\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_statements\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 52\u001b[39m final_stmt_list = visitor.finalize(unrolled_stmt_list)\n\u001b[32m 54\u001b[39m \u001b[38;5;28mself\u001b[39m._unrolled_ast.statements = final_stmt_list\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3140\u001b[39m, in \u001b[36mQasmVisitor.visit_basic_block\u001b[39m\u001b[34m(self, stmt_list)\u001b[39m\n\u001b[32m 3138\u001b[39m result = []\n\u001b[32m 3139\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m stmt \u001b[38;5;129;01min\u001b[39;00m stmt_list:\n\u001b[32m-> \u001b[39m\u001b[32m3140\u001b[39m result.extend(\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvisit_statement\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstmt\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[32m 3141\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3120\u001b[39m, in \u001b[36mQasmVisitor.visit_statement\u001b[39m\u001b[34m(self, statement)\u001b[39m\n\u001b[32m 3118\u001b[39m result.extend(ret_stmts)\n\u001b[32m 3119\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m-> \u001b[39m\u001b[32m3120\u001b[39m result.extend(\u001b[43mvisitor_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstatement\u001b[49m\u001b[43m)\u001b[49m) \u001b[38;5;66;03m# type: ignore[operator]\u001b[39;00m\n\u001b[32m 3121\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 3122\u001b[39m raise_qasm3_error(\n\u001b[32m 3123\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mUnsupported statement of type \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mtype\u001b[39m(statement)\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m,\n\u001b[32m 3124\u001b[39m error_node=statement,\n\u001b[32m 3125\u001b[39m span=statement.span,\n\u001b[32m 3126\u001b[39m )\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:2216\u001b[39m, in \u001b[36mQasmVisitor._visit_forin_loop\u001b[39m\u001b[34m(self, statement)\u001b[39m\n\u001b[32m 2214\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m statement_block != statement.block:\n\u001b[32m 2215\u001b[39m statement_block = copy.deepcopy(statement.block)\n\u001b[32m-> \u001b[39m\u001b[32m2216\u001b[39m result.extend(\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvisit_basic_block\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstatement_block\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[32m 2217\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 2218\u001b[39m result.extend(\u001b[38;5;28mself\u001b[39m.visit_basic_block(statement.block))\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3140\u001b[39m, in \u001b[36mQasmVisitor.visit_basic_block\u001b[39m\u001b[34m(self, stmt_list)\u001b[39m\n\u001b[32m 3138\u001b[39m result = []\n\u001b[32m 3139\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m stmt \u001b[38;5;129;01min\u001b[39;00m stmt_list:\n\u001b[32m-> \u001b[39m\u001b[32m3140\u001b[39m result.extend(\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mvisit_statement\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstmt\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[32m 3141\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3117\u001b[39m, in \u001b[36mQasmVisitor.visit_statement\u001b[39m\u001b[34m(self, statement)\u001b[39m\n\u001b[32m 3114\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m visitor_function:\n\u001b[32m 3115\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(statement, qasm3_ast.ExpressionStatement):\n\u001b[32m 3116\u001b[39m \u001b[38;5;66;03m# these return a tuple of return value and list of statements\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m3117\u001b[39m _, ret_stmts = \u001b[43mvisitor_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstatement\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# type: ignore[operator]\u001b[39;00m\n\u001b[32m 3118\u001b[39m result.extend(ret_stmts)\n\u001b[32m 3119\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:3102\u001b[39m, in \u001b[36mQasmVisitor.visit_statement..\u001b[39m\u001b[34m(x)\u001b[39m\n\u001b[32m 3081\u001b[39m logger.debug(\u001b[33m\"\u001b[39m\u001b[33mVisiting statement \u001b[39m\u001b[33m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m'\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28mstr\u001b[39m(statement))\n\u001b[32m 3082\u001b[39m result = []\n\u001b[32m 3083\u001b[39m visit_map = {\n\u001b[32m 3084\u001b[39m qasm3_ast.Include: \u001b[38;5;28mself\u001b[39m._visit_include, \u001b[38;5;66;03m# No operation\u001b[39;00m\n\u001b[32m 3085\u001b[39m qasm3_ast.QuantumMeasurementStatement: \u001b[38;5;28mself\u001b[39m._visit_measurement,\n\u001b[32m 3086\u001b[39m qasm3_ast.QuantumReset: \u001b[38;5;28mself\u001b[39m._visit_reset,\n\u001b[32m 3087\u001b[39m qasm3_ast.QuantumBarrier: \u001b[38;5;28mself\u001b[39m._visit_barrier,\n\u001b[32m 3088\u001b[39m qasm3_ast.QubitDeclaration: \u001b[38;5;28mself\u001b[39m._visit_quantum_register,\n\u001b[32m 3089\u001b[39m qasm3_ast.QuantumGateDefinition: \u001b[38;5;28mself\u001b[39m._visit_gate_definition,\n\u001b[32m 3090\u001b[39m qasm3_ast.QuantumGate: \u001b[38;5;28mself\u001b[39m._visit_generic_gate_operation,\n\u001b[32m 3091\u001b[39m qasm3_ast.QuantumPhase: \u001b[38;5;28mself\u001b[39m._visit_generic_gate_operation,\n\u001b[32m 3092\u001b[39m qasm3_ast.ClassicalDeclaration: \u001b[38;5;28mself\u001b[39m._visit_classical_declaration,\n\u001b[32m 3093\u001b[39m qasm3_ast.ClassicalAssignment: \u001b[38;5;28mself\u001b[39m._visit_classical_assignment,\n\u001b[32m 3094\u001b[39m qasm3_ast.ConstantDeclaration: \u001b[38;5;28mself\u001b[39m._visit_constant_declaration,\n\u001b[32m 3095\u001b[39m qasm3_ast.BranchingStatement: \u001b[38;5;28mself\u001b[39m._visit_branching_statement,\n\u001b[32m 3096\u001b[39m qasm3_ast.ForInLoop: \u001b[38;5;28mself\u001b[39m._visit_forin_loop,\n\u001b[32m 3097\u001b[39m qasm3_ast.WhileLoop: \u001b[38;5;28mself\u001b[39m._visit_while_loop,\n\u001b[32m 3098\u001b[39m qasm3_ast.AliasStatement: \u001b[38;5;28mself\u001b[39m._visit_alias_statement,\n\u001b[32m 3099\u001b[39m qasm3_ast.SwitchStatement: \u001b[38;5;28mself\u001b[39m._visit_switch_statement,\n\u001b[32m 3100\u001b[39m qasm3_ast.SubroutineDefinition: \u001b[38;5;28mself\u001b[39m._visit_subroutine_definition,\n\u001b[32m 3101\u001b[39m qasm3_ast.ExternDeclaration: \u001b[38;5;28mself\u001b[39m._visit_subroutine_definition,\n\u001b[32m-> \u001b[39m\u001b[32m3102\u001b[39m qasm3_ast.ExpressionStatement: \u001b[38;5;28;01mlambda\u001b[39;00m x: \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_visit_function_call\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m.\u001b[49m\u001b[43mexpression\u001b[49m\u001b[43m)\u001b[49m,\n\u001b[32m 3103\u001b[39m qasm3_ast.IODeclaration: \u001b[38;5;28;01mlambda\u001b[39;00m x: [],\n\u001b[32m 3104\u001b[39m qasm3_ast.BreakStatement: \u001b[38;5;28mself\u001b[39m._visit_break,\n\u001b[32m 3105\u001b[39m qasm3_ast.ContinueStatement: \u001b[38;5;28mself\u001b[39m._visit_continue,\n\u001b[32m 3106\u001b[39m qasm3_ast.DelayInstruction: \u001b[38;5;28mself\u001b[39m._visit_delay_statement,\n\u001b[32m 3107\u001b[39m qasm3_ast.Box: \u001b[38;5;28mself\u001b[39m._visit_box_statement,\n\u001b[32m 3108\u001b[39m qasm3_ast.CalibrationDefinition: \u001b[38;5;28mself\u001b[39m._visit_calibration_definition,\n\u001b[32m 3109\u001b[39m qasm3_ast.CalibrationStatement: \u001b[38;5;28mself\u001b[39m._visit_calibration_statement,\n\u001b[32m 3110\u001b[39m qasm3_ast.CalibrationGrammarDeclaration: \u001b[38;5;28mself\u001b[39m._visit_calibration_grammar_declaration,\n\u001b[32m 3111\u001b[39m }\n\u001b[32m 3113\u001b[39m visitor_function = visit_map.get(\u001b[38;5;28mtype\u001b[39m(statement))\n\u001b[32m 3114\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m visitor_function:\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\visitor.py:2331\u001b[39m, in \u001b[36mQasmVisitor._visit_function_call\u001b[39m\u001b[34m(self, statement)\u001b[39m\n\u001b[32m 2328\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m actual_arg, formal_arg \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(statement.arguments, subroutine_def.arguments):\n\u001b[32m 2329\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(formal_arg, (qasm3_ast.ClassicalArgument, qasm3_ast.ExternArgument)):\n\u001b[32m 2330\u001b[39m classical_vars.append(\n\u001b[32m-> \u001b[39m\u001b[32m2331\u001b[39m \u001b[43mQasm3SubroutineProcessor\u001b[49m\u001b[43m.\u001b[49m\u001b[43mprocess_classical_arg\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 2332\u001b[39m \u001b[43m \u001b[49m\u001b[43mformal_arg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mactual_arg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfn_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mstatement\u001b[49m\n\u001b[32m 2333\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 2334\u001b[39m )\n\u001b[32m 2335\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 2336\u001b[39m quantum_vars.append(\n\u001b[32m 2337\u001b[39m Qasm3SubroutineProcessor.process_quantum_arg(\n\u001b[32m 2338\u001b[39m formal_arg,\n\u001b[32m (...)\u001b[39m\u001b[32m 2346\u001b[39m )\n\u001b[32m 2347\u001b[39m )\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\subroutines.py:144\u001b[39m, in \u001b[36mQasm3SubroutineProcessor.process_classical_arg\u001b[39m\u001b[34m(cls, formal_arg, actual_arg, fn_name, fn_call)\u001b[39m\n\u001b[32m 140\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(formal_arg.type, ArrayReferenceType):\n\u001b[32m 141\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mcls\u001b[39m._process_classical_arg_by_reference(\n\u001b[32m 142\u001b[39m formal_arg, actual_arg, actual_arg_name, fn_name, fn_call\n\u001b[32m 143\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m144\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_process_classical_arg_by_value\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 145\u001b[39m \u001b[43m \u001b[49m\u001b[43mformal_arg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mactual_arg\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mactual_arg_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfn_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfn_call\u001b[49m\n\u001b[32m 146\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\subroutines.py:190\u001b[39m, in \u001b[36mQasm3SubroutineProcessor._process_classical_arg_by_value\u001b[39m\u001b[34m(cls, formal_arg, actual_arg, actual_arg_name, fn_name, fn_call)\u001b[39m\n\u001b[32m 187\u001b[39m \u001b[38;5;66;03m# 2. as we have pushed the scope for fn, we need to check in parent\u001b[39;00m\n\u001b[32m 188\u001b[39m \u001b[38;5;66;03m# scope for argument validation\u001b[39;00m\n\u001b[32m 189\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mcls\u001b[39m.visitor_obj._scope_manager.check_in_scope(actual_arg_name):\n\u001b[32m--> \u001b[39m\u001b[32m190\u001b[39m \u001b[43mraise_qasm3_error\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 191\u001b[39m \u001b[43m \u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mUndefined variable \u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mactual_arg_name\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[33;43m used\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\n\u001b[32m 192\u001b[39m \u001b[43m \u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43m for function call \u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mfn_name\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m'\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m\"\u001b[39;49m\n\u001b[32m 193\u001b[39m \u001b[43m \u001b[49m\u001b[33;43mf\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43mUsage: \u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mfn_name\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m ( \u001b[39;49m\u001b[38;5;132;43;01m{\u001b[39;49;00m\u001b[43mformal_args_desc\u001b[49m\u001b[38;5;132;43;01m}\u001b[39;49;00m\u001b[33;43m )\u001b[39;49m\u001b[38;5;130;43;01m\\n\u001b[39;49;00m\u001b[33;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 194\u001b[39m \u001b[43m \u001b[49m\u001b[43merror_node\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfn_call\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 195\u001b[39m \u001b[43m \u001b[49m\u001b[43mspan\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfn_call\u001b[49m\u001b[43m.\u001b[49m\u001b[43mspan\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 196\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 198\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(formal_arg, ExternArgument):\n\u001b[32m 199\u001b[39m formal_arg_type = formal_arg.type\n", - "\u001b[36mFile \u001b[39m\u001b[32m~\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\pyqasm\\exceptions.py:137\u001b[39m, in \u001b[36mraise_qasm3_error\u001b[39m\u001b[34m(message, err_type, error_node, span, raised_from)\u001b[39m\n\u001b[32m 135\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m raised_from:\n\u001b[32m 136\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m err_type(message) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mraised_from\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m137\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m err_type(message)\n", - "\u001b[31mValidationError\u001b[39m: Undefined variable 'gamma_0' used for function call 'qaoa_layer_function_3'\n\nUsage: qaoa_layer_function_3 ( qubit[3] qubits , float gamma , float alpha )\n" + "Result bitstring: [0, 0, 1, 0, 1]\n" ] } ], "source": [ - "program = \"\"\"\n", - "OPENQASM 3;\n", - "include \"stdgates.inc\";\n", - "input float gamma_0;\n", - "input float alpha_0;\n", - "input float gamma_1;\n", - "input float alpha_1;\n", - "qubit[7] qb;\n", - "bit[3] mid;\n", - "def qaoa_maxcut_cost_3(qubit[3] qubits,float gamma) {\n", - "\tcnot qb[0],qb[1];\n", - "\trz(2 * gamma) qb[1];\n", - "\tcnot qb[0],qb[1];\n", - "\tcnot qb[0],qb[2];\n", - "\trz(2 * gamma) qb[2];\n", - "\tcnot qb[0],qb[2];\n", - "\tcnot qb[1],qb[2];\n", - "\trz(2 * gamma) qb[2];\n", - "\tcnot qb[1],qb[2];\n", - "\tcnot qb[2],qb[3];\n", - "\trz(2 * gamma) qb[3];\n", - "\tcnot qb[2],qb[3];\n", - "}\n", - "def qaoa_x_mixer_3(qubit[3] qubits,float alpha) {\n", - "\trx(-2 * alpha) qb[0];\n", - "\trx(-2 * alpha) qb[1];\n", - "\trx(-2 * alpha) qb[2];\n", - "}\n", - "def qaoa_layer_function_3(qubit[3] qubits,float gamma,float alpha) {\n", - "\tqaoa_maxcut_cost_3(qubits, gamma);\n", - "\tqaoa_x_mixer_3(qubits, alpha);\n", - "}\n", - "for int i in [0:9999] {\n", - "\treset qb[0];\n", - "\treset qb[1];\n", - "\treset qb[2];\n", - "\treset qb[3];\n", - "\treset qb[4];\n", - "\treset qb[5];\n", - "\treset qb[6];\n", - "\th qb[0];\n", - "\th qb[1];\n", - "\th qb[2];\n", - "\th qb[3];\n", - "\th qb[4];\n", - "\th qb[5];\n", - "\th qb[6];\n", - "\tqaoa_layer_function_3(qb[0:3], gamma_0, alpha_0);\n", - "\tqaoa_layer_function_3(qb[3:6], gamma_0, alpha_0);\n", - "\tqaoa_layer_function_3(qb[0:3], gamma_1, alpha_1);\n", - "\tqaoa_layer_function_3(qb[3:6], gamma_1, alpha_1);\n", - "\tqaoa_maxcut_cost_3(qb[0:3], 1);\n", - "\th qb[6];\n", - "\tcswap qb[qb[6]],qb[qb[0], qb[3]];\n", - "\tcswap qb[qb[6]],qb[qb[1], qb[4]];\n", - "\tcswap qb[qb[6]],qb[qb[2], qb[5]];\n", - "\tmeasure qb[{6}] -> mid[0];\n", - "\tif (mid[0] == 0){\n", - "\t\tmeasure_0 = measure_0 + 1;\n", - "\t}\n", - "}\n", - "out = measure_0/10000;\n", - "out = 2*(out - 0.5);\n", - "out = sqrt(out);\n", - "out = log(out);\n", - "\n", - "\"\"\"\n", - "\n", - "\n", - "module = pyqasm.loads(program)\n", - "#loaded_circuit = qml.from_qasm(module.unroll())\n", - "print(module.unroll())" + "def to_bitstring(integer, num_bits):\n", + " result = np.binary_repr(integer, width=num_bits)\n", + " return [int(digit) for digit in result]\n", + " \n", + " \n", + "keys = list(final_distribution_int.keys())\n", + "values = list(final_distribution_int.values())\n", + "most_likely = keys[np.argmax(np.abs(values))]\n", + "most_likely_bitstring = to_bitstring(most_likely, len(graph))\n", + "most_likely_bitstring.reverse()\n", + " \n", + "print(\"Result bitstring:\", most_likely_bitstring)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "df258b64", + "execution_count": 12, + "id": "a6c223b0", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA60AAAI+CAYAAABXIOyGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbARJREFUeJzt3Qm8TeX+x/GfISRTCJFLNCcUkSYNbqTJTZIGkqv6X6rLzS1doelPkzQot25Ut5Q0p/5KRBMpkiKKEjdzQpF5/1/f5/Va+6697XPOPvvstffa2+f9em3OWXudZ83Pen7rGVapSCQSMQAAAAAAQqh0tlcAAAAAAICCELQCAAAAAEKLoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgCQRqVKlbKhQ4dmdJmnnXaa+2Rj+/Szpq1bty4jy2/YsKFdeeWVGVkWACAcCFoBADnjqaeecgGS9ylbtqzVq1fPBTE//fSThdEnn3ziArsNGzYkNb+2xb+NlSpVskaNGtlFF11kL7/8su3evTsr65VJYV43AEDmlc3CMgEAKJHbb7/dDj74YNu6davNnDnTBbMfffSRff3111ahQgULWwB22223uWC0WrVqSf1N+fLl7V//+pf7+ffff7cff/zR3nzzTRe4qkb19ddftypVqkTnf/fddzOyXt766GFBkApbt0WLFlnp0jxzB4C9CUErACDnnH322dayZUv385///GerWbOm3X333fbGG2/YxRdfbLlOQeHll18eM+3OO++04cOH28CBA6137942fvz46HflypULdH1Uu7t9+3b3QCDbDwUU0AMA9i48qgQA5LxTTjnF/b9kyZKY6QsXLnS1k9WrV3fBlgJdBbZ+O3bscLV6hx56qJunRo0advLJJ9vkyZOL7DOqmkD1sSyImrgOGDDA/ayaYa/J79KlS1PazptvvtnOOussmzBhgn377beFrt/DDz9sRx99tFWsWNH2339/t+3jxo1Lar30c9++fe25555zaShQnDRpUqF9dtWnVQ8MVAOsfXjDDTe4mnCP0tbfqlY8nj/NotYtUZ/W77//3rp06eKOs7b3hBNOsLfeeitmnmnTprl0XnzxRbvrrrvsoIMOcsf7zDPPtMWLFxfzSAAAMomaVgBAzvMCGgVnnvnz59tJJ53k+rwq2Ntvv/1cwNKpUyfXN/RPf/pTNEgaNmyYq7Ft1aqVbdq0yT7//HObM2eO/fGPfyzRel144YUuuHz++eftgQcecDXCcsABB6Sc5hVXXOGaAyuoPuywwxLO88QTT9j111/vAnYveJw3b559+umndumllya1XlOnTnX7S8Grvi8sOBcFrJpH+1JNth966CH75Zdf7Jlnngl0n61evdpOPPFE27Jli9tmBcxPP/20nX/++fbSSy9Fj7NHtdVqXnzjjTfaxo0b7Z577rHLLrvM7RsAQDgRtAIAco6CDdXsKRhTsKGaUtUGnnvuudF5FKz94Q9/sM8++yzapPQvf/mLq0W96aabosGMauQ6duxojz/+eNrXs2nTpnbccce5AEzBclGBXzKaNGmSsFbZT9ukGlLVyKa6Xuo7+tVXX9lRRx2V1HqpVlR9baVPnz6uxvXRRx91waGWF9Q+UxCqwPXDDz90x1bUfFrp9O/f3y644IKYPrA6Z+bOnRttUq0HHTpX1B/a27cAgHCheTAAIOe0a9fO1bzVr1/f1SaqFlXNftXkU9avX+9qClX79+uvv7oAV5+ff/7Z2rdvb9999110tGEN9KNaWU3LBRpNWLRdBdE2/ec//3EBe6ratm2bdMDqBap+1113nfv/7bfftiApfdWQewGrt4+uvvpqVwO/YMGCmPl79uwZ0wfYa1quJsYAgHAiaAUA5JxRo0a55rFq/qlaUgWk/gF61EcxEonYrbfe6oJb/2fIkCFunjVr1kRHItarVdTU9phjjnH9KdWUNqx+++0393/lypULnEc1yQrcFMypr64Cyo8//rhYy1HNaXFoOX6NGzd2NZyp9t9NlkZWPvzww/eYfuSRR0a/91Ptu5/XpFxNmQEA4UTzYABAzlEw5o0erCakqmVTX001aVWw5r3LVE1TVbOayCGHHOL+P/XUU11TWzVtVV9RvWpGfSlHjx7t+rmKBvBREBxv165dlmlqxupf/0QUsGlfTJw40Q2gpD68aqo7ePBg15Q6Gfvuu2+J1lP7rLDfs7UPy5Qpk3B6ouMLAAgHaloBADlNQYgG/1mxYoU98sgjblqjRo3c//vss49rSpzo46+p1KizajaqfpTLly93/SH9I+SqNk61sfHia/ESKShYS9W///1vl2ZRg0SpyXTXrl1t7NixtmzZMjvnnHPcqLneiL7pXq/45tWq7dbDA69PqlejGb8fE+3D4qxbgwYNXIAeTyNHe98DAHIbQSsAIOfpdS+qfR05cqQLymrVquWm/fOf/7SVK1fuMf/atWujP6ufq59qalWLuW3btpimrgqC/H/35ZdfJtXkVsGjJAp6i0uDDqk2WMFofHNcv/htUh9O9U9VbaJe8ZPu9fKabMe/csd7p65oYCaNBPzBBx/EzKca4HjFWTc1D581a5bNmDEjOm3z5s1uYC0FzMXplwsACCeaBwMA8oL6oupdnXoP6LXXXuuCKDUbVj9VjSar2leNMqvgRoMUKegUBTUKcFu0aOFqXPW6G/WV1atePFdddZWNGDHCNTXu1auX6w+r5sMaoVevyCmM0pV//OMfdskll7ja3/POOy8amCWyc+dOe/bZZ93PCsJVG6mBptTX9vTTTy9ypGO9y7VOnTrulT+1a9e2b775xtVCq7bVq2FOZb0K88MPP7jXzHTo0MHtY62/mmw3a9YsOo+aWyvw1v9q3q0A1v++2VT2mV5npBpyBcd65Y2OoV55o/VRs2j/yMEAgBwVAQAgR4wdO1YdDyOfffbZHt/t2rUr0rhxY/fZuXOnm7ZkyZJI9+7dI3Xq1Inss88+kXr16kXOPffcyEsvvRT9uzvvvDPSqlWrSLVq1SL77rtv5Igjjojcddddke3bt8ek/+yzz0YaNWoUKVeuXKR58+aRd955J9KjR49IgwYNYubT+g0ZMiRm2h133OGWXbp0aff9Dz/8UOA2Kk3N430qVqwYadiwYaRz585uvbWd8dq2bes+nn/+85+RU089NVKjRo1I+fLl3T4ZMGBAZOPGjUmtl37u06dPwvWL3z79rGkLFiyIXHTRRZHKlStH9t9//0jfvn0jv//+e8zfbtmyJdKrV69I1apV3XwXX3xxZM2aNcXaZ9rf2kd+Os5ato5hhQoV3PGcOHFizDzvv/++S2fChAkx05WupuvcAgCEUyn9k+3AGQAAAACARGgzAwAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0OI9rSnavXu3rVixwr3vrlSpUtleHQAAAADIGXqJza+//mp169Yt8p3aBK0pUsBav379bK8GAAAAAOSs5cuX20EHHVToPAStKVINq7eTq1Spku3VAQAAAICcsWnTJlcJ6MVVhSFoTZHXJFgBK0ErAAAAABRfMl0tGYgJAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChRdAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0Cqb7RVAbvp1/Vbb+tuOtKRVodI+Vrl6hbSkBQAAACC/ELQipYD1ucEzbdfO3WlJr0zZ0nbZ7ScQuAIAAADYA82DUWyqYU1XwCpKK121tgAAAADyC0ErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi1feACgQ7+MFAABAthG0AkiI9/ECAAAgDGgeDCAh3scLAACAMKCmFXnfLFVomgoAAADkJoJW5H2zVKFpKgAAAJCbaB6MvG+WKjRNBQAAAHITQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0Mp60Dpq1Chr2LChVahQwVq3bm2zZs0qcN758+db586d3fylSpWykSNH7jGP9138p0+fPtF5TjvttD2+v/baawPbRgAAAABADgat48ePt/79+9uQIUNszpw51qxZM2vfvr2tWbMm4fxbtmyxRo0a2fDhw61OnToJ5/nss89s5cqV0c/kyZPd9C5dusTM17t375j57rnnngC2EAAAAABQEmUti0aMGOGCx549e7rfR48ebW+99ZaNGTPGbr755j3mP/74491HEn0vBxxwQMzvCnAbN25sbdu2jZlesWLFAgPffPDr+q229bcdaUmrQqV9rHL1CmlJCwAAAAByImjdvn27zZ492wYOHBidVrp0aWvXrp3NmDEjbct49tlnXW2umgD7Pffcc+47Ba7nnXee3XrrrS6QLci2bdvcx7Np0yYLc8D63OCZtmvn7rSkV6Zsabvs9hMIXAEAAADsPUHrunXrbNeuXVa7du2Y6fp94cKFaVnGa6+9Zhs2bLArr7wyZvqll15qDRo0sLp169q8efPspptuskWLFtkrr7xSYFrDhg2z2267zXKBaljTFbCK0lKaBK0AAAAA9qrmwUF78skn7eyzz3bBqd/VV18d/fmYY46xAw880M4880xbsmSJa0qciGqEVWPrr2mtX79+gGsPAAAAAMha0FqzZk0rU6aMrV69Oma6fk9HX9Mff/zR3nvvvUJrTz0atVgWL15cYNBavnx59wEAAAAA7AWjB5crV85atGhhU6ZMiU7bvXu3+71NmzYlTn/s2LFWq1YtO+ecc4qcd+7cue5/1bgCAAAAAMIjq82D1dy2R48e1rJlS2vVqpV77+rmzZujowl3797d6tWr5/qTegMrLViwIPrzTz/95ALOSpUq2SGHHBIT/CpoVdply8ZuopoAjxs3zjp27Gg1atRwfVr79etnp556qjVt2jSj2w8AAAAACHHQ2rVrV1u7dq0NHjzYVq1aZc2bN7dJkyZFB2datmyZG1HYs2LFCjv22GOjv993333uo9fZTJs2LTpdzYL1t1dddVXCGl597wXI6pfauXNnGzRoUODbCwAAAADIsYGY+vbt6z6J+ANRadiwoUUikSLTPOusswqcT0Hq9OnTU1xbAAAAAMBe0acVAAAAAICiELQCAAAAAEKLoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChRdAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChRdAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoZT1oHTVqlDVs2NAqVKhgrVu3tlmzZhU47/z5861z585u/lKlStnIkSP3mGfo0KHuO//niCOOiJln69at1qdPH6tRo4ZVqlTJpbl69epAtg8AAAAAkKNB6/jx461///42ZMgQmzNnjjVr1szat29va9asSTj/li1brFGjRjZ8+HCrU6dOgekeffTRtnLlyujno48+ivm+X79+9uabb9qECRNs+vTptmLFCrvwwgvTvn0AAAAAgJIpa1k0YsQI6927t/Xs2dP9Pnr0aHvrrbdszJgxdvPNN+8x//HHH+8+kuh7T9myZQsMajdu3GhPPvmkjRs3zs444ww3bezYsXbkkUfazJkz7YQTTkj4d9u2bXMfz6ZNm4q5tQAAAACAnKlp3b59u82ePdvatWv335UpXdr9PmPGjBKl/d1331ndunVdrexll11my5Yti36nZe7YsSNmuWo+/Ic//KHQ5Q4bNsyqVq0a/dSvX79E6wgAAAAACHHQum7dOtu1a5fVrl07Zrp+X7VqVcrpql/sU089ZZMmTbLHHnvMfvjhBzvllFPs119/dd8r7XLlylm1atWKtdyBAwe6Wlrvs3z58pTXEQAAAACQA82Dg3D22WdHf27atKkLYhs0aGAvvvii9erVK+V0y5cv7z4AAAAAgL2gprVmzZpWpkyZPUbt1e+FDbJUXKpRPeyww2zx4sXud6WtpskbNmwIdLkAAAAAgBwOWtVEt0WLFjZlypTotN27d7vf27Rpk7bl/Pbbb7ZkyRI78MAD3e9a5j777BOz3EWLFrl+r+lcLgAAAAAgx5sH63U3PXr0sJYtW1qrVq3ce1c3b94cHU24e/fuVq9ePTcIkqiGdMGCBdGff/rpJ5s7d6571+ohhxzipt9444123nnnuSbBepWNXqejGt1u3bq57zWIkpoJa9nVq1e3KlWq2HXXXecC1oJGDgYAAAAA7IVBa9euXW3t2rU2ePBgNwhS8+bN3QBK3uBMqv3UiMIeBaHHHnts9Pf77rvPfdq2bWvTpk1z0/7zn/+4APXnn3+2Aw44wE4++WT3Khv97HnggQdcup07d3avsdG7YR999NGMbjsAAAAAIAcGYurbt6/7JOIFop6GDRtaJBIpNL0XXnihyGVWqFDBRo0a5T4AAAAAgPDKWp9WAAAAAACKQtAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChRdAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtLIetI4aNcoaNmxoFSpUsNatW9usWbMKnHf+/PnWuXNnN3+pUqVs5MiRe8wzbNgwO/74461y5cpWq1Yt69Spky1atChmntNOO839vf9z7bXXBrJ9AAAAAIAcDVrHjx9v/fv3tyFDhticOXOsWbNm1r59e1uzZk3C+bds2WKNGjWy4cOHW506dRLOM336dOvTp4/NnDnTJk+ebDt27LCzzjrLNm/eHDNf7969beXKldHPPffcE8g2AgAAAABSV9ayaMSIES547Nmzp/t99OjR9tZbb9mYMWPs5ptv3mN+1aDqI4m+l0mTJsX8/tRTT7ka19mzZ9upp54anV6xYsUCA18AAAAAwF5e07p9+3YXSLZr1+6/K1O6tPt9xowZaVvOxo0b3f/Vq1ePmf7cc89ZzZo1rUmTJjZw4EBXi1uYbdu22aZNm2I+AAAAAIA8rWldt26d7dq1y2rXrh0zXb8vXLgwLcvYvXu3/fWvf7WTTjrJBaeeSy+91Bo0aGB169a1efPm2U033eT6vb7yyisFpqW+srfddlta1gsAAAAAkAPNg4Omvq1ff/21ffTRRzHTr7766ujPxxxzjB144IF25pln2pIlS6xx48YJ01JtrPrfelTTWr9+/QDXHgAAAACQtaBVTXPLlCljq1evjpmu39PR17Rv3742ceJE++CDD+yggw4qdF6NWiyLFy8uMGgtX768+wAAAAAA9oI+reXKlbMWLVrYlClTYprz6vc2bdqknG4kEnEB66uvvmpTp061gw8+uMi/mTt3rvtfNa4AAAAAgPDIavNgNbft0aOHtWzZ0lq1auXeu6pX03ijCXfv3t3q1avn+pN6gzctWLAg+vNPP/3kAs5KlSrZIYccEm0SPG7cOHv99dfdu1pXrVrlpletWtX23Xdf1wRY33fs2NFq1Kjh+rT269fPjSzctGnTrO0LAAAAAEDIgtauXbva2rVrbfDgwS64bN68uXtljTc407Jly9yIwp4VK1bYscceG/39vvvuc5+2bdvatGnT3LTHHnvM/X/aaafFLGvs2LF25ZVXuhre9957Lxogq19q586dbdCgQRnaagAAAABAzgzEpKa8+iTiBaKehg0buua/hSnqewWp06dPT2FNAQAAAAB7TZ9WAAAAAACKQtAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChRdAKAAAAAMivoPX9999P/5oAAAAAAJCOoLVDhw7WuHFju/POO2358uWpJAEAAAAAQDBB608//WR9+/a1l156yRo1amTt27e3F1980bZv355KcgAAAAAApC9orVmzpvXr18/mzp1rn376qR122GH2l7/8xerWrWvXX3+9ffnll6kkCwAAAABAegdiOu6442zgwIGu5vW3336zMWPGWIsWLeyUU06x+fPnlzR5AAAAAMBeLOWgdceOHa55cMeOHa1Bgwb2zjvv2COPPGKrV6+2xYsXu2ldunRJ79oCAAAAAPYqZVP5o+uuu86ef/55i0QidsUVV9g999xjTZo0iX6/33772X333eeaCwMAAAAAkNGgdcGCBfbwww/bhRdeaOXLly+w3yuvxgEAAAAAZLx58JAhQ1zT3/iAdefOnfbBBx+4n8uWLWtt27Yt0coBAAAAAPZuKQWtp59+uq1fv36P6Rs3bnTfAQAAAACQtaBVfVlLlSq1x/Sff/7Z9WcFAAAAACDjfVrVh1UUsF555ZUxzYN37dpl8+bNsxNPPDEtKwYAAAAAQLGC1qpVq0ZrWitXrmz77rtv9Lty5crZCSecYL17907/WgIAAAAA9krFClrHjh3r/m/YsKHdeOONNAUGAAAAAITvlTcaPRgAAAAAgNAErccdd5xNmTLF9t9/fzv22GMTDsTkmTNnTrrWDwAAAACwF0s6aL3ggguiAy916tQpyHUCAAAAAKB4Qau/STDNgwEAAAAAoX1PKwAAAAAAoappVV/Wwvqx+q1fv74k6wQAAAAAQPGC1pEjRyY7KwAAAAAAmQ1ae/TokZ4lAgAAAACQ7qB106ZNVqVKlejPhfHmAwAAAAAgIwMxqU/rmjVr3M/VqlVzv8d/vOnFMWrUKGvYsKFVqFDBWrdubbNmzSpw3vnz51vnzp3d/OpfW1CT5aLS3Lp1q/Xp08dq1KhhlSpVcmmuXr26WOsNAAAAAAhRTevUqVOtevXq7uf3338/LQsfP3689e/f30aPHu2CSwWh7du3t0WLFlmtWrX2mH/Lli3WqFEj69Kli/Xr1y/lNPW3b731lk2YMMGqVq1qffv2tQsvvNA+/vjjtGwXAAAAACDDQWvbtm0T/lwSI0aMsN69e1vPnj3d7wo0FUyOGTPGbr755j3mP/74491HEn2fTJobN260J5980saNG2dnnHGGm2fs2LF25JFH2syZM+2EE05ImO62bdvcx1NUE2kAAAAAQBbf0/rLL7/YfffdZ7169XKf+++/v1ivutm+fbvNnj3b2rVr99+VKV3a/T5jxoyU1imZNPX9jh07YuY54ogj7A9/+EOhyx02bJirlfU+9evXT2kdAQAAAAABB60ffPCB6zP60EMPueBVH/188MEHu++SsW7dOtu1a5fVrl07Zrp+X7VqVSqrlVSa+r9cuXKu/21xljtw4EBXS+t9li9fntI6AgAAAAACaB7sp0GMunbtao899piVKVPGTVOw+Je//MV999VXX1m+KV++vPsAAAAAAEJe07p48WL729/+Fg1YRT9rACR9l4yaNWu6v4kftVe/16lTJ5XVSipN/a9mxBs2bEjbcgEAAAAAIQpajzvuOPvmm2/2mK5pzZo1SyoNNdFt0aKFTZkyJTpt9+7d7vc2bdqkslpJpanv99lnn5h5NLLwsmXLUl4uAAAAACDLzYPnzZsX/fn666+3G264wdWqeqPtauRdvR91+PDhSS9cNbM9evSwli1bWqtWrdzraTZv3hwd+bd79+5Wr149NwiSqIZ0wYIF0Z9/+uknmzt3rnvX6iGHHJJUmhpESQNHaT69wqdKlSp23XXXuYC1oJGDAQAAAAAhD1qbN29upUqVskgkEp3297//fY/5Lr30UtffNRmab+3atTZ48GA3CJKWMWnSpOhASqr91Oi/nhUrVtixxx4b/V2jF+ujV/BMmzYtqTTlgQcecOl27tzZvcZG73F99NFHk90VAAAAAICwBa0//PBDICvQt29f90nEC0Q9GrHYHzSnkqZUqFDB1QrrAwAAAADIg6C1QYMGwa4JAAAAAADpeOWNR/1L1YRX/Uv9zj///JIkCwAAAABA6kHr999/b3/605/c+1j9/Vz1s/fOVgAAAAAAsvLKG40cfPDBB9uaNWusYsWKNn/+fPvggw/ciL3x/VABAAAAAMhoTeuMGTNs6tSpVrNmTTcKrz4nn3yyezWNXofzxRdfpLxCAAAAAACUqKZVzX8rV67sflbgqlfReIM1LVq0KJUkAQAAAABIT01rkyZN7Msvv3RNhFu3bm333HOPlStXzh5//HFr1KhRKkkCAAAAAJCeoHXQoEG2efNm9/Ptt99u5557rp1yyilWo0YNGz9+fCpJAgAAAACQnqC1ffv20Z8POeQQW7hwoa1fv97233//6AjCAAAAAABk9T2tsnz5cvd//fr1S7wyAAAAAACUeCCmnTt32q233mpVq1a1hg0buo9+VrPhHTt2pJIkAAAAAADpqWm97rrr7JVXXnEDMLVp0yb6GpyhQ4fazz//bI899lgqyQIAAAAAUPKgddy4cfbCCy/Y2WefHZ3WtGlT10S4W7duBK0AAAAAgOw1Dy5fvrxrEhxPr8DRq28AAAAAAMha0Nq3b1+74447bNu2bdFp+vmuu+5y3wEAAAAAkNHmwRdeeGHM7++9954ddNBB1qxZM/f7l19+adu3b7czzzwzLSsGAAAAAEDSQatGB/br3LlzzO+88gYAAAAAkLWgdezYsWlfOAAAAAAAaR892LN27VpbtGiR+/nwww+3Aw44oCTJAQAAAABQ8oGYNm/ebFdddZUdeOCBduqpp7pP3bp1rVevXrZly5ZUkgQAAAAAID1Ba//+/W369On25ptv2oYNG9zn9ddfd9P+9re/pZIkAAAAAADpaR788ssv20svvWSnnXZadFrHjh1t3333tYsvvtgee+yxVJIFAAAAAKDkNa1qAly7du09pteqVYvmwQAAAACA7Aatbdq0sSFDhtjWrVuj037//Xe77bbb3HcAAAAAAGStefDIkSOtQ4cOdtBBB1mzZs3ctC+//NIqVKhg77zzTlpWDAAAAACAlILWY445xr777jt77rnnbOHChW5at27d7LLLLnP9WgEAAAAAyErQumPHDjviiCNs4sSJ1rt377SsBAAAAAAAaenTus8++8T0ZQUAAAAAIFQDMfXp08fuvvtu27lzZ/rXCAAAAACAkvRp/eyzz2zKlCn27rvvuv6t++23X8z3r7zySirJAgAAAABQ8qC1WrVq1rlz51T+FAAAAACAYILW3bt327333mvffvutbd++3c444wwbOnQoIwYDAAAAALLfp/Wuu+6yW265xSpVqmT16tWzhx56yPVvBQAAAAAg60HrM888Y48++qi988479tprr9mbb77p3tWqGlgAAAAAALIatC5btsw6duwY/b1du3ZWqlQpW7FiRdpXDAAAAACAYgWtesVNhQoV9nhv644dO9K9XgAAAAAAFG8gpkgkYldeeaWVL18+Om3r1q127bXXxrz2hlfeAAAAAAAyHrT26NFjj2mXX355WlYEAAAAAIASBa1jx44tzuwAAAAAAGSuTysAAAAAAJlE0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChFYqgddSoUdawYUOrUKGCtW7d2mbNmlXo/BMmTLAjjjjCzX/MMcfY22+/HfN9qVKlEn7uvffe6DxaXvz3w4cPD2wbAQAAAAA5GLSOHz/e+vfvb0OGDLE5c+ZYs2bNrH379rZmzZqE83/yySfWrVs369Wrl33xxRfWqVMn9/n666+j86xcuTLmM2bMGBeUdu7cOSat22+/PWa+6667LvDtBQAAAADkUNA6YsQI6927t/Xs2dOOOuooGz16tFWsWNEFmok8+OCD1qFDBxswYIAdeeSRdscdd9hxxx1njzzySHSeOnXqxHxef/11O/30061Ro0YxaVWuXDlmvv322y/w7QUAAAAA5EjQun37dps9e7a1a9fuvytUurT7fcaMGQn/RtP984tqZguaf/Xq1fbWW2+5mtl4ag5co0YNO/bYY13T4Z07dxa4rtu2bbNNmzbFfAAAAAAAwSprWbRu3TrbtWuX1a5dO2a6fl+4cGHCv1m1alXC+TU9kaefftrVqF544YUx06+//npXQ1u9enXX5HjgwIGuibBqfhMZNmyY3XbbbcXcQgAAAABAzgatmaBmxpdddpkbtMlP/Wg9TZs2tXLlytk111zjgtPy5cvvkY6CWv/fqKa1fv36Aa89AAAAAOzdshq01qxZ08qUKeOa8Prpd/UxTUTTk53/ww8/tEWLFrnBnoqiUYvVPHjp0qV2+OGH7/G9AtlEwSwAAAAAIE/7tKp2s0WLFjZlypTotN27d7vf27Rpk/BvNN0/v0yePDnh/E8++aRLXyMSF2Xu3LmuP22tWrVS2hYAAAAAQB42D1aT2x49eljLli2tVatWNnLkSNu8ebMbTVi6d+9u9erVc8125YYbbrC2bdva/fffb+ecc4698MIL9vnnn9vjjz8ek66a7+p9rpovngZt+vTTT92Iwurvqt/79etnl19+ue2///4Z2nIAAAAAQOiD1q5du9ratWtt8ODBbjCl5s2b26RJk6KDLS1btszVgHpOPPFEGzdunA0aNMhuueUWO/TQQ+21116zJk2axKSrYDYSibh3usZTM199P3ToUDcq8MEHH+yCVn+fVQAAAABA9mU9aJW+ffu6TyLTpk3bY1qXLl3cpzBXX321+ySiUYNnzpyZ4toCAAAAAPaKPq0AAAAAABSGoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChRdAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChRdAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBolc32CgBIzdChQ0OdHgAAAJA3Na2jRo2yhg0bWoUKFax169Y2a9asQuefMGGCHXHEEW7+Y445xt5+++2Y76+88korVapUzKdDhw4x86xfv94uu+wyq1KlilWrVs169eplv/32WyDbBwAAAADI0aB1/Pjx1r9/fxsyZIjNmTPHmjVrZu3bt7c1a9YknP+TTz6xbt26uSDziy++sE6dOrnP119/HTOfgtSVK1dGP88//3zM9wpY58+fb5MnT7aJEyfaBx98YFdffXWg2woAAAAAyLGgdcSIEda7d2/r2bOnHXXUUTZ69GirWLGijRkzJuH8Dz74oAtIBwwYYEceeaTdcccddtxxx9kjjzwSM1/58uWtTp060c/+++8f/e6bb76xSZMm2b/+9S9Xs3vyySfbww8/bC+88IKtWLEi4XK3bdtmmzZtivkAAAAAAPI4aN2+fbvNnj3b2rVr998VKl3a/T5jxoyEf6Pp/vlFNbPx80+bNs1q1aplhx9+uP3P//yP/fzzzzFpqElwy5Yto9OUppb96aefJlzusGHDrGrVqtFP/fr1U95uAAAAAEAOBK3r1q2zXbt2We3atWOm6/dVq1Yl/BtNL2p+1cQ+88wzNmXKFLv77rtt+vTpdvbZZ7tleWkooPUrW7asVa9evcDlDhw40DZu3Bj9LF++POXtBgAAAADsxaMHX3LJJdGfNVBT06ZNrXHjxq729cwzz0wpTTU31gcAAAAAsJfUtNasWdPKlCljq1evjpmu39UPNRFNL8780qhRI7esxYsXR9OIH+hp586dbkThwtIBAAAAAOxFQWu5cuWsRYsWrhmvZ/fu3e73Nm3aJPwbTffPLxoBuKD55T//+Y/r03rggQdG09iwYYPrT+uZOnWqW7YGZgIAAAAAhEPWRw/W626eeOIJe/rpp92ovho0afPmzW40YenevbvrT+q54YYb3Mi/999/vy1cuNCGDh1qn3/+ufXt29d9r3etamThmTNn2tKlS12Ae8EFF9ghhxziBmwSjTqsfq8atVjvhP3444/d36tZcd26dbO0JwAAAAAAoevT2rVrV1u7dq0NHjzYDYLUvHlzF5R6gy0tW7bMjerrOfHEE23cuHE2aNAgu+WWW+zQQw+11157zZo0aeK+V3PjefPmuSBYtakKQs866yz3ahx/n9TnnnvOBarq46r0O3fubA899FAW9gAAAAAAILRBqyh49GpK42nwpHhdunRxn0T23Xdfe+edd4pcpkYKVvALAHs7tVgJY1oAAAChaB4MAAAAAEBBCFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChRdAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtMpmewWAbBk6dGgo0wIAAADwX9S0AgAAAABCi5pWAFmT7hpqarwBAADyDzWtAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFpls70CABCUoUOHhjo9AAAAFI2aVgAAAABAaBG0AgAAAABCi6AVAAAAABBaoejTOmrUKLv33ntt1apV1qxZM3v44YetVatWBc4/YcIEu/XWW23p0qV26KGH2t13320dO3Z03+3YscMGDRpkb7/9tn3//fdWtWpVa9eunQ0fPtzq1q0bTaNhw4b2448/xqQ7bNgwu/nmmwPcUuxN6E8JAAAA5EFN6/jx461///42ZMgQmzNnjgta27dvb2vWrEk4/yeffGLdunWzXr162RdffGGdOnVyn6+//tp9v2XLFpeOglr9/8orr9iiRYvs/PPP3yOt22+/3VauXBn9XHfddYFvLwAAAAAgh4LWESNGWO/eva1nz5521FFH2ejRo61ixYo2ZsyYhPM/+OCD1qFDBxswYIAdeeSRdscdd9hxxx1njzzyiPteNauTJ0+2iy++2A4//HA74YQT3HezZ8+2ZcuWxaRVuXJlq1OnTvSz3377ZWSbAQAAAAA5ELRu377dBZNqvhtdodKl3e8zZsxI+Dea7p9fVDNb0PyyceNGK1WqlFWrVi1mupoM16hRw4499ljXPHnnzp0FprFt2zbbtGlTzAcAAAAAkMd9WtetW2e7du2y2rVrx0zX7wsXLkz4N+r3mmh+TU9k69atdtNNN7kmxVWqVIlOv/76610NbfXq1V2T44EDB7omwqr5TUT9XW+77bYUthIAAAAAkNMDMQVFgzKpmXAkErHHHnss5jv1o/U0bdrUypUrZ9dcc40LTsuXL79HWgpq/X+jmtb69esHvAUAAAAAsHfLatBas2ZNK1OmjK1evTpmun5XH9NEND2Z+b2AVSMET506NaaWNZHWrVu75sEakVh9YeMpkE0UzAIAAAAA8rRPq2o3W7RoYVOmTIlO2717t/u9TZs2Cf9G0/3ziwZe8s/vBazfffedvffee67falHmzp3r+tPWqlWrRNsEAAAAAMij5sFqctujRw9r2bKlezfryJEjbfPmzW40YenevbvVq1fPNduVG264wdq2bWv333+/nXPOOfbCCy/Y559/bo8//ng0YL3ooovc624mTpzo+sx6/V3Vf1WBsgZt+vTTT+300093Iwjr9379+tnll19u+++/fxb3BgAAAAAgVEFr165dbe3atTZ48GAXXDZv3twmTZoUHWxJr6lRDajnxBNPtHHjxtmgQYPslltusUMPPdRee+01a9Kkifv+p59+sjfeeMP9rLT83n//fTvttNNcM18Fu0OHDnWjAh988MEuaPX3WQUAAAAAZF/Wg1bp27ev+yQybdq0PaZ16dLFfRJp2LChG3ipMBo1eObMmSmuLQAAAABgr+jTCgAAAABAYQhaAQAAAAChRdAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKLoBUAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAABCi6AVAAAAABBaBK0AAAAAgNAiaAUAAAAAhBZBKwAAAAAgtAhaAQAAAAChRdAKAAAAAAgtglYAAAAAQGgRtAIAAAAAQougFQAAAAAQWgStAAAAAIDQImgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWAAAAAEBoEbQCAAAAAEKrbLZXAAAAAMgXQ4cODWVaQC6jphUAAAAAEFrUtAIAkOfSXVtD7Q8AIJMIWgGgBGgGBgAAECyaBwMAAAAAQouaVgAAikCNOpAfaCq/d+A45x9qWgEAAAAAoUXQCgAAAAAILZoHAwAA5EEzc5pEAshXBK0AEGIUQovGPgIAIL8RtAIAkGUE3uHAgFvZx7UAIBGCVgBAoAgEAABAzgeto0aNsnvvvddWrVplzZo1s4cffthatWpV4PwTJkywW2+91ZYuXWqHHnqo3X333daxY8fo95FIxIYMGWJPPPGEbdiwwU466SR77LHH3Lye9evX23XXXWdvvvmmlS5d2jp37mwPPvigVapUKfDtBQAAAFJBbXQ48EB2Lwtax48fb/3797fRo0db69atbeTIkda+fXtbtGiR1apVa4/5P/nkE+vWrZsNGzbMzj33XBs3bpx16tTJ5syZY02aNHHz3HPPPfbQQw/Z008/bQcffLALcJXmggULrEKFCm6eyy67zFauXGmTJ0+2HTt2WM+ePe3qq6926QEAgOKhALd34DgjHTiPkHNB64gRI6x3794uaBQFr2+99ZaNGTPGbr755j3mV21ohw4dbMCAAe73O+64wwWejzzyiPtb1bIq8B00aJBdcMEFbp5nnnnGateuba+99ppdcskl9s0339ikSZPss88+s5YtW7p5VLur2tr77rvP6tatu8dyt23b5j6ejRs3uv83bdpkYfPrr7/a79s3pznNTVZ+UyRn049fhviPZ0klOg/SmX6iZQSdftDHOR/2UT6cR+leRq6nn4ll5GN+ke5lJEpfD6vTaeDAgTl9nLkWUlsG+yjz11uuX2v5nOdlm7fdit+KFMmibdu2RcqUKRN59dVXY6Z37949cv755yf8m/r160ceeOCBmGmDBw+ONG3a1P28ZMkSbXXkiy++iJnn1FNPjVx//fXu5yeffDJSrVq1mO937Njh1uWVV15JuNwhQ4a4dPnw4cOHDx8+fPjw4cOHj6Xls3z58iLjxqzWtK5bt8527drlakH99PvChQsT/o36vSaaX9O9771phc0T3/S4bNmyVr169eg8iZ5OqBmzZ/fu3a5fbI0aNaxUqVKWa/Rko379+rZ8+XKrUqVKTi4j19PPxDLYhuynn4ll5Hr6mVhGrqefiWWwDdlPPxPLyPX0M7EMtiH76WdiGbmefqaWESTVsKplX6JWrqFrHpwrypcv7z5+1apVs1ynEzzokzzoZeR6+plYBtuQ/fQzsYxcTz8Ty8j19DOxDLYh++lnYhm5nn4mlsE2ZD/9TCwj19PP1DKCUrVq1aTmKx34mhSiZs2aVqZMGVu9enXMdP1ep06dhH+j6YXN7/1f1Dxr1qyJ+X7nzp2u5rSg5QIAAAAAMi+rQWu5cuWsRYsWNmXKlJhmt/q9TZs2Cf9G0/3ziwZi8ubXaMEKPP3zqOr8008/jc6j//UqnNmzZ0fnmTp1qlu2RjAGAAAAAIRD1psHq59ojx493Ci+ejerRv7dvHlzdDTh7t27W7169aIjaN1www3Wtm1bu//+++2cc86xF154wT7//HN7/PHH3ffqX/rXv/7V7rzzTvdeVu+VN2orrVfjyJFHHulGINaoxRpxWK+86du3rxtZOJk21flATZ31Ltv4Js+5tIxcTz8Ty2Absp9+JpaR6+lnYhm5nn4mlsE2ZD/9TCwj19PPxDLYhuynn4ll5Hr6mVpGWJTSaEzZXgm9rubee+91gyA1b97cvWPVq/E87bTTrGHDhvbUU09F558wYYJ7pc3SpUtdYKr3sup1NR5tkg6gAlnVqJ588sn26KOP2mGHHRadR02BFai++eabVrp0aevcubNbbqVKlTK89QAAAACAUAetAAAAAACErk8rAAAAAACFIWgFAAAAAIQWQSsAAAAAILQIWgEAAAAAoUXQCgAAAAAILYJWIM0YkBu5gPN078BxBpAs8guEGUEr8joT89Y9yG347bffbPXq1fb777/b7t27rVSpUu7/XJPJ45zuZWXiOGci/SDPG72z+vvvv7eVK1farl273Hmaa/tr586dtmPHDgtaLud5+ZAfbd261X799deYaUFsQyb3SxDnVCbWP8hrIVPHOahtyMT6B31vy4f8wlvfXL+eM3Hf2Z1jxzYeQSsSWrp0qY0fP942b94cWOFWheepU6fa9OnT7YcffohOT9eylixZYvfff7/9/PPPgW3DV199ZR06dLBTTjnFTj/9dLv++utty5YtVrp06bRlDkHup0wc5+XLl9uLL75oL7/8ss2aNctN07LSJRPHWcdUgkp/06ZN7v90njd+8+bNszPOOMPOPPNM9/8FF1xgq1atSutxCPo4L1iwwC655BJr166dXXrppfbSSy/Z9u3b05Z+PuR5QedHOsaffPKJe3gQlK+//tqdnyeffLLblvvuu88VqNN5bQR9vQV9Laxfvz7Q9c9EnpeJ47xt27bAtiET6x/0vS0T5Ze1a9e6+4/2l3fdSbq25dtvv7V+/frZihUrArsedG949NFH7bHHHrOJEyem/XoO+lrLRJ6XMREgzqJFiyKVK1eO1KtXL/Lvf/87snnzZjd99+7daVvGvHnzInXr1o00a9Yssu+++0ZatmwZGT58ePT7ki7r22+/jVSvXj1Sq1atyO233x75+eef05Ku3w8//BCpWbNm5Prrr4+8+uqrkVtuuSVy7LHHRg4//PDIqlWr3Dy7du0K7X7K1HHWMTj++OMjBxxwQKR+/fqR/v37py39TBznb775JnLBBRdEJkyYEJ2WzvQXLFgQadWqVeSBBx6ITivpeeO3fPnySJ06dSIDBgyIfPDBB5EnnngicuKJJ7ppM2bMyJnjXLVq1cjll18eueuuu9z6H3fccZE///nPkS1btpQ4/XzI84LOj3QdVKhQIdKwYcPIhx9+mNZz1LN48eLI/vvvH+ndu3fk8ccfj3Tr1s0d53bt2kV+/fVXN09Jlxv09Rb0taD1/8Mf/hC58cYbo9N27twZSaeg87xMHGdtw7XXXhv55JNP0r4NmVj/oO9tmSq/HHzwwZGjjz46UqZMmcg555wTGTNmTPT7km6LjsOBBx7ojsVVV10VWbFiRVrW2++rr75yx+Gkk06KHHrooe4+cdlll7n7ai5ca5nI8zKJoBUxfvnlF5exXHrppZFOnTpFjjrqqMjTTz+d1kKcMl9ljH/961/dzzNnzowMGTLEFeRuuOGG6HypLmvjxo2RP/3pT5FLLrkk8pe//MXdTIYOHZr2TF+ZjArP3r6R2bNnR9q0aeMKduvXry/R8oLcT5k4zjoOzZs3d+u6fft2FxjohlWpUiV3bH777bcSpx/0cf7+++8jjRs3jlSsWDFy7rnnRl577bXod+lIf+nSpe6GrgDylFNOiTzyyCNpv6lMmTLFBUpr1qyJTtPP2ncqVM+fP79Eywv6OMttt93m1tezY8eOyP333+8CPxUYf//99706zws6P9I6n3XWWZErrrjCFX4aNWrkHoCku+Dz2GOPRdq3bx9NV+v68ssvR1q0aBE54YQToudSqvsp6Ost6Gth2bJlLp/TuXTMMcdEBg4cmPbANeg8LxPHecmSJZGDDjooUqpUKfeg67PPPkvrNgS9/pm4twVdflm9enWkQYMGkX79+rnj8fbbb0d69uzpjosePHpSTV8PBy6++GL3ueOOO1xQ2aNHj7QGrjqOJ598cqRv377R++bUqVNd/nHaaae56zvs19rSDJQxMomgFTF0wd90000ug5GuXbvuUYgrKV2ouoi+/PLL6LRNmza5ZZQvX94tvyS0nnoy+dJLL7nf//73vxea6aeaOTz88MORatWqJXyq1bp1a5eJlqQwHeR+ysRxXrdunStYKWjymz59unsyeuWVV4b6OCswuvnmm10g8/rrr0fOPPNMV1Dx31hKkunrb7WuZ599duT//u//Ir169XIFnnTfVF544QVXQ7Zt27aYNHXT79Chg7tpluSYB32cpU+fPi5A9du6dWvk0UcfddfarbfemnKhPR/yvKDzIz3YUMFNgaqosBtE4KrjqFpEPx1XHRvVXCoAUTAY1ustyGtB+Zce1Gj933vvvcidd94ZOfLII9MauAad52XiOCtf0MMhXccvvviiO08V2KQzcA1y/TNVhgm6/PL5559HmjRpElMj+eOPP7rztkaNGu5cLqkRI0a4PFRGjRq1R+Ba0n2ke6buO2p946ftUKsZXYupHudMXGu7MlTGyCSCVsTQCaynuf4T2V+I85ri6YLTJxW64FXD8Nxzz+1xs/nnP//pmqw8//zzJdoOFQj9mZSaRirTV+2G9wRRGVJJbiwLFy50+2XkyJExhQX9PHHiRFe7NWnSpJTTD3I/ZeI4az+rSaf2j8c7Jtoverr44IMPprz+3hPpII/zp59+Gr0pfv3115EzzjhjjxtLSW6MaqLlNZfSE9Gibiqp3Hg3bNjgCrcqyHnnqZemtqlp06au5iBVmTjOatKswqCCPv8+0JNwbZeOuVeYS2UZKljlap7nrbeamQWVH+ka0rni30eqkYkPXLWskgROCsZUU6lCnH9Z2k8PPfSQ+85rGZCKoK+3IK8FWbt2beSZZ56JBsiqYYoPXEtaCA0yz/POjcmTJwd2nJXXv/HGG9FAQ60a0hW4ZmL9M1WGCbr8MnfuXJfnvfPOOzHT1fRYQb8CWtValpR/HykQV+DavXv3aOCqY+I9sC0uBe2qLfZfX97+Vn5bpUqVyD/+8Y+U1z3o8kWmyhiZRNCKPQqy3v/+C10ZvleIU3M6PSHyN2srDhUC1cxM7fjVXyC+SYmePKWadvwF58/Q1QfIe1q5cuVKt4zOnTsX+yL15ldNlTLHtm3bRt588809Mjs1g1GhItXt0Lqncz9l8jh7aevv9aRy2rRpMdumZV533XWuCZT2VbLHQDcg///e3/m3IV3HWeILBAqaEj0R9WqgiiPR+qgZlXdT0ZNjj56Sppq+9o0KOqod89+ovO1TkzY14UpFUMc5fr6ffvrJ9Te98MIL92i2pvNU/aW8Wol05Rdhz/PirwU9nNAyTj311LTkR/H7JtG15g9ctY1qxn3vvfcWazv8aevBg5rjqW9g/H7SAwo1s031AUvQ15tHtea6ptJ1LRQWjOrcSVTjqqafqT5giV+vdOR58fceNbNUcBHEcRavX6nn448/jgauqgH0tlPNYcO2/kGXYTJRfhGtn84btZLRz/EBs66RVPIK/zZ4/Oe6F7iqxlVBmvodq+ZYf1Oc/eQda90ztS/U/Dv+mNxzzz3uvqeHSWErXxQkiDwvkwha93JqCvI///M/rjClQpmXoSfKDFT7oKZPKlSoSZuepCVDBRE1j9PF4tETSvXLUab73XffxcyvaSoMJXvTVS1J/HoXdLPX00rV2Ogp33777Vfo3xW2DO8mpqd5uvhVUFRTJD9lPP5MIVn+p57aT0cccUSJ91MmjnOi9dcgGKeffnqkS5cuewz687//+7+uls8rdBdFT65V6NDTSKUX3wTPvw2pHmfvXNUAD/HnkHceaX94NxbdyDSQhZpZqeYj2RtXotoo72+1bO+mohuw0lffLD2hLip9rfv777+/x3K0bur7qfMlvqCgQFBBrX8dsnmcVaDRk3gVOlTD6hUKVUuiwqAGwfCeoosKDBpAJNmn9tqPhfVF8m9XWPO8+Gvh3XffjW6b0lHfpZLkR/HHQLUK4l0D/vXU8g477DDXJ6ts2bKuxiCV4+DtdxU0a9eu7QIC1UR4dP7oOPgHLElWUNebgkYNNuNfT/2s/m7puBa85Rd2Xmg9/YGrziWt/3/+859ISfaRv5BfkjzPf+9RQK+aT68GSMdZ6Zb0OKvFjfaDv7WFl2d756w/cNVx0X7Sta0HUtle/6DLMJkovyQ6BmpFotrIu+++O/qw0aP7UceOHZNuGRB/b4s/7/zp6DpWHqhgU8v3jlkq15vyao13oEA4Prh/8sknXZ6uWvGwlC9WJ8iTvG1LR56XbQStezGveYMKJnpa98c//tH1ffOaH8VncPpfI7VpJLVkC296cqRmJmpiob5zWobXx0FNFjSyom4I/kxFT8aS7ROiwpVuHMrENaJlQfzN1xQEqn+RLuxkFLQMb/1UOFABSwOUaF+qmZ8GT1AzMY0AmAxljHp66vWh82eaGp1Q/WdS3U+ZOM5ahtbHy7z966+RCfWkUzd9NTvylqFCgwbASWb0VxVutQ1XX32161unYEKZrJ4E+2+G/m0o7nGOP1d101CzTo8yc+880rzaj7qZaDTBZJ7Yx++jwgrSCnY0Mq6Ok7YhmYKJ9pH6Cqmpqf/m6h0L1Q5o+Wq6pmBHzcI0MIbW3wtKsn2cFYzputF5qpphpaeCh9fETIUWra/2vfIP7RcVJHV9+o9VUSOvquBaWHAV5jyvoGvBe/CgWg3lR8qvUsmPCjoGarqbqGCna0LNXnXuffHFF0nto4KOg7f93gAlKnhqu9QcU60BdBz0XTKCvt50Pmg0UY2OqvNP19VHH30UrbXQ/aAk14L2iwr1XlCVKHD11l8FVeWFOg+SXf9E951EAURJ87z4e48e/njNFXUsFUiW5Dgrf/f6WOucV54Wv6+8Y6/AVQ9YNCiNmq4WtQ2ZWP+gyzCZKL/EHwOl462vHtToYZbOT3+wpkGm1PIgmSCpoHtbQYGrjr+2R/soviY82evNnxdrv6mFhGpVx44dG304oXuPHlAoYM92+SJRnqRaea27f1BBbxmp5HlhQNC6F1PGpGZpHt34Bg0a5JraaYATf6agC1SFJJ3gyWYCKqips7pq9tRUSk8e1SREBSCvluzZZ591T+p1oamzuNZHNwn/gCUFUeFMT7T1BEx/q9EtC2tGoeZZerpUnG0oahlexqbaHtVgaT5lTGpyk2whVwUHDWuvTFmvRvAyGH+mqSaKqe6noI+zbkRquqm/0Y3dKyT61/+tt95y3ykTViFYQZN+TnYfqd+IMnE/BfMqpOn88g+Yk8pxLuhcVcFahXV/gdfbVwoWtA3JLKOgfVRYQVo1iio4JFNzpWOqQZV0furv1KxVNXserxCnm6ua0argrJvteeedl9Q5lInjrH2hwE3r71EQpGOpc9UrrKgAo21V4VOFJA1wNGfOnCLTVxNjFax0fapAo3QLO3ZhzPOKuha816DoAYWarhU3PyrqGHgBmFfwUTNC5S/aR8nWsBZ1HLzzSfMpbc2nY60CYzLHORPXm+4LOvf0mhAdN7UCUMFfBUXVvojyDbViUJrFvRYU8KjgqWOq88crSBfWX1iBggq4yfalLOi+kyhwTSXPK+zeU7p06WjfXo2toIc4qRxn1cprBPS//e1vrlZK57yuK9Wgxrdm8LZBwUeywUzQ6x90GSYT5ZeCjoHuQV5LE6WtEYm1LurCoI/yvGS2oah7W6Lm1HpwoH2UbJ5a0PXmv7fNmjXL1UiWK1fOrYPyLj2cSOZYB12+KCxP0kPXf/3rXzG1wankeWFB0LoX0w1VGWA8PRnTxasCqHeCqwCn92DFNzkojJrr6eL2N+XTxanMUzdLr6ZBmcFTTz3lmmCoQJbsTVcXpZpR6Ompnmwnk+krM0u2qUiyy4h/qqvAINl3R6ofmm6KF110kWv2o8KNBpZJFLgqc0xlPwV5nNUvRhmf1l81d2puotqFRAGNbu4a2EHbd99997knwMnS+/bOP//8PZrSqLZYBQgV2r1tSOU4F3auKtP3mvl5Nxftf+27ZG7sRe2jRAVR7R+ln2zNlc4FNc/UDVDniUYpLShw9ejYJDuIRyaOs9JQYUk3dj8FYCoUqhDiXXfqN6agRmknOwCTgkY93dYx03Wkp9CFBa5hzPOKuhZ0znh96fyDlSWbHyVzDPxNXlVQUv5SnH2UzHHwzlX9r2Ot/ZlsE7xMXG+qlTjkkEP2OLe9V3p4g2qpQF/ca0F5vwrHCrbHjx/v1l9NigsLXFXzp0As2WCpqPtOosC1OHlesvceL39SMKZlF+c4i4IkBYn+mi4FStoeNZdWwOPtM90bdF4XZxuCXv+gyzBBl1+KOgYKXhUQi8oZetWNlq+8JNlgLJl7W3zgquUkWztZ1PXm78OvvEjpDhs2zAWC8c18s1G+SCZPUnA8bty4mP1U3DwvLAha92JqFqSmair8iXdCq+CigpEyfX8H+uK2dVcfCT0p8vrv+C9+ZaTqC1DS9vP+i1qZopcp6xUD6RpNMZlleJlNKoNr6MmYXkui/aNh7pXZqxlZoqbCYTzOysA1UqP2gf4vLKBJlfrWqAmi11zJK4SImh3pPEv2BpLKuap95N8venKa7E03mX0UXxDV8SjuO+D8NyvdwFTzohulf0CHkpxLmTjOGrRDtZDx/Z8UCKtQoWuvqD5oBVGtoPre+gv6XsDkb2ZXktEaM5HnJXMtxNcypfMYqAmdv4CabP/M4h6HkoxCHPT1pmbqaqro1ST5W3qor55qXL3Ceir0EE6FTFGT46ICVy1LfSzTed+Jv28WN89L9t7jfZcKDZKj4+DfLlFwoBpD1Rz6KXhLtrtIJtY/E2WYIMsvyRwDnbt+/iaq6by3lSS/KOp68+5tqebdQZcvksmTFBz739WeShkjDAha92J6uqNmWuoX5T2R9DITPdVSc4aSPIXRE29l+CoEebyLVRm9mjKog76kq/O33pOmpiR6ku89TdSNuDi1bplahpfJKpDwtt8bgdMrQHhPPIv7vjT/TUG1ILp5p/s4JzpmOr6q8YkvJGr99XS/OPw3IfW70T5XgVm1F/4ATP3j/P0egzpX1eypuMFZomY/Qe2jeHoi7N3cvafSeqLsHwUxDNvgpyfd6huod/jF11ioVk7nqoKnVMWfs4lq+nT9FXfwMf+InDoX053nZfJaCPoYFOc4JNu8r6B0gzpXtRw1S/c3HfUH7yqEqr9eQetUnPXXsdd9Jr4grXuDmjUW93UexbnvFPeBRKbKGN56q0+gmoHrIYXHP/CSap4UmPv/Jgz3zsKCtnSUL4JOv7jHwGt5kGqeF9S9LZXrrTjBcXHuC6mUL1LNk0paEZJNBK17CdVCDR8+3D2J9w/Ao4KJCihqIuQfbVA/q2mHN7BEcS9S/a+LW/0+lL53QXoZmi4mjVinvjSpbEP8y579GYnXDEYZsy5gNYEoTl+ooJfhZSTxmZOXiel7FSCUaarJljJNFebUVKko/loo//pqm1QoDOI4xy9PGaL64HqFRI16d80117ibZDKZpb+Gwr8Nesel+mGqSZt/VFbvPaTxI/tl81zVDc77Wz/vmAe1j/zb5b+5q4+X0i7OeRr0NqhmSE+41czK/z5AFRDVN0z9rf1Nf9VMTAWgZJvSFpR+/D7zAiYNSqGBgdTcPNllxO8j7Xu9p1GFnXScR0FfC0Efg8KWkc7jEHSe5OcVyLWP1U9PheX4PFyDzOh1Iqnwr7+3LE1TzZhXkFYApWOkc8Bfo5Kt+06myhjx26Aaf62rBkLyaso8+k7nsJqKJiMT907/MuIDS/9xT7V8EXT6QR+DTN3bgr7egr4vZDpPChOC1r2Anlyrs7X6KmlkN41+p8zKayaj4fI1XYOyqIZBTcvU90OjnMW/X6sg+hv10/IuIC8j0FMkPV1Sp3PdEP2UWWr0tWSewCXaBg0m43866M/gdPGqj09xBvvJxDLU4V0DQaiDvDJaZYz+J+Ve+l4BQk+pdWPUqz7iX58QT7UsGkxAr6rw+AsogwcPdk/S03mc4/lHFlXBReuvJisamj+ZJ7naBvWb8/cj8m+DXr+hwRyU+etJt/aJmrmp6UuytT+ZOFfV5Ec3PD351MMPfxMyf0E6XfuosJu70tRTXp2rydZcBb0Nyns0AIzS10iKOr/VV8mrBdO26ZUOKgypMKyCzN///ndXAFLAkUr6Cobi+xR5NHjOPvvs467/ZGtO4veR9oMKjQocVcBRQbck51HQ10LQxyBTxyHoPElN6Lyaa/8x03FWvzDtD41S7KcCoqb585fipp9oO1QDpJo/jcaq9U+2L3GQ951MlTHit8F7D65q+nSf1rK9UX09WgcdI2//ZfPemWgZhQWWxS1fBJ1+0McgU/e2oK+3oO8LmciTwoygNc/piY8yF42C5zWJUsagp+W6MXk3bV1YevKmp1UqqCgzTvaplS4gDR+vv/Xeo+UfIEQFKBV2VGhRZqcnlxrgRDfEZF61Udg26AmV//2M3nJV0NJIisn2C8jEMtQHzXtVhZ7aqpbEe1WFf+hzL5PWU0o9RUxmaHvtYz3NVkFDx8+fKfoLJxquPd3HOZ6XIWrQAj2ZTHakRj251oh8ytTV7Er7KdE26FhohFMVjFSrpOH/w3KuqtZL26vgV+8/U3Mc/a5t8Q8p7y0vnfsoUbMlLUdPcIszAm7Q26CmUuoz6TVVUqFPT/41EqNu9l4zPJ3Denrvjeio11Qkc5wLS18FKH/fZ22D9pueTGv9kx1FMdE+UuFPAZnSV39QFULU7CuV8yjoayHoY5Cp4xB0nqQ8W9eO0vfeu+l/36FqoVUbrYKz3hWsAWY0CJT6HCezDQWlXxDdlxQcaB8mu4+CvO9kqoxR0DZoJF/VfKk2X7XzWm9dD3rIpj6n+puiXtuSiXtnYctIFFgWt3wRdPpBH4NM3duCvt6Cvi9kIk8KO4LWvYCeFHlNErymUKo10RN6fed1zlbGoCdJapKV7NNDPX3XyG66sDUSpi5Y79UO/mBAF6tqAzQAgIb+1+iXxemvVNg26Ome9x5EUQamPhbFfe9U0MtQ5q7t91OTEdVEKCPTi539N0vdVJTRFFVwUGalfnLq4/buu++6wogKrwXdfCXdxzme9p+2V5lrMk9xtQ2qZVFTNBU+VUDQYCb+G1d8M1Vl8jomyQ54kolzVU859ZDDT005dQ6paU78qz3SvY/imzrqBqeCY3GaTQW5DV5BQAUTr6+ZPwBRDZiOkUfBkwIdNcHzX38lSV9Ptf2FINXSqQCgkTZLuo9UYFMBQcGACnKpnEeZuBaCPgaZOA5B50mqHVHBXINPqfCp5srq7xtfSFTeqsKqaqm7dOmyxzWSavrxtK9UyNUrN4rTjzKo+06myhiFbYOCCb3mSfmQau/VBF3nnGp1Tz/99CKPcybuncksIz4o075PtnwRdPpBH4NM3dsycb0FeV/IRJ6UCwha85hOYBUcNBy5nnjFZ8LKdJXh6ElMqpT56WJUZqkmMxpeW4UH70X0uvATFSCS7Wye7Dao2YVfMi97zuQyRO8x8zJ9fwY8evRo1/Qk/lUVypSSvaloHdUnzCtkejcujX7oKcnorkUd50THWP1YivNgQoVQvUNUdDzUzEg3Ln8zF//gIWE7V72blp54q5bJn5aeiOopuIay9zfP0asT0r2P4gsoql0qjqC3QeujApO/UOXtY6Wja8F/3hZXMumr351fcUckLmwfqYZp4MCBJTqPgr4Wgj4GmTgOQedJKvRpgBo1o9RxVnNQFRK9ILygZnbJDtRSVPqJ0tZ5oFrMsNx3MlHGKGobFGBrRG0/rVOygxcGfe9Mdhnx52txyhdBpx/0McjEvS0T11vQ94UlAedJuYCgNY95J69GVFPzMf/gCF5momnquK1RKFMtAPmf4Ogpup7uqPAwefLkmKZfxR0Bt7jboKdYqQzdnolliAb6UXMcr2+g/wmuCnZqIlLSUTk9euKZ6MalIeJTzcCKOs7egEapjDiZaF8qU/aeuPpvXGp25G/WFpZzVfTUU80Vvae//mOswqGe2qbaRKe4+8h7BUZxz9Mgt8E/OIuaL/kHDPJu3ur/pv5jauaU6qsekk3fK3xlYh8lu4xMXQtBH4NMHIcg8yTxvzpIhXzVTKqQ6B8NVen7B6sqzjYUlb4o/fjXD4XlvpOpMkZR26DgO9XrIBP3zuIso6SvVwkq/SCPQabubUFfb0HeFzKVJ4UdQWue8TJVf0FDJ6/6Cqkdffzobq+88kqxBtZIhppteIUH76m3mo+omUQyF08mtiEb+0kZmJqOqIO+l453Y9eTUr1yRctJ9qakZkoajdN/I40fWMi7cel/NftS87uSvlcuyOMcT4PC+JsKqQ+LtiFdBZSSboPHP68GqtCx9PoF+gvMetqqJlXJyuQ+CmobEp2rKnSo2ZL6S8a/nkVP7tU/M9lRUYNOPx+Ocyb2USaPQ9DXc0HHQQVpr5Do1W6oBkrNCIszCnEq6ada25fO+45w78z+MrJx/8/EeRTUvS3o6y2o+0JJt2FHDr/apiAErXlET501mqT31NR/kuvpji56DaShi0aZjZpWaLRJ9T9I9smSnmZroBoVDEaOHBnTwd5/gXiFh1q1arl+R8pokmmWlYltyOZ+Up8rDTagwU78T8KUrm4uybyqQvtRg0CoIKARG/V3Kih46flvXLq5aeRD7X8V5JJt9pXN45woU1Z/F6WtpmZh2QbdlBK9YkDnkPpxaSRHfx9AFc41MEL8q5SyuY+C3ob4c/Xwww93T4RVIFDfRe1v9X3ynhJruo6Z+pDHvyM0G+nnw3HOxD7KxDIyfT0XxCskqmZRffaUfjL99oJOP+j7jnDvjGR9Gdm8/2fiPArq3hb09Zzu+0ImtiEXEbTmCT3R1lMcnazqd+ZdLP6buZoVqEmWTmzN26xZs8gBBxyQdEd2DT6gTFIjP6ojuH7WCGh69YLHvzzNrydOymiSuYAysQ3Z2k/qcO81nVLGroxfmZpqHzQCqAY50M2+qCeIGtBCNwcVBNS/QU9Nu3bt6mos9DTVG/DC/+TviiuucCP4JfvOw2wd58JuXOqvpmZsYdkG9XNRUx8NipCob5AGldFNWSMH/vOf/3SFdfU/0eAn/vdqZnMfBb0NBZ2rKmypOZmeQGtfqy+cXimg60xP8VW4Smbgi6DTz4fjnIl9lIllZPt6jqeaJuW5Sj+ZgDjo9IO+7wj3zqIFvYxs3f8zcR5l8t4W9PVc0vtCJrYhVxG05gE90VSmoWYJehKmJhx6EpfopuKNNKknV2pK4PUNSKZpiIYx9/ct0A1KGaYKIOrv4PGe9Kk5it65l8yoZZnYhmzvJ9U0KAPzMqRu3bq5G7oKd3qfl16WXRRl2uofFP+0UU/ZNEKdRnD0N7fTSH7KOJMtNGT7OCe6canJkeZJ9glr0Nug0TY1aqFu5BoFVc0fE91U9PRZzZl0I1HNk/rvJXMcMrGPgt6Gos5Vne8atEL7XrUxehekBuVRk1F/n51spp8PxznofZSJZYTlevYvo1+/fq7QncwIu0Gnn4n7DvfO5AS9jGze/zNxHmXy3hb09VySe2cm8oxcRdCaJ9Q8xGvPrgEP1IfInxkk03+gKH/84x+jQ5B7T/L0ZE1NSLS8N954I6Z5iV5FUJwMPxPbkO39pGYjb7/9dszNXU9Lk31VhWomNCKnXnrtvSPPoz5Fevrpf8qmzO/777/PqeMcv+/1BFHvcAvLNuj1H3rFhpo9ql+RnmwWdlPRuquJT3FGRg16H2ViG4o6V7U9JXkiHHT6+XCcg95HmVpGmK5nHRvVGidbSxx0+pm47wj3zuwvI9v3/0ycR5m+twV9PadyX8hUnpGLCFpzmC7uRJ3FldGoCYL3FMu74PWUSzfy4g58oZuRlqMmGmqqoOZe3guqRcvSS+T1NC6+nX0YtiFs+0kv4PavQzLr7x9s4eSTT455F5i/o79ePXDJJZdE1ydXj7OWrWOQTNqZ2gaPmmDpXXIe1R55N5UNGzZEpxd3EIRM7aOgtyGVczUs6efDcc7EPsrUcQjT9ezPq/3BQrbTD+q+I9w7I1lfRtju/5k4jzJxbwv6ei7JIEhBb0MuI2jNUWomonfUqUP8NddcE5k4ceIeJ/LixYujmYGetvXp08dlask+8YnP9KZNmxYpU6ZMTHMsbx59p9HL1Ak92YwsE9sQ5v1U3PX/85//7P5ezXAaN27sMrD4DFLNUc4777yk0s6n4xz0NhRUAPBu6DNnzox5Gqob9KOPPureIRnWfRTkNgRxrmbjWsi145yJfZQPeVKqx1mjtYYh/aDvO2HPt4u7/rl6LYT5WktlG8J2bwv6ek72vpCJbcgXBK05aOHCha5zvJ6oqXO3BjvQBa5+PPGZgZ5iqUO42rrrPVrqIJ4MNbFSXySNPuenacq0/ANgiDJStd1Ptv9KJrYh1/dTovVXvxK9qF1NbPR6gU6dOrnMy8vY1B9F8+smlkwBLh+Oc9DbUFD68bxmPHoSrafV6lOnm3GY91GQ25DOczWb10KuHOdM7KN8yJOCPs5Bp1/YMsi38+dayIdrLR/ubdm8ntO5jHxB0JpjdIFr5Dh/Ew29MkAj9jVv3jymA73XsV4Zhk70ZEdeU8d7za/MY+DAgTH9FdTsRyNC6jt1qFcTDg19rgxJI8J5o9dlextyfT8VtP633367G7lP/R30onANgqCPbl6aV5l9MoOPBL3++XAMiko/kY8++ig6NH8yA1Nkex8FuQ3pOlezfS3kwnHOxD7K9nHIhes56PSLWgb5dn5cC/lwrWX7PMqH6zldy8gnBK05SB3i/X0avMxAT2r0FEsvFfYyDb0vTU09kh2UQiM8XnXVVW4Zo0aNchfHgAEDYjIpPdV7+umn3RDnGhRAQ7DXrVu3WBdQkNuQL/upoPW/9957Xd8SjRSo3zVyoJoO9e3bN+nMPh+Oc9DbUFD6Bd1UdNPVYAiVK1dO+jhkax9lahvSca4GnX6291G68rygj0HQy8j16zkT5xH5dvbvnZlaRi5fa/lwb8vm9Zzue08+IWjNIV4zCl3cGsVNTS/ih9jW0ysNle11YNeoiv6XsBdFnbl18Xiju40fPz5hhiZqIjJ9+nQ30lmyo7tlYhtyfT8ls/66SWkIdX8ToOKM2pgPxznobSgs/UQ3FTVn0tD/yTZryvY+ytQ2lORczfa1kAvHORP7KNvHIReu56DTL2oZ5Nv5cS3kw7WW7fMoH67ndC0j3xC05iC1Yde7m/SExrvgvUxi2bJl7qT3D0teXHr646cLSmneeOON0QtJfSaSeZF0trYhH/ZTMuv/1ltvRedPdhCSTK1/PhyDwtLXUPxeYUHb4t2Mc2kfZXIbSnKuZvNayJXjHPQ+ysQycv16zsR5RL69d1wLuX6t5cO9LdvXc7qWkU8IWnPU1KlTI+XLl3ejrPmfyKxcudJ1dv/kk09KvAyNZuZlMM8//3z0CZDey6UXGV944YXugkslw8/UNuT6fsr19c+XbSgqffUpKsmQ82HYR2HfBvZR9tPP1DJy/XoOOv1klrG359v5cC3k+jEIyzbkw/WcjmXkA4LWHKbmFMoMlKno6cyCBQtcR/kDDzww+qLmktJF5DU70TI0Wtnhhx8eKVu2bFpeZJyJbcj1/ZTr658v21BY+sXtbx3GfZQL28A+yn76mVpGrl/PQadf1DLIt/PjWsj1YxCGbciH6zldy8h1BK05Tp3i27Zt695vpXd3aSS5dJ/cupC8J0BnnHGGG7Vs3rx5ObUNub6fcn3982Ub2EfZ3wb2UfbTz9Qycv16Djr9TCwj149zPlwLuX4M8mUb8uF6znUErXlALxpWZ3md2EUNl12SpgtqoqAmC19++WVObkOu76dcX/982Qb2Ufa3gX2U/fQztYxcv56DTj8Ty8j145wP10KuH4N82YZ8uJ5zWVlDzqtSpYr7BO3oo4+2OXPmWNOmTXNyG3J9P+X6+ufLNgSdfj7so6C3gX2U/fQztYxcv54zkX7Qy8j145wP10KuH4N82YZMpJ+pZeSiUopcs70SyA06VUqVKpXt1Qi9XN9Pub7+mdgG9tHegX0UDrl+PWfiPMqHczUftiHX5cMx4HrOXwStAAAAAIDQKp3tFQAAAAAAoCAErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgDAXmHp0qXu3Xdz587NyPKeeuopq1atmoXBFVdcYf/7v/9re5PTTjvN/vrXv0Z/P+GEE+zll1/O6joBAFJD0AoAyHlXXnmlC0i9T40aNaxDhw42b9686Dz169e3lStXWpMmTdzv06ZNc/Nu2LChWMvp1KlTUvN27drVvv32W8u2L7/80t5++227/vrrbW82aNAgu/nmm2337t3ZXhUAQDERtAIA8oKCVAWl+kyZMsXKli1r5557bvT7MmXKWJ06ddz0oO3YscP23Xdfq1WrlmXbww8/bF26dLFKlSoVOM/27dstW7SvMuHss8+2X3/91f7v//4vI8sDAKQPQSsAIC+UL1/eBaX6NG/e3NWqLV++3NauXbtH82D9fPrpp7vp+++/v5uuWlR56aWX7JhjjnFBp2ps27VrZ5s3b7ahQ4fa008/ba+//nq0Rle1tV6648ePt7Zt21qFChXsueee26N5sP5e6/Xvf//bGjZsaFWrVrVLLrnEBVIe/XzZZZfZfvvtZwceeKA98MADezRzffTRR+3QQw91y6ldu7ZddNFFBe6TXbt2ue0577zzYqZr+XfccYd1797dqlSpYldffbWb/tFHH9kpp5zitl0106qd1bbLLbfcYq1bt95jGc2aNbPbb789+vu//vUvO/LII936HXHEEW59PQXtqx9//NGto46Ftv3oo492tcOer7/+2gWdCry1zWruvG7duuj3Wkdti77Xfrv//vv3WE89tOjYsaO98MILBe4vAEA4EbQCAPLOb7/9Zs8++6wdcsghLvCMp4DM69+4aNEiVzv74IMPuv+7detmV111lX3zzTcuKL3wwgstEonYjTfeaBdffHFMje6JJ54YTVNB8g033OD+rn379gnXa8mSJfbaa6/ZxIkT3Wf69Ok2fPjw6Pf9+/e3jz/+2N544w2bPHmyffjhhzZnzpzo959//rkLJBUkar0nTZpkp556aoH7Qc2jN27caC1bttzju/vuu88FnF988YXdeuutbt20bZ07d3Z/p8BSQWzfvn3d/AqmZ82a5ebzzJ8/38176aWXut8VgA4ePNjuuusutx/Uj1ZpK9j3i99Xffr0sW3bttkHH3xgX331ld19993RmmE13z7jjDPs2GOPdduvbV69erU7Fp4BAwa4fakHCu+++647bv795mnVqpXbpwCAHBMBACDH9ejRI1KmTJnIfvvt5z66vR144IGR2bNnR+f54Ycf3PQvvvjC/f7++++733/55ZfoPJpf05YuXVrgci644IKYaV66I0eOjJk+duzYSNWqVaO/DxkyJFKxYsXIpk2botMGDBgQad26tftZ0/fZZ5/IhAkTot9v2LDB/c0NN9zgfn/55ZcjVapUiUmjMK+++qrbL7t3746Z3qBBg0inTp1ipvXq1Sty9dVXx0z78MMPI6VLl478/vvv7vdmzZpFbr/99uj3AwcOjK6/NG7cODJu3LiYNO64445ImzZtCt1XxxxzTGTo0KEJt0F/f9ZZZ8VMW758uUtn0aJFkV9//TVSrly5yIsvvhj9/ueff47su+++0f3mef3119327Nq1K+GyAADhRE0rACAvqLmvmv7qoxpB1eCpSamaniZLNY9nnnmmax6sfqBPPPGE/fLLL0n9baLazHhqllu5cuXo72rKumbNGvfz999/7/p3qjbQoybEhx9+ePT3P/7xj9agQQNr1KiRayKrms0tW7YUuLzff//dNZtWk9yi1lcDNqlJs2o4vY/2oQYu+uGHH6K1rePGjXM/q/b5+eefd9O8Jrqqhe3Vq1dMGnfeeWdM7WyiZav2WPOddNJJNmTIkJgBtLRe77//fkyaanYsSlcf9cn1N12uXr16zH7zqNmztke1ugCA3EHQCgDIC+oLqebA+hx//PGub6UCKQWeyVK/RzXL1WA9Rx11lBvESMGPF7QVtfyi7LPPPjG/K5gszmi2CnjV7FXBogJeNcVVoF3QCMg1a9Z0QW2igZbi11dNqq+55ppo4K+PAsbvvvvOGjdu7OZR02k1S9Y6fPLJJ67PsEZJ9v5etL/9aag/6syZMwtd9p///GcXtCsQV/NgBbXa91666u/qT1MfrVdhTaMTWb9+vVu2glcAQO4gaAUA5CUFhKVLl3a1jYmUK1cuOlhR/N+pxu+2225z/T0136uvvhr9m/j500W1pwpqP/vss+g09UeNf22ORj/W4FD33HOPq5HU4EZTp05NmKYGfpIFCxYUufzjjjvOzecF/v6Pt68OOuggN4CSanj1Uc2vN0KyBkiqW7euCz7j//7ggw8ucvnqZ3zttdfaK6+8Yn/729+iDxu0Xuo7q1rq+HQVgCqg1n779NNPo2mpdjzR64YUQKtvLAAgtwQ/7j8AABmgJp+rVq2KBi2PPPJItJYuETWzVYCqAZE0qqxq3xQc6XU5Z511lgvGFAhp9GGNhisKnN555x1X26gBntR8N11Ui9qjRw83qJCat2r5aiqrwNtr3qt1VVCoGkaNtKsRdlVTm6gprBxwwAEu6NOASl4AW5CbbrrJTjjhBDfwkmo+FRAqiFXNs/alR82BtV6qvdXoxn4K9NXUV/tFgzrpmGjwJB0PDTJVEI2OrKbchx12mJtXzYG9fa5BmhTAqpb373//u9s3ixcvdqMAqzZdzYXVJFn7TcdE++0f//iH22/xNAiTji0AILdQ0woAyAsaVVZNZvVR/0bVWE6YMMG9MiaRevXquSBLI9mqllDBml7/ohFsFcQqgBo0aJB7fYoCKundu7cLENV8VQGhRvpNpxEjRlibNm3c+2VVm6oaX+/1MaJX6KgmUqPpavro0aNdU2G9IqYgCkBVK1qUpk2buhF4VUOp196oRlLNj1V76qdX7Pz888+u2XGnTp32WJYCybFjx7p+waqVVT/ZompaVXut4FTbpGBX+957VY6Wr/2seRRwKl0FudoXXmB67733unXWAwrtt5NPPtlatGgRs4yffvrJNWnu2bNnkfsCABAupTQaU7ZXAgAA7El9chVcK3BWbWIq1DxagbZeYaOAeG+lmmTV4j7++OPZXhUAQDHRPBgAgJBQH9qFCxe6EYTVn1XvY5ULLrgg5TTV7PmZZ56xdevW2d5MzYYLa6IMAAgvaloBAAhR0Komtuozq8GP1MRVTYbVJBYAgL0VQSsAAAAAILQYiAkAAAAAEFoErQAAAACA0CJoBQAAAACEFkErAAAAACC0CFoBAAAAAKFF0AoAAAAACC2CVgAAAABAaBG0AgAAAAAsrP4f2N0FkWzTqBsAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -474,74 +307,136 @@ } ], "source": [ - "edges = [(0, 1), (1, 2), (2, 0), (2, 3)]\n", - "graph = nx.Graph(edges)\n", - "positions = nx.spring_layout(graph, seed=1)\n", - "\n", - "nx.draw(graph, with_labels=True, pos=positions)\n", + "plt.rcParams.update({\"font.size\": 10})\n", + "final_bits = final_distribution_bin\n", + "values = np.abs(list(final_bits.values()))\n", + "top_4_values = sorted(values, reverse=True)[:4]\n", + "positions = []\n", + "for value in top_4_values:\n", + " positions.append(np.where(values == value)[0])\n", + "fig = plt.figure(figsize=(11, 6))\n", + "ax = fig.add_subplot(1, 1, 1)\n", + "plt.xticks(rotation=45)\n", + "plt.title(\"Result Distribution\")\n", + "plt.xlabel(\"Bitstrings (reversed)\")\n", + "plt.ylabel(\"Probability\")\n", + "ax.bar(list(final_bits.keys()), list(final_bits.values()), color=\"tab:grey\")\n", + "for p in positions:\n", + " ax.get_children()[int(p[0])].set_color(\"tab:purple\")\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, - "id": "0d1cf38b", + "execution_count": 13, + "id": "76444240", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10100\n", + "10110\n", + "01011\n", + "01001\n" + ] + } + ], + "source": [ + "for p in positions:\n", + " print(list(final_bits.keys())[p[0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ca9172e6", "metadata": {}, "outputs": [], "source": [ - "for i,j in graph.edges:\n", - " std.cnot(i,j)\n", - " std.rz(2, j)\n", - " std.cnot(i,j)" + "def evaluate_sample(x: Sequence[int], graph: nx.Graph) -> float:\n", + " assert len(x) == len(\n", + " list(graph.nodes())\n", + " ), \"The length of x must coincide with the number of nodes in the graph.\"\n", + " return sum(\n", + " x[u] * (1 - x[v]) + x[v] * (1 - x[u])\n", + " for u, v in list(graph.edges)\n", + " )" ] }, { "cell_type": "code", - "execution_count": null, - "id": "e0a2c6c0", + "execution_count": 15, + "id": "3a6a65a6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "OPENQASM 3;\n", - "include \"stdgates.inc\";\n", - "qubit[3] qb;\n", - "bit[3] cb;\n", - "def qaoa_cost_3(qubit[3] qubits) {\n", - "\tz qb[0];\n", - "\tz qb[1];\n", - "\tz qb[2];\n", - "}\n", - "cnot qb[0],qb[1];\n", - "rz(2) qb[1];\n", - "cnot qb[0],qb[1];\n", - "cnot qb[0],qb[2];\n", - "rz(2) qb[2];\n", - "cnot qb[0],qb[2];\n", - "cnot qb[1],qb[2];\n", - "rz(2) qb[2];\n", - "cnot qb[1],qb[2];\n", - "cnot qb[2],qb[3];\n", - "rz(2) qb[3];\n", - "cnot qb[2],qb[3];\n", - "\n" + "The value of the cut is: 5\n" ] } ], "source": [ - "program = builder.build()\n", - "print(program)" + "cut_value = evaluate_sample(most_likely_bitstring, graph)\n", + "print(\"The value of the cut is:\", cut_value)" ] }, { "cell_type": "code", - "execution_count": null, - "id": "afbf2ca4", + "execution_count": 16, + "id": "01920bcd", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of the cut is: 5\n", + "The value of the cut is: 5\n", + "The value of the cut is: 5\n", + "The value of the cut is: 5\n" + ] + } + ], + "source": [ + "for p in positions:\n", + " result = list(final_bits.keys())[p[0]]\n", + " bin = [int(digit) for digit in result]\n", + " bin.reverse()\n", + " cut_value = evaluate_sample(bin, graph)\n", + " print(\"The value of the cut is:\", cut_value)\n", + " #print(list(final_bits.keys())[p[0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "968c5412", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of the cut is: 5\n", + "The value of the cut is: 4\n", + "The value of the cut is: 5\n", + "The value of the cut is: 2\n" + ] + } + ], + "source": [ + "# results from https://quantum.cloud.ibm.com/docs/en/tutorials/quantum-approximate-optimization-algorithm\n", + "result = [\"01011\", \"10101\", \"10110\", \"11000\"]\n", + "for r in result:\n", + " bin = [int(digit) for digit in r]\n", + " bin.reverse()\n", + " cut_value = evaluate_sample(bin, graph)\n", + " print(\"The value of the cut is:\", cut_value)" + ] } ], "metadata": { diff --git a/qbraid_algorithms/qtran/gate_library.py b/qbraid_algorithms/qtran/gate_library.py index 4f8deef..6627d54 100644 --- a/qbraid_algorithms/qtran/gate_library.py +++ b/qbraid_algorithms/qtran/gate_library.py @@ -52,7 +52,7 @@ class GateLibrary: """ def __init__( - self, gate_import, gate_ref, gate_defs, program_append, builder, annotated=False + self, gate_import, gate_ref, gate_defs, program_append, builder, subroutine_ref, annotated=False ): """ Initialize the gate library with necessary components. @@ -67,6 +67,7 @@ def __init__( """ self.gate_import = gate_import # Libraries to import self.gate_ref = gate_ref # Available gate names + self.subroutine_ref = subroutine_ref # Available subroutine names self.gate_defs = gate_defs # Gate definitions dictionary self.program = program_append # Function to append code self.builder = builder # Circuit builder reference @@ -142,7 +143,7 @@ def call_subroutine(self, subroutine, parameters, capture=None): subroutine: Name of the gate to apply parameters: list of all parameters to apply """ - if subroutine not in self.gate_ref: + if subroutine not in self.subroutine_ref: print( f"stdgates: subroutine {subroutine} is not part of visible scope, " f"make sure that this isn't a floating reference / malformed statement, " @@ -304,7 +305,7 @@ def begin_subroutine(self, name, parameters: list[str], return_type=None): parameters: List of parameter names return_type: Optional return type specification """ - if name in self.gate_ref: + if name in self.subroutine_ref: print(f"warning: subroutine {name} replacing existing namespace") call = ( f"def {name}({','.join(parameters)}) {' -> ' + return_type if return_type is not None else ''}" @@ -312,6 +313,7 @@ def begin_subroutine(self, name, parameters: list[str], return_type=None): ) self.program(call) self.builder.scope += 1 + self.subroutine_ref.append(name) def close_scope(self): """Close the current scope block and decrease indentation level.""" diff --git a/qbraid_algorithms/qtran/qasm_builder.py b/qbraid_algorithms/qtran/qasm_builder.py index 8934cd8..e3edb46 100644 --- a/qbraid_algorithms/qtran/qasm_builder.py +++ b/qbraid_algorithms/qtran/qasm_builder.py @@ -68,6 +68,7 @@ def __init__(self): self.imports = [] # List of library names to import (e.g., "std_gates.inc") self.gate_defs = {} # Dictionary mapping gate names to definition strings self.gate_refs = [] # List of available gate names for validation + self.subroutine_refs = [] # List of available subroutine names for validation self.program = "" # Accumulated OpenQASM program code self.scope = 0 # Current indentation/nesting level @@ -98,6 +99,7 @@ def import_library(self, lib_class, annotated=False): program_append=self.program_append, # Provide code appending function builder=self, # Pass reference to this builder annotated=annotated, # Set annotation mode + subroutine_ref=self.subroutine_refs # Share subroutine definitions dictionary ) def program_append(self, line): From b11c2904c0e8486f13b684dc084025de4edbad91 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Mon, 26 Jan 2026 20:35:01 +0100 Subject: [PATCH 09/20] Fixed parameters indexing --- qbraid_algorithms/qaoa/qaoa.py | 4 ++-- qbraid_algorithms/qaoa/test.ipynb | 32 +++++++++++++++---------------- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index 96a821a..fcc1074 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -276,8 +276,8 @@ def generate_algorithm(self, depth : int, layer : str = "", param : list[float] std.add_input_var(f"gamma_{i}", qtype="float") std.add_input_var(f"alpha_{i}", qtype="float") else: - std.classical_op(f"float gamma_{i} = {param[i]}") - std.classical_op(f"float alpha_{i} = {param[i+1]}") + std.classical_op(f"float gamma_{i} = {param[i*2]}") + std.classical_op(f"float alpha_{i} = {param[i*2+1]}") for q in range(self.builder.qubits): std.reset(q) diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb index 62ed6c2..a402d74 100644 --- a/qbraid_algorithms/qaoa/test.ipynb +++ b/qbraid_algorithms/qaoa/test.ipynb @@ -153,10 +153,10 @@ " message: Return from COBYLA because the trust region radius reaches its lower bound.\n", " success: True\n", " status: 0\n", - " fun: -3.2509\n", - " x: [ 2.869e+00 2.624e+00 1.241e+00 3.187e+00 4.219e+00\n", - " 3.169e+00]\n", - " nfev: 41\n", + " fun: -2.9066\n", + " x: [ 2.515e+00 2.679e+00 1.439e+00 4.172e+00 4.180e+00\n", + " 4.063e+00]\n", + " nfev: 34\n", " maxcv: 0.0\n" ] } @@ -182,7 +182,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -215,7 +215,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAcE1JREFUeJztnQnYVdP+x1cDTSqkQUpEJNdVIYqkuFJdynBNGTPdTOEaCknIEJmHzMMl4zVLoiQqolQXRRIlUkmR0rj/z3f5r/fu97T3Ofs9w3vO2e/n8zznqXef/Ttrrb3XXvu7fmut36rkeZ5nAAAAAKDoqZzvDAAAAABAdkDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMSEqvnOQKGyYcMG88MPP5jatWubSpUq5Ts7AAAAUEHxPM/89ttvpnHjxqZy5eQ+OYRdCBJ1TZs2zXc2AAAAACzz5883TZo0MclA2IUgT527iHXq1Ml3dgAAAKCC8uuvv1pnk9MmyUDYheCGXyXqEHYAAACQb6JMDWPxBAAAAEBMQNgBAAAAxASEHQDEivvuu8/89a9/LZlG0b59e/Pmm28GrjLr1q2bHdp4+eWXS313/vnnmz322MNUq1bNtG7duhxzDwCQGQg7AIgVWjF24403milTpphPPvnEdOnSxfTs2dN8/vnnpc67/fbbk85X6dOnjznmmGPKIccAANmDxRMAECsOPfTQUn8PGTLEevE+/PBDs+uuu9pj06ZNM8OGDbPCb+utt97oN+6880777+LFi82MGTPKKecAAJmDsAOA2LJ+/Xrz/PPPm99//90OyYqVK1ea448/3txzzz2mUaNG+c4iAEBWQdgBQOz473//a4XcH3/8YTbbbDPz0ksvmVatWtnvLrzwQtOhQwc7PAsAEDcQdgAQO3beeWc73Lp8+XLzwgsvmJNPPtm899575uuvvzZjx441n376ab6zCACQExB2ABA7Nt10U7Pjjjva/2t168cff2zuuOMOU6NGDTNnzhyz+eablzr/yCOPNB07djTjxo3LU44BALIDwg4AYs+GDRvM6tWrzeDBg83pp59e6rvddtvN3HbbbRstugAAKEYQdgAQKwYMGGDj02277bbmt99+MyNGjLCeuLfeessulghaMKFzt99++5K/NWS7YsUKs3DhQrNq1So7rCs0T0/eQACAQoU4dpB2oNezzjrL7LDDDnZ4q379+nYy+qxZs0q+//nnn80hhxxiGjdubAO9agPjc889125mDJArFi1aZE466SQ7z+7AAw+0w7ASdX/7298i/4a8em3atDH333+/+eqrr+z/9fnhhx9ymncAgEyp5Cn8OmyExEfdunXt5GuJmorIa6+9ZqpUqWJatGhho/Q//vjj5uabb7YTzxUP7IEHHjAtW7a03o6lS5eaq6++2no25s6da+1++eUX88wzz5i99trLCj95Qc455xzTtm1b60UBAACA7GoShF0ICLtgttxySyvuTjvttI2+UyDX3Xff3Qo4efKCUOBX2c+fP78ccgsAAFCxNAlz7CDtQK9+dPzRRx+185Q05BqEhrFefPFF06lTp3LIMQAAQMWDOXaQMtCrArxqjtw///nPUoFexb333mu/10fz795+++2NJpcfd9xxpmbNmmabbbaxPY2HHnooDyUBACjeec2a7nLeeefZuaOa16wpMOeff7714PgZM2aMDcBdu3Ztu1DosssuM+vWrctTiSAfIOwgUqDXjz76yPTt29cGev3iiy9Kvu/du7edc6fgrzvttJM5+uijbbR/PwolMXXqVPPKK6/YGGIXXXRRHkoCABVB2GixjBbNKFbhFltsYbp27WqmT59uioEmTZqYG2+80UyZMsXuY9ylSxe7KO3zzz+3Ix763HLLLeazzz4zjz32mBk1alSpaTEqZ/fu3e2iNbXLzz77rHn11VdN//7981ouKGc0xw42Zvny5Zp7aP/NF/fee6+32267ebVr17afffbZxxs5cqT97ueff/bOPfdcb6eddvKqV6/uNW3a1DvvvPO8ZcuWldg/+uijtgxBn59++imtPB144IHemWeeGfjd6tWrvZo1a3ojRowItX///fdt+j/88ENa6QNAfHn11Ve9N954w/vqq6+8L7/80rv88su9TTbZxPvss8+8//73v94RRxxhz/n666+9MWPGeC1atPCOPPLIEvvffvvN23LLLb1TTjnFmzVrlrXT9w0bNvTWrFnjFSNbbLGF99BDDwV+99xzz3mbbrqpt3btWvv3gAEDvD333LPUObpeekf8+uuv5ZJfyL8mYY5dEfTe/KtS1XtTT0x/u96bhka/++47O1SqY9pCSRxzzDG25+bnlFNOsR61Bg0aZBToNQjlSZ+w7529SHYOAFRMEoNEDxkyxHrxPvzwQ+uZ+s9//lPynRZo6fsTTjjBDjVWrVrVhluSZ++aa64pmes7aNAg6wVUG+l2I4nDvGbhJtKr7K5drV69eqlz5N1Umy8v4AEHHFAueYc8kyNxWfQUgscu095bIosWLbK93yeeeCJSWv379/fee+89b+7cud6MGTPs35UqVfJGjx7tzZkzx7v++uu9Tz75xPvuu++8CRMmeIceeqjtLTtvoHrejzzyiO1p6zdef/11b5dddvH23XffDK4AAFQE1q1b5z399NO2Tfv8888Dz3nwwQe9rbbaquRveaXq1avnDRo0yI4grFy50uvXr59td8LaxUJDbW2tWrW8KlWqeHXr1rXtaBCLFy/2tt12W+vVdLz11lte5cqV7aiJrt/333/vdezY0b7Lko2kQLw0CcKuSIRdOo1cIrfccottKNTYRaFPnz5es2bNbJr169e3w7ASdWLBggVet27dvAYNGlix2KRJE+/444+3wx+OsWPHeu3bt7dpaihAwyaXXXaZ98svv5S5/FC+w/giaAhfdRCgUIWNUEdyhx12sAJHn5133tn79ttvi/q5u/nmm0udo/dSu3btvEMOOWSjIeZhw4Z5derUsddPU2NuuOEG+xvPPPNMOVwByBUIuxgJu0wbOT/qtfbt2zeHuYW4zFUSqv+ap/njjz+WfFatWpW3MkHFQJ622bNn29EAjRKos5rYmQ0TNuq06vhJJ53kTZ482Zs0aZKt17vuumvkDm2hPXfyuJ122mmlvJLqMKujHfY8btiwwXa+VeYvvvjC/qauBxQvCLsYCbtMGjk/EydOtOXR70Dh99yXLFnide3a1dt6662tx1Qe0XPOOSej+ljWYXzVl5deeint9ACyQeKCrWTCRvVbowjr16/faFFXvrzNmT53nTt39k4++WT7fz3/aks6derk/f7775HSHzhwoG1jNOoDFUOTEO6kwFFMOE343WOPPcwNN9xgd3a44447Sr7XJudaIKGYRYoxt8kmmwT+jmLHtW7d2v4OFH7YgsqVK9vzFapAe5XqnHfeeccukElnEra2divLJGyHtoDbaqutTLt27cwjjzxiF8cA5DJkiUJ2KPalFj/onEmTJtkFYy76/sEHH2zbRT0biQsFVq5caZ+dSpUqlRxzf7uFW+VFOs/dgAEDSvbhVriWrbfe2owbN84cf/zxJWXX7z388MP274ULF9qP0nJoZx/FH1Vbc+2119p2SDv+aJtHqCCUi9QsQgrFY5dIOr03hQDYbLPNvLvuuqsccwrZXPgi7rjjDuu5K69h/Guuucb74IMPvKlTp3o33nijV61aNZsHiDeZeps11KiFVK1atbLDkG4ebpThSI1KXHrppTZciRZe/fOf/7QLtvRsDB061Nt7771t3mTrnyLgvFEzZ8609VRTTjQEqTRPOOEEW//LK8RSJs+d5jVvvvnm9nqpvdhxxx3t//Xcvfvuu6Hhq7Q4zf+OcPOadb3cvSuvOYI61rZtW3vPdt999zSuIATBUGxMhF2yVanKV6pGziExoQeRRQvFu/BF82Uk4Hv37l3uw/j+IZ2yCEsoTrIxT0wv97vvvts78cQT7cs9aqcmbMHW2Wef7bVu3TqSsNH5WnkvcaN0u3TpYufalRfF/Nzl4t5DdkDYxUTYJVuVGrX3JjQfRStWofgWvhx77LFejRo17H2VFySTxQtlmasUhMLVKB9//PFH2nmAiuVtlihR3c6kUyPUoUkUEMVCsT936d57hZwpJmF3bxJvpbj//vtt51rf6X4EOUqmTJniHXTQQba9V+ivM844w46YZQPm2MUEzaP49ttvbdDJRYsW2TlWf/vb3+x3CjTpAgInfrbbbrtSvzNx4kTz1FNP5akUFZdU27EJzZPp0aOHDTJ99dVXb/Qb2dyOzR9cOtVcpaB5Us8995zdokn7Bj/wwAO2Duo7zV9atmzZRulpbqDmCWqOns7bb7/9zLvvvpvxPC2R6/Qhs/mZbo/p6667znz//fcb7THtWLJkiZ0HduaZZ4bmQe2XtsZKdk4hU5bnLgi1Ie65K08ymZsbt3nRbv6m5rNffvnlJgjNmz7ooIPsnHi1+Zo3LVttClDuZEVKxpBC8NhBvMi0516W7dgyHca/8sorvfPPP996C2SjFbpKW3OexG233WbjY7kYWUG9Vw3TdO/e3Zs+fbod2tFwmlYnKp1MhoTKI/2KTqbeZjccKY+F5tilOxyp4T/ZXnvttV4xkOlzp3ovD6bKresnL5Lq7FVXXVV0IbaKzWMX1VvpRssS2xx59BJXZOta6lzdy0xhKDYLIOyKn2y41oXEjV5Amqeoic09e/ZMKz+Zhi3QCyNoqD0Xw/hvvvmmndOkRTdq5NVA6wXzwAMPRGrk1Ojr+Pjx40sJWR17++23vVw3srlIv1jqXTbSlzDTvVb8N73gJU5Uf8sqzNzLPZ1OjYSgXpTJYnMWGrl47oYPH15KLBTLHMFiFnbrksyLDmtz7rzzzo3mQuo6uriEmYKwywIIu+InG16fF154wQqK++67z/6GHvJnn3025z33QtqOLZ1GTgFSFfH/9NNP91asWGHn4Ch6vl7US5cuLar0i6ne5Sp9iUOJlLJ6m93LvaydGuVV9+qSSy6JVGYovJGGYhR2MyJ4K8PaHNXZqlWr2tXbEsdqZzQvVOdq+81MQdhlAYRdPCmL10diYJtttgmdOJzLnnshbMeWSSMn5s+f7+2xxx5W0Oo3FGxZoVOKJf181TuFJdILQvc9XY+b6l5i3dKKxnTrfVmEmb9To6F7CbSydGrUmdEzozAl/u+11zWUP+mONBSjsFsdwVuZrM156qmnvIYNG9r2Rm3/xRdfbP9WuKhMQdhlAYRdvEjH6/PRRx/Z4/KcaXikUaNGduhBL56KQCaNnDxmhx12mN1PWLHwtFpMscUkGKLGE8t3+vmqd9rTWcflUWvZsqUVtxJGbjeCKB43CTvFIdQm8PK6Kf2PP/44UvrajkvH5XmQ11Pp628JyijCTJ0aXWd5CSVONYSvPHz66adW3KXq1EgQBH2vMkHhh9jSM6t7fdZZZ9mYd/q/Pnqei91bmUrYORYuXGhXw2q0QPsVa/VwpiDssgDCLh5k4vXRC1nHNUFYQ1MSGMcdd5xXr149G6yzolGWRk4LL3Q8cZ6XAq5KkETxOim8i4KgKuCsRLU+iXH8wtJ/5513bIOa+Py69Jtd9nrST6HVOwkz/Z6/3iV7wbit6NJJ/4ADDigRU9pMXnOpdEz1/pVXXokUZkn3NkooJigsshFiK073vrPPW1kWYed4+OGHbccmGyMtZdEkxb9GGSBCyBEty3/hhRdsyJH33nsvMPRCIm4LoiuuuMIceeSR9v+PPvqoXRb//PPP221/KhL+sA2pcGFIxo8fb2rWrGkef/xxGzqgcePG9ndc6AB93DZKiXTu3NmGFtC2SgsWLDDdunUzo0ePjpS+ft9tJ+VHf5fH1lLZqne9evWydU1ou8Co9U7napvBtWvX2jAZRx99tA0bohAyqTjjjDPsNlb3339/SYgR3XfV+x9//DHStnKyh+IMsRWGC7EV13s/YMAA28Zomztt1TlixAhblrfeest+77Zv+/rrr0tC+ugZ0/lbbrmlPXb33XebDh062FA/b7/9trnkkktsCBVtD1eeEMcOKvReu8mQoBD+l7Feks2bNzfz5s0zcUaNnESZ4iiqAdPfauR69+5tv1cDJ+Hib+T0t/YCFf369bONnWKUrVq1ygob7VWpmGaK23fBBReY/v37m3322Sc0fd2zRo0a2dhfr732mm1sFy9ebMVKqvQVd0uxv5Su9h5VTDs1snPnzrXpF0O90zVSfdP+wIoDt9NOO0Wud7r+EpTvv/++GTx4sBVmJ5xwQpnSr4j1HiouixYtMieddJLtlB144IHm448/tqLOxY4dPny4adOmje34iP3339/+rXiEjsmTJ9vzd9ttNxtrU50j7YVc3uCxgwpFWbxOeinrhfbll1/a4LZCokJip1mzZqYiNHLy0NStW9d6ehIbOQkGhxo559FUQE4FBVaATnmd5HmTuNN1V+BhiZyypr/LLruYjh072qCp8kaVJX0FGtV923XXXW2gZ5v+09+bQq53EoZXXnml6dq1a4nHT79x2mmnRfoNfyBr3TuJys8++8zmIVWg24pc76Hi8nASb6VQAPmgIPJ+nnjiCVMQZDzwG1OYY5c5qeJpaam8gsZq6xXNH9KqPU06TZwrpdWhiuuk1UXaIDxo+5qyTgQWmvSrSb0KCOpinulv/zymfv362Yngb731ljdr1izvtNNOK5eQGXEg01WtQvdbc1R0jurPkiVLspK3XM6xy0W9a9y4sV2I4K93YdcuLH2dq9+i3gMUHyyeyAJxEHbZEFaTJ0+2m2jrxawgqQcffLA3bdq0rMTTUigETY7XZtKaIK78dejQocRe6WgS7+DBg+1Kq3HjxtlVgv/6178yngicbPWdP5ikgm8qPb3UdA21D6DLP+Q2dIALNKy64zZ2104SWvFayMIuF/VO4VISAxSHXbug9BUqR4tJJMyo9wDFB8IuC8RB2GUqrLRcW6LvlFNOsb122SngojxnYdHGo8bzWrZsmc3L888/X/LdzJkz7TWfNGmS/VvbWNWoUaOUMNVLSZ4LBclMJUz1ogpbxfXTTz9lcGWhPEMH+OPS6dyJEydmnJdcr4rNp8dP10chUdQxmjNnjvfkk09agacwJgBQnCDsskAchF2mwkpxr/T3vHnzMt77LjGel8Rk0AtdIR5uvfVW+395KFq1alVKmCpwq+wkCFIJ05UrV5aKtaSPxKKW40PxhQ747rvvSu59nIVdph4/xexTvDEX3Fo7lijy/R9//JHHUgHkfoRJPProo/Z3FCZJz49s4gDhTmAjNOlcoRJ+//13u2JwypQpdkL0QQcdVHJOy5Yt7dLtSZMm2dWKWh1Ur149O6lUYSf0G/q/JrJvt912Zrv+byRN89sbe9jVikrvjz/+sEvAtbpPq+20glETxBOXgTds2NCueBRnn322XX7+ySef2HAN+nvo0KH2uzlz5ti8aEm6Jse7ifPK24cffmjzX6NGDftxaEXl2LFjU06ShfyHDvjoo4/sqjRN3tfqVt3vgQMHmh122MHWpziT6STutm3b2mcAoJhQOB2FBmnRooUNq+JCJH366ad24dOFF15o3njjDfse04Kqc8891xxxxBFmwoQJJb9x6623mmHDhpmbb77Z7L333vZ9p0U/FQ2EXczJRFjpRauXsWJpKWyF0EOnl3PVqlUziucVhYMPPtg+oAr3oFANStPFUdLDmkqYBq1YUky1o446KlL6kL9VtbpPL774ohk0aJBtnBWCQzHvtFI01apOACg+Dj300FJ/DxkyxK6iVydFoi9VR/6XX36x7cNrr71mw5U4osRujBvEsYs5TljJA9K3b18rrL744otItgpRofAK++67r3141DP6y1/+YuOA6btM4nkpPtmaNWvMsmXLSp3/008/2e8cEgLyFCrYrbxvCgDpfjeVME1EDcPxxx9fyosHuUHXWuJb4TUk8t55550SUSfkcfr/qSClPhJ1QnGg5F39+eefbadE8efUyG+zzTZ5LBUAlAdq85955pnII0xCAYEVEmjBggVW8EkMaqRn/vz5pqKBsIs5mQgr9Y70clbPaK+99rK9Ih3TS1bxwDKJ56X8KB7ZmDFjSr5T3CwFQPUPtSUK03/96182f9tvv32Z0tXDP3PmzMhxwACg+JD4l4dGO5/oo7bkzTffLPlenYRzzjnHTjHRCIZ2lFGb51BHQp5h7ZAiz3DTpk3tkJ+CZEP5jDDpvvgDc2uESZ31VB35b775xr5frr/+enP77bfbESIFLFeHUu+6igRDsRWMIGHltstKFFbalklbMMlb5nB/R9mWKdk8Kw3PSWQpkKrmVKkRPu+882za/mFUiVA1tNWrV7fDc/IUat6VGl4nTP0Pe6LHz/HQQw+Z1q1b23IDQDzJdJ6W2jedf91115n69evbOaASghIIar/yTZR5zcVMJlN39E6SV+/OO++003jE008/bd8H7777rg32XVFA2MWYTIWVejrahkkNm77Tg6NGU3PdtJuAmTE1o3lWt912m21IJSwlNvXg3XvvvaV+Q71tzbXQ9/I2aohO862iCFPHihUrzHPPPWc9lgBQ3CQXN5XNtzd2T3uelhbqaGTAoZ02tGhLc32h/EaYhNp4LaBS5/6YY45J2ZEP2gqvfv36dheairYVHsIuxo3ckpFTbI8lXWGlOQyaiKpJ7hJLOld742mrJvcQZbK6T164e+65x37ChKnmYvmF6U033WRuueWWyB4/8eyzz5p169ZF3isTACpmJIBEfvjhB7uIp1OnTuWceyjrCJPmgrvjTZo0sf+Xp3XJkiUVbis8hF2M2ap7v6Su+VTCSkgE+ie9lyfZ8Pg5ganhlsT5GQAQPzKJBOA47rjj7DxiTf3Qak1N5YDCHmHaaaed7DB6v379zAMPPGDP0W9KvNsRpgoEwg4Klkw9fo6JEydmOWcAEMd5Wg51GhVq56uvvrLiQIIiqNMIhdWRV0irCy+80EZu0LnytGqESd6+ikTBCTvNh9DHBRXUhNerrrrKKnm5VfWwjR492rpgNX7uYqypIjj0neZJaMKkemx6sDW/KmrsNYC4E/dJ2JmwfNJzZq+9rjazZs2yoXE6dOhgpwBIMDgUMPniiy82H3zwgX3JaIHPXXfdZb0/Qp6GMC/B5MmT7SpzKLx5Wg79rY+8PfIQdezY0QbIjjIFJRk8d7ntyMtL9/DDD1f4IPSVC3VVk+ZDaMcBTXKVe/Xzzz+38x300Ryrzz77zDz22GNWjftDWGhehdS6HmB5arQqSudJHAIApOKP+Z/ZBUOaUK/YWJqXpVV2mqsl9K/+1upwxdrTikq1Nxqyc6vFJQblefB/Tj/9dBumZ88998xzCSsWZQ2xFGQv9BsAxUDBCTs1jt27d7fL1TVmrlVN8rqpkVVw3P/85z/2HG0tJNGn7zXBX5Pjhbx5CsD75JNP2vAW8vTJoyeVX96xbOQlVM9cOzg0aNDAehfVkPhRz//www+33kf1NhRQ0R9XyaEl+toiRR4ErdzSb0Fxo9572AfyR8Ojr7GBkjVaoJXY6hjq5a/OppCQ04iCjmuVtj7qQKojKqHnvEbO66OP4qZpztapp55aKnwQZJdf3nvMjB8/3t4fzbXTMKq8p7179y41T0ujObqfuh/+eVojR460K2XlONBvqN1VPDVNzNc2ilC48L4tYGGXLPp0EJpHoRvkhlm1ukkNrRsSERqLV4BJef3KE83ryLTnLyRmTzzxRNsITZ8+3Z6nHRQAIPeojREaknOeGz2z/q3NNEykOT0amg3i1VdftcFv9QxXdJJ1aDLt1Kz/fbmdp6Vhc20rpWHYxHlaf//73+08LW1jJ9GtVa8OvcgffPBBGytTYVA0X+uwww4zr7/+esbljjvZElYS0Hq+/B+N4qWC9+3/qFpMq5oS0TJmeePOPPPMkmNa3eQXdcL9HbbVlGus/a52F2lclUMfoYa7SpUqVnD6K4I7Lq+h28vU9f70nTuuBkNbIqmxOeCAA2xFVK9Qc26cOJUXQC8QeR7VMMlWq3yGDh1q5wo65NGMgsu7KrN+PyzvUcukY65MUdJ2gjvx/LDjGipRPpQfh8t72PFslinouLuGqfJe1jIlI9dlSoUrc5zvU5TyK50LLrjAemwkFnRcQ3q1atUyl112mW1/lP8rrrjC/qupIiKxTFpVqQ6mhIQ/n/mqe5ncpxYDRye9dt9c3y2ndS9VJIDZ1x4cWiblQbsSKIitv0wuTYk9TeEJyrvLSyb3KWrZk92nVOJKQtXND5UnUqJI70+Xd4kr1V2V0y1CkOB170l/mfS96v6MGTPM1KlTzeHP/lm/g/jpuRfM3VecbZ8PpaX58BJSEkd6XpywkhdcWwyqTApnJaEt8SQvtyunbOVddXVPwen91yaojdDInf95evD/37fatUjvW+dpd+9bkex9q/Td/dP7Vunnu90ramEXtqrJL+4kvDSXTsdUOTJFD4R/U3KHbrgqldAybMVxUyX3BzxUfjXJVhVm8eLFJcc1FKz4ORoa0PJtzbPxv9TVsxAaFlCF0WRrVQR9rwqnh0qrsrT3nXoWSkcTfzVPp0+fPrZ3kgqJS6Eekub9zJ49u1QvKpMyRUlbZVID4/Lh0HC7Qgmo7A6VXfdUgt3t/yfUA9Swu/b8U71w5KJMuk8OdS7U81Qd8D9U2SpTMhQYWg3V999/bz1DKs/w4cPtbiCuTKpPej7UcOq4yqFOjiaGuzLpRaXro2dJnSQ1XppIngpXtrjep6jl1yRsDctp5MD/O2pztG+xBIKeV02ub968ud2IXPjLpOukvClIdqHUvczuU/LXhn43WZmiXvuwMkW1L1uZyqfupbp2/vOD71Nye70nJZTktZRw0JQkxe1T+dVO6LckXPQO0XfawUdDzUpHC4QkIPxlUpvjrrnzfCWbwrDVVuvMd999V+Kk0O9o5aqmNWj3Dwkr/avnRGU69thjbXxRLZhUvpRPtWXKp4Sku0+yKet9+uqrr+wxPb+axuUcN+59K1Q3VObE962QAFX7q2slDaLpX/ls99zuKFGo5PmlYYGiiqmLev/999u/9WCplyHBJRe5hkEcWiShYQ//Bdbepmp0VVF0QaN67LRPoG6iU/eZKG3ZKJaahNn7779vj6t3L3e/Ko16/jq/f//+dj6gJlrrgVBwXbmFVRnUi5CbWr0r9XhUCdsO/V8FC8L1XnPRe9jxyrdSpl0IHoaylKk8vSbJrt/On95phylc71f1WlMJ5M3WC0ONrL5TSIBrrrmmpIcssafhQKWpvGuhkXrt8hSpvql+iR/2v8JEqTdxvU/bDxiZsvx60Uhc6yWhhjWoTBpGUtoS02ovNHQnb4i/TJoHrGdZLwzZFULdy6fHLtVwa6q6lyr9ZB67sDKVV91LJ+/++5TKXqtq/WWSQJDXSoJPIkNiTUOPCi2iuWPKu6YISIRIVKrj58qkuq8Opt5BEhepPHaJ+ZfAk6dLdhJWelf/4x//sG2X6qXyqXeunp3LL7/ctmM6pne9Rut0TfXe0zDo+eefX8rbm+o+rVmzxg756n2rOZY6rnJqtbR738ruyiuvDH3fDhs2zD7T7n1bo/fdpkqN2knrfS7bPUUF0VxdN/2s6Dx2YauanOCSqJMXQwLOL+qEehtqSFVxXe9Q4+26EEHDuQ79nn/OjEMVMDEGji60c837CetN6riCKerFrJeuq6DqLSkyukKzqPev4wqM2bZtW2vjXs5CQz1ari80UVurh2VrzJ8RtsOImvd0ypQKf9phcYSCjqvMQUM2YcdzXaay5D3seFjew9C8ID+656rP6rDIC6denev9uof83//+t22s1XFw0fUVksOhRk3CTnNfmu67zlSqEn4PE8uQ+Hc6YRuyeZ/Kkn5ZY1ipUZVA02IHvRTUYxdB988NX2nOjtocN8nalUm/pdha8qAky0c+6l62nqeg3xXphpdKVffKal+IbUQY2Wg7/GWS90touNGJDAkOee/db7r/awRJYXuEOix6L7388sslocSiLPpx+dc7201hcM4UzVt0Uxiuv/56+2xocYvy5ObZKd8ScXoHKs8aLtY56rDeeuutke9Hv379St63Lk8Sr2V53x511FGl3rcrv/zA1G7dLbTs+Xo/BZ5riij6tESdxuhVWeVG1t9uLpxumi6SvpeAk+qWh0vz6qTKNWwZJNzKA200rd6Kev5uqxOH8qs5D/IM6sap9yLvijyMYfvfqRz6/k83bnJhBxVzAr9/2ySHenxPPfWU7bl/n0TUVXSWvn2fefKbCVbYaZjFzc3VC07eUv8eo2p3NCyjF4nEoD/WnRN8GjGQRwCgPPGLK3nMhLz3ieJKnT2JKzdVSMe0KlxDtArN42LKlgW9bzUE6l9M5BdWmsLgF1Z+QaRVyw6NSGju3VlnnWWnS0V5h5+bo/ftrF//Nzxa6FQtpujTEniaCClcAEqHGk8NU0rc6aaq8sh7p0os16vcvOWNHhB56rT4w9/zD0IbFft7/lqJJTTcpoqlMXr1eIRc1HrY7P5335RTYWJIsQQLTbeBdugc9VDVIZKdno89bv5zfidszIpP/xym1YRrPxJzeuEJPY/qhEosq91RD1/CLhHN0ZOQ1tyZQql3+U4fyod0xZUCbcupovqdDpkIqyAUdkTDk3rnJXacyvN9W7VNO1MsFJywSxYxWg1tlCmBEjwbT1rNz4Mlj2MmPX8Ns6nnpPlTGu9X2W6++Wb7neYrXH8T22XFnUx6v0LzZLTCS3NetEBIHSfvL32JpxZCs8teTylutNIwSggGPf/ZBmEGuRRXEjt6FyV6x+S9q75LJ7NVj/951Pzo3ax0MxFWQWj6idq0VAtvcv2+rdnyT6FXDBScsIsTWumTjZ6/KpYeQA0va5WYejB6IDSfCuJNNnq/akT1UcBvNWpqsBpt2dlU22aXci4NAOSSbHit1FG87rrrSs7ToivNa9fCgn5jVuR0CoOOaVROq4r1G/pb32vlbKr3Xa7ftz3+XfYh6XyBsMshUbyLUXr+mtSp1Y36QMUgGw10EG4Vlre+9Cq+8gavE0D2yYbXSvPb/WhxhdBq1aof/xkKJFdTGOQlVGghhRPSPGK1e/reP+8uf+/bb02xUNA7TwDkdyP45FHU1WiqVycvmea7aRhUUcuzsT2NGmgtEFIj7RpofdSD9DeYWskmr53O1dC8v4FWz1dz6zSUoWFYCT8N16qBrtYYbx1A3JDXSgutJK60EMB95G1zqB1TGyRxp7nnElfZcBpoCoPEVeLHiTohUaV2TOFIFK5Lgs0/JURtqNo0hSlRW6ftQSUE87XwsVjBYwcQthH8VedZcaeJu4qzpKFPNTQScUJz1dQAKeyOvGYSYYo9pz1D3RJ/Cb0zzjjDLnBQEEv9lubLpSIbwwqK86go9JovothRauAVzkCrxPe9639xHgEgHmTLa+VHbUvJ7z4T7rGDwgFhBxC6Efz/hgNdFHVtHK44ckIxliTA2rX7c7WUBJOCWeocCTu3PY3mbGjxgiNZPMVsNtDaM9ltSr8xCDuAVFtyaUWzdmTwr8aUx0kLkhQfVatH9Z06Vdp/NhENJ8pbr10fFHMSoDxA2EHeKKZ5Volx5IQafQ1xaJsZLVzQllGKmO68bIq4rt0GtKJLQk8vBEVwl9BzYUsAoHBwG8ln6ql3XHrppTYQvYQdQHmBsKvAFJOwKrQ4ckJCTruBaJsXraLS0KcWO7gYi99882eQQU0EVtR0DWlomxoJP7ePIQAUDqNGjSr1dzqeesebb75pt/DSdAz9H6C8QNhB0VJewjQojpwYOHCg7blrH0H13LX9jnru2tJLw6BuBap/mEZz5KJuBwcAxeepF9oiS3Nr1SaowwdQniDsANKII6eVqFpxKsG366672mO77767FXXaVHr48OFsBwdQAT312diSCyATEHYAaURRd5trJ+7yoC3tnKeO7eAAipd0PfWZbskFwTB1KDoIO4A0oqhr70/10LU5tWJAqfeuBl4r5eThE2wHB1DxPPXpbskFkC0QdgBpRFFXdHLtR9y/f39z6KGHmhUrVlih9/jjj5vu3buXnM92cADx2fEliqc+3S25ALIFwg4gzY3gW7RoEbjThB+2gwMonuG87r++kXRLriie+nS35ALIFmwpBgAAEGFLLuep1z6r8tT/9a9/NU888cRGnnqAfILHDgAAIOKOL1E89X7YkgvKGzx2AAAAADEBYQcAAAAQExB2AAAAADGBOXYAAFlcXUmgVADIJwi7PEM0bQAAgNyyXQV61yLsAAAAIOfg6S4fEHYAAAAVgIrktarIIOwAihAaaAAACIJVsQAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxgTh2AGlCLDkAACg08NgBAAAAxAQ8dgAAABHASw/FAB47AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQg7AAAAgJiAsAMAAACICQUn7G644Qaz1157mdq1a5sGDRqYXr16mS+//DLwXM/zTLdu3UylSpXMyy+/XOq7efPmmR49epiaNWva37nkkkvMunXryqkUAAAAAOVPwQm79957z5xzzjnmww8/NG+//bZZu3atOfjgg83vv/++0bm33367FXWJrF+/3oq6NWvWmIkTJ5rHH3/cPPbYY+aqq64qp1IAAAAAlD9VTYExatSoUn9LkMnjNmXKFLP//vuXHJ82bZoZNmyY+eSTT8zWW29dymb06NHmiy++MO+8845p2LChad26tbn22mvNZZddZq6++mqz6aabllt5AAAAACqsxy6R5cuX23+33HLLkmMrV640xx9/vLnnnntMo0aNNrKZNGmS2W233ayoc3Tt2tX8+uuv5vPPPy+nnAMAAABUcI+dnw0bNpgLLrjA7LvvvuYvf/lLyfELL7zQdOjQwfTs2TPQbuHChaVEnXB/67sgVq9ebT8OiUChoWB9ROXKlU2VKlXsUK/y5nDHNYdP8/4cOqbvwo67302Gzqla9c/blDhHcJNNNolkLzRkrd9JzHsqkpUpk7y742XJu/Kt/Ecl6n0KQ7ZB9ylK3v35131KzHvQFIIoeY96/1zew+5f1LyH3b+o9oK6V7ruRUk7rI0oS97D6l66ea8IdU/nJWvL85F36t6fda8seV8XcP/Kkvd07l9QGx9U9zLREbEQdppr99lnn5kPPvig5Nirr75qxo4daz799NOsL9oYPHjwRsc1rKsFGGLbbbc1bdq0MTNmzLCLMxw777yzadmypZk8ebJZvHhxyXENATdr1syMHz/e/PbbbyXH27dvb4eX9dupGDlypOnevbtZtWqVeffdd0uOq8JoHmEUe1G/fn0rhmfPnu1bjJL69icrU5S0O3fubGrUqFGSD4fKFDXvWkjTpUsXM3/+fDsE/z+S5z/1fUpuv2TJkpL75H+oXJmi5N/dJ/2WPMkOlSkZpe9TUN1Lnnddq2R1L0reRVjdi2ovqHul616UtP1tRGLdi5r3sLqXKu/xrnupy56sLY+adljdS5W+//zgupe6/HGte1HSTvbOTYX/2gfVvSj13t9GBLd76euICRMmmKhU8qK4LvLAueeea1555RV7g7bffvuS4/Lg3XnnnaV6T1K++rtjx45m3LhxdpGEBKD/Is+dO9c0b97cTJ061V7UKB67pk2b2opZp06dnHnsWgxMLu5mX3twUo/ddv3fSGkf1ntIlfa3N/ZIWqYdr3wr7bzr+PYDRpYp74k9olT5nzPkkKT3KZX9N9d3S9pzjZr/MI9dsusXlnd3/6LmPez+Ra03YfcvSr11VLS6p7wnayOi5D2Z1yRq3sPqXrrPTRzqXpSyJ2vL85F3//2L8twUa91Llncd3+GKUZHzvi7g/jW//M3IeQ+6f1HqfS49dkuXLjX16tWz09OcJikaj50KdN5555mXXnrJijS/qBP9+/c3p59+eqljmk932223mUMPPbREnQ8ZMsQsWrSopIeoFba6GK1atQpMt1q1avaTiCpn4pCnLnSQazesNxl2PMpQqv+cKOenSiMs72GUtUy5zLsqd5ThkHTvUyIurXTynmiXrbxHvX8urahlTSSxzGW9BkHnU/eKO+8Voe65cwop79S9aEOp/rSrpnH/gspblmsQVtayPk+ZtHsl55oCHH4dMWKE9dbJFe3mxNWtW9e6trVYImjBhNybTgQqPIoE3IknnmiGDh1qf+PKK6+0vx0k3gAAAADiQMGtir3vvvusq/GAAw6wYUzc59lnn438G1LBr7/+uv1X3rsTTjjBnHTSSeaaa67Jad4BAAAA8knBeezSmfIXZKPJhhtPXAUAAACILwXnsQMAAACA9EDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABATEDYAQAAAMQEhB0AAABARRd248ePN/PmzUt6zvz58+15AAAAAFDAwq5z587mscceS3rOE088Yc8DAAAAgAIWdp7npTxnw4YNplKlSukmAQAAAACFMsdu9uzZpm7durlMAgAAAAD+n6qmDPTp06fU3y+//LL59ttvNzpv/fr1JfPrunXrVpYkAAAAAKA8hJ1/Tp2GWKdNm2Y/Qej7vfbay9x2223p5g0AAAAAciXs5s6dWzK/rnnz5uaCCy4w/fr12+i8KlWqmC222MLUqlWrLD8PAAAAAOUl7Jo1a1by/0cffdS0adOm1DEAAAAAKBJh5+fkk0/Obk4AAAAAID/CzjF58mTz8ccfm2XLltlFE0Fz7QYOHJhpMgAAAACQK2G3dOlS06tXLzNhwoSkMe0QdgAAAAAFLuwuuugi88EHH5gDDjjADss2adLEVK2asQMQAAAAANIkbSX2+uuvm3bt2pkxY8awuwQAAABAMe88sWrVKrP//vsj6gAAAACKXdi1bt06cNcJAAAAACgyYTdo0CDz6quvmg8//DC7OQIAAACA8p1jt3DhQtOjRw/TqVMn07t3b9O2bVtTp06dwHNPOumkdJMBAAAAgFwLu1NOOcXOr1OoE+0hq0/ifDt9p2MIOwAAAIACFnbaUgwAAAAACge2FAMAAACo6IsnAAAAACAmHrt58+ZFPnfbbbdNNxkAAAAAyLWw22677SIFJ9Y569atSzcZAAAAAMi1sNNK1yBht3z5cjN9+nQzd+5cGwpFAhAAAAAACljYKbxJGApzMmzYMDN06FDz8MMPp5sEAAAAAOR78YQ8eRdffLHZddddzSWXXJKLJAAAAACgPFfF7rnnnmbs2LG5TAIAAAAAykPYzZkzh4UTAAAAAIU+xy6MDRs2mAULFtg5eK+88oo58MADs50EAAAAAGRT2FWuXDlpuBMtoNhiiy3sIgoAAAAAKGBht//++wcKOwk+Cbq99trLnHrqqaZBgwaZ5hEAAAAAcinsxo0bl64pAAAAAOQA9ooFAAAAiAlZWTwxYcIEM23aNPPrr7+aOnXqmNatW5t99903Gz8NAAAAAOUh7CZOnGjn0X399dclCybcvLsWLVqYRx991LRv3z6TJAAAAAAg18Lu888/NwcffLBZuXKl+dvf/mY6d+5stt56a7Nw4ULz7rvvmtGjR5uuXbuaDz/80LRq1SrdZAAAAAAg18LummuuMWvWrDEjR440hxxySKnvLrvsMjNq1Chz2GGH2fOeeeaZdJMBAAAAgFwvntCq2KOOOmojUefQcX0v7x0AAAAAFLCwW758udl+++2TnqPvdR4AAAAAFLCwa9y4sZ0/l4yPPvrIngcAAAAABSzsNH9Ow7EDBw40f/zxR6nv9PegQYPsMGzPnj2zkU8AAAAAyNXiCQm6119/3Vx//fXm/vvvN+3atTMNGzY0P/30k/n444/N4sWLTfPmze15AAAAAFDAwq5evXp2KPbSSy+1q161OtZRvXp1G9/upptuMltuuWW28goAAAAAuQpQvNVWW5lHHnnEeuxmzZpVsvNEy5YtzSabbJLJTwMAAABAroXdkCFDzO+//24GDx5cIt7072677VZyjuLbXXHFFaZ27dqmf//+ZU0CAAAAAHK9eOKdd94xV111lR2GTeaR23TTTe05EnfEsQMAAAAoQGH3xBNPmC222MKce+65Kc8955xz7Pw67RcLAAAAAAUm7CZOnGgOOuggU61atZTn6hydO2HChEzyBwAAAAC5EHY//PCDDWESFe088eOPP5YlCQAAAAAoD2FXuXJls3bt2sjn61zZAAAAAEDuKZPq0vZgn332WeTzde4222xTpgyNHz/eHHrooTatSpUqmZdffnmjc2bOnGl3vqhbt66pVauW2Wuvvcy8efNK7XyhOX5awLHZZpuZI4880gZOBgAAAIgzZRJ2HTt2NGPHjjXffvttynN1js7df//9y5QhhVLZfffdzT333BP4/Zw5c8x+++1nY+VpS7MZM2bY3S0UFNlx4YUXmtdee808//zz5r333rNDyEcccUSZ8gEAAAAQ6zh28oJpletRRx1lRo0aZQMUB/Hzzz+bf/zjH2bdunWmb9++ZcpQt27d7CcMhVDp3r27GTp0aMmxHXbYoeT/y5cvNw8//LAZMWKE6dKliz2mPO+yyy52p4x99tmnTPkBAAAAiKXHrm3btuaCCy4wU6dONa1atbIx7RSnbvbs2fYjD5q8Z/puypQp1nMmm2yxYcMG88Ybb5iddtrJdO3a1TRo0MDsvffepYZrla7m9mlFrkPevW233dZMmjQpa3kBAAAAKPqdJ4YNG2aHPW+++Wa7C4U+fjzPM1WqVDEDBgww1113XTbzahYtWmRWrFhhbrzxRvvb2otWnkMNs0pgdurUySxcuNAGSN58881L2TZs2NB+F8bq1avtx6Ht0YREolswooUgKtv69eutyHS44/JQqvwOHdN3YcejLETROVWr/nmb9Dt+omzb5tLQfEX9TmLeU5GsTJnk3R0vS96Vb+U/KlHvUxiyDbpPUfLuz7/uU2LeVaZ08h71/rm8h92/qHkPu39R7QV1r3Tdi5J2WBtRlryH1b10814R6p7OS9aW5yPv1L0/615Z8r4u4P6VJe/p3L+gNj6o7mWiI3Im7JTZ66+/3px22ml2iFOx7ZxgatSokdl3333NKaecUmp4NFu4i9CzZ0/rDRStW7e2eRg+fLgVdulyww032G3SEhk9erSpWbOm/b+8fm3atLHz+vyLNXbeeWfrFZw8ebJZvHhxyXHlrVmzZnZByG+//VZyvH379tbbqN9OxciRI+3Q86pVq0rt4qEK06NHj0j2on79+qZDhw7Ws/rll1+6X0lpn6xMUdLu3LmzqVGjRkk+HCpT1LxrazoNq8+fP99MmzbNd0by/Ke+T8ntlyxZUnKf/A+VK1OU/Lv7pN/ye4xVpmSUvk9BdS953nWtktW9KHkXYXUvqr2g7pWue1HS9rcRiXUvat7D6l6qvMe77qUue7K2PGraYXUvVfr+84PrXuryx7XuRUk72Ts3Ff5rH1T3otR7fxsR3O6lryPKEhO4khfFdZEnJCJfeukl06tXr5I9aLUKdtCgQebKK68sOe+yyy4zH3zwgS24FmwceOCB5pdffinltdOF0TCyE4RRPHZNmza1FbNOnTo589i1GJhc3M2+9uCkHrvt+r+R0j6s95Aq7W9v7JG0TDte+Vbaedfx7QeMLFPeE3tEqfI/Z8ghSe9TKvtvru+WtOcaNf9hHrtk1y8s7+7+Rc172P2LWm/C7l+UeuuoaHVPeU/WRkTJezKvSdS8h9W9dJ+bONS9KGVP1pbnI+/++xfluSnWupcs7zq+wxWjIud9XcD9a375m5HzHnT/otT7XHrsli5daiN9aB2B0yRZ89jlEw2xKrSJX/2Kr776qqQ3tccee9gKNWbMGBvmROh8KeNkql07ZQTtqKHfShzy1IUOcu2G9SbDjkcZSvWfE+X8VGmE5T2MspYpl3lX5S5LXMSy3qdEXFrp5D3RLlt5j3r/XFpRy5pIYpnLeg2CzqfuFXfeK0Ldc+cUUt6pe9GGUv1pV03j/gWVtyzXIKysZX2eMmn3Ss41BYbm0H399dclf8+dO9e6N7XvrFyYl1xyiTnmmGNsGBW5hjXHTqFNtHBDKLadhokvuugiayNle95551lRx4pYAAAAiDMFJ+w++eSTUmP5Emji5JNPNo899pg5/PDD7Xw6zYk7//zz7bj0f/7zHxvbznHbbbdZ5SyPnYZXtYL23nvvzUt5AAAAACqssDvggANSrljs06eP/YShVbsKcBwW5BgAAAAgjrCRKwAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMQNgBAAAAxASEHQAAAEBMKDpht379ejNw4ECz/fbbmxo1apgddtjBXHvttcbzvJJz9P+rrrrKbL311vacgw46yMyePTuv+QYAAADINUUn7G666SZz3333mbvvvtvMnDnT/j106FBz1113lZyjv++8804zfPhw89FHH5latWqZrl27mj/++COveQcAAADIJVVNkTFx4kTTs2dP06NHD/v3dtttZ55++mkzefLkEm/d7bffbq688kp7nnjiiSdMw4YNzcsvv2yOPfbYvOYfAAAAIFcUnceuQ4cOZsyYMearr76yf0+fPt188MEHplu3bvbvuXPnmoULF9rhV0fdunXN3nvvbSZNmpS3fAMAAADkmqLz2PXv39/8+uuvpmXLlqZKlSp2zt2QIUNM79697fcSdUIeOj/6230XxOrVq+3HoTTE2rVr7UdUrly5JM0NGzaUnOuOr1u3rtRcPx3Td2HH3e8mQ+dUrfrnbdLv+Nlkk00i2YtKlSrZ30nMeyqSlSmTvLvjZcm78q38RyXqfQpDtkH3KUre/fnXfUrMu8qUTt6j3j+X97D7FzXvYfcvqr2g7pWue1HSDmsjypL3sLqXbt4rQt3Tecna8nzknbr3Z90rS97XBdy/suQ9nfsX1MYH1b1MdERshd1zzz1nnnrqKTNixAiz6667mmnTppkLLrjANG7c2Jx88slp/+4NN9xgBg8evNHx0aNHm5o1a9r/b7vttqZNmzZmxowZZt68eSXn7LzzzlZoajh48eLFJcdbt25tmjVrZsaPH29+++23kuPt27c3DRo0sL+dipEjR5ru3bubVatWmXfffbfkuCqMG45OZS/q169vvZ1aRPLll1+6X0lpn6xMUdLu3LmzXcDi8uFQmaLmvXbt2qZLly5m/vz59n7/j+T5T32fktsvWbKk5D75HypXpij5d/dJv+X3GKtMySh9n4LqXvK861olq3tR8i7C6l5Ue0HdK133oqTtbyMS617UvIfVvVR5j3fdS132ZG151LTD6l6q9P3nB9e91OWPa92Lknayd24q/Nc+qO5Fqff+NiK43UtfR0yYMMFEpZIXxXVRQDRt2tR67c4555ySY9ddd5158sknzaxZs8w333xjV8p++umn9oI4OnXqZP++4447InvslJYqZp06dXLmsWsxMLm4m33twUk9dtv1fyOlfVjvIVXa397YI2mZdrzyrbTzruPbDxhZprwn9ohS5X/OkEOS3qdU9t9c3y1pzzVq/sM8dsmuX1je3f2Lmvew+xe13oTdvyj11lHR6p7ynqyNiJL3ZF6TqHkPq3vpPjdxqHtRyp6sLc9H3v33L8pzU6x1L1nedXyHK0ZFzvu6gPvX/PI3I+c96P5Fqfe59NgtXbrU1KtXzyxfvrxEk8TGY7dy5cqNXOIquLtACoPSqFEjOw/PCTuJNK2O7du3b+jvVqtWzX4SUeVMHPJUekGu3bDeZNjxKEOp/nOinJ8qjbC8h1HWMuUy77rvUYZD0r1Pibi00sl7ol228h71/rm0opY1kcQyl/UaBJ1P3SvuvFeEuufOKaS8U/eiDaX6066axv0LKm9ZrkFYWcv6PGXS7pWca4qMQw891M6pkztTQ7HyzN16662mT58+JSpZQ7Py4rVo0cIKPcW901Btr1698p19AAAAgJxRdMJO8eok1M4++2yzaNEiK9jOOussG5DYcemll5rff//dnHnmmWbZsmVmv/32M6NGjTLVq1fPa94BAAAAcknRCTtNKFWcOn3CkNfummuusR8AAACAikLRxbEDAAAAgGAQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBMQdgAAAAAxAWEHAAAAEBNiLezuueces91225nq1aubvffe20yePDnfWQIAAADIGbEVds8++6y56KKLzKBBg8zUqVPN7rvvbrp27WoWLVqU76wBAAAA5ITYCrtbb73VnHHGGebUU081rVq1MsOHDzc1a9Y0jzzySL6zBgAAAJATYins1qxZY6ZMmWIOOuigkmOVK1e2f0+aNCmveQMAAADIFVVNDFmyZIlZv369adiwYanj+nvWrFmBNqtXr7Yfx/Lly+2/S5cuNWvXri0Rh1WqVLG/vWHDhpJz3fF169YZz/NKjuuYvgs7rt/dsHpl0rL8/PPPpmrVP2+TfsfPJptsEsleVKpUyf6OP++pbH/99dekZcok7zpe1rwr38q/I5X9L7/8kvQ+pbJftmxZyX1KzHuU9F3+7X1KyLvKlMw+LO/u/kXNe9j9i5r3sPsX1b4i1j3lPVkbESVtfxuRbt7D6l66z00c6l6Usidry/ORd//9i/LcFGvdS5Z3e7wMeV8XcP/Kkveg+xel3ie28YntXiY6QlpE+L8LxYshCxYsUMm9iRMnljp+ySWXeO3atQu0GTRokLXhw4cPHz58+PAxBfiZP39+Sg0US4/dVlttZVXuTz/9VOq4/m7UqFGgzYABA+xiC4eUtBRyvXr1rPIuD9Rjadq0qZk/f76pU6dOudrnM23suXfFal/Mea/o9sWc94puX8x5Txd56n777TfTuHHjlOfGUthtuummZo899jBjxowxvXr1KhFq+vvcc88NtKlWrZr9+Nl8881NPlBFyaSyZGKfz7Sx594Vq30x572i2xdz3iu6fTHnPR3q1q0b6bxYCjsh79vJJ59s9txzT9OuXTtz++23m99//92ukgUAAACII7EVdsccc4xZvHixueqqq8zChQtN69atzahRozZaUAEAAAAQF2Ir7ISGXcOGXgsRDQUroHLikHB52Oczbey5d8VqX8x5r+j2xZz3im5fzHkvDyppBUW5pAQAAAAAOSWWAYoBAAAAKiIIOwAAAICYgLADAAAAiAkIOwAAAICYgLArQFjPAgAAAOmAsCtAtIXZggULTCGgHTvyJTTzmbZLvyJf+3yS7/Sh4lHRO9T5LH++r70Xs3tPuJMCYtasWXaHjIkTJ5oGDRqYGjVqmL322ssceeSRZtdddy2XPKxfv96sWLHCCstWrVqV+k5VJdW+uVHOyVXamaa/evVq8+2339o9gtu3b7+R0KhcOXU/yD1O6eQhn+XPd9nznb72YJw8ebJZs2aN6dChQ6mte6Kmr/OUdjb2ls7mb6WbfpQyxzX9fFKRyw7ZAWFXQLRs2dJst912Zp999jErV640S5YsMTNnzjTr1q0z3bt3NxdffLGpXbt2qP3atWvNJptsknb6erHdeOON5rPPPjObbbZZyUvujDPOsAIzGdqurVatWmmLjEzSzkb6o0ePNtdff72ZN2+etfv5559N586dzXnnnWcOOuiglPYSJFtuuWXKBjosT/ksf77Lnu/0n3vuOTN06FD7vOm50+/pGTzttNMibUGonW0aNWqUMv1kL+w//vjDll/Pul/Ul0WsZtKpWbRokfniiy9sHfLXt2JJP920ZTd79mz7/OkeavtJ/96f5SHq83nts1H+dMue72u/du1a88knn5hx48bZ9+4uu+ximjRpYurVq2d/K1n6/uutDrnOy1cnLBAJO8g/Tz75pNe8eXPvl19+KTmm/7/33nveZZdd5jVp0sQ7//zzvbVr14b+xk033eSNGzfOW7x4sbdu3brAc1auXBlqv91223nHH3+8d9ddd3n33Xefd+WVV3r77ruv17RpU++EE07wvvnmm1Bb5e2RRx7xpk+f7v3222+B5/z66685STsb6W+99dZev379vGeeecYbNWqUN3z4cO9vf/ubV6NGDa9Dhw7eRx99lDT9I444whs4cKC1XbRoUeA57t5u2LChoMqf77LnO/2tttrKu+aaa7wxY8Z4s2bN8t58803vpJNO8jbbbDOvWbNm3iuvvJI0/b333tveo0cffdSbN2/eRt8rzSVLloSmLzvd51atWnm77rqr95e//MU+87Nnz/aisHz58sA0oxxz7Ua9evVs2roWW2yxhXfKKafYuhSFoGteXulnmvbFF19s09M11/2uXr2616NHD1uXopB4v5XO+vXrNzov6FghXPtMyp9p2fN97U855RR7zdu2bettueWWXpUqVby99trLtr9hNn6++uqrjdIPe++WNwi7AuH666/3/v73v4d+/9xzz3kNGzb0pk2bFvi9XoqVKlXyatas6bVv394bNmyY9+mnn9pG3z3Uv//+u31h6eWVyIgRI7ztt9/enuNYtWqV9+WXX9oXrSr/cccdV+p7f96Utl6C++yzj31gX3zxRe/rr7/2Vq9eXfJbXbp08aZOnZrVtLORvuxlu2bNmpJjumbLli3z3nrrLa979+5WaPz888+B6b/wwgs2fTUKeslLoN16663exIkTvRUrVthzlI8WLVp4H3zwQUGVP99lz3f6uk5KP6hB1nPSp08fb8899/QWLFgQmL7slX63bt1s+p07d/bOO+88KwadmFRnTCL17bff3sj+6aeftukPGjTIXouHH37Yu+iii7w2bdrYPOu4/9okoo7faaed5j3//PM2v3/88cdG56j87loEdShV9+699177W2PHjvVuueUWr127drYtOfnkk0PFshg9erR30EEHeTfffLM3fvz4jUSm7qXqXpD4zDT9TNN+4oknvB122KHk2s2ZM8f+X+KiatWqXqdOnbyZM2eGlv21117zdtxxR++cc86xdupQJ6avjrS/s56tsue7/JmWPd/X/vHHH7fpqzOntkXP2OTJk71TTz3Vq1WrlrfTTjt577//fmj6//nPf2w+ld+77757o/ZBwlDP3IwZM7x8gLArECZNmmQfZr2Ugl7gevFIsKmHF9b7OPPMM63HTuJNlVOfQw891Pv3v/9tH5ynnnrK23TTTQPt77nnHvviV0MQ1ohIWKrxSeSMM86wD8SECRO8/v37296nPBB6IQ8ZMsTaPPDAA161atWynnY20td1UWMaJh4+/PBD+3sSz0GocTnxxBO9jz/+2LvzzjutQNeLef/99/fOOuss60m77bbbbI+00Mqf77LnO/3XX3/d22233by5c+cG9vz1ctlll128O+64I9D+wgsv9I499ljrYZHIlKjTdVeZJPYkzK677jor7ILQC0zeOT/yuKpTJi+kRJ/ahDBUbyQsJRAkKpWePB7fffddSYdO9UfpBCFh8K9//avUMZV94cKF1pOoa5OYPz9du3b1Nt98c1ve/fbbz4pMdUaUfze68MYbb1iPdLbTzzRtdRouuOCCwO8ktOQxl7APQ3VN112/I1F/8MEH2+fvnXfeKelQvfzyy17lypWzXvZ8lz/Tsuf72h955JHe2WefXfK330OnZ0e/r3dnGIcffrhtZ/Su1b9qI9QOPPvssyWjYmpb5AXMBwi7AkIvAA3Hnnvuud6UKVOswHOVVD2CunXr2pd3InqIVakTG4GXXnrJNh6q3Ntss411e/fu3Tsw7S+++MIKSw2Jff/994HnHHjggd5VV121keBUvuVl8KMHTGJTD1/Lli2tyNRDkM20s5W+0pRLXkN6n332WaAbXg/5JZdcstFxnauXvoZC/aj3pxezXrzyJm2yySY2P4VW/nyXPd/pyzOonr88neqhB3nu/vGPf2yUhpBwkoetb9++pY5LDEpI68XkhJdeukHP7VFHHWWH3cO44oorbBl++umnjb6TR+Cvf/2rFcfy2EjIqiy65z179rSCVl5KCU2VIej6qVOgTxi33367HSoLGhZW+nvssYcVz/IEX3vttba90YtO9VUvbnkkdQ2ynX6maeveqU7pOiXmyQliedJ33nln22lIRG2z6ow6ZfKsS4ipHAcccIAVGr169fKGDh1qOxi6x9kse77Ln2nZ833t3QiZpnn4kdfOecfVGZLHXO1oIhJu6kTp+dJ7Wefo91Qedapbt25tO3jKY1j6uQZhVwC4l5kqldy6apjl5tUQnB5QPZiaf6PeSZi9xMEnn3xi/3Zi0P8g6OWvF0zQUKRDLwj1EjXsJ1ezhvKcJ+Xzzz8PFZbqYbr5BonDRvJCqUxKW2I122lnK3291PUgyrWuYWx5PtVzc98lS19puhdv4hxI3Qt5TJV+UCNVCOXPd9ld+qrfZU1fabj0E8seNX29ONXjl9dDnSoNkUlkCt0LdYjC0hdu+DOx/PpbQ0ZKX2IzCA3DSXhqaCjIa6m5lQ0aNLDPdyLffvutFZUqo0PCVENT8ijI06mXo9KX5zMInavvNcfQ77V0aChQwjtoSOnHH3+0w/4SF/62SC86tVvyuuy+++7298PmSaabfjbSlidb30sUBM1p05xUzX+TBywR3St1tOQhc0iU6BnTC1/PsURGsnuf72ufbvmzUfZ8X/tPP/3Uq127tm1zgqZo6JnWvDv3Tk3Mm4bM1Xnzo1ExTc2Qk0WiUukH2ZcHCLsCIfGlpJebGm252eVp0aT6H374IeXv+IeR9GJxHgi9ODRBNRk6V8NJGvJVpZR7WQ+JXrqaj3DMMcdELo9+y+VDXg15jILw51U9TKWVbtp+b49+L0r67prpo8ZG7vRtt93W9rrUK9P/NZSRrGcdlheXvhogeeQKsfyFUHb9q7kumh+nNOWFipJ+2ARnf9mTpe//Db1c5PHWC1HPnDwlumbqZAV5C5NNSvd7HvTi1XBZGMqrhuPUcdPQkOYV6gUhj4yEqbw2WlwSlneJOycIEzt08kaqU6hRgGTI6ylPj+6/Jo5LTGuxh4aEr776artwKwx1Gt38vcQ2TMfltQwbCvSnrzqnOl6W9PX7maYt4a72Tl7NSy+91A6laVK+OkvyoGsoPBku3URRL2EgL6/EdS7KXgjlz7TsSlvtmzyNmVz7xLL/ETF9TX9SuVX3jz76aCsK1YmWkNb8Rnm/k+Ge8UQvv/4eMGBA6HNbHhDuJM8oxMKLL75oPv/8c/Pll1+atm3bmhNPPNEuvfaHQqhevXrS30kMdaLbquXaVapUsf8OHDjQLse+7rrrIi0XV0yxp556yobf2HHHHW1+/v73v5dajh5lqbfycfPNN9twHIMHDw48R7HbFOLDn/YTTzxhQwC0aNEiNO0we5eu8pQq/aCy//DDD+aNN96w+WjatKldCq+wG1WrVt3IPspS9/vvv9/89NNP5qqrriqo8hdC2VX/t9pqq1KhQ5T+nDlzzLbbbps0/UT7oJAPydIPyr9+b8KECfZfhT3Yeuutzd577x2YdpTyP/PMMzacxfnnn7/Rdy6cwvLly81jjz1m7r77bjN37lzbBijsguJZ6t+zzjrLhr0J4/876CWhGRQyRc+98tWmTRuz77772t8OQ+3LK6+8Yh5++GHbBqnMKpvaJOWlb9++pnfv3qH2ya7LbrvtZjp16hSYviu/6qbu+SOPPGLrvNLXd1HS999z/V9pu7InS9t//vjx482zzz5rpk+fbu2+//57G0tS9U5pH3744UnTDSqTULgihS+54447clL2fJU/07L731kffvihefrpp82UKVPsMaWrNqis1z6x7B1SpO/yqvfb66+/bkOu/Pjjj/ZvxdRUe6vnrmvXroHpi6A8uGOyU9ii2267zeQDhF2e6dmzp32It99+e/siVUVXoGI9lIpbd9xxx9mXWlhMHb8wVEygPfbYwzYEionnZ9myZaZmzZpm0003Dc2L0nAvBX3KQqqYS0EPo8SDGhS9wL7++mv7Aj3iiCPsQ+XPU1gsIb+9hIBeYL169bIx0BKFcKo4T2oU9NG1Tic4aOLLNQqFUv58lF0N6JNPPmlj2OlFokZYsRqV/2222aZM9noR6Np169bNHHjggVYMl4VMy+92ySirra7Zr7/+WioY8rRp02xcPYk9Cfr999/f/OUvfwn8baUrUZ8o+F2dUdBlvRzVmZNADrJPFPYSdmPGjLFir1mzZmbPPfe0/wbhXqRh6DfUhukTlL5iBkrY1K9fv+SYnoO3337bfiebsPRlt2rVKivqg/KRKu0gG8URnDp1qr0u+l0FhZe4T6fsEgeKS6lYiBLn2Sx7vsufadkXL15cUna9j+SQUOdL4kpiL9W1d/ZbbLGFTUv/+p0aq1Okr3dcYkdRnS91qvQ7+uywww72fRlEkL0fleHBBx+0Gws0bNjQ5IW8+QrBDj9pHoGLUSb3u+ZOaDhGK/006f3BBx9M+huHHXaYHaqTO1srIzWko6E8za/Q0F6quDoaotUcjMQVmf6JpGW19Q9FJUPDbRp205DB5ZdfbiezatWuXOhyizsXf9iQW5i9XPiaV+bKHmZ/ww032FVjiaEgopQ9mb3SLfTy57vsGu5UfgcPHmyHoDTxWCtXNa9Fc1TcvLWwsofZa06SFiM4+7CyaHKzQi5ouDKs/MnKEWbvn4KQDA196xnXwgjNg9PqXi2AiIrfXsP2mlcVNFcoCqpnGsaNct9SDb1HxYW2aNy4sdeoUSO7eEZzBcNiMIbZ6qNhNM1RjTJVpdjLXkjlT6fsep/pudX0CE11UBumlfv//e9/y2yvqUUaSlVbFDaHNErZ00XPeqHErUsEYZdHNAFUgiwIxeXRC06VPywWTqbCUPM5tGJWedCL5bHHHtsodpBekJrcm9hoRLXVizcoBpheTMp7YuBWrXLSpGCJG5U/jEztlX8JYM3x0NJ2lVFzLhJXP+kF7ibyZ9M+n+XPd9nfffddK8ASw/qokdWcI80r0tywsPAvmdq7/GsenRasaMWqghIn5l+CWXNu0rVXRyvIXgJMYkwTrG+88UY7t08dMT1P+lcTsEXYyzaZvRZcvfrqq14ytBBDdSNoFbBEbbIg6Knsowh7hbPQ3EWtGNS8KnVCtKJR+decsGRtVjJbdXDdYoKwYLWaNK+5nFrUErTYJ1XZk9nnuuz5Ln+mZddzq+gMmv+mRQ0KR6J5nZqLpgVCWtmb7DeS2eujlanOfn1A2dVGaYGUOmSJgk5/uzLo3RuUj2T2bl6vs8+34EPY5RH10FWhJcSCUOXRcnUtnMiFMNQEVfX4FSpDca40iVSxt/SiUKgUhaJQZdZLLLE3mYmtUDw+Tdp1D4jfy6eXi7wwWrUUFiQyU3tNiO/YsaNdhamJsvq/fk+9X11vCST1ApX/oB0bMrXPZ/nzXXaFKVB9caJUZfB71uQJlGjVCySITO3l3VRICIVUUNy3Qw45xAol1WfVX62u04sjLP+Z2stDkxj+RPdPK3cVjkgvaCfugsjU3sW51H1TPC/dx0SPiQI8Ky5m0AsuU3uJkqAFMWqz1CmpX7++9VgHkYmty7s8u/J0K1yI4hAqr360AlqLGYJezpnaZ5r/fJY/07JLhKlOJKJnV3nWM6v3ShiZ2p900kl2BbpGNDQyoGuZ+O5Vp0nxAYMEbqb25QnCLo+oV6/KouFTRQ/XrhL+oS1FDFcPRauHciEMtQ2SCxIp75p6QGo0tFRcLyk9oIrLo5dYNm2Fwkko7+p1+vG/COQNUi8uF/byppx++un2/3oIJYA0JKAXlUSKhgjk+dFLOxf2+Sx/vss+f/5861FMrJf+XrYazbDVqJnaq/GXN86dLw+UhrJ0XGJF9VbDPGHhhTK1l6dNnuygfGtoVwJZz5ATrtm21ypMiQB1DnSuhrbkiZBIl+ddHvZ//vOfVqzmwl5xCRVWJsxTpFXC8oYGbc+Wia0bwtdQvQJeqwzydmkoXNdUQ3oKM6TVybqHubDPNP/5LH+mZdcoksSZfzccf4dM3naNMgXtjJQN+44dO9rRBYlRnasQRxJobrtOtam6thKuubAvTxB2eUZDVWoEtYWJGkiJJQ2vKMCieuYKkpgrYahe9siRIzc6rmFXhcjQi1peB3lAsmkr1KOTt0/iRI2BouX743gpNpkeGIVfyYW9hqzl2k9Ev6GI4eqNJst/pvYu/+phZ1L+dOzzWXYnPFXHJX4k/iQG/EP9CuEh4aYttrJtL+RBDpqTo+OKO6Xef7LyZ2qv7/Vc6kUYVDZNrdBzH7Z9YCb2incoD7uCugq3dZsCIasjoI6Zvlf+1VnLtr1QnEDV28QYY06gyvuk4caga5yJra6L5qbdf//99m8N5Wt48aGHHirplEoYKO9B+wNnap9p/vNZ/myUXW2U2muN6PhxwlTvLj23YXNNM7FfsGCB9XK7oW4JQh3TdCaNfEm0Kl6l8h80lSFT+/IGYVcg6CHRi1riTl4PPSTqAafaDDoTYShcj0cNgz/+l9BQloLD5sLWefokSNXj03wtzYtS9Hx5WvRy0LyhXNo73HwUv7dLD2ey2HfZsFdDpPzL26GGoaz5T8c+cWjM3buoec/U3o86HPKsybukOq8hDO0QoXwrnlyu7cPKpPyHbT+XDXsFntWkb3k7NJQrj6d/yFbDqMliTmZqr4DMGi5PRC8qdQTkiUgWey8Te10rCWB5XuTtUMdU+fXv6SmPUFD+M7F1KEaa4gQmsnTpUuuJkVcoWbuVib3Lv0Yz0sl/pvaZ5j/TssvDpveThjPVZkkkOq+yyqAOWrKyZ2IvdG6QJ1PvEXUG5YVMdu8ztS9PCHeSB7QcWjGLFD9H8ccUokTxpmrVqmW/V7iT5s2b22XXyUJ0+FGYhH//+982XIpu6S+//GJDQFx00UXmr3/9a1rhK4466igbjuGdd97Jqa3Kq2uhMigsi+IJdenSxYZq0HXItX0iWu5/9tlnm6VLl9rQE7m21zL71157zS73131TLLey5D9T+8R7l27Z07GfP3+++eCDD2y4HsWwUugTxYA64YQTTKNGjXJuH1SGQYMG2fALioGXK/uvvvrK3HfffTbvCvmgUEcKr6AwDmobDjnkEBt/MFf2/tAVyrM/fINCzqgtUhzLXNkrFMujjz5q3nzzTRuySeEzateubX9L9/Hoo48OjXuZiW0iiWGAlHeFClL8wVzZK0SN4ha++uqrNv+6f2XJf6b2qe5dlPJnYqu2WrHrZsyYYUOXKOxJtWrVbN099dRTzaWXXppT+2T3TuV54YUXTHnY5xKEXR5QbCFVzAYNGtgXoF5OCsZ67LHH2kq55ZZb5lQYOnsFxlQMLNkq1pFi7qhiujhFitejeFr+eEKZ2KZqGIR7UFORDXtdm7DYY/peL5DNN988q/aKUSXxLdGj7xSjTNdQcZuEBEGy2EeZ2Dvb559/3tYxxUlT8OmddtqpVJ1Llfd07R2qGyLx3in+lBroVGRqn+reSZjrJaGXZS7s/fz3v/+1z7GeWYlyXeMLLrjACvOwOFrZtPej5+nnn3+2HUIFyFZcxFzbK26e4jAqJqNEueKvnXPOObZNS3UvM7ENQp1CxZG86aabbFzFXNsr/qKCA8+cOdO+A1R/y5L/dO0Tg9m7OquOeKr8Z2LrF0LqfKszpnyrY6qYfH369LExKMNixGVqnwyJ5fPOO8/069fPtG7dutztsw3CrpyRKNpnn31sr0YvZL2EVTkVeVyR3/VCvOuuu8xJJ52UM2EYZC8hqGDIqpj+nQCyaSvUy0r0IK5Zs8Y+sIkNRnnZR9lBIFv2p59+ug1CKjGs3raun67lfvvtZy688EKz++6758w+yFaR7jt27GhfCKqPZU27LPYfffTRRrs4JN67ZME/c2Gv83XvnEhLFhA6U3u9iPXsTJo0yQpivQD0ewpOrjokUZZMDGbLXuXQC1CdAYlz/V8dRP9uCK6TmE17/zUT/vuU7LplyzaKKNc1TCaI07VX8GHtAKEdFlxnSO8B3b8oAjxb9gpALFu12QqCLxHm92xLINWoUSNrttkI5J1N+0oJAbnL0jHM1L5cyfdYcEXjuuuus3PCHP5l4ZozpZV1io2leTRBKC6WwlhoYrYmjLv9IjWBUxOq69SpYwMHh5HKXnME3KbiiXOHMrF1c3OqVq1q5z/JJjFEgmy04klBj4MCR+ba3s0bzJW9rp/mgGhJvBa+uPkpd955p11JplhUWmkYFuA5E/sotpqXmUnayey1Uk0Ti1VPNAk5cXK3u3ean6a5PHGz1ybvmguoUCSaC6n5cZqHpoVPWsnoX/gSRC7sNdlbbY326dSk+8TyZNNe85MUCsOP6op/VadsgsJkZGIbZu/O9+fT2UfJe1nsNS9NK4Q1D1arJxUpQCtXNRdU8+QUpiYZubDXfVPMQ81JTVyI4c9/JrZuEZcWU/jvjc7xz8nWvy6geCK5sA+Kc+diXkbJf1ns8wXCrpzRhG8tjPAHbvVHwNaqMy2XVhyyXAjDTOwzTVubWmtjdy320EIPvRw04V1BNl0QY4Wy0AtU/8bNXvG+NOnXkSj+tBBCK9pcwOls2uczbaGwKxKAEsT6HXUCtOBn4MCBVjS41ba6dkETlIvdXotatKrQXy9kp8UPWuWoHQi06i+MXNsrwGtY2KRs2EsU6NrommlxT2JICrUlahO1kjnxJZqJbRR7vaSdfVD8sUzt1V4oTIl/kYPai3vvvdfGY1RnWatdw8i1vZwBYfaZ2AoFr9e1U0BxLQYMEsiqR2o/gsRZsdvnC4RdOaPen4SdetpaQRZUGSTs3LLybAvDTOwzTfu4446zq5rUMKinpzhkioenBkLXQ8FVe/XqZf8fR/t33nnHRpf3Bw3W9XMeMHl6tLpXEdSzbZ/PtEXfvn3tThQS/RIHCouiVeDyPOjFJC+oVnqGXbtit1dHQOI4aHcHCQNtiaa6E9brL3Z7eXgU+09B050Y0bFbb73Ven6FYvOpc5BN20KwV+fPxR0M2oZK4kkx0vQuCLp2+bTPNG2FQdFzIs++npEqVarYzrGupVthqw6zPMFBFLt9vkDY5QEJAy1ZlwhSEFP1eseNG2eVvyqRImgn7sGZLWGYiX0mtnoRqGenQJZ+JAjefvttKwj0YlDvKGhbnWK3FxJB2ilE+zs+8MADJaLIj4ZXtLNCtu3zmbZeBhq+T/xOdVzb0GlPY/WGde0UAzFu9kKevj333LPUMyOB5K6j4mHtuOOOGw1txcFe0zUkENxWTOoAar9TxT/TC1FeH32vdk9iKVu2hWAvdFyizx8qRL/lrqXiDep7bRdWaPaZ2Gr3IYUjcu2hQvIozqOCHLuYdxLIEspBu2UUu30+QdjlCY3dK8invDwa2tFwhiqKovYrin2uhGGm9pmm7QjanF0vSF2DxD1A42SvF6EC+Kox1NCePAEK5KprqDhQEk7Jrl8m9vlM20/QPo6Kexj12hejveZBabhU4ihoqzPFhVPsuzjaK1C6YoypnvhRcGMJA4lheX3kDUnsMGRiWwj2QqJIu3U0b97c/lYi2rFAsdnCrn0+7TOx1THNOU2cj6rnR04CdQYU1Drs2hW7fT5B2JUj8u5o/9SpU6fanr6b/Ks5GzqmxjHVJOhsCMNM7dOxDXoZCv8kWAV4VGDdONr7f0M9P+3aoT1HNXynSejq9R1++OF2iC8X9vlMO2xDcj8azlBg2zja+xffKGi4hnI0pKfth3Qt1dvX5HTt1hJne//E90S0NZm2qMqVbb7t9dxohxgFFpaXT9dKniDNS5anW1M6CtU+07QdQUO1spUwrgj25QnhTsqJBx980AbV1JJxLdXfeeedbaiAAw880Bx22GGh8d78KEaZYvZoSbWWlWvZuZZ+z5kzxy6zV4gBhRsJC3eSiX220lYwTVU5hczwl1nHXnnlFbPNNtsExkEqdvugkAwK1aG4e7qeisFVt27d0DARmdjnM+0w+0TGjRtn4w+6eHxxsvejUCBjxowxY8eONR9//LGNQ6d6dNppp9mgyqpXcbb3Py/uuipMRqdOnUz//v3NkUcemVPbfNi7c/Wc6Hop9pyun0KXqB3t3bu3jQGn0EGFZp+pbbLwILp2PXv2tIHUDz/88NjZ5xOEXTmgoJ2K9aRYX2eccYYN5jhy5EjbQM6ePdsGmb3jjjtsPKrEaNbZEoaZ2Gc77VatWpmWLVvaAKY9evQwTZo0ibW9H91fF8Q56q4i2bLPZ9rOXp9041AVq72edQUP1rXTDhHt2rWzIlgdIl1Lxa5MFv8xLvaKQSfxq9hr/jZD8b+0Q42epWzaFoJ9EP64lwrirk5RWcinfaZpJwY7/uSTT0z79u0rpH1OKVf/YAXljjvusKtrghg7dqyND6UFCf4l5X40nq8hL03a1IpUxU9TvDIN/Wi+k5ajuzATQe7iTOxzmbbmbWg1nbMPGuYodnutmtNqUsUa03yUxEn5bojviy++KLXfZzbs85l2Knt/vDvZB9X9YrfXNTn++OPtVAXVIT3jetYPOeQQOyndHzokaKg3bvaal6l2UHNzFfNQCxPCyMS2EOzVFmjKSrrk076Y814I9oUAwq4cUMwfNQyaV+eCGfrjgOm4YiQpDlIuhGEm9vlMOy72mn+oxSb6V8E+9WLwB7HVC1ITlIM22M7EPp9pY/9n3EfFdRw/frz9W52C4cOH27mp+k0F+tUk/DDibK+5WZqbFmafiW0h2GveoQJIax6ifiNsUYnmKAYtxMqnfXmlrTm5QYHci92+EEDYlQOKyq5GQhNQXYTqxF5u+/btbZDDXAjDTOzzmXYc7LVLwZlnnmm9fQpuqVhoTZs2tTs1aKGFVtLefvvtXs2aNbNun8+0sfds3Ct9n4ieewXz1SIEF/sN+8JJOxv2Wkyi2H/q+Km+KDyGIghIILpYcGpbwjqN+bQv5rwXgn0hgLDLMW7IRsF9mzRpYlcVKQaSVsEKbc01YsQIu12Ti2CfbWGYiX0+0y52e8V60pCVP2ivGgbd85deesmGjVFEc3mDXBDQbNnnM23s/wyHI1EoAajhfDfE4w/wqrAhCnActjVdRbUv5rwLBbFWtAC3vaKG6gcMGOA1a9bMhsaQaFQQd9lrV4tCsi/mvBeCfaGAsCsn9KLQfptS+gpoWatWLSvmtC2V5mppa6JcCMNM7POZdhzs3X13240lzkPSC0TDGRIHCoaZbft8po29Z0MbKWiv5mc6geBHw7hqB7D/PlZ5V7ugTkHiFmsShhra0x6r2pIubOvBfNoXc94Lwb5QQNjlEHl7tI+o1L4iVCtyv+alyLujLZoU/FDufsWvS7V5cLrCMBv2+Uw7DvZqLIJeDuKaa64J3YooG/b5TLsi2+t5lvjTLiwK2q05O/ICvfvuu3axzYsvvmhfEnvssQf2BZR2NuyFAta6oLVBbbsW5CgWYCHaF3PeC8G+ECDcSQ7p06ePmT59uunWrZvZbLPNbNiTr7/+2ixYsMA0a9bMDB482IbOCGPJkiXm2WefNTfffLNdYq8YcVtssYUNN9CmTRsbbuCbb76xv69wKokhKDKxz2facbK/5ZZbbJiEOnXqmMaNG9vwMAqNoPhvipP00EMP2eN///vfs2afz7Sx35hly5aZxx57zIwYMcJMmzbNhoioXr26adu2rRkwYIDZZ599sC/AtLNhH4RiwrVu3dqceuqp5rLLLisq+2LOeyHYlxcIuxyhyyoxpzhICmDpjknYvf/++/alsHTpUvPCCy/YOHa5EIaZ2Ocz7bjZ165d29rPnDnTzJ8/3wrBiy66KGn8o0zs85k29n8GLpX486NnX8dXrFhhA72qTikmGvaFk3au7IPOee6558xxxx1nA54Xin0x570Q7AuKfLsM44riXmmCpfZYDEKuXoUM0GqbIOQC1mo7/x6FOqZNqLU/oSbsaygwaPJupvb5TDvO9tqS6ZFHHrH2CpGSGBstG/b5TBv7P9GeyZqXqVhnbrP0oBh57rexL4y0y8s+LDRSvu2LOe+FYF9IIOxyhIRbly5dvP3339/OywhqBIYNGxY6TyNTYZiJfT7Txp57V8z22itZE6u1Mbrm31144YU23qFi37mYX4qBpcDWM2bMwL5A0s6lvYLduuDlK1assEHdgzqF+bQv5rwXgn2hgbDLIRMnTrTBS7VE+sknn7QTsd2kTPUItJBC0c1zIQwzsc9n2thz74rZXrHv+vbtawMWK8itdq7QC0OLp2644Qa7olqev6pVq2JfQGlXdPtiznsh2BcaCLsco56dBFz16tVt3CsFtfznP/9pewUKgDh9+vScCMNM7fOZNvbcu2K0V89+yJAhNu6VHz3jWlWpMAlaTS2vwKmnnop9gaRd0e2LOe+FYF+IIOzKCbl0NT9LrlxtR6NQCQp+mEthmKl9PtPGnntXjPaagzNr1iz7f+1Qkujxk1CUJ2DatGnYF1DaFd2+mPNeCPaFBqti84BCJVSuXLlMNosWLTKvv/66efnll+3KHa2kPeqoo8wuu+ySc/t8po09966Y7d3zrma2SpUq5sEHHzT9+vWz4XKwL+y0K7p9Mee9EOzzCcKuggjDbNnnM23suXfFbC9uvfVWs379enPJJZdgX0RpV3T7Ys57IdiXNwg7AIByYu3atdYDkK5ArMj2xZz3Yrcv5rwXgn15g7ADAAAAiAnFIT8BAAAAICUIOwAAAICYgLADAAAAiAkIOwAAAICYgLADAAAAiAkIOwAAAICYgLADAAAAiAkIOwAAAICYgLADAAAAMPHg/wAcr1YMlpVgpAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -237,18 +237,18 @@ "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", - " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" + "{11: 0.1742, 26: 0.0396, 24: 0.0258, 22: 0.1728, 7: 0.0263, 13: 0.0122, 20: 0.1724, 19: 0.0198, 3: 0.0013, 21: 0.0131, 9: 0.1754, 16: 0.0044, 14: 0.0189, 5: 0.0393, 25: 0.0019, 12: 0.0198, 15: 0.0048, 17: 0.0216, 10: 0.011, 27: 0.0038, 23: 0.0046, 2: 0.0017, 28: 0.0018, 30: 0.0029, 1: 0.0038, 18: 0.0125, 31: 0.0017, 29: 0.0014, 0: 0.0015, 4: 0.0037, 8: 0.0042, 6: 0.0018}\n" ] }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "{9: 0.1756, 20: 0.1849, 11: 0.1806, 10: 0.0331, 18: 0.0266, 5: 0.0517, 22: 0.1818, 13: 0.0322, 21: 0.0282, 27: 0.0054, 14: 0.0025, 26: 0.0474, 0: 0.0019, 3: 0.0026, 24: 0.0044, 12: 0.0024, 1: 0.0056, 2: 0.0011, 23: 0.0005, 28: 0.0021, 31: 0.0033, 19: 0.003, 8: 0.0009, 17: 0.0024, 4: 0.0042, 7: 0.0063, 6: 0.0013, 16: 0.0008, 15: 0.0011, 30: 0.0042, 25: 0.0015, 29: 0.0004}\n" + "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", + " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" ] } ], @@ -270,7 +270,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Result bitstring: [0, 0, 1, 0, 1]\n" + "Result bitstring: [1, 0, 0, 1, 0]\n" ] } ], @@ -297,7 +297,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -336,10 +336,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "10100\n", - "10110\n", + "01001\n", "01011\n", - "01001\n" + "10110\n", + "10100\n" ] } ], From fe57828a7641b28b14cdc50a75045a0085649427 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 29 Jan 2026 14:42:20 +0100 Subject: [PATCH 10/20] Added validation on size of the graph Removed class level variables Removed unnecessary comment blocks Fixed comment which didn't match the method body removed name check in qasm variable declaration --- qbraid_algorithms/qaoa/qaoa.py | 68 +++++++++++++------------ qbraid_algorithms/qtran/gate_library.py | 6 --- 2 files changed, 36 insertions(+), 38 deletions(-) diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index fcc1074..15f0a88 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -5,13 +5,6 @@ class QAOA: - builder : QasmBuilder - mixer_hamiltonian : str - cost_hamiltonian : str - layer_circuit : str - use_subroutines : bool - use_input : bool - def __init__(self, num_qubits : int, qasm_version : int = 3, use_input : bool = True): self.builder = QasmBuilder(num_qubits, version=qasm_version) self.use_input = use_input @@ -28,9 +21,15 @@ def xy_mixer(self, graph : nx.Graph) -> str: Returns: mixer Hamiltonian subroutine name """ + if len(graph.nodes) > self.builder.qubits: + raise ValueError( + f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + ) + std = self.builder.import_library(lib_class=std_gates) - mixer_name = f"qaoa_xy_mixer_{self.builder.qubits}" + mixer_name = f"qaoa_xy_mixer_{self._xy_mixer_count}_{self.builder.qubits}" + self._xy_mixer_count += 1 qubit_array_param = f"qubit[{self.builder.qubits}] qubits" @@ -63,9 +62,14 @@ def x_mixer(self, graph : nx.Graph) -> str: Returns: mixer Hamiltonian subroutine name """ + if len(graph.nodes) > self.builder.qubits: + raise ValueError( + f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + ) std = self.builder.import_library(lib_class=std_gates) - mixer_name = f"qaoa_x_mixer_{self.builder.qubits}" + mixer_name = f"qaoa_x_mixer_{self._x_mixer_count}_{self.builder.qubits}" + self._x_mixer_count += 1 qubit_array_param = f"qubit[{self.builder.qubits}] qubits" @@ -94,9 +98,14 @@ def min_vertex_cover_cost(self, graph : nx.Graph) -> str: Returns: Cost Hamiltonian subroutine name """ + if len(graph.nodes) > self.builder.qubits: + raise ValueError( + f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + ) std = self.builder.import_library(lib_class=std_gates) - cost_name = f"qaoa_min_vertex_cover_cost_{self.builder.qubits}" + cost_name = f"qaoa_min_vertex_cover_cost_{self._min_vertex_cover_cost_count}_{self.builder.qubits}" + self._min_vertex_cover_cost_count += 1 qubit_array_param = f"qubit[{self.builder.qubits}] qubits" @@ -134,9 +143,14 @@ def max_clique_cost(self, graph : nx.Graph) -> str: Returns: Cost Hamiltonian subroutine name """ + if len(graph.nodes) > self.builder.qubits: + raise ValueError( + f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + ) std = self.builder.import_library(lib_class=std_gates) - cost_name = f"qaoa_min_vertex_cover_cost_{self.builder.qubits}" + cost_name = f"qaoa_max_clique_cost_{self._max_clique_cost_count}_{self.builder.qubits}" + self._max_clique_cost_count += 1 qubit_array_param = f"qubit[{self.builder.qubits}] qubits" @@ -178,9 +192,14 @@ def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : Returns: (mixer, cost) : tuple[str, str] mixer and cost hamiltonian subroutine names respectively """ + if len(graph.nodes) > self.builder.qubits: + raise ValueError( + f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + ) std = self.builder.import_library(lib_class=std_gates) - cost_name = f"qaoa_maxcut_cost_{self.builder.qubits}" + cost_name = f"qaoa_maxcut_cost_{self._maxcut_cost_count}_{self.builder.qubits}" + self._maxcut_cost_count += 1 qubit_array_param = f"qubit[{self.builder.qubits}] qubits" @@ -251,17 +270,17 @@ def generate_algorithm(self, depth : int, layer : str = "", param : list[float] Load the Quantum Approximate Optimization Algorithm (QAOA) ansatz as a pyqasm module. Args: - cost_ham : str - Name of the cost Hamiltonian subroutine depth : int Depth of the circuit (i.e. number of layer repetitions) layer : str Name of the layer circuit subroutine - epsilon : float - Error for expectation value calculation + param : list[float] + Parameters for circuit definitions, the number of parameters to provide is 2*depth. + The expected format is [gamma_0 alpha_0 gamma_1 alpha_1 ... gamma_(depth-1) alpha_(depth-1)], + where gamma and alpha are the coefficients for the cost and mixer Hamiltonians respetively Returns: - (PyQasm Module) pyqasm module containing the QAOA ansatz circuit + (str) qasm code containing the QAOA ansatz circuit """ std = self.builder.import_library(lib_class=std_gates) @@ -288,21 +307,6 @@ def generate_algorithm(self, depth : int, layer : str = "", param : list[float] for i in range(depth): std.call_subroutine(layer, parameters=[f"qb[0:{num_qubits}]", f"gamma_{i}", f"alpha_{i}"]) - #std.call_subroutine(cost_ham, [f"qb[0:{num_qubits}]", "1"]) - #std.h(self.builder.qubits - 1) std.measure(list(range(num_qubits)), list(range(num_qubits))) - """for q in range(num_qubits): - std.cswap(control=f"qb[{self.builder.qubits - 1}]", targ1=f"qb[{q}]", targ2=f"qb[{q+num_qubits}]") - std.h(self.builder.qubits - 1) - std.measure([self.builder.qubits - 1], [0]) - - std.begin_if("cb[0] == 0") - std.classical_op("measure_0 = measure_0 + 1") - std.end_if()""" - - """std.classical_op(f"expval = measure_0/{repetitions}") - std.classical_op("expval = 2*(expval - 0.5)") - std.classical_op("expval = sqrt(expval)") - std.classical_op("expval = log(expval)")""" return self.builder.build() diff --git a/qbraid_algorithms/qtran/gate_library.py b/qbraid_algorithms/qtran/gate_library.py index 6627d54..0b98d9c 100644 --- a/qbraid_algorithms/qtran/gate_library.py +++ b/qbraid_algorithms/qtran/gate_library.py @@ -404,8 +404,6 @@ def add_var(self, name, assignment=None, qtype=None): name: variable name Assignment: whatever definition you want as long as it resolves to a string """ - if name in self.gate_ref: - print(f"warning: gate {name} replacing existing namespace") call = f"{qtype if qtype is not None else 'let'} {name} {f'= {assignment}' if assignment is not None else ''};" self.program(call) return name @@ -418,8 +416,6 @@ def add_input_var(self, name, assignment=None, qtype=None): name: variable name Assignment: whatever definition you want as long as it resolves to a string """ - if name in self.gate_ref: - print(f"warning: gate {name} replacing existing namespace") call = f"input {qtype if qtype is not None else 'let'} {name} {f'= {assignment}' if assignment is not None else ''};" self.program(call) return name @@ -432,8 +428,6 @@ def add_output_var(self, name, assignment=None, qtype=None): name: variable name Assignment: whatever definition you want as long as it resolves to a string """ - if name in self.gate_ref: - print(f"warning: gate {name} replacing existing namespace") call = f"output {qtype if qtype is not None else 'let'} {name} {f'= {assignment}' if assignment is not None else ''};" self.program(call) return name From cf44b77d558873d78ca1b32195fc9ab4540646de Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 29 Jan 2026 15:33:52 +0100 Subject: [PATCH 11/20] Added references to Hamiltonian subroutine definitions --- qbraid_algorithms/qaoa/qaoa.py | 10 +++++-- qbraid_algorithms/qaoa/test.ipynb | 50 +++++++++++++------------------ 2 files changed, 29 insertions(+), 31 deletions(-) diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index 15f0a88..f7b6ae3 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -1,7 +1,5 @@ from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder import networkx as nx -import pyqasm -from pyqasm.modules.base import QasmModule class QAOA: @@ -15,6 +13,8 @@ def xy_mixer(self, graph : nx.Graph) -> str: Generate XY mixer Hamiltonian subroutine. xy_mixer_hamiltonian = $$\frac{1}{2}\sum_{(i,j)\in E(G)} X_iX_j + Y_iY_j$$ + + This mixer was introduced in From the Quantum Approximate Optimization Algorithm to a Quantum Alternating Operator Ansatz by Stuart Hadfield, Zhihui Wang, Bryan O’Gorman, Eleanor G. Rieffel, Davide Venturelli, and Rupak Biswas Algorithms 12.2 (2019). Args: graph : nx.Graph Graph that describes the problem @@ -56,6 +56,8 @@ def x_mixer(self, graph : nx.Graph) -> str: Generate X mixer Hamiltonian subroutine. x_mixer_hamiltonian = $$\sum_{i} X_i$$ + + This mixer is used in A Quantum Approximate Optimization Algorithm by Edward Farhi, Jeffrey Goldstone, Sam Gutmann [arXiv:1411.4028]. Args: graph : nx.Graph Graph that describes the problem @@ -92,6 +94,8 @@ def min_vertex_cover_cost(self, graph : nx.Graph) -> str: Generate min vertex cover cost Hamiltonian subroutine. cost_hamiltonian $$3\sum_{(i,j)\in E(G)} (Z_i \otimes Z_j + Z_i + Z_j)-\sum_{i \in V(G)} Z_i$$ + https://openqaoa.entropicalabs.com/problems/minimum-vertex-cover/ + As described in Ising formulations of many NP problems by Andrew Lucas [arXiv:1302.5843] Args: graph : nx.Graph Graph that describes the problem @@ -137,6 +141,7 @@ def max_clique_cost(self, graph : nx.Graph) -> str: Generate max clique cost Hamiltonian subroutine. cost_hamiltonian $$3\sum_{(i,j)\in E(\bar{G})} (Z_i \otimes Z_j - Z_i - Z_j)+\sum_{i \in V(G)} Z_i$$ + As described in Ising formulations of many NP problems by Andrew Lucas [arXiv:1302.5843] Args: graph : nx.Graph Graph that describes the problem @@ -184,6 +189,7 @@ def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : Generate cost hamiltonian and mixer hamiltonian subroutines. cost_hamiltonian = $$\sum_{E(graph)} Z_i \otimes Z_j$$ + This Hamiltonian is decribed in Quantum Approximate Optimization Algorithm for MaxCut: A Fermionic View by Zhihui Wang, Stuart Hadfield, Zhang Jiang, Eleanor G. Rieffel [arXiv:1706.02998]. mixer_hamiltonian = $$\sum_{i} X_i$$ Args: diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb index a402d74..9a3d401 100644 --- a/qbraid_algorithms/qaoa/test.ipynb +++ b/qbraid_algorithms/qaoa/test.ipynb @@ -142,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 18, "id": "df258b64", "metadata": {}, "outputs": [ @@ -153,10 +153,10 @@ " message: Return from COBYLA because the trust region radius reaches its lower bound.\n", " success: True\n", " status: 0\n", - " fun: -2.9066\n", - " x: [ 2.515e+00 2.679e+00 1.439e+00 4.172e+00 4.180e+00\n", - " 4.063e+00]\n", - " nfev: 34\n", + " fun: -1.9181000000000001\n", + " x: [ 1.314e+00 1.433e+00 1.545e+00 4.204e+00 3.998e+00\n", + " 4.483e+00]\n", + " nfev: 35\n", " maxcv: 0.0\n" ] } @@ -176,13 +176,13 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 19, "id": "e8596cb2", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -201,26 +201,18 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 20, "id": "103981ed", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", - " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "execution_count": 9, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -232,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 21, "id": "0d1cf38b", "metadata": {}, "outputs": [ @@ -240,7 +232,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{11: 0.1742, 26: 0.0396, 24: 0.0258, 22: 0.1728, 7: 0.0263, 13: 0.0122, 20: 0.1724, 19: 0.0198, 3: 0.0013, 21: 0.0131, 9: 0.1754, 16: 0.0044, 14: 0.0189, 5: 0.0393, 25: 0.0019, 12: 0.0198, 15: 0.0048, 17: 0.0216, 10: 0.011, 27: 0.0038, 23: 0.0046, 2: 0.0017, 28: 0.0018, 30: 0.0029, 1: 0.0038, 18: 0.0125, 31: 0.0017, 29: 0.0014, 0: 0.0015, 4: 0.0037, 8: 0.0042, 6: 0.0018}\n" + "{21: 0.0732, 13: 0.0668, 22: 0.084, 18: 0.0703, 23: 0.0061, 2: 0.0079, 30: 0.0355, 9: 0.0864, 11: 0.0829, 20: 0.0819, 26: 0.0424, 4: 0.0366, 5: 0.0382, 10: 0.0713, 27: 0.0349, 14: 0.0235, 1: 0.035, 19: 0.025, 6: 0.004, 29: 0.009, 12: 0.021, 31: 0.0054, 28: 0.0043, 17: 0.0238, 15: 0.0057, 25: 0.0041, 0: 0.0047, 16: 0.004, 8: 0.0059, 3: 0.0056, 7: 0.0002, 24: 0.0004}\n" ] }, { @@ -262,7 +254,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 22, "id": "ec6a816c", "metadata": {}, "outputs": [ @@ -291,13 +283,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 23, "id": "a6c223b0", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -328,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 24, "id": "76444240", "metadata": {}, "outputs": [ @@ -337,8 +329,8 @@ "output_type": "stream", "text": [ "01001\n", - "01011\n", "10110\n", + "01011\n", "10100\n" ] } @@ -350,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 25, "id": "ca9172e6", "metadata": {}, "outputs": [], @@ -367,7 +359,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 26, "id": "3a6a65a6", "metadata": {}, "outputs": [ @@ -386,7 +378,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 27, "id": "01920bcd", "metadata": {}, "outputs": [ @@ -413,7 +405,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 28, "id": "968c5412", "metadata": {}, "outputs": [ From 8687ce169332956c9c9c9c44e4d1e88957727e18 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 29 Jan 2026 16:11:07 +0100 Subject: [PATCH 12/20] Added some unit tests Fixed constructor for QAOA --- qbraid_algorithms/qaoa/qaoa.py | 5 ++ qbraid_algorithms/qaoa/test.ipynb | 62 ++++++++++++--------- tests/test_qaoa.py | 92 +++++++++++++++++++++++++++++++ 3 files changed, 132 insertions(+), 27 deletions(-) create mode 100644 tests/test_qaoa.py diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index f7b6ae3..3d5b792 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -6,6 +6,11 @@ class QAOA: def __init__(self, num_qubits : int, qasm_version : int = 3, use_input : bool = True): self.builder = QasmBuilder(num_qubits, version=qasm_version) self.use_input = use_input + self._x_mixer_count = 0 + self._max_clique_cost_count = 0 + self._xy_mixer_count = 0 + self._min_vertex_cover_cost_count = 0 + self._maxcut_cost_count = 0 def xy_mixer(self, graph : nx.Graph) -> str: diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb index 9a3d401..1d68161 100644 --- a/qbraid_algorithms/qaoa/test.ipynb +++ b/qbraid_algorithms/qaoa/test.ipynb @@ -142,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "id": "df258b64", "metadata": {}, "outputs": [ @@ -153,10 +153,10 @@ " message: Return from COBYLA because the trust region radius reaches its lower bound.\n", " success: True\n", " status: 0\n", - " fun: -1.9181000000000001\n", - " x: [ 1.314e+00 1.433e+00 1.545e+00 4.204e+00 3.998e+00\n", - " 4.483e+00]\n", - " nfev: 35\n", + " fun: -3.4163\n", + " x: [ 2.854e+00 2.644e+00 2.693e+00 2.873e+00 2.865e+00\n", + " 3.000e+00]\n", + " nfev: 46\n", " maxcv: 0.0\n" ] } @@ -176,13 +176,13 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 8, "id": "e8596cb2", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -201,18 +201,26 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 9, "id": "103981ed", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", + " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAcQZJREFUeJztnQn4VdP+/1ejlCZRGRpxhVBIEg1yJWPmmcqYWfdGobqZIpfimudrnomkGyqpZE5XiiS3DCGpRNJw/s9r+a/z29/T3ufs75nPPu/X85ynvvvsddZae6+99nt91md9VpVYLBYzQgghhBCi5Kla6AIIIYQQQojsIGEnhBBCCBERJOyEEEIIISKChJ0QQgghRESQsBNCCCGEiAgSdkIIIYQQEUHCTgghhBAiIkjYCSGEEEJEhOqFLkCxsn79evPtt9+aunXrmipVqhS6OEIIIYQoU2KxmPnll1/MlltuaapWTW6Tk7ALAFHXrFmzQhdDCCGEEMKyaNEis/XWW5tkSNgFgKXOXcR69eoVujhCCCGEKFNWrFhhjU1OmyRDwi4AN/2KqJOwE0IIIUShCeMapsUTQgghhBARQcJOCCGEECIiSNgJIYSIc+edd5pddtkl7obSqVMn8+qrr8a/79atm50O8n7OOeecCr/x3nvvmR49epgGDRqYhg0bmp49e5qPP/64ALURovyQsBNCCBGHFXfXX3+9+eCDD8z7779v9ttvP3P44Yeb2bNnx88588wzzXfffRf/jBw5Mv7dypUrzYEHHmiaN29u3nnnHTN16lTr8I24W7NmTYFqJUT5oMUTQggh4hx66KEV/r722mutFW/GjBlmp512ssdq165tmjZt6pt+7ty5ZunSpeaqq66Kh4waNmyYtQL+73//M9tuu20eaiFE+SKLnRBCCF/WrVtnnnzySfPrr7/aKVnHY489ZjbbbDPTtm1bM3jwYPPbb7/Fv9t+++1No0aNzP3332/++OMPs2rVKvv/HXbYwbRs2bJANRGifJDFTgghRAX++9//WiH3+++/m0022cS88MILZscdd7TfnXjiiaZFixY2Av6sWbPMZZddZj777DPz/PPP2++Zdp08ebLp3bu3ufrqq+2x7bbbzvznP/8x1avrlSNErqkSY58K4RsMsH79+mb58uWKYyeEKCuwtC1cuND2f88++6y57777zJtvvhkXd14mTpxoF0p88cUXZptttrEWOhZYtGnTxpx//vnW6vfPf/7TTtGyqGLjjTcuSJ2EKBdNouGTEEKICtSsWTPuC7f77rtbQXbLLbeYu+++e4NzO3bsaP91wu7xxx83X331lXn77bfje1pyjNWxY8aMMccff3yeayNEeSEfOyGEEElZv369Wb16te93M2fOtP9uscUW9l/87RB03gj57m9+RwiRWyTshBBCxGExxJQpU6zVDV87/sZn7qSTTjLz58+3fnOEQuH7l156yZx66qmmS5cudtUr/PWvfzU///yzOe+888ycOXNsmJS+ffta/7ru3bsXunpCRB5NxQohhIjzww8/WLFGfDp8ehBsLHxAsC1atMi8/vrrZvTo0XalLOFMjjrqKHPllVfG0+Nb9/LLL5vhw4fbBRhY69q3b2/Gjx8ft+oJIXKHFk8EoMUTQgghhCg1TaKpWCGEKKMtwRyM6Xv16mV931588cX48YceemiDLcPcB2ueEKK40VSsEEJEcEswYsch3v7973/bLcE++uij+M4RwHSqd4GD47jjjrNbgnnp06ePjWnXuHHjvNRBCJE+EnZCCFFmW4KxkvWmm26ye8Em+r0RZ84ba+7HH3+0serYPUIIUfxI2AkhREQhOPAzzzxTYUswwpGwe8Ttt98euN+rl4cfftjuDXv00UfnocRCiEyRsBNCiDLaEuySSy4xe++9t52eDQOWOoSgdowQojSQsBNCiIix/fbb2+lWtyXYaaedZrcEY3cIplXxtwsDu0cQi+6RRx7JeZmFENlB4U4CULgTIURU2H///e12X1jdbr311vhWX266lr/33XdfG4jYy+mnn24+/PDD0EJQCJEbtFesEEKIDbYEI2jwGWecUeG7nXfe2YwaNWqDRRcrV640Tz/9tBkxYkSeSyuEyATFsRORJdN4XrBw4UJz8MEHW+dxQj0MHDjQrF27No+1ECJ7W4KxWKJt27YVPtC8eXPTqlWrCr/z1FNP2bZ+8sknF6gmQoh0kMVORJZM43kxRYWo42U4ffp0u8USWy3VqFHDXHfddXmujRCZbwlWGVg0ceSRR5oGDRrkrKxCiOwjH7sA5GMXTTbddFNz4403Wt8hwMH8kEMOicfzYvVg79697XdY9/ju22+/NU2aNLHH7rrrLnPZZZfZ2F41a9YsaF2EEEKUByu0pZgQG1rfnnzyyUrF82JFIP5HTtRBz5497QM2e/bsvJZfCCGECIOEnYg0+BgRx2ujjTYy55xzTqXieS1evLiCqAP3N99l4t939tlnx1cpbr755rYMc+fO3eB32LeT36lVq5b18TvvvPPSug5CCCHKA/nYiUiTrXhe2fbv23333a0zO07rS5cuNf/4xz/MAQccYBYsWGCqVatmf+Pmm2+22z4xddyxY0drbcQhXgghhAhCPnYByMcumlQmntfQoUPNSy+9ZIWhA+HVunVrG9urffv2Gfn3eZk1a5bZddddreCkfD///LPZaqutzMsvv2x69OiRYa2FEEKUMvKxEyJFPK9BgwZZMYVocx8gnteDDz5o/8/0KVO5rDJ0vPbaa/ahctO56fr3eeE4eRJuolmzZvF8KOs333xjdthhB2sBPPbYY82iRYuycBWEEEJEFU3FishC/C7i0zHd+csvv5jHH3/cWuII/cBiCb8FE954XkyNIuBOOeUUM3LkSOtXd+WVV1o/N3z2MtmvE+644w5z6aWXWmHHlDFizq20/fLLL62wI6zKLbfcYkdq5E3ICgSpVuQKIYTwQxY7Efl4XogmpjPfe++9SsXzwtdt7Nix9l8EGoFa+b2rrrqqUv5977zzjunfv7/17/v000/j3+Njh88dPn9/+ctfrEUOEQiIujVr1tjpYlbi7rXXXuaJJ54w8+bNM5MmTUrzigiRe7KxcOjCCy+0fqgMoNq1a1eAWghRushiJyILAVYrg5+7aYsWLcy4cePSyh+r2rbbbmv/z0sKYYn17e6777bHsMLxYYEFwq1hw4bWqnfCCSfYmHrgtfDxEtxss83sbhhCFCvZWDgE/fr1s4MiLNRCiPBI2AmRZ/8+P3gB8nHfd+7c2f772Wef2Rcl8BJcsmSJFZtCFCuJe85ee+211oo3Y8YMK+zOOuus+HctW7Y011xzjV04xIpvLHmApRoIBC5hJ0TlkLATIs/+ffjPsQ8nVgqscF9//bW1cDA1ddBBB9n0TM1i5bjooovMPffcY6e0+M02bdqY7t27F7p6ooxpOeiVpN9/df3BFRYOPfPMM5VaOCSEyAz52ImC+NpgfbrgggusHxqCBgGEXw1Lub3BednD1e/jXalaav59BBt+6623rIhjqva4444zdevWtfvREoTY8fDDD9v4dexX27VrV7tH7fjx4+2/QpRqYHC3cIjv+dAneBcOCSEyQ3HsAlAcu8whBhs+M15fG+K44WvD38OGDTN9+vSxHf7//vc/+wJACBJIGFatWlVB6AHns8AA65cQojgtdn/88Yf1BXWBwe+77z67SMiJO44z+Pnuu+/MP//5TxvWZ9q0adZ6x4DQBeKmD2Ygg5WbwSB9xoQJE+xvY+1mX+err77anueFQSEBvj///HPbfx9zzDF260AhykGTSNgFIGGXG5IF6WXKhpWnTM9Ur76hlwD+NgTtZVEEIUiEEMU9FZsYGNwtHPKCCGThEOIPC553MEg/geDDAhhmMJhsx5bDDjssS1dAiOLWJPKxE3khla8NuAbrJ+rc1GTt2rXN0UcfnePSCiEKsXCIFeFecGN4++237cILRN5zzz0X/w6hyMIMBoNr1661/QY7thDvMXHHFsSfEOWChJ3IKamC9DpY7cmUinfFXCJY6k488UTrkyeEiObCIWBrPQZ6U6dOtaKwQYMGNiYkfYfXFy9xMJi4Ywv577333taCp8UZolyQsBM5xQXpdb42BOn1+to4EzMLBDhGTCs/GLXPmTPHPPLII3ksvRAi3YVD+M8xdYS1zC0c+vbbb+3CodGjR1vrWpMmTUyXLl0qLBxiMEhQYgSaw1npiXVHiJSgwaB2bBFCq2JFjnFBeglKOmLECBuvig7XwYj6wAMPtKtCseYFrfjE/4bOnt8pBzJdUfzxxx/baS2sFJyD9cJ73YXIFVjW8WljahWR9/rrr8d3e9lyyy1twO/vv//e+tax9/Fjjz1m27KD/xO/8f3337d7OhOUe/bs2Xa61om6oMGgdmwRQsJOFNDXhs6ZKRnE30svvWTDgPixcuVK8/TTT/suuIh69P4PPvjAvuD2228/G9eOFxxWDz6sJvzkk0/sCkDCoHivD+mwgDz66KM2zRVXXGGnyG677baC1kvkXtSX+pZcmQwGtWOLEBJ2ke/g6cwY2bLogBf9wIEDraNxPkBITJkyxY7emV7hb3xt2E7IiToWUzDC5+/FixfbDwstvOCTQ5lxki6n6P34HLE6kGDFOInjo4gTedu2ba0TOefgQI7o43scxt29ZTsmXobEv2vdurW9dn379jXPP/+8KQVKve0XUtQ7aAPESCynwSArZYG24doNg0KmbVl5G+V2I4RDPnYluucif7sO3rv0n2Nu6T8CiQ6qadOm1ocFnxd8Xxjh4oNSSF8bBB77QILbT9Xh9aMBhN+RRx5pHajLkWysKHbnEG6mFCj1tp+rLbnCrAwt5S25ki28cKLut99+s5Zo/ubjrHKEScHKx/Sr87+bOHGiOf744+3OFlwrpmWj2m6EiEMcO7Ehy5cvJ76f/beYaNiwYey+++7z/e7pp5+O1axZM7ZmzRr797hx42JVq1aNLV68OH7OnXfeGatXr15s9erVeSuzSI9Zs2bF6tSpE6tWrVqsfv36sVdeecX3vB9//DHWvHnz2OWXXx74W9OmTYtVr1499p///CdWquSr7d9xxx2xnXfeOVa3bl372WuvvezvOe6+++5Y165d7Xf0ET///PMGv/HZZ5/FDjvssFijRo3seZ07d45NnDix0nVeu3Zt7IknnrB1mz17tu859957b2yzzTbz/W7YsGGxXXfdtcKxFpeNTfpJRabpk9GvX79YixYtbH0333zzWI8ePWITJkyw302aNMleb7/PggUL4r9Bn83vNGjQILbpppvGatSoERs5cqRvfuozRRQ1iaZiSwRGkk8++WSlrDasJN15553tyjMHDsWMcpnWEaWxohjLZv/+/e2K4k8//bTCOWFWFDNlh7WL4K5YPEqNfLf9ZFOhgMUIH6/LL7888DcOOeQQa0HDYsTv4CfGMVwNsrElV2XCBEVl4UW3bt3iMe8SP14LP+2A3+HasNsEWxDyjPihPlNEEQm7AvoKARu802HxHR3QsmXLfDt4fEqYbqET69y5s91KJ1UHz0vE20GB+zvsC0aU9opihCCBWmkXhH0oJTIRN5m0/WT+jXDxxRfb1ZpM+flBeViFyTk8+/wOQhFBiMjOp6gvRwrVboQoFiTsckymo386eNLXqVPHbstDh4W/EYF6Hergy4PKriimjXXv3t2KAsRJqVEM4iaMtTCRRo0a2bKzUwrpsNyxlRaO+GHD9WQrTFA5UgztRohCosUTBXSE3mmnnezoH4I2ta9ataoVdqNGjbKO04i7V155Jb7nYrIOHgfgd999t8LvET/KfSei60SOZYhBBNNIAwYMiFsb+I5zSgEnbgCB895771lxk4+2H3bHFD+wvDOFiFWdsvEMI+pYvcrKzGyIeu4rFqlkYYLKlUK2GyGKAVns8kg6o/8PP/zQbo/Dy6F9+/Y2avvYsWPtizuV1YY8eEHhq+Jgyx2mfcO+pERhcCuKsT4wlcrLya0opk1gjeDe8gIjdpf7EPAVWOXHikiEn/f7Dh06mHKwWGba9sNYfYLAXeK8886zYo7nFaGAyGOQxyrLfIQJYksuys/xVatW2f/zIShwuZHPdiNEUZCX5Rxlvio2zOpGt+LLu8Ju0KBBsaFDh9rjTZs2jR1xxBGxKlWqxLp162ZXCO6+++529d4XX3wR++677+IfVtIB/7Zt2zZ2wAEHxGbOnBkbP368XWk2ePDgUOXOdHUgK9VYndayZctYrVq1Yq1bt7b10eoykQra/ptvvmnbEM8Pf9P2WSHJM9mxY8fAtu/aLasbeeZ22WWX2NVXXx1v++m021atWsVOP/30lM8svP766zbvxL5j2223jY0YMSIvK0OpX9A5xbwqtpDtJht9ZqaUcp9bymWPmibRVGyR7JfqB6NGRpXACJ3RJlYb9lbEGoDfXrI4cEy7Yd3D4sBIFD898r7qqqsyjiXGNLLzD+SDVSGRuXPn2tEyUyCUESvjmWeeaetCLKlC03LQK0m//+p6/5V0whR1DETXbgkwy0pg4pENGTIk3vbZfaOy7Za9St3iiVTwXABWdi/87d3/NAgscUG4laGpCHLt+JPoru7MNHZmpn1mppRyn1vKZY8aVVB3hS5EMYKIomNwy+GzCX5yBMt0Ph9Ap4OjOxtjewPxsr8hvlJM6eyzzz7x4x07drS/k2+neALc3njjjRUi3QeV3Q/S4mPIZt2FRsKufKhMu/Xzb7zhhhvs6kgEg5v6ZDEULx6mTfHX4nzyYbVlmzZt7K4fQ4cOtbsc3HvvvdbPiyl1FkKUcrvXc5NfSrnPLeWyl7ImkY9dgX0+UuH2e2RTbAebXON/06JFC1PM/oGlvvuBKH3Sabd+/o3sXrDVVlvZ7++66y7r74qoAyzo/O2s6+xLykIJ9jhmULbHHnuYqVOnmjFjxhRc1InSoZT73FIuexTQVGwBVzeCG/3j7Aw47npH/yhzYjExpdSsWTMr5hjFwDHHHJPz8meyOjAR6vivf/1LZnVR1O02cSqUdssAy7VbwmMkC5GBhYEPgy9gGgrLHf0AUKa//e1v9sXHAI8VrnfccUeF+GmISeLg4W7BKts999zTjBw5UsKwDCjlPreUyx4lJOwK6PPhRv/Dhw+Pn8/oHx588EHTp08f+3+EHJHRTznlFLvCjWlYItqnGzohH/6BibCyF98KxKizdJQ7yaa0NJ1Vuu02la/RJZdcYkMWsf8vfcL5559v90KeNm2aTY+ljzwPO+wwK/iIg8fADgHIqmfFrIs2pdznlnLZo4SmYgu4RQ4w8vfbIseJOqAjZ9RCPCXm2Vl+zwsiH6QKlBoGNtnGp2Lvvfe2O20IEeV2m2znCl549Ak333yznaalfAziWODhFmfgRL506VLrsM+LkmcdYcfzz8b1Itpk0nbdTkdu1of2dsQRR8S/x5JGKB6CaNMmjzrqqHicPi8PPfSQ/R3CwbBQjzS5Lnumz12qXZ5+z3HdiwkJO5Ez/0A38mIln3uBJa4UFCLK7TbR14ipVXxkWfjkYKEFL2H2KQXEHC8fBCBx57DS8/8ddtihwp6oojyoTNvFWvz3v//dth8sXmeccYYVdm6nI6zFL7/8srUWY0lDRGEt9sKg44orrrCuAKTDGIG1ONdlz/S5S7XL0yV5rnsh0VSsyJl/oHtI8QvE4kjAXEcpRHHPhq8U/lGJPPHEE9YZX0S33Qb5GjFNhVUjcTUgbcbtDkJZKC9BjdnLFLD+UX63Wb2IJpm23d122822XaxmWLsI34K7D+kRPgwQ+E1EDyCeGDBgLWbvY1aqsqc0AoiFQw4sWMX+3CXb5WnrHNe92JD5RKS1+0GY1YFMGfMQv/HGG/bB8u6AkE/TOvz000+2DAitZcuW5W0E6DoQfCzdhxd2rin0tSvndpvpzhVY6AgP0blzZ/vSwfeubdu2dm9TvhPRJRdtl2eWAWgYazHpsbIhshA9/Maxxx4b39Gm2J+7TCzlr2VQ92JDcewKEMdOhAPRxIjT64TOQhLnhM4LEyd0fCKcEzqme+eE7gUxxbQW4sbFT0onHpeLy0TAWvZcZQTI/51vFB0CHQUjQEAMYa3xE3O5XDyR62sn0otdedxxx9mXXuJ1xErBvtEMFrAsXH755XYQ4KaiuP4sluK7TK29hY5jpzh4uSXRWkwfhc8n//bt23eDqVFWXOPTRqxGBrLMSrRu3dr6xtE3YMX6+uuvzaxZs6y1uZiJct1XKI6diAKZOqF7rVeMWvE9SZd0RoAOLGPENqMTeeCBB0LtHBClayf+z9eIa81iKKwSDmJULly4MB7viwj9CDrvNL77O8zOFaK8ycRaTPuiX7v11lutawkDVFxH5s2bZ4PlFzvlXHcvEnaiJEhXWPFQs7rw4YcfTssBnhEggogg0cQTdL5S+Iqk8pUC8n766aetmZ/pznPPPdfGZiqHa1eu4GvEbhT4ZtJ++Btfo5NOOsmOuJlmHTBggH1ZcC+wJHBfnJWXqSssegwI5syZY6f+OQf/OqwLonjJhgvEhRdeGA9M365du0qXIWhlKn5qWH4T3SnI3/mwuWlPb3gSZiYYmDL4KHbKue5e1FuLoiYTYYWF5IQTTrBTkIiWfI8AgT1K8ZXCl+Syyy4zl156aTzAdNSvXbmSytdo1KhR5pBDDrEvdfyMeLE8//zzFUQ2U+lM/yAM9t13X+u/yW4W6fgbifyRLb/cfv362Wn7fFuL6avccQehd9gmL587HWWL9ZWouwslxHPrRDmDclf3MKKc38MXln2qCZUycOBAG4cy32iJlSgYYXxtggJehgFLCT5vJ598csYjQKBz4CXNCJBO140AvQLJOwL0g+DSrHSsTAiAdCn0tStXEneuSIT4WLfffrv9BIEI9Ma7FKVBpiszgalAYFUo4r4yJFuZ6rUWu12NLrjgggrWYtw2EKIXXXSRXVXLOfwmg41itxZnWvfdd9/d/h8hRx/NJgD4s7Zq1crWHUtqssDizIwg6uj/cWvBR5YBHoLyuuuuy+u1kLATRU0mwooHE6sVogacbxumdWIVGbNnVkaAjNz8RoB+ILRwgseKVsrXzrtbihD5pFQWX/CiRwSEdYFwAiOXOx1hLcatgj7LG6LJC64XWBYRKZzbtWtXay0u9h1PMq37oYceautK3Zmd4VzcH5jtwO81lSifMGGCnc0h9h2zH0yjIxCZqWEjgnwuvqhaSj4KmIRR2VgiNt54Y/tAoKKxSBSjOVQU1rT+3HPPmY8//tiKKT733XefPf7WW2+Fiiaeqa8UUy7k+cknn9hl/LRtRm604ahfOyHKlUz9cnO505GzFvMuRXDiAuAGc/ikdejQwWy11Va270LkYHniHPYph/nz59uAx/ie8X4mHIh3OpL+kUU+fh8Glrkkk7o7qBO/g9WOcyk3WiKMXzL/7rzzzhXimCIeWc3qpuLL1mKXbJ9F/sYngeCFPCjMifPgcMxZForJHCoKa1onvIQXHlZglBUmZEemI0DaHJ0DI0DaLtYzVqLmY+/DQl87IcqVTFwgCgllZNCGuMMQQsidAw44wFqh6tSpY8UQf7MgAYu+8yHG0oXVir6QbcDoL71wDoPIPfbYwxQ7/80gsDj/ekWd+959V9bCLpmPAi8jLAkOXj58jx8QDRGzaTGZQ0XhpxUK6SvFlj58yvHaCVGuZNsvN18w3eqFGJfMeGGtYpEPvmRYxDCyuDhqGF5wLUHoYc2i7t66YOUaM2aMHTj67cJTbGxfoqK86IVdMh8FP1ywPrfVTpA5lDlzzKGsThTl44Tuhe1qohKPO6Wfka6dEEVBpn65hcK5OGHVB+qAOPP6B9OPMECcOnVqhWlKB7tKsHMNbipRF+VNmzY17777boXfc9PU+Rbu1UvJHJqIW71y1llnxY+law6l0XpXKjIv7kYcfIAGTDR/BKc3UKg7jtXQ+/LjGN8FHXe/63DiNNEfMOg4nQTloDwOHjzO5zhTzy+++KLtPPBJxEzOMaa5HQsWLLDWTB5M6o+pffTo0TasgqsTOw+wOgsrEKMzHmAspd7QC+nWKRnut7x18qtr0P0Ie5+CIG0u71MywtYpVdkL1fZycZ8K/TwVS51aDR5nkjHv6gOS1ikVuW57qXB1DrpPYdMX4j6xsAgrPSspcYF49NFHrQsEqynx+SaMCS4Qzoec3UZwf+Dj7hP+uCtXrrQuRmwh9+GHH9rjvAMRHvmoE7AylncGVizqx4p+pmTxWee9SxrqS36UNbGt0vbwzeWdwjuY74vxeUrWR5Av94AZDyfK8THkuBPlTF0D14f3IluSYemkTsQv5T7zzs2GjihpYRdkDvWKO4QXvnQcY4o1U3Ac9Vvpx9QuDyTgr4TFD5HjDVhIeXGkRK17Ny5mGpj4Nzjg85A7EK3ceH7be7NYUo0AGzeuYsfNDgI0Lm/0axoe9W99+f8Fv0zk+6dfMGce0tlePxoXMXkQZUzDMdJCOLOjAA0Tyw3Tdm7VD4KQa0udeChZ2o2oI4YPPo74b3l9FtOpUypcGjaKpkzs2Ue7cODAS8dDZHBv3KXw9yl582fgkK37xG95g/9Sp2SkrlPysnOtct32/OqUm/u04fPUb0LyPVNv6bS25OoU9j6lwtU3qE6p2k6u217Y8gfdp7Dp/e7TRW8nTz++zzYZ3SdEGFOYvLtwgWDwO2zYMGvtoVzEheSFTpgMXvRcV7cYyd0nxJLX2R7LEdx99922L85H26PMxOGjj3fXk7bHTgyI09tuu80KF2Iskid18l537hO+eFwX3jG578srd58c3j7ikUceMbvttptd+Y8/IKIc3cG1YBqadyeinHpjELn33nttObi34PaXJUYl71zEGbqCkCnehWrp1slvu8eS3ivW7bNIwwZuGNOrCK6xY8dakeJgrzfMv95Gw01g/zceuqCpWD+LHSuBeNicP0ExWhhSTcm50TuNkWj2NG4aGQ8kowl8GjnOSIw60SFxDiuRucZ+ZeeaY8VjVOmWwKdTp7CWh1yN8rYbMiFp/l9e1yunlqBtr/xPYN7zrz0waZ3Clj2q1q1k1861nVKrU74sdqnaTq7bXtg+K+g+pcrfW//E+xSm7uVuLcaKyDuU9wSWR7+y817kb6YleU8ieFgk5oVFkOyyg1+ee08U4/MEnM/MH4MIr1/y3/72t/gUM4aQQYMGWXGLVsBfmfoh3l2dvvzyS+tPiCDknYrAw4rntVSnWydW82JYCbNXbFFa7IJ8FJzgQnAwz0/j84o6p8y5kEwbutGhM4f6Tec6+D2/2GI0yMT4PVxoZ672EjSaDDoeFBeosseT4U3jfCa4LhynYTmfCVcnRlQ0IkaOXOfEstO4HnvsMTu6cpbMfJQdKJffVE7Q/ajsfUrE5ZWN+xRU9iAqWye//DJpe4w0CQcwd+7c+DQ+G2UzqvQOmBiNu2l8pqDo6LAquPxdiCLCJ7jFGvis4GKR7ecpqH7ZuE+Jx5OJE+Ko5bqPyMZzU6i2V9nyV/Ya+J0ftuzunEL05WHbXrb7PXccMcGzymwN08del53Esjs3HBZN8K4lcoW3TvwWcd5YwOX3nshXnSpzPyhvMlyUgyC/ZOqDf553C7lk5KLfi5fFFBnJYoch6pivZzEFjvX8jd8cH6f++R4Bd8opp9g4XKwEvPLKK625Ox9BYYtZHDMSY8uYtm3b2mP4dTCqwMeOAIxcV17UXMvEJeucw7mMGDAfs9JJRBcX+oDV6AyMGOm6Zw9c6AMGBnTuTBMwJYEF2DsK5bllWonfwNLLs+31iRWimHCx3BjgMgBmZsI7NQi8b3i/4BBPn8j0nTdaAzA7hEUHixZ9Jm2eGY5ihued6Ufccai/e7cyHe5A/NAnEM+Oc4855hhrqfMO+IA+gYHfGWecUYCaiKKz2CUL04DAY89OcCtXHDSili1bxqcKWQWL9c6ZQ9nMvJyjqPPQEigX64rXr4FVx1wrtrFhxMH+oHRUiaMpHGYJN0PsQHwRuUdc51JYwi4KE/qADez5HVaWuRhWWPTwncJPc8sttyxI3YRIN5Yb0PexOpIZI/yxEEIE6sUnDVcfFhLQ/llJiS8aBggG1X369InHWy1GCCvmVsB7QcxRdkDkYmzBEs/7Fn/AxClYwPCClR+fMZF/qpdSiIuwIRdwNEx0mC5nWPjgrCU4d3qh02L05fWZYCSKT6IXOjA+7CWIkyh+FYzcinGZviiO0AdM59OevIFJOc45DNBYXSZEKQ1ogMD3iKA99/xzS0JmhFiQxjkIO/paN23nBsh33XWXNVKw4jXRKFEshHm34jfHJxWIXVE4im4qVmT3QUXUES4GK4rXETYRRBsvYeczcdhhhwWe66ba8rGRvSjdaXymcRJXQTJ4QBzmOxK7ENkY0ACWqKeeesparXg2nnzySetY7yxd9IuEJfHOeuCnCt4ZEyFyhYRdhFn62p0Z+0xgWWE6gVXGTMMi/JiuZZWyrHXlgZvG5wWWOI3PoggWQuA2wfSU3zS+EFEZ0ABho/A5xXcOi/XZZ59tB8/OEkc4D/pZQpvgd0rUAVZTQqLvshBlMRUrssfKj8Zl7DPBiiZWRxLLB6sMq6FY/cj0w/bDXs+Lf6AozWl8/o/11wt+S7S1Qm+hlC/fVlG6+Pklu71PGcSwbSUzHawixcfurbfesrse7bTTTtbflBAg9K34fV944YUVVouXa7tNtZpcZAcJuwjT4rKxKR+WVD4TdFRuw+cN+b9YgSJauNAHWCJYtJRqGh8Sp/Gx6PICxPfIBVnlHCwhRGkXotQGNAxkmMFA8CHggEC8iDp86vClgxNPPNF+2FIKlwX8UW+++eYNfJeFyAUSdkIIX2sFU/iEtXHT+MCUq/MXwvLLQhqmZVkowRZE3ml8vsO6e+aZZ9oXHtNXvDCJxK4VsaIUBzT4k0Ki5Q2rnN92a247ywceeMAuLiK6gxC5RsJOCJGz0AcEs0bM9ejRIx6gmNA6QpTigIbwHfjS4VdHyB787JiKdXEaHVj1WGSB/ynfES6KmRHvBvJC5AoJOyFEzkIfsJpQoQ+i5SdVzgMawpgQSovFEATjJugwQg+fOu/+1+z3iV8y3yMG2Q6ToMZC5AMJOyGEECLkgIatthJ3mkjk4YcfzmKphKgcEnZCCCFEGVDO1uKWZVR3CTsh0qScOgohhBClgYSdKFkkrNJH104IIaKJQsQLIYQQQkQECTshhBBCiIigqVghhBAiD8gFIpgRI0bY7Svnzp1rYwYSB/CGG26IBzz/6quvAnfAYf9e9jn38tNPP9ldQb755hu7X285IYudECInnXSHDh1skNfGjRub3r1724DGDjpptlny+zzzzDPxjpmdK9ilgs3WmzVrZoMdr1ixooA1E0LkgjfffNMGiJ4xY4YN6sxONexHzR7lwPP/3XffVfgMHz7cBoHu1avXBr93+umnm1122SWrojzZp5iQxU4IkbNOGnG3du1ac/nll9tO+tNPP7V7Z7pO2ss999xjbrzxxngnzU4Vhx9+uLnmmmvstmVffPGF/U12ujDNTypQzYQQuWD8+PEV/n7ooYfsoJC9prt06WK3bWvatGmFc9j67dhjj7XiLjHQ9LJly8zQoUPNq6++asoNCTshRFF20g0bNjT9+/ePf9+iRQtz7rnnWvFX7SQJOyGizPLly+O71/hBXzJz5kxz++23Vzj+6aefmquuusq888475ssvvzTliISdEKJoO2kv3377rfXB6dq1q5mas5IKIQrtI7h+/Xpz8cUXm86dO5u2bdv6nnP//febHXbYwfriOVavXm1OOOEEO/hr3rx52Qo7+dgJIXJKup20g466du3aZquttjL16tUz9913Xx5KLYQoFLhcfPLJJ+bJJ5/0/X7VqlV2D2r86LwMHjzY9iMnn3yyKWck7IQQRdlJO0aNGmU+/PBDM2bMGDN//nwzYMCAHJdYCFEoWCA1duxYM2nSJLP11lv7nvPss8+a3377zZx66qkVjk+cONEuvqpevbr99OjRwx7fbLPNzLK3HjPlgqZihRA576SnTJlS6U7agS8enzZt2tip3H333ddsdV4nU30T/2ldIUTpEYvFzAUXXGB9bSdPnhwY2sRZ+A877DC7qMrLc889ZweKjvfee8/069fPvPXWW+bYx8tnWlbCroxRTCVRzJ100LSuZd2abBZXCFEEln0s91jmCZO0ePFie7x+/fo2rp2D1fEMFMeNG7fBb2yzzTYV/l6yZIn9l+nZanWWmnJBwk4IUZSdNMe+//57GzKFlbKzZ882AwcOtL56X9dvktf6CCFyCyFKoFu3bhWOP/jgg6ZPnz7xvx944AFr/Sd8kvBHPnZCiJx00qyEpZPeYost4p+nnnqqwnnJOmkE4L333mv22WcfO+K+5JJLrGWPqV0hRPSs/H4fr6iD6667zixcuNDGuUxFt27d7G80aNDAlBOy2Akhsj6NT2caBjppPn50797dTJ8+Pa3yCSFEuSJhJ4QQQoRAfsmiFNBUrBBCCCFERJCwE0IIIYSICBJ2QgghhBARQcJOCCGEECIiSNgJIYQQQkQECTshhBBCiIggYSeEEEIIEREk7IQQQgghIoKEnRBCCCFERJCwE0IIIYSICBJ2QgghhBARQcJOCCGEECIiSNgJIYQQQkQECTshhBBCiIhQvdAFEEIIIYRIRstBryT9/qvrD85bWYodCTshRN5RJy2EELlBU7FCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRISiE3YjRowwHTp0MHXr1jWNGzc2vXv3Np999pnvubFYzPTq1ctUqVLFvPjiixW+W7hwoTn44INN7dq17e8MHDjQrF27Nk+1EEIIIYTIP0Un7N58801z3nnnmRkzZpjXXnvNrFmzxhxwwAHm119/3eDc0aNHW1GXyLp166yo++OPP8z06dPNv//9b/PQQw+ZoUOH5qkWQgghhBD5p7opMsaPH1/hbwQZFrcPPvjAdOnSJX585syZ5qabbjLvv/++2WKLLSqkmTBhgvn000/N66+/bpo0aWLatWtnrr76anPZZZeZf/zjH6ZmzZp5q48QQgghRNla7BJZvny5/XfTTTeNH/vtt9/MiSeeaG6//XbTtGnTDdK8/fbbZuedd7aiztGzZ0+zYsUKM3v27DyVXAghhBCizC12XtavX28uvvhi07lzZ9O2bdv48UsuucTsvffe5vDDD/dNt3jx4gqiDtzffOfH6tWr7ceBCASmgvlA1apVTbVq1exUL2VzuOP48OH35+AY3wUdd7+bDM6pXv3P25ToI1ijRo1Q6YEpa34nseypSFanTMrujlem7JSb8ocl7H0KgrR+9ylM2b3l5z4llt3PhSBM2cPeP1f2oPsXtuxB9y9selDbq9j2wuQd1EdUpuxBbS/dspdD2+O8ZH15Icqutvdn26tM2df63L/KlD2d++fXx/u1vUx0RCSEHb52n3zyiZk6dWr82EsvvWQmTpxoPvroo6wv2hg+fPgGx5nWZQEGNG/e3LRv397MmjXLLs5wbL/99qZNmzbm3XffNT/++GP8OFPALVq0MFOmTDG//PJL/HinTp3s9DK/nYpx48aZgw46yKxatcpMmjQpfpwGgx9hmPSw+eabWzE8b948z2KU1Lc/WZ3C5N29e3ez8cYbx8vhoE5hy85Cmv32288sWrTITsH/H8nLn/o+JU+/ZMmS+H3yPlSuTmHK7+4Tv4Ul2UGdklHxPvm1veRl51ola3thyg5BbS9selDbq9j2wuTt7SMS217Ysge1vVRlj3bbS133ZH152LyD2l6q/L3n+7e91PWPatsLk3eyd24qvNfer+2FaffePsK/30tfR0ybNs2EpUosjOmiAJx//vlmzJgx9ga1atUqfhwL3q233lph9ITy5e99993XTJ482S6SQAB6L/KCBQtM69atzYcffmgvahiLXbNmzWzDrFevXs4sdtsNSS7u5l19QFKLXctBr6RMHzR6SJX3V9cfnLRO2175n7TLzvFWg8dVquyJI6JU5Z9/7YFJ71Oq9F9e1yvpyDVs+YMsdsmuX1DZ3f0LW/ag+xe23QTdvzDt1lFubY+yJ+sjwpQ9mdUkbNmD2l66z00U2l6YuifrywtRdu/9C/PclGrbS1Z2jm9zxfjQZV/rc/9aX/5q6LL73b8w7T6XFrulS5eaRo0aWfc0p0lKxmJHhS644ALzwgsvWJHmFXUwaNAgc8YZZ1Q4hj/dqFGjzKGHHhpX59dee6354Ycf4iNEVthyMXbccUfffDfaaCP7SYTGmTjlyYX2M+0GjSaDjoeZSvWeE+b8VHkElT2IytYpl2WncYeZDkn3PiXi8kqn7InpslX2sPfP5RW2rokk1rmy18DvfLW90i57ObQ9d04xlV1tL9xUqjfv6mncP7/6VuYaBNW1ss9TJv1e/FxThNOvjz/+uLXWYYp2PnH169e3pm0WS/gtmMC86UQg4VEQcKeccooZOXKk/Y0rr7zS/rafeBNCCCGEiAJFtyr2zjvvtKbGbt262TAm7vPUU0+F/g1U8NixY+2/WO9OPvlkc+qpp5qrrroqp2UXQgghhCgkRWexS8flzy8NzoYbOq4KIYQQQkSXorPYCSGEEEKI9JCwE0IIIYSICBJ2QgghhBARQcJOCCGEECIiSNgJIYQQQkQECTshhBBCiIggYSeEEEIIEREk7IQQQgghIoKEnRBCCCFERJCwE0IIIYSICBJ2QgghhBDlLuymTJliFi5cmPScRYsW2fOEEEIIIUQRC7vu3bubhx56KOk5Dz/8sD1PCCGEEEIUsbCLxWIpz1m/fr2pUqVKulkIIYQQQohi8bGbN2+eqV+/fi6zEEIIIYQQ/5/qphL069evwt8vvvii+eqrrzY4b926dXH/ul69elUmCyGEEEIIkQ9h5/WpY4p15syZ9uMH33fo0MGMGjUq3bIJIYQQQohcCbsFCxbE/etat25tLr74YnPRRRdtcF61atVMw4YNTZ06dSrz80IIIYQQIl/CrkWLFvH/P/jgg6Z9+/YVjgkhhBBCiBIRdl5OO+207JZECCGEEEIURtg53n33XfPee++ZZcuW2UUTfr52Q4YMyTQbIYQQQgiRK2G3dOlS07t3bzNt2rSkMe0k7IQQQgghilzYDRgwwEydOtV069bNTstuvfXWpnr1jA2AQgghhBAiTdJWYmPHjjV77rmneeONN7S7hBBCCCFEKe88sWrVKtOlSxeJOiGEEEKIUhd27dq18911QgghhBBClJiwGzZsmHnppZfMjBkzslsiIYQQQgiRXx+7xYsXm4MPPth07drVnHTSSWa33XYz9erV8z331FNPTTcbIYQQQgiRa2HXp08f619HqBP2kOWT6G/HdxyTsBNCCCGEKGJhx5ZiQgghhBCieNCWYkIIIYQQ5b54QgghhBBCRMRit3DhwtDnNm/ePN1shBBCCCFEroVdy5YtQwUn5py1a9emm40QQgghhMi1sGOlq5+wW758ufn444/NggULbCgUBKAQQgghhChiYUd4kyAIc3LTTTeZkSNHmvvvvz/dLIQQQgghRKEXT2DJ+/vf/2522mknM3DgwFxkIYQQQggh8rkqdo899jATJ07MZRZCCCGEECIfwm7+/PlaOCGEEEIIUew+dkGsX7/efPPNN9YHb8yYMaZHjx7ZzkIIIYQQQmRT2FWtWjVpuBMWUDRs2NAuohBCCCGEEEUs7Lp06eIr7BB8CLoOHTqYvn37msaNG2daRiGEEEIIkUthN3ny5HSTCiGEEEKIHKC9YoUQQgghIkJWFk9MmzbNzJw506xYscLUq1fPtGvXznTu3DkbPy2EEEIIIfIh7KZPn2796L744ov4ggnnd7fddtuZBx980HTq1CmTLIQQQgghRK6F3ezZs80BBxxgfvvtN/PXv/7VdO/e3WyxxRZm8eLFZtKkSWbChAmmZ8+eZsaMGWbHHXdMNxshhBBCCJFrYXfVVVeZP/74w4wbN84ceOCBFb677LLLzPjx481hhx1mz3vyySfTzUYIIYQQQuR68QSrYo8++ugNRJ2D43yP9U4IIYQQQhSxsFu+fLlp1apV0nP4nvOEEEIIIUQRC7stt9zS+s8l45133rHnCSGEEEKIIhZ2+M8xHTtkyBDz+++/V/iOv4cNG2anYQ8//PBslFMIIYQQQuRq8QSCbuzYsea6664zd999t9lzzz1NkyZNzPfff2/ee+898+OPP5rWrVvb84QQQgghRBELu0aNGtmp2EsvvdSuemV1rKNWrVo2vt0NN9xgNt1002yVVQghhBBC5CpA8WabbWYeeOABa7GbO3dufOeJNm3amBo1amTy00IIIYQQItfC7tprrzW//vqrGT58eFy88e/OO+8cP4f4dldccYWpW7euGTRoUGWzEEIIIYQQuV488frrr5uhQ4faadhkFrmaNWvacxB3imMnhBBCCFGEwu7hhx82DRs2NOeff37Kc8877zzrX8d+sUIIIYQQosiE3fTp083+++9vNtpoo5Tncg7nTps2LZPyCSGEEEKIXAi7b7/91oYwCQs7T3z33XeVyUIIIYQQQuRD2FWtWtWsWbMm9PmcSxohhBBCCJF7KqW62B7sk08+CX0+52611VbplEsIIYQQQuRS2O27775m4sSJ5quvvkp5LudwbpcuXSpbJiGEEEIIkWthx0pXplePPvpos2TJksDzfvrpJ3PMMceYtWvXmv79+6dTLiGEEEIIkcsAxbvttpu5+OKLzejRo82OO+5ozjnnHNO9e3ez9dZb2++/+eYb88Ybb5h77rnH7hU7YMAAm0YIIYQQQhThzhM33XST3Qv2xhtvtLtQ8PESi8VMtWrVzODBg80111yTzbIKIYQQQohsCrsqVaqY6667zpx++uk2+DCx7RYvXmy/a9q0qencubPp06eP2WabbSr700IIIYQQIp/CzoFwk0VOCCGEEKJ4UJA5IYQQQoiIUHTCbsqUKebQQw+1MfOY9n3xxRc3OGfOnDnmsMMOM/Xr1zd16tQxHTp0MAsXLox///vvv9sVvI0aNTKbbLKJOeqoo8z333+f55oIIYQQQpS5sPv111/Nrrvuam6//Xbf7+fPn2/22Wcf06ZNGzN58mQza9YsM2TIELugw3HJJZeYl19+2TzzzDPmzTfftFuhHXnkkXmshRBCCCFECfnY5YpevXrZTxBXXHGFOeigg8zIkSPjx7wLNZYvX27uv/9+8/jjj5v99tvPHmORxw477GBmzJhh9tprrxzXQAghhBCiMBSdxS4Z69evN6+88or5y1/+Ynr27GkaN25sOnbsWGG69oMPPrBBlPfff//4Max7zZs3N2+//XaBSi6EEEIIUYYWu2T88MMPZuXKleb666+3K3JvuOEGM378eDvNOmnSJNO1a1cbeqVmzZqmQYMGFdI2adIkHpbFj9WrV9uPY8WKFfZfRCIfqFq1qo3Rt27dOisyHe44O20Qx8/BMb4LOu5+NxmcU736n7eJ3/FSo0aNUOkBf0V+J7HsqUhWp0zK7o5XpuyUm/KHJex9CoK0fvcpTNm95ec+JZadOqVT9rD3z5U96P6FLXvQ/QubHtT2Kra9MHkH9RGVKXtQ20u37OXQ9jgvWV9eiLKr7f3Z9ipT9rU+968yZU/n/vn18X5tLxMdEUlh5y7C4Ycfbv3ooF27djaW3l133WWFXbqMGDHCDB8+fIPjEyZMMLVr17b/x+rXvn1769fnXayx/fbbW6vgu+++a3fccFC2Fi1a2AUhv/zyS/x4p06drLWR307FuHHj7NTzqlWrrHh10GAOPvjgUOlh8803N3vvvbeZN2+e+eyzz9yvpEyfrE5h8mZnko033jheDgd1Clv2unXr2mn1RYsWmZkzZ3rOSF7+1PcpeXq2zXP3yftQuTqFKb+7T/yW12JMnZJR8T75tb3kZedaJWt7YcoOQW0vbHpQ26vY9sLk7e0jEtte2LIHtb1UZY9220td92R9edi8g9peqvy95/u3vdT1j2rbC5N3snduKrzX3q/thWn33j7Cv99LX0dMmzbNhKVKLIzpokCgeF944QXTu3dv+/cff/xhV8EOGzbMXHnllfHzLrvsMjN16lRb8YkTJ5oePXqYn3/+uYLVjgvDdmhOEIax2DVr1sw2zHr16uXMYrfdkOTibt7VByS12LUc9ErK9EGjh1R5f3X9wUnrtO2V/0m77BxvNXhcpcqeOCJKVf751x6Y9D6lSv/ldb2SjlzDlj/IYpfs+gWV3d2/sGUPun9h203Q/QvTbh3l1vYoe7I+IkzZk1lNwpY9qO2l+9xEoe2FqXuyvrwQZffevzDPTam2vWRl5/g2V4wPXfa1Pvev9eWvhi673/0L0+5zabFbunSpjfTBOgKnSSJhsWOKldAmXvULn3/+eXw0tfvuu9sGxZ61hDkBzkcZJ1PtG220kf0kwm8lTnlyof1Mu0GjyaDjYaZSveeEOT9VHkFlD6Kydcpl2WncYaZD0r1Pibi80il7YrpslT3s/XN5ha1rIol1ruw18Dtfba+0y14Obc+dU0xlV9sLN5Xqzbt6GvfPr76VuQZBda3s85RJvxc/1xQZ+NB98cUX8b8XLFhgzZubbrqpNWEOHDjQHHfccaZLly7WNIyPHaFNCH0CxLZju7MBAwbYNCjbCy64wIo6rYgVQgghRJQpOmH3/vvvV5jLR6DBaaedZh566CFzxBFHWH86fOIuvPBCOy/93HPP2dh2jlGjRlnljMWO6VVW0N5xxx0FqY8QQgghRNkKu27duqVcsdivXz/7CYJgxQQ4DgpyLIQQQggRRUoqjp0QQgghhAhGwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggREUpO2K1bt84MGTLEtGrVymy88cZmm222MVdffbWJxWLxc/j/0KFDzRZbbGHP2X///c28efMKWm4hhBBCiFxTcsLuhhtuMHfeeae57bbbzJw5c+zfI0eONP/617/i5/D3rbfeau666y7zzjvvmDp16piePXua33//vaBlF0IIIYTIJdVNiTF9+nRz+OGHm4MPPtj+3bJlS/PEE0+Yd999N26tGz16tLnyyivtefDwww+bJk2amBdffNEcf/zxBS2/EEIIIUSuKDmL3d57723eeOMN8/nnn9u/P/74YzN16lTTq1cv+/eCBQvM4sWL7fSro379+qZjx47m7bffLli5hRBCCCFyTclZ7AYNGmRWrFhh2rRpY6pVq2Z97q699lpz0kkn2e8RdYCFzgt/u+/8WL16tf04yAPWrFljP1C1atV4nuvXr4+f646vXbu2gq8fx/gu6Lj73WRwTvXqf94mfsdLjRo1QqWHKlWq2N9JLHsqktUpk7K745UpO+Wm/GEJe5+CIK3ffQpTdm/5uU+JZadO6ZQ97P1zZQ+6f2HLHnT/wqYHtb2KbS9M3kF9RGXKHtT20i17ObQ9zkvWlxei7Gp7f7a9ypR9rc/9q0zZ07l/fn28X9vLREdEVtg9/fTT5rHHHjOPP/642WmnnczMmTPNxRdfbLbccktz2mmnpf27I0aMMMOHD9/g+IQJE0zt2rXt/5s3b27at29vZs2aZRYuXBg/Z/vtt7dCk+ngH3/8MX68Xbt2pkWLFmbKlCnml19+iR/v1KmTady4sf3tVIwbN84cdNBBZtWqVWbSpEnx4zQYNx2dKj1svvnm1trJIpLPPvvM/UrK9MnqFCbv7t272wUsrhwO6hS27HXr1jX77befWbRokb3f/0fy8qe+T8nTL1myJH6fvA+Vq1OY8rv7xG95LcbUKRkV75Nf20tedq5VsrYXpuwQ1PbCpge1vYptL0ze3j4ise2FLXtQ20tV9mi3vdR1T9aXh807qO2lyt97vn/bS13/qLa9MHkne+emwnvt/dpemHbv7SP8+730dcS0adNMWKrEwpguiohmzZpZq915550XP3bNNdeYRx991MydO9d8+eWXdqXsRx99ZC+Io2vXrvbvW265JbTFjrxomPXq1cuZxW67IcnF3byrD0hqsWs56JWU6YNGD6ny/ur6g5PWadsr/5N22TneavC4SpU9cUSUqvzzrz0w6X1Klf7L63olHbmGLX+QxS7Z9Qsqu7t/YcsedP/Ctpug+xem3TrKre1R9mR9RJiyJ7OahC17UNtL97mJQtsLU/dkfXkhyu69f2Gem1Jte8nKzvFtrhgfuuxrfe5f68tfDV12v/sXpt3n0mK3dOlS06hRI7N8+fK4JomMxe63337bwCROxd0FIgxK06ZNrR+eE3aINFbH9u/fP/B3N9poI/tJhMaZOOVJfn6m3aDRZNDxMFOp3nPCnJ8qj6CyB1HZOuWy7Nz3MNMh6d6nRFxe6ZQ9MV22yh72/rm8wtY1kcQ6V/Ya+J2vtlfaZS+HtufOKaayq+2Fm0r15l09jfvnV9/KXIOgulb2ecqk34ufa0qMQw891PrUYc5kKhbL3M0332z69esXV8lMzWLF22677azQI+4dU7W9e/cudPGFEEIIIXJGyQk74tUh1M4991zzww8/WMF29tln24DEjksvvdT8+uuv5qyzzjLLli0z++yzjxk/frypVatWQcsuhBBCCJFLSk7Y4VBKnDo+QWC1u+qqq+xHCCGEEKJcKLk4dkIIIYQQwh8JOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEKIiCBhJ4QQQggRESTshBBCCCEigoSdEEIIIUREiLSwu/32203Lli1NrVq1TMeOHc27775b6CIJIYQQQuSMyAq7p556ygwYMMAMGzbMfPjhh2bXXXc1PXv2ND/88EOhiyaEEEIIkRMiK+xuvvlmc+aZZ5q+ffuaHXfc0dx1112mdu3a5oEHHih00YQQQgghckIkhd0ff/xhPvjgA7P//vvHj1WtWtX+/fbbbxe0bEIIIYQQuaK6iSBLliwx69atM02aNKlwnL/nzp3rm2b16tX241i+fLn9d+nSpWbNmjVxcVitWjX72+vXr4+f646vXbvWxGKx+HGO8V3QcX53/erfktblp59+MtWr/3mb+B0vNWrUCJUeqlSpYn/HW/ZUaVesWJG0TpmUneOVLTvlpvyOVOl//vnnpPcpVfply5bF71Ni2cPk78pv71NC2alTsvRBZXf3L2zZg+5f2LIH3b+w6cux7VH2ZH1EmLy9fUS6ZQ9qe+k+N1Foe2HqnqwvL0TZvfcvzHNTqm0vWdnt8UqUfa3P/atM2f3uX5h2n9jHJ/Z7megItAh4vwskFkG++eYbah6bPn16heMDBw6M7bnnnr5phg0bZtPoo48++uijjz76mCL8LFq0KKUGiqTFbrPNNrMq9/vvv69wnL+bNm3qm2bw4MF2sYUDJY1CbtSokVXe+YARS7NmzcyiRYtMvXr18pq+kHkrve5dqaYv5bKXe/pSLnu5py/lsqcLlrpffvnFbLnllinPjaSwq1mzptl9993NG2+8YXr37h0Xavx9/vnn+6bZaKON7MdLgwYNTCGgoWTSWDJJX8i8lV73rlTTl3LZyz19KZe93NOXctnToX79+qHOi6SwA6xvp512mtljjz3MnnvuaUaPHm1+/fVXu0pWCCGEECKKRFbYHXfccebHH380Q4cONYsXLzbt2rUz48eP32BBhRBCCCFEVIissAOmXYOmXosRpoIJqJw4JZyP9IXMW+l170o1fSmXvdzTl3LZyz19KZc9H1RhBUVechJCCCGEEDklkgGKhRBCCCHKEQk7IYQQQoiIIGEnhBBCCBERJOyEEEIIISKChF0RovUsQgghhEgHCbsihC3MvvnmG1MMsGNHoYRmIfN2+ZfztS8khc5flB/lPqAuZP0Lfe1jEbv3CndSRMydO9fukDF9+nTTuHFjs/HGG5sOHTqYo446yuy00055KcO6devMypUrrbDccccdK3xHU0m1b26Yc3KVd6b5r1692nz11Vd2j+BOnTptIDSqVk09DnKPUzplKGT9C133QufPHozvvvuu+eOPP8zee+9dYeuesPlzHnlnY2/pbP5WuvmHqXNU8y8k5Vx3kR0k7IqINm3amJYtW5q99trL/Pbbb2bJkiVmzpw5Zu3ateaggw4yf//7303dunUD069Zs8bUqFEj7fx5sV1//fXmk08+MZtsskn8JXfmmWdagZkMtmurU6dO2iIjk7yzkf+ECRPMddddZxYuXGjT/fTTT6Z79+7mggsuMPvvv3/K9AiSTTfdNGUHHVSmQta/0HUvdP5PP/20GTlypH3eeO74PZ7B008/PdQWhOxs07Rp05T5J3th//7777b+POteUV8ZsZrJoOaHH34wn376qW1D3vZWKvmnmzfp5s2bZ58/7iHbT3r3/syHqC/ktc9G/dOte6Gv/Zo1a8z7779vJk+ebN+7O+ywg9l6661No0aN7G8ly997vRmQc16hBmG+IOxE4Xn00UdjrVu3jv3888/xY/z/zTffjF122WWxrbfeOnbhhRfG1qxZE/gbN9xwQ2zy5MmxH3/8MbZ27Vrfc3777bfA9C1btoydeOKJsX/961+xO++8M3bllVfGOnfuHGvWrFns5JNPjn355ZeBaSnbAw88EPv4449jv/zyi+85K1asyEne2ch/iy22iF100UWxJ598MjZ+/PjYXXfdFfvrX/8a23jjjWN777137J133kma/5FHHhkbMmSITfvDDz/4nuPu7fr164uq/oWue6Hz32yzzWJXXXVV7I033ojNnTs39uqrr8ZOPfXU2CabbBJr0aJFbMyYMUnz79ixo71HDz74YGzhwoUbfE+eS5YsCcyfdNznHXfcMbbTTjvF2rZta5/5efPmxcKwfPly3zzDHHP9RqNGjWzeXIuGDRvG+vTpY9tSGPyueb7yzzTvv//97zY/rjn3u1atWrGDDz7YtqUwJN5v8lm3bt0G5/kdK4Zrn0n9M617oa99nz597DXfbbfdYptuummsWrVqsQ4dOtj+NyiNl88//3yD/IPeu/lGwq5IuO6662KHHHJI4PdPP/10rEmTJrGZM2f6fs9LsUqVKrHatWvHOnXqFLvppptiH330ke303UP966+/2hcWL69EHn/88VirVq3sOY5Vq1bFPvvsM/uipfGfcMIJFb73lo28eQnutdde9oF9/vnnY1988UVs9erV8d/ab7/9Yh9++GFW885G/qQn7R9//BE/xjVbtmxZ7D//+U/soIMOskLjp59+8s3/2WeftfnTKfCSR6DdfPPNsenTp8dWrlxpz6Ec2223XWzq1KlFVf9C173Q+XOdyN+vQ+Y56devX2yPPfaIffPNN775k578e/XqZfPv3r177IILLrBi0IlJBmOI1Ndee22D9E888YTNf9iwYfZa3H///bEBAwbE2rdvb8vMce+1SYSB3+mnnx575plnbHl///33Dc6h/u5a+A0oaXt33HGH/a2JEyfG/vnPf8b23HNP25ecdtppgWIZJkyYENt///1jN954Y2zKlCkbiEzuJW3PT3xmmn+meT/88MOxbbbZJn7t5s+fb/+PuKhevXqsa9eusTlz5gTW/eWXX45tu+22sfPOO8+mY0CdmD8Dae9gPVt1L3T9M617oa/9v//9b5s/gzn6Fp6xd999N9a3b99YnTp1Yn/5y19ib731VmD+zz33nC0n5b3ttts26B8Qhjxzs2bNihUCCbsi4e2337YPMy8lvxc4Lx4EGyO8oNHHWWedZS12iDcaJ59DDz009sgjj9gH57HHHovVrFnTN/3tt99uX/x0BEGdCMKSzieRM8880z4Q06ZNiw0aNMiOPrFA8EK+9tprbZp77rknttFGG2U972zkz3WhMw0SDzNmzLC/h3j2g87llFNOib333nuxW2+91Qp0XsxdunSJnX322daSNmrUKDsiLbb6F7ruhc5/7NixsZ133jm2YMEC35E/L5cddtghdsstt/imv+SSS2LHH3+8tbAgMhF1XHfqhNhDmF1zzTVW2PnBCwzrnBcsrgzKsEIi+ugTgqDdICwRCIhK8sPi8b///S8+oKP9kI8fCIO//e1vFY5R98WLF1tLItcmsXxeevbsGWvQoIGt7z777GNFJoMRyu9mF1555RVrkc52/pnmzaDh4osv9v0OoYXFHGEfBG2N687vIOoPOOAA+/y9/vrr8QHViy++GKtatWrW617o+mda90Jf+6OOOip27rnnxv/2Wuh4dvh93p1BHHHEEbaf4V3Lv/QR9ANPPfVUfFaMvgUrYCGQsCsieAEwHXv++efHPvjgAyvwXCNlRFC/fn378k6Eh5hGndgJvPDCC7bzoHFvtdVW1ux90kkn+eb96aefWmHJlNjXX3/te06PHj1iQ4cO3UBwUm6sDF54wBCbPHxt2rSxIpOHIJt5Zyt/8sQkz5TeJ5984muG5yEfOHDgBsc5l5c+U6FeGP3xYubFizWpRo0atjzFVv9C173Q+WMZZOSPpZMRup/l7phjjtkgD0A4YWHr379/heOIQYQ0LyYnvHjp+j23Rx99tJ12D+KKK66wdfj+++83+A6LwC677GLFMRYbhCx14Z4ffvjhVtBipURoUge/68eggE8Qo0ePtlNlftPC5L/77rtb8Ywl+Oqrr7b9DS862isvbiySXINs559p3tw72hTXKbFMThBjSd9+++3toCER+mbaDIMyLOsIMerRrVs3KzR69+4dGzlypB1gcI+zWfdC1z/Tuhf62rsZMtw8vGC1c9ZxBkNYzOlHE0G4MYji+eK9zDn8HvVhUN2uXTs7wKOMQfnnGgm7IsC9zGhUmHXpmDHzMgXHA8qDif8No5Og9IiD999/3/7txKD3QeDlzwvGbyrSwQuCUSLTfpiamcpzlpTZs2cHCktGmM7fIHHaCCsUdSJvxGq2885W/rzUeRAxrTONjeWTkZv7Lln+5OlevIk+kNwLLKbk79dJFUP9C113lz/tu7L5k4fLP7HuYfPnxcmIH6sHgyqmyBCZwL1gQBSUP7jpz8T68zdTRuSP2PSDaTiEJ1NDflZLfCsbN25sn+9EvvrqKysqqaMDYcrUFBYFLJ28HMkfy6cfnMv3+Bh6rZYOpgIR3n5TSt99952d9kdcePsiXnT0W1hddt11V/v7QX6S6eafjbyxZPM9osDPpw2fVPzfsIAlwr1ioIWFzIEo4Rnjhc9zjMhIdu8Lfe3TrX826l7oa//RRx/F6tata/scPxcNnmn87tw7NbFsTJkzePPCrBiuGRhZEJXk75c+H0jYFQmJLyVebnTamNmxtOBU/+2336b8He80Ei8WZ4HgxYGDajI4l+kkpnxplJiXeUh46eKPcNxxx4WuD7/lyoFVA4uRH96yMsIkr3Tz9lp7+L0w+btrxofOBnN68+bN7aiLURn/Zyoj2cg6qCwufzogLHLFWP9iqDv/4uuCfxx5YoUKk3+Qg7O37sny9/4GLxcs3rwQeeawlHDNGGT5WQuTOaV7LQ+8eJkuC4KyMh3HwI2pIfwKeUFgkUGYYrVhcUlQ2RF3ThAmDuiwRjIoZBYgGVg9sfRw/3EcR0yz2IMp4X/84x924VYQDBqd/15iH8ZxrJZBU4He/GlztPHK5M/vZ5o3wp3+DqvmpZdeaqfScMpnsIQFnanwZLh8E0U9wgArL+I6F3UvhvpnWnfypn/D0pjJtU+s++8h88f9iXrT9o899lgrChlEI6Txb8T6nQz3jCda+fl78ODBgc9tPlC4kwJDiIXnn3/ezJ4923z22Wdmt912M6eccopdeu0NhVCrVq2kv5MY6oTbynLtatWq2X+HDBlil2Nfc801oZaLE1Psscces+E3tt12W1ueQw45pMJy9DBLvSnHjTfeaMNxDB8+3PccYrcR4sOb98MPP2xDAGy33XaBeQeld/lSplT5+9X922+/Na+88ootR7NmzexSeMJuVK9efYP0YZa633333eb77783Q4cOLar6F0Pdaf+bbbZZhdAh5D9//nzTvHnzpPknpvcL+ZAsf7/y83vTpk2z/xL2YIsttjAdO3b0zTtM/Z988kkbzuLCCy/c4DsXTmH58uXmoYceMrfddptZsGCB7QMIu0A8S/49++yzbdibIP7/AD0emoGQKTz3lKt9+/amc+fO9reDoH8ZM2aMuf/++20fRJ2pG30SZenfv7856aSTAtMnuy4777yz6dq1q2/+rv60Te75Aw88YNs8+fNdmPy995z/k7ere7K8vedPmTLFPPXUU+bjjz+26b7++msbS5J2R95HHHFE0nz96gSEKyJ8yS233JKTuheq/pnW3fvOmjFjhnniiSfMBx98YI+RL31QZa99Yt33TpG/Kyvvt7Fjx9qQK9999539m5ia9Lc8dz179vTNH/zK4I6RjrBFo0aNMoVAwq7AHH744fYhbtWqlX2R0tAJVMxDSdy6E044wb7UgmLqeIUhMYF233132xEQE8/LsmXLTO3atU3NmjUDy0Ie7qXApzKkirnk9zAiHuhQeIF98cUX9gV65JFH2ofKW6agWELe9AgBXmC9e/e2MdAShXCqOE90Cny41ukEB018uYahWOpfiLrTgT766KM2hh0vEjphYjVS/q222qpS6XkRcO169eplevToYcVwZci0/m6XjMqm5ZqtWLGiQjDkmTNn2rh6iD0EfZcuXUzbtm19f5t8EfWJgt+1GYIu83JkMIdA9kufKOwRdm+88YYVey1atDB77LGH/dcP9yINgt+gD+Pjlz8xAxE2m2++efwYz8Frr71mvyNNUP6kW7VqlRX1fuVIlbdfGuIIfvjhh/a68LsEhUfcp1N3xAFxKYmFiDjPZt0LXf9M6/7jjz/G6877CIMEgy/EFWIv1bV36Rs2bGjz4l+vUWN1ivx5xyUOFBl8Majid/hss8029n3ph196L9Th3nvvtRsLNGnSxBSEgtkKhZ1+wo/AxSjD/I7vBNMxrPTD6f3ee+9N+huHHXaYnarDnM3KSKZ0mMrDv4KpvVRxdZiixQcjcUWm15G0smm9U1HJYLqNaTemDC6//HLrzMqqXUzomMWdiT9oyi0oPSZ8/Mpc3YPSjxgxwq4aSwwFEabuydKTb7HXv9B1Z7qT8g4fPtxOQeF4zMpV/FrwUXF+a0F1D0qPTxKLEVz6oLrg3EzIBaYrg+qfrB5B6b0uCMlg6ptnnIUR+MGxupcFEGHxpmfaHr8qP1+hMNDOmMYNc99STb2HxYW22HLLLWNNmza1i2fwFQyKwRiUlg/TaPiohnFVKfW6F1P906k77zOeW9wjcHWgD2Pl/n//+99Kp8e1iKlU+qIgH9IwdU8XnvViiVuXiIRdAcEBFEHmB3F5eMHR+INi4WQqDPHnYMUsZeDF8tBDD20QO4gXJM69iZ1G2LS8eP1igPFiouyJgVtZ5YRTMOKG+geRaXrKjwDGx4Ol7dQRn4vE1U+8wJ0jfzbTF7L+ha77pEmTrABLDOtDJ4vPEX5F+IYFhX/JNL0rP350LFhhxSpBiRPLj2DG5ybd9Ay0/NIjwBBjOFhff/311rePgRjPE//igA1BL9tk6Vlw9dJLL8WSwUIM2obfKmBEbbIg6KnShxH2hLPAd5EVg/hVMQhhRSPlxycsWZ+VLC0DXLeYIChYLU7z+HKyqMVvsU+quidLn+u6F7r+mdad55boDPi/saiBcCT4deKLxgIhVvYm+41k6fmwMtWlX+dTd/ooFkgxIEsUdPzt6sC7168cydI7v16XvtCCT8KugDBCp0EjxPyg8bBcnYUTuRCGOKgy4idUBnGucCIl9hYvCkKlEIqCxsxLLHE0mUlaIB4fTrvuAfFa+Xi5YIVh1VJQkMhM0+MQv++++9pVmDjK8n9+j9Ev1xuBxCiQ8vvt2JBp+kLWv9B1J0wB7cWJUurgtaxhCUS08gLxI9P0WDcJCUFIBeK+HXjggVYo0Z5pv6yu48URVP5M02OhSQx/wv1j5S7hiHhBO3HnR6bpXZxL7hvxvLiPiRYTAjwTF9PvBZdpekSJ34IY+iwGJZtvvrm1WPuRSVpXdiy7WLoJF0IcQsrqhRXQLGbwezlnmj7T8hey/pnWHRFGm0iEZ5cy88zyXgki0/SnnnqqXYHOjAYzA1zLxHcvgybiA/oJ3EzT5xMJuwLCqJ7GwvQp0cPZVcI7tUXEcEYorB7KhTBkGyQXJBLrGiMgOg2WivOS4gElLg8vsWymBcJJUHZGnV68LwKsQYzicpEea8oZZ5xh/89DiABiSoAXFSKFKQIsP7y0c5G+kPUvdN0XLVpkLYqJ7dI7yqbTDFqNmml6On+sce58LFBMZXEcsUK7ZZonKLxQpumxtGHJ9is3U7sIZJ4hJ1yznZ5VmIgABgecy9QWlghEOpZ3LOznnHOOFau5SE9cQsLKBFmKWCWMNdRve7ZM0ropfKbqCXhNHbB2MRXONWVKjzBDrE7mHuYifablL2T9M607s0iIM+9uON4BGdZ2Zpn8dkbKRvp9993Xzi4gRjmXEEcINLddJ30q1xbhmov0+UTCrsAwVUUnyBYmdJCIJaZXCLDIyJwgibkShoyyx40bt8Fxpl0JkcGLGqsDFpBspgVGdFj7ECd0BkTL98bxIjYZDwzhV3KRnilrTPuJ8BtEDGc0mqz8maZ35WeEnUn900lfyLo74UkbR/wg/hAD3ql+Qngg3NhiK9vpAQuyn08Ox4k7xeg/Wf0zTc/3PJe8CP3qhmsFz33Q9oGZpCfeIRZ2grqC27qNQMgMBBiY8T3lZ7CW7fRAnEDabWKMMSdQsT4x3eh3jTNJy3XBN+3uu++2fzOVz/TifffdFx+UIgwou9/+wJmmz7T8hax/NupOH0V/zYyOFydMeXfx3Ab5mmaS/ptvvrFWbjfVjSDkGO5MzHwhWolXSfn9XBkyTZ9vJOyKBB4SXtSIO6wePCSMgFNtBp2JMAQ34qFj8Mb/AqayCA6bi7TO0ocgZcSHvxZ+UUTPx9LCywG/oVymdzh/FK+1i4czWey7bKSnI6L8WDvoGCpb/nTSJ06NuXsXtuyZpvfCgAPLGtYl2jxTGOwQQbmJJ5fr9EF1ovxB289lIz2BZ3H6xtrBVC4WT++ULdOoyWJOZpqegMxMlyfCi4qBAJaIZLH3MknPtUIAY3nB2sHAlPJ69/TEIuRX/kzSOoiRRpzARJYuXWotMViFkvVbmaR35Wc2I53yZ5o+0/JnWncsbLyfmM6kz0IkOqsydWCAlqzumaQHzvWzZPIeYTCIFTLZvc80fT5RuJMCwHJoYhYRP4f4Y4QoId5UnTp17PeEO2ndurVddp0sRIcXwiQ88sgjNlwKt/Tnn3+2ISAGDBhgdtlll7TCVxx99NE2HMPrr7+e07TUl2tBHQjLQjyh/fbbz4Zq4DrkOn0iLPc/99xzzdKlS23oiVynZ5n9yy+/bJf7c9+I5VaZ8meaPvHepVv3dNIvWrTITJ061YbrIYYVoU+IAXXyySebpk2b5jy9Xx2GDRtmwy8QAy9X6T///HNz55132rIT8oFQR4RXIIwDfcOBBx5o4w/mKr03dAVl9oZvIOQMfRFxLHOVnlAsDz74oHn11VdtyCbCZ9StW9f+Fvfx2GOPDYx7mUnaRBLDAFF2QgURfzBX6QlRQ9zCl156yZaf+1eZ8meaPtW9C1P/TNLSVxO7btasWTZ0CWFPNtpoI9t2+/btay699NKcpk9276jPs88+a/KRPpdI2BUAYgvRMBs3bmxfgLycCMZ6/PHH20a56aab5lQYuvQExiQGFmmJdUTMHRqmi1NEvB7iaXnjCWWSNlXHAO5BTUU20nNtgmKP8T0vkAYNGmQ1PTGqEN+IHr4jRhnXkLhNgCBIFvsok/Qu7TPPPGPbGHHSCD79l7/8pUKbS1X2dNM7aBuQeO+IP0UHnYpM06e6dwhzXhK8LHOR3st///tf+xzzzCLKucYXX3yxFeZBcbSymd4Lz9NPP/1kB4QEyCYuYq7TEzePOIzEZESUE3/tvPPOs31aqnuZSVo/GBQSR/KGG26wcRVznZ74iwQHnjNnjn0H0H4rU/500ycGs3dtloF4qvJnktYrhBh8Mxij3AxMicnXr18/G4MyKEZcpumTgVi+4IILzEUXXWTatWuX9/TZRsIuzyCK9tprLzuq4YXMS5jGSeRxIr/zQvzXv/5lTj311JwJQ7/0CEGCIdMwvTsBZDMtMMpKtCD+8ccf9oFN7DDylT7MDgLZSn/GGWfYIKSIYUbbXD+u5T777GMuueQSs+uuu+YsvV9aIt3vu+++9oVAe6xs3pVJ/84772ywi0PivUsW/DMX6Tmfe+dEWrKA0Jmm50XMs/P2229bQcwLgN8jODltCFGWTAxmKz314AXIYABxzv8ZIHp3Q3CDxGym914z8N6nZNctW2nDiHKuYTJBnG56gg+zAwQ7LLjBEO8B7l8YAZ6t9AQgJi19NkHwEWFeyzYCaeONN85a2mwE8s5m+ioJAbkrMzDMNH1eKfRccLlxzTXXWJ8wh3dZOD5TrKwjNhZ+NH4QF4swFjhm4zDu9ovEgROH6nr16tnAwUGkSo+PgNtUPNF3KJO0zjenevXq1v+JNIkhEkjDiieCHvsFjsx1euc3mKv0XD98QFgSz8IX559y66232pVkxKJipWFQgOdM0odJi19mJnknS89KNRyLaSc4ISc6d7t7h38avjxRS88m7/gCEooEX0j84/BDY+ETKxm9C1/8yEV6nL3pa9inE6f7xPpkMz3+SYTC8EJb8a7qJI1fmIxM0gald+d7y+nShyl7ZdLjl8YKYfxgWT1JpABWruILip8cYWqSkYv03DdiHuKTmrgQw1v+TNK6RVwspvDeG87x+mTzrwsonkgu0vvFuXMxL8OUvzLpC4WEXZ7B4ZuFEd7Ard4I2Kw6Y7k0cchyIQwzSZ9p3mxqzcbuLPZgoQcvBxzeCbLpghgTyoIXKP9GLT3xvnD6dSSKPxZCsKLNBZzOZvpC5g2EXUEAIoj5HQYBLPgZMmSIFQ1utS3Xzs9BudTTs6iFVYXedkE6Fj+wypEdCFj1F0Su0xPgNShsUjbSIwq4NlwzFvckhqSgL6FPZCVz4ks0k7Rh0vOSdun94o9lmp7+gjAl3kUO9Bd33HGHjcfIYJnVrkHkOj3GgKD0maQFgtdz7QgozmJAP4FMO6L/8BNnpZ6+UEjY5RlGfwg7RtqsIPNrDAg7t6w828Iwk/SZ5n3CCSfYVU10DIz0iENGPDw6CK4HwVV79+5t/x/F9K+//rqNLu8NGsz1cxYwLD2s7iWCerbTFzJv6N+/v92JAtGPOCAsCqvAsTzwYsIKykrPoGtX6ukZCCCO/XZ3QBiwJRptJ2jUX+rpsfAQ+4+g6U6McOzmm2+2ll8gNh+Dg2ymLYb0DP5c3EG/bagQT8RI413gd+0KmT7TvAmDwnOCZZ9npFq1anZwzLV0K2wZMGMJ9qPU0xcKCbsCgDBgyToiiCCmjHonT55slT+NiAjaiXtwZksYZpI+k7S8CBjZEcjSC4Lgtddes4KAFwOjI79tdUo9PSCC2CmE/R3vueeeuCjywvQKOytkO30h8+ZlwPR94ne0cbahY09jRsNcO2IgRi09YOnbY489KjwzCCR3HYmHte22224wtRWF9LhrIBDcVkwMANnvlPhnvBCx+vA9/R5iKVtpiyE9cBzR5w0Vwm+5a0m8Qb5nu7BiS59JWnYfIhyR6w8JyUOcR4Icu5h3CGSEst9uGaWevpBI2BUI5u4J8omVh6kdpjNoKETtJ4p9roRhpukzzdvhtzk7L0iuQeIeoFFKz4uQAL50hkztYQkgkCvXkDhQCKdk1y+T9IXM24vfPo7EPQx77UsxPX5QTJcijvy2OiMuHLHvopieQOnEGKOdeCG4McIAMYzVB2tI4oAhk7TFkB4QRezW0bp1a/tbibBjAbHZgq59IdNnkpZj+Jwm+qPy/GAkYDBAUOuga1fq6QuJhF0ewbrD/qkffvihHek75198NjhG55jKCTobwjDT9Omk9XsZgtcJlgCPBNaNYnrvbzDyY9cO9hxl+g4ndEZ9RxxxhJ3iy0X6QuYdtCG5F6YzCGwbxfTexTcEDWcqhyk9th/iWjLaxzmd3VqinN7r+J4IW5OxRVWu0hY6Pc8NO8QQWBgrH9cKSxB+yVi6ceko1vSZ5u3wm6olLcK4HNLnE4U7yRP33nuvDarJknGW6m+//fY2VECPHj3MYYcdFhjvzQsxyojZw5JqlpWz7Jyl3/Pnz7fL7AkxQLiRoHAnmaTPVt4E06TJETLDW2eOjRkzxmy11Va+cZBKPb1fSAZCdRB3j+tJDK769esHhonIJH0h8w5Kn8jkyZNt/EEXjy9K6b0QCuSNN94wEydONO+9956NQ0c7Ov30021QZdpVlNN7nxd3XQmT0bVrVzNo0CBz1FFH5TRtIdK7c3lOuF7EnuP6EbqEfvSkk06yMeAIHVRs6TNNmyw8CNfu8MMPt4HUjzjiiMilLyQSdnmAoJ3EeiLW15lnnmmDOY4bN852kPPmzbNBZm+55RYbjyoxmnW2hGEm6bOd94477mjatGljA5gefPDBZuutt450ei/cXxfEOeyuItlKX8i8XXo+6cahKtX0POsED+basUPEnnvuaUUwAyKuJbErk8V/jEp6YtAhfom95u0ziP/FDjU8S9lMWwzp/fDGvSSIO4OiylDI9JnmnRjs+P333zedOnUqy/Q5Ja/2wTLllltusatr/Jg4caKND8WCBO+Sci/M5zPlhdMmK1KJn0a8MqZ+8HdiOboLM+FnLs4kfS7zxm+D1XQuvd80R6mnZ9Ucq0mJNYY/SqJTvpvi+/TTTyvs95mN9IXMO1V6b7w70vu1/VJPzzU58cQTrasCbYhnnGf9wAMPtE7p3tAhflO9UUuPXyb9IL65xDxkYUIQmaQthvT0BbispEsh05dy2YshfTEgYZcHiPlDx4BfnQtm6I0DxnFiJBEHKRfCMJP0hcw7KunxP2SxCf8S7JMXgzeILS9IHJT9NtjOJH0h81b6P+M+EtdxypQp9m8GBXfddZf1TeU3CfSLE34QUU6Pbxa+aUHpM0lbDOnxOySANH6I/EbQohJ8FP0WYhUyfb7yxifXL5B7qacvBiTs8gBR2ekkcEB1EaoTR7mdOnWyQQ5zIQwzSV/IvKOQnl0KzjrrLGvtI7glsdCaNWtmd2pgoQUraUePHh2rXbt21tMXMm+lj9m4V3yfCM89wXxZhOBivyl98eSdjfQsJiH2HwM/2gvhMYgggEB0seDoW4IGjYVMX8plL4b0xYCEXY5xUzYE9916663tqiJiILEKFtia6/HHH7fbNbkI9tkWhpmkL2TepZ6eWE9MWXmD9tIxcM9feOEFGzaGiOZYg1wQ0GylL2TeSv9nOBxEIQKQ6Xw3xeMN8ErYEAIcB21NV67pS7nsQBBrogW47RWZqh88eHCsRYsWNjQGopEg7qRnV4tiSl/KZS+G9MWChF2e4EXBfpsofQJa1qlTx4o5tqXCV4utiXIhDDNJX8i8o5De3Xe33ViiHxIvEKYzEAcEw8x2+kLmrfQxG9qIoL34ZzqB4IVpXPoBpf86UmWnX2BQkLjFGsKQqT32WGVLuqCtBwuZvpTLXgzpiwUJuxyCtYd9RFH7RKgmcj9+KVh32KKJ4IeY+4lfl2rz4HSFYTbSFzLvKKSns/B7OcBVV10VuBVRNtIXMu9yTs/zjPhjFxaCduOzgxVo0qRJdrHN888/b18Su+++u9IXUd7ZSA8ErHVBa/36dhbkEAuwGNOXctmLIX0xoHAnOaRfv37m448/Nr169TKbbLKJDXvyxRdfmG+++ca0aNHCDB8+3IbOCGLJkiXmqaeeMjfeeKNdYk+MuIYNG9pwA+3bt7fhBr788kv7+4RTSQxBkUn6QuYdpfT//Oc/bZiEevXqmS233NKGhyE0AvHfiJN033332eOHHHJI1tIXMm+l35Bly5aZhx56yDz++ONm5syZNkRErVq1zG677WYGDx5s9tprL6Uvwryzkd4PYsK1a9fO9O3b11x22WUllb6Uy14M6fOFhF2O4LIi5oiDRABLdwxh99Zbb9mXwtKlS82zzz5r49jlQhhmkr6QeUctfd26dW36OXPmmEWLFlkhOGDAgKTxjzJJX8i8lf7PwKWIPy88+xxfuXKlDfRKmyImmtIXT965Su93ztNPP21OOOEEG/C8WNKXctmLIX1RUWiTYVQh7hUOluyx6AemXkIGsNrGD0zArLbz7lHIMTahZn9CHPaZCvRz3s00fSHzjnJ6tmR64IEHbHpCpCTGRstG+kLmrfR/wp7J+GUS68xtlu4XI8/9ttIXR975Sh8UGqnQ6Uu57MWQvpiQsMsRCLf99tsv1qVLF+uX4dcJ3HTTTYF+GpkKw0zSFzJvpde9K+X07JWMYzUbo+N/d8kll9h4h8S+czG/iIFFYOtZs2YpfZHkncv0BLt1wctXrlxpg7r7DQoLmb6Uy14M6YsNCbscMn36dBu8lCXSjz76qHXEdk6ZjAhYSEF081wIw0zSFzJvpde9K+X0xL7r37+/DVhMkFt2ruCFweKpESNG2BXVWP6qV6+u9EWUd7mnL+WyF0P6YkPCLscwskPA1apVy8a9IqjlOeecY0cFBED8+OOPcyIMM01fyLyVXveuFNMzsr/22mtt3CsvPOOsqiRMAqupsQr07dtX6Ysk73JPX8plL4b0xYiEXZ7ApIt/FqZctqMhVALBD3MpDDNNX8i8lV73rhTT44Mzd+5c+392KEm0+CEUsQTMnDlT6Yso73JPX8plL4b0xYZWxRYAQiVUrVq1Uml++OEHM3bsWPPiiy/alTuspD366KPNDjvskPP0hcxb6XXvSjm9e97pZqtVq2buvfdec9FFF9lwOUpf3HmXe/pSLnsxpC8kEnZlIgyzlb6QeSu97l0pp4ebb77ZrFu3zgwcOFDpSyjvck9fymUvhvT5RsJOCCHyxJo1a6wFIF2BWM7pS7nspZ6+lMteDOnzjYSdEEIIIUREKA35KYQQQgghUiJhJ4QQQggRESTshBBCCCEigoSdEEIIIUREkLATQgghhIgIEnZCCCGEEBFBwk4IIYQQIiJI2AkhhBBCRAQJOyGEEEIIEw3+HwaORXsx5AEiAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, - "execution_count": 20, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -224,23 +232,23 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, "id": "0d1cf38b", "metadata": {}, "outputs": [ { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "{21: 0.0732, 13: 0.0668, 22: 0.084, 18: 0.0703, 23: 0.0061, 2: 0.0079, 30: 0.0355, 9: 0.0864, 11: 0.0829, 20: 0.0819, 26: 0.0424, 4: 0.0366, 5: 0.0382, 10: 0.0713, 27: 0.0349, 14: 0.0235, 1: 0.035, 19: 0.025, 6: 0.004, 29: 0.009, 12: 0.021, 31: 0.0054, 28: 0.0043, 17: 0.0238, 15: 0.0057, 25: 0.0041, 0: 0.0047, 16: 0.004, 8: 0.0059, 3: 0.0056, 7: 0.0002, 24: 0.0004}\n" + "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", + " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" ] }, { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", - " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" + "{20: 0.1926, 22: 0.1948, 9: 0.189, 10: 0.0229, 11: 0.1928, 26: 0.0454, 18: 0.0252, 8: 0.0016, 5: 0.0402, 21: 0.028, 23: 0.0021, 28: 0.0053, 16: 0.0016, 6: 0.0047, 25: 0.0055, 13: 0.0259, 3: 0.0059, 0: 0.0021, 24: 0.0033, 7: 0.0033, 31: 0.0024, 15: 0.0021, 30: 0.0008, 19: 0.0004, 29: 0.0003, 1: 0.0003, 4: 0.0004, 14: 0.0003, 17: 0.0004, 27: 0.0002, 12: 0.0002}\n" ] } ], @@ -254,7 +262,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "id": "ec6a816c", "metadata": {}, "outputs": [ @@ -262,7 +270,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Result bitstring: [1, 0, 0, 1, 0]\n" + "Result bitstring: [0, 1, 1, 0, 1]\n" ] } ], @@ -283,13 +291,13 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 12, "id": "a6c223b0", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -320,7 +328,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 13, "id": "76444240", "metadata": {}, "outputs": [ @@ -328,10 +336,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "01001\n", "10110\n", "01011\n", - "10100\n" + "10100\n", + "01001\n" ] } ], @@ -342,7 +350,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 14, "id": "ca9172e6", "metadata": {}, "outputs": [], @@ -359,7 +367,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 15, "id": "3a6a65a6", "metadata": {}, "outputs": [ @@ -378,7 +386,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 16, "id": "01920bcd", "metadata": {}, "outputs": [ @@ -405,7 +413,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 17, "id": "968c5412", "metadata": {}, "outputs": [ diff --git a/tests/test_qaoa.py b/tests/test_qaoa.py new file mode 100644 index 0000000..b568b4d --- /dev/null +++ b/tests/test_qaoa.py @@ -0,0 +1,92 @@ +# Copyright 2025 qBraid +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" +Tests for QAOA implementation. +""" +import io +import os +import sys +import tempfile +from pathlib import Path + +import pyqasm +from pyqasm.modules.base import QasmModule + +from qbraid_algorithms import qaoa +from qbraid_algorithms.utils import get_max_count + +import networkx as nx + +from .local_device import LocalDevice + +def test_generate_program(): + """Test that generate_program correctly returns a str object.""" + qaoa_module = qaoa.QAOA(4) + edges = [(0, 1), (0, 2), (0, 4), (1, 2), (2, 3), (3, 4)] + graph = nx.Graph(edges) + qaoa_module.setup_maxcut(graph=graph) + program = qaoa_module.generate_algorithm(2) + assert isinstance(program, str) + assert qaoa_module.builder.qubits == 4 # 4 data qubits + + +def test_unroll(): + """Test that pyqasm unrolls correclty.""" + qaoa_module = qaoa.QAOA(4) + edges = [(0, 1), (0, 2), (0, 4), (1, 2), (2, 3), (3, 4)] + graph = nx.Graph(edges) + qaoa_module.setup_maxcut(graph=graph) + program = qaoa_module.generate_algorithm(2) + module = pyqasm.loads(program) + module.unroll() + +def test_correct_hamiltonian_from_graph(): + """Test that the cost Hamiltonian for maxcut is generated correctly.""" + qaoa_module = qaoa.QAOA(4) + edges = [(0, 1), (0, 2)] + graph = nx.Graph(edges) + qaoa_module.setup_maxcut(graph=graph) + program = qaoa_module.generate_algorithm(2) + assert ("cnot qubits[0],qubits[1];"+os.linesep+ + "rz(-2 * gamma) qubits[1];"+os.linesep+ + "cnot qubits[0],qubits[1];"+os.linesep+ + "cnot qubits[0],qubits[2];"+os.linesep+ + "rz(-2 * gamma) qubits[2];"+os.linesep+ + "cnot qubits[0],qubits[2];") in program + +def test_use_input(): + """Test the use_input parameter.""" + qaoa_module = qaoa.QAOA(4, use_input=False) + edges = [(0, 1), (0, 2)] + graph = nx.Graph(edges) + qaoa_module.setup_maxcut(graph=graph) + program = qaoa_module.generate_algorithm(2, [1, 2, 3, 4]) + assert "gamma_0 = 1" in program + assert "alpha_0 = 2" in program + assert "gamma_1 = 3" in program + assert "alpha_1 = 4" in program + + +def test_execution(): + """Test correct execution in local device.""" + device = LocalDevice() + qaoa_module = qaoa.QAOA(4, use_input=False) + edges = [(0, 1), (0, 2)] + graph = nx.Graph(edges) + qaoa_module.setup_maxcut(graph=graph) + program = qaoa_module.generate_algorithm(2, [1, 2, 3, 4]) + module = pyqasm.loads(program) + module.unroll() + program_str = pyqasm.dumps(module) + result = device.run(program_str, shots=1000) \ No newline at end of file From e9bdb0e402c70cd3d9c2041c522c7b4e00395975 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 29 Jan 2026 18:08:27 +0100 Subject: [PATCH 13/20] Fix for format check --- examples/qaoa.ipynb | 522 ++++++++++++++++++++++++ qbraid_algorithms/qaoa/__init__.py | 5 +- qbraid_algorithms/qaoa/qaoa.py | 119 ++++-- qbraid_algorithms/qaoa/test.ipynb | 463 --------------------- qbraid_algorithms/qtran/gate_library.py | 24 +- requirements-test.txt | 3 +- tests/test_qaoa.py | 12 +- 7 files changed, 622 insertions(+), 526 deletions(-) create mode 100644 examples/qaoa.ipynb delete mode 100644 qbraid_algorithms/qaoa/test.ipynb diff --git a/examples/qaoa.ipynb b/examples/qaoa.ipynb new file mode 100644 index 0000000..ff53fcc --- /dev/null +++ b/examples/qaoa.ipynb @@ -0,0 +1,522 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "47f77f7f", + "metadata": {}, + "source": [ + "## Import Required Libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c81f61d", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "import networkx as nx\n", + "from qbraid_algorithms.qaoa import QAOA\n", + "import pyqasm\n", + "\n", + "from qiskit_qasm3_import import parse\n", + "from qiskit_ibm_runtime import Session, Sampler as Sampler, Estimator\n", + "from qiskit_aer import AerSimulator\n", + "from scipy.optimize import minimize\n", + "from qiskit.visualization import plot_histogram\n", + "from qiskit.quantum_info import SparsePauliOp\n", + "import numpy as np\n", + "from typing import Sequence" + ] + }, + { + "cell_type": "markdown", + "id": "0f421985", + "metadata": {}, + "source": [ + "## Graph definition for max-cut problem\n", + "\n", + "The Max-Cut problem is an optimization problem that is hard to solve (more specifically, it is an _NP-hard_ problem) with a number of different applications in clustering, network science, and statistical physics. This example considers a graph of nodes connected by edges, and aims to partition the nodes into two sets such that the number of edges traversed by this cut is maximized.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "18ff0ac8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "edges = [(0, 1), (0, 2), (0, 4), (1, 2), (2, 3), (3, 4)]\n", + "graph = nx.Graph(edges)\n", + "positions = nx.spring_layout(graph, seed=1)\n", + "\n", + "nx.draw(graph, with_labels=True, pos=positions)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8805a7ad", + "metadata": {}, + "source": [ + "## Compute cost function\n", + "In this case the *Qiskit* object are used to calculate the cost but it can be done with custom methods" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9d2812e8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost Function Hamiltonian: SparsePauliOp(['IIIZZ', 'IIZIZ', 'ZIIIZ', 'IIZZI', 'IZZII', 'ZZIII'],\n", + " coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])\n" + ] + } + ], + "source": [ + "def build_max_cut_paulis(graph: nx.Graph) -> list[tuple[str, float]]:\n", + " \"\"\"Convert the graph to Pauli list.\n", + " \n", + " This function does the inverse of `build_max_cut_graph`\n", + " \"\"\"\n", + " pauli_list = []\n", + " for i,j in graph.edges:\n", + " pauli_list.append((\"ZZ\", [i, j], 1))\n", + " return pauli_list\n", + "\n", + "n = 5\n", + "max_cut_paulis = build_max_cut_paulis(graph)\n", + "cost_hamiltonian = SparsePauliOp.from_sparse_list(max_cut_paulis, n)\n", + "print(\"Cost Function Hamiltonian:\", cost_hamiltonian)" + ] + }, + { + "cell_type": "markdown", + "id": "383019ac", + "metadata": {}, + "source": [ + "## Create cost function\n", + "Here we create two different cost functions, one for getting the counts that uses the *Sampler* primitive for retreiving the counts and the *Estimator* to calculate the cost" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5e8714c7", + "metadata": {}, + "outputs": [], + "source": [ + "def cost_function_res(params):\n", + " qaoa = QAOA(5, use_input=False)\n", + " qaoa.setup_maxcut(graph=graph)\n", + " program = qaoa.generate_algorithm(3, param=params)\n", + " module = pyqasm.loads(program)\n", + " module.unroll()\n", + " loaded_circuit = parse(pyqasm.dumps(module))\n", + " aer_sim = AerSimulator()\n", + " with Session(backend=aer_sim):\n", + " sampler = Sampler()\n", + " sampler.options.dynamical_decoupling.enable = True\n", + " sampler.options.dynamical_decoupling.sequence_type = \"XY4\"\n", + " sampler.options.twirling.enable_gates = True\n", + " sampler.options.twirling.num_randomizations = \"auto\"\n", + " result = sampler.run([loaded_circuit], shots=10000).result()\n", + " return result[0].data.cb.get_counts(), result[0].data.cb.get_int_counts()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76eec508", + "metadata": {}, + "outputs": [], + "source": [ + "objective_func_vals = []\n", + "def cost_function(params):\n", + " qaoa = QAOA(5, use_input=False)\n", + " qaoa.setup_maxcut(graph=graph)\n", + " program = qaoa.generate_algorithm(3, param=params)\n", + " module = pyqasm.loads(program)\n", + " module.unroll()\n", + " loaded_circuit = parse(pyqasm.dumps(module))\n", + " aer_sim = AerSimulator()\n", + " with Session(backend=aer_sim) as session:\n", + " sampler = Estimator(mode=session)\n", + " sampler.options.default_shots = 20000\n", + " pub = (loaded_circuit, cost_hamiltonian, [])\n", + " result = sampler.run([pub]).result()\n", + " cost = result[0].data.evs\n", + " objective_func_vals.append(cost)\n", + " return cost" + ] + }, + { + "cell_type": "markdown", + "id": "0f8a48f1", + "metadata": {}, + "source": [ + "## Define initial parameters and minimize the cost function" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "df258b64", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " message: Return from COBYLA because the trust region radius reaches its lower bound.\n", + " success: True\n", + " status: 0\n", + " fun: -1.0089000000000001\n", + " x: [ 1.571e+00 1.529e+00 1.588e+00 3.159e+00 4.148e+00\n", + " 4.152e+00]\n", + " nfev: 26\n", + " maxcv: 0.0\n" + ] + } + ], + "source": [ + "initial_gamma = np.pi\n", + "initial_beta = np.pi / 2\n", + "init_params = [initial_beta, initial_beta, initial_beta, initial_gamma, initial_gamma, initial_gamma]\n", + "result = minimize(\n", + " cost_function,\n", + " init_params,\n", + " method=\"COBYLA\",\n", + " tol=1e-2,\n", + " )\n", + "print(result)" + ] + }, + { + "cell_type": "markdown", + "id": "c52d23ac", + "metadata": {}, + "source": [ + "## Visualization of the cost vs iterations during minimization" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e8596cb2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(12, 6))\n", + "plt.plot(objective_func_vals)\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "14bb8eec", + "metadata": {}, + "source": [ + "## Output distribution with initial parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "103981ed", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", + " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "res_bin, res_int = cost_function_res(init_params)\n", + "plot_histogram(res_bin)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0d1cf38b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", + " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{19: 0.0286, 21: 0.0923, 29: 0.0126, 27: 0.0266, 10: 0.0967, 4: 0.0289, 8: 0.0189, 15: 0.021, 18: 0.0965, 12: 0.0276, 30: 0.0293, 11: 0.0246, 2: 0.0126, 13: 0.0994, 20: 0.0213, 14: 0.0296, 5: 0.0457, 0: 0.0075, 7: 0.0197, 9: 0.0235, 1: 0.0279, 17: 0.0292, 22: 0.0235, 26: 0.052, 23: 0.0191, 16: 0.0201, 24: 0.0188, 6: 0.0097, 31: 0.0098, 3: 0.0091, 25: 0.0088, 28: 0.0091}\n" + ] + } + ], + "source": [ + "res_bin, res_int = cost_function_res(result.x)\n", + "shots = 10000\n", + "final_distribution_bin = {key: val / shots for key, val in res_bin.items()}\n", + "final_distribution_int = {key: val / shots for key, val in res_int.items()}\n", + "print(final_distribution_int)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ec6a816c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Result bitstring: [1, 0, 1, 1, 0]\n" + ] + } + ], + "source": [ + "def to_bitstring(integer, num_bits):\n", + " result = np.binary_repr(integer, width=num_bits)\n", + " return [int(digit) for digit in result]\n", + " \n", + " \n", + "keys = list(final_distribution_int.keys())\n", + "values = list(final_distribution_int.values())\n", + "most_likely = keys[np.argmax(np.abs(values))]\n", + "most_likely_bitstring = to_bitstring(most_likely, len(graph))\n", + "most_likely_bitstring.reverse()\n", + " \n", + "print(\"Result bitstring:\", most_likely_bitstring)" + ] + }, + { + "cell_type": "markdown", + "id": "586cb315", + "metadata": {}, + "source": [ + "## Output distribution after optimization" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a6c223b0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.rcParams.update({\"font.size\": 10})\n", + "final_bits = final_distribution_bin\n", + "values = np.abs(list(final_bits.values()))\n", + "top_4_values = sorted(values, reverse=True)[:4]\n", + "positions = []\n", + "for value in top_4_values:\n", + " positions.append(np.where(values == value)[0])\n", + "fig = plt.figure(figsize=(11, 6))\n", + "ax = fig.add_subplot(1, 1, 1)\n", + "plt.xticks(rotation=45)\n", + "plt.title(\"Result Distribution\")\n", + "plt.xlabel(\"Bitstrings (reversed)\")\n", + "plt.ylabel(\"Probability\")\n", + "ax.bar(list(final_bits.keys()), list(final_bits.values()), color=\"tab:grey\")\n", + "for p in positions:\n", + " ax.get_children()[int(p[0])].set_color(\"tab:purple\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "76444240", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "01101\n", + "01010\n", + "10010\n", + "10101\n" + ] + } + ], + "source": [ + "for p in positions:\n", + " print(list(final_bits.keys())[p[0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ca9172e6", + "metadata": {}, + "outputs": [], + "source": [ + "def evaluate_sample(x: Sequence[int], graph: nx.Graph) -> float:\n", + " assert len(x) == len(\n", + " list(graph.nodes())\n", + " ), \"The length of x must coincide with the number of nodes in the graph.\"\n", + " return sum(\n", + " x[u] * (1 - x[v]) + x[v] * (1 - x[u])\n", + " for u, v in list(graph.edges)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3a6a65a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of the cut is: 4\n" + ] + } + ], + "source": [ + "cut_value = evaluate_sample(most_likely_bitstring, graph)\n", + "print(\"The value of the cut is:\", cut_value)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "01920bcd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of the cut is: 4\n", + "The value of the cut is: 4\n", + "The value of the cut is: 4\n", + "The value of the cut is: 4\n" + ] + } + ], + "source": [ + "for p in positions:\n", + " result = list(final_bits.keys())[p[0]]\n", + " bin = [int(digit) for digit in result]\n", + " bin.reverse()\n", + " cut_value = evaluate_sample(bin, graph)\n", + " print(\"The value of the cut is:\", cut_value)\n", + " #print(list(final_bits.keys())[p[0]])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "968c5412", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of the cut is: 5\n", + "The value of the cut is: 4\n", + "The value of the cut is: 5\n", + "The value of the cut is: 2\n" + ] + } + ], + "source": [ + "# results from https://quantum.cloud.ibm.com/docs/en/tutorials/quantum-approximate-optimization-algorithm\n", + "result = [\"01011\", \"10101\", \"10110\", \"11000\"]\n", + "for r in result:\n", + " bin = [int(digit) for digit in r]\n", + " bin.reverse()\n", + " cut_value = evaluate_sample(bin, graph)\n", + " print(\"The value of the cut is:\", cut_value)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/qbraid_algorithms/qaoa/__init__.py b/qbraid_algorithms/qaoa/__init__.py index 57d3529..97d580a 100644 --- a/qbraid_algorithms/qaoa/__init__.py +++ b/qbraid_algorithms/qaoa/__init__.py @@ -11,7 +11,10 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. - +""" + Quantum Approximate Optimization Algorithm (QAOA) used to define cost and mixer Hamiltonians + and generate QASM programs accordingly. +""" from .qaoa import QAOA __all__ = ["QAOA"] diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index 3d5b792..56f1c5e 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -1,25 +1,54 @@ -from qbraid_algorithms.qtran import QasmBuilder, std_gates, GateLibrary, GateBuilder +# Copyright 2025 qBraid +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Quantum Approximate Optimization Algorithm (QAOA) Implementation + +This module provides an implementation of the Quantum Approximate Optimization Algorithm ansatz +for different standard mixer and cost Hamiltonians, namely maximum-cut, maximum clique and minimum vertex cover. +""" import networkx as nx -class QAOA: +from qbraid_algorithms.qtran import QasmBuilder, std_gates +class QAOA: + """ + Quantum Approximate Optimization Algorithm (QAOA) class used to define cost and mixer Hamiltonians + and generate QASM programs accordingly. + """ def __init__(self, num_qubits : int, qasm_version : int = 3, use_input : bool = True): self.builder = QasmBuilder(num_qubits, version=qasm_version) self.use_input = use_input + self.mixer_hamiltonian = "" + self.cost_hamiltonian = "" + self.layer_circuit = "" self._x_mixer_count = 0 self._max_clique_cost_count = 0 self._xy_mixer_count = 0 self._min_vertex_cover_cost_count = 0 self._maxcut_cost_count = 0 - def xy_mixer(self, graph : nx.Graph) -> str: - """ + r""" Generate XY mixer Hamiltonian subroutine. xy_mixer_hamiltonian = $$\frac{1}{2}\sum_{(i,j)\in E(G)} X_iX_j + Y_iY_j$$ - This mixer was introduced in From the Quantum Approximate Optimization Algorithm to a Quantum Alternating Operator Ansatz by Stuart Hadfield, Zhihui Wang, Bryan O’Gorman, Eleanor G. Rieffel, Davide Venturelli, and Rupak Biswas Algorithms 12.2 (2019). + This mixer was introduced in + From the Quantum Approximate Optimization Algorithm to a Quantum Alternating Operator Ansatz + by Stuart Hadfield, Zhihui Wang, Bryan O’Gorman, + Eleanor G. Rieffel, Davide Venturelli, and Rupak Biswas Algorithms 12.2 (2019). Args: graph : nx.Graph Graph that describes the problem @@ -28,11 +57,12 @@ def xy_mixer(self, graph : nx.Graph) -> str: """ if len(graph.nodes) > self.builder.qubits: raise ValueError( - f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + f"The graph provided has more nodes" + f"({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" ) - + std = self.builder.import_library(lib_class=std_gates) - + mixer_name = f"qaoa_xy_mixer_{self._xy_mixer_count}_{self.builder.qubits}" self._xy_mixer_count += 1 @@ -55,14 +85,15 @@ def xy_mixer(self, graph : nx.Graph) -> str: std.end_subroutine() return mixer_name - + def x_mixer(self, graph : nx.Graph) -> str: - """ + r""" Generate X mixer Hamiltonian subroutine. x_mixer_hamiltonian = $$\sum_{i} X_i$$ - This mixer is used in A Quantum Approximate Optimization Algorithm by Edward Farhi, Jeffrey Goldstone, Sam Gutmann [arXiv:1411.4028]. + This mixer is used in A Quantum Approximate Optimization Algorithm + by Edward Farhi, Jeffrey Goldstone, Sam Gutmann [arXiv:1411.4028]. Args: graph : nx.Graph Graph that describes the problem @@ -71,10 +102,11 @@ def x_mixer(self, graph : nx.Graph) -> str: """ if len(graph.nodes) > self.builder.qubits: raise ValueError( - f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + f"The graph provided has more nodes" + f"({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" ) std = self.builder.import_library(lib_class=std_gates) - + mixer_name = f"qaoa_x_mixer_{self._x_mixer_count}_{self.builder.qubits}" self._x_mixer_count += 1 @@ -93,9 +125,9 @@ def x_mixer(self, graph : nx.Graph) -> str: std.end_subroutine() return mixer_name - + def min_vertex_cover_cost(self, graph : nx.Graph) -> str: - """ + r""" Generate min vertex cover cost Hamiltonian subroutine. cost_hamiltonian $$3\sum_{(i,j)\in E(G)} (Z_i \otimes Z_j + Z_i + Z_j)-\sum_{i \in V(G)} Z_i$$ @@ -109,10 +141,11 @@ def min_vertex_cover_cost(self, graph : nx.Graph) -> str: """ if len(graph.nodes) > self.builder.qubits: raise ValueError( - f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + f"The graph provided has more nodes" + f"({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" ) std = self.builder.import_library(lib_class=std_gates) - + cost_name = f"qaoa_min_vertex_cover_cost_{self._min_vertex_cover_cost_count}_{self.builder.qubits}" self._min_vertex_cover_cost_count += 1 @@ -132,17 +165,16 @@ def min_vertex_cover_cost(self, graph : nx.Graph) -> str: std.cnot(i,j) std.rz("3 * 2 * gamma", i) std.rz("3 * 2 * gamma", j) - + for i in graph.nodes: std.rz("-2 * gamma", i) std.call_space = old_call_space std.end_subroutine() - return cost_name - + def max_clique_cost(self, graph : nx.Graph) -> str: - """ + r""" Generate max clique cost Hamiltonian subroutine. cost_hamiltonian $$3\sum_{(i,j)\in E(\bar{G})} (Z_i \otimes Z_j - Z_i - Z_j)+\sum_{i \in V(G)} Z_i$$ @@ -155,10 +187,11 @@ def max_clique_cost(self, graph : nx.Graph) -> str: """ if len(graph.nodes) > self.builder.qubits: raise ValueError( - f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + f"The graph provided has more nodes" + f"({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" ) std = self.builder.import_library(lib_class=std_gates) - + cost_name = f"qaoa_max_clique_cost_{self._max_clique_cost_count}_{self.builder.qubits}" self._max_clique_cost_count += 1 @@ -180,21 +213,23 @@ def max_clique_cost(self, graph : nx.Graph) -> str: std.cnot(i,j) std.rz("-3 * 2 * gamma", i) std.rz("-3 * 2 * gamma", j) - + for i in graph.nodes: std.rz("2 * gamma", i) std.call_space = old_call_space std.end_subroutine() - return cost_name - def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : - """ + def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : + r""" Generate cost hamiltonian and mixer hamiltonian subroutines. cost_hamiltonian = $$\sum_{E(graph)} Z_i \otimes Z_j$$ - This Hamiltonian is decribed in Quantum Approximate Optimization Algorithm for MaxCut: A Fermionic View by Zhihui Wang, Stuart Hadfield, Zhang Jiang, Eleanor G. Rieffel [arXiv:1706.02998]. + This Hamiltonian is decribed in + Quantum Approximate Optimization Algorithm for MaxCut: + A Fermionic View by Zhihui Wang, Stuart Hadfield, + Zhang Jiang, Eleanor G. Rieffel [arXiv:1706.02998]. mixer_hamiltonian = $$\sum_{i} X_i$$ Args: @@ -205,10 +240,11 @@ def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : """ if len(graph.nodes) > self.builder.qubits: raise ValueError( - f"The graph provided has more nodes ({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" + f"The graph provided has more nodes" + f"({len(graph.nodes)}) than the qubits initialized ({self.builder.qubits})" ) std = self.builder.import_library(lib_class=std_gates) - + cost_name = f"qaoa_maxcut_cost_{self._maxcut_cost_count}_{self.builder.qubits}" self._maxcut_cost_count += 1 @@ -229,14 +265,13 @@ def qaoa_maxcut(self, graph : nx.Graph) -> tuple[str, str] : std.call_space = old_call_space std.end_subroutine() - # mixer hamiltonian $$\sum_{i} X_i$$ mixer_name = self.x_mixer(graph) return mixer_name, cost_name - + def setup_maxcut(self, graph : nx.Graph): - """ + r""" Perform the setup for a Max Cut problem with the given graph. Args: @@ -247,7 +282,7 @@ def setup_maxcut(self, graph : nx.Graph): self.layer_circuit = self.layer(self.cost_hamiltonian, self.mixer_hamiltonian) def layer(self, cost_ham : str, mixer_ham : str) -> str : - """ + r""" Create layer circuit. Args: cost_ham : str @@ -276,8 +311,8 @@ def layer(self, cost_ham : str, mixer_ham : str) -> str : return name - def generate_algorithm(self, depth : int, layer : str = "", param : list[float] = []) -> str: - """ + def generate_algorithm(self, depth : int, layer : str = "", param : list[float] | None = None) -> str: + r""" Load the Quantum Approximate Optimization Algorithm (QAOA) ansatz as a pyqasm module. Args: @@ -293,14 +328,16 @@ def generate_algorithm(self, depth : int, layer : str = "", param : list[float] Returns: (str) qasm code containing the QAOA ansatz circuit """ + if param is None and self.use_input is False: + raise ValueError( + "Param cannot be None if use_input is False" + ) std = self.builder.import_library(lib_class=std_gates) layer = self.layer_circuit if layer == "" else layer num_qubits = self.builder.qubits - #self.builder.claim_qubits(self.builder.qubits) - #self.builder.claim_qubits(1) - + for i in range(depth): if self.use_input: std.add_input_var(f"gamma_{i}", qtype="float") @@ -308,10 +345,10 @@ def generate_algorithm(self, depth : int, layer : str = "", param : list[float] else: std.classical_op(f"float gamma_{i} = {param[i*2]}") std.classical_op(f"float alpha_{i} = {param[i*2+1]}") - + for q in range(self.builder.qubits): std.reset(q) - + for q in range(self.builder.qubits): std.h(q) diff --git a/qbraid_algorithms/qaoa/test.ipynb b/qbraid_algorithms/qaoa/test.ipynb deleted file mode 100644 index 1d68161..0000000 --- a/qbraid_algorithms/qaoa/test.ipynb +++ /dev/null @@ -1,463 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "aba58bd7", - "metadata": {}, - "outputs": [], - "source": [ - "from matplotlib import pyplot as plt\n", - "import networkx as nx\n", - "from qbraid_algorithms.qaoa import QAOA\n", - "import pyqasm\n", - "\n", - "from qiskit_qasm3_import import parse\n", - "from qiskit_ibm_runtime import Session, Sampler as Sampler, Estimator\n", - "from qiskit_aer import AerSimulator\n", - "from scipy.optimize import minimize\n", - "from qiskit.visualization import plot_histogram\n", - "from qiskit.quantum_info import SparsePauliOp\n", - "import numpy as np\n", - "from typing import Sequence" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "18ff0ac8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "edges = [(0, 1), (0, 2), (0, 4), (1, 2), (2, 3), (3, 4)]\n", - "graph = nx.Graph(edges)\n", - "positions = nx.spring_layout(graph, seed=1)\n", - "\n", - "nx.draw(graph, with_labels=True, pos=positions)\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "cb51638b", - "metadata": {}, - "outputs": [], - "source": [ - "objective_func_vals = []" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "9d2812e8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Cost Function Hamiltonian: SparsePauliOp(['IIIZZ', 'IIZIZ', 'ZIIIZ', 'IIZZI', 'IZZII', 'ZZIII'],\n", - " coeffs=[1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j, 1.+0.j])\n" - ] - } - ], - "source": [ - "def build_max_cut_paulis(graph: nx.Graph) -> list[tuple[str, float]]:\n", - " \"\"\"Convert the graph to Pauli list.\n", - " \n", - " This function does the inverse of `build_max_cut_graph`\n", - " \"\"\"\n", - " pauli_list = []\n", - " for i,j in graph.edges:\n", - " pauli_list.append((\"ZZ\", [i, j], 1))\n", - " return pauli_list\n", - "\n", - "n = 5\n", - "max_cut_paulis = build_max_cut_paulis(graph)\n", - "cost_hamiltonian = SparsePauliOp.from_sparse_list(max_cut_paulis, n)\n", - "print(\"Cost Function Hamiltonian:\", cost_hamiltonian)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "5e8714c7", - "metadata": {}, - "outputs": [], - "source": [ - "def cost_function_res(params):\n", - " qaoa = QAOA(5, use_input=False)\n", - " qaoa.setup_maxcut(graph=graph)\n", - " program = qaoa.generate_algorithm(3, param=params)\n", - " module = pyqasm.loads(program)\n", - " module.unroll()\n", - " loaded_circuit = parse(pyqasm.dumps(module))\n", - " aer_sim = AerSimulator()\n", - " with Session(backend=aer_sim):\n", - " sampler = Sampler()\n", - " sampler.options.dynamical_decoupling.enable = True\n", - " sampler.options.dynamical_decoupling.sequence_type = \"XY4\"\n", - " sampler.options.twirling.enable_gates = True\n", - " sampler.options.twirling.num_randomizations = \"auto\"\n", - " result = sampler.run([loaded_circuit], shots=10000).result()\n", - " return result[0].data.cb.get_counts(), result[0].data.cb.get_int_counts()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "76eec508", - "metadata": {}, - "outputs": [], - "source": [ - "def cost_function(params):\n", - " qaoa = QAOA(5, use_input=False)\n", - " qaoa.setup_maxcut(graph=graph)\n", - " program = qaoa.generate_algorithm(3, param=params)\n", - " module = pyqasm.loads(program)\n", - " module.unroll()\n", - " loaded_circuit = parse(pyqasm.dumps(module))\n", - " aer_sim = AerSimulator()\n", - " with Session(backend=aer_sim) as session:\n", - " sampler = Estimator(mode=session)\n", - " sampler.options.default_shots = 20000\n", - " pub = (loaded_circuit, cost_hamiltonian, [])\n", - " result = sampler.run([pub]).result()\n", - " cost = result[0].data.evs\n", - " objective_func_vals.append(cost)\n", - " return cost" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "df258b64", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " message: Return from COBYLA because the trust region radius reaches its lower bound.\n", - " success: True\n", - " status: 0\n", - " fun: -3.4163\n", - " x: [ 2.854e+00 2.644e+00 2.693e+00 2.873e+00 2.865e+00\n", - " 3.000e+00]\n", - " nfev: 46\n", - " maxcv: 0.0\n" - ] - } - ], - "source": [ - "initial_gamma = np.pi\n", - "initial_beta = np.pi / 2\n", - "init_params = [initial_beta, initial_beta, initial_beta, initial_gamma, initial_gamma, initial_gamma]\n", - "result = minimize(\n", - " cost_function,\n", - " init_params,\n", - " method=\"COBYLA\",\n", - " tol=1e-2,\n", - " )\n", - "print(result)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "e8596cb2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+cAAAINCAYAAABcVg7sAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZbVJREFUeJzt3Qd4m9X59/Fblmx57x3b2XvvBAokJJCwKTTMlsKflwIFCpSWQltWS5sWWqBsWkppadgjrDICgTCTkL33smPHK/G2ZVvSe50jyXESJ/GQ9Gh8P9elS4+XdGIE5Kf7PvcxOZ1OpwAAAAAAAMNEGPfUAAAAAABAIZwDAAAAAGAwwjkAAAAAAAYjnAMAAAAAYDDCOQAAAAAABiOcAwAAAABgMMI5AAAAAAAGI5wDAAAAAGAwi4QRh8MhxcXFkpCQICaTyejlAAAAAABCnNPplNraWsnNzZWIiKPXx8MqnKtgnp+fb/QyAAAAAABhprCwUPLy8o769bAK56pi7vmlJCYmGr0cAAAAAECIq6mp0UViTx49mrAK555WdhXMCecAAAAAAH853tZqBsIBAAAAAGAwwjkAAAAAAAYjnAMAAAAAYDDCOQAAAAAABiOcAwAAAABgMMI5AAAAAAAGI5wDAAAAAGAwwjkAAAAAAAYjnAMAAAAAYDDCOQAAAAAABiOcAwAAAABgMMI5AAAAAAAGI5wDAAAAAGAwwjkAAAAAAAYjnAMAAAAAYDDCOQAAAAAABiOcAwHM4XDKqsIqabU7jF4KAAAAAB8inAMBbP6qvXL+E1/Lgx9vNnopAAAAAHyIcA4EsNWFVfr+rRV7dRUdAAAAQGginAMBrLi6Sd+X1dpkVZErqAMAAAAIPYRzIICVVDe2XX+0fp+hawEAAADgO4RzIIDtc1fOlY/Xl4rTSWs7AAAAEIoI50CAsrXapaKuWV+bI0yys6JetpbVGb0sAAAAAD5AOAcCvGoeHRkhJw9M19cf09oOAAAAhCTCORCgiqtc4Tw3KUZmDc/W1x+tLzV4VQAAAAB8gXAOBPgwuJzkaJk5LEsiTCJr91bL3qqDQ+IAAAAAhAbCORCgStxt7dmJMZIeb5UJvVP1x7S2AwAAAKGHcA4EqGJ3hTw3OVrfnz48S99zpBoAAAAQegjnQIBXznOSYvS9Z9/50p37ZX+9a4o7AAAAgNBAOAcCvHKu9pwr+amxMiwnURxOkU82MhgOAAAACCWEcyBA7as5OK3dw9Pa/jFT2wEAAICQQjgHAlBjs12qGloOqZy3b23/cmu5NDS3GrY+AAAAAN5FOAcCULH7GLV4q0USoyPbPj8kO0EKUmPF1uqQRZvLDVwhAAAAAG8inAMBqKTKMwzuYNVcMZlMMoup7QAAAEDIIZwDAVw5zz4snLdvbf90U5k0tzr8vjYAAAAA3kc4BwK4ct5+GJzH2IIUSY+3Sm1TqyzeUWnA6gAAAAB4G+EcCEAl7sp5+2FwHuYIk5w2LFNf09oOAAAAhAbCORCAiquPXjlXTne3ti/YUCoOdfA5AAAAgKBGOAcCUEnV0Svnygn90/Qk97Jam6wqqvLz6gAAAAB4G+EcCED73JXznKNUzq0Ws0wfQms7AAAAECoI50CAqW1qkVpbq77OPUrlXPEcqfbx+lJxOmltBwAAAIIZ4RwIMCXuqnlSTKTERlmO+n3TBmdKlDlCdlbUy9ayOj+uEAAAAIC3Ec6BAFPs2W/ewRnn7ak95ycOSNPXH62jtR0AAAAIZoRzIEAr58cL58os99T2jzYQzgEAAIBgRjgHAnZSe8fD4NqbOSxLIkwi6/bWyF73zwEAAAAIPoRzIGDPOD9+5Tw93ioTeqfq64+Z2g4AAAAELcI5EGBKqj17zo9fOVdOd09t50g1AAAAIHgRzoFA3XN+jGPUOtp3vnTnftlf3+zTtQEAAADwDcI5EEDUeeUlVZ629s5VzvNTY2VYTqI4nCKfbCz18QoBAAAA+ALhHAgg1Y0t0thi19fZndhzfnhrO/vOAQAAgOBEOAcCSLG7ap4WFyXRkeZO/5yntf2LrRVSb2v12foAAAAA+AbhHAjAYXBdqZorQ7ITpCA1VppbHfLFlnIfrQ4AAACArxDOgQA8Rq2zk9o9TCaTzGJqOwAAABC0giqcf/HFF3LOOedIbm6uDiPz5883ekmAV5VUuSrnuZ2c1N5Ra/unm8p0BR0AAABA8AiqcF5fXy+jR4+WJ554wuilAL49Rq2LlXNlbEGKpMdbpbapVRbvqPTB6gAAAAD4ikWCyBlnnKFvQKgq7kHl3BxhktOGZcpLSwt1a/vJgzJ8sEIAAAAAEu6V866y2WxSU1NzyA0IZPtqul85V053t7Yv2FAqDnXwOQAAAICgENLhfO7cuZKUlNR2y8/PN3pJwFE5nc52be1dr5wrJ/RPk3irRcpqbbKysMrLKwQAAADgKyEdzu+8806prq5uuxUWFhq9JOCoKuub9SA3k6nrR6l5WC1mmT4kU19/zNR2AAAAIGiEdDi3Wq2SmJh4yA0IVCVVrqp5RrxVIs3d/1ez/ZFqqhoPAAAAIPCFdDgHgklxdWOPWto9pg3OlChzhOyqbJCtZXVeWh0AAAAAXwqqcF5XVyerVq3SN2Xnzp36es+ePUYvDfDaGefdHQbnofacnzggTV9/tI7WdgAAACAYBFU4X7ZsmYwdO1bflJ///Of6+u677zZ6aUCPtQ2D68Yxaoeb5Z7a/tEGwjkAAAAQDILqnPNp06axhxYhq9gdznN7WDlXZg7Lkoi31sq6vTVSdKBB8lJivbBCAAAAAL4SVJVzICza2r1QOU+Pt8qE3qn6+uP1pT1+PAAAAAC+RTgHAsTBM857XjlXTm83tR0AAABAYCOcAwHA7nBKaY27rd0LlfP2+86/27Vf9tc3e+UxAQAAAPgG4RwIABV1Nml1OMUcYZLMBO+E8/zUWBmakygOp8gnG2ltBwAAAAIZ4RwIAMXu/eZZCVYd0L1llru1/WNa2wEAAICARjgHAmi/eXaSd6rmh7e2f7G1QuptrV59bAAAAADeQzgHAqhynpPsnWFwHkOyE6QgNVaaWx2yaEu5Vx8bAAAAgPcQzoEAqpznerlybjKZ2lrbmdoOAAAABC7CORAASqobvXqMWket7Qs3lekKOgAAAIDAQzgHAkBxlXePUWtvbEGKpMdbpbapVRbvqPT64wMAAADoOcI5EAD2udvafVE5V9PfTxuWqa9pbQcAAAACE+EcMFir3SFlte5w7oPKuXK6u7V9wYZScaiDzwEAAAAEFMI5YLDSWpuovBxpNkl6nNUnz3FC/zSJt1qkrNYmKwurfPIcAAAAALqPcA4YrMR9jFpWYrRERJh88hxWi1mmD6G1HQAAAAhUhHPAYMVtx6h5f795e2eMcLW2f7CuRJxOWtsBAACAQEI4BwKkcu6r/eYepwzKEKslQgr3N8qGkhqfPhcAAACAriGcAwYr8eGk9vbirBYd0JUP19HaDgAAAAQSwjlgsGJ35dwXZ5wf7oyRrtZ2wjkAAAAQWAjngMH21fincq6cOiRLT4XfWlYn28rqfP58AAAAADqHcA4YrLjKE859XzlPiomUE/qn6+sP15X4/PkAAAAAdA7hHDCQrdUuFXU2fZ2b7PvKefup7R9ypBoAAAAQMAjngIFKq13BXE1RT4mN9MtznjYsS9Rx6uv21kjh/ga/PCcAAACAYyOcAwYqrnYfo5YULSaTyS/PmRZvlUl9U/U1g+EAAACAwEA4BwxU0hbO/dPS7nHGiBx9T2s7AAAAEBgI50AgDIPzwzFq7c0a7tp3vnz3ASl1T4sHAAAAYBzCORAAlfNcP1fOs5OiZWxBsr7+iOo5AAAAYDjCOWCgEoMq54dMbWffOQAAAGA4wjlgoJLqJkMq58rs4a5950t27pf99c1+f34AAAAABxHOgUAYCGdA5bwgLVaG5SSK3eGUBRuongMAAABGIpwDBmlstsuBhhZDprV70NoOAAAABAbCOWBw1TwuyiyJ0RZD1jDbHc6/2lYhNU2uNwoAAAAA+B/hHDB4v7manG4ymQxZw8CsBOmfESctdqcs3FhmyBoAAAAAEM4BwxRXuY9RSzampd3jjBGuwXC0tgMAAADGIZwDBlfOc5L8Pwyuo9b2z7eUSUNzq6FrAQAAAMIV4RwwelK7QcPgPIbnJkpeSow0tThk0eZyQ9cCAAAAhCvCOWCQ4ir3GecGHKPWntrv3ja1fT2t7QAAAIARCOeAQfa1tbUbWzlv39quhsLZWu1GLwcAAAAIO4RzwCDF7rZ2oyvnytj8FMlKtEqtrVW+3lZh9HIAAACAsEM4BwxQZ2uV2ibX8LXsAKicR0SYZNZwd2s7U9sBAAAAvyOcAwYocR+jlhBtkXirRQLBbHc4X7ChVFrtDqOXAwAAAIQVwjlggGL3fvPcAKiae0zqmyopsZFyoKFFlu7cb/RyAAAAgLBCOAcMrJznBMB+cw+LOUJOH+aqnn9AazsAAADgV4RzwMDKeSBMau9oavtH6/eJw+E0ejkAAABA2CCcAwZWznOTAqdyrpwwIE0SrBYpq7XJysIDRi8HAAAACBuEc8AAJZ7KeXJgVc6tFrPMGJqprz9YS2s7AAAA4C+Ec8AAJdWBWTlv39qu9p07nbS2AwAAAP5AOAf8TAXeQK2cK6cMypSYSLPsrWqU9cU1Ri8HAAAACAuEc8DPahpbpaHZrq9zArByHhNllmmDM/T1B+tKjF4OAAAAEBYI54CfFbtb2tWZ4tGRZglEtLYDAAAA/kU4Bwzabx5ox6i1d+qQTIkyR8iO8nrZVlZn9HIAAACAkEc4B/ysuMq13zw3OfBa2j0SoiPlewPT26rnAAAAAHyLcA74WTBUzpXZww+2tgMAAADwLcI54Gcl7sp5TgBXzpXThmWJOcIkG0tqZHdlvdHLAQAAAEIa4RwwaCBcboBXzlPiomRKv1R9/SHVcwAAAMCnCOeAn+3znHEegMeoHY7WdgAAAMA/COeAH6ljyUrc4Tw3ObAr58qs4dliMomsKqxq2ysPAAAAwPsI54Af7a9vFlurQ19nJQZ+5TwzMVrGF6To64+ongMAAAA+QzgH/MhTNU+Pt0qUJTj+9Zs9gtZ2AAAAwNeCIx0AIaK4yj0MLsAntR/e2q58t2u/VNTZjF4OAAAAEJII54ABlfNgGAbnkZ8aKyN7JYnDKbJgQ6nRywEAAABCEuEcMOAYtZwAP0btcLS2AwAAAL5FOAf8qKTKM6k9eCrn7cP5N9sqpLqxxejlAAAAACGHcA4YcsZ5cFXO+2fEy6CseGl1OOXTjbS2AwAAAN5GOAcMaGsPtsq5Mts9GO5DWtsBAAAAryOcA37icDiltCY4K+fK7BE5+n7RlnKpt7UavRwAAAAgpBDOAT9Rx5C12J0SYRLJTLBKsBmakyC902LF1uqQzzeXG70cAAAAIKQQzgE/KXbvN89MiBaLOfj+1TOZTAdb29fT2g4AAAB4U/AlBCBIlVS5j1ELwv3mh09tX7ixVJpa7EYvBwAAAAgZhHPAz5Xz3CDcb+4xOi9ZcpKipb7ZLl9trTB6OQAAAEDIIJwD/q6cJwVv5TwiwiSzaG0HAAAAvI5wDvhJieeM8+TgrZy3b21fsKFUWuwOo5cDAAAAhATCOeAnJZ4zzoO4cq5M7JMqybGRUt3YIhuKa4xeDgAAABASCOeAn4RK5dwcYZIBGfH6es/+BqOXAwAAAIQEwjngB612h5TWNIVE5VwpSIvV94RzAAAAwDsI54AflNXaxOEUsUSYJC3eKsGuINUdzisJ5wAAAEBYhvMnnnhC+vTpI9HR0TJ58mRZunSp0UsCOr3fPCsxWreFh0w4p3IOAAAAhF84f+WVV+TnP/+53HPPPbJixQoZPXq0zJo1S8rKyoxeGnBMxVXulvbk4G9pV3rT1g4AAAB4lUWCyEMPPSTXXHONXHXVVfrjp59+Wt5//3157rnn5I477pBQ8ZP/LJNIS4QkxUQecUuMPvTjhGiLPnsawVE5z0kK7mFwHvnuynlxdaM0tzokyhJU7/MBAAAAASdownlzc7MsX75c7rzzzrbPRUREyMyZM+Xbb7/t8GdsNpu+edTUBP6xT3aHUz7eUNrp7zeZRBKsFkmKPUqIj42UGUOyZHB2gk/Xjc5VznNCpHKeEW+VmEizNLbYZW9Vo/RNjzN6SQAAAEBQC5pwXlFRIXa7XbKysg75vPp406ZNHf7M3Llz5b777pNg4nA65aGLRuszpNvfag77WN2aWhzidIrUNLXqW6G4qrOH+/c3u+SrX50qkWaqm8afcR4alXOTyaT3nW8urZXdlfWEcwAAACBcwnl3qCq72qPevnKen58vgUwF6AvG5XXqe22t9o6De4O6V4G9Rd5auVdKa2yyYEOpnDkyx+frR8f2ec44D4Fj1Nq3tqtwXsi+cwAAACB8wnl6erqYzWYpLT205Vt9nJ2d3eHPWK1WfQtVVotZMhPU7eiBLzbKLI8t3Cb/XbybcG6gYnc4z00Ojcq5wsR2AAAAwHuCps85KipKxo8fL59++mnb5xwOh/546tSphq4tkF0yqUDUvLhvtlfK9vI6o5cTltTAtIo6W8hVzj0T23dz1jkAAAAQPuFcUS3q//jHP+Tf//63bNy4Ua6//nqpr69vm96OI/VKjpFTh2Tq63mL9xi9nLBUWtOkZwOoieapcVESKqicAwAAAGEazi+++GL5y1/+InfffbeMGTNGVq1aJR9++OERQ+JwqMun9Nb3ry8vlKYWu9HLCTvFVZ5j1KL1ILVQ4TlOTe05d6p3HwAAAACERzhXbrzxRtm9e7c+Im3JkiUyefJko5cU8E4ZmCH5qTF6ovu7q4uNXk7YKQnBYXBKXkqMPsqvvtkulfXNRi8HAAAACGpBF87RdRERJrlskqt6/t8ltLb7W3GIHaPmER1pluxE1xsOtLYDAAAAPUM4DxNzJuRJpNkkqwurZN3eaqOXE1ZKqtyV8+TQqpwf3toOAAAAoPsI52EiPd4qZ4xwHaWmjlWD/5S4K+c5IVY5V3q7wzkT2wEAAICeIZyHkR+6B8O9vapYappajF5O2O05zw3ByjkT2wEAAADvIJyHkYl9UmRQVrw0ttjlrRV7jV5OGA6EC73KeYH7rHPCOQAAANAzhPMwoo7xunyyezDc4t0cf+UH6ui6/e5J5qE2rf2Qyjlt7QAAAECPEM7DzPfH9ZKYSLNsLauTpTv3G72csKmaq995UkykhGo431fTpN+IAAAAANA9hPMwkxgdKeePzdXX8zhWzedKqtzD4JKjdedCqEmNi5K4KLO+Ljrg+rMCAAAA6DrCeRjytLZ/sK5EKupsRi8npBV7hsGF4H5zRb3hUJAWp685Tg0AAADoPsJ5GBrRK0lG5ydLi90pry4rNHo54VE5D8H95h4Fqa43HnZX1hu9FAAAACBoEc7D1A8nF+j7F5fsEbuDwXC+rpznJIdm5fzQ49RoawcAAAC6i3Aeps4ZnasHlKl9wl9sKTd6OSFrX7UrsOaGcuXc3dbOcWoAAABA9xHOw1R0pFl+MD5PX89bstvo5YT+GedhUTmnrR0AAADoLsJ5GLvM3dq+cFOZ7HXvjYZ3FVeFQeW8LZw3iNPJFgkAAACgOwjnYax/Rryc0D9N1JbzlzhWzevqba1S09Sqr7NDOJz3So6RCJNIU4tDypn+DwAAAHQL4TzM/XCK61i1l78rlOZWh9HLCSkl7v3mCVaLJERHSqiKskRIjvuouD2V7DsHAAAAuoNwHuZOG5YlmQlWfd75gg2lRi8npBRXefabh27VvKPWdgAAAABdRzgPc5HmCLlkYr6+/u9iBsP5onLuqSqHst5phHMAAACgJwjnkEsmFeg9w9/uqJRtZXVGLyfkKue5YVA5z/dUzmlrBwAAALqFcA7JTY6RU4dk6WuOVfOecKqc09YOAAAA9AzhHNoPp7iOVXtjeZE0NtuNXk5onXEewpPaPWhrBwAAAHqGcA7t5IEZkp8ao4/+endNsdHLCalwrjoTwqVyXlZr480dAAAAoBsI59AiIkxy2STXsWrzGAzXY06nU0qqGsOmcp4UEykJ0RZ9XXiA6jkAAADQVYRztLloQp5EmSNkdVG1rC2qNno5QU11INS7K8jhsOfcZDIdbG1nKBwAAADQZYRztEmLt8oZI7P1NceqeWcYXHJspMREmSUceFrbd7PvHAAAAOgywjkO8cMprtb2d1YXS3Vji9HLCVol7mPUwqFqfvhxaoWEcwAAAKDLCOc4xITeKTI4K0EaW+zy1ooio5cTtIrdlfPcMNhv7tE7NU7fM7EdAAAA6DrCOY7YO3y5+1i1/y7ZoweboQeV8+TwCedtbe2V9UYvBQAAAAg6hHMc4ftje0lslFm2ldXJkp37JVCpNw7eW1MsDy/Y0rbHO9Aq5+HU1u4J54UHGsXh4E0dAAAAoCsI5zhCQnSknDeml76et2SPBCI1Tf4HT38rN764Uv726VY55YHP5ddvrQ2Y/c772s44D5/KufqzmiNM0tzq0OedAwAAAOg8wjk6dPlkV2v7h+tKpDyAglZFnU1+9foaOfeJr2T57gO6wj8mP1ma7Q55cckemf6Xz+WXr62WnRXGtlaXuMN5OFXOLeYI6ZXs+vPS2g4AAAB0DeEcHRrRK0mH3ha7U15dVmj0cnQ19tkvd8j0Bz+XV5YVitoKr9rvF942TebfcKK8eu1UOWlgurQ6nPLa8iKZ8dfP5eaXV8rW0lpD2u2Lqzxt7eFTOW/f2s5QOAAAAKBrCOc47rFqqiJtN3AP8eeby2T2376Q+9/fKLW2VhnZK0neuH6qPHzxGMl2h99JfVPlhasny1s/PUFmDMkUtdy3VxXL6Y98Idf/d7msL67223oPNLSIrdWhrz3rCxcFaRynBgAAAHSHpVs/hbBw9qgc+f17G2RvVaMs2lImpw7J8uvzq9Z09fwLN5Xpj9Pjo+T2WUPkB+PzJCLC1OHPjC1IkX9eOVHW7a2WJz7bJh+s29d2mzk0U248daDuCPCFA/XNutX+s80H12u1mCWctE1sJ5wDAAAAXUI4x1FFR5plzvg8efarnTJv8R6/hfPaphZ5fOE2ee7rnbqt3hJhkqtO7CM3zRgoidGRnW7Lf+qH42VLaa1+LDXV/ZONZfqm2t9/NmOgTOyT2qPW9V2VDbJs134dyL/btV+2lx+6z3poTqKEGyPb2lvsDv2GzPTBmTLaR2/AAAAAAL5COMcxXTa5QIfzhZvLpOhAg+SluMKXL6jjt95YUSQPfLS5bQjdtMEZctfZw6R/Rny3HnNQVoI8eulYuWXmQHny8+3y1sq98uXWCn2b3DdVh/QT+qfp892Pt+ddtcYv23VAlu12BfKKuuYjvq9/RpxM6J0qE/qkyKwR2RJu2o5TMyCcqzdgHvlkq3y2uVzevuFEvz8/AAAA0BOEcxxTv4x4OXFAmny9rVJeWrpHfjlriE+eZ+WeA3LvuxtkdWGV/rhvepzcdfZQr1Xr1Z/jL3NGy80zXCH99eWF+gz3y59dIuMKkuWmUwfqNwI8Ib26oUVW7HEF8e92HdDr8uwj94gyR8iovCQZ3ydFB/LxvVMkNS5Kwplnz7l646LO1irxVv/9J2blHtdrZ2NJjbTaHXp6PAAAABAsCOc4rh9O7q3D+SvfFcrNMwZJlMV7oaespkn+9OEmeXPFXv2xCnM/mzFArjyhr1efxyM/NVbmXjBSP8czi3boNxxW7KmSq57/Tkb0SpSRvZJlxe4DsqWsVk+Eby8lNlIH8Al9UmVC7xTdOq9a/3GQ2naQHBspVQ0tunruz9b+1UXVbV0OOyrqddcEAAAAECwI5ziumcOyJDPBKmW1Nrlr/joZmBUvsVEWfca4usVZPdeWQz62WiKO2i5ua7XLc1/tkscXbpX6Zrv+nNrf/svZgyUzwfcTztX54/eeO1x+Or2/PPvlTnnh292ybm+Nvnmo6r0O4+5ArlrWj9f+DpHeqbFS1VCt9537K5yrQL6x+OA/uw3FNYRzAAAABBXCOY4r0hwhl0wqkEc/3arPGO8sNVA9TgV2a7vg7v54R3l929CwsQXJcu85ww0Z4qXeCPj1mUPlulP6y4tLdktNU6uMK0jRoTwjwer39YQC1Z2gqth7Kv2373zTvhppth/cdrChpEbOH9vLb88PAAAA9BThHJ1y3Sn9RNWMy+ts0mBr1dXuhuZWaVD3NrvUN7dKY7PrvqnFFZLUWePqXHJ1E3ENeGtPVePvOGOInD+m11GPRvMXtVdcHbOG4JzY7plVoBob1HYEVTkHAAAAggnhHJ2iKt+3njaoU99rdzh1cHeFdbvU21qlscV1r8N8s11X1U8fnu3XgWHwj95pBoRz937zUwZlyOeby3XlXB13xzYEAAAABAuSEbzOHGGShOhIfUN4trX7O5yvKXJVzueMz9fH5O2vb5bSGptkJ/l+fgEAAADgDZw1BMAnbe1FBxp0F4WvqSPbtpbV6euJfVP04D5lQ4mrmg4AAAAEA8I5AK9Pwo80m6TF7pR9NU0+f751e6v1PvPcpGg94G+Ye0I8+84BAAAQTAjnALy+rSEvxVU9311Z77dhcKPyXNP+h+W6w3kJ4RwAAADBg3AOwGf7zgv9sO98jXsY3Kj8JH0/LMd1T+UcAAAAwYRwDsDrevtxKNxq9zC4Me7K+dCcBH2/q7JB70cHAAAAggHhHIDPhsLtrvRtOK+ss0nRgUZ9PSLPVTFPi7dKdqJrSvsmWtsBAAAQJAjnAIK2rd3T0t4vI04S2x3d59l3vpFwDgAAgCBBOAfgdb3T/NPWvqrw0JZ2j7aJ7YRzAAAABAnCOQCfVc4PNLRITVOLz55njXu/+Sh3S7tH28R2hsIBAAAgSBDOAXhdvNUiaXFR+nqPj/adO53Otrb20fkdV8437auVVrvDJ88PAAAAeBPhHIBPFKT5dt+5GgRXWd8slgiTDHWH8bbnTo2VuCiz2FodsrPC92etAwAAAD1FOAfg04ntvtp37qmaD8lJkOhI8yFfi2gX2Nl3DgAAgGBAOAfg2+PUfBbOXfvNRx82DM6DfecAAAAIJoRzAD4N575qa/dMaj9aOKdyDgAAgGBCOAcQdG3tdodT1u3teBjcEcepFdfo4XEAAABAICOcA/DpQLi9Bxq9PjF9e3md1DfbJTbKLAMy4zv8nsHZCRJhEj00rqzW5tXnBwAAALyNcA7AJ7ISoiXKEiGtDqeUVDd59bFXu1vaR+QmiVkl8A6oIXH9M1zBnX3nAAAACHSEcwA+oSam56fE+KS1/eD55knH/L62oXDsOwcAAECAI5wD8P3E9krvhvPV7knto44yDK6jfecAAABAICOcA/CZ3mlxXq+c21rtstFdCR9zlGFwh1fOPd8PAAAABCrCOQCfyffBcWobS2qlxe6UlNhIyXO3zR+N5zi1nZX1Um9r9doaAAAAgIAI57/73e+koeHIv2w3NjbqrwHAIW3t++u99phr2rW0m0wdD4PzSI+3SlaiVdRJapv21XptDQAAAEBAhPP77rtP6urqjvi8CuzqawCg9HYfp7bHi3vOVxce+3zzo+47p7UdAAAAoRbOnU5nhxWr1atXS2pqqjfWBSAE5Ke4wnlNU6tUN7R4dRjc6LxjT2o/YmI7Q+EAAAAQwCxd+eaUlBQdytVt0KBBhwR0u92uq+nXXXedL9YJIAjFRJklI8Eq5bU23do+KrZz1e6jqbO1yvbyuk5NavcYluMK8VTOAQAAEDLh/JFHHtFV8//7v//T7etJSQcrV1FRUdKnTx+ZOnWqL9YJIEj1To3V4VxNbO9soD6atUXVev94r+QYHfo7Y2hOgr7fVFIjrXaHWMzMwQQAAECQh/Mf//jH+r5v375y4oknisXSpR8HEKZD4ZbtPuCV49QOnm/euZZ2z3FusVFmaWi2y67KehmQ6QrrAAAAQCDpVgkpISFBNm7c2Pbx22+/Leeff778+te/lubmZm+uD0CIHKfmjaFwnkntnR0Gp5gjTDIk2xXI17PvHAAAAKEUzq+99lrZsmWLvt6xY4dcfPHFEhsbK6+99prcfvvt3l4jgFCY2O6Nyrl7UntXKueHDIVj3zkAAABCKZyrYD5mzBh9rQL5KaecIi+++KI8//zz8sYbb3h7jQBC4Kzznobzijqb7K1qFDWHcmSvLoZzz1A4KucAAAAItaPUHA6Hvv7kk0/kzDPP1Nf5+flSUVHh3RUCCIlwXlzVKM2trv9u9KSlvX9GvCRER3arcr6RyjkAAABCKZxPmDBB7r//fnnhhRdk0aJFctZZZ+nP79y5U7Kysry9RgBBTE1Vj46MEIfTFdC7a1U3W9qVwVkJEmFS1fdmKatt6vYaAAAAgIAK5+pItRUrVsiNN94ov/nNb2TAgAH686+//rqccMIJ4gt/+MMf9GOrve3JyT07jgmA/5hMJq+0tnsq52O6MAyu/Xnr/TLi9TWt7QAAAAhE3ToLbdSoUbJ27dojPv/ggw+K2WwWX1BT4OfMmaPPUf/nP//pk+cA4BsqnG8prZPd3QznaivN6kLPMWrde3NuWE6ibCur00Phpg3O7NZjAAAAAL7So4PKly9f3nak2rBhw2TcuHHiK/fdd5++V0PnAASXgtQ4fV/YzXBedKBRDjS0SKTZJENzundOudp3/s7qYirnAAAACJ1wXlZWpo9PU/vNPS3mVVVVMn36dHn55ZclIyNDAoHNZtM3j5oa/lIOGKEgNaZHZ52vdre0D81JFKvF3O3KucJxagAAAAiZPec33XST1NXVyfr162X//v36tm7dOh1+f/azn0mgmDt3riQlJbXd1DR5AP5X4D7rvLtt7Qdb2rs+DM5DBXtlZ0W9NDS3dvtxAAAAgIAJ5x9++KE8+eSTMnTo0LbPqbb2J554Qj744INOP84dd9yhh0Ud67Zp0ybprjvvvFOqq6vbboWFhd1+LADeaWtX+8e7anWRa1L76G7uN/dMjc9MsIp6+k37arv9OAAAAEDAtLWrM84jI488Z1h9znP+eWfcdtttcuWVVx7ze/r16yfdZbVa9Q2AsfJSXG3tdbZWvXc8NS6q0z9rdzhl3V53OO/GpPbDq+dlteV63/m4gpQePRYAAABgeDg/9dRT5eabb5aXXnpJcnNz9ef27t0rt956q8yYMaPTj6P2pgfK/nQAvhMdaZbsxGjZV9MkuyvruxTO1YT1hma7xEaZpb/7OLTuUkPhFm0pZ985AAAAQqOt/fHHH9f7y/v06SP9+/fXt759++rPPfbYY95fpRoktWePrFq1St/b7XZ9rW5q7zuA4Nl33tWzzj3D4Eb2ShJzhKlHa2gbCsfEdgAAAIRC5VwNVluxYoV88sknbXvC1f7zmTNniq/cfffd8u9//7vt47Fjx+r7zz77TKZNm+az5wXgvbPOl+7c3+Xj1DzD4Hra0u6pnCub9tXodvmehn0AAADAkMr5woUL9eA3VSFXw9pOO+00Pbld3SZOnCjDhw+XL7/8UnxBnW+uBkkdfiOYA8ETzpXdXTxObY17GFxPJrV79EmLk5hIszS1OPTUdgAAACAow/kjjzwi11xzjSQmuqpP7amjyq699lp56KGHvLk+ACGidzfa2pta7LrK3dNJ7R6qUj4kJ0Ffs+8cAAAAQRvOV69eLbNnzz7q108//XRZvny5N9YFIMTkuyvnXWlr31hSIy12px4g55n43lOefefqsQEAAICgDOelpaUdHqHmYbFYpLy83BvrAhCibe0lNU1ia7V3qaV9dF6S3krjDZ595wyFAwAAQNCG8169esm6deuO+vU1a9ZITk6ON9YFIMSkxUVJXJRZnE6RogONXRoGN8oLLe1HTGyncg4AAIBgDednnnmm3HXXXdLU1HTE1xobG+Wee+6Rs88+25vrAxAiVOXb09re2X3nnmPURuf3fBicx5DsRFFD2strbVJWe+R/ywAAAICAP0rtt7/9rbz55psyaNAgufHGG2Xw4MH68+o4tSeeeEKfP/6b3/zGV2sFEAKt7Zv21cqeTkxsr2lqkR3uiererJzHRJmlb3qcbC+vl40ltZKZEO21xwYAAAD8Es6zsrLkm2++keuvv17uvPNOfZSZpyI2a9YsHdDV9wBATye2ryuq1i3wvZJjJD3e6tV1DMtN0uFc7Ts/ZVCGVx8bAAAA8Hk4V3r37i3/+9//5MCBA7Jt2zYd0AcOHCgpKSndWgCA8BsK15lwvto9DG5Mvveq5h5DcxLk3dXsOwcAAEAQh3MPFcYnTpzo3dUACGlte8470dZ+cBic9/abHzEUrtj1BgAAAAAQVAPhAKAneqfFtVXOPdtijmaNexicN/ebH36cmtrT3tDc6vXHBwAAALqKcA7Ab9T+cXVceWOLXSrqmo/6fWqKenF1k/7ekT6onKshcGofu3p/YPO+Wq8/PgAAANBVhHMAfhNliZDcpBh9vWe/axJ7R9YUutrNB2TES7y127tvOlU9Z985AAAAAgHhHEDADYXzZUv7kfvOCecAAAAwHuEcgF+1hfPKxk5Mavd+S/vhlfONVM4BAAAQAAjnAPyq4DhnnatBcav9WDnftK9W7I5jD6cDAAAAfI1wDsCgtvaO95wX7m+UqoYWiTJHyJCcBJ+to296nERHRkhDs112Vx59/zsAAADgD4RzAAG153yVu2o+NCdBrBazz9ZhjjDJkGyGwgEAACAwEM4BGBLOS2ts0tRiP+Lrawp939J+xMR2hsIBAADAYIRzAH6VHBspCdGu49EKO6ier3EPgxud74dw7pnYTuUcAAAABiOcA/Ark8l01Nb2VrtD1u51h/M8301q96ByDgAAgEBBOAfgd0cL59vK66SxxS7xVov0y4j3+TqGZCeIySRSVmuT8lqbz58PAAAAOBrCOQDDjlPbXXloOF/t3m8+oleiHtjma7FRFumbFqevOe8cAAAARiKcAzCscn74nvPVnv3mfhgG5zHU09pOOAcAAICBCOcAAqatfY37GDV/DIM7Yigc+84BAABgIMI5AL/rnRrXFs4dDqe+VseqbSqp1dej/DAM7oihcFTOAQAAYCDCOQC/y0mO1nvKba0OKa+ztYXjVodT0uOjpFdyjN/WMtxdOd9RXtfhuesAAACAPxDOAfhdpDlCcpOjD2ltX+MeBjcqL1kft+YvGQlW/YaAKuBv3ueq3AMAAAD+RjgHYGhru2diu2cYnD9b2hX1RsBQz75zWtsBAABgEMI5AEPkHzYUbrUBw+CO2HfOUDgAAAAYhHAOwPDj1KobW2RHeb3fj1E7YmI7lXMAAAAYhHAOwBC901zhfHdlvazb62ppz0uJkdS4KL+vZbi7cr6xpKZtejwAAADgT4RzAAafdd5oaEu70jc9XqIjI6Sh2S67Dzt7HQAAAPAHwjkAQ/ecV9TZ5Nvtlfp6tJ+HwXmoY90GZyXoa/adAwAAwAiEcwCGSIqJlOTYSH39TVs4N6ZyfshQuBJXiz0AAADgT4RzAIa3ttsdTokwiYzoZUzl/JChcFTOAQAAYADCOQDDW9uVAZnxEme1BEDlnHAOAAAA/yOcAzBM73bh3MiWdmVwdqKYTCKlNTa9Dx4AAADwJ8I5AMPb2pVRBk1q94i3WqRPWlzbkWoAAACAPxHOAQREOB9jcOW8/b5zwjkAAAD8jXAOwDD9M+P1IDhVtR6c7TrKzEht+84ZCgcAAAA/M276EoCwl5UYLX//0QRJjImUKIvx7xW2TWyncg4AAAA/I5wDMNTMYVkSKDyV8+3l9dLUYpfoSLPRSwIAAECYML5UBQABIjPBKmlxUfrc9S2ltUYvBwAAAGGEcA4AbiaTiX3nAAAAMAThHADaYd85AAAAjEA4B4B2hnrCOZVzAAAA+BHhHADa8bS1q7POHQ6n0csBAABAmCCcA0A7/dLj9LFu9c122bO/wejlAAAAIEwQzgGgHYs5QoZkJ+hr9p0DAADAXwjnAHCUoXArdh8weikAAAAIE4RzADjMtMEZ+n7+qr3S3OowejkAAAAIA4RzADjMjKFZkplglYq6Zvl4wz6jlwMAAIAwQDgHgMNEmiPkkon5+nre4j1GLwcAAABhgHAOAB24eFKBRJhEvt1RKdvK6oxeDgAAAEIc4RwAOtArOUZOHZKpr19aSvUcAAAAvkU4B4CjuHxyb33/+vIiaWqxG70cAAAAhDDCOQAcxcmDMnQFvbqxRd5fU2L0cgAAABDCCOcAcBTmCJNcNrlAX89bstvo5QAAACCEEc4B4BjmTMgTS4RJVuypkg3FNUYvBwAAACGKcA4Ax5CZEC2zhmfr6xeXUj0HAACAbxDOAeA4Lne3tr+1Yq/U2VqNXg4AAABCEOEcAI5jav806ZceJ/XNdnlnVbHRywEAAEAIIpwDwHGYTIcOhnM6nUYvCQAAACGGcA4AnXDhuDyJskTI+uIaWV1UbfRyAAAAEGII5wDQCSlxUXL2yBx9PW8xg+EAAADgXYRzAOiky6e4WtvfXVMs1Q0tRi8HAAAAIYRwDgCdNK4gRYZkJ0hTi0PeXFlk9HIAAAAQQgjnANCFwXCeY9XmLdnDYDgAAAB4DeEcALrg/LG9JDbKLNvK6mTpzv1GLwcAAAAhgnAOAF2QEB0p543JbaueAwAAAN5AOAeALrpsUm99/8G6Eqmosxm9HAAAAIQAwjkAdNHIvCQZnZckLXanvL6cwXAAAADoOcI5AHTD5ZNd1fMXl+wRh4PBcAAAAOgZwjkAdMPZo3MkIdoie/Y3yFfbKoxeDgAAAIIc4RwAuiE2yiIXjsvT1/OW7DZ6OQAAAAhyQRHOd+3aJVdffbX07dtXYmJipH///nLPPfdIc3Oz0UsDEMYuc595/snGMtlX3WT0cgAAABDEgiKcb9q0SRwOhzzzzDOyfv16efjhh+Xpp5+WX//610YvDUAYG5SVIJP6pIrd4ZRXvis0ejkAAAAIYian0xmUk4wefPBBeeqpp2THjh2d/pmamhpJSkqS6upqSUxM9On6AISHt1ftlZtfXiU5SdHy5e3TxWIOivc8AQAA4CedzaFB+7dI9QdLTU01ehkAwtzsEdmSGhclJdVN8tnmcqOXAwAAgCAVlOF827Zt8thjj8m11157zO+z2Wz6XYr2NwDwJqvFLHPGMxgOAAAAQRzO77jjDjGZTMe8qf3m7e3du1dmz54tc+bMkWuuueaYjz937lzdPuC55efn+/hPBCAcXTrJNRhu0ZZyKdzfYPRyAAAAEIQM3XNeXl4ulZWVx/yefv36SVRUlL4uLi6WadOmyZQpU+T555+XiIiI41bO1c1DVc5VQGfPOQBv+9E/l8iXWyvkp9P6y+2zhxi9HAAAAATZnnOLGCgjI0PfOkNVzKdPny7jx4+Xf/3rX8cN5orVatU3APC1yycX6HD+6rJCuWXmIImyBOWuIQAAABgkKP72qIK5qpgXFBTIX/7yF11x37dvn74BQCCYMTRLMhOsUlHXLB9v4L9NAAAACMFwvmDBAj0E7tNPP5W8vDzJyclpuwFAIIg0R8glE11zLeYt3mP0cgAAABBkgiKcX3nllaK2xnd0A4BAcfGkAokwiXy7o1K2ldUZvRwAAAAEkaAI5wAQDHolx8ipQzL19UtLqZ4DAACg8wjnAOBFl0/ure9fX14kTS12o5cDAACAIEE4BwAvOnlQhq6gVze2yPtrSoxeDgAAAIIE4RwAvMgcYZLLJhfo63lLdhu9HAAAAAQJwjkAeNmcCXliiTDJij1VsqG4xujlAAAAIAgQzgHAyzITomXW8Gx9/eJSqucAAAA4PsI5APjA5e7W9rdW7JU6W6vRywEAAECAI5wDgA9M7Z8m/dLjpL7ZLu+sKjZ6OQAAAAhwhHMA8AGT6dDBcE6n0+glAQAAIIARzgHARy4clydRlghZX1wjb63ca/RyAAAAEMAI5wDgIylxUXLZJFf1/OevrpYnPttGBR0AAAAdIpwDgA/ddfYwufp7ffX1gx9tll+9sUZa7A6jlwUAAIAAQzgHAB8yR5h0QP/decMlwiTy6rIiufJfS6W6scXopQEAACCAEM4BwA+umNpHnv3xBImNMsvX2yrlB099I4X7G4xeFgAAAAIE4RwA/OTUIVny2nVTJSvRKlvL6uT7T34tqwqrjF4WAAAAAgDhHAD8aHhuksy/4UQZmpMoFXXNcsnfv5UP1+0zelkAAAAwGOEcAPwsJylGV9CnD86QphaHXD9vufzjix1McgcAAAhjhHMAMEC81SL/uGKC/GhKb1GZ/A//2yi/nb9OWpnkDgAAEJYI5wBgEIs5Qk9x/+1ZQ8VkEpm3ZI/8v/8skzpbq9FLAwAAgJ8RzgHAQCaTSf7fSf3k6R+Ol+jICPl8c7me5F5S3Wj00gAAAOBHhHMACACzhmfLKz+ZKunxVtm0r1bOf+JrWbe32uhlAQAAwE8I5wAQIEbnJ8v8G06QQVnxUlpjk4ue+VY+3Vhq9LIAAADgB4RzAAggeSmx8vr1J8hJA9Olodku1/xnmfz7m11GLwsAAAA+RjgHgACTGB0pz105US6ZmC8Op8g976yX+95dL3b1AQAAAEIS4RwAAlCkOULmXjBSfjV7iP74X1/vkmtfWC4NzUxyBwAACEWEcwAI4Enu10/rL09cNk6iLBHyycZSufTvi6WpxW700tBN32yrkML9DUYvAwAABCDCOQAEuLNG5chL10yRlNhIWV1ULf/8aqfRS0I3fLu9Ui57dolc8dxScbBFAQAAHIZwDgBBYHzvFLnnnOH6+onPtsm+6iajl4Qumrdkt77fWVEvS3buN3o5AAAgwBDOASBInDcmV4d0NcX9zx9uMno56IL99c3y8fqDx+K9trzQ0PUAAIDAQzgHgCDag37vOcPFZBJ5a+VeWb77gNFLQie9uaJImu0OSYuL0h9/sHaf1NkY7gcAAA4inANAEBmZlyQXjc/X1+p4NfYuBz6n0ykvLd2jr39++iDplxEnjS12+d+aEqOXBgAAAgjhHACCzC9mDZYEq0XWFFXL68uLjF4OjkN1OGwvr5eYSLOcOzpX5rjfXKG1HQAAtEc4B4Agk5FglZ/NGKivH/hok9Q2tRi2FlW5/2xTmVQ1NBu2hkD30lJXCD97VI4kREfKBeN6SYRJ5LtdB2RXRb3RywMAAAGCcA4AQejHJ/TR7dEVdc3y2MJthq3jgY82y1XPfyc/fm6ptNodhq0jUFU3tsj7a4v19SWTCvR9VmK0nDwoQ1/T+QAAADwI5wAQhKIsEXLX2cP09b++3ik7yuv8voZPN5bK04u262t1/vozX+zw+xoC3Turi6WpxSGDsuJlXEFy2+d/MD5P37+xokjszA0AAACEcwAIXtMHZ8qpQzKlxe6U37+3wa/PXXSgQX7+6mp9PTovSd8/8skW2byv1q/rCHQvuwfBXTyxQE/b95g5NEuSYiKlpLpJvtleYeAKAQBAoCCcA0AQU9XzSLNJPttcrvd++0Nzq0NueHGlbtlWwfzV66bKDPebBL94bbW00N6urS2qlvXFNRJljpALxvY65GvRkWZ9br3y2jJa2wEAAOEcAIJa3/Q4+b8T++prVT1XwdnX/vTBJlldWCWJ0RZ5/LJxYrWY5Y8XjNSV4LV7q+Xpz12t7uHu5e9cVfPZI7IlxX2+eXue1vaP1u/Tb3QAAIDwRjgHgCB346kDJD3eKjsq6uX5b3b69Lk+XFciz33teo6/XjRG8lNj24ac3Xuuaw/8owu3ysaSGglnDc2t8vYqzyA419FphxvZK0kGZyWIrdUh761xfS8AAAhfhHMACHLqeK7bZw/W149+uk3Kapt88jy7K+vll6+t0dc/ObmfnDYs65Cvnz+ml/4c7e0i760pkTpbq/ROi5UpfdM6/B61B33OBFf1nNZ2AABAOAeAEPCDcXl6/7cKhA9+uNnrj9/UYpcbXlwhtbZWGd87RX45y/VmwOFh8w/fHyHJsZF6r/WTn4Vve/sr37nONr94Yr5EqEPNj+K8Mb3EHGGSVYVVsq2MYXoAAIQzwjkAhAAVAO85d7i+fm15kd4T7k33v79B1u2tkZTYSHn8srESae74fx+ZCdFyn3sdjy3cKuuLqyXcbCmtleW7D+jQ7dlXfjQZCVY9dd/zzw0AAIQvwjkAhIhxBSltU8Hve3e9OJ3eOT/77VV75b+LXcPNHr54jOQkxRzz+88dnSuzh2dLq8Mpt7262i9D6gLJy0tdVXM1wV69WXE8ntb2N1fsldYw3goAAEC4I5wDQAj51RlDJDbKLCv2VMn8VXt7/Hjby+vk12+u1dc3Th8g09xV3mNR7e2/P3+ErrJv2lcrj3+2TcKFav9/c6WrAn7ppIJO/YyqnKfGRUl5rU2+2Fru4xUCAIBARTgHgBCipqar6e2eI8/qba3dfqzGZrvcMG+F1DfbZUq/VLll5sBO/6xq11YBXXnis22ybm94tLd/vKFUqhpaJCcpWk4elNGpn4myROhhesrrtLYDABC2COcAEGLUuecFqbFSWmPTwbi77nlnna58q2PaHr1krFiOss/8aM4elStnjswWu8M1vd3WapdQ9/JSV/v/nAn5es95Z3n2pn+yoUwO1Df7bH0AACBwEc4BIMRER5rlt2cN1dfPfrlTH4HWVaqC++qyIjGZRB69ZIxkJh5/73RHfn/eCEmLi9Ih/7FPQ7u9Xf2ev9leqX9nF7n3kXfWsNxEGZ6bKM12h7yzmjPPAQAIR4RzAAhB6rzxkwam67B3//sbu/Szm/fVym/nu/aZ3zpzkJwwIL3b60iLt8r97vb2pxZtlzVF3p0iH4jHp508MEPyUmK7/PNz3NXz15a7HgcAAIQXwjkAhCA1lO3us4fp1uoFG0rly04OGlN71H86b7k0tTh0uFdD4HrqjJE5cvaoHN3erqa3h2J7e4vd0XYU2qWT8rv1GOeO6SWRZpM+sm5jSY2XVwgAAAId4RwAQtTArAS5Ympvff27dzfoAHks6ui137y1VraX10t2YrQ8cvEYfX66N/zuvBGSHh8lW8vq5JFPtkqoWbipTE9bV3/GU4dkdesx1MT2mUNdP8tgOAAAwg/hHABC2C0zB+nQp0LxfxfvPub3vvxdocxfVayr7Y9dNla3pHuLWsP954/U188s2i6rCqtCsqX9wvF5evp6d3nOPJ+/cu9x30wBAAChhXAOACEsKSZSfnH6YH398IItUlln6/D71hdXyz3vrNfXv5w1WCb2SfX6WmaPyJbzxuSKwyly26ur9JngoaCkulE+31ymry+Z2LmzzY9G7VdXx9BV1jfrajwAAAgfhHMACHEXT8yXYTmJUtPUKn9dsOWIr9c2tejzzJtbHTJjSKb85KR+PlvLvecM10ezqdb5hz85ci3B6NXvivQbDpP7pkrf9LgePZY6ru6CsZx5DgBAOCKcA0CIU23q9547XF+/tHSPrpK332d+xxtrZVdlg/RKjpG/XjTaa/vMO5ISFyV//L5revs/vtghy3cfkGCmhty9uszV0n7ppJ5VzQ8/8/yzTWVScZROBwAAEHoI5wAQBib1TdUT051Okfve2aBDufKfb3fL+2tL9JTwxy8bK8mxUT5fy+nDs3V1WFWbf/na6qBub/9qW4XsrWrU2wdU2763BvmNzk+WVodT7z0HAADhgXAOAGHi12cOlejICFm6a7+8t6ZEVhdWyf3vb9Bfu/OMoTK2IMVva7nnnOGSmWCVHRX18tePN0uwennpHn3//bG9JDrS7LXHbTvzfFlR2xspAAAgtBHOASBM5CbHyPWnuM4tn/u/jXLDiyukxe6U2cOz5aoT+/h1LUmxkTL3Atf09me/2inLdu2XYKOOTlNnyCuXdPNs86M5Z3Sunvq+ubRWn3sOAABCH+EcAMLItaf003vLi6ubpOhAoxSkxsoDc0aJyeS7feZHM2Nollw4Lk+32v/y9TXS2Bxc7e1vrijSredj8pNlSHaiVx9btcnPGu5qk39tuWtPOwAACG2EcwAII6r1WrW3K6oy++Tl4yQxOtKw9dx9zjDJSrTKzop6efCj4GlvV63mnrPNL/Vy1fzw1va3VxWLrTW43rgAAABdRzgHgDBz5shsefji0fLC/02SEb2SDF2LqhD/6cJR+vpf3+yUpTuDo719yc79er98XJRZzh6V65PnOHFAuuQkRUt1Y4t8soEzzwEACHWEcwAIM6qF/ftj82RyvzQJBNMHZ8pFEzzt7aul3tYqgc5TNT93TK7EWS0+OwLvgnGeM89pbQcAINQRzgEAhvvt2cN0lXh3ZYOc89hX8u32SglU1Q0t8r+1Jfr6koneOdv8aH4w3tUyv2hLuZTWNPn0uQAAgLEI5wAAw6l97+qcdc/xapf+Y7E+A/1AfbMEmrdWFomt1SFDcxJlVJ5vtwX0TY+TCb1T9Jnwb67gzHMAAEIZ4RwAEBDG906VT247RX44xVWNfm15kcx8aJEOw4Fy1rdax8vulvZLJub7Zcr9nAl5ba3tgfJ7AAAA3kc4BwAEVAX9/vNHyhvXT5VBWfFSWd8st76yWq54bqnsrqw3enmyuqhaNu2rFaslQs4f49oP7mtnjcqVmEizbC+vl5WFVX55TgAA4H+EcwBAQFbR37vpJPnlrMH6yLcvt1bI6Q9/IU9+vk1a7A7D1vXy0j36/qyROZIU658j6OKtFjljhPvM82VFfnlOAADgf4RzAEBAUqH8hukD5ONbTpYTB6Tpfd4PfLhZD4xbseeA39dTZ2uVd1YX6+uLJ/rmbPOj+YG7tf291cXS1MKZ5wAAhCLCOQAgoPVJj5P/Xj1Z/jpntKTERuq28guf+kbumr9Oappa/LYOFYwbmu3SLyNOJvVNFX+a0jdN8lJipNbWKh+t3+fX5wYAAP5BOAcABDw1eO3C8Xny6W3T5MJxrjPRX1i8W057aJF8uK7EL4PSXvLzILj2IiJM+s+t0NoOAEBoIpwDAIJGalyU/PWi0fLi/5usjxkrrbHJdf9dIdf8Z7kUVzX67Hk3ltTI6sIqiTSb5AJ3SPa3H4x3Pe/X2ytkrw//rAAAwBiEcwBA0DlhQLp8cPNJctOpA3Rg/mRjqa6iP/fVTrGrQ8G97BV31fy0YVmSHm8VI+SnxsqUfqm6a+DN5VTPAQAINYRzAEBQio40y22nD5b3f3aSTOidIvXNdvndexvk+09+Lev2VnvtedQAtjdXuMLwJRNdZ7AbZc541yC611cEztnvAADAOyxeehwAAAwxKCtBXr12qrz03R750webZE1RtZz3xNdy0YQ8KUiNkzirWZ8THme1SGxUu/soi8RaXffq62pfd0c+WFciNU2t0is5Rr43IF2MdMbIbLn77XWyu7JBvtt1wO+D6QAAgO8QzgEAQU8F68sn95bThmbJfe9tkPfXlMhLS12t6J3lCvBmiY06NMRvL6trOz7taAHeX9TazhqVI68uK5LXlhUSzv2stKZJb5344ZTeepsBAADeZHKGUV9cTU2NJCUlSXV1tSQmJhq9HACAj3yxpVwWbiqTelurPv6svrlVGmzu+2a7NLT7uDNb1NW+9i9uny45STFitO927Zc5T3+r3zj47jcz9ZsI8D3116XL/rFEvt1RKWPyk+XN608w/M0aAEBo5VD+jw4ACDknD8rQt84ELlur49AQr8J7W5BvlTqbXYZmJwREMFfU/vo+abGyq7JB/re2ROZMcO1Dh2+9uWKvDubKqsIqeXPl3rYJ+gAAeEPQhPNzzz1XVq1aJWVlZZKSkiIzZ86UP//5z5Kbm2v00gAAQUqdV64Gy6lbmgTPmlUgf/CjzTL3g00ypV8aLdY+tr++We5/f4O+HpqTqI/W+/OHm2TW8CxJiI40enkAgBARNNPap0+fLq+++qps3rxZ3njjDdm+fbv84Ac/MHpZAAD43f+d2FdG9ErUofGa/yyTOlurhBrVtaAm5QeCuf/bKAcaWmRwVoK8cf1U6ZceJ+W1Nnl84TajlwYACCFBE85vvfVWmTJlivTu3VtOOOEEueOOO2Tx4sXS0tJi9NIAAPCrmCiz/OOKCZKRYJVN+2rllpdXicMH57sbZVtZnZz0589k5kOLdAg20rfbK+U197nyf7xghB7Kd9fZw/THz329U7aXuwYGAgAQNuG8vf3798u8efN0SI+MPHo7mc1m05vv298AAAgFag/83380XqIsEfLJxlL5y8ebJRTUNLXIT15YJpX1zVJ0oFFue221YW882Frt8pv5a/X1ZZMLZHxv13T86UMy5dQhmdJid8rv3t3AmfMAgPAL57/61a8kLi5O0tLSZM+ePfL2228f8/vnzp2rp+J5bvn5DM0BAISOsQUp8sCFo/T1k59vl7dWuiq8wcrucOougB3l9ZKVaBWrJUJP3n/2qx2GrOfpz3fotaTHW+VXs4Yc8jVVPVdT/Be5TwYAACCow7lqTVeDbY5127RpU9v3//KXv5SVK1fKxx9/LGazWa644opjvlt955136nH1nlthYdfOvAUAINCdP7aX/HRaf339qzfWyoo9ByRYPbxgiw66KpQ/e8VEufscV/v4Ax9u1hPS/WlHeZ088blrT7laR1LsoZ16fdPj5Orv9dPXv39vg66yAwAQtOecl5eXS2Wl61iSo+nXr59ERUUd8fmioiJdCf/mm29k6tSpnXo+zjkHAIQi1fZ97X+Xy4INpbrK+86NJ0pucmAc/dZZ6li4n85boa8fuXiMftNB/RXlhhdXyP/W7pOC1Fh572ffk0Q/TEdXz3v5s0vkm+2V+ki+f181URcMDqcG8Z36l8+lrNYmv5o9RK53v0kCAEB3cqihlfOMjAwZMmTIMW8dBXPF4XC07SsHACCcRUSY5OGLx8iQ7ASpqLPpCe5q2nmwUEeT3fbqan19zUl9dTBXVCCee8Eo6ZUcI3v2N8hv3lrnl/3db63cq4O5quDff96IDoO5Em+1yB1nuNrdH1u4VUprmny+NgBA6AqKPedLliyRxx9/XJ9zvnv3blm4cKFceuml0r9//05XzQEACGUqKD774wmSFhcl64tr5BcGDlLrigP1zXoAXGOLXU4amK4r0O0lxUTKo5eOFXOESd5dXSyvLSvy+Xruf3+jvr555kApSDv2GfLnj+kl4wqSpaHZLn/64OBWPAAAQjKcx8bGyptvvikzZsyQwYMHy9VXXy2jRo2SRYsWidVqNXp5AAAEhLyUWHn6R+P1oDLVCv63T7dKIGu1O+TGl1ZI4f5G3bb+2KVjxWI+8q8m43unyG2nD9LXd7+zTraV1fpsTXM/2KjPj1dnml9zkmtP+fG6Fu49d7io4rqquC/btd9nawMAhLagCOcjR47U1XK1P72pqUl27twpTz31lPTq5Wp7AwAALhP7pMofvj9SX6tw/t6aYglUqtL89bZKiY0yy9+vGC/JsR1vZVOuO7m/fG9AujS1OOTGF1dKU4v3B7At3lEpry47eKZ5ZAdvFHRkVF6yXDzBdSLMve+u11Png5Eaanf/exvk3nfWy9fbKqTF7tpCCADwj6AI5wAAoPMumpCv924rqr19bVG1BJo3VxTJs1/t1Nd/nTNahmQnHrdC/dDFoyU9Pko27auVP7hbz716pvlbR55p3lm/mDVYEqItsm5vjby2LPhOh1FB/KYXV+p/Js9/s0sPxBv/+wVyy8sr9bA+NfwOAOBbhHMAAELQHWcMlWmDM3Sl+f/957uAGla2pqhK7njTFYRvOnWAnDEyp1M/l5kQLX+9aIy+fmHxbvlwXYnX1vTMoh2y/ShnmneG+rlbZ7pa7x/4aLNUN7ZIsFCVfvUmzscbSiXKEiHnjcmV1LgoqWlqlfmrivUU/XG/XyBX/WupvLR0j5TVBs5rCQBCiaFHqfkbR6kBAMJJTVOLXPDkN7KtrE5G5yXJK9dOlehIs6FrKq+1ybmPfyUl1U0yc2im/P1HE3RVvCvm/m+jPPPFDkmMtsj/bj5J77Xv6Znms//2pTS3OuRvl4yR88b06nb1+cy/fSlby+rkqhP7yD3nDJdAp/4a+Ou31spLSwvFEmGSZ340XmYMzdKBfcWeA/Lx+n06tO+ubGj7GbW/fmx+spw2LFtOH54l/TPiDf0zAECo5FDCOQAAIWx3Zb2c98TXUtXQoiui6gzxox0N5msq/F7+7GL5btcB6Z8RJ/NvOFESunFuuXqcOc98K6sLq2RC7xR5+SdTOhwk19UzzdW0+P/836Qe/X6+3FouP/rnUj1d/oObT5JBWQkSqNSfXU2m/+dXO0W9P/K3S8bKOaNzO/w+9YbDgg2lOqyvPmybhPpn6QnqY/KSu/xmCwCEuhrC+ZEI5wCAcPTN9gq54p9LpdXhlF/OGiw3TB9gyDrUnu55S/ZIgtUi8288sUcV1z2VDXLWo19Kra1Vt8bfdvrgbj3OWyuL5NZXVuszzT++9WTpnRYnPXXtC8vko/WlcuKANPnv1ZMNezPkeB5asEUedU/0f+AHo/Ssgs7YV90kCza6groaotdiP/hXyYwEq8wcmiWnD8uSqf3TDO/UAIBAQDjvAOEcABCu5i3ZLb95a52+fvqH42X2iGy/Pv+LS/bo9mmVU5/78USZPiSzx4+pzj2/6aWV+jHnXT1ZThiQ3uUzzWc8tEgfnebNNy0K9zfox1UVfiN+153x9KLtbeey33vOMLnyRNcAwe5snfh8c7muqn++qUy/WeIRF2WWK0/sIzfPGKT3sgNAuKrpZA7lv5QAAISByyf3lh9P7a2vf/7qKtlQXOO351Znf9/zjuuNgV+cPtgrwVxRLdjqCDNVZrjllVVSWWfr0s+rcKqC+aCs+E6dad5Z+amxct3Jrse7//0NPjn2rSde+HZXWzC/ffbgbgdzJTE6Us4dnavPqF9+12l6W8APpxRIVqJV6pvt8sRn2+WCp77Wcw8AAMdGOAcAIEzcdfYwfVZ4Q7NdrvnPMqnoYpjtjpLqRrnuvyt06/NZI3Pkp9P6e/Xx7zl3mAzIjJeyWpvc9tpqcXTyjPElOyrlFfeRZ3/8/kivV3avm9ZfcpKipehAo/z9ix0SKF5fXiR3vb1eX98wvb/8dJr3tjio3+HJgzLk/vNHyrd3zJAnLx8nybGR+ni5sx/7Ur8pEEYNmwDQZYRzAADChBqa9sRl46RvepzsrWqU615Yrs/39hVVMVbPod4EGJKdIA/OGeX1/dexURZ5/LKxOhiq9urnvnadnX4s6s+sWuyVSycVyIQ+XTvTvLPr+vWZQ/X1k59v079vo6nzym9/fbW+vvKEPrqLwVfUULgzR+bIR7ecrAftqSP91JsCVz3/HUexAcBREM4BAAgjSbGR8uyPJ0hCtEWW7T6g96H7opqpHlM9tprsraqn/7higg6svjAkO1F3BSh//nCTPkf9WP7edqZ5lNwxu+tnmnfW2aNyZFLfVB1M//i/jWKkzzaVyc0vrxTVWHDRhDy5++xhfhlUl5UYLf++apLe1+55A2X2I1/qPeoAgEMRzgEACDNqSrqqoKsTr1Sb87NfHr/a3FX/+nqXvLGiSB8ppp5L7cP2pR9OLpDZw7N1+7waElfb1NLh9+2sqJfHPtumr1WgV29W+IoKv/eeM1z/nt9fU6Inmxs1rf+6/y7Xvxv1hsHcC0b59bgz9VxqX/t7N31PhuYk6n3+alvFnW+ulYbmgwPkACDcEc4BAAhDam+wp9r8xw82yqyHv5AbXlwhj3yyRQfJLaW1etp4d3yzrUL+4K4Uq9buE7s4Rb27QfjPF46SXskxsruyQX47/8iOAPXxb+ev1X8u1WqtBpn52rDcRD2MT7n3nfXSau/e77S7Vuw5IP/v38vE1uqQmUMz5eGLx+g3TIygznyff8MJcu3J/fSE/ZeW7pGzHv1KVhUeu9MBAMIFR6kBABCm1F8BfvfeBl3l7ogKcX3SYmVgZoIMzIrXg9fUdb+MuKOeX62OETv38a/kQEOLXDguT/7ig33mx5sMf/HfF4vd4ZQHfzBK5rQ7u9sXZ5p39si26X/9XKoaWuT35w2XH03t45fnXV9cLZf+fbHUNLXqM9f/+eOJAXPuuKrm3/bqaimpbtKvs5tnDNTDAtVcBAAINZxz3gHCOQAAR1LDylSlfFtpnWwtq5WtZXX6uv2Z1e2pwmtBaqwMcIf2ge7QnpMcLT98dols2lcro/OS5JVrpxoSBh9fuFX+8vEWiYk0y3s/+55u4/fVmeadpSaVq4FoSTGR8vkvpklKXJRPn29bWa1c/Mxiqaxvlgm9U+Q/V0/y2Z7/7qpuaJHfvr1On1evjCtI1pV9f71pAgD+QjjvAOEcAIDOUX89KK2xucK6Du11OvBtKa2T6saO93N7pMdb5d2bTpScpBgxgqqa/+ifS+Sb7ZV6j/NbPz1B7nl7vT46TZ1p/t5NJ3n96LTjUe3sZz/2lX7jQp0Dro4b85U9lQ0y55lv9D+/Eb0S5cVrpujzyAP1dfb2qmK5a/46/WZQXJRZ7jl3uMwZn+fXjgsA8CXCeQcI5wAA9Iz6a0NFXbMO7dvK6tzB3XWtPq9axuf9v8k+OZ6sK0prmuSMv32pK+Vqf/mXWyv051+/bqpha1MD4S75+2LdeaDeIFD70X1xrvxFz3wrhfsbdUeD6l5I9XGV3huKDjTIz19dLUt37tcfnzEiW58/7+sOAwDwB8J5BwjnAAD4jmodV3+pCJQwqI4PU+dqe1w6KV9PKjfSjS+ukPfWlOgj1l75yRSvVofVefIqmO8or5feabHy2rVTJTMxWoKF6nh45ovt8tDHW6TV4ZTMBKv8Zc5oPbwQAMIhhzJ1AwAAeIWqcgZKMFemD8mUa07qq6/Vmea/8uGZ5p2lptdHR0boCrEK6d7cv/2jfy7VwTw3KVp3LwRTMFfUYLifThsg8284UfpnxElZrU2ueG6p3PfuemlqsRu9PADwOSrnAAAgZLXYHTJv8W7dyj6iV5IEgkc/3SoPLdgi2YnRev+52v9utZjd9xH6PsocIdZIs/ve9bEK9VFmc9vHnvumVocexKeOJFP7/V+9dor0y4iXYNbYbJe5H2yU/3y7W3+sWvQvmpAvYwqSZURuksREBcbUeQDoDNraO0A4BwAARlNV4JkPLZKiA41eeTzVGa/+NpccGykv/2SKDMkOnb/jqK0Jv3x9jW7Zb19hH5KdIKPzk2VMfrKMzU/WE/kjDDq/HQCOh3DeAcI5AAAIBBuKa+TVZYU6qDe3OsTWdjv4seveLs12h9haHG336nOOw/72lhYXJc9dOVEH1lBTWWeTV5cVyco9B3R3gGp3P1yC1SKj8pN0WB+Tn6LvMxKshqwXAA5HOO8A4RwAAIQCdTRb+9Cuzk834kx5f1N/bS2pbtIh3XNbW1QtjR3sSe+VHOMO68m0wwMwFOG8A4RzAACA0HujYktpnTusu6rrW8vqdKt/e552+FF5yfq8+0FZCXovu6qwc6Y6AF8inHeAcA4AABD6aptaZO3ealdg31N11HZ4RXUdqJA+MCteBmQm6OA+MDNBshIJ7QC8g3DeAcI5AABA+GnfDr++uFq2ltbp6vruyvoj9u+338c+QFXYMxPcwd1Vbc9Jiia0A+gSwnkHCOcAAADwUAP5dlbUy5bSWtlWVucO7bWyq7JB7EdJ7XFRZhngbonPS4mR2CizxEZZDrtvd211X0eavTpR3uFwuuYOtDr0kYFqgKC6tTocEhNl0R0Baq2B+EaCWnurwykOp+vebneKXV879O/dc9Pf475v/zmRzsaX4//Z1XGEnmMMDx5TaNYfWyJMAfn781C/m8r6ZimrbdKdIWU1TVJWY9PXpeq61qaPJXS9Bl2vQ/WaiHHfu16fh33OevA1HNf2Gvb+6zfc1BDOj0Q4BwAAwPGoifi7Khp0UFf72beV1ergroK8Kxx2jzqrvn2Abx+SXM/rCtg6bLsDd4vd2TbBvy2E210h9nhUlkqMiZTE6EhJjLG47qMjdXBv+/jw63Zfj4k062F7dU2tUmdrlXqbXd+7rg+9P/Tarq/VrbapVeqbW3VI1AHb6TxiHkCgUrlch3aL+WCAt6gwb2537fq6CvbRFrP+Z6yGM6p79ftT1yrsu64936P+2bt+znVtlmiL5+fMbacUtA/ZKnSXqhBeY5Py2iYprbHpIwZ78nrsqoRoi6THWyU9PkrS4qySnhClP06Lt0pG/MFr9fV4qyWg39jwN8J5BwjnAAAA6C4VjFUrvGqJV9V2T2WyoblVGvS9K5SqQKs/trVKQ4vdL2HUUwFWg+/UelSoD0aRZpNEmEy6aq0qtereHKH+XCKWiAiJiFBvOhw/9HXmd+4Up7Tana5jDNWxhnbXmyFGU3+8zr5m1PeqoJyZYNVzEjIToiVT3SdG68/FRVncr0fXmyue16rnDZP2n/N8j/p+/Tp2f1938r9648IT5F2h3XXvuVavU/Vmjfp92x2u37tdf+x640m96aD+2ahuCk/nhOdrnp9xfd0ppw7JlPPH9pJQyKEWv64KAAAACFIq/A5ULe1ZCXLmyJxO/YyqgzW1OA4J8B1dq7gZ6Q7Y+nbYtedrKvQc/n0q0LavUqrnVIGzprFFappapLqxte3add/+49a2z1e3+1r7iqx66Pgoi8RHWyROtUFbLRJvNevqqOv64P2R167vUxVhtW4VytrfXOHbJGaTK4wbrW27QIvqVrC7gru+2ds6GJo7+JwK902tDr1VQoVb9fPq2vNxU7uP9XWrXYdf/bH7MT1UMFe/ChVkVdDO8gTudveeIK7Cr0W9c+EjnteSCutVjS1SUasq9s26aq+q++Xtrj2fV69n9TN7qxr1zdeyEq0BH847i3AOAAAA+IgKzaptWd3S/PicnhZpVUHtTiDzVP91+31kYO5d9wX1BkF0hKe9PNJvz6sqwirsq+CurlPjXNVlo7V/LamW9f4Z8cf9GfWGU2Vds5SrwF5r0/viXaHeJhX1zTrIqzcgLGb15oxrb3/btdn1Zk2k6pYwq3tX54R6A0q/mWN2fb/+Hv25CBnZK0lCBeEcAAAAwCGBzLU3nqjgLypsun7nEvT0nyPVIvmpsUYvJej4rgcCAAAAAAB0CuEcAAAAAACDEc4BAAAAADAY4RwAAAAAAIMRzgEAAAAAMBjhHAAAAAAAgxHOAQAAAAAwGOEcAAAAAACDEc4BAAAAADAY4RwAAAAAAIMRzgEAAAAAMBjhHAAAAAAAgxHOAQAAAAAwGOEcAAAAAACDEc4BAAAAADAY4RwAAAAAAIMRzgEAAAAAMBjhHAAAAAAAg1kkjDidTn1fU1Nj9FIAAAAAAGGgxp0/PXn0aMIqnNfW1ur7/Px8o5cCAAAAAAizPJqUlHTUr5ucx4vvIcThcEhxcbEkJCSIyWSSQH5nRb2BUFhYKImJiUYvB/ApXu8IJ7zeEU54vSOc8HrHsajIrYJ5bm6uREQcfWd5WFXO1S8iLy9PgoX6F5t/uREueL0jnPB6Rzjh9Y5wwusdR3OsirkHA+EAAAAAADAY4RwAAAAAAIMRzgOQ1WqVe+65R98DoY7XO8IJr3eEE17vCCe83uENYTUQDgAAAACAQETlHAAAAAAAgxHOAQAAAAAwGOEcAAAAAACDEc4BAAAAADAY4TwAPfHEE9KnTx+Jjo6WyZMny9KlS41eEtBjX3zxhZxzzjmSm5srJpNJ5s+ff8jX1WzKu+++W3JyciQmJkZmzpwpW7duNWy9QHfNnTtXJk6cKAkJCZKZmSnnn3++bN68+ZDvaWpqkhtuuEHS0tIkPj5eLrzwQiktLTVszUB3PfXUUzJq1ChJTEzUt6lTp8oHH3zQ9nVe6whlf/rTn/TfaW655Za2z/GaR08QzgPMK6+8Ij//+c/1UQwrVqyQ0aNHy6xZs6SsrMzopQE9Ul9fr1/P6s2njjzwwAPy6KOPytNPPy1LliyRuLg4/dpX/5MDgsmiRYv0X8wWL14sCxYskJaWFjn99NP1vwMet956q7z77rvy2muv6e8vLi6WCy64wNB1A92Rl5enA8ry5ctl2bJlcuqpp8p5550n69ev11/ntY5Q9d1338kzzzyj35xqj9c8ekQdpYbAMWnSJOcNN9zQ9rHdbnfm5uY6586da+i6AG9S/+l566232j52OBzO7Oxs54MPPtj2uaqqKqfVanW+9NJLBq0S8I6ysjL9ml+0aFHbazsyMtL52muvtX3Pxo0b9fd8++23Bq4U8I6UlBTns88+y2sdIau2ttY5cOBA54IFC5ynnHKK8+abb9af5zWPnqJyHkCam5v1O8+qndcjIiJCf/ztt98aujbAl3bu3Cn79u075LWflJSkt3Xw2kewq66u1vepqan6Xv13XlXT27/ehwwZIgUFBbzeEdTsdru8/PLLuktEtbfzWkeoUt1RZ5111iGvbYXXPHrK0uNHgNdUVFTo/7FlZWUd8nn18aZNmwxbF+BrKpgrHb32PV8DgpHD4dB7EU888UQZMWKE/px6TUdFRUlycvIh38vrHcFq7dq1OoyrbUhqj+1bb70lw4YNk1WrVvFaR8hRb0Cpraeqrf1w/PcdPUU4BwDAh9WVdevWyVdffWX0UgCfGTx4sA7iqkvk9ddflx//+Md6ry0QagoLC+Xmm2/W80TU4GbA22hrDyDp6eliNpuPmOioPs7OzjZsXYCveV7fvPYRSm688UZ577335LPPPtNDszzUa1ptY6qqqjrk+3m9I1ipSuGAAQNk/Pjx+rQCNfzzb3/7G691hBzVtq6GNI8bN04sFou+qTei1EBbda0q5Lzm0ROE8wD7n5v6H9unn356SEuk+li1iwGhqm/fvvp/Wu1f+zU1NXpqO699BBs181AFc9Xau3DhQv36bk/9dz4yMvKQ17s6am3Pnj283hES1N9dbDYbr3WEnBkzZuhtHKpTxHObMGGCXH755W3XvObRE7S1Bxh1jJpqB1P/ck+aNEkeeeQRPVjlqquuMnppQI/U1dXJtm3bDhkCp/5HpoZkqUEpal/u/fffLwMHDtRh5q677tJnoqszooFga2V/8cUX5e2339ZnnXv2GaohhzExMfr+6quv1v+9V69/dTb0TTfdpP/iNmXKFKOXD3TJnXfeKWeccYb+73htba1+7X/++efy0Ucf8VpHyFH/TffMD/FQR7+qM809n+c1j54gnAeYiy++WMrLy+Xuu+/Wf6EbM2aMfPjhh0cMygKCjTr/dvr06W0fq/9xKerNqOeff15uv/12/UbUT37yE90O9r3vfU+/9tnThWDz1FNP6ftp06Yd8vl//etfcuWVV+rrhx9+WJ/GceGFF+oK46xZs+TJJ580ZL1AT6gW3yuuuEJKSkp0GFdnPqtgftppp+mv81pHuOE1j54wqfPUevQIAAAAAACgR9hzDgAAAACAwQjnAAAAAAAYjHAOAAAAAIDBCOcAAAAAABiMcA4AAAAAgMEI5wAAAAAAGIxwDgAAAACAwQjnAADAa/r06SOPPPKI0csAACDoEM4BAAhSV155pZx//vn6etq0aXLLLbf47bmff/55SU5OPuLz3333nfzkJz/x2zoAAAgVFqMXAAAAAkdzc7NERUV1++czMjK8uh4AAMIFlXMAAEKggr5o0SL529/+JiaTSd927dqlv7Zu3To544wzJD4+XrKysuRHP/qRVFRUtP2sqrjfeOONuuqenp4us2bN0p9/6KGHZOTIkRIXFyf5+fny05/+VOrq6vTXPv/8c7nqqqukurq67fnuvffeDtva9+zZI+edd55+/sTERLnooouktLS07evq58aMGSMvvPCC/tmkpCS55JJLpLa21m+/PwAAAgHhHACAIKdC+dSpU+Waa66RkpISfVOBuqqqSk499VQZO3asLFu2TD788EMdjFVAbu/f//63rpZ//fXX8vTTT+vPRUREyKOPPirr16/XX1+4cKHcfvvt+msnnHCCDuAqbHue7xe/+MUR63I4HDqY79+/X795sGDBAtmxY4dcfPHFh3zf9u3bZf78+fLee+/pm/reP/3pTz79nQEAEGhoawcAIMiparMK17GxsZKdnd32+ccff1wH8z/+8Y9tn3vuued0cN+yZYsMGjRIf27gwIHywAMPHPKY7fevq4r2/fffL9ddd508+eST+rnUc6qKefvnO9ynn34qa9eulZ07d+rnVP7zn//I8OHD9d70iRMntoV4tYc9ISFBf6yq++pn//CHP3jtdwQAQKCjcg4AQIhavXq1fPbZZ7ql3HMbMmRIW7XaY/z48Uf87CeffCIzZsyQXr166dCsAnNlZaU0NDR0+vk3btyoQ7knmCvDhg3Tg+TU19qHf08wV3JycqSsrKxbf2YAAIIVlXMAAEKU2iN+zjnnyJ///OcjvqYCsIfaV96e2q9+9tlny/XXX6+r16mpqfLVV1/J1VdfrQfGqQq9N0VGRh7ysarIq2o6AADhhHAOAEAIUK3mdrv9kM+NGzdO3njjDV2Ztlg6/7/85cuX63D817/+Ve89V1599dXjPt/hhg4dKoWFhfrmqZ5v2LBB74VXFXQAAHAQbe0AAIQAFcCXLFmiq95qGrsK1zfccIMexnbppZfqPd6qlf2jjz7Sk9aPFawHDBggLS0t8thjj+kBbmqSumdQXPvnU5V5tTdcPV9H7e4zZ87UE98vv/xyWbFihSxdulSuuOIKOeWUU2TChAk++T0AABCsCOcAAIQANS3dbDbrirQ6a1wdYZabm6snsKsgfvrpp+ugrAa9qT3fnop4R0aPHq2PUlPt8CNGjJB58+bJ3LlzD/keNbFdDYhTk9fV8x0+UM7Tnv72229LSkqKnHzyyTqs9+vXT1555RWf/A4AAAhmJqfT6TR6EQAAAAAAhDMq5wAAAAAAGIxwDgAAAACAwQjnAAAAAAAYjHAOAAAAAIDBCOcAAAAAABiMcA4AAAAAgMEI5wAAAAAAGIxwDgAAAACAwQjnAAAAAAAYjHAOAAAAAIDBCOcAAAAAABiMcA4AAAAAgBjr/wOr7A9f1SyPdAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(12, 6))\n", - "plt.plot(objective_func_vals)\n", - "plt.xlabel(\"Iteration\")\n", - "plt.ylabel(\"Cost\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "103981ed", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", - " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "res_bin, res_int = cost_function_res(init_params)\n", - "plot_histogram(res_bin)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "0d1cf38b", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", - " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{20: 0.1926, 22: 0.1948, 9: 0.189, 10: 0.0229, 11: 0.1928, 26: 0.0454, 18: 0.0252, 8: 0.0016, 5: 0.0402, 21: 0.028, 23: 0.0021, 28: 0.0053, 16: 0.0016, 6: 0.0047, 25: 0.0055, 13: 0.0259, 3: 0.0059, 0: 0.0021, 24: 0.0033, 7: 0.0033, 31: 0.0024, 15: 0.0021, 30: 0.0008, 19: 0.0004, 29: 0.0003, 1: 0.0003, 4: 0.0004, 14: 0.0003, 17: 0.0004, 27: 0.0002, 12: 0.0002}\n" - ] - } - ], - "source": [ - "res_bin, res_int = cost_function_res(result.x)\n", - "shots = 10000\n", - "final_distribution_bin = {key: val / shots for key, val in res_bin.items()}\n", - "final_distribution_int = {key: val / shots for key, val in res_int.items()}\n", - "print(final_distribution_int)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "ec6a816c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Result bitstring: [0, 1, 1, 0, 1]\n" - ] - } - ], - "source": [ - "def to_bitstring(integer, num_bits):\n", - " result = np.binary_repr(integer, width=num_bits)\n", - " return [int(digit) for digit in result]\n", - " \n", - " \n", - "keys = list(final_distribution_int.keys())\n", - "values = list(final_distribution_int.values())\n", - "most_likely = keys[np.argmax(np.abs(values))]\n", - "most_likely_bitstring = to_bitstring(most_likely, len(graph))\n", - "most_likely_bitstring.reverse()\n", - " \n", - "print(\"Result bitstring:\", most_likely_bitstring)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "a6c223b0", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.rcParams.update({\"font.size\": 10})\n", - "final_bits = final_distribution_bin\n", - "values = np.abs(list(final_bits.values()))\n", - "top_4_values = sorted(values, reverse=True)[:4]\n", - "positions = []\n", - "for value in top_4_values:\n", - " positions.append(np.where(values == value)[0])\n", - "fig = plt.figure(figsize=(11, 6))\n", - "ax = fig.add_subplot(1, 1, 1)\n", - "plt.xticks(rotation=45)\n", - "plt.title(\"Result Distribution\")\n", - "plt.xlabel(\"Bitstrings (reversed)\")\n", - "plt.ylabel(\"Probability\")\n", - "ax.bar(list(final_bits.keys()), list(final_bits.values()), color=\"tab:grey\")\n", - "for p in positions:\n", - " ax.get_children()[int(p[0])].set_color(\"tab:purple\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "76444240", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10110\n", - "01011\n", - "10100\n", - "01001\n" - ] - } - ], - "source": [ - "for p in positions:\n", - " print(list(final_bits.keys())[p[0]])" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "ca9172e6", - "metadata": {}, - "outputs": [], - "source": [ - "def evaluate_sample(x: Sequence[int], graph: nx.Graph) -> float:\n", - " assert len(x) == len(\n", - " list(graph.nodes())\n", - " ), \"The length of x must coincide with the number of nodes in the graph.\"\n", - " return sum(\n", - " x[u] * (1 - x[v]) + x[v] * (1 - x[u])\n", - " for u, v in list(graph.edges)\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "3a6a65a6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The value of the cut is: 5\n" - ] - } - ], - "source": [ - "cut_value = evaluate_sample(most_likely_bitstring, graph)\n", - "print(\"The value of the cut is:\", cut_value)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "01920bcd", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The value of the cut is: 5\n", - "The value of the cut is: 5\n", - "The value of the cut is: 5\n", - "The value of the cut is: 5\n" - ] - } - ], - "source": [ - "for p in positions:\n", - " result = list(final_bits.keys())[p[0]]\n", - " bin = [int(digit) for digit in result]\n", - " bin.reverse()\n", - " cut_value = evaluate_sample(bin, graph)\n", - " print(\"The value of the cut is:\", cut_value)\n", - " #print(list(final_bits.keys())[p[0]])" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "968c5412", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The value of the cut is: 5\n", - "The value of the cut is: 4\n", - "The value of the cut is: 5\n", - "The value of the cut is: 2\n" - ] - } - ], - "source": [ - "# results from https://quantum.cloud.ibm.com/docs/en/tutorials/quantum-approximate-optimization-algorithm\n", - "result = [\"01011\", \"10101\", \"10110\", \"11000\"]\n", - "for r in result:\n", - " bin = [int(digit) for digit in r]\n", - " bin.reverse()\n", - " cut_value = evaluate_sample(bin, graph)\n", - " print(\"The value of the cut is:\", cut_value)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/qbraid_algorithms/qtran/gate_library.py b/qbraid_algorithms/qtran/gate_library.py index 0b98d9c..f4e019c 100644 --- a/qbraid_algorithms/qtran/gate_library.py +++ b/qbraid_algorithms/qtran/gate_library.py @@ -315,26 +315,26 @@ def begin_subroutine(self, name, parameters: list[str], return_type=None): self.builder.scope += 1 self.subroutine_ref.append(name) - def close_scope(self): + def __close_scope(self): """Close the current scope block and decrease indentation level.""" self.builder.scope -= 1 self.program("}") def end_if(self): """End conditional block.""" - self.close_scope() + self.__close_scope() def end_loop(self): """End loop block.""" - self.close_scope() + self.__close_scope() def end_gate(self): """End gate definition block.""" - self.close_scope() + self.__close_scope() def end_subroutine(self): """End subroutine definition block.""" - self.close_scope() + self.__close_scope() def controlled_op(self, gate_call, params, n=0): """ @@ -407,7 +407,7 @@ def add_var(self, name, assignment=None, qtype=None): call = f"{qtype if qtype is not None else 'let'} {name} {f'= {assignment}' if assignment is not None else ''};" self.program(call) return name - + def add_input_var(self, name, assignment=None, qtype=None): """ simple stub for programatically adding a variable @@ -416,10 +416,11 @@ def add_input_var(self, name, assignment=None, qtype=None): name: variable name Assignment: whatever definition you want as long as it resolves to a string """ - call = f"input {qtype if qtype is not None else 'let'} {name} {f'= {assignment}' if assignment is not None else ''};" + call = (f"input {qtype if qtype is not None else 'let'} " + f"{name} {f'= {assignment}' if assignment is not None else ''};") self.program(call) return name - + def add_output_var(self, name, assignment=None, qtype=None): """ simple stub for programatically adding a variable @@ -428,10 +429,11 @@ def add_output_var(self, name, assignment=None, qtype=None): name: variable name Assignment: whatever definition you want as long as it resolves to a string """ - call = f"output {qtype if qtype is not None else 'let'} {name} {f'= {assignment}' if assignment is not None else ''};" + call = (f"output {qtype if qtype is not None else 'let'} " + f"{name} {f'= {assignment}' if assignment is not None else ''};") self.program(call) return name - + def classical_op(self, operation): """ simple stub for programatically perform a classical operation @@ -585,4 +587,4 @@ def cry(self, theta, control, targ): # ═══════════════════════════════════════════════════════════════════════════ def cswap(self, control, targ1, targ2): """Apply controlled swap gate""" - self.call_gate("cswap", f"{targ1}, {targ2}", controls=control) \ No newline at end of file + self.call_gate("cswap", f"{targ1}, {targ2}", controls=control) diff --git a/requirements-test.txt b/requirements-test.txt index acbe046..14f26ac 100644 --- a/requirements-test.txt +++ b/requirements-test.txt @@ -1,4 +1,5 @@ pytest pytest-cov qiskit[qasm3-import]>=2.1.0,<2.3.0 -qiskit-aer>=0.17.0,<0.18.0 \ No newline at end of file +qiskit-aer>=0.17.0,<0.18.0 +networkx \ No newline at end of file diff --git a/tests/test_qaoa.py b/tests/test_qaoa.py index b568b4d..ee54cb3 100644 --- a/tests/test_qaoa.py +++ b/tests/test_qaoa.py @@ -14,19 +14,13 @@ """ Tests for QAOA implementation. """ -import io import os -import sys -import tempfile -from pathlib import Path + +import networkx as nx import pyqasm -from pyqasm.modules.base import QasmModule from qbraid_algorithms import qaoa -from qbraid_algorithms.utils import get_max_count - -import networkx as nx from .local_device import LocalDevice @@ -89,4 +83,4 @@ def test_execution(): module = pyqasm.loads(program) module.unroll() program_str = pyqasm.dumps(module) - result = device.run(program_str, shots=1000) \ No newline at end of file + _ = device.run(program_str, shots=1000) From 3d9e0023d915c9489ae09fcb4a69af2dc1ade323 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 29 Jan 2026 18:31:34 +0100 Subject: [PATCH 14/20] More fixes for isort and mypy --- qbraid_algorithms/qaoa/qaoa.py | 6 ++++-- requirements.txt | 1 + tests/test_qaoa.py | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/qbraid_algorithms/qaoa/qaoa.py b/qbraid_algorithms/qaoa/qaoa.py index 56f1c5e..32f4f4b 100644 --- a/qbraid_algorithms/qaoa/qaoa.py +++ b/qbraid_algorithms/qaoa/qaoa.py @@ -18,10 +18,12 @@ This module provides an implementation of the Quantum Approximate Optimization Algorithm ansatz for different standard mixer and cost Hamiltonians, namely maximum-cut, maximum clique and minimum vertex cover. """ + import networkx as nx from qbraid_algorithms.qtran import QasmBuilder, std_gates + class QAOA: """ Quantum Approximate Optimization Algorithm (QAOA) class used to define cost and mixer Hamiltonians @@ -311,7 +313,7 @@ def layer(self, cost_ham : str, mixer_ham : str) -> str : return name - def generate_algorithm(self, depth : int, layer : str = "", param : list[float] | None = None) -> str: + def generate_algorithm(self, depth : int, layer : str = "", param = None) -> str: r""" Load the Quantum Approximate Optimization Algorithm (QAOA) ansatz as a pyqasm module. @@ -330,7 +332,7 @@ def generate_algorithm(self, depth : int, layer : str = "", param : list[float] """ if param is None and self.use_input is False: raise ValueError( - "Param cannot be None if use_input is False" + "param cannot be None if use_input is False" ) std = self.builder.import_library(lib_class=std_gates) diff --git a/requirements.txt b/requirements.txt index e10e60c..946e159 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,3 +3,4 @@ pyqasm>=0.5.0,<1.1.0 sympy>=1.14.0 scipy>=1.16.0 numpy>=2.3.1 +types-networkx \ No newline at end of file diff --git a/tests/test_qaoa.py b/tests/test_qaoa.py index ee54cb3..cd00f99 100644 --- a/tests/test_qaoa.py +++ b/tests/test_qaoa.py @@ -17,13 +17,13 @@ import os import networkx as nx - import pyqasm from qbraid_algorithms import qaoa from .local_device import LocalDevice + def test_generate_program(): """Test that generate_program correctly returns a str object.""" qaoa_module = qaoa.QAOA(4) From f4179ca28818a4c5867dc5292e89f1e59eb208d0 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 29 Jan 2026 18:43:46 +0100 Subject: [PATCH 15/20] Added more unit tests --- examples/qaoa.ipynb | 78 ++++++++++++++++++++++----------------------- tests/test_qaoa.py | 30 +++++++++++++++-- 2 files changed, 67 insertions(+), 41 deletions(-) diff --git a/examples/qaoa.ipynb b/examples/qaoa.ipynb index ff53fcc..73a7c06 100644 --- a/examples/qaoa.ipynb +++ b/examples/qaoa.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "1c81f61d", "metadata": {}, "outputs": [], @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "id": "18ff0ac8", "metadata": {}, "outputs": [ @@ -77,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "9d2812e8", "metadata": {}, "outputs": [ @@ -118,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "5e8714c7", "metadata": {}, "outputs": [], @@ -143,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "76eec508", "metadata": {}, "outputs": [], @@ -177,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "df258b64", "metadata": {}, "outputs": [ @@ -188,10 +188,10 @@ " message: Return from COBYLA because the trust region radius reaches its lower bound.\n", " success: True\n", " status: 0\n", - " fun: -1.0089000000000001\n", - " x: [ 1.571e+00 1.529e+00 1.588e+00 3.159e+00 4.148e+00\n", - " 4.152e+00]\n", - " nfev: 26\n", + " fun: -2.2875\n", + " x: [-2.921e-01 2.782e+00 2.051e+00 4.779e+00 2.335e+00\n", + " 3.005e+00]\n", + " nfev: 57\n", " maxcv: 0.0\n" ] } @@ -219,13 +219,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "e8596cb2", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -252,7 +252,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "103981ed", "metadata": {}, "outputs": [ @@ -266,12 +266,12 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAb55JREFUeJztnQe0FEX6t4sogoCAREUERTGtoKACioKuCibMomsA15zQNYCKLOawCuYc1jVhRESWRRFkBRVBgVVRAXFhUUBEwECmv/Mrv7r/vkP3TM+dmTszPc9zzhy4Pf1OVXVXV//qraq3qnie5xkAAAAAKHqq5jsDAAAAAJAdEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMaF6vjNQqGzcuNF89913pm7duqZKlSr5zg4AAACUKJ7nmZ9//tm0aNHCVK2a3CeHsAtBoq5ly5b5zgYAAACAZcGCBWabbbYxyUDYhSBPnbuI9erVy3d2AAAAoERZuXKldTY5bZIMhF0IbvhVog5hBwAAAPkmytQwFk8AAAAAxASEHQAAAEBMQNgBAMSIhx56yPzhD38om0bSuXNn889//rPs+wMPPNAO5/g/5513Xtn3M2bMMH369LHzeTbffHOz8847m3vuuSdPpQGAdGGOHQBAjNCKudtuu820bdvWhkj4+9//bo4++mjz6aefml133dWec/bZZ5sbbrihzKZ27dpl/582bZpp0qSJefbZZ624mzx5sjnnnHNMtWrVzEUXXZSXMgFAdKp4evIhcAVK/fr1zYoVK1g8AQBFTcOGDc2dd95pzjrrLOuxa9++vRk2bFhk+wsvvNDMmjXLvPvuuznNJwBkrkkYigUAiCkbNmwwL774ovn111/tkKzjueeeM1tttZXZbbfdzMCBA81vv/2W9Hf0MpE4BIDCh6FYAICY8Z///McKudWrV5stttjCvP7662aXXXax351yyimmVatWNoL9zJkzzdVXX22++uor89prrwX+loZihw8fbt56661KLgUAVASGYkNgKBYAipW1a9ea+fPn2/brlVdeMY8//rh57733ysSdHw2vHnTQQWbOnDlm++23L/fdZ599Zrp3724uvfRSc91111ViCQDAD0OxAAAlTM2aNc0OO+xg9tprL3PrrbeaPfbYI3Rl6z777GP/lbDz88UXX1jBp4UTiDqA4gFhBwAQczZu3GjWrFkT+N306dPtv82bNy879vnnn1tP3RlnnGFuvvnmSssnAGQOc+wAAGKEFkP07NnTbLvttubnn382zz//vJkwYYL517/+ZebOnWv/7tWrl2nUqJGdY3fZZZeZbt262dh3bvi1R48e5tBDDzWXX365WbRokT2ucCeNGzfOc+kAIBUIOwCAGLFkyRJz+umnm++//97OyZFgk6j74x//aBYsWGDeeecdG+pEK2UVp+64444rN9SqOXk//PCDjWOnj0MLLr799ts8lQoAosLiiRBYPAEAAACFAIsnACDW22I51C/VsKO2xRoxYkTZcbbFAoBShaFYACjKbbGEhhQl6hJhWywAKFUYig2BoViAwt0Wy63mPOKII8zUqVPtik4F4e3du3eoPdtiAUCxwlAsAMR6WyxtgaUdFB544AHTrFmzSL/DtlgA+Zs+ce6559oA2JoaodXV8sB/+eWX5X5j3LhxpkuXLqZu3br2udauKOvXr89DaYobhB0AFOy2WNoOa7PNNjPnnXdeuW2xFKJDLwC9HKLgtsXScCwA5G76hKZByIuukDl6PhUTUShY9lNPPWW95lqlrcHCQw45xHbc3LxYheE57LDD7JQLPa8jR440AwYMyHPJig+GYkNgKBagMLfF0g4Jf/nLX2zjL+EnNM8ubCiWbbEACmP6hB/FUNSOKG4ru2uuuca8/fbb5uOPPy4758033zQnnniiDeEjL14pszINTcLiCQAo6G2xXG9fDb5WtmooR4F2t9xyy3LnKx7b/vvvb4PxOtgWC6DykRfu5ZdfLjd9wo+Oy3vXunVru7hJaGeUWrVqlTtPz/rq1autF/DAAw+stPwXOwzFAkBRbYuloRn19rV4wn3E0KFD7cvCwbZYAIUzfUI8+OCD9nt9NP9OHjp14IR2OtGUiRdeeMEKw4ULF5obbrjBfqdg2xAdhB0AFOS2WBMnTrQ7Hehlob/liTv11FPtpOrddtut3EdoCy15APzDr5rD47bF0kc7KgBAbthpp51sR+ujjz4y559/vu1UyWvu0POrKRSaUrHjjjvaYVZ55ISeVQ3bShBKGOp7zbkTVasiVdKBOXYhMMcOIH9oTo5WyPm3xdIKOW2LFUTiHLu//vWvZsiQIZucx7ZYAJXHwQcfbOfPPfLII4FzaBs0aGDnziqYuEOSRM+9vtOzKo/flClTTKdOnUwps5JwJ/FZAk4EfShFnnjiCduoa+hVE6e1v2mYqHMvA//CCQk7HUv8IOoAKn/6RBDumUz8Xp20Fi1a2PedhmX17ttzzz0rKcfxAGFX4EvA/RH0ZXPttdfaYan7778/zyUDgDiSjXhkl1xyiW3bNKTWvn37PJQCCmn6xDfffGNuvfVW+z7TSnfNpTvhhBNsHXLDrUJDsbLVu+7GG2+07857773X7hgDaaChWNiUFStWaIja/pttGjRo4D3++OOB382YMcOmO2fOnFD7Cy64wOvevXvW8wUA+efBBx/0dt99d69u3br2s++++3qjR48u+/6cc87x2rRp49WqVcvbaqutvKOOOsqbNWtWud/473//6/Xq1cvbfPPNvcaNG3tXXHGFt27dukjpjxw50nvrrbe8r7/+2vvqq6+8a665xqtRo4b32Wef2e8feeQR77333vPmzZvnTZs2zTvyyCO9li1beuvXry/7jYsvvti7//77vdNOO83bY489snZtoHDrTr9+/bxWrVp5NWvWtHYHHXSQN3bsWPvdwoULvZ49e3pNmjSxdWmbbbbxTjnlFO/LL78s9xt6r9WvX9/mb5999imX91InHU2CsKtEYaeG74UXXrAV//PPP9/k+19++cXr37+/17p1a2/NmjWhv3Pqqad6xx13XNbyBQCFQ6bCSv/utttu3sEHH+x9+umn9uWol/jAgQMrvTM6ePDgtIRdMmHy448/ehdddJG344472he/yiwBuXz58nK/8c4773idO3f2tthiC69p06beVVddFVnUFjuFWHcgOyDsCkzYzZw506tTp45XrVo12xvRg+fngQcesN8rvZ122impt27SpEle9erVvX/9618Z5wsAioN0hJVexlWrVvUWLVpUds5DDz3k1atXL2mHMRed0XSFXTJh8p///Mc79thj7Tkq67hx47y2bduW6+ROnz7d5nXIkCHe7NmzvQkTJnjt2rXz/vKXv3ilSr7qDmQXhF2BCTs9EGpkpk6d6g0YMMD2gPyNpHqcasjUk1IPas899/RWrVq1ye+oYZPtjTfemHGeAKDwqYiwGjRo0CZi6ptvvrHt2SeffFKpndF0hV26wuSll16y18Z55ORZ6tixY7lzJATl4Vu5cqVXSuSr7kD+NQmLJyoxgr4mE2sCqbZR8a9s1RLmtm3bmm7dutmtkzQRWaEb/BBBH6B0yCTQq+L1NW3atNzvub/1Xa7jkWULLSB78cUXQ3cvEC70Q/Xq1SPtXlAK5LvuQP5B2BXBEnAi6AOUFvkWVtnojOZKmDiWLl1qV06qs+tg94L81x3IPwi7Al8CTgR9gNIjE2GlnTkWL15c7vfc3/qusuKR5UqYuGCthx9+uBV8ilnoYPeCwqs7UPmURk3PIwquevrpp9vGSkOp2shc8eoUbFVDBv/+979tw6MH8aSTTjJ169a1Ak+x64QePIk4xbFr3rx52acYonAni4e1bNkyc/HFF9vrIiGr7aAU+0pDK0H8+OOPNiagglcuX768kksCkF/SEVZ6ztSJVNvj0HCbnsEgz1cu4pHNmTPHijN1QletWlW2p692G8hUmPz888/msMMOs22lBEmNGjXK2asDrDZC+ZNXT3H2RJs2bUwpUpl1BwqEHM3zK3pyGceuVMh0hZufo48+2sZB0j356aefKr0sAJWFFli5kBRaxKC/q1SpYmOCzZ0717vlllvsQizFG9MqeS24atiwobd48eJyISsOOeQQu0p0zJgxNq6YC1nR6upRST/ZiEd2wAEH2Gc18aMypYtim51xxhn2/2qPFQJFv//rr79GsteCgMQ4e4VKpuFeLr30Uq9Tp072vil6gn5D1/3111/PSt2B/MGq2CyAsMsN6axw8zd2asgl/hB2EHeyIay+/fZbe56CzGolvcJ9uOcqlbArVFGrtlhBayV81Bn8/vvvyz5+0XbHHXdYW3Ugb7jhBnudJGxKoTOsGKcSarJp1KiR16FDB1tH+vTpk5W6E2dRPH36dO/kk0+210XnKEzOsGHDvEIBYZcFEHaVu/RePPbYY7Yh8aNzmzVrZnuY48ePR9gBZEghC7tkotY9/6k8gXHbvaAinWE/99xzjxUrcSdTUfzEE094l1xyiY19KO/mP/7xDytu77vvPq/YNMnva8QBcoTma2jehlZdaaVbOivcNO+jT58+djK05uBpfg8AxJcnnngi9LsDDzzQzgdLxbvvvmvigFb1vvzyy2mFe0nku+++M6+99po54IADTNw58sgjy/19880323neH374oTnrrLPMq6++Wvad9jrW93/605/M+vXr7fXr169fOXvNyfzggw/s9bvoootMMcHiCcgpmaxw06TtnXfe2T58AAClQCbhXhzqENeuXdtsvfXWVvg9/vjjppTYUIEYiGHnNGzY0BQbCLsiXVUqHn30UduL1Xdhq0W//vpruypsq622suftt99+Zvz48ZVWhkxWuKnnrR6rHjx9tKpYqCyDBw+utDIAABRDZ9gxdOhQ88knn5g33njDzJ07164ULgWyIYodWvE9fPjwpOcUKgzFFjAK73HbbbfZmEMagvj73/9uRZqCS+66667mt99+s6JIH3m3gjjiiCOsvUSSQhIMGzbMHtPDno+4RP6l92qcFFBUD+HIkSM3iRgv17lCJTgUKkbucoWIkSsdACBuuM6wUIdY7Z46w4888kikcC9Cbbs+7dq1sx6n/fff3wwaNMiGyioFUbxixQobKkyiWIGY/eIulSh28WP1rpUDQbERiw2EXZHOGZCw69+/vz2uGFNBqFcye/ZsO29Fnj8hoagtZVRxcy3sJDZ79uxp58epMXr++edtXhXHTw+XHhiJU8Xo09/6iMaNG5tq1aptIt5UHqHh2S233DKneQcAKATS6QyH2YtsBZCOuyj+IgbbdzIUG6M5A4k0atTI9mCeeeYZa6dJoqrgCn6sSp/P4MwaJtBQg1znehD9wZcXLFhgip1sDKNvt9129jv/R8Iccgv3DvJFsuDQrjOstlyddf3tdiLS+0GMHj3aPPXUU7bjrt9466237JBk165dbZ0sdVF8yCGHWPEXJorjsn0nHruYrCoNQi+Td955x/Tu3dv2ULSljkTdmDFjTIMGDYpihVumNsU8jC60z+XZZ59d9rfuI+QW7h3kC9cZ1r622vpLHQzXGZbAU2dYOK+UY968eVa4abrNY489Zi677DIraFq2bGmOPfZYM2DAABN3Mh0h+uyzz0yPHj2sR9Rt3yn0nc4pJhB2MZgzEIZeShdeeKEVc5qXpodeq6M0xCvvWdznWxTzMLpfDLBH46ZsN+CtpN9/e9vhFf5t7h3ki0w7w/I2adJ/KZKpKH7Ft32nPo5WrVpZ72cxwVBsgZNqVWkytGBi1KhRdghXrvg999zTzq+TwJMXAgp3GN0hz5GG1Dt06GDj+Wk4HSoP7h1A8YhiCbA1a9ZYkafRKok6vygO+rghai2kCPq+2ESdwGMXow2dE5HbWWgI1o/+dhNqoTCH0cUll1xixbhWtakXrqEG9UbvvvvunOYbuHcAULwg7Ip0zoBwE2fnzJlT9jLS8I/O1wtFLybNpdPw7fXXX182/0KuZy33hsIdRhf+2FMaVpD39txzz7WeW62Kg9zBvas4GrbWx3k6NHyt9kdtmVt8orZMC6jUrv3000+brHLX8Lcm/use6NoFLVCBeE2hyGT6BJSHodgCJtmqUvHwww/bYR43Qbtbt272b634cYF8tVDil19+sZNCO3bsaN5//30btFJDulC4w+hB7LPPPnY4L8rQQDZWdi5btsyuxtM5evFqWx7VpVIgn/cuLotPpk2bZqZOnWrbHi0+0YpD4RafXHPNNaG/sXbtWnPCCSfYAL0AkB4IuyKdM5BsTsCZZ55Zdo7EnMTgjz/+aFcBae8713OOO6nEjYbZtLhE86A03HbccceZxYsXl/uNcePGmS5dupRNhL/66qsrPFcqnWH0IOS9cCubK+PlKlGn899++207V1NhGKJGYS+0a58plXnvih0tPunVq5ddVbzjjjta75vusRafCC0+0SrNfffdN/Q3hgwZYld27r777pWYc4B4wFAslGzYCr04NNyjbcu0ikobPSs0wKRJk6z9jBkz7Avq2muvtbEAFy5caGNCaUL93/72t5wOo0uAaxWXVrnpuP5WfrVvbpRQNZmu7Jw1a5b19spLrM6BuO++++z1UNlbtGhRsNc+U/J97+JElI3sASDLeBDIihUrtK7c/gvxoUGDBt7jjz/uLV++3KtRo4b38ssvl303a9Yse88/+OAD+/fAgQO9jh07lrMfOXKkV6tWLW/lypVJ0+nXr5/XqlUrr2bNml7jxo29gw46yBs7dmzZ94MHD7ZpJX6eeuop+/20adO8ffbZx6tfv75Nb+edd/ZuueUWb/Xq1WmXef369d4LL7xg8/L555+X+278+PE23Z9++qnc8SeeeMLbcsstyx1bt26dV61aNe+1117z8n3tW109KunnwQcf9HbffXevbt269rPvvvt6o0ePLvutVatWeRdccIHXsGFDr06dOt6xxx7rLVq0qOzeNWrUKPD+6HPFFVdU2r3LBamuXTaYOXOmva6qL7oOb7311ibnhNU9P7qmsofKIZPnxt2vsOdm8eLFOa93cWZFGpoEjx2UpOdAQ5Tr1q0zBx98cNk52ldRXhd5WDRMpKG3xOjkWoCiYUTZa45aReJRuWH0sH0KhVZUuqGrfKzslEcqcdiwevXq1iPlAnfm89qnIhOPoe7d/fffbxdO+NEUB6Wv0CX65PLelfriE8gPmXraTzrpJDvFI+i5KYVpCIUCc+wg1kjcSNRoJaKG8py4kTjRBPnE1XhNmzYtEy6KQK5QFS+88IIVJxoO1G4CQqErckk25qjJXmJKedcLViuhcz2MWSjXPtk8L10LiTeFHtHcQy2Q0DZMSs8JMolIt5G6Poo+r7iQWkAClb/4BCoHnpt4gLArgOXfyT6QHc+B5jxphZ08B9rkOQpz5861YuOUU06x3ip5lLbffnv7nSbCRxFXDi1eUW84bAVquosf1HN+8803bc9ZnpDvvvvO9pwTUcMrIaTP/vvvb7788stIZVejrAU7frRwQStlo+6mkMm11/Y/8opJEEoY6iWjF05QXMZ0gwyn8hgGoXl+tWvXNscff3xaaUN2Fp9A5cNzU7wwFAsl4TkQ6mFqMYA8BxoyUEgFiSy/50jCzAkXiSttwSZ7HZeQGjp0qP2uTZs2KYcl/KjHKg+aPE9RSLb4QflSz1mT+iX4nIDbeeed7ff+1YYqmyuPxGnUVaVqyHVt1Jjrugn1vPWCVuiOXF97FwtO11iiVIsOtEJcCxt07c2n5UVnOkPRLjZaMo9hIrreEvjySJQ6qTqcfaq8n9HiEzF//nzbidC/Ehi6Z0L1SfcScgfPTfGDsIOS9BxIaNSoUcOG1JCnTXz11Vf2ReJW7/nFlTxG8nhpZaheQvLcRRVXEmQSMQrS6h9OzeUcNbc5vYLiao6LGlYJJ610jfJyVTk0V0YxEhUvUelJuJ588skpV8Rm49o75OF06WlYVpuaaw6befX3clRknle66JpqlfA//vEPE/d9cnO9Z6dQfVI4E4fib7rnx4Vq0rPi3/ZQ8TnF+PHjk85thczrTlyfm1ICYQexJVnYCr1w5EWTV0hCRvPYLr74Yiss/KJMw4ESOJpIfNNNN9le7B133GEbvlTiSmjoUXPDNBz5zTffVFrPWS9Xfa+o/rLVR8PBGorVMGeql6vEqITW119/bT10misjAavAxkJ5+stf/mKHaiTWNCdO+xArD+7ay1aCTR9dY22wXZFrr6HX1157zQ5Nv/TSSzYvleExdMhr2759+zLPJSQn04VD4umnn7afYhO2qXbdSPXcuO3o5PX/7LPPbAfLeSsrC56b4oc5dlCyO3doWPWII46wXiMJGzVOEhB+5CmTx0GTv/WdxJBESJQFAGq4+/TpYwWKBF+6ZDJHTS9XiTo1xBrSmj17tg0K61ZzpgpureFenav0JMwUHFii+L///W+kOX669gpsLFsJMQVETvfay7spL6ni6GnIWzum9O7d21SUII+hI8xjqJ02JCaZ/A1RyNbc2H79+lkhVQiUynPzUBYWrOlaaJGa5hVqFfCVV16Zl6DqeOygZD0HCqfxwAMP2E8Y2oJND6sbltBQbNSJwPJaqcetwLT57Dk75Hm78cYbbSOdar/STOf46Xt3/SUiR4wYUW7XlCjXXnP68umtFcOHD7cNc0XvIZQW2Zgbe++999p/5eGeOXNmpea/lJ+bbTIM9aIpMxJ1aoO1UlhTEeRYkBi+5ZZbKrUsCDuAHIkrCRMNp0oQCjUWbg9f7ajgHwrN1Rw1P/L+aRFCupvQV2SOX75JNc9LHkMN8er6+YfEEtGLWI13omcWIBU8N8X13ByZoSgfO3asHeHQ1p8audEwtDrSGu1Q51bvksoCYQeQI3H16quvmlWrVpXZShRqiOXf//53WdiUXPWcNdwjkam/5R3TsKh6jVdccUVeVscVo7dWqOcNkA48N8X/3GyogCjXv9rb2D9fUsJX02g0FO8WAJWksEs2+VRzhQYPHmyVsV6gjRs3tnNupIr1snPoO11MraDSg6W5SQqSqXAPUDgU8iTobIirRPG2dOlS+696eal6spn2nCU61fhq+ECeQnkdFVhUq1yjkq3VcQClBM9NaYryRYsWlRN17nv3XWVSvZjGufW3Jpsqer4utiZyK4CpjrnhrkIa5843ErOakK6VkAp30aVLF3P77bfbhscfhFdeHM0lk0DQKkTNI0usoJpboNWdmvOhXtsBBxxg503FmWwNS+Sj56z7mLi1T77n+AGUArl8bgq9M1zs7BQTUV61mLY02W233ezwls6RN0Rj3fpew05u5Ykb53722WftGLc8LvLo6QWoh6qUUIXUKh5dOw3FyZWsUBdyLwv9q78VK0zzwTQJVNdI11dDjg5d89NOO8307dvXzJgxw56noJOVIUw7depk46tphZG8sxru9CNheswxx1jvrbxmJ5544iYrlbbbbjtbRv9HnYco4kqeY4k2iTzNnQhaACBPsq6lRHSyBlrxt9Q5KaZ5J5mujgModXhuimeXp5ohW+GpXXei3I9flOvfxHeP+7uyO7wF57FLNs4dhJS1XuhumLWi49x68Pxb3qxcudL+KzGkj5B3RqEblC+/8HHHJS7dBHmhY/ou7Lj73WToHFe2xGXTaiSUD+XHIdGi83Vcgtd/XHGhJJAUPkNhJCT8JFzkDa1Tp461UewhnSMhqOsml/Sll15qhZCEncu7RLc//2FlCst7lGFxDXvKI6twF25oVEJU4lL5VQgN/e08aUKTVBVGQ2XUNXf3SUP4GoZ090mdBZfXdO9TqjKle5+CjofVsVzVvcS8a3GHPH6tW7e2w9DqKOl+yHOrpfxuGNqFBujfv78dgtbHlUnBjxX2QB51zTXUPBV9J2+7GtBMypTJcxOH+5Sq7MnKlIqoZQpD5+TyeUqF//cr+z6lem40xzbd5+aTTz6xx/XcRCFZmaJcu1y2exXNezbuU5SyJ5ZJ6eoe6B3jRLkcCTruRLmcDy7qgBxN2l1I71DVPb1HdZ/lqMqGjihqYRc2zp2I5izJG3fOOeeUHavoOLfUedAqRXkA9UAKzbWSMNRwpG6o332riZRTpkyxS9Qd8hi2atXKTJw40T7kDpVNN16/nYrRo0dbD6Yql+YM+iuehpx1Dfz79Mm7JU/mggULygW2lEdLaQoFvlR+lF9VPq2SdGVS5dMxiUI1KI888oitqGqANF9L56oCK+SHVndqmFKCUY2RejTq4fz5z38u80p1797devcktCTCdT/1kPijyodxwQUX2H8VWFdlUoBg9aQ03Km5lwr4K2GqpfUqr9DOCFpiLw+k4g2pTBKA+l5l1n3SEH2698n/UKlMGtrWvfGTrfukIXPFnfN7J3NR95KVSfde99V1nLT7g8Sx7rFsNQytjpBWvqnOKG8KvCpcmfSSc/G7hBPoqlN6JjMpUypUjrjepyhlT1amVM1+6jIlt9e1yuXzFLX8+bhP/udG0zeaN29e9twoX4oNqRe6/7nRqIpw9ynxuXEBfvXcGLN1yvInK1OUa5fLdi/zulfx+5QKxRzVrjZ6r6mtkiiX80P3T6NUWjghUa7347x588xjjz1m8+FGAjV3WlPJ5FjQEK7EmXSF3kl+L21FyxS0VWUYVTy/NCwQdKH8scPkRdIF9os7edQ0LKaJ6yNHjrRqWkjkae6d8+AIvdjl4VGFdBHAo3jstH2RKqZebLnq5bUdlFzczb7xkKx4GJS+GhMFrVUPUqjyqDLKEyeBrPPVqEg4ybule6AKpd0G5EpWI+U2k5dwUgXUPZCHVKJYZZK9ztGcPf2tvEgE7L333vY31AvV8m/l87tu16Ysu79M2slAlV+Np4bl1QuWwNS9cvdf91Ci8rrrrjODBg2y10G9JXUSdL31UOlBU3R3d13x2BVfmXa47v+e73Sfm2K/T60Hjk5Z9mRlStXmzL35sKRlSmX/zS09c1r3orSZcX2eUpVdc+ySlSnKc5PLMiXLf7K8Z+M+tbkm+XaO3Re/YsWpf061OqtuJazeIQryrq0N9Z7Ru0/z0fVedPdJzgYtopNekeaQwJMXT3nKtEya8iNnhetsF53HLmzy6e89FmOVuNzd6k3Lm+de6kLiIbFnEmWcW56ooPhe+m3/77sLHeTaDetNhh1P/N1U5wSdn6qyusm0GoqWp06Cy/2OvDAa6tZ3CoqpyuN6LSqf9hXVSlAJOwk3uaDVk5N41gOge+KGcl1F076AipWmkB7ugVAvx6H7qiFVzZdr2XW9qVItvAr6y6sHQL/TtWvXsuF0/V8PzzXXXGMXxuhh0G/rgdHD6e6TRJzKpE6AvHU6R3VCq0QzuU/pHNe19T/cqY6H1bFc171iLlNYfiu7TMkWLbm8R1m0pBeCOi9uRV7i/J4oZU+W9zDSvU+JuLRyWfeSEXR+1DKlWnCmMmXj3mWj7oWR7vMUlq9cthFhVGYbkYji0iXDRRoIW7Cmcur9FnU/8FyWqeAWTySbfCrkndG8Kj0s8tRpArsfuVw1lKvJ7g43zh11jkLcUITsUaNGWTEmV7EfXUs1VLpe8k5KmGnotU2bNvZ79UaErp16Ck4g63uJJzeU69D9UAVXoxeEeh3PPfecbTCTibpENFwhYao9Fv3DLBKmGjbWEK96WWpAJeL8jYkEoRYuqAemOXt33XWXbYj9HlqAQlu0pGMnnHCC7XhB5cC9gzhQcB67ZLHDnKjT0KrGv/W3W+Sgl7zUr76XCNEqTm3Wrnl1GpbTw5puxP1iRx4siTp5NXUNNaE3DM0rEGqsJPKOOuqoMo+prtusWbPsAgp5ydR7ladOK1B1XzS06jxmclU7j5kfnXP//ffbe6eJwhKae935YVrCVPMmwoSpRKl6NBqGdcIzDM0RlLtbZfCHfgHIBvJ0+3GLlrR4RPviSgwkero151Sebj1/ztPt5vzKHioH7h3EgerFFDtM4kST8IUbqnVoMqPCWkjcSQSopyTvnRvnVgy2UmPZ2w+ZZ7+ZZDdP17C1Wzyi66phBv+2KBLGmuSqFbBaJOEEjxovebl0TF4xLVRwvVCt8NL8uqCh3ET3uzZD1kpKzX9Uo6d77O12vu35hiGhqPkKmQjTIDQ8ovy5xST5IllMKuJRFTbp3Dvn6dZUACFPcTJPtz+6PaTHig9eMp06/TVp7E61g2qP5JGT80DfaW6w20FGaD6vznELddQuauoG9w6KgYITdskCs7o4YKnQhP/ElTulyC+fji67bn4k5s4880z7f61AkpdUQ6QSxmrgJOL8aFhBjZm8XBpykMdLAkq91KgeMwkvfRQmRUJSC1OaNexuNtt659D8y8sqj20mwlTH1BnQii79hv7W91o5q/wD5BINz2lFuTzdWvAj5LFWhzOKpxvSY/WCz8yF119sQ1CovdL8W7VRim2qay7UqdSUDU3lUZukNkajD1OnTi2bv6uVjXIeqOOq4VfdMxdGiXsHhU5RzLGDitHq6lG24Un8OFEnNLwqwSTxpl6qW87tH8qVsNJKVIk3DX2rp6twI37UQErURfGYubko3obkcfy0tZy8HRKmmuvnPvIaOiRMtRBD4k5eWQlT7UziUM9a8/K0U4byrEnNEnZaEAKQazKZGwrp0/TEG2z7pmddoZc0FKrV/RpKdWgBlUYCtFJfHVBN1VHb5c5RO6ewG5rHLVu1f2onNY1EbSX3DgqdgvPYQeGQDY+Zerha1bzffvtZD5m8ewpDop1D1rUI99aJKN5ZNbjJdpFQg6uJ0ACVTbbnhkL6JA6DCw3PqnOoOGu67i+99JINZeFGNhRSQse104zaL92XYcOG2akbmnPs2jHuHRQqCDtI6jHLdChXwZ0VPkBBHjWkIY+bwgOol9z1vv8L+AoQF3I1NzQuVNZ+p0HD4EJCTvu2SsBJmKmN0r3S0Ku7d/L0b7311nYo1s3H1cIK//SNUrx3UBwg7CCnHjM1jGr4gkHYQfzIhqdbaBhQHSb9qzlcbueLjWtXmao1f/8dSD0Mnhh6SSMGGj6VR07ibMSIEXaOnWJvqjOre6ehXC2K0Dw6/atA+ZpfrNEHCbyK3juJRw3hAuQShB1ACVJZXpNSJBuebnH99deX23rPTexv2ucWU2vbP1RCSeI3DK4hVIVdkuBz84Q1F0+iToFnXRB8zcMTrlOqe6c4oLofEoUVvXf6jcR6AZBtEHZQsiBu8kecr302PN1CE/+D4qClunalTKrYnVoAIRIXOihMloZuZa+FEVqQ5fa29u9KoXMyuXcAlQHCDgAASiJ2pzZZ13Doueeea1fPa56dhmK10l8ePqH4p5pLp/in8rzJThu+K1aqFlwAFDoIOwAoOeLsMSxlUsXu1H6finGq2HOaM/fLL79Yoadh0169etlzNe9O8+g0xNqjRw+7rZiGbSUWNWxbyuTyuUm1T2/U4NLLli2zC2DkeZVnVt9pX/NSAmEHAACxid2ZSly0bdvWvPrqq0nP6dixo93xCCp/n95Mg0ufeuqpNli02+u3b9++5pxzzjFm21NNqYCwAyhC8DgBQCnt0+sWtWhxkoJLC4XNGjp0qD1Hwk57mo8ZM8auXpY4F/fdd5/1xrY4/zBTvW4jUwog7AAqCOIKAKBwgksr/MyWW25ZJuqE9u/VkOza778y1et2MaUAwg4AAAAKhooEl3Zz8Jo0aVLut3SexOGGX5ebUgFhBwAAAEUdXFrB8OF3EHYAkDYMQwOkD89N7oJLP/zww3bP3iVLlpT7PS3E0ErZhnW2NKUCwg4AAAAKeo/lVMGlXQzC5cuX28UUe+21V9nuIfq+ZvP/C5sSd1GOsAMAAICC3mM5SnBp7eF72GGHmbPPPtt68BTuRB7Ak08+2UwukRWxorz0BQAAAKhkFMZEK2G1wrV58+ZlH62CFS64dOPGjW1w6T/84Q/mmWeeKRdcWjz33HNWBB500EH2+H777WceffRRU0rgsQMAAICC32M5SnDphg0bWs9fKYOwK2GKac4AAAAApAZhB0ULwhQAAKA8zLEDAAAAiAl47KDC4DEDAAAoLPDYAQAAAMQEPHYAAJUInu7ihXsHxQAeOwAAAICYgLADAAAAiAkMxQIAQEnAUCqUAnjsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICcewAAACgoCEGYXTw2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEBIQdAAAAQExA2AEAAADEhIITdrfeeqvp1KmTqVu3rmnSpInp3bu3+eqrrwLP9TzP9OzZ01SpUsWMGDGi3Hfz5883hx9+uKldu7b9nSuvvNKsX7++kkoBAAAAUPkUnLB77733zIUXXmg+/PBD8/bbb5t169aZQw45xPz666+bnDts2DAr6hLZsGGDFXVr1641kydPNn//+9/N008/ba6//vpKKgUAAABA5VPdFBhjxowp97cEmTxu06ZNM926dSs7Pn36dHPXXXeZqVOnmubNm5ezGTt2rPniiy/MO++8Y5o2bWrat29vbrzxRnP11Vebv/71r6ZmzZqVVh4AAACAkvXYJbJixQr7b8OGDcuO/fbbb+aUU04xDzzwgGnWrNkmNh988IHZfffdrahzHHrooWblypXm888/r6ScAwAAAJS4x87Pxo0bTf/+/U3Xrl3NbrvtVnb8sssuM126dDFHH310oN2iRYvKiTrh/tZ3QaxZs8Z+HBKBQkPB+oiqVauaatWq2aFe5c3hjmsOn+b9OXRM34Udd7+bDJ1TvfrvtylxjmCNGjUi2QsNWet3EvOeimRlyiTv7ng6eVe+lf+oRL1PYcg26D5Fybs//7pPiXkPmkIQJe9R75/Le9j9i5r3sPsX1V5Q98rXvShph7UR6eQ9rO5VNO+lUPd0XrK2PB95p+79XvfSyfv6gPuXTt4rcv+C2vigupeJjoiFsNNcu88++8y8//77ZcdGjhxp3n33XfPpp59mfdHGkCFDNjmuYV0twBDbbrut6dChg5k5c6ZdnOHYaaedTLt27cyUKVPMDz/8UHZcQ8CtWrUyEydOND///HPZ8c6dO9vhZf12KkaPHm169eplVq1aZcaPH192XBVG8wij2IvGjRtbMTx79mzfYpTUtz9ZmaKk3b17d7P55puX5cOhMkXNuxbS9OjRwyxYsMAOwf8fyfOf+j4lt1+6dGnZffI/VK5MUfLv7pN+S55kh8qUjPL3KajuJc+7rlWyuhcl7yKs7kW1F9S98nUvStr+NiKx7kXNe1jdS5X3eNe91GVP1pZHTTus7qVK339+cN1LXf641r0oaSd756bCf+2D6l6Ueu9vI4LbvYrriEmTJpmoVPGiuC7ywEUXXWTeeOMNe4Nat25ddlwevHvvvbdc70nKV3/vv//+ZsKECXaRhASg/yLPmzfPtGnTxnzyySf2okbx2LVs2dJWzHr16uXMY9d2UHJxN/vGQ5J67LYb8FZK+7DeQ6q0v73t8KRl2uG6f1U47zreeuDotPKe2CNKlf+5Nx+W9D6lsv/mlp5Je65R8x/msUt2/cLy7u5f1LyH3b+o9Sbs/kWpt45Sq3vKe7I2Ikrek3lNouY9rO5V9LmJQ92LUvZkbXk+8u6/f1Gem2Kte8nyruPbXzsmct7XB9y/Ntf8M3Leg+5flHqfS4/dsmXLTKNGjez0NKdJisZjpwJdfPHF5vXXX7cizS/qxIABA8yf//zncsc0n27o0KHmyCOPLFPnN998s1myZElZD1ErbHUxdtlll8B0N9tsM/tJRJUzcchTFzrItRvWmww7HmUo1X9OlPNTpRGW9zDSLVMu867KHWU4pKL3KRGXVkXynmiXrbxHvX8urahlTSSxzOleg6DzqXvFnfdSqHvunELKO3Uv2lCqP+3qFbh/QeVN5xqElTXd5ymTdq/sXFOAw6/PP/+89dbJFe3mxNWvX9+6trVYImjBhNybTgQqPIoE3GmnnWbuuOMO+xvXXXed/e0g8QYAAAAQBwpuVexDDz1kXY0HHnigDWPiPsOHD4/8G1LBo0aNsv/Ke/enP/3JnH766eaGG27Iad4BAAAA8knBeewqMuUvyEaTDTeduAoAAAAQXwrOYwcAAAAAFQNhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAApS7sJk6caObPn5/0nAULFtjzAAAAAKCAhV337t3N008/nfScZ555xp4HAAAAAAUs7DzPS3nOxo0bTZUqVSqaBAAAAAAUyhy72bNnm/r16+cyCQAAAAD4/1Q3adCvX79yf48YMcJ8++23m5y3YcOGsvl1PXv2TCcJAAAAAKgMYeefU6ch1unTp9tPEPq+U6dOZujQoRXNGwAAAADkStjNmzevbH5dmzZtTP/+/c2ll166yXnVqlUzDRo0MHXq1Enn5wEAAACgsoRdq1atyv7/1FNPmQ4dOpQ7BgAAAABFIuz8nHHGGdnNCQAAAADkR9g5pkyZYj7++GOzfPlyu2giaK7doEGDMk0GAAAAAHIl7JYtW2Z69+5tJk2alDSmHcIOAAAAoMCF3eWXX27ef/99c+CBB9ph2W222cZUr56xAxAAAAAAKkiFldioUaPM3nvvbcaNG8fuEgAAAADFvPPEqlWrTLdu3RB1AAAAAMUu7Nq3bx+46wQAAAAAFJmwGzx4sBk5cqT58MMPs5sjAAAAAKjcOXaLFi0yhx9+uDnggAPMqaeeavbcc09Tr169wHNPP/30iiYDAAAAALkWdmeeeaadX6dQJ9pDVp/E+Xb6TscQdgAAAAAFLOy0pRgAAAAAFA5sKQYAAABQ6osnAAAAACAmHrv58+dHPnfbbbetaDIAAAAAkGtht91220UKTqxz1q9fX9FkAAAAACDXwk4rXYOE3YoVK8yMGTPMvHnzbCgUCUAAAAAAKGBhp/AmYSjMyV133WXuuOMO88QTT1Q0CQAAAADI9+IJefKuuOIKs+uuu5orr7wyF0kAAAAAQGWuiu3YsaN59913c5kEAAAAAFSGsJs7dy4LJwAAAAAKfY5dGBs3bjQLFy60c/DeeOMNc9BBB2U7CQAAAADIprCrWrVq0nAnWkDRoEEDu4gCAAAAAApY2HXr1i1Q2EnwSdB16tTJ9O3b1zRp0iTTPAIAAABALoXdhAkTKmoKAAAAADmAvWIBAAAAYkJWFk9MmjTJTJ8+3axcudLUq1fPtG/f3nTt2jUbPw0AAAAAlSHsJk+ebOfRzZkzp2zBhJt317ZtW/PUU0+Zzp07Z5IEAAAAAORa2H3++efmkEMOMb/99pv54x//aLp3726aN29uFi1aZMaPH2/Gjh1rDj30UPPhhx+aXXbZpaLJAAAAAECuhd0NN9xg1q5da0aPHm0OO+ywct9dffXVZsyYMeaoo46y57344osVTQYAAAAAcr14Qqtijz/++E1EnUPH9b28dwAAAABQwMJuxYoVpnXr1knP0fc6DwAAAAAKWNi1aNHCzp9LxkcffWTPAwAAAIACFnaaP6fh2EGDBpnVq1eX+05/Dx482A7DHn300dnIJwAAAADkavGEBN2oUaPMLbfcYh555BGz9957m6ZNm5rFixebjz/+2Pzwww+mTZs29jwAAAAAKGBh16hRIzsUe9VVV9lVr1od66hVq5aNb3f77bebhg0bZiuvAAAAAJCrAMVbbbWVefLJJ63H7ssvvyzbeaJdu3amRo0amfw0AAAAAORa2N18883m119/NUOGDCkTb/p39913LztH8e2uvfZaU7duXTNgwIB0kwAAAACAXC+eeOedd8z1119vh2GTeeRq1qxpz5G4I44dAAAAQAEKu2eeecY0aNDAXHTRRSnPvfDCC+38Ou0XCwAAAAAFJuwmT55sDj74YLPZZpulPFfn6NxJkyZlkj8AAAAAyIWw++6772wIk6ho54nvv/8+nSQAAAAAoDKEXdWqVc26desin69zZQMAAAAAuSct1aXtwT777LPI5+vcrbfeuiL5AgAAAIBcCrv999/fvPvuu+bbb79Nea7O0bndunVLN08AAAAAkGthp5WuGl49/vjjzdKlS0PP+/HHH80JJ5xg1q9fb84///yK5AsAAAAAchmgeM899zT9+/c3w4YNM7vssos577zzTPfu3c0222xjv1+4cKEZN26cefTRR+1esZdffrm1AQAAAIAC3HnirrvusnvB3nnnnXYXCn38eJ5nqlWrZgYOHGhuuummbOYVAAAAALIp7KpUqWJuueUWc9ZZZ9ngw4ptt2jRIvtds2bNTNeuXc2ZZ55ptt9++3R/GgAAAAAyoMKxSCTc5JHTAokvvvjCfvT/G2+8MSNRN3HiRHPkkUfaFbgSkSNGjNjknFmzZpmjjjrK1K9f39SpU8d06tTJzJ8/v+z71atX2/mA2tZsiy22MMcdd5xZvHhxhfMEAAAAUAwUXJC5X3/91eyxxx7mgQceCPx+7ty5Zr/99jPt2rUzEyZMMDNnzjSDBg2yw8OOyy67zLz55pvm5ZdfNu+9954NrHzsscdWYikAAAAAimAoNtf07NnTfsK49tprTa9evcwdd9xRdszvIVyxYoV54oknzPPPP2969Ohhj2nIeOeddzYffvih2XfffXNcAgAAAID8UHDCLhkbN240b731lrnqqqvMoYceaj799FO7bZkWavTu3dueM23aNBuSRfvUOuTd23bbbc0HH3wQKuzWrFljP46VK1faf/VbbrcN7aKhhSEbNmyweXG44wrvosUjDh3Td2HHo+zioXOqV//9Nul3/NSoUSOSvdCwtn4nMe+pSFamTPLujqeTd+Vb+Y9K1PsUhmyD7lOUvPvzr/uUmHeVqSJ5j3r/XN7D7l/UvIfdv6j2grpXvu5FSTusjUgn72F1r6J5L4W6p/OSteX5yDt17/e6l07e1wfcv3TyXpH7F9TGB9W9THRELIXdkiVLzC+//GJuu+02O7/v9ttvN2PGjLHDrOPHjzcHHHCAXchRs2ZNs+WWW5azbdq0adkijyBuvfVWM2TIkE2Ojx071tSuXdv+X+KwQ4cOdvjXP6dvp512suJxypQpNsyLo3379qZVq1Z23uDPP/9cdrxz586mSZMm9rdTMXr0aOuhXLVqlS2jQxXm8MMPj2QvGjdubLp06WJmz55tvvrqK/crKe2TlSlK2gqHs/nmm5flw6EyRc173bp1rfd1wYIFZvr06b4zkuc/9X1Kbq9Yje4++R8qV6Yo+Xf3Sb+ljoVDZUpG+fsUVPeS513XKlndi5J3EVb3otoL6l75uhclbX8bkVj3ouY9rO6lynu8617qsidry6OmHVb3UqXvPz+47qUuf1zrXpS0k71zU+G/9kF1L0q997cRwe1exXXEpEmTTFSqeFFcF3lCivf1118v88Zprpy2KOvTp48danVoIYUWUbzwwgv2eN++fct538Tee+9tK6bEYFSPXcuWLW3FrFevXs48dm0HJRd3s288JKnHbrsBb6W0D+s9pEr729sOT1qmHa77V4XzruOtB45OK++JPaJU+Z9782FJ71Mq+29u6Zm05xo1/2Eeu2TXLyzv7v5FzXvY/Ytab8LuX5R66yi1uqe8J2sjouQ9mdckat7D6l5Fn5s41L0oZU/Wlucj7/77F+W5Kda6lyzvOr79tWMi5319wP1rc80/I+c96P5Fqfe59NgtW7bMLgjVdDOnSWLhsdtqq63shVJwZD+aP/f++++XhVxZu3atWb58eTmvnVbF6rswNttsM/tJRJUzcchTFzrItRvWmww7HmUo1X9OlPNTpRGW9zDSLVMu867KHWU4pKL3KRGXVkXynmiXrbxHvX8urahlTSSxzOleg6DzqXvFnfdSqHvunELKO3Uv2lCqP+3qFbh/QeVN5xqElTXd5ymTdq8sL6aI0BCrQpv43Zri66+/LnOT77XXXvZmaAcMh86XyzOKOxYAAACgWCk4j53m0M2ZM6fs73nz5tlx64YNG9qx6SuvvNKcdNJJplu3bnZoVXPsFNpEoU+EYtspeLK2M5ONXJYXX3yxFXWsiAUAAIA4U3DCburUqeUmaUqgiTPOOMM8/fTT5phjjjEPP/ywXexwySWX2AmHr776qo1t5xg6dKh1iSowsebNaQXtgw8+mJfyAAAAAJSssDvwwANThqLo16+f/YShYMUKcBwW5BgAAAAgjhTVHDsAAAAACAdhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATEHYAAAAAMQFhBwAAABATik7YbdiwwQwaNMi0bt3abL755mb77bc3N954o/E8r+wc/f/66683zZs3t+ccfPDBZvbs2XnNNwAAAECuKTphd/vtt5uHHnrI3H///WbWrFn27zvuuMPcd999Zefo73vvvdc8/PDD5qOPPjJ16tQxhx56qFm9enVe8w4AAACQS6qbImPy5Mnm6KOPNocffrj9e7vttjMvvPCCmTJlSpm3btiwYea6666z54lnnnnGNG3a1IwYMcKcfPLJec0/AAAAQK4oOmHXpUsX8+ijj5qvv/7a7LjjjmbGjBnm/fffN3fffbf9ft68eWbRokV2+NVRv359s88++5gPPvggVNitWbPGfhwrV660/65bt85+RNWqVU21atXscPDGjRvLznXH169fX25IWMf0Xdhx97vJ0DnVq/9+m/Q7fmrUqBHJXlSpUsX+TmLeU5GsTJnk3R1PJ+/Kt/Iflaj3KQzZBt2nKHn351/3KTHvKlNF8h71/rm8h92/qHkPu39R7QV1r3zdi5J2WBuRTt7D6l5F814KdU/nJWvL85F36t7vdS+dvK8PuH/p5L0i9y+ojQ+qe5noiNgKuwEDBljR1a5du7KLc/PNN5tTTz3Vfi9RJ+Sh86O/3XdB3HrrrWbIkCGbHB87dqypXbu2/f+2225rOnToYGbOnGnmz59fds5OO+1k8yOv4Q8//FB2vH379qZVq1Zm4sSJ5ueffy473rlzZ9OkSRP726kYPXq06dWrl1m1apUZP3582XFVGOe1TGUvGjdubEWx5hp+9dVX7ldS2icrU5S0u3fvbuc5unw4VKaoea9bt67p0aOHWbBggZk+fbrvjOT5T32fktsvXbq07D75HypXpij5d/dJv6WOhUNlSkb5+xRU95LnXdcqWd2LkncRVvei2gvqXvm6FyVtfxuRWPei5j2s7qXKe7zrXuqyJ2vLo6YdVvdSpe8/P7jupS5/XOtelLSTvXNT4b/2QXUvSr33txHB7V7FdcSkSZNMVKp4UVwXBcSLL75orrzySnPnnXeaXXfd1V7I/v37W4/dGWecYYdqu3btar777ju7eMJx4oknWgU9fPjwyB67li1b2opZr169nHns2g5KLu5m33hIUo/ddgPeSmkf1ntIlfa3tx2etEw7XPevCuddx1sPHJ1W3hN7RKnyP/fmw5Lep1T239zSM2nPNWr+wzx2ya5fWN7d/Yua97D7F7XehN2/KPXWUWp1T3lP1kZEyXsyr0nUvIfVvYo+N3Goe1HKnqwtz0fe/fcvynNTrHUvWd51fPtrx0TO+/qA+9fmmn9GznvQ/YtS73PpsVu2bJlp1KiRWbFiRZkmiY3HTqJOXjs3pLr77rub//73v9bjJmHXrFkze3zx4sXlhJ3+lvINY7PNNrOfRFQ5E4c8daGDXLthvcmw41GGUv3nRDk/VRpheQ8j3TLlMu+q3FGGQyp6nxJxaVUk74l22cp71Pvn0opa1kQSy5zuNQg6n7pX3HkvhbrnzimkvFP3og2l+tOuXoH7F1TedK5BWFnTfZ4yaffK8mKKjN9++22Ti6eL45SvwqBI3I0bN66c902rY6O4YwEAAACKlaLz2B155JF2Tp3GqTUU++mnn9ph2H79+pW5PzU0e9NNN5m2bdtaoae4dy1atDC9e/fOd/YBAAAAckbRCTvFq5NQu+CCC8ySJUusYDv33HNtQGLHVVddZX799VdzzjnnmOXLl5v99tvPjBkzxtSqVSuveQcAAADIJUUn7LRSSHHq9AlDXrsbbrjBfgAAAABKhaKbYwcAAAAAwSDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGJCrIXdAw88YLbbbjtTq1Yts88++5gpU6bkO0sAAAAAOSO2wm748OHm8ssvN4MHDzaffPKJ2WOPPcyhhx5qlixZku+sAQAAAOSE2Aq7u+++25x99tmmb9++ZpdddjEPP/ywqV27tnnyySfznTUAAACAnBBLYbd27Vozbdo0c/DBB5cdq1q1qv37gw8+yGveAAAAAHJFdRNDli5dajZs2GCaNm1a7rj+/vLLLwNt1qxZYz+OFStW2H+XLVtm1q1bVyYOq1WrZn9748aNZee64+vXrzee55Ud1zF9F3Zcv7txzW9Jy/Ljjz+a6tV/v036HT81atSIZC+qVKlif8ef91S2K1euTFqmTPKu4+nmXflW/h2p7H/66aek9ymV/fLly8vuU2Leo6Tv8m/vU0LeVaZk9mF5d/cvat7D7l/UvIfdv6j2pVj3lPdkbUSUtP1tREXzHlb3KvrcxKHuRSl7srY8H3n3378oz02x1r1kebfH08j7+oD7l07eg+5flHqf2MYntnuZ6AhpEeH/LhQvhixcuFAl9yZPnlzu+JVXXuntvffegTaDBw+2Nnz48OHDhw8fPqYAPwsWLEipgWLpsdtqq62syl28eHG54/q7WbNmgTYDBw60iy0cUtJSyI0aNbLKuzJQj6Vly5ZmwYIFpl69epVqn8+0sefeFat9Mee91O2LOe+lbl/Mea8o8tT9/PPPpkWLFinPjaWwq1mzptlrr73MuHHjTO/evcuEmv6+6KKLAm0222wz+/Gz5ZZbmnygipJJZcnEPp9pY8+9K1b7Ys57qdsXc95L3b6Y814R6tevH+m8WAo7Ie/bGWecYTp27Gj23ntvM2zYMPPrr7/aVbIAAAAAcSS2wu6kk04yP/zwg7n++uvNokWLTPv27c2YMWM2WVABAAAAEBdiK+yEhl3Dhl4LEQ0FK6By4pBwZdjnM23suXfFal/MeS91+2LOe6nbF3PeK4MqWkFRKSkBAAAAQE6JZYBiAAAAgFIEYQcAAAAQExB2AAAAADEBYQcAAAAQExB2BQjrWQAAAKAiIOwKEG1htnDhQlMIaMeOfAnNfKbt0i/la59P8p0+lB6l3qHOZ/nzfe29mN17wp0UEF9++aXdIWPy5MmmSZMmZvPNNzedOnUyxx13nNl1110rJQ8bNmwwv/zyixWWu+yyS7nvVFVS7Zsb5ZxcpZ1p+mvWrDHffvut3SO4c+fOmwiNqlVT94Pc41SRPOSz/Pkue77T1x6MU6ZMMWvXrjVdunQpt3VP1PR1ntLOxt7S2fytiqYfpcxxTT+flHLZITsg7AqIdu3ame22287su+++5rfffjNLly41s2bNMuvXrze9evUyV1xxhalbt26o/bp160yNGjUqnL5ebLfddpv57LPPzBZbbFH2kjv77LOtwEyGtmurU6dOhUVGJmlnI/2xY8eaW265xcyfP9/a/fjjj6Z79+7m4osvNgcffHBKewmShg0bpmygw/KUz/Lnu+z5Tv+ll14yd9xxh33e9Nzp9/QMnnXWWZG2INTONs2aNUuZfrIX9urVq2359az7RX06YjWTTs2SJUvMF198YeuQv74VS/oVTVt2s2fPts+f7qG2n/Tv/VkZoj6f1z4b5a9o2fN97detW2emTp1qJkyYYN+7O++8s9lmm21Mo0aN7G8lS99/vdUh13n56oQFImEH+efZZ5/12rRp4/30009lx/T/9957z7v66qu9bbbZxrvkkku8devWhf7G7bff7k2YMMH74YcfvPXr1wee89tvv4Xab7fddt4pp5zi3Xfffd5DDz3kXXfddV7Xrl29li1ben/605+8b775JtRWeXvyySe9GTNmeD///HPgOStXrsxJ2tlIv3nz5t6ll17qvfjii96YMWO8hx9+2PvjH//obb755l6XLl28jz76KGn6xx57rDdo0CBru2TJksBz3L3duHFjQZU/32XPd/pbbbWVd8MNN3jjxo3zvvzyS++f//ynd/rpp3tbbLGF16pVK++NN95Imv4+++xj79FTTz3lzZ8/f5PvlebSpUtD05ed7vMuu+zi7brrrt5uu+1mn/nZs2d7UVixYkVgmlGOuXajUaNGNm1diwYNGnhnnnmmrUtRCLrmlZV+pmlfccUVNj1dc93vWrVqeYcffritS1FIvN9KZ8OGDZucF3SsEK59JuXPtOz5vvZnnnmmveZ77rmn17BhQ69atWpep06dbPsbZuPn66+/3iT9sPduZYOwKxBuueUW74gjjgj9/qWXXvKaNm3qTZ8+PfB7vRSrVKni1a5d2+vcubN31113eZ9++qlt9N1D/euvv9oXll5eiTz//PNe69at7TmOVatWeV999ZV90ary9+nTp9z3/rwpbb0E9913X/vAvvbaa96cOXO8NWvWlP1Wjx49vE8++SSraWcjfdnLdu3atWXHdM2WL1/u/etf//J69eplhcaPP/4YmP4rr7xi01ejoJe8BNrdd9/tTZ482fvll1/sOcpH27Ztvffff7+gyp/vsuc7fV0npR/UIOs56devn9exY0dv4cKFgenLXun37NnTpt+9e3fv4osvtmLQiUl1xiRS33777U3sX3jhBZv+4MGD7bV44oknvMsvv9zr0KGDzbOO+69NIur4nXXWWd7LL79s87t69epNzlH53bUI6lCq7j344IP2t959913vb3/7m7f33nvbtuSMM84IFcti7Nix3sEHH+zdeeed3sSJEzcRmbqXqntB4jPT9DNN+5lnnvG23377sms3d+5c+3+Ji+rVq3sHHHCAN2vWrNCyv/nmm94OO+zgXXjhhdZOHerE9NWR9nfWs1X2fJc/07Ln+9r//e9/t+mrM6e2Rc/YlClTvL59+3p16tTxdtxxR+/f//53aPqvvvqqzafye//992/SPkgY6pmbOXOmlw8QdgXCBx98YB9mvZSCXuB68UiwqYcX1vs455xzrMdO4k2VU58jjzzS+8c//mEfnOeee86rWbNmoP0DDzxgX/xqCMIaEQlLNT6JnH322faBmDRpkjdgwADb+5QHQi/km2++2do8+uij3mabbZb1tLORvq6LGtMw8fDhhx/a35N4DkKNy2mnneZ9/PHH3r333msFul7M3bp1884991zrSRs6dKjtkRZa+fNd9nynP2rUKG/33Xf35s2bF9jz18tl55139u65555A+8suu8w7+eSTrYdFIlOiTtddZZLYkzC76aabrLALQi8weef8yOOqTpm8kBJ9ahPCUL2RsJRAkKhUevJ4/Pe//y3r0Kn+KJ0gJAz+8pe/lDumsi9atMh6EnVtEvPn59BDD/W23HJLW9799tvPikx1RpR/N7rw1ltvWY90ttPPNG11Gvr37x/4nYSWPOYS9mGorum663ck6g855BD7/L3zzjtlHaoRI0Z4VatWzXrZ813+TMue72t/3HHHeRdccEHZ334PnZ4d/b7enWEcc8wxtp3Ru1b/qo1QOzB8+PCyUTG1LfIC5gOEXQGhF4CGYy+66CJv2rRpVuC5SqoeQf369e3LOxE9xKrUiY3A66+/bhsPVe6tt97aur1PPfXUwLS/+OILKyw1JPa///0v8JyDDjrIu/766zcRnMq3vAx+9IBJbOrha9eunRWZegiymXa20leacslrSO+zzz4LdMPrIb/yyis3Oa5z9dLXUKgf9f70YtaLV96kGjVq2PwUWvnzXfZ8py/PoHr+8nSqhx7kuTvhhBM2SUNIOMnDdv7555c7LjEoIa0XkxNeeukGPbfHH3+8HXYP49prr7VlWLx48SbfySPwhz/8wYpjeWwkZFUW3fOjjz7aClp5KSU0VYag66dOgT5hDBs2zA6VBQ0LK/299trLimd5gm+88Ubb3uhFp/qqF7c8kroG2U4/07R171SndJ0S8+QEsTzpO+20k+00JKK2WXVGnTJ51iXEVI4DDzzQCo3evXt7d9xxh+1g6B5ns+z5Ln+mZc/3tXcjZJrm4UdeO+cdV2dIHnO1o4lIuKkTpedL72Wdo99TedSpbt++ve3gKY9h6ecahF0B4F5mqlRy66phlptXQ3B6QPVgav6Neidh9hIHU6dOtX87Meh/EPTy1wsmaCjSoReEeoka9pOrWUN5zpPy+eefhwpL9TDdfIPEYSN5oVQmpS2xmu20s5W+Xup6EOVa1zC2PJ/qubnvkqWvNN2LN3EOpO6FPKZKP6iRKoTy57vsLn3V73TTVxou/cSyR01fL071+OX1UKdKQ2QSmUL3Qh2isPSFG/5MLL/+1pCR0pfYDELDcBKeGhoK8lpqbmWTJk3s853It99+a0WlyuiQMNXQlDwK8nTq5aj05fkMQufqe80x9HstHRoKlPAOGlL6/vvv7bC/xIW/LdKLTu2WvC577LGH/f2weZIVTT8bacuTre8lCoLmtGlOqua/yQOWiO6VOlrykDkkSvSM6YWv51giI9m9z/e1r2j5s1H2fF/7Tz/91Ktbt65tc4KmaOiZ1rw7905NzJuGzNV586NRMU3NkJNFolLpB9lXBgi7AiHxpaSXmxptudnladGk+u+++y7l7/iHkfRicR4IvTg0QTUZOlfDSRryVaWUe1kPiV66mo9w0kknRS6PfsvlQ14NeYyC8OdVPUylVdG0/d4e/V6U9N0100eNjdzp2267re11qVem/2soI1nPOiwvLn01QPLIFWL5C6Hs+ldzXTQ/TmnKCxUl/bAJzv6yJ0vf/xt6ucjjrReinjl5SnTN1MkK8hYmm5Tu9zzoxavhsjCUVw3HqeOmoSHNK9QLQh4ZCVN5bbS4JCzvEndOECZ26OSNVKdQowDJkNdTnh7df00cl5jWYg8NCf/1r3+1C7fCUKfRzd9LbMN0XF7LsKFAf/qqc6rj6aSv3880bQl3tXfyal511VV2KE2T8tVZkgddQ+HJcOkminoJA3l5Ja5zUfZCKH+mZVfaat/kaczk2ieWfXXE9DX9SeVW3T/xxBOtKFQnWkJa8xvl/U6Ge8YTvfz6e+DAgaHPbWVAuJM8oxALr732mvn888/NV199Zfbcc09z2mmn2aXX/lAItWrVSvo7iaFOdFu1XLtatWr230GDBtnl2DfddFOk5eKKKfbcc8/Z8Bs77LCDzc8RRxxRbjl6lKXeysedd95pw3EMGTIk8BzFblOID3/azzzzjA0B0LZt29C0w+xduspTqvSDyv7dd9+Zt956y+ajZcuWdim8wm5Ur159E/soS90feeQRs3jxYnP99dcXVPkLoeyq/1tttVW50CFKf+7cuWbbbbdNmn6ifVDIh2TpB+Vfvzdp0iT7r8IeNG/e3Oyzzz6BaUcp/4svvmjDWVxyySWbfOfCKaxYscI8/fTT5v777zfz5s2zbYDCLiiepf4999xzbdibMP5/B70sNINCpui5V746dOhgunbtan87DLUvb7zxhnniiSdsG6Qyq2xqk5SX888/35x66qmh9smuy+67724OOOCAwPRd+VU3dc+ffPJJW+eVvr6Lkr7/nuv/StuVPVna/vMnTpxohg8fbmbMmGHt/ve//9lYkqp3SvuYY45Jmm5QmYTCFSl8yT333JOTsuer/JmW3f/O+vDDD80LL7xgpk2bZo8pXbVB6V77xLJ3SZG+y6veb6NGjbIhV77//nv7t2Jqqr3Vc3fooYcGpi+C8uCOyU5hi4YOHWryAcIuzxx99NH2IW7durV9kaqiK1CxHkrFrevTp499qYXF1PELQ8UE2muvvWxDoJh4fpYvX25q165tatasGZoXpeFeCvqkQ6qYS0EPo8SDGhS9wObMmWNfoMcee6x9qPx5Cosl5LeXENALrHfv3jYGWqIQThXnSY2CPrrWFQkOmvhyjUKhlD8fZVcD+uyzz9oYdnqRqBFWrEblf+utt07LXi8CXbuePXuagw46yIrhdMi0/G6XjHRtdc1WrlxZLhjy9OnTbVw9iT0J+m7dupnddtst8LeVrkR9ouB3dUZBl/VyVGdOAjnIPlHYS9iNGzfOir1WrVqZjh072n+DcC/SMPQbasP0CUpfMQMlbBo3blx2TM/B22+/bb+TTVj6slu1apUV9UH5SJV2kI3iCH7yySf2uuh3FRRe4r4iZZc4UFxKxUKUOM9m2fNd/kzL/sMPP5SVXe8jOSTU+ZK4kthLde2dfYMGDWxa+tfv1FiTIn294xI7iup8qVOl39Fn++23t+/LIILs/agMjz32mN1YoGnTpiYv5M1XCHb4SfMIXIwyud81d0LDMVrpp0nvjz32WNLfOOqoo+xQndzZWhmpIR0N5Wl+hYb2UsXV0RCt5mAkrsj0TyRN19Y/FJUMDbdp2E1DBtdcc42dzKpVu3Khyy3uXPxhQ25h9nLha16ZK3uY/a233mpXjSWGgohS9mT2SrfQy5/vsmu4U/kdMmSIHYLSxGOtXNW8Fs1RcfPWwsoeZq85SVqM4OzDyqLJzQq5oOHKsPInK0eYvX8KQjI09K1nXAsjNA9Oq3u1ACIqfnsN22teVdBcoSionmkYN8p9SzX0HhUX2qJFixZes2bN7OIZzRUMi8EYZquPhtE0RzXKVJViL3shlb8iZdf7TM+tpkdoqoPaMK3c/89//pO2vaYWaShVbVHYHNIoZa8oetYLJW5dIgi7PKIJoBJkQSguj15wqvxhsXAyFYaaz6EVs8qDXixPP/30JrGD9ILU5N7ERiOqrV68QTHA9GJS3hMDt2qVkyYFS9yo/GFkaq/8SwBrjoeWtquMmnORuPpJL3A3kT+b9vksf77LPn78eCvAEsP6qJHVnCPNK9LcsLDwL5nau/xrHp0WrGjFqoISJ+Zfgllzbipqr45WkL0EmMSYJljfdtttdm6fOmJ6nvSvJmCLsJdtMnstuBo5cqSXDC3EUN0IWgUsUZssCHoq+yjCXuEsNHdRKwY1r0qdEK1oVP41JyxZm5XMVh1ct5ggLFitJs1rLqcWtQQt9klV9mT2uS57vsufadn13Co6g+a/aVGDwpFoXqfmommBkFb2JvuNZPb6aGWqs98QUHa1UVogpQ5ZoqDT364MevcG5SOZvZvX6+zzLfgQdnlEPXRVaAmxIFR5tFxdCydyIQw1QVU9foXKUJwrTSJV7C29KBQqRaEoVJn1EkvsTWZiKxSPT5N23QPi9/Lp5SIvjFYthQWJzNReE+L3339/uwpTE2X1f/2eer+63hJI6gUq/0E7NmRqn8/y57vsClOg+uJEqcrg96zJEyjRqhdIEJnay7upkBAKqaC4b4cddpgVSqrPqr9aXacXR1j+M7WXhyYx/Inun1buKhyRXtBO3AWRqb2Lc6n7pnheuo+JHhMFeFZczKAXXKb2EiVBC2LUZqlT0rhxY+uxDiITW5d3eXbl6Va4EMUhVF79aAW0FjMEvZwztc80//ksf6ZllwhTnUhEz67yrGdW75UwMrU//fTT7Qp0jWhoZEDXMvHdq06T4gMGCdxM7SsThF0eUa9elUXDp4oerl0l/ENbihiuHopWD+VCGGobJBckUt419YDUaGipuF5SekAVl0cvsWzaCoWTUN7V6/TjfxHIG6ReXC7s5U3585//bP+vh1ACSEMCelFJpGiIQJ4fvbRzYZ/P8ue77AsWLLAexcR66e9lq9EMW42aqb0af3nj3PnyQGkoS8clVlRvNcwTFl4oU3t52uTJDsq3hnYlkPUMOeGabXutwpQIUOdA52poS54IiXR53uVhP++886xYzYW94hIqrEyYp0irhOUNDdqeLRNbN4SvoXoFvFYZ5O3SULiuqYb0FGZIq5N1D3Nhn2n+81n+TMuuUSSJM/9uOP4OmbztGmUK2hkpG/b777+/HV2QGNW5CnEkgea261Sbqmsr4ZoL+8oEYZdnNFSlRlBbmKiBlFjS8IoCLKpnriCJuRKG6mWPHj16k+MadlWIDL2o5XWQBySbtkI9Onn7JE7UGChavj+Ol2KT6YFR+JVc2GvIWq79RPQbihiu3miy/Gdq7/KvHnYm5a+IfT7L7oSn6rjEj8SfxIB/qF8hPCTctMVWtu2FPMhBc3J0XHGn1PtPVv5M7fW9nku9CIPKpqkVeu7Dtg/MxF7xDuVhV1BX4bZuUyBkdQTUMdP3yr86a9m2F4oTqHqbGGPMCVR5nzTcGHSNM7HVddHctEceecT+raF8DS8+/vjjZZ1SCQPlPWh/4EztM81/PsufjbKrjVJ7rREdP06Y6t2l5zZsrmkm9gsXLrRebjfULUGoY5rOpJEviVbFq1T+g6YyZGpf2SDsCgQ9JHpRS9zJ66GHRD3gVJtBZyIMhevxqGHwx/8SGspScNhc2DpPnwSpenyar6V5UYqeL0+LXg6aN5RLe4ebj+L3dunhTBb7Lhv2aoiUf3k71DCkm/+K2CcOjbl7FzXvmdr7UYdDnjV5l1TnNYShHSKUb8WTy7V9WJmU/7Dt57Jhr8CzmvQtb4eGcuXx9A/Zahg1WczJTO0VkFnD5YnoRaWOgDwRyWLvZWKvayUBLM+LvB3qmCq//j095REKyn8mtg7FSFOcwESWLVtmPTHyCiVrtzKxd/nXaEZF8p+pfab5z7Ts8rDp/aThTLVZEonOq6wyqIOWrOyZ2AudG+TJ1HtEnUF5IZPd+0ztKxPCneQBLYdWzCLFz1H8MYUoUbypOnXq2O8V7qRNmzZ22XWyEB1+FCbhH//4hw2Xolv6008/2RAQl19+ufnDH/5QofAVxx9/vA3H8M477+TUVuXVtVAZFJZF8YR69OhhQzXoOuTaPhEt97/gggvMsmXLbOiJXNtrmf2bb75pl/vrvimWWzr5z9Q+8d5VtOwVsV+wYIF5//33bbgexbBS6BPFgPrTn/5kmjVrlnP7oDIMHjzYhl9QDLxc2X/99dfmoYcesnlXyAeFOlJ4BYVxUNtw2GGH2fiDubL3h65Qnv3hGxRyRm2R4ljmyl6hWJ566inzz3/+04ZsUviMunXr2t/SfTzxxBND415mYptIYhgg5V2hghR/MFf2ClGjuIUjR460+df9Syf/mdqnundRyp+Jrdpqxa6bOXOmDV2isCebbbaZrbt9+/Y1V111VU7tk907leeVV14xlWGfSxB2eUCxhVQxmzRpYl+AejkpGOvJJ59sK2XDhg1zKgydvQJjKgaWbBXrSDF3VDFdnCLF61E8LX88oUxsUzUMwj2oqciGva5NWOwxfa8XyJZbbplVe8WokviW6NF3ilGma6i4TUKCIFnso0zsne3LL79s65jipCn49I477liuzqXKe0XtHaobIvHeKf6UGuhUZGqf6t5JmOsloZdlLuz9/Oc//7HPsZ5ZiXJd4/79+1thHhZHK5v2fvQ8/fjjj7ZDqADZiouYa3vFzVMcRsVklChX/LULL7zQtmmp7mUmtkGoU6g4krfffruNq5hre8VfVHDgWbNm2XeA6m86+a+ofWIwe1dn1RFPlf9MbP1CSJ1vdcaUb3VMFZOvX79+NgZlWIy4TO2TIbF88cUXm0svvdS0b9++0u2zDcKukpEo2nfffW2vRi9kvYRVORV5XJHf9UK87777zOmnn54zYRhkLyGoYMiqmP6dALJpK9TLSvQgrl271j6wiQ1GZdlH2UEgW/Z//vOfbRBSiWH1tnX9dC33228/c9lll5k99tgjZ/ZBtop0v//++9sXgupjummnY//RRx9tsotD4r1LFvwzF/Y6X/fOibRkAaEztdeLWM/OBx98YAWxXgD6PQUnVx2SKEsmBrNlr3LoBajOgMS5/q8Oon83BNdJzKa9/5oJ/31Kdt2yZRtFlOsaJhPEFbVX8GHtAKEdFlxnSO8B3b8oAjxb9gpALFu12QqCLxHm92xLIG2++eZZs81GIO9s2ldJCMidTscwU/tKJd9jwaXGTTfdZOeEOfzLwjVnSivrFBtL82iCUFwshbHQxGxNGHf7RWoCpyZU16tXzwYODiOVveYIuE3FE+cOZWLr5uZUr17dzn+STWKIBNloxZOCHgcFjsy1vZs3mCt7XT/NAdGSeC18cfNT7r33XruSTLGotNIwLMBzJvZRbDUvM5O0k9lrpZomFqueaBJy4uRud+80P01zeeJmr03eNRdQoUg0F1Lz4zQPTQuftJLRv/AliFzYa7K32hrt06lJ94nlyaa95icpFIYf1RX/qk7ZBIXJyMQ2zN6d78+ns4+S93TsNS9NK4Q1D1arJxUpQCtXNRdU8+QUpiYZubDXfVPMQ81JTVyI4c9/JrZuEZcWU/jvjc7xz8nWvy6geCK5sA+Kc+diXkbJfzr2+QJhV8lowrcWRvgDt/ojYGvVmZZLKw5ZLoRhJvaZpq1NrbWxuxZ7aKGHXg6a8K4gmy6IsUJZ6AWqf+Nmr3hfmvTrSBR/WgihFW0u4HQ27fOZtlDYFQlACWL9jjoBWvAzaNAgKxrcaltdu6AJysVur0UtWlXorxey0+IHrXLUDgRa9RdGru0V4DUsbFI27CUKdG10zbS4JzEkhdoStYlayZz4Es3ENoq9XtLOPij+WKb2ai8UpsS/yEHtxYMPPmjjMaqzrNWuYeTaXs6AMPtMbIWC1+vaKaC4FgMGCWTVI7UfQeKs2O3zBcKuklHvT8JOPW2tIAuqDBJ2bll5toVhJvaZpt2nTx+7qkkNg3p6ikOmeHhqIHQ9FFy1d+/e9v9xtH/nnXdsdHl/0GBdP+cBk6dHq3sVQT3b9vlMW5x//vl2JwqJfokDhUXRKnB5HvRikhdUKz3Drl2x26sjIHEctLuDhIG2RFPdCev1F7u9PDyK/aeg6U6M6Njdd99tPb9CsfnUOcimbSHYq/Pn4g4GbUMl8aQYaXoXBF27fNpnmrbCoOg5kWdfz0i1atVs51jX0q2wVYdZnuAgit0+XyDs8oCEgZasSwQpiKl6vRMmTLDKX5VIEbQT9+DMljDMxD4TW70I1LNTIEs/EgRvv/22FQR6Mah3FLStTrHbC4kg7RSi/R0fffTRMlHkR8Mr2lkh2/b5TFsvAw3fJ36nOq5t6LSnsXrDunaKgRg3eyFPX8eOHcs9MxJI7joqHtYOO+ywydBWHOw1XUMCwW3FpA6g9jtV/DO9EOX10fdq9ySWsmVbCPZCxyX6/KFC9FvuWireoL7XdmGFZp+JrXYfUjgi1x4qJI/iPCrIsYt5J4EsoRy0W0ax2+cThF2e0Ni9gnzKy6OhHQ1nqKIoar+i2OdKGGZqn2najqDN2fWC1DVI3AM0TvZ6ESqArxpDDe3JE6BArrqGigMl4ZTs+mVin8+0/QTt46i4h1GvfTHaax6UhksljoK2OlNcOMW+i6O9AqUrxpjqiR8FN5YwkBiW10fekMQOQya2hWAvJIq0W0ebNm3sbyWiHQsUmy3s2ufTPhNbHdOc08T5qHp+5CRQZ0BBrcOuXbHb5xOEXSUi7472T/3kk09sT99N/tWcDR1T45hqEnQ2hGGm9hWxDXoZCv8kWAV4VGDdONr7f0M9P+3aoT1HNXynSejq9R1zzDF2iC8X9vlMO2xDcj8azlBg2zja+xffKGi4hnI0pKfth3Qt1dvX5HTt1hJne//E90S0NZm2qMqVbb7t9dxohxgFFpaXT9dKniDNS5anW1M6CtU+07QdQUO1spUwLgX7yoRwJ5XEY489ZoNqasm4lurvtNNONlTAQQcdZI466qjQeG9+FKNMMXu0pFrLyrXsXEu/586da5fZK8SAwo2EhTvJxD5baSuYpqqcQmb4y6xjb7zxhtl6660D4yAVu31QSAaF6lDcPV1PxeCqX79+aJiITOzzmXaYfSITJkyw8QddPL442ftRKJBx48aZd99913z88cc2Dp3q0VlnnWWDKqtexdne/7y466owGQcccIAZMGCAOe6443Jqmw97d66eE10vxZ7T9VPoErWjp556qo0Bp9BBhWafqW2y8CC6dkcffbQNpH7MMcfEzj6fIOwqAQXtVKwnxfo6++yzbTDH0aNH2wZy9uzZNsjsPffcY+NRJUazzpYwzMQ+22nvsssupl27djaA6eGHH2622WabWNv70f11QZyj7iqSLft8pu3s9aloHKpitdezruDBunbaIWLvvfe2IlgdIl1Lxa5MFv8xLvaKQSfxq9hr/jZD8b+0Q42epWzaFoJ9EP64lwrirk5ROuTTPtO0E4MdT5061XTu3Lkk7XNKpfoHS5R77rnHrq4J4t1337XxobQgwb+k3I/G8zXkpUmbWpGq+GmKV6ahH8130nJ0F2YiyF2ciX0u09a8Da2mc/ZBwxzFbq9Vc1pNqlhjmo+SOCnfDfF98cUX5fb7zIZ9PtNOZe+Pdyf7oLpf7Pa6JqeccoqdqqA6pGdcz/phhx1mJ6X7Q4cEDfXGzV7zMtUOam6uYh5qYUIYmdgWgr3aAk1ZqSj5tC/mvBeCfSGAsKsEFPNHDYPm1blghv44YDquGEmKg5QLYZiJfT7Tjou95h9qsYn+VbBPvRj8QWz1gtQE5aANtjOxz2fa2P8e91FxHSdOnGj/Vqfg4YcftnNT9ZsK9KtJ+GHE2V5zszQ3Lcw+E9tCsNe8QwWQ1jxE/UbYohLNUQxaiJVP+8pKW3NygwK5F7t9IYCwqwQUlV2NhCagugjVib3czp072yCHuRCGmdjnM+042GuXgnPOOcd6+xTcUrHQWrZsaXdq0EILraQdNmyYV7t27azb5zNt7D0b90rfJ6LnXsF8tQjBxX7DvnDSzoa9FpMo9p86fqovCo+hCAISiC4WnNqWsE5jPu2LOe+FYF8IIOxyjBuyUXDfbbbZxq4qUgwkrYIV2prr+eeft9s1uQj22RaGmdjnM+1it1esJw1Z+YP2qmHQPX/99ddt2BhFNJc3yAUBzZZ9PtPG/vdwOBKFEoAazndDPP4ArwobogDHYVvTlap9MeddKIi1ogW47RU1VD9w4ECvVatWNjSGRKOCuMteu1oUkn0x570Q7AsFhF0loReF9tuU0ldAyzp16lgxp22pNFdLWxPlQhhmYp/PtONg7+67224scR6SXiAazpA4UDDMbNvnM23sPRvaSEF7NT/TCQQ/GsZVO4D9/2KVd7UL6hQkbrEmYaihPe2xqi3pwrYezKd9Mee9EOwLBYRdDpG3R/uISu0rQrUi92teirw72qJJwQ/l7lf8ulSbB1dUGGbDPp9px8FejUXQy0HccMMNoVsRZcM+n2mXsr2eZ4k/7cKioN2asyMv0Pjx4+1im9dee82+JPbaay/sCyjtbNgLBax1QWuD2nYtyFEswEK0L+a8F4J9IUC4kxzSr18/M2PGDNOzZ0+zxRZb2LAnc+bMMQsXLjStWrUyQ4YMsaEzwli6dKkZPny4ufPOO+0Se8WIa9CggQ030KFDBxtu4JtvvrG/r3AqiSEoMrHPZ9pxsv/b3/5mwyTUq1fPtGjRwoaHUWgExX9TnKTHH3/cHj/iiCOyZp/PtLHflOXLl5unn37aPP/882b69Ok2REStWrXMnnvuaQYOHGj23Xdf7Asw7WzYB6GYcO3btzd9+/Y1V199dVHZF3PeC8G+skDY5QhdVok5xUFSAEt3TMLu3//+t30pLFu2zLzyyis2jl0uhGEm9vlMO272devWtfazZs0yCxYssELw8ssvTxr/KBP7fKaN/e+BSyX+/OjZ1/FffvnFBnpVnVJMNOwLJ+1c2Qed89JLL5k+ffrYgOeFYl/MeS8E+4Ii3y7DuKK4V5pgqT0Wg5CrVyEDtNomCLmAtdrOv0ehjmkTau1PqAn7GgoMmrybqX0+046zvbZkevLJJ629QqQkxkbLhn0+08b+d7RnsuZlKtaZ2yw9KEae+23sCyPtyrIPC42Ub/tiznsh2BcSCLscIeHWo0cPr1u3bnZeRlAjcNddd4XO08hUGGZin8+0sefeFbO99krWxGptjK75d5dddpmNd6jYdy7ml2JgKbD1zJkzsS+QtHNpr2C3Lnj5L7/8YoO6B3UK82lfzHkvBPtCA2GXQyZPnmyDl2qJ9LPPPmsnYrtJmeoRaCGFopvnQhhmYp/PtLHn3hWzvWLfnX/++TZgsYLcaucKvTC0eOrWW2+1K6rl+atevTr2BZR2qdsXc94Lwb7QQNjlGPXsJOBq1apl414pqOV5551newUKgDhjxoycCMNM7fOZNvbcu2K0V8/+5ptvtnGv/OgZ16pKhUnQamp5Bfr27Yt9gaRd6vbFnPdCsC9EEHaVhFy6mp8lV662o1GoBAU/zKUwzNQ+n2ljz70rRnvNwfnyyy/t/7VDSaLHT0JRnoDp06djX0Bpl7p9Mee9EOwLDVbF5gGFSqhatWpaNkuWLDGjRo0yI0aMsCt3tJL2+OOPNzvvvHPO7fOZNvbcu2K2d8+7mtlq1aqZxx57zFx66aU2XA72hZ12qdsXc94LwT6fIOxKRBhmyz6faWPPvStme3H33XebDRs2mCuvvBL7Ikq71O2LOe+FYF/ZIOwAACqJdevWWQ9ARQViKdsXc96L3b6Y814I9pUNwg4AAAAgJhSH/AQAAACAlCDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAAAgJiDsAAAAAGICwg4AAADAxIP/B0RWovhdAbAGAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, - "execution_count": 11, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -283,23 +283,23 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "0d1cf38b", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", - " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" + "{5: 0.0609, 19: 0.0442, 18: 0.0559, 22: 0.1022, 11: 0.1019, 14: 0.0457, 26: 0.0612, 12: 0.0444, 9: 0.102, 17: 0.0456, 3: 0.0034, 21: 0.0578, 10: 0.053, 20: 0.1043, 13: 0.0594, 29: 0.0029, 1: 0.0067, 4: 0.005, 27: 0.0059, 7: 0.0035, 25: 0.003, 0: 0.0019, 28: 0.0038, 15: 0.0021, 23: 0.0027, 16: 0.0021, 2: 0.0029, 6: 0.003, 30: 0.0055, 24: 0.0029, 31: 0.0022, 8: 0.002}\n" ] }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "{19: 0.0286, 21: 0.0923, 29: 0.0126, 27: 0.0266, 10: 0.0967, 4: 0.0289, 8: 0.0189, 15: 0.021, 18: 0.0965, 12: 0.0276, 30: 0.0293, 11: 0.0246, 2: 0.0126, 13: 0.0994, 20: 0.0213, 14: 0.0296, 5: 0.0457, 0: 0.0075, 7: 0.0197, 9: 0.0235, 1: 0.0279, 17: 0.0292, 22: 0.0235, 26: 0.052, 23: 0.0191, 16: 0.0201, 24: 0.0188, 6: 0.0097, 31: 0.0098, 3: 0.0091, 25: 0.0088, 28: 0.0091}\n" + "C:\\Users\\cical\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.13_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python313\\site-packages\\qiskit_ibm_runtime\\fake_provider\\local_service.py:273: UserWarning: Options {'dynamical_decoupling': {'enable': True, 'sequence_type': 'XY4'}, 'twirling': {'enable_gates': True, 'num_randomizations': 'auto'}} have no effect in local testing mode.\n", + " warnings.warn(f\"Options {options_copy} have no effect in local testing mode.\")\n" ] } ], @@ -313,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "ec6a816c", "metadata": {}, "outputs": [ @@ -321,7 +321,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Result bitstring: [1, 0, 1, 1, 0]\n" + "Result bitstring: [0, 0, 1, 0, 1]\n" ] } ], @@ -350,13 +350,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "id": "a6c223b0", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -387,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "id": "76444240", "metadata": {}, "outputs": [ @@ -395,10 +395,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "01101\n", - "01010\n", - "10010\n", - "10101\n" + "10100\n", + "10110\n", + "01001\n", + "01011\n" ] } ], @@ -409,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "id": "ca9172e6", "metadata": {}, "outputs": [], @@ -426,7 +426,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "id": "3a6a65a6", "metadata": {}, "outputs": [ @@ -434,7 +434,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "The value of the cut is: 4\n" + "The value of the cut is: 5\n" ] } ], @@ -445,7 +445,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "id": "01920bcd", "metadata": {}, "outputs": [ @@ -453,10 +453,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "The value of the cut is: 4\n", - "The value of the cut is: 4\n", - "The value of the cut is: 4\n", - "The value of the cut is: 4\n" + "The value of the cut is: 5\n", + "The value of the cut is: 5\n", + "The value of the cut is: 5\n", + "The value of the cut is: 5\n" ] } ], @@ -472,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "id": "968c5412", "metadata": {}, "outputs": [ diff --git a/tests/test_qaoa.py b/tests/test_qaoa.py index cd00f99..52e675f 100644 --- a/tests/test_qaoa.py +++ b/tests/test_qaoa.py @@ -65,7 +65,7 @@ def test_use_input(): edges = [(0, 1), (0, 2)] graph = nx.Graph(edges) qaoa_module.setup_maxcut(graph=graph) - program = qaoa_module.generate_algorithm(2, [1, 2, 3, 4]) + program = qaoa_module.generate_algorithm(2, param=[1, 2, 3, 4]) assert "gamma_0 = 1" in program assert "alpha_0 = 2" in program assert "gamma_1 = 3" in program @@ -79,8 +79,34 @@ def test_execution(): edges = [(0, 1), (0, 2)] graph = nx.Graph(edges) qaoa_module.setup_maxcut(graph=graph) - program = qaoa_module.generate_algorithm(2, [1, 2, 3, 4]) + program = qaoa_module.generate_algorithm(2, param=[1, 2, 3, 4]) module = pyqasm.loads(program) module.unroll() program_str = pyqasm.dumps(module) _ = device.run(program_str, shots=1000) + +def test_x_mixer(): + qaoa_module = qaoa.QAOA(8) + edges = [(0, 1), (0, 2)] + graph = nx.Graph(edges) + qaoa_module.setup_maxcut(graph=graph) + program = qaoa_module.generate_algorithm(2) + assert ("rx(2 * alpha) qubits[0];"+os.linesep+ + "rx(2 * alpha) qubits[1];"+os.linesep+ + "rx(2 * alpha) qubits[2];") in program + +def test_xy_mixer(): + qaoa_module = qaoa.QAOA(8) + edges = [(0, 1), (0, 2)] + graph = nx.Graph(edges) + qaoa_module.setup_maxcut(graph=graph) + qaoa_module.mixer_hamiltonian = qaoa_module.xy_mixer(graph=graph) + program = qaoa_module.generate_algorithm(2) + assert ("cnot qubits[0],qubits[1];"+os.linesep+ + "rx(-alpha) qubits[1];"+os.linesep+ + "ry(-alpha) qubits[1];"+os.linesep+ + "cnot qubits[0],qubits[1];"+os.linesep+ + "cnot qubits[0],qubits[2];"+os.linesep+ + "rx(-alpha) qubits[2];"+os.linesep+ + "ry(-alpha) qubits[2];"+os.linesep+ + "cnot qubits[0],qubits[2];") in program \ No newline at end of file From 099a202c686525ef3752466e69c5d36a9eb11d8e Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 29 Jan 2026 18:59:12 +0100 Subject: [PATCH 16/20] Fixed unit tests --- tests/test_qaoa.py | 50 ++++++++++++++++++++++++---------------------- 1 file changed, 26 insertions(+), 24 deletions(-) diff --git a/tests/test_qaoa.py b/tests/test_qaoa.py index 52e675f..93a83f0 100644 --- a/tests/test_qaoa.py +++ b/tests/test_qaoa.py @@ -26,42 +26,42 @@ def test_generate_program(): """Test that generate_program correctly returns a str object.""" - qaoa_module = qaoa.QAOA(4) + qaoa_module = qaoa.QAOA(5) edges = [(0, 1), (0, 2), (0, 4), (1, 2), (2, 3), (3, 4)] graph = nx.Graph(edges) qaoa_module.setup_maxcut(graph=graph) program = qaoa_module.generate_algorithm(2) assert isinstance(program, str) - assert qaoa_module.builder.qubits == 4 # 4 data qubits + assert qaoa_module.builder.qubits == 5 # 5 data qubits def test_unroll(): """Test that pyqasm unrolls correclty.""" - qaoa_module = qaoa.QAOA(4) + qaoa_module = qaoa.QAOA(5, use_input=False) edges = [(0, 1), (0, 2), (0, 4), (1, 2), (2, 3), (3, 4)] graph = nx.Graph(edges) qaoa_module.setup_maxcut(graph=graph) - program = qaoa_module.generate_algorithm(2) + program = qaoa_module.generate_algorithm(2, param=[1, 2, 3, 4]) module = pyqasm.loads(program) module.unroll() def test_correct_hamiltonian_from_graph(): """Test that the cost Hamiltonian for maxcut is generated correctly.""" - qaoa_module = qaoa.QAOA(4) + qaoa_module = qaoa.QAOA(5) edges = [(0, 1), (0, 2)] graph = nx.Graph(edges) qaoa_module.setup_maxcut(graph=graph) program = qaoa_module.generate_algorithm(2) - assert ("cnot qubits[0],qubits[1];"+os.linesep+ - "rz(-2 * gamma) qubits[1];"+os.linesep+ - "cnot qubits[0],qubits[1];"+os.linesep+ - "cnot qubits[0],qubits[2];"+os.linesep+ - "rz(-2 * gamma) qubits[2];"+os.linesep+ - "cnot qubits[0],qubits[2];") in program + assert ("\tcnot qubits[0],qubits[1];\n"+ + "\trz(-2 * gamma) qubits[1];\n"+ + "\tcnot qubits[0],qubits[1];\n"+ + "\tcnot qubits[0],qubits[2];\n"+ + "\trz(-2 * gamma) qubits[2];\n"+ + "\tcnot qubits[0],qubits[2];") in program def test_use_input(): """Test the use_input parameter.""" - qaoa_module = qaoa.QAOA(4, use_input=False) + qaoa_module = qaoa.QAOA(5, use_input=False) edges = [(0, 1), (0, 2)] graph = nx.Graph(edges) qaoa_module.setup_maxcut(graph=graph) @@ -75,7 +75,7 @@ def test_use_input(): def test_execution(): """Test correct execution in local device.""" device = LocalDevice() - qaoa_module = qaoa.QAOA(4, use_input=False) + qaoa_module = qaoa.QAOA(5, use_input=False) edges = [(0, 1), (0, 2)] graph = nx.Graph(edges) qaoa_module.setup_maxcut(graph=graph) @@ -86,27 +86,29 @@ def test_execution(): _ = device.run(program_str, shots=1000) def test_x_mixer(): + """Test that the x mixer Hamiltonian is generated correctly.""" qaoa_module = qaoa.QAOA(8) edges = [(0, 1), (0, 2)] graph = nx.Graph(edges) qaoa_module.setup_maxcut(graph=graph) program = qaoa_module.generate_algorithm(2) - assert ("rx(2 * alpha) qubits[0];"+os.linesep+ - "rx(2 * alpha) qubits[1];"+os.linesep+ - "rx(2 * alpha) qubits[2];") in program + assert ("\trx(2 * alpha) qubits[0];\n"+ + "\trx(2 * alpha) qubits[1];\n"+ + "\trx(2 * alpha) qubits[2];") in program def test_xy_mixer(): + """Test that the x mixer Hamiltonian is generated correctly.""" qaoa_module = qaoa.QAOA(8) edges = [(0, 1), (0, 2)] graph = nx.Graph(edges) qaoa_module.setup_maxcut(graph=graph) qaoa_module.mixer_hamiltonian = qaoa_module.xy_mixer(graph=graph) program = qaoa_module.generate_algorithm(2) - assert ("cnot qubits[0],qubits[1];"+os.linesep+ - "rx(-alpha) qubits[1];"+os.linesep+ - "ry(-alpha) qubits[1];"+os.linesep+ - "cnot qubits[0],qubits[1];"+os.linesep+ - "cnot qubits[0],qubits[2];"+os.linesep+ - "rx(-alpha) qubits[2];"+os.linesep+ - "ry(-alpha) qubits[2];"+os.linesep+ - "cnot qubits[0],qubits[2];") in program \ No newline at end of file + assert ("\tcnot qubits[0],qubits[1];\n" + "\trx(-alpha) qubits[1];\n"+ + "\try(-alpha) qubits[1];\n"+ + "\tcnot qubits[0],qubits[1];\n"+ + "\tcnot qubits[0],qubits[2];\n"+ + "\trx(-alpha) qubits[2];\n"+ + "\try(-alpha) qubits[2];\n"+ + "\tcnot qubits[0],qubits[2];") in program \ No newline at end of file From fe87a96e0f9510c360109ab0a79c806bc0b91f3a Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 29 Jan 2026 19:02:52 +0100 Subject: [PATCH 17/20] Fixed format check for unit tests --- tests/test_qaoa.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/test_qaoa.py b/tests/test_qaoa.py index 93a83f0..7246779 100644 --- a/tests/test_qaoa.py +++ b/tests/test_qaoa.py @@ -14,8 +14,6 @@ """ Tests for QAOA implementation. """ -import os - import networkx as nx import pyqasm @@ -111,4 +109,4 @@ def test_xy_mixer(): "\tcnot qubits[0],qubits[2];\n"+ "\trx(-alpha) qubits[2];\n"+ "\try(-alpha) qubits[2];\n"+ - "\tcnot qubits[0],qubits[2];") in program \ No newline at end of file + "\tcnot qubits[0],qubits[2];") in program From fbd249972b112613b8b6fc70264da74264d00132 Mon Sep 17 00:00:00 2001 From: Lorenzo Cicala Date: Thu, 29 Jan 2026 19:27:44 +0100 Subject: [PATCH 18/20] Enhanced code coverage --- tests/test_qaoa.py | 68 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/tests/test_qaoa.py b/tests/test_qaoa.py index 7246779..e46a790 100644 --- a/tests/test_qaoa.py +++ b/tests/test_qaoa.py @@ -110,3 +110,71 @@ def test_xy_mixer(): "\trx(-alpha) qubits[2];\n"+ "\try(-alpha) qubits[2];\n"+ "\tcnot qubits[0],qubits[2];") in program + +def test_min_vertex_cover(): + """Test that the cost Hamiltonian for min vertex cover is generated correctly.""" + qaoa_module = qaoa.QAOA(5) + edges = [(0, 1), (0, 2)] + graph = nx.Graph(edges) + qaoa_module.cost_hamiltonian = qaoa_module.min_vertex_cover_cost(graph=graph) + program = qaoa_module.generate_algorithm(2) + assert ("cnot qubits[0],qubits[1];\n"+ + "\trz(3 * 2 * gamma) qubits[1];\n"+ + "\tcnot qubits[0],qubits[1];\n"+ + "\trz(3 * 2 * gamma) qubits[0];\n"+ + "\trz(3 * 2 * gamma) qubits[1];\n"+ + "\tcnot qubits[0],qubits[2];\n"+ + "\trz(3 * 2 * gamma) qubits[2];\n"+ + "\tcnot qubits[0],qubits[2];\n"+ + "\trz(3 * 2 * gamma) qubits[0];\n"+ + "\trz(3 * 2 * gamma) qubits[2];\n"+ + "\trz(-2 * gamma) qubits[0];\n"+ + "\trz(-2 * gamma) qubits[1];\n"+ + "\trz(-2 * gamma) qubits[2];") in program + +def test_max_clique(): + """Test that the cost Hamiltonian for max clique is generated correctly.""" + qaoa_module = qaoa.QAOA(5) + edges = [(0, 1), (0, 2)] + graph = nx.Graph(edges) + qaoa_module.cost_hamiltonian = qaoa_module.max_clique_cost(graph=graph) + program = qaoa_module.generate_algorithm(2) + assert ("\tcnot qubits[1],qubits[2];\n"+ + "\trz(3 * 2 * gamma) qubits[2];\n"+ + "\tcnot qubits[1],qubits[2];\n"+ + "\trz(-3 * 2 * gamma) qubits[1];\n"+ + "\trz(-3 * 2 * gamma) qubits[2];\n"+ + "\trz(2 * gamma) qubits[0];\n"+ + "\trz(2 * gamma) qubits[1];\n"+ + "\trz(2 * gamma) qubits[2];") in program + +def test_validation(): + """Test the validation inside Hamiltonian generation""" + qaoa_module = qaoa.QAOA(1) + edges = [(0, 1), (0, 2)] + graph = nx.Graph(edges) + try: + qaoa_module.x_mixer(graph=graph) + assert False + except ValueError: + assert True + try: + qaoa_module.xy_mixer(graph=graph) + assert False + except ValueError: + assert True + try: + qaoa_module.qaoa_maxcut(graph=graph) + assert False + except ValueError: + assert True + try: + qaoa_module.min_vertex_cover_cost(graph=graph) + assert False + except ValueError: + assert True + try: + qaoa_module.max_clique_cost(graph=graph) + assert False + except ValueError: + assert True From 51e31ad98032513dbab3595fc54d653d400bbb4e Mon Sep 17 00:00:00 2001 From: TheGupta2012 Date: Mon, 2 Feb 2026 11:16:55 +0530 Subject: [PATCH 19/20] add: nx dependency in main package --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 946e159..f10d67c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,4 +3,4 @@ pyqasm>=0.5.0,<1.1.0 sympy>=1.14.0 scipy>=1.16.0 numpy>=2.3.1 -types-networkx \ No newline at end of file +networkx>=3.1.0 \ No newline at end of file From 5ef3568d942d20993f507755b39f346ade80daa8 Mon Sep 17 00:00:00 2001 From: TheGupta2012 Date: Mon, 2 Feb 2026 11:24:58 +0530 Subject: [PATCH 20/20] add: all type stubs in the mypy tox cmd --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index bccbd44..dc74e18 100644 --- a/tox.ini +++ b/tox.ini @@ -49,7 +49,7 @@ envdir = .tox/linters skip_install = true deps = mypy commands = - mypy qbraid_algorithms + mypy --install-types --non-interactive qbraid_algorithms [testenv:headers] envdir = .tox/linters