From 9f8869f0a9afe11defdb25dd4ae23a3bd649d86c Mon Sep 17 00:00:00 2001 From: olmai Date: Mon, 17 Jun 2024 13:23:43 +0200 Subject: [PATCH 1/7] notebooks folder --- notebooks/placeholder | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 notebooks/placeholder diff --git a/notebooks/placeholder b/notebooks/placeholder new file mode 100644 index 0000000..e69de29 From a1437f1cfac6b29cf876650e4ca632a96b9e9bdd Mon Sep 17 00:00:00 2001 From: Oliver Maith <73993227+Olimaol@users.noreply.github.com> Date: Mon, 17 Jun 2024 13:24:58 +0200 Subject: [PATCH 2/7] Created test_example using Colab --- notebooks/test_example.ipynb | 656 +++++++++++++++++++++++++++++++++++ 1 file changed, 656 insertions(+) create mode 100644 notebooks/test_example.ipynb diff --git a/notebooks/test_example.ipynb b/notebooks/test_example.ipynb new file mode 100644 index 0000000..dc9d01f --- /dev/null +++ b/notebooks/test_example.ipynb @@ -0,0 +1,656 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true, + "authorship_tag": "ABX9TyOZMLYfTMYkRkseiKuZBo6p", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Install CompNeuroPy and ANNarchy" + ], + "metadata": { + "id": "MQwRmyFdmUuD" + } + }, + { + "cell_type": "code", + "source": [ + "!pip install CompNeuroPy\n", + "!git clone https://github.com/ANNarchy/ANNarchy && cd ANNarchy && git checkout develop && pip install .\n", + "!rm -rf ANNarchy" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "VGC0ujzTm-z3", + "outputId": "047c2bc4-fb92-4026-9b5c-7a77b20f5843" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: CompNeuroPy in /usr/local/lib/python3.10/dist-packages (1.0.1)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.12.1)\n", + "Requirement already satisfied: cython in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (3.0.10)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (3.7.1)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.13.1)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.25.2)\n", + "Requirement already satisfied: typingchecker in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.1.11)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (2.0.3)\n", + "Requirement already satisfied: tabulate in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.9.0)\n", + "Requirement already satisfied: deap in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.4.1)\n", + "Requirement already satisfied: screeninfo in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.8.1)\n", + "Requirement already satisfied: cmaes in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.10.0)\n", + "Requirement already satisfied: pip-chill in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.0.3)\n", + "Requirement already satisfied: pingouin in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.5.4)\n", + "Requirement already satisfied: efel in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (5.6.28)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (4.66.4)\n", + "Requirement already satisfied: neo>=0.5.2 in /usr/local/lib/python3.10/dist-packages (from efel->CompNeuroPy) (0.13.1)\n", + "Requirement already satisfied: pynwb>=2.6.0 in /usr/local/lib/python3.10/dist-packages (from efel->CompNeuroPy) (2.8.0)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from efel->CompNeuroPy) (4.12.2)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (4.53.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (24.1)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->CompNeuroPy) (2023.4)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas->CompNeuroPy) (2024.1)\n", + "Requirement already satisfied: seaborn in /usr/local/lib/python3.10/dist-packages (from pingouin->CompNeuroPy) (0.13.1)\n", + "Requirement already satisfied: statsmodels in /usr/local/lib/python3.10/dist-packages (from pingouin->CompNeuroPy) (0.14.2)\n", + "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from pingouin->CompNeuroPy) (1.2.2)\n", + "Requirement already satisfied: pandas-flavor in /usr/local/lib/python3.10/dist-packages (from pingouin->CompNeuroPy) (0.6.0)\n", + "Requirement already satisfied: mpmath<1.4.0,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->CompNeuroPy) (1.3.0)\n", + "Requirement already satisfied: quantities>=0.14.1 in /usr/local/lib/python3.10/dist-packages (from neo>=0.5.2->efel->CompNeuroPy) (0.15.0)\n", + "Requirement already satisfied: h5py>=2.10 in /usr/local/lib/python3.10/dist-packages (from pynwb>=2.6.0->efel->CompNeuroPy) (3.9.0)\n", + "Requirement already satisfied: hdmf>=3.14.0 in /usr/local/lib/python3.10/dist-packages (from pynwb>=2.6.0->efel->CompNeuroPy) (3.14.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->CompNeuroPy) (1.16.0)\n", + "Requirement already satisfied: xarray in /usr/local/lib/python3.10/dist-packages (from pandas-flavor->pingouin->CompNeuroPy) (2023.7.0)\n", + "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->pingouin->CompNeuroPy) (1.4.2)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->pingouin->CompNeuroPy) (3.5.0)\n", + "Requirement already satisfied: patsy>=0.5.6 in /usr/local/lib/python3.10/dist-packages (from statsmodels->pingouin->CompNeuroPy) (0.5.6)\n", + "Requirement already satisfied: jsonschema>=2.6.0 in /usr/local/lib/python3.10/dist-packages (from hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (4.19.2)\n", + "Requirement already satisfied: ruamel-yaml>=0.16 in /usr/local/lib/python3.10/dist-packages (from hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (0.18.6)\n", + "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6.0->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (23.2.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6.0->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (2023.12.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6.0->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (0.35.1)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6.0->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (0.18.1)\n", + "Requirement already satisfied: ruamel.yaml.clib>=0.2.7 in /usr/local/lib/python3.10/dist-packages (from ruamel-yaml>=0.16->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (0.2.8)\n", + "Cloning into 'ANNarchy'...\n", + "remote: Enumerating objects: 30590, done.\u001b[K\n", + "remote: Counting objects: 100% (9111/9111), done.\u001b[K\n", + "remote: Compressing objects: 100% (1868/1868), done.\u001b[K\n", + "remote: Total 30590 (delta 7370), reused 8955 (delta 7223), pack-reused 21479\u001b[K\n", + "Receiving objects: 100% (30590/30590), 19.35 MiB | 18.80 MiB/s, done.\n", + "Resolving deltas: 100% (23634/23634), done.\n", + "Branch 'develop' set up to track remote branch 'develop' from 'origin'.\n", + "Switched to a new branch 'develop'\n", + "Processing /content/ANNarchy\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (67.7.2)\n", + "Requirement already satisfied: cython in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (3.0.10)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (1.25.2)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (1.12.1)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (1.13.1)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (3.7.1)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (4.66.4)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (1.2.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (4.53.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (1.4.5)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (24.1)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (9.4.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (3.1.2)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (2.8.2)\n", + "Requirement already satisfied: mpmath<1.4.0,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->ANNarchy==4.8.1) (1.3.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->ANNarchy==4.8.1) (1.16.0)\n", + "Building wheels for collected packages: ANNarchy\n", + " Building wheel for ANNarchy (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for ANNarchy: filename=ANNarchy-4.8.1-cp310-cp310-linux_x86_64.whl size=2055169 sha256=21c94490fa22f85a8f81e73fb001631c9e16a6855a8e598576486ed321f8b2ca\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-nn2c_iqx/wheels/27/fe/ed/59a29dfb0abcc144a3e2959967c5f106d5da012bb1711593e7\n", + "Successfully built ANNarchy\n", + "Installing collected packages: ANNarchy\n", + "Successfully installed ANNarchy-4.8.1\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Import packages" + ], + "metadata": { + "id": "Mcoz2oq76flU" + } + }, + { + "cell_type": "code", + "source": [ + "from IPython.display import Image, display" + ], + "metadata": { + "id": "bMhApHy-6iJ3" + }, + "execution_count": 29, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#Run Code" + ], + "metadata": { + "id": "O7uDvr2W7UZ_" + } + }, + { + "cell_type": "code", + "source": [ + "from ANNarchy import Population, setup, simulate, compile\n", + "from CompNeuroPy import (\n", + " CompNeuroMonitors,\n", + " PlotRecordings,\n", + ")\n", + "from CompNeuroPy.neuron_models import Izhikevich2007\n", + "\n", + "\n", + "### setup ANNarchy timestep and create results folder\n", + "setup(dt=0.1)\n", + "\n", + "### first we create two populations, each consist of 1 neuron\n", + "Population(1, neuron=Izhikevich2007(I_app=0), name=\"my_pop1\")\n", + "Population(1, neuron=Izhikevich2007(I_app=52), name=\"my_pop2\")\n", + "\n", + "### compile\n", + "compile()\n", + "\n", + "### after compilation we can define the monitors using the monitor_dictionary\n", + "### and the CompNeuroMonitors class\n", + "### for my_pop1 we use a recording period of 2 ms\n", + "### for my_pop2 we do not give a recording preiod, therefore record every timestep\n", + "monitor_dictionary = {\"my_pop1;2\": [\"v\", \"spike\"], \"my_pop2\": [\"v\"]}\n", + "mon = CompNeuroMonitors(monitor_dictionary)\n", + "\n", + "### In this part we demonstrate starting/pausing all monitors\n", + "### simulate for 100 ms [0, 100]\n", + "simulate(100)\n", + "\n", + "### start all monitors and simulate for 100 ms [100, 200]\n", + "mon.start()\n", + "simulate(100)\n", + "\n", + "### pause all monitors and simulate for 100 ms [200, 300]\n", + "mon.pause()\n", + "simulate(100)\n", + "\n", + "### In this part we demonstrate starting single monitors\n", + "### start only monitor for my_pop1 and simulate for 100 ms [300, 400]\n", + "mon.start(compartment_list=[\"my_pop1\"])\n", + "simulate(100)\n", + "\n", + "### start all monitors and simulate for 100 ms [400, 500]\n", + "mon.start()\n", + "simulate(100)\n", + "\n", + "### In this part we demonstrate pausing single monitors\n", + "### pause monitor for my_pop1 and simulate for 100 ms [500, 600]\n", + "mon.pause(compartment_list=[\"my_pop1\"])\n", + "simulate(100)\n", + "\n", + "### start all monitors and simulate for 100 ms [600, 700]\n", + "mon.start()\n", + "simulate(100)\n", + "\n", + "### In this part we demonstrate chunking recordings by reset\n", + "### reset WITHOUT model, creating new chunk --> first chunk [0, 700]\n", + "### also in this chunk do not record the first 100 ms\n", + "### WITHOUT model --> time continues at 700 ms [700, 800]\n", + "mon.reset(model=False)\n", + "mon.pause()\n", + "simulate(100)\n", + "\n", + "### start all monitors and simulate for 700 ms [800, 1500]\n", + "mon.start()\n", + "simulate(700)\n", + "\n", + "### reset WITH model, creating new chunk --> second chunk [700, 1500]\n", + "### in third chunk time is reset to 0 ms\n", + "### also in this chunk do not record the first 100 ms [0, 100]\n", + "mon.reset(model=True)\n", + "mon.pause()\n", + "simulate(100)\n", + "\n", + "### start all monitors and simulate for 700 ms [100, 800]\n", + "mon.start()\n", + "simulate(700)\n", + "\n", + "### Next we demonstrate getting recordings DURING SIMULATION by using\n", + "### get_recordings_and_clear\n", + "### this also resets the monitors back to their initialized state, i.e. there are no\n", + "### recordings and they are not started yet\n", + "### recordings1 consists of 3 chunks, third chunk [0, 800]\n", + "recordings1, recording_times1 = mon.get_recordings_and_clear()\n", + "\n", + "### Now continue simulation, creating NEW RECORDINGS, monitors are not started yet\n", + "### model was not reset, so time continues at 800 ms\n", + "### simulate for 100 ms [800, 900]\n", + "simulate(100)\n", + "\n", + "### start all monitors and simulate for 100 ms [900, 1000]\n", + "mon.start()\n", + "simulate(100)\n", + "\n", + "### reset monitors and model, creating new chunk --> first chunk [800, 1000]\n", + "### simulate for 100 ms [0, 100]\n", + "mon.reset(model=True)\n", + "simulate(100)\n", + "\n", + "### get recordings using get_recordings_and_clear\n", + "### this time directly start recording again\n", + "### recordings2 consists of 2 chunks, second chunk [0, 100]\n", + "recordings2, recording_times2 = mon.get_recordings_and_clear()\n", + "\n", + "### Now continue simulation, creating NEW RECORDINGS\n", + "### directly start monitors and reset model so time is reset to 0 ms\n", + "### simulate for 100 ms [0, 100]\n", + "mon.start()\n", + "mon.reset(model=True)\n", + "simulate(100)\n", + "\n", + "### get recordings the normal way (simultions are finished)\n", + "### recordings3 consists of 1 chunk [0, 100]\n", + "recordings3 = mon.get_recordings()\n", + "recording_times3 = mon.get_recording_times()\n", + "\n", + "### print the idx and time lims of the recordings and the sizes of the recorded\n", + "### arrays\n", + "print(\"#################### ALL RECORDINGS INFO ####################\")\n", + "recordings_list = [recordings1, recordings2, recordings3]\n", + "for all_times_idx, all_times in enumerate(\n", + " [recording_times1.all(), recording_times2.all(), recording_times3.all()]\n", + "):\n", + " print(f\"recordings{all_times_idx+1}\")\n", + " for chunk in range(len(all_times)):\n", + " print(f\"\\tchunk: {chunk}\")\n", + " for pop_name in [\"my_pop1\", \"my_pop2\"]:\n", + " print(f\"\\t\\tpop_name: {pop_name}\")\n", + " print(\n", + " f\"\\t\\trecording_array_size: {recordings_list[all_times_idx][chunk][f'{pop_name};v'].shape}\"\n", + " )\n", + " for time_point in [\"start\", \"stop\"]:\n", + " print(f\"\\t\\t\\ttime_point: {time_point}\")\n", + " for unit in [\"ms\", \"idx\"]:\n", + " print(f\"\\t\\t\\t\\tunit: {unit}\")\n", + " for period in range(\n", + " len(all_times[chunk][pop_name][time_point][unit])\n", + " ):\n", + " print(\n", + " f\"\\t\\t\\t\\t\\tperiod {period}: {all_times[chunk][pop_name][time_point][unit][period]}\"\n", + " )\n", + "print(\"#############################################################\")\n", + "\n", + "### plot recordings 1 consisting of 3 chunks\n", + "for chunk in range(len(recordings1)):\n", + " ### using plot_recordings which plots the recordings of one chunk\n", + " PlotRecordings(\n", + " figname=f\"monitor_recordings_1_chunk{chunk}.png\",\n", + " recordings=recordings1,\n", + " recording_times=recording_times1,\n", + " shape=(2, 2),\n", + " plan={\n", + " \"position\": [1, 2, 3],\n", + " \"compartment\": [\"my_pop1\", \"my_pop2\", \"my_pop1\"],\n", + " \"variable\": [\"v\", \"v\", \"spike\"],\n", + " \"format\": [\"line\", \"line\", \"raster\"],\n", + " },\n", + " chunk=chunk,\n", + " )\n", + "\n", + "### plot recordings 2 consisting of 2 chunks\n", + "for chunk in range(len(recordings2)):\n", + " ### using plot_recordings which plots the recordings of one chunk\n", + " PlotRecordings(\n", + " figname=f\"monitor_recordings_2_chunk{chunk}.png\",\n", + " recordings=recordings2,\n", + " recording_times=recording_times2,\n", + " shape=(2, 2),\n", + " plan={\n", + " \"position\": [1, 2, 3],\n", + " \"compartment\": [\"my_pop1\", \"my_pop2\", \"my_pop1\"],\n", + " \"variable\": [\"v\", \"v\", \"spike\"],\n", + " \"format\": [\"line\", \"line\", \"raster\"],\n", + " },\n", + " chunk=chunk,\n", + " )\n", + "\n", + "### plot recordings 3 consisting of 1 chunk\n", + "for chunk in range(len(recordings3)):\n", + " ### using plot_recordings which plots the recordings of one chunk\n", + " PlotRecordings(\n", + " figname=f\"monitor_recordings_3_chunk{chunk}.png\",\n", + " recordings=recordings3,\n", + " recording_times=recording_times3,\n", + " shape=(2, 2),\n", + " plan={\n", + " \"position\": [1, 2, 3],\n", + " \"compartment\": [\"my_pop1\", \"my_pop2\", \"my_pop1\"],\n", + " \"variable\": [\"v\", \"v\", \"spike\"],\n", + " \"format\": [\"line\", \"line\", \"raster\"],\n", + " },\n", + " chunk=chunk,\n", + " )\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Jt0QyXKIoqid", + "outputId": "46400287-5b52-4b8f-c21c-193b8477d417" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Compiling ... OK \n", + "#################### ALL RECORDINGS INFO ####################\n", + "recordings1\n", + "\tchunk: 0\n", + "\t\tpop_name: my_pop1\n", + "\t\trecording_array_size: (200, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 100.0\n", + "\t\t\t\t\tperiod 1: 300.0\n", + "\t\t\t\t\tperiod 2: 600.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\t\t\tperiod 1: 50\n", + "\t\t\t\t\tperiod 2: 150\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 198.0\n", + "\t\t\t\t\tperiod 1: 498.0\n", + "\t\t\t\t\tperiod 2: 698.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 49\n", + "\t\t\t\t\tperiod 1: 149\n", + "\t\t\t\t\tperiod 2: 199\n", + "\t\tpop_name: my_pop2\n", + "\t\trecording_array_size: (4000, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 100.0\n", + "\t\t\t\t\tperiod 1: 400.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\t\t\tperiod 1: 1000\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 199.9\n", + "\t\t\t\t\tperiod 1: 699.9\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 999\n", + "\t\t\t\t\tperiod 1: 3999\n", + "\tchunk: 1\n", + "\t\tpop_name: my_pop1\n", + "\t\trecording_array_size: (350, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 800.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 1498.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 349\n", + "\t\tpop_name: my_pop2\n", + "\t\trecording_array_size: (7000, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 800.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 1499.9\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 6999\n", + "\tchunk: 2\n", + "\t\tpop_name: my_pop1\n", + "\t\trecording_array_size: (350, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 100.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 798.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 349\n", + "\t\tpop_name: my_pop2\n", + "\t\trecording_array_size: (7000, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 100.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 799.9\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 6999\n", + "recordings2\n", + "\tchunk: 0\n", + "\t\tpop_name: my_pop1\n", + "\t\trecording_array_size: (50, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 900.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 998.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 49\n", + "\t\tpop_name: my_pop2\n", + "\t\trecording_array_size: (1000, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 900.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 999.9\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 999\n", + "\tchunk: 1\n", + "\t\tpop_name: my_pop1\n", + "\t\trecording_array_size: (50, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 0.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 98.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 49\n", + "\t\tpop_name: my_pop2\n", + "\t\trecording_array_size: (1000, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 0.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 99.9\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 999\n", + "recordings3\n", + "\tchunk: 0\n", + "\t\tpop_name: my_pop1\n", + "\t\trecording_array_size: (50, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 0.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 98.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 49\n", + "\t\tpop_name: my_pop2\n", + "\t\trecording_array_size: (1000, 1)\n", + "\t\t\ttime_point: start\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 0.0\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 0\n", + "\t\t\ttime_point: stop\n", + "\t\t\t\tunit: ms\n", + "\t\t\t\t\tperiod 0: 99.9\n", + "\t\t\t\tunit: idx\n", + "\t\t\t\t\tperiod 0: 999\n", + "#############################################################\n", + "Generate fig monitor_recordings_1_chunk0.png... \n", + " WARNING PlotRecordings: my_pop1 does not contain any spikes in the given time interval.\n", + "Done\n", + "\n", + "Generate fig monitor_recordings_1_chunk1.png... \n", + " WARNING PlotRecordings: my_pop1 does not contain any spikes in the given time interval.\n", + "Done\n", + "\n", + "Generate fig monitor_recordings_1_chunk2.png... \n", + " WARNING PlotRecordings: my_pop1 does not contain any spikes in the given time interval.\n", + "Done\n", + "\n", + "Generate fig monitor_recordings_2_chunk0.png... \n", + " WARNING PlotRecordings: my_pop1 does not contain any spikes in the given time interval.\n", + "Done\n", + "\n", + "Generate fig monitor_recordings_2_chunk1.png... Done\n", + "\n", + "Generate fig monitor_recordings_3_chunk0.png... Done\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Display figures" + ], + "metadata": { + "id": "dk85GsFd5Vw8" + } + }, + { + "cell_type": "code", + "source": [ + "display(Image(filename='monitor_recordings_1_chunk0.png', height=700))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 717 + }, + "collapsed": true, + "id": "6buxwMbaqKWP", + "outputId": "e2abcdde-fbba-462e-ece3-529d77d3661e" + }, + "execution_count": 31, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "height": 700 + } + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "display(Image(filename='monitor_recordings_1_chunk1.png', height=700))" + ], + "metadata": { + "id": "QygeB6NLqTJf", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 717 + }, + "outputId": "4377ebbb-1d39-4e87-febf-fd8c83801a71" + }, + "execution_count": 32, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "image/png": { + "height": 700 + } + } + } + ] + } + ] +} \ No newline at end of file From d3550c3c106b489ad5770f1f94fa3339fc2c0193 Mon Sep 17 00:00:00 2001 From: Oliver Maith <73993227+Olimaol@users.noreply.github.com> Date: Mon, 17 Jun 2024 13:33:13 +0200 Subject: [PATCH 3/7] updated test_example notebook --- notebooks/test_example.ipynb | 359 ++--------------------------------- 1 file changed, 11 insertions(+), 348 deletions(-) diff --git a/notebooks/test_example.ipynb b/notebooks/test_example.ipynb index dc9d01f..902f823 100644 --- a/notebooks/test_example.ipynb +++ b/notebooks/test_example.ipynb @@ -44,109 +44,11 @@ "!rm -rf ANNarchy" ], "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, "collapsed": true, - "id": "VGC0ujzTm-z3", - "outputId": "047c2bc4-fb92-4026-9b5c-7a77b20f5843" + "id": "VGC0ujzTm-z3" }, "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Requirement already satisfied: CompNeuroPy in /usr/local/lib/python3.10/dist-packages (1.0.1)\n", - "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.12.1)\n", - "Requirement already satisfied: cython in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (3.0.10)\n", - "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (3.7.1)\n", - "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.13.1)\n", - "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.25.2)\n", - "Requirement already satisfied: typingchecker in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.1.11)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (2.0.3)\n", - "Requirement already satisfied: tabulate in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.9.0)\n", - "Requirement already satisfied: deap in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.4.1)\n", - "Requirement already satisfied: screeninfo in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.8.1)\n", - "Requirement already satisfied: cmaes in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.10.0)\n", - "Requirement already satisfied: pip-chill in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (1.0.3)\n", - "Requirement already satisfied: pingouin in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (0.5.4)\n", - "Requirement already satisfied: efel in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (5.6.28)\n", - "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from CompNeuroPy) (4.66.4)\n", - "Requirement already satisfied: neo>=0.5.2 in /usr/local/lib/python3.10/dist-packages (from efel->CompNeuroPy) (0.13.1)\n", - "Requirement already satisfied: pynwb>=2.6.0 in /usr/local/lib/python3.10/dist-packages (from efel->CompNeuroPy) (2.8.0)\n", - "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from efel->CompNeuroPy) (4.12.2)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (1.2.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (4.53.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (1.4.5)\n", - "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (24.1)\n", - "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (9.4.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (3.1.2)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->CompNeuroPy) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->CompNeuroPy) (2023.4)\n", - "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas->CompNeuroPy) (2024.1)\n", - "Requirement already satisfied: seaborn in /usr/local/lib/python3.10/dist-packages (from pingouin->CompNeuroPy) (0.13.1)\n", - "Requirement already satisfied: statsmodels in /usr/local/lib/python3.10/dist-packages (from pingouin->CompNeuroPy) (0.14.2)\n", - "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (from pingouin->CompNeuroPy) (1.2.2)\n", - "Requirement already satisfied: pandas-flavor in /usr/local/lib/python3.10/dist-packages (from pingouin->CompNeuroPy) (0.6.0)\n", - "Requirement already satisfied: mpmath<1.4.0,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->CompNeuroPy) (1.3.0)\n", - "Requirement already satisfied: quantities>=0.14.1 in /usr/local/lib/python3.10/dist-packages (from neo>=0.5.2->efel->CompNeuroPy) (0.15.0)\n", - "Requirement already satisfied: h5py>=2.10 in /usr/local/lib/python3.10/dist-packages (from pynwb>=2.6.0->efel->CompNeuroPy) (3.9.0)\n", - "Requirement already satisfied: hdmf>=3.14.0 in /usr/local/lib/python3.10/dist-packages (from pynwb>=2.6.0->efel->CompNeuroPy) (3.14.1)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->CompNeuroPy) (1.16.0)\n", - "Requirement already satisfied: xarray in /usr/local/lib/python3.10/dist-packages (from pandas-flavor->pingouin->CompNeuroPy) (2023.7.0)\n", - "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->pingouin->CompNeuroPy) (1.4.2)\n", - "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn->pingouin->CompNeuroPy) (3.5.0)\n", - "Requirement already satisfied: patsy>=0.5.6 in /usr/local/lib/python3.10/dist-packages (from statsmodels->pingouin->CompNeuroPy) (0.5.6)\n", - "Requirement already satisfied: jsonschema>=2.6.0 in /usr/local/lib/python3.10/dist-packages (from hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (4.19.2)\n", - "Requirement already satisfied: ruamel-yaml>=0.16 in /usr/local/lib/python3.10/dist-packages (from hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (0.18.6)\n", - "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6.0->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (23.2.0)\n", - "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6.0->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (2023.12.1)\n", - "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6.0->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (0.35.1)\n", - "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema>=2.6.0->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (0.18.1)\n", - "Requirement already satisfied: ruamel.yaml.clib>=0.2.7 in /usr/local/lib/python3.10/dist-packages (from ruamel-yaml>=0.16->hdmf>=3.14.0->pynwb>=2.6.0->efel->CompNeuroPy) (0.2.8)\n", - "Cloning into 'ANNarchy'...\n", - "remote: Enumerating objects: 30590, done.\u001b[K\n", - "remote: Counting objects: 100% (9111/9111), done.\u001b[K\n", - "remote: Compressing objects: 100% (1868/1868), done.\u001b[K\n", - "remote: Total 30590 (delta 7370), reused 8955 (delta 7223), pack-reused 21479\u001b[K\n", - "Receiving objects: 100% (30590/30590), 19.35 MiB | 18.80 MiB/s, done.\n", - "Resolving deltas: 100% (23634/23634), done.\n", - "Branch 'develop' set up to track remote branch 'develop' from 'origin'.\n", - "Switched to a new branch 'develop'\n", - "Processing /content/ANNarchy\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (67.7.2)\n", - "Requirement already satisfied: cython in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (3.0.10)\n", - "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (1.25.2)\n", - "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (1.12.1)\n", - "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (1.13.1)\n", - "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (3.7.1)\n", - "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from ANNarchy==4.8.1) (4.66.4)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (1.2.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (4.53.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (1.4.5)\n", - "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (24.1)\n", - "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (9.4.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (3.1.2)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib->ANNarchy==4.8.1) (2.8.2)\n", - "Requirement already satisfied: mpmath<1.4.0,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy->ANNarchy==4.8.1) (1.3.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.7->matplotlib->ANNarchy==4.8.1) (1.16.0)\n", - "Building wheels for collected packages: ANNarchy\n", - " Building wheel for ANNarchy (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for ANNarchy: filename=ANNarchy-4.8.1-cp310-cp310-linux_x86_64.whl size=2055169 sha256=21c94490fa22f85a8f81e73fb001631c9e16a6855a8e598576486ed321f8b2ca\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-nn2c_iqx/wheels/27/fe/ed/59a29dfb0abcc144a3e2959967c5f106d5da012bb1711593e7\n", - "Successfully built ANNarchy\n", - "Installing collected packages: ANNarchy\n", - "Successfully installed ANNarchy-4.8.1\n" - ] - } - ] + "outputs": [] }, { "cell_type": "markdown", @@ -165,7 +67,7 @@ "metadata": { "id": "bMhApHy-6iJ3" }, - "execution_count": 29, + "execution_count": null, "outputs": [] }, { @@ -376,209 +278,10 @@ "\n" ], "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Jt0QyXKIoqid", - "outputId": "46400287-5b52-4b8f-c21c-193b8477d417" + "id": "Jt0QyXKIoqid" }, "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Compiling ... OK \n", - "#################### ALL RECORDINGS INFO ####################\n", - "recordings1\n", - "\tchunk: 0\n", - "\t\tpop_name: my_pop1\n", - "\t\trecording_array_size: (200, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 100.0\n", - "\t\t\t\t\tperiod 1: 300.0\n", - "\t\t\t\t\tperiod 2: 600.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\t\t\tperiod 1: 50\n", - "\t\t\t\t\tperiod 2: 150\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 198.0\n", - "\t\t\t\t\tperiod 1: 498.0\n", - "\t\t\t\t\tperiod 2: 698.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 49\n", - "\t\t\t\t\tperiod 1: 149\n", - "\t\t\t\t\tperiod 2: 199\n", - "\t\tpop_name: my_pop2\n", - "\t\trecording_array_size: (4000, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 100.0\n", - "\t\t\t\t\tperiod 1: 400.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\t\t\tperiod 1: 1000\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 199.9\n", - "\t\t\t\t\tperiod 1: 699.9\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 999\n", - "\t\t\t\t\tperiod 1: 3999\n", - "\tchunk: 1\n", - "\t\tpop_name: my_pop1\n", - "\t\trecording_array_size: (350, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 800.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 1498.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 349\n", - "\t\tpop_name: my_pop2\n", - "\t\trecording_array_size: (7000, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 800.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 1499.9\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 6999\n", - "\tchunk: 2\n", - "\t\tpop_name: my_pop1\n", - "\t\trecording_array_size: (350, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 100.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 798.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 349\n", - "\t\tpop_name: my_pop2\n", - "\t\trecording_array_size: (7000, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 100.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 799.9\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 6999\n", - "recordings2\n", - "\tchunk: 0\n", - "\t\tpop_name: my_pop1\n", - "\t\trecording_array_size: (50, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 900.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 998.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 49\n", - "\t\tpop_name: my_pop2\n", - "\t\trecording_array_size: (1000, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 900.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 999.9\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 999\n", - "\tchunk: 1\n", - "\t\tpop_name: my_pop1\n", - "\t\trecording_array_size: (50, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 0.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 98.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 49\n", - "\t\tpop_name: my_pop2\n", - "\t\trecording_array_size: (1000, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 0.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 99.9\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 999\n", - "recordings3\n", - "\tchunk: 0\n", - "\t\tpop_name: my_pop1\n", - "\t\trecording_array_size: (50, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 0.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 98.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 49\n", - "\t\tpop_name: my_pop2\n", - "\t\trecording_array_size: (1000, 1)\n", - "\t\t\ttime_point: start\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 0.0\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 0\n", - "\t\t\ttime_point: stop\n", - "\t\t\t\tunit: ms\n", - "\t\t\t\t\tperiod 0: 99.9\n", - "\t\t\t\tunit: idx\n", - "\t\t\t\t\tperiod 0: 999\n", - "#############################################################\n", - "Generate fig monitor_recordings_1_chunk0.png... \n", - " WARNING PlotRecordings: my_pop1 does not contain any spikes in the given time interval.\n", - "Done\n", - "\n", - "Generate fig monitor_recordings_1_chunk1.png... \n", - " WARNING PlotRecordings: my_pop1 does not contain any spikes in the given time interval.\n", - "Done\n", - "\n", - "Generate fig monitor_recordings_1_chunk2.png... \n", - " WARNING PlotRecordings: my_pop1 does not contain any spikes in the given time interval.\n", - "Done\n", - "\n", - "Generate fig monitor_recordings_2_chunk0.png... \n", - " WARNING PlotRecordings: my_pop1 does not contain any spikes in the given time interval.\n", - "Done\n", - "\n", - "Generate fig monitor_recordings_2_chunk1.png... Done\n", - "\n", - "Generate fig monitor_recordings_3_chunk0.png... Done\n", - "\n" - ] - } - ] + "outputs": [] }, { "cell_type": "markdown", @@ -595,31 +298,11 @@ "display(Image(filename='monitor_recordings_1_chunk0.png', height=700))" ], "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 717 - }, "collapsed": true, - "id": "6buxwMbaqKWP", - "outputId": "e2abcdde-fbba-462e-ece3-529d77d3661e" + "id": "6buxwMbaqKWP" }, - "execution_count": 31, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": { - "image/png": { - "height": 700 - } - } - } - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", @@ -627,30 +310,10 @@ "display(Image(filename='monitor_recordings_1_chunk1.png', height=700))" ], "metadata": { - "id": "QygeB6NLqTJf", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 717 - }, - "outputId": "4377ebbb-1d39-4e87-febf-fd8c83801a71" + "id": "QygeB6NLqTJf" }, - "execution_count": 32, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAADwAAAAtACAYAAAClLNZCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAC4jAAAuIwF4pT92AAEAAElEQVR4nOzdd3iUVfow4Ceh9w6CVFERXBsIFlSavQD2uoK9t59tdVVsu669rro2XOuuXVGwoGBDaSIqoIJUAWnSO8l8f/iRZTIB0gvc93XNlZwz7znnmTczk2Seec6kJRKJRAAAAAAAAAAAAAAAAAAAAKVCekkHAAAAAAAAAAAAAAAAAAAA/I8CYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAbBH69u0baWlpWZeWLVuWdEibNHTo0KR409LSYujQoVvN+pRNw4YNiyuuuCL23XffaNKkSVSpUiXlfvTWW2+VdJhAGfTkk08mPZdce+21JR3SJn3//fdRrly5rHgPOOCAkg4JAAAAACBX5FXL1vqUTfKqQFGRVwUA2PqUL+kAAAAAgNJt5syZcdppp3kzA1Akfv/997juuuuy2vXq1Yvrr7++BCPavF122SVOO+20eO655yIi4vPPP48XXnghTjvttBKODAAAAAAAKCnyqlC6ZWRkxMSJE2P8+PExd+7cWLRoUaSnp0edOnWiXr16sfvuu8d2221X0mFulLwqAMDWyScAAwBAMXv00UdTdnY98MADi2y9a6+9NmW9c889t8jWA7Ysc+bMiU6dOklSQyk2bdq0eP311+O6666Lgw46KOrWrZvyu79r164lHeZGXX/99bFgwYKs9g033BC1atXK11zFeS5uu+22qFSpUlb7mmuuiaVLlxbK3AAAAACAvCpQtsirQumTmZkZX3zxRdx8883RpUuXqFatWrRt2zaOPfbYuOCCC+K6666La6+9Ns4999w49thjo3Xr1tGwYcM4++yzY8yYMSUdfgp5VQCArZNPAAYAgGJ2yimnxJVXXhmrVq3K6vvkk09i2rRp0aJFi0JdKyMjI55//vmU/rPOOqtQ1wG2XOeee27MmjUrpb9mzZrRpEmTpCRNROQ7uQTk3kcffRSfffZZjBo1KkaNGhXz588v6ZDybcKECfHUU09ltRs1ahTnn39+rseX5Llo3rx59O3bN/71r39FRMTs2bPj3nvvjZtvvrnYYgAAAACALZm8KlCWyKtC6TFlypS477774vXXX4/Zs2fnaey8efPi6aefjqeffjp69eoVjz/+eGyzzTZFFGnuyasCAGy9FAADAEAxq127dhx77LHx4osvZvUlEol49tlno1+/foW61qBBg1JeyN55551jr732KtR1gC3Tzz//HAMGDEjq23HHHeOpp56K/fbbL9LS0kooMti6XX311TF27NiSDqNQ3HjjjZGRkZHVvuKKK6Jy5cq5Hl/S5+Lqq6+Op556Kus23HfffXHJJZdEvXr1SiwmAAAAANhSyKsCZYW8KpQun376aTzyyCMFnuftt9+Ozz//PAYMGBD77rtvIUSWf/KqAABbr/SSDgAAALZGOe0U/eyzz0YikSjUdZ555plcrQ2Qk7fffjvleemNN96I/fffX5IaKLBvvvkm3njjjax2zZo148ILLyzBiPKudevWcdxxx2W1ly5dGnfeeWcJRgQAAAAAWxZ5VaAskFeFsqFcuXKx5557xuWXXx733ntvPP/88/HSSy/F/fffHyeddFLUqFEjZczvv/8ehx12WIwaNaoEIv6DvCoAwNZNATAAAJSArl27xnbbbZfUN3Xq1BgyZEihrTFv3rx49913k/oqVKgQp512WqGtUZqsT/Svv0ydOrWkQ4Iyb8SIEUntP/3pT7HzzjuXUDTA5tSsWTO6dOkSZ555ZkmHkit33nln0pth/vznP+eYVM+P4jwXF1xwQVL78ccfjyVLlhT5ugAAAACwNZBXLXzyqlD45FWh9EpLS4vu3bvHc889FwsXLoyRI0fG/fffH//3f/8Xp512Wpx88slx+eWXx8svvxzTp0+PK664IqVwf8mSJXHqqafGmjVrSuQ2yKsCAGzdFAADAEAJSEtLy/GF05x2ls6vF154IdauXZvU17Nnz2jQoEGhrQFs2aZPn57UbtOmTQlFAmRXrVq16Ny5c1x22WXx/PPPx4QJE2LRokUxdOjQuPHGG0s6vM2aNm1avP7660l95513Xr7mKulz0aVLl9hxxx2z2kuXLo0nn3yyyNcFAAAAgK2BvCpQFsirQulTvnz5OOOMM2LixInx8ccf56potnbt2nHfffdF//79U4qAf/7553j44YeLMuQcyasCAFC+pAMAAICtVd++faNfv36RkZGR1ffGG2/EkiVLombNmgWev3///il9Z511VoHnBbYeixcvTmpXq1athCIBNvT2229H06ZNo1y5ciUdSr498sgjSX8DdezYMXbZZZc8z1NazsWZZ54Zf/nLX7LaDz/8cFxxxRWRnm7/RQAAAAAoKHlVoLSTV4XSpUOHDvHjjz9G69at8zW+T58+MWrUqHjkkUeS+p977rm48sorCyPEXJNXBQDAX0oAAFBCtt122zjkkEOS+lauXBkvv/xygeceOXJkfP/990l9TZs2TVkPYFNWrVqV1M6+wy1QMlq0aFHiidmCWLduXTz//PNJfccff3y+5iot5yJ7/NOmTYshQ4aUUDQAAAAAsGWRVwVKO3lVKF122WWXfBf/rnfTTTel5CG/++67mDFjRoHmzQt5VQAAInwCMAAAlKizzjorBg4cmNTXv3//OO+88wo0b067VPfp0ydXuyUuXLgwfvzxx5g4cWIsXLgwli1bFlWrVo26detGo0aNolOnTlG3bt0CxZdbK1asiBEjRsTEiRPj999/j3Xr1kWtWrWiW7dusfPOOxfZuitXroyff/45fvzxx5g/f34sWbIkypcvH3Xq1In69evH7rvvHi1btiyy9Te0atWqGD58ePz444+xcOHCqFChQjRp0iR23HHHaN++falLHC5atChGjhwZc+bMiXnz5sXq1aujfv360bBhw+jYsWM0bty4pEPcYmRkZMQ333wTU6ZMiXnz5sXixYujbt260aBBg9hxxx3zteNrWbV27doYMWJEjB8/PhYsWBAREY0aNYr27dvHbrvtlut5lixZEiNHjoyffvopFi1aFNWqVYttttkmOnfuHE2bNi2q8Ld448ePj2+//TZmz54da9asiYYNG0bTpk2jc+fOUb169SJZ8+eff47x48fH3LlzY8GCBVGtWrVo2LBhNGvWLDp16hQVKlQoknU3tGDBghg+fHj88ssvsWTJkqhVq1Y0adIkdttttwInm8u6Dz74IObMmZPUd9xxx5VQNIVju+22iz322CPGjBmT1ffcc89Fjx49SjAqAAAAANhyyKtumryqvCobJ6/6P/KqpZu8aunKqzZo0CD23HPPGD58eFL/5MmTo1mzZsUSg7wqAAAREZEAAABKzJo1axINGjRIRETSZdy4cfmec+XKlYnatWsnzZeWlpb45ZdfNnr8G2+8kTj33HMTO+64Y0os2S9paWmJnXfeOXHPPfckli5dmq8Y+/XrlzLvhoYNG5Y4+uijE5UqVcoxhn79+qXM2adPn6RjWrRoket4MjMzE1988UXimmuuSXTq1ClRvnz5zZ6Hpk2bJi677LLEtGnT8nUOhgwZkjLnkCFDsq7/5ZdfEmeccUaiatWqG42hefPmib/+9a+JZcuWFfr6ebFixYrEvffem9hnn30S5cqV2+R523nnnRP/+Mc/8hVzfhx55JFJ61eoUCExd+7cAs351Vdfpdyuq666qpAi3ryRI0cmTjrppESdOnU2ea6bNGmSOOeccxKTJk3K1bxTpkzZ7P1+c5cpU6YU6m3d3P105syZiQsvvDBRo0aNjca04447Jp577rlNrjN27NjE8ccfv9HnnIhI7LPPPokvvvgiV3F//PHHuXreyqvddtstac6GDRsmVq9eXeB586tFixZJ8fTp0yfrutWrVyfuu+++RKtWrTZ6TqtUqZI49thjE2PHji2UeGbOnJm47LLLEi1bttzk/bRGjRqJ3r175/s5b3O/w4YOHZo4+OCDN/l82L59+8STTz6ZyMzMLIRbniqnx3OXLl2KZK38OO2005Jia9euXZGtVZzn4qabbkpap3r16olVq1YVyVoAAAAAsLWRV5VX3Vi+SF61cMiryqvKqxYdedXSm1fdnOOPPz4lpv/85z/Ftr68KgAAiUQioQAYAABK2JVXXlmoSa8XX3wxZb5u3brleOwDDzyQqFmzZr6TUnXq1Em8/vrreY5xYy/yr1mzJnHRRRcl0tLSNrluYSaqhw4dmmjWrFm+z0H58uUTN9xwQyIjIyNP52BTCbhnnnkmUaVKlVzH0Lx588TgwYMLbf28ePLJJxONGzfO83lr1KhR4tVXX83zenn1+uuvp6x9//33F2jOc889N2XO8ePHF07AmzBv3rzEiSeeuNnHR/ZLhQoVEpdeeulmkyVlLVH9+uuvJ2rVqpXr2I4//viUc5CZmZm45ZZbNvsGi/WXtLS0xN/+9rdcxd62bduksdtuu21i3bp1+T4Xw4YNS4nnuuuuy/d8hWFjiepJkyYldt555zw9j1533XV5fh5db926dYkbb7xxk2/s2djl8MMPz/Mbjjb2O2zdunWJiy66KE/r77fffonJkyfn63ZvSmkuAM7IyEjUr18/KbYLL7ywyNYrznOR03PWBx98UCRrAQAAAMDWSF71f69Jy6sOSSQS8qqFSV5VXnX9RV618MmrJv8OK0151c054ogjUmJ5++23i2VteVUAANZLDwAAoESdddZZKX3PP/98rFu3Ll/z9e/fP1drRESMGTMmlixZkq91IiIWLlwYxx13XPzjH//I9xzrZWRkxHHHHRf//Oc/I5FIFHi+3JoyZUrMmDEj3+PXrVsXt99+e/Tq1SvfP7MNPfbYY3HmmWfGypUrcz1m+vTpcfjhh8d7771X4PVza+3atXH22WfHOeecE7Nnz87z+Dlz5sQJJ5wQt912WxFE9z9HHXVU1K9fP6nv2Wefzfd8K1eujP/+979JfXvttVe0bds233PmxuTJk2PfffeN//73v3l+fKxduzYeeuihOOigg2LhwoVFFGHxeuGFF+K4446LxYsX53rMq6++GmeeeWZWO5FIxDnnnBP9+vWLjIyMXM2RSCTir3/9azzyyCObPfaiiy5Kas+cOTPeeeedXMeb3WOPPZbUTk9Pj3PPPTff8xWVKVOmROfOnWPcuHG5HrNu3bq44447om/fvpGZmZmn9VasWBFHH3103HbbbbFixYq8hhsDBw6MffbZJ7777rs8j91QIpGIU089Nf75z3/madwXX3wRXbp0icmTJxdo/bJk5MiRMX/+/KS+rl27lkwwhWyfffaJypUrJ/UNGjSohKIBAAAAgC2PvOof5FX/IK9auORV5VXXk1ctHvKqZSOvOmnSpJS+xo0bF8va8qoAAKxXvqQDAACArV3btm1jn332ia+++iqrb86cOTFw4MDo2bNnnuaaPn16fPLJJ0l9tWvXjmOPPTZX49u0aRO77bZbtG3bNho3bhw1atSIihUrxtKlS2P69OkxZsyY+PDDD5OSqIlEIq6//vrYZZdd4ogjjshTvBu66aabkpI4devWjcMOOyw6duwYDRs2jJUrV8avv/4agwYNirS0tHyvsznbbLNNdOjQIdq2bRstW7aMmjVrRtWqVWP58uUxd+7c+P777+P999+PuXPnJo1799134/rrr4+77ror32t//fXXccMNN2S1y5cvH927d48DDzwwtt1221i9enVMmzYt3nnnnRgzZkzS2DVr1sSxxx4bQ4cOjb333jvfMeRGZmZm9O7dOwYOHJhyXZMmTaJHjx6xxx57RP369aNy5crx+++/x5gxY2LQoEExffr0rGMTiUTcdNNNUb9+/bjggguKJNYKFSrEaaedFg888EBW39ixY2PMmDGxxx575Hm+N998MyU5esYZZxQ0zE2aO3du7Lfffjm+IaBp06ZxzDHHRNu2baNu3boxd+7cGDt2bLz55puxYMGCpGM///zzOPDAA2PYsGFRqVKllLkqVqwYu+22W1Lf+PHjY+3atVntOnXqRPPmzTcaa8WKFfN68/Js1KhRcf3112cl7GvXrh2HH3547L333lnPFRMmTIhXXnklpk6dmjT2pZdeit69e8fxxx8ff//73+Ppp5/Ouq5FixZx5JFHxp/+9KeoV69eLFq0KEaMGBGvvPJKyht6rr322jjyyCOjZcuWG43z9NNPj+uuuy6WLl2a1ffYY4/F0UcfnefbvGDBgnj11VeT+g477LBNrl8S1q5dG8ccc0zMmTMnq2/HHXeMY445Jlq3bh3Vq1eP3377LT7//PMYOHBgrFq1Kmn8888/H3Xq1IkHH3wwV+tlZmZGr169YvDgwSnX1ahRI4466qjo1KlTbLPNNrFkyZKYOHFivPnmmylJ2lmzZsUBBxwQo0ePjtatW+fjlkfce++9SW9iqVGjRvTq1Ss6duwYjRo1ikWLFsWPP/4Yr7/+esqbo2bMmBHdu3ePb7/9NmrXrp2v9cuSTz/9NKVvzz33LIFICl+lSpVil112iZEjR2b1DR06tOQCAgAAAIAtjLzqH+RV5VWLgrzq/8iryqsWNXnVspFXHTduXPz0009JfVWqVImdd965yNeOkFcFAGADxf+hwwAAQHZPPfVUIiKSLr169crzPDfffHPKPBdccMFGj+/bt29in332STzxxBOJGTNm5GqNpUuXJm6++eZExYoVk9Zp0KBBYsWKFbmao1+/filxlitXLuvrjTfemFi2bNlGx69cuTKlr0+fPknztWjRIlex9O/fP7Hddtslbr/99sTYsWNzNWbdunWJF154IbHNNtskrZmWlpYYMWJEruYYMmRIyjmoXLly1vf77LNP4scff9zo+IEDBya23XbblDl22mmnxKpVq/K1/pAhQ3IV+0033ZQytmnTpolXXnklsW7duo2OW7t2beLJJ59MVK9ePWlsxYoVE6NHj87V2vkxduzYlHgvueSSfM114IEHJs1TpUqVxKJFiwo54v/JzMxMHHbYYSnxV6lSJXHfffclMjIychy3YsWKxDXXXJNIT09PGXv55Zfnev0WLVokje3Tp08h3bLcyel+WqlSpaSf48KFC3Mcu2rVqsRFF12UMr5NmzaJ4cOHZ52bqlWrJh577LGN3ndnz56d2HfffVPmOffcczcb/8UXX5zyHDFx4sQ8n4d77rknZf133303z/MUtuz3jw2fw2rXrp149tlnNzp25syZiSOPPDLldqWlpeX6ueiOO+5IGR8RiXPOOWeTj8tnnnkmUbt27ZRxnTp1Sqxdu3az6+b0O2zD237GGWds9H6ZkZGRuOeee5KOX3/p27dvrm53bkyZMiVl/i5duhTa/AVx3HHHJcVVo0aNRGZmZpGtV9zn4uyzz05aq3z58rn++wgAAAAA2Dx5VXlVeVV51ZzIq8qrJhLyqhsjr5o/l1xyScraPXv2LJa1Ewl5VQAA/kcBMAAAlAJLly5NSd6VL18+MWfOnFzPkZmZmWjVqlXKi7GjRo3a6JiCJNg++uijRPny5ZPW+te//pWrsTm9yB8RifT09MQrr7ySr3jym6hesmRJvl8gnzZtWqJ58+ZJ65588sm5GptTAm79pWvXrjkm47P75ZdfEk2aNEkZf+utt+Zr/dwkh4YNG5aS/Nxnn33ydF/69ttvEzVr1kya47DDDsv1+Pxo37590nr16tVLrF69Ok9zTJ8+PeW2n3rqqUUU8R9efPHFHBNigwcPztX4f/3rXzkmAkeOHJmr8aUxUb3+8uCDD+ZqjkMOOSRlbMOGDRMRkahevXri66+/3uwcv//+e6JBgwZJc9SsWXOzyacJEyakrH3VVVflKu71MjMzE9tvv33K89vG3qRQnLLfPzZMPObmTTsZGRmJk08+OWX8DjvssNnbN2XKlESFChVSxt5+++25in3kyJEpz0MRkbjnnns2O3Zjv8MiIvGXv/wlV+sPGDAg5XdoRCQ+/fTTXI3fnNJcANyyZcukuPbee+8iXa+4z8WDDz6Yst6wYcOKbD0AAAAA2NrIq8qryqvKq+ZEXlVeVV41Z/Kq+fPjjz+mbOAREYkBAwYU6bobklcFAGC99AAAAEpc9erV44QTTkjqW7duXTz//PO5nmPIkCExZcqUpL7ddtstOnTosNExtWrVylugGzjwwAPj8ssvT+p76qmn8j1fRMQVV1wRxx9/fIHmyKsaNWpEWlpavsY2b948Hn300aS+V199NRYvXpzveOrVqxevvfZaVK5cebPHbrfddvHiiy+m9D/66KOxdu3afMewKbfffntkZmZmtZs0aRIDBw7M031pt912SzlvgwYNirFjxxZanNmdeeaZSe0FCxbEgAED8jTHv//976TbHhFxxhlnFDi2TbnvvvtS+u66667o0aNHrsafe+65cf755yf1JRKJHOctS0455ZS49NJLc3XsbbfdltI3d+7ciIh48MEHY6+99trsHHXq1Ikrr7wyqW/JkiUxbNiwTY7baaedUn5W/fv3j9WrV292zfUGDx4ckyZNSuo777zzIj299L6k8/DDD0fHjh03e1x6eno8++yzseOOOyb1T5w4MQYOHLjJsY888kjK89wxxxwTf/3rX3MV45577hlPPPFESv9DDz0UGRkZuZoju65du8Ydd9yRq2OPPPLIuOGGG3Jcf0u2Zs2amDZtWlJfixYtSiiaopHT7fn5559LIBIAAAAA2DLJq/5BXlVetajIq/6PvKq8alGTV928ksirrl27Nv785z/HmjVrkvr322+/OPLII4ts3Q3JqwIAsKHS+18NQESsXr06vv766+jfv3/cd9998be//S0efvjh+O9//xsTJ06MRCJR0iEWqeXLl8cnn3wSjz/+eNxxxx1xxx13xKOPPhqDBg2KGTNmlHR4ABSys846K6Wvf//+uR7/zDPP5GrOwnT66acntceMGRMrVqzI11w1atSIm2++uRCiKl6HHXZY1K9fP6u9bt26GD58eL7nu/nmm6NevXq5Pr5r165x7LHHJvX99ttv8fbbb+c7ho354YcfUpJHf//736N27dp5nuuUU06JHXbYIanvrbfeKkB0m1+vUqVKSX15eXxFRDz77LNJ7ZYtW0b37t0LGtpGff311zF69Oikvl122SUuuuiiPM1zxx13RJ06dZL6XnvttZgzZ06BYywJ5cqVy3UyMCKiY8eO0bx585T+Nm3a5OmNBscdd1xK3zfffLPZcRdffHFSe8GCBfHKK6/ket3HHnssqV2hQoUif24viD333DPld8OmVKxYMe69996U/scff3yjY1atWhVPP/10yjx5TfKeeOKJ0bVr16S+6dOn5/v5M6/rX3vttdG0adOkvrfffjtmz56dr/XLgmnTpqX8H7/tttuWUDRFI/vPNCJi6tSpxR8IAAAAAGzB5FXlVSPkVYuKvKq8anbyqkVDXjX3ijuveuWVV8bIkSOT+ipXrhz/+te/imS9nMirAgCwIQXAUEAzZ86MN998M/7yl79E9+7do2bNmpGWlpZ1admyZUmHWCaNHj06TjvttKhVq1bss88+ceaZZ8aVV14ZN9xwQ1x66aVx0kknxY477hjNmjWLfv36xe+//17SIReqzz//PI4++uioW7du9OjRIy644IK4/vrr4/rrr4+LLrooDj/88GjevHk0bdo0zjrrrBg/fnxJh5wiIyMjxo4dG0888UScffbZseuuu0a5cuWSHh9lMRkBUJT23Xff2GmnnZL6xo0bFyNGjNjs2CVLlsQbb7yR1FepUqU49dRTCzXG7LInGtetWxejRo3K11wnnnhiVK9evTDCKlbp6enRunXrpL6vv/46X3NVrlw5/vznP+d53LnnnpvSN2jQoHzFsCmvvfZaUrtGjRpx4okn5muutLS0OOyww5L6hg4dmt/QNqtOnTrRq1evpL4PPvggfvvtt1yN//zzz+OXX35J6uvTp0++dznPjY8++iilLz87FNeuXTtOPvnkpL61a9cW6fkuSgceeGCOiedN2X333VP6zjjjjDz9/Fq3bh01a9ZM6vvpp582O+6oo45K2bl2U0nYDc2aNStlR/VjjjkmGjZsmKvxJeHss8/O8+Pi8MMPT0nuffzxxxvdcX/kyJGxaNGipL6ePXvmK+F54YUXpvTl9NjbnL333jt22WWXPI3J6Tl/3bp1MXjw4DyvX1b8+uuvKX3bbLNNCURSdBo3bpzSZwMvAAAAAChc8qryqvKqQ/Mb2mbJq8qrZievWjTkVXOvOPOqjz/+eDz88MMp/XfffXe0a9eu0NfbGHlVAAA2VL6kA4Cy6Msvv4x77703hg8fHrNmzSrpcLYomZmZcf3118fdd98dmZmZmz1+5syZceutt8a//vWvePbZZ+PQQw8thiiLzuLFi+PCCy+Ml156KVfHz5w5M5555pno2LFjsb64sCl33XVXDBgwIL755pt871QKsDU766yz4uqrr07q69+/f3Tq1GmT415++eVYuXJlUl/v3r2jbt26eVo/IyMjvvrqq/j222/j+++/j9mzZ8fSpUtj6dKlsW7dulzNMX369DytuV63bt3yNa4o/PDDDzFy5Mj47rvvYtq0abFkyZJYunRprF69OsfjJ02alNTO7zno2rVr1KpVK8/jDjzwwKhZs2YsWbIkqy+/yfJN+fTTT5Pa7du3j8qVK+d7vlatWiW1x4wZk++5cuPMM89M2iF43bp18fzzz6c85nKSfVfrtLS06Nu3b2GHmOTLL79M6cu+K3lunXDCCfHoo4+mzJ/fNxqUpAMOOCDPY7IniiMi9t9//3zN8/3332e1sydLc1KuXLk4//zz47rrrsvqGzZsWHz33Xex6667bnLsk08+mfLce8EFF+Qt6GLWu3fvPI9JT0+PXr16xT//+c+svlWrVsW3334bHTt2TDk+p8dGTjuJ50avXr2iUqVKSc/vOc2/Ofm53RF/vPEg+87rX3/9db7etFQWbPh7ar1q1aqVQCRFp2rVqil9S5cuLYFIAAAAAGDLJq9aOsir5kxe9X/kVUuOvKq8qrxq3rzzzjspn0QdEXHqqafm2F+U5FUBANiQAmDIh5EjR8abb75Z0mFskc4777x46qmnUvqrVq0arVu3jipVqsSCBQti8uTJkUgksq6fM2dO9OrVK956662UHQ/LipkzZ8bBBx+c46f5NmrUKBo1ahSVKlWKhQsXxtSpU3OdLChuL730UowdO7akwwAos04//fS4/vrrk3bn/M9//hP333//JhOC2ZNoEX8kvXPrt99+i3/84x/xn//8J+bMmZO3oLPJTeImJ+3bty/QugW1evXqePjhh6N///45/j7Oi/yegw4dOuRrXHp6euy2227x+eefZ/VNmDAhVqxYkeML5vmRkZGRkvz+7rvvctwBOLd+//33pPbixYtj7dq1UaFChXzPuSkHHXRQNG3aNGmn1GeffXazierly5fHq6++mtTXrVu3aNmyZVGEmeWbb75Jajdt2jTfO7p26NAh0tPTkzbZyT5/WbH99tvneUyNGjWKZJ7FixfnatzZZ58dt9xyS6xatSqr77HHHovHHntso2MyMjLiySefTOpr165ddOnSJQ8RF69tt902GjVqlK+xOf0OGD16dI6J6pzuu3vuuWe+1q1YsWLsuuuuMXLkyKy+cePGxerVq6NSpUq5nie/z9+77LJLlC9fPun/u9GjR+drrrIgp02iqlSpUgKRFJ2cbs/y5ctLIBIAAAAA2LLJq5YcedVNk1eVVy0t5FXlVeVVc++TTz6JE088MTIyMpL6DzzwwHj66acLbZ3cklcFAGBD6SUdAGxpqlevXtIhlFmvvfZaSvFvu3bt4r333ovFixfHd999F8OHD49JkybFnDlz4pZbbomKFStmHbtmzZro06dPLFy4sLhDL7AlS5bEoYcemvSieJ06deLOO++MyZMnx2+//RZjx46NESNGxMSJE2P58uXx9ddfx0033RStW7cuwchzLz09fYt7AQKgKDRs2DCOPPLIpL5FixbFG2+8sdEx48ePj+HDhyf1tWjRInr06JGrNZ944olo06ZNPPjggwVOUkfkPnGTXcOGDQu8dn59+eWXsfPOO8fVV19d4CR1RP7PQZs2bfK95k477ZTUTiQSMX/+/HzPl92CBQuSkmwREQsXLoyxY8fm+zJjxoyUdbInrwtTenp6nH766Ul948ePjxEjRmxy3GuvvRbLli1L6jvjjDMKPb4NJRKJWLBgQVJf27Zt8z1f9erVo1mzZkl9hXn/KE516tTJ85ic3vxQGPNs+KaiTalfv37KruAvvPDCJnevfeedd2LmzJlJfeeff34uIy0ZhfkcFhExd+7cHI/Nft+tWLFigf4vateuXVI7MzMzz/9X5ve2V6pUKWXX/o3d7i1B9oR5xB+7uW9JypdP3W+xtG7gBQAAAABlmbxqyZBX3Tx5VXnV0kJetfSSV827osyrDhs2LHr16pXy3L3ffvvFW2+9lacC58IirwoAwIYUAEMB1KhRI7p27RpXX311vPrqqzF16tQYMGBASYdVZt1yyy1J7T333DNGjBgRhx9+eMo/eg0aNIibbropBg0alHTdvHnz4vHHHy+WeAvT//3f/8UPP/yQ1e7SpUtMnDgxrrnmmpQXLSL+eCFmr732iltuuSUmTpwYJ510UnGGmystWrSI4447Lu68884YMmRILFq0KE444YSSDgugTMhph+lnnnlmo8fndN0ZZ5wR6emb/3P/rrvuivPOOy+WLFmStyA3IbeJm+xq1qxZaDHkxZAhQ+Lggw+OX375pdDmzO85qFWrVr7XzGlsfnfMzkn2pGlRWblyZZHOn1OC+dlnn93kmOzX16xZM4499thCjCrVkiVLknaVjoioXbt2gebMnpgtyjcFFKXC2sm8qHZE35iLLrooqb1s2bJ48cUXN3p89v9rqlatmvJGi9KmuJ7DsieRC7JuRM5vWsjr46Mwb3thPneXNjltCpU9kV7W5fR7rLA+NQIAAAAASCavWrzkVXNHXvV/5FVLlrxq6SWvmj9FkVcdOXJkHHbYYSmbF3Tq1Cnee++9qFatWoHXyA95VQAANqQAGPLhqKOOinHjxsWiRYtiyJAhcdddd8Vxxx0XLVq0KOnQyqzJkycnFcBGRDz66KOb/ee5e/fuKS/ml7Ui7KFDhyYlGDp27BgDBw6MevXq5Wp8WlpagV+0LEyPPfZYzJkzJ6ZOnRqvvvpqXHPNNdG1a9eoUaNGSYcGUGYceuih0aRJk6S+Tz75JKZNm5Zy7Lp16+KFF15I6ktPT4++fftudp0vvvgirr322pT+atWqxSmnnBKPPvpoDB06NCZNmhQLFy6MFStWRGZmZiQSiaRLYclpZ8eitnDhwjjxxBNjxYoVSf3p6elx8MEHxx133BHvv/9+jBs3LubPnx/Lli2LjIyMlHPQpUuXQomnIImDnMZuahfcvMrrrq2l1fbbbx/7779/Ut/LL7+80UTJlClT4tNPP03qO+mkk3JMthSmnH52BU0sZR9fmPcPNq9jx47RqVOnpL7HHnssx2MnTZoUH330UVLfKaecUuCEbFErruew7P2F/djY1Np5mSO/Y7fkx2ZO56mo36BU3HK6PSX1xgAAAAAA2NLJqxYfedXck1f9H3lV8kNeNe9j5VXzZ8yYMXHIIYekbO7Rvn37+OCDD0psw40IeVUAAJIpAIZ8aN26dbRr1y5Xuz+SOz/99FNSu2nTptGxY8dcjc2+S+CkSZMKLa7i8H//939ZL/KXL18+nnrqqTK9i9U+++wTDRs2LOkwAMq0cuXKpSSaE4lEjrvpvvfeezFnzpykvh49euRqY5Irrrgipa9v377x66+/xosvvhgXXHBBdOnSJVq3bh21a9eOKlWqRFpaWtLxZf3F5b///e8xb968pL4999wzfvzxx/jggw/iL3/5SxxyyCHRrl27qFevXlSrVi3HvwEL6zwsX768UMcW5gYcOSVmTzzxxJSkfUEvLVu2LLSYNyb7btWLFi2Kt956K8djn3322ZQ3ZOS023Vhy+lnV5D7R07jbdBS/C6++OKk9nfffRfDhg1LOe5f//pXyv3u/PPPL9LYCkNxPYdl7y/sx8am1s7LHPkduyU/NnP6X7Gs7pq/MTndHv8jAwAAAEDRkFctPvKquSevuvHxRUFedcskr5q3sfKqeTd27Ng48MADUzZt2G233eKjjz4q8Q/lkVcFAGBDqhehjFmxYkV89NFH8eyzz8Zdd90V9957bzz//PMxevToQt0psrhl/0euWbNmuR7bvHnzpPaiRYsKI6RiMXLkyBgzZkxWu3fv3rHrrrsWaww//fRTvPLKK/HPf/4z/v73v8fjjz8e77zzzhb3YgFAWXPmmWemJIX//e9/p/y+3/BT5Nc766yzNjv/pEmTYtSoUUl9Rx11VPTv3z9PL2KX9d8X//nPf5LazZo1i8GDB8cOO+yQp3kK6zwsXry4UMcWZkKifv36KX1l9ed/wgknRPXq1ZP6cnojSCKRiOeeey6pr23btrH33nsXZXgREVGzZs2UN0UU9O/c7OPr1q1boPnIuxNOOCEaNGiQ1Jd9t+rVq1dH//79k/o6duwYHTp0KPL4Cqq4nsPq1KlTaOtG5PzYyuvjozBve0knk4tSTm+k+/XXX0sgkqKT0+3JzRsIAQAAAID8kVctHvKquSev+gd5VQpCXjVvY+VV8+aHH36IAw88MOW5eZdddonBgweXise8vCoAABtSAAxlxJdffhmHH3541K1bNw4++OA444wz4tprr42rrroqTj/99Nhzzz1jm222iZtuuimWLl1a0uHmWa1atZLaedntMfuxOb2IWlo9/fTTSe3TTjutWNZdtmxZ3HLLLbHddtvFTjvtFCeeeGJcfPHF8de//jUuuOCC6NWrVzRs2DC6desWn3/+ebHEBECy1q1bR5cuXZL6pkyZEkOGDMlqz5kzJwYOHJh0TN26daN3796bnf+jjz5K6bvpppvyHOfkyZPzPKa0mDBhQsqLyZdeemnK3yWbs3bt2kJ7kf3nn3/O99iffvopqZ2Wllaofxc1aNAg5c0T06ZNK7T5i1O1atXi+OOPT+r76KOPYubMmUl9Q4YMialTpyb1Fccu1RE5//wmTJiQ7/mWL18e06dPT+orS383bykqVaoU55xzTlLfa6+9FgsWLMhqv/rqq0ntiIgLLrigWOIrqMJ8DovY+O6+2ZP9a9asiV9++SXfa48fPz6pnZ6enuekbn5v+5o1a1KeZ7bkXY3r1asXNWvWTOrb0hLV2X+XRES0atWqBCIBAAAAgK2DvGrRk1fNG3nVP8irUhDyqhsnr/o/+cmrjhs3Lrp37x7z589P6t95553j448/LjWPd3lVAAA2pAAYSrnly5fHCSecEPvtt18MGjQoVq9evdFj586dG7fddlvsuOOOMXLkyGKMsuB23333pPaECRNi+fLluRo7YsSIpHanTp0KK6wi99577yW1u3btWuRrvvvuu9G6deu4+eabY8qUKRs9LiMjI4YOHRoHHHBAnHfeebFu3boijw2AZDntOL3h7qXPP/98yvPzqaeeGpUqVdrs3DNmzEhqV65cOfbcc888x/jVV1/leUxpkf0cRETsv//+eZ5nzJgxsWrVqsIIKUaPHp2vcZmZmfHtt98m9bVt2zaqVq1aCFH9oXLlyrHbbrsl9f38888xZ86cQlujOGVPOGdmZqbsSp199+py5crFn//856IOLUv79u2T2r/++mu+z/fo0aMjMzMzqa8s7Hy8JTr//POjXLlyWe1Vq1YlPbdn37m6Tp06cdJJJxVbfAXx66+/xty5c/M1Nqfnv43dR7M/NiIi5dMXcmvNmjXx3XffJfX96U9/iooVK+Zpnvw+f3/33Xexdu3apL4t/bG56667JrVzepNCWfbjjz+m9GX//QkAAAAAFC551aIlr5o38qryqhQOedWcyav+T14fmxMmTIgePXrEvHnzkvp32mmn+Pjjj1MKpkuavCoAAOspAIZSbO7cudGlS5d49dVXU65r2rRpdOjQIXbfffeoU6dO0nW//fZbdO3aNb744oviCrXAmjZtGvvuu29We/Xq1fHQQw9tdtzq1avjgQceSOrL6UX90ui3335L2pGrZcuWWTtjLlu2LPr37x8HH3xwtGzZMipVqhQNGjSIXXbZJc4///x47733IpFI5HnNJ554Inr37p3y4lHVqlWjbdu20alTp9h+++0jPT09Zdxxxx2XrzUByL9jjz02Zdfk119/PZYsWRIRyUnr9XL7ezD7TpZ53ZFzvVdeeSVf40qD7OcgIn/n4b///W9hhBMRf+yMvHjx4jyPGzx4cNb9Yr299967sMLKctBBB6X0vfHGG4W+TnHYf//9Y4cddkjq2zAxvXTp0nj99deTrj/ssMNim222KY7wIiKS/j5e77XXXsvXXDn9T5HT/BS9Zs2aRc+ePZP6/vWvf0UikYjvvvsuhg0blnRdnz59okqVKsUZYoG89dZbeR6TmZkZb7/9dlJf5cqVUzaKWq8wHxsDBgxIebNRfh4b+bndETk/hxbF83dp0rFjx6T2tGnTUn6HlWVjx45Najds2DCaN29eQtEAAAAAwNZBXrVoyavmnbyqvCoFJ6+aSl41WV6ev3/++efo3r17yuYAbdq0iSFDhkSjRo3yFVdRklcFAGA9BcBQSmVmZsZJJ52UtNtVgwYN4u67747Zs2fHjBkzYtSoUTFmzJiYP39+fPHFF9G9e/esY1esWBEnn3xyLFiwoCTCz5c777wzqfD0pptuin//+98bPX7RokVx3HHHxYQJE7L6jjrqqDjqqKOKNM7Ckv1TmrfbbruI+OOF5jZt2sSZZ54ZH330UUybNi3WrFkT8+fPjx9++CH+9a9/xZFHHhkdO3ZM+fTjTfn444/jggsuiIyMjKy+o446KoYOHRqLFy+O8ePHx/Dhw2PixIkxb968uPPOO6NGjRpZx7799ttx1113FfBWA5AXVapUiVNOOSWpb+XKlfHyyy/H8OHDY/z48UnXdejQIdc7IVarVi2pvXDhwpRdbDfn008/zffOnKVB9nMQkXPyelMWLVoUzzzzTGGFFKtWrYoXXnghz+OefPLJlL7DDjusMEJK0qtXr5S+e+65J2XH9LKib9++Se2ff/45K0n4yiuvxIoVK5KuP/PMM4srtIiIOOSQQ1L6nnjiiTw/VhcvXhwvvfRSUl+FChWiW7duBYqP/Lv44ouT2pMmTYrBgwfH448/nnLs+eefX1xhFYqnnnoqz2MGDRqUtDlSRESPHj2iQoUKOR7fqVOnqF27dlLfgAEDYtasWXle+9FHH03pO/jgg/M8z1dffRXjxo3L05jVq1fH888/n9RXvnz5OPDAA/O8flmSUyI++27hZVn227LXXnuVUCQAAAAAsPWQVy1a8qp5J68qr0rhkFdNJq/6P3nJq06aNCm6desWv/32W1L/DjvsEJ988kmxbliQF/KqAACspwAYSqm77747hgwZktXea6+94ocffoirrroq5Z/N9PT06Ny5c3z00UdJL3j8+uuvceuttxZbzAW13377xSOPPBJpaWkREbFu3bro27dvdOrUKf7xj3/Em2++Ge+//3688MILcckll0Tr1q3j3XffzRp/0EEHxcsvv1xS4efZpEmTkto1a9aMF154IQ4++OBcvcAyevTo6NKlS7z55pubPXbRokVx2mmnZb2omZ6eHk8//XS888470aVLlyhfvnzS8XXr1o1rrrkmvv7662jQoEFW/0033ZTyIggARSunnaf79++fY3I0t7tUR0Q0btw4qb1y5cr4/PPPcz1+xYoVce655+b6+NIo+zmIiPjwww/zNMfFF18cixYtKqSI/nDzzTfHwoULc338Z599lrJD6zbbbJNjUrmgOnfuHF27dk3qmzx5clx55ZWFvlZxOP3005M2oIn43w7w2XeCr1+/fhx55JHFFlvEH8m4PffcM6nvu+++yzGZuSl//etf4/fff0/qO+GEE6Jhw4YFjpH86d69e7Rr1y6p7+677055o0r37t2jTZs2xRlagY0cOTIl+bopa9eujauuuiqlf1MJ+kqVKsXZZ5+d1Ld69eq4/PLLc71uxB+7W3/yySdJfS1atEjZSTy3Lrvssjwdf9ddd6Uk6Hv16pXj76ctSY8ePVKee/PyN0hpNmXKlJSfaU5vOgIAAAAACp+8atGRV807eVV5VQqHvOr/yKvmL686ZcqU6N69e8p7clu3bh1DhgyJJk2a5CmW4iSvCgDAegqAoRRasWJF0ietNm7cOAYOHLjZF5LS09PjgQceSNr16Zlnnin0F0+L0gUXXBCDBw+OnXfeOatv5MiRcd1118UxxxwThx12WPz5z3+ORx55JOvFtu222y4ef/zxeP/993PccbK0yv5zmThxYpx99tmRSCQiIqJp06bxl7/8Jf7zn//EgAED4rHHHosjjjgiacyqVatSPik6J48//nhS4e7f/va3XO202K5du3j22Wez2mvWrIlHHnlks+MAKDw57T49fPjwlCRATrtab8r++++f0vfXv/411q5du9mxK1eujOOPPz5+/vnnXK9XGu2xxx5RvXr1pL4HH3ww5QXmjbn11lvjxRdfLPS45s+fH8cff3ysXr16s8dOnTo1Tj311JT+Cy64YKM7vBbU7bffnrVhy3oPPfRQ9OvXL+vvmLz64Ycf4vTTT89Tgr4wNG3aNGVH2ldeeSXGjh0bX375ZVL/aaedVmTndFP+7//+L6Xvqquuis8++yxX45955pmUnXjT0tLiiiuuKJT4yL+LLrooqf3RRx/F0qVLk/rK2i7V61188cXxzTffbPa4RCIRZ511Vvz4449J/dtvv30cfvjhm10j+2Py1VdfjbvvvjtXMY4ZMyYl2R3xR7K5XLlyuZoju48//jhuuOGGXB07aNCguO2221L6L7300nytXZbUq1cvZffmDTdAK8tyuh2buy8DAAAAAIVDXrXoyKvmj7xq8ZJX3XLJq8qr5jevOmPGjOjevXvMmDEjqX+77baLIUOGxLbbbpu7gEuIvCoAAOspAIZS6LnnnkvaSe7mm2+OunXr5mpsuXLl4rrrrstqL1u2LD744INCj7Eode/ePUaOHBlXXXXVZl8gaN68eVx11VVxyimnpOx0VdplLwAeN25c1gvSffv2jZ9++inuuOOOOPHEE+PII4+M888/P95999345JNPonbt2lnj1qxZEyeffHKsW7cux3UyMjLi4Ycfzmo3b948T7tJHn744bHHHntktV9//fVcjwWgcOS0A/XKlSuT2sccc0zUqlUr13N26tQpWrRokdT35ZdfxjHHHBPz58/f6LiRI0fGAQccEAMHDoyIPz7BvqyqUKFC9O7dO6lv4cKF0aNHj/juu+82Om7WrFlxyimnRL9+/bL6Cus8VK5cOSL+SHb06NFjk28G+OCDD+KAAw5ISazvtNNOcc011xRKPDnp3Llz0m1f79Zbb43u3bvnerfRBQsWxFNPPRUHHXRQ7LrrrvH8889HRkZGYYe7WWeccUZSe8mSJXHyySenHJebzVOKwsknn5yS5Fi5cmUcfvjh8cgjj0RmZmaO41atWhXXXXddnHPOOSlvILj88sujQ4cORRYzuXP66adv8rljm222SXmOKu3WP4ctWbIkDjzwwJSdtzc0e/bsOProo1PeeJWWlhZPPPHEZv+/a9GiRdx+++0p/ddcc01cdNFFsWTJko2Ofe6556JHjx6xePHipP5OnTrFJZdcssl1N2b9bf/b3/4W55xzTsrc62VmZsYDDzwQxxxzTMqbw/r27RsHHHBAvtYva7Lft7/88suUv23KosGDBye1d9lll2jVqlUJRQMAAAAAWx951aIhr5o/8qrFS151yyWvKq+an7zqrFmzonv37jF16tSk/pYtW8aQIUOiWbNm+Yq/uMmrAgAQEVG+pAMAUq1/4Tcionz58nHSSSflaXyPHj0iPT0960Wrzz//PE488cRCjbEoPf7443HrrbfG7NmzN3vs9OnT48ILL4wbbrgh7r777hJ7ATE/li1blmP/UUcdFc8880zKDpDrdevWLd5+++3o1q1b1s944sSJ8corr+S4Q+nYsWNj1qxZWe2TTjopz7ssHnzwwTFmzJiIiPjxxx9j/vz5Ub9+/TzNAUD+nXrqqXH11VdvcufinJLZm1KuXLno169fyu/Od999N1q2bBnHHnts7L333lG/fv1YtmxZTJ8+PQYNGhQjRoxISno98sgjcfrpp+ftBpUiN954Y/z3v/9NShb8/PPPsccee8Shhx4a3bt3j6ZNm8a6deti9uzZMXTo0Bg8eHDSz+LMM8+MX375JT799NMCx9OvX7+44YYbIiMjI7788svYeeed48ADD4wePXrEtttuG2vWrImpU6fGgAEDYvTo0SnjK1WqFP37989KmBSVm266KX788cf4z3/+k9Q/dOjQOOCAA2LHHXeMrl27xs477xx169aNSpUqxaJFi2LhwoUxfvz4GD16dEyYMKFEEtPZ9erVK+rWrZu0Ac+ECROSjunQoUPssssuxR1alv79+8fuu++e9Pfx8uXL45JLLom77747jjnmmGjbtm3Url075s+fH99++228+eabOb7ppH379nHHHXcUZ/hsRPXq1eP000+PRx55JMfrzz777BLZHb0gjjnmmBg3blyMHTs2Fi5cGH/+85/jb3/7Wxx99NHRunXrqF69evz222/xxRdfxHvvvZdjYvKSSy6Jbt265Wq9q666Kj766KOU5OCjjz4aL774YvTs2TM6duwYjRo1iiVLlsSkSZPijTfeiIkTJ6bMVatWrXjxxRejfPn8vVR26623Zr1J6KmnnopXXnklevfuHR07doyGDRvGokWL4scff4zXX389pk+fnjK+RYsWcf/99+d6vVmzZm1yB+Q1a9ak9I0aNSp23333jY5p0qRJ0usRRemUU06J6667Lut/2hUrVsT7778fRx99dJ7nKi3nYvXq1fHee+8l9ZXlv5EAAAAAoCySVy068qr5I69avORVt0zyqvKqG8ptXrVfv34xadKklP5169ZFz5498xX7eueff36xfeq0vCoAABERkQAK1ZAhQxIRkXVp0aJFnsZnZmYm6tatmzW+Xbt2+YqjQYMGWXN07959o8fdf//9SfEW1aVPnz6bjXnNmjWJY489Nmlc3bp1EzfddFNixIgRiYULFybWrFmTmDVrVuKdd95JHH300Ym0tLSk46+66qpcnZ9atWoVy+2eMmXKRmO48MILU44vX758Yvr06bm6DX379k0a26VLlxyPe+CBB5KOe+WVV3I1/4b++c9/Js3x2Wef5XmORCKR6NOnT9I8/fr1y9c8AFujk046aaO/b7bbbrtEZmZmvuY9+eST8/177q9//WsikUik9Ofm+b1fv34p4woq+++Z3P4d9vjjj+f7HHTv3j2xatWqRJcuXXL1e3lD2f9ujIjEkCFDEo888ki+YqlYsWJiwIABuT5fG1s/tzIyMhJ//etfU/4eK8hl3rx5uV6/MF188cWbjOuRRx4pkbg2NGnSpMT2229foPO73377JX7//fc8rduiRYukOXLzd31hKuj9dL3Ces7Jz2N9UyZMmJDjY6hcuXK5/r+gJOV0/5g8eXKiUaNG+bqPnnbaaYmMjIw8xbB8+fLEkUceWaDHRpMmTRLffvttrtfM6f6UmZmZOOGEE/K1ftOmTRO//PJLnm73lClTCu25d/0lr69fFFSPHj2S1j/11FPzNU9pORcDBgxIeRzPmjUrX7cJAAAAAMg/edXNk1eVV80vedWNk1dNJq+aTF71f5fiyqtm/11XmJfift+rvCoAAOkBlCpz5sxJ2iVv/PjxkZaWlufLvHnzsubYcL7S7IILLojXX389q92pU6cYN25c3HLLLdGxY8eoXbt2VKhQIRo3bhxHHXVUvPHGG/HWW28l7cR4zz33RP/+/Usi/DyrXr16St+hhx4azZo1y9X4c889N6k9fPjwHHfgyr7T4gknnJDn+9NFF12UNEdZuU8BbEk2tRP1mWeeudFPjt+c/v3753mX68qVK8fDDz8ct99+e77WLG3OO++8ePTRR6NixYp5GnfmmWfGwIEDo1KlSoUaz0UXXRRPPvlknnabbtasWbz33ntx5JFHFmosm5Kenh633357DBw4MHbbbbcCzVWrVq04++yzc/z7qDicccYZG72uUqVKccoppxRjNDlr3bp1DBs2LOtvubyoUKFCXHLJJfHRRx9FnTp1iihC8mOnnXaKHj16pPQfccQRuf6/oLRp1apVfP7559G2bdtcjylfvnxce+218eyzz0Z6et5eqqpatWq89dZbccMNN0SVKlXyGm4ceuih8dVXXxX4eSwtLS1efPHFOO+88/I0rnPnzvHpp5/GdtttV6D1y6ILLrggqf3OO+/EsmXLSiiagnvppZeS2j179ozGjRuXUDQAAAAAsPWSVy068qr5I69avORVt0zyqn+QV5VXjZBXBQDYGikAhlJmwYIFhT7n4sWLC33OwjZ06NB4+umns9oNGzaMd999N7bZZptNjuvZs2f885//TOq7+uqrY+XKlUUSZ2HK6YXYLl265Hp8x44dk16IWbVqVXz//fcpx22t9ymALU2PHj2iZcuWKf3p6enRp0+ffM9bqVKleOqpp+K9996Lzp07b/LYWrVqxXnnnRfjxo2Liy++ON9rlkYXXHBBfPPNN3HiiSdGhQoVNnpcxYoV46ijjorPPvssnn766UJPUq939tlnx3fffRd//vOfN5l4adasWVx//fUxfvz4OPDAA4skls059NBD49tvv40BAwbEMcccE3Xr1s3VuO222y7OOeeceO2112L27Nl5Ts4Xpvbt28euu+6a43W9e/cuNcndBg0axH//+98YMWJEnHjiiZuNq3HjxnHOOefEhAkT4qGHHiqx88um7bnnnil92RN4Zc0OO+wQY8aMibvuuiuaN2++0eMqV64cxxxzTIwaNSr+8Y9/RLly5fK1Xrly5eK2226LiRMnxqWXXprj78sNVa9ePXr16hWffPJJDBo0aJMx5kX58uXj8ccfj8GDB0f37t03mXTfY4894sknn4zPP/98q0xSR/zx/NqqVaus9tKlS+Pll18uwYjyb8GCBfHGG28k9f3f//1fCUUDAAAAAFs3edWiJa+af/KqxUdedcskryqvKq/6B3lVAICtT1oikUiUdBCwJRk6dGh069Ytq92iRYuYOnVqrsd/+eWXsd9++xVqTJuKYcSIEfHhhx8W6no52W233eKoo47a6PXHHHNMvPnmm1ntv//973Hdddflau7MzMxo27Zt/Pzzz1l9L7zwQpx66qkbHXPPPffEqlWrcjV/QVxyySVRq1atHK974oknUnYxe/vtt6Nnz565nn+XXXaJH374Ias9cODAOOyww5KOOeigg2Lw4MF5iHrz+vfvH3379s3zuL59+8a///3vrHa/fv3i5ptvLrzAACiwOXPmxJdffhmzZs2KRYsWRaVKlaJRo0bRtm3b2GOPPaJ8+fIlHWKRW758eQwbNiwmT54cv//+e6SlpUXdunVjhx12iI4dOxb7bsorV66M4cOHx48//hi///57VKpUKRo3bhw77LBD7LnnnvnepbyoJBKJ+P777+OXX36JBQsWxIIFCyIzMzNq1KgRtWvXjtatW0fbtm2jdu3aJR1qmZeRkRGjRo2KqVOnxrx582LJkiVRu3btaNiwYey4444bTb5TemRkZESrVq1ixowZWX3bbbddTJo0qdQ9tnPSsmXLmDZtWla7T58+8eyzz6Yc98MPP8TYsWNj1qxZsXbt2mjYsGE0bdo0OnfuHDVq1CiS2H766acYN25czJs3LxYsWBDVqlWLBg0aRPPmzaNTp055/nSCDd18881xyy23JPXl9PLa/Pnz4+uvv45ffvklli1bFjVr1ozGjRvHHnvsEa1bt873+luShx56KC677LKsdocOHWLUqFElGFH+3H///UmJ6Y4dO8aIESNKMCIAAAAAoKjJq8qrFpS8avGRVy375FXlVbd28qoAAFu3Lf9VJihjqlatmtRu165dPPjggwWac1O7G3bq1Ck6depUoPkLKpFIxCeffJLUt6li4ezS09PjiCOOSCoA/uyzzzZZAHzVVVflPdBC1rZt25S+mjVr5mmO7McvXLgw5Zjs96l//OMf0aFDhzytk93OO+9coPEAlF6NGjWKY445pqTDKFHVqlWLgw46qKTDyFKlSpXo2rVrdO3ataRDyZW0tLTYddddJUmLQbly5WKvvfaKvfbaq6RDIZ8GDhyYlKSOiDj33HPLRJI6L/70pz/Fn/70p2Jds02bNtGmTZtiXTO7+vXrx5FHHlmiMZR255xzTtx5550xa9asiIgYPXp0fP7557H//vuXcGS5l5GREQ8//HBSX79+/UooGgAAAACguMiryqsWlLxq8ZFXLfvkVYuOvGrZIK8KALB1UwAMpUz9+vWT2olEIg488MASiqZ4LFy4MBYvXpzU16pVqzzNkf34mTNnFjiuotauXbuUvtWrV+dpjuyfYpy92Dci9T7VqlWrLf4+BQAAZUH25FblypXjzDPPLKFooPhVqVIlbrjhhrjwwguz+u64444ylaj+z3/+E1OmTMlqd+7cOY444ogSjAgAAAAAAGDLIq/K1k5eFQBg65Ze0gEAybbZZpukT+ydNm1arF27tgQjKno5Fb2WL5+3/QkqVKiQ1M7IyChQTMWhXr160bx586S+OXPm5GmOuXPnpsyZXfbi6EmTJuVpDQAAoPCNHDkyPvroo6S+U045JRo0aFBCEUHJOPvss6N169ZZ7UGDBsWYMWNKMKLcSyQSceeddyb1/f3vfy+haAAAAAAAALY88qrwB3lVAICtlwJgKGUqVKgQnTt3zmqvWLEihg8fXoIRFb2cilZnzZqVpzmyf+JvWXlxp2fPnknt0aNH53rsnDlz4tdff03q23HHHVOO69atW1L7k08+yUOEAABAYVu3bl1cfPHFSX1paWlx+eWXl0xAUIIqVKgQDzzwQFLfddddVzLB5NFLL70U33//fVb7hBNOiAMOOKAEIwIAAAAAANhyyKvC/8irAgBsvRQAQyl06KGHJrUffvjhEoqkeFSsWDEaN26c1JfXItWPP/44qb3hLlel2dFHH53UfuuttyIzMzNXY1977bWkdtu2baNRo0Ypx3Xq1Cnq1KmT1f7kk09i/Pjx+YgWAAAoqJ9++il69uwZI0aMSOo/6aSTYpdddimhqKBkHXnkkXHUUUdltT/44IOU//NLmzVr1sSNN96Y1a5WrVrce++9JRgRAAAAAADAlkNeFVLJqwIAbJ3Kl3QAQKqzzz47br/99li0aFFE/FHo+d5778URRxxRsoEVoR49esQLL7yQ1X7ggQeiT58+Ub785p+mPv300/jqq69S5isLunTpEm3atImffvopIiKmT58e//73v+OMM87Y5LgVK1ak/AN8wgkn5HhshQoV4vLLL49+/fpFREQikYjzzjsvPvnkk6hQoUIh3AoAAGBjdt9994iIyMzMjFmzZsWCBQtSjqlevXr87W9/K+bIoHR5+OGHo3379lntnB4rpcnUqVPj9NNPz2rvscce0bRp0xKMCAAAAAAAoOySV4XckVcFANj6KACGUqhWrVpx7bXXxnXXXRcRf7ygcfLJJ8cLL7wQPXv2zPU8o0ePjrvuuiv++9//FlWohea0005LKgD+4Ycf4sILL4zHH3880tM3/mHlkyZNilNOOSWpb4cddoh99tmnyGItTOXKlYvbb789jj/++Ky+K664Inbbbbekf9A3lJGREWeddVZMmTIlq69atWpxySWXbHSdyy67LB599NGYM2dORER88cUXcdxxx8Vzzz0XtWrVylWsy5cvj6effjqqVasWZ511Vq7GAADA1m7s2LGbPeahhx6KVq1aFUM0UHq1aNEibr755pIOI9d23HHHMhUvAAAAAABAaSavCrkjrwoAsPVRAAz59OWXX8bKlStT+rO/CLFq1aoYPHhwjnM0adIk2rVrl+N111xzTXz++ecxcODAiIhYunRp9O7dO3r37h0XX3xxdO7cOSpVqpSy1nfffReDBw+O119/Pb755puIiDJRAHzIIYdEt27dYsiQIVl9Tz75ZEyYMCFuvvnm6NKlS9KnAS9YsCCeffbZuO2222Lx4sVJc/3973+PcuXKFVvsBXXcccdFly5d4tNPP42IiMWLF0e3bt3i1ltvjTPOOCNq1qyZdeyoUaPi6quvjqFDhybNcd9990W9evU2ukatWrXi1VdfjR49esTatWsjIuKdd96JnXfeOa644oo4/vjjo3nz5injZsyYEcOHD4+33norBgwYEEuWLMn6JOGNWbhwYYwePTrH62bPnp3Unjx58kYfHx06dIg6depsci0AACjLKlasGHfffXecccYZBZrn8MMPj1mzZhVSVBs3cODAaNKkSZGvAwAAAAAAALCevCoAALA1UwAM+XTqqafGtGnTNnvcnDlz4qCDDsrxuj59+sSzzz6b43Xp6enx0ksvRe/evbOKPROJRLz55pvx5ptvRqVKlaJFixZRp06dWLVqVSxatCh+/fXXyMjIyO9NKnEvvfRS7LvvvkmfbPvFF1/EgQceGNWrV49WrVpFlSpVYsGCBTF58uRIJBIpc1x55ZVx3HHHFWfYheLll1+Ozp07Z932JUuWxOWXXx7XXHNNtG7dOqpVqxa//vpr/PbbbyljzznnnDj33HM3u8b+++8fzz33XJxxxhmxatWqiIiYOXNmXHXVVXHVVVdF48aNo2HDhlGpUqVYvHhxzJ07NxYuXJjn2zJ27NiN3ueze/755+P555/P8bohQ4ZE165d87w+AACUVmlpaVG9evVo3bp1dO/ePc4///zYYYcdCjzv+PHjc/X/aUGtWbOmyNcAAAAAAAAAtm7yqgAAAP+Tlsipgg7YrJYtWxb4hYBNFQCvt27durj22mvjoYceinXr1uV5jWbNmsX06dPzGWHxmzFjRpx++ukpn3C7ORUqVIjbbrstrrnmmkhLSyua4IrYr7/+GkcffXSMGjUqV8enp6fHTTfdtNlP5M1u9OjRccopp8TPP/+c5xjLlSsXjz766CYLjocOHRrdunXL89zZKQAGAIDcKYz/T3NjypQp0bJlyyJfBwAAAAAAAKCwyasCAABlUXpJBwBsWvny5ePee++Nn376Kc4999xo2LDhZse0bNkyzj333Pjwww9j6tSpRR9kIWrWrFl8/PHH8corr0TXrl0jPX3TT1O1atWKCy64IL7//vu49tpry2zxb0RE06ZN46uvvopHHnkkWrduvdHjKlWqFEcffXSMHTs2z8W/EREdOnSI8ePHx3PPPRd77713lCtXbpPHV6pUKbp37x733HNPzJgxI1efNgwAAAAAAAAAAAAAAABA/vkEYChjEolEjBs3LsaNGxfz58+PRYsWRaVKlaJWrVrRqlWraNeuXTRp0qSkwyw0S5cujVGjRsXkyZNj0aJFsWrVqqhZs2bUq1cvdt1112jXrt1mi4TLqh9++CHGjBkTs2bNiszMzKhfv360aNEi9ttvv6hatWqhrbN48eL4+uuvY9asWTF//vxYu3Zt1KhRIxo2bBg77bRTtGnTJipXrlxo6wEAAAAAAAAAAAAAAACwaQqAAQAAAAAAAAAAAAAAAACgFNkyPzYTAAAAAAAAAAAAAAAAAADKKAXAAAAAAAAAAAAAAAAAAABQiigABgAAAAAAAAAAAAAAAACAUkQBMAAAAAAAAAAAAAAAAAAAlCIKgAEAAAAAAAAAAAAAAAAAoBRRAAwAAAAAAAAAAAAAAAAAAKWIAmAAAAAAAAAAAAAAAAAAAChFFAADAAAAAAAAAAAAAAAAAEApogAYAAAAAAAAAAAAAAAAAABKkfIlHQCUVosWLYpPP/00q92sWbOoVKlSCUYEAAAAAAAA/7N69eqYMWNGVrtLly5Ru3btkguIrZK8KgAAAAAAAKVZWc6rKgCGjfj000+jd+/eJR0GAAAAAAAA5Mpbb70VvXr1Kukw2MrIqwIAAAAAAFCWlKW8anpJBwAAAAAAAAAAAAAAAAAAAPyPAmAAAAAAAAAAAAAAAAAAAChFypd0AFBaNWvWLKn91ltvxfbbb19C0QAAAAAAAECySZMmRe/evbPa2fNbUBzkVQEAAAAAACjNynJeVQEwbESlSpWS2ttvv33svPPOJRQNAAAAAAAAbFr2/BYUB3lVAAAAAAAAypKylFdNL+kAAAAAAAAAAAAAAAAAAACA/1EADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQCmiABgAAAAAAAAAAAAAAAAAAEoRBcAAAAAAAAAAAAAAAAAAAFCKKAAGAAAAAAAAAAAAAAAAAIBSRAEwAAAAAAAAAAAAAAAAAACUIgqAAQAAAAAAAAAAAAAAAACgFFEADAAAAAAAAAAAAAAAAAAApYgCYAAAAAAAAAAAAAAAAAAAKEUUAAMAAAAAAAAAAAAAAAAAQClSvqQD2Fr88ssvMWLEiPj1119jzZo1UadOndhpp51i3333jcqVK5dYXIlEIr755pv49ttvY+7cuRER0ahRo9htt92iffv2kZaWVmhrLViwIL788sv45ZdfYvny5VGtWrVo3bp1dO7cOerVq1do6wAAAAAAAAAAAAAAAAAAlGUKgIvYW2+9Fbfddlt88803OV5fvXr16Nu3b/Tr1y/q169fbHGtXbs2HnzwwXjggQdi5syZOR7TtGnTuPzyy+PSSy+NChUq5HutsWPHxk033RTvvvtuZGZmplxfrly5OOKII+K2226LXXfdNd/rAAAAAAAAAAAAAAAAAABsCdJLOoAt1erVq+O0006Lo48+eqPFvxERy5Yti0ceeSTatWsXn332WbHENmPGjNhrr73i6quv3mjxb0TEr7/+GldddVXss88+mzxuUx588MHYc88945133smx+DciIiMjI955553o0KFDPPzww/laBwAAAAAAAAAAAAAAAABgS6EAuAhkZmbGiSeeGC+++GJSf7ly5aJVq1ax++67R61atZKumzdvXhx22GHx1VdfFWlsc+fOjW7dusWYMWOS+qtUqRI777xztG3bNipXrpx03ejRo6Nbt24xf/78PK113333xeWXXx7r1q1L6m/cuHF06NAhGjdunNS/bt26uPTSS+Ohhx7K0zoAAAAAAAAAAAAAAAAAAFsSBcBF4O6774633347qe/888+P6dOnx+TJk2PMmDHx+++/xxtvvBHNmzfPOmbFihVxwgknxOLFi4sstr59+8Yvv/yS1a5cuXI88MADMX/+/Pjhhx9i/PjxMX/+/LjvvvuSCoEnTpwYZ555Zq7XGTZsWFxzzTVJfV27do3Ro0fHrFmzYtSoUTFr1qwYOXJkdOnSJem4K6+8MkaMGJHPWwgAAAAAAAAAAAAAAAAAULYpAC5kCxYsiL/97W9JfXfccUc89thj0aRJk6y+9PT0OProo2PYsGHRsmXLrP5ff/017rvvviKJ7cMPP4xBgwZltStUqBAffPBBXHbZZVG1atWs/mrVqsUVV1wR77//flSoUCGrf8CAATFkyJBcrXX11VdHRkZGVvuoo46KDz74INq3b5903J577hkffvhhHHHEEVl969ati6uvvjrPtw8AAAAAAAAAAAAAAAAAYEugALiQ3XXXXbF06dKs9gEHHBDXXnvtRo/fdttt46mnnkrqu//++2PBggWFHtuNN96Y1P7LX/4SBxxwwEaP79KlS0rsN9xww2bXGTRoUAwbNiyrXa9evXj66aejYsWKOR5fsWLFeOaZZ6JevXpZfZ999ll89NFHm10LAAAAAAAAAAAAAAAAAGBLowC4EGVmZkb//v2T+m6++eZIS0vb5LgePXrE/vvvn9VeunRpvPLKK4Ua2/fffx8jRozIalerVi1Xn7J7zTXXRLVq1bLaw4YNiwkTJmxyTPaC5osuuigaNGiwyTENGzaMCy+8cJPzAAAAAAAAAAAAAAAAAABsDRQAF6Jhw4bFvHnzstrbbbdddO3aNVdjzzrrrKT2W2+9VYiRRbz99ttJ7RNOOCFq1Kix2XE1atSI448/PqlvU7GtXr06Pvjgg6S+M888M1cxZj9u0KBBsWbNmlyNBQAAAAAAAAAAAAAAAADYUigALkTvvfdeUvuggw7a7Kf/bnjshoYOHRrLly8vstgOPvjgXI/NHtu777670WOzx92mTZto0aJFrtZp2bJl7LDDDlntpUuXxqeffprrOAEAAAAAAAAAAAAAAAAAtgQKgAvRt99+m9Ted999cz22SZMm0bJly6z2mjVrYvz48YUSVyKRiO+++y7fsXXu3DmpPXbs2EgkEjkeW5BzkNNa2ecDAAAAAAAAAAAAAAAAANjSKQAuRBMmTEhqt2vXLk/jsx+ffb78mjZtWqxYsSKrXa1atWjevHmux7do0SKqVq2a1V6+fHnMmDEjx2NL6zkAAAAAAAAAAAAAAAAAACgrFAAXkpUrV8b06dOT+po1a5anObIf/9NPPxU4rpzmyWtcOY3ZWGwFXauozgEAAAAAAAAAAAAAAAAAQFlRvqQD2FLMnz8/EolEVrtChQrRsGHDPM2x7bbbJrXnzp1bKLFln6dp06Z5nmPbbbdNKsbdWGwFXauozgEAAFD8EolEZGZmRkZGRmRmZkYikcjq29TXwjqmONbc8LL+Nmf/flPXFeVxpSGGoop1w/tY9vtcUbW3lLVK8naUJWU19rIad0TZjV3cxa+sxi7u4ldWYy+rcQMlp23btiUdAgBF4LXXXosBAwZEzZo149RTT4299967pEMCAAAAAABKgALgQrJs2bKkdtWqVSMtLS1Pc1SrVm2Tc+ZX9nmyr5MbuY2toGsV1TmYO3duzJs3L09jJk2aVChrAwBQdiQSiVi7dm3WZd26dVmXjIyMPH1fmMdlZGRkFdFuWFCb/Wtpu07xAgAAABStChUqlHQIABSy22+/PW688cas9hNPPBFvvfVWHHbYYSUYFQAAAAAAUBIUABeS7IWqlStXzvMcVapU2eSc+VWcsRV0raI6B48++mjccssthTIXAAC5l5mZGatXr47Vq1fHqlWrsr7Pqb2+b82aNbFmzZqkQty1a9fmqq+g4zIyMkr6lAEAAAAAsJVauXJl3H777Ul9a9asidtuu00BMAAAAAAAbIUUABeSVatWJbUrVqyY5zkqVaqU1F65cmWBYlqvOGMr6FpFdQ4AALZmmZmZsXLlyli5cmWsWLEiT1/XF+nmtng3e3vdunUlffMBAAAAAKBMePXVV2P16tUp/V999VWsW7cuypf3Nh8AAAAAANiayAwUkuyfdLtmzZo8z5E9iZOfT+rNSXHGVrly5VixYkW+1yqqcwAAUJolEolYtWpVLFu2LOmyfPnyTfYtX748V4W8Ob1ZCAAAAAAAKF2mT5++0esSiUQxRgIAAAAAAJQGCoALSfXq1ZPa2T8JNzeyf9pt9jnzqzhjq169elIBcF7XKqpzcOGFF8bxxx+fpzGTJk2K3r17F8r6AMCWZ33R7uLFi2PJkiWxZMmSrO839nXJkiUpBb3rC3kzMzNL+iYBAAAAAAAlaFNFvmlpacUYCQAAAAAAUBooAC4k2QtVV6xYEYlEIk8JmOXLl29yzsKKLfs6uZHb2KpXrx5z587N91pFdQ4aNmwYDRs2LJS5AIAtx+rVq+P333+PhQsXxu+//570/fqvixYt2mhR77p160r6JgCFKC0tLdLT05O+5tSX/br1Y9f//5fT95u6Lj/HFeXcZSXWDX9u2X+ORdXeUtYqydtRlpTV2Mtq3BFlN3ZxF7+yGru4i19Zjb2sxg2UjNq1a8f7779f0mEAUEg2tVmovxMBAAAAAGDrowC4kNSvXz/S0tKydmNdu3ZtzJ07Nxo1apTrOWbOnJnULqyC1ezz/Prrr3meI7exNWzYMCZPnpzvtYrqHAAAW7ZVq1bFvHnzYt68ebFgwYKUYt6cCnt///33WLlyZUmHzhaoXLlyUa5cuShfvnyUL19+o99v6rqcvk9PT4/09PQoV65cjl9L+3UbK6LNS8FtUR7jzXMAAACURePGjYurr766pMMAoJBs6hOAAQAAAACArY8C4EJSpUqVaN68eUybNi2rb/r06XkqAJ4+fXpSe6eddiqU2Nq0aZPUnjFjRp7nyD5mY7G1adMmvv7666x29tu0OUV1DgCAsmX58uUxd+7crKLezV2WLVtW0iFTQJUqVYrKlStHpUqVomLFilGxYsWoUKFCVKhQIen7nNq57cvPMRsW6+amSLdcuXIKSQEAAAAAyBcFwAAAAAAAwIYUABeinXbaKakAePz48dGxY8dcj58wYULKfIWhRYsWUaVKlaxPuFu+fHlMmzYtWrRokavx06ZNixUrVmS1q1WrFs2aNcvx2Owxjx8/Pk+xFtU5AABK3rp162LevHnx22+/xezZs+O3337LumzYnj17dixfvrykw91qpKWlRdWqVaNKlSopX9dfKlWqlFSgu+ElN32bO6ZChQqKZgEAAAAA2OopAAYAAAAAADakALgQ7b777vHBBx9ktYcNGxZ9+vTJ1djZs2fH1KlTs9oVKlSIdu3aFUpcaWlpseuuu8bw4cOTYsttAfCXX36Z1N511103WqCx++67J7WHDRuWp1izr5V9PgCg9EkkErFo0aKYMWNG/Prrr1mXGTNmZBX2zp49O+bNm+eNK3mUnp4e1atXj2rVqkX16tVTLtWqVdto8e7mvq7/vmLFiopvAQAAAACgFJBHAQAAAAAANqQAuBAdeeSRceedd2a1Bw8eHIlEIlcFFR9++GFSu1u3blG9evVCjW3DAuCPPvooTj755FyN/eijj5LaRx111EaP7dq1a1SrVi3rU/t+/vnnXH/a8NSpU2PixIlZ7Ro1akTXrl1zFSMAUDQSiUT8/vvvWQW92Qt813+/YsWKkg611KhRo0bUqlUratasmfV1w+9r1KiRYzFvToW+lStXVpwLAAAAAABbiczMzJIOAQAAAAAAKEUUABeifffdN+rXrx/z58+PiIjJkyfH0KFDo1u3bpsd+/TTTye1e/XqVaix9ezZM2688cas9quvvhoPPfTQZouMly5dGq+++mquY6tcuXIcfPDB8eabb2b1PfPMM3HLLbdsNsZnnnkmqX3ooYdGxYoVNzsOACiYRYsWxZQpU2Lq1KkxZcqUpO+nTp2atbHH1qBy5cpRt27dqFOnTtStWzfq1q0btWvXjlq1am2yqHfD4t709PSSvhkAAAAAAEAZ5BOAAQAAAACADSkALkTp6enRt2/fuOeee7L6brnllujatesmP7nt448/js8//zyrXaNGjTjhhBMKNbZdd901OnbsGCNHjoyIiGXLlsVdd90Vt9566ybH3XXXXUlFP3vvvXe0a9duk2POOuuspALgf/7zn3HxxRdHgwYNNjpm7ty58eijj6bMAwAU3MqVK2Py5MkpRb7r24sWLSrpEAtVWlpa1K5dO6uAd8Ni3vXfb6yvSpUqJR0+AAAAAACwlVIADAAAAAAAbEgBcCG79tpr4/HHH49ly5ZFRMSnn34ad955Z/zlL3/J8fiZM2fG2WefndR32WWXRf369Te5TvaC4iFDhkTXrl03OebWW2+Nww47LKv9j3/8Iw488MA44IADcjx+fewbuv322ze5RkTEEUccEXvvvXd8/fXXERGxYMGCOOuss+L111+PChUqpBy/Zs2aOOuss2LBggVZffvvv38ccsghm10LAPhDRkZGTJs2LX7++eeUy/Tp08v0G0bKly8fDRo0iPr160eDBg02e6lbt26UK1eupMMGAAAAAADIk7KczwEAAAAAAAqfAuBCVr9+/bj++uvj+uuvz+q77rrrYvr06XHDDTdEkyZNIiIiMzMz3nnnnbjsssti+vTpWcc2adIkrrzyyiKJ7dBDD42DDz44Pvzww4iIWLt2bRxyyCHxj3/8I84555yoWrVqREQsX748nnzyybjuuuti7dq1WeMPP/zw6NGjR67Wuvvuu6NLly6RmZkZEREDBgyIgw8+OO69995o37591nGjR4+OK6+8Mj799NOsvnLlysVdd91V4NsLAFuaRCIRc+bMybHI95dffok1a9aUdIi5lp6eHo0aNYrGjRvHNttsk3XZsN2oUaNo0KBB1KpVK2XzEwAAAAAAgC2NAmAAAAAAAGBDCoCLwLXXXhvDhg2Ld999N6vvscceiyeeeCJatGgRtWrViilTpsSiRYuSxlWpUiVeeeWVqF27dpHF9txzz8U+++wTU6ZMiYiIVatWxeWXXx7XXXddbLfddpFIJGLy5MmxatWqpHGtW7eOZ599Ntfr7LfffnHHHXfEtddem9U3dOjQ6NChQzRp0iQaN24cs2bNitmzZ6eMveuuu2LvvffO3w0EgC1AIpGImTNnxrhx45IuEyZMiCVLlpR0eJuUnp4ejRs3jqZNm2ZdciryrVevnk/pBQAAAAAA2IACYAAAAAAAYEMKgItAenp6vPrqq3HGGWfEf/7zn6z+jIyMmDx5co5j6tWrF6+99lp07ty5SGNr1KhRDBkyJHr16hVjx47N6l+5cmWMGzcuxzG77757vPPOO9GgQYM8rXXNNddEuXLl4tprr42MjIys/lmzZsWsWbNSji9Xrlzcc889cfnll+dpHQAoy+bNmxdjx46NH374IavQd/z48bF48eKSDi1FuXLlokmTJknFvc2aNUsp9i1f3p+YAAAAAAAAeZWZmVnSIQAAAAAAAKWI6owiUrly5Xj55ZfjuOOOi9tvvz2+/fbbHI+rVq1a9OnTJ/r16xcNGzYslthatGgRI0aMiAceeCAefPDBHItxIyKaNGkSl19+eVx22WVRsWLFfK115ZVXRo8ePeKGG26IQYMG5ZisSk9Pj8MPPzxuv/322G233fK1DgCUdhkZGTFp0qQYO3ZsfPvtt1lfN/Z7uCRUqFAhmjdvHq1atYpWrVpFy5Yts742b948ttlmG5/aCwAAAAAAUER8AjAAAAAAALAhBcBF7Nhjj41jjz02Jk2aFMOHD4+ZM2fGmjVronbt2tG2bdvo3LlzVK5cOc/zFjTpU7FixbjmmmviqquuitGjR8fYsWNj7ty5ERHRsGHD2H333aN9+/aRnp5eoHUi/vgE4XfffTfmz58fX3zxRUyePDmWL18e1apVi9atW0fnzp2jfv36BV4HAEqLNWvWxPfffx+jRo2KMWPGxNixY+O7776LFStWlGhc6enp0bRp06zC3g2LfFu1ahVNmjRR4AsAAAAAAFAKKQ4GAAAAAICtjwLgYrL99tvH9ttvX9JhpEhPT4+OHTtGx44di3yt+vXrR+/evYt8HQAoTuvWrYsJEybEqFGjYtSoUTFy5MgYO3ZsrFmzpsRi2nbbbWPHHXdMubRs2TIqVqxYYnEBAAAAAACwcYp8AQAAAACADSkABgDIpUQiEdOnT49hw4bFiBEjYuTIkTFmzJgS+WTf2rVrR5s2bVKKfLfffvuoXr16sccDAAAAAABAwSgABgAAAAAANqQAGABgI9asWRNjxoyJYcOGZV1mzZpVrDE0btw4dt5556xLu3btok2bNlGvXr1IS0sr1lgAAAAAAAAoOpmZmSUdAgAAAAAAUIooAAYA+P/mz58fX375ZVax78iRI2P16tXFsnaDBg1il112SSn2rVu3brGsDwAAAAAAQMnyCcAAAAAAAMCGFAADAFutefPmxWeffRZDhw6NTz/9NL7//vsiXzM9PT3atGkTu+22W+y+++5ZX7fZZpsiXxsAAAAAAIDSSwEwAAAAAACwIQXAAMBWY8OC36FDh8YPP/xQpOtVrlw59thjj2jfvn1Wse/OO+8cVatWLdJ1AQAAAAAAKHsUAAMAAAAAABtSAAwAbLFWrFgRn376aXz44YcxePDgIi34rVChQuy6667RsWPH2HPPPaNjx47Rrl27KF/en1sAAAAAAABsngJgAAAAAABgQypSAIAtRiKRiO+//z4++OCD+OCDD+Lzzz+PNWvWFMlabdu2jb333jur4HfXXXeNSpUqFclaAAAAAAAAbPkUAAMAAAAAABtSAAwAlGlz586NwYMHxwcffBAffvhh/Pbbb4W+RrVq1WKvvfaKfffdN/bdd9/Ya6+9om7duoW+DgAAAAAAAFuvzMzMkg4BAAAAAAAoRRQAAwBlSiKRiPHjx8c777wT77zzTgwfPrzQd0Nv0aJFdO7cOavgd5dddony5f3ZBAAAAAAAQNHxCcAAAAAAAMCGVLIAAKXe2rVr44svvsgq+p08eXKhzt+yZcvo2rVrdO3aNbp06RItW7Ys1PkBAAAAAABgcxQAAwAAAAAAG1IADACUSosXL473338/3nnnnRg4cGAsWrSo0OZW8AsAAAAAAEBpowAYAAAAAADYkAJgAKDUWLx4cbz99tvxyiuvxIcffhhr164tlHnr1asXBx10UBx88MHRrVs3Bb8AAAAAAACUOgqAAQAAAACADSkABgBK1JIlS2LAgAHx3//+Nz744INYs2ZNgecsX7587LvvvnHwwQfHIYccEu3bt4/09PRCiBYAAAAAAACKRmZmZkmHAAAAAAAAlCIKgAGAYrd06dJ4991345VXXolBgwbF6tWrCzxn69at45BDDolDDjkkunbtGjVr1iyESAEAAAAAAKB4+ARgAAAAAABgQwqAAYBisXbt2hg0aFA899xz8d5778WqVasKNF96enp07tw5evbsGUcddVS0adOmkCIFAAAAAACA4qcAGAAAAAAA2JACYACgyCQSifj222/j3//+d7z00ksxb968As1XrVq1OPTQQ6Nnz55x+OGHR/369QspUgAAAAAAACi9FAcDAAAAAMDWRwEwAFDofvvtt3jxxRfj3//+d3z//fcFmmvbbbeNnj17Rs+ePaNr165RuXLlQooSAAAAAAAASg9FvgAAAAAAwIYUAAMAhWLVqlUxYMCA+Pe//x3vv/9+ZGRk5HuubbfdNo4//vg44YQTYq+99or09PRCjBQAAAAAAABKHwXAAAAAAADAhhQAAwAFMmnSpHj88cejf//+8fvvv+d7nsaNG2cV/e6zzz6KfgEAAAAAANiqZGZmlnQIAAAAAABAKaIAGADIs3Xr1sWAAQPisccei48++ijf8zRq1CiOO+64OPHEE6Nz586KfgEAAAAAANhq+QRgAAAAAABgQwqAAYBcmzVrVjz55JPx5JNPxsyZM/M1R7Vq1eK4446L008/Pbp06RLlypUr5CgBAAAAAACg7FEADAAAAAAAbEgBMACwSYlEIj755JN49NFH4+23346MjIw8z5GWlhbdunWLPn36xDHHHBPVq1cvgkgBAAAAAACg7FIADAAAAAAAbEgBMACQo1WrVsULL7wQ9957b/z444/5mmOHHXaIPn36xJ///Odo3rx5IUcIAAAAAAAAWw4FwAAAAAAAwIYUAAMASRYsWBCPPfZYPPzwwzF37tw8j69Zs2acfPLJ0adPn9h7770jLS2tCKIEAAAAAACALUtmZmZJhwAAAAAAAJQiCoABgIiI+OWXX+L++++PZ555JlauXJnn8e3bt48LLrggTj755KhWrVoRRAgAAAAAAABbLp8ADAAAAAAAbEgBMABs5b7++uu455574o033sjzmwoqV64cJ510UlxwwQXRsWNHn/YLAAAAAAAA+aQAGAAAAAAA2JACYADYCiUSiXj33XfjzjvvjC+//DLP43fcccc4//zzo0+fPlG3bt0iiBAAAAAAAAC2LgqAAQAAAACADSkABoCtyPrC35tvvjm++eabPI1NT0+P3r17x4UXXhjdu3f3ab8AAAAAAABQiBQAAwAAAAAAG1IADABbgYIU/larVi3OPvvsuOyyy6JVq1ZFFCEAAAAAAABs3RQAAwAAAAAAG1IADABbsEQiEe+9917cfPPNMXr06DyN3WabbeKyyy6L8847L+rUqVNEEQIAAAAAAAAREZmZmSUdAgAAAAAAUIooAAaALVBBCn/btWsXV111VZxyyilRqVKlIooQAAAAAAAA2JBPAAYAAAAAADakABgAtiCJRCI++OCDuOGGG/Jc+Nu9e/e46qqr4tBDD420tLQiihAAAAAAAADIK8XBAAAAAACw9VEADABbiJEjR8a1114bQ4YMydO4nj17xo033hh77rlnEUUGAAAAAAAAbI4iXwAAAAAAYEMKgAGgjJs4cWL89a9/jVdffTVP43r27Bn9+vWL9u3bF1FkAAAAAAAAQG4pAAYAAAAAADakABgAyqgFCxbEzTffHI8//nisW7cu1+MU/gIAAAAAAEDpk5mZWdIhAAAAAAAApYgCYAAoY9asWROPPPJI3HbbbbFo0aJcj+vZs2fcdNNN0aFDh6ILDgAAAAAAAMgXnwAMAAAAAABsSAEwAJQRiUQi3n777bj66qtj0qRJuR6n8BcAAAAAAABKPwXAAAAAAADAhhQAA0AZMGHChLj00ktj8ODBuR7TtWvXuPPOO6NTp05FGBkAAAAAAABQGBQAAwAAAAAAG0ov6QAAgI1bunRpXHPNNbHrrrvmuvh31113jUGDBsUnn3yi+BcAAAAAAADKiMzMzJIOAQAAAAAAKEV8AjAAlEKJRCJefvnluOqqq2L27Nn/j707jdOyLvvHf8wAAwiiiKCiCKK4kJq5FiqiMG4QUAmouYDkcmu5VeYuuOVWYpmWqbjv4hIoCQJqUi64pIIooBKINwgissjAzPV/0P83N9fFOTADM+c1y/v9evng/B7n8mHqVQ/wM0elntl+++3jmmuuieOPPz4KC/2ODwAAAAAAAKhLbAAGAAAAAADWpAAMALXMRx99FP/zP/8TEyZMqNT9LVu2jIsuuijOO++8aN68eQ2nAwAAAAAAAGqCDcAAAAAAAMCaFIABoJZYuXJl3HDDDXHNNdfEypUr13t/QUFBDBkyJK6++urYZpttUkgIAAAAAAAA1BQbgAEAAAAAgDUpAANALfDyyy/H6aefHh9++GGl7j/44IPjlltuie9973s1nAwAAAAAAABIgw3AAAAAAADAmgrzHQAAGrIlS5bE6aefHoccckilyr9bb711PPDAA/HSSy8p/wIAAAAAAEA9YgMwAAAAAACwJhuAASBPxo4dG6eeemrMmTNnvfc2btw4zj333LjsssuiVatWKaQDAAAAAAAA0qQADAAAAAAArEkBGABS9tVXX8X5558f99xzT6Xu7969e9x+++3RtWvXmg0GAAAAAAAA5E1ZWVm+IwAAAAAAALWIAjAApGjMmDFx6qmnxrx589Z77xZbbBE33XRTDB48OAoKClJIBwAAAAAAAOSLDcAAAAAAAMCaCvMdAAAagqVLl8bpp58effr0qVT598QTT4wPP/wwhgwZovwLAAAAAAAADcC6CsDKwQAAAAAA0PDYAAwANezVV1+Nk046KWbNmrXeezt16hR//etfo1evXikkAwAAAAAAAGoLJV8AAAAAAGBNNgADQA0pKSmJiy66KLp3777e8m9BQUGcffbZ8d577yn/AgAAAAAAQAOkAAwAAAAAAKzJBmAAqAEff/xxHH/88fHmm2+u994uXbrE3XffHQcddFAKyQAAAAAAAIDaqKysLN8RAAAAAACAWsQGYACoZvfff3/svffe6y3/FhQUxC9/+ct49913lX8BAAAAAACggbMBGAAAAAAAWJMNwABQTZYsWRJnnXVWPPDAA+u9t2PHjnHfffdF9+7dU0gGAAAAAAAA1HY2AAMAAAAAAGtSAAaAavDWW2/FwIEDY+bMmeu9d8iQITFixIho1apVCskAAAAAAACAusAGYAAAAAAAYE2F+Q4AAHVZJpOJO+64I7p167be8m/btm3j6aefjrvvvlv5FwAAAAAAAMhiAzAAAAAAALAmG4ABYAMtW7YszjjjjHjggQfWe29xcXHcd999sfXWW6eQDAAAAAAAAKhrbAAGAAAAAADWZAMwAGyAadOmxf7777/e8m/jxo3jxhtvjLFjxyr/AgAAAAAAABVSAAYAAAAAANZkAzAAVNETTzwRgwcPjmXLlq3zvh133DEefvjh2G+//VJKBgAAAAAAANRVZWVl+Y4AAAAAAADUIjYAA0AllZaWxiWXXBIDBgxYb/n3uOOOi7ffflv5FwAAAAAAAKgUG4ABAAAAAIA12QAMAJWwePHiOP744+P5559f531FRUVxyy23xOmnnx4FBQUppQMAAAAAAADqOhuAAQAAAACANSkAA8B6TJ06Nfr37x8ff/zxOu/r1KlTPP7447HvvvumlAwAAAAAAACoL2wABgAAAAAA1lSY7wAAUJuNGTMmDjjggPWWf/v06RNvvfWW8i8AAAAAAACwQWwABgAAAAAA1qQADAAJMplM3HzzzdG3b99YunRphfcVFBTEVVddFc8880y0bt06xYQAAAAAAABAfWIDMAAAAAAAsKbG+Q4AALXNqlWr4uc//3nccccd67yvVatW8dBDD0Xv3r1TSgYAAAAAAADUVwrAAAAAAADAmhSAAWANX331VQwYMCBefPHFdd636667xtNPPx277LJLSskAAAAAAACA+mxdBWDlYAAAAAAAaHgK8x0AAGqLTz75JH7wgx+st/zbr1+/eO2115R/AQAAAAAAgGqj5AsAAAAAAKxJARgAImLKlCnx/e9/P6ZPn77O+y6++OIYNWpUtGrVKqVkAAAAAAAAQENQVlaW7wgAAAAAAEAt0jjfAQAg355//vkYMGBALFu2rMJ7mjRpEnfeeWecdNJJKSYDAAAAAAAAGgobgAEAAAAAgDUpAAPQoN19991x2mmnRWlpaYX3tGnTJp566qk4+OCDU0wGAAAAAAAANCQ2AAMAAAAAAGsqzHcAAMiHTCYTV155ZQwdOnSd5d/ddtstXnvtNeVfAAAAAAAAoEbZAAwAAAAAAKzJBmAAGpyysrI499xz449//OM67+vRo0c89dRTsfnmm6cTDAAAAAAAAGiwFIABAAAAAIA12QAMQIOyatWqOPnkk9db/j322GNj7Nixyr8AAAAAAABAKsrKyvIdAQAAAAAAqEUUgAFoMFasWBE/+clP4oEHHljnfb/61a/iwQcfjKZNm6aUDAAAAAAAAGjobAAGAAAAAADW1DjfAQAgDUuWLIm+ffvGSy+9VOE9BQUFMWLEiDj77LNTTAYAAAAAAABgAzAAAAAAAJBNARiAem/RokVxxBFHxJtvvlnhPUVFRfHggw/GMccck2IyAAAAAAAAgP+yARgAAAAAAFiTAjAA9dqXX34ZvXr1infffbfCe1q0aBFPPfVUFBcXp5gMAAAAAAAA4P/YAAwAAAAAAKxJARiAeut///d/o1evXvH+++9XeM/mm28ezz//fHz/+99PMRkAAAAAAABANhuAAQAAAACANSkAA1AvzZs3Lw477LD48MMPK7xn6623jhdeeCH22GOPFJMBAAAAAAAArE0BGAAAAAAAWJMCMAD1zpw5c+Kwww6Ljz/+uMJ7OnXqFOPHj48dd9wxxWQAAAAAAAAAycrKyvIdAQAAAAAAqEUUgAGoV+bOnRs9evSImTNnVnhPly5dYsKECbHddtulmAwAAAAAAACgYjYAAwAAAAAAayrMdwAAqC5ffPFFHHbYYess/+66664xadIk5V8AAAAAAACgVllXAVg5GAAAAAAAGh4FYADqhQULFkTPnj3jo48+qvCe73znOzFp0qRo3759iskAAAAAAAAA1k/JFwAAAAAAWJMCMAB13qJFi6K4uDimTp1a4T177rlnTJw4MbbaaqsUkwEAAAAAAABUTllZWb4jAAAAAAAAtYgCMAB12uLFi+Pwww+Pd999t8J7vve978WECROibdu2KSYDAAAAAAAAqDwbgAEAAAAAgDUpAANQZy1btiyOPvromDJlSoX37LHHHjFu3Lho06ZNiskAAAAAAAAAqkYBGAAAAAAAWJMCMAB1UklJSfz4xz+Of/7znxXes9tuu8X48eOVfwEAAAAAAIBar6ysLN8RAAAAAACAWkQBGIA6p7S0NE488cR44YUXKrynS5cu8eKLL0a7du1STAYAAAAAAACwYWwABgAAAAAA1qQADECdkslk4qyzzorHHnuswns6d+4cEyZMiG222SbFZAAAAAAAAAAbzgZgAAAAAABgTQrAANQpl156afzlL3+pcN6hQ4eYMGFCbLfddimmAgAAAAAAANg4NgADAAAAAABrUgAGoM64+eab49prr61wvuWWW8a4ceOiY8eOKaYCAAAAAAAAAAAAAAAAqF4KwADUCY8++micf/75Fc433XTTGDt2bOyyyy4ppgIAAAAAAAAAAAAAAACofgrAANR6L7/8cpx00kkVzps2bRrPPvts7LPPPimmAgAAAAAAAAAAAAAAAKgZCsAA1GpTp06Nfv36RUlJSeK8sLAwHnnkkejRo0e6wQAAAAAAAAAAAAAAAABqiAIwALXW559/HkcddVQsXry4wnvuuuuu6N+/f2qZAAAAAAAAAAAAAAAAAGqaAjAAtdI333wTvXv3jtmzZ1d4z7XXXhuDBw9OLxQAAAAAAAAAAAAAAABAChSAAah1Vq9eHQMHDox33nmnwntOP/30uPDCC9MLBQAAAAAAAAAAAAAAAJASBWAAap1f/vKXMXbs2Arnffr0iVtvvTUKCgpSTAUAAAAAAACQH5lMJt8RAAAAAACAlCkAA1Cr/PnPf44//OEPFc7322+/eOSRR6Jx48YppgIAAAAAAAAAAAAAAABIjwIwALXGiy++GD//+c8rnHfu3Dn+9re/RYsWLVJMBQAAAAAAAAAAAAAAAJAuBWAAaoWPPvoojjnmmCgtLU2ct27dOp577rnYaqutUk4GAAAAAAAAAAAAAAAAkC4FYADybtGiRdGnT59YvHhx4rxx48bxxBNPxC677JJuMAAAAAAAAAAAAAAAAIA8UAAGIK9Wr14dgwYNio8//rjCe2699dY47LDDUkwFAAAAAAAAAAAAAAAAkD8KwADk1cUXXxzjx4+vcH7OOefE6aefnmIiAAAAAAAAAAAAAAAAgPxSAAYgbx599NG48cYbK5wfddRRcdNNN6WYCAAAAAAAAAAAAAAAACD/FIAByIt33303TjnllArnXbt2jYcffjgaN26cYioAAAAAAAAAAAAAAACA/FMABiB1ixYtih/96EexfPnyxHnr1q3j2Wefjc022yzlZAAAAAAAAAAAAAAAAAD5pwAMQKpKS0vjuOOOi08++SRxXlhYGA8//HDsuOOOKScDAAAAAAAAAAAAAAAAqB0UgAFI1eWXXx4vvPBChfNrr702jjjiiBQTAQAAAAAAAAAAAAAAANQuCsAApOa5556La6+9tsL5McccExdccEGKiQAAAAAAAAAAAAAAAABqHwVgAFIxe/bsOPHEEyuc77777jFy5MgoKChIMRUAAAAAAAAAAAAAAABA7aMADECNKykpiYEDB8aiRYsS55tvvnk89dRT0bJly5STAQAAAAAAAAAAAAAAANQ+CsAA1Ljf/OY38dprr1U4f+CBB2KnnXZKMREAAAAAAAAAAAAAAABA7aUADECNGjVqVIwYMaLC+YUXXhi9e/dOLxAAAAAAAAAAAAAAAABALacADECNmTlzZgwZMqTC+cEHHxxXXXVViokAAAAAAAAA6p5MJpPvCAAAAAAAQMoa5zsAAPVTSUlJHHvssbFkyZLEebt27eKRRx6Jxo39XxEAAAAAAFA7ZTKZ+PTTT+O9996LOXPmxOLFi6Np06bRunXr6NKlS+y3337RrFmzav3mN998E6+++mp89NFHsWTJkmjevHl07NgxunXrFu3bt6/WbwEAAAAAAAC1l9YVADXisssuizfffDNxVlBQEA899JB/SQUAAAAAAKh1vvrqq3j66adj7NixMWHChPjyyy8rvLdJkybRu3fvOPfcc+OQQw7ZqO9+8skncfnll8djjz0WJSUla80LCgrikEMOieHDh0f37t036lsAAAAAAABA7VeY7wAA1D/jx4+PG264ocL5sGHDomfPnikmAgAAAAAAWL+zzjortt566zjllFPiscceW2f5NyJi1apV8fTTT0ePHj3i5JNPjiVLlmzQdx977LHYfffd44EHHkgs/0b8dxvxpEmTokePHnHhhRdGJpPZoG8BAAAAAAAAdYMNwABUqwULFsSJJ55Y4bxXr15xySWXpJgIAAAAAACgcl577bXEAm6jRo1im222ia222ipWrVoVn332WXz99ddZ99x3333x4YcfxosvvhgtW7as9Dcff/zxOO6446KsrCzrvG3bttGhQ4eYP39+zJ07t7zwm8lk4vrrr4+VK1fGzTffvAF/SgAAAAAAAKAusAEYgGqTyWRiyJAh8cUXXyTO27ZtG/fff380atQo5WQAAAAAAABVs/nmm8eZZ54ZY8aMia+++ir+85//xJtvvhnvvvtuLFy4MCZOnBgHH3xw1jOvv/56DB48uNLfmDlzZgwZMiSr/Pvd7343JkyYEPPnz48pU6bEf/7zn5g2bVr8+Mc/znp2xIgRMWrUqI36MwIAAAAAAAC1lwIwANXm1ltvjTFjxlQ4HzlyZGy99dYpJgIAAAAAAKiaTp06xZ133hmff/55/OlPf4qjjz46Nt1006x7GjVqFD169IiJEyfGaaedljV78sknY+LEiZX61mWXXRbLli0rv95vv/3i5ZdfjkMPPTTrvl122SWeeOKJtb51wQUXxOrVq6vyxwMAAAAAAADqCAVgAKrFv//97/j1r39d4fzss8+O3r17p5gIAAAAAACgaoYPHx7Tp0+PoUOHRvPmzdd7f6NGjeK2226LfffdN+v8zjvvXO+zH3zwQTz66KPl10VFRXHvvfdGq1atEu8vKCiIW265Jbp06VJ+NnPmzBg5cuR6vwUAAAAAAADUPQrAAGy0lStXxoknnhgrV65MnH/3u9+N66+/PuVUAAAAAAAAVdO7d+8oKiqq0jONGjWKCy64IOvs73//+3qfu/vuu6OsrKz8+thjj43ddtttnc80a9YsLrzwwqyzypSNAQAAAAAAgLpHARiAjTZs2LD497//nThr3rx5PPzww9GsWbOUUwEAAAAAAKTj4IMPzrpeuHBhLF++fJ3PPPvss1nXQ4cOrdS3Bg0aFC1atCi/fuONN+Lzzz+vZFIAAAAAAACgrlAABmCjvPrqq3HDDTdUOB8xYsR6f1s9AAAAAABAXda6deu1zr7++usK758+fXrMmDGj/LpFixbRrVu3Sn0r995MJhNjxoypQloAAAAAAACgLlAABmCDLV26NE4++eQoKytLnPfv3z9OPfXUlFMBAAAAAACka+7cuWudtWnTpsL733nnnazr/fffPxo3blzp7x144IHrfB8AAAAAAABQ9ykAA7DBfv3rX8fMmTMTZ+3atYs77rgjCgoKUk4FAAAAAACQrldeeSXrumPHjlFUVFTh/dOmTcu67tq1a5W+l3t/7vsAAAAAAACAuk8BGIAN8vzzz8ef//znCud33HFHtG3bNsVEAAAAAAAA+XH33XdnXR999NHrvH/69OlZ1x06dKjS93Lvz30fAAAAAAAAUPcpAANQZYsWLYqhQ4dWOB8yZEj069cvxUQAAAAAAAD58dxzz8XLL7+cdTZ48OB1PjN//vys6+22265K39x2222zrhcsWFCl5wEAAAAAAIDar3G+AwBQ95xzzjkxb968xFnHjh1jxIgR6QYCAAAAAADIg0WLFsXpp5+edda/f//Yf//91/nc0qVLs65btGhRpe/m3r9q1apYuXJlNG3atErvyTV//vwql4lnzJixUd8E/iuTyeQ7AgAAAAAAUMsoAANQJc8991w88MADFc7vueeeaNWqVYqJAAAAAAAA0ldWVhYnnHBCzJkzp/xss802iz/84Q/rfTa3ANysWbMqfbt58+aJ79zYAvBtt90Ww4cP36h3ABtmfQVgBWEAAAAAAGh4CvMdAIC64+uvv17rt9iv6bzzzosePXqkFwgAAAAAACBPfv3rX8fzzz+fdfaXv/wlOnTosN5nv/3226zroqKiKn07qei7YsWKKr0DqF3KysryHQEAAAAAAKhlbABOwQcffBBTpkyJefPmRWlpabRp0yZ23333OOCAA6Jx4/z8R/Dtt9/GtGnTYurUqbFgwYJYtmxZbLbZZtGmTZvYe++9Y5dddslLLqB2u+CCC7J+i/2adtlll7jmmmtSTgQAAAAAAJC+P/zhD/H73/8+6+yCCy6IQYMGVer53I2/JSUlVfr+ypUr1/tOoG6x4RcAAAAAAMilAFxDMplMjBw5Mq6//vr46KOPEu9p06ZN/M///E9ceOGF0aJFixrP9P7778eoUaNi/Pjx8a9//StWrVpV4b3t2rWLoUOHxs9//vNo3759lb4zbNiwGD58+AbnPPnkk+Oee+7Z4OeBmjFx4sS44447EmcFBQVx9913R/PmzVNOBQAAAAAAkK6HHnoozj333KyzwYMHx3XXXVfpd7Rs2TLrOncj8PokbfvNfeeGOPPMM2PAgAFVembGjBnRv3//jf42NHQ2AAMAAAAAALkUgGvA4sWLY+DAgTFu3Lh13rdw4cK4+uqr46GHHopnn302vvOd79RInrlz58aRRx4Z77//fqWfmT9/fvz2t7+NP/3pT/HHP/4xTjrppBrJBtQNy5Yti5/97GcVzn/xi19Et27dUkwEAAAAAACQvtGjR8fJJ5+ctanzxz/+cdx5551RUFBQ6ffklnWXLVtWpRy59zdu3LhaNgC3a9cu2rVrt9HvAarOBmAAAAAAACBXYb4D1DcrVqyII444Yq3yb1FRUey8886xxx57rLXtd9asWXHooYfGjBkzaiTTV199VWH5t0WLFrHTTjvF/vvvH7vssks0atQoa75kyZI4+eST48Ybb6yRbEDdcOmll8asWbMSZzvssENce+21KScCAAAAAABI18SJE2PAgAGxevXq8rPi4uJ4+OGH1/p71vXJLdnOmTOnSs/PnTs367pt27ZVeh6ofWwABgAAAAAActkAXM3OP//8eP3118uvCwsL45JLLonzzjsvWrduHRERJSUl8dBDD8X5558fX331VURELFiwIAYOHBhvvPFGlf9yuKp23333OOmkk6Jnz56x1157RWHh//XAlyxZEvfff39cccUVsXDhwvLzCy64IHbbbbfo06dPlb930003xXe/+91K39++ffsqfwOoOf/617/illtuqXD+17/+da1fbAAAAAAAAFCfvPbaa9G3b9/49ttvy8+6desWTz31VBQVFVX5fbvsskvW9ezZs6v0fO79u+66a5UzALWLDcAAAAAAAEAuBeBq9OGHH8Zf//rXrLMHHnggjjvuuKyzoqKiGDx4cOy3335x0EEHxeLFiyMi4u2334777rsvhgwZUiP5evfuHZdeeml8//vfr/CeVq1axVlnnRV9+/aNQw45JD755JPy2bnnnhtHHHFENGnSpErf3WeffaJHjx4bGhvIo1WrVsVpp51W4V82n3rqqdGzZ8+UUwEAAAAAAKTn3//+dxx11FGxdOnS8rPvfe978dxzz23wL0nNLexOnTq1Ss9PmzZtne8D6h4FYAAAAAAAIFfh+m+hsq644oooLS0tvz7xxBPXKv+u6Tvf+U7cdNNNWWfDhw+PVatWVWuutm3bxquvvhqjR49eZ/l3TR06dIhRo0ZlbQeeOXNmTJo0qVqzAbXbiBEj4r333kucbbvttnHjjTemnAgAAAAAACA906dPj+Li4vjqq6/Kz3bbbbf4+9//HpttttkGv3evvfbKun7jjTdi9erVlX7+1VdfXef7gLqnrKws3xEAAAAAAIBaRgG4mnz11VcxatSo8uuCgoIYNmzYep8bMmRIdOzYsfz6s88+i/Hjx1drtq222iq6detW5ef22muvOPLII7PO/v73v1dXLKCW+/TTT9f5v2N//vOfN+pfbAEAAAAAAKjNPvvss+jVq1fMnz+//GyHHXaIcePGRdu2bTfq3bvuumvsuOOO5dfLli2LyZMnV+rZZcuWxT//+c/y64KCgujTp89G5QHyzwZgAAAAAAAglwJwNRkzZkzWb2Tu0aNHdO7ceb3PFRYWxpAhQ7LOnn766eqOt8EOPvjgrOvZs2fnKQmQpkwmEz//+c9j+fLlifOBAwf6F0kAAAAAAIB6a968edGzZ8+YM2dO+dm2224bL774Ymy77bbV8o2+fftmXd91112Veu7RRx+NpUuXll/vu+++0b59+2rJBOSPDcAAAAAAAEAuBeBqMmbMmKzrww8/vNLPFhcXZ12PHj26WjJVh9atW2ddf/3113lKAqRp1KhRa/3v2v/TqlWrGDFiRLqBAAAAAAAAUrJo0aIoLi6OmTNnlp+1bds2xo0bFzvssEO1feeUU06JgoKC8utHHnkkpk2bts5nvv3227juuuuyzoYOHVptmYD8sQEYAAAAAADIpQBcTd55552s627dulX62X322SeaNm1afv3555/HggULqivaRpk7d27WdZs2bfKUBEjLkiVL4uyzz65wfu2118Y222yTYiIAAAAAAIB0fPPNN3HkkUfGBx98UH62+eabxwsvvBC77bZbtX5r9913j4EDB5Zfl5SUxMknnxxLlixJvD+TycS5554bH3/8cflZ586d45RTTqnWXEB+2AAMAAAAAADkapzvAPXBqlWrYsaMGVlnXbt2rfTzTZs2jR133DGmTp1afjZt2rRo27ZttWXcUK+88krW9c4777xB71m5cmXMmjUrFi5cGE2aNIk2bdpE+/btY5NNNqmOmEA1uvTSS+Pzzz9PnO2///5xxhlnpJwIAAAAAAAgHX379o033ngj6+z888+PL7/8MsaPH1+ld+2zzz7RunXrdd5z9dVXx9/+9rdYvnx5RES88cYb0b179xgxYkT06NGj/L6PPvooLrroohg1alTW89ddd100adKkSrmA2skGYAAAAAAAIJcCcDWYNWtWrF69uvy6efPmseWWW1bpHR06dMgqAE+fPj26d+9ebRk3xMyZM+Oll17KOjv66KOr/J6zzjorZs2aFd9++23WeePGjWOfffaJo446Ks4888xaUXiGhm7KlCnxpz/9KXHWqFGj+Mtf/hKNGjVKORUAAAAAAEA6Jk2atNbZ5ZdfvkHvmjhxYlaJN8lOO+0Ud911Vxx//PHl5b933303Dj300Gjbtm1sv/32MX/+/JgzZ85a5cBf/OIXMWDAgA3KBtQ+CsAAAAAAAECuwnwHqA/mz5+fdb3ttttW+R25z+S+Mx8uuuiirL9g6tq1a+y3335Vfs/UqVPXKv9GRKxevTpee+21GDZsWHTs2DEuv/zyKC0t3ajMwIYrKyuLn//851FWVpY4P+ecc2KvvfZKNxQAAAAAAEA9d+yxx8aDDz4YzZs3zzpfsGBBTJkyJf7zn/+sVQz81a9+FbfcckuaMYEaVtHf0wIAAAAAAA2XDcDVYOnSpVnXLVq0qPI7cp/JfWfaHnvssXj88cezzq699tooKCioke+tWLEirrrqqnjllVfib3/7W7Rs2bJa3z9//vxYsGBBlZ6ZMWNGtWaA2u6+++6Lf/3rX4mzDh06xPDhw1NOBAAAAAAA0DAcd9xxccABB8Rll10Wjz/+eKxatSrxvu7du8eVV14ZhxxySMoJgZq2vg3ANgQDAAAAAEDDowBcDXLLus2aNavyO3J/m3M+C8DTp0+PU089Nevsxz/+cfTr16/S7ygoKIgf/OAH0bt379h///1jt912iy222CIKCwtj4cKF8dZbb8Xo0aPj3nvvzdoOPGnSpDj22GPjmWeeiUaNGlXbn+m2225TXoR1+Prrr+M3v/lNhfM//vGP1V7MBwAAAAAAqG3yWbDr3LlzPPjgg3H77bfHP/7xj/j444/jm2++iWbNmsX2228fBx54YGy77bZ5ywfULBuAAQAAAACAXArA1WDNAmtERFFRUZXf0bRp06zrFStWbFSmDbVo0aL44Q9/GEuWLCk/22677eKOO+6o9DsOP/zwOP7442PnnXdOnLdv3z7at28fffr0iUsvvTSOPfbYePXVV8vnY8aMidtuuy1+8YtfbPgfBKiSYcOGxfz58xNnRx99dPTt2zflRAAAAAAAAA1Tq1at4uijj853DCBlNvwCAAAAAAC5CvMdoDqce+65UVBQUOP/DBs2LPH7uRt/S0pKqvxnWLly5TrfmYYVK1ZE37594+OPPy4/a9GiRYwaNSratGlT6fd069atwvJvru222y7Gjx8fP/jBD7LOr7766li+fHmlvwlsuA8++CD++Mc/Js6KiopixIgRUVBQkHIqAAAAAAAAgIbDBmAAAAAAACCXDcDVoGXLllnXuRuBKyN342/uO2va6tWrY+DAgVmbeIuKimLUqFGx33771ei3mzVrFvfdd1/stttusXr16oiImD9/frzwwgvRv3//avnGmWeeGQMGDKjSMzNmzKi270Ntlclk4he/+EWUlpYmzn/5y19Gly5dUk4FAAAAAAAA0LDYAAwAAAAAAORSAK4GuWXdZcuWVfkduc+kWQDOZDJx8sknx+jRo8vPGjVqFA8++GAcfvjhqWTYaaedom/fvjFq1Kjys+osALdr1y7atWtXLe+C+uTxxx+PiRMnJs622267uOSSS1JOBAAAAAAAANDwKAADAAAAAAC56kUBuHfv3rHlllvW+He6d++eeJ5bLJ07d26V3537TJpl1TPPPDMeeuih8uuCgoK444474phjjkktQ0REz549swrA06dPT/X70NAsW7YsfvnLX1Y4/93vfhctWrRIMREAAAAAAABAw1RWVpbvCAAAAAAAQC1TLwrAxcXFUVxcnLfvd+7cORo3bhyrV6+OiIgVK1bEggULom3btpV+x+zZs7Oud91112rNWJELLrgg/vznP2ed/f73v49TTjklle+vqUOHDlnXCxYsSD0DNCQ33XRTzJkzJ3F26KGHxoABA1JOBAAAAAAAANAw2QAMAAAAAADkKsx3gPqgSZMmseOOO2adTZ06tdLPr1y5MmbNmpV1lkYB+Kqrroobb7wx62z48OFx7rnn1vi3kzRp0iTretWqVXnJAQ3B3Llz44YbbkicNWrUKP7whz9EQUFByqkAAAAAAAAAGiYbgAEAAAAAgFwKwNVkr732yrqePHlypZ+dMmVKrFy5svx6m222iXbt2lVXtEQjRoyIyy+/POvsl7/85Vpnafriiy+yrquyQRmomksuuSSWL1+eOPv5z38eu+++e8qJAAAAAAAAABouG4ABAAAAAIBcCsDVpE+fPlnX48aNq/Szuff+8Ic/rJZMFbnzzjvj/PPPzzo77bTT4qabbqrR767PP/7xj6zrDh065CkJ1G9TpkyJe++9N3HWpk2bGDZsWLqBAAAAAAAAABo4G4ABAAAAAIBcCsDV5Oijj47GjRuXX0+aNClmzZq13ucymUzcc889WWf9+vWr7njlHnnkkTj99NOzfnPsT3/607j99ttr7JuVsXjx4njyySezznr27JmnNFB/ZTKZtX4BwJqGDRsWm2++eXqBAAAAAAAAALABGAAAAAAAWIsCcDXZYoston///uXXmUymUls077777vj000/Lrzt27Bi9evWq/oARMXr06DjppJOyfmts//7945577onCwvz+V+FXv/pVLF68uPy6qKgojjrqqPwFgnrq6aefjpdffjlxtuuuu8bpp5+eciIAAAAAAAAAFIABAAAAAIBcCsDVaPjw4VlF2vvvvz8efvjhCu+fOnVq/OpXv8o6u+yyy6KoqGid3/n000+joKAg6581S8RJJk2aFAMGDIhVq1aVnx1++OHx6KOPZm0u3ljXXXddTJkypdL3r169On75y1/GXXfdlXV+xhlnxDbbbFNtuYCIkpKS+PWvf13h/KabboomTZqkmAgAAAAAAACAiMj6Ze4AAAAAAAAREdXX/CS6du0aP/vZz+KOO+4oPzvhhBNi2rRpcd5550Xr1q0jImLVqlXx4IMPxvnnn5+19XbPPfeMk08+udpzvf/++9G3b9/49ttvy8+23nrrOOussyrcBFqR5s2bx4EHHljhfOzYsXHRRRdFt27dYuDAgdGzZ8/Ydddd1yoZf/311/Hcc8/FDTfcEO+8807WbMcdd4zLL7+8SrmA9bv11ltj5syZibNevXrF0UcfnXIiAAAAAAAAACJsAAYAAAAAANamAFzNbr755njrrbfizTffjIj//obWq666Kq6//vrYYYcdomnTpjFr1qxYunRp1nNbbrllPP7449W6jff/efPNN+Obb77JOvviiy+iX79+VX5Xx44d17ttOCJi8uTJMXny5IiIaNq0aWy33Xax2WabRaNGjWLhwoXx6aefJv722q233jqef/75aNOmTZWzARVbuHBhXHXVVYmzwsLC+N3vfhcFBQUppwIAAAAAAAAgwgZgAAAAAABgbQrA1WyTTTaJv//97zFgwICYMGFC+XlJSUlMnz498ZlOnTrFs88+GzvvvHNaMVO1cuXKCreOrunoo4+OkSNHRrt27VJIBQ3Lb3/726yN42saOnRo7LnnnukGAgAAAAAAAKCcDcAAAAAAAECuwnwHqI+22GKLGDduXNxxxx2x0047rfO+iy++ON57773YY489UkxYcy655JI444wz4jvf+U40atRovfe3bNkyBgwYEC+99FKMGTNG+RdqwOzZs+PWW29NnLVs2TKuvPLKlBMBAAAAAAAAsKb1bQBWEAYAAAAAgIbHBuAaUlhYGKeeemqceuqp8d5778Vbb70V8+bNi9LS0mjTpk3svvvuccABB0STJk2q/O5OnTpV6S92Bg8eHIMHD67ydzZEcXFxFBcXR0TE8uXLY+rUqfHpp5/GvHnzYunSpVFWVhabb755tG7dOrp27Rp77LFHpYrCwIYbNmxYrFy5MnF24YUXxtZbb51yIgAAAAAAAADWpOALAAAAAADkUgBOwR577FFvNvxWxSabbBL77rtv7LvvvvmOAg3WBx98EPfee2/ibOutt45zzz033UAAAAAAAAAArEUBGAAAAAAAyFWY7wAA1JyLL744ysrKEmdXXHFFtGjRIuVEAAAAAAAAAOSq6O91AQAAAACAhksBGKCeevXVV+PZZ59NnHXp0iWGDh2aciIAAAAAAAAAktgADAAAAAAA5FIABqiHMplMXHjhhRXOr7nmmmjSpEmKiQAAAAAAAACoiA3AAAAAAABALgVggHpozJgx8Y9//CNxtu+++8YxxxyTciIAAAAAAAAAKmIDMAAAAAAAkEsBGKCeKS0tjYsuuqjC+XXXXRcFBQUpJgIAAAAAAABgXWwABgAAAAAAcikAA9Qzjz76aLz//vuJs+Li4ujZs2fKiQAAAAAAAABYFwVgAAAAAAAglwIwQD2yevXqGD58eIXz6667LsU0AAAAAAAAAFSGAjAAAAAAAJBLARigHnnwwQfjo48+SpwNGjQo9t5775QTAQAAAAAAALA+CsAAAAAAAEAuBWCAemLVqlVx5ZVXJs4KCwvXuRkYAAAAAAAAgPxRAAYAAAAAAHIpAAPUE/fee2/MmjUrcXbCCSfELrvsknIiAAAAAAAAACojk8nkOwIAAAAAAFDLKAAD1AMlJSVx1VVXJc4aNWoUl19+ecqJAAAAAAAAAKgsG4ABAAAAAIBcCsAA9cBdd90Vs2fPTpwNHjw4dtxxx5QTAQAAAAAAAFBZCsAAAAAAAEAuBWCAOu7bb7+Na665JnHWpEmTuOyyy1JOBAAAAAAAAEBVKAADAAAAAAC5FIAB6rg77rgj5s6dmzj72c9+Fh07dkw5EQAAAAAAAABVsb4CcCaTSSkJAAAAAABQWygAA9RhK1asiN/+9reJs6ZNm8bFF1+cciIAAAAAAAAAqsoGYAAAAAAAIJcCMEAddtddd8UXX3yRODv99NNju+22SzkRAAAAAAAAAFWlAAwAAAAAAORSAAaoo0pKSuL6669PnDVr1iwuvPDClBMBAAAAAAAAsCEymUy+IwAAAAAAALWMAjBAHXXvvffGnDlzEmdnnHFGbLPNNiknAgAAAAAAAGBD2AAMAAAAAADkUgAGqINWr14dv/3tbxNnTZs2jV//+tcpJwIAAAAAAABgQykAAwAAAAAAuRSAAeqghx9+OD755JPE2dChQ6N9+/YpJwIAAAAAAABgQykAAwAAAAAAuRSAAeqY0tLSuPbaaxNnjRs3jgsuuCDlRAAAAAAAAABsDAVgAAAAAAAglwIwQB3z5JNPxocffpg4O+mkk6Jjx44pJwIAAAAAAABgYygAAwAAAAAAuRSAAeqQsrKyuPrqqxNnhYWFcdFFF6WcCAAAAAAAAICNpQAMAAAAAADkUgAGqENGjx4d7733XuLsuOOOi5122inlRAAAAAAAAABsrEwmk+8IAAAAAABALaMADFBHZDKZCrf/RkRcfPHFKaYBAAAAAAAAoLrYAAwAAAAAAORSAAaoIyZNmhRvvPFG4uwnP/lJdO3aNeVEAAAAAAAAAFQHBWAAAAAAACCXAjBAHXHDDTdUOLvkkktSTAIAAAAAAABAdVIABgAAAAAAcikAA9QB7777bowdOzZxdtRRR8X3vve9lBMBAAAAAAAAUF0UgAEAAAAAgFwKwAB1wI033ljh7De/+U2KSQAAAAAAAACobgrAAAAAAABALgVggFrus88+i0ceeSRxtv/++0f37t1TTgQAAAAAAABAdVpfATiTyaSUBAAAAAAAqC0UgAFqud///vdRWlqaOPvNb34TBQUFKScCAAAAAAAAoDop+AIAAAAAALkUgAFqsYULF8add96ZOOvSpUv069cv5UQAAAAAAAAAVLf1bQAGAAAAAAAaHgVggFrstttui+XLlyfOfvWrX0WjRo1STgQAAAAAAABAdVMABgAAAAAAcikAA9RSK1asiD/84Q+Js6222ipOOumklBMBAAAAAAAAUBMUgAEAAAAAgFwKwAC11MiRI+PLL79MnJ1zzjnRrFmzlBMBAAAAAAAAUBMUgAEAAAAAgFwKwAC1UGlpafz+979PnLVs2TLOOOOMlBMBAAAAAAAAUFMUgAEAAAAAgFwKwAC10OjRo2PmzJmJs9NOOy1at26dciIAAAAAAAAAaooCMAAAAAAAkEsBGKAWuvnmmxPPGzduHOedd17KaQAAAAAAAACoSZlMJt8RAAAAAACAWkYBGKCWefvtt+Oll15KnA0aNCi22267lBMBAAAAAAAAUJNsAAYAAAAAAHIpAAPUMiNGjKhwZvsvAAAAAAAAQP2jAAwAAAAAAORSAAaoRb744ot4+OGHE2cHHXRQ7LPPPiknAgAAAAAAAKCmKQADAAAAAAC5FIABapHbbrstVq1alTiz/RcAAAAAAACgflIABgAAAAAAcikAA9QSK1asiNtvvz1x1qlTp+jXr1/KiQAAAAAAAABIgwIwAAAAAACQSwEYoJZ46KGH4ssvv0ycnX322dGoUaOUEwEAAAAAAACQBgVgAAAAAAAglwIwQC2QyWTi5ptvTpxtuummMXTo0JQTAQAAAAAAAJCWTCaT7wgAAAAAAEAtowAMUAu8+OKL8cEHHyTOTjnllGjVqlXKiQAAAAAAAABIiw3AAAAAAABALgVggFpgxIgRiecFBQVx9tlnpxsGAAAAAAAAgFStrwBsQzAAAAAAADQ8CsAAeTZr1qx47rnnEmf9+vWLzp07p5wIAAAAAAAAgDTZAAwAAAAAAORSAAbIs9tvv73C39Z87rnnphsGAAAAAAAAgNQpAAMAAAAAALkUgAHyaMWKFXH33Xcnzvbcc8/o3r17yokAAAAAAAAASJsCMAAAAAAAkEsBGCCPHnnkkVi0aFHi7KyzzoqCgoKUEwEAAAAAAACQNgVgAAAAAAAglwIwQJ5kMpn405/+lDjbbLPN4qc//WnKiQAAAAAAAADIh0wmk+8IAAAAAABALaMADJAnr7/+ekyZMiVxNnjw4GjRokXKiQAAAAAAAADIBxuAAQAAAACAXArAAHlS0fbfiIgzzzwzxSQAAAAAAAAA5JMCMAAAAAAAkEsBGCAPFixYEI8++mjirLi4OHbeeeeUEwEAAAAAAACQLwrAAAAAAABALgVggDy48847o6SkJHF21llnpZwGAAAAAAAAgHxSAAYAAAAAAHIpAAOkrLS0NP785z8nzrbffvvo06dPyokAAAAAAAAAyCcFYAAAAAAAIJcCMEDKRo8eHbNnz06cnXHGGdGoUaOUEwEAAAAAAACQTwrAAAAAAABALgVggJTdfvvtiedFRUXxs5/9LOU0AAAAAAAAAORbJpPJdwQAAAAAAKCWUQAGSNEnn3wSL7zwQuJs4MCB0bZt25QTAQAAAAAAAJBvNgADAAAAAAC5FIABUnTXXXdV+JubzzzzzJTTAAAAAAAAAFAbKAADAAAAAAC5FIABUrJq1aq4++67E2d77rlnfP/73085EQAAAAAAAAC1gQIwAAAAAACQSwEYICVjxoyJefPmJc5OO+20KCgoSDkRAAAAAAAAALXB+grAmUwmpSQAAAAAAEBtoQAMkJK//vWviefNmzePn/70pymnAQAAAAAAAKC2sAEYAAAAAADIpQAMkILZs2fH888/nzgbNGhQbL755ukGAgAAAAAAAKDWUAAGAAAAAAByKQADpOCuu+6KTCaTODvttNNSTgMAAAAAAABAbVLR3ycDAAAAAAANlwIwQA1bvXp13HXXXYmz3XffPb7//e+nnAgAAAAAAACA2sQGYAAAAAAAIJcCMEANe/7552Pu3LmJs9NOOy0KCgpSTgQAAAAAAABAbaIADAAAAAAA5FIABqhhd9xxR+J5s2bN4oQTTkg5DQAAAAAAAAC1jQIwAAAAAACQSwEYoAb95z//ieeeey5xNnDgwGjdunXKiQAAAAAAAACobRSAAQAAAACAXArAADVo5MiRFf5F7WmnnZZyGgAAAAAAAABqIwVgAAAAAAAglwIwQA0pKyuLkSNHJs5222236NatW8qJAAAAAAAAAKiNFIABAAAAAIBcCsAANeSll16KTz/9NHF26qmnRkFBQbqBAAAAAAAAAKiVMplMviMAAAAAAAC1jAIwQA2paPtvkyZN4sQTT0w5DQAAAAAAAAC1lQ3AAAAAAABALgVggBqwZMmSeOKJJxJnffv2jS233DLlRAAAAAAAAADUVgrAAAAAAABALgVggBrw2GOPxYoVKxJnQ4YMSTkNAAAAAAAAALWZAjAAAAAAAJBLARigBowcOTLxfOutt44jjjgi5TQAAAAAAAAA1GYKwAAAAAAAQC4FYIBqNn369Jg8eXLi7MQTT4zGjRunnAgAAAAAAACA2kwBGAAAAAAAyKUADFDN7rnnngpnQ4YMSS8IAAAAAAAAAHWCAjAAAAAAAJBLARigGpWWlsZ9992XODvggANit912SzkRAAAAAAAAALVdJpPZqDkAAAAAAFD/KAADVKMXXnghPv/888SZ7b8AAAAAAAAAJLEBGAAAAAAAyKUADFCNRo4cmXjerFmzOPbYY1NOAwAAAAAAAEBdoAAMAAAAAADkUgAGqCaLFi2KZ555JnH24x//ODbbbLOUEwEAAAAAAABQFygAAwAAAAAAuRSAAarJww8/HCUlJYmzIUOGpJwGAAAAAAAAgLpCARgAAAAAAMilAAxQTe6///7E8+233z4OO+ywlNMAAAAAAAAAUFcoAAMAAAAAALkUgAGqwccffxyvvfZa4uzkk0+OwkL/cwsAAAAAAABAMgVgAAAAAAAgl0YaQDV44IEHKpydeOKJKSYBAAAAAAAAoK7JZDL5jgAAAAAAANQyCsAAGymTyVRYAD7ggAOiS5cuKScCAAAAAAAAoC6xARgAAAAAAMilAAywkf71r3/FrFmzEmcnnHBCymkAAAAAAAAAqGsUgAEAAAAAgFwKwAAbqaLtv40bN45BgwalnAYAAAAAAACAukYBGAAAAAAAyKUADLARSkpK4tFHH02cHXnkkdG2bduUEwEAAAAAAABQ1ygAAwAAAAAAuRSAATbC2LFjY+HChYmzE044IeU0AAAAAAAAANRFCsAAAAAAAEAuBWCAjfDAAw8knm+66abRt2/flNMAAAAAAAAAUBcpAAMAAAAAALkUgAE20Ndffx3PPvts4uyYY46J5s2bp5wIAAAAAAAAgLook8nkOwIAAAAAAFDLKAADbKAnn3wyVq5cmTg74YQTUk4DAAAAAAAAQF1lAzAAAAAAAJBLARhgA91///2J59tuu20ccsghKacBAAAAAAAAoK5aXwHYhmAAAAAAAGh4FIABNsDs2bNj0qRJibPjjz8+GjVqlG4gAAAAAAAAAOosG4ABAAAAAIBcCsAAG+CRRx6pcHbiiSemmAQAAAAAAACAuk4BGAAAAAAAyKUADLABKioA77nnnrHHHnuknAYAAAAAAACAukwBGAAAAAAAyKUADFBFH330Ubz99tuJs+OPPz7lNAAAAAAAAADUdQrAAAAAAABALgVggCp69NFHK5wNGjQoxSQAAAAAAAAA1AeZTCbfEQAAAAAAgFpGARigCjKZTDz88MOJsx/84AfRqVOndAMBAAAAAAAAUOfZAAwAAAAAAORSAAaogvfffz+mTZuWODv22GNTTgMAAAAAAABAfaAADAAAAAAA5FIABqiCRx55JPG8oKAgjjnmmJTTAAAAAAAAAFAfKAADAAAAAAC5FIABKimTyVRYAD7kkEOiffv2KScCAAAAAAAAoD5QAAYAAAAAAHIpAANU0ptvvhmzZs1KnB177LEppwEAAAAAAACgvigtLc13BAAAAAAAoJZRAAaopIq2/zZq1Ch+8pOfpJwGAAAAAAAAgPrCBmAAAAAAACCXAjBAJZSVlcVjjz2WOOvVq1dsueWWKScCAAAAAAAAoL5QAAYAAAAAAHIpAANUwuTJk2POnDmJs2OPPTblNAAAAAAAAADUF5lMRgEYAAAAAABYiwIwQCU88sgjiedFRUXRv3//dMMAAAAAAAAAUG9kMpl8RwAAAAAAAGohBWCA9Vi9enU8/vjjibOjjjoqNt9883QDAQAAAAAAAFBvlJaW5jsCAAAAAABQCykAA6zHpEmTYv78+YmzQYMGpZwGAAAAAAAAgPqkrKxsvffYEgwAAAAAAA2PAjDAejzxxBOJ582bN48f/vCHKacBAAAAAAAAoD6pTAEYAAAAAABoeBSAAdahtLQ0nnrqqcRZnz59omXLliknAgAAAAAAAKA+KS0tzXcEAAAAAACgFlIABliHf/zjHzF//vzE2YABA1JOAwAAAAAAAEB9YwMwAAAAAACQRAEYYB2efPLJxPNmzZrFUUcdlXIaAAAAAAAAAOobBWAAAAAAACCJAjBABcrKyiosAB911FHRsmXLlBMBAAAAAAAAUN+UlpbmOwIAAAAAAFALKQADVOBf//pXfP7554mzn/zkJymnAQAAAAAAAKA+sgEYAAAAAABIogAMUIGKtv8WFRVFnz59Uk4DAAAAAAAAQH2kAAwAAAAAACRRAAZIkMlkKiwAFxcXx2abbZZyIgAAAAAAAADqo9LS0nxHAAAAAAAAaiEFYIAEU6ZMic8++yxxdswxx6ScBgAAAAAAAID6ygZgAAAAAAAgiQIwQIInnngi8bxx48bRt2/flNMAAAAAAAAAUF/ZAAwAAAAAACRRAAbIkclk4sknn0ycHXbYYbHFFluknAgAAAAAAACA+soGYAAAAAAAIIkCMECOf//73zFjxozE2THHHJNyGgAAAAAAAADqMwVgAAAAAAAgiQIwQI6Ktv8WFhZG//790w0DAAAAAAAAQL1WWlqa7wgAAAAAAEAtpAAMkOOJJ55IPD/kkEOibdu2KacBAAAAAAAAoD6zARgAAAAAAEiiAAywhqlTp8a0adMSZ8ccc0zKaQAAAAAAAACo7xSAAQAAAACAJArAAGt4+umnE88LCgriRz/6UbphAAAAAAAAAKj3SktL8x0BAAAAAACohRSAAdbwzDPPJJ5369Ytttlmm5TTAAAAAAAAAFDfVWYDcCaTSSEJAAAAAABQmygAA/z/Pv/883j99dcTZ/379083DAAAAAAAAAANQmUKwAAAAAAAQMPTON8BGoIPPvggpkyZEvPmzYvS0tJo06ZN7L777nHAAQdE48YN5z+CuXPnxj//+c/47LPPYsWKFdGqVavYeeed46CDDoqWLVvmOx7Es88+W+GsX79+KSYBAAAAAAAAoKEoLS3NdwQAAAAAAKAWajjt05RlMpkYOXJkXH/99fHRRx8l3tOmTZv4n//5n7jwwgujRYsWNZ6pU6dO8dlnn23w8xMnTowePXpU+bmXXnophg0bFpMmTUqcFxUVxaBBg+LKK6+MTp06bXA+2FhPP/104nnXrl2jS5cu6YYBAAAAAAAAoEGwARgAAAAAAEhSmO8A9dHixYvjiCOOiKFDh1ZY/o2IWLhwYVx99dWx5557xgcffJBiwnRkMpm44IILokePHhWWfyMiSkpK4v7774/dd989nnzyyfQCwhqWLFkSEyZMSJz1798/3TAAAAAAAAAANBg2AAMAAAAAAEkUgKvZihUr4ogjjohx48ZlnRcVFcXOO+8ce+yxx1rbfmfNmhWHHnpozJgxI82oNe7ss8+OG2+8MeusoKAgOnToEHvvvXdsueWWWbNly5bFoEGD4qmnnkozJkRExNixY2PVqlWJs379+qWcBgAAAAAAAICGwgZgAAAAAAAgSeN8B6hvzj///Hj99dfLrwsLC+OSSy6J8847L1q3bh0R/914+9BDD8X5558fX331VURELFiwIAYOHBhvvPFGNGrUqMZzbrXVVvHAAw9U6Znvfve7lb73sccei1tvvTXr7Cc/+Un89re/jS5dupSfvfjii3H++efHv//974j472+1Pfnkk+N73/tedOrUqUr5YGM8/fTTieft27ePfffdN90wAAAAAAAAADQYCsAAAAAAAEASBeBq9OGHH8Zf//rXrLMHHnggjjvuuKyzoqKiGDx4cOy3335x0EEHxeLFiyMi4u2334777rsvhgwZUuNZmzVrFr169aqRd5eUlMRvfvObrLMzzjgjbrvttigoKMg679mzZ7z88svRq1evePPNNyMi4ptvvokrrrgi7r333hrJB7lKSkriueeeS5z17ds3CgstSwcAAAAAAACgZpSWluY7AgAAAAAAUAtptVWjK664IusvZU488cS1yr9r+s53vhM33XRT1tnw4cNj1apVNZYxDXfddVd8+umn5dddunSJm2++ea3y7/+z2Wabxb333htFRUXlZw8++GB8+OGHNR0VIiLipZdeiq+//jpx1r9//3TDAAAAAAAAANCg2AAMAAAAAAAkUQCuJl999VWMGjWq/LqgoCCGDRu23ueGDBkSHTt2LL/+7LPPYvz48TURMTV33nln1vVFF10UzZo1W+czXbt2jUGDBpVfl5aWxsiRI2skH+R65plnEs833XTT6NGjR7phAAAAAAAAAGhQFIABAAAAAIAkCsDVZMyYMbF69ery6x49ekTnzp3X+1xhYWEMGTIk6+zpp5+u7nipmTNnTrz11lvl1y1btoyBAwdW6tmhQ4dmXVdUyoTqlMlkKvzv2tFHHx1NmzZNOREAAAAAAAAADUlpaWm+IwAAAAAAALWQAnA1GTNmTNb14YcfXulni4uLs65Hjx5dLZnyIffncOCBB0aLFi0q9eyBBx4Ym2yySfn19OnT4+OPP67WfJDrrbfeijlz5iTO+vXrl3IaAAAAAAAAABoaG4ABAAAAAIAkCsDV5J133sm67tatW6Wf3WeffbK2jH7++eexYMGC6oqWqo35OTRu3Dj233//db4PqltFG7ebNGkSRx99dLphAAAAAAAAAGhwFIABAAAAAIAkCsDVYNWqVTFjxoyss65du1b6+aZNm8aOO+6YdTZt2rRqybY+X375Zbzzzjvx8ssvxzvvvBP/+c9/IpPJbPD7cnNX5eeQdH9aPwcarmeeeSbxvEePHrHZZpulnAYAAAAAAACAhqa0tDTfEQAAAAAAgFqocb4D1AezZs2K1atXl183b948ttxyyyq9o0OHDjF16tTy6+nTp0f37t2rLWOu+fPnR9euXRMLtltssUUcfPDBcfzxx8dPfvKTaNSoUaXfO3369KzrDh06VClX7v2574Pq9Mknn8R7772XOOvfv3+6YQAAAAAAAABokGwABgAAAAAAktgAXA3mz5+fdb3ttttW+R25z+S+s7qtWLGiwu26ixYtimeeeSYGDRoUu+yyS7z00kuVfu+CBQuyrrfbbrsq5Ur750DDNnr06Apnffv2TTEJAAAAAAAAAA2VDcAAAAAAAEASG4CrwdKlS7OuW7RoUeV35D6T+858mTlzZvTs2TN+97vfxTnnnLPOe1esWLHWX0pV9WdRUz+H+fPnr1VOXp8ZM2ZUy7epvSoqAO+9995VLq8DAAAAAAAAwIaozAbgTCaTQhIAAAAAAKA2UQCuBrkl1WbNmlX5Hc2bN1/nO6tLq1at4sgjj4wjjjgivvvd78YOO+wQrVq1iuXLl8fnn38ekydPjpEjR8Y//vGP8mdKS0vjvPPOi6222iqOPfbYCt+dlLmqP4ua+jncdtttMXz48Gp5F/XD0qVLY9KkSYmzH/7wh+mGAQAAAAAAAKDBqkwBGAAAAAAAaHgUgKvBt99+m3VdVFRU5Xc0bdo063rFihUblSnJjTfeGEcddVS0bNlyrVmrVq2iVatWseuuu8Ypp5wSTz31VJxyyimxePHiiPjvb5IdOnRo9OjRI7beeuvE9+f+HCKq/rNI4+cAERHjx4+PkpKSxFnv3r1TTgMAAAAAAABAQ1VaWprvCAAAAAAAQC1UmO8A1eHcc8+NgoKCGv9n2LBhid/P3XJbUalwXVauXLnOd1aHAQMGJJZ/k/zoRz+K559/Pmsj7/Lly+Oaa66p8JmkzFX9WaTxc4CIiNGjRyeeb7XVVrHPPvuknAYAAAAAAACAhsoGYAAAAAAAIIkNwNUgt1SbtAl3fXI33Va2qFuTvv/978cFF1wQw4cPLz976KGH4pZbbonCwrW740mZv/322yqVeGvq53DmmWfGgAEDqvTMjBkzon///tXyfWqXsrKyeO655xJnvXv3TvzvNwAAAAAAAADUBAVgAAAAAAAgiQJwNcgtqS5btqzK78h9pjYUgCMizjnnnLj66qujtLQ0IiIWLVoUb775Zuy///5r3du8efNo1KhR+b0R//1zbb755pX+Xk39HNq1axft2rWrlndR97399tsxb968xFnv3r1TTgMAAAAAAABAQ7bmv2cBAAAAAADw/9SLAnDv3r1jyy23rPHvdO/ePfE8t1g6d+7cKr8795naUlZt3bp17L333vHGG2+Un02fPj2xABwR0bZt2/jiiy/Kr+fMmRPbbrttpb9XW38O1C9jxoxJPG/SpEkUFxennAYAAAAAAACAhswGYAAAAAAAIEm9KAAXFxfntbTXuXPnaNy4caxevToiIlasWBELFiyItm3bVvods2fPzrreddddqzXjxujQoUNWAXjBggUV3rvLLrtkFYBnz54dBxxwQKW/VZt/DtQfo0ePTjzv0aNHbLrppimnAQAAAAAAAKAhUwAGAAAAAACSFOY7QH3QpEmT2HHHHbPOpk6dWunnV65cGbNmzco6q03F1yZNmmRdr1q1qsJ7c3NX5ecQETFt2rR1vg821hdffJFVaF9T7969U04DAAAAAAAAQENXWlqa7wgAAAAAAEAtpABcTfbaa6+s68mTJ1f62SlTpsTKlSvLr7fZZpto165ddUXbaGtu9I2IdW423pifw+rVq+P1119f5/tgYz3//PMVzvr06ZNiEgAAAAAAAACwARgAAAAAAEimAFxNcouD48aNq/Szuff+8Ic/rJZM1WHlypVrbUvt0KFDhffnblCdPHlyLFu2rFLfevXVV2P58uXl1zvvvHPsvPPOVUgL6zd69OjE81122WWtTd4AAAAAAAAAUNMUgAEAAAAAgCQKwNXk6KOPjsaNG5dfT5o0KWbNmrXe5zKZTNxzzz1ZZ/369avueBvskUceySrlNm3aNA488MAK7+/QoUN873vfK79eunRpPPbYY5X61l133ZV1XZt+DtQPK1eujBdeeCFxZvsvAAAAAAAAAPlQWlqa7wgAAAAAAEAtpABcTbbYYovo379/+XUmk4lhw4at97m77747Pv300/Lrjh07Rq9evao/4Ab44osv4pJLLsk6O/zww2OTTTZZ53NDhw7Nur7uuuvi22+/Xecz06ZNi0cffbT8urCwMAYPHly1wLAer7zySixdujRxpgAMAAAAAAAAQD7YAAwAAAAAACRRAK5Gw4cPj8LC//uR3n///fHwww9XeP/UqVPjV7/6VdbZZZddFkVFRev8zqeffhoFBQVZ/6xZIs41b968uOKKK+Krr76q3B/k///GkUceGXPnzi0/KygoqFSp+dRTT43tt9++/Pqjjz6K8847LzKZTOL9S5YsiZNOOilKSkrKz44//vjo2rVrpfNCZYwePTrxfLPNNlvnZmsAAAAAAAAAqCk2AAMAAAAAAEkUgKtR165d42c/+1nW2QknnBCXX355Vvl21apVcc8998RBBx0UixcvLj/fc8894+STT672XCtXrowrr7wytt9++/jpT38ao0aNis8//zzx3hkzZsSll14ae+21V7z77rtZs3POOSf23nvv9X6vqKgorrvuuqyzP//5zzFw4MD4+OOPs84nTJgQBx98cLz55pvlZy1btowrr7yysn88qJRMJlNhAfiII46IJk2apJwIAAAAAAAAAGwABgAAAAAAkjXOd4D65uabb4633nqrvNBaVlYWV111VVx//fWxww47RNOmTWPWrFmxdOnSrOe23HLLePzxx6Nx45r7j2Tp0qXx0EMPxUMPPRQREW3atIl27dpFq1atYsWKFTFv3rxYsGBB4rMDBgyI3/3ud5X+1nHHHRevvPJK3H777eVnTzzxRDz55JPRoUOHaNu2bXz22Wfx5ZdfZj1XWFgYI0eOjB122GED/oRQsRkzZsTMmTMTZ3369Ek5DQAAAAAAAAD8lwIwAAAAAACQRAG4mm2yySbx97//PQYMGBATJkwoPy8pKYnp06cnPtOpU6d49tlnY+edd04rZkRELFy4MBYuXLjOe5o2bRrXXnttnHfeeVFQUFCl9996663RrFmzuPnmm8vPMplMzJ49O2bPnr3W/ZtsskmMHDkyjjnmmCp9Bypj7NixiecFBQVx5JFHppwGAAAAAAAAAP6rtLR0vfdkMpkUkgAAAAAAALVJYb4D1EdbbLFFjBs3Lu64447Yaaed1nnfxRdfHO+9917sscceNZZnq622iltuuSX69+8fW221VaWe6dixY1x66aUxa9asOP/886tc/o347zbf3//+9zFhwoQ4+OCDK7yvqKgofvrTn8b7778fAwcOrPJ3oDIqKgDvv//+0bZt25TTAAAAAAAAAMB/2QAMAAAAAAAksQG4hhQWFsapp54ap556arz33nvx1ltvxbx586K0tDTatGkTu+++exxwwAHRpEmTKr+7U6dOVfrNrs2bN4+zzz47zj777IiImDdvXkyfPj1mz54dX375ZSxfvjyKioqidevW0a5du9hvv/2iffv2Vc5VkUMPPTQOPfTQmDNnTkyePDlmz54d3377bWy66abRpUuXOOigg6JVq1bV9j3I9e2338bEiRMTZ7b/AgAAAAAAAJBPCsAAAAAAAEASBeAU7LHHHjW64beqttlmm9hmm21S/+52221nwy958corr8SKFSsSZ0cccUTKaQAAAAAAAADg/5SWluY7AgAAAAAAUAsV5jsAQE0bO3Zs4nnr1q1jv/32SzkNAAAAAAAAAPwfG4ABAAAAAIAkCsBAvVdRAbi4uDgaN7YIHQAAAAAAAID8UQAGAAAAAACSKAAD9drs2bNj6tSpibMjjzwy5TQAAAAAAAAAkK20tDTfEQAAAAAAgFpIARio1/7+979XODviiCNSTAIAAAAAAAAAa7MBGAAAAAAASKIADNRrY8eOTTzfc889o3379imnAQAAAAAAAIBsNgADAAAAAABJFICBemvVqlUxfvz4xNmRRx6ZchoAAAAAAAAAWJsNwAAAAAAAQBIFYKDe+te//hVLlixJnCkAAwAAAAAAAFAbKAADAAAAAABJFICBemvs2LGJ5y1atIgDDzww5TQAAAAAAAAAsLbS0tJ8RwAAAAAAAGohBWCg3qqoANyzZ88oKipKOQ0AAAAAAAAArM0GYAAAAAAAIIkCMFAv/e///m+89dZbibMjjzwy5TQAAAAAAAAAkEwBGAAAAAAASKIADNRLL7zwQoWzI444IsUkAAAAAAAAAFCx0tLSfEcAAAAAAABqIQVgoF4aO3Zs4vnOO+8cnTt3TjkNAAAAAAAAACSzARgAAAAAAEiiAAzUO2VlZRVuAD7yyCNTTgMAAAAAAAAAFVMABgAAAAAAkigAA/XOO++8E19++WXiTAEYAAAAAAAAgNqktLR0vfdkMpkUkgAAAAAAALWJAjBQ74wbNy7xvKioKA455JCU0wAAAAAAAABAxWwABgAAAAAAkigAA/XO+PHjE88PPPDA2GSTTVJOAwAAAAAAAAAVq8wGYAAAAAAAoOFRAAbqlRUrVsQrr7ySOCsuLk45DQAAAAAAAACsmw3AAAAAAABAEgVgoF559dVXY+XKlYmzXr16pZwGAAAAAAAAANZNARgAAAAAAEiiAAzUK+PGjUs8b926dey9994ppwEAAAAAAACAdSstLc13BAAAAAAAoBZSAAbqlfHjxyeeH3bYYdGoUaOU0wAAAAAAAADAutkADAAAAAAAJFEABuqNL7/8Mt5+++3EWXFxccppAAAAAAAAAGD9bAAGAAAAAACSKAAD9caECRMik8kkznr16pVyGgAAAAAAAABYPwVgAAAAAAAgiQIwUG+MGzcu8XyHHXaIHXfcMeU0AAAAAAAAALB+CsAAAAAAAEASBWCgXshkMhUWgG3/BQAAAAAAAKC2UgAGAAAAAACSKAAD9cLMmTPjs88+S5wVFxennAYAAAAAAAAAKkcBGAAAAAAASKIADNQL48ePTzwvKCiIww47LOU0AAAAAAAAAFA5CsAAAAAAAEASBWCgXhg3blzi+d577x1t2rRJOQ0AAAAAAAAAVI4CMAAAAAAAkEQBGKjzSktLY8KECYmz4uLilNMAAAAAAAAAQOUpAAMAAAAAAEkUgIE6b8qUKbF48eLEWa9evdINAwAAAAAAAABVoAAMAAAAAAAkUQAG6rzx48cnnjdr1iwOPPDAlNMAAAAAAAAAQOVVpgCcyWRSSAIAAAAAANQmCsBAnTdu3LjE84MPPjiaNWuWchoAAAAAAAAAqDwbgAEAAAAAgCQKwECdtmLFipg8eXLirLi4OOU0AAAAAAAAAFA1CsAAAAAAAEASBWCgTps8eXKUlJQkznr27JlyGgAAAAAAAACoGgVgAAAAAAAgiQIwUKdNnDgx8bx169ax1157pRsGAAAAAAAAAKpIARgAAAAAAEiiAAzUaRUVgA855JAoLPQ/cQAAAAAAAADUbgrAAAAAAABAEu04oM5aunRpvP7664mzww47LOU0AAAAAAAAAFB1CsAAAAAAAEASBWCgzvrHP/4Rq1evTpwdeuihKacBAAAAAAAAgKpTAAYAAAAAAJIoAAN11sSJExPP27ZtG9/5zndSTgMAAAAAAAAAVacADAAAAAAAJGmc7wAAG6qiAnCPHj2ioKAg5TQAAAAAAABQPWbOnBmvv/56zJkzJ0pKSqJ169ax6667Rrdu3aJZs2b5jgdUMwVgAAAAAAAgiQIwUCd9/fXXMWXKlMTZoYcemnIaAAAAAAAA2HhPP/10XHXVVfHWW28lzlu2bBmDBw+OK664IrbccsuU0wE1RQEYAAAAAABIUpjvAAAb4pVXXomysrLE2WGHHZZyGgAAAAAAANhwK1eujBNOOCF+9KMfVVj+jYhYunRp3HrrrdG1a9d4+eWXU0wI1CQFYAAAAAAAIIkCMFAnTZgwIfF8m222iZ133jnlNAAAAAAAALBhysrKYtCgQfHggw9mnTdq1Ch22GGH2GuvvWKzzTbLmi1YsCCOOuqo+Oc//5lmVKCGKAADAAAAAABJFICBOmnixImJ54ceemgUFBSknAYAAAAAAAA2zI033hjPPPNM1tkZZ5wRs2fPjlmzZsXbb78dixYtilGjRsX2229ffs/y5ctj4MCB8fXXX6cdGahmCsAAAAAAAEASBWCgzlm0aFG8++67ibNDDz005TQAAAAAAACwYRYuXBjXXHNN1tlvf/vbuP3226N9+/blZ4WFhfGjH/0oJk+eHJ06dSo/nzNnTvz+979PKy5QQxSAAQAAAACAJArAQJ3z0ksvRSaTSZwpAAMAAAAAAFBX3HDDDfHNN9+UX3fv3j1+85vfVHj/tttuG3feeWfW2c033xwLFy6ssYxAzVMABgAAAAAAkigAA3XOxIkTE887dOgQnTt3TjkNAAAAAAAAVF1ZWVmMHDky62zYsGFRUFCwzud69uwZBx98cPn1N998E4899liNZATSUZkCcEW/JBsAAAAAAKi/FICBOmfChAmJ54cddth6/4UIAAAAAAAAqA0mT54cCxYsKL/u3Llz9OjRo1LPDh06NOv66aefrsZkQJrKysryHQEAAAAAAKilFICBOmX+/PnxwQcfJM4OPfTQlNMAAAAAAADAhhkzZkzWdXFxcaV/2W1xcXHW9aRJk2LZsmXVlg1IT2W2/wIAAAAAAA2TAjBQp0yaNKnCmQIwAAAAAAAAdcU777yTdd2tW7dKP9u+ffvo1KlT+XVJSUlMnTq1mpIBaVIABgAAAAAAKqIADNQpEydOTDzv3LlzbL/99imnAQAAAAAAgA0zbdq0rOuuXbtW6fnc+3PfB9QNCsAAAAAAAEBFFICBOqWiDcC2/wIAAAAAAFBXrFixImbPnp111qFDhyq9I/f+6dOnb3QuIH0KwAAAAAAAQEUUgIE6Y/78+fHhhx8mzhSAAQAAAAAAqCu+/PLLyGQy5ddNmjSJdu3+P/buPMrOus4T/6eWVJaqLCQhQkhIyEoWQkIAI2FzNNAKCDOKttjTxKadsbGPo+Lu/CRR21GbkXbGwe5pEdBunRaXlgY3kMPSiWwhQELWSiWkCcGEQEL22u7vD4/VuZXnqbq3UvXce6ter3M4p5/P9z7P847a/HPzvp9xRT3jtNNOy7vetWtXr2QDsqUADAAAAAAApKktdQCAQj366KOpZ5dcckmGSQAAAAAAAKDnDhw4kHc9bNiwqKqqKuoZ9fX1XT6zJ3bt2hW7d+8u6p7GxsYTfi8MZArAAAAAAABAGgVgoGI88sgjifMpU6bEhAkTMk4DAAAAAAAAPdO5rDtkyJCinzF06NAun9kTt912WyxfvvyEnwMUTgEYAAAAAABIU13qAACFSisAX3zxxRknAQAAAAAAgJ47cuRI3nVdXV3Rzxg8eHDe9eHDh08oE1AaCsAAAAAAAEAaBWCgIuzduzeeffbZxDMFYAAAAAAAACpJ542/zc3NRT/j6NGjXT4TqAwKwAAAAAAAQJraUgcAKMSKFSsil8slnikAAwAAAAAAUEkaGhryrjtvBC5E542/nZ/ZEzfeeGNce+21Rd3T2NgY11xzzQm/GwYqBWAAAAAAACCNAjBQER555JHE+fjx42PKlCkZpwEAAAAAAICe61zWPXToUORyuaiqqir4GQcPHuzymT0xbty4GDdu3Ak/ByicAjAAAAAAAJCmutQBAAqRVgC++OKLi/qLEAAAAAAAAFBqY8eOzfuOq6WlJXbt2lXUM3bs2JF3rbgLlUkBGAAAAAAASKMADJS9gwcPxlNPPZV4dvHFF2ecBgAAAAAAAE7M0KFD4/TTT8+bbd++vahndP78mWeeecK5gOwpAAMAAAAAAGkUgIGy99hjj0Vra2vimQIwAAAAAAAAlahzYXfdunVF3b9+/founwdUBgVgAAAAAAAgjQIwUPYeeeSRxPmYMWNi1qxZGacBAAAAAACAEzd//vy865UrVxZ8786dO2Pbtm0d14MGDYrZs2f3UjIgSwrAAAAAAABAGgVgoOylFYAvuuiiqK72rzEAAAAAAAAqz5VXXpl3/cADD0Qulyvo3l//+td5129+85ujoaGh17IB2Sm0AFzovx8AAAAAAID+Q3MOKGtHjx6Nxx57LPHs4osvzjgNAAAAAAAA9I4LLrggxo4d23Hd1NQUDz30UEH33n777XnXV199dW9GAzJkAzAAAAAAAJBGARgoa0899VQcOXIk8UwBGAAAAAAAgEpVXV0dS5cuzZstX7682y2fv/nNb+LRRx/tuB4+fHi8+93v7ouIQAYUgAEAAAAAgDQKwEBZe+SRRxLnw4cPj7PPPjvjNAAAAAAAANB7PvWpT0VDQ0PH9cMPPxxf/epXUz+/Y8eO+PM///O82X/7b/8tb5MwUFkUgAEAAAAAgDQKwEBZSysAL168OGprazNOAwAAAAAAAL1n7Nix8dnPfjZv9pnPfCZuvPHGeOmllzpm7e3t8c///M9xwQUXxLZt2zrm48ePj5tuuimruEAfUAAGAAAAAADSKAADZau1tTVWrFiReHbxxRdnnAYAAAAAAAB636c+9am48sor82bf+ta34vTTT4+pU6fGOeecE2PGjIn/+B//Y2zfvr3jM0OHDo0f/vCHMWrUqIwTA71JARgAAAAAAEijAAyUrWeffTb279+feKYADAAAAAAAQH9QXV0dd999d/zxH/9x3rytrS2amppi9erVsXfv3ryzMWPGxM9//vNYvHhxhkmBvqAADAAAAAAApFEABsrWI488kjgfMmRInHvuuRmnAQAAAAAAgL4xZMiQ+MEPfhA/+tGPYv78+amfq6+vjxtvvDHWrVsXl156aWb5gL6jAAwAAAAAAKSpLXUAgDRpBeBFixbF4MGDM04DAAAAAAAAfeud73xnvPOd74zGxsZ4/PHHY8eOHdHc3ByjRo2KWbNmxeLFi2PIkCGljgn0IgVgAAAAAAAgjQIwUJZyuVysWLEi8eyiiy7KOA0AAAAAAABkZ9q0aTFt2rRSxwAyoAAMAAAAAACkqS51AIAkmzdvjt27dyeeKQADAAAAAAAA0B8oAAMAAAAAAGkUgIGylLb9t7q6OhYtWpRxGgAAAAAAAADofQrAAAAAAABAGgVgoCylFYDnzZsXw4cPzzgNAAAAAAAAAPQ+BWAAAAAAACCNAjBQltIKwIsXL844CQAAAAAAAAD0DQVgAAAAAAAgjQIwUHb27NkTGzZsSDxTAAYAAAAAAACgv1AABgAAAAAA0igAA2Vn5cqVqWcKwAAAAAAAAAD0FwrAAAAAAABAGgVgoOysWLEicT5hwoQ4/fTTM04DAAAAAAAAAH2j0AJwLpfr4yQAAAAAAEC5UQAGyk5aAdj2XwAAAAAAAAD6ExuAAQAAAACANArAQFk5evRoPPnkk4lnCsAAAAAAAAAA9CcKwAAAAAAAQBoFYKCsPP3003H06NHEMwVgAAAAAAAAAPoTBWAAAAAAACCNAjBQVlasWJE4r6+vj3nz5mWcBgAAAAAAAAD6jgIwAAAAAACQRgEYKCtpBeBFixZFbW1txmkAAAAAAAAAoO8oAAMAAAAAAGkUgIGykcvlUgvAixcvzjgNAAAAAAAAAPQtBWAAAAAAACCNAjBQNhobG2P37t2JZwrAAAAAAAAAAPQ3CsAAAAAAAEAaBWCgbKRt/62uro5FixZlnAYAAAAAAAAA+pYCMAAAAAAAkEYBGCgbaQXgs846K0aMGJFxGgAAAAAAAADoWwrAAAAAAABAGgVgoGykFYAXL16ccRIAAAAAAAAA6HsKwAAAAAAAQBoFYKAsvPrqq7F+/frEMwVgAAAAAAAAAPojBWAAAAAAACCNAjBQFlauXJl6pgAMAAAAAAAAQH+kAAwAAAAAAKRRAAbKwooVKxLnp512Wpx++ukZpwEAAAAAAACAvqcADAAAAAAApFEABsrCb3/728T54sWLo6qqKuM0AAAAAAAAAND3FIABAAAAAIA0CsBAybW2tsaTTz6ZeHbBBRdknAYAAAAAAAAAsqEADAAAAAAApFEABkpu7dq1cejQocSzN73pTRmnAQAAAAAAAIBsFFoAzuVyfZwEAAAAAAAoNwrAQMk99thjifPBgwfH/Pnzsw0DAAAAAAAAABmxARgAAAAAAEijAAyUXFoB+Jxzzom6urqM0wAAAAAAAABANhSAAQAAAACANArAQMmlFYAXLVqUcRIAAAAAAAAAyI4CMAAAAAAAkEYBGCipV199NTZu3Jh49qY3vSnjNAAAAAAAAACQHQVgAAAAAAAgjQIwUFKPP/546pkNwAAAAAAAAAD0ZwrAAAAAAABAGgVgoKQee+yxxPn48eNjwoQJGacBAAAAAAAAgOwoAAMAAAAAAGkUgIGSSisAL1q0KKqqqjJOAwAAAAAAAADZUQAGAAAAAADSKAADJdPe3h6PP/544tmiRYsyTgMAAAAAAAAA2VIABgAAAAAA0igAAyWzcePG2LdvX+KZAjAAAAAAAAAA/Z0CMAAAAAAAkEYBGCiZ3/72t4nz2traWLhwYcZpAAAAAAAAACBbCsAAAAAAAEAaBWCgZB577LHE+dlnnx3Dhg3LOA0AAAAAAAAAZKu1tbXUEQAAAAAAgDKlAAyUTFoBeNGiRRknAQAAAAAAAIDsKQADAAAAAABpFICBkti/f3+sXbs28UwBGAAAAAAAAICBQAEYAAAAAABIowAMlMSTTz4ZuVwu8UwBGAAAAAAAAICBQAEYAAAAAABIowAMlMRjjz2WOB87dmxMnTo14zQAAAAAAAAAkD0FYAAAAAAAII0CMFASaQXgRYsWRVVVVcZpAAAAAAAAACB7CsAAAAAAAEAaBWAgc7lcLn77298mni1atCjjNAAAAAAAAABQGm1tbQV9LpfL9XESAAAAAACg3CgAA5lramqKV155JfFMARgAAAAAAACAgcIGYAAAAAAAII0CMJC5xx57LHFeVVUV5513XsZpAAAAAAAAAKA0FIABAAAAAIA0CsBA5h5//PHE+Zw5c2LEiBEZpwEAAAAAAACA0lAABgAAAAAA0igAA5l74oknEueLFi3KOAkAAAAAAAAAlI4CMAAAAAAAkEYBGMhUc3NzPPPMM4ln559/frZhAAAAAAAAAKCEFIABAAAAAIA0CsBAptasWRNHjx5NPDvvvPMyTgMAAAAAAAAApdPW1lbqCAAAAAAAQJlSAAYy9eSTTybOhw4dGnPmzMk4DQAAAAAAAACUjg3AAAAAAABAGgVgIFNPPPFE4nzBggUxaNCgjNMAAAAAAAAAQOkoAAMAAAAAAGkUgIFMpW0APu+88zJOAgAAAAAAAAClpQAMAAAAAACkUQAGMnPgwIFYt25d4tn555+fcRoAAAAAAAAAKC0FYAAAAAAAII0CMJCZp59+Otrb2xPPbAAGAAAAAAAAYKBRAAYAAAAAANIoAAOZefLJJxPno0aNimnTpmWcBgAAAAAAAABKq62trdQRAAAAAACAMqUADGTmiSeeSJyfd955UVVVlXEaAAAAAAAAACgtG4ABAAAAAIA0CsBAZtI2AJ933nkZJwEAAAAAAACA0mpvb4/29vZSxwAAAAAAAMqUAjCQid27d8fWrVsTz84///yM0wAAAAAAAABAabW1tZU6AgAAAAAAUMYUgIFMPPXUU6lnNgADAAAAAAAAMNC0trYW/NlcLteHSQAAAAAAgHKkAAxk4oknnkicn3baaTF+/PiM0wAAAAAAAABAaRVTAAYAAAAAAAYeBWAgE08++WTi3PZfAAAAAAAAAAaitra2UkcAAAAAAADKmAIw0OdyuVzqBuDzzz8/4zQAAAAAAAAAUHo2AAMAAAAAAF2pLXWAgeD555+PVatWxc6dO6OtrS3GjBkTc+fOjTe+8Y1RW+u/Avq/7du3x+7duxPPbAAGAAAAAAAAYCBSAAYAAAAAALqifdpHcrlc3HHHHfHVr341Nm3alPiZMWPGxF/8xV/Epz/96aivr+/TPFVVVb32rJtvvjmWLVuWer5s2bJYvnx5j59//fXXx5133tnj+yk/Tz75ZOrZueeem2ESAAAAAAAAACgPCsAAAAAAAEBXqksdoD/au3dvXH755XHDDTekln8jIvbs2RNf+tKXYt68efH8889nmPDE1NXVlToCFeaJJ55InM+YMSNGjRqVbRgAAAAAAAAAKAMKwAAAAAAAQFcUgHvZ4cOH4/LLL4/7778/b15XVxczZsyIs84667htv01NTfHmN785Ghsbs4zaY1deeWWpI1Bh0jYAn3feeRknAQAAAAAAAIDyoAAMAAAAAAB0pbbUAfqbj33sY3nbTqurq+Nzn/tcfPSjH42TTjopIiKam5vj+9//fnzsYx+L1157LSIidu/eHe9+97vjySefjJqaml7P1bmQXKhvfvOb8bOf/azjesGCBTFv3ryinnHLLbfE2WefXfDnx48fX9TzKW9tbW3x1FNPJZ6df/75GacBAAAAAAAAgPKgAAwAAAAAAHRFAbgXbdiwIf7+7/8+b/YP//AP8d73vjdvVldXF0uXLo3zzjsvLrzwwti7d29ERKxevTq++93vxvvf//5ez/bWt7616Hva29uPy7J06dKin7Nw4cK49NJLi76P/mHjxo1x4MCBxDMbgAEAAAAAAAAYqNra2kodAQAAAAAAKGPVpQ7Qn9x88815X8785//8n48r/x5rzpw5ccstt+TNli9fHi0tLX2WsRgPPPBAvPjiix3XgwYNiuuuu66EiahEx27EPlZtbW3Mnz8/2zAAAAAAAAAAUCZsAAYAAAAAALqiANxLXnvttfjJT37ScV1VVRXLli3r9r73v//9MWnSpI7rF154IR544IG+iFi0O++8M+/6yiuvjLFjx5YmDBVr1apVifO5c+fG0KFDM04DAAAAAAAAAOVBARgAAAAAAOiKAnAvue+++/K+mLn00ktjypQp3d5XXV0d73//+/Nm//zP/9zb8Yr2+uuvH5dj6dKlJclCZUsrAJ933nkZJwEAAAAAAACA8qEADAAAAAAAdEUBuJfcd999edeXXXZZwfcuWbIk7/ree+/tlUwn4p/+6Z/i8OHDHdfjxo2Lt7/97SVMRCVqbW2NZ555JvFs4cKF2YYBAAAAAAAAgDKiAAwAAAAAAHRFAbiXdC45XnDBBQXfu3Dhwhg8eHDH9UsvvRS7d+/urWg9ctddd+Vdv+9974va2toSpaFSbdiwIa9Ifqxzzjkn4zQAAAAAAAAAUD4UgAEAAAAAgK5odPaClpaWaGxszJvNnj274PsHDx4cU6dOjXXr1nXM1q9fHyeffHKvZSxGY2NjrFixIm+2dOnSE3rm0aNHo6mpKfbs2RODBg2KMWPGxPjx42PYsGEn9FzK26pVqxLntbW1cdZZZ2WcBgAAAAAAAADKR1tbW6kjAAAAAAAAZUwBuBc0NTXl/Srr0KFDY+zYsUU9Y+LEiXkF4I0bN8bFF1/caxmLceedd+Zdn3POOTFv3rweP+9DH/pQNDU1xZEjR/LmtbW1sXDhwnjb294WN954Y8kKz/SdtALw3LlzY8iQIRmnAQAAAAAAAIDyUcwG4Fwu14dJAAAAAACAclRd6gD9wa5du/KuTzvttKKf0fmezs/MSi6Xi+9973t5sxPd/rtu3brjyr8Rv/8i6/HHH49ly5bFpEmT4vOf/7xft+1nnn766cT5woULM04CAAAAAAAAAOWlmAIwAAAAAAAw8NgA3AsOHDiQd11fX1/0Mzrf0/mZWXnwwQdj+/btHdd1dXVx3XXX9fl7Dx8+HF/84hfj0UcfjX/5l3+JhoaGXn3+rl27Yvfu3UXd09jY2KsZBpq2trZYvXp14pkCMAAAAAAAAAADnQIwAAAAAADQFQXgXtC5rDtkyJCinzF06NAun5mVO++8M+/6yiuvjDFjxhT9nKqqqnjTm94UV1xxRZx//vkxa9asGD16dFRXV8eePXvi6aefjnvvvTfuuuuuvO3ADz30UPzxH/9x/OxnP4uampoT/eN0uO2222L58uW99jy6t3Hjxjh06FDimQIwAAAAAAAAAAOdAjAAAAAAANCV6lIH6A+OLbBG/H5rbrEGDx6cd3348OETytQT+/fvj5/85Cd5s6VLlxb9nMsuuyw2bNgQK1asiM9+9rPx1re+NU477bQYOnRoDB48OMaPHx9XXnll/O3f/m1s3rw5Fi9enHf/fffdF7fddtuJ/FEoA6tWrUqc19TUxLx58zJOAwAAAAAAAADlRQEYAAAAAADoSr8oAH/kIx+JqqqqPv9n2bJlie/vvPG3ubm56D/D0aNHu3xmFu6+++68ja1veMMb4m1ve1vRz7ngggtixowZBX12woQJ8cADD8Sb3vSmvPmXvvSl1O2xVIa0AvCcOXNK8r9vAAAAAAAAACgnbW1tpY4AAAAAAACUsdpSB+gPGhoa8q47bwQuROeNv52fmYW77ror7/p973tf1Nb2/f9EhgwZEt/97ndj1qxZHb9uu2vXrvj1r38d11xzTa+848Ybb4xrr722qHsaGxt77f0DUVoBeOHChRknAQAAAAAAAIDyYwMwAAAAAADQFQXgXtC5rHvw4MGin9H5nqwLwE1NTfHoo4/mzZYuXZrZ+6dNmxbveMc74ic/+UnHrDcLwOPGjYtx48b1yrPoXltbW6xevTrxTAEYAAAAAAAAABSAAQAAAACArvWLAvAVV1wRY8eO7fP3XHzxxYnzzsXSHTt2FP3szvdkXVa96667IpfLdVyfc845cdZZZ2Wa4S1veUteAXjjxo2Zvp/es3nz5tQivAIwAAAAAAAAACgAAwAAAAAAXesXBeAlS5bEkiVLSvb+KVOmRG1tbccXM4cPH47du3fHySefXPAztm/fnnd95pln9mrGruRyufjud7+bN8ty++8fTJw4Me969+7dmWegd6xatSpxXlNTE2effXbGaQAAAAAAAACg/CgAAwAAAAAAXakudYD+YNCgQTF16tS82bp16wq+/+jRo9HU1JQ3y7IA/PDDD8e2bds6ruvq6uK6667L7P1/MGjQoLzrlpaWzDPQO9IKwLNnz46hQ4dmnAYAAAAAAAAAyo8CMAAAAAAA0BUF4F4yf/78vOuVK1cWfO+qVavi6NGjHdennnpqjBs3rreidevOO+/Mu77qqqtizJgxmb3/D15++eW862I2KFNe0grACxcuzDgJAAAAAAAAAJQnBWAAAAAAAKArCsC95Morr8y7vv/++wu+t/Nnr7rqql7JVIiDBw/Gj3/847zZ0qVLM3v/sf71X/8173rixIklycGJaW9vj9WrVyeeKQADAAAAAAAAwO+1tbWVOgIAAAAAAFDGFIB7ydvf/vaora3tuH7ooYeiqamp2/tyudxxG3ivvvrq3o6X6kc/+lEcOHCg4/qUU06JP/qjP8rs/X+wd+/e44rIb3nLWzLPwYnbvHlz7N+/P/HsnHPOyTgNAAAAAAAAAJQnG4ABAAAAAICuKAD3ktGjR8c111zTcZ3L5WLZsmXd3ved73wntm3b1nE9adKkeOtb39r7AVPcddddedfve9/78orMWfn4xz8ee/fu7biuq6uLt73tbZnn4MStWrUqcV5dXR3z58/PNgwAAAAAAAAAlCkFYAAAAAAAoCsKwL1o+fLlUV397/+Rfu9734sf/OAHqZ9ft25dfPzjH8+b/X//3/8XdXV1Xb5n27ZtUVVVlffPsSXiQr3wwgvx0EMP5c2WLl1a9HOO9ZWvfCW1AJqktbU1brrpprj99tvz5h/84Afj1FNPPaEslMbTTz+dOJ81a1YMGzYs4zQAAAAAAAAAUJ4UgAEAAAAAgK4oAPei2bNnx5//+Z/nzf7kT/4kPv/5z8drr73WMWtpaYk777wzLrzwwrytt/PmzYvrr78+q7hx1113RS6X67heuHBhzJ0794Se+ctf/jLOPffcWLx4cXzjG9+ItWvXJn5htW/fvvjBD34Q5513Xnz961/PO5s6dWp8/vOfP6EclE5aAXzhwoUZJwEAAAAAAACA8qUADAAAAAAAdKW21AH6m1tvvTWefvrpeOqppyIior29Pb74xS/GV7/61TjjjDNi8ODB0dTUFAcOHMi7b+zYsXH33XdHbW12/5V897vfzbs+0e2/x1q5cmWsXLkyIiIGDx4cEyZMiJEjR0ZNTU3s2bMntm3bFu3t7cfdd8opp8QvfvGLGDNmTK9lITvt7e2pG4AVgAEAAAAAAADg3xVTAD72B94BAAAAAICBQQG4lw0bNix+9atfxbXXXhsPPvhgx7y5uTk2btyYeM/kyZPjnnvuiRkzZmQVMx599NHYsmVLx3VdXV1cd911ffKuo0eP5r0rzdvf/va44447Yty4cX2Sg763ZcuWeP311xPPFIABAAAAAAAA4N+1tbWVOgIAAAAAAFDGqksdoD8aPXp03H///fF//+//jWnTpnX5uc9+9rOxZs2aOOusszJMGHHXXXflXV911VUxevToE37u5z73ufjgBz8Yc+bMiZqamm4/39DQENdee208/PDDcd999yn/Vri07b/V1dUxf/78bMMAAAAAAAAAQBkrZgMwAAAAAAAw8NgA3Eeqq6vjAx/4QHzgAx+INWvWxNNPPx07d+6Mtra2GDNmTMydOzfe+MY3xqBBg4p+9uTJkyOXy51Qvm9/+9vx7W9/+4SekWTJkiWxZMmSiIg4dOhQrFu3LrZt2xY7d+6MAwcORHt7e4waNSpOOumkmD17dpx11lkFFYWpDKtXr06cz5w5M+rr6zNOAwAAAAAAAADlSwEYAAAAAADoigJwBs4666zMN/yWg2HDhsW5554b5557bqmjkJFnnnkmcb5gwYJsgwAAAAAAAABAmVMABgAAAAAAulJd6gBA/5DL5VI3ACsAAwAAAAAAAEA+BWAAAAAAAKArCsBAr3j55Zdj165diWfz58/PNgwAAAAAAAAAlDkFYAAAAAAAoCsKwECvSNv+G6EADAAAAAAAAACdtbW1lToCAAAAAABQxhSAgV7xzDPPJM4nTJgQY8eOzTYMAAAAAAAAAJQ5G4ABAAAAAICuKAADvSKtAGz7LwAAAAAAAAAcr6WlpdQRAAAAAACAMqYADPSK1atXJ84XLFiQcRIAAAAAAAAAKH8KwAAAAAAAQFcUgIETtn///mhsbEw8swEYAAAAAAAAAI6nAAwAAAAAAHRFARg4Yc8++2zqmQ3AAAAAAAAAAHA8BWAAAAAAAKArCsDACXvmmWcS5yNGjIjJkydnmgUAAAAAAAAAKkFra2upIwAAAAAAAGVMARg4YWkF4Pnz50dVVVW2YQAAAAAAAACgAtgADAAAAAAAdEUBGDhhq1evTpwvWLAg4yQAAAAAAAAAUBkUgAEAAAAAgK4oAAMnpKWlJdauXZt4Nn/+/GzDAAAAAAAAAECFKKYAnMvl+jAJAAAAAABQjhSAgROyfv36aG5uTjxTAAYAAAAAAACAZK2traWOAAAAAAAAlDEFYOCEPPPMM4nzQYMGxezZs7MNAwAAAAAAAAAVopgNwAAAAAAAwMCjAAyckLQC8Jw5c6Kuri7bMAAAAAAAAABQIRSAAQAAAACArigAAydk9erVifMFCxZknAQAAAAAAAAAKocCMAAAAAAA0BUFYKDHcrlc6gbg+fPnZ5oFAAAAAAAAACqJAjAAAAAAANAVBWCgx1544YXYu3dv4pkCMAAAAAAAAACka21tLXUEAAAAAACgjCkAAz2Wtv03IuLss8/OLggAAAAAAAAAVBgbgAEAAAAAgK4oAAM9llYAnjJlSowcOTLbMAAAAAAAAABQQRSAAQAAAACArigAAz22evXqxPmCBQsyTgIAAAAAAAAAlUUBGAAAAAAA6IoCMNBjaRuA58+fn2kOAAAAAAAAAKg0CsAAAAAAAEBXFICBHtmzZ09s37498UwBGAAAAAAAAADStbe3R3t7e6ljAAAAAAAAZUwBGOiRZ599NvVswYIFGSYBAAAAAAAAgMrS2tpa6ggAAAAAAECZUwAGeuS5555LnI8ZMybGjx+fcRoAAAAAAAAAqBwtLS2ljgAAAAAAAJQ5BWCgR9IKwGeffXZUVVVlnAYAAAAAAAAAKocCMAAAAAAA0B0FYKBH0grA8+bNyzgJAAAAAAAAAFQWBWAAAAAAAKA7CsBA0VpbW+P5559PPDv77LMzTgMAAAAAAAAAlaW1tbWoz+dyuT5KAgAAAAAAlCsFYKBojY2NceTIkcQzG4ABAAAAAAAAoGs2AAMAAAAAAN1RAAaK9txzzyXOq6urY/bs2RmnAQAAAAAAAIDKogAMAAAAAAB0RwEYKFpaAXjmzJkxZMiQjNMAAAAAAAAAQGVRAAYAAAAAALqjAAwULa0APG/evIyTAAAAAAAAAEDlUQAGAAAAAAC6owAMFE0BGAAAAAAAAAB6rrW1tdQRAAAAAACAMqcADBRl37598cILLySeKQADAAAAAAAAQPdsAAYAAAAAALqjAAwUZc2aNalnCsAAAAAAAAAA0D0FYAAAAAAAoDsKwEBRnnvuucT5yJEjY+LEiRmnAQAAAAAAAIDKowAMAAAAAAB0RwEYKEpaAXjevHlRVVWVcRoAAAAAAAAAqDytra2ljgAAAAAAAJQ5BWCgKF0VgAEAAAAAAACA7tkADAAAAAAAdEcBGChYe3t7rFmzJvFMARgAAAAAAAAACqMADAAAAAAAdEcBGCjYtm3b4sCBA4lnCsAAAAAAAAAAUBgFYAAAAAAAoDsKwEDBnnvuudSzuXPnZpgEAAAAAAAAACqXAjAAAAAAANAdBWCgYGkF4KlTp0ZDQ0PGaQAAAAAAAACgMrW2tpY6AgAAAAAAUOYUgIGCpRWA582bl3ESAAAAAAAAAKhcNgADAAAAAADdUQAGCqYADAAAAAAAAAAnTgEYAAAAAADojgIwUJCDBw9GY2Nj4pkCMAAAAAAAAAAUrtgCcC6X66MkAAAAAABAuVIABgry/PPPp36hqAAMAAAAAAAAAIWzARgAAAAAAOiOAjBQkOeeey5xPmzYsJgyZUrGaQAAAAAAAACgcrW2tpY6AgAAAAAAUOYUgIGCpBWAzzrrrKiu9q8SAAAAAAAAACiUDcAAAAAAAEB3tPaAgqQVgOfNm5dxEgAAAAAAAACobArAAAAAAABAdxSAgW7lcrnUAvDZZ5+dcRoAAAAAAAAAqGwKwAAAAAAAQHcUgIFu7dixI1577bXEMxuAAQAAAAAAAKA4CsAAAAAAAEB3FICBbq1Zsyb1bO7cuRkmAQAAAAAAAIDK19raWuoIAAAAAABAmVMABrq1du3axPmECRPipJNOyjgNAAAAAAAAAFQ2G4ABAAAAAIDuKAAD3Xr++ecT57b/AgAAAAAAAEDxFIABAAAAAIDuKAAD3UrbAKwADAAAAAAAAADFUwAGAAAAAAC6owAMdKmtrS3WrVuXeDZnzpyM0wAAAAAAAABA5VMABgAAAAAAuqMADHRp69atcfjw4cQzG4ABAAAAAAAAoHgKwAAAAAAAQHcUgIEurV27NnFeVVUVs2bNyjgNAAAAAAAAAFQ+BWAAAAAAAKA7CsBAl55//vnE+ZQpU6K+vj7jNAAAAAAAAABQ+Zqbm0sdAQAAAAAAKHMKwECX0jYAz507N+MkAAAAAAAAANA/KAADAAAAAADdUQAGupRWAJ4zZ07GSQAAAAAAAACgfyi2AJzL5fooCQAAAAAAUK4UgIFUzc3NsWHDhsQzG4ABAAAAAAAAoGdsAAYAAAAAALqjAAyk2rx5c7S2tiaeKQADAAAAAAAAQM+0tLSUOgIAAAAAAFDmFICBVM8//3zivLa2NmbOnJlxGgAAAAAAAADoH2wABgAAAAAAuqMADKRau3Zt4nzGjBlRV1eXcRoAAAAAAAAA6B8UgAEAAAAAgO4oAAOp0grAc+fOzTgJAAAAAAAAAPQfCsAAAAAAAEB3FICBVGkF4Dlz5mScBAAAAAAAAAD6DwVgAAAAAACgOwrAQKLDhw9HY2Nj4pkNwAAAAAAAAADQcwrAAAAAAABAdxSAgUQbNmyIXC6XeKYADAAAAAAAAAA9pwAMAAAAAAB0RwEYSLR27drE+eDBg2Pq1KkZpwEAAAAAAACA/qOlpaXUEQAAAAAAgDKnAAwkSisAz549O2pqajJOAwAAAAAAAAD9hw3AAAAAAABAdxSAgURpBeA5c+ZknAQAAAAAAAAA+hcFYAAAAAAAoDsKwECitALw3LlzM04CAAAAAAAAAP1HW1tbtLW1lToGAAAAAABQ5hSAgeO8/vrrsX379sQzBWAAAAAAAAAA6LmWlpZSRwAAAAAAACqAAjBwnHXr1qWeKQADAAAAAAAAQM81NzeXOgIAAAAAAFABFICB46xduzZx3tDQEKeffnrGaQAAAAAAAACg/7ABGAAAAAAAKIQCMHCctALwnDlzoqqqKuM0AAAAAAAAANB/2AAMAAAAAAAUQgEYOE5aAXju3LkZJwEAAAAAAACA/qUnBeBcLtcHSQAAAAAAgHKmAAwc5/nnn0+cKwADAAAAAAAAwImxARgAAAAAACiEAjCQZ8+ePfHyyy8nnikAAwAAAAAAAMCJUQAGAAAAAAAKoQAM5Fm3bl3q2Zw5czJMAgAAAAAAAAD9jwIwAAAAAABQCAVgIM/69esT56NGjYpTTjkl4zQAAAAAAAAA0L8oAAMAAAAAAIVQAAbypG0Anj17dlRVVWWcBgAAAAAAAAD6l5aWllJHAAAAAAAAKoACMJAnrQA8a9asjJMAAAAAAAAAQP9jAzAAAAAAAFAIBWAgz/r16xPns2fPzjgJAAAAAAAAAPQ/CsAAAAAAAEAhFICBDq+//nq8+OKLiWcKwAAAAAAAAABw4hSAAQAAAACAQigAAx3Stv9GKAADAAAAAAAAQG9QAAYAAAAAAAqhAAx0WLduXeK8vr4+Jk6cmHEaAAAAAAAAAOh/FIABAAAAAIBCKAADHdI2AM+aNSuqqqoyTgMAAAAAAAAA/U9aAbi2tjbjJAAAAAAAQDlTAAY6pG0Anj17dsZJAAAAAAAAAKB/amlpSZzX1dVlnAQAAAAAAChnCsBAh7QC8KxZszJOAgAAAAAAAAD9U9oGYAVgAAAAAADgWArAQEREHDp0KLZt25Z4ZgMwAAAAAAAAAPQOBWAAAAAAAKAQCsBARERs3Lgxcrlc4pkCMAAAAAAAAAD0DgVgAAAAAACgEArAQERErFu3LnE+ePDgOOOMMzJOAwAAAAAAAAD9U08KwGk/6A0AAAAAAPRfCsBARKQXgGfOnBk1NTUZpwEAAAAAAACA/imtADx48OCMkwAAAAAAAOVMARiIiIj169cnzmfPnp1xEgAAAAAAAADov1paWhLngwYNyjgJAAAAAABQzhSAgYhI3wA8a9asjJMAAAAAAAAAQP+VtgG4rq4u4yQAAAAAAEA5UwAG4ujRo9HY2Jh4ZgMwAAAAAAAAAPQeBWAAAAAAAKAQCsBAbN68Odra2hLPFIABAAAAAAAAoPcoAAMAAAAAAIVQAAZi/fr1ifOampqYNm1axmkAAAAAAAAAoP86evRo4lwBGAAAAAAAOJYCMBDr1q1LnE+fPt0XjAAAAAAAAADQi9IKwIMHD844CQAAAAAAUM4UgIHUAvDs2bMzTgIAAAAAAAAA/ZsCMAAAAAAAUAgFYCDWr1+fOJ81a1bGSQAAAAAAAACgf1MABgAAAAAACqEADANca2trbNy4MfHMBmAAAAAAAAAA6F0KwAAAAAAAQCEUgGGAa2pqiubm5sQzBWAAAAAAAAAA6F0KwAAAAAAAQCEUgGGAW7duXeK8qqoqZs6cmXEaAAAAAAAAAOjfFIABAAAAAIBCKADDALd+/frE+RlnnBFDhw7NOA0AAAAAAAAA9G8KwAAAAAAAQCEUgGGAS9sAPHv27IyTAAAAAAAAAED/pwAMAAAAAAAUQgEYBjgFYAAAAAAAAADIjgIwAAAAAABQCAVgGMDa29tjw4YNiWezZs3KOA0AAAAAAAAA9H9pBeAhQ4ak3pPL5foqDgAAAAAAUKYUgGEAe/HFF+PQoUOJZwrAAAAAAAAAAND7bAAGAAAAAAAKoQAMA1ja9t+IiDPPPDPDJAAAAAAAAAAwMCgAAwAAAAAAhVAAhgFs48aNifNTTjklRo4cmXEaAAAAAAAAAOj/FIABAAAAAIBCKADDAJa2Adj2XwAAAAAAAADofW1tbdHW1pZ4pgAMAAAAAAAcSwEYBjAFYAAAAAAAAADITtr23wgFYAAAAAAAIJ8CMAxgGzduTJzPnDkz4yQAAAAAAAAA0P8pAAMAAAAAAIVSAIYBav/+/bFjx47EMxuAAQAAAAAAAKD3KQADAAAAAACFUgCGASpt+2+EAjAAAAAAAAAA9AUFYAAAAAAAoFAKwDBApRWAhwwZEqeffnrGaQAAAAAAAACg/1MABgAAAAAACqUADAPUhg0bEuczZsyI6mr/agAAAAAAAACA3qYADAAAAAAAFErLDwaotALwmWeemXESAAAAAAAAABgYFIABAAAAAIBCKQDDALVx48bEuQIwAAAAAAAAAPQNBWAAAAAAAKBQCsAwALW1tcWmTZsSz2bOnJlxGgAAAAAAAAAYGLoqANfV1WWYBAAAAAAAKHcKwDAAvfDCC6lfKtoADAAAAAAAAAB9I+27+rq6uqiqqso4DQAAAAAAUM4UgGEA2rBhQ+rZjBkzMkwCAAAAAAAAAANHWgF48ODBGScBAAAAAADKXW2pAwDZ27hxY+J8woQJ0dDQkHEaAAAAAAAAKE/t7e3R2NgYa9asiZ07d8brr78eQ4cOjdGjR8esWbNiwYIFMWjQoF595549e2LFihWxZcuWOHjwYNTX18fUqVNj8eLFMWbMmF59F5A9BWAAAAAAAKBQCsAwAKVtAD7zzDMzTgIAAAAAAADl5eWXX44f//jH8etf/zoeeuiheP3111M/O3To0HjXu94VH/3oR2PBggUn9N5nn302Pv/5z8e9994b7e3tx53X1NTEFVdcEV/84hdj3rx5J/QuoHR6WgDO5XJ9EQcAAAAAAChj1aUOAGRPARgAAAAAAACOd/XVV8dpp50Wf/mXfxn33HNPl+XfiIjDhw/H9773vTj33HPjE5/4RDQ3N/fovd/4xjfi3HPPjXvuuSex/BsR0dbWFvfcc08sXLgw/vf//t89eg9Qel0VgKuqqjJOAwAAAAAAlDMbgGEA2rhxY+J85syZGScBAAAAAACA8rFixYrEAu6gQYNi/PjxcfLJJ8eRI0eiqakpDh061HHe3t4et9xyS2zatCl+/OMfR21t4V/Ff/3rX4+bbrrpuPmpp54a48ePj5deeil27tzZMW9tbY0Pf/jDkcvl4sMf/nCRf0Kg1Hq6ARgAAAAAABh4bACGAea1116L3/3ud4lnNgADAAAAAADA773hDW+IT3ziE/Gb3/wmXn/99di2bVs8+eSTsWbNmti7d2/cc889cdZZZ+Xdc88998SnP/3pgt+xcuXK+OQnP5k3u/TSS2PVqlXx0ksvxVNPPRUvvfRSPPnkk3HJJZfksnliRwABAABJREFUfe6mm26KJ554oud/QKAkFIABAAAAAIBC2QA8wLW2tsbjjz8ea9eujT179kRNTU2ceuqpsXDhwpgzZ06vvmvHjh3x29/+Nl544YU4fPhwjBgxImbMmBEXXnhhNDQ09Oq7SJe2/TdCARgAAAAAAADmzp0bN998c1xzzTWpm3wHDRoUV111VSxZsiSuvfbauPfeezvO/tf/+l/xX/7Lf4kZM2Z0+65PfOIT0dbW1nF91VVXxY9+9KOoq6vL+9y5554bv/71r+M//af/FPfdd19E/P673k984hPx8MMP9+SPCZSIAjAAAAAAAFAoBeA+0tTUFE888UQ8/vjj8cQTT8Tq1avj8OHDHeeXXHJJPPTQQyXLd+DAgfjKV74S3/rWt+LVV19N/MzMmTPjU5/6VCxdujSqqqp6/K6HH344li1blvrnrauri/e85z3xhS98ISZPntzj91CYtAJwfX19nHbaaRmnAQAAAAAAgPJx++23x1VXXRXV1dUFfX7IkCHx//7f/4szzzwzXnzxxYiIaGlpibvuuiv+6q/+qst7f/GLX8TKlSs7rseMGRO33377ceXfP6irq4vvfOc7MXv27NizZ09ERDzyyCNx//33x5IlSwrKC5SeAjAAAAAAAFCowr61pCD33HNPXHHFFXHyySfH1KlT473vfW/8zd/8TaxcuTKv/Ftqa9asiXnz5sVf/dVfpZZ/I35fFP2zP/uzeNvb3hb79u0r+j25XC4++clPxqWXXtpl2bm5uTm+973vxdy5c+PHP/5x0e+hOBs2bEicz5w584SK3gAAAAAAAFDprr766oLLv39QX18fH/7wh/Nmv/rVr7q979vf/nbe9Yc+9KE4+eSTu7xn3LhxceONN3b5HKC8KQADAAAAAACFUgDuRQ8++GD8/Oc/j1deeaXUUVJt3Lgx/sN/+A+xdevWvHlDQ0PMmzcvpk+fHoMGDco7+9WvfhVve9vb4siRI0W968Mf/nD89V//dd6sqqoqJk6cGOecc06MHTs27+zgwYPxnve8J376058W9R6Kk1YAPvPMMzNOAgAAAAAAAP3DRRddlHe9ffv2Lj9/9OjR40rCf/Znf1bQuzp/7he/+EU0NzcXdC9QegrAAAAAAABAoRSAM1JfX1/qCNHa2hrXXnttXkF59OjRcdddd8Wrr74azz77bGzatClefvnl+NznPpf3y9a//e1v45Of/GTB7/rhD38Y3/zmN/Nm73znO2Pjxo2xffv2WLVqVezevTseeOCBmDdvXsdn2tra4vrrr49t27b1/A9KlzZu3Jg4VwAGAAAAAACAnjnppJPyrvft29fl5x966KE4ePBgx/XMmTNj0qRJBb1r8uTJMX369I7r/fv3x8MPP1xEWqCUFIABAAAAAIBCKQD3gdGjR8fll18e//2///f42c9+Fjt37jyuDFsK3/nOd2LNmjUd1yeddFI8+uij8ad/+qd5W39Hjx4dX/rSl+J73/te3v3f+ta3YvPmzd2+p7m5OT71qU/lzT74wQ/G3XffnfdFdETEW97ylnjkkUfi3HPP7Zjt378/br755qL+bBSmpaUlGhsbE89mzpyZcRoAAAAAAADoH3bs2JF3PWbMmC4//8wzz+RdX3DBBUW9b/HixV0+DyhfR44cSZwrAAMAAAAAAJ0pAPeiD3zgA9HY2Bh79uyJX/7yl/HFL34x3vGOd8Qpp5xS6mjR3NwcX/rSl/Jmt9xyS8yePTv1nuuuuy7+5E/+pOO6tbU1li1b1u27br/99rwNvtOnT49bb701qqqqEj8/cuTIuOuuu6Kurq5j9o//+I+xYcOGbt9FcbZu3RotLS2JZzYAAwAAAAAAQM88+uijedczZszo8vPr16/Pu+7qe9sknT/f+XlA+UorAA8dOjTjJAAAAAAAQLlTAO5Fc+bMialTp5Y6RqJf/epX8W//9m8d15MnT473v//93d63bNmyvOLu3XffHfv27evynm9/+9t515/5zGdiyJAhXd4ze/bseM973tNx3dbWFnfccUe3+SjOxo0bE+dVVVXHbWcGAAAAAAAAutfW1hbf/e5382Zvf/vbu7yn8/d2EydOLOqdnT+f9j0gUH4OHz6cOFcABgAAAAAAOlMAHiB+9rOf5V2///3vT93Ie6ypU6fGJZdc0nHd0tISP//5z1M//+KLL8bTTz/dcd3Q0BDvfve7C8p4ww03dJmZE5e2VXnSpEm+TAQAAAAAAIAe+Lu/+7toamrquB40aFBcd911Xd6za9euvOsJEyYU9c7TTjuty+cB5SttA3B3P6wOAAAAAAAMPLWlDkA27rvvvrzryy67rOB7lyxZEg899FDH9b333hvvfe97C3rP4sWLo76+vqD3LF68OIYNGxaHDh2KiN//SvXmzZttpu1FaQXgM888M+MkAAAAAAAAUPm2bNkSn/70p/NmH/rQh7ot9B44cCDvutDvVNM+3/l5PbVr167YvXt3Ufc0Njb2yrthoLABGAAAAAAAKJQC8ADwu9/9Ll5++eWO68GDB8c555xT8P2LFy/Ou37mmWdSP9v57IILLij4PbW1tXH++efnlY2feeYZBeBetHHjxsS5AjAAAAAAAAAU59ChQ/Gud70r9u/f3zGbNGlSfOELX+j23s6F3WI3f3YuCvZWAfi2226L5cuX98qzgGQ2AAMAAAAAAIWqLnUA+t769evzrqdNmxZ1dXUF3z979uy868bGxmhtbS3oXZ3vLfZdnZ/HiUkrAM+cOTPjJAAAAAAAAFC5crlcXH/99Xk/kFxbWxv/+I//GMOHD+/2/s4FwGK+v434/Y8+HyttoyhQfhSAAQAAAACAQikADwCdS58TJ04s6v6TTz4574um5ubm2Lp1a5+8q/Pn0wqrFO/VV1+NV155JfFMARgAAAAAAIBS+8hHPhJVVVV9/s+yZctOOOtNN90UP/rRj/Jm3/jGN2Lx4sUF3d+56Nfc3FzU+48ePdrl84DylVbY77zZu7NcLtcXcQAAAAAAgDJWW+oA9L1du3blXU+YMKHoZ4wfPz6amprynjl9+vTjPrd79+4Tetdpp52Wd905Oz23efPm1LMZM2ZkmAQAAAAAAAAq11e+8pW49dZb82Y333xz3HjjjQU/o6GhIQ4dOtRxnbYRNE3nAmFDQ0NR96e58cYb49prry3qnsbGxrjmmmt65f0wEHS1AbiqqirjNAAAAAAAQDlTAB4ADhw4kHddX19f9DM639P5mRG//5K5ra3thN5VyHt6YteuXceVk7vT2NjYK+8uF2kF4GHDhsX48eMzTgMAAAAAAACV5+/+7u/iM5/5TN7swx/+cNFbhRsaGvJ+DPngwYNF3d/5871VAB43blyMGzeuV54FJOvpBmAAAAAAAGDgUQAeADqXaIcMGVL0Mzp/0ZRUzE2aFfuuQt7TE7fddlssX768V55VqTZt2pQ4nzFjhl8RBgAAAAAAoOSuuOKKGDt2bJ+/5+KLL+7Rfd///veP2/J7/fXXx9/8zd8U/axx48ZFU1NTx/WLL75Y1P07duw47nlAZehqAzAAAAAAAMCxFIAHgM5fHtXV1RX9jMGDB+ddJ/0ibdKXVMW+q5D30DNpBeDp06dnnAQAAAAAAACOt2TJkliyZEmpYyT62c9+Ftdff320t7d3zN75znfG7bff3qMf2505c2Y89thjHdfbt28v6v7Onz/zzDOLzgCURloB2AZgAAAAAACgs+pSB+gNH/nIR6KqqqrP/1m2bFmp/6g90vlXYpubm4t+xtGjR7t8Ztqs2HcV8h56pqsNwAAAAAAAAECyBx54IN7znvdEa2trx+zyyy+P73//+1FTU9OjZ3Yu7K5bt66o+9evX9/l84Dy1NbWFi0tLYln/n4EAAAAAADQmQ3AA0BDQ0PeddqvyXal8ybezs9Mmx05cqSoL6kKeU9P3HjjjXHttdcWdU9jY2Ncc801vfL+UsvlcrF58+bEMwVgAAAAAAAASLZixYq4+uqr837I+KKLLoqf/vSnUVdX1+Pnzp8/P+965cqVRefq6nlAeerq72vYAAwAAAAAAHSmADwAdC7RHjx4sOhndL4nqZg7dOjQqKmpiba2trz7Ro0a1avv6Ylx48bFuHHjeuVZlejll1+OAwcOJJ5Nnz494zQAAAAAAABQ/p5++um44oor4tChQx2zc889N+69994TLupdeumlUV9f3/H96KZNm+KFF16ISZMmdXvvtm3b8n78d/jw4XHppZeeUB4gG51/FP1YNgADAAAAAACd9YsC8BVXXBFjx47t8/dcfPHFff6OvtC5+Priiy8W/YyXXnqpy2f+wcknnxwvv/xy3rtOO+20gt+zY8eOgt5DcTZt2pR6ZgMwAAAAAAAA5Fu3bl1cfvnlsW/fvo7Z3Llz45e//GWMGDHihJ8/ZMiQuOyyy+KnP/1px+w73/lOLF++vNt7v/Od7+Rd/9Ef/dEJbSMGstPVBmAFYAAAAAAAoLN+UQBesmRJLFmypNQxytbMmTPzrrdv317U/bt27cr7Eqquri6mTJmS+q5jC8Dbt2+PN77xjQW/q3O2M888s6isJEsrAI8ePTrGjBmTcRoAAAAAAAAoX1u3bo0lS5bEK6+80jGbNm1a3H///b363doNN9yQVwD+P//n/8Rf/uVfxsknn5x6z65du+K222477jlAZehqA/CJbhYHAAAAAAD6n+pSB6DvdS7RbtmyJZqbmwu+f/369XnXU6dOjdra5O5453etW7eu4PckvUsBuHds3rw5cW77LwAAAAAAAPy7l156Kd761rfGSy+91DE7/fTT4ze/+U2ccsopvfquK664IhYtWtRxvWfPnrjhhhuipaUl8fPNzc1xww03xJ49ezpmF110UVx++eW9mgvoOzYAAwAAAAAAxegXG4Dp2imnnBKnnHJKx2beo0ePxqpVq+JNb3pTQfevWLEi73r+/Pmpn+18tnLlyoJztra2xhNPPFHwuyhc2gbg6dOnZ5wEAAAAAAAAytOhQ4fisssui6ampo5ZTU1NfPrTn45NmzalfueW5sILL+y20PfXf/3Xcckll0R7e3tERPzLv/xLXHbZZfE//+f/jHPOOafjc6tWrYqbbropHn744bxsX/va14rKBJRWVwXgoUOHdrkhGAAAAAAAGHgUgAeIK664Im6//faO6/vvv7/gAvD999+fd33VVVd1+Z5jrVy5Mg4ePBj19fXdvmfFihVx6NChjusZM2bYUNtL0v4ygv98AQAAAAAA4Pd27doVzz//fN6sra0tbrzxxh49b+vWrTF58uQuP3PhhRfG//gf/yM+9alPdcweeuihWLhwYYwfPz5OPfXUeOmll2Lnzp3H3fu1r30tb4MwUP66KvgOGTJEARgAAAAAAMhTXeoAZOMd73hH3vUdd9wRuVyu2/u2bNmS9yvSgwYNire//e2pn584cWIsWLCg4/rAgQPxwx/+sKCMxxaUIyKuvvrqgu6ja21tbbFly5bEMwVgAAAAAAAAKK1PfvKTccstt0RNTU3e/KWXXopVq1YdV/6tqamJW2+9NT72sY9lGRPoBWkbgGtra6O21m/4AwAAAAAA+RSAB4jLL788JkyY0HG9bdu2uOOOO7q9b9myZXlF4Xe+850xcuTILu+54YYb8q6/8pWvpH6J9Qfr16+Pf/qnf+q4rq6ujqVLl3abj+5t3749mpubE88UgAEAAAAAAKD0brrppnjqqafiiiuuiOrq5K/xq6ur48orr4xVq1bFRz7ykWwDAr0ibcPvkCFDMk4CAAAAAABUAj8fWoG2bdsWZ5xxRt5s69atMXny5NR7Bg8eHJ/73OfiL/7iLzpmH//4x2PRokUxe/bsxHu+//3vxz/8wz90XNfU1MTy5cu7zfeBD3wgvva1r8X27dsjImLTpk3x0Y9+NG677baoqqo67vOvv/56/Omf/mleSfW6665LzUVxNm3alHo2bdq0DJMAAAAAAABA+Zo8eXLejyNnbf78+XHvvffGK6+8Ev/6r/8aTU1NcfDgwaivr4+pU6fG4sWLY+zYsSXLB5y4tB9PHzp0aMZJAAAAAACASqAA3MseeOCBxPm6devyrl977bXUz06ZMiWmTJnS69luuOGG+OY3vxnPP/98R4aLLroobr311rjuuuuitvb3/3N49dVX49Zbb40vf/nLeff/1//6XwvaGFtXVxdf+cpX4rrrruuY/e3f/m288sor8eUvfzmmT5/eMX/wwQfjox/9aDz33HMds4aGhvjCF75wQn9W/l1aAXj8+PHR0NCQcRoAAAAAAACgK2PHjo1rrrmm1DGAPnAiG4BL+QMFAAAAAABAaSgA97IlS5YU9Lnnnnsu9bM333xzLFu2rBdT/d6gQYPi7rvvjgsvvDBeffXViPh92ff666+PD33oQzF16tQ4fPhwbN26NVpaWvLuPf/88+OWW24p+F3vfe9749FHH41vfetbHbMf/ehH8eMf/zgmTpwYJ598crzwwgvxyiuv5N1XXV0dd9xxx3Ebjum5tAJwIWVuAAAAAAAAAKB3pG0ALqQADAAAAAAADDzVpQ5AtmbNmhUPPvhgTJo0KW9+4MCBePbZZ2PTpk3HlX/f+ta3xq9+9asYOnRoUe/65je/GR/96EfzZrlcLrZv3x6rVq06rvw7bNiw+MEPfhDvete7inoPXdu8eXPiXAEYAAAAAAAAALKTVgD+w9/HqKqqyjIOAAAAAABQ5hSAB6Czzz471qxZE5/5zGfipJNOSv3c9OnT4+///u/j17/+dYwaNaro91RXV8fXv/71ePDBB+Oiiy5K/VxdXV28733vi7Vr18a73/3uot9D19I2AE+fPj3jJAAAAAAAAAAwcB0+fDhxbgMwAAAAAACQpLbUAfqbXC7X5++YPHnyCb9n+PDh8eUvfzmWL18ejz/+eKxduzb27NkTNTU1ceqpp8Y555wTZ511Vq/kffOb3xxvfvOb48UXX4yVK1fG9u3b48iRIzF8+PCYPn16XHjhhTFixIheeRf5jh49Gtu2bUs8swEYAAAAAAAAALLT3QZgAAAAAACAYykAD3CDBg2KCy+8MC688MI+f9eECRNs+M3Yli1bUsviCsAAAAAAAAAAkB0bgAEAAAAAgGJUlzoA0Hc2b96cOK+uro4pU6ZknAYAAAAAAAAABi4bgAEAAAAAgGIoAEM/tmnTpsT55MmTo66uLuM0AAAAAAAAADBw2QAMAAAAAAAUQwEY+rG0AvCMGTMyTgIAAAAAAAAAA5sNwAAAAAAAQDEUgKEfUwAGAAAAAAAAgPKQVgC2ARgAAAAAAEiiAAz92ObNmxPnCsAAAAAAAAAAkK3Dhw8nzhWAAQAAAACAJArA0E/t378/du7cmXg2ffr0jNMAAAAAAAAAwMCWtgF46NChGScBAAAAAAAqgQIw9FNp238jbAAGAAAAAAAAgKzZAAwAAAAAABRDARj6qU2bNiXOBw8eHBMnTsw4DQAAAAAAAAAMbDYAAwAAAAAAxVAAhn4qbQPwtGnToqamJuM0AAAAAAAAADCw2QAMAAAAAAAUQwEY+qm0DcDTp0/POAkAAAAAAAAAcOjQocR5fX19xkkAAAAAAIBKoAAM/VRaAXjGjBkZJwEAAAAAAAAADh48mDgfNmxYxkkAAAAAAIBKoAAM/VRjY2Pi3AZgAAAAAAAAAMhe2gbgQgrAuVyut+MAAAAAAABlTgEY+qHXXnstXn311cSzadOmZZwGAAAAAAAAAAa2XC7XbQG4qqoqy0gAAAAAAECZUwCGfmjLli2pZwrAAAAAAAAAAJCtI0eOpJ7V19dnmAQAAAAAAKgUCsDQDzU2NibOhwwZEuPHj884DQAAAAAAAAAMbGnbfyP+fQMwAAAAAADAsRSAoR9KKwBPnTo1qqv9vz0AAAAAAAAAZOngwYOpZwrAAAAAAABAEk1A6IfSCsDTpk3LOAkAAAAAAAAAYAMwAAAAAABQLAVg6IcUgAEAAAAAAACgfCgAAwAAAAAAxVIAhn5IARgAAAAAAAAAykdXBeD6+voMkwAAAAAAAJVCARj6mf3798fvfve7xDMFYAAAAAAAAADIXloBuLa2NgYNGpRxGgAAAAAAoBIoAEM/s2XLltQzBWAAAAAAAAAAyN7BgwcT58OGDcs4CQAAAAAAUCkUgKGfaWxsTJwPGjQoJk6cmHEaAAAAAAAAACBtA7ACMAAAAAAAkEYBGPqZtALwlClToqamJuM0AAAAAAAAAIACMAAAAAAAUCwFYOhn0grA06ZNyzgJAAAAAAAAABCRXgCur6/POAkAAAAAAFApFIChn1EABgAAAAAAAIDycvDgwcS5DcAAAAAAAEAaBWDoZxSAAQAAAAAAAKC8pG0AVgAGAAAAAADSKABDP3L48OHYsWNH4pkCMAAAAAAAAACUhgIwAAAAAABQLAVg6EeamppSzxSAAQAAAAAAAKA0TrQAnMvlejMOAAAAAABQARSAoR9pbGxMnNfU1MSkSZMyTgMAAAAAAAAARKQXgOvr6zv+76qqqqziAAAAAAAAFUABGPqRtALwpEmTYtCgQRmnAQAAAAAAAAAiIg4ePJg4L3QDMAAAAAAAMPAoAEM/klYAnjZtWsZJAAAAAAAAAIA/SNsArAAMAAAAAACkUQCGfkQBGAAAAAAAAADKjwIwAAAAAABQLAVg6EcUgAEAAAAAAACg/CgAAwAAAAAAxVIAhn7i6NGjsX379sQzBWAAAAAAAAAAKJ20AnB9fX3GSQAAAAAAgEqhAAz9xLZt26K9vT3xTAEYAAAAAAAAAErn4MGDiXMbgAEAAAAAgDQKwNBPNDY2Js6rqqrijDPOyDgNAAAAAAAAAPAHaRuAFYABAAAAAIA0CsDQT6QVgCdOnBhDhgzJOA0AAAAAAAAA8AcKwAAAAAAAQLEUgKGfSCsAT5s2LeMkAAAAAAAAAMAf5HI5BWAAAAAAAKBoCsDQTygAAwAAAAAAAED5OXLkSORyucSz+vr6jNMAAAAAAACVQgEY+oktW7YkzhWAAQAAAAAAAKB0Dh48mHpmAzAAAAAAAJBGARj6gdbW1ti6dWvimQIwAAAAAAAAAJTOgQMHUs+GDx+eYRIAAAAAAKCSKABDP7B9+/ZobW1NPFMABgAAAAAAAIDS6aoA3NDQkGESAAAAAACgkigAQz/Q2NiYejZlypQMkwAAAAAAAAAAx1IABgAAAAAAekIBGPqBtALw+PHjo76+PuM0AAAAAAAAAMAfpBWAq6qqYujQoQU9I5fL9WYkAAAAAACgAigAQz+QVgCeNm1axkkAAAAAAAAAgGOlFYAbGhqiqqoq4zQAAAAAAEClUACGfiCtADx16tSMkwAAAAAAAAAAx+qqAHwsZWAAAAAAAOBYCsDQDzQ1NSXOFYABAAAAAAAAoLT279+fOO9cAAYAAAAAADiWAjBUuFwupwAMAAAAAAAAAGWq0A3AAAAAAAAAx1IAhgr3u9/9Lg4fPpx4NmXKlIzTAAAAAAAAAADHSisADx8+POMkAAAAAABAJVEAhgq3ZcuW1DMFYAAAAAAAAAAoLRuAAQAAAACAnlAAhgrX1NSUOB8xYkSMGTMm4zQAAAAAAAAAwLEUgAEAAAAAgJ5QAIYKl1YAnjJlSlRVVWWcBgAAAAAAAAA4lgIwAAAAAADQEwrAUOG6KgADAAAAAAAAAKWlAAwAAAAAAPSEAjBUOAVgAAAAAAAAAChfCsAAAAAAAEBPKABDhduyZUviXAEYAAAAAAAAAEpPARgAAAAAAOgJBWCoYIcOHYqdO3cmnikAAwAAAAAAAEDpKQADAAAAAAA9oQAMFWzbtm2pZ1OnTs0uCAAAAAAAAACQaP/+/YlzBWAAAAAAAKArCsBQwZqamhLn1dXVcfrpp2ecBgAAAAAAAADoLG0D8PDhwzNOAgAAAAAAVBIFYKhgaQXgiRMnRl1dXcZpAAAAAAAAAIDO0grANgADAAAAAABdUQCGCpZWAJ4yZUrGSQAAAAAAAACAzpqbm6OlpSXxTAEYAAAAAADoigIwVLAtW7YkzhWAAQAAAAAAAKD00rb/RhRXAM7lcr0RBwAAAAAAqCAKwFDBbAAGAAAAAAAAgPJVTAG4qqqqr+MAAAAAAAAVRAEYKlQul0stAE+dOjXjNAAAAAAAAABAZ721ARgAAAAAABh4FIChQr388stx5MiRxDMbgAEAAAAAAACg9BSAAQAAAACAnlIAhgqVtv03QgEYAAAAAAAAAMrB/v37U8+GDRuWYRIAAAAAAKDSKABDhdqyZUvifMSIETF69OiM0wAAAAAAAAAAnaUVgBsaGqK62l/bAQAAAAAA0vkmASpU2gbgKVOmRFVVVcZpAAAAAAAAAIDOXn/99cT5yJEjM04CAAAAAABUGgVgqFBdFYABAAAAAAAAgNLbt29f4nzEiBEZJwEAAAAAACqNAjBUqLQC8NSpUzNOAgAAAAAAAAAkSdsArAAMAAAAAAB0RwEYKpQNwAAAAAAAAABQ3hSAAQAAAACAnlIAhgp06NCh2LlzZ+KZAjAAAAAAAAAAlIe0AvDIkSMzTgIAAAAAAFQaBWCoQFu3bk09UwAGAAAAAAAAgPKwb9++xLkNwAAAAAAAQHcUgKECNTU1Jc6rq6vj9NNPzzgNAAAAAAAAAJAkbQOwAjAAAAAAANAdBWCoQGkF4IkTJ0ZdXV3GaQAAAAAAAACAJArAAAAAAABATykAQwVKKwBPnTo14yQAAAAAAAAAQJq0AvDIkSMzTgIAAAAAAFQaBWCoQGkF4ClTpmScBAAAAAAAAABIs2/fvsS5DcAAAAAAAEB3FIChAm3ZsiVxrgAMAAAAAAAAAOUjbQNwsQXgXC7XG3EAAAAAAIAKogAMFaa9vT22bt2aeKYADAAAAAAAAADlIZfLFVUArqqq6utIAAAAAABABVEAhgrz8ssvx5EjRxLPFIABAAAAAAAAoDwcOXIkWltbE89GjhyZcRoAAAAAAKDSKABDhWlqako9UwAGAAAAAAAAgPKQtv03InkDMAAAAAAAwLEUgKHCpBWAR44cGaNHj844DQAAAAAAAACQZN++falnCsAAAAAAAEB3FIChwqQVgKdMmRJVVVUZpwEAAAAAAAAAktgADAAAAAAAnAgFYKgwaQXgM844I+MkAAAAAAAAAECargrADQ0NGSYBAAAAAAAqkQIwVJitW7cmzqdMmZJxEgAAAAAAAAAgTVoBePjw4VFTU5NxGgAAAAAAoNIoAEOF2bZtW+LcBmAAAAAAAAAAKB/79u1LnI8YMSLjJAAAAAAAQCVSAIYKcvTo0dixY0fi2eTJk7MNAwAAAAAAAACkStsArAAMAAAAAAAUQgEYKsi//du/RS6XSzyzARgAAAAAAAAAyocCMAAAAAAAcCIUgKGCbN26NfVs0qRJGSYBAAAAAAAAALqyd+/exPnIkSOzDQIAAAAAAFQkBWCoINu2bUucv+ENb4hhw4ZlGwYAAAAAAAAASPXaa68lzk866aSMkwAAAAAAAJVIARgqSNoG4MmTJ2cbBAAAAAAAAADokgIwAAAAAABwIhSAoYKkbQA+44wzsg0CAAAAAAAAAHRp7969ifNRo0ZlmgMAAAAAAKhMCsBQQWwABgAAAAAAAIDKYAMwAAAAAABwIhSAoYKkFYBtAAYAAAAAAACA8tKbBeBcLneicQAAAAAAgAqjAAwV4vDhw/G73/0u8cwGYAAAAAAAAAAoL3v37k2cjxo1KtMcAAAAAABAZVIAhgqxbdu21DMbgAEAAAAAAACgfLS3t8e+ffsSz9I2AFdVVfVlJAAAAAAAoMIoAEOFSCsAV1VVxemnn55tGAAAAAAAAAAg1b59+yKXyyWepRWAAQAAAAAAjqUADBVi69atifPx48fH4MGDM04DAAAAAAAAAKTZu3dv6tmoUaMyywEAAAAAAFQuBWCoEGkbgM8444xsgwAAAAAAAAAAXXrttddSz2wABgAAAAAACqEADBUibQPw5MmTsw0CAAAAAAAAAHSpqwLwyJEjM0wCAAAAAABUKgVgqBA2AAMAAAAAAABAZUgrAI8YMSJqamoyTgMAAAAAAFQiBWCoEDYAAwAAAAAAAEBl2Lt3b+L8pJNOyjYIAAAAAABQsRSAoQLs378/9uzZk3hmAzAAAAAAAAAAlJe0DcAKwAAAAAAAQKEUgKECbNu2LfXMBmAAAAAAAAAAKC9pBeBRo0ZlGwQAAAAAAKhYCsBQAdIKwDU1NTFx4sRswwD8/+zdeXTV9Z0//tdNAoGALAIBAgEEFRS1blirVayK2lqX1mq3ad1GbV2q3ey0jhVrfx1n6tLV2umijtWqbe24jEVHrUvd17qACKhsAcK+hEC2+/ujXzPG3AvZ7ufeJI/HOffcfN6vz/JMjvb0ePPMGwAAAAAAANimdevWZVy3AzAAAAAAANBWCsDQDbz99tsZ18eOHRslJSUJpwEAAAAAAAAAtiXbDsAKwAAAAAAAQFspAEM3kK0AvNNOOyWcBAAAAAAAAADYnmwF4CFDhiQbBAAAAAAA6LYUgKEbeOeddzKuT5gwIdEcAAAAAAAAAMD2rVu3LuO6HYABAAAAAIC2UgCGbsAOwAAAAAAAAADQfWTbAVgBGAAAAAAAaCsFYOgG7AAMAAAAAAAAAN2HAjAAAAAAANBZCsBQ4NauXRvr16/POLMDMAAAAAAAAAAUlnQ6HevWrcs4GzJkSIfvCQAAAAAA9C4KwFDgsu3+G6EADAAAAAAAAACFZuPGjVFfX59xNmzYsKzXpVKpXEUCAAAAAAC6IQVgKHBvv/12xvU+ffrE6NGjE04DAAAAAAAAAGzLqlWrss6GDx+eYBIAAAAAAKA7UwCGApdtB+Dx48dHcXFxsmEAAAAAAAAAgG3aVgF4WzsAAwAAAAAAvJcCMBS4bDsAT5gwIdkgAAAAAAAAAMB2rV69OuN6cXFxDB48OOE0AAAAAABAd6UADAUu2w7AO+20U7JBAAAAAAAAAIDtyrYD8PDhwyOVSiWcBgAAAAAA6K4UgKHA2QEYAAAAAAAAALqPbDsADxs2LOEkAAAAAABAd6YADAUsnU7bARgAAAAAAAAAupFt7QAMAAAAAADQVgrAUMBWrVoVNTU1GWd2AAYAAAAAAACAwpOtAGwHYAAAAAAAoD0UgKGAZdv9N8IOwAAAAAAAAABQiFavXp1x3Q7AAAAAAABAeygAQwF7++23M67369cvRo4cmXAaAAAAAAAAAGB7su0ArAAMAAAAAAC0hwIwFLBsOwBPmDAhUqlUsmEAAAAAAAAAgO3KVgAeNmxYwkkAAAAAAIDuTAEYCti2CsAAAAAAAAAAQOFZvXp1xnU7AAMAAAAAAO2hAAwFbOHChRnXx48fn3ASAAAAAAAAAGB70um0HYABAAAAAIAuoQAMBUwBGAAAAAAAAAC6j02bNkV9fX3GmR2AAQAAAACA9lAAhgKVTqcVgAEAAAAAAACgG8m2+2+EAjAAAAAAANA+CsBQoNauXRubNm3KOFMABgAAAAAAAIDCs60C8LBhwzp833Q63eFrAQAAAACA7kkBGApUtt1/IxSAAQAAAAAAAKAQrV69OuN6cXFxDB48eJvXplKpXEQCAAAAAAC6KQVgKFDZCsAlJSUxevTohNMAAAAAAAAAANuTbQfgYcOGRVGRX9MBAAAAAADazicLUKCyFYArKyujuLg44TQAAAAAAAAAwPZsqwAMAAAAAADQHgrAUKAWLVqUcX38+PEJJwEAAAAAAAAA2mLFihUZ10eMGJFwEgAAAAAAoLtTAIYClW0HYAVgAAAAAAAAAChM1dXVGddHjhyZcBIAAAAAAKC7K8l3APJjy5YtMWfOnJg9e3asXLkyampqYvDgwTFs2LDYd999Y/LkyfmO2OspAAMAAAAAAABA95JtB2AFYAAAAAAAoL0UgHPkrbfeimeffTaeeeaZePbZZ+Oll16K2tra5vn06dPjkUceSTTTa6+9FnfeeWc8+OCD8fTTT0d9fX3Wc8vLy+PMM8+M888/PyoqKtr1nJkzZ8bll1/e4Zynnnpq3HjjjR2+vqdQAAYAAAAAAACA7kUBGAAAAAAA6CoKwF3o7rvvjl/+8pfx7LPPxqpVq/Idp9nSpUvjmGOOiddee63N11RXV8e//du/xc9//vP46U9/Gl/84hdzmJD327x5c6xcuTLjTAEYAAAAAAAAAAqTAjAAAAAAANBVFIC70MMPPxz33XdfvmO0snbt2qzl3wEDBsTo0aNjxx13jPXr18f8+fOjsbGxeb5hw4Y49dRTY8WKFfHNb34zqci93qJFi7LOxo0bl2ASAAAAAAAAAKAt0ul01gJweXl5wmkAAAAAAIDuTgE4IQMGDIiampp8x4iIiD322CO++MUvxhFHHBF77713FBUVNc82bNgQN998c1x22WWxevXq5vWLL744dtttt/j4xz/e7uddddVV8YEPfKDN51dUVLT7GT3NwoULs84qKysTTAIAAAAAAAAAtMWGDRuirq4u48wOwAAAAAAAQHspAOfAjjvuGNOmTWt+HXDAATFr1qw4/fTT85rr2GOPjX/913+NAw88MOs5gwYNivPOOy+OP/74mD59erz99tvNs4suuiiOPvro6NOnT7ueu99++8Vhhx3W0di9UrYC8KhRo6Jfv34JpwEAAAAAAAAAtifb7r8RCsAAAAAAAED7KQB3obPOOisuuOCCmDRpUr6jtDBixIh44okn4qCDDmrzNZWVlXHnnXfGfvvtF01NTRERsWDBgnjkkUdixowZuYrK/5OtADx+/PiEkwAAAAAAAAAAbaEADAAAAAAAdKWifAfoSaZOnVpw5d+If3yI1J7y77v23nvvOOaYY1qs3X///V0Vi21QAAYAAAAAAACA7iVbAXjgwIFRVlaWcBoAAAAAAKC7UwBmmw455JAWx4sWLcpTkt5FARgAAAAAAAAAupfq6uqM6+Xl5QknAQAAAAAAegIFYLZp6NChLY7Xr1+fpyS9iwIwAAAAAAAAAHQv2XYAHjlyZMJJAAAAAACAnkABmG1aunRpi+Nhw4blKUnvUV9f3+rn/i4FYAAAAAAAAAAoTLksAKfT6U7fAwAAAAAA6F5K8h2Awvb444+3ON511107dJ+tW7fGW2+9FatXr44+ffrEsGHDoqKiIsrKyroiZo+ydOnSaGpqyjhTAAYAAAAAAACAwmQHYAAAAAAAoCspAJPVggUL4tFHH22x9rGPfazd9znvvPPirbfeii1btrRYLykpif322y8++tGPxrnnnhsjRozoVN6eYuHChVlnCsAAAAAAAAAAUJiqq6szrre1AJxKpboyDgAAAAAA0M0V5TsAhevb3/52pNPp5uPdd989pk2b1u77zJ49u1X5NyKioaEhnnnmmZg5c2aMHz8+vvvd70ZjY2OnMvcEixYtyrg+ZMiQGDRoUMJpAAAAAAAAAIC2sAMwAAAAAADQlewATEZ33HFH/OEPf2ix9oMf/CBnf222trY2rrjiinj88cfjnnvuiYEDB3bp/aurq2PlypXtumb+/PldmqGtsu0AbPdfAAAAAAAAAChM6XQ6li1blnFWXl6ecBoAAAAAAKAnUACmlblz58ZZZ53VYu2Tn/xknHDCCW2+RyqVig996ENx7LHHxgEHHBC77bZb7LjjjlFUVBSrV6+OF198Me6999646aabWuwO/Mgjj8RnPvOZuOuuu6K4uLjLvqfrrrsuLr/88i67Xy4pAAMAAAAAAABA97Jhw4bYvHlzxtmYMWMSTgMAAAAAAPQERfkOQGFZs2ZNHHfccbFhw4bmtbFjx8Z//ud/tvkeRx11VLzxxhvxxBNPxHe+85048sgjY8yYMdG/f/8oLS2NioqK+PjHPx7XX399zJs3Lw4++OAW1//P//xPXHfddV32PXU3CsAAAAAAAAAA0L1UVVVlnVVUVCSYBAAAAAAA6Cl6RAH4oosuilQqlfPXzJkz8/2t5lRtbW0cf/zxMW/evOa1AQMGxJ133hnDhg1r830OOuig2HXXXdt07tixY+PBBx+MD33oQy3Wv//972f9y7g9nQIwAAAAAAAAAHQv2yoAjxo1KsEkAAAAAABAT1GS7wAUhoaGhjjllFPiiSeeaF7r27dv3HnnnTFt2rScPrtfv37xX//1X7HbbrtFQ0NDRERUV1fHAw88ECeeeGKXPOPcc8+Nk08+uV3XzJ8/v8ue31bpdDoWLVqUcTZu3LhEswAAAAAAAAAAbbN06dKM68OHD4/S0tKE0wAAAAAAAD2BAjCRTqfj1FNPjXvvvbd5rbi4OG655ZY46qijEsmw8847x/HHHx933nln81pXFoDLy8ujvLy8S+6VS9XV1bFly5aMMzsAAwAAAAAAAEBhyrYD8JgxYxJOAgAAAAAA9BQ9ogB87LHHxvDhw3P+nEMPPTTnz8iHc889N2699dbm41QqFf/5n/8Zn/rUpxLNccQRR7QoAM+dOzfR5xeChQsXZp0pAAMAAAAAAABAYcpWAK6oqEg4CQAAAAAA0FP0iALwjBkzYsaMGfmO0S1dfPHFcf3117dYu+aaa+KMM85IPEtlZWWL45UrVyaeId+yFYD79evXLXYwBgAAAAAAAIDeSAEYAAAAAADoakX5DkD+XHHFFfHDH/6wxdrll18eF110UV7y9OnTp8VxfX19XnLkU7YC8Lhx4yKVSiWcBgAAAAAAAABoi6VLl2ZcVwAGAAAAAAA6SgG4l/rRj34U3/3ud1usff3rX2+1lqTly5e3OB4xYkSekuRPtgLw+PHjE04CAAAAAAAAALSVHYABAAAAAICupgDcC/3617+Or33tay3Wzj777LjqqqvylOgf/va3v7U4rqyszFOS/FEABgAAAAAAAIDupampKZYtW5ZxpgAMAAAAAAB0lAJwL3PbbbfFOeecE+l0unnt85//fPziF7/IY6qIdevWxZ/+9KcWa0cccUSe0uSPAjAAAAAAAAAAdC+rV6+O+vr6jDMFYAAAAAAAoKMUgHuRe++9N774xS9GU1NT89qJJ54YN954YxQV5fcfhW984xuxbt265uO+ffvGRz/60fwFyhMFYAAAAAAAAADoXpYuXZp1NmbMmASTAAAAAAAAPYkCcDf0zjvvRCqVavF65513tnnNI488EieffHKLvzh71FFHxe233x4lJSVdlu3KK6+MF154oc3nNzQ0xNe//vX4zW9+02L9S1/6UowePbrLcnUH69evj/Xr12ecKQADAAAAAAAAQGGqqqrKuF5UVBTl5eVd8ox0Ot0l9wEAAAAAALqPrmt+EhERDz74YMb12bNntzheu3Zt1nMnTpwYEydO7LJMr732Whx//PGxZcuW5rVRo0bFeeedF4899li77tW/f/84+OCDs85nzZoV3/72t+Oggw6KU045JY444oiYMmVKq5Lx+vXr47777ov/+I//iJdffrnFbNKkSfHd7363Xbl6gmy7/0YoAAMAAAAAAABAocq2A/DIkSOjuLi4zfdJpVJdFQkAAAAAAOgBFIC72IwZM9p03iuvvJL13MsuuyxmzpzZZZmef/752LhxY4u15cuXxwknnNDue40fP367uw1HRDz55JPx5JNPRkREaWlpjB07NgYPHhzFxcWxevXqeOedd6KpqanVdaNGjYq//OUvMWzYsHZn6+4WLVqUcb24uDjGjBmTcBoAAAAAAAAAoC2yfd5fWVmZcBIAAAAAAKAnUQAm57Zu3RoLFizY7nkf+9jH4oYbbojy8vIEUhWebDsAjxkzptUOygAAAAAAAABAYchWAB43blzCSQAAAAAAgJ5Eq5Audckll8Ruu+0Wjz/+eLzxxhvR2Ni4zfMHDhwYH/3oR+P888+PQw89NKGUhWnx4sUZ130gCAAAAAAAAACFy+f9AAAAAABALigAd7F0Op3zZ0yYMKFdzznttNPitNNOy12g95gxY0bMmDEjIiI2b94cs2fPjnfeeSeWLVsWmzZtiqamphgyZEgMHTo0dt9999hzzz2juLg4kWyFzl8EBgAAAAAAAIDux+f9AAAAAABALigAkzNlZWWx//77x/7775/vKN1Ctr8IXFlZmXASAAAAAAAAAKAtmpqa7AAMAAAAAADkRFG+AwD/4C8CAwAAAAAAAED3Ul1dHXV1dRlnPu8HAAAAAAA6QwEYCkBjY2MsXbo048wOwAAAAAAAAABQmLL9se8In/cDAAAAAACdowAMBWDZsmXR2NiYceYDQQAAAAAAAAAoTNkKwKWlpTFixIiE0wAAAAAAAD2JAjAUgMWLF2edjRs3LsEkAAAAAAAAAEBbZfu8f9y4cZFKpRJOAwAAAAAA9CQKwFAAsv1F4LKyshg6dGjCaQAAAAAAAACAtsj2eb8/9g0AAAAAAHSWAjAUAH8RGAAAAAAAAAC6HwVgAAAAAAAgVxSAoQBkKwBXVlYmnAQAAAAAAAAAaCsFYAAAAAAAIFcUgKEA+EAQAAAAAAAAALqft99+O+O6P/gNAAAAAAB0lgIwFAA7AAMAAAAAAABA97J+/fpYvXp1xtnEiRMTTgMAAAAAAPQ0CsBQAOwADAAAAAAAAADdS7bdfyO6vgCcTqe79H4AAAAAAEDhUwCGPKutrY2VK1dmnNkBGAAAAAAAAAAK01tvvZVxvaSkJMaOHdvu+6VSqc5GAgAAAAAAehAFYMizJUuWZJ3ZARgAAAAAAAAAClO2AvCECROiuLg44TQAAAAAAEBPowAMebZ48eKss478RWAAAAAAAAAAIPeyFYAnTZqUcBIAAAAAAKAnUgCGPFu0aFHG9eHDh0dZWVnCaQAAAAAAAACAtshWAJ44cWLCSQAAAAAAgJ5IARjyLNsOwJWVlQknAQAAAAAAAADaSgEYAAAAAADIJQVgyLNsOwArAAMAAAAAAABAYWpsbIx33nkn40wBGAAAAAAA6AoKwJBn2XYAHjduXMJJAAAAAAAAAIC2WLp0adTX12ecKQADAAAAAABdQQEY8ixbAdgOwAAAAAAAAABQmN56662ss5122inBJAAAAAAAQE+lAAx5lE6nY9GiRRlndgAGAAAAAAAAgMKUrQA8bNiwGDx4cMJpAAAAAACAnkgBGPJo/fr1sWnTpowzOwADAAAAAAAAQGFasGBBxvWJEycmnAQAAAAAAOipFIAhj7Lt/hthB2AAAAAAAAAAKFTz5s3LuK4ADAAAAAAAdBUFYMijxYsXZ1wvKiqK0aNHJ5wGAAAAAAAAAGiLuXPnZlzfddddE04CAAAAAAD0VArAkEfZdgAeM2ZMlJSUJJwGAAAAAAAAANiepqamrDsAT548OeE0AAAAAABAT6UADHmUbQfgysrKhJMAAAAAAAAAAG2xePHiqK2tzThTAAYAAAAAALqKAjDkUbYdgMeNG5dwEgAAAAAAAACgLebOnZt1tuuuuyaYBAAAAAAA6MkUgCGP7AAMAAAAAAAAAN1LtgLw6NGjY9CgQTl5Zjqdzsl9AQAAAACAwqUADHlkB2AAAAAAAAAA6F6yFYAnT56ccBIAAAAAAKAnUwCGPGlsbIylS5dmnNkBGAAAAAAAAAAKU64KwKlUqlPXAwAAAAAAPYsCMOTJihUror6+PuNMARgAAAAAAAAACpMdgAEAAAAAgCQoAEOeLF68OOts3LhxCSYBAAAAAAAAANqipqYm6+f9CsAAAAAAAEBXUgCGPMn2gWC/fv1i2LBhCacBAAAAAAAAALZn3rx5WWcKwAAAAAAAQFdSAIY8WbRoUcb1cePGRSqVSjgNAAAAAAAAALA9c+bMybjet2/fmDBhQrJhAAAAAACAHk0BGPIk2w7AlZWVCScBAAAAAAAAANritddey7g+efLkKC4uTjgNAAAAAADQkykAQ55sawdgAAAAAAAAAKDwZCsA77HHHgknAQAAAAAAejoFYMgTOwADAAAAAAAAQPfy6quvZlxXAAYAAAAAALqaAjDkiR2AAQAAAAAAAKD72LRpU7z99tsZZwrAAAAAAABAV1MAhjzYunVrrFixIuPMDsAAAAAAAAAAUHhmz56ddaYADAAAAAAAdDUFYMiDJUuWZJ3ZARgAAAAAAAAACs9rr72WcX3AgAExYcKEZMMAAAAAAAA9ngIw5MHixYuzzuwADAAAAAAAAACFJ1sBeOrUqVFU5FdwAAAAAACAruXTB8iDbAXgoUOHxoABAxJOAwAAAAAAAABsT7YC8B577JFwEgAAAAAAoDdQAIY8WLJkScZ1u/8CAAAAAAAAQGFSAAYAAAAAAJKkAAx5kK0APHbs2ISTAAAAAAAAAADbs2LFili2bFnG2dSpUxNOAwAAAAAA9AYKwJAHCsAAAAAAAAAA0H289NJLWWcf+MAHcv78dDqd82cAAAAAAACFRQEY8kABGAAAAAAAAAC6j2wF4IqKihg5cmSXPCOVSnXJfQAAAAAAgJ5BARjyQAEYAAAAAAAAALqPF198MeP6vvvum3ASAAAAAACgt1AAhoRt3bo1qqurM84UgAEAAAAAAACg8CgAAwAAAAAASVMAhoRVVVVlnSkAAwAAAAAAAEBhWbduXbz11lsZZ/vss0/CaQAAAAAAgN5CARgStmTJkqwzBWAAAAAAAAAAKCwvv/xy1pkdgAEAAAAAgFwpyXcA6G2yFYAHDRoUO+ywQ8JpAAAAAAAAgEKxcePGeOKJJ+LNN9+MDRs2RP/+/WP8+PFx0EEHRUVFRb7jQa/10ksvZVzfcccdo7KyMuE0AAAAAABAb6EADAnLVgC2+y8AAAAAAAAUvqampjjkkEPiySefbLE+ffr0eOSRRzp0z7fffju++93vxh133BF1dXWt5qlUKqZPnx6XX355HHrooR16BtBxL774Ysb1fffdN1KpVMJpAAAAAACA3qIo3wGgt1EABgAAAAAAgO7rZz/7Wavyb2fccccdsccee8Tvfve7jOXfiIh0Oh2PPPJIHHbYYfEv//IvkU6nu+z5wPY988wzGdf32WefhJMAAAAAAAC9iR2AIWEKwAAAAAAAANA9LVy4MC655JIuu98f/vCH+OxnPxtNTU0t1keMGBGVlZVRXV0dS5cubS78ptPp+Pd///fYunVrXHvttV2WA8hu9erVMW/evIyzAw44IOE0AAAAAABAb2IHYEiYAjAAAAAAAAB0T2effXZs2rQpIiIGDBjQqXstWLAgTj/99Bbl3w984APx8MMPR3V1dbzwwguxePHimDNnTnzyk59sce2PfvSjuPPOOzv1fKBtnn322ayzAw88MMEkAAAAAABAb6MADAlTAAYAAAAAAIDu58Ybb4wHHnggIiIGDhwYF198cafud+mll0ZNTU3z8bRp0+Kxxx6Lj3zkIy3Omzx5cvzxj3+Ms88+u8X6xRdfHA0NDZ3KAGzf008/nXF9zJgxPucHAAAAAABySgEYElRfXx/Lli3LOPPBIAAAAAAAABSmFStWxNe+9rXm4yuuuCLGjRvX4fu9/vrrcfvttzcf9+3bN2666aYYNGhQxvNTqVT8+Mc/jl122aV5bcGCBXHDDTd0OAPQNtkKwB/84AcTTgIAAAAAAPQ2CsCQoOXLl0c6nc44UwAGAAAAAACAwnTeeefF2rVrIyJi//33j6985Sudut9vf/vbaGpqaj7+zGc+E7vttts2r+nXr1/8y7/8S4u1X//6153KAWxbU1NTPPPMMxlnBx54YMJpAAAAAACA3kYBGBK0ZMmSrLPKysoEkwAAAAAAAABt8ec//zn+9Kc/RURESUlJ/OpXv4qios591H733Xe3OD7zzDPbdN2nP/3pGDBgQPPxc889F1VVVZ3KAmQ3d+7cWL9+fcaZAjAAAAAAAJBrCsCQoGwF4AEDBsTgwYMTTgMAAAAAAABsy7p16+K8885rPv7qV78ae++9d6fuOXfu3Jg/f37z8YABA+Kggw5q07XvPzedTsf//M//dCoPkF223X+Li4tjv/32SzgNAAAAAADQ2ygAQ4KyFYDHjh0bqVQq4TQAAAAAAADAtnzta1+LZcuWRUTETjvtFDNnzuz0PV9++eUWxwcccECUlJS0+fqDDz54m/cDus5TTz2VcX2vvfaKsrKyRLOk0+lEnwcAAAAAAOSfAjAkaFsFYAAAAAAAAKBwPPjgg3HDDTc0H19//fVdUvibM2dOi+Pdd9+9Xde///z33w/oOo899ljG9Q9+8IMJJwEAAAAAAHojBWBIkAIwAAAAAAAAFL6ampo4++yzm48///nPx1FHHdUl9547d26L48rKynZd//7z338/oGusWLEi3njjjYyzD3/4wzl5ZiqVysl9AQAAAACA7kkBGBKkAAwAAAAAAACF75JLLom33347IiKGDRsW1157bZfdu7q6usVxez8rHDNmTIvjlStXdjoT0Nrjjz+edTZ9+vQEkwAAAAAAAL1VSb4DQG+iAAwAAAAAAACF7emnn46f/vSnzcdXXXVVjBgxosvuv2nTphbHAwYMaNf17z+/vr4+tm7dGqWlpZ3OVl1d3e5C8fz58zv9XChEjz76aMb1iRMn+owfAAAAAABIhAIwJKSxsTGqqqoyznw4CAAAAAAAAPlXV1cXZ555ZjQ1NUVExOGHHx6nnXZalz7j/QXgfv36tev6/v37Z7xnVxSAr7vuurj88ss7fR/oCbIVgO3+CwAAAAAAJKUo3wGgt6iuro6GhoaMMwVgAAAAAAAAyL8rrrgiZs+eHRH/KOb+8pe/7PJnbNmypcVx375923V9pqJvbW1tpzIBLa1evTpeffXVjLNDDz004TQAAAAAAEBvpQAMCVmyZEnWmQIwAAAAAAAAvdlFF10UqVQq56+ZM2dmzfDKK6/Ev//7vzcfX3rppbHzzjt3+ff6/h1/6+rq2nX91q1bt3tPoHMef/zxrDM7AAMAAAAAAEkpyXcA6C2yFYBLS0tj2LBhCacBAAAAAAAA3tXY2Bhnnnlm1NfXR0TEnnvuGd/85jdz8qyBAwe2OH7/jsDbk2m33/ffs6POPffcOPnkk9t1zfz58+PEE0/skudDoXj00UczrldWVsaECROSDQMAAAAAAPRaCsCQkGwF4LFjx0YqlUo4DQAAAAAAAPCua665Jp5//vmIiCgqKor//M//jD59+uTkWe8v69bU1LTr+vefX1JS0mU7AJeXl0d5eXmX3Au6swceeCDj+vTp032+DwAAAAAAJEYBGBKyePHijOtjx45NOAkAAAAAAAAUlmOPPTaGDx+e8+cceuihrdZqa2vjsssuaz7+8pe/HAceeGDOMry/YJvtDwlns3Tp0hbHI0aM6HQm4P8sWbIkZs+enXF2+OGHJ5wGAAAAAADozRSAISHb2gEYAAAAAAAAerMZM2bEjBkz8vLsrVu3Rm1tbfPxz3/+8/j5z3/e7vs8+uijrXYGXbt2bQwZMqTF2uTJk1scL1q0qF3Pef/5U6ZMadf1wLb97//+b9bZUUcdlWASAAAAAACgtyvKdwDoLRSAAQAAAAAAgPcXdrPtNJrNnDlztnk/oHMeeOCBjOtTp06NMWPGJJwGAAAAAADozRSAISEKwAAAAAAAAMDee+/d4vi5556LhoaGNl//xBNPbPN+QMc1NTVl3QHY7r8AAAAAAEDSSvIdAHqDpqamWLp0acaZAjAAAAAAAADkz8CBA7MW/rblgQceiB/+8IfNx3vttVdcffXVre79flOmTIlJkybFggULIiKipqYmnnzyyTj00EO3+8yampp46qmnmo9TqVR8/OMfb3d2ILMXX3wxVq9enXGmAAwAAAAAACRNARgSsGrVqqirq8s4UwAGAAAAAACA/CkpKYkjjzyy3dctWbKkxfHQoUPbfJ/jjz8+rr322ubj3/zmN20qAN9+++2xadOm5uP9998/Kioq2pgY2J77778/43ppaWmb/h0FAAAAAADoSkX5DgC9wfs//H8vBWAAAAAAAADoXc4444xIpVLNx7fddlvMmTNnm9ds2bIlrrzyyhZrZ555Zk7yQW91zz33ZFw/5JBDoqysLOE0AAAAAABAb6cADAnIVgAuKSmJ8vLyhNMAAAAAAAAA+bTHHnvEKaec0nxcV1cXp556amzYsCHj+el0Oi666KKYN29e89rEiRPjjDPOyHlW6C2WL18ezzzzTMbZMccck3Ca1tLpdL4jAAAAAAAACVMAhgRkKwCPGTMmior8awgAAAAAAAC9zfe///0WO4o+99xzceihh8YjjzzS4rw333wzPvWpT8Uvf/nLFutXXnll9OnTJ4mo0Cvce++9WWfHH398IhneuzM4AAAAAABASb4DQG+QrQA8duzYhJMAAAAAAAAAhWDnnXeO3/zmN/G5z32ueWfPv//97/GRj3wkRowYEePGjYvq6upYsmRJq50/L7jggjj55JPzERt6rLvvvjvj+pQpU2KXXXZJOA0AAAAAAIACMCRCARgAAAAAAAB4v8985jORTqfjzDPPjNra2ub1lStXxsqVKzNe841vfCP+4z/+I6mI0Cts3rw5/vd//zfjLKndfwEAAAAAAN6vKN8BoDdQAAYAAAAAAAAy+exnPxuvvfZafO5zn4s+ffpkPe/QQw+NRx55JH74wx9GKpVKMCH0fA8++GBs2bIl40wBGAAAAAAAyBc7AEMCFIABAAAAAACgZznttNPitNNO65J7TZw4MW655Zb4xS9+EX/7299i3rx5sXHjxujXr1+MGzcuDj744BgzZkyXPAto7Y9//GPG9eHDh8eBBx6YcBoAAAAAAIB/UACGHEun0wrAAAAAAAAAwHYNGjQoPvaxj+U7BvQqW7Zsif/+7//OOPv4xz8excXFyQYCAAAAAAD4f4ryHQB6urVr10ZtbW3GmQIwAAAAAAAAAOTPrFmzYuPGjRlnn/rUpxJOAwAAAAAA8H8UgCHHsu3+G6EADAAAAAAAAAD5dMcdd2RcHzp0aMyYMSPhNAAAAAAAAP9HARhybOnSpRnXi4qKYtSoUQmnAQAAAAAAAAAiIjZv3hx33313xtknPvGJ6Nu3b8KJAAAAAAAA/o8CMORYtgLwqFGjoqSkJOE0AAAAAAAAAEBExH333Rc1NTUZZ5/+9KcTTgMAAAAAANCSAjDkWLYCcEVFRcJJAAAAAAAAAIB3/f73v8+4PmzYsPjIRz6ScBoAAAAAAICWFIAhx6qqqjKujxkzJuEkAAAAAAAAAEBExKpVq+Kee+7JODvppJOiT58+CScCAAAAAABoSQEYcizbDsAKwAAAAAAAAACQH7feemvU19dnnH32s59NOA0AAAAAAEBrCsCQY9kKwBUVFQknAQAAAAAAAAAiIm644YaM6xMmTIhDDz004TQAAAAAAACtKQBDjlVVVWVctwMwAAAAAAAAACTv5Zdfjpdffjnj7LTTTouiIr9OAwAAAAAA5J9PLCCH6urqorq6OuNMARgAAAAAAAAAknfjjTdmnX3xi19MLkg7pNPpfEcAAAAAAAASpgAMObRs2bKss4qKigSTAAAAAAAAAAC1tbVx8803Z5x95CMfiZ122inhRP8nlUrl7dkAAAAAAEDhUQCGHKqqqso6swMwAAAAAAAAACTr9ttvjzVr1mScnX766QmnAQAAAAAAyE4BGHJo6dKlGdfLyspi8ODBCacBAAAAAAAAgN7t5z//ecb1wYMHxyc/+cmE0wAAAAAAAGSnAAw5lK0AXFFREalUKuE0AAAAAAAAANB7Pfvss/H8889nnJ122mkxYMCAhBMBAAAAAABkpwAMOVRVVZVxfcyYMQknAQAAAAAAAIDeLdvuvxERX/7ylxNMAgAAAAAAsH0KwJBD2XYAVgAGAAAAAAAAgOSsWLEibr/99oyzI488MiZPnpxwIgAAAAAAgG1TAIYcylYArqioSDgJAAAAAAAAAPReP/nJT2Lr1q0ZZ+edd17CaQAAAAAAALZPARhyyA7AAAAAAAAAAJBfGzdujOuuuy7jrLKyMj7+8Y8nnAgAAAAAAGD7FIAhR9LpdFRVVWWcKQADAAAAAAAAQDJ+9atfxbp16zLOvvrVr0ZJSUmygQAAAAAAANpAARhyZMOGDVFTU5NxVlFRkXAaAAAAAAAAAOh96urq4tprr804GzJkSPzzP/9zwokAAAAAAADaRgEYcmTp0qVZZ3YABgAAAAAAAIDcu+WWW2LJkiUZZ+eee27ssMMOCScCAAAAAABoGwVgyJGqqqqss9GjRyeYBAAAAAAAAAB6n/r6+rjiiisyzkpLS+OCCy5IOBEAAAAAAEDbKQBDjmTbAXj48OFRWlqacBoAAAAAAAAA6F1uvPHGePvttzPOTj311Bg1alTCiQAAAAAAANpOARhyJFsBeMyYMQknAQAAAAAAAIDeZevWrVl3/y0uLo6LL7444UQAAAAAAADtowAMOVJVVZVxXQEYAAAAAAAAAHLrN7/5TSxevDjj7LTTTotJkyYlnAgAAAAAAKB9FIAhR7LtAFxRUZFwEgAAAAAAAADoPTZt2pR1998+ffrEpZdemnCizkun0/mOAAAAAAAAJEwBGHIkWwHYDsAAAAAAAAAAkDv/8R//EcuXL884++d//ucYP358wokAAAAAAADaTwEYcqSqqirjugIwAAAAAAAAAOTGkiVL4qqrrso4Ky0tje985zsJJ2q7VCqV7wgAAAAAAEABUQCGHGhsbMz614QrKioSTgMAAAAAAAAAvcMll1wStbW1GWcXXHBBjB07NuFEAAAAAAAAHaMADDmwYsWKaGxszDizAzAAAAAAAAAAdL1nn302/uu//ivjbPjw4XHJJZcknAgAAAAAAKDjFIAhB6qqqrLOFIABAAAAAAAAoGs1NDTEOeeck3V++eWXx5AhQ5ILBAAAAAAA0EkKwJADS5cuzbjep0+fGD58eMJpAAAAAAAAAKBn++lPfxovv/xyxtluu+0WZ599drKBAAAAAAAAOkkBGHIgWwG4oqIiUqlUwmkAAAAAAAAAoOdavHhxXHrppVnnV199dZSUlCSYCAAAAAAAoPMUgCEHqqqqMq6PGTMm4SQAAAAAAAAA0HOl0+m44IILoqamJuP8pJNOio9+9KMJpwIAAAAAAOg8BWDIgWw7ACsAAwAAAAAAAEDXufXWW+Ouu+7KOBs4cGD86Ec/SjYQAAAAAABAF1EAhhzIVgCuqKhIOAkAAAAAAAAA9ExLly6N888/P+v8iiuuiLFjxyaYCAAAAAAAoOsoAEMOVFVVZVy3AzAAAAAAAAAAdF46nY5//ud/jnXr1mWc77333tssBwMAAAAAABQ6BWDIgWw7ACsAAwAAAAAAAEDn/fKXv4xZs2ZlnJWUlMRvf/vbKCkpSTgVAAAAAABA11EAhi62efPmrH9huKKiItkwAAAAAAAAANDD/P3vf4+LLroo6/y73/1u7LPPPskFAgAAAAAAyAEFYOhiVVVVWWd2AAYAAAAAAACAjtu4cWOcfPLJsXXr1ozzadOmxbe//e2EUwEAAAAAAHQ9BWDoYkuXLs06swMwAAAAAAAAAHRMOp2Oc845J+bNm5dxXlpaGjfddFOUlJQknAwAAAAAAKDrKQBDF8tWAB48eHAMGDAg4TQAAAAAAAAA0DP84he/iN///vdZ59dcc03stttuCSYCAAAAAADIHQVg6GJVVVUZ18eMGZNwEgAAAAAAAADoGf7617/GV77ylazzk08+Ob785S8nmChZ6XQ63xEAAAAAAICEKQBDF8u2A7ACMAAAAAAAAAC031tvvRWf+tSnorGxMeN84sSJ8atf/SpSqVTCybpWd88PAAAAAAB0LQVg6GLZCsAVFRUJJwEAAAAAAACA7m3Dhg1x/PHHx5o1azLO+/btG3fccUcMHjw44WQAAAAAAAC5pQAMXayqqirjuh2AAQAAAAAAAKDttm7dGp/4xCfi9ddfz3rOz372s9hvv/0STAUAAAAAAJAMBWDoYtl2AFYABgAAAAAAAIC2aWpqii9+8Yvx8MMPZz3nggsuiLPOOivBVAAAAAAAAMlRAIYulE6ns+4AXFFRkXAaAAAAAAAAAOh+0ul0XHTRRXHHHXdkPefII4+Ma665JsFUAAAAAAAAySrJdwB6j6VLl8ZTTz0VCxcujNra2hg0aFDsuuuu8eEPfzgGDhyY73hdYvXq1VFXV5dxZgdgAAAAAAAAANi+mTNnxk9/+tOs85133jluv/32KCnxay8AAAAAAEDP5ZOQHHnrrbfi2WefjWeeeSaeffbZeOmll6K2trZ5Pn369HjkkUcSzTRhwoRYuHBhh6//61//Gocddli7r3v00Udj5syZWb/fvn37xqc//en43ve+FxMmTOhwvkKQbfffCDsAAwAAAAAAAMD2XH755fG9730v67y8vDxmzZoVO+64Y4KpAAAAAAAAkqcA3IXuvvvu+OUvfxnPPvtsrFq1Kt9x8i6dTse3vvWt+OEPf7jN8+rq6uLmm2+OO++8M2666aY46aSTEkrY9bIVgFOpVIwcOTLhNAAAAAAAAADQfXzve9+LmTNnZp0PHDgw/vKXv8SkSZOSCwUAAAAAAJAnRfkO0JM8/PDDcd999yn//j9f+cpXWpV/U6lUVFZWxr777hvDhw9vMaupqYlPf/rT8ec//znJmF1q2bJlGdfLy8ujpETfHgAAAAAAAADeL51Ox+WXXx6XXXZZ1nP69OkTf/7zn2PfffdNMBkAAAAAAED+aCQmZMCAAVFTU5PvGM1GjhwZv/vd79p1zQc+8IE2n3vHHXfEz372sxZrJ510Uvzbv/1b7LLLLs1rDz30UHzta1+LV155JSIiGhsb49RTT4199tknJkyY0K58hSBbAbiioiLhJAAAAAAAAABQ+JqamuLCCy9s9TsG71VUVBQ333xzHHnkkQkmAwAAAAAAyC8F4BzYcccdY9q0ac2vAw44IGbNmhWnn356vqM169evX84+GKurq4tvfetbLda+9KUvxXXXXRepVKrF+hFHHBGPPfZYHHnkkfH8889HRMTGjRvjsssui5tuuikn+XKpqqoq4/ro0aMTTgIAAAAAAAAAha2uri5OO+20+P3vf5/1nHfLv5/+9KcTTAYAAAAAAJB/CsBd6KyzzooLLrggJk2alO8oefWb3/wm3nnnnebjXXbZJa699tpW5d93DR48OG666abYZ599oq6uLiIibrnllvj2t78dU6ZMSSJyl8m2A7ACMAAAAAAAAAD8nw0bNsQpp5wS999/f9ZzioqK4qabborPfe5zCSYDAAAAAAAoDEX5DtCTTJ06tdeXfyMifv3rX7c4/va3vx39+vXb5jW77757i7/W29jYGDfccENO8uVStgJwRUVFwkkAAAAAAAAAoDC99dZbcdBBB22z/JtKpeLGG2+Mf/qnf0owGQAAAAAAQOFQAKZLLVmyJF588cXm44EDB8Ypp5zSpmvPPPPMFsd33XVXl2ZLQlVVVcZ1OwADAAAAAAAAQMTjjz8eH/zgB+P111/Pek6fPn3itttuiy984QsJJgMAAAAAACgsCsB0qf/5n/9pcXzwwQfHgAED2nTtwQcfHGVlZc3Hc+fOjXnz5nVpvlxKp9N2AAYAAAAAAACADNLpdPzqV7+KI444IlatWpX1vAEDBsR9993X5j82DgAAAAAA0FMpANOlXn755RbHBx10UJuvLSkpiQMOOGCb9ytka9asibq6uowzOwADAAAAAAAA0FvV1NTEaaedFmeffXbU19dnPW/YsGHx17/+NY488sgE03UP6XQ63xEAAAAAAICEleQ7APm1atWqWLJkSWzYsCEGDRoUw4YNi7Fjx0YqlerQ/ebMmdPiePfdd2/X9bvvvns88sgjWe9XyLLt/huhAAwAAAAAAABA7zRnzpw4+eST4/XXX9/meTvvvHPce++9MXny5ISSFZ6O/q4GAAAAAADQMykA91LV1dWx++67ZyzY7rjjjnHIIYfE5z73uTjppJOiuLi4zfedO3dui+PKysp25Xr/+e+/XyHbVgF41KhRCSYBAAAAAAAAgPxKp9Nx0003xfnnnx81NTXbPPfwww+PP/zhD7HjjjsmlA4AAAAAAKDwFeU7APlRW1ubdXfdNWvWxF133RWf/vSnY/LkyfHoo4+2+b4rV65scTx27Nh25RozZkyL4+rq6nZdn09VVVUZ10eMGBF9+vRJOA0AAAAAAAAA5Ed1dXV84hOfiNNPP3275d8vfelLMWvWLOVfAAAAAACA97EDMNu0YMGCOOKII+Lqq6+OCy+8cJvn1tbWRmNjY4u1AQMGtOt57z9/06ZN7bo+m+rq6lbl5O2ZP39+u87PtgNwRUVFu+4DAAAAAAAAAN3VXXfdFWedddZ2P6Pv06dP/OhHP4ovf/nLkUqlEkoHAAAAAADQfSgA9zKDBg2KY445Jo4++uj4wAc+EDvttFMMGjQoNm/eHFVVVfHkk0/GDTfcEH/729+ar2lsbIyvfvWrMXLkyPjMZz6T9d6Zyrr9+vVrV77+/ftv954dcd1118Xll1/eJffKJlsBePTo0Tl9LgAAAAAAAADkW3V1dXzta1+LW265Zbvnjh8/Pv7whz/EtGnTEkgGAAAAAADQPSkA9yI//OEP46Mf/WgMHDiw1WzQoEExaNCgmDJlSpxxxhnx5z//Oc4444xYt25dRESk0+k488wz47DDDotRo0ZlvP+WLVtarfXt27ddGUtLS1sc19bWtuv6fKqqqsq4rgAMAAAAAAAAQE+VTqfjhhtuiG9+85uxZs2a7Z5/3HHHxY033hg77rhjAukAAAAAAAC6r6J8B+gKF110UaRSqZy/Zs6cme9vtVNOPvnkjOXfTD7xiU/EX/7ylxY78m7evDn+v//v/8t6Tabdfuvq6tqVcevWrdu9Z6HKtgNwRUVFwkkAAAAAAAAAIPfmzJkThx12WJx55pnbLf/27ds3rrrqqrjrrruUfwEAAAAAANrADsBkdeCBB8bFF18cl19+efParbfeGj/+8Y+jqKh1dzxTuXjLli3tKvG+f8ffthaWt+fcc8+Nk08+uV3XzJ8/P0488cQ2n5+tAGwHYAAAAAAAAAB6kjVr1sT3vve9+PnPfx4NDQ3bPX+vvfaKm2++Ofbaa68E0gEAAAAAAPQMCsBs04UXXhjf//73o7GxMSL+8SHe888/HwcccECrc/v37x/FxcXN50ZE1NTUxJAhQ9r8vJqamhbHXVUALi8vj/Ly8i65VybpdDqqqqoyzhSAAQAAAAAAAOgJ6uvr4/rrr4+ZM2dud8ffiIiioqK4+OKLY+bMmVFaWppAQgAAAAAAgJ6jRxSAjz322Bg+fHjOn3PooYfm/BmFZujQobHvvvvGc88917w2d+7cjAXgiIgRI0bE8uXLm4+XLFkSY8aMafPzli5d2uI4l6XdrrR+/frYsmVLxllFRUXCaQAAAAAAAACg66TT6bj77rvjX/7lX+KNN95o0zVTpkyJX//613HwwQfnOB0AAAAAAEDP1CMKwDNmzIgZM2bkO0aPVVlZ2aIAvHLlyqznTp48uUUBeNGiRfHBD36wzc9atGhRi+MpU6a0I2n+ZNv9N8IOwAAAAAAAAAB0T+l0Oh544IH413/913j++efbdE1paWlccsklcfHFF9v1FwAAAAAAoBOK8h2AwtenT58Wx/X19VnPfX9hd/bs2e161pw5c7Z5v0K1bNmyrLNRo0YlmAQAAAAAAAAAOu+xxx6L6dOnxzHHHNPm8u/hhx8er7zySlx66aXKvwAAAAAAAJ2kAMx2vXdH34iIESNGZD137733bnH85JNPtvk5DQ0N8eyzz27zfoUqWwF42LBhPtQEAAAAAAAAoFtIp9Nx3333xfTp02P69Onx+OOPt+m6MWPGxO9+97t48MEHY9ddd81xSgAAAAAAgN6hJN8BKGxbt26N5557rsVaZWVl1vOPPfbYFsdPPvlk1NTUxIABA7b7rCeeeCI2b97cfLzrrrt2mw8Gq6qqMq6PHj064SQAAAAAAAAA0D4NDQ1xxx13xL//+7/HK6+80ubrysrK4uKLL45vfOMbbfq9AAAAAAAAANrODsBs02233dailFtaWhoHH3xw1vMrKytjn332aT7etGlT3HHHHW161m9+85sWxyeccEI70+ZPth2AKyoqEk4CAAAAAAAAAG2zfv36+PGPfxy77LJLfP7zn29X+fcLX/hCzJ07Ny677DLlXwAAAAAAgBxQACar5cuXxyWXXNJi7aijjoqysrJtXnfmmWe2OL7yyitjy5Yt27xmzpw5cfvttzcfFxUVxWmnnda+wHmUrQBsB2AAAAAAAAAACs3rr78e5557bowZMyYuuuiieOedd9p87XHHHRcvvfRS/Nd//VeMHTs2dyFpIZ1O5zsCAAAAAACQMAXgbuidd96JVCrV4rWtD+OWLVsWl112Waxdu7ZdzzjmmGNi6dKlzWupVCpmzpy53WvPOuusGDduXPPxm2++GV/96lezfhi1YcOG+OIXvxh1dXXNa5/73Odi9913b3PefKuqqsq4rgAMAAAAAAAAQCGor6+PO++8Mw4//PDYY4894he/+EXU1NS0+foZM2bE008/HXfffXfsvffeuQsKAAAAAABARESU5DtAT/Pggw9mXJ89e3aL47Vr12Y9d+LEiTFx4sQuy7R169b43ve+F9dcc00cf/zxcdJJJ8WBBx4YFRUVrc6dP39+3HjjjfGzn/0s1q9f32J24YUXxr777rvd5/Xt2zeuvPLK+NznPte8dv3118eqVaviBz/4Qeyyyy7N6w8//HB89atfjVdeeaV5beDAgfG9732vI99q3mTbATjTzxgAAAAAAAAAkjJ79uz47W9/GzfffHNUV1e3+/rDDjssZs6cGdOnT89BOt4rlUrlOwIAAAAAAFBAFIC72IwZM9p03iuvvJL13Msuu6xNO+2216ZNm+LWW2+NW2+9NSIihg0bFuXl5TFo0KCora2NZcuWxcqVKzNee/LJJ8fVV1/d5md99rOfjccffzx+8YtfNK/98Y9/jD/96U9RWVkZI0aMiIULF8aqVataXFdUVBQ33HBD7LTTTh34DvMjnU5nLQDbARgAAAAAAACApK1fvz5uv/32+O1vfxvPPPNMu69PpVJx4oknxre+9a344Ac/mIOEAAAAAAAAbI8CcC+2evXqWL169TbPKS0tjR/84Afx1a9+td1/afZnP/tZ9OvXL6699trmtXQ6HYsWLYpFixa1Or+srCxuuOGG+NSnPtWu5+Tbxo0bo6amJuPMDsAAAAAAAAAAJGHLli3xl7/8JW677ba45557ora2tt336NOnT3zhC1+Ib37zmzFlypQcpAQAAAAAAKCtFIB7gZEjR8aPf/zj+Otf/xpPPfVUrFixYrvXjB8/Pr7whS/El7/85Q6XWIuKiuKaa66J4447Li677LJ4/PHHM57Xt2/fOPnkk+OKK67oVjv/vivb7r8RdgAGAAAAAAAAIHfq6+vjoYceittuuy3+/Oc/x4YNGzp0n/Ly8jjnnHPinHPOiTFjxnRxSgAAAAAAADpCAbiLpdPpnD9jwoQJ7XpO//794ytf+Up85StfiYh/FFbnzp0bixYtilWrVsXmzZujb9++MXTo0CgvL49p06Z16c61H/nIR+IjH/lILFmyJJ588slYtGhRbNmyJXbYYYfYZZdd4sMf/nAMGjSoy56XtKqqqqwzBWAAAAAAAAAAutKWLVvi4YcfjrvuuivuvPPOWLVqVYfvdeCBB8b5558fn/rUp6K0tLQLUwIAAAAAANBZCsC90OjRo/NSTB07dmyccsopiT8317LtADx06NDo169fwmkAAAAAAAAA6GnWrl0b9913X/z3f/93zJo1KzZt2tThew0YMCBOOeWUOPfcc2P//ffvwpQAAAAAAAB0JQVg6KRsBWC7/wIAAAAAAADQEel0Ot58882YNWtW3HPPPfHoo49GQ0NDp+558MEHxxlnnBEnn3xy7LDDDl2UFAAAAAAAgFxRAIZOqqqqyrheUVGRcBIAAAAAAAAAuqsNGzbEQw89FPfff3/MmjUrFi5c2Ol7jho1Kk499dQ4/fTTY/LkyV2QEgAAAAAAgKQoAEMn2QEYAAAAAAAAgPZqaGiIF154IR588MG4//7746mnnur0Lr8REUOGDImTTjopPvvZz8b06dOjpMSvhgAAAAAAAHRHPuWBTlIABgAAAAAAAGB7Ghoa4sUXX4xHHnkkHnnkkXj88cdj06ZNXXLvAQMGxAknnBCf/exn46ijjoq+fft2yX0BAAAAAADIHwVg6KSqqqqM6xUVFQknAQAAAAAAAKBQ1NXVxUsvvRSPPvpolxd+I/6x0+/HP/7xOOGEE+JjH/tYlJWVddm9AQAAAAAAyD8FYOgkOwADAAAAAAAAUFVVFU899VTz64UXXoitW7d26TPGjRsXJ5xwQpx44olxyCGHRJ8+fbr0/gAAAAAAABQOBWDohE2bNsXGjRszzhSAAQAAAAAAAHqmrVu3xt///vcWhd9FixZ1+XNSqVQccMABccwxx8QJJ5wQe++9d6RSqS5/DgAAAAAAAIVHARg6IdvuvxERFRUVCSYBAAAAAAAAIBe2bNkSr7zySrzwwgvxwgsvxIsvvhivvfZa1NfX5+R5FRUVcfTRR8fRRx8dRx55ZAwbNiwnzwEAAAAAAKCwKQBDJ2yrAGwHYAAAAAAAAIDupaamJl577bXmsu8LL7wQr7/+ejQ0NOTsmf3794+DDz64ufS7xx572OUXAAAAAAAABWDojKqqqozrgwcPjrKysoTTAAAAAAAAANAWjY2NsWDBgnj11VfjlVdeiVdffTVeffXVWLBgQaTT6Zw++93C72GHHRaHHXZYTJs2Lfr27ZvTZ9L95fqfSwAAAAAAoPAoAEMnZNsB2O6/AAAAAAAAAPmXTqdj2bJlMXv27OaS7yuvvBKzZ8+O2traRDKUlZXFQQcdpPALAAAAAABAuygAQycoAAMAAAAAAADkX11dXcyfPz/eeOONVq+NGzcmmmXSpEnxoQ99qPm15557RkmJX88AAAAAAACgfXzCBJ1QVVWVcb2ioiLhJAAAAAAAAAA9WzqdjhUrVsT8+fNj3rx5LUq+CxYsiMbGxsQz9e/fP6ZNmxYf+tCH4qCDDooDDzwwysvLE88BAAAAAABAz6MADJ1gB2AAAAAAAACArtPY2BiLFy+OBQsWxPz581u8L1iwIGpqavKWraysLPbee+/Yb7/9ml9Tpkyxuy8AAAAAAAA54VMo6IRsBWA7AAMAAAAAAAC0lk6nY926dfHOO+/EwoULY+HChc3l3vnz58fbb78d9fX1+Y4ZAwYMiH322Sf23XffFmXf4uLifEcDAAAAAACgl1AAhk6oqqrKuG4HYAAAAAAAAKA3SqfTsWLFihYF34ULF7Y43rhxY75jNisqKoqdd9459txzz9hrr71izz33jD333DMmTpwYRUVF+Y4HAAAAAABAL6YADB1UW1sb69evzzhTAAYAAAAAAAB6o/322y/q6uryHSOj8vLyFiXfvfbaK3bffffo379/vqMBAAAAAABAKwrA0EHLly/POlMABgAAAAAAAHqjfJd/i4qKYtKkSTFlypSYMmVK7LbbbjFlypSYPHly7LjjjnnNBgAAAAAAAO2hAAwdtK0C8KhRoxJMAgAAAAAAANC7DBo0KHbdddfmgu+7r0mTJkVpaWm+4wEAAAAAAECnKQBDB2UrAPfv3z922GGHhNMAAAAAAAAA9Czl5eUxadKk2HnnnVu9Dxs2LFKpVL4jAgAAAAAAQM4oAEMHZSsAjx492gfNAAAAAAAAANtRUlISlZWVMWHChFYF34kTJ8agQYPyHREAAAAAAADyRgEYOihbAXjUqFEJJwEAAAAAAAAoPP369Yvx48fH+PHjY8KECc1fv3s8evToKC4uzndMAAAAAAAAKEgKwNBBy5Yty7iuAAwAAAAAAAD0VldffXV8+MMfjgkTJsSIESMilUrlOxIAAAAAAAB0SwrA0EF2AAYAAAAAAABo6eijj46pU6fmOwYAAAAAAAB0e0X5DgDdlQIwAAAAAAAAAAAAAAAAAJALCsDQQQrAAAAAAAAAAEASamtr8x0BAAAAAABImAIwdEA6nVYABgAAAAAAAAC61IgRIzKuP/nkkwknAQAAAAAA8k0BGDpg7dq1UV9fn3GmAAwAAAAAAAAAdMTBBx+ccf2hhx5KOAkAAAAAAJBvCsDQAcuWLcs6Gz16dIJJAAAAAAAAAICe4vDDD8+4/txzz8WGDRsSTgMAAAAAAOSTAjB0wPLly7POysvLE0wCAAAAAAAAAPQURxxxRMb1xsbGeOyxxxJOAwAAAAAA5JMCMHRAtgLwsGHDom/fvgmnAQAAAAAAAAB6gt122y1GjRqVcfbwww8nnAYAAAAAAMgnBWDogGwF4GwfwgEAAAAAAAAAbE8qlYrDDz8840wBGAAAAAAAehcFYOgABWAAAAAAAAAAIBeyFYD//ve/x8qVKxNOAwAAAAAA5IsCMHSAAjAAAAAAAAAAkAtHHHFE1tkjjzySXBAAAAAAACCvFIChA5YtW5ZxXQEYAAAAAAAAAOiMCRMmxE477ZRx9tBDDyWcBgAAAAAAyJeSfAeA7ijbDsCjR49OOAkAAAAAAAAA0NMcccQR8etf/7rV+sMPP5yHNAAAAAAA0HUaGxujrq4u6uvrm9/f+3VXr61YsSLf33KHKQBDB2QrANsBGAAAAAAAAADorMMPPzxjAXjevHmxePHiqKyszEMqAAAAAAAKQTqdjoaGhkRLtO1d29YsnU7n+0fYbSgAQzvV1dXF6tWrM84UgAEAAAAAAACAzjr88MOzzh5++OE49dRTE0wDAAAAAND9pNPpaGxsbC6hNjQ0tHjP9nVn50k8q76+Pt8/XhKiAAztVF1dnXWmAAwAAAAAAAAAdNbIkSNj6tSp8frrr7eaPfTQQwrAAAAAAECXSKfTiRdkk5o3NDTk+8cLnaYADO20fPnyrDMFYAAAAAAAAACgKxxxxBEZC8APP/xwpNPpSKVSeUgFAAAAAL1PY2NjwZRau3pX2qampnz/eIFtUACGdspWAO7Tp08MHTo04TQAAAAAAAAAQE90+OGHx09+8pNW60uXLo25c+fGlClT8pAKAAAAAFpLp9PR2NhYMKXWrp6n0+l8/4iBXkoBGNpp2bJlGddHjhwZRUVFCacBAAAAAAAAAHqi6dOnR1FRUcYdOO6//34FYAAAAIBuJp1OF9yusF01b2hoyPePF+jBioqKom/fvtGnT59W721Z27x5c9x33335/jY6RAEY2inbDsCjRo1KOAkAAAAAAAAA0FMNGTIkDjjggHj66adbzWbNmhUXXnhhHlIBAAAA5FZTU1Obd3zNd+m1vfNMf+gNICklJSUZy7LtKdJmW8v1+Z3dtPP1119XAIbeIlsBePTo0QknAQAAAAAAAAB6smOOOSZjAfjRRx+NLVu2RL9+/fKQCgAAAMi3dDodjY2N7SrHdnSW9D3S6XS+f7wAUVxcHH369Gkuzb7360xrnZ2355qOlGv79OkTqVQq3z9WOkABGNrJDsAAAAAAAAAAQBKOPvromDlzZqv12traePzxx2PGjBnJhwIAAIBuJJ1OF3zhtaP3AMi3JMqu+Zory1IoFIChnRSAAQAAAAAAAIAkTJs2LYYOHRpr165tNZs1a5YCMAAAADnz3t1l333V1dW1aa0953b2+u2VZpuamvL9owR6saKiooIos+ZiXlRUpCQLCVAAhnZSAAYAAAAAAAAAklBcXBxHHnlk/OEPf2g1u//+++Pqq6/OQyoAAAC2JZ1OtyqhFkpRtj3PSqfT+f5RAr1ESUlJ3susnZlv65qioqJ8/3iBbk4BGNohnU7HsmXLMs4UgAEAAAAAAACArnbMMcdkLAC//vrrsWTJkhg7dmweUgEAACSnqampuZT63ldb13J17vvX3lugBehq75ZK81lmzcW8pKTELrIA26AADO2wcePGqK2tzThTAAYAAAAAAAAAutpRRx2VdfbAAw/EGWeckWAaAACgp2hsbIytW7dGXV1dq/euLMV2xfWNjY35/nEB3UBRUVHBl107Oi8uLs73jxeAPFEAhnZYvnx51pkCMAAAAAAAAADQ1caOHRtTp06N119/vdVs1qxZCsAAAFDAmpqaYuvWrVmLttlm7T2/I/dSqoXe6/1l020VUdtSUi2Ee5SUlERRUVG+f7QA0OUUgKEdFIABAAAAAAAAgKQdc8wxGQvADz74YDQ2NtoFBgAAIiKdTsfWrVtjy5YtzcXXd79u63tXl3CVbKH7enc32UItvHb0HsXFxZFKpfL94wUA2kgBGNohWwF40KBBUVZWlnAaAAAAAAAAAKA3OProo+Pqq69utb527dp47rnn4sADD8xDKgAA+IfGxsY2l2vbW8htz7V1dXX5/lFAr/fe4um7r759+7ZprT3nvnctV6VZu8kCAIVAARjaIVsB2O6/AAAAAAAAAECuHHLIIdG/f/+ora1tNfvLX/6iAAwAQDQ0NMSWLVuitrY24/u2Zm19z1bIbWhoyPe3D91eKpXqdCm2owXarrq+pKTEzrIAAF1MARjaYdmyZRnXFYABAAAAAAAAgFzp169fTJ8+PWbNmtVqdu+998bll1+eh1QAAGTS2NgYtbW1sXnz5qitre3SAu62Zkq48H/69u3b/Hq3rPr+V3vW23JuZ0u1xcXF+f6xAQBQgBSAoR3sAAwAAAAAAAAA5MNHP/rRjAXgF198MZYuXRpjxozJQyoAgO4hnU7Hli1bmku5733v6rW6urp8f7vQ5TpTjE26jGsXWgAAehIFYGgHBWAAAAAAAAAAIB+OO+64uPDCCzPO7r333jjnnHMSTgQA0DUaGhqipqam1Wvz5s0tjjtbzoVCVlRUFKWlpdG3b9+M70nO3v+1Qi0AAOSPAjC0gwIwAAAAAAAAAJAPO+20U0ydOjVef/31VrN77rlHARgAyJl0Oh21tbXbLeh2dG7HXJKUSqWiX79+0a9fvygtLW31nnTZ9t1ZcXFxvn80AABAAVIAhnZQAAYAAAAAAAAA8uW4447LWAB+6KGHYvPmzVFWVpaHVABAoUin07F169bYuHFjbNq0qfn13uNsX2+roLt58+ZIp9P5/vbo5kpKSlqUbLMVcLf33tlr7GYLAAB0JwrA0EaNjY1RXV2dcTZ69OiE0wAAAAAAAAAAvc1xxx0XV155Zav1LVu2xIMPPhjHH398HlIBAB1VV1e33WJuWwu8737d2NiY72+LAtWnT5/o379/9OvXb7vv2dYy7Zzb1gKuHW4BAADaTwEY2mjt2rXR1NSUcWYHYAAAAAAAAAAg1z74wQ/G8OHDY9WqVa1m99xzjwIwACSgvr4+Nm7cGBs2bGh+z/TKNntvabeuri7f3w55UFpa2qbCbUffs60p4AIAAHQ/CsDQRpk+PHuXAjAAAAAAAAAAkGvFxcVx7LHHxk033dRqdu+990ZTU1MUFRXlIRkAFLZ0Oh2bN2/ebjG3LWXe2trafH875EBZWVn079+/xXtH1t4/f+/r3d1w/f81AAAA2koBGNooWwG4qKgoRowYkXAaAAAAAAAAAKA3Ou644zIWgJcvXx4vvPBCTJs2LQ+pACC3GhoaYv369bFu3bpW75nWMr03Njbm+9ugnYqKimLAgAExYMCAKCsriwEDBuSkpNuvX79IpVL5/nYBAACgFQVgaKNsBeARI0ZEcXFxwmkAAAAAAAAAgN7oqKOOir59+0ZdXV2r2V133aUADEBBqq2tjbVr1263sJttVlNTk+9vgSxKS0ubS7rZXu+Wd9s7Ly0tVcwFAACgV1MAhjbKVgAeNWpUwkkAAAAAAAAAgN5qhx12iMMOOyweeOCBVrM//vGPccUVVyjKAJAT9fX1sXbt2ubXmjVrWrxva23r1q35jt+rFRUVxcCBA2OHHXaIgQMHtvp64MCBHSrvlpWV2UAFAAAAckgBGNpIARgAAAAAAAAAKAQnnnhixgLw3LlzY/bs2TF16tQ8pAKgO0in07Fx48ZYtWrVdsu7759t2rQp3/F7jUwl3W2Vd7c369evnz8QAgAAAN2QAjC0kQIwAAAAAAAAAFAIPvGJT8R5550X6XS61eyPf/yjAjBAL9HU1BTr1q2L1atXx6pVqzK+v39tzZo1UV9fn+/oPU6fPn1i8ODBscMOO8SgQYNavN6/tsMOO2yz2Nu/f/8oKirK97cEAAAAFAAFYGijlStXZlwfPXp0wkkAAAAAAAAAgN5s1KhRccghh8Rjjz3WavanP/0pLrvssjykAqAzGhsbY82aNbFq1aqs5d33r61ZsyaampryHb1be7ecm6m425710tLSfH8rAAAAQA+kAAxtZAdgAAAAAAAAAKBQnHTSSRkLwK+++mrMnTs3Jk+enIdUALyrqakp1q5dGytXrozq6upW7+9fW716tTJvO+2www4xZMiQGDx4cIv3TGuDBw+OwYMHtyjtDhw40E67AAAAQEFTAIY2ylYAHjlyZMJJAAAAAAAAAIDe7pOf/GRceOGFGWd/+tOf4jvf+U7CiQB6tnQ6HevXr99mife976tWrYrGxsZ8xy5YJSUlWcu62Qq8730fNGhQFBcX5/vbAAAAAMgpBWBoo5qamozrdgAGAAAAAAAAAJI2duzY+NCHPhRPPfVUq5kCMEDb1dTUxPLly1u9VqxY0Wqtvr4+33ELSklJSey4444xdOjQGDp0aPPX21p7t+Dbv3//SKVS+f4WAAAAAAqaAjB0kh2AAQAAAAAAAIB8OOmkkzIWgF988cWYP39+7LzzznlIBZB/dXV1UV1dnbHY+/6C76ZNm/IdN69SqVQMGTKkXSXed78eMGCAEi8AAABADikAQycpAAMAAAAAAAAA+XDSSSfFN77xjYyzW2+9Nb773e8mnAggt+rr62P58uVRVVUVVVVVsXTp0lZfL1++PNasWZPvqHnRt2/fGDZsWAwfPrzFe7a1HXfcMYYMGRJFRUX5jg4AAABABgrA0Al9+vSJoUOH5jsGAAAAAAAAANALTZgwIaZNmxbPPfdcq9ktt9wSl156qZ0ZgW6hqakpVq1a1VzmzVbura6ujnQ6ne+4iSgrK2tTife9a3bkBQAAAOhZFIChE8rLy/0HUwAAAAAAAAAgbz7/+c9nLAC/+eab8fzzz8e0adPykArg/zQ0NERVVVUsXry4xeu9xd5ly5ZFfX19vqPm1MCBA6O8vDxGjBixzffhw4fH8OHDo3///vmODAAAAECeKQBDJ4wcOTLfEQAAAAAAAACAXuwzn/lMfP3rX4/GxsZWs1tuuUUBGMippqamWL58eaty75IlS5q/XrZsWTQ1NeU7apfr379/lJeXb7PM++7XI0aMUOgFAAAAoN0UgKETFIABAAAAAAAAgHwaOXJkHHnkkXH//fe3mv3+97+Pq666KkpK/IoQ0H7pdDrWrVsXCxcujIULF7Yq+S5evDiWLl0aDQ0N+Y7aZcrKymL06NExcuTIGDVqVKtXeXl5jBw5MkaMGBEDBgzId1wAAAAAejj/dR86QQEYAAAAAAAAAMi3f/qnf8pYAK6uro6HHnoojj766DykAgpdOp2ONWvWxMKFC+Odd95pfr33eMOGDfmO2WklJSUZy7yZSr4DBw7Md1wAAAAAaKYADJ2gAAwAAAAAAAAA5NuJJ54YZWVlsXnz5lazm2++WQEYeql0Oh2rVq3aZsF306ZN+Y7ZYf369YuKioqoqKiIMWPGNH89evToGD16dHPJd+jQoVFUVJTvuAAAAADQbgrA0AkKwAAAAAAAAABAvg0cODBOPPHEuPXWW1vN7rzzzli3bl0MGTIk+WBAzm3dujXefvvtWLBgQbz11luxYMGC5q/feeedjH8YoNAVFxfHqFGjMpZ73/v10KFDI5VK5TsuAAAAAOSMAjB0ggIwAAAAAAAAAFAIPv/5z2csANfW1satt94a5557bh5SAV1hzZo1Lcq97y35LlmyJNLpdL4jttnAgQOjsrIyKisrY+zYsRnLveXl5VFcXJzvqAAAAACQdwrA0AkKwAAAAAAAAABAITjqqKNi9OjRsWzZslazX/3qV/HlL3/ZTplQoNLpdCxfvjzefPPNmDdvXquy77p16/IdsU369esXY8eObS74ZnoNHjzY/xYBAAAAQBspAEMnKAADAAAAAAAAAIWgpKQkTj/99PjBD37Qavbyyy/HCy+8EPvvv38ekgHvWrduXbz55putXvPmzYtNmzblO942lZSUZCz3vndt+PDhyr0AAAAA0IUUgKETFIABAAAAAAAAgEJx5plnZiwAR0T8+te/VgCGBNTW1sb8+fNbFXzffPPNWLlyZb7jZdWnT58YP358TJgwofn13uPRo0dHcXFxvmMCAAAAQK+iAAwdVFxcHMOGDct3DAAAAAAAAACAiIiYOHFiHHnkkfHggw+2mt16661x1VVXxcCBA/OQDHqWdDodK1asiDlz5jS/3njjjXjzzTdj0aJF+Y6XUWlpaYtC7/vLvqNGjYqioqJ8xwQAAAAA3kMBGDpoxIgR/qM3AAAAAAAAAFBQzjrrrIwF4I0bN8bvfve7+NKXvpSHVNA9NTU1xcKFC1sUfWfPnh1z5syJdevW5TteC6lUKsaOHRsTJ06MSZMmxaRJk2KnnXaKnXbaKSZMmBDl5eV+1wkAAAAAuhkFYOigkSNH5jsCAAAAAAAAAEALJ5xwQgwfPjxWrVrVavbjH/84zj77bCVAeJ+6urqYP39+q6Lv3Llzo7a2Nt/xmpWWlrYo+E6aNKn5eMKECdGvX798RwQAAAAAupACMHSQAjAAAAAAAAAAUGhKS0vj9NNPjx/+8IetZm+88Ub87//+bxx99NF5SAb59+6Ovq+++mq8+uqr8dprr8Wrr74ac+fOjYaGhnzHi4iIHXfcMXbeeedWBd9JkybF6NGjFfgBAAAAoBdRAIYOUgAGAAAAAAAAAArReeedF1dffXU0NTW1mv34xz9WAKZXqK6ubi74vlv2ff3112PTpk35jhZlZWWxyy67xK677tritcsuu8SwYcPyHQ8AAAAAKBAKwNBBCsAAAAAAAAAAQCEaP358fPKTn4w//vGPrWZ/+ctf4o033ogpU6bkIRl0vc2bN7cq+r766qtRXV2d11wlJSUxceLEViXfXXfdNSoqKiKVSuU1HwAAAABQ+BSAoYMUgAEAAAAAAACAQnXhhRdmLABHRPzoRz+K66+/PuFE0HkrV66Ml19+ufn10ksvxdy5czPudp2U4cOHx2677Ra77bZbTJkyJSZPnhy77rprjB8/Pvr06ZO3XAAAAABA96cADB2kAAwAAAAAAAAAFKqDDz449ttvv3jhhRdazW644Ya49NJLY8yYMXlIBtvX1NQUb7/9dnPJ993C79KlS/OWqbKysrnou/vuuzd/PXz48LxlAgAAAAB6NgVg6CAFYAAAAAAAAACgUKVSqbjoooviC1/4QqtZXV1dXHXVVXHttdfmIRm0VF9fH7Nnz44XXnihxe6+GzduTDxLcXFxTJo0qbnc+27Zd8qUKTFw4MDE8wAAAAAAvZsCMHSQAjAAAAAAAAAAUMhOOeWU+M53vhOLFy9uNfvlL38Z3/72t6O8vDwPyeitGhsb44033ojnn3+++fXyyy/Hli1bEs+y0047xR577BF77rln7LnnnjF16tTYddddo7S0NPEsAAAAAACZKABDB/kADAAAAAAAAAAoZH379o1vfetbcf7557ea1dbWxjXXXBNXXnllHpLRGzQ1NcW8efNalH1ffPHF2Lx5c6I5hg8f3lzy3XPPPWOPPfaIqVOnxg477JBoDgAAAACA9lIAhg5IpVIxYsSIfMcAAAAAAAAAANimM888M77//e/H8uXLW81+/vOfx9e//nW/A0GnpdPpeOedd+LZZ59tLvu+8MILsXHjxsQylJWVxdSpU1sUfffcc88YOXJkYhkAAAAAALqSAjB0wLBhw6KkxL8+AAAAAAAAAEBh69evX3zzm9+Mr3/9661mmzZtiiuuuCJ+8pOf5CEZ3dnGjRvj+eefj6effrr5VV1dndjzR44cGfvss0/svffeza+dd945iouLE8sAAAAAAJBrGozQAf4yKAAAAAAAAADQXZxzzjnxb//2b7Fq1apWs+uvvz4uvPDCmDRpUh6S0R00NTXF3LlzW5R9X3vttWhqasr5s1OpVOyyyy6x9957tyj8jho1KufPBgAAAADINwVg6AAFYAAAAAAAAACguxgwYEBcfPHFcfHFF7ea1dfXxyWXXBK33XZbHpJRiNasWRPPPPNMc9n3mWeeifXr1+f8uX379o299tqruei7zz77xJ577hkDBw7M+bMBAAAAAAqRAjB0gAIwAAAAAAAAANCdnH/++fGTn/wklixZ0mp2++23x4UXXhgf+tCH8pCMfEqn0/HWW2/F3/72t/jb3/4WTzzxRMyZMyfnzy0pKYm99tor9t9//+bX1KlTo2/fvjl/NgAAAABAd6EADB2gAAwAAAAAAAAAdCf9+/ePK664Ik4//fSM83PPPTeee+65KCnx60Q9WUNDQ/z9739vLvz+7W9/i+XLl+f0mcXFxTF16tQWZd8999wz+vXrl9PnAgAAAAB0d/6LPXSAAjAAAAAAAAAA0N184QtfiGuuuSZeffXVVrOXX345rrvuuvjKV76Sh2TkyqZNm+Lpp59uLvs+/fTTUVNTk9NnTpkyJaZNm9Zc9t17772jrKwsp88EAAAA/n/27jvMqupsHPYzQy/Su4AUAUUEpVlABBRjbPG1xZIo6k+jxiQaSyyx5bUmMUaTGBMbxBKjCXbjK4KgiGJBUQQpAiJopEjvZX9/+DnxMDPMGZg5c+bMfV/XuS7XPmvtZ+1xFmfv/cyzDwC5SAEw7AAFwAAAAAAAAABAZVOtWrX4zW9+E4cffniR719zzTVx4oknRuvWrTM8M8rK8uXLY/z48fHKK6/EhAkT4v33348tW7aUW7wmTZrE/vvvX/Dq169fNGrUqNziAQAAAABUJQqAYQcoAAYAAAAAAAAAKqPvfOc7cfzxx8e//vWvQu+tXLkyzj333HjmmWciLy+vAmZHaa1ZsyYmTJgQY8eOjbFjx8bkyZNj69at5RKrevXq0atXr5SC386dO/tdAQAAAAAoJwqAYQcoAAYAAAAAAAAAKqs77rgjXnzxxVizZk2h95577rl48MEH46yzzqqAmVGSDRs2xJtvvllQ8Dtp0qTYtGlTucRq06ZNHHDAAQXFvr179466deuWSywAAAAAAApTAAw7QAEwAAAAAAAAAFBZtWvXLq677rq4/PLLi3z/oosuiqFDh0aHDh0yOzEK2bx5c0yePDnGjh0bY8aMiddffz3WrVtX5nHy8vKiZ8+eMXDgwBgwYEAMGDAg2rdvX+ZxAAAAAABInwJg2AEtWrSo6CkAAAAAAAAAAOywiy66KP7+97/He++9V+i9VatWxUknnRSvvfZa1KpVqwJmV3Vt3bo1pk6dWvANv+PHj4+VK1eWeZzatWvHfvvtFwMHDoyBAwfGAQccEA0bNizzOAAAAAAA7DgFwFBKjRs3jpo1a1b0NAAAAAAAAAAAdliNGjXib3/7W/Tp0yc2btxY6P233347Lrroovjzn/9cAbOrOpIkiVmzZhUU/L7yyiuxZMmSMo/TtGnTgmLfgQMHRu/evf39CwAAAABAllMADKXUsmXLip4CAAAAAAAAAMBO69GjR9x4441x+eWXF/n+PffcE/369YuzzjorwzPLbfPnz49XXnklxowZE2PHjo2FCxeWeYxdd901hg4dGoMGDYqBAwdGt27dIi8vr8zjAAAAAABQfhQAQykpAAYAAAAAAAAAcsXPf/7zeO655+LVV18t8v0f/ehH0bZt2zjssMMyPLPcsWjRonjllVcKvuV39uzZZR6jWbNmMWTIkBg6dGgccsghsfvuuyv4BQAAAACo5BQAQykpAAYAAAAAAAAAckW1atXisccei969e8d//vOfQu9v3rw5jj/++Bg/fnz07t27AmZY+SxfvjzGjx9fUPA7derUMo/RoEGDOPjgg2Po0KExdOjQ6NGjR+Tn55d5HAAAAAAAKo4CYCglBcAAAAAAAAAAQC5p3bp1PP744zFkyJDYsmVLofdXr14dw4YNi9GjRysCLsKaNWvi9ddfjzFjxsTYsWNj8uTJsXXr1jKNUadOnRg4cGBBwW/v3r2jenV/+gUAAAAAkMvcBYZSUgAMAAAAAAAAAOSagw46KH73u9/Fz372syLf/+qrr+KQQw6J//u//4v+/ftneHbZZcOGDTFp0qSCb/h98803Y9OmTWUao0aNGrH//vsXFPzut99+UatWrTKNAQAAAABAdlMADKWkABgAAAAAAAAAyEU//elPY+7cufH73/++yPeXL18eQ4YMiUceeSSOPfbYjM6tIm3evDkmT55cUPA7YcKEWLduXZnGyM/Pj969excU/A4cODDq1atXpjEAAAAAAKhcFABDKSkABgAAAAAAAABy1e233x6ff/55PP7440W+v3bt2jjuuOPixhtvjCuuuCLy8/MzPMPyt3Xr1pgyZUq88sorMW7cuBg/fnysXLmyzOP06NGjoOB30KBB0bhx4zKPAQAAAABA5aUAGEpJATAAAAAAAAAAkKvy8/Nj5MiRsXr16njhhReK7JMkSVx99dUxduzYGDlyZOy6664ZnmXZ2rp1a3z44Ycxbty4eOWVV+LVV1+NZcuWlXmc3XffvaDgd/Dgwf4GBQAAAACA7VIADKUk+QIAAAAAAAAA5LLatWvHqFGj4qSTTopnnnmm2H5jxoyJvfbaK2666aY477zzolq1ahmc5Y7bunVrfPTRRzF+/Ph45ZVXYvz48bF06dIyj7PrrrsWFPwOHTo02rdvX+YxAAAAAADIXQqAoZQUAAMAAAAAAAAAua5WrVrxxBNPxBlnnBGPPfZYsf1WrFgRF154Ydx7771xww03xDHHHBN5eXkZnGnJVq9eHW+99Va8/vrr8frrr8ebb74ZK1asKPM4zZo1iyFDhhQU/Hbp0iXrfhYAAAAAAFQeCoChFBo0aBC1a9eu6GkAAAAAAAAAAJS7mjVrxqOPPhrdunWLG264Ybt9p0yZEscee2z06tUrfvzjH8fJJ58cu+yyS4Zm+l+bN2+O6dOnx+TJk+Odd96JiRMnxpQpU2LLli1lHqtBgwZx8MEHFxT89ujRI/Lz88s8DgAAAAAAVZMCYCgF3/4LAAAAAAAAAFQleXl5cf3118eee+4Z/+///b9YvXr1dvtPmTIlzj333Pj5z38eRx11VBx99NFx+OGHR5MmTcp8bkuXLo3p06fH9OnT47333ovJkyfHlClTYv369WUeKyKiTp06MXDgwIKC3969e0f16v78CgAAAACA8uEONJSCAmAAAAAAAAAAoCr6/ve/H3379o3TTjstJk2aVGL/1atXx2OPPRaPPfZYRETsueeesd9++8Vee+0Vu+++e3Ts2DGaN28ejRs3jjp16qSM3bp1a6xatSpWrlwZy5cvj4ULF8Znn30WCxYsiM8++yxmzZoVH3/8cSxZsqRcjvUbNWvWjAMOOCAGDx4cQ4YMif333z9q1apVrjEBAAAAAOAbCoChFBQAAwAAAAAAAABVVefOneO1116L22+/Pf73f/831q5dm/bYb76ptyg1a9aMatWqFbTXr18fSZLs9HxLq0aNGrHffvsVFPwecMABhYqTAQAAAAAgUxQAQykoAAYAAAAAAAAAqrIaNWrEFVdcEaeeempccskl8c9//nOn97lx48YymFnp1ahRI/r27RtDhgyJwYMHx4EHHhj16tWrkLkAAAAAAMC2FABDKSgABgAAAAAAAACIaN++fTzxxBMxZcqU+NWvfhWjRo2q6CmVqGnTpnHggQfGgQceGAMGDIi+ffv6hl8AAAAAALKWAmAoBQXAAAAAAAAAAAD/1atXr/jXv/4VM2fOjPvuuy9GjBgRixcvruhpRY0aNWLvvfeO3r17xwEHHBADBgyIrl27Rl5eXkVPDQAAAAAA0qIAGEpBATAAAAAAAAAAQGFdu3aNX//613HjjTfGuHHj4plnnolnn3025s+fX+6xGzZsGHvuuWfsu+++0bt37+jdu3f06NEjatasWe6xAQAAAACgvCgAhlJQAAwAAAAAAAAAULyaNWvGYYcdFocddlj84Q9/iHnz5sWkSZNi0qRJMX369Jg9e3bMmzcvtmzZkvY+8/LyonXr1tG2bdto165dtG3bNrp16xZ77rln7LHHHtGyZUvf7AsAAAAAQM5RAAxpOuuss6JTp04VPQ0AAAAAAAAAgEohLy8vOnbsGB07doyTTz65YPumTZtiyZIlsWzZsli2bFmsXLkykiSJiIgkSaJ27drRsGHDaNiwYTRo0CCaNGkSNWrUqKjDAAAAAACACqEAGNL085//3DcAAwAAAAAAAADspBo1akTr1q2jdevWFT0VAAAAAADIWvkVPQEAAAAAAAAAAAAAAAAAAOC/FAADAAAAAAAAAAAAAAAAAEAWUQAMAAAAAAAAAAAAAAAAAABZRAEwAAAAAAAAAAAAAAAAAABkEQXAAAAAAAAAAAAAAAAAAACQRRQAl5M5c+bEY489FhdffHEMGDAg6tatG3l5eQWvwYMHZ3Q+3469s6/rr79+u7Guv/76ndr/8OHDM/IzAQAAAAAAAAAAAAAAAADIRtUregK55Jlnnom//OUv8dZbb8WSJUsqejrlpmbNmhU9BQAAAAAAAAAAAAAAAACAnKUAuAyNHTs2XnjhhYqeRrk76qijKnoKAAAAAAAAAAAAAAAAAAA5SwFwhtSrVy/WrFlTYfFHjx69Q+P++Mc/xtNPP13Q3nfffaNnz56l2sdvf/vb6NWrV9r927RpU6r9AwAAAAAAAJS3JEniww8/jA8//DC++OKLWL9+fdSrVy/atGkT3bp1ix49ekT16juXgl+1alW8/vrrMXPmzFi5cmXUqVMndttttzjwwAPlUQEAAAAAAKCKUQBcDpo0aRL9+vUrePXv3z9efPHFOPPMMytsToceemipx2zdurXQnIcPH17q/fTp0ycGDx5c6nEAAAAAAAAAFW3RokXxu9/9LkaOHBn/+c9/iu1Xt27dGDhwYJx++ulx2mmnlSrG3Llz49prr43HH388Nm7cWOj9vLy8OPjgg+OGG26IQYMGlfoYAAAAAAAAgMpHAXAZOuecc+InP/lJdO7cuaKnUiZefvnlWLBgQUG7Ro0aceqpp1bgjAAAAAAAAAAy54EHHoiLLrooVq1aVWLftWvXxksvvRQrVqwoVQHw448/HmeeeWasXbu22D5JksS4ceNi8ODBcfnll8ctt9wSeXl5accAAAAAAAAAKh8FwGVor732qugplKkRI0aktI866qho1qxZxUwGAAAAAAAAIIMuuuiiuPPOOwttr1evXrRp0yaaNGkSq1evjgULFsSKFSt2KMYTTzwRp5xySmzdujVle/PmzaNdu3axaNGiWLhwYSRJEhFfFwLfdtttsWHDhrjjjjt2KCYAAAAAAABQOeRX9ATITitXroynnnoqZdvw4cMrZC4AAAAAAAAAmXTNNdcUKv497bTTYvz48bFixYqYOXNmvPnmmzF16tRYvnx5zJ07N/7617/Gd77zncjPTy8N/8knn8SZZ56ZUvzbq1evGDt2bCxatCjefffd+Oyzz2L69Olx3HHHpYz9/e9/H6NGjdr5AwUAAAAAAACylgJgivSPf/wj1q1bV9Bu0aJFHHHEERU4IwAAAAAAAIDy99prr8VNN91U0G7QoEGMGTMmHn744Rg0aFBUq1at0JgOHTrEOeecEy+++GI8//zzacW55pprYs2aNQXtfv36xauvvhpDhgxJ6detW7f45z//Geeee27K9ssvvzw2b95cmkMDAAAAAAAAKhEFwBRp5MiRKe3TTjstqlevXkGzAQAAAAAAACh/GzZsiHPPPTeSJImIiOrVq8eLL74YQ4cOTXsfjRs3LrHPRx99FP/4xz8K2jVr1oyRI0dGgwYNiuyfl5cXd955Z3Tp0qVg2yeffBIPPvhg2vMCAAAAAAAAKhcFwBQye/bseP3111O2DR8+fKf2uWHDhpg+fXpMmDAhJk2aFLNnz461a9fu1D4BAAAAAAAAytI999wTH3/8cUH74osvjgMOOKDM4zzwwAOxdevWgvbJJ58ce+6553bH1K5dO6644oqUbffdd1+Zzw0AAAAAAADIDgqAKWTEiBEp7d69e0fPnj13eH8//vGPo1GjRtG9e/c46KCDYv/9948uXbpEw4YNY//9948bbrghFi9evJOzBgAAAAAAANg59957b8F/16xZs1DBbVl55plnUtpnn312WuO+//3vR7169Qrab7/9dnz++edlOjcAAAAAAAAgO1Sv6AmQXZIkiYceeihl285++++0adOK3L558+aYNGlSTJo0KW677ba49NJL47rrrotq1artVLyiLFq0qNRFxrNnzy7zeQAAAAAAAADZ6c0334yPPvqooH3EEUdEkyZNyjzOjBkzUnKR9erViwMPPDCtsd/0HT16dER8nd99/vnn45xzzinzeQIAAAAAAAAVSwEwKcaOHRvz588vaNesWTNOPfXUco+7bt26+N///d947bXX4tlnn4369euX6f7vvvvuuOGGG8p0nwAAAAAAAEDueP7551PaQ4YMKZc477//fkq7f//+Ub16+qn7AQMGFBQAF7U/AAAAAAAAIDfkV/QEyC4jRoxIaR911FHRtGnTUu8nLy8vDjzwwLjpppti9OjRsWDBgli7dm2sX78+Fi5cGM8++2z86Ec/itq1a6eMGzduXJx88smxZcuWnTkMAAAAAAAAgFJ5++23U9q9evUq+O/XXnstzjrrrNhrr72iQYMGscsuu0Tnzp3j6KOPjj/96U/x1VdfpR1n+vTpKe3u3buXap7b9t92fwAAAAAAAEBu8A3AFFi1alWMGjUqZdvw4cNLvZ/DDjssTj311OjatWuR77dp0ybatGkTRx11VPzyl7+Mk08+OV5//fWC959//vm4++674yc/+UmpYwMAAAAAAADsiHfeeSel3alTp1i0aFGcffbZ8dxzzxXqv3r16pgzZ04899xz8ctf/jKuueaa+PnPf15inBkzZqS027VrV6p5btt/2/0BAAAAAAAAuSEnCoAvuuiiuPPOO8s9znXXXRfXX399ucepKE888USsXbu2oN2yZcv47ne/W+r9HHjggWn3bdu2bbz88ssxdOjQeOONNwq233jjjXH22WdH3bp1Sx2/KBdccEGceOKJpRoze/bsOPbYY8skPgAAAAAAAJC9li1bFkuXLk3ZtmbNmhg4cGDMnz+/xPHLly+PSy65JN5777144IEHokaNGsX2XbRoUUq7bdu2pZrrrrvumtJevHhxqcYDAAAAAAAAlUNOFABTNkaOHJnSPu2006J69fL/Faldu3b87W9/iz333DM2b94cEV8nvV966aUyK8Bt0aJFtGjRokz2BQAAAAAAAOSW5cuXF9p22mmnFRT/Vq9ePU488cQ49NBDo1WrVrFixYqYOHFiPPLII7Fs2bKCMQ8//HC0aNEibr/99mJjrV69OqVdr169Us112/6bNm2KDRs2RK1atUq1n6IsWrSo1AXFs2fP3um4AAAAAAAAQGEKgImIiDlz5sRrr72Wsm348OEZi7/77rvHMcccE6NGjSrYVpYFwAAAAAAAAADFKaoAePLkyRER0bFjx3j22Wdjr732Snn/lFNOiWuvvTZOOeWUGDNmTMH2O+64I4455pg4+OCDi4y1bQFw7dq1SzXXOnXqFLnPsigAvvvuu+OGG27Y6f0AAAAAAAAAOy8nCoCPPPLIaNasWbnHGTRoULnHqCgjR46MJEkK2r1794699947o3M45JBDUgqAZ8yYkdH4AAAAAAAAQNW0bVHuN3bZZZcYM2ZMdOzYscj3mzdvHs8++2z0798/pk6dGhERSZLETTfdVGwB8Pr161PaNWvWLNVciyr0XbduXan2AQAAAAAAAGS/nCgAHjZsWAwbNqyip1FpJUkSf/vb31K2ZfLbf7/Rrl27lPbixYszPgcAAAAAAAAg8y666KK48847yz3OddddF9dff32h7cV9C+9VV11VbPHvN+rUqRN//OMfY/DgwQXbRo8eHXPnzi1y7LaxNm7cWPLEv2XDhg0l7hMAAAAAAACo/HKiAJidM378+Jg3b15Bu2bNmnHqqadmfB41atRIaW/atCnjcwAAAAAAAACqnvr16xfalp+fH2effXZa4w8++ODo1q1bzJgxo2Dbq6++WmQB8Laxtv1G4JIU9W2/Rc1/R1xwwQVx4oknlmrM7Nmz49hjjy2T+AAAAAAAAMB/KQAmRowYkdI++uijo2nTphmfx3/+85+UdvPmzTM+BwAAAAAAAKDqKaqAds899yxVznLQoEEpBcDvvPNOnHHGGSXGWrNmTSlmWrh/9erVy+wbgFu0aBEtWrQok30BAAAAAAAAO0cBcBW3Zs2a+Ne//pWybfjw4RUylwkTJqS027VrVyHzAAAAAAAAADLryCOPjGbNmpV7nEGDBhW5vXnz5pGfnx9bt24t2Na1a9dS7btbt24p7UWLFhXZb9sC2wULFpQqzsKFC1PaHqwMAAAAAAAAuUkBcBX3z3/+M1avXl3QbtWqVRx++OEZn8fy5csLFSIfcsghGZ8HAAAAAAAAkHnDhg2LYcOGVVj82rVrR4cOHWLOnDkF2xo0aFCqfWzbf9myZUX227ZQeP78+aWKs23/PfbYo1TjAQAAAAAAgMohv6InQMUaOXJkSvu0006L6tUzXxd+6aWXxvLlywvaNWvWjO9+97sZnwcAAAAAAABQNXXv3j2lvWHDhlKNX79+fUq7bt26RfbbtmB32rRppYozffr07e4PAAAAAAAAyA0KgCuhefPmRV5eXspr3rx5pd7Pp59+GuPGjUvZNnz48J2a26233hrvvvtu2v03b94cl1xySdx///0p288777xo3br1Ts0FAAAAAAAAIF29e/dOaX/55ZelGr9o0aKUdtOmTYvst88++6S033777di8eXPacV5//fXt7g8AAAAAAADIDZn/qtcc9/LLLxe5fdunNi9btqzYvp06dYpOnTqV+dy2NXLkyEiSpKDdp0+f6NGjx07t88UXX4wrr7wyDjzwwDjppJPikEMOiT322KPQtwqvWLEiXnjhhfj1r38d77//fsp7nTt3jmuvvXan5gEAAAAAAABQGsccc0z86le/Kmi/9957kSRJ5OXlpTV+2wcld+vWrch+e+yxR3Tu3Dk++eSTiIhYs2ZNTJw4MQYNGlRijDVr1sQbb7xR0M7Ly4ujjjoqrfkBAAAAAAAAlYsC4DI2bNiwtPp98MEHxfa97rrr4vrrry/DWRXtb3/7W0p7Z7/999smTpwYEydOjIiIWrVqRdu2baNhw4ZRrVq1WLp0acybNy+2bt1aaFyrVq3i3//+d7FPwwYAAAAAAAAoD3369In27dvH/PnzIyJi+fLlMWbMmDj00ENLHLt06dIYO3ZsyrbBgwcX2/+YY46JO+64o6B9//33p1UA/I9//CNWr15d0O7bt2+0adOmxHEAAAAAAABA5ZNf0ROgYrz22msFT5SOiKhZs2aceuqp5RJrw4YN8cknn8TkyZPj7bffjjlz5hRZ/HvEEUfElClTokuXLuUyDwAAAAAAAIDtOffcc1PaN954YyRJUuK4X//617Fhw4aCdqdOnaJPnz7F9j/rrLNSvln4sccei+nTp283xvr16+PWW29N2Xb22WeXODcAAAAAAACgclIAXEWNHDkypX300UdHkyZNdnq/V199dZx33nmx1157RbVq1UrsX79+/TjxxBNj/Pjx8fzzz0eLFi12eg4AAAAAAAAAO+Kiiy6Kli1bFrTHjx8f11133XbHPPPMM3H77benbLv88su3my/t0aNHnHTSSQXtjRs3xhlnnBErV64ssn+SJHHRRRfFrFmzCrZ16tQpzjrrrO3ODQAAAAAAAKi8qlf0BHJNOk9/3lkdOnTY6Tj33Xdf3HfffWU0o/8aNmxYDBs2LCIi1q5dG9OmTYt58+bFF198EatXr46tW7dGo0aNonHjxtG9e/fYe++90yoUBgAAAAAAAChv9erVi1tvvTXOPPPMgm3/+7//G7NmzYrrr78+unXrVrB98eLFcdddd8Vtt90WW7ZsKdh+0EEHpfXNvDfeeGM8++yzsXbt2oiIePvtt2PQoEHx+9//PgYPHlzQb+bMmXHllVfGqFGjUsbfeuutUaNGjR09VAAAAAAAACDLKQCm3NStWzf69u0bffv2reipAAAAAAAAAKRl+PDhMWnSpLjnnnsKtj322GPx2GOPRfv27aNly5axYsWK+OSTT1IKfyO+fpjzY489FtWrl5yK33333eP++++PU089teAB0FOmTIkhQ4ZE8+bNo3379rFo0aJYsGBBoQdE/+QnP4kTTzyxDI4WAAAAAAAAyFYKgAEAAAAAAADgW+6+++5o1KhR3HbbbSnFt/Pnz4/58+cXOeaAAw6IJ598Mlq2bJl2nJNPPjmSJImzzz471q1bV7B98eLFsXjx4iLHXHrppfHrX/867RgAAAAAAABA5ZRf0RMAAAAAAAAAgGySl5cXt9xyS7zxxhvx3e9+N/Lzi0+t9+jRI/72t7/FhAkTSlX8+41TTjklpk6dGqeeemrUqFGj2H6DBg2KcePGxW9+85vIy8srdRwAAAAAAACgcvENwAAAAAAAAABQhP322y9eeOGFWLJkSUycODHmzJkTq1evjoYNG0bLli1j//33j/bt2+90nE6dOsUjjzwSf/7zn2PChAkxa9asWLVqVdSuXTvat28fAwYMiF133bUMjggAAAAAAACoLBQAAwAAAAAAAMB2NGvWLI455phyj9OgQYM44ogjyj0OAAAAAAAAkP3yK3oCAAAAAAAAAAAAAAAAAADAfykABgAAAAAAAAAAAAAAAACALKIAGAAAAAAAAAAAAAAAAAAAsogCYAAAAAAAAAAAAAAAAAAAyCIKgAEAAAAAAAAAAAAAAAAAIIsoAAYAAAAAAAAAAAAAAAAAgCyiABgAAAAAAAAAAAAAAAAAALKIAmAAAAAAAAAAAAAAAAAAAMgi1St6ApCtNmzYkNKePXt2Bc0EAAAAAAAACts2f7VtfgsyQV4VAAAAAACAbFaZ86oKgKEYn332WUr72GOPrZiJAAAAAAAAQBo+++yz6N27d0VPgypGXhUAAAAAAIDKpDLlVfMregKQrZYvX17RUwAAAAAAAADIavKqAAAAAAAAUD4UAEMxVq5cWdFTAAAAAAAAAMhq8qoAAAAAAABQPqpX9AQgW/Xt2zel/fjjj0f37t0raDbAzpo9e3Yce+yxBe2nnnoqdt9994qbELDTrGvILdY05BZrGnKLNQ25xZqG3LJhw4b47LPPCtoHH3xwBc6GqkpeFXKL80XILdY05B7rGnKLNQ25xZqG3GJNQ26pzHlVBcBQjAYNGqS0u3fvHnvttVcFzQYoa7vvvrs1DTnGuobcYk1DbrGmIbdY05BbrGmo/Hr37l3RU6CKk1eF3OZ8EXKLNQ25x7qG3GJNQ26xpiG3WNNQ+VXWvGp+RU8AAAAAAAAAAAAAAAAAAAD4LwXAAAAAAAAAAAAAAAAAAACQRRQAAwAAAAAAAAAAAAAAAABAFlEADAAAAAAAAAAAAAAAAAAAWUQBMAAAAAAAAAAAAAAAAAAAZBEFwAAAAAAAAAAAAAAAAAAAkEUUAAMAAAAAAAAAAAAAAAAAQBZRAAwAAAAAAAAAAAAAAAAAAFlEATAAAAAAAAAAAAAAAAAAAGQRBcAAAAAAAAAAAAAAAAAAAJBFFAADAAAAAAAAAAAAAAAAAEAWqV7RE4Bs1bx587juuutS2kDlZU1D7rGuIbdY05BbrGnILdY05BZrGoCy5rMFcos1DbnFmobcY11DbrGmIbdY05BbrGkgW+QlSZJU9CQAAAAAAAAAAAAAAAAAAICv5Vf0BAAAAAAAAAAAAAAAAAAAgP9SAAwAAAAAAAAAAAAAAAAAAFlEATAAAAAAAAAAAAAAAAAAAGQRBcAAAAAAAAAAAAAAAAAAAJBFFAADAAAAAAAAAAAAAAAAAEAWUQAMAAAAAAAAAAAAAAAAAABZRAEwAAAAAAAAAAAAAAAAAABkEQXAAAAAAAAAAAAAAAAAAACQRRQAAwAAAAAAAAAAAAAAAABAFlEADAAAAAAAAAAAAAAAAAAAWUQBMAAAAAAAAAAAAAAAAAAAZBEFwAAAAAAAAAAAAAAAAAAAkEWqV/QEIF0bNmyI9957L6ZPnx7Lli2LdevWRYMGDaJFixbRu3fv2H333SMvL2+n42zevDkmTZoUU6dOjaVLl0a1atWidevW0adPn9hrr73K4Ej+a+HChfHGG2/Ep59+WnA8Xbt2jYEDB0b9+vXLNBZkm1WrVsWECRNiwYIFsWTJkqhevXq0bds2+vbtG126dCnTOK+//nrMnDkzVq5cGXXq1InddtstDjzwwGjTpk2ZxYmI+Oijj+Ldd9+NL774IrZs2RJNmzaNHj16xH777RfVq/vIhW2tX78+Jk6cGB9//HEsW7YsatasGW3bto399tsvOnXqVKaxPvnkk3jrrbdiwYIFsXHjxmjcuHHsscceceCBB0bt2rXLLE4mjwmqMmsaytfq1avjo48+io8//jiWLl0a69evj0aNGkWLFi2ib9++0aFDhzKPmalz6UxeH0C2+OKLL2LmzJkxf/78WLJkSaxduzZq1qwZDRs2jA4dOkTfvn2jSZMmZRozU/e8MnkfD6oy598AlY+8KuQWeVVAXhXYUdY0lB85VcgtcqpAWXD+DZSbBLLcO++8k5x22mlJrVq1kogo9rXrrrsm1157bbJ06dIdirNq1ark6quvTpo0aVJsjG7duiUPPPBAsnXr1p06pnHjxiWDBw8uNk7NmjWTH/7wh8ncuXN3Kg5ko4kTJybf+c53kurVqxe7Bnr06JGMHDlyp9banDlzkh/84AdJzZo1i4yRl5eXDB48OBk/fvxOHc/WrVuT+++/P+natWuxx9O0adPkl7/8ZbJ69eqdigXlbcGCBcmoUaOSX/ziF8mQIUOSXXbZJeV3ebfddiuTOIsWLUp+/OMfJ/Xq1St23fTp0yd56qmndjrWk08+mfTu3bvYOPXr108uvPDCZPHixZXmmCBdmVjTGzZsSCZNmpTcddddyQ9+8IOka9euSV5eXkqcBx98cKfjfMOapqorz3X95ptvJldccUXSr1+/JD8/f7vX37vttltyyy23JF999dVOHU8mz6UzdX0ApVFea3revHnJTTfdlBx++OFJs2bNtruev3n1798/ue+++5JNmzbt1DFl6p5XJu/jQboydU1dnA8++CCpUaNGobWwM+fjzr8BKh95Vcgt8qqQveRVK8cxQbrkVXecNU02klPdcXKqZCM51R0np0q2klfdcc6/oepSAEzW2rJlS/KLX/yixIvkbV8tW7ZM/v3vf5cq1gcffJB07Ngx7Rjf+c53kuXLl5f6mLZu3ZpcdtllacepV69e8s9//rPUcSAbbdq0KTn//PNLtZ4PO+ywHboB9o9//COpW7duWjHy8vKSX/ziFzt08bps2bJk2LBhaR9Pp06dkqlTp5Y6DpSnCRMmJP/zP/+TtGnTpsTf4bK4qH7llVfSvmEWEcnpp5+ebNiwodRx1q9fn5x22mlpx2nevPkO35zO1DFBOjK1pi+55JKkX79+xSZ9yurG2Desaaqy8l7X7733XtKpU6dSnad/82rVqlWpr7+/kclz6UxdH0A6MvFZfe+99+7Qmo6IZJ999kk+/PDDUsfM5D2vTN3Hg3Rk+pq6OJs3b0769etXZufjzr8BKh95VXlVcou8qrwq2Ule1TUguUVe1Zomt8ip7vx5tJwq2URO9euXnCq5RF7V+TewcxQAk7X+3//7f0V+ENWtWzfZe++9k/79+yedO3cu9CS8iK+ffPPCCy+kFefjjz8u8oOwfv36Sc+ePZMuXboU+YSPAw44IFm3bl2pjunCCy8s8kK4Xbt2Se/evYucR7Vq1ZJRo0btyI8QssbmzZuTI444osg13aZNm6Rv377JHnvsUeRa69OnT6meTPf4448X+QcuzZs3T3r37p20bdu2yH83LrroolId09q1a5P+/fsX+e9P165dk7333rvIp+s0b948mTVrVml/hFBu7rjjjrQvBnf2ovq1115L6tSpU2i/jRo1Svbdd9+kQ4cOSbVq1Qq9f9xxx5XqhvGWLVuS733ve0V+pnbs2DHZZ599koYNGxZ5jjFx4sSsPCZIV6bWdFFrqLjXziaqrWmquvJe188++2yx+2vYsGHSrVu3pH///kmnTp2KPI/Oz89P/v73v5cqZibPpTN1fQDpysRndXHJ6tatWyd77713sv/++yc9evRI6tevX2S/Jk2aJO+9916pYmbqnlcm7+NBOjJ5Tb09v/nNb8rsfNz5N0DlJK+64+eYkG3kVXfuXhCUJ3lV14DkFnlVa5rcIqe6c+fRcqpkGznVnbvfJadKNpJXdf4N7BwFwGSlJ554otCHT/fu3ZPnn38+2bRpU0rfRYsWJTfccEOhp+Q1b968xCfcbtq0Kdl7770LnZCPHDky2bhxY0G/pUuXJldffXWhC9yf/OQnaR/TP/7xj0LHdPzxxyczZ85M6ffyyy8nPXv2TOm3yy67JHPnzk07FmSbK664otDv/9FHH5188MEHKf2WL1+e3HHHHckuu+yS0vf0009PK87s2bML3dTq1atXMnbs2JR+H3/8cXLccccVmtO//vWvtI/pvPPOK3ST7pprrkn5d2fDhg3Jgw8+mDRu3Dil77777pts3rw57VhQnrZ3Ub3tzauduaj+6quvCj25a7fddkueeuqplIvLzz77LPnRj35UaC6333572rFuvfXWQuPPO++8ZOHChQV9tmzZkowaNSpp3759Sr+2bdum/SS7TB4TpCtTa7q4RHX16tWTWrVq7dSNsW1Z01R15b2ut01W77///skf//jH5KOPPirUd9GiRclNN91U6MnPNWrUSCZPnpx2zEydS2fy+gDSlYnP6nvvvTepVq1aMmTIkOTGG29MXn311WTFihWF+m3ZsiV56623kh/84AeF5tK1a9dk/fr1acXL1D2vTN7Hg3Rl6vx7e2bPnp2S7N32s6+05+POvwEqH3lVeVVyi7yqvCrZS17VNSC5RV7Vmia3yKnKqZJb5FTlVMk98qrOv4GdowCYrNSjR4+UD52+ffuW+KTaMWPGJNWrV08Zd/PNN293zF/+8peU/o0bNy7ygvwbjzzySKEbcdueeBdlw4YNSYcOHQp9uBf3NI3ly5cnffv2TemfbqIOss2sWbMKPVHmpz/96XbHvPvuu4VugL/99tslxjrllFNSxvTr16/IC/IkSZKtW7cm5557bkr/zp07F/pjmKJMnz690DE9+uijxfafOnVq0qhRo5T+DzzwQIlxIBO+uajeZZddksGDByeXXXZZ8sQTTyTz5s1LXnnllTK7qL7yyitT9tWxY8eUi9xt3XTTTSn9GzZsWOIfoCVJkixZsqTQH7vccsstxfZfsGBBoc/oa6+9NquOCUojU2u6YcOGSV5eXtKlS5fktNNOS37/+98nr7/+erJu3brk4IMP3qkbY99mTUP5r+tnn302yc/PT37wgx8kU6dOTWvMlClTkiZNmqTEHjRoUFpjM3kunanrAyiNTHxWf/bZZ8mSJUtKNWbEiBGFkkB33313ieMyec8rU/fxoDQydf5dnK1btyZDhgwpiHH00Ufv1Pm482+AykleVV6V3CGvKq9KdpNXdQ1IbpFXtabJLXKqcqrkFjlVOVVyj7yq829g5ygAJut88sknhU6O33rrrbTGbvvEigMOOKDYvhs2bEjatWuX0v/+++8vMca2T/A59dRTSxxz9913p4zp0qVLsm7duu2O+eijj1Kevl2tWrVk+vTpJcaCbLPtDZ8+ffqk9XS5Bx54IGXcoYceut3+U6dOTXkSVc2aNZNp06Ztd8y6deuSLl26pMT561//WuLcTjrppJQxP/zhD0scc9999xW6OPn207SgosyePTv56KOPki1bthR6r6wuqhctWlToCV0vv/zydsds3bo1GTRoUMqYq666qsRYl19+eaEb58XdKPvGyy+/nDJml112KfHmXiaPCUojE2s6SZJk/PjxybJly4p8rywT1dY0lP+6njFjRtpJ6m97+umnC127z5o1q8RxmTqXzuT1AZRGpj6rd8TJJ5+cEn/o0KEljsnUPa9M3seD0qjoNf3tP+KoX79+Mn/+/J06H3f+DVD5yKt+TV6VXCGv+jV5VbKVvKprQHKLvKo1TW6RU5VTJbdUdP5le+RUYcdU9LqWV3X+DZWdAmCyzgsvvJDyYdO2bdu0x7700kspY5s3b15s32eeeSalb4cOHUr80E2Sr08+8vLyCsbVqFEjWb58+XbH9O7dOyVWuk/W+uEPf5gy7vLLL09rHGSTVq1apfweP/7442mN27x5c6EL0Tlz5hTb/+c//3lK33SfdnX//fenjOvfv/92+3/11VcpT8XPy8tLPvnkkxLjbNmyJdltt91SYr3wwgtpzREqSlldVN91112FLnTTMWbMmJRxrVq12u5n9ZYtW5LmzZunjBk7dmxasQ466KCUcSU9mS9TxwRlKVM3wMsqUW1NQ8kqOrHVvXv3lPh/+MMftts/k+fSmbo+gLJU0Wv6ueeeS4nfunXrEsdk6p5XJu/jQVkp7zW9YMGClG96u/POO5Mk2fHzceffAJWTvOp/yauSC+RVvyavSmUkr1rxxwRlSV61eNY0lVFF51/kVKFsVfSallOFsievWjzn38A38gOyzFdffZXSbteuXdpj27dvn9Jevnx5sX2ffvrplPaZZ54ZeXl5Jcbo3LlzHHzwwQXtTZs2xQsvvFBs/wULFsTkyZML2vXr14+TTjqpxDgREWefffZ25wzZbsaMGfGf//ynoF2tWrU48sgj0xpbrVq1OOKII1K2jRo1qtj+zzzzTEp72/VTnO9///tRr169gvbbb78dn3/+ebH9n3/++di8eXNBe/DgwdGpU6cS4+Tn58eZZ56Zsu2pp55Ka45Q2W37+ZXu+hwyZEh07NixoP2f//wn3nzzzWL7T5w4MRYvXlzQ7tSpUwwePDitWNvOqaT1maljgqrMmobsd9BBB6W058+fv93+mTyXztT1AeSSzp07p7SXLFmy3f6ZvOeVqft4UJlccMEFsWLFioiI6N+/f1x44YU7tT/n3wCVk7zqf8mrUtnJq/6XvCpVmbzqf7kGhPRZ05Dd5FQht8ipQuUjr+r8G3KBAmCyTsOGDVPa69atS3vstn2bNWtWbN/nn38+pX3YYYelHWfYsGEp7eeeey7tOAMGDEi58N2eAQMGRN26dQvaM2bMiFmzZqU9T6ho296s2n333VN+p0vSq1evlPa2N5y+MWPGjJg9e3ZBu169enHggQemFWPbvkmSFFq335apfzsgV6xevTpeffXVlG3prpu8vLw49NBDU7aV5jN32LBhad3A+qbvt40bNy7WrFlTZN9MHhNUZdY0ZL/GjRuntL+5WV6cTJ1LZ/L6AHLJ+vXrU9qNGjXabv9M3vNyLQ6pHnvssYL7ZNWrV49777038vN3Lt3j/BugcpJXTe0rr0plJq+ayrUcVZG8airXgJA+axqym5wq5BY5Vahc5FX/y7qGyk0BMFlnn332SWlPnz692A+1bb311lsp7f79+xfZ78svv0x5em6tWrWid+/eac9xwIABKe3333+/2L7bvpfuBXLE1ycZ2x7D9mJBtlm6dGlKu0mTJqUa37Rp05R2cb//227v379/VK9ePe04mVrTffr0iVq1ahW0P//885QnAEEu+uijj2LTpk0F7Y4dO0arVq3SHp+p9dmmTZvo0KFDQXvjxo0xbdq0Ivtm8pigKrOmIfstXLgwpb3t+fu2MnUuncnrA8glkyZNSmn36dNnu/0zdc8rk/fxoDJYunRp/PSnPy1oX3LJJdGzZ8+d3q/zb4DKSV71v+RVqezkVVPJq1IVyasW5hoQ0mNNQ3aTU4XcIqcKlYe8qnUNuUQBMFmnbdu2KR+CGzZsiLvuuqvEcRs2bIjf//73KduK+4r76dOnp7R33333qFmzZtpz7N69e0p79uzZsXnz5rRibTu2tLG23R9ks22fkLNly5ZSjf/2SWtExMqVKwvdEIvI3DrbtGlTylPvShurVq1a0blz57RiQa7I5OdgpmL5bIfMsKYhuyVJEhMmTEjZ1rVr12L7Z/Jc2rqG0lu3bl387ne/S9l2xhlnbHdMRX1Wl+d9PKgMfvaznxX8wVbnzp3juuuuK5P9Ov8GqJzkVbcfy+cElYm8aip5VaoiedUdjwNVnTUN2UtOFXKLnCpULvKqPqshlygAJivddtttKQmua6+9NkaOHFls/+XLl8cJJ5yQ8qF09NFHx9FHH11k/xkzZqS027VrV6r5NW/ePGrXrl3Q3rhxY8ydO7dcYm3bf9v9QTbb9snUixYtKtX4ovoXdfKZqXU2Z86clAvaOnXqRLNmzcolFuSKsl6fn376aaxfv75Qv3Xr1sX8+fPLNFZx6zNTxwRVmTUN2W/cuHEp18F5eXlx+OGHF9s/k+fSrsOhdBYuXBhHHnlkzJw5s2Db4MGD4/vf//52x2VqrWXyPh5kuxdeeCEeeeSRgvY999wTderU2en9Ov8GqNzkVYvv73qOykRedcdjQa6QVy05jmtAKMyahuwmpwq5Q04VKhd5VeffkGuqV/QEoCgDBw6MP/7xj/HjH/84kiSJzZs3x/Dhw+NPf/pTHHfccdGtW7eoU6dOLFmyJCZNmhSPPvpofPXVVwXjhw0bFn//+9+L3f+2ya+2bduWeo5t2rSJOXPmpOyzS5cuhfp989SQHY216667prRLm+iDitSpU6eU9rx582Lx4sXRvHnztMa/8847hbZ9+eWXhbbt7Jredp1tu26Li7PtuB2JZU2T63Z2fbZs2TKqV69ecHN769atsXTp0kJracmSJZEkSUG7Ro0a0aJFi1LFSnd9ZuqYoCqzpiG7bd26Na688sqUbYcffni0atWq2DGZPJfO1PUBVBabN2+OcePGpWxbvXp1LFiwICZMmBDPPPNMrFu3ruC9/fffP0aNGhV5eXnb3W+m7nll8j4eZLNVq1bFeeedV9D+4Q9/GIceemiZ7Nv5N0DlJq/6X3IwVGbyqiXHsqbJdfKqhbkGhJJZ05C95FShcpFTlVMld8irfs35N+QWBcBkrfPPPz+6desWP/3pT+Ojjz6KiIi333473n777WLHdOrUKS6//PI455xzUp50va3Vq1entOvVq1fq+W07Ztt9Rnz9hI8tW7bsVKx04kC26tSpU7Rp0yY+//zzgm3/+Mc/4sILLyxx7OrVq+O5554rcntJ23Z2nW3atCk2bNgQtWrVKtM4RY2xpsl1O7tu8vLyok6dOrFq1api91nUtrp165Z4c21b6a7PTB0TVGXWNGS33/72tzFp0qSCdn5+ftx0003bHZPJc+lMXR9AZbF69eoYNmxYif1atmwZl1xySVx00UVRo0aN7fbN5D0v1+LwtV/84hfx2WefRUREs2bN4ne/+12Z7dv5N0DlJ6+afhzIVvKqJceypsl18qqFuQaEklnTkL3kVKFykVN1HU7ukFf9mvNvyC3FZ/IgCwwdOjTefvvtuPTSS6NatWrb7du+ffu49NJL49RTT91ukjqi8AdX7dq1Sz23OnXqbHefxW0rbax04kA2O/bYY1Pat956ayxfvrzEcbfcckusXLmy0PZ01trOrrPyilNULGuaXFdRn7nluT79WwDlz5qG7PXaa6/F1VdfnbLtoosuin333Xe74yrTuk73+gByScuWLePqq6+Oc845p8REdURm73n5rIavP3/vueeegvbtt98ezZo1K7P9V6bP6dLEAqhq5FV9RlD5yatuP5Y1Ta6TV925WFBVWdOQneRUITfJqUL2k1fdsVhA9lMATFa75557onPnzvHb3/620BNwtjV//vy44IILokOHDvHAAw9st+/69etT2jVr1iz13LZ9StW6detKjLMjsdKJA9ns4osvTvnjkYULF8bxxx8fa9asKXbMQw89FLfddluR76Wz1nZ2nZVXnKJiWdPkuor6zC3P9enfAih/1jRkpzlz5sRxxx0XmzdvLti2zz77xM0331zi2Mq0rtO9PoBc8uWXX8ZPf/rTaN++fdx+++2RJMl2+2fynpfPaqq69evXx9lnn12wLg899NA4/fTTyzzGt2Xz53RpYgFUNfKqPiOo/ORVtx/LmibXyavuXCyoqqxpyD5yqpC75FQhu8mr7ngsIPspACYrbdq0KU444YQ4//zz44svvoiIiCZNmsS1114bb731Vixbtiw2btwYn3/+eTzzzDPxP//zP5GXlxcREV999VWcffbZcdlllxW7/22ffrFx48ZSz3HDhg3b3Wdx20obK504kM123333uOKKK1K2jR07Nvbaa6+45557Yt68ebFx48ZYtmxZjBkzJk466aQ4/fTTY8uWLZGXlxcNGzZMGVu/fv1CMXZ2TW+7zoraZ1nEKSqWNU2uq6jP3PJcn/4tgPJnTUP2WbJkSXz3u9+NJUuWFGxr2bJljBo1qsjk7rYq07pO9/oAKotGjRpFkiQFry1btsRXX30VkydPjrvuuiv23nvvgr6rVq2KSy+9NM4444zYunVrsfvM5D0vn9VUddddd13MmjUrIr5+QvO3n1hdVirT53RpYgFUFfKqpYsD2UxedfuxrGlynbzqzsWCqsqahuwip2pNU3nJqfqcpvKTV93xWED2UwBMVjr//PPjX//6V0G7f//+8dFHH8UNN9wQ/fr1i0aNGkWNGjWidevWcfTRR8eoUaPiqaeeSvlA+u1vfxsPPvhgkfvfNtFV1BN2SrLt0y+KSp4Vta20sdKJA9nuV7/6VRx99NEp2z799NM4//zzo2PHjlGrVq1o0qRJHHroofHEE08U9Lnhhhti9913TxnXqFGjQvvf2TVd1NNs0lnT5fVvB+SSivrMLc/16d8CKH/WNGSXVatWxXe/+92YOXNmwbaGDRvG//3f/0XHjh3T2kdlWtfpXh9AZZWfnx+NGzeOfffdN37yk5/ElClT4re//W1BEUjE198gdfvttxe7j0ze8/JZTVU2efLklLV47bXXRufOncs8TmX6nC5NLICqQl61dHEg28mrFh/LmibXyavuXCyoqqxpyB5yqtY0uUVO1ZqmcpFX3blYQPZTAEzWGTduXNx///0F7RYtWsRzzz0XrVq12u64Y445Jv70pz+lbLvsssvSushcs2ZNqee57ZiiPgzr1KkT1apV26lY6cSBbFetWrV48skn4+KLLy60JopSo0aNuPnmm+Oaa66J1atXp7yXTqJ6Z9dZ9erVi3zCTab+7YBcsrPrJkmSHUpUr127NpIkKVWsdNdnpo4JqjJrGrLH+vXr45hjjol33nmnYFvdunXj+eefj169eqW9n0yeS2fq+gByRV5eXlxyySVxyy23pGy/4YYbYtmyZUWOyeQ9L9fiVFWbN2+Os846K7Zs2RIRET179oxLL720XGI5/waovORVSx8Hsp28avFjrGlynbxqYa4BoWTWNGQHOVU5VXKfnCpkL3nVojn/htyiAJisc9ddd6W0L7roomjevHlaY4cPHx5du3YtaC9dujRGjRpVqF+LFi1S2gsWLCj1PD///PPt7vMb2869tLEWLlyYVhzIdtWqVYvf/e53MXXq1Dj77LOjTZs2hfrUq1cvTj/99HjrrbfiyiuvjIiv1/G3bfvk6oidX9PbrrPi/s3ZNs6243YkljVNrtvZ9fnll1/G5s2bC9r5+fnRrFmzQv2aNWuW8nS9TZs2xaJFi0oVK931maljgqrMmobssGnTpjjppJNi3LhxBdtq1qwZo0aNigEDBpRqX5k8l87U9QHkmksuuSQ6depU0F6zZk3885//LLZ/pu55ZfI+HmSThx9+OKZMmRIRX59j/vWvf43q1auXSyzn3wCVl7xqKjkYcoW8atFjrGlynbxqYa4BoWTWNFQ8OdWvyalSVcipQvaRVy2a82/ILQqAySpJksTYsWNTth199NFpj8/Pz48jjzwyZdurr75aqF+3bt1S2vPnzy/FLCMWLVoU69evL2jXrFkz5WS+LGNt23+PPfYo1XjINnvssUfcd999sXDhwvjss8/i3Xffjddeey1mz54dX331VYwcOTL22WefiIhYvHhxLFmypGBsvXr1Ys899yy0z0yts06dOqVcEKxbty4WL15cLrEgV5T1+txtt92KfFpknTp1on379mUaq7j1maljgqrMmoaKt3Xr1jj99NPj2WefLdhWrVq1ePTRR+M73/lOqfeXyXNp1+GwY6pXrx7HHHNMyraJEycW2z9Tay2T9/Egmyxfvrzgv7du3Rr7779/5OXllfgaP358yn7OPPPMlPePPfbYQrGcfwNUTvKqhbmeI9fIq1rTVC3yqiXHcQ0IhVnTULHkVEuOA7lGThWyj7xqenGcf0PlpgCYrLJs2bJYsWJFyraOHTuWah/b9i/qCVjbfkh+8sknsXHjxrRjTJ8+PaXduXPnYp8Ssm2sadOmpR2nqFguksklbdu2jd69e8fAgQOjc+fOUbNmzZT3P/zww5T2PvvsE9WqVSu0n0ytsxo1akTnzp13ONaGDRtizpw5acWCXJHJz8FMxfLZDplhTUPFSZIkzj333HjssccKtuXl5cV9990Xxx9//A7tM5Pn0tY17Lht1+l//vOfYvtW1Gd1ed7Hg6rM+TdA5SOvWnIsnxPkEnlVa5rcJ6+643GgqrOmoWLIqVrTVF1yqlC1Of8GKoICYLLKhg0bCm0r7cljjRo1Utpbtmwp1KdVq1bRqlWrlLjvvvtu2jFef/31lPY3T9Utyrbvbe8pP9vavHlzvPXWW2nHglzz/PPPp7S/+93vFtlv23Xx9ttvx+bNm9OOk6k1/e6776b8O9e6deto0aJF2uOhMtprr71SPpvnzZsXX3zxRdrjM7U+v/jii5g3b15Bu0aNGtG9e/ci+2bymKAqs6ah4lx88cVx//33p2y76667Yvjw4Tu130ydS2fy+gBy3bb32b4tU/e8MnkfD6oy598AlY+8aip5Vao6eVWo/ORVC3MNCOmxpqFiyKla0/ANOVWoWpx/AxVBATBZpWnTpoW2ff7556Xax7ZPpm7evHmR/Y488siU9ujRo9OOsW3fo48+uti+28aZOHFirFmzJq04r7/+eqxdu7ag3bVr1+jatWva84TKbMuWLfHEE08UtKtVqxZnnnlmkX332GOPlCdqrVmzJu2T6TVr1sQbb7xR0M7Ly4ujjjqq2P7bvlde/3ZArthll11i0KBBKdvSXTdJksTLL7+csm1762bb9fnyyy9HkiRpxXrppZdS2kOGDIn69esX2TeTxwRVmTUNFeOaa66JO++8M2XbzTffHBdeeOFO7ztT59KZvD6AXPPpp5+mtFu2bFls30ze88rUfTzIJscff3yMHj261K+ePXum7Oeyyy5Lef9Xv/pVkfGcfwNUPvKqqeRVqcrkVSE3yKumcg0I6bOmIfPkVOVUqdrkVCG7yKsW5vwbco8CYLJKzZo1o3Xr1inbxo4dW6p9jBkzJqX97QvUbzvmmGNS2g8++GBaH7yffPJJjB8/vqBdo0aNOOKII4rt365du9h3330L2qtXr47HH3+8xDgRUejpYN/73vfSGge54K9//Wt89tlnBe0jjjgi2rRpU2z/bdf0tuunOP/4xz9i9erVBe2+fftuN84RRxyR8gT9cePGxZw5c0qMkyRJjBgxImWbNU1VsaPr85VXXom5c+cWtFu2bBn77bdfsf0PPPDAaNasWUF7zpw5MW7cuLRilfYzN1PHBFWZNQ2Z95vf/CZuvPHGlG1XXnllXHnllWWy/0yeS2fq+gBySZIk8dxzz6Vs2zbh9W2ZvOeVqft4kE3atWsXhx56aKlfjRs3TtlP9+7dU94vbl07/waofORVU8mrUpXJq0LukFf9L9eAkD5rGjJLTlVOlapNThWyj7xqYc6/IQclkGV+8IMfJBFR8OrRo0eyadOmtMaOGzcuZWxEJK+99lqRfdevX5+0bds2pe/9999f6vmdfPLJJY754x//mDKma9euybp167Y7Ztq0aUnNmjULxuTn5ycfffRRibEgF8yePTtp2rRpwe9/jRo1Svz9//DDD5O8vLyCMTVr1kymTZu23THr1q1LunTpkrI+77nnnhLnd8IJJ6SM+eEPf1jimPvuuy9lzG677ZZs2LChxHFQkV555ZVCv7c74ssvv0zq1auXsq8xY8Zsd8zWrVuTQYMGpYy54oorSox16aWXpow5+OCDk61bt253zMsvv5wyZpdddkkWL16cNccEZaWs1nRJDj744JQ4Dz744A7vy5qG7SvLdX3PPfcUup6+8MILy26y/79MnUtn8voAykqmPquLc//99xf6d2DevHnbHZOpe16ZvI8HZaWi1vTOnI87/waofORVvyavSlUmrwrZQV41O44Jyoq8avGsaSojOdXiyalSGcmpFk9OlcpKXrV4zr+BbygAJuu8+OKLhU6MzznnnGTLli3bHTdr1qykTZs2KeO6dOmSbN68udgxf/7zn1P6N27ceLsnx4888khK/2rVqiUzZswo8Zg2bNiQtG/fPmXseeedV+yH/IoVK5K+ffum9P/BD35QYhzIVp9++mmyZs2atPpOmzYt2W233VJ+/6+66qq0xn7/+99PGdevX79kxYoVRfbdunVr8qMf/Silf6dOnZKNGzeWGOejjz5K8vPzU8Y++uij2+3fqFGjlP733XdfWscEFaksL6p/8YtfpOyrY8eOycKFC4vtf9NNN6X0b9iwYbJ06dIS4yxevDipX79+ythbbrml2P4LFixIOnTokNL/l7/8ZVYdE5SVypiotqZh+8pqXT/yyCOFzm/PPPPMEm9M74hMnktn6voAykpZrOlx48Ylt912W9rX4N94/PHHUxLIEZGceOKJJY7L5D2vTN3Hg7JSGRPVzr8BKh95VXlVco+8qrwqlZO8anYcE5QVedXts6apbORUt09OlcpGTnX75FSpjORVt8/5N5AkCoDJUkOGDCmUrB44cGDy8ssvF3pq9ZIlS5Lf/va3ScOGDQuNeeKJJ7YbZ+PGjclee+2VMqZJkybJyJEjU+IsXbo0+eUvf1nogvqCCy5I+5geffTRQvM74YQTkpkzZ6b0GzNmTNKzZ8+UfvXr10/mzJmTdizINn/4wx+Spk2bJj/72c+ScePGJWvXri3U54MPPkguu+yyQhfHBxxwQIlPuvrGrFmzkrp166aM79WrV/LKK6+k9JsxY0Zy3HHHFVqTjz/+eNrHdO6556aMzc/PT6655prkq6++KuizcePG5MEHH0waN26c0rdnz55pP4EfMmHChAnJ6NGjC71++9vfpvzutmzZssh+o0ePLvHpckuXLk1atWpV6CL96aefTrmR9dlnnxW6URwRya9//eu0j+fmm28uNP78889PueDdsmVL8uSTTxa6sdamTZtk2bJlacXJ5DFBaWRiTX/++efFjt32XPayyy4rtm86n/HWNJTvuh49enRSvXr1lP3sscceyYsvvljsvop7vfPOO2kdT6bOpTN5fQClUZ5r+sknn0wiImnUqFFy1llnJc8++2zyn//8p8i+K1euTJ5++unkiCOOKPT736RJk2T+/PlpHU+m7nll8j4elEYmzr9LY2f/cNT5N0DlI68qr0pukVeVVyW7yau6BiS3yKta0+QWOVU5VXKLnKqcKrlHXtX5N7DjFACTlb744oukY8eOhT58vjmJ3XvvvZP+/fsnnTt3TvLy8orsd8kll6QVa9q0aUmTJk2KjNOrV6+ka9euSY0aNQq9379//yKTbdtz/vnnF9pPXl5e0r59+6RPnz5Js2bNCr2fn59fYsIdst0f/vCHlN/ratWqJbvvvnvSr1+/pEePHknTpk2LXMf9+vVLlixZUqpYf//734v8d6F58+ZJnz59knbt2hX5/k9+8pNSxVmzZk2hJ2xFRFKzZs2kW7duSc+ePQs92ScikmbNmnk6Flln26fD78jrjDPOKDHO+PHjk9q1axca26hRo2TfffdNOnbsmFSrVq3Q+9/73vdK9bTMLVu2JEcddVSh/VSrVi3p1KlTsu+++xZ66mVEJHXq1EkmTJhQqp9dpo4JSiMTa/rBBx/c6RgRkcydO7fE47GmoXzX9XXXXVcm6zkikoMPPjit48nkuXSmrg+gNMpzTX+TrC7qd37PPfdM9ttvv2TfffdNdtttt2LvqTVq1Ch59913S3VMmbrnlcn7eJCuTF1Tp2tnE9XOvwEqH3nVnTvHhGwjr7pz94KgvMmrugYkt8irWtPkFjnVHT+PllMlG8mpfv2SUyWXyKs6/wZ2nAJgstb8+fOTwYMHl/pDvUaNGsmtt95aqg+q999/v1QnFIceemjaT9z4ti1btiQXX3xx2nHq1q2b/OMf/yh1HMg22yaqS3rl5eUl/+///b9k9erVOxTv0UcfTerUqZN2vEsvvXSHTm6XLl2aDB06NO04HTp0SD744IMdOiYoT5m8qB4zZkyRN5eKe5166qnJ+vXrS31M69atS04++eS04zRt2rTQkyvTlaljgnTlWqI6SaxpyLVkdZJk9lw6U9cHkK6KSFan+xo2bNgOfVtaJu95Zeo+HqQr1xLVSeL8G6AykleVVyV3yKt+/ZJXJVvJq7oGJLfIq1rT5BY5VTlVcoucqpwquUde1fk3sOPyA7JUu3btYsyYMfH444/H4MGDIz9/+7+uDRs2jPPPPz8+/PDD+MUvfhF5eXlpx+rVq1d8+OGHceWVV0bjxo2L7delS5e4995746WXXopGjRqlvf9v5Ofnx+9+97sYO3ZsHHTQQcX2q1mzZpx22mkxderUOOmkk0odB7LN4MGD44wzzohWrVptt1+tWrXi+OOPjzfffDPuvffeqFev3g7FO+WUU2Lq1Klx6qmnRo0aNYrtN2jQoBg3blz85je/KdW/Gd9o0qRJjB49Ov7617/G7rvvvt1+V111VXz44Yex9957lzoO5JKhQ4fGtGnT4vzzz4+6desW22/fffeNf/3rX/HII49ErVq1Sh2ndu3a8fe//z3++c9/xj777FNsv3r16sUFF1wQ06ZNi8GDB5c6TkTmjgmqMmsack8mz6UzdX0A2eCwww6LUaNGxTnnnBPdunVL63e5QYMGceqpp8aYMWPipZdeio4dO5Y6bibveWXqPh5UZc6/ASofeVV5VXKHvKq8KnxDXtU1IOwIaxpyi5wqlA851f+SU4Wd4/wbyJS8JEmSip4EpGPVqlXxzjvvxJw5c2L58uWxfv36aNCgQTRt2jR69uwZ3bt3LzGZnY5NmzbFpEmTYurUqbF06dKoVq1atG7dOnr37l3mCaYFCxbExIkTY/78+bF+/frYZZddokuXLjFw4MBo0KBBmcaCbDFnzpyYOnVqzJ8/P1auXBkRX9+A6tatW+y3337bPSHdEStXrowJEybErFmzYtWqVVG7du1o3759DBgwIHbdddcyjfXhhx/G5MmT44svvogtW7ZE06ZNo0ePHrHffvtt96YYVFXr1q2LiRMnxvTp02P58uVRs2bN2HXXXWO//fbb7k3rHTF79uyYNGlSLFy4MDZu3BiNGjWKPffcMwYMGBC1a9cusziZPCaoyqxpyD2ZOpfO5PUBZIPly5fHtGnTYu7cubFo0aJYs2ZN1KxZMxo2bBhNmzaNvffeO7p27Vrmf6CRqXtembyPB1WZ82+AykdeFXKDvCrwDXlVYEdZ05Bb5FShfMipAmXF+TdQXhQAAwAAAAAAAAAAAAAAAABAFtn5x/oCAAAAAAAAAAAAAAAAAABlRgEwAAAAAAAAAAAAAAAAAABkEQXAAAAAAAAAAAAAAAAAAACQRRQAAwAAAAAAAAAAAAAAAABAFlEADAAAAAAAAAAAAAAAAAAAWUQBMAAAAAAAAAAAAAAAAAAAZBEFwAAAAAAAAAAAAAAAAAAAkEUUAAMAAAAAAAAAAAAAAAAAQBZRAAwAAAAAAAAAAAAAAAAAAFlEATAAAAAAAAAAAAAAAAAAAGQRBcAAAAAAAAAAAAAAAAAAAJBFFAADAAAAAAAAAAAAAAAAAEAWUQAMAAAAAAAAAAAAAAAAAABZRAEwAAAAAAAAAAAAAAAAAABkEQXAAAAAAAAAAAAAAAAAAACQRRQAAwAAAAAAAAAAAAAAAABAFlEADAAAAAAAAAAAAAAAAAAAWUQBMAAAAAAAAAAAAAAAAAAAZBEFwAAAAAAAAAAAAAAAAAAAkEUUAAMAAAAAAAAAAAAAAAAAQBZRAAwAAAAAAAAAAAAAAAAAAFlEATAAAAAAAAAAAAAAAAAAAGQRBcAAAAAAAAAAAAAAAAAAAJBFFAADAAAAAAAAAAAAAAAAAEAWUQAMAAAAAAAAAAAAAAAAAABZRAEwAAAAlMLgwYMjLy+v4EX5mDdvXsrPuajX9ddfX9HTzErjxo0r8Wc3YsSIip4mAAAAAAAAOUxeNTPkVXecvCoAAFAZKAAGAAAAAAAAAAAAAAAAAIAsogAYAAAAAAAAAAAAAAAAAACySPWKngAAAABkyrx586Jjx44F7TPOOCNGjBhRcRMibYcddlhcdtllKds6depUQbPJbr169YrRo0enbHvppZfiN7/5TQXNCAAAAAAAgMpEXrXykldNn7wqAABQGSgABgAAALJe69at49BDD63oaVQKjRs3LvSzWrBgQQXNBgAAAAAAAMgUedX0yasCAACVgQJgAAAAKIVx48ZV9BQAAAAAAAAAspq8KgAAAOy8/IqeAAAAAAAAAAAAAAAAAAAA8F8KgAEAAAAAAAAAAAAAAAAAIIsoAAYAAAAAAAAAAAAAAAAAgCxSvaInAAAAAFXVli1b4o033og5c+bE559/HrVq1Yo99tgjBg8eHHXq1Nnu2JUrV8aECRNi5syZsXbt2mjWrFn07Nkz9ttvv8jLy9vpuS1fvjwmTpwYX3zxRSxevDhq164dzZs3j3333Te6d+++0/vPBkuXLo2JEyfGwoUL46uvvopmzZpF//79Y5999ilx7OzZs+PNN9+Mzz//PPLy8qJNmzYxePDg2HXXXXd4PqtWrYr33nsvZsyYEcuXL48NGzZE3bp1o3HjxtGhQ4fo3r17tGzZcof3DwAAAAAAAJWRvGrFklcFAACoOAqAAQAAyHkdOnSITz/9tND2kSNHxsiRI4sd9+CDD8bw4cNTtg0ePDjGjx9f0E6SpNjxI0aMiDPPPLPQ/tavXx+33XZb3HvvvbFw4cJC4xo1ahRXXnllXHrppZGfn5/y3pdffhnXXHNNPPTQQ7F+/foij/X3v/99fO973yt2Xtvz7LPPxm9/+9uYOHFibN68ucg+7du3j4suuiguuOCCqFWr1g7FyYTi/l99/PHHce2118bTTz8dGzduLDRu3333jT/96U9xwAEHFHrvlVdeiauuuirefPPNQu/l5eXF0UcfHX/4wx+iffv2ac9z8uTJceONN8bzzz9f5Hy+rWPHjnHkkUfG+eefnzN/MAAAAAAAAEB2kFdNn7yqvCoAAEAm5JfcBQAAACgrX375ZRx44IFx/fXXF5mkjvj6KdG/+MUv4pRTTomtW7cWbH/77bejV69ece+99xaZpI6ImDdvXhx77LFx5513lmpeixYtiiFDhsQxxxwTr776arFJ6oiI+fPnx89//vPo2bNnfPLJJ6WKU9Gefvrp6N27dzzxxBPFJoXfe++9OPjgg+PJJ59M2X7DDTfEIYccUmSSOuLrRPgzzzwT++23X8yYMSOt+dx6663Rr1+/ePLJJ0tMUkdEzJ07N/74xz/Go48+mtb+AQAAAAAAoDKSV61Y8qoAAADZQQEwAAAAZMj69evjyCOPjPfee69g22677Rb9+vWLLl26RF5eXkr/xx9/PG699daI+PrpysOGDYsvv/wyIiKqVasWXbt2jX79+kXbtm0Lxbr44otjwoQJac1r1qxZsf/++8e4ceNStufl5UWHDh2ib9++sffee0f9+vVT3p85c2YccMABMXPmzLTiVLTXX389TjrppFi3bl1ERNSuXTv23HPP6Nu3bzRv3jyl76ZNm+IHP/hBzJo1KyK+Tihff/31BU+7btiwYfTs2TP22WefQj+X//znP3HcccfFpk2btjuf+++/P6688sqUP0aIiNhll11i7733jv333z969eoV7dq1K/S7AQAAAAAAALlKXrViyasCAABkDwXAAAAA5LxHHnkkRo8eHQ8//HDK9sMOOyxGjx5d7Os73/lOmc7jtttui3fffTfy8/PjwgsvjHnz5sW8efPirbfeipkzZ8b8+fPj+OOPTxlz0003xcKFC+PEE0+MFStWRKNGjeKOO+6IxYsXx4wZM+Ktt96Kzz77LCZNmhQ9evQoGJckSfzsZz8rcU5r166N733vezF37tyCbR07doy//OUvsXTp0pg7d268/fbb8cEHH8SyZcvi3//+d/Tu3bug7+LFi+P73/9+bNiwoQx+QuXrBz/4QWzcuDHatGkTI0aMiKVLl8a0adPi7bffji+//DL+7//+L9q3b1/Qf+3atXHVVVfF66+/HldffXVERPTr1y9efvnlWLp0aUyZMiXee++9WLJkSdx9991Rq1atgrHTpk2Le+65p9i5bNiwIS6//PKUbccff3y88847sWLFivjggw/ijTfeiPfffz/mz58fK1asiDFjxsQll1wSLVu2LOOfDAAAAAAAAMirbo+8qrwqAABARahe0RMAAACA8jZgwICIiJg3b17K9tatW8ehhx6asXnMmzcv8vPz47HHHosTTzyx0Ptt27aNxx9/PL7zne/Eyy+/HBFfJ0uHDRsW06dPj1atWsXYsWNjzz33LDS2f//+MXbs2Nhrr71i8eLFERExefLkeP/992OfffYpdk6XXHJJTJ8+vaB99NFHx6OPPlro6csREdWrV4/DDz88hgwZEqeccko8+eSTERHx/vvvx9133x0XX3xxqX4emTZv3rzo1q1bjB07Ntq0aZPyXl5eXsEfLvTs2bMg8f7kk0/GlClTYuvWrXHCCSfEo48+GjVq1EgZW6tWrTj//POjTp06ceaZZxZsv//+++MnP/lJkXMZM2ZMfPXVVwXt008/PUaOHFns3HfZZZcYOnRoDB06NG6++eZYsGBBqY8fAAAAAAAAtkdedZ9i5ySv+jV5VQAAgMzyDcAAAACQQZdddlmRSepv5Ofnx4033piy7ZtE8siRI4tMUn+jefPmhZLF//73v4vt/9lnn8V9991X0O7Zs2c88cQTRSapv61WrVrx8MMPR4cOHQq23XnnnbFly5btjqtoNWrUiMcff7xQkvrbunbtmpJs3rJlS8yaNSt23333GDlyZKEk9bedccYZ0a1bt4L2lClT4osvviiy78yZM1PaF1xwQbqHETVr1oxOnTql3R8AAAAAAAAqG3nViiOvCgAAkD0UAAMAAECG1KtXL6644ooS++23337RsmXLlG0DBw6Mww47rMSx3/ve91La7733XrF9//SnP8XmzZsL2r/5zW+iVq1aJcaIiKhbt25KUvzTTz+Nd955J62xFeXEE0+Mnj17ltjvmGOOKbTtiiuuiLp16253XF5eXqGxxf38161bl9LeXgIcAAAAAAAAqhJ51YolrwoAAJA9FAADAABAhhx66KHRqFGjtPrutddeKe0TTjghrXHdunVLSXrOnz+/2L4vvPBCwX+3atUqDj300LRifGPbxPlrr71WqvGZtr0nhH9bjx49Utp5eXlx3HHHpTV27733TmkX9/Pf9mnZDz/8cFr7BwAAAAAAgFwnr1qx5FUBAACyhwJgAAAAyJA+ffqk3bdp06Yp7d69e6c1rlq1ainJ8JUrVxbZb9myZTF16tSU/efnl+42Qfv27VPa06dPL9X4TEv357/tz75jx47RuHHjHRpb3M9/6NChUa1atYL2HXfcERdccEHMmTMnrTgAAAAAAACQq+RVK5a8KgAAQPZQAAwAAAAZ0rx587T71q1bt0zGrlu3rsg+M2bMiCRJCtovvPBC5OXllepVr169lH1+9dVXac+xIqT7Myyrn31E8T//du3axVlnnZWy7c9//nN07tw5+vbtG1dccUW88MILWf8zBQAAAAAAgLImr1qx5FUBAACyhwJgAAAAyJDatWtnfOy3k9HftnTp0h2eS3FWrFhR5vssSzv6M9yZ/2/F/fwjIu666644+uijC21/991347bbbosjjzwymjVrFvvuu29cddVV8dFHH+3wPAAAAAAAAKCykFetWPKqAAAA2UMBMAAAAFRBy5cvL/N9bt26tcz3mctq164dTz/9dDz66KOxzz77FNknSZJ4//3345ZbbokePXrEUUcdFbNnz87sRAEAAAAAAKCKkletePKqAABAVVa9oicAAAAAZF7dunVT2kOGDImrrrpqp/bZuHHjnRpfFeXl5cUpp5wSp5xySkybNi1Gjx4d48aNiwkTJsSSJUsK9X/++efj1Vdfjeeffz4OOuigCpgxAAAAAAAAVB3yqtlBXhUAAKiqFAADAABAFdSsWbOUdu3atePQQw+toNkQEdG9e/fo3r17/OxnP4skSeLjjz+Ol156Kf75z3/GhAkTCvqtWrUqTjjhhPjkk0+ifv36FThjAAAAAAAAyG3yqtlHXhUAAKhK8it6AgAAAEDmdezYMaU9e/bsCpoJRcnLy4s999wzfvazn8Vrr70Wr776asofFyxatCgeeuihCpwhAAAAAAAA5D551ewmrwoAAOQ6BcAAAABUGfn5qZfBSZJU0EwqXtu2bWP33XcvaM+aNSs+++yzCpwR23PQQQfFrbfemrLt20+vBgAAAAAAgLIir/pf8qqVi7wqAACQaxQAAwAAUGXUq1cvpb127doKmkl2OPzww1Paf/zjHytoJqRjwIABKe0lS5ZU0EwAAAAAAADIZfKqqeRVKxd5VQAAIJcoAAYAAKDKaNCgQVSrVq2gPXfu3AqcTcW7+OKLo3r16gXtP/zhDzF58uQKnBHbs21iunHjxhU0EwAAAAAAAHKZvGoqedXKRV4VAADIJQqAAQAAqDJq1KgRXbt2LWi///778cknn1TgjCpWp06d4uyzzy5or1u3Lo466qh44403SrWfsWPHxrnnnlvW08tp11xzTTz88MOxefPmtPonSRK33357yrY+ffqUx9QAAAAAAACo4uRVU8mrVhx5VQAAoKpTAAwAAECVcthhhxX895YtW2LQoEFxww03xJNPPhmjR4+Ol19+ueD1xRdfVOBMM+OOO+6Ifffdt6D9xRdfxKBBg+LMM8+MN998s8hE6urVq2PChAlx9dVXxx577BGHHHJIvPTSS5mcdqX34Ycfxg9/+MPYdddd4/zzz48XX3wxli5dWqjf1q1bY8KECXHYYYfFU089VbC9bt26ceqpp2ZwxgAAAAAAAFQl8qqp5FUrhrwqAABQ1VWv6AkAAABAJl1wwQXxl7/8JdavXx8REZ9//nlcf/31RfZ98MEHY/jw4ZmbXAWoU6dOPPPMM3HEEUfEhx9+GBERmzdvjhEjRsSIESOiXr160a5du2jYsGGsXbs2li1bFgsXLowkSSp45rlh0aJFcc8998Q999wTERGtW7eOZs2aRb169WLNmjUxd+7cWL16daFxt99+e+y6666Zni4AAAAAAABVhLxqKnnViiWvCgAAVFUKgAEAAKhSunbtGg899FCceeaZRSYAq6K2bdvGG2+8Eeedd1488sgjKUnoNWvWxMcff1ziPtq3b1+eU6wyvvjii+0+Ib1OnTpxxx13xI9+9KMMzgoAAAAAAICqRl61MHnV7CGvCgAAVBX5FT0BAAAAyLQTTjghZs6cGbfeemt85zvfiXbt2kX9+vUjLy+voqdWYerVqxcPPfRQvP/++3HKKadEo0aNShyzxx57xM9+9rOYOHFivPrqq+U/yRxy7733xgMPPBDHH398tGzZssT+TZo0ifPOOy+mT58uSQ0AAAAAAEBGyKsWJq+aWfKqAABAVZeXfPvxUwAAAAARsXXr1pg8eXLMnDkzlixZEitXroy6detGo0aNonPnztG9e/do3rx5ucWfN29edOzYsaB9xhlnxIgRI8otXkWbO3duzJgxIz799NNYsWJFbNy4MerXrx/NmzePvffeO7p37x7Vq1ff4f2PGDEizjzzzIL2gw8+GMOHDy+DmQMAAAAAAEDVJa+aWfKqAABAVbPjVzgAAABAzsrPz4++fftG3759K3oqVULHjh1TEvMAAAAAAABA9pNXzSx5VQAAoKrJr+gJAAAAAJRk5MiRkZeXl/K6/vrrK3paWWncuHGFflbffko1AAAAAAAAkJvkVdMnrwoAAFQGCoABAAAAAAAAAAAAAAAAACCLKAAGAAAAAAAAAAAAAAAAAIAskpckSVLRkwAAAAD4tvXr18eECRO226dTp07RqVOnDM2o8li2bFm8++672+2z1157RevWrTM0IwAAAAAAAKA8yKvuOHlVAACgMlAADAAAAAAAAAAAAAAAAAAAWSS/oicAAAAAAAAAAAAAAAAAAAD8lwJgAAAAAAAAAAAAAAAAAADIIgqAAQAAAAAAAAAAAAAAAAAgiygABgAAAAAAAAAAAAAAAACALKIAGAAAAAAAAAAAAAAAAAAAsogCYAAAAAAAAAAAAAAAAAAAyCIKgAEAAAAAAAAAAAAAAAAAIIsoAAYAAAAAAAAAAAAAAAAAgCyiABgAAAAAAAAAAAAAAAAAALKIAmAAAAAAAAAAAAAAAAAAAMgiCoABAAAAAAAAAAAAAAAAACCLKAAGAAAAAAAAAAAAAAAAAIAsogAYAAAAAAAAAAAAAAAAAACyiAJgAAAAAAAAAAAAAAAAAADIIgqAAQAAAAAAAAAAAAAAAAAgiygABgAAAAAAAAAAAAAAAACALKIAGAAAAAAAAAAAAAAAAAAAsogCYAAAAAAAAAAAAAAAAAAAyCIKgAEAAAAAAAAAAAAAAAAAIIsoAAYAAAAAAAAAAAAAAAAAgCyiABgAAAAAAAAAAAAAAAAAALKIAmAAAAAAAAAAAAAAAAAAAMgiCoABAAAAAAAAAAAAAAAAACCLKAAGAAAAAAAAAAAAAAAAAIAsogAYAAAAAAAAAAAAAAAAAACyiAJgAAAAAAAAAAAAAAAAAADIIgqAAQAAAAAAAAAAAAAAAAAgiygABgAAAAAAAAAAAAAAAACALKIAGAAAAAAAAAAAAAAAAAAAsogCYAAAAAAAAAAAAAAAAAAAyCIKgAEAAAAAAAAAAAAAAAAAIIsoAAYAAAAAAAAAAAAAAAAAgCyiABgAAAAAAAAAAAAAAAAAALKIAmAAAAAAAAAAAAAAAAAAAMgiCoABAAAAAAAAAAAAAAAAACCLKAAGAAAAAAAAAAAAAAAAAIAsogAYAAAAAAAAAAAAAAAAAACyiAJgAAAAAAAAAAAAAAAAAADIIgqAAQAAAAAAAAAAAAAAAAAgiygABgAAAAAAAAAAAAAAAACALKIAGAAAAAAAAAAAAAAAAAAAsogCYAAAAAAAAAAAAAAAAAAAyCIKgAEAAAAAAAAAAAAAAAAAIIsoAAYAAAAAAAAAAAAAAAAAgCyiABgAAAAAAAAAAAAAAAAAALKIAmAAAAAAAAAAAAAAAAAAAMgiCoABAAAAAAAAAAAAAAAAACCLKAAGAAAAAAAAAAAAAAAAAIAsogAYAAAAAAAAAAAAAAAAAACyiAJgAAAAAAAAAAAAAAAAAADIIgqAAQAAKBcdOnSIvLy8gtfw4cNLHDNv3ryUMXl5eTFixIhynysAAAAAAAAAAAAAQDapXtETAAAAqIo2b94cH330UXz88cexfPnyWL58eWzZsiXq1asX9evXj7Zt20aHDh2iQ4cOUatWrYqeLgAAAAAAAAAAAAAAGaQAGAAAIEM2bNgQTz75ZDzwwAMxYcKEWLduXYljatSoET169Ih+/frFwQcfHIcddlg0a9YsA7MFIF2ffvppvPPOOwWvd999N5YtW5bS5+CDD45x48ZVzAQBAAAAAAAAAACASkcBMAAAQAY888wz8eMf/zgWLFhQqnGbNm2K9957L957773461//Gvn5+fHjH/847rrrrnKaKQAlGT16dLz66qsFBb9Lliyp6CkBAAAAAAAAAAAAOUYBMAAAQDlKkiR+/OMfx5///Ocy2d/WrVtj/vz5ZbIvAHbMZZddFlOmTKnoaQAAAAAAAAAAAAA5TAEwAABAOTrvvPPir3/9a5HvtW/fPoYOHRp77bVXNG/ePOrVqxerV6+OZcuWxaxZs+Ldd9+NKVOmxIYNGzI8awAAAAAAAAAAAAAAKpICYAAAgHLy1FNPFVn827t37/j1r38dQ4cOjby8vO3uY+3atfHiiy/Gk08+GU8++WSsWbOmvKZb5ubNm1fRUwDIqAYNGsS+++4bnTt3jgceeKCipwMAAAAAAAAAAABUYgqAAQAAykGSJHHxxRcX2n7cccfFo48+GrVq1UprP3Xr1o3jjjsujjvuuFixYkU8+OCDsXDhwrKeLgClVK9evdhnn32ib9++Ba9u3bpFXl5ezJs3TwEwAAAAAAAAAAAAsFMUAAMAAJSDiRMnFvoG3F133TVGjBiRdvHvtho2bBgXXXTRzk8OgJ3y9NNPR9u2baNatWoVPRUAAAAAAAAAAAAgRykABgAAKAf//ve/C20bPnx47LLLLhUwGwDK0m677VbRUwAAAAAAAAAAAABynAJgAACAcvDpp58W2tanT58KmEnJpk2bFu+//3588cUXsXHjxmjRokW0bds2BgwYEPXr16/o6VWYJEniww8/jE8++SQWL14cS5cujXr16kXz5s2jQ4cO0a9fv6hevewuq1etWhUffvhhzJw5M5YvXx6rV6+OGjVqRN26daNZs2ax2267RZcuXaJ58+ZlFrOsbNq0Kd56662YNm1aLF26NCIiWrZsGb17945evXqlvZ+VK1fG22+/HTNmzIjly5dHvXr1olWrVjFgwIBo27ZteU0/51XEGp85c2ZMmzYtFi1aVLB2WrRoEe3atYv+/ftHjRo1yiXuty1dujQmTZoUn3zySaxcuTIaNmwYbdq0iV69ekXnzp3LPT4AAAAAAAAAAADAzlAADAAAUA4WLVpUaFu9evUyOocOHTqkFCKfccYZMWLEiIiI2LhxY/zpT3+KP/zhDzF37twix9epUyeOOOKIuPbaa6Nnz55lGr88rVixIo4//vgYM2ZMyvYePXrECy+8EO3atdvu+HfeeSfuuuuueOmll+LLL78stt8uu+wSw4YNi1/84hfRv3//HZrrli1b4uGHH46RI0fG+PHjY+vWrSWO6dixYwwcODCOO+64OPzww6N27do7FDsd48aNiyFDhqRse+WVV2Lw4MEREfH555/HTTfdFA899FCsWrWqyH107do1fvnLX8YPf/jDYuN88MEHceONN8YzzzwTGzZsKLLPAQccEL/5zW9iwIABJc577Nixccghh6Rsu+666+L6668vcez27LPPPjFlypSCdosWLeKzzz6LmjVr7tR+d1RFr/Ftff755/HrX/86nn766Zg3b16x/XbZZZc45JBD4mc/+1nB71JpXH/99XHDDTekbEuSpOC/x48fHzfffHOMGTMmtmzZUuQ+evfuHeeff36cffbZkZeXV+o5AAAAAAAAAAAAAJS3/IqeAAAAQC4qqiizqG8FrgiffPJJ9O7dO37+858XWxgYEbFu3br417/+FX369ImrrroqreLUijZ//vwYOHBgoeLfQw89NF5//fXtFv9++umncfzxx0e/fv3ioYce2m7xb8TX39g7atSo2G+//eL444+P5cuXl2quH3zwQfTu3TuGDx8er7zySto/37lz58ZDDz0U//M//5ORgurijBo1Krp37x533313scW/EV9/E+zpp58eJ510UqHi3iRJ4le/+lX07t07nnjiiWKLfyMi3njjjTjooIPi5ptvLnFuQ4cOjT333DNl23333VdsMWg63njjjZTi34iIs88+u8KKf7cn02t8y5Ytce2110aXLl3izjvv3G7xb8TXa+epp56KIUOGxJFHHhnz58/fobhFzePCCy+MwYMHx0svvbTd/9+TJ0+Oc845JwYNGrTdnxEAAAAAAAAAAABARVEADAAAUA5atWpVaNvjjz9eATNJNXfu3BgwYEB89NFHaY/ZvHlz3HLLLTF8+PCsLgKePHly7L///jF16tSU7WeeeWa88MIL0aBBg2LHvvnmm9G/f/8YNWrUDsUeNWpU7L///jF79uy0+r/77rtx8MEHxwcffLBD8Sraww8/HCeccEKsWLEi7TFPPPFEnHXWWQXtJEninHPOieuuuy7twtwkSeLqq6+OP/7xjyX2/fGPf5zSXrhwYTzz/7F35+Faz/njx1+nc1qkdagsUSmyy1JESJkv0qJsM5YWS6Jl5odhxGVsTb6aZoaM7DXRDNmKFEpjSWhB5ktSmSKhEUnadX5/uDRzd5/q3KfTOW88Htflj/t135/3+31Xn65Levo8+WSxz7uxoUOHZryuUKFC9OzZs8TrbStlfY+vWLEiOnfuHDfeeGOsWLEi1+PGuHHjomXLllt9LxQWFsbZZ58df/nLX3K6bvLkyXHsscfGBx98sFX7AwAAAAAAAAAAAJS2gvI+AAAAwI/RkUceGXfffXfGbOLEiTFkyJDo27dvuZxp7dq10aVLl4wn2+61117RpUuXaNy4cVSrVi0+/fTTePnll2PcuHGxatWqjOsfeOCBqF27dtx6661lffQtevrpp+PMM8+Mb775JmN+/fXXx7XXXrvZa1944YU46aSTsr5vhQoV4uijj44jjzwyGjVqFLVq1YqVK1fGwoUL48UXX4znn38+I1ydPXt2tGvXLqZPn77Z2Hj16tVxzjnnZD0xOC8vL1q2bBmtWrWKxo0bR40aNSI/Pz+WLVsWS5YsiXfffTdmzpwZM2fOjMLCwmL+yJS+6dOnR//+/TecoVatWtGuXbs44ogjom7durFy5cqYNWtWjBo1KutJsH/729/ilFNOidNPPz1+//vfx3333bfhvQYNGkT79u1j//33jx122CGWLl0aU6dOjVGjRsWyZcsy1rnyyiujffv20bBhw02es2vXrnHVVVdlPJ146NCh0blz55y/85IlS+KRRx7JmJ100kmb3b88lPU9vn79+ujUqVNMnDgx673q1atHhw4dokWLFrHTTjvFsmXLYs6cOfHEE09khfKLFi2KY445JmbMmBGNGzcuwTePGDx4cDz88MMZ+3fq1CmaN28e9erVi6VLl8Z7770Xjz32WHz00UcZ13700UfRpk2beOutt6JWrVol2h8AAAAAAAAAAACgtOUVluffGgYAAPiR+ve//x0NGjSIlStXZr3XoUOHuOKKK6JVq1bb9AwNGzaMBQsWbHhdpUqVDcFfrVq14s9//nN069atyGsXLVoUF110UYwdOzZjnpeXF5MmTYrWrVvnvH+3bt1i+PDhm71m/vz50ahRo4zZsGHDonv37pu85o477oh+/fplxLgVK1aMe++9N7p27brZ/T799NNo1qxZRjAZ8d1Tg6+77rrYfffdN3ntvHnzonfv3vHss89mzE877bSsWPS/Pfjgg3HuuedmzA455JAYMWJE7Lfffps97/dnfvLJJ+POO++Mnj17Rq9evbZ4TUm98MILcdxxx2XMKleuHKtXr46IiL59+8YNN9xQZDS5evXquOyyy7KeyNq0adMYMWJEtGzZMtavXx9Vq1aNwYMHx4UXXhj5+flZ63z66adx6qmnxpQpUzLmPXv2jLvuumuz5+/bt2/G04Lz8vLi/fffjyZNmmz2uo0NHjw4Lr/88ozZ2LFj4+STT85pndJW3vf4zTffHFdddVXW/MILL4xBgwZFzZo1i7xu2LBhcemll2ZF8C1atIhXXnklCgo2//+ru+666+L666/PmP33d+/Ro0f88Y9/LPLX5fr16+NPf/pTXHPNNVkBdPfu3WPYsGGb3bu4ivq97Nhjj40XXnihVNYHAAAAAAAAAAAAfvwqlPcBAAAAfozq1KkTffr0KfK9p556Ko4++uioX79+nHfeeXHPPffEzJkzY926ddv0TN/HbtWrV4/nnntuk2FgRMQuu+wSY8aMiV/+8pcZ88LCwujZs2esX79+m561OAoLC+M3v/lN9O7dOyP+rVmzZjzzzDNbjH8jIs4777yM+Dc/Pz9GjhwZ999//2bj34iIxo0bx/jx46NHjx4Z80cffTSmTp26yevGjBmT8XrHHXeM5557rljxb0TETjvtFD179ow33nijWN+xtH0f/956661x2223bfKJqZUrV47bb789TjjhhIz57Nmzo0OHDrF+/fqoVq1aTJo0KXr16lVk/Bvx3fcdO3Zs1KlTJ2P+0EMPFRnY/7fevXtnvC4sLNxiNLyxwsLCuPPOOzNmDRo0iJNOOimndcpCWd7j8+fPL/Lp2jfddFPcfffdm4x/I74LdCdMmJD1pOypU6eW+Anj33/33/72t3H//fdv8tdlhQoV4rLLLotHHnkkKzQePnx4vPTSSyXaHwAAAAAAAAAAAKC0CYABAAC2kRtuuCFatmy5yfc//vjjGDZsWPTs2TOaNWsW1atXj8MPPzz69esXjz76aNZTaUvLkCFDonnz5lv8XIUKFWL48OGx1157ZcznzJkT48aN2yZnK65Vq1bFGWecEX/4wx8y5rvvvnu88sor0aZNmy2uMW3atBg/fnzGbODAgXHWWWcV+xx5eXlx1113xT777JMxv/nmmzd5zQcffJDxunPnzrHDDjsUe8//VrVq1RJdt7XOOuus6NevX7E+e+ONN2bNFi9eHBHfRcSHH374FteoXbt2XHbZZRmzZcuWZT0VeGN77713tG3bNmM2bNiwDRFzcUycODHmzp2bMbvooouiQoV0/0ilLO7x22+/PdauXZsx69KlS1x99dXFOuNhhx0Wd999d9b8tttuywj6c9G6desYOHBgsT7bvn37uOaaa4rcHwAAAAAAAAAAACAF6f5tVQAAgB+4KlWqxLhx46JDhw7F+vyqVati6tSpMWTIkDj99NNj5513jtatW8f999+fU7C4OYcddlhOT42tVKlSDB48OGu+8RNRy9Lnn38ebdq0iUcffTRjfsghh8Rrr71W7Cfp/u///m/G6yZNmsSll16a83kqVqwY/fv3z5iNHz9+kz9nX3/9dcbrksa/5SU/P7/YkWVERPPmzYt8mnLTpk2znp68OaeddlrW7I033tjidRs/iXvJkiUxatSoYu87dOjQjNcVK1aM888/v9jXl7WyuMdXrVoV9913X9Y6ucazZ555ZrRu3Tpj9uGHH2Y9Jbu4ct3/yiuvjPr162fMxowZE5988kmJ9gcAAAAAAAAAAAAoTQJgAACAbahWrVoxZsyYGDFiRDRp0iSnawsLC+PFF1+M888/P/baa68YOXLkVp/nggsuiLy8vJyuadeuXVYk9/zzz2c9/bMsvP/++3HEEUfEq6++mjE/+eST46WXXoqdd965WOusWrUqxo4dmzHr3r175Ofnl+hc7dq1y1r/tddeK/KzGwe/kydPLtGe5eX4448vMujdnGbNmmXNevTokdOvxcaNG0eNGjUyZrNnz97idR06dIgGDRpkzIobsC9atCieeuqpjFmXLl2ibt26xbq+PJTFPT5t2rRYunRpxqxjx46x66675rRvRMQll1ySNZswYULO6xxxxBFxwAEH5HRNlSpV4txzz82YrVu3LiZOnJjz/gAAAAAAAAAAAAClTQAMAACwjeXl5cW5554bs2bNiqeeeip++ctfZoWMW/Lhhx/GOeecEz169NiqpwGfcsopOV9ToUKF6NSpU8Zs1apV8dZbb5X4HCUxefLkOPLII2PevHkZ84svvjjGjBkT22+/fbHXev3117N+HI866qgSn+1nP/tZ1KxZM2P25ptvFvnZww8/POP15MmT4+qrr45169aVeP+ydMwxx+R8zcYBbkTE0UcfvdXrbByhFiU/Pz969eqVMZsyZUq8/fbbW7z2nnvuyfp5ufjii7d80HJUFvf4K6+8kjUr6gnNxdGpU6eoXLnyFtffkpJ874jvgu6NbSreBwAAAAAAAAAAAChLBeV9AAAAgJ+KgoKCaN++fbRv3z6+/fbbeOutt2Ly5Mkxbdq0ePPNN2P27Nnx7bffbnaN4cOHx4oVK+Lhhx/Oef9dd9016tWrV6KzH3LIIVmzGTNmRPPmzUu0Xq4efvjh6NatW0a0m5eXFzfffHNcccUVOa9XVGB4ySWXRKVKlUp8xhUrVmS8/vzzz4v8XPfu3eO2226LwsLCDbPf//738be//S169OgRnTt3zvlJpmUp1ydZR0RUr159m6zz1VdfFeu6Cy64IK6//vpYtWrVhtnQoUNj6NChm7zm22+/jXvuuSdjtu+++8axxx6bw4nLVlnd42+88UbW7LDDDivRvpUqVYoDDzwwpk2btmH2zjvvxOrVq7PC4M059NBDS7T/AQccEAUFBRmh94wZM0q0FgAAAAAAAAAAAEBpEgADAACUg/z8/Dj00EMzorUVK1bE66+/Hv/4xz/ikUceiffee6/Ia0eNGhWtWrWKvn375rRn06ZNS3zevffeO2u2ePHiEq+Xi3vvvTemTJmSEcxWqVIl/vrXv8YZZ5xRojUXLlyYNZs1a1aJz1iUJUuWFDlv1qxZ9OvXL2699daM+fz58+N3v/td/O53v4u6detGq1atonnz5nHkkUfG4YcfnlMMuS3Vrl0752sqVqy4TdZZu3Ztsa7bcccd48wzz4y//vWvG2YPPvhg3HLLLUXGyRERTz75ZHz88ccZs42fJJyasrrHN47bK1WqFI0bNy7x3vvuu29GALx+/fr48ssvY6eddir2GiX97pUrV45GjRrFnDlzNszK6vc2AAAAAAAAAAAAgM2pUN4HAAAA4DtVq1aN4447Lm644YaYNWtWPPPMM7HffvsV+dmbbrop64mzW1KzZs0Sn62oa5cuXVri9XLxyiuvZMS/EREPPfRQiePfiE3HuaVp5cqVm3xv8ODBcemll27y/cWLF8fjjz8eV111VRx77LFRq1atOOGEE2LYsGHx9ddfb4vjFltRMW95rlNcvXv3zni9fPnyGDly5CY/f+edd2a8rlq1anTt2nWbnK20lNU9/uWXX5bavhFFx+BffPFFTmuU5ncvq9/bAAAAAAAAAAAAADZHAAwAAJCoE044IaZNmxYnnXRS1nuLFy+OJ598Mqf1tt9++xKfpahryypELSgoyJpdfSdu85sAAKpdSURBVPXV8cknn5R4zY0DxrKWn58fgwcPjqlTp0aHDh2K/I7/bdWqVfHcc8/FeeedFw0bNoyBAwfGunXryui0Pw7NmzePFi1aZMyGDh1a5Gfnzp0bEyZMyJidddZZWx26bmtldY9vPN+afXPdO5c1SnpteUf2AAAAAAAAAAAAABECYAAAgKRtt9128dBDD8WOO+6Y9d7zzz+f01rffPNNic9R1LXVq1cv8Xq5GDBgQBx00EEZs3feeSeOPvroWLBgQYnW3G677bJms2bNisLCwlL7Z/jw4Vs8R/PmzePJJ5+Mjz/+OO67774455xzolGjRpu95osvvoj+/ftHq1atPKk0R3369Ml4/fbbb8eUKVOyPnfXXXdlPXW6V69e2/RspaGs7vGN51uzb65757JGSa8tq9/bAAAAAAAAAAAAADZHAAwAAJC4GjVqRPfu3bPms2fPzmmdr776qsRnKOraWrVqlXi9XNStWzf+8Y9/xOGHH54xnzdvXhx99NHx/vvv57xmUUH1F198UeIzbq26devGeeedFw888EB88MEH8emnn8ajjz4a/fr1iz333LPIa15//fU444wzyvikP2xnnHFG1KlTJ2O28VOAV69eHcOGDcuYNW/ePA499NBtfr6tVVb3eO3atUtt34goMmT/2c9+ltMapfndy+r3NgAAAAAAAAAAAIDNEQADAAD8ALRo0SJr9vnnn+e0RklC2e8VFRvXrVu3xOvlqnbt2jFx4sRo3bp1xvyjjz6KY445Jv75z3/mtF69evWyZiV9mvC2UK9evTj11FPj1ltvjffffz9mzJgRv/jFL7I+N2HChBg/fnw5nPCHqXLlynHhhRdmzB599NFYsmTJhtePPPJIxuuIiIsvvrhMzre1yuoe3ziiXrNmTcybN6/Ee7/77rsZrytUqJBzAFzS775mzZqYP39+xqwsf28DAAAAAAAAAAAA2BQBMAAAwA9AzZo1s2YFBQU5rbFw4cJYvHhxifafMWNG1qysn4harVq1GD9+fLRr1y5j/tlnn0Xr1q1j2rRpxV5r46cJR0S89NJLW33GbeWQQw6Jv//97zFgwICs9x577LFyONEPV69evSI/P3/D61WrVmU88XfjJwLXrl27yPg6RWV1jx9yyCFZs+nTp5do3zVr1sTbb7+dMdt///2jUqVKOa1T1PmL4+233461a9dmzH4IT3sGAAAAAAAAAAAAfvwEwAAAAD8An332WdasqKfYbsno0aNzvmb9+vUxZsyYjFmVKlWiWbNmOa+1tapUqRKjR4+O0047LWP+xRdfRNu2bYsd8R533HFZAfXYsWOzQsDUXHnllbHDDjtkzDaOJ9m83XbbLTp27Jgxu+uuu6KwsDDefvvtmDJlSsZ73bp1i+22264sj7hVyuIeP/LII7Nmjz76aM77RkQ89dRTsWrVqi2uvyUl+d4REY8//njW7IgjjijRWgAAAAAAAAAAAAClSQAMAADwAzBp0qSsWePGjXNe59577835mvHjx8fChQszZm3bto2KFSvmvFZpqFixYjz00EPRvXv3jPnXX38dJ554Yjz77LNbXKNGjRrRunXrjNnChQvjgQceKMWTlr78/PzYc889M2ZfffVVOZ3mh6tPnz4Zr+fOnRsTJ06MO++8M+uzvXr1KqtjlYqyuMdbtGgRtWrVypg99dRTsWjRopz3vuOOO7Jm//M//5PzOq+++mq88847OV2zevXqrHu+oKAgjj/++Jz3BwAAAAAAAAAAAChtAmAAAIBt4Kmnnop//etfpbLWvHnzYtSoUVnzk08+Oee1pk2bllPkunbt2rj88suz5uUdRebn58f999+fFXKuXLkyOnbsWKyngV5zzTVZs8svvzw++OCD0jrmNvHJJ59kvK5Tp045neSHq02bNrHvvvtmzAYNGhQPPvhg1ueaNm1alkfbamVxj1euXDkuuOCCjNnq1avj17/+dbH3jfjuqcEb/88NGjRokPWE5uL61a9+ldPnb7nllqzwuVOnTrHzzjuXaH8AAAAAAAAAAACA0iQABgAA2Aaefvrp2GuvvaJHjx7x3nvvlXidRYsWRefOnWPFihUZ8zp16sTPf/7zEq3Zp0+feOONN7b4ucLCwjj//POzzt+kSZNo165difYuTXl5eTFkyJD47W9/mzFfs2ZNnH766TFy5MjNXn/sscdm/Rh++eWXceKJJ8asWbNKdKZVq1bFXXfdFX/84x+LfH/58uXxm9/8Jj788MMSrT9mzJhYsGBBxuyggw4q0Vo/db179854PWHChPj6668zZuUdupdUWdzjffr0yXpC8COPPBKDBg0q1hnffPPNrIg44ruINz8/v1hrbOz5558vMuwvyvjx4+PGG2/Mmvfr169EewMAAAAAAAAAAACUNgEwAADANrJu3boYPnx47LPPPnHEEUfE7bffnvX01k1ZsWJF3HnnnXHwwQfHP//5z6z3Bw0aFFWqVMnpPN9/ftmyZXH88cdnPe30v33yySfRuXPnrCeJ5uXlxd133x0VKqTzr5MDBw6MAQMGZMzWrVsXXbt2jbvvvnuz1w4fPjx22WWXjNmcOXOiRYsWMXDgwPjqq6+2uH9hYWFMmTIl/t//+3/RsGHD6NWr1yafIrxu3br4wx/+EHvssUd07tw5Ro4cWaw91q9fH8OHD49zzjkn672iZmxZ165do0aNGpt8f6eddopTTjml7A5UCsryHm/QoEHcdNNNWfMrrrgievfuHcuWLdvktSNGjIi2bdtm/dpv0aJF9O3bd7P7bsr3333AgAFx4YUXbvK+Wr9+ffz5z3+OLl26xNq1azPe6969exxzzDEl2h8AAAAAAAAAAACgtBWU9wEAAAB+Cl5//fV4/fXXo2/fvtGwYcM4/PDDY999940dd9wxdthhh8jLy4tly5bFggULYubMmTFp0qT45ptvilzrjDPOiG7duuV8hi5dusQ777wTM2fOjC+//DLOPffcGDBgQHTu3DkaN24c1apVi08//TQmT54cTz/9dKxcuTJrjb59+8Zxxx2X897bWv/+/aN69erxq1/9KgoLCyPiu9DvoosuiuXLl8ell15a5HW77LJLjBkzJlq3bp3x4718+fLo379/DBgwIFq1ahVHHnlk7LzzzlG7du1YuXJlLF26NBYtWhRvvPFGzJgxI5YsWZLTeb/99tsYPXp0jB49OipWrBgHHnhgHHzwwbH33ntH7dq1o2bNmrF27dpYvHhxvPPOO/HMM88U+dTgs88+O1q2bJnT3nynWrVq0bVr17j99tuLfP+CCy7IesJt6sr6Hr/88stjwoQJMXHixIz5HXfcESNHjoyOHTtG8+bNo169erFs2bKYO3duPP744zFnzpystWrWrBkjR46MgoKS/VHVDTfcEFdccUVERNx7770xatSoOOWUU6J58+ZRt27dWLp0abz33nvx2GOPFXkvNWjQIP70pz8Ve79FixZt9inJa9asyZpNnz49mjVrtslrdtlllxg3blyxzwAAAAAAAAAAAAD8uAmAAQAAytj8+fNj/vz5Jbq2W7ducd9995Xo2ooVK8YTTzwRLVu2jM8++ywiIt57770YOHBgsa4/55xzcgrkylrfvn2jWrVqccEFF8T69es3zC+77LJYvnx5XHvttUVed9hhh8Vrr70Wp556arz//vsZ733zzTfx7LPPxrPPPrvNzr127dqYMWNGzJgxI6frWrduHXfcccc2OtVPQ+/eveMvf/nLhmj8e/n5+dGzZ89yOlXJlfU9XqFChRgzZkyceeaZMXbs2Iz3vvrqq3jggQeynjBclO/D1yZNmhR7741dfvnlMX369Bg1alREfPcU5BEjRsSIESO2eG39+vVj0qRJUatWrWLvt2bNmpg5c2ZOZ/zmm282e83SpUtzWg8AAAAAAAAAAAD4catQ3gcAAAD4MTr33HPj7LPPziko25w99tgjxowZE8OHD4/8/PwSr9OoUaN4+eWXY5999in2NQUFBXHllVfG8OHDo0KFtP81skePHvH3v/8968mtv/vd7zY8HbQo+++/f0ybNi369OkTVapU2aozNG/ePE4++eQi3ysoKIgddthhq9avWLFiXHrppfHMM89EjRo1tmqtn7q999472rZtmzU/+eSTY7fddiuHE229sr7Hq1atGqNHj45rrrkmtttuu1yPGyeeeGK8+uqrcdBBB+V87X/Ly8uLkSNHxkUXXZTTdUcddVS8+OKLsccee2zV/gAAAAAAAAAAAAClLe2/uQ0AAPADddRRR8WDDz4Yixcvjueffz6uvfbaaNOmTVSrVq3Ya9SrVy/OPvvsePrpp2P27NnRsWPHUjnbnnvuGW+++Wbccsstsfvuu2/yc1WqVIkuXbrE9OnT4+abb96q8LgsnXHGGfHEE09khbyDBg2KSy65JOtpr9+rUaNGDBkyJObPnx/XXHNNHHzwwcWKIbfbbrto27ZtDBw4MN59992YOnVqnHTSSUV+tlq1avHZZ5/Fyy+/HP37949jjjkmqlatWqzv1aBBg7jiiiti1qxZMXjw4KhcuXKxrmPzDjvssKzZxRdfXA4nKT1lfY/n5+fHjTfeGHPmzIl+/fpFw4YNN/v5atWqRadOnWLSpEkxfvz4zZ4xFwUFBXHnnXfGxIkTo02bNpu9fw8++OC455574uWXXxb/AgAAAAAAAAAAAEnKK9zU33wGAACg1BUWFsbHH38cc+bMiQ8//DCWLVsWX3/9deTl5UWNGjWievXqsfPOO8eBBx4Y9erV26q9GjZsGAsWLNjwulu3bjF8+PCsz/3f//1fzJw5MxYtWhRr166NunXrRv369eOoo46K6tWrb9UZfui+/PLLmD59eixevDiWLFkSy5Yti6pVq274eWratGnsscceWxVHr1u3LubNmxfz5s2LhQsXxrJly2LlypUb9tl9993jgAMOiF133bUUvxkREd9++200atQoPvroow2zPfbYI+bOnRt5eXnleLLiSfkenz17drzzzjvx73//O5YsWRLbb7991KlTJ3bfffdo0aJFVKpUqcRrX3fddXH99ddnzIr6463PP/88XnvttZg3b14sX748atSoETvvvHMcfPDB0bhx4xLvDwAAAAAAAAAAAFAWCsr7AAAAAD8leXl5Ub9+/ahfv355H2WD/fffP/bff//yPkaSateuHT//+c+36R4FBQXRtGnTaNq06Tbdh2zjxo3LiH8jInr27PmDiH9zUR73eAq/pnfcccdo3759uZ4BAAAAAAAAAAAAoKQqlPcBAAAAAMrDkCFDMl5XqVIlzjvvvHI6DQAAAAAAAAAAAAD8hwAYAAAA+MmZNm1aTJgwIWN21llnRZ06dcrpRAAAAAAAAAAAAADwHwJgAAAA4Cdl3bp10adPn4xZXl5e/PrXvy6fAwEAAAAAAAAAAADARgTAAAAAwE/G7Nmzo2PHjjF16tSM+S9+8Ys44IADyulUAAAAAAAAAAAAAJCpoLwPAAAAALCtNGvWLCIi1q9fH4sWLYolS5ZkfaZatWoxYMCAMj4ZAAAAAAAAAAAAAGyaABgAAAD40Zo5c+YWP3PbbbdFo0aNyuA0AAAAAAAAAAAAAFA8AmAAAADgJ6lSpUoxaNCg6NGjx1at065du1i0aFEpnWrTxo0bF7vssss23wcAAAAAAAAAAACA8icABgAAAH4S8vLyolq1atG4ceNo06ZN9OrVK/bcc8+tXvfdd9+NBQsWlMIJN2/NmjXbfA8AAAAAAAAAAAAA0pBXWFhYWN6HAAAAAPihatiwYZkEwP/617+iYcOG23wfAAAAAAAAAAAAAMpfhfI+AAAAAAAAAAAAAAAAAAAA8B+eAAwAAAAAAAAAAAAAAAAAAAnxBGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASUlDeB4BULV26NF588cUNr3fbbbeoXLlyOZ4IAAAAAAAA/mP16tXx0UcfbXh97LHHRq1atcrvQAAAAAAAAACUGgEwbMKLL74Yp5xySnkfAwAAAAAAAIpl9OjR0alTp/I+BgAAAAAAAACloEJ5HwAAAAAAAAAAAAAAAAAAAPgPATAAAAAAAAAAAAAAAAAAACSkoLwPAKnabbfdMl6PHj06mjRpUk6nAQAAAAAAgExz586NU045ZcPrjf/7FgAAAAAAAAA/XAJg2ITKlStnvG7SpEnst99+5XQaAAAAAAAA2LyN//sWAAAAAAAAAD9cFcr7AAAAAAAAAAAAAAAAAAAAwH8IgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAgIQIgAEAAAAAAAAAAAAAAAAAICECYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAACAhAiAAQAAAAAAAAAAAAAAAAAgIQJgAAAAAAAAAAAAAAAAAABIiAAYAAAAAAAAAAAAAAAAAAASIgAGAAAAAAAAAAAAAAAAAICECIABAAAAAAAAAAAAAAAAACAhAmAAAAAAAAAAAAAAAAAAAEiIABgAAAAAAAAAAAAAAAAAABIiAAYAAAD+P3v3HWVVdf4P+J2hSS8CUqQKCAqCitixK7HEhgVjxN4wMcYejSWxG6PJD0tEJUYFe4sYFAXEhiBKFyw0CwoISK9zfn+4vF/uNO4gMEd9nrVmrdln3n32vuece+8x5HM2AAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAAAAAAAAAAAAAAAAJAiAsAAAAA/McOHD4+8vLzMz3XXXVfeUwKIiMj6bNp3333LezqwyZXlmj/11FOz6mfMmLFZ5ggAAAAAAAAAAMBPkwAwAAAAAAAAAAAAAAAAAACkSMXyngAAAMDmMHfu3Bg1alTWz/z587NqkiQpp9kBAAAAAAAAAAAAAMD/EQAGAAB+tj766KO4/vrrY9SoUTF9+vTyng6k1owZM6JVq1aZdu/evePf//53+U2IIlq2bBkzZ86MiIgWLVrEjBkzyndCAAAAAAAAAAAAAGxSAsAAAMDP1tSpU+OJJ54o72kAAAAAAAAAAAAAAECZCAADAAC/SDVq1IglS5aU9zQAflaSJCnvKcBm5ZoHAAAAAAAAAABgUxEABgAAfvaqVq0aXbp0iW7dusUuu+wSu+yyS1SqVClat25d3lMDAAAAAAAAAAAAAIAiBIABAICfrW7dusUHH3wQnTp1iooVs//zZ8aMGeUzKQAAAAAAAAAAAAAAWA8BYAAA4GerSZMm0aRJk/KeBgAAAAAAAAAAAAAAlIkAMAAAm9Xo0aPjk08+iS+//DLy8/Njm222if322y9q165dar8VK1bEW2+9FR999FEsXrw46tatG+3bt4+99967yMquvzRr1qyJkSNHxsSJE2P+/PlRq1ataNasWey7777rPa65KCgoiFGjRsUnn3wSc+bMibVr10bDhg2jVatWsccee0SlSpU2wqv4P4sXL44333wzPvnkk1i6dGk0aNAgWrduHd27d9/oY6XN6tWr44033ohp06bFvHnzonr16tG2bdvYe++9o2bNmht1rFWrVsW7774b06dPjzlz5kSFChWiYcOG0bZt2+jWrVvk5+dvtHFGjhwZM2bMiLlz50ZBQUE0aNAg2rZtG7vttltUqFBhg/e9evXqmDBhQkycODG+/fbbWLp0aVSpUiVq1qwZLVq0iHbt2sU222yzUV7Hhpg1a1a88847MWvWrEiSJBo0aBBdunSJHXfcMfLy8n70/qdOnRoffvhhzJkzJ5YuXRr169ePJk2axF577bVR3vvlae3atfH+++/HZ599FvPmzYvFixdHjRo1omnTprHddttFhw4dNvgYjh07NiZPnhxz5syJFStWRMOGDaNZs2ax1157RdWqVTfq6/jh83PcuHHx7bffRvXq1aNx48bRvXv3aNSo0UYdq6xWrFgRkydPjo8++ijmzp0bS5cujZo1a8aWW24ZnTp1io4dO260z4ENtXz58hgxYkRMmTIllixZEnXr1o2WLVvGPvvsE9WrV9/s85kzZ05MnDgxPvvss1i4cGGsWbMm6tWrF40aNYpdd911k5zT1atXxzvvvBMTJ06MhQsXZr7j99lnn6hbt+5GH6+8LV68OD788MOYOnVqLFy4MFauXBnVqlXLnPvtttsuttpqq40yzi/lXmPOnDkxcuTI+Prrr+Pbb7+NGjVqRMOGDaNbt27RqlWrH7Xv+fPnxwcffBCffvppfPfdd7FmzZqoVq1a1K9fP1q1ahXbb7/9z/I6BQAAAAAAAAAA2GwSoFgTJ05MIiLzM3HixPKeEgCk3rBhw7K+P6+99tokSZJkzZo1yT/+8Y+kbdu2WX//4adatWrJpZdemixfvrzIPhctWpRcdtllSa1atYrt26BBg+SBBx4odV6ff/55UqFChUyfdu3abdDre+GFF7LGPv744zdoP2VV0nFdtWpVcssttyQNGjQo9thUqVIlOfHEE5Mvvvhig8b95ptvkj59+iRbbrllsfuPiKRmzZrJKaecksyYMSPn/V577bVZ+xg2bFiSJEkyZ86c5KyzzkqqVKlS7Fj16tVLrrzyymKvkw0xffr0ImOUl2XLliVXXHFFUq9evRLP5VlnnZXMnTs3SZKSr4lcTJs2LTn55JOTmjVrlnhe69evn/zud7/LjLchJkyYkBx33HFJjRo1ShynTp06yQUXXJB88803Zdr37Nmzkz59+iR169Ytcd/rvpbjjz8+GTx48Aa/lpKsO84+++yT2T5q1Khk//33L3FOzZo1S/r3779BY65YsSK5/fbbk2222abE/VesWDE54IADkjfffHO9+2vRosV6j2FxPxs6//WZOHFictJJJyW1a9cudfxGjRol55xzTjJ27Nic9rto0aLkqquuSpo0aVLiPrfYYovkqKOOSiZMmJDzfPv371/scVm7dm3St2/fZOutty52rLy8vOSQQw5Z71i9e/feoPPTu3fvYvf3+eefJ7fffnuy7777lvhZ+8NP3bp1kz/+8Y/Jl19+mfPxSJKS3xe5vL7p06cnSZIkCxcuTC666KKkevXqxc6tcuXKyXnnnfejPqNyUVBQkIwYMSK54IILkm233Xa9x71Tp07Jv//972T16tU5j1HSd+KKFSuSv/zlLyV+L1SoUCE54YQT1vv9e/PNN2f1u/HGGzfoWBx99NFZ+3n55Zc3aD8lGTNmTHL00UcnlStXXu9xbtWqVXLBBRckkyZNKnF/m/NeY2Nc8+vz7LPPJltssUVW39K++9euXZs8/PDDSdeuXZO8vLwSj2WHDh2S/v37J2vXrs359SZJkrz22mvJQQcdlOTn55d6rvLy8pL27dsnl19+eTJr1qwyjQEA5M6/ZwEAAAAAAAD8fJXvUi4AAPzsLV26NH71q1/FhRdeGJ988kmxNcuWLYvbb789Dj744Fi+fHlm+2effRY777xz3HbbbbFo0aJi+86dOzfOPPPMuOiii0qcw9Zbbx2HHXZYpv3xxx/HiBEjyvxa+vXrl9U+++yzy7yPjWXhwoWx3377xRVXXBFz584ttmblypXx+OOPx3bbbRf/+9//yrT/J598Mtq0aRN33313fPvttyXWLV68OP7zn//EtttuG3fffXeZxljXhAkTonPnztGvX79YuXJlsTXz58+Pm2++OTp37hwzZszY4LHSZvr06dG5c+e45ZZbYv78+cXWrFy5Mvr16xedO3eOCRMmbPBYd911V7Rv3z4effTRWLx4cYl18+bNi//3//5fbLPNNvHss8+WaYw1a9bE7373u+jcuXM89dRTsWTJkhJrFy5cGH379o02bdrEoEGDctr/kCFDon379nH33XfHggUL1ls/b968ePLJJ+Ovf/1rzq/hx/jnP/8Zu+++ewwdOrTEms8//zxOO+20OPvss6OgoCDnfU+aNCm22267uPTSS+Ozzz4rsW7NmjXx+uuvx9577x2nn356rF69ukyvoTysXr06zj///Nhhhx1iwIAB8d1335Va//XXX8e//vWvOPLII9e77zfeeCPatGkTN954Y3z11Vcl1q1YsSKef/756NKlS1x11VVlfg0/WLRoURx88MFxwQUXxBdffFFsTZIk8corr8Suu+4ar7zyygaPVRbjx4+P5s2bx6WXXhrDhw8v8bP2BwsWLIi///3vG/Qd8mNMnjw5OnfuHHfeeWcsXbq02JpVq1bFvffeG7vtttsm/T649NJLo3v37tG3b9+YOnXqeusnTJgQp556auy3334xZ86cDR73yy+/jN122y2uueaaEr8X1q5dG0888UR07do1PvzwwxL3dfrpp2etaPvggw9GkiRlms/XX38d//3vfzPt5s2bxyGHHFKmfZTmlltuiV122SWee+65WLVq1Xrrp0+fHn379o0BAwaUaZyf6r3GPffcEz179owVK1ZERESFChWiX79+cd111xVb/8knn8ROO+0UvXv3jvfff7/U8/3RRx/FaaedFnvuuWeJ95PrSpIkfve738WBBx4YQ4YMWe93WJIkMWXKlLj11ls322cdAAAAAAAAAADAz4kAMAAAm0ySJHHiiSfGkCFDMtuaNGkSXbt2je222y4qVKiQVf/mm2/GhRdeGBERc+bMif333z8TGs7Ly4vWrVvHLrvsEq1bty4y1l133RWPPfZYiXM599xzs9qFw7zr8+WXX2YFoFq3bh37779/mfaxsRQUFMRxxx0Xb7/9dmbblltuGTvuuGN06NAhtthii6z6RYsWxTHHHBPDhg3Laf/9+vWLXr16FQmI1qhRI7bffvvo0qVL1KlTJ+tvK1eujAsuuCD+8pe/lPn1fPPNN9GjR4+YPXt2ZtvWW28dXbt2jdatW0d+fvZ/tnz88cex//77lxrk+6n46quvsq7zH1SoUCHatGkTXbt2jSZNmmTV9+jRI7755psyj/XnP/85LrrooiLhqjp16kTnzp2jY8eOUaNGjay/LVq0KI4//vjo379/TmMsW7YsDj/88Ojbt2+RUFCjRo2iS5cusdNOO0XDhg2z/rZ48eI48sgj46mnnip1/5MmTYojjjiiSDi0SpUqse2220a3bt1i5513jjZt2mQF3jaX++67Ly688MJYu3ZtRERUrVo1OnToELvsskvWefxBv3794q677spp3++//37svffeMW3atKztlSpVirZt2xa5Vn7Qv3//+PWvf51TqK68fPfdd3HggQfGvffeW+S6qVq1arRr1y523XXX6NChQ5FrdH0GDRoUPXr0KBLG3GKLLaJ9+/ax0047RYMGDbL+tnbt2rjpppvijDPOKPNrWb16dRx++OHx+uuvZ7Y1bNgwdtppp9hhhx2ievXqWfXLli2Lnj17xsyZM8s8VlmtWrWqSBCwcuXKsc0228SOO+4Y3bp1i7Zt20bFihWzar777rs4/PDDc/4O+TFmzJgRBxxwQNbxaNGiReyyyy7RoUOHIvcNn332WRxzzDGxZs2aTTKfHwKX66pbt2506NAhdt111+jSpUs0bty4SM1bb70V+++/f9ZDTXK1cOHCOPDAA2Ps2LGZbU2bNo2uXbtGx44do0qVKln18+bNi1//+tclPiilYcOGcfTRR2fa06ZNK/UBBcX597//nXWMzzjjjCLfzRvqwQcfjCuvvLLIe79mzZrRqVOn2G233aJz587RrFmzyMvL2+Bxfqr3Gn/605+iT58+meNTrVq1eP755+PMM88stv69996LPfbYI8aNG5e1/Yf7im7dusV2221X5F5x5MiRsfvuu683BHzNNddE3759i2yvV69edO7cOXbbbbfo1KlTse8LAAAAAAAAAAAANkA5rj4MqTZx4sQkIjI/EydOLO8pAUDqDRs2LOv7s2XLlpnfe/XqlUyePDmrft68ecn555+f1ScvLy8ZP358csghhyQRkWyxxRbJNddck8yePTur75QpU5Lu3btn9W3UqFGyatWqYue2du3arPlsscUWyfz583N+bX/5y1+yxrrpppvKfoA2UOHj2qJFi8zvO+20UzJs2LCkoKAgU7948eLkX//6V1KnTp0ix2fBggWljjVmzJikUqVKWf2aN2+ePPnkk8mKFSsydWvWrEkGDx6cbL/99lm1EZG8/PLLpY5x7bXXlvh6TjzxxOSjjz7Kqv/yyy+TSy+9NKlQoUJWvx49epT9YK5j+vTpRea+ufXo0SNr/MqVKyfXXXdd8s0332TVTZw4MTnmmGOKfW9FRHLttdeWOs6LL75Y5LV27NgxGTx4cLJmzZpM3cqVK5Mnn3wyadasWZF5jRs3br2v55RTTsnqV6NGjeTPf/5zMm3atCK1Y8eOTXr27JlVX7NmzeSTTz4pcf+HHnpoVn2XLl2Sl156KVm5cmWR2lWrViUffPBBcuONNyadOnVK9txzz/XOv6zWnUvTpk2TypUrJxGRdOjQIXnmmWeS5cuXZ9WPGTMm2X333bP6VatWLZk3b16p4yxatKjIOa9WrVpy2223Jd9++21W7bhx45KjjjqqyPm+/PLLi933W2+9lQwZMiR59NFHs+oPPvjgZMiQISX+fPXVVz/u4K3j6KOPLjLfffbZJxk8eHDW506SfP9ZPnHixOTGG29MOnTokLRo0aLE/c6aNavI5+CWW26Z9OvXL1m8eHFW7TvvvJPstddeReZx7733ljr3/v37Z9W3bt068/tvfvObZPz48Vn1K1asSB566KGkVq1aWf2OP/74Yvc/adKkzDHfaqutMvVbbbVVqedn0qRJRfY1evTozLG98847k4kTJyarV68uUrd8+fLk+eefT7p165Y1xyZNmhQ5bsUpfB5L07t372KPX9WqVZNrrrkm+fLLL7Pq58+fn1x++eVJXl5eVr977rlnvfPaEH369Elq1qyZnHbaacnTTz9d4nX/xRdfJLfcckuR6+33v//9esco/J34wzGoWLFicsEFFySffvppVv2SJUuSv/3tb0W+qy+77LISx3j99dezak844YScj0FBQUHSpk2bTN8KFSokn3/+ec79S7NixYqkXr16WXM79thjk/fffz/rvuYHixYtSl5//fXk4osvTrbaaqvkqquuKnHfm/Ne48dc89OnTy+2btWqVclvf/vbrNr69esnI0eOLHHfs2fPTho2bJjVZ4cddkgGDhxY5L27fPny5Iknnki22WabrPpDDz202GOfJN9f54Wvu3POOafI/f0P5s+fn7z00kvJueeem9SuXTvp169fqccGANhw/j0LAAAAAAAA4OdLABhK4P8wAQBlVzio+sPP3/72t1L7nXbaaVn1HTp0yIQHR4wYUWK/pUuXZmp/+HnuuedKrL/xxhuzav/5z3/m9LoKCgqywncVK1YsEkjelEo6roceemiJgeckSZKPP/64SBDk/PPPL7G+oKAg6dSpU1Z9586dSw0Nr1ixItl///2z+jRu3DhZtmxZiX0Kh3J++LnhhhtKPQ7PPPNMkWDOk08+WWqf0pR3APiJJ57IGrtKlSrJ66+/Xmqfq666qthjV1oAeOnSpVnBwYhIDjrooCLBynXNnz+/yLXQpUuXUuf2+OOPZ9Vvs802RYJrxbntttuy+v36178utm7hwoVJxYoVM3Xt27cv9TorrHDYa2Mo7lwccsghydKlS0vss3Tp0qRz585Zfe66665Sx7nggguy6mvXrp188MEHpfYpfK3k5+cnY8aMKbG+8Puhd+/epe5/Y7nvvvuyxs3Ly0tuv/32nPoWFBQkQ4cOLfHvhx9+eNa+mzVrlsyYMaPE+rVr1xYJ3FWrVq1ICHVdhQPAP7yG9QXdRowYkeTn52f6VKpUKZkzZ06pfdYNMJYWfC7JN998U6b/rl27dm1y5plnZr22XIK2PyYMGRFJvXr1klGjRpXa74YbbijT59OGev/995Pvvvsu5/oZM2YkrVq1ysyratWqRUL6hRX3nVilSpVk0KBBpfYrHNpv2LBhqfcE7dq1y9RWrlw5mTt3bk6vaejQoVnjHHbYYTn1y8WgQYOy9n3KKafk3HflypXJZ599VuLfN+e9xo+55osLAC9atCg56KCDsupat26dfPzxx6Xuu/BDRc4+++xSr4kkSZIFCxYke+yxR1a/Z599ttjau+++O6vummuuKXXf61q8eHEya9asnOsBgLLx71kAAAAAAAAAP1/5AQAAm9AJJ5wQF198cak1N9xwQ+Tn/9+t6UcffRQREX//+99j7733LrFftWrV4s9//nPWtv/9738l1p9++ulRqVKlTLtfv36lzusHQ4YMiRkzZmTahx9+eDRq1CinvptK48aN4/HHH896PYW1bds2/vOf/2Rt69+/f3z33XfF1g8ZMiQmTJiQaVerVi1efPHFqFOnToljVKlSJZ599tms4zF79uwYMGBAjq/ke4cffnhcddVVpdYcc8wxcemll2Ztu/POO8s0TpoUnvuNN94Y+++/f6l9brjhhjjooIPKNM6jjz4a33zzTabdpEmTePrpp6NKlSol9qlbt268+OKLUbVq1cy2sWPHxuuvv15sfZIkcd1112Xa1apVi1deeSW22Wab9c7v0ksvjeOOOy7T/u9//xsff/xxkbrp06fHmjVrMu1TTz01a37r0759+5xrN1Tz5s3jiSeeiGrVqpVYU61atbjllluytpX2ubVw4cJ46KGHsrY9+OCDseOOO5Y6lxtuuCF+9atfZdoFBQWpe7+sWbMmbrrppqxtV155ZVxyySU59c/Ly4v99tuv2L9NnTo1Bg0alGnn5+fH008/HS1atChxf/n5+fHQQw9Fp06dMtuWLVsW9957b07z+cHvf//7OPPMM0ut2XvvvbOu+9WrV5f4/tpYGjZsGNtvv33O9fn5+XH33XdnvY/79++/KaaW5cEHH4xddtml1JrLL788tt5660x77NixWZ9zG8vOO+8ctWrVyrm+RYsWWfcWy5cvj8cff7zM495yyy1x6KGHllrzm9/8JnbddddMe86cOTFmzJgS688+++zM76tWrSpyf1CSwvdKZ511Vk79clH4s/7888/PuW/lypWjdevWZRrvp3Cv8fXXX8c+++wTQ4YMyWzbeeed45133om2bduW2G/kyJExePDgTPtXv/pV3HfffaXeJ0ZE1KlTJ5555pmoWbNmZtsdd9xRbO2POV81atSIZs2a5VwPAAAAAAAAAADA9wSAAQDYZPLy8uIvf/nLeuuaNGkSXbt2zdrWokWLOP3009fb94gjjsgKD3/44Ycl1jZq1CiOPPLITHvChAnx3nvvrXeMTRl+2VBXX311VlijJIccckhWqHT58uUxcODAYmsfeOCBrPZFF10UzZs3X+8YtWvXzgp/RkTcf//96+23rltvvTWnuquuuiorjPXuu+9mAuM/JR999FGMHDky027atGn8/ve/z6nv7bffXqaxCp/X66+/PqdAW8uWLePCCy/M2lbSeX3llVdiypQpmfaFF16YU/j3B1dffXXm9yRJ4rnnnitSs3z58qz2+kJN5eGKK66I2rVrr7fuoIMOirp162baH3zwQYm1AwYMiGXLlmXae+65Zxx77LE5zefvf/97VvvJJ58s8QEA5eHZZ5+NWbNmZdqtW7cu8lmyoR588MFIkiTT7tWrV3Tr1m29/SpWrFjkPdavX7+sfZWmatWqRR5MUZITTjghq13adVBeKleunBVU/vDDD4u8Fzembt26xVFHHbXeuooVK8YxxxyTta208OvmdMABB0Tjxo0z7XfeeadM/Zs2bRp9+vTJqbYs19Cpp56a9eCHwt8NxZk/f348++yzmXbjxo3jsMMOy2luudjcn+tpv9eYOnVq7L777ln3soccckgMHz48ttpqq1L73nXXXVntO++8M/Ly8nIat1GjRlkPLXj77beLDdT/FL6HAQAAAAAAAAAAfm4EgAEA2GR22GGHaNeuXU61HTt2zGofffTRUaFChfX2q1GjRrRs2TLTXjdMVpxzzjknq72+VYDnzp0bL774YqbdrFmz6NGjx3rntSlVqlQpTjzxxJzre/fundUePnx4sXUjRozIap922mk5j9GrV6+s1VjHjBmTFVoszc477xzbbbddTrU1atQoEn584403cp5nWhQ+ByeeeGLOQZrOnTtHly5dcqpdsmRJViCsWrVqZbp2Cofw33zzzWLrXn755az2b3/725zHiPj+s2LdVaSLG6dJkyZZ7SeffDJWr15dpnE2pby8vDj++ONzqq1QoULWKrNz586NlStXFltb+PrO5cEIP2jfvn3ssccemfaqVauygufl7dVXX81qn3feeRstUPZjjttBBx2UtbrsN998U+yq1MU58MADY8stt8yptvD7+PPPP895jptTq1atMr+vWbMmJk6cuMnGKhxoLU2aj9+69yWlPZikOMccc0zO74OyHIMtt9wyevbsmWl/9NFH8dZbb5W6/0ceeSTrs+m0006LihUr5jS3XBT+XH/00Uc32r4LS/u9xrvvvht77rlnzJgxI7Otd+/e8dJLL0WNGjVK7VtQUJC1+m+3bt1i2223LdP4Bx98cFY7l+/hTXm+AAAAAAAAAAAA+J4AMAAAm8zOO++cc23hwNROO+20QX0XLVpUau0BBxwQbdu2zbQff/zxWLx4cYn1Dz/8cKxatSrTPv3007NWHC4PO+ywQ9SrVy/n+n333TerPWrUqCI1M2bMyFrtrUWLFmVawbVWrVpZqzivXbs2Ro8evUHzK2t9ca8n7QrP+cceg5K8//77sXbt2kx7l112WW+QaF1t27aNZs2aZdqzZ8+OmTNnFqlbNyhUvXr1aN++fc5j/GDdcYpbabFFixZZ79333nsvevToUebVNTeVli1b5hz8jIho2LBhVruklXkLr1K+7oreuTjggAOy2mkKABcOmB166KEbZb8rV66MsWPHZtqVKlWKvfbaK+f++fn5sd9++2Vty/W4FV7NvjS5XgObwrJly+Lxxx+Pc845J3bbbbdo0qRJ1KxZM/Lz8yMvLy/rp/CDM+bNm7fJ5pXm4zdjxoy47bbb4rjjjosOHTpEgwYNokqVKkWOV15eXrz77ruZfmU9XpvyGJx77rlZ7fU9BGXdv+fl5cUZZ5yR89xysf/++2c97OXOO++M888/P6ZNm7ZRx4lI973G888/HwcccEB8++23mW1XXnll/Pvf/84pcD1hwoSsc1+Wa+gHzZs3z2oX9z180EEHZbUvvvjiuPrqq+Prr78u83gAAAAAAAAAAADkRgAYAIBNpkGDBjnXVqtWbaP0Xb58eam1eXl5cfbZZ2faS5cujYEDB5ZY/8ADD2R+z8/PL9MqkptK4dWS16d58+ZRq1atTHvmzJmRJElWTeFQ5w477FDmeXXu3Dmrvb7VmH9Q1tdTuH769Oll6p8Ghedc1mOw7uqxpdlc53XdoNDSpUuLDRGu72fdwPj8+fOLnct1112X1R46dGjsueee0apVqzj33HNj4MCBxQaUN4fCQbz1qV69ela7uM+uJEmyVvSsVatW1sqiudjQ9+XmsG7Ir3r16tGhQ4eNst+vv/4668EN7du3j8qVK5dpHxt63MpyHeRyDWxsq1evjltvvTUaNWoUvXr1ivvvvz/ee++9mD17dixZsqTId0NxFi5cuMnml8bjN3PmzDjqqKOidevWcfnll8fTTz8dU6ZMiXnz5mVdZyUp6/HalMdgr732iu233z7Tfuqpp0oMDb/77rsxadKkTPuAAw6I1q1b5zy3XDRr1qzIfdW9994b22yzTXTt2jWuuOKKePnll0v8TiiLtN5r3HfffXHsscdmzl1+fn7cfffdcdNNN+W8j8Jh3XvuuafM38HrXhcRxX8P77HHHlkh4DVr1sSNN94YTZs2jb333juuu+66eP3110t9sA4AAAAAAAAAAABlIwAMAMAms8UWW5RL3/U59dRTo0qVKpn2uiHfdb355psxderUTPuQQw4pskJaeSjLKqM/WHfF4IKCgiIrJS9YsCCrXb9+/TKPUbhP4X2WpKyvp3D9pgyjbSqF5/xjj0FJNsd5Xbp0aaxcubLM+y1NSYG0k046Kf76179GXl5e1vYZM2bEv/71rzjppJOiZcuW0bJlyzj77LNj6NChOQUaN4Yf+5lV3Dy/++67KCgoyLQ35L2/oe/LTW3RokWxZs2aTLt+/fpFzuuGKs/Psx9zHWzqa3X58uXRo0ePuOKKK35UQG9jv9/XlbbjN2rUqOjcuXO88MILG7z/XELC69rUx2DdFZ2XL18ejz32WLF1he+NzjrrrA2eV2n++c9/xhFHHFFk+5gxY+LWW2+Nww47LOrXrx877rhj/OlPf8oKJZdFWu81br311qzP+QEDBsT5559fpn2su3LwxlLS9/CAAQNit912y9pWUFAQb731Vlx//fVx4IEHRr169WL33XePG2+8MWbMmLHR5wYAAAAAAAAAAPBLIgAMAMAvTv369ePYY4/NtEePHh3jxo0rUtevX7+s9qYKv5RV4dWSc1F4lcAlS5aU2i5cvyFj5BowK+vrWd9r+SkoPOcfewxyHWdTnNdNEYoqLcR29dVXx7vvvhuHHnpoVKhQodiamTNnRr9+/eKAAw6IHXbYIYYMGbLR57g5lOf7clMrPI8aNWpstH3/nI/bj3H++efH0KFDs7Y1aNAgjjvuuLjhhhvi4Ycfjueeey4GDx4cQ4YMyfxceuml5TTj8vXtt9/GoYceWiQIucMOO0SfPn3izjvvjCeeeCJefPHFePXVV7OO2Yastr65nHLKKVnfOYXvdSK+v96feOKJTLt+/fpx1FFHbZL5bLHFFvHCCy/EgAEDokuXLsXWJEkSY8eOjZtvvjk6duwYhx9+eHz66adlGiet9xrrPpAmIuKRRx4pc8h+U3wPrxtKXlf9+vVjxIgRcc8990SbNm2KrVmzZk2MHDkyrr766thmm23it7/9bXzzzTcbfY4AAAAAAAAAAAC/BBXLewIAAFAezjnnnBgwYECm3a9fv+jbt2+mvXDhwnj66acz7UaNGhW7Ql15WLZsWZn7LF26NKtdOGxXuF24fkPGqFmzZk79yvp61vdafgoKB4uWLVuW8/GKyP38bI7zWjhUVa9evazg2Kaw6667xqBBg2L27Nnx6quvxvDhw2PEiBExbdq0IrUTJ06MQw45JO6444646KKLNum8NrbyfF9uaoXnsTHDdT/n47ahxo4dGw8//HCmXalSpbjtttvi/PPPj8qVK5fa97PPPtvU00ulG2+8MWtl1bZt28ajjz4a3bp1W2/fDXlQx+ZSu3btOOGEE6J///4R8f218f7770fXrl0zNQMGDMh6D/Tu3Xu918mPkZeXF7169YpevXrF5MmTY8iQITF8+PB46623Yt68eUXqBw0aFCNGjIhBgwbF3nvvndMYab3XGDBgQJx99tmZa23QoEHx61//Op5//vmoWrVqTvsofL316tUrTj/99B81ryZNmpT4t0qVKsV5550X5513Xrz//vvx+uuvx/Dhw+Odd96JRYsWZdUWFBTEo48+Gq+99loMHz48tt122x81LwAAAAAAAAAAgF8aAWAAAH6RunfvHh06dIiPPvooIiIee+yxuP322zNhi8ceeyyWL1+eqT/11FOjYsV03D4XF4ZZn/nz52d+z8/Pj1q1amX9vW7dulntdUNPGzqvwvvMtd/6FJ5bnTp1ytQ/DQrPed68eWUKGOZ6fjbHea1Tp05UrFgx1qxZExERy5cvjwMPPLDM42yIxo0bR+/evaN3794REfHVV1/F0KFD4/nnn48XX3wxVq9eHRHfrx558cUXx+677x677bbbZpnbxlC7du3Iz8/PrMS4Od+Xm1qtWrWyrpt58+ZFkiSRl5f3o/ddnp9nafXkk09mrax9/fXXxx/+8Iec+q77/fFLsu6DDLbYYosYPHhwtG7dOqe+aT9m5557biYAHPH9Q1DWDQA/8MADWfVnnXXWZpvbdtttF9ttt11ceOGFkSRJTJkyJV599dV4+umn46233srULV68OHr27BmfffZZTuHctN5r7LTTTjFs2LA48MADY86cORER8eqrr8ahhx4aL730Uk4rmNevXz+rXadOnc32Pdy1a9fo2rVrXH755VFQUBDjxo2LwYMHxxNPPBHjxo3L1H399dfRs2fPGDduXOTn52+WuQEAAAAAAAAAAPwc+H9cAQDwi3XOOedkfl+4cGE89dRTmXa/fv0yv+fl5W3W8Mv6TJw4sUz1M2fOzFqRrUWLFkVCdi1atMhqrxvayFXhPoX3WZKyvp4JEyZktVu1alWm/mlQOERW1mMwfvz4nOo2x3nNy8vL2rZ8+fL46quvyjzOxtCkSZM4+eST4+mnn45PPvkkdtlll8zfkiSJO++8s1zmtaHy8vKiWbNmmfaiRYtixowZZdrHhr4vN4c2bdpkfl+6dGnmgQw/VuPGjbNWK50yZUqsWrWqTPtI83HbECNHjsz8np+fH+eee27OfSdNmrQpppRqs2bNyvoc69GjR87h3+XLl8f06dM31dQ2im7dukWXLl0y7YEDB2ZWvP1hReAfdO/evdxWbc3Ly4sOHTrEhRdeGG+++WaMGDEiK+w6Z86ceOSRR3LaV5rvNTp16hTDhw+Pxo0bZ7YNHz48DjnkkFi8ePF6+xee26effrrR55iL/Pz82HHHHePKK6+MsWPHxjPPPJO1ivHEiRPjlVdeKZe5AQAAAAAAAAAA/FQJAAMA8IvVu3fvrGDCD6Hf0aNHZ4W/9t9//5yDP5vDhAkTyrS64BtvvJHV7tatW5Gali1bxlZbbZVpz5w5M6ZNm5bzGIsXL84KDFWsWDFrNcGyzK+s9cW9nrRbN5ga8eOPQUm6du0aFSpUyLRHjx4dS5YsyXmcTz/9ND7//PNMu3HjxtG8efMidfvtt19We+jQoTmPsam0aNEiBgwYkLVt3dUjfyoKr1hc1mNbuL6kFZALr8i47mqxm8ree++d1X755Zc3yn4rV64cO+64Y6a9atWqMp37JEli+PDhWdvSsHL0uueorOfnm2++yfzeoEGDnFc0LigoKPPn08/BuscrIsoUgH3zzTczq4+n2boh8MWLF8fjjz8eEdkPQInYvKv/rs/ee+8dt9xyS9a2XN/bab/X6NChQ7zxxhux9dZbZ7a9/fbbcdBBB8XChQtL7dutW7eoVq1apv3OO+/EihUrNtVUc3bMMcfExRdfnLXtp/g9DAAAAAAAAAAAUJ4EgAEA+MWqU6dOHH/88Zn2W2+9FVOmTIkHHnggqy5N4ZeIiNWrV2eCOrl4+OGHs9r77LNPsXWFt//73//OeYyBAwfG8uXLM+2uXbtmhVFKM2bMmJg8eXJOtUuWLIlnnnkma1tJryfN9t1336z2448/nnNgbNy4cTF27NicamvUqBE777xzpr1s2bJ48sknc51mPPTQQ1ntko51jx49stp9+/bNeYxNqU2bNlnB9nnz5pXjbDbMj3lfTp06Nd5+++1Mu0qVKrHrrrsWW1u9evWs9rJly3Kf5AYqfN3ce++9Gy04+WOO25AhQ4oE39u1a7dR5vVjrHuOynp+1g0Ml2U15BdffDG++OKLMo31c1A4YF2WY3bPPfds7OlsEieddFLUqFEj0+7Xr18sX74868EJdevWjZ49e5bH9Eq05557ZrVz/Vz/KdxrtG3bNkaMGBEtW7bMbHvvvffigAMOKPXBL5UrV479998/0166dGn0799/U041Zxt6vgAAAAAAAAAAAPieADAAAL9o666AFxFx5513xsCBAzPt+vXrx9FHH725p7VeN9xwQyxevHi9da+88krWCqBVq1aNXr16FVt75plnZrX//ve/5xT8WrRoUVx33XVZ28oamr788stzqrvxxhtj0aJFmfZuu+0WHTp0KNNYabDddttlBTG//PLL+Oc//5lT30svvbRMYxU+r9dcc01OqwDPnDkz/vGPf2RtK+m8HnXUUdGmTZtM+7333ot77723TPPcFFatWpV1veS66mma9OrVKyv4+eabb8bzzz+fU9/CKy8ef/zxUbt27WJra9WqlbVa9PTp08s+2TI68sgjs4Ju06ZNK/JZsqHOOOOMyMvLy7Qfe+yxGDNmzHr7rV27Ni677LKsbYXfQ+WlXr16md+//fbbnL4DftCoUaPM7wsWLMgpCLlkyZIi19AvxbrHKyL3VUtffvnleOGFFzbFlDa6mjVrxm9+85tM+7333os///nPWavNnnzyybHFFluUw+xKVjhAWpbP9Z/CvUarVq1ixIgRWd+pH3zwQey3334xd+7cEvsVvje49tprY9asWZtsnrn6MecLAAAAAAAAAAAAAWAAAH7hdtttt+jcuXOmff/992eFqk455ZSoXLlyeUytVLNnz44TTzyx1NUyP/300zjllFOytvXu3Tvq1KlTbP2BBx4YO+ywQ6a9dOnSOPLII+O7774rcYxVq1bFcccdF7Nnz85sa9y4cZx00kk5vpLvvfTSS3HTTTeVWvPcc8/F7bffnrXtD3/4Q5nGSZPCc7/qqqti2LBhpfb585//HEOGDCnTOL/5zW+yVsH98ssv4/jjjy91RcuFCxfGkUcembXK6I477pi1wuC6KlSoEH/961+ztl144YXRr1+/Ms31448/jrPPPju+/PLLIn8bMGBA3HzzzbFgwYKc93f33XdnrUy97mrIPxV16tSJ008/PWvb6aefHuPHjy+137XXXhuDBg3KtPPz8+Oiiy4qsb5SpUpZq9yOHTs2Pvvssw2cdW4qVKgQV199dda2m2++Oe64446c+idJUuJ7pl27dnH44Ydn2gUFBXHssceW+lCDJEnizDPPjHHjxmW2Va9evciDIsrL9ttvn/k9SZIiK5SWZo899shqX3bZZVFQUFBi/bJly+KYY46JadOmlX2iPwPNmzePpk2bZtqjR4+OJ554otQ+o0aNipNPPnlTT22jKnxtF37vlfVhHmX15z//OR599NFYs2ZNTvVJkhSZY1k+138q9xrNmjWLN954I9q3b5/ZNn78+Nhnn33i66+/LrZP9+7d45BDDsm0586dGwcffHBMmTIl53ELCgri+eefLzEo3adPn/jvf/9bZIXskqxcubLIw01KO18tW7aMvLy8zE9ZVm4HAAAAAAAAAAD4uRIABgDgF++cc84p8W9pWflxXS1atIiI71ca3H333eONN97ICmMsXbo0+vXrF926dYs5c+Zktm+11ValBl/y8vKif//+UalSpcy2Dz74ILp06RLPPPNMVmC0oKAghgwZEl27do1XX301az8PPfRQmVYM/OH1XHXVVXHSSSfF1KlTs/4+e/bsuPzyy+O4446LtWvXZrYffPDBccIJJ6x3/2PGjInXXnutyM/bb79dpLa4utdeey2nlUPL6sQTT4wDDzww0165cmX06NEjrr/++iKr/E2ePDl69uwZN9xwQ0RE1qqp61OtWrUiQdz//e9/0a1btxgyZEhWCHDVqlXxzDPPRJcuXbJCkJUrV15vEOfEE0/Mei+tXr06zj777DjggAPipZdeiqVLlxbps3r16hg3blzcddddsffee0f79u2jX79+xQbb58yZE3/6059i6623jp49e8bAgQNj5syZxc7l448/jgsuuKDI6qWbOsy2qdx4441Z53zBggWxxx57xB133FEkED1x4sQ49thj4y9/+UvW9ksvvTR23HHHUsc5+OCDM7+vXbs2unfvHtdff30899xzMWTIkKz3xLqh/x/jjDPOiJ49e2baSZLEJZdcEvvvv3+8+uqrsXLlyqz6goKCmDRpUtx0003RoUOHOO2000rc9z333JP1wIOZM2fGjjvuGA899FCR63HkyJGx7777FrnO//a3v0WTJk02/AVuROuen4iI8847L373u9/FwIED45VXXsk6P4VX+D355JMjP////iegQYMGxRFHHFGkbsWKFfH0009H586dMw8b+Cmusr4xFH6AximnnBI333xz1sqwERFffPFFXH311dG9e/dYsGBBbLHFFmX6jC5PXbp0iW7duhX7t1133TU6deq0ScefMGFC/Pa3v42mTZvGeeedF4MHD45vv/22SF1BQUG89dZbcfDBB2etgF6tWrWcHziyqe81NrYmTZrE8OHDo2PHjpltH330Ueyzzz4lPsjgP//5TzRr1izTnjp1auy8887xhz/8IcaNG1dscHfBggXx2muvxUUXXRQtW7aMo48+Ot57771i9//222/Hr3/962jVqlVccsklMXz48CLvh4jvv9sHDx4ce+65Z4wePTqzvVGjRlkPZgAAAAAAAAAAAGD9Kpb3BAAAoLydfPLJcdlll8WSJUuytu+1116pDD6dcsopMXLkyBgyZEiMGTMm9t1339hyyy2jRYsWsWLFipg+fXrWqqcREVWqVIlHH3006tatW+q+d9ppp7j77rvj3HPPzQRDZ8yYET179oyaNWtGy5Yto0KFCjFz5sxiV2K9/vrro0ePHmV6Pbfeemv88Y9/jK+++ioGDhwYAwcOjObNm8dWW20VCxYsiGnTphVZqbJFixbx4IMP5rT/iy++ON54442cag866KBit++zzz4xfPjwnPZRFv3794+99torE2RdtWpVXHfddXHDDTdEq1atok6dOjF79uyssE/Tpk3jlltuiRNPPDHncY444oi4+uqrMwHiiIhx48bFwQcfHHXr1o0WLVrE2rVrY8aMGVkrYEd8v3Lsfffdl7U6dEn+3//7f7FgwYJ48sknM9uGDh0aQ4cOjYoVK0aLFi2iXr16sWbNmli4cGF8+eWXpa5EXJxly5bFM888k1n9tE6dOtGoUaOoU6dOrFq1Kj7//PMiAeqI7wPKRx11VJnGSouaNWvGU089FQcffHDmfbd06dK45JJL4sorr4xWrVpFrVq1Yvbs2cWuntyjR48igeDinH/++fGvf/0rVqxYERERX331VVx33XXF1vbv3z9OPfXUDX5N63rwwQdj7ty5We/TYcOGxbBhw6JatWrRrFmzqFOnTixevDhmzZqV9Vn9Q6ivOFtvvXU8+uijceyxx2aCxPPmzYszzjgjLrjggmjVqlVUrVo1Pv/886yHJfzg9NNPT83qvxERhx9+eGy77baZ4OKKFSuib9++0bdv3yK1vXv3zgozt2/fPs4999y45557MttefvnlePnll6NZs2bRuHHjWLJkScyYMSNr5e/u3bvHb3/7259seP7HuOSSS+KRRx7JfP6uWrUq/vSnP8U111wT2267bVSvXj3mzp0bM2bMyApW/vOf/4zHHnssZsyYUU4zL5tzzz03Ro0aVWT75jznc+bMifvuuy/uu+++iIho3Lhx1K9fP6pXrx5Lly6N6dOnF7lHi/h+xeJ1V2ouzaa+19gUttpqqxg2bFgcfPDB8eGHH0bE9w+42GeffWLo0KFFPv8aNmwYgwYNisMOOyw+//zziPj+O/Mf//hH/OMf/4jatWtH06ZNo2bNmrFkyZKYP3/+Bj3MYebMmXHHHXfEHXfcEXl5edG0adPYcssto2rVqrFo0aKYNm1a5nvkBxUqVIgHHnggqlatuoFHAwAAAAAAAAAA4JfJCsAAAPzi1axZM3r16lVke1oDT/n5+fHUU0/FXnvtldn27bffxgcffBCTJ08uEv6tWbNmPP3001mrzZbmrLPOioEDB0bNmjWzti9evDgmTJgQY8eOLRL+rVKlSvTt2zeuueaaMr+erbbaKl555ZWsVTZnzZoVo0ePjk8//bRIIKdNmzYxdOjQ2Hrrrcs8VtpsvfXW8frrr8c222yTtX3NmjXxySefxOjRo7PCv02aNInBgwfHVlttVeax/vrXv8add94ZlStXztq+YMGCGDt2bEyYMKFI+LdWrVrx1FNPlbrK6roqVaoUTzzxRNx6661FQj5r1qyJzz77LEaPHh0ffvhhTJ8+vdjwb/369csUEFq4cGFMmTIlRo4cGR988EGx4d+zzjorHnnkkZz3mUZdu3aNESNGROvWrbO2r169Oj7++ON4//33iw3/nnrqqfHiiy8WOe/FadeuXTzyyCNRo0aNjTbvXNSqVSteffXVOPPMMyMvLy/rb8uWLYupU6fGe++9F5MnTy42BFiaww47LF555ZVo2LBh1vbly5fH5MmTY8yYMUXCvxUqVIgrr7yyXIN/xalYsWI888wzRT4vcnXnnXcWu/rm559/HqNGjYrJkydnhX/322+/eOGFF6JixV/ms+Pq1asXL774YpHP2zVr1sSkSZNi1KhRMX369Ez4Nz8/P/7+97+n9t6hJCeccELWStkR3983lOUhExvb7NmzY8KECTFy5MiYMGFCkfd91apV47777itTQP+neq9Rv379eP3112OXXXbJbJs2bVp07949PvvssyL1nTp1ijFjxsQhhxxS5G/fffddTJ48Od57772YNGlSieHf5s2b5zy/JEniiy++iHHjxsXIkSNj8uTJRcK/devWjWeeeSYOO+ywnPcLAAAAAAAAAADA9wSAAQAgvl/pcV116tSJ4447rpxms361a9eOoUOHxs033xz169cvtqZy5cpx/PHHx+TJk4sNfZXm+OOPj08//TT69OkT9erVK7GuZs2accopp8SUKVOiT58+ZRpjXR07doyxY8fGmWeeGVWqVCm2pm7dunH55ZfH+PHji4Qgf8q22WabGD9+fFx++eUlrtBcpUqVOOuss2LcuHHRsWPHDR7rD3/4Q3z00Udx8sknlxry3HLLLeN3v/tdfPrpp3HMMceUeZzLLrsspk+fHpdccklOQaJGjRrFySefHM8++2x89dVXxQaczznnnHjhhRfizDPPjDZt2qx3n1WqVImjjz463nzzzbj//vt/FiHGjh07xuTJk+P2228v9T1QsWLFOOCAA+LNN9+M/v37R6VKlXIeo2fPnvHxxx/HLbfcEoccckg0a9YsatSoUSSYu7FVrlw5+vXrFx988EEcc8wxUb169VLrW7RoERdeeGEMHjx4vfveZ5994tNPP40//elPWeG/wrbYYos46qij4sMPP4ybbrqpzK9hc9h+++1j/Pjx0b9//+jZs2e0a9cuateuHRUqVFhv38qVK8cLL7wQd955ZzRq1KjEupYtW0bfvn3jtddeKxIM/aXZcccdY8yYMXHyySeXeIzz8vLioIMOipEjR8ZFF120mWf441WrVi1OOOGErG29evVa73twY+jXr1889NBDceyxx+b0YIt69erFueeeGx999FGcc845ZR7vp3qvUbdu3Xjttddijz32yGybNWtW7LPPPpkVwdfVoEGDGDx4cIwYMSKOOOKI9Z7LvLy82HHHHeOKK66I8ePHx3/+859i6/773/9G375947DDDsvps6FJkyZx6aWXxscffxxHHnnkeusBAAAAAAAAAAAoKi/5YakSIMukSZOywhUTJ06M7bffvhxnBABsSg899FCcccYZmXafPn2ib9++5Tij/zN8+PDYb7/9Mu1rr702rrvuukx7zZo18e6778aECRNiwYIFUatWrdh6661jv/322yjhrbVr18aoUaPik08+iTlz5kRBQUE0aNAgWrduHXvssUeZwoUREdddd11cf/31mfawYcNi3333zbQXLVoUb775ZnzyySexdOnSqF+/frRu3Tr23XffMo/1U7Nq1ap44403Ytq0aTFv3ryoXr16tG3bNrp3715kReaNMdY777wT06dPj7lz50Z+fn40bNgw2rVrF926dYv8/I33vKhPP/00xo4dG3Pnzo0FCxZExYoVo3bt2tG8efPo0KFDtGzZssz7nDt3bkyePDmmTZsW8+fPj2XLlkW1atWibt260b59++jcufNmCbCVpylTpsSHH34Yc+bMiWXLlsWWW24ZTZs2jb322itq165d3tP7UVauXBnvvvtuzJw5M+bOnRurVq2KmjVrRvPmzaNjx44bvApuRMTYsWNj0qRJMWfOnFi5cmU0aNAgmjVrFnvttVdUq1ZtI76K9FqzZk2MHj06xo8fH99++21UqFAhGjVqFF26dInOnTuX9/RSaf78+TFixIiYOXNmLF68OKpXrx6tWrWKPfbYo8gK0z813bt3jzfffDPTHj16dHTt2nWzz2P69OkxderUmDlzZnz33XexatWqqFGjRjRo0CA6deoU2223Xc4Pc3Cv8X9Wr16dWbF63rx5sXTp0qhevXrUrVs32rVrF9ttt12ZvzOSJImPP/44Pvnkk5g1a1YsWrQo1q5dGzVr1oxGjRrFDjvsEO3atduo9xIAQMn8exYAAAAAAADAz5cAMJTA/2ECAH5Z9thjj3j33Xcz7bFjx6YmBLW+APBPzfpCOQDA5jF16tRo3759pt2lS5f48MMPy3FGG4d7DQDgl8S/ZwEAAAAAAAD8fFmGAQCAX7zx48dnhX933XXX1IR/AQA2lfvvvz+rfc4555TTTAAAAAAAAAAAAIDCBIABAPjFu+2227Laffr0KaeZAABsHvPnz49+/fpl2rVq1YqTTz65HGcEAAAAAAAAAAAArEsAGACAX7Rhw4bFgAEDMu2mTZvG8ccfX44zAgDY9P74xz/G4sWLM+2zzz47atSoUY4zAgAAAAAAAAAAANZVsbwnAAAAm8uCBQtizJgxEfH9qndvv/123H///ZEkSabmqquuiipVqpTXFAEANrrJkyfHV199FQUFBfH555/Ho48+GsOHD8/8vUaNGnHZZZeV3wQBAAAAAAAAAACAIgSAAQD4xRg3blwcdNBBJf591113jXPOOadM+1w3VLwxbb/99tG4ceONvl8A4Jfntttui4cffrjEv99yyy3RoEGDzTgjAAAAAAAAAAAAYH0EgAEAICLatGkTzzzzTOTn55ep3/pCxRuqf//+ceqpp270/QIArOu8886LPn36lPc0AAAAAAAAAAAAgEIEgAEA+MWqUaNGbLvttnHMMcfE73//+6hRo0Z5TwkAYJOqUKFCbLnlltGtW7c499xz47DDDivvKQEAAAAAAAAAAADFyEuSJCnvSUAaTZo0KTp27JhpT5w4MbbffvtynBEAkEbDhw+P/fbbb6Pv1wrAAAAAAKyPf88CAAAAAAAA+PmyAjAAAPwI++67b3imDgAAAAAAAAAAAAAAsDHll/cEAAAAAAAAAAAAAAAAAACA/yMADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAAAAKSIADAAAAAAAAAAAAAAAAMD/b9+ObROIoigKri1LpDRAEzRAC7RMH2S/AdKN1hkILEsOkP6xNJO97OZPB4AQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABDyNXsAVK3r+nRfr9dJSwAAAAAAAOCn1//V638LAAAAAAAAgP9LAAy/GGM83efzec4QAAAAAAAA+IMxxnI8HmfPAAAAAAAAAOANPmcPAAAAAAAAAAAAAAAAAAAAHgTAAAAAAAAAAAAAAAAAAAAQ8rFt2zZ7BBTdbrflcrnc78PhsOx2u4mLAAAAAAAA4GFd12WMcb9Pp9Oy3+/nDQIAAAAAAADgbQTAAAAAAAAAAAAAAAAAAAAQ8jl7AAAAAAAAAAAAAAAAAAAA8CAABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAIAQATAAAAAAAAAAAAAAAAAAAIQIgAEAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAAAIQJgAAAAAAAAAAAAAAAAAAAIEQADAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAAAAEIEwAAAAAAAAAAAAAAAAAAAECIABgAAAAAAAAAAAAAAAACAEAEwAAAAAAAAAAAAAAAAAACECIABAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAAAACECYAAAAAAAAAAAAAAAAAAACBEAAwAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAABCBMAAAAAAAAAAAAAAAAAAABAiAAYAAAAAAAAAAAAAAAAAgBABMAAAAAAAAAAAAAAAAAAAhAiAAQAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAAAhAmAAAAAAAAAAAAAAAAAAAAgRAAMAAAAAAAAAAAAAAAAAQIgAGAAAAAAAAAAAAAAAAAAAQgTAAAAAAAAAAAAAAAAAAAAQ8g2UiEYx3142YgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": { - "image/png": { - "height": 700 - } - } - } - ] + "execution_count": null, + "outputs": [] } ] } \ No newline at end of file From 1574873688c54de32ad777c649205bba3d20c745 Mon Sep 17 00:00:00 2001 From: olimaol Date: Tue, 18 Jun 2024 11:19:37 +0200 Subject: [PATCH 4/7] SimulationEvents: "run" no longer needs to be called at time 0 --- src/CompNeuroPy/simulation_functions.py | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/CompNeuroPy/simulation_functions.py b/src/CompNeuroPy/simulation_functions.py index a674150..5c7a70d 100644 --- a/src/CompNeuroPy/simulation_functions.py +++ b/src/CompNeuroPy/simulation_functions.py @@ -285,6 +285,11 @@ class SimulationEvents: SimulationEvents. Do never simulate within the effect functions of the events. The simulation is done between the events. + !!! warning + The onset of events and trigger times should be given in simulation steps (not + in ms). The 'end' event has to be triggered to end the simulation (otherwise + it will be triggered right at the beginning). + Example: ```python from CompNeuroPy import SimulationEvents @@ -433,9 +438,15 @@ def run(self): Run the simulation. The simulation runs until the end event is triggered. The simulation can be run multiple times by calling this function multiple times. """ + ### for all events with given onset, change onset to current step + onset + ### (otherwise run would need to be called at time 0) + for event in self.event_list: + if event.onset is not None: + event.onset = get_current_step() + event.onset + ### check if there are events which have no onset and are not triggered by other ### events and have no model_trigger --> they would never start - ### --> set their onset to current step --> they ar run directly after calling run + ### --> set their onset to current step --> they are run directly after calling run triggered_events = [] for event in self.event_list: if event.trigger is not None: From e77aa2d98ceb1aa3ef2dec5dc51da8239db3c586 Mon Sep 17 00:00:00 2001 From: olimaol Date: Tue, 18 Jun 2024 14:16:52 +0200 Subject: [PATCH 5/7] imulation_functions: the attr and current simulation functions now return the attr/current values for each time step as arrays --- src/CompNeuroPy/simulation_functions.py | 69 +++++++++++++++++++------ 1 file changed, 52 insertions(+), 17 deletions(-) diff --git a/src/CompNeuroPy/simulation_functions.py b/src/CompNeuroPy/simulation_functions.py index 5c7a70d..96c0546 100644 --- a/src/CompNeuroPy/simulation_functions.py +++ b/src/CompNeuroPy/simulation_functions.py @@ -24,6 +24,11 @@ def attr_sim(pop: str, attr_dict, t=500): dictionary containing the attributes and their values t (int): duration in ms + + Returns: + attr_list_dict (dict): + dictionary containing the attribute values for each time step, keys are the + attribute names """ ### save prev attr @@ -42,6 +47,10 @@ def attr_sim(pop: str, attr_dict, t=500): for attr, v in v_prev_dict.items(): setattr(get_population(pop), attr, v) + ### return the values for the attribute for each time step + attr_list_dict = {attr: [v] * int(round(t / dt())) for attr, v in attr_dict.items()} + return attr_list_dict + def attribute_step(pop: str, attr, t1=500, t2=500, v1=0, v2=100): """ @@ -66,16 +75,18 @@ def attribute_step(pop: str, attr, t1=500, t2=500, v1=0, v2=100): dictionary containing: - duration (int): duration of the simulation + - v_arr (np.array): array of attribute values for each time step """ - + v_list = [] ### first/pre step simulation - attr_sim(pop, {attr: v1}, t=t1) - + attr_list_dict = attr_sim(pop, {attr: v1}, t=t1) + v_list.extend(attr_list_dict[attr]) ### second/post step simulation - attr_sim(pop, {attr: v2}, t=t2) + attr_list_dict = attr_sim(pop, {attr: v2}, t=t2) + v_list.extend(attr_list_dict[attr]) - ### return duration of the simulation - return {"duration": t1 + t2} + ### return duration of the simulation and the attribute values + return {"duration": t1 + t2, "v_arr": np.array(v_list)} def attr_ramp(pop: str, attr, v0, v1, dur, n): @@ -107,6 +118,7 @@ def attr_ramp(pop: str, attr, v0, v1, dur, n): - dv (int): step size of attribute - dur_stim (int): duration of single steps + - v_arr (np.array): array of attribute values for each time step Raises: ValueError: if resulting duration of one stimulation is not divisible by the @@ -125,11 +137,13 @@ def attr_ramp(pop: str, attr, v0, v1, dur, n): dv = (v1 - v0) / (n - 1) # for n stimulations only n-1 steps occur dur_stim = dur / n v = v0 + v_list = [] for _ in range(n): - attr_sim(pop, attr_dict={attr: v}, t=dur_stim) + attr_list_dict = attr_sim(pop, attr_dict={attr: v}, t=dur_stim) + v_list.extend(attr_list_dict[attr]) v = v + dv - return {"dv": dv, "dur_stim": dur_stim} + return {"dv": dv, "dur_stim": dur_stim, "v_arr": np.array(v_list)} def increasing_attr(pop: str, attr, v0, dv, nr_steps, dur_step): @@ -155,15 +169,18 @@ def increasing_attr(pop: str, attr, v0, dv, nr_steps, dur_step): dictionary containing: - attr_list (list): list of attribute values for each step simulation + - v_arr (np.array): array of attribute values for each time step """ attr_list = [] v = v0 + v_list = [] for _ in range(nr_steps): attr_list.append(v) - attr_sim(pop, {attr: v}, t=dur_step) + attr_list_dict = attr_sim(pop, {attr: v}, t=dur_step) + v_list.extend(attr_list_dict[attr]) v += dv - return {"attr_list": attr_list} + return {"attr_list": attr_list, "v_arr": np.array(v_list)} def current_step(pop: str, t1=500, t2=500, a1=0, a2=100): @@ -188,8 +205,13 @@ def current_step(pop: str, t1=500, t2=500, a1=0, a2=100): dictionary containing: - duration (int): duration of the simulation + - current_arr (np.array): array of current values for each time step """ - return attribute_step(pop, "I_app", t1=t1, t2=t2, v1=a1, v2=a2) + attribute_step_ret = attribute_step(pop, "I_app", t1=t1, t2=t2, v1=a1, v2=a2) + return { + "duration": attribute_step_ret["duration"], + "current_arr": attribute_step_ret["v_arr"], + } def current_stim(pop: str, t=500, a=100): @@ -206,8 +228,13 @@ def current_stim(pop: str, t=500, a=100): duration in ms a (int): current amplitude + + Returns: + current_arr (np.array): + array of current values for each time step """ - attr_sim(pop, {"I_app": a}, t=t) + attr_list_dict = attr_sim(pop, {"I_app": a}, t=t) + return np.array(attr_list_dict["I_app"]) def current_ramp(pop: str, a0, a1, dur, n): @@ -239,13 +266,18 @@ def current_ramp(pop: str, a0, a1, dur, n): - da (int): current step size - dur_stim (int): duration of one stimulation + - current_arr (np.array): array of current values for each time step Raises: ValueError: if resulting duration of one stimulation is not divisible by the simulation time step without remainder """ attr_ramp_return = attr_ramp(pop, "I_app", a0, a1, dur, n) - return {"da": attr_ramp_return["dv"], "dur_stim": attr_ramp_return["dur_stim"]} + return { + "da": attr_ramp_return["dv"], + "dur_stim": attr_ramp_return["dur_stim"], + "current_arr": attr_ramp_return["v_arr"], + } def increasing_current(pop: str, a0, da, nr_steps, dur_step): @@ -272,9 +304,13 @@ def increasing_current(pop: str, a0, da, nr_steps, dur_step): dictionary containing: - current_list (list): list of current amplitudes for each stimulation + - current_arr (np.array): array of current values for each time step """ increasing_attr_return = increasing_attr(pop, "I_app", a0, da, nr_steps, dur_step) - return {"current_list": increasing_attr_return["attr_list"]} + return { + "current_list": increasing_attr_return["attr_list"], + "current_arr": increasing_attr_return["v_arr"], + } class SimulationEvents: @@ -534,9 +570,8 @@ def _run_model_trigger_events(self): """ ### loop to check if model trigger got active for model_trigger in self.model_trigger_list: - if ( - int(get_population(model_trigger).decision[0]) == -1 - ): ### TODO this is not generalized yet, only works if the model_trigger populations have the variable decision which is set to -1 if the model trigger is active + ### TODO this is not generalized yet, only works if the model_trigger populations have the variable decision which is set to -1 if the model trigger is active + if int(get_population(model_trigger).decision[0]) == -1: ### -1 means got active ### find the events triggerd by the model_trigger and run them for event in self.event_list: From d9d8091f71252b937fffc95daf2183b81b2b57a5 Mon Sep 17 00:00:00 2001 From: Oliver Maith <73993227+Olimaol@users.noreply.github.com> Date: Tue, 18 Jun 2024 14:19:20 +0200 Subject: [PATCH 6/7] Mit Colab erstellt --- notebooks/experiment_example.ipynb | 345 +++++++++++++++++++++++++++++ 1 file changed, 345 insertions(+) create mode 100644 notebooks/experiment_example.ipynb diff --git a/notebooks/experiment_example.ipynb b/notebooks/experiment_example.ipynb new file mode 100644 index 0000000..a50e0d9 --- /dev/null +++ b/notebooks/experiment_example.ipynb @@ -0,0 +1,345 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true, + "authorship_tag": "ABX9TyMvW7lhxBXG2gi+iXDgU0PT", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Install CompNeuroPy and ANNarchy" + ], + "metadata": { + "id": "MQwRmyFdmUuD" + } + }, + { + "cell_type": "code", + "source": [ + "!pip install CompNeuroPy\n", + "!git clone https://github.com/ANNarchy/ANNarchy && cd ANNarchy && git checkout develop && pip install .\n", + "!rm -rf ANNarchy" + ], + "metadata": { + "collapsed": true, + "id": "VGC0ujzTm-z3" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#Imports and setup ANNarchy timestep" + ], + "metadata": { + "id": "Mcoz2oq76flU" + } + }, + { + "cell_type": "code", + "source": [ + "from IPython.display import Image, display\n", + "from CompNeuroPy import (\n", + " CompNeuroExp,\n", + " CompNeuroMonitors,\n", + " CompNeuroModel,\n", + " current_step,\n", + " current_ramp,\n", + " PlotRecordings,\n", + ")\n", + "from CompNeuroPy.full_models import HHmodelBischop\n", + "from ANNarchy import dt, setup, get_population\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "setup(dt=0.01)" + ], + "metadata": { + "id": "bMhApHy-6iJ3" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Define the Experiment\n", + "A single run resets the model, sets the leakage potential of population 0 and runs a current ramp and current step." + ], + "metadata": { + "id": "pyf2gSTyN80I" + } + }, + { + "cell_type": "code", + "source": [ + "class MyExp(CompNeuroExp):\n", + "\n", + " def run(self, model: CompNeuroModel, E_L: float):\n", + " # PREPARE RUN\n", + " self.reset()\n", + " self.monitors.start()\n", + " # SET E_L PARAMETER\n", + " get_population(model.populations[0]).E_L = E_L\n", + " # SIMULATION\n", + " ret_current_ramp = current_ramp(pop=model.populations[0], a0=0, a1=100, dur=1000, n=50)\n", + " self.reset(parameters=False)\n", + " ret_current_step = current_step(pop=model.populations[0], t1=500, t2=500, a1=0, a2=50)\n", + " # OPTIONAL DATA OF RUN\n", + " self.data[\"population_name\"] = model.populations[0]\n", + " self.data[\"time_step\"] = dt()\n", + " self.data[\"current_arr\"] = np.concatenate([ret_current_ramp[\"current_arr\"], ret_current_step[\"current_arr\"]])\n", + " # RETURN RESULTS\n", + " return self.results()" + ], + "metadata": { + "id": "8coZOl3oOc1B" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Create/Compile Model\n", + "The model is a single population (consisting of 1 neuron) of a Hodgkin & Huxley neuron. The `HHmodelBischop` class is a child of the `CompNeuroModel` class with a predefined model creation function." + ], + "metadata": { + "id": "XCbqszREO0U2" + } + }, + { + "cell_type": "code", + "source": [ + "model = HHmodelBischop()\n", + "model.populations" + ], + "metadata": { + "id": "gHmfSnNlO2WP" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Initialize the experiment\n", + "Recording the membrane potential of the models first population." + ], + "metadata": { + "id": "EQL2vn40PA_O" + } + }, + { + "cell_type": "code", + "source": [ + "my_exp = MyExp(monitors=CompNeuroMonitors({model.populations[0]: [\"v\"]}))" + ], + "metadata": { + "id": "I6SphV4qPHTU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Set the \"reset-state\" for the experiment\n", + "Set the membrane potential of the model to -90 mV." + ], + "metadata": { + "id": "bJn_adfcPRz5" + } + }, + { + "cell_type": "code", + "source": [ + "print(f\"Compilation state v = {get_population(model.populations[0]).v}\")\n", + "get_population(model.populations[0]).v = -90.0\n", + "print(f\"Changed state v = {get_population(model.populations[0]).v}\")\n", + "my_exp.store_model_state(compartment_list=model.populations)" + ], + "metadata": { + "id": "wyE8p0SmPZ0c" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Run the experiment twice with different leakage potentials" + ], + "metadata": { + "id": "QOuRAfGhPeyT" + } + }, + { + "cell_type": "code", + "source": [ + "results_run1: CompNeuroExp._ResultsCl = my_exp.run(model=model, E_L=-68.0)\n", + "results_run2: CompNeuroExp._ResultsCl = my_exp.run(model=model, E_L=-90.0)" + ], + "metadata": { + "id": "PKqJScoJPf7q" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# PlotRecordings\n", + "This allows to easily get overview plots of the recordings of a single recording chunk." + ], + "metadata": { + "id": "Xg_52O9uPkgd" + } + }, + { + "cell_type": "code", + "source": [ + "for chunk in [0,1]:\n", + " PlotRecordings(\n", + " figname=f\"example_experiment_chunk_{chunk}.png\",\n", + " recordings=results_run1.recordings,\n", + " recording_times=results_run1.recording_times,\n", + " chunk=chunk,\n", + " shape=(1, 1),\n", + " plan={\n", + " \"position\": [1],\n", + " \"compartment\": [results_run1.data[\"population_name\"]],\n", + " \"variable\": [\"v\"],\n", + " \"format\": [\"line\"],\n", + " },\n", + " )" + ], + "metadata": { + "id": "ftBPfNZgPmok" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "display(Image(filename='example_experiment_chunk_0.png', height=700))" + ], + "metadata": { + "id": "o8Lvap-8QFIL" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "display(Image(filename='example_experiment_chunk_1.png', height=700))" + ], + "metadata": { + "id": "p4-rWESeQJkm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Get Data and Time Arrays\n", + "Each experiment run created 2 recording chunks. They all start at time 0 (because of resetting the model, see above). The function combine_chunks() can be used to combine the chunks into a single recording time and value array." + ], + "metadata": { + "id": "OkEO6pyePzmT" + } + }, + { + "cell_type": "code", + "source": [ + "time_arr1, data_arr1 = results_run1.recording_times.combine_chunks(\n", + " recordings=results_run1.recordings,\n", + " recording_data_str=f\"{results_run1.data['population_name']};v\",\n", + " mode=\"consecutive\",\n", + ")\n", + "time_arr2, data_arr2 = results_run2.recording_times.combine_chunks(\n", + " recordings=results_run2.recordings,\n", + " recording_data_str=f\"{results_run2.data['population_name']};v\",\n", + " mode=\"consecutive\",\n", + ")\n", + "current_arr = results_run1.data[\"current_arr\"]" + ], + "metadata": { + "id": "SoiA-7cMP2bj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Plot Data of Both Runs" + ], + "metadata": { + "id": "mUso4pycQTLf" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure()\n", + "plt.subplot(211)\n", + "plt.plot(time_arr1, data_arr1, label=\"E_L = -68.0\")\n", + "plt.plot(time_arr2, data_arr2, label=\"E_L = -90.0\")\n", + "plt.plot(\n", + " [time_arr1[0], time_arr1[-1]], [-90, -90], ls=\"dotted\", label=\"initial v = -90.0\"\n", + ")\n", + "plt.legend()\n", + "plt.ylabel(\"Membrane potential [mV]\")\n", + "plt.subplot(212)\n", + "plt.plot(time_arr1, current_arr, \"k--\")\n", + "plt.ylabel(\"Input current\")\n", + "plt.xlabel(\"Time [ms]\")\n", + "plt.tight_layout()\n", + "plt.savefig(\"example_experiment_combined.png\")" + ], + "metadata": { + "id": "61hXVuUDQYJ2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "display(Image(filename='example_experiment_chunk_1.png', height=700))" + ], + "metadata": { + "id": "aMVQLAi-QcFG" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 433ee43060ca9bf8c01d2a0678da64b0896ce943 Mon Sep 17 00:00:00 2001 From: olimaol Date: Tue, 18 Jun 2024 14:23:06 +0200 Subject: [PATCH 7/7] removed not used notebooks --- notebooks/placeholder | 0 notebooks/test_example.ipynb | 319 ----------------------------------- 2 files changed, 319 deletions(-) delete mode 100644 notebooks/placeholder delete mode 100644 notebooks/test_example.ipynb diff --git a/notebooks/placeholder b/notebooks/placeholder deleted file mode 100644 index e69de29..0000000 diff --git a/notebooks/test_example.ipynb b/notebooks/test_example.ipynb deleted file mode 100644 index 902f823..0000000 --- a/notebooks/test_example.ipynb +++ /dev/null @@ -1,319 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [], - "toc_visible": true, - "authorship_tag": "ABX9TyOZMLYfTMYkRkseiKuZBo6p", - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "source": [ - "#Install CompNeuroPy and ANNarchy" - ], - "metadata": { - "id": "MQwRmyFdmUuD" - } - }, - { - "cell_type": "code", - "source": [ - "!pip install CompNeuroPy\n", - "!git clone https://github.com/ANNarchy/ANNarchy && cd ANNarchy && git checkout develop && pip install .\n", - "!rm -rf ANNarchy" - ], - "metadata": { - "collapsed": true, - "id": "VGC0ujzTm-z3" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "#Import packages" - ], - "metadata": { - "id": "Mcoz2oq76flU" - } - }, - { - "cell_type": "code", - "source": [ - "from IPython.display import Image, display" - ], - "metadata": { - "id": "bMhApHy-6iJ3" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "#Run Code" - ], - "metadata": { - "id": "O7uDvr2W7UZ_" - } - }, - { - "cell_type": "code", - "source": [ - "from ANNarchy import Population, setup, simulate, compile\n", - "from CompNeuroPy import (\n", - " CompNeuroMonitors,\n", - " PlotRecordings,\n", - ")\n", - "from CompNeuroPy.neuron_models import Izhikevich2007\n", - "\n", - "\n", - "### setup ANNarchy timestep and create results folder\n", - "setup(dt=0.1)\n", - "\n", - "### first we create two populations, each consist of 1 neuron\n", - "Population(1, neuron=Izhikevich2007(I_app=0), name=\"my_pop1\")\n", - "Population(1, neuron=Izhikevich2007(I_app=52), name=\"my_pop2\")\n", - "\n", - "### compile\n", - "compile()\n", - "\n", - "### after compilation we can define the monitors using the monitor_dictionary\n", - "### and the CompNeuroMonitors class\n", - "### for my_pop1 we use a recording period of 2 ms\n", - "### for my_pop2 we do not give a recording preiod, therefore record every timestep\n", - "monitor_dictionary = {\"my_pop1;2\": [\"v\", \"spike\"], \"my_pop2\": [\"v\"]}\n", - "mon = CompNeuroMonitors(monitor_dictionary)\n", - "\n", - "### In this part we demonstrate starting/pausing all monitors\n", - "### simulate for 100 ms [0, 100]\n", - "simulate(100)\n", - "\n", - "### start all monitors and simulate for 100 ms [100, 200]\n", - "mon.start()\n", - "simulate(100)\n", - "\n", - "### pause all monitors and simulate for 100 ms [200, 300]\n", - "mon.pause()\n", - "simulate(100)\n", - "\n", - "### In this part we demonstrate starting single monitors\n", - "### start only monitor for my_pop1 and simulate for 100 ms [300, 400]\n", - "mon.start(compartment_list=[\"my_pop1\"])\n", - "simulate(100)\n", - "\n", - "### start all monitors and simulate for 100 ms [400, 500]\n", - "mon.start()\n", - "simulate(100)\n", - "\n", - "### In this part we demonstrate pausing single monitors\n", - "### pause monitor for my_pop1 and simulate for 100 ms [500, 600]\n", - "mon.pause(compartment_list=[\"my_pop1\"])\n", - "simulate(100)\n", - "\n", - "### start all monitors and simulate for 100 ms [600, 700]\n", - "mon.start()\n", - "simulate(100)\n", - "\n", - "### In this part we demonstrate chunking recordings by reset\n", - "### reset WITHOUT model, creating new chunk --> first chunk [0, 700]\n", - "### also in this chunk do not record the first 100 ms\n", - "### WITHOUT model --> time continues at 700 ms [700, 800]\n", - "mon.reset(model=False)\n", - "mon.pause()\n", - "simulate(100)\n", - "\n", - "### start all monitors and simulate for 700 ms [800, 1500]\n", - "mon.start()\n", - "simulate(700)\n", - "\n", - "### reset WITH model, creating new chunk --> second chunk [700, 1500]\n", - "### in third chunk time is reset to 0 ms\n", - "### also in this chunk do not record the first 100 ms [0, 100]\n", - "mon.reset(model=True)\n", - "mon.pause()\n", - "simulate(100)\n", - "\n", - "### start all monitors and simulate for 700 ms [100, 800]\n", - "mon.start()\n", - "simulate(700)\n", - "\n", - "### Next we demonstrate getting recordings DURING SIMULATION by using\n", - "### get_recordings_and_clear\n", - "### this also resets the monitors back to their initialized state, i.e. there are no\n", - "### recordings and they are not started yet\n", - "### recordings1 consists of 3 chunks, third chunk [0, 800]\n", - "recordings1, recording_times1 = mon.get_recordings_and_clear()\n", - "\n", - "### Now continue simulation, creating NEW RECORDINGS, monitors are not started yet\n", - "### model was not reset, so time continues at 800 ms\n", - "### simulate for 100 ms [800, 900]\n", - "simulate(100)\n", - "\n", - "### start all monitors and simulate for 100 ms [900, 1000]\n", - "mon.start()\n", - "simulate(100)\n", - "\n", - "### reset monitors and model, creating new chunk --> first chunk [800, 1000]\n", - "### simulate for 100 ms [0, 100]\n", - "mon.reset(model=True)\n", - "simulate(100)\n", - "\n", - "### get recordings using get_recordings_and_clear\n", - "### this time directly start recording again\n", - "### recordings2 consists of 2 chunks, second chunk [0, 100]\n", - "recordings2, recording_times2 = mon.get_recordings_and_clear()\n", - "\n", - "### Now continue simulation, creating NEW RECORDINGS\n", - "### directly start monitors and reset model so time is reset to 0 ms\n", - "### simulate for 100 ms [0, 100]\n", - "mon.start()\n", - "mon.reset(model=True)\n", - "simulate(100)\n", - "\n", - "### get recordings the normal way (simultions are finished)\n", - "### recordings3 consists of 1 chunk [0, 100]\n", - "recordings3 = mon.get_recordings()\n", - "recording_times3 = mon.get_recording_times()\n", - "\n", - "### print the idx and time lims of the recordings and the sizes of the recorded\n", - "### arrays\n", - "print(\"#################### ALL RECORDINGS INFO ####################\")\n", - "recordings_list = [recordings1, recordings2, recordings3]\n", - "for all_times_idx, all_times in enumerate(\n", - " [recording_times1.all(), recording_times2.all(), recording_times3.all()]\n", - "):\n", - " print(f\"recordings{all_times_idx+1}\")\n", - " for chunk in range(len(all_times)):\n", - " print(f\"\\tchunk: {chunk}\")\n", - " for pop_name in [\"my_pop1\", \"my_pop2\"]:\n", - " print(f\"\\t\\tpop_name: {pop_name}\")\n", - " print(\n", - " f\"\\t\\trecording_array_size: {recordings_list[all_times_idx][chunk][f'{pop_name};v'].shape}\"\n", - " )\n", - " for time_point in [\"start\", \"stop\"]:\n", - " print(f\"\\t\\t\\ttime_point: {time_point}\")\n", - " for unit in [\"ms\", \"idx\"]:\n", - " print(f\"\\t\\t\\t\\tunit: {unit}\")\n", - " for period in range(\n", - " len(all_times[chunk][pop_name][time_point][unit])\n", - " ):\n", - " print(\n", - " f\"\\t\\t\\t\\t\\tperiod {period}: {all_times[chunk][pop_name][time_point][unit][period]}\"\n", - " )\n", - "print(\"#############################################################\")\n", - "\n", - "### plot recordings 1 consisting of 3 chunks\n", - "for chunk in range(len(recordings1)):\n", - " ### using plot_recordings which plots the recordings of one chunk\n", - " PlotRecordings(\n", - " figname=f\"monitor_recordings_1_chunk{chunk}.png\",\n", - " recordings=recordings1,\n", - " recording_times=recording_times1,\n", - " shape=(2, 2),\n", - " plan={\n", - " \"position\": [1, 2, 3],\n", - " \"compartment\": [\"my_pop1\", \"my_pop2\", \"my_pop1\"],\n", - " \"variable\": [\"v\", \"v\", \"spike\"],\n", - " \"format\": [\"line\", \"line\", \"raster\"],\n", - " },\n", - " chunk=chunk,\n", - " )\n", - "\n", - "### plot recordings 2 consisting of 2 chunks\n", - "for chunk in range(len(recordings2)):\n", - " ### using plot_recordings which plots the recordings of one chunk\n", - " PlotRecordings(\n", - " figname=f\"monitor_recordings_2_chunk{chunk}.png\",\n", - " recordings=recordings2,\n", - " recording_times=recording_times2,\n", - " shape=(2, 2),\n", - " plan={\n", - " \"position\": [1, 2, 3],\n", - " \"compartment\": [\"my_pop1\", \"my_pop2\", \"my_pop1\"],\n", - " \"variable\": [\"v\", \"v\", \"spike\"],\n", - " \"format\": [\"line\", \"line\", \"raster\"],\n", - " },\n", - " chunk=chunk,\n", - " )\n", - "\n", - "### plot recordings 3 consisting of 1 chunk\n", - "for chunk in range(len(recordings3)):\n", - " ### using plot_recordings which plots the recordings of one chunk\n", - " PlotRecordings(\n", - " figname=f\"monitor_recordings_3_chunk{chunk}.png\",\n", - " recordings=recordings3,\n", - " recording_times=recording_times3,\n", - " shape=(2, 2),\n", - " plan={\n", - " \"position\": [1, 2, 3],\n", - " \"compartment\": [\"my_pop1\", \"my_pop2\", \"my_pop1\"],\n", - " \"variable\": [\"v\", \"v\", \"spike\"],\n", - " \"format\": [\"line\", \"line\", \"raster\"],\n", - " },\n", - " chunk=chunk,\n", - " )\n", - "\n" - ], - "metadata": { - "id": "Jt0QyXKIoqid" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "#Display figures" - ], - "metadata": { - "id": "dk85GsFd5Vw8" - } - }, - { - "cell_type": "code", - "source": [ - "display(Image(filename='monitor_recordings_1_chunk0.png', height=700))" - ], - "metadata": { - "collapsed": true, - "id": "6buxwMbaqKWP" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "display(Image(filename='monitor_recordings_1_chunk1.png', height=700))" - ], - "metadata": { - "id": "QygeB6NLqTJf" - }, - "execution_count": null, - "outputs": [] - } - ] -} \ No newline at end of file