{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Minimum Eigen Optimizer\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An interesting class of optimization problems to be addressed by quantum computing are Quadratic Unconstrained Binary Optimization (QUBO) problems.\n",
    "Finding the solution to a QUBO is equivalent to finding the ground state of a corresponding Ising Hamiltonian, which is an important problem not only in optimization, but also in quantum chemistry and physics. For this translation, the binary variables taking values in $\\{0, 1\\}$ are replaced by spin variables taking values in $\\{-1, +1\\}$, which allows one to replace the resulting spin variables by Pauli Z matrices, and thus, an Ising Hamiltonian. For more details on this mapping we refer to [1].\n",
    "\n",
    "Qiskit optimization provides automatic conversion from a suitable `QuadraticProgram` to an Ising Hamiltonian, which then allows leveraging all the `SamplingMinimumEigensolver` implementations, such as\n",
    "\n",
    "- `SamplingVQE`,\n",
    "- `QAOA`, or\n",
    "- `NumpyMinimumEigensolver` (classical exact method).\n",
    "\n",
    "Note 1: `MinimumEigenOptimizer` does not support `qiskit_algorithms.VQE`. But `qiskit_algorithms.SamplingVQE`\n",
    "can be used instead.\n",
    "\n",
    "Note 2: `MinimumEigenOptimizer` can use `NumpyMinimumEigensolver` as an exception case though it inherits `MinimumEigensolver` (not `SamplingMinimumEigensolver`).\n",
    "\n",
    "Qiskit optimization provides a the `MinimumEigenOptimizer` class, which wraps the translation to an Ising Hamiltonian (in Qiskit Terra also called `SparsePauliOp`), the call to a `MinimumEigensolver`, and the translation of the results back to an `OptimizationResult`.\n",
    "\n",
    "In the following we first illustrate the conversion from a `QuadraticProgram` to a `SparsePauliOp` and then show how to use the `MinimumEigenOptimizer` with different `MinimumEigensolver`s to solve a given `QuadraticProgram`.\n",
    "The algorithms in Qiskit optimization automatically try to convert a given problem to the supported problem class if possible, for instance, the `MinimumEigenOptimizer` will automatically translate integer variables to binary variables or add linear equality constraints as a quadratic penalty term to the objective. It should be mentioned that a `QiskitOptimizationError` will be thrown if conversion of a quadratic program with integer variables is attempted.\n",
    "\n",
    "The circuit depth of `QAOA` potentially has to be increased with the problem size, which might be prohibitive for near-term quantum devices.\n",
    "A possible workaround is Recursive QAOA, as introduced in [2].\n",
    "Qiskit optimization generalizes this concept to the `RecursiveMinimumEigenOptimizer`, which is introduced at the end of this tutorial.\n",
    "\n",
    "### References\n",
    "[1] [A. Lucas, *Ising formulations of many NP problems,* Front. Phys., 12 (2014).](https://arxiv.org/abs/1302.5843)\n",
    "\n",
    "[2] [S. Bravyi, A. Kliesch, R. Koenig, E. Tang, *Obstacles to State Preparation and Variational Optimization from Symmetry Protection,* arXiv  preprint arXiv:1910.08980 (2019).](https://arxiv.org/abs/1910.08980)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting a QUBO to a SparsePauliOp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit_algorithms.utils import algorithm_globals\n",
    "from qiskit_algorithms import QAOA, NumPyMinimumEigensolver\n",
    "from qiskit_algorithms.optimizers import COBYLA\n",
    "from qiskit.primitives import Sampler\n",
    "from qiskit_optimization.algorithms import (\n",
    "    MinimumEigenOptimizer,\n",
    "    RecursiveMinimumEigenOptimizer,\n",
    "    SolutionSample,\n",
    "    OptimizationResultStatus,\n",
    ")\n",
    "from qiskit_optimization import QuadraticProgram\n",
    "from qiskit.visualization import plot_histogram\n",
    "from typing import List, Tuple\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem name: \n",
      "\n",
      "Minimize\n",
      "  x*y - x*z + 2*y*z + x - 2*y + 3*z\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Binary variables (3)\n",
      "    x y z\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# create a QUBO\n",
    "qubo = QuadraticProgram()\n",
    "qubo.binary_var(\"x\")\n",
    "qubo.binary_var(\"y\")\n",
    "qubo.binary_var(\"z\")\n",
    "qubo.minimize(linear=[1, -2, 3], quadratic={(\"x\", \"y\"): 1, (\"x\", \"z\"): -1, (\"y\", \"z\"): 2})\n",
    "print(qubo.prettyprint())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we translate this QUBO into an Ising operator. This results not only in a `SparsePauliOp` but also in a constant offset to be taken into account to shift the resulting value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "offset: 1.5\n",
      "operator:\n",
      "SparsePauliOp(['IIZ', 'IZI', 'ZII', 'IZZ', 'ZIZ', 'ZZI'],\n",
      "              coeffs=[-0.5 +0.j,  0.25+0.j, -1.75+0.j,  0.25+0.j, -0.25+0.j,  0.5 +0.j])\n"
     ]
    }
   ],
   "source": [
    "op, offset = qubo.to_ising()\n",
    "print(\"offset: {}\".format(offset))\n",
    "print(\"operator:\")\n",
    "print(op)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes a `QuadraticProgram` might also directly be given in the form of a `SparsePauliOp`. For such cases, Qiskit optimization also provides a translator from a `SparsePauliOp` back to a `QuadraticProgram`, which we illustrate in the following."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Problem name: \n",
      "\n",
      "Minimize\n",
      "  x0*x1 - x0*x2 + 2*x1*x2 + x0 - 2*x1 + 3*x2\n",
      "\n",
      "Subject to\n",
      "  No constraints\n",
      "\n",
      "  Binary variables (3)\n",
      "    x0 x1 x2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "qp = QuadraticProgram()\n",
    "qp.from_ising(op, offset, linear=True)\n",
    "print(qp.prettyprint())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This translator allows, for instance, one to translate a `SparsePauliOp` to a `QuadraticProgram` and then solve the problem with other algorithms that are not based on the Ising Hamiltonian representation, such as the `GroverOptimizer`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solving a QUBO with the MinimumEigenOptimizer"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start by initializing the `MinimumEigensolver` we want to use."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "algorithm_globals.random_seed = 10598\n",
    "qaoa_mes = QAOA(sampler=Sampler(), optimizer=COBYLA(), initial_point=[0.0, 0.0])\n",
    "exact_mes = NumPyMinimumEigensolver()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we use the `MinimumEigensolver` to create `MinimumEigenOptimizer`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "qaoa = MinimumEigenOptimizer(qaoa_mes)  # using QAOA\n",
    "exact = MinimumEigenOptimizer(exact_mes)  # using the exact classical numpy minimum eigen solver"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first use the `MinimumEigenOptimizer` based on the classical exact `NumPyMinimumEigensolver` to get the optimal benchmark solution for this small example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "objective function value: -2.0\n",
      "variable values: x=0.0, y=1.0, z=0.0\n",
      "status: SUCCESS\n"
     ]
    }
   ],
   "source": [
    "exact_result = exact.solve(qubo)\n",
    "print(exact_result.prettyprint())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we apply the `MinimumEigenOptimizer` based on `QAOA` to the same problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "objective function value: -2.0\n",
      "variable values: x=0.0, y=1.0, z=0.0\n",
      "status: SUCCESS\n"
     ]
    }
   ],
   "source": [
    "qaoa_result = qaoa.solve(qubo)\n",
    "print(qaoa_result.prettyprint())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analysis of Samples\n",
    "`OptimizationResult` provides useful information in the form of `SolutionSample`s (here denoted as *samples*). Each `SolutionSample` contains\n",
    "information about the input values (`x`), the corresponding objective function value (`fval`), the fraction of samples corresponding to that input (`probability`),\n",
    "and the solution `status` (`SUCCESS`, `FAILURE`, `INFEASIBLE`). Multiple samples corresponding to the same input are consolidated into a single `SolutionSample` (with its `probability` attribute being the aggregate fraction of samples represented by that `SolutionSample`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "variable order: ['x', 'y', 'z']\n",
      "SolutionSample(x=array([0., 1., 0.]), fval=-2.0, probability=0.4409914383320322, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([0., 0., 0.]), fval=0.0, probability=0.2276808656506505, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([1., 1., 0.]), fval=0.0, probability=0.1413908468641879, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([1., 0., 0.]), fval=1.0, probability=0.1257339279014548, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([0., 0., 1.]), fval=3.0, probability=0.020491301242878, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([1., 0., 1.]), fval=3.0, probability=0.0304288193232328, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([0., 1., 1.]), fval=3.0, probability=0.0123642766450843, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([1., 1., 1.]), fval=4.0, probability=0.0009185240404783, status=<OptimizationResultStatus.SUCCESS: 0>)\n"
     ]
    }
   ],
   "source": [
    "print(\"variable order:\", [var.name for var in qaoa_result.variables])\n",
    "for s in qaoa_result.samples:\n",
    "    print(s)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We may also want to filter samples according to their status or probabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_filtered_samples(\n",
    "    samples: List[SolutionSample],\n",
    "    threshold: float = 0,\n",
    "    allowed_status: Tuple[OptimizationResultStatus] = (OptimizationResultStatus.SUCCESS,),\n",
    "):\n",
    "    res = []\n",
    "    for s in samples:\n",
    "        if s.status in allowed_status and s.probability > threshold:\n",
    "            res.append(s)\n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SolutionSample(x=array([0., 1., 0.]), fval=-2.0, probability=0.4409914383320322, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([0., 0., 0.]), fval=0.0, probability=0.2276808656506505, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([1., 1., 0.]), fval=0.0, probability=0.1413908468641879, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([1., 0., 0.]), fval=1.0, probability=0.1257339279014548, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([0., 0., 1.]), fval=3.0, probability=0.020491301242878, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([1., 0., 1.]), fval=3.0, probability=0.0304288193232328, status=<OptimizationResultStatus.SUCCESS: 0>)\n",
      "SolutionSample(x=array([0., 1., 1.]), fval=3.0, probability=0.0123642766450843, status=<OptimizationResultStatus.SUCCESS: 0>)\n"
     ]
    }
   ],
   "source": [
    "filtered_samples = get_filtered_samples(\n",
    "    qaoa_result.samples, threshold=0.005, allowed_status=(OptimizationResultStatus.SUCCESS,)\n",
    ")\n",
    "for s in filtered_samples:\n",
    "    print(s)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to obtain a better perspective of the results, statistics is very helpful, both with respect to\n",
    "the objective function values and their respective probabilities. Thus, mean and standard deviation are the very\n",
    "basics for understanding the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "fvals = [s.fval for s in qaoa_result.samples]\n",
    "probabilities = [s.probability for s in qaoa_result.samples]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(fvals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.9364916731037085"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(fvals)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, despite all the number-crunching, visualization is usually the best early-analysis approach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x=0 y=1 z=0': 0.4409914383320322,\n",
       " 'x=0 y=0 z=0': 0.2276808656506505,\n",
       " 'x=1 y=1 z=0': 0.1413908468641879,\n",
       " 'x=1 y=0 z=0': 0.1257339279014548,\n",
       " 'x=0 y=0 z=1': 0.020491301242878,\n",
       " 'x=1 y=0 z=1': 0.0304288193232328,\n",
       " 'x=0 y=1 z=1': 0.0123642766450843}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "samples_for_plot = {\n",
    "    \" \".join(f\"{qaoa_result.variables[i].name}={int(v)}\" for i, v in enumerate(s.x)): s.probability\n",
    "    for s in filtered_samples\n",
    "}\n",
    "samples_for_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnMAAAIhCAYAAAAl9jzyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1wElEQVR4nO3deXxM5/4H8M/JJJKIJAgSW4QiaqfEvpbEpbqpvdZeW9EqdV20li729tLSvZarXHqrbqsIsW+xi62WCEkQCZHIhiQz8/394TdTIwlzJsvMZD7v16uvV/PMmZPn+eaZ8Zkz5zxHEREBEREREdklJ2t3gIiIiIgsxzBHREREZMcY5oiIiIjsGMMcERERkR1jmCMiIiKyYwxzRERERHaMYY6IiIjIjjlbuwP2Qq/XIy4uDp6enlAUxdrdISIiomJORJCWloZKlSrBySnv428Mc2aKi4tD1apVrd0NIiIicjDXr19HlSpV8nycYc5Mnp6eAB4V1MvLy8q9ISIiouIuNTUVVatWNWaQvDDMmcnw1aqXlxfDHBERERWZZ53exQsgiIiIiOwYwxwRERGRHWOYIyIiIrJjDHNEDmjZsmUICAiAm5sbWrRogaNHj5r1vHXr1kFRFLz66qt5bjN69GgoioLFixebtH/66ado3bo1SpYsidKlS1veeSIiMsEwR+Rg1q9fj4kTJ2LmzJk4efIkGjVqhJCQENy+ffupz4uOjsb777+Pdu3a5bnNxo0bcfjwYVSqVCnHY1lZWejduzfGjBmT7zEQEdFfGOaIHMznn3+OESNGYNiwYahbty6++eYblCxZEsuXL8/zOTqdDgMHDsTs2bNRo0aNXLe5efMmxo8fjzVr1sDFxSXH47Nnz8Z7772HBg0aFNhYiIiIYY7IoWRlZeHEiRPo0qWLsc3JyQldunRBeHh4ns/76KOPUKFCBbz11lu5Pq7X6zFo0CBMnjwZ9erVK/B+ExFR3rjOHJEDSUxMhE6ng6+vr0m7r68vLl68mOtzDhw4gB9//BERERF57nf+/PlwdnbGO++8U5DdJSIiMzDMEVGe0tLSMGjQIHz//fcoV65crtucOHECS5YswcmTJ3nfYiIiK2CYI3Ig5cqVg0ajQUJCgkl7QkIC/Pz8cmwfFRWF6Oho9OzZ09im1+sBAM7Ozrh06RL279+P27dvw9/f37iNTqfDpEmTsHjxYkRHRxfOYIiICADDHJFDKVGiBF544QXs3LnTuLyIXq/Hzp07MW7cuBzb16lTB2fPnjVp++CDD5CWloYlS5agatWqGDRokMk5eAAQEhKCQYMGYdiwYYU2FiIieoRhjsjBTJw4EUOGDEGzZs0QFBSExYsXIyMjwxi8Bg8ejMqVK2Pu3Llwc3ND/fr1TZ5vWCPO0O7j4wMfHx+TbVxcXODn54fAwEBjW2xsLJKSkhAbGwudTmc8B69mzZooVapUIY2WiKj4Y5gjcjB9+/bFnTt3MGPGDMTHx6Nx48YIDQ01XhQRGxsLJ6eCv9B9xowZWLVqlfHnJk2aAAB2796Njh07FvjvIyJyFIqIiLU7YQ9SU1Ph7e2NlJQUeHl5Wbs7REREVMyZmz24zhwRERGRHWOYIyIiIrJjDHNEREREdoxhjoiIiMiOMcwRERER2TGGOSIiIiI7xjBHREREZMcY5oiIiIjsGMMcERERkR1jmCMiIiKyYwxzRERERHaMYY6IiIjIjjHMEREREdkxhjkiIiIiO8YwR0RERGTHGOaIiIiI7BjDHBEREZEdY5gjIiIismPO1u4AERWdEYut3YOcvp9g7R4QEdk3HpkjIiIismMMc0RERER2jGGOiIiIyI4xzBERERHZMYY5IiIiIjvGMEdERERkxxjmiIiIiOwYwxwRERGRHWOYIyIiIrJjDHNEREREdoxhjoiIiMiOMcwRERER2TGGOSIiIiI7xjBHREREZMcY5oiIiIjsGMMcERERkR1jmCMiIiKyYwxzRERERHaMYY6IiIjIjjHMEREREdkxhjkiIiIiO8YwR0RERGTHGOaIiIiI7BjDHBEREZEdY5gjIiIismMMc0RERER2zGbD3LFjx9C9e3eULl0aHh4eaNmyJX7++WeL95ecnIzKlStDURR069atAHtKREREZD3O1u5Abnbv3o2QkBC4ubmhX79+8PT0xIYNG9C3b19cv34dkyZNUr3PcePGISUlpRB6S0RERGQ9NndkTqvVYsSIEXBycsK+ffvw3Xff4bPPPsPp06dRu3ZtTJs2DTExMar2uWHDBqxduxbz588vpF4TERERWYfNhbldu3YhKioKAwYMQOPGjY3t3t7emDZtGrKysrBq1Sqz93fnzh2MGTMGgwYNQo8ePQqhx0RERETWY3Nhbs+ePQCA4ODgHI+FhIQAAPbu3Wv2/kaPHg2NRoMlS5YUSP+IiIiIbInNnTMXGRkJAKhVq1aOx/z8/FCqVCnjNs/y008/4ddff8X//vc/lClTRtU5c5mZmcjMzDT+nJqaCgDIzs5GdnY2AMDJyQkajQY6nQ56vd64raFdq9VCRIztGo0GTk5OebYb9mvg7Pzoz6PVas1qd3FxgV6vh06nM7YpigJnZ+c82/PqO8dUPMdki/h64pg4Jo6JY8p7TOawuTBnCFze3t65Pu7l5WVWKIuLi8M777yD/v3745VXXlHdj7lz52L27Nk52rdv346SJUsCAPz9/dGkSROcOXMGsbGxxm0CAwNRp04dHD16FHfu3DG2N27cGNWqVcO+ffuQlpZmbG/VqhUqVKiA7du3m/zhOnXqBHd3d2zZssWkD927d8eDBw+we/duY5uzszN69OiBxMREhIeHG9s9PT3RuXNnXL9+HREREcb28uXLo3Xr1oiMjMSlS5eM7RxT8R6TLTLUjX8njolj4pg4JtMxnThxAuZQ5PG4agOCg4MRFhaGyMhI1KxZM8fjlStXRnp6+jMDXffu3XHixAmcP38e5cqVAwBER0ejevXqCAkJQWho6FOfn9uRuapVqyIxMRFeXl4AHPdTAsdkv2MasRg256uxPDLHMXFMHBPHlFt7UlISfHx8kJKSYsweubG5I3OGI3J5hbXU1FSUKVPmqftYtWoVtm7div/+97/GIKeWq6srXF1dc7S7uLjAxcXFpE2j0UCj0eTY1jABzG1/cr+WtDs5OeX6dVpe7Xn1nWMqnmOyRXw95cQxcUwcE8cEmP9ebnMn0RjOlcvtvLj4+Hikp6fnej7d406dOgUA6N27NxRFMf5XvXp1AMC2bdugKIrJ1bJERERE9sjmPr536NABc+fOxfbt29GvXz+Tx7Zt22bc5mlatWqF9PT0HO3p6elYv349qlSpgpCQEPj7+xdcx4mIiIiswObOmdNqtQgMDMTNmzdx+PBh49GzlJQUBAUFITo6GpcuXUJAQAAA4NatW0hJSUHFihXzvGjCQM05c09KTU2Ft7f3M7+3JrJltnjO3PcTrN0DIiLbZG72sLmvWZ2dnfHDDz9Ar9ejffv2GDlyJCZNmoRGjRrh8uXLmDNnjjHIAcDUqVPx/PPPY+PGjdbrNBEREZGV2NzXrMCjy4MPHDiAmTNnYv369cjOzkaDBg0wf/589O3b19rdIyIiIrIZNvc1q63i16xUHPBrViIi+2G3X7MSERERkfkY5oiIiIjsGMMcERERkR1jmCMiIiKyYwxzRERERHaMYY6IiIjIjjHMEREREdkxhjkiIiIiO8YwR0RERGTHGOaIiIiI7BjDHBEREZEdY5gjIiIismMMc0RERER2jGGOiIiIyI4xzBERERHZMYY5IiIiIjvGMEdERERkxxjmiIiIiOwYwxwRERGRHWOYIyIiIrJjDHNEREREdoxhjoiIiMiOMcwRERER2TGGOSIiIiI7xjBHREREZMcY5oiIiIjsGMMcERERkR1jmCMiIiKyYwxzRERERHaMYY6IiIjIjjHMEREREdkxhjkiIiIiO8YwR0RERGTHGOaIiIiI7BjDHBEREZEdY5gjIiIismMMc0RERER2zOIwV7duXfzrX//C3bt3C7I/RERERKSCxWEuNjYW77//PqpUqYL+/ftj165dBdkvIiIiIjKDxWEuPj4eX331FerXr4/169eja9euqFmzJubNm4f4+PiC7CMRERER5cHiMFeqVCmMGjUKx44dw+nTp/H2228jOTkZ06ZNg7+/P15//XVs3boVIlKQ/SUiIiKixxTIBRANGjTAl19+ibi4OKxevRpt27bFb7/9hpdeegnVqlXD7NmzcfPmzYL4VURERET0mAK9mtXV1RUhISHo3r07/Pz8ICK4ceMGZs+ejRo1amDs2LG4f/9+Qf5KIiIiIodWYGFu+/bt6NOnD6pUqYIpU6ZAURR8+OGHuHLlCn7++Wc0bdoU33zzDcaOHVtQv5KIiIjI4Tnn58k3b97E8uXLsWLFCsTExAAAgoODMWrUKPTs2RMajQYAUKNGDbzxxhvo2bMnfvvtt/z3moiIiIgA5CPMvfTSS9i2bRt0Oh18fX0xZcoUjBw5EgEBAXk+p3Xr1tiyZYulv5KIiIiInmBxmNuyZQs6d+6MUaNG4bXXXoOz87N31bNnT1SqVMnSX0lERERET7A4zF2+fBk1a9ZU9Zz69eujfv36lv5KIiIiInqCxRdAzJkzB7///vtTt/njjz8wfPhwS38FERERET2DxWFu5cqViIiIeOo2p0+fxqpVqyz9FURERET0DAW6ztyTHj58aNa5dERERERkmXwlLUVRcm0XEVy/fh1bt27lBQ9EREREhUjVkTknJydoNBrj+nGzZs0y/vz4f87OzqhevTpOnjyJfv36FUrHiYiIiEjlkbn27dsbj8bt27cP/v7+ua4rp9FoULZsWXTu3BkjRowokI4SERERUU6qwtyePXuM/+/k5IRhw4ZhxowZBd0nIiIiIjKTxefM6fX6guwHEREREVmgUK9mJSIiIqLCZfaRueHDh0NRFMyZMwe+vr5mLwasKAp+/PFHiztIRERERHlTRETM2dDJyQmKouDChQuoXbs2nJzMO6inKAp0Ol2+OmkLUlNT4e3tjZSUFHh5eVm7O0QWGbHY2j3I6fsJ1u4BEZFtMjd7mH1k7tq1awCAypUrm/xMRERERNZjdpirVq3aU38mIiIioqLHCyCIiIiI7JjZR+ZiY2Mt/iX+/v4WP5eIiIiI8mZ2mAsICMjzXqxPoygKtFqt6ucRERER0bOZHeYGDx5sUZgjIiIiosJjdphbuXJlIXYjp2PHjmHmzJk4dOgQsrOz0aBBA0ycOBF9+vQx6/lbt27FqlWrEBERgfj4eGRlZcHf3x9t2rTBlClTULt27UIeAREREVHhs/h2XoVp9+7dCAkJgZubG/r16wdPT09s2LABffv2xfXr1zFp0qRn7mPLli04fPgwWrRogb/97W9wcXHBhQsXsGrVKqxZswZbtmxB586di2A0RERERIXH7EWDi4pWq0WdOnVw48YNHD58GI0bNwYApKSkICgoCNHR0bh8+fIzl0Z5+PAh3NzccrTv3LkTXbp0QbNmzXDs2DGz+8VFg6k44KLBRET2o8AXDS6q23nt2rULUVFRGDZsmDHIAYC3tzemTZuGoUOHYtWqVZgxY8ZT95NbkAOAF198EWXKlMGVK1fM7hMRERGRrVJ1zpyiKJgyZQp8fX3NPodObZjbs2cPACA4ODjHYyEhIQCAvXv3mr2/J4WHhyM5ORlt27a1eB9EREREtsLmbucVGRkJAKhVq1aOx/z8/FCqVCnjNubYvn07Dh06hMzMTERGRuKPP/5AuXLl8K9//eupz8vMzERmZqbx59TUVABAdnY2srOzATy6X61Go4FOp4Nerzdua2jXarV4/FtsjUYDJyenPNsN+zVwdn7053lyaZe82l1cXKDX603uhasoCpydnfNsz6vvHFPxHJMt4uuJY+KYOCaOKe8xmcPmbueVkpIC4NHXqrnx8vIybmOO7du347PPPjP+XLNmTaxbtw4vvPDCU583d+5czJ49O9f9lSxZEsCjxZCbNGmCM2fOmCyqHBgYiDp16uDo0aO4c+eOsb1x48aoVq0a9u3bh7S0NGN7q1atUKFCBWzfvt3kD9epUye4u7tjy5YtJn3o3r07Hjx4gN27dxvbnJ2d0aNHDyQmJiI8PNzY7unpic6dO+P69euIiIgwtpcvXx6tW7dGZGQkLl26ZGznmIr3mGyRoW78O3FMHBPHxDGZjunEiRMwh81dABEcHIywsDBERkaiZs2aOR6vXLky0tPTVQU6AEhPT8eff/6Jjz76CDt27MDy5csxYMCAPLfP7chc1apVkZiYaDwJ0VE/JXBM9jsmW7wA4quxPDLHMXFMHBPHlFt7UlISfHx8nnkBRL7D3MaNG7Fy5UqcOnUKKSkp8Pb2RtOmTTF06FC8+uqrqvfXu3dv/PLLLzh+/HiuR888PT1RpkwZi28vptVq0axZM1y5cgXXrl1D+fLlzXoer2al4sAWwxyvZiUiyp252cPik2i0Wi369OmDN954A5s2bUJ8fDxKliyJ+Ph4/P777+jVqxf69Omj+lZehnPlcjsvLj4+Hunp6bmeT2cuZ2dndOrUCRkZGTh+/LjF+yEiIiKyBRaHublz5+KXX35Bu3btsH//fjx8+BC3bt3Cw4cPsW/fPrRt2xYbNmzAvHnzVO23Q4cOAB6dm/akbdu2mWxjqbi4OACPDpESERER2TOLv2atUaMG3NzccObMGeP3yY/Lzs5Gw4YNkZmZiatXr5q9X61Wi8DAQNy8eTPPRYMvXbqEgIAAAMCtW7eQkpKCihUrmlw0cfz4cTRr1izH/rdt24aePXvCw8MDN27cgIeHh1n94tesVBzwa1YiIvtR6F+z3rp1Cz179sw1yAGPjnr17NkTt27dUrVfZ2dn/PDDD9Dr9Wjfvj1GjhyJSZMmoVGjRrh8+TLmzJljDHIAMHXqVDz//PPYuHGjyX6aN2+OBg0aYODAgZgyZQrGjRuH9u3bo1u3bgCA5cuXmx3kiIiIiGyVxfdmrVq1KtLT05+6TUZGBvz9/VXvu1OnTjhw4ABmzpyJ9evXIzs7Gw0aNMD8+fPRt29fs/YxZ84c7N69G3v37sWdO3fg5OQEf39/jBw5EhMmTMDzzz+vul9EREREtsbir1kXLFiAhQsX4syZM6hYsWKOx2/evIlGjRphypQpmDx5cr47am38mpWKA37NSkRkPwr83qxPLgXSp08fHDx4EE2aNMGECRPQtm1b+Pr6IiEhAfv378eSJUvQtm1b9O7d2/JREBEREdFTmX1kzsnJCYqi5GgXkTzbDc9TuzyJLeKROSoOeGSOiMh+FPiRucGDB+ca2oiIiIjIeswOcytXrizEbhARERGRJSxemoSIiIiIrI9hjoiIiMiOWbzOHACkpaVh6dKl2LFjB+Li4pCZmZljG0VREBUVlZ9fQ0RERER5sDjM3blzB61bt0ZUVBS8vLyMV1xkZWXhwYMHAIBKlSrx/qdEREREhcjir1lnzZqFqKgo/Pvf/0ZycjIA4L333kNGRgaOHDmCoKAgBAQE4Pz58wXWWSIiIiIyZXGY27JlC1588UW8+eabOZYsad68ObZu3Yro6GjMnj07350kIiIiotxZHOZu3bqFJk2aGH/WaDTGr1cBoEyZMvjb3/6Gn3/+OX89JCIiIqI8WRzmvL29kZ2dbfy5TJkyuHHjhsk2Xl5eSEhIsLx3RERERPRUFoe5GjVqIDo62vhzkyZNEBYWhrt37wIAHjx4gE2bNsHf3z/fnSQiIiKi3Fkc5oKDg7Fz507cv38fADBq1Cjcvn0bjRo1Qu/evVG/fn1ERUVh6NChBdVXIiIiInqCxWFu9OjR+P77741h7vXXX8fChQuRkZGBDRs2ID4+HhMnTsTkyZMLrLNEREREZEoRESnIHep0OiQmJqJChQo5rnK1Z4Z19FJSUuDl5WXt7hBZZMRia/cgp+8nWLsHRES2ydzska87QORGo9HA19e3oHdLRERERLnId5i7desW1q1bh1OnTiElJQXe3t5o0qQJ+vXrh4oVKxZEH4mIiIgoD/kKc8uWLcPkyZORmZmJx7+t/emnnzB9+nQsWrQIb7/9dr47SURERES5szjMrVu3DuPHj0e5cuUwffp0tGvXDr6+vkhISMC+ffuwZMkS4+N9+vQpyD4TERER0f+z+AKIpk2b4saNG4iIiEClSpVyPH7jxg00adIE/v7+OHHiRL47am28AIKKA14AQURkP8zNHhYvTXLhwgX06dMn1yAHAFWqVEHv3r1x4cIFS38FERERET2DxWGudOnS8PDweOo2pUqVQunSpS39FURERET0DBaHuZdffhmbNm2CVqvN9fHs7Gxs2rQJr7zyisWdIyIiIqKnszjMLViwAB4eHggODsbhw4dNHgsPD0dwcDA8PT0xb968fHeSiIiIiHJn9tWsNWrUyNGWlZWFkydPok2bNnB2dka5cuWQmJhoPFpXsWJFNG3aFFFRUQXXYyIiIiIyMvvInF6vh4iY/Ofi4gJ/f3/4+/ujUqVKKFGiBCpVqmRsc3FxgV6vL8z+F1vLli1DQEAA3Nzc0KJFCxw9ejTPbb///nu0a9cOZcqUQZkyZdClSxeT7bOzszFlyhQ0aNAAHh4eqFSpEgYPHoy4uDiT/Vy+fBmvvPIKypUrBy8vL7Rt2xa7d+8utDESERFR/pl9ZC46OroQu0GPW79+PSZOnIhvvvkGLVq0wOLFixESEoJLly6hQoUKObbfs2cP+vfvj9atW8PNzQ3z589HcHAwzp8/j8qVK+P+/fs4efIkPvzwQzRq1AjJycl499138fLLL+P48ePG/bz00kuoVasWdu3aBXd3dyxevBgvvfQSoqKi4OfnV5QlICIiIjNZvM6coynKdeZatGiB5s2bY+nSpQAeHRWtWrUqxo8fj3/+85/PfL5Op0OZMmWwdOlSDB48ONdtjh07hqCgIMTExMDf3x+JiYkoX7489u3bh3bt2gEA0tLS4OXlhbCwMHTp0qXgBkhWw3XmiIjsR6GvM/c4rVaL8+fPIzw8HOfPn8/zCld6tqysLJw4ccIkPDk5OaFLly4IDw83ax/3799HdnY2ypYtm+c2KSkpUBTFuHSMj48PAgMD8e9//xsZGRnQarX49ttvUaFCBbzwwgv5GhMREREVnnyFuaSkJIwYMQLe3t5o2LAh2rZti4YNG6J06dIYOXIk7t69W1D9dBiJiYnQ6XTw9fU1aff19UV8fLxZ+5gyZQoqVaqU59G0hw8fYsqUKejfv78x6SuKgh07duDUqVPw9PSEm5sbPv/8c4SGhqJMmTL5GxQREREVGovvzZqUlISWLVviypUrKFu2LNq1a4eKFSsiPj4ex48fxw8//IC9e/ciPDz8qUeIqGDNmzcP69atw549e+Dm5pbj8ezsbPTp0wcigq+//trYLiIYO3YsKlSogP3798Pd3R0//PADevbsiWPHjqFixYpFOQwiIiIyk8VH5j7++GNcuXIFkydPRkxMDEJDQ7FixQps3boVMTExmDJlCiIjI/Hpp58WZH+LvXLlykGj0SAhIcGkPSEh4ZkXISxatAjz5s3D9u3b0bBhwxyPG4JcTEwMwsLCTL5/37VrF/744w+sW7cObdq0QdOmTfHVV1/B3d0dq1atKpjBERERUYGzOMz99ttv6NixI+bPn5/jtl4lS5bE3Llz0bFjR2zcuDHfnXQkJUqUwAsvvICdO3ca2/R6PXbu3IlWrVrl+bwFCxbg448/RmhoKJo1a5bjcUOQi4yMxI4dO+Dj42Py+P379wE8Oj/vcU5OTlxehoiIyIZZHObi4uKeGi4AoFWrVjnWMqNnmzhxIr7//nusWrUKFy5cwJgxY5CRkYFhw4YBAAYPHoypU6cat58/fz4+/PBDLF++HAEBAYiPj0d8fDzS09MBPApyb7zxBo4fP441a9ZAp9MZt8nKygLw6G9VpkwZDBkyBKdPn8bly5cxefJkXLt2DT169Cj6IhAREZFZLD5nztvbGzExMU/dJiYmBt7e3pb+CofVt29f3LlzBzNmzEB8fDwaN26M0NBQ40URsbGxJkfQvv76a2RlZeGNN94w2c/MmTMxa9Ys3Lx5E7///jsAoHHjxibb7N69Gx07dkS5cuUQGhqK6dOno3PnzsjOzka9evXw22+/oVGjRoU7YCIiIrKYxevM9enTB7/99hs2b96c61WTO3fuRPfu3fHqq69i/fr1+e6otRXlOnNEhYXrzBER2Q9zs4fFR+ZmzpyJzZs3IyQkBN27d0eHDh3g6+uLhIQE7NmzB1u3bkXJkiUxY8YMS38FERERET2DxWGuXr162LZtG4YOHYrNmzdj8+bNUBQFhgN9zz33HFauXIl69eoVWGeJiIiIyJTFYQ4A2rZti8jISBw8eBCnTp1CamoqvLy80KRJE7Rp0waKohRUP4mIiIgoFxaHueHDh6NBgwZ477330LZtW7Rt27Yg+0VEREREZrB4aZK1a9fi9u3bBdkXIiIiIlLJ4jD33HPP4datWwXZFyIiIiJSyeIwN3z4cGzevBk3b94syP4QERERkQoWnzPXq1cv7N69G61bt8Y//vEPNG/eHL6+vrle9ODv75+vThIRERFR7iwOczVq1DAuRfLOO+/kuZ2iKNBqtZb+GiIiIiJ6CovD3ODBg7n0CBEREZGVWRzmVq5cWYDdICIiIiJL5GvRYCp4tnjvTID3zyQiIrJV+Q5zmZmZ2LJlC06dOoWUlBR4e3ujSZMm6N69O1xdXQuij0RERESUh3yFud9//x0jR47EnTt3jPdkBR5d9FChQgV899136NmzZ747SURERES5szjM7dy5E7169YJGo8Hw4cPRrl07+Pr6IiEhAfv27cNPP/2E119/Hdu2bUPnzp0Lss9ERERE9P8sDnMzZ86Eu7s7Dh06hPr165s8NnjwYLzzzjto06YNZs6cyTBHREREVEgsvgPEqVOn0Ldv3xxBzqBhw4bo06cPTp48aXHniIiIiOjpLA5zJUuWRPny5Z+6TYUKFVCyZElLfwURERERPYPFYa5Lly7YsWPHU7fZsWMHunbtaumvICIiIqJnsDjMLVq0CLdv38bgwYNx/fp1k8euX7+OQYMGITExEYsWLcp3J4mIiIgodxZfADFo0CCUKVMGa9aswbp16+Dv72+8mjU2NhY6nQ4NGzbEm2++afI8RVGwc+fOfHeciIiIiPIR5vbs2WP8f61Wi6tXr+Lq1asm25w+fTrH83g/VyIiIqKCY3GY0+v1BdkPIiIiIrKAxefMEREREZH1FViYi42Nxb59+wpqd0RERERkhgILcytWrECnTp0KandEREREZAZ+zUpERERkx2w2zB07dgzdu3dH6dKl4eHhgZYtW+Lnn38267kigq1bt2LMmDFo2LAhvL29UbJkSTRq1Ahz5szBw4cPC7n3REREREXD4qtZC9Pu3bsREhICNzc39OvXD56entiwYQP69u2L69evY9KkSU99fmZmJrp37w5XV1d07NgRISEhePjwIbZt24bp06fjf//7H/bs2cNbjREREZHdK7Aw5+3tDX9//3zvR6vVYsSIEXBycsK+ffvQuHFjAMCMGTMQFBSEadOm4Y033kC1atXy3IdGo8Enn3yCt99+G2XKlDG2Z2dno1evXti0aROWLVuGyZMn57u/RERERNZUYF+zTpgwAdeuXcv3fnbt2oWoqCgMGDDAGOSAR2Fx2rRpyMrKwqpVq566DxcXF0yfPt0kyBnap06dCgDYu3dvvvtKREREZG02d86c4c4SwcHBOR4LCQkBkL8g5uLiAgBwdrbJb5iJiIiIVDE70RjWkAsKCoKbm5uqNeXat29v9raRkZEAgFq1auV4zM/PD6VKlTJuY4nly5cDyD0sPi4zMxOZmZnGn1NTUwE8+qo2OzsbAODk5ASNRgOdTmdyRwxDu1arhYgY2zUaDZycnPJsf7RfF4vHVph0Ol0+xvQXQ4jWarVmtbu4uECv10On0xnbFEWBs7Nznu15/T0K9u9kn2OyRYX7evqLPf2dOCaOiWPimAxjMofZYa5jx45QFAUXLlxA7dq1jT+b4/EBPUtKSgqAR1+r5sbLy8u4jVpbt27Ft99+i+effx5vvfXWU7edO3cuZs+enaN9+/btxgsn/P390aRJE5w5cwaxsbHGbQIDA1GnTh0cPXoUd+7cMbY3btwY1apVw759+5CWlmZsb9WqFSpUqIDt27cD6GHR2ApbZGSkxWN6fDJ26tQJ7u7u2LJli8n+u3fvjgcPHmD37t3GNmdnZ/To0QOJiYkIDw83tnt6eqJz5864fv06IiIijO3ly5dH69atERkZiUuXLhnbC+PvZK9jskWGuvHvxDFxTBwTx2Q6phMnTsAcijweV59i1qxZUBQF48ePR9myZY0/m2PmzJlmbQc8OmIWFhaGyMhI1KxZM8fjlStXRnp6uupAd+zYMbz44otwdnbG/v37Ua9evadun9uRuapVqyIxMRFeXl4ACudTwtvLbPPI3DfjeWSuOIxpxGLYnK/G8sgcx8QxcUwcU27tSUlJ8PHxQUpKijF75MbsI3OzZs166s8FxXBELq+wlpqamuPChmc5fvw4goOD4eTkhG3btj0zyAGAq6srXF1dc7S7uLgYz7sz0Gg00Gg0ObbN67y8vNqf3K8tMYyvoMakpt3JySnXrwjzas/r71HYfyd7GJMtKurXkz38nTgmjolj4pgA89/Lbe4kGsO5crmdFxcfH4/09PRcz6fLy/Hjx9G1a1fo9Xps27YNzZs3L7C+EhEREVmbxWEuLS0NV69ezXGYcv369Rg4cCDeeustnDx5UvV+O3ToAAD/f/6YqW3btpls8yyGIKfT6RAaGooWLVqo7g8RERGRLbM4zP3jH/9Ao0aNTMLc119/jQEDBuA///kPVqxYgXbt2uHixYuq9vviiy+iRo0aWLt2rcnJgykpKZgzZw5KlCiBwYMHG9tv3bqFixcv5vha9sSJE+jatSu0Wi22bt2KVq1aWTZQIiIiIhtm8Yk1e/fuRZcuXUxuiTVv3jxUrlwZa9euRXx8PAYPHoyFCxfixx9/NL9Dzs744YcfEBISgvbt25vczismJgaLFi1CQECAcfupU6di1apVWLFiBYYOHQoASEpKQteuXXHv3j1069YNYWFhCAsLM/k9pUuXxoQJEywdPhEREZFNsDjM3bp1C926dTP+fOHCBVy/fh0LFixA27ZtAQC//PKLqvXoDDp16oQDBw5g5syZWL9+PbKzs9GgQQPMnz8fffv2febzU1NTkZycDAAIDQ1FaGhojm2qVavGMEdERER2z+Iwl5mZiRIlShh/3rt3LxRFMVmMt0aNGvj9998t2n9QUBC2bt36zO1WrlyJlStXmrQFBATAzBVXiIiIiOyaxefMValSBWfOnDH+/Mcff6Bs2bJo2LChse3u3bsoVapU/npIRERERHmy+Mjc3/72Nyxbtgzvv/8+3NzcEBoaanJhAgBcvnwZ/v7++e4kEREREeXO4jA3depUbNq0CZ9//jkAoGLFivjoo4+Mj9++fRsHDx7EuHHj8t9LIiIiIsqVxWHOz88P58+fx86dOwEA7du3N7nVRGJiIhYuXIiQkJD895KIiIiIcpWve/64u7vjpZdeyvWxunXrom7duvnZPRERERE9g83dzouIiIiIzJevI3M6nQ4///wzduzYgbi4OGRmZubYRlEU41exRERERFSwLA5zGRkZCA4OxuHDhyEiUBTFZG03w8+KohRIR4mIiIgoJ4u/Zv3kk08QHh6O2bNnIzExESKCWbNm4datW1i/fj1q1KiB3r1753q0joiIiIgKhsVh7tdff0XLli3xwQcfoGzZssZ2X19f9O7dG7t378aOHTuwcOHCAukoEREREeVkcZiLjY1Fy5Yt/9qRk5PJUbgqVaqgR48eWLVqVf56SERERER5sjjMeXh4wMnpr6d7e3vj1q1bJtv4+fkhNjbW8t4RERER0VNZHOaqVatmEtTq16+PXbt2GY/OiQh27tyJihUr5r+XRERERJQri8Pciy++iN27d0Or1QIAhgwZgtjYWLRq1QqTJ09G27ZtERERgV69ehVYZ4mIiIjIlMVLk4wYMQI+Pj64c+cOKlasiOHDh+PUqVP46quvEBERAQDo1asXZs2aVUBdJSIiIqInWRzmatWqhSlTppi0ffnll5gxYwauXr2KatWqwc/PL98dJCIiIqK85esOELkpX748ypcvX9C7JSIiIqJc8N6sRERERHbM4iNzNWrUMGs7RVEQFRVl6a8hIiIioqew+MicXq+HiOT47969e4iOjkZ0dDQyMzOh1+sLsr9ERETkoJYtW4aAgAC4ubmhRYsWOHr0aJ7bnj9/Hr169UJAQAAURcHixYufuu958+ZBURRMmDDB2JaUlITx48cjMDAQ7u7u8Pf3xzvvvIOUlJQCGlHBsPjIXHR09FMfmzhxIhISEhAWFmbpryAiIiICAKxfvx4TJ07EN998gxYtWmDx4sUICQnBpUuXUKFChRzb379/33if+Pfee++p+z527Bi+/fZbNGzY0KQ9Li4OcXFxWLRoEerWrYuYmBiMHj0acXFx+OWXXwp0fPlRKOfMBQQEYP369UhOTsb06dML41cQERGRA/n8888xYsQIDBs2DHXr1sU333yDkiVLYvny5blu37x5cyxcuBD9+vWDq6trnvtNT0/HwIED8f3336NMmTImj9WvXx8bNmxAz5498dxzz6Fz58749NNPsWnTJuM6u7ag0C6AcHFxQdeuXfHzzz8X1q8gIiIiB5CVlYUTJ06gS5cuxjYnJyd06dIF4eHh+dr32LFj0aNHD5N9P01KSgq8vLzg7FzgC4JYrFB7cv/+fSQlJRXmryAiIqJiLjExETqdDr6+vibtvr6+uHjxosX7XbduHU6ePIljx46Z3Y+PP/4YI0eOtPh3FoZCC3P79+/Hf/7zHwQGBhbWryAiIiKyyPXr1/Huu+8iLCwMbm5uz9w+NTUVPXr0QN26dW3u7lYWh7nOnTvn2q7VanHz5k3jBRIzZsyw9FcQERERoVy5ctBoNEhISDBpT0hIsPhuUydOnMDt27fRtGlTY5tOp8O+ffuwdOlSZGZmQqPRAADS0tLQrVs3eHp6YuPGjXBxcbF8MIXA4jC3Z8+eXNsVRUGZMmUQHByMiRMnomvXrpb+CiIiIiKUKFECL7zwAnbu3IlXX30VwKMl0nbu3Ilx48ZZtM8XX3wRZ8+eNWkbNmwY6tSpgylTphiDXGpqKkJCQuDq6orff//drKN4Rc3iMMf144iIiKioTJw4EUOGDEGzZs0QFBSExYsXIyMjA8OGDQMADB48GJUrV8bcuXMBPLpo4s8//zT+/82bNxEREYFSpUqhZs2a8PT0RP369U1+h4eHB3x8fIztqampCA4Oxv379/HTTz8hNTUVqampAB7dvtQQ+Kwt3+fM3b59Gzdv3oRer0flypUtPtxJRERElJe+ffvizp07mDFjBuLj49G4cWOEhoYaL4qIjY2Fk9Nfi3TExcWhSZMmxp8XLVqERYsWoUOHDnl+u/ikkydP4siRIwCAmjVrmjx27do1BAQE5G9QBUQREVH7pMzMTCxZsgTff/89rl69avJYmTJlMGjQILz77rs2M8iCkJqaCm9vb+MlyYVlxOJC23W+fD/B2j2ggmCL84tzi4god+ZmD9XrzF2/fh3NmzfH1KlTERUVhYoVKyIoKAhBQUGoWLEikpKSsGTJEjRr1gw7duwwPu/WrVtcc46IiIiogKkKc9nZ2ejevTvOnTuH/v3748KFC7hx4wbCw8MRHh6OGzdu4MKFCxg4cCCSkpLw6quvIjo6GlFRUWjbtm2+1oIhIiIiopxUhblvv/0W58+fx8yZM/HTTz/luoZcYGAgVq9ejdmzZ+P+/fsYOHAg2rdvjxs3buCFF14osI4TEZHtKegboc+dOxfNmzeHp6cnKlSogFdffRWXLl3KsV14eDg6d+4MDw8PeHl5oX379njw4EFBDo3IZqkKcz///DNq1qxp1tpxH3zwAWrVqoXw8HA8fPgQ27ZtQ48ePSzuKBER2TbDjdBnzpyJkydPolGjRggJCcHt27dz3d5wI/R58+blefHc3r17MXbsWBw+fBhhYWHIzs5GcHAwMjIyjNuEh4ejW7duCA4OxtGjR3Hs2DGMGzfO5GR4ouJM1dWsf/75J/r16wdFUZ65raIoCA4OxpUrV3DkyJEcV4EQEVHx8viN0AHgm2++webNm7F8+XL885//zLF98+bN0bx5cwDI9XEACA0NNfl55cqVqFChAk6cOIH27dsDAN577z288847Jvvg3YfIkaj62JKeng5vb2+ztzfciJZBjoioeCvMG6E/LiUlBQBQtmxZAI+Wxzpy5AgqVKiA1q1bw9fXFx06dMCBAwcK7HcS2TpVYa5ChQq4cuWK2dtHRUWhQoUKqjtFRET25Wk3Qo+Pjy+Q36HX6zFhwgS0adPGuKirYXmsWbNmYcSIEQgNDUXTpk3x4osvIjIyskB+L5GtU/U1a6tWrbB161bEx8c/c3Hg+Ph4bN68GS+99FK+OkhERAQAY8eOxblz50yOuhnuRjRq1Cjj17tNmjTBzp07sXz5cuPdAMi+2eIamYDtrJOp6sjc6NGjkZ6ejtdeew2JiYl5bnf37l289tpruH//PkaNGpXvThIRkW0rjBuhP27cuHH4448/sHv3blSpUsXYXrFiRQBA3bp1TbZ//vnnERsbm+/fS2QPVIW5Tp06YcSIEThy5Aief/55fPDBB9i1axciIyMRGRmJXbt2Yfr06Xj++edx5MgRjBgxAh07diykrhMRka14/EboBoYbobdq1cri/YoIxo0bh40bN2LXrl2oXr26yeMBAQGoVKlSjuVKLl++jGrVqln8e4nsiep7s3711Vfw8vLCv/71L8ydOzfHIWwRgZOTE95//30e3iYiciAFfSN04NFXq2vXrsVvv/0GT09P4/l33t7ecHd3h6IomDx5MmbOnIlGjRqhcePGWLVqFS5evIhffvnFClUgKnqqw5xGo8HChQsxcuRIrFy5EuHh4cYXl5+fH1q3bo0hQ4agVq1aBd5ZIiKyXYVxI/Svv/4aAHJ8y7NixQoMHToUADBhwgQ8fPgQ7733HpKSktCoUSOEhYXhueeeK7zBEtkQRUTE2p2wB+be7Da/eJInFSZbnF+cW0T0LLb43gUU/vuXudmDy2MTERER2TGGOSIiIiI7xjBHREREZMcY5oiIiIjsGMMcERERkR1jmCMiIiKyYwxzRERERHZM9aLBRERET3LUdcCIbAGPzBERERHZMYY5IiIiIjvGMEdERERkxxjmiIiIiOwYwxwRERGRHWOYIyIiIrJjDHNEREREdoxhjoiIiMiOMcwRERER2TGGOSIiIiI7xjBHREREZMcY5oiIiIjsGMMcERERkR2z2TB37NgxdO/eHaVLl4aHhwdatmyJn3/+2eznR0VFYdasWXj55ZdRuXJlKIqCgICAwuswERERkRU4W7sDudm9ezdCQkLg5uaGfv36wdPTExs2bEDfvn1x/fp1TJo06Zn72L9/P2bPng2NRoPnn38e8fHxRdBzIiIioqJlc0fmtFotRowYAScnJ+zbtw/fffcdPvvsM5w+fRq1a9fGtGnTEBMT88z9tG/fHuHh4UhLS8PZs2fh4uJSBL0nIiIiKlo2F+Z27dqFqKgoDBgwAI0bNza2e3t7Y9q0acjKysKqVaueuZ8aNWqgZcuWcHd3L8TeEhEREVmXzYW5PXv2AACCg4NzPBYSEgIA2Lt3b1F2iYiIiMhm2dw5c5GRkQCAWrVq5XjMz88PpUqVMm5TmDIzM5GZmWn8OTU1FQCQnZ2N7OxsAICTkxM0Gg10Oh30er1xW0O7VquFiBjbNRoNnJyc8mx/tF/b/DpYp9PlY0x/cXZ+NOW0Wq1Z7S4uLtDr9dDpdMY2RVHg7OycZ3tef4+C/TvZ55hsUeG+nv5iT38nexyTrb53PV4z/p3seUy2Ob+K4u9kDpsLcykpKQAefa2aGy8vL+M2hWnu3LmYPXt2jvbt27ejZMmSAAB/f380adIEZ86cQWxsrHGbwMBA1KlTB0ePHsWdO3eM7Y0bN0a1atWwb98+pKWlGdtbtWqFChUqYPv27QB6FN6g8iEyMtLiMT0+GTt16gR3d3ds2bLFZP/du3fHgwcPsHv3bmObs7MzevTogcTERISHhxvbPT090blzZ1y/fh0RERHG9vLly6N169aIjIzEpUuXjO2F8Xey1zHZIkPd+Hey7zEBr8AWPV4b/p3seUy2Ob8K++904sQJs/qhyOMR3AYEBwcjLCwMkZGRqFmzZo7HK1eujPT0dNWBzs3NDX5+foiOjjZr+9yOzFWtWhWJiYnw8vICUDiffN5eZpufPr4ZzyNzxWFMIxbD5nw1lkfmisOYbPW9yzC/AP6d7HlMtjq/vn2ncP9OSUlJ8PHxQUpKijF75MbmjswZjsjlFdZSU1NRpkyZQu+Hq6srXF1dc7S7uLjkuDJWo9FAo9Hk2NYwqc1tt+Urbg3jK6gxqWl3cnLK9SvCvNrz+nsU9t/JHsZki4r69WQPfyd7HpOtya0G/DvZ95hsia28l9vcSTSGc+VyOy8uPj4e6enpuZ5PR0REROSIbC7MdejQAQD+//wxU9u2bTPZhoiIiMjR2VyYe/HFF1GjRg2sXbvW5OTBlJQUzJkzByVKlMDgwYON7bdu3cLFixeL5KIIIiIiIltjcyfWODs744cffkBISAjat29vcjuvmJgYLFq0yOQeq1OnTsWqVauwYsUKDB061NiemJiI999/3/hzdnY2EhMTTbZZtGgRypUrVwSjIiIiIiocNhfmgEeXPB84cAAzZ87E+vXrkZ2djQYNGmD+/Pno27evWftIT0/PcaeIjIwMk7ZZs2YxzBEREZFds8kwBwBBQUHYunXrM7dbuXIlVq5cmaM9ICAANrbqChEREVGBs7lz5oiIiIjIfAxzRERERHaMYY6IiIjIjjHMEREREdkxhjkiIiIiO8YwR0RERGTHGOaIiIiI7BjDHBEREZEdY5gjIiIismMMc0RERER2jGGOiIiIyI4xzBERERHZMYY5IiIiIjvGMEdERERkxxjmiIiIiOwYwxwRERGRHWOYIyIiIrJjDHNEREREdoxhjoiIiMiOMcwRERER2TGGOSIiIiI7xjBHREREZMcY5oiIiIjsGMMcERERkR1jmCMiIiKyYwxzRERERHaMYY6IiIjIjjHMEREREdkxhjkiIiIiO8YwR0RERGTHGOaIiIiI7BjDHBEREZEdY5gjIiIismMMc0RERDZk2bJlCAgIgJubG1q0aIGjR48+dfv//ve/qFOnDtzc3NCgQQNs2bLF5PFZs2ahTp068PDwQJkyZdClSxccOXKkMIdARYxhjoiIyEasX78eEydOxMyZM3Hy5Ek0atQIISEhuH37dq7bHzp0CP3798dbb72FU6dO4dVXX8Wrr76Kc+fOGbepXbs2li5dirNnz+LAgQMICAhAcHAw7ty5U1TDokLGMEdERGQjPv/8c4wYMQLDhg1D3bp18c0336BkyZJYvnx5rtsvWbIE3bp1w+TJk/H888/j448/RtOmTbF06VLjNgMGDECXLl1Qo0YN1KtXD59//jlSU1Nx5syZohoWFTKGOSIiIhuQlZWFEydOoEuXLsY2JycndOnSBeHh4bk+Jzw83GR7AAgJCclz+6ysLHz33Xfw9vZGo0aNCq7zZFUMc0RERDYgMTEROp0Ovr6+Ju2+vr6Ij4/P9Tnx8fFmbf/HH3+gVKlScHNzw7/+9S+EhYWhXLlyBTsAshqGOSIiomKuU6dOiIiIwKFDh9CtWzf06dMnz/PwyP4wzBEREdmAcuXKQaPRICEhwaQ9ISEBfn5+uT7Hz8/PrO09PDxQs2ZNtGzZEj/++COcnZ3x448/FuwAyGoY5oiIiGxAiRIl8MILL2Dnzp3GNr1ej507d6JVq1a5PqdVq1Ym2wNAWFhYnts/vt/MzMz8d5psAsMcFQsFuS5TdnY2pkyZggYNGsDDwwOVKlXC4MGDERcXZ7KPTz/9FK1bt0bJkiVRunTpwhgWETmYiRMn4vvvv8eqVatw4cIFjBkzBhkZGRg2bBgAYPDgwZg6dapx+3fffRehoaH47LPPcPHiRcyaNQvHjx/HuHHjAAAZGRmYNm0aDh8+jJiYGJw4cQLDhw/HzZs30bt3b6uMkQoewxzZvYJel+n+/fs4efIkPvzwQ5w8eRK//vorLl26hJdfftlkP1lZWejduzfGjBlT6GMkIsfQt29fLFq0CDNmzEDjxo0RERGB0NBQ40UOsbGxuHXrlnH71q1bY+3atfjuu+/QqFEj/PLLL/jf//6H+vXrAwA0Gg0uXryIXr16oXbt2ujZsyfu3r2L/fv3o169elYZIxU8RUTE2p2wB6mpqfD29kZKSgq8vLwK7feMWFxou86X7ydYuwd5a9GiBZo3b25cV0mv16Nq1aoYP348/vnPf+bYvm/fvsjIyMAff/xhbGvZsiUaN26Mb775JtffcezYMQQFBSEmJgb+/v4mj61cuRITJkzAvXv3Cm5QhcQW55ctzy0yny3OLYDzq7hw1PllbvbgkTmya0WxLhMApKSkQFEUfp1KREQ2h2GO7Fphrstk8PDhQ0yZMgX9+/cv1KOyRERElnC2dgeIbFl2djb69OkDEcHXX39t7e4QUTHhqF8bUuFgmCO7VpjrMhmCXExMDHbt2sWjckREZJP4NSvZtcJal8kQ5CIjI7Fjxw74+PgUzgDILhTk0jcA8OuvvyI4OBg+Pj5QFAUREREmjyclJWH8+PEIDAyEu7s7/P398c477yAlJaWgh0ZExQDDHNm9gl6XKTs7G2+88QaOHz+ONWvWQKfTIT4+HvHx8cjKyjLuJzY2FhEREYiNjYVOp0NERAQiIiKQnp5etAWgQlXQS98Aj9b+atu2LebPn5/rPuLi4hAXF4dFixbh3LlzWLlyJUJDQ/HWW28VyhiJyL7xa1aye3379sWdO3cwY8YMxMfHo3HjxjnWZXJy+utzi2Fdpg8++ADTpk1DrVq1TNZlunnzJn7//XcAQOPGjU1+1+7du9GxY0cAwIwZM7Bq1SrjY02aNMmxDdm/zz//HCNGjDB+OPjmm2+wefNmLF++PNelb5YsWYJu3bph8uTJAICPP/4YYWFhWLp0qXHpm0GDBgEAoqOjc/2d9evXx4YNG4w/P/fcc/j000/x5ptvQqvVwtmZb91E9Be+I1CxMG7cOOORtSft2bMnR1vv3r3zXP08ICAA5iy/uHLlSqxcuVJNN8nOGJa+efzIrjlL30ycONGkLSQkBP/73//y1RfDOlMMckT0JH7NSkSUh6JY+sbcfnz88ccYOXKkxfsgouKLYY6IyIalpqaiR48eqFu3LmbNmmXt7hCRDeLxerJrXKuJClNhLn1jjrS0NHTr1g2enp7YuHEjXFxcVO+DiIo/HpkjIspDYS19Y47U1FQEBwejRIkS+P333+Hm5qZ+AETkEHhkjojoKSZOnIghQ4agWbNmCAoKwuLFi3MsfVO5cmXMnTsXwKOlbzp06IDPPvsMPXr0wLp163D8+HF89913xn0mJSUhNjYWcXFxAIBLly4BeHRUz8/Pzxjk7t+/j59++gmpqalITU0FAJQvXx4ajaYoS0BENo5hjojoKQp66RsA+P33341hEAD69esHAJg5cyZmzZqFkydP4siRIwCAmjVrmvTn2rVrCAgIKKzhEpEdYpgjInqGglz6BgCGDh2KoUOH5vl4x44dzVoeh4gI4DlzRERERHaNYY6IiIjIjvFrViKiXHDZGyKyFzwyR0RERGTHGOaIiIiI7JjNhrljx46he/fuKF26NDw8PNCyZUv8/PPPqvaRmZmJjz76CLVq1YKbmxsqVaqEkSNH4vbt24XUayIiIqKiZZPnzO3evRshISFwc3NDv3794OnpiQ0bNqBv3764fv06Jk2a9Mx96PV6vPLKK9i2bRtatmyJXr16ITIyEj/88AN27tyJw4cPo3z58kUwGiIiIqLCY3NH5rRaLUaMGAEnJyfs27cP3333HT777DOcPn0atWvXxrRp0xATE/PM/axatQrbtm1D//79cejQIcybNw8bNmzAV199hatXr+KDDz4ogtEQERERFS6bC3O7du1CVFQUBgwYgMaNGxvbvb29MW3aNGRlZWHVqlXP3M/3338PAJg7dy4URTG2jxo1CjVq1MCaNWvw4MGDAu8/ERERUVGyuTBnWE09ODg4x2MhISEAgL179z51Hw8fPsSRI0cQGBiIatWqmTymKAq6du2KjIwMHD9+vGA6TURERGQlNnfOXGRkJACgVq1aOR7z8/NDqVKljNvkJSoqCnq9Ptd9PL7vyMhItGvXLtdtMjMzkZmZafw5JSUFwKMbZGdnZwMAnJycoNFooNPpoNfrjdsa2rVarckteTQaDZycnPJsz87ORtZDl6eOzVqSk3UWj+lxzs6PppxWqzWr3cXFBXq9HjqdztimKAqcnZ2h1+uR9dDmPo8AAO7ezbZ4TLm15zXH1M69rIcFPtR8u3u38F5Pj1M792z1tWioF1Dwr6f8zD17qFdBv57yM/dstV5JSdZ5L3/W3LPVet27V7jv5UlJSQDwzNv72VyYM4Qmb2/vXB/38vIybpOffTy+XW7mzp2L2bNn52ivXr36U393cfXvqdbugX1hvczHWqnDeqnDeqnDeqlTVPVKS0vLM9MANhjmbMXUqVMxceJE4896vR5JSUnw8fExOQfPVqWmpqJq1aq4fv26MbxS3lgvdVgv87FW6rBe6rBe6thbvUQEaWlpqFSp0lO3s7kwZ0ieeR01S01NRZkyZfK9j8e3y42rqytcXV1N2kqXLv3U32uLvLy87GLC2grWSx3Wy3yslTqslzqslzr2VK+nZRUDmzvh6PHz2Z4UHx+P9PT0PM+FM6hRowacnJzyPLfuaeflEREREdkTmwtzHTp0AABs3749x2Pbtm0z2SYv7u7uCAoKwqVLl3KsSSciCAsLg4eHB5o1a1ZAvSYiIiKyDpsLcy+++CJq1KiBtWvXIiIiwtiekpKCOXPmoESJEhg8eLCx/datW7h48WKOr1RHjhwJ4NG5b49fBfLtt9/i6tWrGDhwINzd3Qt3MFbk6uqKmTNn5viqmHLHeqnDepmPtVKH9VKH9VKnuNZLkWdd72oFed3OKyYmBosWLTK5ndfQoUOxatUqrFixAkOHDjW26/V6dO/e3Xg7rw4dOuDKlSv49ddfERAQgCNHjvB2XkRERGT3bO7IHAB06tQJBw4cQJs2bbB+/Xp8/fXX8PX1xbp168y6LyvwaI2W3377DbNmzcKdO3fwr3/9CwcPHsRbb72F8PBwBjkiIiIqFmzyyBwRERERmccmj8wRERERkXkY5oiIiIjsGMMcERERkR1jmKNc8VRKIiIi+8AwR7lSFAV37961djeomHj8w4Fer0d6ejpiY2Ot2CMqTji/yBr0er21u2DEq1nJKCMjAxs3bsR//vMf3L9/Hx4eHihXrhyCgoIQEhKC5557ztpdJDt2584drFq1CuvWrUNWVhZEBD4+Pmjfvj369OmD+vXrW7uLZMc4v6gwiAgURYFOp0NmZibi4+ORlZWFOnXqmGyn1+vh5GS942MMcwTg0X1v33//faxduxYuLi547rnnkJycjISEBACPbvTbo0cPDBo0CB06dICbm5txkjuizMxMPHjwAN7e3g5bAzVu3ryJ0aNHY/PmzShXrhzq16+PmJgYXLt2zbhNmzZt8Pbbb+Oll16Cp6enFXtrexz5tWYOzi/LcW49W3R0NL744gv873//Q2ZmJjIyMlC2bFl06dIF/fv3R6dOnazdRUCIROSf//ynuLm5yQcffCC3b9+Wq1evyq1bt+TQoUPy7rvvSvny5UVRFPHz85MFCxZYu7tWN2vWLOnevbv89NNPEhkZKQ8ePHjmc+7duyc6na4Iemd7Jk+eLCVLlpT58+fL/fv3JTU1VURELl26JHPnzpXGjRuLoiiiKIqMGTNG0tLSrNxj60pLS5MLFy6YNa+I80sNzi11YmNjpUOHDqIoitSrV0/69+8vTZo0ES8vL+OcqlGjhnzxxReSlJRktX4yzJGIiFSuXFkGDBggd+7cyXOb1atXS9OmTUVRFBk3bpxDvxmULl3a+EIOCAiQUaNGyR9//CE3btyQrKysHNunpKTI7Nmz5ZNPPrFCb62vatWqMmDAAElMTBQREb1en2ObHTt2SJcuXURRFOnTp4/cvXu3qLtpMz788ENp1qyZzJkzR3bt2iU3b94UrVb71OckJCRIdnZ2EfXQtnB+mY9zS52JEydKqVKl5KuvvjJpj46Olh9//FFeffVVcXFxEUVR5G9/+5tcvnzZKv1kmCO5cOGCeHp6yoQJE0RERKvVGt8MdTqdyQv91KlT0rZtW1EURXbu3GmV/lrb6dOnxcXFRVq3bi3vv/++NG3a1PhibtSokUyfPl32798viYmJkpmZKSIiu3btkhIlSsiAAQNERBzqCF1kZKT4+PjIiBEjRERM/lF4cn7dvn1bevfuLYqiyPr164u8r7bCx8dHFEURjUYjPj4+8vLLL8uXX34pR44cMQaWx927d0/eeecd+fvf/26F3loX55c6nFvqBAQESL9+/YzhP7cP68eOHZO+ffuKoijSpUsXiY2NLepuMsyRSFxcnFSvXl26detm1vYxMTGiKIpMnTo110/Axd26devEyclJvvzySxEROXfunKxYsUKGDh0qNWvWFEVRxM3NTTp16iT/+te/5M8//5SpU6eKoiiya9cuEZFnfhIuTtLS0qRevXoSFBRk1nxJTk6WUqVKyahRo4xh2JGcPXtW3NzcpEOHDrJs2TJ55ZVXpEKFCqIoilSrVk2GDBkiq1evlnPnzklycrKIiOzbt09Kliwp/fv3FxHH+rDA+WU+zi11rl27JpUrVzaO/fEPCnq9Psf7+KRJk0RRFOO/DUX57yPDHImIyNixY0VRFPnggw9Mvqp4fLIaJvKtW7ckMDBQunfvbpW+WtvSpUtFURTZtGmTSfuDBw/k2LFjsnjxYnnllVfE19dXFEURHx8f8fT0FD8/Pyv12Ppmz54tiqLIkCFD5MKFC7m+yRnm1507d6RRo0by4osvFnU3bcKGDRtEURTjuanR0dGybds2mTVrlrRv3148PT3F2dlZGjZsKO+9955s2bJF3n33XYf9sCDC+WUuzi11dDqdtGjRQmrVqmUMt7kx1CQzM1MqVaokffr0kfT09CLq5SMMcyQij44u1alTR1xdXaV///5y9OjRPLfdvXu3VKxYUSZPniwijvXiFhFJTU2Vr7/+Wi5cuCAij17wT/7jkZSUJNu3b5c5c+YYT77+5z//KSLikOee3LhxQ9q0aSOKosiLL74o//3vf/M8CX3Hjh1SsWJFmTRpkog43vz66aefRFEU+e2330zas7OzJTIyUn755Rd59913pVGjRlKiRAkpVaqUuLq6SsWKFa3UY+vj/DIP55Z6X331lXFe7du3T+7fv59jG8NXr3fv3pWgoCBp06ZNUXeTYY7+cvnyZXn99deNJ/a/8MIL8sUXX8ilS5fk5s2bcuXKFYmKipJ27dqJu7u7XLx4UUQc67D7s+RWi+HDh4uiKA5fr5SUFJk4caLx4pE6derI1KlTZdu2bXL06FE5ceKEHD58WJo2bSqenp5y6dIlEXG8emVkZMjatWslMjJSRHL/qiY9PV1Onjwp//nPf4wn9TvyhwURzi9zcG6pl5qaavx3sUGDBrJo0SI5f/68pKen55g7oaGh4ufnJxMnThSRov2gwDBHIvLXG9qNGzdkyZIl8sILLxhDnaIoEhgYKJUrVxZFUcTd3d14mN4Rz5kzZ8yGF/Hly5elXr16EhgYaPZziyNDPe7evSvr1q2TXr16Sbly5Yzzq3z58uLq6iqKooi3t7d8/fXXIuK49cpLbvUYNWqUKIpicqTY0XB+5R/n1tN9+eWXUqtWLVEURapWrSpDhgyRb7/9Vn799VfZtWuXbNy4UQIDA8XHx8d4RWtR1ouLBlOe9u3bhy1btuDPP//E/fv3kZqaisaNG+PNN99EmzZtoNFouODkM2zevBkDBw7EjBkzMHHiRGi1Wjg7O1u7Wzbh5MmT2L9/P6KiopCamoqEhAS0bt0aPXv2ROPGjQE45oKm5ozZsNp8ZGQkevbsCb1ej8uXLztkvfLC+ZUT55Z6hno8ePAAhw8fxubNm7Fr1y5cunQJDx8+BPDX7eR8fX3x2WefYcCAAUXeT4Y5eqbMzEykpaWhXLly0Ol00Gg01u6S3Xjw4AFCQ0MRHBwMDw8Ph31DfBqtVgsRgYuLi7W7Ynf27t2LkSNHYuzYsXjnnXf4YSEXnF+W4dzK2+XLl3H69Glcv34dSUlJuHHjBjp06IB27dqhZs2aVukTwxyZuHz5MlxdXVGtWjVkZ2ebvAEyiOT0eL0M9WGd8nbmzBm4ubmhdu3aJvNLr9dDURTWTaWsrCyEh4cjKCgI7u7uDj/3OL8KDufWs9lSTRjmyDgh7927h0mTJuHixYs4ePAggEcv6BIlSli5h7ZFTb1s6cVubcnJyRg9ejTCw8MRGxsLAHj48CHc3Nys3DPb9Xg4efzDAgDOqydwfqnDuaXOkSNHULJkSTRo0MB4lFJEoNPpbOKIpZO1O0C248KFC/j999/RqFEjAMD169cxadIkLFq0yMo9s03m1Itvin+dT3Lx4kXs27cPPXv2BPDo5tWDBg3C+++/b83u2azk5GR8+umn6NKlC4BHc+nhw4c8wvQEzi/1OLfUSU5OxuzZs43nWjo7O+P+/ftQFMUmghzAMEf4K3AcPnwYd+/exZgxYwAAp0+fxo8//micrHq93mp9tCWslzqP1yshIQGjR48GAJw/fx6bN29GhQoVAAA6nc5qfbQlDCfqcH6Zj3NLHUO9Ll26hLNnzxrf66OiotCtWzcMHjzYmt0zwTDn4AyT9datW9i2bRuee+45NGjQAFlZWTh8+DAePnyIIUOGAOBRJoD1Uutp9Tp06BAePnyIESNGAACcnPh2BDCcqMH5pQ7nljqGeoWHh+PmzZsYNWoUgEfh7vjx4wgMDATw6CIba+PsJgDAuXPncODAAQwdOhTAo08eoaGhaN++PcqUKQOdTsdw8hjWS53c6rVt2zbW6wkMJ5bh/Ho2zi11nlavgwcP4uHDh3j77bcBwCZWeOBfzMEpigKdTof9+/fj/v37xhfz6dOncfLkSeMnN3qE9VKH9bIMw4l5OL/U49xSx17qZRtn7pFVGK5gio6OxrZt29CyZUtUqFABqamp2Lt3L1xdXdGvXz8AtvHJw9pYL3VYL/WeFU7Wrl1r5R7aDs4vdTi31LG3ejHMOTDDp4lTp07h+PHjWL58OYBHa6eFhYXh1VdfBQAuFvn/WC91WC91GE7U4fwyH+eWOvZYL8ee4YQHDx5gz549cHZ2xqBBgwAAJ06cwNWrV7FixQoAPJH/cayXOqyX+RhO1OP8Mg/nljr2WC/b6AUVOcMnD8Pk7NmzJ5ycnJCQkICdO3eifPnyaNeuHQDb+eRhTayXOqyXZRhOzMP5pR7nljr2Vi9eAOGgDJPwzz//RGRkJP7+978D+Gv9IcPktYVLrm0B66WOoV6XLl1CZGQkhg8fDoD1yovhyjmGE/NwfpmPc0udx9eWCwsLw8svv2wX9WKYc2BarRZVqlTB+++/j27dugEADh06hNu3b2PkyJEAeIn641gvdXQ6HerXr4/Fixeje/fuAICDBw+yXrlgOFGP88s8nFvqGOp19epVREZGGq9ivXjxIvbv32+z9eLXrA7IcL9CZ2dntGvXDs2bNwcApKWlQVEU9OjRw3i/Pr4Zsl7mMnz1lZGRAQ8PD2g0GtStWxe1a9cG8OhrC19fX/Tv35/1ygXDydNxflmOc8t8IgIRQZs2bbBhwwb06NEDALB//34kJCTYbL0UMRxTpGLN8EaYkpKC6dOno0uXLsaTOB+XkJCAzMxM+Pv7Q6/X29yELSqslzqGeiUnJ+PNN9/E3/72N4wbNy7HdmlpacjKyoKPj49D1wvIGU4MDCdVP3jwAGvXrsWuXbuwZs0a4/aOiPNLHc4tdR5/v/f29s7xeHZ2NrZu3YqtW7fi66+/ts16CTmE7OxsERGZP3++KIoiTZs2lcuXLz/1OTqdrii6ZpNYL3WerFeNGjXk+PHjT32OI9dLr9eLiEhSUpJ0795dvvzyy1y3S01NlcTERBFx7HpxfpmPc0sdQ73u3r0rdevWlSlTpuS6nVarlQcPHpg8x5YwzDkIw+SrU6eO+Pj4iKIo8t5774mIY7+Q88J6qWOoV2BgoAQEBIiiKDJw4EAr98p2MZyow/llPs4tdQz1WrBggSiKIuXKlZPt27eLSN6hTavVFln/zMUw5wAML9QzZ86Ioigyb9486d+/vyiKIufOnTNuZ5i4V65ckVWrVsn169et0l9rY73UebJeCxculAkTJoiiKLJr1y7jdoZ6nT9/Xj799FO5ePGiVfprCxhOzMf5pQ7nljqGetWqVUsaNGggiqJISEiIZGZm5rmtLWKYcwCGTx5vv/22VKhQQY4dOyYRERGiKIq88sorxscN5s+fL6VKlZLo6GhrdNfqWC91Hq+Xr6+vHD16VK5fvy7u7u7Stm1bSU5ONtl+wYIF4uLiIlFRUVborfUxnKjD+WU+zi11nqzXZ599JnPmzBFFUeTf//63cTtDvU6ePCljxoyREydOWKW/T8Mw50B8fHxk4MCBcu/ePRERGTNmjCiKIr/++qtxm7i4OAkODpYaNWqIiG1/EilsrJc6hnoZ/nGdMWOGKIoiX3/9tXGbuLg46dq1q9SsWVNEHLNeDCeW4fx6Ns4tdR6vl5+fnxw5ckRSU1OlYsWKUrdu3Rwf0BctWiSKosilS5es0d2nYpgr5gzf7W/fvl0URZEVK1YYH7tz5454enpK+/btjS/yLVu2SMmSJWXhwoUiIjmOQhV3rJc6hnpt27ZNFEWR5cuXGx97+PChVK9eXWrXri23bt0SEZHNmzc7dL0ex3DybJxfluHcUqdcuXIycOBASUpKEhGRpUuXiqIoMmPGDOM2hnrVrl1bRGyvXgxzxZxhwr366qtSvXp1OXv2rIiIZGVliYjIwoULRVEU+fzzz0VEZPr06aIoivEqJ1ubsIWN9VLHMN633npLGjRoYKyX4XyTlStXmlw88sEHHzh0vRhO1OH8Mh/nljqGr1hDQ0Nz1EtEpE2bNlK6dGnjKga2Xi+GOQcRFhYma9askYcPH5q03759W+rVqyeBgYGyadMmCQoKknbt2omIbV6xU1RYL3XCw8Pljz/+yHHScFpamnTu3FnKly8vq1evlmbNmjl0vRhOLMP59WycW5aZPHmytGzZMke9/vjjD3FxcZF+/fqJiMiHH35o0/VimCP58ccfRVEUadeunbi4uMhPP/0kIo73Zmgu1kudrVu3iqIo0qhRI9FoNKyXMJwUJM4vU5xb6pw7d04OHDhg/PbFICsrS/r37y8uLi7yxRdfyAsvvGDT9WKYcxBPW0dIp9PJa6+9JoqiSIkSJYqwV7aL9VLnWZ9Sx48fL4qiiIuLSxH1yH4xnOTE+VUwOLfUOXv2rLi5uRmXeFm7dq2I2Ga9eDsvB2e45U1ERATGjx+P+vXr4+uvvzbe9oVMsV7qyP/f9iY6Ohrjxo1D1apVWS/gmbcDeuedd7B06VI4OzsjKyurCHtmXzi/cuLcUudZ9VqwYAH++c9/wtXVFQ8ePCjCnqnDMEcmMjMz4erq6tD3NVSD9bIM65U7hpOCwfmVE+eWZRISEvDBBx/A19cXn3zyic3Wi2GOiAqdTqcDAGg0Giv3xD4xnDwd55flOLfUedaRPGthmCvGbHXS2SrWi2wFw8lfr0e+LgsW55Y6er0eAGw+8DLMORi+MarDehHZDr4ec8fgSwxzxVBWVhbCw8Ph6+uLUqVKwcnJCT4+PnB1dbV212wS62U+/mNBhUlEcPfuXezduxcVKlSAs7MzSpUqherVq6NUqVLW7p5d4WvVsTDMFSN3797FDz/8gGXLluHWrVvQ6XTw9fVFvXr10LJlS7Rp0wZNmzaFr68v5NGyNDZ/6LgwsV6W0ev1EBF+TWMG/oNqvlu3buGLL77AF198Ybxq0NPTE1WqVEGTJk3QoUMHdOjQAbVq1YKiKA5/rheDrzrF/bXIMFeMDBkyBGvWrEFQUBAaNmyI9PR0pKam4s8//8S1a9dQtmxZdOvWDRMmTMALL7xg7e5aHeulzqZNm9C+fXt4e3sb23Q6HRRFceh/VJ+F4dc8vXv3xsaNG/HKK6+gQYMG0Gq1uHfvHo4ePYqIiAgAQNu2bTFu3Di8/vrr1u2slTH4WqZYny9YKKvXUZGLiIgQjUYjo0ePlvT0dGN7fHy8HD9+XL777jt5+eWXpWTJklKiRAn56KOPJCMjw4o9ti7WS53Tp0+LoihSpUoVGTlypOzYsSPHNlqtVvR6vXHB5aSkJOOtbxzR77//Lvfu3TNp02q1T12Q2lFFRESIk5OTTJw40aQ+6enpcvPmTdm+fbu8/fbbUrFiRVEURd5++23jTeQd0RtvvCEajUZef/11mTlzpkyfPl3Gjh0rzZs3FxcXF3FxcZFOnTrJhg0brN1Vm/DTTz/J3bt3Tdq0Wq1NLv5rKYa5YmLq1KlSvnx52b9/v4hIjnuK6vV6iYmJka+//lr8/PykRIkSDv1CZ73UmTp1qiiKIu7u7qIoiiiKInXr1pUPPvhATp8+bbKt4Q3y448/Fk9PTzl+/Lg1umxVDL/qfPjhh1K2bFnZt2+fiEiOW1GJiNy7d082bdokLVq0EEVRZNmyZUXdTZvA4KvOqVOnjO9Z3bp1k19++SXHNtnZ2aLT6Yz1jI+Pl4iICElNTS3q7lqMYa6YGD16tPj4+MjNmzdF5Om3G7lw4YLUqlVLqlWrVqw+majBeqnz8ssvS9myZSUiIkJWr14tbdq0Mb5BKooibdu2lS+++EJiYmJMnqMoihV7bT0Mv+pMmTJF3N3d5erVqyLy9NvpXb9+XVq2bClly5aVtLS0ouqizWDwVWfGjBmiKIpUrlzZ+Fr08PCQYcOGycGDB022NbwWP/nkE3Fzc5NDhw5Zo8sWYZgrJlatWiWKosj8+fONbY9/6jf8bLiZ8Pvvvy/e3t52NVkLEutlvri4OHnhhRfEz8/PpD06Olo+/vhjCQwMNHmT7NOnj3z44YdSqlQpefPNN0XENu9lWJgYftX57bffRFEUGT9+vDGcPH6kxCA7O1tERObNmyfu7u6yc+fOIu+rtTH4qvPGG2+Ip6ennD59WrZu3SoDBw6UcuXKGV+LVapUkWnTpsnly5eNz3n55ZdFo9FYsdfqMcwVExcvXpQ6deqIh4eHfPnllzkODz/5xrhgwQJxc3OTiIgIEXn2jayLG9bLfAkJCTJgwAAZNmyYaLVaycrKyvEPyLFjx+Ttt982eZNUFMX4ydeRwhzDr3rXr183Bt4PP/wwx9eCT55ruHjxYnFxcZGTJ0+KiGO9Hhl8zZeQkCAtWrSQcuXKmbTfunVLvvvuO+nWrZuUKFHC+Hps3ry5vPvuu+Lh4SEDBw4Ukb/qaOsY5oqRHTt2SNWqVUVRFGndurUsWbJEzp49m+NFnpiYKMHBwVK1alUr9dQ2sF7m0ev1cunSJbl06ZLJP5o6nS7XN7qVK1eKh4eHw9aL4dcyFy9elLZt24qiKFKxYkWZMmWKHDp0KEct4uPjpWPHjuLv72+lnloXg6/57t27J+PGjZOhQ4fKw4cPJTs7O8f4//zzT/n000+lefPmdv1aZJgrJgwT9PDhw/LSSy8ZJ2RgYKD069dP5syZI2FhYfLdd99J27Ztxc3NTRYuXCgi9vPJoyCxXgVLp9MZLyLZsWOHuLm5yeTJk0XE8erF8KueoU7nzp2Tv//978bXY8mSJaVly5Yyfvx4+fe//y3Tpk2T+vXrS8mSJWXJkiUi4njzS4TBV43k5GS5deuWyWtRr9fnGtI2bNggPj4+dvlaZJgrpvbu3Svjx4+XWrVqmXzaMHy1M2/ePElJSRERx/qklhfWq+C8+eaboiiKREZGisjTz+lxVAy/T3f9+nWZM2eONG7cOMfr0d/fX7799lvjkkKO9npk8C1YOp3O+HX19u3b7fa1yEWDixmdTmdcEDEzMxNJSUm4ceMGDh48iOTkZNStWxfVq1dHUFCQlXtqG1ivgvXgwQPMnz8fe/bswZ49e4r9qusFYdCgQVizZg0uX76MmjVrOvQCrzqdDk5OTiZzJiYmBvv374dWq0VAQAD8/PxQp04dK/bStty4cQOrV6/Gzz//jNOnT5s8VrVqVUyfPh0DBw6Eh4cHX4/PMHDgQPznP/+xy9ciw1wx9HhAyQtf1H9hvdQx5w3u4cOHcHNzs6s3Q2tg+DUlItBqtXBxcTH+7Mj1eBoG34Kl1Wrx5ZdfYvPmzdixY4fdvXcxzBUThje9mJgY7NmzBy1atMj1Rcw3x0dYL3WerFfLli0RGBho7W7ZBYbfZzPMr6ioKKxfvx4dO3ZE69atrd0tm8bgq86T9Xq8Pbe62dtr0X56Sk9lmIybN2/GsGHDcO/ePQBAfHw8zp49i4cPH5ps5+hYL3WerFdycjKAnPWiRwyfkWNiYrB69WpcunTpqdu7ubkBgF3941GQDPMrLCwMH3zwgbF+0dHR2LFjB1JTU63ZPZtiqM3Vq1excOFCHDp0CADfq/KSV70MDHUzhD0De3st2ldvKVeGyZqcnIz9+/fDx8cHLVu2BAD89NNPGDx4MDIyMqzZRZvCeqnDeqnH8Gu+x+fX3r17Ua5cObRp0wYA8N///hcjR4403kyeGHzVMrdeiqLA2dnZav3ML4a5YuTPP//Ezp07MXDgQADAtWvXsGnTJqSkpMDHxwf8Rt0U66UO62Uehl/LGObXgAEDADyaX5s3b4ZGo4Gvry/nFxh81XKkejHMFQOGTx6HDx9GYmIiRo0aBQA4e/Ysjh07hvfeew/AoxNmifVSi/WyDMOveZ42v44cOYJ33nkHAOfX4xh81XGEejHM2TnDJIyLi0NoaChq166N559/HpmZmQgPD8fDhw8xZMgQAHjmFZuOgPVSh/VSj+HXfM+aX5mZmZxfj2HwVceR6sUwV0ycOXMGBw8exPDhwwEAV65cQWhoKDp16gQvLy/odDqeIPsY1ksd1ss8DL+W4fx6NgZfdRytXgxzdk5RFGi1Whw4cAAPHz7EW2+9BQCIiIjA6dOn8fbbb1u5h7aF9VKH9bIMw4l5OL/U49xSx1HqZb+XbpBxfZxr164hNDQU7dq1g4+PD+7du4e9e/fC3d0dvXr1AlA8PnnkF+ulDuul3rPCyX//+18r99B2cH6pw7mljqPVi2HOjhk+TZw6dQonT57E6tWrAQCXL19GWFgYXnvtNQCPVra250uuCwrrpQ7rpQ7DiTqPz69Tp07h3//+NwDOr9xwbqnjiPVy7FdIMXD//n3s2bMHbm5uxqvmTp48iZiYGKxZswaA/S1+WJhYL3VYL/Mx/Kp3//597N69GxqNhvPrKRh81XHEehWPUTiwuLg47NmzB926dQPwaFHSHTt2oGLFisbb4fDN8C+slzqslzoMv+okJibi8uXL6NevHwDg1q1b2L59O/z8/Di/nsDgq46j1Ythzo7p9XrUrFkTa9asgbe3NwDgwoUL2LZtG8aOHQugeH3yyC/WSx3WSz2GX/Pp9Xr4+/tj2bJlKFWqFIBH638dPnwYgwcPBsD59TgGX3UcrV58ldgRnU4HjUaDmzdvwsfHx3g/xyZNmhi3qV69Ol5//XWMGTMGQPGarGqxXuqwXvnD8Pt0hvl18eJFlCxZEv7+/gCAOnXqGLcJCAjA0KFDMW7cOACcXwYMvuo4Yr0UKQ5LHzsIvV4PJycntG/fHuXLl8fSpUtRsWJFZGdnw8XFxdrdszmslzqslzp5hd/HRUdHY+bMmfjoo49QrVo1Y40dkeGk9I4dO0Kr1WLlypWoWbNmsftHtSDkFXwfFxcXh6VLl2LcuHGoVKmSQ88t1guAkF158OCBBAcHi6IoMmjQILl//77J41qt1ko9s02slzqsl/l0Op2IiLRr105ef/11iYuLExGRrKwsa3bLpmVlZcmoUaNEURTp0KGDREVFmTxuqKmj0+v1IiLSoUMHadOmjURGRoqISHZ2tjW7ZbNYLxGGOTuUlJQkY8eOFUVRpFmzZnLo0CERefRGaJjU9BfWSx3Wy3wMv+plZGTIRx99JK6urlKzZk3ZtGmTaLVazq8nMPiq4+j1YpizU3fv3jX+g9uqVSs5f/68tbtk01gvdVgv8zH8qqfT6eSzzz4TRVGkatWqsnPnTmt3ySYx+KrjyPVimLNz3333nXh5eUm5cuVkzZo1xvbiPnEtxXqpw3qZh+HXfI/PnT/++ENq1KghGo1GFi5cKBkZGSJS/I+iqMHgq46j1othzg5ptVrjuQDp6enyxRdfSIkSJaRixYqyYcMG43b8B/cR1ksd1styDL/PZjhSYvDrr7+Kn5+fuLq6yrJly6zYM9vD4KuOI9eLYa6YOH36tDRv3lxcXFxkzpw5DnXipyVYL3VYr7wx/Kr35PyJj4+Xrl27iqIo8tZbb0lCQoKVemZbGHzVceR6cWkSG/f4JdeHDx/GzZs3odVqUapUKdy4cQMA4OzsjJiYGJw4cQLXrl1D6dKlMW7cOEyZMgUeHh7F7xLsp2C91GG9CseZM2fw97//HREREZg9ezYmT57skMtvGObX2bNn8csvvyA+Ph7Ozs5wcnLCzZs34e7ujqysLCQkJCA2NhaxsbEoWbIk3nzzTXz66afw8fExLmniqJ5cuiUhIQGDBg3Cjh07MHz4cMyZMwcVKlSwYg9ti6PWi2HOxhneyHr06IGtW7ca2zUaDXQ6HUqUKAFXV1dkZWXhueeeQ2JiIgDg9u3bGDlyJL755htrdd0qWC91WC91GH7VMcyvAQMGYN26dQCAEiVKwN3dHffv30eFChWMNa1evTri4uJQtmxZHD9+HMHBwVi7di3Kli1r5VEUDQZfdVgvUwxzdmL16tXw8PBAlSpVEB8fjxo1akCv1yMjIwM1a9ZEcnIyNBoNqlSpgqtXr2LmzJn45ZdfMHbsWCxevBgajcbaQyhSrJc6rJd5GH4ts3XrVvj6+qJUqVK4e/cu6tSpg+TkZCiKgipVquD27dvw9PSEl5cXoqOj8fnnn2Pp0qXo378/fvjhB7i7u1t7CIWOwVcd1ssUw1wxlZ6eju7du+Py5cvYv38/atWqZe0u2TTWSx1HrxfDb8F78ihJnz59EBoaij179qBp06ZW7FnRYvBVh/X6f0V8jh5ZQK/XG0/qfPwk6rxOqDZs+9FHH4mzs7PDLZPAeqnDehW+tLQ0adeunfj6+srly5et3Z0iZ5hL5lwEYphfCxYsEEVR5MyZM4XaN3v0ZB179+4tnp6ecuLECSv1yLY5Qr0c48QNO6coivEcm8c/ueb1Xb+TkxPu3buHo0ePQlEU1K1bt0j6aStYL3VYL3VEBHq93vj/j7fnRq/Xo1SpUujatSvu3r2L7OzsIumnLTHMJXPOT3JyckJqair+/PNPlCtXDg0aNCjs7tkUwzzKaz4Bf9XRMA+bN2+O9PR0h7yHMuv1CL9mLcb+/PNPXL16FS+99JK1u2IXWC91WC/z3bt3D4MGDcK2bduQlZVl7e7YhaioKMTGxqJTp07W7opNS01NxbvvvovNmzfj9u3b1u6OzSuu9WKYIyIqAgy/VFgYfNUpjvVimLNR8v8nA8ujhZ0tWsrAEZdAYL3Mw3qRrZNitGwEUWFjmLMjOp3O5PwmejrWSx3WK28Mv2TLGHzVKY71YpizMdnZ2dizZw9iYmKQnJwMFxcXNG/eHG3atDHZjv8wPMJ6qcN6FRyGXyKyFQxzNuT8+fNYsGABVq9eneOxKlWqoE+fPhg2bBjq1atnhd7ZHtZLHdZLPYZf82VmZsLV1dWkzZwjIKwdUf4xzNmQkJAQ7N69G6NHj0ZQUBCqVKmCkydPYvPmzTh48CCysrLg6uqKUaNGYdy4cahZs6a1u2xVrJc6rJc6DL/qzJ8/HzVq1EDTpk1RuXJluLm5WbtLNovBVx3WywyFuIYdqXDixAlRFEVmzpyZ6+NXr16VTz75RCpVqiSKokifPn3kzp07ImLeQpzFDeulDuulXnBwsLi4uMj48eNl9erVsnv3bvnss8+kc+fO4urqKoqiiJubm7z77rsSGRlp7e5alWF+lS5dWlq1aiUzZsyQHTt2yI0bNyQ7O9tkW61WKyIily9flq+++kouXrxojS5b1bx58+Tnn3+WK1euyIMHD6zdHZvHej0bw5yNmDVrlpQtW1b27t0rIn+94WVnZ5v8Y5qWlibvv/++KIoiI0aMMG7naFgvdVgvdRh+1Zk5c6YoiiIdOnSQwMBAcXJykrJly0r37t1l8eLFEh4ebqyPwYIFC8TV1VV27txppV5bB4OvOqyXeRjmbMTixYtFURQ5duxYro/rdDrjRL1z54706NFDypQp47BHBFgvdVgvdRh+1Rk4cKA4OTnJyZMn5fTp07JkyRJ57bXXxM/PTxRFkapVq8qbb74pK1askEuXLsm1a9ckJCREXF1drd31Isfgqw7rZR6GORsRHh4uiqLI66+/LleuXMlzO8M/JCtWrBBnZ2fZuHFjEfXQtrBe6rBe6jD8mu/OnTvStWtXqVq1qkl7XFychIWFyccffyydOnUSLy8v0Wg00qBBA3n99ddFURQZNmyYiEiOIyzFGYOvOqyXeRjmbIRWq5Vhw4aJoijy2muvyYEDB4w3nH6c4R/bL7/8UpycnIw3Cna0r3ZYL3VYL3UYfs2Xnp4u//jHP2TIkCGSlpaW4/Hs7Gy5cuWKbNiwQd577z1p2rSp8ZzDI0eOiIjkOheLIwZfdVgv8zHM2ZDU1FQZPXq0uLm5SenSpWXw4MESGhoqiYmJkp6eLpmZmSIicvr0aQkKCpKaNWtaucfWxXqpw3qZj+FXvczMTJNx51WD7du3i7+/v1SrVq2IemY7GHzVYb3Mx6VJbExiYiLWrl2LVatW4dSpUwCAgIAABAUFwdvbG3fv3sWePXug0+nw2WefYfjw4dBqtXB2drZyz62D9VKH9TJfWloa/vGPf2DlypVwc3PDyy+/jAEDBqBZs2Zwc3ODi4sLSpQogTNnzmDEiBFISkpCZGSktbtd5MSMu2KICPR6PTQaDTZu3IhevXph2rRp+OSTTxxyfmVlZcHFxcW4tIbkscxGWFgY/v73v0NRFERHRxdxL20H62UGKwZJeoro6Gj5/vvvpU+fPlK3bl3x9fUVFxcXURRFWrVqJWFhYcbDx454FOBJrJc6rJd57ty5I0uWLJGmTZuKoiiiKIpUr15d+vbtKyNHjpRevXqJj4+PlC5dWn788UcRcZyvdSyh1+tl0qRJoiiK8etrRzlyIvJo/M8ar16vN56P+euvv4qiKDJ9+nQRcby5xXqZj0fmbExuixxeuXIFd+/ehbe3N3Q6HWrWrJljAUVHxXqpw3pZJiYmBmFhYQgLC8O5c+dw9+5dJCUlQavVomXLlvjoo4/QsWNHODs7F8v7Pqql0+mg0WhytGdlZeGXX37B2bNnMXfuXNbqKUQEkydPxueff47IyEg899xzjrUIrkqOXi+GORvz+ORzpIloKdZLHdZLHYZfdfKaU0+GNkPYY5hj8FWL9codw5yNMEy8iIgITJ8+HcOHD0evXr2s3S2bxXqpw3pZhuHXPObOL8M/N470j2xeGHzVYb2eju9MNsIw6Y4ePYqtW7eiXLlyAIBTp05hxYoVyMjIAHP3X1gvdVgvdQy1OHPmDHr06IENGzYwyD2FufNLURSH+gc2N7nNrcc9fpK/iBiPQjlq3Vgv8/DdyQYYJuvdu3cRFhYGPz8/dOjQASKCzZs346233kJSUpLDTc68sF7qsF7qMfyaj/NLHQZfdVgv8zDM2ZA///wTu3fvRv/+/QEAV69exY4dO9C4cWNUrVoVer3eyj20LayXOqyXeRhOLMP59WycW+qwXuZjmLMBhokYHh6OpKQkjB49GgBw7tw5hIeH4+9//zsA8M3w/7Fe6rBelmE4MQ/nl3qcW+qwXs/GMGdlhk8eN27cwLZt21C3bl3UqlULDx48wIEDB5CdnY0hQ4YAgMMtrJkb1ksd1ks9hhPzcX6pw7mlDutlPoY5G3HmzBkcPHgQb731FoBHyx9s27YNwcHB8PDwgE6ns3IPbQvrpQ7rZR6GE8twfj0b55Y6rJc6DHNWpigKsrOzsX//fmRlZWH48OEAgIiICJw7dw5jxoyxcg9tC+ulDutlGYYT83B+qce5pQ7rZR6GOSsyfPK4du0aQkND0bFjR3h7eyM5ORl79uyBh4cHXnnlFQDIdZFER8N6qcN6qcdwYj7OL3U4t9RhvdThsUkrMpwPcOrUKZw5cwZr164FAFy6dAk7duzAG2+8AQAOeSPq3LBe6rBe6hiWN2A4MQ/nl/k4t9RhvdRz7FeYDcjIyMDmzZshIujbty8A4OTJk7h+/TrefvttAOBipY9hvdRhvczHcKIe55d5OLfUYb3U46vMyh4+fIhy5crhnXfeAQDcvHkTW7ZsQZUqVdC8eXMAfDN8HOulDuulDsOJOpxf5uPcUof1UoeR1sp8fHzw/vvvo1SpUgCAxMREXLp0Cf369QPATx5PYr3UYb3UYThRh/PLfJxb6rBe6ijCe9IUGcONgmNjY+Ht7Q1vb+8c29y7dw/79+9H+/bt4e3t7XA3C34c66UO61Uw4uLiUKpUKXh5eeH06dN444038Nprr2HBggUOHU44v/KPc0sd1st8DHNFyPBm2LVrV3Tv3h3vvfceJ+RTsF7qsF7qMJyow/llPs4tdViv/GOYK2Kpqal47rnnULp0aRw8eBAVKlQwmZSG/9fpdLxKB6yXWqyX+RhO1OP8Mg/nljqsV/7xC+cipNfr4eXlhSVLliAqKgrjx48H8NeVO3q93vj/Go0Gd+/etVpfbQHrpQ7rpY6TkxNSU1MRERGBr776Crdv34azszMe/3xr+H8uTMr5pQbnljqsVwEQKnIZGRny5ptviqIosmzZMpPHEhISJDw8XMaOHSuDBw+2Ug9tC+ulDutlHp1OJyIia9asEUVRpE+fPrk+bpCYmFhkfbNlnF/PxrmlDuuVfwxzRUyv14uISHJyslStWlUaNmwox48fly+//FLefPNN8fPzE0VRRFEU+fTTT0VERKvVWrPLVsV6qcN6qcdwYj7OL3U4t9RhvSzHc+as4MaNG7hy5Qo+/fRT7Ny5E8CjryVKliyJwMBAvPnmmwgMDET79u3h7u7u8Cd6sl7qsF7mM4z93r17aNiwIcqUKYPly5cjPDwcR44cwY4dO5CQkAAA+OSTTzBt2jSHPx+M88s8nFvqsF75ZLUY6YD+/e9/y8svvyxly5YVRVHE3d1dqlevLoqiyPjx4yUmJsbaXbQprJc6rJdlrl+/Lrt375YuXboYjyo5OzuLl5eXNG/eXJYsWSKhoaFy//59Efnr6JSj4fxSj3NLHdbLcrxUpJDJ/3/a2LRpE4YMGQJXV1d07doVQUFB6NKlC5KTkzFo0CAcP37ceIKnI1/Fw3qpw3pZbvXq1fjll19w4MABJCcnw83NDQEBAYiOjsaYMWPw/vvvw9/fP8fzHOkoE+eXZTi31GG9CoD1cqRj+c9//iPfffed3LhxI8djP/74oyiKIv/4xz9EhJ82RFgvtVgv8xjG/vvvv4uiKOLm5iY9e/aUjz/+WMLDw2XLli3i4+MjrVq1kujoaBERyc7OtmaXbQLn17NxbqnDehUshjkrMFyZo9PpRKfTiV6vlzfeeEMURZH169dbuXe2h/VSh/V6NoYTy3F+PR3nljqsV8FgmLMRR44ckYCAAKlcubLEx8dbuzs2j/VSh/XKG8NJ/nF+5Y5zSx3Wy3K8mtWGfPPNN3j77beh1+ut3RW7wHqpw3qZ7+jRo+jbty+ys7Nx4sQJ+Pr6WrtLNo/zyzycW+qwXuZhmLMhaWlpOHXqFNq3b89Lrs3AeqnDeqnDcKIO55f5OLfUYb2ejWGOiCgXDCdUWDi31GG9no1hjoiIiMiOOVm7A0RERERkOYY5IiIiIjvGMEdERERkxxjmiIiIiOwYwxwRERGRHWOYIyIiIrJjDHNEREREdoxhjoiIiMiOMcwRERER2bH/AyWmAB//hRiqAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(samples_for_plot)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RecursiveMinimumEigenOptimizer"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `RecursiveMinimumEigenOptimizer` takes a `MinimumEigenOptimizer` as input and applies the recursive optimization scheme to reduce the size of the problem one variable at a time.\n",
    "Once the size of the generated intermediate problem is below a given threshold (`min_num_vars`), the `RecursiveMinimumEigenOptimizer` uses another solver (`min_num_vars_optimizer`), e.g., an exact classical solver such as CPLEX or the `MinimumEigenOptimizer` based on the `NumPyMinimumEigensolver`.\n",
    "\n",
    "In the following, we show how to use the `RecursiveMinimumEigenOptimizer` using the two `MinimumEigenOptimizer`s introduced before."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we construct the `RecursiveMinimumEigenOptimizer` such that it reduces the problem size from 3 variables to 1 variable and then uses the exact solver for the last variable. Then we call `solve` to optimize the considered problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "rqaoa = RecursiveMinimumEigenOptimizer(qaoa, min_num_vars=1, min_num_vars_optimizer=exact)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "objective function value: -2.0\n",
      "variable values: x=0.0, y=1.0, z=0.0\n",
      "status: SUCCESS\n"
     ]
    }
   ],
   "source": [
    "rqaoa_result = rqaoa.solve(qubo)\n",
    "print(rqaoa_result.prettyprint())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_samples = get_filtered_samples(\n",
    "    rqaoa_result.samples, threshold=0.005, allowed_status=(OptimizationResultStatus.SUCCESS,)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x=0 y=1 z=0': 1.0}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "samples_for_plot = {\n",
    "    \" \".join(f\"{rqaoa_result.variables[i].name}={int(v)}\" for i, v in enumerate(s.x)): s.probability\n",
    "    for s in filtered_samples\n",
    "}\n",
    "samples_for_plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x500 with 1 Axes>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_histogram(samples_for_plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.25.0.dev0+1d844ec</td></tr><tr><td><code>qiskit-aer</code></td><td>0.12.0</td></tr><tr><td><code>qiskit-ibmq-provider</code></td><td>0.20.2</td></tr><tr><td><code>qiskit-nature</code></td><td>0.7.0</td></tr><tr><td><code>qiskit-optimization</code></td><td>0.6.0</td></tr><tr><th>System information</th></tr><tr><td>Python version</td><td>3.10.11</td></tr><tr><td>Python compiler</td><td>Clang 14.0.0 (clang-1400.0.29.202)</td></tr><tr><td>Python build</td><td>main, Apr  7 2023 07:31:31</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>4</td></tr><tr><td>Memory (Gb)</td><td>16.0</td></tr><tr><td colspan='2'>Thu May 18 16:56:50 2023 JST</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2023.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import tutorial_magics\n",
    "\n",
    "%qiskit_version_table\n",
    "%qiskit_copyright"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}