diff --git a/docs/notebooks/adapt-vqe.ipynb b/docs/notebooks/adapt-vqe.ipynb
new file mode 100644
index 0000000..daf6eff
--- /dev/null
+++ b/docs/notebooks/adapt-vqe.ipynb
@@ -0,0 +1,1313 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Qiskit ADAPT-VQE tutorial\n",
+    "\n",
+    "[ADAPT-VQE](https://www.nature.com/articles/s41467-019-10988-2) is a variation of the original VQE algorithm, which grows the ansatz at each iteration by selecting operators from an operator pool. This typically results in shorter depth circuits than fixed-depth ansatze designed for VQE. For a ground state estimation problem from the quantum chemistry domain, steps are outlined as follows.\n",
+    "\n",
+    "1. We find the fermionic Hamiltonian by defining the molecular geometry, and map it onto qubit representation using a mapper such as the Jordan-Wigner transform. \n",
+    "2. The quantum computer is typically initiated in the Hartree-Fock state under the same transformation as an estimate to the ground state energy.\n",
+    "3. We define the pool of operators as the set of excitation operators generated by the UCC ansatz. Note that under the Jordan-Wigner transformation, these operators are anti-Hermitian.\n",
+    "4. Until the algorithm terminates:\n",
+    "    - we compute the gradient of each operator from the pool and select the operator with the maximum gradient,\n",
+    "    - grow the ansatz with $\\textrm{exp}(j*\\theta_i*\\textrm{operator}_i)$,\n",
+    "    - run VQE over all parameters $\\theta_i$,\n",
+    "    - and terminate the algorithm if the gradient of all operators from the pool are smaller than some threshold (convergence) or if we reach the maximum number of allowed iterations.\n",
+    "\n",
+    "We note the following variants of the ADAPT-VQE algorithm:\n",
+    "- A hardware-efficient variant called [qubit-ADAPT-VQE](https://arxiv.org/abs/1911.10205), which reduces the circuit depth by constructing the pool directly with individual Pauli operators.\n",
+    "- A [utility scale ADAPT-VQE experiment](https://arxiv.org/abs/2308.04481) for the Schwinger model using up to 100 qubits of IBM Quantum devices.\n",
+    "\n",
+    "In the following, we define the problem and implement the algorithm using Qiskit Patterns formalism in 4 steps:\n",
+    "1. Map classical inputs to a quantum problem\n",
+    "2. Optimize problem for quantum execution\n",
+    "3. Execute using Qiskit Primitives\n",
+    "4. Post-process and return result in classical format\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Define the molecule\n",
+    "We start by defining the molecule using ``pyscf``. As an example we select LiH and build it by providing its geometry.\n",
+    "Code to generate additional molecules can be found in at [``Example_Molecules.ipynb``](https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<pyscf.gto.mole.Mole at 0x7fd090930d90>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from pyscf import ao2mo, gto, mcscf, scf\n",
+    "\n",
+    "# LiH\n",
+    "distance = 1.59\n",
+    "mol = gto.Mole()\n",
+    "mol.build(\n",
+    "    verbose=0,\n",
+    "    atom=[[\"Li\", (0, 0, 0)], [\"H\", (0, 0, distance)]],\n",
+    "    basis=\"sto-6g\",\n",
+    "    spin=0,\n",
+    "    charge=0,\n",
+    "    symmetry=\"Coov\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Nuclear energy: 0.998447567773585\n",
+      "Electronic energy: -8.950577623117868\n",
+      "Total energy: -7.952130055344282\n",
+      "Total energy - nuclear energy: -8.950577623117868\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Nuclear energy: {mol.energy_nuc()}\")\n",
+    "print(f\"Electronic energy: {mol.energy_elec()[0]}\")\n",
+    "print(f\"Total energy: {mol.energy_tot()}\")\n",
+    "print(f\"Total energy - nuclear energy: {mol.energy_tot() - mol.energy_nuc()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generate the fermionic Hamiltonian\n",
+    "We generate the fermionic Hamiltonian consisting of creation and annihilation operators. Single-electron (h1e) and double-electron (h2e) operators are extracted below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mf = scf.RHF(mol)\n",
+    "E1 = mf.kernel()\n",
+    "mx = mcscf.CASCI(mf, ncas=5, nelecas=(1, 1))\n",
+    "cas_space_symmetry = {\"A1\": 3, \"E1x\": 1, \"E1y\": 1}\n",
+    "mo = mcscf.sort_mo_by_irrep(mx, mf.mo_coeff, cas_space_symmetry)\n",
+    "E2 = mx.kernel(mo)[:2]\n",
+    "\n",
+    "h1e, ecore = mx.get_h1eff()\n",
+    "h2e = ao2mo.restore(1, mx.get_h2eff(), mx.ncas)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Qiskit Patterns Step 1: Map classical inputs to a quantum problem\n",
+    "We will map the Hamiltonian operator, the initial state and the operator pool of the ansatz to a quantum problem using the Jordan-Wigner transform. We also define functions to compute gradients and the cost of these operators."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Map the fermionic Hamiltonian to a qubit operator\n",
+    "Now, we map the fermionic Hamiltonian to a qubit Hamiltonian using the Jordan-Wigner transformation. Here, we implement the Jordan-Wigner mapper directly using only ``PySCF``, ``numpy``, and ``Qiskit``, as implemented [here](https://learning.quantum.ibm.com/course/quantum-chemistry-with-vqe/the-hamiltonian)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ------------Loading packages and defining necessary functions for mapping the fermionic Hamiltonian to one usable on IBM Quantum Systems---------------------\n",
+    "\n",
+    "import numpy as np\n",
+    "from qiskit.quantum_info import SparsePauliOp\n",
+    "\n",
+    "\n",
+    "def cholesky(V, eps):\n",
+    "    # see https://arxiv.org/pdf/1711.02242.pdf section B2\n",
+    "    # see https://arxiv.org/abs/1808.02625\n",
+    "    # see https://arxiv.org/abs/2104.08957\n",
+    "    no = V.shape[0]\n",
+    "    chmax, ng = 20 * no, 0\n",
+    "    W = V.reshape(no**2, no**2)\n",
+    "    L = np.zeros((no**2, chmax))\n",
+    "    Dmax = np.diagonal(W).copy()\n",
+    "    nu_max = np.argmax(Dmax)\n",
+    "    vmax = Dmax[nu_max]\n",
+    "    while vmax > eps:\n",
+    "        L[:, ng] = W[:, nu_max]\n",
+    "        if ng > 0:\n",
+    "            L[:, ng] -= np.dot(L[:, 0:ng], (L.T)[0:ng, nu_max])\n",
+    "        L[:, ng] /= np.sqrt(vmax)\n",
+    "        Dmax[: no**2] -= L[: no**2, ng] ** 2\n",
+    "        ng += 1\n",
+    "        nu_max = np.argmax(Dmax)\n",
+    "        vmax = Dmax[nu_max]\n",
+    "    L = L[:, :ng].reshape((no, no, ng))\n",
+    "    print(\n",
+    "        \"accuracy of Cholesky decomposition \",\n",
+    "        np.abs(np.einsum(\"prg,qsg->prqs\", L, L) - V).max(),\n",
+    "    )\n",
+    "    return L, ng\n",
+    "\n",
+    "\n",
+    "def identity(n):\n",
+    "    return SparsePauliOp.from_list([(\"I\" * n, 1)])\n",
+    "\n",
+    "\n",
+    "def creators_destructors(n, mapping=\"jordan_wigner\"):\n",
+    "    c_list = []\n",
+    "    if mapping == \"jordan_wigner\":\n",
+    "        for p in range(n):\n",
+    "            if p == 0:\n",
+    "                l, r = \"I\" * (n - 1), \"\"\n",
+    "            elif p == n - 1:\n",
+    "                l, r = \"\", \"Z\" * (n - 1)\n",
+    "            else:\n",
+    "                l, r = \"I\" * (n - p - 1), \"Z\" * p\n",
+    "            cp = SparsePauliOp.from_list([(l + \"X\" + r, 0.5), (l + \"Y\" + r, -0.5j)])\n",
+    "            c_list.append(cp)\n",
+    "    else:\n",
+    "        raise ValueError(\"Unsupported mapping.\")\n",
+    "    d_list = [cp.adjoint() for cp in c_list]\n",
+    "    return c_list, d_list\n",
+    "\n",
+    "\n",
+    "def build_hamiltonian(ecore: float, h1e: np.ndarray, h2e: np.ndarray) -> SparsePauliOp:\n",
+    "    ncas, _ = h1e.shape\n",
+    "\n",
+    "    C, D = creators_destructors(2 * ncas, mapping=\"jordan_wigner\")\n",
+    "    Exc = []\n",
+    "    for p in range(ncas):\n",
+    "        Excp = [C[p] @ D[p] + C[ncas + p] @ D[ncas + p]]\n",
+    "        for r in range(p + 1, ncas):\n",
+    "            Excp.append(\n",
+    "                C[p] @ D[r] + C[ncas + p] @ D[ncas + r] + C[r] @ D[p] + C[ncas + r] @ D[ncas + p]\n",
+    "            )\n",
+    "        Exc.append(Excp)\n",
+    "\n",
+    "    # low-rank decomposition of the Hamiltonian\n",
+    "    Lop, ng = cholesky(h2e, 1e-6)\n",
+    "    t1e = h1e - 0.5 * np.einsum(\"pxxr->pr\", h2e)\n",
+    "\n",
+    "    H = ecore * identity(2 * ncas)\n",
+    "    # one-body term\n",
+    "    for p in range(ncas):\n",
+    "        for r in range(p, ncas):\n",
+    "            H += t1e[p, r] * Exc[p][r - p]\n",
+    "    # two-body term\n",
+    "    for g in range(ng):\n",
+    "        Lg = 0 * identity(2 * ncas)\n",
+    "        for p in range(ncas):\n",
+    "            for r in range(p, ncas):\n",
+    "                Lg += Lop[p, r, g] * Exc[p][r - p]\n",
+    "        H += 0.5 * Lg @ Lg\n",
+    "\n",
+    "    return H.chop().simplify()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "accuracy of Cholesky decomposition  1.1796119636642288e-16\n",
+      "The Hamiltonian consists of 276 10-qubit Pauli operators.\n"
+     ]
+    }
+   ],
+   "source": [
+    "H = build_hamiltonian(ecore, h1e, h2e)\n",
+    "print(f\"The Hamiltonian consists of {len(H)} {2 * mx.ncas}-qubit Pauli operators.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Initial state\n",
+    "A common strategy is to initiate the quantum computer to the Hartree-Fock state, which we implement using the functions below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit import QuantumCircuit\n",
+    "\n",
+    "\n",
+    "def hartree_fock_bitstring(num_spatial_orbitals: int, num_particles: tuple[int, int]) -> list[bool]:\n",
+    "    \"\"\"Compute the bitstring representing the Hartree-Fock state for the specified system.\n",
+    "    Args:\n",
+    "        num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n",
+    "        num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n",
+    "                       electrons in the first and second number, respectively.\n",
+    "    Returns:\n",
+    "        The bitstring representing the state of the Hartree-Fock state as array of bools.\n",
+    "    Raises:\n",
+    "        ValueError: If the total number of particles is larger than the number of orbitals.\n",
+    "    \"\"\"\n",
+    "    # validate the input\n",
+    "    assert num_spatial_orbitals >= 1\n",
+    "    num_alpha, num_beta = num_particles\n",
+    "\n",
+    "    if any(n > num_spatial_orbitals for n in num_particles):\n",
+    "        raise ValueError(\"# of particles must be less than or equal to # of orbitals.\")\n",
+    "\n",
+    "    half_orbitals = num_spatial_orbitals\n",
+    "    bitstr = np.zeros(2 * num_spatial_orbitals, bool)\n",
+    "    bitstr[:num_alpha] = True\n",
+    "    bitstr[half_orbitals : (half_orbitals + num_beta)] = True\n",
+    "\n",
+    "    return bitstr.tolist()\n",
+    "\n",
+    "\n",
+    "def hartree_fock_circuit(\n",
+    "    num_spatial_orbitals: int, num_particles: tuple[int, int]\n",
+    ") -> QuantumCircuit:\n",
+    "    \"\"\"Prepare the quantum circuit under the Jordan-Wigner transform from the bitstring representing\n",
+    "    the Hartree-Fock state for the specified system.\n",
+    "    Args:\n",
+    "        num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n",
+    "        num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n",
+    "                       electrons in the first and second number, respectively.\n",
+    "    Returns:\n",
+    "        The quantum circuit preparing the Hartree-Fock state under the Jordan-Wigner transform.\n",
+    "    \"\"\"\n",
+    "    # Get the Hartree-Fock initial state in boolean bitstring representation\n",
+    "    hf_bitstring = hartree_fock_bitstring(num_spatial_orbitals, num_particles)\n",
+    "\n",
+    "    # Under the Jordan-Wigner transform, corresponding circuit is found by flipping the qubits by an\n",
+    "    # X-gate as indicated by the boolean list\n",
+    "    hf_circuit = QuantumCircuit(len(hf_bitstring))\n",
+    "    for i, hf_bit in enumerate(hf_bitstring):\n",
+    "        if hf_bit:\n",
+    "            hf_circuit.x(i)\n",
+    "\n",
+    "    return hf_circuit"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We build the circuit preparing the Hartree-Fock state in Jordan-Wigner transform."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 203.885x869.556 with 1 Axes>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num_spatial_orbitals = mx.ncas\n",
+    "num_particles = mx.nelecas\n",
+    "\n",
+    "hf_circuit = hartree_fock_circuit(num_spatial_orbitals, num_particles)\n",
+    "hf_circuit.draw(output=\"mpl\", style=\"iqp\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Operator pool\n",
+    "We define the set of operators as the single and double excitation operators generated by the UCC ansatz. These operators are also represented under the Jordan-Wigner transform. Note that this results in anti-Hermitian excitation operators, but we multiply them with the complex phase 1j so that they appear Hermitian."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def single_excitation(\n",
+    "    num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\"\n",
+    ") -> list[SparsePauliOp]:\n",
+    "    \"\"\"Compute single excitation operators under the Jordan-Wigner transform\n",
+    "    (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n",
+    "    Args:\n",
+    "        num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n",
+    "        num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n",
+    "                       electrons in the first and second number, respectively.\n",
+    "    Returns:\n",
+    "        A list of single excitation operators under the Jordan-Wigner transform.\n",
+    "    \"\"\"\n",
+    "    C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n",
+    "\n",
+    "    num_alpha, num_beta = num_particles\n",
+    "    half_orbitals = num_spatial_orbitals\n",
+    "    indices_alpha = list(range(num_alpha))\n",
+    "    indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n",
+    "\n",
+    "    single_excitation_operators = []\n",
+    "\n",
+    "    for p in indices_alpha:\n",
+    "        for r in range(p + 1, half_orbitals):\n",
+    "            if r not in indices_alpha:\n",
+    "                exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n",
+    "                single_excitation_operators.append(exc)\n",
+    "\n",
+    "    for p in indices_beta:\n",
+    "        for r in range(p + 1, 2 * half_orbitals):\n",
+    "            if r not in indices_beta:\n",
+    "                exc = 1j * (C[p] @ D[r] - C[r] @ D[p]).simplify()\n",
+    "                single_excitation_operators.append(exc)\n",
+    "\n",
+    "    return single_excitation_operators"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def double_excitation(\n",
+    "    num_spatial_orbitals: int, num_particles: tuple[int, int], mapping=\"jordan-wigner\"\n",
+    ") -> list[SparsePauliOp]:\n",
+    "    \"\"\"Compute double excitation operators under the Jordan-Wigner transform\n",
+    "    (up to complex coefficient 1j, such that they appear Hermitian instead of anti-Hermitian).\n",
+    "    Args:\n",
+    "        num_spatial_orbitals: The number of spatial orbitals, has a min. value of 1.\n",
+    "        num_particles: The number of particles as a tuple storing the number of alpha- and beta-spin\n",
+    "                       electrons in the first and second number, respectively.\n",
+    "    Returns:\n",
+    "        A list of single excitation operators under the Jordan-Wigner transform.\n",
+    "    \"\"\"\n",
+    "    C, D = creators_destructors(2 * num_spatial_orbitals, mapping=\"jordan_wigner\")\n",
+    "\n",
+    "    num_alpha, num_beta = num_particles\n",
+    "    half_orbitals = num_spatial_orbitals\n",
+    "    indices_alpha = list(range(num_alpha))\n",
+    "    indices_beta = list(range(half_orbitals, (half_orbitals + num_beta)))\n",
+    "\n",
+    "    double_excitation_operators = []\n",
+    "\n",
+    "    # Both excitations from alpha\n",
+    "    if len(indices_alpha) > 1:\n",
+    "        # from these indices\n",
+    "        for p in indices_alpha:\n",
+    "            for r in range(p + 1, num_alpha):\n",
+    "                # to these indices\n",
+    "                for a in range(indices_alpha[-1] + 1, half_orbitals):\n",
+    "                    for b in range(a + 1, half_orbitals):\n",
+    "                        exc = (\n",
+    "                            1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n",
+    "                        )\n",
+    "                        double_excitation_operators.append(exc)\n",
+    "\n",
+    "    # Both excitations from beta\n",
+    "    if len(indices_beta) > 1:\n",
+    "        # from these indices\n",
+    "        for p in indices_beta:\n",
+    "            for r in range(p + 1, half_orbitals + num_beta):\n",
+    "                # to these indices\n",
+    "                for a in range(indices_beta[-1] + 1, 2 * half_orbitals):\n",
+    "                    for b in range(a + 1, 2 * half_orbitals):\n",
+    "                        exc = (\n",
+    "                            1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n",
+    "                        )\n",
+    "                        double_excitation_operators.append(exc)\n",
+    "\n",
+    "    # One excitation from alpha, one from beta\n",
+    "    # from these indices\n",
+    "    for p in indices_alpha:\n",
+    "        for r in indices_beta:\n",
+    "            # to these indices\n",
+    "            for a in range(indices_alpha[-1] + 1, half_orbitals):\n",
+    "                for b in range(indices_beta[-1] + 1, 2 * half_orbitals):\n",
+    "                    exc = 1j * (C[p] @ C[r] @ D[a] @ D[b] - C[b] @ C[a] @ D[r] @ D[p]).simplify()\n",
+    "                    double_excitation_operators.append(exc)\n",
+    "\n",
+    "    return double_excitation_operators"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The excitation pool consists of 24 operators.\n"
+     ]
+    }
+   ],
+   "source": [
+    "num_spatial_orbitals = mx.ncas\n",
+    "num_particles = mx.nelecas\n",
+    "\n",
+    "single_excitation_operators = single_excitation(num_spatial_orbitals, num_particles)\n",
+    "double_excitation_operators = double_excitation(num_spatial_orbitals, num_particles)\n",
+    "\n",
+    "excitation_pool = single_excitation_operators + double_excitation_operators\n",
+    "print(f\"The excitation pool consists of {len(excitation_pool)} operators.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Gradient of the excitation operators\n",
+    "We compute the gradient of all excitation operators in the pool given the current optimized ansatz. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=None):\n",
+    "    \"\"\"\n",
+    "    Computes the gradients for all available excitation operators.\n",
+    "    Args:\n",
+    "        ansatz: ansatz built so far.\n",
+    "        hamiltonian: Hamiltonian after qubit mapping in SparsePauliOp format.\n",
+    "        excitation_pool: anti-Hermitian operators whose gradients need to be computed.\n",
+    "        estimator: an instance of the Qiskit Estimator primitive.\n",
+    "        params: parameters to be assigned to the ansatz, if any.\n",
+    "    Returns:\n",
+    "        List of computed gradients in the same order as the excitation operators in the excitation pool.\n",
+    "    \"\"\"\n",
+    "    # The excitations operators are applied later as exp(i*theta*excitation).\n",
+    "    # For this commutator, we need to explicitly pull in the imaginary phase.\n",
+    "    if params is not None:\n",
+    "        ansatz_opt = ansatz.assign_parameters(params)\n",
+    "    else:\n",
+    "        ansatz_opt = ansatz\n",
+    "    # We recall that 1j was omitted earlier for the anti-Hermitian operators.\n",
+    "    commutators = [1j * (hamiltonian @ exc - exc @ hamiltonian) for exc in excitation_pool]\n",
+    "    ansatz_list = [ansatz_opt for _ in range(len(commutators))]\n",
+    "    gradients = estimator.run([(a, c) for a, c in zip(ansatz_list, commutators)]).result()\n",
+    "    gradients_list = []\n",
+    "    for pub_result in gradients:\n",
+    "        gradients_list.append(pub_result.data.evs)\n",
+    "\n",
+    "    return gradients_list"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Cost function\n",
+    "We define the cost function as the expectation value of the Hamiltonian operator given an ansatz with its parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def cost_func(params, ansatz, H, estimator):\n",
+    "    energy = estimator.run([(ansatz, H, params)]).result()[0].data.evs\n",
+    "    return energy"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Qiskit Patterns Step 2: Optimize problem for quantum execution"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We start by selecting a backend for execution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ibm_brisbane\n"
+     ]
+    }
+   ],
+   "source": [
+    "# To run on hardware:\n",
+    "from qiskit_ibm_runtime import QiskitRuntimeService\n",
+    "\n",
+    "service = QiskitRuntimeService(channel=\"ibm_quantum\", instance=\"ibm-q/open/main\")\n",
+    "backend = service.least_busy(operational=True, simulator=False)\n",
+    "print(backend.name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here we optimize the circuit for running on a real backend by specifying the optimization_level and adding dynamical decoupling. The code below generates a mass manager using preset pass managers from qiskit.transpiler."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit.circuit.library import XGate\n",
+    "from qiskit.transpiler import PassManager\n",
+    "from qiskit.transpiler.passes import (\n",
+    "    ALAPScheduleAnalysis,\n",
+    "    ConstrainedReschedule,\n",
+    "    PadDynamicalDecoupling,\n",
+    ")\n",
+    "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
+    "\n",
+    "target = backend.target\n",
+    "pm = generate_preset_pass_manager(target=target, optimization_level=3)\n",
+    "pm.scheduling = PassManager(\n",
+    "    [\n",
+    "        ALAPScheduleAnalysis(target=target),\n",
+    "        ConstrainedReschedule(target.acquire_alignment, target.pulse_alignment),\n",
+    "        PadDynamicalDecoupling(\n",
+    "            target=target, dd_sequence=[XGate(), XGate()], pulse_alignment=target.pulse_alignment\n",
+    "        ),\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we use the pass manager on the initial state. We can similarly apply device layout characteristics to the Hamiltonian to get a more physical representation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hf_circuit_ibm = pm.run(hf_circuit)\n",
+    "H_ibm = H.apply_layout(hf_circuit_ibm.layout)\n",
+    "excitation_pool_ibm = [exc.apply_layout(hf_circuit_ibm.layout) for exc in excitation_pool]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Qiskit Patterns Step 3: Execute using Qiskit Primitives\n",
+    "Before we execute on the selected hardware, it is a good idea to use a simulator for cursory debugging, and sometimes for estimates of error. For those reasons, we briefly show how to run ADAPT-VQE on a simulator. But it is critical to note that no classical computer, simulator or GPU can accurately simulate the full functionality of a highly-entangled 127-qubit quantum computer. In the present era of quantum utility, simulators will have limited use."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Recall that for each choice of parameters in the variational circuit, an expectation value must be calculated (since that is the value to be minimized). We do this with the Qiskit Primitive, Estimator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Hartree-Fock energy: -7.95213012467435\n"
+     ]
+    }
+   ],
+   "source": [
+    "# To run on simulator\n",
+    "from qiskit.primitives import StatevectorEstimator as Estimator\n",
+    "\n",
+    "estimator = Estimator()\n",
+    "\n",
+    "hf_energy = estimator.run([(hf_circuit, H)]).result()[0].data.evs\n",
+    "print(f\"Hartree-Fock energy: {hf_energy}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's grow the ansatz step by step by before putting the code into a loop. First, our ansatz is simply the Hartree-Fock initial state. Now we will compute the gradient of each operator in the excitation pool and select the operator with the largest gradient to append to our current ansatz with a corresponding variational parameter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[array(3.30587015e-08), array(0.), array(0.), array(1.0864841e-09), array(3.30587015e-08), array(0.), array(0.), array(1.0864841e-09), array(-0.02426337), array(0.), array(0.), array(0.06680867), array(0.), array(-0.04614929), array(0.), array(0.), array(0.), array(0.), array(-0.04614929), array(0.), array(0.06680867), array(0.), array(0.), array(-0.25025159)]\n",
+      "Found operator SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) with maximum gradient 0.2502515943160271 at index 23.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "ansatz = hf_circuit\n",
+    "hamiltonian = H\n",
+    "\n",
+    "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator)\n",
+    "print(gradients)\n",
+    "\n",
+    "max_gradient = np.max(np.abs(gradients))\n",
+    "max_index = np.argmax(np.abs(gradients))\n",
+    "max_operator = excitation_pool[max_index]\n",
+    "print(f\"Found operator {max_operator} with maximum gradient {max_gradient} at index {max_index}.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Expand the Ansatz\n",
+    "We found that a double-excitation operator $O_n$ in the pool has the largest gradient magnitude. Therefore, we will now append it to the ansatz as $\\textrm{exp}(i*\\theta_0*O_n)$, where $\\theta_0$ is the corresponding time evolution parameter. This will be our variational parameter to be optimized in the VQE step. Now we can easily time-evolve the selected operator by using the ``EvolvedOperatorAnsatz`` from Qiskit. Note that the operator to be complex exponentiated and evolved consists of summed Pauli operators. Therefore, the evolution parameter of this ansatz class can be specified to run with different methods such as ``LieTrotter``, ``SuzukiTrotter``, or exactly with ``MatrixExponential`` to test small problems."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1959.72x869.556 with 1 Axes>"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from qiskit.circuit.library import EvolvedOperatorAnsatz\n",
+    "from qiskit.synthesis import LieTrotter\n",
+    "\n",
+    "ansatz = EvolvedOperatorAnsatz(\n",
+    "    operators=max_operator,\n",
+    "    evolution=LieTrotter(),\n",
+    "    parameter_prefix=\"theta\",\n",
+    "    initial_state=hf_circuit,\n",
+    ")\n",
+    "ansatz.decompose().draw(output=\"mpl\", style=\"iqp\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that adding an operator to the ansatz does not drain the pool, i.e. the operator we added can again be selected in another iteration."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Run VQE\n",
+    "We are now ready to run a full VQE on the ansatz that we have so far. We use the cost function and the Estimator primitive as defined above and randomly initiate the parameters to be optimized."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2.58036611]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Random start for the ansatz parameters\n",
+    "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n",
+    "print(x0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we classically optimize the $\\theta_0$ parameter of our ansatz using the ``minimize`` function from ``scipy``."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " message: Optimization terminated successfully.\n",
+      " success: True\n",
+      "  status: 1\n",
+      "     fun: -7.966906269077601\n",
+      "       x: [ 3.024e+00]\n",
+      "    nfev: 24\n",
+      "   maxcv: 0.0\n",
+      "\n",
+      "   Normal return from subroutine COBYLA\n",
+      "\n",
+      "   NFVALS =   24   F =-7.966906E+00    MAXCV = 0.000000E+00\n",
+      "   X = 3.024170E+00\n"
+     ]
+    }
+   ],
+   "source": [
+    "from scipy.optimize import minimize\n",
+    "\n",
+    "res = minimize(\n",
+    "    cost_func,\n",
+    "    x0,\n",
+    "    args=(ansatz, H, estimator),\n",
+    "    method=\"cobyla\",\n",
+    "    options={\"maxiter\": 50, \"disp\": True},\n",
+    ")\n",
+    "print(res)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Step 4: Post-process, return result in classical format\n",
+    "We now interpret the results and decide if we need another iteration of the algorithm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found ground energy: -7.966906269077601\n",
+      "[3.02416963]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Note this returns the total energy, and we are often interested in the electronic energy\n",
+    "ground_energy = getattr(res, \"fun\")\n",
+    "print(f\"Found ground energy: {ground_energy}\")\n",
+    "\n",
+    "# Optimal parameters so far\n",
+    "x_opt = getattr(res, \"x\")\n",
+    "print(x_opt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[array(0.00707565), array(0.), array(0.), array(-0.0017079), array(0.00707565), array(0.), array(0.), array(-0.0017079), array(-0.01805408), array(0.), array(0.), array(0.07148028), array(0.), array(-0.04085333), array(0.), array(0.), array(0.), array(0.), array(-0.04085333), array(0.), array(0.07148028), array(0.), array(0.), array(-0.00026435)]\n",
+      "Found maximum gradient 0.07148028012540592 at index 11\n",
+      "Maximum gradient is below the threshold: False\n"
+     ]
+    }
+   ],
+   "source": [
+    "gradient_threshold = 1e-3\n",
+    "\n",
+    "gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params=x_opt)\n",
+    "print(gradients)\n",
+    "\n",
+    "max_gradient = np.max(np.abs(gradients))\n",
+    "max_index = np.argmax(np.abs(gradients))\n",
+    "\n",
+    "print(f\"Found maximum gradient {max_gradient} at index {max_index}\")\n",
+    "print(f\"Maximum gradient is below the threshold: {max_gradient < gradient_threshold}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Since the maximum gradient is not below the threshold, we append the operator at the found index to the ansatz."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABroAAAV1CAYAAABDPR50AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD630lEQVR4nOzdeZxWZd0/8M8Mi+wii4CCiAIKyOKGorhgWu75KyvLtcwsJc0MLLO0rEilTa0eK23Xh7JNxbQSF8ANQhQRF1CQZUYdAZUBZJn5/cEjOTEsMzIz3MP7/XrxKs91nTPf+8w597nn/pzrOkWVlZWVAQAAAAAAgAJT3NAFAAAAAAAAQG0IugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCA1begCqF5lZWWWr1jT0GVssVYtm6aoqKjW61dWVmbNire3YkUAAAAAAA2jacsd3tP3pcCWE3Rto5avWJM2B/+mocvYYssePSutWzWr9fprVryd3+95xlasCAAAAACgYZw+53dp1qpFQ5cB2wVTFwIAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQtougq6ysLKNHj07v3r3TokWL9OjRIxdffHHKy8tz7rnnpqioKDfeeGNDlwkAAAAAAEANNG3oAura9OnTc9xxx6W0tDStW7dO//79s2jRolx//fWZM2dOFi9enCQZMmRIwxZaR7590f65/NND8qmvP5Rf/vWFDdrvv/n4DBu8c/Y/7W+ZOXtJA1RYA0VF6X/eCdnrzGPSpnvnrHz9zbx058OZfu24rFnxdkNXBwAAAAAA1LNGPaKrrKwsJ510UkpLS3PppZempKQk06ZNS2lpaa655pqMHz8+U6ZMSVFRUQYNGtTQ5daJq37yRGa8sDjf/9JB2bVLqyptXzhjQI48sFuu/Mm0bT/kSjL0m+dk6DfOydLnF+TRK27J3LseSf9zj8/7fvPlpKioocsDAAAAAADqWaMOui666KIsWLAgI0eOzNixY9O2bdv1baNHj87gwYOzZs2a7L777mnXrl0DVlp3Vq+pyNlXPJTWLZvl5qsOW7+87+475tufPyCPPvVqrvvVjAascMu079s9/T51XOaOfzT3n3tdXvj9vzLlql/n8at+nW7DB6bXKYc2dIkAAAAAAEA9a7RB16xZszJu3Lh06tQpY8aMqbbP/vvvnyQZPHhwleUvvfRSTj755LRt2zY77bRTzjrrrLz++ut1XnNdeWLW6xlz85P5wKHdc96H90pxcVF+8+3DU1SUnH3FQ6moqGzoEjer1/8bnqLi4jzz8/FVlr/w+39l9fKV2fPDhzdQZQAAAAAAQENptM/ouu2221JRUZHTTz89bdq0qbZPy5Ytk1QNut56662MGDEiHTp0yG233ZYVK1Zk9OjROfHEEzN58uQUFxdmNnj1z57IyUfulrGXDs2QvTvmoIE754vXPZbn577R0KVtkU5Deqdi7dqUPVH1OWNr316dxU/PTachezZQZQAAAAAAQENptEHXhAkTkiQjRozYaJ8FCxYkqRp0/exnP8vChQvz0EMPZbfddkuSdO/ePYccckjuuOOOnHLKKXVXdB1as6YyZ1/xUKbcdnIu+Fi/TJxWmh/+7umGLmuLteqyU95e/FYqVq3ZoG156eJ0Gbp3ips1TcXqDdsBAAAAAIBtS2VlZZYvX54kadWqVYqKimq1nUYbdM2bNy9J0rNnz2rb16xZk8mTJyepGnTdddddGT58+PqQK0mGDRuWPfbYI3feeWetgq4DDjggpaWlNVqnIs2SDlfU+GdtyhvLVuXtVWvTvFmT3D1xfiq34oyFffr2TXFW13r9ZpXFuTJDN9repOUOWbuq+u2vfXvd8qYtm2eVoAsAAAAAaGB9+/TN6qKKhi4DtmkVFRUpKSlJkgwZMiRPPPFErbbTaIOu8vLyJMmKFSuqbR83blzKysrStm3b9OrVa/3yZ555Jh/5yEc26D9gwIA888wztaqltLQ0CxcurNlKRc2TDrX6cRv1y28elubNmuSZOUtyxWeG5A/3vpQXF7y1VbZdsmhRUrmq1us3L2qSdNl4+9oVb6dZ6x2rbWuyQ7MkyZoVtf/5AAAAAABby6KSRVlVubahy4CC8corr9R63UYbdHXt2jVLlizJtGnTMmzYsCptJSUlGTVqVJJk0KBBVYbDLVmyJO3bt99gex06dMhzzz1X61pqqiLNUlKrn1a9z3+if0YM3SWXXz81f7t/XqaNOyW3fPOwHPmpu7fK9rvtsst7HtGVTdzgsPyVJdmxb/cUN2+6wfSFrbp2yMrX3zBtIQAAAACwTdil2y5GdMFmvHtEV5cumxgJsxmNNug6+uijM2vWrFxzzTU55phj0rdv3yTJlClTcuaZZ6asrCzJuuFwdW3q1Kk1Xqd8+eq0Ofg3W+Xn996tXcZcfEAen/FarrnlqVRUVOaqn07LmIsPzOc/0T833Fq7kWrv9sLzz6d1q2a1Xn/18pX5/Z5nbLS9bPrs7HrkkHTat09efWzW+uVNdmiWDvvsnlcenbXRdQEAAAAA6tPzLzyfZq1aNHQZsE0rLy9PmzZtkiSTJk2q9XaKt1ZB25rRo0enY8eOmT9/fgYMGJCBAwemT58+GTp0aPbYY48cddRRSao+nytJdtpppyxdunSD7S1evDgdOmzluQTrQVFR8qurD0+T4qKcfcWDqahY92Cua385I1Oefi1jLj4ge3Rv28BVbt5Lf3s4lRUV6X/eCVWW9zn96DRr1SIv/vmhBqoMAAAAAABoKI026OrevXsmTpyYE044IS1atMjcuXPToUOH3HTTTRk/fnyef/75JBsGXf369av2WVzPPPNM+vXrVy+1b02Xnj0wh+7bJV//ybQ8+9Ib65dXVFTmnK89lKZNinPLNw9rwAq3zNJnX86zv7wnu59wcEbcPCp9PvG+HHDlWRl61dkpfXhmXvxz7dNeAAAAAACgMDXaqQuTdaHVXXfdtcHyZcuWZe7cuSkuLs4+++xTpe3EE0/M5ZdfngULFqR79+5Jksceeyxz5szJddddVy91by1799oxV1+4Xx558tV879dPb9D+zJylW30Kw7r0+Nd/lWXzX0vfM45O9/ftl5WL38ysW/6eJ64dl1RWNnR5AAAAAABAPSuqrNz+EoLHHnssBx98cPbaa688++yzVdrefPPNDBw4MJ06dco3vvGNrFy5MqNHj07nzp3zyCOPpLi4fgbBbc1ndNWHZY+eVafP6AIAAAAAKBSnz/mdZ3TBZrz7GV3Lli1L69ata7WdRjt14abMmDEjyYbTFiZJu3btMmHChHTr1i2nnXZaPv3pT+eQQw7JXXfdVW8hFwAAAAAAAJvXqKcu3JhNBV1Jsueee1Y75SEAAAAAAADbju1yiNLmgi4AAAAAAAC2fdvliK4JEyY0dAkAAAAAAAC8R9vliC4AAAAAAAAKn6ALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCA1begCqF6rlk2z7NGzGrqMLdaqpUMJAAAAAACoX9KJbVRRUVFat2rW0GUAAAAAAABss0xdCAAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABWm7CLrKysoyevTo9O7dOy1atEiPHj1y8cUXp7y8POeee26Kiopy4403NnSZAAAAAAAA1EDThi6grk2fPj3HHXdcSktL07p16/Tv3z+LFi3K9ddfnzlz5mTx4sVJkiFDhjRsoWzWwM//v3QcuEc6DtojbXt2ybL5r+b2oRc0dFkAAAAAAEADadQjusrKynLSSSeltLQ0l156aUpKSjJt2rSUlpbmmmuuyfjx4zNlypQUFRVl0KBBDV0um7H/5aen66H75K25pXl7yVsNXQ4AAAAAANDAGnXQddFFF2XBggUZOXJkxo4dm7Zt265vGz16dAYPHpw1a9Zk9913T7t27RqwUrbE7QddkP8d8Mn847Srs/yVJQ1dDgAAAAAA0MAabdA1a9asjBs3Lp06dcqYMWOq7bP//vsnSQYPHrx+2TvB2NChQ7PDDjukqKioXupl85a9/GpDlwAAAAAAAGxDGm3Qddttt6WioiKnn3562rRpU22fli1bJqkadM2ePTt/+tOf0rVr1xx44IH1UisAAAAAAAA112iDrgkTJiRJRowYsdE+CxYsSFI16Dr88MNTUlKSO+64I0cffXTdFgkAAAAAAECtNW3oAurKvHnzkiQ9e/astn3NmjWZPHlykqpBV3Hx1s/+DjjggJSWlm717TYmzSqLc2WGNnQZAAAAAADvWd8+fbO6qKKhy4BtWkXFf86R4cOH54knnqjVdhpt0FVeXp4kWbFiRbXt48aNS1lZWdq2bZtevXrVaS2lpaVZuHBhnf6MQte8qEnSpaGrAAAAAAB47xaVLMqqyrUNXQYUjFdeeaXW6zbaoKtr165ZsmRJpk2blmHDhlVpKykpyahRo5IkgwYNSlFRUZ3XwqY1qyxO3OAAAAAAADQCu3TbxYgu2IyKioqUlJQkSbp0qf1ImEYbdB199NGZNWtWrrnmmhxzzDHp27dvkmTKlCk588wzU1ZWliQZMmRIndcyderUOv8ZhW718pX5/Z5nNHQZAAAAAADv2fMvPJ9mrVo0dBmwTSsvL0+bNm2SJJMmTar1drb+A6m2EaNHj07Hjh0zf/78DBgwIAMHDkyfPn0ydOjQ7LHHHjnqqKOSVH0+FwAAAAAAAIWj0Y7o6t69eyZOnJhRo0blwQcfzNy5c9O/f//cdNNNOe+887LnnnsmEXQVkj1OPTxtundOkrTo2C7FzZpm0Bc+nCRZtuC1vHj7Qw1ZHgAAAAAAUM8abdCVJP369ctdd921wfJly5Zl7ty5KS4uzj777NMAlVEbfT/+vnQ9ZECVZftd9vEkSenDMwVdAAAAAACwnWnUQdfGzJw5M5WVlenbt29atWq1Qfvtt9+eJHnmmWeq/Pfuu++eAw44oP4KpYp7PnxlQ5cAAAAAAABsQ7bLoGvGjBlJNj5t4Uc+8pFq//vss8/Or371qzqtDQAAAAAAgC0j6KpGZWVlfZYDAAAAAABALRQ3dAENYXNBFwAAAAAAANu+7XJE14QJExq6BAAAAAAAAN6j7XJEFwAAAAAAAIVP0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBB2i6CrrKysowePTq9e/dOixYt0qNHj1x88cUpLy/Pueeem6Kiotx4440NXSab0G6Pbhky6mM54a7v5LSnb87pL/w2J//zugy6+ENp2nKHhi4PAAAAAABoAE0buoC6Nn369Bx33HEpLS1N69at079//yxatCjXX3995syZk8WLFydJhgwZ0rCFskl9Tjsqe3/y2Lz8j6mZ8+eJqVyzNl0PGZD9vvyJ7H7SIRl/4uVZu3JVQ5cJAAAAAADUo0YddJWVleWkk05KaWlpLr300lx55ZVp27ZtkuTaa6/NZZddlqZNm6aoqCiDBg1q4GrZlLnjH81TN/wlq99avn7Zc7/5R958qSSDv3Bq+nz8qDz7y3sasEIAAAAAAKC+NeqpCy+66KIsWLAgI0eOzNixY9eHXEkyevToDB48OGvWrMnuu++edu3aNWClbM7rT86pEnK946W/PZwk2Wnv3eq7JAAAAAAAoIE12qBr1qxZGTduXDp16pQxY8ZU22f//fdPkgwePHj9sttvvz0f/vCH07Nnz7Rq1Sp77713vvrVr2bZsmX1Ujc103qXjkmSFa8tbdhCAAAAAACAetdog67bbrstFRUVOf3009OmTZtq+7Rs2TJJ1aBr7NixadKkSb7zne/k73//ez73uc/lpz/9aY499thUVFTUS+1smaLi4gz+wqmpWL0mL/5lUkOXAwAAAAAA1LNG+4yuCRMmJElGjBix0T4LFixIUjXouvPOO9O5c+f1/33EEUekc+fOOf300zNp0qQcfvjhdVQxNTX0m+dk5wP3yr+/8/u8OWdRQ5cDAAAAAADUs0YbdM2bNy9J0rNnz2rb16xZk8mTJyepGnS9O+R6xwEHHJAkWbhwYa1qOeCAA1JaWlqrdbcXzSqLc2WGbnH/fUefln7nHp/nfvuPzLjhL3VYGQAAAABAzfTt0zeri8wQBpvy7ln0hg8fnieeeKJW22m0QVd5eXmSZMWKFdW2jxs3LmVlZWnbtm169eq1yW3df//9SZJ+/frVqpbS0tJah2Tbi+ZFTZIuW9Z3yKUfzeBLTs0Lt03II6N/VreFAQAAAADU0KKSRVlVubahy4CC8corr9R63UYbdHXt2jVLlizJtGnTMmzYsCptJSUlGTVqVJJk0KBBKSoq2uh2Fi5cmK997Ws59thjM2TIkFrXwqY1qyxOtuAGhyGXfjRDvvTRzB53fyZf+tO6LwwAAAAAoIZ26baLEV2wGRUVFSkpKUmSdOmyhSNhqtFog66jjz46s2bNyjXXXJNjjjkmffv2TZJMmTIlZ555ZsrKypJkk+HVsmXL8sEPfjDNmzfPLbfcUutapk6dWut1txerl6/M7/c8Y5N9Bl9y6rqQ648PZtIlP0kqK+upOgAAAACALff8C8+nWasWDV0GbNPKy8vTpk2bJMmkSZNqvZ1GG3SNHj06t956a+bPn58BAwZk7733zsqVKzN79uwcd9xx2X333XPvvfdWeT7Xu61YsSInnXRSXnrppUycODHdunWr51fAu+19zrHZd/RpWbbgtZRMfCp7fGh4lfYVr72RkoeeaqDqAAAAAACAhtBog67u3btn4sSJGTVqVB588MHMnTs3/fv3z0033ZTzzjsve+65Z5JUG3StXr06p556aqZOnZr77rsv/fv3r+/y+S+dhqz7fbXp3jmHXf/5DdpLH54p6AIAAAAAgO1MUWXl9jf/27Jly9KuXbsUFRXlrbfeSqtWrda3VVRU5LTTTssdd9yRu+++O0cddVQDVrr92JKpCwEAAAAACsHpc35n6kLYjHdPXbhs2bK0bt26VttptCO6NmXmzJmprKxM3759q4RcSXLhhRfmj3/8Y7785S+nVatWefTRR9e37bnnnuncuXN9lwsAAAAAAEA1ihu6gIYwY8aMJNVPW/j3v/89SfLd7343w4YNq/Jv/Pjx9VonAAAAAAAAG7ddjujaVNA1d+7ceq4GAAAAAACA2jCiCwAAAAAAgIK0XY7omjBhQkOXAAAAAAAAwHu0XY7oAgAAAAAAoPAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCBtF0FXWVlZRo8end69e6dFixbp0aNHLr744pSXl+fcc89NUVFRbrzxxoYuEwAAAAAAgBpo2tAF1LXp06fnuOOOS2lpaVq3bp3+/ftn0aJFuf766zNnzpwsXrw4STJkyJCGLZRNarfnLhn8xY+k48BeadVlpxQ3a5ryhWVZcN+0PP2Tv2XFq0sbukQAAAAAAKCeNeqgq6ysLCeddFJKS0tz6aWX5sorr0zbtm2TJNdee20uu+yyNG3aNEVFRRk0aFADV8umtO7WMa12bp+X//54yhe9nsq1a7PT3rul7xlHp9cHD80dR38pK19/s6HLBAAAAAAA6lGjDrouuuiiLFiwICNHjszYsWOrtI0ePTq33nprnnzyyfTq1Svt2rVroCrZEiWTZqRk0owNlpc+Oisjfn5pen9sRJ7+yd8aoDIAAAAAAKChNNpndM2aNSvjxo1Lp06dMmbMmGr77L///kmSwYMHr182ceLEHH300enWrVt22GGHdO/ePR/72Mcya9aseqmbmilf8FqSpHn71g1cCQAAAAAAUN8a7Yiu2267LRUVFTn99NPTpk2bavu0bNkySdWga8mSJRk4cGDOP//87LzzzlmwYEHGjBmTYcOG5emnn0737t3rpX6q12SHZmnaukWa7NAs7fv2yP5fPSNJsuC+Jxq4MgAAAAAAoL412qBrwoQJSZIRI0ZstM+CBQuSVA26Tj755Jx88slV+h144IHZa6+98qc//SkXX3xxHVTLlurziffl4O98ev1/v/XyK3nowh/l1ceMuAMAAAAAgO1Now265s2blyTp2bNnte1r1qzJ5MmTk1QNuqrTsWPHJEnTprXbXQcccEBKS0trte72olllca7M0M32e/mex/PG7IVp1rpFOuzTKz3ef2B26NC2HioEAAAAANgyffv0zeqiioYuA7ZpFRX/OUeGDx+eJ56o3cxtjTboKi8vT5KsWLGi2vZx48alrKwsbdu2Ta9evTZoX7t2bSoqKjJv3rx85StfSdeuXfPRj360VrWUlpZm4cKFtVp3e9G8qEnSZfP9lpcszvKSxUmSl++ZknnjH8uJf/9umrbcITNu+EsdVwkAAAAAsHmLShZlVeXahi4DCsYrr7xS63UbbdDVtWvXLFmyJNOmTcuwYcOqtJWUlGTUqFFJkkGDBqWoqGiD9Y844oj1I7569+6dCRMmpHPnzrWuhU1rVlmc1OIGhyWz5mXx0y9l77M/IOgCAAAAALYJu3TbxYgu2IyKioqUlJQkSbp02YKRMBvRaIOuo48+OrNmzco111yTY445Jn379k2STJkyJWeeeWbKysqSJEOGDKl2/ZtvvjlLly7NSy+9lOuuuy7vf//7M3ny5Oy22241rmXq1Km1fh3bi9XLV+b3e55Rq3WbtGie5ju12coVAQAAAADUzvMvPJ9mrVo0dBmwTSsvL0+bNuu+2580aVKtt1O8tQra1owePTodO3bM/PnzM2DAgAwcODB9+vTJ0KFDs8cee+Soo45KsvHnc+2111456KCDctppp+W+++7LW2+9lWuvvbY+XwLv0rJz+2qXdz1kQNrv3SOv/fuF+i0IAAAAAABocI12RFf37t0zceLEjBo1Kg8++GDmzp2b/v3756abbsp5552XPffcM8nGg653a9++fXr37p3Zs2fXddlsxMHXnJdWO++UkslPZ9mC19Jkh2bpOGjP9PrgIVmzbGWmfuPXDV0iAAAAAABQzxpt0JUk/fr1y1133bXB8mXLlmXu3LkpLi7OPvvss9ntvPrqq3nuuedy0EEH1UWZbIGX/jIpe37kyOz54cPTomO7VFZWpnxhWZ7/7T/z9E/vSPnCsoYuEQAAAAAAqGeNOujamJkzZ6aysjJ9+/ZNq1atqrSdccYZ6d27d4YMGZL27dvnhRdeyA9+8IM0bdo0l1xySQNVzNw7H8ncOx9p6DIAAAAAAIBtyHYZdM2YMSNJ9dMWHnzwwfnNb36TH/3oR1m5cmV69OiRESNG5PLLL0/Pnj3ru1QAAAAAAAA2QtD1X0aOHJmRI0fWd0kAAAAAAADUUHFDF9AQNhV0AQAAAAAAUBi2yxFdEyZMaOgSAAAAAAAAeI+2yxFdAAAAAAAAFD5BFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAWp0QddZWVlGT16dHr37p0WLVqkR48eufjii1NeXp5zzz03RUVFufHGGxu6TGqhScvm+fCjP845JbfnoG+f29DlAAAAAAAA9axpQxdQl6ZPn57jjjsupaWlad26dfr3759Fixbl+uuvz5w5c7J48eIkyZAhQxq2UGpl31GnpUXHdg1dBgAAAAAA0EAa7YiusrKynHTSSSktLc2ll16akpKSTJs2LaWlpbnmmmsyfvz4TJkyJUVFRRk0aFBDl0sNdRjYK/3POyFPjB3X0KUAAAAAAAANpNEGXRdddFEWLFiQkSNHZuzYsWnbtu36ttGjR2fw4MFZs2ZNdt9997RrZ1RQISkqLs4hYz+bhfdPz8vjH2vocgAAAAAAgAbSKIOuWbNmZdy4cenUqVPGjBlTbZ/9998/STJ48OCNbue4445LUVFRrrrqqrook1rq/5kTs2PvXfPY5b9o6FIAAAAAAIAG1CiDrttuuy0VFRU5/fTT06ZNm2r7tGzZMsnGg64//OEPmT59el2VSC216bFzhoz6aJ78/u1ZtuC1hi4HAAAAAABoQE0buoC6MGHChCTJiBEjNtpnwYIFSaoPut5888184QtfyNixY3PGGWe853oOOOCAlJaWvuftNGbNKotzZYZutt+waz+TZfNeycyb7qyHqgAAAAAAaq5vn75ZXVTR0GXANq2i4j/nyPDhw/PEE0/UajuNMuiaN29ekqRnz57Vtq9ZsyaTJ09OUn3Q9dWvfjV9+/bN6aefvlWCrtLS0ixcuPA9b6cxa17UJOmy6T57fPiw7HL4oPz9/309lWvW1k9hAAAAAAA1tKhkUVZV+g4TttQrr7xS63UbZdBVXl6eJFmxYkW17ePGjUtZWVnatm2bXr16VWmbOnVqfv7zn+ff//73Vquna9euW21bjVWzyuJkEzc4FDdvmgOvOicL7nsiK15dmra7r9unrbp1SJI0b9cqbXfvmrcXv5lVby6vj5IBAAAAAKq1S7ddjOiCzaioqEhJSUmSpEuXzYyE2YRGGXR17do1S5YsybRp0zJs2LAqbSUlJRk1alSSZNCgQSkqKlrftnbt2px//vkZOXJkBgwYsNXqmTp16lbbVmO1evnK/H7PjY+ea9qieVp22jE9jtk/PY7Zf4P2PU89InueekSmfOM3mfk/d9RlqQAAAAAAm/T8C8+nWasWDV0GbNPKy8vTpk2bJMmkSZNqvZ1GGXQdffTRmTVrVq655pocc8wx6du3b5JkypQpOfPMM1NWVpYkGTJkSJX1brzxxrzyyiu56qqr6rliNmf18rdz/6fHbrC8Rcd2GXbNZ7JgwhN54db7smTWvAaoDgAAAAAAaAiNMugaPXp0br311syfPz8DBgzI3nvvnZUrV2b27Nk57rjjsvvuu+fee++t8nyusrKyfO1rX8vYsWOzZs2aLF26dH3bypUrs3Tp0rRr1y7FxcUN8IqoXLM288Y/usHyNt07J0nemltabTsAAAAAANB4NcrUpnv37pk4cWJOOOGEtGjRInPnzk2HDh1y0003Zfz48Xn++eeTpErQtWDBgrz11ls5//zzs9NOO63/lyTXXHNNdtppp7z88ssN8noAAAAAAADYUFFlZWVlQxdRn5YtW5Z27dqlqKgob731Vlq1arV+eXXP0hoxYkTOPvvsnHPOOTn44IPTooV5VevC5p7RBQAAAABQKE6f8zvP6ILNePczupYtW5bWrVvXajuNcurCTZk5c2YqKyvTt2/f9SFXkrRp0yZHHnlktevsvvvuG20DAAAAAACgYTTKqQs3ZcaMGUmqTlsIAAAAAABA4dnuRnTVNOjazmZ2BAAAAAAAKBhGdAEAAAAAAFCQtrsRXRMmTGjoEgAAAAAAANgKtrsRXQAAAAAAADQOgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKkqALAAAAAACAgiToAgAAAAAAoCAJugAAAAAAAChIgi4AAAAAAAAKUtOGLoDqVVZWZvmKNQ1dxhZr1bJpioqKGroMAAAAAABgOyLo2kYtX7EmbQ7+TUOXscWWPXpWWrdq1tBlAAAAAAAA2xFTFwIAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQtougq6ysLKNHj07v3r3TokWL9OjRIxdffHHKy8tz7rnnpqioKDfeeGNDl1knvn3R/ql86tx88pQ+1bbff/PxWTn1nAzovVM9V1Zz55TcXu2/02f/tqFLAwAAAAAAGkDThi6grk2fPj3HHXdcSktL07p16/Tv3z+LFi3K9ddfnzlz5mTx4sVJkiFDhjRsoXXkqp88kZOO2C3f/9JB+ccjC7PwleXr275wxoAceWC3fPmHUzJz9pIGrHLLlT76TJ7/3T+rLKtYvbaBqgEAAAAAABpSow66ysrKctJJJ6W0tDSXXnpprrzyyrRt2zZJcu211+ayyy5L06ZNU1RUlEGDBjVwtXVj9ZqKnH3FQ3nsdyfn5qsOy7GfuzdJ0nf3HfPtzx+QR596Ndf9akYDV7nlls17JS/+aWJDlwEAAAAAAGwDGvXUhRdddFEWLFiQkSNHZuzYsetDriQZPXp0Bg8enDVr1mT33XdPu3btGrDSuvXErNcz5uYn84FDu+e8D++V4uKi/Obbh6eoKDn7iodSUVHZ0CXWSHGzpmnaqkVDlwEAAAAAADSwRht0zZo1K+PGjUunTp0yZsyYavvsv//+SZLBgwevX/bAAw+kqKhog3+FPrXh1T97ItOffT1jLx2aG74yLAcN3DlfveHfeX7uGw1dWo30PPHgnPHi73PGnN/lYzNuzkHf+lSatW3V0GUBAAAAAAANoNFOXXjbbbeloqIip59+etq0aVNtn5YtWyapGnS948c//nH222+/9f/dunXruim0nqxZU5mzr3goU247ORd8rF8mTivND3/3dEOXVSOvTXshc+98JG/NLUmztq3S/aj90u/c49Nl2IDcfdJXs2b5yoYuEQAAAAAAqEeNNuiaMGFCkmTEiBEb7bNgwYIk1Qdd/fv3z8EHH1w3xTWQN5atytur1qZ5sya5e+L8VBbWjIUZf8JXqvz3nD8+mMWz5mX/r3wi/c87Pk/96M8NVBkAAAAAANAQGm3QNW/evCRJz549q21fs2ZNJk+enKT6oGtrOuCAA1JaWlqjdSrSLOlwxVat45ffPCzNmzXJM3OW5IrPDMkf7n0pLy54a6tsu0/fvinO6lqv36yyOFdmaI3Xe/onf8uQL34k3d+3v6ALAAAAANgm9O3TN6uLKhq6DNimVVT85xwZPnx4nnjiiVptp9EGXeXl5UmSFStWVNs+bty4lJWVpW3btunVq9cG7R/72MdSVlaWjh075uSTT853v/vddOrUqVa1lJaWZuHChTVbqah50qFWP65an/9E/4wYuksuv35q/nb/vEwbd0pu+eZhOfJTd2+V7ZcsWpRUrqr1+s2LmiRdar5e5Zq1Wf7K4uzQoW2tfzbr7HrUvnnfr7+cv424JG/MXrTZ/qc+/pMsm/9a7vnwle/5ZzfZoVn+38QfZc6fJ+aJ7972nrcHAAAAwLbnwG+ck+7v2y9/PfKSVK5Zu8VthWhRyaKsqiz81wH15ZVXXqn1uo026OratWuWLFmSadOmZdiwYVXaSkpKMmrUqCTJoEGDUlRUtL5txx13zKhRo3L44YenTZs2eeSRRzJmzJg8+uijmTp1alq0aFGrWmqqIs1SUuO1qtd7t3YZc/EBeXzGa7nmlqdSUVGZq346LWMuPjCf/0T/3HDrM+/5Z3TbZZf3PKIrtbjBockOzdK6W8e8Nu2FWv9skqImxTnwyrPy4p8nblHItTH9zzshq94oz+w/PFCz9c4/Kc3btc7Mn96RJNn7U8fl4G+fm3+PuTUzrt9wpF7z9m1yygM/yNq3V+VvR12ao3/zlXQ9ZMBmf870sX/I9O/9IUMu/WiGfOmjm+1f+vDM3PPhK9N12IAc++dvbNFr+VW3U3Pkzy/NbscNzT0fujKvPv7sBn12Hrp3jv3zN/Ly3x/PA+d9L/t95RMZdNGHMumSn2T2/07YoP+xf/pGOu/fN3d+YHSWPjc/w394YXp/bOPTsr5j9rj7M+kLP07vjx6Z4T8audn+y+a/mtuHXpA23Tvn1Ck/3aLXe/uBn8ve5x6XfT57ch684Id56S+TNujTdveuOfm+sVk66+XcffIVqayon7uZmrRsng/+63tpvmOr/PWIS7Ly9TertO/Yt3tOvvfalD05J3//f19PKitzTsntW7Ttez50ZUofmZlj//SNOjv2/nXWmHxwwvfSZIfm+euRl2TV0mUb9Bt40Yey/1c+kUe/enMGnH/ilvW9/BdZ+uz8Gh3TSep037z8jyk54a7vpPThmfnnx79Vbb9jbrsiXQ8ZkPEnXp7FM17aolq2hkI/P5cteC19zzg6h1z32Uz//h8z/bpxG/Q77IbPZ89Tj8g/Trs6ix58Mi07t88HH/hB3l78Zu44ZlTWrqx6I0u34QPz/nFfy4t/nZyJF/6oVjWd+vhP0qbHzpvtP+niGzP7Dw/UaL9Ou+a2nHL/D1K+qCx3fuCyVKxes0G/Ydedn73OOCb/OnNMFvzr31tU+3t1wJVn1ei98sOP3lhn+6g2x16SHP7ji9PrlEPzj49dnZJJM6r0a9KieU7+53XZoUO7/O3IS9LzpGHb1bW8vmxv52fJ5BkFfS2/58NXJkVFOe4v30ynwXvmjvePyhsvVL0BskWnHXPKA9/PqjeW529HX5q1K2p/82BNtOrWoUa/ixYd2tb59aomx97KJW/l6N98Jc/97p95ZNRNG/QpbtY0J917TVrv0imPXnFzDr/hoi3q+9cRl2S/yz5e8Nfy+lLT98rGcH7W9HdR19erpOaf03c5YnDe/79fy+w/PphJF92wQb99R5+WwZecmslf+p+88Pt/bdG2t5btbf8unDCtoN+LZ//hgbTfq0dOuvfavPbv56u9EbrPx4/Kod+/IE/+6E/rb2x++sa/Zq8zj8neZ38gs26uegP+ptoK0S7ddjGiCzajoqIiJSXrkpAuXWoxEub/NNqg6+ijj86sWbNyzTXX5Jhjjknfvn2TJFOmTMmZZ56ZsrKyJMmQIUOqrLfvvvtm3333Xf/fRx55ZPbZZ5+cfPLJue222/LJT36yxrVMnTq1xuuUL1+dNgf/psbr/beiouRXVx+eJsVFOfuKB1NRse7BXNf+ckY+9L7dM+biAzL+ofnveQrDF55/Pq1bNav1+quXr8zv9zxjo+077NQmby/Z8IvbfUefluJmTTP/HzXfx/zH7icNS/u+PfLg5364xev8efhFyX89563/eSdk2fzXahR0NWnRPPt87uS8MO7+rHpj3UjMZ2/5e3Y7dmiGfPEjWfDPf2fJrHlV1jn4O59Oy8475t5Tv5E15Svz5I/+lOdvrf4DeJPmzXLgVWenWZuWeXXqc0mSeXc/ljfnbjxK3uezJ6fDPr3yyuOzkiRLX1iQh0b+aKP9u79v/+zx/4av7//Il3+eLgf1y/AfXpg73velrFnx9n/qadk8w394Yd5e/FYeuexnSdb9YdbjmP0z9Kqzs+jB6Vlesnh9//6fOTFdDxmQf3/7d1n63PwkyXO//WcWTXyq+mKKirL/lz+R1rt2yiv/98dm6aPPbLL+3h85MrscMXh9/5Wvv7nJ/p2G9En/Tx+fN+YsyorX38gT370t3Y/aNwd969yUTn46K15dWqWe4T+6MEVFRZl48Y31FnIlydoVqzLpkh/n2D9/Iwdf85k88Omx/ymrSXEOu/7zqVi7NpMuvjHvPLRwU6+77W5dsu/o07Ly9Tfyxpx1fwTX5bG3pnxlJn/hJ/nA7Vdm2Jjz8uDnflClb/u9d8uQL34kix56Ks/e8vcsnfXylvX95T1p0WnHGh3Tdb1vFs94KU/96M/Zd9THstdZ789zv/lHlf59zzwmux45JE9c+7/1GnIlhX9+Jsnzv/tXep5wcAZ9/v/l5Xser7IPdztuaPY89Yg895t/rP9ibMVrS/PYFTfniJ98Ift9+eOZctWv1/dv1qZlDv3BBVnx6tI89tWba13T41//ZZq2rv7moR3at82BV56VijVrU/bUi0lqtl+XlyzOY1+7JYdd//nsO+pj+fd3fl+l+y5HDs5eZxyTF26bUG8hV5Iav1fW5T5Kan7sJcmjX705XQ/dJ4d+/3P564gvZk35yvVt+3/19OzYe9c8+NkfZMVrS7e7a3l92R7Pz0K+lidJKisz6Qs/zsn3jc3wH43M3Sd+tcrnoUOuOz/N27fJhE9eW28hV5Ia/y7a7LZznV+vanLsLX325bzwvxOy1xnH5OW7H8vC+6dX6T9k1EezU7+emXjRDXnx9ofS7dB9tqjv8pLFjeJaXl9q+l7ZGM7Pmv4u6vp6ldR8vy568Mk897t/Zq8zjsm8ux6p8n1Kx8F7ZuDIU7Lw/ifqPeRKts/9W8jvxUmy9Ln5mf79P2b/r3wi/c49vko41bp7pxx41dlZ/My8PPm9P65fvuK1pXnpr5MzcOQpefZX96RybcUWtRWi5194Ps1a1XzQBGxPysvL06ZNmyTJpEkb3hS6pYoqKysrN9+t8CxYsCBDhgzJ66+/nqZNm2bvvffOypUrM3v27Bx33HGpqKjIvffem5/97Gc577zzNrmtysrKtG3bNmeffXZ+/OMf10v9Wyvo+tI5A3PdF4dm9A8ez3W/rHrnbf8922fauFPy6FOvvucpDJc9eladBl0HfuOcdN6vT0ofnpnyhWVp2qpFur9v33QbPnDdXSOnXrXBHa1sueP+enWatWmZO47+0nvaTm2mM3zn7p47jhmVxU//50Ns6+6d8sH7vpe35r2au47/8voh67sdf1COunlUZv7srky58leb3f4hYz+bvqcfnSeu/d88+YPN34m1x4cPy+E3XpxFDz6Zf37i25sNZnbss2tOGD8ma8pX5s73j86K15auq/PYA3PULy/LrF/ek8cu/8X6/gd961Ppd+7xue+cazL/3inrl3cY2Csnjh+TkslPrx/R0m7PXXLyP6/LkmfmbfFIqEGXnJr9Rp+WF26bkMlf/Mlm+3cdNiDvH/e1vDF7YcafcHmVP06r06LTjjnp3mvTvF2rjD/hK1n6/IIk6z6wn3Dnt7PwgSdz31lj1vcfcP5JOfCqs/PY127JrF/U/H3mnTtk37m7rDYOvOrsDDj/pCqjKAZ/8SPZd9TH8uhXfpFnf3XPZrfRpGXznHDnd9J+rx75x2lXp3Ty05tdZ2sde0O/eU76n3di7j/ve5l31yNJ1n25d+Lfv5u2Pbvkb0ddmvKFZTXuuzEbO6Y3Zmvtm6ImxTlh/JjsuOcu+dtRl2bZ/FeT/N97wYTv5805izL+xMtr9YfOOSW3r7/TtzYK/fxMkla7dMwpE75f5W7RHTq2yyn3fz9rlr+dvx11adYsX1lle0f+4kvZ7dgDq9ylfegPLkif047Kv874ThbcN22zr2FTNVWrqCjH3PrV7HrkkEy86IbM+eODm/0ZG9uvR/1ydLofvX/+/sEr1o/8bta2VU65//uprKzM30Z8MauXVT/F9aac+vhPUvrwzEz6Qs0/E26V98qtuI82ZlPHXo/3H5D3/frLVUZGdB02IB+4/crMG/9YHvjMf0Y3bW/X8i31zt3n79wpXhvb2/lZ6NfyJOl37vE56FufqjLKcc+PHJHDrv98nv7J3zL16t9udvvVea+flbbGe+XWvF5VayPHXrM2LfPB+7+fouLi/G3EJVn15vIkSachvXP8nd/O/H9Ozf2fuq7GfTel0K7lW+q9fFbaGu+VhXZ+bq3fxda6Xm3MpvZr09Ytcsr9309x82brZ4RoskOznPSPa9Ny553ytxFfzPLSxZvY+sa9l89Kyfa5fwv5vThJioqLc/xd3077vXrkjvd9KW/NLU2SvP8PV6bLQXtn/AmXV/m+J0m6HjIgx/7pG7n/09dl3vjHtrit0Jw+53eCLtiMdwddy5YtS+vWrWu1neKtWdS2pHv37pk4cWJOOOGEtGjRInPnzk2HDh1y0003Zfz48Xn++eeTJIMHD97ibb57isNCsHevHXP1hfvlkSdfzfd+veEHxWfmLM1VP52WIw7ols9/on8DVLjlSh+emdXLVmTPjxyRod84J0NGfTQ7tG+Tf4+5Nfd8+MqCDrmKmzfNwIs+lA8+8IOc+dKt+cSzv877fv3ldNjnP8+Oa9WtQ06b+ct88P7vp0mL5lXWP+zHF+fshX9It8MGrl92TsntGf7DC9PtsIE54a7v5IwXf5+PPfnzDL36k2n6XxfYlp3bp8tB/bJgwua/EHm3Ux//SY7903+G/J9Tcnva9Ng5XQ8ZkHNKbl//r033zpvczu4nDcvyV5Zs8KGnfEFZHr/y1+k4sFeGfPEjSZIdOrTNsO+elzdmL8y0Mbdutsa9znp/+p5+dF6+d8oW/fHTYZ9eOeS6z2bZ/Ffz4Od+sNkPws3atspRt4xOk+bNcv+nx1b5IPzyPVMy+48PZu+z359uw9f9broOG5C9P3lsZv/hgQ3+2Fs846U8dcNfsuuRQ9L3jKNTVLzuLuUkWzwSatej9s2QSz+Ssumz8+hXfr7Z/q137ZQjfvbFrC5fmQmfum6zH4SLmjbJiF98Ka136ZhJX/hxlQ/Crz85J0/d8Jf0OGb/9Pn4UUnWBQH7XnZaSiY/XauQa2uZ9t3b8sbshTnoW+emZef26TCwVwZd/KEsmjhji74YS5Lh378wHQbsnn9/63db9If31jz2/v2dW/PG7IUZ9t1Pp0WnHZMkgy7+cDoO3COPf/1XVYKrmvStzqaO6Y3ZWvumcm1FJl50Q4qbNsnwH164fvmh378wxU2bZOJFNzTY3XyFfn4myfJFr+fxq36dnfr1XD+9y7DvnpcWHdtl8iU/qfbLgkcv+1lWLV2W4T+4ME1aNk/3Y/ZPn9OOWndH6RZ8ib65mqqz/+WnZ9cjh2TWzXdv0Zfom9qvD3/pf7LqjWUZ/qOR66+dQ795Tlp165BJX/hxrUKu92prvFduzX1Unc0de/P/MTWz//hg9jrjmOxy5OA0bd0ih/7wgqx8/c088uWqo5u2t2t5fdrezs9Cv5Ynyayb707pwzMz5IsfSfu9eqRVtw456OpPZenz8/PEtf+7Ra+hLrzX98qtfb2qzsaOvdXLVmTyJT9Jq6475aBvn5tk3dT2w390Yd5euqzKNIU16bsxhXgtrw9b472y0M7PrfG72JrXq43Z1H5dU74yk7/407TsvGMO/r9zYt8vfzzt+/bI41//Za1Drq1he9y/hfxenCSVFRWZdPGNKS4uXve3XFFR9v7UcdnlsIF56od/2uD7niR55dFZWV2+IrufeEiN2gA2ptFOXZgk/fr1y1133bXB8mXLlmXu3LkpLi7OPvvss9nt3HHHHSkvL8/QoUProsw68+xLb6Tlgb/eZJ/v3vxUvnvzRqZl2IbMv3dKg36ZUFeKmjbJMbdekZ0P2Ctzbn8wz97y9zRv1yp9Tj86x9/xrfz9/309rz85J8tLFmfyJT/O+3795Qz95jl5ZPS6L5J6n3ZU9vzQYXnqhj+nZGLVEXsdBu6RnicenOd/f19m//HBdDt0n/T/9Alpv9du+cfHvrl+epcuw9aFnGVPzH5Pr+WhkT/K0G+ck5WL38pTP/rT+uX//SyFKq+/uDg7H7h3SiZV/8fM7P+dkJ7HDc3Akafk5XunZJ8LPpgddmqb+8767mbDzZ0P3CtDr/5k3pi9MBM/v+G82P9thw5tc9Qt657dN+FT11U7VeZ/O/zGi7Jj713zyGU/y2v/fn6D9sevuDndDhmQQ39wQcafeHkO/cEF66aJueKWarf35A9uz27vPyAHfP2sdBiwezrv1yePX/WrvDln889Na9uraw7/8cV5e8myTDj3uqx9e9PPzGuyQ7OMuHlUdtipTe4767vr77jalKHf/GS6HNQvM274S+aNf7Ta+nscs38OvOrslEx+OsN/eGEq1qzN5Freybe1rF25KpMuvjHH/e1bOeT7n0ubXTtl7durM/mLW1bXgM+dnF6nHJqX/jo5M2+6c7P9t/axt3blqky86MYcf8e3csh152f62D9k0MUfysv3TsnscffXum91NndM/7etvW/eeH5Bpl3zvznwyrPS/zMnpmLVmuxy2MBMuerXGzwzob4V+vmZ/N976gkHZZ8LPpjiZk2z+4nD8swv7k7pIzOr7b8uuPhFRvz80gz77meyyxGDU76wLI9vwQicLa3p3XqeOCwDR56SVx6blcev2vTnl2Tz+3Xl62/mkct+nhG/+FL2/+rpWfTAk+lz2lHrvszagi/R6sp7ea/c2vvov23psff4FTen26H75NCxn0vpY7PSdrcumXDudXl78YZTYW9v1/L6sr2dn4V+LX/HpC/8OB+c8L0cdsPns3LxW2naukUmXnTjZs/NuvRe3ivr6nr1bps79komzcizv7o3/T51XObd/Vh2PmCvtO/bI/d/+roN/g6pSd//VqjX8vryXt4rC/X8fC+/i7q4Xv23LdmvJZNm5Nlf/yP9PnlslpcuTv/zTsjL90zZopsZ6tr2tn8L/b04Sd54YWGmXfu/OfDrZ+Wgqz+Z3h8/KmVPzclT1TyrNVkXjpVNn7P+O6ktbQPYmEY7omtTZs6cmcrKyvTp0yetWrWq0nbGGWfk61//ev7617/mX//6V66++uqcccYZGTJkSE477bQGqpjGqt+njku3Q/fJfed8Nw9/6X/y3G/+kRk3/jV3HjMqKxe/mQO/ftb6vvP/MTXP/OLu7HXm+9PzhIOzY+9dctC3P5VXpz6XJ67Z8C6zDv17ZuLI6zPlyl/luV/fmwc+870884vx2eWwgel18n/uimnft3uS5K25r7yn1/LinyZmzfK3s/K1N/Linyau/7epO4la79opzdq0zFvzNv5B7OEv/U9WvbU8x/z+8vQ6+ZDMuPEvKZu+6VCuZZedcuTPv5SKVWsy4dzrsvqt5ZvsX1RcnCNv+mLa9Ng5D4++qdq7jf7bkFEfS4/3H5Dnb71vg+cJvWPVm8sz+dKfpk33zvngfWPTpkfnTPriTzZaT+WatZl48Y1pskOz7H3OsXnlsVl55mfjN1tL01YtctQvL0uzNi3z4Pnfz/JFr292nWHXnp9Og/fM9O/9MQsnPLHZ/r0/NiL9PnlsFj74ZKb93wNkq63/8zekSfNmOfHuMdn5gL0y5apf13rKwa3ptWkvZOb/3JkeR++fnfr1zJRv/CblCzY9uilJuh02MPtffnoWPzNvi6anqatjr+yJFzLjx3/NbscOzfvHfS2rl63Y6J3HNen7bltyTL9bXe2bmTfdmVcem5X9vvzx7H/F6Sl99JnM/NmGN63Ut0I/P9/x8Jf+J6vfWp59Pndy3nyxJP/+zu822X/eXY/kpb9NTu+PHplWXXbK5Et/utnjuqY1JeueIzf8hxekvOT1PHDe99ZPcbcxW7pf541/NHP+PDH9PnVchl//+bwxZ1GmfnvTr7mu1fa9sq720btt6bG36s3leXjU/6T1rp2y54cOy5w/T8zLd298Wpnt6Vpen7a387PQr+VJsmz+q5l69W/TceAe2fWIwZnx47/m9SfnbLamulbb98q6vF4lW37sTf3Wb/PmiyU59HufS//zT8ycPz200amuatL3HYV+La8PtX2vLPTzsza/i7q6Xr1bTfbrv6/+bd6cW5p9LvhgVr2xPI+M3vzfDfVle9u/hf5enCQz/+fOvDrlufQ79/gUN2mSSRfduMlZOd6aW5pWXXbKDju1qVEbQHW2y6Brxox1I1+qm7ZwwIAB+ctf/pKzzjorxx13XG655Zacd955eeCBB9K8efMN+sN7sceHD8vSFxbk9adezA4d2q7/V9y8aRY9+FR2Hrp3lakKp179m7w+48UcMvazOfLnX0rl6rV56HM/rPaDwxuzF+ble6qOgptxw1+SrHuI6ztadGyXJHl76YZ3Yde1//zsjd9hteK1dQ9Ub9FxxyyZNS/T3/UA0+oUN2uaEb/4Ulp12SmTvnBj3tiCIfgHfP3MdBs+MM/84u68ePtDm+3f4wMHZvAXPpzXnnhhs9OWLHrwyTz323+kRccd8/zv/5WShzY9gnL1m8tTsWpNkqybemgLHqM4/EcXZqe9emTqt36b0oc3f4dbv3OPT++PHpmX75mSp7Zgqo+Og/fMsO+el7defiUPbWbah3ceRNui445Z+MD0vHDrfZvd/juKmjapch7s0KHt+ofgNm/fZoO2mnrnTt2K1Wuy8P7N/wHQpnvnHPE/l2T1shW5/1PXbnb6h7o+9p783h+zZNa8tOi4Yx776s2bnE6jJn2Tmh3TSR3vm8rKTLxo3d25RcXFmXTxjVt0Hryj+Y6tqz1WmrRsvsHy4uY1G9he6Odnkqxd8XbW/N/D1Esmz1j/YPVNeefcWfn6G+sf9r41a2q+Y+scdcuoFDdtmgfO+96WTRVTg/362OW/yMqyN9KiQ9tMuvjGLXrN72jWttWGx1NxUYqbN9tgeZOWW/45sabvlXW9j5KaH3tvL1mWirXrvuhY8M+pm+y7vV3Lq7yW5k03eqz89/LmO9Z8Lvrt7fws9Gv5u19Dkiz457832//d6vKzUk1/F3V9varJsbd2xapMvOiG7LBT27z9+pt57Ks3b5W+72gM1/J3q6vPSjV9r2wM52dtfhd1eb1Kar5f165ek9VvrZsW7/Wn5mzR+/y71dVnpWT73L+F/F6cJKmsXP/9zptzSzc7K8c7o+3emXZ/S9sAqtOopy7cmE0FXV/5ylfyla98pb5LYjvVvk/3NG25Qz4+85cb7bNDh7br7xqsWLUmD37uhznlgR9kp713y4MX/HCjd4AvfWHDD/4rXl2at5cuS9ueXdYvW/897X89g664WdPs0L7qnTOry1du1bnfK9/54Zt5/t1rU9dNHfD6Uy9u9i7ig75zbnY+YK88dcOft+ihpb3+3/AMOP+klD76TKZ8Y/NT8ezYe5ccdv3IrFz8Vu7/9Nj1X3pvrv69znz/+texKYf+8MIUN2uapc/Pz6AvfDhz73g4b83b+Gi7gRd9KLufOCwv/mVSnrlp86NeuhzcLwdeedb/TfVx/Wb7t+jYLkfdPCqVlZW5/9yxWzTtwzuvc0teb5XaDtw7x/75G9W2nfzPDR8O/qtup27xtnfss2v2Hf2xLJk1Lzv23jWHjv1s/vmJb2+0f5OWzTPiltFpvmPrddM/bOJ38I66PvYqVq/J60+9mJ369dzsvq1J35oe0/Wxb5a9/GpWlr2x/v/XxMn/vC5teuy8wfKBF56SgReeUmXZpItvzOw/PLDF224M5+fQqz+V1rt0zOKnX0qfT7wvc/74YF6dsvEvx7seuk/2PucDeX3GS+k4sFcOvPKs9dPnbpWaiopy+E++kHa9uuXh0Tdt0VQxNd2vq94ozxuzF6Xlzjtt0fbf7X2/uixdDxmwwfI2/69z9vh/w6ssmz72D5n+vT9s8ba3+L2yHvZRTY+9Jjs0y2HXj8yqN5ZnzYqVOfCqc7Lw/ulZ9Ub5RtfZnq7l77bHKcMz/Ecjq237789/y+a/mtuHXrDF297ezs/GcC1v0bFdhl1zXt6a90p22KlNhl17fu469rJUrN78MZjU7Welmvwu6vx6VYtj750+b8xetMn3opr2bQzX8v9Wl5+VtvS9srGcnzX9XdT19ao2+3XwFz6cjgN75fUZL2XXI4esn45vS9XlZ6Xtcf8W+ntx74+NSI9j9l//2WSfCz+4/obr6n/G//1vdTcQbqoNoBqCLmhgi5+ZlylX/Wqj7W//13zx3Y/eL8VNmyRJOu7TKy/9ZdJ7+vnvbH+H9m2qTMOx8wF7bfCHdE0/mNbkZ28Nfc84OnudcUwWPjA908Zsfgj+Tv175pCxn035oi2biqdZm5YZccvoNG25Qyacc+0WTVtSE/3OPT7dDt0n/x5za+bf83hO+sd1OfQHF+SeD11Zbf9dRwzJvqM/lsUz52bypZuf6qNVtw458meXZs3KVZnwqWs3+0DboibFOfLnl6b1rp3y0MgfbdG0D+/F4mfm5t6PVj3mdjlicAZeeEoeuvBHNb678B1FxcUZ/qORqayszIRPXZfeHzsyg79wavp8/Ki8cNuEatc5ZOzn0nFgr0y75rYtmv6hro+9ulKbY7qu98179dCFP6oyEjZJPvCHKzP7jw9mzh8fqLJ86XPzt3i7jeH87PH+A9L7o0fmud/9M09c87855cEf5NDvX5A7jhlV7bOSmrZukeE/uCArXnsj9370GznoW5/KXme+P3PvfGSD50LWtqb9vvzxdD9q3zz/+3/l+d/+c7P9a7pf36sp3/j1BqNsDr/xoix+Zl6e/snfqizfki87aqOu91FNj70k2e8rn8iOvXfNgxf8MCtffzMfGPf1HPStT23Rs1I2p9Cv5f9t4QPTN7i27fmRI9P7I0dssHxzzyx7t+3t/Gws1/Jh156f5u3bZMKnrlsX1n3vcxl8yal54toNpyGvTl19VqqJ+rhe1fTYqyuN4Vpenbr6rFQTjeH8rOnvoj6uVzXdrx0G9sqgiz6UhQ9Mz4RPXZuT/zk2B3373JRMenr9TWebU1eflezfTdsW34tb7dIxQ79xTpbMmpe7T7o8x/zv1zLkix/Jy/dO2egIzHe+C6ruOYmbagOoznYZdE2YUP0fQ1Df3nypNC06tkvJpKe36C6VjoP2yP5fOT0LH3wyb7/+ZgZ89qQseuipLHrwyQ36tu/TfYNlLXdunx3at8mid33AXPLsy0mSdr26Zckz89Yvr+4P6c19MK2s4Z025Ytez6o3y9OuV7carVedzvv1yUHfOjdvzXslD37uh5vdn83bt8lRt4xOcZMmeeC8sVv0QfOwGz6f9n265/Erf7XVH/jctlfX7Hf5J/LaEy/k6Rv/msqKikz/3h+y/+Wnp9+5x2fWzXdX7d+zSw7/8cVZ/eby3H/udZud0qC4edOMuHlUWnZunwnnXrfZKQSS5MCrzknXYQPyzC/G58U/TXxPr29LrHqjfIMv51p365gkefXxZ2v9rK+Bnz8lnfftk8euuCVvzS3Nk9+/Pbt94MAceNXZWfjgkxv8UdP//BOz54cOy8v3PJ6nfvinzW6/Po69ulLTY7qu983WsLG7PJfNe6XaL3+3RGM4P3fYqU0Oue78LJv/aqZc9eusKV+Zx756c4746SXZ78sfz5RqHio99BvnpE2PnXPf2d/NqqXL8tgVt6Tb8IE59Hufy19HfDFryquO8K1pTbsdf1AGjjxl3VQxl/9is/1rul+3htefenGDZWvfXp0Vryyp9fFUE3W9j2pz7O18UL/0+/TxmTv+0fU32zz323+sD1nm/2PT0xhuSqFfy6uz4tWlWfHq0irLugztlyTv6Rja3s7PxnAt3+NDh6Xn8Qdl5k135tXHn82rjz+b3U8aloEjT8m8vz+WxTM2/6VjXX1W2lL1cb2q6bFXVxrLtbw6dfFZqSYaw/lZ099FfVyvarpfi5s3zWHXfz5rlr+dyZf+NGtXrMrkL/4kx/75Gxl2zWdy/7kbjhKtTl18VrJ/N7/tbfG9+NDvX5CmrXbIxItvzNq3V2fyJT/JyfeNzfAfXpi7T/xqtdMktuvVLctfWVLt6LJNtQFUZ7t8RhdsK+b88cG06rJTBpx/UrXt756LuGmrFjnip5dk1RvLMnHk9Xnksp/lrZdfzWHXj1z/rKt327H3rtnt2AOrLBs48pQkycv3PL5+WemjzyRJOu/ft0rfd/6Qfve/zU0htqZ8ZZrXYHRWZUVFXnns2XTer/cWr1Odlp3b58hffCmVFRW5/9zrsmoTz/xK1t0VfMT/XJK2Pbvksa/dktemvbDZnzH4klOz27FD8+KfJ+aZn21+2pIaKSrK8B+OTPH/PY/onQ+AT//4bymbPjv7Xf6JKtNNNm25Q0bcMjrN2rXKQyOv36I74w4ec14679snT93w57x89+an+tjj1MPT/9PHr5v2YQv/aN4W7dSvZwZf8pGUPjxzfRhRsXpNJn3hx2nacoccOvazVfp3PWRADrjizP+b/mHzIxPq49irKzU9put632yzGsn5efB3zkuLTjtm8hd/uv4L8Jf+Ojnz/v5Y+n36+Ox84F5V+u86Ykj6nn50Zv/xwfXBxaqly/LIZT9Lmx4758Arz3pPNe3Yt3sO+9H/TRVz7nWbnSqmNvu10NXHPqrpsde05Q4Z/oMLsmrpsjx62X+myJvyjd9k2YLX1t0NX4vnTCWN4Fpej7a387MxXMtb7tw+B33rU3lj9sJM++5/RqNMvvSnWbPi7XXXmWbb/j2odX29qumxV1cay7V8W9RYzs+a/C7q43pV0/2aJPt+6WPZae/d8vhVv15/s8Crjz+bWTf/PT2PPyi9Tjl0i7ZTF+zfTdsW34v3Ouv92fWIwXnqhr+sD4bfmluaaWNuTed9+2SfCz+4wTpFxcXpOHiPvPLIMzVqA9iYbf/TNDRiz/xifHY5YlAOvPKsdBu+T0omPZ3Vy5an9a6d0m34wKx9e3XuPfWqJMmwa85L29275J+f+Pb6O5Qe+twPc9zfrs7w6z+ff51e9RkFi5+Zl8NuvCjP//6+vPliSboduk92P2lYSh+emZf+9vD6fm+//mZKJj+d7u/bN1O/+Zv39Hpem/ZC+nz8qOw7+rR1zwirqMz8f0zd5ANa5975cHocs386Demdsumza/Vzj/zFpWndrWPm3f1Y2u/dI+337lFtvxWvvZGSh57KkFEfza5HDM7SFxZkzfKV2ePDh2102y/+aWJ2OWJwhnzpo1mz4u2UPjJzk/0XPfhUjUfoDPjsSekydO9Mvfq3Ve7GqqyoyKSLb9xgirRh152fDv175pXHZmWHndpstJ415Svz8j1T0ucT70vfT7wvK15bmjdeWLjJ+l+++/G06dklh1x7firWrs38e6Zs8kP4q1Oeq/EzlOpLUdMmGf6jkalYs+7LsHd7/akXM+PHf60y7VHLndvnyJ99McVNm2Tu+EfT4wMHbHTbS555OUtmzavzY6+u1PSYLiouqvN9s61qDOdnzxOHpdcph+bZX92TkklV76x9ZPTP0uWgflWmgmnerlUOGfu5lJe8nsevuLlK//n3TsmcPz1UZYq09nvvVqOaVry2NEfdMjrN2rTMi3+dVO1zHd7x1txX8tq/n6/xfi10TVo2r/N9VNNjb82Kt7P/185Mu17d8sBnvldlGpk15Ssz+dKfvqcpDAv9Wl5ftrfzs7Fcyw8Z+7k0a9cq/zpzTJUpt5Yvej1TvvGbGk9h2BDq+npVm2OvrjSGa/m2qLGcnzX9XdT19ao2n9M779cnAz53cub/69+Z/b9VZzyaNubWdH/fflttir2asn83bVt8L27TY+cc8LUzs/jpl/LkD26v0mfWL+5OzxMOrnYKwy7D+qdZ65aZe9fD/73pTbYBbIygCxpQ5Zq1+dcZ38ne5xybPU89PENGfTRJsqJ0SV6bPjtz/u/Bv3t+5IjseeoRmXHjX6tMU1g2fXamffe2HPj1szLg/JMy86Y717ctnvFiplz1q+z35U9krzOPyeplKzLr5rvz7zG3bjDdw3O/vjdH/uzSdBy0R7VTD2ypaWNuTfP2bbL3OR9I8x1bp6i4OLcf+LlNTqMy946Hc+BV52TPUw+vddD1zhRAPY8/KD2PP2ij/UofnpmSh55a3799n+45/MaLN7ntF/80MTsfsFeKiovTtOUOOeS6z26y/z0fujKlNfiwumOfXbPf6NPy6tTnMvN/7tygfenzCzaYIq3L0L2TJF0O6pcuB/Xb6LaXzX81L98zZX3/lp3b57DrP7/Jem4/8HPpNGiPNG25Q5LkwKvO3mT/SRffmNnbaNA1+JJT03Fgrzzy5Z9n2fwNa/zvaY/a9eyaFh3XjaIcfPGHN7nt6WP/kCWz5tX5sVdXanpMJ6nzfbMtagzn54LylRn23U/nrXmvZOrVv9ugz8qyNzaYCmbot85N61065p+nfzur3ly+wTr/PUVaTWsqfXhmdtxzlyTJXmcck73OOGaj/WePuz+v/fv5Gu/XQtey4451vo9qeuy13b1r9j77/Xnpjocz985HNuhT8tBT72kKw0K+lten7e38bAzX8t6nHZUex+yfGT/+a7XhzAu33lfjKQwbQl1fr2pz7NWVxnAt3xbtuOeuBX9+Ll/0eo1/F3V9vUpq9jn9zZdKMvxHI7N62Yo8/KX/2aDP2pVbb4q9mmrRsZ39uxnb4nvx8B9emOLmTTPx4hurfTbaxqYw3PPUw7P8lSXVfjbYVBvAxhRV1vShOtSL8uWr0+bg9za6pj4te/SstG7VrNbrr16+Mr/f84ytWNH27ZyS2zN73P0b3Pm6MUXFxTn5vrFZPHNuJo68vo6r29DAkadk4Of/X24/6MLCnd4MAAAAgE1q2bl9PvzYj/Pvb/9+g+cdb6qtEJ0+53dp1qpFQ5cB27Ty8vK0abPuUTjLli1L69a1mw7fM7qAVFZUZOo3f5NepxyaHfvsWu8//5mfj8+qN8qzz+dOrvefDQAAAED9GPj5U1K+6PU8++t7a9QGsCmmLgSSJAvvn57fdP9Yg/zstW+vzu1DL2iQnw0AAABA/Xj8679Kvv6rGrcBbIoRXQAAAAAAABQkI7qgEfpVt1MbugQAAAAAAKhzRnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAXJM7q2Ua1aNs2yR89q6DK2WKuWDiUAAAAAAKB+SSe2UUVFRWndqllDlwEAAAAAALDNMnUhAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUJEEXAAAAAAAABUnQBQAAAAAAQEESdAEAAAAAAFCQBF0AAAAAAAAUpEYfdJWVlWX06NHp3bt3WrRokR49euTiiy9OeXl5zj333BQVFeXGG29s6DIBAAAAAACooaYNXUBdmj59eo477riUlpamdevW6d+/fxYtWpTrr78+c+bMyeLFi5MkQ4YMadhC2WLN27fJoIs+lN2OPTCtu3XM6vIVWfLs/Dxx3bi8+tishi4PAAAAAACoR4026CorK8tJJ52U0tLSXHrppbnyyivTtm3bJMm1116byy67LE2bNk1RUVEGDRrUwNWyJVp375Rj//SNNGvdIi/cOiFvvFiS5u1aZad+u6V11w4NXR4AAAAAAFDPGm3QddFFF2XBggUZOXJkxo4dW6Vt9OjRufXWW/Pkk0+mV69eadeuXQNVSU0cfuPFKW7SJH876tKseHVpQ5cDAAAAAAA0sEb5jK5Zs2Zl3Lhx6dSpU8aMGVNtn/333z9JMnjw4A3a/vKXv+SQQw5J69ats+OOO+bQQw/NzJkz67RmNq3Lwf3S5aB+mfGTv2XFq0tT1LRJmrRs3tBlAQAAAAAADahRjui67bbbUlFRkdNPPz1t2rSptk/Lli2TbBh0XX/99bn00ktzySWX5Oqrr87bb7+dxx57LCtWrKjzutm47kftlyQpX1iW9/36y9n1qH1T3LRJ3pizKE/+4I958U8TG7hCAAAAAACgvjXKoGvChAlJkhEjRmy0z4IFC5JUDbrmzJmTUaNG5Qc/+EFGjhy5fvnxxx9fR5Wypdr13iVJcsjYz+bNF0sy6eIbU9ysaQZ89qR1Uxo2bZrZ4+5v4CoBAAAAAID61CiDrnnz5iVJevbsWW37mjVrMnny5CRVg65bbrklzZo1y3nnnbdV6znggANSWlq6VbfZ2DSrLM6VGbrx9tbrRuCtXrYi9556VSpWr0mSvHzP4/nwoz/Ofl/5RGb/4YGksrI+ygUAAAAA2Ki+ffpmdVFFQ5cB27SKiv+cI8OHD88TTzxRq+00yqCrvLw8STY63eC4ceNSVlaWtm3bplevXuuXP/zww9lrr73yu9/9Lt/61rcyf/789OnTJ1//+tfz8Y9/vNb1lJaWZuHChbVef3vQvKhJ0mXj7WtXrkqSvPTXSetDriRZ9UZ55v9janp/9Mjs2HuXvPGC/QwAAAAANKxFJYuyqnJtQ5cBBeOVV16p9bqNMujq2rVrlixZkmnTpmXYsGFV2kpKSjJq1KgkyaBBg1JUVFSlbeHChfnKV76Sa665Jj169MjNN9+cT3ziE+ncuXOOPvroWtfDpjWrLE42cYNDecnrSZIVry7doG3FK0uSJM13rP55bAAAAAAA9WmXbrsY0QWbUVFRkZKSkiRJly6bGAmzGY0y6Dr66KMza9asXHPNNTnmmGPSt2/fJMmUKVNy5plnpqysLEkyZMiQKutVVFRk2bJl+e1vf5tTTjklSfK+970vzzzzTK6++upaB11Tp06t9WvZXqxevjK/3/OMjbaXPTE7OfsDad2t4wZtrXZZt2xl2Rt1Vh8AAAAAwJZ6/oXn06xVi4YuA7Zp5eXladNm3QCWSZMm1Xo7xVuroG3J6NGj07Fjx8yfPz8DBgzIwIED06dPnwwdOjR77LFHjjrqqCRVn8+VJB06dEiSKoFWUVFRjj766Dz99NP19wLYwMv3PJ5Vby3PHh8+PE3fdYFouXP77HbsgXlj9sK8Nddz0AAAAAAAYHvSKIOu7t27Z+LEiTnhhBPSokWLzJ07Nx06dMhNN92U8ePH5/nnn0+yYdA1YMCAjW5z5cqVdVozm7bqjfJM/eZv0nqXjjlh/HfS//wTM3DkKTlh/JgUN2uax664paFLBAAAAAAA6llRZWVlZUMXUZ+WLVuWdu3apaioKG+99VZatWq1vu2OO+7IBz/4wfzpT3/Khz70oSTrpjMcMmRIOnTokAceeKCBqm78Njd14Tt2O/6gDLzgg2nfb7ekojKv/vv5PPm9P+TVKc/VQ5UAAAAAAJt3+pzfmboQNuPdUxcuW7YsrVu3rtV2GuUzujZl5syZqaysTN++fauEXEly0kkn5bDDDstnPvOZvP7669ltt93yi1/8IjNnzsw///nPBqqYd3v57sfy8t2PNXQZAAAAAADANmC7C7pmzJiRZMNpC5N1z+O64447ctlll+Xyyy/Pm2++mcGDB+fuu+9e/1wvAAAAAAAAtg2Crv/Svn373HTTTbnpppvqsywAAAAAAABqqLihC6hvmwu6AAAAAAAAKAzb3YiuCRMmNHQJAAAAAAAAbAXb3YguAAAAAAAAGgdBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAVJ0AUAAAAAAEBBEnQBAAAAAABQkARdAAAAAAAAFCRBFwAAAAAAAAWpaUMXUB/Kyspy7bXX5s9//nMWLFiQzp0750Mf+lC+853v5KKLLsott9ySG264ISNHjmzoUtmIIZd+NEO+9NGNtlesXpPf7HZaPVYEAAAAAAA0tEYfdE2fPj3HHXdcSktL07p16/Tv3z+LFi3K9ddfnzlz5mTx4sVJkiFDhjRsoWzSvLsfy5tzSzZYvlO/nhl44SmZ/89/N0BVAAAAAABAQ2rUQVdZWVlOOumklJaW5tJLL82VV16Ztm3bJkmuvfbaXHbZZWnatGmKiooyaNCgBq6WTVkya16WzJq3wfJh1/ZLkrxw6331XRIAAAAAANDAGvUzui666KIsWLAgI0eOzNixY9eHXEkyevToDB48OGvWrMnuu++edu3aNWCl1EbTljuk1wcPTfnCsiy8f3pDlwMAAAAAANSzRht0zZo1K+PGjUunTp0yZsyYavvsv//+SZLBgwevX3bkkUemqKio2n+f/exn66V2tszuJw1L83atM/sPD6SyoqKhywEAAAAAAOpZo5268LbbbktFRUVOP/30tGnTpto+LVu2TFI16PrJT36SN998s0q/8ePH51vf+lZOPPHEuiuYGuvzifelsqIiL9w2oaFLAQAAAAAAGkCjDbomTFgXfowYMWKjfRYsWJCkatDVv3//Dfp9+9vfTufOnXPsscfWqpYDDjggpaWltVp3e9GssjhXZugW92+35y7pclC/LHroqSyb/2odVgYAAAAAUDN9+/TN6iKzUMGmVLxrprbhw4fniSeeqNV2Gm3QNW/evCRJz549q21fs2ZNJk+enKRq0PXfXnvttdxzzz254IIL0rRp7XZXaWlpFi5cWKt1txfNi5okXba8f5+PH5UkeeHW++qoIgAAAACA2llUsiirKtc2dBlQMF555ZVar9tog67y8vIkyYoVK6ptHzduXMrKytK2bdv06tVro9u57bbbsmbNmpx55pm1rqVr1661Xnd70ayyONnCGxyKmhSn90eOyMrFb2be3x+r28IAAAAAAGpol267GNEFm1FRUZGSkpIkSZcuNRgJ818abdDVtWvXLFmyJNOmTcuwYcOqtJWUlGTUqFFJkkGDBqWoqGij2/ntb3+bfv365YADDqh1LVOnTq31utuL1ctX5vd7nrFFfXu8/4C03HmnPPPzu1Kxak0dVwYAwLZoyKUfzYwb/5K1b6/O8B9emMUz5+aZn4+v0TZ2O/bArHh1aV6b9sJm+/b+6JEZevUn8+ZLpbnr2MuSJC06tsthN3w+bXt2zdpVq/PoV36eVx6dlSQ57McXZ5fh++Slv03O41//VY1fHwAAhe35F55Ps1YtGroM2KaVl5enTZs2SZJJkybVejvFW6ugbc3RRx+dJLnmmmvy/PPPr18+ZcqUjBgxImVlZUmSIUOGbHQbzz77bKZOnfqeRnOx9fX5+PuSJM/fOqGBKwEAoKEM+dJH02SHZu9pG7sdOzSd9++7xf1LH565PuRKkv2/ekZe+/cL+fOhn8+kL/w4h//4Cylq2iRJMvHCH+W53/zzPdUHAADA5jXaEV2jR4/Orbfemvnz52fAgAHZe++9s3LlysyePTvHHXdcdt9999x7772bfD7Xb3/72xQVFeX000+vx8rZlJZddsquI4bktWkvZOmzLzd0OQAANIBh13wmSXLcX69O5dqKLH9lSXbss2ve/4cr03qXjln63Pw8+NkfpGL1mhQ1bZL9Rp+WrsP3SZNmTfPGiyV5ZPRN6bx/3/R4/wHpdvig9P7okZn1y3uy4J//zuE//UKatW2ZJjs0T+nkp/PYFbcklZXV1rH7ycPy52GfT5K8/uScLH9lcboO65+SiTPqbV8AAABs7xrtiK7u3btn4sSJOeGEE9KiRYvMnTs3HTp0yE033ZTx48evH+W1saCrsrIyv//973PkkUdmt912q8/S2YTeHxuR4qZN8vyt9zV0KQAANJBHLvtZkuTvp3wtdxwzKivL3kiHAb1y39lj8tfDv5AWnXZMzxMOSpLsc8EHs3rF2xl//FdyxzGjsuTZl7PvZR/PwglPZP4/pmbmT+/IHceMygu33pdVb5bnvrO+m7s+cFnuOOrStOmxc3qdfEi1NeywU5sUN22aFa8tXb9s2fzX0nrXznX++gEAAPiPRjuiK0n69euXu+66a4Ply5Yty9y5c1NcXJx99tmn2nUfeuihzJs3L1deeWVdl0kNzLj+z5lx/Z8bugwAALYxL//9saxdsSpJUjZ9dtru3jXJuudwNW/bKrsfvy74Km7eNMvmv1b9RoqLsv8VZ6TL0L2ToqK07NQuS599OS/9bXK9vAYAAABqrlEHXRszc+bMVFZWpm/fvmnVqlW1fX7729+mZcuWOfXUU+u5OgAAoKbWvr16/f+vXFuR4ibrnpVVVFSUx664JYsefHKz2xhw/klp2WnHjD/hK1n79uoceNXZadKi+ueAvb1kWSrWrk3Lzu3Xj+pq06NzyhduJEQDAACgTjTaqQs3ZcaMdXPmb2zawpUrV+b222/PKaeckrZt29ZnaQAAwBZY9dbyNGtX/U1r7/byPY+n/2dOTJOWzZMkTVo2T/u+3f9vGyvSrO1/ttF8x9ZZ8eqSrH17dVp2bp/dTxy2yW3Pu/OR7HXW+5MkHQfvmVZdO6T0kWdq+5IAAACohe1yRNfmgq4WLVpk6dKl9VgRAABQEzP/5868/3+/nrUr3s7yV5ZstN+MG/+awV9slhPHj8n/Z+/O47Qq6/6Bf4Z9FwUVFERkUUAWNxTFFNMeccvK0nLJMjOVNDOw7Cn1aTGUMg3tse1XPamRVpZLWkkS4gYSLoiKKAjCqCOorMLA/P4gpyYGYUZmhjO8368Xr/Jc1znznXvOfc6578+5rlNRsX7ZU9ffnjeeW5A5t03K8GtHZbejh+aZn9+TWT+5O4f/+OJ88P5rsrJ0cRZOfuJda5j2zV/l0PEX5MNTfpC1a8ozedR1qShfuyV/TQAAADZB0AUAABTO49+7NY9/79Zq26b9zy8r/3/F2nWZcfWEzLh6wgb9Xn98Tv5w+EVVlt11zFc2u4ZVZW/mL6d8Y7P7AwAAsOVtk1MXTpw4MRUVFTn22GMbuhQAAKAAyletzg4Dds9x94zdrP6HXn9h9vjIoVm9dGUdVwYAALBt2yZHdAEAANTE3D8+mLl/fHCz+08+/9o6rAYAAIB3bJMjugAAAAAAACg+QRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABRSow+6ysrKMmbMmPTu3TutWrVK9+7dc+GFF2b58uU566yzUlJSkvHjxzd0mQAAAAAAANRQs4YuoC7NmDEjI0eOTGlpadq2bZv+/ftn4cKFue666zJnzpwsXrw4STJkyJCGLZTN0qxNq/T7zDHZ48RD0q77Tlm7ek3emrMoz/3qL3n+N/c3dHkAAAAAAEA9a7QjusrKynL88centLQ0F198cRYtWpTp06entLQ0Y8eOzV133ZWpU6empKQkgwYNauhy2ZSSkhx181ezz5iTUzZjTqZe8Ys88f3fpqRpkwy/dlT2++ppDV0hAAAAAABQzxpt0HXBBRdkwYIFGTVqVMaNG5f27dtXto0ZMyaDBw9OeXl5dt9993To0KEBK2Vz7Lhvn+x8YL/M+umfMuWLN+S5X/01T//4rvzpxK9l6bxXsufpRzV0iQAAAAAAQD1rlEHXrFmzMmHChHTu3DlXXnlltX3222+/JMngwYOrLJ88eXLe//73p3PnzunYsWMOOuig/O53v6vzmnl3zdu3TpKsKF1cZfm6NeVZtfitrFmxqiHKAgAAAAAAGlCjDLpuueWWrFu3LqeeemratWtXbZ/WrdcHJ/8edD3++OM56qij0rRp0/z85z/PhAkT0r1795x00km5884766V2qlf2j+fz9hvLMvD8D6bHccPSdtfO2a73Ltn30k+k06A9MuO7tzZ0iQAAAAAAQD1r1tAF1IWJEycmSUaMGLHRPgsWLEhSNeiaMGFCSkpKcvvtt6dNmzZJkiOPPDJ77LFHbrrpphx33HF1WDXvZvWby3PfmWNzyLjPZcSPL/7X8qUrcv9nxuWle6Y2YHUAAAAAAEBDaJRB17x585IkPXr0qLa9vLw8U6ZMSVI16Fq9enVatGhROdorSZo2bZr27dtn3bp1ta5n//33T2lpaa3X3xY0r2iSyzL0XfuUL1+VJc/Oz/w/T8ur055Ny47tstenjs77bvhC7jtzbBb9/Yl6qhYAAAAAYOP69umbNSW1/04ZtgX/nrsMHz48//jHP2q1nUYZdC1fvjxJsnLlymrbJ0yYkLKysrRv3z49e/asXH766afn+uuvz8UXX5xLLrkkzZo1y4033pjZs2fnhhtuqHU9paWlefnll2u9/ragRUnTZOeNt3fca7cc88dvZurlv8izv/xz5fIXbn8gJ/7tmhwy7nP57UGjUvEeAkkAAAAAgC1h4aKFWV2xtqHLgMJ45ZVXar1uowy6unTpkiVLlmT69OkZNmxYlbZFixZl9OjRSZJBgwalpKSksm3w4MG577778uEPfzjXXHNNkqRt27a59dZb8773ve891cO7a17RJHmXjGrAZ49Ls9YtM/eOB6ssX7tydRb89bH0O+uYtOu+Y5bOq/2bAQAAAABgS9il6y5GdMEmrFu3LosWLUqS7Lzzu4yE2YRGGXQdeeSRmTVrVsaOHZujjjoqffv2TZJMnTo1p59+esrKypIkQ4YMqbLe7Nmzc/LJJ+eAAw7Ieeedl6ZNm+amm27KKaeckjvvvDNHHHFEreqZNm3ae/p9tgVrVqzKTb1O22h7m647JElKmjTZoK2kWdMq/wsAAAAA0JCem/1cmrdp1dBlwFZt+fLladeuXZLkgQceqPV2NkwNGoExY8akU6dOmT9/fgYMGJCBAwemT58+GTp0aPbYY4/KwOrfn8+VJJdeemnatGmT3//+9xk5cmQ+8IEP5Be/+EUOPPDAXHzxxQ3xq/BPbzy3IEnS++QRVZa36NAmu/3XAXl7ydIsfdFz0AAAAAAAYFvSKIOubt26ZfLkyTn22GPTqlWrzJ07NzvssENuvPHG3HXXXXnuueeSbBh0Pfnkkxk8eHCaNas60G3//ffPrFmz6q1+NvT0j+/MqsVLs99XT82hP/h89jzjAxl4wYdz/F+uTpsuO2T62F97PhcAAAAAAGxjGuXUhUnSr1+/3HnnnRssX7ZsWebOnZsmTZpk7733rtLWpUuXzJgxI+Xl5VXCrqlTp2bXXXet85rZuOULynLXMV/O4C9+NF2HD0zPDx6S8lWrs3jm3Ey94pd56e5HGrpEAAAAAACgnjXaoGtjZs6cmYqKivTt2zdt2rSp0nb++efnYx/7WD70oQ/lnHPOSdOmTXPzzTdn0qRJufbaaxuoYt6xdN4reeDC8Q1dBgAAAAAAsJXY5oKuJ598MsmG0xYmyUc/+tHccccdGTt2bD75yU9m7dq16du3b2666aZ84hOfqO9SAQAAAAAAeBeCrv9w3HHH5bjjjqvPkgAAAAAAAKiFJg1dQH3bVNAFAAAAAABAMWxzI7omTpzY0CUAAAAAAACwBWxzI7oAAAAAAABoHARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACmmbCLrKysoyZsyY9O7dO61atUr37t1z4YUXZvny5TnrrLNSUlKS8ePHN3SZAAAAAAAA1ECzhi6grs2YMSMjR45MaWlp2rZtm/79+2fhwoW57rrrMmfOnCxevDhJMmTIkIYtlE1q1Xm77DP65HR7/75pteN2WfnaG3npT49mxtUTsvqtFQ1dHgAAAAAAUM8addBVVlaW448/PqWlpbn44otz2WWXpX379kmSq666KpdcckmaNWuWkpKSDBo0qIGr5d206tQhx919ZVrvvH2e+7+/ZMmz87P9nt2z5xkfyM4H9s/dH/xq1q5c3dBlAgAAAAAA9ahRB10XXHBBFixYkFGjRmXcuHFV2saMGZObb745jz/+eHr27JkOHTo0UJVsjkEXfjjtuu+USedekxdvn1K5/NVpz+awH16UAeccnye+/9sGrBAAAAAAAKhvjfYZXbNmzcqECRPSuXPnXHnlldX22W+//ZIkgwcPrrL8r3/9aw466KC0atUqO+20Uz73uc/lzTffrPOa2bguB++d8pVvVwm5kuTFPzyY8pVvp/fJIxqoMgAAAAAAoKE02qDrlltuybp163LqqaemXbt21fZp3bp1kqpB16RJk3L00Udn1113ze9///t861vfym233ZYTTzwxFRUV9VI7G2rasnnWrqpmasKKiqxdtToddu+Slju0r//CAAAAAACABtNopy6cOHFikmTEiI2P9FmwYEGSqkHX//zP/6RPnz659dZb06TJ+hywU6dO+chHPpK77rorxx13XB1WzcYseXZ+dj/2oOwwYPcsnjm3cvkOA3ZPy+3XB1xtd+2ctxcvbaAKAQAAAACA+tZog6558+YlSXr06FFte3l5eaZMWT8N3r8HXY888kg+9alPVYZcSfKBD3wgSXL77bfXKujaf//9U1paWuP1tiXNK5rksgzdaPvTP74rux19QA678Yt59Ov/L288Oz8d9+yeoVecmbWr16Rpi+Zp1rplPVYMAAAAAFC9vn36Zk3JuoYuA7Zq69b96z0yfPjw/OMf/6jVdhpt0LV8+fIkycqVK6ttnzBhQsrKytK+ffv07NmzcnnTpk3TokWLKn2bN2+ekpKSzJw5s1a1lJaW5uWXX67VutuKFiVNk5033v7qI7My6XPfz4Hf/HSOuumrSZJ15Wsz++b70uq5BelxzIFZs7T6vzUAAAAAQH1auGhhVlesbegyoDBeeeWVWq/baIOuLl26ZMmSJZk+fXqGDRtWpW3RokUZPXp0kmTQoEEpKSmpbOvbt28eeeSRKv2nTp2aioqKLF68uNa18O6aVzRJNnGDw7w7H8pLdz+S7fvtlmbtWuet51/OqtffyrF3X5l1a8rz1txF9VMsAAAAAMC72KXrLkZ0wSZUVFSkoqIiSdK1a9dab6fRBl1HHnlkZs2albFjx+aoo45K3759k6wPrU4//fSUlZUlSYYMGVJlvQsuuCBnnHFGvvnNb+Zzn/tcFixYkPPOOy9NmzatMp1hTUybNu09/S7bgjUrVuWmXqdtsl/FunVVntHVeseO6bR3z5Q+9HTWrlxdhxUCAAAAAGye52Y/l+ZtWjV0GbBNqF1yUwBjxoxJp06dMn/+/AwYMCADBw5Mnz59MnTo0Oyxxx454ogjklR9PleSnHbaabnkkkvyjW98IzvuuGP233//jBgxIkOGDHlPiSJ1oKQkQ7/56ZQ0bZInrv1tQ1cDAAAAAADUs0Y7oqtbt26ZPHlyRo8enUmTJmXu3Lnp379/brzxxpx99tnp1atXkg2DrpKSknznO9/JV7/61bz44ovZdddds91226VTp075/Oc/3xC/CkmatWmV4/50Zeb96dEse+nVtGjfJj0/NDydB/fKY1fenNIHa/f8NAAAAAAAoLgabdCVJP369cudd965wfJly5Zl7ty5adKkSfbee+9q123fvn0GDRqUJPnxj3+clStX5lOf+lSd1svGrVtTnsUz52WPDw1Pm522T/nKt1P2+Jz8+ePfyML7H2/o8gAAAAAAgAbQqIOujZk5c2YqKirSt2/ftGnTpkrbtGnT8pe//CX77rtvysvL89e//jXXXXddxo0bVzkKjPq3bk15/n7e9xu6DAAAAAAAYCuyTQZdTz75ZJINpy1MkpYtW+aOO+7IlVdemfLy8gwcODATJkzISSedVN9lAgAAAAAA8C4EXf9h4MCBefDBB+u7JAAAAAAAAGqoSUMX0BDeLegCAAAAAACgGLbJEV0TJ05s6BIAAAAAAAB4j7bJEV0AAAAAAAAUn6ALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSCUVFRUVDV0EVFRUpHzl2w1dBgAAAADAe9asdcuUlJQ0dBmwTRB0AQAAAAAAUEimLgQAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABRSs4YugPpVUVGR8pVvN3QZAAAAADSAZq1bpqSkpKHLAIAtRtC1jSlf+XZu6nVaQ5cBAAAAQAM4dc6v0rxNq4YuAwC2GFMXAgAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFtE0EXWVlZRkzZkx69+6dVq1apXv37rnwwguzfPnynHXWWSkpKcn48eMbukwAAAAAAABqoFlDF1DXZsyYkZEjR6a0tDRt27ZN//79s3Dhwlx33XWZM2dOFi9enCQZMmRIwxa6tSgpSf+zj82epx+Vdt12zKrX38qLdzyYGVdNSPnKtxu6OgAAAAAAgEqNekRXWVlZjj/++JSWlubiiy/OokWLMn369JSWlmbs2LG56667MnXq1JSUlGTQoEENXe5WYej/nJmhV5yZN55bkIf/+2eZe+dD6X/WMXn/L7+clJQ0dHkAAAAAAACVGvWIrgsuuCALFizIqFGjMm7cuCptY8aMyc0335zHH388PXv2TIcOHRqoyq1Hx77d0u/TIzP3rodz/2f+9XotfenVHPSts9LzxEPy4u8faMAKAQAAAAAA/qXRjuiaNWtWJkyYkM6dO+fKK6+sts9+++2XJBk8eHCV5S+++GJOOOGEtG/fPttvv33OOOOMvP7663Vec0Pr+aHhKWnSJE//+K4qy2ff9NesWbEqvT7yvgaqDAAAAAAAYEONNui65ZZbsm7dupx66qlp165dtX1at26dpGrQtXTp0owYMSILFizILbfckh/96EeZPHlyjjvuuKxbt65eam8onYf0zrq1a1P2j9lVlq99e00WPzU3nYf0aqDKAAAAAAAANtRopy6cOHFikmTEiBEb7bNgwYIkVYOuH/3oR3n55Zfz97//PbvttluSpFu3bjn44IPzxz/+MSeeeOJm11BRUZEVK1YkSdq0aZOSrfwZV2123j5vL16adavLN2hbUbo4Ow/dK02aN8u6NRu2AwAAAAAA1LdGG3TNmzcvSdKjR49q28vLyzNlypQkVYOuO++8M8OHD68MuZJk2LBh2WOPPXLHHXfUKOhasWJF5Wiyrl27pkmThh9A17yiSS7L0GrbmrZumbWr11Tbtvbt9cubtW6R1YIuAAAAgELq26dv1pQ07lmLACieLl26ZNq0abVat9EGXcuXL0+SrFy5str2CRMmpKysLO3bt0/Pnj0rlz/99NP56Ec/ukH/AQMG5Omnn651PYsWLar1ultSi5Kmyc7Vt61d+Xaat92u2ramLZsnScpXrq6r0gAAAACoYwsXLczqirUNXQYAbDGNNujq0qVLlixZkunTp2fYsGFV2hYtWpTRo0cnSQYNGlRlSsElS5akY8eOG2xvhx12yLPPPlvreramEV3ZyE07K15Zku36dkuTFs02mL6wTZcdsur1N01bCAAAAFBgu3TdxYguALY6Xbp0qfW6jTboOvLIIzNr1qyMHTs2Rx11VPr27ZskmTp1ak4//fSUlZUlSYYMGVIv9cyePTtt27atl5/1btasWJWbep1WbVvZjOez6+FD0nmfPnn1kVmVy5u2bJ4d9t49rzw8q9r1AAAAACiG52Y/l+ZtWjV0GQCwxTT8EKM6MmbMmHTq1Cnz58/PgAEDMnDgwPTp0ydDhw7NHnvskSOOOCJJ1edzJcn222+fN954Y4PtLV68ODvssEN9lN5gXvzDg6lYty79zz62yvI+px6Z5m1a5YXf/b2BKgMAAAAAANhQow26unXrlsmTJ+fYY49Nq1atMnfu3Oywww658cYbc9ddd+W5555LsmHQ1a9fv2qfxfX000+nX79+9VJ7Q3njmZfyzP+7J7sfe1BG/HR0+nzi/dn/sjMy9PJPpvTBmXnhdw80dIkAAAAAAACVGu3Uhcn60OrOO+/cYPmyZcsyd+7cNGnSJHvvvXeVtuOOOy6XXnppFixYkG7duiVJHnnkkcyZMydXX311vdTdkB79+s+zbP5r6Xvaken2/n2zavFbmfWzP+UfV01IKioaujwAAAAAAIBKJRUV21568cgjj+Sggw7KnnvumWeeeaZK21tvvZWBAwemc+fOueKKK7Jq1aqMGTMmO+64Yx566KE0abL5g+CWL1+edu3aJVkfrm3tz+gCAAAAoHE7dc6vPKMLgEal0U5d+G6efPLJJBtOW5gkHTp0yMSJE9O1a9eccsop+cxnPpODDz44d955Z41CLgAAAAAAAOpWo566cGPeLehKkl69elU75SEAAAAAAABbj21yiNKmgi4AAAAAAAC2ftvkiK6JEyc2dAkAAAAAAAC8R9vkiC4AAAAAAACKT9AFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFNI2EXSVlZVlzJgx6d27d1q1apXu3bvnwgsvzPLly3PWWWelpKQk48ePb+gytwoDP/+hHP6ji/ORh6/PmYtuy0mP3tDQJQEAAAAAAFSrWUMXUNdmzJiRkSNHprS0NG3btk3//v2zcOHCXHfddZkzZ04WL16cJBkyZEjDFrqV2O/SU7Nq8dIsfvKFtOjQpqHLAQAAAAAA2KhGHXSVlZXl+OOPT2lpaS6++OJcdtllad++fZLkqquuyiWXXJJmzZqlpKQkgwYNauBqtw63HXhelr30apLkg3/7Xpq3bdXAFQEAAAAAAFSvUU9deMEFF2TBggUZNWpUxo0bVxlyJcmYMWMyePDglJeXZ/fdd0+HDh0asNKtxzshFwAAAAAAwNau0QZds2bNyoQJE9K5c+dceeWV1fbZb7/9kiSDBw+uXPZOMDZ06NC0bNkyJSUl9VIvAAAAAAAANdNog65bbrkl69aty6mnnpp27dpV26d169ZJqgZdzz//fH7729+mS5cuOeCAA+qlVgAAAAAAAGqu0T6ja+LEiUmSESNGbLTPggULklQNut73vvdl0aJFSZLLL788U6ZM2SL19OnTJ02aNHyu2LyiSS7L0IYuAwAAAIAG0LdP36wpWdfQZQBAFV26dMm0adNqtW6jDbrmzZuXJOnRo0e17eXl5ZUh1r8HXXUVRr0TnjW0FiVNk50bugoAAAAAGsLCRQuzumJtQ5cBAFtMow26li9fniRZuXJlte0TJkxIWVlZ2rdvn549e9Z5PV27dt1qRnTFTTsAAAAA26Rduu5iRBcAW50uXbrUet1GG3R16dIlS5YsyfTp0zNs2LAqbYsWLcro0aOTJIMGDUpJSUmd1zN79uy0bdu2zn/OpqxZsSo39TqtocsAAAAAoAE8N/u5NG/TqqHLAIAtpuGHGNWRI488MkkyduzYPPfcc5XLp06dmhEjRqSsrCxJMmTIkIYoDwAAAAAAgPeo0Y7oGjNmTG6++ebMnz8/AwYMyF577ZVVq1bl+eefz8iRI7P77rvn3nvvrfJ8LpI9Tnpf2nXbMUnSqlOHNGneLIO+8JEkybIFr+WF2/7ekOUBAAAAAABUarRBV7du3TJ58uSMHj06kyZNyty5c9O/f//ceOONOfvss9OrV68kEXT9h74ff3+6HDygyrJ9L/l4kqT0wZmCLgAAAAAAYKvRaIOuJOnXr1/uvPPODZYvW7Ysc+fOTZMmTbL33ns3QGVbr3s+cllDlwAAAAAAALBZGnXQtTEzZ85MRUVF+vbtmzZt2mzQfttttyVJnn766Sr/vfvuu2f//fevv0IBAAAAAADYqG0y6HryySeTbHzawo9+9KPV/vcnP/nJ/PznP6/T2gAAAAAAANg8gq5qVFRU1Gc5AAAAAAAA1EKThi6gIWwq6AIAAAAAAGDrt02O6Jo4cWJDlwAAAAAAAMB7tE2O6AIAAAAAAKD4BF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKaZsIusrKyjJmzJj07t07rVq1Svfu3XPhhRdm+fLlOeuss1JSUpLx48c3dJlbhQ57dM2Q0Sfn2Du/nVOe+mlOnf1/OeEvV2fQhR9Os9YtG7o8AAAAAACASs0auoC6NmPGjIwcOTKlpaVp27Zt+vfvn4ULF+a6667LnDlzsnjx4iTJkCFDGrbQrUSfU47IXp86Oi/9eVrm/G5yKsrXpsvBA7Lvlz+R3Y8/OHcdd2nWrlrd0GUCAAAAAAA07qCrrKwsxx9/fEpLS3PxxRfnsssuS/v27ZMkV111VS655JI0a9YsJSUlGTRoUANXu3WYe9fDeeIHv8+apSsqlz37yz/nrRcXZfAXTkqfjx+RZ/7fPQ1YIQAAAAAAwHqNeurCCy64IAsWLMioUaMybty4ypArScaMGZPBgwenvLw8u+++ezp06NCAlW49Xn98TpWQ6x0v/uHBJMn2e+1W3yUBAAAAAABUq9EGXbNmzcqECRPSuXPnXHnlldX22W+//ZIkgwcPrlx222235SMf+Uh69OiRNm3aZK+99spXv/rVLFu2rF7q3lq13aVTkmTla280bCEAAAAAAAD/1GiDrltuuSXr1q3Lqaeemnbt2lXbp3Xr1kmqBl3jxo1L06ZN8+1vfzt/+tOfcu655+aHP/xhjj766Kxbt65eat/alDRpksFfOCnr1pTnhd8/0NDlAAAAAAAAJGnEz+iaOHFikmTEiBEb7bNgwYIkVYOuO+64IzvuuGPlfx922GHZcccdc+qpp+aBBx7I+973vjqqeOs19H/OzE4H7JnHvn1T3pqzsKHLAQAAAAAASNKIg6558+YlSXr06FFte3l5eaZMmZKkatD17yHXO/bff/8kycsvv1zrevr06ZMmTRp+AF3ziia5LEM3u/8+Y05Jv7OOybP/9+c8+YPf12FlAAAAANS1vn36Zk3JtjlrEQBbry5dumTatGm1WrfRBl3Lly9PkqxcubLa9gkTJqSsrCzt27dPz54933Vbf/vb35Ik/fr1q3U9ixYtqvW6W1KLkqbJzpvXd8jFH8vgi07K7Fsm5qExP6rbwgAAAACocwsXLczqirUNXQYAbDGNNujq0qVLlixZkunTp2fYsGFV2hYtWpTRo0cnSQYNGpSSkpKNbufll1/O1772tRx99NEZMmRIrevp2rXrVjOiK5tx086Qiz+WIV/6WJ6f8LdMufiHdV8YAAAAAHVul667GNEFwFanS5cutV630QZdRx55ZGbNmpWxY8fmqKOOSt++fZMkU6dOzemnn56ysrIkedfwatmyZfngBz+YFi1a5Gc/+9l7qmf27Nlp27bte9rGlrBmxarc1Ou0d+0z+KKT1odct07KAxfdkFRU1FN1AAAAANSl52Y/l+ZtWjV0GQCwxTTaoGvMmDG5+eabM3/+/AwYMCB77bVXVq1aleeffz4jR47M7rvvnnvvvbfK87n+3cqVK3P88cfnxRdfzOTJk9O1a9d6/g0axl5nHp19xpySZQtey6LJT2SPDw+v0r7ytTez6O9PNFB1AAAAAAAA/9Jog65u3bpl8uTJGT16dCZNmpS5c+emf//+ufHGG3P22WenV69eSVJt0LVmzZqcdNJJmTZtWu67777079+/vstvMJ2HrH9d2nXbMYde9/kN2ksfnCnoAgAAAAAAtgolFRXb3rx0y5YtS4cOHVJSUpKlS5emTZs2lW3r1q3LKaeckj/+8Y+5++67c8QRR9T65yxfvjzt2rWr/JlFmboQAAAAgMbp1Dm/MnUhAI1Kox3R9W5mzpyZioqK9O3bt0rIlSTnn39+br311nz5y19OmzZt8vDDD1e29erVKzvuuGN9lwsAAAAAAEA1mjR0AQ3hySefTFL9tIV/+tOfkiTf+c53MmzYsCr/7rrrrnqtEwAAAAAAgI3bJkd0vVvQNXfu3HquBgAAAAAAgNowogsAAAAAAIBC2iZHdE2cOLGhSwAAAAAAAOA92iZHdAEAAAAAAFB8gi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFtE0EXWVlZRkzZkx69+6dVq1apXv37rnwwguzfPnynHXWWSkpKcn48eMbukwAAAAAAABqoFlDF1DXZsyYkZEjR6a0tDRt27ZN//79s3Dhwlx33XWZM2dOFi9enCQZMmRIwxa6lejQa5cM/uJH02lgz7TZefs0ad4sy18uy4L7puepG/6Qla++0dAlAgAAAAAAJGnkQVdZWVmOP/74lJaW5uKLL85ll12W9u3bJ0muuuqqXHLJJWnWrFlKSkoyaNCgBq5269C2a6e02aljXvrTo1m+8PVUrF2b7ffaLX1POzI9P3hI/njkl7Lq9bcaukwAAAAAAIDGHXRdcMEFWbBgQUaNGpVx48ZVaRszZkxuvvnmPP744+nZs2c6dOjQQFVuXRY98GQWPfDkBstLH56VET++OL1PHpGnbvhDA1QGAAAAAABQVaN9RtesWbMyYcKEdO7cOVdeeWW1ffbbb78kyeDBgyuXTZ48OUceeWS6du2ali1bplu3bjn55JMza9aseql7a7V8wWtJkhYd2zZwJQAAAAAAAOs12hFdt9xyS9atW5dTTz017dq1q7ZP69atk1QNupYsWZKBAwfmnHPOyU477ZQFCxbkyiuvzLBhw/LUU0+lW7du9VJ/Q2vasnmatW2Vpi2bp2Pf7tnvq6clSRbc948GrgwAAAAAAGC9Rht0TZw4MUkyYsSIjfZZsGBBkqpB1wknnJATTjihSr8DDjgge+65Z37729/mwgsvrINqtz59PvH+HPTtz1T+99KXXsnfz782rz6ybY9sAwAAAAAAth6NNuiaN29ekqRHjx7VtpeXl2fKlClJqgZd1enUqVOSpFmz2r9cffr0SZMmDT9TZPOKJrksQzfZ76V7Hs2bz7+c5m1bZYe9e6b7Bw5Iyx3a10OFAAAAANSVvn36Zk3JuoYuAwCq6NKlS6ZNm1ardRtt0LV8+fIkycqVK6ttnzBhQsrKytK+ffv07Nlzg/a1a9dm3bp1mTdvXr7yla+kS5cu+djHPlbrehYtWlTrdbekFiVNk5033W/FosVZsWhxkuSle6Zm3l2P5Lg/fSfNWrfMkz/4fR1XCQAAAEBdWLhoYVZXrG3oMgBgi2m0QVeXLl2yZMmSTJ8+PcOGDavStmjRoowePTpJMmjQoJSUlGyw/mGHHVY54qt3796ZOHFidtxxx1rX07Vr161mRFdqcdPOklnzsvipF7PXJ/9L0AUAAABQULt03cWILgC2Ol26dKn1uo026DryyCMza9asjB07NkcddVT69u2bJJk6dWpOP/30lJWVJUmGDBlS7fo//elP88Ybb+TFF1/M1VdfnQ984AOZMmVKdtttt1rVM3v27LRt27ZW625Ja1asyk29TqvVuk1btUiL7dtt4YoAAAAAqC/PzX4uzdu0augyAGCLafghRnVkzJgx6dSpU+bPn58BAwZk4MCB6dOnT4YOHZo99tgjRxxxRJKNP59rzz33zIEHHphTTjkl9913X5YuXZqrrrqqPn+FBtF6x47VLu9y8IB03Kt7Xntsdv0WBAAAAAAAsBGNdkRXt27dMnny5IwePTqTJk3K3Llz079//9x44405++yz06tXryQbD7r+XceOHdO7d+88//zzdV12gzto7Nlps9P2WTTlqSxb8FqatmyeToN6pecHD075slWZdsUvGrpEAAAAAACAJI046EqSfv365c4779xg+bJlyzJ37tw0adIke++99ya38+qrr+bZZ5/NgQceWBdlblVe/P0D6fXRw9PrI+9Lq04dUlFRkeUvl+W5//tLnvrhH7P85bKGLhEAAAAAACBJIw+6NmbmzJmpqKhI375906ZNmyptp512Wnr37p0hQ4akY8eOmT17dq655po0a9YsF110UQNVXH/m3vFQ5t7xUEOXAQAAAAAAsEnbZND15JNPJql+2sKDDjoov/zlL3Pttddm1apV6d69e0aMGJFLL700PXr0qO9SAQAAAAAA2AhB138YNWpURo0aVd8lAQAAAAAAUENNGrqAhvBuQRcAAAAAAADFsE2O6Jo4cWJDlwAAAAAAAMB7tE2O6AIAAAAAAKD4BF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAITX6oKusrCxjxoxJ796906pVq3Tv3j0XXnhhli9fnrPOOislJSUZP358Q5e51WraukU+8vD1OXPRbTnwW2c1dDkAAAAAAACVmjV0AXVpxowZGTlyZEpLS9O2bdv0798/CxcuzHXXXZc5c+Zk8eLFSZIhQ4Y0bKFbsX1Gn5JWnTo0dBkAAAAAAAAbaLQjusrKynL88centLQ0F198cRYtWpTp06entLQ0Y8eOzV133ZWpU6empKQkgwYNauhyt0o7DOyZ/mcfm3+Mm9DQpQAAAAAAAGyg0QZdF1xwQRYsWJBRo0Zl3Lhxad++fWXbmDFjMnjw4JSXl2f33XdPhw5GLP2nkiZNcvC4z+Xlv83IS3c90tDlAAAAAAAAbKBRBl2zZs3KhAkT0rlz51x55ZXV9tlvv/2SJIMHD97odkaOHJmSkpJcfvnldVHmVq3/Z4/Ldr13zSOX/qShSwEAAAAAAKhWowy6brnllqxbty6nnnpq2rVrV22f1q1bJ9l40PWb3/wmM2bMqKsSt2rtuu+UIaM/lse/d1uWLXitocsBAAAAAACoVrOGLqAuTJw4MUkyYsSIjfZZsGBBkuqDrrfeeitf+MIXMm7cuJx22mlbpKY+ffqkSZOGzxWbVzTJZRn6rn2GXfXZLJv3SmbeeEc9VQUAAABAfejbp2/WlKxr6DIAoIouXbpk2rRptVq3UQZd8+bNS5L06NGj2vby8vJMmTIlSfVB11e/+tX07ds3p5566hYLuhYtWrRFtvNetShpmuy88fY9PnJodnnfoPzpQ19PRfna+isMAAAAgDq3cNHCrK7wnQ8AjUejDLqWL1+eJFm5cmW17RMmTEhZWVnat2+fnj17VmmbNm1afvzjH+exxx7bojV17dp1qxnRlY3ctNOkRbMccPmZWXDfP7Ly1TfSfvcuSZI2XXdIkrTo0Cbtd++Stxe/ldVvraivkgEAAADYQnbpuosRXQBsdbp06VLrdRtl0NWlS5csWbIk06dPz7Bhw6q0LVq0KKNHj06SDBo0KCUlJZVta9euzTnnnJNRo0ZlwIABW7Sm2bNnp23btlt0m7WxZsWq3NSr+lFqzVq1SOvO26X7Uful+1H7bdDe66TD0uukwzL1il9m5v/+sa5LBQAAAGALe272c2neplVDlwEAW0yjDLqOPPLIzJo1K2PHjs1RRx2Vvn37JkmmTp2a008/PWVlZUmSIUOGVFlv/PjxeeWVV3L55ZfXc8VbhzUr3s7fPjNug+WtOnXIsLGfzYKJ/8jsm+/LklnzGqA6AAAAAACAqhpl0DVmzJjcfPPNmT9/fgYMGJC99torq1atyvPPP5+RI0dm9913z7333lvl+VxlZWX52te+lnHjxqW8vDxvvPFGZduqVavyxhtvpEOHDlvF9IN1paJ8bebd9fAGy9t12zFJsnRuabXtAAAAAAAADaFRpjbdunXL5MmTc+yxx6ZVq1aZO3dudthhh9x4442566678txzzyVJlaBrwYIFWbp0ac4555xsv/32lf+SZOzYsdl+++3z0ksvNcjvAwAAAAAAwIZKKioqKhq6iPq0bNmydOjQISUlJVm6dGnatGlTuXzatGkb9B8xYkQ++clP5swzz8xBBx2UVq02fw7j5cuXp127dpXb39qf0QUAAABA43bqnF95RhcAjUqjnLrw3cycOTMVFRXp27dvZciVJO3atcvhhx9e7Tq77777RtsAAAAAAABoGI1y6sJ38+STTyapOm0hAAAAAAAAxbPNjeiqadC1jc3sCAAAAAAAUBhGdAEAAAAAAFBI29yIrokTJzZ0CQAAAAAAAGwB29yILgAAAAAAABoHQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBCEnQBAAAAAABQSIIuAAAAAAAACknQBQAAAAAAQCEJugAAAAAAACgkQRcAAAAAAACFJOgCAAAAAACgkARdAAAAAAAAFJKgCwAAAAAAgEISdAEAAAAAAFBIgi4AAAAAAAAKSdAFAAAAAABAIQm6AAAAAAAAKCRBFwAAAAAAAIUk6AIAAAAAAKCQBF0AAAAAAAAUkqALAAAAAACAQhJ0AQAAAAAAUEiCLgAAAAAAAApJ0AUAAAAAAEAhCboAAAAAAAAoJEEXAAAAAAAAhSToAgAAAAAAoJAEXQAAAAAAABSSoAsAAAAAAIBC2iaCrrKysowZMya9e/dOq1at0r1791x44YVZvnx5zjrrrJSUlGT8+PENXSYAAAAAAAA10KyhC6hrM2bMyMiRI1NaWpq2bdumf//+WbhwYa677rrMmTMnixcvTpIMGTKkYQvdipy56LZql69ZvjI39T69nqsBAAAAAACoXqMOusrKynL88centLQ0F198cS677LK0b98+SXLVVVflkksuSbNmzVJSUpJBgwY1cLVbl9KHn85zv/pLlWXr1qxtoGoAAAAAAAA21KiDrgsuuCALFizIqFGjMm7cuCptY8aMyc0335zHH388PXv2TIcOHRqoyq3Tsnmv5IXfTm7oMgAAAAAAADaq0T6ja9asWZkwYUI6d+6cK6+8sto+++23X5Jk8ODBlcvuv//+lJSUbPBvW5zasEnzZmnWplVDlwEAAAAAAFCtRjui65Zbbsm6dety6qmnpl27dtX2ad26dZKqQdc7rr/++uy7776V/922bdu6KXQr1eO4g7LHR96XJs2aZmXZm5n7hymZPvbXWbN0RUOXBgAAAAAAkKQRB10TJ05MkowYMWKjfRYsWJCk+qCrf//+Oeigg+qmuK3ca9NnZ+4dD2Xp3EVp3r5Nuh2xb/qddUx2HjYgdx//1ZSvWNXQJQIAAAAAADTeoGvevHlJkh49elTbXl5enilTpiSpPuja0vr06ZMmTRp+psjmFU1yWYa+a5+7jv1Klf+ec+ukLJ41L/t95RPpf/YxeeLa39VliQAAAADUkb59+mZNybqGLgMAqujSpUumTZtWq3UbbdC1fPnyJMnKlSurbZ8wYULKysrSvn379OzZc4P2k08+OWVlZenUqVNOOOGEfOc730nnzp1rXc+iRYtqve6W1KKkabJzzdd76oY/ZMgXP5pu799P0AUAAABQUAsXLczqirUNXQYAbDGNNujq0qVLlixZkunTp2fYsGFV2hYtWpTRo0cnSQYNGpSSkpLKtu222y6jR4/O+973vrRr1y4PPfRQrrzyyjz88MOZNm1aWrVqVat6unbtutWM6EotbtqpKF+bFa8sTssd2m/5ohqpXY/YJ+//xZfzhxEX5c3nF26y/0mP3pBl81/LPR+57D3/7KYtm+dDk6/NnN9Nzj++c8t73h4AAABsqw644sx0e/++uf3wi1JRvnaz27ZWu3TdxYguALY6Xbp0qfW6jTboOvLIIzNr1qyMHTs2Rx11VPr27ZskmTp1ak4//fSUlZUlSYYMGVJlvX322Sf77LNP5X8ffvjh2XvvvXPCCSfklltuyac+9ala1TN79uy0bdu2dr/MFrRmxarc1Ou0Gq/XtGXztO3aKa9Nn10HVTU+JU2b5IDLzsgLv5u8WSHXxvQ/+9isfnN5nv/N/TVb75zj06JD28z84R+TJHt9emQO+tZZeezKm/PkdRuOyGvRsV1OvP+arH17df5wxMU58pdfSZeDB2zy58wY95vM+O5vMuTij2XIlz62yf6lD87MPR+5LF2GDcjRv7tis36Xn3c9KYf/+OLsNnJo7vnwZXn10Wc26LPT0L1y9O+uyEt/ejT3n/3dyu1PveKXmfm/f6zsd+ai2zL/L4/lvjOurFx29G+vSKfBe+Sm3qevX1BSkpG//590Htwrf/zA6Lw5++UqP6tV5+1y4v3fy+o3V+QPR16cfcackr0/d0Imnff9vPj7Bzaorf3uXXLCfePyxqyXcvcJ/52KdfXzYaJp6xb54F+/mxbbtcnth12UVa+/VaV9u77dcsK9V6Xs8Tn504e+nlRU5MxFt23Wtu/58GUpfWhmjv7tFXW2n/z1jCvzwYnfTdOWLXL74Rdl9RvLNug38IIPZ7+vfCIPX/qTPPP/7qnc/h1HX5LXH5+TJJu1L+wwsGeOvfPbKX1wZv7y8W9WW9NRt/x3uhw8IHcdd2mN+i5+8sVN/r5byr5f+UQGXfDhPHDRDXn+1xM3aD/6t1dkx/365o7/GpM3np2f4d8/P71P3vhzLN/x/IS/5YEvXJ/eHzs8w68dtcn+y+a/mtuGnpd23XbMSVN/uFm133bAuVm24LX0Pe3IHHz15zLje7dmxtUTNuh36A8+n14nHZY/n/KNLJz0eOXvVeU9nGz2vrDLYYPzgV9/Lc/fOikPXPCDDX7ePmNOyeCLTsqUL/1vXp44PSf+7ZosX1iWO/7rkqxbU75B/2FXn5M9Tzsqfz39yiz462Ob9bu/V/tfdkaNjkEfeXh82nXfaZPbfeDC8Xn+N/fX+X6SJO+7/sL0PPGQ/Pnkb2TRA09W6de0VYuc8Jer03KHDvnD4Rdl5WtvJNnM43k23Bdqcj5JUqNzT31pvWPHfPD+a/L24rfyx6NGZ+2q1VXauw4fmA9M+FpeuH1KJp9/ba3eiyc9ekOd7SfTx95S4/fSO9u/ZcCn8vbipUlSua/97TPjMu+uh5Ok8ned9bM/5ZGv/jRJ0nHP7jn+3qvy2mPPVXszUZ+PH5FDvndeHr/2t+tvDqrhdcDalas32GZdaNN1hxq9bq12aF/nx+ya7CerlizNkb/8Sp791V/y0OgbN+jTpHmzHH/v2LTdpXNuH3FRVixanJMevSFrlq/KH0Z8sbLf5uwLNT0u9vnEETU+99SHml7/bk3Xcfd85LJavZeqew8n2ex9oabnk5pcB8y+6a+b/N23pJpeE9X157EkNd7HavP61vZ43+2o/Wp0jGnRoW3Nzg1Jnhp/e/Y8/ajs9cn/yqyf3l2l/7u1ba2em/1cmrep3Y3cALA1arRB15gxY3LzzTdn/vz5GTBgQPbaa6+sWrUqzz//fEaOHJndd989995772Y9n+u4445L27ZtM23atFoHXUXRcvt2eXvJhl8o7zPmlDRp3izz/1y7OTK3NbsfPywd+3bPpHO/v9nr/G74BUlF1WX9zz42y+a/VqOgq2mrFtn73BMye8LfsvrN9VN4PvOzP2W3o4dmyBc/mgV/eSxLZs2rss5B3/5MWu+4Xe496YqUL1+Vx6/9bZ67ufoPc01bNM8Bl38yzdu1zqvTnk2SzLv7kbw1d+PTc+79uROyw94988qjs5Ikb8xekL+Punaj/bu9f7/s8aHhlf0f+vKPs/OB/TL8++fnj+//UspXvv2velq3yPDvn5+3Fy/NQ5f8aDNeoU2oqMgDX7g+J9w3LsOvHZW7j/tqlXDq4KvPSYuO7TLxU1dl7crV+cd3bkm3I/bJgd88K6VTnsrKV9/417ZKSjL82vNTUlKSyReOr7eQK0nWrlydBy66Pkf/7oocNPazuf8z4/5VVtMmOfS6z2fd2rV54MLxScX6He/d/ibtd9s5+4w5JatefzNvzln/RUVd7ifly1dlyhduyH/ddlmGXXl2Jp17TZW+HffaLUO++NEs/PsTeeb/3bN5L8pGLH7yxTxx7e+yz+iTs+cZH8izv/xzlfa+px+VXQ8fkn9c9esa961PM8b9Jt2P2i9DL/9kFk6akRWLFle29f/scely8IA89q1f5Y1n5ydJnv2/v2Th5Ceq31hJSfb78ifSdtfOeeWfX66VPvz0u+4jvT96eHY5bHBl/1Wvv/Wu/TsP6ZP+nzkmb85ZmJWvv5kkee5Xf02PYw/KoM9/KC/d82iV13C3kUPT66TD8uwv/7zFvmhcOOnxPPurv2TP047KvDsfqnKO6zS4VwaOOjEv/+0flV++PPK1n+XQ6z6ffUafnMe+fVOVbe1y+ODsedpRmX3LxHoLuZLU+Bj06Nf/X5q1rf5LjZYd2+eAy87IuvK1KXvihSR1v58kycNf/Wm6HLJ3Dvneubl9xBdTvnxVZdt+Xz012/XeNZM+d01lyPVe1Oh8UlJSf+eeGlj52ht55L9/msNu+EL2/fLHM/XyX1S2NW/XOodcc15WvvpG5ZfEtXkv1uV+smLR4np9L73x7PzM+N6t2e8rn0i/s46p8gVk226dc8Dln8zip+fl8e/eun5hDa8D6ktNX7d2u+1U58fsmuwnbzzzUmb/emL2PO2ovHT3I3n5bzOq9B8y+mPZvl+PTL7gB1XOX7VR0+NifZ97NldNr3+3puu4JA3yXqrp+aSm1wH1qab7ZV1/Hktqvo/V5+u74C+P1egYs2LR4pqdG7L+/Pvi7VMycNSJeebn96Ri7brNagMA6kejDbq6deuWyZMnZ/To0Zk0aVLmzp2b/v3758Ybb8zZZ5+dXr16JclmBV3v+PcpDhurQV84KTvu2yelD87M8pfL0qxNq3R7/z7pOnxgXnvsucz62Z8ausRC2OvMo7N45twseXrepjv/07rVG96ZWxt7fGh4WnZslzm3TqqyfMoXr88H7/tuhl87Knce8+XKKRV2O+bA7PGh4Zn5oztT+tDMJMmiv2/ky6okB4/7XFp0aJt/XPXryg9WS2bN2yA8q6znI4dmh717ZuGkxzPj6t8kSVaVvZkXfju52v7b9dk1B115dlaULs79n1l/h/zbr7+Vh8bcmCP+3yXZ72un55FLf1LZf/+vnpYOPbvmvjPHVt71914tnVua6d++OQd+89PZe9SJlaPgen30sOx29NA8dcMf8urU9R/61769JpMvGJ9j7/hWDh53bpXRBQM+e1x2Htovj3ztZ3lrTs1H9r1z9+I7d07X1KuPPpNZP7k7A845Pj0/NLzyruZBF34knQf3ysNf+UmWznulsv/G/iZNW7fIsXd8O+vK1+b+c66p/MKorveT0odmZtZP707/s4/L3Lsezrw7H0ryTlA3KmvfXp0pX7yhZi/KRjxx7W/T/QP7Z/+vnZ6X/zYjy+a/mmT9B939v3Z6ymY8nyf+uR/UpG9Nnbnotso7p2tq3ZryTL5wfI6768oc8r3zKkecdei1S/b98sfz2mPP5akb/jWq7bXHnstrjz1X7bYGXXRS2u7aObNvmZjZN9+XJFn20qtZ9tKr1fbvMmxAuhw8IEtmzau8i7Z85dsb3adadd4u+116WtYsW5m/fbrqF1xTLv5hTpz4vRx67ajKUQstO3XIsLGfzdJ5r2TqFb+s8WvzbqZe/ovsetjgDLvqnLzy6DNZ/cayNG3ZPIdeNyprlq/KlC/+a4TDnFsnpccxB2bAuSfkpXserRzl3Lx9mxwybv379NGv/79a1XHSozek9MGZeeAL19dovZoeg166Z2r1GyopyVE3fzVNmjfLlIt/mDeeeSlJ3e8nSbL6jWV5aMyNef8vvpwDLv9kZVuXYQPS79MjM/eOh/LiH6bU6HXZmJqeT+rq3PPOnffv3CVfUy/+/oH0OPag9PvMMZl39yOVoz2GfuNTaddtx/z1tG9XjoStzXuxrveTunwvVeep8bdnt6MPyL6XfiIL7puepXNLkySHfO/8NG3VIg9cOL7KCKmaXAfU1Hs5t9fkdauPY3ZN95NHv/b/0nX4wBw87tz8YcRFWf3WiiRJ5yG9s/e5H8y8Pz2ywfVrbdTm2qwuzz21PbfX9Hi1tV3HJXX7XqpObc4nNbkOqKnantvfUZP9sq4/jyU138eSun19/1NNjzE1PTckyZzbJqXPx4/IbkcfkHl3PbLZbQBA3Wv4h0bVoX79+uXOO+/M0qVLs3Tp0jzyyCP57Gc/m+XLl2fu3Llp0qRJ9t57701u549//GOWL1+eoUOH1kPVDav0wZlZs2xlen30sAy94swMGf2xtOzYLo9deXPu+chlG0yPszVq0qJZBl7w4Xzw/mty+os35xPP/CLv/8WXs8PePSv7tOm6Q06Z+f/ywb99L01btaiy/qHXX5hPvvybdD10YOWyMxfdluHfPz9dDx2YY+/8dk574aac/PiPM/Qbn0qz/xju33rHjtn5wH5ZMHF6jeo+6dEbcvRv/zV9xJmLbku77july8EDcuai2yr/teu247tuZ/fjh2XFK0uy+Kmqo0mWLyjLo5f9Ip0G9syQL340SdJyh/YZ9p2z8+bzL2f6lTdvssY9z/hA+p56ZF66d2oev2bTU1fssHfPHHz157Js/quZdO41mxzR1Lx9mxzxszFp2qJ5/vaZcVXu3n/pnql5/tZJ2euTH0jX4ev/Nl2GDchenzo6z//m/sy/dyNfttTSrJ/endIHZ2bIFz+ajnt2T5uuO+TAb3w6bzw3P/+46tdV+r7++Jw88YPfp/tR+6XPx49Isj5c2OeSU7JoylOZ9ZOGm75i+nduyZvPv5wDv3lWWu/YMTsM7JlBF344Cyc/mWd+vnkjoYZ/7/zsMGD3PPbNX6V0ylOb7L8l95PHvn1z3nz+5Qz7zmfSqvN2SdYHdZ0G7pFHv/7zLH+5bLN+h02pWLsuky/4QZo0a5rh3z+/cvkh3zs/TZo1zeQLflB5Z2ZN+ta3xU++mCd+8PvseviQ9D3tyJQ0WT96L8lmjyrc9Yh9MuTij6ZsxvN5+Cs/3mT/trt2zmE/+mLWLF+ViZ++usod59UpadY0I37ypbTdpVMe+ML1eeO5BVXaVyx8PY9e/ots369H5RQ8w75zdlp16pApF92Q8hWrqttsrZX/80uW1jtul4O+dVaSZJ8vfzwd+3bPo1//f1lRWnVkwYNf+t+sfnNZhl87qvL8MfR/zkybrjvkgS9cnzXLVm7R+jbHljgG7Xfpqdn18CGZ9dO7N+uL5i29n8z/87Q8f+uk7HnaUdnl8MFp1rZVDvn+eVn1+lt56MtbdsRUTc4n9X3uqYmHL/lRVr+xLMOvOT9NW7dIt6P2S59Tjlg/oue+TV+DbOq9WJ0tuZ/U53upYt26PHDh+DRp0mT9cbukJHt9emR2OXRgnvj+bze4Zkpqdh1Qn97r67alj9nV2dh+smbZyky56Ia06bJ9Dvzn8bZpy+YZfu35efuNZdVON1ZbNT0u1ve5Z3NtiWNQQ17HJfX/Xqrp+aSm1wH1aUvsl1vy89jGvNs+Vp+vb02PMbU5N7zy8KysWb4yux93cI3aAIC612hHdL2bmTNnpqKiIn379k2bNm2qtJ122mnZY489su+++6Zdu3Z56KGHctVVV2XIkCE55ZRTGqji+jP/3qkN+qXNe1XSrGmOuvm/s9P+e2bObZPyzM/+lBYd2qTPqUfmmD9+M3/60Nfz+uNzsmLR4ky56Pq8/xdfztD/OTMPjVn/oaf3KUek14cPzRM/+F0WTa46r/sOA/dIj+MOynM33Zfnb52Urofsnf6fOTYd99wtfz75fyqnf9t5WP8kSdk/nn9Pv8vfR12boVecmVWLl+aJa39bufw/n7VU5fdv0iQ7HbBXFj1Q/YfY5389MT1GDs3AUSfmpXunZu/zPpiW27fPfWd8Z5Mh5k4H7Jmh3/hU3nz+5Uz+/IZzrP+nlju0zxE/G50kmfjpq6udEvM/vW/8Bdmu96556JIfVXtn+KP//dN0PXhADrnmvNx13KU55Jrz1k/l898/2+S2a+OBL1yfD078bg79weezavHSNGvbKpMvGJ+1b6/ZoO/j19yW7kftlwMu/2QWTXkqw79/ftaVr82UWt7BuaWsXbU6D1w4PiP/8M0c/L1z027Xzln79ppM+eLm1TXg3BPS88RD8uLtUzLzxjs22X9L7ydrV63O5AvG55g/fjMHX31OZoz7TQZd+OG8dO/UPD/hb5v1O2yuN59bkOljf50DLjsj/T97XNatLs8uhw7M1Mt/scFzJWrSt749fs1t2e0D+2f/r5+RHQbsnh337ZNHL//5Zo0qbN+zS953/YV5e8myTDzr6mr39X/XtGXzjPjp6LTcvl3uO+M7lXfCvpuh//Op7Hxgvzz5g99XPmfhPz3/64npceyB2fu8D6ZJ82bZ/bhhefond1eOOt3SFj3wZJ75xZ/T71NHZ0Xp4vQ/+9i8dM/Uar/IX/X6W3nokh9nxE++lP2+emoW3v94+pxyxPov8jbjC8S68l6OQT2OG5aBo07MK4/MyqP/Ng3extTVfvLof/80XQ/ZO4eMOzelj8xK+912zsSzrt5io3U3+FmbeT6p73PP5lr/pe1PMuLHF2fYdz6bXQ4bnOUvl+XRy36+Wetvznvx323p/aS+30tvzn4506/6dQ74+hk58BufSu+PH5GyJ+a86wjcmlwH1Jf38rrV1TH7321qP1n0wJN55uf3pt+nR2be3Y9kp/33TMe+3fO3z1z9rte4tVHT42J9n3s213s5BjX0ddw76vu9VNPzSU2uA+rbe9kv6+Lz2H/anH2sPl/fmh5janpuqFi3LmUz5lR+5t/cNgCg7jXqEV0b8+ST6wOM6qYtHDBgQH7/+9/njDPOyMiRI/Ozn/0sZ599du6///60aNFig/5sXfp9emS6HrJ37jvzO3nwS/+bZ3/55zw5/vbccdTorFr8Vg74+hmVfef/eVqe/snd2fP0D6THsQdlu9675MBvfTqvTns2/xi74d2FO/TvkcmjrsvUy36eZ39xb+7/7Hfz9E/uyi6HDkzPE/5111bHvt2SJEvnvrLBNmrihd9OTvmKt7PqtfXTSrzz793uvG27a+c0b9c6S+dt/IuLB7/0v1m9dEWOuunS9Dzh4Dw5/vcpm/HuoVzrnbfP4T/+UtatLs/Es67OmqUr3rV/SZMmOfzGL6Zd953y4Jgbq70b7j8NGX1yun9g/zx3830bPPfoHavfWpEpF/8w7brtmA/eNy7tuu+YB754wybrqa1l81/NtG/8XzoN3CO7HjY4T15/e15/fE61fSvK12by53+Qpi2a57i7r8xO+++ZqZf/olZTDm5pr02fnZn/e0e6H7lftu/XI1Ov+GWWL9j0SKiuhw7MfpeemsVPz9usKQLraj8p+8fsPHn97dnt6KH5wISvZc2ylVv0ru9/N/PGO/LKI7Oy75c/nv3++9SUPvx0Zv7ozvfctz5VlK/N5AvHp2nL5tnrzKPzyiOz8vSP7trkes3atMoR/++SNG/XOpPO+V5WLHx9k+sMu+qcdB7cKzO+e2tenviPTfbvffKI9PvU0Xl50uOZ/s8He2/Mg1/636xZuiJ7n3tC3nphUR779q82uf334rFv/F/emluavc/7YFa/uSIPjdn4Pjbvrocz53eT0+/TIzP8us/nzTkLM+1bdVvfptT2GNRxr90y/PvnZfmi13P/2d+tnNZ2Y+pyP1n91oo8OPp/03bXzun14UMz53eT89LddTP1T03OJ/V97qmJeXeun4ar98cOT5udt8+Ui3+4WXXV5L2Y1N1+Ut/vpZn/e0denfps+p11TJo0bZoHLhj/riNwa3IdUJ9q+7rV5TE72fz9ZNo3/y9vvbAoh3z33PQ/57jM+e3f62Sar9ocF+v73LM5ansM2lqu45L6fy/V5nxSk+uA+lab/bKuPo/9u5rsY/X5+tb0GFPTc8PSuaVps/P2abl9uxq1AQB1S9D1H77yla/kySefzFtvvZU1a9bkxRdfzPe+971st9129V0mtbDHRw7NG7MX5PUnXkjLHdpX/mvSolkWTnoiOw3dq8pUhdO+8cu8/uQLOXjc53L4j7+UijVr8/dzv1/the2bz7+8wbMInvzB75OsfyDwO1p16pAkefuNLX8H+qb862dv/G69la+tf0B9q07bZcmseZnxbw/YrU6T5s0y4idfSpudt88DXxifNzdjypr9v356ug4fmKd/cndeuO3vm+zf/b8OyOAvfCSv/WP2JqfAWjjp8Tz7f39Oq07b5bmb/vquzxfYEv79zr8Ff3nsXfu+88D7Vp22y8v3z6h8FsnmKGnWtMo+23KH9pUPeG/Rsd0GbbX9PdatKc/Lf9v0l1vtuu2Yw/73osrncWxqaqO63k8e/+6tWTJrXlp12i6PfPWnmzWNSq1UVGTyBevvYC5p0iQPXDi+crTme+pbjRbbta3279q0dYsNljdpUbMB2GveWlH53L8F903frLqGX3t+tt+ze6Z98/9S+uCm7xLud9Yx6f2xw/PSPVPzxGZMbdRpcK8M+87ZWfrSK/n7Zkyds3bl2yn/53NgFk15cos9qH6jP29NedYsXT/l1+tPzNnkPvbIpT/JqrI302qH9nngwvE1qq95+zYb/u2blKRJi+YbLG/aevNvsqnpMajFdm1zxM9Gp0mzZrn/7O9u3vREdbyfvL1kWdatXf/l+IK/TNtE7/emJueT93LuadKi2Ub/rv+5vMV2bWv8e7xzfF/1+pt5ddqmn3VT0/diXe8n7+W9VGMVFZXXSG/NLd2sEbg1uQ74T3V5bq/p61bXx+ya7CdrV67O5At+kJbbt8/br7+VR776003WU1s1PS6+13NPXZ3ba3oM2tqu45L39l6qjZqeT2p6HfCf6urcntRuv6zLz2NJzfex9/r61kSNjzE1PDe8MzLunWnVN7cNAKhb2+TUhe8WdFFsHft0S7PWLfPxmRt/gHnLHdpX3lm8bnV5Jp37/Zx4/zXZfq/dMum872/0Ls83Zm/4gW/lq2/k7TeWpX2PnSuXVX6fXFJSpW+T5s3SsmPVO7vWLF+1Ref8r3jnh//Hz/5Pr01bPw3F60+8sMm7sg/89lnZaf8988QPfrdZd9v2/NDwDDjn+JQ+/HSmXrHpqY22671LDr1uVFYtXpq/fWZc5Zfzm6p/z9M/UPl71JVWnTpk2Nizs3TeK2m5fbsMu+qc3Hn0JRs8lPg/a/v3/91cOx+wV47+3RXVtp3wl6s3WPbzridt9ra367Nr9hlzcpbMmpfteu+aQ8Z9Ln/5xLc22r9p6xYZ8bMxabFd2/VTG83b9OjEut5P1q0pz+tPvJDt+/Wo87/7spdezaqyNyv//5bq+59O+MvVadd9pw2WDzz/xAw8/8Qqyx64cHye/839m73tQ75/fpo0b5Y3npufQV/4SOb+8cF3/TsOvODD2f24YXnh9w/k6Rs3PSpt54P65YDLzvjn1EbXbbJ/q04dcsRPR6eioiJ/O2vcZk2dM/Qbn07bXTpl8VMvps8n3p85t07aog+s/0+Dv/CRdBrYM68/+WJ2PXxI5TQ8G7P6zeV58/mFab3T9ps1tc+/e//PL0mXgwdssLzdh3bMHh8aXmXZjHG/yYzv/mazt73Zx6CSkrzvhi+kQ8+ueXDMjZv1O9T1fvLOw+lXv7ki5StX5YDLz8zLf5uR1W8u3+S6tVWT80ltzz17nDg8w68dVW3bf16vLJv/am4bet5mb7vLIXtnrzP/K68/+WI6DeyZAy47o3I65urU+L1YD/vJe3kv1VTvk0ek+1H7Vb5ee5//wcqblqpTm+uAf1eX5/aavG51fsyuxX7yTp83n19Yp+/xpGbXZu/13FOX5/bNPQZtjddx7/W9VFO1OZ/U9DrgP9Xlub2m+2Vdfx6rzT72Xl/fmqrJMaam54a881G7uhvJ3q0NAKhT22TQNXHixIYugTq0+Ol5mXr5zzfa/vZ/zM3d7ch906RZ0yRJp7175sXfP/Cefv4722/ZsV2VqXp22n/PDb7sqOmHnJr87C2h72lHZs/TjsrL98/I9Cs3PWXN9v175OBxn8vyhZs3tVHzdq0z4mdj0qx1y0w886rNmgKrPg276py06NguEz999fqA6LvnZvBFJ9XJg7MXPz03936s6v6xy2GDM/D8E/P386+t9V2PJU2aZPi1o1JRUZGJn746vU8+PIO/cFL6fPyIzL6l+mPhwePOTaeBPTN97C2bNbVRXe8njdXfz7+2ygjTJPmv31yW52+dlDm33l9l+RvPzt/s7fY765h0PWTvPHblzZl/z6M5/s9X55Brzss9H76s2v67jhiSfcacnMUz52bKxZue2qhN1x1y+I8uTvmq1Zn46auyZtnKd+1f0rRJDv/xxWm7a+f8fdS1mzV1TvcP7J/eHzs8z/7qL/nH2F/nxEnX5JDvnZc/HjV6k88TrI0dBvbMoAs+nJfvn5GJn74qJ/xlXA781llZ9MBTlUHmljT1il9sMHLnfeMvyOKn5+WpG/5QZfnmfHlUG/t++ePpdsQ+ee6mv+a5//vLJvvX9X6SJPt+5RPZrveumXTe97Pq9bfyXxO+ngO/+enNek7M1uzl+2dscHzv9dHD0/ujh22wvCb7d7O2rTL8mvOy8rU3c+/HrsiB3/x09jz9A5l7x0MbPGc0qd17sa73k/rUZpdOGXrFmVkya17uPv7SHPXrr2XIFz+al+6dutHRK+/1OqCuzu01UR/H7JruJ1urLXHuqatze01sjddx9XlNndT8fLIlrgPq6txe0/2yPj6P1XQfq+/rrJqozbnhnc/a1T3z693aAIC6tU0GXTReb71YmladOmTRA09t1l1UnQbtkf2+cmpenvR43n79rQz43PFZ+PcnsnDS4xv07din2wbLWu/UMS07tsvCf/uwsuSZl5IkHXp2zZKn51Uur+7Ljk19yKmo4Z1gyxe+ntVvLU+Hnl1rtF51dty3Tw785llZOu+VTDr3+5t8PVt0bJcjfjYmTZo2zf1nj9usDy2H/uDz6dinWx697OcN/qDv/7THhw9Nj2MOzMwb78irjz6TVx99Jrsfv/4B6/P+9EgWP7npL35qYvWbyzf4YrJt105JklcffabWz/oa+PkTs+M+ffLIf/8sS+eW5vHv3Zbd/uuAHHD5J/PypMc3+DDb/5zj0uvDh+alex7NE9//7Sa3Xx/7SWO1sTtxl817pdovqTdH+55dsu+ln8hr/5idp8bfnop16zLju7/Jfpeemn5nHZNZP727av8eO+d911+YNW+tyN/OunqTU+E0adEsI346Oq137JiJZ129WdN+HXD5mekybECe/sldeeG3kzfZv+X27XLw1edk2fxXM/XyX6R8+ao88tWf5rAfXpR9v/zxTL1803cm10STFs1y6HWfT/mKtzPl4h9m7crVmfLFG3L0767IsLGfzd/O2nDUxXv1+hMvbLBs7dtrsvKVJbX+29fEbsccmIGjTlw/PdGlP9lk//rYT3Y6sF/6feaYzL3r4cobTp79vz9XBjfz/1y30xjWpZWvvpGVr75RZdnOQ/slyXv6ew+94sy0675T7vvkd7L6jWV55L9/lq7DB+aQ756b20d8MeXLq44Yr+l7sa73k/p2yPfOS7M2LTP5wvFZ+/aaTLnohpxw37gM//75ufu4r24wNd+WuA6oq3P75qqPY3ZN95Ot1ZY699TFub0mtsbruPq+pq7p+WRLXQfUxbm9pvtlfXweq+k+1hDXWTVR03NDsv5z/opXllQ72vXd2gCAurVNPqOLxmvOrZPSZuftM+Cc46tt//e5spu1aZXDfnhRVr+5LJNHXZeHLvlRlr70ag69blTls67+3Xa9d81uRx9QZdnAUScmSV6659HKZaUPP50k2XG/vlX6vvNlx7//29RUZ+XLV6VFDUZnVaxbl1ceeSY77tt7s9epTusdO+bwn3wpFevW5W9nXZ3V7/LMr2T9qKHD/veitO+xcx752s/y2vTZm/wZgy86KbsdPTQv/G5ynv7Rpqc2qk+td+qYA7/56bz5/MtVHr4+5eIfpnzl2xn+/VFp0nzrv09g+349Mviij6b0wZmVAce6NeV54AvXp1nrljlk3Oeq9O9y8IDs/9+n/3Nqo02PoKiP/YQaKClZv2/+83lh73wwf+r6P6RsxvPZ99JPVJlmtVnrlhnxszFp3qFN/j7qus26u/igK8/Ojvv0yRM/+N0mH+qeJHuc9L70/8wx66fO2cwvCQ/69tlp1Xm7TPniDyu/qH/x9imZ96dH0u8zx2SnA/bcrO1srn2+dHK232u3PHr5LyqD31cffSazfvqn9DjmwPQ88ZAt+vMa2nZ9u+XQa/85PdFZV29yeqL62E+atW6Z4decl9VvLMvDl/xr2r2pV/wyyxa8tn4kQC2eXdWY7TpiSPqeemSev3VS5Ze2q99Ylocu+VHadd8pB1x2RpX+NX0v1sd+Up/2POMD2fWwwXniB7+v/FJ96dzSTL/y5uy4T5/sff4Hq/RvLNcBdX3Mrul+sjWr73NPXdgar+Pq+71Um/PJ1nwdUJP9sj4+j9V0H0u27te3pueGZP3r3GnwHnnloadr1AYA1L2t/xMa1MDTP7kruxw2KAdcdka6Dt87ix54KmuWrUjbXTun6/CBWfv2mtx70uVJkmFjz0773XfOXz7xrcq73f5+7vcz8g/fyPDrPp+/nlr1GUaLn56XQ8dfkOduui9vvbAoXQ/ZO7sfPyylD87Mi394sLLf26+/lUVTnkq39++Taf/zy/f0+7w2fXb6fPyI7DPmlPXPCFtXkfl/nvauD/ude8eD6X7Ufuk8pHfKZjxfq597+E8uTtuunTLv7kfSca/u6bhX92r7rXztzSz6+xMZMvpj2fWwwXlj9oKUr1iVPT5y6Ea3/cJvJ2eXwwZnyJc+lvKVb6f0oZnv2n/hpCfqfdTPwePOTfMObfLX06+sMiXIioWvZ+oVv6zz6Va2hJJmTTP82lFZV74+2Pp3rz/xQp68/vYqUxi23qljDv/RF9OkWdPMvevhdP+v/Te67SVPv5Qls+bV+X5CzQz43PHZeehemfaN/6ty137FunV54MLxG0xhOOzqc7JD/x555ZFZabl9u43+PcqXr8pL90xNn0+8P30/8f6sfO2NvDn75Xf9+71096Np12PnHHzVOVm3dm3m3zP1Xb/IeHXqs1n20qvpcdyw9DzxkDzz83uy6IGqdz8/NOZH2fnAflt0CsMd9+2TAeeekPl/fSzP/7rqVJ7Tr7w53d6/71Yztc6W0LR1ixzxszFp3q51Xrj9gWqfJfKOpXNfyWuPPVfn+0n5yrez39dOT4eeXXP/Z79bZaqf8uWrMuXiHzaaKQy3lBYd2uTgcedm+aLX8+h//7RK2/x7p2bOb/9eZQrDjnvtVqP34srX3qjz/aQ+teu+U/b/2ulZ/NSLefya26q0zfrJ3elx7EEbTFPVGK4D6vqYXZv9ZGtV3+eeurC1XsfV93uppueTrfk6oKb7ZV1/HitpUlLjfWxrfn1rc25Ikp2H9U/ztq0z984H/3OT79oGANQ9QReNSkX52vz1tG9nrzOPTq+T3pchoz+WJFlZuiSvzXg+c/75wOdeHz0svU46LE+Ov/3/t3f/UVrXdf7/Hxcz4MAAGmAOKggKKCI/VhPTzFUDVxRWM7MS3erjbpmyuC0rbrVlmxrh0rFYa5ePW59KwQ+laQpmmZSR9iWIUEISJEGQQZtAhRGEgfn84XfZRn4kyMw17/F2O6fj8f16X9c8L88Yg3der3eTYwrrFj2dhV+6Myd/7m8y6ONjsmTa/TvX1i/+feZ//ls58Z8vzbGXj8y2TZuz9BsP5NeTZuxyzMdT3/5RzvzfE9J9yNG7PcbijVo4aUY6HNI5x33kr9Lh4OqU2rXLXSd/Yq9H3ay877Gc/PmP5JiLz9jv0PXfRyoddd4pOeq8U/Z437rHlqT250/svP+Q/kfmjFuv2et7//7uuXn7O45NqV27VHY8KKf925V7vf/Bi67Puhb8jU+/D56dXiNPyuKv3bvb/yizfMbDzXrcyoEy9JMXp/vgvvnlP9+WTat33Tn4+iMMux5Vk6rur+14HHrN+/b63oumfDcblq5q9u8T3riD+x+REyd+MC8seCpL/vP+XdZfXLZmlyMMDxt+XJLksFMG5rBTBu7xvTetfiHPPjh/5/0dDz0k757693ud566TP5EeQ45OZceDkiQnf/7De73/F9fcmjX1W3Lql/42G1c9nwU33LHLPVvqXjqgRxhWVHXI6V8dl22bNuexf/rPXda3b2ldR+scCB27H5yDjzk8SXLsZSNz7GUj93jv0zN/mj/8elmzf5906VOT4z58Tp6577GsvP+Xu9xT+/Mn2swRhgfK8BuvSPXh3fPQ2Juy9eVXdll//RGG+/rv4rrHljT790lLOv0rV6ddh8rMvebW3T6r5vXHVB1zyZlt4ueA5v7/7P35PmmNqrp3bdFfe5rLwccc0ep+jmvpn6l7nj54n349WfvzJ1rtzwH7833Z3L8fe22uN/499vIzta32n2+y7782/PdJCcdcfEZeeX7Dbn8t29saAND8So37+hAg3rD6+vp07vzasXObNm1KdXX5j93Z9sqWTD/msnKPUTgfqb0rT8/86S47Y/ak1K5d/vrhKVm/ZGXmjpvazNPtavC4CzP479+bu065+s8eQwIAAADsWcdDD8n75n0tv75p+i7Pvd3bWms1dsUdad+pqtxjAMAB4xld0Awad+zIgi98J30vfFcO7n9Ei3/9J2+bna0v1eeET/x1i39tAAAAaEsG//2FqV/7x/zu2z/apzUAoGXY0dWM7OhqO/Z1RxcAAABAa2RHFwBtjR1dAAAAAAAAFFJluQeAIvhWz4vLPQIAAAAAAPA6dnQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACF1OZDV11dXSZOnJh+/fqlqqoqvXr1yjXXXJP6+vpcccUVKZVKufXWW8s9JgAAAAAAAPuostwDNKdFixZl1KhRWbduXaqrq3P88cdn7dq1mTp1alasWJH169cnSYYNG1beQVuhDod0zpDxF6X3uSenumf3bKvfnA2/W53f/NvMvDBvabnHAwAAAAAAaLuhq66uLmPGjMm6desyYcKEXH/99enSpUuS5Oabb851112XysrKlEqlDBkypMzTti7VR/bIuXf/a9pXV2X5jDl56fe16dC1U942sHeqa7qVezwAAAAAAIAkbTh0jR8/PmvWrMm4ceMyZcqUJmsTJ07MjBkz8vjjj6dv377p2rVrmaZsnc649Zq0q6jID86ekM0vvFjucQAAAAAAAHarTT6ja+nSpZk5c2Z69OiRSZMm7faek046KUkydOjQXdbuueeenHbaaamurs7BBx+cd73rXVmyZEmzztxaHPbOgTnslIFZ/PUfZPMLL6ZUWZGKjh3KPRYAAAAAAMAu2uSOrjvvvDM7duzI2LFj07lz593e07FjxyS7hq6pU6dmwoQJ+eQnP5kbbrghr776aubNm5fNmzc3+9ytwZFnn5gkqX+uLu/59j/niLP/Iu0qK/LSirV5/Jbv5fd3zy3zhAAAAAAAAK9pk6Frzpw5SZKzzjprj/esWbMmSdPQtWLFilx77bW55ZZbMm7cuJ3XzzvvvGaatPXp2u/wJMlpU67My7+vzS+uuTXt2ldm0JVjXjvSsLIyT8/8aZmnBAAAAAAAaKOha9WqVUmSo446arfrDQ0NefTRR5M0DV3f/OY30759+/zd3/3dAZ+pf//+adeu/CdFtm9sl+szfM/r1a/tdNu2aXN+dPHns2NbQ5Lk2Qd/lff9f1/LiZ+6NE9/92dJY2NLjAsAAADAATSg/4BsK+0o9xgA0ERNTU0WLFiwX69tk6Grvr4+SfZ43ODMmTNTV1eXLl26pG/fvjuvP/bYYzn22GNzxx135MYbb8zq1avTv3//fO5zn8uHPvShNzVTbW3tm3r9gdKhVJEctuf17Vu2JkmeufcXOyNXkmx9qT6rf7wg/S45Mwf3OzwvLX+uuUcFAAAA4ABbW7s2Wxu3l3sMADhg2mToqqmpyYYNG7Jw4cKceuqpTdZqa2tz7bXXJkmGDBmSUqnUZO25557Lpz71qUyePDm9evXKN77xjVx66aU59NBDM2LEiP2eqWfPnq1mR1f28od26mv/mCTZ/MKLu6xtfn5DkqTDwbt/7hkAAAAArdvhPQ+3owuAVqempma/X9smQ9eIESOydOnSTJ48OSNHjsyAAQOSJPPnz8/ll1+eurq6JMmwYcOavG7Hjh3ZtGlTbr/99lx44YVJkve85z158sknc8MNN7yp0LV8+fJUV1fv9+sPlG2vbMn0Yy7b43rdb55OPvxXqe7ZfZe1Toe/dm1L3UvNNh8AAAAAzWfZ8mVp36mq3GMAwAFT/i1GzWDixInp3r17Vq9enUGDBmXw4MHp379/hg8fnqOPPjpnn312kqbP50qSbt26JUmToFUqlTJixIj89re/bbkPUEbPPvirbN34So5+3xmp/JMfejq+/ZD0PvfkvPT0c9m4cl0ZJwQAAAAAAHhNmwxdRx55ZObOnZvzzz8/VVVVWblyZbp165Zp06Zl9uzZWbZsWZJdQ9egQYP2+J5btmxp1plbi60v1WfBF76T6sO75/zZX8zxHx+dweMuzPmzJ6Vd+8rM+5dvlntEAAAAAACAJEmpsbGxsdxDtKRNmzala9euKZVK2bhxYzp16rRz7b777ssFF1yQu+++OxdddFGS144zHDZsWLp165af/exn+/S16uvr07lz551ftwhHF/633uedksFXXZBDBvZOdjTmhV8vy+Nf/m5emP9UC0wJAAAAQHMYu+IORxcC0Ka0yWd07c2SJUvS2NiYAQMGNIlcSTJmzJi8+93vzsc+9rH88Y9/TO/evfNf//VfWbJkSR566KEyTVwezz4wL88+MK/cYwAAAAAAAOzRWy50LV68OMmuxxYmrz2P67777st1112XT3/603n55ZczdOjQPPDAAzuf6wUAAAAAAEDrIHS9ziGHHJJp06Zl2rRpLTkWAAAAAAAA+6hduQdoaX8udAEAAAAAAFAMb7kdXXPmzCn3CAAAAAAAABwAb7kdXQAAAAAAALQNQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhSR0AQAAAAAAUEhCFwAAAAAAAIUkdAEAAAAAAFBIQhcAAAAAAACFJHQBAAAAAABQSEIXAAAAAAAAhVRZ7gFaQl1dXW6++eZ8//vfz5o1a3LooYfmoosuyhe/+MWMHz8+3/zmN/Pv//7vGTduXLlHLbthEy7JsH+6ZI/rO7Y15Du9P9iCEwEAAAAAAOxemw9dixYtyqhRo7Ju3bpUV1fn+OOPz9q1azN16tSsWLEi69evT5IMGzasvIO2EqsemJeXV9bucv1tA4/K4KsvzOqHfl2GqQAAAAAAAHbVpkNXXV1dxowZk3Xr1mXChAm5/vrr06VLlyTJzTffnOuuuy6VlZUplUoZMmRImadtHTYsXZUNS1ftcv3UmwcmSZbPeLilRwIAAAAAANitNv2MrvHjx2fNmjUZN25cpkyZsjNyJcnEiRMzdOjQNDQ0pE+fPunatWsZJ23dKjselL4XvCv1z9XluZ8uKvc4AAAAAAAASdpw6Fq6dGlmzpyZHj16ZNKkSbu956STTkqSDB06dOe1M888M6VSabf/u/LKK1tk9tamz5hT06FrdZ7+7s/SuGNHuccBAAAAAABI0oaPLrzzzjuzY8eOjB07Np07d97tPR07dkzSNHR9/etfz8svv9zkvtmzZ+fGG2/M6NGjm2/gVqz/pe9J444dWX7nnHKPAgAAAAAAsFObDV1z5rwWZc4666w93rNmzZokTUPX8ccfv8t9N910Uw499NCce+65B3jK1q/rMYfnsFMGZu3Pn8im1S+UexwAAAAAAICd2mzoWrVqVZLkqKOO2u16Q0NDHn300SRNQ9fr/eEPf8iDDz6Yq666KpWV+/+Pq3///mnXrvwnRbZvbJfrM/wN39//Q2cnSZbPeLi5RgIAAACghQzoPyDbSh5NAUDrUlNTkwULFuzXa9ts6Kqvr0+SbN68ebfrM2fOTF1dXbp06ZK+ffvu8X3uvPPONDQ05PLLL39T89TW1r6p1x8oHUoVyWFv7N5SRbv0e/9fZsv6l7Pqh/OadzAAAAAAmt3a2rXZ2ri93GMAwAHTZkNXTU1NNmzYkIULF+bUU09tslZbW5trr702STJkyJCUSqU9vs/tt9+egQMH5h3veMebmqdnz56tZkdX3uAf2ul1zjvS8e1vy5O3zcqOrQ3NOxgAwD4aNuGSLL71nmx/dVtO/8rVWb9kZZ68bfY+vUfvc0/O5hdezB8WLv+z9/a75MwMv+GjefmZdZl17nVJksHjL0q/9/9luh7dMz+94t/y7IPzd97/7q9dk8NPPyHP/ODR/Opz39qnuQAAmsvhPQ+3owuAVqempma/X9tmQ9eIESOydOnSTJ48OSNHjsyAAQOSJPPnz8/ll1+eurq6JMmwYcP2+B6/+93vsmDBgnzxi1980/MsX7481dXVb/p93qxtr2zJ9GMue0P39v/Qe5Iky2bMac6RAAD2y7B/uiRP3jYr21/dtt/v0fvc4Vm/ZOUbCl1Jsu6xJZnz0Zt3/n3tz5/IM/f+IqffcvUu9869+qsZNuGSdDi4037PBwBwoC1bviztO1WVewwAOGDabOiaOHFiZsyYkdWrV2fQoEE57rjjsmXLljz99NMZNWpU+vTpkx/96Ed7fT7X7bffnlKplLFjx7bg5K1Dx8PeliPOGpY/LFyeF3/3bLnHAQBo4tTJH0uSjLr3hjRu35FXnt+Qg/sfkXO+e32qD++eF59anUeuvCU7tjWkVFmREyd+MDWnn5CK9pV56fe1+eXEaTn0pAHpdc470vOMIel3yZlZ+n8ezJqHfp0z/uMf0r5Lx1Qc1CHrHv1t5v3LN5PGxt3OUbfo6Zb82AAAAMDrlP8svWZy5JFHZu7cuTn//PNTVVWVlStXplu3bpk2bVpmz56dZcuWJckeQ1djY2OmT5+eM888M717927J0VuFfh84K+0qK7JsxsPlHgUAYBe/vO5/J0l+eOFnc9/Ia7Ol7qV0G9Q3D394Uu494x9S1ePgHHX+KUmSE666INs2v5rZ530q9428Nht+92z+4roP5bk5v8nqHy/Ikv+4L/eNvDbLZzycrS/X5+G/+VJm/dV1ue/sCenc6+3p+9enlfOjAgAAAHvRZnd0JcnAgQMza9asXa5v2rQpK1euTLt27XLCCSfs9rU///nPs2rVqlx//fXNPWartHjq97N46vfLPQYAwBv27A/nZfvmrUle22nVpc9r53v3PvfkdOjSKX3Oey18tetQmU2r/7D7N2lXykn/clkOG35cUiqlY4+uefF3z+aZHzzaIp8BAAAA2DdtOnTtyZIlS9LY2JgBAwakU6fdPzPh9ttvT8eOHXPxxRe38HQAAOyPP31WV+P2HWlXUZEkKZVKmfcv38zaRx7/s+8x6ONj0rHHwZl9/qey/dVtOfnzH05FVftmmxkAAAB4c9rs0YV7s3jx4iR7PrZwy5Ytueuuu3LhhRemS5cuLTkaAABv0NaNr6R9193/oaU/9eyDv8rxHxudio4dkiQVHTvkkAFH/v/vsTntu/zPe3Q4uDqbX9iQ7a9uS8dDD0mf0ac2z/AAAADAAfGW3NH150JXVVVVXnzxxRacCACAfbXkP+/POf/3c9m++dW88vyGPd63+NZ7M/Qf22f07ElpbHzt2m+/dm9eXLYmK+56JKd/dVx6nzs8v/vWg1n6Xw/kzNsm5IKf3ZLN69Zn7dwn9jrDkH94X469/JxUde+a0477RE656W9z3znX5tU/vnwgPyoAAACwB6XGxv/+7f5bx9lnn52f/vSnmTVrVs4///xm+zr19fXp3LlzkteeC1ZdXd1sX+uN2vbKlkw/5rJyjwEAUDj9LjkzvUcNz5yP3vyGXzNswiXpcHCn/Opz32q+wQAA9sHYFXekfaeqco8BAAfMW/Lowjlz5qSxsbFZIxcAAG1Lw5at6TaoT0Y/OPkN3f/ur12To9/37mzduLmZJwMAAIC3rrfk0YUAALCvVt73WFbe99gbvn/u1V9txmkAAACA5C26owsAAAAAAIDiE7oAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAoJKELAAAAAACAQhK6AAAAAAAAKCShCwAAAAAAgEISugAAAAAAACgkoQsAAAAAAIBCEroAAAAAAAAopDYfuurq6jJx4sT069cvVVVV6dWrV6655prU19fniiuuSKlUyq233lruMQEAAAAAANhHleUeoDktWrQoo0aNyrp161JdXZ3jjz8+a9euzdSpU7NixYqsX78+STJs2LDyDtrKVHaqysC/PS9HX/iudO719mzfui0vr6jNsjseytPf/Vm5xwMAAAAAAEjShnd01dXVZcyYMVm3bl0mTJiQ2traLFy4MOvWrcvkyZMze/bszJ8/P6VSKUOGDCn3uK1HqZSRMz6Tv5j4gdQtWpH5//rtPPGVu1OqaJfTvzouJ33msnJPCAAAAAAAkKQNh67x48dnzZo1GTduXKZMmZIuXbrsXJs4cWKGDh2ahoaG9OnTJ127di3jpK3LoSf2z2GnDMzSb/wwj/7j17Psjp/kydtm54cXfjYbVz2fYy8fWe4RAQAAAAAAkrTR0LV06dLMnDkzPXr0yKRJk3Z7z0knnZQkGTp0aJPrc+fOzXve85706NEjhxxySN75znfm+9//frPP3Fq079IxSfLKuvVNru/Y1pAt61/Otle2lGMsAAAAAACAXbTJ0HXnnXdmx44dGTt2bDp37rzbezp2fC3o/GnoevzxxzNy5MhUVFTkW9/6VmbOnJlevXrl4osvzqxZs1pk9nKr+83TefXFTRl89QU5avSpqT6iRw7ud3hO/PSl6T7k6Cz68vfKPSIAAAAAAECSpLLcAzSHOXPmJEnOOuusPd6zZs2aJE1D18yZM1MqlXLvvfemU6dOSZIRI0bk6KOPzvTp0zN69OhmnLp12PpSfR7+yOS8a8qVOeu2Cf9zfeMr+dnfTsmzD84v43QAAAAAAAD/o02GrlWrViVJjjrqqN2uNzQ05NFHH03SNHRt3bo1HTp02LnbK0kqKirSpUuX7Nix403N1L9//7RrV/4NdO0b2+X6DN/rPQ31W7LhqdVZ/eMFeWHBUznokM457qPn5oyv/0Me/sjk1P78iRaaFgAAAIADaUD/AdlWenP/nQsADrSamposWLBgv17bJkNXfX19kmTz5s27XZ85c2bq6urSpUuX9O3bd+f1yy+/PF/72tcyYcKEXHfddamsrMy0adOyfPnyfP3rX39TM9XW1r6p1x8oHUoVyWF7Xj/kuN45774bM//z385T3/nxzuu/v/cXufCnt+RdU67M3e8cl8Y3Gf4AAAAAaHlra9dma+P2co8BAAdMmwxdNTU12bBhQxYuXJhTTz21yVptbW2uvfbaJMmQIUNSKpV2rg0dOjQPP/xwLrrootxyyy1Jkurq6nzve9/LGWec8aZm6tmzZ6vZ0ZW9NKpBHxudyo4HZeX9jzW5vn3z1qz5ya8z8Irz0rnXodm46vlmnhQAAACAA+3wnofb0QVAq1NTU7Pfr22ToWvEiBFZunRpJk+enJEjR2bAgAFJkvnz5+fyyy9PXV1dkmTYsGFNXrd8+fJ84AMfyMknn5yrrroqFRUVmT59ej74wQ9m1qxZOfvss/d7puXLl6e6unq/X3+gbHtlS6Yfc9ke1zv17JYkKe0mypUqK5r8FQAAAIBiWbZ8Wdp3qir3GABwwJR/i1EzmDhxYrp3757Vq1dn0KBBGTx4cPr375/hw4fn6KOP3hms/vT5XEny6U9/Op06dco999yTUaNG5Zxzzsm3v/3tnHLKKZkwYUI5PkqLe3HZmiRJvw+c1eR6h66d0vuvTs6rGzZm4zPryjEaAAAAAABAE20ydB155JGZO3duzj///FRVVWXlypXp1q1bpk2bltmzZ2fZsmVJdg1dixcvztChQ1NZ2XSj2zve8Y4sXbq0xeYvpydvm5Ut6zfmpM+Mzbv//e9z7N+ck8HjL8qYh/4tnWq6ZeHk/+v5XAAAAAAAQKvQJo8uTJKBAwdm1qxZu1zftGlTVq5cmXbt2uWEE05oslZTU5NFixaloaGhSeyaP39+jjjiiGafuTWoX1OX2ef9c4b+4/vT8/TB6XvBu9KwZWvWL1mZ+f/6nTz7wLxyjwgAAAAAAJCkDYeuPVmyZEkaGxszYMCAdOrUqcna1VdfnUsuuSTvfe978/GPfzwVFRWZMWNGHnnkkXz1q18t08Qtb+Oq5/OLa24t9xgAAAAAAAB79ZYLXYsXL06y67GFSfL+978/999/fyZPnpwPf/jD2b59ewYMGJDp06fn0ksvbelRAQAAAAAA2Auh63VGjx6d0aNHt+RIAAAAAAAA7Id25R6gpf250AUAAAAAAEAxvOV2dM2ZM6fcIwAAAAAAAHAAvOV2dAEAAAAAANA2CF0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFNJbInTV1dVl4sSJ6devX6qqqtKrV69cc801qa+vzxVXXJFSqZRbb7213GO2ClU9Ds6pkz+W9y/4z1y+6s5cvOA/MvyGj6ZD107lHg0AAAAAAKCJynIP0NwWLVqUUaNGZd26damurs7xxx+ftWvXZurUqVmxYkXWr1+fJBk2bFh5B20Fqrp3zegHJqXjYW/LstsfyoanVudtx/bKsX9zTg475fg8cMFnsn3z1nKPCQAAAAAAkKSNh666urqMGTMm69aty4QJE3L99denS5cuSZKbb7451113XSorK1MqlTJkyJAyT1t+Q665KJ17vT2PfOKWPHPvozuvv7Dgqfzlf3wygz4+Jk985e4yTggAAAAAAPA/2vTRhePHj8+aNWsybty4TJkyZWfkSpKJEydm6NChaWhoSJ8+fdK1a9cyTto61Jx2Qho2v9okciXJMz94LA2bX02/D5xVpskAAAAAAAB21WZD19KlSzNz5sz06NEjkyZN2u09J510UpJk6NChTa7/5Cc/yTvf+c5UVVXl7W9/e6688sq89NJLzT5zuVUc1D7bt+zmaMLGxmzfsjVd+9TkoG5ddl0HAAAAAAAogzYbuu68887s2LEjY8eOTefOnXd7T8eOHZM0DV2PPPJIzj333BxxxBG55557ctNNN+Wuu+7KhRdemMbGxhaZvVw2PLU6B72tS7oN6tPkerdBfXLQ214LXNVH9CjDZAAAAAAAALtqs8/omjNnTpLkrLP2fNzemjVrkjQNXV/4whfSv3//fO9730u7dq91wO7du+d973tfZs+endGjR+/XPP3799/5fuXUvrFdrs/w3a49edvs9D735PzltH/Mrz73f/LiU6tzyLG9MvxfP5LtW7elokP7VHY8qIUnBgAAAOBAGdB/QLaVdpR7DABooqamJgsWLNiv17bZ0LVq1aokyVFHHbXb9YaGhjz66GvPovrT0DVv3rx89KMfbRKlzjnnnCTJvffeu9+hq7a2dr9ed6B1KFUkh+1+7YV5S/PIlV/JKTf+r4yc/pkkyY6G7Vk+4+FULVuTo847Jds2bm7BaQEAAAA4kNbWrs3Wxu3lHgMADpg2G7rq6+uTJJs37z7MzJw5M3V1denSpUv69u2783pFRUU6dOjQ5N727dunVCplyZIl+zRDp06dsmnTppx++ul54YUXUiqV9vFTHHjtG9sle/lDO6tm/TLPPjAvbxvYO5WdO+blp5/Llj++nPMfmJQd2xry8srWEewAAAAA2HeH9zzcji4AWp2ampr9fm2bDV01NTXZsGFDFi5cmFNPPbXJWm1tba699tokyZAhQ5oEqAEDBmTevHlN7p8/f34aGxuzfv36fZqhVCqluro6v/nNb/bzUxx4217ZkunHXLbXexp37Mj6JSt3/n3HQw9J9xP6Zt0vn8z2zVubeUIAAAAAmsuy5cvSvlNVuccAgAOm/A+NaiYjRoxIkkyePDnLli3beX3+/Pk566yzUldXlyQZNmxYk9eNHz8+jz76aG688cbU1dVl0aJFueqqq1JRUdEqnrHV4kqlDL/xf6VU0S5PfPXuck8DAAAAAACwU5vd0TVx4sTMmDEjq1evzqBBg3Lcccdly5YtefrppzNq1Kj06dMnP/rRj5o8nytJLrvssixZsiQ33HBDPvvZz6aioiJXX311OnTokK5du5bp07SMyk5VGf3DSVn1w19l07MvpEOXTun73tPTY+gx+fWkGVn32L4d3QgAAAAAANCc2uwWpSOPPDJz587N+eefn6qqqqxcuTLdunXLtGnTMnv27J27vF4fukqlUr70pS+lrq4ujz/+eJ5//vl8+ctfzvLly3PaaaeV46O0mB3bGrJ+yaoc/d7T886brsiQay7Kqxs25scfuiGLp36/3OMBAAAAAAA0UWpsbGws9xAtbdOmTenatWtKpVI2btyYTp067fX+2267LVdffXWWLl2aY445poWmbB5v5BldAAAAALRNY1fc4RldALQpbfbowr1ZsmRJGhsbM2DAgF0i14IFC/LQQw/lxBNPTENDQ37yk59k6tSpmTJlSuEjFwAAAAAAQFvylgxdixcvTrLrsYVJctBBB+X+++/PpEmT0tDQkMGDB2fmzJm5+OKLW3pMAAAAAAAA9kLoep3Bgwfnsccea+mRAAAAAAAA2Eftyj1AOewtdAEAAAAAAFAMb8kdXXPmzCn3CAAAAAAAALxJb8kdXQAAAAAAABSf0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIQldAAAAAAAAFJLQBQAAAAAAQCEJXQAAAAAAABSS0AUAAAAAAEAhCV0AAAAAAAAUktAFAAAAAABAIZUaGxsbyz0ELaexsTENm18t9xgAAAAAlEFlx4NSKpXKPQYAHDBCFwAAAAAAAIXk6EIAAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAKSegCAAAAAACgkIQuAAAAAAAACknoAgAAAAAAoJCELgAAAAAAAApJ6AIAAAAAAKCQhC4AAAAAAAAK6f8BpIS8JocIZLgAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 2210.55x1789.28 with 1 Axes>"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Initiate the list of operators with the first one\n",
+    "operator_list = [max_operator]\n",
+    "# Append the second operator\n",
+    "operator_list.append(excitation_pool[max_index])\n",
+    "\n",
+    "ansatz = EvolvedOperatorAnsatz(\n",
+    "    operators=operator_list,\n",
+    "    evolution=LieTrotter(),\n",
+    "    parameter_prefix=\"theta\",\n",
+    "    initial_state=hf_circuit,\n",
+    ")\n",
+    "ansatz.decompose().draw(output=\"mpl\", style=\"iqp\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[3.69347678 1.31200293]\n",
+      " message: Optimization terminated successfully.\n",
+      " success: True\n",
+      "  status: 1\n",
+      "     fun: -7.968684162211259\n",
+      "       x: [ 3.260e+00  3.191e+00]\n",
+      "    nfev: 38\n",
+      "   maxcv: 0.0\n",
+      "   Normal return from subroutine COBYLA\n",
+      "\n",
+      "   NFVALS =   38   F =-7.968684E+00    MAXCV = 0.000000E+00\n",
+      "   X = 3.259787E+00   3.191352E+00\n",
+      "\n",
+      "Found ground energy: -7.968684162211259\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Random start for the ansatz parameters\n",
+    "x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n",
+    "print(x0)\n",
+    "\n",
+    "res = minimize(\n",
+    "    cost_func,\n",
+    "    x0,\n",
+    "    args=(ansatz, H, estimator),\n",
+    "    method=\"cobyla\",\n",
+    "    options={\"maxiter\": 50, \"disp\": True},\n",
+    ")\n",
+    "print(res)\n",
+    "\n",
+    "# Note this returns the total energy, and we are often interested in the electronic energy\n",
+    "ground_energy = getattr(res, \"fun\")\n",
+    "print(f\"Found ground energy: {ground_energy}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Putting it all together\n",
+    "Now we automate the algorithm in a single loop."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iter: 0\n",
+      "Maximum gradient: 0.2502515943160271\n",
+      "Operator: SparsePauliOp(['YZZZYXZZZY', 'XZZZYYZZZY', 'XZZZXXZZZY', 'YZZZXYZZZY', 'XZZZYXZZZX', 'YZZZYYZZZX', 'YZZZXXZZZX', 'XZZZXYZZZX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) at index 23\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.96690628533084\n",
+      "            Iterations: 2\n",
+      "            Function evaluations: 5\n",
+      "            Gradient evaluations: 2\n",
+      "Result at iter 0: -7.96690628533084\n",
+      "Iter: 1\n",
+      "Maximum gradient: 0.07148403096724774\n",
+      "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) at index 11\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.968684179381521\n",
+      "            Iterations: 4\n",
+      "            Function evaluations: 14\n",
+      "            Gradient evaluations: 4\n",
+      "Result at iter 1: -7.968684179381521\n",
+      "Iter: 2\n",
+      "Maximum gradient: 0.06886933068636508\n",
+      "Operator: SparsePauliOp(['IIIYYXZZZY', 'IIIXYYZZZY', 'IIIXXXZZZY', 'IIIYXYZZZY', 'IIIXYXZZZX', 'IIIYYYZZZX', 'IIIYXXZZZX', 'IIIXXYZZZX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) at index 20\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.970337033804881\n",
+      "            Iterations: 9\n",
+      "            Function evaluations: 38\n",
+      "            Gradient evaluations: 9\n",
+      "Result at iter 2: -7.970337033804881\n",
+      "Iter: 3\n",
+      "Maximum gradient: 0.037913688371952387\n",
+      "Operator: SparsePauliOp(['IIYZYIIXZY', 'IIXZYIIYZY', 'IIXZXIIXZY', 'IIYZXIIYZY', 'IIXZYIIXZX', 'IIYZYIIYZX', 'IIYZXIIXZX', 'IIXZXIIYZX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) at index 13\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.970872545712573\n",
+      "            Iterations: 13\n",
+      "            Function evaluations: 70\n",
+      "            Gradient evaluations: 13\n",
+      "Result at iter 3: -7.970872545712573\n",
+      "Iter: 4\n",
+      "Maximum gradient: 0.0370331504791646\n",
+      "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) at index 18\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.9713831777419575\n",
+      "            Iterations: 8\n",
+      "            Function evaluations: 51\n",
+      "            Gradient evaluations: 8\n",
+      "Result at iter 4: -7.9713831777419575\n",
+      "Iter: 5\n",
+      "Maximum gradient: 0.03222663915985274\n",
+      "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) at index 8\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.971773096075161\n",
+      "            Iterations: 11\n",
+      "            Function evaluations: 79\n",
+      "            Gradient evaluations: 11\n",
+      "Result at iter 5: -7.971773096075161\n",
+      "Iter: 6\n",
+      "Maximum gradient: 0.010822180643551265\n",
+      "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n",
+      "              coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.843848009002418\n",
+      "            Iterations: 17\n",
+      "            Function evaluations: 140\n",
+      "            Gradient evaluations: 17\n",
+      "Result at iter 6: -7.843848009002418\n",
+      "Iter: 7\n",
+      "Maximum gradient: 0.027309663041504336\n",
+      "Operator: SparsePauliOp(['IIIIIIIIXY', 'IIIIIIIIYX'],\n",
+      "              coeffs=[ 0.5+0.j, -0.5+0.j]) at index 0\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.9721464190570135\n",
+      "            Iterations: 19\n",
+      "            Function evaluations: 176\n",
+      "            Gradient evaluations: 19\n",
+      "Result at iter 7: -7.9721464190570135\n",
+      "Iter: 8\n",
+      "Maximum gradient: 0.007078468872372422\n",
+      "Operator: SparsePauliOp(['XZZZYIIIII', 'YZZZXIIIII'],\n",
+      "              coeffs=[ 0.5+0.j, -0.5+0.j]) at index 7\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.969650196128157\n",
+      "            Iterations: 35\n",
+      "            Function evaluations: 354\n",
+      "            Gradient evaluations: 35\n",
+      "Result at iter 8: -7.969650196128157\n",
+      "Iter: 9\n",
+      "Maximum gradient: 0.062120282561613935\n",
+      "Operator: SparsePauliOp(['YZZZYIIIXY', 'XZZZYIIIYY', 'XZZZXIIIXY', 'YZZZXIIIYY', 'XZZZYIIIXX', 'YZZZYIIIYX', 'YZZZXIIIXX', 'XZZZXIIIYX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) at index 11\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.970433246503186\n",
+      "            Iterations: 20\n",
+      "            Function evaluations: 221\n",
+      "            Gradient evaluations: 20\n",
+      "Result at iter 9: -7.970433246503186\n",
+      "Iter: 10\n",
+      "Maximum gradient: 0.04600075108884966\n",
+      "Operator: SparsePauliOp(['IIIYYIIIXY', 'IIIXYIIIYY', 'IIIXXIIIXY', 'IIIYXIIIYY', 'IIIXYIIIXX', 'IIIYYIIIYX', 'IIIYXIIIXX', 'IIIXXIIIYX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) at index 8\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.97202896422045\n",
+      "            Iterations: 40\n",
+      "            Function evaluations: 484\n",
+      "            Gradient evaluations: 40\n",
+      "Result at iter 10: -7.97202896422045\n",
+      "Iter: 11\n",
+      "Maximum gradient: 0.007578946243724553\n",
+      "Operator: SparsePauliOp(['IIIXYIIIII', 'IIIYXIIIII'],\n",
+      "              coeffs=[ 0.5+0.j, -0.5+0.j]) at index 4\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.971706856193244\n",
+      "            Iterations: 28\n",
+      "            Function evaluations: 369\n",
+      "            Gradient evaluations: 28\n",
+      "Result at iter 11: -7.971706856193244\n",
+      "Iter: 12\n",
+      "Maximum gradient: 0.03538610952465948\n",
+      "Operator: SparsePauliOp(['IYZZYIXZZY', 'IXZZYIYZZY', 'IXZZXIXZZY', 'IYZZXIYZZY', 'IXZZYIXZZX', 'IYZZYIYZZX', 'IYZZXIXZZX', 'IXZZXIYZZX'],\n",
+      "              coeffs=[-0.125+0.j, -0.125+0.j, -0.125+0.j,  0.125+0.j, -0.125+0.j,  0.125+0.j,\n",
+      "  0.125+0.j,  0.125+0.j]) at index 18\n",
+      "Optimization terminated successfully    (Exit mode 0)\n",
+      "            Current function value: -7.972179565844087\n",
+      "            Iterations: 35\n",
+      "            Function evaluations: 496\n",
+      "            Gradient evaluations: 35\n",
+      "Result at iter 12: -7.972179565844087\n",
+      "Iter: 13\n",
+      "Maximum gradient: 0.00030622409164124463\n",
+      "Terminating: converged.\n",
+      "Found ground energy: -7.972179565844087\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qiskit.circuit.library import EvolvedOperatorAnsatz\n",
+    "from qiskit.primitives import StatevectorEstimator as Estimator\n",
+    "from qiskit.synthesis import LieTrotter\n",
+    "from scipy.optimize import minimize\n",
+    "\n",
+    "# Define the conditions for termination\n",
+    "gradient_threshold = 1e-3\n",
+    "max_iter = 15\n",
+    "terminate = False\n",
+    "\n",
+    "# Initiate the problem\n",
+    "ansatz = hf_circuit\n",
+    "hamiltonian = H\n",
+    "excitation_pool = single_excitation_operators + double_excitation_operators\n",
+    "estimator = Estimator()\n",
+    "params = None\n",
+    "\n",
+    "iter = 0\n",
+    "operator_list = []\n",
+    "while not terminate:\n",
+    "    print(f\"Iter: {iter}\")\n",
+    "    gradients = compute_gradients(ansatz, hamiltonian, excitation_pool, estimator, params)\n",
+    "    max_gradient = np.max(np.abs(gradients))\n",
+    "    print(f\"Maximum gradient: {max_gradient}\")\n",
+    "    # Check convergence\n",
+    "    if max_gradient > gradient_threshold:\n",
+    "        # Find the operator with the largest gradient\n",
+    "        max_index = np.argmax(np.abs(gradients))\n",
+    "        max_operator = excitation_pool[max_index]\n",
+    "        print(f\"Operator: {max_operator} at index {max_index}\")\n",
+    "        # Grow the ansatz\n",
+    "        operator_list.append(max_operator)\n",
+    "        ansatz = EvolvedOperatorAnsatz(\n",
+    "            operators=operator_list,\n",
+    "            evolution=LieTrotter(),\n",
+    "            parameter_prefix=\"theta\",\n",
+    "            initial_state=hf_circuit,\n",
+    "        )\n",
+    "        # Run VQE on the current ansatz\n",
+    "        x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n",
+    "        res = minimize(\n",
+    "            cost_func,\n",
+    "            x0,\n",
+    "            args=(ansatz, H, estimator),\n",
+    "            method=\"slsqp\",\n",
+    "            options={\"maxiter\": 50, \"disp\": True},\n",
+    "        )\n",
+    "        print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n",
+    "        x_opt = getattr(res, \"x\")\n",
+    "        params = x_opt\n",
+    "        # Terminate if maximum number of iterations reached\n",
+    "        iter += 1\n",
+    "        if iter >= max_iter:\n",
+    "            print(\"Terminating: reached maximum iteration.\")\n",
+    "            terminate = True\n",
+    "    # Terminate if converged\n",
+    "    else:\n",
+    "        print(\"Terminating: converged.\")\n",
+    "        terminate = True\n",
+    "\n",
+    "# Note this returns the total energy, and we are often interested in the electronic energy\n",
+    "ground_energy = getattr(res, \"fun\")\n",
+    "print(f\"Found ground energy: {ground_energy}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit.circuit.library import EvolvedOperatorAnsatz\n",
+    "from qiskit.synthesis import LieTrotter\n",
+    "\n",
+    "# To continue running on real hardware use\n",
+    "from qiskit_ibm_runtime import EstimatorV2 as Estimator, EstimatorOptions, Session\n",
+    "from scipy.optimize import minimize\n",
+    "\n",
+    "hf_circuit_ibm = pm.run(hf_circuit)\n",
+    "H_ibm = H.apply_layout(hf_circuit_ibm.layout)\n",
+    "\n",
+    "# Define the conditions for termination\n",
+    "gradient_threshold = 5e-3\n",
+    "max_iter = 15\n",
+    "terminate = False\n",
+    "\n",
+    "with Session(backend=backend):\n",
+    "    session_options = EstimatorOptions()\n",
+    "    session_options.default_shots = 10000\n",
+    "    session_options.resilience_level = 1\n",
+    "\n",
+    "    # Initiate the problem\n",
+    "    ansatz = hf_circuit_ibm\n",
+    "    hamiltonian = H_ibm\n",
+    "    excitation_pool = single_excitation_operators + double_excitation_operators\n",
+    "    estimator = Estimator(session=Session(service, backend=backend), options=session_options)\n",
+    "    params = None\n",
+    "\n",
+    "    iter = 0\n",
+    "    operator_list = []\n",
+    "    while not terminate:\n",
+    "        print(f\"Iter: {iter}\")\n",
+    "        excitation_pool_ibm = [exc.apply_layout(ansatz.layout) for exc in excitation_pool]\n",
+    "        gradients = compute_gradients(ansatz, hamiltonian, excitation_pool_ibm, estimator, params)\n",
+    "        max_gradient = np.max(np.abs(gradients))\n",
+    "        print(f\"Maximum gradient: {max_gradient}\")\n",
+    "        # Check convergence\n",
+    "        if max_gradient > gradient_threshold:\n",
+    "            # Find the operator with the largest gradient\n",
+    "            max_index = np.argmax(np.abs(gradients))\n",
+    "            max_operator = excitation_pool[max_index]\n",
+    "            print(f\"Operator: {max_operator} at index {max_index}\")\n",
+    "            # Grow the ansatz\n",
+    "            operator_list.append(max_operator)\n",
+    "            ansatz = EvolvedOperatorAnsatz(\n",
+    "                operators=operator_list,\n",
+    "                evolution=LieTrotter(),\n",
+    "                parameter_prefix=\"theta\",\n",
+    "                initial_state=hf_circuit,\n",
+    "            )\n",
+    "            ansatz = pm.run(ansatz)\n",
+    "            hamiltonian = H.apply_layout(ansatz.layout)\n",
+    "            # Run VQE on the current ansatz\n",
+    "            x0 = 2 * np.pi * np.random.random(ansatz.num_parameters)\n",
+    "            res = minimize(\n",
+    "                cost_func,\n",
+    "                x0,\n",
+    "                args=(ansatz, hamiltonian, estimator),\n",
+    "                method=\"slsqp\",\n",
+    "                options={\"maxiter\": 50, \"disp\": True},\n",
+    "            )\n",
+    "            print(f\"Result at iter {iter}: {getattr(res, 'fun')}\")\n",
+    "            x_opt = getattr(res, \"x\")\n",
+    "            params = x_opt\n",
+    "            # Terminate if maximum number of iterations reached\n",
+    "            iter += 1\n",
+    "            if iter >= max_iter:\n",
+    "                print(\"Terminating: reached maximum iteration.\")\n",
+    "                terminate = True\n",
+    "        # Terminate if converged\n",
+    "        else:\n",
+    "            print(\"Terminating: converged.\")\n",
+    "            terminate = True\n",
+    "\n",
+    "# Note this returns the total energy, and we are often interested in the electronic energy\n",
+    "ground_energy = getattr(res, \"fun\")\n",
+    "print(f\"Found ground energy: {ground_energy}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "quantum",
+   "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.10.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/pyproject.toml b/pyproject.toml
index 4e3a14b..6d0b950 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -75,6 +75,7 @@ notebook = [
     # QISKIT CORE
     "qiskit[visualization] >= 1.0.0",
     # EXTRA
+    "pyscf >= 2.4.0"
 ]
 
 [project.urls]