{ "cells": [ { "cell_type": "markdown", "id": "e19337d0", "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": "6a1ff595", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_1412/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": "32947131", "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": "89daadb4", "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": "ce78754c", "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": "3dab10ef", "metadata": {}, "source": [ "Finally, we define the hardware configuration:" ] }, { "cell_type": "code", "execution_count": 4, "id": "da722b38", "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": "45831475", "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": "77b37ca9", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "### Generate dummy data\n", "\n", "import numpy as np\n", "from qblox_instruments.ieee488_2.dummy_transport import DummyBinnedAcquisitionData\n", "from quantify_scheduler.qblox import start_dummy_cluster_armed_sequencers\n", "\n", "def get_dummy_binned_acquisition_data(\n", " real: float, imag: float, theta: float, threshold: float\n", "):\n", " angle = 2 * np.pi * theta / (360)\n", " threshold *= 1000 # different normalization (integration length) on qblox instruments\n", " if real * np.cos(angle) - imag * np.sin(angle) > threshold:\n", " thres = 1\n", " else:\n", " thres = 0\n", " return DummyBinnedAcquisitionData(data=(real, imag), thres=thres, avg_cnt=0)\n", "\n", "\n", "def setup_dummy_data(theta: float, threshold: float):\n", " # Means and standard deviations\n", " x0, xs0 = -2.7, 2.5\n", " y0, ys0 = 2.9, 2.5\n", " x1, xs1 = -14, 2.5\n", " y1, ys1 = 1.9, 2.5\n", "\n", " # Number of points per data cluster\n", " max_batch_size = 60\n", "\n", " # Generate random samples\n", " x0_samples = np.random.normal(x0, xs0, max_batch_size)\n", " y0_samples = np.random.normal(y0, ys0, max_batch_size)\n", " x1_samples = np.random.normal(x1, xs1, max_batch_size)\n", " y1_samples = np.random.normal(y1, ys1, max_batch_size)\n", "\n", " # interleave the random samples such that we get\n", " # x = [x0_samples[0], x1_samples[0], x0_samples[1],...]\n", " # y = [y0_samples[0], y1_samples[0], y0_samples[1],...]\n", "\n", " x = np.vstack((x0_samples, x1_samples)).reshape(-1, order=\"F\")\n", " y = np.vstack((y0_samples, y1_samples)).reshape(-1, order=\"F\")\n", " states = np.array([0, 1] * max_batch_size)\n", "\n", " # prepare cluster with dummy data that will be returned \n", " # after retrieving acquisitions.\n", " cluster.delete_dummy_binned_acquisition_data(1)\n", " cluster.set_dummy_binned_acquisition_data(\n", " slot_idx=1,\n", " sequencer=0,\n", " acq_index_name=\"0\",\n", " data=[\n", " get_dummy_binned_acquisition_data(float(re), float(im), theta, threshold)\n", " for re, im in zip(x, y)\n", " ],\n", " )\n", "\n", "def setup_dummy_and_start_sequencer(theta: float, threshold: float):\n", " setup_dummy_data(theta, threshold)\n", " start_dummy_cluster_armed_sequencers(ic_cluster)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(0, 0)" ] }, { "cell_type": "code", "execution_count": 6, "id": "abc13185", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
<xarray.Dataset> Size: 24kB\n",
       "Dimensions:  (dim_0: 1000)\n",
       "Coordinates:\n",
       "    x0       (dim_0) int64 8kB 0 1 0 1 0 1 0 1 0 1 0 1 ... 1 0 1 0 1 0 1 0 1 0 1\n",
       "Dimensions without coordinates: dim_0\n",
       "Data variables:\n",
       "    y0       (dim_0) float64 8kB -0.008856 -0.00961 ... -0.00155 -0.02085\n",
       "    y1       (dim_0) float64 8kB -0.001023 -0.0006401 ... 0.004431 0.00364\n",
       "Attributes:\n",
       "    tuid:                             20260319-151511-611-4dff21\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.008856 -0.00961 ... -0.00155 -0.02085\n", " y1 (dim_0) float64 8kB -0.001023 -0.0006401 ... 0.004431 0.00364\n", "Attributes:\n", " tuid: 20260319-151511-611-4dff21\n", " name: Readout Calibration\n", " grid_2d: False\n", " grid_2d_uniformly_spaced: False\n", " 1d_2_settables_uniformly_spaced: False" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from qcodes import ManualParameter\n", "\n", "from quantify_scheduler import Schedule, ScheduleGettable\n", "from quantify_scheduler.operations import Measure\n", "from quantify_scheduler.schedules import readout_calibration_sched\n", "\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\"qubit\": \"q0\", \"prepared_states\": states}\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=60,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "measurement_control.verbose(False)\n", "\n", "dataset = measurement_control.run(\"Readout Calibration\")\n", "dataset" ] }, { "cell_type": "markdown", "id": "42325bf1", "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": "4f407eee", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABFIAAAKCCAYAAADyVP0fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8ekN5oAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1xT1/sH8E+IjLBlgyjg3qg4ilon4t6r2qoo2rrXt27rqlvc21oBrf60WlfVKi7UqnWWqnVbFesAsQrKCOv+/oi5EkggzAT4vF8vXpiTk3vPvQkx98lzniMRBEEAERERERERERFlyUDXAyAiIiIiIiIiKiwYSCEiIiIiIiIi0hIDKUREREREREREWmIghYiIiIiIiIhISwykEBERERERERFpiYEUIiIiIiIiIiItMZBCRERERERERKQlBlKIiIiIiIiIiLTEQAoRERERERERkZYYSCEiIirGJBIJZs2apeth5LugoCBIJBI8efJEbGvWrBmaNWsm3g4NDYVEIsGePXsKfoBpPHnyBBKJBEFBQTodBxEREanHQAoREVEBUF4cK38MDAxgY2ODtm3b4uLFi7oeXr5at25dtoMCCQkJWL58ORo0aAArKyuYmJigYsWKGDlyJO7fv58/Ay1gO3bswIoVK3Q9DCIiIsqmEroeABERUXHSp08ftGvXDikpKbh//z7WrVuH5s2b48qVK6hRo4auh5cv1q1bBzs7O/j5+WnVPyoqCm3atMG1a9fQoUMH9O3bF+bm5rh37x527tyJTZs2ITExMdfjCgkJyfU2cmPHjh24desWxo4dq9Lu5uaG+Ph4GBoa6mZgRERElCkGUoiIiApQnTp18NVXX4m3P//8c7Rt2xbr16/HunXrdDgy/eHn54c///wTe/bsQffu3VXu+/777zFt2rQ82Y+RkVGebEcpLi4Opqamud6ORCKBiYlJHoyIiIiI8gOn9hAREenQ559/DgB49OiRSvu7d+8wduxYlC5dGsbGxihfvjwWLVqE1NRUlX4BAQFo2LAhbG1tIZPJ4OXlpbbGh1wux7hx42Bvbw8LCwt06tQJ//77r9ox/fnnn2jbti0sLS1hbm6Oli1b4o8//lDpM2vWLEgkkgyPTV+LxN3dHX///TfOnDkjTmtKW5ckvUuXLuHw4cPw9/fPEEQBAGNjYwQEBIi3b9y4AT8/P5QtWxYmJiZwcnLCoEGD8ObNG437UEpfI0UpJSUFU6dOhZOTE8zMzNCpUyc8e/Ysw2OrV6+Oa9euoUmTJjA1NcXUqVMBAAcOHED79u3h4uICY2NjlCtXDt9//z1SUlJUHn/48GE8ffpUPC/u7u4ANNdIOXXqFD7//HOYmZnB2toanTt3xp07d1T6KJ+Xhw8fws/PD9bW1rCyssLAgQMRFxeX5TkhIiKirDEjhYiISIeUAYeSJUuKbXFxcWjatCmeP3+Ob775BmXKlMGFCxcwZcoUvHz5UqWuxsqVK9GpUyd8+eWXSExMxM6dO9GzZ08cOnQI7du3F/sNHjwYP/30E/r27YuGDRvi1KlTKvcr/f333/j8889haWmJiRMnwtDQEBs3bkSzZs1w5swZNGjQIFvHt2LFCowaNQrm5uZiJomjo6PG/gcPHgQA9OvXT6vtHz9+HP/88w8GDhwIJycn/P3339i0aRP+/vtv/PHHH2qDPVmZN28eJBIJJk2ahMjISKxYsQI+Pj4ICwuDTCYT+7158wZt27bFF198ga+++ko8rqCgIJibm2P8+PEwNzfHqVOnMGPGDMTExGDJkiUAgGnTpiE6Ohr//vsvli9fDgAwNzfXOKYTJ06gbdu2KFu2LGbNmoX4+HisXr0ajRo1wvXr18UgjFKvXr3g4eGBBQsW4Pr169i8eTMcHBywaNGibJ8PIiIiSkcgIiKifPf48WMBgDB79mzh9evXwqtXr4Rz584J9erVEwAIu3fvFvt+//33gpmZmXD//n2VbUyePFmQSqVCeHi42BYXF6fSJzExUahevbrQokULsS0sLEwAIAwfPlylb9++fQUAwsyZM8W2Ll26CEZGRsKjR4/EthcvXggWFhZCkyZNxLaZM2cK6j5GBAYGCgCEx48fi23VqlUTmjZtmvkJ+qhr164CAOHt27da9U9//IIgCP/3f/8nABDOnj2b6biaNm2qMq7Tp08LAIRSpUoJMTExYvvPP/8sABBWrlyp8lgAwoYNG7Qa0zfffCOYmpoKCQkJYlv79u0FNze3DH2Vr5XAwECxrVatWoKDg4Pw5s0bse2vv/4SDAwMhP79+4ttyudl0KBBKtvs2rWrYGtrm2FfRERElH2c2kNERFSAZs6cCXt7ezg5OeHzzz/HnTt3sHTpUvTo0UPss3v3bnz++ecoWbIkoqKixB8fHx+kpKTg7NmzYt+0GRJv375FdHQ0Pv/8c1y/fl1sP3LkCABg9OjRKmNJX+Q0JSUFISEh6NKlC8qWLSu2Ozs7o2/fvvj9998RExOTJ+dBE+X2LSwstOqf9vgTEhIQFRWFzz77DABUzkF29O/fX2X/PXr0gLOzs3gelYyNjTFw4MBMx/T+/XtERUXh888/R1xcHO7evZvt8bx8+RJhYWHw8/ODjY2N2F6zZk20atUqw7gAYOjQoSq3P//8c7x58ybfnz8iIqLigFN7iIiICtDXX3+Nnj17IiEhAadOncKqVatUamcAwIMHD3Djxg3Y29ur3UZkZKT470OHDmHu3LkICwuDXC4X29NOaXn69CkMDAxQrlw5le1UqlRJ5fbr168RFxeXoR0AqlSpgtTUVDx79gzVqlXT/oCzydLSEoAiAGFtbZ1l///++w+zZ8/Gzp07Vc4LAERHR+doDBUqVFC5LZFIUL58eXEallKpUqXUFqz9+++/MX36dJw6dSpD4CInY3r69CmAjM8XoHhejh07htjYWJiZmYntZcqUUemnnDr29u1b8RwTERFRzjCQQkREVIAqVKgAHx8fAECHDh0glUoxefJkNG/eHHXr1gUApKamolWrVpg4caLabVSsWBEAcO7cOXTq1AlNmjTBunXr4OzsDENDQwQGBmLHjh35ehyaao+kDwplV+XKlQEAN2/eFAvxZqZXr164cOECJkyYgFq1asHc3Bypqalo06ZNhsK8eS1t5onSu3fv0LRpU1haWmLOnDkoV64cTExMcP36dUyaNCnfx6QklUrVtguCUCD7JyIiKsoYSCEiItKhadOm4YcffsD06dNx9OhRAEC5cuXw4cMHMeCiyS+//AITExMcO3YMxsbGYntgYKBKPzc3N6SmpuLRo0cqWQ337t1T6Wdvbw9TU9MM7QBw9+5dGBgYoHTp0gA+ZTi8e/dOJXNEmT2RVnYKvnbs2BELFizATz/9lGUg5e3btzh58iRmz56NGTNmiO0PHjzQen/qpH+8IAh4+PAhatasmeVjQ0ND8ebNG+zduxdNmjQR2x8/fpyhr7bnxc3NDUDG5wtQPC92dnYq2ShERESUv1gjhYiISIesra3xzTff4NixYwgLCwOgyLK4ePEijh07lqH/u3fvkJycDECRdSCRSFSyQJ48eYL9+/erPKZt27YAgFWrVqm0p139R7k9X19fHDhwQGUaS0REBHbs2IHGjRuL00KU04TS1muJjY1FcHBwhjGbmZnh3bt3mk9CGt7e3mjTpg02b96c4TgAIDExEd9++604XiBjlkX648qurVu34v379+LtPXv24OXLl+J5zIy6MSUmJmLdunUZ+pqZmWk11cfZ2Rm1atVCcHCwynm8desWQkJC0K5duyy3QURERHmHGSlEREQ6NmbMGKxYsQILFy7Ezp07MWHCBBw8eBAdOnSAn58fvLy8EBsbi5s3b2LPnj148uQJ7Ozs0L59eyxbtgxt2rRB3759ERkZibVr16J8+fK4ceOGuP1atWqhT58+WLduHaKjo9GwYUOcPHkSDx8+zDCWuXPn4vjx42jcuDGGDx+OEiVKYOPGjZDL5Vi8eLHYz9fXF2XKlIG/vz8mTJgAqVSKLVu2wN7eHuHh4Srb9PLywvr16zF37lyUL18eDg4OaNGihcbzsXXrVvj6+qJbt27o2LEjWrZsCTMzMzx48AA7d+7Ey5cvERAQAEtLSzRp0gSLFy9GUlISSpUqhZCQELXZH9lhY2ODxo0bY+DAgYiIiMCKFStQvnx5DBkyJMvHNmzYECVLlsSAAQMwevRoSCQSbNu2Te2UGi8vL+zatQvjx49HvXr1YG5ujo4dO6rd7pIlS9C2bVt4e3vD399fXP7YysoKs2bNytXxEhERUTbpdM0gIiKiYkK5pO2SJUvU3u/n5ydIpVLh4cOHgiAIwvv374UpU6YI5cuXF4yMjAQ7OzuhYcOGQkBAgJCYmCg+7scffxQqVKggGBsbC5UrVxYCAwPVLk0cHx8vjB49WrC1tRXMzMyEjh07Cs+ePcuw/LEgCML169eF1q1bC+bm5oKpqanQvHlz4cKFCxnGfO3aNaFBgwaCkZGRUKZMGWHZsmVqlxl+9eqV0L59e8HCwkIAoNVSyHFxcUJAQIBQr149wdzcXDAyMhIqVKggjBo1SjxHgiAI//77r9C1a1fB2tpasLKyEnr27Cm8ePEiw3FlZ/nj//u//xOmTJkiODg4CDKZTGjfvr3w9OlTlfE1bdpUqFatmtqxnz9/Xvjss88EmUwmuLi4CBMnThSOHTsmABBOnz4t9vvw4YPQt29fwdraWgAgLoWsbvljQRCEEydOCI0aNRJkMplgaWkpdOzYUbh9+7ZKH+Vz//r1a5V2dcdPREREOSMRBFYdIyIiIiIiIiLSBmukEBERERERERFpiYEUIiIiIiIiIiItMZBCRERERERERKQlBlKIiIiIiIiIiLTEQAoRERERERERkZYYSCEiIiIiIiIi0hIDKUREpLeCgoIgkUjw5MmTLPu6u7vDz88v38dERNqZNWsWJBKJSltycjImTpyI0qVLw8DAAF26dAEAfPjwAYMHD4aTkxMkEgnGjh1b8AMmIiLSEgMpRESULy5cuIBZs2bh3bt3uh5Klu7evYuJEyeiVq1asLCwgLOzM9q3b4+rV6+q7f/8+XP06tUL1tbWsLS0ROfOnfHPP/+o9Hn27Blmz56N+vXro2TJkrCzs0OzZs1w4sQJjeM4ceIEWrRoASsrK1hYWMDLywu7du3K0O/gwYOoU6cOTExMUKZMGcycORPJyckqfc6ePYtOnTqhdOnSMDExgZOTE9q0aYPz589n2F5ISAj8/f1RvXp1SKVSuLu7axzjw4cP0aNHD5QsWRKmpqZo3LgxTp8+rbF/Tvf15MkTSCQStT87d+5U6Xv58mUMHz4cXl5eMDQ0zHDxnpambS5cuFCl37179zBu3Dg0bNgQJiYmmQb0du3aha+++goVKlSARCJBs2bNtD4faWnz/Gu7rw8fPmDmzJlo06YNbGxsIJFIEBQUlKNxAcC7d+/g4OAAiUSCPXv25Hg7W7ZswZIlS9CjRw8EBwdj3LhxAID58+cjKCgIw4YNw7Zt29CvX79s/Q29fPkSkydPRvPmzWFhYQGJRILQ0NAcj5OIiCgzJXQ9ACIiKpouXLiA2bNnw8/PD9bW1jnaRr9+/fDFF1/A2Ng4bweXzubNm/Hjjz+ie/fuGD58OKKjo7Fx40Z89tlnOHr0KHx8fMS+Hz58QPPmzREdHY2pU6fC0NAQy5cvR9OmTREWFgZbW1sAwIEDB7Bo0SJ06dIFAwYMQHJyMrZu3YpWrVphy5YtGDhwoMoYAgMD4e/vj1atWmH+/PmQSqW4d+8enj17ptLvt99+Q5cuXdCsWTOsXr0aN2/exNy5cxEZGYn169eL/e7fvw8DAwMMHToUTk5OePv2LX766Sc0adIEhw8fRps2bcS+O3bswK5du1CnTh24uLhoPE/Pnj2Dt7c3pFIpJkyYADMzMwQGBsLX1xcnT55EkyZNsjzX2u5LqU+fPmjXrp1Km7e3t8rtI0eOYPPmzahZsybKli2L+/fvZ7rNVq1aoX///ipttWvXVrl98eJFrFq1ClWrVkWVKlUQFhamcXvr16/HtWvXUK9ePbx58ybLY1JH2+df231FRUVhzpw5KFOmDDw9PXMdVJgxYwbi4uJytQ0AOHXqFEqVKoXly5dnaP/ss88wc+ZMsW3NmjVa/w3du3cPixYtQoUKFVCjRg1cvHgx12MlIiLSSCAiIsoHS5YsEQAIjx8/LpD9ubm5CQMGDMjRY69evSq8f/9epS0qKkqwt7cXGjVqpNK+aNEiAYBw+fJlse3OnTuCVCoVpkyZIrbdunVLeP36tcpjExIShMqVKwuurq4q7Y8fPxZkMpkwevToLMdatWpVwdPTU0hKShLbpk2bJkgkEuHOnTuZPjY2NlZwdHQUWrdurdL+/PlzITExURAEQWjfvr3g5uam9vHDhw8XSpQoIdy9e1dlm6VLlxbq1KmT5dizs6/Hjx8LAIQlS5Zkuc1Xr14JcXFxgiAIwogRI4TMPt4AEEaMGJHlNt+8eSPExMQIgpD1azk8PFxISUkRBEEQqlWrJjRt2jTL7aeVnedf230lJCQIL1++FARBEK5cuSIAEAIDA7M1LqWbN28KJUqUEObMmSMAEHbv3q3V42bOnJnhuWjevLlQrVq1DH09PDyE9u3bq7Rl528oJiZGePPmjSAIgrB7924BgHD69GmtxklERJRdnNpDRER5btasWZgwYQIAwMPDQ5w+8eTJE3HKhrppBhKJBLNmzRJvq6uRIggC5s6dC1dXV5iamqJ58+b4+++/1Y7j0aNHePToUZbj9fLygrm5uUqbra0tPv/8c9y5c0elfc+ePahXrx7q1asntlWuXBktW7bEzz//LLZVq1YNdnZ2Ko81NjZGu3bt8O+//+L9+/di+4YNG5CSkoI5c+YAUGS9CIKQYZy3b9/G7du38fXXX6NEiU9JpcOHD4cgCFlOuTA1NYW9vX2G6VYuLi4wNDTM9LEAcO7cOdSuXRuVKlVS2WanTp1w/fp1PHjwIMttaLuvtGJjY5GYmKjxfkdHR8hksmxtMz4+HgkJCRrvt7GxgYWFhVbbUtb7yCltn//s7MvY2BhOTk45HlNaY8aMQdeuXfH5559r7PP777+jXr16MDExQbly5bBx40aV+5V/96dPn8bff/8tvieEhoZCIpHg8ePHOHz4sMp7RXb+hiwsLGBjY5Mnx0tERJQVBlKIiCjPdevWDX369AEALF++HNu2bcO2bdtgb2+f623PmDED3333HTw9PbFkyRKULVsWvr6+iI2NzdC3ZcuWaNmyZY739erVK5ULudTUVNy4cQN169bN0Ld+/fp49OiRysWdpm2amprC1NRUbDtx4gQqV66MI0eOwNXVFRYWFrC1tcV3332H1NRUsd+ff/4JABn27+LiAldXV/H+tGJiYhAVFYW7d+9i6tSpuHXrVo7PiVwuVxuwUB7LtWvXcrTdzMyePRvm5uYwMTFBvXr1EBISkuttBgUFwczMDDKZDFWrVsWOHTvyYKQ5p+3zrwu7d+/GhQsXsHjxYo19bt68CV9fX0RGRmLWrFkYOHAgZs6ciX379ol97O3tsW3bNlSuXBmurq7ie0KVKlWwbds22NnZoVatWlq9V6j7GyIiIipIrJFCRER5rmbNmqhTpw7+7//+D126dFEpKPr69escb/f169dYvHgx2rdvj19//VUsKjpt2jTMnz8/t8NWce7cOVy8eBHTp08X2/777z/I5XI4Oztn6K9se/HihUrGRloPHz7E3r170bNnT0ilUrH9wYMHkEqlGDhwICZOnAhPT0/s3bsXc+fORXJyMhYsWABAUVAz7b7S7//FixcZ2nv16oVjx44BAIyMjPDNN9/gu+++0/Y0qKhUqRLOnTuH9+/fq2Rr/P777wAURXjzioGBAXx9fdG1a1eUKlUK//zzD5YtW4a2bdvi4MGDaN++fY6227BhQ/Tq1QseHh548eIF1q5diy+//BLR0dEYNmxYno0/O7R9/gtafHw8vv32W4wbNw7u7u4ai+3OmDEDgiDg3LlzKFOmDACge/fuqFGjhtjHzMwMX331FTZv3gypVIqvvvpKvO+rr77C9OnTUapUKZV2dTT9DRERERUkBlKIiKjQOHHiBBITEzFq1CiVlVnGjh2rNpCizbLJ6kRGRqJv377w8PDAxIkTxfb4+HgAUFv81sTERKVPenFxcejZsydkMlmGFWI+fPiA1NRULFy4EJMmTQKguBD977//sHLlSkydOhUWFhZZ7j8mJiZD+8KFC/G///0Pz549Q3BwMBITEzOs8KOtYcOG4ddff0Xv3r0xb948mJmZYd26deLqRpqOPSfKlCkjBoCU+vXrh6pVq+J///tfjgMp6VctGjRoELy8vDB16lT4+flle4pQXtD2+S9oCxcuRFJSEqZOnaqxT0pKCo4dO4YuXbqIQRQAqFKlClq3bo0jR47k2Xgy+xsiIiIqSJzaQ0REhcbTp08BABUqVFBpt7e3R8mSJfNkH7GxsejQoQPev3+PAwcOqNROUV5ky+XyDI9T1ttQdyGekpKCL774Ardv38aePXsyrFajfIxyOpRSnz59EB8fL07ZyWr/6vZdq1YttGrVCoMGDcLx48dx+fJl+Pn5aTz+zLRt2xarV6/G2bNnUadOHVSqVAmHDx/GvHnzAEA8V9HR0Xj16pX4899//+Vof+nZ2Nhg4MCBuHfvHv7999882aaRkRFGjhyJd+/e5cvUJKXExESVc/Lq1SukpKQA0P75zw+anqsnT55gyZIlmDdvXob6QWm9fv0a8fHxGf4mAWjMzMqJrP6GiIiIChIDKUREVKDSZpKkpbyo1KXExER069YNN27cwIEDB1C9enWV+21sbGBsbCxOsUlL2abuAm/IkCE4dOgQgoKC0KJFiwz3Kx/j6Oio0u7g4AAAePv2LYBPU3o07T+ri0sjIyN06tQJe/fuzXH2yMiRIxEREYELFy7g6tWruHv3LqysrAAAFStWBKAoTurs7Cz+dOvWLUf7Uqd06dIAkGfBmfzaZnoXLlxQOSfOzs7i0sbaPv/5QdNzNWPGDJQqVQrNmjUTi0S/evUKgCJ48uTJkwKt35LV3xAREVFB4tQeIiLKF5oCJsrMkfQrxyizTTLj5uYGQFFTomzZsmL769evc32xmZqaiv79++PkyZP4+eef0bRp0wx9DAwMUKNGDXEqS1qXLl1C2bJlM0zBmDBhAgIDA7FixYoMGQdKXl5eePDgAZ4/f65yXMqaJ8rCm7Vq1QIAXL16FfXr11fp9++//+Lrr7/O8jjj4+MhCALev3+f42ksZmZm8Pb2Fm+fOHECMpkMjRo1AgBMnDhRpdZFXmULAcA///wDAHlSuDg/t5mep6cnjh8/rtKmXFVH2+c/P2h6rsLDw/Hw4UOV8SgNHz4cgCLAY29vD5lMpnbFpnv37uXJGLX5GyIiIipIzEghIqJ8YWZmBiBjwMTS0hJ2dnY4e/asSvu6deuy3KaPjw8MDQ2xevVqleVhV6xYoba/tssfA8CoUaOwa9curFu3LtMMih49euDKlSsqwZR79+7h1KlT6Nmzp0rfJUuWICAgAFOnTsWYMWM0brN3794AgB9//FFsS01NRWBgIGxsbODl5QVAsaRy5cqVsWnTJpUMnvXr10MikaBHjx5iW2RkZIb9vHv3Dr/88gtKly4tZjvk1oULF7B37174+/uLmSlVq1aFj4+P+KMcf3aoK0r8/PlzbNmyBTVr1lRbcDcn23z//j1WrFgBOzu7HI1TWyVLllQ5Jz4+PmJdHW2f//yg6bmaO3cu9u3bp/Lz/fffA1AEX/bt2wczMzNIpVK0bt0a+/fvR3h4uLjdO3fuZKhxkxPa/g0REREVJGakEBFRvlBekE2bNg1ffPEFDA0N0bFjR5iZmWHw4MFYuHAhBg8ejLp16+Ls2bO4f/9+ltu0t7fHt99+iwULFqBDhw5o164d/vzzT/z2228qyxQrKZf5zaro7IoVK7Bu3Tp4e3vD1NQUP/30k8r9Xbt2FQNDw4cPxw8//ID27dvj22+/haGhIZYtWwZHR0f873//Ex+zb98+TJw4ERUqVECVKlUybLNVq1biVI7OnTujZcuWWLBgAaKiouDp6Yn9+/fj999/x8aNG1WKyy5ZsgSdOnWCr68vvvjiC9y6dQtr1qzB4MGDUaVKFbFf27Zt4erqigYNGsDBwQHh4eEIDAzEixcvsGvXLpWx3LhxAwcPHgSgWBUlOjoac+fOBaDIpOjYsSMARdZQr1690KlTJzg5OeHvv//Ghg0bULNmTa1XTdJ2XxMnTsSjR4/QsmVLuLi44MmTJ9i4cSNiY2OxcuVKlW0+ffoU27ZtAwAxwKXcppubG/r16wcAWLt2Lfbv34+OHTuiTJkyePnyJbZs2YLw8HBs27YNRkZG4jajo6OxevVqAJ8K1K5ZswbW1tawtrbGyJEjxb5nz54VA4OvX79GbGysuP8mTZqgSZMmmZ6T7Dz/2dnXmjVr8O7dOzGz5ddffxVry4waNUoMfKnTuHHjDG3W1tYAgHr16qFLly5i++zZs3H06FF8/vnnGD58OJKTk7F69WpUq1YNN27cyPTYM5OdvyHg03P+999/AwC2bdsmriiVdvUtIiKiXBOIiIjyyffffy+UKlVKMDAwEAAIjx8/FgRBEOLi4gR/f3/ByspKsLCwEHr16iVERkYKAISZM2eKjw8MDFR5nCAIQkpKijB79mzB2dlZkMlkQrNmzYRbt24Jbm5uwoABA1T27+bmJri5uWU5zgEDBggANP6k3b8gCMKzZ8+EHj16CJaWloK5ubnQoUMH4cGDByp9Zs6cmek2T58+rdL//fv3wpgxYwQnJyfByMhIqFGjhvDTTz+pHe++ffuEWrVqCcbGxoKrq6swffp0ITExUaXPmjVrhMaNGwt2dnZCiRIlBHt7e6Fjx47C2bNnM2xPeZ7V/aQ9p//995/QuXNncYweHh7CpEmThJiYmCzPcXb3tWPHDqFJkyaCvb29UKJECcHOzk7o2rWrcO3atQzbPH36tMZtNm3aVOwXEhIitGrVSnBychIMDQ0Fa2trwdfXVzh58mSGbT5+/FjjNtO/pjJ7rtO+njOj7fOfnX25ublp/ZrWhvI87969O8N9Z86cEby8vAQjIyOhbNmywoYNG8SxptW0aVOhWrVqGR7v5uYmtG/fXutjVfc3lFlfIiKivCQRhDS50UREREREREREpBFrpBARERERERERaYmBFCIiIiIiIiIiLTGQQkRERERERESkJQZSiIiIiIiIiIi0xEAKEREREREREZGWGEghIiIiIiIiItISAylERERERERERFpiIIWIiIiIiIiISEsMpBARERERERERaYmBFCIiIiIiIiIiLTGQQkRERERERESkJQZSiIiIiIiIiIi0xEAKEREREREREZGWGEghIiIiIiIiItISAylERERERERERFpiIIWIiIiIiIiISEsMpBARERERERERaYmBFCIiIiIiIiIiLTGQQkRERERERESkJQZSiIiIiIiIiIi0xEAKEREREREREZGWGEghIiIiIiIiItISAylERERERERERFpiIIWIiIiIiIiISEsMpBARERERERERaYmBFCIiIiIiIiIiLTGQQkRERERERESkJQZSiIiIiIiIiIi0xEAKEREREREREZGWGEghIiIiIiIiItISAylERERERERERFpiIIWIiIiIiIiISEsMpBARERERERERaYmBFCIiIiIiIiIiLTGQQkRERERERESkJQZSiIiIiIiIiIi0xEAKEREREREREZGWGEghIiIiIiIiItISAylERERERERERFpiIIWIiIiIiIiISEsMpBARERERERERaYmBFCIiIiIiIiIiLTGQQkRERERERESkJQZSiIiIiIiIiIi0xEAKEREREREREZGWGEghIiIiIiIiItJSCV0PoDhITU3FixcvYGFhAYlEouvhEBERERFRISQIAt6/fw8XFxcYGPA7cSJdYSClALx48QKlS5fW9TCIiIiIiKgIePbsGVxdXXU9DKJii4GUAmBhYQEAeLZxIyytrHQ8msIvXi6HzNhY18OgQoKvF8oOfXq9nL11Cx3nzoWzbVksX/unrodDasjl8TA2lul6GKTnBEFAbOw7JCYmoGRJJ2Ynk1Y0vb88fRqDSZNKi9cXRKQbDKQUAOV/mJYyGSxNTXU8msLPUCrVmwsd0n98vVB26NPrxf5j4D05JRGmppY6Hg2pI5UaMpBCWRIEAYKQCqnUEKamlgykkFY0vb+YmCh+83VEpFucWEdERKSHZEZGAIDEpHgdj4SIiIiI0mIghYiISA+ZfsyMSUyS63gkRERERJQWAylERER6SDnFKDE5QccjISIiIqK0GEghIiLSQ8qpPSmpyUhJSdbxaIiIiIhIiYEUIiIiPWSapuitXM46KURERET6goEUIiIiPWRsaAgJFKsyyOVxOh4NERERESkxkEJERKSHJBIJTAwNAQCJicxIISIiItIXDKQQERHpKZMSikAKM1KIiIiI9AcDKURERHpKZqgoOMuMFCIiIiL9wUAKERGRnpIZMiOFiIiISN8wkEJERKSnTJiRQkRERKR3GEghIiLSUzIjRSCFyx8TERER6Q8GUoiIiPSUGEhJiNXxSIiIiIhIiYEUIiIiPWVqZAwASIhnjRQiIiIifcFAChERkZ4SM1LiP+h4JERERESkVELXAyAiIiL1TI0VGSnyBGakEBGRfkpNTUV4eDgePXqE+Ph4pKam6npIRDkmkUhgbGyM0qVLo3z58jD8uIJiegykEBER6SnZx6k9iayRQpRRVBTw4gXg4gLY2el6NETF0oMHD3DgwAF8+PAB5ubmsLCwgFQq1fWwiHIsNTUV8fHxuHDhAoyMjNC0aVM0atQoQz8GUoiIiPSUibFy1R5mpBCpCAkB1q4FhFRAYgCMGAH4+up6VETFyoMHD7Bz506ULVsWTZs2RalSpSCRSHQ9LKI88ebNG1y+fBnHjx+HIAho3Lixyv2skUJERKSnzGQmABhIIVIRFfUpiAIofq9bp2gnogIhCAKOHj0KNzc3fPHFF3B1dWUQhYoUW1tbtG3bFo0aNcKpU6cQF6f6WYyBFCIiIj1lavJxag8DKUSfvHjxKYiilJoCvHypm/EQFUMRERF48+YNvL29OZWHirSGDRtCEATcuXNHpZ2BFCIiIj1lZqLMSInX8UiI9IiLi2I6T1oGUsDZWTfjISqGnj59ihIlSqBs2bK6HgpRvjIzM0OpUqXw5MkTlXYGUoiIiPSUTLlqDzNSiD6xs1PURDH4+C24gRQYPpwFZ4kKUHx8PGQyGbNRqFiwsLBAQkKCShuLzRIREekpZY2UxERmpBCp8PUF6tRRTOdxdmYQhaiACYIAA4PC+528RCLBvn370KVLF10PhQoBAwODDMt6F95XPxERURFnJvuYkZLIjBSiDOzsgBo1GEQh0kOvX7/GsGHDUKZMGRgbG8PJyQmtW7fG+fPndT00ojzBjBQiIiI9pZzak5SYkEVPIiIi/dG9e3ckJiYiODgYZcuWRUREBE6ePIk3b97oemhEeYIZKURUaEVFATducMVLKrpMjYwAAIlJDKQQEVHh8O7dO5w7dw6LFi1C8+bN4ebmhvr162PKlCno1KmT2G/ZsmWoUaMGzMzMULp0aQwfPhwfPnwQ7w8KCoK1tTUOHTqESpUqwdTUFD169EBcXByCg4Ph7u6OkiVLYvTo0UhJSREf5+7uju+//x59+vQRC4WuXbs20zE/e/YMvXr1grW1NWxsbNC5c+cMxUXTCg0NhUQiwbFjx1C7dm3IZDK0aNECkZGR+O2331ClShVYWlqib9++KsvmpqamYsGCBfDw8IBMJoOnpyf27Nkj3p+SkgJ/f3/x/kqVKmHlypUq+/bz80OXLl0QEBAAZ2dn2NraYsSIEUhKShL7rFu3DhUqVICJiQkcHR3Ro0ePTI+fso+BFCIqlEJCAH9/YNp0xe+QEF2PiCjvicVmk1gjhYiICgdzc3OYm5tj//79kMvlGvsZGBhg1apV+PvvvxEcHIxTp05h4sSJKn3i4uKwatUq7Ny5E0ePHkVoaCi6du2KI0eO4MiRI9i2bRs2btyoEowAgCVLlsDT0xN//vknJk+ejDFjxuD48eNqx5GUlITWrVvDwsIC586dw/nz52Fubo42bdogMTEx02OdNWsW1qxZgwsXLojBmBUrVmDHjh04fPgwQkJCsHr1arH/ggULsHXrVmzYsAF///03xo0bh6+++gpnzpwBoAi0uLq6Yvfu3bh9+zZmzJiBqVOn4ueff1bZ7+nTp/Ho0SOcPn0awcHBCAoKQlBQEADg6tWrGD16NObMmYN79+7h6NGjaNKkifjYoKAgSCSSTI+LssapPURU6ERFAWvXAqmC4naqAKxbp6g7yKnyVJSYfgykMCOFiIgKixIlSiAoKAhDhgzBhg0bUKdOHTRt2hRffPEFatasKfYbO3as+G93d3fMnTsXQ4cOxbp168T2pKQkrF+/HuXKlQMA9OjRA9u2bUNERATMzc1RtWpVNG/eHKdPn0bv3r3FxzVq1AiTJ08GAFSsWBHnz5/H8uXL0apVqwzj3bVrF1JTU7F582YxwBAYGAhra2uEhobC19dX47HOnTsXjRo1AgD4+/tjypQpePTokbgsdI8ePXD69GlMmjQJcrkc8+fPx4kTJ+Dt7Q0AKFu2LH7//Xds3LgRTZs2haGhIWbPni1u38PDAxcvXsTPP/+MXr16ie0lS5bEmjVrIJVKUblyZbRv3x4nT57EkCFDEB4eDjMzM3To0AEWFhZwc3ND7dq1xcdaWVmhUqVKGo+JtMOMFCIqdF68+BREUUpJVSzeQFSUyDi1h4iICqHu3bvjxYsXOHjwINq0aYPQ0FDUqVNHzJoAgBMnTqBly5YoVaoULCws0K9fP7x580ZlKoypqakYRAEAR0dHuLu7w9zcXKUtMjJSZf/KQEXa23fu3FE71r/++gsPHz6EhYWFmE1jY2ODhIQEPHr0KNPjTBsYcnR0hKmpqRhEST+2hw8fIi4uDq1atRL3Y25ujq1bt6rsZ+3atfDy8oK9vT3Mzc2xadMmhIeHq+y3WrVqKktPOzs7i/tp1aoV3NzcULZsWfTr1w/bt29XOaddu3bF3bt3Mz0uyhozUoio0HFxAQwkqsEUqYFiBUyiokTMSElmIIWIiAoXExMTtGrVCq1atcJ3332HwYMHY+bMmfDz88OTJ0/QoUMHDBs2DPPmzYONjQ1+//13+Pv7IzExEaampgAAQ0NDlW1KJBK1bemXps2ODx8+wMvLC9u3b89wn729faaPTTuWrMamrP9y+PBhlCpVSqWf8cf/73fu3Ilvv/0WS5cuhbe3NywsLLBkyRJcunRJ437T78fCwgLXr19HaGgoQkJCMGPGDMyaNQtXrlyBtbV1psdD2mMghYgKHTs7YMQIxXSelFRFEGX4cE7roaJHmZGSnJKElJQUlW+fiIiICpOqVati//79AIBr164hNTUVS5cuhYGBYpJE+jogufHHH39kuF2lShW1fevUqYNdu3bBwcEBlpaWeTaG9KpWrQpjY2OEh4ejadOmavucP38eDRs2xPDhw8W2rLJi1ClRogR8fHzg4+ODmTNnwtraGqdOnUK3bt1yPH5SxUAKERVKvr6KmigvXyoyURhEoaJIWWwWABIT4yGTmWfSm4iISPfevHmDnj17YtCgQahZsyYsLCxw9epVLF68GJ07dwYAlC9fHklJSVi9ejU6duyI8+fPY8OGDXk2hvPnz2Px4sXo0qULjh8/jt27d+Pw4cNq+3755ZdYsmQJOnfujDlz5sDV1RVPnz7F3r17MXHiRLi6uubJmCwsLPDtt99i3LhxSE1NRePGjREdHY3z58/D0tISAwYMQIUKFbB161YcO3YMHh4e2LZtG65cuQIPDw+t93Po0CH8888/aNKkCUqWLIkjR44gNTVVrIuyb98+TJkyhdN7comBFCIqtOzsik8AJSpKURvGxaX4HDMBJmlSdxlIISKiwsDc3BwNGjTA8uXL8ejRIyQlJaF06dIYMmQIpk6dCgDw9PTEsmXLsGjRIkyZMgVNmjTBggUL0L9//zwZw//+9z9cvXoVs2fPhqWlJZYtW4bWrVur7WtqaoqzZ89i0qRJ6NatG96/f49SpUqhZcuWeZ6h8v3338Pe3h4LFizAP//8A2tra9SpU0c8L9988w3+/PNP9O7dGxKJBH369MHw4cPx22+/ab0Pa2tr7N27F7NmzUJCQgIqVKiA//u//0O1atUAANHR0bh3716eHldxJBEEQci6G+VGTEwMrKysEL11Kyw5Ly3X4uVylW9piTJTFF4vISGfVikykCimNWVSQJ5yQR9fLybdukOenITNm5/AwcFN18OhNOTyeBgby3Q9DNJzgiAgNvYd5PJ42Ng4c9lR0oqm95fHj2MwZowVoqOj83UaSlZOnz6NsLAwjBs3Tmdj0MTd3R1jx45VWRWIKDd2796NhIQE9OvXT2wrdKv2rF27Fu7u7jAxMUGDBg1w+fLlTPvv3r0blStXhomJCWrUqIEjR46o3L937174+vrC1tYWEokEYWFhGbaRkJCAESNGwNbWFubm5ujevTsiIiLy8rCIiNTStNRzVJRux0UFR1ZCkZWSmBiv45EQEREREVDIAim7du3C+PHjMXPmTFy/fh2enp5o3bp1huWulC5cuIA+ffrA398ff/75J7p06YIuXbrg1q1bYp/Y2Fg0btwYixYt0rjfcePG4ddff8Xu3btx5swZvHjxgoV6iKhAcKlnMjFUFJyVy+Oy6ElEREREBaFQ1UhZtmwZhgwZgoEDBwIANmzYgMOHD2PLli2YPHlyhv4rV65EmzZtMGHCBACKOWnHjx/HmjVrxGJGyvScJ0+eqN1ndHQ0fvzxR+zYsQMtWrQAAAQGBqJKlSr4448/8Nlnn+X1YRIRibjUM5mKgRRmpBAREWVF03UdUV4qNBkpiYmJuHbtGnx8fMQ2AwMD+Pj44OLFi2ofc/HiRZX+ANC6dWuN/dW5du0akpKSVLZTuXJllClTRuN25HI5YmJiVH6IiHJCudSz9OO7NZd6Ln6UBWeZkUJERESkHwpNRkpUVBRSUlLg6Oio0u7o6Khx6aZXr16p7f/q1Sut9/vq1SsYGRnBOl2R2My2s2DBAsyePTtDe7xcDkO5XOt9k3rxPIeUDUXh9fJ5U6BKdeDVK8DJCbCzBeIL/2HpJX18vRh/rJGiLFZJ+oPPB2lDEATI5fFITEyAXB7PYrOkFU3vL6yXRaQfCk0gpTCZMmUKxo8fL96OiYlB6dKlITM21rvVIAornkfKjqLweintovih/KdvrxczExMAgCCkcoUYPcTnhLIiCAKSkxVBWmNjGQMppDV17y9GRkk6GAkRpVdoAil2dnaQSqUZVsuJiIiAk5OT2sc4OTllq7+mbSQmJuLdu3cqWSmZbcfY2BjGevZBnIiICifZxxop8bEfdDwSIiIiIgIKUY0UIyMjeHl54eTJk2JbamoqTp48CW9vb7WP8fb2VukPAMePH9fYXx0vLy8YGhqqbOfevXsIDw/P1naIiIhyQmasCKQkskYKEREVIqGhoXB3d8/WY7Zs2aKxbAMVbX5+fujSpYuuh6G1QhNIAYDx48fjhx9+QHBwMO7cuYNhw4YhNjZWXMWnf//+mDJlith/zJgxOHr0KJYuXYq7d+9i1qxZuHr1KkaOHCn2+e+//xAWFobbt28DUARJwsLCxPonVlZW8Pf3x/jx43H69Glcu3YNAwcOhLe3N1fsISKifKecapQQz4wUIiIq3NauXQt3d3eYmJigQYMGuHz5ssr9ly5dwsaNG/NsfwsWLEC9evVgYWEBBwcHdOnSBffu3cv0Me/fv8fYsWPh5uYGmUyGhg0b4sqVK9napjZ93N3dIZFIMvyMGDGiwI41qzGcPXsWHTt2hIuLCyQSCfbv35/p9hYuXAiJRIKxY8eqtGd1TgHFirtBQUHZPexMdezYEW3atFF737lz5yCRSHDjxo0cbbtQBVJ69+6NgIAAzJgxA7Vq1UJYWBiOHj0qFpQNDw/Hy5cvxf4NGzbEjh07sGnTJnh6emLPnj3Yv38/qlevLvY5ePAgateujfbt2wMAvvjiC9SuXVtcHhkAli9fjg4dOqB79+5o0qQJnJycsHfv3gI6aiIiKs5MjT5mpCQwI4WIiAqvXbt2Yfz48Zg5cyauX78OT09PtG7dGpGRkWKfzp074+DBg3m2zzNnzmDEiBH4448/cPz4cSQlJcHX1xexsbEaHzN48GAcP34c27Ztw82bN+Hr6wsfHx88f/5c621q0+fKlSt4+fKl+HP8+HEAQM+ePTWOrVmzZhqDDTk51qzGEBsbC09PT6xdu1bjNtJua+PGjahZs2aG+7I6p4AigSH9Ai+55e/vj+PHj+Pff//NcF9gYCDq1q2rdrzakAiCIOR2gJS5mJgYWFlZIXrrVljm8YujOIqXy/WuGCTpL75eKDv08fUyctV6rD3xG7q2H4+B3yzV9XAoDbk8nsVmKUuCIIirbtnYOLPYLGlF0/vL48cxGDPGCtHR0bC0tNTByBROnz6NsLAwjBs3TmOf0NBQ+Pn54cmTJwCABg0aoF69elizZg0ARZmG0qVLY9SoUZg8eTIAQC6Xw9bWFn/88YfKl9955fXr13BwcMCZM2fQpEmTDPfHx8fDwsICBw4cEL9oBxTlHtq2bYu5c+dme5va9hk7diwOHTqEBw8eaHyfaNasGfz8/ODn55frY83uGCQSCfbt26d2+s2HDx9Qp04drFu3DnPnzkWtWrWwYsUKANqfUz8/P7x7905j1kuzZs1Qo0YNSKVSBAcHw8jICHPnzkXfvn0xcuRI7NmzB46Ojli9ejXatm0LAEhOToarqytGjhyJ6dOnq4zX2dkZS5YswdChQ7M8L7t370ZCQgL69esnthWqjBQiIqLiRlkjRZ6g+RslIiIifZaYmIhr167Bx8dHbDMwMICPjw8uXrwothkbG8PX11clKyUoKCjPApDR0dEAABsbG7X3JycnIyUlBSYfV8xTkslk+P3333O0TW36JCYm4qeffsKgQYMK7FjzcgwjRoxA+/btVZ5fpZycU02Cg4NhZ2eHy5cvY9SoURg2bBh69uyJhg0b4vr16/D19UW/fv0QF6fI4i1RogT69++PoKAgpM0f2b17N1JSUtCnT59s7T8tBlKIiIj0mHL540R5vI5HQgQgKgq4cUPxm4hIS1FRUUhJSRFLMig5OjqKtSmV0k/vsbKyQqVKlXI9htTUVIwdOxaNGjXSmO1iYWEBb29vfP/993jx4gVSUlLw008/4eLFiyolJLKzTW367N+/H+/evdMq00Qb2uwzr8awc+dOXL9+HQsWLFB7f3bPaWY8PT0xffp0VKhQAVOmTIGJiQns7OwwZMgQVKhQATNmzMCbN29U6p4MGjQIjx49wpkzZ8S2wMBAdO/eHVZWVtnaf1oMpBAREekxmYliqpGcNVJI10JCAH9/YPo0xe+QEF2PiIiKoHbt2uHy5cuI+hiw7dq1a5Yr+Wzfvh3m5ubiz7lz5zL0GTFiBG7duoWdO3dmuq1t27ZBEASUKlUKxsbGWLVqFfr06QMDg4yXztpsU5s+P/74I9q2bQsXFxeV9vnz52c4rqFDh6q0hYeH5/hYtRlDZp49e4YxY8Zg+/btGTJO0srOOc1M2nomUqkUtra2qFGjhtimDNSlrbtTuXJlNGzYEFu2bAEAPHz4EOfOnYO/v3+29p1eiVw9moiIiPKVmexjRkoSM1JIh6KigLVrASFVcVtIBdatA+rUAezsdDs2ItJ7dnZ2kEqliIiIUGmPiIiAk5OTStvjx49hbW2drcKjnTp1QoMGDcTbpUqVUrl/5MiROHToEM6ePQtXV9dMt1WuXDmcOXMGsbGxiImJgbOzM3r37o2yZctme5va9Hn69ClOnDihdjGToUOHolevXuLtL7/8Et27d0e3bt3EtvSBj+wcqzZjyMy1a9cQGRmJOnXqiG0pKSk4e/Ys1qxZA7lcDqlUqvU5zYqhoaHKbYlEotKmnJKUmpqq0s/f3x+jRo3C2rVrERgYiHLlyqFp06bZ2nd6DKQQERHpMVNlRoqcGSmUz6KigBcvABeXjMGRFy8+BVGUUlOAly8ZSCGiLBkZGcHLywsnT54Ui5Wmpqbi5MmTGDlypErfgwcPol27dihRQvtLVQsLC1hYWGRoFwQBo0aNwr59+xAaGgoPDw+tt2lmZgYzMzO8ffsWx44dw+LFi7XeZnb2GxgYCAcHB5VCrEo2NjYqNU5kMhkcHBxQvnz5PD3WzMaQmZYtW+LmzZsqbQMHDkTlypUxadIkSKVSlfs0ndP81qtXL4wZMwY7duzA1q1bMWzYsFzXomEghYiISI+JGSmJzEihfBQS8injRGIAjBgB+Pp+ut/FRdGeNphiIAWcnQt+rERUKI0fPx4DBgxA3bp1Ub9+faxYsQKxsbEYOHCgSr+DBw/iu+++E2/v27cPU6ZMyXJ6jzojRozAjh07cODAAVhYWIj1WKysrCCTybBmzRrs27cPJ0+eFB9z7NgxCIKASpUq4eHDh5gwYQIqV64sjjOrbWrbB1AEkwIDAzFgwIBsBY5ycqwA1B5vZmP48OEDHj58KN5+/PgxwsLCYGNjgzJlysDCwiJDDRYzMzPY2tqqtGd1TvObubk5evfujSlTpiAmJiZPatGwRgoREZEeM/24HHNiUoKOR0JFlqZpO2kLytrZKYIrBh+/XTSQAsOHMxuFiLTWu3dvBAQEYMaMGahVqxbCwsJw9OhRlQK0jx8/xr1799CmTRuxLTo6Gvfu3cvRPtevX4/o6Gg0a9YMzs7O4s+uXbsAKIrgPnr0SOUx0dHRGDFiBCpXroz+/fujcePGOHbsmDiFJKttatsHAE6cOIHw8HAMGjQoR8eXnWPVdLyZjeHq1auoXbs2ateuDUARDKtduzZmzJiRrbFldU4Lgr+/P96+fYvWrVtnqw6MJhIh7TpAlC9iYmJgZWWF6K1bYZmNuX6kXrxcDtnHCwuirPD1Qtmhj6+XE2FhaDVjBko7VsLaH7L/bRzlH7k8HsbGsqw76rsbNxQFZNObNx9IU8QPgCK48vKlIhOFQRStCIKA2Nh3kMvjYWPjnGdLm1LRpun95fHjGIwZY4Xo6GhYWlrqYGQKp0+fRlhYGMaNG6exT2hoKPz8/PDkyROtt7ty5UocOXIEx44dy4NRUmHSp08fSKVS/PTTT7oeSga7d+9GQkIC+vXrJ7YxI4WIiEiPfcpI4dQeyifKaTtpaZq2Y2enCK4wiEJE+eDgwYPo1KmTrodBBSg5ORm3b9/GxYsXUa1aNV0PR2uskUJERKTHZEZGAIDERE7toXyinLazbp2igCyn7RCRjqSt3UHFw61bt9CwYUM0b94cQ4cO1fVwtMZAChFRFjJbyIIov4kZKckMpFA+8vVVLGXMaTtElEfc3d0xduxYXQ+D9FytWrUQF1f4ViZkIIWIKBPKhSxSBcBAknEhC6L8JmOxWSoodnYMoBBRnmEghYoy1kghItJAuZBF6seS3KlCxoUsiPKbcmpPUkoiUlNTs+hNRERERPmNgRQiIg1evPgURFFKSVVkvhMVFNM0qwglMSuFiIiISOcYSCEi0sDFRTGdJy2pgfqFLIjyizIjBQDk8sI3h5iIiIioqGEghYhIA+VCFtKP75RSAy5kQQXPwMAAxlJFSTO5nEsgExEREekai80SEWWCC1mQPjApYQh5SjIzUih/cGkyIsoHoaGh8PPzw5MnT7R+zJYtW9CwYUNUrlw5/wZGesnPzw/v3r3D/v37dT0UrTAjhYgoC3Z2QI0avL4g3ZEZKqb3JCYyI4XyWEgI4O8PTJ+m+B0SousREVERdfbsWXTs2BEuLi6QSCRqL5gvXbqEjRs3Ftg+169fj5o1a8LS0hKWlpbw9vbGb7/9pnF77u7ukEgkGX5GjBgh9klJScF3330HDw8PyGQylCtXDt9//z0EQbXw3vPnz/HVV1/B1tYWMpkMNWrUwNWrV3N8rAsWLEC9evVgYWEBBwcHdOnSBffu3cvycWvXroW7uztMTEzQoEEDXL58WeV+bZ63rLahzdhWrlyJoKCgbB93Zjp27Ig2bdqove/cuXOQSCS4ceNGjrbNQAoREZGeM/kYSGFGCuUp5dJkwsfVoIRULk1GRPkmNjYWnp6eWLt2rcY+nTt3xsGDBwtsn66urli4cCGuXbuGq1evokWLFujcuTP+/vtvtf2vXLmCly9fij/Hjx8HAPTs2VPss2jRIqxfvx5r1qzBnTt3sGjRIixevBirV68W+7x9+xaNGjWCoaEhfvvtN9y+fRtLly5FyZIlNR5Ls2bNMg00nDlzBiNGjMAff/yB48ePIykpCb6+voiNjdX4mF27dmH8+PGYOXMmrl+/Dk9PT7Ru3RqRkZFin6zOoTbb0GZsVlZWsLa21jjWnPD398fx48fx77//ZrgvMDAQdevWRc2aNXO0bU7tISIi0nMmhoYAmJFCeezFi09BFKXUFMVcRqbgEVEea9u2Ldq2bZtpn5YtWyIiIgK3bt1C9erV832fHTt2VLk9b948rF+/Hn/88QeqVauWob+9vb3K7YULF6JcuXJo2rSp2HbhwgV07twZ7du3B6DIYvm///s/lSyNRYsWoXTp0ggMDBTbPDw8sndw6Rw9elTldlBQEBwcHHDt2jU0adJE7WOWLVuGIUOGYODAgQCADRs24PDhw9iyZQsmT54MIOtzqM02tBlbVlN7mjVrhho1akAqlSI4OBhGRkaYO3cu+vbti5EjR2LPnj1wdHTE6tWrxfF26NAB9vb2CAoKwvTp08VtffjwAbt378aSJUs0HldWmJFCRESk50yNOLWH8oGLCyBJ91HQQMqlyYhIZ4yNjeHr66uSlRIUFASJRJLJo/JGSkoKdu7cidjYWHh7e2fZPzExET/99BMGDRqkMr6GDRvi5MmTuH//PgDgr7/+wu+//64SjDh48CDq1q2Lnj17wsHBAbVr18YPP/yQp8cTHR0NALCxsdE4/mvXrsHHx0dsMzAwgI+PDy5evKjVPnK6jazGpklwcDDs7Oxw+fJljBo1CsOGDUPPnj3RsGFDXL9+Hb6+vujXrx/i4hQZvCVKlED//v0RFBSkMrVq9+7dSElJQZ8+fbK1/7QYSCEiItJzJkac2qNWVBRw4wanouSUcmkyA6nitoGUS5MRkc6ln95jZWWFSpUq5dv+bt68CXNzcxgbG2Po0KHYt28fqlatmuXj9u/fj3fv3sHPz0+lffLkyfjiiy9QuXJlGBoaonbt2hg7diy+/PJLsc8///yD9evXo0KFCjh27BiGDRuG0aNHIzg4OE+OKTU1FWPHjkWjRo00ZvZERUUhJSUFjo6OKu2Ojo549eqVVvvJyTa0GZsmnp6emD59OipUqIApU6bAxMQEdnZ2GDJkCCpUqIAZM2bgzZs3KnVPBg0ahEePHuHMmTNiW2BgILp37w4rK6ts7T8tBlKIiIj0nKmRMQAgIV7zPOdih0VS84avL7B5MzBvvuK3r6+uR1TwGJAj0ivt2rXD5cuXEfXxb7Jr1664e/dupo/Zvn07zM3NxZ9z585pvb9KlSohLCwMly5dwrBhwzBgwADcvn07y8f9+OOPaNu2LVxcXFTaf/75Z2zfvh07duzA9evXERwcjICAAJUgSWpqKurUqYP58+ejdu3a+PrrrzFkyBBs2LBB7DN//vwMxzR06FCVtvDwcLVjGzFiBG7duoWdO3dqfR4KSm7GlraeiVQqha2tLWrUqCG2KQM6aeuzVK5cGQ0bNsSWLVsAAA8fPsS5c+fg7++f00MAwBopREREek/MSGEgRUFTkdQ6dZhNkRN2dsX3vIWEfHotSQwUGTrFMZhEpEceP34Ma2vrbBUe7dSpExo0aCDeLlWqlNaPNTIyQvny5QEAXl5euHLlClauXJnp6kFPnz7FiRMnsHfv3gz3TZgwQcxKAYAaNWrg6dOnWLBgAQYMGAAAcHZ2zpD1UqVKFfzyyy/i7aFDh6JXr17i7S+//BLdu3dHt27dxLb0QRwAGDlyJA4dOoSzZ8/C1dVV4zHY2dlBKpUiIiJCpT0iIgJOTk4aH5ebbWg7Nk0MP9aMU5JIJCptyilWqamq9b/8/f0xatQorF27FoGBgRnq2uQEM1KIiIj0nKmxIiOFgZSPMiuSSqQtrlpEpJcOHjyIdu3aoUQJ7b/zt7CwQPny5cUfmUyW4/2npqZCLpdn2icwMBAODg5iQdm04uLiYGCgepktlUpVLu4bNWqUYfnf+/fvw83NTbxtY2OT4ZgcHBxU2tKeI0EQMHLkSOzbtw+nTp3KsnitkZERvLy8cPLkSZVjP3nypFY1YrKzjeyOLa/16tULBgYG2LFjB7Zu3Zqhrk1OMCOFiIhIz4mBlAQGUgB8KpKaNpjCIqmUXVy1iKhAffjwAQ8fPhRvP378GGFhYbCxsUGZMmXE9oMHD+K7774Tb+/btw9TpkzJcnpPTvY5ZcoUtG3bFmXKlMH79++xY8cOhIaG4tixY+Jj1qxZg3379onBgtTUVAQGBmLAgAFqgz0dO3bEvHnzUKZMGVSrVg1//vknli1bhkGDBol9xo0bh4YNG2L+/Pno1asXLl++jE2bNmHTpk3ZPkalESNGYMeOHThw4AAsLCzEGiVWVlaQyWQZjgMAxo8fjwEDBqBu3bqoX78+VqxYgdjYWHEFHm3OoTbbyGps+c3c3By9e/fGlClTEBMTk6GuTU4wkEJERKTnZMqpPQksNgvgU5HUdesUF74skko5wYAcUYG6evUqmjdvLt4eP348AGDAgAEICgoCoLhIv3fvHtq0aSP2i46OzpC9kVf7jIyMRP/+/fHy5UtYWVmhZs2aOHbsGFq1aiU+JioqCo8ePRJvnzhxAuHh4SqBkbRWr16N7777DsOHD0dkZCRcXFzwzTffYMaMGWKfevXqiQGiOXPmwMPDAytWrFApSJtd69evB6BYJjitwMBA+Pn5ZTgOAOjduzdev36NGTNm4NWrV6hVqxaOHj2qUjw2q3OozTayGltB8Pf3x48//oh27dqpnRKVXRIh7TpAlC9iYmJgZWWF6K1bYZmNuX6kXrxcDtnHb2eJssLXC2WHvr5evt3wI5YeOYD2PsPxzei1uh6O/oiKUmQPODvrJIgil8fD2Dj/v0mjfBQSkjEgl8c1UgRBQGzsO8jl8bCxcS6QZVyp8NP0/vL4cQzGjLFCdHQ0LC0tdTAyhdOnTyMsLAzjxo3T2Cc0NBR+fn548uSJ1ttduXIljhw5opIRQsVDnz59IJVK8dNPP+l6KBns3r0bCQkJ6Nevn9jGjBQiIiI9Z2rycWqPnFN7VBTnIqmUN3x9FUWKdRiQI6JPDh48qFJMlYq+5ORk3L9/HxcvXsQ333yj6+FojYEUIiIiPacMpCTK43U8EqIiiAE5Ir2Rtn4HFQ+3bt1Cw4YN0bx5cwwdOlTXw9EaAylERER6ztTEBAAgl7NGChUyUVGKoq4uLgxWEBUz7u7uGDt2rK6HQXquVq1aiIsrfJ9vGEghIiLSc2YyRSAlMZEZKVSIhIR8Wl5YYqAoEJzH9UeISH8xkEJFmUHWXYiIiEiXzGQfp/YkFr5vbKiYior6FEQBFL/XrVO0ExERFXIMpBAREek55fLHiYkJOh4JkZZevFBdVhhQrIzz8qVuxkNERJSHGEghIiLSc6Yfl2ROTOLUHiokXFwU03nSMpAqVsYhIiIq5BhIISIi0nOyj4EUOWukUGFhZ6eoiWIgVdw2kALDh7PgLBERFQksNktERKTnPmWkyHU8EqJs8PUF6tRRTOdxdmYQhYiIigwGUoiIiPScWCOFU3uosLGzy1kAhcsmExGRHmMghYiISM+JGSnJzEjJEi/ACz8um0xERHqOgRQiIiI9J2akJCdAEARIJBIdj0hP8QK88NO0bHKdOgyMERGR3mCxWSIiIj2nDKQAXAJZI00X4FFRuh0XZQ+XTSYiokKAgRQiIiI9p1y1BwASuXKPerwALxq4bDIRERUCDKQQERHpuRJSKQw/LiMrl8fpeDR6ihfgRQOXTSYiokKANVKIiIgKAZmhEZLk8cxI0UR5Ab5unSIThRfghReXTSYiIj3HQAoREVEhYFLCEDHyeGakZIYX4EVHTpdNzitc/YmIiDJR6Kb2rF27Fu7u7jAxMUGDBg1w+fLlTPvv3r0blStXhomJCWrUqIEjR46o3C8IAmbMmAFnZ2fIZDL4+PjgwYMHKn3u37+Pzp07w87ODpaWlmjcuDFOnz6d58dGRESkiYmhIQBALmdGSqbs7IAaNXjxSzkXEgL4+wPTpyl+h4ToekRERKRnClUgZdeuXRg/fjxmzpyJ69evw9PTE61bt0ZkZKTa/hcuXECfPn3g7++PP//8E126dEGXLl1w69Ytsc/ixYuxatUqbNiwAZcuXYKZmRlat26NhIRPqyJ06NABycnJOHXqFK5duwZPT0906NABr169yvdjJiIiAgCZkaLgLKf2EOUjrv5ERERaKFSBlGXLlmHIkCEYOHAgqlatig0bNsDU1BRbtmxR23/lypVo06YNJkyYgCpVquD7779HnTp1sGbNGgCKbJQVK1Zg+vTp6Ny5M2rWrImtW7fixYsX2L9/PwAgKioKDx48wOTJk1GzZk1UqFABCxcuRFxcnEpAhoiIKD/JxIwUTu0psqKigBs3eNGuS1z9iYiItFBoAimJiYm4du0afHx8xDYDAwP4+Pjg4sWLah9z8eJFlf4A0Lp1a7H/48eP8erVK5U+VlZWaNCggdjH1tYWlSpVwtatWxEbG4vk5GRs3LgRDg4O8PLyUrtfuVyOmJgYlR8iIqLcYEZKEcfpJPqBqz8REZEWCk2x2aioKKSkpMDR0VGl3dHREXfv3lX7mFevXqntr5ySo/ydWR+JRIITJ06gS5cusLCwgIGBARwcHHD06FGULFlS7X4XLFiA2bNnZ2iPl8thKJdrcbSUmXieQ8oGvl4oO/T59WJUQvFf9vuYt6yToify7Hl4EwWsWQVAOZ0kBVi7GqheBbBlrZcCZWEGfDMY2LhJ8TxIpMDX/or2HD7fgiBALo9HYmIC5PJ4SCSSPB40FUWa3l8YTCfSD4UmkKIrgiBgxIgRcHBwwLlz5yCTybB582Z07NgRV65cgbOabyimTJmC8ePHi7djYmJQunRpyIyNITM2LsjhF1k8j5QdfL1Qdujr68XcxAQAkJqcBGNjmY5HQ0p58lxEvQUgASD91CYAePMOcCmd++1T9rTrCNT3zrPVnwRBQHKyIkhrbCxjIIW0pu79xcgoSQcjIaL0Cs3UHjs7O0ilUkRERKi0R0REwMnJSe1jnJycMu2v/J1Zn1OnTuHQoUPYuXMnGjVqhDp16mDdunWQyWQIDg5Wu19jY2NYWlqq/BAREeWGMsAjj/+g45FQnuN0Ev3D1Z+ICoREIhFrU+YHPz8/dOnSJVfbCA0NhUQiwbt37/JkTFQ0FJpAipGREby8vHDy5EmxLTU1FSdPnoS3t7fax3h7e6v0B4Djx4+L/T08PODk5KTSJyYmBpcuXRL7xMUpivoZGKieKgMDA6SmpitGRkRElE9MjYwAcPnjIsnODhgxQhE8ARS/hw/nRTwRFVp+fn6QSCSQSCQwNDSEo6MjWrVqhS1btqhcQ718+RJt27bNt3GsXLkSQUFBudpGw4YN8fLlS1hZWeXNoD7K7yAS5a9CNbVn/PjxGDBgAOrWrYv69etjxYoViI2NxcCBAwEA/fv3R6lSpbBgwQIAwJgxY9C0aVMsXboU7du3x86dO3H16lVs2rQJgOLFO3bsWMydOxcVKlSAh4cHvvvuO7i4uIiRS29vb5QsWRIDBgzAjBkzIJPJ8MMPP+Dx48do3769Ts4DEREVP6Yfp/bIE2J1PBLKF76+QJ06eTadhIhI19q0aYPAwECkpKQgIiICR48exZgxY7Bnzx4cPHgQJUqU0DizILdSUlIgkUjyJPhhZGSUb+PMC0lJSTD8uLIfFZxCk5ECAL1790ZAQABmzJiBWrVqISwsDEePHhWLxYaHh+NlmuXpGjZsiB07dmDTpk3w9PTEnj17sH//flSvXl3sM3HiRIwaNQpff/016tWrhw8fPuDo0aMw+fiB1c7ODkePHsWHDx/QokUL1K1bF7///jsOHDgAT0/Pgj0BRKQTXJGU9IHM+GNGSgKXPy6yCnI6Cd/YiCifGRsbw8nJCaVKlUKdOnUwdepUHDhwAL/99puYJZI2KyMxMREjR46Es7MzTExM4ObmJn5BDgDv3r3DN998A0dHR5iYmKB69eo4dOgQACAoKAjW1tY4ePAgqlatCmNjY4SHh2eY2tOsWTOMGjUKY8eORcmSJeHo6IgffvhB/HLewsIC5cuXx2+//SY+Jv3UHuW+jh07hipVqsDc3Bxt2rRRuQ69cuUKWrVqBTs7O1hZWaFp06a4fv26eL+7uzsAoGvXrpBIJOJtAFi/fj3KlSsHIyMjVKpUCdu2bVM5rxKJBOvXr0enTp1gZmaGefPm5fQpolwoVBkpADBy5EiMHDlS7X2hoaEZ2nr27ImePXtq3J5EIsGcOXMwZ84cjX3q1q2LY8eOZXusRFT4hYQAa9cCqQJgIFFk3/v66npUpE+iooAXLxRlLvLz+tfsY4A/Uc5ACuWS8o1NSFXUZuEbGxEVkBYtWsDT0xN79+7F4MGDVe5btWoVDh48iJ9//hllypTBs2fP8OzZMwCKkg5t27bF+/fv8dNPP6FcuXK4ffs2pNJPRbrj4uKwaNEibN68Gba2tnBwcFA7huDgYEycOBGXL1/Grl27MGzYMOzbtw9du3bF1KlTsXz5cvTr1w/h4eEwNTVVu424uDgEBARg27ZtMDAwwFdffYVvv/0W27dvBwC8f/8eAwYMwOrVqyEIApYuXYp27drhwYMHsLCwwJUrV+Dg4IDAwEC0adNGPI59+/ZhzJgxWLFiBXx8fHDo0CEMHDgQrq6uaN68ubj/WbNmYeHChVixYgVKlCiBJ0+ewMPDA6dPn0azZs1y/PyQ9gpdIIWIqKBERX0KogCK3+vWKbLvmXVPQMEG2sRiswykUG4o39gE5VLLqfr7xlZQUUoiKlCVK1fGjRs3MrSHh4ejQoUKaNy4MSQSCdzc3MT7Tpw4gcuXL+POnTuoWLEiAKBs2bIqj09KSsK6deuynDXg6emJ6dOnA1Cstrpw4ULY2dlhyJAhAIAZM2Zg/fr1uHHjBj777DO120hKSsKGDRtQrlw5AIov+9N+Md+iRQuV/ps2bYK1tTXOnDmDDh06wN7eHgBgbW2tMm0oICAAfn5+GD58OABFaYs//vgDAQEBKoGUvn37iuUtAOD58+eoVKmSxsAP5b1CNbWHiCg3spvJ/uLFpyCKUkqqooQBkaZAW37NlDAzUQRSEhNZbJZy4cWLT0EUpdQU/XtjCwkB/P2B6dMUv0NCdD0iIsojgiCoXQbcz88PYWFhqFSpEkaPHo2QNH/3YWFhcHV1FYMo6hgZGaFmzZpZ7j9tH6lUCltbW9SoUUNsU5aNiIyM1LgNU1NTMYgCAM7Ozir9IyIiMGTIEFSoUAFWVlawtLTEhw8fEB4enunY7ty5g0aNGqm0NWrUCHfu3FFpq1u3rsrtUqVK4e7du6hfv36m26e8w4wUIioWcpI54OKi6Js2mCI14IqkpJBZoC0/vjw3lX0sNsuMFMoN5VLLaYMpebHUcl5mjxSmrBkiyrY7d+7Aw8MjQ3udOnXw+PFj/Pbbbzhx4gR69eoFHx8f7NmzBzKZLMvtymQytQGa9NIXZlWuLJT2NoBMV2hVtw1B+PShYMCAAXjz5g1WrlwJNzc3GBsbw9vbG4mJiVmOTxtmZmZ5sh3KOWakEFGRl9PMAeWKpNKP75RSA65ISp8oA21p5WegzZQZKZQX8mOp5bzOHiksWTNElG2nTp3CzZs30b17d7X3W1paonfv3vjhhx+wa9cu/PLLL/jvv/9Qs2ZN/Pvvv7h//34Bjzhnzp8/j9GjR6Ndu3aoVq0ajI2NEZXug6ehoSFSUlJU2qpUqYLz589n2FbVqlXzfcyUPcxIIaIiLzeZA1yRlDRRXo+uW6d4PeV3oM3sY0ZKYmJC/uyAio+8fGPLj+yR/MqaIaICJZfL8erVK5XljxcsWIAOHTqgf//+GfovW7YMzs7OqF27NgwMDLB79244OTnB2toaTZs2RZMmTdC9e3csW7YM5cuXx927dyGRSNCmTRsdHF3mKlSogG3btqFu3bqIiYnBhAkTMmTVuLu74+TJk2jUqBGMjY1RsmRJTJgwAb169ULt2rXh4+ODX3/9FXv37sWJEycy3d/z58/RsmVLbN26ldN7CggzUoioyMtt5kBBrkhKhYuvL7B5MzB/nuJ3fi58IjP6uPxxIqf2UB7Iqze2/MgeyY+sGSIqcEePHoWzszPc3d3Rpk0bnD59GqtWrcKBAwdUVttRsrCwwOLFi1G3bl3Uq1cPT548wZEjR2BgoLhk/eWXX1CvXj306dMHVatWxcSJEzNkdOiLH3/8EW/fvkWdOnXQr18/jB49OsMqQkuXLsXx48dRunRp1K5dGwDQpUsXrFy5EgEBAahWrRo2btyIwMDALFfiSUpKwr179xAXx88IBUUipJ3MRfkiJiYGVlZWiN66FZbW1roeTqEXL5eLq1cQZUX5egkJyZg5wNU+KT19fn859/ffaDJlCpxtPbAx8B9dD4cAyOXxMDbOet5+kRYVpZjOkz57ZPPmvKmVUgTSAQVBQGzsO8jl8bCxcdaqhgORpveXx49jMGaMFaKjo2FpaamDkSmcPn0aYWFhGDdunM7GQFRQdu/ejYSEBPTr109s49QeIioWOEWHCjtlRkpiEmukkB5JO8ctNSVvs0fs7PhmTUREeomBFCIqNviZnAoz04+ZMolJch2PhIqlzFblYaSaiIiKGQZSiIiICgExIyWZGSlUwJTrxwupiiKw6taPVwZPXrxQvZ0f8nKpZSIiohxgIIWIiKgQkKXJSBEEgXUWqGBouyqPNsGWvFBQ+yEiIsoEV+0hIiIqBJRTewQISE5O1PFoqNjQZlUeTcGWqKi8HUtB7YeI8l1oaCgkEgnevXtXoPsNCgqCdS4X/3jy5AkkEgnCwsI09tHV8VHBYSCFSMeiooAbN/g5kIgyp5zaAwByOZc3pALi4qLI/EjLQKq6fnx2l0DO6X98+bHUcm7k9j9wfgCgIkoikWT6M2vWLF0PUW8dO3YMn332GSwsLGBvb4/u3bvjyZMnGvs/efIE/v7+8PDwgEwmQ7ly5TBz5kwkJqp+4SIIAgICAlCxYkUYGxujVKlSmDdvnnj/y5cv0bdvX1SsWBEGBgYYO3as2v29e/cOI0aMgLOzM4yNjVGxYkUcOXIkLw5dVKNGDQwdOlTtfdu2bYOxsTGi9OB9k1N7iHRImaGcKgAGEmYoE5FmhiVKoISBAZJTUyGXx8PcvKSuh0TFgTar8iiDLemXQE4bbFHKzdSc7Ownv6k7jjp1tK/dwilKVIS9TBPc3LVrF2bMmIF79+6Jbebm5rh69Wq2t5uYmAijNF8qFDWPHz9G586dMX78eGzfvh3R0dEYN24cunXrhuvXr6t9zN27d5GamoqNGzeifPnyuHXrFoYMGYLY2FgEBASI/caMGYOQkBAEBASgRo0a+O+///Dff/+J98vlctjb22P69OlYvny52n0lJiaiVatWcHBwwJ49e1CqVCk8ffo01xk+6fn7+2PWrFlYvnw5ZDLVJcADAwPRqVMn2OlBfSxmpBDpiDJDOVVQ3E4VmKFMRJkzKWEIgBkpVADSZkv4+gKbNwPz5it+qys0O2KEIqgBaF4CObdTc7TdT35Tdxxr1gD+/sD0aYrfISHZezw/AFAR4uTkJP5YWVlBIpGotJmbm4t9r127hrp168LU1BQNGzZUCbjMmjULtWrVwubNm+Hh4QETExMAiqyIwYMHw97eHpaWlmjRogX++usv8XF//fUXmjdvDgsLC1haWsLLyytD4ObYsWOoUqUKzM3N0aZNG5XgT2pqKubMmQNXV1cYGxujVq1aOHr0aKbHfOTIEVSsWBEymQzNmzfPNItEk2vXriElJQVz585FuXLlUKdOHXz77bcICwtDUlKS2se0adMGgYGB8PX1RdmyZdGpUyd8++232Lt3r9jnzp07WL9+PQ4cOIBOnTrBw8MDXl5eaNWqldjH3d0dK1euRP/+/WFlZaV2X1u2bMF///2H/fv3o1GjRnB3d0fTpk3h6emp8ZiUU6kOHTqESpUqwdTUFD169EBcXByCg4Ph7u6OkiVLYvTo0UhJSQEAfPXVV4iPj8cvv/yisq3Hjx8jNDQU/v7+Wp/T/MRACpGOvHjxKYiilJKquwxlItJ/MsOPK/ckcuUeykchIRmDAnZ2QI0amoMW6oIt6aeu5MXUnKyCOgVB3XFA0D4wom9TlIh0aNq0aVi6dCmuXr2KEiVKYNCgQSr3P3z4EL/88gv27t0r1iTp2bMnIiMj8dtvv+HatWuoU6cOWrZsKWZYfPnll3B1dcWVK1dw7do1TJ48GYaGhuI24+LiEBAQgG3btuHs2bMIDw/Ht99+K96/cuVKLF26FAEBAbhx4wZat26NTp064cGDB2qP4dmzZ+jWrRs6duyIsLAwDB48GJMnT87QTyKRICgoSOO58PLygoGBAQIDA5GSkoLo6Ghs27YNPj4+KuPPSnR0NGxsbMTbv/76K8qWLYtDhw7Bw8MD7u7uGDx4sEpGijYOHjwIb29vjBgxAo6OjqhevTrmz58vBkA0iYuLw6pVq7Bz504cPXoUoaGh6Nq1K44cOYIjR45g27Zt2LhxI/bs2QMAsLOzQ+fOnbFlyxaV7QQFBcHV1RW+epK9x6k9RDri4qKYzpM2mCI10E2GMhEVDiYfAynMSKF8o+0qPerY2X3qo2nqS15MzUm7H11QN8UoPWVgRN049WmKEpGOzZs3D02bNgUATJ48Ge3bt0dCQoKYfZKYmIitW7fC3t4eAPD777/j8uXLiIyMhPHHIuwBAQHYv38/9uzZg6+//hrh4eGYMGECKleuDACoUKGCyj6TkpKwYcMGlCtXDgAwcuRIzJkzR7w/ICAAkyZNwhdffAEAWLRoEU6fPo0VK1Zg7dq1GY5h/fr1KFeuHJYuXQoAqFSpEm7evIlFixap9KtUqZLGbA8A8PDwQEhICHr16oVvvvkGKSkp8Pb2zlYNkocPH2L16tUq03r++ecfPH36FLt378bWrVuRkpKCcePGoUePHjh16pTW2/7nn39w6tQpfPnllzhy5AgePnyI4cOHIykpCTNnztT4uKSkJPEcAUCPHj2wbds2REREwNzcHFWrVkXz5s1x+vRp9O7dG4Biek/btm3x+PFjeHh4QBAEBAcHY8CAATAw0I9cEP0YBVExpMxQln78K5Qa6CZDmYgKD+XUHmakUL7Ji2wJTcEYQD+m5uRW+ilGEgMA6ZYjzywwoi9TlIj0QM2aNcV/O3/8m4mMjBTb3NzcxCAKoJi28+HDB9ja2sLc3Fz8efz4MR49egQAGD9+PAYPHgwfHx8sXLhQbFcyNTUVL+qV+1XuMyYmBi9evECjRo1UHtOoUSPcuXNH7THcuXMHDRo0UGnz9vbO0O/u3bvo2rWrxnPx6tUrDBkyBAMGDMCVK1dw5swZGBkZoUePHhAEQePjlJ4/f442bdqgZ8+eGDJkiNiempoKuVyOrVu34vPPP0ezZs3w448/4vTp0ypTqbKSmpoKBwcHbNq0CV5eXujduzemTZuGDRs2ZPq49Ofb0dER7u7uKlO8HB0dVZ73Vq1awdXVFYGBgQCAkydPIjw8HAMHDtR6vPmNGSlEOuTrq/iC7uVLxectfoYiosyYGnFqD+WzvMiWyCwYU9D/8UVFaV8ANjvSH8f165kX5M3q8fwAQMVU2ikrEokiIJma+un9w8zMTKX/hw8f4OzsjNDQ0AzbUhY9nTVrFvr27YvDhw/jt99+w8yZM7Fz504xiJF+moxEItEqUJHf1q5dCysrKyxevFhs++mnn1C6dGlcunQJn332mcbHvnjxAs2bN0fDhg2xadMmlfucnZ1RokQJVKxYUWyrUqUKACA8PByVKlXSanzOzs4wNDSEVCpV2c6rV68yLQSs7nyra0v7vBsYGMDPzw/BwcGYNWsWAgMD0bx5c5QtW1arsRYEBlKIdEzXGcpEVHiYGHFqT7GSX0GAzGizSk9WZCbq202MP+2jII4nv1fGSXscOQmM8AMAUbbVqVMHr169QokSJeDu7q6xX8WKFVGxYkWMGzcOffr0QWBgYKbZIEqWlpZwcXHB+fPnxSlHAHD+/HnUr19f7WOqVKmCgwcPqrT98ccf2h1QGnFxcRmmrSiDFmmDDOk9f/4czZs3h5eXFwIDAzNso1GjRkhOTsajR4/EzJD79+8DUGT8aKtRo0bYsWMHUlNTxX3cv38fzs7O+bKa0sCBAzF37lzs3bsX+/btw+bNm/N8H7nBqT1EVKylr4VIpM9MjRQXognxsToeCeU7dQVfC0puC7rGJ6hvT5Dnfmza0sXKOFkV5CWiXPPx8YG3tze6dOmCkJAQPHnyBBcuXMC0adNw9epVxMfHY+TIkQgNDcXTp09x/vx5XLlyRczA0MaECROwaNEi7Nq1C/fu3cPkyZMRFhaGMWPGqO0/dOhQPHjwABMmTMC9e/ewY8cOtUVlK1eujH379mncb/v27XHlyhXMmTMHDx48wPXr1zFw4EC4ubmhdu3aAIDLly+jcuXKeP78OQBFEKVZs2YoU6YMAgIC8Pr1a7x69QqvXr1SOWd16tTBoEGD8Oeff+LatWv45ptv0KpVK5UslbCwMISFheHDhw94/fo1wsLCcPv2bfH+YcOG4b///sOYMWNw//59HD58GPPnz8eIESO0PrfZ4eHhgRYtWuDrr7+GsbExunXrli/7ySlmpBBRsaX8sjJVUBT+zesvK4nympiRksBASpGWm4KveSU32RL6UEw1s+lFDHRkpIvsJ6IckEgkOHLkCKZNm4aBAwfi9evXcHJyQpMmTeDo6AipVIo3b96gf//+iIiIgJ2dHbp164bZs2drvY/Ro0cjOjoa//vf/xAZGYmqVavi4MGDGYrWKpUpUwa//PILxo0bh9WrV6N+/fqYP39+hhWI7t27h+joaI37bdGiBXbs2IHFixdj8eLFMDU1hbe3N44ePQqZTAZAkbVy7949cTnk48eP4+HDh3j48CFcXV1VtqecrmRgYIBff/0Vo0aNQpMmTWBmZoa2bduKxXGVlMEaQLEU844dO+Dm5iYu5Vy6dGkcO3YM48aNQ82aNVGqVCmMGTMGkyZN0uKs5oy/vz9OnjyJ4cOHiwWI9YVE0IcJYUVcTEwMrKysEL11Kyw/zt2jnIuXyyH7WKWbKCuaXi9RUYovedOvmrR5c9H+DMnPypnT9/eXHrPn45drf2BQ/wB06fE/XQ+n2JPL42FsLMv7Dd+4ochESW/efEXGQ2EQEpJxelBBRqqVb/Lpgzk6eJMXBAGxse8gl8fDxsZZrAOhN/J7ChTliKb3l8ePYzBmjBWio6NhaWmpg5EpnD59GmFhYRg3bpzOxkBUUHbv3o2EhAT069dPbGNGChEVSy9eqAZRACAlVT+/rMyr4AczcAo/mZiR8kHHI6F8pQ8ZHUo5fQPSdTHVvKj1UhzoQ/YTEVEhxEAKERVLLi6KYEL6jBRdXKdkJq+CH8rPysrjTRX4WbkwUmbLyBNYbLZI05cgQG4zFXRdTFXXwZzCgFOgiIhyhIEUIiqW0l6npKQqgij69mVlXgY/ClMGDmlm9nHVk0Q5lz8u8nQdBCgqmQq6DuboO33KfsoK56YSkR5hIIWIii1dX6dkJS+DH4UlA4cy9ykjhcVmiwVdBgF0nanAi+aCoS/ZT1lhHRci0jMMpBBRsabPX1bmZfCjMGTgUNbMPlaslzMjhfKbLjMVeNFcsPT9W4Wikh1FREUKAylERHoqr4Mf+vJZuah/0Zyfx2f6cWqPXM4aKZTPdJWpwItm3dDnbxV0nR1FRKQGAylERHosr4Mfuv6sXNRXDsrv4zOTKTJSkhKZkUIFQBfRV140U3qFqY4LERUbBroeABERZc7ODqhRo/BfQ2gqnhsVpdtx5ZXMji8lKQny//5T6S//7z+kJCVlax+mso8ZKYnMSKECUtBvQMqL5rR40Vy8KbOjDKSK2/pax4XUEgQBy5Ytg4eHB0xNTdGlSxdER0dr7Pv111/DxsYGEokEYWFhBTtYPdKsWTOMHTtW18MoVrJ7zhlIISLSkago4MaNohNIyEpmxXOLAk3H9/xZMv5atAh/TJqE+NevAQDxr1/jj0mT8NeiRdkKpph+LDabyIwUKqp40Uzq+PoCmzcD8+YrfhelVMYibsKECVi/fj2Cg4Nx7tw5XLt2DbNmzVLb9+jRowgKCsKhQ4fw8uVLVK9evWAHq0f27t2L77//Pk+3uX79etSsWROWlpawtLSEt7c3fvvtt0wfc/bsWXTs2BEuLi6QSCTYv3+/2n5r166Fu7s7TExM0KBBA1y+fFltv4ULF0IikWQIWKSkpOC7776Dh4cHZDIZypUrh++//x6CIKjdjj7g1B4qkop6DYbipig+n0V9ios6RX3lIE3HZ2/xAQ+ePkV8RAQuT52KmuPG4cby5YiPiAAAJL9/D6mNjVb7UAZS5EkJeT5+Ir2hLwWdSL/oem4qZdulS5ewbNkyXL16FXXq1AEADBkyBNu3b8fy5csz9H/06BGcnZ3RsGFDjdtMTEyEkZFRvo1ZX9ho+bkgO1xdXbFw4UJUqFABgiAgODgYnTt3xp9//olq1aqpfUxsbCw8PT0xaNAgdOvWTW2fXbt2Yfz48diwYQMaNGiAFStWoHXr1rh37x4cHBzEfleuXMHGjRtRs2bNDNtYtGiRGHCrVq0arl69ioEDB8LKygqjR4/W6vgK+rXBjBQqckJCAH9/YNp0xe+QEF2PiHKjKD6fRX2KiybKL5qlH//nKWorB2k6Ppfy1qg/fz5kjo6Ij4jApcmTER8RAZmjI+rPnw/jbHxYkjEjhYqLojKnkagYCwgIQMuWLcUgCgA4OjoiSs0HHj8/P4waNQrh4eGQSCRwd3cHoJhuMXLkSIwdOxZ2dnZo3bo1AEAul2P06NFwcHCAiYkJGjdujCtXrojba9asGUaNGoWxY8eiZMmScHR0xA8//IDY2FgMHDgQFhYWKF++fKYZGVu3boWtrS3kcrlKe5cuXdCvX79Mj/3o0aNo3LgxrK2tYWtriw4dOuDRo0cAgNevX8PJyQnz588X+1+4cAFGRkY4efKkOP60WRt79uxBjRo1IJPJYGtrCx8fH8TGxmY6hvQ6duyIdu3aoUKFCqhYsSLmzZsHc3Nz/PHHHxof07ZtW8ydOxddu3bV2GfZsmUYMmQIBg4ciKpVq2LDhg0wNTXFli1bxD4fPnzAl19+iR9++AElS5bMsI0LFy6gc+fOaN++Pdzd3dGjRw/4+vpqzGwBNL82Mjv3SrGxsejfvz/Mzc3h7OyMpUuXatyPJgykUJFSXC9Qi6qi+nwW9SkumVFmZ8+fVzSzszUdn8zeHjXHjVPpW3PcOMjs7bO1fXFqDzNSiIhIj8nlchw+fDjDBXhCQgKsrKwy9F+5ciXmzJkDV1dXvHz5UiUoEhwcDCMjI5w/fx4bNmwAAEycOBG//PILgoODcf36dZQvXx6tW7fGf2nqkQUHB8POzg6XL1/GqFGjMGzYMPTs2RMNGzbE9evX4evri379+iEuTn3dsZ49eyIlJQUHDx4U2yIjI3H48GEMGjQo0+OPjY3F+PHjcfXqVZw8eRIGBgbo2rUrUlNTYW9vjy1btmDWrFm4evUq3r9/j379+mHkyJFo2bJlhm29fPkSffr0waBBg3Dnzh2EhoaiW7du4rSXoKAgSCSSTMeTXkpKCnbu3InY2Fh4e3tn67FpJSYm4tq1a/Dx8RHbDAwM4OPjg4sXL4ptI0aMQPv27VX6pdWwYUOcPHkS9+/fBwD89ddf+P3339G2bdtM96/utZHZuVeaMGECzpw5gwMHDiAkJAShoaG4fv16to6dU3uoSMnsApVfahU+RfX5LOpTXLJS1LOz1R1f/OvXuJEujfnG8uWKTJVsBFNkH1NWGUihLBXFOZFEVGhcv34d8fHx+N///oeJEyeK7UlJSWjevHmG/lZWVrCwsIBUKoWTk5PKfRUqVMDixYvF27GxsVi/fj2CgoLEC+0ffvgBx48fx48//ogJEyYAADw9PTF9+nQAwJQpU7Bw4ULY2dlhyJAhAIAZM2Zg/fr1uHHjBj777LMMY5LJZOjbty8CAwPRs2dPAMBPP/2EMmXKoFmzZpkef/fu3VVub9myBfb29rh9+zaqV6+Odu3aYciQIfjyyy9Rt25dmJmZYcGCBWq39fLlSyQnJ6Nbt25wc3MDANSoUUPl3FWqVCnT8SjdvHkT3t7eSEhIgLm5Ofbt24eqVatq9Vh1oqKikJKSAkdHR5V2R0dH3L17FwCwc+dOXL9+XSU4lt7kyZMRExODypUrQyqVIiUlBfPmzcOXX36Z6f7TvzaArM/9hw8f8OOPP+Knn34SA1fBwcFwdXXV+rgBZqRQEaO8QE0rvy5Qi1uh0JzI7TkqyOezIBX1KS6kSv7ff7g8dao4nafBwoXiNJ/LU6dmWM0nMwykqFFY3owLcpzKOZHTpxWdOZHFXWF5nRN9dP/+fZiZmeHmzZsICwsTf9zd3dGoUaNsbcvLy0vl9qNHj5CUlKSyHUNDQ9SvXx937twR29LW4pBKpbC1tVUJQCgv/iMjIzXue8iQIQgJCcHz588BKLI//Pz8xAyQ7du3w9zcXPw5d+4cAODBgwfo06cPypYtC0tLS3GqUnh4uLjtgIAAJCcnY/fu3di+fTuMP2adpufp6YmWLVuiRo0a6NmzJ3744Qe8fftWvL9r165i0CIrlSpVQlhYGC5duoRhw4ZhwIABuH37tlaPzYlnz55hzJgx2L59O0xMTDT2+/nnn7F9+3bs2LED169fR3BwMAICAhAcHJzp9tO/NoCsz/2jR4+QmJiIBg0aiI+xsbHROhilxIwUKlKUF6jr1ikyF/LrArU4FgrNrrw4RwX1fOoCaykWHyUsLGDx8RskZQZK/fnzcXnqVFi4uaGEhYXW2xKn9iTLIQhCtlN5ixzlG42QqlgyV1/fjAtynMo5kcLHFGYhVfEmWqcO32gKq8LyOidKIyYmBnZ2dihfvrzY9vTpUzx48CBDxkBWzMzMcjQGQ0NDldsSiUSlTfl/aNopH+nVrl0bnp6e2Lp1K3x9ffH333/j8OHD4v2dOnVSuSAvVaoUAEU9Ejc3N/zwww9wcXFBamoqqlevjsTERLHvo0eP8OLFC6SmpuLJkycqQZ60pFIpjh8/jgsXLiAkJASrV6/GtGnTcOnSJXh4eGTjjABGRkbic+Ll5YUrV65g5cqV2LhxY7a2o2RnZwepVIqIjwX0lSIiIuDk5IRr164hMjJSpU5OSkoKzp49izVr1kAul0MqlWLChAmYPHkyvvjiCwCKjJunT59iwYIFGDBggMb9q3ttaHPu8wIDKVTk5PcFqqa6HfyM+klenqOiHHAo6lNcSEFqaAjPSZOQ/P69WFhWZm+PzxYtQgkLC0jTfdDLjDIjJVVIQXJyEgwNi/7KBRoVloBBQY/zxYtP+1JKTSn8cyKLq8LyOidKx87ODtHR0SpB/3nz5qFdu3a5mkoCAOXKlRPrYiinuiQlJeHKlSsZltXNC4MHD8aKFSvw/Plz+Pj4oHTp0uJ9FhYWsEj3hcibN29w7949/PDDD/j8888BAL///rtKn8TERHz11Vfo3bs3KlWqhMGDB+PmzZsqq9ykJZFI0KhRIzRq1AgzZsyAm5sb9u3bh/Hjx+fq2FJTUzMU080OIyMjeHl54eTJk+jSpYu4zZMnT4o1X27evKnymIEDB6Jy5cqYNGkSpFLFUvdxcXEwMFCdLCOVSjMNcqmjzbkvV64cDA0NcenSJZQpUwYA8PbtW9y/fx9NmzbVel8MpFCRlJ8XqEW1bkdeyutzxIADFXZSQ8MMSxxnZ7UeJdM0ab+JifHFO5BSWAIGBT1OFxcAEgBp34QlhX9OZHFVWF7nROm0aNECCQkJWLhwIb744gts374dv/76a6arsGjLzMwMw4YNw4QJE2BjY4MyZcpg8eLFiIuLg7+/fx6MXlXfvn3x7bff4ocffsDWrVuz7F+yZEnY2tpi06ZNcHZ2Rnh4OCZPnqzSZ9q0aYiOjsaqVatgbm6OI0eOYNCgQTh06FCG7V26dAknT56Er68vHBwccOnSJbx+/RpVqlQBAOzbtw9TpkzJcnrPlClT0LZtW5QpUwbv37/Hjh07EBoaimPHjgEA1qxZg3379okrBwGK1XYePnwo3n78+DHCwsLE8w4A48ePx4ABA1C3bl3Ur18fK1asUFkdqXr16irjMDMzg62trUp7x44dMW/ePJQpUwbVqlXDn3/+iWXLlmVZ1Dc9bc69ubk5/P39MWHCBNja2sLBwQHTpk3LEMjJCgMpRNlU3AuFaoPniCh/GJYoAQOJBKmCALk8DmZmGVc+KDZcXBTTHNJeZBpI9e+NRh/GWdyngOWEvhTr1YfXD1EOODo6IigoCBMmTMD333+PFi1a4Pfff1fJ5siNhQsXIjU1Ff369cP79+9Rt25dHDt2TO3SurllZWWF7t274/Dhw2LWRWYMDAywc+dOjB49GtWrV0elSpWwatUqsUBtaGgoVqxYgdOnT8PS0hIAsG3bNnh6emL9+vUYNmyYyvYsLS1x9uxZrFixAjExMXBzc8PSpUvFQrvR0dG4d+9eluOKjIxE//798fLlS1hZWaFmzZo4duwYWrVqBUBRODb9MsFXr15VKQ6szIAZMGAAgoKCAAC9e/fG69evMWPGDLx69Qq1atXC0aNHMxSgzczq1avx3XffYfjw4YiMjISLiwu++eYbzJgxQ+ttAFmfe6UlS5bgw4cP6NixIywsLPC///0P0dHR2dqXRFCum0T5JiYmBlZWVojeuhWW1ta6Hk6hFy+XQ6ahGFNBCQnJWLeD05VV6cs50ofXCxUeheH1Yt69J2KT5Ni06RGcnMrqeji6pXyjSU1RXFwW8BuNXB4PY2NZ1h0Lcpw3biiKzKY3bz6gYf49pZPHNUkEQUBs7DvI5fGwsXHOfm2j9K+fAf2BcuV1H+ShfKXp/eXx4xiMGWOF6Oho8SJcF06fPo2wsDCMGzdOZ2MoSC1btkS1atWwatUqXQ+FdGD37t1ISEhAv379xDZmpBDlQFGu25FXeI6yJ7tffurLl6VU8EwMDRGbJIdcHqfroeheYXmjKchxMoMhd/SxJkna18+DB0BQMAvPEhWQt2/fIjQ0FKGhoVi3bp2uh0N6hIEUohxi3Y6s8RxpJ7srHHHVqKIlJSlJpRAtoFgyWVMhWpOPbYmJ8QU2Rr1WWN5o8nOc6SOryuXO0mbAFIZzpI38jiLra00S5b6nT9evIA9REVe7dm28ffsWixYtyvbyuFS0MZBCRJRLuflcn90VjrhqVNGSkpSEvxYtwvunT8WlkeNfvxaXRvacNClDMMXUUDH1SC5nIIWgeRpKYcjUya6CWAZYnzN69DXIQ1SEPXnyRNdDID2VvdK0emDt2rVwd3eHiYkJGjRokGXl5927d6Ny5cowMTFBjRo1cOTIEZX7BUHAjBkz4OzsDJlMBh8fHzx48CDDdg4fPowGDRpAJpOhZMmSWhUaIqKiLyQE8PcHpk1X/A4Jyd7jM1vhKC/660JUlKJMQ1SUrkei/5Lfv8f7p08RHxGBy1On4u3t27g8dSriIyLw/ulTJL9/n+ExyowUTu0hjdNQoqIUF9Y1ahSdC+zMjjUvKTN6DBRLcupVRo8yyJOWvgR5iIiKmUIVSNm1axfGjx+PmTNn4vr16/D09ETr1q0RGRmptv+FCxfQp08f+Pv7488//0SXLl3QpUsX3Lp1S+yzePFirFq1Chs2bMClS5dgZmaG1q1bIyEhQezzyy+/oF+/fhg4cCD++usvnD9/Hn379s334yUi/aYpOyQ7n+uVKxylldkKR9ntX9ByG1gqboxtbBSZKI6OiI+IwKXJkxEfEQGZoyPqz5+vdolkmZEiI4VTeyjTDIWipiCP1dcX2LxZUaB382b9mTupz0EeIqJiplAFUpYtW4YhQ4Zg4MCBqFq1KjZs2ABTU1Ns2bJFbf+VK1eiTZs2mDBhAqpUqYLvv/8ederUwZo1awAoslFWrFiB6dOno3PnzqhZsya2bt2KFy9eYP/+/QCA5ORkjBkzBkuWLMHQoUNRsWJFVK1aFb169SqowyYiPZUX2SHKz8XSj+/GyhWONH0uzm7/gpQXgaXiSGZvj5rpVj2oOW4cZPb26vsbGQEAEhJi831spOeKU4ZCQR+rvmb06GuQh4iomCk0gZTExERcu3YNPj4+YpuBgQF8fHxw8eJFtY+5ePGiSn8AaN26tdj/8ePHePXqlUofKysrNGjQQOxz/fp1PH/+HAYGBqhduzacnZ3Rtm1blayW9ORyOWJiYlR+iKjoyavsEOXn4vnztPtcnN3+BaUwTDvSR/GvX+PG8uUqbTeWL0f869dq+5t+DKQkxmcRSOEcq6KvOGUoFKdjzYq+BnmIiIqRQlNsNioqCikpKXB0dFRpd3R0xN27d9U+5tWrV2r7v3r1Srxf2aapzz///AMAmDVrFpYtWwZ3d3csXboUzZo1w/3792GjJu16wYIFmD17dob2eLkchnK5NodLmYjnOaRsyM/Xi5kFMPgbYNNGIEUApBLA/2tFe3w2d2tmAZS3UPxbm8dmt39BKGkHCADSJt9LJYC1rf6MMSsF/f4if/sWl6dPR3xkJGQODqg+ahRurV6NdxERODdlCurPnQvjkiVVHmNYQlEj5cOHd5oLzp48AWzYCMWzYQAM/QZo6aO+L+WY1gV/30R9Kvxqm8cXv00/B6pXAV69ApycFNvXZlz5Oab82k9Oj1XHBEGAXB6PxMQEyOXxkEgkWT+Iij1N7y+c1kmkHwpNIEVXUlMVlwTTpk1D9+7dAQCBgYFwdXXF7t278c0332R4zJQpUzB+/HjxdkxMDEqXLg2ZsTFkxsYFM/AijueRsiM/Xy8d2wHe9Yve4hg5UdoFGD1SMZ0nJfXTtKPSLroeWfYU5PuLka0t7Nzd8V4iEVftKblggbhqj4WtbYZVeyxkJgAUK/4YG8sybjQqCti4GYAEwMdv7zf9CNT31t0LNL+XrNUhtc9BWgWy0kxpxY+2CmJM+bWf7B6rHhAEAcnJiiCtsbGMgRTSmrr3FyOjJB2MhIjSKzSBFDs7O0ilUkRERKi0R0REwMnJSe1jnJycMu2v/B0REQHnNLn4ERERqFWrFgCI7VWrVhXvNzY2RtmyZREeHq52v8bGxjDmhT5RkaTuetDOrshdG+ZYUV11Nb9IDQ3hOWkSkt+/FwvLyuzt8dmiRShhYZEhiAJ8CvQkalq1R9+WSC2oi/bcyo9gj6aVZnS5XnlBjUkfjz27inAAkIiIcqfQ1EgxMjKCl5cXTp48Kbalpqbi5MmT8Pb2VvsYb29vlf4AcPz4cbG/h4cHnJycVPrExMTg0qVLYh8vLy8YGxvj3r17Yp+kpCQ8efIEbm5ueXZ8RKQfMisrwRVptMPp+9kjNTTMsDqPsY2N2iAKAJh+DKTINRWb1acCpAW1ZG1uREUBgVuAQYOA6dPy9o87tyvN5Eedm4Ja/aawryikfMPP69cEEREVCYUmIwUAxo8fjwEDBqBu3bqoX78+VqxYgdjYWAwcOBAA0L9/f5QqVQoLFiwAAIwZMwZNmzbF0qVL0b59e+zcuRNXr17Fpk2bAAASiQRjx47F3LlzUaFCBXh4eOC7776Di4sLunTpAgCwtLTE0KFDMXPmTJQuXRpubm5YsmQJAKBnz54FfxKI9FRR+OJO+cV5qqAoIpv2i3NNK9IUpi9XqWgw/Ti1R56gISNFWZRz3TrFhasui3LqW3ZMemmzZZTyMnNCGdRKu31tg1r5lcmTmzHp437yQ1HIpiEionxVqAIpvXv3xuvXrzFjxgy8evUKtWrVwtGjR8ViseHh4TAw+PQtXMOGDbFjxw5Mnz4dU6dORYUKFbB//35Ur15d7DNx4kTExsbi66+/xrt379C4cWMcPXoUJiYmYp8lS5agRIkS6NevH+Lj49GgQQOcOnUKJdMVACQqrjILQBQWWQVKMluRhp+rKSt5GWgUM1I0Te0B9GeOlT5fTKe/WE4rr4I9OQ1q5eeFfEEF2vQpoKct5R9qTLR+BwCJiEjnClUgBQBGjhyJkSNHqr0vNDQ0Q1vPnj0zzRyRSCSYM2cO5syZo7GPoaEhAgICEBAQkO3xEhV1RSVTI6tAiXKp47R9crLUMRU/eR1oNDNR1kjJYuUGfSjeo88X0+qyZZTyMtiTk6BWfmfyFFSgTV8CekqZRTRVspMkH3/SvOHn5jURFQX8cw+wsQJs+J8GEVFRUOgCKUSkX4pKpkZWgZK014NpV6QpTMdIBS8/Ao3i1J7ETDJS9Im+XUwrqcuWARRtef3Hnd2gVkFk8hRUoC0v95NZICSrtK/MpkplyE5S/kfwMZiSmwBgSAiwZg2Aj0urjxgPtG6d/e0UFtlJvysKc4KJqNhiIIUoE/w/PmtFJVPDzg5o3hw4eepTW7Nmqs+7vl4Pkv7Kj0CjqTIjJTGLjBR9og/ZMempy5bp3Ano2En3Y9XnTB5dySwQklU9maymSmWWnTRxElC5cs7OvXK/UG774369vIrmc5mduj6FZTUvIiINGEgh0qAo1P0oCEUlUyMqCjh1SrXt1Cngq69Uj0UfrwdJf+VHoNHsY0ZKoQqk6CtdRkezitQzcvtJZoEQIOt6MllNldKUnQQBsLLK+blXt18hn2ut6OoboOzU9WExXyIqAhhIIVKjqNT9KCjZ/byvj5m/d+6qzIYHoLh99y7QuHHBjqWoK07nMT8CjTIjIwCAnIGUvJGT6KjyRWxXEnApnf19avttPCO3CpkFQgQh63oyWU2VsrMD/AYAgYGq28ntdCpxvymf2iT5WGxZl1ke2anro++reRERaYGBFCI1ikrdj4KU9vO+NvX8ssr0iYoCDv4K7N+nCGjoOiuoqGcoFVRwIy/PY0pSEpLfv4exjY3YJv/vP5SwsIDU0DCPRpx7eZ1YoFy1JzEpIQ9GV0zk5QtcpSipAIwcnb0XcXH4Nj4n5zuzx2QVCMmqnow2U6W6dlP8ZxMcrNhWXkynUu537VpASAKQjymbun5dZaeujz6v5kVEpCUGUojUKCp1P3QhswtlbTN90m5DKb+zgqpUzrBGAwwkiqnxBZmhpItsjYIKEuXleUxJSsJfixbh/dOnqD9/PmT29oh//RqXp06FhZsbPCdN0qtgSl4mFigzUhKTmJGilbz8lj5DUdIcXKwWxm/js/PGlJPzndVjsgqEaFNPRpuIZrduQJMmeTudytcXqF0beHwfKGkJlK+e+22qo+vXVXbq+rAGEBEVAQykEKlRVOp+FLSsLpS1yfRJv43M+uYlOztg5Ej1z/mNG9pnKOUmEKKLrJeCDBLlZaZX8vv3eP/0KeIjInB56lTUHDcON5YvR3xEhHi/NE2mSlFSLDNScvqHldff0ufFxWph+zY+O4GRnJxvbR+TWSBE27QvbSKa2Yl6avu6tLMDZCWArJYszw19eF1lJ/2ONYCIqJBjIIVIA/4fn31ZXShrk+mjbhua+uY1Tc+5thlKuQmEZDegkVeZKwU5jS0vM72MbWxQf/58XJ46FfEREbg0eTIAQOboiPrz56tM9ylqxBopxSWQkpuMkrz+lj4vLlYL07fxmoIcHu5AfELGN6CcnO/sPCazIEdB15PRt1Vn9OV1pc3zkPY/sBo1CmZcRER5zEDXAyDSZ3Z2iv/j9fHzrT5SXiin9+CB4rfyc5704zuPukwfTdswkBTMZ0J1z7k249YUCImK0m6/mQU00gsJAfz9gWnTFb9DQrQ/vvTUnW9NwY2oKEV2jrbHlJ425zE7ZPb2qDlunEpbzXHjILO3z9kGCwnZx4yUpGS5jkdSADRdyGv7IlQGPtLKzbf0yhexgVRxW5LDi1VfX2DzZmDefMXvgkg9U/fHm9UftaYgx/++BaZPy/gGlJPzndfPUUHI7esyvxT06yonlP+BqXv9ULHRrFkzjB07NtM+7u7uWLFihdbbnDVrFmrVqiXe9vPzQ5cuXXI0voKWfuxUODAjhYiyJbNMCDs7YIBfxoUPtm5VTDu3s8s600fdtKpOnYFOHXMXRMltBkdW485tZoe22Rp5PRVH22lseTXtKC8zveJfv8aN5ctV2m4sXy7WTCmqlFN7UlKTkZychBIl9KcWTJ7LbUZJfnxLn/ZFbGuds1V7lGMriCi9pswJbTIqMlsWGMg4DScn59vODmjeHDh18lNbs2b6/Q2GruuRZEafV3rSdUFcKlB+fn4IDg7O0P7gwQPs3bsXhvlcx2zlypUQhE8fqpo1a4ZatWplKziTHyQSCfbt26cS5Pn2228xatSofN/3rFmzsH//foSFheX7vooDBlKISGvaXEyXL5fxcekDCll9zsvOxbY2AZK8CgJkNu7cTlvRNqCRH1Nxsjrf6oI3a9cC7h5AxQrZ319efM6X//efOK1H5uioUiPl8tSp+GzRoiI7vUc5tQcAEhPji3YgJS+m0uTHPE3lizg/a17khcym5mhzQZs+MJKhJDcyBhCye76jooDTp1XbQkOBr77S34trfahHUhjpcwCK8kWbNm0QmO7bNXt7e0il0nzft5WVVb7vI6+Ym5vD3Nxc18OgbOLUHiLSirZTV7IzVSQz2kyr0maKS9Sb3E25yc54czttRZmVPX+e5qzsvDq/6WV2vtUFb1IF4Nv/6S4ru4SFBSzc3MSaKCWrVlVkojg6wsLNDSUsLHQzsAJgbGgICRQvArm+X8jnVvqpNDnNKMnuPM3czmPTF5ouXG/f0XxBm57yjalrV0Cibt6lmgBCds53ZhfX+iqvXpfFTWGcxkW5YmxsDCcnJ5UfqVSaYWpPZGQkOnbsCJlMBg8PD2zfvj3Dtt69e4fBgwfD3t4elpaWaNGiBf766y+N+047tcfPzw9nzpzBypUrIZFIIJFI8PjxY5QvXx4BAQEqjwsLC4NEIsHDhw81bnvz5s2oUqUKTExMULlyZaxbt068LzExESNHjoSzszNMTEzg5uaGBQsWAFBMVwKArl27QiKRiLc1TUuaP38+HB0dYW1tjTlz5iA5ORkTJkyAjY0NXF1dMwSpJk2ahIoVK8LU1BRly5bFd999h6SkJABAUFAQZs+ejb/++ks8B0FBQVqd27/++gvNmzeHhYUFLC0t4eXlhatXr2o8P8UFM1KI9JgulsLVRNtMiIJa8UjbKS4vXxZcMdW8+OI7q2yNgjq/aanLtgEU30vrKitbamgIz0mTkPz+vZh5IrO3x2eLFqGEhYVeLX2c1yQSCUwMDRGflAi5PE7Xw8l/BV35W9+KiOaGpsyJqlWyn1Gx/0DGgIckD96ACmt2ByvSZ5++FMQlvePn54cXL17g9OnTMDQ0xOjRoxEZGanSp2fPnpDJZPjtt99gZWWFjRs3omXLlrh//z5ssshAXblyJe7fv4/q1atjzpw5ABSZMYMGDUJgYCC+/fZbsW9gYCCaNGmC8uXLq93W9u3bMWPGDKxZswa1a9fGn3/+iSFDhsDMzAwDBgzAqlWrcPDgQfz8888oU6YMnj17hmfPngEArly5AgcHBwQGBqJNmzaZZuacOnUKrq6uOHv2LM6fPw9/f39cuHABTZo0waVLl7Br1y588803aNWqFVxdXQEAFhYWCAoKgouLC27evIkhQ4bAwsICEydORO/evXHr1i0cPXoUJ06cAPApayerc/vll1+idu3aWL9+PaRSKcLCwlSmZkkkEgQGBsLPzy/T56GoYSCFSE/pYinczGRn6kpBfL7UNrDj7Jx3K8VooyCmp+f1+c0qYKf87KtuWer8XJI6K1JDwwxLHBfV6TzpyUoYIT4pEYmJRTwjRamg6j4UpRoOyj/sAQMUharSXrhWqJi9C1p1WSMAMGEC0Lhx7sZZmC+u9bkeib5iAKpYOXTokMqUlbZt22L37t0qfe7fv4/ffvsNly9fRr169QAAP/74I6pUqSL2+f3333H58mVERkbC+GOdsICAAOzfvx979uzB119/nek4rKysYGRkBFNTUzg5OYntfn5+mDFjBi5fvoz69esjKSkJO3bsyJClktbMmTOxdOlSdOvWDQDg4eGB27dvY+PGjRgwYADCw8NRoUIFNG7cGBKJBG7/z96Zx0dR3///tbu5lhCOsCEhyKWAQUERFAQpiqYBUU4vrJoEwRPaEgQ5PfDAEtRQBQW+CAm2HtXKVS0GqWhRBDUqP8shIEcVSVkQCJBsjt3fH5PZnZ2dmZ17Zjfvpw8fYWfn+Mzn85nZeb/mfXTqFNw2ozF/W6tWrcLaIUR6ejpeeuklOJ1OXHzxxSguLsb58+cxe/ZsAMCsWbPwpz/9CVu3bsW4ceMAAHPnzg1u37lzZ0ybNg1vvfUWHn30UbjdbjRv3hwJCQlhx5bTt0eOHMH06dORk5MDAOjWLTyu++KLL46pUCq9ICGFIGyI3glF9UCpJ4TRz5dyhR1PG/09OOzgKaRX/8oV7PLymJwo0x4Jz5CgVJSyQ9/FAymJiUA1moZHCmDexImXHA58r5rCAqBrt3DDVYlBK+Y10vhQrRm2LXv2AAgAOT2ibkLEMCRANRmGDBmCV199Nfg5NTU1Yp3du3cjISEBffv2DS7LyclBq1atgp+/++47nD17Fm3atAnbtrq6GgcOHFDdvuzsbNx0001YuXIl+vXrhw0bNsDn8+G2224TXP/cuXM4cOAAJkyYgPvuuy+4vL6+PigkFBYW4re//S0uvvhiDBs2DDfffDPyVLwJvfTSS+F0hkLhMjMz0bNnz+Bnl8uFNm3ahHnuvP3223jppZdw4MABnD17FvX19WjRooXkceT07dSpUzFx4kS8/vrryM3NxW233YaLLgolRdyzZ4/i84sHSEghCA0Y9WxvREJRPbDTiyQlwo6e7babp5AWlAp23bsBkyerF6Xiqe+sxt3oUtskPFLMDLWJ1TATLkJeNWWrmTwn/JrtSn7ARo8KhfcY4TVSURE/IVUEQQBghBOxEBklnD17Fu3atcOWLVsivuMKLmqYOHEi7rnnHpSUlGDVqlW444470KxZM9F2AMD//d//oX///mHfsWE6ffr0wcGDB/HPf/4TH330EW6//Xbk5ubi3XffVdQuflUjh8MhuMzvZ+7127Ztw1133YV58+Zh6NChaNmyJd566y288MILkseR07dPPvkkfve73+H999/HP//5TzzxxBN46623MGbMGEXnFG+QkEIQKjHSKNRaAcZI7PQiSYlAoke7rfAUMvJFvBrBTq0oZUcvq1jGnci438a9kGJ2qE0sh5mwyPGqkStOeb3AhvUhAcXhZJLOjhiprk/EbmjxFFJFCEPuiIQIOTk5qK+vx9dffx0M7dm7dy9OnToVXKdPnz44duwYEhISgglalZKUlISGhoaI5cOHD0dqaipeffVVbNy4EZ9++qnoPjIzM5GdnY0ff/wRd911l+h6LVq0wB133IE77rgDt956K4YNG4aTJ08iPT0diYmJgu3Qyueff45OnTphzpw5wWWHDx8OW0eoD+T2bffu3dG9e3cUFRXhzjvvxKpVq0hIsboBBBGLGG0UWpFQNJYJBICTvxr/jGa0pxD/OdNoDw61gp0aUcquXlaxSkoS81Yq7kN7rAi1sZPrnRqiedXIFS3Ky4HFixEWzBfwA+vWM0KKUqTEm3gJqYpVjBY54imBM6E7bAjMAw88gFdffRUJCQmYMmUK3G53cJ3c3FwMGDAAo0ePRnFxMbp3746jR4/i/fffx5gxY3DllVdGPU7nzp2xfft2HDp0CM2bN0d6ejqcTidcLhcKCwsxa9YsdOvWDQMGDJDcz7x58/CHP/wBLVu2xLBhw+Dz+fDVV1/h119/xdSpU/Hiiy+iXbt2uOKKK+B0OvHOO+8gKysr6N3RuXNnbN68Gddccw2Sk5PRunVrTf3H0q1bNxw5cgRvvfUWrrrqKrz//vtYs2ZNRB8cPHgQ3377LS644AKkpaVF7dtLL70U06dPx6233oouXbrgp59+wpdffolbbrkluN+cnBw899xzTU5YofLHBKECKaNQL+SUwo1F9Kwqyi1//Mgj0mWQ9cCo0sNAZCnn99YoL9ustG/1KNksFyP7rinSLInxSPHVxLmQEq1cqlFlipWWS2axQ9nkaKV55ZQbZsUW8H7ohNaVg5h4w/YTlcW1DvbHZ+4cY35Ao409QYCplJOdnY1rr70WY8eOxf3334+2bdsGv3c4HPjggw8wePBgjB8/Ht27d8e4ceNw+PBhZGZmyjrGtGnT4HK5cMkllyAjIwNHjhwJfjdhwgTU1tZi/PjxUfczceJErFixAqtWrUKvXr1w7bXXorS0FF26dAHAVM4pLi7GlVdeiauuugqHDh3CBx98EMx38sILL2DTpk3o0KEDrrjiCiXdJMnIkSNRVFSEyZMno3fv3vj888/x2GOPha1zyy23YNiwYRgyZAgyMjLw5ptvRu1bl8uFEydOID8/H927d8ftt9+OG2+8EfPmzQvud+/evTh9+rRu5xIrOAKBgMCvJKEnZ86cQcuWLXF69Wq00BjHRwDVPh/cjVmlrcLrZZ43+G/y+SHoRDh6elgIjQELdyz0ni/l5ZGeQlpFLqFzESo3DDDCWq9ewu1S27derzkv343oO72xw/1FDsNmPoYPd32HSQ8tx9Ab74u+QSzDThxuqE1eni3ecvt81UhOdofaaae37mIXNnvD4XuscH/Adu5kDGsh+OvKQWx/z84P3dDExjkOCAQCOHfuFHy+aqSnt4PD4Yi+kRnImQtakTP2hCBh9xcOBw+ewR//2BKnT5+OmkjUSD7++GN8++23KCoqsqwNevHvf/8bN9xwA/773//KFmaIpsU777yDmpoa3HPPPcFlFNpDECqg0Bvl6B0OJeQVxGJkyIgRXv9C5+IPAA7Iq5CjtW+5L6q5n/VGTt9RGL083ElJAABf9TmLW2ICQhMnWniKmRPJ6wX27A4Pg7FDjg+xGDw5eWCEwoMAZpmaHzs5SXxjPaQqFjEjpCoeEjgTcYvP58Px48fx5JNP4rbbbiMRhVAECSkEoRJ65lOG3jkyhPJ7sBgdMqJ3wl2xXCX5+cDq1dHFOq19K+bNYoQtKtV3VNVHPs2Sm0hoDwt/4kgZgGZWf9n8EbBsRWRbuO0x8sdB7UUa7QeML7awqHVi9niYEsylZdJVf+ySzbypKLpmiBzxkMCZiFvefPNNTJgwAb1798bq1autbg4RY5CQQhAasPqZL5ae9fSuRMT3CuLuM9ae0cQ8nPLygMGDo4t1WvpWzJvl7FmgrMw8USOeqvo01NWhvqoKyenpwWW+kyeRkJYGF690oVrcjTlSamuagEeKEGIGYEqyedVfvF5g6TIwvmMCGP3WXWsoUbQfsLw8oEtn4JFpCPnGqbwwy8tDIgocjEpsV5XUiBAtrxf4cS+Q3hJIt5EnhlkiB715ImxKYWEhCgsLrW4GEaOQkEIQMUqsvb03IhyK+2yWnAL4atQ9o5klSEkdR+w5U65YN2o0sH6dsr71eoGtW4W9WUpLQ6aTGaJGvFT1aairw3cLFqDq8GH0mz8f7owMVB8/jh2zZyOtUydcPmOGLmKKO6XRIyXeq/aIIWYAVteYV/3l6FEAfgAu4e+vu07ZMZXciMwqF1xdg4iEs0r7k99WBBhXu8GD7XdxG9GvwepHPubzpKnA0KG6NFcXzBI5rH7zRBAEoTMkpBBEDBKrb++NeF7T+mxmliAl5zhqzoW7XweAMWOAkSOi74e7HR+hkCmjRQ29PZbMhrWBPc3OoerwYVRXVmLH7Nm4rKgIO0tKUF1ZCQCor6qCi+OpopZmrJCit0dKLLm5ieVOMSsfQ3Y2JIsfbtkC3H23svg6uV4QanNbKB1fPUI/olUJstN80ztnSLD6EbvPRmGmb197nC8LiRwEQRCKofLHBBGDmFF+2SiEqopaVTFUTJDSux1GHYe/3wAYrxSl23FxOYGCQvNLFZtZillvuKWrH3qkFc4OewHuzExUV1Zi+8yZqK6shDszE/3mzw8L99FCakoKAKC2tlqX/QEwvgyqEfBvKNFK/+p97AcfCB2Lj78B2LMn+s1NTXlYNeWC1YyvHv15YH/kMqcL2L/PfvNN7zLMQsJMQEX5aDtgh9LeBEEQNoI8UggiBjH77b2RL6mtDFEyK5zEqOOo3a9YxaOJE4BrrmG2bZ5qflWqWAyjFxLJ/u/1FnhhxqPY99wjwfUuKyqCOyNDt+OyHik1eiWbNStUxAzMnEg35AL9BjCCSXExwsNgHMDChdG9TNR4QSjNbaFlfLX0p9fL5Ebhc8stnJwpCttjJHrnDAl69HAS9jpisGKN3Up7EwRB2AASUpogseS5TQhjZvllI4UOq0OUzBKkjDqO2v2KbceKKAAzBo9MY8KFcnL0G49o959Y8zAXE7O2LV0H7mnsLCkJ5kzRA3dj1R7dPFLMKINqJmITSekPoJz1PR5g0CDg/PmQAe5wMhVu5AgFasNnlAgcWsdX7YUpdFwAaNHCvvNNTyGO/bFesgQI1AGIIVc7lngSWQnT2bJlCwoLC3Ho0CHZ26xcuRIDBw5ETk6OcQ0jCB2g0J4mBtcF3S6etIQ68vKAFSuA+c8yf414OWR06IvVIUp6hJPI8XY2KmxF7X6jbcfeJ4qLmRfqFRXa2skSj/cfVpTi4kQDUn79Hu7MTHSb9QKOtx6M45V12DF7NnwnT+py3FS3zqE9eoc02BGloS1K12dvys/OB6ZzK900wgoF/JuGlvAZoVhJIawaX7HjXtLD3vNNbr/KgZ0Xcx8HXng+9jw5ouW4IQiFLFmyBJ07d0ZKSgr69++PHTt2hH2/fft2LFu2TNW+q6qqMGXKFHTq1AlutxsDBw7El19+Gfy+oaEBjz32GLp06QK3242LLroITz/9NAJRSrv/9a9/RYcOHdC6dWtMnTo17LtDhw6he/fuOHPmjKo2E7ELeaQ0Iax++0/oj9Fv740OfbFDglEtnhdKvHWMijZQu1+x7Yy6T8Tr/SfSOyyAmzt+gIzqRJwd9gKm/qkF/IFpcKABI90fYFBami7HTXU3Jput1Sm0x6wyqFah9K262rfw7E1ZLOntvn3A3LmRIRJGhyNZNb5ix+3WPf7mm5T3kscDuBMAn445jcxCjscUuToTMnn77bcxdepULF26FP3798eiRYswdOhQ7N27F23btgUAjBo1Cr///e9RUlKieP8TJ07E999/j9dffx3Z2dn4y1/+gtzcXOzatQvt27fHggUL8Oqrr6KsrAyXXnopvvrqK4wfPx4tW7bEH/7wB8F9er1eTJw4EaWlpbjwwgtx00034frrr8fNN98MAHj44Yfxpz/9CS1atFDfMURMQkJKEyJeyosS2lDyvGO00GFmiJIQWsKW1AgDRglfavcrtJ3d8rnEAuE2sAOtWw5D5eHf4KFHWnASAbvwjyM3Y/Rphy7n26wxtKeutkb7zlhiMUmNXJSGtugRCsMXCgrypfOCGK2MWzW+YseNp/mmNIdILAkP0UQ4yp9CKODFF1/Efffdh/HjxwMAli5divfffx8rV67EzJkzAQA33HADKisr8f3336Nnz56y911dXY2///3vWLduHQYPHgwAePLJJ7Fhwwa8+uqreOaZZ/D5559j1KhRuOmmmwAAnTt3xptvvhnhFcPlxx9/RMuWLXHHHXcAAIYMGYLdu3fj5ptvxptvvonExESMHTtWVX8QsQ0JKU0IO7z9J6xFqXBghtBh1bO0Vg+JeBUG7JbPJVYIt4ET4T3fSmB+OHSbH+6kJACAr07nN9yxlqRGLkrzkOhR9pd/c7NDHhqrxlfsuGa1x0jhQqn3Unk5830sCQ/RXBgpfwohg9raWnz99deYNWtWcJnT6URubi62bdsWXJacnIy8vDysX78+KKSUlpZi/PjxkiE49fX1aGhoQEpjVTsWt9uNrVu3AgAGDhyI5cuX44cffkD37t3x3XffYevWrXjxxRdF99utWzecP38e33zzDTp16oQvv/wS9957L3799Vc89thj+Pjjj1X1BxH7UI6UJoRReRoI+VhZPVBJvhNuO83IxaJnOLpctOZnEcqNEQ/CgN3yuViN1wv8eyvzv5Lr1uj5wXqk1Nbp6JESzyjNQ6Ilbwl/P+zNzZ0CJoiQg9a8INF+VKhkrbqyz0r6TUkOkZMnlJe6VoMR4y70Q035UwgFeL1eNDQ0IDMzM2x5ZmYmjh07FrZs1KhRWL9+ffBzy5YtcfHFF0vuPy0tDQMGDMDTTz+No0ePoqGhAX/5y1+wbds2/NI4J2fOnIlx48YhJycHiYmJuOKKKzBlyhTcddddovtt3bo1ysrKkJ+fj379+iE/Px9Dhw7FtGnTMHnyZBw8eBBXXHEFevbsiXfffVdptxAxDHmkNDHiyZM21rCyzC8g34NCrJ3xNFe8XuD0Gcak4XaJEkNXrbdOLHh02y2fi1WUlwOLF4fmiAPA5Mnyrlujvbl0r9qjhViY1IDyCajnhGVvrNw7jta8INFCKijkQp3HhNJ+U+K9VFkJwI8wQU1vryQzx10Pzy2CEGD48OEYP348vF4vPB4PxowZgzFjxkTd7vXXX8e9996L9u3bw+VyoU+fPrjzzjvx9ddfAwD+9re/4a9//SveeOMNXHrppfj2228xZcoUZGdno6CgQHS//ON/8skn2LlzJ15++WV07doVb775JrKystCvXz8MHjw4mO+FiG9ISGmCxKvntp2xQ6JNOaEVdmin0XCFIgdCYgpr6ALMizw5NqFSO8tqMU0JdsvnYjZB+4uzLABmmZLrwe8P/6sXbGhPbb1P3x0rJdaMdaUTkLu+WsGIb8wDTF8tLGaSrqohmkDQVEIuoo3Jnt3KwqnU9JuSRL6ZmWCcwXmCml7Cg9njHu9Jqgld8Xg8cLlcqKysDFteWVmJrKyssGUHDx5Eq1at0KpVK0XHuOiii/DJJ5/g3LlzOHPmDNq1a4c77rgDF154IQBg+vTpQa8UAOjVqxcOHz6M5557TlJI4eLz+fDwww/j9ddfx/79+1FfX49rr70WANC9e3ds374dI0aMUNRuIjYhIYUgTMAO+TTkvCG3QzuNhC8UsQLKtGlMxZ6KCsbzW4nQIdcuawoiVTwhdC0AzDI51wNfiAkgNN6tW9ahvqoKyenpwfV9J08iIS0NrsREWe0LhvbUWxja01SMdUCbYCQU/hDwAzUaRLBo+Va05GOxg4eRnDbI9cjhIyVcqO03uar6998jTERx6OyqZkUenlhzNSQsIykpCX379sXmzZsxevRoAIDf78fmzZsxefLksHXXr1+P4cOHIyFBnamampqK1NRU/Prrr/jwww9RXFwMADh//jyczvDMFi6XC34FbzueeeYZDBs2DH369ME333yD+vr64Hd1dXVoaGhQ1WYi9iAhhSBMwC6JNqM979ilnUYhJhS1bMn820ihw0qRyg52UayR4o4M/QKY60PO9SA23j//tx5Hli5A1eHD6Dd/PtwZGag+fhw7Zs9G844d0eOBB9CM4xIsJrCwHin1DcxDm8vlUnGW8qmra0BVVT3S05ODy07u/S/SAg6Etczs5KlmICUYpaVG396I8Ido+1R7zGjihBk3EzmilVKPHJZowkV2NiKufIfMH8FoqvqJE8CqUgCJCAvt6dMn+r7lYlWoTay4GhKWM3XqVBQUFODKK69Ev379sGjRIpw7dy5YxYdl/fr1eOyxx4Kf16xZg1mzZmHPnj2S+//www8RCARw8cUXY//+/Zg+fTpycnKC+x8xYgSeffZZdOzYEZdeeim++eYbvPjii7j33ntltX/Xrl14++238c033wAAcnJy4HQ68dprryErKwt79uzBVVddpaRLiBiGks0ShAnYLdGmWNJzu7VTb6QSgGpNPisEN9+fVclp2TyLc+bKz7PY1CkvB6ZPixRRHGCuDznXg9h4Z6SdRdXhw6iurMSO2bPx665d2DF7NqorK3Hyu++wY+ZMVB8/DgCoPn4cX8yYge8WLEBDXV3YvliPFMD4PCl1dQ1YsOA7zJjxBY4fZ451/Hg1Zrx2CgswFHXgiDjxmB9Ba0JNvRLXKtmnmmOKiRNswlI1SVuVEq0NLNHGROh7AJg+XXnomUSVEEUcOwYmPwp33xp/ZPgYMdcIQkfuuOMOPP/883j88cfRu3dvfPvtt9i4cWNYAtqDBw9i7969GDZsWHDZ6dOnsXfv3qj7P336NCZNmoScnBzk5+dj0KBB+PDDD5HY+DLi5Zdfxq233oqHH34YPXr0wLRp0/DAAw/g6aefjrrvQCCA+++/Hy+++CJSUxkR3e12o7S0FE899RQmTJiAxYsXo3379kq7hYhRyCOFIEzCDt6vcnJ02KGdRhEtvElPbxyhvja6lDQfpeFE5LkCeE+E9xnAjN+DDwJXXSW/X8TmWnbXVmg9f35QPNk+cyYAwJ2RgUAggBqvFztmz8ZlRUXYWVKC6sZY8vqqKrg4oUApjR4pAODznYfb3Vz7yYtQVVWPw4erUFlZjdmzd6Co6DKUlOxEpdcHtOiCqio30gNn49doM6IUsh59FG2fSo8ZTZwwI4xLbmiKWo+cnJzox4+QUGXE88m5eWZlIaJqk1xvFyXE8484ERdMnjw5IpSHy/r163HdddchLS0tuKywsBCFhYVR93377bfj9ttvF/0+LS0NixYtwqJFi5Q0GQDgcDiCZZS53Hzzzbj55psV74+IfUhIIQgTsdL7VYlRHc9eumLPmHpWWRHr6xUrmP/Ner5VEk4US4lwjeSXXyL7zB8ALrhA+XiJzTV3RgYuKyoKiigAcNkjjyAlIyNSYMnMRL/588PyqQDMA11KQiJq6usM90hJT0/G/Pn9MHv2DlRWVmPmzO0AgMxMN+bP74d0x5XxbbRJJdT0Keh7I26s0ZLhKjmmlDhhVu4NuaKVxwMUFgClZcy6Yh45YklQxYQPNaKZlvw5enm78InnH3Ei7lm/fj3Gjh1rdTMIIiokpBBEEyHeE8kqQewZU68XeVJ93auXvSo1AZQIl0u7dvp6JgnNterjx7GzpCRs2c6SEvSbPz9SYCkqgjsjQ3DfrJDi851X1zgFZGS4UVR0WVBEAYCiosuQkeEG4DZ/opjtPmX3t/x6VE+KJj6YkXuD3waHEyjIF1Z+WREFDiA/X757pVRfeTzAkCHAvzaH9nPddZHHZ+efO0W+p86xY1Dl7UIQTYzNmzdHX4kgbADlSCGIJoJVOTr4cPOG2BGPR7vYIbev5fRFtHWkvpeb88aI/DCxiqeNsXmCfCdPBr1O3JmZ6P+nP8GdmcnkTJkxA989/3zY+jtLSoI5U/ikJDaWQDbYIwVgcqKUlOwMW1ZSsjOYM8VUzMjVIYQeNwcjkJtXRA55eYzb3LPzmb9cgcGs3Bt5eYwwAgdzLqVl4WMckUg2AKxeLX4T5I6ZWF/t+4G5ke77Afj44/B9bNkSvm/u/Js2XX7+nKwsRDx2x2NOIYLg0LlzZ0yZMsXqZhCEIZBHCkE0EfQMXVFLUwkfkdPXcvoi2jp65bwxqloT12kAiJ38K0Y6HySkpSGtUycACFbt6Td/PnbMnIna06fRUFsLd2ZmWI6UHbNn4+oFCyLCe5o1Cik+JeElKjh50hcM68nMdIdypDTmTFmw4Oqwaj66IOZx0pRKLstFj7Abfn9Hc9lLSQaqa5jt9O53rxcoK0PQe4M/xlrOV2xbVhDhe93w9y00//iIiSNt2gDjC4HSt4TDkQgiDiEhhYhnSEghCBHiMfGmHAPRqPO2S/iIWeMq1ddy+iLaOnrmvDFCZOOKPKxzTgCxI6AZlWLAlZiIy2fMQH1VVVAYcWdk4KrnnsPuZctw9siRcIFl9mykdeqEBE7SPZaUxioERof2pKUloFMn5vjz5/dDRoY7mDOlU6c0pKXp/CghFXphVq6OWEJrMlwlYUEeD1BREb5+QQHQtat+N9VoY6zlfIW2BeQLI2LVgNh9RhNHBl8LDMplwnzsGCJGEARByIaEFIIQIJ49J8QMRK8XWL8BWLfWmPO2Q44Ws8eV39esiHP6TPS+iNZf6zfo2596emHwRR5uM5ty/hUWV2JiWAUeAGjWti16z5wZIbBcvWABEtLS4GoUTbi4kxgvEKNDexITXZgx43JUVdUHPU8yMtxYsOBqpKUlIDGRU/5Yq1IZzeNEjwo68Ua03CZSKPXwEVq/dBXzb7W5Wdj9svMm2hhrOV+hHCxKhBGxti0sBmp88m6eHg8gkveIIAiCiB1iLkfKkiVL0LlzZ6SkpKB///7YsWOH5PrvvPMOcnJykJKSgl69euGDDz4I+z4QCODxxx9Hu3bt4Ha7kZubi3379gnuy+fzoXfv3nA4HPj222/1OiXCZoi96bdrTg89KC8H7r0XWLNG23lL5euQyhtiRt4UI8dVTvvZsPo5c4HnF0YUwYwIpYnWX2vXRB5DaziOXikghEQgLk01/0o0XImJEeE7yenpgiIKALiT2NAe45PNJia6IsJ30tOTw0UUPXKXRCvBa3SuDrsncRJDLLdJNKL1t5z1WdTmZuHPm4qK6GOs9nz52z6/kBFGuDhdzHKhfYvNv27d7Zk/hyAIgjCMmPJIefvttzF16lQsXboU/fv3x6JFizB06FDs3bsXbdu2jVj/888/x5133onnnnsON998M9544w2MHj0aFRUV6NmzJwCguLgYL730EsrKytClSxc89thjGDp0KHbt2oWUlJSw/T366KPIzs7Gd999Z8r5EtZgB88JMwm+YBT4Tsl5R/P2EAsfYb3EjfYSMWpc5Xi5CIk4TgcjpvgDwqE0UuE2/94qPF4jR9ljjgrlXOFiRZLjeKOurgFJTkZgqTl/DgCTyyTCQ8QshDwVliwBmrmBnB76lOBlMSqJjR6Vb4xGyuNHbjyaEu8PPmKhMSxqcrMIecQsLAamPQLAAeTkCO9PS/wdd1sh75Zu3cW3tXsFJ7XEYzwzQRCEgcSUkPLiiy/ivvvuw/jx4wEAS5cuxfvvv4+VK1diJqdcJMuf//xnDBs2DNOnTwcAPP3009i0aRMWL16MpUuXIhAIYNGiRZg7dy5GjRoFAFi9ejUyMzOxdu1ajBs3Lrivf/7znygvL8ff//53/POf/zThbAmrMCrxpl2R8h6Qe95y83Xwnz8B5gWkGXlTjBhXOXlMxEJ5/AFgxqNAy5biz+JCz+vl5cDixZHrOh3AyBHqz0VP+CKQ0wEEAoz4Y0WSYyOw0uaoq2vAggXf4b+HmJAeX/VZHD9eHcxZMmPG5eaLKUKeCgE/UFysTJSQG7ahdxIbvYQgI9FD6BHah5IwGf748FEaZiUn+avRgpYaYcSoJEpWEQsiIhGTbNmyBYWFhTh06JDsbVauXImBAwciJyfHuIYRhA7ETGhPbW0tvv76a+Tm5gaXOZ1O5ObmYtu2bYLbbNu2LWx9ABg6dGhw/YMHD+LYsWNh67Rs2RL9+/cP22dlZSXuu+8+vP7662jWrFnUtvp8Ppw5cybsfyJ2kFsyNl4QCiEBlJ23kvK53PARM8vuBj2yG8/V6dA+rlLt54byLCyODOVxOoC2mdG9wbn9JeY95Gp87rXTHGW95+c/C7z2GrByJfNvpV74doQ7tmZW32WpqqrH4cNVqK9jZtVP/z0RrKpz+HAVqqrqzW0QEPJUEEJpyIeWsA21SAlBYoPs9QLf/z9zwoD0KHEslQ9FSX9zx2f8eG1hVmLzRo9Szkqwa2lrOWgNR9OzfDZBROHTTz/FiBEjkJ2dDYfDgbVr10ass337dixbtkzV/quqqjBlyhR06tQJbrcbAwcOxJdffin7ezH++te/okOHDmjdujWmTp0a9t2hQ4fQvXt3sveaIDHjkeL1etHQ0IDMzMyw5ZmZmdizZ4/gNseOHRNc/9ixY8Hv2WVi6wQCARQWFuLBBx/ElVdeKUtRfe655zBv3ryI5dU+HxJ9vqjbE9JUm9CHv7kW6NGTSayflQV42gDVMTR03hOcl2ttpNdNTQMmPgAsXwY0BBh19eaRwE3D5Z93aw9j3HPNEJcDaBVle7XbKYE7X3z1zDn6wXhI+OqVHYffr2LtD7iAlxaHL+fTEACmPgI88CCQe4O84/94GKgT8B6a8kdg4ED7zdHUNKArp9gM+2+7tZNLtPuL90T42DYEgJeXMPeLaNeaXrhTgcee7I3Pp2wEfMCmj/aiHn3Rtq0bTz7ZC6mpfsNLIkeQlgrcNQ74y+vC3/sbgCMHmfXk7i+tK/NvM87F0xqRV3MjgQZgyctAzx5Am0ZDe/NHwNJl8KEOQCLw4APADbmR2+rF4R+BQF34MqV9KrWPS3sq6292fP57CPDXAQgAfj9w+gTw9Q7mJtlGhiiRlgo8MBFYtpzpZzgRMQZKz1MNJ7yhm7ucdiskEAjA56tGbW0NfL5qOBwCby/U0DgPmT5zqpuHeswtwhDE7uNGJxg3knPnzuHyyy/Hvffei7FjxwquM2rUKPz+979HSUmJ4v1PnDgR33//PV5//XVkZ2fjL3/5C3Jzc7Fr1y60b98+6vdCeL1eTJw4EaWlpbjwwgtx00034frrr8fNN98MAHj44Yfxpz/9CS1atFDcXiK2iRkhxSpefvllVFVVYdasWbK3mTVrVphaeebMGXTo0AHu5GS4k5MltiTkYkY/dshm/o81pHJ2iIUjjBgODOinPuS7Qzbwh8mR+Tyi9Z/a7ZTiTk6G1wusWMZ4hrBBD68tZ85bSw4YofajPvw4Uihpw4WdgESB8KTLewFum99aYin8Xur+8qtXYGwDwKkT5t4vOrZPxhW9MrHrq//AiXoAyZg69Sq0b9/avEbwybkUorPe6QI6dgGS3aY2STbZHYDJfxAPWQkAOHGKWc/rBZatADsTkuEAlr8G9Btg3OTudCHgSIzMZaKkT/XYB5dgP3A8Sl5/g/mrJDxk+Aim7375BUhJDoX16NFGblvFbkDBeMkAAAcwebLuXlCBQAD19YxIm5zs1kdI4c1DAOrmod7zgtCVZIExSEqqE1gzNrjxxhtx4403Sq5zww03oLKyEt9//30wp6Ucqqur8fe//x3r1q3D4MGDAQBPPvkkNmzYgFdffRVz5syR/P6ZZ54R3O+PP/6Ili1b4o477gAADBkyBLt378bNN9+MN998E4mJiaKiEBHfxIyQ4vF44HK5UFlZGba8srISWVlZgttkZWVJrs/+raysRDtOTG9lZSV69+4NAPjXv/6Fbdu2IZn3YH3llVfirrvuQllZWcRxk5OTI9YnCDOQytkRLamr1pBvtfn3zMrbpzbZrNcL7N7DPGezm3P7Vaj9Xq90slWlbWCRSkBrZ+KpnLgVOZQa6urCyiIDwE/7fsHu/1Q1fmIMtJKSnZg/vx8yMiwyfsQSkTpiZKKyF/OePcDCheIJWKUq3Rh1jlpK/uq5Dy5yKvjITXgVLfmrkjbyRROp/B9eL0dEAfN38WJ9E3V5vcDPPwOtUoHm0cPDZaPXPNR7XhCERpKTk5GXl4f169cHhZTS0lKMHz8egYD4g1V9fT0aGhoiioW43W5s3bo16vdidOvWDefPn8c333yDTp064csvv8S9996LX3/9FY899hg+/vhjDWdLxDKyhJR0XjnGaDgcDlRUVKBTp06qGiVEUlIS+vbti82bN2P06NEAAL/fj82bN2Py5MmC2wwYMACbN2/GlClTgss2bdqEAQMGAAC6dOmCrKwsbN68OSicnDlzBtu3b8dDDz0EAHjppZfCFMqjR49i6NChePvtt9G/f3/dzo8g9HhjLyYW7NkjLxmsVqTEGDnFJthQbyO8FtQYwFwBgA9XAOGfN1/wkEKpER5rBSPkJiKOJUaNBtatFa+4pCcNdXX4bsECVB0+jH7z58OdkYGj+37GrOnbUNM4ty7v1RxH/udGZSWTcHbBgqsjShWrQulNScggGzUSGDHS2MHWy92J3U9OjrRhqbTSjV7ocfHreQPRu4KPHm3kiyYFBUBZmXBeGI8H2LMbkVmnAsyP5qBBytotxJr3gNKyxrClBmB8PjB6XNTNZKHnPIy1HxYi7hk1ahReffVVzJ49GwCTw/Liiy+W3CYtLQ0DBgzA008/jR49eiAzMxNvvvkmtm3bhq5du0b9XozWrVujrKwM+fn5qK6uRn5+PoYOHYoJEyZg8uTJOHjwIEaOHIm6ujo8+eSTuPXWW3XtC8K+yBJSTp06hUWLFqFly5ZR1w0EAnj44YfR0CDgGquRqVOnoqCgAFdeeSX69euHRYsW4dy5c8EqPvn5+Wjfvj2ee+45AMAf//hHXHvttXjhhRdw00034a233sJXX32F5cuXA2AEnylTpuCZZ55Bt27dguWPs7Ozg2JNx44dw9rQvHlzAMBFF12ECy64QPdzJJomer2xFxMLArC2pLOc8zPaa0GpNwdfAOAjRwDxc59vG8fFAcDh0GaEx1LBiHgqJ86fo2PGMJWSjDyP+qoqVB0+jOrKSuyYPRuXFRVhb8mf0drfG6mNuSRSkhswf36/YNWetDQdnE3VVvGIYpDV1TWgqqo+TOjRVLZZr2ojQvtZsUL4PKx8g6/l4ucKTr166dMWPSv48Pet9DyFkqZyRRQWo72HWN57DyhdxT0wsKoUGJQLZGRo37/e8zCWfliIuGf48OEYP348vF4vPB4PxowZgzFjxkTd7vXXX8e9996L9u3bw+VyoU+fPrjzzjvx9ddfy/peDP7xP/nkE+zcuRMvv/wyunbtijfffBNZWVno168fBg8ejLZt22rrACImkP20NW7cONmT4ve//73qBklxxx134Pjx43j88cdx7Ngx9O7dGxs3bgwmiz1y5AiczlCs7sCBA/HGG29g7ty5mD17Nrp164a1a9eGxds9+uijOHfuHO6//36cOnUKgwYNwsaNGyPcvgjCKPR8Yy8mFvTIsa6ks5zzM8trQclLt2hloeWIMPzNZzzKvOwGmDYkpwA11cz6as4zFvKOxEs5caE5un6d8SWnk9PT0W/+fOyYPRvVlZXYPnMmAGBMJpB19WB8ue5r+HznkZHhxoIFV6sXJLiIlQLu0hno1j369iIGGVu2+fDhqmAIkqayzVJVaJSGggjtZ8UKccGBvZkcOcjkkrDjBci9QbCxnXqXt+XeVPftA1avti48RKzykpTXRk4PMPI25wblcIZu1GrxeoHSUoEvGlVkPYQUwN6eJLHwA0XYloMHD6JVq1Zo1aqVou0uuugifPLJJzh37hzOnDmDdu3a4Y477sCFF14o63s5+Hw+PPzww3j99dexf/9+1NfX49prrwUAdO/eHdu3b8eIEQY/HBC2QJaQ4vf7o6/EoaqqKvpKKpk8ebJoKM+WLVsilt1222247bbbRPfncDjw1FNP4amnnpJ1/M6dO0vG5xGEUvR+Yy/2XGVmbg3u89PuPdHPz0yvBbkv3cQEgGnTmGdspSKMPwC0bBnaLlrOmmgIefD06WPuc6uc52Qr87qoeY73nmASyvK3sdKzxp2RgcuKioIiCgD0LvojDv70MwCgto6p4KBLOA8gbpA+Mk1TIk62bDMbglRUdBlKSnaisrI6+H16ugIhRW2OCP7EULsfj4epamLHhJxcD5tg8fXGCaxWcBKC7+UyeLB1Rr1YqEtBPlAmIvB4PMyc1tu76OhRRErpAGCAimxHTxK9PMWIJsv69esxfPhwJCSo87BMTU1Famoqfv31V3z44YcoLi5W9L0UzzzzDIYNG4Y+ffrgm2++QX19ffC7uro6Q6IyCHsie3b+4x//wPDhw8M8PgiCD72AUI4Rb+yFnqvMenHFNfDF6hI4HcCp0yFPDDt6LYgJAHLC5qOdj1oPHPb6SnFHbr9kCVPSOQBzEroqCcWy4qWpmlCx8nKmtLEDkdtYOUerjx/HTl4ZyJ0lJUhqdDPWvRSmaO4LzkQFFN/s09OTgyFIlZXVmDlzOwAgM9ON+fP7KReC1OSI4AsMY0YzF7UVOU+Mgu9hI2TQ6xHeImYsW/XjLxbqkpcH/EZC4NHjBsV/+BG7hm6/Nf4fjvTyFCPikrNnz2L//v3BzwcPHsS3336L9PT0sHQK69evx2OPPRb8vGbNGsyaNQt79uyR3P+HH36IQCCAiy++GPv378f06dORk5MTTAMR7fto7Nq1C2+//Ta++eYbAEBOTg6cTidee+01ZGVlYc+ePbjqqqtk9wcR28gWUkaPHo3MzEwUFhZi/Pjxkkl5iKZJPFXmMBMz39gb/eKKLxCI+W4FAkBxcfg8mTSJJw74Ga8NPeeQUqGP+3ytJAwn2piq8W7gC1T8vuXujy/M6C1wqhGCzHxpqqZ9wW3AFBLlb2OVZ43v5MlgWI87MxOXFRVhZ0kJqisr8d+33mLW0VtIYU82zBhvxN8AbFgPrF2n6m1zRoYbRUWXBUUUACgqukxdpSGlOSKEBIY1a5hzGTIE2LIlPqqWSFXTYVErFLE3E3eKPY1lMVFE6gbEvUECyjOeC4lzI0by8sc4gTvvAvJyNZ6gCWj9wbCiqhURM3z11VcYMmRI8PPUqVMBAAUFBShtDIc7ePAg9u7di2HDhgXXO336NPbu3Rt1/6dPn8asWbPw008/IT09HbfccgueffZZJCYmyvpeikAggPvvvx8vvvgiUlNTATAVf0pLSzFp0iT4fD4sXrwY7du3l90fRGwjW0g5ePAgVq1ahbKyMvzpT3/CoEGDMHHiRNx6661wu23o1kqYSjxW5jATO4c5K0EqrwgLVwTgzpM+fRiBhSUAfeeQWqHP41EXhiM1pkq9G+QKVFxYYUZrCJEQdk8gq6Z9crax4jpNSEtDWmMFPLZqD5szpXWrVsCpU6itq9H/wHl5TE6UR6YhIn8EK6IAig3o48erUVKyM2yZprLNShMfCQkMAT8joiwsBmp8sX0TBkS8IRyA06lNKIoIF+LHL9rEWOYq1tzPQoiFQMkVCKXEOW7C4qwswJ0A+HQWPaO1TakgokdIjlVVrYiY4LrrrouaImH9+vW47rrrkJaWFlxWWFiIwsLCqPu//fbbcfvtt6v+XgqHwyFYJvnmm2/GzTffrGqfRGwjO06nQ4cOePzxx3HgwAF89NFH6Ny5Mx566CG0a9cODz74IL788ksj20nYHCkjhJCHx8OEmFv9DKoFViAQw+mIFAHYeXL0qPh3WhET+rxeY7cVG1OPBygoDPVVNO8GMYGKuz2/211OxotGbdulEBpnq0OxuKhpn9xtzL5OXYmJuHzGDFy9YAHcjQkq3RkZuHrBAlyanw/AgNAelm7dmfwRzsa8JU4XMHqU+NvmKJw86QuG9WRmuvGnP/VHZmaobPPJkz517ZQ7KKyBJ4S/gRFR1AwuW7dd7YUld3s567HGc2FB+LhNnswY9c/OZ/4qNY7lhAvZxVguLwcmTADmzmH+lpcLryd4Trw8MtHGREqce+UV5t9W/LDL7QMuYiE5Suc16ynGnX+x7OFFmM769esxcuRIq5tBEFFRlcFnyJAhGDJkCBYvXoy33noLpaWluPrqq9GzZ0989913ereRiAHsmOOCMB9++AO/1G9+AVBWKj5PjJpDWjwojPC+KC8P9YMDQH6+tF0jdn3NngP8chTocQlw6GBk2ElNtTGeI1YmkJWDmvax27y8BAA7X/MjX2pbkQfKlZgIV3p62LLk9HSknToFAMZ4pLDwPT6AcI8UQLYBnZaWgE6dmDeMrAeKLmWb5Q6KVMiSWhFg80fAshXq3+DL9QDge04UFgJjx0rvq6AA6NYtMsRFDWKCAet5YBdjWUl+jmghUHI8bETzCcncXgti815tjhI9Q3Lixc2WsITNmzdb3QSCkIXKpxaGtLQ03HDDDTh8+DD27NmDXbt26dUuIsawu2FFqEdLXhHWLuE+SzVPFZ8nRs0huUKf0LnqLRIKhemsXs0Uu1BS+ea664BnnwkP2SleCOzexQgr3bsxx9JbnGL7qE+fkNe6Uc/JWkQLNc/xeXlAj57AqRPAvv0hsYvtX8BeeaDcSUkAAF+dweEC/PwSSvKScEhMdGHGjMsbq/MwiWVll20WmwxKQxHYibFhPbBuvbZQF68XWLoMQX8wpXlC5Bq8Qp4TpauYw44ZK76v1auZi1Svm6hQmeDnF9orHEqJGCAlggDyxDW9xTm5Nz2pea9WENE7JMeO1YQI0+ncuTOmTJlidTMIwhBUCSnV1dV45513sHLlSvz73/9Gly5dMHXqVFmxa0T8Qi8grMHIN+Ra8opw28L9t9Q8MWoOyRH6xM5Vb5FQrYcLP/Ht9GnhITuLF4e8f/hJfPVqu5kJpfU4lprneE8bwJ0EzJ0bWRWJ/Tf71+o8UO5kRoyoq1cZEqMWDRdqYqIrosRx1Go9Ykaj2jfvHg8w/l4mIaiWm83RowilJ25EyRt8uQavmOdEaRlTjcbjEd/XZ58B11xjzCQNBIDW6fb6sVciBvCTFfMpyFf29oAvzo1SGJogVxSMNu+FRC8lopDepaCJJg0JKUQ8o0hI+eKLL7By5Ur87W9/Q21tLcaOHYuPPvooLPsy0bShFxDmYqRha2QCYal5YtQckrL9op2rHLtRrqAl5OHCLwctBts3O3dGijEBhJL1ctuvlzhlZkJpo44ld4yExC6hHDUNfmD9BuBeeVUTdacZK6Q01MLv98PplJ32TDtm3eyljEat4oHWc8jORkSqOSVv8OUa/UKGMcBst2cPU75ZzLvitRXAypXafxyOHo08PgLGha4oeUPAX5crBjic0oJGXh7QzM2UkePjdMkr0waEi3Mb1gNr1oYnnf3tb6Ofg5aQJK4AV1HB27lDviBCb8QIgiBkI/up65JLLsE111yDiooKPPfcc/jll1/wl7/8hUQUgrAILUlQ5RCLCYSj5WIUy0kp51yl8lmyef3mzI3M68dvE/uc72q8+zoQKgctNydgtKS+/PbrkSDVzPlgxLGkxoiPUP86HcJ9vm6tftecUtjQHsDAhLNWI2U0iiWPfW1F9AtRDzwe4MEH1CfVlJuU0+NhcqIIUVzMnCd/X1zUJg3l9plQXxuVXFZOolS2bWvei1w3L48JaRozhll3zRrpiz6nh/x5JIe166BL0lqxJM5SY8E+GIR5ozgZcUQuevxgEARBNAFke6Tk5ubizTffxOWXX25kewiCkInRJWhjLYGwFu8cLecq5T0hVno4Lw/o3AX4cgfwt78p97zghxs5HYwYw50Oeo+VmfPB6Lw0cvp51GhGJGETJT/8MPDTz4xNxsVv4Et5Ibgv39PTw4WUlJRUcxphJlJeG1KhGdw3+uyFqKWkqxg35AL9Bqh/gy/XA2DsWOCHH4DPP+N9IeB+9tlnjAjARWnSUKEwEzVhH0pjT+V4ZoQl3uV2BWddQH6ZbrnzSGu41oUdxLcTmucOJ5AiEPYmFYKzc6d+CWMJgiAISWQLKS+99JKR7SAIQiFGG7axlEBYylBOTYu+vZZzFRO0vvwSWLpUXGBZvFiwgKhsMYxvf1VUGDtWZs4Hj4cpD80me3U5A7i/4Bw8nubBdXwnTyIhLQ2uxMSo+1MiOn60GVixLCR+jRkDjBzBrOf1AmvXGCtYSREpFjqR7EqAr6EePt95cxphNtHyNkQTD/bsUZdHRQwhYUBriJCc7b1eYNs24e+4hrLHw4Q1rVypPmmomJixYoV0hml+30jlthETV6KFrUQk3hXpi0BAmaCglwilNmGrkJgT8APTpgsLf2ICnN4JYwmCIAhRZAkpffr0webNm9G6dWtZOx00aBDefvtttG/fXlPjCIIQxwzDNlbCpaUM5a4yhBRA/bmmuIWXv/pqpFDS0JjSQExEAcIN82gvc7n2lxljZdZ8CC8PHcAN2R8h9YO/oXrQfLgzMlB9/Dh2zJ6NtE6dcPmMGXAlJkr2lZKqTcuWBmuwwB8A1q9jhBSA2e/kydaIi2JiYXJiYqOQYvPQHiNLMEmJB1BoUEshJAxc+xtl+1CLVKlevqGsNWmolJghFd/IL71cWoqwEJclS4CzZ4GyMnHvoGhCQLSSxdx1lQoKeohQUn1/7pT0tnl5QJfOjHgi15MmmncNJYwlCIIwDFlCyrfffovvvvsO6enpsnb67bffwuczuYoAQTRBzDBszcwpqdbO0ss7R8251ojYr0JCicsJnDkjLaKwz7xqQpXMGCujj+H1hgtNATjw0U/Xox3+ih2zZ+OyoiLsLClBdWUlAKC+qgqbv0qX7Cu5ouPRoxE1WCI8V6wSF8XEwiRnEoBqe+dIUVqiWIhoE0/MgGTzX2h9Qy/mpdGzB5AtEbKhF1Kleq+7LrJvtExUpV4NQn1TVgbB5Lh8cYUvEkQTAqT6gb+uGkFBDyFCqO8DYnd9HtU12oW/WHkDQhAEEePIDu254YYbEJD5Q+BwRMmCSBCEbpgldBiJmGggV1yRMpSrDdZ0hUQcLux3bJvczYTX63cV8NBD4d7rdiq1qxalAtn6DZFCkx8u1LTuierKT7F95kwAQL0nB6n3zMbhE61k9ZUc2yI7OzIDu5AgZ8U1JyYWNktKAqph39AetSWK1cAO8p49AAKMiKLFMOZOXjEvjWPH5AspWtRi9jyEwlq2bAHuvluex4KSY8ntM6G+EfUa4ZfDEhAJpC5Wobbl5wNt2yI45nL2I4UeQoTavtcrNCceHgwIgiBsjiwh5eDBg4p3fMEFFyjehiAI+6DlmV/pcYQMYdYDXK5HhlUv4bj2DV9McTmB4oWArybUJq9XsJApvvoq9G8x7wMrS+1ykTs3lHrVeL1Mglc+Tgcw4MFR2PfcpwCAXcjFJyd+D//zDkERSyz/iZhtwT2fBx4EXltuv7xAYmLhlHeSgNMWV+3RkvNCb8QSyyq9OfC9aAoLhA3crCzm39EuCiVeOUL78nqZYz3wALD01fD1jehPsT4TapuY8c9P3AoH4HDIEwmkhAChBFELFwr3rRYxSc/+9HqBH/cC6S2B9CjhRYUFQGlj+BOF5hAEQdgWWUJKp06djG4HQRA2QksFHKWIiQalpSGxgRVXOndhQmnk5AyJhp5CEftcv34Dk1ODa+h27xbZxtFjpKu/iHm5rFsbSnxqFXLnhhqvGqG5AAA35Z3DTyuLAQBnkY4tmIRAwBHcLx8lYV3885n4gHQ+TSsRsm3da5lku5Z5pEQTCMxMfhnN+0VKDIi2n7LVTN4Pbn6Phx8G2nii94ESrxyhfQGc7R2IkGKN6k/+DVXsPMU8WLjt5p6LHvk72LaZ6fGklvJyJl4Rje6Rk6YCQ4eKr8uKKHAw3jZG/fjaDanr0qw3OwRBEAqQHdpDEETTQG1YidrnHCHRQMzLYPo0fcQdI4Qij4fxFhk5IroRPnKEdPUXj4cpv2t1qV0+SuaGmvLcwnMhgOyv56HaWwl3ZiZajJyLwP+5Irblh1DJeQ4XOp/ly4AB/ZicmnaEb9u6k5jyqJZ4pMgxYs1MfinH+0WOZ4jYfk6fijzmCRl9INcrR6g/Fy9u/DLA+esIeXyY5bEQbazFPFjkLlOLnh5PRhjrbL+BbWNjv/XtK3yTCgvdCgCrVwODB8e/eCB1XeqRY4kgCMIASEghCCIMNQawFmHC4+GXugXyC0KfueiRM0Rr/hEllXTE8HiiV3+JJrYYidg5is2Nzz5jil1w11WTAFgofOWhB/3I+KoFqlyZ6Dd/Ps45MuBcEYA/4AjbLz+EiovY/BQ8H4vFKqW4k5IAANXnz5p/cLlGrFlxd9G8X+R6Lwjtx+EE1q6L3PaPk6P3gVyvHMGKNELJlwLAtGlAy5aG9GddXS22b1+HioqN2L//Kxw9+gPq6nxIDDiQjVR0RSv0QQb6+7OQyD1PoZuf3GUsSsWM7GxEBks6lN8ojTLWBfPHiAg9ZofB2QWp6xKwv8cRQRBNFhJSCIIIQ6kBrFWYCC91y3gyjx0DNE8NGdRK8mBEQ41QxG2rXp4sQrYl34awotQu9xwdAAoLgbFjme/EQo5WvMZUDOWnJlBTnjuyX1xouGEG6quqkJyeDjeASZMceOWVABr8jrAQKrb/2OMD0vNTcK6rsMGsJKVRSKmtsSC0R0nYjhnJL6N5v8g1VIX2M2qkgItYA5i8H1H6QK5XjqAoIIDTBeTk6N6f9fV1WLeuBOvWvYhTpyojvq9FAIdQhUOowkf4L1ohGaO+fRejeuQgISFRewP0EjOUFjwwMjwoeI1w8sU4RK4RM8Pg7ITUdRnQsXw5QRCEzpCQQhBEGEoNYC3CBN/IDSDkycw1qJNTQmE9LGq9M5QIRVxhA9C/kg7XthQTacxMoCs0HqtKATgYcYs/N7gI9Yfa9vNtbldiIlzp6cHPzH4dYfvl99+o0YxXz+494vOzV6/IuT7h/th6Pm+WzIT2+KrPmX9wM8N25CI16ZQYqvz9AOEeKey2F3eX1wdyLoaKiujn5zBGUT1yZBdKSu7BgQMy2tDIKfhQ9s5T2FrxDxQVvY6OHS9R3wClYgZ7cz5zGoJllpUY2kZ6grDXyJIlQKAOgMT4eTzheXjscD2ZQbTrsimKSwRBxASqhJRTp07h3XffxYEDBzB9+nSkp6ejoqICmZmZaN++vd5tJAjCZJQYwGpCOFiiiTBcg1qNd4MQQkJRfn6kJ4OQYa6XVwyfaF49Zj1HiyV7LSsFBv8mPBXCZ58xnihchPpDS/ulvPy5+xXqvzVrmP+F3k1z5yd/rqemKW+LlQSFlBoLhBTAunJZUohNOqXCD38/Qtu2kcgPIrddACeXhoQ3isMJPL8Q6NZdfB0V7N79OebNuxHnz59Rtf2BAxV49NEBeOKJf6JHj4HqGqFEzOB7rmhNvitXYFN7E8jLA664Ajj4A9C6BdC1p/B65eXhyYwLmkii2WjXpd3EWoIgiEYUCyk7d+5Ebm4uWrZsiUOHDuG+++5Deno63nvvPRw5cgSrV682op0EQZiMXANYzIMFAHbulH7mVCLC6Gmvsfvaswf47rvIMst9+kQa5uvWqheMoqHFq4ePFoM/O1s4sICf5NbjYXKirFxpTH8AysKoxAQgIPJcnI7I53DuXK/2aWuL2YSEFAtCe1iEbhZ2VZ603EiEtvU1JvlVqhjy+0cwPwoH1oDUWUQ5cmSXqIgyGMAYAH0AtAbwK4AKAGsAfMpb9/z5M5g370YUF29T55miRMzge66wYopaLw45ApvWsCOPB3AnhOYLf/zFKkX9pgkkmgWkr0s7irUEQRBQIaRMnToVhYWFKC4uRlpa6NXd8OHD8bvf/U7XxhEEERvwn3MqKoAJE6IbnlxPZqmKK9z19XqGqqhgCmJwDW3WE+SRaZGGuT8AjBkTWd5Yj/YICRhCokQ021Srwe/xMDlRVpWGLxdqi9ocKHJQmndHLHeLENOnA4MGGdcWs3Fb7ZEihN2rbGi5kehxExLqnz59IJofZcLEyGzOOlBfX4cXX7w7QkS5BMBKAP0FthkMYAqA7QDuBbCL893582dQUnIPFi78QnnOFLneQoLJW/3AozO0Jd+VMtb1zqFSXs5szx3/rCzKBSJ1bZnpmknIxuFwIBCQ8cNLEHGA3++Hg5eDS7GQ8uWXX2LZsmURy9u3b49jx46pbx1BEDEN+5yjxPBkPZlZwz+/wBx7K/hcLPBdg58xZ4S8T0aOkFfeWCmf/jv8swPiL0TFRBK9ylaPHcs0gFtFSUwgMepFoVIPHancLVxcTiZHp5FtMZvUlEYhxYryx0IYmbgzHhDrnxUrGBWzdFX4+k6XehElivK6bl0Jfvzxm7BlwwG8C8AdZdf9AXwF4FYAH3CWHzhQgXXrSnDLLY8qb6+cG4qY54oeyXfFjHU9c6icPBEewsWO/5zZwus3Xt8EYUdSUlJQXV0Nv98Pp9NpdXMIwlDOnTuHFi1ahC1TPOuTk5Nx5kykC+gPP/yAjIwM9a0jCCIukDI8uQgZ/qvLmOXs9zt3hj4b3UYW1tieNIn5N7uMFRM8HiZJqV424XvvAatWhYs6Tmeo8iMgLpJw+0Zuv3MpL2c8h+bMZf6WlzPLx44BXnsNmP8sY99JiVvc/tBrzFgPEy7Rwoby8pi2jhkT2pYVxNjt1XjMqGmLmbgbDa1an86hPWoHU8rojDWMuAlJ9c/YscD48Y2hKtCWD4K9uOfOYf6ueS/sXOrqarFu3Ythm1wCeSIKi7txfX4gz/r1Jairq1XeZiD6DZZVTZ0u5jPbR4BxPxiseMNFbcLTykoAAuN/VOT6qBGINdQTI39oibinQ4cOqKurw+HDh61uCkEYSnV1NX766Sd07NgxbLlij5SRI0fiqaeewt/+9jcAjFvXkSNHMGPGDNxyyy36tJYgiJhFbt4TKcO/osLYnBRioSBcY9uMsGyvFygtjVzO93iQ4xWhR9nqJUsAdzOgR074sYHo5y9WNUdou2ghSmrDhjwe4N7x4V5DgLYxNDKESQ+apaQAAHw+HT1StITmGJ240yyMCk+K1j9jxjJ5MbRMWiGvl1WNni6N57K92emIEscrIV9EYXEDeA3AAM6yX389hu3b12HQoNuMGWexWFK5Y6W0TUqTFEuRmQnmHSYvOe4lPcyvTmP3EDzC9mRnZ6NVq1bYvn07OnfuHBH2QBDxwldffYVAIIAePXqELVcspLzwwgu49dZb0bZtW1RXV+Paa6/FsWPHMGDAADz77LO6NZggmhJ2sSn0aIdcw1PM8E9OkWfga4HfRjHD3+iw7KNHhcOLnI7w52c5IolSg19InPEHgOJi5lhDhgAffyxPzBKrmrN2DTB5cvh2cvO4aBGy+OOmdQztnOsw1c0IKbV6hfZoDc0xI3Gnngjd9IwMT5LTP1pvPFKJaxvPpWJgatjiwRDOiSKHqwH8BgA3QrGiYiMGnW9p3DjzY0nljpXauafXTSC9DXPMV18NH/9u3c2tTkMheIQOOBwO5Obm4u9//zvWrFmD6667Dunp6VY3iyB049y5c/jqq6/w8ccfY+DAgWH5YQEVQkrLli2xadMmbN26FTt37sTZs2fRp08f5Obm6tZogmhKKHmTb2Y7tDzzynnmFDP8a6qlDXy9nsXF2mimqCXmGVNQGGlXyRFJtJatZvEHgM3/Cv8s9YwtFioVQPh2SvO42Cm/oJ3awiXV3RjaU6tDaI/XC2zdqj0fhJmJO7UgZlTrmRNDCCUXqpobkpDXCxd/A/bv/yps0RiZTRdjLMKFlAN7twObvcaPs5Kx2vcDk2Gcn59EiUiox1jl5QF9+0aOv5mKrdFznGgy9OzZE36/Hxs2bMDOnTvRtm1btGjRAi6Xy+qmEYRq/H4/zp8/j19++QWBQAADBw7Eb3/724j1FAspLIMGDcIgJaUPCIKIQMmbfLPbofWZV47hKfTc6PVKG/h6Povz22h2mVshz5iCAiZHCR+5z9hyDX65CVpZpBKsSoky3O3EQpT27FFWSYcIwZY/rq2t0bYjrqjAR02IgRmJO7UgJejIDU/SAr9/hIxwtd4TfK8XPk4Xjp44EraoT+RairiC9/nnYweAQJfwhUaMs9BYOZzA6VNMn/L7ku8DqFeblI6V2PVhlmJrxhwnmgyXXXYZcnJysH//fhw4cADnz5+H3y/jwYIgbIrL5UJGRgauuOIK9OjRA6mpqYLrKRZSnnrqKcnvH3/8caW7JIgmi9w3+Va0Q2llErWeHEJhGFIGvlEVU6wqc6vkJaTSvCVyj71nD7BwoXT5YKl8K1Jj5nQAp04z/SsmuCxcCJw/T+H5anAnJQEAfFo8UviiAhc9Qwy8XuDMaWsMOP4NSkrQ6dXL3DALsXLIWjx3uDeWffuA1auZc3E4gfx81JWtD1u9tcZT4G9fV+dDRDlnI8Y5QjRyAIFGF0axvuSiR5vs5GUlFz3zvhAEgKSkJFxyySW45BJ++mmCiF8UCylr1qwJ+1xXV4eDBw8iISEBF110EQkphG2wS94RKeS+ybeiHUoqk+jtySFl4BtVMcXKMrdyX0Jq6Wex68HjYbxBzp8PDx267jpgyxb5CVbZMVu/AVi3lmmjAyGbhm3vpEnhghVgnmgVjwQ9Uuo0eKSI5dSYMDFUetfrBfbsZpbn9FA+UGEeL46QmGKGAScmVEgJOmaFWYgZ4dMe0e65w95YevViLsbSMmafZWVIdCaitiFUWedXjafB3z4RbNLJRjHFyHHm/2DI6UuAGX892mQXLyulRJvjsfAQRRAEYSGKhZRvvvkmYtmZM2dQWFiIMWO0RtkShD6YHaKhFqk3+WaWWFWaqJSLUZ4cYga+Uc/iWsUkNSh5TtXSz2LXA/f4Qs/Ud9+tzI70eEJVc/giGNveFSuAadMZcYWLmcJhPOFuFFJ8WoQUMTd/VkQpLw/PLQGHstjDCI+XALOPR2cwtcaNHHQxoWJhMTB6FLBuvXFJX+UgZoRzxSYWtd4TXm9IRAGAgB/ZDSk4hJCQUgEm4axa+E+G7dEcQQFl2jTjx9njAVq0EO9LvncMHMDzC5kkr1oxM0xG7o8Gdz1AfBuxOW6nhNAEQRA2RXWOFC4tWrTAvHnzMGLECNxzzz167JIgVGNViIZahN7kW1FiVe0LWKM9Ocx6MaxFTFKDUrFPbT+LXQ9nzwFlpZHH18OOZG0asXwogPGilVUvU80+LhvaU6dFSJFy82cnUJgR2lhKS+5NVUgsCPiBli2tEyoemYagoDNmDDBipDU/EGJGeE6OfqEXAn3QFS1xCGeCn9cAmKLuDAAA7/E+X4SWzD/8DeaMMyDel5lthddvrVN1EbPCZOSIG14vsGE9sGYtgvMbYP4tVxCJxVAlgiAIC9BFSAGA06dP4/Tp03rtjiBUY2WIhlq4b/KtLLEqZTiLGYhmeHLo/WJY7FzUijZi+5NarlTsU9vPYtdD6aqQaWyE2CjUXqeD8URhH+/Z7/UWrazySLPiuMHQnnqfth2JTX6xsJ+AgpuqlYktRSvYBEJ/161nhBQlsBe3pzWQ3UF9+6SMcL1UZIE+6OPIxEeB/wY/fwpgO9SVQP4C4RV7AKAPMph/6D3ObL+7U4DqmvCbq1hfVtcgstB8gOlXQB/l02jFX464IZgwmnPecgWRWA1VIgiCMBnFQspLL70U9jkQCOCXX37B66+/jhtvvFG3hhGEWqwI0dALsxL2K0XKQDTDk0PPt/zRjF2lYyC2P6njqBH71PazWB4evlmht9go1F6/P8x8hQPAjEf19fq3yiPNquOyHim19TUIBAJwOBxRtpBAaPKLCREOBTdVKxNb8o8tdC5KjcQwgzUATP6DPkmhhIxwPX4UBPq//wNPotWbE3DqVGVwtXsBfAXArWDX1QAm8Ja1RjL6I0veOCu5uQsJBXwvC7FScEJC3v59wNy5+oWv6DFWYv0RTdyQShgtto0YVNGHIAhCFoqFlJKSkrDPTqcTGRkZKCgowKxZs3RrGEGoxewQjXhHjoFo5Ms4Pd/y623siu2vcxfp46gV+9T0s1QeHi5GiI3c9p46HZkXxR/Q3+vfKo80q47LeqQATAnk5GQlZrAM2AkUZqQ1XohKTsysGL1ox05JZpL0qDUSIwxWncIejFbRef2f6PFg1PmpKCubEVxlF4BbAbwLeWJKdeP6u3jLR6ILEh0JTB4aqRwkYqEqQmKCmFAg5GXB70shIS8/PyJvjOZx1Kr4S4XuRBM3xDzH+Mid66NHAWvXmZcQmiAIIgZRLKQcPHjQiHYQhK5Y+cwe6whVCZVjIBphB+gtfOht7Irtb/cu6eNoEfvU9DN7PXz2GbDitcjvnQ7jnpPZ9nq95niKWeWRZtVxWY8UAPD5zusvpADM5Jk+Dag6C6SlqXchstLljjsRtRiJdgt7UGK88/p/1KgibN36Ng4cqAgu+wDAlQBWQjrM5wswnih8EeUitMQoXMj0UY1EuJlYqMrZs0BZWaSYICUUyOl//kOB3uOoNTlrtNCdaF5doiFsUFYhi38eVuYPIgiCsDm65UghCLth1zAZOyPk/dGnj3WhUnoLH3oYu1y7Zf/+yO9dTuCi7nU4hu2oRAVOYT/O4Sj8qMNHTyaie/tsXNm1K4b16YNXlvbHieOJpoh9Hg9ThGXlyvDzdwB44AFmnI0+vhmeYlZ5pFl1XJfLhSSXC7UNDaitrdb/AEIGYqzeWPUwEq0Oe+DegCoqNBnvCQmJKCp6HY8+OgDnz4cSz+4CcDWA3wAYC+AKAK3BlDj+BkxiWX5OFABIRQKK0BsJcEbvEzEho7QUwQBArpggJRTI7X/+Q4GeVZG0JmeVI+xECwHjCy2jRoZy/8h5qyR0HmryBxEEQTQRZAkpY8eOlb3D997j524nCCIWEPP+WLHCulApvd/yazV2uUKTUCYKP+rRus865D63DpU4FfF9TV0tdh46hJ2HDmHlRx8hs1UrTB01CkU9RsEMXZt//uw5vLoUWLbM+OSoZnmKWeWRZtVxUxKSUNtQDZ/vvL47jqfqHdGMRLmeHRE5V0wMewjLEcKpxgKIj02U8+rY8RI88cQ/MW/ejWFiCsCIJUKCiRCpSMDj6IeOSGMW5Ocrz8Mhlb+mVy9gyBDgX5vDv1cbdqJn3h49vFvkCnRSb4iiCS1mnAdBEEQTQtaTe8uWLY1uB0EQFiPl/WGVgahE+ODbC+zn1h6gQ3ZoPS2VebhCEz9ZaxWO4FuU4PRXB2SfX+WpU5hRVoa3t27F60VFuKRjR9nbqoU9/z17QhV0AOa8lFS0VYtZnmJWeaRZcdyUhESc8VVr90gRiuuLF8NK6lyUenZwbyJtWmmr2iOXiBwh/DsQIseGL7yMGS3ogdOjx0AUF29DSck9YWE+crkILVGE3iERBQC6dZPeSEjIKODlLQFCYoLXC3z8cfg+HM7oeVikMLAqkmLvFr2EHS03IKu9rQiCIGIMWULKqlWrjG4HQRAWE837w8iCBFLIedblhyQNGcI8c/sDjLnxh8naKvMAwkITy0nsxg7MQz3UeQRUHDiAAY8+in8+8QQG9uihah9K8HiYfuGfjj/ACCyDBhneBEJH3ElJwDnA59MgpAiF8PTpEz+GlZiRmJKszuuGvYlo6XMlyEkmyh0bIeFlzRomN4yAUNSx4yVYuPALrFtXgnXrXgyr5iNG6+SWGJl7H0a9vyf8YVLuHBG6uac2FxYTdu4UTjQrlYdFCu6PUa9eytbnzwu9RBCrk7vp6aVDEATRBKAcKQRBANAe9hJNJNFSfUdK+BAKSdr8r9D3fugTjSAkNDkAnMERCRFlMIAxAPoglGWgAsAaAJ+GrXnm/HncOG8ethUXm+KZQhiLniW7o5GSyCScVR3aIxbCw43ri3XDSsxIrK4xx+tG64QQzBHiAJxO4bERE14khKKEhETccsujGDlyCrZvX4eKio04cOBr/PzzD6irq0FiYgraZ16Ii9p2R59+N6F/7j1IPH0GSFrPhElx2wEw4oecUCnu92Jigp7eEkoTw8pZXy8RxOrkblaLOQRBEDGEKiHl3Xffxd/+9jccOXIEtbW1Yd9VVCh3CyUIwhr4z/Zqn6GiiSR6V9/hIuUpwtLg1+5pISQ0DR9Rj+nrXhQQUS6BeN2LwQCmANgO4F5w616cOX8e95SU4IuFC5GYYKzO3SOHEYK4XecAU5DFbMwUHcxAz5LdYnD7rFmjkKI6tEcq7CWeDCuhc/F6jfe6UVLmVwwxIUhsbKSSs0YRihITkzBo0G0YNOg2+ecFRyh5b0UFMGGC+go2QmKCXt4SSvP+KFnfahFEL+LlPAiCIAxG8ZP6Sy+9hDlz5qCwsBDr1q3D+PHjceDAAXz55ZeYNGmSEW0kiCaJ0calmLGn9BlKjkiid/UdLkKeIkIsXAicP6/NoOXbYS//cx3O4EfeWsMBvAsgWhna/gC+AnArmKKjDBUHDqBk3To8esst6hsqA48HmDw5cg4oHXstc9TrBdZvANatNVZ0MBMjRUMW/rVb10ajR0q0t/3xZFjxz8XocAYxQ/zc2VA+ELlig5ioJdRW9rzCwnsacTiZkCY9zwsBxitl0CDjEhTrIeopzfsTL3mC4k2tJgiCsAGKhZRXXnkFy5cvx5133onS0lI8+uijuPDCC/H444/j5MmTRrSRIJocRr/R1tPYkyOS6F19hwvfU8TpAC6/HPj223BvC70MWtYOq62rw7JN63jfXgJ5IgqLu3H9K8H1TClZvx53XzMS3v8l6vrcq9YDSegZXOscLS8HFi82ZoyEkGtHeE8Av3rV2xtGioaA8LX7q7dRSKk+p26nTTU3Ajsp+vRhwpiM8LoRLfNbpk5sUCJqsRf4Bk7oDXu8adO1/bCIndeu3cYKD3LPX+yCVxoiFA8JWJWGMhEEQRCycCrd4MiRIxg4cCAAwO12o6qqCgBwzz334M0339S3dQIsWbIEnTt3RkpKCvr3748dO3ZIrv/OO+8gJycHKSkp6NWrFz744IOw7wOBAB5//HG0a9cObrcbubm52LdvX/D7Q4cOYcKECejSpQvcbjcuuugiPPHEExEhTQShF2Iih9er3zGkjD2lsCIJFyGRZNRoZjn7vZ52Wl4eYweNGcN8/uZb4fXYEB89WLd9OypPneItXQn5IgqLG8BrYUuO/forRt2/HXPmMh7y5eXq28lSXs7si79Pj4fJtSg2FkLbaZ2jwZfZAt+pnYdSiJ270HoPPRh9PSnkXg9qEbp2XWCElBq1QgoQuoienc/8tdLQ8nqZ/BpyJpSSdbmwk2LuHOZvRYX0haAW1hDnIlXmV288HmD8vUx1G247WPFGqN/k9KnQeTldwCU9hJebKTzwx5Z7IbOiodMVapvUj5HS9e2GmEeUng8UTQG19xmCIOIaxUJKVlZW0POkY8eO+OKLLwAABw8eRCAQxbdeI2+//TamTp2KJ554AhUVFbj88ssxdOhQ/O9//xNc//PPP8edd96JCRMm4JtvvsHo0aMxevRofP/998F1iouL8dJLL2Hp0qXYvn07UlNTMXToUNTU1AAA9uzZA7/fj2XLluE///kPSkpKsHTpUsyePdvQcyWaLnqKHGJkZzP5MLioNfbY50wxkYR9pl2zBvD7GbHDKDuNDREBhI10gCn5q9RAFnqG2hiRD2owhHOiyOFqAL8JW1IJZv96CGlqhQ+x7XbvkZ6j0Z45pfLa6Ck6sG2Rc+7B9SC9XjSiXQ9aERJqnGDCNGprNAgpQHRVzQykjGAt63Ix07j0eICCgpC44HSFf2YxWmyQSqrLRW6figkM3bpHLh81Ut9zkULO2CoVDe0kMipFKjSJkIfa+wxBEHGP4tCe66+/HuvXr8cVV1yB8ePHo6ioCO+++y6++uorjB071og2BnnxxRdx3333Yfz48QCApUuX4v3338fKlSsxc+bMiPX//Oc/Y9iwYZg+fToA4Omnn8amTZuwePFiLF26FIFAAIsWLcLcuXMxatQoAMDq1auRmZmJtWvXYty4cRg2bBiGDRsW3OeFF16IvXv34tVXX8Xzzz9v6PkSTRMjw2BY+BqAA9qMPbEQEb4RGwCwfh0wcoTalosjZpzz1eIAlIWPiIWwfLV/P2/NMSpbzjIWwL+Dn07jQPDfWkNDlIabsF7xp88Ib+eA+ByVE/IjltdGSnRQG+Iv99z1DMkxMj+rUNLji7sk49ABjeWP7YCSxJ5Kk4ZyMSLvhdgELS8Hyji5UArygTFjgeYiZX6NQk6IitI+FZvo3JCiNWslyy7rjtyxVZr3J1bzBMVDaJKVaLnPEAQR9ygWUpYvXw6/n7mhTJo0CW3atMHnn3+OkSNH4oEHHtC9gSy1tbX4+uuvMWvWrOAyp9OJ3NxcbNu2TXCbbdu2YerUqWHLhg4dirVr1wJgvGiOHTuG3Nzc4PctW7ZE//79sW3bNowbN05wv6dPn0Z6erpoW30+H3w+X/DzmTNnop4fQbAIGUqG5D7kLHM6mecCLQg9Z0bzrtEz952YAFVwL7ByhXAboh1XKpfMD0eP8tbW2IG4IuzTWfwc/LdWIU2JOMcXQviVfVxOprKP0BwF5OXeEcprM2o0I7AJjYmWfCwp7shzcDqA5JTQZ6+XEY2cDqBBJwHTSLuLb78+9pdk4ADgqz5rzAHNQonAoUUM0du4lKrKwzfCylYDvxlsfjWkaHlwvF5g61blfSo10deuQ/DKM8sAjUXhwMhEsE01/5FexEuyYYIgDEGxkOJ0OuF0ht7xjhs3TlRw0BOv14uGhgZkZmaGLc/MzMQekaQHx44dE1z/2LFjwe/ZZWLr8Nm/fz9efvllSW+U5557DvPmzYtYXu3zIZEjsBDqqG4Cffiba4EePYFjx4CsLMDTBqiWOG3vCc7zeBvpff94GKgTEDcOHgFS07S3nUtrD/MYzX0McTmA7/cAs+Ywy50AHngQyL1B27FS04CJDwDLlzHGsMsBTLgfyLnEJ9iGVlH6FJDuK19dHW/t1tpOgLe9H3VogC94Hqlp0dsrhljf8PfpPQG8tDjUVw2BkEePH+HbCc3R//e9/LkltD0QeY5CbXp5CbNttLn+0WZg2dLwsWf3MfURZt4BoXUYwcWHBoj3kV1ITQO6NvZpUiLzU37+fFVse6V4WiPijuFwAW1aAfzzUrIun7RU4IGJwLLlQKCB2e7+Ccxyhf3n++UnYPFLoXYEGoAlLwM9ezA35QDvPuFvAI4cZI6VlgqkdW3ckQnjdu1vmHaxF10bD3PczR8BS5ch8kqB/D7lc/hH6XNXywlv6MeujYAhKzS2d90B/L9vme8vvlh4O4MJBALw+apRW1sDn68aDkdjfF5Y3zuBBx8AbsiV2pVyxMadiI6W+4wOiN3PVZe6JwhCVxQLKV27dsXdd9+N3/3ud+jevbsRbbItP//8M4YNG4bbbrsN9913n+h6s2bNCvOEOXPmDDp06AB3cjLcyRpLDhIA0CT6sUM28380lL6tv7ATkCjgndClI+DWuVs7ZAN/mBzuuZCfz3i6OwA0RtHjteXAgH7aX/CMGM7sh/uSt9oH/GFycoT3hJy+leqr5MRE1IQlnf5VW+N526ckJuKB/GT0uATo3k353vgvOYX6JqIF3vBxYZnxKNCyZeR2/DmqdG7JmeOCbQoAp05Ib+v1AiuWCZ8Py4plzF/uOg4AMx9NRk5O7LxwbNGsGQCgvs6H5GSlyY5tRHYHYPIfIt+eZ3fQtq4Qw0cA/QZo9wg58SuS+bMsAODEKaDThYAjMdI7omMXwKpxyu4Q3kdeL7BsBQSvFKV9yqVFKzCPmJybgdi5y/XIkFt9hju2+/YBpaWcdjiYuu8m5zkJBAKor2cU2eRkNyOkCPX98teYtuue9LiDunFs6mi9z+iA0D09KYn/IocgCCtQLKRMmjQJb7zxBp5++mn06dMHd999N+644w5kZWUZ0b4gHo8HLpcLlZWVYcsrKytFj52VlSW5Pvu3srIS7Thun5WVlejdu3fYdkePHsWQIUMwcOBALF++XLKtycnJSG4Chj5hPWrKGBsdOsSH78FudHlYIU9ztV70Un3VPTsbOw8d4qxdASbhrFq+CfuUVNceK15TX1pYSFyLFm6SImLbtc2UJ+aweTXLyphj6zG31OYMkkpoyyL0vR+MaBQrIgoANEth4pTi4i2lkotVa3iMHvFX7dqJh5LEQliFUOgCAEyYCFxzjbq2sjcgvogidO5yxRGluSrYZXPmhLcDBtZYVwqFjRgb1qQXZofhEQQRMyiu2lNUVIQvv/wSu3fvxvDhw7FkyRJ06NABeXl5WL16tRFtBAAkJSWhb9++2Lx5c3CZ3+/H5s2bMWDAAMFtBgwYELY+AGzatCm4fpcuXZCVlRW2zpkzZ7B9+/awff7888+47rrr0LdvX6xatSostIkgrERMlPjsM+kCFGwRgvnPmlOEgFsMxOjysHLawEeqyoxYX13ZtStvzTUaW/he2KeWuAiA+tLCakoT14jY4b4aecdm82qyAk5+gfa5pbYKjtA84+N0CMxFh73TKQjRLJkpf+zznbe4JTqhpHqQ1ZWG2ohUr+EmXrVzxRexMsZtxPPAScIXPABm/wuLI89dSfUkNdVnjh6FYP02u1StEev7WLsBqSWWquFYfZ8hCMKWqFYEunfvjnnz5uGHH37Av//9bxw/fjxYTccopk6div/7v/9DWVkZdu/ejYceegjnzp0LHjc/Pz8sGe0f//hHbNy4ES+88AL27NmDJ598El999RUmT54MAHA4HJgyZQqeeeYZrF+/Hv/v//0/5OfnIzs7G6NHjwYQElE6duyI559/HsePH8exY8dEc6gQhJmIGYsrXov+XGLVc4HR5WGVwj7LzZkr3mdCfTUsIjvvpwC2q2zFF+BW7AGADE7yWjnlr1kxKFppYim0iFxCAs7qMn0qyqoR/oTmWZ8rwst+BwLAkCHh69z/QOw9Kzdzx5FHSiwSTSyxsxHGL2PscDJ16ouL1Rm3QoJHwA/UCCQaUiKOqBEdsrMRfsXL3M4sxEpI23Ge6I2ZJcgJgiAMQnFoD5cdO3bgjTfewNtvv40zZ87gtttu06tdgtxxxx04fvw4Hn/8cRw7dgy9e/fGxo0bg8lijxw5EuYtMnDgQLzxxhuYO3cuZs+ejW7dumHt2rXo2bNncJ1HH30U586dw/33349Tp05h0KBB2LhxI1IaXaU3bdqE/fv3Y//+/bjgggvC2hMIRPEbJwiD4YeecJET5mMVennKavUKVhMaxTKqf39ktmqFylOnOEvvBfAVACX5D6oBTAhbkozWyEL/4OdoYgY3lMcB4Uo7cuwGLWFfZoZsyR13dp6t3wCsXQNUhEdPIQBgyxageCHjddOunf4Jl80glYQU64mF8rhiFw57oezZwwgoWirtuFPkV80JCh2B6OuyNyduGFC0m5PHw+RDWbw4dAw525kJt+8RAHJ6WN0ic6CwJoIg4gDFQsoPP/yAv/71r3jzzTdx8OBBXH/99ViwYAHGjh2L5s2bG9HGMCZPnhz0KOGzZcuWiGW33XabpMDjcDjw1FNP4amnnhL8vrCwEIWFhWqaShCmwD6HffYZ44nCRa0hq0WgkLutVrtDS0lcFi3Gf1JiIqaOGoUZZWWcpbsA3ArgXcgTU6ob198VtvTugSPh/SJRlpjBF4P48q7TocxuUCtyqc1lohQ1475uraCDPwBmvH01jMMAYM8KPdFolsLk5PJZKaTEQq6Dpky0XCQeD9CiBSKuFCXGLfcYLFJeFhUVvAUKb1ZyCBMqAFtmka6okJcnJl7weoEzpyFbRCMIgrApioWUnJwcXHXVVZg0aRLGjRsXUTqYIAjz8XiYvIArV4obskoLI6gRKPQQN+SgxZOEi5TxL6e/ikaNwttbt6LiwAHO0g8AXAlgJcDxKonkCzCeKOEiSp+LLsKr00bh9Cl5YoacpKoRUUhRUCNyaU1iLKe/1Yx7tP4xIz+P0TRrTG5umUeK3IShhDXITdTKhs/I8SaJdgwglBulm0CFR3b9MEPaKX6zUppslovHAwwaFP0c5KC3YKjlvGKRMLGN4z/ZlMKaCIKIGxQLKXv37kW3bipqcRIEYShShqxcgUOLQKGXuCEHvcJIxPqMfUEYrb8SExLwelERBjz6KM6c5yb63AXgagC/ATAWwBUAWoMpcfwNmMSy/+bvDi1TU/F6URESExJkixlCYhAXf8A8b2m13ixy56eacZfqH6vz8+iFO4lJNltbZ4GQEm+GYDx61sgNo9BSZUhJbhQlbVK7vhL0Lr+shKYU4hIhtjUKKNOm2dNTiCAIIgqKhRQSUQjCvggZskoEDi0ChdE5MrjoGUbC7zOAybEoVxC6pGNH/POJJ3DjvHk8MQVgxJJIwUSIlqmp+ODxx3FJx46K2i+VJwcw3+NCqTeLkvmpZtyFxLL8AqBb1/ipZBkSUmSWV9KTeDIErfCsMUK44e9TyNMEAPbvC8W0sWiJ7VPizWL0+nIxqvyyXIw6Lzsidq+ItXrzBEEQjVAdX4KIM/gFIqQEDj5aqraYWdZY78o/bJ8BwNatyqveDOzRA9uKi9HnootUHb/PRRfh8wULMLCHukSD3Ko248fbpyKSHKLNT25pajnjLlTKml/1Z+wY+xZRUUMwtKfOggQvdi3hKlXTXGx9LVVElB4PUF7+Vc4xhPbp8QAFBZHrlq0W3peaKkNKK9AYvb4cjC6/LIemULmHnbdsImIudrhXEARBqERT1R6CIOyPkrf4WvJcsM/qZWXMsYw24rk5BAMAeuRo2x83vISPHEHoko4d8cXChShZtw7Ff1+HE2dPRT1mVuvWKBo5EkWjRiExQdvtmPUE6dULGPwb7RWRzEJqfoqF/Ii9MJcKEYqFoipqCXqk1JsU2sP3eFAbDmIUajxLtHjWqDmeUg8HOceQ2mfXrpH71NtzSKk3i9HrR0PJmLtTYFhyVL3Py07w5+2QIUypNLvcKwiCIDRAQgpBxDlKxREteS5YEcXpYMInjPaK5+cyKSgEul6k3EueH17CRYkglJiQgEdvuQV3XzMSo+7fjkpU4DQO4Cx+hh91cCclonv79uh70UUY1qcPRvXvj6TERPkNlWg/1661u2ggZodz5ycgHfLDPz8zc/SowesFdjcWDumhczoArkdKIBCAw+GIsoUGxAx6uxiCakMw1IZYnFB5vGhGPPciAeQdQ2qfRoeQcNvLDxeSQuxiFgt30vPmJrdP2DnPF1HUigBeb2hM2O3Z82K9N+IhR4/QtbhlC5OAuMZn/b2CIAhCI6qFFK/Xi6SkJLRo0ULP9hAEYQBK7Rw98lysLmM8I4x6ThI65qpVzL/lVAziPquLVXaZOIGphqTkOR8AsrMS8ezkQXjllUFo8DeKPAXA2LHqzlUKoyolGZVzU66Xyc6dynLumJmjRynl5cDixSEzzAFg8mT9hEZ3o5ASQAB1dT4kJaXos2M+0UQKtR2t52RT61mi1rPml1/UHU/KiOeLVaNHyTuG1D65LoMBv77eAFpyy/DH3sw8NXLGXGk1omh8+gmw6k0Agcjzi7fqV2LXYo1PmdhGEARhUxQJKadOncKcOXPw9ttv49dffwUAZGRkYPz48XjsscfQrFkzQxpJEIR2jPRSsMKIlSpry/VGSE2L/J5vzBcUCoeXCIkocoWLvDzg7DmgrJRZt6wMaN6cWa6X3WiUF4aR4oxcL5MUt/A+kkU0Aj0TEOtJ0A7jLAuAWSY0TmrmBhvaAzAlkA0TUoxILKu38ajF80KJ4swOFJv3QenxxIx4IFKsWrtO3jGkhAHWZZDt54J8fS9qNUlY+WPPFXqU7kst0cZcaTUiqQv4xAlgVSmARACO8PMD4qv6FdC0EukSBNEkkS2knDx5EgMGDMDPP/+Mu+66Cz0akyLu2rULL7/8MjZt2oStW7di586d+OKLL/CHP/zBsEYTRCwTj9U1rTBio5X9ZYWcrjwhRcx75tZbgXfflc7vokS4+GFfSERh112yBKisDB1HqeeM0DO+3gKWkSEyStpbI5LuwydSmEZLfh8jERP8+GWpG+rq8OE/fFhW2jw4Nx4oPIuhNyfDFSX8KzEhAQlOJ+r9fvh859G8eWsDzgT6G0Z6VULRM2eLHMWZKwAgAFyfqy7vg5grlpDhzsUhMbmlSrdx+7lsNfCbwdZ5AAm2qUx/oU4OUmPuFhElU5Ijl0UTBY8dAyByfoGA8Lnv2QO0aBGbDwx2zJ9EEAShI7KFlKeeegpJSUk4cOAAMjMzI77Ly8vDPffcg/Lycrz00ku6N5Qg4gGj3vQrRW8xxwojln9MPmJCjpgx/847jKeAVH6X3XvkCQH8UA4WfwD42zvhn195BejchREO+OMRbb4YIWDpLc5w55qS9qo5Nzul6mARE/ycjtC5NNTV4dOnX8HSbycH54w/ACxb5Yb7m8UY/NjDUcWUlIREnK31weczMOGs3oaRHh4uZudsiQj10Jj3gW/Ei5Uq5tOnj/iNnL9PI0tUqxXXxDw97ObBUC2i3PI9UuSIgllZiCiWyT0//rk7nEBxMQTDgGIFpddiPL5pIggibpEtpKxduxbLli2LEFEAICsrC8XFxRg+fDieeOIJFAiV2SOIJo5dkmHKFXOUPs9YYcTm5TEixO5dwJkzwN//HinkVPOed8UMW64BK5TfJZhvkAffuBcK5ZCiwQ9MnxY5HnLmixECllD/cI1+JQjNNbntVXtudku0y54HdywdYJax7ayvqsJPh+sQgCtsWz9c+PlwHeqrquBKT5c8jjsxCWdrfaitNbhyj54XupK3/UIYlbNFCiV5H9QYhXyxSkhUCfiBDeuZkB85IVFGhlioEde8XuDMaQhWwSnIZ7xl7OLBILfv5IhVbdoA4wuB0rdC4zZqJPOdUD/6Gz2eAOXeWnYSJORei/GWI4YgiLhHtpDyyy+/4NJLLxX9vmfPnnA6nXjiiSd0aRhBxBtWJcMUKv4QTcxR6zljthEbkeukAOjWTdq+i+bJAkSOi1hVH6cj8jlfKneLGELjITVf2ONkZ+svYLH9w/WoCQSYCklKnmnFhKAVK5j/5bTXjh4mauCW6gaAHF7VnuT0dAyZPR7vTG8IE1OcaMB1s8cjOYqIAgApiUyeFJ/vvK5tF0SvC13u234xjPS0EENppRc1RiF34qckA49MQ7g06wiJKEB0I9voEAslF2pYWJQDQTGFbVNeHhNyZJeLXm7fyZ0Xg68FBuUC/9jAjOGaNcxfvifV6VON3igcjCzHbTV6hfkRBEGYiGwhxePx4NChQ7jgggsEvz948CDatm2rW8MIIt6wIo8IX2gYNTq6mKOX54zRL8QEc52sZoz0aMdjn1c/+wxY8Vrk93wPDDFxZPp0YNCg8GXRcrfwjyM2HmLzZd8+YO7ccJGrTx9G7NCLPn0AhyO0zwCUzwEpIahXr/D9mFXt1Eo8nsi5wuWCi9vg3luOYtXfM+GHC040YPwtlbjg4mxZ+3c3CilhHil2eisthFZPCSuSWUZ4jMio9KLGKGQnvtcr/L1SAUlK7NBjnrDbHT0a/plLRFhUo4AybVq4umi3i16OUKRUrJISwthxVzO3Y1WQsEIUJQiC0IhsIWXo0KGYM2cONm3ahCROhQAA8Pl8eOyxxzBs2DDdG0gQ8YLZeUSEhIZ1a6OLOXp4zpiRC0ZrOz0epirPypWR+ykojExbINRvOTnC++WP83XXMWkU2M+33MLkD2yXDTz7jPh49O4NVHwT+m7AACYfI3dMFy9mRA89+1qPOSBXOJQzV/SscmRXXaH6+HG03voE7kEdTqMdWuIXtN6aiOrh8+HOyIi6vbsxh0rQIyUW3kpr9ZSwKpkl17Bu0wrI7hD+vZ5G4dGjiAwUDEAwLEZOpSD+8eXMEzkXjpz9iPVLy5b2Lm2xYQAAZBtJREFUuyD5yBF35HrmyJkfaud2rAoSVOGHIIgYRLaQ8tRTT+HKK69Et27dMGnSJOTk5CAQCGD37t145ZVX4PP5sHr1aiPbShAR2NkwEsLMUAUhY9gfAMaMAdavExdztHrOmJULRg8PH77owYYHjR0jvV40EUxonO++m/m8b19IDHE6gCFDwkWWhx9mwmiEktV+/rlwbpeAzn1tRN8K9dkP+6LPFb1EObskehbCd/IkdsyejerKSmRkZuKGonuws6QE1ZWV2DF7Nq5esCBqeI87ickrUltbbd5baT1uwFpvilbFf7GGtVByXz2NQrF95eczLnhaBCQ580Su0CJnvjUFY1mO4CK3H9TM7VjtY6tEUYIgCA3IFlIuuOACbNu2DQ8//DBmzZqFQOOTu8PhwG9/+1ssXrwYHTt2NKyhBMHHCsNILw9oM54N9h+IXOZyAiNHMP/zn82456bFc8asXDB6efjIfVbt04dJVeBAZI4LsfZx12H/zYblAMzfLVuA4oVMWV/2WXfCBOFktf5AxHvoCPToazP6VqyyEbf9eoaZ2SHRsxgJaWlI69QJANBvPuOB0m/+fOyYPRtpnTohIS0tyh4Ad6OnaPX5s+a8ldbT40XrTdFuoSB6GoVi+8rLAwZHySUS7Qcr2jyRK5DInW8eD6Mc/2tzaNl116lreyyjZH4onduxLEjES1IsgiCaDLKFFADo0qUL/vnPf+LXX3/Fvn37AABdu3ZFuoxEeAShJ1YYRnZ+o83H6wXKSiOX5+eHew6zCJ2b3ISgfMzMBaPXc1e0Z1W9xl5MZPLVhAp+7Nwpnl/F5Qy9iGY9aAKBcDFCa1+z9kufPvLmQDR7R6hvpSobcduvlyhnVaJnubgSE3H5jBmor6oKep64MzJw9YIFSEhLi1r6GABSGoWUWt95499K6+nxotRgjhUDW0+jUGxfUjeuaEKXVOUc7gUoRyCRO9+8XuDjj8OXbdnCuOsJ/SDZOSxNK0aKBrEsSNhNFCUIgpBAkZDC0rp1a/Tr10/vthCEbMw2jOz+RpuPWHLUbt0il0lVV+FX85SD2blgjH7u0nPs5YhMYslq2X7kv4iuqNCvr5UKRmoFJqnKRvkFofbrJcpZkehZKa7ExIgSx3Kq9bA0S2ZCe3zV53V5K11X14Cqqnqkp4dKEZ886UNaWgIS9fJ4UWowx5qBrefNScm+ogldYZVzeHA9ROQKJHLnm5x5E6vJUtVg5I8XCRIEQRCGo0pIIQirMdswsvsbbT5K+seIc4vlF2J8lPSPHO+MaCITuw4rUDgAjB7DhGMJvYjWq6+VCkZaBCapykbduob+zUYCbP5XaJlYJIAU/H53OsIFm3iADe3x1ZxlFmiYGHV1DViw4DscPlyF+fP7ISPDjePHqzF79g506pSGGRM7IFGrx4uQwbxkCdClM9Ctu7z149XA1oqUYAGIiyhAuIeIEkFOznyTI8zYKVlqrHg/EQRBEJZAQgoRk5jt9RALb7S5KOkfo87Nbi/E1D4T61l9BlBu3zocwAXtpdfTo6+VCmpaBDiPh6mMtGpV+HJ+v0aLBFAypnl5wNmzQGkp0+6yUqB5qr0dGpTQLDkFAOCrOR9aqHJiVFXV4/DhKlRWMuJJUdFlKCnZicpKJrFqVVILpGvNwyBkMAf8wLTpyiq+2FXNtpLsbIiG7Aj1Ixd+nyq5YUWbb0LCzKiRkW23Q7LUWPN+IgiCIEyHhBQiZjHT68Fs4UYPxPqHb3wKva0fOcratuuNlhwncsZeqXeGlL1hVRiZUkFNqwA3dgyAQHgFI/68kxJrKiqUjanXyxyL3Z0cj5tYehndLIX1SDkfZc3opKcnY/78fpg9ewcqK6sxc+Z2AEBmphvz5/djwn3k3IClOlHIYAaadsUXtfD7uaKCt4Ij/KYl1O/BVQUuYj1VcXbebFgPrFkLrFkDrF0XuoDtkCyVvJ8IgiAIGZCQQsQ0Zno9xGK4Cr9/xAQF9tzWbwDWrWWebdetjY+XcN4T2oWJaGOvZ3iUVWFkUoKRkD2sh7g4diyT70Vs3omJNckpysdUSb/GUmJplmYpjEdKrU+7kAIAGRluFBVdFhRRAKCo6DJkZLhDK2lJdsqNYZNb8cVqA9uO8Pu5sAAoLUO4N4qTuTgApr/YdYTElEAA+PWkdhXR6wX27Gb+ndMjcj9r14XayBcqot1wjVY5yfuJIAiCkAEJKQShALuFqyhBjqfDurWxk1BXLr/8ok6YEPLcEXueT3HrFx5lZRiZkP0iJSroJS5KzTshsaamWvmYyu1XPYQ3Kwgmm9VJSDl+vBolJTvDlpWU7AzmTJFE7hv9vDwmJ8q06fI8TWJRzTYSoX4WEki4IkB5OWcdoWLqgdB4qA1pYWubB/ftACZPDu1HjlAh9mNrRsgNeT9FEmsuegRBECbgtLoBBEGYg9QbeTnfxyrt2jEGNJdowkR5OTBhAjBnLvO3vFx6nenTmKSoLmdo/2pflrPigR77UoPHE6rW9O+twqKC1xu5vtr2RZt3eXlMBan5zzJ/8/KA/Qci9xNtTOX2q5TwZmeapbBCSrXmfZ086QuG9WRmuvGnP/VHZqY7mDPl5Emf9A6iJTvl0q07MzBOF/M5mqeJ1gnH4vUytca5k9lK1LRHLM8MeDc8VgTgCy+CBcgRKYApaRN7jLB9B5hl7H5YoUKojXL2raV9cmBvFnLnZLzD/tjNnSP+g0gQBNEEIY8Ugmgi7N8fuYxrfIq9sT91mnlOlfMMaceXVp42ykJQ5HjuCK2zZQtQvBDw1Wh/WW71i3f2hbKQmaV3mJEcTxHuy2mvl0kUyyc/X17CWW6/Aoztyp2vrPAWK4mlWVLdTGhPXa12ISUtLQGdOqUBQNADhc2Z0qlTGtLSojw6KH2jLzXhjbipaPVq4LYpLdW69oj1c34+sHp1ZAjUzp3C4TzsPoRypygNaRFLZhvg3DjUhmmZGXJj9U3YLlC+GIIgCFFISCGIJgCbaJPPLbeI57xwOgC/Hygulpcnws55JZQ8E8vJpSG2jq8m5M2hFavCyLxecREF0F9UUJprRajvAaBbN/nHkwpZUiq8CWGFoNjM3eiRUqs9tCcx0YUZMy5HVVU9k1gWTM6UBQuuRlpaAhITXdI7UGMoC014I8I4tBqG/DY9MBEYPsKa9oj1c14ek3yIf8MTE14WFgM1PiAlWX6YlRjuFAiGDPGT2KoRKswOuYnlWF69oHwxBEEQopCQQhBNADHj8913gczMyJwXe/YAC4pD6/kbPbOlKpxYnVcimvEq95lYjodEikiKiMYKtLZCqVG/e4+0iGKEh7sSm0qPHDJS8zU1TdvLaKsExVQ22awOHikAI6akp4cLJqyoIgutb/SNehMuZhh+9hlwzTXREyfx27RsOdBvgLbYNi2Gqlg/i93wRo8C1q0PF166dQ99ryWhLzv5I+4gjRcCfz9KhQo7JBy2o9ulkVC+GIIgCFFISCEIg7DT85aQ8QkICx4ej7Ah7Q8wAsugQZHfWVVphkVP41WOh0SNiK3qq1F3TK2IzTU9++XOcaHqpEYg16ZS6sEihNR87ZqmrD1crBQU3UmN5Y91ElJ0QcsbfaPehIuVXX5tBbBypfRFIpiTRKYIo6Q9Sg1VOf3M9aSBAxgzBhgxkvmOG9+mVgCLyL8C5rwefBC46ip1fSN0Y7My5MaMRLd2ww7iFUEQhE0hIYUgDMBuYS7ssxDXyGPRQ/CwstKMEcZrtGd1O3mkiM01tf3SIyfSMd/pMFZEUSo6arWllM5Xue0zSlCUc3y2ak9tnUVqnt4Y9Sacbxhyieb1okWEkdseIwxVoSSz69YDrVqFKvhwhQE1AphY4tsLLlB3Lu+9B5SWMm3lixZWhNw05VwhlC+GIAhCEKraQxA6I2bAWl0cIi8PWPi8vAo2rDHNxQEgJ0d433IrohiBUdWGpIqD2MUjRWquqe0Xj4epVModSyGvfL2QUyFJrJ1qi7coma9K2scKNFy0Copyj+8OCikSHil2q1QjBTtIRlROYUtBTZgY+Z1YdSGhNnHRUkGGbc+z80OlqfREzLuHWypZawUctZV4uLDz8/XXgdJVCMq5/LbJmcd6zHXuPpRUotKKHa9TLTdcgiCIOIU8UghCZ6wOc5Giezd5YREeD1BYyLwQDCDk6SDVfqteWlnhDWOlBw4XqbmmpY1mjaWVoTByzlFp+/QIO1J7fDa0p7ZOpDRxLIYlGDkRPR4mHGflSmVeL2ybPvuM8UThoiX0yEgvi+xsCCaA1TN0SqtnTVjokQBs2yoqos9jPeY6fx+FBebkConF65QgCKKJQkIKQeiMXYxsMeTYJuXlTJUfVkQpKJT3LGeFx7XexqtdjymE1FzT2kYzxtJq0THaOappn562v5LjS4b2xHJYgpETUa3xHybCcMKDYioJpwNwOPQVBsQmf7TYNKH8KhHNdTJVhaLNYz3mutA+ylYDBQXCZaX1IpavU4IgiCYICSkEoTN2MbKlkLJNhN6Cry4DBv/GXufApU8f4JFpofAjM9pph7DxaHPNDm2Uwu6io9r26WX7Kzl+MNlsfQ0CgQAcDk6MEZUwFUftRRJMPPVyo+Js0ySc+34APtqMyBTiAWD06MgKPlrbz5/8cjwshOYnn1tvBf6zK/o81mOui+2jWzcm9EpsrmjNMC92XLEs7wRBEISlkJBCEAZgdwNWCqu9BJRiZWJfKzxw+ESba2a1UY0NYXfR0er2KTk+65ESCPhRX1+HxMSk0JdUwlQatRdJXh7Qswdw4pQ9b/SLFgH/2iz8ndPFVO0ZMdK4Hyq5HhZiSXwBZvnAgcC77wp/z5/H7hTtc13qehGbK3qE5Ij1Q3ExcP480292KQVIEARBkJBCEEZhByNbDUZ4CRhVClpuDgk7laLWE+559eplXTu0iFl2Fx2tbp/c47MeKQDg850PF1LkhLDE60ViNG08QHYHq1sRyZc7pEUU7vgbNd5yvUOE5md+PtC2LXDmDLBsmbiIwj0PoTwrajxtlIZ86RWSwz9ukEDj/gMQrGJEEARBWAIJKQRBhKH3W3gjPUbkeM98tBlYsUz6+LFoQ9qlxLYeCWPtLjpa3T45x09MSIDL4URDwI/a2moArcJXkFJkKMGl/dByUyovBxYvFv5u+E1MmIwZE1qJJxR/flZUAAsXiof8TJjI5KkRy40CMMdeWAx066687UoUVD1D5/LygGZuxguFC3f/lDuFIAjCFpCQQhBEBHq9hTe6KouY90xyClM9MsUNLFsaKuUsdHy7CBJKsLLaDZ9YCwWLVxwOB1ISEnGuzgef77zwSkKKjN0TXMaiyqkVLcIWO54ROVEaueF6a2LT5Hh2sPPT620UgkTOwekC2qSHLxMSMwJ+oEakipXc9svpK71D53J6iIc6sVCOI4IgCMshIYUgTCSWbAI93sIbbWQLec9cdx0wfRpzXAcAPwCXyPHtJEgowU7ihd6hYLF0jUhhxXmkJDJCCuORIhM7J6K12lPGikHUKmxJJW69/gZ13hlaUKPKb1gPURHF4QT8fsZjgzsnrMwDpLb6k5L9+f0I6xPKcUQQBGE5JKQQhEnEoueDVsyoysJ9Tk9OCYkogPCjOPf4dhIklGCnajd6hoLFyzVi1Xm4G/OiKBJS7JqI1mpPGatEHK3ClmDCUgfw2Fzgqn66NlU2SlR5rxdYu07gCwfw0EPAq68ieGfnzwk9xQylKBWMool0QqFOVp1bUyJelHyCIEyBhBSCMIFY9XzQillVT9jn9J07I4URICQ68I+vRZAw4nlL7j6DlVc5xrqe/ar03OTYENH2GS/XiJXnwQopoqE9QlhtgIphpaeMlSKOVmFLbDytElGUIuZRM2Y00L49IuRx7pywOjO0mGDk9QI//wy0SgWaN2NEuldeiS7Scfdn9bk1Baz2gCMIIuYgIYUgTMAszwc7vkwx8/lPUBhxAAufB3w1kcdXK/QY4XFgF28Mte2QeuksZ5+x6h3Ex8rzYCv3+HwKPFIA7RepETceKz1lrBRxpIQtuf0cy0a32LiPGMn8O9qcsDozNJ+gcd4AoAG4bSzwzgaIetVIYbdziyes9oAjCCImISGFIEzAjDwSdjHEhTDr+U9IGJlwP9C9m/g2ajyyhTwOOncBaqrV2ZJKvRiM8noQ2u+SJYC7GdAjR92+5bbVTuFKWrDyPFLUeKSwqL1IjXqLa6WnjNXhTkI3JaX9HKtGd7Rxt6P3lBgRlYT8wDvvAkhEKAU67JOTqClj51xRBEHYFhJSCMIElHo+SL14FBJM+vSJjbAIuS9Utbzg5tsgqWnRt1Fic4h5HEx7hHnHqEbEUurFYJTXg9B+/QEmr6NacU5uW80KAzMaK8+jWZIGIUUNRr/Ftcqzwg7hTtybUlN7Wy417rHkbSMYpuQH4ETUxLF2dC+NZ6wWTwmCiElISCEIk5D7/CflWSL2dv+RadGNVaufy+R6zOjhWcO1Qao1VL8UQsjjAAg9FqsRsZR6MRjl9SB2boB6cU5JW2PJRpLCqvMIhvacP2vOAc14i2uVZ4XZg8i9QQPhN+um+LZcatxjxdtGMPGvEygsAFa/Li7SUa4O87GDeEoQRMxBQgpBmEi0579oYRBib/cdkDZWrQ77kRveoXfIitcL/HgYuLCTvnYd1+NACKXeIWq8GEaNBtav09frIdq5qfF6UXpudrSR1IiQVpxHSlIyAMBXY5JHSry/xTVrELmGczDkIxAyovv0ib9+tlrZ14qc9ocZ5/WAwwUU3gOMHgsMvlZYpGtq3kd2Il6UfIIgTMNpdQOUsmTJEnTu3BkpKSno378/duzYIbn+O++8g5ycHKSkpKBXr1744IMPwr4PBAJ4/PHH0a5dO7jdbuTm5mLfvn1h65w8eRJ33XUXWrRogVatWmHChAk4e9akN35Ek0IqDAIIvd3n4nICOTnM85rLGVrGzU8oJE54vcaeC5do5xVtvT17lB+zvByYMAF4ch7zt7xc+T7EyMtjvIDEUOMdkpcHrFgBzH+W+SsmdLHntWYN4PcDY8ZIry+F18tUOuLOBbYdMx4VnmtqbDe552ZH2P6eM1f/eaQ3qckmCymsoeh0MZ+F3uIKTTK9MHLfZhGRRyOAiESkQPR+jiXYi2ruHPtfVEIoaT9783tmPvDSS4yAAjBj16tX5BhKeR8RxiM2LgRBEALElEfK22+/jalTp2Lp0qXo378/Fi1ahKFDh2Lv3r1o27ZtxPqff/457rzzTjz33HO4+eab8cYbb2D06NGoqKhAz549AQDFxcV46aWXUFZWhi5duuCxxx7D0KFDsWvXLqSkpAAA7rrrLvzyyy/YtGkT6urqMH78eNx///144403TD1/Iv7ZfyByGdd4lXq7L/YyxQ7VUOSGd4iFlhQXA+fPyzfAxZKm6vlSr0eOcFu1eIco9VgKgPFKGTlC+bGkvJQ8HmDQIKbP1eT6EHpZq+fLfS0vs5VsG2slmVOSG0N7as6Zd1Cpt7hGhijES/iDWLlfFtaIjpe35bHucaGm/R4P0KYNcO4UEK2iVrx7eREEQcQRMSWkvPjii7jvvvswfvx4AMDSpUvx/vvvY+XKlZg5c2bE+n/+858xbNgwTJ8+HQDw9NNPY9OmTVi8eDGWLl2KQCCARYsWYe7cuRg1ahQAYPXq1cjMzMTatWsxbtw47N69Gxs3bsSXX36JK6+8EgDw8ssvY/jw4Xj++eeRzcYzyyAQCCAQEEg+QCgiXvvR6wVKV4WloAMA3HMP8wzGnvJvfwtccUX48zT7XZs2zP9AaFm7doyzOPdR3eUAsrJC6xhNmzaMEf7KK0BDgDn+Qw+Fn5fQeiwBMM+uV1wh71n7559D2wca/2sIAOvWA/eON+acnGDCbUaOCB8TPeGeF0u9n7HF2HGXg9cLLF4cmhMNAeH+lZprYoJEUKAB0yd627da9i9nW+79Ra/+NotmKaxHyjlz75FCNx52krGzLNCg7CKWwsh9K0Tw90iJWteuHSLv0BwcrtDNWqifY42ff24sBczBX2/fi4qPyvaz8yTq8wv3hyXQwIy/0I8l0SQQmy/x+AxMELFIzAgptbW1+PrrrzFr1qzgMqfTidzcXGzbtk1wm23btmHq1Klhy4YOHYq1a9cCAA4ePIhjx44hNzc3+H3Lli3Rv39/bNu2DePGjcO2bdvQqlWroIgCALm5uXA6ndi+fTvGjBkTcVyfzwefL5Th8syZMwCAU+fPw5+YqPzkiTCqfT746uutbobu7P0REMqLmtUBOMV7wZzgBjpcyPyb/x2fBDdQMBF47bWQiDF+ArM82rZ60u8a4KIcoLISyMxknguFjt/vGqDBBfz5pfDldQHgh4NMu6OR2gqoByPA+OGDH8x8+fs64Nob9HteFzonwLh+TW0FNCBSFGvWUtkxheaaWP8KzbV//YvxVmcFiYkTgeuvB06cABYtCW/fn19h+kiPPteyf7nbcu8vevW3WTidTGzf2bOncO7cKWsb8+NeRMyyQB1w8AfArfHRw8h9K8Tnq0Z9Pact7MXBXh3sxSGGOwGYWMDcoAMNYESVRmHF4QImjGfWsXo89aJVKiKuKocLaNksNs5RZfsDgQDOnTuN2tpqJCe74XA4RNfFNf2AnIvCf1hioW/swIkTwLFjjPgYC8JcFCLuL41UV5+xoDUEQfCJGSHF6/WioaEBmZmZYcszMzOxRySBwrFjxwTXP3bsWPB7dpnUOvywoYSEBKSnpwfX4fPcc89h3rx5EctramuR6BMylQkl1NTWWt0EQ2iZzvzl5fdHi9baK88MuAbo3gP43/+Atm2BNunh+zxxkvPMlq7tWFI0aw50ac4c7+tvI4/HtqNFK+az2r5o1hz47TBg40agAaH54g8Ah39ivtcL9pwA/SsECR0rfzzjucSKGPcUMsuFji02rlrm2omTwPIVoW39YD5378Eciy9x6tnnh/6rfv9yt+XeX5T2t9UkJjA5NHw1Z+GLFkJgNOktG//Bm2WtW0QPb7By3wqpra0JfTh5AlixHGFXx4rlQI/uQLqEUXfNAGYd9gYNhP6d3sb0czKU5s2A8fnAqlIEr6rCe5jlsXCeKtsfCARQW1uN2loffL5qaSGFPU7zLsy/Y6Ff7MCnn4SPy/jCUE6aGCXs/sKhrk54OUEQ5hIzQkosMWvWrDBPmDNnzqBDhw7IatUKLVq1sq5hcUK1zwd3Y1JFvbGykEC7dGDqpPDwl4cfBrJaAUd/0t6mdukAukYuNzoUQ+7x+MuHDQG2bAnvi54C7RejcyaQDKABPrjAzBeXA7isO+BJj92iEeNGA7mDFJTRRuS4is01Of17/CdAyK8uUA1cfjHgRqQHB9vnWknUsH+52/LvL3L72w5ktm4NgDHa0tMtzqmQ3g6YNDU8ROHhh4GuPe29b4X4fIyHAQDgp+MQvDqqA0ybpUhvF35/5l+LsXrDEqJZOoAkMD6DDuaz1fNVCaPHAYNyFd0UAoEAkpPd8PmqkZ7eLrqQQijD6wVWvYmw66/0LWacYvh6Cbu/cDh9OtWC1hAEwSdmhBSPxwOXy4XKysqw5ZWVlcjKyhLcJisrS3J99m9lZSXacRJ5VVZWonfv3sF1/ve//4Xto76+HidPnhQ9bnJyMpIFDH2Hw0E/njpgVD9aXSIYAIYOBfr2DT2fVVQwnuFGtcnrbbRFwDiTBwC8+irTBiOePcSO1+XCyOWffAIsfB7w1Sg3YL1eYPVq1kme+Q8ACgqBjAxrx1oPeygjg/lf6hjRxpU/16IluWXb3L49I0DwEwez5zN5cmSCWqm2KiEjQ/3+5W4rdH+J1t92IdXNJEivrZXxxtsMlEwyO+1bAWHzpZmbEXX4iUKzswEt4xEviXWB0M0JQLDUs5E/Okah4qbAzpWwORNPApmV/PILQr94jQT8TJhPLNy8RRB73rXF/Z0giNgRUpKSktC3b19s3rwZo0ePBgD4/X5s3rwZkydPFtxmwIAB2Lx5M6ZMmRJctmnTJgwYMAAA0KVLF2RlZWHz5s1B4eTMmTPYvn07HnrooeA+Tp06ha+//hp9+/YFAPzrX/+C3+9H//79jTlZwnTsVJ2DrW5iRpvMrugjdrzdu4SX+2qYSoR6HAcAunW1dqyVCjhqn7HljqucSjpCbRarHAVoKy4i53y17D9eCp+IwRVSbIOe5ZrM3LdSuGIHix5limO9yg0fqfK+sXg+WogngcxqqNoRQRAWEDNCCgBMnToVBQUFuPLKK9GvXz8sWrQI586dC1bxyc/PR/v27fHcc88BAP74xz/i2muvxQsvvICbbroJb731Fr766issX74cAKPoTpkyBc888wy6desWLH+cnZ0dFGt69OiBYcOG4b777sPSpUtRV1eHyZMnY9y4cYoq9hD2xg4lgs1oE99QlVuWWC/EjtfjksjlTgdw6jTTZqXnK3VeVo21UgFHi9eMXuMq1uYVK5j/xQQJNfatkvPVYj/byfbWm2DVntrzFrekicEXOwDGqFtYDHTrrm3f8SY8kMHLEG8CmdV4PCGF39+gj4hJEAQRBafVDVDCHXfcgeeffx6PP/44evfujW+//RYbN24MJos9cuQIfvnll+D6AwcOxBtvvIHly5fj8ssvx7vvvou1a9eiZ89QHPWjjz6K3//+97j//vtx1VVX4ezZs9i4cSNSUlKC6/z1r39FTk4ObrjhBgwfPhyDBg0KijGEcXi9wM6dzF+jYQ1PLkYKCnLQu03l5cCECcCcuczf8vLQs4fLGdq/kc8eQsfLLwBqqpmwG3a5A0ylx+LiUFu1Hoc9r+zsMOdfAEw/Gz3WUgIOHzEBQ+61oNe4RhOdWGFKyzXq9QL/3tpYjlnl+RIMzRpDSsUSFBIGISR2BPxAjQ4ZiVnhgYuewoOWH1o127I3JyeTGLnJGrxSAhmhjrw8RuF/dj7zl7x7CIIwmJjySAGAyZMni4bybNmyJWLZbbfdhttuu010fw6HA0899RSeeuop0XXS09PxxhtvKG4roR6zc1hwX2YIhStYgZ5tkvKGMDvcgXu8ffuAstLQOBcUMIUqFi7UHnrDHufgEaBLR+ltAwJhQHqjxEtED68ZPcZVqs16XKPcffCx2iMsFnEnJQGwWWhPNOIhR4SRXhZSb9q19p2W0BIt28Z7jJ0cyDPHGOLZ5ZAgCNsRc0IKEf9YlcPCjs92erUpmmGu5NlDD7uH3W7u3PBxXr0aeGSafqE3Hg+Qmga4Obmfjx5lUtJxCcB4o12JMKZXaI7WZ0qxNgPar1H+dc7Hao+wWCQopNTHiEdKvOSIMDqsQOiHICwniwMYMxoYMVL5BagmtESPsJSmbvBSKApBEETMQ0IKYTuszFdix2c7Pdqkl2Gup6eQ2Dg7YGzeFrPzwnCRK4zZyUNKqM07d2q/RsUSAgP28AiLRYKhPXUxIKTEW44Io5V47g+B18vEwgUl4QCwZg2wdp38m7La3CteL7B1a3zlbbEKO769IQiCIGRDQgphO6w0dOMVPQxzvT2FxMY5Jye8rU4Hk0dFr2dMq0UKucKYnZ6x+W3W4xoV28e0acwcIJtCOaxHii8WhJR4S6IKmKfEb1iPSL86KBOj1ISWCFUmkrstIYwd394QBEEQsoipZLNE08DsBKhyMTP5rRGwedjmP6suD5uSZKlykBrnvDwgP5/xTvEHmDwqShPOSqG0L6wae4+HKf+sVPAyuq1SYyf3+GL7GDTI+ms9VmE9UurqdUhyajRGJ1GNV7xexvNEDLkJS5UmfRWqTMQiZ1sjb0qx/uNMEARBxCTkkULYEju9jQfUhbTolUNRz1yMWl5+GeEpJDbOXi9QVhZ652pEnhy5fWFU4mMjcmzq2dZo7ZNK2yD3+Ha7zmMdd6OQ0uCvR319HRISEi1ukQSUI0IdQp48XJSIUUouQLHjTpgIXHON+LZG58GJlzw7fOIhCTNBEEScQ0IKYVvs4vGqJqRFL4PW7OpFUhgVEiM0zmbkyZF6TmW/S3Ebk/jYiHHVM/RKbvv4aRvUHN8u13k8wHqkAEzlHlsLKYB6Ja0pG5lCITksasQouRegWCiQlIhidB6ceMuzwxKv4hBBEEScQUIKQURBqVGvl0FrVfUiKfT0IJCyhYzOkyMlFPC/01vQMWpcxebp+g3AveONb5+VSaIJhqSEBDjgQAAB+Hzn0axZC6ubFB2lSpqYkdlUxBUhT578fKBbN2PduuR6EHHHQSoPDqB9vOIxz068ikMEQRBxCAkpBBEFpUa9XgalXQ1TNR4EfBsnmseDkQlhpYQCIPI7PloFHaPGVWieAsC6tcDIEdqq6chpHyWJth6Hw4GUxERU19XC56s2vwFGixliRubZs42xgBJv8O0qtKhpl1UxcdGOyxe5CguEvVg+/ZRZV6vHhZqEuVoxeh7FozhEEAQRp5CQQhBRUGrU62VQxothyhdNCgqZ5LHRPB70sBW8XuDHw8CFnULbSwkFgYCweMKOgx6CjlHj6vEAo0YzVVC5+APKnsHVtk+t+GVX+zYadm23OyEJ1XW1qK01WUgxIxxBzMgsLUUwo5LQG3wrQyWkJoqWdlkVEyd2XCGRq2w1UFAArF7NjJPDyfz9cGNoOy0eF2bn2TFjHlkhDhEEQRCqICGFIGSgxKjXy5vCSK8MsxDy/uCKKCxiHg9abAX2mbcuACRyvF6iCQVC3xUvBHw1ygUdIRuKHdewfvEDFRXan8lHjgDWrgkvjKpUpNEy7/LygM5dgN27gB6XAN27Sa9vpxxASrBzu1MSE4FqwOc7r//OxUQBs8IRhIxMoXwh3Df4VoZK8AzvuocmoarftUhPTw6262QgBWnwITHQENshHGIiV7duTGm0PXuA4mLhbbV4XJjlnWPWPKIkzARBEDEDCSkEIRMlRr1ez3axXtVEyPvDH2DKGmsx9qMRLc+HlFAwZAiw+V+hfV13XXRBQAgpY7tPH8b7hSUAfZ7JPR5g8mTt4pvaeadEYLBjDiA52L3dzRKTAEB/jxSpt/FmhSMIGZkF+UBpmfgbfKtCJXiGd13AgQWvHMDhvyVi/oKrkfHLURwPNMNsjEEnnMAMfIhEo9tlpBuVlCeFxwO0aIHwuz4i11OLGd45Zs6jWP/hJwiCaCKQkEIQBqHXs10sVzXJzhYWTfLzGW9vvrEv9cJbyfN/tDwfUmWXP/44fLstW4C779Y3UfDRo5EmRbQExnLPX69ncKXzTqnAYNccQNGwe7tTGoUUXT1Sor2NNzMcQWiCpzYXf4NvVagEz/CuQjIOow0qvT7Mnr0DRfd2RAnGoBItgt+nO33GtcvosJRonhRi1YZixePC7HkUyz/8BEEQTQQSUgiCMIyKivDPDjDPzHl5wODB4baQmDeDmjAKOXk+hJ5TzUoUrCQPiZrzt+IZXGnfxWoOILu3251kgEdKtLfxZocj8Ce4lHpoVagEz/BOx3nMd6zD7DYTUVlZjZnP7QXQApk4g/lYw4goRrXLrLAUJePgcAKjRwEjRsaGYCA0j0aNZL6za8IkgiAIwlBISCEIwhCCz+6cZU5nqDoO1xYS82bo3EVdGIXaPB9mJQoWal9+PvMszn4P2D+MhIvSvovVHEB2bzcrpNRUn9Nvp3LexlsdjiClHlrRNgHDO+PhAhRd0BszZ24PrlY06ypkNO9hbLvMDEux2zjoCdv+DeuBNWuZzN5r1jZ+GTA/kTFBEARhKSSkEARhCEo8FMTW3b1LvYcI+8x78AjQpaO8Z3YzEwVzbYp9+0NJeLleJ3YPI+Gipu9i1a6yc7tZIcVXo2Noj1yvDjuHI1jRNt5EOR5IRcnsHWGrlKw8gvnz+yHD41a2byVeEEaGpSj1xjB7HIzwFlm7DqFXBNxkVyYmMiYIgiAsh4QUgiAMQYmHgti6PS7R5iHi8QCpaYA7WX67zUwUzC6bO1fY68TuYSR81PSdnW1vKeza7mbJzGT36emRAthbPdILI4zuxoly8qQPs2d8gcrKamRmulFUdBlKSnaisrIas2fvwIIFVzPVfOSgNN+JUeFNVpaVloMR7RPy7uHCevqw61K4D0EQRNzitLoBBEHYC68X2LmT+asF9tnd1XiXkfJQEFu3ezf5+9ATjwfo1Uv7ceTsJ5rXiRXnz6JmLujVd4Q6Qh4pOgspQHwPbnk5MGECMHcO87e8XNfdp6UloFOnNGRmujF/fj9ccklrzJ/fD5mZbnTqlIa0NJnvtcTynUS7SPPymDLEz85n/moVFNS2wyyMah/r3SOG0wXs22foXCIIgiDsAXmkEAQRRE1iUymUvMQWWzfeX4RH8zqx6vz1nguEObhTUgAAtXqG9sQ7JiRjTUx0YcaMy1FVVR/0PMnIcGPBgquRlpaAxESXvB1pyXeipxuVVWWlAXmeQ0a1j+/dAwfgcDDHEirHzc6lK64A3PTITRAEEU/QXZ0gCADGJTZV8uwutq5dwyj0YtRoYP068dwiWs9facRCLCW5jQca6upQX1WF5PT04DLfyZNISEuDKzFR0b6CyWaN8EiJV0wSBRITXUhPDxdMZIfzsFhVzllOOxwmxB3KDdcxsp/46jYQ+rfUXLqwg/ZjEwRBELaBQnsIggAgHWKiJ3qFDsUDbDTBmjWA3w+MGaOP173QMebMle9lLjYXPvuMxk1vGurq8N2CBfhixgxUHz8OAKg+fhxfzJiB7xYsQENdnaL9paYwhnmtjzxSZCMUrmGFOCEH1iPC2SjIKM13onfsJhyhZYFAZM17PVESrqO1n6LBDXPj/juW5hJBEAShCfJIIQgCgDmJTSlcJATf6yMAxitl5AjjjiHXs0RoLgDAiteAlSub9rjpTX1VFaoOH0Z1ZSV2zJ6Ny4qKsLOkBNWVlcHvXRxPlWg0awzt8ZGQIh+jkrEahdp4P72Tr/bp0xjWwqlgY6TrmlLPIZuUvQ7OpXOnjD8+QRAEYRokpBBEE4Yf8qFH6V+pY1G4SAgzShurPQZ/LnBp6uOmN8np6eg3fz52zJ6N6spKbJ85EwDgzsxEv/nzw8J95NCs0SPF56vWva1xTawlY1Ia72dEHhiz86TIDdfh/7BZXPYaHg9HbCIIgiDiBRJSCKKJIuYdotWWEMvHocaoN6IaqV0wwwNIyzHYufDZZ4wnChe9BZ+mjjsjA5cVFQVFFAC4rKgI7owMxftKdTcmm60lIUUx8ZyMyQjRw+x8LXI8h+xSkjme5xJBEAQBgHKkEESTRMw7xOvVVuFUKh8Ha9RzkTLq1eT2iCXMKG2s9RgeD3DNNcrGjVBO9fHj2FlSErZsZ0lJMGeKEtzJlCOFEMCI3B1G5yERQqqMs91LMhMEQRBxBXmkEEQTxIiwkmihO0pCh8wIAzLK20XJfrV6AMk5ltZj6BnyFc8eRmrxnTwZDOtxZ2aG5UjZMXs2rl6wQFF4T/NmjTlS6sgjheBgVB4Yq/KQCB3HypLMBEEQRJODhBSCaIIYEVYiR5yR+8xtdP4Qo5LeqtmvWg9wJcfS6mUuNG5KRRFKNCxMQloa0jp1AgD0mz8f7oyMYM6UtE6dkJCWpmh/bPljCu0hIjBK9LBLGItdSkMTBEEQTQISUgiiCWJEYlm54oycZ24j84eIebt07gLUVKv3ljAzma4ViXu546ZUFKFEw+K4EhNx+YwZqK+qCnqeuDMycPWCBUhIS4MrMVHR/pqxoT11Nbq3lYgD7CJ6GEGsVV8iCIIgYhoSUgiiiaL3y0k9xRkjKwiJebtMn6bNW8KMKjxWHIuPGlHEyvbGAq7ExIgSx0qr9bCwHik+8kghmiKxVn2JIAiCiFlISCGIJoRQVUg9nzP1fIY16nlYyNsF0O4tYUYVHiuOxUeNKGJle5sabLLZOjt4pFBSHH2wYz/q0SajziuevW5iCTvOW4IgCB0hIYUgmghm5ajQ8xnWiOdhvreLkKiixFuC+6xolBdNtHMw8lh81IgiVra3qREM7an3WdsQu5ShFSKWDDw79qMebbLTecXSfIgV7DS+YtC4EwShERJSCKIJQDkqwuF6uySnhMJ6WOR6SwiJUytWmONVbpUHu1pRhDzuzSEY2mNl1R6xMrR2uOHEgoHHYsd+1KNNdjqvWJoPsYKdxlcMGneCIHTAaXUDCIIwHqlwDCm8XmDnTuZvvOHxAL16Ad27Mc9Qrsa7oVxhQEycApj9mlUFVOmx9BjTvDxGMJr/LPNX7vOnmvYaQTzPa9YjpcFfj4aGemsaIVWG1krEDDw7TgSvF9i61X79qMfY2mV+xNJ8iCXsMr5i0LgTBKET5JFCEE0ANeEYTalcrRpviVhMoKrnmMZqGoJ4n9esRwoA+HzVaNZMWflkXbBrGVopA89Ok5n7tpyP1f2ox9jaZX7EynyINewyvmLQuBMEoRPkkUIQTQA2HEOu14WYt0U8v7BR6i3BilNc7JxAtSmOKZ+m0AcpHCGl1qrKPewNx+liPtulDC1r4HGxk4EHRL4t52KHftRjbO0yP4Tmg8MJpCSb2454wy7jK0Ys3AcIgogJyCOFIJoISrwuYtHbwmxiLYEqjWnT6AOHw4GUhETU1NdZJ6QA9kyKw71o/Q32M/AA4bflADBhInDNNfq3VU3CTT3G1g7zgz8fAKbvp02PP1c1s7HD+IoRC/cBgiBiAhJSCKIJITccg8rVysPOz4p8jBjTWCt60FTmNSuk+HznrW2InvFfek02u1+0YmERRogoWhJu6jG2dogPzMsDunRmxBM7J0eNRewwvmLY/T5AEERMQKE9BEFEIBQKlF/A2DHxFAahB3ZJoBoNpeFd0SgvByZMAObMZf6Wl+vXVqPQuw/sijuRCe+x1CNFT9jJNneOPpPNzhetkWER3CzLsZZw08gM0dU19k6OShiDne8DBEHEBOSRQhCEINwXNvv2AWWl8ZugM9ZQ+3Jer5dwsVxOuym8iGSFFMs9UvQgFkqp6o0Rk5TvfTJ6VOwk3DS6VK3dk6MSBEEQtoQ8UgiCEMXjYZ4ly8riO0FnLPHee8C996r3BNHjJZzactp2Id5fRLKVe3y+OPBIsXspVaPQc5IKiVHr1gPgZcu2o3hghueM3ZOjEgRBELaEPFIIgpBEzwSdsZZTw268twZYVRr6bJUnSFPJNRKrpMSTRwp5C2hHTIwaM4YRVOyccNOsUrVNwVWNIAiC0BUSUgiCkEQvo5n1zqbwIHV4vUx4FR8rqs7EWsWipgbrkRIXOVKowoZ2xMSoESOZ/+0sHpgppNk5OSpBEARhO0hIIQhCEj2M5ljOqWEXhDyDAEaUsuLlPL3AtS/NkpMBADXnz1ncEp2gyaaNaGKUnfuThDSCIAjCppCQQhBE1JAbrXaMnuFBdsXosCUhzyAAKCiwrg/pBa49SUlMBAD4qs9a3BIdocmmDSvEqKZSspogCIJokpCQQhBNHLkhN1rsGCXhQbGYR8WMsCW+Z5DTARQUAmPH6HscIvZhPVKi5kiJxYuNUI+ZYpTelXZISCMIgiBsBgkpBNGEMSvkRm54UCzmUTEzbIlezBJyCAopNRKhPUaXlI1nuAJUWqrVrbEfTbFkNUEQBNHkiJnyxydPnsRdd92FFi1aoFWrVpgwYQLOnpV2W66pqcGkSZPQpk0bNG/eHLfccgsqKyvD1jly5AhuuukmNGvWDG3btsX06dNRX18f/P69997Db3/7W2RkZKBFixYYMGAAPvzwQ0POkSDMxswytnl5wIoVwPxnmb98m01MkLB7mWWzSwHHe+leQjvuRiGltkbEI8WMkrLxSnk5U3d87hzm7+aPrG6R/WiqJasJgiCIJkXMCCl33XUX/vOf/2DTpk34xz/+gU8//RT333+/5DZFRUXYsGED3nnnHXzyySc4evQoxo4dG/y+oaEBN910E2pra/H555+jrKwMpaWlePzxx4PrfPrpp/jtb3+LDz74AF9//TWGDBmCESNG4JtvvjHsXAnCLNiQGy5GlrGVEgHMFiT0wuw+JMzH6wV27owdnaFZSmOyWTGPFDJ01SEkQC1bHjsTwyzYSjtcqGQ1QRAEEWfEhJCye/dubNy4EStWrED//v0xaNAgvPzyy3jrrbdw9OhRwW1Onz6N1157DS+++CKuv/569O3bF6tWrcLnn3+OL774AgBQXl6OXbt24S9/+Qt69+6NG2+8EU8//TSWLFmC2tpaAMCiRYvw6KOP4qqrrkK3bt0wf/58dOvWDRs2bDDt/AnCKNiQG1fjncDKMraxKkjYqQ8J/WEdEObMZf6Wl1vdouiwoT2i5Y/J0FWHkAAVIAEqAvam6HQxn6nSTjixpswSBEEQgsREjpRt27ahVatWuPLKK4PLcnNz4XQ6sX37dowZE5lt8euvv0ZdXR1yc3ODy3JyctCxY0ds27YNV199NbZt24ZevXohMzMzuM7QoUPx0EMP4T//+Q+uuOKKiP36/X5UVVUhPT1dtL0+nw8+ny/4+cyZM4rPmSDMxO8P/2sFepRZtgq9c5dQDlB7EKtlu5ulpAAAamtEhBQqKasOVoDiiikOEqAEoYROwnz6CbDqTQAByk1EEAQR48SEkHLs2DG0bds2bFlCQgLS09Nx7Ngx0W2SkpLQqlWrsOWZmZnBbY4dOxYmorDfs98J8fzzz+Ps2bO4/fbbRdv73HPPYd68eRHLq30+JHIEFkId1dSHuuE9Aby0GODqJy8vAXr0BDxtzG/Pb65ljn3sGJCVxbShWuNw6zlfvCc4dgGvf1LTgK5p7DHVH+OjzcCypcyYOAE88CCQe4N+7SSk4c6XHw8DdQLhZgePMONtVxITGU+A6uoq+HwiYsq1vwF69ghdbG08gNi6BENaKvDARCacJ9AAOFzwTShgllPfRZKWCqR1Zf7dxPsnEAjA98tPqF31GnxIhAMOZg4teZm5DtuQ0EREInb/FvU2JAjCVCwVUmbOnIkFCxZIrrN7926TWhOdN954A/PmzcO6desihB0us2bNwtSpU4Ofz5w5gw4dOsCdnBxMAkhog/pRH371Ag4ALu7CAHDqBNAh25o2dcjW/9h6zBczKgp5vcCKZeFj8tpyYEA/+S90Y7Hykd1g58uFnYBEgbLdXToCbhvfglqlNQcA1DfUIjnZLb5idgfmf0I+w0cA/QaElMq0VOk+JggwQkr9ydMAHEiGixFSACAA4MQpug4JUYTuL0lJdRa0hCAIPpYKKY888ggKCwsl17nwwguRlZWF//3vf2HL6+vrcfLkSWRlZQlul5WVhdraWpw6dSrMK6WysjK4TVZWFnbs2BG2HVvVh7/ft956CxMnTsQ777wTFi4kRHJyMpLJ0CdiADYvCd9Q1NNT3agwFTPDX8wK8ZBKuCvnOLEaimJXYjXcLNXNhPb4akWq9hDa8HhCk6CJe1oQCsjKQkRqQspNRBAEEbNYKqRkZGQgIyMj6noDBgzAqVOn8PXXX6Nv374AgH/961/w+/3o37+/4DZ9+/ZFYmIiNm/ejFtuuQUAsHfvXhw5cgQDBgwI7vfZZ5/F//73v6CHyaZNm9CiRQtccsklwX29+eabuPfee/HWW2/hpptu0nTOBGEnjDYUjfKOMNvrQqvAIZfsbMYbhXsoB+Q/Z5vVzqZELKZ6CCWbrbG4JQRBBGnTBhhfCJS+xeTZodxEBEEQMU1M5Ejp0aMHhg0bhvvuuw9Lly5FXV0dJk+ejHHjxiE7m4kB+Pnnn3HDDTdg9erV6NevH1q2bIkJEyZg6tSpSE9PR4sWLfD73/8eAwYMwNVXXw0AyMvLwyWXXIJ77rkHxcXFOHbsGObOnYtJkyYFPUreeOMNFBQU4M9//jP69+8fzJ3idrvRsmVLazqEIHTEKEPRKO8IM70uWK+XFLfxnjsAcPLXyGUOR+QyMczwMGqKcB0QYgF3UhIAiqMnCNsx+FpgUC6TmyhWlFmCIAhCkJgofwwAf/3rX5GTk4MbbrgBw4cPx6BBg7B8+fLg93V1ddi7dy/Onw+5MpeUlODmm2/GLbfcgsGDByMrKwvvvfde8HuXy4V//OMfcLlcGDBgAO6++27k5+fjqaeeCq6zfPly1NfXY9KkSWjXrl3w/z/+8Y/mnDhBmIDHA/TqZV6Yih33y4db9nb6NGDIEGNLHJeXA9MeCfdGAZhzlXtuVIqZADhCSh15pBCE7TDiB5cgCIIwnZjwSAGA9PR0vPHGG6Lfd+7cGYFAuAmSkpKCJUuWYMmSJaLbderUCR988IHo91u2bFHcVoJQSjyWuzXKO8KsvC58r5ctW4DihYCvRv8Xiezx+CIKoPzcYjEUhdCXYGgPCSkEQRAEQRCGEDMeKQQRr3A9HyZMYD7HA0Z5R5jhdSHm9eKrMeZFotDxAEYwUnNu9MKzacN6pPjqKLSHIAiCIAjCCGLGI4Ug4pF4r7JilHeE0V4XZucaETqe0wEsfB7o3s2YYxLxC+uRUlfvs7glBEEQBEEQ8Ql5pBCEhZiV78NKtHpHeL3Azp3MXz33K4XZuUaEjjdpEokohDrcrJDSUIuGhgaLWxOjiN14CIIgCIIgQB4pBGEpVGVFGrPLHHMxO9eImuPFY24dQjusRwoA1NXVwOVKtbA1MQh74wn4AYfT3BsPQRAEQRAxAXmkEISFUJUVccTCnvR6QSznhbPZuUaUHC9ec+sQ2klJTAz+2+c7L7EmEUEw87Of+Rzw63vjIQiCIAgiLiCPFIKwGKqyIoxU2JPWPrLS00UP4j23DqENp9OJZFcCfA31qK2lhLOKOHo0JKKw+Bv0ufEQBEEQBBE3kEcKQdgAqrISCRv2xEWPsCejPV3MoCnk1iG0kZLYWLnHR0KKIrKzmXAeLk4XxVsSBEEQBBEGCSkEQdgSo8Ke4kGEMEpkIuIHdwIT3kOhPQphbzxOF/PZ6aJ4SztBSYAJgiAIm0ChPQRB2BYjwp7iIcEva+u98gojAlFuHYKPO4nxSKHQHhVQvKU9oSTABEEQhI0gIYUgCFvj8ehrx5ghQphRTYdsPUKKUGgPeaSoQu8bD6ENsSTAlBiKIAiCsAgSUgiCaHIYKUKYmciWbD1CjGbkkULEE5QEmCAIgrAZlCOFIIgmidoEv1Ih+vGQyJaID8gjhYgrKAkwQRAEYTNISCGIGIVy7plPeTkwYQIwZy7zt7w8/Pt4SGRLxAdsjpSa6nMWt4QgdICSABMEQRA2g0J7CCIGMTN8hGAQ8zbhhujHQyJbIj5wJycDAGpryCOFiBMoMRRBEARhI8gjhSBiDAofsQY53iZGlWwmCKWEPFLOWtwSgtARtTGZBEEQBKEz5JFCEDGGlEFPz5bGIdfbhF6aEnYglTxSCIIgCIIgDIM8UggixmANei4UPmI8SrxN6KUpYTVsaE9NDeVIIQiCIAiC0BvySCGIGIM16F95hfFEofAR8yBvEyJWaJZCHikEQRAEQRBGQUIKQcQgZNBbh8dD/U3Yn2aNHilU/pggCIIgCEJ/SEghiBiFDHrCrni9TC6f7Gyao1bhZj1SaqstbglBEARBEET8QUIKQRAEoRt6lOYmIUY7qe4UAIDPR0IKQRAEQRCE3pCQQhAEQeiCWGnuPn3kCyJ6CDEE0CyFEVJqKbSHIAiCIAhCd6hqD0EQBKELUqW55SAmxHi9+razKdC8WaOQUkceKQRBEARBEHpDQgpBEAShC1pLc2sVYogQ7qQkAICPcqQQdsTrBXbuJJWUIAiCiFlISCEIgiB0gS3N7Wr8ZVFamlurEEOEYIUUSjZL2I7ycmDCBGDuHOZvebnVLSIIgiAIxVCOFIIgCEI3tJTmZoWYV15hPFGUCjFECLb8cW1djcUtIQgObPxewM98DviVJ1IiCIIgCBtAQgpBEAShK1pKc2sRYogQ7kYhxUdCCmEnjh4NiSgs/gbmgqeLnSAIgoghSEghCIIgbIUWIYZgYD1S6khIUQbV3jaW7GzA4QwXU5wuit8jCIIgYg7KkUIQBEEQcUYw2Ww9CSmyodwdxsPG7zldzGeni+L3CIIgiJiEPFIIgiAIIs4IeqTU++D3++F00nsTSSh3h3lQ/B5BEAQRB5CQQhAEYSMosoDQA9YjBWDCe5KTm1nYmhiAcneYC8XvEQRBEDEOCSkEQRA2obyceSnuDzBlgCdNYl7eEoRSuEKKz1dNQko0KHcHQRAEQRAKIF9fgiAIFXi9wM6dzF+99seKKADz95VX9Ns/0bRwuVxIcjF5KGprqy1uTQxAuTsIgiAIglAAeaQQBKEL3JAUIL7DU4zwHDl6NCSisDT4KbKAUE9KQhJqG6rh8523uimxAeXuIAiCIAhCJiSkEAShGa6w4GhcFkB8hqeIeY5ozUmZnc30F1dMcTkpsoBQjzsxEWd81eSRogTK3UEQBEEQhAwotIcgCE3whYVA4/9AfIanSHmOaIGNLHA13pVdToosILSRkthYApk8UgiCIAiCIHSFPFIIgtCEkLDAJd7CU4z0HKHIAkJP3EEhhTxSCIIgCIIg9IQ8UgiC0AQrLIgRb+EpcjxHtCSi9XiAXr1IRCG0wwoptbXkkUIQBEEQBKEn5JFCEIQmWGHhlVcY7xMHAEejx0a8hqdIeY5QCWPCLqQkkUcKQRAEQRCEEZCQQhCEZvjCAhD/4SlCOSmNSkRLEGpoxgop1ecsbglBEARBEER8QUIKQRC6wBcWmqJwQCWMCTvBeqTUkJBCEARBEAShK5QjhSAIQieE8sXEW44YInZolpwMAKitISGFIAiCIAhCT0hIIQiC0AkqYUzYCVZIqSEhhSAIgiAIQlcotIcgCEJHqIQxYRdCHilUtYcgCIIgCEJPSEghCILQGaFEtARhNu6gRwoJKQRBEARBEHoSM6E9J0+exF133YUWLVqgVatWmDBhAs6ePSu5TU1NDSZNmoQ2bdqgefPmuOWWW1BZWRm2zpEjR3DTTTehWbNmaNu2LaZPn476+nrB/X322WdISEhA79699TotgiAIgjCEZimNHik+ElIIgiAIgiD0JGaElLvuugv/+c9/sGnTJvzjH//Ap59+ivvvv19ym6KiImzYsAHvvPMOPvnkExw9ehRjx44Nft/Q0ICbbroJtbW1+Pzzz1FWVobS0lI8/vjjEfs6deoU8vPzccMNN+h+bgRBEAShN81SUgAAtbXVFreEIAiCIAgivogJIWX37t3YuHEjVqxYgf79+2PQoEF4+eWX8dZbb+Ho0aOC25w+fRqvvfYaXnzxRVx//fXo27cvVq1ahc8//xxffPEFAKC8vBy7du3CX/7yF/Tu3Rs33ngjnn76aSxZsgT/v707j46yuv84/skkmUkCTkIgyQBlVzZF2SSMGyKRUFGkxaoY2eSgFtBWlgpH/CG2yqLIUSq1i4TWgigq1CNIQQIuEBZz2EmRA9iIJKEUQ0SSyXZ/f4QZmWYhA5NMMnm/zpmTM/e5zzP3Tr7MM3xzl6KiIq/rPf7443rooYfkdDprvb8AAFypKFv59scuRqQAAAD4VYNIpKSnpysmJkZ9+/b1lCUlJclisWjHjh2VnpORkaHi4mIlJSV5yrp27aq2bdsqPT3dc90ePXooISHBUyc5OVn5+fk6ePCgpyw1NVXHjh3T7Nmza9Rel8ul/Px8rwcAAHWpSSQjUhqN06elffvKfwIAgFrXIBabzcnJUXx8vFdZWFiYYmNjlZOTU+U5VqtVMTExXuUJCQmec3JycrySKO7j7mOSdOTIEc2YMUOff/65wsJq9nbNnTtXc+bMqVBe4HIp3OWq0TVQtQLeQ/iAeIEvgilewq3l96zCwnNyuUim1IZ68b5u+kR644+SyiRZpMcfkwYlXeos1CFjjFyuAhUVFcrlKlBISEigm4QGoKrPF5LjQP0Q0ETKjBkzNH/+/GrrZGZm1lFrKiotLdVDDz2kOXPmqHPnzjU+b+bMmZoyZYrneX5+vtq0aaNIm82ziwKuDO8jfEG8wBfBEi8xTZpIkopLimSzRQa4NcEroO/t6dPSH/8iKURSaHnZn96U+jnZOqweMcaopKQ8SWuzRZJIQY1V9vlitRYHoCUA/ldAEylTp07V2LFjq63TsWNHORwOnTp1yqu8pKREZ86ckcPhqPQ8h8OhoqIi5eXleY1Kyc3N9ZzjcDi0c+dOr/Pcu/o4HA59//33+vLLL7V7925NnjxZklRWViZjjMLCwrRhwwbdcccdFV7bZrPJFiRfxAEADZM7IVRUxBopQevkScmUeZeVlUrZ2SRSAACoRQFNpMTFxSkuLu6S9ZxOp/Ly8pSRkaE+ffpIktLS0lRWVqbExMRKz+nTp4/Cw8O1adMmjRgxQpJ0+PBhZWVleRaMdTqdeuGFF3Tq1CnP1KGNGzfKbrere/fuCg8P1/79+72uu2TJEqWlpem9995Thw4dLrvvAADUpkhr+WKzRcWFAW4Jak2rVlKIxTuZYgmVWrYMXJsAAGgEGsQaKd26ddOQIUM0YcIEvfHGGyouLtbkyZP14IMPqlWrVpKkb7/9VoMGDdLf/vY39evXT9HR0Ro/frymTJmi2NhY2e12PfHEE3I6nerfv78kafDgwerevbtGjRqlBQsWKCcnR7NmzdKkSZM8I0quu+46r7bEx8crIiKiQjkAAPVJlHtEComU4NWihTRpkrRkSflIFEuoNHEio1EAAKhlDSKRIknLly/X5MmTNWjQIFksFo0YMUKvvfaa53hxcbEOHz6s8+d/HMK8aNEiT12Xy6Xk5GQtWbLEczw0NFQfffSRfvnLX8rpdKpJkyYaM2aMnn/++TrtGwAA/uYekeIikRLcBg+Wevcun87TsiVJFAAA6kCIMcYEuhHBLj8/X9HR0Tr7t7/J/j+7CMF3BS5X0CwG6U+nT5dPl2/Viu/RFyNe4Itgipevc3PVYcIE2cIjtOp9dnmoDS5XAQv5NnY1uPkaY/TDD3lyuQoUG9uSxWZRI1V9vhw/nq9f/SpaZ8+eld1uD0DLAEgNaEQKgKpt2CC9/rpUZiRLSPlI78GDA90qAIF08YgUYwz/eQP8zX3zNWXla9Vw8wWARsMS6AYAuDKnT/+YRJHKfy5ZUl4OoPGKumhkTXGxK4AtAYKQ++brXujXlHHzBYBGhEQK0MCdPPljEsWttKx8ujyAxuviKUouF1sgA35V3dbTAICgRyIFaOBatSqfznOxUAu7X0rlfxjcf4A/EKJxCgsNVZil/DZfVMQaKUCNnD4t7dt36RuHe+vpi7H1NAA0GiRSgAbOvftl6IV/zaEWdr+Uyqeujx8vPTen/OeGDYFuEVD3IsMurJPiIpGCeqqmiYu64L5xzHrm0jcO983XElr+nK2nAaBRYbFZIAiw+6W3qtaN6d2b9waNS0R4uL4vKmRqD+qn+rRYa1VrnlR34+DmCwCNFiNSgCDRooXUowff4yTWjQHcIsPLR6QwtQf1Tn1brPVy1zzh5gsAjRKJFABBh3VjgHIR4e6pPYxIQT1T3xZrZc0TAIAPSKQACDqsGwOUi7IyIgX1VH1LXLDmCQDAB6yRAiAouaeuH8+SOrTluzAaJ0akoN5yJy6WLCkfiVIfEheseQIAqCESKQCCVosWUpOrpEhboFsCBEbkhREphQU/BLglQCXqY+KiRYv60Q4AQL1GIgUAgCAVaS3PIhYxIgX1FYkLAEADxBopAAAEqUjbhak9jEgBAADwGxIpAAAEqSa28hEprkISKQAAAP5CIgUAgCAVcWFqD2ukAAAA+A+JFAAAglRUxIXtj11sfwwAAOAvJFIAAAhSURERklhsFgAAwJ9IpAAAEKSi3GukkEgBAADwGxIpAAAEqSaR5SNSXEztAQAA8BsSKQAABKmoiPIRKUVFjEgBAADwFxIpAAAEKfeIlKIiRqQAAAD4C4kUAACClHtEClN7AAAA/IdECgAAQSrSemH742ISKQAAAP5CIgUAgCDl3rWnqLgwwC0BAAAIHiRSAAAIUpGeRAojUgAAAPyFRAoAAEHqxxEprgC3BAAAIHiQSAEAIEi510hxMSIFAADAb0ikAAAQpDwjUkpcMsYEuDUAAADBgUQKAABByj0ixZgylZQUBbg1AAAAwYFECgAAQcqdSJEkl4vpPQAAAP5AIgUAUK+dPi3t21f+E74JDwtTaEj5rb6oiEQKAACAP4QFugEAAFRlwwbp9delMiNZQqRJk6TBgwPdqoYjJCREEWHh+qHYJZfrfKCbAwAAEBQYkQIAqJdOn/4xiSKV/1yyhJEpvnJP72FECgAAgH+QSAEA1EsnT/6YRHErLZOyswPTnoYqIixckhiRAgAA4CckUgAA9VKrVuXTeS4WapFatgxMexqqyHBGpAAAAPgTiRQAQL3UokX5miihF+5UoRZp4sTyctSce2oPI1IAAAD8g8VmAQD11uDBUu/e5dN5WrYkiXI5IsLdiRRGpAAAAPgDiRQAQL3WogUJlCsRxYgUAAAAv2JqDwAAQcwztef8uQC3BAAAIDiQSAEAIIhF2mySJFchI1IAAAD8gUQKAABBLMp6IZFSwIgUAAAAfyCRAgBAEIuMuJBIYbFZAAAAvyCRAgBAEIvyTO35IcAtAQAACA4kUgAACGI/jkhhjRQAAAB/IJECAEAQa3JhREoRU3sAAAD8osEkUs6cOaOUlBTZ7XbFxMRo/PjxOneu+oXzCgsLNWnSJDVv3lxNmzbViBEjlJub61UnKytLQ4cOVVRUlOLj4zV9+nSVlJR41XG5XHrmmWfUrl072Ww2tW/fXkuXLvV7HwEA8LcoRqQAAAD4VVigG1BTKSkpys7O1saNG1VcXKxx48bp0Ucf1YoVK6o856mnntLatWu1atUqRUdHa/Lkyfr5z3+urVu3SpJKS0s1dOhQORwObdu2TdnZ2Ro9erTCw8P14osveq5z//33Kzc3V2+++aauvvpqZWdnq6ysrNb7DADAlWoSGSFJKipiRAoAAIA/NIhESmZmptavX69du3apb9++kqTFixfrrrvu0ssvv6xWrVpVOOfs2bN68803tWLFCt1xxx2SpNTUVHXr1k3bt29X//79tWHDBh06dEiffPKJEhIS1LNnT/32t7/V008/reeee05Wq1Xr16/Xp59+qmPHjik2NlaS1L59+zrrOwAAVyLqQiKFESkAAAD+0SCm9qSnpysmJsaTRJGkpKQkWSwW7dixo9JzMjIyVFxcrKSkJE9Z165d1bZtW6Wnp3uu26NHDyUkJHjqJCcnKz8/XwcPHpQkffjhh+rbt68WLFig1q1bq3Pnzpo2bZoKCqr+y57L5VJ+fr7XAwCAQGhyYWpPUTEjUgAAAPyhQYxIycnJUXx8vFdZWFiYYmNjlZOTU+U5VqtVMTExXuUJCQmec3JycrySKO7j7mOSdOzYMX3xxReKiIjQ6tWrdfr0aU2cOFH//e9/lZqaWulrz507V3PmzKlQXuByKdzlunSHUa0C3kP4gHiBL4IxXiyW8r+ZFLrOy8WCs37F+4maMMbI5SpQUVGhXK4ChYSEBLpJaACq+nxhmiZQPwQ0kTJjxgzNnz+/2jqZmZl11JrKlZWVKSQkRMuXL1d0dLQk6ZVXXtF9992nJUuWKDIyssI5M2fO1JQpUzzP8/Pz1aZNG0XabIq8sHsCrgzvI3xBvMAXwRYvMU2aSJJKil2y2Sres3BleE9xKcYYlZSUJ2lttkgSKaixyj5frNbiALQEwP8KaCJl6tSpGjt2bLV1OnbsKIfDoVOnTnmVl5SU6MyZM3I4HJWe53A4VFRUpLy8PK9RKbm5uZ5zHA6Hdu7c6XWee1cfd52WLVuqdevWniSKJHXr1k3GGJ04cULXXHNNhde22WyyBdkXcQBAwxTl3v64pDDALQEAAAgOAV0jJS4uTl27dq32YbVa5XQ6lZeXp4yMDM+5aWlpKisrU2JiYqXX7tOnj8LDw7Vp0yZP2eHDh5WVlSWn0ylJcjqd2r9/v1eSZuPGjbLb7erevbsk6eabb9bJkye9tlr+6quvZLFY9JOf/MSv7wcAAP4WabVKklwMBwcAAPCLBrHYbLdu3TRkyBBNmDBBO3fu1NatWzV58mQ9+OCDnh17vv32W3Xt2tUzwiQ6Olrjx4/XlClTtHnzZmVkZGjcuHFyOp3q37+/JGnw4MHq3r27Ro0apb179+qf//ynZs2apUmTJnlGlDz00ENq3ry5xo0bp0OHDumzzz7T9OnT9cgjj1Q6rQcAgPrkxxEpwbf+CwAAQCA0iESKJC1fvlxdu3bVoEGDdNddd+mWW27Rn/70J8/x4uJiHT58WOfP/7i946JFi3T33XdrxIgRuu222+RwOPTBBx94joeGhuqjjz5SaGionE6nHn74YY0ePVrPP/+8p07Tpk21ceNG5eXlqW/fvkpJSdE999yj1157rW46DgDAFXCPSCkqZmoPAACAP4QYY0ygGxHszp49q5iYGH0za5bsERGBbk6DV1BcrMjw8EA3Aw0E8QJfBGO85BUUqN0LL0iSNv3yDYWGhga4RcHDVVwsW5DFC/zPGKNzRQVyFRepeZNoFptFjVT1+ZLznwI9+M6TysvL81rDEUDdIpFSB06cOKE2bdoEuhkAAAAAgsA333zDeo1AAJFIqQNlZWU6efKkrrrqKv4KcYXcW0l/8803stvtgW4O6jniBb4gXuAL4gW+IF7gi+rixRij77//Xq1atZLF0mBWaQCCTkC3P24s2OHH/+x2O19EUGPEC3xBvMAXxAt8QbzAF1XFC1N6gMAjjQkAAAAAAFBDJFIAAAAAAABqiEQKGhSbzabZs2fLZrMFuiloAIgX+IJ4gS+IF/iCeIEviBeg/mOxWQAAAAAAgBpiRAoAAAAAAEANkUgBAAAAAACoIRIpAAAAAAAANUQiBQAAAAAAoIZIpCCgzpw5o5SUFNntdsXExGj8+PE6d+5ctecUFhZq0qRJat68uZo2baoRI0YoNzfXc3zv3r0aOXKk2rRpo8jISHXr1k2vvvpqhets2bJFvXv3ls1m09VXX61ly5b5u3vws9qIF0l68skn1adPH9lsNvXs2bPCNb7++muFhIRUeGzfvt2f3YOfBSpeJGnfvn269dZbFRERoTZt2mjBggX+6hZqSW3FS1ZWloYOHaqoqCjFx8dr+vTpKikp8RzfsmVLpZ8vOTk5tdJPXJ7XX39d7du3V0REhBITE7Vz585q669atUpdu3ZVRESEevTooXXr1nkdN8bo//7v/9SyZUtFRkYqKSlJR44c8apzOTGJ+iEQ8dK+ffsKnyPz5s3ze98AXGCAABoyZIi54YYbzPbt283nn39urr76ajNy5Mhqz3n88cdNmzZtzKZNm8yXX35p+vfvb2666SbP8TfffNM8+eSTZsuWLebo0aPmrbfeMpGRkWbx4sWeOseOHTNRUVFmypQp5tChQ2bx4sUmNDTUrF+/vtb6iitXG/FijDFPPPGE+f3vf29GjRplbrjhhgrXOH78uJFkPvnkE5Odne15FBUV+bN78LNAxcvZs2dNQkKCSUlJMQcOHDBvv/22iYyMNH/84x/92T34WW3ES0lJibnuuutMUlKS2b17t1m3bp1p0aKFmTlzpqfO5s2bjSRz+PBhr8+X0tLSWusrfLNy5UpjtVrN0qVLzcGDB82ECRNMTEyMyc3NrbT+1q1bTWhoqFmwYIE5dOiQmTVrlgkPDzf79+/31Jk3b56Jjo42a9asMXv37jXDhg0zHTp0MAUFBZ46lxOTCLxAxUu7du3M888/7/U5cu7cuVrvL9BYkUhBwBw6dMhIMrt27fKUffzxxyYkJMR8++23lZ6Tl5dnwsPDzapVqzxlmZmZRpJJT0+v8rUmTpxoBg4c6Hn+m9/8xlx77bVedR544AGTnJx8ud1BLauLeJk9e3a1iZTdu3dfcT9QNwIZL0uWLDHNmjUzLpfLU/b000+bLl26XEGPUJtqK17WrVtnLBaLycnJ8dT5wx/+YOx2uyc+3ImU7777rhZ6Bn/o16+fmTRpkud5aWmpadWqlZk7d26l9e+//34zdOhQr7LExETz2GOPGWOMKSsrMw6Hw7z00kue43l5ecZms5m3337bGHN5MYn6IRDxYkx5ImXRokV+7AmA6jC1BwGTnp6umJgY9e3b11OWlJQki8WiHTt2VHpORkaGiouLlZSU5Cnr2rWr2rZtq/T09Cpf6+zZs4qNjfV67YuvIUnJycnVXgOBVZfxUpVhw4YpPj5et9xyiz788EPfO4E6E8h4SU9P12233Sar1eopS05O1uHDh/Xdd99dRm9Q22orXtLT09WjRw8lJCR46iQnJys/P18HDx70ul7Pnj3VsmVL3Xnnndq6das/u4crUFRUpIyMDK/fs8ViUVJSUpWfC5f6jnH8+HHl5OR41YmOjlZiYqJX7Pgakwi8QMWL27x589S8eXP16tVLL730ktc0QgD+FRboBqDxysnJUXx8vFdZWFiYYmNjq5wbnpOTI6vVqpiYGK/yhISEKs/Ztm2b3nnnHa1du9brOhd/sXVfIz8/XwUFBYqMjLyMHqE21VW8VKZp06ZauHChbr75ZlksFr3//vsaPny41qxZo2HDhvncF9S+QMZLTk6OOnToUOEa7mPNmjWr8bVQN2orXqq617iPSVLLli31xhtvqG/fvnK5XPrLX/6i22+/XTt27FDv3r390T1cgdOnT6u0tLTS3+O//vWvSs+p6vd+cVy4y6qr42tMIvACFS9S+fpdvXv3VmxsrLZt26aZM2cqOztbr7zyyhX3C0BFJFLgdzNmzND8+fOrrZOZmVknbTlw4IDuvfdezZ49W4MHD66T14Rv6lO8VKVFixaaMmWK5/mNN96okydP6qWXXiKRUscaQryg/mgI8dKlSxd16dLF8/ymm27S0aNHtWjRIr311lsBbBmAhuTi7ynXX3+9rFarHnvsMc2dO1c2my2ALQOCE4kU+N3UqVM1duzYaut07NhRDodDp06d8iovKSnRmTNn5HA4Kj3P4XCoqKhIeXl5Xn8FzM3NrXDOoUOHNGjQID366KOaNWtWhev8784Kubm5stvtjEapY/UlXnyVmJiojRs3XtE14LuGEC9Vfb64j6HuBDpeHA5Hhd06ahIL/fr10xdffFFtu1E3WrRoodDQ0Er/TVcXG9XVd//Mzc1Vy5Ytveq4dwK7nJhE4AUqXiqTmJiokpISff31117JWgD+wRop8Lu4uDh17dq12ofVapXT6VReXp4yMjI856alpamsrEyJiYmVXrtPnz4KDw/Xpk2bPGWHDx9WVlaWnE6np+zgwYMaOHCgxowZoxdeeKHCdZxOp9c1JGnjxo1e10DdqA/xcjn27Nnj9YUGdaMhxIvT6dRnn32m4uJiT9nGjRvVpUsXpvXUsUDHi9Pp1P79+73+Q7xx40bZ7XZ17969ynbz+VJ/WK1W9enTx+v3XFZWpk2bNlX5uXCp7xgdOnSQw+HwqpOfn68dO3Z4xY6vMYnAC1S8VGbPnj2yWCwVpogB8JNAr3aLxm3IkCGmV69eZseOHeaLL74w11xzjdfWfidOnDBdunQxO3bs8JQ9/vjjpm3btiYtLc18+eWXxul0GqfT6Tm+f/9+ExcXZx5++GGvLeBOnTrlqePe/nj69OkmMzPTvP7662x/3ADURrwYY8yRI0fM7t27zWOPPWY6d+5sdu/ebXbv3u3ZVWPZsmVmxYoVJjMz02RmZpoXXnjBWCwWs3Tp0rrpOC5LoOIlLy/PJCQkmFGjRpkDBw6YlStXmqioKLY/rudqI17c2x8PHjzY7Nmzx6xfv97ExcV5bX+8aNEis2bNGnPkyBGzf/9+86tf/cpYLBbzySef1E3HcUkrV640NpvNLFu2zBw6dMg8+uijJiYmxrMb06hRo8yMGTM89bdu3WrCwsLMyy+/bDIzM83s2bMr3c42JibG/OMf/zD79u0z9957b6XbH1cXk6ifAhEv27ZtM4sWLTJ79uwxR48eNX//+99NXFycGT16dN12HmhESKQgoP773/+akSNHmqZNmxq73W7GjRtnvv/+e89x97azmzdv9pQVFBSYiRMnmmbNmpmoqCjzs5/9zGRnZ3uOz54920iq8GjXrp3Xa2/evNn07NnTWK1W07FjR5OamlrLvcWVqo14McaYAQMGVBozx48fN8aUJ1K6detmoqKijN1uN/369fPa8hT1U6DixRhj9u7da2655RZjs9lM69atzbx582q7u7hCtRUvX3/9tfnpT39qIiMjTYsWLczUqVNNcXGx5/j8+fNNp06dTEREhImNjTW33367SUtLq/X+wjeLFy82bdu2NVar1fTr189s377dc2zAgAFmzJgxXvXfffdd07lzZ2O1Ws21115r1q5d63W8rKzMPPvssyYhIcHYbDYzaNAgc/jwYa86l4pJ1F91HS8ZGRkmMTHRREdHm4iICNOtWzfz4osvmsLCwlrtJ9CYhRhjTB0PggEAAAAAAGiQWCMFAAAAAACghkikAAAAAAAA1BCJFAAAAAAAgBoikQIAAAAAAFBDJFIAAAAAAABqiEQKAAAAAABADZFIAQAAAAAAqCESKQAAAAAAADVEIgUAgDrw3HPPqWfPnrX+OiEhIQoJCVFMTIzP57Zv395zfl5ent/bBgAAEAxIpAAAGr2xY8dq+PDhgW6G36Smpuqrr76SJC1cuFDNmjVTYWFhhXrnz5+X3W7Xa6+9JknatWuX3n///TptKwAAQENDIgUAgCATExOj+Ph4SdKoUaP0ww8/6IMPPqhQ77333lNRUZEefvhhSVJcXJxiY2PrtK0AAAANDYkUAACqkZ+fr8jISH388cde5atXr9ZVV12l8+fPS5Kefvppde7cWVFRUerYsaOeffZZFRcXV3nd22+/Xb/+9a+9yoYPH66xY8d6nrtcLk2bNk2tW7dWkyZNlJiYqC1btvjU/vj4eN1zzz1aunRphWNLly7V8OHDSZ4AAAD4gEQKAADVsNvtuvvuu7VixQqv8uXLl2v48OGKioqSJF111VVatmyZDh06pFdffVV//vOftWjRoit67cmTJys9PV0rV67Uvn379Itf/EJDhgzRkSNHfLrO+PHjlZaWpn//+9+esmPHjumzzz7T+PHjr6iNAAAAjQ2JFAAALiElJUVr1qzxjD7Jz8/X2rVrlZKS4qkza9Ys3XTTTWrfvr3uueceTZs2Te++++5lv2ZWVpZSU1O1atUq3XrrrerUqZOmTZumW265RampqT5dKzk5Wa1atfI6b9myZWrTpo0GDRp02W0EAABojEikAABwCXfddZfCw8P14YcfSpLef/992e12JSUleeq88847uvnmm+VwONS0aVPNmjVLWVlZl/2a+/fvV2lpqTp37qymTZt6Hp9++qmOHj3q07VCQ0M1ZswYLVu2TMYYlZWV6a9//avGjRsni4WvAgAAAL4IC3QDAACo76xWq+677z6tWLFCDz74oFasWKEHHnhAYWHlt9H09HSlpKRozpw5Sk5OVnR0tFauXKmFCxdWeU2LxSJjjFfZxWuqnDt3TqGhocrIyFBoaKhXvaZNm/rch0ceeURz585VWlqaysrK9M0332jcuHE+XwcAAKCxI5ECAEANpKSk6M4779TBgweVlpam3/3ud55j27ZtU7t27fTMM894yi5ej6QycXFxys7O9jwvLS3VgQMHNHDgQElSr169VFpaqlOnTunWW2+94vZ36tRJAwYM0NKlS2WMUVJSktq1a3fF1wUAAGhsSKQAAFADt912mxwOh1JSUtShQwclJiZ6jl1zzTXKysrSypUrdeONN2rt2rVavXp1tde74447NGXKFK1du1adOnXSK6+8ory8PM/xzp07KyUlRaNHj9bChQvVq1cv/ec//9GmTZt0/fXXa+jQoT73Yfz48ZowYYKk8jVSAAAA4DsmRgMAUAMhISEaOXKk9u7d67XIrCQNGzZMTz31lCZPnqyePXtq27ZtevbZZ6u93iOPPKIxY8Zo9OjRGjBggDp27OgZjeKWmpqq0aNHa+rUqerSpYuGDx+uXbt2qW3btpfVhxEjRshmsykqKkrDhw+/rGsAAAA0diHmfydoAwCABiskJESrV6++7ETJli1bNHDgQH333XeKiYnxa9sAAACCAYkUAACCSEhIiCIiItS8eXOdOHHCp3OvvfZaHTt2TIWFhSRSAAAAqsAaKQAABJEjR45IUoWdfmpi3bp1np2D7Ha7X9sFAAAQLBiRAgAAAAAAUEMsNgsAAAAAAFBDJFIAAAAAAABqiEQKAAAAAABADZFIAQAAAAAAqCESKQAAAAAAADVEIgUAAAAAAKCGSKQAAAAAAADUEIkUAAAAAACAGvp/X11VGq+5kGAAAAAASUVORK5CYII=", "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": "56790db6", "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": "aa84344a", "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": "4f0ab386", "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": "debcc9e7", "metadata": { "tags": [ "remove-cell" ] }, "outputs": [], "source": [ "cluster.delete_dummy_binned_acquisition_data(1)\n", "\n", "cluster.start_sequencer = lambda: setup_dummy_and_start_sequencer(acq_rotation, acq_threshold)" ] }, { "cell_type": "code", "execution_count": 10, "id": "1a865728", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import ConfusionMatrixDisplay\n", "import matplotlib.pyplot as plt\n", "\n", "single_qubit_device.cfg_sched_repetitions(1)\n", "\n", "states = ManualParameter(name=\"States\", unit=\"\", label=\"\")\n", "states.batched = True\n", "\n", "prepared_states = np.asarray([0, 1] * 500)\n", "readout_calibration_kwargs = {\n", " \"qubit\": \"q0\",\n", " \"prepared_states\": states,\n", " \"acq_protocol\": \"ThresholdedAcquisition\",\n", "}\n", "\n", "gettable = ScheduleGettable(\n", " single_qubit_device,\n", " schedule_function=readout_calibration_sched,\n", " schedule_kwargs=readout_calibration_kwargs,\n", " real_imag=True,\n", " batched=True,\n", " max_batch_size=60,\n", ")\n", "\n", "measurement_control.settables(states)\n", "measurement_control.setpoints(prepared_states)\n", "measurement_control.gettables(gettable)\n", "dataset = measurement_control.run(\"Readout Calibration Verification\")\n", "\n", "prepared_states = dataset.x0.values\n", "measured_states = dataset.y0.values\n", "\n", "ConfusionMatrixDisplay.from_predictions(\n", " prepared_states, measured_states, cmap=\"Blues\", normalize=None\n", ")\n", "plt.title(\"Confusion Matrix\")\n", "plt.xlabel(\"Measured State\")\n", "plt.ylabel(\"Prepared State\")\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "3d26a260", "metadata": {}, "source": [ "As expected, the threshold that we set did a good job of discriminating the qubit states (the discrimination is not perfect because the data points belonging to the two states slightly overlap).\n", "\n", "## Conditional Reset\n", "\n", "The conditional reset is implemented in Quantify as a gate. When we have a single {{ Reset }} at the beginning of a schedule, we simply replace the {{ Reset }} gate with the {{ ConditionalReset }} gate, for example\n", "\n", "```{code-block} python\n", "schedule = Schedule()\n", "#schedule.add(Reset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q0\"))\n", "...\n", "```\n", "\n", "In other cases, however, we need to pass extra arguments to {{ ConditionalReset }} that we illustrate below.\n", "\n", "### Example: Modifying the T1 schedule\n", "\n", "In this example, we use the schedule function {{ t1_sched }} using the {{ ConditionalReset }} instead of the standard {{ Reset }}. We need to ensure that all acquisition protocols in the schedule are equal to `\"ThresholdedAcquisition\"`." ] }, { "cell_type": "code", "execution_count": 11, "id": "1908d68b", "metadata": {}, "outputs": [], "source": [ "from quantify_scheduler.qblox.operations import ConditionalReset\n", "from quantify_scheduler.operations import X, Reset\n", "\n", "\n", "# original T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(Reset(qubit), label=f\"Reset {i}\")\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(qubit),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule\n", "\n", "\n", "# updated T1 schedule\n", "def t1_sched(\n", " times: np.ndarray,\n", " qubit: str,\n", " repetitions: int = 1,\n", ") -> Schedule:\n", "\n", " schedule = Schedule(\"T1\", repetitions)\n", " for i, tau in enumerate(times):\n", " schedule.add(\n", " ConditionalReset(qubit, acq_channel=0),\n", " label=f\"Reset {i}\",\n", " )\n", " schedule.add(X(qubit), label=f\"pi {i}\")\n", " schedule.add(\n", " Measure(\n", " qubit,\n", " acq_protocol=\"ThresholdedAcquisition\",\n", " acq_channel=1,\n", " ),\n", " ref_pt=\"start\",\n", " rel_time=tau,\n", " label=f\"Measurement {i}\",\n", " )\n", " return schedule" ] }, { "cell_type": "markdown", "id": "92c00b14", "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": "e339a253", "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": "f07f4e1d", "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": "b632c53f", "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": "eda508bc", "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": "2104f85a", "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": "6c6c702c", "metadata": {}, "source": [ "```{note}\n", "Often, we can use an `Analysis` class on datasets to visualize the data and extract relevant parameters such as {{ T1Analysis }}\n", "```\n", "\n", "### Note on Execution Order\n", "\n", "Parallel {{ ConditionalReset }} operations are not supported. For example, compiling the following schedule will raise a {{ RuntimeError }}:\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"), ref_pt=\"start\")\n", "```\n", "\n", "and will have to be scheduled sequentially,\n", "\n", "```{code-block} python\n", "schedule = Schedule(\"\")\n", "schedule.add(ConditionalReset(\"q0\"))\n", "schedule.add(ConditionalReset(\"q1\"))\n", "```\n", "\n", "\n", "## Closing Remarks\n", "\n", "You can find more technical information and explanations of the different limitations in our [reference guide](sec-qblox-conditional-playback)." ] } ], "metadata": { "file_format": "mystnb", "kernelspec": { "display_name": "python3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.25" }, "myst": { "substitutions": { "BasicTransmonElement": "{class}`~quantify_scheduler.device_under_test.transmon_element.BasicTransmonElement`", "Cluster": "{class}`~qblox_instruments.Cluster`", "ConditionalReset": "{class}`~quantify_scheduler.backends.qblox.operations.gate_library.ConditionalReset`", "Measure": "{class}`~quantify_scheduler.operations.gate_library.Measure`", "MeasurementControl": "{class}`~quantify_core.measurement.control.MeasurementControl`", "QuantumDevice": "{class}`~quantify_scheduler.device_under_test.quantum_device.QuantumDevice`", "ReadoutCalibrationAnalysis": "{class}`~quantify_core.analysis.readout_calibration_analysis.ReadoutCalibrationAnalysis`", "Reset": "{class}`~quantify_scheduler.operations.gate_library.Reset`", "RuntimeError": "{class}`~RuntimeError`", "Schedule": "{class}`~quantify_scheduler.schedules.schedule.Schedule`", "ScheduleGettable": "{class}`~quantify_scheduler.gettables.ScheduleGettable`", "T1Analysis": "{class}`~quantify_core.analysis.single_qubit_timedomain.T1Analysis`", "ThresholdedAcquisition": "{class}`~quantify_scheduler.operations.acquisition_library.ThresholdedAcquisition`", "readout_calibration_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.readout_calibration_sched`", "t1_sched": "{class}`~quantify_scheduler.schedules.timedomain_schedules.t1_sched`" } }, "source_map": [ 23, 69, 82, 123, 130, 147, 151, 184, 194, 260, 292, 302, 310, 314, 323, 330, 339, 380, 401, 451, 464, 520, 546, 555, 561, 567 ] }, "nbformat": 4, "nbformat_minor": 5 }