{ "cells": [ { "cell_type": "markdown", "id": "970ced18", "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": "3e391cc7", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1893/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": "974f71cd", "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": "1ce240b3", "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": "05388b9b", "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": "c120b505", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "efa5f41b", "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": "34ce64ce", "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": "7a1f5328", "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 = 0\n", " else:\n", " thres = 1\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\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", "n_points = 500\n", "\n", "# Generate random samples\n", "x0_samples = np.random.normal(x0, xs0, n_points)\n", "y0_samples = np.random.normal(y0, ys0, n_points)\n", "x1_samples = np.random.normal(x1, xs1, n_points)\n", "y1_samples = np.random.normal(y1, ys1, n_points)\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] * 500)\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), 0, 0)\n", " for re, im in zip(x, y)\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 6, "id": "d2030d9e", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:769: RuntimeWarning: Number of instructions (16012) compiled for 'seq0' of QRMRFCompiler 'cluster_module1' exceeds the maximum supported number of instructions in Q1ASM programs for QRMRFCompiler (12288).\n", " warnings.warn(\n" ] }, { "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.003184 -0.01342 ... -0.002188 -0.01367\n",
       "    y1       (dim_0) float64 8kB 0.003089 0.002234 ... 0.006676 -0.0009378\n",
       "Attributes:\n",
       "    tuid:                             20250925-134349-487-166642\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.003184 -0.01342 ... -0.002188 -0.01367\n", " y1 (dim_0) float64 8kB 0.003089 0.002234 ... 0.006676 -0.0009378\n", "Attributes:\n", " tuid: 20250925-134349-487-166642\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\": prepared_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=200,\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": "5f624ee2", "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": "f931d429", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABD0AAAJzCAYAAAAMdmheAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1hT1xsH8G/YG2SDA1BRnCiuuvdeuFcVlFpbd622ota9994KaLW4x89aZ7Va96jVuqUqKktUQEABw/39EXNLIECAQCB8P8/DY3Nycu/JSUK5b97zHokgCAKIiIiIiIiIiLSMjqYHQERERERERESUHxj0ICIiIiIiIiKtxKAHEREREREREWklBj2IiIiIiIiISCsx6EFEREREREREWolBDyIiIiIiIiLSSgx6EBEREREREZFWYtCDiIiIiIiIiLQSgx5EREREREREpJUY9CAiItJCEokE06dP1/Qw8l1gYCAkEgmePXsmtjVr1gzNmjUTb589exYSiQR79+4t+AGm8ezZM0gkEgQGBmp0HERERMUJgx5ERER5IL+Qlf/o6OjA2toa7du3x6VLlzQ9vHy1du3aHF/Af/z4EcuWLUO9evVgaWkJIyMjVKhQASNHjsSjR4/yZ6AFbOfOnVi+fLmmh0FEREQA9DQ9ACIiIm3Qr18/dOjQAVKpFI8ePcLatWvRvHlzXLt2DdWqVdP08PLF2rVrYWtrC19fX5X6R0dHo127drhx4wY6deqE/v37w8zMDA8fPkRwcDA2btyI5OTkPI/rxIkTeT5GXuzcuRP//PMPxo4dq9Du4uKCDx8+QF9fXzMDIyIiKoYY9CAiIlIDLy8vfPnll+Ltxo0bo3379li3bh3Wrl2rwZEVHr6+vvjrr7+wd+9e9OjRQ+G+WbNmYfLkyWo5j4GBgVqOI5eYmAgTE5M8H0cikcDIyEgNIyIiIiJVcXkLERFRPmjcuDEAICQkRKE9JiYGY8eORenSpWFoaIjy5ctjwYIFSE1NVei3ePFiNGjQADY2NjA2NkatWrWU1qRISkrCd999Bzs7O5ibm6NLly54+fKl0jH99ddfaN++PSwsLGBmZoaWLVvi8uXLCn2mT58OiUSS4bHpa2e4urri7t27+OOPP8SlPWnraKR35coV/Prrr/Dz88sQ8AAAQ0NDLF68WLx9+/Zt+Pr6omzZsjAyMoKjoyOGDBmCN2/eZHoOufQ1PeSkUikmTZoER0dHmJqaokuXLnjx4kWGx1atWhU3btxAkyZNYGJigkmTJgEADh06hI4dO8LZ2RmGhoYoV64cZs2aBalUqvD4X3/9Fc+fPxfnxdXVFUDmNT1+//13NG7cGKamprCyskLXrl1x//59hT7y1+XJkyfw9fWFlZUVLC0tMXjwYCQmJmY7J0RERMUVMz2IiIjygTw4UKJECbEtMTERTZs2xatXrzBs2DCUKVMGFy9ehL+/P8LDwxXqQKxYsQJdunTBgAEDkJycjODgYPTq1QtHjhxBx44dxX5fffUVfv75Z/Tv3x8NGjTA77//rnC/3N27d9G4cWNYWFjghx9+gL6+PjZs2IBmzZrhjz/+QL169XL0/JYvX45Ro0bBzMxMzNBwcHDItP/hw4cBAAMHDlTp+CdPnsS///6LwYMHw9HREXfv3sXGjRtx9+5dXL58WWlgJjtz5syBRCLBjz/+iKioKCxfvhytWrXCrVu3YGxsLPZ78+YN2rdvj759++LLL78Un1dgYCDMzMwwbtw4mJmZ4ffff8fUqVMRFxeHRYsWAQAmT56M2NhYvHz5EsuWLQMAmJmZZTqmU6dOoX379ihbtiymT5+ODx8+YNWqVWjYsCFu3rwpBkzkevfuDTc3N8ybNw83b97E5s2bYW9vjwULFuR4PoiIiIoFgYiIiHLt6dOnAgBhxowZwuvXr4WIiAjh/PnzQp06dQQAwp49e8S+s2bNEkxNTYVHjx4pHGPixImCrq6uEBoaKrYlJiYq9ElOThaqVq0qtGjRQmy7deuWAEAYPny4Qt/+/fsLAIRp06aJbd7e3oKBgYEQEhIitoWFhQnm5uZCkyZNxLZp06YJyv48CAgIEAAIT58+FduqVKkiNG3aNOsJ+qxbt24CAOHdu3cq9U///AVBEH755RcBgHDu3Lksx9W0aVOFcZ05c0YAIJQsWVKIi4sT23fv3i0AEFasWKHwWADC+vXrVRrTsGHDBBMTE+Hjx49iW8eOHQUXF5cMfeXvlYCAALGtRo0agr29vfDmzRux7e+//xZ0dHSEQYMGiW3y12XIkCEKx+zWrZtgY2OT4VxEREQkw+UtREREajBt2jTY2dnB0dERjRs3xv3797FkyRL07NlT7LNnzx40btwYJUqUQHR0tPjTqlUrSKVSnDt3TuybNvPg3bt3iI2NRePGjXHz5k2x/ejRowCA0aNHK4wlfQFNqVSKEydOwNvbG2XLlhXbnZyc0L9/f/z555+Ii4tTyzxkRn58c3Nzlfqnff4fP35EdHQ0vvjiCwBQmIOcGDRokML5e/bsCScnJ3Ee5QwNDTF48OAsx/T+/XtER0ejcePGSExMxIMHD3I8nvDwcNy6dQu+vr6wtrYW26tXr47WrVtnGBcAfPPNNwq3GzdujDdv3uT760dERFRUcXkLERGRGnz99dfo1asXPn78iN9//x0rV65UqPUAAI8fP8bt27dhZ2en9BhRUVHifx85cgSzZ8/GrVu3kJSUJLanXdbx/Plz6OjooFy5cgrHqVixosLt169fIzExMUM7AFSqVAmpqal48eIFqlSpovoTziELCwsAsmCBlZVVtv3fvn2LGTNmIDg4WGFeACA2NjZXY3B3d1e4LZFIUL58eXEpklzJkiWVFkO9e/cupkyZgt9//z1DkCE3Y3r+/DmAjK8XIHtdjh8/joSEBJiamortZcqUUegnXz717t07cY6JiIjoPwx6EBERqYG7uztatWoFAOjUqRN0dXUxceJENG/eHLVr1wYApKamonXr1vjhhx+UHqNChQoAgPPnz6NLly5o0qQJ1q5dCycnJ+jr6yMgIAA7d+7M1+eRWa2M9AGcnPLw8AAA3LlzRyzympXevXvj4sWLmDBhAmrUqAEzMzOkpqaiXbt2GYq+qlvajA65mJgYNG3aFBYWFpg5cybKlSsHIyMj3Lx5Ez/++GO+j0lOV1dXabsgCAVyfiIioqKGQQ8iIqJ8MHnyZGzatAlTpkzBsWPHAADlypVDfHy8GBzJzL59+2BkZITjx4/D0NBQbA8ICFDo5+LigtTUVISEhChkCzx8+FChn52dHUxMTDK0A8CDBw+go6OD0qVLA/gvcyAmJkYhI0OelZBWToqJdu7cGfPmzcPPP/+cbdDj3bt3OH36NGbMmIGpU6eK7Y8fP1b5fMqkf7wgCHjy5AmqV6+e7WPPnj2LN2/eYP/+/WjSpInY/vTp0wx9VZ0XFxcXABlfL0D2utja2ipkeRAREVHOsaYHERFRPrCyssKwYcNw/Phx3Lp1C4Ase+HSpUs4fvx4hv4xMTH49OkTANm3+RKJRCG74tmzZzh48KDCY9q3bw8AWLlypUJ72l1g5Mdr06YNDh06pLCUIzIyEjt37kSjRo3EpRHypTJp64skJCQgKCgow5hNTU0RExOT+SSkUb9+fbRr1w6bN2/O8DwAIDk5GePHjxfHC2TMXkj/vHJq27ZteP/+vXh77969CA8PF+cxK8rGlJycjLVr12boa2pqqtJyFycnJ9SoUQNBQUEK8/jPP//gxIkT6NChQ7bHICIioqwx04OIiCifjBkzBsuXL8f8+fMRHByMCRMm4PDhw+jUqRN8fX1Rq1YtJCQk4M6dO9i7dy+ePXsGW1tbdOzYEUuXLkW7du3Qv39/REVFYc2aNShfvjxu374tHr9GjRro168f1q5di9jYWDRo0ACnT5/GkydPMoxl9uzZOHnyJBo1aoThw4dDT08PGzZsQFJSEhYuXCj2a9OmDcqUKQM/Pz9MmDABurq62Lp1K+zs7BAaGqpwzFq1amHdunWYPXs2ypcvD3t7e7Ro0SLT+di2bRvatGmD7t27o3PnzmjZsiVMTU3x+PFjBAcHIzw8HIsXL4aFhQWaNGmChQsXIiUlBSVLlsSJEyeUZlXkhLW1NRo1aoTBgwcjMjISy5cvR/ny5TF06NBsH9ugQQOUKFECPj4+GD16NCQSCbZv3650WUmtWrWwa9cujBs3DnXq1IGZmRk6d+6s9LiLFi1C+/btUb9+ffj5+Ylb1lpaWmL69Ol5er5EREQEbllLRESUF/JtSBctWqT0fl9fX0FXV1d48uSJIAiC8P79e8Hf318oX768YGBgINja2goNGjQQFi9eLCQnJ4uP27Jli+Du7i4YGhoKHh4eQkBAgNLtZD98+CCMHj1asLGxEUxNTYXOnTsLL168yLBlrSAIws2bN4W2bdsKZmZmgomJidC8eXPh4sWLGcZ848YNoV69eoKBgYFQpkwZYenSpUq3ho2IiBA6duwomJubCwBU2r42MTFRWLx4sVCnTh3BzMxMMDAwENzd3YVRo0aJcyQIgvDy5UuhW7dugpWVlWBpaSn06tVLCAsLy/C8crJl7S+//CL4+/sL9vb2grGxsdCxY0fh+fPnCuNr2rSpUKVKFaVjv3DhgvDFF18IxsbGgrOzs/DDDz8Ix48fFwAIZ86cEfvFx8cL/fv3F6ysrAQA4va1yrasFQRBOHXqlNCwYUPB2NhYsLCwEDp37izcu3dPoY/8tX/9+rVCu7LnT0RERP+RCAIrXxERERERERGR9mFNDyIiIiIiIiLSSgx6EBEREREREZFWYtCDiIiIiIiIiLQSgx5EREREREREpJUY9CAiIiIiIiIircSgBxERERERERFpJQY9iIgo3wUGBkIikeDZs2fZ9nV1dYWvr2++j4mIiIiItB+DHkRElKWLFy9i+vTpiImJ0fRQsvXgwQP88MMPqFGjBszNzeHk5ISOHTvi+vXrSvu/evUKvXv3hpWVFSwsLNC1a1f8+++/Cn1evHiBGTNmoG7duihRogRsbW3RrFkznDp1KsPx5MEdZT8REREZ+h8+fBheXl4wMjJCmTJlMG3aNHz69ClDv5MnT6JRo0YwMTFBiRIl0LNnzwwBpDdv3mDRokVo0qQJ7OzsYGVlhS+++AK7du3KcLyzZ89mOs7Lly9nNcWiXbt24csvv4S7uzskEgmaNWumtN/du3fRq1cvlC1bFiYmJrC1tUWTJk3wv//9L8vjp6SkoHLlypBIJFi8eLHCfWFhYfjyyy9RsWJFmJubw8rKCnXr1kVQUBAEQcjyuK1bt4ZEIsHIkSMz3BcZGYnBgwfD3t4exsbG8PLywp49e7KeiFyMHwDCw8Px9ddfw83NDcbGxihXrhzGjRuHN2/eKPTL7HWSSCRo3bp1tuOIj4/HtGnT0K5dO1hbW0MikSAwMDDT/qmpqVi3bh1q1KgBY2Nj2NjYoEWLFvj7778z9A0JCUH//v3F+XJ3d8fkyZPzdEy5HTt2QCKRwMzMLMOxAgMD0aVLF5QuXRqmpqaoWrUqZs+ejY8fP2Y7H0REVPzoaXoARERUuF28eBEzZsyAr68vrKyscnWMgQMHom/fvjA0NFTv4NLZvHkztmzZgh49emD48OGIjY3Fhg0b8MUXX+DYsWNo1aqV2Dc+Ph7NmzdHbGwsJk2aBH19fSxbtgxNmzbFrVu3YGNjAwA4dOgQFixYAG9vb/j4+ODTp0/Ytm0bWrduja1bt2Lw4MEZxjFz5ky4ubkptKWfu99++w3e3t5o1qwZVq1ahTt37mD27NmIiorCunXrxH5HjhxB165d4eXlhfnz5yMuLg4rVqxAo0aN8Ndff8HOzg4AcOnSJUyePBkdOnTAlClToKenh3379qFv3764d+8eZsyYkWGco0ePRp06dRTaypcvr9Jcr1u3Djdu3ECdOnUyXKin9fz5c7x//x4+Pj5wdnZGYmIi9u3bhy5dumDDhg34+uuvlT5u1apVCA0NVXpfdHQ0Xr58iZ49e6JMmTJISUnByZMn4evri4cPH2Lu3LlKH7d//35cunRJ6X1xcXFo1KgRIiMjMWbMGDg6OmL37t3o3bs3duzYgf79+2czI6qPPz4+HvXr10dCQgKGDx+O0qVL4++//8bq1atx5swZ3LhxAzo6su+ltm/fnuHx169fx4oVK9CmTZtsxxEdHY2ZM2eiTJky8PT0xNmzZ7PsP2TIEOzYsQODBg3CyJEjkZCQgL/++gtRUVEK/W7duoVmzZqhZMmS+P7772FjY4PQ0FC8ePEi18dMOz8//PADTE1NM9yXmJiIwYMH44svvsA333wDe3t7XLp0CdOmTcPp06fx+++/QyKRZDsvRERUjAhERERZWLRokQBAePr0aYGcz8XFRfDx8cnVY69fvy68f/9eoS06Olqws7MTGjZsqNC+YMECAYBw9epVse3+/fuCrq6u4O/vL7b9888/wuvXrxUe+/HjR8HDw0MoVaqUQntAQIAAQLh27Vq2Y61cubLg6ekppKSkiG2TJ08WJBKJcP/+fYV+5cuXF5KSksS2W7duCTo6OsK4cePEtn///Vd49uyZwjlSU1OFFi1aCIaGhkJ8fLzYfubMGQGAsGfPnmzHmZnQ0FBBKpUKgiAIVapUEZo2baryYz99+iR4enoKFStWVHp/ZGSkYGlpKcycOVMAICxatEil43bq1EkwNTUVPn36lOG+Dx8+CK6uruIxR4wYoXD/woULBQDC6dOnxTapVCrUqVNHcHR0VJj/7GQ3/h07dggAhCNHjii0T506VQAg3Lx5M8vj+/n5CRKJRHjx4kW2Y/n48aMQHh4uCIIgXLt2TQAgBAQEKO27a9cuAYCwf//+LI8plUqFqlWrCvXq1RMSExOz7KvqMdP68ccfhYoVKwoDBgwQTE1NFe5LSkoSLly4kOExM2bMEAAIJ0+eVPk8RERUPHB5CxERZWr69OmYMGECAMDNzU1Mq3/27BmePXuWaaq8RCLB9OnTxdvKanoIgoDZs2ejVKlSMDExQfPmzXH37l2l4wgJCUFISEi2461Vq1aGdHgbGxs0btwY9+/fV2jfu3cv6tSpo5Dp4OHhgZYtW2L37t1iW5UqVWBra6vwWENDQ3To0AEvX77E+/fvlY7l/fv3kEqlSu+7d+8e7t27h6+//hp6ev8lXQ4fPhyCIGDv3r0AgLdv3+LevXvo1q0bDAwMxH6enp6oVKkSgoODxTY3Nze4uLgonEcikcDb2xtJSUkZlu2kHaeyJTXZKV26tJiNkFO6urooXbp0pkumJk6ciIoVK+LLL7/M0XFdXV2RmJiI5OTkDPctXLgQqampGD9+vNLHnj9/HnZ2dmjRooXYpqOjg969eyMiIgJ//PGHyuPIbvxxcXEAAAcHB4V2JycnAICxsXGmx05KSsK+ffvQtGlTlCpVKtuxGBoawtHRUaVxL126FHXr1kW3bt2QmpqKhIQEpf1OnDiBf/75B9OmTYOxsTESExMzfa+reky5x48fY9myZVi6dKnCZ0POwMAADRo0yNDerVs3AMjwOSciImLQg4iIMtW9e3f069cPALBs2TJs374d27dvF5dU5MXUqVPx008/wdPTE4sWLULZsmXRpk0bpRdFLVu2RMuWLXN9roiICIXARWpqKm7fvo3atWtn6Fu3bl2EhIRkGsxIe0wTExOYmJhkuK958+awsLCAiYkJunTpgsePHyvc/9dffwFAhvM7OzujVKlS4v1JSUkAlF8Em5iYICwsTGmtkPTjBJAhcAMAgwcPhoWFBYyMjNC8efNMa5+oQ0JCAqKjoxESEoJly5bht99+U/qaXr16FUFBQVi+fHm2yxQ+fPiA6OhoPHv2DEFBQQgICED9+vUzzFdoaCjmz5+PBQsWZBpQSEpKynSeAeDGjRsqPU9Vxt+kSRPo6OhgzJgxuHz5Ml6+fImjR49izpw58Pb2hoeHR6bHP3r0KGJiYjBgwACVxqOquLg4XL16FXXq1MGkSZNgaWkJMzMzlC1bViEICECsZ2NoaIjatWvD1NQUJiYm6Nu3L96+fZurY8qNHTsWzZs3R4cOHXI0/qze50REVLyxpgcREWWqevXq8PLywi+//AJvb2+4urqK971+/TrXx339+jUWLlyIjh074n//+594cTh58uRM6zHk1vnz53Hp0iVMmTJFbHv79i2SkpLEb9bTkreFhYWhYsWKSo/55MkT7N+/H7169YKurq7YbmJiAl9fXzHocePGDSxduhQNGjTAzZs3Ubp0aQCyIpZpz5X+/GFhYQBkmQBWVla4cOGCQp83b97g3r17AGTFWDP7Jv/t27fYvHkzGjdurHAuAwMD9OjRAx06dICtrS3u3buHxYsXo3Hjxrh48SJq1qyp9Hh58f3332PDhg0AZBkU3bt3x+rVqxX6CIKAUaNGoU+fPqhfv362u/2sWLEC/v7+4u2WLVsiICBA6blr1qyJvn37ZnqsihUr4tSpU3j+/LlCxsz58+cByOY5O6qOv3Llyti4cSPGjx+P+vXri+0+Pj7YvHlzlufYsWMHDA0N0bNnz2zHkxMhISEQBAHBwcHQ09PDwoULYWlpiRUrVqBv376wsLBAu3btAEAM4vXu3Rvt2rWDv78//v77b8ybNw8vXrzAn3/+CYlEkqNjAsCvv/6KEydOZFngNDMLFy6EhYUF2rdvr54JISIircGgBxERFbhTp04hOTkZo0aNUvg2fOzYsUqDHqpsdatMVFQU+vfvDzc3N/zwww9i+4cPHwBAaWFVIyMjhT7pJSYmolevXjA2Nsb8+fMV7uvduzd69+4t3vb29kbbtm3RpEkTzJkzB+vXr1fp/PLlDzo6Ohg2bBgWLFgAf39/DBkyBHFxcfjhhx/EJRyZjTM1NRUDBgxATEwMVq1apXBfgwYNFJYIdOnSBT179kT16tXh7++PY8eOKT1mXowdOxY9e/ZEWFgYdu/eDalUmmEZSmBgIO7cuSMu78lOv379ULt2bbx+/RpHjhxBZGRkhvk4c+YM9u3bhytXrmR5rK+++grr169H7969sWzZMjg4OGD37t04cOAAgMznObfjL1myJOrWrYsOHTrAxcUF58+fx8qVK2Fra6t0txdAljnx66+/okOHDrkuKpyZ+Ph4ALKA2uXLl1GvXj0AsveGm5sbZs+eLQYo5H3r1KmDn3/+GQDQo0cPmJiYwN/fH6dPn0arVq1ydMzk5GR89913+Oabb1C5cuUcjX3u3Lk4deoU1q5dq/Z5ISKioo/LW4iIqMA9f/4cAODu7q7QbmdnhxIlSqjlHAkJCejUqRPev3+PQ4cOKdT6kC9jkC8fSUu+7aWypQ5SqVTcDWXv3r1wdnbOdhyNGjVCvXr1FLa4ze78ac89c+ZM+Pn5YeHChahQoQJq164NPT09+Pn5AUCGGiZyo0aNwrFjx7B582Z4enpmO87y5cuja9euOHPmjFif4e3bt4iIiBB/YmNjsz1OZjw8PNCqVSsMGjQIR44cQXx8PDp37ixuMRsXFwd/f39MmDBBzIjJjouLC1q1aoV+/fphx44dKFu2LFq1aiUGKD59+oTRo0dj4MCBGXapSa969erYuXMnQkJC0LBhQ5QvXx4rV67E8uXLAfw3z/Hx8QpzIs94ysn4L1y4gE6dOmHOnDkYM2YMvL29sWTJEkyZMgVLly4Vs3jS27dvHz5+/JhhaYtUKlUYU0REhNK6JlmRv+fc3NzE4IT8eXfu3BlXr14Va7/I+8qXvsnJd7i5ePFijo+5bNkyREdHK91lKCu7du3ClClT4Ofnh2+//TZHjyUiouKBQQ8iIsqVzOoVZFbQsCAlJyeje/fuuH37Ng4dOoSqVasq3G9tbQ1DQ0NxmUla8jZlAY2hQ4fiyJEjCAwMVCh4mZ3SpUsr1DqQLzXJ7Pxpz21gYIDNmzcjLCwM586dw8OHD3H8+HHExsZCR0dH6RazM2bMwNq1azF//nwMHDgwR+NMTk4W66p0794dTk5O4s+YMWNUPlZ2evbsiWvXruHRo0cAgMWLFyM5ORl9+vQRC+W+fPkSAPDu3Ts8e/Ys2wv5nj174sWLFzh37hwAYNu2bXj48CGGDRsmHlOeNfT+/Xs8e/YMiYmJCo8PCwvD1atXcenSJTx//hxly5YFAFSoUEEcZ9o5kQdTcjL+DRs2wMHBIUNNly5dukAQBDFokN6OHTtgaWmJTp06KbS/ePFCYUxOTk6ZHiMz8vdc+uKqAGBvb4+UlBTxfZFZX3t7e/H55uSYsbGxmD17NoYOHYq4uDhx/uLj4yEIAp49e6Z0e9uTJ09i0KBB6Nixo5hFRURElB6XtxARUZYyC27IMzLS78Ahz+LIirxmwuPHj8WLSkBW60N+wZRbqampGDRoEE6fPo3du3ejadOmGfro6OigWrVqSgt3XrlyBWXLloW5ublC+4QJExAQEIDly5dn+IY7O//++69C8dcaNWoAAK5fv466deuK7WFhYXj58iW+/vrrDMdwcHAQLx6lUinOnj2LevXqZcj0WLNmDaZPn46xY8fixx9/zPE4jYyMxGMuWbJE4fVQJbNFVfJsDHn2SGhoKN69e4cqVapk6Dt37lzMnTsXf/31lzh3qh4zJSUFDRs2zNB327Zt2LZtGw4cOABvb2+x3cDAQCErRJ6h06pVKwDAoEGD0KhRI/F+eTZDTsYfGRmpNDiYkpICAEp30wkPD8eZM2fg6+ubYVmUo6MjTp48qdCmSnZPWs7OznB0dFRauyQsLAxGRkbiZ6JWrVrYtGlThr7yWjTy97qqxwwNDUV8fDwWLlyIhQsXZujr5uaGrl274uDBg2LblStX0K1bN9SuXRu7d+9WutMLERERAEBjm+USEVGRsG7dOgGA8Ndff2W4z9bWVujWrZtC2/fffy8AEKZNmya2BQQECACEp0+fCoIgCFFRUYK+vr7QsWNHITU1Vew3adIkAYDg4+OjcMwnT54IT548UWm8w4cPFwAIGzZsyLLf/PnzBQDCtWvXxLYHDx4Iurq6wo8//qjQd+HChQIAYdKkSVkeMyoqKkPbr7/+KgAQRo8erdDu4eEheHp6Cp8+fRLbpkyZIkgkEuHevXsqjX3v3r0K7cHBwYKOjo4wYMAAhXlVZZy3bt0S9PX1hS5dumR5bmWqVKkiNG3aVOl9kZGRGdqSk5MFLy8vwdjYWHj//r0gCIJw48YN4cCBAwo/GzZsEAAIvr6+woEDB4SYmJhMxy8IgtC5c2dBIpEIjx8/FgRBEO7fv5/hmAcOHBAACB06dBAOHDgghIWFZfq8Hj16JJibmwudOnXKdg5yMv6RI0cKAIQzZ84oHGPs2LECAOHy5csZjr906VIBgHD69Olsx5KZa9euCQCEgIAApfePGTNGACCcOHFCbHv9+rVgYWEhdOjQQWwLDw8XDA0NhUaNGglSqVRs9/f3FwAIV69ezdExExISlL5OzZs3F4yMjIQDBw4ozMm9e/cEGxsboUqVKsLbt29zPR9ERFQ8SATh82JaIiIiJa5duyYWXOzbty/09fXRuXNnmJqawt/fH/Pnz4efnx9q166Nc+fO4dGjR7hx4wamTZuG6dOnA5AVeBw8eDCePn0q7gAzadIkzJs3Dx06dECHDh3w119/4bfffkNycjI6duyIwMBAcQzyx2RX0HT58uX47rvvUL9+fQwfPjzD/d26dYOpqSkA2fKGmjVr4v379xg/fjz09fWxdOlSSKVS3Lp1S/y2+sCBA+jevTvc3d0xderUDMds3bq1mIHh7u6OmjVronbt2rC0tMTNmzexdetWODk54dq1awpp/keOHEGXLl3QvHlz9O3bF//88w9Wr14NPz8/bNy4Uez3888/Y9++fWjSpAnMzMxw6tQp7N69G1999RU2bdok9rt69SoaN24MS0tLLFiwAPr6+grjbNCggZhV06JFCxgbG6NBgwawt7fHvXv3sHHjRujr6+PSpUuoVKlSlvMMAOfOnROXkaxatQomJiZinZEmTZqgSZMm4pzHxcWhSZMmKFmyJCIiIrBjxw48ePAAS5Yswbhx4zI9x7Nnz+Dm5oZFixZh/PjxYvvYsWNx4cIFtGvXDmXKlMHbt2+xb98+XLt2DaNGjcLKlSuzHLtEIsGIESMy7B5TuXJl9OrVC2XKlMHTp0+xbt06mJub48KFCyhZsmS2c6Lq+B8+fIhatWpBIpFg1KhRcHFxwR9//IFffvkFrVu3xokTJzIcq3bt2ggPD8eLFy+go5Oz1cmrV69GTEwMwsLCsG7dOnTv3l3coWfUqFGwtLQEAERGRqJmzZqIj4/HuHHjYGlpifXr1+PFixe4dOmSQvbIrFmzMHXqVLRu3Rre3t74+++/sWnTJvTt2xc7d+4U++XkmOn5+vpi7969YkFUQPa5rVKlCl69eoW5c+dmeF3KlSunsCMOERERMz2IiChbs2bNEkqWLCno6OgoZGwkJiYKfn5+gqWlpWBubi707t1biIqKyjbTQxAEQSqVCjNmzBCcnJwEY2NjoVmzZsI///wjuLi4ZMj0cHFxEVxcXLIdp4+PjwAg05+05xcEQXjx4oXQs2dPwcLCQjAzMxM6deokZgnITZs2Lctjpv22fvLkyUKNGjUES0tLQV9fXyhTpozw7bffChEREUrHe+DAAaFGjRqCoaGhUKpUKWHKlClCcnKyQp8rV64ITZo0EUqUKCEYGRkJnp6ewvr16zNkcsjnOLOftN/ur1ixQqhbt65gbW0t6OnpCU5OTsKXX36Z4blnJat5Sfva//LLL0KrVq0EBwcHQU9PTyhRooTQqlUr4dChQ9me4+nTpwIAYdGiRQrtJ06cEDp16iQ4OzsL+vr6grm5udCwYUMhICAgywwXOQDCiBEjMrT37dtXKF26tGBgYCA4OzsL33zzjdJMFVVlNn5BkGUV9ezZUyhdurSgr68vuLi4COPHjxcSEhKU9gUgjBs3LlfjcHFxUfkzERISInTr1k2wsLAQjI2NhRYtWihkbsilpqYKq1atEipUqCDo6+sLpUuXVvr+zckx0/Px8RFMTU0V2uRzmtlP+t8dREREzPQgIiIiIiIiIq3E3VuIiIiIiIiISCsx6EFEREREREREWolBDyIiIiIiIiLSSgx6EBEREREREZFWYtCDiIiIiIiIiLQSgx5EREREREREpJUY9CAiIiIiIiIircSgBxERERERERFpJQY9iIiIiIiIiEgrMehBRERERERERFqJQQ8iIiIiIiIi0koMehARERERERGRVmLQg4iIiIiIiIi0EoMeRERERERERKSVGPQgIiIiIiIiIq3EoAcRERERERERaSUGPYiIiIiIiIhIKzHoQURERERERERaiUEPIiIiIiIiItJKDHoQERERERERkVZi0IOIiIiIiIiItBKDHkRERERERESklRj0ICIiIiIiIiKtxKAHEREREREREWklBj2IiIiIiIiISCsx6EFEREREREREWolBDyIiIiIiIiLSSgx6EBEREREREZFWYtCDiIiIiIiIiLQSgx5EREREREREpJUY9CAiIiIiIiIircSgBxERERERERFpJQY9iIiIiIiIiEgrMehBRERERERERFqJQQ8iIiIiIiIi0koMehARERERERGRVmLQg4iIiIiIiIi0EoMeRERERERERKSVGPQgIiIiIiIiIq3EoAcRERERERERaSUGPYiIiIiIiIhIKzHoQURERERERERaiUEPIiIiIiIiItJKDHoQERERERERkVZi0IOIiIiIiIiItBKDHkRERERERESklRj0ICIiIiIiIiKtxKAHEREREREREWklBj2IiIiIiIiISCsx6EFEREREREREWolBDyIiIiIiIiLSSgx6EBEREREREZFWYtCDiIiIiIiIiLQSgx5EREREREREpJUY9CAiIiIiIiIircSgBxERERERERFpJQY9iIiIiIiIiEgrMehBRERERERERFqJQQ8iIiIiIiIi0koMehARERERERGRVmLQg4iIiIiIiIi0EoMeRERERERERKSVGPQgIiIiIiIiIq3EoAcRERERERERaSU9TQ+AZFJTUxEWFgZzc3NIJBJND4eIiIiIiNRAEAS8f/8ezs7O0NHhd85EBY1Bj0IiLCwMpUuX1vQwiIiIiIgoH7x48QKlSpXS9DCIih0GPQoJc3NzAMCLrVthYWKi4dEUTR+SkmBsaKjpYVA+4mus/bJ6je88f45GP/4IUyNLbAkMLeCRkbokJX2AoaGxpodB+UAQBCQkxCA5+SNKlHBk5qoW4+dYdVIp8OhRHGbMKC3+vU9EBYtBj0JC/oeBhYkJgx65pK+rywtiLcfXWPtl9RpXc3EBACR8jAUggYkJ/3gsinR19XmxpKUEQYAgpEJXVx8mJhYMemgxfo5VJ5UCRkay/+ZngkgzuKiMiIiKBAsTE1gZyYLCkZFPNTwaIiIiIioKGPQgIqIiw8XaDgCDHkRERESkGgY9iIioyHC1twcARLx8ouGREBEREVFRwKAHEREVGa4ODgCAiFePNTwSIiIiIioKGPQgIqIio1wpJwBAVASXtxARERFR9hj0ICKiIqN8KWcAQGT0cw2PhIiIiIiKAgY9iIioyHD7vLzl9dsXEARBw6MhIiIiosKOQQ8iIioy5IVMP6Yk4v37NxoeDREREREVdgx6EBFRkWFkYAAHMwsAQGTkM80OhoiIiIgKPQY9iIioSCltbQsAiIz4V8MjISIiIqLCjkEPIiIqUlztZXU9wl9w21oiIiIiyhqDHkREVKSUdXIEAES8eqLhkRARERFRYcegBxERFSnybWujIp9qeCREREREVNjpaXoAREREOVHOWZbpEfXmuYZHQkREVPTExMTg6dOnSExM5PbvVKRJJBIYGhqidOnSsLe3h0QiUdqPQQ8iIipS3BxkNT2iY8KQmpoKHR0mLRIREWXn1atXOHr0KF69egUAMDIy4v9DqUgTBAEfP36EIAiwtbVFy5YtUalSpQz9GPQgIqIipZStLXQkEqRIk/HuXQRsbJw1PSQqTqKjgbAwwNkZsLXV9GiIiFTy6tUrbN++HSVKlECPHj1QoUIFGBoaanpYRHn26dMn/Pvvv7h27Rr27NmDHj16oEqVKgp9GPQgIqIiRV9PD84WJfAy9i0iI58y6EEF58QJYM0aQEgFJDrAiBFAmzaaHhURUbYOHToEa2tr+Pj4MNhBWkVPTw8VKlRA+fLlsX//fhw8eBAVKlSAvr6+2If5TEREVOS42NgBACLCQzQ8Eio2oqP/C3gAsn/XrpW1ExEVYtHR0YiKikKTJk0Y8CCtpaOjgxYtWiAlJQWPHz9WvE9DYyIiIso1N3tZXY+IF4+z6UmkJmFh/wU85FKlQHi4ZsZDRKSikJAQ6OnpoVy5cpoeClG+sra2hr29PZ48eaLQzqAHEREVOWU/7+ASEcZMDyogzs6yJS1p6egCTk6aGQ8RkYoSEhJgYmKikO5PpK0sLS2RkJCg0MagBxERFTnlSsvqeLx+/UyzA6Hiw9ZWVsNDR1d2W0cXGD6cxUyJqNBLTU2Frq6upoeRaxKJBAcPHtT0MKiI0NXVRWqqYmYmC5kSEVGRU9ZJlukR9SZUwyOhYqVNG8DLS7akxcmJAQ8i0gqvX7/G1KlT8euvvyIyMhIlSpSAp6cnpk6dioYNG2p6eER5xqAHEREVOW4Ospoeb2IjIJV+gq4u/3dGBcTWlsEOItIqPXr0QHJyMoKCglC2bFlERkbi9OnTePPmjaaHRqQWXN5CRERFjlOJEjDU1UOqIMXr1y80PRwiIqIiKSYmBufPn8eCBQvQvHlzuLi4oG7duvD390eXLl3EfkuXLkW1atVgamqK0qVLY/jw4YiPjxfvDwwMhJWVFY4cOYKKFSvCxMQEPXv2RGJiIoKCguDq6ooSJUpg9OjRkEql4uNcXV0xa9Ys9OvXD6ampihZsiTWrFmT5ZhfvHiB3r17w8rKCtbW1ujatSuePXuWaf+zZ89CIpHg+PHjqFmzJoyNjdGiRQtERUXht99+Q6VKlWBhYYH+/fsjMTFRfFxqairmzZsHNzc3GBsbw9PTE3v37hXvl0ql8PPzE++vWLEiVqxYoXBuX19feHt7Y/HixXBycoKNjQ1GjBiBlJQUsc/atWvh7u4OIyMjODg4oGfPnlk+f8o5Bj2IiKjI0dHRQSkrawBAZORTDY+GiIioaDIzM4OZmRkOHjyIpKSkTPvp6Ohg5cqVuHv3LoKCgvD777/jhx9+UOiTmJiIlStXIjg4GMeOHcPZs2fRrVs3HD16FEePHsX27duxYcMGhcABACxatAienp7466+/MHHiRIwZMwYnT55UOo6UlBS0bdsW5ubmOH/+PC5cuAAzMzO0a9cOycnJWT7X6dOnY/Xq1bh48aIYOFm+fDl27tyJX3/9FSdOnMCqVavE/vPmzcO2bduwfv163L17F9999x2+/PJL/PHHHwBkQZFSpUphz549uHfvHqZOnYpJkyZh9+7dCuc9c+YMQkJCcObMGQQFBSEwMBCBgYEAgOvXr2P06NGYOXMmHj58iGPHjqFJkybiYwMDAyGRSLJ8XpQ95gMTEVGR5GJrj5A3UYgIC4GnZwtND4eIiKjI0dPTQ2BgIIYOHYr169fDy8sLTZs2Rd++fVG9enWx39ixY8X/dnV1xezZs/HNN99g7dq1YntKSgrWrVsnbo3bs2dPbN++HZGRkTAzM0PlypXRvHlznDlzBn369BEf17BhQ0ycOBEAUKFCBVy4cAHLli1D69atM4x3165dSE1NxebNm8VgQEBAAKysrHD27Fm0adMm0+c6e/ZssUaJn58f/P39ERISgrJly4rjPXPmDH788UckJSVh7ty5OHXqFOrXrw8AKFu2LP78809s2LABTZs2hb6+PmbMmCEe383NDZcuXcLu3bvRu3dvsb1EiRJYvXo1dHV14eHhgY4dO+L06dMYOnQoQkNDYWpqik6dOsHc3BwuLi6oWbOm+FhLS0tUrFgx0+dEqmGmBxERFUnyuh4RLx9reCRERERFV48ePRAWFobDhw+jXbt2OHv2LLy8vMRsBAA4deoUWrZsiZIlS8Lc3BwDBw7EmzdvFJaDmJiYiAEPAHBwcICrqyvMzMwU2qKiohTOLw8qpL19//59pWP9+++/8eTJE5ibm4tZKtbW1vj48SNCQrLexj5tEMfBwQEmJiZiwCP92J48eYLExES0bt1aPI+ZmRm2bdumcJ41a9agVq1asLOzg5mZGTZu3IjQUMUi61WqVFHYPcfJyUk8T+vWreHi4oKyZcti4MCB2LFjh8KcduvWDQ8ePMjyeVH2mOlBRERFktvnHVwiw//V8EiItEx0NBAWBjg7s2grUTFhZGSE1q1bo3Xr1vjpp5/w1VdfYdq0afD19cWzZ8/QqVMnfPvtt5gzZw6sra3x559/ws/PD8nJyTAxMQEA6OvrKxxTIpEobUu/nWhOxMfHo1atWtixY0eG++zs7LJ8bNqxZDc2eb2SX3/9FSVLllToZ2hoCAAIDg7G+PHjsWTJEtSvXx/m5uZYtGgRrly5kul505/H3NwcN2/exNmzZ3HixAlMnToV06dPx7Vr12BlZZXl8yHVMehBRERFUvnSzgCAqKhnmh0IkTY5cQJYswYQUgGJDjBihGyrXiIqVipXroyDBw8CAG7cuIHU1FQsWbIEOjqyhQLp61bkxeXLlzPcrlSpktK+Xl5e2LVrF+zt7WFhYaG2MaRXuXJlGBoaIjQ0FE2bNlXa58KFC2jQoAGGDx8utmWXbaKMnp4eWrVqhVatWmHatGmwsrLC77//ju7du+d6/KSIy1uIiKhIKvs50yPqbWg2PYlIJdHR/wU8ANm/a9fK2olIK7158wYtWrTAzz//jNu3b+Pp06fYs2cPFi5ciK5duwIAypcvj5SUFKxatQr//vsvtm/fjvXr16ttDBcuXMDChQvx6NEjrFmzBnv27MGYMWOU9h0wYABsbW3RtWtXnD9/Hk+fPsXZs2cxevRovHz5Um1jMjc3x/jx4/Hdd98hKCgIISEhuHnzJlatWoWgoCAAgLu7O65fv47jx4/j0aNH+Omnn3Dt2rUcnefIkSNYuXIlbt26hefPn2Pbtm1ITU0V63gcOHAAHh4eantexRUzPYiIqEiS1/SIiX+NpKQPMDQ01vCIiIq4sLD/Ah5yqVIgPJzLXIi0lJmZGerVq4dly5YhJCQEKSkpKF26NIYOHYpJkyYBADw9PbF06VIsWLAA/v7+aNKkCebNm4dBgwapZQzff/89rl+/jhkzZsDCwgJLly5F27ZtlfY1MTHBuXPn8OOPP6J79+54//49SpYsiZYtW6o982PWrFmws7PDvHnz8O+//8LKygpeXl7ivAwbNgx//fUX+vTpA4lEgn79+mH48OH47bffVD6HlZUV9u/fj+nTp+Pjx49wd3fHL7/8gipVqgAAYmNj8fDhQ7U+r+JIIgiCoOlBEBAXFwdLS0vEBgfD4vO6OMqZD0lJMP68xo60E19j7ZeT11gQBJj37I2ElCSsXXsfpUrxm5CigAGqQiw6GvDzUwx86OgCmzerFPQQBAEJCTFISvoAa2snbrOoxfg5Vp1UCjx4EAd/f0vExsbm65KMzJw6dQp3797NNHtCk1xdXTF27FiF3WGI8iI4OBhSqRQDBgwQ27i8hYiIiiSJRIIy1rILscjIZ5odDJE2sLWV1fDQ+bzLgI4uMHw4szyIiKhI4/IWIqJCghsm5JyLrR3uR75CxKsnQC1Nj4ZIC7RpA3h5yZa0ODnxlxERERV5DHoQERUC8g0TUgVAR8INE1Tl5uAA3AUiXj7W9FCItIetLYMdRFQgnj17pukhUDHA5S1ERBom3zAh9XOFpVSBGyaoqlwp2ba1EeH/angkRERERFQYMehBRKRhYWH/BTzkpKmy7HLKWvlSTgCAqNfPNDsQIiIiIiqUGPQgItIwZ2fZkpa0dHVky+kpa/Jta1+/faHhkRARERFRYVTkgh5r1qyBq6srjIyMUK9ePVy9ejXL/nv27IGHhweMjIxQrVo1HD16VOH+/fv3o02bNrCxsYFEIsGtW7cyHOPjx48YMWIEbGxsYGZmhh49eiAyMlKhT2hoKDp27AgTExPY29tjwoQJ+PTpU56fLxFpP/mGCbqffyPr6nDDBFW5fg56xH+MRWJinIZHQ0RERESFTZEKeuzatQvjxo3DtGnTcPPmTXh6eqJt27aIiopS2v/ixYvo168f/Pz88Ndff8Hb2xve3t74559/xD4JCQlo1KgRFixYkOl5v/vuO/zvf//Dnj178McffyAsLAzdu3cX75dKpejYsSOSk5Nx8eJFBAUFITAwEFOnTlXfkycirdamDbB5MzB3juxfFjFVjYWJCayMTABw21oiIqLcOnv2LFxdXXP0mK1bt+LBgwf5MyAq9Hx9feHt7a3pYaikSAU9li5diqFDh2Lw4MGoXLky1q9fDxMTE2zdulVp/xUrVqBdu3aYMGECKlWqhFmzZsHLywurV68W+wwcOBBTp05Fq1atlB4jNjYWW7ZswdKlS9GiRQvUqlULAQEBuHjxIi5fvgwAOHHiBO7du4eff/4ZNWrUQPv27TFr1iysWbMGycnJ6p8IItJKtrZAtWrM8MgpF2s7AEBk5FMNj4SIiEh7ZJdhf+XKFWzYsEFt55s3bx7q1KkDc3Nz2Nvbw9vbGw8fPsy0v1QqxU8//QQ3NzcYGxujXLlymDVrFgThv0Jp69atQ/Xq1WFhYQELCwvUr18fv/32m8Jxpk+fDolEovDj4eGh0OfcuXPo3LkznJ2dIZFIcPDgwTw9V1XGpUx241BlDlU5t6ura4Y5kUgkGDFihNhnxYoVCAwMzPUcKNO5c2e0a9dO6X3nz5+HRCLB7du3c3zcIhP0SE5Oxo0bNxSCEzo6OmjVqhUuXbqk9DGXLl3KEMxo27Ztpv2VuXHjBlJSUhSO4+HhgTJlyojHuXTpEqpVqwaHz2nW8vPExcXh7t27So+blJSEuLg4hR8iIso5V3t7ANy2loiISF1UybDv2rUrDh8+rLZz/vHHHxgxYgQuX76MkydPIiUlBW3atEFCQoLS/gsWLMC6deuwevVq3L9/HwsWLMDChQuxatUqsU+pUqUwf/583LhxA9evX0eLFi3QtWvXDNdoVapUQXh4uPjz559/KtyfkJAAT09PrFmzRuXn06xZs0yDAqqOK73sxqHKHKpy7mvXrinMx8mTJwEAvXr1EvtYWlrCyspKxdlQjZ+fH06ePImXL19muC8gIAC1a9dG9erVc3xcPXUMriBER0dDKpUqBBYAwMHBIdO0qoiICKX9IyIiVD5vREQEDAwMMrygaY+T2Xnk9ykzb948zJgxI0P7h6Qk6Ovqqjw++s+HpCRND4HyGV9j7Zeb17i0nSzT42XoAyQlfVD3kEjN+BppL0EQkJT0AcnJH5GU9AESiST7B1GRxM+x6qRSIDm56M1X2gx7AFi/fj1+/fVXbN26FRMnTgQAtGzZEpGRkfjnn39QtWrVPJ/z2LFjCrcDAwNhb2+PGzduoEmTJhn6X7x4EV27dkXHjh0ByLITfvnlF4WMlM6dOys8Zs6cOVi3bh0uX76MKlWqiO16enpwdHTMdGzt27dH+/btc/W8lFF1XDkdhypzqMq57T7/bSU3f/58lCtXDk2bNhXbfH19ERMTk2nWS7NmzVCtWjXo6uoiKCgIBgYGmD17Nvr374+RI0di7969cHBwwKpVq8Tn1KlTJ9jZ2SEwMBBTpkwRjxUfH489e/Zg0aJFmT73rBSZoIe28ff3x7hx48TbcXFxKF26NIwNDWFsaKjBkRVtnDvtx9dY++X0Na7oUgoA8Pb1CxgaGufHkEjN+DppJ0EQ8OmTLHBpaGjMoIeW4+dYNVIpYGCQoulh5Ig8w97f319sU5Zhb2hoiDZt2uDw4cNi0CMwMBCDBw9WWGKSW7GxsQAAa2trpfc3aNAAGzduxKNHj1ChQgX8/fff+PPPP7F06VKl/aVSKfbs2YOEhATUr19f4b7Hjx/D2dkZRkZGqF+/PubNm4cyZcrk+TmoIqtx5VV2c6jKuZOTk/Hzzz9j3LhxOf69HhQUhB9++AFXr17Frl278O233+LAgQPo1q0bJk2ahGXLlmHgwIEIDQ2FiYkJ9PT0MGjQIAQGBmLy5Mni+fbs2QOpVIp+/frl6PxyRWZ5i62tLXR1dTPsmhIZGZlpVM7R0TFH/TM7RnJyMmJiYjI9Tmbnkd+njKGhobiOSv5DREQ5V66kbG/fyOjnGh4JERFR0ZdVhn36LPb0S1wsLS1RsWLFPI8hNTUVY8eORcOGDTPNIpk4cSL69u0LDw8P6Ovro2bNmhg7diwGDBig0O/OnTswMzODoaEhvvnmGxw4cACVK1cW769Xrx4CAwNx7NgxrFu3Dk+fPkXjxo3x/v37PD+PrGQ3rrzKag5zcu6DBw8iJiYGvr6+OR6Dp6cnpkyZAnd3d/j7+8PIyAi2trYYOnQo3N3dMXXqVLx580ahTseQIUMQEhKCP/74Q2wLCAhAjx49YGlpmeMxAEUo6GFgYIBatWrh9OnTYltqaipOnz6daVSqfv36Cv0B4OTJkzmKoNWqVQv6+voKx3n48CFCQ0PF49SvXx937txRWON28uRJWFhYqPWNS0REGbl9/qPs9dsXavlmiYiIiFTToUMHXL16FdHR0QCAbt26Zbujy44dO2BmZib+nD9/PkOfESNG4J9//kFwcHCmx9m9ezd27NiBnTt34ubNmwgKCsLixYsRFBSk0K9ixYq4desWrly5gm+//RY+Pj64d++eeH/79u3Rq1cvVK9eHW3btsXRo0cRExOD3bt352QqMHfu3AzP65tvvlFoCw0NVXlceZXVHObk3Fu2bEH79u3h7Oyc4zGkrb+hq6sLGxsbVKtWTWyTB9bSXkd7eHigQYMG4mYlT548wfnz5+Hn55fj88sVqeUt48aNg4+PD2rXro26deti+fLlSEhIENeaDRo0CCVLlsS8efMAAGPGjEHTpk2xZMkSdOzYEcHBwbh+/To2btwoHvPt27cIDQ1FWFgYAIjVbR0dHeHo6AhLS0v4+flh3LhxsLa2hoWFBUaNGoX69evjiy++AAC0adMGlStXxsCBA7Fw4UJERERgypQpGDFiBAyZik9ElK/khUw/piTi/fs3sLDg9jdERES5lZMM+6dPn8LKyipHBS27dOmCevXqibdLliypcP/IkSNx5MgRnDt3DqVKlcr0OBMmTBCzPQCgWrVqeP78OebNmwcfHx+xn4GBAcqXLw9A9oX2tWvXsGLFikx3nrGyskKFChXw5MkTlZ8TAHzzzTfo3bu3eHvAgAHo0aMHunfvLralDRzkdFw5kd0cqnru58+f49SpU9i/f3+uxqGvr69wWyKRKLTJl6+kpqYq9PPz88OoUaOwZs0aBAQEZKgnklNFJtMDAPr06YPFixdj6tSpqFGjBm7duoVjx46JEaLQ0FCEh4eL/Rs0aICdO3di48aN8PT0xN69e3Hw4EGF9J7Dhw+jZs2aYgGcvn37ombNmli/fr3YZ9myZejUqRN69OiBJk2awNHRUeGF19XVxZEjR6Crq4v69evjyy+/xKBBgzBz5sz8nhIiomLPyMAADmayJYLctpaIiChvcpJhf/jwYXTo0AF6eqp/l25ubo7y5cuLP8bGsvowgiBg5MiROHDgAH7//Xe4ublleZzExETo6Chezurq6ma4gE4vNTUVSVkUTo+Pj0dISAicnJxUfEYy1tbWGZ6Xvb29QltW85TduFSR0znM7twBAQGwt7cXr5ULSu/evaGjo4OdO3di27ZtGDJkSJ7qRBWpTA9AFrUaOXKk0vvOnj2boa1Xr14KW+uk5+vrm+36JCMjI6xZsybLLYpcXFxw9OjRLI9DRET5o4yNHSLj4xAR/i/c3etoejhERERFWnYZ9nKHDx/GTz/9JN4+cOAA/P39s13iosyIESOwc+dOHDp0CObm5mL9EEtLSxgbG2P16tU4cOCAGIzp3Lkz5syZgzJlyqBKlSr466+/sHTpUgwZMkQ8pr+/P9q3b48yZcrg/fv32LlzJ86ePYvjx4+LfcaPH4/OnTvDxcUFYWFhmDZtGnR1dRWKZsbHxytkfjx9+hS3bt2CtbV1rgqeqjKu9M9XlXFkN4eqnhuQBUICAgLg4+OTo6CWOpiZmaFPnz7w9/dHXFxcruqJpFXkgh5ERETpudk74NrzEES8zFkqKhEREWXUp08fvH79GlOnTkVERARq1KihkGEPyC64Hz58iHbt2oltsbGxYrmAnFq3bh0A2VanaQUEBMDX1xfR0dEICQkR21etWoWffvoJw4cPR1RUFJydnTFs2DBMnTpV7BMVFYVBgwYhPDwclpaWqF69Oo4fP47WrVuLfV6+fIl+/frhzZs3sLOzQ6NGjXD58mWFbVuvX7+O5s2bi7flu3D6+PggMDAwx89VlXGlf76qjCO7OVT13ABw6tQphIaGKgSRCpKfnx+2bNmCDh065KqeSFoSgVXfCoW4uDhYWloiNjgYFiYmmh5OkfQhKYnbmWo5vsbaL7ev8Y+bArDwfwfQurEvRk0IyIeRkbokJX3gVpdaShAEJCTEICnpA6ytnbhlrRbj51h1Uinw4EEc/P0tERsbq5EdG0+dOoW7d+9izJgxmfY5e/YsfH198ezZM5WPu2LFChw9ejRDhgAVD/369YOuri5+/vlnTQ9FQXBwMKRSqcIuPkWqpgcREZEy5UvJvgGIYk0PSi86Grh9W/YvERGpzeHDh9GlSxdND4MK2KdPn3Dv3j1cunQJVapU0fRwVMLlLUREVOSVc5ZVk49681zDI6FC5cQJYM0aQEgFJDrAiBFAmzaaHhURkVZIW2uCio9//vkHDRo0QPPmzfHNN99oejgqYdCDiIiKPLfPa4xfx7xCampqhmruVAxFR/8X8ABk/65dC3h5Abbc1piIKC1XV1eMHTtW08OgIqBGjRpITEzU9DByhH8VEhEVI9qa6V/azg66Eh18kqbg3bvw7B9A2u/B/f8CHnKpUiCc7w8iovQY9CBtxkwPIqJiQp7pnyoAOhLtyvTX09WFs2UJvIh5g8jIZ7CxKanpIZEmnTgBrF6dsV1HF3ByKvjxEBERkcYw04OISAtkl8Ehz/RP/bxfV6ogy/TXpoyPMtayJQsR4SHZ9CStJn+zI93mdDq6wPDhXNpCRERUzDDTg4ioiFMlgyMs7L+Ah5w0VZbpry3XgG72Drjw70NEvHis6aGQJoWFZVzWAgDjxwONGhX8eAqz6GjZfDk7a88vAiIionQY9CAiKsIyy+BIX6vR2VkWEEkb+NDV0a5M/7Kfd3CJCGOmR7Hm7CzbqSVt4ENHF/Dw0NyYCiPubENERMUEl7cQERVhWWVwpGVrK7um0f38W19XR/sy/cuVdgYAREU91fBISKPkb3YdXdltLmvJKLOdbbRpvRsR5cjZs2fh6uqao8ds3boVDx48yJ8BUaHn6+sLb29vTQ9DJQx6EJHaaesOIYWRPIMjrcwyONq0ATZvBubOkf2rbV/qlnOSZXpEvQnV8EhI4+Rv9jlztfPNnlfKlgBxZxsiSuPcuXPo3LkznJ2dIZFIcPDgwQx9rly5gg0bNhToOeXmz58PiUSi8o4za9asgaurK4yMjFCvXj1cvXpVvG/69OmQSCQKPx7psgOlUil++uknuLm5wdjYGOXKlcOsWbMgCEL6U6ksJ89X7v379xg7dixcXFxgbGyMBg0a4Nq1a7k67qtXr/Dll1/CxsYGxsbGqFatGq5fv56hX2ZzvWLFCgQGBqr4bFXTuXNntGvXTul958+fh0Qiwe3bt3N8XAY9iEitTpwA/PyAyVNk/544oekRabecZnDY2gLVqmnnl95uDg4AgLdxkZBKP2l4NKRx2vxmzyv5EqC0uLMNEaWRkJAAT09PrFmzJtM+Xbt2xeHDhwv0nABw7do1bNiwAdWrV1fpuLt27cK4ceMwbdo03Lx5E56enmjbti2ioqLEPlWqVEF4eLj48+effyocY8GCBVi3bh1Wr16N+/fvY8GCBVi4cCFWrVqV6XmbNWuWZVBA1eeb1ldffYWTJ09i+/btuHPnDtq0aYNWrVrh1atXOTruu3fv0LBhQ+jr6+O3337DvXv3sGTJEpQoUUKhX1ZzbWlpCSsrK5XHrgo/Pz+cPHkSL1++zHBfQEAAateurfLrnhZrehCR2qhaX4LUq00b2RyHh8uuWYrrXDuWKAFDXT0kST/h9esXcHR00/SQiAonebR07VpZhgeXABFROu3bt0f79u2z7NOyZUtERkbin3/+QdWqVQvknPHx8RgwYAA2bdqE2bNnq3TcpUuXYujQoRg8eDAAYP369fj111+xdetWTJw4EQCgp6cHR0fHTI9x8eJFdO3aFR07dgQAuLq64pdfflHIGMkpVZ5vWh8+fMC+fftw6NAhNGnSBIAsS+V///sf1q1bJ86HKsddsGABSpcujYCAALHNzU3x76bs5trX1xcxMTGZZpI0a9YM1apVg66uLoKCgmBgYIDZs2ejf//+GDlyJPbu3QsHBwesWrVKHG+nTp1gZ2eHwMBATJkyRWEse/bswaJFi7KfKCWY6UFEaqNqfQlSP36pDejo6KCUlTUAIDKSdT2IssQlQESUR4aGhmjTpo1CtkdgYCAkEkkWj8qbESNGoGPHjmjVqpVK/ZOTk3Hjxg2F/jo6OmjVqhUuXboktj1+/BjOzs4oW7YsBgwYgNBQxaWyDRo0wOnTp/Ho0SMAwN9//40///wzR0GLvPr06ROkUimMjIwU2o2NjTNkpmTn8OHDqF27Nnr16gV7e3vUrFkTmzZtUuiT07lWJigoCLa2trh69SpGjRqFb7/9Fr169UKDBg1w8+ZNtGnTBgMHDkRiYiIAWfBp0KBBCAwMVFg6tGfPHkilUvTr1y9X42DQg4jUJif1JYjyg4utPQDu4EKkEkZLiSiP0i9xsbS0RMWKFfPlXMHBwbh58ybmzZun8mOio6MhlUrh8HkJrJyDgwMiIiIAAPXq1UNgYCCOHTuGdevW4enTp2jcuDHev38v9p84cSL69u0LDw8P6Ovro2bNmhg7diwGDBignienAnNzc9SvXx+zZs1CWFgYpFIpfv75Z1y6dAnhOfyG8d9//8W6devg7u6O48eP49tvv8Xo0aMRFBQEIHdzrYynpyemTJkCd3d3+Pv7w8jICLa2thg6dCjc3d0xdepUvHnzRqFOx5AhQxASEoI//vhDbAsICECPHj1gaWmZq3Ew6EFEalMcdgihwk1e1yPixSMNj4SoALBqNBFpWIcOHXD16lVEf/491K1bt2x3dNmxYwfMzMzEn/Pnz2d7nhcvXmDMmDHYsWNHhkyHvGrfvj169eqF6tWro23btjh69ChiYmKwe/dusc/u3buxY8cO7Ny5Ezdv3kRQUBAWL14sBgkAYO7cuRme1zfffKPQlj6DJKe2b98OQRBQsmRJGBoaYuXKlejXrx90dHJ2WZ+amgovLy/MnTsXNWvWxNdff42hQ4di/fr1ap3rtPU3dHV1YWNjg2rVqolt8mBU2voqHh4eaNCgAbZu3QoAePLkCc6fPw8/P79cj4M1PYhIrVhfgjSpbElZWlFE+L8aHglRPjtx4r9tZyU6sogzl6gQUQF7+vQprKysclTQskuXLqhXr554u2TJktk+5saNG4iKioKXl5fYJpVKce7cOaxevRpJSUnQ1dXN8DhbW1vo6uoiMjJSoT0yMjLTGh5WVlaoUKECnjx5IrZNmDBBzPYAgGrVquH58+eYN28efHx8AADffPMNevfuLT5mwIAB6NGjB7p37y62OTs7Z/tcs1KuXDn88ccfSEhIQFxcHJycnNCnTx+ULVs2R8dxcnJC5cqVFdoqVaqEffv25XquldHX11e4LZFIFNrkS6FSUxV3FPPz88OoUaOwZs0aBAQEoFy5cmjatGmOnmNaDHoQkdrZ2jLYQZpRvpTsj4nXr59reCRE+UheNVq+7ayQyqrRRKQRhw8fRocOHaCnp/plpbm5OczNzXN0npYtW+LOnTsKbYMHD4aHhwd+/PHHTC/CDQwMUKtWLZw+fRre3t4AZBfYp0+fxsiRI5U+Jj4+HiEhIRg4cKDYlpiYmCGbQldXV+Fi3draGtbW1uJtY2Nj2Nvbo3z58jl6rqowNTWFqakp3r17h+PHj2PhwoU5enzDhg3x8OFDhbZHjx7BxcUl13OtTr1798aYMWOwc+dObNu2Dd9++22easUw6EFERFrDzfFzmuTbvKWPEhVqYWH/BTzkUqWyFDsGPYhIDeLj4xUyHZ4+fYpbt27B2toaZcqUEdsPHz6Mn376Sbx94MAB+Pv7Z7vEJTfnTL9DjKmpKWxsbBTaV69ejQMHDuD06dNi27hx4+Dj44PatWujbt26WL58ORISEsTdXMaPH4/OnTvDxcUFYWFhmDZtGnR1dRWKZnbu3Blz5sxBmTJlUKVKFfz1119YunQphgwZkuPnqerzVfZ8jh8/DkEQULFiRTx58gQTJkyAh4eH+FxUPe53332HBg0aYO7cuejduzeuXr2KjRs3YuPGjTA3N1dprvOTmZkZ+vTpA39/f8TFxcHX1zdPx2PQg4iItIa8pkdM/GskJX2AoaGxhkdElA+cnWVLWtIGPnR0WTWaiNTm+vXraN68uXh73LhxAAAfHx8EBgYCkF1MP3z4EO3atRP7xcbGZsggUOc5sxMdHY2QEMVi5n369MHr168xdepUREREoEaNGjh27JhYT+Lly5fo168f3rx5Azs7OzRq1AiXL1+GnZ2deIxVq1bhp59+wvDhwxEVFQVnZ2cMGzYMU6dOzdVzVfX5pn8+sbGx8Pf3x8uXL2FtbY0ePXpgzpw5CktGVDlunTp1xADVzJkz4ebmhuXLlxdoYdbs+Pn5YcuWLejQoUOelwVJhLR7wZDGxMXFwdLSErHBwbAwMdH0cIqkD0lJMDY01PQwKB/xNdZ+eX2NBUGAec/eSEhJwtq191GqlIcaR0fqwGCUmpw4IVvSkiqVBTyGD9d4TQ9BEJCQEIOkpA+wtnbK120rSbP4OVadVAo8eBAHf39LxMbGwsLCosDHcOrUKdy9exdjxozJtM/Zs2fh6+uLZ8+eqXzcFStW4OjRozh+/LgaRklFTb9+/aCrq4uff/5Z00NREBwcDKlUqhDAYaYHERFpDYlEgjLWtrgf+QqRkU8Z9CDtxarRRKRhhw8fVijSScXDp0+f8OjRI1y6dAnDhg3T9HBUwqAHERFpFRdbO9yPfIXwl0+AWpoeDVE+YtVoItKgtHUzqPj4559/0KBBAzRv3hzffPONpoejEgY9iIhIq5R1dATuApGvnmTfmfJPdLSs4KazMy/MiYgKOVdXV4wdO1bTw6AioEaNGkhMTNT0MHKEQQ8iItIqZUvKijlGhP+r4ZEUYydO/LelqkQHGDFC4/UmiIgocwx6kDbTyb4LERFR0VG+lCzoEfX6mWYHUlxFR/8X8ABk/65dK2snIiIiKmAMehARkVaRb1v7+u2LnD84Ohq4fZsX6HkRFqa4lSog22EkPFwz4ynq+J4kIiLKEy5vISIirSIPesR/jEViYhxMTFTcHpBLMtTjiZJaKjq6sh1GKGf4niQiIsozZnoQEZFWMTcxQQljUwBAZORT1R7EJRnqER0NBAVlbPcZxGKmOcX3JBERkVow6EFERFrHxVp2gR0Z+Uy1B3BJhnoom0cAKO9e8GMp6vieJCIiUgsGPYiISOu42NkDACJePlbtAc7OsuUDaXFJRs5xHtWHc0lERKQWDHoQEZHWcXN0BACEqxr0sLWV1UvQ0ZXd1tEFhg/nkoyc4jyqT1GbS3nB1TdvND0SIiIiBSxkSkREWqecfNtaVWt6ALICkV5esuUDTk6F9+IyP0RHy5ZTODvn/XkX53lUt6Iyl2LBVSkAKTB4EODdV9OjIiIiAsCgBxERaaHyJT8HPV4/z9kDbW0L74VlfsmPHUKK4zzml8I+l+kLriIVCAgEGrUC7Ow0OTIiIiIAXN5CRFSsyDPQtX0DCPm2ta/fvYQgCBoeTSHGHUIor5QWr01lwVUiIio0mOlBRFRMyL/QTxUAHYl6vtAvrFzsZYVMP6Yk4v37N7CwKMTflGtSVjuEFObsgtxQ5xIe+o+84KrC+0iHBVeJiKjQYKYHEVExIP9CP/Vz0kOqoN1f6BsZGMDBzAIAEJmTuh7FTXHZIeTECcDPD5gyWfbviRPqP0dxSaNKL33BVYkuMNg354Gl4jp/RESU75jpQURUDISF/RfwkJOmaucX+nJlbOwQGR+HiPB/4e5eR9PDKZzkF6xr18oyPAr7DiG5kdkSHi8v9T3P/KiLUpTIC66GhQGWJoCZSc4eX9znj4iI8hWDHkRExYCzs2xJS9rAh66WZ6C72Tvg2vMQhL9Qcdva4qqo7BCSW/m9hCezoIqbK/DhY/FZTmNrC9jYAAkxQNIH1R9XEEEpIiIq1hj0ICIqBtJ+oS9NlQU8tO0L/fTcnBwBABFhTzQ8kiIgP3cI0XQtDWU1J9S5hCezoMr4CdqbuaDO17Q41ZUhIiKNYNCDiKiY0PYv9NOTb1v7OvKZZgdSnKVdtgAJ4OsLdGxfsGPI7yU8Sgt5QnszF9S9FCW/g1JERFTsMehBRFSM5OcX+oVNWWdZpkfUm+caHkkhUdAZF+mXLUAAAgMAaRLQq1/+nz+t/Iz4pQ+qKAuAaEvmQn4sRSkOdWWIiEijGPQgItICml5BUBi5OTgAAF7HvEJqaip0dIrxhmWaKBSpbNkCAGzfATRvXfBv1PyM+KUNqhgZ/re0RU5bMhfyaylKcUtDIyKiAsWgBxFRESe/nk0VZMVKta18QG6VtrODrkQHn6QpePcuHDY2JTU9JM3QVKFIZ2cAEgDptg2Clm4blDaooq2ZC/m5FKU4paEREVGBKsZfexERFX3y61n5riypguxaKzpas+MqDPR0deFsWQIAEBn5VMOj0aCsvp3PT7a2shoe6Um0JOshK23aAJs3A3Pmyv7VliikfCmKjq7stjYFdIgoWxKJBAcPHsy34/v6+sLb2ztPxzh79iwkEgliYmLUMibSDsz0ICIqwsLCFLehBWS7s2jjF+m54WJjhxcxbxAeFoLKlRtpejiaoclCkd27y5I9AoNk59fRBb72U++bs7Cu7dLWzAUuRSHSOr6+vggKCgIA6OnpwdraGtWrV0e/fv3g6+srLg8NDw9HiRIl8m0cK1asgCCkzw7MmQYNGiA8PByWlpZqGpWMRCLBgQMH8hyUIc1g0IOIqAhzdpYtaUkb+NDV0f4v0lXl5uCAP0MeIPJlMd62VtOFIrt1Bxo3+e8i2dxUfcfWRK0S0t6ADlEx1q5dOwQEBEAqlSIyMhLHjh3DmDFjsHfvXhw+fBh6enpwdHTMl3NLpVJIJBK1BCoMDAzybZzqkJKSAn19fU0Po9jh8hYioiJMfj2r+/m3ua4Os83TcnOUFTONCAvR8Eg0TNPLLWxtgWrV1J/hoaxWSXFY2xUdDdy+XTyeKxEVCENDQzg6OqJkyZLw8vLCpEmTcOjQIfz2228IDAwEoLi8JTk5GSNHjoSTkxOMjIzg4uKCefPmiceLiYnBsGHD4ODgACMjI1StWhVHjhwBAAQGBsLKygqHDx9G5cqVYWhoiNDQ0AzLW5o1a4ZRo0Zh7NixKFGiBBwcHLBp0yYkJCRg8ODBMDc3R/ny5fHbb7+Jj0m/vEV+ruPHj6NSpUowMzNDu3btEJ5miee1a9fQunVr2NrawtLSEk2bNsXNmzfF+11dXQEA3bp1g0QiEW8DwLp161CuXDkYGBigYsWK2L59u8K8SiQSrFu3Dl26dIGpqSnmzJmT25eI8qDIBT3WrFkDV1dXGBkZoV69erh69WqW/ffs2QMPDw8YGRmhWrVqOHr0qML9giBg6tSpcHJygrGxMVq1aoXHjx+L98s/OMp+rl27BgB49uyZ0vsvX76s/gkgIkpHfj07d452lQ9Qh3KlnQEAUVHFuKaHXH4EHjRJU7VKNO3ECcDPD5gyWfbviROaHhERaakWLVrA09MT+/fvz3DfypUrcfjwYezevRsPHz7Ejh07xGBAamoq2rdvjwsXLuDnn3/GvXv3MH/+fOjq6oqPT0xMxIIFC7B582bcvXsX9vb2SscQFBQEW1tbXL16FaNGjcK3336LXr16oUGDBrh58ybatGmDgQMHIjExMdPnkZiYiMWLF2P79u04d+4cQkNDMX78ePH+9+/fw8fHB3/++ScuX74Md3d3dOjQAe/fvwcA8ZovICAA4eHh4u0DBw5gzJgx+P777/HPP/9g2LBhGDx4MM6cOaNw/unTp6Nbt264c+cOhgwZIl47nj17NvsXgdSiSC1v2bVrF8aNG4f169ejXr16WL58Odq2bYuHDx8q/aBcvHgR/fr1w7x589CpUyfs3LkT3t7euHnzJqpWrQoAWLhwIVauXImgoCC4ubnhp59+Qtu2bXHv3j0YGRmJ68LS+umnn3D69GnUrl1bof3UqVOoUqWKeNvGxiYfZoGIKCNmmytXzkmW4hr1JlTDIyG102StEk3R1E48RFRseXh44Pbt2xnaQ0ND4e7ujkaNGkEikcDFxUW879SpU7h69Sru37+PChUqAADKli2r8PiUlBSsXbsWnp6eWZ7f09MTU6ZMAQD4+/tj/vz5sLW1xdChQwEAU6dOxbp163D79m188cUXSo+RkpKC9evXo1y5cgCAkSNHYubMmeL9LVq0UOi/ceNGWFlZ4Y8//kCnTp1gZ2cHALCyslJYOrN48WL4+vpi+PDhAIBx48bh8uXLWLx4MZo3by7269+/PwYPHizefvXqFSpWrAgTE5MsnzupT5HK9Fi6dCmGDh2KwYMHo3Llyli/fj1MTEywdetWpf1XrFiBdu3aYcKECahUqRJmzZoFLy8vrF69GoAsy2P58uWYMmUKunbtiurVq2Pbtm0ICwsTU7fk68LkPzY2Njh06BAGDx4MiUSicD4bGxuFvlyvRUSkWW4OsuUtb+Ii8OlTioZHQ2pVHHcSKejsFi6jISr2BEHIcM0DyIqf3rp1CxUrVsTo0aNxIk3W2a1bt1CqVCkx4KGMgYEBqlevnu350/bR1dWFjY0NqlWrJrY5fP7/fFRUVKbHMDExEQMeAODk5KTQPzIyEkOHDoW7uzssLS1hYWGB+Ph4hIZm/YXJ/fv30bBhQ4W2hg0b4v79+wpt6b8oL1myJB48eIC6detmeXxSnyIT9EhOTsaNGzfQqlUrsU1HRwetWrXCpUuXlD7m0qVLCv0BoG3btmL/p0+fIiIiQqGPpaUl6tWrl+kxDx8+jDdv3ihE6+S6dOkCe3t7NGrUCIcPH87y+SQlJSEuLk7hh4gKF/69X/Q5ligBQ109CEIqoqNfaHo4pG6arlVS0OTZLWnlV3aLsmU0/KVIVOzcv38fbm5uGdq9vLzw9OlTzJo1Cx8+fEDv3r3Rs2dPAICxsXG2xzU2NlYaTEkv/ZfIEolEoU1+jNTUdAHhbI6RdpcYHx8f3Lp1CytWrMDFixdx69Yt2NjYIDk5OdvxqcLUVI0FvClXiszylujoaEilUjGaJ+fg4IAHDx4ofUxERITS/hEREeL98rbM+qS3ZcsWtG3bFqVKlRLbzMzMsGTJEjRs2BA6OjrYt28fvL29cfDgQXTp0kXpcebNm4cZM2ZkaP+QlAT9NOvdSHUfkpI0PQTKZwX5Gp86DWxYD6RCFh0e9g3QqmWBnb7Yyo/XuKSVNf59E4WXLx+iRAktXvpQRCQlfVDvAc1NAfPynw+u5mMXNuamwLCvgA0bAUEKSD5vAWxuqt7n/iYaWL0Sst+AkJ1r9UoAwucfHeCbYUBLxS+WBEFAUtIHJCd/RFLSB5UuaKhoUvvnWItJpUByctGcr99//x137tzBd999p/R+CwsL9OnTB3369EHPnj3Rrl07vH37FtWrV8fLly/x6NGjLLM9CosLFy5g7dq16NChAwDgxYsXiE4X3NXX14dUKlVoq1SpEi5cuAAfHx+FY1WuXDn/B005UmSCHoXBy5cvcfz4cezevVuh3dbWFuPGjRNv16lTB2FhYVi0aFGmQQ9/f3+Fx8TFxaF06dIwNjSEsaFh/jyBYoBzp/0K4jWOjgY2bwAkAOQhyC0bgfp1tTtzvrBQ92vsamuPf99E4c3rlzA0zP7bJ8p/mb4O0dGyJRzOzvywZaZDZ6Bu/f+2AM6PeYp+B8XfgHJpghgbt8jGkeb8giDg0ydZ4NLQULVvcano4u9T1UilgIFB4V9emZSUhIiICIUta+V1EQcNGpSh/9KlS+Hk5ISaNWtCR0cHe/bsgaOjI6ysrNC0aVM0adIEPXr0wNKlS1G+fHk8ePAAEokE7dq108Czy5q7uzu2b9+O2rVrIy4uDhMmTMiQreLq6orTp0+jYcOGMDQ0RIkSJTBhwgT07t0bNWvWRKtWrfC///0P+/fvx6lTp7I836tXr9CyZUts27aNS1wKSJFZ3mJrawtdXV1ERkYqtEdGRma6F7Ojo2OW/eX/qnrMgIAA2NjYZBrISKtevXp48uRJpvcbGhrCwsJC4YeICoewMCBVUGyTpmr/phDaSl7XI+LFIw2PhLLEXUlUl9878ShbRpNecdgph6gYOXbsGJycnODq6op27drhzJkzWLlyJQ4dOqSw64qcubk5Fi5ciNq1a6NOnTp49uwZjh49Ch0d2e+Offv2oU6dOujXrx8qV66MH374IUOmRGGxZcsWvHv3Dl5eXhg4cCBGjx6dYZOMJUuW4OTJkyhdujRq1qwJAPD29saKFSuwePFiVKlSBRs2bEBAQACaNWuW5flSUlLw8OHDLHecIfWSCGkXNBVy9erVQ926dbFq1SoAsrVbZcqUwciRIzFx4sQM/fv06YPExET873//E9saNGiA6tWrY/369RAEAc7Ozhg/fjy+//57ALKMC3t7ewQGBqJv377i4wRBQLly5dC9e3csXrw427EOHToUN27cUNjjOStxcXGwtLREbHAwLFjJN1c+JCUx00PLFdRrHB0tu+ZKG/jQ1ZGVDOCXz/krP17jub/sxuRffkbDWt3x47R9aj025VxS0oeM3xDLP3Tpd2JZtBD48JGZH5pw4oRsZ5hUqey1SE2FbGnLZxIdYPEiwP2/1HVBEJCQEIOkpA+wtnZipocWU/o5JqWkUuDBgzj4+1siNjZWI190njp1Cnfv3sWYMWMK/NxEBS04OBhSqRQDBgwQ24rU8pZx48bBx8cHtWvXRt26dbF8+XIkJCSIRUUHDRqEkiVLYt68eQCAMWPGoGnTpliyZAk6duyI4OBgXL9+HRs3bgQgK2IzduxYzJ49G+7u7uKWtc7OzvD29lY49++//46nT5/iq6++yjCuoKAgGBgYiFG//fv3Y+vWrdi8eXM+zgYR5Rf5phBr18oyPHR1VN8UQpXsfGbwF6zypZwBAFGvn2l2IJS5zHYl+X48AEF2gT1ihPYXKi1M2rSRbYUrX0Zz8+Z/QRBA9nqNn8DXhYiICr0iFfTo06cPXr9+jalTpyIiIgI1atTAsWPHxEKkoaGhYkoVIMvq2LlzJ6ZMmYJJkybB3d0dBw8eRNWqVcU+P/zwAxISEvD1118jJiYGjRo1wrFjx2BkZKRw7i1btqBBgwbw8PBQOrZZs2bh+fPn0NPTg4eHB3bt2iVWMCai/JGfwYP0f++rcvwTJ4A1a2QZIjoS5dcCqvQh9SrrKPt/xOs3WW89RxpkbJTJHZ8zC4RU2QW3lxcjhQXJ1va/+W7TBnBzlQU65AEqvi5ERFQEFKmgBwCMHDkSI0eOVHrf2bNnM7T16tULvXr1yvR4EokEM2fOxMyZM7M8786dOzO9z8fHR6FqLxHlv4IIHqT9ez870dH/jQeQ/Zv+WkCVPqR+8poeMQnRTMkurD58zL6PvIYEPyya8+Gj8owcvi5ERFSIFZlCpkREcpkFD9LtLlagVCl+ygKpmmFtbg5TfVmdkNevn2t4NIVQdDRw+7ZmP0CqFM7U0ZWlXeWXwjAPhZ2y1ym/XxciIqI8YtCDiIqcwhg8cHaWZZykpaujeC2gSh9SP4lEgjLWsm+hIyOfang0hUxh2TFFXkhH5/MOATq6QIuWirdVLayTG4VlHgo7Za9Tfr4uRFQonD17FhKJBDExMQV63sDAQFhZWeXpGM+ePYNEIsGtW7cy7aOp50cFh0EPIipyCmPwQH4toKvz33jSXwuo0ofyh4utHQAg/GXmW4kXO/KUqfT1GTSV6dCmjWyLpDlzZf+OHat4O7+K3xS2eSjs0r9OLEpEVKRJJJIsf6ZPn67pIRZax48fxxdffAFzc3PY2dmhR48eePbsWZaPefv2LQYMGAALCwtYWVnBz88P8fHx4v3yIE36n8uXL4t9mjVrprRPx44dFc51//59dOnSBZaWljA1NUWdOnUQGqq++maRkZHQ19dHcHCw0vv9/Pzg5eWltvPlRZGr6UFElJfdVfKTKsVPc1MglfKurKMjcBeIePlYeYfiuKVOZjumaLI+Q/pCOjkprJNbhXEecqug3scF8bpoi+L4u4WKlPA0abK7du3C1KlT8fDhQ7HNzMwM169fz/Fxk5OTYWBgoJYxFkZPnz5F165dMW7cOOzYsQOxsbH47rvv0L17d9y8eTPTxw0YMADh4eE4efIkUlJSMHjwYHz99dcZ6keeOnUKVapUEW/b2NiI/71//34kJyeLt9+8eQNPT0+FOpYhISFo1KgR/Pz8MGPGDFhYWODu3bsZNuvICwcHB3Ts2BFbt25F3759Fe5LSEjA7t27MX/+fLWdLy+Y6UFERZL8y8a5cwrXl422tkC1aln/batKH1KvciVlaUCREf9mvLO4Lm1gfQYZbZmH4vo+Lsz4mlAR4OjoKP5YWlpCIpEotJmZmYl9b9y4gdq1a8PExAQNGjRQCI5Mnz4dNWrUwObNm+Hm5iZeXMfExOCrr76CnZ0dLCws0KJFC/z999/i4/7++280b94c5ubmsLCwQK1atTIEWY4fP45KlSrBzMwM7dq1UwjUpKamYubMmShVqhQMDQ3F3T2zcvToUVSoUAHGxsZo3rx5ttkZyty4cQNSqRSzZ89GuXLl4OXlhfHjx+PWrVtISUlR+pj79+/j2LFj2Lx5M+rVq4dGjRph1apVCA4ORlhYmEJfGxsbhddBX19fvM/a2lrhvpMnT8LExEQh6DF58mR06NABCxcuRM2aNVGuXDl06dIF9vb2mT4nX19feHt7Y+7cuXBwcICVlRVmzpyJT58+YcKECbC2tkapUqUQEBAgPsbPzw+nT5/OkEGyZ88efPr0CQMGDMjRvOYXBj2IqEiIjgbu/KOYcc7gAamqfGlnAEBU+kKmxXlpA+szyGjDPBTn93FhxdeEtNDkyZOxZMkSXL9+HXp6ehgyZIjC/U+ePMG+ffuwf/9+sYZGr169EBUVhd9++w03btyAl5cXWrZsibdv3wKQZT6UKlUK165dw40bNzBx4kSFC/zExEQsXrwY27dvx7lz5xAaGorx48eL969YsQJLlizB4sWLcfv2bbRt2xZdunTB48fKMztfvHiB7t27o3Pnzrh16xa++uorTJw4MUM/iUSCwMDATOeiVq1a0NHRQUBAAKRSKWJjY7F9+3a0atVKYfxpXbp0CVZWVqhdu7bY1qpVK+jo6ODKlSsKfeUBikaNGuHw4cOZjgMAtmzZgr59+8LU1BSALBD066+/okKFCmjbti3s7e1Rr149HDx4MMvjAMDvv/+OsLAwnDt3DkuXLsW0adPQqVMnlChRAleuXME333yDYcOG4eXLlwCADh06wMHBIcNcBQQEoHv37nmuyaIuXN5CpKW0KaNWvj1tigDo59P2tKTdXD9/s/H67QvFO7RpaUNucL2VTE7moTD+ci3u7+PCiK8JaaE5c+agadOmAICJEyeiY8eO+Pjxo5jVkZycjG3btsHOTlZH688//8TVq1cRFRUFQ0PZLmqLFy/GwYMHsXfvXnz99dcIDQ3FhAkT4OHhAQBwd3dXOGdKSgrWr1+PcuXKAQBGjhyJmTNnivcvXrwYP/74o7i8YsGCBThz5gyWL1+ONWvWZHgO69atQ7ly5bBkyRIAQMWKFXHnzh0sWLBAoV/FihVhaWmZ6Vy4ubnhxIkT6N27N4YNGwapVIr69evj6NGjmT4mIiIiQ6aFnp4erK2tERERAUC2nGjJkiVo2LAhdHR0sG/fPnh7e+PgwYPo0qVLhmNevXoV//zzD7Zs2SK2RUVFIT4+HvPnz8fs2bOxYMECHDt2DN27d8eZM2fE11AZa2trrFy5Ejo6OqhYsSIWLlyIxMRETJo0CQDg7++P+fPn488//0Tfvn2hq6sLHx8fBAYG4qeffoJEIkFISAjOnz+PkydPZnqegsagB5EWkgcJUgVZwc+iHCTIbHtaLy/FvxsL43UIFR5uDg4AgPiPsUhMjIOJiYXsDvnShrQXJ0VxaUNe5KY+gzZ+4FSZh/37gcBAAILsfZOfv1xzMsd8Hxc+fE00Txt/T2lY9erVxf92+vxejoqKQpkyZQAALi4uYsADkC1diY+PV6hHAQAfPnxASEgIAGDcuHH46quvxCyJXr16iQEOADAxMVG47eTkhKioKABAXFwcwsLC0LBhQ4XjN2zYUGEJTVr3799HvXr1FNrq16+fod+DBw8ymQWZiIgIDB06FD4+PujXrx/ev3+PqVOnomfPnjh58iQkEkmWj8+Mra0txo0bJ96uU6cOwsLCsGjRIqVBjy1btqBatWqoW7eu2JaaKvu907VrV3z33XcAgBo1auDixYtYv359lkGPKlWqQEfnv8UgDg4OqFq1qnhbV1cXNjY24msAAEOGDMH8+fNx5swZtGjRAgEBAXB1dUWLFi1yMQP5g8tbiLRMZkGCgsyojY4Gbt9WzzlV2Z5Wvmx68hQumyblzE1MUMJYlvapsG2tNixtKGjFtU7Bgf1AYACAz7+Q8nO5Qk7nmO/jwoeviWYV199T+Sztsg35Rb38AhuAuLxCLj4+Hk5OTrh165bCz8OHDzFhwgQAslogd+/eRceOHfH777+jcuXKOHDggNJzys8rCOn+MNSANWvWwNLSUqyZ0aRJE/z88884ffp0hqUqco6OjgrBAgD49OkT3r59C0dHx0zPVa9ePTx5knH3uYSEBAQHB8PPz0+h3dbWFnp6eqhcubJCe6VKlbLdvUXZfCtrS/u6u7u7o3HjxggICEBqaiq2bduGwYMH5zrwkx+Y6UGkZbIKEhTE31rqzjKRb0+b9jml3Z5W1UwQIhdrW7x7lYDIyKdwc/P87w4u8VBdZnUKtP0DFx0NBAZlbM+P5Qq5neOs3sf8xlsz+LtFM4rr76lCyMvLCxEREdDT04Orq2um/SpUqIAKFSrgu+++Q79+/RAQEIBu3bple3wLCws4OzvjwoULCtkLFy5cUMh8SKtSpUoZamSk3Q5WVYmJiQoZEYAsCwJQDASlVb9+fcTExODGjRuoVasWAFkNjdTU1AzZJ2ndunVLzKxJa8+ePUhKSsKXX36p0G5gYIA6deooFJoFgEePHsHFxSX7J5cLfn5++Pbbb9GlSxe8evUKvr6++XKe3GKmB5GWkQcJ0kobJMiMOrIz8iPLRP5lme7n31bpt6dVJRNEm6kzq0bbudrJ1tGGv1BS3IxVcVWTVZ0CbabseQOy5Qt5Wa6g7AOclzlW9j4+sJ/feGsSf7cUvOL6e6oQatWqFerXrw9vb2+cOHECz549w8WLFzF58mRcv34dHz58wMiRI3H27Fk8f/4cFy5cwLVr11CpUiWVzzFhwgQsWLAAu3btwsOHDzFx4kTcunULY8aMUdr/m2++wePHjzFhwgQ8fPgQO3fuVFqw1MPDQyHjJL2OHTvi2rVrmDlzJh4/foybN29i8ODBcHFxQc2aNQHI6m14eHjg1atXAGQBl3bt2mHo0KG4evUqLly4gJEjR6Jv375wdpYVXA8KCsIvv/yCBw8e4MGDB5g7dy62bt2KUaNGZRjDli1b4O3tnWH5kHxedu3ahU2bNuHJkydYvXo1/ve//2H48OHZzmlu9OrVC/r6+hg2bBjatGmD0qVL58t5couZHkRaRh4kWLtWdvGfPkigjLqyM/Iry0T+ZdnTUMCtjOKxsssEKSpy80WsNtVuKQhuTo7ALSDiVcYUUVKRttYpyO4DqOx5A4CPT+5/uck/wEKqYn0Qdc7xfvmSnM8Kyzfemc03M1JIHbT191QRJJFIcPToUUyePBmDBw/G69ev4ejoiCZNmsDBwQG6urp48+YNBg0ahMjISNja2qJ79+6YMWOGyucYPXo0YmNj8f333yMqKgqVK1fG4cOHMxRElStTpgz27duH7777DqtWrULdunUxd+7cDDvRPHz4ELGxsZmet0WLFti5cycWLlyIhQsXwsTEBPXr18exY8dgbGwMQJYN8vDhQ4UtbHfs2IGRI0eiZcuW0NHRQY8ePbBy5UqFY8+aNQvPnz+Hnp4ePDw8sGvXLvTs2TPD+P7880+cyCSQ3a1bN6xfvx7z5s3D6NGjUbFiRezbtw+NGjXKfDLzwMTEBH379sXGjRszzGVhIBEKw6IoQlxcHCwtLREbHAwLExNND6dI+pCUBOPPlaFJ9rejqhsR+PllDBps3py72obqOpYymb3GJ05kDPJkdvFfGP+mzk3wIr/nWlPy83O8+vARjNq8EbWqtMa0efy2O9fkH7hU6X91CnIQbUtK+gBDQ+Ocnze/PryZBR+U9ZM/b4kO4OsDdOueu3PKP8DpL8rkH+A8zrF4jiFDINYgSWvOXFn2gZoJgoCEhBgkJX2AtbWT8vXcmc23qq8DFQq5/hwXFHV8htREKgUePIiDv78lYmNjYWFhUeBjOHXqFO7evZtp9gORNgkODoZUKsWAAQPENmZ6EGkpVTdkUGd2Rm6yTNRB1WXT+ZEZkdfrsNzWJNF07ZaiqHzJz5XmXz/X8EiKOE3UKcivC+KcrP1X5/PObjtTdZwrLAxKAx55XZKTF5nNt5srazCQerGeChGlwaAHUTGn7uUhmvo7I7sgT34UPFVHECW3wQttWdZTkOTb1ka9ewFBEApVVfEiJzfb3OZWfhYlzC74oIw6EmRVSb/P6xxntiTHNw9LcvIqs/m+d195+4MHQD6lYlMxUJC/p4ioUGMhU6JiLrtCobk9ZmGr26bugqfqKtqa28Kz+fG6aTsXe1kh06SUD4iLY+XXQiWrirz5WZRQHhhIK7O1/+rcArMgtjNNfw6JDuA7OPdLctQhs/muXCljOwAsWsTCq0RElGfM9CCiYpEFqu7MCHUtL8nLkqDi8Lqpk5GBARzNLBERH4uoqGewtLTT9JAIyH7pSn4WJUz7AUy79j/9hyk/sk0K4gNc2H5JZDbf7hVk7WnnGOAyFyIiUgsGPYgIgPZngaq73og6gyh5uS7R9tdN3Urb2CIiPhYR4f/C3b2OpodD0dHA6tUQa08ou8hVNTCRW6p8AHOzDEYVBfEBLmy/JDKb7zZtABNjYOFCxf7qmGciIirWGPQgomJDnV96qjuIUtiuS7SVm70Drj0PQfiLx5oeiuoK45ZD6vK/w8hQbFPZRW5+Zyxk9wEszltg5sf7L7P59qhUfOeZiIjyDYMeRFSsqDO4UNgyxyl7bk6OAICIsCc5f7Amgg/avI1ndDRw8FDG9sx2F9FkZFDd2SZFJZBV0O+//M7qISKiYolBDyLSGpq4jmCGRtEiblsb+TRHj0s5dgLv1wbAGvHixd/b2k1hbq4HfX3d/Bhq/u5aUhgoWzICAN5dC+fzU1eUs6gEsjT1/mM0mUhjBEHAsmXLsGrVKkRGRqJNmzYICgqCpaWl0r7Dhg3D3r178e7dO/z111+oUaNGwQ+6EGjWrBlq1KiB5cuXa3ooxUZO55y7txCRVpBvrDB5St43ViDtVU4e9Ih+rvJjUiJeY8HaEPyIbngNM0BIxes1Qfhx/EUsWPA3UlKk+TPY/Ny1JDey2mElNzLbyaNzF/UcPz/kdWuqzAIJ6ppTddLk+68wbgFGVAxMmDAB69atQ1BQEM6fP48bN25g+vTpSvseO3YMgYGBOHLkCMLDw1G1atWCHWwhsn//fsyaNUutx1y3bh2qV68OCwsLWFhYoH79+vjtt9+yfdyaNWvg6uoKIyMj1KtXD1evXlW4/9y5c+jcuTOcnZ0hkUhw8ODBTI81f/58SCQSjB07NtfHKCwY9CAqhNR9bZGfCsNY1bV9LBW8gn7/uDk4yM4bG4bUVCVZBkq8D3mJ57BBJCwwCd1wD06YJHRFZHQSnj9/j/fvP+XPYHOynWp+U+d2rXIFsW2rOqjzTVrYAllZKUzvPyLKd1euXMHSpUuxa9cuNGnSBLVq1cLQoUNx9OhRpf1DQkLg5OSEBg0awNHREXp6GRcQJCcn5/ewCwVra2uYm5ur9ZilSpXC/PnzcePGDVy/fh0tWrRA165dcffu3Uwfs2vXLowbNw7Tpk3DzZs34enpibZt2yIqKkrsk5CQAE9PT6xZsybL81+7dg0bNmxA9erVM9yn6jGyUtDvDQY9iAqZopSxUFjGmtX2scVVYQhGZUcT759StrbQlejgkzQF796p9gaxrlgac3EIDohDJCwwEd0RCQs42Bpi7ty6sLY2zJ/BFpagQH5mJ7RpA2zeDMyZK/u3sC3zUHewJ6+BhIL8YBeW9x8RFYjFixejZcuW8PLyEtscHBwQreT3ja+vL0aNGoXQ0FBIJBK4uroCkC05GDlyJMaOHQtbW1u0bdsWAJCUlITRo0fD3t4eRkZGaNSoEa5duyYer1mzZhg1ahTGjh2LEiVKwMHBAZs2bUJCQgIGDx4Mc3NzlC9fPstMh23btsHGxgZJSUkK7d7e3hg4cGCWz/3YsWNo1KgRrKysYGNjg06dOiEkJAQA8Pr1azg6OmLu3Lli/4sXL8LAwACnT58Wx582G2Lv3r2oVq0ajI2NYWNjg1atWiEhISHLMaTXuXNndOjQAe7u7qhQoQLmzJkDMzMzXL58OdPHLF26FEOHDsXgwYNRuXJlrF+/HiYmJti6davYp3379pg9eza6deuW6XHi4+MxYMAAbNq0CSVKlMhwvyrHSC+z90ZWcy+XkJCAQYMGwczMDE5OTliyZInK55Vj0IOoEClKGQvqHmte/paXbx+bVm63j9UGhSUYlZVM3z9v8ve8erq6cLaU/Q88UtW6Hra2sBvpg+8kpxWavxtfA3Z2xuoeoqLCEBTI7+yE3C5lyO8AQH4Ee/ISSMiPbJvsFIb3HxHlu6SkJPz6668ZLmI/fvyotJ7HihUrMHPmTJQqVQrh4eEKAYygoCAYGBjgwoULWL9+PQDghx9+wL59+xAUFISbN2+ifPnyaNu2Ld6+favwOFtbW1y9ehWjRo3Ct99+i169eqFBgwa4efMm2rRpg4EDByIxMVHpc+jVqxekUikOHz4stkVFReHXX3/FkCFDsnz+CQkJGDduHK5fv47Tp09DR0cH3bp1Q2pqKuzs7LB161ZMnz4d169fx/v37zFw4ECMHDkSLVu2zHCs8PBw9OvXD0OGDMH9+/dx9uxZdO/eHYIg+4MnMDAQEokkw+OyIpVKERwcjISEBNSvX19pn+TkZNy4cQOtWrUS23R0dNCqVStcunQpR+cbMWIEOnbsqHAsdVD23shq7uUmTJiAP/74A4cOHcKJEydw9uxZ3Lx5M0fnZiFTokIkq4yFwvblmjrHKq/rlyrIghc5reun7u1ji7LMggmFrfZlZu+fiAigtHP+ntvFxg4vYt4gPCwElSs3Uukxr2s2xjIbfSD6v2+Qli27jblz62Yd+FBHdV1NV8stjNu1FkQx0KyCPXl5PVQt1Jn2vQNorqitpt9/RJTvbt68iQ8fPuD777/HDz/8ILanpKSgefPmGfpbWlrC3Nwcurq6cHR0VLjP3d0dCxcuFG8nJCRg3bp1CAwMRPv27QEAmzZtwsmTJ7FlyxZMmDABAODp6YkpU6YAAPz9/TF//nzY2tpi6NChAICpU6di3bp1uH37Nr744osMYzI2Nkb//v0REBCAXr16AQB+/vlnlClTBs2aNcvy+ffo0UPh9tatW2FnZ4d79+6hatWq6NChA4YOHYoBAwagdu3aMDU1xbx585QeKzw8HJ8+fUL37t3h4uICAKhWrZrC3FWsWDHL8cjduXMH9evXx8ePH2FmZoYDBw6gcuXKSvtGR0dDKpXC4fMyXjkHBwc8ePBApfMBQHBwMG7evKkQyFKX9O8NIPu5j4+Px5YtW/Dzzz+LQaagoCCUKlUqR+dmpgdRIVKUMhbUNVZ1ZYzIv5CcO6d4fyFZVJb6ZPb+Sfe3U76Q1/WIePlYpf5v3yZh0qSriIxOgoODMebPrwcHB2NERn7ApElX8fZtkvIHauKb+fxQ2JY5FFQx0PysaZFddkv6987/DhedWiBEVOQ8evQIpqamuHPnDm7duiX+uLq6omHDhjk6Vq1atRRuh4SEICUlReE4+vr6qFu3Lu7fvy+2pa0doaurCxsbG4VggfxiPm19ivSGDh2KEydO4NWrVwBkWRW+vr5iZsWOHTtgZmYm/pw/fx4A8PjxY/Tr1w9ly5aFhYWFuFwnNDRUPPbixYvx6dMn7NmzBzt27IChofKlrZ6enmjZsiWqVauGXr16YdOmTXj37p14f7du3VQOQlSsWBG3bt3ClStX8O2338LHxwf37t1T6bG58eLFC4wZMwY7duyAkZGR2o+f/r0BZD/3ISEhSE5ORr169cTHWFtbqxw4kmPQg6gQkV9b6H7+ZBbmjAV1jVWdF+nFpeB/Vln9RSVwlun7xyb/z13WWTYZkWEh2fSUMTfXg4uLORwcjDF3bl1UrlwCc+fWhYODMVxczGFuriRpsijt0qGKwrTMIbMMjAcP1LvcRVPBHmXvnYOH1BOAKQrFfoiowMXFxcHW1hbly5cXf/T19fH48eMM38Rnx9TUNFdj0NfXV7gtkUgU2uSBi6yKkNesWROenp7Ytm0bbty4gbt378LX11e8v0uXLgpBndq1awOQ1c94+/YtNm3ahCtXruDKlSsAFItthoSEICxMVgT92bNnmY5BV1cXJ0+exG+//YbKlStj1apVqFixIp4+VXFJbRoGBgYoX748atWqhXnz5sHT0xMrVqxQ2tfW1ha6urqIjIxUaI+MjMyQjZOZGzduICoqCl5eXtDT04Oenh7++OMPrFy5Enp6epBK87ZbnbL3hipzrw5c3kJUyKia+VwYqGOs8ov0tIGP7C7S1bFioKjKbilQUVrqo+z98yGTpAl1EretjXqmUn99fV38+KMn3r//JBYttbMzxoIFX8DcXA/6+roZH5RfSyM0qbAsc1C23EaiAyxcCEBQ73IXTfxCVvbeEVKBbt2AQ4dl7yNVAjDpf1EWxJIgIiqSbG1tERsbC0EQxODCnDlz0KFDh0yXU6iqXLlyYh0H+XKPlJQUXLt2LcNWqOrw1VdfYfny5Xj16hVatWqF0qVLi/eZm5tn2GXlzZs3ePjwITZt2oTGjRsDAP7880+FPsnJyfjyyy/Rp08fVKxYEV999RXu3LkDe3t7pWOQSCRo2LAhGjZsiKlTp8LFxQUHDhzAuHHj8vTcUlNTMxRqlTMwMECtWrVw+vRpeHt7i/1Pnz6NkSNHqnT8li1b4s6dOwptgwcPhoeHB3788Ufo6ir5eycPVJn7cuXKQV9fH1euXEGZMmUAAO/evcOjR4/QtGlTlc/FoAdRIVRYri1Ukdexyi/SFZa4pAI3byr/ezyv9T+KMlXrdRSlwJkm3utlnT6nyL4Jzabnf/T1dWFtrfg/+yx3bSmMdTA0Rd1RyrSRPXkAIDUVwOcPhrrrXajrTarqPGT23uncRfajygc7fYDDxwcICtJMTRAiKvRatGiBjx8/Yv78+ejbty927NiB//3vf7h69Wqej21qaopvv/0WEyZMgLW1NcqUKYOFCxciMTERfn5+ahi9ov79+2P8+PHYtGkTtm3blm3/EiVKwMbGBhs3boSTkxNCQ0MxceJEhT6TJ09GbGwsVq5cCTMzMxw9ehRDhgzBkSNHMhzvypUrOH36NNq0aQN7e3tcuXIFr1+/RqVKlQAABw4cgL+/f7ZLXPz9/dG+fXuUKVMG79+/x86dO3H27FkcP34cALB69WocOHBA3EEGAMaNGwcfHx/Url0bdevWxfLly8UdcOTi4+Px5MkT8fbTp09x69Yt8bWpWrWqwjhMTU1hY2Oj0J7dMVSlytybmZnBz88PEyZMgI2NDezt7TF58mTo6ORswQqDHkSkcV5egJAm00OA8r/Ho98UjSKd+SUnxWOLUuCsoMlreryJi8CnTynQ09PP5hG5oOzCXNN1MDSRHqUsu6Bp47wfN21kLzbmc5ZHGqlS4MIFoGHDwvFByEmWRXbvneyej7LlMWkDHnJFPfMor4pzyiBROg4ODggMDMSECRMwa9YstGjRAn/++adClkRezJ8/H6mpqRg4cCDev3+P2rVr4/jx40q3Q80rS0tL9OjRA7/++quY8ZAVHR0dBAcHY/To0ahatSoqVqyIlStXisVPz549i+XLl+PMmTOwsLAAAGzfvh2enp5Yt24dvv32W4XjWVhY4Ny5c1i+fDni4uLg4uKCJUuWiEVcY2Nj8fDhw2zHFRUVhUGDBiE8PByWlpaoXr06jh8/jtatWwOQFS5Nv7Vrnz598Pr1a0ydOhURERGoUaMGjh07plDc9Pr16wrFaeXZJz4+PggMDMx2XOo6BpD93MstWrQI8fHx6Ny5M8zNzfH9998jNjZW5fMAgEQQBCH7bpTf4uLiYGlpidjgYFiYmGh6OEXSh6QkGGdSVIgKt9u3Zdurpjd3jqxGh9zVG0mYNSPja5y+n7bavx8ICFRs09WRlVjQlr/ZC+JznJqaCpMePZEk/YSNG0Pg6Fg2/04WHa35lBtNLWuIjgaGDIGYgQEAEh0krVsNQ+cc/iGd1QVqdLSs2Gf6i/rP59N4Opiy8enoZv/Bze175/ZtWQHU9JRlj6j5l4cgCEhIiEFS0gdYWzvleFvGAsOlPnmWlPQBhob5vGW3lpBKgQcP4uDvb4nY2FjxwrkgnTp1Cnfv3sWYMWMK/Nya0LJlS1SpUgUrV67U9FBIA4KDgyGVSjFgwACxjYVMiUjjVC2+6eRUNIp05ofoaNmXtekN8sn+uqkw1S0sDOPR0dFBaStZxdTIyJwXFssRTVfX/fytf4ogwVuYKBRUffs2CSkpeStKlqUH96EQ8ABk53/4KGfHyW4XnPQFR9OfT15AVlNvvqzqu2Qlt++dzHad8fUpPDvwaJK2FRkmItG7d+9w4MABnD17FiNGjND0cKgQ4fIWItI4VYtv2toUnSKd6qZsaQsAuJfP/DGFrf5JYRqPi60dnryJRPirEHh6tsz7AQtrqnxYGFIECRagLZ7DBnNxAHap8Xh9/wUmbYuDi4s5fvzRU3kx1sIgswvUzArZXLgAbNmseIxUqWzL14OHcvfNfl5f28wKr+ZXtDaz5TFt2gCNm2g+80jTtLHIMBEBkO3e8u7dOyxYsCDHW5qSdmPQg4gKBVWLb2qqSKemr2lzusuNqkVPC0pexpMfc+/q6Ag8/AeRLx/n/WCFOVXe2RnvYYznsEEkLDAJ3fCd5DSWBcQgMlpWAV62K00+BD08KgGQQDHbQwJUrKD6MXJygWprK6vhsXVrxgCDPOAB5KyIpzpeW3kQYvVqKBRb3bUL6NMnfz6Qmf2iZLEfFhkm0mJZbSVLxRuXtxBRoaFqNndBrxiQZ9dPnqI8u74gyK+bdD//1s4uy+X+g8yLnmpCVkVYs5Jfc1/WWbZnfUT4v3k7UGFPlbe1hfXIwZgrOQQHxCESFpgodENkdBIcHIwxd27drHehyeO5MXLkf0stJDqy2zY5+OCmqQ4vyuoCNf1SFx1dwLtr7paXqPO19fIC0te3OH5MVvMkv36haHppVWGl7D1SXFIGiYiKKWZ6EBFloTBlTKia5XLixOcvldPRZP2TnGaqAPk79+VLOQMAol4/y9uBikKqfJs2sPPywneXnmPiptdi83ffVYedXT4XIlT2pk36oNpjMytk4zMo67lNf05AMdMDkF3oGhnKanykTyGSpxbFxarvtVX2PgEAaMEWVGlTsWxsND0a1RSlfb2JiCjPGPQgogKh6eUhuZWTbWILQnbZ6eKX0+naNV3/RNW6LWnl59yXdZRt3/b6TWjeDlREUuVfC6ZYdjheoW3ZstuYO7du/gc+crukIrNAQXn3nJ8zfY2LZs2A8RMyLlsRI4YCZEtz0i3Pye1r6+yc8VhyhS1IlhPpl/8MHw40rKvpUamGS32IiIoNBj2IKN8VpgKW2UkfnMlNhoImZVbwdPx4oFGjgh9PWjn9cjU/597t8571MQnRedt6MbOikYXoYurt2yRMmnQVkZEf4OBgjO++q45ly24jMvIDJk26igULvsi/JS55oc6AUto3n5HhfwEP4L9lK26uinU35IEP+Rjy8tra2gK+vkBgQMb7CmGQTCWZLf/xKAeYmWh2bERERGkw6EFE+aowLQ/JTmbBmaK0Y0xmgQIPD82NKa2cfLmaXXZIXrKHrM3NYWZgiPjkJERFPUPp0pVydoC0CnmqvLm5HlxczAFAzOyYO7cuJk26ChcXc5ibF9I/BdQdUJK/+W7fVr5s5eo1ZMzEEIBvvgVKlcr7a9u9uyzZIyDwv/NICvEvlOw+YMoycQQpEBkJmLkVzBiJiIhUUEj/0iEibZHZEoUHDzSfeZBWVsGZQn5NqyA3y0gKs8zmPq/ZQxKJBGVK2OJe5Ku8Bz0A9afKq3E9mL6+Ln780fPzLi2yjA47O2MsWPAFzM31Cu92tYDyN0Be58bYCEqXrZQooby/ubmsIKg6dOsu2zb2wQPZbQ+PvL2++bVuUJVda4yNlGzFqwt8zqIiIiIqLBj0IKJ8pSzzAAAWLgQSEwvPMpfs6kcUpeXfRSlIo4r0c6+u7KEytna4F/kK4S+fALXUO+Y8ye02qVlcAOvr62bYllYjS1qio4Hn/wIuZXOW8pM+2qXK3CibD/nj0wc8hg+XvYHWr1e8T5IPaVK2tqpFfLMLaKSfC18foFz5vAdAMlu2kvYDlvbcaQmpwN9/Aw3r5/78REREasagBxHlq/SZB3ICCtcyl6JWuyM7RSlIk1PqKnBa1tERuAtEvHys3gHmRXYXnJldCOc2UJL+3PlZbVgcYwog0c/5GFW5GM9wrjTz4eWV8UL9/+ydeXwU9f3/n7shJBFCICQkBCGEGwWPqCCCCIpAPbg8Wy0J4vGt0BYoiALeigIqqFjRH0LAelUrhz0QpaVWRVBRqeUQkEOBBJZwE5Yc+/tjMpvZ2ZnZmd2ZPcLn+XjwCJnjM5/5zGcm837N+3C5YdZM6NhJ+n3s2PjIzxLqemqNxcLafCHhXn+53U8/Na5aoz52AD547TXo2gkyE/ThKRAIBIJ6hxA9BAKLJGoVklgycCCknSV5dyiJZRUU9XWsb2EhkWI0z2N9D9glULVvJe1QVvqjjb2LEKMSuOvXaxvCVsQAPewQTYywo49mywPrHevqq7U9E055636PBzcpM2OlWwJXtb28rZmbVc97AwKTrRodG6S8Hvv3Qwfjw8UFsX6YCQQCgSAqCNFDILBAIlUhiTe6dokfTwq96xgP9k48YDTP4+EesEug6tA6D4CyAzvt72S46FUsSU3RN4TNigF62CFIhGLzJmt91DJGzVZz0RuPDz8MPo7W/rF2kzJzPbXGQr39B8th6TLzoUBGgofyBgt1bFcStGhR1268igpOC30CgUAgiBvcse6AQJAo6OUR8Hhi269EQTZUk2qfOrHypAh1HbOypJyF8fZ+Hi2Mxkdr3UsvwQ8xiA4ZOBDmz4fpT0o/w7FV5LK1B8p/Clzh8UgVPuy8uc22Kd8o7tr8G7LBWXFK3xCWjVAlVsqgGhnZdrByJcycFbxcr48rV8Lo0TBtqvRz5Uppud7YqG9WrfFwuQmuzAIMHRJ/N7uZ66keCzXuJFiyNFjI0pt/et4bo+8MvsHUx3a5kRLDIgkeo0dDZnP96xgP6Al94g+6QCAQ1EuEp4dAYBK78gicycSDJ4XedfzsM+jdO24LcETtmEbz3OcLXlfjg4l/kFIhxMLjI5JxbVv7NfrEqaOcOHGERo0ynPn6a7VNvYolel4OkZZ2NetBEQ6ycakWHPT6aOR1ApCbK+XgOOUNfogoJ796PEaOhEWLgvN5XD8k8nO0G7PXc+BAOH4cSkoISsw6dAgsWRK4vZFnjd4c0HsoqucoSP/PzYW0BrDv58Dr7oT3UCRE6h0lEAgEgoRCiB4CgUm2bQ9elsiJLmNFuIaqxwM/7oJ2+ZG9k+pVk5n/GixYYJ+HcyzCQOw4Zqh8GVpjF29Jac2SftZZNEtrxKGKE+zfv5OC9Fb2h3mEGzqivlFCGcKRKIqRiiZG6HkQTJyoXcFEzxjVCtVQlpHVEpbmzw8cj8aNwzvHWKiXZq6nxyMJOepqM7NmQrPMuvGSMRKywpkDWnPU54MTh6GsDKjB7wEC8SUqOCn0CQQCgSDuEKKHQGACjwcWlQQvHzkyPt7fEg2rNoRsz1T6IFnHmDfbpl41GQi/9Kkau0qqOnHMUOMUKl/GmDGBx5FxylvGafIzszi05wRlZTsoOOay/+uvnV+UQxnCkbi+OOWGpWVcupKCy8DKEzMtVWN7d6ABr1XRRktYmj9fOpe9e8M/x1jmfVBeT60bV2tuyYlZwxEx7JwDOTlIEdQqD5R4ERWcFPoEAoFAEHcI0UMgMIGWyz9Ax47R70uiY9UbwYwxb7VN+d3+ww/h7XcC19kRshSLUCgzxzQ7Tka2z8CB0LZACmlR3xJ2e8tEg7bZLfh2zy72/bQV+vex/+uv3V+UnUyy6UTbWsbl3aONy+327w+rV9dtHypUw4p3yMCB5s8xGglezaAnvISaW+GIGHbNgczmUj9ffjl+RYV4iLcUCAQCQVRIuESmL730Em3btiU1NZWePXuybt06w+3fffddunTpQmpqKt27d+fvf/97wHqfz8dDDz1Ey5YtSUtLY8CAAWzdGpiVr23btrhcroB/Tz/9dMA2GzZs4PLLLyc1NZXWrVszU12bU5DQyC7/SmId2uJErkWnCScZrJExH26bIFX/fOed4OV2XNdYzBetY7pdkJIq/d/qOBkldO3UUcrhkaTxFyTREvwWtMwFoHTPNvOJMq1gtc1EvLFDIWedfXK69POqAXXrtISF1aulEA15++uHGCf21EtcquUdYmVc7UjwavV6qrc3SrhpZm7ZnZnZyvmor3s8KqFneuZqgUAgOENIKE+Pd955hwkTJjBv3jx69uzJnDlzGDRoEFu2bKGFXB5Nweeff84vf/lLnnrqKa677jrefPNNhg0bxvr16+nWrRsAM2fO5IUXXmDRokUUFBTw4IMPMmjQIDZu3Ehqaqq/rccee4y77rrL/3t6err//0ePHmXgwIEMGDCAefPm8d///pc77riDpk2bcvfddzs4IgI1ToVe21Ui0y7ioWxoOITjAREqx0Q4bfrtCNVyu65rLOaLVthOjQ8mTZSW5+ba630ifyT97DPJw8OudqNNh7Nry9aW/igtcOLrr9k2E6mEptWHrTIkI6sZ5LWu+11LWDjlDczZYRSKoOVNYjWRpxaReum8/35dklEz11Pr+ufmGodHGc0tu/8ghjM/nfRMUhLPpXEFAoFAEHMSSvR47rnnuOuuuxg1ahQA8+bN429/+xsLFizg/vvvD9r++eefZ/DgwUyaNAmAxx9/nI8++oi5c+cyb948fD4fc+bMYdq0aQwdOhSAxYsXk5OTw9KlS7n11lv9baWnp5Obm6vZrzfeeIPTp0+zYMECGjZsyLnnnsu3337Lc889J0SPKPLxKpj/inNCQLx4wsYiX4Rd5OVJae2UtncoD4hQAkIoUUSJ/F585Kh2uJJebsVwiMV80Qo9kefHzFnmx8ksWVlSDo8FC+xtN5q0byV19IBnd91Cp8I8jNqMl1AKM1gxfuWbbvs2KJGrp/hg7O/MhWjIhLqhtKqJWEnkqUUkeR+WvA8lC+t+D3U99a7/3XcT9NTUKl+rbtNuAS0e56c8t7Ztq6vME+9ioUAgEAhiQsKEt5w+fZqvv/6aAQPq3GLdbjcDBgxgzZo1mvusWbMmYHuAQYMG+bffsWMHpaWlAdtkZGTQs2fPoDaffvppmjdvzoUXXsisWbOoqqoKOE7fvn1p2LBhwHG2bNnCoUOHNPvm9Xo5evRowD9B+Hg88Mo86yEOVokHT9hQ4R5miYYXvfoY69cHrndhzoaQvaQffSTYS1q2S+RQCz2vipUrYfRomDoNnpkVUFPAv586t2KkxGK+nKoI9mCprgHvKXPjZBWz4x+vyGVr9x/6CZ9PQwmLFnaEUkQDo3ALNfJNN20qLFyoOD+LIRoyoW4o5Xqz7YZ6EIYTouHxSAKPGqPrqXf9571c+4vL+DzUxzd7jcwSzflp5o+Tcm6VLLT3XAUCgUBQ70gYTw+Px0N1dTU5OTkBy3Nycti8ebPmPqWlpZrbl5aW+tfLy/S2Afjd735HYWEhmZmZfP755zzwwAPs27eP5557zt9OQUFBUBvyumbNmgX17amnnuLRRx8NWl7h9ZKclKR5PgJ9ftwFlXhRjlx1DezYDY3SdXdLTBpIRq3y9TPJBU2bQ4XXXBMfr6oViZCUz3v+DwZcZW831ce47dfwxuvB/e7azVy/G6VD+w5e0lKCt7/8Cqmd0lLJGzxLNRaeg/DC3LpjV/vqFN+a2n6Mvls6htkxjDaeg4qP3M31t2uWpT8/OnQyHqdwCTX+VqjwRvcCtMjIAMBbWcGBAz+RkZEd1eP7yWpG0JVzJUHzpuCtiE2ftNj1I/gqA5fVVMPuHZDeqG7ZQQ/MfYHAmSjhpRpqTtft060r/H4s4ILOnaB5lvlzPuipuzGaq4SAKy6X2pYnprrdVR/DvFfwP6X+757AfCMy6Y0gvUNt5030S2uMQDqG3vXUuv5KXEkwblzg+Oidu9lrZAWT89Pn8+H1VnD69Cm83gpcLrW8HAIz18RgbgHB52o0RwRh442n51KcU10Np08n7nj169ePCy64gDlz5uhu07ZtW8aNG8e4ceNMtfnII4+wdOlSvv32WwCKi4s5fPgwS5cujbi/TqPuuyAxSBjRI5ZMmDDB///zzjuPhg0bcs899/DUU0+RkpISVpsPPPBAQLtHjx6ldevWpKWkkBZmm2cy7fIhGXBRN3ZJbihoA2n1aDhlj2UX+AUe+ct66zxzbXg8UhiQso3XXoVePezNdac+xtt/CvwdAB8cPmi+74Du/dE6T7+dQx6NYwOT74OMjPhP3G8lh0vrPPjd2OBwIHlsjMYpEuxsN5rPwLSUFHIbZ1B6/AiHD5fSokWbqB07gLzWUsiHOpRCzn0RL+S3A1dycNhImwJISatb5jmE9l0nkeJuKO3z7/+EH4ZhJoQjr7X2GHo88Mr8wD6++hr06BXaiyJU7gitMQIoHqV/PdXXX40PyGpRt7/RuWsd3+WG9IzAa2Tl3EzOT5/PR1WVJFympKRZEz3MXpMQcytgPiZSnpwEJMVoPgn8VFdDw4ZaQmj8UFxczKJFwR5qW7du5f333yc5OdnR4z///PMB3pZmhJZo4HK5WLJkCcOGDfMvmzhxIr/97W8dP7YQV+wlYUSPrKwskpKSKCsrC1heVlamm2sjNzfXcHv5Z1lZGS0V8bFlZWVccMEFun3p2bMnVVVV7Ny5k86dO+seR3kMNSkpKWELJoJgsrIkb4XXXo2PRKNOoM7lAZIBPHOWVE3DLNEop6p1jBqf9XwedqGX96NLl/ifI+HkcIkkn8iZmA+wTfNsSo8fobT0Rzp16lG3ItqDES+Jg4wwm+dCK1eHjKt2Hwg/T0SkOSaMwjUiTTSrHiOXG4qL4PK+UtiG3nySr//mzTBzJrp5PLTO/aWXoKAtdOwkLRs2NLh6zcRJ+n02c25Oz89Q10S+H9NS9eeWcj7GYx4SgSCOGTx4MAsXLgxYlp2dTVIUPNAzar0uE4HGjRvTuHHjWHdDYJGEyenRsGFDLrroIlatWuVfVlNTw6pVq+jVq5fmPr169QrYHuCjjz7yb19QUEBubm7ANkePHmXt2rW6bQJ8++23uN1uf8WYXr168cknn1BZWafifvTRR3Tu3FkztEXgDAOukkKupz8Zv9XxIkFPSPCestZONMqp6h2juDi6uR/k0HBI3LwT4eZwCSefiDLvyR13wIKFZ0ZovJzXo/SnbXULlTkDRo+Wfo8G8ZA4KBRm8lxo5dQoHiXt8/IfpX0iyRMRaY4JrTK3RolOrebJUI7Ra69Bo8bm5lNWlpRNeexY7XwkHg98+mnwucuixpw5Uvv+yjWuwG20+mzl3Jycn0bXRHk/TpwE/fsHjs+oUcHzMVHy5AgEcUJKSgq5ubkB/5KSkujXr19A2Mr+/fu5/vrrSUtLo6CggDfeeCOorcOHD3PnnXeSnZ1NkyZNuPLKK/nuu+90j11cXOz3piguLubf//43zz//PC6XC5fLxY4dO+jQoQPPPPNMwH7ffvstLpeLbdu2abQqMX/+fLp27UpqaipdunThj3/8o3/d6dOnGTt2LC1btiQ1NZX8/HyeeuopQArZARg+fDgul8v/+yOPPBLwcVzu+/Tp08nJyaFp06Y89thjVFVVMWnSJDIzMzn77LODBKXJkyfTqVMnzjrrLNq1a8eDDz7otyVLSkp49NFH+e677/xjUFJSYmpsv/vuO/r37096ejpNmjThoosu4quvvtIdnzOFhPH0ACnMpKioiIsvvpgePXowZ84cTpw44a/mMnLkSFq1auWfrL///e+54oorePbZZ7n22mt5++23+eqrr3j11VcByWVp3LhxPPHEE3Ts2NFfsjYvL89/461Zs4a1a9f6J8+aNWsYP348t99+u1/Q+NWvfsWjjz7K6NGjmTx5Mt9//z3PP/88s2fPjv4gneFEqzpeLLBSpcSIaJRT1TvGwIHQt2/oD4WRfmD3eGD5B7BsaWBIyPz58f0RXQu7rnso1B4lPiS7adnS+u8RXtBS8sgr3Vv70lTfvxDb4cFi5mGr5xkg5wKIpCRspOVkrVZmCcczRB4jPc8Mq+5aSm8MLXw18M9Vgb+r0epzOOcG9ntCZWVBUVFgJZaRI6V16vFbvRpmzZRKG+s90COdIwKBQJPi4mL27t3Lv/71L5KTk/nd737H/v37A7a56aabSEtL4x//+AcZGRm88sorXHXVVfzwww9kZmYatv/888/zww8/0K1bNx577DFA8ji54447WLhwIRMnTvRvu3DhQvr27UuHDh0023rjjTd46KGHmDt3LhdeeCHffPMNd911F40aNaKoqIgXXniB5cuX8+c//5k2bdrw008/8dNPPwHw5Zdf0qJFCxYuXMjgwYMNPV7++c9/cvbZZ/PJJ5/w2WefMXr0aD7//HP69u3L2rVreeedd7jnnnu4+uqrOfvsswGpMmhJSQl5eXn897//5a677iI9PZ377ruPW265he+//54VK1bw8ccfA3XeMKHG9rbbbuPCCy/k5ZdfJikpiW+//TYgPMnlcrFw4UKKi4sNr0N9I6FEj1tuuYUDBw7w0EMPUVpaygUXXMCKFSv8SUN3796N2133leCyyy7jzTffZNq0aUyZMoWOHTuydOlSunXr5t/mvvvu48SJE9x9990cPnyYPn36sGLFClJTUwFJ9Xz77bd55JFH8Hq9FBQUMH78+IB8HBkZGaxcuZIxY8Zw0UUXkZWVxUMPPSTK1QpsfSe0U6yIhhe93jFC2UpW8lfo7T93bmAYjRwSMn++9JFSDyeiGSJtU33d3S4YMtSevinR8iiBxCqJHC4dasvW7i/bIS0I1wiMFpFMKjtyHFg5vtENrzZyjYQHjwc2b5L+36VreOVk1f02+yD0eODokfAMaCPPjA+Ww6g79PdVjp1aOAkXrT6HIw44kStj5cq6uQDSz0WL4Mhh7fvxlNf4gR5JyWGB4Azkr3/9a0DYxi9+8QvefffdgG1++OEH/vGPf7Bu3TouueQSAF577TW6du3q3+bTTz9l3bp17N+/3x/K/8wzz7B06VLee++9kPZRRkYGDRs25KyzzgpIE1BcXMxDDz3EunXr6NGjB5WVlbz55ptB3h9KHn74YZ599llGjBgBSF7+Gzdu5JVXXqGoqIjdu3fTsWNH+vTpg8vlIj8/379vdraU2Lxp06a66QpkMjMzeeGFF3C73XTu3JmZM2dy8uRJpkyZAki5HJ9++mk+/fRTbr31VgCmTZvm379t27ZMnDiRt99+m/vuu4+0tDQaN25MgwYNAo5tZmx3797NpEmT6FJbkrBjx8AY+M6dOydUOJFdJJToATB27FjGjh2ruW716tVBy2666SZuuukm3fZcLhePPfaYX0lUU1hYyBdffBGyX+eddx7/+c9/Qm4nOHOI1HjXwk6xIhpeMepjyDZHappUWlVtM4WTv0KJ3y7QWBcqb4kT18uuNuXrLnuvOOGBoeVRImN3zpd4o70senh2SQvi+QtxJMamHR4sescPR4hRGrkuNxSN1M83MXcudXe2Swr/sPJADPCScMHwYXD9EPMqrLyfPC/MGNChPDOWLa/rQyi0hDgzyOEiRn22Kg4YzaPmBqWljNATdXw10jipM0KZvR8TIU+OQBAn9O/fn5dfftn/e6NGwdWeNm3aRIMGDbjooov8y7p06ULTpk39v3/33XccP36c5qrnQUVFBdu3bw+7f3l5eVx77bUsWLCAHj168MEHH+D1enXtvBMnTrB9+3ZGjx7NXXfd5V9eVVXlN/qLi4u5+uqr6dy5M4MHD+a6665jYBgvVueee27Ah/ecnJyAj+xJSUk0b948wCPmnXfe4YUXXmD79u0cP36cqqoqmjRpYngcM2M7YcIE7rzzTl5//XUGDBjATTfdRPv27f3b6lU9re8knOghECQCkRrvRiRqCI9SAJBRCwGRJlnV81YA45AQu66X0u4D++eAHK5jV3tKZLtHfY0geglnY0VBrbeg58heampqcMfrF+JYJO80c/wTx6FkkTUhRqutRYulZJ9qJTRA8ED6v/K8rSY9xScph0uXGfdVaz8f8Jt74ZJLQnuVhPLM0Bt7LQEpL4/gVNAhkOetGaPfijhgNI/CFT2MRJ2aahg+XBI/wrkfE/WPpkAQZRo1aqQbJmKF48eP07JlS82P0UpxJBzuvPNOfv3rXzN79mwWLlzILbfcwllnnaXbD4D/9//+Hz179gxYJ4eqFBYWsmPHDv7xj3/w8ccfc/PNNzNgwADee+89S/1SV7dxuVyay2pqpOfcmjVruO2223j00UcZNGgQGRkZvP322zz77LOGxzEzto888gi/+tWv+Nvf/sY//vEPHn74Yd5++22GDx9u6ZzqG0L0EAgcwI4KKfWpioZW5RkINtwjzV+h560QKhTIjuul9uoYOszeKjnRqLqj9ChZvqz+VkJSc3ZWFkkuN1XVlZSX7yUr6+z4/EIcqWgRqQeL3vFLFlkXYsyey969aBr6ZnNObN4Eu3ZrG9Sh+qppiPvg5ZchKclY2DHjmaE19mpPmuIiaN9BqlhiBZdbynnRLNOeUCQlTnhCGVX7cSdJHjHXD4mv+1EgOAPp0qULVVVVfP311/7wli1btnD48GH/NoWFhZSWltKgQQN/8k+rNGzYkOrq4PLd11xzDY0aNeLll19mxYoVfPLJJ7pt5OTkkJeXx48//shtt92mu12TJk245ZZbuOWWW7jxxhsZPHgw5eXlZGZmkpycrNmPSPn888/Jz89n6tSp/mW7du0K2EZrDMyObadOnejUqRPjx4/nl7/8JQsXLhSiR6w7IBDURyI13p0ItYgVcki7ngeG0nC3mrdELQxp5b8YOgyGXG/8jhzp9dLyFFm+zN4SvdFKaJqVBXeMksbsTLEvGiQl0SqjGbsPH2T//p2S6AHx94U42sk7zRxfy1A1I0iYPRc9DwczOSeCPEQ0MOqrriHuC52IVG+sQD/URMv7xZ/t36KXh68GVn4EH34o7WdX3g0wnkc+C300alNGPU7xdD8KBGcgchjIPffcw8svv0yDBg0YN24caWlp/m0GDBhAr169GDZsGDNnzqRTp07s3buXv/3tbwwfPpyLL7445HHatm3L2rVr2blzJ40bNyYzMxO3201SUhLFxcU88MADdOzY0bDaJsCjjz7K7373OzIyMhg8eDBer5evvvqKQ4cOMWHCBJ577jlatmzJhRdeiNvt5t133yU3N9fvNdG2bVtWrVpF7969SUlJsa0qZ8eOHdm9ezdvv/02l1xyCX/7299Y4q+6VTcGO3bs4Ntvv+Xss88mPT095Niee+65TJo0iRtvvJGCggJ+/vlnvvzyS2644QZ/u126dOGpp54640SQhClZKxAkEvL7WzglUvVCLaJROlQu8WrXseQqg68t0N9GbbjLlR5DlR5WlldVVoBU7v/aa5IBD8bnFcn1An0vjGHDA9scWSRtG874qvvodkmFDZyyAbKy4r9yqp20aS4lLNu3N/x4Y8eRJ4FWKVOzmCk3a+X4RUXBZUYBtm613pZevomxYwkoveoyoYaaETzk4+qJJ3Iftc5PTkSqh9b5FRfBpIlw32TtsTf0DtE4F5dbu2/SSvhwRd1+oUrsWiWSeWSmzWeftbdtgUBgGwsXLiQvL48rrriCESNGcPfdd9OitvQ7SGEcf//73+nbty+jRo2iU6dO3HrrrezatctffCIUEydOJCkpiXPOOYfs7Gx2797tXzd69GhOnz7tr95pxJ133sn8+fNZuHAh3bt354orrqCkpISCggJAqqAyc+ZMLr74Yi655BJ27tzJ3//+d39+jmeffZaPPvqI1q1bc+GFF1oZJkOGDBnC+PHjGTt2LBdccAGff/45Dz74YMA2N9xwA4MHD6Z///5kZ2fz1ltvhRzbpKQkDh48yMiRI+nUqRM333wzv/jFL3j00Uf97W7ZsoUjR47Ydi6JgsvnC1eWF9jJ0aNHycjI4Mjbb9NEJzZNYEyF10tabSbjeMHjsf61fMMGyZBXM/1J40T1kWK3d4nHI4kReh4eEFjK1gzyNdZqO8ktvR+rx9nMeSkTrHpPWfduMOoPSHNg61YpZ2Ok4/v+ElhUUj+8gLSI1X088ulnef3zf3PLiKncVvxE1I9vCnmipqUal+qMRj+UD7Yl7ys8EmpxJ2nfkIDXW0FKSpp2W0bHlJOvdelivO2GDTBtqv56ZR/NPIBefx3e/bP2/jrnGNBv5QNAGbYyfETwtqNHG4fFqBOpyiFY27ZKOVFqqmu38aEplDw53dE/JD6fjxMnDuP1VpCZ2RKXyxV6J0FCEnAfCwyprobNm4/ywAMZHDlyJGSySif4+OOP+d///sfvf//7qB/bbv7zn/9w1VVX8dNPP5kWUQRnFm+//TbV1dUBYU0ivEUgcJBwvONT0+wNizCDE4lX9ZKK3jkaup4Tnrhg1LZWfgut83rpJUg7C7rW2k1aoojaJgiVX8VMWM60acHj27ZAu4qNHh5PneChbKc+l5ONFu3ypBusLF49PbSqpthpvEZShra9RuI7ZdiIUdtmH5JZWdCnT+jtIHTST5cbhg01VznF4wG9hHZmwnjkddOmBYet+IARIwK31QrxkHEnSXk61IKX7JZ1eV+pP0cOw8yZ2uddnzMSCwSCeo3X6+XAgQM88sgj3HTTTULwEFhCiB4CQRzht2sUy6KRSNKJJJl6OSh69w79YTSU7WU2v4XWedX4JHvA7ZI882XvC3mdWkQw6wFjlPdSb3wnTTTnsSGPyZGjziczPVORy9aW7d8R455oYEepWSMiKYMLxvk5tNq+4vLI+6yF8uExdmxgiIvsXdGhozW11SjkxGw+Fb02Fi2Cvn0DhaHCQsl7RPYOWbw4MG9Gx076x5EFJI9HOxdJUVFoEUogEAjilLfeeovRo0dzwQUXsHjx4lh3R5BgCNFDIIgTtCqcuF0wcxZ06ujssZ1Ikmk1KSmYFxjMtq1XzQWkZUrBQ0YpIlj1gNH7aK3XD3W7Sg8UrTFxoe0FlJIqefQLGyZ82uflAnDg4O4QWzqMlkEaadWWUMeLVFDRS2wJ2m136wp5rSPrtxq1uFJUBPdNgmPHIT09dEiMHnrJTK3kU9GrvOKrfdisX68tOnXvLokiVmMk5esRkNfEBY0bRy5wCQQCQYwoLi6muLg41t0QJChC9BAI4gQ9rwTvKeePHY5AYQYrVT+tCgxm2laflxpZXNETe+zygNGqKqPVruyBItsh6jHxIYkeSe6669Svn3mPESdJ9I/HBbVusgePllFVVUmDBsnR74SeQepEiVAZuwQVrRtywwbttktL7RU9tISbktocI/I4hjsp1YKOldAYmQqdh7jLDakpxqKTnpIa6oYrLASXS1FNpfaBWlNDUHLTgrZSH6Nx8yb6g0IgEAgECYkQPQSCOCFaJUn1sCJQWMFsyH44AoOZtuXz2rwZZs0KHt+RRbB4kbbYY+c1UY5vSmqdUKFGKfZojYkPmDgRMjIkO+XJJ2Kf46M+lFjOadqUlKQGeKur8Hh+Ije3XXQ7EMrjIpJSs0bYKaiob0i9tnNzw++vFkYhKHaEAkX6cNTzFikqkm5iq6KTnjimFBT0xCw1NdUwcVJ0PD+El4lAIBAIYoQoWSsQxAmRlk01KjdrthSt3WVKrZTAlQUGJVoCQzhldeUciFrjO2J4YIncwsK69iO9Jlr96N5dCldStqtGFnv0xqRLF2n9E4/rC0XRIpYllu3E7XbTumlzAMrKYpDXw8jjApwpEQr2lMG12nZzi6WRQt3wsqigh3IcwyWSh6N6HFxuGDVKSmKq1Xcj0UlPHHv/fanyy7Sp0s9t27TbxRXUZFBb6rG2o5a5Xr8T7UEhEAgEgoREeHoIBHFEuB8Ujb60x+orvNXjmgmx+XgVzH8l/HPRG1/5A7Ven53wgFF6oMycqV2tR29MIDjhrXrfaOFEEtxYkZ+VzbaDZZTu2cb551/lyDEqK6s5dqyKzMy6srzl5V7SW7QkOZTHRTjloMwwcKAU4rBxE5zT1ThZZjhtq28gb4W0LlSog1nPADNVT6JxUxidj9HDx4oXj544VlJCQNjK4sVS4la5jK0yz4oyVCeUl4nyGuCC4uLAijNmcTIvjUAgEAgEIRCih0AQZ1i1a4xyYYD9pWgj7ZPRcY0EBo8HXplX950y3HMxCpE36rMT4yV7oJw8qS/2KMURH1KiU71ywG6X85V+1MQ6LMtO2ubmwpbv2ffzNkfar6ysZsaM79i16xjTp/cgOzuNAwcqmDJlHfn56Uz+zRiS5zkQwhIKp8MOtG6gUMe0mmBV+fDYtjXY2Hd6HLUSqXboECiA6D1IrCiraakEpTPWEy86dKyrBKNsVz5WakpdaIuMUiBSXwN8Uq4UFzDcovDhZF4agUBgC6tXr6a4uJidO3ea3mfBggVcdtlldOnSxbmOCQQ2IMJbBIIEx+hLu9G6WPUpFHpe5Hv3gjpq385zidVYQV3kghxio7Y316+X8pHMnFnrub49OOzF7YJZz0Q/RN7uECAtqisr8ZaXByzzlpdTXVlp30GA9nm1ZWv3bbe1XZljx6rYtesYZWWS0LFx4yGmTFlHWVkFu3Yd41iPK5wJYTEiFmEHB00cM1S4jxbyw2P4iOiOo14iVTnUZOXK0G2YCZ9ZuRL+MJEgwaO4SD9ERqtdeVnHTsahTXq5UkoWWZ8fToZRCQQCx3jppZdo27Ytqamp9OzZk3Xr1gWsX7t2La+88kpYbR87doxx48aRn59PWloal112GV9++aXp9Xq88cYbtG7dmmbNmjFhwoSAdTt37qRTp04cPXo0rD4LEhfh6SEQxBA7EtmH+tIei6/wWn1yu6QEnhG1qVoWaZtB7cfQY8GKB8riRdKH5MWL67xDRhbBqYq6XCTRxKkQIJAEj+9mzODYrl30mD6dtOxsKg4cYN2UKaTn53P+5MkkJdtTaaVDa+li7z+wy5b21GRmpjB9eg+/0HH//WsByMlJY/r0HrUhLynRvYBOhx1oPeT27Qt9zEg9A+QbSs5H4WS1EKcTqYJ0HgElaBVc3hcaNTYfIqO8JoWFMPEPgCu4rO82HY8nudSu1fNx8kEhEAhs55133mHChAnMmzePnj17MmfOHAYNGsSWLVto0aIFAEOHDuW3v/0ts2fPttz+nXfeyffff8/rr79OXl4ef/rTnxgwYAAbN26kVatWIddr4fF4uPPOOykpKaFdu3Zce+21XHnllVx33XUA3HvvvTz99NM0adIk/IERJCTC00MgiBErV0ofAadOM/8xUAujL+3R+Apvpk8gGeuTJkZ2nvf8nz1tauXli9VYhULPA6VjxzrvkJEjYVFJ5HMpEuxOgitTdewYx3btoqKsjHVTpnBo40bWTZlCRVkZx3btourYMduOJZetPXBwt21tqsnOTmP8+PMClo0ffx7Z2WmOHdMQs4k0w0lmKT/k1B4PLVuGPqYdngF6x7ebaCRS3bsXTcFDFiAGDoSpU+AX10g/9bxblGNyxx3Sv5kzJVey9evrtvN4YNEi7TYiCUtx6kEhEAhs57nnnuOuu+5i1KhRnHPOOcybN4+zzjqLBQsW+Le56qqrKCsr4/vvv7fUdkVFBX/5y1+YOXMmffv2pUOHDjzyyCN06NCBl19+OeR6PX788UcyMjK45ZZbuOSSS+jfvz+bNm0C4K233iI5OZkR4eQlEiQ8wtNDIIgB4ea80MPoA1qsPq4NHAhtC6SPiPKreqTnOeAq6NwxsNyr1TaNEqzG44dIIw8UuX/TpsW+bK1TpGRm0mP6dL/Qsfb++wFIy8mhx/TppGRm2nIcjwdOHpREj8MnPHi9FaSk2C9EHDhQwezZGwKWzZ69wZ/jI+qYSaQZTs4Po5wczU0m7wx1Qxq5ylnNCWIF9XGjkUh1u47Xhdz2nDnwz1XSsn/8HS7rDddcEzg2Wjk6ZNTjo+e94ooTNVggEDjK6dOn+frrr3nggQf8y9xuNwMGDGDNmjX+ZSkpKQwcOJDly5fTrVs3AEpKShg1ahQ+n1a6dYmqqiqqq6tJTQ10101LS+PTTz8NuV6Pjh07cvLkSb755hvy8/P58ssvueOOOzh06BAPPvgg//rXvyyNg6D+IDw9BIIY4ET+CKMPaLH6uHaqIvjbZKTneaoi/LEzU1413j5EhvJAiWUukmiRlp3NeePHByw7b/x40rKzbWlf/vg9c3o6yUhVVfbv32lL20rKy73+0JacnDSefronOTlp/hwf5eVe249pCqNyuOHm/LCrBK/eDRnKiyOcnCBmWLlS8o6QPSXk4yrPZ9Qoe3NXeDxSHg0t7r0XDpXXCR4yn38WPDZGYTgQOD5a3isuNzwzK/wcKXaUvnWSeO+fQBBFPB4P1dXV5NR6QMrk5ORQWloasGzo0KEsX77c/3tGRgadO3c2bD89PZ1evXrx+OOPs3fvXqqrq/nTn/7EmjVr2LdvX8j1ejRr1oxFixYxcuRIevTowciRIxk0aBATJ05k7Nix7NixgwsvvJBu3brx3nvvhTEygkRFeHoIBCGwI++Gmljnj4gWkZ6n1thH0maillc1+uAdL3PJiftEpuLAATao4oU3zJ7tz/ERCUohzIWLdLIoZw9bt+6gdeuuEbWtJj29Afn56QB+zw45x0d+fjrp6TH8k6yXVCbcnB9mcnKEWxbJjBeHE9VCgvJq+KTflSWeZJHm8r72uYwZeV0UFsKHH+rvqxwbrTFRs3Vrncik5Y0TbjljpysERUq8908giGOuueYaRo0ahcfjISsri+HDhzN8+PCQ+73++uvccccdtGrViqSkJAoLC/nlL3/J119/bWq9Hurj//vf/2bDhg28+OKLdOjQgbfeeovc3Fx69OhB3759/flJBPUb4ekhEBhgV94NNXbkj0iEj1KRnKfW2HsOSu//RcXhtSkLBEr0BIJ4G1+9D97xkIvEqfsEpCotcmhLWk4OPZ9+mrScHH+OD3VVF6uohbBGSC8/27bYX7Y2OTmJyZPPZ8aMS/2hLNnZacyYcSmTJ59PcnKS7ceMGLM5P9RYzclh5YbTE2I2b65rw4lqIZs3Eey75pOOq8ZOl7G8POqKdSsPXavYNmtmvL9SpFKOiRaLF9ddA7PeOKGwo0KQkw/kWFQwUh8/nv7YCARAVlYWSUlJlJWVBSwvKysjNzc3YNmOHTto2rQpTZs2tXSM9u3b8+9//5vjx4/z008/sW7dOiorK2nXrp2p9Wbwer3ce++9vPLKK2zbto2qqiquuOIKOnfuTKdOnVi7dq2lPgsSF+HpIRDoYHfeDTWR5I8wyksRb4Rznlpj/9JLUOWTlFq3S6pe0rGjtbFTfryUq55o2UGJNL4Q21wkTt8nDdLTSc/PB/B7dsg5PtLz82mQnh5R+2pPmTSkl7nTJ+0XPUASPjIzA41OqWpLnGIm54ceZiem1a/smh4LLikZp7qNWN4Ydrk+ZWVBcbFUBleJLD61bAnz9BP7BYhU8ph89hm8Nj94W7UXT7jeOEoirRBkZn5EMt5OVzAyQniYCOKUhg0bctFFF7Fq1SqGDRsGQE1NDatWrWLs2LEB2y5fvpxrrrmGBg3CMysbNWpEo0aNOHToEB9++CEzZ860tN6IJ554gsGDB1NYWMg333xDVVWVf11lZSXV1Rp5mAT1EiF6CAQ6RCMUIpz3SaeNTCewep6bNgePfY0vMCHq4sXSx8dwzrmmJvCnkkQcX7DHNgkHp++TpORkzp88mapjx/xJS9Oys7l0xgwapKdHXK5WLYSl1ooeRw7/GHHf6w1G4kEoYzPUxAwn4ahaiHG5wefTbyPURDRrMHfpiuRxoZjwLrdU6lWJE4Zs48aBx1YnFB37W1WS0tpttUSqrCzo3Rtee40gzxU7kq6qiSTUyMz8iHS8nQiFMoOTyXYFAhuYMGECRUVFXHzxxfTo0YM5c+Zw4sQJRo0aFbDd8uXLefDBB/2/L1myhAceeIDNWl5wCj788EN8Ph+dO3dm27ZtTJo0iS5duvjbD7U+FBs3buSdd97hm2++AaBLly643W5ee+01cnNz2bx5M5dccomVIREkMKZEj0yL2fFdLhfr168nv/brnECQiMRLrgQ1iZqXwiwrV9aGzYcgnHP2v2PW/u4j+B2zvo9vpKjtw2jcJ0nJySSp/g7ZVbUFAm3670rz+PWLUHZgp23t1wuU4oE8CbZvkxJsRmLch/uVXXnRjhyWyq5abQOsGcxZWTB2rLHXixOGrNymWqAoLKz7v1qYAmMPF/lclDlKnKrMEom3UKj5Ycd4R9K/SIilh4lAYIJbbrmFAwcO8NBDD1FaWsoFF1zAihUrApKb7tixgy1btjB48GD/siNHjrBly5aQ7R85coQHHniAn3/+mczMTG644QaefPJJkms/ZoRab4TP5+Puu+/mueeeo1GjRoBU+aWkpIQxY8bg9XqZO3curVq1sjosggTFlOhx+PBh5syZQ0ZGRshtfT4f9957r3AXEiQ8ZkMhok28ijF2oBYlZNwu6UOuknDOWU/Q2LwZ+vSRfg93fJ1M5Bkv6IX9xON9YhW/TZ8uvcwdKP8pth2KV5QigZJwjftIvrLLF83jMW5D7+YMx2CWxYXNmwFfrfeHAj1D9rPPJO+KcG4MrTZ9Gkqs2qsl1LECzgXJY8WpGzfcUKNQ88Mu4SAWoVCx8jARCCwwduzYoHAWJcuXL6dfv36kK0JNi4uLKS4uDtn2zTffzM033xz2eiNcLpdmadvrrruO6667Lqw2BYmN6fCWW2+91XR229/+9rdhd0ggiCdiGRIO2u/qdogx8Wqga4kSAJMmwcmT8GLtx85wDWstQQOkVAAnT0rXO5zxDZUDJF7H2wpGYT+xvk/spKD2C9aJU0c5ceIIjRqFFvvjEicmnVokUBOOsWn0ld3sORi1oeXJUVgotXv0SHgG8/r1+t4hehVSXpsPCxaE5w3jpHGclVWn+CpxYv6EE4MXygvDzrGJdoxgrDxM7KQ+/HETRMTy5csZMWJErLshEITElOhRoxX4bsCxY8fC6oxAEC+o/47H4m+5kSEdT0lQ7Xzn0fOykD9Adu0Ghw9aTysgI79jKo13CM7bYWV8Q+UASbSkqHqECvuJ1X1iN43T0shMa0x5xXHKynbQrt0Fse6SdZxKjqhXOlUmXGNT64azeg5abWh5crz0Uq3bmA8p74UqR0eocwjlHaI2ZJWE6w0TbeM43pJrGj2QE104SGTFeNXH8Mr8+JkngpiwatWqWHdBIDCFaU+Pv/71r1xzzTW43aLKraB+Ew9GqplkmvGQBFU9VkXFMCJ0aXZdQnlZZDWH1nnGfTBjG6WdFZwCQJ23w+z4GokBYH9S1Fh9WAsn7CdRPwLmZ2ZRvuc4+/fvTDzRw8nkiHpeDBC5sanOGWLlHJQTrXv3uuV6YSF1vwAuqe8mDebK3btY6/uZ9RxgG4fZywkqa2pIvnsFeWd3pkOHiyksHEzPeX8kee2XwRVSws3ZEC3j2MrYR/MGN3ogJ7JwAImpGHs8MO8V/KWURRLWekHbtm0ZN25crLshEDiCadFj2LBh5OTkUFxczKhRo+jQoYOT/RIIYkK8VO5wKpmmne1qjdXChYAPIvF0tNPLQmv7vXshJ8e+vChGYkCk4622KWIpyFkN+4kH8TBc8rOz+WbPTvb9tBUujXVvLOJkckStr+ojR1qvHa1GPdGtnIORV4KRSOPHBxMnQkaG4TlUVVWybNlsli15hsMcCFp/usrLzp0b2LlzAx9/vICmTXMYevU9DEX1ohVJWEo0jGOzYx+JN0i8hM4IwmfvXqAGUJTfFklYEx4hegjqM6ZFjx07drBw4UIWLVrE008/TZ8+fbjzzju58cYbSUtLc7KPAkHUiJfKHU4lK7WzXb38G4sWQd++1kLy1djhZaFnG8lGeP/+sHp15Mk3Q4kB6vF2u8yNd5AXTZE0trEU5MwKUvEiHoZLQctc+BZK92yLdVes43RyRLu/qquN56IiaJGNqbATq6Em7qTaOtWqdkMk8Nz93WfMfvkutu/dZPq0Dh8uY9G7j/FpdgfGe1rTxtfI2dALu4QEM/PHaNybNzduP95CZwThkZcHqDy/RRJWgUAQx5iOVWndujUPPfQQ27dv5+OPP6Zt27b85je/oWXLlvzf//0fX375pZP9FAiigiwKKIlFZRT5XT3JXdcHO96V7WxXa6xAMnA/+wzefx9Gj4ap0+COO2DBQuld2U7MXi8tI3z1apg5C6Y/CfPnR/bePXCg1Ia6LXm8lV30+aQ8iEZo9VcpeMgow2icxOOBDRukn1lZUgSB0ZwJFfIT73Q4W4qhKiv9McY9CQN50rlrv8DabWjLxrUdgoeW8VyyUBF7Vnvn6J2DkVeC3H5uLsyaCU9Ol27OsWMtjc2mRbO578F+lgQPJdsPbOO+1K/YdPfNkT9o9Fi5UnrYTpsq/Vy5Mvy2zMyfUOOuh55YYvcfBoHzZGXB/93j3HNGIBAIbMa0p4eS/v37079/f+bOncvbb79NSUkJl156Kd26deO7776zu48CQdSw6sJvRKQf3goL4Q8Tpdd+OysJ2vWhNitLyuGxcGHwuvmvBf7uA5YsgWVL7f2wZ/Z66Rnh3lOBKQAi7YvWWBYWgktRctdHaK8Hrf7KHh/RLlUcTphKopdVbt9K6uh+z64Y9yRMnMpxYPdXesPEqD7JkJo4Uf8BaOSVoNXX7t0tjc3u7z7j0b/cx0mqgtb1BYYDhUAz4BCwHlgCfKLa9mTFMR7901hmnreGNthsFDqRwyXUGIXrTbR5k3OhV4Loc9UA6NErcXOpCASCM4qwRA+Z9PR0rrrqKnbt2sXmzZvZuHGjXf0SCGKGHfZCpPkMnM6HYFf484jhgI4XghZOhDmYuV6xNMKthkx5PHDkaJBzP0luGFkEi0rq5oXTH9bCDVOxUzyMBXLZ2gOHfsLn8+Fyabg0xTt25zhwwrgOlXOjplrKtaHXvl7lDggd9hKiz1VVlTz3xzuDBI9zgAVAT419+gLjgLXAHYDyjejkyaPMnv1rZs36ggYNkg2PbQmncrgYjZFRxRSfzh+ClSth7tzg5UqxJFEzH5/JiFwqAoEgQQhL9KioqODdd99lwYIF/Oc//6GgoIAJEyZQXFxsc/cEgtgQyd/xSPMZxEs+BLPvn40b67/nauFEjpRQ1yuWRrgVwUUpdimLacr9jTaR5LixQzy0wwaqrqyk6tgxUjIz/cu85eU0SE8nKVnb+Mxv0ULarvIUR496yKh0CWPMCeNabTyrMeM9oDXRNmyIuK/Lls3mx32bA5ZdA7wHhMpi1hP4CrgR+Lti+fbt61m2bDY33HCfqT6YwsjrwkkRIZyM06geJkqxROT6EAhizurVqykuLmbnzp2m91mwYAGXXXYZXbp0ca5jAoENWKo/+8UXX3D33Xf783icffbZfPzxx2zbto2pU6fSqlUrp/opECQMkeYziId8CHKI+NRpxiHi/o+/Ftp20sNCmXtCjV7eDacxm0dFLXb5ALcbJt8n9bewUFsMczIcXi9nSkqq/jgrMZP/Qw+zc9CI6spKvpsxgy8mT6bigFRxo+LAAb6YPJnvZsygurJSc7+U5GRyG2cAULb8LfvyJSQysnGtxI7EhfKN+eR0GDUqvBwB6okWTl8VD4/KytMsW/ZcwOpzMCd4yKTVbn+Oavny5bOprDxtvLPRg0y93d69cNllgcv79ZMSB6nnrdl2zWL2BtcLY5o4Ubr+IteHQBCXfPLJJ1x//fXk5eXhcrlYunRp0DZr167llVdeCav9Y8eOMW7cOPLz80lLS+Oyyy4LyBFZXV3Ngw8+SEFBAWlpabRv357HH38cn8GXtqeeeopLLrmE9PR0WrRowbBhw9iyZYthP9544w1at25Ns2bNmDBhQsC6nTt30qlTJ44ePRrWOQriB9OeHueccw5btmzhwgsv5KmnnuJXv/oVGRkZTvZNIIhbjD6gRRpKEc7+dn7Qs+JpolfBRe7z1VdL+SxWrnTew8JMSFCsPHHNfBTVE7sOHjRe72Q4vJaHTL9+MGmis6Vo7fJ2qjp2jGO7dlFRVsa6KVM4b/x4NsyeTUVZmX99ksIDREmb5tmUHj9C6buL6ISU2NSWkI5ExSikwY62ZQP68r72JBxS9tXllkrr6rWn8jJYO6g7hw+XBWyyAPOCh0wa8BrQS7Hs0KFS1q5dRp8+N5nqi+4NptxOzerV8M9/4pejfTVSaInLFRtPCj1vFPnLsJNllgUCQdicOHGC888/nzvuuIMRI0ZobjN06FB++9vfMnv2bMvt33nnnXz//fe8/vrr5OXl8ac//YkBAwawceNGWrVqxYwZM3j55ZdZtGgR5557Ll999RWjRo0iIyOD3/3ud5pt/vvf/2bMmDFccsklVFVVMWXKFAYOHMjGjRtp1KhR0PYej4c777yTkpIS2rVrx7XXXsuVV17JddddB8C9997L008/TZMmTSyfnyC+MC16DBgwgLfeeovzzz/fyf4IBHFPKOM60lAKq/vbnf/DinGtJdC4XTBoEKxYASs+rCu32rGjc7nOwjGSox0+Hkpw0RpLkJLCLlggjaHTeUm0xkQp2KSk1gke4FzolV0CT0pmJj2mT2fdlClUlJWx9v77AUjLyaHH9OkBIS9q2rZowbpd29hHReCKM9kYcypBqhK7lMmBA+HEcShZJBnUixZJsXiyZ4E80SHIy2D9itcDmuqLdg4PM1wKXA78R7Fs/foV2qKH2bwp6u3UaIUK4VNkU46yeBdKMHO6zLJAIAiLX/ziF/ziF78w3Oaqq66irKyM77//nm7dupluu6Kigr/85S8sW7aMvn37AvDII4/wwQcf8PLLL/PEE0/w+eefM3ToUK699loA2rZty1tvvcW6det0212xYkXA7yUlJbRo0YKvv/7afxwlP/74IxkZGdxyyy2AVKxj06ZNXHfddbz11lskJyfrCj6CxMK06PHCCy842Q+BICEwa1xHahuY3d+J/B+pOp8zU1KDl2kJNCNHSvaFbLPW+GDxYsmD3an3a6tGstOJYsNBPZZK5DEsKobFi5zxmlGPydBhMOT6wLyPGzZEx9tEz9tJDquxIlSlZWdz3vjxfsED4Lzx40nLzjbcr12eZHCVcSpwxZlujCVK4kKPp07wgDpD//jx2gdUrcfDsKFB4sE2DgX8PjzCrowgUPTYvv1r7Q3NejwYVr1BmqM1NRgGHmq1G6scIE56EQkEAkdJSUlh4MCBLF++3C96lJSUMGrUKMMwlKqqKqqrq0lNDXy5TEtL49NPPwXgsssu49VXX+WHH36gU6dOfPfdd3z66ac899xzWk1qcuTIEQAydT5ydOzYkZMnT/LNN9+Qn5/Pl19+yR133MGhQ4d48MEH+de//mX6WIL4xpToUVhYyKpVq2jWrJmpRvv06cM777wjcnwI6h1WjGulbaD1Lhnq/dKMbeFEyMOpCu3l3lPay9XvsrEIw7ASEhQviWK1kMfys8+Cy/5W10DHDpJ4ZPeHdq0xWbIEli6BsWPrBKFoVcGxM6ym4sABNqjcbjfMnk2P6dMNhY8OctnanCZwIEkYY4mGnoBQUkJA2MfSZUFeBns5EbBbYYRduVD1+549P2hvqOXx4NK4wYyq3igr2CjDe3w+AkQQtXgXjUSiRn/UouFFJBAIHGHo0KG8/PLLTJkyBYCMjAw6d+5suE96ejq9evXi8ccfp2vXruTk5PDWW2+xZs0aOnToAMD999/P0aNH6dKlC0lJSVRXV/Pkk09y2223mepXTU0N48aNo3fv3rpeKM2aNWPRokWMHDmSiooKRo4cyaBBgxg9ejRjx45lx44dDBkyhMrKSh555BFuvPFGCyMjiCdMiR7ffvst3333na5KprW91+uNqGMCQTwSjtGn5VUA9ngaOGGEhtOm+l022uVhrYQExUKUsUJWFvTuLYW0aI2hEx/a9XKz+Aiu9BmtKjh2hNV4y8v9oS1pOTkBOT3WTZnCpTNm6Ia4tMvLBWB/5WFnlCaBs+gJCGqhwFcDw4fDsuW1YSEuKgncxtznHn3U+1dW6ijI8g02dy51woxPSkqqF0Mpi3EjRwbHECpFhPXr9T0pnChHHA6J4kUkEAgCuOaaaxg1ahQej4esrCyGDx/O8OGhfeRef/117rjjDlq1akVSUhKFhYX88pe/5OuvJW+4P//5z7zxxhu8+eabnHvuuXz77beMGzeOvLw8ioqKQrY/ZswYvv/+e7/niB7q/v773/9mw4YNvPjii3To0IG33nqL3NxcevToQd++fWlRW+FNkFiYDm+56qqrDN2UlLhcrtAbCQQJiFWjT+sL+ksv1f1f/hnu+6UTRmi0c5LYhdkPhXYLRU54hEd7DPXyiUCwIBTND7JmwmqaZeiXpG2Qnk56fj6A37NDzvGRnp9Pg/R03WMX5OQA4Dmyl5rMTNyJZIxFO2FNPKIlDBSNDAx5AWn59UOkf5s3w6xZJPvcnFYIH4c0mreCev/kZI1YQZnCwtqEo/KENxlDCdI1V6IUEYxuXJFIVCAQRMCOHTto2rQpTZs2tbRf+/bt+fe//82JEyc4evQoLVu25JZbbqFdu3YATJo0ifvvv59bb70VgO7du7Nr1y6eeuqpkKLH2LFj+etf/8onn3zC2WefbbpPXq+Xe++9l9dff51t27ZRVVXFFVdcAUCnTp1Yu3Yt119/vaXzFMQHpkSPHTt2WG7YygQTCBIJK/k2Pv002FgzY1g60Z9othkrT2UzHwrtFBS08mD06SOFCEVqbxqNod02rVE+ES1BKNofZPWEqpxsqSTtsV27/KJGxYEDflHj/MmTOX/y5ABRJC07m0tnzKBBejpJycm6xzw7K4skl5uq6kr27/+Jhg1zycxM8a8vL/eSnt6A5OQkx87bEvKk2L6tzrCPdpWOeEPrJmrUWN/joUkT8NWQRyN2cszfzHqkZKbh8o3q91ank6WHh/q6yH80zAoQ8o1oNjRFL+bSzkSiHg/8uAUyMyDzDM59IxCcQSxfvpxrrrmGBg1Mf0sPoFGjRjRq1IhDhw7x4YcfMnPmTABOnjyJ2x1YfjwpKYmaGv2cRj6fj9/+9rcsWbKE1atXU1BQYKkvTzzxBIMHD6awsJBvvvmGqqoq/7rKykqqq7USRQsSAVOzM7/2S5lAIJBQG31qI1RpDKtx1zpC6XkahGPQOmGERtpmPHsqhyvKaBV9UOfBWLJE+t1q2JLWddcaw1BJWMMVROQxWf4BLFsqte+0h4nZvuoJVRkNj7EpREnalMzMoLK0RlVbZBokJdEqoxm7Dx9k9uyPKS/vwPTpPcjOTuPAgQqmTFlHfn46kyefH3vhQ698qVaYQn3zArGaHMno5q81/jv4mgaIHkuAcRF08X3V7+3JCL4uRiVo3Ulw5LB0rupzDCc0RUsksSOR6MqVtaE5teHNYyZIpbwEAkFCcvz4cbZt2+b/fceOHXz77bdkZmbSpk0b//Lly5fz4IMP+n9fsmQJDzzwAJs3bzZs/8MPP8Tn89G5c2e2bdvGpEmT6NKlC6NGjQLg+uuv58knn6RNmzace+65fPPNNzz33HPccccd/jbmzp3LkiVLWLVqFSCFtLz55pssW7aM9PR0SktLASnPSFqaceHxjRs38s477/DNN5JU3aVLF9xuN6+99hq5ubls3ryZSy65xMzQCeKQ8CQ5wRlNfXtnjhS1EVpUDItKtAUP2VgDbU+DeKwqUl+xKspoeXVoXWMZK2FLZq+7XhLWtgWSd8m27XVzL5z5k5UFd4ySqrY47aVjda5r26rhl6Q1Q35WNrsPH2TPz9s4eqwVU6asY/z485g9ewNlZVLG32PHqsjMjKHoYaZ8qewlEI1kldEk3PPRu/lr1bXCl6byse8n/+JPgLWEV7b2CwIrtwAUkh14XYyuocstVWKZOVP7HK2GpuiJJPPnR5a7Rm7XHxZU2+5FF4kXBYEgQfnqq6/o37+///cJEyYAUFRURElJCSAJIVu2bGHw4MH+7Y4cOcKWLVtCtn/kyBEeeOABfv75ZzIzM7nhhht48sknSa71wnzxxRd58MEHuffee9m/fz95eXncc889PPTQQ/42PB4P27dv9//+8ssvA9CvX7+AYy1cuJDi4mLdvvh8Pu6++26ee+45GjVqBEiVZEpKShgzZgxer5e5c+eKIh0JjBA9BJYQRnkgWkaonuBx52gpQaVWjjnle288VhUxS30VxLSuzfJl4MKwKKSpsCUr110vCevEPwT3I9JcMU5eP6NzbqSfZkOzX+GWpDVDQYsc/rNtM/16+1j7TRplZRXcf/9aAHJy0pg+vUdAyEtMMFO+tGVLcx4BiXQDO5F80+OB3Fx6Pr2Qpo/34/Dxg/5VdwBfAcbfCQOpAEarljUjhZ7kBoaP6F3DIUOlB42M1jlaDU0xEkm6dw9/7LTa9dmcFySR5qdAUA/o169fyHyOy5cvp1+/fqQrcmQVFxcbCgwyN998MzfffLPu+vT0dObMmcOcOXN0t3nkkUd45JFH/L+bzT+pxuVyaSY8ve6667juuuvCalMQX7hDbyIQSOgZKh5PbPsVS7SM0BqfZAwrSXIHCh4g/V/5jmlUVSQRWLkSRo+GqdOknytXam/n8UiJKRNp3uhdm2HDpWurh5kEqVauu5zbQo3en3i9dpy8BmbatnOu65WkrThwwHpjKgrypIt39PAuxo8/L2Dd+PHnkZ1txQR2CNno1UIZpmBk7ELdDTxtqvENrEe0b+xQ52MVxfkn3z+VoecNC1i9EbgRScgwQ0Xt9htVy4dQQLI7OTB8RPMaumD58uCGa6qlmtbyOMuxX+5ab6NQoSlax7KSv0PvOqelEvSXz2WiXbPzJtL5WZ9IxD+ignrL8uXLGTJkSKy7IRCERIgeAtMkulHuBFpGaJIbiovrjGGzeRH02nKy1KtdmBXEzAgj0Xqfs3IcvWsz5HrJI7zwwuB9ktzSh9pw29a67rJ9I88tLQEkVDtmxalwMNu2XXNdXZK259NPk5aT48/x4S0vD+9EamnfSurQnj3bmT17Q8C62bM3cOCAWRPYQbKyYJjORJs4sc4Vz8jY1fOaUN4cRjeM0wbp1h9g6VL4cl1dHyI13pVonP/QNftpnx8odP0duBgp1MWIL2q3+7tqefv88xj62BvSQ0O+LrL3QlFRnXDhPy8dOfO1+YHjPHCg1OaT02HWTDgrDT79j/a1siqSKNG7zitXwsRJqv6a+MNndt6YmZ9nCkL8EcQZq1atYsyYMbHuhkAQkrDCWw4fPsx7773H9u3bmTRpEpmZmaxfv56cnBwR61SPsbvUZ31AL8HiwIHQt6+18OhYlXq1g1CC2N69kJoWOowjWuFTVo9jdG08Hvj228DtXUjbLVkiJQU1al+r7SFDofyQtie3MrdFSipMmmicP0adcNepECorbRuNZ4XX/DEjKUlrhvZ5uQDs+nkHp30V5OSkBeT0mDJlHTNmXBr7EJfrh8CSpQQYne4k6NKl7netEq7yoG/YYJwXwih3hhNhJkrmzIF/rgpcZmfyTdD0Gmng8zH+qonc98a9nPQe9y/fCFwKXA6MAC4EmiGVpf0GKWmpOocHQKNGGYyf9BYN2pxTt1A9rsVF0KGjlLS0tnqBLupxzsqC9etrE4nK88AFY8cGP3yUD5HUFKg4pZ0kVYnedS5oq5GPxA0PTYWLeltvTy+uL5oldeM1jMbpe01wxtO2bVvGjRsX624IBI5gWfTYsGEDAwYMICMjg507d3LXXXeRmZnJ+++/z+7du1m8eLET/RTEAYlslDuJXjGAcPIixKrUayR4PHDkqLYgtnUbTJtWJy7oCSPRzGkS7nH0ro2W4KP8Va995Xu1snLK0iWhq8Ao55b6nhw5Ejp21J4/RuJUpGNstW075npScnLYJWnNUJCTA8Bp30FatEj2V2+ZPr2Hv3pLenoEqbGMjCsrhldWlmTchhIA9AZdLy9EaorkMWBkaDlpkG79IVjwUPZh5EgpySfU/QwHrfN3uWmz4F0e5jweZR0nqQrY5T9oixtaNGqUwUMP/Z02SsFDy4BdtFjy2GjZkuCMQRoZhLSSoQZs45OW6SmP69ebTwT7wXLt67xxk0Y+khrwhlAvrcwbO0vqhiKek/1GW/wRnHEI0UNQn7H8tjZhwgSKi4uZOXNmQNKaa665hl/96le2dk4QfySiUR4N7Ez8GM+lXtUoPSZc1AkbsvGtTOqq542gzOXnlEGuJNLjqHNkaXlAqVG3r+VpUlgoeYVYTUhq5Z500lsrnLbtmOtJyclhlaQ1Q26zZqQ0SMZbVcnEiS39OTyys9OYMeNS0tMbhF+u1si4CsfwMjsRtAZdywukXz8pZEErwabS0LLbIFWKPf9TZ8RQ9aGkhLo7JsLMverzr6kBfHQlk5n0Zjbfsp0jlk+nfftCxo9/PVDwAGMDVnPstOqfm0iG6tN5uFnxGvB4aj2JNI5/TlcNwSgJWrTQOAcFVuaNkZeSncS7J0U0xR+BQCCoZ1jO6fHll19yzz33BC1v1aqVvxayk7z00ku0bduW1NRUevbsybp16wy3f/fdd+nSpQupqal0796dv/89MMrW5/Px0EMP0bJlS9LS0hgwYABbt271r9+5cyejR4+moKCAtLQ02rdvz8MPP8zp06cDtnG5XEH/vvjiC3tPPk5QJ+AUnJmoPSbkV/LJ90kfKzt00BYClKkcamqkj40QvZwm4R5HL1+FOs+GFsr29TxNNm3WF05C5c4xe0+q+2qnt5aTbccKl8tFm6bNAfB6Ay9AZmZKaMFDLw+GUY6CSPIXRPJwVueF+Ne/9KvCKA2tSHJEqFHnKzh2TH9blxtdzwc1ZhL4KM9/4h8C2m5DOrPoTdGgcTRtmmPqVJo1zqKoaAazZn0RLHiAcU6SvXuDz02Nyw1FI0MkQ63dTuvhZiURrF5/hg6Bjp0Cr78rSbp2mc31+y4LW8VF5ueN8vooc6LYid3Jce3GzntNIBAIzjAse3qkpKRw9OjRoOU//PAD2TaUCDTinXfeYcKECcybN4+ePXsyZ84cBg0axJYtW2ih8VXh888/55e//CVPPfUU1113HW+++SbDhg1j/fr1dOvWDYCZM2fywgsvsGjRIgoKCnjwwQcZNGgQGzduJDU1lc2bN1NTU8Mrr7xChw4d+P7777nrrrs4ceIEzzzzTMDxPv74Y84991z/782bG/zRFwgMsDOk2KnwZL3KNRkZdcfR+vJfrXin9BH4Ia1/f1j1z7r1/frZ/z5nNkxLOW7lh7SFirYFcKpC6v/MWdqlY9Xt63maKD1l1Ngp/gwcKPV700boeg506mhPu3Lb9c0TrE3zLLZ6Sinds43zz7/K/I5G3hpGxpXPFzsXdtkLRCvHh4yWoWXHhdcSe/7yF7isN3z+WXAfikZCySLjr94ejxSWsXSZOa8Z+fw9nqAv6g1cDbhh4G8YcvcM1q5dxvr1K9i+/Wv27PmBytMVJOOmFY1pTwaFrhx6PreM5Nw8/fMN5b2g/qKvxlcjnX+jxtL5yO0F5NeodSPTuh5WvAZ0wn+4vrZig/L65+ZCWgPw6iT5Vd8XRUX68XhqwnUNM/tHMBE8KerjQ1YgEAiigGXRY8iQITz22GP8+c9/BqQvYbt372by5MnccMMNtndQyXPPPcddd93FqFGjAJg3bx5/+9vfWLBgAffff3/Q9s8//zyDBw9m0qRJADz++ON89NFHzJ07l3nz5uHz+ZgzZw7Tpk1j6FAp+/3ixYvJyclh6dKl3HrrrQwePJjBgwf722zXrh1btmzh5ZdfDhI9mjdvTm5urlOnLzhDsDOZp1FbkYohocIZ9BJ0yrkqZJReDP/6V+C61avh9ttD98/quYR6b1SH7Wh9c62uqUsi6nbB0GHa202cCH361P2uN25dugSOl3KdnR/znE4Wm0jhWWZom5sLW75n38/bzO8Uyk0+lHHlhOFl5SbRM3InTZImqtb+kV54PSHo2mvhhhFS7oi8llJGZPmmbdRYWzSQxQ51clez4QpqQULed+IkkseMoc/Am+jT56a67VeuDO6HkeABUh9zcyWvmlPe4IRQ6uNroT4f+cG2ebO0Xu9aaR3DyGvAzLby9ff54MRh/XNW3xeLa/OYOPXQ0BMfte6HaIXRREp9e8gKBAJBFLAsejz77LPceOONtGjRgoqKCq644gpKS0vp1asXTz75pBN9BOD06dN8/fXXPPDAA/5lbrebAQMGsGbNGs191qxZw4QJEwKWDRo0iKVLlwKwY8cOSktLGTBggH99RkYGPXv2ZM2aNdx6662a7R45coRMjZjxIUOGcOrUKTp16sR9991nWLfa6/XiVST60vKeEZx52JnM06gtOX9dJIavGY8JtbgAUt4KLaEk3Fwb4Rrxeu+NemE7WijHdvmyYIFEFjPUx9UbN3VlFu8pez/mmZlf8Vq4IFa0z5Mmbtm+7eZ3CpVwMJRxZbfhZTVHiF7/lOqd3RgJQVlZUhiFGi31cuVKVQUTFWa9ZgYOlCqT/GFiXVvKiiUVp+puEqtf37WuR/fu2uf25Zfw8h/121KfT1aW+etkpd92eBjEogqLlvh4/DgsWqR9PwhPCoFAIKiXWBY9MjIy+Oijj/j000/ZsGEDx48fp7CwMEA4cAKPx0N1dTU5OYHxtDk5OWyWv2qoKC0t1dxezj0i/zTaRs22bdt48cUXA7w8GjduzLPPPkvv3r1xu9385S9/YdiwYSxdulRX+Hjqqad49NFHg5ZXeL0kJ4WZGO8MpyJUtvgo4DlYWwUwTQp7aNkSsixEOf24Cyo1DP8du6GRxeqbem199194YS7Ir57VPnjxJejazVpfAS6/QtqvtFT6aJnVPLjkaKN06KDo+533wKuvSMdNcsHou6VtmmVJpoXylTjJBU0VbaqvseegfeciozVuarS8P6prYMgQ+NsHweemHhOjcVOPF1gr42pEqPn18Sp4ZZ40nm7gtl9D+3bm5rE8963OeTXxcB8raZMrhW2Wlv2IV89lX01WM4JmsysJmjetc/u/4nLo1rVuEjTPMrfOKgc9MPeFur74quGlF6X2mxsYdOH24aCnbiLotK85jumN4J474ZVXpT66kuDu0dJyo+OmN4L0DtL/9/4UeK5aqK+DEUcPg6pqCzXV8IcJ+O+S/7sHrhoQ2A+jtrdvhbnPUyekaFwP5Rhe2Q82/hf+vdrc+ZgY/wC0+q3Xholz9Pl8ePf9zOmfd+PtVIUrSxH2bOa+sJNdP4KvMnBZTTWUzFd0WGP8zV7LMxzTz0MB1dVw+rQYL4EgllgWPWT69OlDHye/+sQhe/bsYfDgwdx0003cdddd/uVZWVkBHiWXXHIJe/fuZdasWbqixwMPPBCwz9GjR2ndujVpKSmkpaQ4dxL1HL2xi8bXa6XHgYwLGDYchlxv7rjt8iFZI/ShoA2kWZwWem01TJb6FSCt+eDwQWgdwiNbi9Z5wfsZjff110CvHsEf0lrnwe/GBntAqNtWXuNDHu1zWf8l9O4dnveC1rgpcbukZKZPPhE8tjcOk/6Z+UioNW6RYOYcjebXiWMw/5XA8XzzdelnKA+aSENmlH1vlK5/H8eCLq3PBqDM8zPHjqWZe37ktYaxvwv2lMhrHbydepmZdVbwHCLoLvEBBw+Hbt9qHyx4lKSkpAUvvOZ66NEr/K/sWueqRO6T2XPKbweuZJ3cGrXHePU1qc9m+iqPjzqHvPJ6aI3hH+6DIcOkEJ+jR6VcJ1rzyo5yqxG24fvwQ6pemgNUkUIarrFj6/Y3e1/YheH1U3Yac/eDIAjN+1gQRHU1NGxYGXpDgUDgGJZFj8cee8xw/UMPPRR2Z4zIysoiKSmJsrKygOVlZWW6eTRyc3MNt5d/lpWV0VIRL11WVsYFF1wQsN/evXvp378/l112Ga+++mrI/vbs2ZOPPvpId31KSgopcfRiX59xOocBBIcNyPiQclgsW2ruuGaTbJpBr62uXayXFrUiGpgZb73QEquexXrlYue/BgsWSMeG4P7061/JsrVrWbF+PV9t28YPe/firawkJTmZTnl5pOV2oHJfIbn0xE2y37NDHsMelxhfJ7Nii11inNk5bjS/NmzQF3qMwqwiDclS9/3OeyRhLF7YsVHyBDx+6iB33FHB2LFp5p4f8eImH63kjHaV+4wkX4HWuSpR15s205eA5KAaPl5mwzPU46NEvh5GY9ixU12Izy9+ETyv7Bj/SNuQ9/d7cmjsH837wmxulHhLVioQCAQC27EseixRZSGsrKxkx44dNGjQgPbt2zsmejRs2JCLLrqIVatWMWzYMABqampYtWoVY8eO1dynV69erFq1inHjxvmXffTRR/Tq1QuAgoICcnNzWbVqlV/kOHr0KGvXruU3v/mNf589e/bQv39/LrroIhYuXIjbHbrS77fffhsgpAhig505MozQykehxMpx7Xwn1GtLafi6XTBypP5xrIhGdoy3kc3jOSh5d8gigdIm0aok89JLdf8HqPJVMf6lZRxYvIwDRw8HtX/q9Gk27NwJ7AQ+JoWmFDCUjq6hTJ7UICAvoJVkqFrjZpcYZ3XM9fqtJyDJ6OVXCTcXi17fX31F8gSKh1B6jwcWz29MMilU4gV28sc/djU/n+Mh4WC0kjNGO1+DFkFGrlqksOMPgKpNswaz1viAJNIolUczY6g1r+wY/0jb2LuXoNAis/13ioED4aw0mDlTe328JisVCAQCga1YFj2++eaboGVHjx6luLiY4cOH29IpPSZMmEBRUREXX3wxPXr0YM6cOZw4ccJfzWXkyJG0atWKp556CoDf//73XHHFFTz77LNce+21vP3223z11Vd+Tw2Xy8W4ceN44okn6Nixo79kbV5enl9Y2bNnD/369SM/P59nnnmGAwcO+Psje4osWrSIhg0bcuGFFwLw/vvvs2DBAubPV8SNCmJCJAaZFfLy9Kt8hHNcq++ERh4DWm0NHAjHT8CiEml8Fi2Cxo2DjW6rBrWT471ypZS/Qy7tqhQJ9D7gKvtyjN18y2yO+LaDybzBXg6zmUXs833KHd7xQBs2bAgUXaD2XZ/gj65642anGBfOmGvNCbUXiBo9b6BQVXws990XXTvZiL17wYeLdLIoZw+wg5qarub6F08ZYaPxdT1eyn0qz/XI4WBj14oRH+Sd4QNc0nlZFZD0KuI8M6vOgyOSMbRj/K20oTW/8/IICt1xuSE1xl6tXbpqn9fEicYVbgQCgUBQbwg7p4eSJk2a8Oijj3L99dfz61//2o4mNbnllls4cOAADz30EKWlpVxwwQWsWLHCn4h09+7dAV4Yl112GW+++SbTpk1jypQpdOzYkaVLl9KtWzf/Nvfddx8nTpzg7rvv5vDhw/Tp04cVK1aQmpoKSJ4h27ZtY9u2bZx99tkB/fEpLK3HH3+cXbt20aBBA7p06cI777zDjTfe6NhYCMwRiUFmN04dNxyPAY+nTvAAfaPbqkHt1Hj7RQKkSHq5v20LpEINemKT21W7v28T63iUKk6GdfwjbOe2P95HYeXDNKWrf5xBe+xDjZud4pCdY660F7dulapJhgqziiQkS7PvrvjxNJf718jXgnL24GYbmBlbO3Ir2I1TX9eVxm9RUV1VjFh+QZfP1eOJTAjQ9M7wScZyRoY1AUnP40ZZlSYSrxytfYtGBiuy4fRRz41NPb/9+z8fGCIzcVJs7wG98zrD8tIJBALBmYwtogdIZVyPHDliV3O6jB07VjecZfXq1UHLbrrpJm666Sbd9lwuF4899phurpLi4mKKi4sN+1RUVERRUZHhNoLYYGeODCOkL8LByAadU8cN12PArNG9TaNKp5FB7dR46/X3y3X6gocLqS+7yndz75t6gkdfYDhQCDQDDgHrgSXAJwFbnqw8yRc8Sm9mku5rI70/19QdXzn2oYQIvfUpqQR4kpjB7jGX7cXu3aFvX2erWWr1ffTd8fPhVe7f7+ZKXn0N2MrdocbWrtwWVomFZ4nS+KVWYcQnGcJFI+ND6IkktEfP8yFc74BQN4rHI1XKmTUTTnmte+WoVcsSnbKskfYx1Pz2qfJnROseMCJecuwIBAKBICZYFj1eeOGFgN99Ph/79u3j9ddf5xe/+IVtHRPEjnjyyraDaHl2axmxM2eB95Rzxw3XY8CMd4DsDaLGKP8HODPecn+rVf1t1kx/H7cbup9Xxf1PP6cheJwDLAB6auzZFxgHrAXuADb611Rxkm+ZTW9mQU3w41Me++7dQyc6Va/v1w8mTQwvx4dTc9yKc0C4jgTqvlstzew0AwfC7WUtefBdOLfrj/TvX015eRWZmXUu++XlXtLTG5CcnBSb3Bax8CzRDP2Q/1sDixbD5X1j/0ckkpvDiXwoejeK1jXs3j289gGmTQtfeDO6mY3mN9QlUlIT7fwuSpQvNeGMqUAgEAgSHsuix+zZswN+d7vdZGdnU1RUxAMPPGBbxwSxIRqVTmKB03nT9L62d+poT/seD2zaLP2/q+IjY7ihDWa8A/SSs3Y0cU52j3dWluQ5v6BE+l3ub2EhzJun7e1RXQOPvbGMb378UbXmGuA9IFSpvZ7AV8CNwN/9S4+wnR9ZRmf3DQGeHnK/5LEPZWsp16ekwsQ/aHuNOC06xAPKvld4Y9sXLc7vLNUWPnR4FzNmfMeuXceYPr0H2dlpHDhQwZQp68hvmcLk4WkkN06Lbm6LWHmWbN5kXAo0lkauGr3kO2aIhmqudQ1fegkK2gaGv5jFSeHNKO+HViJT9TbRJh5DzQQCgUAQdSyLHjt27HCiH4I4IFqVTuorTr0br1wZmLfCBYwdqwqhDiO0IVR/4ykfysqVUqqAGiDZBSOL6t5bx47Vrt4ClSz89zLVsnMwJ3jIpNVufzFKj48dLOeZe4aQnJRsOPahhAh5/YKFwcKNEwl3BeHRtkULAPaX/0RFzTHKyiShY/z485g9ewNlZRVQVsaxb/9CpusU9O8Pq1c7Wy1FJhaeJe+/DyULjbeJpzKgoQzfUO6NTiuKWtfQVwN/mFj3sA+F8hz0Svdu3Rq5p0NI7xeN6naxyu8SK0FQIBAIBHGHbTk9BIlPtCqd1Gfsfjf2v7MplvmQlsnvbZF6b+ttH618KKHQEuMWL4K+lwee//IPYNnSuhwqP9esxcthVWsLMC94yKQBrwG9/Eu8HOJk+lpu6tMnYqHL45H6rcYdRwk9z3QKapNln/QeZca0zjzxxBbKyiq4//61AORwlOksIZOT0g26erW5vAx2xBJGu2rKEpOCR7yUAQ1l+MaDJ4CeSKEssQv6c0XrHG68Ed79c+B2ixdLiXoivS56f3SCEpm6YfgwuH5IbOZCPJRRFgjiBJfLFVCAQSCoz/h8PlwuV8AyU6LHiBEjTB/k/ffft9YrQdwQT1/2BRJ6ISY1qrKeZsSWcOyraOd+0+qjGTEuKwvuGAVDrpeWHz4Ct81cr2q9L9o5PMxwKXA58B//khXr13NTnz4RC11613joMPFeHi80TksjM60x5RXHqa4uZfz48/yCB8B4Piab43U71FRLgofRV3W7jG0n8k7o4fFIyTH1cLlh2NDYGblamMlBEWtPAPkaBuRIUfT1g+WwdJn2XNELjdEybqwa/FZroYPUry7t4edd0Ok8yM42dywniJcyygJBHNCwYUNOnTqlaQwKBPWNU6dO0aRJk4BlpkSPjIwMRzokiC/i5cu+oA4tIQqsewFEkqslWrki9PpoNumqMk+dxwNH2KY6wvAIezgCpejx9fbtAceF8D7aa52f2yWqKcYb+ZlZlO85ztatm3nvvcBKZbMZwHSW1AkfoQwru93u7VAnzaiimiVcAVxw333hVzVxklA5KMLxBHAi2/fAgVIOjz9MJMC3z+WuEzwgeK7ohcZoYcXgj0SUa94cGp8FmTGeC9EUBAWCOKdly5acOnWK0tJSWgrhT1CP8Xq97Nmzh86dOwcsNyV6LFwYwpVVUG8QVd3iC+UHQNkolkuxWvlYF++5WkL10UiM0xNLTiXthYDKiYUR9vLCgN82/7SH0aOl4yqKdYYlKinPD6Q2J020z9PeThutvlV3MkvbFi34Zs9O/lSymiMnhpGTk6bI6QFTGM4M/kKm2xvasHLC7T4SddKsgasXhlFcHL8qXSjD16ongLpMb3ExWPCGNaRjJymHh7KvQ4fAkiWB2ynnim5ojAqXha8Y9SkXhnipEQgAKCgoIC0tjfXr13PttdfGujsCgWP897//paqqinPOOSdgucjpIQgikatAJCpGhqT8zra5tnqL1Y+pyz+I/1wtoUJY5DHYsRsK2tT120gsqaypVB3FoL6tKQL391ZV+usUKLsejqg0cCC0LYi8gosWdlZkcrK6k3wPNMuC1nn2tGknBbm5ADRO9ZDaOM1fvWX69B611Vuakj58qtT5UBcsHtzu5QFPSzVv4KoFBJcbiotg+Ijgdq2oYk4qaR4P5OZq51ix6gmgVaa3ZKGkeg63SfgoLJQeBLikhz0EenpA4FzROoeaGoK8RZ6ZZb4STCQeMHv2QNNGkqdHvCBeauxFvl+zmkFe61j3RmCSpKQkevfuzccff0yjRo3o3bs3ycnJse6WQGAbNTU1/Pe//+Xvf/875513Hk2bNg1YH5bo8d577/HnP/+Z3bt3c/r06YB169er4+gFAoERZgzJrKzwPqR6PLB0SfDyeMvVYiaEJSsLGqVDWkrdMiOxJCU5mVMBz6dDEfYycH83+i8LRqKSnn330Up7K7jIZY6VlX8iEVKc9BhS3gM+4HcmC1ZEk/ZnS5OxRYvD/H7ypWRmShMxOzuNGTMuJT29AcnJSeYai7XbvdqzI5SBq5y0Rl/OwwmJMNonUjFEq211nhXl+aSmQMUp6bhax9ML7ylZBJfbkCBUbyyKiqTyVb4a7bmivibr1wfPLSulb7VEOZdbGh8Z9bXx970aqIZRI2HYrZGNhyD+CPB08sHY38Xfw1qgS58+faiqqmL16tV89tlntG/fniZNmuB2a1RdEggSBJ/Px4kTJ/jxxx85efIk5557LsOGDQvazrLo8cILLzB16lSKi4tZtmwZo0aNYvv27Xz55ZeMGTPGjr4LBGcMToee7N0bbEgDDBkauw9fWnZMuPlkjMSSTnl5bNi5U7H1eqRkpuHyTcBvjWmlu6WeqKQncL3/Pqz40Hw7oVAeR024QopT1Z2C7gHi05O+fSvpQhw4uNsveMiofzdFtNzu1TecVuiCGqUngZ4hru5vOCERRvusXx9Zolcr/cnKMnc8OXmPGp+NN4K6vyeOQ0kJ0pPcBUUjtcdB6c0Q6dxSi3JyfyZOkpZD4FgpRRkAamBhCfQZENtEpgJ7CfJ0SuCwpzOYfv36cd555/G///2PH3/8kV27dlFTEyI8TiCIY1wuF6mpqRQWFnLOOefQsmVLzWS9lkWPP/7xj7z66qv88pe/pKSkhPvuu4927drx0EMPUV5ebkvnBYIzBT1D8rPPoHfvwPeIcD566iXJHHJ95H0PByOvlnDe043Ekos7dFCJHkuAcRH0PrAyVa+u7UnaIh1XmdMDJO/y9esDbRM9gattQa1No0E44pT6OGrCFVKcqu6UKKWy5bK1Bw79ZF/2e6fd7rUEi9xcbaFD/rKv9CSwIhzohURs3qzvpma0T6Q5JayEaJg9Tz1PVrOhSUYPcb3+Liyh7snik34341US6dzSSqwqj4syfMZXoxI8/J2X/pD16RNfN7IgfEQJ4HpDZmYml19+OZdffnmsuyIQRA3L/ky7d+/msssuAyAtLY1jx44B8Otf/5q33nrL3t4JBPUc2ZBUM/81GD1asllA+jl6NEydFrg8FLIokFR7pye5rSVBtQuPB/7zqRRqoTT6X3oJftga2N/u3evsrQ0bpJ9GDBwI8+fD9Celn7LQMLhQnbj0E2CteneTfIGycgvATf0K/cd95tnArX1ItoGy73rG/aaN2t44LsITp/RK4EJkFZm05pIdERla90C8hV8B5LdogQsX3spTHDlyINbdCY2eIZ+WKgkcStxJUs6HJ6cH3kShyr0qkUMi1Myapf3A8njg6BHtvuAzf1w9tPqjJ06YOU95PNW4kyTvi717jR9W8kN82lTth7jm+LkIfjr46hI8OU3FqeDj11QHL5NFNTUL5lv7gyWIb6zcUwKBQBBnWBY9cnNz/R4dbdq04YsvvgBgx44d+LTqwgsEAl3UhqQS2RPgh63aHgKhxAAZPVEgWsjv+jNnBr++1/iknH3qd2KrIo9SLJEZ2rMnOaokRnAHUGHxDCqA0QFLUmjG0pd7svwD6X3vVIV+Pg4ZPeO+6znawlfxqPAEBb3jTL4v8utvZS6ZFa2CxBRXfFaVTElOJiddKt9eVrYjxr0xgZ4hf8orDbi7Nv+IMueD+iayYuTIF1K9vSy2KCfCqo8VDwVf3T5yX7p0jdy4kvujPk+tiWXmPPXyeVx9tZTTQ0/MAH0BSjkmWv0dNMj8+TqB3rjgCl5WXFTXdyVa5ypITNRz1CVKAAsEgsTBcnjLlVdeyfLly7nwwgsZNWoU48eP57333uOrr75ihF1l2wSCMwg5rOOzzyQPDyWyJ0Ck7v/hejpHmkcwVKgF1HlFyJ7kRnlOGqWbP3bD5GQmDB3K5EWLFEs3AjcC7wFpJlqpqN1+Y8DSAoYAySxZIiWKvemm4G+yWolYtUJxOnUMXO5CsnX6hul1qnccuyqKmplLVqu8KEObmjaPz+otAPnNsyg9dpiysh107tzT0WNVVlZz7FhVQL6Q8nKv+YSpRhViunc3F0tmNeHqwIFwVpokZihRusB7PDDvFQKDwlxw3+TA0lR2JHo1GzNn5jz1xvPDDwkK/1CHxXyw3FxYgLq/ENg+SH2Qq7o4jd64QGAFn5Ejpeo1l/eFTz+FBS8HtiNCIOoPyjnavKmo3iIQCBIGy6LHq6++6k94M2bMGJo3b87nn3/OkCFDuOeee2zvoEBwJpCVJeXwWLAgOGeC7Algdy4FJVq5Dpd/AMuWRlae1CjUQolSxDHK8dDBgugBMH7oUN759FPWb9+uWPp34GJgAWBkuH6B5OERKHhk0J52DPX/7gP+/G7gnnqhH3o2mLxcHvMVH0rCQbglYZXHSUmVPFH0ClLYTbjJeWUxpcLrfB/DJT+7BWt3bmPf7q2hN46AyspqZsz4jl27jvlL4x44UCGVxs1PZ/Lk80k+cshYkQxlyJtVQq0m25G9NPRKrO7di5SuViHc+GogIyO0ALBhg3UF1q7z1BrPoUNgiao8llblmyVLg49n5DGjPPbYsbGr8gP643LiuOThIuf0aNxY2rZ3b1jwCqBz/QWJjzxHvVa9JgUCgSB2WBY93G53QGmjW2+9lVtvFWXJBIJIMesJYFcuBRn1V/n+/eGf/wz0WjAyXI28QfQSqapFDbcLDh+R2rIzYWZygwa8Pn48ve67j6MnTyrWbAQuBS4HRgAXAs2QytJ+g5S09D/q5mhAIy5gPG6DR6fbBTNnSddNTSjPGVlkgtBiQai2lAUpwhGuwvXysTsxaaTeRnbSLk+ahGV7tzl6nGPHqti16xhlZZLQMX78ecyevYGyMsnIOPbXVWSWmKhsYleFGCuuYqHElrw8giJrQwkA6oSsxUWSZ4HdhDpPLSFm6TJ9gQdqRR4N5XfoEHM3tt1VfsK5odTj4vHUCR4Q7OFy550w/1VpXSyEmkiJp4eOQCAQCGzBsujRoUMHbr/9dn71q1/RqVMnJ/okEJyxhPIEsLu6pdZX+VX/1N5Wy3ANFcagJ+RAYDiHzyd5xMtt6Ik84XgBnNOmDf94+GF+8eijKuEDJGEjWNzQIqNRIx4e/BD/XtKGaoPqbjU+8J4KXh5qrIzEAnm9/A5uJnwkknLIVsNTlNgpWkXSDyfocLYUd+N0To/MzBSmT+/BlCnrKCur4P77pQS8OTlpTJ/Ykcz7fmO+sonTFWK0MHpgZWXB/90Dr75mzntBKx/GwoWSjhCLkFr1eKoFHjmpqbytVliMyw3XDwlu26g8sB3XUK99MyiFAKPEr82bw5VXQtdOUOFLPOEgkjESCAQCQdxiWfQYM2YMb775Jo8//jiFhYXcfvvt3HLLLeTm5jrRP4GgXmDlw5He+60TtovZ8BMINly1jOqXXoK0s6Brl9CCTWGhVIRg1qxgw3z+fOmfXSLPZV27smbmTH49e7Yq1MUcGbTnzXvHc3ZGG669TApbX7pEu+qK2xVs4JsRIPTEgq3bYNq0OsO/qBgWlQS3pR73cD0uIhFLQF/osnoNI+2HE7TPk/7O7T+42/FjZWenMX78eX7BA2D8+PPI9v4UX2Uj9R5uRg+sqwZAj15Sn1NTpCohevFXeglEFy2CviZKtzqN8gG3dWudB4TSYDaTn8RKeeBwiKR9tRBQVGQcwgSQ2RwyW4IdpZ0jxewfYKevgUAgEAhihmXRY/z48YwfP54ffviBN954g5deeomJEyfSv39/br/9dkaOHOlEPwWChCXevlYr0TK0tdAyXLWM6hqVx4Z8nlr2T1aWJBroGebqQhKRck6bNnwxaxazly1j1vvL8Bw7HHKfFJpRwBDaMZR5sxrgQzq3ocNg2oPwxOPBwkdRcXC/zQgQWmLByJHBAofyd2Vb6nEP1+PCjvAUOzyT7A6TsYOCnBwAPIf3UF1dTVKSiYSiYXLgQAWzZ28IWDZ79gam35VNttYOqSlaS50lkq/iyvgro/21PCVA+t3JyWBVqQZJndQymM3cEEbeE3acY7jtawkBixdLIUaLFgcLOfFWxc/KHHX6GggEAoEgZlguWSvTqVMnHn30UX744Qf+85//cODAAUaNGmVn3wSChEfva/V/Po2PCn6yoe0vF+qGq66s+93tguHDtcuTapVGlTFTVnflSpg1M3i51VAIs6VRQcrxcd8NN7Cn5DWmDr6PNgygCQUk0RAXLtIaNuTc1gW0YQCF3MdVzKcDN+CmgV/cqPFJuQsffzy4/VHFMGJ48HK9MrLq81SXhO3QQVtY0kM57lrX1ozHhdm+hiIry1i4CnXd7OqHnbRq3pwGbjfVNVUcOrQv9A4KKiurKS8PjM8qL/dSWVkdtG15udcf2pKTk8bTT/ckJydNyvHx0l7KOSv4AKeinAHWTBlWO/bPypIMbDVOJseUa2ZrlaHVm7hGBjOEviGslAcOh3Db1zuvDh2lh9ST02NTC90MVueo09dAIBAIBDHDsqeHknXr1vHmm2/yzjvvcPToUW666Sa7+iUQ1Av0vlZreUPECq2PkLffbq3Ko1aOC6Ov8v53UdVyq6EQ4XrRNExO5ol7+zDu5j6a57lyZd15GXnCKBe7XdCte/A28gfjomJYvCh0yIfaK0YrEazPpx1aA4HjLl/bzZul7buaqHRpV3iKEWauWzT6YZUGSUnkNWnG7sMHKSvbQVbW2ab2M1WNRVGGNj29Afn5UqkieXs5x0d+yxTScHaSyQAAZxBJREFUD50OPIDThpmW10OkX8Wt7D98hDSBF9WGjtiZHFOrdJVeiIPaM0WZUFUvd4fZ6xIqAWykhNu+UenjWOSLsYLVOer0NRAIBAJBzLAseshhLW+99RY7duzgyiuvZMaMGYwYMYLGjRs70UeBIGExCh/Ry1EQi8Tx6ndXs++ySqNamZsDjL/K6+USmTgR+vTR3sfjgR93Qbv8QNtE6UUzdy5UVUGPHubzT2htpzyvo0dh3jx9kUGmxgeTJgYa8GrjvqgIOnY0H/KhZfgPGRpcJVOJetzDqeDiVOJcsJarw8l+hEt+Vja7Dx+kdO92OnW6jGPHqsjMrAstKS/3kp7eIEDECFmN5VgVmZl12ycnJzF58vkBbWdnpzFjxqVS2//6TfQMM73wACNj2AxW9x8xQsrhYWYymH2Iap1bbq62obx5s3FCVflmnTsX/9PC55NuQLPKdmEhTPwD4IIuXey/puHcUIksBIQzR+PxoSMQCASCiLEsenTp0oVLLrmEMWPGcOutt5JTG+MsEAiCseoNEWn+j1gJJn36wMmT5r/K6+Wb6KLjiSCPS6UPkl11tolaOPEBL8+TRIqxYyPzolGKBWZT8SkNeAg27hcvljzBrVwbrSqZytK2SlwEjnskyUCd+ohrNVdHvH1MLmiRw3+2bWbPrh9Me28YVmOZ3iNANJFJTk4KEELkdgD7DLNQD4xQiR0jMYbD2d/MZDCbw0Hv3GbN1DaU8YVOqFpYKCXu9Oe1CKNkktNVQ8K5oRJJCFDP6XDmaLw9dAQCgUAQMZZFjy1bttCxY0cn+iIQ1EuUXgMzZwZ6DCi/ykdarcKOhKmRiCZa78VGhR2UYpDbJXkw6PVJa1xmztL3ovERPHZWzk19TC0vD1kIUa+TDXifz75EnOp38KHDtL09XK46wQX0BYbNm6FJk9hUk7SzpG0saNdK6uien7aya6957w3daizZaeF1JFLDzIyRHSo8QM8YNnuz2W1MW6m+oXduGzdpJ+ns0jV0QlU7k4XGW9WQRBAC9OZ0ogg2AoFAIHAMy6KHEDzOTGLhQVCfMOMNEUm1CjvKe9ohmijfi0O1J7+LLv9A8lxYskT6qd5Ob1y8p6Rtleet3kYeO6vnZqaU7333QYscKaRFz4APx7g3c68NuV5b9KjxBc4XLYHB7aoT36KRV0Z9PtHO1WH3s6vD2XkAHD7ykyXvDd1qLLVeIlHFrJFtJjxAbQxb9Viw05i2IjroVYV5bX5dWVZ1LFpxkRTSokQ5HuGG/CR61RDlTda8eez6YDSnE2EcBQKBQOAYYVdvEZw5yInsp04LTmR/JmKlWogadXUOpS0QSbUKI8HEDHqiSbgVZqy0pwzV0NpOb1wOH5HeZ2c9o90Heey0+vLSS/DDVv3+G1Wmkdvu0gU6ddSvkCIb91aqp7y/xNy9lpUlVYrRO2fldso+qJOgRnqdQ6H37DC6D6Jx/EgoyJVCOg8c3O333lCi5b1hWI1lyrqgqi6Oo2dkf/ZZ4GSQJ5C71mMlVHhApBVdIsVK9Q31uSmRy7KqPQOGj4DiUXXHUI+H1fEKp9/xhlGlm2gSqnqOQCAQCM5oLHt6CM4s7PAgqE/Y7Q2hXh7uF/BIQwYi8TKJpD0z26nHxUVwBZzfjpXyB8pNuV11Y7dhg3bZV3XSUSVa4TeyWJDkhpEjpb6Dsfe0Fc/q99+HhSWBfTS610aMAFywqETa1mi+1Mg2qEbVl0iusxGhnh1Of3x16tlVUJvH6uDRMvbtO2rKe8OwGkt+OunpUf5TbOTlsGBB4I1hZRLH2mPBag4H+dw++0w6d6N+y94MffsaJ1Q9U5KFejyweZMqcWutyNWlPTTWKKus3t9OF6xIE+sKBAKBoF4jRA+BIXYbw9HAqVAcO4yoUH0LN/w40pABu/MsmG3P7HYDB0JZGbz1bqDRLl+D+bW22ubN0nJl4QO9Cjqhrp9WAtF9+2DrtjqhQSl8KdvQCukwwuOBkpLg5aHutRHDoe/l+ikVUtMCSwNrRew4lU8j1s8Op46f26wZKQ2S8VZVMmXKXzl4MJOcnLSAnB5TpqxjxoxL/SEuIauxJGt4GziJ2shWohXqYlah0ivbmhqcqNUxrD5Es7Kgd2/pAaJnMEcjZCdUv+MpxlQ5Hmp81dLDunGBuf3tStqaiMKRQCAQCKJG2KKHx+OhYcOGNGnSxM7+COKMREs6aIcnhh6RGlFm+xbuF/BI8rXZnWfBbHtmt3t/Cfz5Xe1jydege3dJ7JA9MNTH0Mr9Eer6Ka+FxyOF1MiCB2gLJ+HMwb17tQUJtyv0vaaXUkE+vlZuEnm51njbZVvF+tnh1PFdLhdtmjZnq6eUrKwjNGjQypT3hmE1llhgxcvBLFpiiq8GJk6quxE8Htj1I+S3c84gtfoQNTKYo5lkVK/fVirSOC2MqMdDjSsJjKr6OTmeTiUtjSfBSSAQCARhYUn0OHz4MFOnTuWdd97h0KFDAGRnZzNq1CgefPBBzjorhDujIOGIdtLBSPAcdDYUJxIjyuMJDL8w07dw3rMiCRmw+33RbHtmPnAuKtE/jnwNjMSGgQOhbYFx0lEjlG2rUQon4XoD6XmjFBVb8yLatDn4+GqS3FLlG++p4PG2UzSM9bPDyePnZ2Wz1VNKv8t99OpzaXx4b4SDGS8Hq8huWe/+uW6ZbNieOA4li8BXCa5k57PoWkHvQRTrkB2zIkG0St5qjYeMOwl+8xspmam3wvz+eqFE4YgMdsfNRWtcBQKBQOAopkWP8vJyevXqxZ49e7jtttvo2rUrABs3buTFF1/ko48+4tNPP2XDhg188cUX/O53v3Os04LokigV3/btc9adPhIjavkH1nIpOOmxYoTd74tm25O3k5PEKt91jSqpyLk7QFtsSDsLutaGunTqKIkIZnJgQHCIiF4flMKJUYlYeXHXLsHH1MohUlQkha+YwUiUgWDPjk4aRbicyIFh17MjXBvIqWdX25wc2PxfDpTuCPLWiKn3RjjYHRbg8cB77wUvr6muFTwSrCxrrHNFmBUJouWNojceEydKrnbNm8OJw9b3DzeUyEkSoZSwQCAQCExhWvR47LHHaNiwIdu3bydH5br42GOPMXDgQH7961+zcuVKXnjhBds7KogtTicdtIOWLZ13pw/HiPJ4pAolavRCF+pj8lgzRque0KPnBTF4ENxyi9SeVrJSdbJTqBM8XEjJSJXv0so+rl9f1xcX2qEnECyc5OUFb++irkSs/PvYscHv8eEa6Or5otVHLc8O9TVxKgdGpM+OSAVAJ55d7fKkG7ds33Z7G44VdqpDup4Arvgqy2pWSYt1rggzoosd3iiRjkefPtJ6X4ha3/ESSmSGWHv5CAQCgcA2TIseS5cu5ZVXXgkSPAByc3OZOXMm11xzDQ8//DBFRUW2dlIgMENW8+i401s1ovQ8FYYO027HbuMz1uHIZoxWI6Fn/frA92gXUtVIpReEltggI7dVUxOY0HPxYqkIQ1ZWcB+VVU70cm1MmhSYMBWkvmrhU/1/7lzt9/hwDHQjTxg9zw6ta1JYGH/5e+JVAOzQWhqU/ft3xq4TdmOXOqRXGeammyQPkHiormHVm0BPFAr34WplPzOiS6TeKHaNh1niNZRITay9fAQCgUBgG6ZFj3379nHuuefqru/WrRtut5uHH37Ylo4JBOEQj6E4erlAhlxvbftw3rNiFSYjY9ZoNQoLUVYfAXC5pIolSvTEBmVbWsv27ZP+HyoPhpqioroPmzL+j5SKZXqJRH1I56ZuIxRatpLWfNETZZT9VF+T+fPjL39PrCvA6NEuNxeA/eW7Y9eJeEVtpLvcUFwEw0dICS5jXV0jXG8CtSgUbhhGuPvJdadrNB5mkXij2DUeVonHUCI1sfbyEQgEAoFtmBY9srKy2LlzJ2effbbm+h07dtCiRQvbOiYQhEu8heJYzQVidvtQHwvj4Su5kZjRpEld3/WEHh/apWY1w9kN+pHkDvT0kJe1bGnsKaFHR42cGFrthAqPsYKegKU3X/QEFaNr4rRoaPXDeKwrwOhRUOvxeOTEQbzek6SknAFJvK1cPL2JJC/fvQPaFCRWyILy/EFbKChoCxWnQj+UrQgM8j5K3zOtfcK9eWPpXaFV2zveRIbCQpj4B8ClrSILBAKBICEwLXoMGjSIqVOn8tFHH9GwYcOAdV6vlwcffJDBgwfb3kGBoD5g9X001PZmPDji4Su5nheCnONC2Xctw71rl9BGr55ooU7eefw4LFqkncRUq4+gX/1Ey+jWM9BvuCG43K4L6f3ZLKEELCvzSy9HysyZcPJknZBitl9m7eBwvI6sCobRolnjxqQ3TOXY6VOUle2kTZtzYtshpwnHO0FPfc7KgvRGkJLmTF/1kCdrWqp1bwLl+eOCPr21hYI/TAR8+mMUjsBgdZ9QOTXUxMq7Qm9OxZO7ZjwlVRUIBAJBRFhKZHrxxRfTsWNHxowZQ5cuXfD5fGzatIk//vGPeL1eFi9e7GRfBYKExqoHit72Zj044uEruZbRqvS4UPZd7103YH+Xdji71nkqk3euX18neLhdMLKo7t1Vz7CW+7J1GyxeFNro1mtn4EBo1AhKSgKFnkjzwqgFLLPzS91PGR/WPIGsiBjhlGyWiScbSMblctEmM4v/lf7M/v31XPSIt+SS4aA2Xvv3h9WrzXkTqM8fH3z6qc6Bame43hiZERjUSqJZUSJcAz0W3hWh5lQ8uGvWh3kvEAgEAj+mRY+zzz6bNWvWcO+99/LAAw/gq/2a4HK5uPrqq5k7dy5t2rRxrKMCgUDCrAdHPHwl93ggN7dOgDh8RPIo0Ou71ruu0uht2hxa5wUfZ+gwWL4s8Dzl5J1aItHiRVJeELXXvdqwzsqC7t2lbc0Y3XrtjBghJU0N13C3W8AaOFAq52t0LYywGjpltWSzmniwgdS0ycrmf6U/s+/nbXBxrHvjIPGWXNIqWsbr6tUwayac8oa+IXWr0SjQStyqNUahBAY94SKUKBGpgR5tZTER5lQi9FEgEAgEpjEtegAUFBTwj3/8g0OHDrF161YAOnToQGZmpiOdEwgEwVgxgGP5ldzOCiGy0Vvh1T+GC/jFYLj5ZnNJUpd/AHeMCj6G0fHNYOTVH27YiBMC1oH9wcvMCilWQqeslmxOFNrl5sL3UPrz1lh3xVniLbmkVfSM11NeSdEMhV41GpnRd8I5XWHipMBtXG44cli6Aczk3jASLkI9yCMx0JUPGzPjYQeJMKcSoY8CgUAgMI07nJ2aNWtGjx496NGjhxA8BIIoIxvASbV3r5nEqN27Rycn3YYN0k89TwCQKp/IOTMiMd7Vx/AB/1gBn3wSuJ0sEqlZtlRqI95YuRJGj4ap06SfK1dKywcOlCqsTH9S+hlJaLnHI4X7qBlZZC3BqBI9wcRqyeZEoX0r6WTLSn+McU8cRn7guJOk3+0Kf1A+MJxENl6VWDFe5fNXtwHSsnO6QsdOgWNEbd3rmTMDb2Jlm+qHsp5wsXmz/j6RnqP8sJk2VbufTuHUnLKTROijQCAQCExjydNDIBDEB/GW50Dt1TF0mL53xbKldZ4ZN9wQvvGuZ0wvWiSFkihDVIYOgyVLArdTV4GJB0KFjch93btX+hlu3/XGrmMHc/tb8TyxWrI5UehQG2e1/8DO2HYkGtj9wFn1MbwyPzoJIu3IWSGf/wfLYdlyqR2Q+j9xUl3/CwslkWLWLOuhJnoeJbNm1WUYtvMcY52zIt7+iGmRCH0UCAQCgSmE6CEQJBiReiNbLRsaah8tQ335suBSrW5XneBB7bo/vysl+Rwxwvp56FUh0RIzhlwPS5dol6w1QzhjFg6hwkbCqYCihR05QszaA/GQW8YJ5LK1+8t/inFPooRdiVU8Hpj3CtITgugY23YYr1lZMOoOqRa0XKUFgvvfpEl4oSbyjRKQNFWjfb2HkdXSqvGQsyIek/WoSYQ+CgQCgSAkQvQQCBKISI3ecPYPtY+eoT58eGBy0SFDg70tINgzwyxZWVBUDAsXBi7XMt6zsmDs2PAMb7uEBjMYiRFWk4caYZcQYdYeqI8fTNu2aAHASe8xjh8/TOPGTWPboURh716gBkiqWxYNY9su47XiFEFpeZX9jyQXxMCBcFZacIZhuf3167UTnYZTucVsP6Ol+BodMxZ9SGTEeAkEAkEQQvQQCEwQD+8QkRq94exvZh+j8IUh19cZuhDo6SGjF2ZiZsxHDAd8deVojYz3cAxvO4UGMxiJERs2mE8eaga7hYhQ16u+fTBtnJZGZlpjyiuOs3//Tho3viDWXUoM8vIISicW6wSRVh7wocSCSMNpunTVbj81RTscpaBteGEqZvoZbhncSNAqL/yvf0W3D4lMLK6ZQCAQJABC9BAIQhDNL/1GWKmYYdf+ZvYJ5TWgbNusZ4aVMbdSDtaq4W21SolRCJBZm0pPjLC7bC3YJ0TEyz1iB1auVX5mFuV7jlNWtoN27S6ISv8Snqws+L974NXXrIkCTinPVo1EtVjgcsPQIYHbRKIo6okRFae0w1E2bgo/TMWon7HI+aF1zH+uqlsf7bwjiUas87QIBAJBHCNED4HAgGh/6TciUqM3nP3N7mP2Hd+MZ4bRmDdK125XNt7lghB22UVmz9/I6A9HENASI9avlwpCKKmpkZbHUmCIp3skUqxeq7YtWvDNnp3sq+9la5XYIT5cNQB69DIvCjj19TpcI1GZ2HTpMilub+mywH5FoihqPVA9Hm0PkHN0PEOsVKfR6mcscn5oHVNNtPOOJBLxkKdFIBAI4pSwStYKBGcKRl/6o438AdBsqVo79reyT1aWudK4I0bAa6/pl14Nd8z1Sr1Ggpnz1zP6jUr3Wq3S6bfNVMt9hNeencTTPRIJ4VyrgtxcAEp/3haFHsYBdpY4NfvA0BMm7Jj0RkaiGZYuc6ZfEDw+8sNIXUJVXS7XrtKqkZb6teuYamIdChXPxOKaCQQCQYIgPD0E9RY7Pkg6EVIQCZHmYQhnfyeSUOp9XPR44MjR4MovocbcSW+DUOdvZPT7fPbk4dArMRtue3YSb/dIuIQT/uUvW1v2o8O9iwNi5Tpv59dr9R+FSJKOxuKrut7DyKmHdKSlfu04Zr9+sHp19PqQyMTimgkEAkGCIEQPQb3ErhwDdlW5sJNI8zAo9zcrDEUjCaXymrmoEz6UY17h1e5zpPlOQmF0/qGMfjsEAb3yvOG2ZyfxeI+EQzjiTftW0sr9nt0O9y4OiJXrfCTChBK9EJlwjUS7+mUVvYeREw/pWJRd0jrm7bfXr9JPTlIfS2UJBAKBDQjRQ1DvsPurfzy+Q9jhxRJPySfV10wWOyZOhC5d6s7x41Uw/5XgPsfS2yCU0W9XaVhlOzLxIjDI98jmzdK169oltv0Jh3DEG7ls7YFDP+Hz+XC5XFHqbQyIpZEf6ddrIy+VcB/wZ8pX9Wgo3qGOGYs+JDJivAQCgSCIhBM9XnrpJWbNmkVpaSnnn38+L774Ij169NDd/t133+XBBx9k586ddOzYkRkzZnDNNdf41/t8Ph5++GH+3//7fxw+fJjevXvz8ssv07FjR/825eXl/Pa3v+WDDz7A7XZzww038Pzzz9O4cWP/Nhs2bGDMmDF8+eWXZGdn89vf/pb77rvPmUEQGOLEV/94eoewQ6yIt+STetcsIyPQK+WVeZIHCAT3uX9/WPXPuv379YveuRjZTXaJZsp2UlLBe0r6eapCGptIztWqiKa1/fr18SOihYvVa5XfogUuXHgrT3HkyAGaNm0RnY7GArWRr1W1xCkGDpRKs27cJCXu7NjJ2v6hvFTCfcDHoyIuEAgEAoEgiIRKZPrOO+8wYcIEHn74YdavX8/555/PoEGD2L9/v+b2n3/+Ob/85S8ZPXo033zzDcOGDWPYsGF8//33/m1mzpzJCy+8wLx581i7di2NGjVi0KBBnDp1yr/Nbbfdxv/+9z8++ugj/vrXv/LJJ59w9913+9cfPXqUgQMHkp+fz9dff82sWbN45JFHePXVV50bDIEu8ld/JbEOAbCLcJItyhVNlNuEm3xSqy07MHPN9u4FdV5/uc8eD/zrX4HrVq92NsGneiyM8jKazdkYCrmdTh2l8540MfLErVYTwGptb1fC1njAyrVKSU4mJz0DgLKyHQ73LA4YOFDKPjx8uPT7kiX2ZQ02YuVKmDgJXpsv/bR6PCcTPNp1c8capx7uAoFAIBDEAQnl6fHcc89x1113MWrUKADmzZvH3/72NxYsWMD9998ftP3zzz/P4MGDmTRpEgCPP/44H330EXPnzmXevHn4fD7mzJnDtGnTGDp0KACLFy8mJyeHpUuXcuutt7Jp0yZWrFjBl19+ycUXXwzAiy++yDXXXMMzzzxDXl4eb7zxBqdPn2bBggU0bNiQc889l2+//ZbnnnsuQBwxg8/nw6euS3kGEUnYhjx2zZtLXsZ//CNU+yDJBb/5DTRvHlzyM9HYs0c6JyVVNdKYNW8evL3fKwRJ4ZS/vrdsKXlMKEWEJBfk5uqPkV5b4aC+zmaumdRnHz5FilO5z1bHJVLsHItw8Hhg7ty661ftk/pz4YXWvf6ttKO3/R8m2jf+ifYMzM/MovTYYUr3badTJ32vw3qDzwdLluKfBb5qy5PP0jWWJ10Exwt4wPiqwZVUf/4o2IH8QJOfaBE80ORrm2j3scA64hqbx+dDjJVAEGMSRvQ4ffo0X3/9NQ888IB/mdvtZsCAAaxZs0ZznzVr1jBhwoSAZYMGDWLp0qUA7Nixg9LSUgYMGOBfn5GRQc+ePVmzZg233nora9asoWnTpn7BA2DAgAG43W7Wrl3L8OHDWbNmDX379qVhw4YBx5kxYwaHDh2iWbNmQX3zer14vV7/70ePHgXg8IkT1JyhD8Z//lP6iCgbknfeCVdeaX7/Cq8Xb1UVAD16Q/suUFYGOTnSu+3hE450O6o0agrVBIsVZ2UEn9/BgzDnpcBtn/+jNC7Nm0PRnVLpWFlkGDUaGqRpj1Ootqygd51DXbMGaXD7KC+vl1QF9fk05sdFfV6lpZJwIp+H1jKnxiJctvwIXtWySh/8sEMaD6fa0dv+hDe88ddCeR8nAq2aN4dd29j14385cfEvYt0d5/lxC0GzwFcJO36ANHOvFF5vBVVV6pnk3PEA6N0DurQPfMCcOGx+f7sJ9aCJdHsr/XhpDgF37x+fl8YqjOP4fD5OnDjC6dMVpKSk1e88N2c4lu7jM5zqaqioOBrrbggEZzQJI3p4PB6qq6vJyckJWJ6Tk8PmzZs19yktLdXcvrS01L9eXma0TYsWgXHaDRo0IDMzM2CbgoKCoDbkdVqix1NPPcWjjz4atPzU6dMkJyVpnk995mA5vDq/7rWrBun3Tl2heaa5Nk6dPh3w+1mNoaA27UpFPfm7fFZjGDkKShbWiQa/LpaWq89x50+gNh1rfLDrZ2n7Xr2l8d2/H1q0kMZZb5z+u9G4LbOEus5nNYYmp6W+V5wOvvY9Lz1Nt26BfV7xUd14yBiNi9yPlR/BhyukxJtuoFhyIAsY2+JRcEXfwH1DjWs0yKgdF/U5N2kWeq4fLK+z+6y2o7f92fnm56VeX+Rrrb6P451W2ZK3QdnebXi9FTHuTRTIzKj9j2oWNGsCJs//9OlToTey8Xh+Gp8FjWv/VsfyWn3yb1hYgv9uGVUMfa+wb3sr/LSToCearwZ+3iWNl0z5wbqbNVNfDPH5fJw+XcHp01683gohetRjLN3HZzjV1VBZKcZLIIglCSN61DceeOCBAC+Uo0eP0rp1a3KbNaPJWWcZ7Fk/OfAzJGss91VAS5OiR4XXS1pKiq39ikduHQYD+oTOnZfcGdII/vp+XifIqh3TlplAB+PjrVwJC14G9ciq2zJDqOscKmykwuslLTcFOkhe75s2wpsLA9t0A7OekfJe6J2PfIyGiuVvLZR+Ktt6u0Qaa+UYrymzZywioWUmTBgTGA50773QzcS1VI+vlXaMjtutg7l5adSXgQMT7z4+v0MBfAiHD5WRmVkPEgeFIrMljJkQGCpy773QoZvpJrxeyQsgWseLK7b+AAvfJOBJU/I29BmgH1O28C3z21ulczJBfylcSdDpPMisbd9C+IvP5yMlJQ2vt4LMzJZC9KjHWLqPz3Cqq6FJk0ax7oZAcEaTMKJHVlYWSUlJlJWVBSwvKysjNzdXc5/c3FzD7eWfZWVltFQkNCsrK+OCCy7wb6NOlFpVVUV5eXlAO1rHUR5DTUpKCikaL/Yul+uMfElo1UoyoNQlR/PywOxwnEljl50t/Qu1zdixwSU4Q+2nxOOR9oe6qikQXltgfJ0PHqy1a2qP5QNefhkuuqju3V6+xsoKNuq++YDTXu15I5+PT7WPvJ+6rRofbNkiGfJ5edKyxYuD9y0qtj4WkTJokDQ2ZkUG9bnL4zt/vhTmZLYdo+OamZdGfbnoImiUnlj3cfs86W/H/oO7E6rfEWF18qkIeFabSeQU4fHiBr94AAFPEV+NFLqidfPs20fQE8toe6so/1AoS+/Kbfv/CCjuVvWDWYV8fc+kv8lnIuL6msflQoyVQBBjEkb0aNiwIRdddBGrVq1i2LBhANTU1LBq1SrGjh2ruU+vXr1YtWoV48aN8y/76KOP6NWrFwAFBQXk5uayatUqv8hx9OhR1q5dy29+8xt/G4cPH+brr7/moosuAuCf//wnNTU19OzZ07/N1KlTqaysJDk52X+czp07a4a2CIJRVkNUGuiJ+m4bL0RaUVGrygvAxInQp4/1/qivs9sFI0dKyzdsMFdqWF0pRI1RpR6984G66jHK9S5g1qy6MqxDh2nv37FDsO0WSVJes5iptCn348hR/fG1Wnwi0hLORtWDOqSH324sKKgNZfQc3kN1dTVJZ0p4oh11vGURwFcjVVcxSqAZT3XDw0F+cKlL54JxJRm58oxyP7sqz8gUFsLEPwAu6NIlcJxDlfsVCAQCgSABSBjRA2DChAkUFRVx8cUX06NHD+bMmcOJEyf81VxGjhxJq1ateOqppwD4/e9/zxVXXMGzzz7Ltddey9tvv81XX33lLyXrcrkYN24cTzzxBB07dqSgoIAHH3yQvLw8v7DStWtXBg8ezF133cW8efOorKxk7Nix3HrrreTVfvr91a9+xaOPPsro0aOZPHky33//Pc8//zyzZ8+O/iAlMJEa6AJtIrEV5FKyas+MLl3C78/AgXD8BCwqkdpdtAgaN5auvdax1O/2RsJFKLFM63xAWjZmjPR/WZCRPRDkvMI1Pli6pG658phbt8K0aXXiSP/+Ugld+XerxRDsEkzUHjFqYlXKWXte+WiedgTJ1V7CW15Og/R0kpK1gqLig7ObN6eB201VTRXl5XvJzm4d6y4lBmoRwFcj3XyFhYn98Ne7ebXEA5AEDaOHllIpVnpi2DVGoYSnaIguAoFAIBA4TEKJHrfccgsHDhzgoYceorS0lAsuuIAVK1b4k4bu3r0bt9vt3/6yyy7jzTffZNq0aUyZMoWOHTuydOlSunWriwW+7777OHHiBHfffTeHDx+mT58+rFixgtTUVP82b7zxBmPHjuWqq67C7XZzww038MILL/jXZ2RksHLlSsaMGcNFF11EVlYWDz30kOVytYLE/5gXD9jpYeCEB47HUyd4gPTzj3+UwiyKiuvW6R1LT4iZODH4I6WZ8xkyFIZcX7dfYSEs/wCWLAne3wd0Oxe+/1/dsl69JOFGeT6r/lm3Xj4/s7acUqiQBZPCQuvXNJRHDMDVV5try26Cr4OP69r8la0zltP9kUdIa9WKigMHWDdlCun5+Zw/eXLcCh9JSUm0yshk1yEPZWU7hOhhlvroQfD++1BSAviCBQQt8cDlhmdmQcdOxu069UXAjPDktOgiEAgEAkEUcPlE4ei44OjRo2RkZHDk7bfPyESmdpBoCRCdQMtgtuJhoIfHY9/79oYNMHVa8PLhw2HZUqnvLqC4GEaMCNxGvsYrVwYLMVY9KTZvlkSMriqhxOOB0aONxQIlWp4jWkx/UgojCdUv9bHdLsnbxIe1a6o3zmrsnCdWkedV87TDbJ0xiYqyMtwtWnDJhAlsmD2birIy0nJyuHTGDFIyo5QlNgyumDCZT7Zt4ve/XchVVxfHujtxj9dbQcqxE9JkV3sQzJ+fmAb1kvdh4cLAZerzkR9cSvEgFjeezIYNMG1q8PInpwc/rEz+EZBK1h4WiUzPAEQiU/NUV8PmzUd54IEMjhw5QpMmTWLdJYHgjCOhPD0EAoE+6i/7Vj0MjLDTAyc1TdtTY+mSurARH1LC0L59tY+r9+EzlJeLvH7btjrvDLXRbxQ+ow5tAXOCh9kwEq1jK3+3ck31QnnU6LUZ3ZwkTWk2fTrrpkzhcFkZa++/H4C0nBx6TJ8e14IHQNsWLfhk2yZKf94a664kDvXJg8DjgZJFwcvVnivxFsNpJXRFuGEKBAKBIIERoodAUE8wSg4ZL++qWjkm5BATdThJqL6r38FDebno5bdQG/1GeT+U4TdG9L4MvvjCekiQGaHC7DXVShore4yEatMpjyEj0rKzOW/8eD6pFTwAzhs/nrRol8UJg3atJCOxdO/2GPckjlGqaOm1pRvjTQQIF6N8HWoBIZ7EAzuFJ/n6tmwJaeLVUiAQCATxhfjLJBDUE/RyXcRLvjmtHBNuF8ycBZnN6kJbZKz0PZSXS6j8FkqjX0ssGDqsLu9H40aB67TavPZauPNO67ac+thauF3mx0VtU5Yfgi/XwdvvBG6nHGsnPYaMqDhwgA2q5M8bZs+mx/TpcS98dDhbSmq9f/+OGPckTlEny7znTrjmemldPIkA4aLlMQFQVBQf52bktmWH8KS8vrjgziLo3cuWrgsEAoFAYAdC9BAI6gnxXvZXL3Rjfxl06hhZ30N5uRiFrECwwGJkByjXpaTCpInaYk24tpzc/mefwfzXgtcPHRZeedn3l9R5qajDdPr1q2szFh5D3vJy1k2ZIuXwUOX0WDdlStzn9GjXMheA/Qd3x7gnUcJsHFlthbOgZJmvvAo9epmbUNGIs4oUtceEyw3FRTB8ROh9ncZMWeBIhKegUrw18Npr0LUTZMaJ4i4QCASCMx4heggEOsTzu7Ze3+LZW1wvdGPWLDh5MrK+h/JyMQob0RNYjOwA5TojscbqHFJu37s3LFigEQp0feh21Lz/PiwsqftdPQyrV8Ptt+uH9zjtMdQgPZ30/HwAuj/yCM1ataJHbY6P9Px8GqSnO3dwGyiorSBWfmw/lZWnSU5uGOMeOUgoI1q9ftjQYA8In8kqLWYM9nghHh++dpQFDvUQ0wrt8VXD/v3QIbLuCwQCgUBgF0L0EAg0CDenQTSEklB9i1dvcfljqDrMRB0+EU7fQ3m5aK0fWQQdO0Run8i2jrIaDFifQ1rb2+G54/HUVtE0wCi8JxoeQ0nJyZw/eTJVx45R00jK95CWnc2lM2bQID09bsvVyuQ0bUpKg2S8VZV4PD/RsmX7WHfJGUIZ0Vrrly7TKNWaBEcOS9vrTSyzBns8qdPx9vCNtCywGdFJsxRvErRoEXn/BQKBQCCwCSF6CAQqws1pEI3kj7HKt2AXAwdC2lkwc2bgcjvCJ0J9aLX6IdasLeXxwPIP6nKSaCU8DXWd9K7r/PnSv0g+Hu/dq528VImV8B6nSEpOJikzkwqv178snkNalLhcLto0bc5WTyllZTvqr+gRyojW/OpfU1uPenld6IevSnoIGHlvmDHYnfQEiScxJVysVGdRY1Z0CgrtSYLRoyCzub3nIhAIBAJBBAjRQyBQEU5Og2iJEYlQoSWUrdC1i3PhE6E+tJr9EGtWwFq5EubODRQVanzaFV6MrpPRde3ePbJrm5enXWpXJpzwnngllnZqflY2Wz2llO7ZBhcMiO7B7SLUAIYyovXWXz9E+rd5c63iWTsbjcItQh3LjtANPRIprMaISKqzWPESUaqkublS9RZvhX3nIRAIBAJBhLhj3QGBIN6QcxooCWWUGxmtse5bpHg8sGGD9DMUK1fC6NEwdZr0c+XK4G3k9/Ck2qdPvCVc1ROw1Ofvt7k02pCThSoxuk561/XwEXPjbkRWFhQXBy93u2DyfZInSSLac2rMzD0naVub12Pfz9uie2C7kAdw2tTQN687SfpdbUQbrc/KgiZNCLpjZEPa6rGMjPJI0BNTIr0RY8XAgdJN/uR0aze7LDopMfISycqKXKEVCAQCgcAhhKeHQKAinJwG0Ur+GO18C1ZCdqx4u8Qy55+ZvHxmvDSMKsIkuWHkSFi82Nx10iqTW1MjfRS3I1RqxAjAVeeBIvenSxfpPOQ+JCrxEPbVvpV0s5ft2x6dA9qJFa+JSOLI/N4b1XXLjAxpU22FEbphRKR5MKwSDfekcNy2IvESEQgEAoEgzhCih0CggVWjPJpiRLQEg1CGpPpd3WroTSzCJ8yIOGYFrNQ07bAR+doPHAh9+5q/TsqEqDNn1rVrlwE/Yjj0vbyuP+vXSx/0ncxBEy3iIeyrw9lSedYDB3ZF54B2YtXQDzeOzJ/N+EVpgpsxpEO1ZbdR7pSYokUswmisiCzxWJEmVtSHHC8CgUBwBiNED4FAB6tGeTTfD6MhGBgZkuvXB4sHhYXRL3VqBbPeAOoqM25XsC3lt1UU7btdMHSYVFJW6e1v5TrJEQBqISVcA17rPd3ng/JDsfeMsJNYlNlVU5ArhbfsL98dvYPaRTQN/YEDoVtXOHjYvtJJdj50o+Xh4GROEj3CEVniJblPLEWH+pLjRSAQCM5ghOghENhIvLwf2oGWIQnw7bfw3nvalUaiXerUCpF6A8jv3KlpwWV33S6Y9Qx06hh5P+0y4NVeLf37w7/+Vfe7U54RsbBNoh32pUVBbU6PIycO4vWeJCXlrOgdPFKiHcrQPAvyWtvTlhMP3Wgo2LEIo4m2yGIXdogO4T6YEnncBAKBQOBHiB4CgUCTrCwoKoKFJYHLlYKHjGwwx7M3tFkxQcsjZO5ccLn0BYMaH3hP2dNPOwx4rXNY9c/A/qqxwzMiGmWb9Yj13GvWuDHpDVM5dvoUZWU7adPmnOh2IFJiPYCxQs8YdlrBjqZ3DURfZLELO0SHSESTRB03gUAgEAQgRA+B4Awm1MevDh2Cl8mVSZR2s9JgdsJWkPvZLAta54XXhlkxQcsjxIcUFgLOCQZKIrU/jZKsKpEFHDs8I+IhmWgsPa1cLhdtMrP4X+nPlJXtSDzRAxLPVS1St6JYhi1E27sm2iKLXUQqOkQqmiTquAkEAoEgACF6CARnKJEk9bRSmcTOfvqA340N3y5RigkpqXCqQnonVheF0PLmUBOOYGDFRovE/jRzDklumDlL8lCx48N+PCQTjTX5WS34X+nPlO7ZBpfEujf1nEgFi3gIW9BTN52IEUvUaiyRig6RiiaJOm4CgUAgCECIHgLBGYjVpJ5q7wijyiRa7+uRhlP7+0nkdklWlnYiVtleUp+z2yV5eag9W6wKBtEM/dC6bv36werVgdfRjhwkMvGQTDTWFOTmwPdQ+vO2WHelfmOHYBEvYQtqddNJ75NEDGGKVHSww1MjEcdNIBAIBAEI0UMgOAOx8lVe731PyxNBy7A/fgIWlYRn7DvhPWBG8FGf8/r1wcKPFcEgFqEfWtft9tude2+Ph2SisaZ9K8mQKiv9McY9qefYIVjEY9hCNLxPEi2ECSITHezy1EjEcRMIBAKBHyF6CARnIFa/ypt539My7F+cG7iNVWPfCe+BUEKK0iule3dpvRM5NkKJN3Z4uKuvm9Pv7Wf6B9EOtQln9h/YGduO1HfsECziMWzBrJiz9Qf430Y49xzo2Em7LbtCZGJZKlZJJA+vM/3BJBAIBAIheggEZyJaX+VHjpTebeX1VjGbPNOKp0ZQP12R2yVGQopRCIrdOTaMxJtYVkGJlDP5g6hctnZ/+U8x7kk9xy7BIt6MYTNizpw58M9Vdb9feRWMGxfYjl0hMrFM9KpFJALMmfxgEggEAoEQPQSCMxXl+/7WbeGHoMhYSQAaTjj15s1wqhIu6G6tX2r0wjDAXAhKOO/dVkI/tDxmXnoJ2hbYm4NDYD9tW7QA4KT3GMePH6Zx46ax7VB9RL4BCwth/vzIBYt4MoZDiTlbfwgUPED6/dpr6jw+7AqRiYdEr0riTYARCAQCQUIhRA+B4AxGfnedNi3yfBNmEoACFBUHh5GEOo6ceLTSB8k2eD5ofeDdsCF0CEokHhhmPypreczU+GDiH2BsBJVrBM7TOC2N5mc15uDJ45SV7aBx4wtj3aX6RTQN31iFdRQWSjc7LujSJfDY/9uovc/GTXWih10JWuMl0SvEnwAjEAgEgoRDiB4CQRwTjfduO5OFGiUAdbugqAhGDLcmHoSbBDTU2Kk/8IYKQbEjGamZj8p6HjM+xHt+IpCfmcXBk8fZv38n7dsL0cMWPB7YvCl6hm+svApCHffcc7T3O6dr3f/tStAaT4le40mAEQgEAkFC4o51BwQCgTYrV8Lo0TB1mvRz5UpnjiMb2UoiSRaalSUlAM3Kkt7X58+H6U/Ca6/BiBH64oHHo92ekSijRzhjJ3uqJNU+FdUhKOH0IxzkfqiviZXjeTyS54remAqcIz9bCnH5eecWysu9AevKy71UVlbHoluJi3wzz5ypb/jaiZ5XgdM3k5njduwk5fBQcuVVgclM/Q+QJOn3SKqV2NGOHcgCjJJYV9oRCAQCQUIhPD0EgjgkmiVOnS41qvZusOpZYjUJaCRjZxSC4kQlGaN+tC2QvNyVQ2XmeImcBLU+UJCbC8CqlV+y8p9fMH16D7Kz0zhwoIIpU9aRn5/O5Mnnk5ycFOOeJgBqIUCNE4ZvrLwKzB533Dgph8fGTZKHh1b1FrsStMZLotdoVNqJlyo1AoFAIHAEIXoIBHGInSEnZojmu2045XKtiDKRjp1eCIrT4pCaTh2lHB7K8KCRI0OH9ERLLBNoI5etPXZ0N8cqJaFj/PjzmD17A2VlFdK6Y1VkZgrRIyRaQoCMU54HWmEdLjekpth7HDPHdSdJx92wIdAY79hJv1StjF0JWuMl0auTf6REklSBQCCo9wjRQyCIQ6LpVSATrXfbcMQD+X13x24oaGO8rZNjF+0PnwMHwvETdZV1Fi2Cxo3138ejLZYJgmnfSppojZsc4qwGaZSVVXD//WsByMlJY/r0HmRmOmxA1xf0BIhJk4KTfNqF2qsApONPnOSsMazlzdCvn3RcYYxLOPFHSiRJFQgEgjMCkdNDIIhDQuWXSHSUuT7mzzf3Hp+VBd3ODT0GTo6d7AEdLU9vj6dO8IDQ+U9S07SXp6Q60r16RXVlJd7y8oBl3vJyqisrLbVTkJMDQPnRPYwbF1hfefz488jO1rlIgmC08kqMGQN9+jh3A3o8kJsLU6cE5pGIRm4P+cH45HSYNRP+9S/jHB8ieU/kGIUVCQQCgaDeIDw9BII4JV7CqZ3CSc8SJ8bO7lwZsoCSmganKrRDya16bpyq0D6W91T4/bRCoobFV1dW8t2MGRzbtYse06eTlp1NxYEDrJsyhfT8fM6fPJmk5GRTbbXJzsaFC2/lKZ577hOgTnGaPXuDP8eHwCTRfBCqwxxikdtDfjBu2GB8fBGSYQ/xVKVGIBAIBI4hRA+BII6Jl3DqRMTOsbM7V4ZSQJHRElKshurEIixKJpETqFYdO8axXbuoKCtj3ZQpnDd+PBtmz6airMy/Pikz01RbKcnJtGjchLLjRzhwYCc5ORcG5PSYMmUdM2ZcKkJcrBCNB6FWmIOaaBrDRsa4CMmwj2gkSRUIBAJBzBHhLQKBQBACO8vVqgUUGa3QFauhOrEKi7JahjjeSMnMlDw8cnKoKCtj7f33U1FWRlpODj2mTyfFpOAhk988G4Am6eVMn96Dc85pxvTpPcjJSSM/P5309Dj73iDCJPSTpsohLtE2ho1KxoqQDHtRhhWZjbcUCAQCQUIRZ29eAoEgEhI1vCDesdODQktAkdEKXbHq3R+LsKj6kEA1LTub88aPZ+399/uXnTd+PGnZ2ZbbKsjJYd2ubQzohz+UJTs7jRkzLiU9vUF8lasVYRISep4Vs2bCKW9sYgz1bmYRkmE/wq1SIBAI6jXC00MgqCesXAmjR8PUadLPlStj3aPwiMePznZ6UMgCihZ6QkpWFnTvbv54VrePFK1zilZYjV1UHDjAhtmzA5ZtmD2bigMHLLfVrmUuAEcO7QxYnpmZEl+Ch16YhB03XzzeyEboeVZ07BTdm0mrX+rjG3mBCAQCgUAgCEJ4eggE9QC7c07EinjOC2GXB4W6ZK9MIlfoCacMcTzhLS9n3ZQp/pAWZU6PdVOmcOmMGZZCXDq0zgNgf9kOp7psD0ZhEpFcvET1Hkmk7NGx7qtwKxQIBAJBAiFED4GgHuB0eEE03m8TQbixywNaaa+kpErVVeLdxgpFrG2wSGiQnk56fj6Av3pLj+nT/dVbGqSnW2qvfZ7k4rL/4E+299VWnAiTSPQkm/EW5mD08I1VXxNV1BIIBALBGYsQPQSCGGC3iOBk1Y5oeV84JdzE6wfJeLOt7CBRzykpOZnzJ0+m6tgxv0dHWnY2l86YQYP0dNPlamXatmgBgOfwHqqrq0lKiqOQFiVOVK5wynvkTCQexYVEF7UEAoFAcEYiRA+BIMo4ISI4FV4QTe8LJ4SbeA6XEcQXScnJQWVprVZtkTm7eXMauN1U1VRRXr6X7OzWdnTRGex20RFJNu0hXsUFIWoJBAKBIAERiUwFgijiZGlPuere9Cftq7pnZ6nWUNhdbjXRy6gKEpekpCRaZUiCSVm85/UAezPfiiSb9hCvZWllUUuJELUEAoFAEOcITw+BIIo4nXvD7vACJ8NmtLDzo3N9KKMqSFzym2ez65CH0n3b6datb6y7E10SOcFLvBCvHjNOhEQJBAKBQOAwQvQQCKJItEWESLEjbMZqTg27hJtEG2tB/aIgJ4dPtm2i9Ketse5KbHAqwUu8Jumxm3gWF4SoJRAIBIIEQ4geAkEUScTSnpG838Yyp0YsBJtIOFNsuTOFdrUVXMr2/RjjntQj4jGxp5PEs7iQqFmLBQKBQHBGIkQPgSDKxPN7rB7hvN/GQwla9VgDbNhgTlhQCzZFxTBiuDP9FAlX6x/tz64tW7s/AXJ6JALxmtjTaYS4IBAIBAJBxAjRQyCIAWfCe2y85NSQx9qKsKAl2CxcCPhgxAh7+xcP4pDAftq1zAVg/8HdMe5JPSFWVUOEC5ZAIBAIBAmPqN4iEAgcQc6poSRWOTWsVnLREmwAFi2yv/pLNCvkCKJHQU4OAOVHy6isPB3j3tQDYlE1ZOVKGD0apk2Vfq5c6dyxBAKBQCAQOIYQPQQCgSPYXYI2EqwKC1qCDUht2C1GxJM4JLCPnKZNSW2QjA8fBw6cod4eHo8UT2aHUhjtUrh64TSi5rVAIBAIBAmHCG8RCASOES/5S6xWcsnKknJ4LFwYuNwJMSIRk9sKQuNyuWjdrDlbD5Syf/9O8vI6xLpL0cWJpKPRfKDEKpxGIBAIBAKB7QjRQyAQOEo85C8JR1gYMRzwSSEtNT5nxQgnbTmRkiB25DfPZuuBUkr3bIMLBsS6O9HDyaSj0XqgyOE0SuHD6XAagUAgEAgEjiBED4FAcEYQjrAwYgT07au9j91ighO2nKgKE1va5uTA5v+y7+dtse5KdKkPXhJKpbSm2vlwGoFAIBAIBI4hRA+BQHDGEI6woLVPIogJTlaFEd4j5mjfSvIKKNu3PcY9iTL1xUsiXuLzBAKBQCAQRETCJDItLy/ntttuo0mTJjRt2pTRo0dz/Phxw31OnTrFmDFjaN68OY0bN+aGG26grKwsYJvdu3dz7bXXctZZZ9GiRQsmTZpEVVWVf/3777/P1VdfTXZ2Nk2aNKFXr158+OGHAW088sgjuFyugH9dunSx7+QFAkHcYLUSTKxwqiqMXNBi6jRR0CIUHc7OA2D/gZ2x7Ui0iXbSUSfJyoLu3ROz7wKBQCAQCIAE8vS47bbb2LdvHx999BGVlZWMGjWKu+++mzfffFN3n/Hjx/O3v/2Nd999l4yMDMaOHcuIESP47LPPAKiurubaa68lNzeXzz//nH379jFy5EiSk5OZPn06AJ988glXX30106dPp2nTpixcuJDrr7+etWvXcuGFF/qPde655/Lxxx/7f2/QIGGGViAQWMBITIgnu8hq8lYzOOk9Uh9p1zIXgP3lZ2D1FuElIYgmwv1MIBAIBAYkhGW+adMmVqxYwZdffsnFF18MwIsvvsg111zDM888Q15eXtA+R44c4bXXXuPNN9/kyiuvBGDhwoV07dqVL774gksvvZSVK1eyceNGPv74Y3Jycrjgggt4/PHHmTx5Mo888ggNGzZkzpw5Ae1Onz6dZcuW8cEHHwSIHg0aNCA3N9e5QRAIBHGBE2KCEzhRFSZRBJ94oSAnB4CjJ8rxek+SknJWjHsUZeIhi3GiIox48zhRKUggEAgE9YqECG9Zs2YNTZs29QseAAMGDMDtdrN27VrNfb7++msqKysZMKAuY36XLl1o06YNa9as8bfbvXt3cmpfTAEGDRrE0aNH+d///qfZbk1NDceOHSMzMzNg+datW8nLy6Ndu3bcdttt7N5t/GXP6/Vy9OjRgH8CgSD+kcWEpNqnZzyXmB04EObPh+lPSj8jtQNkwUdJPAo+8ULTRo1Ib5gKQFnZzth2RpA4yDFk06aGjiHzeGDDhviLr4sWepWCztTxEAgEAoEmCeHpUVpaSosWLQKWNWjQgMzMTEpLS3X3adiwIU2bNg1YnpOT49+ntLQ0QPCQ18vrtHjmmWc4fvw4N998s39Zz549KSkpoXPnzuzbt49HH32Uyy+/nO+//5709HTNdp566ikeffTRoOUVXi/JSUma+wiMqfB6Y90FgcPEyzW+/Aro2g1KSyE3F7KaQ0V8dC2IRunQofYxFGkfG6XDnffAq69AtQ+SXDD6bmm5XecfL9fYLs5u1pxNZXv4+efN5OQUxLo7cYHXWxHrLsQvBz0w9wVANuKr4aUXoVtXaK5SVld9DPNeqd3WDf93D1wV29LIPp8Pr7eC06dP4fVW4HK5Qu8UCbt+BF9l4LKaati9A9IbOXvsMxxxH5unuhpOnxbjJRDEkpiKHvfffz8zZsz4/+3de3xU5Z3H8W9mSCYJcRJCLpNoCAnKzarcSozVKiUSLKtll91VXhQBs2gr2N2CtvIqyuqu9ValamFplwKtFaOsq+2K9QWC1FUuWhbkKkUuBkhmkgghIpDrs38MM81IEpKQ5MycfN6v17zCnPOcM78zzwzJ/OZ5fk+rbfbu3dtN0VzYypUr9cgjj+j3v/99SBLmlltuCf776quvVl5enrKzs/Xqq6+qqKio2XPNmzdPc+bMCd6vrq5WVlaW4lwuxblcXXcRNsdzZ3/h0sdZmf5bT3Prt6X80V1bqiFc+rgz5KSma6/vmD4vPyKXK87qcMIGz0ULKk9IipLU5MsPI+nzKikzq0m7SumXS0Pb/urX0uh8S4edGWNUX+9PXLpccV2f9MjOlaKiz18pqF+OxGusy/E+bpuGBikmpu7CDQF0GUuTHnPnztX06dNbbZObmyuPx6Py8vKQ7fX19Tp+/HiLdTQ8Ho9qa2tVVVUVMtrD5/MFj/F4PPrwww9Djgus7vLV8xYXF+uf/umftGrVqpApM81JSkrSwIED9emnn7bYxuVyyWWjP+wB9ByUami7HE+6tEvyHt1vdSiIBG1d7re0NLSN5B/h0NMK7DQtXtTYENkrBQEAuoylSY/U1FSlpqZesF1+fr6qqqq0detWjRw5UpK0fv16NTY2Ki8vr9ljRo4cqejoaK1bt06TJk2SJO3bt08lJSXKz88Pnvexxx5TeXl5cOTG2rVr5Xa7NXTo0OC5Xn75Zd11110qLi7WhAkTLhjvqVOndODAAU2dOvWCbQFEPmoOoiWBZWu93oMWR4KI0NYP8W1NjvQErBQEALiAiKjpMWTIEI0fP14zZ87UkiVLVFdXp9mzZ+uOO+4Irtxy7NgxjR07Vr/97W81evRoJSYmqqioSHPmzFFycrLcbrfuu+8+5efn69prr5UkjRs3TkOHDtXUqVP11FNPyev1av78+Zo1a1ZwFMbKlSs1bdo0Pffcc8rLywvW+oiLi1NiYqIk6f7779ett96q7OxslZaWasGCBXI6nZo8ebIFzxaA7hRYOKDR+It8snAAmrr83ByoiorPLI4EEaMtH+IZ4RCK4WcAgFZERNJDkl566SXNnj1bY8eOlcPh0KRJk/T8888H99fV1Wnfvn06ffp0cNvChQuDbWtqalRYWKjFixcH9zudTr355pv6/ve/r/z8fPXu3VvTpk3To48+Gmzzq1/9SvX19Zo1a5ZmzZoV3D5t2jStWLFCknT06FFNnjxZn3/+uVJTU3X99ddr8+bNbRrFAiByBRYOCCzj2mj8n0FGjODvb/j1PzeKsPz4EYsjQURpy4d4RjgAANAmUcYYY3UQ8BcyTUxM1MniYrnj460OJyKdqamxVQFEnC/c+njHDukn88/f/tPHpKuu6v54Il1lpXTwsxrlZrts8/nt1JkzuuT22yVJK1eeUEJCkrUBhYGamjMUQLQpY4y+/LJKNTVnlJyc0fWFTGEZ3sdt19AgffJJtebNS9TJkyfldrutDgnocSJmpAcAhJvMTP+UlsYmqWOno+PT6iOxNkhnxRyYJlRnpGgbTRNKiItT3/gEfX76lHy+Q0pIGG51SAAAAD2Kw+oAACBSBabVO8/9T+p0dHxa/Zo1UlGRf+RIUZH/frjrrJhbmiZUWdl5sVopO9n/gvD5DlkcCS5KZaV/eJddXpgAAPQQjPQAgIvQGdPqI7E2SGfGXFoaOlpGkhoa7bP6ZnZquv7v6GGVHfmL1aGgowJDkUyjf9UUuwxFAgCgB2CkBwBcpJQUfw2Pjn5Ab+1Df7jqzJgD04SauphpQuEmN8MjSfIdO2BxJOiQQIYvsDysaWz/UCRGiQAAYBmSHgBgsUj80N+ZMXfmNKFwNOAy/5NSXs70lohUWvrXhEdAY0PbM3yBeWDzfxI5c9cAALARprcAgMUCH/oXL/aPloiED/2dHXNgmtChEimnX3hfe3sNuNSf9PBVfGZxJOiQzEz/lJamiQ+Hs20Zvv1/kX7xC0nnhkUFRomE89w1AABshqQHAISBzqgN0t06O+aUFKn3JVLcBVYljrRVbnLS0yVJlVVHZYxhGc9I0zTD19jgT3i0JcMXqAOir8wDC4wSiYQXLwAANkDSAwDCREpK5H0O6u6YA58jG41/ek0k1JPsl5qqKEWppu6sqqrK1adPutUhob3am+H7ah2Qpto6SgQAAHQKanoAACJCpC5t64qOlsedKIllayNaeyoWN1cHRPJPkwn3uWsAANgMSQ8AsCm7LRgRiavcBGT3TZVE0qPHCNQBaSrKIf3s6fAfmgQAgM2Q9AAAGwosGPGT+fZZMCISV7kJyE5NkyR5j+xv+0F2y1r1JIE6IA6n/77D6b9/xUBr4wIAoAeipgeAsBVpBSvDRUvTQDp7wYju7p9IXOUmIDfDI0nyln7atgMCxUtMo3+EQCQUL0GoSKxODACADZH0ABCWmitYecONVkcVGVqbBtJZn7usKigaqZ8jL8/KlCSVt2V6y1eLYLLMaeSKxOrEAADYDNNbAISdFgtWfm5tXJGiq6eBWF1QtD31JMPFgEz/k19eWXLhxs0VwQwscwoAAIB2IekBIOy0NFLB67UmnkgTmAbiPPc/fGdPA4nkgqJWyUn3L1NbebJUDQ0NrTdurghmOC9zSu0RAAAQxpjeAiDsBEYqNP1g7XRIHo91MUWarpwG0lL/hOtn8nBwaXKyejkcqm+s1/HjpUpNzWq5cdPiJY0N/oRHuBYvofYIAAAIc4z0ABB2Whyp0NfauCJNR6eBXOiL+64eSWJHTqdTlyYmS2rjsrXjxklLl0qP/dT/MxwTCS3VHrHriA9GtAAAEJEY6QEgLDU3UuFMjdVR2V9bC5RGakFRK2X3TdVnJyrlLTugr33tmxc+INyLYLZWeySc4+4IRrQAABCxGOkB9BCR+CVlJBasjGTtLVBK/7RPoK6H98h+iyPpJJFWe6SjetqIFgAAbIakB9ADrFkjFRVJP5nv/7lmjdURhbdITBB1BgqUdq3ccyu4eMsOWBxJJwnMc3I4/ffDufbIxWA1HQAAIhrTWwCba+nb+xEj7PfZpDO0dXqHHVGgtGtdnpUpSSovP2xtIJ2pJ8xzCoxoaZr4sOOIFgAAbIqRHkA3smIEAd/et117p3fYDQVKu1auxz+9peLzEosj6WR2n+fUU0a0AABgU4z0ALpJZ40gqKz0JzIyM9v2Nzff3rddawminvL5pid8cW+V/udqehyv9qmurlbR0TEWR4Q2440BAEDEYqQH0A06awRBR2pz8O192wUSRE31xASR3b+4t0p6UpJie0XLyKiiwmajPXoC3hgAAEQkRnoA3aAzRhBcTG0OvqRsm0CCaPFif/+QIEJnioqKUlafvtpf4ZXPd0iZmZdbHVLkau+QNwAA0GOR9AC6QWdMMbnYxElKCp8N2oIEEbpS/5Q07a/wylv6qTT8ZqvDiUyBuYKm0V9gtCdVGwYAAO3G9BagG3TGFBOmXnQfRrGjqwTqeniPfmpxJBEqMOQtsJKKaexZ1YYBAEC7MdID6CYXO4KAqRdA5MvN9EiSfGUHLY4kQpWWhi4dK0mNDT2r2jAAAGgXkh5AN7rYKSZMvQAi2+WXZUqSyisOWxtIpMrM9E9paZr4cDgZ8gYAAFrE9BYgwjD1AohcuRn+kR7lx1m9pUMCQ94cTv99h5MhbwAAoFWM9AAAoJvknKvpUf3lcZ09+6ViY3tbHFEEYsgbAABoB0Z6AADQTfokJMjtipMklZcftjaYSMaQNwAA0EYkPQAA6Eb9kv0f1H2+w9YGAgAA0AOQ9AAAoBv165sqSfIeY9nadquslHbsYIlaAADQZtT0AACgG+V40qVdkvfofqtDiSxr1kiLFvlXboly+AuajhtndVQAACDMMdIDAIBuFFi21us9aHEkEaSy8q8JD8n/c/FiRnwAAIALIukBAEA3ujzLn/QorzhsbSCRpLT0rwmPgMYG/wouAAAArSDpAQBANwosW1tx/KjFkUSQzEz/lJamHE7/krUAAACtIOkBAEA36p+WJkk6XfOFTp2qsjaYSJGS4q/h4XD67zuc0r33smQtAAC4IAqZAgDQjXrHxqpvfII+P31KPt8hJSQMtzqkyDBunDRihH9KS0YGCQ8AANAmjPQAAKCbZSf7P7D7fIcsjiTCpKRIV11FwgMAALQZSQ8AALpZdqq/rkfZkb9YHAkAAIC9kfQAAKCb5WZ4JEneY59aHAkAAIC9kfQAAKCbBZetZXoLAABAlyLpAQBANxuQ6R/pUV5ZYnEkAAAA9kbSAwCAbtY/3V/To7LqqIwxFkcDAABgXyQ9AADoZv1SUxWlKNXUnVVVVbnV4QAAANgWSQ8AALqZKzpaHneiJJatBQAA6EokPQAAsEB231RJks970OJIAAAA7IukBwAAFshJ89f1KDuy3+JIAAAA7Ctikh7Hjx/XlClT5Ha7lZSUpKKiIp06darVY86ePatZs2apb9++SkhI0KRJk+Tz+ULalJSUaMKECYqPj1daWpoeeOAB1dfXB/dv2LBBUVFR5928Xm/IeRYtWqT+/fsrNjZWeXl5+vDDDzvv4gEAtpOb4V/BxVd2wOJIAAAA7Ctikh5TpkzR7t27tXbtWr355pt67733dPfdd7d6zA9/+EP9z//8j1atWqU//elPKi0t1d/93d8F9zc0NGjChAmqra3Vxo0b9Zvf/EYrVqzQww8/fN659u3bp7KysuAtLS0tuO+VV17RnDlztGDBAv3f//2frrnmGhUWFqq8nOJ0AIDm5V6WIUkqp6YHAABAl4mIpMfevXv19ttva+nSpcrLy9P111+vF154QcXFxSotLW32mJMnT+rXv/61nn32WX3rW9/SyJEjtXz5cm3cuFGbN2+WJK1Zs0Z79uzR7373Ow0bNky33HKL/u3f/k2LFi1SbW1tyPnS0tLk8XiCN4fjr0/ds88+q5kzZ2rGjBkaOnSolixZovj4eC1btqzrnhQAQEQbkHku6VFZYnEkAAAA9hURSY9NmzYpKSlJo0aNCm4rKCiQw+HQli1bmj1m69atqqurU0FBQXDb4MGD1a9fP23atCl43quuukrp6enBNoWFhaqurtbu3btDzjds2DBlZGTo5ptv1gcffBDcXltbq61bt4Y8jsPhUEFBQfBxmlNTU6Pq6uqQGwCg58g597un8mSpGhoaLI4GAADAnnpZHUBbeL3ekOkkktSrVy8lJyefV1uj6TExMTFKSkoK2Z6enh48xuv1hiQ8AvsD+yQpIyNDS5Ys0ahRo1RTU6OlS5fqpptu0pYtWzRixAhVVlaqoaGh2fN88sknLV7T448/rkceeeS87WdqahTtdLZ4HFp2pqbG6hDQxehj++tJfZzcu7eiHU7VNdarrOyAUlOzrA6pW9TUnLE6BHQRY4xqas6otvasamrOKCoqyuqQ0EV4H7ddQ4NUW8vzBVjJ0qTHgw8+qCeffLLVNnv37u2maJo3aNAgDRo0KHj/uuuu04EDB7Rw4UK9+OKLHT7vvHnzNGfOnOD96upqZWVlKc7lUpzLdVEx92Q8d/ZHH9tfT+rjSxOTdfhEhaqqynTZZQOtDqfbuFxxVoeALmCMUX29P3HpcsWR9LA53sdt09AgxcTUWR0G0KNZmvSYO3eupk+f3mqb3NxceTye84qC1tfX6/jx4/J4PM0e5/F4VFtbq6qqqpDRHj6fL3iMx+M5b5WVwOouLZ1XkkaPHq33339fkpSSkiKn03neqjBNH6c5LpdLrh70hz0A4HzZKak6fKJC3rKD+trXbrQ6HAAAANuxtKZHamqqBg8e3OotJiZG+fn5qqqq0tatW4PHrl+/Xo2NjcrLy2v23CNHjlR0dLTWrVsX3LZv3z6VlJQoPz9fkpSfn6+dO3eGJFTWrl0rt9utoUOHthj39u3blZHhL0AXExOjkSNHhjxOY2Oj1q1bF3wcAACa0//c1E3vkf0WRwIAAGBPEVHTY8iQIRo/frxmzpypJUuWqK6uTrNnz9Ydd9yhzMxMSdKxY8c0duxY/fa3v9Xo0aOVmJiooqIizZkzR8nJyXK73brvvvuUn5+va6+9VpI0btw4DR06VFOnTtVTTz0lr9er+fPna9asWcFRGD//+c+Vk5OjK6+8UmfPntXSpUu1fv16rVmzJhjfnDlzNG3aNI0aNUqjR4/Wz3/+c3355ZeaMWNG9z9ZAICIkXtuBRdv2QGLIwEAALCniEh6SNJLL72k2bNna+zYsXI4HJo0aZKef/754P66ujrt27dPp0+fDm5buHBhsG1NTY0KCwu1ePHi4H6n06k333xT3//+95Wfn6/evXtr2rRpevTRR4NtamtrNXfuXB07dkzx8fG6+uqr9c4772jMmDHBNrfffrsqKir08MMPy+v1atiwYXr77bfPK24KAEBTl2f5E/fl5YetDQQAAMCmoowxxuog4C9kmpiYqJPFxXLHx1sdTkQ6U1PTowog9kT0sf31tD7e/Mknyv/Rj5Ts9mjF78qsDqdb1NScoQCiTRlj9OWXVaqpOaPk5AwKmdoY7+O2a2iQPvmkWvPmJerkyZNyu91WhwT0OJbW9AAAoCfLOTci8ES1T3V1PWe5XgAAgO5C0gMAAIukJSUptle0jIwqKo5YHQ4AAIDtkPQAAMAiUVFRyurTV5Lk8x2yOBoAAAD7IekBAICF+qecW7a29FOLIwEAALAfkh4AAFio/7m6Ht4j+y2OBAAAwH5IegAAYKEBl2ZIkrxlBy2OBAAAwH5IegAAYKErsjIlSRWVn1kcCQAAgP2Q9AAAwEKB6S3lx0ssjgQAAMB+SHoAAGChnHNJj+ovj+vs2S8tjgYAAMBeSHoAAGChPgkJcrviJEnl5YetDQYAAMBmSHoAAGCxfskpkiSf75DFkQAAANgLSQ8AACzWPzVNklTKsrUAAACdiqQHAAAWy/H463r4jh2wOBIAAAB7IekBAIDFcjMzJEk+30GLIwEAALAXkh4AAFjs8qxMSVJ5xWFrAwEAALAZkh4AAFgssGxtxfGjFkcCAABgLyQ9AACwWP80fyHT0zVf6NSpExZHAwAAYB8kPQAAsFjv2Fil9L5EEsvWAgAAdCaSHgAAhIHs5BRJks9L0gMAAKCzkPQAACAM9EvxT3EpO7rf4kgAAADsg6QHAABhIDfDI0nyHvvU4kgAAADsg6QHAABhILhsLTU9AAAAOg1JDwAAwsCATP9Ij/LKzyyOBAAAwD5IegAAEAZy0tMlSRUnjskYY3E0AAAA9kDSAwBsoLJS2rHD/xORqV9qqqIUpdr6s6qqKrc6HAAAAFvoZXUAAICLs2aNtGiR1GgkR5Q0a5Y0bpzVUaG9YqKj5XEnqqy6Sj7fIfXpk251SAAAABGPkR4AEMEqK/+a8JD8PxcvZsRHpMrumypJ8nkPWhwJAACAPZD0AIAIVlr614RHQEOjVFZmTTy4ODlp/tEdZUf2WxwJAACAPZD0AIAIlpnpn9LSlNMhZWRYEw8uTm6GfwUXX+mnFkcCAABgDyQ9ACCCpaT4a3g4z/1v7nRI997r347IMyArU5Lk8x2yOBIAAAB7oJApAES4ceOkESP8U1oyMkh4RLIB50Z6VHx+xOJIAAAA7IGkBwDYQEoKyQ476J/ur+lRebJUDQ0NcjqdFkcEAAAQ2ZjeAgBAmLg0OVnRDqcaGut1/Pgxq8MBAACIeCQ9AAAIE06nU5cmJkuirgcAAEBnIOkBAEAYyU5JlSSVlR6wOBIAAIDIR9IDAIAwknOurof3yH6LIwEAAIh8JD0AAAgjuZkZkiSf96DFkQAAAEQ+kh4AAISRAZf5kx7l5YetDQQAAMAGSHoAABBGcj3+6S3ln5dYHAkAAEDkI+kBAEAYCdT0OFHtU11djcXRAAAARDaSHgAAhJG0pCTFRcfIyKiigtEeAAAAF4OkBwAAYSQqKkpZSX0lST7fIYujAQAAiGwkPQAACDP9U9MkSd7SAxZHAgAAENlIegAAEGay084lPY7stzgSAACAyEbSAwCAMDPgUv+ytd6ygxZHAgAAENlIegAAEGauyMqUJJVXHLY2EAAAgAhH0gMAgDATWLa24vgRiyMBAACIbL2sDgB+xhhJUvWuXVJsrMXRRKYzdXWqi462Ogx0IfrY/uhjv75nzkiSqk8fV/TqRYqLdlkcUeepqauTiz62JWOMHLVnFFNXK3fvREVFRVkdEroI7+O2a2yQPJWNkv769z6A7hVlePeFhaNHjyorK8vqMAAAAAB0gSNHjuiyyy6zOgygxyHpESYaGxtVWlqqSy65hG9GOqC6ulpZWVk6cuSI3G631eGgC9DH9kcf2x99bH/0sf3Rx+1njNEXX3yhzMxMORxUFwC6G9NbwoTD4SDz2wncbje/gG2OPrY/+tj+6GP7o4/tjz5un8TERKtDAHosUo0AAAAAAMCWSHoAAAAAAABbIukBW3C5XFqwYIFcLvuscIBQ9LH90cf2Rx/bH31sf/QxgEhDIVMAAAAAAGBLjPQAAAAAAAC2RNIDAAAAAADYEkkPAAAAAABgSyQ9AAAAAACALZH0QFg6fvy4pkyZIrfbraSkJBUVFenUqVOtHnP27FnNmjVLffv2VUJCgiZNmiSfzxfc//HHH2vy5MnKyspSXFychgwZoueee+6882zYsEEjRoyQy+XS5ZdfrhUrVnT25UFd08eS9IMf/EAjR46Uy+XSsGHDzjvH4cOHFRUVdd5t8+bNnXl5kHV9LEk7duzQDTfcoNjYWGVlZempp57qrMtCE13VxyUlJZowYYLi4+OVlpamBx54QPX19cH9GzZsaPZ97PV6u+Q6e5JFixapf//+io2NVV5enj788MNW269atUqDBw9WbGysrrrqKr311lsh+40xevjhh5WRkaG4uDgVFBRo//79IW068jpCx1nRx/379z/v/frEE090+rUBQLMMEIbGjx9vrrnmGrN582bzv//7v+byyy83kydPbvWY733veyYrK8usW7fO/PnPfzbXXnutue6664L7f/3rX5sf/OAHZsOGDebAgQPmxRdfNHFxceaFF14Itjl48KCJj483c+bMMXv27DEvvPCCcTqd5u233+6ya+2puqKPjTHmvvvuM7/4xS/M1KlTzTXXXHPeOQ4dOmQkmXfeeceUlZUFb7W1tZ15eTDW9fHJkydNenq6mTJlitm1a5d5+eWXTVxcnPnlL3/ZmZcH0zV9XF9fb772ta+ZgoICs23bNvPWW2+ZlJQUM2/evGCbd99910gy+/btC3kfNzQ0dNm19gTFxcUmJibGLFu2zOzevdvMnDnTJCUlGZ/P12z7Dz74wDidTvPUU0+ZPXv2mPnz55vo6Gizc+fOYJsnnnjCJCYmmjfeeMN8/PHH5rbbbjM5OTnmzJkzwTYdeR2hY6zq4+zsbPPoo4+GvF9PnTrV5dcLAMYYQ9IDYWfPnj1Gkvnoo4+C2/74xz+aqKgoc+zYsWaPqaqqMtHR0WbVqlXBbXv37jWSzKZNm1p8rHvvvdeMGTMmeP9HP/qRufLKK0Pa3H777aawsLCjl4NmdEcfL1iwoNWkx7Zt2y76OtAyK/t48eLFpk+fPqampia47cc//rEZNGjQRVwRvqqr+vitt94yDofDeL3eYJv/+I//MG63O9ingaTHiRMnuuDKeq7Ro0ebWbNmBe83NDSYzMxM8/jjjzfb/h//8R/NhAkTQrbl5eWZe+65xxhjTGNjo/F4PObpp58O7q+qqjIul8u8/PLLxpiOvY7QcVb0sTH+pMfChQs78UoAoO2Y3oKws2nTJiUlJWnUqFHBbQUFBXI4HNqyZUuzx2zdulV1dXUqKCgIbhs8eLD69eunTZs2tfhYJ0+eVHJycshjNz2HJBUWFrZ6DrRfd/ZxS2677TalpaXp+uuv1x/+8If2XwRaZWUfb9q0Sd/85jcVExMT3FZYWKh9+/bpxIkTHbgaNKer+njTpk266qqrlJ6eHmxTWFio6upq7d69O+R8w4YNU0ZGhm6++WZ98MEHnXl5PU5tba22bt0a0jcOh0MFBQUtvv8u9Dvz0KFD8nq9IW0SExOVl5cX0t/tfR2hY6zq44AnnnhCffv21fDhw/X000+HTFkDgK7Uy+oAgK/yer1KS0sL2darVy8lJye3OF/b6/UqJiZGSUlJIdvT09NbPGbjxo165ZVXtHr16pDzNP1DO3CO6upqnTlzRnFxcR24InxVd/VxcxISEvTMM8/oG9/4hhwOh1577TVNnDhRb7zxhm677bZ2XwuaZ2Ufe71e5eTknHeOwL4+ffq0+VxoWVf1cUv/Dwf2SVJGRoaWLFmiUaNGqaamRkuXLtVNN92kLVu2aMSIEZ1xeT1OZWWlGhoamn3uP/nkk2aPaamvmvZlYFtrbdr7OkLHWNXHkr8W04gRI5ScnKyNGzdq3rx5Kisr07PPPnvR1wUAF0LSA93mwQcf1JNPPtlqm71793ZLLLt27dJ3vvMdLViwQOPGjeuWx+wJwqmPW5KSkqI5c+YE73/9619XaWmpnn76aZIebRAJfYyLEwl9PGjQIA0aNCh4/7rrrtOBAwe0cOFCvfjiixZGBqA5TX/vXn311YqJidE999yjxx9/XC6Xy8LIAPQEJD3QbebOnavp06e32iY3N1cej0fl5eUh2+vr63X8+HF5PJ5mj/N4PKqtrVVVVVXIN4g+n++8Y/bs2aOxY8fq7rvv1vz58887z1dXEfD5fHK73YzyaINw6eP2ysvL09q1ay/qHD1FJPRxS+/jwD60zuo+9ng8560m0Zb+Gz16tN5///1W40bLUlJS5HQ6m33vtNafrbUP/PT5fMrIyAhpE1h5qSOvI3SMVX3cnLy8PNXX1+vw4cMhCUwA6ArU9EC3SU1N1eDBg1u9xcTEKD8/X1VVVdq6dWvw2PXr16uxsVF5eXnNnnvkyJGKjo7WunXrgtv27dunkpIS5efnB7ft3r1bY8aM0bRp0/TYY4+dd578/PyQc0jS2rVrQ86BloVDH3fE9u3bQ/5YQ8sioY/z8/P13nvvqa6uLrht7dq1GjRoEFNb2sDqPs7Pz9fOnTtDPgivXbtWbrdbQ4cObTFu3scXJyYmRiNHjgzpm8bGRq1bt67F99+Ffmfm5OTI4/GEtKmurtaWLVtC+ru9ryN0jFV93Jzt27fL4XCcN7UJALqE1ZVUgeaMHz/eDB8+3GzZssW8//775oorrghZvu7o0aNm0KBBZsuWLcFt3/ve90y/fv3M+vXrzZ///GeTn59v8vPzg/t37txpUlNTzXe/+92QJdPKy8uDbQJL1j7wwANm7969ZtGiRSxZ20W6oo+NMWb//v1m27Zt5p577jEDBw4027ZtM9u2bQuu+rBixQqzcuVKs3fvXrN3717z2GOPGYfDYZYtW9Y9F96DWNXHVVVVJj093UydOtXs2rXLFBcXm/j4eJas7QJd0ceBJWvHjRtntm/fbt5++22TmpoasmTtwoULzRtvvGH2799vdu7caf75n//ZOBwO884773TPhdtUcXGxcblcZsWKFWbPnj3m7rvvNklJScGVdKZOnWoefPDBYPsPPvjA9OrVy/zsZz8ze/fuNQsWLGh2OdOkpCTz+9//3uzYscN85zvfaXbJ2tZeR+g8VvTxxo0bzcKFC8327dvNgQMHzO9+9zuTmppq7rzzzu69eAA9FkkPhKXPP//cTJ482SQkJBi3221mzJhhvvjii+D+wLKj7777bnDbmTNnzL333mv69Olj4uPjzd/+7d+asrKy4P4FCxYYSefdsrOzQx773XffNcOGDTMxMTEmNzfXLF++vIuvtmfqij42xpgbb7yx2X4+dOiQMcaf9BgyZIiJj483brfbjB49OmT5THQeq/rYGGM+/vhjc/311xuXy2UuvfRS88QTT3T15fZIXdXHhw8fNrfccouJi4szKSkpZu7cuaauri64/8knnzQDBgwwsbGxJjk52dx0001m/fr1XX69PcELL7xg+vXrZ2JiYszo0aPN5s2bg/tuvPFGM23atJD2r776qhk4cKCJiYkxV155pVm9enXI/sbGRvPQQw+Z9PR043K5zNixY82+fftC2lzodYTO1d19vHXrVpOXl2cSExNNbGysGTJkiPnpT39qzp4926XXCQABUcYY082DSwAAAAAAALocNT0AAAAAAIAtkfQAAAAAAAC2RNIDAAAAAADYEkkPAAAAAABgSyQ9AAAAAACALZH0AAAAAAAAtkTSAwAAAAAA2BJJDwAAAAAAYEskPQAA6ET/+q//qmHDhnX540RFRSkqKkpJSUntPrZ///7B46uqqjo9NgAAgHBB0gMA0GNMnz5dEydOtDqMTrN8+XL95S9/kSQ988wz6tOnj86ePXteu9OnT8vtduv555+XJH300Ud67bXXujVWAAAAK5D0AAAgQiUlJSktLU2SNHXqVH355Zf67//+7/Pa/dd//Zdqa2v13e9+V5KUmpqq5OTkbo0VAADACiQ9AACQVF1drbi4OP3xj38M2f7666/rkksu0enTpyVJP/7xjzVw4EDFx8crNzdXDz30kOrq6lo870033aR/+Zd/Cdk2ceJETZ8+PXi/pqZG999/vy699FL17t1beXl52rBhQ7viT0tL06233qply5adt2/ZsmWaOHEiiQ4AANDjkPQAAECS2+3W3/zN32jlypUh21966SVNnDhR8fHxkqRLLrlEK1as0J49e/Tcc8/pP//zP7Vw4cKLeuzZs2dr06ZNKi4u1o4dO/QP//APGj9+vPbv39+u8xQVFWn9+vX67LPPgtsOHjyo9957T0VFRRcVIwAAQCQi6QEAwDlTpkzRG2+8ERzVUV1drdWrV2vKlCnBNvPnz9d1112n/v3769Zbb9X999+vV199tcOPWVJSouXLl2vVqlW64YYbNGDAAN1///26/vrrtXz58nadq7CwUJmZmSHHrVixQllZWRo7dmyHYwQAAIhUJD0AADjn29/+tqKjo/WHP/xBkvTaa6/J7XaroKAg2OaVV17RN77xDXk8HiUkJGj+/PkqKSnp8GPu3LlTDQ0NGjhwoBISEoK3P/3pTzpw4EC7zuV0OjVt2jStWLFCxhg1NjbqN7/5jWbMmCGHg1/5AACg5+lldQAAAISLmJgY/f3f/71WrlypO+64QytXrtTtt9+uXr38vy43bdqkKVOm6JFHHlFhYaESExNVXFysZ555psVzOhwOGWNCtjWtAXLq1Ck5nU5t3bpVTqczpF1CQkK7r+Guu+7S448/rvXr16uxsVFHjhzRjBkz2n0eAAAAOyDpAQBAE1OmTNHNN9+s3bt3a/369fr3f//34L6NGzcqOztbP/nJT4LbmtbPaE5qaqrKysqC9xsaGrRr1y6NGTNGkjR8+HA1NDSovLxcN9xww0XHP2DAAN14441atmyZjDEqKChQdnb2RZ8XAAAgEpH0AACgiW9+85vyeDyaMmWKcnJylJeXF9x3xRVXqKSkRMXFxfr617+u1atX6/XXX2/1fN/61rc0Z84crV69WgMGDNCzzz6rqqqq4P6BAwdqypQpuvPOO/XMM89o+PDhqqio0Lp163T11VdrwoQJ7b6GoqIizZw5U5K/pgcAAEBPxQRfAACaiIqK0uTJk/Xxxx+HFDCVpNtuu00//OEPNXv2bA0bNkwbN27UQw891Or57rrrLk2bNk133nmnbrzxRuXm5gZHeQQsX75cd955p+bOnatBgwZp4sSJ+uijj9SvX78OXcOkSZPkcrkUHx+viRMndugcAAAAdhBlvjrRGAAAhL2oqCi9/vrrHU5qbNiwQWPGjNGJEyeUlJTUqbEBAACEC5IeAABEoKioKMXGxqpv3746evRou4698sordfDgQZ09e5akBwAAsDVqegAAEIH2798vSeet+NIWb731VnAFGbfb3alxAQAAhBNGegAAAAAAAFuikCkAAAAAALAlkh4AAAAAAMCWSHoAAAAAAABbIukBAAAAAABsiaQHAAAAAACwJZIeAAAAAADAlkh6AAAAAAAAWyLpAQAAAAAAbOn/AUuajawOBKxHAAAAAElFTkSuQmCC", "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": "bf5956f7", "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": "fb450acb", "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": "add09bc9", "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": "3b1a059b", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "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(\n", " float(re), float(im), acq_rotation, acq_threshold\n", " )\n", " for re, im in zip(x, y)\n", " ],\n", ")\n", "\n", "cluster.start_sequencer = lambda: start_dummy_cluster_armed_sequencers(ic_cluster)" ] }, { "cell_type": "code", "execution_count": 10, "id": "bdbc7c2c", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/local/lib/python3.9/site-packages/quantify_scheduler/backends/qblox/compiler_abc.py:769: RuntimeWarning: Number of instructions (16012) compiled for 'seq0' of QRMRFCompiler 'cluster_module1' exceeds the maximum supported number of instructions in Q1ASM programs for QRMRFCompiler (12288).\n", " warnings.warn(\n" ] }, { "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\": prepared_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=200,\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": "fdc45ff6", "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 }}. When using multiple consecutive {{ ConditionalReset }} on the same qubit, we need to increment the `acq_index` for each one, similar to when adding multiple {{ Measure }} to the schedule. We also need to ensure that all acquisition protocols in the schedule are equal to `\"ThresholdedAcquisition\"`." ] }, { "cell_type": "code", "execution_count": 11, "id": "f7b0784b", "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, acq_index=i),\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_index=i, 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_index=i,\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": "f530a2b1", "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": "16548dfe", "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": "6bf3f795", "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": "2f022e8c", "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": "61f0cfde", "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": "36ef9be2", "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": "4a0556b9", "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.23" }, "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, 255, 287, 297, 305, 309, 318, 325, 345, 386, 407, 458, 471, 527, 553, 562, 568, 574 ] }, "nbformat": 4, "nbformat_minor": 5 }