{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running on the Aer simulator \n",
    "============================="
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this two-part tutorial, we demonstrate the process of executing a simple quantum chemical computation using 'shot' based sampling on noisy quantum emulators and hardware.\n",
    "\n",
    "Since this tutorial is focused on practical quantum computation, we will perform a straightforward calculation: the single-point evaluation of the total energy for the H2 molecule using the Unitary Coupled Cluster (UCC) ansatz, without optimization or parameter variance. \n",
    "\n",
    "In this first part of the tutorial, we take advantage of [pytket-qiskit](https://docs.quantinuum.com/tket/extensions/pytket-qiskit/) to run circuits on the AER simulator locally. For the second part we examine the use of a [Quantinuum hardware emulator](InQ_htut_qsys_H2.ipynb). The use of IBM hardware (and emulator) is also possible, but note that this requires an IBM Quantum account and the appropriate credentials to run on a machine with at least four qubits for a brief duration. Users with access to Quantinuum Nexus can add their [IBMQ credentials](https://docs.quantinuum.com/nexus/user_guide/credentials.html) and access IBMQ backends [via Nexus](https://docs.quantinuum.com/nexus/trainings/notebooks/basics/ibmq_examples.html).\n",
    "\n",
    "The outlined steps are as follows:\n",
    "\n",
    "Notebook 1\n",
    "\n",
    "- Define the system \n",
    "- Perform noise-free simulation (AerStateBackend)\n",
    "- Perform stochastic simulation (AerBackend)\n",
    "- Perform simulation with simple noisy simulation of the quantum computation (AerBackend + custom noise profile)\n",
    "\n",
    "Notebook 2\n",
    "\n",
    "- Redefine the system\n",
    "- Perform computation with emulated hardware noise (QuantinuumBackend emulator + machine noise profile)\n",
    "- Demonstrate error mitigation methods on emulated hardware (PMSV)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 0. System preparation\n",
    "To begin, we use the `express` module to load in the converged mean-field (Hartree-Fock) spin-orbitals, potential, and Hamiltonian from a calculation of H2 using the STO-3G basis set. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from inquanto.express import load_h5\n",
    "\n",
    "h2 = load_h5(\"h2_sto3g.h5\", as_tuple=True)\n",
    "hamiltonian = h2.hamiltonian_operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we prepare the Fermionic space and define the Fermionic state. \n",
    "\n",
    "The space here is defined with 4 spin-orbitals (which matches the full H2 STO-3G space) and we use the D2h point group.\n",
    "\n",
    "This point group is the most practical high symmetry group to approximate the $\\text{D} \\infty \\text{h}$ group. We also explicitly define the orbital symmetries.\n",
    "\n",
    "The state is then set by the ground state occupations [1,1,0,0] and the Hamiltonian encoded from the Hartree-Fock \n",
    "integrals. \n",
    "\n",
    "A space of excited states is then created using the UCCSD ansatz, which is then mapped to a quantum circuit using Jordan-Wigner (JW) encoding. InQuanto uses an efficient ansatz circuit compilation approach here, provided by the `FermionSpaceStateExpJWChemicallyAware` class, to reduce the computational resources required.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from inquanto.spaces import FermionSpace\n",
    "from inquanto.states import FermionState\n",
    "from inquanto.symmetry import PointGroup\n",
    "from inquanto.ansatzes import FermionSpaceStateExpChemicallyAware\n",
    "\n",
    "space = FermionSpace(\n",
    "    4, point_group=PointGroup(\"D2h\"), orb_irreps=[\"Ag\", \"Ag\", \"B1u\", \"B1u\"]\n",
    ")\n",
    "\n",
    "state = FermionState([1, 1, 0, 0])\n",
    "qubit_hamiltonian = hamiltonian.qubit_encode()\n",
    "\n",
    "exponents = space.construct_single_ucc_operators(state)\n",
    "## the above adds nothing due to the symmetry of the system\n",
    "exponents += space.construct_double_ucc_operators(state)\n",
    "ansatz = FermionSpaceStateExpChemicallyAware(exponents, state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ansatz circuit structure is well-defined, but the guess for the wave function parameters (weights of the exponentiated determinants / angles of rotation gates) has not been established. These parameters are initialized with a single value denoted as 'p', detailed below. \n",
    "\n",
    "Once the parameters are defined, the `Computable` class is employed to specify the quantity of interest: we seek to evaluate the expectation value of the Hamiltonian for a given parameter value $\\theta$, $E=\\langle \\Psi(\\theta)|\\hat{H} |\\Psi(\\theta)\\rangle$.\n",
    "\n",
    "For demonstration purposes, we fix the random seed on the initialization of the parameters using `seed=6`, which should set a parameter value of 0.499675. Alternatively, this parameter can be set using `p = ansatz.state_symbols.construct_from_array([0.4996755931358105])`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{d0: 0.4996755931358105}\n"
     ]
    }
   ],
   "source": [
    "# p = ansatz.state_symbols.construct_random(seed=6)\n",
    "p = ansatz.state_symbols.construct_from_array([0.4996755931358105])\n",
    "print(p)\n",
    "\n",
    "from inquanto.computables import ExpectationValue\n",
    "\n",
    "expectation0 = ExpectationValue(ansatz, hamiltonian.qubit_encode())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the circuit and parameters now established, it becomes possible to display and analyze the circuit. This particular circuit comprises 4 qubits and consists of 31 gates. Notably, among these gates, the multi-qubit CNOT gates, are expected to contribute the most noise. In this circuit, there are a total of 4 CNOT gates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "<div style=\"resize: vertical; overflow: auto; height: 400px; display: block\">\n",
       "    <iframe srcdoc=\"\n",
       "&lt;!DOCTYPE html&gt;\n",
       "&lt;html lang=&#34;en&#34;&gt;\n",
       "&lt;head&gt;\n",
       "    &lt;meta charset=&#34;UTF-8&#34;&gt;\n",
       "    &lt;!-- Download Vue 3--&gt;\n",
       "&lt;script type=&#34;application/javascript&#34; src=&#34;https://unpkg.com/vue@3&#34;&gt;&lt;/script&gt;\n",
       "&lt;!-- Download Circuit Renderer with styles --&gt;\n",
       "&lt;script type=&#34;application/javascript&#34; src=&#34;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.js&#34;&gt;&lt;/script&gt;\n",
       "&lt;link rel=&#34;stylesheet&#34; href=&#34;https://unpkg.com/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.css&#34;&gt;\n",
       "\n",
       "&lt;!-- Fallback to jsdelivr in case UNPKG is down --&gt;\n",
       "&lt;script type=&#34;application/javascript&#34;&gt;\n",
       "    if (typeof Vue === &#34;undefined&#34;) {\n",
       "        const loadVue = new Promise(resolve =&gt; {\n",
       "            const vueFallback = document.createElement(&#34;script&#34;)\n",
       "            vueFallback.type = &#34;application/javascript&#34;\n",
       "            vueFallback.src = &#34;https://cdn.jsdelivr.net/npm/vue@3&#34;\n",
       "            vueFallback.async = false\n",
       "            vueFallback.defer = false\n",
       "            vueFallback.addEventListener(&#39;load&#39;, () =&gt; {\n",
       "              console.log(&#34;vue loaded&#34;);\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(vueFallback)\n",
       "        })\n",
       "        const loadRenderer = new Promise(resolve =&gt; {\n",
       "            const rendererFallback = document.createElement(&#34;script&#34;)\n",
       "            rendererFallback.type = &#34;application/javascript&#34;\n",
       "            rendererFallback.src = &#34;https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.umd.min.js&#34;\n",
       "            rendererFallback.async = false\n",
       "            rendererFallback.defer = false\n",
       "            rendererFallback.addEventListener(&#39;load&#39;, () =&gt; {\n",
       "              console.log(&#34;renderer loaded&#34;);\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(rendererFallback)\n",
       "        })\n",
       "        const loadCSS = new Promise(resolve =&gt; {\n",
       "            const cssFallback = document.createElement(&#34;link&#34;)\n",
       "            cssFallback.rel = &#34;stylesheet&#34;\n",
       "            cssFallback.href = &#34;https://cdn.jsdelivr.net/npm/pytket-circuit-renderer@0.10/dist/pytket-circuit-renderer.min.css&#34;\n",
       "            cssFallback.addEventListener(&#39;load&#39;, () =&gt; {\n",
       "              console.log(&#34;css loaded&#34;);\n",
       "              resolve(true)\n",
       "            })\n",
       "            document.head.appendChild(cssFallback)\n",
       "        })\n",
       "        window[&#39;_circuitRendererLoading&#39;] = Promise.all([loadVue, loadRenderer, loadCSS])\n",
       "    } else {\n",
       "        window[&#39;_circuitRendererLoading&#39;] = new Promise(resolve =&gt; resolve(&#34;already loaded&#34;))\n",
       "    }\n",
       "&lt;/script&gt;\n",
       "&lt;/head&gt;\n",
       "&lt;body&gt;\n",
       "\n",
       "\n",
       "    &lt;div id=&#34;circuit-display-vue-container-eb9ccca0-96d0-4a19-8be3-d24db11924ec&#34; class=&#34;pytket-circuit-display-container&#34;&gt;\n",
       "        &lt;div style=&#34;display: none&#34;&gt;\n",
       "            &lt;div id=&#34;circuit-json-to-display&#34;&gt;{&#34;bits&#34;: [], &#34;commands&#34;: [{&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;X&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [1]]], &#34;op&#34;: {&#34;type&#34;: &#34;S&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;V&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [3]]], &#34;op&#34;: {&#34;type&#34;: &#34;S&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;Sdg&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [1]]], &#34;op&#34;: {&#34;type&#34;: &#34;H&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [3]]], &#34;op&#34;: {&#34;type&#34;: &#34;H&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;Vdg&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [1]]], &#34;op&#34;: {&#34;type&#34;: &#34;S&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [3]]], &#34;op&#34;: {&#34;type&#34;: &#34;S&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]], [&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;CX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [1]]], &#34;op&#34;: {&#34;type&#34;: &#34;V&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [3]]], &#34;op&#34;: {&#34;type&#34;: &#34;V&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;params&#34;: [&#34;0.499675593135811/pi&#34;], &#34;type&#34;: &#34;Rz&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;H&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;params&#34;: [&#34;-0.499675593135811/pi&#34;], &#34;type&#34;: &#34;Rz&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;H&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]], [&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;CX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;V&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;Vdg&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;S&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;S&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;S&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;H&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;H&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;S&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;S&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]]], &#34;op&#34;: {&#34;type&#34;: &#34;V&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]]], &#34;op&#34;: {&#34;type&#34;: &#34;V&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [2]], [&#34;q&#34;, [3]]], &#34;op&#34;: {&#34;type&#34;: &#34;CX&#34;}}, {&#34;args&#34;: [[&#34;q&#34;, [0]], [&#34;q&#34;, [1]]], &#34;op&#34;: {&#34;type&#34;: &#34;CX&#34;}}], &#34;created_qubits&#34;: [], &#34;discarded_qubits&#34;: [], &#34;implicit_permutation&#34;: [[[&#34;q&#34;, [0]], [&#34;q&#34;, [0]]], [[&#34;q&#34;, [1]], [&#34;q&#34;, [1]]], [[&#34;q&#34;, [2]], [&#34;q&#34;, [2]]], [[&#34;q&#34;, [3]], [&#34;q&#34;, [3]]]], &#34;phase&#34;: &#34;0.0&#34;, &#34;qubits&#34;: [[&#34;q&#34;, [0]], [&#34;q&#34;, [1]], [&#34;q&#34;, [2]], [&#34;q&#34;, [3]]]}&lt;/div&gt;\n",
       "        &lt;/div&gt;\n",
       "        &lt;circuit-display-container\n",
       "                :circuit-element-str=&#34;&#39;#circuit-json-to-display&#39;&#34;\n",
       "                :init-render-options=&#34;initRenderOptions&#34;\n",
       "                view-format=&#34;None&#34;\n",
       "        &gt;&lt;/circuit-display-container&gt;\n",
       "    &lt;/div&gt;\n",
       "    &lt;script type=&#34;application/javascript&#34;&gt;\n",
       "      (async function () {\n",
       "        await window[&#39;_circuitRendererLoading&#39;]\n",
       "\n",
       "        const circuitRendererUid = &#34;eb9ccca0-96d0-4a19-8be3-d24db11924ec&#34;;\n",
       "        const displayOptions = JSON.parse(&#39;{}&#39;);\n",
       "\n",
       "        // Script to initialise the circuit renderer app\n",
       "\n",
       "const { createApp } = Vue;\n",
       "const circuitDisplayContainer = window[&#34;pytket-circuit-renderer&#34;].default;\n",
       "// Init variables to be shared between circuit display instances\n",
       "if (typeof window.pytketCircuitDisplays === &#34;undefined&#34;) {\n",
       "    window.pytketCircuitDisplays = {};\n",
       "}\n",
       "// Create the root Vue component\n",
       "const app = createApp({\n",
       "    delimiters: [&#39;[[#&#39;, &#39;#]]&#39;],\n",
       "    components: { circuitDisplayContainer },\n",
       "    data () {\n",
       "      return {\n",
       "        initRenderOptions: displayOptions,\n",
       "      }\n",
       "    }\n",
       "})\n",
       "app.config.unwrapInjectedRef = true;\n",
       "app.mount(&#34;#circuit-display-vue-container-&#34;+circuitRendererUid);\n",
       "window.pytketCircuitDisplays[circuitRendererUid] = app;\n",
       "      })()\n",
       "    &lt;/script&gt;\n",
       "\n",
       "\n",
       "\n",
       "&lt;/body&gt;\n",
       "&lt;/html&gt;\n",
       "\"\n",
       "            width=\"100%\" height=\"100%\"\n",
       "            style=\"border: none; outline: none; overflow: auto\"></iframe>\n",
       "</div>\n",
       "\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "2-qubit GATES:  4\n",
      "<tket::Circuit, qubits=4, gates=31>\n"
     ]
    }
   ],
   "source": [
    "from pytket.circuit.display import render_circuit_jupyter\n",
    "\n",
    "render_circuit_jupyter(ansatz.get_circuit(p))\n",
    "\n",
    "from pytket import Circuit, OpType\n",
    "\n",
    "print(\"\\n2-qubit GATES:  {}\".format(ansatz.circuit_resources()['gates_2q']))\n",
    "\n",
    "print(ansatz.state_circuit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now ready to think about how we run this circuit. \n",
    "\n",
    "To better comprehend the impact of noise on computing this circuit, in the following cell, we establish a set of \"shots\" to scan over, along with a random seed number and various other parameters. To illustrate the varying degrees of stochasticity and quantum noise across different backends, we will present convergence plots. These plots will demonstrate how the average energy converges towards the expectation value with increasing sampling. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.rcParams[\"figure.figsize\"] = (12, 4)\n",
    "\n",
    "set_shots = [10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000]\n",
    "# N_shots * N_measured_terms is the total number of shots\n",
    "# n_shots arg is number of samples per commuting set formed from the Hamiltonian terms\n",
    "set_seed = 1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Noiseless Statevector simulation\n",
    "\n",
    "The evaluation of a quantum measurement can be carried out directly by state vector methods, which perform the linear algebra of gate operations directly to an explicit $2^N$ dimensional representation of the quantum state. This method returns the computable of the system directly without considering the stochasticity of the quantum measurements at the end of the circuit. Note that statevector backends do not take number of shots as an arguemnt. The needed resultant probability amplitudes are returned directly rather than averaged over sampling the computational basis eigenvalues. For the given system parameter ($\\theta =  0.499676$), we expect an energy of $-0.587646$ Ha.\n",
    "\n",
    "In general, to define where the computation is performed we set the backend, in this case `backend = AerStateBackend()` ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statevector energy is -0.5876463677225002Ha\n"
     ]
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from pytket.extensions.qiskit import AerStateBackend\n",
    "from inquanto.computables import ExpectationValue\n",
    "from inquanto.protocols import BackendStatevectorProtocol\n",
    "\n",
    "backend = AerStateBackend()\n",
    "\n",
    "expval_expression = ExpectationValue(ansatz, hamiltonian.qubit_encode())\n",
    "protocol = BackendStatevectorProtocol(backend)\n",
    "evaluator = protocol.get_evaluator(p)\n",
    "statevector_energy = expval_expression.evaluate(evaluator=evaluator)\n",
    "\n",
    "shotless_energies = [statevector_energy,] * len(\n",
    "    set_shots\n",
    ")  # for plotting later\n",
    "\n",
    "print(\"Statevector energy is \" + str(np.real(statevector_energy)) + \"Ha\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Noiseless simulation\n",
    "\n",
    "Subsequently, we proceed to simulate \"shots\", representing the runs of the quantum computer, using the `AerBackend`. This simulation, devoid of quantum noise such as decoherence during processing, does incorporate the stochastic nature of measuring the system, culminating in a probabilistic collapse into a computational basis state upon simulation completion. Each individual shot yields a measurement outcome of 0 or 1 on each qubit. By accumulating numerous shots, one can estimate the expectation value of each Pauli string within the Hamiltonian. Higher shot counts lead to increased precision in these expectation values, ultimately resulting in enhanced precision of the overall Hamiltonian expectation value.\n",
    "\n",
    "We generate a plot to illustrate the convergence of energy concerning the number of shots. This plot reveals that with approximately 1000 shots, the averaging of the system reaches a sufficient level, closely resembling the results obtained from the AerStateBackend (within a margin of 0.01 Ha).\n",
    "\n",
    "We recommend changing the seed value in `protocol.run()` to examine different convergence regimes. Consider what number of shots is required for consistent precision. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pytket.extensions.qiskit import AerBackend\n",
    "from inquanto.protocols import PauliAveraging\n",
    "from pytket.partition import PauliPartitionStrat\n",
    "\n",
    "backend = []\n",
    "backend = AerBackend()\n",
    "\n",
    "protocol_template = PauliAveraging(\n",
    "    backend,\n",
    "    shots_per_circuit=10,\n",
    "    pauli_partition_strategy=PauliPartitionStrat.CommutingSets,\n",
    ")\n",
    "protocol_template.build(p, ansatz, hamiltonian.qubit_encode()).compile_circuits()\n",
    "\n",
    "protocol_pickle = protocol_template.dumps()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "noiseless_energies = []\n",
    "for i in set_shots:\n",
    "    protocol = PauliAveraging.loads(protocol_pickle, backend)\n",
    "    protocol.shots_per_circuit = i\n",
    "    protocol.run(seed=set_seed)\n",
    "    aer_expectation = protocol.evaluate_expectation_value(\n",
    "        ansatz, hamiltonian.qubit_encode()\n",
    "    )\n",
    "    noiseless_energies.append(aer_expectation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.5848319000310381\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(set_shots, shotless_energies, label=\"AerStateBackend\", color=\"black\", ls=\"--\")\n",
    "plt.plot(set_shots, noiseless_energies, label=\"AerBackend\")\n",
    "plt.xscale(\"log\")\n",
    "plt.ylim([-1, 0])\n",
    "plt.xlabel(\"Number of shots\")\n",
    "plt.ylabel(\"Energy (Ha)\")\n",
    "plt.title(\n",
    "    \"Convergence behavior of the expectation value for \"\n",
    "    + r\"$\\theta=$%.5f\" % list(p.values())[0]\n",
    ")\n",
    "plt.legend()\n",
    "\n",
    "print(noiseless_energies[-1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Simple quantum noise model\n",
    "\n",
    "Having demonstrated the stochastic nature of quantum measurement, we are ready to consider quantum noise. \n",
    "\n",
    "To do this, first we will use a simple quantum noise model. The noise in quantum circuits can manifest in many ways. A simple noise model is constructed by adding depolarising error to CNOT gates. This can be a reasonable first approximation to multi-qubit operations which generally cause the most quantum noise. \n",
    "\n",
    "One part of the InQuanto protocol workflow that greatly influences the number and type of gates present in the circuits to be measured, is the compilation step. This is taken care of by the `.compile_circuits()` method, applied after the protocol is built (above). A detailed outline of compilation and how one can optimise this process to reduce the resources required to run a circuit can be found in the [circuit compilation tutorial](https://docs.quantinuum.com/inquanto/tutorials/InQ_htut_circ_comp.html).\n",
    "\n",
    "There are many other types of quantum noise that can be added, some of which are detailed in the [Qiskit documentation](https://qiskit.org/documentation/aer/stubs/qiskit_aer.noise.NoiseModel.html). One other simple example is the readout error, which represents incorrectly measuring the qubit state at the end of the circuit.\n",
    "\n",
    "We recommend modifying the `cnot_error_rate` parameter and also the seed number in `protocol.run(seed=set_seed)`.  In particular, consider whether for larger CNOT error rate (>0.01) the system does or does not practically converge to the AerStateBackend result.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "## In this cell we define the noise model\n",
    "from qiskit_aer.noise import NoiseModel  # , ReadoutError\n",
    "import qiskit_aer.noise as noise\n",
    "\n",
    "\n",
    "cnot_error_rate = 0.01\n",
    "noise_model = NoiseModel()\n",
    "error_1 = noise.depolarizing_error(cnot_error_rate, 2)\n",
    "\n",
    "n_qubits = 4\n",
    "for qubit in range(n_qubits):\n",
    "    for qubit2 in (x for x in range(n_qubits) if x != qubit):\n",
    "        noise_model.add_quantum_error(error_1, [\"cx\"], [qubit, qubit2])\n",
    "\n",
    "print(noise_model.is_ideal())  ## this reports false if there is noise in the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x17b8c93d0>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/QAAAGQCAYAAAAA3ysHAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAfBRJREFUeJzt3Qd8U+X6wPGne9IWKFBK2SB7DwFBVFAERcGFk+HeF+dfrldx494DvSrDvTfiwM1FNsgWkD1LoS1toTP/z/OmCUmbtEmbNk37+957THJyxnuSc0qe87wjyGKxWAQAAAAAAASUYH8XAAAAAAAAeI+AHgAAAACAAERADwAAAABAACKgBwAAAAAgABHQAwAAAAAQgAjoAQAAAAAIQAT0AAAAAAAEIAJ6AAAAAAACEAE9AAAAAAABiIAeAAAAAIAAREAPAAAAAEAAIqAHADi57777JCgoSA4cOFAjt+eNmTNnmn1v3bpVapLFixfLoEGDJCYmxpRvxYoVAfW5IjDOs0A7Fl9cF94qKCiQhx9+WFq3bi3R0dEydOhQ+fvvv6t8vwDgKwT0AHxq8+bNcs0110ibNm0kMjJS4uLi5IQTTpDnnntOjhw54u/iAX6Xn58v559/vhw8eFCeeeYZeeutt6Rly5Yul/3f//5nAvf09PRqL2dt44vPku+jZlwXvlJYWCjnnHOO2d+VV15pAvu1a9fK6NGjTaBflXJzc+X//u//JDk5WaKiouT444+XH374oULb0nLrDZCuXbu6fH/p0qVy+umnm3+P69WrJ6eddprLmyWeLmezbNkyOeuss6RBgwbmZoju//nnn3daZuPGjXLhhRdKSkqKWaZjx47ywAMPSE5OToWOFUBpoS7mAUCFfPPNN+YHWUREhIwfP978456Xlyd//PGH3HHHHbJmzRp57bXX/F1M1CGXXXaZ+TGp52RNuum1bds2+e9//2uCiPICyPvvv18mTpwoCQkJ1VbG2sgXn6W7bdTE8yzQeHNd+MqTTz4p8+bNk0WLFkmXLl3MvCZNmsgll1wiv/zyiwwfPrzK9q3n0McffyyTJ0+W9u3bm5oRo0aNkp9//lkGDx7s8XZ27twpjzzyiKnV4C7o1u01b95cpk6dKkVFRfLyyy+bmgh63B06dPBqOZvvv//e3Pjo1auX3HPPPRIbG2u+Qy2PzY4dO6R///4SHx8vN954own8FyxYYLavNw+++OKLCn9+AI4hoAfgE1u2bDE/aDWj8tNPP0nTpk3t791www2yadMmE/AHsuzsbLc/mlAzhYSEmKkmnQP79+83jwTotYevz7O6qCqui7Ku14yMDBMIa0BtC+aVVvlXK1eurLKAXgPk999/X5544gm5/fbbzTzbTfA777zT3DjylK4/YMAAU9vAVfMbDba1BoAG0g0bNjTzLr30UjnuuOPk3//+t3zyySdeLacyMzNNec844wxzUyI42HWFX61lobVZ9Ka+7TO++uqrzc2C2bNny6FDh6R+/fpefXYASqPKPQCfePzxxyUrK0veeOMNp2Depl27dvKvf/3L/nr58uUycuRIU7VP7+wPGzZM/vzzT5dthPVmgC0jpnf6J02a5FRdT39Q6HK//vprqf2++uqr5r3Vq1fb5+3atUsuv/xyk4nRjJr+0HjzzTdd7lurX1588cXmR4dj1kSzN3379jXNCtq2bWv2Y1vHkTf7Ku84Hbd5xRVXmKqauk1t+3ndddeZ2hDe7Lc8+uPwggsuMN+R/sDT7+/o0aNeH5+N/rAr7/g0Q3f99debbJD+uNT9aq0Px/a83nzf7toDe3P+uTsHXClvu3r8mvFSely6/ZNOOsnltnT/WrNF6Xesy7o6Fk8+18qeD+Wtr81ptCqtTo5Na7T6tP490CBJAw7Hz3X9+vU+Pb/Kui7K+iw9OefK+z58cZ55ev078vRa8PQYXdEytWrVqtR8V3/vKnqulXddVMX1+s4778jhw4dNgOkoLCzMPOp7VUW/N70B5Lhv/bdEz18NqDWz7YnffvvNbOvZZ591u8zvv/9ubkzYgnSl16R+3l9//bX5d9ub5dS7774r+/btM1X9NZjXGycapJekgb/Sc8GRblfXCw8P9+g4AZSNDD0An/jqq69Mu3lbdqMsWvV+yJAh5seZZiP0B5T++NQfcPrDVNsSOtIf/foDetq0aaZa4Ouvvy6NGzeWxx57zLyvWQL9kffhhx/afxTafPDBB+YHpa1tof4I0WyG/vDTKoCNGjWSb7/91vyQ0h8fmq1xpD8utTqkZnIsFov9x6W2M9QfJVr9VgMVbROo23Lk7b7KO061e/duU4VRgzj9MagBlP6A1h91+uNffyB5u193tDz6Q17Loz+etW2kZlQ0s1JVx6edYml2ytbmUgOOV155xZwb+kNd22B683374vxzdQ5UdLvav0SzZs3Mtm6++Wbp169fqR+7Ntq2Vzvneu+990wb38TERDO/5HlW3uda2fPBk/U1SJw1a5bpL+Puu++Wp59+2l47RzOhGvCWzGD78vwq77oo67PUbZZ3znnzfXhzPnjzPbri6bWgn4Mnx1hZFT3Xyrouqup6/fTTT6Vz584mg++Y2bYF0+4y+9rWX89pT2gVc1fZa/03RDPfekyO9BxW2m5dq76XRf/duemmm0zzhG7dupXZVl+vz5L0O9ebXXrDR78zT5dTP/74oym7XmNjxowx14V+Xtr0RK8NvTmh9DvS81e/f/23Um8W6Hmo555+z9R4A3zEAgCVlJGRob+aLGeffbZHy48ZM8YSHh5u2bx5s33e7t27LfXq1bOceOKJ9nlTp04127388sud1h87dqylYcOGTvMuuugiS+PGjS0FBQX2eXv27LEEBwdbHnjgAfu8K664wtK0aVPLgQMHnNa/8MILLfHx8ZacnBynfet2Sxo9erQlOjrasmvXLvu8jRs3WkJDQ806Fd2XJ8c5fvx4c0yLFy8uVa6ioiKv9uuOrTxnnXWW0/zrr7/ezF+5cmWVHZ+rsi1YsMCsP3v2bK+/7xkzZph1t2zZUuHzz9U54Iqn2/3555/Ndj/66KNyt/nEE0+UKn/J8pX3uVb2fPBm/SlTppjv4LfffjPHp+V79tlnq/T88vS6cPdZenrOlbUNX5xnnlwfrnhyLXhzjCWPZcKECZaWLVuWWt9WbkeVOdfcXRdVcb3qZxUTE2OWdze5uz5t5fRkcnXdqi5dulhOOeWUUvPXrFlj1ps+fXq5x/Diiy+az3T//v3m9dChQ812S+rWrZvluOOOczo/cnNzLS1atDD7+vjjj71aTnXv3t38G6jTTTfdZPnkk0/Moy6n37WjBx980BIVFeX0udx9993lHh8Az1HlHkCl2arVaa+45dGsgnamo3f1NaNvo9lurSapbe1s27O59tprnV5rtiYtLc1puXHjxpk2mFoV3kazUloNUN9Tmq3RdoDakY8+16yMbRoxYoTJumhmrKx9a/k1O6Hl16q9jk0KtEqojS/2VfI49Vg+//xzs02t7l+SZsUqsl93NLvqSLNBas6cOVVyfMoxQ6SZMH1fP1uthuy4PU++76o6/3y1XV8p63Ot7Png7fpa7VmzwhMmTDBVvDVrrJm4qjy/PLkuyuLpOeeNqvo754on10JVHGNJvvzbU9XXq3beptXENeOvPcs7ThdddJFZpnv37i7X7dGjR6l13E1JSUkut6HNUlx1oGjLbJc3Iox+f/fee69p9+6uhoiNXoeaQdcsudbG0Ey7tn/fs2eP0748XU5p9Xut+aLva80arb2ij1rTQvsG0J7tbbQWzoknnmg6xNXzQ5tjaO2JF198scxyA/AcVe4BVJqt2qAnbQ5TU1PND4GSPeaqTp06mR+hWuXRsZOiFi1aOC1n60RHq+fa9q1V4LXdqVYz1faVSp/37NnTVG207Vur5OoPC3e97ds6ZrLRKrAl39cfNvpjuCTHeRXZV3nHqdvUH69lVSevyH7d0WqrjrSvAK0+qtV1q+L4lH62WuV4xowZpjqnY5VZx2qunnzfvjr/Sp4Dvtqur5T1uWqb9MqcD95+z9rkQ9tLa5VpDU70e3QXUPvq/PLkuiiLp+ecN6rq75wrnlwLVXGMVfm3p6qvV1vfAVolvGTHd48++qip7u/u74h+L5XtLE9vsGgV95JsfUi4qvru6D//+Y+pzm+7CVYWvcGhn5F2wKfNYpTe+NKbGdoGXptseLOcY/lsNz9s9CaLNofQfgD0+tbgXpvA6I0CbeqhNPjX702H7NP1HdvsA6gYAnoAlaY/NjVb7djxnC+56z3a8UepZjs0i/PZZ5+ZoXa0Lef8+fNNJsDG1mmP9tyrGURXSmZlyvth5U5F9uXJcVbFfj3lGJhV1fHpD1QNOrSt7cCBA02govvVtr+OnS558n37SkXPgepS1uda2fOhIut/99139uBEM3WeBFi+OL8qytNzrqpV9Pr35FqozDG6uyFj6+TQH99ZZa9Xzc6rkm249eaGdg6nWWR3tD25dvboCc2eu/petYaB3lgpyZYNd6z9VZJeU3rDRDvC074jbPR609oXerNC/03WgN9GA3LtDV/7I9DvXtvca8/1yvHGhafLafl0mZL9f2ifD7abUErPRx3WzhbM2+jY9dqvhvYlUJVDAwJ1BQE9AJ8488wzzY8MvTOvPxjL+oGjnexs2LCh1Hva67Vm6MrrDMgdrV6qmQUdV3jdunXmh7Bj9WvdtzYL0B+iFf0RoT9YNPOoPVKX5DjPF/sqSbepP9TKunHiy/2WDMb0+PRHu1ahrIrjs1UV1mDgqaeess+zZZm9/b6r8/yrqu2WV13ck3JV5nvydv2//vrLdBCpPbRrx17aYdeqVatMcFBV55cn10VZn6U355yn30dV/p1zpbxrwZtjdJWRdrWc9pzvqKr+5lXF52hrHubYc7vSz1ADdh0dwR3t1O3kk0/2eDhXVyMEaO0JHW9ea5Y41r5YuHCh/X139EaAXifalMVVcxa9pnTEiJI935fs9V+bjmmgrR1Iertcnz59TJMCLYtj7QnbDQZbMwC9ueRqWDq98aAKCgrcHicAz9GGHoBPaLU8zXboD3j9R9xVm8XnnnvOZCtOO+00+eKLL5yGTNJ1dCgc/SFRVvXSsuiPSM1KaHVTnbTHYMeAQfd97rnnmnZ8rn78a/XO8ug2dD/aZtcxO6LBiPbm7Mt9laQ/XjUTpyMKLFmypNT7+iPel/t96aWXnF6/8MIL5lH7CqiK41O63ZIZSd1vyWygJ9+3u+1XxflXVdu1ZRA9Cbzclasy35M36+uPdB1+TLN3eq1rBk6P/5ZbbqnS88uT66Ksz9Kbc87T76Mq/85V9G+fp8dYkjaF0My13qxxzCRrjQBHVfE3oao+R60poOeNBtU2O3fulAcffNC0Cy+rJoEv2tCfd9555rN3bJqgVfC1FoX22u94k0KbHOjNC1tP/Nq0RD/7kpM2O9BmG/pc28GXRc8RHVFEa2y4G0O+rOV0RAalw9Q60pEZQkND7UMOalZfs/Ba5d6RjhSh26uOGhtAXUCGHoBP6I8+/YGlWSFt26g/ivSHh2Y7NKPx0UcfmR/76qGHHjI/dvTHmHbEoz8AtN2d/qDR8ewrSocz0vZ52m5Pq1Q++eSTpZbR9pH6I05/NF111VVm2CKtPqmdNWkmwpOqlNrxl3bUpEN0aSZHf5hpBz96vJqV9OW+StJqtLpv7WxM2ybqZ60/rvXz1Q6itJMrX+1Xs0taNVLb6GrNi7ffftu0kdQftFV1fFrT46233jIZXd2e7le35aqdpSfftytVdf5VxXY1E6Z0KDitHq3HrJ2OeTPcU2W/J0/X1+PX81+zxJoB1R/r2nGXtvfVAGbUqFFVdn55cl24+yy9OefcbaM6zzNXyrsWvDnGkvQ4tb3z2LFjTUZYA0wddkyDtZKd3FXF34Sq+By1ppXeBNIbT1oDQD8XzWjr0Hm2G0vu+KINvX4+OrzelClTTL8C2v+K1g7QmxYlg+RFixaZGgFTp041//bocIla9pJsGfmS7+lY9VprRm+M6PetQ0TqjQO97jST7+1ySqvRa7ME7S9Ds+x63WmnjHq96THZmgzccccd5ka3dvCowxjqdnVMe52nN//LaloAwAte9IgPAOX6+++/LVdddZWlVatWZqghHVrohBNOsLzwwguWo0eP2pdbtmyZZcSIEZbY2Fgz9M3JJ59s+d///ue0LdswRKmpqeUOEWXzww8/mPeCgoIsO3bscFnGffv2WW644QZL8+bNLWFhYZakpCTLsGHDLK+99lq5+7aZN2+epVevXuYY27Zta3n99dctt912myUyMtJn+3J3nNu2bTPDdDVq1MgSERFhadOmjdmHDjHkzX7dsZVn7dq1lvPOO898h/Xr17fceOONliNHjlTp8R06dMgyadIkS2Jiojk39BxZv369GTZLh8/y9vt29xlW5vwriyfb9WbYOtuwT82aNTPDkDkeizefa2XOB0/WX7p0qRm2UYeucqRDYPXr18+SnJxsvtuqOL+8uS5cfZbennOutlEV51lZf+dcKeta8OYYXe33+++/t3Tt2tX8vevQoYPl7bffdjlsXWXOtbKui6q4Xg8ePGg555xzzPB1TZo0MeduZmampbrouX777bebz0fPV71O5s6d6/Zz0eMri7th6zZt2mQ57bTTzHev++nYsaNl2rRpTteFN8vZ5OXlWe677z5zDun33K5dO8szzzxTarmFCxdaRo4caY5Tl9Oh8R5++GFLfn6+B58SAE8E6X+8uQEAAHBNMyPaUZDjkD0AnGmW8f777zdVsDXbCAAAKo429ABQASXHCdYgXsfPtrUdBAAAAKoabegBoALatGlj+gTQR+3tWduU6hjc2jkgAAAAUB0I6AGgArSjIO2pd+/evWYcaB2qTzvmat++vb+LBgAAgDoi4Krc6zA3OqanjgOtvYRq759l0R43dexMXb5bt26mSiwAVJb2/qs9EutYzjqk09y5c6V3797+LhYQEG3otfse2s8DAFDHAnodD/PWW281Q3foECg6tM2IESPMkB+u6FBZF110kRmPU8fB1A6rdHI1PioAAAAAAIEkoHq514x8v379zHjPqqioSJo3by433XST3HXXXaWW1/GwdTxWHfPSZsCAAdKzZ0+ZPn16tZYdAAAAAIA62YY+Ly9Pli5dKlOmTLHPCw4OluHDh8uCBQtcrqPzNaPvSDP6n3/+udv95ObmmslGbxocPHhQGjZsKEFBQT45FgAAAAAA3NG8++HDhyU5OdnEvQEf0B84cEAKCwulSZMmTvP19fr1612uo51VuVpe57szbdo0Mz4uAAAAAAD+tGPHDklJSQn8gL66aA0Ax6y+dnbVokUL80HGxcX5tWwAAAAAgNovMzPTNC+vV69emcsFTECvveGGhITIvn37nObr66SkJJfr6Hxvllc6/JROJWkwT0APAAAAAKgu5TX7Dphe7sPDw6VPnz4yb948p/bt+lrHf3ZF5zsur3744Qe3ywMAAAAAECgCJkOvtCr8hAkTpG/fvtK/f3959tlnTS/2kyZNMu+PHz9emjVrZtrBq3/9618ydOhQeeqpp+SMM86Q999/X5YsWSKvvfaan48EAAAAAIA6FNDrMHSpqaly7733mo7tdPi5uXPn2ju+2759u1MPgIMGDZJ3331X/vOf/8i///1vad++venhvmvXrn48CgAAAAAA6tg49P7qjCA+Pt50jkcbegAAAPiLjviUn5/v72IA8IGwsDDTR1xl49CAytADAAAAdY3m37R2anp6ur+LAsCHEhISTIft5XV8VxYCegAAAKAGswXzjRs3lujo6Er9+AdQM27S5eTkyP79+83rpk2bVnhbBPQAAABADa5mbwvmGzZs6O/iAPCRqKgo86hBvV7fZVW/rxXD1gEAAAB1ja3NvGbmAdQu0cXXdWX6xiCgBwAAAGo4qtkDtU+QD65rAnoAAAAAAAIQAT0AAAAABID77rtPevbsWe37nThxoowZM6ba94vyEdADAAAAqDILFiwwHX6dccYZPtvmZ599JgMGDDDjdNerV0+6dOkikydPrnTgO3PmTDOUmLd++eUXU33aNmmHZ1qm1157zettAd4goAcAAABQZd544w256aab5LfffpPdu3dXalvaedi8efNk3Lhxcu6558qiRYtk6dKl8vDDD1eqYzFf2bBhg+zZs0fWrl0r11xzjVx33XWmvEBVIaAHAAAAUCWysrLkgw8+MIGtZug1A+7oiy++kN69e0tkZKS0adNG7r//fikoKLC/r9nuV155Rc466yyJiYkxgftXX30lJ5xwgtxxxx3SoUMHOe6440x18Jdeesmso/vQ7axcudKeMbft9+mnn5Zu3bqZbTVv3lyuv/56U0Zbln3SpEmSkZFhX08z/So3N1duv/12adasmVn3+OOPN8uXpMOPJSUlSevWreXmm282j8uWLbO/P3fuXBk8eLCpBaDDEJ555pmyefNmp23s3LlTLrroImnQoIHZV9++fWXhwoUuP19dVz+3G2+80YxtXl45bTUQvvvuO+nUqZPExsbK6aefbm5COA6VeOutt9rLeOedd5pto2YioAcAAAACUHZ2ttvp6NGjHi975MgRj5atiA8//FA6duxoAu9LL71U3nzzTXtw+Pvvv8v48ePlX//6l8lov/rqqybg1KDdkQbVY8eOlVWrVsnll19uAuY1a9bI6tWrXe5Ts/e33XabqfKugapOOk8FBwfL888/b9afNWuW/PTTTyZgVYMGDZJnn31W4uLi7OtpcKw0YNamA++//7789ddfcv7555tAeOPGjS7LoMeowfv27dtNUO342WqwvGTJEpO51/LosRUVFZn39ebC0KFDZdeuXfLll1+amxJaPtv7jrQcenPg4osvlhdffNHcgPCknDk5OfLkk0/KW2+9ZWpNaBltx6meeuop8z3od/XHH3/IwYMHTRMH1FAWlCkjI0P/4phHAAAAoDodOXLEsnbtWvNYkv5GdTeNGjXKadno6Gi3yw4dOtRp2cTERJfLVcSgQYMszz77rHmen59vtv3zzz+b18OGDbM88sgjTsu/9dZblqZNmzod4+TJk52WycrKMsen77Vs2dIybtw4yxtvvGE5evSofZmpU6daevToUW75PvroI0vDhg3tr2fMmGGJj493Wmbbtm2WkJAQy65du5zma/mnTJlinusxaXliYmLMFBoaagkODrY89NBDZe4/NTXVrLdq1Srz+tVXX7XUq1fPkpaW5nJ523HNnz/fUr9+fcuTTz7pVTn1+HR/mzZtsr//0ksvWZo0aWJ/rZ//448/bn+t31tKSorl7LPPLvNY4Nvr29M4NNTfNxQAAAAA1D7anlzbuNuyu6GhoSZTrm3qTzrpJJN9nj9/vlNGXqt7a+0CzSJHR0ebeVrl3JFWJf/mm29MdfOff/5Z/vzzT5ORf+6550x22raeKz/++KNMmzZN1q9fL5mZmaZ6f8n9laQ1A7RcWrXfkVZv1yrpjrTWgXbSp+/psWvGXKvOa5MDpZnye++911ShP3DggD3zrlnyrl27yooVK6RXr15mHXd02VNPPdV8bo4dAXpaTj3Otm3b2l83bdpU9u/fb55rcwOtmeBYq0C/N/0OqHZfMxHQAwAAAAHI1vbbFe1V3pEtYHNFq3072rp1q886w9OAOTk52T5Pg8KIiAhTRVzLr23dzznnnFLrapt6xwDeFQ1Kdbryyivl7rvvNoGsttfXdvCu6HFpm3UNrjUY1qBZq5RfccUVkpeX5zag13Lq56md75X8XLUNuiNtM2/rJV+r/GvgrvuyBfSjR4+Wli1byn//+1/zuWhAr4G87l9p7/jladSokVn3vffeM00QtImAN+UMCwtzek+r6hOsBy4CegAAACAAuQt0q3NZdzSQnz17tmmPfdpppzm9px3YaTCqneFpFr9du3aV3l+rVq1MQG5r6x8eHm6y1Y400NUAWstku4mhbfwduVpPM+Y6T2+KDBkyxKtyaWBt66MgLS3NHK8G87bt6A0FR927d5fXX3/dtFt3l6XXoP/rr7+WUaNGyYgRI+T77783tQIqU04bHQZQM/Z6I+LEE0+0f5f62en3hZqHgB4AAACAT2nAeejQIZP91iDRkQ43p9n7hx56yGTMW7RoIeedd54JsrUavnZ2p++5o53kaRV5DWg1252enm46utNh67Qqui3A37Jli6nCnpKSYgJevXGgy7zwwgsmU67V/adPn+60bV1PM93aYV2PHj3MTQLN/F9yySWmAz+9GaCBc2pqqllGA3Dtvd9Gg2mtwm+rcq8dz+mxqfr165uq7zo2vQbNWnX+rrvuctq/9m7/yCOPmJse2jRAl1u+fLnJyA8cOLBUs4ORI0eaSTvg86acZdFOCh999FFp37696dBQRwbQzxg1E73cAwAAAPApDdiHDx9eKpi3BfTay7sGqxr4a4a5X79+MmDAAHnmmWdMkF4W7QX+n3/+MYGrBpwa0O7du9dsR3vTt+1De3c/+eSTTRV1rRGgAboGp4899pip5v7OO++YoNmR9nR/7bXXmrb+ut7jjz9u5s+YMcPsT9vq6z404F68eLG5GeFI39Pj0psH//d//2fGotcbCEpvWGjv85rt1v3fcsst8sQTT5SqIaDHocPf6Q0LHWJPg+uSVeht1ei//fZbU11eg3WtneBpOcui61522WUyYcIEcxNBb4ZoT/yomYK0Zzx/F6Im084y9A+RdhBha58CAAAAVAfN9mqmWdtmO7YrBxD4yrq+PY1DydADAAAAABCACOgBAAAAAAhABPQAAAAAAAQgAnoAAAAAAAIQAT0AAAAAAAGIgB4AAAAAgABEQA8AAAAAQAAioAcAAAAAIAAR0AMAAAAAEIAI6AEAAACghJkzZ0pCQkK17/e+++6Tnj17Vvt+EZgI6AEAAABUmQULFkhISIicccYZPtne1q1bJSgoyD6Fh4dLu3bt5KGHHhKLxeKTfQCBItTfBQAAAABQe73xxhty0003mcfdu3dLcnJyhbeVn59vf/7jjz9Kly5dJDc3V/744w+58sorpWnTpnLFFVf4qORAzUeGHgAAAECVyMrKkg8++ECuu+46k6HXauyOvvjiC+ndu7dERkZKmzZt5P7775eCggL7+5qBf+WVV+Sss86SmJgYefjhh+3vNWzYUJKSkqRly5ZyySWXyAknnCDLli2zv7948WI59dRTJTExUeLj42Xo0KFO76v09HS55pprpEmTJqYMXbt2la+//trlsaSmpkrfvn1l7Nix5iZCUVGRTJs2TVq3bi1RUVHSo0cP+fjjj+3L//LLL6b88+bNM+tFR0fLoEGDZMOGDU7bffTRR83+69WrZ25GHD16tBKfOOoaAnoAAAAggGi18py8Ar9M3lZp//DDD6Vjx47SoUMHufTSS+XNN9+0b+P333+X8ePHy7/+9S9Zu3atvPrqqybgdwzabW3KNYhetWqVXH755S73s2TJElm6dKkcf/zx9nmHDx+WCRMmmOz9n3/+Ke3bt5dRo0aZ+UoD8pEjR8r8+fPl7bffNmXQ4FqbB5S0Y8cOGTJkiAn4NWiPiIgwwfzs2bNl+vTpsmbNGrnlllvMMf76669O6959993y1FNPmTKGhoY6HYN+Pnp8jzzyiHlfaxi8/PLLXn3GqNuCLDQ0KVNmZqa5o5eRkSFxcXH+Lg4AAADqEM3WbtmyxWSBNYOsNLDufO93finP2gdGSHS45612NWt+wQUXmKBdM+8asH700Udy0kknyfDhw2XYsGEyZcoU+/IaWN95552mar7SDPfkyZPlmWeecWpDb8uKBwcHS15enqmKf/XVV5ubAu5oAK+d3L377rty5plnyvfff28C+nXr1slxxx1Xanm9uaD7Xrhwocn0602FZ5991pRJM/QNGjQw1f4HDhxoX0er/efk5Jh9aIb+5JNPNsvocao5c+aYmgpHjhwx36dm7Hv16iUvvfSSfRsDBgww3/uKFSs8/pxRe65vb+NQMvQAAAAAfE6rli9atEguuugi81qz0+PGjTNt6dXKlSvlgQcekNjYWPt01VVXyZ49e0xQbKPV1V3Rqvwa9Op2NNOt1ffvuusu+/v79u0z29PMvAZGGhRpE4Dt27eb93XdlJQUl8G8jQbempk/55xz5LnnnjPBvNq0aZMpowb6juXXjP3mzZudttG9e3f7c72hofbv328e9WaCY60C5XiDACgPneIBAAAAASQqLMRkyv21b09p4K5ZecdO8LRysFZXf/HFF01wrW3mNVguyTFbqW3nXWnevLnp3V516tTJBNL33HOPqcKu62t1+7S0NBOIazt73a8Gy5rRN8cSFVXuMeg6WpNA29Xfcccd0qxZMzNfy66++eYb+zzHdRyFhYXZn9tuCGhtAcAXCOgBAACAAKJBoTfV3v1BA3nNVmvb8dNOO83pvTFjxsh7771nOsPTLL4tKK8sbfuu+9WAXQN6bRuv7dG13bytHfyBAwecMuc7d+6Uv//+222WXqv0v/XWW3LxxReb6vNajV5vUHTu3NkE7prt1872KkpvRGiVfu1LwEbb+wOeqtl/CQAAAAAEHM1oHzp0yPTartXdHZ177rkme6/jxmtb9hYtWsh5551ngmetPr969WrzXnk0+753714TxGuHeZqJ16Db1t5Yq9prMK5V9rU9smbYHbPyGoifeOKJpjxPP/20ubGwfv16c8Pk9NNPd7pR8M4775imA6eccooJ6rV3/dtvv910hKfZ9sGDB5u2znoTQfevtQM8oX0LTJw40ZRR+xvQ/WgHe9rjP+AJ2tADAAAA8CkN2LWqeslgXmkAbevRXQN/7ZyuX79+pjM47fxOq8d7Qrev22jVqpXpEE8z8dqu3rEMelNBawJcdtllcvPNN0vjxo2dtvHJJ5+YfWuwrll37ZCvsLCw1L60/b/WKtBx7zWo1zbwDz74oKnir73da6ZdbwJoFXzt4MxT2qeAbkP326dPH9m2bZsZ4g/wFL3cl4Ne7gEAAFATe8EGENjo5R4AAAAAgDqKgB4AAAAAgABEQA8AAAAAQAAioAcAAAAAIAAR0AMAAAAAEIAI6AEAAAAACEAE9AAAAAAABCACegAAAAAAAhABPQAAAAAAAYiAHgAAAECtMXPmTElISKgz+0XdRkAPAAAAwOdSU1PluuuukxYtWkhERIQkJSXJiBEjZP78+fZlgoKC5PPPP5dA06pVK3n22Wed5o0bN07+/vtv8ae8vDx5/PHHpUePHhIdHS2JiYlywgknyIwZMyQ/P98sM3HiRPO5P/roo07r6veg8x0VFhbKM888I926dZPIyEipX7++jBw50uk7POmkk8x67iZ9PxAdOXJEGjRoYD7D3NxcqakCJqA/ePCgXHLJJRIXF2fufF1xxRWSlZVV5vI33XSTdOjQQaKioswfkptvvlkyMjKqtdwAAABAXXTuuefK8uXLZdasWSbQ/fLLL01wl5aWJrWRxhyNGzf22fbuu+8+E3x7E8zrDRMN1K+++mr53//+J4sWLZIbbrhBXnjhBVmzZo19WQ3OH3vsMTl06JDb7VksFrnwwgvlgQcekH/961+ybt06+eWXX6R58+bme7TdiPn0009lz549ZtL9qR9//NE+T9/3FdtNiZLHXRHlrffJJ59Ily5dpGPHjj656VTRctaagF6DeT0Jf/jhB/n666/lt99+MyeqO7t37zbTk08+KatXrzZVYObOnWtuBAAAAACoOunp6fL777+boPHkk0+Wli1bSv/+/WXKlCly1lln2bPcauzYsSaTa3utXnnlFWnbtq2Eh4ebBN1bb71VavvXXHONNGnSxASnXbt2NTGCo++++046deoksbGxcvrpp5vg0mbx4sVy6qmnmuxrfHy8DB06VJYtW+YUzGpAbatdkJycbJKDSoPZbdu2yS233GLPQrurcv/VV19Jv379TBl1X3qsVUVrDGiMNG/ePBPE9+zZU9q0aSMXX3yxLFy4UNq3b29fdvjw4abGxLRp09xu78MPP5SPP/5YZs+eLVdeeaW0bt3aZP5fe+018x3qvOzsbJPF1m3p1KhRI7Nuw4YN7fP0fXdef/118x3p56OB88svv2x/b+vWreaz/eCDD8z3o8u888475ibHmDFj5OGHHzbfi54fatWqVXLKKaeYGyu6f40VHRPA7tZz54033pBLL73UTPq8JI0xtbaCnl96Hl522WVy4MAB+/t6ntx4440yefJk893rzZYqYQkAa9eutWhRFy9ebJ/37bffWoKCgiy7du3yeDsffvihJTw83JKfn+/xOhkZGWbf+ggAAABUpyNHjpjfwvpoV1RkseRm+WfSfXtAf2/HxsZaJk+ebDl69KjLZfbv329+Z8+YMcOyZ88e81p9+umnlrCwMMtLL71k2bBhg+Wpp56yhISEWH766SfzfmFhoWXAgAGWLl26WL7//nvL5s2bLV999ZVlzpw55n3dnq4/fPhwEz8sXbrU0qlTJ8vFF19s3/e8efMsb731lmXdunXm873iiissTZo0sWRmZpr3P/roI0tcXJzZ5rZt2ywLFy60vPbaa+a9tLQ0S0pKiuWBBx4w5dbJtt/4+Hj7Pr7++mtT7nvvvdfsY8WKFZZHHnnE4+9+6tSplgkTJni8fPfu3S2nnXZaucvpNs8++2zzOUdGRlp27Nhh5n/22Wfm+7A566yzLMcdd5zLbcyfP98sq+s42rJli5m/fPnycsvx9ttvW5o2bWr55JNPLP/88495bNCggWXmzJlO22rVqpV9md27d5vy67l12WWXWVavXm2mrKwss61zzjnHsmrVKvP9tm7d2unzc7WeO5s2bbJERERYDh48aL5v/Zy2bt1qf//QoUOWRo0aWaZMmWLOoWXLlllOPfVUy8knn2xfZujQoWZ/d9xxh2X9+vVm8uj69jIODZUAsGDBAnO3q2/fvk53lYKDg83dJk/vdGl1e62yHxoaEIcNAAAAlJafI/JIsn/2/e/dIuEx5S6mv7c1Y33VVVfJ9OnTpXfv3ibLqlW4u3fvbpaxZXP1d75mcm20hq1mU6+//nrz+tZbb5U///zTzNdsv1bn1qrdWgX8uOOOM8toJrpk1Wzdr2b5lWZKteq4jWZyHWnWWcvx66+/yplnninbt283ZdKYIywszGTqtYaB0oxzSEiI1KtXz6ncJWkmWI/3/vvvt8/TDHdV2bhxo1ft1TWG0iz+1KlTXWagtZmEZs9dsc2vTJ8But+nnnpKzjnnHPNaawCsXbtWXn31VZkwYYJ9Oc1w25axiYmJMdn98PBw8/q///2vHD161NQm0PfUiy++KKNHjza1RDSD7mo9d958802Tfdc+A5Rm17UfAq21Ydt2r1695JFHHnFaR5sj6GdiOy+1VoT2aVCVAqLK/d69e0u1R9E/Enox6Xue0OoPDz74YJnV9JV2eJCZmek0AQAAAPC+Db02gdW281rlXdtfa2CvgX5ZNFDXjtwc6Wudr1asWCEpKSn2oMkV7RDOFsyrpk2byv79++2v9+3bZ242aMClVe416afVszWQV+eff77pFE1vFOhyn332mRQUFHh1/FrOYcOGeby8NlHQ6tu2SYNFrWLuOE9fu6PNBLylwa72cWD7bH2xTU9oVf3Nmzeb5tCOx/fQQw+Z+Y4ck7o22kmfY1C+bt06c7PEFszbzpmioiLZsGGD2/Vc0Y4A9TPRqvY2+lzPW92eWrlypfz8889OZdcmA8qx/H369JGq5tdU9V133WVOorK4O7m8oUH5GWecIZ07d7bfVXFH25E43kUDAAAAapSwaGum3F/79oK2e9a26jrdc889pt21Zma96eytJG0jXW4xw8KcXmtbbMfgVDPA2jnfc889Z9r3azv5gQMH2jsu00yrBoJaG0D78NLaAk888YTJ4JfcdmXKWTJw1ZsANs8//7zs2rXLKV6yZZpd0Rsc69ev92qfJ554osk+a98GJb8T3Z67WMw2v6ybKmWxtW3XzPrxxx/v9J7WfnDkGKSXNc8TnqynfS/o566jFpQM9LV/Aj2Xtfy27H9JevPIm/0FdEB/2223lXsx610xrcrieEdN6R0y7cm+rGou6vDhw+aOoFaJ0Ttr5V2AejJrtR7HmwF6QQMAAAA1gnbC5kG195pIE2yOPYbrb3MNlEpW59Zh0RyrXetrXVdplf2dO3c6VW32lm5PO2AbNWqUeb1jxw6nDs1sAbkGbTppJ3OagdWO17SWgWZ5S5a7JC2nBoCTJk3yqEy6v3bt2tlfa21kjUUc55VFO7/797//bUYW0OrgJZsg6M0KVwGm9oqvVe9LdhKnzQV0m9qxn34GjrSqvHY8p8FtReiNCe2Y7p9//jGdn1dWp06dTAZdM/+2Y9TvWJtol9f5XUna/ECP/e677y7VhELf02PWc0B7wdeOHP3dnNuve9d2M7a2M2XRu2Xak+XSpUvt1RZ++uknU+Wh5B0dR3oB6B0nveOmVX30DmF5dFmdAAAAAFSMZr+12vrll19uAltNri1ZssS0Jz777LPty2lApEGvVo/W3+DaZvmOO+6QCy64wASl2oZdA0od+kyz5Urb4mtmWav0P/300ybg1cy0ZuE1kecJrWqvPedrVlxjBt2nY0Zdg0MN2DXW0Or7b7/9tnlfs/m2cmuP8hr4abm1F/OStCaCVrnXqv+6nCYk58yZI//3f/8nVUHbmn/zzTdmn9rUePDgwfbPXTPJGoxq4F6SVkPXoFprBDjSMn/00UfmxorWTtDt6mf10ksvmdhK36tMBlprRevIAdrkQb83bfqsZdWh9BwTrJ645JJLzOetZdUa2ampqWYIc+15vqxaDSXpenq+6fHpyAmOxo8fb/od0KSy3uDR2gUXXXSR3Hnnnebmy6ZNm+T99983bfRL1jKQut6GXu+46Jes7Ve0Awy926IdW+hJpnd2lFaL0LtmtrEP9WQ77bTTzF0aPXn1tba316m8u2kAAAAAKk7bFGsw/Mwzz5jgW4MjrXKvv+e1QzHHTK9Wadcasbassg4tplXhtRM8HQdcO0nTDskcO3zT7KgOB6cBlWbuNajy5je+xgcaOGqmVYM+DSwd++zSDvI0YNMbDXpDQm8maKCnWWmlHezpsGoarLtLUGp5NejV4FADae2IzxarVAW9saCfpX4W+pkNGDDAfEYaqOvxlQxQHenx2NqH2+gNEh26TrP++j1qpnvIkCFmyD7tD0G/p8rQ5hca/Op3qzcV9EaN3kjRzvG8FR0dbarKa7Ctx3zeeeeZGxCO55onbJ3quer7QOfpTR29uaMxqMakes5pzKnl1xsqet5orYDqFKRd3UsA0C9Hg3i9kPRD0jtyenLqHwulF5R++do5gV48epJpL5iubNmyxWmcy7LojQC9a2TrIR8AAACoLtpzt/521d+5ntQ2BVA7rm9P49CAGb9NqzG8++67bt/XAN3x3oQG9QFyrwIAAAAAgNpZ5R4AAAAAADgjoAcAAAAAIAAR0AMAAAAAEIAI6AEAAIAajr6hgNrH4oPrmoAeAAAAqKHCwsLMY05Ojr+LAsDHbNe17TqviIDp5R4AAACoa0JCQszY1vv377ePt63jgwMIXJqZ12Ber2u9vvU6rygCegAAAKAGS0pKMo+2oB5A7ZCQkGC/viuKgB4AAACowTQj37RpU2ncuLHk5+f7uzgAfECr2VcmM29DQA8AAAAEAP3x74sAAEDtQad4AAAAAAAEIAJ6AAAAAAACEAE9AAAAAAABiIAeAAAAAIAAREAPAAAAAEAAIqAHAAAAACAAEdADAAAAABCACOgBAAAAAAhABPQAAAAAAAQgAnoAAAAAAAIQAT0AAAAAAAGIgB4AAAAAgABEQF9bFOSKFBb4uxQAAAAAgGpCQF9b/DBVZOYokYP/+LskAAAAAIBqQEBfG2QfEFnxrsiOhSLTh4gsmy1isfi7VAAAAACAKkRAXxvEJIpc+7tIi0EieVkiX94k8sGl1kAfAAAAAFArEdDXFvVbikz8WmT4/SLBYSLrvxZ5eYDI39/5u2QAAAAAgCpAQF+bBIeIDJ4sctVPIo06iWSnirx7gchXk0Xysv1dOgAAAACADxHQ10ZNu4tc/YvIgBusr5fOsLat37nE3yUDAAAAAPgIAX1tFRYpcvojIuO/EKmXLHJws8gbp4n8PI3h7QAAAACgFiCgr+3anCRy/f9Eup4rYikU+fVRkTdPE0nb7O+SAQAAAAAqgYC+LoiqL3LemyLnvC4SES+ya6nI9MEiS95keDsAAAAACFAE9HVJ9/Ot2fpWQ0Tyc0S+vkXk3XEiWfv9XTIAAAAAgJcI6Oua+BSR8V+KjHhEJCRCZON31uHt1n/j75IBAAAAALxAQF8XBQeLDLzB2hN+k64iOWki718s8sWNIrmH/V06AAAAAIAHCOjrsiadrWPWD7pZRIJElr9lbVu/faG/SwYAAAAAKAcBfV0XGiFy2oMiE78WiW8ucmiryIzTReY9KFKY7+/SAQAAAADcIKCHVavBItfNF+l+oYilSOT3J0VeHy6S+re/SwYAAAAAcIGAHsdExouc86rI+TNFIhNE9qwQeXWIyMLXGN4OAAAAAGoYAnqU1mWsyPULRNqcLFJwVOTbO0TePlckc4+/SwYAAAAAKEZAD9fikkUu/VRk5OMioZEim+eJvDJQZM3n/i4ZAAAAAICAHuUOb3f8NSJX/yqS1F3kyCGRjyaIfHatyNEMf5cOAAAAAOo0AnqUr3FHkSvniQy+VSQoWGTleyKvDBbZ9j9/lwwAAAAA6iwCengmNFxk+FSRiXNEElqKZGwXmTFK5IepIgW5/i4dAAAAANQ5BPTwTsuBItf+IdLzUhGxiMx/VuS/w0T2r/N3yQAAAACgTiGgh/ci40TGvCRywVsiUQ1E9q0SeXWoyIKXRYqK/F06AAAAAKgTCOhRcZ3PErn+T5F2p4oU5op8N0XkrTEiGbv8XTIAAAAAqPUI6FE59ZqIXPKRyBlPiYRGiWz51Tq83aqP/V0yAAAAAKjVgiwWi8XThYuKiuTXX3+V33//XbZt2yY5OTnSqFEj6dWrlwwfPlyaN28utU1mZqbEx8dLRkaGxMXF+bs4NduBjSKfXi2ye5n1dbfzRUY9KRKV4O+SAQAAAECti0M9ytAfOXJEHnroIROwjxo1Sr799ltJT0+XkJAQ2bRpk0ydOlVat25t3vvzzz99eRwIJIntRa74XmTo/1mHt1v1kcgrg0T++dXfJQMAAACAupmh10B+4MCBMnHiRDn11FMlLCys1DKasX/33Xfl1VdflbvvvluuuuoqqQ3I0FfQjsUin14lcmiL9fXAG0VOuUckLNLfJQMAAACAWhGHehTQr1u3Tjp16uTRjvPz82X79u3Stm1bqQ0I6CshN0vk+7tFls60vm7cReSc10SSuvq7ZAAAAABQN6rcexrMK83eV0Uwf/DgQbnkkkvMwSQkJMgVV1whWVlZHq2r9yxGjhwpQUFB8vnnn/u8bHAjIlZk9HMiF70vEp0osn+NyH9PFpn/PMPbAQAAAEAlhVZ0Re0QTzPxeXl5TvO7d+8uVUGD+T179sgPP/xgagFMmjRJrr76alPNvzzPPvusCebhJx1GWoe3+/Imkb+/FfnhHpGN34uMeVkkoYW/SwcAAAAAtb+Xe5WammqCae0Yz5XCwkLxNa3y37lzZ1m8eLH07dvXzJs7d67phG/nzp2SnJzsdt0VK1bImWeeKUuWLJGmTZvKZ599JmPGjPF431S59yE91ZbNEpn7b5H8bJGIOGsv+N0vEOGGCwAAAAD4vsq9o8mTJ5se7hcuXChRUVEmsJ41a5a0b99evvzyS6kKCxYsMNXsbcG80mHygoODTTnKqkVw8cUXy0svvSRJSUke7Ss3N9d8eI4TfESD9j4TRa79XSSln0hupshnV4t8NFEk56C/SwcAAAAAAcXrgP6nn36Sp59+2gTXGlC3bNlSLr30Unn88cdl2rRpVVLIvXv3SuPGjZ3mhYaGSoMGDcx77txyyy0yaNAgOfvssz3elx6D3gmxTdrDP3ysYVuRSXNFTr5bJChEZO3n1uHtNv/k75IBAAAAQO0N6LOzs+3Bdf369U0VfNWtWzdZtmyZV9u66667TNv2sqb169dLRWhtAb35oO3nvTFlyhRTrcE27dixo0L7RzlCQkWG3ily5Q8iDduJHN4j8tZYkW//TyT/iL9LBwAAAAC1r1O8Dh06yIYNG6RVq1bSo0cPM+68Pp8+fbppo+6N2267zYxtX5Y2bdqY6vL79+93ml9QUGB6vndXlV6D+c2bN5uq+o7OPfdcGTJkiPzyyy8u14uIiDATqkmzPiLX/G7tKG/x6yILp4v884t1eLumPfxdOgAAAACoPZ3ivf322yaY1kB86dKlcvrpp5vAOjw8XGbOnCnjxo2rsk7xtGO7Pn36mHnff/+92be7TvG0Kv6BAwec5mktgueee05Gjx4trVu39mjfdIpXjTb+IPLFDSJZ+0SCw0ROniJywmSR4BB/lwwAAAAAqo2ncajXAb2rjue0WnyLFi0kMTFRqoqOI79v3z5TE8A2bJ2247cNW7dr1y4ZNmyYzJ49W/r37+9yG1qFn17ua7jsNJGvbhZZ/7X1dYuBImOni9Rv5e+SAQAAAEBg93JfUnR0tPTu3btKg3n1zjvvSMeOHU3QrsPVDR48WF577TX7+xrka1MAvcGAABbTUGTc2yJnvywSXk9k+wKRVwaLLH/HOuwdAAAAAMC7DP2tt97qyWKmB/zahAy9Hx3aKvLpNSI7/rS+7nimyOjnrUE/AAAAANRSnsahHneKt3z5cqfXf/zxh2nPrmPRO1ZpB3xGq9lPmiMy/zmRnx+xVsPfuVjk7JdE2p/q79IBAAAAgF9VuA19vXr1ZOXKlaYX+tqMDH0NsWelyCdXiRzYYH3d70qRUx8UCY/2d8kAAAAAIDDb0APVQoewu+ZXkeOvtb7WIe5eHSKya6m/SwYAAAAAfkFAj8ARFiUy8jGRyz4TqddUJG2TyBunifz6uEhhgb9LBwAAAADVioAegaftKSLX/U+ky1iRogKRnx8WmXG6SNpmf5cMAAAAAKqNx53i/fXXX06vtem9jj+flZXlNL979+6+Kx3gTnQDkfNmiBw3UmTO7dbO8qYPETn9EZHeE7SHRn+XEAAAAABqRqd4wcHBphd7V4vb5utjYWGh1CZ0ihcA0neIfH6dyNbfra87jLIObxfbyN8lAwAAAAD/D1u3ZcsW70sBVIeE5iLjvxRZ8KLITw+KbJgjsmORyNkvinQY6e/SAQAAAEDNGrauriBDH2D2rhb59CqR/WutrzucIdJmqEhKP5GkbiIhYf4uIQAAAAD4JA71KKDfvn27tGjRQjy1a9cuadasmdQGBPQBKP+oNVOvGXtHoZEiyb1EUvqKpPS3BvlxTf1VSgAAAACo+oC+SZMmMmbMGLnyyiulX79+LpfRHX344Yfy3HPPydVXXy0333yz1AYE9AFs93KRjT9Yq99rp3lH00svE9/cGtjr1Ly/NYsfGuGP0gIAAACA79vQr127Vh5++GE59dRTJTIyUvr06SPJycnm+aFDh8z7a9askd69e8vjjz8uo0aN8mSzQNXSbLxOSu9b6bj1GtibAH+JyP41Ihk7rNOaT63LhUSINO1RHOAXB/rxKX49DAAAAACodBv6I0eOyDfffCN//PGHbNu2zbxOTEyUXr16yYgRI6Rr165S25Chr8VyD4vsWmYN8m1TTlrp5eolW6vpawZfq+prwB8W6Y8SAwAAAKgDMn1Z5b4uI6CvQ/RSOPiPNXu/s7iavnayZykxFGNwmEjT7seq6uuU0ELHb/RXyQEAAADUIgT0PkJAX8flZVvb4puq+prFXySSnVp6udgmzgG+VvUPj/ZHiQEAAAAEOAJ6HyGghxO9XNK3WbP4ts729v4lUlTgvFxwqEiTrsc629Mq+/Vbk8UHAAAAUC4Ceh8hoEe58o+I7FlZHOAvsmbys/aWXi460bmzveTeIhGx/igxAAAAgBqMgN5HCOjhNb2kMnY6d7anAX9hnvNyQcEijbsUB/iaxe8n0rAtWXwAAACgjsusqoA+OztbYmJipK4goIdP5B+1Vs13HDYvc2fp5aLqF7fDL66m36yPSCTnHQAAAFCXZFZVQB8bGysXXHCBXH755TJ48GCp7QjoUWUydzsH+Nr5XmFuiYWCRBp3OtbZnrbHb9heJDjYT4UGAAAAELAB/eeffy4zZ86UOXPmSKtWrUxgP378eElOTpbaiIAe1aYgT2TfqmO96Wuwn7699HKR8SLN+h7rbE+fRyX4o8QAAAAAArENfWpqqrz11lsmuF+3bp2MGDHCBPdnnXWWhIaGSm1BQA+/OryvuB1+cRZ/1zKRgiOll0vscKyzPa2u36iDSHCIP0oMAAAAIJA6xXvhhRfkjjvukLy8PElMTJRrr71W7rrrLomODvxxuAnoUaMU5ovsW+NQVX+xyKEtpZeLiBNp1vtYZ3uayY9u4I8SAwAAAKhpAf2+fftk1qxZJkO/bds2GTt2rFxxxRWyc+dOeeyxx0wV/O+//14CHQE9arysVJFdS44F+JrFz88uvVzDdsc629Pq+o06iYTUnto0AAAAQG1RZQH9p59+KjNmzJDvvvtOOnfuLFdeeaVceumlkpBwrA3v5s2bpVOnTiZjH+gI6BFwCgtEUtcdC/B1SttUermwmOIsfnFne/oYk+iPEgMAAACoQBzqdXpu0qRJcuGFF8r8+fOlX79+LpfR7Pzdd9/t7aYB+IJm3ZO6Wad+V1jn5Ry0tsG3dba3c6lI3mGRrb9bJ5v6rY8F9zo16SISEua3QwEAAAAgvsvQ5+Tk1Iq28Z4iQ49aqahQJHXDsQBfe9Y/sKH0cqFRxVn8vsfa49dr4o8SAwAAAHVGZlVVudcNu9xQUJBERERIeHi41CYE9KgzjhwS2bW0eNg8nZaI5GaUXi6hxbHgXnvWb9JNJLR2XfcAAABArQzog4ODTfDuTkpKikycOFGmTp1qlg10BPSos4qKRNI2FrfFLx42b/86ESnxJyM0UqRpT+tQeTGNiqfE4qmRSHSiSHRDOuADAAAA/N2GXnu11/bxGrT379/fzFu0aJHp8f4///mPGZ/+ySefNNn6f//7395uHkBNoTfkNEjXqfdl1nlHM6y96Ns629NJM/s7/rROZYlqcCzIdwz2S87TKTLBun8AAAAAvsvQDxs2TK655hq54IILnOZ/+OGH8uqrr8q8efPkrbfekocffljWr18vgY4MPVAG/fORttka2KdvF8lOFck5IJKtU6r1MSetdFa/PEEh1qy+CfBtjyVvADjUBIiI03Y/VXWUAAAAQO2och8VFSV//fWXtG/f3mn+xo0bpUePHqbTvC1btkiXLl3M80BHQA/4oAM+7WU/xxbk65Tm8FxvAji81loA3goJd5Pt1+r+Lm4AhMdUxZECAAAANbvKffPmzeWNN96QRx991Gm+ztP3VFpamtSvX78i5QZQ2wSHiMQ2sk7SqfzlC/KOBfhO2f7ijL/tte29vCyRwjyRw7utkyfCol0E+w41AZzeSxQJjaj0xwAAAAD4mtcBvbaPP//88+Xbb7+1j0O/ZMkSU73+448/Nq8XL14s48aN83lhAdQB2mN+XFPr5In8IyWq+Lu5AWB7LMwVyc+xNhHQyRNapb/Mdv90AAgAAIDq53WVe7V161bTXn7DBuu41R06dDDt6lu1aiW1DVXugVpE/9xpRr+8av+29/TmQFGB9/sxHQA2EmnSRaTVCSItB1s7F6SdPwAAAPzVhj4/P19OP/10mT59eqk29LUVAT1Qh+mfx6Pp5Vf796QDQM3e24J7fWzUiZ78AQAAUH1t6MPCwkyHeABQJ2hGPaq+dUps710HgJm7RXYuEdn2h8iOxdZ5a7+wTrYsfstBIq0Gi7Q8QaRJVwJ8AAAAVG2V+1tuucWMMV+yU7zaigw9gErTjv52LxPZ+rvI1vkiOxZa2/E7ioy3BvY6aQY/qbu1Q0EAAADUOZlVNWzdTTfdJLNnzzZV7vv06SMxMc7DPz399NNSmxDQA/C5wnyR3SusAf62+SLb/7S27S/ZEV+LAcUZ/MEiTXvQ2R4AAEAdkVlVAf3JJ5/sfmNBQfLTTz9JbUJAD6DKFRaI7F0psvUPawZ/+wKR3EznZcJjrQG+yeAPFknuJRIS5q8SAwAAIBAD+rqGgB5AtdO2+HtXWQN8zeBv+5+1cz5HYdEizY8/1tFes94ioRH+KjEAAAACKaDftGmTbN68WU488USJiooS3Yxm6GsbAnoAfldUJLJ/TXEGX4P8/4kcOei8TGikSPP+x3rRb9ZXJCzSXyUGAABATQzo09LS5IILLpCff/7ZBPAbN26UNm3ayOWXXy7169eXp556SmoTAnoANTLAT11fHNwXV9PXXvQdhUSIpPQrzuCfYH0eHu2vEgMAAMDfw9bZernX4eu2b98unTp1ss8fN26c3HrrrbUuoAeAGkeHt2vS2Todf7WI3pc98LdDBn++SNY+a7Cvk1knTKRZH2v7ew3ytbp+uHOnpgAAAAgsXgf033//vXz33XeSkpLiNF97vd+2bZsvywYA8IQ2d2rUwTr1u8Ia4KdtLs7eF2fwD+8W2fGndfr9SZHgUGvHerZe9FscLxJRz99HAgAAgKoM6LOzsyU6unS1zYMHD5rx6QEANSDAT2xnnfpMtAb4h7ZYA3vN3muQn7FDZOdi6/THMyJBIdah8UwGXwP8ASKR8f4+EgAAAJTB6zb0o0aNMuPPP/jgg1KvXj3566+/pGXLlnLhhRdKUVGRfPzxx1Kb0IYeQK10aNux4F6n9BI1rIKCRZK6F2fwtR3+QJGo+v4qLQAAQJ2SWVWd4q1evVqGDRsmvXv3NmPOn3XWWbJmzRqToZ8/f760bdtWahMCegB1QsbO4gx+cYB/8J8SCwSJJHU91ou+BvnRDfxUWAAAUOdo2FpUYB3eVx8t+lhY4nWBm3lFzq+jG4o06SJ1dtg63eiLL74oK1eulKysLBPc33DDDdK0aVOpbQjoAdRJmXucM/hpG0sv07jLseBep9hG/igpAC8dyMqV1bsyZP/hXPNaBx3WkYusj8WT/q94NGKn98wz23Pro5kb5H47xf+3D2/suC3betZlSmzHxT5clteprA7bKbmP8spbcjsO7xWvVXZ5HT8j+/6tgoOCJCTYunyI/XntG+4ZlQ1WC0sEpRqAFpUdxJYZ2JYIYm3LeLwPL8rh1T7dBODllVMqNNq6a53PFrlgttTpcejrikAK6LV/A3dCQkIkMjLSo2WDg4MlKiqqQsvm5OSIu1NK/+Fy7H/Bm2WPHDlimnS4ExMTU6Fljx49KoWFhT5ZVstr+8c5NzdXCgoKfLKsfr76Oau8vDzJz8/3ybJ6Puh54e2yupwu7472pREaGur1svoZ6GfhTnh4uBlhw9tl9TvT784dXU6X93ZZPcf0XPPFsvoZ2Pog0WtCrw1fLOvNdV/eskFZ+yV4558SsmOBmYLT/i61jaKG7aWw+SApbD5AilIGiiW2MX8jHPA3woq/EdX7N2LbvkOyZs9hWbs3S9buOSzr9mbJ3kz3nw2qV0jxjQMN8HXSwD84SI49Bju/tt0ICA0JNjcGdH5QkMXcOLDeNLAte2z9sNAQ+w0FDRqDxFJqe1oOnRcWFiqhwcFmMBVd1mIpMvsxNyIcyqfz9Bw25QgOEktRoVnW7EeXKVGOiPBws6yWRwO+osKCYzd4Styo0TLY/p4UFRba//7Zbpo4rhMeFnZs2aIi8zfF+QbOsZtIZruhoea5fdni5YItBRJclCchhXkSYsmTsKAiCRedlytSkCtFuVnW94vyJLgwr3jZXAkqypNQS4GEOSwr+TnWZcxyuRJUvLy+NusXT0EF+t5R6/uFuWYeKq5QgqVQQqQoKFiK9NHhtT4W2udZp/2NT5B+174qdTagT09Pl0WLFsn+/ftL/SgaP3681CaBFNCXdadX+z745ptvnH6EuvtBMHToUPnll1/srxs1aiQHDpQY47pY3759ZfHixfbXrVq1cjvaQefOnU3zDJsuXbrI2rVrXS6r/TJs3brV/rpfv36yZMkSl8smJiZKamqq/fVJJ50kv/76q9sfyY6ByhlnnCFz5swRdxwvj/PPP7/MPiK0tortx/3EiRNl1qxZbpfVa0c/V6W1W15++WW3y27ZssV8ruqOO+6QJ598sswmMfq5qvvuu0/uv/9+t8vqNayfq3riiSfkzjvvdLvszz//bD5X9dJLL8mNN97odtmvv/7afK5q5syZMmnSJLfLfvjhh+ZzVR999JFccMEFbpedMWOG+VyVnstnnnmm22W1BpF+rkrP5ZNPPtntso8//rj5XJWey/3793e77NSpU83nqvRc7tq1q9tlb7/9dvO5Kj2XW7du7XbZ66+/3nyuSs/lxo0bu112woQJ5nNVei7Hxsa6Xfa8884zn2uV/I345uPiDP58WT3nNemaWPqfkg0HCmVNdgM555anrJn8uGT+RvA3gr8RVfg3IqReopx+0VVyyrkTZPXuTPlrZ7ocyCodJGjgVXBwlyRGBknv3r1MzktP5blz5zpEVya8smezGzRMlG7dulnzYxaRP+b/IUVFFod0tclXm6f14uKkU8dO9u2uWLnSBGXWv0FBTvvQm0zaXFOX0+U3bdwk+QX5DssdS4nrDZBmKSlmWbV7z27Jzy9wKGsxE/CGSmKjRPt2Dx1Kl4LCAoeyHjtGLVdMbGzxshZzM6iwsMihvMeOUR+DQ4LtZUBlWSRC8s2kAXSE5El4UEHxvDzrvCCH57qceW1bJ7/4fYcpqHi+fZs679j6jvuwLRca5P4mb01QaAmSguKA1Pro/NoEqRZbsFr82r6sPmqQGywFlmPvlVzW/trisLzTPq3zrfsKcbFMcLnlcXxt1iuxL5fltrjYv31Z66N+Hk5/AzwwsmuSvHJpH6mT49B/9dVXcskll5gfJrphxx+I+ryqAnpto3/TTTeZ/Wt24dxzz5XnnnuuzB+zasGCBXL33XfLwoULzR28nj17mmH3HDNGAAAvxSRaq6t1PltOnjBDirLTZEiLEBnaKkSGtgyVnknB0iExRDokZoh8eqV1nfqt5M1hmiGMlG3pRbIto0i2plvM833Z/DoGvBES11giktpJeJO2El78GBKTIKv1xs1Pm+zLaeY0P22n5O3dJHn7NlsfU7eIJe+IDDrvPJkx6Rr7skFXHO92f31GjZIPXrza/jrmtuFub/p1HHqifPH8T9YquhaLNGs2Rg6lpZlMrS17anveoVcv+f6JedbI32KR3r0vk127dtqrr5vlip+3bd9efvzhe+sdBYtFRp5+nWzavMlpe7ZlU5KT5bu53xYvWySXXnqrrFu31mF71qBeX9dPiJdvvv7aWl6xyOTJ/zHNSh33bXseFRkpn336ibW8YpH7H7hfli9dZq/irxloW1V8zU7Pnj2rONNdKK++8oosX7GiOINdnJG3Zb2Dg+TfU+6S0JAQc8Pl2znfyAYtr8P7toy6rn/eeedKRHiYyXavWLFMtm7ZUpyRt2bPbc913QH9+0lkRLhYiopkx/atsm/v3uJMfvGk51Px69atWkqE1l6xFElGeppkpqcfWy7IYl9enzdISJCw0CDNDkru0SOSl3tEgk3232Jfxmw7qMiU1foZFreBLiwwWfCIYPe1mvwl3xJsvX0QHGYe8ywhkpUvkmsJM89zJUyOWkIlzxIquZZQCYqINVOehElOYbAcyDxiXVZCix9DzKOuFxodL2Ex9c3zIwUiuw5kSq4uJ7rtMCkwgXuwFBaJxMQlSIOGjaxZ5cJC+eefzdabyGYqvgFhKTLzGjdqJK1atjDndWFBgSxevMjlcnrOJjdtKt27dTPfR1FRoXw751v7cnru2c5tfWyekiJDhgwurgkiMnvWzOK3nJfTqvEtW6bIWaNHS1jxuf/CC89LvtbAclquyNxga9mihUyaOMFcK1qOadMekeysLPtytrLq8s1Tmssdt99mvbaCguSeu++WtLQDpZYT/VuTnCyPP/6Y/fq+/bZbZeeOHaWW0+mGm36U2sLrDP1xxx1nMjmPPPKIy+HrqsrIkSNlz5498uqrr5oqMnpHXzMH7777bpnB/Omnny5TpkyR0aNHm2po+gf67LPP9niIvUDK0FPl3vtlqU5LddpAr05bXVXuvf4bcTRdQnYukpCdf0rYroUie1Ye+2HhgiUkQixxKRJcv4VIQnORhBaSG9VEiuJSzHxLbJJIsPUcVPyNOIa/EbX7b0SRxSJ7MvNlQ+oRWb07Q1bvzJBVuzIk82jpcyI0OEjaNY6R7slx0qeJRbrVOyLNQg5K5NE0Ccre7zClWh/zsqwBVvGPXQ3+rT96xfnHb/Fzc0baf5QfW8+2nNkWUAmW0EiR0AgJCokQCY0US2i4FAWHm3mi80LCxWJ7HhohweHREhxmXUeX00yuPreE6DqRZjndhj6GRsZKaES0mV8QFCJ5RcHF2wk3/wbZ9xEcElB/I2rt74gqjjViHP79rnNV7vXgV61aJW3atJHqsm7dOlMVU6u6aRVvpdXC9MbCzp07JTk52eV6AwYMkFNPPdUMsVdRgRTQA0CNdTRDZNcy6/B46TtEMnaIpG+3Pj+8u8xg3wgONVX2JaGlSLwG/M2LH4tvAMSlmB9lQCDTKuz/HMiWNbszZNXODBPAr9mdKYeLg/coOSqNgjKkkaRLckiGdIk7IsfFHpEW4YelcVCGxOanSXD2fpGs/dbOpAKapnODHardF7929dw+L8jFeu62IeVsr+Q2vCyTee7QdEFf601Js34Zk9Mytv2FuFnG9r6rZVxtv8S2XZanxLZLLeNi3y6XcSybq2W0uoEt6LY9hh1rjgFAqqzK/YgRI0w7xeoM6DXTnpCQYA/m1fDhw80dG61KP3bsWJftD/U9bR4waNAg2bx5s3Ts2FEefvhhGTx4sNt96R19x7v6+kECACopMl6krZt2yoX5Ipm7Sgf6Gfq4XSRjl0hRfvH87W52oA13m9qz+/ag3zzXKUUkvPpqlQHlKSgsMsH7qh0HZcv2bbJv11bJTN0lcYUHpZFkSLOgdOkZlG4C+MYR6ZIUnCFRlhIZOk2suU+uiUQnisQ2EYltbH2sp89tU2PrdVlmQFoyUC4vYC4Z7HoajLtaDwDgCa8Deu3IRjuH0Y6KtHMUW3UUGx2X3tf27t1bqgMYrS7SoEED854r//xjHUNZO6fRDoK07fzs2bNl2LBhplOg9u3bu1xv2rRpZXYSBADwMc3K1G9lnVzRasBZ+0oH+o43AAqOWjP9Ou1Y6Ho7MY1KB/qOmf5IamHBR7TyY+5ha6Y8a58UZO6RA3t2yKH9O+TIoT0SlLVPInMPSKKkyxjJlJCg4sqSpuGxu20WP4ZGFQfmSccCdadgvXienu96bQEAajWvA/qrrrrKPD7wwAOl3jMdMZTRfrCku+66Sx577LFyq9tXhK195DXXXGPvQbdXr14yb948efPNN03g7oq2t7/11ludMvTNmzevUBkAAD6gVTW1ur1OLQa4Dp6yD7gO9NOLH/MOi2SnWqfdy1zvR7OVjoG+U6a/pUhUfTKHdZ3WJikO0p0f99qfWw7vE8vhvRJceNTpx1ZS8WTncCppp1d5EQ1MUB4R31SC6jkG67bsevG88FjOQwBAxQP6sjoS8tZtt91mH2LGHa3an5SUZKrQO9IOb7Tne33PlaZNm5pHbXvvqFOnTrJ9+/YyO+DxtMM8AEANoMFNbCPr1KyP64D/aPqx4N4E+yUy/UcOWtv5711lnVwJi3FfpV+fxzS2tltFYLGdH7YA/bAG5vtKBOvF7+Wklbs5x8GTDluiJNUSL6mSIIeC64slpolEJiRJfOPmktSspSQlt5DgekkSHJMokQ6dPgIAUGUBvS/pGLu2cXbLMnDgQElPT5elS5dKnz7WH2s//fSTublw/PGuh1jRMXm1s7wNGzY4zf/7779Nj/kAgDoU8Gt2Xaem3V0vk5vlOtC33QDQYC4/WyR1vXVyRXtH1rb69mr8LZ2r9Gsb/xC//rNbNzLoWtVdp7ysY89zM0WOpFtraBx2CNBtj4Xue8QvqSgoVDJD6st+S7zszK8n+4viZb8kSKrFNsXL0chGktS0ubRvniRdm8VJt2bx0q9+tBl2CQAAX/L4l4X2KP/ee++ZnvbUo48+Ktdee63prE6lpaXJkCFDTNt6X9Osug4/p9X9p0+fboa5ufHGG+XCCy+093C/a9cu0z5e28n379/fVP/Xtv5Tp06VHj16mDb0s2bNkvXr18vHH3/s8zICAAJYRKxI407WyZX8oyIZO4uD/ZKZ/h3WTv00KDy42Tq5oj0/xzU71jO/Yy/9+lhXe+rXDHletkPwXRyAlwzI9aaL4zLm/UyHeVkiBe6HdSqXNrkobo+eH91Y0iRBtufFysacGPkrPcJM+4oS5JDE6kjb9tUaxoRL12bxJnA/oVm8dEmOl5T6UfZhBwEAqBEB/XfffefU+7uOQ3/BBRfYA3qtAl8yG+5L77zzjgniNWjX3u3PPfdcef755+3va5Cv+3ccS3Hy5MlmLMhbbrnFVM/XwP6HH36Qtm3bVlk5AQC1kI5znNjOOrntqX+36176zfOd1p76dZ5O29z11J/kXKW/ZKa/JvXUX5BbRrDtGJwXB9uOwbdTsH7Yocc3H9EhsCLqWSdtcx4RZ+300LRHd+5MLjOsoazJjJDVe3PN+O46VNyWDdnWIdZLaFwvQk7RoL1ZvMm6axCfFBdJ8A4A8BuPx6HXINqxt/l69erJypUr7cPX7du3z2TLvekULxAwDj0AoNK0/xlti23vsG9b6c77PMku6zBkTtn9Fs6Zfs0yl1mOwtLBtKvJZUBuC96LA/LCPPEprcFggvA4a40JW0DuGJTb59nej3N432F5N727H8rOMwH76l2Zsro4eN+W5nrct+T4SKfAvWtyvDSOi/TtMQMAUN3j0AMAAC9pZ3m2nvrFRd8vem9dO1xzFejbnmswnXPAOu1e7no/EcU99WumX5sAOAXjh639APiaBtMlA+qSk/19W1DuIiAPi6pU7+06rntqVq7sPZAl+zKPyr7MXNmrjxlHzaMG7rvSXd800Sry1sDdOnVJjpPEWDrIBQDUfB4H9FqdrGSVMqqYAQDgA/rvaUyidXLVU7/STt1KBfrFNwB0nvbUn5shsm+VdSqLduDnlAWP8zAoLxGQ67wq7p1dKxJmHikwQbkJ0B2CdA3a9bU+P5CV67KafEmtGkYfy7wnW7PvCdF1sO8CAEDdCuj1H1QdYs42pJu2TddO8WJiYsxrx/b1AADAx6ISrFNStzJ66teO+3ZYe3LXjLfLgDxWJLRmZJ9zCwplv0NQvjfjqOw/nGse7cF75lE5mu/ZkLmhwUGmnXuT+EjTtr1J8ZQUHyHJ8VHSsWmcxEe5ro4PAECtbkM/adIkjzY4Y8YMqU1oQw8AgHeKiixyKCfPHpTvzbAG7bbA3ZZZP5jteTv8hOgwE6RrO/akuAhrwB4fKU3qacBuDdy1x3mGhgMA1AY+b0Nf2wJ1AADgvSN5hQ7ZdOujvtZMu+P8/ELPeq4PDw2WJrYAPc4hs27PskeY15FhVVu1HwCAQESneADgA3kFRbL9YI5sOZAtWw9km+eaNTy+dQPplhIvEaEEI6jZCossph26NaNeOptum5d5tMDjbSbGhtuDdGtm3Vr93f48LtJk3umTBwCAiiGgBwAvqhHvzjhignad/knNlq1p1uc7DuZIkZuEZERosPRsnmCC+/6tG0qvFgkSE8GfX1QPbVmXlVtgr/ru2DbdFqRr0K49xGtQ74no8JDiIP1Y1XfnNuuR0ig2wmTfAQBA1eEXJQCUCH4OZOVZA/XUbPnHBO9Z1sx7Wo7JxLsTEx4irRvFSKuGMdK8QbRZf/HWg5KWnScLtxw0k8gmCQkOMkNjaYDfr5VO9ellG5Wi5+W2tGzZuD9LNu23nq+OWfacvEKPtqPNzxvVc6j+Xtw2/VhVeGuHc/UiQsmqAwAQSJ3i1VV0igfUTplH803V+C0lp9RsOZzrvkpxWEiQtGwYI60TY6RNYoy0Sjz2XAOhkkGO/ondnJoti7YcNMH9wn/SZHfG0VLb7ZhUT/oXB/j6qAEUUFJ2boFsTrUG7fYpNcuMsV5edr1eZGhxlfdIaWw6kosoURU+0oy9rjecAABAYMShBPTlIKAHAtfR/ELTll2rxlsD9izZeiDHZN21rbA7GpM3S4iyB+qtiwP3NomxkpwQKaEhlatGvPNQjgnuFxVn7bV8rsbKtgX3x7duKM0bRJERrUPSsnLtwbotcN+8P8vlzSCb2IhQadsoRto2jpW2jWLNOXwsyx4h0eFUygMAIFAQ0PsIAT1QsxUUFsmu9GPt2h3bt2t797L+wmlGvXVxtl2rytsCeK0uX509aqcezpUlmr3fYg3y1+3NLFVuDci0/b0G+P1bNZD2jWMZnivA6T+/GqBv3HfYGrA7BO+HcvLL7GhOA/Z2jZ0nzbJz0wcAgNqBgN5HCOgB/9M/U/sP59oz7dq+3fo8y2TgyxoeS9v6tikO1o9Vj4+VVonRUi8yTGqijCP5smzbIRPgayb/r53ppY5RewbXDL6tHX6X5LhK1xxA1cgv1PbtOaWCdn1eVtv2lPpR1mC9RPBOfwsAANR+mQT0vkFAD1Sf9Jw85yx78RBw+ryswEd70nbKtOvz4iC+YUx4wGctddzv5TsOyeIth2TR1jRZti1djuQXluqQr3fL+iZ7r1n8Hs0TGLfbD9+T6/bt2W5vOoUGB5kbTSWDdr0JRRV5AADqrkwCet8goAd8KyevwLRjtw33Zsu06/OyqhlrR12asTRBu71tuzXTnhwfVaeqn2vGd/WuDFM939bZXsmxwcNDgqVH83hrFf3WDaVPy/qmjTV8c+PJMWi39SyvTT/KGubNsZq87XnLhtESRs0KAABQAgG9jxDQAxULOHVc9lI9yB/Ilj1ldOqltB3wsU7ojmXdm9ePZkxrN4qKLLJh32FrgF/c2Z62y3ek9zu6JNsCfGs1/QYxVN12R/9p1OHenLLtxdXkdVhDd/Qz1Wy7dkznmHFvGhdZp246AQCAyiGg9xECetRl+ucht6DIVHfXzLo+6rBZ1tfWedm51sfd6Uetvcin5Zh27WUNoRUfFWZv1+5YPV7Hb48hi+yT702/h8XFvehrNf0dB0tnj7VjPVuAr1PT+Cipi50q6vnq2KO89iavQw1mlTF8YXJ8pHPQXpxxbxgbUa3lBwAAtRMBvY8Q0COQsuI5uYWSXRx4Owbbrl8fC84d13HeRmG5Y1u7ExUW4pxld8i61yczXO32ZByxV9HXSauJl6RD49k62tNq+jp0XqD3P+A4hKE27zg2DJy1Z3lt/pFXWOS2mYdWiS/Zvl2ry3PjCQAAVCUCeh8hoIevaYDsKtttgmiHgNv2Wh+1s61sXS63wMXrQvPaXVDiK1rdXTte0466YiJCJEofi19r+2AdAs6Wddde5HWYtdoSDNZGB7PzTNt7Wxt8bZNf8t5NYmxEcXBvnTo0qVfjq43rCAG2LLvjGO47DuW4HcIwMiz4WPt2h+C9ZcMYmnkAAAC/IKD3EQL6ut0u+WiBBt3HsttH8o9luR2z3c7BtfXRvo5DBlwDeK3CXpW012zNHmqQrdOx59bHGH2MsL5ngnN9jHB4r3idKMdlw0IYEq2WO3w0X5ZtTzfV9DXIX7EjvdRNorjIUJPBN23wWzeQbs3i/dKhm20Yw5Lt2zWAL9l3QMmmHq6GgWuWULc6VQQAADUfAb2PENAHro37DtuHOzuW/S4OtB1eOwbbOhSYY6BelTR+iCkOmPXRMYA+9toabOujPSNuf21dTrPltmBdH8kowldV1P/aqT3pp5l2+Mu2HTI3qko2q+jdMsEe5PdqXt+cl76szbLzUE6pHuW1Y7rDJXr1L9mxor16vEMAnxgb+EMYAgCAuiGTgN43COgDi2bnvly5Wz5ZulPW7sn02XbtAXVx8OwYUNsCcHvG2ynAdpEhL34dERpMcIGA6jxOrynHofJKDjMYFhJksvba/l6r6vdpVV/iIsPK3XZuQaG5+VYy4/7PgWzJc1OjRW+IaZX4tqXat8dIPQ/2CQAAUJMR0PsIAX1gZBLnrdsvnyzbKb/+nWrvxE2Di87J8VLPofq5LbttD7hLvD4WsBdnyCNCJDI0hOq4gIsmKVrFXbP3tmr6OsybI71f1Skpzt4Gv3tKvLnpZqseb9q5788yvcy763tRa5xoR4qOQbtOOiJCZJjvagMAAADUJAT0PkJAXzPpaavtfTWI/3rlbsl0qH7bo3mCnNu7mYzunkxv6kA1XpM6NN4i09Femgnwdeg8T9WLDHXZvj2lfrTpbR4AAKAuyfQwDmXcHQSUHQdz5PPlu+TT5btMFV2bpvGRMrZXMzmndzNp17ieX8sI1EXafKRFw2gzndcnxczbn3m0OMC3Thv2HZZGsRHO2fbiAF5HSaAJCgAAgHcI6FHjZeUWyJxVe+TTZTvlz38OOnXINbJrkpzbJ0UGtGlIFg+oYRrHRcqZ3ZPNpLQ5DNcpAACA7xDQo0bSH/7/23zAdG43d81eOZpv7RhLE3gD2zSUc3qnmGBeO5gDEBgI5gEAAHyLaAg1bqi5T5btMtXqHTvY0k6xNBM/plczM2Y0AAAAANR1BPTwu4PZefLlCmu7eB332iY+KkxG92gq5/ZOkZ7NE2hfCwAAAAAOCOjhFzq29E/rrUPN/bx+vxQUj1kVGhwkJ3VobHqpP6VTY4kIZVgqAAAAAHCFgB7VOqyVZuA1iP9y5W5Jz8m3v9e1WZzJxI/ukSyJsRF+LScAAAAABAICelS5PRlH5LPlu0wHd5tTjw0117heRPFQcynSIYmh5gAAAADAGwT0qBI5eQUyd/Ve+XTZLpm/+YBYrDXqJSI0WEZ0sQ41d0LbhhIaEuzvogIAAABAQCKgh88UFVnkzy1p8snSXfLt6j2Sk1dof69/6wamXfyobk2lXmSYX8sJAAAAALUBAT0q7Z/ULJOJ12r1u9KP2Oe3bBgt5/RKMdXqWzSM9msZAQAAAKC2IaBHhaTn5MlXf+2RT5ftlOXb0+3z60WEypnFQ831aVmfoeYAAAAAoIoQ0MNj+YVF8uuGVNNL/bx1+yWvsMjMDwkOkhPbJ5rO7U7t3EQiwxhqDgAAAACqGgE9yh1qbs3uTOtQcyt2S1p2nv29jkn15Lw+KXJWz2RpXC/Sr+UEAAAAgLqGgB4u7cs8Kp8v32Xaxm/Yd9g+PzE2XM7u2cxUqe+cHOfXMgIAAABAXUZAD7sjeYXy/dq98smyXfLHxlQpKh5qLjw02FSl117qh7RvJGEMNQcAAAAAfkdAX8dplfrFWw/JJ0t3ypxVe+RwboH9Pe3UTjPxZ3RrKvHRDDUHAAAAADUJAX0dtS0t21Sn/3T5Ttlx8NhQc80SokwmfmzvFGmdGOPXMgIAAAAA3COgr0Myj+bLN8VDzWlW3iYmPERGdWsq5/ZJkf6tGkhwMEPNAQAAAEBNR0BfyxUUFsnvmw6YKvU/rN0nuQXWoeZ0ePjB7RJNlfoRXZIkKpyh5gAAAAAgkBDQ11Lr9mSaTPznK3ZL6uFc+/z2jWNNJn5Mz2aSFM9QcwAAAAAQqAjoaxEN3L9YYR1qbu2eTPv8+tFhZqi5c3o3k27N4iVI0/MAAAAAgIBGQF8L5OQVyI3vLpdf/06VwuKx5sJCgmRYxyYmiD+pQ2Mz9BwAAAAAoPYgoK8FosNDZXf6ERPM92ieYHqpH909WerHhPu7aAAAAACAKkJAX0s8OKarqVrfrnE9fxcFAAAAAFANCOhriX6tGvi7CAAAAACAakTDagAAAAAAAlDABPQHDx6USy65ROLi4iQhIUGuuOIKycrKKnOdvXv3ymWXXSZJSUkSExMjvXv3lk8++aTaygwAAAAAgNT1gF6D+TVr1sgPP/wgX3/9tfz2229y9dVXl7nO+PHjZcOGDfLll1/KqlWr5JxzzpELLrhAli9fXm3lBgAAAACgKgRZLBbrOGc12Lp166Rz586yePFi6du3r5k3d+5cGTVqlOzcuVOSk5NdrhcbGyuvvPKKydLbNGzYUB577DG58sorPdp3ZmamxMfHS0ZGhqkdAAAAAABAVfI0Dg2IDP2CBQtMNXtbMK+GDx8uwcHBsnDhQrfrDRo0SD744ANTXb+oqEjef/99OXr0qJx00knVVHIAAAAAAOpwL/faFr5x48ZO80JDQ6VBgwbmPXc+/PBDGTdunMnK6/LR0dHy2WefSbt27dyuk5ubaybHOyMAAAAAANQ0fs3Q33XXXRIUFFTmtH79+gpv/5577pH09HT58ccfZcmSJXLrrbeaNvTant6dadOmmaoNtql58+YV3j8AAAAAALWyDX1qaqqkpaWVuUybNm3k7bfflttuu00OHTpkn19QUCCRkZHy0UcfydixY0utt3nzZpOJX716tXTp0sWpqr7Onz59uscZeg3qaUMPAAAAAKhJbej9WuW+UaNGZirPwIEDTaZ96dKl0qdPHzPvp59+Mu3ijz/+eJfr5OTkmEdtZ+8oJCTErOdORESEmQAAAAAAqMkColO8Tp06yemnny5XXXWVLFq0SObPny833nijXHjhhfYe7nft2iUdO3Y07yt9rpn4a665xszTjP1TTz1lhr0bM2aMn48IAAAAAIA6ENCrd955xwTpw4YNM8PVDR48WF577TX7+/n5+WbMeVtmPiwsTObMmWNqAIwePVq6d+8us2fPllmzZpn1AQAAAAAIZAExDr0/MQ49AAAAAKA61apx6AEAAAAAgDMCegAAAAAAAhABPQAAAAAAAYiAHgAAAACAAERADwAAAABAACKgBwAAAAAgABHQAwAAAAAQgAjoAQAAAAAIQAT0AAAAAAAEIAJ6AAAAAAACEAE9AAAAAAABiIAeAAAAAIAAREAPAAAAAEAAIqAHAAAAACAAEdADAAAAABCACOgBAAAAAAhABPQAAAAAAAQgAnoAAAAAAAIQAT0AAAAAAAGIgB4AAAAAgABEQA8AAAAAQAAioAcAAAAAIAAR0AMAAAAAEIAI6AEAAAAACEAE9AAAAAAABCACegAAAAAAAhABPQAAAAAAAYiAHgAAAACAAERADwAAAABAACKgBwAAAAAgABHQAwAAAAAQgAjoAQAAAAAIQAT0AAAAAAAEIAJ6AAAAAAACEAE9AAAAAAABiIAeAAAAAIAAREAPAAAAAEAAIqAHAAAAACAAEdADAAAAABCACOgBAAAAAAhABPQAAAAAAAQgAnoAAAAAAAIQAT0AAAAAAAGIgB4AAAAAgABEQA8AAAAAQAAioAcAAAAAIAAR0AMAAAAAEIAI6AEAAAAACEAE9AAAAAAABCACegAAAAAAAhABPQAAAAAAAShgAvqHH35YBg0aJNHR0ZKQkODROhaLRe69915p2rSpREVFyfDhw2Xjxo1VXlYAAAAAAKpawAT0eXl5cv7558t1113n8TqPP/64PP/88zJ9+nRZuHChxMTEyIgRI+To0aNVWlYAAAAAAKpakEXT2AFk5syZMnnyZElPTy9zOT2s5ORkue222+T222838zIyMqRJkyZmGxdeeKFH+8vMzJT4+HizblxcnE+OAQAAAACAysahoVJLbdmyRfbu3Wuq2dvoB3L88cfLggUL3Ab0ubm5ZrLRD9D2gQIAAAAAUNVs8Wd5+fdaG9BrMK80I+9IX9vec2XatGly//33l5rfvHnzKiglAAAAAACuHT582CSma2RAf9ddd8ljjz1W5jLr1q2Tjh07VluZpkyZIrfeeqv9dVFRkRw8eFAaNmwoQUFBpZbv16+fLF682Kt9eLuOJ8vrHRy96bBjxw6aBlTy+6nt5auqffpqu5XZTkXX9WY9T5flmnSNa7L69heo1yT/RlYfrsfq22egXo/erse/kZXDNVl9++sXANekZuY1mNdm5GXxa0Cv7dsnTpxY5jJt2rSp0LaTkpLM4759+0wv9zb6umfPnm7Xi4iIMJOjsnrVDwkJ8foPkbfreLO8Lscfxsp9P7W9fFW1T19ttzLbqei63qzn7T64Jp1xTVbf/gL1muTfyOrD9Vh9+wzU69Hb9fg3snK4JqtvfyEBck2WlZmvEQF9o0aNzFQVWrdubYL6efPm2QN4vRuovd1701N+eW644YYqX6ci+0BgfHb+KF9V7dNX263Mdiq6rjfr1fRzqqar6Z9fdZevKvcXqNck/0ZWn5r+2fFvpG+3w7+RNV9N//z4N7JmXJMB28v99u3bTdX3L7/8Up544gn5/fffzfx27dpJbGysea5V87UN/NixY81rrc7/6KOPyqxZs0yAf88998hff/0la9eulcjISKlN6I0fqFm4JoGag+sRqFm4JgHfCZhO8e69914TmNv06tXLPP78889y0kknmecbNmyw90qv7rzzTsnOzparr77aDHM3ePBgmTt3bq0L5pU2E5g6dWqp5gIA/INrEqg5uB6BmoVrEvCdgMnQAwAAAACAY4IdngMAAAAAgABBQA8AAAAAQAAioAcAAAAAIAAR0AMAAAAAEIAI6AEAAAAACEAE9HXE2LFjpX79+nLeeef5uyhAnbZjxw4z1Gbnzp2le/fu8tFHH/m7SECdpsPa9u3bV3r27Cldu3aV//73v/4uElDn5eTkSMuWLeX222/3d1GAGo9h6+qIX375RQ4fPiyzZs2Sjz/+2N/FAeqsPXv2yL59+0zwsHfvXunTp4/8/fffEhMT4++iAXVSYWGh5ObmSnR0tGRnZ5ugfsmSJdKwYUN/Fw2os+6++27ZtGmTNG/eXJ588kl/Fweo0cjQ1xGaEaxXr56/iwHUeU2bNjXBvEpKSpLExEQ5ePCgv4sF1FkhISEmmFca2Gueg1wH4D8bN26U9evXy8iRI/1dFCAgENAHgN9++01Gjx4tycnJEhQUJJ9//nmpZV566SVp1aqVREZGyvHHHy+LFi3yS1mB2s6X1+PSpUtNdlAzEAD8d01qtfsePXpISkqK3HHHHeZGGwD/XI9azX7atGnVWGogsBHQBwCtAqg/NPQPoCsffPCB3HrrrTJ16lRZtmyZWXbEiBGyf//+ai8rUNv56nrUrPz48ePltddeq6aSA7WTL67JhIQEWblypWzZskXeffdd0ywGQPVfj1988YUcd9xxZgLgIW1Dj8ChX9lnn33mNK9///6WG264wf66sLDQkpycbJk2bZrTcj///LPl3HPPrbayArVdRa/Ho0ePWoYMGWKZPXt2tZYXqO0q82+kzXXXXWf56KOPqrysQG1XkevxrrvusqSkpFhatmxpadiwoSUuLs5y//33V3vZgUBChj7A5eXlmWq7w4cPt88LDg42rxcsWODXsgF1jSfXo/7GmThxopxyyily2WWX+bG0QO3nyTWp2XjtNFZlZGSYKsMdOnTwW5mBunw9alV7HQ1m69atpjO8q666Su69914/lhqo+QjoA9yBAwdMG9wmTZo4zdfX2oO2jf6xPP/882XOnDmmjSDBPuCf63H+/PmmyqG2K9TO8XRatWqVn0oM1G6eXJPbtm2TIUOGmKq/+njTTTdJt27d/FRioPby9DcrAO+Eerk8AtSPP/7o7yIAEJHBgwdLUVGRv4sBoFj//v1lxYoV/i4GgBK0NhuA8pGhD3DaE68OuVOyAx99rUNiAag+XI9AzcI1CdQcXI9A1SCgD3Dh4eHSp08fmTdvnn2eZv/09cCBA/1aNqCu4XoEahauSaDm4HoEqgZV7gNAVlaWbNq0yf5ah9XR6oENGjSQFi1amOE/JkyYIH379jVVB5999lkzbMikSZP8Wm6gNuJ6BGoWrkmg5uB6BPzA393so3w63Jx+VSWnCRMm2Jd54YUXLC1atLCEh4ebIUH+/PNPv5YZqK24HoGahWsSqDm4HoHqF6T/8ceNBAAAAAAAUHG0oQcAAAAAIAAR0AMAAAAAEIAI6AEAAAAACEAE9AAAAAAABCACegAAAAAAAhABPQAAAAAAAYiAHgAAAACAAERADwAAAABAACKgBwCgjtq6dasEBQXJihUrpKZYv369DBgwQCIjI6Vnz55erz9x4kQZM2ZMlZQNAICahoAeAAA/0eBTA+pHH33Uaf7nn39u5tdFU6dOlZiYGNmwYYPMmzfPL2WYOXOmJCQk+GXfAAB4g4AeAAA/0kz0Y489JocOHZLaIi8vr8Lrbt68WQYPHiwtW7aUhg0b+rRcAADUNgT0AAD40fDhwyUpKUmmTZvmdpn77ruvVPXzZ599Vlq1alWqqvkjjzwiTZo0MRnmBx54QAoKCuSOO+6QBg0aSEpKisyYMcNlNfdBgwaZmwtdu3aVX3/91en91atXy8iRIyU2NtZs+7LLLpMDBw7Y3z/ppJPkxhtvlMmTJ0tiYqKMGDHC5XEUFRWZMmk5IiIizDHNnTvX/r7WSli6dKlZRp/rcbvy8ccfS7du3SQqKsoE/foZZmdnOy3z5JNPStOmTc37N9xwg+Tn59vf05sn48ePl/r160t0dLQ5to0bN5r3fvnlF5k0aZJkZGSYMjiW4+WXX5b27dubz0k/h/POO8/NNwYAQPUgoAcAwI9CQkJMEP7CCy/Izp07K7Wtn376SXbv3i2//fabPP3006b6+plnnmkC14ULF8q1114r11xzTan9aMB/2223yfLly2XgwIEyevRoSUtLM++lp6fLKaecIr169ZIlS5aYAHzfvn1ywQUXOG1j1qxZEh4eLvPnz5fp06e7LN9zzz0nTz31lAm2//rrLxP4n3XWWfZges+ePdKlSxdTFn1+++23l9qGzr/ooovk8ssvl3Xr1pkA/JxzzhGLxWJf5ueffzaZfn3UcmkVep0cb37osXz55ZeyYMECs+6oUaNM0K83NvRmSVxcnNmXrRy6/M0332xuNmhzAP0cTjzxxEp9XwAAVJoFAAD4xYQJEyxnn322eT5gwADL5Zdfbp5/9tlnGp3al5s6daqlR48eTus+88wzlpYtWzptS18XFhba53Xo0MEyZMgQ++uCggJLTEyM5b333jOvt2zZYvbz6KOP2pfJz8+3pKSkWB577DHz+sEHH7ScdtppTvvesWOHWW/Dhg3m9dChQy29evUq93iTk5MtDz/8sNO8fv36Wa6//nr7az1OPV53li5dava9detWl+/bPgc9Vpvzzz/fMm7cOPP877//NuvPnz/f/v6BAwcsUVFRlg8//NC8njFjhiU+Pt5pu5988oklLi7OkpmZWe5xAgBQXcjQAwBQA2g7es0ma9a5ojS7HRx87J92rRauVdMdawNoFfT9+/c7radZeZvQ0FDp27evvRwrV640mW6tbm+bOnbsaN7TLLhNnz59yixbZmamqT1wwgknOM3X194cc48ePWTYsGHmuM4//3z573//W6r/Af0c9FhttOq97Zh1X3qMxx9/vP19/Uw6dOhQZjlOPfVU066/TZs2psnBO++8Izk5OR6XGwCAqkBADwBADaDVt7UK+pQpU0q9p0G6Y5Vy5dgm3CYsLMzptbb/djVP27J7Kisry1TB16HtHCetJu9Y5Vx7pq8OGqj/8MMP8u2330rnzp1NUwUNxrds2WJfprLH7Eq9evVk2bJl8t5775kbBPfee6+5uaBNEgAA8BcCegAAaggdvu6rr74y7bodNWrUSPbu3esU1Pty7Pg///zT/lw70dOO6Tp16mRe9+7dW9asWWM64GvXrp3T5E0Qr23Sk5OTTRt7R/paA3NvaICumf3777/ftPvXtvufffaZR+vqcekxap8CNtpfgLaLt5VDt1dYWFhqXc3sawd8jz/+uOkDYOvWrabfAgAA/CXUb3sGAABOtBr5JZdcIs8//7zTfO1FPjU11QSS2rO6dsimGWoNkn3hpZdeMr23a7D7zDPPmCrs2umc0h7itVq7dkR35513mt7yN23aJO+//768/vrrTlXby6Od72lHfW3btjU93GuP+3pjQquve0oDcR2f/rTTTpPGjRub1/rZ2G5AlEeP8+yzz5arrrpKXn31VZN5v+uuu6RZs2ZmvtKbF1ozQfejWXjtCV8D93/++cfUStBOBufMmWOy/lo7AAAAfyFDDwBADaK9qJesHq7Bqg6ZpoG3BpiLFi1y2QN8ZWoG6KTb/uOPP0zv7zr8nLJl1TVjrUG03nTQ4el0WDzH9vqe0F7ib731VtOLvW5Hb0zovjTI9pTexNBe/LVX+uOOO07+85//mJ7zdeg5T+mNBG3zryMAaP8BWvNBA3RbVX3t6V5HBBg3bpypHaE3UvR4P/30U9Pjv34f2pO/Vr/X9voAAPhLkPaM57e9AwAAAACACiFDDwAAAABAACKgBwAAAAAgABHQAwAAAAAQgAjoAQAAAAAIQAT0AAAAAAAEIAJ6AAAAAAACEAE9AAAAAAABiIAeAAAAAIAAREAPAAAAAEAAIqAHAAAAACAAEdADAAAAABCACOgBAAAAAJDA8/++E9pJ+IEitwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1200x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## This cell runs the cnot noisy simulation\n",
    "\n",
    "noisy_backend = AerBackend(\n",
    "    noise_model=noise_model\n",
    ")  # this defaults to no noise, which is the same as NoiseModel.is_ideal\n",
    "noisy_energies = []\n",
    "\n",
    "# rebuild protocol/circuits for new noisy backend\n",
    "protocol_template = PauliAveraging(\n",
    "    noisy_backend,\n",
    "    shots_per_circuit=10,\n",
    "    pauli_partition_strategy=PauliPartitionStrat.CommutingSets,\n",
    ")\n",
    "protocol_template.build(p, ansatz, hamiltonian.qubit_encode()).compile_circuits()\n",
    "protocol_pickle = protocol_template.dumps()\n",
    "\n",
    "for i in set_shots:\n",
    "    protocol = PauliAveraging.loads(protocol_pickle, noisy_backend)\n",
    "    protocol.shots_per_circuit = i\n",
    "    protocol.run(seed=set_seed)\n",
    "    aer_expectation = protocol.evaluate_expectation_value(\n",
    "        ansatz, hamiltonian.qubit_encode()\n",
    "    )\n",
    "    noisy_energies.append(aer_expectation)\n",
    "\n",
    "plt.plot(set_shots, shotless_energies, label=\"AerStateBackend\", color=\"black\", ls=\"--\")\n",
    "plt.plot(set_shots, noiseless_energies, label=\"AerBackend\")\n",
    "plt.plot(set_shots, noisy_energies, label=\"Stochastic + CNOT error Aer\")\n",
    "plt.xscale(\"log\")\n",
    "plt.ylim([-1, 0])\n",
    "plt.xlabel(\"Number of shots\")\n",
    "plt.ylabel(\"Energy (Ha)\")\n",
    "plt.title(\n",
    "    \"Convergence behavior of the expectation value for \"\n",
    "    + r\"$\\theta=$%.5f\" % list(p.values())[0]\n",
    ")\n",
    "plt.legend()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final plot shows that noisy operations lead to a shift in the total expectation value due to biasing. Increasing the number of shots should increase precision but not accuracy without the use of error mitigation methods. \n",
    "\n",
    "This tutorial has demonstrated the use of freely available Qiskit backends to evaluate a simple quantum system. The final example adds a simple model of quantum noise. \n",
    "\n",
    "This is the first part of this tutorial, and for the second part we examine the use of a [Quantinuum hardware emulator](InQ_htut_Hser_H2.ipynb) involving a more complex and realistic noise model, and the use of noise mitigation."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}