{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Scan $\\psi$ at fixed $Q$ and $hkl_2$\n", "\n", "This **hklpy** notebook demonstrates a diffractometer scan of angle $\\psi$, the\n", "component of the reference vector ($hkl_2$) that is perpendicular to the\n", "scattering vector ($Q$). In this schematic:\n", "\n", "\n", "\n", "color | description\n", "--- | ---\n", "blue | incident and exit X-ray beams\n", "green | scattering vector ($Q$)\n", "red | reference vector ($hkl_2$)\n", "yellow | rotation ($\\psi$) from $hkl_2$ around $Q$\n", "black | principle cartesian axes\n", "gray | sample\n", "\n", "First, setup bluesky and build the diffractometer object." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from bluesky import plan_stubs as bps\n", "from bluesky import preprocessors as bpp\n", "from bluesky import RunEngine\n", "from bluesky.callbacks.best_effort import BestEffortCallback\n", "from hkl import A_KEV\n", "from hkl import new_lattice\n", "from hkl import SimulatedE4CV\n", "from hkl.diffract import Diffractometer\n", "from hkl.util import libhkl\n", "from ophyd import Signal\n", "from ophyd.sim import noisy_det\n", "import databroker\n", "import math\n", "import numpy\n", "\n", "bec = BestEffortCallback()\n", "cat = databroker.temp().v2\n", "RE = RunEngine()\n", "RE.subscribe(cat.v1.insert)\n", "RE.subscribe(bec)\n", "bec.disable_plots()\n", "\n", "UserUnits = libhkl.UnitEnum.USER\n", "\n", "diffractometer = SimulatedE4CV(\"\", name=\"diffractometer\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Configure the real-space axes so they are reported in LiveTable. Also, the\n", "orientation reflections should be reported with other configuration information,\n", "not as primary data." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "for item in diffractometer.real_positioners:\n", " item.kind = \"hinted\"\n", "diffractometer.reflections.kind = \"config\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Add a sample of *vibranium*. The cubic lattice constant is exactly $2\\pi$." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "HklSample(name='vibranium', lattice=LatticeTuple(a=6.283185307179586, b=6.283185307179586, c=6.283185307179586, alpha=90.0, beta=90.0, gamma=90.0), ux=Parameter(name='None (internally: ux)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), uy=Parameter(name='None (internally: uy)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), uz=Parameter(name='None (internally: uz)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), U=array([[1., 0., 0.],\n", " [0., 1., 0.],\n", " [0., 0., 1.]]), UB=array([[ 1.000000e+00, -6.123234e-17, -6.123234e-17],\n", " [ 0.000000e+00, 1.000000e+00, -6.123234e-17],\n", " [ 0.000000e+00, 0.000000e+00, 1.000000e+00]]), reflections=[])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "diffractometer.calc.new_sample(\"vibranium\", lattice=new_lattice(2 * math.pi))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Set the diffractometer's wavelength by setting the X-ray photon energy.\n", "Orient the sample with two observed reflections and compute the $UB$ orientation matrix." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[-5.55111433e-17, -1.11022287e-16, -1.00000000e+00],\n", " [ 0.00000000e+00, 1.00000000e+00, -1.72254627e-16],\n", " [ 1.00000000e+00, -6.12323400e-17, -1.16743483e-16]])" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "diffractometer.energy.put(A_KEV / 1.54) # (8.0509 keV)\n", "\n", "om = 29.35355\n", "tth = 2 * om\n", "r1 = diffractometer.calc.sample.add_reflection(\n", " 4,\n", " 0,\n", " 0,\n", " position=diffractometer.calc.Position(tth=tth, omega=om, chi=0, phi=0),\n", ")\n", "\n", "r2 = diffractometer.calc.sample.add_reflection(\n", " 0,\n", " 4,\n", " 0,\n", " position=diffractometer.calc.Position(tth=tth, omega=om, chi=90, phi=0),\n", ")\n", "\n", "diffractometer.calc.sample.compute_UB(r1, r2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## bluesky plan_stub to move $\\psi$\n", "\n", "Create a bluesky plan stub to move $\\psi$ given $hkl_2$ and $Q$.\n", "\n", "
\n", "\n", "This plan stub has been generalized to set all the extra parameters. It makes\n", "no assumption about any specific diffractometer geometry. The default `mode`\n", "can be changed with a keyword argument. When using keyword `test=True`, the\n", "number of `digits` reported can be changed with a keyword argument.\n", "\n", "It is helpful to have a separate plan stub (a plan that does not generate any\n", "data streams) to perform the steps needed to change the $\\psi$ value. For the\n", "forward computation (hkl to angles), the procedure is:\n", "\n", "1. select the diffractometer mode\n", "2. set the extra parameters ($hkl_2$ and $\\psi$)\n", "3. compute angles from `forward(Q)`\n", "4. move diffractometer to the computed angles\n", "\n", "
\n", "\n", "**NOTE**:\n", "The $\\psi$ rotation angle is an *extra* diffractometer parameter, only available\n", "as defined by certain diffractometer modes. It is not defined as an ophyd\n", "`Signal` object. It cannot be scanned directly with any of the standard bluesky\n", "plans, nor can it be moved with `bps.mv()`. A custom plan is needed to scan\n", "$\\psi$." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def move_psi_forward(\n", " dfrct: Diffractometer,\n", " Q: dict, # (h, k, l)\n", " extras: dict, # (h2, k2, l2, psi)\n", " mode: str = \"psi_constant\",\n", " test: bool = False,\n", " digits: int = 5,\n", "):\n", " \"\"\"\n", " Set extras and compute forward solution given 'Q' & reference reflection 'hkl_2'.\n", "\n", " EXAMPLE::\n", "\n", " RE(\n", " move_psi_forward(\n", " diffractometer,\n", " Q=dict(h=2, k=1, l=0),\n", " extras=dict(h2=2, k2=2, l2=0, psi=25),\n", " )\n", " )\n", " \"\"\"\n", " dfrct.engine.mode = mode\n", " extras = [extras[k] for k in dfrct.calc.parameters]\n", " dfrct.calc.engine._engine.parameters_values_set(extras, UserUnits)\n", "\n", " # TODO: When test=True, can any moves be avoided?\n", " solution = dfrct.forward(list(Q.values()))\n", "\n", " reals = [] # convert to ophyd real positioner objects\n", " for k, v in solution._asdict().items():\n", " reals.append(getattr(dfrct, k))\n", " reals.append(v)\n", " if test:\n", "\n", " def pos_dict(pos_tuple):\n", " # fmt: off\n", " return {\n", " k: round(v, digits) or 0 \n", " for k, v in pos_tuple._asdict().items()\n", " }\n", " # fmt: on\n", "\n", " result = pos_dict(dfrct.position)\n", " result.update(pos_dict(dfrct.real_position))\n", " result.update(\n", " dict(\n", " zip(\n", " dfrct.calc.parameters,\n", " dfrct.calc.engine._engine.parameters_values_get(UserUnits),\n", " )\n", " )\n", " )\n", " print(result)\n", " else:\n", " yield from bps.mv(*reals)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## bluesky plan to scan extra parameters such as $\\psi$\n", "\n", "Create a generalized bluesky plan that can scan $\\psi$ given $Q$ & $hkl_2$.\n", "The values of $hkl_2$ are described as constants in the ``extras`` input\n", "dictionary. The `axis` parameter is `psi` in this example. The `pseudos`\n", "parameter contains the values of $Q$.\n", "\n", "Do not provide a ``reals`` keyword. That's a future feature. It must remain at\n", "the default value of `None` for this example." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def scan_extra_parameter(\n", " dfrct: Diffractometer = None,\n", " detectors: list = [],\n", " axis: str = None, # name of extra parameter to be scanned\n", " start: float = None,\n", " finish: float = None,\n", " num: int = None,\n", " pseudos: dict = None, # h, k, l\n", " reals: dict = None, # angles\n", " extras: dict = {}, # define all but the 'axis', these will remain constant\n", " md: dict = None,\n", "):\n", " \"\"\"\n", " Scan one (or more) extra diffractometer parameter(s), such as psi.\n", "\n", " - iterate extras as decribed:\n", " - set extras\n", " - solution = forward(pseudos)\n", " - move to solution\n", " - trigger detectors\n", " - read all controls\n", " \"\"\"\n", " # if pseudos is None and reals is None:\n", " # raise SolverError(\"Must define either pseudos or reals.\")\n", " # if pseudos is not None and reals is not None:\n", " # raise SolverError(\"Cannot define both pseudos and reals.\")\n", " forwardTransformation = reals is None\n", "\n", " _md = {\n", " \"diffractometer\": {\n", " \"name\": dfrct.name,\n", " \"geometry\": dfrct.calc.geometry_name,\n", " \"engine\": dfrct.engine.name,\n", " \"mode\": dfrct.engine.mode,\n", " \"extra_axes\": dfrct.calc.parameters,\n", " },\n", " \"axis\": axis,\n", " \"start\": start,\n", " \"finish\": finish,\n", " \"num\": num,\n", " \"pseudos\": pseudos,\n", " \"reals\": reals,\n", " \"extras\": extras,\n", " \"transformation\": \"forward\" if forwardTransformation else \"inverse\",\n", " }\n", " _md.update(md or {})\n", "\n", " # Make a Signal for psi so it can be reported in LiveTable and any stored data.\n", " signal = Signal(name=axis, value=start)\n", " all_controls = detectors\n", " all_controls.append(dfrct)\n", " all_controls.append(signal)\n", " # TODO: controls.append(extras_device) # TODO: need Device to report ALL extras\n", " all_controls = list(set(all_controls))\n", "\n", " @bpp.stage_decorator(detectors)\n", " @bpp.run_decorator(md=_md)\n", " def _inner():\n", " for value in numpy.linspace(start, finish, num=num):\n", " # note the new position for reporting later\n", " yield from bps.mv(signal, value)\n", "\n", " # move\n", " extras.update({axis: value})\n", " if forwardTransformation:\n", " yield from move_psi_forward(dfrct, Q=pseudos, extras=extras)\n", " else:\n", " pass # TODO: inverse\n", "\n", " # trigger\n", " group = \"scan_extra_parameter_detectors\"\n", " for item in detectors:\n", " yield from bps.trigger(item, group=group)\n", " yield from bps.wait(group=group)\n", "\n", " # read & record the data point\n", " yield from bps.create(\"primary\")\n", " for item in all_controls:\n", " yield from bps.read(item)\n", " yield from bps.save()\n", "\n", " return (yield from _inner())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Scan $\\psi$ over a wide range in coarse steps. This example chooses $Q=(210)$\n", "and $hkl_2=(1 \\bar2 0)$. (The reference $hkl_2$ was chosen to be perpendicular\n", "to $Q$.) Save the `uid` from the scan for later reference." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "Transient Scan ID: 2 Time: 2024-09-05 15:57:02\n", "Persistent Unique Scan ID: 'c9c96fe0-c712-433a-abf6-ea1548c8dbd8'\n", "New stream: 'primary'\n", "+-----------+------------+------------+------------------+------------------+------------------+----------------------+--------------------+--------------------+--------------------+------------+\n", "| seq_num | time | noisy_det | diffractometer_h | diffractometer_k | diffractometer_l | diffractometer_omega | diffractometer_chi | diffractometer_phi | diffractometer_tth | psi |\n", "+-----------+------------+------------+------------------+------------------+------------------+----------------------+--------------------+--------------------+--------------------+------------+\n", "| 1 | 15:57:02.9 | 1.050 | 2.000 | 1.000 | -0.000 | -79.339 | -90.000 | -90.000 | -31.808 | 0.000 |\n", "| 2 | 15:57:03.0 | 1.074 | 2.000 | 1.000 | 0.000 | -79.006 | -81.313 | -94.382 | -31.808 | 9.722 |\n", "| 3 | 15:57:03.0 | 1.072 | 2.000 | 1.000 | -0.000 | -77.970 | -72.678 | -98.972 | -31.808 | 19.444 |\n", "| 4 | 15:57:03.0 | 1.085 | 2.000 | 1.000 | -0.000 | -76.109 | -64.157 | -104.015 | -31.808 | 29.167 |\n", "| 5 | 15:57:03.0 | 0.901 | 2.000 | 1.000 | -0.000 | -73.189 | -55.838 | -109.835 | -31.808 | 38.889 |\n", "| 6 | 15:57:03.0 | 0.944 | 2.000 | 1.000 | -0.000 | -68.806 | -47.853 | -116.906 | -31.808 | 48.611 |\n", "| 7 | 15:57:03.0 | 0.960 | 2.000 | 1.000 | -0.000 | -62.300 | -40.424 | -125.944 | -31.808 | 58.333 |\n", "| 8 | 15:57:03.0 | 0.957 | 2.000 | 1.000 | -0.000 | -52.679 | -33.940 | -137.984 | -31.808 | 68.056 |\n", "| 9 | 15:57:03.0 | 0.935 | 2.000 | 1.000 | 0.000 | -38.852 | -29.055 | -154.156 | -31.808 | 77.778 |\n", "| 10 | 15:57:03.0 | 0.919 | 2.000 | 1.000 | 0.000 | -20.890 | -26.674 | -174.424 | -31.808 | 87.500 |\n", "| 11 | 15:57:03.0 | 0.935 | 2.000 | 1.000 | 0.000 | -1.790 | -27.460 | 164.179 | -31.808 | 97.222 |\n", "| 12 | 15:57:03.0 | 0.975 | 2.000 | 1.000 | 0.000 | 14.333 | -31.174 | 145.735 | -31.808 | 106.944 |\n", "| 13 | 15:57:03.0 | 1.087 | 2.000 | 1.000 | 0.000 | 26.007 | -36.938 | 131.684 | -31.808 | 116.667 |\n", "| 14 | 15:57:03.0 | 1.023 | 2.000 | 1.000 | 0.000 | 33.972 | -43.944 | 121.251 | -31.808 | 126.389 |\n", "| 15 | 15:57:03.1 | 0.995 | 2.000 | 1.000 | 0.000 | 39.344 | -51.679 | 113.277 | -31.808 | 136.111 |\n", "| 16 | 15:57:03.1 | 0.947 | 2.000 | 1.000 | -0.000 | 42.951 | -59.847 | 106.885 | -31.808 | 145.833 |\n", "| 17 | 15:57:03.1 | 0.980 | 2.000 | 1.000 | -0.000 | 45.319 | -68.277 | 101.491 | -31.808 | 155.556 |\n", "| 18 | 15:57:03.1 | 0.988 | 2.000 | 1.000 | -0.000 | 46.758 | -76.862 | 96.702 | -31.808 | 165.278 |\n", "| 19 | 15:57:03.1 | 1.095 | 2.000 | 1.000 | 0.000 | 47.443 | -85.529 | 92.241 | -31.808 | 175.000 |\n", "+-----------+------------+------------+------------------+------------------+------------------+----------------------+--------------------+--------------------+--------------------+------------+\n", "generator scan_extra_parameter ['c9c96fe0'] (scan num: 2)\n", "\n", "\n", "\n" ] } ], "source": [ "uid, = RE(\n", " scan_extra_parameter(\n", " diffractometer,\n", " detectors=[noisy_det,],\n", " pseudos=dict(h=2, k=1, l=0),\n", " axis=\"psi\",\n", " start=0,\n", " finish=175,\n", " num=19,\n", " extras=dict(h2=1, k2=-2, l2=0),\n", " ),\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Get the run data from the catalog using the `uid` as an index. View the\n", "metadata from that run." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Start({'axis': 'psi',\n", " 'diffractometer': {'engine': 'hkl',\n", " 'extra_axes': ['h2', 'k2', 'l2', 'psi'],\n", " 'geometry': 'E4CV',\n", " 'mode': 'psi_constant',\n", " 'name': 'diffractometer'},\n", " 'extras': {'h2': 1, 'k2': -2, 'l2': 0},\n", " 'finish': 175,\n", " 'num': 19,\n", " 'plan_name': 'scan_extra_parameter',\n", " 'plan_type': 'generator',\n", " 'pseudos': {'h': 2, 'k': 1, 'l': 0},\n", " 'reals': None,\n", " 'scan_id': 2,\n", " 'start': 0,\n", " 'time': 1725569822.9740038,\n", " 'transformation': 'forward',\n", " 'uid': 'c9c96fe0-c712-433a-abf6-ea1548c8dbd8',\n", " 'versions': {'bluesky': '1.13.0a5.dev23+g997eb228', 'ophyd': '1.9.0'}})" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "run = cat[uid]\n", "run.metadata[\"start\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Create plots of each diffractometer *real* axis *v*. $\\psi$ to show how the axes\n", "moved during the scan. Use the axis names as recorded in the databroker\n", "catalog.\n", "\n", "**Note**:\n", "Detector axes (such as `tth`) remain constant as shown in the LiveTable. The plots show variations past the 6th decimal place due to machine precision." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHgCAYAAACl7mduAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACBEElEQVR4nO3dd3hT1RsH8G+atunem0JbNqXMslE2BWSjgILIElRABFQEF6AMBRkiPxWQKcgeogzZyKZQNrJbWjroTrrbJOf3R20ktKVpaJu2+X6eJw/tuefe+96bQ/Pm3HPPlQghBIiIiIiMgImhAyAiIiIqK0x8iIiIyGgw8SEiIiKjwcSHiIiIjAYTHyIiIjIaTHyIiIjIaDDxISIiIqPBxIeIiIiMBhMfIiIiMhpMfIiIiMhoMPEhoxAcHIwRI0bAx8cHMpkMzs7O6NmzJ06ePFkm+//qq6/g7+8PtVqtKTt69ChGjRqFunXrwtraGlWqVEHfvn1x6dIlrXVTUlIwdepUBAUFwdXVFRKJBDNnzix0X6mpqZg0aRK8vLxgYWGBxo0bY/PmzVp1Vq1ahSpVqiAtLa1Ej7MkzJw5ExKJRKe6crkcJiYmWLJkSYnWW7x4sY7Rlo6C2ktx20FZ0rUt60qXNgyU73ZM5RcTH6r0vvjiC7Rq1QqPHz/GV199hQMHDmDRokV4/PgxOnTogI0bN5bq/qOiojB//nx89dVXMDH577/cTz/9hLCwMHzwwQfYt28fvv/+e8TGxqJVq1Y4evSopl5CQgJWrFiBrKws9OvXr8j9DRgwAOvWrcOMGTOwf/9+NG/eHG+88QZ+++03TZ3hw4fD2toa8+fPL9FjLWsXL16EEAItWrTQqV7z5s1LpF5pKqy9FLcdlCVd27KudGnDQOVpx1TGBFEl9uWXXwoAYsGCBfmWZWZmiho1agh7e3uRnJxcajFMnTpVVKlSRahUKq3yJ0+e5KubkpIi3N3dRefOnTVlarVaqNVqIYQQcXFxAoCYMWNGgfvau3evACB+++03rfKuXbsKLy8voVQqNWXfffedsLe3F2lpafoeWqmYMWOG0PVP0zfffCPMzMxERkZGkfVMTU1Fenp6kfWkUqlITU3VOd6SVlh7KU47KGu6tmVdFKcNC1F+2zGVX+zxoUrr3LlzmD17NoYPH46PPvoo33KZTIaxY8dCLpfjyJEjpRJDdnY2Vq1ahSFDhmh9ewcANze3fPVtbGzg7++PiIgITZlEItH50s+uXbtgY2ODgQMHapWPHDkSUVFROH/+vKZs6NChUCgUBV5CeNb9+/cxcuRI1KpVC1ZWVqhSpQp69+6N69eva9XLu0x18+ZNvPHGG7C3t4e7uztGjRoFuVyeb7t79+5F48aNIZPJ4Ofnh++++06n48wTHByMBg0a4Ny5c+jcuTNsbGzg4eGBr776Kl+9gIAAWFpaAgCEEFi8eDEsLCwwbdo0qFQqTb169erB2tq6WHGUlOe1l+K0g7Kma1vWRXHaMFC8dkwE8FIXVWJff/01JBJJvg/Bp1WvXh0A8Pjx43zLhBBQKpU6vQpz/vx5JCQkoGPHjjrFLJfLERISgvr16+tU/1k3btxAvXr1YGpqqlXesGFDzfI8Hh4eqFu3Lvbu3VvkdqOiouDs7IxvvvkGBw4cwP/+9z+YmpqiZcuWuHPnTr76r776KmrXro0dO3Zg2rRp+O233zB58mStOkeOHEHfvn1ha2uLzZs3Y8GCBdi6dSvWrFmj8/FevHgRcXFxmDJlCoYPH449e/agXbt2mDFjBk6cOKFVL+/yVXx8PHr37o05c+Zg165d+OabbyCVSvPVKy5DtJfyTN+2XJw2DBSvHRMBgGnRVYgqHrlcjoMHDyIoKAjVqlUrtF5qaioAFPgN/8SJEzp/AIWGhsLX1zdf+dmzZwEATZs21Wk748ePR1paGj777DOd6j8rISFBk8w9zcnJSbP8aU2bNsXhw4eL3G67du3Qrl07ze8qlQo9e/ZE/fr1sXz5cixatEir/ujRo/Hxxx8DALp06YL79+9j9erVWLVqlabX4rPPPoO7uzsOHToECwsLAEC3bt0KPI8FiY+Px6NHj9C8eXOcPHkSMpkMAFCnTh1s27YNt27dQvv27TX1WrRogb///htDhgyBr68vrly5Am9v7wK3BwBZWVl49913cfjwYcjlcvj7+2PRokVo06ZNgfEYor2UZ/q25eK2YUD3dkwEMPGhSur69etQKpVo0KDBc+vlfdDkfZt8WmBgIIKDg3Xan5eXV4HlUVFRkEgkcHFxKXIbX3zxBTZu3IgffvgBgYGBOu23IM+7HPLsMjc3N8TGxkKpVOb7hv00pVKJ+fPnY8OGDbh//z5ycnI0y/7555989fv06aP1e8OGDZGZmYnY2Fi4u7sjLS0NwcHBGDdunCbpAQBbW1v07t0b69atK/I4896b2bNna5Ie4L8Pxrz3JK/eoUOH8N5772Hy5MmYO3duvuPNq9esWTPNMfv5+eH06dPw9vbGr7/+ij59+iA8PBxWVlb54inr9lJSjh8/rnPCdvnyZTRu3LjIei/alovThgHd2zERwMSHKimFQgEAcHV1LbROSkoKNm3aBD8/P82H3dNsbGx0+iMPoNA/thkZGTAzM9NcSinMrFmzMHv2bMyZMwcTJkzQaZ8FcXZ2LvAbcWJiIoD/vjXnsbCwgBACmZmZsLGxKXS7U6ZMwf/+9z988sknaN++PRwdHWFiYoK3334bGRkZBcbxtLzEJK9uUlIS1Go1PDw88q1bUFlBLl68CEtLS3Tq1EmrPCQkBADQpEkTTT0LCwvs27cP7dq1K/QOoIsXL8Lc3FyTBFtbW+PLL7/ULB8+fDgmT56Me/fuoVGjRvnWL8v2UpLq1KmDlStX6lT3eb2neV60LRe3DQO6t2MigIkPVVJ5lzDCwsIKrTN//nykpKTghx9+KPBbZElcunBxcUF2djbS0tIKHTA7a9YszJw5EzNnzsSnn36q0/4K06BBA2zatCnfN9+8QcgBAQFa9RMTEyGTyYr8sNiwYQPeeustzJ07V6s8Pj4eDg4OxY7T0dEREokEMTEx+ZYVVFaQixcvolGjRvmSiIsXL8LFxUXzIX3x4kU0adIEM2bMQK9evTB9+nTMmzevwO01bNhQq/foabdv30ZGRgZq1KhR4PKyai8lzdPTE2+//XaJbKsk2nJx2zCgezsmApj4UCXVoEED1KhRA5s2bcLXX38NR0dHreUbNmzA3LlzMWjQIAwfPrzAbZTEpYu6desCAB48eFDg5bSvv/4aM2fOxOeff44ZM2botK/n6d+/P1auXIkdO3Zg8ODBmvJ169bBy8sLLVu21Kr/8OFD+Pv7F7ldiUSSLyHYu3cvIiMjUbNmzWLHaW1tjRYtWmDnzp1YsGCB5nJXSkoK/vjjD522ERwcjAEDBuQrv3TpktblleDgYLz66qvo1q0bVq5ciZEjR8Lb2xvjx4/Pt72+ffsWuK/09HQMGzYMn3/+eaEfrmXRXsqzkmrLxW3DgO7tmAhg4kOVlEQiwcqVK/HKK6+gefPm+OSTT1CzZk3ExMRg8+bN2LNnD0aMGIEVK1YUug1bW9sCL4EVR4cOHQDk3lr/7AfZwoUL8eWXX6J79+7o2bMnzp07p7W8VatWmp/379+PtLQ0pKSkAABu3bqF7du3AwBeeeUVzZiTHj16oGvXrnjvvfegUChQs2ZNbNq0CQcOHMCGDRu0LqGo1WpcuHABo0ePLvI4evXqhbVr16Ju3bpo2LAhLl26hAULFmgNDi6ur7/+Gt27d0fXrl3x4YcfQqVS4dtvv4W1tbXmskZhoqOjER0dne/9USqVuHr1KqZMmaJVLy8RGjFiBB4/foyJEyfCw8MDr776qla9gu7oysnJwaBBg+Dv7//cXozSbi+A7u1AIpGgffv2OH78+AvFo6vitOWi4itOGwaK146JAHACQ6rcrl69KgYNGiTc3d2FiYmJACB8fHzEoUOHyiyGl19+Wbzyyiv5ytu3by8AFPp6mo+PT6H1QkNDteqmpKSIiRMnCg8PD2Fubi4aNmwoNm3alG//R44cEQDEpUuXijyGpKQkMXr0aOHm5iasrKzESy+9JE6ePCnat28v2rdvr6mXN/lgXFyc1vpr1qwpMNY9e/aIhg0bCnNzc1GtWjXxzTff6DSB4e+//y4AiGvXrmmVX716VQAQO3fufG69sWPHCgsLC/H3339r1bt69apWPZVKJV5//XXRp08fkZOTU+R5KgmFtRchdGsHKSkpAoB4/fXXyyReIYrXlnWJT9c2LETx2jGREEJIhBCiNBMrovJk2LBh2LJlC86cOfPC3851lddl/+jRI1SpUqVM9qmLYcOG4eHDhzh9+rShQym3xowZg3v37uHAgQNad5+VphdtL/v27UOvXr1w9erVIu9qNISSjo/tmIqLiQ8ZFYVCgUaNGsHc3BwhISFlMoBUCIE2bdogMDAQy5YtK/X96eLBgweoV68ejh49ipdeesnQ4ZRLjx49gq+vLywsLLQur+zfvx8vv/xyqe33RdvLxx9/jMjIyHzPtSovSjI+tmPSBxMfojJw48YN7NmzB9OmTcv3KAJDOHbsGO7du4exY8caOhQqQHlrL+UV2zHpg4kPERERGQ1+lSAiIiKjwcSHiIiIjAYTHyIiIjIaTHyIiIjIaDDxISIiIqPBxIeIiIiMBhMfIiIiMhpMfIiIiMhoMPEhIiIio8HEh4iIiIwGEx8iIiIyGkx8qNK5evUqJBIJ7ty5AwBYvHgxfH1989XbuXMn3njjDdSsWROWlpbw9fXF0KFDce/ePb33rVAoMGfOHHTo0AEeHh6wsbFBgwYN8O233yIzMzNf/ZycHMyaNQu+vr6QyWSoW7cufvjhh3z1fvnlF/Tr1w++vr6wtLREzZo18d577yE6Ovq58Tx58gTOzs6QSCTYvn27zseha1wAsHHjRjRp0gQWFhZwcXHBkCFDEBERofO+AODw4cNo3bo1rKys4OLighEjRiA2NlarTlhYGCQSSYGvzZs3F7mPlJQUTJ06FUFBQXB1dYVEIsHMmTMLrDtixIgC91O3bl2djuf48eOFxnru3DmtuoXVK87+UlNTMWnSJHh5ecHCwgKNGzfOd05UKhUWLVqE7t27w9vbG1ZWVqhXrx6mTZuG5ORknfaTnZ2NL7/8En5+fjA3N4ePjw+mT5+OjIwMrXozZ8587nE97/168803IZFI0KtXrwKXb968GY0bN4aFhQW8vLwwadIkpKam6nVOniWEQLt27SCRSDBhwgQdzghVSIKoklm5cqVwcHAQarVaCCHEoEGDxMCBA/PVa9GihejTp49YvXq1OH78uPj1119FvXr1hI2Njbhx44Ze+75+/bpwcXERkydPFr///rs4cuSImDlzprCwsBCdO3fWxJTn7bffFjKZTMyfP18cO3ZMTJs2TUgkEjFnzhytel5eXmLo0KFi48aN4vjx42L58uXC29tbeHp6ipiYmELjefXVV4WXl5cAILZt26bzcega19KlSwUA8fbbb4sDBw6IX375RXh6egofHx+RmJio076OHz8uTE1NRd++fcXBgwfFhg0bRJUqVURAQIDIzMzU1AsNDRUAxPvvvy/Onj2r9YqPjy9yP6GhocLe3l60a9dOvP322wKAmDFjRoF1hw8fLiwtLfPt58qVKzod07FjxwQAMXfu3HzbSElJ0ar77PKzZ8+KJUuWCABi2rRpOu2va9euwsHBQfz888/i6NGjmuPbuHGjpk5KSoqwtbUVY8eOFdu2bRPHjh0TCxcuFI6OjsLf31+kp6cXuZ8BAwYICwsLMXfuXHHo0CHx1VdfCXNzc9G7d2+tehEREQUeV0BAgLC0tBRJSUkFbv/PP/8U1tbWws7OTvTs2TPf8g0bNmja29GjR8XPP/8s7O3tRdeuXfU6J8/64YcfhKenpwAgxo8fX+T5oIqJiQ9VOmPHjhVBQUGa36tVqyYWLFiQr96TJ0/ylUVGRgozMzMxevRovfadmpoqUlNT85UvWLBAABAnT57UlN24cUNIJBIxd+5crbpjxowRlpaWIiEh4bmxBgcHCwDi66+/LjCW7du3CxsbG7Fu3bpiJT66xpWZmSns7e3zfeidOXNGABCffvqpTvtr3ry58Pf3Fzk5OZqy06dPCwDixx9/1JTlJT4FvZe6UKvVmsQzLi6uyMTH2tpar/0I8V/iU5xk82kjRowQEolE3Lt3r8i6e/fuFQDEb7/9plXetWtX4eXlJZRKpRBCCKVSWWCCuG3bNgFA/Prrr8/dz9mzZwUAsXDhQq3yuXPnCgDi4MGDz10/NDRUSCQS8eabbxa4PDk5WVSpUkUsWrRI+Pj45Et8lEql8PT01Pq/LYQQGzduFADEvn37NGW6npNn47OxsRE7d+5k4lPJ8VIXVTrBwcFo0aIFACAmJgbh4eGa35/m5uaWr8zLywve3t7FvlSTx9raGtbW1vnK8/b/9HZ3794NIQRGjhypVXfkyJHIyMjAgQMHnhtrYGAgpFJpgbEmJiZi/PjxmDNnDqpVq1asY9A1rhs3bkAul+OVV17Rqte6dWs4OTlhx44dRe4rMjISwcHBGDZsGExNTTXlbdq0Qe3atbFr165ixf48eZdZyruUlBRs27YN7du3R82aNYusv2vXLtjY2GDgwIFa5SNHjkRUVBTOnz8PAJBKpXB2ds63fkFtsyCnT58GgHzvd94lqaLe79WrV0MIgbfffrvA5R9++CE8PT0xceLEApefO3cO0dHR+drlwIEDYWNjo9VWdD0nTxs7diy6du2K/v37P/c4qOJj4kOVgq+vr+aD7fLly5g9ezYkEgk8PT0BAO3bt4dEIsGIESOeu52HDx/i0aNHqF+/vlZ53piF48eP6xXf0aNHAUBruzdu3ICrqys8PDy06jZs2FCz/HlOnDgBlUqVL1YAmDhxIvz8/PQap6BrXNnZ2QAAmUyWbxsymQz37t0rcFzTs/t6etvP7q+gc/DNN9/A3NwcVlZWeOmll7Bnzx4djqr4MjIy4OHhAalUCm9vb0yYMAGJiYn56nXo0KHQhGr8+PEwNTWFnZ0dunXrhlOnThW5382bNyMtLa3ABKGgfd24cQP16tXTShwB3dtRQW2zIIW933m/X7t2rdB11Wo11q5di5o1a6J9+/b5lh8+fBjr16/HL7/8AqlUWuA2CmsrZmZmqFu3rtZxFvec/PLLL7hw4QKWLVtW6DFQ5WFadBWi8m/fvn3Izs7GoUOH8Pnnn+P06dMwNTXFrFmzEBcXp/mD5uTkVOg2lEolRo8eDRsbG0yePFlrmYmJCaRSqV49BteuXcP8+fPRv39/rT/aCQkJBcZjbW0Nc3NzJCQkFLrNlJQUjBs3DlWrVsWoUaO0lu3duxdbt25FSEgITEyK/91G17jq1KkDExMTnD59Wutb+IMHDzSDrpOSkjTJZ2H7Agp+X5ycnLTOgUwmw5gxY9C1a1d4enoiPDwcP/zwA/r27YuVK1cW2pOgj0aNGqFRo0YICAgAkJtkLl68GEeOHEFwcDBsbGw0daVSab4Pa3t7e3zwwQfo0KEDnJ2dcf/+fSxYsAAdOnTA3r170a1bt0L3vWrVKjg4OODVV1/Nt6ygfSUkJKB69er56uad0+e1o8jISEybNg3NmjUrdDBxHn9/fwC5PT9+fn6a8rxk7nn7OXjwICIiIjBv3rx8y1JTUzFmzBh89NFHaNSoUaHbKKqthIWFadXV9ZxERkbio48+wvz58+Hl5VXo/qkSMfClNqISNWnSJNG2bVvN7/7+/mLmzJlFrqdWq8Vbb70lpFKp2L17d4nFExoaKqpWrSpq166tNWZHiNzxBnXr1i1wPXNzc/HOO+8UuCwjI0N06dJFWFlZiXPnzmktyxsn8fnnn2vKChtvkpOTo/XKG/9SnLiGDRsmzMzMxM8//ywSEhLE1atXRcuWLYVUKhUANAOvlUql1r5UKpUQ4r/xGc8ehxC5Y7VkMlmBceTJzs4WTZo0Ec7OzlpjhIpS1Bifgmzfvl0AEIsWLdJ5naclJSUJb29v0bBhw0Lr3Lhxo9jjS2rVqiW6d++erzwqKkoAEPPmzStwvYSEBNGwYUPh5uYmHjx4UOR+srKyRM2aNYWXl5c4ePCgSEpKEvv37xfu7u5CKpUW2maEEOK1114TpqamIjo6Ot+y8ePHi1q1aomMjAxNWUFjfObMmaPVpp4WFBQk6tSpo/m9OOekV69eol27dlo3HhT3PaCKhZe6qMJTqVRQKpVQKpU4ceIEXnrpJSiVSsTGxuKff/5B27ZtoVQqoVKpClxf/DvuYMOGDVi7di369u1bInE9evQIHTt2hKmpKY4cOZLvm6qzs3OB35LT0tKQnZ1d4DfbrKws9O/fH6dOncKePXvQsmVLreWfffYZzMzMMGHCBCQnJyM5OVlzq296ejqSk5MhhEBYWBjMzMy0XidOnCh2XD/99BMGDx6McePGwdnZGU2aNEHdunXRs2dPyGQyzZiSzp07a+0rr5cqb3lB+0tMTHxuDx2Qe5lj8ODBSEhIeKFpCHTRv39/WFtb57sdXVcODg7o1asXrl27lu/27zyrVq0CgGL1XhX2fuVdlivoHCYlJaFr166IjIzEoUOHCuwdeZa5uTn279+PatWqISgoCI6Ojnjttdfw6aefwtHREVWqVClwvfj4eOzZswc9e/bMd/n0woUL+PHHHzF//nxkZmZq2qxarYZSqURycjKysrI0xwno1lZ0PSfbt2/HgQMHMH/+fMjlcs3+gdxLe8nJycjJySny3FAFY+jMi+hFtW/fXgAo8tW+fft866rVajFq1CghkUjE6tWrSyymsLAw4evrK3x8fERYWFiBdfK+wT77LTjv7plnb7vNzMwU3bt3FzKZTBw4cKDAbepyLpKSkkRWVpYIDg7WeikUCr3iEkKIxMREcfXqVREXFyeEEKJOnTqiY8eOmuW3b9/W2ldoaKgQQojHjx8LAOKbb77Jt806deoUeJvys+bNmycAiNu3bxdZN48+PT4qlUpYWVmJ119/Xed1nvXOO+8IAFq9G3mysrKEi4uLCAwMLNY2x4wZI2xsbPL1eG3atEkAEKdPn9YqT0xMFE2bNhWOjo4iJCSk+Achct+3a9euibS0NE0vyqxZswqsu2jRIgFA/PHHH/mWrVmzpsj2unjxYiHEf3f6bd68WWsbOTk5wsbGRowZM0ZTpus5mTFjRpH737Vrl17niMovJj5U4eV9qM6dO1dYWlqKc+fOieDgYNG7d2/Rrl07zYftsx+MarVajB49WkgkErFixYoSi+fRo0fC19dXVK1a9bmXEPJuG3/2Q/+dd97Jdzt7Zmam6NGjhzA3Nxd//vlnodu8fPmyOHbsmNZr8eLFAoCYOXOmOHbsWJGXhIoTV0F+//13AUDnS4YtWrQQAQEBWrcY5yVZP/3003PXzc7OFo0bNxYuLi4F3qJcGH0Sny1btggAYsmSJTqv87TExERRpUoV0bhx4wKX591W/vQt/LrYt29fgQlB9+7d8926nZf0ODg4iODg4OIfRAEmT54srK2txePHjwtcXr9+/UJvIY+Ojs7XXo8dOybc3d1Fq1atxLFjx0RERIQQ4r/b2Z+9hJWXzOzfv19Tpus5CQ0NLXD/AES/fv3EsWPHNMk8VR5MfKjSGDlypOjVq5fmd29vb7Fs2bJC60+YMEEAEKNGjco30dqz34RnzZolpFKpOH78+HNjePLkiahevbqQyWRiw4YN+bab90c8T95EgQsWLBDHjx8Xn376aYETBfbq1UsAEJ999lm+bd68efO5Mekzp4yucW3fvl0sXbpUHDp0SPzxxx/iww8/FKampuLdd9/VeV/Hjh0Tpqamon///uLQoUNi48aNomrVqvkmMJw8ebKYMGGC2LRpkzh27JhYv369aN68uQAg1qxZo9O+9u3bJ7Zt2yZWr14tAIiBAweKbdu2iW3btom0tDQhRG5vXZs2bcTSpUvFvn37xP79+8W0adOEhYWFqF+/fr55mjp16iSkUqlW2RtvvCE++eQTzUSBK1asEHXq1BGmpqbi0KFDBcbWvXt3YWlpKZKTkwuNv6B9CZE7LsvR0VGsWLFCHD16VIwZM0YAEBs2bNDUSU9PF82bNxcSiUR8//33+drR/fv3tbYplUpFp06dtMq+/fZbsW7dOnHs2DGxefNmMWDAAGFiYlLopIDnzp0r1pxOeQoa4yOEEL/++qsAIMaOHas5rw4ODoVOYFjUOSkMOManUmPiQ5WCSqUSrq6uYvny5UIIIUJCQgQA8ejRo0LX8fHxKbR728fHR6tuXpf4sWPHnhtHXpJR2OvZHobs7GwxY8YMUa1aNWFubi5q164tli5dmm+7xb2EV1BMxUl8dI1r165donHjxsLa2lpYWlqKZs2aiVWrVuWbobooBw8eFK1atRIWFhbCyclJvPXWW/kmbVy1apVo0aKFcHJyEqampsLR0VF069ZN/PXXXzrv53nved7lt8TERNG/f3/h6+srLC0thbm5uahVq5aYOnVqgUlJ3uXFp82bN080btxY2NvbC6lUKlxdXUX//v3FhQsXCowrPDxcmJiYiLfeeuu58Re0LyFyZ2WeOHGi8PDwEObm5qJhw4Zi06ZNWnXyJoAs7DV8+HCt+gW1rVmzZokaNWoImUwmHBwcRPfu3cXff/9daLxjxowREolEp8HTTyss8RFCiN9++000bNhQmJubCw8PDzFx4sR8s2ELods5KQwTn8pNIoQQhY3/ISIiIqpMeFcXERERGQ0mPkRERGQ0mPgQERGR0WDiQ0REREaDiQ8REREZDT6k9BlqtRpRUVGwtbXV64GUREREVPaEEEhJSYGXl9dzH9DMxOcZUVFRqFq1qqHDICIiIj1ERETA29u70OVMfJ5ha2sLIPfE2dnZGTgaIiIi0oVCoUDVqlU1n+OFYeLzjLzLW3Z2dkx8iIiIKpiihqlwcDMREREZDSY+REREZDSY+BAREZHR4BgfPalUKuTk5Bg6DCIqgLm5+XNvZyUi48XEp5iEEIiJiUFycrKhQyGiQpiYmMDPzw/m5uaGDoWIyhkmPsWUl/S4ubnBysqKkxwSlTN5k5BGR0ejWrVq/D9KRFqY+BSDSqXSJD3Ozs6GDoeICuHq6oqoqCgolUqYmZkZOhwiKkd4EbwY8sb0WFlZGTgSInqevEtcKpXKwJEQUXnDxEcP7DonKt/4f5SICsPEh4iIiIwGEx8iIiIyGkx8iIiIyGgw8TEycXFxMDMzQ3p6OpRKJaytrREeHq5ZnpiYiPfffx916tSBlZUVqlWrhokTJ0Iulxsw6vJn5syZaNy4saHDqNA6dOiASZMmGToMIiojarVAcno2QuPTkJ6tNFgcvJ3dyJw9exaNGzeGlZUVzp8/DycnJ1SrVk2zPCoqClFRUfjuu+/g7++PR48e4d1330VUVBS2b99uwMgrppycnHJ7O3V5jq04srOzOVEhURkSQiA1S4nk9Bwkp+cgKT0byRk5SE7PRlJaDpIzsv9dlo2k9BzIM3LryDNyIETuNja+3RJta7oYJH72+LwAIQTSs5UGeYm81lNMZ86cQdu2bQEAp06d0vycJyAgADt27EDv3r1Ro0YNdOrUCXPmzMEff/wBpVL3DD07OxsTJkyAp6cnLCws4Ovri3nz5mmWJycnY+zYsXB3d4eFhQUCAgLw559/AgASEhLwxhtvwNvbG1ZWVmjQoAE2bdqktf0OHTpg4sSJmDp1KpycnODh4YGZM2fqHJ9cLsfYsWPh5uYGOzs7dOrUCVevXgWQ2yvm4eGBuXPnauqfP38e5ubmOHjwINauXYtZs2bh6tWrkEgkkEgkWLt2LYDcu4l+/vln9O3bF9bW1pg9ezZUKhVGjx4NPz8/WFpaok6dOvj+++91jnXEiBHo168fZs2apYn3nXfeQXZ2tqbOgQMH8NJLL8HBwQHOzs7o1asXHjx4oFkeFhYGiUSCrVu3okOHDrCwsMCGDRt0Ptfvv/8+Jk2aBEdHR7i7u2PFihVIS0vDyJEjYWtrixo1amD//v1a6926dQuvvPIKbGxs4O7ujmHDhiE+Pl5zTCdOnMD333+vOYdhYWFFrpcXz4QJEzBlyhS4uLiga9euOp9LIiqYIjMHVyKSsfdaNDaef4T/HbuPOXtv4aNtV/H2uot47acz6LzwOJrNPoRan+1Hg5kH8fL8Y+i97BTeWn0BEzddxpe/38Tiw3ex5nQYdl2OxLE7cbgSkYzQ+DQkp/+X9FibS5GRbbipJtjj8wIyclTw//Ivg+z71lfdYGWu29sXHh6Ohg0bAgDS09MhlUqxdu1aZGRkQCKRwMHBAUOGDMGPP/5Y4PpyuRx2dnYwNf1vfx06dICvr6/mA/9ZS5cuxZ49e7B161ZUq1YNERERiIiIAJA7s26PHj2QkpKCDRs2oEaNGrh16xakUikAIDMzE4GBgfjkk09gZ2eHvXv3YtiwYahevTpatmyp2ce6deswZcoUnD9/HmfPnsWIESPQtm3bIj8IhRDo2bMnnJycsG/fPtjb22P58uXo3Lkz7t69C1dXV6xevRr9+vVDUFAQ6tatizfffBPjxo1DUFAQMjIycOPGDRw4cACHDx8GANjb22u2P2PGDMybNw+LFy+GVCqFWq2Gt7c3tm7dChcXF5w5cwZjx46Fp6cnBg0aVMS7l+vIkSOwsLDAsWPHEBYWhpEjR8LFxQVz5swBAKSlpWHKlClo0KAB0tLS8OWXX6J///64cuWK1jOrPvnkEyxcuBBr1qyBTCYr1rmeOnUqLly4gC1btuC9997D7t270b9/f3z66adYvHgxhg0bhvDwcFhZWSE6Ohrt27fHmDFjsGjRImRkZOCTTz7BoEGDcPToUXz//fe4e/cuAgIC8NVXXwHInXSwqPWejue9997D6dOn9f4SQGRslCo1whPT8TAuDQ/jU//9Nw0P49IQn5pV7O1ZmJnAwdIcDlZmcLAyg6NV3s/mcLDU/t3Rygz2VmZwsDSHualh+1wkgn81tCgUCtjb22s+7J+WmZmJ0NBQ+Pn5wcLCAunZygqR+CiVSjx+/BgKhQLNmjVDcHAwbGxs0LhxY+zduxfVqlWDjY0NXFzydzsmJCSgadOmGDZsGGbPnq0pf+utt1ClShWtXpynTZw4ETdv3sThw4fzzaly8OBB9OjRA//88w9q166t0zH07NkT9erVw3fffQcgN/FSqVQ4efKkpk6LFi3QqVMnfPPNN8/d1tGjR9G/f3/ExsZCJpNpymvWrImpU6di7NixAIDx48fj8OHDaN68Oa5evYrg4GBYWFgAyB3js3v3bly5ckVr2xKJBJMmTcLixYufG8P48ePx5MkTnS4fjhgxAn/88QciIiI0k2f+/PPP+PjjjyGXywt8GGdcXBzc3Nxw/fp1BAQEICwsDH5+fliyZAk++OCD5+6vqHOtUqlgb2+PAQMGYP369QByH+Xi6emJs2fPolWrVvjyyy9x/vx5/PXXf/8/Hj9+jKpVq+LOnTuoXbs2OnTogMaNG2PJkiWaOrquJ5fLcfny5UKP4dn/q0TGQgiBxLTsfxOa3OTmwb+JTnhCOpTqwj/y3WxlqOZkBUfr3ETFIS9xsdT+PS+hsTCTluGRFe15n99PY4/PC7A0k+LWV90Mtm9dmZqawtfXF1u3bkXz5s3RqFEjnD59Gu7u7mjXrl2h6ykUCvTs2RP+/v6YMWOG1rK8D7zCjBgxAl27dkWdOnXQvXt39OrVC0FBQQCAK1euwNvbu9CkR6VS4ZtvvsGWLVsQGRmJrKwsZGVlwdraWqteXi9WHk9PT8TGxj43LgC4dOkSUlNT8z12JCMjQ+vy0HfffYeAgABs3boVFy9e1PkDtFmzZvnKfv75Z/zyyy949OgRMjIykJ2dXazB0Y0aNdKaMbx169ZITU1FREQEfHx88ODBA3zxxRc4d+4c4uPjoVarAeT29gUEBBQamz7nWiqVwtnZGQ0aNNCUubu7A4Dm/F+6dAnHjh2DjY1NvmN58OBBoe+9rusVdI6JjEmWUoVHCel4GJeam9g81Ysjz8gpdD1LMyn8XKxR3dUa1V2sUd3VBtVdreHnYg1bi4o/5k8XTHxegEQi0bnXxZDq16+PR48eIScnB2q1GjY2NlAqlVAqlbCxsYGPjw9u3ryptU5KSgq6d+8OGxsb7Nq1q9iDYJs2bYrQ0FDs378fhw8fxqBBg9ClSxds374dlpaWz1134cKFWLx4MZYsWYIGDRrA2toakyZN0hrTAiBfTBKJRPOB/zxqtRqenp44fvx4vmUODg6anx8+fIioqCio1Wo8evQoX6JVmGeThq1bt2Ly5MlYuHAhWrduDVtbWyxYsADnz5/XaXvPk9eb1rt3b1StWhUrV66El5cX1Go1AgIC8p2zZ2N7kXP9dFleHHnnX61Wo3fv3vj222/zxezp6Vno8ei63rPHQVSZRSVn4HxoAq4/VmiSm8dJ6Sis80YiAbzsLVHd1Ro1/k1sqrvk/uthZwETE+Oe2bz8f2rTC9u3bx9ycnLQuXNnzJ8/H4GBgXj99dcxYsQIdO/ePd+HmkKhQLdu3SCTybBnzx69LxXY2dlh8ODBGDx4MF577TV0794diYmJaNiwIR4/foy7d+8W+M3/5MmT6Nu3L958800AuR+G9+7dQ7169fSK41lNmzZFTEyMpiesINnZ2Rg6dCgGDx6MunXrYvTo0bh+/bqmZ8Pc3Fzn50CdPHkSbdq0wbhx4zRlT/cs6eLq1avIyMjQJI3nzp2DjY0NvL29kZCQgH/++QfLly/Hyy+/DCB34LqusZXGuW7atCl27NgBX19frbFhTyvoHOqyHlFlFy3PwLmHCTj3IBHnQhPwKCG9wHq2MtPcpMbVJl/vTXm7DFWe8C+LEfDx8UFMTAyePHmCvn37wsTEBLdu3cKAAQPg5eWlVTclJQVBQUFIT0/Hhg0boFAooFAoAOQOPs0bgFzUGJ/FixfD09MTjRs3homJCbZt2wYPDw84ODigffv2aNeuHV599VUsWrQINWvWxO3btyGRSNC9e3fUrFkTO3bswJkzZ+Do6IhFixYhJiamxBKfLl26oHXr1ujXrx++/fZb1KlTB1FRUdi3bx/69euHZs2a4bPPPoNcLsfSpUthY2OD/fv3Y/To0Zo7z3x9fREaGqq5bGdra6s1XuhpNWvWxPr16/HXX3/Bz88Pv/76K4KDg+Hn56dzzNnZ2Rg9ejQ+//xzPHr0CDNmzMCECRNgYmICR0dHODs7Y8WKFfD09ER4eDimTZum03ZL61yPHz8eK1euxBtvvIGPP/4YLi4uuH//PjZv3oyVK1dCKpXC19cX58+fR1hYGGxsbODk5KTTekSVTbQ8A+cfJuLsg4QCEx2piQQBVewRWM0RNd3+7cFxtYarjYzPpdMDEx8jcfz4cTRv3hwWFhY4efIkqlSpki/pAXLHWORdgqlZs6bWstDQUE0PSXh4eIGDavPY2Njg22+/xb179yCVStG8eXPs27dPs86OHTvw0Ucf4Y033kBaWhpq1qypGZT8xRdfIDQ0FN26dYOVlRXGjh2Lfv36ldgkihKJBPv27cNnn32GUaNGaW5fb9euHdzd3XH8+HEsWbIEx44d0wyQ+/XXX9GwYUP89NNPeO+99/Dqq69i586d6NixI5KTk7FmzRqMGDGiwP29++67uHLlCgYPHgyJRII33ngD48aNy3f79/N07twZtWrVQrt27ZCVlYXXX39dc/u+iYkJNm/ejIkTJyIgIAB16tTB0qVL0aFDhyK3W1rn2svLC6dPn8Ynn3yCbt26ISsrCz4+PujevbumDXz00UcYPnw4/P39kZGRoWlfRa1HVNHFyDNze3T+fYU9k+iYSIAG3g5oVd0Jrao7o5mPo9GMvykLvKvrGcW5q4uoLIwYMQLJycnYvXu3oUOpMPh/lcoTnRKdKvZoVd05N9HxZaKjD97VRUREZAAx8kycD81LdBIRGp+mtZyJjmEx8aFKZ+PGjXjnnXcKXFbQHWyGVtCt23mKczmMiAwjITULp+7HPzfRCdAkOk5o5usEOyY6BsPEhyqdPn36aM06/LTy+GyqZydBfFqVKlU0d2oRUfmhVKlx4m4ctl6MwJF/YrUmBmSiU74x8aFKx9bWFra2toYOQ2fPDiInovLrfmwqtl2KwM6QSMSl/PeYB39PO7StmXvpqrkfE53yjImPHnSZJI+IDIf3bFBJSsnMwd5r0dh6MQIh4cmacmdrcwxoWgUDm1VFbfeK82XL2DHxKQZzc3OYmJggKioKrq6uMDc35xwKROWMEAJxcXH5ZpcmKg4hBM6HJmLrxQjsvx6DjJzcyTalJhJ0rOOGQc280bGuG8yknGahomHiUwwmJibw8/NDdHQ0oqKiDB0OERVCIpHA29ubEx5SsUUlZ2DHpcfYHvJYayLBGq7WGNSsKvo3rQI3W06RUJFV2MRn3rx5+PTTT/HBBx9onu4shMCsWbOwYsUKJCUloWXLlvjf//6H+vXrl9h+zc3NUa1aNSiVSp0fWUBEZcvMzIxJD+ksM0eFQ7eeYNulxzh5Lw55V0ptZKbo3cgTA5tVRZOqDuzhryQqZOITHByMFStW5Hto5Pz587Fo0SKsXbsWtWvXxuzZs9G1a1fcuXOnRAe75nWhsxudiKjiuhEpx7aLEdh9JUrrieatqjthULOq6B7gUSEeRE3FU+He0dTUVAwdOhQrV67E7NmzNeVCCCxZsgSfffYZBgwYAABYt24d3N3d8dtvvxU6rwsRERmPpLRs7L4Sia0XH+OfaIWm3MveAq8GeuO1QG/4OFsbMEIqbRUu8Rk/fjx69uyJLl26aCU+oaGhiImJQVBQkKZMJpOhffv2OHPmTKGJT1ZWFrKy/rslMe+BnEREVDmo1AJ/34vDtosROHwrFtmq3DtzzU1NEOTvjkHNqqJtTRdITXgpyxhUqMRn8+bNCAkJQXBwcL5lMTExAAB3d3etcnd3dzx69KjQbc6bNw+zZs0q2UCJiMjg0rOVWHUyFBvPhyNGkakpD6hih0HNqqJPIy84WJkbMEIyhAqT+EREROCDDz7AwYMHn/vQwWcHnwkhnjsgbfr06ZgyZYrmd4VCgapVq754wEREZBBqtcDuK5H49sBtPFHk9ug7WpmhX5MqGBhYFf5ehT/Akiq/CpP4XLp0CbGxsQgMDNSUqVQq/P3331i2bBnu3LkDILfnx9PTU1MnNjY2Xy/Q02QyGWQyWekFTkREZeZiWCK++vMWrj2WAwCqOlnio6A66B7gAZkp7/SjCpT4dO7cGdevX9cqGzlyJOrWrYtPPvkE1atXh4eHBw4dOoQmTZoAALKzs3HixAl8++23hgiZiIjKSERiOr45cBt7r0UDyL0VfUKnmhjRxhcWZkx46D8VJvGxtbVFQECAVpm1tTWcnZ015ZMmTcLcuXNRq1Yt1KpVC3PnzoWVlRWGDBliiJCJiKiUpWYp8eOx+/jlVCiylWqYSIDBzathStfacLVlbz7lV2ESH11MnToVGRkZGDdunGYCw4MHD1aoB1YSEVHRVGqB7ZcisOCvu4hPzR3H06aGMz7v6c8xPPRcEsGn+WlRKBSwt7eHXC6HnR3/8xARlTdnHsRj9p//4Na/8/D4uVjj01fqoUs9N86ubMR0/fyuVD0+RERUeYXFp2Huvn9w8NYTAICthSk+6FwLb7X2hbkpHxZKumHiQ0RE5Zo8IwfLjt7D2jNhyFEJSE0kGNqyGiZ1qQ0na87DQ8XDxIeIiMolpUqNTcERWHzoLhLTsgEA7Wu74vOe9VDLnWM3ST9MfIiIqNz5+24cZu+9hbtPUgEANd1s8FnPeuhYx83AkVFFx8SHiIjKjfuxqZiz9xaO3YkDADhYmWFyl9oY0rIazKQcx0MvjokPEREZXFJaNr4/cg+/nnsElVrA1ESC4W18MbFTLdhbmRk6PKpEmPgQEZHB5KjU+PXsI3x/5B7kGTkAgC713PDpK/VQ3dXGwNFRZcTEh4iIDOLE3TjM+uMmHsalAQDqetjii17+aFvTxcCRUWXGxIeIiMqUEALLjt7HwkN3AQDO1ub4MKgOBjevCqkJJyCk0sXEh4iIykyWUoVpO65j1+VIAMCbraphave6sLPgOB4qG0x8iIioTMSnZuGdXy/h0qMkSE0kmNWnPt5s5WPosMjIMPEhIqJSd/dJCkatDcbjpAzYWpjip6GBeKkWx/JQ2WPiQ0REper4nVhM+O0yUrOU8HG2wqrhzVHTjXdskWEw8SEiolIhhMC6M2H46s9bUAughZ8Tlr8ZCEc+X4sMiIkPERGVOKVKjVl/3MKv5x4BAAYGemNO/wZ8ijoZHBMfIiIqUfKMHEz4LQQn78VDIgE+6V4X77SrDomEt6qT4THxISKiEvMoIQ2j1gbjQVwaLM2kWPJ6Y3Sr72HosIg0mPgQEVGJuBCaiHd+vYik9Bx42Fngl+HNEFDF3tBhEWlh4kNERC9s28UIfLrrOnJUAg297bHyrWZwt7MwdFhE+TDxISIivanVAgsO3sFPxx8AAF5p4IGFAxvD0lxq4MiICsbEh4iI9JKercSULVdx4GYMAOD9TjUxuUttmPB5W1SOMfEhIqJii5Fn4u31wbgRqYC51ATfvtYA/Zt4GzosoiIx8SEiomK5/liOt9cH44kiC07W5lgxLBDNfJ0MHRaRTpj4EBGRzg7ciMakLVeQmaNGLTcbrB7RHFWdrAwdFpHOmPgQEVGRhBD46cQDzD9wBwDQvrYrfhjSBHYWZgaOjKh4mPgQEdFzZSlVmL7zOnaGRAIARrTxxec968FUysdPUMXDxIeIiAqVmJaNd369iOCwJEhNJJjZ2x/DWvsaOiwivTHxISKiAt17koJR64IRkZgBWwtT/Di0KV6u5WrosIheCBMfIiLK5++7cRi/MQQpWUpUc7LC6hHNUNPN1tBhEb0wJj5ERKQlOCwRo9cFI0cl0MLXCT8PC4STtbmhwyIqEUx8iIhIIyo5A+9tuIQclUC3+u5Y+kYTyEz5+AmqPDgkn4iIAACZOSq88+slxKdmo56nHRYPbsykhyodJj5ERAQhBKbvvI7rkXLNbMxW5rwoQJUPEx8iIsKqU6HYdTkSUhMJ/jekKWdjpkqLiQ8RkZH7+24c5u77BwDwRc96aF3D2cAREZUeJj5EREbsUUIa3t90GWoBDGrmjeFtfA0dElGpYuJDRGSkUrOUGLP+IuQZOWhSzQFf9wuARCIxdFhEpYqJDxGREVKrBaZsuYK7T1LhZivDz28G8g4uMgpMfIiIjNDSo/dw8NYTmEtNsHxYINztLAwdElGZYOJDRGRk/roZgyWH7wEA5vQPQJNqjgaOiKjsMPEhIjIid5+kYMqWKwCAEW18MbBZVcMGRFTGmPgQERmJ5PRsjFl/EWnZKrSu7ozPetYzdEhEZa7CJD7z5s1D8+bNYWtrCzc3N/Tr1w937tzRqiOEwMyZM+Hl5QVLS0t06NABN2/eNFDERETlh1KlxvubLuNRQjq8HS3xv6FNYSatMB8BRCWmwrT6EydOYPz48Th37hwOHToEpVKJoKAgpKWlaerMnz8fixYtwrJlyxAcHAwPDw907doVKSkpBoyciMjw5v91ByfvxcPSTIqVbzXj09bJaEmEEMLQQegjLi4Obm5uOHHiBNq1awchBLy8vDBp0iR88sknAICsrCy4u7vj22+/xTvvvKPTdhUKBezt7SGXy2FnZ1eah0BEVCZ2X47EpH/H9fxvSFP0bOhp2ICISoGun98VpsfnWXK5HADg5OQEAAgNDUVMTAyCgoI0dWQyGdq3b48zZ84Uup2srCwoFAqtFxFRZXH9sRyf7LgGABjfsQaTHjJ6FTLxEUJgypQpeOmllxAQEAAAiImJAQC4u7tr1XV3d9csK8i8efNgb2+veVWtyjsciKhyiEvJwthfLyJLqUbnum74sGsdQ4dEZHAVMvGZMGECrl27hk2bNuVb9ux060KI507BPn36dMjlcs0rIiKixOMlIipr2Uo13ttwCdHyTFR3tcbi1xvDxISPoyAyNXQAxfX+++9jz549+Pvvv+Ht7a0p9/DwAJDb8+Pp+V9XbmxsbL5eoKfJZDLIZLLSC5iIyABm/nETFx8lwVZmipVvNYOdhZmhQyIqFypMj48QAhMmTMDOnTtx9OhR+Pn5aS338/ODh4cHDh06pCnLzs7GiRMn0KZNm7IOl4jIYDaef4TfzodDIgGWvtEENVxtDB0SUblRYXp8xo8fj99++w2///47bG1tNeN27O3tYWlpCYlEgkmTJmHu3LmoVasWatWqhblz58LKygpDhgwxcPRERGXjQmgiZvyeO3/Zx93qoGNdNwNHRFS+VJjE56effgIAdOjQQat8zZo1GDFiBABg6tSpyMjIwLhx45CUlISWLVvi4MGDsLW1LeNoiYjKXlRyBsZtvASlWqBXQ0+8176GoUMiKncq7Dw+pYXz+BBRRZSZo8JrP5/BjUgF6nnaYcd7rWFlXmG+2xK9sEo/jw8REeUSQmDajmu4EamAk7U5VgwLZNJDVAgmPkREFdzKkw+x+0oUpCYS/G9IU1R1sjJ0SETlFhMfIqIK7MTdOHyz/zYA4Mte/mhdw9nAERGVb0x8iIgqqLD4NLz/WwjUAhjUzBtvtfYxdEhE5R4THyKiCig1S4kx6y9CkalEk2oO+LpfwHNnqSeiXEx8iIgqGLVaYPKWK7gXmwp3OxmWvxkImanU0GERVQhMfIiIKpjvj9zDoVtPYC41wc9vBsLNzsLQIRFVGEx8iIgqkEuPkvD9kXsAgDn9A9CkmqOBIyKqWJj4EBFVEGq1wMw9uY+jeLWpNwY2q2rgiIgqHiY+REQVxLZLEbgeKYetzBTTetQ1dDhEFRITHyKiCkCekYP5B+4AAD7oUguutjIDR0RUMTHxISKqAL4/fA8Jadmo6WaD4W18DR0OUYXFxIeIqJy79yQF686GAQBm9PaHmZR/uon0xf89RETlmBACM/+4CZVaIMjfHS/XcjV0SEQV2gs9vjc9PR3h4eHIzs7WKm/YsOELBUVERLn+uhmD0/cTYG5qgs97+hs6HKIKT6/EJy4uDiNHjsT+/fsLXK5SqV4oKCIiAjJzVPj6z38AAO+0q45qznzqOtGL0utS16RJk5CUlIRz587B0tISBw4cwLp161CrVi3s2bOnpGMkIjJKy088RGRyBjztLfBehxqGDoeoUtCrx+fo0aP4/fff0bx5c5iYmMDHxwddu3aFnZ0d5s2bh549e5Z0nERERuVxUjp+PH4fAPDpK/VgZf5CIxOI6F969fikpaXBzc0NAODk5IS4uDgAQIMGDRASElJy0RERGal5+24jS6lGCz8n9GroaehwiCoNvRKfOnXq4M6d3Im0GjdujOXLlyMyMhI///wzPD35H5SI6EWceRCPvdejYSIBZvauD4lEYuiQiCoNvfpOJ02ahOjoaADAjBkz0K1bN2zcuBHm5uZYu3ZtScZHRGRUlCo1Zu25BQB4s5UP/L3sDBwRUeWiV+IzdOhQzc9NmjRBWFgYbt++jWrVqsHFxaXEgiMiMjYbz4fjzpMUOFiZYUrX2oYOh6jSKZHRclZWVmjatGlJbIqIyGglpmVj4cHcYQQfBdWBg5W5gSMiqnz0SnymTJlSYLlEIoGFhQVq1qyJvn37wsnJ6YWCIyIyJt8dvANFphL1PO3wRotqhg6HqFLSK/G5fPkyQkJCoFKpUKdOHQghcO/ePUilUtStWxc//vgjPvzwQ5w6dQr+/pxplIioKDci5dh0IRwAMKtPfUhNOKCZqDTodVdX37590aVLF0RFReHSpUsICQlBZGQkunbtijfeeAORkZFo164dJk+eXNLxEhFVOkIIzNxzE0IAfRp5oYUfe8uJSotECCGKu1KVKlVw6NChfL05N2/eRFBQECIjIxESEoKgoCDEx8eXWLBlQaFQwN7eHnK5HHZ2vJuCiErf7suRmLTlCizNpDj6UXt42lsaOiSiCkfXz2+9enzkcjliY2PzlcfFxUGhUAAAHBwc8j28lIiItKVmKTF3X+7zuCZ0qsmkh6iU6X2pa9SoUdi1axceP36MyMhI7Nq1C6NHj0a/fv0AABcuXEDt2rwVk4joef537D5iU7JQzckKo1/yM3Q4RJWeXoObly9fjsmTJ+P111+HUqnM3ZCpKYYPH47FixcDAOrWrYtffvml5CIlIqpkQuPTsOpkKADgi17+sDCTGjgiospPrzE+eVJTU/Hw4UMIIVCjRg3Y2NiUZGwGwTE+RFRWRq8NxpHbsWhX2xXrRjbnoymIXkCpjvHJExMTg+joaNSuXRs2NjZ4gRyKiMioHLsdiyO3Y2FqIsGXvfyZ9BCVEb0Sn4SEBHTu3Bm1a9fGK6+8onlu19tvv40PP/ywRAMkIqpsspVqfPVn7vO4Rrb1RU23it9bTlRR6JX4TJ48GWZmZggPD4eVlZWmfPDgwThw4ECJBUdEVBmtOR2K0Pg0uNjIMLFzLUOHQ2RU9BrcfPDgQfz111/w9vbWKq9VqxYePXpUIoEREVVGsYpMLD1yDwAwrUdd2FqYGTgiIuOiV49PWlqaVk9Pnvj4eMhkshcOioiosvrmwG2kZavQuKoDBjSpYuhwiIyOXolPu3btsH79es3vEokEarUaCxYsQMeOHUssOCKiyuTSoyTsDIkEkPs8LhM+j4uozOl1qWvBggXo0KEDLl68iOzsbEydOhU3b95EYmIiTp8+XdIxEhFVeCp17vO4AGBQM280qupg2ICIjJRePT7+/v64du0aWrRoga5duyItLQ0DBgzA5cuXUaNGjZKOkYiowtt2MQLXI+WwlZni4251DR0OkdHSq8cHADw8PDBr1qySjIWIqFKSZ+Rg/l93AAAfdKkFV1uOhSQyFL0Tn8zMTFy7dg2xsbFQq9Vay/r06fPCgRERVRZLDt9FYlo2arrZYHgbX0OHQ2TU9Ep8Dhw4gLfeegvx8fH5lkkkEqhUqhcOjIioMrj7JAXrz+ZO8zGjtz/MpC80YT4RvSC9/gdOmDABAwcORHR0NNRqtdarPCQ9P/74I/z8/GBhYYHAwECcPHnS0CERkRESQmDWHzehUgsE+bvj5Vquhg6JyOjplfjExsZiypQpcHd3L+l4XtiWLVswadIkfPbZZ7h8+TJefvll9OjRA+Hh4YYOjYiMzF83Y3D6fgLMTU3weU9/Q4dDRNAz8Xnttddw/PjxEg6lZCxatAijR4/G22+/jXr16mHJkiWoWrUqfvrpJ0OHRkRGJDNHha///AcA8E676qjmnH/SVyIqe3qN8Vm2bBkGDhyIkydPokGDBjAz055yfeLEiSUSXHFlZ2fj0qVLmDZtmlZ5UFAQzpw5U+A6WVlZyMrK0vyuUChKNUYiMg7LTzxEZHIGPO0t8F4HTvNBVF7olfj89ttv+Ouvv2BpaYnjx49DIvlv9lGJRGKwxCc+Ph4qlSrfJTh3d3fExMQUuM68efN4Wz4RlajHSen48fh9AMCnr9SDlbneN9ASUQnT61LX559/jq+++gpyuRxhYWEIDQ3VvB4+fFjSMRbb04kYkDvA8NmyPNOnT4dcLte8IiIiyiJEIqrE5u27jSylGi39nNCroaehwyGip+j1NSQ7OxuDBw+GiUn5ui3TxcUFUqk0X+9ObGxsoQOxZTIZH6xKRCXmzIN47L0eDRMJMLNP/UK/dBGRYeiVuQwfPhxbtmwp6VhemLm5OQIDA3Ho0CGt8kOHDqFNmzYGioqIjIVSpcasPbcAAG+28kE9TzsDR0REz9Krx0elUmH+/Pn466+/0LBhw3yDmxctWlQiweljypQpGDZsGJo1a4bWrVtjxYoVCA8Px7vvvmuwmIjIOOy+EoU7T1LgYGWGKV1rGzocIiqAXonP9evX0aRJEwDAjRs3tJYZult38ODBSEhIwFdffYXo6GgEBARg37598PHxMWhcRFS5KVVqLDt6DwDwTrsacLAyN3BERFQQiRBCGDqI8kShUMDe3h5yuRx2duymJiLd7Lr8GJO3XIWjlRlOfdIJ1jLeyUVUlnT9/H7h0cmPHz9GZGTki26GiKjCUqkFfjiae/v62y9XZ9JDVI7plfio1Wp89dVXsLe3h4+PD6pVqwYHBwd8/fXX+Z7UTkRU2f15LQoP49Jgb2mGt1rzsjpReabX15LPPvsMq1atwjfffIO2bdtCCIHTp09j5syZyMzMxJw5c0o6TiKickmrt+clP9hamBWxBhEZkl6Jz7p16/DLL7+gT58+mrJGjRqhSpUqGDduHBMfIjIa+65H435sKuwsTDG8ra+hwyGiIuh1qSsxMRF169bNV163bl0kJia+cFBERBWBWi3ww793co1+qTrs2NtDVO7plfg0atQIy5Yty1e+bNkyNGrU6IWDIiKqCA7cjMHdJ6mwtTDFCPb2EFUIel3qmj9/Pnr27InDhw+jdevWkEgkOHPmDCIiIrBv376SjpGIqNxRqwWWHsnt7RnZ1g/2luztIaoI9Orxad++Pe7evYv+/fsjOTkZiYmJGDBgAO7cuYOXX365pGMkIip3Dt6Kwe2YFNjITDG6rZ+hwyEiHek92YSXl1eRg5jHjRuHr776Ci4uLvruhoio3BFC4PsjuXdyjWjjC3sr9vYQVRSl+nj1DRs2QKFQlOYuiIjK3KFbT/BPtALW5lKMfom9PUQVSakmPnwaBhFVNrm9Pblje4a38YWjNZ/JRVSRlGriQ0RU2Rz5JxY3oxSwMpfi7ZerGzocIiomJj5ERDoSQmDpv/P2DGvtAyf29hBVOEx8iIh0dPxOHK49lsPSTIox7O0hqpCY+BAR6UAIgSX/ju15s1U1uNjIDBwREemj2ImPUqnErFmzEBERUWTdN998E3Z2dnoFRkRUnvx9Lx5XI5JhYWaCse1qGDocItJTsRMfU1NTLFiwACqVqsi6P/30E+fwIaIKTwiB7w/fBQAMbekDV1v29hBVVHpd6urSpQuOHz9ewqEQEZVPp+7HIyQ8GTJTE7zTjmN7iCoyvWZu7tGjB6ZPn44bN24gMDAQ1tbWWsv79OlTIsERERlabm9P7tieN1pUg5udhYEjIqIXIRF6zDJoYlJ4R5FEItHpMlh5pVAoYG9vD7lczvFJRIQz9+Mx5JfzMDc1wcmpHeHOxIeoXNL181uvHh+1Wq13YEREFUnenVxvNK/KpIeoEnjh29kzMzNLIg4ionLn3MMEXAhNhLnUBO924J1cRJWBXomPSqXC119/jSpVqsDGxgYPHz4EAHzxxRdYtWpViQZIRGQoeWN7BjX3hqe9pYGjIaKSoFfiM2fOHKxduxbz58+Hufl/U7Y3aNAAv/zyS4kFR0RkKBdCE3H2YQLMpBK816GmocMhohKiV+Kzfv16rFixAkOHDoVUKtWUN2zYELdv3y6x4IiIDGXpv2N7XgusiioO7O0hqiz0SnwiIyNRs2b+b0BqtRo5OTkvHBQRkSFdepSIU/fjYWoiwTiO7SGqVPRKfOrXr4+TJ0/mK9+2bRuaNGnywkERERnSksN5vT3eqOpkZeBoiKgk6XU7+4wZMzBs2DBERkZCrVZj586duHPnDtavX48///yzpGMkIiozIeFJOHkvHlITCcZ35NgeospGrx6f3r17Y8uWLdi3bx8kEgm+/PJL/PPPP/jjjz/QtWvXko6RiKjM5I3tGdCkCnt7iCohvXp8AKBbt27o1q1bScZCRGRQVyKScfxOHKQmEkzoxN4eospIrx6f6tWrIyEhIV95cnIyqlfnA/yIqGL64d/enn6Nq8DH2bqI2kRUEemV+ISFhRX4PK6srCxERka+cFBERGXt+mM5jtyOhYkE7O0hqsSKdalrz549mp//+usv2Nvba35XqVQ4cuQIfH19Syw4IqKy8v2/vT19G1eBnwt7e4gqq2IlPv369QOQ+wT24cOHay0zMzODr68vFi5cWGLBERGVhRuRchz+5wkk7O0hqvSKlfjkPZXdz88PwcHBcHFxKZWgiIjK0g9Hc3t7ejf0Qg1XGwNHQ0SlSa+7ukJDQzU/Z2ZmwsLCosQCIiIqS/9EK/DXzdzenomd2dtDVNnpNbhZrVbz6exEVCnk9fb0bOCJmm62Bo6GiEqbXonP7Nmz+XR2Iqrw7sSkYN/1GADA+51qGTgaIioLfDo7ERmtpf/29rzSwAN1PNjbQ2QM+HR2IjJK956kYN/1aADAxM7s7SEyFnw6OxEZpR+O3ocQQPf6HqjrYWfocIiojPDp7ERkdO7HpuKPa1EAgPd5JxeRUakQT2cPCwvD6NGj4efnB0tLS9SoUQMzZsxAdna2Vr3w8HD07t0b1tbWcHFxwcSJE/PVISJadvQehAC6+rujvpd90SsQUaVRIZ7Ofvv2bajVaixfvhw1a9bEjRs3MGbMGKSlpeG7774DkPvIjJ49e8LV1RWnTp1CQkIChg8fDiEEfvjhhzKJk4jKv4dxqdhzNbe35wOO7SEyOhIhhHiRDaSmpmpmdM5jZ1f618sXLFiAn376STOH0P79+9GrVy9ERETAy8sLALB582aMGDECsbGxOsekUChgb28PuVxeJsdBRGVrytYr2BkSic513bBqRHNDh0NEJUTXz2+9LnWFhoaiZ8+esLa2hr29PRwdHeHo6AgHBwc4OjrqHXRxyOVyODk5aX4/e/YsAgICNEkPkNsrlZWVhUuXLhW6naysLCgUCq0XEVVOYfFp+P3Kv709XdjbQ2SM9LrUNXToUADA6tWr4e7uDolEUqJBFeXBgwf44YcftB6IGhMTA3d3d616jo6OMDc3R0xMTKHbmjdvHmbNmlVqsRJR+fG/Y/ehUgt0rOOKht4Ohg6HiAxAr8Tn2rVruHTpEurUqfNCO585c2aRSUdwcDCaNWum+T0qKgrdu3fHwIED8fbbb2vVLSgBE0I8NzGbPn06pkyZovldoVCgatWquh4CEVUQjxLSsPNyJADO20NkzPRKfJo3b46IiIgXTnwmTJiA119//bl1fH19NT9HRUWhY8eOaN26NVasWKFVz8PDA+fPn9cqS0pKQk5OTr6eoKfJZDLIZLLiB09EFcqSw/egUgu0r+2KJtXK5pI8EZU/eiU+v/zyC959911ERkYiICAAZmZmWssbNmyo03ZcXFzg4uKiU93IyEh07NgRgYGBWLNmDUxMtIcntW7dGnPmzEF0dDQ8PT0BAAcPHoRMJkNgYKBO+yCiyul2jAK7r+T29nzc7cW+sBFRxaZX4hMXF4cHDx5g5MiRmjKJRKK5rKRSqUosQCC3p6dDhw6oVq0avvvuO8TFxWmWeXh4AACCgoLg7++PYcOGYcGCBUhMTMRHH32EMWPG8O4sIiP33V93IUTuE9gDqnDeHiJjplfiM2rUKDRp0gSbNm0qk8HNBw8exP3793H//n14e3trLcu7G18qlWLv3r0YN24c2rZtC0tLSwwZMkQzzw8RGaeQ8CQc/ucJTCTA5K61DR0OERmYXvP4WFtb4+rVqwU+qLSi4zw+RJWHEAJDVp7H2YcJGNTMG/Nfa2TokIiolJTqPD6dOnXC1atX9Q6OiKgsnLofj7MPE2AuNcEHXdjbQ0R6Xurq3bs3Jk+ejOvXr6NBgwb5Bjf36dOnRIIjItKXEAIL/roDAHizlQ+qOFgaOCIiKg/0utT17B1VWhsshcHNZYmXuogqhwM3ovHuhhBYmUvx99SOcLHhtBVElZmun9969fg8+2wuIqLyRKUW+O7gXQDA2y/5MekhIg29xvgQEZVnO0Me435sKhyszPB2u+qGDoeIyhG9E58TJ06gd+/eqFmzJmrVqoU+ffrg5MmTJRkbEVGxZSlVWHL4HgDgvfY1YGdhVsQaRGRM9Ep8NmzYgC5dusDKygoTJ07EhAkTYGlpic6dO+O3334r6RiJiHS26Xw4IpMz4G4nw/A2voYOh4jKGb0GN9erVw9jx47F5MmTtcoXLVqElStX4p9//imxAMsaBzcTVVxpWUq0X3AM8anZmNM/AENb+hg6JCIqI6U6j8/Dhw/Ru3fvfOV9+vRBaGioPpskInpha06HIj41Gz7OVhjUrKqhwyGickivxKdq1ao4cuRIvvIjR46galX+sSGispecno3lfz8EAEzpWhtmUt67QUT56XU7+4cffoiJEyfiypUraNOmDSQSCU6dOoW1a9fi+++/L+kYiYiK9POJh0jJVKKuhy16N/QydDhEVE7plfi899578PDwwMKFC7F161YAueN+tmzZgr59+5ZogERERYlVZGLtmdzL7B93qwMTk9J9cDIRVVx6JT4A0L9/f/Tv378kYyEi0svSo/eQmaNG02oO6FTXzdDhEFE5ptdF8OrVqyMhISFfeXJyMqpX52RhRFR2whPSsflCBABgave6kEjY20NEhdMr8QkLCyvweVxZWVmIjIx84aCIiHS1+PBdKNUC7Wq7olV1Z0OHQ0TlXLEude3Zs0fz819//QV7e3vN7yqVCkeOHIGvr2+JBUdE9Dy3YxTYfSX3y9bHQXUMHA0RVQTFSnz69esHIPcJ7MOHD9daZmZmBl9fXyxcuLDEgiMiep7v/roLIYBXGniggbd90SsQkdErVuKT91R2Pz8/BAcHw8XFpVSCIiIqSkh4Eg7/8wQmEmBKV/b2EJFu9Lqri7MzE5EhCSGw4MAdAMBrgd6o6WZj4IiIqKLQa3DzxIkTsXTp0nzly5Ytw6RJk140JiKi5zp1Px5nHybAXGqCD7rUNnQ4RFSB6JX47NixA23bts1X3qZNG2zfvv2FgyIiKowQAgv+yu3tGdqqGqo4WBo4IiKqSPRKfBISErTu6MpjZ2eH+Pj4Fw6KiKgwf92MwbXHcliZSzG+Y01Dh0NEFYxeiU/NmjVx4MCBfOX79+/nBIZEVGpUaoHvDt4FALz9kh9cbGQGjoiIKhq9BjdPmTIFEyZMQFxcHDp16gQg98nsCxcuxJIlS0oyPiIijZ0hj3E/NhUOVmZ4ux2/ZBFR8emV+IwaNQpZWVmYM2cOvv76awCAr68vfvrpJ7z11lslGiAREQBkKVVYcvgeAOC99jVgZ2Fm4IiIqCLS+yGl7733Ht577z3ExcXB0tISNja8nZSISs+m8+GITM6Au50Mw9v4GjocIqqg9E588ri6upZEHEREhUrLUmLZsfsAgImda8HCTGrgiIiootI78dm+fTu2bt2K8PBwZGdnay0LCQl54cCIiPKsOR2K+NRs+DhbYVCzqoYOh4gqML3u6lq6dClGjhwJNzc3XL58GS1atICzszMePnyIHj16lHSMRGTEktOzsfzvhwCAKV1rw0yq158tIiIAeiY+P/74I1asWIFly5bB3NwcU6dOxaFDhzBx4kTI5fKSjpGIjNjPJx4iJVOJuh626N3Qy9DhEFEFp1fiEx4ejjZt2gAALC0tkZKSAgAYNmwYNm3aVHLREZFRi1VkYu2Z3GcDfhRUByYmEgNHREQVnV6Jj4eHBxISEgAAPj4+OHfuHIDch5cKIUouOiIyakuP3kNmjhpNqzmgcz03Q4dDRJWAXolPp06d8McffwAARo8ejcmTJ6Nr164YPHgw+vfvX6IBEpFxCk9Ix+YLEQCAqd3rQiJhbw8RvTi97upasWIF1Go1AODdd9+Fk5MTTp06hd69e+Pdd98t0QCJyDgtPnwXSrVAu9quaFXd2dDhEFElUezER6lUYs6cORg1ahSqVs29rXTQoEEYNGhQiQdHRMbpdowCu69EAgA+Dqpj4GiIqDIp9qUuU1NTLFiwACqVqjTiISLCd3/dhRDAKw080MDb3tDhEFElotcYny5duuD48eMlHAoRERASnoTD/zyBiQSY0pW9PURUsvQa49OjRw9Mnz4dN27cQGBgIKytrbWW9+nTp0SCIyLjIoTAggN3AACvNvVGTTc+A5CISpZE6HH/uYlJ4R1FEomkQl8GUygUsLe3h1wuh52dnaHDITIqJ+/FYdiqCzCXmuDYxx1QxcHS0CERUQWh6+e3Xj0+eXd0ERGVFCEEFvyV29sztFU1Jj1EVCp0HuPj5OSE+Ph4AMCoUaM0szUTEZWEv27G4NpjOazMpRjfsaahwyGiSkrnxCc7OxsKhQIAsG7dOmRmZpZaUERkXFRqge8O3gUAjH7JDy42MgNHRESVlc6Xulq3bo1+/fohMDAQQghMnDgRlpYFd0WvXr26xAJ8VlZWFlq2bImrV6/i8uXLaNy4sWZZeHg4xo8fj6NHj8LS0hJDhgzBd999B3Nz81KLh4he3NozYbgfmwoHKzOMaVfd0OEQUSWmc+KzYcMGLF68GA8ePAAAyOVyg/T6TJ06FV5eXrh69apWuUqlQs+ePeHq6opTp04hISEBw4cPhxACP/zwQ5nHSUS6uR+bivkHbgMAPu5WB3YWZgaOiIgqM50TH3d3d3zzzTcAAD8/P/z6669wdi7baeT379+PgwcPYseOHdi/f7/WsoMHD+LWrVuIiIiAl5cXAGDhwoUYMWIE5syZwzu0iMohpUqND7deQZZSjfa1XTGkRTVDh0RElZxeg5s7duxY5pePnjx5gjFjxuDXX3+FlZVVvuVnz55FQECAJukBgG7duiErKwuXLl0qdLtZWVlQKBRaLyIqGz8ef4Crj+WwszDFt6825INIiajUVYjBzUIIjBgxAu+++y6aNWtWYJ2YmBi4u7trlTk6OsLc3BwxMTGFbnvevHmwt7fXvPKeP0ZEpetGpBxLj9wDAHzdLwAe9hYGjoiIjIFBBzfPnDkTs2bNem6d4OBgnDlzBgqFAtOnT39u3YK+LQohnvstcvr06ZgyZYrmd4VCweSHqJRl5qgwZesVKNUCrzTwQJ9GXkWvRERUAvQa3CyRSEpkcPOECRPw+uuvP7eOr68vZs+ejXPnzkEm077FtVmzZhg6dCjWrVsHDw8PnD9/Xmt5UlIScnJy8vUEPU0mk+XbLhGVrsWH7uLuk1S42Mgwu18DXuIiojKj1yMr/Pz8cPHixTIb3BweHq419iYqKgrdunXD9u3b0bJlS3h7e2P//v3o1asXHj9+DE9PTwDAli1bMHz4cMTGxuo8uJmPrCAqXcFhiRi0/CyEAH55qxm6+Bf+xYSISFel+siK0NBQvQPTR7Vq2nd62NjkPriwRo0a8Pb2BgAEBQXB398fw4YNw4IFC5CYmIiPPvoIY8aMYQJDVE6kZSnx4darEAIYGOjNpIeIypzOic/SpUsxduxYWFhYYOnSpc+tO3HixBcOrLikUin27t2LcePGoW3btloTGBJR+TB33z8IT0xHFQdLfNnb39DhEJER0vlS19OXt/z8/ArfoESChw8flliAZY2XuohKx4m7cRi++gIA4LcxLdGmhouBIyKiyqTEL3U9fXmrrC91EVHFJk/PwdTtubOtj2jjy6SHiAxG58Tn6Vu+n0cikWDhwoV6B0RElc+MPTfwRJGF6i7W+KR7XUOHQ0RGTOfE5/Lly1q/X7p0CSqVCnXq1AEA3L17F1KpFIGBgSUbIRFVaPuvR2P3lSiYSICFgxrB0lxq6JCIyIjpnPgcO3ZM8/OiRYtga2uLdevWwdHREUDunDkjR47Eyy+/XPJRElGFFJeShU93XQcAjOtQE02qORo4IiIydnrN41OlShUcPHgQ9evX1yq/ceMGgoKCEBUVVWIBljUObiYqGUIIjFl/CYf/eQJ/TzvsHt8W5qY6PyWHiKhYdP381uuvkEKhwJMnT/KVx8bGIiUlRZ9NElEls/3SYxz+5wnMpSZYNLgRkx4iKhf0+kvUv39/jBw5Etu3b8fjx4/x+PFjbN++HaNHj8aAAQNKOkYiqmAeJ6Xjqz9uAQAmd62Nuh7sPSWi8kGvmZt//vlnfPTRR3jzzTeRk5OTuyFTU4wePRoLFiwo0QCJqGJRqwU+3nYNKVlKBPo4Ymy76oYOiYhIQ68xPnnS0tLw4MEDCCFQs2ZNWFtbl2RsBsExPkQvZs3pUMz64xYszaTY/8HL8HWp+H8XiKj8K9VndeWxtrZGw4YNX2QTRFSJPIhLxTf7bwMAPn2lLpMeIip3ONqQiEqEUqXGlK1XkaVU4+VaLnizlY+hQyIiyoeJDxGViJ9PPMDViGTYWphi/msNIZFIDB0SEVE+THyI6IXdjJLj+yP3AACz+tSHp72lgSMiIioYEx8ieiFZShWmbLmKHJVAt/ru6N+kiqFDIiIqFBMfInohiw/dw50nKXC2Nsfc/g14iYuIyjUmPkSkt0uPErHi7wcAgLkDGsDZRmbgiIiIno+JDxHpJT1biSlbr0ItgAFNq6BbfQ9Dh0REVCQmPkSkl3n7buNRQjo87S0wo3f9olcgIioHmPgQUbGdvBeHX889AgAseK0R7C3NDBwREZFumPgQUbHIM3Lw8bZrAIC3WvvgpVouBo6IiEh3THyIqFhm7bmJGEUmfJ2tMK1HXUOHQ0RULEx8iEhnB27EYOflSJhIgIWDGsPK/IUe90dEVOaY+BCRTuJTs/DZrusAgHfa10Cgj6OBIyIiKj4mPkRUJCEEPt15HQlp2ajrYYtJXWoZOiQiIr0w8SGiIu0MicTBW09gJpVg0aDGkJlKDR0SEZFemPgQ0XM9SkjDzD9uAgAmdakNfy87A0dERKQ/Jj5EVKiIxHQMWXkeKZlKNKnmgHfaVTd0SEREL4SJDxEVKDI5A0N+OYfI5AxUd7XG8mGBMJXyTwYRVWz8K0ZE+cTIMzFk5TlEJGbA19kKm8a0gputhaHDIiJ6YUx8iEhLrCITb6w8h0cJ6ajmZIVNY1vB3Y5JDxFVDkx8iEgjLiULb6w8h9D4NFRxsMRvY1rC097S0GEREZUYJj5EBCB3gsIhK8/hQVwavOwtsHlsK3g7Whk6LCKiEsXEh4iQmJaNN385j3uxqfCws8Cmsa1Q1YlJDxFVPkx8iIxccnpu0nM7JgVutjL8NqYlfJytDR0WEVGpYOJDZMTkGTkYtuoCbkUr4GIjw29jWqG6q42hwyIiKjVMfIiMlCIzB2+tvoDrkXI4W5vjtzEtUdONSQ8RVW5MfIiMUGqWEiNWX8DViGQ4Wplh45iWqO1ua+iwiIhKHRMfIiOTlqXEyDUXEBKeDHtLM2x4uyXqevD5W0RkHJj4EBmR9GwlRq0NRnBYEmwtTLFhdEvU97I3dFhERGWGiQ+RkcjIVuHtdRdxPjQRtjJT/Dq6JRp4M+khIuPCxIfICGTmqDD214s48yAB1uZSrB3VAo2rOhg6LCKiMsfEh6iSy1Kq8O6GSzh5Lx5W/yY9gT6Ohg6LiMggKlTis3fvXrRs2RKWlpZwcXHBgAEDtJaHh4ejd+/esLa2houLCyZOnIjs7GwDRUtkeNlKNcZtCMHxO3GwMDPB6hHN0dzXydBhEREZjKmhA9DVjh07MGbMGMydOxedOnWCEALXr1/XLFepVOjZsydcXV1x6tQpJCQkYPjw4RBC4IcffjBg5ESGkaNSY8JvIThyOxYyUxOsHt4crao7GzosIiKDkgghhKGDKIpSqYSvry9mzZqF0aNHF1hn//796NWrFyIiIuDl5QUA2Lx5M0aMGIHY2FjY2el2u65CoYC9vT3kcrnO6xCVN0qVGhM3X8a+6zEwNzXBL281Q7varoYOi4io1Oj6+V0hLnWFhIQgMjISJiYmaNKkCTw9PdGjRw/cvHlTU+fs2bMICAjQJD0A0K1bN2RlZeHSpUuFbjsrKwsKhULrRVSRKVVqTN56NTfpkZpg+bBAJj1ERP+qEInPw4cPAQAzZ87E559/jj///BOOjo5o3749EhMTAQAxMTFwd3fXWs/R0RHm5uaIiYkpdNvz5s2Dvb295lW1atXSOxCiUqZSC3y07Sr+uBoFM6kEPw5tio513AwdFhFRuWHQxGfmzJmQSCTPfV28eBFqtRoA8Nlnn+HVV19FYGAg1qxZA4lEgm3btmm2J5FI8u1DCFFgeZ7p06dDLpdrXhERESV/oERlQK0WmLr9GnZfiYKpiQTLhjRFF3/3olckIjIiBh3cPGHCBLz++uvPrePr64uUlBQAgL+/v6ZcJpOhevXqCA8PBwB4eHjg/PnzWusmJSUhJycnX0/Q02QyGWQymb6HQFQuqNUC03dex46Qx5CaSLD0jSboVt/D0GEREZU7Bk18XFxc4OLiUmS9wMBAyGQy3LlzBy+99BIAICcnB2FhYfDx8QEAtG7dGnPmzEF0dDQ8PT0BAAcPHoRMJkNgYGDpHQSRgQkh8PnvN7DlYgRMJMDiwY3xSgNPQ4dFRFQuVYjb2e3s7PDuu+9ixowZqFq1Knx8fLBgwQIAwMCBAwEAQUFB8Pf3x7Bhw7BgwQIkJibio48+wpgxY3h3FlVaQgjM2HMTv50Ph0QCLBzUCH0aeRW9IhGRkaoQiQ8ALFiwAKamphg2bBgyMjLQsmVLHD16FI6OuTPQSqVS7N27F+PGjUPbtm1haWmJIUOG4LvvvjNw5ESl44kiE1O3X8OJu3GQSIAFrzVC/ybehg6LiKhcqxDz+JQlzuNDFcEfV6Pw+e4bkGfkwNzUBHP7N8BrgUx6iMh46fr5XWF6fIgISE7Pxpe/38Seq1EAgIAqdlg8qDFqudsaODIiooqBiQ9RBXHibhymbr+KJ4osSE0kGN+xJt7vVBNm0goxHRcRUbnAxIeonEvPVmLuvn+w4Vzu1A3VXayxaHBjNK7qYNjAiIgqICY+ROXYpUdJ+HDrFYQlpAMARrTxxSfd68LSXGrgyIiIKiYmPkTlULZSje+P3MVPxx9ALQBPewsseK0RXqpV9LxXRERUOCY+ROXM7RgFJm+5in+icx+YO6BJFczoUx/2lmYGjoyIqOJj4kNUTqjUAr+cfIiFB+8iW6WGo5UZ5vZvgB6chZmIqMQw8SEqByIS0/Hh1qu4EJYIAOhc1w3zXm0AN1sLA0dGRFS5MPEhMiAhBLYER+DrP28hLVsFa3Mpvuztj0HNqkIikRg6PCKiSoeJD5GBxKZkYvqO6zhyOxYA0MLXCd8NbIRqzlYGjoyIqPJi4kNkAPuvR+PTXdeRlJ4Dc6kJPupWG6Nfqg6pCXt5iIhKExMfojIkz8jBzD03setyJADA39MOiwc3Rh0PPnKCiKgsMPEhKiOn7sXj4+1XES3PhIkEGNehJiZ2rgVzUz5ygoiorDDxISplGdkqfHvgNtaeCQMA+DpbYeGgxgj0cTRsYERERoiJD1EpuhKRjClbruBhfBoAYFgrH0x/pS6szPlfj4jIEPjXl6gU3I5RYPmJh9hzNQoqtYC7nQzzX2uE9rVdDR0aEZFRY+JDVEKEEDgfmoifTzzA8TtxmvI+jbzwdd8A2FvxkRNERIbGxIfoBanVAgdvxeDnEw9xJSIZAGAiAXo08MQ77aqjobeDQeMjIqL/MPEh0lOWUoVdIZFY8fdDzRgec1MTDAz0xpiXq8PXxdrAERIR0bOY+BAVkyIzBxvPhWP16VDEpWQBAOwsTPFWa18Mb+MLV1uZgSMkIqLCMPEh0tETRSZWnw7Fb+fCkZKlBAB42ltg9Et+eL1FNdjI+N+JiKi8419qoiI8iEvFihMPsetyJLJVagBALTcbvNO+Bvo08uIEhEREFQgTH6JChIQn4efjD3DonycQIresua8j3m1fAx3ruMGEz9UiIqpwmPgQPUUIgWN3YvHziYe4EJqoKe/q745321dHoI+TAaMjIqIXxcSHCECOSo0/rkZh+YmHuPMkBQBgJpWgX+MqeKd9ddR040NEiYgqAyY+ZNTSspTYHByBVScfIkqeCQCwkZliSMtqGNXWDx72FgaOkIiIShITHzJKD+NSsetyJNaffQR5Rg4AwMVGhlEv+WJoSx/YW3KWZSKiyoiJDxkFtVrgckQyDt16gkO3YvAgLk2zzM/FGmPbVUf/JlVgYSY1YJRERFTamPhQpZWZo8Lp+/E4dOsJDv8Ti/jULM0yM6kErao7Y0iLagiq7wEp79AiIjIKTHyoUklKy8aR27E4dCsGf9+NR0aOSrPMVmaKDnXdEOTvjvZ1XGFnwctZRETGhokPVXiPEtJw6NYTHLz1BBfDEqEW/y3ztLdAV393dPV3R0s/Z042SERk5Jj4UIWjVgtcj5Tj4K0YHLr1BHefpGotr+dph67+7gjyd0d9LztIJLyMRUREuZj4UIWQpVTh7IOEf8frPMETxX/jdaQmErT0c0JXf3d0qeeOqk5WBoyUiIjKMyY+VG7J03Nw7E4sDt16ghN345D674NBAcDaXIr2dVwR5O+BjnXcYG/F8TpERFQ0Jj5ULgghECXPxI1IOW5EynExLAnBYYlQPjVgx81Whi7/jtdpU8MZMlPeek5ERMXDxIfKnBACEYkZuBElx/V/E52bUQokpmXnq1vb3ebfwckeaFjFng8GJSKiF8LEh0qVWi0QlpCGG1EKTW/OjUg5FJnKfHVNTSSo5W6LAC87NPC2R/varvBxtjZA1EREVFkx8aESo1ILPIxLxY0oOW5EKnA9Uo5bUQqtsTl5zKUmqONhi4AqdgioYo8AL3vU8bDlzMlERFSqmPiQXpQqNe7FpmouU+UlOU9PGJhHZmqCep52CKhihwZV7FHfyx613W05pw4REZU5Jj5UIJVaIC4lC9HyDMTIMxEtz0S0PAPR8kxEJKbjdkwKspTqfOtZmklR3+vfXpwq9gioYoearjYwlTLJISIiw2PiY4RyVGo8UWRqEhrNv4oMze+xKVlQPT0FcgFsZKaaJKfBv0mOn4sNn3tFRETlFhOfSiZLqcIT+b89NYqnE5v/em7iUrMgnp/TAMidGNDdVgZPB0t42FvA084CHvYW8HKwRD1PO/g4WfEuKyIiqlAqTOJz9+5dfPzxxzh9+jSys7PRoEEDzJ49Gx07dtTUCQ8Px/jx43H06FFYWlpiyJAh+O6772Bubm7AyHMlpWUjNUuJzBwVMnPUyFSq/vs559+flWpk5TxTrny6ztN1tcuz/i3LUemQ0SD36eS5ycy/SY29xVP/WsLT3gIuNjL23hARUaVSYRKfnj17onbt2pqkZsmSJejVqxcePHgADw8PqFQq9OzZE66urjh16hQSEhIwfPhwCCHwww8/GDp8TNx8GSfvxZfJvmSmJvBysISHXcEJjYe9BZyszNlbQ0RERkcihC4XPQwrPj4erq6u+Pvvv/Hyyy8DAFJSUmBnZ4fDhw+jc+fO2L9/P3r16oWIiAh4eXkBADZv3owRI0YgNjYWdnZ2Ou1LoVDA3t4ecrlc53V08c6vF/H33XhYmJnAwkwKCzMpZKZ5P//7r6lUe7mZyb9lT5f/VyYrYD1rc1PYWZrywZxERGRUdP38rhA9Ps7OzqhXrx7Wr1+Ppk2bQiaTYfny5XB3d0dgYCAA4OzZswgICNAkPQDQrVs3ZGVl4dKlS1qXxJ6WlZWFrKz/HnipUChK5RiWD2tWKtslIiIi3VWIxEcikeDQoUPo27cvbG1tYWJiAnd3dxw4cAAODg4AgJiYGLi7u2ut5+joCHNzc8TExBS67Xnz5mHWrFmlGT4RERGVEwadXGXmzJmQSCTPfV28eBFCCIwbNw5ubm44efIkLly4gL59+6JXr16Ijo7WbK+gyztCiOde9pk+fTrkcrnmFRERUSrHSkRERIZn0B6fCRMm4PXXX39uHV9fXxw9ehR//vknkpKSNNftfvzxRxw6dAjr1q3DtGnT4OHhgfPnz2utm5SUhJycnHw9QU+TyWSQyWQvfjBERERU7hk08XFxcYGLi0uR9dLT0wEAJibaHVQmJiZQq3NnD27dujXmzJmD6OhoeHp6AgAOHjwImUymGQdERERExq1CPEegdevWcHR0xPDhw3H16lXNnD6hoaHo2bMnACAoKAj+/v4YNmwYLl++jCNHjuCjjz7CmDFjSvTuLCIiIqq4KkTi4+LiggMHDiA1NRWdOnVCs2bNcOrUKfz+++9o1KgRAEAqlWLv3r2wsLBA27ZtMWjQIPTr1w/fffedgaMnIiKi8qJCzONTlkprHh8iIiIqPbp+fleIHh8iIiKiksDEh4iIiIxGhZjAkIiIqKRERUVh//79MDExgaenJ7p37w4AOH36NO7cuQMHBwf07dsXKpUKmzZtglqthkwmw6uvvqqZ/iQlJQXff/89xo0bBycnJ63th4aG4ujRozA1NUX//v1hZ2eHBw8e4NixYzA1NcUrr7wCNzc3rXViY2Px559/Ash9NqW7uzuOHz+O27dvw8LCAnXq1EHr1q211tm8eTPCwsIwaNAgVK9eHQCwdu1azfL27dvDz89Pa51ly5bBxsZGsx9XV1ecO3cON27cAJD7xIOqVatq6mdnZxf7HBR2fh88eIBTp05BrVajW7du8PLywurVq2FiYgKJRIJXX30VNjY22Lx5MzIyMiCVStGvXz/Y2dnpdH7q16+v0/sPQVrkcrkAIORyuaFDISKiUpCSkiKys7OFEELs3LlTxMTEiNTUVLFhwwYhhBAnT54UN27cEDk5OUKhUAghhLh06ZI4d+6cZhsHDx4Ua9asEQkJCfm2v3btWpGZmSkiIiLEn3/+KYQQYvXq1SIrK0soFAqxZcuWfOts3rxZJCcnC7lcLjZt2iSEEOLYsWPiwYMHhR6HQqHIV2fNmjVCpVIVus6qVavylf38889CrVaLpKQksXnzZq1l+pyDgs5vdna22LJlS77YlEqlEEKIy5cvi1OnTgkhhEhMTBRCCPHgwQNx4MABIYRu50fXz29e6iIiIqNiY2MDMzMzALkz/puYmCAyMhK+vr4AgOrVq+Px48cwNTWFra2tVj0ASEtLQ1ZWluaRSU/LycmBqakpZDIZvL29ER8fr1lmbm4OW1tbJCYm5lsvIyMD9vb2sLOzQ2Zmpqb88OHDWL9+fYGPXsqL7WkSiQTr16/H9u3bkZGRAQC4cuUKoqKiNPtZs2YN/vjjDyiVSgCAk5MTlEolMjMzYWlpqbWOPuegoPP7+PFjSCQSbNy4Ebt27UJ2djaA3DuyAUCpVGp6wRwdHfPtT5/zUxgmPkREZJSePHmC9PR0uLq6IjMzU3MJx8LCQuvDNTs7GyEhIWjQoAEA4Ny5c2jRokWB28zIyNB6GkDeJLsAkJqaivj4eK1kKI946gbrvJ9btmyJsWPHomfPnti/f79OxzRo0CCMGDECderUwd9//w0AaNy4seYB3qNGjcLIkSPh4OCAS5cuAQD8/Pzwv//9D7/99htatmyZb53inoM8T5/f1NRUpKamYujQofD29tbsOykpCatWrcKFCxe0Lv+p1WqcPHlSMwFxSZ0fgIkPEREZoYyMDOzbtw99+vQBkJvsZGVlAQCysrJgYWEBIPdD9vfff0enTp00CZFCodD6kE5LS8PatWuxdu1aWFpaarYD/PcMyaCgIOzYsQMnT57UjKFZv3491q5di9TUVK1nSub9nNf74uzsrPNx5a1Tt25dxMbGFrk8KysLly9fxvvvv4/Ro0fj8OHD+dbR5Rw8q6DzW7VqVZiYmMDPzw9xcXEAcnt3Ro8ejQ4dOuDMmTOa9Q8ePIhGjRppxg6V1PkBOLg5n7xMUqFQGDgSIiIqDWq1Gr///jvatGkDtVoNhUIBOzs7nDt3Dg0aNMCtW7fg5OQEhUKBM2fOwNXVFc7OzlAoFIiOjkZcXBzWrl2L+Ph4JCYm4rXXXsOAAQMA5H7gZ2ZmapbZ29tDoVDA1tYW/fv3R3JyMkJCQqBQKNCvXz9NPKampoiMjIREIoFUKoVCoUBWVhZkMhkyMjKQk5NT4OdSVlYW0tLSNMvy1nn06BFsbGy01lGpVBBCwNTUFHfv3oWVlRVSUlJgYmKCtLQ05OTkID09Pd9+dD0Hzzu/tra2iImJgUKhQGhoKKysrJCUlKQZ2KxSqTR1b9y4gezsbPj5+WliKc75EUVMT8gJDJ/x+PFjrRHtRERUuQQEBKBHjx6aXofDhw/j8ePHaNu2LerUqQO5XI7du3fDysoKkyZNQkREBADgxo0buHjxomY7/fr1w99//51vzE716tXRsWNHKJVK7N69G3K5HC+//DKqV6+OjIwM/Pnnn5pnUOZxd3fXPIJp3759iImJQa9eveDm5gaJRILDhw/j0aNHWuu88sorqFWrFjIzM3Hx4kVcunQJY8eORU5OjmbfKSkpaNy4MZ48eQKFQoE333wT2dnZyMjIwM6dO5GdnY2XX34ZtWvXhomJCU6cOIG7d+9q1klNTdX5HLz00ku4evUqfHx8Cjy/rVq1Qr169ZCTk4MdO3bA3NwcAwYMgFqthkqlwu7du5GamorPP/8ckZGREEIgLCwMx48fL9b5iYiIgLe3d6HvPxOfZ6jVakRFRcHW1lara+1FKRQKVK1aFREREUY7I7SxnwNjP36A54DHb9zHD/AclObxCyGQkpICLy+vfA81fxovdT3DxMTkuZnii7KzszPKxv40Yz8Hxn78AM8Bj9+4jx/gOSit47e3ty+yDgc3ExERkdFg4kNERERGg4lPGZHJZJgxY4bW/A7GxtjPgbEfP8BzwOM37uMHeA7Kw/FzcDMREREZDfb4EBERkdFg4kNERERGg4kPERERGQ0mPkRERGQ0mPiUkR9//BF+fn6wsLBAYGAgTp48aeiQSsW8efPQvHlz2Nraws3NDf369cOdO3e06owYMQISiUTr1apVKwNFXLJmzpyZ79g8PDw0y4UQmDlzJry8vGBpaYkOHTrg5s2bBoy45Pn6+uY7BxKJBOPHjwdQ+d7/v//+G71794aXlxckEgl2796ttVyX9zwrKwvvv/8+XFxcYG1tjT59+uDx48dleBQv5nnnICcnB5988gkaNGgAa2treHl54a233kJUVJTWNjp06JCvXbz++utlfCT6KaoN6NLmK3IbKOr4C/p7IJFIsGDBAk2dsnz/mfiUgS1btmDSpEn47LPPcPnyZbz88svo0aMHwsPDDR1aiTtx4gTGjx+Pc+fO4dChQ1AqlQgKCkJaWppWve7duyM6Olrz2rdvn4EiLnn169fXOrbr169rls2fPx+LFi3CsmXLEBwcDA8PD3Tt2hUpKSkGjLhkBQcHax3/oUOHAAADBw7U1KlM739aWhoaNWqEZcuWFbhcl/d80qRJ2LVrFzZv3oxTp04hNTUVvXr1gkqlKqvDeCHPOwfp6ekICQnBF198gZCQEOzcuRN3797VPLX7aWPGjNFqF8uXLy+L8F9YUW0AKLrNV+Q2UNTxP33c0dHRWL16NSQSCV599VWtemX2/gsqdS1atBDvvvuuVlndunXFtGnTDBRR2YmNjRUAxIkTJzRlw4cPF3379jVcUKVoxowZolGjRgUuU6vVwsPDQ3zzzTeasszMTGFvby9+/vnnMoqw7H3wwQeiRo0aQq1WCyEq9/sPQOzatUvzuy7veXJysjAzMxObN2/W1ImMjBQmJibiwIEDZRZ7SXn2HBTkwoULAoB49OiRpqx9+/bigw8+KN3gykBBx19Um69MbUCX979v376iU6dOWmVl+f6zx6eUZWdn49KlSwgKCtIqDwoKwpkzZwwUVdmRy+UAACcnJ63y48ePw83NDbVr18aYMWMQGxtriPBKxb179+Dl5QU/Pz+8/vrrePjwIQAgNDQUMTExWm1BJpOhffv2lbYtZGdnY8OGDRg1apTWQ38r8/v/NF3e80uXLiEnJ0erjpeXFwICAiptu5DL5ZBIJHBwcNAq37hxI1xcXFC/fn189NFHlaon9Hlt3pjawJMnT7B3716MHj0637Kyev/5kNJSFh8fD5VKBXd3d61yd3d3xMTEGCiqsiGEwJQpU/DSSy8hICBAU96jRw8MHDgQPj4+CA0NxRdffIFOnTrh0qVLFX4205YtW2L9+vWoXbs2njx5gtmzZ6NNmza4efOm5v0uqC08evTIEOGWut27dyM5ORkjRozQlFXm9/9ZurznMTExMDc3h6OjY746lfFvRGZmJqZNm4YhQ4ZoPaRy6NCh8PPzg4eHB27cuIHp06fj6tWrmkulFVlRbd6Y2sC6detga2uLAQMGaJWX5fvPxKeMPP1tF8hNCp4tq2wmTJiAa9eu4dSpU1rlgwcP1vwcEBCAZs2awcfHB3v37s33n6Gi6dGjh+bnBg0aoHXr1qhRowbWrVunGcxoTG1h1apV6NGjB7y8vDRllfn9L4w+73llbBc5OTl4/fXXoVar8eOPP2otGzNmjObngIAA1KpVC82aNUNISAiaNm1a1qGWKH3bfGVsA6tXr8bQoUNhYWGhVV6W7z8vdZUyFxcXSKXSfFl7bGxsvm+Blcn777+PPXv24NixY/D29n5uXU9PT/j4+ODevXtlFF3Zsba2RoMGDXDv3j3N3V3G0hYePXqEw4cP4+23335uvcr8/uvynnt4eCA7OxtJSUmF1qkMcnJyMGjQIISGhuLQoUNavT0Fadq0KczMzCplu3i2zRtLGzh58iTu3LlT5N8EoHTffyY+pczc3ByBgYH5uusOHTqENm3aGCiq0iOEwIQJE7Bz504cPXoUfn5+Ra6TkJCAiIgIeHp6lkGEZSsrKwv//PMPPD09Nd24T7eF7OxsnDhxolK2hTVr1sDNzQ09e/Z8br3K/P7r8p4HBgbCzMxMq050dDRu3LhRadpFXtJz7949HD58GM7OzkWuc/PmTeTk5FTKdvFsmzeGNgDk9gAHBgaiUaNGRdYt1fe/TIZQG7nNmzcLMzMzsWrVKnHr1i0xadIkYW1tLcLCwgwdWol77733hL29vTh+/LiIjo7WvNLT04UQQqSkpIgPP/xQnDlzRoSGhopjx46J1q1biypVqgiFQmHg6F/chx9+KI4fPy4ePnwozp07J3r16iVsbW017/U333wj7O3txc6dO8X169fFG2+8ITw9PSvFsT9NpVKJatWqiU8++USrvDK+/ykpKeLy5cvi8uXLAoBYtGiRuHz5suaOJV3e83fffVd4e3uLw4cPi5CQENGpUyfRqFEjoVQqDXVYxfK8c5CTkyP69OkjvL29xZUrV7T+LmRlZQkhhLh//76YNWuWCA4OFqGhoWLv3r2ibt26okmTJhXiHDzv+HVt8xW5DRT1f0AIIeRyubCyshI//fRTvvXL+v1n4lNG/ve//wkfHx9hbm4umjZtqnV7d2UCoMDXmjVrhBBCpKeni6CgIOHq6irMzMxEtWrVxPDhw0V4eLhhAy8hgwcPFp6ensLMzEx4eXmJAQMGiJs3b2qWq9VqMWPGDOHh4SFkMplo166duH79ugEjLh1//fWXACDu3LmjVV4Z3/9jx44V2OaHDx8uhNDtPc/IyBATJkwQTk5OwtLSUvTq1atCnZPnnYPQ0NBC/y4cO3ZMCCFEeHi4aNeunXBychLm5uaiRo0aYuLEiSIhIcGwB6aj5x2/rm2+IreBov4PCCHE8uXLhaWlpUhOTs63flm//xIhhCj5fiQiIiKi8odjfIiIiMhoMPEhIiIio8HEh4iIiIwGEx8iIiIyGkx8iIiIyGgw8SEiIiKjwcSHiIiIjAYTHyIiIjIaTHyIiAB06NABkyZNMnQYRFTKOHMzERGAxMREmJmZwdbW1tChEFEpYuJDRERERoOXuoio0ujQoQMmTJiACRMmwMHBAc7Ozvj888+R9/3uxx9/RK1atWBhYQF3d3e89tprWuvyUhdR5Wdq6ACIiErSunXrMHr0aJw/fx4XL17E2LFj4ePjgyZNmmDixIn49ddf0aZNGyQmJuLkyZOGDpeIyhgTHyKqVKpWrYrFixdDIpGgTp06uH79OhYvXozZs2fD2toavXr1gq2trSYZIiLjwktdRFSptGrVChKJRPN769atce/ePXTu3Bk+Pj6oXr06hg0bho0bNyI9Pd2AkRKRITDxISKjYGNjg5CQEGzatAmenp748ssv0ahRIyQnJxs6NCIqQ0x8iKhSOXfuXL7fa9WqBalUClNTU3Tp0gXz58/HtWvXEBYWhqNHjxooUiIyBI7xIaJKJSIiAlOmTME777yDkJAQ/PDDD1i4cCH+/PNPPHz4EO3atYOjoyP27dsHtVqNOnXqGDpkIipDTHyIqFJ56623kJGRgRYtWkAqleL999/H2LFjcfr0aezcuRMzZ85EZmYmatWqhU2bNqF+/fqGDpmIyhAnMCSiSqNDhw5o3LgxlixZYuhQiKic4hgfIiIiMhpMfIiIiMho8FIXERERGQ32+BAREZHRYOJDRERERoOJDxERERkNJj5ERERkNJj4EBERkdFg4kNERERGg4kPERERGQ0mPkRERGQ0/g9OJHAaijEmsAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHgCAYAAACl7mduAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACRH0lEQVR4nOzdd1hTZxsG8PskQNh7yxIREBEH7r0Xbltrbd3VtmqtVuvocNVVd7XDOqptbbWuWheKCm5Rwb1wsAVkE2ZCkvf7A8lnZBgQOIQ8v+vK1XrmncOBPDnnPe/LMcYYCCGEEEK0gIDvAIQQQgghNYUKH0IIIYRoDSp8CCGEEKI1qPAhhBBCiNagwocQQgghWoMKH0IIIYRoDSp8CCGEEKI1qPAhhBBCiNagwocQQgghWoMKH0IIIYRoDSp8iFa4fv06xo0bB1dXV4hEIlhZWSEgIAAXLlyokf0vWbIEPj4+UCgUymnBwcGYMGECvL29YWRkhHr16mHw4MEIDw9XWTc7Oxtz5sxB7969YWNjA47jsGjRojL3lZOTgxkzZsDR0RH6+vpo1qwZ9uzZo7LM9u3bUa9ePeTm5lbp+6wKixYtAsdxai2blZUFgUCADRs2VOly69evVzNt9SjtfKnoeVCT1D2X1aXOOQzU7vOY1F5U+JA679tvv0Xbtm0RHx+PJUuW4MSJE1i3bh3i4+PRtWtX/PXXX9W6/4SEBKxatQpLliyBQPD/X7lffvkF0dHR+Pzzz3H8+HH88MMPSE5ORtu2bREcHKxcLi0tDVu2bIFEIsGQIUPeuL9hw4bh999/x8KFCxEYGIhWrVrh/fffx99//61cZuzYsTAyMsKqVauq9L3WtLCwMDDG0Lp1a7WWa9WqVZUsV53KOl8qeh7UJHXPZXWpcw4Ddec8JjWMEVKHLViwgAFgq1evLjGvoKCANWjQgJmZmbHMzMxqyzBnzhxWr149JpfLVaa/ePGixLLZ2dnMzs6O9ejRQzlNoVAwhULBGGMsJSWFAWALFy4sdV/Hjh1jANjff/+tMr1Xr17M0dGRyWQy5bQ1a9YwMzMzlpubW9m3Vi0WLlzI1P3TtHLlSqarq8vy8/PfuJyOjg7Ly8t743JCoZDl5OSonbeqlXW+VOQ8qGnqnsvqqMg5zFjtPY9J7UVXfEidFRoaiqVLl2Ls2LGYPXt2ifkikQiTJ09GVlYWzpw5Uy0ZpFIptm/fjlGjRql8ewcAW1vbEssbGxvDx8cHcXFxymkcx6l96+fff/+FsbEx3n33XZXp48ePR0JCAq5evaqc9sEHH0AsFpd6C+F1T58+xfjx49GwYUMYGhqiXr16GDhwIO7evauyXPFtqvv37+P999+HmZkZ7OzsMGHCBGRlZZXY7rFjx9CsWTOIRCLUr18fa9asUet9Frt+/TqaNGmC0NBQ9OjRA8bGxrC3t8eSJUtKLOfr6wsDAwMAAGMM69evh76+PubNmwe5XK5crlGjRjAyMqpQjqpS3vlSkfOgpql7LqujIucwULHzmBCAbnWROuy7774Dx3ElPgRf5e7uDgCIj48vMY8xBplMptarLFevXkVaWhq6deumVuasrCzcuHEDjRs3Vmv51927dw+NGjWCjo6OynQ/Pz/l/GL29vbw9vbGsWPH3rjdhIQEWFlZYeXKlThx4gR++ukn6OjooE2bNoiIiCix/PDhw+Hp6YkDBw5g3rx5+PvvvzFz5kyVZc6cOYPBgwfDxMQEe/bswerVq7F3717s2LFD7fcbFhaGlJQUfPHFFxg7diwOHz6Mzp07Y+HChTh37pzKcsW3r1JTUzFw4EAsW7YM//77L1auXAmhUFhiuYri43ypzSp7LlfkHAYqdh4TAgA6b16EEM2TlZWFoKAg9O7dGy4uLmUul5OTAwClfsM/d+6c2h9AUVFRcHNzKzH9ypUrAIAWLVqotZ2pU6ciNzcXX3/9tVrLvy4tLU1ZzL3K0tJSOf9VLVq0wOnTp9+43c6dO6Nz587Kf8vlcgQEBKBx48b49ddfsW7dOpXlJ06ciC+//BIA0LNnTzx9+hS//fYbtm/frrxq8fXXX8POzg6nTp2Cvr4+AKBPnz6lHsfSpKamIiYmBq1atcKFCxcgEokAAF5eXti3bx8ePHiALl26KJdr3bo1zp8/j1GjRsHNzQ23bt2Ck5NTqdsDAIlEgk8++QSnT59GVlYWfHx8sG7dOrRv377UPHycL7VZZc/lip7DgPrnMSEAFT6kjrp79y5kMhmaNGlS7nLFHzTF3yZf5e/vj+vXr6u1P0dHx1KnJyQkgOM4WFtbv3Eb3377Lf766y9s2rQJ/v7+au23NOXdDnl9nq2tLZKTkyGTyUp8w36VTCbDqlWrsGvXLjx9+hSFhYXKeQ8fPiyx/KBBg1T+7efnh4KCAiQnJ8POzg65ubm4fv06pkyZoix6AMDExAQDBw7E77///sb3WfyzWbp0qbLoAf7/wVj8Myle7tSpU/j0008xc+ZMLF++vMT7LV6uZcuWyvdcv359XLp0CU5OTvjzzz8xaNAgxMbGwtDQsESemj5fqsrZs2fVLthu3ryJZs2avXG5tz2XK3IOA+qfx4QAVPiQOkosFgMAbGxsylwmOzsbu3fvRv369ZUfdq8yNjZW6488gDL/2Obn50NXV1d5K6UsixcvxtKlS7Fs2TJMmzZNrX2WxsrKqtRvxOnp6QD+/625mL6+PhhjKCgogLGxcZnb/eKLL/DTTz9h7ty56NKlCywsLCAQCPDRRx8hPz+/1ByvKi5MipfNyMiAQqGAvb19iXVLm1aasLAwGBgYoHv37irTb9y4AQBo3ry5cjl9fX0cP34cnTt3LvMJoLCwMOjp6SmLYCMjIyxYsEA5f+zYsZg5cyaePHmCpk2blli/Js+XquTl5YWtW7eqtWx5V0+Lve25XNFzGFD/PCYEoMKH1FHFtzCio6PLXGbVqlXIzs7Gpk2bSv0WWRW3LqytrSGVSpGbm1tmg9nFixdj0aJFWLRoEb766iu19leWJk2aYPfu3SW++RY3Qvb19VVZPj09HSKR6I0fFrt27cKYMWOwfPlylempqakwNzevcE4LCwtwHIekpKQS80qbVpqwsDA0bdq0RBERFhYGa2tr5Yd0WFgYmjdvjoULF2LAgAGYP38+VqxYUer2/Pz8VK4everRo0fIz89HgwYNSp1fU+dLVXNwcMBHH31UJduqinO5oucwoP55TAhAhQ+po5o0aYIGDRpg9+7d+O6772BhYaEyf9euXVi+fDlGjBiBsWPHlrqNqrh14e3tDQB49uxZqbfTvvvuOyxatAjffPMNFi5cqNa+yjN06FBs3boVBw4cwHvvvaec/vvvv8PR0RFt2rRRWT4yMhI+Pj5v3C7HcSUKgmPHjuH58+fw8PCocE4jIyO0bt0aBw8exOrVq5W3u7Kzs3HkyBG1tnH9+nUMGzasxPTw8HCV2yvXr1/H8OHD0adPH2zduhXjx4+Hk5MTpk6dWmJ7gwcPLnVfeXl5GD16NL755psyP1xr4nypzarqXK7oOQyofx4TAlDhQ+oojuOwdetW9O/fH61atcLcuXPh4eGBpKQk7NmzB4cPH8a4ceOwZcuWMrdhYmJS6i2wiujatSuAokfrX/8gW7t2LRYsWIC+ffsiICAAoaGhKvPbtm2r/P/AwEDk5uYiOzsbAPDgwQPs378fANC/f39lm5N+/fqhV69e+PTTTyEWi+Hh4YHdu3fjxIkT2LVrl8otFIVCgWvXrmHixIlvfB8DBgzAzp074e3tDT8/P4SHh2P16tUqjYMr6rvvvkPfvn3Rq1cvzJo1C3K5HN9//z2MjIyUtzXKkpiYiMTExBI/H5lMhtu3b+OLL75QWa64EBo3bhzi4+Mxffp02NvbY/jw4SrLlfZEV2FhIUaMGAEfH59yr2JU9/kCqH8ecByHLl264OzZs2+VR10VOZfflK8i5zBQsfOYEADUgSGp227fvs1GjBjB7OzsmEAgYACYq6srO3XqVI1l6NSpE+vfv3+J6V26dGEAyny9ytXVtczloqKiVJbNzs5m06dPZ/b29kxPT4/5+fmx3bt3l9j/mTNnGAAWHh7+xveQkZHBJk6cyGxtbZmhoSHr2LEju3DhAuvSpQvr0qWLcrnizgdTUlJU1t+xY0epWQ8fPsz8/PyYnp4ec3FxYStXrlSrA8P//vuPAWB37txRmX779m0GgB08eLDc5SZPnsz09fXZ+fPnVZa7ffu2ynJyuZyNHDmSDRo0iBUWFr7xOFWFss4XxtQ7D7KzsxkANnLkyBrJy1jFzmV18ql7DjNWsfOYEMYY4xhjrDoLK0Jqk9GjR+Off/7B5cuX3/rbubqKL9nHxMSgXr16NbJPdYwePRqRkZG4dOkS31FqrUmTJuHJkyc4ceKEytNn1eltz5fjx49jwIABuH379hufauRDVeej85hUFBU+RKuIxWI0bdoUenp6uHHjRo00IGWMoX379vD398ePP/5Y7ftTx7Nnz9CoUSMEBwejY8eOfMeplWJiYuDm5gZ9fX2V2yuBgYHo1KlTte33bc+XL7/8Es+fPy8xrlVtUZX56DwmlUGFDyE14N69ezh8+DDmzZtXYigCPoSEhODJkyeYPHky31FIKWrb+VJb0XlMKoMKH0IIIYRoDfoqQQghhBCtQYUPIYQQQrQGFT6EEEII0RpU+BBCCCFEa1DhQwghhBCtQYUPIYQQQrQGFT6EEEII0RpU+BBCCCFEa1DhQwghhBCtQYUPIYQQQrQGFT6EEEII0RpU+JA65/bt2+A4DhEREQCA9evXw83NrcRyBw8exPvvvw8PDw8YGBjAzc0NH3zwAZ48eVLpfYvFYixbtgxdu3aFvb09jI2N0aRJE3z//fcoKCgosXxhYSEWL14MNzc3iEQieHt7Y9OmTSWW27ZtG4YMGQI3NzcYGBjAw8MDn376KRITE8vN8+LFC1hZWYHjOOzfv1/t96FuLgD466+/0Lx5c+jr68Pa2hqjRo1CXFyc2vsCgNOnT6Ndu3YwNDSEtbU1xo0bh+TkZJVloqOjwXFcqa89e/a8cR/Z2dmYM2cOevfuDRsbG3Ach0WLFpW67Lhx40rdj7e3t1rv5+zZs2VmDQ0NVVm2rOUqsr+cnBzMmDEDjo6O0NfXR7NmzUocE7lcjnXr1qFv375wcnKCoaEhGjVqhHnz5iEzM1Ot/UilUixYsAD169eHnp4eXF1dMX/+fOTn56sst2jRonLfV3k/rw8//BAcx2HAgAGlzt+zZw+aNWsGfX19ODo6YsaMGcjJyanUMXkdYwydO3cGx3GYNm2aGkeEaCRGSB2zdetWZm5uzhQKBWOMsREjRrB33323xHKtW7dmgwYNYr/99hs7e/Ys+/PPP1mjRo2YsbExu3fvXqX2fffuXWZtbc1mzpzJ/vvvP3bmzBm2aNEipq+vz3r06KHMVOyjjz5iIpGIrVq1ioWEhLB58+YxjuPYsmXLVJZzdHRkH3zwAfvrr7/Y2bNn2a+//sqcnJyYg4MDS0pKKjPP8OHDmaOjIwPA9u3bp/b7UDfXxo0bGQD20UcfsRMnTrBt27YxBwcH5urqytLT09Xa19mzZ5mOjg4bPHgwCwoKYrt27WL16tVjvr6+rKCgQLlcVFQUA8A+++wzduXKFZVXamrqG/cTFRXFzMzMWOfOndlHH33EALCFCxeWuuzYsWOZgYFBif3cunVLrfcUEhLCALDly5eX2EZ2drbKsq/Pv3LlCtuwYQMDwObNm6fW/nr16sXMzc3Z5s2bWXBwsPL9/fXXX8plsrOzmYmJCZs8eTLbt28fCwkJYWvXrmUWFhbMx8eH5eXlvXE/w4YNY/r6+mz58uXs1KlTbMmSJUxPT48NHDhQZbm4uLhS35evry8zMDBgGRkZpW7/6NGjzMjIiJmamrKAgIAS83ft2qU834KDg9nmzZuZmZkZ69WrV6WOyes2bdrEHBwcGAA2derUNx4Popmo8CF1zuTJk1nv3r2V/3ZxcWGrV68usdyLFy9KTHv+/DnT1dVlEydOrNS+c3JyWE5OTonpq1evZgDYhQsXlNPu3bvHOI5jy5cvV1l20qRJzMDAgKWlpZWb9fr16wwA++6770rNsn//fmZsbMx+//33ChU+6uYqKChgZmZmJT70Ll++zACwr776Sq39tWrVivn4+LDCwkLltEuXLjEA7Oeff1ZOKy58SvtZqkOhUCgLz5SUlDcWPkZGRpXaD2P/L3wqUmy+aty4cYzjOPbkyZM3Lnvs2DEGgP39998q03v16sUcHR2ZTCZjjDEmk8lKLRD37dvHALA///yz3P1cuXKFAWBr165Vmb58+XIGgAUFBZW7flRUFOM4jn344Yelzs/MzGT16tVj69atY66uriUKH5lMxhwcHFR+txlj7K+//mIA2PHjx5XT1D0mr+czNjZmBw8epMKnjqNbXaTOuX79Olq3bg0ASEpKQmxsrPLfr7K1tS0xzdHREU5OThW+VVPMyMgIRkZGJaYX7//V7R46dAiMMYwfP15l2fHjxyM/Px8nTpwoN6u/vz+EQmGpWdPT0zF16lQsW7YMLi4uFXoP6ua6d+8esrKy0L9/f5Xl2rVrB0tLSxw4cOCN+3r+/DmuX7+O0aNHQ0dHRzm9ffv28PT0xL///luh7OUpvs1S22VnZ2Pfvn3o0qULPDw83rj8v//+C2NjY7z77rsq08ePH4+EhARcvXoVACAUCmFlZVVi/dLOzdJcunQJAEr8vItvSb3p5/3bb7+BMYaPPvqo1PmzZs2Cg4MDpk+fXur80NBQJCYmljgv3333XRgbG6ucK+oek1dNnjwZvXr1wtChQ8t9H0TzUeFD6gQ3NzflB9vNmzexdOlScBwHBwcHAECXLl3AcRzGjRtX7nYiIyMRExODxo0bq0wvbrNw9uzZSuULDg4GAJXt3rt3DzY2NrC3t1dZ1s/PTzm/POfOnYNcLi+RFQCmT5+O+vXrV6qdgrq5pFIpAEAkEpXYhkgkwpMnT0pt1/T6vl7d9uv7K+0YrFy5Enp6ejA0NETHjh1x+PBhNd5VxeXn58Pe3h5CoRBOTk6YNm0a0tPTSyzXtWvXMguqqVOnQkdHB6ampujTpw8uXrz4xv3u2bMHubm5pRYIpe3r3r17aNSokUrhCKh/HpV2bpamrJ938b/v3LlT5roKhQI7d+6Eh4cHunTpUmL+6dOn8ccff2Dbtm0QCoWlbqOsc0VXVxfe3t4q77Oix2Tbtm24du0afvzxxzLfA6k7dN68CCG13/HjxyGVSnHq1Cl88803uHTpEnR0dLB48WKkpKQo/6BZWlqWuQ2ZTIaJEyfC2NgYM2fOVJknEAggFAordcXgzp07WLVqFYYOHaryRzstLa3UPEZGRtDT00NaWlqZ28zOzsaUKVPg7OyMCRMmqMw7duwY9u7dixs3bkAgqPh3G3VzeXl5QSAQ4NKlSyrfwp89e6ZsdJ2RkaEsPsvaF1D6z8XS0lLlGIhEIkyaNAm9evWCg4MDYmNjsWnTJgwePBhbt24t80pCZTRt2hRNmzaFr68vgKIic/369Thz5gyuX78OY2Nj5bJCobDEh7WZmRk+//xzdO3aFVZWVnj69ClWr16Nrl274tixY+jTp0+Z+96+fTvMzc0xfPjwEvNK21daWhrc3d1LLFt8TMs7j54/f4558+ahZcuWZTYmLubj4wOg6MpP/fr1ldOLi7ny9hMUFIS4uDisWLGixLycnBxMmjQJs2fPRtOmTcvcxpvOlejoaJVl1T0mz58/x+zZs7Fq1So4OjqWuX9Sh/B8q42QKjVjxgzWoUMH5b99fHzYokWL3rieQqFgY8aMYUKhkB06dKjK8kRFRTFnZ2fm6emp0maHsaL2Bt7e3qWup6enxz7++ONS5+Xn57OePXsyQ0NDFhoaqjKvuJ3EN998o5xWVnuTwsJClVdx+5eK5Bo9ejTT1dVlmzdvZmlpaez27dusTZs2TCgUMgDKhtcymUxlX3K5nDH2//YZr78PxoraaolEolJzFJNKpax58+bMyspKpY3Qm7ypjU9p9u/fzwCwdevWqb3OqzIyMpiTkxPz8/Mrc5l79+5VuH1Jw4YNWd++fUtMT0hIYADYihUrSl0vLS2N+fn5MVtbW/bs2bM37kcikTAPDw/m6OjIgoKCWEZGBgsMDGR2dnZMKBSWec4wxtg777zDdHR0WGJiYol5U6dOZQ0bNmT5+fnKaaW18Vm2bJnKOfWq3r17My8vL+W/K3JMBgwYwDp37qzy4EFFfwZEs9CtLqLx5HI5ZDIZZDIZzp07h44dO0ImkyE5ORkPHz5Ehw4dIJPJIJfLS12fvWx3sGvXLuzcuRODBw+uklwxMTHo1q0bdHR0cObMmRLfVK2srEr9lpybmwupVFrqN1uJRIKhQ4fi4sWLOHz4MNq0aaMy/+uvv4auri6mTZuGzMxMZGZmKh/1zcvLQ2ZmJhhjiI6Ohq6ursrr3LlzFc71yy+/4L333sOUKVNgZWWF5s2bw9vbGwEBARCJRMo2JT169FDZV/FVquL5pe0vPT293Ct0QNFtjvfeew9paWlv1Q2BOoYOHQojI6MSj6Ory9zcHAMGDMCdO3dKPP5dbPv27QBQoatXZf28im/LlXYMMzIy0KtXLzx//hynTp0q9erI6/T09BAYGAgXFxf07t0bFhYWeOedd/DVV1/BwsIC9erVK3W91NRUHD58GAEBASVun167dg0///wzVq1ahYKCAuU5q1AoIJPJkJmZCYlEonyfgHrnirrHZP/+/Thx4gRWrVqFrKws5f6Bolt7mZmZKCwsfOOxIRqG78qLkLfVpUsXBuCNry5dupRYV6FQsAkTJjCO49hvv/1WZZmio6OZm5sbc3V1ZdHR0aUuU/wN9vVvwcVPz7z+2G1BQQHr27cvE4lE7MSJE6VuU51jkZGRwSQSCbt+/brKSywWVyoXY4ylp6ez27dvs5SUFMYYY15eXqxbt27K+Y8ePVLZV1RUFGOMsfj4eAaArVy5ssQ2vby8Sn1M+XUrVqxgANijR4/euGyxylzxkcvlzNDQkI0cOVLtdV738ccfMwAqVzeKSSQSZm1tzfz9/Su0zUmTJjFjY+MSV7x2797NALBLly6pTE9PT2ctWrRgFhYW7MaNGxV/E6zo53bnzh2Wm5urvIqyePHiUpddt24dA8COHDlSYt6OHTveeL6uX7+eMfb/J/327Nmjso3CwkJmbGzMJk2apJym7jFZuHDhG/f/77//VuoYkdqLCh+i8Yo/VJcvX84MDAxYaGgou379Ohs4cCDr3Lmz8sP29Q9GhULBJk6cyDiOY1u2bKmyPDExMczNzY05OzuXewuh+LHx1z/0P/744xKPsxcUFLB+/foxPT09dvTo0TK3efPmTRYSEqLyWr9+PQPAFi1axEJCQt54S6giuUrz33//MQBq3zJs3bo18/X1VXnEuLjI+uWXX8pdVyqVsmbNmjFra+tSH1EuS2UKn3/++YcBYBs2bFB7nVelp6ezevXqsWbNmpU6v/ix8lcf4VfH8ePHSy0I+vbtW+LR7eKix9zcnF2/fr3ib6IUM2fOZEZGRiw+Pr7U+Y0bNy7zEfLExMQS52tISAizs7Njbdu2ZSEhISwuLo4x9v/H2V+/hVVczAQGBiqnqXtMoqKiSt0/ADZkyBAWEhKiLOZJ3UGFD6kzxo8fzwYMGKD8t5OTE/vxxx/LXH7atGkMAJswYUKJjtZe/ya8ePFiJhQK2dmzZ8vN8OLFC+bu7s5EIhHbtWtXie0W/xEvVtxR4OrVq9nZs2fZV199VWpHgQMGDGAA2Ndff11im/fv3y83U2X6lFE31/79+9nGjRvZqVOn2JEjR9isWbOYjo4O++STT9TeV0hICNPR0WFDhw5lp06dYn/99RdzdnYu0YHhzJkz2bRp09ju3btZSEgI++OPP1irVq0YALZjxw619nX8+HG2b98+9ttvvzEA7N1332X79u1j+/btY7m5uYyxoqt17du3Zxs3bmTHjx9ngYGBbN68eUxfX581bty4RD9N3bt3Z0KhUGXa+++/z+bOnavsKHDLli3My8uL6ejosFOnTpWarW/fvszAwIBlZmaWmb+0fTFW1C7LwsKCbdmyhQUHB7NJkyYxAGzXrl3KZfLy8lirVq0Yx3Hshx9+KHEePX36VGWbQqGQde/eXWXa999/z37//XcWEhLC9uzZw4YNG8YEAkGZnQKGhoZWqE+nYqW18WGMsT///JMBYJMnT1YeV3Nz8zI7MHzTMSkLqI1PnUaFD6kT5HI5s7GxYb/++itjjLEbN24wACwmJqbMdVxdXcu8vO3q6qqybPEl8ZCQkHJzFBcZZb1ev8IglUrZwoULmYuLC9PT02Oenp5s48aNJbZb0Vt4pWWqSOGjbq5///2XNWvWjBkZGTEDAwPWsmVLtn379hI9VL9JUFAQa9u2LdPX12eWlpZszJgxJTpt3L59O2vdujWztLRkOjo6zMLCgvXp04edPHlS7f2U9zMvvv2Wnp7Ohg4dytzc3JiBgQHT09NjDRs2ZHPmzCm1KCm+vfiqFStWsGbNmjEzMzMmFAqZjY0NGzp0KLt27VqpuWJjY5lAIGBjxowpN39p+2KsqFfm6dOnM3t7e6anp8f8/PzY7t27VZYp7gCyrNfYsWNVli/t3Fq8eDFr0KABE4lEzNzcnPXt25edP3++zLyTJk1iHMep1Xj6VWUVPowx9vfffzM/Pz+mp6fH7O3t2fTp00v0hs2YesekLFT41G0cY4yV1f6HEEIIIaQuoae6CCGEEKI1qPAhhBBCiNagwocQQgghWoMKH0IIIYRoDSp8CCGEEKI1aJDS1ygUCiQkJMDExKRSA1ISQgghpOYxxpCdnQ1HR8dyB2imwuc1CQkJcHZ25jsGIYQQQiohLi4OTk5OZc6nwuc1JiYmAIoOnKmpKc9pCCGEEKIOsVgMZ2dn5ed4WajweU3x7S1TU1MqfAghhBAN86ZmKtS4mRBCCCFagwofQgghhGgNKnwIIYQQojWo8CGEEEKI1qDChxBCCCFagwofQgghhGgNKnwIIYQQojWo8CGEEEKI1qDChxBCCCFagwofQgghhGgNKnwIIYQQojWo8CGEEEKI1qDChxCiNfKkMhQUyvmOQQjhEY3OTgip855n5uPH4KfYHx4HuYLB1coIHrbG8LQzhqedCTxsjdHAxhj6ukK+oxJCqhkVPoSQOishMx8/hTzF3rA4FMqZcnpUai6iUnNx6sEL5TQBB7hYGqKhnQk87YzR0NYEDe2oICKkrqHChxBS5yRlFeDns0+x51ocpHIFAKB9AyvM7OUJVytDPHmRgycvsvE4+eV/X+QgK78Q0Wl5iE7Lo4KIkDqMY4yxNy+mPcRiMczMzJCVlQVTU1O+4xBCKuCFuAC/nH2Gv6/FQiorKnjaultiZk9PtHG3KnM9xhhSciRlFkSlebUgamhbdMuMCiJC+KPu5zcVPq+hwocQzZMsLsAv557h76uxkLwseFq7WWJGr4Zo38C60tutbEHU28ce3w/3g5mhbqX3TQipGCp8KokKH0I0R0q2BJvPPcOu0BhlwdPS1QIze3mifQMrcBxXLftVpyBysTTE5g/94eNIf0cIqQlU+FQSFT6E1H6pORL8eu4Z/gyNQUFhUcHTwsUcM3t5oqOHdbUVPG/CGMPd51mY+vcNxKXnQ19XgJXD/DCkeT1e8hCiTajwqSQqfAipvdJyJNhyPhJ/XIlB/sv+eJo5FxU8nRvyV/C8LjNPis/33MK5xykAgHHt3fB1QCPoCqnrNEKqCxU+lUSFDyG1T0auFFsuROL3y9HIkxYVPH5OZpjZ0xNdvWxqTcHzKrmC4YfTj7Ex+CkAoJWbBX4a1QK2pvo8JyOkbqLCp5Ko8CGk9sjMk2LrhUjsvBSN3JcFj289U8zs6Ynu3ra1suB53akHL/DFP7eQLZHBxkSEXz5ogZZulnzHIqTOocKnkqjwIYR/WXmF2HYxEjsuRSNHIgMANHY0xYyenujZSDMKnldFpebi4z/D8PhFDnQEHL4JaISx7d007n0QUptR4VNJVPgQwp+s/EJsvxiFHRejkP2y4GnkYIoZPRuit4+dRhcKuRIZ5h64g6N3EgEAQ5vXw/KhTWCgR33+EFIV1P38pp6bCSG8k8kV+OXsM2y5EInsgqKCx8vOBDN6NkSfxvYQCDS34ClmJNLBpvebo5mzOVYEPsK/N5/jUVI2fv3QHy5WhnzHI0Rr0BWf19AVH0JqllzBMPOfWzh8OwEA4GlnjM97eKKfb90oeEpz5VkaPtt9A6k5Upjq6+CH95ujm5ct37EI0Wjqfn7Ts5WEEN4oFAzzDtzB4dsJ0BFwWPWOH0583hkBfg51tugBgHYNrHDks45o7mIOcYEME3Zexw+nn0ChoO+hhFQ3jSl8Bg0aBBcXF+jr68PBwQGjR49GQkKCyjKxsbEYOHAgjIyMYG1tjenTp0MqlfKUmBBSHsYYFhy+h33h8RBwwMb3m2NES+c6XfC8ysHMAHsmt8UHbVzAGLD+9GNM+iOszKEwCCFVQ2MKn27dumHv3r2IiIjAgQMH8OzZM7zzzjvK+XK5HAEBAcjNzcXFixexZ88eHDhwALNmzeIxNSGkNIwxfHf0IXaFxoLjgHUjmqF/Ewe+Y9U4kY4Qy4Y2wep3/KCnI8CZR8kY/ONFPEoS8x2NkDpLY9v4HD58GEOGDIFEIoGuri4CAwMxYMAAxMXFwdHREQCwZ88ejBs3DsnJyWq316E2PoRUL8YYVp+MwM9nnwEAvh/eBO+1cuE5Ff/uxmfhk13heJ6ZDwNdIb5/xw+DmjryHYsQjVGn2/ikp6fjr7/+Qvv27aGrWzT68ZUrV+Dr66ssegCgT58+kEgkCA8PL3NbEokEYrFY5UUIqT6bgp8qi54lgxtT0fNSEyczHPmsIzo1tEZ+oRzTd9/Ed0cfoFCu4DsaIXWKRhU+c+fOhZGREaysrBAbG4v//vtPOS8pKQl2dnYqy1tYWEBPTw9JSUllbnPFihUwMzNTvpydnastPyHa7tdzz7Du1GMAwNf9G2FMOzd+A9UylkZ62Dm+NaZ0bQAA2H4xCh9su4qUbAnPyQipO3gtfBYtWgSO48p9hYWFKZf/8ssvcfPmTQQFBUEoFGLMmDF49U5daZ2bMcbK7fRs/vz5yMrKUr7i4uKq9k0SQgAAOy9FYUXgIwDA7N6emNTZnedEtZNQwGFOX29s/tAfxiIdXItKx4BNFxAek8F3NELqBF47MJw2bRpGjhxZ7jJubm7K/7e2toa1tTU8PT3RqFEjODs7IzQ0FO3atYO9vT2uXr2qsm5GRgYKCwtLXAl6lUgkgkgkeqv3QQgp3+5rsVh05AEAYFo3D0zr3pDnRLVfX197NLQzxsd/huNpcg5GbrmCBQMb48M2LhrdgzUhfOO18CkuZCqj+EqPRFJ0Cbhdu3ZYtmwZEhMT4eBQ9HRIUFAQRCIR/P39qyYwIaTCDt6Ix1f/3gUATOpUH7N6e/KcSHM0sDHGoakdMGf/bRy/m4RvD93DrdhMLBvqC31dGuqCkMrQiKe6rl27hmvXrqFjx46wsLBAZGQkFixYgMTERNy/fx8ikQhyuRzNmjWDnZ0dVq9ejfT0dIwbNw5DhgzBpk2b1N4XPdVFSNU5eicB03ffhIIBY9q5YvGgxnS1ohIYY9h6IRIrAx9BwYoGbN38oT+cLWmoC0KK1amnugwMDHDw4EH06NEDXl5emDBhAnx9fXHu3DnlbSqhUIhjx45BX18fHTp0wIgRIzBkyBCsWbOG5/SEaKeg+0mYsecWFAx4r6UzFg2koqeyOI7D5M4NsGtiG1ga6eF+ghjvbL6MF+ICvqMRonE04opPTaIrPoS8vbMRyZj8RzikcgWGNHPE2hHNINSSHpmrW0JmPsb8dg1Pk3PQ1Nkc/0xuS7e9CEEdu+JDCNEcl5+m4uM/i4qe/k3ssebdplT0VCFHcwNsH9sS5oa6uB2Xia8O3gV9fyVEfVT4EEKqzPXodEz8PQwSmQI9G9liw3vNoSOkPzNVzdXKCD+NagGhgMPBm8+x7UIU35EI0Rj0F4kQUiVuxWVi/I7ryC+Uo1NDa/w4qgX0dOhPTHXp4GGNBQN8AAArAh8iJCKZ50SEaAb6q0QIeWv3E7IwZvtV5EhkaOtuiS2jW1K7kxowpp0rRrZyhoIB03ffxLOUHL4jEVLrUeFDCHkrj19k48NtVyEukMHf1QLbx7aCgR4VPTWB4zgsGeyLVm4WyC6QYdLvYcjKL+Q7FiG1GhU+hJBKi0zJwaitV5GRVwg/JzPsGN8KRiJe+0XVOno6AvzyoT8czfQRmZqLz3bfhFxBjZ0JKQsVPoSQSolNy8OorVeRmiOBt70J/pjQGqb6unzH0krWxiJsHdsS+roCnH+cgpWBD/mOREitRYUPIaTCEjLzMWpbKJLEBfCwNcZfH7WBuaEe37G0WmNHM6x9txkAYOuFKBwIj+c3ECG1FBU+hJAKSRYXYNTWUMRn5MPNyhB/f9QGVsY00G9tEODngOndPQAA8w/exY1YGtGdkNdR4UMIUVtqjgSjtl1FdFoenCwM8PektrA11ec7FnnFjJ6e6O1jB6lcgY//DEdSFg1rQcirqPAhhKglM0+KD7ddxdPkHDiY6WP3pLZwNDfgOxZ5jUDAYf17zeBlZ4KUbAkm/xmGgkI537EIqTWo8CGEvJG4oBCjt1/Do6Rs2JiI8NdHbWhk8FrMSKSDbWNbwsJQF3fiszDvwB0a1oKQl6jwIYSUK08qw/gd13H3eRYsjfTw10dt4G5jzHcs8gbOlob4+QN/6Ag4HLqVgF/PR/IdiZBagQofQki5Fh2+j/CYDJjq6+DPia3haWfCdySipnYNrLBwYNGwFt+feITgRy94TkQI/6jwIYSU6fDtBOwNiwfHAb+ObonGjmZ8RyIV9GFbV4xq4wLGgOm7b+FpcjbfkQjhFRU+hJBSxabl4euDdwEAn3XzQLsGVjwnIpXBcRwWDWyM1vUtkSOR4aPfw5CVR8NaEO1FhQ8hpIRCuQLT99xEtkSGlq4WmN6jId+RyFvQ0xHglw9aoJ65AaLT8jBt9w3I5Aq+YxHCCyp8CCElrDv1GLfiMmGqr4MNI5tBR0h/KjSdlbEIW8e0hIGuEBeepGL58Ud8RyKEF/TXjBCi4uKTVGw+9wwA8P1wPzhZ0GPrdYWPoynWjWgKAPjtUhT2hsXxnIiQmkeFDyFEKTVHgpl7b4ExYFQbF/Rr4sB3JFLF+jVxwIyeRbcuv/n3HsJj0nlOREjNosKHEAIAUCgYZu+7jZRsCTztjPFtgA/fkUg1md69Ifr52r8c1uIGEjLz+Y5ESI2hwocQAqDo1sfZiBSIdATY9H4LGOgJ+Y5EqolAwGHNu03hbW+C1JyiYS3ypTSsBdEOVPgQQnDveRa+P1HU2PWbAT7wsqdOCus6I5EOto5pCUsjPdx7LsYcGtaCaAkqfAjRcrkSGT7bfROFcoY+je3wYRsXviORGuJsaYhfPmgBHQGHI7cT8PPZZ3xHIqTaUeFDiJZb8N99RKXmwsFMH98P9wPHcXxHIjWojbsVFg9uDABYExSBUw9oWAtSt1HhQ4gWO3TzOQ7ciIeAA34Y2Rzmhnp8RyI8+KCNK0a3dQVjwIw9N/H4BQ1rQeouKnwI0VIxabn45tA9AMD0Hg3Rur4lz4kInxYM9EFbd0vkSuX46PcwZORK+Y5ESLWgwocQLSSVKTB9903kSGRo7WaJad08+I5EeKYrFODnD/zhZGGA2PQ8TP37BgppWAtSB1HhQ4gWWhsUgdvxWTAz0KUhKYiSpZEeto1tCUM9IS4/S8OyYw/5jkRIlaO/doRomfOPU/Dr+UgARUNSOJob8JyI1Cbe9qZY/14zAMDOy9EIiUjmNxAhVYwKH0K0SEq2BF/svQ0A+LCtC/r62vOciNRGfRrbY0KH+gCAeQfuICuvkOdEhFQdKnwI0RIKBcOsfbeRmiOBl50JvqEhKUg5vuzjhfrWRnghlmDx0ft8xyGkylDhQ4iW2H4xCucfvxySYlRz6OvSkBSkbAZ6Qqx5tykEHHDwxnPq34fUGVT4EKIF7sRnYtXJoiEpFgz0gacdDUlB3szf1QKTOrkDAOYfvEuPuJM6gQofQuq4nFeGpOjna49RrWlICqK+mb084WFrjNQcCRYcplteRPNR4UNIHbfg0D3EpOXB0UwfK4fRkBSkYvR1hVj7blMIX47ndfxuIt+RCHkrVPgQUocdvBGPgzefFw1J8X5zmBnq8h2JaKCmzub4tEsDAMA3h+4hNUfCcyJCKo8KH0LqqKjUXHz7ckiKGT090cqNhqQglfdZDw9425sgPVeKbw/dA2OM70iEVAoVPoTUQcVDUuRK5WhT3xJTaUgK8pZEOkVPeekIOATeS8KRO3TLi2gmKnwIqYNWn3yEu8+zYG5YNCSFUEDtesjb861nhmndi4roBf/dQ3J2Ac+JCKk4KnwIqWPORiRj64UoAMCq4X5wMKMhKUjVmdrNA40dTZGZV4ivDt6lW15E41DhQ0gdkpxdgNn7ioakGNPOFb0b05AUpGrpCgVYO6IpdIUcTj9MxsEbz/mOREiFaFzhI5FI0KxZM3Ach1u3bqnMi42NxcCBA2FkZARra2tMnz4dUil1uEW0g0LBMGvvbaTmSOFtb4Kv+jfiOxKpo7ztTTGjpycAYNGR+0jKolteRHNoXOEzZ84cODo6lpgul8sREBCA3NxcXLx4EXv27MGBAwcwa9YsHlISUvO2XIjEhSep0NcV4EcakoJUs487u6OpszmyC2SYe+AO3fIiGkOjCp/AwEAEBQVhzZo1JeYFBQXhwYMH2LVrF5o3b46ePXti7dq12Lp1K8RiMQ9pCak5t+IyseZkBABg0cDG8LClISlI9dIRCrD2XT/o6Qhw7nEK9obF8R2JELVoTOHz4sULTJo0CX/++ScMDQ1LzL9y5Qp8fX1Vrgb16dMHEokE4eHhZW5XIpFALBarvAjRJNkFhZi++yZkCoaAJg54r5Uz35GIlvCwNcHs3kW3vL47+hDxGXk8JyLkzTSi8GGMYdy4cfjkk0/QsmXLUpdJSkqCnZ2dyjQLCwvo6ekhKSmpzG2vWLECZmZmypezM31oEM3BGMM3h+4hNj0P9cwNsHxYExqSgtSoiR3d4e9qgRwJ3fIimoHXwmfRokXgOK7cV1hYGDZt2gSxWIz58+eXu73S/uAzxsr9IJg/fz6ysrKUr7g4ulxLNMfh2wn471YChAIOG99vBjMDGpKC1CyhgMOad5tCX1eAS0/TsOtqLN+RCCmXDp87nzZtGkaOHFnuMm5ubli6dClCQ0MhEolU5rVs2RIffPABfv/9d9jb2+Pq1asq8zMyMlBYWFjiStCrRCJRie0SogkycqVYfOQBAOCz7h7wd6UhKQg/6lsbYW5fbyw+8gArjj9El4Y2cLEq2SSBkNqAYxpwXTI2Nlal7U1CQgL69OmD/fv3o02bNnByckJgYCAGDBiA+Ph4ODg4AAD++ecfjB07FsnJyTA1NVVrX2KxGGZmZsjKylJ7HUL4MGvvbRy4EQ8vOxMc+awj9HQ04s41qaMUCob3t4bialQ62tS3xO5JbSGgHsNJDVL385vXKz7qcnFxUfm3sbExAKBBgwZwcnICAPTu3Rs+Pj4YPXo0Vq9ejfT0dMyePRuTJk2iAobUORefpOLAjXhwHLB8WBMqegjvBAIOq99pir4/nMfVqHT8fiUa4zvU5zsWISXUmb+WQqEQx44dg76+Pjp06IARI0ZgyJAhpT76Togmy5fK8dW/dwEAo9u6wt/VgudEhBRxsTLE/JcdZ35/4hEiU3J4TkRISRpxq6sm0a0uUtutDHyEzeeewd5UH6e+6AwTfWrQTGoPxhhGb7+Gi09T4e9qgb0ft6NBckmNUPfzu85c8SFEG9xPyMLWC5EAgO+G+FLRQ2odjuPw/Tt+MBbpIDwmA9svRvIdiRAVVPgQoiHkCob5B+9CrmDo52uPXj5lP61ICJ/qmRvg2wFFt7zWBD3G0+RsnhMR8n9U+BCiIXZejsad+CyY6Otg8aDGfMchpFwjWjqjq5cNpDIFZu29DZlcwXckQgBQ4UOIRojPyMPaoKKxuOb3awRbU32eExFSPo7jsHKYH0z0dXA7Pgu/nqdbXqR2oMKHkFqueFiKPKkcrd0sMZLG4iIawt5MH4sGFl2d3HD6MR4l0ViIhH9U+BBSyx25k4izESnQEwqwfFgT6hSOaJRhLeqhZyM7FMoZZu29jUK65UV4RoUPIbVYZp4US47cBwBM7eYBD1tjnhMRUjEcx2H5MF+YG+rifoIYP4U85TsS0XJU+BBSiy079hCpOVI0tDXGp10b8B2HkEqxNdHHksG+AIAfg5/i3vMsnhMRbUaFDyG11OWnqdgXHg8AWEHDUhANN9DPAf187SFTMMzedxsSmZzvSERL0V9SQmqhgsL/D0vxYVsXtHSjkdeJZuM4DkuH+MLKSA+PkrKx6Qzd8iL8oMKHkFpo45kniE7Lg52pCHP6evMdh5AqYWUswtIhRbe8fjn3DLfjMvkNRLQSFT6E1DIPE8XY8rLPkyWDfWFKw1KQOqRfEwcMauoIuYJh1r7bKCikW16kZlHhQ0gtIlcwzDt4FzIFQ5/GdujT2J7vSIRUucWDGsPGRISnyTlYf+ox33GIlqHCh5Ba5I8r0bgdlwkTkY7yKRhC6hoLIz0sH9oEALD1QiQ95UVqFBU+hNQSzzPzsfpk0bAUc/t5w46GpSB1WC8fOwxs6ggFA74+dA8KBeM7EtESVPgQUgswxvDty2EpWrpaYFRrF74jEVLtvgloBGORDm7HZWL39Vi+4xAtQYUPIbXAsbuJCH6UDF0hhxU0LAXREnam+pjV2xMAsOpEBFJzJDwnItqACh9CeJaVV4hFhx8AAKZ09UBDOxOeExFSc0a3dYWPgymy8guxMvAR33GIFqDChxCeLT/+EKk5EjSwMcKUbjQsBdEuOkIBlg71BccB+8PjcS0qne9IpI6jwocQHl15loZ/wuIAACuH+0GkI+Q5ESE1r4WLBUa2KmrX9u2hezSCO6lWVPgQwpOCQjm+fjksxag2LmhFw1IQLTanjxcsjfQQ8SIbOy5F8R2H1GFU+BDCkx+DnyIyNRe2JiLMpWEpiJazMNLDvH5FvwcbTj9BQmY+z4lIXUWFDyE8iEjKxuZzzwAU9WJrZkDDUhDyTgsntHS1QJ5Uju+OPuA7DqmjqPAhpIYVDUtxBzIFQy8fO/T1pWEpCAEAgYDD0qG+EAo4BN5LQkhEMt+RSB1EhQ8hNWxXaAxuxmbCWKSDJYMbg+Oozx5Cinnbm2JCBzcAwML/7tMgpqTKUeFDSA1KyMzHqhNFfZXM6esFBzMDnhMRUvt83tMT9qb6iE3Pw89nn/Edh9QxVPgQUkMYY1jw3z3kSuVo4WKOD9u48h2JkFrJWKSDBQN9AACbzz5DVGouz4lIXUKFDyE1JPBeEk4/LBqWYuVwPxqWgpBy9PO1RxdPG0jlCiz47x4Yo0FMSdWgwoeQGpCVV4iFh+8DAD7t0gCeNCwFIeXiOA6LBzWGno4AF56k4tjdRL4jkTqCCh9CasDKE4+Qki2Bu40RpnTz4DsOIRrBzdoIU7oWDeOy5MgDZBcU8pyI1AU66i64ceNGTJ48Gfr6+ti4cWO5y06fPv2tgxFSV1yNTMPua7EAgBVDm0Bfl4alIERdn3RpgEM3nyM6LQ/rTz1Rtv0hpLI4puaN0/r16yMsLAxWVlaoX79+2RvkOERGRlZZwJomFothZmaGrKwsmJqa8h2HaLiCQjn6b7yAyJRcvN/aGSuG+fEdiRCNc/5xCsb8dg0CDjjyWUc0djTjOxKphdT9/Fb7ik9UVFSp/08IKdvPZ58hMiUX1sYizOvbiO84hGikzp42CGjigGN3E/HtoXvY/0l7ejiAVBq18SGkmjx5kY1fzj4F8HJYCkMaloKQyvp2gA+M9IS4EZuJfeFxfMchGkztKz6vksvl2LlzJ86cOYPk5GQoFAqV+cHBwVUSjhBNVdRnz30Uyhl6NrJF/yY0LAUhb8PeTB8ze3li6bGHWBH4CL187GFppMd3LKKBKlX4fP7559i5cycCAgLg6+tLXe4T8ppjdxNxJTINIh0BFg6kYSkIqQrj2rthf3g8HiVl4/vAR/j+HWozRyquUoXPnj17sHfvXvTv37+q8xCi8fKkMiw79hBA0RMpzpaGPCcipG7QEQqwdIgv3tl8Bf+ExWFEKyf4u1ryHYtomEq18dHT04OHB/VFQkhpfg55hsSsAjhZGODTl32QEEKqRks3S4xo6QQA+Prfe5DJFW9YgxBVlSp8Zs2ahR9++IG6ECfkNdGpudhyvqg7h28CfKjPHkKqwbx+jWBuqItHSdnYeTma7zhEw6h9q2vYsGEq/w4ODkZgYCAaN24MXV3Vp1UOHjxYNekI0TDfHX0AqVyBTg2t0aexHd9xCKmTLI30MK+vN+YdvIv1px5jgJ8j7M30+Y5FNITahY+ZmWqHUUOHDq3yMIRosuBHL3DmUTJ0BBw1aCakmo1o6Yx/wuJwMzYT3x17gJ9GteA7EtEQahc+O3bsqM4chGg0iUyOJUceAAAmdKwPD1tjnhMRUrcJBByWDvHFwE0XcexOIt5rmYLOnjZ8xyIaoFJtfKKiovDkyZMS0588eYLo6Oi3zVQqNzc3cByn8po3b57KMrGxsRg4cCCMjIxgbW2N6dOnQyqVVkseQl617UIUotPyYGsiwmfdqeE/ITWhsaMZxrUvGkJpwX/3UFAo5zkR0QSVKnzGjRuHy5cvl5h+9epVjBs37m0zlWnJkiVITExUvr755hvlPLlcjoCAAOTm5uLixYvYs2cPDhw4gFmzZlVbHkIAICEzHz8GF/XQPL+/N0z0qYdmQmrKzF4NYWsiQnRaHn49p7njRJKaU6nC5+bNm+jQoUOJ6W3btsWtW7feNlOZTExMYG9vr3wZG///dkJQUBAePHiAXbt2oXnz5ujZsyfWrl2LrVu3QiwWV1smQpYff4j8QjlaulpgSLN6fMchRKuY6Ovi2wFFI7b/dPYpYtJyeU5EartKFT4cxyE7O7vE9KysLMjl1Xep8fvvv4eVlRWaNWuGZcuWqdzGunLlCnx9feHo6Kic1qdPH0gkEoSHh5e5TYlEArFYrPIiRF1XnqXh6J1ECDhg8WBq0EwIHwb4OaCjhzWkMgUW/Hefuloh5apU4dOpUyesWLFCpciRy+VYsWIFOnbsWGXhXvX5559jz549CAkJwbRp07BhwwZMmTJFOT8pKQl2dqqPD1tYWEBPTw9JSUllbnfFihUwMzNTvpydnaslP6l7ZHIFFh2+DwAY1cYFjR3N3rAGIaQ6cByHJYMbQ08owLnHKThxr+y/+YRUqvBZtWoVgoOD4eXlhfHjx2P8+PHw8vLC+fPnsXr1arW3s2jRohINll9/hYWFAQBmzpyJLl26wM/PDx999BE2b96M7du3Iy0tTbm90r5tM8bK/RY+f/58ZGVlKV9xcTTqL1HPn6ExiHiRDQtDXczu7cV3HEK0mruNMT7p4g4AWHzkAXIkMp4TkdqqUmN1+fj44M6dO/jxxx9x+/ZtGBgYYMyYMZg2bRosLdUfN2XatGkYOXJkucu4ubmVOr1t27YAgKdPn8LKygr29va4evWqyjIZGRkoLCwscSXoVSKRCCKRSO3MhABAao4E6049BgDM7uMFc0MaJZoQvk3p5oF/bz1HXHo+Np55gq/6N+I7EqmFKlX4AICjoyOWL19e7jJTpkzBkiVLYG1tXep8a2vrMue9yc2bNwEADg4OAIB27dph2bJlSExMVE4LCgqCSCSCv79/pfZBSFlWnXiE7AIZfOuZYmQrF77jEEIA6OsKsWSQL8bvvI7tF6MwrEU9eNub8h2L1DKVutWlrl27dlVJY+ErV65g/fr1uHXrFqKiorB37158/PHHGDRoEFxcij50evfuDR8fH4wePRo3b97EmTNnMHv2bEyaNAmmpnTik6pzKy4Te8PiAQCLBzWGUEANmgmpLbp526JvY3vIFQzf/HsPCgU1dCaqqrXwqaqW9SKRCP/88w+6du0KHx8fLFiwAJMmTcLu3buVywiFQhw7dgz6+vro0KEDRowYgSFDhmDNmjVVkoEQAFAoGBb+dw8AMKxFPfi7qn9rlxBSMxYM9IGhnhBhMRk4cCOe7ziklqn0ra6a1KJFC4SGhr5xORcXFxw9erQGEhFttS88Drfjs2As0sG8ft58xyGElMLR3ACf92iIFYGPsCLwEXr52FE7PKJUrVd8CKlLsvILsepEBABgRs+GsDWh0aAJqa0mdKwPTztjpOdK8f3L31tCACp8CFHb+lOPkZYrhYetMca2d+M7DiGkHLpCAZYOaQIA2HM9FnfiM/kNRGoNKnwIUcOjJDH+DI0BACwa2Bi6QvrVIaS2a13fEkOb1wNjRX37UI/OBKhE4SOTybB48WK1Ovr78MMP6YkqovEYY1j4333IFQz9fO3RsWHlumAghNS8uX29YaArRHhMBg7fTuA7DqkFKlz46OjoYPXq1WqNyfXLL79Uup8eQmqLo3cScTUqHfq6AnwdQB2iEaJJ7M30MbVbAwDAysBHyJNSj87arlLX63v27ImzZ89WcRRCap9ciQzLjj0EAEzp6gEnC0OeExFCKuqjTu5wsjBAYlYBNp+L5DsO4VmlHmfv168f5s+fj3v37sHf3x9GRkYq8wcNGlQl4Qjh208hT5EkLoCzpQEmd3bnOw4hpBL0dYX4un8jfPrXDfx67hlGtHSiLzFajGOVaO0lEJR9oYjjOLVug9VWYrEYZmZmyMrKovZJWi4qNRe9159DoZxhy2h/9G5sz3ckQkglMcbw/tZQhEamI8DPAT+NasF3JFLF1P38rtStLoVCUeZLk4seQl615Mh9FMoZunjaoJdP2QPdEkJqP47jsGBAYwg44NidRFyNTOM7EuHJWz+TW1BQUBU5CKlVzjx8gZCIFOgKOSwc6AOOo/G4CNF0Po6meL910fiOi488gJzG8dJKlSp85HI5vvvuO9SrVw/GxsaIjCxqLPbtt99i+/btVRqQkJpWUCjH4iMPABT1/upuY8xzIkJIVfmilydM9XXwIFGMvWFv7paF1D2VKnyWLVuGnTt3YtWqVdDT+//4J02aNMG2bduqLBwhfNh2IRKx6XmwMxXhs+4N+Y5DCKlCVsYizOjpCQBYczICWfmFPCciNa1Shc8ff/yBLVu24IMPPoBQKFRO9/Pzw6NHj6osHCE17XlmPn4MeQoA+Kp/IxiLNGIcX0JIBYxu54oGNkZIy5Vi05knfMchNaxShc/z58/h4eFRYrpCoUBhIVXPRHMtP/YQBYUKtHazxKCmjnzHIYRUA12hAAsGNgYA7LwcjWcpOTwnIjWpUoVP48aNceHChRLT9+3bh+bNm791KEL4cPlpKo7dTYSAAxYNakwNmgmpw7p42qCHty1kCoalRx/wHYfUoEpdx1+4cCFGjx6N58+fQ6FQ4ODBg4iIiMAff/yBo0ePVnVGQqpdoVyBRUfuAwA+bOsKH0fqw4mQuu7rgEY4/yQFIREpCHmUjG7etnxHIjWgUld8Bg4ciH/++QfHjx8v6hthwQI8fPgQR44cQa9evao6IyHV7o8rMXj8IgeWRnr4opcn33EIITXA3cYY4zvUBwB8d+wBpDIFz4lITah0y80+ffqgT58+VZmFEF6kZEuw4dRjAMCXfbxgbqj3hjUIIXXFtO4eOHgjHpEpufjjSjQ+6kRD09R1lbri4+7ujrS0kr1eZmZmwt2dThqiWVadeIRsiQxN6plhREtnvuMQQmqQqb4uvuzjBQD44cwTpOZIeE5EqlulCp/o6OhSh6aQSCR4/vz5W4cipKbciM3AvvB4AMDiwY0hFFCDZkK0zTv+zvCtZ4rsAhnWBj3mOw6pZhW61XX48GHl/588eRJmZmbKf8vlcpw5cwZubm5VFo6Q6iRXMCz8r6hB8zv+TmjhYsFzIkIIH4QCDgsHNsa7m69gz/VYfNjWBY0dzd68ItFIFSp8hgwZAqBosLexY8eqzNPV1YWbmxvWrl1bZeEIqU57w+Jw93kWTEQ6mNvXm+84hBAetXKzxMCmjjhyOwGLjzzAP5PbUpcWdVSFbnUVj8Du4uKC5ORklVHZJRIJIiIiMGDAgOrKSkiVycorxOqTEQCAGb08YWMi4jkRIYRv8/p5Q19XgGtR6Qi8l8R3HFJNKtXGJyoqCtbW1gBodHaimdaffoz0XCka2hpjTDtXvuMQQmqBeuYG+KRLAwDAsmMPUVBYsi0r0XyVKnwUCgWNzk401tPkHOwKjQEALBzYGLrCSv0aEELqoI87N4CjmT6eZ+Zj6/lIvuOQalCpv/hLly6l0dmJxlp+/CFkCoaejWzRsaE133EIIbWIgZ4Q8/o3AgD8fPYZErPyeU5EqhqNzk60yoUnKQh+lAwdAYevXv5xI4SQVw30c0BLVwvkF8rxfSB9ptU1NDo70RoyuQJLjz4EAIxu5wp3G2OeExFCaiOOK3q8neOAQ7cSEB6TznckUoVodHaiNf4Ji0PEi2yYG+ri8x4N+Y5DCKnFmjiZYYR/UU/ui488gELBeE5EqgqNzk60grigEOte9sg6o0dDGo+LEPJGs/t44djdRNyJz8KBG/F4l4a0qRNodHaiFX4Kfoq0XCka2Bjhg7b0+Doh5M1sTESY3qOoWcf3JyKQXUBNOeoCGp2d1HkxabnYcSkaAPBNgA89vk4IUdu49vWx+1ocolJz8VPIM8zrR728a7q3/gTIycmBWCxWeRFSm6w4/ghSuQKdGlqjq5cN33EIIRpET0eAbwKKngD97WIUolNzeU5E3lale24OCAiAkZERzMzMYGFhAQsLC5ibm8PCggZ6JLVHaGQaTtxPgoArutpDY+8QQiqqu7ctOnvaQCpXYNnxh3zHIW+pUre6PvjgAwDAb7/9Bjs7O/owIbWSQsGw9NgDAMD7rV3gZW/CcyJCiCbiOA4LBjRCnw2pOPXgBS48SUGnhnT1WFNVqvC5c+cOwsPD4eXlVdV5CKkyB27E495zMUxEOviilyffcQghGszD1gRj2rlix6VoLDnyAIGfd4IOtRfUSJX6qbVq1QpxcXFVnYWQKpMrkWHVy9HXP+vhAStjGn2dEPJ2ZvTwhIWhLp4k5+Cvq7F8xyGVVKkrPtu2bcMnn3yC58+fw9fXF7q6uirz/fz8qiQcIZW1+dwzpGRL4GpliLHt3fiOQwipA8wMdTGrtxe+OXQP6049xqCmjrAwoj7BNE2lCp+UlBQ8e/YM48ePV07jOA6MMXAcB7lcXmUBCamo55n52PJyVOX5/RpBpCN8wxqEEKKe91u7YFdoDB4lZWP96cdYMtiX70ikgip1q2vChAlo3rw5rly5gsjISERFRan8lxA+fR/4CBKZAm3qW6JPYzu+4xBC6hChgMOCgT4A8LIAoi5cNE2lrvjExMTg8OHDpQ5USgifbsRm4PDtBHAc8O0AenydEFL12jewRj9fewTeS8KSIw/w10dt6G+NBqnUFZ/u3bvj9u3bVZ2FkLfCGMN3R4seX3/X3wm+9cx4TkQIqau+6t8IejoCXH6WhqAHL/iOQyqg0mN1zZw5E4sWLcKBAwdw+PBhlVd1OXbsGNq0aQMDAwNYW1tj2LBhKvNjY2MxcOBAGBkZwdraGtOnT4dUKq22PKR2OXw7ATdjM2GoJ8Ts3tTVAiGk+jhbGmJyJ3cAwLJjD1FQSG1bNUWlbnV98sknAIAlS5aUmFddjZsPHDiASZMmYfny5ejevTsYY7h7965yvlwuR0BAAGxsbHDx4kWkpaVh7NixYIxh06ZNVZ6H1C75Ujm+D3wEAJjStQFsTfV5TkQIqes+7doA+8LjEJueh98uRWFKV2r+oQk4xhjjO8SbyGQyuLm5YfHixZg4cWKpywQGBmLAgAGIi4uDo6MjAGDPnj0YN24ckpOTYWpqqta+xGIxzMzMkJWVpfY6hH+bzjzB2lOPUc/cAGdmdYG+Lj3JRQipfv/ejMfMf27DUE+Is7O70pcuHqn7+a0R3U7euHEDz58/h0AgQPPmzeHg4IB+/frh/v37ymWuXLkCX19fZdEDFI0gL5FIEB4eXua2JRIJDbKq4V6IC/DLuWcAgLn9vKnoIYTUmMFN66GZsznypHKsO/WY7zhEDZUufM6dO4eBAwfCw8MDDRs2xKBBg3DhwoWqzKZU/Ij8okWL8M033+Do0aOwsLBAly5dkJ6eDgBISkqCnZ3qo8sWFhbQ09NDUlJSmdtesWIFzMzMlC9nZ+dqeQ+k+qw5GYE8qRwtXMwx0M+B7ziEEC0iEHD4dkDR6O17w+LwMJG+PNd2lSp8du3ahZ49e8LQ0BDTp0/HtGnTYGBggB49euDvv/9WezuLFi0Cx3HlvsLCwqBQKAAAX3/9NYYPHw5/f3/s2LEDHMdh3759yu2V9jhhcaeKZZk/fz6ysrKULxqKQ7Pce56F/TfiAdDj64QQfvi7WiKgiQMUDFh+/CE0oAWJVqtU4+Zly5Zh1apVmDlzpnLa559/jnXr1uG7777DqFGj1NrOtGnTMHLkyHKXcXNzQ3Z2NgDAx8dHOV0kEsHd3R2xsUXjpdjb2+Pq1asq62ZkZKCwsLDElaBXiUQiiEQ0jpMmYoxhydEHYAwY0swRzV0s+I5ECNFSc/t6vxy5PRVnH6egm5ct35FIGSp1xScyMhIDBw4sMX3QoEGIiopSezvW1tbw9vYu96Wvrw9/f3+IRCJEREQo1y0sLER0dDRcXV0BAO3atcO9e/eQmJioXCYoKAgikQj+/v6VeZukljt5PwnXotKhryvAnL7efMchhGgxFytDjOvgBqDo8XaZXMFvIFKmShU+zs7OOHPmTInpZ86cqZY2Mqampvjkk0+wcOFCBAUFISIiAp9++ikA4N133wUA9O7dGz4+Phg9ejRu3ryJM2fOYPbs2Zg0aRI9nVUHSWRyLD9e9Pj65E7ucDQ34DkRIUTbTe3mAQtDXTxNzsGe69Rsoraq1K2uWbNmYfr06bh16xbat28PjuNw8eJF7Ny5Ez/88ENVZwQArF69Gjo6Ohg9ejTy8/PRpk0bBAcHw8Ki6PaGUCjEsWPHMGXKFHTo0AEGBgYYNWoU1qxZUy15CL92XopGbHoebE1E+LhLA77jEEIIzAx0MaOnJxYevo/1px5jcDNHmOjr8h2LvKbS/fj8+++/WLt2LR4+fAgAaNSoEb788ksMHjy4SgPWNOrHp/ZLzZGg2+qzyJbIsObdpnjH34nvSIQQAgAolCvQZ8N5RKbk4tOuDTCXbsPXGHU/vzWiA8OaRIVP7ff1v3fx19VYNKlnhv+mdoBAQE9yEUJqj1MPXmDSH2HQ0xEgeFYXOFkY8h1JK1RrB4bu7u5IS0srMT0zMxPu7u6V2SQhanmUJMbua0VP8n07wIeKHkJIrdOzkS3auVtBKlNg9cmIN69AalSlCp/o6OhSx+OSSCR4/vz5W4cipDSMMSw79hAKBvRvYo/W9S35jkQIISVwHIevAxqB44D/biXgVlwm35HIKyrUuPnVkddPnjwJMzMz5b/lcjnOnDkDNze3KgtHyKtCIpJx4Ukq9IQCzOvbiO84hBBSJt96ZhjW3AkHbsRj6dEH2PdJO+pgtZaoUOEzZMgQAEXV7NixY1Xm6erqws3NDWvXrq2ycIQUK5QrsPRYUUP68R3d4GJF98wJIbXbl328cOxuAsJiMhB4Lwn9m9CQOrVBhW51KRQKKBQKuLi4IDk5WflvhUIBiUSCiIgIDBgwoLqyEi22KzQGkSm5sDLSw7RuHnzHIYSQN7I308fkzkXdbawMfASJrGQTEVLzKtXGJyoqCtbW1lWdhZBSZeZJseH0EwDArN5e1C8GIURjfNzZHbYmIsSm5+HPKzF8xyGoZOEzffp0bNy4scT0H3/8ETNmzHjbTISo+OHME2TlF8Lb3gTvtar6nsEJIaS6GIl0MLu3FwBg45knyMiV8pyIVKrwOXDgADp06FBievv27bF///63DkVIsWcpOcpvSd8E+EBIj68TQjTMcH8neNubQFwgww9nnvAdR+tVqvBJS0tTeaKrmKmpKVJTU986FCHFlh97CJmCoWcjW3RsSLdXCSGaRyjg8E2AD4Di9oo5PCfSbpUqfDw8PHDixIkS0wMDA6kDQ1JlLjxJwZlHydARcPiqPz2+TgjRXB0bWqO7ty1kCoYVgY/4jqPVKjVI6RdffIFp06YhJSUF3bt3B1A0MvvatWuxYcOGqsxHtJRMrsDSo0WPr49u5wp3G2OeExFCyNv5qr83zj1OwakHL3DlWRraNbDiO5JWqlThM2HCBEgkEixbtgzfffcdAMDNzQ2//PILxowZU6UBiXb6JywOES+yYW6oi897NOQ7DiGEvDUPWxOMau2CP0NjsOz4Axye2pGG3eFBpW51AcCnn36K+Ph4vHjxAmKxGJGRkVT0kCohLijEuqDHAIAZPRrC3FCP50SEEFI1ZvRsCBORDu49F+PfmzTEEx8qXfgUs7GxgbEx3YYgVefnkGdIy5WigY0RPmjrynccQgipMlbGIkx52Qnr6pMRyJdSp4Y1rVK3ugBg//792Lt3L2JjYyGVqvZLcOPGjbcORrRTfEYefrsUBQD4qn8j6ArfujYnhJBaZXwHN+wKjcHzzHxsvRCJ6XQ7v0ZV6lNl48aNGD9+PGxtbXHz5k20bt0aVlZWiIyMRL9+/ao6I9Eia05GQCpToH0DK3T3tuU7DiGEVDl9XSHm9vMGAGw+9wzJ4gKeE2mXShU+P//8M7Zs2YIff/wRenp6mDNnDk6dOoXp06cjKyurqjMSLXEnPhOHbiWA44qu9tBIxoSQumqgnwOau5gjTyrH2pdtGknNqFThExsbi/bt2wMADAwMkJ2dDQAYPXo0du/eXXXpiNZgjGHZy9HXhzavB996JTvIJISQuoLjOHwTUNQ/2d7wODxMFPOcSHtUqvCxt7dHWloaAMDV1RWhoaEAigYvZYxVXTqiNU4/TMbVqHSIdATKcW0IIaQu83e1REATBzAGLDv2kD4/a0ilCp/u3bvjyJEjAICJEydi5syZ6NWrF9577z0MHTq0SgOSuq9QrsCKwKKrPRM71oejuQHPiQghpGbM7esNPaEAF5+m4mxECt9xtEKlnurasmULFAoFAOCTTz6BpaUlLl68iIEDB+KTTz6p0oCk7ttzPQ6RKbmwMtLDp10b8B2HEEJqjIuVIcZ1cMOW85FYdvwhOjW0hg49zVqtKnx0ZTIZvvvuOyQmJiqnjRgxAhs3bsT06dOhp0edzRH1ZRcUYsOpl50V9mwIE31dnhMRQkjNmtrNAxaGunianIPd1+P4jlPnVbjw0dHRwerVqyGXU6dL5O1tPlfUWaG7jRFGtnbhOw4hhNQ4MwNdzOjpCQDYcOoxsgsKeU5Ut1XqelrPnj1x9uzZKo5CtE1CZj62XSjqrHB+P+qskBCivUa1cYG7jRHScqX4+ewzvuPUaZVq49OvXz/Mnz8f9+7dg7+/P4yMjFTmDxo0qErCkbptTVAEJDIF2tS3RM9G1FkhIUR76QoFmN+vESb9EYbtF6MwqrULnC0N+Y5VJ3GsEs/PCQRlfzPnOE6jb4OJxWKYmZkhKysLpqamfMeps+49z8LAHy+CMeDwtA7wczLnOxIhhPCKMYZRW6/iSmQaBjV1xMb3m/MdSaOo+/ldqXsLCoWizJcmFz2kZhR3VsgYMLiZIxU9hBCCogsHXwc0AscBh28n4GZsBt+R6iS1Cx9LS0ukpqYCACZMmKDsrZmQigqJSMaVyDToUWeFhBCiwreeGYa3cAIALKVODauF2oWPVCqFWFzUpfbvv/+OggIaVI1UnEyuwIrjjwAUjVBM97AJIUTV7N5eMNAVIjwmA4H3kviOU+eo3bi5Xbt2GDJkCPz9/cEYw/Tp02FgUHoPu7/99luVBSR1y96weDxJzoGFoS6mdPXgOw4hhNQ69mb6mNTZHRvPPMGKwIfo0cgWIh0h37HqDLWv+OzatQv9+/dHTk4OACArKwsZGRmlvggpTY5EhnUvOyv8vEdDmBlQZ4WEEFKajzu7w9ZEhLj0fPxxOYbvOHVKpZ7qql+/PsLCwmBlZVUdmXhFT3VVn3VBEdgY/BRuVoYImtkFejrUbw8hhJRl7/U4zDlwByb6Ojj3ZTdYGtHICOWp8qe6Xm3c3K1bNxqaglRIUlYBtlyIBADM6+dNRQ8hhLzBcH8neNubILtAho1nnvAdp86gxs2kRqwNikBBoQItXS3Qp7E933EIIaTWEwo4fBPgAwDYFRqDZyk5PCeqG6hxM6l2DxLE2H8jHgBe9lHB8ZyIEEI0Q8eG1ujubYvgR8lYcfwRto1tyXckjVepxs0cx1HjZqK2FYFFnRUO8HNAcxcLvuMQQohG+aq/N4QCDqcfvsCVZ2l8x9F41Lj5NdS4uWqde5yCsb9dg55QgDOzulC/PYQQUgnfHLqLXaGx8HMyw6EpHSAQ0JXz11XrkBVRUVF1sughVUuuYFh+7CEAYGx7Vyp6CCGkkj7v4QkjPSHuxGfhyJ0EvuNoNLXb+GzcuBGTJ0+Gvr4+Nm7cWO6y06dPf+tgRPPtD49DxItsmBnoYlq3hnzHIYQQjWVjIsLHXRpg3anHWH0yAn197alTw0pS+1bXq7e36tevX/YGOQ6RkZFVFrCm0a2uqpErkaHbmrNIzpbgm4BG+KiTO9+RCCFEo+VJZei6mv6ulkXdz2+1r/hERUWV+v+ElGbrhUgkZ0vgYmmI0e1c+Y5DCCEaz1BPB7N6e2LugbvYFPwU7/o7w8yQesCvKLULny+++EKt5TiOw9q1aysdqDRnz55Ft27dSp137do1tGrVCgAQGxuLqVOnIjg4GAYGBhg1ahTWrFlDnS3WsGRxAX49V3TVb25fb7ocSwghVeQdf2f8djEaES+y8WPIE3z9sp8foj61C5+bN2+q/Ds8PBxyuRxeXl4AgMePH0MoFMLf379qEwJo3749EhMTVaZ9++23OH36NFq2LOrTQC6XIyAgADY2Nrh48SLS0tIwduxYMMawadOmKs9Eyrbu1GPkF8rR3MUc/ZtQZ4WEEFJVhAIO8/p7Y/yO6/j9cgzGtHOjB0cqSO3CJyQkRPn/69atg4mJCX7//XdYWBT1y5KRkYHx48ejU6dOVR5ST08P9vb//wAtLCzE4cOHMW3aNGVneEFBQXjw4AHi4uLg6OgIAFi7di3GjRuHZcuWUXudGhKRlI29YXEAgG+os0JCCKlyXT1t0MHDCpeepmFNUAR+GNmc70gapVKPs69duxYrVqxQFj0AYGFhgaVLl1b5ba7SHD58GKmpqRg3bpxy2pUrV+Dr66ssegCgT58+kEgkCA8PL3NbEokEYrFY5UUqb0XgQygY0M/XHv6ulnzHIYSQOofjOMzv1wgA8N+tBNyJz+Q3kIapVOEjFovx4sWLEtOTk5ORnZ391qHeZPv27ejTpw+cnZ2V05KSkmBnZ6eynIWFBfT09JCUlFTmtlasWAEzMzPl69Vtkoq58CQFZyNSoCPgMLevN99xCCGkzvKtZ4ahzesBAJYff4hK9EWstSpV+AwdOhTjx4/H/v37ER8fj/j4eOzfvx8TJ07EsGHD1N7OokWLwHFcua+wsDCVdeLj43Hy5ElMnDixxPZKu63CGCv3dsv8+fORlZWlfMXFxamdn/yfXMGw7GVnhaPbucLN2ojnRIQQUrfN6u0JPR0BQiPTEfwome84GkPtNj6v2rx5M2bPno0PP/wQhYWFRRvS0cHEiROxevVqtbczbdo0jBw5stxl3NzcVP69Y8cOWFlZYdCgQSrT7e3tcfXqVZVpGRkZKCwsLHEl6FUikQgikUjtzKR0B2/E41FSNkz0dTC9O3VWSAgh1c3JwhDjO7jh13ORWBH4CF08baAjrNT1DK1SqcLH0NAQP//8M1avXo1nz56BMQYPDw8YGVXsW761tTWsra3VXp4xhh07dmDMmDHQ1VXtu6Bdu3ZYtmwZEhMT4eDgAKCowbNIJKqWJ83I/+VL5VgTFAEA+Ky7ByyMqPsAQgipCVO6euCf63F4mpyDfeHxeL+1C9+Rar23Kg2NjIzg5+eHpk2bVrjoqYzg4GBERUWVepurd+/e8PHxwejRo3Hz5k2cOXMGs2fPxqRJk+iJrmq27UIkXoglcLIwwJh2bnzHIYQQrWFmoIvPXl5lX3fqMXIlMp4T1X4adU1s+/btaN++PRo1alRinlAoxLFjx6Cvr48OHTpgxIgRGDJkCNasWcNDUu2Rki3B5nPPAABz+npDX5c6KySEkJo0uq0rXCwNkZItwdYLmjtkVE1Re6wubUFjdVXM1//exV9XY9HUyQyHpnagfnsIIYQHR+8kYNrfN2GoJ8TZL7vC1kSf70g1Tt3Pb4264kNqlycvsrHnetFTcF/1p84KCSGELwFNHNDM2Rx5Ujk2nH7Cd5xajQofUmkrAx9BrmDo7WOHNu5WfMchhBCtxXEcvupf1AykqLFz9fepp6mo8CGVcvlpKs48SoaOgMO8ftRZISGE8K11fUv08rGDXMGwMvAR33FqLSp8SIUpFAzLjhd1VvhBGxe42xjznIgQQggAzOvnDaGAw+mHyQiNTOM7Tq1EhQ+psEO3nuN+ghgmIh1M70GdFRJCSG3RwMYY77cuGnpp+fGHUCjo+aXXUeFDKqSgUI41J4s6K5zSzQNWxtTrNSGE1Caf9/CEkZ4Qd+KzcPRuIt9xah0qfEiF/HYpCglZBXA008f4Dm58xyGEEPIaGxMRPunSAACw6sQjSGRynhPVLlT4ELWl50rxS0hRZ4Wz+3hRZ4WEEFJLfdTJHXamIsRn5OPPKzF8x6lVqPAhatsU/ATZEhl8HEwxpFk9vuMQQggpg4GeEF/08gQAbAp+iqy8Qp4T1R5U+BC1xKTlYldo0beGr/o3gkBAnRUSQkht9o6/M7zsTJCVX4ifzj7lO06tQYUPUcvqkxEolDN09rRBx4bWfMchhBDyBkIBh3n9i/pZ23kpGnHpeTwnqh2o8CFvdCsuE0fvJILjgHl9qbNCQgjRFF09bdDBwwpSuQJrgiL4jlMrUOFDysUYw4qXnRUOa+4EH0cauJUQQjQFx3GY369oKIv/biXgTnwmv4FqASp8SLmCHyXjalQ69HQEmNXbk+84hBBCKsi3nhmGNi96IGX58YdgTLs7NaTCh5RJJlcox3uZ0KE+HM0NeE5ECCGkMmb19oSejgChkekIiUjmOw6vqPAhZdofHo8nyTkwN9TFp10b8B2HEEJIJTlZGCo7nV1x/BFkcgW/gXhEhQ8pVZ5UhnWnHgMAPuveEGYGujwnIoQQ8jamdPWAhaEuniTnYF94PN9xeEOFDynV9gtRSM6WwNnSAB+2deE7DiGEkLdkZqCLz7oXDSy97tRj5EpkPCfiBxU+pITUHAk2nysamuLLPt4Q6dDQFIQQUhd82NYVLpaGSMmWYNuFKL7j8IIKH1LCxjNPkCuVw8/JDAOaOPAdhxBCSBXR0xFgTl8vAMCv558hObuA50Q1jwofoiIyJQd/X40FAMzr501DUxBCSB0T0MQBzZzNkSeVY8PpJ3zHqXFU+BAVq09GQKZg6O5ti/YNaGgKQgipaziOw9cBRZ0a/nM9Dk+Ts3lOVLOo8CFK4TEZCLyXBAEHzKWhKQghpM5q5WaJ3j52kCuYsr82bUGFDwGgOjTFu/7O8LI34TkRIYSQ6jS3nzeEAg6nHyYjNDKN7zg1hgofAgAIevACYTEZ0NcVYGYvGpqCEELqugY2xni/tTMAYMXxh1AotGMoCyp8CArlCnz/8lLnRx3dYW+mz3MiQgghNeHzHp4w0hPidnwWjt5N5DtOjaDCh+Cf63GITM2FpZEePu7iznccQgghNcTGRIRPuhQNSbTqxCNIZHKeE1U/Kny0XI5Ehg2ni4am+LxHQ5jo09AUhBCiTT7q5A47UxHiM/Lx55UYvuNUOyp8tNzW85FIzZHC1coQ77emoSkIIUTbGOgJMatXUaeGm4KfIiuvkOdE1YsKHy2WnF2ArRciAQBz+nhDT4dOB0II0UbD/Z3gZWeCrPxC/Hz2Kd9xqhV90mmxH04/QZ5UjqbO5ujfxJ7vOIQQQngiFHCY16+o/7Ydl6PxPDOf50TVhwofLfU0OQd7rscBAL7q5w2Oo6EpCCFEm3X1skE7dytIZQqsDYrgO061ocJHS6068QhyBUPPRnZo427FdxxCCCE84zgO8/sXXfX59+ZzPEgQ85yoelDho4WuR6cj6MELCDhgXj8vvuMQQgipJfyczDGwqSMYA1aeqJtDWVDho2UYY1j+cmiK91q5wMOWhqYghBDyf1/29oKukMP5xym49DSV7zhVjgofLXPiXhJuxmbCQFeImT0b8h2HEEJILeNiZYgP2rgCAFYE1r2hLKjw0SKFcgW+f3npclJnd9ia0tAUhBBCSvqsuwdMRDq491yMI3cS+I5Tpajw0SK7r8UiOi0P1sZ6mNyZhqYghBBSOitjET7pWjSUxeqTEXVqKAsqfLREdkEhfjj9BADweU9PGIt0eE5ECCGkNpvQoX6dHMqCCh8tseV8JNJypXC3NsLIVs58xyGEEFLLGegJ8UUvTwDAjyFPkZVfN4ayoMJHC7wQvzI0RV9v6Arpx04IIeTNhrdwgqedMTLzCvHL2Wd8x6kS9AmoBdafeoyCQgX8XS3Qp7Ed33EIIYRoCB2hAHP7vhzK4lIUEurAUBYaU/g8fvwYgwcPhrW1NUxNTdGhQweEhISoLBMbG4uBAwfCyMgI1tbWmD59OqRSKU+Ja4fHL7KxN+zl0BT9aWgKQgghFdPd2xZt6ltCIlNg3anHfMd5axpT+AQEBEAmkyE4OBjh4eFo1qwZBgwYgKSkJACAXC5HQEAAcnNzcfHiRezZswcHDhzArFmzeE7Or+8DH0HBgL6N7eHvasl3HEIIIRqmaCiLRgCAAzfi8ShJs4ey0IjCJzU1FU+fPsW8efPg5+eHhg0bYuXKlcjLy8P9+/cBAEFBQXjw4AF27dqF5s2bo2fPnli7di22bt0KsVizf0iVdeVZGs48SoZQwGFOXxqaghBCSOU0czZHQBOHoqEsAjV7KAuNKHysrKzQqFEj/PHHH8jNzYVMJsOvv/4KOzs7+Pv7AwCuXLkCX19fODo6Ktfr06cPJBIJwsPDy9y2RCKBWCxWedUFCgXDisCioSlGtXaBu40xz4kIIYRosi/7eEFHwOFsRAouP9PcoSw0ovDhOA6nTp3CzZs3YWJiAn19faxfvx4nTpyAubk5ACApKQl2dqoNdy0sLKCnp6e8HVaaFStWwMzMTPlydq4bj3ofu5uIO/FZMNITYnoPGpqCEELI23GzNsIHbVwAFF310dShLHgtfBYtWgSO48p9hYWFgTGGKVOmwNbWFhcuXMC1a9cwePBgDBgwAImJicrtldZwlzFWboPe+fPnIysrS/mKi4urlvdakyQyOVadLLoU+XGXBrAxEfGciBBCSF3wWY+GMBbp4E58Fo7eTXzzCrUQr933Tps2DSNHjix3GTc3NwQHB+Po0aPIyMiAqakpAODnn3/GqVOn8Pvvv2PevHmwt7fH1atXVdbNyMhAYWFhiStBrxKJRBCJ6lZh8FdoLOLS82FjIsJHnerzHYcQQkgdYW0swsed3bH21GOsPvkIfRrbQaQj5DtWhfBa+FhbW8Pa2vqNy+Xl5QEABALVC1QCgQAKhQIA0K5dOyxbtgyJiYlwcHAAUNTgWSQSKdsBaYOs/EJsCi4amuKLXp4w1KOhKQghhFSdiZ3q48/QGMSl5+Ov0FhM6KhZX7A1oo1Pu3btYGFhgbFjx+L27dt4/PgxvvzyS0RFRSEgIAAA0Lt3b/j4+GD06NG4efMmzpw5g9mzZ2PSpEnKq0TaYPO5Z8jIK4SHrTHe9XfiOw4hhJA6xlBPBzNfDmWxKfgJxAWaNZSFRhQ+1tbWOHHiBHJyctC9e3e0bNkSFy9exH///YemTZsCAIRCIY4dOwZ9fX106NABI0aMwJAhQ7BmzRqe09echMx8/HYxCgAwr683dGhoCkIIIdXgXX8nNLAxQkZeITZr2FAWHGNMM5tlVxOxWAwzMzNkZWVp3JWi2ftuY394PFrXt8Q/k9tSL82EEEKqzakHLzDpjzCIdAQ4+2VXOJgZ8JpH3c9vuiRQRzxKEuPAjXgAwPx+NDQFIYSQ6tWzkS1auVlAIlNgvQYNZUGFTx3xfeAjMAb0b2KP5i4WfMchhBBSx706lMX+8Hg8fpHNcyL1UOFTB1x5loaQiBToCDh82ceb7ziEEEK0RAsXC/TztYeCFX0B1wRU+Gi4V4emeL+1C+pbG/GciBBCiDYpHsrizKNkhEam8R3njajw0XA0NAUhhBA+udsY4/3WRUNZrDj+ELX9mSkqfDSYVKbA6pMRAIDJnWloCkIIIfyY3qMhjPSEuB2fhWO1fCgLKnw02N9XYxCbngdrYxqaghBCCH9sTESY3LkBAGD1yQhIZQqeE5WNCh8NlV1QiI3BTwEAM3o2hJGIhqYghBDCn4861Ye1sQgxaXn4+2oM33HKRIWPhtpyPhLpuVK4WxvhvVbOfMchhBCi5YxEOpjZq6it6cbgp8iupUNZUOGjgZLFBdh2oWhoijl9vaBLQ1MQQgipBd5r6Qx3GyOk50rx67lIvuOUij4xNdD600+QXyhHCxdz9Glsz3ccQgghBACgIxRgbt+i/uS2XYzEC3EBz4lKosJHwzxNzsbesDgAwPz+jWhoCkIIIbVKbx87+LtaoKCwdg5lQYWPhvn+RATkCoaejezQys2S7ziEEEKICo7j8FX/oqs+e8Pi8KSWDWVBhY8GCYtOx6kHLyDggHn9vPiOQwghhJTK39USfRrbFQ1lcSKC7zgqqPDREIwxLD9eNDTFe62c4WFrwnMiQgghpGxz+npDKOBw+uELXItK5zuOEhU+GuLk/Re4EZsJfV0BZvT05DsOIYQQUq4GNsYY+bK7leW1aCgLKnw0gEyuwKqTRaPeftTRHXam+jwnIoQQQt7s854NYagnxK24TATeS+I7DgAqfDTCP2FxiEzJhaWRHj7u4s53HEIIIUQttib6mNSp6HNr1YlHKJTzP5QFFT61XK5Ehg2nnwAAPuvuARN9XZ4TEUIIIeqb1Nkd1sZ6iE7Lw+5rsXzHocKnttt2IQop2RK4WBrigzaufMchhBBCKsRYpIPPX7ZN/eH0E+RIZLzmocKnFkvNkWDL+WcAgNl9vKCnQz8uQgghmmdkK2e4WxshLVeKLeee8ZqFPklrsY1nniBXKoefkxkGNHHgOw4hhBBSKbpCAeb0Lep/buuFKCTzOJQFFT61VFRqLv6+WnQvdF4/bwgENDQFIYQQzdWnsT1auJgjv1DO6xNeOrztmZRrzckIyBQMXb1s0L6BNd9xCCGEkLfCcRwWD/JFjkSGdg2seMtBhU8tdCsuE8fuJoLjoBzllhBCCNF0TZzM+I5At7pqG8YYVrwcmmJYcyc0cjDlOREhhBBSd1DhU8sEP0rG1ah06OkI8EVvGpqCEEIIqUpU+NQicgXD9yeKhqYY394N9cwNeE5ECCGE1C1U+NQiB8Lj8fhFDswMdDGlqwffcQghhJA6hwqfWiJfKse6U48BANO6ecDMkIamIIQQQqoaPdVVS+y4HIUkcQHqmRtgdDsamqK2YIxBJpNBLpfzHYUQUgqhUAgdHR1wHPV1RtRDhU8tkJErxS9ni7rwntXbE/q6Qp4TEQCQSqVITExEXl4e31EIIeUwNDSEg4MD9PT0+I5CNAAVPrXAjyFPkV0gQyMHUwxpVo/vOASAQqFAVFQUhEIhHB0doaenR98oCallGGOQSqVISUlBVFQUGjZsCIGAWnCQ8lHhw7O49Dz8eSUGAA1NUZtIpVIoFAo4OzvD0NCQ7ziEkDIYGBhAV1cXMTExkEql0NfX5zsSqeWoNObZmqAISOUKdPCwQueGNDRFbUPfHgmp/ej3lFQEnS08uvc8C//dSgAAzOvbiG6lEEIIIdWMCh8erQws6qxwcDPHWjF+CSGEEFLXUeHDk/OPU3DxaSr0hALM7u3FdxxCCCFEK1DhwwOFgimv9nzY1hXOltR4llS9lJQU6OrqIi8vDzKZDEZGRoiNjVXOT09Px2effQYvLy8YGhrCxcUF06dPR1ZWFo+pa59FixahWbNmfMfQaF27dsWMGTP4jkEIAHqqixf/3X6OB4limIh0MK07DU1BqseVK1fQrFkzGBoa4urVq7C0tISLi4tyfkJCAhISErBmzRr4+PggJiYGn3zyCRISErB//34ek2umwsJC6OrWzh7Xa3O2ipBKpdRXD3lrdMWnhhUUyrHmZNHQFJ90bQBLI/ol1gSMMeRJZby8GGOVynz58mV06NABAHDx4kXl/xfz9fXFgQMHMHDgQDRo0ADdu3fHsmXLcOTIEchkMrX3I5VKMW3aNDg4OEBfXx9ubm5YsWKFcn5mZiYmT54MOzs76Ovrw9fXF0ePHgUApKWl4f3334eTkxMMDQ3RpEkT7N69W2X7Xbt2xfTp0zFnzhxYWlrC3t4eixYtUjtfVlYWJk+eDFtbW5iamqJ79+64ffs2gKKrYvb29li+fLly+atXr0JPTw9BQUHYuXMnFi9ejNu3b4PjOHAch507dwIAOI7D5s2bMXjwYBgZGWHp0qWQy+WYOHEi6tevDwMDA3h5eeGHH35QO+u4ceMwZMgQLF68WJn3448/hlQqVS5z4sQJdOzYEebm5rCyssKAAQPw7Nkz5fzo6GhwHIe9e/eia9eu0NfXx65du9Q+1p999hlmzJgBCwsL2NnZYcuWLcjNzcX48eNhYmKCBg0aIDAwUGW9Bw8eoH///jA2NoadnR1Gjx6N1NRU5Xs6d+4cfvjhB+UxjI6OfuN6xXmmTZuGL774AtbW1ujVq5fax5KQstAVnxr255UYPM/Mh72pPiZ0qM93HKKm/EI5fBac5GXfD5b0gaGeer+qsbGx8PPzAwDk5eVBKBRi586dyM/PB8dxMDc3x6hRo/Dzzz+Xun5WVhZMTU2ho/P//XXt2hVubm7KD/zXbdy4EYcPH8bevXvh4uKCuLg4xMXFASjqCLJfv37Izs7Grl270KBBAzx48ABCYVHv5AUFBfD398fcuXNhamqKY8eOYfTo0XB3d0ebNm2U+/j999/xxRdf4OrVq7hy5QrGjRuHDh06vPGDkDGGgIAAWFpa4vjx4zAzM8Ovv/6KHj164PHjx7CxscFvv/2GIUOGoHfv3vD29saHH36IKVOmoHfv3sjPz8e9e/dw4sQJnD59GgBgZvb/BxEWLlyIFStWYP369RAKhVAoFHBycsLevXthbW2Ny5cvY/LkyXBwcMCIESPe8NMrcubMGejr6yMkJATR0dEYP348rK2tsWzZMgBAbm4uvvjiCzRp0gS5ublYsGABhg4dilu3bqk81j137lysXbsWO3bsgEgkqtCxnjNnDq5du4Z//vkHn376KQ4dOoShQ4fiq6++wvr16zF69GjExsbC0NAQiYmJ6NKlCyZNmoR169YhPz8fc+fOxYgRIxAcHIwffvgBjx8/hq+vL5YsWQIAsLGxeeN6r+b59NNPcenSpUp/CSDkVRzTkDPpxo0bmDt3Lq5fvw6hUIjhw4dj3bp1MDY2Vi4TGxuLqVOnIjg4GAYGBhg1ahTWrFlToUujYrEYZmZmyg+AqpSVV4jOq0OQlV+I74c3wXutXN68EuFFQUEBoqKiUL9+fejr6yNPKtOIwkcmkyE+Ph5isRgtW7bE9evXYWxsjGbNmuHYsWNwcXGBsbExrK1L9hmVlpaGFi1aYPTo0Vi6dKly+pgxY1CvXj2Vqzivmj59Ou7fv4/Tp0+X6JIhKCgI/fr1w8OHD+Hp6anWewgICECjRo2wZs0aAEWFl1wux4ULF5TLtG7dGt27d8fKlSvL3VZwcDCGDh2K5ORkiEQi5XQPDw/MmTMHkydPBgBMnToVp0+fRqtWrXD79m1cv35d2RHeokWLcOjQIdy6dUtl2xzHYcaMGVi/fn25GaZOnYoXL16odftw3LhxOHLkCOLi4pQdZ27evBlffvklsrKySu2vJiUlBba2trh79y58fX0RHR2N+vXrY8OGDfj888/L3d+bjrVcLoeZmRmGDRuGP/74AwCQlJQEBwcHXLlyBW3btsWCBQtw9epVnDz5/9+P+Ph4ODs7IyIiAp6enujatSuaNWuGDRs2KJdRd72srCzcvHmz3Pfx+u8r0U7qfn5rxBWfhIQE9OzZE++99x5+/PFHiMVizJgxA+PGjVP+MZHL5QgICICNjQ0uXryItLQ0jB07FowxbNq0ied3UOTnc0+RlV+IhrbGGN7Cie84pAIMdIV4sKQPb/tWl46ODtzc3LB37160atUKTZs2xaVLl2BnZ4fOnTuXuZ5YLEZAQAB8fHywcOFClXnFH3hlGTduHHr16gUvLy/07dsXAwYMQO/evQEAt27dgpOTU5lFj1wux8qVK/HPP//g+fPnkEgkkEgkMDIyUlmu+CpWMQcHByQnJ5ebCwDCw8ORk5MDKysrlen5+fkqt4fWrFkDX19f7N27F2FhYWp/eLZs2bLEtM2bN2Pbtm2IiYlBfn4+pFJphRpHN23aVKW38Hbt2iEnJwdxcXFwdXXFs2fP8O233yI0NBSpqalQKBQAir74+fr6lpmtMsdaKBTCysoKTZo0UU6zs7MDAOXxDw8PR0hIiMqX0GLPnj0r82ev7nqlHWNC3oZGFD5Hjx6Frq4ufvrpJ+U3np9++gnNmzfH06dP4eHhgaCgIDx48ABxcXFwdHQEAKxduxbjxo3DsmXLqvzqTUUlZOZjx6VoAEVDU+gIqXmVJuE4Tu2rLnxq3LgxYmJiUFhYCIVCAWNjY8hkMshkMhgbG8PV1RX3799XWSc7Oxt9+/aFsbEx/v333wo3gm3RogWioqIQGBiI06dPY8SIEejZsyf2798PAwODctddu3Yt1q9fjw0bNqBJkyYwMjLCjBkzVNq0ACiRieM45Qd+eRQKBRwcHHD27NkS88zNzZX/HxkZiYSEBCgUCsTExJQotMryetGwd+9ezJw5E2vXrkW7du1gYmKC1atX4+rVq2ptrzzFV9MGDhwIZ2dnbN26FY6OjlAoFPD19S1xzF7P9jbH+tVpxTmKj79CocDAgQPx/fffl8js4OBQ5vtRd73X3wchb6v2/yUHIJFIoKenp3KZt/gP6sWLF+Hh4YErV67A19dXWfQAQJ8+fSCRSBAeHo5u3bqVuW2JRKL8t1gsrpb3sO7UY0hlCrSub4nu3rbVsg9Cjh8/jsLCQvTo0QOrVq2Cv78/Ro4ciXHjxqFv374lPtTEYjH69OkDkUiEw4cPV/o2gampKd577z289957eOedd9C3b1+kp6fDz88P8fHxePz4canf/C9cuIDBgwfjww8/BFD0YfjkyRM0atSoUjle16JFCyQlJSmvhJVGKpXigw8+wHvvvQdvb29MnDgRd+/eVV7Z0NPTg1wuV2t/Fy5cQPv27TFlyhTltFevLKnj9u3byM/PV/6NCw0NhbGxMZycnJCWloaHDx/i119/RadOnQAU/Q1UN1t1HOsWLVrgwIEDcHNzU2kb9qrSjqE66xFSHTTiskP37t2RlJSE1atXQyqVIiMjA1999RUAIDExEUDRfefiP1TFLCwsoKenh6SkpDK3vWLFCpiZmSlfzs7OVZ5foWCQyRXgOGB+P28amoJUG1dXVxgbG+PFixcYPHgwXFxc8ODBAwwbNgweHh5wdXVVLpudnY3evXsjNzcX27dvh1gsRlJSEpKSklQ+pMaMGYP58+eXuc/169djz549ePToER4/fox9+/bB3t4e5ubm6NKlCzp37ozhw4fj1KlTyitDJ06cAFDU1ubUqVO4fPkyHj58iI8//rjc39eK6tmzJ9q1a4chQ4bg5MmTiI6OxuXLl/HNN98gLCwMAPD1118jKysLGzduxJw5c9CoUSNMnDhRuQ03NzdERUXh1q1bSE1NVfmi9DoPDw+EhYXh5MmTePz4Mb799ltcv369QpmlUikmTpyIBw8eIDAwEAsXLsS0adMgEAhgYWEBKysrbNmyBU+fPkVwcDC++OILtbZbXcd66tSpSE9Px/vvv49r164hMjISQUFBmDBhgvI8cnNzw9WrVxEdHa28PafOeoRUB14Ln0WLFikfbyzrFRYWhsaNG+P333/H2rVrYWhoCHt7e7i7u8POzk75dAiAUgsKxli5hcb8+fORlZWlfBU/jVKVBAIOG0Y2x9nZXdHcxaLKt0/Iq86ePYtWrVpBX18fV69eRb169VSuhBYLDw/H1atXcffuXXh4eMDBwUH5evX3IDY2VvkFozTGxsb4/vvv0bJlS7Rq1QrR0dE4fvy48grtgQMH0KpVK7z//vvw8fHBnDlzlB9s3377LVq0aIE+ffqga9eusLe3x5AhQ6rsWHAch+PHj6Nz586YMGECPD09MXLkSERHR8POzg5nz57Fhg0b8Oeff8LU1BQCgQB//vknLl68iF9++QUAMHz4cPTt2xfdunWDjY1NiUfAX/XJJ59g2LBheO+999CmTRukpaWpXP1RR48ePdCwYUN07twZI0aMwMCBA5WP7wsEAuzZswfh4eHw9fXFzJkzsXr1arW2W13H2tHREZcuXYJcLkefPn3g6+uLzz//HGZmZspzYPbs2RAKhfDx8YGNjQ1iY2PVWo+Q6sDrU12pqakqfTaUxs3NTeXy+4sXL2BkZASO42Bqaoo9e/bg3XffxYIFC/Dff/8p++cAgIyMDFhaWiI4OLjMW12vq86nuojmoKdECB/GjRuHzMxMHDp0iO8oGoV+XwmgIU91WVtbl/pYbXmKb2f99ttv0NfXV/bj0a5dOyxbtgyJiYnKhnFBQUEQiUTw9/ev2uCEEEII0Uga06Lsxx9/RPv27WFsbIxTp07hyy+/xMqVK5VPZvTu3Rs+Pj4YPXo0Vq9ejfT0dMyePRuTJk2iKzeE1FF//fUXPv7441LnlfYEG99Ke3S72Ou9IRNCqofGFD7Xrl3DwoULkZOTA29vb/z6668YPXq0cr5QKMSxY8cwZcoUdOjQQaUDQ0JI3TRo0CCVXodfVRvHpnq9E8RX1atXT/mkFiGk+mhM4fOmTtQAwMXFRTkGECGk7jMxMYGJiQnfMdTm4UGDEhPCN2o6T0g5NGREF0K0Gv2ekoqgwoeQUhTfJsnLy+M5CSHkTYp/T2vj7U1S+2jMrS5CapJQKIS5ublyPCJDQ0PqeJKQWoYxhry8PCQnJ8Pc3FylXzdCykKFDyFlsLe3BwC1BsMkhPDH3Nxc+ftKyJtQ4UNIGTiOg4ODA2xtbVFYWMh3HEJIKXR1dSt8pSchIQGBgYEQCARwcHBA3759AQCXLl1CREQEzM3NMXjwYMjlcuzevRsKhQIikQjDhw+HSCQCUDTkyw8//IApU6bA0tJSZftRUVEIDg6Gjo4Ohg4dClNTUzx79gwhISHQ0dFB//79YWurOmZjcnKy8uGcgIAAZc/ijx49gr6+Pry8vNCuXTuVdfbs2YPo6GiMGDEC7u7uAICdO3cq53fp0gX169dXWefHH39UdqsQEBAAGxsbhIaG4t69ewCKxrh8degmqVRa4WNQ2vFNSEhAUFAQACArKwtt2rSBj48PDh48CADIzc1FgwYN0Ldv31KP3/3793H58mUAQKdOneDt7Q2ZTIZjx44hMzMT1tbW6j8VyYiKrKwsBoBlZWXxHYUQQkg1yM7OZlKplDHG2MGDB1lSUhLLyclhu3btYowxduHCBXbv3j1WWFjIxGIxY4yx8PBwFhoaqtxGUFAQ27FjB0tLSyux/Z07d7KCggIWFxfHjh49yhhj7LfffmMSiYSJxWL2zz//lFhnz549LDMzk2VlZbHdu3czxhgLCQlhz549K/N9iMXiEsvs2LGDyeXyMtfZvn17iWmbN29mCoWCZWRksD179qjMq8wxKO34vmr37t0l1jl+/LjyfZR2/LZt28akUimTSCTK93Dx4kWV967u5zc1biaEEKJVjI2NlQ2hOY6DQCDA8+fP4ebmBgBwd3dHfHw8dHR0lN0lFC8HFF2dkEgkyg50X1VYWAgdHR2IRCI4OTmpDMukp6cHExMTpKenl1gvPz8fZmZmMDU1RUFBgXL66dOn8ccff5Q6oGxpXTlwHIc//vgD+/fvR35+PoCi/qMSEhKU+9mxYweOHDkCmUwGALC0tIRMJkNBQQEMDAxU1qnMMSjt+BaTSqXIyckpcZUsNjYWbm5uZR4/a2trSKVSSKVS5bAk0dHRiIiIwM6dOxEREVEiR1mo8CGEEKKVXrx4gby8PNjY2KCgoEB5C0dfX1+l+JBKpbhx4waaNGkCAAgNDUXr1q1L3WZ+fr5yOwCgUCiU/5+Tk1PmGJXslUfyi/+/TZs2mDx5MgICAtTu2XvEiBEYN24cvLy8cP78eQBAs2bNlAMVT5gwAePHj4e5uTnCw8MBAPXr18dPP/2Ev//+W9kh6KvrVPQYFHv1+BZ78uRJif6snj9/Dnt7ewgEgjKPn7e3N7Zs2YItW7YoM2ZkZMDT0xOjRo3C+fPnVY51eaiNDyGEEK2Tn5+P48eP49133wVQVOxkZ2cDACQSifKqAmMM//33H7p3764siMRisUobndzcXOzbtw8A8MEHH0AikSjnFT8N2rt3bxw4cACmpqbKNjR//PEHFAoF3nnnHZWnRov/v/jqi5WVldrvq3gdb2/vUnsKf3V+aGgoJBIJbt68ic8++ww5OTk4evQoPvjgA5V11DkGr3v9+BZ7+PBhibY4Dx8+hLe3tzJfaccvJCQEU6ZMAWMMf/31Fxo0aACRSARXV1fo6OjA0tJS7e5HqPB5TXGlLRaLeU5CCCGkOigUCvz3339o3749FAoFxGIxTE1NERoaiiZNmuDBgwewtLSEWCzG5cuXYWNjAysrK4jFYiQmJiIlJQU7d+5Eamoq0tPT8c4772DYsGEAij7wCwoKlPPMzMwgFothYmKCoUOHIjMzEzdu3IBYLMaQIUOUeXR0dPD8+XNwHAehUAixWAyJRAKRSIT8/HwUFhaW+rkkkUiQm5urnFe8TkxMDIyNjVXWkcvlYIxBR0cHjx8/hqGhIbKzsyEQCJCbm4vCwkLk5eWV2I+6x6C84wsAMpkMKSkpMDAwUNnHkydP0KJFC+W00o4fx3HKW3dSqRRisRh2dnaIjIyEra0t0tLSlA+hsDd0aMmxNy2hZeLj41VatBNCCKlbfH190a9fP6SkpAAoakcTHx+PDh06wMvLC1lZWTh06BAMDQ0xY8YMxMXFAQDu3buHsLAw5XaGDBmC8+fPl2iz4+7ujm7dukEmk+HQoUPIyspCp06d4O7ujvz8fBw9erTE1Qk7OzsEBAQAAI4fP46kpCQMGDAAtra24DgOp0+fRkxMjMo6/fv3R8OGDVFQUICwsDCEh4dj8uTJKCwsVO47OzsbzZo1w4sXLyAWi/Hhhx9CKpUiPz8fBw8ehFQqRadOneDp6QmBQIBz587h8ePHynVycnLUPgYdO3bE7du34erqWurxbdiwIVxdXXH69Gnl+jY2NujSpQv2799f7vFr1qwZWrZsCQC4ceMGbty4AWNjYwwdOhQikQjh4eG4efMmACAuLg5OTk5l/vyp8HmNQqFAQkICTExMqrTDOrFYDGdnZ8TFxWntaPHafgy0/f0DdAzo/Wv3+wfoGFTn+2eMITs7G46OjioNql9Ht7peIxAIyq0U35apqalWnuyv0vZjoO3vH6BjQO9fu98/QMegut6/mZnZG5ehp7oIIYQQojWo8CGEEEKI1qDCp4aIRCIsXLhQpX8CbaPtx0Db3z9Ax4Dev3a/f4COQW14/9S4mRBCCCFag674EEIIIURrUOFDCCGEEK1BhQ8hhBBCtAYVPoQQQgjRGlT41JCff/4Z9evXh76+Pvz9/XHhwgW+I1WLFStWoFWrVjAxMYGtrS2GDBmCiIgIlWXGjRsHjuNUXm3btuUpcdVatGhRifdmb2+vnM8Yw6JFi+Do6AgDAwN07doV9+/f5zFx1XNzcytxDDiOw9SpUwHUvZ//+fPnMXDgQDg6OoLjOBw6dEhlvjo/c4lEgs8++wzW1tYwMjLCoEGDEB8fX4Pv4u2UdwwKCwsxd+5cNGnSBEZGRnB0dMSYMWOQkJCgso2uXbuWOC9GjhxZw++kct50DqhzzmvyOfCm91/a3wOO47B69WrlMjX586fCpwb8888/mDFjBr7++mvcvHkTnTp1wv/au/+Qqu43DuDvm12rObGs5b1mXUzMQOMujUoZJq5kMimobf2QMnK2oltJDSqotUF/RLAK+rH6o8Ityb9sREahpFILy7xWZmF3eNMYmvRD1zLz5n2+f4wdOunU7+Y9Z57zfsGFez/nc+D5nOe5l+eec39kZmaiublZ79CGXGVlJTZs2ICqqiqUlpbizZs3yMjIwMuXL1XzPvnkE7S0tCi3Cxcu6BTx0IuPj1etra6uTtm2b98+7N+/H4cPH0Z1dTVsNhsWLFig/Cu0EVRXV6vWX1paCgCqf2k2Uv5fvnwJp9OJw4cP97l9MDnPz8/H2bNnUVRUhKtXr+KPP/5AVlYWenp6tFrGv9LfMejs7ITb7cauXbvgdrtRXFyMBw8eYOHChb3m5uXlqeri+PHjWoT/rw1UA8DANT+ca2Cg9b+97paWFpw8eRIWiwVLlixRzdMs/0IBN3v2bFm3bp1qbPr06bJ9+3adItJOW1ubAJDKykplLCcnRxYtWqRfUAG0e/ducTqdfW7z+/1is9lk7969ylhXV5eEhYXJsWPHNIpQe5s3b5aYmBjx+/0iYuz8A5CzZ88qjweT8/b2drFarVJUVKTM+e2332TEiBFy8eJFzWIfKu8eg77cuHFDAEhTU5MyNm/ePNm8eXNgg9NAX+sfqOaNVAODyf+iRYskPT1dNaZl/nnGJ8C6u7tRU1ODjIwM1XhGRgauXbumU1Ta6ejoAACEh4erxisqKjBx4kRMmzYNeXl5aGtr0yO8gPB4PIiMjER0dDSWLVuGxsZGAIDX60Vra6uqFkaNGoV58+YZtha6u7tx+vRprFmzRvWnv0bO/9sGk/Oamhr4fD7VnMjISCQkJBi2Ljo6OmCxWDB27FjVeGFhISZMmID4+Hh8/fXXhjoT2l/Nm6kGHj9+jJKSEuTm5vbaplX++SelAfbkyRP09PQgIiJCNR4REYHW1ladotKGiGDLli346KOPkJCQoIxnZmbi888/h8PhgNfrxa5du5Ceno6ampph/2umc+bMwY8//ohp06bh8ePH2LNnD1JSUlBfX6/ku69aaGpq0iPcgPv555/R3t6O1atXK2NGzv+7BpPz1tZWBAcHY9y4cb3mGPE1oqurC9u3b8eKFStUf1KZnZ2N6Oho2Gw23L17Fzt27MDt27eVS6XD2UA1b6YaKCgoQGhoKBYvXqwa1zL/bHw08va7XeDPpuDdMaNxuVy4c+cOrl69qhpfunSpcj8hIQGzZs2Cw+FASUlJryfDcJOZmancnzFjBpKTkxETE4OCggLlw4xmqoUTJ04gMzMTkZGRypiR8/93/knOjVgXPp8Py5Ytg9/vx9GjR1Xb8vLylPsJCQmIjY3FrFmz4Ha7kZiYqHWoQ+qf1rwRa+DkyZPIzs7G6NGjVeNa5p+XugJswoQJCAoK6tW1t7W19XoXaCQbN27EuXPnUF5ejqioqH7n2u12OBwOeDwejaLTTkhICGbMmAGPx6N8u8sstdDU1ISysjJ8+eWX/c4zcv4Hk3ObzYbu7m48f/78b+cYgc/nwxdffAGv14vS0lLV2Z6+JCYmwmq1GrIu3q15s9TAlStX0NDQMOBrAhDY/LPxCbDg4GAkJSX1Ol1XWlqKlJQUnaIKHBGBy+VCcXExLl++jOjo6AH3efr0KR49egS73a5BhNp6/fo17t+/D7vdrpzGfbsWuru7UVlZachaOHXqFCZOnIhPP/2033lGzv9gcp6UlASr1aqa09LSgrt37xqmLv5qejweD8rKyjB+/PgB96mvr4fP5zNkXbxb82aoAeDPM8BJSUlwOp0Dzg1o/jX5CLXJFRUVidVqlRMnTsi9e/ckPz9fQkJC5OHDh3qHNuTWr18vYWFhUlFRIS0tLcqts7NTRERevHghW7dulWvXronX65Xy8nJJTk6WSZMmye+//65z9P/e1q1bpaKiQhobG6WqqkqysrIkNDRUyfXevXslLCxMiouLpa6uTpYvXy52u90Qa39bT0+PTJkyRbZt26YaN2L+X7x4IbW1tVJbWysAZP/+/VJbW6t8Y2kwOV+3bp1ERUVJWVmZuN1uSU9PF6fTKW/evNFrWf+X/o6Bz+eThQsXSlRUlNy6dUv1uvD69WsREfn111/lu+++k+rqavF6vVJSUiLTp0+XmTNnDotj0N/6B1vzw7kGBnoOiIh0dHTIe++9Jz/88EOv/bXOPxsfjRw5ckQcDocEBwdLYmKi6uvdRgKgz9upU6dERKSzs1MyMjLkgw8+EKvVKlOmTJGcnBxpbm7WN/AhsnTpUrHb7WK1WiUyMlIWL14s9fX1yna/3y+7d+8Wm80mo0aNktTUVKmrq9Mx4sC4dOmSAJCGhgbVuBHzX15e3mfN5+TkiMjgcv7q1StxuVwSHh4uY8aMkaysrGF1TPo7Bl6v929fF8rLy0VEpLm5WVJTUyU8PFyCg4MlJiZGNm3aJE+fPtV3YYPU3/oHW/PDuQYGeg6IiBw/flzGjBkj7e3tvfbXOv8WEZGhP49ERERE9N/Dz/gQERGRabDxISIiItNg40NERESmwcaHiIiITIONDxEREZkGGx8iIiIyDTY+REREZBpsfIiIiMg02PgQEQFIS0tDfn6+3mEQUYDxl5uJiAA8e/YMVqsVoaGheodCRAHExoeIiIhMg5e6iMgw0tLS4HK54HK5MHbsWIwfPx47d+7EX+/vjh49itjYWIwePRoRERH47LPPVPvyUheR8Y3UOwAioqFUUFCA3NxcXL9+HTdv3sTatWvhcDgwc+ZMbNq0CT/99BNSUlLw7NkzXLlyRe9wiUhjbHyIyFAmT56MAwcOwGKxIC4uDnV1dThw4AD27NmDkJAQZGVlITQ0VGmGiMhceKmLiAxl7ty5sFgsyuPk5GR4PB58/PHHcDgcmDp1KlauXInCwkJ0dnbqGCkR6YGNDxGZwvvvvw+3240zZ87Abrfjm2++gdPpRHt7u96hEZGG2PgQkaFUVVX1ehwbG4ugoCCMHDkS8+fPx759+3Dnzh08fPgQly9f1ilSItIDP+NDRIby6NEjbNmyBV999RXcbjcOHTqE77//HufPn0djYyNSU1Mxbtw4XLhwAX6/H3FxcXqHTEQaYuNDRIayatUqvHr1CrNnz0ZQUBA2btyItWvX4pdffkFxcTG+/fZbdHV1ITY2FmfOnEF8fLzeIRORhvgDhkRkGGlpafjwww9x8OBBvUMhov8ofsaHiIiITIONDxEREZkGL3URERGRafCMDxEREZkGGx8iIiIyDTY+REREZBpsfIiIiMg02PgQERGRabDxISIiItNg40NERESmwcaHiIiITON/DjV25HvMm2sAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkwAAAHgCAYAAABXUjLLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAACZOElEQVR4nOzdd3xT1fsH8M9N0qR7b7qYLVD2BpU9lI2KKCJLcIDIkqFfBJSh8EMENwoyBWSoyJBZkE0pQ2aB7tK9ks7M8/uj5NI0aZuWtEnb5/165UV777n3npvekqdnPIdjjDEQQgghhJAyCcxdAUIIIYQQS0cBEyGEEEJIBShgIoQQQgipAAVMhBBCCCEVoICJEEIIIaQCFDARQgghhFSAAiZCCCGEkApQwEQIIYQQUgEKmAghhBBCKkABEyGEEEJIBShgIqQM4eHhmDBhAgIDAyGRSODm5obBgwfj7NmzNXL9zz77DC1atIBGo+G3nTp1CpMmTUJISAjs7OzQoEEDDB8+HBERETrH5ubmYt68eRgwYAA8PDzAcRyWLFlS5rXy8vIwc+ZM+Pr6wtraGm3btsWuXbt0ymzcuBENGjRAfn6+Se/TFJYsWQKO44wqK5VKIRAI8PXXX5u03Nq1a42sbfUw9LxU9jmoScY+y8Yy5hkGLPs5JpaNAiZCDFi0aBG6du2KxMREfPbZZ/jnn3/w1VdfITExEb169cKOHTuq9fpJSUlYtWoVPvvsMwgET39Nf/jhB8TGxuLDDz/E4cOHsW7dOqSlpaFr1644deoUXy4zMxMbNmyAXC7HiBEjKrzeqFGjsGXLFixevBhHjhxBp06d8Prrr+O3337jy4wfPx52dnZYtWqVSe+1pl29ehWMMXTu3Nmocp06dTJJuepU1vNS2eegJhn7LBvLmGcYqDvPMTEDRgjR8emnnzIAbPXq1Xr7ioqKWOPGjZmTkxPLycmptjrMmzePNWjQgKnVap3tqampemVzc3OZl5cX69u3L79No9EwjUbDGGMsPT2dAWCLFy82eK1Dhw4xAOy3337T2d6/f3/m6+vLVCoVv+3//u//mJOTE8vPz6/qrVWLxYsXM2P/O/viiy+YlZUVKywsrLCcSCRiBQUFFZYTCoUsLy/P6PqaWlnPS2Weg5pm7LNsjMo8w4xZ7nNMLBu1MBFSwqVLl7Bs2TKMHz8ec+fO1dsvkUgwdepUSKVSnDx5slrqoFAosHHjRrzxxhs6rQUA4OnpqVfe3t4eLVq0QEJCAr+N4ziju6j++OMP2Nvb49VXX9XZPnHiRCQlJeHy5cv8trFjx0Imkxns6ijt0aNHmDhxIpo2bQpbW1s0aNAAQ4cOxa1bt3TKabvT7ty5g9dffx1OTk7w8vLCpEmTIJVK9c576NAhtG3bFhKJBA0bNsT//d//GXWfWuHh4WjVqhUuXbqEvn37wt7eHt7e3vjss8/0yoWGhsLGxgYAwBjD2rVrYW1tjQULFkCtVvPlmjdvDjs7u0rVw1TKe14q8xzUNGOfZWNU5hkGKvccE6JFARMhJXz++efgOE7vw7OkRo0aAQASExP19jHGoFKpjHqV5fLly8jMzETv3r2NqrNUKsW1a9fQsmVLo8qXdvv2bTRv3hwikUhne+vWrfn9Wt7e3ggJCcGhQ4cqPG9SUhLc3NzwxRdf4J9//sF3330HkUiELl26IDIyUq/8yy+/jGbNmmHfvn1YsGABfvvtN8yaNUunzMmTJzF8+HA4ODhg165dWL16NX7//Xf8+uuvRt/v1atXkZ6ejtmzZ2P8+PE4cOAAXnjhBSxevBhnzpzRKaftZsvIyMDQoUOxfPly/PHHH/jiiy8gFAr1ylWWOZ4XS1bVZ7kyzzBQueeYEC1RxUUIqR+kUimOHTuGAQMGICAgoMxyeXl5AGCwReHMmTNGf3DFxMQgKChIb/vFixcBAO3btzfqPNOmTUN+fj4++eQTo8qXlpmZyQeBJbm6uvL7S2rfvj1OnDhR4XlfeOEFvPDCC/z3arUagwcPRsuWLfHTTz/hq6++0ik/efJkfPTRRwCAfv364dGjR9i0aRM2btzIt5J88skn8PLywvHjx2FtbQ0AGDhwoMH30ZCMjAzExcWhU6dOOHv2LCQSCQAgODgYe/bswd27d9GzZ0++XOfOnfHvv//ijTfeQFBQEG7cuAE/Pz+D5wMAuVyOd999FydOnIBUKkWLFi3w1VdfoXv37gbrY47nxZJV9Vmu7DMMGP8cE6JFARMhT9y6dQsqlQqtWrUqt5z2A0r712tJHTp0QHh4uFHX8/X1Nbg9KSkJHMfB3d29wnMsWrQIO3bswDfffIMOHToYdV1Dyuu2Kb3P09MTaWlpUKlUen/Rl6RSqbBq1Sps374djx49glKp5Pfdu3dPr/ywYcN0vm/dujWKioqQlpYGLy8v5OfnIzw8HO+//z4fLAGAg4MDhg4dii1btlR4n9qfzbJly/hgCXj6gar9mWjLHT9+HO+99x5mzZqFFStW6N2vtlzHjh35e27YsCHOnz8PPz8/bNu2DcOGDUN8fDxsbW316lPTz4upnD592uhA7/r162jbtm2F5Z71Wa7MMwwY/xwTokVPCSFPyGQyAICHh0eZZXJzc7Fz5040bNiQ/5Asyd7e3qgPBwBl/iddWFgIKysrvsunLEuXLsWyZcuwfPlyTJ8+3ahrGuLm5mbwL/CsrCwAT/9K17K2tgZjDEVFRbC3ty/zvLNnz8Z3332H+fPno2fPnnBxcYFAIMDbb7+NwsJCg/UoSRvQaMtmZ2dDo9HA29tb71hD2wy5evUqbGxs0KdPH53t165dAwC0a9eOL2dtbY3Dhw/jhRdeKHNG1dWrVyEWi/ng2c7ODp9++im/f/z48Zg1axYePnyINm3a6B1fk8+LKQUHB+Pnn382qmx5rbVaz/osV/YZBox/jgnRooCJkCe0XS2xsbFlllm1ahVyc3PxzTffGPyr1RRdLO7u7lAoFMjPzy9zIPHSpUuxZMkSLFmyBB9//LFR1ytLq1atsHPnTr2/tLWDs0NDQ3XKZ2VlQSKRVPghs337drz11ltYsWKFzvaMjAw4OztXup4uLi7gOA4pKSl6+wxtM+Tq1ato06aNXvBx9epVuLu78x/uV69eRbt27bB48WIMGTIECxcuxMqVKw2er3Xr1jqtVSXdv38fhYWFaNy4scH9NfW8mJqPjw/efvttk5zLFM9yZZ9hwPjnmBAtCpgIeaJVq1Zo3Lgxdu7cic8//xwuLi46+7dv344VK1Zg9OjRGD9+vMFzmKKLJSQkBAAQFRVlsNvv888/x5IlS/C///0PixcvNupa5Rk5ciR+/vln7Nu3D6+99hq/fcuWLfD19UWXLl10ykdHR6NFixYVnpfjOL1A4tChQ3j8+DGaNGlS6Xra2dmhc+fO2L9/P1avXs13y+Xm5uLvv/826hzh4eEYNWqU3vaIiAidbqDw8HC8/PLLGDhwIH7++WdMnDgRfn5+mDZtmt75hg8fbvBaBQUFGDduHP73v/+V+aFcE8+LJTPVs1zZZxgw/jkmRIsCJkKe4DgOP//8M1566SV06tQJ8+fPR5MmTZCSkoJdu3bhwIEDmDBhAjZs2FDmORwcHAx21VVGr169ABSnOCj9AbhmzRp8+umnGDRoEAYPHoxLly7p7O/atSv/9ZEjR5Cfn4/c3FwAwN27d7F3714AwEsvvcSPqXnxxRfRv39/vPfee5DJZGjSpAl27tyJf/75B9u3b9fp6tFoNLhy5QomT55c4X0MGTIEmzdvRkhICFq3bo2IiAisXr1aZ9B0ZX3++ecYNGgQ+vfvjzlz5kCtVuPLL7+EnZ0d3/1SluTkZCQnJ+v9fFQqFW7evInZs2frlNMGUBMmTEBiYiJmzJgBb29vvPzyyzrlDM2QUyqVGD16NFq0aFFuq0l1Py+A8c8Bx3Ho2bMnTp8+/Uz1MVZlnuWK6leZZxio3HNMCM+sWaAIsRA3btxgANj9+/fZzZs3Wdu2bZlAIGACgYABYIGBgez48eNs3759bMyYMaxx48bM2tqaBQYGsjfeeIM9ePCgyteWSqVs2bJlrGfPnszLy4vZ2dkxW1tbFhwcrJdcsWfPngxAma+S3NzcyiwXExOjUzY3N5fNmDGDeXt7M7FYzIRCIQPA9uzZo1Pu5MmTDACLiIjQuw+FQsGWLFnCAgMDmVgsZk2aNGFdu3Zlnp6ezNbWlj333HPs7NmzrGfPniwkJIS1bduWSSQSZmNjwwCwGzdu6Jzv119/NVjXAwcOsNatWzMrKysmFouZSCTiz1E6GWJMTEyZ78HOnTsZY4zdvHmTAWD79+9njDH2119/MQDsv//+YzKZjH300Uesf//+zNramgFgEyZM0Cl38+ZNxhhj48ePN3id4ODgsn70OsLCwsqs68WLF3XKlvcMlL5eYGBgmWUnTpzIfHx8mFgsZgBYt27ddI5VqVRszZo1bODAgaxBgwbMxsaGhYSEsPnz57Ps7Gyj7ksul7NFixaxoKAgZmVlxQICAtiCBQvY888/X+59GHqNGTPG4DXGjh3LALCgoCD+GW7dujX/M965cydr06YNk0gkzMfHh40aNcrgc5ybm8s+/PBD5uPjwyQSCWvTpg1/jrJoNBr+XqZNm2bUe0JqJwqYCGGM/fzzz8zZ2ZnPijx69Gj26quvMsYYe/PNN5mVlRULDw9nnTt3ZsOGDWObNm1ip0+fZtu2bWPNmzdn9vb27Pbt21W69q1bt5i7uzubNWsW++uvv9jJkyfZ6NGjGQDWo0cPvk5ab7/9NpNIJGzVqlUsLCyMLViwgHEcx5YvX65TztfXl40dO5bt2LGDnT59mv3000/Mz8+P+fj4sJSUlDLr8/LLLzNfX1+DAdObb77JunfvbvA4Y+u1fv16BoC9/fbb7J9//mG//PIL8/HxYYGBgSwrK8uo9+z06dNMJBKx4cOHs2PHjrHt27ezBg0asNDQUFZUVMSX0wZMH3zwAbt48aLOKyMjo8LrxMTEMCcnJ/bCCy+wt99+u9xM2ePHj2c2NjZs2LBhrF27duz06dPs4sWLeoFgWbQB04oVK/Tqmpubq1O29P4VK1bwwf2CBQuMul7//v2Zs7Mz+/HHH9mKFSv4oGTHjh18mdzcXObg4MCmTp3K9uzZw8LCwtiaNWuYi4sLa9GiRYVZ0BljbNSoUcza2pqtWLGCHT9+nH322WdMLBazoUOH6pRLSEjQu6+LFy+y0NBQJhaLGcdx7L///tM7/8GDB5mdnR1zdHRkgwcP1tu/fft2/nk7deoU+/HHH5mVlRVzcnIq9z05deoU/zMv+Z6U9s033zAfHx8KmOoBCpgIYYxNnTqVDRgwgP8+ICCAXxpFKpWyoKAg1qxZMxYdHa137OPHj5mVlRWbPHlyla6dl5ent6yGRqNhAQEBDAA7e/Ysv/327duM4zi2YsUKnfJTpkxhNjY2LDMzk99maOmJ8PBwBoB9/vnnBuuyd+9eZm9vz7Zs2aIXMD169IhZWVnp1Key9SoqKmJOTk56H5YXLlxgANjHH39ssF6lderUibVo0YIplUp+2/nz5xkA9v333/PbtAGToWVujFGZpUW0ARMAZm1tzezs7PjXv//+W+G1tAFT6SDV2Hp6eHgwAOzhw4cVli+9lMjcuXPZ66+/rreUiEqlMhhY7tmzhwFg27ZtK/c6Fy9eZADYmjVrdLZrA7Rjx46Ve3xMTAzjOI41b96cvf7663r7c3JyWIMGDdhXX33FAgMD9QImlUrFfHx8dH63Hz16xLegHj58uMz3RKus5VW09bO3t2f79++ngKkeoEzfhKB48K52MdaUlBTEx8fz3zs6OiImJgaRkZFo2LCh3rG+vr7w8/Or9HIOWnZ2dnqzmziOw9KlSwEAcXFx/PY///wTjDFMnDhRp/zEiRNRWFiIf/75h99maOmJDh06QCgUGqxrVlYWpk2bhuXLlxucCh4fH49vv/0Wzz33nN4+Y+t1+/ZtSKVSvPTSSzrlunXrBldXV+zbt0/v3KU9fvwY4eHhGDdunM6MqO7du6NZs2b4448/KjyHsSq7tIhAIABjDIWFhcjLy+Nfzz//vMnqZIj2Og0bNjSYwLG00kuJrF69Gr/99pveUiJCoVAv3QMA/nejomf+/PnzAKD38x4yZAgAVPjz3rRpExhj+OGHH/QW0QWAOXPmwMfHBzNmzDB4/KVLl5CcnKzzXMbHx+Obb76Bvb29zrNS2eVVAGDq1Kno378/Ro4cWe59kLqBAiZSbwUFBfEfiNevX8eyZcvAcRx8fHwAAD179gTHcZgwYUK554mOjkZcXJzecg7aNdKqOohWm96gZCLN27dvw8PDQy/vUFlLQJR25swZqNVqg0tPzJgxAw0bNiwzD07v3r0xdepUg/uMrZdCoQAAg9PwJRIJHj58iKKionLvQXsuQwOcW7dubfA9+OKLLyAWi2Fra4vnnnsOBw4cKPcaVVVYWAhvb28IhUL4+flh+vTpBgej9+rVq8xAbNq0aRCJRHB0dMTAgQNx7ty5Cq+7a9cuFBYW4vPPP9dbT87QtSq7lEhpp06dAoAKlzAp6+et/f6///4r81iNRoPNmzejSZMm6Nmzp97+EydOYOvWrfjll1/KzEFl6Fnp3bs33nvvPYSEhOjcZ2Xfk19++QVXrlzBt99+W+Y9kLqFZsmReuvw4cNQKBQ4fvw4/ve//+H8+fMQiURYunQp0tPT+f8IDSW901KpVJg8eTLs7e311j0TCAQQCoVVWvz0v//+w6pVqzBy5Eid/+wzMzMN1sfOzg5isdhg8j6t3NxcvP/++/D398ekSZN09h06dAi///47rl27pveBawxj6xUcHAyBQIDz58/r/NUfFRWF5ORkAMUJKrVBa1nXAgz/XFxdXXXeA4lEgilTpqB///7w8fHhWxeGDx+On3/+2WS5hACgTZs2aNOmDZ/z58yZM1i7di1OnjyJ8PBwndQCQqFQ70PeyckJH374IXr16gU3Nzc8evQIq1evRq9evXDo0CEMHDiwzGtv3LgRzs7O/Ay+kgxdqypLiWg9fvwYCxYsQMeOHfmWorJop+2fP39ep3VWGwSWd51jx44hISHBYP6rvLw8TJkyBXPnzjWYEFSromelZM61yrwnjx8/xty5c7Fq1aoy0z2QOsi8PYKEmN/MmTNZjx49+O9btGjBlixZUuFxGo2GvfXWW0woFLI///zTZPWJiYlh/v7+rFmzZjpjkhgrHk8REhJi8DixWMzeeecdg/sKCwtZv379mK2tLbt06ZLOPu04kP/973/8trLG0yiVSp2XdnxPZeo1btw4ZmVlxX788UeWmZnJbt68ybp06cKPK9EOSFepVDrXUqvVjDHGduzYwQDo3QdjxWPRJBKJwXpoKRQK1q5dO+bm5qYzBqoiFY1hMmTv3r0MAPvqq6+MPqak7Oxs5ufnx1q3bl1mmdu3b1d6/EzTpk3ZoEGD9LYnJSUxAGzlypUGj8vMzGStW7dmnp6eLCoqqsLryOVy1qRJE+br68uOHTvGsrOz2ZEjR5iXlxcTCoVlPjOMMfbKK68wkUjEkpOT9fZNmzaNNW3aVGcWqaExTMuXL9d5pkoaMGCAzozCyrwnQ4YMYS+88ILOhIzK/gxI7UNdcqReUqvV/CrwZ86cwXPPPQeVSoW0tDTcu3cPPXr0gEqlglqtNng8Ywxvv/02tm/fjs2bN5eZvLCy4uLi0Lt3b4hEIpw8eVLvL+OyloDIz8+HQqEw+Je0XC7HyJEjce7cORw4cEAvid8nn3wCKysrTJ8+HTk5OcjJyeEXGC4oKEBOTg4YY4iNjYWVlZXO68yZM5Wu1w8//IDXXnsN77//Ptzc3NCuXTuEhIRg8ODBkEgk/JiZvn376lxL2yqm3V/WUhjltQgCgJWVFV577TVkZmbi4cOH5ZZ9ViNHjoSdnZ1ejiFjOTs7Y8iQIfjvv/8MLicDFLcuAahUa1lVlhLJzs5G//798fjxYxw/ftyosVJisRhHjhxBQEAABgwYABcXF7zyyiv4+OOP4eLiggYNGhg8LiMjAwcOHMDgwYP1unmvXLmC77//HqtWrUJRURH/zGo0GqhUKuTk5EAul/P3CRj3rBj7nuzduxf//PMPVq1aBalUyl8fKO6CzMnJ0Vk3kdQh5o7YCDGHivIZaV89e/bUO1aj0bBJkyYxjuPYpk2bTFan2NhYFhQUxAIDA1lsbKzBMtq/mEv/1a2djVR6+nNRUREbNGgQk0gk7J9//jF4TmPei+zsbCaXy1l4eLjOSyaTValejDGWlZXFbt68ydLT0xljjAUHB7PevXvz++/fv69zLW0+psTERAaAffHFF3rnDA4OZv379zd4nyWtXLmSAcV5t4xVlRYmtVrNbG1ty8wfZIx33nmHAdDLycVYcQuOu7s769ChQ6XOOWXKFGZvb6/XwrZz504GgJ0/f15ne1ZWFmvfvj1zcXFh165dq/xNsOKf23///cfy8/P5VpulS5caLPvVV18xAOzvv//W26fNz1Xea+3atYyxpzMnd+3apXMOpVLJ7O3t2ZQpU/htxr4nixcvrvD6f/zxR5XeI2LZKGAi9ZL2w3jFihXMxsaGXbp0iYWHh7OhQ4eyF154gf+QLv2BqtFo2OTJkxnHcWzDhg0mq09cXBwLCgpi/v7+5XZ1aKfvlw4W3nnnHb20AkVFRezFF19kYrGYHTx4sMxzXr9+nYWFhem81q5dywCwJUuWsLCwsAq7ripTL0O0SSCN7drs3LkzCw0N1ZnqrQ3Ofvjhh3KPVSgUrG3btszd3d3gVPGyVCVg2r17NwPAvv76a6OPKSkrK4s1aNCAtW3b1uB+7fT+kqkUjHH48GGDgcSgQYP0ptBrgyVnZ2cWHh5e+ZswYNasWczOzo4lJiYa3N+yZcsyp/InJyfrPa9hYWHMy8uLde3alYWFhbGEhATG2NO0AqW72rRB0JEjR/htxr4nMTExBq8PgI0YMYKFhYXxfwSQuoUCJlKvTZw4kQ0ZMoT/3s/Pj3377bdllp8+fToDwCZNmqSXYK/0X95Lly5lQqGQnT59utw6pKamskaNGjGJRMK2b9+ud17tf/5a2gSRq1evZqdPn2Yff/yxwQSRQ4YMYQDYJ598onfOO3fulFunquQEMrZee/fuZevXr2fHjx9nf//9N5szZw4TiUTs3XffNfpaYWFhTCQSsZEjR7Ljx4+zHTt2MH9/f73ElbNmzWLTp09nO3fuZGFhYWzr1q2sU6dODAD79ddfjbrW4cOH2Z49e9imTZsYAPbqq6+yPXv2sD179rD8/HzGWHHrYPfu3dn69evZ4cOH2ZEjR9iCBQuYtbU1a9mypV6erT59+jChUKiz7fXXX2fz58/nE0Ru2LCBBQcHM5FIxI4fP26wboMGDWI2NjYsJyenzPobuhZjxePOXFxc2IYNG9ipU6fYlClTGAC2fft2vkxBQQHr1KkT4ziOrVu3Tu85evTokc45hUIh69Onj862L7/8km3ZsoWFhYWxXbt2sVGjRjGBQFBmMshLly5VKieXlqExTIwxtm3bNgaATZ06lX9fnZ2dDbZEGvOelAU0hqnOo4CJ1FtqtZp5eHiwn376iTHG2LVr1xgAFhcXV+Yx5S0zERgYqFNW23QfFhZWbj3KWxLDUIuGQqFgixcvZgEBAUwsFrNmzZqx9evX6523sl2NhupUmYDJ2Hr98ccfrG3btszOzo7Z2Niwjh07so0bN+plNK/IsWPHWNeuXZm1tTVzdXVlb731ll6yzo0bN7LOnTszV1dXJhKJmIuLCxs4cCA7evSo0dcp72eu7SbMyspiI0eOZEFBQczGxoaJxWLWtGlTNm/ePIPBjLYbtKSVK1eytm3bMicnJyYUCpmHhwcbOXIku3LlisF6xcfHM4FAwN56661y62/oWozpL4dTcikRrfKWlgHAxo8fr1Pe0LO1dOlS1rhxYyaRSJizszMbNGhQuYk8p0yZwjiOM2pQeUllBUyMMfbbb7+x1q1bM7FYzLy9vdmMGTP0sqczZtx7UhYKmOo+jjHGyhrfRAghhBBCKHElIYQQQkiFKGAihBBCCKkABUyEEEIIIRWggIkQQgghpAIUMBFCCCGEVIACJkIIIYSQClDARAghhBBSAQqYCCGEEEIqQAETIYQQQkgFKGAysX///RdDhw6Fr68vOI7Dn3/+Wa3XCwoKAsdxeq9p06ZV6XyZmZkYNGgQfH19IZFI4O/vj+nTp0Mmk5V73IYNG9CrVy84OjqC4zjk5OTolXnw4AGGDx8Od3d3ODo6okePHggLC9MpEx8fj6FDh8LOzg7u7u6YMWMGFAqFTpmjR4+ia9eucHBwgIeHB15++WXExMTw+/fv34/+/fvDw8MDjo6O6NatG44ePapXn5ycHEybNg0+Pj6wtrZG8+bNcfjwYYP3t3LlSnAch5kzZ5b7PpRWVFSECRMmoFWrVhCJRBgxYkSljieEEGIZKGAysfz8fLRp0wbffvttjVwvPDwcycnJ/Ov48eMAgFdffbVK5xMIBBg+fDgOHDiABw8eYPPmzThx4gTefffdco8rKCjAoEGD8PHHH5dZZvDgwVCpVDh16hQiIiLQtm1bDBkyBCkpKQAAtVqNwYMHIz8/H+fOncOuXbuwb98+zJkzhz9HdHQ0hg8fjj59+uDGjRs4evQoMjIyMGrUKL7Mv//+i/79++Pw4cOIiIhA7969MXToUFy/fp0vo1Ao0L9/f8TGxmLv3r2IjIzEzz//jAYNGujVOzw8HBs2bEDr1q2Nfh+11Go1bGxsMGPGDPTr16/SxxNCCLEQ5l7Mri4DwP744w+dbXK5nH300UfM19eX2drass6dO1e4OGtlfPjhh6xx48aVXsi0POvWrWN+fn5GldUu2pqdna2zPT09nQHQWXRTJpMxAOzEiROMseJV4QUCAXv8+DFfZufOnUwikTCpVMoYY2zPnj1MJBIxtVrNlzlw4ADjOI4pFIoy69WiRQu2dOlS/vsffviBNWrUqNxjGCtejLNp06bs+PHjrGfPnuzDDz/U2V+Zn+f48ePZ8OHDy70eIYQQy0QtTDVs4sSJOH/+PHbt2oX//vsPr776KgYNGoSHDx8+87kVCgW2b9+OSZMmgeM4E9QWSEpKwv79+9GzZ89nOo+bmxuaN2+OrVu3Ij8/HyqVCj/99BO8vLzQoUMHAMDFixcRGhoKX19f/riBAwdCLpcjIiICANCxY0cIhUL8+uuvUKvVkEql2LZtGwYMGAArKyuD19ZoNMjNzYWrqyu/7cCBA+jWrRumTZsGLy8vhIaGYsWKFVCr1TrHTps2DYMHDy6zdag6f56EEEIsiLkjtroMpVqYHj16xDiO02lBYYyxvn37soULFz7z9Xbv3s2EQqHe+atizJgxzMbGhgFgQ4cOZYWFhUYdV1YLE2OMJSYmsg4dOjCO45hQKGS+vr7s+vXr/P4pU6aw/v376x0nFovZb7/9xn9/5swZ5unpyYRCIQPAunXrZvB6WqtWrWKurq4sNTWV3xYcHMwkEgmbNGkSu3r1Ktu5cydzdXXVaYXauXMnCw0N5e+9dAtTZX+e1MJECCG1F7Uw1aBr166BMYZmzZrB3t6ef505cwZRUVEAgNjYWIODuEu+pk+fbvD8GzduxIsvvqjTQgMAEyZMqPCcGRkZOsesXbsW165dw59//omoqCjMnj37me6dMYb3338fnp6eOHv2LK5cuYLhw4djyJAhSE5O5ssZahljjPHbU1JS8Pbbb2P8+PEIDw/HmTNnIBaL8corr4Axpnfszp07sWTJEuzevRuenp78do1GA09PT2zYsAEdOnTAmDFj8Mknn+CHH34AACQkJODDDz/E9u3bYW1tbfCejPl5EkIIqRtE5q5AfaLRaCAUChEREQGhUKizz97eHgDQoEED3Lt3r9zzuLi46G2Li4vDiRMnsH//fr19K1euxIIFCyp1Tm9vb3h7eyMkJARubm54/vnnsWjRIvj4+JR7nrKcOnUKBw8eRHZ2NhwdHQEA33//PY4fP44tW7ZgwYIF8Pb2xuXLl3WOy87OhlKphJeXFwDgu+++g6OjI1atWsWX2b59O/z9/XH58mV07dqV3757925MnjwZe/bs0etS8/HxgZWVlc7PoXnz5khJSYFCoUBERATS0tL47kKgeAD3v//+i2+//RZyudyonychhJC6gQKmGtSuXTuo1WqkpaXh+eefN1jGysoKISEhlT73r7/+Ck9PTwwePFhvn4+PT5UDHQB8y41cLq/yOQoKCgAUz8IrSSAQQKPRAAC6deuG5cuXIzk5ma/vsWPHIJFI+MCloKBALzjRfq89D1DcsjRp0iTs3LnT4HvSo0cP/Pbbb9BoNHydHjx4AB8fH4jFYvTt2xe3bt3SOWbixIkICQnB/PnzIRQKjfp5EkIIqSPM2R9YF+Xm5rLr16+z69evMwDsq6++YtevX2dxcXGMMcbGjh3LgoKC2L59+1h0dDS7cuUK++KLL9ihQ4eqfE21Ws0CAgLY/Pnzn7n+hw4dYps2bWK3bt1iMTEx7NChQ6xly5asR48efJnExEQWHBzMLl++zG9LTk5m169fZz///DM/G+769essMzOTMVY8S87NzY2NGjWK3bhxg0VGRrK5c+cyKysrduPGDcYYYyqVioWGhrK+ffuya9eusRMnTjA/Pz82ffp0/jonT55kHMexpUuXsgcPHrCIiAg2cOBAFhgYyAoKChhjjP32229MJBKx7777jiUnJ/OvnJwc/jzx8fHM3t6eTZ8+nUVGRrKDBw8yT09PtmzZsjLfG0Oz5Iz5ed65c4ddv36dDR06lPXq1Yt/PgghhNQeFDCZmHbQc+nX+PHjGWOMKRQK9umnn7KgoCBmZWXFvL292ciRI9l///1X5WsePXqUAWCRkZHPXP9Tp06xbt26MScnJ2Ztbc2aNm3K5s+frzOoOiYmhgHQmT6/ePFig/f966+/8mXCw8PZgAEDmKurK3NwcGBdu3Zlhw8f1rl+XFwcGzx4MLOxsWGurq5s+vTprKioSKfMzp07Wbt27ZidnR3z8PBgw4YNY/fu3eP39+zZs9yfgdaFCxdYly5dmEQiYY0aNWLLly9nKpWqzPfGUMBkzM8zMDDQYH0IIYTUHhxjBkbKEkIIIYQQHs2SI4QQQgipAA36NgGNRoOkpCQ4ODiYLGEkIYQQQqoXYwy5ubnw9fXVm5RUGgVMJpCUlAR/f39zV4MQQgghVZCQkAA/P79yy1DAZAIODg4Ait9wbY4hQgghhFg2mUwGf39//nO8PBQwmYC2G87R0ZECJkIIIaSWMWY4DQ36JoQQQgipAAVMhBBCCCEVoICJEEIIIaQCNIaJEEKegVqthlKpNHc1CCEGlF5k/VlQwEQIIVXAGENKSgpycnLMXRVCSDmcnZ3h7e39zHkSKWAihJAq0AZLnp6esLW1paS1hFgYxhgKCgqQlpYGAPDx8Xmm81HARAghlaRWq/lgyc3NzdzVIYSUwcbGBgCQlpYGT0/PZ+qeo0HfhBBSSdoxS7a2tmauCSGkItrf02cda0gBEyGEVBF1wxFi+Uz1e0oBEyGEEEJIBShgIoQQQgipAAVMhBBCCCEVoICJQK1hYIyZuxqEkBqWnp4OKysrFBQUQKVSwc7ODvHx8fz+rKwsfPDBBwgODoatrS0CAgIwY8YMSKVSM9ba8ixZsgRt27Y1dzVqtV69emHmzJnmrka5KGCq524k5KDZ/47g+9NR5q4KIaSGXbx4EW3btoWtrS0iIiLg6uqKgIAAfn9SUhKSkpLwf//3f7h16xY2b96Mf/75B5MnTzZjrWsvS84Ib8l1qwyFQlFt56aAqZ7753YK1BqGw7eSzV0VQmo1xhgKFCqzvKraQnzhwgX06NEDAHDu3Dn+a63Q0FDs27cPQ4cORePGjdGnTx8sX74cf//9N1QqldHXUSgUmD59Onx8fGBtbY2goCCsXLmS35+Tk4OpU6fCy8sL1tbWCA0NxcGDBwEAmZmZeP311+Hn5wdbW1u0atUKO3fu1Dl/r169MGPGDMybNw+urq7w9vbGkiVLjK6fVCrF1KlT4enpCUdHR/Tp0wc3b94EUNwK5+3tjRUrVvDlL1++DLFYjGPHjmHz5s1YunQpbt68CY7jwHEcNm/eDKB4dtaPP/6I4cOHw87ODsuWLYNarcbkyZPRsGFD2NjYIDg4GOvWrTO6rhMmTMCIESOwdOlSvr7vvPOOTqDwzz//4LnnnoOzszPc3NwwZMgQREU9/aM4NjYWHMfh999/R69evWBtbY3t27cb/V5/8MEHmDlzJlxcXODl5YUNGzYgPz8fEydOhIODAxo3bowjR47oHHf37l289NJLsLe3h5eXF8aNG4eMjAz+ns6cOYN169bx72FsbGyFx2nrM336dMyePRvu7u7o37+/0e9lZVHiynrubrIMAPAwNQ9KtQZWQoqhCamKQqUaLT49apZr3/1sIGzFxv13Hh8fj9atWwMACgoKIBQKsXnzZhQWFoLjODg7O+ONN97A999/b/B4qVQKR0dHiERPr9erVy8EBQXxgUJp69evx4EDB/D7778jICAACQkJSEhIAABoNBq8+OKLyM3Nxfbt29G4cWPcvXuXTzBYVFSEDh06YP78+XB0dMShQ4cwbtw4NGrUCF26dOGvsWXLFsyePRuXL1/GxYsXMWHCBPTo0aPCD1DGGAYPHgxXV1ccPnwYTk5O+Omnn9C3b188ePAAHh4e2LRpE0aMGIEBAwYgJCQEb775Jt5//30MGDAAhYWFuH37Nv755x+cOHECAODk5MSff/HixVi5ciXWrl0LoVAIjUYDPz8//P7773B3d8eFCxcwdepU+Pj4YPTo0RX89IqdPHkS1tbWCAsLQ2xsLCZOnAh3d3csX74cAJCfn4/Zs2ejVatWyM/Px6effoqRI0fixo0bEAie/h8/f/58rFmzBr/++iskEkml3ut58+bhypUr2L17N9577z38+eefGDlyJD7++GOsXbsW48aNQ3x8PGxtbZGcnIyePXtiypQp+Oqrr1BYWIj58+dj9OjROHXqFNatW4cHDx4gNDQUn332GQDAw8OjwuNK1ue9997D+fPnq3V4Ccdo8Mozk8lkcHJy4v8jqU06LT+B9Fw5AOCfmc8jxLt21Z8QcygqKkJMTAwaNmwIa2trAECBQlUrAiaVSoXExETIZDJ07NgR4eHhsLe3R9u2bXHo0CEEBATA3t4e7u7uesdmZmaiffv2GDduHJYtW8Zvf+utt9CgQQOdVqOSZsyYgTt37uDEiRN6OXGOHTuGF198Effu3UOzZs2MuofBgwejefPm+L//+z8AxQGbWq3G2bNn+TKdO3dGnz598MUXX5R7rlOnTmHkyJFIS0uDRCLhtzdp0gTz5s3D1KlTAQDTpk3DiRMn0KlTJ9y8eRPh4eH8z37JkiX4888/cePGDZ1zcxyHmTNnYu3ateXWYdq0aUhNTcXevXsrvPcJEybg77//RkJCAp+Q8ccff8RHH30EqVSqExBppaenw9PTE7du3UJoaChiY2PRsGFDfP311/jwww/LvV5F77VarYaTkxNGjRqFrVu3AiheNsjHxwcXL15E165d8emnn+Ly5cs4evTp70diYiL8/f0RGRmJZs2aoVevXmjbti2+/vprvoyxx0mlUly/fr3MezD0+6pVmc9vamGqx9Jz5XywBAB3k2QUMBFSRTZWQtz9bKDZrm0skUiEoKAg/P777+jUqRPatGmD8+fPw8vLCy+88EKZx8lkMgwePBgtWrTA4sWLdfZpPyjLMmHCBPTv3x/BwcEYNGgQhgwZggEDBgAAbty4AT8/vzKDJbVajS+++AK7d+/G48ePIZfLIZfLYWdnp1NO22qm5ePjw68hVp6IiAjk5eXpLXFTWFio0431f//3fwgNDcXvv/+Oq1ev6n3wlqVjx45623788Uf88ssviIuLQ2FhIRQKRaUGjbdp00Yny3y3bt2Ql5eHhIQEBAYGIioqCosWLcKlS5eQkZEBjUYDoLh1MTQ0tMy6VeW9FgqFcHNzQ6tWrfhtXl5eAMC//xEREQgLC4O9vb3evURFRZX5szf2OEPvcXWggKkeu/ekO66s7wkhxuM4zuhWHnNq2bIl4uLioFQqodFoYG9vD5VKBZVKBXt7ewQGBuLOnTs6x+Tm5mLQoEGwt7fHH3/8ASsrq0pds3379oiJicGRI0dw4sQJjB49Gv369cPevXv5tb7KsmbNGqxduxZff/01WrVqBTs7O8ycOVNvcG/pOnEcxwcK5dFoNPDx8cHp06f19jk7O/NfR0dHIykpCRqNBnFxcXoBWllKBxu///47Zs2ahTVr1qBbt25wcHDA6tWrcfnyZaPOVx5t693QoUPh7++Pn3/+Gb6+vtBoNAgNDdV7z0rX7Vne65LbtPXQvv8ajQZDhw7Fl19+qVfn8hbENfa40vdRXSz/t5tUG+34JSshB6Wa8d8TQuquw4cPQ6lUom/fvli1ahU6dOiAMWPGYMKECRg0aJDeh6FMJsPAgQMhkUhw4MABo1tWSnN0dMRrr72G1157Da+88goGDRqErKwstG7dGomJiXjw4IHBloazZ89i+PDhePPNNwEUf4g+fPgQzZs3r1I9Smvfvj1SUlL4ljdDFAoFxo4di9deew0hISGYPHkybt26xbekiMViqNVqo6539uxZdO/eHe+//z6/rWRLljFu3ryJwsJCPti8dOkS7O3t4efnh8zMTNy7dw8//fQTnn/+eQDFA/qNrVt1vNft27fHvn37EBQUpDP2rSRD76Exx9WkWjPCd9iwYQgICIC1tTV8fHwwbtw4JCUllVleqVRi/vz5fJTs6+uLt956S++YXr168aPyta8xY8ZU9+1YBG2LUt+Q4l/6u0kyysdESB0XGBgIe3t7pKamYvjw4QgICMDdu3cxatQoNGnSBIGBgXzZ3NxcDBgwAPn5+di4cSNkMhlSUlKQkpKi8+H21ltvYeHChWVec+3atdi1axfu37+PBw8eYM+ePfD29oazszN69uyJF154AS+//DKOHz/Ot0T9888/AIrHEh0/fhwXLlzAvXv38M477yAlJcVk70e/fv3QrVs3jBgxAkePHkVsbCwuXLiA//3vf7h69SoA4JNPPoFUKsX69esxb948NG/eXCe1QlBQEGJiYnDjxg1kZGRALpeXdTk0adIEV69exdGjR/HgwQMsWrQI4eHhlaqzQqHA5MmTcffuXRw5cgSLFy/G9OnTIRAI4OLiAjc3N2zYsAGPHj3CqVOnMHv2bKPOW13v9bRp05CVlYXXX38dV65cQXR0NI4dO4ZJkybxz1FQUBAuX76M2NhYvhvRmONqUq0JmHr37o3ff/8dkZGR2LdvH6KiovDKK6+UWb6goADXrl3DokWLcO3aNezfvx8PHjzAsGHD9MpOmTIFycnJ/Ounn36qzluxGHeTigOm4W19IRRwyC5QIlVW9i86IaRuOH36NDp16gRra2tcvnwZDRo0gK+vr165iIgIXL58Gbdu3UKTJk3g4+PDv7Sz3IDisTHJyWWnJrG3t8eXX36Jjh07olOnToiNjcXhw4f5Acr79u1Dp06d8Prrr6NFixaYN28e/4G4aNEitG/fHgMHDkSvXr3g7e2NESNGmOy94DgOhw8fxgsvvIBJkyahWbNmGDNmDGJjY+Hl5YXTp0/j66+/xrZt2+Do6AiBQIBt27bh3Llz+OGHHwAAL7/8MgYNGoTevXvDw8NDbyp+Se+++y5GjRqF1157DV26dEFmZqZOa5Mx+vbti6ZNm+KFF17A6NGjMXToUD6NgkAgwK5duxAREYHQ0FDMmjULq1evNuq81fVe+/r64vz581Cr1Rg4cCBCQ0Px4YcfwsnJiX8G5s6dC6FQiBYtWsDDwwPx8fFGHVeTau0suQMHDmDEiBGQy+VG96eHh4ejc+fOiIuL45OzGRqZX1m1cZZckVKNlouPQq1huLSwL97adBkPUvOwaUJH9HnS4kQIMay8WTeEVKcJEyYgJycHf/75p7mrUmuYapZcrWlhKikrKws7duxA9+7dKzX4UCqV8nlGStqxYwfc3d3RsmVLzJ07F7m5ueWeRy6XQyaT6bxqmwepuVBrGFxsreDlKEFzn+IH5V5y+fdOCCGE1Ee1KmCaP38+7Ozs4Obmhvj4ePz1119GH1tUVIQFCxbgjTfe0Ikix44di507d+L06dNYtGgR9u3bh1GjRpV7rpUrV8LJyYl/+fv7V/mezEU7fqmFryM4jkOLJwGTtpuOEELqgh07dsDe3t7gq2XLluaunp6y6mpvb6+TZ4rUPLN2yS1ZsgRLly4tt0x4eDifYyEjIwNZWVmIi4vD0qVL4eTkhIMHD+olQitNqVTi1VdfRXx8PE6fPl1us1tERAQ6duyIiIgItG/f3mAZbW4KLZlMBn9//1rVJbf4r9vYcjEObz/XEP8b0gL/PkjHW5uuoJG7HU7N7WXu6hFi0ahLrvbIzc1FamqqwX1WVlY6g9wtwaNHj8rc16BBgwrTMBB9dSJx5fTp0yuckVZymqe7uzvc3d3RrFkzNG/eHP7+/rh06RK6detW5vFKpRKjR49GTEwMTp06VeEb0r59e1hZWeHhw4dlBkwSiUQnI2xtpO16a+Fb/H5ou+RiMvNRoFDVinwyhBBSEQcHBzg4OJi7GkZr0qSJuatAymDWT0VtAFQV2oax8qZvaoOlhw8fIiwsTC+TqyF37tyBUqksN5lWbccY47vktIGSh4MEHg4SpOfKcT8lF+0DXMxZRUJqBWMSIxJCzMtUv6e1ohnhypUruHLlCp577jm4uLggOjoan376KRo3bqzTuhQSEoKVK1di5MiRUKlUeOWVV3Dt2jUcPHgQarWazyfh6uoKsViMqKgo7NixAy+99BLc3d1x9+5dzJkzB+3atdNbtbsuScwuRK5cBbFQgMYeT1POt/BxxJncdNxNklHAREg5xGIxBAIBkpKS4OHhAbFYXOHQAEJIzWKMQaFQID09HQKBAGKx+JnOVysCJhsbG+zfvx+LFy9Gfn4+fHx8MGjQIOzatUunaywyMhJSqRRA8QJ9Bw4cAAC9NXrCwsLQq1cviMVinDx5EuvWrUNeXh78/f0xePBgLF68mF8puy6682RgdxNPe4hFT8f9N/dxxJkH6bRECiEVEAgEaNiwIZKTk8tNoEsIMT9bW1sEBAQ8c+6mWhEwtWrVCqdOnaqwXMnx60FBQRVmrfb398eZM2eeuX61TckZciVpv6clUgipmFgsRkBAAFQqlVmyDhNCKiYUCiESiUzSAlwrAiZiWndLjV/SauFTPDAyMqU4R5NQQF0MhJRHu+hoZRejJYTUPrUqDxMxDb6FqVTA1NDdHtZWAhQo1IjLzDdH1QghhBCLRAFTPSMtVCIxuxCAfsAkFHAI9qaM34QQQkhpFDDVM/eftC41cLaBk61+N4K2W+5usrRG60UIIYRYMgqY6pmn45cMJ3KjJVIIIYQQfRQw1TNljV/SokV4CSGEEH0UMNUzZc2Q0wp5sj1FVoSsfEWN1YsQQgixZBQw1SNKtQYPUvMA6Odg0rKXiBDoZgsAlMCSEEIIeYICpnokOj0fCpUGdmIh/F1syyxH45gIIYQQXRQw1SMlF9wVlJOU8uk4JgqYCCGEEIACpnqlovFLWnwLEwVMhBBCCAAKmOqVstaQK635k/2P0vIgV9EaWYQQQggFTPUEY4wfk1RRC5OvkzWcbKyg0jA8fDJInBBCCKnPKGCqJ9Jz5cjMV0DAAcFehpNWanEcxye2pHFMhBBCCAVM9cadJ4FPQ3c72IiFFZZv4eMEgMYxEUIIIQAFTPXG0/FLTkaVpxYmQggh5CkKmOqJp+OXyu+O09IODL+bJANjrNrqRQghhNQGFDDVExWtIVdaE097iAQcZEUqJEmLqrNqhBBCiMWjgKkeKFSoEZORD8D4gEkiEqKJpz0AyvhNCCGEUMBUD0Sm5kLDAHd7MTwcJEYfR0ukEEIIIcUoYKoHSuZf4riyl0QpTTuOiQZ+E0IIqe8oYKoHKjt+SYuWSCGEEEKKUcBUDxi7hlxp2vLxWQXILVKavF6EEEJIbUEBUx2n0TDcN3INudJc7MTwcbIGANxPyTV53QghhJDaggKmOi4+qwD5CjXEIgEaudtV+nhtKxONYyKEEFKfUcBUx2kDnWAvB4iElf9x00w5QgghhAKmOu/p+CXjMnyXRi1MhBBCCAVMdV5VZ8hpacc93U/JhUqtMVm9CCGEkNqEAqY6rmQOpqoIdLWFrVgIuUqD2Mx8U1aNEEIIqTUoYKrDcgoU/DpwzSs5Q05LIOAQ4l3cnXeHxjERQgippyhgqsO045f8XGzgaG1V5fM8HcdEqQUIIYTUTxQw1WHaAKeq45e0tOOYKOM3IYSQ+ooCpjrsWccvadFMOUIIIfVdrQmYhg0bhoCAAFhbW8PHxwfjxo1DUlJSucdMmDABHMfpvLp27apTRi6X44MPPoC7uzvs7OwwbNgwJCYmVuet1Jh7VczwXVqItwM4DkjPlSMtt8gUVSOEEEJqlVoTMPXu3Ru///47IiMjsW/fPkRFReGVV16p8LhBgwYhOTmZfx0+fFhn/8yZM/HHH39g165dOHfuHPLy8jBkyBCo1erqupUaoVBp8DDNNF1ytmIRGroVZwmncUyEEELqI5G5K2CsWbNm8V8HBgZiwYIFGDFiBJRKJaysyh7QLJFI4O3tbXCfVCrFxo0bsW3bNvTr1w8AsH37dvj7++PEiRMYOHCgwePkcjnkcjn/vUxmeV1VUel5UKoZHCQi+LnYPPP5mvs6IjojH/eSZejZzMMENSSEEEJqj1rTwlRSVlYWduzYge7du5cbLAHA6dOn4enpiWbNmmHKlClIS0vj90VERECpVGLAgAH8Nl9fX4SGhuLChQtlnnPlypVwcnLiX/7+/s9+UyZWcvwSx3HPfD5aIoUQQkh9VqsCpvnz58POzg5ubm6Ij4/HX3/9VW75F198ETt27MCpU6ewZs0ahIeHo0+fPnzrUEpKCsRiMVxcXHSO8/LyQkpKSpnnXbhwIaRSKf9KSEh49pszMVONX9JqQQO/CSGE1GNmDZiWLFmiNyi79Ovq1at8+Y8++gjXr1/HsWPHIBQK8dZbb4ExVub5X3vtNQwePBihoaEYOnQojhw5ggcPHuDQoUPl1osxVm6rjEQigaOjo87L0jzrGnKlaWfKRaXnoUhZu8d3EUIIIZVl1jFM06dPx5gxY8otExQUxH/t7u4Od3d3NGvWDM2bN4e/vz8uXbqEbt26GXU9Hx8fBAYG4uHDhwAAb29vKBQKZGdn67QypaWloXv37pW/IQvBGCuxhpyTSc7p5SiBq50YWfkKPEjNRWs/Z5OclxBCCKkNzBowaQOgqtC2LJUcfF2RzMxMJCQkwMfHBwDQoUMHWFlZ4fjx4xg9ejQAIDk5Gbdv38aqVauqVC9LkCIrQnaBEkIBh6Ze9iY5J8dxaO7jgPOPMnE3SUYBEyGEkHqlVoxhunLlCr799lvcuHEDcXFxCAsLwxtvvIHGjRvrtC6FhITgjz/+AADk5eVh7ty5uHjxImJjY3H69GkMHToU7u7uGDlyJADAyckJkydPxpw5c3Dy5Elcv34db775Jlq1asXPmquNtK1LjT3sYG0lNNl5aRwTIYSQ+qpWpBWwsbHB/v37sXjxYuTn58PHxweDBg3Crl27IJFI+HKRkZGQSqUAAKFQiFu3bmHr1q3IycmBj48Pevfujd27d8PB4em4nrVr10IkEmH06NEoLCxE3759sXnzZgiFpgs0apqpMnyXRkukEEIIqa9qRcDUqlUrnDp1qsJyJQeA29jY4OjRoxUeY21tjW+++QbffPPNM9XRkphqDbnSSi7Cq9EwCATPnq6AEEIIqQ1qRZccqZynM+RMGzA19rCHWChAnlyFxOxCk56bEEIIsWQUMNUx+XIVYjPzAZg+YLISCvhB5NQtRwghpD6hgKmOuZ+SC8YADwcJPBwkFR9QSXzGbwqYCCGE1CMUMNUxT/MvVU8yzeY0U44QQkg9RAFTHVNd45e0+JlytKYcIYSQeoQCpjrG1GvIldbcu/i8j3MKIS1QVss1CCGEEEtDAVMdotYw3OdTCphmDbnSnGyt0MDZBgBwL4VamQghhNQPFDDVIXGZ+ShUqmFtJUBDd9MsiWKItruPuuUIIYTUFxQw1SHa8UvBXg4QVmNSSW13Hw38JoQQUl9QwFSHVPf4JS1tdx+lFiCEEFJfUMBUh1TXGnKltfBxAgA8TM2DUq2p1msRQgghloACpjqkutaQK83PxQb2EhEUag2i0vOq9VqEEEKIJaCAqY7IylcgRVYEAAip5oBJIODQ/Em3HI1jIoQQUh9QwFRHaAOXQDdb2EtE1X49milHCCGkPqGAqY7QBi7V3R2n1YJfIiW3Rq5HCCGEmBMFTHXEvWpeEqW05iUW4WWM1cg1CSGEEHOhgKmOuFvNi+6WFuztAAFXPHYqLVdeI9ckhBBCzIUCpjpArlLjUVrxbLXm1ZyDScvaSojGHsXZxGkcEyGEkLqOAqY64GFqHlQaBicbK/g6WdfYdUt2yxFCCCF1GQVMdcDT8UsO4LjqWxKlNG1GcQqYCCGE1HUUMNUBT8cvOdXodbUtTPeoS44QQkgdRwFTHVCyhakmaQeYx2Tmo0ChqtFrE0IIITWJAqZajjH2NAdTDQ341vJwkMDdXgLGgPsplI+JEEJI3UUBUy2XJC2CrEgFkYBDE0/7Gr++NkijJVIIIYTUZRQw1XLa8UNNPO0hEQlr/PrabkBKLUAIIaQuo4CplqvphJWlPV0ihQImQgghdRcFTLWcNlCp6fFLWtqA6X5KLjQaWiKFEEJI3UQBUy13t4bXkCutobsdJCIBChRqxGUVmKUOhBBCSHWjgKkWy5OrEJdZHKSYK2ASCQUI9qZxTIQQQuo2CphqsftPWpe8Ha3haic2Wz1oHBMhhJC6jgKmWszc45e0aE05QgghdR0FTLXYXTNl+C6NcjERQgip62pNwDRs2DAEBATA2toaPj4+GDduHJKSkso9huM4g6/Vq1fzZXr16qW3f8yYMdV9OyZxN7k4u3ZNryFXWsiTMUzJ0iJk5yvMWhdCCCGkOtSagKl37974/fffERkZiX379iEqKgqvvPJKucckJyfrvDZt2gSO4/Dyyy/rlJsyZYpOuZ9++qk6b8Uk1BqGyBTLaGFysLZCgKstAGplIoQQUjeJzF0BY82aNYv/OjAwEAsWLMCIESOgVCphZWVl8Bhvb2+d7//66y/07t0bjRo10tlua2urV9bSxWTko0ipga1YiEA3O3NXB819HBCfVYC7yTJ0b+Ju7uoQQgghJlVrWphKysrKwo4dO9C9e/cyg6XSUlNTcejQIUyePFlv344dO+Du7o6WLVti7ty5yM0tfyFZuVwOmUym86pp2vFLwd4OEAq4Gr9+adpuQUotQAghpC6qVQHT/PnzYWdnBzc3N8THx+Ovv/4y+tgtW7bAwcEBo0aN0tk+duxY7Ny5E6dPn8aiRYuwb98+vTKlrVy5Ek5OTvzL39+/SvfzLO6ZeUmU0rQDv2mmHCGEkLrIrAHTkiVLyhyYrX1dvXqVL//RRx/h+vXrOHbsGIRCId566y0wZtxyHJs2bcLYsWNhbW2ts33KlCno168fQkNDMWbMGOzduxcnTpzAtWvXyjzXwoULIZVK+VdCQkLV3oBnoG3JMVfCytK046gepeVBrlKbuTaEEEKIaZl1DNP06dMrnJEWFBTEf+3u7g53d3c0a9YMzZs3h7+/Py5duoRu3bqVe46zZ88iMjISu3fvrrBO7du3h5WVFR4+fIj27dsbLCORSCCRSCo8V3WylBxMWg2cbeBoLYKsSIVHaXlo6WvemXuEEEKIKZk1YNIGQFWhbVmSy+UVlt24cSM6dOiANm3aVFj2zp07UCqV8PHxqVK9akJGnhxpuXJw3NMp/ebGcRya+zjickwW7ibJKGAihBBSp9SKMUxXrlzBt99+ixs3biAuLg5hYWF444030LhxY53WpZCQEPzxxx86x8pkMuzZswdvv/223nmjoqLw2Wef4erVq4iNjcXhw4fx6quvol27dujRo0e131dVaVuXGrrZwVZsORMdnyawLH/QPCGEEFLb1IqAycbGBvv370ffvn0RHByMSZMmITQ0FGfOnNHpGouMjIRUKtU5dteuXWCM4fXXX9c7r1gsxsmTJzFw4EAEBwdjxowZGDBgAE6cOAGhUFjt91VVljZ+SevpEinSCkoSQgghtYvlNE+Uo1WrVjh16lSF5QwNAJ86dSqmTp1qsLy/vz/OnDnzzPWraZY2fknr6SK8uWCMgePMn+6AEEIIMYVa0cJEdFnKGnKlNfWyh0jAQVqoRJK0yNzVIYQQQkyGAqZapkipRlR6PgDzryFXmkQkRBNPewDAPUpgSQghpA6hgKmWeZiaB7WGwcXWCl6O5k1tYMjTcUwUMBFCCKk7nmkMk0KhQFpaGjQajc72gICAZ6oUKVvJ8UuWOEaohY8j/rj+mBbhJYQQUqdUKWB6+PAhJk2ahAsXLuhs1w70Vasp03N14ccveVvWgG8tamEihBBSF1UpYJowYQJEIhEOHjwIHx8fi2zpqKvuWugMOS3tQPS4zALkyVWwl9SKiZiEEEJIuar0aXbjxg1EREQgJCTE1PUh5WCM8V1dlpaDScvNXgIvRwlSZXLcT5ahY5CruatECCGEPLMqDfpu0aIFMjIyTF0XUoHE7ELkFqkgFgrQ2MPe3NUpUwvqliOEEFLHGB0wyWQy/vXll19i3rx5OH36NDIzM3X2yWT0IVldtAFIE097iEWWO8GxOZ/Akp4FQgghdYPRXXLOzs46Y5UYY+jbt69OGRr0Xb0sNcN3adr63aVcTIQQQuoIowOmsLCw6qwHMYKlriFXmrZ+91NyoVJrIBJabmsYIYQQYgyjA6aePXvyX8fHx8Pf319vdhxjDAkJCaarHdFxL+VJC5OFB0xBbnawsRKiUKlGbGY+mnha1hIuhBBCSGVV6U//hg0bIj09XW97VlYWGjZs+MyVIvpkRUokZBUCsPyASSjgEPIkvcDd5Fwz14YQQgh5dlUKmMpaiT4vLw/W1tbPXCmi7/6TwKOBsw2cbK3MXJuK8QksaRwTIYSQOqBSeZhmz54NAOA4DosWLYKtrS2/T61W4/Lly2jbtq1JK0iK3U2SAniaGNLStaCZcoQQQuqQSgVM169fB1DcwnTr1i2IxWJ+n1gsRps2bTB37lzT1pAAAO49aWGy9O44LVoihRBCSF1SqYBJO1Nu4sSJWLduHRwda8eHd11w18IzfJcW4u0AjgPSc+VIz5XDw0Fi7ioRQgghVValMUwcxxkcw5Sfn49JkyY9c6WILpVag8jUJy1MFp6DSctOIkKQmx0A6pYjhBBS+1UpYNqyZQsKCwv1thcWFmLr1q3PXCmiKzojHwqVBnZiIfxdbCs+wELQOCZCCCF1RaW65GQyGRhjYIwhNzdXZ0acWq3G4cOH4enpafJK1nclF9wVCPRb9ixVcx8HHLqVTOOYCCGE1HqVCpi0y6NwHIdmzZrp7ec4DkuXLjVZ5Uix2pLhuzRt9yG1MBFCCKntKj3omzGGPn36YN++fXB1deX3icViBAYGwtfX1+SVrO/u1pI15ErTBnhR6fkoUqphbSU0c40IIYSQqqlUwKRdHiUmJgYBAQEGB36X9P777+Ozzz6Du7t71WtIdLrkahNvR2u42Fohu0CJB6m5aO3nbO4qEUIIIVVSpUHfgYGBFQZLALB9+3bIZNQd8yzScouQkaeAgAOCvWpH0kotjuP4II+65QghhNRm1bqMPGOsOk9fL2jHLzV0t4ONuPZ1abWgJVIIIYTUAZXqkiM1j8/w7etk5ppUzdMWJlqElxBSO/xxPRF/3UhCpyBX9Ar2QAsfR6N6VUjdRgGThXua4bt2dcdplZwpV9aizYQQYimO303FnN9vQsOA05HpWH00El6OEvRq5oneIR7o0cQdDtaWvwA6MT0KmCycduxPbVlDrrTGHvawEnLIlauQmF0If9fak3iTVE5OgQJ3kmS4/ViK20ky3EmSQshxCPFxRIi3A5r7OCDE2xE+TtYUOBOLdDMhBx/svAYNA/o19wLAcP5RJlJlcuy+moDdVxMgEnDoGOSC3sGe6BXsiWZe9vQ81xMUMFmwIqUa0el5AGpvwCQWCdDU0wF3k2W4kySjgKmOyMiT4/ZjKR8g3XosRWK2fvZ/AHiYloe/bz793snG6kkAVRxIhfg4opmXPWzF9N8RMZ/4zAJM3hKOIqUGvYI98OOb7SESClCkVCM8Ngth99NxOjIN0Rn5uBSdhUvRWVh55D58nazRK8QTvZoVtz7ZSeg5rqsq/ZNVqVRYvnw5Jk2aBH9//3LLvvnmm7RA7zOITMmFhgHu9uJavXhtcx9H3E2W4dyjdPi52IDjAAHHQcBxT74GAA6CJ9u5Ev9yXPF27sl+ruR+PPlXAP5rayshhLUoG7qlY4whVSZ/0mokLf73sQwpsiKD5QNcbRHawBGhDZzQ0tcJGsZwPzkX91NkuJ+ci6j0PEgLlbgck4XLMVn8cRwHBLnZ8a1Q2oCqgbNNrcpuT2qnnAIFJmy+gow8BVr6OuLbN4qDJQCwthLi+aYeeL6pBz4d2gJxmfk4HZmOsMg0XIzKRJK0CL9djsdvl+MhFgrQuWHxuKdewZ5o7GFXI61P0kIl4jMLEJeVj7jMAsRlFv8bn1WAtFw5hAIOEqEAYpEAVvy/HMQiIcQiAcRC7sm/T/eLtf+KDGwT6h7vaC1C7xBPWAmrdR6Z2XGsClPZ7O3tcfv2bQQFBVVDlWofmUwGJycnSKVSkwaIO6/EY+H+W3i+qTu2Te5isvPWtI3nYvD5wbs1dj1rKwHsJSLYSUSwE4uefC2EnUT0dLtEBPsS22zFxWXs+X3F/9paCevNBzZjDInZhbiTVNxidPtxcbdaRp5CryzHFc/cbNXACaG+TmjZwBEtfZzgZFv+2A65So1HaXlPg6iUXNxLzkVGntxgeXuJCMHeDnwA1dzHAc28HGgMCTGZIqUa4zZeRnhsNnydrPHHtB7wcrSu+MAnx16MzsTp+2kIi0xHfFaBzn5/Vxt+7FO3Ru5Vnums0TCk5cqLA6GsgifBUQHin3yfU6Cs0nlN6cO+TTGrv/4KIJauMp/fVQqYRowYgREjRmDChAlVrWOdUl0B049novD1iQcY3y0IC19qbrLz1rRkaSGmbL2KzDwFNIyBMUDDAIBBw1BiGwOe/KthAHuy/+k2BgagprNV2Il1g63QBo54qZUPujVy4/8KrW00Goa4rIInLUba1iMZpIX6//EKOKCppwNCGzjxrUfNfRxhb8Kuh/RcOSJTcnEvWYZ7T1qjHqXlQaHWGCzv72qDEG9HNPd2QNsAZ3Rv7E6Z5EmlaTQMM3Zdx8H/kuFgLcK+97qjWRXz3THGEJ1R3Pp0OjINl6OzdJ5fsUiAbo3c0CvYA72DPRHkbqdzvEKlQWJ2wdOAKLMA8VlPW4rkKsO/C1ru9mIEuNoiyM0OAW62CHSzRYCrHXycrKFhDEo1g0KlKX6pi/9Vqp9+r1RrIFfpbtf+K1droFQxKNTqJ/8+PU5aqMSVmCw4SEQ4t6APnGxq1x8z1R4w/fTTT1iyZAnGjh2LDh06wM5O9wc/bNiwyp7SaHK5HF26dMHNmzdx/fp1tG3btsyyjDEsXboUGzZsQHZ2Nrp06YLvvvsOLVu21Dnf3LlzsXPnThQWFqJv3774/vvv4efnZ3SdqitgAgC1hqFIqaZ+8VIY0w+2GAMKlWrky1XIk6tK/Ftqm6L4X+32fIUKedqvS5TTVPCb4WonxsCWXrUmeMotUuLswwycuJuKsMg0ZBv4q9RKyKGZlwNaNXBCywZOCPV1RIi3o1lygCnVGsRk5ONesrYlqjiQMtQdaG0lwHNNPNC/hSf6hHjV6i5sUnO+OHIfP56JgpWQw5aJndG9ielWpciXq3AxKhNhkWk4HZmOxzm6Y/yC3GzRLsAFqbIixGUWIFlaWO7/OUIBB19nawS6PgmIXJ8GRQFutib9A6YyNBqGQev+xYPUPMzu3wwz+jY1Sz2qqtoDJoGg7A8GjuOgVqsre0qjffjhh3j48CGOHDlSYcD05ZdfYvny5di8eTOaNWuGZcuW4d9//0VkZCQcHIr/injvvffw999/Y/PmzXBzc8OcOXOQlZWFiIgICIXGfUhUZ8BEzIMxhiKlplTgpUJ2gRJnHqTj6J0UZOU/7aqy1OApMbsAJ++l4cS9VFyKzoRS/fTXXSwSoLmPI1o1cESorxNCGzihqZc9JCLLbqnJzlfgfkpxl97dJBnOP8pAkvRpEMVxQBs/Z/Rv4YV+zb1oFhMxaPulOPzvz9sAgK9Gt8Go9sb/kVxZjDE8TMvD6cg0hN1PR3hsFlQGoiNrK4F+QORmh0BXWzRwsbHYMUJ/3XiMD3fdgLOtFc7N72O24K0qqj1gMpcjR45g9uzZ2LdvH1q2bFluwMQYg6+vL2bOnIn58+cDKG5N8vLywpdffol33nkHUqkUHh4e2LZtG1577TUAQFJSEvz9/XH48GEMHDjQqHpRwFT/qNQaXIrOwqFbyWUGT4Nb+aJrI9caDZ40Gob/Hktx4m4qTtxLxf0U3YShDd3t0K+5J/o290KHQBeL/Q+4MhhjuJss4wPD/xKlOvv9XGzQr3lx8NS5oSvEotp/z5bqv8Qc3Hosxasd/C36fT55LxVTtl6FhsEsrSK5RUqcf5SBB6l58HW2QeCTAMnDQVIrg3u1hqH/V2cQnZGP+YNC8F6vxuauktFqNGAqKiqCtbVxA+SeRWpqKjp06IA///wT7u7uaNiwYbkBU3R0NBo3boxr166hXbt2/Pbhw4fD2dkZW7ZswalTp9C3b19kZWXBxcWFL9OmTRuMGDECS5cuNXhuuVwOufzpIFWZTAZ/f38KmOopcwdPhQo1zj3KwMl7qTh5Pw3puU+fTQEHdAx0Rb8WxUFSYw97k1/f0qTKivjg6fyjDJ2xHw4SEXoGe6Bfcy/0CvaAs63YjDWtW+Iy8/HSurPIV6jR1t8Z349tD19nG3NXS8+tRClG/3QRhUo1Rnf0w5cvt66VQYql2RuRiLl7bsLNToyz83vXmjQhlQmYqnRHarUaK1aswI8//ojU1FQ8ePAAjRo1wqJFixAUFITJkydXqeJlYYxhwoQJePfdd9GxY0fExsZWeExKSgoAwMvLS2e7l5cX4uLi+DJisVgnWNKW0R5vyMqVK8sMpkj9IxIK8FxTdzzX1B2fD2/JB0//3E5GVr4CO68kYOeVhCfBkzcGt/J55uBJGxScvJeKc6WCAnuJCD2beaBvc0/0DvaEi139Cgq8HK3xRpcAvNElAAUKFc49zMCJe6k4dT8NGXkKHPwvGQf/S4ZQwKFjoAv6t/BC3+ZeaFhqEC4xnkqtwczdN5CvKB6OcSMhB0O+OYdvXm+HHiYcF/SsErIKMGlLOAqVajzf1B3LR7aiYMlEhrf1xbqTD5CQVYjfLsfj7ecbmbtKJlelgGn58uXYsmULVq1ahSlTpvDbW7VqhbVr1xodMC1ZsqTCwCM8PBwXLlyATCbDwoULK13X0r8MxizPUVGZhQsXYvbs2fz32hYmQgwHT0n453bKk+ApHjuvxFc6eKqo26mBs82TD35PdGnoZtHdITXJVizCgJbeGNDSGxoNw43EHJy4m4qT99IQmZrL54NadugeGnvYod+TcU/tA1won1clfHPqEa7H58DBWoSf3+qIzw/exZ0kGcZtvIw5A4LxXs/GZk/PIS1QYuLmcKTnyhHi7YDvx7avE13SlsJKKMD7vZpg4f5b2PBvNN7sGljnZq5WqUuuSZMm+Omnn9C3b184ODjg5s2baNSoEe7fv49u3bohOzvbqPNkZGQgIyOj3DJBQUEYM2YM/v77b50gRq1WQygUYuzYsdiyZYvecdXZJVcajWEiFXnabVccPJWcoVZW8CRXqXExKpNvSSo5sBkA2vo7o19zT/Rr4YVgLwf6S7mSErIKcOJe8Vivy9G6g3Bd7cToHeyJfs098Xwzj1o1iLWmRcRl4dUfL0LDgG9eb4ehbXxRpFTj079u4/eriQCKlxlZM7qN2aacy1VqjN90BZeis+DjZI0/3u8Bb6fqH0pS3yhUGvRaHYYkaRE+G94Sb3ULMneVKlTtY5hsbGxw//59BAYG6gRMd+/eRefOnZGXl1flyhsSHx8PmUzGf5+UlISBAwdi79696NKli8EUANpB37NmzcK8efMAAAqFAp6ennqDvrdv347Ro0cDAJKTk+Hn50eDvkm1Uak1uBidicO3kg0GTwNaeCGnQImzD9P5Lg6geAbN80090K+5J3qHeMLTgf7DNxVpoRL/PkjHiXupCLufBlmRit8nFgowrK0vVr9CY11Kyy1S4sV1Z5GYXYhR7Rvgq9FtdfbvuhKPTw/cgUKlQaCbLX4Y24FfkLumMMYwc/cN/HUjCfYSEfa82w3Na+lSU7XB1oux+PSvO/B1ssbpj3pbfGt3tY9hatmyJc6ePYvAwECd7Xv27NFpzTGVgIAAne/t7YsHrjZu3FgnWAoJCcHKlSsxcuRIcByHmTNnYsWKFWjatCmaNm2KFStWwNbWFm+88QYAwMnJCZMnT8acOXPg5uYGV1dXzJ07F61atUK/fv1Mfh+EAMXddtqlFj4fHqoTPGXlK7ArPIEv6+kgQd/mXujfwpOSM1YjJxsrDG3ji6FtfKFUa3A1NptvfYrLLMDeiER82LcprYVYyuK/7jxZVNsGS4e11Ns/pnMAWvo64b0dEYjLLMDI789j+chWeKVD9U3hL+3/jkXirxtJEAk4/PBmewqWqtnojv749tQjJEmLsO9aIl7vHFDxQbVElQKmxYsXY9y4cXj8+DE0Gg3279+PyMhIbN26FQcPHjR1HY0WGRkJqfTp2I558+ahsLAQ77//Pp+48tixY3wOJgBYu3YtRCIRRo8ezSeu3Lx5s9E5mAh5FoaCp1P30+BgbYV+zT0R6utk9rEf9Y2VUIBujd3QrbEb/je4OfquKZ4uHZ9VQAFTCX/deIz91x9DKODw9WvtylyuppWfEw5+8Bw+3HUDZx6kY+6em7gWn43FQ1tUe86vnVfi8V1YFABg5ahWeL6pR7VejxSvvfdOz8b4/OBdfH/6EV7p4FdnxopVOa3A0aNHsWLFCkRERECj0aB9+/b49NNPMWDAAFPX0eJRlxwhddf4TVdw5kE6vhjVCmPq0F/LzyIxuwAvrjuL3CKV0WuIaTQM6089xLqTD8EY0MbPCd+/2QENqin1QFhkGt7echVqDau165zVVoUKNZ5fdQoZeQr836ttarRFsbIq8/ld5bBv4MCBOHPmDPLy8lBQUIBz587Vy2CJEFK3BTxpVUrILqigZP2g1jDM3n0TuUUqtAtwxgd9mhh1nEDAYWa/Zvh1Qic421rhZqIUQ9afxb8P0k1ex9uPpZi+4xrUGoaX2/thZr/atVxHbWcjFvJpBb4PewR1RetM1RJVCpgaNWqEzMxMve05OTlo1Kju5V4ghNRf/q7FLSDxWYUVlKwffjwThSuxWbATC7HutXaVzifWK9gTf09/Dq0aOCG7QInxv17B+pMPoTHRh+rjnEJM2hyOfIUaPZq4YeUoyrVkDm92DYSzrRWiM/Jx8L8kc1fHJKoUMMXGxhpcL04ul+Px48fPXClCCLEU/i5PWpiyqIXpZkIO1h5/AAD4bHgoAtyqNqbL39UWe97thtc7+4Mx4KvjD/D21quQGlgQujKkhUpM/PUK0nLlCPZywA9vdrD4WVp1lb1EhMk9GgIAvgt7ZLKA2JwqNej7wIED/NdHjx6Fk5MT/71arcbJkycRFBRkssoRQoi5aQd61/eAKV+uwszdN6DSMAxp7YNR7Rs80/msrYRYOao12gW4YNGft3HqfhqGfHsWP4ztgNAGThWfoBSFSoP3tkfgQWoevBwl+HViJziWMRCd1IzxPYKw4Ww0HqTm4eidFLzYysfcVXomlQqYRowYAaA4e/b48eN19llZWSEoKAhr1qwxWeUIIcTctAFTZr4C+XIV7OppEsvPD95FTEY+fJ2ssXyE6bq5Rnf0RwsfR7y3IwIJWYUY9cMFLBseitGdjF89gTGGBfv/w4WoTNiJhdg0oZNFrmNX3zhaW2Fi9yCsP/UI35x6hEGh3rW6e7RSbZUajQYajQYBAQFIS0vjv9doNJDL5YiMjMSQIUOqq66EEFLjnGys+AzV9XXg9z+3k7ErPAEcB3z1Wls42Zq25Sa0gRMOTn8efUI8oVBpMG/ff1iw7z8UKfWHfhiy9sRD7L9WnOLgu7Ht0dK38i1UpHpMeq4h7MRCfmmn2qxKnbsxMTFwdy9eULGoqKiC0oQQUrtpB34n1MOB3ynSIizYfwsA8F7PxujayK1aruNka4Vf3uqIOf2bgeOAXeEJeOXHCxV2hf5+NQHrTz4EACwfEYpewZ7VUj9SNc62Yox7skTKN6ceooqZjCxClQImjUaDzz//HA0aNIC9vT2io6MBAIsWLcLGjRtNWkFCCDE3bWqB+Ho2jkmjYZiz5wZyCpRo7eeEmf2qN5eRQMDhg75NsWViZ7jYWuH2YxmGfHMOYZGGWyb+fZCOj58Ec9N7N6E8WRbq7ecbwtpKgJuJUvz7sPz1Yy1ZlQKmZcuWYfPmzVi1ahXEYjG/vVWrVvjll19MVjlCCLEE9XWm3MZzMTj/KBM2VkJ8/VrbGptx9kIzDxyc8Tza+DlBWqjEpM3hWHv8gc5Mq7tJMry/4xpUGoaR7RpgzgBKTGmp3O0lGNuleCm1b07W3lamKj39W7duxYYNGzB27FidJURat26N+/fvm6xyhBBiCerjTLk7SVKsOlr8//nioS3QyMO+Rq/fwNkGv7/bDWO7BIAxYN3Jh5i4ORzZ+QokS4tzLeXJVejayBVfvkwLI1u6d15oBLFIgKtx2bgYrZ/HsTaoUsD0+PFjNGmin91Vo9FAqXy2PBqEEGJp/OtZtu9ChRof7roBpZphQAsvvFaJGWumJBEJsXxkK6x5tQ0kIgHOPEjHkG/OYfymK0iRFaGppz1+erMj5VqqBTwdrTHmyXP0zclHZq5N1VTpKWvZsiXOnj2rt33Pnj1o167dM1eKEEIsCb88SlZhre1OqIwVh+/hUVoePB0k+MICWm9e7uCHP97vgUA3WzzOKcSD1Dx4OBTnWjL1jD1Sfd7t2RhWQg4XozMRHptl7upUWpUSiixevBjjxo3D48ePodFosH//fkRGRmLr1q04ePCgqetICCFm5etsDY4DCpVqZOQp4OEgMXeVqs3Je6nYdikOALBmdBu42okrOKJmtPB1xIHpz+GTP27hv0QpvnujPfxcqpZpnJiHr7MNXungh51Ximc2bpvcxdxVqpQqtTANHToUu3fvxuHDh8FxHD799FPcu3cPf//9N/r372/qOhJCiFlJREL4OFoDqNvdcmm5RZi39z8AwNvPNcTzTT3MXCNdTjZW+PaN9vh3Xm+08qNcS7XRez2bQCjgcPZhBm4k5Ji7OpVS5Y7fgQMH4syZM8jLy0NBQQHOnTuHAQMGmLJuhBBiMfzq+MBvxhg+2vMfMvMVCPF2wEeDgs1dJVIHBbjZYkTb4mV1vnmSP6u2eOaRcnl5eZDJZDovQgipa+p6aoEtF2Jx5kE6JCIB1r/eDhKRsOKDCKmCab0bQ8ABJ++n4fZjqbmrY7QqZ/oePHgw7Ozs4OTkBBcXF7i4uMDZ2RkuLi6mriMhhJhdXU5eGZmSixVHilMIfDK4OZp5OZi5RqQua+RhjyGtfQEA356qPTPmqjToe+zYsQCATZs2wcvLy+wzKAghpLrV1eVRipRqfLjrOhQqDXoHe2Bc10BzV4nUA9P7NMGBm0n4504KIlNyEext+UF6lQKm//77DxEREQgOpj5uQkj9UFdbmFYfjcT9lFy424ux6pU29AcwqRHNvBzwYqg3jtxOwbdhj/DN65afkqhKXXKdOnVCQkKCqetCCCEWS5u8MllaCKVaY+bamMa/D9Kx8VwMAGD1K23qdLoEYnmm9ylOgH3wvyREpeeZuTYVq1IL0y+//IJ3330Xjx8/RmhoKKysdBOHtW7d2iSVI4QQS+FhL4FEJIBcpUFSTiEC3ezMXaVnkpWvwJw9NwEA47sFoneIp5lrROqblr5O6NfcEyfupeG7sEf4anRbc1epXFUKmNLT0xEVFYWJEyfy2ziOA2MMHMdBrVabrIKEEGIJBAIOfi42iErPR0JW7Q6YGGOYv+8/pOfK0dTTHgtfam7uKpF66oM+TXHiXhr+upGEmX2bIcDNcpORVqlLbtKkSWjXrh0uXryI6OhoxMTE6PxLCCF1UUAdWVNu55UEHL+bCrFQgHVj2sHailIIEPNo4++MF5p5QK1h+P60Zc+Yq1ILU1xcHA4cOGBwAV5CCKmr/OvAwO9HaXn47OAdAMC8QcFo4eto5hqR+u7Dvk3w74N07LuWiA/6NkUDZxtzV8mgKrUw9enTBzdv3jR1XQghxKIF1PJs3wqVBjN3X0eRUoPnmrhjUo+G5q4SIegQ6Irujd2gVDP8eDrK3NUpU5VamIYOHYpZs2bh1q1baNWqld6g72HDhpmkcoQQYkn8anm276+OP8DtxzI421phzeg2EAgohQCxDB/0aYoLUZnYfTUB0/s0gdeTtRstSZUCpnfffRcA8Nlnn+nto0HfhJC6ik9emV37kldeiMrAT/8W//X+xajWFvmBROqvro1c0SnIBeGx2fjpTDQ+HdrC3FXSU6UuOY1GU+aLgiVCSF2lHcOUla9Anlxl5tpUztIDd8EY8HpnfwwK9TZ3dQjRwXEcPujTFADw25U4ZOTJzVwjfc+8+C4hhNQXjtZWcLYtHoJQm7rlChVqRKbmAgBm96cVGohler6pO9r4O6NIqcHPZy1vxn2VA6YzZ85g6NChaNKkCZo2bYphw4bh7NmzpqwbIYRYnNq4REpMRj4AwNnWCu72YjPXhhDDOI7DjCfZv7ddjEN2vsLMNdJVpYBp+/bt6NevH2xtbTFjxgxMnz4dNjY26Nu3L3777TdT15EQQiyGfy0c+K1ddqKxhz2tFUcsWp8QT7T0dUSBQo1N52PMXR0dVQqYli9fjlWrVmH37t2YMWMGPvzwQ+zevRtffPEFPv/8c1PXkRBCLIZ/LUwtoA2YGrnX3uzkpH4oHstU3Mq0+XwspIVKM9foqSoFTNHR0Rg6dKje9mHDhiEmpnojQrlcjrZt24LjONy4caPMckqlEvPnz0erVq1gZ2cHX19fvPXWW0hKStIp16tXL3Acp/MaM2ZMtd4DIaT2qo0z5aLSi7vkGnvam7kmhFRsQAtvBHs5IFeuwpYLseauDq9KAZO/vz9Onjypt/3kyZPw9/d/5kqVZ968efD19a2wXEFBAa5du4ZFixbh2rVr2L9/Px48eGAwR9SUKVOQnJzMv3766afqqDohpA6ojckro9KedskRYukEAg7TnrQybTofYzEzUquUh2nOnDmYMWMGbty4ge7du4PjOJw7dw6bN2/GunXrTF1H3pEjR3Ds2DHs27cPR44cKbesk5MTjh8/rrPtm2++QefOnREfH4+AgAB+u62tLby9aZotIaRi/Bim7AJ+wXFLptEwftB3Yw/qkiO1w+BWPvj6xANEp+dj28U4vNersbmrVLUWpvfeew+7du3CrVu3MHPmTHz44Ye4ffs2du/ejXfeecfUdQQApKamYsqUKdi2bRtsbau2mrFUKgXHcXB2dtbZvmPHDri7u6Nly5aYO3cucnNzyz2PXC6HTCbTeRFC6gdfZxsIOKBIqUG6BeaKKS1ZVoRCpRpWQo4ff0WIpRMKOEzrVdzK9MvZaBQozN/KVKUWJgAYOXIkRo4cacq6lIkxhgkTJuDdd99Fx44dERsbW+lzFBUVYcGCBXjjjTfg6Ph0scmxY8eiYcOG8Pb2xu3bt7Fw4ULcvHlTr3WqpJUrV2Lp0qVVuRVCSC0nFgng42SDxzmFSMgqgKeDZWfM1nbHBbjawkpIqfdI7TG8rS/WnXyI+KwC/HY5Hm8/38is9anSb0+jRo2QmZmptz0nJweNGhl/Q0uWLNEbcF36dfXqVXzzzTeQyWRYuHBhVaoLpVKJMWPGQKPR4Pvvv9fZN2XKFPTr1w+hoaEYM2YM9u7dixMnTuDatWtlnm/hwoWQSqX8KyEhoUr1IoTUTn4uTwZ+Z1n+wO+SKQUIqU1EQgHef9IVt+HfaBQpzbuSSJUCptjYWINLoMjlcjx+/Njo80yfPh337t0r9xUaGopTp07h0qVLkEgkEIlEaNKkuJmuY8eOGD9+fLnXUCqVGD16NGJiYnD8+HGd1iVD2rdvDysrKzx8+LDMMhKJBI6OjjovQkj9UZuSV/IBE82QI7XQqPZ+aOBsg7RcOX6/at7GiUp1yR04cID/+ujRo3BycuK/V6vVOHnyJIKCgow+n7u7O9zd3Ssst379eixbtoz/PikpCQMHDsTu3bvRpUuXMo/TBksPHz5EWFgY3NzcKrzWnTt3oFQq4ePjY9xNEELqndqUiylam1KAWphILSQWCfBuz0b49MAdxGWa9/etUgHTiBEjABQnlirdsmNlZYWgoCCsWbPGZJXTKjmjDQDs7Yt/8Rs3bgw/Pz9+e0hICFauXImRI0dCpVLhlVdewbVr13Dw4EGo1WqkpKQAAFxdXSEWixEVFYUdO3bgpZdegru7O+7evYs5c+agXbt26NGjh8nvgxBSN9TKFiaaIUdqqVc7+qNbY3c0MXMraaUCJo1GAwBo2LAhwsPDjWodqkmRkZGQSqUAgMTERL5FrG3btjrlwsLC0KtXL4jFYpw8eRLr1q1DXl4e/P39MXjwYCxevBhCobCmq08IqSW0ySsTLTx5ZW6REqmy4pl8jaiFidRS1lZCswdLQBVnyVV3Nu+KBAUFgTGmt73ktrLKlOTv748zZ86YvH6EkLpN2yWXJC2EQqWBWGSZs8+03XHu9hI42ViZuTaE1G5V+i2fMWMG1q9fr7f922+/xcyZM5+1ToQQYtE87CWwthKAMSApx3JbmaIzqDuOEFOpUsC0b98+g2N8unfvjr179z5zpQghxJJxHKeT8dtSRaXRGnKEmEqVAqbMzEydGXJajo6OyMjIeOZKEUKIpfOvBQO/tQO+G7lTCxMhz6pKAVOTJk3wzz//6G0/cuRIpRJXEkJIbfV0EV7L7ZKjHEyEmE6VBn3Pnj0b06dPR3p6Ovr06QMAOHnyJNasWYOvv/7alPUjhBCL9DTbt2W2MKk1DLEZxXVrQjPkCHlmVQqYJk2aBLlcjuXLl+Pzzz8HUDwr7YcffsBbb71l0goSQogl4luYLHQMU2J2ARRqDSQiAXydbcxdHUJqvSovvvvee+/hvffeQ3p6OmxsbPhkkoQQUh9Y+hgmbXdcQ3c7CAWcmWtDSO1X5YBJy8PDwxT1IISQWkUbMOUUKCErUsLR2rLyHPEz5Kg7jhCTqHLAtHfvXvz++++Ij4+HQqHQ2Xft2rVnrhghhFgye4kIrnZiZOUrkJBVgJa++jOHzYmWRCHEtKo0S279+vWYOHEiPD09cf36dXTu3Blubm6Ijo7Giy++aOo6EkKIRfLnB35b3kw5miFHiGlVKWD6/vvvsWHDBnz77bcQi8WYN28ejh8/jhkzZvBruRFCSF3nz6cWsLxxTNplUahLjhDTqFLAFB8fj+7duwMAbGxskJubCwAYN24cdu7cabraEUKIBfO30Jly2fkKZOYXD5VoSEkrCTGJKgVM3t7eyMzMBAAEBgbi0qVLAIoX5a1owVtCCKkrAiy0hUm7hpyPkzXsJM88t4cQgioGTH369MHff/8NAJg8eTJmzZqF/v3747XXXsPIkSNNWkFCCLFU2vXkLC21AM2QI8T0qvSnx4YNG6DRaAAA7777LlxdXXHu3DkMHToU7777rkkrSAghlkrbwpSYXQiNhkFgIfmOojJohhwhplbpgEmlUmH58uWYNGkS/P39AQCjR4/G6NGjTV45QgixZD7O1hBwgFylQXqeHF6O1uauEoASLUw0Q44Qk6l0l5xIJMLq1auhVquroz6EEFJrWAmfLjtiSeOYovkcTBQwEWIqVRrD1K9fP5w+fdrEVSGEkNrH0sYxKVQaxD2pSyPqkiPEZKo0hunFF1/EwoULcfv2bXTo0AF2drq/lMOGDTNJ5QghxNL5u9rgYrTlJK+Mz8qHWsNgKxbC20K6CAmpC6oUML333nsAgK+++kpvH8dx1F1HCKk3AixsEd6oEgkrOc4yBqETUhdUKWDSzpAjhJD6ztKSV9IacoRUD6PHMLm6uiIjIwMAMGnSJD67NyGE1GfagCnRUlqYnsyQa0QDvgkxKaMDJoVCAZlMBgDYsmULioqKqq1ShBBSW2gHfSfLiiBXmX84QhTNkCOkWhjdJdetWzeMGDECHTp0AGMMM2bMgI2NjcGymzZtMlkFCSHEkrnbi2FjJUShUo2knCKzrt3GGHsaMHlSlxwhpmR0C9P27dvx0ksvIS+v+JdRKpUiOzvb4IsQQuoLjuPg71r8x6O5B35n5CmQW6QCxwFBbhQwEWJKRrcweXl54YsvvgAANGzYENu2bYObm1u1VYwQQmqLAFdbPEjNM3vySm3rkr+LLaythGatCyF1TZUGfffu3RtisbjaKkUIIbWJ35NxTJYSMFHCSkJMjwZ9E0LIMwqwkNQC/BpyNOCbEJOjQd+EEPKM/C0keWV0Bs2QI6S6GB0wbd++HWvXrkVUVBQ4joNUKqVWJkIIAfhB3+ZeHoWSVhJSfWjQNyGEPCNtLiZpoRLSQiWcbKxqvA5FSjUSs4sDtsae1MJEiKkZPYappJiYGAqWCCHkCTuJCG52xRNhzDXwOyYjH4wBjtZP60IIMR2jW5jWr1+PqVOnwtraGuvXry+37IwZM565YoQQUpv4u9oiM1+BxOwChDZwqvHrP01YSYvuElIdjA6Y1q5di7Fjx8La2hpr164tsxzHcdUaMMnlcnTp0gU3b97E9evX0bZt2zLLTpgwAVu2bNHZ1qVLF1y6dEnnfHPnzsXOnTtRWFiIvn374vvvv4efn1913QIhpA7yd7XFjYQcsw38jk6nGXKEVCejA6aYmBiDX9e0efPmwdfXFzdv3jSq/KBBg/Drr7/y35fOHzVz5kz8/fff2LVrF9zc3DBnzhwMGTIEEREREAop8RshxDgBZh74TWvIEVK9jA6YZs+ebVQ5juOwZs2aKleoPEeOHMGxY8ewb98+HDlyxKhjJBIJvL29De6TSqXYuHEjtm3bhn79+gEong3o7++PEydOYODAgQaPk8vlkMvl/Pfa/FSEkPpLO/DbXC1MlLSSkOpldMB0/fp1ne8jIiKgVqsRHBwMAHjw4AGEQiE6dOhg2ho+kZqaiilTpuDPP/+Era2t0cedPn0anp6ecHZ2Rs+ePbF8+XJ4enry96BUKjFgwAC+vK+vL0JDQ3HhwoUyA6aVK1di6dKlz3ZDhJA6xZzJKzUaRkkrCalmRgdMYWFh/NdfffUVHBwcsGXLFri4uAAAsrOzMXHiRDz//PMmryRjDBMmTMC7776Ljh07IjY21qjjXnzxRbz66qsIDAxETEwMFi1ahD59+iAiIgISiQQpKSkQi8X8PWh5eXkhJSWlzPMuXLhQp8VNJpPB39+/SvdGCKkbtMkrE7MKodEwCAQ1N/A6RVaEQqUaIgGHQDfj/6AkhBjP6ICppDVr1uDYsWM6gYaLiwuWLVuGAQMGYM6cOUadZ8mSJRW21ISHh+PChQuQyWRYuHBhper52muv8V+HhoaiY8eOCAwMxKFDhzBq1Kgyj2OMlTvLRCKRQCKRVKouhJC6zcfJGkIBB4Vag7RcObydrGvs2toB3wFutrASVilbDCGkAlUKmGQyGVJTU9GyZUud7WlpacjNzTX6PNOnT8eYMWPKLRMUFIRly5bh0qVLekFKx44dMXbsWL2ZcGXx8fFBYGAgHj58CADw9vaGQqFAdna2TvCXlpaG7t27G30fhBAiEgrg62yNhKxCxGcV1GjARAO+Cal+VQqYRo4ciYkTJ2LNmjXo2rUrAODSpUv46KOPym25Kc3d3R3u7u4Vllu/fj2WLVvGf5+UlISBAwdi9+7d6NKli9HXy8zMREJCAnx8fAAAHTp0gJWVFY4fP47Ro0cDAJKTk3H79m2sWrXK6PMSQghQPI4pIasQCVkF6NzQtcauSwO+Cal+VQqYfvzxR8ydOxdvvvkmlEpl8YlEIkyePBmrV682aQUBICAgQOd7e/viv6IaN26sky8pJCQEK1euxMiRI5GXl4clS5bg5Zdfho+PD2JjY/Hxxx/D3d0dI0eOBAA4OTlh8uTJmDNnDtzc3ODq6oq5c+eiVatW/Kw5QggxVvFMucwanylHLUyEVL8qBUy2trb4/vvvsXr1akRFRYExhiZNmsDOzrx/3URGRkIqlQIAhEIhbt26ha1btyInJwc+Pj7o3bs3du/eDQcHB/6YtWvXQiQSYfTo0Xziys2bN1MOJkJIpfmbaaYcJa0kpPpVKWDSsrOzQ+vWrU1VF6MFBQWBMaa3veQ2GxsbHD16tMJzWVtb45tvvsE333xj0joSQuqfkjPlakqeXIVkaREAoDF1yRFSbWg6BSGEmIi/S3G275rskot50rrkbi+Gsy0tuktIdaGAiRBCTESbvDI1twhFSnWNXJMf8O1O3XGEVCcKmAghxERc7cSwFQvBGPA4p2a65fgB357UHUdIdaKAiRBCTITjuKdLpNRQtxwN+CakZlDARAghJuTnUrMBE6UUIKRmUMBECCEm9HQR3urvklNrGKIzqIWJkJpAARMhhJiQv+uTmXKZ1d/C9Di7EAqVBmKRAA2ezNAjhFQPCpgIIcSEAmoweaW2O66hmx2EgrIXDCeEPDsKmAghxIS0yStrIhcTzZAjpOZQwEQIISbk96RrLLdIBWmBslqvFUUz5AipMRQwEUKICdmKRXC3lwCo/m45PmklLYlCSLWjgIkQQkyMH/hdzd1y0ZRSgJAaQwETIYSYWE0kr5QWKJGRpwAANKKAiZBqRwETIYSYmL9L9Q/8jsoobl3ydrSGvURUbdchhBSjgIkQQkysJpJXRqXRDDlCahIFTIQQYmJ+T8YwVWeXnHaGXCN36o4jpCZQwEQIISambWF6nF0ItYZVyzWeriFHLUyE1AQKmAghxMR8nGwgEnBQqDVIlRVVyzX4GXKe1MJESE2ggIkQQkxMKOD4td2qo1tOqdYg7sladZRSgJCaQQETIYRUg+qcKRefVQCVhsFWLIS3o7XJz08I0UcBEyGEVANt8srqmCmnnSHX0N0OAlp0l5AaQQETIYRUA+0ivInV0MJEa8gRUvMoYCKEkGpQnV1ytCQKITWPAiZCCKkGT5NXVkcLEyWtJKSmUcBECCHVQNsllyqTo0ipNtl5GWPUJUeIGVDARAgh1cDF1opf4y3RhAO/M/MVkBYqwXHFg74JITWDAiZCCKkGHMfBrxpyMUU/aV1q4GwDayuhyc5LCCkfBUyEEFJNqmMcUxQN+CbELChgIoSQaqIdxxSfacKAKY0CJkLMgQImQgipJtXZwtSIFt0lpEZRwEQIIdVEm+07Pst0g75phhwh5kEBEyGEVJOAEtm+GWPPfL4ipRqJT1qrKAcTITWr1gVMcrkcbdu2BcdxuHHjRrllOY4z+Fq9ejVfplevXnr7x4wZU813QQipD/yeZPvOlasgLVQ+8/niMgugYYCDtQge9pJnPh8hxHi1LmCaN28efH19jSqbnJys89q0aRM4jsPLL7+sU27KlCk65X766afqqDohpJ6xthLCw6E4sDHFEiklZ8hxHC26S0hNEpm7ApVx5MgRHDt2DPv27cORI0cqLO/t7a3z/V9//YXevXujUaNGOtttbW31yhJCiCkEuNoiPVeOhKxCtPZzfqZzaWfI0YBvQmperWlhSk1NxZQpU7Bt2zbY2tpW6fhDhw5h8uTJevt27NgBd3d3tGzZEnPnzkVubm6555LL5ZDJZDovQggxxN9FO/DbtC1MhJCaVStamBhjmDBhAt5991107NgRsbGxlT7Hli1b4ODggFGjRulsHzt2LBo2bAhvb2/cvn0bCxcuxM2bN3H8+PEyz7Vy5UosXbq00nUghNQ/pkwtEJ1BM+QIMRezBkxLliypMPAIDw/HhQsXIJPJsHDhwipfa9OmTRg7diysra11tk+ZMoX/OjQ0FE2bNkXHjh1x7do1tG/f3uC5Fi5ciNmzZ/Pfy2Qy+Pv7V7luhJC6y08bMD1jCxNjjO+Sa0Iz5AipcWYNmKZPn17hjLSgoCAsW7YMly5dgkSiOyukY8eOGDt2LLZs2VLuOc6ePYvIyEjs3r27wjq1b98eVlZWePjwYZkBk0Qi0asLIYQYEmCigClVJke+Qg2hgEOAKwVMhNQ0swZM7u7ucHd3r7Dc+vXrsWzZMv77pKQkDBw4ELt370aXLl0qPH7jxo3o0KED2rRpU2HZO3fuQKlUwsfHp8KyhBBSEe3yKI9zCqHWMAgFVZvdph2/FOBqC7Go1gw/JaTOqBVjmAICAnS+t7cv7r9v3Lgx/Pz8+O0hISFYuXIlRo4cyW+TyWTYs2cP1qxZo3feqKgo7NixAy+99BLc3d1x9+5dzJkzB+3atUOPHj2q6W4IIfWJt6M1rIQclGqGFFkRGjjbVOk8Twd8U+sSIeZQp/5MiYyMhFQq1dm2a9cuMMbw+uuv65UXi8U4efIkBg4ciODgYMyYMQMDBgzAiRMnIBQKa6rahJA6TCjg+CDpWRbhjaYlUQgxq1rRwlRaUFCQwWUGDG2bOnUqpk6davA8/v7+OHPmjMnrRwghJfm72iI2swAJ2QXoBrcqnYNSChBiXnWqhYkQQiyRf4k15apKO0OO1pAjxDwoYCKEkGrm/2RNuaomryxQqJAkLQIANHKnFiZCzIECJkIIqWZPk1cWVul47fglVzsxXOzEJqsXIcR4FDARQkg183d9tuVRaIYcIeZHARMhhFQzbQtTeq4chQp1pY+PohlyhJgdBUyEEFLNnGys4CApnpScWIU15bQtTI2ohYkQs6GAiRBCqhnHcfxMuaoswsvPkKMWJkLMhgImQgipAfw4pkomr9RoGGIyqEuOEHOjgIkQQmpAVWfKPc4phFylgVgogJ9L1ZZVIYQ8OwqYCCGkBmi75Co7U047finI3RYiIf2XTYi50G8fIYTUAH4MU6UDpuLuOEpYSYh5UcBECCE1QJvtOzG70OC6l2XhczDRkiiEmBUFTIQQUgO044/y5CpkFyiNPi6aFt0lxCJQwEQIITXA2koIL0cJgMp1y1HSSkIsAwVMhBBSQyq7CK+0UIn0XDkASlpJiLlRwEQIITUkoJLJK7XdcZ4OEjhYW1VbvQghFaOAiRBCaohfJWfKRVN3HCEWgwImQgipIXwLU5ZxyStphhwhloMCJkIIqSH+T2bKGTuGKYpmyBFiMShgIoSQGhLgVtzClJRTCLWm4lxMfNJKCpgIMTsKmAghpIZ4OVhDLBRApWFIlpbfLadSaxCXqR3DRF1yhJgbBUyEEFJDBAKOT2BZUbdcQnYhlGoGaysBfJ1o0V1CzI0CJkIIqUHamXKJFQz8jkorHr/UyN0eAgFX7fUihJSPAiZCCKlBAa7GtTA9nSFH45cIsQQUMBFCSA3SZvuuKHmlNmBq5E7jlwixBBQwEUJIDfJ3NW55FH4NOWphIsQiUMBECCE1yNjkldF8DiZqYSLEElDARAghNUjbJZeRJ0eBQmWwTFa+AtkFSgDFg74JIeZHARMhhNQgJ1srOFqLAACJ2YZbmbTjlxo428BGLKyxuhFCykYBEyGE1DB+HFOm4XFMfEoB6o4jxGJQwEQIITWMH8dUxky56Axthm/qjiPEUlDARAghNcy/goHf2hYmmiFHiOWoNQFTUFAQOI7TeS1YsKDcYxhjWLJkCXx9fWFjY4NevXrhzp07OmXkcjk++OADuLu7w87ODsOGDUNiYmJ13gohpJ6rKLVAFM2QI8Ti1JqACQA+++wzJCcn86///e9/5ZZftWoVvvrqK3z77bcIDw+Ht7c3+vfvj9zcXL7MzJkz8ccff2DXrl04d+4c8vLyMGTIEKjV6uq+HUJIPeX/ZD25RANdcnKVmg+kmlCXHCEWQ2TuClSGg4MDvL29jSrLGMPXX3+NTz75BKNGjQIAbNmyBV5eXvjtt9/wzjvvQCqVYuPGjdi2bRv69esHANi+fTv8/f1x4sQJDBw4sNruhRBSfwWUaGFijIHjnq4VF5dZAA0D7CUieDhIzFVFQkgptaqF6csvv4Sbmxvatm2L5cuXQ6FQlFk2JiYGKSkpGDBgAL9NIpGgZ8+euHDhAgAgIiICSqVSp4yvry9CQ0P5MobI5XLIZDKdFyGEGKuBiw04DihQqJGVr/v/WMmElSUDKUKIedWaFqYPP/wQ7du3h4uLC65cuYKFCxciJiYGv/zyi8HyKSkpAAAvLy+d7V5eXoiLi+PLiMViuLi46JXRHm/IypUrsXTp0me5HUJIPSYRCeHlYI0UWRHiswrgZv+0JYlfEoW64wixKGZtYVqyZIneQO7Sr6tXrwIAZs2ahZ49e6J169Z4++238eOPP2Ljxo3IzMws9xql/0Ir3fxtSEVlFi5cCKlUyr8SEhKMvGNCCCn2NLWA7kw5miFHiGUyawvT9OnTMWbMmHLLBAUFGdzetWtXAMCjR4/g5uamt1871iklJQU+Pj789rS0NL7VydvbGwqFAtnZ2TqtTGlpaejevXuZdZJIJJBIaGwBIaTq/FxtcCUWSCg1U047Q66RO82QI8SSmDVgcnd3h7u7e5WOvX79OgDoBEMlNWzYEN7e3jh+/DjatWsHAFAoFDhz5gy+/PJLAECHDh1gZWWF48ePY/To0QCA5ORk3L59G6tWrapSvQghxBhPF+F9GjAxxp52yVELEyEWpVaMYbp48SIuXbqE3r17w8nJCeHh4Zg1axaGDRuGgIAAvlxISAhWrlyJkSNHguM4zJw5EytWrEDTpk3RtGlTrFixAra2tnjjjTcAAE5OTpg8eTLmzJkDNzc3uLq6Yu7cuWjVqhU/a44QQqqDdhHekrmY0nPlyJOrIOCAQDdbc1WNEGJArQiYJBIJdu/ejaVLl0IulyMwMBBTpkzBvHnzdMpFRkZCKpXy38+bNw+FhYV4//33kZ2djS5duuDYsWNwcHDgy6xduxYikQijR49GYWEh+vbti82bN0MopAUvCSHVJ8BNf3mUR0+64wJcbSER0f9BhFgSjjHGzF2J2k4mk8HJyQlSqRSOjo7mrg4hpBZIkRah68qTEAo4RH4+CCKhANsuxWHRn7fRN8QTGyd0MncVCanzKvP5XavyMBFCSF3h6SCBWCSAWsOQLC0C8HSGXCNaEoUQi0MBEyGEmIFAwMHvyRIp2oHf0RmUg4kQS0UBEyGEmElAqUV4KQcTIZaLAiZCCDET7Uy5hOwCFCrUeJxTnMSSWpgIsTwUMBFCiJk8bWEqRHRGceuSi60VXO3E5qwWIcQACpgIIcRM/F2fjmHSJqxsRK1LhFgkCpgIIcRM/FyeZvuOfpKDqTHNkCPEIlHARAghZqJNXpmZr8CtxOKkuzR+iRDLRAETIYSYiaO1FZxsrAAAF6IyAVDARIilooCJEELMSDvwu1CpBkApBQixVBQwEUKIGWkHfgOAlZCDv4tNOaUJIeZCARMhhJiR/5MWJgAIdLODSEj/LRNiieg3kxBCzEibvBKgGXKEWDIKmAghxIwCXEsGTDR+iRBLRQETIYSYUckuOUpaSYjlooCJEELMqIGzDTiu+GvqkiPEconMXQFCCKnPxCIBXmnvh6j0PLTwdTR3dQghZaCAiRBCzGz1q23MXQVCSAWoS44QQgghpAIUMBFCCCGEVIACJkIIIYSQClDARAghhBBSAQqYCCGEEEIqQAETIYQQQkgFKGAihBBCCKkABUyEEEIIIRWggIkQQgghpAKU6ZsQQgipQFJSEo4cOQKBQAAfHx8MGjQIAHD+/HlERkbC2dkZw4cPh1qtxs6dO6HRaCCRSPDyyy9DIpEAAHJzc7Fu3Tq8//77cHV11Tl/TEwMTp06BZFIhJEjR8LR0RFRUVEICwuDSCTCSy+9BE9PT51j0tLScPDgQQDA4MGD4eXlhdOnT+P+/fuwtrZGcHAwunXrpnPMrl27EBsbi9GjR6NRo0YAgM2bN/P7e/bsiYYNG+oc8+2338Le3p6/joeHBy5duoTbt28DAAYOHAh/f3++vEKhqPR7UNb7e/jwYaSlpcHZ2RnDhg2DQCDAuXPn8ODBA9jZ2WHEiBGQSCQG63Po0CGkpqaC4zi89NJL8PLywr///ovo6GgoFAo899xz8PPzM+rnDwBg5JlJpVIGgEmlUnNXhRBCSDXIzc1lCoWCMcbY/v37WUpKCsvLy2Pbt29njDF29uxZdvv2baZUKplMJmOMMRYREcEuXbrEn+PYsWPs119/ZZmZmXrn37x5MysqKmIJCQns4MGDjDHGNm3axORyOZPJZGz37t16x+zatYvl5OQwqVTKdu7cyRhjLCwsjEVFRZV5HzKZTK/Mr7/+ytRqdZnHbNy4UW/bjz/+yDQaDcvOzma7du3S2VeV98DQ+5uYmMgOHDjAGGPs/Pnz7M6dO0wmk7EdO3Ywxhi7c+cOO3/+fJn1ycrKYowxlpmZyb9/KpWKMcaYXC5nP//8c6U+v6lLjhBCCKmAvb09rKysAAAcx0EgEODx48cICgoCADRq1AiJiYkQiURwcHDQKQcA+fn5kMvlcHZ21ju3UqmESCSCRCKBn58fMjIy+H1isRgODg7IysrSO66wsBBOTk5wdHREUVERv/3EiRPYunUrUlJS9I7R1q0kjuOwdetW7N27F4WFhQCAGzduICkpib/Or7/+ir///hsqlQoA4OrqCpVKhaKiItjY2OgcU5X3wND7m52dDS8vLwCAt7c3EhMTIZVK4e7urrOtrPq4uLgAAAQCATiOAwAIhUL+PS/dYlcRCpgIIYQQI6WmpqKgoAAeHh4oKiriu5qsra11ghaFQoFr166hVatWAIBLly6hc+fOBs9ZWFjInwcANBoN/3VeXh4yMjJ0gigtxpje1126dMHUqVMxePBgHDlyxKh7Gj16NCZMmIDg4GD8+++/AIC2bdvC19cXADBp0iRMnDgRzs7OiIiIAAA0bNgQ3333HX777Td06dJF75jKvgdaJd9fd3d3xMXFASjusiwsLISLiwuSkpKg0WgQExPDv+eG6qN18uRJnW1///03fvzxR72ux4pQwEQIIYQYobCwEIcPH8awYcMAFAdJcrkcACCXy2FtbQ2gOHj566+/0KdPHz6QkslkOi0a+fn52Lx5MzZv3gwbGxv+PAD41pABAwZg3759OHv2LD9GaOvWrdi8eTPy8vL4ciWP0bauuLm5GX1f2mNCQkKQlpZW4X65XI7r16/jgw8+wOTJk3HixAm9Y4x5D0or/f56e3vDy8sLW7ZsgVwuh729Pezs7NC6dWts3boVmZmZsLOzK7c+ly5dgru7OwICAvhtQ4cOxbRp03D27Fmj3yOABn2bhDayl8lkZq4JIYSQ6qDRaPDXX3+he/fu0Gg0kMlkcHR0xKVLl9CqVSvcvXsXrq6ukMlkuHDhAjw8PODm5gaZTIbk5GSkp6dj8+bNyMjIQFZWFl555RWMGjUKQHGgUFRUxO9zcnKCTCaDg4MDRo4ciZycHFy7dg0ymQwjRozg6yMSifD48WNwHAehUAiZTAa5XA6JRILCwkIolUqDn0tyuRz5+fn8Pu0xcXFxsLe31zlGrVaDMQaRSIQHDx7A1tYWubm5EAgEyM/Ph1KpREFBgd51jH0Pynt/geJWq7Zt2+LSpUvw9fWFTCZDkyZN0KRJE9y9exdOTk5l1icuLg7R0dEYPHgwfz6VSgWRSAS1Wg2RSMRvL9laVxaOGVOKlCsxMVFnhgAhhJC6JTQ0FC+++CLS09MBFI8TSkxMRI8ePRAcHAypVIo///zz/9u7/5io6z8O4M+Djh8Sokj8uNALGOgGDAUzYYJExSJJnWVSlrgMsgnKtE1bGbS55WxpW0b5BzoqJ/2DrIHLwQTUGMWvFMghjZ8pP6bGD+XXwb2+fzRvniAf8gt3cPd8bGzwvs/B6/V5ve724vP53B3mzZuHtLQ0tLe3AwDq6upQWVlp+D0bN27ExYsXx12T5Ovri+effx6jo6PIy8tDb28vIiMj4evri8HBQeTn52NgYMDoPh4eHli3bh2Af19N1tnZifj4eLi7u0OlUqGoqMhwSuu+V155Bf7+/hgaGkJlZSWqqqqQnJwMnU5n+Nv9/f1Yvnw5urq60NfXh7fffhsjIyMYHBxEbm4uRkZGEBkZiYCAANjY2KC0tBTXr1833Ofu3btT3gdr1qzBlStXoNVqx+3fGzduIDExEXq9Hi0tLYbThZs3b4ajoyO6u7tx/vx5iMiE8aSkpGB4eBg6nQ63bt1Cfn4+4uPj4ebmBltbW5SVleHatWsAgPb2dsVXzHFgmgZ6vR43b96Es7Oz0SHS6dDX14fFixejvb0d8+fPn9bfPRcwf+vOH+A+sPb8Ae4D5j9z+YsI+vv7odFoDBenPwpPyU0DGxub//ZeDo9h/vz5VvlAuY/5W3f+APeBtecPcB8w/5nJ38XFZUrb8aJvIiIiIgUcmIiIiIgUcGCa5ezt7ZGenm70Hh3WhPlbd/4A94G15w9wHzD/2ZE/L/omIiIiUsAjTEREREQKODARERERKeDARERERKSAAxMRERGRAg5Ms1hmZiZ8fHzg4OCAsLCw//xBgXPF559/jmeffRbOzs5wd3fHxo0b0dDQYLTN9u3boVKpjL5Wr15tpoinX0ZGxrj8PD09DbeLCDIyMqDRaODo6Ijo6GjU19ebMeLp9cwzz4zLX6VSYdeuXQAss/4XL17Eq6++Co1GA5VKhby8PKPbp1Lz4eFhpKamws3NDU5OTli/fj3+/vtvE2bx+CbLX6fTYf/+/QgODoaTkxM0Gg22bduGmzdvGv2O6OjocX2RkJBg4kwej1L9p9Lzc7n+gPI+mOg5QaVS4YsvvjBsY8oe4MA0S/30009IS0vDxx9/jJqaGkRGRiIuLg5tbW3mDm3alZaWYteuXSgvL0dhYSFGR0cRGxuLe/fuGW338ssvo6Ojw/B17tw5M0U8MwIDA43yq62tNdx25MgRHD16FMePH0dFRQU8PT3x0ksvob+/34wRT5+Kigqj3AsLCwH8+5lR91la/e/du4eQkBAcP358wtunUvO0tDScPXsWOTk5uHz5Mu7evYv4+HiMjY2ZKo3HNln+AwMDqK6uxsGDB1FdXY3c3Fxcv37d8Cn2D0pKSjLqixMnTpgi/P+bUv0B5Z6fy/UHlPfBg7l3dHTg5MmTUKlUeO2114y2M1kPCM1Kq1atkp07dxqtLVu2TA4cOGCmiEynu7tbAEhpaalhLTExUTZs2GC+oGZYenq6hISETHibXq8XT09POXz4sGFtaGhIXFxc5LvvvjNRhKa1Z88e8fPzE71eLyKWX38AcvbsWcPPU6l5T0+PqNVqycnJMWxz48YNsbGxkV9++cVksU+Hh/OfyO+//y4ApLW11bC2du1a2bNnz8wGZwIT5a/U85ZUf5Gp9cCGDRskJibGaM2UPcAjTLPQyMgIqqqqEBsba7QeGxuLsrIyM0VlOr29vQAAV1dXo/WSkhK4u7sjICAASUlJ6O7uNkd4M6axsREajQY+Pj5ISEhAU1MTAKC5uRmdnZ1G/WBvb4+1a9daZD+MjIzgxx9/xLvvvmv0YdaWXv8HTaXmVVVV0Ol0RttoNBoEBQVZZF/09vZCpVJhwYIFRuunT5+Gm5sbAgMD8eGHH1rMUVdg8p63tvp3dXWhoKAAO3bsGHebqXqAH747C926dQtjY2Pw8PAwWvfw8EBnZ6eZojINEcHevXuxZs0aBAUFGdbj4uKwefNmaLVaNDc34+DBg4iJiUFVVZXZ3/11Ojz33HP4/vvvERAQgK6uLhw6dAgRERGor6831HyifmhtbTVHuDMqLy8PPT092L59u2HN0uv/sKnUvLOzE3Z2dli4cOG4bSzteWJoaAgHDhzAW2+9ZfThq1u3boWPjw88PT1RV1eHjz76CFeuXDGc0p3LlHremuoPANnZ2XB2dsamTZuM1k3ZAxyYZrEH/7sG/h0mHl6zNCkpKbh69SouX75stL5lyxbD90FBQVi5ciW0Wi0KCgrGPYDmori4OMP3wcHBCA8Ph5+fH7Kzsw0XelpLP2RlZSEuLg4ajcawZun1f5THqbml9YVOp0NCQgL0ej0yMzONbktKSjJ8HxQUBH9/f6xcuRLV1dUIDQ01dajT6nF73tLqf9/JkyexdetWODg4GK2bsgd4Sm4WcnNzg62t7bj/Erq7u8f9x2lJUlNT8fPPP6O4uBje3t6Tbuvl5QWtVovGxkYTRWdaTk5OCA4ORmNjo+HVctbQD62trSgqKsJ777036XaWXv+p1NzT0xMjIyP4559/HrnNXKfT6fDGG2+gubkZhYWFRkeXJhIaGgq1Wm2RffFwz1tD/e+7dOkSGhoaFJ8XgJntAQ5Ms5CdnR3CwsLGHVIsLCxERESEmaKaOSKClJQU5Obm4sKFC/Dx8VG8z+3bt9He3g4vLy8TRGh6w8PDuHbtGry8vAyHmx/sh5GREZSWllpcP5w6dQru7u5Yt27dpNtZev2nUvOwsDCo1WqjbTo6OlBXV2cRfXF/WGpsbERRUREWLVqkeJ/6+nrodDqL7IuHe97S6/+grKwshIWFISQkRHHbGe0Bk1xaTv9ZTk6OqNVqycrKkj///FPS0tLEyclJWlpazB3atPvggw/ExcVFSkpKpKOjw/A1MDAgIiL9/f2yb98+KSsrk+bmZikuLpbw8HB5+umnpa+vz8zRT499+/ZJSUmJNDU1SXl5ucTHx4uzs7Oh3ocPHxYXFxfJzc2V2tpaefPNN8XLy8ti8hcRGRsbkyVLlsj+/fuN1i21/v39/VJTUyM1NTUCQI4ePSo1NTWGV4FNpeY7d+4Ub29vKSoqkurqaomJiZGQkBAZHR01V1pTNln+Op1O1q9fL97e3vLHH38YPS8MDw+LiMhff/0ln332mVRUVEhzc7MUFBTIsmXLZMWKFXM+/6n2/Fyuv4jyY0BEpLe3V+bNmyfffvvtuPubugc4MM1i33zzjWi1WrGzs5PQ0FCjl9lbEgATfp06dUpERAYGBiQ2NlaeeuopUavVsmTJEklMTJS2tjbzBj6NtmzZIl5eXqJWq0Wj0cimTZukvr7ecLter5f09HTx9PQUe3t7iYqKktraWjNGPP3Onz8vAKShocFo3VLrX1xcPGHfJyYmisjUaj44OCgpKSni6uoqjo6OEh8fP2f2y2T5Nzc3P/J5obi4WERE2traJCoqSlxdXcXOzk78/Pxk9+7dcvv2bfMmNkWT5T/Vnp/L9RdRfgyIiJw4cUIcHR2lp6dn3P1N3QMqEZHpP25FREREZDl4DRMRERGRAg5MRERERAo4MBEREREp4MBEREREpIADExEREZECDkxERERECjgwERERESngwERERESkgAMTEdFjio6ORlpamrnDICIT4Dt9ExE9pjt37kCtVsPZ2dncoRDRDOPARERERKSAp+SIyKpFR0cjJSUFKSkpWLBgARYtWoRPPvkE9/+XzMzMhL+/PxwcHODh4YHXX3/d6L48JUdkHZ4wdwBEROaWnZ2NHTt24LfffkNlZSWSk5Oh1WqxYsUK7N69Gz/88AMiIiJw584dXLp0ydzhEpEZcGAiIqu3ePFiHDt2DCqVCkuXLkVtbS2OHTuGQ4cOwcnJCfHx8XB2djYMUURkfXhKjois3urVq6FSqQw/h4eHo7GxES+88AK0Wi18fX3xzjvv4PTp0xgYGDBjpERkLhyYiIge4cknn0R1dTXOnDkDLy8vfPrppwgJCUFPT4+5QyMiE+PARERWr7y8fNzP/v7+sLW1xRNPPIEXX3wRR44cwdWrV9HS0oILFy6YKVIiMhdew0REVq+9vR179+7F+++/j+rqanz99df48ssvkZ+fj6amJkRFRWHhwoU4d+4c9Ho9li5dau6QicjEODARkdXbtm0bBgcHsWrVKtja2iI1NRXJycn49ddfkZubi4yMDAwNDcHf3x9nzpxBYGCguUMmIhPjG1cSkVWLjo7G8uXL8dVXX5k7FCKaxXgNExEREZECDkxERERECnhKjoiIiEgBjzARERERKeDARERERKSAAxMRERGRAg5MRERERAo4MBEREREp4MBEREREpIADExEREZECDkxERERECv4HOnV2db7ps3QAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from apstools.utils import plotxy\n", "\n", "title = \"$Q=(210)$ and $hkl_2=(1, -2, 0)$\"\n", "for item in diffractometer.real_positioners:\n", " plotxy(run, \"psi\", item.name, stats=False, title=title)" ] } ], "metadata": { "kernelspec": { "display_name": "bluesky_2024_2", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.0" } }, "nbformat": 4, "nbformat_minor": 2 }