{ "cells": [ { "cell_type": "markdown", "id": "8e9c8a1b", "metadata": {}, "source": [ "```{seealso}\n", "The complete source code of this tutorial can be found in\n", "\n", "{nb-download}`Conditional Reset.ipynb`\n", "\n", "```\n", "\n", "(sec-tutorial-conditional-reset)=\n", "\n", "# Tutorial: Conditional Reset\n", "\n", "In this tutorial, we show how to perform a conditional reset using the [conditional control flow framework](sec-control-flow). A conditional reset consists of measuring the state of a qubit, and then:\n", "- sending a pulse to rotate the qubit to the ground state in case the qubit is found to be in an excited state\n", "- not sending any pulse if the qubit is found to be in the ground state\n", "\n", "This conditional reset is potentially much faster than an idle qubit reset (i.e. waiting for a time {math}`\\gg \\tau_1`).\n", "Quantify discriminates between excited and ground state at the `Measure` operation using a [thresholded acquisition](thresholded_acquisition_explanation), and uses a default {math}`\\pi` pulse to set the qubit to its ground state.\n", "In this tutorial, we demonstrate conditional reset using a Qblox cluster that contains a readout module (`QRM_RF`), responsible for the measurement of the qubit, and a control module (`QCM_RF`), responsible for conditionally sending out the {math}`\\pi` pulse.\n", "\n", "To run a conditional reset, we perform the following steps:\n", "\n", "1. Set up the quantum device, dummy hardware, and hardware configuration.\n", "2. Configure thresholded acquisition parameters to separate the {math}`|0\\rangle` and {math}`|1\\rangle` states.\n", "3. Verify that these parameters are set correctly.\n", "4. Run a conditional reset.\n", "\n", "\n", "```{note}\n", "Currently, the conditional reset is only implemented for the Qblox hardware.\n", "```\n", "\n", "(cond_reset_initial_setup)=\n", "\n", "## Initial Setup\n", "\n", "We follow here the same setup as in the {ref}`sec-tutorial-experiment` tutorial.\n", "\n", "First, we define a single transmon qubit as an element ({{ BasicTransmonElement }}) of the {{ QuantumDevice }} and populate the parameters with some reasonable values:\n", "\n", "```{seealso}\n", "If you want to learn more about how to set up the {{ QuantumDevice }} and hardware configuration, please see our other tutorials, in particular {ref}`sec-tutorial-experiment` and {ref}`sec-tutorial-compiling`.\n", "```" ] }, { "cell_type": "code", "execution_count": 1, "id": "c3d060fb", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1908/40710294.py:4: DeprecationWarning: This package has reached its end of life. It is no longer maintained and will not receive any further updates or support. For further developments, please refer to the new Quantify repository: https://gitlab.com/quantify-os/quantify.All existing functionalities can be accessed via the new Quantify repository.\n", " from quantify_core.analysis import base_analysis as ba\n" ] } ], "source": [ "\"\"\"Disable transparent backgrounds for analysis figures to make them look nicer\n", "in both dark and bright mode on the website.\"\"\"\n", "\n", "from quantify_core.analysis import base_analysis as ba\n", "\n", "ba.settings[\"mpl_transparent_background\"] = False" ] }, { "cell_type": "code", "execution_count": 2, "id": "1b699623", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "from qblox_instruments import Cluster, ClusterType\n", "import tempfile\n", "\n", "from quantify_core.data import handling as dh\n", "from quantify_core.measurement.control import MeasurementControl\n", "from quantify_scheduler import BasicTransmonElement, InstrumentCoordinator, QuantumDevice\n", "from quantify_scheduler.qblox import ClusterComponent\n", "\n", "measurement_control = MeasurementControl(\"measurement_control\")\n", "instrument_coordinator = InstrumentCoordinator(\"instrument_coordinator\")\n", "\n", "# Create a temporary directory for this tutorial\n", "temp_dir = tempfile.mkdtemp()\n", "\n", "# First, don't forget to set the data directory!\n", "dh.set_datadir(temp_dir)\n", "\n", "# Device parameters\n", "ACQ_DELAY = 100e-9\n", "FREQ_01 = 4e9\n", "READOUT_AMP = 0.1\n", "READOUT_FREQ = 4.3e9\n", "PI_PULSE_AMP = 0.15\n", "LO_FREQ_QUBIT = 3.9e9\n", "LO_FREQ_READOUT = 4.5e9\n", "\n", "single_qubit_device = QuantumDevice(\"single_qubit_device\")\n", "\n", "q0 = BasicTransmonElement(\"q0\")\n", "single_qubit_device.add_element(q0)\n", "\n", "# Assign device parameters to transmon element\n", "q0.measure.pulse_amp(READOUT_AMP)\n", "q0.clock_freqs.readout(READOUT_FREQ)\n", "q0.clock_freqs.f01(FREQ_01)\n", "q0.measure.acq_delay(ACQ_DELAY)\n", "q0.rxy.amp180(PI_PULSE_AMP)" ] }, { "cell_type": "markdown", "id": "595a0654", "metadata": {}, "source": [ "Next, we connect to a dummy {{ Cluster }}. If you are connecting to an actual cluster, you would provide the\n", " `identifier` argument (the IP address, device name or serial number) instead\n", " of the `dummy_cfg` argument." ] }, { "cell_type": "code", "execution_count": 3, "id": "a4391ee3", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "cluster = Cluster(\n", " \"cluster\",\n", " dummy_cfg={\n", " 1: ClusterType.CLUSTER_QRM_RF,\n", " 2: ClusterType.CLUSTER_QCM_RF,\n", " },\n", ")\n", "\n", "ic_cluster = ClusterComponent(cluster)\n", "\n", "instrument_coordinator.add_component(ic_cluster)\n", "\n", "single_qubit_device.instr_instrument_coordinator(instrument_coordinator.name)" ] }, { "cell_type": "markdown", "id": "09061738", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "2857b88c", "metadata": { "tags": [ "hide-cell" ] }, "outputs": [], "source": [ "hardware_cfg = {\n", " \"version\": \"0.2\",\n", " \"config_type\": \"quantify_scheduler.backends.qblox_backend.QbloxHardwareCompilationConfig\",\n", " \"hardware_description\": {\n", " f\"{cluster.name}\": {\n", " \"instrument_type\": \"Cluster\",\n", " \"modules\": {\n", " 1: {\"instrument_type\": \"QRM_RF\"},\n", " 2: {\"instrument_type\": \"QCM_RF\"},\n", " },\n", " \"ref\": \"internal\",\n", " }\n", " },\n", " \"hardware_options\": {\n", " \"modulation_frequencies\": {\n", " \"q0:res-q0.ro\": {\"lo_freq\": LO_FREQ_READOUT},\n", " \"q0:mw-q0.01\": {\"lo_freq\": LO_FREQ_QUBIT},\n", " }\n", " },\n", " \"connectivity\": {\n", " \"graph\": [\n", " (f\"{cluster.name}.module1.complex_output_0\", \"q0:res\"),\n", " (f\"{cluster.name}.module1.complex_input_0\", \"q0:res\"),\n", " (f\"{cluster.name}.module2.complex_output_0\", \"q0:mw\"),\n", " ]\n", " },\n", "}\n", "\n", "single_qubit_device.hardware_config(hardware_cfg)" ] }, { "cell_type": "markdown", "id": "9a0f318d", "metadata": {}, "source": [ "(cond_reset_create_schedule)=\n", "\n", "## Readout Calibration\n", "\n", "To discriminate between the ground state and the excited state with {{ ConditionalReset }}, we first need to configure the {{ ThresholdedAcquisition }} parameters `acq_threshold` and `acq_rotation` (see [Tutorial: Acquisitions](thresholded_acquisition_explanation)). We do so by preparing a qubit in either its ground state or its excited state, performing a measurement, and repeating this process 500 times. In the measured IQ plane we expect to find all data points clustered in two distinct groups that correspond to the two different states, and the `acq_threshold` and `acq_rotation` parameters define the line between the two groups. \n", "\n", "We run this calibration using {{ MeasurementControl }} and a predefined {{ Schedule }} called {{ readout_calibration_sched }}:" ] }, { "cell_type": "code", "execution_count": 5, "id": "30d4febd", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "### Generate dummy data\n", "\n", "import numpy as np\n", "from qblox_instruments.ieee488_2.dummy_transport import DummyBinnedAcquisitionData\n", "from quantify_scheduler.qblox import start_dummy_cluster_armed_sequencers\n", "\n", "def get_dummy_binned_acquisition_data(\n", " real: float, imag: float, theta: float, threshold: float\n", "):\n", " angle = 2 * np.pi * theta / (360)\n", " threshold *= 1000 # different normalization (integration length) on qblox instruments\n", " if real * np.cos(angle) - imag * np.sin(angle) > threshold:\n", " thres = 1\n", " else:\n", " thres = 0\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\n", "def setup_dummy_data(theta: float, threshold: float):\n", " # Means and standard deviations\n", " x0, xs0 = -2.7, 2.5\n", " y0, ys0 = 2.9, 2.5\n", " x1, xs1 = -14, 2.5\n", " y1, ys1 = 1.9, 2.5\n", "\n", " # Number of points per data cluster\n", " max_batch_size = 60\n", "\n", " # Generate random samples\n", " x0_samples = np.random.normal(x0, xs0, max_batch_size)\n", " y0_samples = np.random.normal(y0, ys0, max_batch_size)\n", " x1_samples = np.random.normal(x1, xs1, max_batch_size)\n", " y1_samples = np.random.normal(y1, ys1, max_batch_size)\n", "\n", " # interleave the random samples such that we get\n", " # x = [x0_samples[0], x1_samples[0], x0_samples[1],...]\n", " # y = [y0_samples[0], y1_samples[0], y0_samples[1],...]\n", "\n", " x = np.vstack((x0_samples, x1_samples)).reshape(-1, order=\"F\")\n", " y = np.vstack((y0_samples, y1_samples)).reshape(-1, order=\"F\")\n", " states = np.array([0, 1] * max_batch_size)\n", "\n", " # prepare cluster with dummy data that will be returned \n", " # after retrieving acquisitions.\n", " cluster.delete_dummy_binned_acquisition_data(1)\n", " cluster.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re), float(im), theta, threshold)\n", " for re, im in zip(x, y)\n", " ],\n", " )\n", "\n", "def setup_dummy_and_start_sequencer(theta: float, threshold: float):\n", " setup_dummy_data(theta, threshold)\n", " start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(0, 0)" ] }, { "cell_type": "code", "execution_count": 6, "id": "45b1becd", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 24kB\n",
       "Dimensions:  (dim_0: 1000)\n",
       "Coordinates:\n",
       "    x0       (dim_0) int64 8kB 0 1 0 1 0 1 0 1 0 1 0 1 ... 1 0 1 0 1 0 1 0 1 0 1\n",
       "Dimensions without coordinates: dim_0\n",
       "Data variables:\n",
       "    y0       (dim_0) float64 8kB 0.0008036 -0.0162 ... -0.00429 -0.0145\n",
       "    y1       (dim_0) float64 8kB 0.002623 -0.001677 ... 0.003377 0.002783\n",
       "Attributes:\n",
       "    tuid:                             20260619-134721-488-c2433b\n",
       "    name:                             Readout Calibration\n",
       "    grid_2d:                          False\n",
       "    grid_2d_uniformly_spaced:         False\n",
       "    1d_2_settables_uniformly_spaced:  False
" ], "text/plain": [ " Size: 24kB\n", "Dimensions: (dim_0: 1000)\n", "Coordinates:\n", " x0 (dim_0) int64 8kB 0 1 0 1 0 1 0 1 0 1 0 1 ... 1 0 1 0 1 0 1 0 1 0 1\n", "Dimensions without coordinates: dim_0\n", "Data variables:\n", " y0 (dim_0) float64 8kB 0.0008036 -0.0162 ... -0.00429 -0.0145\n", " y1 (dim_0) float64 8kB 0.002623 -0.001677 ... 0.003377 0.002783\n", "Attributes:\n", " tuid: 20260619-134721-488-c2433b\n", " name: Readout Calibration\n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from qcodes import ManualParameter\n", "\n", "from quantify_scheduler import Schedule, ScheduleGettable\n", "from quantify_scheduler.operations import Measure\n", "from quantify_scheduler.schedules import readout_calibration_sched\n", "\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\"qubit\": \"q0\", \"prepared_states\": states}\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=60,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "measurement_control.verbose(False)\n", "\n", "dataset = measurement_control.run(\"Readout Calibration\")\n", "dataset" ] }, { "cell_type": "markdown", "id": "7a6d2d99", "metadata": {}, "source": [ "```{seealso}\n", "More information on configuring {{ MeasurementControl }} can be found in the\n", "[user guide](https://quantify-os.org/docs/quantify-core/dev/user/concepts.html#measurement-control)\n", "of `quantify-core`, and in the tutorials [Running and Experiment](sec-tutorial-experiment) and [ScheduleGettable](sec-schedulegettable-2dsweep-usage)\n", "```\n", "\n", "To determine the qubit threshold parameters, we use the {{ ReadoutCalibrationAnalysis }}:" ] }, { "cell_type": "code", "execution_count": 7, "id": "cd4bc3b8", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABD0AAAJvCAYAAAB4Yqq+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1hT1/8H8HdARmTKkCEKqCiKisVV98atuKutilLrwvmte1br3nW3VsBWq3Vg/bXuVa171j0roiJLZQjIyv39EXMlECDMkPh+PQ+P5uTce869uQncT875HIkgCAKIiIiIiIiIiHSMnqY7QERERERERERUFBj0ICIiIiIiIiKdxKAHEREREREREekkBj2IiIiIiIiISCcx6EFEREREREREOolBDyIiIiIiIiLSSQx6EBEREREREZFOYtCDiIiIiIiIiHQSgx5EREREREREpJMY9CAiItJBEokEc+bM0XQ3ilxgYCAkEglCQkLEshYtWqBFixbi41OnTkEikWD37t3F38EMQkJCIJFIEBgYqNF+EBERfUoY9CAiIioAxY2s4kdPTw9WVlbo0KEDzp8/r+nuFan169fn+Qb+/fv3WLlyJRo0aAALCwsYGxujSpUq8Pf3x8OHD4umo8Vs+/btWLVqlaa7QURERABKaboDREREuqBfv37o2LEj0tPT8fDhQ6xfvx4tW7bE5cuXUbNmTU13r0isX78eNjY28PX1Vat+dHQ02rdvj6tXr6Jz587o378/TE1N8eDBA+zYsQM//vgjUlJSCtyvI0eOFHgfBbF9+3bcvn0b48aNUyp3dnZGUlISDAwMNNMxIiKiTxCDHkRERIXAy8sLX331lfi4adOm6NChAzZs2ID169drsGclh6+vL65fv47du3ejZ8+eSs/NmzcP06dPL5R2DA0NC2U/ComJiShdunSB9yORSGBsbFwIPSIiIiJ1cXoLERFREWjatCkA4MmTJ0rlMTExGDduHMqXLw8jIyNUrlwZixcvhkwmU6q3bNkyNGrUCNbW1pBKpahTp47KnBTJyckYP348bG1tYWZmhq5du+LFixcq+3T9+nV06NAB5ubmMDU1RevWrXHhwgWlOnPmzIFEIsmybebcGS4uLrhz5w7+/vtvcWpPxjwamV28eBF//fUX/Pz8sgQ8AMDIyAjLli0TH9+8eRO+vr6oWLEijI2NYW9vjyFDhuD169fZtqGQOaeHQnp6OqZNmwZ7e3uYmJiga9eueP78eZZta9SogatXr6JZs2YoXbo0pk2bBgD4448/0KlTJzg6OsLIyAiVKlXCvHnzkJ6errT9X3/9hWfPnonnxcXFBUD2OT1OnDiBpk2bwsTEBJaWlujWrRvu3bunVEfxujx+/Bi+vr6wtLSEhYUFBg8ejMTExFzPCRER0aeKIz2IiIiKgCI4UKZMGbEsMTERzZs3x8uXLzFs2DBUqFAB586dw9SpU/Hq1SulPBCrV69G165d8eWXXyIlJQU7duxA79698eeff6JTp05iva+//hq//vor+vfvj0aNGuHEiRNKzyvcuXMHTZs2hbm5OSZNmgQDAwNs2rQJLVq0wN9//40GDRrk6fhWrVqF0aNHw9TUVByhYWdnl239/fv3AwAGDBig1v6PHj2K//77D4MHD4a9vT3u3LmDH3/8EXfu3MGFCxdUBmZyM3/+fEgkEkyePBmRkZFYtWoV2rRpgxs3bkAqlYr1Xr9+jQ4dOuCLL77AV199JR5XYGAgTE1NMWHCBJiamuLEiROYNWsW4uLisHTpUgDA9OnTERsbixcvXmDlypUAAFNT02z7dOzYMXTo0AEVK1bEnDlzkJSUhDVr1qBx48a4du2aGDBR6NOnD1xdXbFw4UJcu3YNmzdvRtmyZbF48eI8nw8iIqJPgkBERET59vTpUwGA8N133wlRUVFCeHi4cObMGaFevXoCAGHXrl1i3Xnz5gkmJibCw4cPlfYxZcoUQV9fXwgNDRXLEhMTleqkpKQINWrUEFq1aiWW3bhxQwAgjBw5Uqlu//79BQDC7NmzxTIfHx/B0NBQePLkiVgWFhYmmJmZCc2aNRPLZs+eLaj68yAgIEAAIDx9+lQs8/DwEJo3b57zCfqge/fuAgDh7du3atXPfPyCIAi//fabAEA4ffp0jv1q3ry5Ur9OnjwpABDKlSsnxMXFieW///67AEBYvXq10rYAhI0bN6rVp2HDhgmlS5cW3r9/L5Z16tRJcHZ2zlJXca0EBASIZbVr1xbKli0rvH79Wiz7999/BT09PWHgwIFimeJ1GTJkiNI+u3fvLlhbW2dpi4iIiOQ4vYWIiKgQzJ49G7a2trC3t0fTpk1x7949LF++HL169RLr7Nq1C02bNkWZMmUQHR0t/rRp0wbp6ek4ffq0WDfjyIO3b98iNjYWTZs2xbVr18TyAwcOAADGjBmj1JfMCTTT09Nx5MgR+Pj4oGLFimK5g4MD+vfvj3/++QdxcXGFch6yo9i/mZmZWvUzHv/79+8RHR2Nzz//HACUzkFeDBw4UKn9Xr16wcHBQTyPCkZGRhg8eHCOfYqPj0d0dDSaNm2KxMRE3L9/P8/9efXqFW7cuAFfX19YWVmJ5bVq1ULbtm2z9AsAhg8frvS4adOmeP36dZG/fkRERNqK01uIiIgKwTfffIPevXvj/fv3OHHiBH744QelXA8A8OjRI9y8eRO2trYq9xEZGSn+/88//8T333+PGzduIDk5WSzPOK3j2bNn0NPTQ6VKlZT2U7VqVaXHUVFRSExMzFIOANWqVYNMJsPz58/h4eGh/gHnkbm5OQB5sMDS0jLX+m/evMF3332HHTt2KJ0XAIiNjc1XH9zc3JQeSyQSVK5cWZyKpFCuXDmVyVDv3LmDGTNm4MSJE1mCDPnp07NnzwBkfb0A+ety+PBhJCQkwMTERCyvUKGCUj3F9Km3b9+K55iIiIg+YtCDiIioELi5uaFNmzYAgM6dO0NfXx9TpkxBy5YtUbduXQCATCZD27ZtMWnSJJX7qFKlCgDgzJkz6Nq1K5o1a4b169fDwcEBBgYGCAgIwPbt24v0OLLLlZE5gJNX7u7uAIBbt26JSV5z0qdPH5w7dw4TJ05E7dq1YWpqCplMhvbt22dJ+lrYMo7oUIiJiUHz5s1hbm6OuXPnolKlSjA2Nsa1a9cwefLkIu+Tgr6+vspyQRCKpX0iIiJtw6AHERFREZg+fTp++uknzJgxA4cOHQIAVKpUCe/evRODI9nZs2cPjI2NcfjwYRgZGYnlAQEBSvWcnZ0hk8nw5MkTpdECDx48UKpna2uL0qVLZykHgPv370NPTw/ly5cH8HHkQExMjNKIDMWohIzykky0S5cuWLhwIX799ddcgx5v377F8ePH8d1332HWrFli+aNHj9RuT5XM2wuCgMePH6NWrVq5bnvq1Cm8fv0ae/fuRbNmzcTyp0+fZqmr7nlxdnYGkPX1AuSvi42NjdIoDyIiIso75vQgIiIqApaWlhg2bBgOHz6MGzduAJCPXjh//jwOHz6cpX5MTAzS0tIAyL/Nl0gkSqMrQkJCsG/fPqVtOnToAAD44YcflMozrgKj2J+3tzf++OMPpakcERER2L59O5o0aSJOjVBMlcmYXyQhIQFBQUFZ+mxiYoKYmJjsT0IGDRs2RPv27bF58+YsxwEAKSkp+Pbbb8X+AllHL2Q+rrzaunUr4uPjxce7d+/Gq1evxPOYE1V9SklJwfr167PUNTExUWu6i4ODA2rXro2goCCl83j79m0cOXIEHTt2zHUfRERElDOO9CAiIioiY8eOxapVq7Bo0SLs2LEDEydOxP79+9G5c2f4+vqiTp06SEhIwK1bt7B7926EhITAxsYGnTp1wooVK9C+fXv0798fkZGRWLduHSpXroybN2+K+69duzb69euH9evXIzY2Fo0aNcLx48fx+PHjLH35/vvvcfToUTRp0gQjR45EqVKlsGnTJiQnJ2PJkiViPW9vb1SoUAF+fn6YOHEi9PX1sWXLFtja2iI0NFRpn3Xq1MGGDRvw/fffo3LlyihbtixatWqV7fnYunUrvL290aNHD3Tp0gWtW7eGiYkJHj16hB07duDVq1dYtmwZzM3N0axZMyxZsgSpqakoV64cjhw5onJURV5YWVmhSZMmGDx4MCIiIrBq1SpUrlwZQ4cOzXXbRo0aoUyZMhg0aBDGjBkDiUSCX375ReW0kjp16mDnzp2YMGEC6tWrB1NTU3Tp0kXlfpcuXYoOHTqgYcOG8PPzE5estbCwwJw5cwp0vERERAQuWUtERFQQimVIly5dqvJ5X19fQV9fX3j8+LEgCIIQHx8vTJ06VahcubJgaGgo2NjYCI0aNRKWLVsmpKSkiNv9/PPPgpubm2BkZCS4u7sLAQEBKpeTTUpKEsaMGSNYW1sLJiYmQpcuXYTnz59nWbJWEATh2rVrQrt27QRTU1OhdOnSQsuWLYVz585l6fPVq1eFBg0aCIaGhkKFChWEFStWqFwaNjw8XOjUqZNgZmYmAFBr+drExERh2bJlQr169QRTU1PB0NBQcHNzE0aPHi2eI0EQhBcvXgjdu3cXLC0tBQsLC6F3795CWFhYluPKy5K1v/32mzB16lShbNmyglQqFTp16iQ8e/ZMqX/NmzcXPDw8VPb97Nmzwueffy5IpVLB0dFRmDRpknD48GEBgHDy5Emx3rt374T+/fsLlpaWAgBx+VpVS9YKgiAcO3ZMaNy4sSCVSgVzc3OhS5cuwt27d5XqKF77qKgopXJVx09EREQfSQSBma+IiIiIiIiISPcwpwcRERERERER6SQGPYiIiIiIiIhIJzHoQUREREREREQ6iUEPIiIiIiIiItJJDHoQERERERERkU5i0IOIiIiIiIiIdBKDHkREVCwCAwMhkUgQEhKSa10XFxf4+voWeZ+ISPu4uLigc+fOmu4GERFpCQY9iIgoV+fOncOcOXMQExOj6a7k6v79+5g0aRJq164NMzMzODg4oFOnTrhy5YrK+i9fvkSfPn1gaWkJc3NzdOvWDf/9959SnefPn+O7775D/fr1UaZMGdjY2KBFixY4duxYtv04duwYWrVqBQsLC5iZmaFOnTrYuXNnlnr79++Hl5cXjI2NUaFCBcyePRtpaWn53ufOnTvx1Vdfwc3NDRKJBC1atMi2j1evXkX79u1hbm4OMzMzeHt748aNG9nWz0zdtu7cuYPevXujYsWKKF26NGxsbNCsWTP83//9X477T01NRfXq1SGRSLBs2TKl5+bMmQOJRJLtz9mzZwEAMpkMgYGB6Nq1K8qXLw8TExPUqFED33//Pd6/f5+lzQ0bNqB3796oUKECJBJJgYNvbdu2hUQigb+/f5bnYmNjMWnSJLi5uUEqlcLZ2Rl+fn4IDQ3NUvfYsWNo2bIlbGxsYGlpifr16+OXX34pUN8yys81rjB06FBIJBKVgYjx48fDy8sLVlZWKF26NKpVq4Y5c+bg3bt3SvXye40QERHlppSmO0BERCXfuXPn8N1338HX1xeWlpb52seAAQPwxRdfwMjIqHA7l8nmzZvx888/o2fPnhg5ciRiY2OxadMmfP755zh06BDatGkj1n337h1atmyJ2NhYTJs2DQYGBli5ciWaN2+OGzduwNraGgDwxx9/YPHixfDx8cGgQYOQlpaGrVu3om3bttiyZQsGDx6s1IeAgAD4+fmhbdu2WLBgAfT19fHgwQM8f/5cqd7Bgwfh4+ODFi1aYM2aNbh16xa+//57REZGYsOGDfna54YNG3D16lXUq1cPr1+/zvY8Xbt2DU2aNEH58uUxe/ZsyGQyrF+/Hs2bN8elS5dQtWrVXM+1um09e/YM8fHxGDRoEBwdHZGYmIg9e/aga9eu2LRpE7755huV261Zs0ZlAAAAevTogcqVK2cpnzZtGt69e4d69eoBABITEzF48GB8/vnnGD58OMqWLYvz589j9uzZOH78OE6cOAGJRCJuv3jxYsTHx6N+/fp49epVrucgJ3v37sX58+dVPieTydC2bVvcvXsXI0eORJUqVfD48WOsX78ehw8fxr1792BmZgZAHhjz8fFBw4YNxWDP77//joEDByI6Ohrjx48vUD+BvF/jCleuXEFgYCCMjY1VPn/58mU0bdoUgwcPhrGxMa5fv45Fixbh2LFjOH36NPT05N+/5fcaISIiypVARESUi6VLlwoAhKdPnxZLe87OzsKgQYPyte2VK1eE+Ph4pbLo6GjB1tZWaNy4sVL54sWLBQDCpUuXxLJ79+4J+vr6wtSpU8Wy27dvC1FRUUrbvn//XnB3dxecnJyUyp8+fSpIpVJhzJgxufa1evXqgqenp5CamiqWTZ8+XZBIJMK9e/fytc/Q0FAhPT1dEARB8PDwEJo3b66yXseOHYUyZcoI0dHRYllYWJhgamoq9OjRI9d28tKWKmlpaYKnp6dQtWpVlc9HREQIFhYWwty5cwUAwtKlS9Xqj0QiEYYOHSqWJScnC2fPns1S97vvvhMACEePHlUqDwkJEWQymSAIgmBiYpLv6zApKUlwcXER+z9q1Cil58+ePSsAENauXatUvmXLFgGAsHfvXrGsbdu2gqOjo/D+/XuxLDU1VahUqZJQq1atfPUvs7xc4woymUxo2LChMGTIEMHZ2Vno1KmTWm0tW7ZMACCcP38+x3rZXSN5aYuIiIjTW4iIKEdz5szBxIkTAQCurq7i9IGQkBCEhIRAIpEgMDAwy3YSiQRz5swRH6vK6SEIAr7//ns4OTmhdOnSaNmyJe7cuaOyH0+ePMGTJ09y7W+dOnVgamqqVGZtbY2mTZvi3r17SuW7d+9GvXr1xFEBAODu7o7WrVvj999/F8s8PDxgY2OjtK2RkRE6duyIFy9eID4+XizfuHEj0tPTMXfuXADy0SSCIGTp5927d3H37l188803KFXq48DLkSNHQhAE7N69O8/7BIDy5cuL357n5MyZM2jTpo04mgUAHBwc0Lx5c/z5559Zph8UpC1V9PX1Ub58+WynTE2ZMgVVq1bFV199pfY+f/vtNwiCgC+//FIsMzQ0RKNGjbLU7d69OwBkuSacnZ2VRn7k15IlSyCTyfDtt9+qfD4uLg4AYGdnp1Tu4OAAAJBKpUp1y5QpozRKqlSpUrCxsVGql5OYmBiMHz8eLi4uMDIygpOTkzhSBMjbNa7wyy+/4Pbt25g/f75afVBwcXER+5ST3K6RI0eOoHbt2jA2Nkb16tWxd+/ePPWDiIg+DQx6EBFRjnr06IF+/foBAFauXIlffvkFv/zyC2xtbQu871mzZmHmzJnw9PTE0qVLUbFiRXh7eyMhISFL3datW6N169b5bis8PFzppk4mk+HmzZuoW7dulrr169fHkydPVN7oZd5n6dKlUbp0abHs2LFjcHd3x4EDB+Dk5AQzMzNYW1tj5syZkMlkYr3r168DQJb2HR0d4eTkJD6fl33mRXJyssob5tKlSyMlJQW3b9/O135zkpCQgOjoaDx58gQrV67EwYMHVb6mly5dQlBQEFatWpWnAMS2bdtQvnx5NGvWLNe64eHhAJDlRr8whIaGYtGiRVi8eHG2QYm6devCxMQEM2fOxIkTJ/Dy5Uv8/fffmDRpEurVq6c0DatFixa4c+cOZs6cicePH+PJkyeYN28erly5gkmTJuXan3fv3qFp06ZYs2YNvL29sXr1agwfPhz379/HixcvctxW1TUOAPHx8Zg8eTKmTZsGe3v7HPeRlpaG6OhohIWF4ciRI5gxYwbMzMxQv379LHXVvUYePXqEvn37okOHDli4cCFKlSqF3r174+jRo7meDyIi+sRodJwJERFpheymtzx9+lQAIAQEBGTZBoAwe/Zs8XFAQIDSPiIjIwVDQ0OhU6dO4nQCQRCEadOmCQCyTCtwdnYWnJ2d89X/06dPCxKJRJg5c6ZYFhUVJQAQ5s6dm6X+unXrBADC/fv3s93no0ePBGNjY2HAgAFK5ebm5kKZMmUEIyMjYebMmcLu3buF/v37CwCEKVOmiPUU5zQ0NDTLvuvVqyd8/vnned5nZjlNOalZs6ZQpUoVIS0tTSxLTk4WKlSoIAAQdu/ene1+89qWwrBhwwQAAgBBT09P6NWrl/DmzRulOjKZTKhfv77Qr18/QRA+XmO5TW+5ffu2AECYNGmSWv1t06aNYG5uLrx9+zbbOvmd3tKrVy+hUaNG4mOomN4iCILw559/Cg4ODuI5ASC0a9cuy/Ssd+/eCX369BEkEolYr3Tp0sK+ffvU6s+sWbOyTJlRyPjeyyy7a1wQBOHbb78VXF1dxSk3OU05OX/+vNIxVq1aVTh58qTKuupcI87OzgIAYc+ePWJZbGys4ODgIHz22WfZHg8REX2amMiUiIg04tixY0hJScHo0aOVvs0fN24cFixYkKW+OkvdqhIZGYn+/fvD1dVV6VvxpKQkAFCZWFWRlFFRJ7PExET07t0bUqkUixYtUnru3bt3kMlkWLRoESZPngwA6NmzJ968eYPVq1dj2rRpMDMzy7V9xfSHvOwzL0aOHIkRI0bAz88PkyZNgkwmw/fffy8m78zu2Ati3Lhx6NWrF8LCwvD7778jPT0dKSkpSnUCAwNx69Ytpek96ti2bRsAKE1tyc6CBQtw7NgxrF+/Pt+JebNz8uRJ7NmzBxcvXsy1rq2tLT777DP4+/vDw8MDN27cwJIlSzB48GDs2rVLrGdkZIQqVaqgV69e6NGjB9LT0/Hjjz/iq6++wtGjR/H555/n2M6ePXvg6ekpTunJKLuRNDld4w8fPsTq1avx22+/qZWYuHr16jh69CgSEhJw7tw5HDt2LNvpU+pcI4B8RFTG4zE3N8fAgQOxePFihIeH5zr6hIiIPh0MehARkUY8e/YMAODm5qZUbmtrizJlyhRKGwkJCejcuTPi4+Pxzz//KOX6UEw7SE5OzrKdYilTVVMT0tPT8cUXX+Du3bs4ePAgHB0dlZ6XSqVISEgQpwQp9OvXD4cOHcL169fRrFmzXNvP2La6+8yL4cOH4/nz51i6dCmCgoIAyKdcTJo0CfPnzxfP1Zs3b5RuOqVSKSwsLPLUloK7uzvc3d0BAAMHDoS3tze6dOmCixcvQiKRIC4uDlOnTsXEiRNRvnx5tfcrCAK2b9+OGjVqoFatWjnW3blzJ2bMmAE/Pz+MGDEiX8eRlJSE2NhYpTJ7e3ukpaVhzJgxGDBggFKeGFX+++8/tGzZElu3bkXPnj0BAN26dYOLiwt8fX1x8OBBdOjQAQDg7++PCxcu4Nq1a2IOlT59+sDDwwNjx44VAyyKKTsKFhYWkEqlePLkidiGOnK7xseOHYtGjRqpvU9zc3Nxuk63bt2wfft2dOvWDdeuXYOnp6dS3dyuEYXKlStnCdhUqVIFgDxAyqAHEREpMKcHERHlW3bfEqenpxdzT7JKSUlBjx49cPPmTfzxxx+oUaOG0vNWVlYwMjJSuSypoizzzR4ADB06FH/++ScCAwPRqlWrLM8rtsmcoLJs2bIAgLdv3wL4mLAyu/Yztq3uPvNq/vz5iIiIwJkzZ3Dz5k1cvnxZzBGiuIHs0aMHHBwcxJ+xY8fmqy1VevXqhcuXL+Phw4cAgGXLliElJQV9+/YVE+Uqck68ffsWISEhKr/1P3v2LJ49e5brKI+jR49i4MCB6NSpEzZu3Jjvfu/cuVPpnChey61bt+LBgwcYNmyY2H/FCKX4+HiEhIQgMTERgHxEy/v379G5c2elfXft2lU8JkB+Hf/888/o1KmTUtJYAwMDdOjQAVeuXBHPSeY+7dy5M1/Hl9M1fuLECRw6dAhjx45VOsa0tDQkJSUhJCREaZSSKj169AAA7NixI9e+ZL5GiIiI8oojPYiIKFfZBTcUIzIyr66gGMWRE2dnZwDyhIQVK1YUy6OiovJ9E68gk8kwcOBAHD9+HL///juaN2+epY6enh5q1qyJK1euZHnu4sWLqFixYpYpIxMnTkRAQABWrVqVZdSFQp06dfDo0SO8fPlS6bjCwsIAQEwAW7t2bQDAlStXlBI6hoWF4cWLF/jmm2/yvM/8KFOmDJo0aSI+PnbsGJycnMRv25cvX670eqgKBOWXYgqNYtREaGgo3r59Cw8Pjyx1FyxYgAULFuD69eviuVPYtm0bJBIJ+vfvn21bFy9eRPfu3VG3bl38/vvvSivm5FW7du1UJswMDQ1FamoqGjdunOW5rVu3YuvWrQgODoaPjw8iIiIgCEKWAGFqaioAefJPAHj9+jXS0tJUBhJTU1Mhk8nE5zL3SXEeK1WqpHZi2tyu8dDQUAAfAxcZvXz5Eq6urli5ciXGjRuXbRvJycmQyWRZRsuokvkaUXj8+DEEQVD6bFIERhSrwxAREQFgIlMiIsrdhg0bBADC9evXszxnY2MjdO/eXansf//7n1qJTA0MDNROZPr48WPh8ePHavV35MiRAgBh06ZNOdZbtGiRAEC4fPmyWHb//n1BX19fmDx5slLdJUuWCACEadOm5bjP4ODgLPXS09OFJk2aCFZWVmLiR0EQBHd3d8HT01MpmeiMGTMEiUQi3L17N1/7zEid5KIZ7dixQwAgLFu2TO1t1GkrIiIiS1lKSorg5eUlSKVSMXHn1atXheDgYKWfTZs2CQAEX19fITg4WIiJicmyH2tra6Fp06bZ9u3u3buCtbW14OHhkSUpZk7ymsj03r17WfqveO06duwoBAcHC2FhYYIgCMKyZctUJgFetWqVAEDYsWOHIAiCkJaWJlhaWgpVqlQRkpOTxXrx8fGCk5OT4O7unmu/1E1kqs41/uzZM5XHaGtrK9StW1cIDg4W36dv374VUlJSsuxDcew///yzWKbuNSIIOScyrV27di5ng4iIPjUc6UFERLmqU6cOAGD69On44osvYGBggC5dusDExARff/01Fi1ahK+//hp169bF6dOn1RqKbmtri2+//RYLFy5E586d0bFjR1y/fh0HDx5UuYyoYtnK3BKarlq1CuvXr0fDhg1RunRp/Prrr0rPd+/eHSYmJgDkyTx/+ukndOrUCd9++y0MDAywYsUK2NnZ4X//+5+4TXBwMCZNmgQ3NzdUq1Ytyz7btm0rTj3p1q0bWrdujYULFyI6Ohqenp7Yt28f/vnnH2zatEkp8ePSpUvRtWtXeHt744svvsDt27exdu1afP3116hWrZpYLy/7PH36NE6fPg1APmomISEB33//PQCgWbNmYu6P06dPY+7cufD29oa1tTUuXLiAgIAAtG/fXu0pLOq2NWzYMMTFxaFZs2YoV64cwsPDsW3bNty/fx/Lly8X84d4eXnBy8tLqQ3F6+3h4QEfH58sfTh8+DBev36d7dSW+Ph4tGvXDm/fvsXEiRPx119/KT1fqVIlNGzYUHz8f//3f/j3338ByEdS3Lx5Uzymrl275pgzJGM+isxcXV2V+u/r64tly5Zh2LBhuH79Ojw8PHDt2jVs3rwZHh4eYpJOfX19fPvtt5gxYwY+//xzDBw4EOnp6fj555/x4sWLLNeiKhMnTsTu3bvRu3dvDBkyBHXq1MGbN2+wf/9+bNy4EZ6enmpf4xUqVECFChWytDFu3DjY2dkpHeOpU6cwZswY9OrVC25ubkhJScGZM2ewd+9e1K1bF1999ZVYV91rRKFKlSrw8/PD5cuXYWdnhy1btiAiIgIBAQG5ng8iIvrEaDrqQkRE2mHevHlCuXLlBD09PaURG4mJiYKfn59gYWEhmJmZCX369BEiIyNzHekhCPLRCt99953g4OAgSKVSoUWLFsLt27cFZ2fnfC9ZO2jQIKXlMTP/ZF529/nz50KvXr0Ec3NzwdTUVOjcubPw6NEjpTqzZ8/OcZ+Zl9+Mj48Xxo4dK9jb2wuGhoZCzZo1hV9//VVlf4ODg4XatWsLRkZGgpOTkzBjxgyV346ru8+c+prx9Xj8+LHg7e0t2NjYCEZGRoK7u7uwcOFCpdEEuVG3rd9++01o06aNYGdnJ5QqVUooU6aM0KZNG+GPP/7ItY3clqz94osvBAMDA+H169c5bp/dT+brLKfrR9XSzOpANkvWvnjxQhgyZIjg6uoqGBoaCg4ODsLQoUOFqKioLHW3bdsm1K9fX7C0tBSkUqnQoEGDPC0r/Pr1a8Hf318oV66cYGhoKDg5OQmDBg0SoqOjBUHI+zWemaolax8/fiwMHDhQqFixoiCVSgVjY2PBw8NDmD17tvDu3Tulunm5RhRtHT58WKhVq5Z4/e7atUvt80FERJ8OiSAIQiHHUYiIiIiIiIiINI6rtxARERERERGRTmLQg4iIiIiIiIh0EoMeRERERERERKSTGPQgIiIiIiIiIp3EoAcRERERERER6SQGPYiIiIiIiIhIJzHoQUREREREREQ6iUEPIiIiIiIiItJJDHoQERERERERkU5i0IOIiIiIiIiIdBKDHkRERERERESkkxj0ICIiIiIiIiKdxKAHEREREREREekkBj2IiIiIiIiISCcx6EFEREREREREOolBDyIiIiIiIiLSSQx6EBEREREREZFOYtCDiIiIiIiIiHQSgx5EREREREREpJMY9CAiIiIiIiIincSgBxERERERERHpJAY9iIiIiIiIiEgnMehBRERERERERDqJQQ8iIiIiIiIi0kkMehARERERERGRTmLQg4iIiIiIiIh0EoMeRERERERERKSTGPQgIiIiIiIiIp3EoAcRERERERER6SQGPYiIiIiIiIhIJzHoQUREREREREQ6iUEPIiIiIiIiItJJDHoQERERERERkU5i0IOIiIiIiIiIdBKDHkRERERERESkkxj0ICIiIiIiIiKdxKAHEREREREREekkBj2IiIiIiIiISCcx6EFEREREREREOolBDyIiIiIiIiLSSQx6EBEREREREZFOYtCDiIiIiIiIiHQSgx5EREREREREpJMY9CAiIiIiIiIincSgBxERERERERHpJAY9iIiIiIiIiEgnMehBRERERERERDqJQQ8iIiIiIiIi0kkMehARERERERGRTmLQg4iIiIiIiIh0EoMeRERERERERKSTGPQgIiIiIiIiIp3EoAcRERERERER6SQGPYiIiIiIiIhIJzHoQUREREREREQ6iUEPIiIiIiIiItJJDHoQERERERERkU5i0IOIiIiIiIiIdBKDHkRERERERESkkxj0ICIiIiIiIiKdxKAHEREREREREekkBj2IiIiIiIiISCcx6EFEREREREREOolBDyIiIiIiIiLSSQx6EBEREREREZFOYtCDiIiIiIiIiHQSgx5EREREREREpJMY9CAiIiIiIiIincSgBxERERERERHpJAY9iIiIiIiIiEgnMehBRERERERERDqJQQ8iIiIiIiIi0kkMehARERERERGRTmLQg4iIiIiIiIh0EoMeRERERERERKSTGPQgIiIiIiIiIp3EoAcRERERERER6SQGPYiIiIiIiIhIJzHoQUREREREREQ6iUEPIiIiIiIiItJJDHoQERERERERkU5i0IOIiIiIiIiIdBKDHkRERERERESkk0ppugOfAplMhrCwMJiZmUEikWi6O0REREREVEwEQUB8fDwcHR2hp8fvnImKG4MexSAsLAzly5fXdDeIiIiIiEhDnj9/DicnJ013g+iTw6BHMTAzMwMAPFy9CWbmFhruDQHA+9RkGBsYabobVIz4mn96CvqaD1+1An/8ewk9u81Ap24TC7FnVFRSU5NgYCDVdDeoGAiCgMTEGKSmvoeFhT1H0n5CtO19LpMBz5/H4bvvyov3BERUvBj0KAaKX8R2ZaQwtyyt4d4QACQl60NqxBvgTwlf809PQV/zKuUdgX+BdzFhsLExL8SeUVFJTjaAkZH23AxR/gmCgIQEGZKTDWBlZc6gxydE297n6elAVJT8/7xOiTSDk8qIiIhUqFjOAQAQFRWq4Z4QERERUX4x6EFERKSCi31ZAEDU6+ca7gkRERER5ReDHkRERCo4l5UHPV7HhGm4J0RERESUXwx6EBERqVDB1hYAkJgcj4SEWA33hoiIiIjyg0EPIiIiFUyMjVFGagKAeT2IiIiItBWDHkRERNlwsrQCAERFPdNwT4iIiIgoPxj0ICIiykZ5a/kUl4iwpxruCRERERHlB4MeRERE2XAuqwh6PNFwT4iIiIgoPxj0ICIiyoaLgz0AICqC01uIiIiItBGDHkRERNlwLWcHAIiKZiJTIiIiIm3EoAcREVE2XOzkQY/oty813BMiIiIiyg8GPYiIiLJRwcYGABATH4nU1BQN94aIiIiI8opBDyIiomyUtbSEkX4pCBDw+jVHexARERFpm1Ka7gAREVFJJZFIUM7CCv+9iUR0dCjs7V013SUiIqJ8S01NxePHj3Hv3j28efMGqampmu4SUYEYGBjA0tIS1apVg5ubGwwNDbPUYdCDiIgoB05W1vjvTSQiXj1FjRrNNd0dooKJjgbCwgBHR+DD9C0i+jRER0cjKCgI8fHxsLOzg6OjIwwMDDTdLaICSU1NRXh4OHbt2oXSpUtj0KBBsPuQk02BQQ8iIqIcVLC1BR7fQ+Srp5ruClHBHDkCrFsHCDJAogeMGgV4e2u6V0RUDGJiYhAYGCjeFNow6Ek65s2bN9i1axeCgoLg5+cHa2tr8Tnm9CAiIsqBi73824LIV/9puCdEBRAd/THgAcj/Xb9eXk5EOu/69etIS0tjwIN0lpWVFQYOHAiJRIKrV68qPcegBxERUQ5cHe0BAFFRoRruCVEBhIV9DHgoyNKBV6800x8iKjaCIODOnTtwd3eHiYmJprtDVGSkUimqVauGu3fvQhAEsZxBDyIiohy42JcFAES9fq7hnhAVgKOjfEpLRnr6gIODZvpDRMUmNTUV0dHRcHVlMm7SfRUrVkRMTAySkpLEMgY9iIiIcuBcVh70eB37SulbAyKtYmMjz+Ghpy9/rKcPjBzJZKZEn4CUlBQAgLGxsYZ7QlT0FNd5cnKyWMZEpkRERDlw+nBTmJL2HnFx0bCwsNVwj4jyydsb8PKST2lxcGDAg+gToQjYSyQSDfckfyQSCYKDg+Hj46PprpAW0NOTj+vg9BYiIiI1GRkYwM7UHADzepAOsLEBatZkwIOIRFFRURgxYgQqVKgAIyMj2Nvbo127djh79qymu0ZUKDjSg4iIKBdOZawR8S4OkZHPULlyHU13h4iIqND07NkTKSkpCAoKQsWKFREREYHjx4/j9evXmu4aUaHgSA8iIqJcVLCRT2mJDOOytUREpDtiYmJw5swZLF68GC1btoSzszPq16+PqVOnomvXrmK9FStWoGbNmjAxMUH58uUxcuRIvHv3Tnw+MDAQlpaW+PPPP1G1alWULl0avXr1QmJiIoKCguDi4oIyZcpgzJgxSE9PF7dzcXHBvHnz0K9fP5iYmKBcuXJYt25djn1+/vw5+vTpA0tLS1hZWaFbt24ICQnJtv6pU6cgkUhw+PBhfPbZZ5BKpWjVqhUiIyNx8OBBVKtWDebm5ujfvz8SExPF7WQyGRYuXAhXV1dIpVJ4enpi9+7d4vPp6enw8/MTn69atSpWr16t1Lavry98fHywbNkyODg4wNraGqNGjUJqaqpYZ/369XBzc4OxsTHs7OzQq1evHI+f8k7rgh7r1q2Di4sLjI2N0aBBA1y6dCnH+rt27YK7uzuMjY1Rs2ZNHDhwQOn5vXv3wtvbG9bW1pBIJLhx40aWfbx//x6jRo2CtbU1TE1N0bNnT0RERBTmYRERUQlW4UMy0wgGPYiISIeYmprC1NQU+/btU0r8mJmenh5++OEH3LlzB0FBQThx4gQmTZqkVCcxMRE//PADduzYgUOHDuHUqVPo3r07Dhw4gAMHDuCXX37Bpk2blAIHALB06VJ4enri+vXrmDJlCsaOHYujR4+q7EdqairatWsHMzMznDlzBmfPnoWpqSnat28vJmzNzpw5c7B27VqcO3dODJysWrUK27dvx19//YUjR45gzZo1Yv2FCxdi69at2LhxI+7cuYPx48fjq6++wt9//w1AHhRxcnLCrl27cPfuXcyaNQvTpk3D77//rtTuyZMn8eTJE5w8eRJBQUEIDAxEYGAgAODKlSsYM2YM5s6diwcPHuDQoUNo1qyZuG1gYKDW5mIpSbRqesvOnTsxYcIEbNy4EQ0aNMCqVavQrl07PHjwAGU//EGa0blz59CvXz8sXLgQnTt3xvbt2+Hj44Nr166hRo0aAICEhAQ0adIEffr0wdChQ1W2O378ePz111/YtWsXLCws4O/vjx49enCeGxHRJ8LVwQ4AEBX5TMM9ISIiKjylSpVCYGAghg4dio0bN8LLywvNmzfHF198gVq1aon1xo0bJ/7fxcUF33//PYYPH47169eL5ampqdiwYQMqVaoEAOjVqxd++eUXREREwNTUFNWrV0fLli1x8uRJ9O3bV9yucePGmDJlCgCgSpUqOHv2LFauXIm2bdtm6e/OnTshk8mwefNmMRgQEBAAS0tLnDp1Ct7e3tke6/fff4/GjRsDAPz8/DB16lQ8efIEFStWFPt78uRJTJ48GcnJyViwYAGOHTuGhg0bApAvhfrPP/9g06ZNaN68OQwMDPDdd9+J+3d1dcX58+fx+++/o0+fPmJ5mTJlsHbtWujr68Pd3R2dOnXC8ePHMXToUISGhsLExASdO3eGmZkZnJ2d8dlnn4nbWlhYoGrVqtkeE6lHq0Z6rFixAkOHDsXgwYNRvXp1bNy4EaVLl8aWLVtU1l+9ejXat2+PiRMnolq1apg3bx68vLywdu1asc6AAQMwa9YstGnTRuU+YmNj8fPPP2PFihVo1aoV6tSpg4CAAJw7dw4XLlwokuMkIqKSxbWcPQAgKpqJTImISLf07NkTYWFh2L9/P9q3b49Tp07By8tLHI0AAMeOHUPr1q1Rrlw5mJmZYcCAAXj9+rXSdJDSpUuLAQ8AsLOzg4uLC0xNTZXKIiMjldpXBBUyPr53757Kvv777794/PgxzMzMxFEqVlZWeP/+PZ48eZLjcWYM4tjZ2aF06dJiwCNz3x4/fozExES0bdtWbMfU1BRbt25VamfdunWoU6cObG1tYWpqih9//BGhocp/K3h4eEBfX1987ODgILbTtm1bODs7o2LFihgwYAC2bdumdE67d++O+/fv53hclDutCXqkpKTg6tWrSsEJPT09tGnTBufPn1e5zfnz57MEM9q1a5dtfVWuXr2K1NRUpf24u7ujQoUK2e4nOTkZcXFxSj9ERKS9nD+MJnwdE6bhnhARERU+Y2NjtG3bFjNnzsS5c+fg6+uL2bNnAwBCQkLQuXNn1KpVC3v27MHVq1fFvBsZp5QYGBgo7VMikagsk8lk+e7nu3fvUKdOHdy4cUPp5+HDh+jfv3+O22bsS259U+Qr+euvv5TauXv3rjg9Z8eOHfj222/h5+eHI0eO4MaNGxg8eHCWaTY5tWNmZoZr167ht99+g4ODA2bNmgVPT0/ExMTk/eRQtrRmekt0dDTS09NhZ2enVG5nZ5dt9Cs8PFxl/fDwcLXbDQ8Ph6GhISwtLdXez8KFC5WGOikkJSfDIIe5clR8kvg6fHL4mn96CvM1tzWXL1kbl/gGcXFvYGQkLbR9U+FJTk7SdBeomAiCgOTkJKSkvEdychLnvH9CtO19np4OpKRoV58BoHr16ti3bx8A+ZfAMpkMy5cvh56e/DvzzHkrCiLz6PkLFy6gWrVqKut6eXlh586dKFu2LMw//G4uCtWrV4eRkRFCQ0PRvHlzlXXOnj2LRo0aYeTIkWJZbqNNVClVqhTatGmDNm3aYPbs2bC0tMSJEyfQo0ePfPeflGlN0EObTJ06FRMmTBAfx8XFoXz58pAaGUFqZKTBnlFGfC0+PXzNPz2F9ZobGxrCxMAICanJiIuLgpMT59eWVAxIfRoEQUBamjywaWQkZdDjE6NN7/P0dMDQMDX3ihry+vVr9O7dG0OGDEGtWrVgZmaGK1euYMmSJejWrRsAoHLlykhNTcWaNWvQpUsXnD17Fhs3biy0Ppw9exZLliyBj48Pjh49il27duGvv/5SWffLL7/E0qVL0a1bN8ydOxdOTk549uwZ9u7di0mTJsHJyalQ+mRmZoZvv/0W48ePh0wmQ5MmTRAbG4uzZ8/C3NwcgwYNgpubG7Zu3YrDhw/D1dUVv/zyCy5fvgxXV1e12/nzzz/x33//oVmzZihTpgwOHDgAmUwm5vEIDg7G1KlTOcWlgLQm6GFjYwN9ff0sq6ZERETA3t5e5Tb29vZ5qp/dPlJSUhATE6M02iOn/RgZGcGIN1dERDpDIpHAqYw1HkSGISoqlEEPIiLSCaampmjQoAFWrlyJJ0+eIDU1FeXLl8fQoUMxbdo0AICnpydWrFiBxYsXY+rUqWjWrBkWLlyIgQMHFkof/ve//+HKlSv47rvvYG5ujhUrVqBdu3Yq65YuXRqnT5/G5MmT0aNHD8THx6NcuXJo3bp1oY/8mDdvHmxtbbFw4UL8999/sLS0hJeXl3hehg0bhuvXr6Nv376QSCTo168fRo4ciYMHD6rdhqWlJfbu3Ys5c+bg/fv3cHNzw2+//QYPDw8A8vySDx48KNTj+hRJBEEQNN0JdTVo0AD169cXlxKSyWSoUKEC/P39xYy/GfXt2xeJiYn4v//7P7GsUaNGqFWrVpboZEhICFxdXXH9+nXUrl1bLI+NjYWtrS1+++039OzZEwDw4MEDuLu74/z58/j8889z7XdcXBwsLCwQu3UrzDNNkyHNSEpO5rf+nxi+5p+ewn7N206ajmP3b2Hk8E1o3/GbQtsvFZ7k5CSt+gaY8k8QBCQkxCA5OQlWVg4c6fEJ0bb3eXo6cP9+HKZOtUBsbGyRTsnITnx8PJYvX47+/fujSpUqxd5+TlxcXDBu3Dil1WGICiIkJASBgYEYM2YMrKysAGjRSA8AmDBhAgYNGoS6deuifv36WLVqFRISEjB48GAAwMCBA1GuXDksXLgQADB27Fg0b94cy5cvR6dOnbBjxw5cuXIFP/74o7jPN2/eIDQ0FGFh8uR0ikiavb097O3tYWFhAT8/P0yYMAFWVlYwNzfH6NGj0bBhQ7UCHkRElHfR0UBYGODoCNjYaLo3cs62ZYH7QOSr/zTdFSIiIiJSk1YFPfr27YuoqCjMmjUL4eHhqF27Ng4dOiQmKw0NDRWT6wDyUR3bt2/HjBkzMG3aNLi5uWHfvn2oUaOGWGf//v1i0AQAvvjiCwDA7NmzMWfOHADAypUroaenh549eyI5ORnt2rVTWpOaiIgKz5EjwLp1gEwA9CTAqFGAt7emewU4O8h/10SGP9VwT4iIiIhIXVoV9AAAf39/+Pv7q3zu1KlTWcp69+6N3r17Z7s/X19f+Pr65timsbEx1q1bJy7NRERERSM6+mPAA5D/u3494OWl+REfro7yoEd0VKhmO0JERKQjQkJCNN0F+gTo5V6FiIioeISFfQx4KKTLgFevNNOfjFzs5UGPqDcvNNwTIiIiIlIXgx5ERFRiODrKp7RkpK8HODhopj8ZOdvaAgDexIUjPT1dw70hIiIiInUw6EFERCWGjY08h4f+h99O+nrAyJGan9oCAA5WVtCX6CFdloaYmHBNd4eIiIiI1KB1OT2IiEi3eXvLc3i8eiUf4VESAh4AUEpfHw7mlngR+wZRUaGwti6n6S4RERERUS440oOIiEocGxugZs2SE/BQcCpjDQCIiAjRbEeIiIgK0alTp+Di4pKnbbZs2YL79+8XTYeoxPP19YWPj4+mu6EWBj2IiIjUVOFDXo/IsP803BMiIqKitW7dOri4uMDY2BgNGjTApUuXlJ6/ePEiNm3aVGjtLVy4EPXq1YOZmRnKli0LHx8fPHjwINftXr58ia+++grW1taQSqWoWbMmrly5kuc6ALBo0SJIJBKMGzdOqXzDhg2oVasWzM3NYW5ujoYNG+LgwYPFfrzx8fEYN24cnJ2dIZVK0ahRI1y+fDlP+0xPT8fMmTPh6uoKqVSKSpUqYd68eRAEQe12AGD16tUIDAws0DnIrEuXLmjfvr3K586cOQOJRIKbN2/meb8MehAREanJ2a4sAAY9iIhIt+3cuRMTJkzA7Nmzce3aNXh6eqJdu3aIjIwU63Tr1g379+8vtDb//vtvjBo1ChcuXMDRo0eRmpoKb29vJCQkZLvN27dv0bhxYxgYGODgwYO4e/culi9fjjJlyuSpDgBcvnwZmzZtQq1atbK04+TkhEWLFuHq1au4cuUKWrVqhW7duuHOnTvZ9q1FixY5BgXyc7xff/01jh49il9++QW3bt2Ct7c32rRpg5cvX6q9z8WLF2PDhg1Yu3Yt7t27h8WLF2PJkiVYs2aN2u0AgIWFBSwtLbPta374+fnh6NGjePEi60p5AQEBqFu3rsrXJzcMehAREampYjn5MjJRUaEa7gkREVHRWbFiBYYOHYrBgwejevXq2LhxI0qXLo0tW7aIdVq3bo2IiAjcvn27UNo8dOgQfH194eHhAU9PTwQGBiI0NBRXr17NdpvFixejfPnyCAgIQP369eHq6gpvb29UqlQpT3XevXuHL7/8Ej/99FOWYAggH4HQsWNHuLm5oUqVKpg/fz5MTU1x4cKFYjvepKQk7NmzB0uWLEGzZs1QuXJlzJkzB5UrV8aGDRvU3ue5c+fQrVs3dOrUCS4uLujVqxe8vb3FkTzqtAPkPr2lRYsWGD16NMaNG4cyZcrAzs4OP/30ExISEjB48GCYmZmhcuXKSiNmOnfuDFtb2yzBonfv3mHXrl3w8/PL62kGwKAHERGR2lzs5SM9ol4/13BPiIiIikZKSgquXr2KNm3aiGV6enpo06YNzp8/L5YZGRnB29tbabRHYGAgJJJMa8/nU2xsLADAysoq2zr79+9H3bp10bt3b5QtWxafffYZfvrppzzXGTVqFDp16qR0zNlJT0/Hjh07kJCQgIYNG+bjyFTL7XjT0tKQnp4OY2NjpXKpVIp//vlH7X02atQIx48fx8OHDwEA//77L/755x906NAh3+1kJygoCDY2Nrh06RJGjx6NESNGoHfv3mjUqBGuXbsGb29vDBgwAImJiQCAUqVKYeDAgQgMDFSabrNr1y6kp6ejX79+eWpfgUEPIiIiNTmXlQc9XseEabgnRERERSM6Ohrp6emws7NTKrezs0N4uPKS7ZmnuFhYWKBq1aoF7oNMJsO4cePQuHFj1KhRI9t6//33HzZs2AA3NzccPnwYI0aMwJgxYxAUFKR2nR07duDatWtYuHBhjn26desWTE1NYWRkhOHDhyM4OBjVq1cv8LGqe7xmZmZo2LAh5s2bh7CwMKSnp+PXX3/F+fPn8erVK7X3OWXKFHzxxRdwd3eHgYEBPvvsM4wbNw5ffvllvtrJiaenJ2bMmAE3NzdMnToVxsbGsLGxwdChQ+Hm5oZZs2bh9evXSnk6hgwZgidPnuDvv/8WywICAtCzZ09YWFjkqX0FBj2IiIjUVP7DcjKJyfFISIjVcG+IiIg0q2PHjrh06RKio6MBAN27d891RZdt27bB1NRU/Dlz5kyWOqNGjcLt27exY8eOHPclk8ng5eWFBQsW4LPPPsM333yDoUOHYuPGjWrVef78OcaOHYtt27ZlGdmQWdWqVXHjxg1cvHgRI0aMwKBBg3D37l3x+QULFmQ5ruHDhyuVhYaqnh6r7vH+8ssvEAQB5cqVg5GREX744Qf069cPenpZb+uz2+fvv/+Obdu2Yfv27bh27RqCgoKwbNkypUBRXtrJScb8G/r6+rC2tkbNmjXFMkVgLWOuGHd3dzRq1EicSvX48WOcOXMm31NbAKBUvrckIiL6xJhKpbA0Lo2Y94mIigqFiUnN3DciIiLSIjY2NtDX10dERIRSeUREBOzt7ZXKnj59CktLyzwltOzatSsaNGggPi5XrpzS8/7+/vjzzz9x+vRpODk55bgvBweHLKMtqlWrhj179qhV5+rVq4iMjISXl5f4XHp6Ok6fPo21a9ciOTkZ+vr6AABDQ0NUrlwZAFCnTh1cvnwZq1evFlewGT58OPr06SPu58svv0TPnj3Ro0cPsczR0THLMeTleCtVqoS///4bCQkJiIuLg4ODA/r27YuKFSuqvc+JEyeKoz0AoGbNmnj27BkWLlyIQYMG5amd3BgYGCg9lkgkSmWKqVAymUypnp+fH0aPHo1169YhICAAlSpVQvPmzfPUdkYMehAREeVB+TLWiHklD3q4uDDoQUREusXQ0BB16tTB8ePHxUSVMpkMx48fh7+/v1Ld/fv3o2PHjihVSv3bSjMzM5iZmWUpFwQBo0ePRnBwME6dOgVXV9dc99W4ceMsS7I+fPgQzs7OatVp3bo1bt26pfTc4MGD4e7ujsmTJ4sBD1VkMhmSk5PFx1ZWVkq5M6RSKcqWLSsGSgrjeBVMTExgYmKCt2/f4vDhw1iyZIna+0xMTMwyYkNfXz9L4CGndopanz59MHbsWGzfvh1bt27FiBEjCpQrhkEPIiKiPHCytsGtV88RwWVrKbPoaCAsDHB0BD5MhSIi0kYTJkzAoEGDULduXdSvXx+rVq0SV93IaP/+/Zg5c6b4ODg4GFOnTs11iosqo0aNwvbt2/HHH3/AzMxMzB9iYWEBqVSKtWvXIjg4GMePHxe3GT9+PBo1aoQFCxagT58+uHTpEn788Uf8+OOPatUxMzPLkkPDxMQE1tbWSuVTp05Fhw4dUKFCBcTHx2P79u04deoUDh8+nOfjVPd4AWQ55sOHD0MQBFStWhWPHz/GxIkT4e7uLr4u6uyzS5cumD9/PipUqAAPDw9cv34dK1aswJAhQ8S+5dZOUTM1NUXfvn0xdepUxMXFwdfXt0D7Y9CDiIgoD1w+JDONZNCDMjpyBFi3DhBkgEQPGDUK8PbWdK+IiPKlb9++iIqKwqxZsxAeHo7atWvj0KFDSslNnz59igcPHqB9+/ZiWWxsbJZRFepSLIfaokULpfKAgAD4+voiOjoaT548UXquXr16YqBl7ty5cHV1xapVq8SknOrWyU1kZCQGDhyIV69ewcLCArVq1cLhw4fRtm3bfB2rOscLIMsxx8bGYurUqXjx4gWsrKzQs2dPzJ8/X5wyos4+16xZg5kzZ2LkyJGIjIyEo6Mjhg0bhlmzZqndTnHw8/PDzz//jI4dO6qcFpQXEiHjWjBUJOLi4mBhYYHYrVthnof5blR0kpKTITUy0nQ3qBjxNf/0FNVrvnjnbkzZthWNvHwwZU5woe+f8i85OQlGRtLibzg6GvDzkwc8FPT0gc2bOeKjiAiCgISEGCQnJ8HKyqHQlsikkk9j7/N8Sk8H7t+Pw9SpFoiNjYW5uXmx9yE+Ph7Lly9H//79UaVKFZV1Tp06BV9fX4SEhKi939WrV+PAgQMFGu1A2qtfv37Q19fHr7/+qumuKAkJCUFgYCDGjBkjTjfi6i1ERER5ULGcPIlb9OvnGu4JlRhhYcoBDwCQpQN5XNqPiEib7N+/H127dtV0N6iYpaWl4e7duzh//jw8PDw03R21cHoLERFRHjh/mN4S9eaFhntCJYajIwAJgAyDZ/X0AQcHTfWIiKjIZcytQZ+O27dvo1GjRmjZsiWGDx+u6e6ohUEPIiKiPHC2tQUAxMRHIi0tFaVKFd/8Viqhrl3LVCABRo7k1BYi0houLi4YN26cprtBWqB27dpITEzUdDfyhNNbiIiI8sDWwgJG+qUgQEB0NEd7fPKio+UJTJVGeegBXl4a6xKVQNHRwM2b8n+JSiAGPUiXcaQHERFRHujp6aGchRX+exOJ6OhQ2Nu7arpLpEk55fPgSA8CuLIPEZGGcaQHERFRHjlZWQMAIl491XBPSOMcHeU3shkxnwcpKEYCKQJjggxYv54jPoiIihGDHkRERHlU4UNej0gGPcjGRv7NvZ6+/LGePvN50Edc2YeISOM4vYWIiCiPXOztAACRr/7TcE+oRPD2lufwePVKPsKjqAMe0dHym2lHRwZXSjrFSKCMgQ+OBCIiKlYc6UFERJRHro72AICoqFAN94RKDBsboGbNog9CHDkC+PkBM6bL/z1ypGjbo4LhSCDSEqdOnYKLi0uettmyZQvu379fNB2iEsvX1xc+Pj6a7kaeMOhBRESURy72ZQEA0W+4egsVI+aH0E7e3sDmzcD8BfJ/mcSUtMDp06fRpUsXODo6QiKRYN++fVnqXLx4EZs2bSq2Njds2IBatWrB3Nwc5ubmaNiwIQ4ePJjjPtPT0zFz5ky4urpCKpWiUqVKmDdvHgTh44pbc+bMgUQiUfpxd3cXn3dxccnyvEQiwahRo4rkODNTp/3cjkHdOgsXLkS9evVgZmaGsmXLwsfHBw8ePFCqs3r1agQGBubr2LPTpUsXtG/fXuVzZ86cgUQiwc2bN/O9fwY9iIiI8kiR0yM6JkzpDyeiIsX8ENqruEYCERWShIQEeHp6Yt26ddnW6datG/bv319sbTo5OWHRokW4evUqrly5glatWqFbt264c+dOtvtcvHgxNmzYgLVr1+LevXtYvHgxlixZgjVr1ijV8/DwwKtXr8Sff/75R3zu8uXLSs8dPXoUANC7d+9s223RokW2gQF1zm1G6raf0zGoW+fvv//GqFGjcOHCBRw9ehSpqanw9vZGQkKCWMfCwgKWlpZq9V1dfn5+OHr0KF68yPplUkBAAOrWrYtatWrle//M6UFEOofT3amolf8Q9EhJe4/4+NcwN+eFRmoo6IcT80MQUTHp0KEDOnTokGOd1q1bIyIiArdv30aNGjWKvM0uXbooPZ4/fz42bNiACxcuwMPDQ+U2586dQ7du3dCpUycA8lETv/32Gy5duqRUr1SpUrC3t1e5D9sPv/MVFi1ahEqVKqF58+a5HpMq6pzb/LSf0zGoW+fQoUNKjwMDA1G2bFlcvXoVzZo1AyCf3hITE5PtCJUWLVqgZs2a0NfXR1BQEAwNDfH999+jf//+8Pf3x+7du2FnZ4c1a9aI56Fz586wtbVFYGAgZsyYIe7r3bt32LVrF5YuXZrjceWGIz2ISKcoprtPn8Hp7lR0jAwMUNbEHAAQGflMw70hrVAYuTiYH4KIShAjIyN4e3srjfYIDAyERCIp8rbT09OxY8cOJCQkoGHDhtnWa9SoEY4fP46HDx8CAP7991/8888/WYIOjx49gqOjIypWrIgvv/wSoaGqc3alpKTg119/xZAhQ4rlOPPSvjrHoO5xKsTGxgIArKys8tTPoKAg2NjY4NKlSxg9ejRGjBiB3r17o1GjRrh27Rq8vb0xYMAAJCYmApAHYwYOHIjAwEClEbS7du1Ceno6+vXrl6f2M2PQg4h0hmK6u+zDZ6VM4HR3KjrlrawBMJkpqaEwc3EwPwQRlSCZp7hYWFigatWqRdberVu3YGpqCiMjIwwfPhzBwcGoXr16tvWnTJmCL774Au7u7jAwMMBnn32GcePG4csvvxTrNGjQAIGBgTh06BA2bNiAp0+fomnTpoiPj8+yv3379iEmJga+vr5FcXi5yq59dY4hL8cJADKZDOPGjUPjxo3zPJLH09MTM2bMgJubG6ZOnQpjY2PY2Nhg6NChcHNzw6xZs/D69WulPB1DhgzBkydP8Pfff4tlAQEB6NmzJywsLPLUfmYMehCRzggL+xjwUEiXcbo7FY3y1vJv1yNePtFwT6jEK+xcHMwPQUQlRMeOHXHp0iVEfwjidu/ePdcVXbZt2wZTU1Px58yZM2q3V7VqVdy4cQMXL17EiBEjMGjQINy9ezfb+r///ju2bduG7du349q1awgKCsKyZcsQFBQk1unQoQN69+6NWrVqoV27djhw4ABiYmLw+++/Z9nfzz//jA4dOsDR0VGpfMGCBVmOafjw4UpluY2qUEd27atzDHk5TgAYNWoUbt++jR07duS5nxnzb+jr68Pa2ho1a9YUy+zs7AAAkZGRYpm7uzsaNWqELVu2AAAeP36MM2fOwM/PL8/tZ8acHkSkMxwdAT2JcuBDX4/T3aloOH/4hR0R9lTDPaESj7k4iEhHPX36FJaWlnlKbNm1a1c0aNBAfFyuXDm1tzU0NETlypUBAHXq1MHly5exevXqbFeRmThxojjaAwBq1qyJZ8+eYeHChRg0aJDKbSwtLVGlShU8fvxYqfzZs2c4duwY9u7dm2Wb4cOHo0+fPuLjL7/8Ej179kSPHj3EssyBirzKqf3MsjsGdev4+/vjzz//xOnTp+Hk5JTnvhoYGCg9lkgkSmWKqTkymfIXAn5+fhg9ejTWrVuHgICAAuVOyYgjPYhIZyimu+t/+GTT1+N0dyo6Lg7yoEdUZIhmO0IlU3Q0cPOm/F/m4iAiHbV//3507NgRpUqp/126mZkZKleuLP5IpdJ8ty+TyZCcnJzt84mJidDTU77l1dfXz3KzndG7d+/w5MkTOGQKTAcEBKBs2bJiUtSMrKysshxT2bJllcryco5Uyal9dY8htzqCIMDf3x/BwcE4ceIEXF1dC9TnvOrTpw/09PSwfft2bN26tdByp3CkBxHpFG9vwMtLPmrcwYH3FFR0KpaTZz+Pfv1cwz2hEufIkY85PCR68oAHP5yISIu8e/dOaQTA06dPcePGDVhZWaFChQpi+f79+zFz5kzxcXBwMKZOnZrrFJf8tDl16lR06NABFSpUQHx8PLZv345Tp07h8OHD4jZr165FcHAwjh8/DkC+4sv8+fNRoUIFeHh44Pr161ixYgWGDBkibvPtt9+iS5cucHZ2RlhYGGbPng19fX2l5JkymQwBAQEYNGhQgYMX6pzbzMeRW/vqHIM6dUaNGoXt27fjjz/+gJmZGcLDwwHIc7UUJDilLlNTU/Tt2xdTp05FXFxcoeVOYdCDiHSOjQ3vJ6joVfiwhFz025ca7gmVKNklLfXy4ocTEWmNK1euoGXLluLjCRMmAAAGDRqEwMBAAPKb9QcPHqB9+/ZivdjYWDx48KBI2oyMjMTAgQPx6tUrWFhYoFatWjh8+DDatm0rbhMdHY0nTz7m2lqzZg1mzpyJkSNHIjIyEo6Ojhg2bBhmzZol1nnx4gX69euH169fw9bWFk2aNMGFCxeUloo9duwYQkNDlYIl+aXOuc18HLm1r84xqFNnw4YNAOTLzmYUEBBQbMlb/fz88PPPP6Njx44FnhKkIBEyrglDRSIuLg4WFhaI3boV5nmY70ZFJyk5GVIjI013g4oRX/NPT1G/5m/fvYNV//4AgF27EmFkVPTfgFDOkpOTNP863LwpX5Y2s/kL5MlHqVAIgoCEhBgkJyfByspBI0tHkmaUiPd5HqSnA/fvx2HqVAvExsbC3Ny82PsQHx+P5cuXo3///qhSpYrKOqdOnYKvry9CQkLU3u/q1atx4MABpZEWpPv69esHfX19/Prrr5ruikohISEIDAzEmDFjxKV2mdODiIgoHyxNTGBiIA+qcNlaEimSlmbEpKVEpIP279+Prl27arobVEzS0tJw9+5dnD9/Hh4eHpruTp4w6EFERJQPEokETmWsATDoQRkwaSkRfSKOHz+OUaNGabobVExu376NunXrwsPDA8OHD9d0d/KEOT2IiIjyqbyVNR5EhiHi1VPgM033hkoMJi2lwhQdDYSFyUcR8VqiIuLi4oJx48ZpuhtUgtWuXRuJiYma7ka+aN1Ij3Xr1sHFxQXGxsZo0KABLl26lGP9Xbt2wd3dHcbGxqhZsyYOHDig9LwgCJg1axYcHBwglUrRpk0bPHr0SKnOw4cP0a1bN9jY2MDc3BxNmjTByZMnC/3YiIhIuzjblgUARL76T8M9oRLHxkaew4M3qVQQR44Afn7yPDF+fvLHREWAQQ/SZVoV9Ni5cycmTJiA2bNn49q1a/D09ES7du0QGRmpsv65c+fQr18/+Pn54fr16/Dx8YGPjw9u374t1lmyZAl++OEHbNy4ERcvXoSJiQnatWuH9+/fi3U6d+6MtLQ0nDhxAlevXoWnpyc6d+4sLuFDRKStoqPleRejozXdE+3k7GAHAIgKD9FsR4hI92S3EhA/sImI8kSrgh4rVqzA0KFDMXjwYFSvXh0bN25E6dKlsWXLFpX1V69ejfbt22PixImoVq0a5s2bBy8vL6xduxaAfJTHqlWrMGPGDHTr1g21atXC1q1bERYWhn379gGQLxf06NEjTJkyBbVq1YKbmxsWLVqExMREpeAJEZG2UXyBOH0Gv0DMLxdF0CPqmYZ7QkQ6JyzsY8BDQZYunzZFRERq05qgR0pKCq5evYo2bdqIZXp6emjTpg3Onz+vcpvz588r1QeAdu3aifWfPn2K8PBwpToWFhZo0KCBWMfa2hpVq1bF1q1bkZCQgLS0NGzatAlly5ZFnTp1VLabnJyMuLg4pR8iopJE8QWi7MOi5TKBXyDmh+uHoEf025ca7kkJxaFERPnHlYCIiAqF1iQyjY6ORnp6Ouzs7JTK7ezscP/+fZXbhIeHq6yvmJai+DenOhKJBMeOHYOPjw/MzMygp6eHsmXL4tChQyhTpozKdhcuXIjvvvsuS3lScjIMkpPVOFoqakl8HT45fM2V/fcMSBWUy9JlwNNQwMRMM30qbMXxmpc1NwcAvI59haSkBOjpac13CUXv+DFg4yYAMgB6wPBhQOs2uW1VIMnJSUW6f8qH19EfE7paF15+E0EQkJychJSU90hOToJEIim0fZcYZibAsK+BTT8CQjog0Qe+8ZOXf8LXura9z9PTgZQU7eozka7RmqCHpgiCgFGjRqFs2bI4c+YMpFIpNm/ejC5duuDy5ctwUBFtnzp1KiZMmCA+jouLQ/ny5SE1MoLUyKg4u0854Gvx6eFr/lFFZ8BA8nGkBwDo6wGuFQCpDp2mon7NKzo4QF+ih3RZGhITY2Ft7Vik7WmN6Ghg02YAEgAflm798WegfsMiT+xpZCQt0v1THhw58jEnhURPvpSvt3eh7FoQBKSlyQObRkZS3Qx6AEDHLvL3DVcCUqJN7/P0dMDQMFXT3SD6pGnNV1I2NjbQ19dHRESEUnlERATs7e1VbmNvb59jfcW/OdU5ceIE/vzzT+zYsQONGzeGl5cX1q9fD6lUiqCgIJXtGhkZwdzcXOmHiKgksbGR33/of/gtoK8HjBzJv6fzqpS+PuzNLQAwr4cS5iIgJuEsPFwJiIioQLQm6GFoaIg6derg+PHjYplMJsPx48fRsGFDlds0bNhQqT4AHD16VKzv6uoKe3t7pTpxcXG4ePGiWEexFnHmIct6enqQyTL9QUdEpEW8vYHNm4EF8+X/FtIXsJ+c8mXkNyKRkQx6iLQ9F0Fh5yL5FHObMPBFREQlhFZNb5kwYQIGDRqEunXron79+li1ahUSEhIwePBgAMDAgQNRrlw5LFy4EAAwduxYNG/eHMuXL0enTp2wY8cOXLlyBT/++CMAeb6OcePG4fvvv4ebmxtcXV0xc+ZMODo6wsfHB4A8cFKmTBkMGjQIs2bNglQqxU8//YSnT5+iU6dOGjkPRESFxcaGXx4WVHkbG1wIeYSIl0803ZWSQzGUaP16+Y2unr72DCUq7CkZRTjFo0RTBL4yBj60KfBFREQ6Q6uCHn379kVUVBRmzZqF8PBw1K5dG4cOHRITkYaGhiqNyGjUqBG2b9+OGTNmYNq0aXBzc8O+fftQo0YNsc6kSZOQkJCAb775BjExMWjSpAkOHToEY2NjAPJpNYcOHcL06dPRqlUrpKamwsPDA3/88Qc8PT2L9wQQEVGJ42Iv/x0U+eqphntSwnh7A15e2pWLILspGV5e+et/Ye9Pm2hz4IuIiHSKVgU9AMDf3x/+/v4qnzt16lSWst69e6N3797Z7k8ikWDu3LmYO3dutnXq1q2Lw4cP57mvRJ+q6Gj5yGZHx5Lz9230a+BtdMnqE+kGV0d5DqiowpzeUhLfRPmhbUOJcpqSkZ/jKOz9aRttDHwREZHO0bqgBxGVbIqR3DIB0JOUjJHcR44AP6yVryOhyT7pyn0sKXN1kI/0iH79onB2+KlOhygMr6OB6Lf5f5MV9pQMTvHQvsAXERHpHK1JZEpEJZ9iJLdiGVSZoPlk/WKfoNk+HTkC+PkB02fI/z1ypHjbp6JTwdYWABD1Vjno8eZNMlJT0/O2M654kX9HjgDDRwAzpuf/TaaYkqH3YZndgk7JKOz9ERERUZ5xpAcRFZqwsI8BD4V0WeGN5M7PSImi7pM6sgsGfQrT+j8FDpZWAICklHd49iwczs72iIpKwrRpl+DsbIbJkz1hYKCv3s4+9ekQOcnpA0DxJoMMgH7BcmcU9pSMT2WKB4eyERFRCcWgBxEVGkdH+fSRjEEGfb3CGcmd32kzij6lF0Gf1FUSAi9UMOmpqUiLj4eRlZVYlvzmDUqZmUFIM4BUYoQkIRmzZx/EpEk+WLnyJiIikgAA8fFpsLJSM+jB6RCq5Tblp7CDRZmnZBT0hl7Xp3hwShYREZVgnN5CRIVGMZJb/8Mni75e4YzkLsi0GbFPksLtU14oAi8ZFXfghfIvPTUV/y5ejAuTJyMpKgoAkBQVhQuTJ+PfxYthYaYH1w9TXN68eY4pUy4iIiIJdnZSLFhQH1ZWRuo3xukQWakz5UcRLMqosIJFirlpBZk2o8s4JYuIiEo4jvQgokJVFCO5CzpSwtsbqFYDiHmtmdHlGVduTJdpJvBC+ZcWH4/4Z8+QFBGBS9Omodb48bi5ciWSIiLE553L2uJu5AvoIVzMHzN+fC3Y2krz3uCnMh1CXeqM4lC8ydatAQQUXrCosJac1dapH9HRwP178v+7V1Pdd07JIiKiEo5BDyIqdIU9krswps3YWAPlHQuvT3nF+1jtZWRlhfoLFuDStGlIiojAxSlTAABSOzvUX7AARlZWsDeXT3sphXCkfNhu5cqbWLCgfv4CH7o+HSIv1J3y4+0N1KgGvI4p3IhrQW/otXXqx5EjwNq1kEeRAEAC+Ptn7TunZBERUQnH6S1EVOIV1bSZ4mZjA9SsqX39JkBqa4ta48crldUaPx5SW1u8eZOMe/+mAgCMDV9j0aIGsLOTIiJCnsz0zZtkTXRZd+Rlyo91Ib/JCjptRlunfoiJYTMOsRPkZZn7zilZRERUwnGkBxFpBY6UyL/iGFmvraP31ZUUFYWbK1cqld1cuRL1FyyAmaUVKtiVxYX/ABvbeFSvXgYLFtQXV28xM+Ov2gIr7A8AdS/YjHPTZOl5v6HX1qkfqvoNyMtU9Z0f0EREVILxLzEi0hoc8Z93+V31pqS1oUnJb96IU1ukdnZKOT0uTZuGzxcvxthv6uH3KbsRE/8KAGBrK8XixZ/DzKyU+svVUs4K6wMgr9NNCnJDr61TP1T1G5CXZdd3fkATfRIkEgmCg4Ph4+NTJPv39fVFTEwM9u3bl+99nDp1Ci1btsTbt29haWlZaH0j7cXpLUREOqogq96UpDY0rZSZGcycncUcHmWqV0f9BQsgtbODmbMzSpmZoaKDPQDgbXwk0tLkU12srIwY8Chp8jvdJL9z07R16oei30pTez5ENEt634koX3x9fSGRSCCRSGBgYAA7Ozu0bdsWW7ZsgUz2MQD66tUrdOjQocj6sXr1agQGBhZoH40aNcKrV69gYWFROJ36QCKRFCgYQ5rDkR5ERDok46j9gq56o47iaEPT9A0M4Dl5MtLi42FkJU9YKrW1xeeLF6OUmRn0DQxQ1sICRvqlkJyehtevX8LOzkWznSbVNDHdRFNTPwo650zR7/v35Y/d3XXnTU1EKrVv3x4BAQFIT09HREQEDh06hLFjx2L37t3Yv38/SpUqBXt7+yJpOz09HRKJpFACFYaGhkXWz8KQmpoKAwMDTXfjk8KRHkREOuLIEcDPD5g+Q/7v48fy6SYZ5XXVm9woVtYpyjZKAn0DAzHgoWBkZQX9D3+06OnpwdGiDAAgKupZsfeP1FTQxKT5VdxZjBUfBjOmy/89ciR/+7GxAZo0kf98ygGP6Gjg5k3dGsJGpIKRkRHs7e1Rrlw5eHl5Ydq0afjjjz9w8OBBcfRFxtEOKSkp8Pf3h4ODA4yNjeHs7IyFCxeK+4uJicGwYcNgZ2cHY2Nj1KhRA3/++ScAIDAwEJaWlti/fz+qV68OIyMjhIaGwtfXV2nqTIsWLTB69GiMGzcOZcqUgZ2dHX766SckJCRg8ODBMDMzQ+XKlXHw4EFxm1OnTkEikSAmJkaprcOHD6NatWowNTVF+/bt8erVK3Gby5cvo23btrCxsYGFhQWaN2+Oa9euic+7uLgAALp37w6JRCI+BoANGzagUqVKMDQ0RNWqVfHLL78onVeJRIINGzaga9euMDExwfz58/P7ElE+MehBRKQDVE0z2boVGORbtKve6MrKOurI7b6nvJX8oCPCQ4qvU5Q32jrdJC+0dcWYkqqwAkhEWqpVq1bw9PTE3r17szz3ww8/YP/+/fj999/x4MEDbNu2TQwGyGQydOjQAWfPnsWvv/6Ku3fvYtGiRdDX/zjtMzExEYsXL8bmzZtx584dlC1bVmUfgoKCYGNjg0uXLmH06NEYMWIEevfujUaNGuHatWvw9vbGgAEDkJiYmO1xJCYmYtmyZfjll19w+vRphIaG4ttvvxWfj4+Px6BBg/DPP//gwoULcHNzQ8eOHREfHw9AHhQBgICAALx69Up8HBwcjLFjx+J///sfbt++jWHDhmHw4ME4efKkUvtz5sxB9+7dcevWLQwZMgQhISGQSCQ4depU7i8CFRintxAR6YDsppm4VQY2by7akfWfwsIN6iRrrWBjCzy+h8iw/zTTSW2h6aV+dPGCjY4G7t/7+FgbV4wpibILILm6AEnvdXe5KqJM3N3dcfPmzSzloaGhcHNzQ5MmTSCRSODs7Cw+d+zYMVy6dAn37t1DlSpVAAAVK1ZU2j41NRXr16+Hp6dnju17enpixowZAICpU6di0aJFsLGxwdChQwEAs2bNwoYNG3Dz5k18/vnnKveRmpqKjRs3olKlSgAAf39/zJ07V3y+VatWSvV//PFHWFpa4u+//0bnzp1ha2sLALC0tFSaOrNs2TL4+vpi5MiRAIAJEybgwoULWLZsGVq2bCnW69+/PwYPHiw+fvnyJapWrYrSpUvneOxUOBj0ICLSAYppJhkDH4ppJsWxqIIuL9yQXbJWLy/lY3ZxsAMARIY/1UAvtUReV04pKrp0wR45AqxdC0Dx5pd8+MnwYVDQKTyaDlRpSnY5YP73LQBBs9cwUTESBAESiSRLua+vL9q2bYuqVauiffv26Ny5M7w/vB9u3LgBJycnMeChiqGhIWrVqpVr+xnr6Ovrw9raGjVr1hTL7Ow+/P6NjMx2H6VLlxYDHgDg4OCgVD8iIgIzZszAqVOnEBkZifT0dCQmJiI0NDTHvt27dw/ffPONUlnjxo2xevVqpbK6desqPS5XrhzuK3ImUZHj9BYiIg0pzGni2jbNRJumyOeUrDUjRdAjKpI5PVTitIvCFx2dKeCBj/9X5C4p6BSeT3l6h6ocMADEc8xrmD4R9+7dg6ura5ZyLy8vPH36FPPmzUNSUhL69OmDXr16AQCkUmmu+5VKpSqDKZllTvqpWGEm42MASqvMqLMPQfj42Tlo0CDcuHEDq1evxrlz53Djxg1YW1sjJSUl1/6pw8TEpFD2Q/nDkR5ERBqgznSJvNKWUftFcexFKadRNBm5fgh6RL95UYy90yKaWDlF14WFQTngoSAAEycBFhYF+zDILlCVeZiTrlJEk9evl1+rEj1ew/TJOXHiBG7duoXx48erfN7c3Bx9+/ZF37590atXL7Rv3x5v3rxBrVq18OLFCzx8+DDH0R4lxdmzZ7F+/Xp07NgRAPD8+XNEZwpoGhgYID09XamsWrVqOHv2LAYNGqS0r+rVqxd9p0ltDHoQURaf6kjm4qLudIn8KOmj9ovy2ItKxvuedFn2o2gqfJjvGx0Tlu1Q4E+a4lvzjDeNxbFyii5zdESWqSyA/LwWxhKzDFQpR5ONjYBvJ/IaJp2VnJyM8PBwpSVrFy5ciM6dO2PgwIFZ6q9YsQIODg747LPPoKenh127dsHe3h6WlpZo3rw5mjVrhp49e2LFihWoXLky7t+/D4lEgvbt22vg6HLm5uaGX375BXXr1kVcXBwmTpyYZbSKi4sLjh8/jsaNG8PIyAhlypTBxIkT0adPH3z22Wdo06YN/u///g979+7FsWPHcmzv5cuXaN26NbZu3Yr69esX5aEROL2FqEho09D9zDIve/opjWQuLupOl9BF2nrs3t7yhLAL5sv/VTUypfyHoEdK2nvEx78u5h5qgU9h5ZTiZmMD+PtDHvj4QFKIc9s0tcRvSaNYctitCq9h0mmHDh2Cg4MDXFxc0L59e5w8eRI//PAD/vjjD6VVVxTMzMywZMkS1K1bF/Xq1UNISAgOHDgAPT3558aePXtQr1499OvXD9WrV8ekSZOyjJQoKX7++We8ffsWXl5eGDBgAMaMGZNlNZnly5fj6NGjKF++PD777DMAgI+PD1avXo1ly5bBw8MDmzZtQkBAAFq0aJFje6mpqXjw4EGOK85Q4ZEIGSczUZGIi4uDhYUFYrduhbmlpaa7QwCSkpMhNTIqkn1r29D9jKKj5YGOzMP4N2/W/r/pivI1z+vIGF0+z7kpzmMvytc8O3b9vkJkQhxWrLiCypXrFGvbJUpOb4ro6CKbg5WcnAQjo9znkeuc6GhAkRCvMEZ4ZHTkyMfpHYqb/BLwS00QBCQkxCA5OQlWVg7FO7KqCK9hyp22vc/T04H79+MwdaoFYmNjYW5uXux9iI+Px/Lly9G/f3+tmGpCVBAhISEIDAzEmDFjYGVlBYDTW4gKlTYO3c8op2/htaH/mpCfIJe60yV0ka4fe3kra0QmxCEqKvTTDXrktkJLSZ+DpY1sbIAmTYpm39qSLKg48RomItIqDHoQFSJtDxqom7CR5AoS5PqU7yN0+djLW9vg6vOniHj5n6a7ohmfeuJLXcWbfCIi0mLM6UFUiBRBg4y0KWigbcuealpB81Mopol/iudXV4+9wof5vxFhOhT0yEuSopwSX2qiP0RERPTJ40gPokKkC0P3dflb+ILKnKagpIyM4Wo7JYeroz0AIDrqmYZ7Ukhym6qSWVGv0JLX/pQExf0G5QcCERGREo70ICpk6qzyUNLp6rfwBaFqVZuSMDKGq+2ULK6OdgCAqOhQDfekEGQ3VSWnERZFuUJLfvqjaYo36Izp8n+D9xZve/xAIKJCcOrUKUgkEsTExBRru4GBgbAs4CIQISEhkEgkuHHjRrZ1NHV8VHwY9CAqAgwa6JbscndER2s2yJVTv0gznD9Mb4mOeanhnhSC/E5VUbwp5i8o3DdFcUydKUyqgjQBAcDeIgp8aGNQiIg0TiKR5PgzZ84cTXexRJozZ47K82ViYpLjdsePH0ejRo1gZmYGe3t7TJ48GWlpaeLzp06dQrdu3eDg4AATExPUrl0b27Zty7KfmJgYjBo1Cg4ODjAyMkKVKlVw4MAB8fmFCxeiXr16MDMzQ9myZeHj44MHDx4U3gkAEBERAQMDA+zYsUPl835+fvDy8irUNvOLQQ8iolzklrtDU0GuguYUocJXwdYWABCX8AbJyUka7k0BKaaqZKTuVBU13xSpqel48yZZqezNm2SkpqYXbn80QVWQBgCCgoomEJGXoBDzohDRB69evRJ/Vq1aBXNzc6Wyb7/9Nl/7TUlJKeSelizffvut0nl69eoVqlevjt69e2e7zb///ouOHTuiffv2uH79Onbu3In9+/djypQpYp1z586hVq1a2LNnD27evInBgwdj4MCB+PPPP8U6KSkpaNu2LUJCQrB79248ePAAP/30E8qVKyfW+fvvvzFq1ChcuHABR48eRWpqKry9vZGQkFBo58DOzg6dOnXCli1bsjyXkJCA33//HX5+foXWXkEw6EFElIuSmqC2pPbrU1bG1BQmBkYAgOjo5xruTQEV5VQVyAMeixf/i8mTLyAqSh4giopKwuTJF7B43mWkXv9X+aa8iPtT6FQFaQB5YKIoIpPqBoU4BYaIMrC3txd/LCwsIJFIlMpMTU3FulevXkXdunVRunRpNGrUSGnkwJw5c1C7dm1s3rwZrq6uMDY2BiAfkfD111/D1tYW5ubmaNWqFf79919xu3///RctW7aEmZkZzM3NUadOHVy5ckWpj4cPH0a1atVgamqK9u3b41WGz1CZTIa5c+fCyckJRkZGqF27Ng4dOpTjMR84cABVqlSBVCpFy5YtERISkufzZmpqqnSeIiIicPfu3Rxv8nfu3IlatWph1qxZqFy5Mpo3b44lS5Zg3bp1iI+PBwBMmzYN8+bNQ6NGjVCpUiWMHTsW7du3x94MowS3bNmCN2/eYN++fWjcuDFcXFzQvHlzeHp6inUOHToEX19feHh4wNPTE4GBgQgNDcXVq1ez7Z+vry98fHywYMEC2NnZwdLSEnPnzkVaWhomTpwIKysrODk5ISAgQNzGz88Px48fR2io8rTeXbt2IS0tDV9++WWez21RYNCDiDRGW75sLAm5O7SpX58yiUSCcpZWAIDISB1IZlpUU1UAxMen4dmzeEREJGHatEu4e/ctpk27hIiIJDy7EYr42Quy3pQXYX8KnY0N4Dsoa3lRjU5RJyjEKTBEVADTp0/H8uXLceXKFZQqVQpDhgxRev7x48fYs2cP9u7dK+bQ6N27NyIjI3Hw4EFcvXoVXl5eaN26Nd68eQMA+PLLL+Hk5ITLly/j6tWrmDJlCgwMDMR9JiYmYtmyZfjll19w+vRphIaGKo0+Wb16NZYvX45ly5bh5s2baNeuHbp27YpHjx6pPIbnz5+jR48e6NKlC27cuIGvv/5aaaSFgkQiQWBgoNrnZvPmzahSpQqaNm2abZ3k5GQxGKQglUrx/v37HIMRsbGxsLKyEh/v378fDRs2xKhRo2BnZ4caNWpgwYIFSE9XMUoywz4AKO1HlRMnTiAsLAynT5/GihUrMHv2bHTu3BllypTBxYsXMXz4cAwbNgwvXrwAAHTs2BF2dnZZzlVAQAB69OhR4JwshYWrtxCRRigWYZAJ8tEKmRdhKGkLEJTUVW1Kar8+ZRWsbfAw6hUiw0M03ZXCYWNTJBeWlZURFiyoLwY6pky5CACwQxwWIBhWSAQEyG/Kvbw+9qGI+iMqzA+f7j3kxxAUJA8wFPXolNw+ELKbAvN/+4HByjcvRESZzZ8/H82bNwcATJkyBZ06dcL79+/FG/mUlBRs3boVth+mev7zzz+4dOkSIiMjYWQkHwW5bNky7Nu3D7t378Y333yD0NBQTJw4Ee7u7gAANzc3pTZTU1OxceNGVKpUCQDg7++PuXPnis8vW7YMkydPxhdffAEAWLx4MU6ePIlVq1Zh3bp1WY5hw4YNqFSpEpYvXw4AqFq1Km7duoXFixcr1atatSosLCzUOi/v37/Htm3bVAZPMmrXrh1WrVqF3377DX369EF4eLh4LK+yGQH4+++/4/Lly9i0aZNY9t9//+HEiRP48ssvceDAATx+/BgjR45EamoqZs+enWUfMpkM48aNQ+PGjVGjRo0c+2hlZYUffvgBenp6qFq1KpYsWYLExERMmzYNADB16lQsWrQI//zzD7744gvo6+tj0KBBCAwMxMyZMyGRSPDkyROcOXMGR48ezbGt4sSRHkRU7HJLwFlSVyQpqQlqS2q/PlWKvB4RYU803JOSz9ZWivHjaymVjccx2OLdx4LiTFZaFFM/evQAfv65+Ean5PSBkN2Um31/cLRHZtoyFJGoGNWq9fHz2uHDiLXIyEixzNnZWQx4APKpK+/evYO1tTVMTU3Fn6dPn+LJE/nvyAkTJuDrr79GmzZtsGjRIrFcoXTp0mLAQ9Guos24uDiEhYWhcePGSts0btwY9+7dU3kM9+7dQ4MGDZTKGjZsmKXe/fv30b179+xPRgbBwcGIj4/HoEEqRvdl4O3tjaVLl2L48OFi8tGOHTsCAPT0sn42nzx5EoMHD8ZPP/0EDw8PsVwmk6Fs2bL48ccfUadOHfTt2xfTp0/Hxo0bVbY7atQo3L59O9uEoxl5eHgo9cXOzg41a9YUH+vr68Pa2lrpdR8yZAiePn2KkydPApCP8nBxcUGrVq1yba+4MOhBRMUupwScXJFEjn9vay8XB3sAQJSujPQoQlFRSVi58qZS2Uq0QRQ+ziEvtmSlRTn1o6REJm1sAJ9uWcuLKs+ItmLeEyKVMk47kUjkScVkso+jxzKvXPLu3Ts4ODjgxo0bSj8PHjzAxIkTAchzgdy5cwedOnXCiRMnUL16dQQHB6tsU9GuIGT6I1LDNm/ejM6dO8POzi7XuhMmTEBMTAxCQ0MRHR2Nbt3kn8kVK1ZUqvf333+jS5cuWLlyJQYOHKj0nIODA6pUqQJ9fX2xrFq1aggPD8+SQNbf3x9//vknTp48CScnp1z7p+p8qyrL+Lq7ubmhadOmCAgIgEwmw9atWzF48GDxGikJGPQgomKXUwJOrkhScke6kHpcHOR/9ERF6UBOjyL05k2yOLXFzk6KRYsawM5OigiYYxq64w1KF2+yUnVWP9GFaGSXrgAyfQDnN7CkC+cjs5KY90QXzzN9Ery8vBAeHo5SpUqhcuXKSj82GT7Xq1SpgvHjx+PIkSPo0aOHUqLMnJibm8PR0RFnz55VKj979iyqV6+ucptq1arh0qVLSmUXLlzI45F9pBjhkJdVSiQSCRwdHSGVSvHbb7+hfPnySku7njp1Cp06dcLixYvxzTffZNm+cePGePz4sVLg4eHDh3BwcIChoSEAQBAE+Pv7Izg4GCdOnICrq2u+j1Edfn5+2LNnD/bs2YOXL1/C19e3SNvLKwY9iKjY5ZSA81NfkYQjXbSf64egR/TblxruSREqhJswM7NScHY2g52dFAsW1Ef16mWwYEF92NlJ4Vy7Asy+m168yUpzW/1EnW//teHm1MYG8Pcv+Co4RTEaoiScv7ws/VsctGnUSUl4/ahEadOmDRo2bAgfHx8cOXIEISEhOHfuHKZPn44rV64gKSkJ/v7+OHXqFJ49e4azZ8/i8uXLqFatmtptTJw4EYsXL8bOnTvx4MEDTJkyBTdu3MDYsWNV1h8+fDgePXqEiRMn4sGDB9i+fbvKhKXu7u5KI06ys2XLFjg4OKBDhw5ZngsODhZzlSgsXboUt27dwp07dzBv3jwsWrQIP/zwgzhq4+TJk+jUqRPGjBmDnj17Ijw8HOHh4WLiVwAYMWIE3rx5g7Fjx+Lhw4f466+/sGDBAowaNUqsM2rUKPz666/Yvn07zMzMxP0kJSXlekz50bt3bxgYGGDYsGHw9vZG+fLli6Sd/GIiUyLSiOzy7SkCIuvXy0d4fGorkuQ00kUXz0FJS1hbGBQ5PV7HvoJMJlM5T1erKbIQCzJ5kCBzFmI1GRjoY/JkT8THp8HKSp7gztZWisWLP4eZWSkYGOjnsodClvHDR5auHAzI7tt/RYLV6Gh5MtDgfQCEAp2XYlHQDMi5nY/8KKTrqsAUwa+MgY/immKVWVGc56JSUl4/KlEkEgkOHDiA6dOnY/DgwYiKioK9vT2aNWsGOzs76Ovr4/Xr1xg4cCAiIiJgY2ODHj164LvvvlO7jTFjxiA2Nhb/+9//EBkZierVq2P//v1ZEqIqVKhQAXv27MH48eOxZs0a1K9fHwsWLMiyEs2DBw/EFU+yI5PJEBgYCF9fX6WpJgqxsbFKy/oCwMGDBzF//nwkJyfD09MTf/zxh1LAJCgoCImJiVi4cCEWLlwoljdv3hynTp0CAJQvXx6HDx/G+PHjUatWLZQrVw5jx47F5MmTxfobNmwAALRo0UKp/YCAgCIZhVG6dGl88cUX+PHHH7Ocy5JAIpS0SVE6KC4uDhYWFojduhXmJWTZnk9dUnIypB+ySFPJFB2d/d/jeblRVtQtY5OM8o4l/zWPjpZ/mZcx8KGvJ//Cu6T9jVtQua3gU1C5vc/TU1ORFh8PowzLtyW/eYNSZmbQzzR/NS/S0tNh3KMn0gUZAgJewtraMd/7KnEUF2jmG8IScoEmJyfByEhasJ2o+vC5eVP+TXtmkyYDiYnKN6YKJei8FLrszsf8BfLcJXmVj+tKEAQkJMQgOTkJVlYOhTt3/MiRrMEvTdzAF/Z5LirF/LlQKO/zYpSeDty/H4epUy0QGxsLc3PzYu9DfHw8li9fjv79+6NKlSrF3j5RcQoJCUFgYCDGjBkjLtHLkR5EVCJltyplXm6UM9YVAIzxL/lfPH0qI12ym8ZTXF9gpqem4t/FixH/7BnqL1gAqa0tkqKicGnaNJg5O8Nz8uR8Bz5K6evD3twCL2PfIioqVL2gh7YMeclp6H9J6XdBz6WqDx9V3/4DwJLFkOfHUPH9kbrnRVte+4zyMhpCneMraddVSVkLvCSNOslJSXv9iIgyYdCDqJBo49+t2iYvN8rR0cDatR9vRWSQb1sSRwVnVlL+3i5Kmp7GkxYfj/hnz5AUEYFL06ah1vjxuLlyJZIiIsTn9TOMAMkrpzLWeBn7FpGRIXB3/zznyto0LLwk3YSp+tA9fgzYtLnwz2XmqS9Kshkwq855yfza+3STJxot6W/6nKYCZaTutV3Q60oxOqcwfwFnF3kvTuqeZ00rSZ8LREQqaN1E43Xr1sHFxQXGxsZo0KBBluy7me3atQvu7u4wNjZGzZo1ceDAAaXnBUHArFmz4ODgAKlUijZt2uDRo0dZ9vPXX3+hQYMGkEqlKFOmDHx8fArzsEjLcbWN4pGXlV3u3c96KyITgPv3s99/ScrBVlJWuCwqmk5Ya2RlJR/hYWeHpIgIXJwyBUkREZDa2aH+ggVKU17yo4KNPK9H5Mv/cq5YEleKyIniJqygSTALSlVyx+hoYOOmojuX3t7At/9Tv75MBly7lv3zql774GBgyBDt+CXi7S2fvjB/geqEs3m5tgtyXZ3+W/laCN5bsOMqaXI7zyVBSflcICLKhlaN9Ni5cycmTJiAjRs3okGDBli1ahXatWuHBw8eoGzZslnqnzt3Dv369cPChQvRuXNnbN++HT4+Prh27Rpq1KgBAFiyZAl++OEHBAUFwdXVFTNnzkS7du1w9+5dGBsbAwD27NmDoUOHYsGCBWjVqhXS0tJw+/btYj12Krk0PUz/U6K4Uc6c76IwbpSLOr8EKSvINJ7CGlUltbVFrfHjcXHKFLGs1vjxkH5IRFoQznby30kRr/7LucPaOCxc00ORsruZ/vZ/kI/pypBMrrDPpXs1FdNcJICenuoRIDn9MlD12quzXUmS02iIvF7b+bmuXr8GAgIBGACQyNsLCJBHvHv0yNuxlGQlYdRJbjT9uUBElAOtGumxYsUKDB06FIMHD0b16tWxceNGlC5dGlu2bFFZf/Xq1Wjfvj0mTpyIatWqYd68efDy8sLatWsByEd5rFq1CjNmzEC3bt1Qq1YtbN26FWFhYdi3bx8AIC0tDWPHjsXSpUsxfPhwVKlSBdWrV0efPn2K67CphMvL6AMqGPHLpA8jBPQk2d8oV3OXz7TPSAIg08phALhMrKYovsBcMF/9LzALc1RVUlQUbq5cqVR2c+VKJEVF5X+nH1QsJ4/ERT+4kfNyk7ktk1pSaXIoUnY305Agy581mc9lQYdzqfpG299ffgH7fZ21fk5Lnap67TNud/asdn8IOToiy6ewJJcodV6vq/BwyANdmQQFafe501a6PkSRiLSW1gQ9UlJScPXqVbRp00Ys09PTQ5s2bXD+/HmV25w/f16pPgC0a9dOrP/06VOEh4cr1bGwsECDBg3EOteuXcPLly+hp6eHzz77TFyHOaeRHsnJyYiLi1P6Id2l6WH6JZ2mpozY2MjvRcQACeSPs/vClYErzcjL38iFGZxKfvMGl6ZNE6e0NFi0SJzqcmnaNCS/eZP3nWbg4mAHAIh69Tjn4f0cFp532QWK3N2B4cOyP5eqpsTkh6rpBjY2QOPGeQtgZX7tM/t5s+7NlyzsBQPt7aHyT1mBH+BERPSR1kxviY6ORnp6Ouzs7JTK7ezscD+bSfrh4eEq64eHh4vPK8qyq/Pff/L52HPmzMGKFSvg4uKC5cuXo0WLFnj48KG4DE5GCxcuVLm+dFJyMgySk9U5XCpiSYX4OpiYAV8PA37cBKQLgL4E8PtGXp70ib/cx44DmzbKv4fTAzBsONCmdf73F/0a+GHtx+/10gVgzTqgWg3Axjpr/abN5c+FhwOWVslwclD9mpSxkY+Gzvh9ob4EsLTma1iS/PcMSFURnHoaKn+/ZZbT+zzd0BAG5csjWRBQc84cGNvYoOacObgyezYMypdHqqEhZAX4nLCzsAAARCMRycgw7UGWDoQ+BcxMPpY1bwrUqCa/UO3tAWsbIDkp323rPDMTYNjXwKYfASEdkOgD3/gBZiZIbtIYqF1b+VyGPQcePADW/gDxXS6kA+vWyM+7dT4CTGYmgFll+f8Vr1UO/cr29VS89gf+Avb/iSyjFgraT0169h+AtKzlma//fBIEAcmmpZHSsxuS9/wfJBlHlUj0AWtLvo90VLKWva7p6UBKinb0WRAErFy5EmvWrEFERAS8vb0RFBQEiw+/0zLXHTZsGHbv3o23b9/i+vXrqF27dvF3ugRo0aIFateujVWrVmm6K5+MvJ5zrQl6aIpMJv8DZPr06ejZsycAICAgAE5OTti1axeGDRuWZZupU6diwoQJ4uO4uDiUL18eUiMjSI2MiqfjlCtVr0V+cwV06Qg0rM+prBlFRwObN8kHNyu+x/z5R/l5yu/5eRutvD8AgADEvAbKZ7MqaHlH+U9SsurXXFFnjH/W/BLZ7TMvNLmqT0HbLmkrElV0BgxU5HRxrQBIs/lozfYz18gIDaZORVp8vJi0VFquHJovWYJSZmb5Xq5WoUq5cgCARKQiHTKUxof96ekDFVwBI6nyBo7l5T+kno5dgPoNVX7oGplbfTyXGVcPyfzpIQB4HVO4571jF8CtKnD3HlC9GuBWJfdtHMsDXw8HfHrJp7T8vFn5+aLoZ3FwrghIDLKu6KHq+s8HQRCQlpYMdPaBkakdJFu3yttSjPDRtvOlSkn7EC5BjArhGiou6emAoWGqpruhlokTJ+KPP/5AUFAQTExM4OPjgzlz5mBlpqmgAHDo0CEEBgbi1KlTqFixImw+4Wt07969MCjg3w2ZbdiwARs2bEBISAgAwMPDA7NmzUKHDh1y3G7dunVYunQpwsPD4enpiTVr1qB+/fri8wsXLsTevXtx//59SKVSNGrUCIsXL0bVqlXVbvf06dNYunQprl69ilevXiE4OLjEL/KhNUEPGxsb6OvrI+LDcoIKERERsLe3V7mNvb19jvUV/0ZERMAhw/DTiIgIMVKpKK9evbr4vJGRESpWrIjQ0FCV7RoZGcGIwQ2tU9BEltqQZ6w4FcWSpEWZyLQocrBpMjlqQdsuiYldC5L8VBV9A4Msy9IWdNUWBVOpFJbGpRHzPhFRkhQ4CwYlZupKamo64uPTYGX18ffUmzfJMDMrBQODbKZalES5fehmTniaWVHkTinI8sOKKTJbtujG0p/Fudxqjx5A8+a69c2DNi1lTTrh4sWLWLFiBa5cuQIvLy8AwNChQ7Ft2zaVQY8nT57AwcEBjRo1ynafKSkpMDQ0LLI+lxSqRv4XlJOTExYtWgQ3NzcIgoCgoCB069YN169fh4eHh8pt1Fn04++//8aoUaNQr149pKWlYdq0afD29sbdu3dhYmKiVrsJCQnw9PTEkCFD0COfSaOL+9rQmpwehoaGqFOnDo4fPy6WyWQyHD9+HA0bNlS5TcOGDZXqA8DRo0fF+q6urrC3t1eqExcXh4sXL4p16tSpAyMjIzx48ECsk5qaipCQEDg7Oxfa8ZFmMZFlVgXNxZHXXCfqtKf4G1pf7+P+CvNv6MLMwVaY11ReX4uCtl2S3w/5SX6qKU6W8jlXkWO+LjHLTaampmPx4n8xefIFREXJh1tHRSVh8uQLWLz4X6SmZl6BRItluzoKiuYGvDCWH7axAVq2VC5r0UJ7buIzf1gV53KrupREU9uWsiadsGzZMrRu3VoMeADyKf/RKq47X19fjB49GqGhoZBIJHBxcQEgn3Lg7++PcePGwcbGBu3atQMgz3c4ZswYlC1bFsbGxmjSpAkuX74s7q9FixYYPXo0xo0bhzJlysDOzg4//fQTEhISMHjwYJiZmaFy5co4ePBgtv3funUrrK2tkZxpaqqPjw8GDBiQ47EfOnQITZo0gaWlJaytrdG5c2c8efIEABAVFQV7e3ssWLBArH/u3DkYGhqK95AtWrTAuHHjxOd3796NmjVrQiqVwtraGm3atEFCQkKOfcisS5cu6NixI9zc3FClShXMnz8fpqamuHDhQrbbqLPox6FDh+Dr6wsPDw94enoiMDAQoaGhuHr1qtrtdujQAd9//z26d++u9vFkd23kdO4VEhISMHDgQJiamsLBwQHLly9Xu10FrQl6AMCECRPw008/ISgoCPfu3cOIESPENwMADBw4EFOnThXrjx07FocOHcLy5ctx//59zJkzB1euXIG/vz8AQCKRYNy4cfj++++xf/9+3Lp1CwMHDoSjo6M4RMfc3BzDhw/H7NmzceTIETx48AAjRowAAPTu3bt4TwAVGSayVFYYK2TkJUCRl/YK86a3KJOsFtY1lZ/XoqBtl/T3g7bc25T/0MHIhDclpsPx8Wl49iweERFJmDbtEu7efYtp0y4hIiIJz57FIz5eRQ4GbaUq4alED5g0uWhuwHNaolVd0dHAyZPKZadOAY8eaiYjdF5klyhWW96wJUlhXEtEeZCcnIy//vory03s+/fvVebzWL16NebOnQsnJye8evVKKYARFBQEQ0NDnD17Fhs3bgQATJo0CXv27EFQUBCuXbuGypUro127dniTIWl4UFAQbGxscOnSJYwePRojRoxA79690ahRI1y7dg3e3t4YMGAAEhMTVR5D7969kZ6ejv3794tlkZGR+OuvvzBkyJAcjz8hIQETJkzAlStXcPz4cejp6aF79+6QyWSwtbXFli1bxPvI+Ph4DBgwAP7+/mjdOmuiulevXqFfv34YMmQI7t27h1OnTqFHjx4QPiRyDgwMhESSeX3BnKWnp2PHjh1ISEjI9sv+/Cz6AQCxsbEAVI9WUafdvFB1beR07hUmTpyIv//+G3/88QeOHDmCU6dO4dq1a3lqW2umtwBA3759ERUVhVmzZiE8PBy1a9fGoUOHxESkoaGh0NP7+AdOo0aNsH37dsyYMQPTpk2Dm5sb9u3bhxo1aoh1Jk2ahISEBHzzzTeIiYlBkyZNcOjQIRgbG4t1li5dilKlSmHAgAFISkpCgwYNcOLECZQpU6b4Dp6KVFFOm9A22X3L7+WV979Z1Zkykp/2CmMqUVFP3yiMayq/r0VB2+b7oXA4fxhKGvHySS41i4+VlREWLKgvBjqmTLkIALCzk2LBgvpKU160XnbTK5o0KZr2FEGWgkxNye5m99uJJXuaQ3YjE/Lzi4MK51oiyoNr164hKSkJ//vf/zBp0iSxPDU1FS0zjz6DfLVLMzMz6OvrZ0kz4ObmhiVLloiPExISsGHDBgQGBop5IX766SccPXoUP//8MyZOnAgA8PT0xIwZMwDI8yMuWrQINjY2GDp0KABg1qxZ2LBhA27evInPP/88S5+kUin69++PgIAA8YvpX3/9FRUqVECLFi1yPH5F3kaFLVu2wNbWFnfv3kWNGjXQsWNHDB06FF9++SXq1q0LExMTLFy4UOW+Xr16hbS0NPTo0UOcFVCzZk2lc6fIn5GbW7duoWHDhnj//j1MTU0RHByslHIho/ws+iGTyTBu3Dg0btxY6f44L+3mReZrA8j93L979w4///wzfv31VzHIFBQUBCcnpzy1rVUjPQDA398fz549Q3JyMi5evIgGDRqIz506dQqBgYFK9Xv37o0HDx4gOTkZt2/fRseOHZWel0gkmDt3LsLDw/H+/XscO3YMVaooJx4zMDDAsmXLEBERgbi4OBw9ejTbuVSknYp62oQ2Kexv+XP7kk8TowqKY/pGYVxT+T03BW2b74fCIS5bG/lMwz1RZmsrxfjxtZTKxo+vBVvbEpoYsCBDsop7ekVBlx9WNToFKPxpDoU9zI0jEwpXXq4lTa0LTzrl4cOHMDExwa1bt3Djxg3xx8XFBY0bN87TvurUqaP0+MmTJ0hNTVXaj4GBAerXr4979+6JZbVqffy9pK+vD2tra6VggeJmPjIyMtu2hw4diiNHjuDly5cA5KMqfH19xZEV27Ztg6mpqfhz5swZAMCjR4/Qr18/VKxYEebm5uJ0nYz5G5ctW4a0tDTs2rUL27ZtyzZ/o6enJ1q3bo2aNWuid+/e+Omnn/D27Vvx+e7du2cbhMisatWquHHjBi5evIgRI0Zg0KBBuHv3rlrbqmPUqFG4ffs2duzYUSztZr42gNzP/ZMnT5CSkqJ0z29lZaV24EhBq0Z6EBWlokhkqY2K+1t+TYwqKIokq6oU9JoqyLkpaNt8PxScq6P826+oaNVJr/OtgCs6REUlYeXKm0plK1fexIIF9Ute4KMwkjkWZ5bpgr5xMo9OyfxtP/AxmJDfYyqKBJmqRiZI9ADjXEYOcXWS7KlzLTHZKRWSuLg42NjYoHLlymLZs2fP8OjRoyzfxOfGxCR/S1JnXv1EIpEolSkCFxmnPWT22WefwdPTE1u3boW3tzfu3LmDv/76S3y+a9euSjfP5T6stNalSxc4Ozvjp59+gqOjI2QyGWrUqIGUlBSx7pMnTxAWFgaZTIaQkBClgExG+vr6OHr0KM6dO4cjR45gzZo1mD59Oi5evAhXV9c8nBF5TkvFa1KnTh1cvnwZq1evxqZNm7LUzeuiH/7+/vjzzz9x+vTpLKMm8tJuXqi6NtQ594VB60Z6EBUlbZl6XJRf7BT3t/yaGFWQ1ySrBVGQa6owRmwU5HrWlvdDSeViJ5/eEv32ZcF3pnjTB+9VnTdBTW/eJItTW+zspFi0qAHs7KRijo83b5Jz30lx0YZkjqo+jAv6xsk4OmXZ0qwjPwoyzaGozmnmkQmKfX87MftrNLscIPRRTteSNrw/SGvY2NggNjZWzDsBAPPnz0fHjh0LPK2hUqVKYh4HhdTUVFy+fLlQpkxk9vXXXyMwMBABAQFo06YNypf/uHy1IiGq4kcqleL169d48OABZsyYgdatW6NatWpKIzMAeb6Mr776Cn379sW8efPw9ddf5zjiRCKRoHHjxvjuu+9w/fp1GBoaIjg4uMDHJpPJsiRqVVB30Q9BEODv74/g4GCcOHFCrUBMTu0WhDrnvlKlSjAwMMDFixfFsrdv3+Lhw4d5aosjPYi0THEsJVrc3/IXd3uFvfRpUdLGERf88laugq0tAOBtfCTS0lJRqpRBLltkI+O3uRnlI2+CmVkpODubAYA4skOR48PZ2QxmZiXoz4KcpkyUhAurKL9lzzg6pTCXfS3Kc+rtDbi6fMw/AmR/jRZVDpBP6cOnpL8/SKu0atUK79+/x6JFi/DFF19g27Zt+L//+z9cunSpwPs2MTHBiBEjMHHiRFhZWaFChQpYsmQJEhMT4efnVwi9V9a/f398++3/s3fm8VGU9x9/74aQBAiBkJAQjoAQDAqKEUGUqigC9eDybG1JENSq1AKCHIL1xAIqiFDQoiRYr2rlsFZFUWpVBBWVnwXkkEOFhCxnhBBCsr8/JrM7OzuzO7M7uzubPG9fvOLOzjzzzDPPzM73M99jIn/7299YtmxZ0PVbtmxJq1ateO6552jTpg179+5lypQpPuvcf//9HD16lPnz59OsWTP+/e9/c+utt/Kvf/3Lr73169ezZs0aBg4cSOvWrVm/fj3l5eV069YNgOXLlzN16tSgIS5Tp07l17/+NR06dKCiooKXX36ZtWvX8t577wGwYMECli9f7iNyTJgwgcLCQnr16kXv3r2ZN2+eT9EPkEJaXn75ZVauXElqaiqlpaWAlGskJSUl6H4BfvnlF3bs2OH5vGvXLr755hvP+TWKkbFv1qwZo0ePZtKkSbRq1YrWrVtz//33++TxNIKNnm4EAkEwrEwyGgw9j/BIPVNG0wMd4ktMiPbYhEM0RLl4oXVaGkkJjaiqOc3Bgz+TldXRfCNq41CNSSMnMTGByZPPpaLitCdpaWZmCrNmXUhqaiMSExOCtBBF7JzMMZqJO628WUV6TCtPGjPEI2GwN7RQDztfH4K4Iysri+LiYiZNmsQjjzzC5ZdfzieffOLjJREOf/nLX6itreX3v/89FRUV9OrVi/feey8iRSHS0tK47rrrePvttz3VOAPhdDp59dVXueeee+jevTtnnnkm8+fP9yQ/Xbt2LfPmzeOjjz6iefPmALz44ouce+65LFq0yFPVU6Z58+Z8/PHHzJs3j2PHjpGbm8uTTz7pSeJ69OhRvv/++6D9OnDgACNHjmT//v2kpaVxzjnn8N5773HllVcCUuJSdWnXYEU/ABYtWgTgl9x16dKlFBUVBd0vwJdffumT4HbChAkAFBYW+uXXDESwsZeZM2cOv/zyC9deey2pqance++9nqozRnG4lX5Mgohw7Ngx0tLSOLpsGc1btIh1dwRAZVUVKToJiOzMpk1S6VI1Mx+TPGAjTTwbtPF6zuMJl0vyUlfnIFmyJDaijR3O+RlFo9l1qJyZM/9D9+6XmG9g0ybJ/V8PZ0LsBjgarF7t7+UQ4KZTVVVJUlIU8pLonZfHZkbnZgyhK9Amx9RUP0C6CagNcfUclW8WwdYLsC+3283xH76nKj2N9BbZOMaMMd9evGP1uYwTonadW0RNDWzdeoypU9M4evSox3COJhUVFTz55JP89re/9SvYUB+54oorOPvss5k/f36suyKIAbt376a4uJh77rnHU4pXeHoIBHFELEuJRtPLJN5pSB7WSqKVIDaeaJfeil2Hyikr3RWa6KH1NlcmzFCH6uoaH48PkHJ+2Mrjw64uWbF+yx6OV4OVY6rVDyPhOHrlhAP1xSfMywG4gbpEd8NubJihHna9PgSCGHH48GHWrl3L2rVr+etf/xrr7ghshBA9BII4Ipa5KIRBa4x49oYJl1iKcnYlN6M1/92xlfL9u0JrQMs4HDkS8vLCMnKqq2uYNetb9uyp8OT2KC+v9OT2mDz5XPsIH3aM7wrFaLcKK0JrrBhTvX4sWSL9C2aImzHY/cK83HX/AGphxcqGG+phx+tDIIgR5513HocPH2bWrFmmS5oK6jdC9BAI4oxYvdgRBm1wtLxhFi6Ejp2ga15s+xYN4ilBbLTokC1VcCnb/0PojUTgoq+oOM2ePRWeqi3jx5/D3LmbKCur9Hyfnm4T0cOuxOpmbJcElnr92LoVmjc35upm1GDX2pfvjqHn+fD1Ru+iyy5r2DcfgaABsnv37lh3QWBThOghEMQhsXixIwza4Gh5w9S6YdJEazw+4iFsRnhb+3JGTjYArvK94TVk8UWfnp7kqdpSVlbJlClSKbisLKmaizLkRRCAWNyM9UKetm+PbD4R9Q1Iqx8OJ8yeDbitTSYaKMwLACd8843vorVr4Xe/EzchgUAgEGCu1otAIGjQDBwoeS3PfEz621DCNowie8OokfOfuFyht716tZT37/7p0t/Vq0NvK9JkZEi2l7A1oGMbKWN6+cEfY9wTfzIzUxg//hyfZePHn0NmZvwkCGyQZGRAUaH/8mXLwrvJBEK+AU2/33sDkpVwZ51HkDMB3IqwEzncxYo+qfflcCLl9QBwwrCh+t4vAoFAIGjwCE8PgUBgChE+rI/8XK4McZEJlv8kkBeHSCIbv+RmZgJw8Og+3G43DoeGKmYlJtyByssrmTt3k8+yuXM3eXJ8NAjs6j4VrF+du/gvi1SIS6AcIkrXrqNH6rw8ItQntRuZ2w27tkHL5tAiG1auapg5PQQCgUAQFCF6CARxgl2fzQW+DBwo5fCYNNF4/pNgyU9FEtn4pV3dCaqqPklFxUGaN4/gCTNR0ePQoSpPaEtWVopPTo9p0zYwa9aF9T/EJZwKKLHuVzSrxxjJ3dGjh/QjFWqfjP7AKVV3txtSGkFVJaTHMLGsQCAQCGyPCG8RCOKAeAptMIrLBZs2Rc4bO5Z0zZOevxPq7rCB8p/oeXEox0UrbEYkkY0Pkhs3pnXT5gCUh5vXIxB6b+N1LrDU1Ebk5qZ6cnicdVZLZs7sTVZWCrm5qaSm1vN3IibHy3b90gotiZSRLwssPjhgzpzg4S5G+qQVOhMKcvzlYzO98Zf1+YdGIBAIBIap5081AkH8Ux9DGxpCWVejCT2NeHGIJLLxTbuW6Rw4fowDB/bQuXNBZHZisqJHYmICkyefW1elRfLoyMxMYdasC0lNbWSfcrWRwi4VUNQE65fSIyJSWYPVXhfq8rwOp+RlESzcRatP6ratKL+rROkJYldPnmgj3EQFAoFAiB4CQSwx8iwSydCGWDwLWSHixMsznJH8J0ZLAYuqKPFLh4xMNv60m7KffcvWVlfX+IgOIIWdhCQ6hBDukJiY4FeW1rKQFisu0ki2Ec3wEDME6peeEW/lzUBvH2Zyd+jd+LTazs6OjPhktZgSaSL1oyaEH4FAIACE6CGoZ8SLMQzGvR2MGsWR2r/VhCvi1DcvETNeHCKJbHzSoXVrAMr2eUWP6uoaZs36lj17KjyJQ8vLpXwaubmpTJ58rjnhQ/02PpY5DawwtCLdhp3GS4levyC4ER/uD2AwoUD+F0ruDr2258yOjPhkV08eLSIlTMSb8CMQCAQRRIgegnpDPBnDZrwdIhHaEMuQmXBEnPoY6gPCi8Mq7Cp6dsrJBsBVvsezrKLiNHv2VHgShyoTicrfq70wgmKHiWSFoRWtNuwwXlpo9WvTpsBGvBWGs1GhICMDCguhpERa34hgpNf2yarIiE929eRRE0lhIp6EH4FAIIgwQvQQ1AvizRg26+1g9bN5LKuBhCPi1OcqJvXdiyPSgoSW6PmrS63fTyh0yskCoNzlTWSanp7EzJm9PRVUpkxZD+BJLBpymEmsJ5IVhlY024j1eOmh7lcgI94qw9moULD8Ta/g4XBC4cjgAkugtnv0sF58sqsnj5pIChPxIvwIBAJBFBDVWwT1gkDGsB0JpRpHRob0bGjFM1usq4HISfZnPuZNsm+EWPdbEBqRrj6kWwHnoLX7CZXcuvAW15GffZZnZkqlYpWMH38OmZkpUeub5WhV+nA4pTwQRitoaLVh1lizoo1IEGo1kUCVUQIZzlbtQ+bNN2HpUl+BpWRZ8OMJ1raVP3AyWtVc7EYk52k0K/wIBAKBzRGeHoJ6QaTyXkSKWFfjiPX+5T6Y3Z8d+i0wRzS8sPREz9JSaJ9jzT7CoUNmJgDHjh+iqqqSpCRJ1Cgvr2Tu3E0+686du8mT4yMuUb9hxyFV+pg923jYhRVv6e34pj/cEBQ9l79w3uirXbACuRW6XFBc7N+GUc+EWIQT2dWTRybS89SuIVwCgUAQZYToIagXxKMxHOtnkVjvP1Titd8NlWiEJOmJntnZ1rQfLi2bNaNJYmNOVJ/C5fqRtm27cuhQlSe0JTMzhXvv9eb0mDJlA48/fgGtWzeJdddDQ75It26FOXOCh11oxT5ZcaGbbSOSMVhWhaBoGfGhGs6BqsFobbtvH+D2X+4w8YbBLiKEnRIARfpHzS5jLhAIBDFEiB6CekM8GsN2eBZxazzD2h0rxy3az75m92enZ/NQiIYXlq7o2cq6fYSDw+GgXYtWbCvfT3n5Xtq27UpqaiM6dGjG4cOncLvdZGYmM3NmbyZP3sDRo6d49tktTJnS03zpWruQkQHNmwfPVxCswkq4k95oG2a9MMxemJFOKhmKwGNWhNHyKAEoKoyvm5Mdy7ja4WFAIBAI6jFC9BDUK8Rzg3HiqdpNOMi2ScsM/1CHaI+B2f3Vh3MULS8sLZuvssrafYRD+3RJ9Cjbvwt6QmJiAnfc0Y0pUzbgcp30VHChtpZTp2rYu+tYaBVc7ESwsAu7lNQ0249QjGY9wWDHdimXhRWY+QEMRYRRe5Q4nFIVl+Ejwut3NLHLnFP3KZ6VbYFAIIgDhOghEDRA4q3aTagoRQM3cM9Yr20S7TEwu79o9S8az9vR8sKys+iZ27o1fA8H9v3gWda6dRNmzerjX8GFY8x0rST9y+r4U7mUBAu7sEtJTTP9CNVozsiQBILipb7LS5bBry7R3k8kL8xQ84DEo0ulErvMORk7ep0IBAJBPUSIHgJBA6Q+l36VbYXkFJVogK9tEqzij9X2htkxj8Y5iqYniZ0FiWiQmy2VrT1QustnuVzBRRY8AMbzAZkcqx9KZCAj2S4lNc30IxyjuUsX/2Va20bDEA4ngWY8X8xmznWkhSc7ep0IBAJBPUWIHgJBAyTeqt0YRW3EBxIN9MZg+3aYPt16IcDsmEf6HDUUbx+70ClHyqrqcu31Wa5ZwYUBzGQ5mbW/1A8lUs9IjnaFFT0jVu6H0gCtrYWNG/0v/nCEGiPbRtMQtlOiVzPI/WjTBlJMPsYanXORFp5cLvjkE3t5nQgEAkE9xhl8FYFAUN+Qn/sS6u4A8VDtJhhaRrwapWigNQYjC6GkxF8IcLnC75/ZMY/0OQrm6WIHXC7YtMma8Y81HbNbA1B+6CfPMmUFl6yMJP7CcrI4RhnNmcZwDjmaxb8SqUTrhA4cCEuWwGMzpb+RcjVavRpGj4bp90t/V6/2/b6gQJXVWefily9MZ12uFbMeEsG2DeRJEgkyMqScIkYqvQQaP5lIX7Tqfnz4ofk2gs05PeHJqmOSj+GF5/2/i4Wnk0AgEDQAhKeHQNBAiVVodqReFmoZ8eD1lkhw+NsX6jGIdEiJ2TGP5Dmyu7dPfUjiqiS3tSR6HDy6n9raWpxOJ6mpjcjNTQVg5szeZH5dzcyFJUxzDyWXg6TeOSq+lUglka7SEggj3hNa5ViVb92VN65AF6beDU5eXlAgGdp6F3WoniRW3VjV7bhcsHWLMe+TaHhHKPtBLTz/PHTrCukmb1yB5lwk8374HYOCSHs6CQQCQQNGiB4CQQMm2qHZkTRk9Yz42XOg6iS0aOVfvQX8xyAa5VXNjHmkzlG0qqqEQn0MvWlcm06Cw0lN7WkOHy6lVascEhMTmDz53LoqLUkwcCCZBQXM2vYTqWe0JTE7M9bdtoZY5y4wYsQGEhv0jHmjIRFmxIBQQn6sEhvU7fTvDx99pG2gq8cvGudY6zy6a+DAAdBIlxIykcw1o3UMAKPHwMUXx+8NTlCvueyyy+jZsyfz5s3TXadjx46MGzeOcePGGWrzwQcfZMWKFXzzzTcAFBUVceTIEVasWBF2fyONuu+C+ECEtwgEgqigZ8gG8xg26i2tFw7SNa/Oe7tV8D4aCSmpTyEXspf3zMciG1lglngIvTHD6tVwx+0JpLjTAHj7bW9ej8TEBEnwkMnIIP2invVH8IDoh2yokY1YJWojVi/0BIyFOugZ/V9sMB8qYTTkx+WCT/5rTSiGVv8/XKNtoIP/+EXjHGudR0cC1HlRWUawMKRwfgT05qIQPAQxpqioCIfD4fdvx44dvPnmmzzyyCMR3f/TTz9NcXGx5/Nll11mWECJJA6Hw0+ImThxImvWrIn4vh988EF69uwZ8f00FISnh0AgiAqhhI6Y9QyxIhwkUBvq/hQWwYjh5vdhJ0LxJIlGNU07h96YQSn2NaUVv3CYN97YzVVXXdhwbJxoVmk56ALXYd/JadR7Quvi37TJWKiDntH/yKMEDJvRI9iFqfTKUBNKKIaeB4IWWuMXyXOsvOEoz6MjAUaPgnQDirZZ9H4IwvWqiXbyXoHABIMHD2bpUt+y2pmZmSQkJER832lpaRHfh1U0a9aMZs2axbobApMITw+BQBAVZENWSSBDNlTPEKN5+cy2odWfpUvhzTdD3088Iufgu3964HyG4VCfEu0qxb4UJO+NBH6IW6+VkAgn+acZVq+GP9ypnWzTqPeE+uI34iWitx7gJ3jI2ycnhe4tECgvhF7/lNtq7TcnB3BobuLB4YT7JmuPX6TOsTpxKfiex8svD6/9QKjnglUJTgPNxfrkSiiIO5KSksjOzvb5l5CQ4Od1ceDAAa699lpSUlLo1KkTL730kl9bR44cYcyYMWRmZtK8eXMuv/xyvv32W919FxUVMWzYMM///+c//+Hpp5/2eJzs2rWLLl268MQTT/hs980333g8UvRYsmQJ3bp1Izk5mfz8fP761796vjt16hRjx46lTZs2JCcnk5uby+OPPw5IITsAw4cPx+FweD6rPTDkvs+cOZOsrCxatGjBww8/zOnTp5k0aRLp6em0a9fOT1CaPHkyXbt2pUmTJpxxxhnMmDGD6upqAIqLi3nooYf49ttvPWMge8IEG9tvv/2W/v37k5qaSvPmzTn//PP58ssvdcenoSA8PQQCQVQwm0Mi0klFzaKXKLWkBC65JD4NcrNEM9dGKLki7YjSayUZyQ2/ET/Yz2sl0oMa6czJ8uSkFkjQzikRzHtCawyMvplXr6f2epBxOOGyy2DipNC9BQJ6ZWhkbJYJlkx2+DBYvlynWScUFkK/fvr9svoc64kMS5ZIYoTbDcePhLcPM1iZ4FRrLkY6EaxAYBFFRUXs27ePjz76iMTERO655x4OHDjgs84NN9xASkoK77zzDmlpaTz77LNcccUVbNu2jfT09IDtP/3002zbto3u3bvz8MMPA5LHya233srSpUuZOHGiZ92lS5dyySWX0KWLdmKfl156iQceeIAFCxZw3nnn8fXXX3PbbbfRtGlTCgsLmT9/PqtWreIf//gHHTp04Mcff+THH38E4IsvvqB169YsXbqUwYMHB/R4+fDDD2nXrh0ff/wxn376KaNHj+azzz7jkksuYf369bz22mvccccdXHnllbRr1w6A1NRUiouLycnJ4f/+7/+47bbbSE1N5b777uOmm27iu+++49133+WDDz4AvN4wwcb2lltu4bzzzmPRokUkJCTwzTffkJiY6Omrw+Fg6dKlFBUVBTwP9Q0heggEgqhh5pk4UiEOodp2Wv0B6XOshJhoE20hSmkXyOdtxw5vWeF4qOqitIUb10qTt22bvfaaL9EytiKZOTlcgzTQGGjduLRuJMr1kpPg3on4eno4JI+FRx8LL+GnViiJjNMptaXGSKLRa4fAipWqdh3e9UtKoFkz7RKvyrGIZOJSq6qohEKkQ3himexXIAD+9a9/+YRt/PrXv+b111/3WWfbtm288847bNiwgQsuuACA559/nm7dunnW+eSTT9iwYQMHDhwgKUnKWfXEE0+wYsUK3njjDW6//faA/UhLS6Nx48Y0adKE7Oxsz/KioiIeeOABNmzYQO/evamurubll1/28/5Q8uc//5knn3ySESNGANCpUyc2b97Ms88+S2FhIXv37iUvL49+/frhcDjIzc31bJuZKXlntmjRwqcfWqSnpzN//nycTidnnnkms2fP5sSJE0ybNg2AqVOn8pe//IVPPvmEm2++GYDp06d7tu/YsSMTJ07k1Vdf5b777iMlJYVmzZrRqFEjn30bGdu9e/cyadIk8vPzAcjLy/Pp65lnnhlX4URWIUQPgaCBEeu35EafiSNRXSSc6jEZGVIOD5V3oikhJtZjHwrKPscq14byvCmJl6ousi38j7VZ3L0Matw/xrpLXuqLseUxSGu8y4wapEbGQHnjMlJ+Vy88oaoqfENevjkuWIDhfCFGBARNbxW3dx9a4+KTW8QBgwbBTTd596ksfWv25hfNXDBGiGQ+DrMCTzz+mAhsT//+/Vm0aJHnc9OmTf3W2bJlC40aNeL888/3LMvPz6dFixaez99++y2//PILrVr55tuprKxk586dIfcvJyeHq6++mhdeeIHevXvz1ltvUVVVxQ033KC5/vHjx9m5cyejR4/mtttu8yw/ffq0x+gvKiriyiuv5Mwzz2Tw4MFcc801DAxB9D/77LNxOr0hjllZWXTv3t3zOSEhgVatWvl4xLz22mvMnz+fnTt38ssvv3D69GmaN28ecD9GxnbChAmMGTOGF198kQEDBnDDDTfQuXNnz7pbt241fXz1ASF6CAQNiEiWjI0EVnpLuw6GH5oxYjjg9noayEIMSGHYgZ4/rRr7aD7ravU52mVu1SE1amIZ8mSGjAy4tHcmLIPywz/Hujte7PY2XcboRFcnuVz4jGSjmzFIzYyBUZFo3z7883m4AYd1hrzDUSdKKNBry4yAUKs4Nr/vFOPil1vEDe+9K/3DIX1Wl76Vw2S6dAl+bu2Y9DNSYVpmzo8IgxFEiKZNm+qGiZjhl19+oU2bNqxdu9bvO6U4Egpjxozh97//PXPnzmXp0qXcdNNNNGnSRLcfAH/729/o06ePz3dyqEpBQQG7du3inXfe4YMPPuDGG29kwIABvPHGG6b6pQwfASmERGtZbd39dd26ddxyyy089NBDDBo0iLS0NF599VWefPLJgPsxMrYPPvggv/3tb3n77bd55513+POf/8yrr77K8OFxnnk/TIToIRA0EKKZj8FKrPKW3r8/tNAMte01YoSUw0N+5t24UcqvF0jMsGrsIyVaadmXen1eskT6F6nUDGr0cqnIxFNVlw51g3WiqoITJ47RpEngNzpRwZPAUjHIjhgPqlGjTmu9RX+Fg0fMTU4zBqdRgUSvzfx8bUMegiunMnqJTB0BVEgjAoInL0qAC045LgFziyi8Qz5UlHZ010LxUm9/o1GSy2oiEaZlVOCpL55ZgrglPz+f06dP89VXX3nCW77//nuOHDniWaegoIDS0lIaNWrkSf5plsaNG1NTU+O3/KqrrqJp06YsWrSId999l48//li3jaysLHJycvjhhx+45ZZbdNdr3rw5N910EzfddBPXX389gwcP5tChQ6Snp5OYmKjZj3D57LPPyM3N5f777/cs27Nnj886WmNgdGy7du1K165dGT9+PL/5zW9YunSpED1i3QGBQBAd7JYYNNq0aWM+NENPZFB6sBsRM6wY+0iJVnrHGKjPckEDudBAJL1O9HKpQPxVdUlt0oS05CYcPXmC8vK95OZ2913BLi7rau+BaBLMqJPHKCVZe72/PiNN0GD7UOegMOpRYFQgCdSm2pCXlVOjb+71xIZJk8JLNKrXrny86nFJSdbflxGMGuyRzAVjJ4wIPHb1zBI0GOQwkDvuuINFixbRqFEjxo0bR0pKimedAQMG0LdvX4YNG8bs2bPp2rUr+/bt4+2332b48OH06tUr6H46duzI+vXr2b17N82aNSM9PR2n00lCQgJFRUVMnTqVvLw8+vbtG7Cdhx56iHvuuYe0tDQGDx5MVVUVX375JYcPH2bChAk89dRTtGnThvPOOw+n08nrr79Odna2x2uiY8eOrFmzhosvvpikpCRatmwZ1vjJ5OXlsXfvXl599VUuuOAC3n77bZarEkl37NiRXbt28c0339CuXTtSU1ODju3ZZ5/NpEmTuP766+nUqRM//fQTX3zxBdddd52n3fz8fB5//PEGJ4II0UMgaCDEKh+DXchoZS40w4jIYFTMsGLsIyFaBTpGrepvyj5HK1RKK7fLyELI62KfF79maN+iFUdLNUSPWLms64VhxLJMkp5Rt3Gjb/4IrXwWpaWQ016/fb1xNupRYEYgCdSmWjk18+Y+kBdJMAIJCHrtzpkNJ6t8j0Eex3ARBrsvwQQeu+U5ETRIli5dypgxY7j00kvJysri0UcfZcaMGZ7vHQ4H//73v7n//vsZNWoU5eXlZGdnc8kll5CVlWVoHxMnTqSwsJCzzjqLyspKdu3a5fFsGD16NDNnzmTUqFFB2xkzZgxNmjRhzpw5TJo0iaZNm9KjRw9PCd7U1FRmz57N9u3bSUhI4IILLuDf//63Jz/Hk08+yYQJE/jb3/5G27Zt2b17t6mx0mPIkCGMHz+esWPHUlVVxdVXX82MGTN48MEHPetcd911vPnmm/Tv358jR454Kq4EGtuEhAQOHjzIyJEjKSsrIyMjgxEjRvDQQw952v3+++85evSoJccRTzjc7li+0jHPwoULmTNnDqWlpZx77rk888wz9O7dW3f9119/nRkzZrB7927y8vKYNWsWV111led7t9vNn//8Z/72t79x5MgRLr74YhYtWuSX6RagqqqKPn368O233/L111/71GgOxLFjx0hLS+PosmU0DzOWTWANlVVVpNRlPW5IrF7tb/Q3lFBg+Zy7XMY8pTdtgvun+y+f+Zj3RbLL5Q1tUTKqSAqDURLu2GvtK8EphZqEai/oHePk+2DOHI3jGiXlNYlEX4Jh9LwpseN1ftXUB3jnf99wx5hnuHrIWGmhPKBqQyaSAyoTy32b6c+c2d4yr3o4E6j66zMk6YkeVh5rKBNS3k7pZbJpk1TRRc1jMwN7rMg3FKXwYsXN3Ei7WuOoRukdctllsHat1KaaMOaa2+3m+PEjVFVVkp7eBofDYbqNuCRS5z6OqKqqJCkpJfiKNqGmBrZuPcbUqWkcPXo0aLLKSFBRUcGTTz7Jb3/7W7p27Rr1/VvJf//7X6644gp+/PFHwyKKoGGxe/duiouLueeeezwlkuPK0+O1115jwoQJLF68mD59+jBv3jwGDRrE999/T+vWrf3W/+yzz/jNb37D448/zjXXXMPLL7/MsGHD2Lhxoyej7uzZs5k/fz4lJSV06tSJGTNmMGjQIDZv3kxysq/r5n333UdOTg7ffvttVI5XIJCxyuvdjuHR0caop7QR7wy9ii7Llkl5P5T7CXfsI1HNRu8Y3WiHk+TV5TeLRahUffFwz83Kgv/BgX0/eBfG0mXdbski9fpTedJY6EWrAP0ONM7y90ZvsqFMSC0vk4KC0N7cR+pmHmqIBcDNv4EOHbweJ3IbAL3OBxzw6afw6SfebS67rH5c2NFE/JALGihVVVWUl5fz4IMPcsMNNwjBQ2CKuBI9nnrqKW677TaPO9PixYt5++23eeGFF5gyZYrf+k8//TSDBw9m0qRJADzyyCO8//77LFiwgMWLF+N2u5k3bx7Tp09n6NChACxbtoysrCxWrFjhqaMM8M4777B69Wr++c9/8s4770ThaAV2IdZh9laHEcS78Rit82FUZOjS2X9bPQFAOfahHIfVz7p6x9gtP7Dg09BDpcIhN1sS6A+U7fYujLXLut2MKK3+uFzGQi+qKvXb1RvnHdth+vTIhhbphbEsWSJVN1Em+wwmBChvHsHylwTbXi/paSghFnLCIyVvrYIVKxUhSSrWroXf/S70OXfwIPy4G85MhMzM0NoIlVg+HMT7D7lAEAKvvPIKo0ePpmfPnixbtizW3RHEGXEjepw6dYqvvvqKqVOnepY5nU4GDBjAunXrNLdZt24dEyZM8Fk2aNAgVqxYAcCuXbsoLS1lwIABnu/T0tLo06cP69at84geZWVl3HbbbaxYsUK3LJKSqqoqqqqqPJ+PHTtm+DgF9uLN5VBSHLsSr/FacSVSRLvkrtL2SkqGk5XSOQk3X0c4x2H1s658jFu3Sh4e3fKDCz6R8DppKJzRVpoYLteP3oV28LawmxGl7o/eGOWp3LQPusB1WNsQ1Wpj5EgoLol8NQw9L5OtW6VyrkoCCQFqb5GiQujcxbjhbUXuGCPzdfVqWLAA37wrGu5jZj2alELDV1/BwnnAaSAFxo6N3g+0KBsrEESdoqIiioqKYt0NQZwSN6KHy+WipqbGz5UpKyuLrVu3am5TWlqquX5paanne3mZ3jput5uioiL+8Ic/0KtXL0MJbB5//HGfhDEylVVVJCrEEEHsqDRwHlashBf/7v1c44ZnFkK37lJSzGjwwx6o1ggj2LUXmqZGpw92wXUQ5i8A2Wwwez6MnHMtmqbC7g3w7GJp307gjj/AgCu834+5A557VupTggNG3y4tr9TYpd5xZLeTRJU2bYwdj+ugZCskp5jbTot1OsfXrbuUFzI7W2pbeTy/ujTw93Yg1HMeSbJatgCg/NCPVCm9Ei79FXTv5h3QVkG8FqLBQUXeikBhI9Ei2Bit+YCqxX9F8ihwwh/ugCvqXmrIx9K9m1ThRW5j/35wV/vup7YG9u6C1KbW9T2jJXWBY95ljgSoPml8/wddsGC+tw13DSxdUvel6ni10Np+4TPSmJg9v4HOhXo/wdj6HXTtEny9NR/A4mfr2nXgxk0VpzlFDVVU4zBzLOHMbSvHURASVbG+N5qkpgZOnYqvPgsE9Y24ET1ixTPPPENFRYWPh0kwpk6d6uNhcuzYMdq3b09KUpLtkuo1ZAKdC5cLXvk7JKi/cMORg9A+J6Jd83BGLiRqeBF06gApDWwqHXZJpozPOTF5PkK5/lwuWPKs776ffw769va+nLz2KumzkegAveOYMdW454fSU0QmVM+XQMfXPifw2Kq/D8XbO9Ie4na7557Zti0Ah38pJyGhEY0aJXq/zGkfuPJINLHrm2y9MXK54NklgIMkeSY/9zz07utb9UV9LI1TwJHoH6rRoRNYmSgxpz2MvcffO6JHT+P7dx1G4+7hRT5e3ZJUGtu7gYNHQpt3uuciSD/V/P1V6Hm+v9eOT5ve8yu368bNaaQKC0kk4DB6LOHObavHURAS8ZbItHHj6uArCgSCiOGMdQeMkpGRQUJCAmVlZT7Ly8rKyM7O1twmOzs74Pry30DrfPjhh6xbt46kpCQaNWpEly7S24hevXpRWFioud+kpCSaN2/u808QX+zbp+mIi9MR3bwFshdxQt2VanUYgcslFQ9wuWLbhhHkMBIl0cgjEShpp5KMDCm8Pti50ToO8A9h0htPdciTcvuFC+G/n8C27cbPyZatxo4vGKtXSwUd7p8u/V29OjLbxDut09JonJCA213LwYM/R78DRi5YvfwTVlzkZm8YRtcPFD4S6Fjkm6yzzoCNZGjRwIFSDo/HZkp/5RwYRvevVUdaiTIpqxZyLg4lkcgdo7UfeV/Dh/svd9fCvRMD3wD0kqeq2w92LFbM7WiNo0AgEAgsw5Cnh1zqxSgOh4ONGzeSm5sbUqe0aNy4Meeffz5r1qxh2LBhANTW1rJmzRrGjh2ruU3fvn1Zs2aNpxYzwPvvv0/fvn0B6NSpE9nZ2axZs8ZTfvbYsWOsX7+eO++8E4D58+fz6KOPerbft28fgwYN4rXXXqNPnz6WHZ/AXmjlaQCpUke0w94jlWPQivwY0cyxEas8EqHk7AjkvaA+Dq15FqgSipYII1PrhtmzvZ+dDmnOdums3Rf5/KkxKyaFknumoearcTqdtE1LZ9ehcsrL95KV1TF6Ozf6hjtS1WTMvmE3s74nuaaiLKozAXAHP5ZoJnLVyp1iZP8uFxQXB247mOEdrdwx6v04nDBsKFw7RPrek9hUSZAbgFbyVBxSiJC7Vvpr5FismNt6uWH27fN+LxDEIWvXrqWoqMhQKL/MCy+8wEUXXUS+XLVJILAphkSPI0eOMG/ePNLS0oKu63a7ueuuu6ip0ajHHiYTJkygsLCQXr160bt3b+bNm8fx48c91VxGjhxJ27ZtefzxxwH405/+xKWXXsqTTz7J1VdfzauvvsqXX37Jc889B0jizLhx43j00UfJy8vzlKzNycnxCCsdOnTw6UOzZs0A6Ny5M+3atbP8GAX2QMswLSyEERovqaLVHyufo6wwOGNhtIZim8gCRMsMc2FJSuHCjNhiRAhSJ0idNNG4qKInyGlR6/aW01X3Rc9jxOmQjg+kF+xGwk5CKWEbi7K3dqFdeit2HSqnrHQX3btfEnhlq+J/9N5wa12wkagmo7X/hQv1bxhm+gvem/bCZyQ3Pdmgz+9m7Fhincg12P63bkHb/9AhLTcqYERL4Am0n7vv9j23MoHEBy2h4c47Ib8z/LQHup4TvHqLywXHjlozt5XHt2O7NxmunULBBAILWLhwIXPmzKG0tJRzzz2XZ555ht69e3u+X79+Pf/3f//H3LlzTbddUVHBjBkzWL58OQcOHOC8887j6aef5oILLgCgpqaGBx98kL///e+UlpaSk5NDUVER06dPx+HQcJlV8PPPPzN58mTeeecdTpw4QZcuXVi6dCm9evXSXP+ll15iypQp/PLLL4waNYqnnnrK893u3bsZOHAgX375pfDej2MM5/S4+eabad26taF1//jHP4bcoUDcdNNNlJeX88ADD1BaWkrPnj159913PYlI9+7di9PpdTm86KKLePnll5k+fTrTpk0jLy+PFStW0L17d8869913H8ePH+f222/nyJEj9OvXj3fffZfk5OSIHIMgfrBbFUcrscLgjJXRasY2UVbfcQP3GEzuryVcLFkSfC6YEYKUx2FGVFELckZR90XPY2TSJDhxQgo3MerBE4o3TEMue5ub0Zr/7thK+f5dgVe0Mq+GmTfckfAI0Nq/u1YqaTrq1vD6KzNwoJRM8uAR3ws11pVxIsmdd0K7duZ+pKIl8OjtZ+BA6NRRCmlRCjnBxAf1j3KrVnD8CDRrAulBjkd5LeHwCh/hzAd5G7ncMUSu+o9AEANee+01JkyYwOLFi+nTpw/z5s1j0KBBfP/99x6bcOjQofzxj38MSfQYM2YM3333HS+++CI5OTn8/e9/Z8CAAWzevJm2bdsya9YsFi1aRElJCWeffTZffvklo0aNIi0tjXvuuUe33cOHD3PxxRfTv39/3nnnHTIzM9m+fTstW7bUXN/lcjFmzBiKi4s544wzuPrqq7n88su55pprALjrrrv4y1/+IgSPOMeQ6FFba+LJGkm5ixRjx47VDWdZu3at37IbbriBG264Qbc9h8PBww8/zMMPP2xo/x07dsTtNvCKVVAviPXLv0hhhcFpF6NV70X4m2/C0mLv51qMPYvqCRdLlkg5OwIRqhBkVmBTe4ocKIM5c4J7fyj7onf+Wmf5ep4EEm5C9YaBhl32tkO29LBYtv8H/ZXMejoEw6z3htFJadQTJScHj1eCkpWrpLAHq7xNWmX4J5MMx0UsUhl2zZLfDb/xczjhggui2z+rxiWvq1Ri1qwYpfxRNvospr6WcAMOuG8y5OdbL+aFEgpmt/kmEABPPfUUt912m8ejfvHixbz99tu88MILTJkyBYArrriCsrIyvvvuO5+XysGorKzkn//8JytXruSSSySPxwcffJC33nqLRYsW8eijj/LZZ58xdOhQrr76akCywV555RU2bNgQsO1Zs2bRvn17lsqurkgpDfT44YcfSEtL46abbgKgf//+bNmyhWuuuYZXXnmFxMRERowYYfjYBPbEcCLTf/3rX6bFD4FAYE/CTZAqP58VFkYuyaoR9BJh6oW/G0nQaTRxqRbhJFs1mghVvX7XPOjXz/d86qHsi3oOOB1SWPrJSu3j//RT31x/6rEHSRia+Zg3R2Mw5LyOZrapD5yRIyXKdpXv1V8pkDEVCqEk7Aw2KeVJMP3+4JloMzJg+DD/5XrHZHWCUTMXmJnjihYZGZJIoByPokJpngRLSmtVpmmrx0UrsWsk0PMySksLfT7J45qSHH5SUzvON0GD59SpU3z11VcMGDDAs8zpdDJgwADWrVvnWZaUlMTAgQNZtWqVZ1lxcXHQ8JPTp09TU1Pj51mfkpLCJ598Akge+2vWrGHbtm0AfPvtt3zyySf8+te/Dtj2qlWr6NWrFzfccAOtW7fmvPPO429/+5vu+nl5eZw4cYKvv/6aQ4cO8cUXX3DOOedw+PBhZsyYwYIFCwLuTxAfGA5vGTZsGFlZWRQVFTFq1ChPFROBQBCfhBq+ow79KCyCvC7RDwEKFEoSTvWdcDxYYum9oPb+qDoJ27fDsmXevDRDhvpv88txbwhQSYkkZGnlDFnyPLzwgnR8BQWhe8OoMetNJQtuySmSQBOPL0Y7tpFCMl2HftJfKRJ5NayM2QvFE+XaIdpJLHds1544sYgxNHpc6jfz0XhTrxyP7QbySFgZHmW155FMNNwpzVxLRs6jelz794e1a0MLn4rUuEYT4aVSL3G5XNTU1HhSCMhkZWWxdetWn2VDhw5l0aJFTJs2DYC0tDTOPPPMgO2npqbSt29fHnnkEbp160ZWVhavvPIK69at89iYU6ZM4dixY+Tn55OQkEBNTQ2PPfYYt9xyS8C2f/jhBxYtWsSECROYNm0aX3zxBffccw+NGzfWrLzZsmVLSkpKGDlyJJWVlYwcOZJBgwYxevRoxo4dy65duxgyZAjV1dU8+OCDXH/99UHHT2A/DIseu3btYunSpZSUlPCXv/yFfv36MWbMGK6//npSUuKnVrZAIPASisGpNnaXlUjGbrSfdQJ5ZIRTfSdc4SKWuWDU57NHD7jkElj1FqxcAcuXS39l28fl8goeUHc+l0njtKzEP2eILG7cOzG0MJ5wUQpuMpGuGhQJOtQlXHQd+Rm32639RiwSeTXkdq04SaG49WdkSKpa8VLf5SXL4FeX6CewjOZFZOS4tIzejz7yfi4qhOEGXKFDMRaN5pEIZEzLx2lmv5Gq6BMNjF5LRkQirXFduxbmzIaTVeZv+sHG1e6CgpXCmiBuueqqqxg1ahQul4uMjAyGDx/OcK3y1CpefPFFbr31Vtq2bUtCQgIFBQX85je/4auvvgLgH//4By+99BIvv/wyZ599Nt988w3jxo0jJydHU7yQqa2tpVevXsycOROA8847j++++47Fixfrbqfu83/+8x82bdrEM888Q5cuXXjllVfIzs6md+/eXHLJJYbzXArsg2HRo3379jzwwAM88MADfPTRRxQXF3PnnXfyxz/+kZtvvpnRo0d7su0KBIL6iZ0qbgTyyFALF04H/PYW49V3Bg6Ejp1gy2bodpYUQmIGu+WCWblC3yNG63zmdZGErE8/lTw81N87iH4+F71qM/FY6rZ9XUerqk9SUXGI5s1baa9o52zKoXqiaHmJ2sl4DnZcWkbvh2u867prpZJJbiBQDLhZY1Fp/BoRIPTWeWuV19vGjJEaCc8jLSJl5MvX0tatgLsuR4pqv0Y8LvTG9WSVtrdSsOMJNK52FxTqg5eKQJeMjAwSEhIoKyvzWV5WVkZ2drbPsl27dtGiRQtatGhhah+dO3fmP//5D8ePH+fYsWO0adOGm266iTPOOAOASZMmMWXKFG6++WYAevTowZ49e3j88ccDih5t2rThrLPO8lnWrVs3/vnPfxrqV1VVFXfddRcvvvgiO3bs4PTp01x66aUAdO3alfXr13PttdeaOlZB7DGc00NJ//79KSkpYf/+/cyZM4f/+7//48ILL+Tcc8+1un8CQb3GynDraBBOzgqrj9UT8q/oT20tbNwo/b8yX8Tzz8OwodrtaLF6tZTMc8nz0t94DrE24hGjRCkcXXyx9vf5+eHlhLHqOGSM5lyxC8mNG5PZNBWA8vI9gVc2m+wlmgwb6s1noHx7rnexK0uGKomE8RwqwXKJaBm9WpSU6N/s9IxFvfXVOR927Ag+hrIxrV5n+Qrj+1VidY4VLd58E269NXK5LTZulDI+z57t377RHDp646o1f43k6tAbVzA3R2KB1XmHBLaicePGnH/++axZ4xV1a2trWbNmDX379vVZd9WqVVx11VU0amT4XboPTZs2pU2bNhw+fJj33nuPoUOlB7YTJ074VOUESEhICJpj8uKLL+b777/3WbZt2zZyc3MN9efRRx9l8ODBFBQUUFNTw+nTpz3fVVdXU1NTY6gdgb0IbXbWkZqayhVXXMGePXvYunUrmzdvtqpfAkG9R6ssqp1e4mgRauhHpI61oMA3gb8b3xdNSo+LyipjbRotO2t3r2MZMx4x6vMZ6PtoOyHohSwpjyeeaN+yFeXHKygv30vnzgWx7o451G+ghw/3VmDRezsdiZKhkaKgACbeCzj8q3tovZnXwh3ABc5MqIiWQLJsmRRCU7JMP1xDK6Rj6BApxs3IfrWI5EW//E3fsCervQaCeSUY9WQxGipjxgtCa1w3bbJ/OFG0vH8EMWPChAkUFhbSq1cvevfuzbx58zh+/LinmovMqlWrmDFjhufz8uXLmTp1ql/uDzXvvfcebrebM888kx07djBp0iTy8/M97V977bU89thjdOjQgbPPPpuvv/6ap556iltv9ZY5X7BgAcuXL/cRZ8aPH89FF13EzJkzufHGG9mwYQPPPfcczz33XNBj3rx5M6+99hpff/01APn5+TidTp5//nmys7PZunWriGyIU0ISPSorK3n99dd54YUX+O9//0unTp2YMGECRUVFFndPIKgfaOW8M2JY2xGzz72BjhXCEw60EpaGG25jJITHrIhjRiCxWkzREi5GjpT2AdJ5uHeiFLKiVb0x0PmOZhiP+jhk4rXUbbtWGWz8aTelP+2MdVfMoWXMyWVn9Qy9Th0jVzLUaoKFFKiNXj0CGX9mjEU9gaRLnuTKFuhGrL54wT+RrFkjNRIXvcslJWVVY6WRH0xoMiJmyDfngoLgY282B4p6XONBUIhU3iGBbbjpppsoLy/ngQceoLS0lJ49e/Luu+/6JDfdtWsX33//PYMHD/YsO3r0qJ+nhRZHjx5l6tSp/PTTT6Snp3Pdddfx2GOPkZiYCMAzzzzDjBkzuOuuuzhw4AA5OTnccccdPPDAA542XC4XO3f6/o5ecMEFHuHl4YcfplOnTsybNy9oAlS3283tt9/OU089RdOmTQGpmkxxcTF33303VVVVLFiwgLZt2wYfPIHtMCV6fP7557zwwgv84x//4NSpU4wYMYIPPviA/v37R6p/AkHco2UgZ2dHPzeGlca0medePRFBTq4ZjvdHOJVWQm3TrGBlRiAJ1SMm2Ln1Kfqww5u8VI5ccRN4f3bJUaIMyz92DJo3t5/NbJSOdQ+N5aW7YtwTkwQy5txu7e82b7G+ZGgkMPp2fuBASciZOEnb4yOY8WfGWKwzfqvdp1lPKRspZwdH2fdgb6pPV5GYmEROTle6dOlFQcFg+vQZSmJiY999KduNlJEazg+MXsiQw0IXLiMiQiCF12x+jXBFi3gRFOycd0hgCWPHjmXs2LG6369atYrLLruM1NRUz7KioiJDL8JvvPFGbrzxRt3vU1NTmTdvHvPmzdNd58EHH+TBBx/0W37NNddwzTXXBO2DEofD4SmXG25bAvthWPQ466yz+P777znvvPN4/PHH+e1vf0taWlok+yYQxD16BvLsOdFNBBnLUBotEcHp0E+uaeaZyWy4jZHn8mBtmknmakYgCdX7x8y5PXLUt1qL8jCi5W0Urvi2cWP8hYVpIZetPVC2O7YdMUswY07ru7O6xeattdnJZubtfOVJbUN99BgpGU6w/Rk0Fk+3SGNl30xWfvZ3jqCI0auW/pw6dZLduzexe/cmPvjgBVq0yGLo0AkMHTqeRo0SQ96vKcJNuKkXMlRYGF7/1OffiIigpfCGkrDTCtEiXgQFu6jigpiwatUqRgRK2iwQ2ATDoseAAQN45ZVXRLJSgcAEegZy1cnwyqKaIdahNFoiwpCh/qHloXq6GH0u/GANLHnWmLEcqE0z3iVmBJJQKuMYPbdapV61iLS3UbjiW6znspWc0VbKfu9y/RjjnpgkmDGn9V1e1+i/tTZqiCsNYzNv5/XWNSJ4yAQxFvfu3czcub9n586NxtoDjhwpo6RkMp988hrji+bTwZHqL/pYaaQGCmmqPGlMcFLPKbns768ukXJbhKKQ6p3/UESEUMv1WiFaCEFBYHOUuTQEAjtjWPSYP39+JPshEISMnRNKBjKQe/SIzkscO5SZ1QotV3p6QHieLsGeC10ueHaxN5zDiLGs16YZ7xIzAkkooTpGzq1eqVctIultFK5g4XLBJ5/Efi5bRYfMTADKj/wU456EQCBjTu+7aL61NvpmXsswNirOGH2TH+IP1JYtn/HQQ7/mxIljIQwA7Ny5kftmXMaf6U03R4Y5hdFMn/UEgXvvrfvggLFjg+9bPT82bpQqnoTiPRLs/Jude+GEqgjRQhBHdOzYkXHjxsW6GwJBRDAkehQUFLBmzRpatmxpqNF+/frx2muviUQvgohj9woowQzkaDwPRSLvRSjohZZb6emi96y+bx/UAgmKdcMxlo3ab2YEErOhOmDs3AYq9arM6QHekr9WXUPK8xGO+BbIUyUeK7cA5LZuDcCx44eoqqokKSklxj0KgvriCnTzCqQYRsMANPJmXsswXrhQqlE9ZzacrAouzgS7ESx/U0rQadJw37t3s67gcQkwHCgAWgKHgY3AcuBj1bonOM1DbGC2+2I6GFUYrchd4YMbFizQj+nTmlOBRAvwbtOqlfYuQ/XM0CNe8msIBGEiRA9BfcaQ6PHNN9/w7bffkp6ebqjRb775hqoqg/UhBYIQiRdX91iH5YZiTBtFfmZNToGTlcFfDCqfcQONSygvRwMJYDk54FStH66xbNR+M3P+zc4VI+dWL6fKpEnQOquuMmcd6pK/4aA+H4WF5sQ35dwKJHjEk+1RU13N6YoKktLTadmsGU0SG3Oi+hRlpT/QIffsWHdPn3BzNkQbI2/mtQxjdy3Mnu09xh49gu9L70bwZmglWE+fruapp37nJ3icBbwA9NHY5hJgHLAeuBXYrPjuBKeZyzfMqb2YRsGMfityV2gKIG4p+3C/ft5FgeaUnmjx1ipv9RlH3cV/cW//PkWi8omVP+R2dk8VCASCeorh8JYrrrgCt9uAfzRS9luBINLYIWzDKLH2cI1k7jq1Ma1nD+mJEuq+hOK9E0wAy8iAO/4Azz8X+RwqWpg5/2bnivLcJiVL4pPL5etNpCWM9OsnhctbXfIXtM/HsmVQWATLSoKfA+UccODfR4Axo42lT7CLfVFTXc23s2ZRsWcPvWfOJCUzk7bNW7D94AHWL3iCtjOfIyFRI/FkrAnFEI418qRX9lvtxhTIQ8HsMbpcsHWL9P/53aS/xcX+69XWSMZ/8+a6E3Llyrn88MPXPsuuAt4AgvkC9QG+BK4H/q1YvpOjrHTs5rpgRn+4uSu2boUtWyRxIhDB5pTWuXE4fcvtytvkd4ZmTXzbj5RnhhU/5PEmIAoEAkE9wZDosWuX+ZJ67dq1M72NQGAGu4RtxAuhPq9pGY16eSL0vG2MeuWE6r1jRAAbcAX07W2d8BMLY1pvnxkZgaua6IlekbqG9M5HXhdYsiTwOVDPAS3BI8FpTPAwk7w20pyuqKBizx4qy8rYMG0a54wfT4ujFQCU/ryD0xUVJBj0powqVocKRIuCAqmErgcNJVRpGKuRBQqld4IWq1dL4RuemeqA4cPQnrkOyZMEt6bBW119ipUrn/LZ4iyMCR4yKXXr98LX42NV8j6G7N1D4uFD+glGw/GQkG9AeqVn8/O9n4PNKS3RYugQ/+zX7hooK4Nmnfz3GUkXy1Bv/vEoIAoEAkE9wZDokZubG+l+CASmiWTYhkBCz+siUJ4ILU8Bo145oXrvGDXerfK4MeqNYqUwEmifRsQiZbi8siCC1deQywVHj+mfj2DnQG9uye0Z7WMoyWsjSVJ6Or1nzmTDtGlUlpWxfsoUWtX9BDfrex5JdhQ8IDKhAtFg3z78hAe1WDNwoFRl5N571VtLzJkDJ07oK2XyhYdKXFm+IkCeC1nN8zd4169fyZEjZT5rv4BxwUMmBXge6KtYdrjyCOsfvJ1+5EgL1KKLfLMqLJTcssx4SKiNeSVabeTk4OfD5VDdsJXeI7ghK8vX0wPAkSAt1yMSLpbheGrEq4AoEAgE9QDD4S0CgR2Jdb6MULCLu30wAhnSWiKDjJbYYFSUCNXzICMD+veHNR96l112mXHPdDPnI5QyseF6GQTbZyCxCLzHp+cNYtU1pA5LMStUgP4cmD1HKvVstI9WJ6+1gpTMTM4ZP571U6YA0BrJADpcUR6bDhmZ/PGaxFEvRCI5yXe9ypP6bQR7E69lxEobwrBhsHKVyosksAizceO7Pl9fgnYODyNcCPwK+K9i2UbKvaKH8tiUXhpyudgueeYuNq1xGD3GeAlfrfBpdb8KCuCrrwC3NA/vvFNKZlpVGbx9K354w/XUiFcBUSAQCOoB6tx+AkHckZEh5Zuz+zM4SEbh6NFw/3Tp7+rVse6RPsG8Lu6+WzJGlSQ4YeRIaVuXy/e7ocMkY1ZeT8tuUrdr5q3+Rx/5Llu71r8PspeDvDyU8xFMYJD3oyVSqPtjlGD7lIUCJQlO2L7de3y33ip54Wv1yYprSC8sZfJ9UkiLUcHHfw64uesu6Jon9THVeYia6uqg7UQieW24VJaXs2nuXM9nWfQo278zsjtWT3zwTv7p9/tOfq11Bw6UTuJjM82dzFgiTySnQvZy18LESb4XumyI6iELE1robetwwrVDpCowgdpWGbw7dnzp8/Vw/S0NMUL1eSdHfRfIITxqQ75kmTkFVGscHE44q5uve5k8p7S8cHBr30SV/frqS+92F15ofB7qzXWzBPLUMIJ6TsaLgChoMKxdu5aOHTua2uaFF15g69atkemQQGAhQvQQCKKE1YZwpNEzpOVndNkOmvkYPPmk9HdkIZSU+IoI8vOmHI49fHhgu0nZrt56Ws/QwYSID9b4Chxvvhna+Qg2Lkb7YwatfQJs3yH91RKL5HOhFCH0kpZqoWX7BkLrmGvdkJZm/pl+4EB4bnE1RfkvMiZ9Mr86T/KEqCwv5/PJk/l21qygwoecvNasgBYpqg4d8oS2pGRl0ecvf6FDXRn4/T9+T9WhQ5HZsZbBp/fGevmb+sZhPKnLMgMHSsIDiotHLk0rT2wtcUSJ+k288sKQt/Ux+OtcqDIyJC8SvVKuGgbvvn3bfFYpMH6kmpyn+vwzv/j3AXd4hjwEFpjmzfOfU1oiiZHqOko++xS2b9P/XkZvrofyw2uk38GIRwFR0GD5+OOPufbaa8nJycHhcLBixQq/ddavX8+zzz4bUvsVFRWMGzeO3NxcUlJSuOiii/jiiy8839fU1DBjxgw6depESkoKnTt35pFHHglaWOOll16iffv2tGzZkgkTJvh8t3v3brp27cqxY8d0thbUV0R4i0AQJeKp2gwYy/egDJl2uWD6dF8RYeFC7//Lf1ethCHXBt+33phohY0UFAQOi9HK76AUBGRqamHVW3DrqPDGxeoEoRkZUqj90mLf5ctK4JJfSd+rw1QC5V0J1qdQQnOsPua0xhVkHP6YSpc38eemuXOpLJNyHhhJ/KlOXgu++UyiSaPUVFLr8mPJ1VsGTpkCkydTUXscZ9Om1u9Uz+CbeK+2oVtcEtx1P17i82QqT+In97lrpQojo26VPsu5PSZO8h+XwpHe49TL5+DJPYGUsFOZKVgrxGbSJN/16qiurvL53DL0o9bcvhpVWMVdd0nVZqwIudAaQ3ctfLjGu448p5YsCR4yFai6jszmLZDTOnC/rMyjYVWoVyRyjQgEEeD48eOce+653HrrrYwYofYdkxg6dCh//OMfmavwYjTKmDFj+O6773jxxRfJycnh73//OwMGDGDz5s20bduWWbNmsWjRIkpKSjj77LP58ssvGTVqFGlpadxzzz2abbpcLsaMGUNxcTFnnHEGV199NZdffjnXXHMNAHfddRd/+ctfaN68uen+CuKbkESPI0eO8MYbb7Bz504mTZpEeno6GzduJCsri7Zt21rdR4GgXhCP1WbM5HvQe9OvJhyhR89bRvkMXVMrjfNIha2ild9BrxzqyhVeUUbPtgs2LqEkCA1mSx456r9MPZbqZ2n1fHMATmfgPoVaQcfqpKhaiT8BUrKy6D1zpuHEn/KYWJ1jxazdn5CYyLmTJ3O6osLT985du+J0OKhx11Bx/BDpSRbfDPQMPhzaxngw4zAey21qJc0EKd/GtUO8x6bnldElT/obKJ8DaJeh1TOSdSrCJCYmceqUN8fIYfNH64N6+8TEZPjLk3CyyvfGZVXOlkCeLTLynDJ6E9VLkApS+EwwrM6jEY+JxASCEPn1r3/Nr3/964DrXHHFFZSVlfHdd9/RvXt3w21XVlbyz3/+k5UrV3LJJZcA8OCDD/LWW2+xaNEiHn30UT777DOGDh3K1VdfDUDHjh155ZVX2LBhg267P/zwA2lpadx0000A9O/fny1btnDNNdfwyiuvkJiYqCvgCOo3pkWPTZs2MWDAANLS0ti9eze33XYb6enpvPnmm+zdu5dly5ZFop8CQdwTr9VmjL6U0hJ15JAMq4SeQN4yAwfCL8ehpNjrydGsmbRcL7/DlVfCu+/5Lq91S94eK1foV0qRDd4ePbzbqQ1hM8/GwQxylwtWLPffLtBY6s23YH0KxyPJantAnfgT4Jzx40nJzDTVTqhCjhbhiCcJiYk+3imNEhLITm3BvmOHOXBgD+npFoseegZffr6/oTtypHTR6BmHdiq3aUZ1ysiQSsiqy52qBZ1gxrGegPTWKm9VES0hyMRFkZPTld27N3k+b0RKZhoqX6s+t213JuR19V/RqgvXiHeGckyVqrTys7Jfeh44F/eTjuX4kcB9ikQiXuGpIRB4SEpKYuDAgaxatcojehQXFzNq1KiAYSinT5+mpqaG5ORkn+UpKSl88sknAFx00UU899xzbNu2ja5du/Ltt9/yySef8NRTT2k1CUBeXh4nTpzg66+/Jjc3ly+++IJbb72Vw4cPM2PGDD5SJ4ATNBhMix4TJkygqKiI2bNnk5qa6ll+1VVX8dvf/tbSzgkE9Y36/JJIz8iG8IUe2cZJTtH3lnG5vIIH+Bu2d/wBnn/OXwB47z3fd8BOh1fwULejV/1EzxA28mxsxCDft8/fIwVgyNDA7evNt0DbhOuRFI49oLZl1Yk/ATbNnesJDzGKVaFlVoonMu3TW7Hv2GHKD+whP//C0BrRY+NG36oYDsUFqDc5ZOFDbRzapdxmKN4m1w7xL3eqftsfzDjWC1VRtqsnBBm8KLp06eUjeiwHxgXdSp83VZ87dz5ff2WrLtwzz4StW7zfZbeBAwe0x9TIuczr6u/xccON8Pvfa1d80aI+//AKBDZg6NChLFq0iGnTpgGQlpbGmWeeGXCb1NRU+vbtyyOPPEK3bt3IysrilVdeYd26dXTp0gWAKVOmcOzYMfLz80lISKCmpobHHnuMW265Rbfdli1bUlJSwsiRI6msrGTkyJEMGjSI0aNHM3bsWHbt2sWQIUOorq7mwQcf5Prrr7duIAS2xrTo8cUXX2gmrGnbti2lpaWWdEogqM/U15dELhdkZ2uXFg3neVMtKPTvL1VmUYsomzYFNmzV+R3kfowd6yvKDBnq/1K4ptZb5EBt8HbsFJ4hbMQg1/OiCZYbBfznm1JAOlkZ2CM/mh5J6vN8R9EvNP23N/GnMqfHhmnTuHDWLEMhLi4XHD1mTWhZJPLytM/IZP3uHZT9bHEFF1mhUctlcjgG+E6O1au9gofDKeWyUBqgep4QyUnRS5QSjrfJsKHeErJ6b/sDGcdaosjQIcE9SExQUDCYDz54wfP5Y2A9oZWt/RzfcrUABY0iEEupFC60KN0PM2ZINxzlmIZ6Lh1OyMoy38/6+sMrENiAq666ilGjRuFyucjIyGD48OEMHx68/tSLL77IrbfeStu2bUlISKCgoIDf/OY3fPXVVwD84x//4KWXXuLll1/m7LPP5ptvvmHcuHHk5ORQWFio2656///5z3/YtGkTzzzzDF26dOGVV14hOzub3r17c8kll9C6dZDcQIJ6gWnRIykpSTPj7bZt28g06XIsEAjqB1qeDsrQj1CfN7XerK9dqy2sGPFQ0OqH2s4BX08PuR032gbvls3hGcI5Of4ZB5wO7ZfQyrEIJZWC8jwp9xWGR74laJ3n50qa8qdzupOCN/GnnOMjNTeXRgpPQz0+WANLnvXmb5HnR6hCTiTy8nTMkh62DpTuDr0RLbQ8M9yKcj1KlxotA7RkGfzqEl/3ILXRf9ll3tAD9Zv6SCQ8DcXbxMcod0jlo/r1k/JPyBVYlAS6WWndLIJ5kJigT5+htGiazpHj3ko+twJfAikm2qkERquWtSSJPu9tghs1jjlU1PNGj337YehQ1TKD5zKQONKqlfF+Gp2LgdaNtyS+AkGU2LVrFy1atKBFixamtuvcuTP/+c9/OH78OMeOHaNNmzbcdNNNnHHGGQBMmjSJKVOmcPPNNwPQo0cP9uzZw+OPPx5Q9FBSVVXFXXfdxYsvvsiOHTs4ffo0l156KQBdu3Zl/fr1XHutgTdIgrjHtOgxZMgQHn74Yf7xj38A4HA42Lt3L5MnT+a6666zvIMCgcDeRMLlX0bvzXrVSV9RBcLzUFDbOVrtdMvXNni7nWXOEDby3Kznta1c/u57UmjO2LHGBBD1eZLRO1/RfDGqfZ4dpA+/m/zcYx6PjpTMTC6cNYtGqakkJCYGbFNdsceN9P+T79MsnCHts7raJ9EoSKVm5f1FwgumY5tsAMoP7A69EaC6uoaKitOkpydJC3JyOEQzUqkkkRppmTMBdmyXyiwphYrsbGMGqNLoT07yr9ShjgOzOuGp2aSUfka5WxIplq+Q/j+UvskXhnwhFxbCsmVeIahwpH6OiiAXf+JHaxl6PIsSvKLHZuB64A2MCR+VdetvVi0fQicS3W5rw5GClZWV0Uo4avRcBhJHjIgeZsKh1OsWFkKXLlJfIzWnBYJ6wKpVq7jqqqto1Mi0WQlA06ZNadq0KYcPH+a9995j9uzZAJw4cQKn0zcjW0JCArW1Bu47dTz66KMMHjyYgoICvv76a06fPu35rrq6mpqampD6LIg/TM/OJ598kuuvv57WrVtTWVnJpZdeSmlpKX379uWxxx6LRB8FAoFNcbngk08iV4rX7Jt1ZfVIN5JQEQp6ng5aBm/XPOOGsNoj5vrrITXVP1+HG9/xc7lgwQLt9RYuNCYwBSphG+vSyXrnuW37Rn4hLEartuhV7ElL0xc8vp01i4o9ezyeJZXl5R7PknMnTyYhMdFyL5gz2kqih+vgjyG3UV1dw6xZ37JnTwUzZ/YmMzOFcndTpjUvJPfYLibzHolOpGSlWmVp58w2LibIRv+mTdrGqBwHFomEp2aTUup5uyj/f+FCKVmmVoJPPdTGcVGhVOVl+3bv+KoN42DGd51AM5ROfMI+duIt1/RvoBfwAoFDXT5H8vBQCx6dSWMoZ4RXtUQLI4lLL79Ce2yNnku9XCrJScH7ZyaERmvd4qXe/bndeO7AsUziKxBEkV9++YUdO3Z4Pu/atYtvvvmG9PR0OnTo4Fm+atUqZsyY4fm8fPlypk6dyla5lLcO7733Hm63mzPPPJMdO3YwadIk8vPzGTVqFADXXnstjz32GB06dODss8/m66+/5qmnnuLWW2811P/Nmzfz2muv8fXXUlrn/Px8nE4nzz//PNnZ2WzdupULLrjA8HgI4hvTokdaWhrvv/8+n3zyCZs2beKXX36hoKCAAQMGRKJ/AkHc0VA8YLVCJWSUwkQ44xHKm3WtZKMFBfDDHjgj13gfjITCyN8bMYS1PGL+8br2vtXCjl4iU7kdI4KFlrCgJClZe7nVaM2HSHhQ6FXs0bP5TldUULFnjydniDKHiPy9XHnFSi+YDnVhoeWHfw65jYqK0+zZU0FZWSXTpm1g/PhzmDt3E2XHgIx8Ksb0Jb1rO/235ierzFe40HtTjzuyCU/NqE5GjHJ3Ldw7UXKZKigIfrPSCwWaM9u3+o26pG0w47vu3DTCyXh6ch+fcgLvG8nNwIXAr4ARwHlAS6SytF8jJS1V5/AAaEojxtOTRs5E65PzKOPutMb4zrsgULlLI+dSLY6AtK+Jk6Tjubi3fvtmwqECea1oLY9FEl+BIMp8+eWX9O/f3/N5woQJABQWFlJcXAxIQsj333/P4MGDPesdPXqU77//Pmj7R48eZerUqfz000+kp6dz3XXX8dhjj5FY58n5zDPPMGPGDO666y4OHDhATk4Od9xxBw888EDQtt1uN7fffjtPPfUUTZs2BaTKMMXFxdx9991UVVWxYMEC2rZta3g8BPFNaH5IQL9+/einU2teIGiohFPO0m4EC20OJHjIz9ZGxkO9H5cLttS9HOiWH/i5WGtbtbCwcKH0ku40kGjwnAQ6dj2DN5ghHMjTQomWwa+V90NGnf9DD628IEqqTgZvI1wCzQerPSgyMrQr9ui1m5Se7skZUllW5imTm5KVRe+ZMw17mJilQ12HTlRVcOLEMZo0aW66jfT0JGbO7M20aRsoK6tkypT1AGRmpjDzL71Jz5QCIw4dOUUqjUhUGNOet/89epg7AXpv6vO7mQtBCQWjqpNWH2tr0fSZWrAAHA7t0AblvvQM6c1b9A1stwEhSCHQdCCVP9Obh9jgI3yAJGxoiRtaNKURD9CbDqTCxIlSLhMlVij0emVlnQlg5A2qkXMp7+Peifh5W+R3hmZNtLczEw5lRCBTYuWcbihvSgRxx2WXXRaw7CxIXh6XXXaZT0XPoqIiioqKgrZ/4403cuONN+p+n5qayrx585g3b57RLntwOBye0rdKrrnmGq655hrT7QniH9Oix8MPPxzweyPqm0BQHwknt4XdnnmCiRV6BvyY0XDxxfoChHo8tCqzfPih1yRx4M1ZoR4XrT5mZ2vnrFD+v9Y5UY6/XlnacAnmaQG+46ckI0MaB3WIiwOpf0bnzMCBUrWZiff6tmMkGWe4c9TIfLA6j4hexR49UjIzOWf8eI/gAXDO+PGmyuOaJbVJE9KSm3D05AnKy/eSm9s9pHYyM1MYP/4cj+ABUFPjNeDKyyuZNms7uZ3uYPLu50h0V/t7dJg9AcHiwIx6jUQSdR+VuRl8cHuT5qhDG5Q3AT1D+qwgYk8w41sl0HRzZjL75r8yd/1idu7caPqwO5PGeHpKgoczQUpko+TNN6G4mJBzmyiRy8pG8pxXnsRPrHLXQFkZNOukvY2ZcKhgXiuOOr8xrXLO4RBKCWaBwEasWrWKESNGxLobAkFQTIsey1Xl2aqrq9m1axeNGjWic+fOQvQQNFhCLWdpN+8QI8apXg4GpcEebDy09rPmQ9/19XJW6Hl03D89uLCgPifK8VcmvdQ79lDJyIDCIli6VPt79fipUeYrqaiQcoG0zpLKzmoVodCja55vmV6nQ0r1EOk5Golyr0YwY8dXlpezae5cn2Wb5s715PiIFO1btOJoaXiiR3l5JXPnbvJZduhQFZMnr2fixHOlcJeySshKoeLJBaRXHrTOpcZoHFisUPZRy2sgEOpQFD1DOpjhb8T4Vo1bh4wM5lxfxMqVc1m58imOHCkL2t2WLbMZ0u1qhq47QCO3W3tfy9/0ijpaxxgKkT7nmrk9EoKXrw25Xw6v5488hlYfXzglmAUCm7BmzZpYd0EgMIRp0UNOBqPk2LFjFBUVGarJLBDUV0IpZxnJyiehYsQ4NZKDIdh4GA33kHNWyNvk5GhvW+uGxx6VvEXWrvX2q7ZW36tBPf5a3bHSMB8xXNpJSYlG/2ull9CBxISMDK+H+urVMGliaELEwIHwy3EoKZa2LymBI0dhyLXBQ5lCnaORKPdqJVWHDnlCW1KysnxyemyYNo0LZ82KWIhL+1at+K70R8r2/RDS9ocOVXlCW7KyJI+PJ57YhMtVict10uP9kZWVwsyZcrhLjoVHoIHVbjtq9FyPDrrAdTiwS1LLdOh3sZSF2QjqUJRQkvsYNb5V49aoUSLXXXcfQ4aMY/36lWzc+C47d37Fzz9vo7r6JImJybRt25XOnc+noGAwffoMJTGxsTQ+6n25XLB1CywtDn6MoRDJc64lNt15p1TBpaoy+PZBXPQ1K/3ggPsm+5Z7svL4QinBLBBEkI4dOzJu3LhYd0MgiAgh5/RQ0rx5cx566CGuvfZafv/731vRpEAQF6ifu80mY4zV2+9AGDVOCwqkl6UOtEuABhsPI+EeIK2zfYdUZVM28AuLtLetdUuCx+w5Uo4K2Ztdrw9GhBetYw8n1GPECLjkEsljY9Zs73I35sKhwhEiXC6v4CFvv3w5rFjuXwLXqjkayvURTRqlppKamwvg8eyQc3yk5ubSSBGvbDW5WVnwPzgQouiRmtqI3Fypf3L1llmzejNp0uccOlTlWW/8+HPIzDRS+NQCIhmzpxcSsHo1LJiP9JZeJ1RAua1RtPI3hJLcJwxRIDGxMf363UC/fjcY20C9r2DH7bCRAqmHWjhq1QqOHwm8jdHwEb1KP3rlnqzAbAlmgSDCCNFDUJ+xRPQAKQPv0aNHg68oENQT9Fz+zXjA2vHttxHj1Gi4Q6Dx0NrPZZfBRx95x8OBlE9QbaAvK6lbruExUVMrCR49evj2Ydde6NQhuDeKA3A6wz/2YLhc/suMignhChGr3tIWe7SEFyvnqN2iHpQkJCZy7uTJnK6o8Hh0pGRmcuGsWTRKTSWhLpt8JMjNbg3AgbI9IW2fmJjA5MnnUlFxmvR0bylPp9Phs97cuZs8okhEiWSeAr2QgE4dpeVyoWKtUAG/t/kqLroYrr4admyXKrLU1tQlNQ0S/2V3gh03SDdUq48xEsKXUswx670RKHwkFgKEmZwjAoFAIAgL06LH/PnzfT673W7279/Piy++yK8DlSYTCOoRwd60G31msevb72AVU8x4GQQaD639/O53khcESB4kegZ+Xh7MecIb4iGjZZBnZEDTVEhJwo+hw2DlCqkNefytOnYtApX6daD9jK2uaBOOEOFySR4deoQSymSGSEc9GKGmutpH3AApvKVRaqpfCEukQlqUdMrJBsDl2htyG4mJCaSnJwDecBeX66Qn3EXO6TFt2gZmzbrQRxyxlEjnKQileorStSuQ4f/55zBmjKSYupESfbprobgEmjaL3wSTgY7b4YSiQhhucSJCOyToNBM+EisBws5KsEAgENQjTIsec1VJ3pxOJ5mZmRQWFjJ16lTLOiYQ2Bkrw1Ls+syjZ5xaHZKj3I/8YlAdLqNn4Js1yANVaRk+XMqXcbIuPFz2FLHy2AOV+gUpb56a1at9q7bIFW2MHrf6Zeu+fYHTN2qJJ3ado6FQU13Nt7NmUbFnjyeMpbK83BPGcu7kyRH16tCiY5bk6eE6/JMl7WmFu8glbXNzU0lNtczJ0xeXS8qTEck8BUGrp9T4LldO5mBlSeV+guRGpi6PGq8JJjWTgDph0iTt2MRwsUuCTrPeG7G60dlBCRYIBIJ6juknn127dkWiHwJBXGF1WIrdnnkCeSVHKiRHL2wkmLBh9Dn1gzWw5Flv+263b5WWFcu9Hh96YSvhHvuWrYFziMhJW5UikLpMrRyCsmSJ9C/QcWuN6S/H9fcfSDyJ1ByNdrnm0xUVVOzZ40lQqkxYKn+fEAXvDiUd6irDHKo4wOnT1TRqFJ7oohXuIuX5uJDU1EYkJiaE3Wc/AuWMsDJMQO+NvFw9ZeEz0kWi9aZeva1eP+MpwaR8AaUkS2VdtS4kvTGTsyIr27HiQrTL+IXivWG3H2OBQCAQWEKEXvcIBPUbK13+o230BSNYzopwvCsCrRMsbKS21vevkmDPqS4XPLvYW5JWL5+FO8D+gx37qepqVq5fz7sbN/Lljh1s27ePqupqkhIT6ZqTQ5uULhzcUkBr+uBE26hVCyh6Xhmyd0mPHubGdOFC7XVvvAF69oy+F0csyjUnpad7EpRWlpWxfsoUAFKysug9c2ZUwlnUZLVoQeOEBE7V1HDo0D5at84Nu01luItM1EJalEQiTCBQ9ZTu3eDgEf3JrNx2+3ZYtkzbII5WfodwfgC0hCa9UJJA6rDVoSh2StBZn9zUBAKBQBAyhkSPESOMx3q++eabIXdGIIgnrHiWioXRFwijOSuMHrvR4wsUNgJ1z+N1y7WSbQayG1wueO89T3pDw+iFraiPPa3FaWb/cyVPrVxJ2ZEjfu2cPHWKTbt3s4ndwAck0YJODOUMhpJAIxwO33wi6kSrDvyFDyPeJXplfbXo2VM7nEcmmF0Wit0Wy3LNKZmZnDN+vEfwADhn/HhS6jwuoo3T6SSneTq7D5dz4MAeS0SPqKKXM2L0GLj44sicUD2ls1UG5LQ3tm2PHlIpJfWNLFr5HcIRG/SEpkChJFpjFolQFLsl6BTeGwKBQNDgcRpZKS0tzfC/SLNw4UI6duxIcnIyffr0YcOGDQHXf/3118nPzyc5OZkePXrw73//2+d7t9vNAw88QJs2bUhJSWHAgAFs377d8/3u3bsZPXo0nTp1IiUlhc6dO/PnP/+ZU6dOReT4BPGF/NwcqoeHltGnVdUjWgQTH5RkZHg9wbX6bOb45LARJbJhH6xPq1fD6NFw/3Tp7+rV3vVWr4Zbb4VXX/Pfp9Ph3afT4fUCUe9fC/m8HzixlwsnTWJySYmm4KFFFUfYSgmfMokbbt3L88/DzMekUBWlvSMLCUWjfPvmdBizH7TGVHnMShS3PD8Cja/6+1tvBaO6t5m5ZjWV5eVsUuWn2jR3LpXl5ZHfuQ7tW7UC4EDZ7pj1IWTkN/tKnAmREzysRO8mPnCgdFE+NtP/4rQCPbEh0A/A9m2wYoX0N1ByUmVukmAECkVR93fTJv3+qb8PdfyC7UcgEAgEghAw5OmxdOnSSPfDEK+99hoTJkxg8eLF9OnTh3nz5jFo0CC+//57Wrdu7bf+Z599xm9+8xsef/xxrrnmGl5++WWGDRvGxo0b6d69OwCzZ89m/vz5lJSU0KlTJ2bMmMGgQYPYvHkzycnJbN26ldraWp599lm6dOnCd999x2233cbx48d54oknoj0EgnqE1QlBrcBMzgplgk05uab8XCvnMzR6fBkZ0L8/rPnQu6xvX2mMklP0+xTIWwB8PUSUaFVp2bjRP2wFpOdvLQ+Gz7Zs4dcPPcSxEyc09hCco+zk7lfu490z/8xFPbr5fKf2kCkqAvkWp8w7GMjDQh2K43RIVSlxgPqWvmyZ9MJb7yWwnjeG+ns3sLRY2seI4YGPP9hci1TYV9WhQ57QlpSsLJ+cHhumTePCWbNiEuLSISMTdmzlwL4for7vsLHbm32riKSHQLC8F+oLYN48+HCNd92LLtZPyqoOJQmWpClYKEowjxS9742On9y/HTukBLKRKnVspzhSgUAgEESVuMrp8dRTT3HbbbcxatQoABYvXszbb7/NCy+8wBSFm7LM008/zeDBg5k0aRIAjzzyCO+//z4LFixg8eLFuN1u5s2bx/Tp0xk6dCgAy5YtIysrixUrVnDzzTczePBgBg8e7GnzjDPO4Pvvv2fRokVC9BCERaQSgoaD0Xwd6gSbbqTPBQW+VVHU6B2fywUffeS77JNPpX9OhySIrF3r36dNm/SFFbdbP5xj4kRvDj/ZvsjOhtlzoOqkVwQZPVo7NGfz3r0BBI9LgOFAAdASOAxsBJYDH/usWVF5gl8/9BDrZs/mrA4dPGOhFhqWLZNelmqF4QcKHRo4UEpcWlIsrVdSIpXoVaMnRgUT5rS+B2l/l/wqeL5AvbkWSFALl0apqaTmSuEjcvUWOcdHam4ujVJTrdmRSXKzswA4sD9Ok4XbJXfCQRe4DtvfuA0kNqhFhOuv9xU8AD77FG64Ef75T9+krGrBKZhgoRasHE4YOsT7vZZHysKF0CQF8uvEWrPhMVpltMyE6ZjF6pwl27fB/zbD2WdJCXQFAoFAYHtCEj3eeOMN/vGPf7B3716/MI+NGzda0jE1p06d4quvvvIpi+t0OhkwYADr1q3T3GbdunVMmDDBZ9mgQYNYsWIFIFWiKS0tZcCAAZ7v09LS6NOnD+vWrePmm2/WbPfo0aOkB3gTWFVVRVVVlefzsWPHgh6foOFhZTJUKzFiu2zZ6u9B4Qa++AIWL9YXPPSOT894Bmn52rW+goTcRnKK9jZJyZDe0l9UAmlZfr73s5Z40KaNvodDWovT/O6ppzQEj7OAF4A+Gj26BBgHrAduBTZ7vjl24gS/nzuXz+fMIbFRI0MeQEbzYbhcXsFDXm/VSv88IXpiVDBhTi/niFyFBgK/XNWaa4EENSuujYTERM6dPJnTFRUej46UzEwunDWLRqmpUS9XK9OpjSR6lJfvicn+LSHWuRNWr4YF8wGH9Z4CVqPnHQP+IsLrr2u30by5t4RTchKcrPK9QRrN1yFfiG+tghUrYfly6e/dd0tqsJYgMXu2NMbDhpqr1OKTfFWOtdO7+VtQ8cXqnCVqj5vLr4Bx40Lvn0AgEAiigmnRY/78+dx///0UFRWxcuVKRo0axc6dO/niiy+4++67I9FHAFwuFzU1NWRlZfksz8rKYuvWrZrblJaWaq5fWlrq+V5epreOmh07dvDMM88E9PJ4/PHHeeihh/yWV1ZVkagQQwSxo9Im5+FXl0K37lBaKj1bZrSCSht0rWkqdKl74a3Vn6pq0Cj4SOkBqNZ4fi0qlMJV9I6vZYaUaFSvmmtNLRytgO5n+/bpyDHtfhytgPYdYMwdUtWWWqCGKhzA7XdIx1dZBa6DMH+B9D1AjRueWQh/Gud/HDW1sGsvrP5wJV//oA5BuAp4A9BRYTz0Ab4Erge8+YU27tzJ7DffZMLQodBIGgelGZHggBaKsfthj37/miocFfTWGzIE3n5LOt4EB4y+3TsmSpqmSmP43LPa6zZNhd/8Dl78u+92CQ74bitMvV86Didwxx9gwBW+67kOegUPuc1v/g9Oa4zct/8HF12k8UUAAl7nTZv6ft+0KadqayFG94acTCmnR/nBH6mqqoxJH+Kagy5YMJ8qqoEEcNdI5Wu7d5OSm9qFgy7vpL/0V1L/5B+AVhnw3f+Bu9pYW3mdILUppHbxXS7Pnz0/+LdVWwN7d0nbKTlVCcvfxHPnkcfv8cfwvyPhXWfFcvzu3o4EaNXC2w/lsS+Yr92WFnI7+370jpniXLrdbqqqKjl16iRVVZU4HBoJi1a8YXwMgrFzO3yoSmr04WoYeDl0zjPXliAs4u0eWVMDp07FV58FgvqGadHjr3/9K8899xy/+c1vKC4u5r777uOMM87ggQce4NChQ5Hoo234+eefGTx4MDfccAO33Xab7npTp0718TA5duwY7du3JyUpiZSkCJUMFJjGLueifY70L57o2UO6eSjtaacDLr4IVrzp7xlw+aWBX6pt+U6qrKIneiQ4oVMHSFGdsjNyIVHDE0Fe99qroG9v2LpVEmrO7ZHk04/DLuldo09VFzckJ2q32zanmmfm/UvVu7MwJnjIpNSt3wulx8eCt9+mZ+pwnluc6NMn2UNGOUeCHXew9a4fJv0zEokgj6Heur+5EZISvR4lCU4YOVIKpVEex/PPSe2ove7V4TlJidpVdpIS/c+/EexynQcjL0c6wQeP7qNx42RtAy7SxHPeA9dh5BmXJM8gN1L52mDVXKKFXpiFsn+5Z4Aj0T/s5cILpZAWmcuvgLPOCXzO9Nrq0AmSVPcrxfh5cAM1Dhh7j9cjRY0bGH4drFzl67GiNeZa+9BDbue7LbqhKW63m9OnJZEyKSnF/5pxuWDVv/33pzcGwdj2g3bft++SzkUw4vn6siFJZs9fDKmpgcaNDYqZAoEgIpgWPfbu3ctFda/bUlJSqKioAOD3v/89F154IQsWLLC2h3VkZGSQkJBAWVmZz/KysjKys7M1t8nOzg64vvy3rKyMNgrf7rKyMnr27Omz3b59++jfvz8XXXQRzz33XMC+JiUlkRQnD9qC+kmkn60yMqQ8C+rQnK555kN2PN7HimUOCFjKVdmPQPuTxyE/X/IkUBvNeuEb+fna7X66Y71GlZYXMC54yKQAzwN9PUtKDx/mwUXryaafzzhMux96X2DuuJUMHSaFtMjrjSz0zo1AZWqVHDoMO3dKYUNa+xgxXMrhIQsjwUJ0AoXndMv3D5lRhyTpEc82Rfu6DldVn6Si4hDNm7eKbgesznsQbTw5MlT5LWKZJEmJ0TAL+eJWrltbK6133QjYvAXO6iblkjCbryNQgtlAOUZ69JD2v3UrzJnjv861Q6R/esqofGGmJGskX3WA0+ntX+FI6JLnPW+jR4cemrJvH5pS+tAhod0gzj5Le/lZ3bSXK7HL9RXPN0mBQCAIA9OiR3Z2NocOHSI3N5cOHTrw+eefc+6557Jr1y7cbr33tOHTuHFjzj//fNasWcOwYcMAqK2tZc2aNYwdO1Zzm759+7JmzRrGKeIt33//ffr2lQyNTp06kZ2dzZo1azwix7Fjx1i/fj133nmnZ5uff/6Z/v37c/7557N06VKcTkOVfgWCmGAkwaUV6OX+MJvPUMtAdgP3TYK0tOBt6O1PPQ5j7pC8FmTkZ7/CQilRqFo80Gp39Hx1zqJL0M7hYYQLgV8B//UsKWOjj+jhBh57VD9JaaBxVh6/Axg+HFqkeT0yjM6NefN8q+pccbkUwq5+dlancwiUCySQKNKjh7agFmweac37X10aeBs7kdy4MZlNUyk/XkF5+Z7oih5W5z2wqk9mjDOPWPCMdOHYrYJMsGotSgoKpEzMHupUwSVLYOjQuvJY/5WS3chGfbB8HcFuyMEEkowMKfvziROB11GjNvblrNTK7fX6t2mTuXwharSEHIdTEmhCIa+r5GGjzukRLJmpXa4vuwgvAoFAEANMix6XX345q1at4rzzzmPUqFGMHz+eN954gy+//JIRI0ZEoo8eJkyYQGFhIb169aJ3797MmzeP48ePe6q5jBw5krZt2/L4448D8Kc//YlLL72UJ598kquvvppXX32VL7/80uOp4XA4GDduHI8++ih5eXmekrU5OTkeYeXnn3/msssuIzc3lyeeeILy8nJPf/Q8TASCWGE0waVV6OUtNJPPMJC3hdE21PvTGofnnvWGV6gN5Ouvh549/Z+51e1+uWOHas9B6rIGZQRK0eMoO/3WCHQO9cZZq5TsyhXe9oK1K7Ntu6/gAdLnVq3gjTf0xZNgnijBEqSaFc705n237vEVOta+Zas60WMvnTsXRG/HZgzyaBCqcTZwoJQj4+CR2FaQkVEKN0ZKw8poeSjI50Ov2olyHaM3CjVGLjwzF6eWsb92LcyZ7Z901az3iREiUUp53Di4+ipfj5tg2OH6sovwIhAIBDHCtOjx3HPPUVsr3TTvvvtuWrVqxWeffcaQIUO44447LO+gkptuuony8nIeeOABSktL6dmzJ++++64nEenevXt9vDAuuugiXn75ZaZPn860adPIy8tjxYoVdO/e3bPOfffdx/Hjx7n99ts5cuQI/fr149133yU5ORmQPEN27NjBjh07aNeunU9/IunZIhCEgpHKH3YjElVsNMdBUVFEbSD/43Vo2lQ73ENpt2zbt0/1bbiG6Xk+n37hZ8219M6h3stwrePXqo4TbG5s/p/28tdf95pkeuJJINvIyDk3I5zpzfvS0vgSPdq1ymDjT7sp+1mdKDfChGtcWkm4xlmrDHvk8NASbsINNUlO0hc85HXCPWdGLjyjF6eesX+yylhsnRWiRSRKKed1NVeqVut8AmzfbjzGMFzsILwIYopsH9XUaKV/FwjqF/I8V+oCpkUPp9Pp08DNN9+sW9o1EowdO1Y3nGXt2rV+y2644QZuuOEG3fYcDgcPP/wwDz/8sOb3RUVFFBUVhdJVgSDqBHuDblesfi71c8hAqiiil28CpMSbl1ziu2+1R0iVX1WFluF1VLV9LdqJzhKccOSoZA/qhe8UFkm5NQB2+DuM4KzL8Wdmbpx1tvZy9fDpiSeBbKNA59xsZIPevI83Z7wOrVsDcGB/lEUPtXHpqMtGGwtjqD4YZ3rCzZIl3hKzoYSaVJ4MLHjYKZwHrBHTrPhxMKOgRoKMDKmE2dKlvsuXLfP/0YkUdhI2BTEhOTkZp9PJsWPHYt0VgSDiHD16FIAmTZp4lplOTtGlSxcefPBBtm3bZl3PBAKBJcjPygl1V7YVXhPRIiNDeullpq8ulxT27XL5Lisp8V/3t7+T2pYNZDW1Ck8QuR21R4iDRNVWh413VhPf7Z1+7Uv5OGprYfZsKaff6tXafVu6FN58s+74i/33VFhofm50zZNyeCi5+CL/8QtVWNM656tXS8d5/3Tv8RppR/PYopwLNFzOyJFUmgMH9kR/5wMHSkkkZcOopMTY4FuNbJwpURtnWhe+HmbWtQo94ebTuuor8qQP1LeBAyWB5LGZ0t+BA/XH5r7J3nWihZFxlS9MZ13FE6PCjLrtjAyvYh3N82glnbv4L5PFvGgQ6rkQ1BsSEhLo2LEjW7dujXVXBIKIs3XrVjp06EDjxo09y0x7etx99928/PLLPPLIIxQUFPC73/2Om266SeS3EAhsQiS8eWON1pt/vYStep4cXTpLfzMyJK8I9Us3p0OqTiKj1U5Tcqhgt2LJRqRkpqHytc+nZrT165OyD3Ioyb0T9b1VMltrf5eX5y3CYGZujBsHV10NWzZDt7MkIWT1amvDkWTCyUmjNe8rq8LvUzTp1Fb6HXWV743+zl0uKC6Jfcx/sJAGM/k+YpW4US+c4fkl8MILUj9AkYjUIWXvVfdN7aGgNzb9+hGQUCp2BNrGzLjq/SDpta/VNsR/Ak47eFrUx4cDgSnOPvts/vWvf7Fjxw66dNEQ4gSCesDu3bvZuXMnV155pc9y06LH+PHjGT9+PNu2beOll15i4cKFTJw4kf79+/O73/2OkSNHWtZpgUAQGrH25g0Vo+JGQYG+cWwk1GHEcMAtiQTKNiZN9D5Pa7XTki4q0WM5MC6MI37T51ManUlwesWEIUNh+XLfLWpqJe8Pdd/kY9D6TumJEcrc6Jon/ZOJ1LNzuDlp4nXey+RmZgLgOqKd2yWi2CmsJJChbDTfRywTN6rFCSVyP3yWuyUBJFR1LxChCD9a2xQUeMvOmh1X9YWp1ye9c1Zbi2aVmlZx5MoVSn6SSJSXjfebpCAszj33XLZt28arr77Kr371K7p3706reLqOBIIAHDp0iP/97398/PHH5Obmcv755/t8b1r0kOnatSsPPfQQDz30EJ9//jl33nkno0aNEqKHQBAlIvE8FEvMiBtang7KkqeaSTJVv+sjRkD3HpLQoedZoG7n9wMLeOzdDxStfAysJ7SytZ+jrNwCMHJwAeNu9NozIFVd0apso+WtIn9ndWJYLSLx7ByvOWmsokOd6HH0+EFOnTpJ48bJQbYwQbAbhh3eRCvRmmBmhJlYiziyOPHpp5KHh7offrhh69bgXhtg/OILRfjR2mbhwroSunVeKXqVZcLt09Yt2udMjby/eDPWzAhWorysIAI0atSIG264gXfeeYdPP/2Ujz76iMaNG5OYmIjDoRH3KxDEAW63m+rqak6dOkViYiJnn302V199NYmJviHjIYseABs2bODll1/mtdde49ixYwEThgoEAuvQC+2IpBAS6bbNiBvBvBmMhjqcrAzsWaBup3laH5Z83oKyI0cUW9wKfAmkmDjiSmC0z5IWKS154LY+NE70HV89AUPtraL8LlRPjGgIaYH2oRaanA7J2yWS+7QT6ampNElszInqU7hcP5KTkxd8IyMYMaCsqJQRacwIM3YQcTIy4OKLpZAWZT+0Ql/MYHRChyL8aG3j81kjds7MuOr16a1VsGKldttKTw+z+7MbRgQrUV5WEEEaNWrEtddey+DBg9m5cyeHDx+mulo7ibpAEC8kJibSokULOnfu7JPHQ4lp0UMOa3nllVfYtWsXl19+ObNmzWLEiBE0a9Ys7E4LBILA6AkEv/ziNYCVQogV6IksVqEX1qAn47fKSwAAbHhJREFUbhjxZjDybGnEs0BuQ6pWm8iEoUOZ7JMpdTNwPfAGxoSPyrr1N/v25eQQjh1N9OtzIAFjxAgp+b9eWVgzz8eRPsdG9yEf76q3JC+X5culv6H2JxrHZRUOh4O2aelsd5Vy4MAea0QPMwaU3WP+zQgzdhFxtPoxciQUF+NjyDvqbmzBMOMBEIrwo5ePRI28jtlx1Wrf4ZQED/U+HXU3dtA+j24NAaY+EGsvJUGDIDExkXwj9xyBoJ5gWvTIz8/nggsu4O677+bmm28mKysrEv0SCAQ66AkExcXeR2gzCSCDEU5ySaPoiQ+BxA2rKhkGE0/URvMdfxhKQedP2LhTWRf230Av4AUCh7p8juTh4St4pNGZju6hus+0SgFD+ZIXrPFg2Lbd+DkO1WvC7DxShvWEOudcByM/d62mQ6sMtrtKKdu/G3pa0KBZA8ruMf9mLny7iDjqfgAcPeI19M1UNTHjAWBE+FFf0FrbaHlazJkNJ6vMj6tW+0OH+CcvApg0yRvuo5fj5YfvIT0N0uPU80MLO3gpCQQCQT3DtOjx/fffk5dnkcutQCAwjZZAoJXU0kwCyECEm1zSCIHEh0B2ixX2WaD2tQz1555txCP3juem+ffxS9UJRUubgQuBXwEjgPOAlkhlab9GSlrqm8MDoBFN6cl4Ep2Ngj7TKgUYOfrWTXgeDKtXSzkU1e9Mtc5xOF4TZuaRVXNu//7Q24lVSEyHzEz4Hg7s2xl8ZSPURwPKzIVvFxFH7ofSUwNg0GC46SZjfQzFAyDQDU7Pa0S9zcaN/sJJXlepDbm8rJkLRUsEUnt6OBN8PV+0kqEuWADUxS3ePQEGDTK2f6uI1E3CLl5KAoFAUI8wLXoIwUMgiC1aAsHIQigpjkwCyGgll4y0uBEIvfb1jO9nn+jAOe4/s4GHOM0J1Vb/RUvc0KIRTenNA7RwdjCUyF8pwCi7FbInhPziWOM79TkO1+PHzDwKZc5p2R9t2oQ2d2MZEtOxjVRmqLxstzUNCgMqspgxfNWeGgDvvQs5bWD4iOD7ClXA0rrBBfMaUW5TUAAT7wUckhAhLw8n2aa6T2bmqNx35HGo6/v550dvXkc60ahdvJQEAoGgnmBa9BAIBLFH63moWdPIVOwwEgJiFXZ5KSujZXyD9DmdblzMbL5hLkcx/1Y+jc6cx3h+P7wDQ64NftxaAowSPQ+GQDaZXptOh/85tqKcrNF5ZHbO6YkUGa3021GPi/w5OSW2ITEdc6SQ0fLyPdY1KgyoyGDW8NXy1AAoLoFfXRL8vOiFhoSCUa8Rs+VlQ71QzMxRzWSrYea8CEe8ilSiUbv9IAoEAkEcI0QPgSBOUT8PRdKuaag2k9r4VgsgqXTgYuawi5X8wEqqOBK0zSRa0tkxhD8NGcqIoY1M5f/TEmBktDwYgnks6IVKzXkCuqqc+qzw+IlEOoZAHihNU7U96V9YCiuWe0OD+veHjz7yjlOkw7kC0SlbEj1ch362tmFhQFmLEcNXbUjn5KBZ8tVtYoLJE/qtVbB8hZQLY8VK854GRrxGXK66EBLZvayufG1BQWSSbRqdo56+K8rZOsII2TIrXumV1hWJRgUCgcC2CNFDIKhHRNKukdsOJYTbDrgOwmGX8X7L9kpBASxZIj3PJiXDpIkqkYBGdOY6OjGEUtbjYiOp7XfyQ9nPnKyuJjkxka5t23J+585clFfAGU360CghkW755sZPLcA4AIfDv1ytsv/BPBb0PCrUgkegdc3OAavTMQTyQOmS6tuOUgSSqXXDmg99P6uJRDiXHh0yMwE4eGw/tbW1OJ3O6OxYYI5gRr+eIV1UBMVLfbcLJcfKipX4iRFNUiC/m3nXK72Qkq1b0BRotm6VwlxilStG7vvCheCuBsJwPzTrtSGfVzXxnicn1sRLXXGBQBC3hCx6uFwuGjduTPPmza3sj0AgsDHxUP5T69lp9WqYv8BbAjdYvwMdp57nh5NEcuhHDv2Y+Qfo0UO73XlPhT5+Wl4Lep4QRsNRtDwq9J4/7ejxY9QDRS0CBcMZQFCKJG1btcLpcHC6ppojR8pIr09VKeoTgTwltAxpWZS45BLpRlRcYr5yi3xRaoZ31MLs2ebyS4RzQatFE4cz9FCbUBg4EM47D3Ztg5bNoUv30Nox47GilZMFvKV17XBDjEcinR9FIBAIMCl6HDlyhPvvv5/XXnuNw4cPA5CZmcmoUaOYMWMGTZo0iUgnBQJB7IlG6dpwX/ZoiRUFBXXLgAQD/Q52nEo7QcvzQ88rINzxU46NUlDR29ZMOIrSo0JZzcUBjB3r+/xptyiJQB4olVXe9YLlRFGS4ITZc6DqZPTFnUYJCWSntmDfscOUl+8VokcoGL2RhHPDCeQpsWlTcFHi+eeNiQ3bt0khLJ9+5jUKiwr9BRflfszcWAJd0Pnd8A/HcXirqihDbVas9IbaFBUaS8waLhkZkNIIqipDb8NMcli9nCzK0roCc0QrP4pAIGjwGBY9Dh06RN++ffn555+55ZZb6NatGwCbN2/mmWee4f333+eTTz5h06ZNfP7559xzzz0R67RAIIg+oSayNGpXhOpFEiwB5b0TzfXbyHEq7QS158fIwtDb1SOUsQklHEUO4Ze76Ub6bPfnTyMvrIPlRJEJFOITLdq1bMW+Y4c5ULabM8/sY2wj4R4useYDeHZJ8LfGVrxd1pt4Woa0jGzULVmi7Q4G3nP573/DZ5/6b1+yDAoLYdkySXBRYza/hN7cyciQVE/1OKnbVZabddfC0qXSzWNEFISPcDES5iOjJ5AoS+sKzBGJ3DACgUCggWHR4+GHH6Zx48bs3LmTrKwsv+8GDhzI73//e1avXs38+fMt76hAIIgtwTwH9MJKjBjroXpBqNvXEhV+qdDeNinZ+HECbN+hbaMMHAi//ALFxdI2JcVSJR31cYaaCDQcDxGz3utbtvqXr3UjhfDb/UVmMA8UtQikxZjRcPHFsX/W7pCZyYY9Oyjb94OxDYR7uITLBYufRfJOQP+tsZVvl7UmntqQVhPIqFOeSz1qayAvTxJOtm6FOXNCz60RbO4Eu4noeT+UlEihPLG+mIxg9EZpRiCxgoYgZIZahlkgEAhMYjhD2ooVK3jiiSf8BA+A7OxsZs+ezT//+U8mTJhAYWGhpZ0UCASxR37eS6i7ayg9B1avhtGj4f7p0t/Vq/WNdZfLv+1AXhB6aLWvJsEJzVK1t686qX+cWrewZSXafXe5pOd7efd6xxlo/AIRytio99ujR/19ZjbDwIGSnXjXndrfdzvLHuOU27o1AAf27wq+sp4BrzVZjbS1aVNo24aC1fvbtw8pkE2BLDCo19N7u2wV8mS7b7Jk1CnRM+r0ckaokbfPyJDUyLvvlpbJ3xk1xPXmzvZtvucl0E1ENlrVuE3cpOyA0RvlwIEwZzaMHiP9jZS4KP+oTr/f+6NaH5F/GEOZvwKBQGACw54e+/fv5+yzz9b9vnv37jidTv785z9b0jGBQGA/9JJehhtWEooXhF6OBnUCym750rIaE2136eK/TK/vRsJWtCrBGM0VYUWpWKN0y/eP4Hc66pf3dkYGtG2r/Z2eEBZtOuVkA1B+YE/wla1yD4+2t0gk9peTg9+7HC2BIVpvl2VR4sQJY94Bel4TSrSSZmplODZSYktv7tw7EXAHPy/yje366+H1f/h+V1/f1kfjOmloeS7smCFbIBDUOwyLHhkZGezevZt27dppfr9r1y5a172dEggE9Re1N7ee0S9XSjGaSNNs/gk9MUArAeXdd8MzCwGD1TjMCA3B1g234o3RsbHCE1oO4Q+3LK3diaaQFAqdciSPStfBvcFX1jLgHU5ITjK+w2gbWZHaX0YG/OEOeO75wAJDtMMUjBp1gXKBAJxXAH/8o/b28o3ZjFGuuz9FKVy986Lez0UXw7p12hVp7BymYaZv0bpOGmKeC7tlyBYIBPUOw6LHoEGDuP/++3n//fdp3Lixz3dVVVXMmDGDwYMHW95BgUBgb/QMyPx8f2N9ZGGdBzr+zzcDB0LHTrBlsxRmECyRpJ4YoLVdQQH8aRwkJ0r9CvZsZUaECbSuVRVvgtlMVpYSNlrC1s52TDBCEdmiiRze4jqyL/jKWvkj3LUwcZLxiRBtIyuS+7tiAPTuG3wCR/vtshGjTkuMue46aN4czuoGeV0Db2/WKFfvT0sA0TovWvv5/HN4Yg6crPIdTzvnmzHbt2hdJyLPhUAgEFiOqUSmvXr1Ii8vj7vvvpv8/Hzcbjdbtmzhr3/9K1VVVSxbtiySfRUIBDZAbT8EMiCVdsX27VKSTz3DPBTD3YjdIrdb7YZEE4KAGZtIT7AJp2KLGj2bKRKlhJX70jovYJ3IEivs7FHdoa4zx08e48SJCpo00UlMIzNwIHTqKAkdobyFNmtkhat4WeGdEgitCaxl2Nrx7XI4EzMUo1y5v+Qk3zkE2vNAbz8nq3yzPds5TCOUvkUzLCqankgCgUDQADAserRr145169Zx1113MXXqVNxu6Qnb4XBw5ZVXsmDBAjp06BCxjgoaHvH8JtkM8XScesJEoOd0+f/vv9832efChd7ny3AM90B2S7iCgFGbSG9cohFGoSesWFFxRWv8Fi70/r/81y52jFnsaPMCpDZpQlpyE46ePIHLtZcOHfTzaXmoPBn6W2gzRpYVb+6t8E4xcuO0s9EdCLlvem5xeoRqlCsvBLXnx8iR2kmYjOzHzmEaofRN7zoBYzlUzGBnVVYgEAjiEMOiB0CnTp145513OHz4MNu3bwegS5cupKenR6RzgoaLle76diaejlNPQEhpIiXADGRAapVCrXV7DXMrPSKURKpdJcGElUiHUeiV2J0zR8qfGM580ho/reSxVo+pANq1SOdo6QkOHNhjTPQI9y20ESPLShFB9k6Rk2aaac+o8GJnozsQoQpLRsSrYGLRwIFw/BcoLpH2X1ICzZr57t+oSBbunFT31co3BKH2TX2dbNwoVVeJRPiOXVVZgUAgiENMiR4yLVu2pHfv3lb3RSAAIuOub0fi7Tj1BITZs8MXbCLlERFLTwvZrrLyhZ3WM79sfyjnElgzn7TGzwE4bJwEtL7QoVUG/yv9ibJ9BsrWgjUu8cGMLKtFhMqT+MmhwdozI7zEY26EcIWlQDccI2KKy+UVPALt38iNLZw5qe5r//7w0Ue+fb/yyuDtyMekd+MMpW/ydRKvnkQCgUDQAAlJ9BAIIkk03s7bgXg7Tj2PAghuYGuVQnXgLYUaKY+ISLSrfn42IqwYeWEX7CVmIK+ggQMlj5vZs323CXc+yeO3YIHvuevfH9autWcS0FCxW5hZ+0wpmemBfTuNbxRpl3irRYRQ2jMjvMRjbgQrhCWtG45RA93s+AbrUyhzUquvH67xfi/3/bzzICXIY2wgoSfc6yVePYkEAoGgASJED4HtsHs5SauIt+NUCwhq1Aa22ogcO9bfaDf74jAU5HZ37YVOHcJrV094CFdYCRbmZMQrqFt+ZOZTQYHk2eGWIxCQBA+t0sBWEk0Rwo5hZnLZ2gNle8xtGMQQra6uoaLiNOnp3qShhw5VkZraiMTEhOBtWykihNKenlBy9Ig0aVKb+q4fb7kRIuWdYtRAj8T+zYZpaPVVjdz3M9rrr2NE6AknhCQePYkEAoGggSJED4HtiEYeBDsQj8cp2w9bt0peBcq3/0oDW8+INOINHcirPVQjOCMDmqZCiqo4hJk2AwkPWtVbArWt/A6CCxpGvIIiNZ/09i0LHmZzLRohmiKEXcPMOuVk1/Vvr2VtVlfXMGvWt+zZU8HMmb3JzEyhvLySadM2kJubyuTJ5wYXPqwWEcy2pxZKHE6orYuzczjhjjFw1bX+29j5xqokUt4pRg10rfEdOsR3nUgrklp9VWNEXIi0J0Yo58puLmUCgUDQQBCih8CWxNvLuVCJx+PMyJCSj544oW1gBzMiQznGN9+E4mJJZLHKCDZrWAcSHjZu9G1LDj/Xalu936HDggsaRr2CIjGf9Pa9fTtMn26NMGFWBLISu4aZdcySwltch3+yrM2KitPs2VNBWZkkdIwffw5z526irKzS8316ehDRA3xzGlhRtcLsjUGtvioToT77HPTuGx83Uz0icSGbMdDl/b+1ClashOXLpb933+2b5NTqxJ2B+nrZZZKLmbrve3fCj7vhzETIzPRtJ9KlkcHcuQoUaiPEEIFAIIgoQvQQ2JZ4ejkXDsGO067PQnrPelYbkW8uh6XF3s9WGMGhvN3XM/6Tkv3bWvOhdn/Bf92VK4zlBDHqxWH1daO175GFUFIcnjAhz+sdO71tGRWBrMSuYWYd6gy4QxUHOH26mkaNEsNuMz09iZkzezNt2gbKyiqZMmU9AFlZKcyc2dsn5CUoVpSuDYeMDGjeHL9EqO4o5lSI5M05Ej+AZsWUFSt9Q0MWLMBnvCOZuFOrr7/7ne/n996DhfOA00CKFEMZqMqM3GczpZGNYDRpk16ojayax+paEggEggaAED0EAhtjx1wDSrSe9aw0Il0uySBWE64RHIowoyc8nKzUTu6q1bbbrV0CdvhwWLUysKARS68g9b7DFbaU81pJrVsaB3XS20iKEHYNM8tq0YLGCQmcqqnh0KF9tG6da0m7mZkpjB9/jkfwABg//hwyM1OMN2KXqhWab/KjlFNBdj/DHV+GqlExRTOvhlYW6wiKTOq+Kj/LcxC5jwGqzIRaGtlK9EJttm61x7UkEAgE9RwheggENsWuuQaCYaURqWVcgySqhGPXhCrMaAkPLpd+VRuttrX2O+Ra6V8wQcPKl79mX1Kr9x2qsKWe12pqao2JQFZixzAzp9NJTvN0dh8up7x8rzWih8tF+eYfmVt8xGfx3LmbPDk+DGGXqhVaYRC3j46869zyN6F4qfdzfTRUjeTVAGmdWLhF7duHV/CoQ28OhlIa2Wr0cqrgtse1JBAIBPUcIXoIBDYlUrkGohEuY5URmZPj/9YfoLDQ94Wf2eMJR5jRevmobksOP9dqO9B+o/WMG64HUTjjpydkyZgRgazEjuF07dJbsftwOWWluzj77F+F19jq1RxasJRpDKeM5mQ1h/HT+nhyekybtoFZsy40FuISi6oVehe6+majrt6ixGhITrAsxMUl/tvUN0NVS1CqrcXvblxUGJtjzskBnL7L9OagHaqs6OVUye8W+74JBAJBA0CIHgKBTYlErgGlsesAhg2XjMtoeCZbhQO45BLp/99c7psPwozxbuXbfSPh50b2Gw1ByioPolDHT2tey8RKBLIruZmZfLJzKwf27QqvobqTnoqDXA4CMLNiJZmte3lyfOTmppKaavCRQG3AOZxQODJyJyyYWKG82VRVardhNCQn2L70yqnGyuMhkqgv8o0bVee8EIaPiE3fPHPw6bpzFSAxq5kkrpFE76Zph74JBAJBPUeIHgKBTbE614Da2HUjJeVfucJ+4eiy8X/0mL+XhxvpmfHjj8NPcGqlMBMo/NzIfs16X4QqkFjpQRTK+GkmRh0JeXn2CS2xCx3qKrgc2P9DeA3VGeqJwGTeo4Ik0t0nYP9+Mnv0YNasC0lNbRS8XK2SgQPhl1/qyirVSt4PTZuZv5EEm8hW5Q8xEpJjZF96YR+FFng82DFrtfIiN6t0Rvp4Bg6E/M7w0x7oeo5/9RZlHwoKYMmS2Mewad00Cwpg4r2AA/Lz7XPuBQKBoB4hRA+BwMZY6Y2gF1Zgt1whauNfK6llUnJdDkEV0S41atUzvVnvi3DCU+xQrUQvN8q+fdL3dpiHduCMnGwAysv3hteQwlBPpIZ0Tvi40Juq2iKfqJRkKCkhrOSQRsJNrMofkpOD391E7Z0RKNlkv37SZy0vlyILPB5iXQ3HKEaVzmgdT6tW0KwJpAe4Udp5TOOhjwKBQFAPEKKHQGBzrPJGCBRWEG2xQA8t418WPmrdvhVTtNJChJvg1AzqUKGiIhgRot1jxvsi3PAUu1QrUc7raFQpqqmu5nRFBUnp6Z5lVYcO0Sg1lYTE8MvBRoKObbIAcB36MbyGrHLvVxpoWtl2zIgRRj04IpmPwa3qv54Xx5w5cOKEd1JanfnWLtVwrCLax3PoIPxUDm3bmvPaiTXx0EeBQCCoJwjRQyBoIMh2j1bljGi/6ddDy/ivdcPk+yAtTfLwOFkJySnaAk5hUXSeFbVChZYWSzbQTTeZ74MZ7wsrwlPsVK0kGlWKaqqr+XbWLCr27KH3zJmkZGZSWV7OhmnTSM3N5dzJk20pfOS2lsJbXEf24Xa7cTgcoTcW7klXG2hasqMZMcKoB4dVgs2+fRp9dvvuT3mTVPZNyxi1MjbOLtVwrCKax/Phh7DkOSBRyushK6bxMKbx0EeBQCCoJwjRo4Fhx5BhQfSQ7Z5Vb0W3JKhR9Iz//Hwph57SG6B/f2+FFKdDCqkfMTw6/dQLFXr3PelluBFPBfW12L8/rPnQ+/1ll2mfE6vCU+xSrSRSVYqUnK6ooGLPHirLytgwbRrnjB/PprlzqSwr83yfoPAAsQvt6wagqrqSiopDNG/eKqz2qtNaUuFM9QlnOXSoylg+j0AJPN215sUIMx4cVqh0evtLToJNm7wX4sCB0CQFZs/23T6SxqiRsQj1x9vKGDyj7USrWorLJeXpQMNTwg4VW4IRD30UCASCeoIQPRoQ0XAhF9ifjAy4dVT0S4IaQS/0Avy9AdauhdlzoOpk8GNwueCHPXBGrjXP/ckp2qV05b4F81RQV50pLIKPPvJdZ+1aqQKMug27hKdYRTRyjCSlp9N75kw2TJtGZVkZ66dMASAlK4veM2f6hLzYieTGjclsmkr58QrKy/eGJXpUV9cwa9a37NlTwcyZvcnMTKG8vNJTuWXy5HMDCx96Btqc2XCyyvyNxKwHR7gqndb+LrsMJk7yz6cQ7TKiwcYi1LwPVuWLMNuOVt6ToUPM7zcY+/bhETxkZHGqRw/7V0WxS1UZgUAgaADEneixcOFC5syZQ2lpKeeeey7PPPMMvXv31l3/9ddfZ8aMGezevZu8vDxmzZrFVVdd5fne7Xbz5z//mb/97W8cOXKEiy++mEWLFpGXl+dZ59ChQ/zxj3/krbfewul0ct111/H000/TrFmziB6rlUTDhVwQX9jlTb8arZe6mzZpewNUnZSebQMhP69XuyExDLFPLRpedBF8+pn2uoE8Fd5807/qjCyAGG0jUCLQePPiioaI43LBvv2ZtLv1PrY/fq9n+Tnjx5OiVfHBRrRr0apO9NhD587nhdxORcVp9uypoKxMEjrGjz+HuXM3UVZW6fk+PT2A6KFnoOV1DblPUYuz0qrgkZzkFTzAP4Ql2sao3liEmvfBqnwR4bRTq9hm+XJYsdLaty05OYATH+FDKU7ZKY5Pj3joo0AgENQD4kr0eO2115gwYQKLFy+mT58+zJs3j0GDBvH999/Tui72Wclnn33Gb37zGx5//HGuueYaXn75ZYYNG8bGjRvp3r07ALNnz2b+/PmUlJTQqVMnZsyYwaBBg9i8eTPJyckA3HLLLezfv5/333+f6upqRo0axe23387LL78c1eMPh2i4kAsEVqEWZEL1BrBK7NNq5/PP4cYb4PXX/T0+9PrmcmlXnZGToaqr1AQ6vmgnAo0kkXzu9004ewaXMYCz+ACATXPnenJ82JX2GRl8/fNuyn4Or2xtenoSM2f2Ztq0DZSVVTJlynoAsrJSmDmzt7EKLpE4UZFWX/W8FDZtCpxPwcyxWqU4ao1FqHkfrMoXodfOp5/CxRdrtyXfMNV3RqsTdWZkwJgxdTk90Ban7KruKzHax3hVtgUCgcAGxJXo8dRTT3HbbbcxatQoABYvXszbb7/NCy+8wJQ6d2UlTz/9NIMHD2bSpEkAPPLII7z//vssWLCAxYsX43a7mTdvHtOnT2fo0KEALFu2jKysLFasWMHNN9/Mli1bePfdd/niiy/o1asXAM888wxXXXUVTzzxBDk5OYb773a7cauzxUeJNm3qKmAoliU4IDvbP4F9QyCW50JgnlatpGfZv/4VatzS3L3zTml5oNP488/S+gDuuv9O10rPja1MRAoo25E5XQvnnguDBytypATp288/+zljA9K7ysJCWLbM28bvfy+t73YHt7cWLPC2W+OW7I3zzouv5+JWrbznxKpLs9zlZsECt2ds3DhZy10MmTKYn16YzYmyMtZPncqFs2bZNsSlQ2tJkCnb90PY96yMjGTGjevB1KnrPcvGjetBRkay8bYjcaIsxOfeLl8cnpwPNd6Lo00b/H4VHQm+P4ryRRzoQpRFFWqBMEJI1Abt9m3wv83QVi61q7xzOCGpceDxN3J8RtBqB+D5v8Hzz2sf788/S2OtRe1p8zdgHdxuN+7+/XHnd8VdWesdOxvOy7Cxap7VE+LtGc7tJq76KxDUR+JG9Dh16hRfffUVU6dO9SxzOp0MGDCAdevWaW6zbt06JkyY4LNs0KBBrFixAoBdu3ZRWlrKgAEDPN+npaXRp08f1q1bx80338y6deto0aKFR/AAGDBgAE6nk/Xr1zN8uH/mxKqqKqqqqjyfjx07BsCREyeojVGFgEYpUDhGekaRjapRo6XlR47HpEsxpbKqiqrTp2PdDYEJel8MnfOhrAyysqRn5mBzt2kLqEF6TKylilpOk+CAKjd8ukF6/jfy7K1sRybBAU3SpGtoxI1w6RWB+3bwIPxcDqfx9wy55bdw+SA4t5fUxs4fYEmJ5/GWMWPg8su1+/b9D1ClWlbthm27pL41ZLbtqqIK/+t8/U85nHv3A+xe8BC0a8cvTieVx+15I8xuJYkx+/fv4PjxI2G15XJV8tRTG4FKz7KnnvqMGTMKyMiIk8ly8CCUlupevFVVlZw+XXdF/PA9fleHuxp2bYOzzoIxhdKPortGEgRGj4KURiCP84cfKhJlOv0vxIMHYeE8fO4Mf30a8jubM+p99uOAdm3hp5+83+edCTt2+AoJE8cFvjGkNPI9Ppxw1SA4cRSOm3j082tHhdbxtmiK/x2zDkcCpDXxjnEYuN1ujh8/yqnkBJLatJWqG1nQru2wap7VI3yu8zigpgYqK4/FuhsCQYMmbkQPl8tFTU0NWVlZPsuzsrLYunWr5jalpaWa65eWlnq+l5cFWkcdOtOoUSPS09M966h5/PHHeeihh/yWnzx1isSq2N2k+14MXbvBgQPQujW0SofK+PnNsJSTp07FuguCEGjSDDrVpdIxMnebNIORo6B4KdRwCifQuy9Mn+EVFIpGwaWXGG9H3u73RdJyuR+B+vafj73bykVH3XXtXH8DDLhS2qZJM2h+Cl562ft4Wws8t0S6dltpOCOkpXvXk3ECzVvGx/V98JBCLLLY2aJFunSdq02v4r+Dk6b87sYHOXdAIqdqayGG9+ZAtMmUBsV1cC9VVZVB1tbnyJFTPPbYV7hcJ8nISOb227vx3HNbKC8/ysMPr+P++8+nRYvGVnU7Mnz8n7qEOHVX4agiuORSn1VOnTrp/ZCeVvc/qqujZXOoqoSL+0K3rt4fxfRW0nKAQwfrwiYUV+KS56T10+sMzR93g1pUc9fCT3ugWRNjx+S3H+Cnvb7rbN8Co8fA8y8E7o8a+fjeXw3vroa3V8Hb/9Ict4DI7XzxBbz6iu93WsfbrAmMGqk4VzJOKPq99H0Yc9mza7ebU6cqOXWqiqqqyvBKOtsZK+ZZPcPnOo8Damqgujq++iwQ1DfiRvSIJ6ZOnerjYXLs2DHat29PdosWNG/RInYdA9qkA11i2gVbUFlVRUqSgRh2Qdxz8zAY0A927a0iLTWJSRNB6W/1arH0fbBQELkds+kMXC54ZanvPhMcMHGiVIpX3U75T77ryrgr665fFW3SYcLdvqE/d90F3aN8nYcSbu7Jt4Ek1Fjtsd2iaRUT7k7yjI2aN15PZ/AgyLBnZAsAPc84A4Ajxw6Qnh569ZDU1Bo6dTqI0+mt3nLGGR091Vvat28XvGxtLHG5YOkr+Fwdxa9CvwE+E66qqpKkpDqvlfQ2cPcE6eKQvTnuugu6dPe2kd5G+zfxp3I0r8RKt7QNwJmJQAp+ISRdz4F0gxeB3n7U7DsYvD9a1CbCu/8h2LgFJb0NtMiGV1dg6HiH3SztQ04aG0qFnyC43W6SklKoqqokPb2NcdEj3nJjWDHP6hk+13kcUFMDzZs3jXU3BIIGTdyIHhkZGSQkJFBWVuazvKysjOzsbM1tsrOzA64v/y0rK6ONImNgWVkZPXv29Kxz4MABnzZOnz7NoUOHdPeblJREkoZB7XA46u+biDhDnAtjxNuzoRpl/3t0d7D9ewduvN4WICW4LC0FI7ksMzONradk/34099mihXZbbdtKwoU6aWtODuhN2UGD4Pzzo1sAQDm2GzeaT6TqctXZoniTuC5aJB0HWDPvHA4HgwY5OP98Ke/ikud9vzdz7mNFbl3njh4/SHV1FY0bJ4fUTuPGjZgypWddlRbp96l16ybMnt2X1NRG9hY8QJrc6ivJXet3Av3u7aFeHG3bSoalumyt8kLMzISxY/2rvJiZUFr70aJXL3j3vcD90cLguBnC7PGGcsM0iXy+Df+mW1XGN5pYMc/qGfH2DOdwEFf9FQjqI3EjejRu3Jjzzz+fNWvWMGzYMABqa2tZs2YNY8eO1dymb9++rFmzhnHjxnmWvf/++/Tt2xeATp06kZ2dzZo1azwix7Fjx1i/fj133nmnp40jR47w1VdfcX7d0/iHH35IbW0tffr0iczBCgQWEY5oEe8VQdT9H3MH9O0dWhWYcDBbeSbUEq7RLFLgWxFFQj48oxVy9CpKrXoLVq6wdt5lZEiFJl54Ibrn3grSU1NJSWxMZfUpXK4fycnJ81/J4IWemJjgV5bWUNUWO5CTIxmpaqPfyAkM5eIwWrY23Io28n6UZWHVXH4FXNA7tDK64YybFvFcYtWqMr6xIJ7HXSAQCGxA3IgeABMmTKCwsJBevXrRu3dv5s2bx/Hjxz3VXEaOHEnbtm15/PHHAfjTn/7EpZdeypNPPsnVV1/Nq6++ypdffslzz0nlzRwOB+PGjePRRx8lLy/PU7I2JyfHI6x069aNwYMHc9ttt7F48WKqq6sZO3YsN998s6nKLQJBtAlHtLCq1Gus0Or/c89KokcogkI4hCJiRPP51qwwph5brXz0Rsph64lBK5abF1CMEKqYFGscDgft0tLZ7iqlvHyvv+gRj2+uQ8GoCGElRi/EcBVHeT9vrYKVq6TjczglpW74MMjraq4/6r5pjRtIZXtDUcTjoQysFlaV8Y0V8TruAoFAYAPiSvS46aabKC8v54EHHqC0tJSePXvy7rvvehKR7t27F6fT6Vn/oosu4uWXX2b69OlMmzaNvLw8VqxYQffu3nje++67j+PHj3P77bdz5MgR+vXrx7vvvktysteF+KWXXmLs2LFcccUVOJ1OrrvuOubPnx+9AxcITBKuaKH3Fl79bGjX8BfN/rul/sfihVmotkqk+xaKMKY1tmqMeFBoiRBDhsLy5b7rGRFQjBKvL0vbp2ew3VVK6b5dnHuu4otQ31zb9cINRixOYLQMzYwMGHUrXDsk8PGF0h/1uG3cCKNH1x+h7NBBKTdK27bBlVYrvV4EAoFAEDfElegBMHbsWN1wlrVr1/otu+GGG7jhhht023M4HDz88MM8/PDDuuukp6fz8ssvm+6rQBArjIoWehgJybBz+Itm/x3e/sfihVmk9hmq/RqqMKY1tg7A6TTvQaG2xcAb2iJjdQhKPL4szW2dCdugfP8Pvl+E8uY63j1D4vEEmiFSxye3G88hHlp8+GFd9ZtEKTdKoPkcC28hgUAgENiCuBM9BAJBcMzmkVATLBTA7uEvWv0ffbs9+mYl4QhPoQpjenMj1BfwahsvHkNQIk1uG8mb8UDpLt8vzL65rm8Gr8A88R7iocTlgiVL8FQ1MTKfCwpg4r2AQ7t8lkAgEAjqJUL0EAjqIVbkLwjkSR6uJ0k0UPe/aWr09m3E+yLcCINwhadwhDG9uRHuuXe5IDsbZs+BqpPxFYISSTrlSJXCyl17fb8w++a6Phm8gtAwKpTFQwjUvn34lHGFwPM5Wl5O8TB2AoFA0MAQoodAUE+xIvxdz9M6XE+SaKHsf2VVdPZpxPvCitCgcIWncIUxq73wtcakRw/r2o9nOma1BsB18Cf/L81c6NHKaVDfjb5YHJ9V+zQilMVLCFRODuDER/jQm8/R8nKKl7ETCASCBoYQPQSCekwkw8OjGYZghVfED3vgjNzIV0IJ5n1hVWiQFcJTJPJChnKu7B4uFWtyW0uix8Fj+6mtrfVJ2A0Yv9CjkdOgvht9sTg+q/cZ6MI3Iw7EWtzKyIAxY+pyehB4PkfDy0mEjwkEAoFtEaKHQCAIiWgVUgjXK0LevtoNiRFOuGrE+8Kq0CAt4WlkYZ3HN7Hx2Aj1XMVDuFQsyUlPx+lwcLqmmiNHykhPD8Mzw8oLV2301nejLxbHF6l96l34RsQBl0sqr7tiZezFrcsvh25dodIdWHyJhpeTCB8TCAQC2yJED4FAEDKRLqQQrgdAqNu7XLBlq/T/3UzkujPifWFlaJDSft2+HUqKjQsOVr+kDedcxUu4VKxIbNSI7NQW7Dt2mPLyveGJHhD8wjUyObS8D7Kz67fRFwujNtr7TElGqsekuBiV4sDq1bBgge/3sRa30ltBehtwOPTXiYaXkyiJKxAIBLbFGXwVgUAgiB4uF2za5LW79DwAjBDK9qtXw623wuzZ0r9bb5WWGUF+rnYqnr1ra2HjRv91EuruvuGGBmVkSM/UJSX+goPLpb3N6tUwejTcP136a/T4AhHOubJ6TOoj7Vq2AuBA2e7I7kieHNPv158cet4HKcmS0aekPhl9slGrJNLHF819rl4NEyfhJ3jIF6N83nH7bysLMXZm4ECp2stjM6W/VnumeH4AEqTPoiSuQCAQ2Abh6SEQWEisQ5zjHXV4RGGhtgdAUrIkjAQbZ6MeBPJ5S06RXmIqH+ndmHuJWVAAbuVLUI3trQ4NMhMeEqn8GeF6a0QrXCpe6ZCZyYY9Oyjb90PkdmI0lELP++BkVeTfpsfyJhsNbwEz+7RyLNTnHiSxZc5syOsqfdY67zLxIm5F2j1R3MgEAoHAlgjRQyCwiHBzTzR0wUTLGF+2DAqLYFmJN2/FZZfBpInGxtlIwlX1edN4h2kqv8S+ff5taG1v5bO3nuBw5Kg0rtEoN2xFcttI2yNmsNv1KCczPbB/V+R2YjSUIpAbf48ekTP67JAkNRZGrdY+rR4LrXPvrpWELBmt8w7Co0GNnW5kAoFAIACE6CEQWEK4b8+tKGEarH92MuC00DPG87pInsj790seHrLgAcbGWbYXdu2FTh20CxUo29PCjMdCLPJTqAUHp0MKq5k9238+7djhv71V/asvLzkjfT2GQqecbADKD+yJ3E6M5iQI5vEQCaPPTklSY2HUKvdp5VjIPw5yaFKwcz9sqG8C02FD4doh8XuxCwQCgaBBIEQPgcACwnl7HulynXY04LQIJBbIz/ubNoU2zhkZ0DQVUpJ8l2udNzVOh2TPgTekRt5WS0SKdjlfGVlw2LpVEjvkw1LOJ5Byf6gZWWhd/+L9Jaddy+d2ysmS+nfox8jtxEz4RrQVLlEZw4tVY6H2FunfH9au1T736nWHDxdih0AgEAjiBiF6CAQWEM7b/UiW6wxkwMn7tov3hxGxwGovCr32Zs+BA2XS5/x8KRHp6NHSenKOUjfaIpLLJRWxmD0Hqk4aswet8sTJyIDmzfXDa9xubZEnr4v5fcWD91Ao2LV8bofMTABch3+O7I7MiBnRVLjsUBnDLpPeirHQ8hZZu1bK4XGyyvfca627cpUkeggEAoFAEAcI0UMgsIBw3u5HMhxCz4Bb9RasXGE/74+CArh3oiQs5GuUirXai0Kvva550j/wF46Uw6n2AtDyqunRI3AfrPbECTafrJhr9Tl/jV3L58qix/GTxzhxooImTVIjtzM7uuvEIomoEjvkE5GxYiwCJaNV37SEl41AIBAI4hwheggEFhGqt3ckwyG0DDinwyt4QGzc97WMXqOGtNVe9cHaCxYCoyzLajYsIhKhFFrzaeRI73iHO9fsnr8mHOR5qU6ea4ccjc2bNCEtKYWjVZW4XHvp0OHs2HYoFsQqaYyd8onIhDsWZrxF7OBlIxAIBAJBGAjRQyCwkFBfkEbqWV7LAB4yFJYv910vmu77WkZvQYE5Q9rqF9GB2tMSjpTIXgChhEVEKpRCOZ+274CSYt/xlhPDhjLXws1foywJXOuWznus82WAdrnkvDx7JWRt17IVR0t/ory8gYoeEBsvFLt6OoQzFma8RWLtZSMQCAQCQZgI0UMgsAmRepZXCyrg6+kB0XPf1/MSuPJKe+ZRAO3KKG63ZLirvQDMhkXoeeIkJVvTb4Dp0/3He8mS4GE3eoQT/rFlq3++kVq3lHy1X7/Q+mMFeuWSlyyJ/fxT0r5VBv8r/YmyfT/A+bHuTQOivno6mFHbtda1c5yaQCAQCAQKhOghEIRBvDzzqQWVWFQXAX0vgXff81/XDnkUZLSEI7WdEEqYknobkMZn0kRrwj4i4UkSq+o0kcSuyUvVdMhsDUDZvl3R33m83OwiQX32dDCjtivXDZTjJNS50pDnmEAgEAgiihA9BIIQsXNugmDEKjRez7NBK3RkyFB7PfeqbQOrqngOHAgdO0lCR6DwnlDsgUgl5Qx1/nTLl5LUKk+3nLQ2ltg1eamajm2ksrUHSqMsetgpiWesiNVN044EynGycWNoc0XMMYFAIBBEEGesOyAQxCN6YRouV2z7ZYaMDCnEIZrP7vIL04S6O0+CU0oa6XT4rud0wJBro9cvKwllXE9W6nsagGQPjB4N90+X/q5ebbwv6vG26gV1KMeZkQFjx3rPt9MhfY61/RjJcbKSM9pmA+A6uDd6O9UzcOPpZmcVsbhpRgqXCzZtCu086uU42bo1tLki5phAIBAIIozw9BAIQiBe3OHBfh7DWi9MmzWtX+ESZtFLlrp9uzRG4VRL0XtBbWZeWDmH7PrC3K79UpLbWipb6zr0U/R2atckngJzKC/iUL0xZPRynOAOba6IOSYQCASCCCNED4EgBOLFHd6uITjqUJF4MDhlIiEiZWRIHi9Ll/ouX7YMMluHL7Cpx9vMvIjEHIpFAQ4j2LVfMrmtpZwehyoOUFNzmoSEKPyE19ckng0JdeiI240nyCyU8rt6OU7yu4U2V8QcEwgEAkGEEeEtAkEIxIM7fLyF4MSD53goYSZGvci7dPZfVlMr5bxQh/+EI7CZmRfxNofqO1ktWtA4IQG3u5aDB3+Ozk7lm50zQfpcn5J4NgS0QkfUNZTk0BQz4S4DB0rljR6bKf0dODD0uSLmmEAgEAgijPD0EAhCxO7eCfEUghMP6AkAgV6QmvGSSE7R9h7Kz7e2WoqZeSHmkL1wOp3kNE9n9+Fyysv30rp1rvRFpGPY7H6zE+ijFTqixuGE2bMBt7lwFy3XqFDniphjAoFAIIggQvQQCMLAzu7w8RKCEy+YFQDMiCRKcURGKW5YaQ+YmRdiDtmPdumt2H24nLLSXZx99q+iV/XCzjc7LeyWzChWaIWOOOpcFN21kldFrcL7I5RwFzWhzpV4m2MCgUAgiBtEeItAYHNCTbIfDyE4VhFOIQKjyAKAkkACgJ5I8umnvv1UiyMg7Wf2HF/b1arwHzPzoiHNoVCJxtxTkpspJTM9sG+XqHqhhxyHNv1+c+WO6iNaoSN33w3PPy+Fpky8F81wF7l0lEAgEAgE9QDh6SEQ2Jhwk0g2BI/haCVrVebuMxJmoleRZcnz8MIL3n5qiSO1bqg6af0xyJiZF9GeQ/H0gj4WiYI7ZEnJTA/s/0FUvdDioI4QFI7nQryjdxFnZEgXnEgiKhAIBIJ6jhA9BAKbEkoOCS3qs8ewVWNkZD/79kntLlliTABQiyRKlP2MVQiJmXkRrTlk12pDWkRr7qk5IycbgPLyvaLqhRb79wshSAu9i1ivEktDHiuBQCAQ1DuE6CEQ2BSRRDI4Vo6RnodBOIa4/IL1008lDw+tfvboYW2i0nglViJCqMTq+uzYJgsA16GfhMGqRZs2QggyS0NwCRQIBAJBg0aIHgKBTRFJJINj1RjpCRtWGOIZGXDxxVJIi14/I2lzRDNcJJx9xZvIF6vrs0NdTg/XkZ9xu904GqrBqjfZWgkhSJdAF2h9dgkUCAQCQYNHiB4CgU0xm0OiIWLFGAUSNowa4mpbQv3ZSD/DsTki4aVilnD3FW8iX6yuz/Z1O6iqruSXXw6Tmpre8AzWYBVrGqoQFIhoVfkRCAQCgcCGCNFDILAxDeXZPRwPgXDHKJCwYcQQVxv7/fvDRx/5G/+ROpeR9FIxilUeMfEm8sXi+kxJSiKjaSqu4xUcOLBHEj0aEnoVa9STraEJQYEwOmYCgUAgENRThOghENiceHt2NytgWOGNEM4YBRI2ghniWsb+mg+97aiNf6vPpRVeKlZg1b7iUeSLxfXZvkUrXMcrKC/fS+fO50V357FGVKwxjxgzgUAgEDRwhOghEAgsI5iAoRUGEuvklcGEjUCGuJaxr0Zt/FuZYyNcLxWrsHJf8SbyxYJ2GRl8/fNuyn7eGeuuRJ/6VrEmGkl3UpLr15gJBAKBQGASIXoIBA2AaDxXBxMwtASR7Gx7JK8M5mGgZ4hrGftqlMa/1Tk2wvFSsZJ4DE2JZ3JbtwbgwP5dMe5JDKhPFWuikWdDuQ+ZeB4zgUAgEAhCQIgeAkE9J1rJLAN5HYC2IDJ7jn2SV4biYaBl7F92Gaxd62/8R8KrJRwvFauJx9CUeKVTXdnaAwd2x7YjZrFKfa0Pky0aeTbU+wBJXJkzG/K6WrMPgUAgEAjiACF6CAT1mGiGjwTyOtATRKpOxr+HgNL+SkqGk5Vw1dXSsSntsWCiUKQSuUYzXESEpkSHM9pJqqDL9WOMe2ICq70a4n2yhZNnw6h4pLUPdy2crAqtz9EgmjW2BQKBQNBgEKKHQFCPiWYyy2BeB3qCSI8e8f/SNiMDNm7096jp0cO7jp4otH0HTJ8eu0SuSoS9ER90yMwEwHX4pxj3xCCieog/oeYmMSMexVv+E1FWVyAQCAQRwhnrDggEgsghG9pKIhk+MnAgLFkCMx+T/srPq7IgkuD09kEpiGRkSAJBvNo/eh41Lpd3Ha0xGDkSSooDbxctVq+G0aPh/unS39Wro98HI7hcsGlTbMYoGNHqW26d6HH0+EFOnToZ2Z1ZQSCvhoaKfENwJkifjeTZ0BOP9CZcKPuIFWaPTSAQCAQCEwhPD4GgHhOLBJN6XgfhhOHb3QNBz6Nm61bo18+7TD0G0fTECYQdqugYIVr5aUIhmn1LT00lJbExldWncLl+JCcnLzI7sop48ziIFmZviqGExMRL/hNRVlcgEAgEESRuPD0OHTrELbfcQvPmzWnRogWjR4/ml19+CbjNyZMnufvuu2nVqhXNmjXjuuuuo6yszGedvXv3cvXVV9OkSRNat27NpEmTOH36tOf7N998kyuvvJLMzEyaN29O3759ee+99yJyjAJBJNDzvogFoXh0xIMHgpZHDcCcOf79VY5BtD1x9AiWb8QOGPGmiRXR7pvD4aBdWjoA5eV7I7MTK4knj4NoY+amKItHSoyIR/HgShfqsQkEAoFAYIC4ET1uueUW/ve///H+++/zr3/9i48//pjbb7894Dbjx4/nrbfe4vXXX+c///kP+/btY8SIEZ7va2pquPrqqzl16hSfffYZJSUlFBcX88ADD3jW+fjjj7nyyiv597//zVdffUX//v259tpr+frrryN2rAKB1cTDM68WdjZ0lXhsOpWAEay/wcJ+ooVdxJdA2FmYiUXf2qdLk6R0X5yUrZXV18dmxl59jVfqs3hUn49NIBAIBDEnLsJbtmzZwrvvvssXX3xBr169AHjmmWe46qqreOKJJ8jJyfHb5ujRozz//PO8/PLLXH755QAsXbqUbt268fnnn3PhhReyevVqNm/ezAcffEBWVhY9e/bkkUceYfLkyTz44IM0btyYefPm+bQ7c+ZMVq5cyVtvvcV5550X8WMXCBoydgr/CBZeM3AgnD4Nixb7Lg/WXzt4n8ciDMosgaoDxZpY9C23dSZsg/L9P0RuJ1YT7xVX7IAdbhiRoj4fm0AgEAhiSlx4eqxbt44WLVp4BA+AAQMG4HQ6Wf//7d15fNTVvf/xdyYkk0RIQtYhmARQIaC0CNQYxZUUqKilpdeqkc3U5SG0vYJe8SEtYq/FnYe1eK1Xgd5WpKUu9Qq1IIhWiKC5CAgU+QkYJTshRErINuf3xzAjYxayzXxneT0fjzwg3+XM5ztnZpLvJ+d8ztatbZ5TXFyspqYm5efne7bl5OQoKytLRUVFnnZHjhyp9PR0zzETJ05UXV2ddu/e3Wa7TqdTX331lZKSktqNt6GhQXV1dV5fALouEEYgdHZ6zbp10nPPtd7emXitHolTXS05HNJjjwfGNKi2BMqomLZYEVv2ANfPrcryQ757EAQmqz8wfCmUrw0AYJmgGOlRXl6utLQ0r219+vRRUlKSysvL2z0nOjpaiYmJXtvT09M955SXl3slPNz73fva8sQTT+j48eO64YYb2o138eLFWrRoUavt9Q0NimpoaPc8+E89/RAUzuon/eQO6fnfSS1GioyQCm93ba/vYhd2p8+rj0i/+a3kLq/XYqRnlkrDL5BSkts/zq0n8frL2xuk3z3nit0m6Y47pXOHBma8l13heu7Ly11JmpTkjuP05/u8q7H11MBU1wuwsvKgGhrqffdAQYbnInwYY9TQUK/GxpNqaKhXREQbhZUQkoLtfd7SIjU2BlfMQKixNOkxf/58Pfroox0es3fvXj9Fc2YrV67UokWL9Ne//rVVEuZ0999/v+bOnev5vq6uTpmZmYq12xVrt/sjVHQCfdFz/lhV5bprpLyLemfEc1f7/Gi1FCEp8vSNRqo9ImVmnOE4Sffd6716S6CprpZe+J137C8+73q+A/UPrZkZ3s/9mfjzfd7V2Hpi6NkDJUlHastkt8f650GDBM9HeDDGqLnZlVm022NJeoSZYHqft7RI0dFNVocBhDVLkx7z5s3TzJkzOzxmyJAhcjgcqqys9Nre3NysmpoaORyONs9zOBxqbGxUbW2t12iPiooKzzkOh0Pbtm3zOs+9uss32121apV+8pOfaPXq1V5TZtpit9tl54YaIc6fS3RaVQqgM7UaqqulY3WuxMHp5UcibVJOjr8i7Z5AqZmCrstKTZUkHTlWKqfTKZstKGarAgAA+J2lSY/U1FSlnvrFrSN5eXmqra1VcXGxxowZI0nauHGjnE6ncnNz2zxnzJgxioqK0oYNGzR16lRJ0r59+1RSUqK8vDxPuw8//LAqKys9IzfWr1+v+Ph4jRgxwtPWyy+/rFtvvVWrVq3S5MmTe3TNQKDoySiN9lZVGT06tG6Wz1Tg8/TET4S+TnxYVW+iq30ayMVB0bGBycmyRUSouaVJx45Vqn//tv8AAAAAEO6CoqbH8OHDNWnSJN1222167rnn1NTUpDlz5ujGG2/0rNxy+PBhjR8/Xv/zP/+jiy66SAkJCSosLNTcuXOVlJSk+Ph4/fSnP1VeXp4uvvhiSdKECRM0YsQITZs2TY899pjKy8u1YMECzZ492zNSY+XKlZoxY4aefvpp5ebmemp9xMbGKiEhwZonBOihno7SCKcRAu0tKPDNxI872XHPPa4RHv5+HrrTp8GwagvaFtWnj9L7Jqjsq1pVVn5O0gMAAKAdQTMe9qWXXlJOTo7Gjx+va665RuPGjdPzzz/v2d/U1KR9+/bpxIkTnm1LlizRtddeq6lTp+ryyy+Xw+HQq6++6tkfGRmpN998U5GRkcrLy9Mtt9yi6dOn66GHHvIc8/zzz6u5uVmzZ8/WgAEDPF8///nP/XPhQC9rb5RGdXXn2wiEVVX8qa0FBdpL/CQkWDPCo7t9OmGCa7UWK1dtqa6Wdu7s2msQUmaS64VWVfm5xZEAAAAErqAY6SFJSUlJWrlyZbv7Bw0aJGO870BiYmK0dOlSLV26tN3zsrOztXbt2nb3b9q0qcuxAoGsN0ZpMEIgsKaG9LRPraqZIvm3NkyoyUxJ0bbP/5/KD39mdSgAAAABK2iSHgB6R2eLc56pNkR70z5CTXvPRSAlfgIpAdMV4VIbxlcGnVpivar8kLWBAAAABDCSHkCY6UpxzjP95d3KEQL+8M3n4vtTpOuv+/qaR4+W5t3jKmBqRR0Pt0BKwHRFONWG8YVBGa6kR2XFIWsDAQAACGAkPYAw1NninF39y3tPVoQJNG09F6+9Jr3+mjRnjmtbIE3LCMaRN8E6QiVQDMlwFS+trvnC4kgAAAACF0kPIEy1NUqjJ395D7XaDG09F5JrlRZ3maBAm5YRbCNv/u//pNNLMdkigmOESqDIOrXke/XRwxZHAgAAELiCZvUWAL7X3VVZerJ6iC9X7uhJ2209F25O035yCJ3jfs18M680erQl4ficL17n7qTHv07W6cSJr3qvYQAAgBBC0gOAh7s2ROSpT4bO1oboaIRIR9atkwoLpQcWuP5dt677sZ+p7bc3dO38bz4Xp7NFhNeSvb7Q1mvGaUIzceSr13l8XJwS7LGSpOrqkt5pFAAAIMSQ9ADgZcIE6YUXpF8/7Pq3M1NUYmK7ngToyeiQM2mr7ed/1/W23c/FD37w9fVF2lzJkO4kh4KFL0ffuHV3VFGw8eXrXJLO7p8sSaqqIukBAADQFmp6AGilK7UhTq/l4daZJIAvVu5wF1I9VtdG26Z7baekSLfOcq3a8s0iocFWOLQz/FWbJVhXnOkqX69Qk5mcot3lX6qy7GDPGwO6I5QqWAMAQhJJDwDd9s2/YkuuG+XHHpeGntfxub29csfpN+sRcn2dfq8ZGdGzUQRtJYKCrXDomfR09Z7T2+nMPVAwrjjTVb5eoSbzVF2P8sMHeqdBnBk3+V9zf/AapxRhC/4K1gCAkMT0FgDd1l5dhoaTrv93NE2iu/VD2vLNm3V3SKe3ffsd3J+cSXdrs5yuq/UrUlKkkSNDt29683XelsEDXMvWVlUe6p0G0TH3C3zBA71fiCjYeKoRO13fG2fvzt0CAKCXMNIDQLd19FfszkyT6K2/9Ld1s24k3XOPlJDgavusfq7t/JG2fT0dldBbI0VCjS9HtAwemC5Jqqr6vPcaRdvau8kP1xd4aenXz4Wbs6X35m75Cz8UACDkkfQA0G3t1WWQOn/z25MpIu7fVd2FVL95s56T83Xb9Q3+q1cRrHpaZ8PX9SuCma+mQg1KS5MkHTl6uPcbh7dQucnvLRkZriktpz8ntsjgqkbM9BwACAskPQD0SFt/xd650/c3v99MYFx1lbRpU/s369VHpN/+9uupL07jOj9c/0jbnp6MSvB1/Qq0lnWqpkdNXaVaWpoVGcmPdZ8JhZv83nR6ltTZ4nougqkaMSN3ACBs8NsRgB775l+xfX3z29Y0ik2bXAVUG062fbO+b593YVP3ef/8pzRuXO/EFSq6OyohXFZkCSSO/v0VZYtUk7NFNTWlSk3Nsjqk0BXsN/m+EMzViBm5AwBhg6QHAC+9Mb3Z1ze/7U2jaDjpKooJ6wTzPVAwstlsykjor8+PVquy8nOSHr7GC7y1YF3GipE7ABA2SHoA8OjNmhe+vDfozkiStPTW2yLkqvuB3hWs90DBKjMpxZX0KD+k88+/zOpwQh8v8NDAyB0ACBskPQBI8s3KG766N+jqSJJ166Tf/NaV5HBzJ3V6Eh9F/xEIslJSpM+kitIDVocCBBdG7gBAWCDpAUBS8K280dnfVT3JHEmRp7bZIqTHn5CGntf9xw/UlWBIxISfbIdrGFNl+UGLIwGCECN3ACDkkfQAICk4V97ozO+qbSVznMZV/6O7fDEqpjcEaiIGvjU4wyFJqqr83OJIAAAAAo/N6gAABAb3lJHIU58KobLyhjuZc7qeJnM6GhVjlfYSMdXV1sUE/xg8wDXSo7rmS4sjAQAACDyM9AAsEKhTEEJxerM7mfPMUkmmd5I5gTgqJtimJ6H3ZKWmSpKqaw/LGKOIiIgznAEAABA+SHoAfhboUxBCcXrzhAnS8Auk2iO9k8zx9ZK83RGIiRj4R+apF15DU72OHz+qfv2SLI4IAAAgcJD0APwoUGtBhIOUZCkzo/faC7RRMYGYiIF/xNrtSjmrn6r/9ZUqKz8n6QEAAHAakh6AHzEFIbQE2qiYQEvEwH8yE5NV/a+vVFVVonPOudDqcAAAAAIGhUwBP/JFUU3gdCkp0siRJDzCzdmnOryi9IDFkQAAAAQWkh6AH4XqCikArOUuZlpJ0gMAAMAL01sAPwvFKQiBuhoNEC6GZDgkSVWVn1scCQAAQGAh6QFYINBqQfREoK9G01kkbhDMBg88lfSoLrE4EgAAgMBC0gNAt4XKajShkrhB+MpOS5MkHTl62OJI4DdkagEA6BSSHgC6LRRWowmVxI0vcE8VPNw1PWr/Va3GxpOKjo6xOCL4lDtTa5xShI1MLQAAHaCQKYBuC4XVaDpK3ISzV1+Vbr1VemCBVFjousdC4Eru10+xUdGSpOrqLy2OBj7lztQap+t743RlaqurrY0LAIAARdIDQLeFwmo0/kzcVFdLO3cG/r3Jq69Jy1dI7lyQe/RLoMcdziIiInR2QpIkqaqKYqYhrbT064SHm7PFP5naYPkQAwDgNExvAdAjwb4ajTtx8+yzrhEevkrcBEvdkOpq6fcrWm8PtmlL4SgzKUX7q8tVUXZI+rbV0cBnMjJcU1pOT3zYIn0/xI4pNQCAIEXSA0CPBftqNL5O3ART3ZC2pvtIrkRNME1bCkdZaanSp1Jl6WdWhwJfOj1T62xxJTx8PcSuvSk1gfghBgDAN5D0AOAXgV4U05eJm2Aq+Oqe7vPNeGfMCLxY4W3QgHRJUmX5IWsDge/5e4hdR1Nq+GAAAAQ4kh4AfC5Ypnb4SluJhEAt+PrN6T62CGnGTOmHP7A6MpyJO+lRVU1Nj7DgzyF2Vk2pAQCgF5D0AOBTwTS1w1f8VTektwR7nZZwNdjhSnpU1xy2OBKEHCum1AAA0EtIegDwqWCa2uFLwZZICPY6LeEoKzVVknTkWKmcTqdsNhZoQyd1Zv5hsH2IAQBwCkkPhIxArxkRroJpaoevkUgIX/74fBqYnCxbRISaW5p07Fil+vd3+OaBEFq6sioLH2IAgCAUNH8GqqmpUUFBgeLj45WYmKjCwkIdP368w3NOnjyp2bNnKzk5WX379tXUqVNVUVHhdUxJSYkmT56suLg4paWl6d5771Vzc3Ob7W3evFl9+vTRqFGjeuuy0EvWrZMKC6UHFrj+XbfO6ojg5h4VHXnq0ybQp3YAvc1fn09RffoovW+CJKmqqsQ3D4LQ0t6qLNXV1sYFAEAvCpqkR0FBgXbv3q3169frzTff1Hvvvafbb7+9w3Puvvtu/e///q9Wr16td999V6WlpfrhD3/o2d/S0qLJkyersbFRW7Zs0e9//3utWLFCv/zlL1u1VVtbq+nTp2v8+PG9fm3omfZqRvA7W+CYMEF64QXp1w+7/g2nIqbwn+pqaefOwHrv+/vz6ez+yZKkyopDvnkAhJaOVmUBACBEBEXSY+/evXrrrbf0wgsvKDc3V+PGjdMzzzyjVatWqbS0tM1zjh07phdffFFPPfWUrr76ao0ZM0bLly/Xli1b9MEHH0iS1q1bpz179uiPf/yjRo0ape9973v61a9+paVLl6qxsdGrvTvvvFM333yz8vLyfH696JqOakYgcKSkSCNHMsIDvhGoo738/fnkrutRUXrANw+A0OJeleV0rMoCAAgxQZH0KCoqUmJiosaOHevZlp+fL5vNpq1bt7Z5TnFxsZqampSfn+/ZlpOTo6ysLBUVFXnaHTlypNLT0z3HTJw4UXV1ddq9e7dn2/Lly3XgwAEtXLiwU/E2NDSorq7O6wu+464ZcbpwrRkBhKN2R1McsTYuyf+fT9lpaZKkyrKDvnkAhBb3/ENbpOt7VmUBAISgoChkWl5errRTv8i59enTR0lJSSovL2/3nOjoaCUmJnptT09P95xTXl7ulfBw73fvk6T9+/dr/vz5+sc//qE+fTr3dC1evFiLFi1qtb2+oUFRDQ2dagOdd1Y/6Sd3SM//TmoxUmSEVHi7a3t9O093Pf0Qdujz0HXgc6mpjdEUh75oUEqyNTG5defzqSfOTnfdrFaUH1BDQ33vP0CAC8dr7rErLpMuGC6Vl0sOh5ScIgXB82iMUUNDvRobT6qhoV4RERFnPgkhIdje5y0tUmNjcMUMhBpLkx7z58/Xo48+2uExe/fu9VM0rbW0tOjmm2/WokWLNHTo0E6fd//992vu3Lme7+vq6pSZmalYu12xdrsvQg17110j5V3UtZX06IvwQ5+HpiHZUlQbKwQNygyMPu/O51N3Dc0cKEk6cvSw7PZY3z2QVTqxDE5IXrevZWS6voKIMUbNza7Mod0eS9IjzATT+7ylRYqObrI6DCCsWZr0mDdvnmbOnNnhMUOGDJHD4VBlZaXX9ubmZtXU1MjhaHtJPofDocbGRtXW1nqN9qioqPCc43A4tG3bNq/z3Ku7OBwOffXVV/roo4+0fft2zZkzR5LkdDpljFGfPn20bt06XX311a0e2263yx4Av2iHG1bSAzon1JZ3do/Qf/ZZ1wgPzwpBFo/yOJ2/Pp/c01uOHG273lVQ68rSqghsofYhBAAIaJYmPVJTU5V6quhaR/Ly8lRbW6vi4mKNGTNGkrRx40Y5nU7l5ua2ec6YMWMUFRWlDRs2aOrUqZKkffv2qaSkxFOMNC8vTw8//LAqKys902fWr1+v+Ph4jRgxQlFRUdq1a5dXu88++6w2btyov/zlLxo8eHC3rx0ArOC+b3QaV62JULlvnDBBGj3aezSFL6aPBDp3IdPjJ4+pvv64YmP7WhxRL2lvadXRo7lpDjYkrwAAfhYUhUyHDx+uSZMm6bbbbtO2bdu0efNmzZkzRzfeeKMyMjIkSYcPH1ZOTo5n5EZCQoIKCws1d+5cvfPOOyouLtasWbOUl5eniy++WJI0YcIEjRgxQtOmTdOOHTv097//XQsWLNDs2bNlt9tls9l0wQUXeH2lpaUpJiZGF1xwgc466yzLnhMA6KpQX96ZFYKk+Lg4JZwa9l1VVWJxNL2IpVVDQ3vJq1D5EAIABKSgSHpI0ksvvaScnByNHz9e11xzjcaNG6fnn3/es7+pqUn79u3TiRMnPNuWLFmia6+9VlOnTtXll18uh8OhV1991bM/MjJSb775piIjI5WXl6dbbrlF06dP10MPPeTXawMAf2B55/AwMDFJklRV9bnFkfQillYNDSSvAAAWCIrVWyQpKSlJK1eubHf/oEGDZIz3b/MxMTFaunSpli5d2u552dnZWrt2bafjePDBB/Xggw92+ngACBTu5VO/WfCT+8bQkpWSqj0Vh0Nr2drTC7c4W1haNVi5k1enJz5IXgEAfCxokh4AgJ5pt+An940hJfNUXY/ywwcsjqSXtVW4BcGF5BUAwAIkPQAgjHDfGPoGD3CtUFZVecjaQHyBZbqCHx9CAAA/I+kBAGGG+8bQNnhguqQQq+mB0MKHEADAj4KmkCkAADizQaeWYD9y9LDFkQAAAFiPpAcABKHqamnnTlZ6RGtZp2p61NRVqqWl2eJoAAAArMX0FgAIMuvWSUuXulZhsUW46gJOmGB1VAgUjv79FWWLVJOzRTU1pUpNzbI6JAAAAMsw0gMAgkh19dcJD8n177PPMuIDX7PZbMpI6C9JqqoqsTgaAAAAa5H0AIAgUlr6dcLDrcXpWggBcDu7f7IkqaLsoMWRAAAAWIukBwAEkYwM15SW00XaXCs/Am7Zp+p6VJL0AAAAYY6kBwAEkZQUVw2PyFOf3pE26a67WP0R3rIcrmVrK8oOWBwJAACAtShkCgBBZsIEafRo15SWAQNIeKC1IRkOSVI1NT0AAECYI+kBAEEoJYVkB9o3yJEmSao68oXFkQAAAFiL6S0AAISY7DRX0uNIbamMMWc4GgAAIHSR9AAAIMRknhoGdLLphI4fP2pxNAAAANYh6QEAQIiJtduVclY/SVIVdT0AAEAYI+kBAEAIOjsxSZJUWfm5xZEAAABYh6QHAAAhKDMlVZJUUcqytQAAIHyR9AAAIARlpbqSHpUkPQAAQBgj6QEAQAgakuGQJFUxvQUAAIQxkh4AAISgwQNPJT2qKWQKAADCF0kPAABCUHZamiTpyNHDFkcCAABgHZIeAACEIHdNj9p/VaupqcHiaAAAAKxB0gMAgBCU3K+fYvpESZKqqr6wOBoAAABrkPQAACAERUREKDMxWZJUVUVdDwAAEJ5IegAAEKLOTnIlPSrLD1ocCQAAgDVIegAAEKLcxUwrSw9YHAkA+Fl1tbRzp+tfAGGtj9UBAAAA38hOdyU9KsoY6QEgjKxbJy1dKhmnFGGTZs+WJkywOioAFmGkBwAAIWrwQIckqbqamh4AwkR19dcJD8n177PPMuIDCGMkPQAACFGDHOmSpKqaLy2OBAD8pLT064SHm7NFKiuzJh4AliPpAQBdxDRhBIvs1FRJUs2xMjmdzjMcDQAhICPDNaXldLZIacAAa+IBYDmSHgDQBevWSYWF0gMLXP+uW2d1RED7BiYnyxYRoaaWRh07Vml1OADgeykprhoetkjX97ZI6a67XNsBhCUKmQJAJ7mnCTuN63uncU0THj2a36UQmKL69FF63wSVfVWrqqoS9e/vsDokAPC9CRNcP5zLylwjPPghDYQ1RnoAQCeVln6d8HBrcTJNGIHt7P7JkqTKikPWBgIA/pSSIo0cScIDAEkPAOisjAzJFuG9LdLGNGEEtqxTdT0qSg9YHAkAAID/kfQAgE5yTxOOPPXJGWljmjACX3ZamiSpsuygxZEAAAD4HzU9AKALmCaMYDN4oKuOR1Xl5xZHAgAA4H8kPQCgi1JSSHYgeAwekC5Jqj7yhcWRAAAA+B/TWwAACGHumh7VRw9bHAkAAID/kfQAACCEuWt6HD95TPX1xy2OBgAAwL+CJulRU1OjgoICxcfHKzExUYWFhTp+vONf3k6ePKnZs2crOTlZffv21dSpU1VRUeF1TElJiSZPnqy4uDilpaXp3nvvVXNzs9cxDQ0NeuCBB5SdnS273a5BgwZp2bJlvX6NAAD0tvi4OMXbYyVJVVUlFkcDAADgX0FT06OgoEBlZWVav369mpqaNGvWLN1+++1auXJlu+fcfffdWrNmjVavXq2EhATNmTNHP/zhD7V582ZJUktLiyZPniyHw6EtW7aorKxM06dPV1RUlH7961972rnhhhtUUVGhF198Ueeee67KysrkdDp9fs0AAPSGsxOTtKfisKqqSpSVNcLqcAAAAPwmKJIee/fu1VtvvaUPP/xQY8eOlSQ988wzuuaaa/TEE08oIyOj1TnHjh3Tiy++qJUrV+rqq6+WJC1fvlzDhw/XBx98oIsvvljr1q3Tnj179Pbbbys9PV2jRo3Sr371K91333168MEHFR0drbfeekvvvvuuDhw4oKSkJEnSoEGD/HbtAAD0VGZyivZUHFZl2QGrQwEAAPCroJjeUlRUpMTERE/CQ5Ly8/Nls9m0devWNs8pLi5WU1OT8vPzPdtycnKUlZWloqIiT7sjR45Uenq655iJEyeqrq5Ou3fvliS98cYbGjt2rB577DENHDhQQ4cO1T333KP6+vp2421oaFBdXZ3XFwAAVsk6VdejovSgxZEAAAD4V1CM9CgvL1faqV/Y3Pr06aOkpCSVl5e3e050dLQSExO9tqenp3vOKS8v90p4uPe790nSgQMH9P777ysmJkavvfaaqqurddddd+nIkSNavnx5m4+9ePFiLVq0qNX2+oYGRTU0nPmC4XP19EPYoc/DD33+tYGpyZKk8tL/p4aG9pP2wS6Urw3ejDFqaKhXY+NJNTTUKyIiwuqQ4CfB9j5vaZEaG4MrZiDUWJr0mD9/vh599NEOj9m7d6+fommb0+lURESEXnrpJSUkJEiSnnrqKf3oRz/Ss88+q9jY2Fbn3H///Zo7d67n+7q6OmVmZirWbles3e632NEx+iL80Ofhhz53GZZ9tiSp5mip7PbWP7dCSahfH1yMMWpudiU27fZYkh5hJpje5y0tUnR0k9VhAGHN0qTHvHnzNHPmzA6PGTJkiBwOhyorK722Nzc3q6amRg6Ho83zHA6HGhsbVVtb6zXao6KiwnOOw+HQtm3bvM5zr+7iPmbAgAEaOHCgJ+EhScOHD5cxRl9++aXOO++8Vo9tt9tl5xdtAECAcC9bW13zhcWRAAAA+JelNT1SU1OVk5PT4Vd0dLTy8vJUW1ur4uJiz7kbN26U0+lUbm5um22PGTNGUVFR2rBhg2fbvn37VFJSory8PElSXl6edu3a5ZVQWb9+veLj4zVihKu6/aWXXqrS0lKv5XE//fRT2Ww2nX322b36fAAA4AvZqamSpJq6SrW0NJ/haAAAgNARFIVMhw8frkmTJum2227Ttm3btHnzZs2ZM0c33nijZ+WWw4cPKycnxzNyIyEhQYWFhZo7d67eeecdFRcXa9asWcrLy9PFF18sSZowYYJGjBihadOmaceOHfr73/+uBQsWaPbs2Z6RGjfffLOSk5M1a9Ys7dmzR++9957uvfde3XrrrW1ObQEAINA4+vdXlC1STtOimppSq8MBAADwm6BIekjSSy+9pJycHI0fP17XXHONxo0bp+eff96zv6mpSfv27dOJEyc825YsWaJrr71WU6dO1eWXXy6Hw6FXX33Vsz8yMlJvvvmmIiMjlZeXp1tuuUXTp0/XQw895Dmmb9++Wr9+vWprazV27FgVFBTouuuu029+8xv/XDgAAD1ks9mUkdBfklRVVWJxNAAAAP4TFKu3SFJSUpJWrlzZ7v5BgwbJGOO1LSYmRkuXLtXSpUvbPS87O1tr167t8LFzcnK0fv36rgUMAEAAObt/sj4/Wq2KsoMaMWKc1eEAAAD4RdCM9AAAAN3nrutRWXbQ4kgAAAD8J2hGegQz9wiUuk8/lWJiLI4GklTf1KSmqCirw4Af0efhhz735oiKlCQd3bFB8WkZFkfjGw1NTbLT52HBGCNbY72imxoVf1YCS9aGkWB7nztbJEe1U5JajUoH4B8Rhnefz3355ZfKzMy0OgwAAAAAFvniiy9Y/RGwAEkPP3A6nSotLVW/fv34S0QAqKurU2Zmpr744gvFx8dbHQ78gD4PP/R5+KHPww99Hn6Ctc+NMfrqq6+UkZEhm43qAoC/Mb3FD2w2G1ndABQfHx9UPzDRc/R5+KHPww99Hn7o8/ATjH2ekJBgdQhA2CLVCAAAAAAAQhJJDwAAAAAAEJJIeiDs2O12LVy4UHa73epQ4Cf0efihz8MPfR5+6PPwQ58D6A4KmQIAAAAAgJDESA8AAAAAABCSSHoAAAAAAICQRNIDAAAAAACEJJIeAAAAAAAgJJH0QNCrqalRQUGB4uPjlZiYqMLCQh0/frzDc06ePKnZs2crOTlZffv21dSpU1VRUeHZv2PHDt10003KzMxUbGyshg8frqeffrpVO5s2bdLo0aNlt9t17rnnasWKFb19eWiDL/pckn72s59pzJgxstvtGjVqVKs2Dh06pIiIiFZfH3zwQW9eHtpgVZ9L0s6dO3XZZZcpJiZGmZmZeuyxx3rrstABX/V5SUmJJk+erLi4OKWlpenee+9Vc3OzZ/+mTZvafJ+Xl5f75DrD2dKlSzVo0CDFxMQoNzdX27Zt6/D41atXKycnRzExMRo5cqTWrl3rtd8Yo1/+8pcaMGCAYmNjlZ+fr/3793sd053XFXqPFX0+aNCgVu/nRx55pNevDUAAM0CQmzRpkvn2t79tPvjgA/OPf/zDnHvuueamm27q8Jw777zTZGZmmg0bNpiPPvrIXHzxxeaSSy7x7H/xxRfNz372M7Np0ybz2WefmT/84Q8mNjbWPPPMM55jDhw4YOLi4szcuXPNnj17zDPPPGMiIyPNW2+95bNrhYsv+twYY37605+a3/72t2batGnm29/+dqs2Dh48aCSZt99+25SVlXm+Ghsbe/Py0Aar+vzYsWMmPT3dFBQUmE8++cS8/PLLJjY21vzud7/rzctDG3zR583NzeaCCy4w+fn5Zvv27Wbt2rUmJSXF3H///Z5j3nnnHSPJ7Nu3z+t93tLS4rNrDUerVq0y0dHRZtmyZWb37t3mtttuM4mJiaaioqLN4zdv3mwiIyPNY489Zvbs2WMWLFhgoqKizK5duzzHPPLIIyYhIcG8/vrrZseOHeb66683gwcPNvX19Z5juvO6Qu+wqs+zs7PNQw895PV+Pn78uM+vF0DgIOmBoLZnzx4jyXz44YeebX/7299MRESEOXz4cJvn1NbWmqioKLN69WrPtr179xpJpqioqN3Huuuuu8xVV13l+f4//uM/zPnnn+91zI9//GMzceLE7l4OOsEffb5w4cIOkx7bt2/v8XWg86zs82effdb079/fNDQ0eLbdd999ZtiwYT24IpyJr/p87dq1xmazmfLycs8x//Vf/2Xi4+M9fexOehw9etQHVwa3iy66yMyePdvzfUtLi8nIyDCLFy9u8/gbbrjBTJ482Wtbbm6uueOOO4wxxjidTuNwOMzjjz/u2V9bW2vsdrt5+eWXjTHde12h91jR58a4kh5LlizpxSsBEGyY3oKgVlRUpMTERI0dO9azLT8/XzabTVu3bm3znOLiYjU1NSk/P9+zLScnR1lZWSoqKmr3sY4dO6akpCSvxz69DUmaOHFih22g5/zZ5+25/vrrlZaWpnHjxumNN97o+kWgS6zs86KiIl1++eWKjo72bJs4caL27duno0ePduNq0Bm+6vOioiKNHDlS6enpnmMmTpyouro67d6926u9UaNGacCAAfrud7+rzZs39+blhb3GxkYVFxd79ZXNZlN+fn67788z/cw9ePCgysvLvY5JSEhQbm6uV/939XWF3mFVn7s98sgjSk5O1oUXXqjHH3/ca0obgNDXx+oAgJ4oLy9XWlqa17Y+ffooKSmp3fnX5eXlio6OVmJiotf29PT0ds/ZsmWL/vSnP2nNmjVe7Zz+i7O7jbq6OtXX1ys2NrYbV4Qz8Veft6Vv37568skndemll8pms+mVV17RlClT9Prrr+v666/v8rWgc6zs8/Lycg0ePLhVG+59/fv373Rb6Dxf9Xl7n9vufZI0YMAAPffccxo7dqwaGhr0wgsv6Morr9TWrVs1evTo3ri8sFddXa2WlpY2++Kf//xnm+e013en9617W0fHdPV1hd5hVZ9LrtpNo0ePVlJSkrZs2aL7779fZWVleuqpp3p8XQCCA0kPBKT58+fr0Ucf7fCYvXv3+iWWTz75RN///ve1cOFCTZgwwS+PGY4Cqc/bk5KSorlz53q+/853vqPS0lI9/vjjJD26IRj6HL0rGPp82LBhGjZsmOf7Sy65RJ999pmWLFmiP/zhDxZGBqA7Tv+5/a1vfUvR0dG64447tHjxYtntdgsjA+AvJD0QkObNm6eZM2d2eMyQIUPkcDhUWVnptb25uVk1NTVyOBxtnudwONTY2Kja2lqvvwhWVFS0OmfPnj0aP368br/9di1YsKBVO99cFaCiokLx8fGM8uiGQOnzrsrNzdX69et71Ea4CoY+b+997t6HrrG6zx0OR6vVIjrTnxdddJHef//9DuNG56WkpCgyMrLN91ZH/dvR8e5/KyoqNGDAAK9j3Cszded1hd5hVZ+3JTc3V83NzTp06JBXghNA6KKmBwJSamqqcnJyOvyKjo5WXl6eamtrVVxc7Dl348aNcjqdys3NbbPtMWPGKCoqShs2bPBs27dvn0pKSpSXl+fZtnv3bl111VWaMWOGHn744Vbt5OXlebUhSevXr/dqA50XCH3eHR9//LHXL1vovGDo87y8PL333ntqamrybFu/fr2GDRvG1JZusLrP8/LytGvXLq8b3/Xr1ys+Pl4jRoxoN27e570rOjpaY8aM8eorp9OpDRs2tPv+PNPP3MGDB8vhcHgdU1dXp61bt3r1f1dfV+gdVvV5Wz7++GPZbLZWU50AhDCrK6kCPTVp0iRz4YUXmq1bt5r333/fnHfeeV7Lz3355Zdm2LBhZuvWrZ5td955p8nKyjIbN240H330kcnLyzN5eXme/bt27TKpqanmlltu8VrirLKy0nOMe8nae++91+zdu9csXbqUJWv9xBd9bowx+/fvN9u3bzd33HGHGTp0qNm+fbvZvn27Z1WHFStWmJUrV5q9e/eavXv3mocfftjYbDazbNky/1x4GLOqz2tra016erqZNm2a+eSTT8yqVatMXFwcS9b6gS/63L1k7YQJE8zHH39s3nrrLZOamuq1ZO2SJUvM66+/bvbv32927dplfv7znxubzWbefvtt/1x4mFi1apWx2+1mxYoVZs+ePeb22283iYmJnpV1pk2bZubPn+85fvPmzaZPnz7miSeeMHv37jULFy5sc/nSxMRE89e//tXs3LnTfP/7329zydqOXlfwHSv6fMuWLWbJkiXm448/Np999pn54x//aFJTU8306dP9e/EALEXSA0HvyJEj5qabbjJ9+/Y18fHxZtasWearr77y7HcvM/rOO+94ttXX15u77rrL9O/f38TFxZkf/OAHpqyszLN/4cKFRlKrr+zsbK/Hfuedd8yoUaNMdHS0GTJkiFm+fLmPrxbG+KbPjTHmiiuuaLPfDx48aIxxJT2GDx9u4uLiTHx8vLnooou8lseE71jV58YYs2PHDjNu3Dhjt9vNwIEDzSOPPOLry4XxXZ8fOnTIfO973zOxsbEmJSXFzJs3zzQ1NXn2P/roo+acc84xMTExJikpyVx55ZVm48aNPr/ecPTMM8+YrKwsEx0dbS666CLzwQcfePZdccUVZsaMGV7H//nPfzZDhw410dHR5vzzzzdr1qzx2u90Os0vfvELk56ebux2uxk/frzZt2+f1zFnel3Bt/zd58XFxSY3N9ckJCSYmJgYM3z4cPPrX//anDx50qfXCSCwRBhjjJ8HlwAAAAAAAPgcNT0AAAAAAEBIIukBAAAAAABCEkkPAAAAAAAQkkh6AAAAAACAkETSAwAAAAAAhCSSHgAAAAAAICSR9AAAAAAAACGJpAcAAAAAAAhJJD0AAOiBBx98UKNGjfL540RERCgiIkKJiYldPnfQoEGe82tra3s9NgAAgEBF0gMAELJmzpypKVOmWB1Gr1m+fLk+/fRTSdKTTz6p/v376+TJk62OO3HihOLj4/Wb3/xGkvThhx/qlVde8WusAAAAgYCkBwAAQSIxMVFpaWmSpGnTpulf//qXXn311VbH/eUvf1FjY6NuueUWSVJqaqqSkpL8GisAAEAgIOkBAAhLdXV1io2N1d/+9jev7a+99pr69eunEydOSJLuu+8+DR06VHFxcRoyZIh+8YtfqKmpqd12r7zySv37v/+717YpU6Zo5syZnu8bGhp0zz33aODAgTrrrLOUm5urTZs2dSn+tLQ0XXfddVq2bFmrfcuWLdOUKVNIdAAAgLBH0gMAEJbi4+N17bXXauXKlV7bX3rpJU2ZMkVxcXGSpH79+mnFihXas2ePnn76af33f/+3lixZ0qPHnjNnjoqKirRq1Srt3LlT//Zv/6ZJkyZp//79XWqnsLBQGzdu1Oeff+7ZduDAAb333nsqLCzsUYwAAAChgKQHACBsFRQU6PXXX/eM6qirq9OaNWtUUFDgOWbBggW65JJLNGjQIF133XW655579Oc//7nbj1lSUqLly5dr9erVuuyyy3TOOefonnvu0bhx47R8+fIutTVx4kRlZGR4nbdixQplZmZq/Pjx3Y4RAAAgVJD0AACErWuuuUZRUVF64403JEmvvPKK4uPjlZ+f7znmT3/6ky699FI5HA717dtXCxYsUElJSbcfc9euXWppadHQoUPVt29fz9e7776rzz77rEttRUZGasaMGVqxYoWMMXI6nfr973+vWbNmyWbjRzwAAEAfqwMAAMAq0dHR+tGPfqSVK1fqxhtv1MqVK/XjH/9Yffq4fjwWFRWpoKBAixYt0sSJE5WQkKBVq1bpySefbLdNm80mY4zXttNrgBw/flyRkZEqLi5WZGSk13F9+/bt8jXceuutWrx4sTZu3Cin06kvvvhCs2bN6nI7AAAAoYikBwAgrBUUFOi73/2udu/erY0bN+o///M/Pfu2bNmi7OxsPfDAA55tp9fPaEtqaqrKyso837e0tOiTTz7RVVddJUm68MIL1dLSosrKSl122WU9jv+cc87RFVdcoWXLlskYo/z8fGVnZ/e4XQAAgFBA0gMAENYuv/xyORwOFRQUaPDgwcrNzfXsO++881RSUqJVq1bpO9/5jtasWaPXXnutw/auvvpqzZ07V2vWrNE555yjp556SrW1tZ79Q4cOVUFBgaZPn64nn3xSF154oaqqqrRhwwZ961vf0uTJk7t8DYWFhbrtttskuWp6AAAAwIUJvwCAsBYREaGbbrpJO3bs8CpgKknXX3+97r77bs2ZM0ejRo3Sli1b9Itf/KLD9m699VbNmDFD06dP1xVXXKEhQ4Z4Rnm4LV++XNOnT9e8efM0bNgwTZkyRR9++KGysrK6dQ1Tp06V3W5XXFycpkyZ0q02AAAAQlGE+ebEYwAAEHAiIiL02muvdTupsWnTJl111VU6evSoEhMTezU2AACAQEXSAwCAIBAREaGYmBglJyfryy+/7NK5559/vg4cOKCTJ0+S9AAAAGGFmh4AAASB/fv3S1KrFV86Y+3atZ4VZOLj43s1LgAAgEDGSA8AAAAAABCSKGQKAAAAAABCEkkPAAAAAAAQkkh6AAAAAACAkETSAwAAAAAAhCSSHgAAAAAAICSR9AAAAAAAACGJpAcAAAAAAAhJJD0AAAAAAEBI+v+1PwkyHgicTQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from quantify_core.analysis.readout_calibration_analysis import (\n", " ReadoutCalibrationAnalysis,\n", ")\n", "\n", "analysis = ReadoutCalibrationAnalysis(dataset)\n", "analysis.run()\n", "analysis.display_figs_mpl()" ] }, { "cell_type": "markdown", "id": "cedf3211", "metadata": {}, "source": [ "The image above shows that the measured IQ points are clustered in two groups as expected. We can now fit a line between the two groups and from there obtain the `acq_threshold` and the `acq_rotation` parameters, that we add to the qubit configuration:" ] }, { "cell_type": "code", "execution_count": 8, "id": "b5248b66", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "fit_results = analysis.fit_results[\"linear_discriminator\"].params\n", "acq_threshold = fit_results[\"acq_threshold\"].value\n", "acq_rotation = (np.rad2deg(fit_results[\"acq_rotation_rad\"].value)) % 360\n", "\n", "q0.measure.acq_threshold(acq_threshold)\n", "q0.measure.acq_rotation(acq_rotation)" ] }, { "cell_type": "markdown", "id": "2129abfd", "metadata": {}, "source": [ "## Verifying parameters\n", "\n", "We can quickly verify that the qubit parameters are set correctly by running again the {{ readout_calibration_sched }} schedule with `\"ThresholdedAcquisition\"` as acquisition protocol. If the calibration was done correctly, we expect that when the state is prepared in the {math}`|0\\rangle` state or {math}`|1\\rangle` state, the thresholded acquisition will return 0 or 1 respectively. The results are then verified using a confusion matrix:" ] }, { "cell_type": "code", "execution_count": 9, "id": "05ce38b3", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "cluster.delete_dummy_binned_acquisition_data(1)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(acq_rotation, acq_threshold)" ] }, { "cell_type": "code", "execution_count": 10, "id": "d33ef619", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import ConfusionMatrixDisplay\n", "import matplotlib.pyplot as plt\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\n", " \"qubit\": \"q0\",\n", " \"prepared_states\": states,\n", " \"acq_protocol\": \"ThresholdedAcquisition\",\n", "}\n", "\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=60,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "dataset = measurement_control.run(\"Readout Calibration Verification\")\n", "\n", "prepared_states = dataset.x0.values\n", "measured_states = dataset.y0.values\n", "\n", "ConfusionMatrixDisplay.from_predictions(\n", " prepared_states, measured_states, cmap=\"Blues\", normalize=None\n", ")\n", "plt.title(\"Confusion Matrix\")\n", "plt.xlabel(\"Measured State\")\n", "plt.ylabel(\"Prepared State\")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "30082931", "metadata": {}, "source": [ "As expected, the threshold that we set did a good job of discriminating the qubit states (the discrimination is not perfect because the data points belonging to the two states slightly overlap).\n", "\n", "## Conditional Reset\n", "\n", "The conditional reset is implemented in Quantify as a gate. When we have a single {{ Reset }} at the beginning of a schedule, we simply replace the {{ Reset }} gate with the {{ ConditionalReset }} gate, for example\n", "\n", "```{code-block} python\n", "schedule = Schedule()\n", "#schedule.add(Reset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q0\"))\n", "...\n", "```\n", "\n", "In other cases, however, we need to pass extra arguments to {{ ConditionalReset }} that we illustrate below.\n", "\n", "### Example: Modifying the T1 schedule\n", "\n", "In this example, we use the schedule function {{ t1_sched }} using the {{ ConditionalReset }} instead of the standard {{ Reset }}. We need to ensure that all acquisition protocols in the schedule are equal to `\"ThresholdedAcquisition\"`." ] }, { "cell_type": "code", "execution_count": 11, "id": "87bbe139", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.qblox.operations import ConditionalReset\n", "from quantify_scheduler.operations import X, Reset\n", "\n", "\n", "# original T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(qubit), label=f\"Reset {i}\")\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(qubit),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule\n", "\n", "\n", "# updated T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(\n", " ConditionalReset(qubit, acq_channel=0),\n", " label=f\"Reset {i}\",\n", " )\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(\n", " qubit,\n", " acq_protocol=\"ThresholdedAcquisition\",\n", " acq_channel=1,\n", " ),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "f8b19904", "metadata": {}, "source": [ "#### Running the T1 schedule using MeasurementControl\n", "\n", "The dataset returned by {{ MeasurementControl }} will in this case have four rows of data, which are: \n", "- `y0`: contains the data establishing whether a qubit was reset or not\n", "- `y1`: contains the actual (thresholded) measurement\n", "- `y2` and `y3`: filled with NaNs (currently {{ MeasurementControl }} expects {{ ScheduleGettable }} to return IQ values)\n", "\n", "Below we run {{ MeasurementControl }} again as before" ] }, { "cell_type": "code", "execution_count": 12, "id": "c9c9f23b", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "## generate dummy data for a fictitious T1 experiment\n", "\n", "import numpy as np\n", "\n", "tau = 1e-5\n", "runs = 1024\n", "times = np.array(list(np.linspace(start=1.6e-7, stop=4.976e-5, num=125)))\n", "num_samples = len(times)\n", "\n", "random_initial_states = np.mean(\n", " np.random.choice([0, 1], num_samples * runs).reshape(num_samples, runs), axis=1\n", ")\n", "\n", "\n", "def generate_random_numbers(times, tau, runs):\n", " times = np.array(times)\n", "\n", " probabilities = np.exp(-times / tau)\n", "\n", " random_results = np.random.rand(runs, len(times)) < probabilities\n", " average_results = random_results.mean(axis=0)\n", "\n", " return average_results\n", "\n", "\n", "average_T1_data = generate_random_numbers(times, tau, runs)\n", "\n", "cluster.delete_dummy_binned_acquisition_data(1)\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=f\"0\",\n", " data=[\n", " DummyBinnedAcquisitionData(data=(0, 0), thres=x, avg_cnt=0)\n", " for x in random_initial_states\n", " ],\n", ")\n", "\n", "ic_cluster.instrument.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=f\"1\",\n", " data=[\n", " DummyBinnedAcquisitionData(data=(0, 0), thres=x, avg_cnt=0)\n", " for x in average_T1_data\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 13, "id": "7a8cbbcf", "metadata": {}, "outputs": [], "source": [ "single_qubit_device.cfg_sched_repetitions(1024) # run and average 1024 times\n", "\n", "# Configure the settable\n", "time = ManualParameter(\"sample\", label=\"Sample time\", unit=\"s\")\n", "time.batched = True\n", "\n", "times = np.array(list(np.linspace(start=1.6e-7, stop=4.976e-5, num=125)))\n", "\n", "# Configure the gettable\n", "gettable = ScheduleGettable(\n", " quantum_device=single_qubit_device,\n", " schedule_function=t1_sched,\n", " schedule_kwargs={\"qubit\": \"q0\", \"times\": times},\n", " batched=True,\n", " num_channels=2,\n", ")\n", "\n", "# Configure MeasurementControl\n", "measurement_control.settables(time)\n", "measurement_control.setpoints(times)\n", "measurement_control.gettables(gettable)\n", "\n", "dataset = measurement_control.run(\"t1\")" ] }, { "cell_type": "code", "execution_count": 14, "id": "e59f13ac", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "# we need to temporarily patch the dataset because I don't understand how to\n", "# pass average thresholds to DummyBinnedAcquisitionData such that\n", "# ScheduleGettable returns floats instead of ints\n", "dataset.y0.values = random_initial_states\n", "dataset.y1.values = average_T1_data" ] }, { "cell_type": "markdown", "id": "1f34f348", "metadata": {}, "source": [ "Above we also passed `num_channels=2` to the {{ ScheduleGettable }} so that it knows to expect measurements on the same qubit, but separate acquisition channels.\n", "\n", "We now plot the contents of this dataset:" ] }, { "cell_type": "code", "execution_count": 15, "id": "b7343c81", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(dataset.x0, np.abs(dataset.y1))\n", "plt.xlabel(\"time [s]\")\n", "plt.ylabel('Probability of |1⟩ state')\n", "plt.title('T1 Relaxation Experiment')\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "c92ab538", "metadata": {}, "source": [ "```{note}\n", "Often, we can use an `Analysis` class on datasets to visualize the data and extract relevant parameters such as {{ T1Analysis }}\n", "```\n", "\n", "### Note on Execution Order\n", "\n", "Parallel {{ ConditionalReset }} operations are not supported. For example, compiling the following schedule will raise a {{ RuntimeError }}:\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"), ref_pt=\"start\")\n", "```\n", "\n", "and will have to be scheduled sequentially,\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"))\n", "```\n", "\n", "\n", "## Closing Remarks\n", "\n", "You can find more technical information and explanations of the different limitations in our [reference guide](sec-qblox-conditional-playback)." ] } ], "metadata": { "file_format": "mystnb", "kernelspec": { "display_name": "python3", "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.9.25" }, "myst": { "substitutions": { "BasicTransmonElement": "{class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement`", "Cluster": "{class}`~qblox_instruments.Cluster`", "ConditionalReset": "{class}`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`", "Measure": "{class}`~quantify_scheduler.operations.gate_library.Measure`", "MeasurementControl": "{class}`~quantify_core.measurement.control.MeasurementControl`", "QuantumDevice": "{class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`", "ReadoutCalibrationAnalysis": "{class}`~quantify_core.analysis.readout_calibration_analysis.ReadoutCalibrationAnalysis`", "Reset": "{class}`~quantify_scheduler.operations.gate_library.Reset`", "RuntimeError": "{class}`~RuntimeError`", "Schedule": "{class}`~quantify_scheduler.schedules.schedule.Schedule`", "ScheduleGettable": "{class}`~quantify_scheduler.gettables.ScheduleGettable`", "T1Analysis": "{class}`~quantify_core.analysis.single_qubit_timedomain.T1Analysis`", "ThresholdedAcquisition": "{class}`~quantify_scheduler.operations.acquisition_library.ThresholdedAcquisition`", "readout_calibration_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.readout_calibration_sched`", "t1_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.t1_sched`" } }, "source_map": [ 23, 69, 82, 123, 130, 147, 151, 184, 194, 260, 292, 302, 310, 314, 323, 330, 339, 380, 401, 451, 464, 520, 546, 555, 561, 567 ] }, "nbformat": 4, "nbformat_minor": 5 }