From 841af02fb84bb6e07e1062a15eac828755f62db3 Mon Sep 17 00:00:00 2001 From: Mackenzie Mathis Date: Wed, 26 Feb 2025 11:08:33 -0500 Subject: [PATCH 1/5] Created using Colab --- Demo_hippocampus.ipynb | 1714 +++++++++++++++++++++++++++++++--------- 1 file changed, 1351 insertions(+), 363 deletions(-) diff --git a/Demo_hippocampus.ipynb b/Demo_hippocampus.ipynb index 0318e56..6358490 100644 --- a/Demo_hippocampus.ipynb +++ b/Demo_hippocampus.ipynb @@ -19,10 +19,10 @@ "source": [ "In this notebook, we show how to:\n", "\n", - "- use CEBRA on the hippocampus data (as shown in Fig. 1, 2).\n", + "- use CEBRA on the hippocampus data.\n", "- use the infoNCE loss with CEBRA.\n", "\n", - "More specifically, this is a mega-notebook, containing all the informations presented in [Hypothesis-driven analysis](https://cebra.ai/docs/demo_notebooks/Demo_hypothesis_testing.html), [Consistency](https://cebra.ai/docs/demo_notebooks/Demo_consistency.html), [Decoding](https://cebra.ai/docs/demo_notebooks/Demo_decoding.html) and [Topological data analysis](https://cebra.ai/docs/demo_notebooks/Demo_cohomology.html) into a single demo notebook. We recommand that you go through those individual notebooks instead, as they present some of the most recently implemented helper functions for plotting, saving models, etc." + "More specifically, this is a notebook demonstrating the information presented in [Hypothesis-driven analysis](https://cebra.ai/docs/demo_notebooks/Demo_hypothesis_testing.html), [Consistency](https://cebra.ai/docs/demo_notebooks/Demo_consistency.html), [Decoding](https://cebra.ai/docs/demo_notebooks/Demo_decoding.html) and [Topological data analysis](https://cebra.ai/docs/demo_notebooks/Demo_cohomology.html) into a single demo notebook. We recommend that you go through those individual notebooks too for deeper informtion." ] }, { @@ -39,12 +39,546 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "9da3c2c8", "metadata": { - "id": "9da3c2c8" + "id": "9da3c2c8", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "b2b6abdc-e423-446c-e27f-4a79408a54f2" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting cebra[demos,dev]\n", + " Downloading cebra-0.5.0rc1-py3-none-any.whl.metadata (6.0 kB)\n", + "Requirement already satisfied: joblib in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (1.4.2)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (1.26.4)\n", + "Collecting literate-dataclasses (from cebra[demos,dev])\n", + " Downloading literate_dataclasses-0.0.6-py3-none-any.whl.metadata (2.3 kB)\n", + "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (1.6.1)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (1.13.1)\n", + "Requirement already satisfied: torch>=2.4.0 in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (2.5.1+cu124)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (4.67.1)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (3.10.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (2.32.3)\n", + "Requirement already satisfied: ipykernel in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (6.17.1)\n", + "Collecting jupyter (from cebra[demos,dev])\n", + " Downloading jupyter-1.1.1-py2.py3-none-any.whl.metadata (2.0 kB)\n", + "Requirement already satisfied: nbconvert in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (7.16.6)\n", + "Requirement already satisfied: seaborn in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (0.13.2)\n", + "Collecting pylint (from cebra[demos,dev])\n", + " Downloading pylint-3.3.4-py3-none-any.whl.metadata (12 kB)\n", + "Requirement already satisfied: toml in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (0.10.2)\n", + "Collecting yapf (from cebra[demos,dev])\n", + " Downloading yapf-0.43.0-py3-none-any.whl.metadata (46 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.8/46.8 kB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting black (from cebra[demos,dev])\n", + " Downloading black-25.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl.metadata (81 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m81.3/81.3 kB\u001b[0m \u001b[31m5.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting isort (from cebra[demos,dev])\n", + " Downloading isort-6.0.0-py3-none-any.whl.metadata (11 kB)\n", + "Collecting coverage (from cebra[demos,dev])\n", + " Downloading coverage-7.6.12-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (8.5 kB)\n", + "Requirement already satisfied: pytest in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (8.3.4)\n", + "Collecting pytest-benchmark (from cebra[demos,dev])\n", + " Downloading pytest_benchmark-5.1.0-py3-none-any.whl.metadata (25 kB)\n", + "Collecting pytest-xdist (from cebra[demos,dev])\n", + " Downloading pytest_xdist-3.6.1-py3-none-any.whl.metadata (4.3 kB)\n", + "Collecting pytest-timeout (from cebra[demos,dev])\n", + " Downloading pytest_timeout-2.3.1-py3-none-any.whl.metadata (20 kB)\n", + "Collecting pytest-sphinx (from cebra[demos,dev])\n", + " Downloading pytest_sphinx-0.6.3-py3-none-any.whl.metadata (5.3 kB)\n", + "Requirement already satisfied: tables in /usr/local/lib/python3.11/dist-packages (from cebra[demos,dev]) (3.10.2)\n", + "Collecting licenseheaders (from cebra[demos,dev])\n", + " Downloading licenseheaders-0.8.8-py3-none-any.whl.metadata (7.8 kB)\n", + "Collecting codespell (from cebra[demos,dev])\n", + " Downloading codespell-2.4.1-py3-none-any.whl.metadata (15 kB)\n", + "Collecting cffconvert (from cebra[demos,dev])\n", + " Downloading cffconvert-2.0.0-py3-none-any.whl.metadata (6.9 kB)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch>=2.4.0->cebra[demos,dev]) (3.17.0)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.11/dist-packages (from torch>=2.4.0->cebra[demos,dev]) (4.12.2)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch>=2.4.0->cebra[demos,dev]) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch>=2.4.0->cebra[demos,dev]) (3.1.5)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch>=2.4.0->cebra[demos,dev]) (2024.10.0)\n", + "Collecting nvidia-cuda-nvrtc-cu12==12.4.127 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cuda-runtime-cu12==12.4.127 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cuda-cupti-cu12==12.4.127 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cudnn-cu12==9.1.0.70 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cublas-cu12==12.4.5.8 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cufft-cu12==11.2.1.3 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-curand-cu12==10.3.5.147 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cusolver-cu12==11.6.1.9 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cusparse-cu12==12.3.1.170 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch>=2.4.0->cebra[demos,dev]) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=2.4.0->cebra[demos,dev]) (12.4.127)\n", + "Collecting nvidia-nvjitlink-cu12==12.4.127 (from torch>=2.4.0->cebra[demos,dev])\n", + " Downloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Requirement already satisfied: triton==3.1.0 in /usr/local/lib/python3.11/dist-packages (from torch>=2.4.0->cebra[demos,dev]) (3.1.0)\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch>=2.4.0->cebra[demos,dev]) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch>=2.4.0->cebra[demos,dev]) (1.3.0)\n", + "Requirement already satisfied: click>=8.0.0 in /usr/local/lib/python3.11/dist-packages (from black->cebra[demos,dev]) (8.1.8)\n", + "Collecting mypy-extensions>=0.4.3 (from black->cebra[demos,dev])\n", + " Downloading mypy_extensions-1.0.0-py3-none-any.whl.metadata (1.1 kB)\n", + "Requirement already satisfied: packaging>=22.0 in /usr/local/lib/python3.11/dist-packages (from black->cebra[demos,dev]) (24.2)\n", + "Collecting pathspec>=0.9.0 (from black->cebra[demos,dev])\n", + " Downloading pathspec-0.12.1-py3-none-any.whl.metadata (21 kB)\n", + "Requirement already satisfied: platformdirs>=2 in /usr/local/lib/python3.11/dist-packages (from black->cebra[demos,dev]) (4.3.6)\n", + "Collecting ruamel.yaml>=0.16.0 (from cffconvert->cebra[demos,dev])\n", + " Downloading ruamel.yaml-0.18.10-py3-none-any.whl.metadata (23 kB)\n", + "Collecting pykwalify>=1.6 (from cffconvert->cebra[demos,dev])\n", + " Downloading pykwalify-1.8.0-py2.py3-none-any.whl.metadata (5.3 kB)\n", + "Collecting jsonschema<4,>=3.0 (from cffconvert->cebra[demos,dev])\n", + " Downloading jsonschema-3.2.0-py2.py3-none-any.whl.metadata (7.8 kB)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->cebra[demos,dev]) (3.4.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->cebra[demos,dev]) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->cebra[demos,dev]) (2.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->cebra[demos,dev]) (2025.1.31)\n", + "Requirement already satisfied: debugpy>=1.0 in /usr/local/lib/python3.11/dist-packages (from ipykernel->cebra[demos,dev]) (1.8.0)\n", + "Requirement already satisfied: ipython>=7.23.1 in /usr/local/lib/python3.11/dist-packages (from ipykernel->cebra[demos,dev]) (7.34.0)\n", + "Requirement already satisfied: jupyter-client>=6.1.12 in /usr/local/lib/python3.11/dist-packages (from ipykernel->cebra[demos,dev]) (6.1.12)\n", + "Requirement already satisfied: matplotlib-inline>=0.1 in /usr/local/lib/python3.11/dist-packages (from ipykernel->cebra[demos,dev]) (0.1.7)\n", + "Requirement already satisfied: nest-asyncio in /usr/local/lib/python3.11/dist-packages (from ipykernel->cebra[demos,dev]) (1.6.0)\n", + "Requirement already satisfied: psutil in /usr/local/lib/python3.11/dist-packages (from ipykernel->cebra[demos,dev]) (5.9.5)\n", + "Requirement already satisfied: pyzmq>=17 in /usr/local/lib/python3.11/dist-packages (from ipykernel->cebra[demos,dev]) (24.0.1)\n", + "Requirement already satisfied: tornado>=6.1 in /usr/local/lib/python3.11/dist-packages (from ipykernel->cebra[demos,dev]) (6.4.2)\n", + "Requirement already satisfied: traitlets>=5.1.0 in /usr/local/lib/python3.11/dist-packages (from ipykernel->cebra[demos,dev]) (5.7.1)\n", + "Requirement already satisfied: notebook in /usr/local/lib/python3.11/dist-packages (from jupyter->cebra[demos,dev]) (6.5.5)\n", + "Requirement already satisfied: jupyter-console in /usr/local/lib/python3.11/dist-packages (from jupyter->cebra[demos,dev]) (6.1.0)\n", + "Requirement already satisfied: ipywidgets in /usr/local/lib/python3.11/dist-packages (from jupyter->cebra[demos,dev]) (7.7.1)\n", + "Collecting jupyterlab (from jupyter->cebra[demos,dev])\n", + " Downloading jupyterlab-4.4.0b0-py3-none-any.whl.metadata (16 kB)\n", + "Requirement already satisfied: regex in /usr/local/lib/python3.11/dist-packages (from licenseheaders->cebra[demos,dev]) (2024.11.6)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->cebra[demos,dev]) (1.3.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib->cebra[demos,dev]) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib->cebra[demos,dev]) (4.56.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->cebra[demos,dev]) (1.4.8)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib->cebra[demos,dev]) (11.1.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib->cebra[demos,dev]) (3.2.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib->cebra[demos,dev]) (2.8.2)\n", + "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (4.13.3)\n", + "Requirement already satisfied: bleach!=5.0.0 in /usr/local/lib/python3.11/dist-packages (from bleach[css]!=5.0.0->nbconvert->cebra[demos,dev]) (6.2.0)\n", + "Requirement already satisfied: defusedxml in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (0.7.1)\n", + "Requirement already satisfied: jupyter-core>=4.7 in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (5.7.2)\n", + "Requirement already satisfied: jupyterlab-pygments in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (0.3.0)\n", + "Requirement already satisfied: markupsafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (3.0.2)\n", + "Requirement already satisfied: mistune<4,>=2.0.3 in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (3.1.2)\n", + "Requirement already satisfied: nbclient>=0.5.0 in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (0.10.2)\n", + "Requirement already satisfied: nbformat>=5.7 in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (5.10.4)\n", + "Requirement already satisfied: pandocfilters>=1.4.1 in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (1.5.1)\n", + "Requirement already satisfied: pygments>=2.4.1 in /usr/local/lib/python3.11/dist-packages (from nbconvert->cebra[demos,dev]) (2.18.0)\n", + "Collecting dill>=0.3.6 (from pylint->cebra[demos,dev])\n", + " Downloading dill-0.3.9-py3-none-any.whl.metadata (10 kB)\n", + "Collecting astroid<=3.4.0-dev0,>=3.3.8 (from pylint->cebra[demos,dev])\n", + " Downloading astroid-3.3.8-py3-none-any.whl.metadata (4.5 kB)\n", + "Collecting mccabe<0.8,>=0.6 (from pylint->cebra[demos,dev])\n", + " Downloading mccabe-0.7.0-py2.py3-none-any.whl.metadata (5.0 kB)\n", + "Collecting tomlkit>=0.10.1 (from pylint->cebra[demos,dev])\n", + " Downloading tomlkit-0.13.2-py3-none-any.whl.metadata (2.7 kB)\n", + "Requirement already satisfied: iniconfig in /usr/local/lib/python3.11/dist-packages (from pytest->cebra[demos,dev]) (2.0.0)\n", + "Requirement already satisfied: pluggy<2,>=1.5 in /usr/local/lib/python3.11/dist-packages (from pytest->cebra[demos,dev]) (1.5.0)\n", + "Requirement already satisfied: py-cpuinfo in /usr/local/lib/python3.11/dist-packages (from pytest-benchmark->cebra[demos,dev]) (9.0.0)\n", + "Collecting execnet>=2.1 (from pytest-xdist->cebra[demos,dev])\n", + " Downloading execnet-2.1.1-py3-none-any.whl.metadata (2.9 kB)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn->cebra[demos,dev]) (3.5.0)\n", + "Requirement already satisfied: pandas>=1.2 in /usr/local/lib/python3.11/dist-packages (from seaborn->cebra[demos,dev]) (2.2.2)\n", + "Requirement already satisfied: numexpr>=2.6.2 in /usr/local/lib/python3.11/dist-packages (from tables->cebra[demos,dev]) (2.10.2)\n", + "Requirement already satisfied: blosc2>=2.3.0 in /usr/local/lib/python3.11/dist-packages (from tables->cebra[demos,dev]) (3.1.1)\n", + "Requirement already satisfied: webencodings in /usr/local/lib/python3.11/dist-packages (from bleach!=5.0.0->bleach[css]!=5.0.0->nbconvert->cebra[demos,dev]) (0.5.1)\n", + "Requirement already satisfied: tinycss2<1.5,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from bleach[css]!=5.0.0->nbconvert->cebra[demos,dev]) (1.4.0)\n", + "Requirement already satisfied: ndindex in /usr/local/lib/python3.11/dist-packages (from blosc2>=2.3.0->tables->cebra[demos,dev]) (1.9.2)\n", + "Requirement already satisfied: msgpack in /usr/local/lib/python3.11/dist-packages (from blosc2>=2.3.0->tables->cebra[demos,dev]) (1.1.0)\n", + "Requirement already satisfied: httpx in /usr/local/lib/python3.11/dist-packages (from blosc2>=2.3.0->tables->cebra[demos,dev]) (0.28.1)\n", + "Requirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.11/dist-packages (from ipython>=7.23.1->ipykernel->cebra[demos,dev]) (75.1.0)\n", + "Collecting jedi>=0.16 (from ipython>=7.23.1->ipykernel->cebra[demos,dev])\n", + " Downloading jedi-0.19.2-py2.py3-none-any.whl.metadata (22 kB)\n", + "Requirement already satisfied: decorator in /usr/local/lib/python3.11/dist-packages (from ipython>=7.23.1->ipykernel->cebra[demos,dev]) (4.4.2)\n", + "Requirement already satisfied: pickleshare in /usr/local/lib/python3.11/dist-packages (from ipython>=7.23.1->ipykernel->cebra[demos,dev]) (0.7.5)\n", + "Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /usr/local/lib/python3.11/dist-packages (from ipython>=7.23.1->ipykernel->cebra[demos,dev]) (3.0.50)\n", + "Requirement already satisfied: backcall in /usr/local/lib/python3.11/dist-packages (from ipython>=7.23.1->ipykernel->cebra[demos,dev]) (0.2.0)\n", + "Requirement already satisfied: pexpect>4.3 in /usr/local/lib/python3.11/dist-packages (from ipython>=7.23.1->ipykernel->cebra[demos,dev]) (4.9.0)\n", + "Requirement already satisfied: attrs>=17.4.0 in /usr/local/lib/python3.11/dist-packages (from jsonschema<4,>=3.0->cffconvert->cebra[demos,dev]) (25.1.0)\n", + "Collecting pyrsistent>=0.14.0 (from jsonschema<4,>=3.0->cffconvert->cebra[demos,dev])\n", + " Downloading pyrsistent-0.20.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (27 kB)\n", + "Requirement already satisfied: six>=1.11.0 in /usr/local/lib/python3.11/dist-packages (from jsonschema<4,>=3.0->cffconvert->cebra[demos,dev]) (1.17.0)\n", + "Requirement already satisfied: fastjsonschema>=2.15 in /usr/local/lib/python3.11/dist-packages (from nbformat>=5.7->nbconvert->cebra[demos,dev]) (2.21.1)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.2->seaborn->cebra[demos,dev]) (2025.1)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas>=1.2->seaborn->cebra[demos,dev]) (2025.1)\n", + "Collecting docopt>=0.6.2 (from pykwalify>=1.6->cffconvert->cebra[demos,dev])\n", + " Downloading docopt-0.6.2.tar.gz (25 kB)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting ruamel.yaml.clib>=0.2.7 (from ruamel.yaml>=0.16.0->cffconvert->cebra[demos,dev])\n", + " Downloading ruamel.yaml.clib-0.2.12-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (2.7 kB)\n", + "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.11/dist-packages (from beautifulsoup4->nbconvert->cebra[demos,dev]) (2.6)\n", + "Requirement already satisfied: ipython-genutils~=0.2.0 in /usr/local/lib/python3.11/dist-packages (from ipywidgets->jupyter->cebra[demos,dev]) (0.2.0)\n", + "Requirement already satisfied: widgetsnbextension~=3.6.0 in /usr/local/lib/python3.11/dist-packages (from ipywidgets->jupyter->cebra[demos,dev]) (3.6.10)\n", + "Requirement already satisfied: jupyterlab-widgets>=1.0.0 in /usr/local/lib/python3.11/dist-packages (from ipywidgets->jupyter->cebra[demos,dev]) (3.0.13)\n", + "Collecting async-lru>=1.0.0 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading async_lru-2.0.4-py3-none-any.whl.metadata (4.5 kB)\n", + "Collecting jupyter-lsp>=2.0.0 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_lsp-2.2.5-py3-none-any.whl.metadata (1.8 kB)\n", + "Collecting jupyter-server<3,>=2.4.0 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_server-2.15.0-py3-none-any.whl.metadata (8.4 kB)\n", + "Collecting jupyterlab-server<3,>=2.27.1 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyterlab_server-2.27.3-py3-none-any.whl.metadata (5.9 kB)\n", + "Requirement already satisfied: notebook-shim>=0.2 in /usr/local/lib/python3.11/dist-packages (from jupyterlab->jupyter->cebra[demos,dev]) (0.2.4)\n", + "Requirement already satisfied: argon2-cffi in /usr/local/lib/python3.11/dist-packages (from notebook->jupyter->cebra[demos,dev]) (23.1.0)\n", + "Requirement already satisfied: Send2Trash>=1.8.0 in /usr/local/lib/python3.11/dist-packages (from notebook->jupyter->cebra[demos,dev]) (1.8.3)\n", + "Requirement already satisfied: terminado>=0.8.3 in /usr/local/lib/python3.11/dist-packages (from notebook->jupyter->cebra[demos,dev]) (0.18.1)\n", + "Requirement already satisfied: prometheus-client in /usr/local/lib/python3.11/dist-packages (from notebook->jupyter->cebra[demos,dev]) (0.21.1)\n", + "Requirement already satisfied: nbclassic>=0.4.7 in /usr/local/lib/python3.11/dist-packages (from notebook->jupyter->cebra[demos,dev]) (1.2.0)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.11/dist-packages (from httpx->blosc2>=2.3.0->tables->cebra[demos,dev]) (3.7.1)\n", + "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.11/dist-packages (from httpx->blosc2>=2.3.0->tables->cebra[demos,dev]) (1.0.7)\n", + "Requirement already satisfied: h11<0.15,>=0.13 in /usr/local/lib/python3.11/dist-packages (from httpcore==1.*->httpx->blosc2>=2.3.0->tables->cebra[demos,dev]) (0.14.0)\n", + "Requirement already satisfied: parso<0.9.0,>=0.8.4 in /usr/local/lib/python3.11/dist-packages (from jedi>=0.16->ipython>=7.23.1->ipykernel->cebra[demos,dev]) (0.8.4)\n", + "Collecting jupyter-client>=6.1.12 (from ipykernel->cebra[demos,dev])\n", + " Downloading jupyter_client-7.4.9-py3-none-any.whl.metadata (8.5 kB)\n", + "Collecting jupyter-events>=0.11.0 (from jupyter-server<3,>=2.4.0->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_events-0.12.0-py3-none-any.whl.metadata (5.8 kB)\n", + "Collecting jupyter-server-terminals>=0.4.4 (from jupyter-server<3,>=2.4.0->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_server_terminals-0.5.3-py3-none-any.whl.metadata (5.6 kB)\n", + "Collecting overrides>=5.0 (from jupyter-server<3,>=2.4.0->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading overrides-7.7.0-py3-none-any.whl.metadata (5.8 kB)\n", + "Requirement already satisfied: websocket-client>=1.7 in /usr/local/lib/python3.11/dist-packages (from jupyter-server<3,>=2.4.0->jupyterlab->jupyter->cebra[demos,dev]) (1.8.0)\n", + "Requirement already satisfied: entrypoints in /usr/local/lib/python3.11/dist-packages (from jupyter-client>=6.1.12->ipykernel->cebra[demos,dev]) (0.4)\n", + "Requirement already satisfied: argon2-cffi-bindings in /usr/local/lib/python3.11/dist-packages (from argon2-cffi->notebook->jupyter->cebra[demos,dev]) (21.2.0)\n", + "Requirement already satisfied: babel>=2.10 in /usr/local/lib/python3.11/dist-packages (from jupyterlab-server<3,>=2.27.1->jupyterlab->jupyter->cebra[demos,dev]) (2.17.0)\n", + "Collecting json5>=0.9.0 (from jupyterlab-server<3,>=2.27.1->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading json5-0.10.0-py3-none-any.whl.metadata (34 kB)\n", + "INFO: pip is looking at multiple versions of jupyterlab-server to determine which version is compatible with other requirements. This could take a while.\n", + "Collecting jupyterlab-server<3,>=2.27.1 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyterlab_server-2.27.2-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyterlab_server-2.27.1-py3-none-any.whl.metadata (5.9 kB)\n", + "Collecting jupyter-server<3,>=2.4.0 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_server-2.14.2-py3-none-any.whl.metadata (8.4 kB)\n", + "Collecting notebook (from jupyter->cebra[demos,dev])\n", + " Downloading notebook-7.4.0b0-py3-none-any.whl.metadata (10 kB)\n", + "INFO: pip is still looking at multiple versions of jupyterlab-server to determine which version is compatible with other requirements. This could take a while.\n", + "Collecting jupyterlab (from jupyter->cebra[demos,dev])\n", + " Downloading jupyterlab-4.4.0a3-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.4.0a2-py3-none-any.whl.metadata (16 kB)\n", + "INFO: This is taking longer than usual. You might need to provide the dependency resolver with stricter constraints to reduce runtime. See https://pip.pypa.io/warnings/backtracking for guidance. If you want to abort this run, press Ctrl + C.\n", + " Downloading jupyterlab-4.4.0a1-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.4.0a0-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.5-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.4-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.3-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.2-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.1-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0rc1-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0rc0-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0b3-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0b2-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0b1-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0b0-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0a2-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0a1-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.3.0a0-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.7-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.6-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.5-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.4-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.3-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.2-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.1-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.0-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.0rc0-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.0b3-py3-none-any.whl.metadata (16 kB)\n", + "Collecting jupyterlab-server<3,>=2.19.0 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyterlab_server-2.27.0-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyterlab_server-2.26.0-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyterlab_server-2.25.4-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyterlab_server-2.25.3-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyterlab_server-2.25.2-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyterlab_server-2.25.1-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyterlab_server-2.25.0-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyterlab_server-2.24.0-py3-none-any.whl.metadata (5.8 kB)\n", + " Downloading jupyterlab_server-2.23.0-py3-none-any.whl.metadata (5.8 kB)\n", + " Downloading jupyterlab_server-2.22.1-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyterlab_server-2.22.0-py3-none-any.whl.metadata (6.1 kB)\n", + " Downloading jupyterlab_server-2.21.0-py3-none-any.whl.metadata (6.1 kB)\n", + " Downloading jupyterlab_server-2.20.0-py3-none-any.whl.metadata (6.0 kB)\n", + " Downloading jupyterlab_server-2.19.0-py3-none-any.whl.metadata (6.0 kB)\n", + "Collecting jupyterlab (from jupyter->cebra[demos,dev])\n", + " Downloading jupyterlab-4.2.0b2-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.0b1-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.0b0-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.0a2-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.0a1-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.2.0a0-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.8-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.1.7-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.1.6-py3-none-any.whl.metadata (16 kB)\n", + " Downloading jupyterlab-4.1.5-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.4-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.3-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.2-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.1-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0rc1-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0rc0-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0b2-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0b1-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0b0-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0a4-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0a3-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0a2-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.1.0a1-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.13-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.12-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.11-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.10-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.9-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.8-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.7-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.6-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.5-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.4-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.3-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.2-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.1-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0rc1-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0rc0-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0b2-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0b1-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0b0-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0a36-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0a35-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0a34-py3-none-any.whl.metadata (15 kB)\n", + " Downloading jupyterlab-4.0.0a33-py3-none-any.whl.metadata (16 kB)\n", + "Collecting jupyter-server-ydoc<0.8.0,>=0.7.0 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_server_ydoc-0.7.0-py3-none-any.whl.metadata (5.3 kB)\n", + "Collecting jupyter-ydoc<0.4.0,>=0.3.0 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_ydoc-0.3.4-py3-none-any.whl.metadata (2.9 kB)\n", + "Collecting jupyterlab (from jupyter->cebra[demos,dev])\n", + " Downloading jupyterlab-4.0.0a32-py3-none-any.whl.metadata (16 kB)\n", + "Collecting jupyter-server-ydoc<0.7.0,>=0.6.0 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_server_ydoc-0.6.1-py3-none-any.whl.metadata (5.3 kB)\n", + "Collecting ypy-websocket (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading ypy_websocket-0.12.4-py3-none-any.whl.metadata (5.2 kB)\n", + "Collecting jupyterlab-server<3,>=2.16.0 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyterlab_server-2.18.0-py3-none-any.whl.metadata (6.0 kB)\n", + " Downloading jupyterlab_server-2.17.0-py3-none-any.whl.metadata (6.0 kB)\n", + " Downloading jupyterlab_server-2.16.6-py3-none-any.whl.metadata (6.3 kB)\n", + "Collecting jupyter-server-fileid<1,>=0.6.0 (from jupyter-server-ydoc<0.7.0,>=0.6.0->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_server_fileid-0.9.3-py3-none-any.whl.metadata (4.7 kB)\n", + "Collecting ypy-websocket (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading ypy_websocket-0.8.4-py3-none-any.whl.metadata (2.5 kB)\n", + "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.11/dist-packages (from pexpect>4.3->ipython>=7.23.1->ipykernel->cebra[demos,dev]) (0.7.0)\n", + "Requirement already satisfied: wcwidth in /usr/local/lib/python3.11/dist-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=7.23.1->ipykernel->cebra[demos,dev]) (0.2.13)\n", + "Collecting aiofiles<23,>=22.1.0 (from ypy-websocket->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading aiofiles-22.1.0-py3-none-any.whl.metadata (8.0 kB)\n", + "Collecting aiosqlite<1,>=0.17.0 (from ypy-websocket->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading aiosqlite-0.21.0-py3-none-any.whl.metadata (4.3 kB)\n", + "Collecting y-py<0.7.0,>=0.6.0 (from ypy-websocket->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading y_py-0.6.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (5.6 kB)\n", + "Requirement already satisfied: sniffio>=1.1 in /usr/local/lib/python3.11/dist-packages (from anyio->httpx->blosc2>=2.3.0->tables->cebra[demos,dev]) (1.3.1)\n", + "INFO: pip is looking at multiple versions of jupyter-events to determine which version is compatible with other requirements. This could take a while.\n", + "Collecting jupyter-events>=0.11.0 (from jupyter-server<3,>=2.4.0->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_events-0.11.0-py3-none-any.whl.metadata (5.8 kB)\n", + "Collecting jupyter-events>=0.9.0 (from jupyter-server<3,>=2.4.0->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_events-0.10.0-py3-none-any.whl.metadata (5.9 kB)\n", + " Downloading jupyter_events-0.9.1-py3-none-any.whl.metadata (5.7 kB)\n", + " Downloading jupyter_events-0.9.0-py3-none-any.whl.metadata (5.7 kB)\n", + "Collecting jupyter-server<3,>=2.0.0rc3 (from jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_server-2.14.1-py3-none-any.whl.metadata (8.4 kB)\n", + "INFO: pip is still looking at multiple versions of jupyter-events to determine which version is compatible with other requirements. This could take a while.\n", + " Downloading jupyter_server-2.14.0-py3-none-any.whl.metadata (8.4 kB)\n", + "INFO: This is taking longer than usual. You might need to provide the dependency resolver with stricter constraints to reduce runtime. See https://pip.pypa.io/warnings/backtracking for guidance. If you want to abort this run, press Ctrl + C.\n", + " Downloading jupyter_server-2.13.0-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.12.5-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.12.4-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.12.3-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.12.2-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.12.1-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.12.0-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.11.2-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.11.1-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.10.1-py3-none-any.whl.metadata (8.4 kB)\n", + " Downloading jupyter_server-2.10.0-py3-none-any.whl.metadata (8.4 kB)\n", + "Collecting jupyter-events>=0.6.0 (from jupyter-server<3,>=2.0.0rc3->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading jupyter_events-0.8.0-py3-none-any.whl.metadata (5.7 kB)\n", + " Downloading jupyter_events-0.7.0-py3-none-any.whl.metadata (5.5 kB)\n", + " Downloading jupyter_events-0.6.3-py3-none-any.whl.metadata (6.1 kB)\n", + "Collecting python-json-logger>=2.0.4 (from jupyter-events>=0.6.0->jupyter-server<3,>=2.0.0rc3->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading python_json_logger-3.2.1-py3-none-any.whl.metadata (4.1 kB)\n", + "Requirement already satisfied: pyyaml>=5.3 in /usr/local/lib/python3.11/dist-packages (from jupyter-events>=0.6.0->jupyter-server<3,>=2.0.0rc3->jupyterlab->jupyter->cebra[demos,dev]) (6.0.2)\n", + "Collecting rfc3339-validator (from jupyter-events>=0.6.0->jupyter-server<3,>=2.0.0rc3->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading rfc3339_validator-0.1.4-py2.py3-none-any.whl.metadata (1.5 kB)\n", + "Collecting rfc3986-validator>=0.1.1 (from jupyter-events>=0.6.0->jupyter-server<3,>=2.0.0rc3->jupyterlab->jupyter->cebra[demos,dev])\n", + " Downloading rfc3986_validator-0.1.1-py2.py3-none-any.whl.metadata (1.7 kB)\n", + "Requirement already satisfied: cffi>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from argon2-cffi-bindings->argon2-cffi->notebook->jupyter->cebra[demos,dev]) (1.17.1)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.11/dist-packages (from cffi>=1.0.1->argon2-cffi-bindings->argon2-cffi->notebook->jupyter->cebra[demos,dev]) (2.22)\n", + "Requirement already satisfied: jsonpointer>1.13 in /usr/local/lib/python3.11/dist-packages (from jsonschema[format-nongpl]>=3.2.0->jupyter-events>=0.6.0->jupyter-server<3,>=2.0.0rc3->jupyterlab->jupyter->cebra[demos,dev]) (3.0.0)\n", + "Requirement already satisfied: webcolors in /usr/local/lib/python3.11/dist-packages (from jsonschema[format-nongpl]>=3.2.0->jupyter-events>=0.6.0->jupyter-server<3,>=2.0.0rc3->jupyterlab->jupyter->cebra[demos,dev]) (24.11.1)\n", + "Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl (363.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m3.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (13.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m113.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (24.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m85.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (883 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m58.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl (664.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m1.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl (211.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m8.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl (56.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m38.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl (127.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m17.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl (207.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m92.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading black-25.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl (1.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m87.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading cebra-0.5.0rc1-py3-none-any.whl (204 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m205.0/205.0 kB\u001b[0m \u001b[31m19.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading cffconvert-2.0.0-py3-none-any.whl (183 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m183.5/183.5 kB\u001b[0m \u001b[31m20.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading codespell-2.4.1-py3-none-any.whl (344 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m344.5/344.5 kB\u001b[0m \u001b[31m35.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading coverage-7.6.12-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (241 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m241.0/241.0 kB\u001b[0m \u001b[31m22.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading isort-6.0.0-py3-none-any.whl (94 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m94.1/94.1 kB\u001b[0m \u001b[31m10.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jupyter-1.1.1-py2.py3-none-any.whl (2.7 kB)\n", + "Downloading licenseheaders-0.8.8-py3-none-any.whl (21 kB)\n", + "Downloading literate_dataclasses-0.0.6-py3-none-any.whl (5.0 kB)\n", + "Downloading pylint-3.3.4-py3-none-any.whl (522 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m522.3/522.3 kB\u001b[0m \u001b[31m45.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pytest_benchmark-5.1.0-py3-none-any.whl (44 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m44.3/44.3 kB\u001b[0m \u001b[31m4.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pytest_sphinx-0.6.3-py3-none-any.whl (10 kB)\n", + "Downloading pytest_timeout-2.3.1-py3-none-any.whl (14 kB)\n", + "Downloading pytest_xdist-3.6.1-py3-none-any.whl (46 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.1/46.1 kB\u001b[0m \u001b[31m5.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading yapf-0.43.0-py3-none-any.whl (256 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m256.2/256.2 kB\u001b[0m \u001b[31m23.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading astroid-3.3.8-py3-none-any.whl (275 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m275.2/275.2 kB\u001b[0m \u001b[31m28.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading dill-0.3.9-py3-none-any.whl (119 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m119.4/119.4 kB\u001b[0m \u001b[31m12.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading execnet-2.1.1-py3-none-any.whl (40 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m40.6/40.6 kB\u001b[0m \u001b[31m4.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jsonschema-3.2.0-py2.py3-none-any.whl (56 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 kB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading mccabe-0.7.0-py2.py3-none-any.whl (7.3 kB)\n", + "Downloading mypy_extensions-1.0.0-py3-none-any.whl (4.7 kB)\n", + "Downloading pathspec-0.12.1-py3-none-any.whl (31 kB)\n", + "Downloading pykwalify-1.8.0-py2.py3-none-any.whl (24 kB)\n", + "Downloading ruamel.yaml-0.18.10-py3-none-any.whl (117 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m117.7/117.7 kB\u001b[0m \u001b[31m12.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading tomlkit-0.13.2-py3-none-any.whl (37 kB)\n", + "Downloading jupyterlab-4.0.0a32-py3-none-any.whl (8.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m8.4/8.4 MB\u001b[0m \u001b[31m97.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jupyterlab_server-2.16.6-py3-none-any.whl (54 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m54.8/54.8 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading async_lru-2.0.4-py3-none-any.whl (6.1 kB)\n", + "Downloading jedi-0.19.2-py2.py3-none-any.whl (1.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.6/1.6 MB\u001b[0m \u001b[31m82.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jupyter_lsp-2.2.5-py3-none-any.whl (69 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m69.1/69.1 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jupyter_server-2.10.0-py3-none-any.whl (377 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m377.9/377.9 kB\u001b[0m \u001b[31m34.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jupyter_events-0.6.3-py3-none-any.whl (18 kB)\n", + "Downloading jupyter_client-7.4.9-py3-none-any.whl (133 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m133.5/133.5 kB\u001b[0m \u001b[31m12.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jupyter_server_ydoc-0.6.1-py3-none-any.whl (11 kB)\n", + "Downloading pyrsistent-0.20.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (120 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m120.0/120.0 kB\u001b[0m \u001b[31m14.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading ruamel.yaml.clib-0.2.12-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (739 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m739.1/739.1 kB\u001b[0m \u001b[31m58.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading ypy_websocket-0.8.4-py3-none-any.whl (10 kB)\n", + "Downloading aiofiles-22.1.0-py3-none-any.whl (14 kB)\n", + "Downloading aiosqlite-0.21.0-py3-none-any.whl (15 kB)\n", + "Downloading json5-0.10.0-py3-none-any.whl (34 kB)\n", + "Downloading jupyter_server_fileid-0.9.3-py3-none-any.whl (16 kB)\n", + "Downloading jupyter_ydoc-0.3.4-py3-none-any.whl (10 kB)\n", + "Downloading y_py-0.6.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.7/1.7 MB\u001b[0m \u001b[31m86.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jupyter_server_terminals-0.5.3-py3-none-any.whl (13 kB)\n", + "Downloading overrides-7.7.0-py3-none-any.whl (17 kB)\n", + "Downloading python_json_logger-3.2.1-py3-none-any.whl (14 kB)\n", + "Downloading rfc3986_validator-0.1.1-py2.py3-none-any.whl (4.2 kB)\n", + "Downloading rfc3339_validator-0.1.4-py2.py3-none-any.whl (3.5 kB)\n", + "Building wheels for collected packages: docopt\n", + " Building wheel for docopt (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for docopt: filename=docopt-0.6.2-py2.py3-none-any.whl size=13706 sha256=9640f2c97f226fb7e2c1b9f5426d35f802d26a7daa5426acccef71f75a4d20ca\n", + " Stored in directory: /root/.cache/pip/wheels/1a/b0/8c/4b75c4116c31f83c8f9f047231251e13cc74481cca4a78a9ce\n", + "Successfully built docopt\n", + "Installing collected packages: y-py, docopt, yapf, tomlkit, ruamel.yaml.clib, rfc3986-validator, rfc3339-validator, python-json-logger, pyrsistent, pathspec, overrides, nvidia-nvjitlink-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, mypy-extensions, mccabe, literate-dataclasses, licenseheaders, jupyter-ydoc, json5, jedi, isort, execnet, dill, coverage, codespell, async-lru, astroid, aiosqlite, aiofiles, ypy-websocket, ruamel.yaml, pytest-xdist, pytest-timeout, pytest-sphinx, pytest-benchmark, pylint, nvidia-cusparse-cu12, nvidia-cudnn-cu12, jupyter-server-terminals, jupyter-client, jsonschema, black, pykwalify, nvidia-cusolver-cu12, jupyter-events, cffconvert, cebra, jupyter-server, jupyterlab-server, jupyter-server-fileid, jupyter-lsp, jupyter-server-ydoc, jupyterlab, jupyter\n", + " Attempting uninstall: nvidia-nvjitlink-cu12\n", + " Found existing installation: nvidia-nvjitlink-cu12 12.5.82\n", + " Uninstalling nvidia-nvjitlink-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-nvjitlink-cu12-12.5.82\n", + " Attempting uninstall: nvidia-curand-cu12\n", + " Found existing installation: nvidia-curand-cu12 10.3.6.82\n", + " Uninstalling nvidia-curand-cu12-10.3.6.82:\n", + " Successfully uninstalled nvidia-curand-cu12-10.3.6.82\n", + " Attempting uninstall: nvidia-cufft-cu12\n", + " Found existing installation: nvidia-cufft-cu12 11.2.3.61\n", + " Uninstalling nvidia-cufft-cu12-11.2.3.61:\n", + " Successfully uninstalled nvidia-cufft-cu12-11.2.3.61\n", + " Attempting uninstall: nvidia-cuda-runtime-cu12\n", + " Found existing installation: nvidia-cuda-runtime-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-runtime-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-runtime-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cuda-nvrtc-cu12\n", + " Found existing installation: nvidia-cuda-nvrtc-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-nvrtc-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cuda-cupti-cu12\n", + " Found existing installation: nvidia-cuda-cupti-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-cupti-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-cupti-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cublas-cu12\n", + " Found existing installation: nvidia-cublas-cu12 12.5.3.2\n", + " Uninstalling nvidia-cublas-cu12-12.5.3.2:\n", + " Successfully uninstalled nvidia-cublas-cu12-12.5.3.2\n", + " Attempting uninstall: nvidia-cusparse-cu12\n", + " Found existing installation: nvidia-cusparse-cu12 12.5.1.3\n", + " Uninstalling nvidia-cusparse-cu12-12.5.1.3:\n", + " Successfully uninstalled nvidia-cusparse-cu12-12.5.1.3\n", + " Attempting uninstall: nvidia-cudnn-cu12\n", + " Found existing installation: nvidia-cudnn-cu12 9.3.0.75\n", + " Uninstalling nvidia-cudnn-cu12-9.3.0.75:\n", + " Successfully uninstalled nvidia-cudnn-cu12-9.3.0.75\n", + " Attempting uninstall: jupyter-client\n", + " Found existing installation: jupyter-client 6.1.12\n", + " Uninstalling jupyter-client-6.1.12:\n", + " Successfully uninstalled jupyter-client-6.1.12\n", + " Attempting uninstall: jsonschema\n", + " Found existing installation: jsonschema 4.23.0\n", + " Uninstalling jsonschema-4.23.0:\n", + " Successfully uninstalled jsonschema-4.23.0\n", + " Attempting uninstall: nvidia-cusolver-cu12\n", + " Found existing installation: nvidia-cusolver-cu12 11.6.3.83\n", + " Uninstalling nvidia-cusolver-cu12-11.6.3.83:\n", + " Successfully uninstalled nvidia-cusolver-cu12-11.6.3.83\n", + " Attempting uninstall: jupyter-server\n", + " Found existing installation: jupyter-server 1.24.0\n", + " Uninstalling jupyter-server-1.24.0:\n", + " Successfully uninstalled jupyter-server-1.24.0\n", + "Successfully installed aiofiles-22.1.0 aiosqlite-0.21.0 astroid-3.3.8 async-lru-2.0.4 black-25.1.0 cebra-0.5.0rc1 cffconvert-2.0.0 codespell-2.4.1 coverage-7.6.12 dill-0.3.9 docopt-0.6.2 execnet-2.1.1 isort-6.0.0 jedi-0.19.2 json5-0.10.0 jsonschema-3.2.0 jupyter-1.1.1 jupyter-client-7.4.9 jupyter-events-0.6.3 jupyter-lsp-2.2.5 jupyter-server-2.10.0 jupyter-server-fileid-0.9.3 jupyter-server-terminals-0.5.3 jupyter-server-ydoc-0.6.1 jupyter-ydoc-0.3.4 jupyterlab-4.0.0a32 jupyterlab-server-2.16.6 licenseheaders-0.8.8 literate-dataclasses-0.0.6 mccabe-0.7.0 mypy-extensions-1.0.0 nvidia-cublas-cu12-12.4.5.8 nvidia-cuda-cupti-cu12-12.4.127 nvidia-cuda-nvrtc-cu12-12.4.127 nvidia-cuda-runtime-cu12-12.4.127 nvidia-cudnn-cu12-9.1.0.70 nvidia-cufft-cu12-11.2.1.3 nvidia-curand-cu12-10.3.5.147 nvidia-cusolver-cu12-11.6.1.9 nvidia-cusparse-cu12-12.3.1.170 nvidia-nvjitlink-cu12-12.4.127 overrides-7.7.0 pathspec-0.12.1 pykwalify-1.8.0 pylint-3.3.4 pyrsistent-0.20.0 pytest-benchmark-5.1.0 pytest-sphinx-0.6.3 pytest-timeout-2.3.1 pytest-xdist-3.6.1 python-json-logger-3.2.1 rfc3339-validator-0.1.4 rfc3986-validator-0.1.1 ruamel.yaml-0.18.10 ruamel.yaml.clib-0.2.12 tomlkit-0.13.2 y-py-0.6.2 yapf-0.43.0 ypy-websocket-0.8.4\n" + ] + } + ], "source": [ "!pip install --pre 'cebra[dev,demos]'" ] @@ -100,14 +634,14 @@ "base_uri": "https://localhost:8080/" }, "id": "f5f8531d", - "outputId": "52c93bb4-b554-41b7-970f-3d3679a71951" + "outputId": "aedb90a7-bafb-4bb9-88f3-fce080612f31" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ - "100%|██████████| 10.0M/10.0M [00:00<00:00, 29.7MB/s]\n" + "100%|██████████| 10.0M/10.0M [00:01<00:00, 5.74MB/s]" ] }, { @@ -116,9 +650,18 @@ "text": [ "Download complete. Dataset saved in 'data/rat_hippocampus/achilles.jl'\n" ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] } ], "source": [ + "#1. Load example data\n", + "%mkdir data\n", "hippocampus_pos = cebra.datasets.init('rat-hippocampus-single-achilles')" ] }, @@ -139,10 +682,10 @@ "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 282 + "height": 363 }, "id": "6019b83e", - "outputId": "7a8d42e0-64a3-4d65-b81b-479184476929" + "outputId": "174b6db3-9bdc-40c0-bb0d-c80e0c8cd350" }, "outputs": [ { @@ -151,7 +694,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIYAAAG9CAYAAABgan3JAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAXEgAAFxIBZ5/SUgABAABJREFUeJzsvXmUJFd15/+NiIzcl8raunpXb6WljSS3kAS2Echm0aAjxCIYY/sYgbxgbI808gyYMywyywwHDEZY9uBhWHzsQbaR2WSwZgTIyDZCAslGexdSb+rq2iv3JTJj+f1Rv/v6ZWREZmRmZFVl5vuc06cro2J57777XuW7cRfJsiwLAoFAIBAIBAKBQCAQCASCkUPe6gYIBAKBQCAQCAQCgUAgEAi2BmEYEggEAoFAIBAIBAKBQCAYUYRhSCAQCAQCgUAgEAgEAoFgRBGGIYFAIBAIBAKBQCAQCASCEUUYhgQCgUAgEAgEAoFAIBAIRhRhGBIIBAKBQCAQCAQCgUAgGFGEYUggEAgEAoFAIBAIBAKBYEQRhiGBQCAQCAQCgUAgEAgEghFFGIYEAoFAIBAIBAKBQCAQCEYUYRgSCAQCgUAgEAgEAoFAIBhRhGFIIBAIBAKBQCAQCAQCgWBEEYYhgUAgEAgEAoFAIBAIBIIRRRiGBAKBQCAQCAQCgUAgEAhGFGEYEggEAoFAIBAIBAKBQCAYUYRhyAOVSgUf+MAHMDs7i3A4jF27duEd73gH5ufnt7ppAoFAIBAIBAKBQCAQCARdI1mWZW11I7Yz1WoV1157LX74wx9i586deNnLXoZTp07hkUcewdTUFH74wx/i4MGDW91MgUAgEAgEAoFAIBAIBIKOER5DbfjIRz6CH/7wh3jpS1+Kubk5/O3f/i0efvhhfPKTn8TKygre8Y53bHUTBQKBQCAQCAQCgUAgEAi6QngMtaBWq2F6ehq5XA6PPfYYfvZnf7bh95dddhkef/xx/PjHP8YVV1yxRa0UCAQCgUAgEAgEAoFAIOgO4THUgn/9139FLpfDoUOHmoxCAHDTTTcBAO69997NbppAIBAIBAKBQCAQCAQCQc8EtroB25mf/OQnAIBjx445/p6OP/744z09Z2ZmBqVSCfv27evpPgKBQCAQDAtnzpxBLBbD4uLiVjdFsA0R350EAoFAIGikl+9OwjDUgjNnzgAA9uzZ4/h7On769GlP9zt69Kjj8ZWVFaiq2kULBX5jmiYAQJaFM51AIBhcLMuCZVkDvZbV63WUSqWtboZgm1IqlVCv17e6GQKBQCAQbBt6+e4kDEMtKBaLAIBoNOr4+1gsBgAoFAo9PUdVVRw6dAhPPfVUT/chTNOErusIBoO+3K8duq4DAAKBwVencrkMWZYRDoe3uimesSwLtVoNoVDIl/PsGIYB0zS3rfGyG32v1+uQZRmKovSxZf7R6Ryr1+tQFKVvRgGn9miahmAwCEmSGs7tVu+2O2790nUdkiR1pFtususFTdOg6zr7OzVI0Py89NJLt7opgm0MeQr59d1JIBAIBIJBx80RxQuDv5MfINy+vPQygE5YloVyubxphqFarQZgOAxDoVDI183ZZlEsFj1tvL2ex6PrOmq12rY1DOm6jmq12pG+0/mDYhiq1+swTdPzHKtUKgiHw31bAzRNgyzLDe0pFosYHx9vOteyLJRKpaEzDAEbfbYbdEg2kUjE833K5TJUVfV17VFVdWDXZE3TBrbtAoFAIBAIBIOI+ObVgng8DmDjS7sT5KaVSCR8eZ5lWY4bA3vhOKc38vxxy7Kg63rT8V7aZYe/J4Vf9ev+/YKXD/3cysPCfn6/2ug0ngT/TP44eXC4FRmk65zc7p3uzx+zLAuGYbQ8363tbvilm/b2Oc0VJ5kYhsFCbdxwkoXTOe1kbm+rl/Ps15im2dE8o/61u6/b+PFtc7qPU1tIt5zO59ejdniVuxtu88errrmd76T39vlknyteIfl4kVEr+XhZy1r9PfFzXvZyz071XSAQCAQCgUDQG4ObfGATIDfls2fPOv6eju/fv9+X57WKla9WqzBN0zFszTTNhmslSUIoFIKmab60S9M0lMtlrK6uIp/PMyMEEQgEenq7W6/XkcvloOu6b232SrVaBdAoQzpmp1arsU1OtVr1vNHtFLsMLMtCNpttOs5/ptC3arWKXC6HbDbb1GYATV4MlmWhWq2iWCw2GJeq1Sry+TyTC+8tVKvVUCqVmKcYj2EYTfrhRLVadZVzpyiKwjxjyLPGNM2G9uXzeea5Uq/X2eY9m82iVquhWCwik8nANE1H+VcqFdRqNei6zjyoSK72Y7lczrWtFPdLc8pJhnaoP53MsWAw2DaMzE2HC4UC6vV6w1pTKBSYbKrVquOcDwQCzCClaRoMw0C9Xm9aj2jcq9UqNE1j6xqNHd8+gsaPZN0K+3ponwPtcNNLejbfD3vIaTabRSAQ8DQHeEKhEEzTRD6fx/r6OkqlEgzDQLFYRLlcRrVadewHzVNd11mfvfSXxt6u653Kygvd3FNV1YHx5hMIBAKBQCAYBoRhqAWXXXYZAOCxxx5z/D0d9yMPAm3G3SiVStB1HWtra02/MwwDlUqFfZZlGdFolOVI6pVSqYRsNouzZ89ieXm5yYAVDAZ7ClnRNI3dt1Qq9c3g4gR5fRmGweTvlrCrXC6zjWs/E6LyzwE2dGNpaanJc40/j893tbKywjLRVyqVBg8Gp3wjpVIJmUymwUhRLBaxtrYGwzCgaVpDGFC5XEY2m3XU13q97sm4VyqVUCwWfRlrRVEaDGO6rjeMp2VZWF1dhWEYyOVyqFarMAwDkiRheXkZ1WoV6+vrWFhYgK7rjvIvFouoVCqo1+uo1WoNcrUfW15edvV20DQNmUwG5XIZ+Xzek3GM+tNJKFY4HG5rSHLT4dXVVWiahtXV1YZjJJtCoYBgMNgUWqiqKjMCVCqVBiNKLBZjcqU5XigUUC6XUa/Xsba2hmq12rC2UPtM08Tq6iosy2KybgWFFhLlcrkjPXOTi6ZpqNVqbB6WSiXE4/EGT5jl5WUEg0FPBj+eaDTK1vf5+Xk2H9fX15HP51EqlZrmMslwdXW1Yd7Zz3PrI4Uc83i5tlM6lT+wYSjbrqGrAoFAIBAIBMOIMAy14Od//ueRSqXw/PPP49///d+bfn/PPfcAAG644QZfntfKdZ7exNfr9aaQAwo14ZFl2TdXfNM02Ubb/lafntVLklt6w0/P2Uz4ECT62d4GkjcfntPPdtrlS+NufyadJ0kSMwIYhoFarcY2pqZpNoRyOBkLyLOD1yk6Rvfgx5e8gpxkwD/PCV6WfsmQT/TLP5+XI/VF1/WGc2q1GusPGTWc5g0l4KZr7c/hj7Xy/KNE2fRML3OUDw0i+bULO1IUpW3ojpv8qV281wuFOtG4Oc15vn00V0zTZHpHfeXnGS8ze5/49vG66CVEjs7j7+0VN7nQPfn2271aarWap7XX3tdAINBg+CJ5k664zReap3zolRed4vvA65MX+XaK17BG/pxe/6YIBAKBQCAQCDpDfPNqQTAYxO/93u8BAH73d3+34U3ypz71KTz++ON4+ctfjiuuuMK357kRiURYSAYfNgBsbAJ5bwJN02BZlm+VtcLhMCKRCMbGxpBOp/vyJjeRSEBVVdbPzYJCq2RZdvXIqFQqLDSGNiudJJbtlHA43CADWZYxPj7e9Ez7eXQsGo1iYmICwMab93YbrEgk0nReJBJBKpViSXT554TDYSQSCUd5BQKBlvpB4SuRSMS12l8vUEJpWZbZfJIkCWNjY5BlGfF4HMFgEJFIBIqiYHx8HKFQCMlkEhMTE8z7iO+vJEmIRqPMi0FV1QZ52Y+l02lXHQ4Gg0gkEgiHw4jFYp487fhQOWDDK4rC0XrBTYdTqRSCwSBSqVTDMZKN27hRsmOq6mdvN8mV9CkajTLPJnomb7ik9tH4SZLEZN0Kem4ul0OtVmPec15xkwt5SbVaV8fHx1kfW8EbXgmSw+TkJBKJBAKBAJLJJGKxGCKRCMLhcMMcJRmOjY1BVVUma69zHgALUyOPUy/XdorTOmWnVquJnEICgUAgEAgEW4hIPt2G973vffjOd76DH/zgBzhy5Ahe9rKX4fTp03j44YcxNTWFL3zhC748R5KklhuOWCwG0zQRiURYrgvaCPChNMCGISMQCPhWpjgajbI32ul0ui+5H8jgtNmVaEhGgUDAtV+lUgmqqrISyvx1/cBuiJEkCdPT000bNicjGukHbeq9GNpisRhqtVpD/+PxOKLRKBRFaTIEOG1SiXabdtM0UalUkEwmWd/8hN+E8pvziYkJyLLMjF2WZUGWZUxPTzPDaiqVYoYNu/ztIUN8BSnqMx2bmppy7RcZlyhJsJdNOK+bFP6jaRozrHSLmw6Pj48zoxl/LBAItDTm8Ya4SCTSVLWMdJGeS8n9yfBp93Ki8yRJwsTEBDMMtYPktbi4iImJCbzwwgu45JJL2l5nf65b/1qtUdPT0y3vQdTr9YY1HNjQn4mJCaYXZGQENmRA/3j4eUp4nfPARshoPB5nf1v6YZgnXWhFpVJp6odAIBAIBAKBYPMQHkNtCIfDeOCBB/D+978f0WgUX//613H69GncfPPNeOyxx3Dw4EHfnuX25ZlCZeh/p6oy/LXklm/faDmFoHlx8ZdlGYqisLf13bxRbvUsCjWh52yWxxAfgmSv9GMPr7DnnOmknV6rDRH2e9OG2L5pcmqDoijMY4L0wqm6Eh8yRdc4PZPXPYLGyUkP6Hl8SIq9/6Zpsmf6DT2fnxN8X+j31KdAIMD+J5k5yYL6y2/O+f/5e7cqO07GEkVRmM63g++LU8hPp/pFOOkPtV+WZWaEsesCXecW/kNrhj3Ujsab+sLPd3om3x76nX382smMrrGHfvUiF75/9jWDh5eTHV5e9jlI96Ok3qQb9DOvf/z5pEe8jjjNeR6+fXZ94vXML9zk6SQP++8FAoFAIBAIBJuDMAx5IBKJ4EMf+hCee+45aJqGhYUFfPGLX8SePXs2tR3kVdQuXMfNm8NecYmSxLajXC63DLXyAiUxdsIeQrJV5PN51Ot1KIrSkNCbPDPi8bgneTlhT/LaLyiMpxVU4a5YLLIxsYeQtOpnpVJpuWmjqmW0Iaf8PUB7z7h+Y++XaZodVUfjE03zx1rlFfITkl88Hm+Yj93qZa846XU2m4Wu66hUKshms8jlcuw80gUKzewnY2NjCIVCOHjwYF/y1XQTTkpyoPUun883ndPpWLabj26QJxaFddJzu71fp/C6Q6GHdoRxSCAQCAQCgWBzEIahAYLyvVA+EzfcDEN8pSbgfFhPKyh0xR6u1imtStFvF8MQ5SQhwxBV04nFYiyvTjcVdpyq//QLr4YhwzAaqmLZN2atqq5VKpWW+UCo/Lu9ahe1r5/5mdphHwf7nGgHGYH4+3iplOUXlFeG8hQBm6tfPG7PzWazTEaZTAbZbLbBMKRpGjRN67ike6ek02mEQiHMzs72xQux03BS3hBPhv1cLtd0XqcVD7tZkwCwsMdIJIJYLMaeu1mGIf45oVCoyTDklgheIBAIBAKBQOA/W78bF3iGD2Mh13+nvBO9vB2nL+OKojSFOXSyuaIQDnvoB7WZh8JSnO5PVY0oNMStHRSK0Enf6Rq6Nz2PoGo6Tm+yW7VlK+D7z7fJqZ1Omz6Sm67rrKoSlXTnq5pRWB3/j3TFqWqWvYKWH+PnVfZe9IV+7mQ87aGFfLUtkh3dPxAIQNd1dm8+zJPXeV7OvByc5kq3Okfts4dNttOXfkGVtuiZpD+8rHiZ2cOoWukLHy4VDAbZGPupX72ss/b78xUGCX7uGIbREKLIr/8EjS9/XavQOwpdo2d1i5Me8e23h6e5hekJBAKBQCAQCLYO8W1sQKGqRJ2EY9i9fpy8NwzDwNraGnsGeSh0w8LCAvMSojwYbp4Vbh4P/FtlKuPsRKchQUSpVIKu61hfX0cqlWq4v1ObotEoJEnq6K1+LzLsBKf2UtiYE8lkssm7aG1tjVUIKhQKKBQKyGQyDRWeyBukUChgaWkJtVoNa2trqNfrbLzD4XBHlYZahRp66afX8/hx4H/vdTwpCTkPlQvP5/MwTRPZbBYLCws4e/YsdF3HqVOnsLCwgPX1dSwvL+PcuXPQNA1ra2solUoolUrMm6RWqyGfz3fkUeNVv3K5XIOMNU1r6osfek1VsqLRKNLpNMbGxth5gUAAoVAIoVAI2WwW+Xwe586dY2tFPp9nc573YMnn8yz0kZeXV1p5LNrp1GPHK5LUWK2Mr/xWKBRYf8gTibzZMpkMTp482bDWl0olpie0JvGeWvl8HsvLyx1VrqPndpqAupXHXCvPunbP4fMmCQQCgUDglbm5Odx3332Ym5vb6qZsOUIWgk4Q37oGFKpM1IlhyJ4nyL5RATY2I9lslj0DQNdGjeXlZWasoeSpbrlY3Db7vGGjH4ahSqXC+pxMJhvu7xRSwZd57oR+G4bcwnpa6Yg9Tw1w3jBkWRaKxSJKpRJyuRzbhK6srKBer6NSqaBUKrHPmUymwTAUCoVQr9c9eyJslmGIxs9uWPB6TzfDkGVZKBQKzEC0tLSEc+fOQdd1nDlzBktLS8hms1hZWcHi4iI0TUMmk0GpVGKhQJVKhRlHWum6E17C8+i+fLvtz/BDr8fGxhAIBBCJRDA2NoZUKtVgGAoGg6ycfKFQwOLiIpaWlqBpGorFIpt31JZKpYJCoYBSqYRardYgL68YhuE53K+f+Zp4eQWDQVadr1QqsfWLxpJywuVyOZw+fbrJaF0oFFCr1ZiBJZfLsblZKBSwsrLSUYgjPbcbw5CXdd1uGPKyJm4Xj0yBQNBfxObVO0JWrZmbm8Pdd9+Nhx9+GHffffdIy0nIQtApwjA0oLSrPOOEPXzBKVzCXt2GjnUDX42GntWqWpNbm51+bncuX7XJyzXUVj70winvER/y45XNCM3hQ3HahQC2ql7EV78jWdA//jg9jz+fH2P+3l7e/Hcio17Os7eLjnXimcBXpuLvaa+2xVc8o2pe/HF7pSkn2Xntp5fznapaOZ3T7XN1XWdhWBQ+x+uO/RrqP1+djf89X9nMrdpct21td67f8OGK/HPs/eaP8X1XVdWxApz9Ogov67TCo1Nb2kGhtu3uy//c7u8P3ZdCWQUCwfAjNq/eEbJqz4kTJ1p+HiWELASdInIMDSixWIxtMv1EURRMTEywZ/TCrl27GkKVgsGg67lub48jkQjbsNgrZ/EoitLgNVGtVj0ltY7FYggEAhgfH4ckSQ1ynZycdHyerustq8JtFdFolHne0Ng5JSJ3qwAEAFNTUwiFQg0bNrpHKBTCzMxMw/WKoiAYDGJiYgKqqjYYiKLRqOOm1olOkpt71ctW51H76LmtdNPpvrx8SGdosz42NoZwOAzDMBAIBHDw4EEEg0GEQiEkEgkYhoFwOIyJiQkEg0G2KSd5pVKplrreLVSli6Bn2/vWLZlMBslkEqqqYm1tDdPT064GBknaSHysqioCgQBqtRrrOxnOYrEYNE1jsuPLt3canqkoiueqir2ue26USiXmIWQnkUi4rlXpdBqyLEPTNLbGUUJ8Xm/T6TRM02Tyon/9olKpIBqNshxOTvCy9LIOABtyUlV1SxKqCwSCzcdp8zo7O7tFrdnePProo02fhawaOXjwIB5++OGGz6OKkEUjDzzwAObm5jA7O4trr712q5uzLRGGoQGlX5WdaGPrxzMmJycbNoatjDRuz+KNBa2MMZIkNWyCNE3zZDij51KuD74d6XTa8Rpd19nmdDsRiURYOBdtyJw2hq02i2NjY5AkyVXW9jGlsBPSGR6SvRfjpSzLno0zXvWy3Xn0+043z3aDBN2H2p9MJpFIJABs6OXu3bvZz3wCXnt/Sdc7MVJ1ArWJcBrjTsOIePL5PDO2ZbNZTE1NtTyfdI0qYtHPfFvy+TyCwaCj0bCTKonkreWFfq2tlUrF1TDUyhiVSqUQj8exvr7Ojjm1MZlMIpfLIRQKIRwONxkw/aZarSIcDnte172+xKBQwkKh0HMbBQLB9qdYLLb8LDiPfU3vV068QWZ2dhbXXHMNHn/88b696BkUSBZkDBllI+IDDzyABx98EACwuLgIAMI45IAIJRtQ+BACqlqj63rX1WVM00S9Xm9w7+8lBMopJIZCTey5ZFo9h/+druss0S/lquArRPHVoaiilhuUr8Me4sZ/dmuXW2iUZVnQNI0lXebLSLcbI8uyui7fTWPHVxGj+/F94J/hlhTaHp5i/+cUvtLq/FZy5LGfY1kWy7NDP/OVm+z3o9AT+3lu4S58u0iXnNpoHxen/rjJiQ8xc/q5V5k5YZomy5vFV7Rykhs/r/hjneiiXb6VSqUpZIqHxpPXHXu4Yif65RWSAa8fTjpDMuDvTedRMuhuURSFyatQKDTIjZ7Prw/8+m4PX3TTQ7uudbt+8+2gdcu+dtH97dXT7G10+2yHnkOyoMp9AoFguDl37lzD51OnTm1NQwaAHTt2NHyen58X4WQ25ubm8OCDDyKbzWJ+fn6kQ+5IFouLi3jwwQdHVg4Amvo+yrJohTAMDQG6rqNarfb0loWS4faT9fV1aJqG5eXlrq7P5/NYWVlhVcSAjbfWtJmgpLGapjGPITd6ecuiqqqrl8nS0hLW19eh6zpOnDjBNjZkKGr13G7bVKvVsL6+jlKpxErHu92PKjpt97dMpmlidXWV6fTq6mrLnCNUdWptba2pelM7lpeXW25At7useOr1Os6cOcPmBa0NbjglLXdLZO4EGaGADU+nF154AZqmuXrzuMkyGAw6ejCFQiFfwjapP2tra8zoRYYe/pgTdJ6maTh79mzXbYjFYiiXyzBNE48//niDztG85Ndw8nKqVqtN3lRutPPg8Qo/TqVSiSX/5qFqaLVajSWs72Wu8Am1yQuxW2O5QCAYDObm5pq+e5ZKJTzwwANb1KLtjVORDpE3phEneYyqjESOofNQmhS3z4INhGFoCCAPml7eZuu63nf33WKxCF3XkcvlurqeyjDrus7CDGjzy3siUZWcVjlaen3z77b5ymazKBQKMAwDS0tLDR5Dmqa1fG63baKx0zSt4Q2+0/2q1Spry3bGsqyG0uUkUzfImyyfzzec56XCVCt9HARZ8ei6zqpRkTddu8pUbnriBU3TmI4HAgGsrq6iVqu5GnPcZEm5g+yoqupLriXS+0Kh0GAYqtfrbF1yg86r1+tYW1vrug3hcJiNy+nTpxsMQyRHXu7kJURt8xLy6Je8+HHVNI1VzOPbTLnIaO71OldofaT+RqNRV89GgUAwHLhtVB9//PFNbslg0Gl6gFHEKY/OqObWsfd7lHUlHo83fHarpjrqCMPQECBJGxWOenmz3kmOFy9YltU06YLBIGRZ7ig3CA956lAiZKCxOo89IXKrsIVe3qq3ComghLCSJCEejzeEqLltfklOgUCgq4WKxo6vgkX3s9NJ3p+tJhQKsT61S8ZMm2h74mwvc6LVH0penp3gpP+bgSzLLBk26Wm73Dqt9KQdfK4tVVURj8cRCARYomG7Mc+tLa3CNrsNh7K3E2hMYE+yoXXJDQqt03W967WLHwvyhrG3j0LGALCwXnuIndfn9Ao/rrRu2XXCKVSsld6Q8ajVMwOBAILBYIP+CgSC4cXt7282mxWhHjYoLMgO5UsRnGfXrl1b3YRtwezsLI4ePco+j3I4md1INjc3N7KyaIUwDA0BgUCAJRvtllAo5JpsuVvsHkjj4+MIhUKYnp7u6n6pVIpVMhofHwdwPtSEqjrRMadkyDx2y7FfzMzMsApdBw8ebDAMRaNRx+dS+AUl4e0UqgpG409JZ530IRaLNchquyLLMiYnJ1nC5MnJyZYGDjIaTk5ONmxOvcyJHTt2tNyAdjuvtiKBpqqq2LdvH6scZ6/WZ8dJT7yGLQGNVQPj8TgOHz6MSCTCqq/ZPY/6Ne/aQXOC5iZwft3kjznBh+ra8zt0ClWeu/TSSxuMUdFolFU75EP5WoWt9hN+/KPRKJLJZNtk1rTGudFubYtGo0gkEhgfH2fG9UEwYAsEgu5p5WX4/e9/fxNbsv1x864SG9zzzM3N4e67727KWzWqIVRzc3N46qmnGo6NqiwANO0NR1kWbohvXUOAJJ2vItXtG1ZFUXw3Ftj/4NP97dWRvMK/raeNC79x4Dd87TYU7TyKukGSpIa+TU5ONvyuXXhNMBhEPp/v+Ln2sSPPL/uGkjxv+HO2K+RxRbQzVJBnhX3c7R5ETrTTx25ltRUhaIqiMKMp0S60yKl/XvvM67S9PDofFtTpff2GnsvrkZvO2KHk7rqut6201g6SF1Wq49tXqVSY8ZN0h9q42fDj1MmYtTq33XxwWh+3ou8CgWDzaGX4PnfuHKumJGguPc5z4sQJISe4b/RHNZTMSR6jKAsyGNoZRVm0Q3zrGgJ6qWJkv4ef2DcJvbbTqSJRq2Pt7tUP3ContaqmRHJqZTzy+kynz63O3a50WoXK7bxew296kdVWGEG6lVu7Y16utz/TXkmr03v7Sadzksc0TYTDYYTD4Z4NFa30lJcXb+jfSnm1ajNBnmnt2tpubetEbwUCweBjD43iQ14I8Ub/PFR6fGZmpklWYoO7gd3QOD4+jgsvvHCLWrP1CL3YwL6ORKNRXHPNNcKY6oAwDAn6xlaFjQwavBdDL+GAgu3FqOs/hWoNOoZhIJVKtQ056xUKG+sklG87EAwGPRlBR30+CASCRuybtXg83mTwGOVkuXb40uP28CDBBnbP1PX1dRw/fnykS9aL8KlmA1m5XB7pfEutEIYhQV+QJKkvHhOtkpf6fW+q7sX/3M3z211LYW39ktlWw/ffLs9Orx8UOh1Lu4za/euUrZCfk8dQr/RDRu2uIY+haDTqS3/cnkXVDv1YB9zWrl51yekae5VGt/v2I3xXIBAMLvbN2sGDB5sMyINUFbTftNrQj+Jm34lWHjKjJiMKn8pmsw3HR9GLaHZ2Fm9961sxMzPTcHzUdMILwjAkGBgsy2pbersXisViw4aGqhER2Wy2q/LJVOrZvjiPCmtra6hWq1hcXGQ5lEzTbFl+nofGvJ9jv5VYlsVKzJdKJdRqNRQKBdTrdWiaBl3Xkcvl2M/dGHgMw9j00t+mabYsA98NhmHAMAysrq6iXC5jcXERmUwG5XIZxWIR1WoVmqahVqt5khOtKaZpYmlpyfEcv421m6HHlmWhVCoxGSwvL7PxWF9fR7lcxvr6esebLpJ/K/ox7gKBYDSwewhtRRGH7UqrDf0obvadEOF257EbPcbGxkY6rA4Akslkw+dR0wkvCMOQYKDopmqXV+wlP3VdR6VSAbCx0Tp9+nRXG55sNotCoYDTp0/70s5B4/nnn0cul8OTTz6JhYUFABubY6+bUjLY9XPst5q5uTkUi0WsrKygWCxiYWEB5XIZ+XwemqZhfn4ehUIBlUqlKx0kY8lmQoYtP6nVaqjVanjuueewurqKp556CidPnsTq6iqWlpaQyWRQKBRQKBQ837NYLKJer7u65rerxtUp5XK5795bZDwDNtaup59+GrVaDZVKBSdPnsTa2hpOnjzZkZyA8/JvBVVxE2wdjz76KD72sY/hjW98I/bs2dNTzqYLLrjANXeZJEl49tlnHa8zDAN/8id/ghe96EWIRCKYmprCW97yFjzzzDO9dE0wRNg3ridOnGj6m/HUU0+JcI//H/J6uPrqq3HNNddsdXO2JfZwu2uuuQZXX3013vrWt45cPhm70SObzY5sWB15T1G/d+/ePfJGMjdEVbIBg99Q9LpZoXu1u499E0PnO21u7L/zO3SgXq93dL6XttMxMgLx1/Jvx0ulEkzTdN3UufWVNlJ2w4bXzWG/ZNrq+X6OW6FQQK1WQzabxeTkJCzLavIYaqXXNObtDCJO93Aaf8uymp7RSrb87zode6/k83nous68gsrlMnRdR71eh2EYKJfLqNfrCAQCDSFCXp9tGIZrn92w97edbJx+ZxhGx3re6r7k9VQoFJgXnqqqSCQSqNVqLBTLfh+3NgIb+mWaZoNHH38dhUm1my9ex4O8vrzIpVu9siyLGWcsy0Iul2NzrlAoIJVKMa+0Vuu4HTevM7unJc3tTv/G8PNWhJ11z4c//GF84xvf8PWeb3vb2xyPp1KppmOmaeLNb34zvva1r2FsbAzXX389VldXcc899+Bb3/oWHnjgAVx11VW+tk8weNirbNFG1l5569FHHx25Tb0Tc3NzOHHiBA4ePNhkVBMy2sAuF03TcN11121Ra7YW8p6am5uDoiiYn59nvxu1KnZ2vSBZHD9+fCSNhq0QhqEBQ9O0pso13VKr1aCqatsv4KZpolQqIRgMNrj5WpbFNhahUAi5XI4lOaMNYT+TtXqBSkDLsgxJktgmjzbbfIlte4I2WZYbwkgmJydZWI9pmggGg6yPrRIkxmIxBAKBhvL1wHm5hkIhJi/aEAUCAZTLZUQiEZbAV9M0XxMx0kZR0zREIhHoug7DMKCqqq/hM6lUCtFoFHv27EE0GmWb02g0ys7RNA2WZTkmK6ZjXvp+7tw5TE1NsfaTMYnKjSeTSSZHu95rmub4/GKxiEgkgkAgwIw3gUCAecRMTEx4F4YLO3fuRCgUQiKRQCgUQjqdRigUgizLUFUV4+PjiEQiUFWVVcbqRB/46/j+yrLMNvHhcBjZbBblchnT09NQVZXppWEYjrKhNcCpHYqiQFVVlMtlNu9Ir0n+lUoFsVgMpVIJiUSCjQnppl0P6T47duxAIpHAnj17kEwmEY/HWRvJOFSv11m5d7c2Ur8DgQD27NnTcJx0dH19Hel0mvVXURS27gUCAWiahng87tpmO7zu5XI5JBIJrK+vIxAIYGxsDJqmQZIkT2uzG7IsI5FIANgwtuzevZsZFaenpxGPxzE9Pd2kS+3+JvC5hAjLsthb/kqlgkAgwNb9er3Oqpa1gj+P7jcMicu3ipe+9KW49NJLceWVV+LKK6/EBRdc0LP33pe+9CXP537hC1/A1772NRw5cgT//M//jB07dgAA/v7v/x433XQTfvVXfxXPPPOMoz4JRgd+4zo7O8s2Z7t3727YxA6zt7BX+HLbDz/8cJPH0NzcHJPjKGM3NoZCIdx33304ePDgyMnGXvWPZ9SSutv1gmfUjGTtEH+VB4xyuYxwOAzTNHs2ulQqFbZxagWFJaRSqYbFxDAMVKtV1Ot1qKqK5eVlZlwhL5mtNgzlcjmWNJZPklqv17G6uso24AAwPT3dcK2iKGxzIkkS9u7dy3Jz1Go1pFIpmKaJRCLRMrHq2NgYJElqWohJrhMTEyiXyzBNE6ZpQpZlRKNRLC0tYXJykrWBjEh+QUaO9fV1TE9Ps/ws0WjUV8PQjh07kEqlcPToUZTLZdRqNayurmLfvn3snHK57Gp8iMfjnis1HT9+HMlkkrWf9LBQKKBcLiOZTKJYLDrKsVgsOj5/fX0dU1NTzBi0vr6OeDyOQqGA9fV1XwxDR44cQTgcRiQSYXqnqirTh127drENO+mZWz+ccNLPYrGIYDDIPEtCoRCWlpZw7tw5JJNJqKrKvJbcNuqWZTFDj51AIABFUbC4uMiMgJFIBGtra5iYmIAkSVhdXUUwGMTa2hozZAAb87NerzfpIX0+fPgwVFVlRlcyepABGNhY31RVhaIoqFQqrrKKx+OQZRmXXHJJw/HV1VXMzMzgzJkzrP2GYSASiTToay6XY4aparXadu5Eo1HWxqWlJUQiEZw5cwaxWAypVArFYpHJrt3a7IaiKMwQLUkSLrroIqiqikAggAsuuACqqiKZTLJ1h3SpWq22/Jvg1rdisQhJkrCysoLJyUn2d6BSqTCdboX9PLe5KPDGe97zni19/qc+9SkAwMc//nFmFAKAN73pTXjd616Hb37zm/jGN76BN73pTVvVRME2gN+4Li4uYvfu3cxYREYQYOPt/qgbPZw8YS688EIcP3684ZxRlhExOzsLSZKwY8cOpl8PP/zwyHmGPPbYY66/G7Wk7hSGeeLECYRCoQaDmcgz1IjIMTRgUBJZPxLJek3+S14B9vPJk4CO87kn/GqjnU7foJMXjD0EjJLO8n0Kh8MN9+erKkmShGg0ymShaRrbvLYLl6ENGe8hQ22g63VdZ5twarOmaQ3t8zpeXqGQLgqloXb4PW6hUAiBQIAZG6jfPPRsJ8gDxMvbZdroEqSHJFt6lhNux/mEzyQvwzBQr9dRrVZ7zhcjSRLi8TgCgQCTVTgcZh43iqIwjyXeWNCJPjgZGWhekL6RpwaFTFJ/7SGVPK1+R/OHdIqeQfPONE2WJNquD6SbTveUZRmxWAzBYBDJZJIZMkOhEJtrgUCgYc676TTpFe9hQ5BXUKVSYffi5UH9Ir1tJQsePtyN+k9GWeB8gude9IoM0WRITCQSbDxIdnzuJGp3u+e6GY2ozZqmMWMm4C53O/b12e+1TrB5nDx5Es888wwikQiuv/76pt/fdNNNAIB77713s5sm2GY45RgCNjZx9vwfo149yKmC27Fjx1qeM2rweWSOHz/eVFBilHSIZODGqOkKH4Z57bXXsgTl11xzzUgZC70gPIYGDAp78CN5KYWqtENRFCSTyaY3uLIss42sJEks3AJwDjnwg07fIsdiMdZP/q21oihIpVId3y8cDmNsbAz1eh2xWIyFP3UT8kFtIE8G2nhSCBuFD/HP9hNFUdjmmgw2dMxP+D6QvkxMTDR4k5EXXK/s3bu34b70czQaZToZDodRqVSaDHV8O3kSiURDKFQikUA4HGZhf1uVC8WtvV4hryRCkiSMj48DOO8ZYs/ZY0eSpLZ6GY/HEQqFmH6lUinmwZRKpdgxHjKK9UIwGGQGsW50OpVKIRAIYMeOHcxbi9YR0tdgMMjKK9N62AnpdBqKomB6eprJMRKJePLk9AMyHpEuef2bYIfWwPHx8Yb1MBgMerofjRV/P8H24hOf+ASef/55hEIhHD16FG94wxswNTXVdN5PfvITAMDP/MzPOM5h2sw+/vjj/W2wYNvjlmMI2NATfmM7ahtZO05hd/YEwvPz8yO9ybUbfuz7pFHSIbssdu3ahXPnzm1Ra7YWpzBMJ09FwQbCMDRg8GEIvUIbkHZQWIL9XHuoFR+K5bdxgfASTsSTTCYdN++qqjr2qR3RaJQZBWRZbgpf6QRFUTAxMeG4oaQ3/vxmqdO+t4M8UMgrhQ/H8RO+3ZFIBJIkYWZmpsF4aDfSdMvs7GyDLHkDB31JiMfjWF9fb3qmm3xp8073Gx8fZwYRp8Srm0Wv+kAheiQvcr2enJxkx8j7xm0+y7Lc1kCVSqXY/JBlGePj40yek5OTCAQCzCBFkOdPL/D96saINjExAUVRsH///iYDGukO5QICzs+nTpienkYgEMC+ffvYOkXjuhmGIfp7Qs8Mh8NdPZeMY+TpRtB8b4f9PLqfYPvw7ne/u+Hzf/7P/xl/+qd/ine84x0Nx8+cOQMATTm7CDreSZVOe9lp4vnnn8ehQ4c830ew/aCwn2PHjonNWQucwu7sm/8HH3xwpDe5dkPjzMzMyFXfIuyysHtEj1LYoX2e2HVilGThBRFKNmDQG3A/Ng2KorBqOu0q7pDxwF7xh4wihmGwxKHk9eL3xkaSJM8bL+oTH37Dt4c+t7of9YX3ZCFDSjAYZElW7XLppD+UFJgMM/SPPHfsXk5+GAVJNqZpMi8IOk6bUz4ZtlMlNl42dB6vR/bPABr0wu5JQDmgeukfGQCcxplPiCvLcpN3EumWvV+8XlNlL16f6J728B+7TNrNMTcZ8iFd9jCfXuVF/eBlHwwGG2TYbp7whkRqo113KFSLjvHhmfZE+tRf0kNev9xkZtdB+kxt72TdIPi5SV409vuR/MiAxc8lN0i36B8ZLN0MYW465TXczEl2vF7RuNv/7wReHrRm8YZAL/fjz+PnomDred3rXoevfvWrOH36NMrlMp588kncfvvt0DQNv/Ebv9FU/axYLAJwN/aTEbJQKPS34YJtjT3sx45bmNmo4iQPJw+YUZcTzyiHktnhc70Bo+U9Ze+r3Qg0SrLwgvAYEqBcLnflsZHJZDA2Noa1tTVkMhns2LEDsVgMxWKxIaxsK9A0jRltnLAsCy+88AIuuOAC13tUKhWW88ePBMNuUK6SzaoSQDlTlpeXsXPnTqytrSEej2NxcRHBYBB79uzBysoKdu7ciWq1Cl3XEQwGG8I7DMPA2toaotEoQqEQO0fXdXZepVJBMBjEwsIC9uzZg2w2i2QyuS0q0bjpu2maWF9fh2maSKVSWFlZQTAYZBvx6elpSJKEWq3G+h+JRJDJZAAAU1NTrP9UVY4SEvOysUP6alkWO49kn0gkkM/n2bzy23OsFyjxsqqqyGaz0DQN5XIZO3fuZJXBkskkTNPEyZMnMT09jVqthlAohGAwiHw+j1gshlgsBk3TUKvVkEwmAWzk+KGE4dVqtWnMqAIWVdSiimeapjV5IG0XstksM8ZnMhkWlkh5niYnJ7G0tATLsjA2NoZ8Po90Os28FKvVKlRVxdLSEhRFYb9zg3I32T2+VldXm5LtbzdGLTnmduUzn/lMw+ejR4/ik5/8JC666CL81m/9Ft7znvfgxhtv7GsbnnrqKcfjbp5Egu2Pk6GD37C1CjMbRZzkMTs7i6NHjzbMDzLMjiIilOw8TsnK3/rWt+LRRx/dsvQHW4U9DPPaa69lHnejWK2uHcJjSIByudzVdWtrazAMAysrKzh+/DhyuRzq9Tqy2ay/DeyCarXaNoHpyZMnW76VLpfLyOVyWFtb87t5DVB1sM2iUqmgUCjgxIkTqFQqOHv2LHK5HJ599lmcOHEC9XodZ8+eZRWnCoUCq1xFGIaBpaUlFItFtoGn5LPA+WpVhmGwe5G+bAfcjCukz8vLy9A0DWfPnmWVus6ePYtarYZ6vY5isYgzZ85gdXUVxWIRZ8+exdmzZxvkVCqVWPLidmNM+srLsFKpsC95uVwOZ8+e7Xqu9otMJsOSL2cyGSwuLuK5555DpVJBtVplXgGGYWBubg75fB6rq6vI5XLQNA0rKyusFLGmacjn8+ze9XodmUyGydAOGW6LxSJL4lwsFrG+vr5tvU0ymQz7d+LECSwvL7PqdisrK7AsC+fOncP8/DyKxSIWFhaYPpimyXTphRdeaPidG6SvdlZWVvrSPz/xI7G7oH/ccsstmJ6exvHjx3Hq1Cl2nMIA3dYqmu/20AbBaOGUTFnQOfaw26eeemqkw6d4rrjiClaJzJ7MfNhxm1/koUfeeqMAhWEuLi7iwQcfHJl+d4swDG1D+HAIPozHHlqymbiFE9H/9hCY7UA7GfFVsLxWUaMxoDAOuqZdqJDTODqFCvFV5+wyt1dZ4ivCeemDvdKTWwgOnUu4ha1QtS76HS8T/rObXPh++oX9fk566wRfXc7pH3/fVqFzbm0iSC48TnrkJTSvnc55xa4Xrc6jMXcK8XJro1t77Z9pDJx0jZ8P7dq6GeuPk76TbJzmt71tTvPN7Wce/r60ftnDzewV5dza7xdOFR95faaf+bXNPqcEg4csyyy/z8LCAju+b98+AMDZs2cdr6Pj+/fv73MLBYOMCCVrxE0eIpysETIC8aXpR9EYQuXZr776aiaLUZ1T9n4++uijuPvuu/Hwww+PlE54RRiGtimVSgWGYbC34cDGF3DySCiXy759ufcSRlapVJqeR8lZp6amMDs7y6r4jI2N+dKuXggGg0xubvBeI05eMZFIBMlksiEshcaEvKLIk8GLRwi/CaLxo3AYwzCQz+eRyWRQLBZRqVSa3rjyn6vVKrLZLAthora0cyOm8KZ4PI4dO3YgHA5j9+7dSKVSuPDCC3HgwAGoqordu3c3JO2lt7wE5VeJx+MoFotQFAWFQgGyLDOdrVQq0DQNu3btYlXr+NC+YrGIcrns6A3SLZqmNeSucHtrbT9++vRp5p0yOTnJqkTt2bMH09PT2LFjByYmJhAMBlklqr1792JychKxWAy7d+/Gnj17GsIB+XlFpejtXjGEaZosz5Qsy6jVamycgI0Ezrt3727Q2Xq93lbHvUAhSu0wDAPz8/PMGwwAxsbGWGhgOp3GzMwMDh48iEgkgnA4zLwCZFnG4cOHkUwmMTExwaocTk1NMTmtra3BsiwWyqeqKkvubV/7gI35qaoq4vE4q3IWi8VYcvB+YhgGm3uapkHTNMzPz6NWq7FwOr7NRDqdxtjYGNLpNA4ePIipqSnE43GMj49jamoKkiRh586d2LVrF2KxGGZmZphO8R5DFJKpqmqThxTJp1wuo1arOVaGcqom1S32uWT3HKT5Td51mqbBMAwUCoWWayZVTBNsX2gO8OvSZZddBgB48sknHb3VHnvsMQDApZdeugktFGxX2m1S7QaPzQq1367Y+0/yoXCyVueOAm45q0bVGMKXZycD2ah66dn7af9eMSo64RVhGNqG8GE4vGGI/5Jt36j3gpeKPU6GoXQ6DVmWMTk5icOHDyOVSkFV1W1hGKJNeCv4jXuxWHQ1DPH5kmhMyIhAmyJd11tu0p0MQ7RxDAQC0HUd+Xwe2WwWpVIJlUqlaYx5A4qmaY6GoXZ6USqVEA6HEYvFmPFj165dSKVSmJ2dxQUXXABVVZkxh3TDvvkjwxDllJJlGYVCAYqisPCySqWCWq2G3bt3A0BDNSqSuZMBrBf48CXqrxNuhiFgo1LW1NQUQqEQdu3axQxDk5OTCAaDUFUVsVgMe/fuxcTEBDMM7dq1qyHfC69fiqIwnXRKumoYBkvyLMsy6vV6k2Fo165dDXO1nc55hQwO7TAMA+fOnYNlWUyu6XS6wTC0Y8cOHDx4EOFwuMEwpCgKDh06xAxDiUQCoVAIk5OTTE6rq6ssx5NhGA1riWEYbH7Ss8PhMBsLKicfi8U2Jb+ZYRhYX18HcN4wdO7cOWas4w2/PLxh6MCBA5iamkIikUA6nWZ5zMgwFI1GGwxDfFhiMplkyZ55wxD/zHK5jHq97mgYmpyc9E0W9rnE66XdMFQqldha6GSM5xEl67c3Tz31FI4fP45oNIqLLrqIHT9w4AAuvvhiVCoVfOtb32q67p577gEA3HDDDZvWVsH2w83QQVBeEGKUQ0D4imQAcM011zTkRbGHk41ifjavHlWjYAwhI5ndI8bJi2gUoLVkZmYG11xzDY4dO9bw+1HQiU4QhqFtBO92z1d14XE6Ti76btAXddpcmaaJer3O8prQvZzyv1DIhNObWwpn0HWdVRHiK/PYQwy8VNHxCy8VgviErE4l7flKZpqmsXAR+rlWq0HX9YYQGLfwLvu9eXlRW/n/ndrfqn1ufeAh2dPmlQ/boQpJgUCgoToRX4WJD72TJImda6/YRP+oshB/L8MwmMxqtRprL+kZycsuR6/YZWDXRbonJfulz7Iss3El4wxfkYwPfaF2W5bF+sXLjtrBV/ayj7cdp3G3V4wjOZKc6vU6JElq0E2vYWFOcqPn8HJ3ClOi39fr9YZqUnyFM/7acrkMXdeZDpGsgfMGRgBMhk79t1e64mVmlx2NGRls7HPT7zxXdD9+XN2MdjRP6vU6FEVpWO9pXDVNY3PNXiWMPpO3UKt1wm0N5Ku0kXGaX8tpbhCk96RfTvfz8pkfJ5IbrQVubNbfi1HnrrvuwkUXXYT3vve9Dce//e1v43vf+17T+Y8//jje/OY3w7Is/MZv/EZTcvPbb78dwEaJ++XlZXb8q1/9Kr75zW/i8OHDfU9YLdi+tDN0EHYDx6i+2XdKJMxjN7KNosfQKBqA3BhVLyk37DmGAIykgcwrwjC0jeA3y9FoFIFAAPF4nC3ysiwzjwF7GFSrN/7ZbBbnzp1DsVjE3NwcqtUq1tbWcOLEiYbQo1beFdFotOkL//LyMpaWlnDq1Cmsr683GA4ANGxwWt2/H5AMW0EVpgAgmUy6ek6VSiW88MIL0HUdq6urOHPmDFRVxcLCAjKZDJaWllAul1EqlVh4FEHJX+1l1GOxWINHTiwWY54E8Xgc0Wi0KUEy359IJIJ0Ot0Q5haNRlsm9CTvgRdeeAHPPfccFhYWsL6+jqWlpZaJoQOBAMbHxxu+4PPym5iYQCgUwvj4OFRVbfAGsbO+vo5MJoO1tTWsrq4yvTJNk4W+6LrO5Nkp4XCYVbUCzs8TqsRGY1MqlVAul5n+79mzB0tLS0xfdV1nHiFra2vI5XJYWVlBsVjEiRMnYBgGlpeX23ra2PUwFAqx8CgefqxVVW3aaJEsyNBCiZtVVcWpU6dYe7sJL+PXFf5ZQLM3SCgUwvr6OlRVxfz8vOP9qI35fB75fB6PP/44lpaWUK1W2TXPPvts03qxd+9epFIpFqJKSJKEeDzuuPa5Ua/Xcfr0abzwwgtsTtJ4++GhFggEmEdLqVSCLMuYmJhgBsNSqYRz5841jSNx6tQpWJbFdMg0TZw7dw75fB5PPPEEzpw50zSOgUAAExMTzJORn3+8MYj0jaq9taJareK5555DrVZrSIzN6zUl+XZLwm9/hqIoTDZ8e6anp1kVNkVRUKvVkM/nsbi46HhfMn4KOudb3/oWXvKSl7B/pEv8Md6bZ3V1FcePH2/IFQQAjzzyCH7pl34JF1xwAW688Ub2ZfqKK67AM888g1e84hX42Mc+1vT8d7zjHXjDG96An/70p7jooovw5je/Gddeey1uuukmRCIR/PVf//W2qE4p2BraGToIsdnfoJ0c7PIbRY8hN0bRSNIq8fQo5tZxq4B48OBBnDhxYmTk4BVhGNpG8G9PyZBAYRLAxpds+sIdiUTYZoDc890oFApYXl5GuVzG6dOnoWkaMpkMXnjhhaYNgB0KBQiHw02GIdrcz8/PI5vNNm30aJPf6v79pFUogiRJDUaVWCzm+palXC5jYWEBpmmyykuKomB5eZlVLatUKuwfPxZU7j4UCjUYhmj8+PFMJBJIpVKIxWIIh8NNhir+MxkYeCNDOBxuaQwjL4WFhQWcOXOGtX91dRXZbNbV00RRFIyNjTVtDEl+qVQKwWCQ5T0hnXUKKcxms8jlcshms1hfX2d9ImMCGdJIlp0SCoUa3Krp/pqmsZAp0ulqtcqMBNPT01hdXW3wKMrlcrAsC9lsloUPVioVzM/Ps5Cndl/A+DEGNrzUnIx3/NiSNwgPyYLyAdVqNayvryMQCGB+fp61t50Hhpc2tloTgsEgcrkcFEXB0tKS4/3IC6VQKKBUKuH48eNYW1tDrVZjpdjJuMYzMzODZDKJsbGxJk+4aDTK5qeX0Fdd1zE/P4+FhYWGuUlhmr0iyzIz+lQqFciy3KDv5XIZy8vLrptfytW0vr7OPHbI8Dg3N4eFhYUmw5Asy0ilUkzHKZfS2NhYw9pM8olEIm2N47VaDWfOnEG9XkehUEA+n0cul2sKW9V1Hdls1tGDxz4eFOIGNOpWOp1m40h5tIrFoqvBybIsYRjqkpWVFTz88MPsH40bf8xLZbrXvOY1eMc73oFkMol//dd/xT333IPnnnsOv/ALv4DPfe5z+M53vuM4H2VZxle+8hV88pOfxK5du/AP//APeOKJJ/CmN70JP/7xj3H11Vf73mfB4CAMPp1hD4WxeziIfEwilIzHTV9G0UgGOOvAqBrJvCBe2WwjnEJN+FAD/rg9vMAeMkAhYhR2QCEa4XCYhb7Qz/x9nLCHMxCqqsI0TYRCoYYwGuB8ZR2nsJ52UDgLbar4vnjFy7kULmRZVsu3l5QfBtjoM3lzBYNBWJYFVVURCARgmmZTeJc9fMKtbfwbfx4K47P3nzwT+I1auz7LsgzLshAKhdiGS1VV6Lretv+SJDUZK/gwLbeQFrtO8aFCtKGgcyi0RlVVWJblWV/szyT9cQs/AjYMHHyYlmVZDV5dNG+ozaQDsiyzpLiqqrZtY7swG6/nkIz40D1KuEztoTnYyTxxeh4/ZnxInSRJCAaDbAzdvGH48DpZlhGNRlnYE11DhlEKT+PXMHtYWzeeBSQXui/1qVu9cro/tYv6Rv0l2VConxP8ekJzW1VVKIrSYDyxP9NpHXFbW/i54CZD+pvAz1W7jPi/I26yoFBNp3WKvw8P9b2V8cePsRpFbr75Ztx8882ez7/jjjtwxx13NB1/6Utfipe+9KVdtUFRFNx+++0srEwgIGjjOjc3h9nZWddQDrc3/aMGH3q3uLiI3bt3N8iB5EnnPPjgg03nDDsHDx7Eww8/3PAZOJ9X59FHH+34u9Gg4qYvbjIadkgH+GTc9913X8M5o7q2OCEMQ9sIMjDw1Ot1mKbZ8i15IpFouq5UKiEej7M3yoZhsCSRfDUg3nvBKexAkiTXcISZmRlYloXx8XFmLLG3nffesCfIa0WpVGLeMKVSqWWIVC9QgmTee8hOPB7H/v37EQgEsHPnTkSjUeYdQ0alYDDIjBr8Hx/avHeLpmns/nYoZ5RXuZJ+7d+/n23GEokE2/i7GQYp7G3Hjh2Ov69Wqywps9u1BIW9mKbJwsii0SjzjiO9tYc3dQKFjPE6E4lEoChKQ18ikQjLm1IqlTA7O8u8GyhsR5IkTE5OsrC/eDyOQ4cOQZZldo/NgOYgzUdZllnluIMHD7L2Oq0h3T6Lfi6VSkzfd+zYwYxje/fudbyexpR0/2d/9mcxPj6OcDiMvXv3QpIkHD16lFXja6XD/DrQCaqq4sCBA5BlGYlEgumgU76vbiE5UbU6mkOKomDHjh0tDa4HDx5kOkT6v2fPHkQiEVx++eUtPRg7pZUMw+EwZmdnWSgosGEY4tcbmjs0D5ygJPpuxkInpqenYZomcrmc4+9lWXZcUwQCwWDTztBB2Deyo+gJA3gzkDnlYxIb3fOQR8jx48eHPq+Mm76MopGMsBugR9VI5gVhGNpGOG3MKUFnqw2oU7iApmls4xKPx6FpGiu/DWwYLOybBbfQK7c/xu2qj5HBod39nahWq6x9tHHsx0KmaRoqlUpLwxBVWALOVxXyksMIQM+b9Fqt5vrWnBIhe4XaMj093VEbaPzdqj3VajXXftp1h8//Q+NLm8lwOMzClMj40A2UeJg3DPHPAM7rLnlRVatV7N69m21EFUVh11Ob6TPNxc2svsfPHZIL5XCamZlpaJ+fzwqHw8jn80gmk03hUm6Vrchbh9p58OBBNnfpGjIQtcuJxK8DnRAIBJhc+gXJifSD93xrVxmN2sbLk6qSHThwwNe1rpUMVVVlVQPdjHM0d/i5a6eVd5Qb1Ca38W/lpSQQCAYXr55AwhNmAy+b2FHf6LbSqVHzPGunC6NkJAM2+st7CwlaI/y0txFOYSBO4TheruPDaOxhJvZ/bvdodZz/nVMIHICm8LJOwlz4Pvdzc6AoStu30vY+OlWZcpNDN6E99va1kn873WjVj3bj53RdN210koeT7vEbwVb39NJPu1zc+kvPI48PpzZ1IzO/6aQ9vbTJabz4MLZO9cVtvvDHWulwJ/rdqg39GLNexqLV+U7hp73Qav3sZA3rdg1o9exW7dusuSUQCDaXTvK+iMpk3sqMt8tDNOy00qlRyzPUShdGLc+QWy6hUZNDJwjD0DbHqUKRF+whPBSusJl0EjrW6lp7X/yEwsK2K+Fw2HXjpCjKpoUytYKqDPkBjXsv+ipJ3ry5+Oek0+mu5tko0Ms8bkc7He7ns0cFL1XceiUUCnUd9iXGWCAYLToxYozapt4JLx4P9pLco5hMd3Z2FhdeeOFIeMG0opUujNp8EknJO0cYhrY5iqJ05TFj3+Tac9/0G0mSug4Fsl/bzw27qqodhbhtNnyyZjuS1JwQeivwkoTZK3xi5148hrzqDJ0Xi8V8M24NGzQm/aCVDveyhgg22CwZtlqnWiHGWCAYPToxYoy6J4zX6kmj7AFBMpqbm8Px48ebfj9qsmnV31GbT24GIPLCI2Oi4DwigH+b08vm2I/7EFTqm77EG4bR9gu9l2dS4l/TNFl1HKcQNL/QNI0l4iaoxDdVSuoWwzBQr9dRKpVYVaJYLIZCoYCxsTFomtZQyYx/VqlUYvKk0uqmaSIej7OqTbquQ5ZlFIvFphLVW4kkSay0dK+GKkmSWELoarUKRVFQrVZRKpVYkvN2/a7X69B1nekUJRy2V40rl8uIRqPMIETyHbRKSNTu5eVlTE9Po1KpIBKJYHl5GalUCpVKBel0GsViEZFIBLlcjiUKVlWVHa/VarAsC+FwmBnMKAcQL/d6vd40R7ul3T16fYZlWdB1nemlpmmQJAnVapVVKyuVSkin06yyFulLuVxmiZepeh/JmnLqUIJt0q12FQ63gm5kmMvlEIlEUC6XWWJ9AGw+UV+LxSKSySTy+TwkSWooOBAOh1GtVlkVRD4kEdjILdTrmisQCAaPTnK+eE1UPax4ldUo5xhqJ6NRk02r/o7afHKqSMYzavmWvDBYOyDBlmEYBhYWFlCtVlGpVJDNZn2799mzZ3H69Gnk83kUi0Xf7utEPp/HysoK+0yGqeXlZbb56RZN05DJZPD000/jzJkzOH78OHK5HB5//HFUq1UsLi6iWCw69nFxcRHVahWapmFpaQlnzpzBiRMnoGkaisUiDMNAPp9HtVrFc88911M7+4FhGKhUKr7ci3TszJkzWFlZwTPPPIPvfOc7WFhYgGEYba8vFApYWlrC2bNnUa1WUSwWUalUkMlkUC6XoWkaNE3D6dOnG0plV6tV6LruSx82k0qlAsMw8PDDD6Ner2NxcRG6ruNHP/oRVldX8fTTT8OyLLzwwgsol8t4+umncerUKaytraFcLuO5555DPp/H2bNncerUKZRKJXbvYrGIxcXFhuf1e476Cc1vIpfLoVAo4OTJkzh37hxWVlbw5JNPQtd1lMtlFAoFrK+vI5fLYW5uDtlslum1pmlYX19HoVDA4uIiVlZWoGka6vU6yuUyarWab3Ngqzlx4gTy+Tx++tOfYmVlBfPz85ifn0e5XGbzqVQq4dlnn4WmaZibm8Pzzz+Pn/zkJ1hZWWFr7MrKCgzDQC6XQ6VSgaZpzMC2tra2xb0UCARbQSdhHKPm7WHHq6y85CEaVtrJaNS8ZAD3sLpRn088QhbOjIxhqFwu4+tf/zpuueUWXHjhhQiHw4jFYrjsssvwoQ99qOVm50tf+hKuuuoqxONxjI+P47WvfS1+8IMfbGLrm7EsC5ZlOR7n/293j06eVygU2Jd6e0LAXsjn88jlcmyT1Um7OkXTtIaNIrDx5rpUKvX8XF3XUalUsLKyglwuh9XVVVSrVSwtLcEwDBQKhYYqTDSG9OadZFssFpHL5ZDJZJgXElXa0nUd6+vrrm1w0gv+M/9M/l8rvOgUeQz5Qb1eR71eRy6XQ6lUwurqKk6ePIlisejaN74fZEzL5/NM3vV6HdVqFfV6HYZhsM0qbwzUdR2GYTje036sExn2U5+p3aZp4uzZszBNE8ViEaZpso08bdLz+Tx0XcfKygoymQwqlQrTJ03TkM/nkc1mG6pE1Wo1FAqFhufxv3caj250rF/Y9ZKMgtlsFoVCgRmFaZ5pmsaMh2tra0xngPPzW9M0FAoFlMtlGIYB0zRRr9dhmmZbw2K7uej12m7xeo9MJsMMYWQwo/Wf5lO9Xsfq6ioMw8Da2hrW19exuLiIcrnM1tNyuQzTNJkcaY4ZhoFyudyXPgoEgu2P13wwo54LpBOjxuzsLA4ePIgTJ06MVI6hdjIapfxL7cLqRm0+tQrFHDVZeGV7+bz3kS9/+cv4zd/8TQDAxRdfjNe97nXI5/P4wQ9+gA9+8IO4++678f3vf7+plPdtt92GO++8E5FIBK9+9atRrVZx//334//9v/+He+65B69//eu3oDfny9gHg8GG0BcKdTAMo22eFQoJ8RI6I0kSEokEC5PwMy9PKpVCvV5nSYz7GVoQCoWakrEGg0HE4/GenxsIBBCJRDA9PY2xsTHIsoxwOIyZmRmYpolEIsFCzKrVKmq1GhvDSCSCYrGIdDrN5Fyr1aAoCgtXoUTUVNbaDm2CLcti1wBgIV6GYbBNPYVxZLNZTExMtAx/qdfrTEdaVRDyM9+RoigYGxtDLBbD1NQUDh06hEQi0TBGlmUhm80iFoshm82ykuqhUAiJRAKqqjaUn49EIlBVFYFAAJZlsTEiaC6USiWEw2EWhqQoCmq1GoLBILLZLKLRKAzDYKGPNIZOsqEx6WeeLGr33r17IcsyEokEZFnGnj17EI1G2ZpGYVGBQICF92iahmQyCUmSkEwm2fpB4ULBYBCJRKLheXxf+DWEDAGGYbCQPEVRoGkak/9mh+nZ802Fw2GWbDwSiSAUCmHHjh0wTZOFx5Hnz9jYGKrVKis9HwgEEI1GmUxUVYWiKExO7SockvcSJTwnw4hlWUyP3MrKA52t126QHrdb68bHxxEKhTA5OdmQf4tCYAOBABRFwdTUFJOVZVmYmZlhc0GSJMRiMbYOUi4yupd9HTYMA9VqdVOSZQsEgq2BNmrEsWPHWp7fLhRk2Okk9IeX7cMPPzwynkPtZDRK5epHqa9eaCUPMijOzc1hdnZ2pOXEMzKGIVVV8Vu/9Vu47bbbcPHFF7PjCwsLuP766/Fv//ZvuO222/DlL3+Z/e473/kO7rzzTkxMTOChhx7CkSNHAAAPPfQQXvGKV+Dtb387XvGKV2BsbGyzu8PebKdSqYaNT7VaRSAQYPlsWlGpVNgX93YoioKdO3eyPDh+GgF2794Ny7L6muSWSKVSDVVwaPMSCoV63rSGQiGk02lccsklLCdJNBrFi170Iui6zjZN5XKZeQRR/qF0Oo2zZ89iZmYGO3bsYJ4rVO1HURS24T98+LDj803TZG/o+bEvl8tIJBKo1WrM2yiTyWDnzp145plncOWVV7Y0DPH5j1pVSPNaCcwLwWAQe/fuRSAQQDKZxL59+5BOpxsSRFuWhTNnzmDfvn145plncPHFF0NVVSQSCUQiEZZjiPSKxpjGed++fQ16TMag1dVVNgbFYhHhcBjZbBZjY2M4fvw49uzZg0qlgunpaZajZnx83FE2pmmynFP9ggwuV199NVRVxczMDAKBAK666iokEglm9Eyn0wgEAgiHw0gkEqhUKlAUBbt27YIkSdi9ezcAMM81Mpja287PH/sasrq6Ck3TmFEuEolgbW0NwWAQe/bs2RLDEK+XZAS74IILmFEnFos1GPc0TcPy8jL279+Ps2fP4sCBAwDOz29ZllluHJIN3avVPCLdIjnQXCTDK63nbnSyXrvhVRcPHjyIcDiMw4cPN+QYCoVCzJBlWRYuvPBCLC8vY+/evSiVSiz3GVV6nJychKIoSKVSzOhPa7zdwE3hZcIwJBAML91sXOn3dO0obeA6kdeoGgVEjqHztOvrqOmIyLfUOSMTSva2t70Nf/EXf9FgFAKAnTt34s/+7M8AAF/96lcbwiQ+9alPAQDe9773MaMQALz0pS/FO9/5TmSzWXz+85/fhNZvwIcbkPcHfWGn31FYCSXwbeWaT+d4gTZQgUCAeRx4aau9DfbPkiQhHo8zbxq3alR+haOQdw7/fNrA9mqUUhQF4XAY4+PjiMfjGBsbQygUwvj4OCzLQiwWY2/NKXwtn8+jXC4jFAqhUqkwr4REIsE8YOjtOxmIksmkY2gTcD7xMi8r+kwhHRROV6/XWbhaK/jwKzfIi8CvcZJlGfF4HOFwGOl0mnm/2CkWi6jX68hmsyy8JRgMIhqNIh6PMw8Z0lnyuKD7k6HJsiy2caWcPYZhsPA9CrvKZrMsGTZ5fFFCczskBwovsoem+RVmRX3asWMHZFlmHinT09OIRCLM44UMY4FAgHmQUYJ0YMODgwwnlIiZ9JFvMz9H7bpWrVZRLpeZnlH+nWq12jbczk2nu5EVnWv3ZAuFQggGg0gmk4jFYohEIhgfH2cJ3mmOaZqGRCLBvJ1IPygxdzQaZR5YdB15w7Rqb6VSYceq1SrLp0U61Qp+TW/3zy5T/h5eSCaTUFUVyWQSkUgEsVisYf2neUVJ9ROJBMLhMPM+pDWWjJb2uUeGWr6NtD4JBILhpZvwDa+VuYaRTuQ1qqExXnIMjUr+pXZhdaOmI63GXuQYcmZkDEOtuOyyywCA5ZUANr7Af+973wMA3HTTTU3X0LF77713k1oJVjUIADNm0MaWwh8oiXKtVmPhZm54CSnoFtpY23MGkeGqUzRNG6hNA+UdIeyGtFqtxjZG5F3kBCV5JcMOnUc5nvj/abMVCAQa7keV0CqVCuLxOGKxGMbHx9lGrp33F93TS7WlfD7f9hwv5PN5VCqVBhlS7hyCQmssy8LOnTsdS1/rut6w4XaSIUEypFA+VVUbQoeCwSB27tyJRCKBdDrNjAS0YbZTr9cbKvnxz6Nk4pRLaTOoVqswDIOFblI4lSRJjkYJ0mHKC8OvP4R9DUkkEkilUkgkEojFYgiHwxgbG2sKA7RDuX+onZVKheWUymQyTJZe81h1mgONwuAolI48XWjs1tfX2xpV+DmvaZqrvMjjJx6PIx6PI5lMMp1qBYWhAhsyIv2hhPZOa4KdTkrDtzIG5/N59jcmGAxC13UWnqiqKizLano+f8yyrKa/UfawP4FAIADEBs5rPqZRTLJMtJPRqORfapdPaZSMZMCGPNzCUEfNSOaVkQklawX9kVFVFePj4wA2StdpmoapqSns2bOn6RqKi3788cc3rZ0U+kE5LejNLQCWMPX555/Hzp072SaHL9Vshzcs+Q15XtXrdebBAGxsaOitfCdQSXve22c7Q1W6aONsD48olUpIJpOsT24b2Ww2C8MwEAqFmKEtHo+zPDgUGlIsFjExMYFoNMo22bTJikaj0HUdhUKB6TJ5BOzdu7ftZiwWi3k2IC4uLrIwkm6xLAvLy8vQdR2xWIy1b21trUF3SJdM08SFF17IQm14arUaMpkMC38ir6JYLMZkSJAMp6am2OaWvGNCoRAURcGFF17IQmvIkysSiTgahiih844dO9j9aWOu6zqWlpYwMzODpaWlTQlHLZVKSCQS2LlzJ+bn53Hw4EGUSiXIsoxMJtN0PukweXqQ9wwfymRfQyYmJpinjiRJLL+MJEkt5zwl/w+HwygUCsxbKx6PY35+Hvv370exWHQMbXO7X6dGkFwux9bU/fv3Q1VVpk9nz57FoUOHWhpRKUeOqqoolUrMm4iXF78W0t8aklc7g3kkEkEul2MyymazmJ6eRi6Xg2VZTDb82mCXQSdhWrSG23XbsiwsLS1hamoKoVAI0WiUrUvVapXNNQrD5KFjpmkyo6lpmszjys9wVIFAsP3oJpRllEKBeDrNxzSKoTFeZTQq+Ze8zK9RCc1sN+ajnr/MDWEYAnDnnXcCAK677jr2RfrMmTMA4GgUAja+YI+NjbE8MfYErU4cPXrU8fjzzz+PQ4cOtb2er5hEmw6C3laXy2VYlsWq5bTabHjxAOkWei7fZjreSegMHzpHb6/pmJuxwh6q1u05vUAePnR/u6zJsABsjKVpmk3toMTFJEMaTxpfAA3/03PIy4MgDyIyEvJv5vmNqhud6AkfitkLFMJl9xDix80wDBa6Q5tS+gyAbbZ5LxN+XOzeECRDfjNNc4xkkEgk2uoffz9d19m1/PPIq880TV8r/LVrj2VZbGMeiURQq9UgSVKDjKhfvM7x1/P953XDyWML8KY/uq43hKfxidLJ04mOe+1rJ9Bco6TblGCc2l6pVBzXUl4W/Lzkwwd5yJgIdOa9Q9fy81/TNKZHABzXBKd7eKXV3w7y9qEQO1rPNE1j6wmFvpFs+DY5/Y1qZzwUCASDj33d82LkGdUNXKdGtFHLHwN47/OoyMbL/BJGsvOMipGsE0Y+lOzb3/42Pv/5z0NVVXz4wx9mx+kNdqs3mPT21V7OuV+0SpBM1bb279+PYDCIVCrFwmG2Aj6vC9/mTr2FKJSKEr4CjSEJdizLYhW/Wm1syPumX+FpVE3MCfJMi0aj2LVrF2KxGKLRKKamphrOo/AMSjpdKBSYYYfexJM3Bv9m3qk6EuUmsuNndTkAvni+BINBTExMNHgLARteTrzuhEIhVlmMl4GmaQ0bcrts+CpvPJ3IwoveUJiZ0/0pP0swGGwbQuQX6XQaoVCIVZuiNqqqiunpaWawoNAgmj9UyY3mcj/mTCQSYfKJRqMs3xGwkcCYZOk11KhTvY5EIkgmkwgGg+wZkiQhlUpBkiTmRWaHDLcAmCcn3c9pve7UGGSH5jvljqJ8Sclksmkt6HVutwofpfxplIMqGo2y0DvSo0AgwGRDBixqE593iORKxwQCwXDCe7QAGLlwp06xr4ft1sdRDI3x2udRkI3X+TUqoZlexnyU85e5MdIeQ88++yx+7dd+DZZl4ROf+ATLNdQvnnrqKcfjbp5EdlqVe6aN1SWXXIJQKISJiQmWIHQroA2SZVkNbe50s1IsFqHrOiKRCAtRoBAXt3sVi0WWZNrNCEVeNZqm9SU8jRLVOhEMBjEzM8MqedHGyG6ErNVqDUluM5kMq+TDJwwGGitF0Uaex63MPX+dH1DYVC9EIhHs3LmTJYMmxsfHG8YzHA5jenoaxWKRJTEHGkMugcY+8ptde1hNJ7IolUpt9YZyEDndPxAIYHp6GoFAwBeZeYGqqAHnPSFJR/fu3ctkTVXY6Eso9YFCyuwheH7Ay4Z+JuPerl27oKpqR5UDO9VrSkTN65ckSZicnIQsy9izZ4+jYahWqzUkOLeXYufb6xRS2inRaJTpOm+M4Z9lXxu6xc0IJ0kS0yXKyUXP5+cdeS+SxyKFBtK59oT/vPFfIBAMH/YNqFdv2VHxcLDjlAexFaNYfturN9koyMbr/BqV0EwvYz4qnmSdMLKGofn5eVx33XXIZDK4/fbbceuttzb8nr7Alstl13tQwlYvYWResLvd23+2GzmcfkebXn5D4jX0pVW7+Osp7Im/n/0ctw1cJ23gEy5TH/kKNm7wIVet7s2HFTn1gT/WaT9ahUXwb8ZpvCgkw95G3rhHiXH5e/P/8221y98pnI2/3i94gyA9l8eu205ytIdJEk5eUPwxvsKY/TyC5MIbLPnwTL6ik10PZFl21Bsn6Hpe5vZ2UFJwJ4ODvQ98eJfbZ2qb09yzJ/alc+h/3tBD/bSfS7QLqWqH07m8bOx6ajd8eHkuf79WbXMLzaXzaWzc3tRS6BmdT8/gddFtDefDR/m8TK2wr/P2vvKfnWRA7eBxk08rIxxfmY6fF25zjeYM/d5pfRShZALBcNPthnRUN2+dymsUcwwB8GToGQXZeNWXUQnN9DLmo2Ik64SRDCVbX1/Hq1/9apw+fRpvf/vb8cd//MdN5+zbtw/ARtJRJ0qlErLZLNLptC+GIf6LO+WOADaMAW6VeNzKZDtRqVS6blu1Wm3YDPIVcDp9BuWm8IKmaU1Vtrz02UsC00Ag0FS63skISMfouf3KCeP0bPL8Ifm3e5tOZejdjFmtjJz9wEkfKNTPz/bYS6HzniWUpL1V+/h2Uugi6XitVkOtVkM2m2VtplCeVlCSay84yaFWq7FwLnvoFt/eYrHIfl+r1TyHtbaTfTgcZl46dpz63sn64qceenmuXT/8bE8r/QI2jD+lUskx91Yul4Ou66wCWz9zTVWrVde1gc/n5BW73Gu1Ggu/JoLBIBRFQbVaFWFiAoGga0YhDMgPRiVEyM7c3Bzuu+++lmFAoyCbUas41g4vYy5k1szIGYaKxSL+w3/4D3j66afxxje+EZ/73Occ39JeeOGFCIVCWFlZwfz8fNPvH3vsMQDApZde6ku7eA+XarXKDCH1et11w+DVMESlmLvFbhjK5/OOpYidSl7boaTCXp9L4R10DSWibYUXw5Cqqk05YLwYhqjykN84yY7aSPJvFxrCl/j2+ox+4aZzVI2I9KWTRORuUMJ1gg+5JBm2ah8vl3K5jFKpxHScjENra2sN57Ybi3q97nmz7TQuboYhu1yLxSLbpNdqNeRyOU/PbLceRCIRqKrqGDLm1PdOdMtPPbSPvRNuiaP9aA/laHKDqgE66UImk0G9Xmf61q98Z8DGuum2NlCYVyfYZaZpWpPukWwqlYowDAkEgq4356O6eetUXqNoQPOaI8Yui2H9ezQ7O4vrrruu5RwZlbw6ozgf/GCkDEOapuHGG2/EI488gte85jW4++67XV3XI5EIfvEXfxEA8JWvfKXp9/fccw8A4IYbbuhLW1tVFKNEnrVajW1AKQkqJV2mECxy4+fDsijxMhmj+NAr2ozSZ77SDsGHR1B76Fm1Wq2h4ow9ETBd7wUKi6HwKb4vbiEXFI7gFC5hlycfNsT3i//My6Fd20luXiqv8ffm28X/TP0mnPplh8aPby9VdKIxokpdNG6mabLxcmun/V5O/SP9seucXb6d4EWWfDiOYRgNcrPL0N5ep2M0hnw1ON5jjP734v1G19O9+Hu69c9ejY3XQbsM7brpVb5uY0iQ3JzCiZxkSs8mTym7XvHVtJz6Zv+Zl5v9Hvbwz3b99sP46EYr/XJqB+kMeYLSHOTnjX387fDn2tcc+p29GqS9Hd2uyW73cronv27T507u22llOYFAsL3ppiLZKNOpvEbRgObVeEb5ZogHH3xwKA0iwnvqPF7mw6gYyTphZAxDhmHgrW99K773ve/hZS97Gb761a+2rXBz++23AwA+8pGP4Kc//Sk7/tBDD+Ev/uIvMDY2hltuucWX9vH5JVRVRTabRaVSYSFPPNVqFXNzczh16hROnz6NJ598EqdOncLa2hrm5uZQKBRQLBbxwgsvANh4qx4Oh1GtVnH27Fmsra3h1KlTKBQKME0TxWIRxWIR9Xodi4uLTaENdu+CRCLR8AerVCrhzJkzUFUVTzzxBOr1OjKZDDRNw+OPP97wJrxd6AVPOBxmCZqj0SjrB1XrakUoFGoy+vH9qNfrWF5eRrFYZBuQaDTaEALEGwDofnyyVzulUgmVSqXJw8oN8mTQNI15OTmFxlBoVLvwpWAwiPX1dRQKBTZ2lmVhfX0di4uLWF9fR6lUQqlUwnPPPQdN0zA/P49yuYxsNuvobcJ7rGiahmw2i/n5edeQFPKuozBAvj8U0sNXn2pHO88WWZaRTqfZ3FldXW17T2BjvtHzebmGw2FWrrxSqSAUCkHXdayurmJ5eRmapmFpaQmLi4t49tlnXZ+nqipUVWWeUSsrK6hWq1hZWYFlWUwu+Xy+aT4sLCyw/ESyLDcYgu3E43HW/lAo5Fh5zol8Pt9x+FAraO688MILeO6557C8vIxqtYpcLtewvuRyuYYNP3mPUZtI13RdR7FYRC6XQy6XQz6fZ14qvE7QutCKVkn76R79QlEUVk3NNE088cQTWFtbw+LiIjKZDMrlMut3KBRCrVbD8vJyy5DApaUlNr9LpRKq1SrzcJufn0e9Xsf6+npTeGUsFoMkSU1hjq3WNDdI5wzDYHPdTffayd8J8tLzGo4pEAi2N71UJBvFzVu38pqdncXBgwdx4sSJkZBTJ14hds/YYTOIdOs9NawG2rm5ubZ5lEbFSNYJI5N8+q677sLXvvY1ABvlj9/1rnc5nvfHf/zHrJTzK1/5Stx666248847cfnll+NVr3oVarUa7r//fliWhS9+8Yu+lOcGGt+mBoNBZLNZBAIBjI+PN32prlQqOH78OEzTRDQaxerqKnbt2oU9e/Zgbm6OlfA+e/Ys9u/fj0qlgnQ6jXw+j7Nnz2JiYgIvvPACIpEIIpEIC+lRFAWLi4sIh8PsC3kwGGwyViSTyYa35OVyGWfOnMGOHTvwxBNP4KKLLkI2m4WiKPjJT36CI0eONGxevUIGBLp2dXUVU1NTKJVKbUN5nEJgyuUySyqu6zqWlpawY8eOhrLLpVKJlTQnw1C9Xm+ocuTmZVYsFlllIlVVWyZSpZAgVVVRrVaRSqXYMXvfqAx1uw1sKBTC+vo6UqkUq4pGhqFCoYByucx0+/nnn8fMzAzOnj2LcDjM2m4vnU6GoWg0ynLtLC0tYffu3U16aRgGzp49i3379rHS1IVCgVUfogpwfH/aeVs4yYNHkiSMj4+z+6ysrHiu8kV6xcuVDKjRaBSZTAa7du1CNpvF6uoq0uk0otEo1tbWYBgGTp48CUVRHJ9H4UWUY2Z5eRnhcJjpcKVSQSwWQy6Xw/j4eMO1CwsLSKVSDYnJ6/U6LMtqMiLxetkurIknl8s1lA/vFZo7p0+fRqlUwu7duxEKhZDL5dh4K4qCXC7X0Ae+uiAZQyKRCAzDYMZp6jeFfvLzOBKJYHV1tWUVMnp+q7b3C0VREI/HIUkSdF3HE088wWRFxv9cLsdCHiuVCpaWljA1NYVUKuV4z8XFRcTjcQSDQZRKJaiqilKpBEmScPbsWUxOTmJ9fb1Br0jGkiShVqs1JCNvVZbeDZIZhaElk0nXFy3t5O8EGYZ0Xfes0wKBYPvSbUUyp2tHIfm0qODmndnZWUiShGPHjrXs67AnGvY6T0Yh+bTXeTDsOtENI2MYymQy7GcyEDlxxx13sM0zAHz605/G5Zdfjrvuugv3338/gsEgXvnKV+L9738/fu7nfs7XNtKXZwrhIC8ipy/VFGJFVasozIj+58NA+PvwISJO1Wj45/LH7M92aw9tMOge9vCnTjYIvDz4tnoJ33D6fbuqO2798truVuPVqo3UJ75KUTdtoPuQRwYZ9yg/Ez8WvB60a7d9/Fq9/ed/5zZO9opY7frU7vd8BSivngl8f+1t5v/RMarCROW4yZDqtfqefQztY28/16l9TuNkL4fuVff8rv7EV8vjZUeec4ZhMG+VYDDYJAf7z/SZP6+VLrVrmxudyKwb7Pfn5UNznuY9HzrXqk1OMrPrSqu1zUnOvfTJ7ZjTszvBKfxXIBAMJr1swOzXDmt+GB5Rwa09/OYfAI4dO9by/GEvWd+JzlDfSV+GTRadGMmGWSe6YWQMQ3fccQfuuOOOrq69+eabcfPNN/vanlbIsozJyUnmaWEnGo3ikksuAbDxtnfPnj2Ix+NIJBKQZZl59Ozbt495ZlAo0r59+xCJRBAKhdibWHrbHgwGsXPnTkSjURiGwTbDExMTLb/cx+NxHDhwAKqq4rLLLkMwGMT4+DjC4TCOHTvm2x9x8hzpJjSBvx7Y8OiYmZlBNBpteFseCoWYzAOBABKJRNuQQyIejzeVk3eDxoU8e/hj3SJJEqampqBpGoLBIJaXlxGLxVAoFDAxMYFwOMzGenZ2FuFwGHv37kUsFoOqqq6GMWpfKBTC+Ph4Q9UvHkVRsHfvXgCNYYAkz3A43LFnQjvPMDtTU1MdnW+HxoC89agNF198McbGxqCqKmKxGEsGzhuR3e4Xj8fZOE9PT0OSzlc1Gxsba9Iv8rYheB3tVUeIXbt2+f7lOhgM4oILLkCtVkMikWBeV+QBqaoqcrlcg4cVrx+81wnNPZITGcElSWrSiU51ZKuQZRmXX345JicnkUwmIcsydF1noVzZbJbliGsVErhr1y7mhUNrDlWQ27dvH4LBICYmJlwNNX564AQCgb4Y1ij0zWuhAoFAsL3pZQNG11Jo1YMPPjiU5cZ5upXXKHlAdGoEG/aS9Z3ozLB7lnmdB8OuE90wMoahQUKSpIa8KXbC4TAOHz7MPlMyZkmSWBgZ0BwqEw6HsXPnTnZeNptt2mjt2LGj6bljY2NtQzH27NkDWZZx8cUXQ1EUpFIpSJKEo0eP+uadwPejG/hcMoFAAJOTk0394jdNsix3tOnsdIPqFF7XLo9QK8iIt7CwwPINybKMcrmMAwcOYGJigo3FgQMHIMsydu7c2TJ/EW8YolClRCLhqA+KomDnzp0NfeLv240holN5TExMdPwMHkmSWH8plCcajeLQoUNNfZ6ammproKT5RQYQ8pahfjnJ0j4H7TLoRUfcnuEHqqpi9+7dAJpzpmmahkAggEKh0DBP+LlMIVfA+dw8fJ4c+p3dMNbPUDA/ofWRdIbC5WRZRjAYRKFQYEmjW4XGkXERON93MmjPzMxAluWWa7afhiHKu+Y3qqoiEokIw5BAMCT0ugFzyg8zzBu4buU1CmFCRKdGsGH3pupEZ4ZdFl7nwbDLoRtGJvn0IGEP8XH6PX0h50PJdF1vCN8hN/x6vd4Q2kVv3+3hLaZpNoUWeQnd4kPG6A0yXWN/o9xNtRk+xILCLCRJYtV96JxWiUrpGno+tZEqAgFgmzI+bM1e9Smfz7NqQjyVSgW1Wg2aprHKb636aZcxfwzYSNRcqVRQLpeh6zqr9ub0bP6efMJiars9ETc/XvQ/H/5jvydfDYrCtVrpJf2OHzMKl6GqSdQPPgEyjSclRqaNczv4Sl/0bErWbH+WlwpnvK7w/bKHmZGsvdyPD91zqjzHV5Gyy9euK3wfdV1nCcUpHxTJzd5Xp2fQfKhUKg3V60j+nVSrIgM1yUqSJOaJRusA75HH983eb15ufNiV05xyWicpRKtSqUDTNBSLRVY2vlQqNcypdn2ipOmky3zlr07g10PLsqCqKgKBAPPepLXcLiM7rdZofj5LkuS4XvDy0nUdlUqFJfeuVqsseT7936qCHX8vvhpau8pqXmTVKlRTIBAMFr0meR2VhLmESIrbHvKQmZmZ8ZSce9h1qBOdGXZZABv6cd1117XNO8UzCmGq7RDfuoaIpaUl9rNhGKxiEn+cJxKJNBgMvGzC/YCqC3mlWq0im80in883JMIulUqszbquY319ve29aLNIZDIZln+qVCpB07QGA1O9XmdvqnRdx49+9CNks9mmt1cnT57E4uIi5ufnWbJnpwpjXjl9+jROnjyJ559/HoVCAUtLSzAMA5lMpmU1qWg0inA4zDw0ALBwsU7lTtB1xWKRGR7aYVkWq0bFV0mjhLLZbBbVahXLy8vsGqrQ9Mgjj2BxcRHVahWPPfZY2817uVxmzyMWFxfZvam60draWkeGjn7NBycZepUrz9LSEnK5HJ5++mk89dRTqFarOH36NDRNw09+8pMmb4tqtdp0jKqmnThxgo0XVVEjuXqlVqs1GWfT6TRCoRCmp6cBbHiqdeupRAYwL9TrdVSrVZw8eRLz8/N44okn8Pjjj2NtbQ3PPPMMcrkcVlZW2t7HNE2cOXOGVW+sVCooFArQdb2h2mIn0LWJRAKTk5OYmZlBOp3G+Pg4JiYmsGvXrq7u60S79SKXy+HEiRN45JFH8NRTT+HMmTM4c+YMdF3HmTNnUK1WmSdTOyh5vq7rzAjXC7FYzBfvOIFAsPX0uhHt1Agw6HQrr1Gq4EYeMouLi57Kz3spXz7IdKIzwy4Lr9C6QnjRo2FHGIaGCD7BtmEYyOfzsCyr4TiP/c10txudTun0OfSWv1wuNxhkyKsGON/fdlB5eKJQKDADQKVSQb1eb9gEGYbRUL7+2WefZaW3eRYWFrC+vo6VlRVWAayTqht2lpeXmaGpUqkgk8nANE22KXUjFAohGAyiXq9DURRYloUdO3awalvdQB4T1WqVeZJ4gTyeyuUyk1c+n2ceLfV6vUE3NU1DqVTCs88+i0wmA03T8NOf/rSj9hGZTAbZbJZ5eem6jlwu15Gho1/zgfLItDvWDip3furUKZw6dQr1eh3Ly8uo1Wo4ceKE52dUq1WcO3cO1WoV5XIZlUqFGe46kVe9Xm/SzUQiAVVVWfXGmZmZrg1D/Hz30pZ6vY7FxUWsra3h5MmTeO6555DL5VjlNNKPVpimiaWlJaZfpKN2b7dOoGsjkQhSqRQmJiZYjrhkMtlzniyedutFsVjEwsICnn32WZw6dQpLS0tYXl6GYRhYWlpCvV5HpVLxpJskI8MwGuZ8t4RCId+q5gkEgsGmUyPAMDA7O4sLL7ywo437KHkajVJfvdCpsceLR80gMzc3h/vuu6/tWuEUpjrKCMPQkGCaZlNiX/IGcnONs4dg9CNXhBOdPodCLChkjuA/U/4WO05hEHyoF4W6UElspzAePuQunU47JmomT51IJMJCRLyGQZDxid6267rOnksl58mI55Ykmm8vhaVQkmg+jLAbSK/4ECGv1wUCAdYevmoY3YvXTUVRoKoq8zKhXFV2+FAeCnWhcChgw4OoVqshGAyyMTZN03MScb49/cBJhk5jSiE5blAy72QyyRLPU2J2SkDPQ2FG/JygMFNVVVEulwGcn0v2ioLd9Mse/taJ/tjxms+GjBikX6FQCMlkEqlUCsFgEPF4HIFAwLM+BINBFiZH7ehlPvEhX27//KLdeqGqKqLRKNLpNEsYTjpERQvaJZimED8K5SSd6rWimN85sAQCwdbR6yZ+lIwA5PUzNzeH48ePd3TtKIQIEZ32ddi9qebm5jrKLeXVcDKIdDLW9j3yqIeTieTTQ0K9Xkc6nW44FovFWEJSL7RKeOonnSZpDofDDTmLiGg0yja4qqqyKlI8pVKpKcFvqVRiVX/Gx8dRKBRYlSn7ZpiMPMCGoeOqq65COp1u2lQeOnSIGSLIqOHVMFSpVFCtVpHJZDAzM8MMQeFwGOl0GqZpYmZmBoqiYHx8vO2GdmxsDIFAABMTEw1eL92OLyVOpgpIXjbEdD4RCARgWRYLDQmHwwiHw00VqkKhEK6++mpWle/FL35x0waxWCwilUqhWq1CURRUKhVUKhWcO3cOe/fuxfz8PDKZDI4cOYJisYiJiQnUajVMTk52lLOkX/PBHsJJx+yGXQrzcjKOARsJpFVVxdGjR2FZFsLhMPbv349wOIzLL7+86RlUKa5YLLI5kc1moSgKJiYmcPbsWRw+fJhVZKP1wyt8Gfp+4HXdIENhNBrFzp07EY/HMTY2BtM02fwZGxvz3L/p6Wnoug5VVWFZFlsnuvVm6eXaTmm3XqRSKRw6dAjT09MIhUJsfgYCAaZLdoO8HcrVRDnucrkcAoFAz6FkAoFgeLBvtjo1WIhqW968OkYp+XSnfR3mRMOdVhkb9qpknYy13WOol2iPYUAYhoYEwzCaNjq0+WhV+phns6yknT6HPE9a3UeWZceNvKZpSCQSTcfoDXcikWAhM07t4jdEsizj0KFDjm3sJfyjVquhXC4jk8lgfHyceS/RBr1QKLAx9LI5ps2dqqoN4Rzdji9d1+n19s0vJdwlDxXydiFoA8vL+IILLmi6Ly3a1DdN01Cr1ZDJZFjoZLlcRiKRwMrKCqanp7G6uupoOGxFuyTA3eJUFcrpmGVZLTfXJDuqBAYAk5OTAIB9+/a5PoOfE+VyGalUCvF4nP0hJc+jTj2snOaon5D+tRsTSpIeCASYAYifn9R3r/lrkskkTNOEoijM8OuWrN0LvVzbKe3Wi2g0img0ynJA8VCFv3bjyieUl2UZlUoFqVRKVBQTCAQAGqslAegqR9AoGTx69WAg2dDf9GGWVScMs3GxU6PXMBvJgM7Gepj1ohuEYWhIsHty0GevG9vNctvv5jlu19hDvpywb7glSWKhEhS2QRsft0pbXtru9Lt6vd42DAMAq0QUi8WYZ000GmWhM516YvDn8s/vdoz9GjPeMOQkF6/PoTElryzytqES3bFYDOl0mhmgAHgaBy998IN2esYfa7Up77Y//Jwg77ZQKMTCJJ1CKju5f7/oZC3jqyT2Er7G34M/1ktfNzNEqt2z/GgLhYlSuB15GYmKYgKBAGjehHb7Rn5UDB69ejAMuzcI0Wk/h9m42KlxY9iNIZRUem5uDrOzsyOrF90gDENDAh/yBGx8WRcVXdDkRSXLMqamphq8ISiXht8Ui0WWdLcV5J1BOYoAYOfOnWyT5eRN4hWnsKWtgow23RhpeMgLgkIMp6amoKoqZmdnIcsy9uzZg6mpKRbOZg9rGxRIXn7Dz4l0Os3y7Vx00UUsV9F20Zlu4I0Sveo/GR5548cgy6Yf0PpE/09MTDADt2BrePTRR3H//ffjkUcewSOPPIL5+XkA6HhMstksvv3tb+Pee+/FD3/4Q8zPzyMUCuGSSy7Br/zKr+Bd73qX49+nm2++GX/5l3/pet//+T//J975znd21inBwOJXDo9RMXj0umkfdm8Qopt+tjMSDCqdGjeG3RjCeykuLi5i9+7dbY1DwPAbnb0gDENDAm1ciF7ekg8T5KFCUFJVSZIa8hP1Q1Zec2yQUY9Cl8izhuglRKdXI4yfkAdPrx4X5EFFfaPxnJychCRJLMSKkijznkODRL/azet7OBxmsuRD/7aLznQDn9+rV/2XZZnJi9aLQZZNP+CNQPy8FIahrePDH/4wvvGNb/R8nz/+4z/GRz/6UUiShMsvvxxXX301VlZW8K//+q945JFHcM899+D//t//i2g06nj9a17zGscchxdeeGHPbRMMDn7l8BgVg0evDLs3CNFtPztN0jysDKuRDOh8rRgVo7MXhGFoiGgVmkM5IDrNGzLotArb6TXEqh2dyNopZI2qk/XiobDdNrF+yNxt/Jzu3e8x7jf9aPcwyccNP/s1rDJqBeVg82qYHAWdGiRe+tKX4tJLL8WVV16JK6+8EhdccEFXm/FYLIZ3v/vd+N3f/d2GvGU//elP8cpXvhL/8i//go985CP47//9vzte/4d/+Id4xSte0W03BENCr4mn+etGweDRqwFs2L1BiG76OawGgG77NaxGsk7XCmF0Po8wDI0IpmmiXC6PnGFoK+k1fKlWq7GcSAKBQLBZ6LqOer0+kJ52AuA973mPL/d573vf63j8yJEj+NjHPoZf+ZVfwd133+1qGBII/Eg8TYyKwcMPQ9owe4MQ3Rg1htUA0E2/htVIRszOzkKSJBw7dqxtv0bF6OwFkR1yQCE3fcp74eV8USVmc+k1RM0wDBiG0XScxtzpn6AzhOx6R8ivmUGfm6Zpbunfi0GU2ahx2WWXAQDOnTu3xS0RbGf8Sjw9KvhlSJubm8N9992Hubk5P5u3bSCjxsMPP4y7777bcz/tG/5hMQB00y8nY9IwQLoxNzeH48ePe7qGjM5XX3310BnIOkV4DG0TOv0SrGkaQqEQCxFrl8yP8q0IBodW+VFqtRpUVUWpVEI4HIau6wgGgyIxbofUajVYltV1MkzBeaOzWF/OU6/XoSgKK+UOgOUQGwQURdlybyGxgdze0CbCKYcQ8dWvfhV///d/D8MwcODAAdxwww246KKLNquJgm2An2/ih93DAfDHkDaKcvLq+TOsXmfd9GtYvWSG1StssxCGoW2CaZodnV8sFhEKhWCaJiqVStuNLSVdFgwOrcrUF4tFJJNJrK6uYnp6mlVAE4ahziiXy9B1XRiGesAwDFQqFWEY4qhWqwiHwyiVSjAMA5IkDZSOBQKBLV9LSqXSlj5f0Jo777wTAHDjjTe6nvOnf/qnDZ/f85734Hd+53dw5513dlRU4ejRo47Hn3/+eRw6dMjzfQSDzShs+PzYrAs5tWYYw+y6CasbViNZN7oxCsZUr4hQsm1Cpx5DvJu/U7iRHaoWs9WIEIFm3EJO+OpK9vMNw4BlWdA0jYV9dGpcbNWWUUHXdV9CZrZCbt08sx/ttCzLF93bLvghI5qfhmH4pmObiSzLW24YGjSZjRKf/exn8Z3vfAdjY2P4wz/8w6bf/+zP/iw++9nPYm5uDuVyGSdOnMCf/dmfYWxsDH/+53+O//pf/+sWtFqwFfgZrjKsYUB+Mwpymp2dxTXXXIOZmZmOw+2GLcyu27C6YaUb3RjWsLpu2HpLgQAAHA0AraCExIMWIlav1yHL8rYwUm0X+ApA1Wq1bbJpSZIQDochyzJSqRRUVUU0GvVlI2eaJgzDGCid6oVwOOzJsNqOrdBr8krpBE3TWnqidYMsy0OlL93I1U4wGIQsywiFQj3nGhtVeh0DQX/453/+Z9x6662QJAlf+MIXsGvXrqZzbr311obPBw4cwLve9S68/OUvx7Fjx3DXXXfh9ttvx969ez0986mnnnI87uZJJNg++BmuMqweDjx+ePuMgpz4XEyLi4vYvXv3yFYl61ZnhlEWQHe6Maxhdd0gPIa2CZ0ahmKxGLtukELENE0Tb4Jt6LoOTdNgWRbK5bKna2KxGBRFwcTEBILBIBKJhC9GCV3XUa1We77PoBCNRnuuHgdsjV53E2pTqVR89+5RFGWoNvF+hDCFw2EEAgHEYjHE43G2Xgu8I2S2/XjyySdx4403olar4c4778Qb3vCGjq4/evQoXve610HXdXz3u9/tUysFw8zs7Cyuu+66odjAOuGXt8/s7CwOHjyIEydODKUHSbceHsPoGdKtzgyjLIDu+iWST59HGIYGFEpMLElSg6fIdg8FMk1zW7fPC93K2O06PhTHa1igoijMW4w8VTo1LtrbRD/3IyzIqe+dVtbzeu9OqkEpiuKY5JuXhZe2bYZe2/vjpiut+t2PsSV93E5rTy9tIbn2cg+an6Rfbjq2lWyn8bKzXUKfBec5efIkXv3qVyOTyeCOO+7A7//+73d1nyNHjgAAFhYW/GyeYJvi9+Zz2MKAnJidncWFF17Y0wZ12MOLujWGDGOYXbdGjWGUBTC8/dosxDevIaRSqWxbL6JgMDjwX/grlUrbcC8nTNNEvV5v8q5QFIWF93Rz317g+0Lt60eS3Hq9DkmSGiodkZ5Wq9WeKjbZQ380TYOqqizHSzf9MQwDhmGgXC578sbaLL3m53YrXXFbA8LhcF/DmrbL2tPtHAUa5eoltLNbqI1bFWZGOco2e80RDB4LCwt41atehYWFBdx666344Ac/2PW9MpkMAOERNiqIqmTe4fsHAMeOHev6XqOQgHp2dhaSJOHYsWMjn3C5m4TawyoLoHPdGPa1pROEx9CQ0Uk40lYQCoUG3jDUbaiJYRiOYVqqqjLjxWZvqvm+9NMwZA+1siwLxWIRlmX1HN5ULpcbrqf71et11Gq1ru5J4X3r6+ueQsQ2S6/58Wq1sXLT0Ugk0pVnmVe2SyWpXtpBcu33WlosFvt2by9s978Vgu1BJpPBa17zGjz//PN4+9vfjj/5kz/p+l6apuFb3/oWgN42vYLBwg8PGGB4Q18IkajbG7SJn5ubw/Hjxzu+fhjD7EbBk84L3erGsK8tnSAMQ0PIdg0PADZyIg16ItZew57sSJLE5LLZlYCc2tMvw4FbKFk/79vrWHk1WG2WXtur1rk9063f/W7ndll7emkHybXfoVbbQVbboQ2Creeuu+7CRRddhPe+970Nx8vlMq6//no88cQTeMtb3oLPfe5zbdePZ599Fn/1V38FTdMajq+srOCXf/mX8cILL+Cyyy7Dz//8z/veD8H2otcNvJ1hNnYA/vZvmHOm9LqJH7Ywu277M2xyALrXjWFfWzphsF03BE1IkrQtQjmGmW7lK8vytkvSy/eln+1zqoRFnhm9hjfZw3GoYptTXhevKIqCUCiEdDq95WW7ebzq3latAdtl7fGjHf0O7dzqUJqtCF0VbA7f+ta38OEPf5h9Js/Jl7zkJezY+9//flx//fUAgNXVVRw/frwp789/+2//DQ899BDLlXXLLbc4Pu9LX/oS+3lxcRG//uu/jltvvRUvfvGLMTU1hXPnzuHRRx9FoVDAnj178Hd/93cD/4JI0B6/w5mGOfQFGP7++UWv4YnDFmbXbX+GTQ5A97oh5t55hGFoCBFf9vtLt5tORVH6GsbTDZtpGOIhA6YkSX0xDJEXVrfhXZQwWFXVbTVmwjDkjUEwDG21rIRhaHhZWVlp+HJM8MdWVlba3ofyARmGgS9/+cuu5/GGodnZWdx222344Q9/iCeeeAJra2sIhUKYnZ3FDTfcgFtvvRXpdLqD3ggGlX6UgKYNG21qR3kD14phzpnS6yZ+2EqTd9ufYZMDsKEb11xzDebm5jrOuyTWlg0kS/iSbzlHjx4FADz11FNd34PCHjZrE8s/j1RIvAF0xzRNVkVuu9JpG/vZp83W517w0lb7OdtVH7Zru/qFn3o27LLbijnpx99GwfAi9GN7Y0+m7Idxoh/33C742bf77ruvYdN/9dVX47rrruu5jduFubm5nrw7HnjgAWY8uPbaa/vQws1jbm4Ojz76aMeJuOnaYfKS6WUODdPa0svfxu2/6xJ4opdEu91ASYOBDTf1zXz2INJrguXNoFKpdJRzpJ+Jhk3TZPo1CLSTBSWzJjqV9WZRq9VQr9e3uhmbil96XC6Xt+WY+oVdhwUCgaAVjz32WMNnPxK6DnOSWJF82hu95saZm5vDgw8+iMXFRTz44IMDnVvHj0Tc11133cAaQOz0MoeGeW3pBGEYGhJ0Xd8yw1C9Xh+5zWSnaJq27Q1D1Wq1ozb2s6KRZVmOFdy2K+1kYRhGw/zsVNabxSjOZb/0eJAMmd1g12GBQCBww2mj6odxYpgNHiL5tDd63cAPkwHAj74MU0WzXubQMK8tnSByDA0JWxHCQCEF9NxqtYpQKMRCKugcqu7kNYkvnS/LMvu/HyEMhmGw5/Wj1Liu66wKFHkSGIYBSZKYjGRZZhtxSZIQCARYn9uNZ6dydYMMFPY2Aq0rlHkZD8Mwuq6E5XR/y7Kg67rnxNL1er2vuZ3sIZXUNpIlP0f49m72fOV1Rdd11mZd16GqKiRJgq7rDe3qV+gQjYllWey5gUCg6Tmkl/0OXZJlGYZhsHlEOkvycpoPTnrt1M5O9N80TRiGwXSbxoOf373MJz+gtYxfd1qNE7UXwMCEhgoEgt6xb1A7zffhxjAniR3mvvlJr7lxhim3Tq99GbZcVL3MoV7yEw0T4lvakKCqKkKh0KY9j69+FgwGEQgEcOrUKRiGgWq12hBeRsc6oVgswrIslMtl6Lruu/eIZVkoFouoVCooFAq+3pvIZrMs9MI0TeYFU6vVkMlkWHjZ4uIiVlZWsLa2Bl3XPYekdCNXJzRNg67r7HOpVGo65oSXqkrdhtfIsuyYGNcwDKytrXm+TyaT6asHDOlmLBaDZVlYXV2FZVlNoZ1U5YygxNubCYVMFQoFrK6uolgsYn5+HpqmMbkGg0GoqgpgQ9b98IKhMalWq6hWq1hZWXEMUdqsENVYLNYQTkY/0//lcrmpLU567TSmnei/rutYX19nnwuFQpP8tzJcLRAIMB3m5dUqjLlarcIwjL6s4QKBYPti36BeccUVW9SSwcHPfC/DWIqc6NUbapi8qXrtyzB5T/XKMIUY9oIwDA0JiqKwDd1mIEkS2yQEAgEoioKFhQWYpsmMCmRYoGOdUK1WmSGlXyEM1WoVmqb1LVdOsVhErVZjnhfA+RwuhUIBtVoNpmlifX0dmUwG+XyeGXu8bP66kasTtVqNeU8BGyEx9mNOeKlo1O1mkNcvHsMwkMvlPN8nn8+3NXD1gq7rqNfriEQisCwLuVwOpmmiXq83PFdRlIbKbKFQaNMNQ2RkKJVKyGazqFQqWFlZQb1eZ3JVVZV5z/Vr3hUKBdTrdWiaxoykTs/h15B+QVXxeAMM5X+iY5VKhY0z4aTXThX9OtF/XdeRz+fZ53K53DS/va4N/YDXYb5fdtnw0BonwtAEAoEfDKvBw+9+iQ1/a2ZnZ3Hw4EGcOHFiaHSoG4YtfKqXeSTmzAbCMDQk9Ds0hTZpfAUyeh79TGXDKXSHD6PpNISAwhQURenqeq/PUBSlL2FkABpKnVN/SC7874LBIPPUsIeOtKKTc1tBoSkkaxq/dvrkRee6bZ/bvSVJ6sgASjLtFzSe9Ax6nl1+Wx1KBpwfi0AggGAwCEVREA6HWVtJrvy87se8I92nf8Fg0PE5/BrSTyiEk6B5QMfoMz9eTnrtNKad6D+tC4RTeB21ZSvg+8f3q5We9PI3QCAQDC792mQN6+bN734N24afxw8j2rAYGHvtxzB5TwG9zaNhnjOdIHIMCTxRLpdhGAbGxsYcfy9JEg4cOABFURCJRBo2AXSsE+LxOGRZRiwW85xPplPi8TgkSWrw5PCTsbExBINBSJKEWCzG5CBJEtLpNFRVhaIo2LlzJzPIBAIBxGIxT5uobuTqRDgcZqGBkiQhHo/7tgH1O2RKURRMTk56Pn98fLxv4wugQTdlWcbU1BTTqe1WoSoejwMAkskkotEoVFXFnj17EAqFIMtyk1z90i87NCakYzt27HD0tunnuNnhwyJJTnSM5i6PV73uRP8DgQAmJibY50Qi0fTcWCy2ZYYhezuIVroeiURYH7ZDuwUCweZg9/j1a5M1TPlhePzu1zDnK3La/PsRQjWIMvKjH8OUT6eXeURz5tFHHx3p7yvCMCTwRLucM5IkYXp6GgCaPDo6Nb7wYUR0nd9vm91ClfyEcjAB578kUT94DwW7sc2rrDr1nnGD94wAmr/Q9YLfMpZlGYlEwvP5tMnvF3avFmqbH55cfkNjwRt7eIOMXa798tghowLJyE2HN1OGvJ7Sz/b/3c73et92KIrCjNWAc6jmZhrLWsH3q9U48WMrPIYEgtGAcnUQ11xzjW8bz2E1ePSjX3QPMh4Mi6z8MKINi4FxWPrhF37MI/K6On78+FB4UXWKMAwJPNHOa6fb3/l5zXZ7ht/3pwTW/Bv4er3es0dVP+Xg9707vR9/vmmaME3T19BBe3jYZtHpuHfTzn71Z6ueTzmz7IYM+3Pafe6kbZ30wc/n9kI73fLSTi+/EwgEw4ndi8GPXIg8w+Th0E+GreIUz+zsLCRJwrFjx7rq07AaGLvBz6Tn24Fe1odh8STrBfEKT+CJWCzWd+8LQWuokhNPvxJnDyP9qrK1FZRKpW0XqrbdaVU9S3CecrnMStALBAJBp2xGro65uTncd999A5sbxk4/ct4MYz4mktPc3ByOHz++1c3Zcnod42HJtUT0ui6IPEPCMCTwiKqqW1JJSXAe0zSbwvk0TRMGAo9QGflhQBg4OofKpgtaI3RLIBBsZ4ZtMwv0x4gzjJtcv+Q0LDrU6xgPk/HQjzEdtmTc3SAMQwJPbEUVJUEjsiw3hcFQcmtBe+zVpwYZP3JLdcqgG9ac5o8XnAyym0mtVttU42+vurXZ7RUIBNuLfm82h2kzS/TDiDM7O4trrrkGMzMzvuZ52kr8ktOw6FCvhoxhMh4Oy5huNcIwJBAMCKqqNlVv4qsDCVrTrypbWwGfpHizME0T5XJ5U5/pJ8FgsKtk6Lqub2kIYrFY3NTnea2K6IYIcxQIRpt+bzaHaTNL9MNTgZKALy4u4sEHHxxYr5h+MCw61Gt+oGHykPFjTIfFk6wXhuP1uaAl9CVdeJYMNk5VorZLlaJBoF9VtrYC4THUOd1WOdsOHkObSa+6Ncg6IhAIeoc8Vebm5vqSKHpYEwf7LathTKTrV5+GQYf8Si4+LMnc/Vh3hnHOdMpw7JIELanX68jlclvdDIFAMMBIkjSShkhZlrfEEEd04+W0lYyijggEgvMIT5Xu8Duh9rB4xfDY/x4OQ5+6RYRONeLHujOMc6ZThMfQCFAul3Hu3DmMjY1tdVMEAsGAIssyotHoVjdj0wkEAl17G/nBoFWD3IowR4FAsH3o91v3YSzD3o8+DYNXDA9t/Ile8iYNgw4dPHgQDz/8cMPnbhmGkvV+rDvDNme6YaQ9htbW1jA9PQ1JknD48OGW537pS1/CVVddhXg8jvHxcbz2ta/FD37wg01qaW8YhtFU5lwgEAg6YZiSd3dCt0mr/UJV1YEytAQCgYFqr0Ag8Jd+e3UMo6dEv/o0OzuLgwcP4sSJEwPvuWWXiaZpvt1rEHXIr/xAw5JXx691Z3Z2Ftddd91IGoWAETcM/cEf/AFWV1fbnnfbbbfh7W9/O5588km88pWvxFVXXYX7778f11xzDb7+9a/3v6E9EgwGkU6nt7oZAoFAIBAIBIIhxU+vDjeGMdyjX30alk0/4K+MhlGHumUYjGR+rzt+h3UOEqP3+vf/57vf/S7+8i//Er/1W7+F//W//pfred/5zndw5513YmJiAg899BCOHDkCAHjooYfwile8Am9/+9vxile8YluHaUWjUezcuXOrmyEQCAQCgUAgGFL89OpwY1jDPWZnZyFJEo4dO+Zbn4Ypma6f4z4MOuRXOJyfIWlbhZ/rzjCEGfbCSHoMVSoV/PZv/zYuueQS/Jf/8l9anvupT30KAPC+972PGYUA4KUvfSne+c53IpvN4vOf/3xf20tYlgXLsmCaJkzThGEY7JjTP7pGkiSEQiHH33t5pmma/eyWoEPcxoSO8zpiWRYMw2A/d6MDowTNK5pbvAzt8t0M+W33ceJ1ifSM173t3v7Nwr5285/t6/iorrdO65dAIBgsisViw+d+Jc8fpnAP2ojOzc3h+PHjvt5beMa4M+hhdn55+gxDyXo/9XwYPKh6YSQ9hv7oj/4IJ06cwPe///2W1WYqlQq+973vAQBuuummpt/fdNNN+MxnPoN7770Xf/AHf9C39hK5XA7xeBzr6+uo1WoolUrYt28fgI28DqVSCZFIBLquIxKJsDwPmUwGkUiE3ScSiaBSqXhKJGtZFs6dO4c9e/b0p1OCrshkMpiYmGg4Zpom8vk8gsEg1tfXEYlEEI1Gce7cOaRSKTbekiTBsizIstygFwJgYWEBlUoF5XIZBw4cQLVaRSqVwtmzZ7Fnzx6srq5iYmIChUIB6XS677lnqtUqQqHQts3ZQmtSrVbDuXPnEIvFEAwGYVkW0zehYxuUy2Wsr6/DMAyk02lYloVyuYxKpYLdu3ejVqshkUg4zu1RwLIs5HI5hEIhZDIZ1Go1GIaxpfmdeuFDH/qQb/f6wAc+4Nu9BIJ+MTc3h6eeeqrhWD88hvjnDbLHB9FPr55h8Iwh/PbkGHTPkGHw9PELP0rVE6Mu15EzDD3++OP45Cc/ibe//e142ctehlOnTrmee/z4cWiahqmpKUfDyLFjx9g9N4O1tTWEw2EsLCygWCzi3LlzmJiYgCRJCIfDWF9fx8TEBCqVCkKhEGR5wyFsaWkJ09PTME0TkiQhEomgVCp5MgyZponTp08Lw9A2wjRNrKysNG0eDcPA6uoqkskkTp48icnJSUxNTeHpp5/GgQMHMDU1BVmWIcsy23CJTXsjZ86cwcrKCpPv+vo6wuEwjh8/jqmpKZw5cwaxWAyLi4tIpVJ937RWKhWoqsrm8nZjfX0doVAIpVIJzzzzDGZmZpBIJGAYBqanpwEIwxBRKBRw8uRJaJqGI0eOwLIsLC0tYW1tDRMTE8jlckgkElhaWhpJw5BpmlhdXcXY2BhOnTqFUqkEXdcH1jB0xx13MCN8L0iSJAxDgoHgscceazrWr03VoG/qeUZ9I+oVvw1owxBm50f44TDMJT7H0OLiInbv3t11H4bJmNoNI2UYMk0Tv/Ebv4GxsTF8/OMfb3v+mTNnAMDVKBKLxTA2NoZMJoNCoYBEItHyfkePHnU8/vzzz+PQoUMt2y1JEnRdh2EY0DQNtVoNtVqtKQTBKXyDD18gOvmyqut6wzXb1XvBDslhu26qe8EtzILGmXTFsizU6/WGUChg+4cobRW6rqNer0PTtIYwH13XG0LK6P9+0+9n9DqneX2r1+vQdb0pXEqwgWmaTE6GYQA4r2/83BzVECp76Cb93Rlkfv7nfx633HJL19f/7//9vwem+qlAYF/vd+3a1bdN1TBs6gk/vR3sDMOmn/DbgDbIBjl+XIHzjgrdMAxzye8++D0PB4mRMgz96Z/+KX70ox/hi1/8oqc3shQr3cqzJhaLIZvNejIMdUu5XIYsy6jX61hdXYWmaQgGgzh8+DB7G6+qKsbGxpinEG8MmZiYQDQaZfmGAO9v8SVJYoYx2vT1K2bcb3RdR6FQwPj4+FY3xVckSXLsk6IoSKfTiEQi2Lt3L+LxOCKRCI4cOYKJiQnEYjFIkgRJkmCa5lAazHpl9+7dSKVS2LlzJxKJBGRZRjAYxMGDBxEMBrFr1y6EQiFMTU1tiidDOBzu6zhpmoZAINB1GfqxsTGoqoq1tTUcPnwYqVQK4XAYpmmyNUewQTwex969e6HrOitWIMsyxsbGEA6HkUqlAGAkvYWADVmk02lEo1EWWjeo3kLE4cOH8ba3va3r6//pn/5JGIYEA8MVV1zRkKvl5S9/ed+eNcibejt+ejvYGYZNP+G3J0c/DXL9xs9xHYa55HcfhiVMtRtGxjB05swZvO9978PLX/5y3HzzzVvSBnvsNeHmSQSA5aFQFAX1eh3Ly8uoVqtIp9M4dOhQQ96YdDrNEk3zHgAUQsQTi8U8tVmWZZbHiN5uD5JhKJPJDKVhaHJysum4LMsstPCCCy6AJEmQZRkXXnghFEURhiAP7N27l3ktqKqKeDwOWZZx5MgRqKqKPXv2QFEUTE9Pb4o8+Vxh/aBarSISiXRtGEqn05BlGaurq7j66qsRCARYe4W+NUKGWsuymMEjmUzCsiwEAgEEg0EAG+v1KMKvX/v27WNyGVQuu+wy9rezW/bu3YtLL73UpxYJBMPDMIV79NN4Mwyb/n7RT4Ncv/FzXIdlLvlV1W+YvOy6YXC/dXXI7/7u76JWq+Gzn/2s52vi8TiADY8dN0qlEgD0zVuIR1EUGIaBQCAAVVUb8gjR7+1IkuT45drrZlOSpJYJuvuBXyFggxLy1ik0pnY5SZLEdICXHRny7OdT6Mawb+ApFNNJH+y/c9N12rTT7zdLZn4+h/pqn1sU+uX1Wbwekb5JkoRgMDjwHh6As750siY5yZLuZz/uJC+vxpBWej2IuK1fg8q//du/9XyPD33oQ74msRYI+ok9x1C/vVMGzcvDjX4abwbZK8aO3xv2QfamGhZjjh/4GVYHDLZe+MHIGIb+4R/+AWNjY3jnO9/ZcLxarQIA5ufn8YpXvAIA8Dd/8zeYmZlhb/vOnj3reM9SqYRsNot0Ot2zYcgtr4QkSSwEaHp6GoZhYGJiApFIZNMNNoFAYNO+sJdKpZ5lSqFVw4ppmtA0zVMScYKXq67rrILdMEPhUk7zpVKp9N0rZ7ugaRrzPCSPwVAohGq1CtM0PXsRUv6qcDjMju3fv39oZFgqldhLAfvxdmuSZVns+n7Lo5VeCwQCwWbiVGq9394pwxLu0c9N/iB7xdjxe8NuN8gNSjSE3wy6h0y/9WLUvOwG/7VcB2SzWXz/+99v+EeDX61W2TEyFl144YUIhUJYWVnB/Px80/3o7Ygfrt6tcnFEo1FEIhFMTU0xg9XU1NSmu9nz4Q79ppWXllcCgQDL5TGMUCLyTuDlahgGarWa383adlDZaycqlcrI5MHRNA31ep2tb8CGJ1S1Wm041g5d15v0Zu/evUNjGKpUKo7Hva5JfqxdXmil1wKBQLCZ2Ddn/fZOoc3sww8/jLvvvrsht9Gg0U8Dl9OmeVCxb9B73bCTNxXx4IMPDowe+an/g64j/dKLmZkZXHPNNQNlJPODkfEYctv8nTp1CgcOHMChQ4fw3HPPNfwuEongF3/xF/GP//iP+MpXvoLbbrut4ff33HMPAOCGG27wpX1UhUWW5YYQAfuGS1EU9tbefm4/6cczKIdSJBJp8EbywzNpmMIsnLD3z0toiVOIy7DTSiaWZaFWqzWEZRqGAdM0EQgEYJrmUIRHAeflwMuCwps61QNKRK/rekMo4zDg1g+va5I9VJOMN4Zh+BpuN2jrG3nF8vKhgggUfscfG1bK5TJ+/OMfY2FhoaVh/9d//dc3sVUCQW/Y37JfccUVfX3esIR79NtbY9i8H/zKI0PY1+BB0SORfPo8fodLDpOXXTeMjGGoW26//Xb84z/+Iz7ykY/g+uuvx5EjRwAADz30EP7iL/4CY2NjPZWj5clmszBNE/F4HMFgsMkjiPIZJZNJrK+vQ5ZlhMNhRCKRgd68/vu//zsuv/zyhlAWr2EtowyNP1GpVBAKhVp6kvFy5RMFDzOhUKjl/Dh37hx27tzJQvIKhQLK5TJ27tyJUqmEZDK5WU3tK1ThjDdwSJKEeDze0fqhqioWFhYQDAaxvr6OaDQK0zQxPT3dj2ZvOm5rj5c1iQ/9NQwDhUIB+Xwepmkil8vh4MGDvuWja6fX2416vQ7LstiaRcUMIpEISqUSYrEYKpUKTNOEqqoD1TcvWJaFD3zgA/j0pz/d0quMDGPCMCQQuDPom1mi3wYuClN79NFHB/r7nt95ZIhB1SORfPo8fhtyhsXo3C3CMNSGV77ylbj11ltx55134vLLL8erXvUq1Go13H///bAsC1/84hd9C1cqFArQdZ19KbZv8CnEIZlMIpfLsY39oG0Q7MzNzeHiiy9u2HgNe94bP5BluSEmWtO0tvlGeLkqijLQeuOVduGPq6urGB8fZ4ahcrmMbDaLmZkZVCqVoTEMkRzs60onOaqADb0pFotIpVJMdrquD41hyGntkSTJ85pE55E35Pr6Our1OhYWFrBr1y7fDEObFdbrF+RlRoYhCmWNRCIs15emacxzdthCPD/0oQ/hox/9KILBIF7/+tfj4MGDjrmsBIJBZCsSTw/yZpbYLMMEhRodP3584HLIAP3brA+qHvnd7kFOTC5yDPmLMAx54NOf/jQuv/xy3HXXXbj//vsRDAbxyle+Eu9///vxcz/3c748gypNtQrt4DfxZDziz7W76nuBwh220kBg91gY5LcawEbuj0AggHq9jmAw2Lf+2O/bLiTI/rtBkDOVju9FP1v1U1EUx+p+qqo2VEkaRPhQU8BZDt3oAFUgk2XZ0bNx0HGTSSeVHAlFUZisotGor8n7B2H+8tirsvGfFUVh842qvw1a/9rx+c9/HslkEg899BAuvvjirW6OQOAbW5F4eljYDMPEMHhAjPpmXeCO37oxqMZCvxiub/RdcMEFF3h6M3nzzTfj5ptv7ls7ZFlGOp2GZVmuHkC8R83ExAQrJU9frjVNa/IiaYdhGKhWq1v65vLYsWMNIVGDztraGiYmJrC0tIS9e/du2nMHPaTQiXq9DtM0++ZBFo1GsWfPnob7JxIJpo+DHNJYLpcRjUb7ohM7duxANBrFrl27EAwGh867ww9kWUYikYCqqrAsC+Pj4wOtT71i1xM+lDUej0OWZUQiEWYIHjbD0OrqKl71qlcJo5Bg6NjsxNPA4FdS2kzse4JBrL7ldx4ZYlD1qB/tHtQqf/3QDboHrW2DJI9e8bUqmaIo+O3f/m0/bzkyUG6KeDzeYOzhCYfDbMMaj8cRi8UaPFKo/HgnmKaJer3eewd64ODBgwMXFtGKYrEIwzCQy+U2dcPcT++krcIwjL7qZygUwsTEREMIXiQSYeFjg2ywrNVqfdO/sbExBINBpNNptm4JGqHws3Q6jfHxcezevXsgv5D7hT08WpZlNu9CoRDzRKM8acNm5D5y5Ajz6u03jz76KD72sY/hjW98I/bs2dNzovJMJoNbb70V+/fvRygUwv79+3Hbbbchm826XmMYBv7kT/4EL3rRi1hV1be85S145plnum6HYHtiX9dmZmb6/sxBr6REbEZ1NXuC5U6r2W4HKI/M4uKir9XDBlWP/G73IFf564duDLI8esVXwxBVFOE5ePAg3vOe9/j5mKGFrxrkFvbBh4XYz7UnlvX6zK38At6qv05Qnop+QMlRez2HNjluRgXLsvpi7ODlaBjGppeyJtlQVS/+GI9pmqhWq56MFt3odCe4VerqVC/7iRedczq3n/PaLqPNklMnem2fZ53I0Q+cZNRvOdn73E5euq7DsixUKhV2LR3zm3bzbKt0arP4nd/5HTzwwAM4depU35/14Q9/GO9973vxta99DfPz8z3da3V1FVdddRU+85nPIBAI4PWvfz0SiQTuvPNOXH311VhfX2+6xjRNvPnNb8btt9+Os2fP4vrrr8fRo0dxzz334MUvfjEeeeSRntok2F48//zzDZ+Xlpb6/ky/S1RvFZthmBgGWfVLToMqG7/bPagGMqA/bR9kefRK1zuuK6+8Er/3e7+Hv/zLv2z5BujUqVNYWVnp9jGCDgiFQm2TD9tRFGWgvCIqlUrfDB5U9a0V5XK57aZpfHwcqqpix44drpubYrHYVRu9UqvVUKvV+voMO6VSCZZlQdM0tjl1kpdhGFhdXfV0T1VVR9rLAjgvV6/nEn7ntNkOdKrXvDz6Pee2C3yfa7VaSyM06dbi4iL7XCqVNs2zZZR45zvfiVtuuQUve9nL8KUvfalng00rXvrSl+L9738/vvnNb2JhYaGnNfS2227Dc889hze+8Y04fvw4/vZv/xZPPvkkfv/3fx9zc3O4/fbbm675whe+gK997Ws4cuQInn32Wdxzzz34p3/6J3zlK19BuVzGr/7qr3bs3SzYnszNzTXp8mYY4CkPyNVXXz0w4T9ObIZhgmQ1OzuLCy+80Pf7bwb9ktOg6pHf7R5UAxnQn7YPsjx6pescQ5VKBZ/97Gfx53/+56zksSRJePbZZ/HQQw/hyiuvHLqkpNudbjwEKE/RoEAJnfuBF/daTdPahs1QHpFEIuFqGOq30WazvYWA833iv/BrmtZUhck0Tc+b9H57DA0CnegKr8ODNK+90qle8/LYbEPpVmBZVkM/dV1v6XlD4Yb5fJ4ZdUd9vvWT3/7t38Z3v/td3HLLLS3PkySpJ8OJX17aCwsLuPvuuxEMBvHnf/7nDd/pPvGJT+Bv/uZv8Nd//df4+Mc/3lCV8FOf+hQA4OMf/zh27NjBjr/pTW/C6173Onzzm9/EN77xDbzpTW/ypZ2CrYPKRPNcccUVm/LsYcgD0q/cOU4MemWy2dlZSJKEY8eODVzb/cbvfECbqYf9wG/dGOUE1F1/A3zyySeRzWbx3e9+Fx/96Edx7bXXwrIs/Mu//At+4Rd+AWNjY/ilX/olAEA2m93yPDaDgv2LfSd0434/aC77gUCgbxuXbjbSTmFhXkIhvD5L1/Wu8uxQxbrNhPrEP9upn5IkeS6R3m/93Ozwom5opSu0XlA/+HPtsqMwzH7mHuo3neo1Lw+/DWWGYbC8bqZpolQqoVarIZvNMgMWeThtlrzthn5FUVq+MKBzY7EYM7p3EupKfbMbeum4ZVnIZDLI5/PIZrPQdX0kDHROPPTQQ7j66qvx9NNPA9jwLN23b5/jv80sWtCK++67D6Zp4mUve1mDgQfY8FC+4YYbYBgGvv3tb7PjJ0+exDPPPINIJILrr7++6Z433XQTAODee+/tb+MFfcfJW2jXrl2btokahjwg/cqdY2eQQ2NonJ2q3/l170HSoX60ebP00G/6qRujSk87x3g8jmuvvRZ/+Id/iK9//esAgBtuuAF/9md/huuvv56FmH3jG99AKpXCy1/+crz//e/H/fff33PDh5lRCXnohn5W3uomga5pmiiXy317VrVaRa1W8xTmxkNJXDeTWCwGSZIaQhrpGE8gEMDk5OSmts2NTsK0tgonGfIUi0WUy2WYptlSryqVCnRd9xQOuV3pVK95efidILter0PTNCbX5eVlFAoFnDp1qiGUslAo+PrcdvCVz0KhUEsPy1gsBlmWMTMzg1KphFgsBsMwUKlUPD3LHopG0N8wy7Lw3HPP4fTp0zhx4gQ0Tet4LRsW3v3ud6NUKuGDH/wgMpkMVlZWcPLkSdd/24Gf/OQnADYqhzpBxx9//PGma37mZ37G0RjrdI1gMHEyLrz85S/fsucPkrGD2Kw+DHJoTD9lNIg6JHLqnKdf7R5Eg6FfdG0Yordednbs2IF3vvOd+Nu//VucO3cOwMYXgZtuugmnT5/GRz/6UVx33XXdPnYkGAXvKqdE5V5wq9jmB+2qejm1l96uU3/c/vFQ9R0vkMdQp2EF7TwF+gH1iby6LMty7Kcsy8xjyE1GRLd64pVOPYa2wqDSTi/r9TrrR6tzKakweWz0oy/9Hi/Say/PIe8ZOo9kQ5/bzdN2UGJnkmu5XEa9Xnf0GNos7GtLJx5DtVqNeQx5TUBNf6vsxh46bvcYMgxjZD2G/u3f/g0veclL8MEPfpBVPdzunDlzBgCwZ88ex9/T8dOnT/d0TTuOHj3q+M+e9FiwudhfYh49enRTQy4G2dhBbFYfKFRoZmYG11xzzUCFxvRTRoOoQ5uRU2dQcnv2a/wG1VDmB10nAfqZn/kZJJNJXHnllXjJS16Cq666yvXcF73oRfjCF74AYONLg1NMsuA8w1S63Y16vT5wOVAsy3KsrBMMBmGaJkzThKZpiEQizKBTq9WgaVqTG75XVFWFoigDIyvaXNLPoVCIHbMbLAzDaMil4fSHiOTar/63M7rYcevLVhIMBj3l3iGjaigUYrLvRx44Gvd+0y7fmGVZWF9fRzqdZuNFhrFQKIRqtQpFUSBJEgzD6Hhc6VrKgxWPxxEKhTAxMcGMMSTr7UytVmPrFeG1nDHJ327ooOOSJGFqagqhUAj1eh2BQGBgvnD6TSKRwAUXXLDVzegI2vi7hf6SdxrvFdfNNYLBY25uDk899VTDMb+9MtsxDHlANqsPFCoEAIuLi9i9e/fAyKuf+W8GUYf6IQ+6J+nIgw8+OFA64jcHDx7Eww8/3PB5VOh6V3DHHXfgxz/+MX70ox/hu9/9Ltsw33vvvfid3/kd/OIv/qKjS+m+ffvwa7/2az01etjZ7D+uW0GpVEIymdx0r5ZeME2zyTBE3i9U5nl1dRW7du1CuVxGqVRCLpfD6upq14ahUCjUtw18PygWixgfH2ceFKFQiB2zQ4luKRTPacNIcu2XYSgajXZkDHDry1YSj8eRy+XanhcOh5m+Ul4cv/XKsiyUSqW+b/4pp087w9Dp06eRTCYbvAypfblcjlVuK5fLSKfTXeUvsiwLsixjenoagUAAF1xwAWuX11xaWwlVIuO9Er2Ge1GYo319o79hkiTh0KFDzIOwm8qZw8JrX/taPPDAAzAMY6D+7m0H7AYI4ujRo5vcEgHx2GOPNR3bis3TICbK5fE7ibAbTh4QgyK3fhu1Bk2H+iUP+wuhQdCRfun1IBoM/aLrmJwPfOADrBTqmTNn8JWvfIVtCj73uc/hP/7H/4idO3dCkiQ8+uij+PKXv4wXXnjBz7YPHeS6v52/OPsVJmIYxpblOfESQtLuHP6zoigwTROGYUDTNJimyZKslstlT5t2NwKBABRFGQjDEIWg0M8U3uQWBkc6oOt6QzgeD3kM9QtVVTsyDPWzxLKXMEQ7nVQVpBA/Cq/qlyfLZsiInuM0L/lzisVi0zkU5kRGR9M0Ua/XO9YzCtMiuUYiEaiqikQi0ZB8vVMd8xNeFm56RbmSeH3wGkpGfbMbwOi4JElIJpOIx+NIJBID5f3oNx/72McgyzJuueWWnv4mbCZk4HPLo0cGRL7yZDfXCAYPe9Lp8fHxLdk8zc3N4b777hvIHCCbmcdkEEOmiM0I6xkkPeqXPAZRR/rZ5tnZWVx33XUjZRQCevAY4tmzZw+LG//lX/5lfOITn8A//dM/4YEHHsBnPvMZPPHEE/i1X/s1SJKEffv24eUvfzm+9KUv+fHooULTtG3vZk9t7HWjs5XhOPl8nm1kqD/2zYqmaahWq0ilUqzkMyVWJoOGqqqo1Wos3AsA2/yEQiFm1NhOYUf9xDRNyLIMXdfZRrNUKkHTNBSLxaaNgGEYCIVCTOdzuRxSqVTDOdvtzXo/5ycZ0yiHDhkbvXiddDonKQzKb2iO9Avy9iEDgz1sjRInRyIRmKaJqampJi+gcDgMYCORfTAYZEadYSzTTmtXIBBAvV7H6uoqC60jOQCNCc4jkQgLNRT4x3ve8x686EUvwl/91V/hG9/4Bl784hdj9+7djnonSRI+//nPb0ErG9m3bx8A4OzZs46/p+P79+/v6RrBYPHAAw805RfaioISZFgBgIcffnjgSrBvphfPIJcjt3+n8NtgMWh61K8wp0HVEb9L1fNslkffdqIvbgipVAo33ngjbrzxRnzmM5/BW97yFrzjHe/A97//fTz44IP4u7/7O2EYcqBYLG57w5BfbaQQjq1geXkZO3fuBABkMhmk0+kmw1CxWMT6+jqSySQ0TYOiKAiHw4hGo6jVajAMA6qqolKpsE0qVdtSFAXRaBThcBjJZBIzMzNb0c1NR9d1KIoCTdNQKBRY6W6+Yhaf64XyTJHx5/nnn28yDJFctwv9DPM0TROVSoUlAKbExV4MQ53OJz4ps9/wVbH8Zn19HRMTE2x+VSqVhvWoXq9jfX0dU1NTsCwL+/fvbzIuUvtSqRSTWTAY3HZGSD+o1WrMMFSpVDA3N4dLLrkEsiw3GIbGx8fZ3EwkEgMRAjdo8N95crkcvvvd77qeu10MQ5dddhkA57Ah/vill17adM2TTz7pmEvQ6RrBYPHEE080Hbviiis2vR2DHB4FNBs8+vn9f1BzDPHtBtCXxNmDqEf9MIYMmo7wBj3AvXqmH/cfBIOhX2zKjisajeLVr341Xv3qVwPwnthy1NiMJKW0Gez2bbBfbdzKzT6FjVDiY6cQEr56DnlvAGC5MugzeQ/RBpM2l8PofdAOkgN5upDxx62qGiXzJl2o1WrsGLHd5NhPvaXwLtIvCkn0QqdGDS9ydVor2q0f/c6HRSFOkiSxEE4ePoTRNM0mLzW+faMQ0sSHjZmmiXK53BTGS+GIpBOBQGBbGWOHhQceeGCrm9Ax1113HWRZxj//8z9jeXkZ09PT7HeapuHee++Foih47Wtfy44fOHAAF198MZ555hl861vfwutf//qGe95zzz0AgBtuuGFT+iDwl7m5OWQymYZjm12NjBj0BLFLS0sNn/u5NxpE4wfQ3O5+yGiQ9KifxpBB05F+t3fQ5OEXvn77O3nypKe48e3uFbNVRCKRvj+Dwiy6ZTPa2G/GxsZYDoxEIuG4QYxEIkin0wDO58vQNA3BYBCBQIBtjEOh0LYzXmwViqKwEMFYLMaMiE4bdKBZl/jqUaMIVQwLBALM+LGVukWGKX69djq2mSQSCWa0cApbCwQCSCaTTIajjn2t2rt3b1PC9XA4PNLzbrNwKsaxXbjrrrtw11134Q1veAP+x//4H+z4zp078da3vhX/5//8H7zrXe/C3/zN37D59+53vxsrKyt429ve1mAwAoDbb78dv/mbv4l3v/vd+Lmf+zn2+69+9av45je/icOHD+PGG2/cvA4KfMO+Wdq1axduuummLWnLICeInZubw/HjxxuO9dMgMUjGD57NaPcghVD101gxaDrS7/YOmjz8wlfDkFPM+AMPPDAyoTS90s8QDKJcLvdk3NmMNvabqakp5mExNjbmuPmOxWKIRCKsHD2w4f5Pb9Ppy/Gw5ibpBkqUDTR6Y9Tr9SajDxmP+GPdVm4bFijXDclEVdUtNcRSvh6nHD5bZRjiK4cpitIkn0AggPHxcTEn/3/4qm3hcBiHDx9uquQ2DGu6oJFvfetb+PCHP8w+k/frS17yEnbs/e9/P66//noAwOrqKo4fP46FhYWme33605/GD3/4Q/z93/89LrroIrz4xS/GU089hSeffBJHjhzBpz71qaZr3vGOd+Db3/42vva1r+Giiy7CL/3SL2F1dRXf//73EYlE8Nd//dfCK21Asa/9hw8f3qKWbECbYtowb+dNPY99g99vg8QgG9H6zSCFUPXTWDFoOtLv9g6SwdBP+v6XeTu/JdtubEaOi14rPA1DHg7eaOG2gaSKQ8D5sBnTNBvCxui8raLXsEC/oQTdAJpk5LQJsMtuFEJ7WkHhUduFVhX7vFwL+K+bvB7x+kbIsiyMQhy8LMjwaGc76ZzAH1ZWVho2DwR/bGVlxdO9Jicn8cgjj+COO+7A17/+dXzta1/Djh078J/+03/CH/3RH2FsbKzpGlmW8ZWvfAV33nknvvCFL+Af/uEfEIvF8KY3vQl/9Ed/hEsuuaTrvgm2Fnsoz1anhhjUPCD2Df5m5GgaxM3tZoTzDFLI0GYYQ4DBM7T2g0EyGPqJ+AY9YgxDKNhWEQ6Ht9Wm0zRNVKvVrW5GW4TODSZUXY+Hwt3aMSi6KRD0i0svvRQf/OAHe7rH/8fem8dJTtf5/6/Ukbqru6vP6blnmB5g5BpcDkFg8YAvKCwroKxfBVlP1B8reH/VZV1dcVFZPFZxFdQV8RhBBXaRVYZDWEYZVnBwmIY5eqZ7po+q7uruupJUkt8fs+8PqXSqKlWVqkqq83w8+jHTqVTyyfvz+aTzeeV9fPrTn2bJnGvhmmuuYcJuuZ9rrrmG7X/TTTdBVdWyRUESiQS++tWv4uDBgxAEAQcPHsRtt91mKAoRXq8XN9xwA3bt2oV8Po9kMomf/exnrijkcPTVyNqdGqIVpcybAXkjDA0NNSWhcjmcVJYdaE0JdSeWaW8WJLTu2LEDd999t63HSbPb6tR7S6PYZ5Xr0hLcsIH6sVvYmFMW3+6YcyZUia/aNiNkWXbE2HRxaRa7du3CoUOHGjrG+Pg4du3aZVGLXFwaY3R0FM8//3zJtnZ7DDl1UU/eCJOTk3jsscdasgB30qKfIA+Z008/vWneYK04h1W4YsjLNLutTr23NIob5G0jZFlmoREcx5WEY+hDJorFIkuwqg9vqoSdhA2nYVfbUQUm7ZgBjrbXDmFmdrQb2YsqWFHoYC1zqdPR33dUVUWxWITX62U5S7xeL4rFInieZwmz7TDm2oG2ihxVP9N6aCz3nCrFYpFVLfR6vSXV0bxeb8m8KxfG6DReeukl/OAHP2jo+y4udkFbNpxo92LJqXlA2hG+5KSQqVbjlBCqZvehkxIuO6mtTmJ5P6naCEVRkEwmEQqF4Pf74ff7kc1mARwNYdK7687MzGBoaAiqqqJQKCAcDrej2S5txOPxIBgMQhRFzM/PIxaLQRAESJIEr9eLSCTSdjdvuyKKIrxeL1544QWIoohVq1ZhcHAQuVwO0Wi03c2zJaqqYmJiAr29vdi/fz+8Xi9WrlyJF198Eaeccgry+TyznVnPok4in8/j4MGDAI5e/7p161AoFCBJEgqFAoaHh5etaAYcTXAcDoeRTqcxODiIZDIJURQhSRKGh4eXzLtcLtemllrHE088gSeeeKLu75PY6uLSbkZHRzExMVGybXh4uO0LaKfmAWnHotaJC+lW5ZBySq6qZvehkxJQN1sUXq5CqisM2QRVVZFKpdDd3Y1wOAyPx8NiuY3yeiSTSQwNDUFRFOTzeVcYWoaQMJTNZjE7Owu/34/FxUUIggCfzwee511hqAyCICAQCGB0dBS5XA7BYBADAwMl4oZLKYqiYGJiAqFQCKOjo+B5HvF4HLt27cKJJ55YIqrR2FxO5HI57N+/H6qqgud5rFy5EtlsFrlcDouLixgeHm53E9tKKpWCoiiYnJxEIpHAzMwMFhcXkc/n0d3d3XHCUKP5hVxc7MSvf/3rJdvsUFzGqYu3dng6OdG7qlX965Rx1Arhxiljo9misBOFVCtwhSEb4fV6S0IxKr0p1FaS4TgOiqIwV3wKk6HvUwgIufGTKz991+PxQJZleDwe5r7v8XhYWIRRtSht+FKzQ2/IK4rn+bIVdFRVhSzLzIZ2hexMYV/UZgoN1IfuaCuhaUMvqH/1fa79nUJbFEWB3+9n/QlgSRhiJZtZYVv9mLQK7TVobWs0nmVZZnbWhvxQGIsoiiVV+/R9pQ/TM9qvmTRzjEuSBI/Hw8LpJEliY8bn80GSJBSLRdYGn8/HKoDR/YHjOBQKBRYypa9Qp71PNdtW9fRJufsmzRW6DhoLoijC7/eXzGHg5bAo8vbQVkqrNg9ojPr9frafLMvsuI0gSdKSe4xV0P0GONpOSZIAHL3PaPucxg9tox+jNtn5Pm4GVxhy6RS2b9+O2dnZkm128BYCnLt4a4enkxO9q1rVv04dR81gdHTUER5DzRbzSITbuXOn459HasFNpmETPB4P+vr6EIvFEAwG4fP5EI/HEY/HDb0+BgYG2Pd4ni9J9JrP55eUpZ+ZmUE2m8XMzAwOHjyI+fl5JJNJLCwsQJIkzM7OolAoYH5+Hvl8HqqqYnJysmxJW1VVkclkkM/nLbSCMcViES+88MKSahhaKBTP7mjfgquqimQyCVVVMT09bbh/NpvF3NwcisUipqamMD4+jvHxcUxOTiKZTEKSJCiKAlmWEQwG0dXVhUgkAo/Hg3w+j1QqhUOHDkGSJExPT2N6ehqTk5PM04zCFStRLBaRSqUaum4KGbEaRVGYTbXXQmNYe97FxUWMjY1hcXER8/Pz2Lt3L4aHh3HMMcdgYGCAeXsQ2uPJsox8Pg9JkpZchxkbWkUqlWJCgZVMTk6WjE3tmAGAw4cP4/Dhw+B5HrlcDscffzxWrVqFeDyOU045BT6fD5FIBLt378bMzAySySRmZ2cxNzcHSZLYPalVXiD19Ekulyu5b9I9pVgsltxfae6Mjo5iYWEBhw8fRjabxcLCAnp6ejAyMoLBwUEUi0WEw2H09PRgaGgIgPG9Wcvi4iIOHDhQsl82m7VkjDVr7ABHPfDm5+fZOSYmJnDkyBFIksTuU/F4nAldgiBgYGAAw8PDWL16tWGCejdpvYuLPdi5c+eSbXbwFnIy7Ujy66TEwlpGRkawefPmpoZ3OSUBdbOTTzspQXmrkkOPjo5iz549treHVbjCkE3gOA49PT2IRCLgeR4ejweRSASRSMTQYyeRSLA3yn6/v6QyRKFQKFl8qKqKubk55HI5zM7OYnJyEouLi0in08hkMpBlGfPz8xAEAdlsFoVCgYW26d8SaY+Zy+VaUpFClmXs37+/4qJSURTMz8/bPmGpVkhTFAXpdJrZutz+8/PzTJyZnp7G1NQUkskk0uk08whSFAWBQADRaJRVTxMEAel0GpOTk5BlmS3UKaRDEARTwh6Nj0YQRbHEY8kqVFVlY1B7LSQMkacLcHThf+TIEeRyOWQyGYyPj6Ovrw9r1qxBT08PJiYmSsaPvq8of5NeGGqFOEqk0+mmLO5TqRQTP1RVxdTUFGRZxtzcHBMup6en4ff7kc/nsX79egwODiIajeLYY4+Fx+NBKBTC/v37MTs7i3Q6jfn5eSwsLKBYLEIQBCaotIJ6ziMIQkn/0/yUZZkl26bthUIBY2NjyGQymJ6eRj6fRyaTQVdXF9asWYPe3l7IsoxQKISuri709fUxj6pKwlAul8PExETJfvl83hK7pdPpiuduBFEUkclkmL2mp6eZIET3qUgkwrzGJElCb28v+vr6MDQ0hFAotOSYRttcXFxay+jo6BJhOpFI2Gbh7FSxox0Vj5xWZYlEClqYuzR/vDttPjVbNHSaPazA0lAyQRBw991347HHHsORI0fKigYcx+G3v/2tlafuCGoJydKGZ+jDubSu+eS67/f74fV64ff7wfM8fD4f20YVdCiUhI7l9/srVtLRhkg0E47jWN6lSvvUWvWHKixJkgSe55d8TrajEDwKxaAwO57nWUgEheoVi8WKeX2010CiHmAcrgccDcug8A+e51k4Gc/zLNyEclBpQ3fIFn6/n31G26kN1N/VqMe2RLFYZOfWjkmyG4UlAUcXl/pxTeE4NIaN0F4PQdelPa/X60UgEGDzIBQKMTtSThztderDNcuFvDQa4lML1OfAy7alfEkAWIU1sq/Z0C0SowkaM2RzCuMk+5ENKRSPCIfDzJ401rT3p1ZWfNNWeRRFkeU8EgSBXZe27fq20bjX31/p91AoBK/XW2Ib+j/ZgMaxdm5WCxEOBoMl+zUSekdCEPWH/jgULgccHVt0z9PaxEyf0TigMUHjhEIN6XO6Pvq7ow+f1h7PxcWl/RgthC644II2tMQYJ4cAjYyMgOM4bN26tWU5hpwUGtPKvD9u8unWHN8qtP0FAFu3bm3KeZxiDyuxTBiamJjAa17zGrz44otVvTaccENyEvoKQHoRJZvNYmBgAIFAAD6fD93d3YhEImxR7vP50Nvbyz6nB/oVK1aU7SuO4xCLxVqyKPb5fDjuuOMQi8XK7kOheGbHlqqqyGaziEajmJmZwcqVK5fsUywWkclkEAwGUSgUMD09jUQigVAohNnZWaxevRr5fB6hUAjpdBqRSASpVAqrV68ue15teATHcejr64PH48Hg4GDZ/Um8GBwcZMIQCUYk3mm/TwtW4OjiOBqNslCfrq4u9v1QKGTKg4DGRz0sLCywJNhaQUMURYTDYWSzWXR1dQE4Gu5IbadFJglui4uLLHxSCy3QAZQkr6U5oBX8YrEY1q1bh1gsBr/fj0gkgp6eHiYGbdiwoeQY2r4iexktklsZ8tLb28v6NpvNwu/348CBA1i7di1b1MfjcZaTi5JpV5sXQ0NDLIE9x3FYvXo1fD4fBgYGwHEcVq5cyUqu00Le6LqPP/54FjJEggYJ0FQpr1VkMhkmSkxMTOCYY44BAIyPj2PFihVQVbWkv/X96/F40N/fv0RQ8Xg8CIfD2Lx5M7q6uthYWrFiBesbCufUj5dqAncsFsP69etL9mskGTp5OgWDQfT39y85N3mF0f1TVVUsLi6yz0OhkKkk4iRmUb6llStXsr7v6+tj9ymfz4e1a9ciFoux+Wl3L08Xl+WMPoR/y5YttlowO6mKEtGqRW2l8wPAnj17bCuAAK1dlDsl+TTQXEHRKfOpVf3lFHtYiWXC0Ec+8hGMjo7iVa96FW644QaMjIxUXMi7WId+Aaz3fqF8DgDKPuRTX2m/29PTU/acHMe1zNXf4/FgzZo1FffhOA7xeLym4+bzeUQiEczPzxsKQ5QTxev1Ip/PY3p6GoFAAB6PB3Nzc1i9ejXz1qBFOm0vh9b+2jaXs3UwGGTfqdQf3d3d7P9+v9/QuyYYDJbsZ+QlZYTH46nZtgSF/2kFAUVRmDBUKBSYMEShgLSI5DiOlZUvl2OFvBOAo9dHC3japvUACoVCbMyGQqEl9lyxYkXJ7/q+KmevVlbf0vYDhX5NTU1haGiIeX/E43GIogifzwdBEEwJC3pb9Pf3A3h5XPX19S35jtF1V5unrbQV5enxeDyYmZnBxo0bwXEckskkent7oShKiW30nn4cx7GxqfcY4nkeq1atAgAmqGmvrdx1Vptz2jFa7Vhm0IZvGs1hRVGwuLjI7heqqrKwNZqLZtDfc7TjRXte8tQjWult5+LiUhujo6N4/vnnS7bZsWonLdZosWj3xVs7RQinCSCtqqLmBM+QdguKdsIJ/eVULBOGfv3rX2PNmjX4zW9+s+zKFFtBLW9NqVKVtrIYUL7qTDMq0dDx9FXOmoGZtpfbR28rLSQaaBeEtLgmTwNtWAx5FGg9tCgUgrwiqo19bTu1YWpGoVpm+4z63aiymRbtwk0bwlWNRsYOeaBpj6ENP9K2gTzWtF5rWu+ham3TVj1qxJ7ljk1oq1XVelwKb6onpEp7Hm0VukgkwqqJEdpQHTPnLXetZqCQzHZ5ghpV7aJqWDSOSLwBXvaoqxa+VMlb0gxkF31bK90rra7OpRe0jI5NocUEhZQBMJ2TyPUCdnHpPJ555pkl2+y4AHNKGBDRzkWtkxbUrayi5gTPkFaIek6ZS60SDZ1iDyuxLOGDIAg4/fTTXVGoTmpJzCtJkmH+pnJVu5oZvqGv2GM3qJqUEdFolIWLaCHvFK/Xi1gshkAggFgshjVr1oDneYTDYVZliEI+enp6EAwGy4aEGZHP5yGKYsP2o/ZWqtoGvDwOKIyuFXR1dS3xgNAKaNqx2d/fz6qqUa6aYDAInucrektpadW1VbN1OSiBdaOQwBAMBrF+/XqEQiGEw2FmT8rjQgl/rTqvEdlstq3hQJIklSSHBo7O7VgsxkKhVq9ezcSL1atXIxgMlohFzUBf5QyoXpXManier+il5PV6kUgkSjyjYrEY+9Hb1cXFZfmgr0prp6TTWpyWILadFbBoQT00NIRzzjnHlv1JtLpfR0ZGsGHDBuzbt8+W1adakTzcKXOJRMPJyUk89thjTesvp9jDSiwThk444QRHlAu3K7VUGpJl2VBIMhKLtKE2zaBcW+yCLMuGC2KyC+VK0kJ21CYkDgaDSCQSLK8P5VEhz6JQKASfz1dTyJUoiksqHtUDVZGrViGOrpfKuLeCYDC4xNuHEtJSm4hYLIZgMIhAIFCSLN3n89W0iG92pTwzti6HJEmWCAPkbebz+VgOF0o0DoB5upEoUCwWmzZPRVFsqzBkdG2U14rGTyKRYJ/19PSUDbe0EqO+FkWxpcIQedyVgxL7a8XbQCDAQljtfG93cXFpHqOjo0uq0hqFFNsBp1XbaietWlBbQav71e6l2lsh6jllLrVKsHGKPazEslCyj33sY7jiiivw+9//HqeddppVh1021FqRzOhhv9yb4Wa6+ZutbNUutBW69OjtQolYZVnG4uIiE4VoP60QVO4YtUBVm+qt+EUhZDzPl1SQKod2QdqMRTG1h/5P7dJTS4iOKIpLbF6NZi/4zdi6HNqqf41QrspUpfM2a57W2j9Wow+jA+wR2tSqsN5KVDtXpfA5qn7YbKi6np3/jlhJLpfD008/XbFyKwC8/e1vb2GrXFyOMjo6in379uHFF19c8tmpp57ahhZVxwlhQFraGZ7ipBxDQGsrt9ndNq0IrXNK5bpWhUQ67d5iBZYJQ1u3bsUNN9yA17zmNbjhhhvwute9DqtWrSq7CKqWpHS5UYs4UK6MfDuSAlI+GLtSy0JMkiQ8//zzWL16NdLpNIaHh5lnEIAluUoahcLQ6hWGstksYrEY6/dq/U+eHRR2ZDXZbJbZK5vNWrKozGazJQmzq1GuWpbV1DvXtAmyG6FWgUFbFc5qwuFwWx8g7FrZyqgCWbWqZHajFX9TBEFoqnBpJz7zmc/g1ltvZUn5jVBVFRzHucKQS8vZtm3bkmTTxPDwsK0XRc1OTmwl7RQgnJJjqB2Jlu1um1aOG7tXrmulYOOke4sVWCYMrVu3joWpfO5zn8PnPve5svtyHOe6qOuoZbFAD9D0AEnQAkm/vRK0oNK/KSaqHYfe1hstzOpZLGrbU8t1lMOoZHQ5ZFnGzMwMhoeHMT8/v8RtupqniJHdtNegvzZa3GsXRLS/mWunEDkSYKoJMVTqnhLOWtVnhDY8TR+qVm9fGh2nHFRGXX9tzRAtKEGv/tjVrrOSCFjpu/rrNhrXldqjH2MAloxLolZ7aced0f1E3x79uRqd57UICuXOpZ13+vbVi9G9otr9Q38fbpbgZubYlSrxWWknSoze6fzzP/8zPve5z8Hr9eLiiy92K7e62Irt27eXFYUA4Nxzz21ha2qHPJ2c8FZfn96hlQKEUzwg2iGetbIKWj20Sriyu+cU0Pr57qT7S6NYJgydc845y+Lhzi5Qnhj9H5hCocDy4Jg9Ti6XY0lqVVWFJEnwer1QFMXUcSjBM+WO8Xg8EAShLk8CqnLm8/kMr6+ZeL1eDA0Nged5xOPxmj1ecrkcAoEAZFlm7RZFkYVUCYLA8r5QXqBgMMgW+KqqIpPJIBKJQJblqravtX36BTTZOpfLIRgMQpKkhjwEeJ5HJpNZEoJSbqyaPaYWWZaRSqWQSCSQz+cRDochCAKKxSJLoEvnzGQyCIVCloeWUeiLoihLrpNC6OpBkqSyYVlUXY8q7On3URQFxWKx5NzabcVikXlfybKMTCaDrq4ucBzHxDcKBWy0PHql8FJFUVAoFMDzPDweDziOMzXWraDcONRup/unKIosgXer0N4rjPrTKhqZj/T9dDqNfD6Pvr4+ZDIZ9PT01P33f7l4C/3bv/0bQqEQHn/88WVdZtjFnvzpT38q+5ldk04TTqocpA0HAtCWBNB0PhIA7GirdnjvtLIKWr20IrTO7p5TrZ7vTrq/WIFlwtAjjzxi1aFcTJLJZJY83M/NzSEej5teaMmyjGQyycJvtEIBlW2vhiiKmJ6ehs/nQ1dXFwKBAJLJZF3hgsViEaIoIhqNIpvNtlQY8vv9OP744yHLMmKxGBPLzDI7O4ve3l4UCgXW7kwmwxLfLiwssCpB6XQaiqJgcHCQCUOKomB6ehpr1qxBPp+vavtaw1L0i0yy9cTEBAYHB7GwsNCQMBSJRDA2NoZisYiNGzeWfJbJZMrmHKqEvj2CIOCFF17AqaeeisOHD2Pt2rVIJpPI5XIlwpAsyzhy5AhWrlxpuehAoS8kcBCKojQUQpfL5RCLxQwXyZS0WJZlVqlNi6IoyOfzS9qTy+XA8zwEQcD4+Di6u7shCAIOHTrE7EVVxebn5xGJRBoShsgm5Rb6xWIRqVQKPT09TBzS910zMbpnAmD3moWFBYRCIaTTaQwMDLRUsNCOHRLsm5Xjp5wdzHLo0CFMTEzgjDPOwNjYmOmqgUZYFV5pdw4dOoTzzz/fFYVcbEmlOWjXpNOEEzwcCH1bm10sw4jlttA1i53HUStD6+zuVdbqfrLzuGgGzkl24LIEo3A8qnRlFlVVS8qlq6qKYrEIVVVNH4e8AAqFAiRJgizLdf+x0563XHlt8pwoF8JWbns1qHSzz+dDJBKpOamuIAhLqrRpr0GSJPaZKIoQBGFJO/P5POuDalRqn5EN9G/myda5XA7FYrFkHNSD3+9HoVBALpdbIsbUWypdf42KoiCdTrN2K4oCQRCW5OyghXUtc8EssiyXrcbXSIgszTsjyLuLwgH1GI0Z7VwiLyH6fzabZftJkgRJklAoFBquVleufdrrKBQKbL9a7jNWUG4c0nZRFFEsFiEIQkurh2nbABj3p5U0euxsNovZ2VkUi0UsLi42dCyrErLbnaGhoZbkP3NxqRWjCmRa7Jp0mnBS5SA7tNUJJbjb0UY79E05Wm2PkZERXHjhhbYUQFrdT3YeF83AMo8hPdPT05iYmAAArFy5EgMDA8061bLF6I1vOByuyUPC4/GU5DmgvBJUKtwMVKbd6/UiEAjA5/PV7XmiLWVeznOBKlVReI1ROwVBqNvzgTwZaiUSicDn85X0i7YNVNIeONpPiqIsqXAWj8dLyozXCwlzlWxAtu7p6UEgELAk30U8HjdcdDbihaLF5/NheHgYfr8f3d3d8Hq9iEajSzw7PB4Puru7607sXQkKl9TPP47jGvLCqORRRYtnjuMMx6bRmNFu8/v9zHNN+3/g5ftIPB4vKVteD2SbclB/0X5WjPVaKDcOaXsoFALP84Zjqtlox06l/D5Wn6seEokEisUiAoGA7b0J7MJb3vIWfPe730U2m3UFIhdboV9kjoyM4NRTT7Wtx4Aeu3s42A27hwoB7WmjnXMMtdoeds6p0+r5vtzuL5avmv71X/8Vt912G1566aWS7Zs2bcL111+P973vfVafctliJL7QYtksXq+35MGeKm/VUoae53km/NECtre313QbtGirnJV7eM7lcojH46zKlpEwlM1m6xYj6g1t6O3tXZLfSdtHsViMHbe7u5vliyE4jsPg4CC8Xm/DC3TyDqlkA7I1CS2NnhMABgcHDRPTRqNRS8JFeJ7Hsccei0AggOHhYfA8j97e3iXeHV6vFytWrGhK7hqq8KUXnTiOa6jaW6XQQG1CbSM7ejyeJf2n3RYIBLB69Wp2LPo/8PIYDYVCDXtuVJs7Pp+PzRNKFm7FuDNLOcGa7jVdXV1MrGqGqFgJbdusroBY6Vz1sHr1agwNDSEcDmPdunXWNKrDuemmm/Dkk0/ikksuwe23345jjjmm3U1ycQHw8vMCMTQ0ZLuFcTWc0l47hKU4YaHbDpHGzjmGWtlnbqjh8sayJ19FUXDllVfi3nvvhaqq6O7uxtq1a8FxHMbGxjA6OooPfOAD+O1vf4uf/exnyyKnQDMxWpgCtSck1ns5lDtuJYy8J+p9I61dmJZrhzYMpVy4h1FYDWCueo626pvZ7wAv277cNWhFCiPBQusl0Ki3gpnwHGonLcytWAiX63erFtler5d5NpGNjM7JcZxlXkr6cUDn1Yso9cwdLfrvas9bSbCh/YyEKtqmFRv1wiPtY0UfVRu3RveKVnnmlOsf7Xaal+1IhqxtW6NjqRKNHlsvgFrVzlrvt07joosugqIoeOSRR3Dcccdh7dq1WLVqleHc5jgOv/3tb9vQSpflxujo6JJqZO3Ie2MFdvZyIJzgrWMH2iHS2EG0swN2t4ObfLq5WPbk+e1vfxv33HMPNm/ejFtuuQVveMMbSj5/4IEH8JGPfAT33nsvvv3tb+M973mPVad2WWaQV4LP5yubz8TIC6FQKNTknVAoFCwTF8xCFYMaPW+r293JiKJY4snWSsyM2Xa2z8XFKgRBqCtBvVPQFuiQZRn79u0rmyeiU23gYj+eeeaZJducKFY4afHWispSlXCCrdohTthZtGtln9nZDoCbfLrZWJbx8c4770Q8HscjjzyyRBQCgIsvvhgPP/wwotEo7rjjDqtOWxczMzP48Ic/jM2bNyMUCiGRSGDr1q34yEc+Yrj/fffdh3PPPRfxeBzxeBznnXceHnjggRa32oWgkBe/31/WQ8ooDE2bcNcMuVyuriTWjUBJkxslGo02HC7icpR8Pt/yRMSA+bFAyZxdXJxMu+ZZq9i/f7/pHzsmg3XpTPTPOMPDw45c9DghoTIt7kdHR7Fnz562tcMJtmpHwl8K1xoZGcHmzZubfr5aaGWf2dkOgJt8utlY5jH05z//Ga973eswODhYdp+hoSG85jWvwX/9139Zddqa2blzJy644AKkUils2bIFl156KRYWFvDnP/8Zt956K2655ZaS/f/lX/4FH/rQh+Dz+fDa174WgUAADz30EN7whjfga1/7Gj7wgQ+06UqW4lRXfG2FMUqwWwnyjKD99NfNcZyh90Sti45a9te2oZF+oPA47cOaqqosHwt9rr1W7ee0vxk7OgEr7Ur/6r9f7Xj6/mgVlUIltdTbPkVRloSxGNlJO96WQ/WocujHH9mlE+aZEVbMN/q/9n5Vjk4WhQBg7dq17W6Ci8sShoaGMDo6yn53au4ru3s5APbxPHCCrYD2eVbRfNizZ49tvKn0Ifit6DM72oFo5diwc1LyZmBpEgMzD5DtfIiemZnBhRdeiHw+j1/+8pe45JJLSj7//e9/X/L7nj178OEPfxiBQADbt2/HmWeeCeDoZHnVq16FD33oQ7jwwgtt84dUkiRwHNeUhLvNJp1OI5PJ1JUwWFVVFAqFqslaa01yW8v+uVyOnV9VVQiCUFdSXUp8KwgCAoEAcrkcBEFAV1cXE7uOHDmCQCAARVHQ09ODbDaL7u5udgwqp95o5SE7UCwWoSgKAoFAQ3YtFArgOI6NE47jIEkSFEWp6lkVDAbbEqZlNjFzIBCoq32pVAp9fX1L7sm5XA6iKCIcDkNVVaRSKYTDYciyvKwrUImiWFI1kezXyeRyuboqaNH9UFEUpNNpdHV1oVgsVgxxrTfpv4uLS/1MTU2V/O7U/EJOSKhsF0HG7gtdbdgUAGzdurVl57aLeKdFm28JAM4555xlm2+pHWPDzknJm4Flr383b96Mhx9+GMlksuw+yWQSDz/8cNtc0/7+7/8eyWQSt9xyyxJRCABOO+20kt9vu+02yLKM9773vUwUAo7eVP/f//t/KBaLuO2225rebrOIoghJktrdjLpIpVI4ePCgYanzapgNual1gUMCghm051cUBfl8vqZzEZQMvFAoADhaLSSVSpW8TT906BCmp6cxOTkJSZIwOztbcoxisejYhzs9xWIRoigCaMyuhUIBhUIB6XQaoihCFEXkcjlT4YXBYLAtnjJmq5zVK1xNT08bbs/lcpidnYUgCCgUChgfH8fc3FzFe/tyQBTFkvvTzMxMG1vTGmoNv9V/T1EUpFIpyLJc9Z5kRVU8JzA1NYUvfOELuOiii3DSSSfhpJNOwkUXXYSbb755ySLdxaWZGIU02dV7pBMgQWZoaKgli/ty0EJ3cnISjz32WInHmB1oZ6ibHcOG9Nffiud7O9oBaM/YcELopZVY9hR29dVXY35+Hq95zWsMq2ls374dr3vd67CwsIBrrrnGqtOaJp/P44c//CEikQje8Y53mPoO5RG6/PLLl3xG2+677z7rGmkSCrsizxBtKBZgPrREG6qi/U47QmfMhs3U+51qlZ2MqBSOReeWZdnQXkbt0oaJFYtF1ofaz+h81K/0mf44Rp8risLOqx0T9di2WdD1k920bdZj1G697Wgf+ilXsc7IluX6Tb9dOw7o3FahnbdG282MWbNhg0Y2ou360B+jz4320d4/jOZCueuzGu3canSs669B+3u18WO2nVbTbDtr262de9p/9XNH+6+Ztnk8Hlves6zk5z//OUZGRvCpT30KDz74IP70pz/hT3/6Ex588EH8v//3/7B582b8/Oc/b3czXZYJ+gWOHb1HzEKeBDt27GB5fOyGXQQZuy902ylKkOfZ6aefbpvwqXblW7KDiKmnHbawq0jWLCwLJbvuuuvw4IMP4j//8z/x+te/Hv39/SymfmxsDDMzM1BVFRdddBGuu+46q05rmqeffhqLi4s4++yzEQqF8J//+Z/4r//6LxQKBYyMjODKK6/E8PAw2z+dTuPgwYMAgFNOOWXJ8VavXo2+vj6MjY1hYWEB8Xi8ZddC4TX0VjYej0OSJFbRpVAomAov0YZgaUMG8vk8QqFQS936E4kE/H5/zaWPKWShnvCiRhBFEYIgIJ/PIxAImDq/LMuQJAkejwfT09NYsWIF5ubm0N/fD+DotUSjUeRyOUiSxMJ5vF5viUCwcuVKFItFhEIh+P1+9PT0ADjab7IsIxQKIRAIQBAE9l1BEEx5nzQbGpvJZJJ5unAcZ+jNJYoistksurq6ABxdOIZCIYyNjWH9+vWYmZnBwMAA866SJAmSJLGwOkmSWL9QmEpXV1dJqKL+vJTIORKJGI7/w4cPY3Bw0LIwPUmSoKqq4fFoPFjF/Pw8gsEgMpkM+vr6WBiU/n5BY47C91auXIlIJFKS4Jq8uIrFIiKRCAqFArLZLAKBAMLhMJvHoiiC47iySeKtJJfLIRQKNTzW5+fnEQ6HWZ/k83mEw2HwPF8yD7u7u2uuIGg27LVWisUiZFm2vBohtVNRlBK7zs7OoqurC/Pz84jH4yzckOd5BINBhMNh1veJRML0fZ1sDRztT6M8WE7l6aefxlVXXQVFUXDZZZfhbW97G9atWweO43DgwAH8+7//O+699178zd/8DZ544gm88pWvbHeTXTocfWjTqaee2sbWNIZdQ1+02KWNdglpK0e7Q93sJpC2wx52DZ9qhy2cEKZqJZYJQ16vF/fddx9uvfVWfPWrX2XhLsSaNWvwwQ9+EB/60Ifa8qD35z//GQAwMDCAv/qrv8Ivf/nLks8/+clP4rvf/S6uuuoqAGCiUE9PT9kQpFWrViGZTGJsbAwnnHBC1TZs2bLFcPvevXuxceNG09ciSRJkWcb8/DxUVUUkEmF5aICj4Ud+v7+qMEShOeFwGNlstkQYanW5856eHnR3d9ccEkPtbocwlMlkMDc3h3g8jhUrVlT9jqIoKBQK8Pl8OHz4MAYGBgyFIRJ4RFFENBpFOBwumTPDw8NIpVLo7++Hx+NhQkg+n4ckSYjFYvD5fFhcXGRiWzMWo/WQz+fB8zySySS6u7uZYFBJGCL7cByHYDCIQ4cOYd26dUgmk+jr60M+nwfHccjn88yGHo+npNQ7/RsIBEoSWRsJQ5WEhSNHjiCRSDhWGAKOLup7e3vR39/PhGStcBMOh0vCKIeHh5k3h7bdwNH+JGFodnYWsVgMPM8zIYDynrVKGKIwzEaFIZ/Px/qEBCf9NXR1dUGSpJruldp7rpUUi8Wa22IGrTCktevc3BzC4TDm5uYQCoUwNTWF3t5eRCIR8DyPcDjM/g4lEgl4PB5T93ayNcdxHScMfeELX4Asy9i2bRsuu+yyks9OPPFEXHLJJbj33nvxpje9CTfffDO2bdvWppa6uDgPu4sdgH3aSAvdnTt32jKvW7tFidHRUVuJAO2wh11ETD3tGht0DrKLHWzRLCwThhYWFsBxHG688UbceOONOHToEA4fPgzg6MJi9erVVp2qLubm5gAAv/rVr+D1evGNb3wDV1xxBXK5HL7+9a/jS1/6Eq6++mocd9xxOPnkk5HJZACg4gM8LSoXFxebfwEatBWC9BWqtP/Wciztd1r9h6JcFTGz321HZSA6p8fjYT/aNpRbzND3yFNGu5+2X2kRrj8Ofdfn8zGbaau06W1Rz5hoJtr2VOs3so/+O2QT+ld7LO0xK9mBwrSM7FupTVZXe9OKVEafWYnebkZzzuj6K3l71NKfzcaqsW52Dnm93hIvqlqO7wTK2UH7mfaeZfQ7YDzOKp2z3Pmdzu9+9zu86lWvWiIKabnssstw1lln4fHHH29hy1yWA9u2bcNLL72ESCSCCy64ACMjI3jmmWdK9rHL4q8enPBWv92eMHrsWnWqnaKENrnxjh07bGGXdtjDLiKmnnaNDTuOi2ZhmTDU3d2N008/Hf/93/8N4GioVbvFIC2Ur6BYLOLzn/98STjbLbfcgrGxMfzsZz/DLbfcgrvuuqspbXj++ecNt5fzJCoHiQLd3d1QVRVer7fkTbHZZLQUmgOUek7UknS53dRTMccKeJ5HLBaD3+9nXiiE1q5aqJ88Hg9WrlwJr9eLRCLBPqdriUajUFW1rJdFuaTEVDmKoPAgs9WtWgElmB0YGKia1Jnn+ZJqawSFXwwMDJTY2ufzIRQKsWuu5D1RzoYUnldu/K9cudLSqn9+v7+sMGT12O7q6kIgEEBvb2/J9dWT9JfGJn0vFAqhr6+vxFuI9mvVvSQSiZSde7Wg9WQDyt8P6wl9taJ9Rvj9/qZ61ujb3dvbC7/fj97eXvA8jxUrViAYDJa0g+f5mgV/ra3LhXM6lfn5eaxZs6bqfmvWrMEf/vCHFrTIZblw5513Mi94QRBw991345xzznETT7eYdnvCaLGrRwjQXlHCjnZphz3sKrS2a2zYcVw0C8ueJLu6umz9R0UbkmGUfJq2PfrooyX7V6p2RTl+YrGYZe00g8/ng9/vRywWQzweh8fjKQlFMVv2V7t41i6SnVQ2uF3hUX6/H5FIBIlEYkm4TzlRgvrJ7/djcHCwJAwMQIlIF41GK4bfGC0ug8FgiZhACzP9+GgnNLYSiQQLASy3UKYxrmflypXsGGTrYDCIaDSKrq4u09dsdN5AIFBxQTo0NGSpMERz2Wz7GiEWiyEQCCwR2+qZ736/H36/vyREr7u7G5FIpEQMqEc8qRcSuBod6yT4ao9rRKW+K0c1wbJevF5vU8P19Hbt7u6Gz+dDd3c3/H4/+vr6EIvFSsZSPcKQ1tadVqVsaGgI//M//1N1vz/+8Y8YGhpq+Hz5fB6f+cxnMDIygmAwiOHhYVx77bWYmJgwfYzvfe97hh6Z+p8f/OAHJd+75pprKu7/rW99q+HrczHH6OgoE4W07Ny5s+R3O3iwNIITkk/bKemz3RPqjoyMYPPmzS33zLCjXeyaCLodtMsWdhwXzcKyJ/ZTTjkFe/futepwlkOJsMPhMMtZomXdunUAXi7hTG/25ubmSvLvaBkfHy85diNoq7CUexiWZZmFnpBXhBFmF3mVwgRqRdv2YrHIQp6oao027Ieuo97wMbJVvd+3gkphK7RNluUloVDlvl+L/c32u5XiXrWxaZZq4T7FYpGN7XKhJNrQuXLHN9MOqqakHUfVvm/1QrVaX+rHUCNo56CZNpTDaCyU66tKx7by2qwc60bhheXOaTSGtCiKAkmSWPhnswR3s8etdx6XC/Gqdh/U2of+X04otHI82JELLrgA3/nOd/DJT34S//iP/7hkzKiqik9/+tN44YUX8K53vauhcxUKBZx//vl46qmnsGLFClx66aU4cOAA7rzzTtx///146qmnTD3YHnPMMbj66qsNP5ufn8cvfvELAMDZZ59tuM8FF1xgKHJt3rzZ/MW4NIQ+XIygF5uEFWJkO3HCG307hefY1SNEG7IDAFu3bm3p+e1ol3Z4mtk1dKqdOYbsNi6ahWXC0Mc+9jFcdNFF2LZtm2F593ZDlcXy+TwEQVjyVnl2dhbAy55C3d3dWLNmDQ4ePIj/+Z//WfLgc+jQISSTSaxdu9aSimSUbFhV1bJvqPP5PPx+P6sEZCcoqTLP86z6USQSQS6XgyzLCIfDrJJWJpOB1+ut29OKErhamZi3GWSz2ZZ7kzULSpLc7KTk2Wy2ZRX+VFVFLpezdR9R1b12iqB6qAJWox5NlOS+VR5FzSKTybDE/3oEQcDk5CS6u7tZ9cB2UiwWUSwWW+ZpqZ9j2iqDeqgapp3GupV8+tOfxj333IMvfvGLuPvuu3HllVeyF1IUyn7gwAH09vbiU5/6VEPn+tznPoennnoKZ555Jh566CH2t/IrX/kKbrzxRlx77bV45JFHqh7n7LPPLiv6fPOb38QvfvELnHXWWWUXuB//+Mdx3nnn1XsZLhZA+TKrIQhCk1vSXOwkulRiZGQEHMdh69atHb24rBc7CHx2SzTcDpvYoR+MaGe7nO5VaRbLnshDoRDe+c534s1vfjPe8IY34I1vfCPWrFlTdiF5zjnnWHVqU6xZswYnnXQSnn32WTz66KN4/etfX/I5hZBpS9NffPHF+OY3v4lt27YteTiiiiFvfOMbLWmfLMusDH25BZcgCOA4DqIo2k4YoupDAJjwAxwVjCRJQiAQYOXD8/k8fD5fQ8KQIAi2F4by+bytRYdaoLHZbGGoUCi0TBiicWTnPhIEwTb5oQgSFxptlyiKLalW1mwKhUJZsUOSJCSTSfA8bwthSJZlVlGuFaiqikKhwOZYJVsVCoWWV8NsJatWrcLDDz+Mt771rdi1axduueWWkmT4AHDCCSfgrrvuwqpVq+o+jyiK+PrXvw4A+MY3vlHyd/KGG27A97//fTz66KPYuXNnQ+XJf/jDHwIA3va2t9V9DJfmMjo6ajp00K5Cilns/ka/3Z4weuzqEWIHgc9uttE7MrTCJnboByPa2S67VatrFpYJQ+eddx5zHb/vvvtw//33V9y/nmoujfLRj34Ub33rW/HhD38Yv/71r1mJ8T/+8Y/48pe/DAB473vfy/a//vrr8e1vfxvf+ta38Ja3vAVnnHEGAODFF1/E5z//efh8Plx//fWWta+aGz3lTqn2RlUbjgOgxIVfURQWimYl2gpP2gSkFEKg/dzn8zXkJVBPGFq1MAYroHMAL/dVLSFvsiwjm80iHA6jUCggEokgm82yvES1toVC+uia6XeOe7myl36slKNVuT7IViQ0+ny+kv8DL7eZPP9kWWZ2pmukkuD0fe3YI5xQCttM3xA0t4GXw320Y14URXi9XibU0ueiKKJYLMLn88Hj8bCQp3K2Marm1uxrawb6e6EgCPD7/RBFEX6/n/0uSRITosl22jltdE+h+wAJaHbxiqrUr+VQVZWJeDTnRFGEz+dj80077ui+Ry8CtLYqdy8URZEdh+6BnRhSdsIJJ+C5557DI488gscff7ykcuurX/1qS7xrnnjiCczPz2Pjxo0lL7qIyy+/HM899xzuu+++uoWh/fv348knnwTP87jyyisbbbJLk9C/XQ8EAoaeQe1Mgmwldn6jbzcPDLu1h7CDwGcn22hDpwC0LK8O9cPOnTtt97e4HV53dhMLm4llT6tvf/vbbTd49PzN3/wNHnroIXz/+9/H8ccfj1e96lXI5/N48sknIQgC3vWud+GKK65g+2/evBm33HILbrjhBrz61a/G6173OvA8j4ceegj5fB5f/epXccwxx1jSNo/HA57ny1YoAsAesqsJDeSST4sRetju6uqCJEkstMtKtBWmKDEpcDSRsqIobNEJHE3u2shY8Xg8dbU/k8kYVrmyEvKWCoVC7CHMbFsLhQJ2796N4447DgcOHMCWLVuwd+9erFmzpi5vg0wmA47j2DVnMhmWNJg8NSqFwWipVD3LSqgi2+LiInw+H+LxOBYXF+H1elk7qc2Tk5NYvXo1crkcE9LS6TR8Ph9eeuklHHvssUgkEkin0wiFQlBVtcQbyQkeCrUskGVZhiAITDz2+XwlXmtzc3OIxWJIpVIYHh6G1+tFoVDA9PQ0UqkUurq6EIlE0NXVBZ7nywoIfr/fEmG53WFDxWIRkiQx78tkMomBgQFMTk6iv78fhw8fRiKRQCqVwsGDB3HKKacglUph9erVJd5SRt6b+XweHMdhcXERK1eutM04q6fvVFXFzMwMVqxYgcnJSaxduxbJZBLd3d1YWFiAx+NhueR4ngfP88jn85ibm8Oxxx5bYp9yXp5zc3MIBoNQFAVjY2M47rjjGrpOu3Peeec1LcTq2WefBVDeI4G2P/fcc3Wfg7yFLr744op/m+655x78/Oc/hyzLWL9+Pd74xjfi2GOPrfu8LrWh9zQ45phjDKvj2s0DvRHs+lbfbh4YdmuPnbCTbfQiVatDPimJ+549e9ouhrTT685OYmGzsUwY+t73vmfVoZrKnXfeibPOOgu33347HnnkEaY6vuc97zFMsvihD30IxxxzDG655RY8/vjjAIBXvvKV+OhHP4o3vOENlrXLjBcMLear7SeK4pKFCN1MmhVKoH0jrl00aUNFaKHZaNUgjuPqqgzVihuqIAjw+Xwsd0ottpYkCYcPH8bGjRsxMzMDVVUxPT2NgYGButpSKBRKFvcUiqjfZoZWLeADgQALP6GxUygUSvpbEASoqoqFhQXmzZDL5cDzPDKZDHiex8TEBMvfkc/nmeeaFkmSbLNgL0ctoVbaRMfA0fkmiiL7PJfLIRQKYWFhgXlLiqKIdDqNyclJqKoKVVVZTqNyc8wqjyErq7vVA9mLyGQy6O3txcLCArq7uzE7O4tQKITZ2VmMjY3h2GOPxezsLIaGhkrucUb3M/JSKxQKpkqUt4p6+o6E2qGhITbnFhcXEYlEmBCuDYOmvEKpVArAy2OY47iy937yElJVFclksrGLXOZQBapy4Wi0fWxsrO5zmA0j+9rXvlby+8c+9jG8733vw2233VaTF92WLVsMt+/duxcbN240fZzlxtTUVMnv0WgUV111FR599FHmrQagoZBCO2Hnt/pUTWl0dNQWnk128Mwxwg59aKe+aqdIZTcxpJ3tsZNY2Gzs4d/eQjiOw7ve9a6aqn688Y1vtCyXUDnKVfXR72MGo+o3tAgzE4qmpVgsmlpMWFnhrBr1HrMVC1F6I08CTC229nq9SCQSzFOG4zjmvVEPPM+X2Mrn87EQN+02M1jZj5Ikla3QROEkPM+ztulLnlM/kjeNz+dDIBBggpzf70dvby/bj46lF4a0Xmx2RVXVkjxD2hBBWZZLFtpkC5qv2vA7ACwESitq+Hw+RCIRVmo+GAwuGSN6rBoLzfQwVVUVkiRVnDv6+UlejySMRaNR8DyPaDSK/v5+9n8zVexofIdCIVt50mrbQmPJzH2RroPGDo0TshnNL5qHgUDA0DO0nC0CgQAbt3bO+VUL5P5/2mmnIRgMloQDmKHePIyUbLicpyp5hywuLtZ1/N///vcYHR1FIpHAxRdfbLjPKaecgjPPPBPnn38+Vq1ahcnJSfznf/4nPvWpT+Ff//VfwfM8br311rrO72KO0dFR7Nmzp2QbCQAjIyO29axpBLstZLW0q5pSJeyWZBmwRx/aqa/aKVLZTQxpZ3vsHFpnNctOGLIrVi5QQ6HQklLS9DCoX2RXgzw3OiFJbCvcpSORCBOFarV1MBjEcccdh3A4jI0bN8Lj8WDjxo11J9mORqMlNzBa1Oq3tRqqPFapDLh2Uanfl2w8ODjIFvK0IO3r64PH48GWLVtY2Fh3d7ehQBcOh20vDEmShFQqxd7yU1io3+9nXhwEiRHaH60I1NPTA7/fj4GBAXbdwWAQQ0ND6OnpYQIaz/MdURkqm81WvG+RsEH09fXB5/NhcHAQwWAQq1atQiAQQCAQQE9PD+LxOHieN+XxGAwGwXEcent7LbmWZqAoCnK5XNVQUo/Hg/7+fng8HgwNDYHjOCaU0fWR6EpiG1WlNAuNP4/Hwzz9nA7lXdy9ezdGRkbY72ZpRx5GM5C30JVXXll2fulzL65fvx7XXXcdzj33XGzduhVf//rXccMNN2D16tWmzmkU/gSU9yRyWVqmXr+4bbcnRDOw20JWix0EDz128M7RY4c+tFNftVOksptXmR08uewUWtcsLBOGrr32WtP7chyH7373u1aduiOwUoH0+/1LvHborbBRSE0lKCmt0+E4runilvYc+mozZvD5fOjv7wfHcejp6QHHcUgkEnWNDaPr1beNtrVa/daGNxmhb7u+jfQ7CV+UNwl42QOKFvwcx7FFupHHkN2Vf1mWkcvl2O/kCUMJtrVok9fTv1pvELIDCWsAWHVAvZeG3e1ihmphknrPKPJAI7GUhMVAIFDyfzO2obFld4Gt2lwEjo4FrW20v9N16ueW3++vqWqd1rOqu7u7I8Yf5V0k4a1VeRhp/GrvG1qy2SwA1OWZVSwW8ZOf/ARAfdXItmzZgksuuQTbtm3Db3/7W1xzzTU1H8PFHPo52Ul5hMpht4WsFjsIHnrsJIAQduhDO/WVHfuoXbTbk2u59EVLcwzRA6QrDDWXciE6lT4vhxPCbczSiodys6ET1b6rX+A3qy3tWICZEegqjVe9bcyGYDbSN+3C6/WWhISQEObz+QwX3pWu0cgOTrBBvdQ7zqywiZXHaiZmxfJyc86q6+zEMal/JmpVHkbKaTU+Pm74OW1fu3Ztzcd+6KGHMD09jQ0bNuBVr3pVXe3btGkTAODIkSN1fd/FHPoQUa13qUvrsYPgocdOAghhhxBHO3imEO0uz24nj7J2CzN2nC/NwDJhaPv27YbbFUXBoUOH8NBDD+HHP/4xPvShDzU9X4+LdWirjbm4WIHWY8WlMpQvidB6/HSCJ18zaUeYpJOot7qji7056aSTACwNJSJo+4knnljzsSmM7P/+3/9bZ+uOVqADlocHS7sYHR1dEn7X6mpG7cBuC1ktdhA89NhJAAHs03/t9kzR047y7ED7hRg97RZm7CjuNgPLVhbnnntuxc/f/va34+KLL8bVV1+NSy65xKrTujQZd/FpjkohY04VQeiarG5/tWS35WxZazu07W/WtTQbj8dT4hmkDQuluWkmXNFp190oFI5oNpRzudkHeHks6edGNZstR1tZwYYNG3DFFVfgi1/8YsX9PvGJT+CnP/0p9u7dW9d5zjrrLHR1dWHv3r344x//iJNPPrnk823btgFAzS/oMpkMfvnLXwKoXxgSBAEPPPAAgNaWGl5u6Bd0QOe+3dZit4UsYRfBQ4/dBBC79J9d2tHO8uxA+4UYPctFmGk3LXUFueqqq7BlyxbcdNNNrTyti0vTEQQBxWIRuVwO2WwWxWIRhw8fxtTUVE15huyEJEltaXsul0Mmk8H8/DxmZ2eRTqcxMzNT83EURUGxWATQvmtpBblcDsViEaIoQpZlpFIpLC4uolAoYHFxsWOv2wzU7/l8HpIkIZvNIp/PY3p6Gul0mo2z5QzZhlBVFalUCoVCAfPz88hkMshms6zalUt9HDhwwNR9LJlM4sCBA3Wfh+d5fOADHwAAvP/972c5hQDgK1/5Cp577jmce+65JSXKv/71r+PYY4/FJz7xibLHveeee5DL5XDGGWewcDAjXnjhBfz7v//7Eg+VmZkZvOUtb8GhQ4dw0kkn4ayzzqr3El2qoE+Qv2XLlmWxiNIvXNu9kCWMhAY7YLd22aX/9Oc1U3CiGbS7f0iIGRkZwebNm1t6biPa7XVHQt2OHTtw9913s0TUnUbL3UE2bdqEBx98sNWndXFpKtlsFoFAAOl0GrIsI5FIYNeuXYhEIhgcHGx38+oin88jFAq1vCJdOp2GIAgQBAGFQoFV4BoYGKjpOJIksXLcuVwOkUikI8Mi5+bm0NPTA0EQEAwGMTY2xsrPZzIZR1Rfaxb5fB7hcBjz8/MIh8OYm5sDz/PYt28fenp6EA6HUSgU0N3d3e6mto10Oo1oNMrmuSzLOHDgANasWYPZ2VmWtFyWZTcMtAVQ1cFG+NSnPoXf/OY3ePLJJ7Fp0ya8+tWvxtjYGHbs2IH+/n7ccccdJfsnk0ns2bOnYt4fCiOrlnR6cnISb3/723H99dfjla98Jfr7+3H48GHs3LkTi4uLWLVqFX7605+646iJTE1Nlfy+XMJq7VpS2m6eF4Td2mWX0DZqB3lTPfbYY23xprJL/9ihEpcdvO7s4knWbFoqDCmKgueee27ZLlKaidYrwKhKDG1vJ/WECNUbVlRP6JDZc+ltDYAJEOS1IcsyFhcXTZ/bTLuMrsXos2rXbtY2iqJU/b6V3ih0PFEUIYoiCoUC8vk8ZFkueettFkVR2DXQv60OKatmH0rGb2TLSvbVfiZJEhRFgSzLUBSFiSGBQKBq1SmjsdxuzIQ2kd2qQTYpFotQFIVVdMtmswiFQvD5fIa5N+wYemg0Poy21wqNHzoOeVgVi0UIgsCq3VUrn25HmzkJRVGwZ88ebN++nSWQrpdgMIjt27fjC1/4An70ox/hF7/4BRKJBK655hr84z/+I1atWlXT8Y4cOYKHH34Yfr8fb37zmyvuOzIygr/7u7/DU089hT/96U9IpVIIBAIYGRnBG9/4Rlx//fXo6elp5PJcKjA6Ooo9e/aUbGv3gr/V2GEhq8UNgTGHnULb9M8F7RAB7CCU2UUMsUM77CLUNZuWCEO5XA6jo6P4whe+gBdffBFveMMbWnHaZQUtgJLJJIaHhzE/P494PI65uTmWYLSW8sHNgDwbaMHPcVzVN/WyLGNmZgaJRALZbBaRSAQ+n89UGWjyoDCLLMsQBAGiKCISicDr9aJYLC5xIy0UCvB6vRAEgZX8DYVC8Pv9iMVikGUZPM9j7dq1NZ2/HKIowu/3Gy64qN+1Xj1G27SoqoqFhYWqtud53lDEXVhYQDQaZX0wNzfHxlY+n2cJy+fm5jAwMABJkpjN/H4/eJ5HKpVi7fN6vfB6vQiFQsjlcvD7/QgEAgiFQhBFsWwFrmpoy9FTiftsNgue51vmBUW2pnEhiiIymQw4jkMsFsPk5CT6+voQj8eRz+chCAICgQAKhQISiQQTxcLhMPL5PAKBABv/sixDVVVEo1H4fD722cDAAKLRKPP0qLRQF0URHo8HsixbMlatQBAE1l/AURsWCgUAR8dXLBbD4cOHEQgE0N/fj1wuh1AohEwmw8rJ07WQGESeb7FYDD6fD8PDw4jFYggEAmWvu1AotP2eqYVEU47jUCwWWfJeGjNzc3NsXs7MzKC/vx/z8/Po7u5mfw+KxWLJ34hYLIZoNAq/3490Oo1AIACe5zEwMIBwOIyenh7WF4qiVB1LZu/NywW9Lb7//e/j+9//fsXvqKqKd7/73Q2fOxQK4bOf/Sw++9nPVt33pptuqhjiv2LFChaWW43h4WHceuutZpvpYjH6BZQdkgq3EjssIJ2C3lY7d+50cwz9L3YQAewglNnBDnZpx3IReC0Thsw8DKqqiv7+ftxyyy1Wndblf6GwmX379mF4eBgzMzOIRqOYnJzE4OAgOI5r+yJnamoKPT09yGQySCaT8Hg8iMfjFceOJEnYv38/wuEwpqamMDw8jFAoVHW8qaqKbDZb02JXkiQsLi5iYWGBCRiFQmGJMKQNGyNhSF8pyuv14vjjj7fk7Xk+n4fH4zEUaSi3jFboMNqmRZZlJJPJqsJQuYp0qVQKwWAQXq8Xqqpienoavb294DgOyWQSiUQCfr8f+/fvRyKRQC6Xw+zsLAKBABMxxsfH0dXVBVVVmagWCoWwuLgIv9+Pnp4eqKrKPEPKeS9Vwufzsf4IhULweDxIp9OIx+MtE4bI1qFQCIIgYHFxEePj4/B6vVi9ejWef/55nHDCCYjH48hkMkin0+ju7kYqlUIikUCxWMTs7Cz8fj9mZ2fR09PDxr8oilAUBd3d3fB6vWwBv2bNGjZeotFoRQ9NCtWrVURtJiQOEqqqMu+7mZkZ+P1+/PnPf0Z3dze6u7uRTqfh8XiQTCYRj8eZSEbjRhRFJghRv4fDYXi93opeWeRVZBcURUEul4PH40E+n2fCENlramqKXfvBgwfR09ODqakpdHV1YXp6GtFoFPl8Hvv27cOKFSuQSqUQiUTQ1dUFjuMwPj6O7u5uDAwMYO3atUyQpfFTzTOJPNVcYehlVq9ezf4GHDx4EOFwGH19fYb78jyP4eFhXHLJJfj//r//r5XNdOkg9AsobS6p5YAdFpB67BAGY4TeVqOjo8w7xQ7taWffud46R7GLGGKH/qB2AC/3jR3msdVYJgxpH4D08DyPFStW4Nxzz8X73//+mnOFuFRHVVUoisLcH4vFIlRVhSRJkGXZFuF79MaRQjvMtInektObf7MCAdmjFug7FHZS7hj0mfYNKi2GtNdkVTneStdB4onR9krfMfP2t9wCT/9dshfHcayPaEGutanP52PXQuNSVVXIsszORZ5OVgg32r6g49M5a6XeMBmyNfUTeQ15vV4W9qWdF2Q/SgZM36F/9SE/qqouyUdSi8BDx6hHeGsWleYcJZMuFAosTI7sWywWIcvykj5SFIV5pdE4MJPDxU42IahN2rAu2qa9b9Hco7FFNjL6G0G2oLGn9biqpSrlck5yXg5tEmmPx4MrrrhiSX4fFxcX67DLQlaLHRb4RlBSYW3oYTvbZqe+c7117IUd+oPaYUeR10osE4YaqaLh0jgUNkO5A3p6euDxeNDX18dCydpNIpEAcNR7I5FIsNwVlaCwj0AggN7eXgQCAVOCUj0eUj6fD+FwmJW69nq9htUIyMMlHo/XdPx6qXTNRgs38h4ph9frbSjZbldXF2sPx3FIJBIIhULgOA69vb3Ma2B4eBherxfBYBA9PT3w+XwsvIlCVVRVZbYGwEL4mkUsFqtLdCKxplavGrI19Uk0GsWKFSvg8XgQDoexceNGdHV1AQCzRzgcRm9vL/s+ecHE43EEAoEScaNR8YJsbxdvIQBsjBAcx7F7WF9fH3iex4YNG9g4i8fjzMuMPFzo+zQu6xHG7eQtBBwVFozCA2lbIpFg42PFihXwer1IJBLsM4/Hg0AggFWrVrEwXq1dEolEQ38rzN6blyvbt2/H0NBQu5vh0uHYVYRoJXYLn7PzAn/r1q0lwpCd2tZO7DCP7OAlYxchxA79Yad2NJOWVyVzaQ5+vx8+nw/r1q0DcHQB5fF4MDg4aEqAaQXkKRaJRNiCrVq7/H4/1q5dC7/fj4GBARb+UQ3tYtIslCOIwm+0b861kHhUy9v0RiBbGWGU06Nang8SDOult7e35Pj9/f1sQUjhZxzHsXAUEh6ovzmOw/DwcIm4RESj0aaOVQqbqRXy7qlVQCFbk7cKiUPAy+GG5LERiUTY2CJRwu/3I5FIwOv1MrGX2u/3+xv20qB+abQKkpWQDQiO45jNSAw69thj4fF44Pf7mcDR19e35J5Cx6qnz+0iqBPae5p2HNI1au+Pq1evZvmmOI5Df38/y+O1fv16AJXncT3oBT2XUs4999x2N8FlGWBnEaJVtLustR47LPDLYae22UWEAOwxj+zgJWMXIcQO/WGndjSTpq1sX3zxRSSTSfT29trqJtip0OKHPFxItDBa8FG4QKsf4qkt2pCOamivqZZFSz3Xx3HcknYZHcMobKyZ6HN8qKpaIqro21jt2quJWtXGh/a7elFBaz/qNyOPjXJeO83yFiLbaYWVWsLDGhFgaLFO56HcTECpV4r22un/+rxV2mpcVsxhI3FOS7vuFVq0giLZhYQRVVWZfbVjjNpd73hq5LvULjpOrd/Tzm99m/TH045LGifa8DD6lz6j+6nWbkSj4mC5+6EdxlA7oAf60047DcFgkP1ulnPOOacZzXLpcCYmJtrdhLZiJ3FB26Z2L/DLYae22UWEAOwR1mYHe9hFCLGLgGmHcdFsLBWGBEHAP/zDP+Db3/425ubmAABXX301i6n/4Q9/iK985Su44447cPLJJ1t5apcayOVyluW/cWkdlEOlWCwyD4pm0InjI5/Pw+fzQZZlJsYUCoWSMLZK1BtuVe4clOulVq+UXC7X1L43Ol+rx0KhUFjifWK0DQCbD/q+afcYpqTe9XgV1tLHlG/J7/dDlmUEAgHm2SaKYtlwOEEQWJXAZlOu7zqd8847DxzHYffu3RgZGWG/m0WbR8rFxQzaRT7RiaEOlbDDYlqPHdtE2KltdhEhiHZ7UNnBHnYRZOwkYHY6lglD+Xwe559/Pn7/+99jcHAQF110ER544IGSfc4//3xcffXV+OlPf+oKQ22k3Ysml/qgxMWFQsEVhmqEqstpF8skFpkRhig/Sz3nNfKQUxQFhULBFYYMyOfzS2xttA04KpYaVVRr9xgWBAEej6fpwhCFOFLid57nWZWyQqFQURgKBAItEYby+Tx4nl92+Yfe/va3g+M4lkOMfndxaRb6RT7Q/sV1q7HDYlqP/m+XHdpE2M1eIyMj4DgOW7dutcXCv91hie22h10EGbsImHb0SLQay4Shf/7nf8aOHTvwt3/7t/ja175mWOp6eHgYxx9/PH7zm9/gn/7pn6w6tUsZzLjwVwpdsBqqGGTVucy0XW8DbRUvvW2aFfLQShtbhTZkqZbv2PU6teFI2m21fr+e89bzGWE0fltJo3OhFWFERse2Y0Uxs9Q6LsttM6rOZjQPms1yFUO+973vVfzdxcVq9ALEli1bOm7RUg27hXrovbjOOeectrdJi13spV1wA0eTYrebdooAdrGHXQQZu4irdrFHM7FsBfeTn/wEa9aswTe/+c2KIRebN2/GoUOHrDqtSwWy2azhdu2bdFmWUSgUWtKedDrNynBbgSRJVY+Xy+VKfqc37Ea2KWcvK9C3ox58Ph8CgUDTPSH8fn9d/STLMiuFbTeCwSD8fn/JvclIvG7GeY08kqjCVDXy+Xxby4A3moBZkiRWVt4sRsnWyyVgpzlhN8r1uxlqsTklpCY70O9GoY+5XI6NpUAg0NLk+XYUi11cOo2pqamS31vpXWonRkZGsGHDBuzbtw+jo6NtbYt+IWnHZyQ72Mtowd1u2tkmu9hDL8C043nLTuKq3h7t9rBrBpY9re3fvx+vfOUrqz5s8jzP8g+5NJd8Pm+4XbvwoFwnrWB+ft5yYajaolO/sKYQHiPblLNXo6iqasmxqapVs6sl+f3+mhfzgP2FIb2I0AphqFwJb7PCUKFQaKv3ixXCULFYrOk7tQhDNCfsBpWNr4dahSEa22QHEmL0D3CFQoHdC83m1rKC5ZhfqFZ2796Nbdu2lYR0uLjUwujoaEnZcaAzFy1mIG+LHTt24O67726rOOSEhaQd7GVHO7WzTXaxB+UYIh577LGWjw87iavkYXf66ad3ZBgZYKEwFAqFTAk++/fvR09Pj1Wn7ShkWbbUO6DcoreRkJpGMFtq3ixmQiK0NlBVFYqilFSm0lPPItxMv1lx3eXCQJoxbhppr5ENzSZSVVW1KUlXK4WSSZLUNK+ccmNUv71cH+q/26rFvPb81caCqqooFoslwgNdD4UvNXpOs3YkqtmpWeOMaCT0kOM403Oa9lcUpeSHxrR2LurvhVrIHs2ce5Ugz1VqF11HJ/GTn/wE559//hLx5yMf+Qhe8YpX4M1vfjNe9apX4bLLLnMTT7vUjH7x1O7Eue3ELt4WTsEO9rLjgptEkaGhoZZ7qdjJHnohptXjwy4i2XLBMmHo5JNPxtNPP42ZmZmy++zfvx//8z//g7/4i7+w6rQdhdWhTGZCjrxeb9kEpVbT09Nj6dt9v99f1a0xHA6X5GehhKxGLtaUnLhWtCEaRnAc19Twr0wmY+nxzNjVCErkrLehqqrIZDKmxZdmhvTpkWUZyWSyZecrR6FQMFwMhsPhkgW9HZOCy7KMxcXFkhBhmhOSJLUkwbGeaiEUFFJqV/L5fE3CSDabxeLiIrLZLDKZDKanp1libkJ7LywUCqlTRU8AALbcSURBVEu8NzOZTEvnnpZcLod9+/axaxYEoWZPM7vzwx/+EH/84x9xyimnsG1PPvkkvvzlLyMWi+Etb3kL1q1bh1/96le466672thSFyeiXyydeuqpbWpJ+7HTQtIOoks17GQvO0EhTJOTk23xlBkZGcGFF17YdpHMHR8vYwfvumZjmTD0rne9C4uLi7jqqqsMF1rpdBrXXnstJEnCu9/9bqtO21FYvVAxE6ri8XhaFooRi8UszWvh8/mqHk9vA1EUEQgEDG3j8/nqCnXTvuk22w4rsTpHlBm7GuHxeODxeAxtWEsbW7lgVxQFCwsLLTtfOURRNBQCKG8M0cxxVC8ksmjzW9CckCSpZblstFSzUytDaOtBEISahCEKjy0UCsjlckin06yKIaEdS5IkLREi6fvtoFAo4MiRI+w+Wk8Iot3ZtWsXTjzxxJK/t//+7/8OjuPw05/+FHfddRf+8Ic/IBqN4jvf+U4bW+riRNrp3WA37GQLJyyq7WAvOy642y3qjY6O4sEHH2y7Ldo9PtrdD5XObUeht1EsE4auuuoqvOUtb8HDDz+MDRs24MILLwQAPPHEE7j00kuxbt06PProo3jb296GN7zhDVadtqOoFP5A4RrlUBRlyYO+GRf+WkJF6oXCFPTnKhaLJYKK9ndZlqsujMxUXNOHsni93rIhLiRs1AqFyFGbi8Ui+6HqXhzHLbneatDimo5bLrzA6jCoWsNZtN8rZ0Ma22bGEvWRdj/6nexQTkjR7i8IAquURsei79PvHMcZerTU0lfV9hUEoWqYjpmwz0rjvdaxVQntODZ7TL0dqb/rFYUavR4jW9E4oDmlv99WCy9r5D5YbbzqqTXs1uv1sh/KN6SvAKm1iX6e0n3KTAheLTYoFoumxHbyXCX7NxrOakemp6excuXKkm3bt2/HwMAAXv/61wMAEokEzjnnHLz00kvtaKKLg2m3d4OdsJMt7BQSVA472MuOC+52inp2EsraPT7sJK7aqS3NwtLMq3fddRe++MUvIhgM4qGHHgIAvPjii7jvvvvAcRw+//nP484777TylB2DoigVw0RUVa3o5i9JUtPegCuK0lBVLVmWDb1A9NeTy+VKQgkaTVStbzeFdJWrxFZvCFUkEgHHcRBFEaIoloR1aKkWcqZncnKSfU8UxZaHvuTz+ZoXwn6/39ADLRqNslwo1a4jGo0u2Y/GP42lVCpVMexPHyJGfUHhNRR+5/V60dfXt+T7tYTUVAvlSyaTEAShojdGKBRqKH9QraFHlaCwtlrGq8/nQ29vL/s9EonA4/HUXRWnWSFNFNJIIaVa6Jqrfb8eUqlUTfezWit5RSIRxGIxRCIRRKNRDA4OLqnCp0VflYw8Kc2EKtZig1wuh8XFxar7hcNhrFu3jv0NCwQCbQlBbCahUKjEO/HIkSMYHR3FueeeW7Jfd3e3W6DDpWbsuLBuF3ayxejoaNtLwVfDDvay44K7nZ4yduiTcuduVw6qzZs3t11cJaGX2tOJWCoMcRyHj3zkIzhy5Ah27NiBn/zkJ7j77rvx+OOPY2pqCp/4xCc67i2gVaiqWlWUqCT8aL0grEZV1bpy7xCKohh+nzw6CFEUS0IJGl3oGp2X5/my7aG37bVCQkixWGSik5EQoL/easzPzwN4OeyjkT6oh1q9HABjG3Icx8Z2OdtrCQQCzONHC4XXSJLERKJyKIrCFqTaY8myXCKichyHWCy25Pu1iKzV9l1cXIQkSRWFAb/f31CFtFrHViVovNVyTK/XWyIC0ZzQh8KZxcrr0aINcdMLmGbuc/WK75lMpqb7M3n8mIXCY+nfeDwOj8dT9n6mH2/FYnFJ1b5y1BJuZlbQDgQC6O/vZ3OE8pV1Ehs2bMDjjz+OdDoN4OiLNI7jmLcQMTk5iYGBgTa00MXJ6OeuHRbW7cIuIoOdvD4qYQd72dGzqp2eMnbok3LnbofnlFHVxXZC7bHzvK6XpiR/8Hq9+Iu/+As3yXQdVFoMVHqD6vF4mvYgzXFcQ3lCyoUo+Hy+kuul3+utZmR0Xm27tSE5RtdT7/n04Rl+v59VP9Oiv95qUNlqr9dbsX+144Kq+ViR18Xn89UsVpS7Pq3tK43TSn3k9/vZ943KwFOYC+2n9ZagY9H3tb8bUYv9zOS5ovA4LZR/p94KVrW0oRZovJkdr9RX2uuz4nqa8RKBxobR8c3c56p5sZBYqR/jwWCwprlUTyW3evan+wW1jeO4knFpRDUb0DFpzJvx/KE5UG1eOplrrrkGH/jAB3Dqqafi5JNPxgMPPIBoNIpLL72U7SNJEp5++mm88pWvbGNLXZwGLWCJdufVaTckMrTbU8fI08KO/UL22rlzZ9vuvXb0rGpn/9llDLe7LXacQ3Zsk5VY6jHkUj/VcipUq2xVbxiUGTweDxMp6qFc5TP99WgrMNECvxE8Ho/heX0+X1OS+AYCAfA8XxLWoYVCzswyODgI4GgIAs/zZftA66lhZbWlRsObjDA7ljiOK9mPfvf5fAiFQkgkEoYha0YhYtq5Q/OkWohTLdW/qh2rr68PwWBwyZjLZrOWecXoq5c1AglZZscrze96w8aMaFb1NQppNDp+uftFLe0qF9Jbbry2G7pf8DzP2qcN6TWiWj8Xi0XmVaSqKuLxuKm2mLG/k3nXu96FN73pTdi/fz/uvfde+P1+3H777SUhmPfffz/m5+dx/vnnt7GlLk5Dv1Cxc2L95YSdvD7M0C4vCLt6VrXbU8YOohAxMjKCDRs2YN++fcvWc6pcG+zQJiup+zXzZz/72YZO/JnPfKah73ca1bwGyiXJJaxaFNZz7mqQF40efbgEvc2nJLCNXlO58zbqAVUOElG0C0Cj6zNLLBZjttcnktWitSOFWllBM2xUrk+q7cdxHLNrpappFApEi3+yC33XbILxWkJ5qu1bTkywMjSw1rFVCbKt2QTAzfD0qDWUygw0hsrdz6qNTe0YLEe5JOONCOvNhO4XWrGn0rg0YwNKXA6YC5EmzN4bnIrf78fPfvYzHDhwADMzMzj22GOXhLGuX78e9957L84444w2tdLFiWzYsAE7duwo+X05Q0IDAOzYsaNtoUl28vqoRju9IOzqgdEuTyq7jF87tMmOc4hyT42OjmJkZMQWbbKSuld+N910E1vEm0U7sVxhqHaqCUftOrcWURTh9/shSRJbrNK2asfU/m7FwjCXyyEYDJY9T7FYNFWJxyxmKsDVczz9v5WOWymvSK00a0yZPa527JgNt6JxVq7Pazm32fFR7ZjauWDUViuo1oZaxnqxWGThZI2em6pS1eoJ0uyxp80npA8tLJeDyEy7ylUTs2tolFHIYCXhhyoVVrrHaO9Btd7H7WonK1m3bh3WrVtn+NnJJ5+Mk08+uaXtcXE+nb5QqRW7Cg12pp3iot2FTfKQ2bNnT0sEETuOXzu2qV1oQ3cnJyexcuXKjrJF3SvIL3zhCzXtPzExge9+97vI5/PL4uFvuZLL5RCLxZDJZNDT01OyrRYBxoqwlGQyiaGhobILHUEQWInnTqHTwjG048gMVoYziaIIjuMatme58U9hTa2glrFeKBRYWGSjiKKIubm5JWW6242iKKxCVCQSWSJ0ZDIZJBKJmo/r9/ubkjS7WRjdLyqFJVKBgErCkDY3WbNCAp2OKIr44x//iImJCQDAypUrcfLJJ9sy3NDF/nT6QqVW7CI02NHzw47Y0SuEaIcgYpfxq6VdbbLjHOp0kaxuYehjH/uYqf2mpqbwT//0T/jOd76DQqGAeDyOv/u7v6v3tC42h8KYtOEItYY26cMVaKFV6yK6WglvWZabtjDXLw5bJQCYDZVyCjR2VFU15ZFl5cLKqvLvxWLRUCyw0mOo2hypVMFNjxX5vbTnraWKVasgryBVVQ3zjdUb5uc0kdnoflGp78ljyOwxXaGjlEKhgM985jO4/fbbWT40IhqN4r3vfS/+4R/+oSk58Fw6l05fqNSKHZIpA87qFye1tZW0QxCxs1DWauw4Lu0o3FlJU6qSAcDMzAxuvvlmfOtb30KhUEA0GsWNN96IG2+8Ed3d3c06rUubofLU2gfbRpNii6JY1wIjGo1WFEmaWRI5k8kgEokwcaEZ+XqWAzR2FhYW0NXV1dJzlwsLqpVm5MvRU62SVC1j3e/3WzYvfD6fLb1G6B5VzvulWYn8nY6++pyLeQRBwGtf+1r893//NwDgxBNPxLp168BxHA4cOIBnn30WX/rSl/DEE0/gt7/9rTsGXUyjHyvu2DlKq0OA9DhpAdnOttrRK4RwRZqjtEugseMc6vQxYflqNZVK4Ytf/CK++c1vIpvNIhqN4uMf/zhuvPHGulzzXZxFOBxeUvWn0YpJ2Wy2ruS6vb29FQUZErGawczMDEKhEARBsDTvz3KDxtHU1FTLhSGrvB2srBhWjlwuV1EIrWWsh0IhS5NI1xIK2Cq8Xi9L/GtkMytDEjuJTk4O3WxuvfVWPPnkkzj77LPxjW98AyeccELJ57t27cIHPvABPP744/iXf/kX017ZLi76KmRuVTL7eBqMjIyA4zhs3brV1gvIduapsktf2QU7CmXtEmjsmj+N2kFj1y7tsgLLVitzc3P45Cc/ifXr1+NLX/oSAOCjH/0o9u/fj89//vOuKLRMIK8FrZBTyZPBDFThplaCwWDFBXktCXZrpVAoQFVVKIpSU0iSqqoVf5YD2mulhag2HKmajayymVX5pxod/2aoFipG3k96uxjZy8p54fV6bfn2mu5RWu8orV3IM2Y5z0MjtHOimXOvE7n77rvR39+PBx54YIkoBACveMUrcP/996Ovrw933XVXG1ro4lT091g7vFVvN+0uKU2LeyoBb3coT9Xk5CQee+yxZV+SnKB+3LFjB+vPZmMklLUb8pIZGRnB5s2bW3bedo7LSrRjXLSKhp/+5+fn8elPfxrr16/HzTffDEVRcOONN2L//v24+eab0dvba0U7XZYxRpXF7E5XVxfzFKolx1IqlYIkSZicnISqqshms5AkCYIgLKuFlv6Npzb8NJ1OAzgaPiXLMgRBwOLiIpLJJBYWFpDJZDAzMwNBEJDL5VrY6vZhJlwtm82iWCxienqaiZVzc3MYHx9HKpVCoVDA7OzsshpnWmiOTU5OYn5+HhMTExBFEbIsY3FxEfl8HplMpm6hutOQZRnJZBLpdBqzs7Ns/k1PT6NYLC7JobPceemll3DeeectKVGvJRqN4rzzzsPevXtb2DIXJ6NNPA0A55xzTke9vXYqdlzcV6Kd7SWvkKGhIduN33bYxe5C2Z49e5a1SAbYt11WULcwtLCwgJtuugnr1q3D5z//eUiShA996EPYt28fbrnlFvT19VnZTpdljB1zlFSjv78fHo8HPM/XlMh2YmICgiBg//79UFUV8/PzKBQKyOVyy2bBToKYlsHBQfb/6elpqKqKQqEAURSRz+eRSqUwPj6OZDKJVCqFgwcPIpfLscpTnY6ZcLW5uTkIgoADBw4wD6PJyUmMjo5ifHwcmUwGR44caUVzbQklq9+/fz9mZmawZ88e5HI5iKKI2dlZLC4uIp1Ou2Ea/4skSTh48CCmpqZw5MgRjI+PY2ZmBmNjY8xmLi/j8/lMCdW5XM4NPXYxjX5B4t6fjqK3y86dO1t6fjsv7o1oZ3vt6hUCtM8u5JljhzAywhXJXsau7bKCup8+1q5di4WFBQSDQVx//fX4+Mc/XrJ4c2kulVz1KWSEPAjo/5UqO2m3ayscUTiUdtGp3U7f0x/XSg8fp1X6AV7OT+PxeGoSdARBgKIo7OFOluUl4WjU9xzHLem3Sn1Mn1F/Go0LM/1Wb5W4WtBeL8dxJa7y5IGlKApUVYUsyygWixAEgVWaEgQBsizXVI2L0PaXNvyKftfuZ5cKcGbmCI0l7cKBhDVRFKEoSt3VuLShaYTR/Ue7Xf//dkNjpVAoQJIkFAoFNsYkSQLP82UrzJmFvktzkOajdizZySaVUFWVFQag+RcMBtk9rFHPqk4Twk844QQ8/PDDLGGlEfv378fDDz+MrVu3trh1Lk7FjslZ7YDeLqOjoyxPictS2lnJzc45hlptF21+IQC2+lvQzjxDdsvTZdfcR1ZQ96pmfn4ewNGF7De+8Q2sXr0aPM+b+rFjzgknkk6ncejQISSTSYyPj2N6epp5Uxw8eBDpdBrz8/OYnp6GLMuYnJwEALYQNFooAijZpqoq9u/fD0VRIMsyWzgqioKxsTHMzMxgdnYWmUyGLS7dN1alhEIh0/sODAyA53kMDw+D4zhEo1HwPL8knG5+fn5J7iKthxGFceTzeRSLRczPz2NqagqZTAZ79+6FKIosXI3Ch8yWFaf8Sc1CX9VOT09PDytN7/P5EAwG0dXVhcHBQXR3d6OrqwtDQ0MIhUJ1eZsVCgUUi0U21gVBwOTkJCYmJlgYWzabZf93CjSWVqxYwUSI3t5erF27FgMDAwiFQnV7eubzeQBHk64fOnQIs7OzWFhYgCRJOHz4MPL5PObn5zE3Nwfg6L2rHtGumdAcW7lyJXp6erBmzRoEAgH4fD50dXUhHA4jFos1lIBZEASk02ns3r2bbUun03jppZegKAry+bxjBBGfz4fBwUEkEgn09vZicHAQPT09WLFiBfx+P+LxeEPHLxQKthsjjfCe97wH+Xwe5513Hr773e+yOQMcnT933nknzjvvPBQKBbz3ve9tY0tdnAQtXE8//XRbeRe0G6NcKK0M93BqqEmrQ4UAZ+TIapVd7DxuWn2vsXOeLjt7uTVKQ6+7yWukWCzW9FNLzhWX8szMzGDv3r2YnJzEvn37MDExgYmJCSiKgr1792J2dhazs7OYmJiALMsYHx+HoijIZrPsoVuW5SWCgHaboih44YUXWD9rPVn27NmDI0eOYGZmhgkSiqKYFhiWC7WIE8PDwwgEAqyMcTweRzAYLKkUpaoqUqmUoTCUTCbZIhw4GpYgSRLm5uYwMTGBhYUF/PnPf0ahUMDBgwehqioTE83m46GQm2YSDofLfjYwMADg6ELe7/cjHA4jkUhg5cqV6OvrQ09PD1avXo1QKFTX4pTCh2is5/N5HDx4EAcOHGAi2uLiIlKpVH0X1ya6u7vB8zzWrFnDPIyGhoawadMmDA8PIxKJYMWKFXUdm0L/Dh8+jJdeegnT09OYm5uDKIoYGxtDLpdDKpViY212dtZ2uXooHG/dunXo6+vDpk2bEA6H4ff7kUgkEIvFmA3rJZ/PY3Z2Fs888wwTgFKpFJ5//nnIsrwkhNLO+P1+rFq1CgMDA1ixYgVWrlyJ3t5e9pKo0Wp0uVzOdmOkEd72trfhXe96F8bHx/Hud78b0WgUg4ODGBwcRDQaxTvf+U4cOnQI7373u/HWt7613c11cXE8+iiGVr6UdmKoSTtECSfkyGqlXZw4bpqFnUUyO7etUeoWhii8pd4fF2Mq2YaEOIJCaMiTRxs6Q4l5VVVl4Q/0kF0sFqEoCgu7oVAG8grSVtPS76cN3xFFkZ1fG/Kkf+NtVK1Gu682HIiEJRKitO2zE/o2aX/XjvFy1XrIzvoKUVQRisqL+3w+eDweVlVKfz69Xei4+n8lSSqxLwm0JNZSH+p/tGND2296yoU21lqdSBsOV24cUcU7j8fDfnw+H/Mgov+TLWu939AcomsWRRGiKEKSpIpzRW8vozFQT4W6WvfTzxlqC40lbel6qsxF1bnIG8bsnNPbQBRFNr5oTkuSxO5HZCOa29rv1zNOqu2jD8HU94kWCu0KBALw+/2sqiGNNa/XyyrM1dNWugfr753knUb2AF6+R5O9tJSzVb33SaPvUb9Ugrz2aPzQ/ON5ns3JWs+rnz92u+83yu23346f/exnOPvss+H3+zEzM4OZmRn4/X68+tWvxs9+9jN885vfbHczXRxEJ1fHaRS993orvdntnFC5HO0QJZyQI6uVdrHzuGn1vcbOIpmd29Yo9kiQ4QIAVb02ZFlmoRjAUY+JgYEB9Pb2Mq+JoaEhAEeTH4fDYXR1dSGRSEBVVfT09ECWZRb2tXfv3pI3stlsFrOzs0xkmpubw+LiIlauXAlBECAIAlvQpVIp9PT0IBaLoa+vD8ViER6PB6IoLnkrQ+ERtEAsFArIZrMlb8cPHz6M/fv3Y3Z2Fo8++igWFhaY91M2m7XdH4t0Ol3i+aYPC6B+TKfTGB8fhyAIJWEik5OTS7aRJ0U1OI5jb+O13lkcxyEUCsHr9TLvLurffD6Pvr4+BAIBeDwezM3NIR6P4+DBgwgGgzh48CBEUUQymcTExARmZmaQTCaZhwxdDyXB1ufWKRcCQ1XDamFubg7ZbNbQI0prZ7PUWpksn8/D4/GwxfHo6Cg8Hg+i0Si6u7uRTqeZFxeF71EltGw2y7ZRqJnWi66Wtpj14jIKuZmbm2PbtOPRiCNHjizJLZTNZk3ZenJykn2XPDxEUWT2O3LkCEKhEKanpxGNRuHz+TA/P8/uFdPT01XbV+6azYhs+mug89QSsiWKYkkScwr5MotW+EmlUohGo1i/fj1efPFFTExMwO/3Y82aNWxOqaqK8fFxpNNpFv5Z6Zr011YrRsdLpVJ1iTK12NXovPl8HpIkIZ1OM0Gu03jTm96ERx99lCV7P3LkCDKZDB555BG86U1vanfzXBxGJ7+5bhQ3oXJttCMs0QkL7FaKNXYeN62+19g5TNbObWuUznvqqsIf/vAHXHnllRgeHobf70d3dzde/epX48477yy7sL311ltxwgknIBQKob+/H1deeWVJjggrqVR9qlgsLhGGBgcH0dfXh1AohEQigeHhYQBgOUN6enqQSCSgKAoSiUSJMPTSSy8tEYaSySQTFNLpNBYWFrBq1SpDYai3txfxeBy9vb2QZRler5clINWiFYbIo4CEIbrWiYkJFv728MMPY2FhgYW+ZTIZWwpDWttpF2W5XI6JXpQHShTFkr4lYUi7jULBzJBIJAAYC0M+n6/EK4HaRMKQ1+vF7Owsurq6MDY2hkAggLGxMQiCgOnpaZavivJHKYrCro8WqfokfOUW6kahitWgnFVG3gStEoZIXFMUBbt374bX60U0GkVPTw/m5uYQCoWYMJROp5HJZDA9Pc3GdDqdtkQYMnO9lGhby+zsLNumn2t6jhw5UiJyqqpqWhg6cuQIm5taYcjr9UJRFBw+fBjhcBhTU1OIxWJLhKGpqSnkcrm6hCEz+Wf0x9UKQ2a9twRBKBGGasnHBYDd9xRFQSqVQiwWw8aNG1k1OJ7nsW7duhJh6NChQ0in05icnMTi4mLFa6q2vRpGf3MaEYbM2tXovJT/joQhpyTirsR//Md/4N3vfjf+z//5P/irv/or/P3f/z0OHDjAcjQNDg42pQpZPp/HZz7zGYyMjCAYDGJ4eBjXXnstJiYmajoOhTWX+3nhhRcMv9fqZ6flihMW1ssRV7AzhxMW2K0Ua+w8btx7zfJgWdVE/fnPf443v/nNkGUZW7duxatf/WrMzMzg8ccfx+9+9zv85je/wV133cX2VxQFV1xxBe699150d3fj4osvRjKZxLZt2/DAAw9g+/btOO2009p2PV6vl/34/X4WRlMsFlloCIU/AGBhItrwCPpdi/5NLYXu6B/SteegY1Z7y1vpQZ8+01fnacXigEI9jNpe6bN6aeTaOI5jC2+j7fq+pe0+nw+qqrJQIhoPFB6jtXulymbasESv11sSHkfbGumzSudvxVjQjz+Px8PCZbR2pTw9Rn2pbyf1lTaEUBvm1kzPiGo2s8LWdC3aMD7qR7Ib3StofyO70TjSLpS148rpkB1oDtLc5HneMITSjDgiSVLN1Q/tgJlx6XRh6K1vfSt+/OMfA3i5ytp9992HW265BT/+8Y9xySWXNOW8hUIB559/Pp566imsWLECl156KQ4cOIA777wT999/P5566qmaH+qvvvpqw+1dXV1Lttn92amToIU1Vbuz48K6XbSz2pUTq8VpK2Lt2LHDtkJNq2nlOLLzuGn1vcbO49HObWuUZSMMFYtFXHfddZBlGXfddRf+5m/+hn22e/dunH322fjRj36Ed77znfjLv/xLAMAdd9yBe++9F5s2bcLjjz/OEtn9/Oc/x+WXX463vvWt2L17t6Vv+yKRSNmHYZ/PxzxFaF9aaAwODrIQLgp7oXZR+BDlrBkcHEQ4HMaxxx5bEvYVjUbh9XoRCoWgKAoThHieZ2WVgaMP7IODgyy/C8dxSCQSbH89lDhZK0zR/2n/VatWscTBr3nNa9jDpsfjQSQSaagSkBlkWYYkSWUriGWzWcRiMfZ7T09PSZu0yZLD4TBbBPT09LCFIAkwwNGkv5TLRLtArqUqlMfjWeKdRR5DiUQCgUAA8Xgcfr8fK1euZIvPkZERRCIRxGIxbNiwAbFYDOvXr0d3dzfC4TBLsEuLVuoDAMwrbGpqCoqiYGBgAIIggOM4zM/PQ5ZlFs5I+1eqMGZET08PG7P6662lwhtRa2Wy3t5eeL1eNr+2bt2KwcFBVrUqkUjA5/Oxcd3V1QWfz8e+w3Ecuru72RjQCkDafEXRaBS5XA6KohgmyeY4rmISbiIYDC4RTRKJBNtG47HcfWXFihUlCZWpGp4ZIYaSpZNAuHr1alalCjh6z4rFYiwXTXd3NzsHz/OsehzZSpZlzM7OsgTjwFHvJ5/PV5LM2OiajdDbj8ZCKBQyLcYFAoGSxW+t45AEdI/Hg1WrVsHv9yMajWLz5s2IRqPsviIIAvx+P4rFItasWYN4PG5YWU9/TYcOHWL3I6NQ3mqEw+ElY6Ovr68uUaYWuxqdNxwOs76mHE9O5bvf/S7uvvtu+Hw+vO1tb8Mpp5yCxcVF3H///fjv//5vvP3tb8fY2JihsNIon/vc5/DUU0/hzDPPxEMPPYRoNAoA+MpXvoIbb7wR1157LR555JGajvm9733P9L7teHZaroyOjrqiUBn0i+xWJp92omDXDiHNCQvsVoo1Thw3zaKdwm417Ny2RuFUp71mrJNdu3bhhBNOwObNmw1dn6+//np89atfxRe/+EV89KMfBQAcf/zx2L17N+6991781V/9Vcn+l156KX71q19h27ZtDecF2LJlCwDg+eefr7iA03oaGCXmpTes2gS+RolSFUVhQo92cUX7Gb211p6DjlEsFpHNZtHT01Pymb795ZISa/elRKMejwfFYpF5t9C1NvvtMeX7oYWrvq0zMzMli1WyodY2dD3a/2uvS4uiKCXbtP1mdjGkt6F2m9b7gNpBx5VluWRsaP/VflfbNiKVSrEQQ1mWsXnzZmQyGYTDYSSTSRQKBWzZssXQLmavSfsdo2urZRzU8x3qW4LyZ+ltpj8HoR0DNH5nZmbQ19eHvXv3Ynh4mOV8mpmZWSKm1dp2/X7l5n+548iyXOLBo/9+Jei7hH68a8eX/r6lH5fAUe+X/fv3l5QZfvHFFxEIBLBmzZqabGNkF/q9lnGhn5f1jGmCrpcSLJONJUlCLpdjXlUkQpL9tDbSn/93v/sd1q5di66uLiZO1oLR9ejvb40cq5Z99fevV7ziFQCO/m10Gueccw6efPJJ/PrXv8ZrXvOaks/e8Y534Ac/+AG+853v4B3veIel5xVFEQMDA5ifn8czzzyDU045peTzk046Cc899xyefvppnHrqqVWPt27dOoyNjdXkkdaOZ6fliHZRDcCWi+p2s3379pKqV62ykRMFO/14Ouecc9iL8mbx4IMPlogup59+Oi688MKmnrMeRkdHsXPnTnAch61btzY9z5Adx06r7zd2vr/ZuW1AY38bnfs6rkbMvimgN9379+/H7t27EQqFcPHFFy/Z7/LLLwdw1C3cSqqFWunDfehHH5phFKpBSaX1+Xq0b+u1x9N6BGmPSZ4k9PCur2pF1Zv0FWb0C2v98ahqElW10YZFaaseEdpqUPrrIaGHrpnQVkrSV9iqZnstWvvScamCkCiKyGQyLCcO5YqhfVRVZYKctmKc9lqp3dqFkiAIVcNM9H2lHS+0wFX/N6kx2Z2uh3701by04p02NE274Nd+V2uTSnbVhp/R/iQ4ku3y+TwKhQLLb6WvZqVFW9mJclrR72by0WjbRdcLoKSvtDalMa29fq3dtban/xuFn5Wzj9mFOY1lyrtDeV4KhQLL/VSpD+hfrX0rCdRatCFj2jFGOa44jmNzlu4H2vGp/77WRvQdrS1rsY12H8oJRHm3RFFkYyqfz7NtWqi91O/aKo/0uRm016edNyQC6c8hSRKzEc3FStdOoXr6e5JZaJ5oEQQBkiSx3HKSJCGbzbLqcpWuFcCSe3W5favdv5zMn/70J5xxxhlLRCEA+OQnPwlVVfGnP/3J8vM+8cQTmJ+fx8aNG5eIQkDznl2Idj07LUfsnI/ELuifd1tVgt2JleIoyTLRiuTH+rWZnUKn9IyOjmLPnj1N7VM7j5123G9GRkawefNm2wkvTsiNVS/LRhjasGEDNm7ciD179uBHP/pRyWe7d+/GD3/4Q/T09OCyyy4DADz77LMAgFe84hWGYUxbt24FADz33HNNbrk1KIqCgwcPIp1O4/nnn0c+n2deH5RkNpVKlSRUroYgCCyR8dTUFBYXFzE/P4/p6emSBcXi4mJJYlQSSWohm82iUCiUJM6kpK7a6mbEwYMH8dJLL2FiYqIkiW42m8XCwgJSqVRJ1S6fz1cx5KnaW/h0Oo3FxUVIkoSxsTE89dRTKBQKePbZZ7G4uIjnn38ec3NzmJ+fZw8qsiwjlUqxviDy+TwOHz5ccl2yLOPgwYN15RGhPiZ7zczMYMeOHawPqJ/0zM3NlSzustksgsEggsEg+vv7EY/HwXEcYrEYAoEAEolEiVeVmUS02mskO0xNTWF2dha7du3CSy+9hP3792NiYgLT09OYnp6GqqqGfT49PQ3gaFJbsq0gCJidna0pMS8lxaVzUNWsw4cPs31IXDMLhZglEgnwPM/CgSKRCAvzqJfJyUnk83ns3bsXuVwOL7zwAtLpNLNdpXbSdYiiiLm5OVaVsN5ExvPz80gmk5iensaBAwdQKBQwNjbGRD6jftPi9XqZOA8cHZvxeLzhcJuxsTF2D5yfn8fExAQOHDiAxcVF7N27F/Pz85iamir5Dt2nZmZm2HhQFAUzMzMoFos1J1XXorXD4uIiZmdnEQqFMDs7ywoAmIXCzihcr1YOHz68JNH4Sy+9hMOHD+PQoUOsSuGuXbuQTCaXVEnTQ7ah+bhcWVhYwMaNGw0/o+3a+75V0LMLPaPoqffZ5ZZbbsF73/teXH/99fj2t7+NmZmZiufvlGcnO+Mmg62OHUqwO0mwa6WQRkmdCbuVZ9fSqj6189hp5VwigYzEODsyMjKCDRs2YN++fbYS8Bpl2QhDXq8X3//+99Hd3Y23vvWtOPXUU/GWt7wF559/Pk488USsWrUKv/3tb1kOn4MHDwI4mvvGCNo+NjZmug1btmwx/Nm7d2+DV1cdVVVZ6eN9+/YxQUX7ZpeEIrNQWer5+XlWYjyTySCdTrNcKiRKaBdRgiCYfttOkPePtmoXveU3WqBNTU1hfHx8ySIrn88jk8lgfn4ekiQxYYg8lcpRLadIJpNhVZkmJyexa9cuiKKIF198EdlsFvv27cPi4iKrCAccFWxIKNIuFOk6tYs1RVEwOTlZxUrGkLcRXS+Jg9TXeq8qYnFxsUQozOfzLC9ST08PyxESDofB8zy6urpKcmDpPZyM0F5joVBALpdDKpXCwsIC9u3bh0OHDuHIkSOYmZlBOp3G3Nwc88DSMzs7yz5TFIX18eLiYk3VzKjd9B1BEFAoFErGHtnULCQ6Uj4i+j0YDJrKI1SJVCrFRNN8Po8DBw4gk8lgfHwchw8frtrOQqEASZKQyWSwsLDQkOhBc2tubg6HDx+GJEmschl5MFXC4/GUhHOKomiJeHbkyBEoisLugdPT0zhy5Aiy2SzGx8eRyWQwOztb8h2aF+l0usT7j36v5hFTCe14zOVyWFhYAM/zWFhYWCLIVmNwcBDRaJQVIKiVZDK55Hzj4+OYmZlh1QnT6TT27t2LdDpddS6Rt5jenssNrWeoHq3XodU049kFAD760Y/i9ttvx1e/+lW85z3vwbp163DHHXe05PztfHZycakVJwt2rWy7XvSwW/VhLa2yi509qMhLhrx4momdBTLCzt5djbBshCEAOOuss/Doo49iw4YNeOaZZ/CTn/wE27dvh8fjwete97qSCUhvRcst2siDRF9K2M5QwlZKEEqLCHpILZc8GgAL79EKCBTm4Pf7wfM8q4qmD23QViOi79UaJkDn0t409SE7+msNh8NLkhhTyBq10aqQHko+zHEcgsEgurq64PF4WIlu/cJNURRWTUgUxZIFHcdxLMeSNgyq1iTOWrT94ff70dXVxa6pXNiGNlk28HK/Ucif1ob6HzpuNfTjgqpa+f1+RCIRhMNhBINBJkhpk2LrIWHP6/VClmV4vV5WOr2Wilb6sC+ynV44rCUxbjkb1ZPHRQ9VAQuFQizHjM/nQzgcLpsMWDuXtYnp6R5Qb9JfOgbP8+zclETYTD/o7dFIiJQWytkTDAbh8/kQCATY/ylhu1H/0nzRjjkag40kRtaPezpmIBAwTLxeCf0crBWj89G9k354nmf3MDN9WE1od2keVj+7XHLJJbjnnnswNjaGXC6HXbt24YYbboAgCHjnO9+JX/7yl009v0t5nLB4ajftCn/p1DATK3GSgEZhdkNDQ03zbHKKB1UrQuqcMDY69f67rEpC3H333XjHO96BM844A3fffTe2bNmCw4cP40tf+hK+/OUvY/v27XjyySebVrmgXBIoShLVTDweD9asWQOfz4dNmzaxRREtKIGj+ZXKvXHO5XLgeR6KorAHPqog09vbC0VRWNWrSCTCbOj1ehGLxUoWLGYrCmmJRCLwer1YuXIl20bnM2rzmjVrUCwWEQgESh5QI5EIQqEQotEoKxltBd3d3WwxtG7dOsRiMQSDQZx88smIx+N4xStewaoqKYoCQRAwNzeHaDSKZDKJ9evXl1wXed5ks1m2cFy7dm1d7dWKBqqqYmBgAGeccQbrg3ILUQp7Iigcivo9FotVDF0Jh8NVF7haTxBajJLIeMIJJ7CFKImOwNGFp1Fo3+DgIPusUCggHo9jdnYWiUSipoS81G5tBStVVUvGnsfjadjTxypWrFiBcDiMY445BpFIBMcddxy6u7uxadOmsu2kvETBYJDNLUoiT0JTPXR3d7M8RfF4HIFAAOvXr2dtqDUUkiqeNcr69evZPZDuT8ViEfF4HJs2bUJXV9cSO9GcGRgYYOPK4/Ggv7+/rmp7WrTjnkIxgaPVClVVbWn1nOHh4SXXsmnTJgQCAZafyu/348QTT0RPT09VwYcEZapEtZz5/ve/j+9///uGn3EcV/Zzyt1nB7761a+W/L5lyxZ8+ctfxrHHHot3v/vd+NjHPoZLL720qW1o57OTnbFzaWu74NqoNjq52lIjaEWbyclJrFy50nK7OMGDqlXjwwnV2Tr13rJshKEXX3wRV199NQYGBnD//fezB/NNmzbh9ttvx+HDh3H//ffjjjvuwPve9z72eblcGxT6oy1hbmc4jkN/fz/y+TyGh4fB8zx7wKfFe6VrEQQBHo+nxGOIFi/VbKBfdNTzJpmOoQ1VogWjkTDU399vqi1WoRUe+vv72flJ8NFWVMpkMqyi2+DgIBYXF0tC1cjDiMJvyAOj3DVVg+O4EpvH4/GS8ujlxB3tNZG3BfByv1cLrzPTz9oFMO1Px60UPkQeIFooBCkQCGBxcRHhcBjj4+OspLpZaF+6XmqX/hitXLxXggRHqmy2evVqAJXzYlESdvLGAkrnUb1lpLXiCuUF0uadqpV6cuYYQW2gOaRtJ403vTBE56a5QuOBfm/EY0g7dkKhEGsD9WUr0d5TiRUrVizZpr1nVIK8vIwqPC436i362kix2FY9u/zt3/4tPvWpT2HPnj04cOAA1q1b19Lzu7iYgRaYVFGqFTihBHs5WrnYdZII1Yq2OkFocEIbWwV5kY2OjmJkZMS2Y7dWlk0o2Y9//GNIkoQLL7zQcMF55ZVXAgBThGkhPz4+bng82r527dpmNNdytNVe9JWAjEJc9FD4kPbtfaVjVDpuPSEPlY5TrrJNte9YEcZT6bjlfmjhpK3Cpm+j1+tloWdGlZvMQJW5qvVJueOasV2l9tT6eT3jibxT9N8n25LXRy12a9YYbha1zD2i3vuAFW2ppy8apZ52WXkd5dpT7v+tHFv1XLuZ49llfrQLqnpZ70+9tOrZxePxsCTaR44cafn5XYBnnnmm5PdOCWVoBq0IfyGcHGLSipApwgnhQoST2toJOCF/D3mRTU5OtqSCX6tYNsIQPYyUq25D2+fm5gAAJ510EgBg165dhhWb6A/yiSeeaHlbm4nf76/L0yESiYDnedt4STgZyttBNtW/safQr2g0img0ysSNeqhWBcrpUAUyPZQQe3h42DKvk06i3vuAi4uLvaFnF71oQFj57ELPS1rvxE59drIbRtV63MWqMa0WapwsIrRysdtKEapRWtFWJwiKbnW2l3FCG+th2QhDFGbx9NNPG37+hz/8AQCYO/T69etx3HHHIZ/P44EHHliy/7Zt2wAAb3zjG5vQ2uahTTpdC9pcLy6NQUl4KZeOPoSF4zi2cKdEzPW+fbdjjLKVSJJkGHZBeXLi8bglOWo6Db33n4uLS2dw1llnoaurC3v37sUf//jHJZ9b9ezy/PPPY8+ePQiHwzj22GPZ9k59drIb+kVIJ4UyWE07hBqq3OSkMDKgtYtdJ3lctKKtThAUW9VG1xbtY9kIQ5Qc8bHHHsM3v/nNks+eeuop3HrrrQCAyy+/nG2/4YYbABwt0zo9Pc2233PPPfjVr36FY445pulJF42g/CD1UK+LvzY8QFXVhko1L3fIjiT4aHPxkNChtXehUCgJLSgUCqzMfbWx0ImVgURRhCiKLPG4JEmYnp4uEYjIdrIsl9iOvge8HGrXrDY2kiekHhRFQbFYRLFYhCzLbCyJoghBEFgpeVmWkc1mIYpi1dLjAJbM90buP+2GbEOIosjyfeVyOeRyORQKBeRyOUiS1PHCajmKxSIKhQJmZmYgSRIOHz6MXC6HVCoFURRZ8nLaVigUmjaXXGqD53l84AMfAAC8//3vL/Ea/cpXvoLnnnsO5557Lk499VS2/etf/zqOPfZYfOITnyg51n/8x3/g4YcfXnKO5557DldccQVUVcU73/nOJX9n7Prs1EnoFyHa/nRpHxQCY+TR5QTaWa7ezh4XrWqr3QXFVpasd23RHpaNMLR161Z8+MMfBgBcd911eMUrXoErr7wSZ599Ns466yxks1m8+93vxmtf+1r2nWuvvRaXXXYZXnzxRRx77LG44oor8Jd/+Ze4/PLLEQqF8MMf/rAtHjR2WLB0eohSK6By3lo3/Hw+vyS/RCqVKll0pdNpjI2NYXFxkS3gylFLNS6nkMlkWKnjcDiMXC6HZ5991nBfEpEI7bhVFKVp45hKNreSYrGIfD4PQRAgSRILsyNBaHJyEgcOHIAoijh8+DDm5+dZKEg1tNdjh/tPvQiCUCJqZTIZCIKAqakpTE9PY3p6GnNzc0gmk8jlclhYWGhja9tHPp9HOp3Grl27UCgUsGPHDszMzOCFF15AJpNBPp+HLMtIpVLYvXs35ufnTYmMLq3hU5/6FE4//XQ8+eST2LRpE9785jfjjDPOwI033oj+/n7ccccdJfsnk0ns2bOnJFcQAPz+97/Ha17zGqxbtw6XXnopK8F96qmnYvfu3TjvvPNw8803Lzm/XZ+dOgknheG0G/0ifufOnS07l53FDiNosXv66ac3fUGuD2e3s8dFswUzpwmKzczZ5dqivSwbYQgAbrnlFtxzzz14/etfj8nJSdx7773485//jHPPPRc/+tGPcPvtt5fs7/F48LOf/Qxf/vKXMTw8jPvvvx9/+tOf8KY3vQlPP/00Tj/99LZch6IohnlVWkUzPS2WE36/f0nyaaPQKFqEEYVCAQsLCxBFkY0FVVVLfoCl1cg6BUmS2Pjz+/3MY8gIWZaXeIgQqqpW9Xyp1+unHR51dD3kJUU2kiQJoigim81ifn4eiqIgk8lAFMWKoqIW7XwnzyT9mNOPPzui9xiSJAnFYhG5XA75fJ4Ja/l83lIBzKxd7GK/YrEIQRCQTCZRLBaZx9Ds7CzzslJVFfl8HqlUiomRjeCkcWR3gsEgtm/fjk9/+tMIh8P4xS9+gbGxMVxzzTV45plnTC9qLrjgAlx77bWIx+N44oknsG3bNrz00ks4++yz8W//9m/4zW9+Y1id0q7PTp2Ek8Jw2o1+vI+OjjbNXp0QXjIyMoINGzZg3759TbOTtvw7ANuLm832DnGSoNjstrq2aC/L7pXNZZddhssuu8z0/l6vFzfccANzjW4WtTwEtzs3SKcKDnZAX6EMOOr1o+3zUCiERCKBYDDI8j6RpxHlJOpkAoFAyXwJBAJYuXKl4b4+n6/Ento3VNXGsaqqWFxcNF2mW9/GVuPxeJjYSDmsOI5DIBAoybfk9XrR1dWFYDBo+q291k40FklkmZ6exsqVK5HP5xGJRCCKom0TW1OuNILyfMViMVZ+nuaQlfe4yclJdHV1LcknpodEq3Z7U/j9foRCIaxYsQJ+vx/r1q1DNBrF4OAgAoEAm1eRSARDQ0MIhUIN20tVVczNzbH7HfWHS32EQiF89rOfxWc/+9mq+95000246aablmw/88wzceaZZ9Z1/lY9Oy1XnFTqu93QYl7rfdAse3VCCWvy2ACAHTt2NMVzSD9+neKFTELZnj17LLWLk8rAN7utri3ay7IThuxKLeVpqYx5O+nEECU7YFSBrLe3t0Ts6e7uRiQSYQt+r9eL6elpCIKArq6ujk+4rB97sVisbIUb/WJV+12Px1N1oT45OVmXMBSNRmv+TqN4vV4Eg0GWX4kW15FIBKqqIhKJQJZl+P1+rFixAj6fz7Qgrb0euv9QPp5nnnkGAwMDSKVSCIfDyGazthWGAoFAiVAYjUbh8XgwMDBQUjKe8lcFg0FLzvv888/juOOOqzreBEGou0CAlQSDQfA8jy1btiAYDOK0005DLBZDPB5HOBwGx3HweDzo7e1FJBJBOBxuWMhRFAVjY2NYtWoVwuFw223g4mJnOnFB0ky2bt1aIgw1y15aT5jJyUmsXLnSceJQK0RHJ47fZtrFSYIieU/t27cPGzZssLytri3ai/vkZRPKLdCMtrfzTSq1pxO8UijJM/3fiHqrgdWL0WJIv8imcvdaKMFwu0IMteFrzUY/9vx+PxKJhOG+eoFM+12O46ouPs2GWlVrI1A6xpphJ4/HU3JvoP8btaWaQKGFEqXrj0tJqGdnZ6EoCnvjZ+fE1OXGg1E4jJXMz8+bCi+s5QWBGeqdlzQvSFjt7+8HgCVCWTAYtEw8U1UVmUwGxWIRiqJYbgsXl05jZGQEHMdh69atHbEg6QQ6wZOrFaKNkxb/RDPt4jRBsZl95jRbdBqur7ZNKCf2aN0rFxYW2p53QZ+jw6moqop0Os1+p5wslFMjmUw6amESDocRi8UMQ9FaQadWquvq6rLsWCQyOcVluhp+vx/BYBDr169n4VgUuuZSyqpVq0x5Wfp8Pss9ZeoVN1uNx+NBf38/C3HsZK9HF5dGcFpyVjvQqlwgnZJjqNmJzZ2YI6uZdnFarprR0VE8+OCDTek3J9mC7sU7duxwk0+7WEs5YYiqAamqaguxQl/lyclMTU0xoU2WZeTzeYyNjUEURRw8eNDWng96uru70dfXh0gk0hZhSFGUjqxKNDQ0ZNmxqAJaOyqWNYNgMIhYLIatW7fC5/Oht7cXgBtmasTxxx+Pnp6eqvsFAgHLvTGdUkHS4/Fg7dq1iMfjTbGDi0un4KSFk11olWDTCdXiWiHaOHEMN9MuThIUmy2GOMkWThzH1XCFIZujr6DT7motqqq2XZxqBK399BWqKBxGVVUIgsCu0yqbW9132uNRslyv11siDDV6zkpVgrTbVFV1hCdZLfYw8n5pxJ5UPc5o/pg5brvnvr4NlPi8q6urpLpeox4v5cac2Spo7bRTuTbHYjEmdFRqnz4csNbzGtmFxl27qdYvHMex3EJu8mkXl/I4aeG03HCiJ4yeVix2nTiGm2kXJwmKzR4fTrKFftx2gse8++Rlc7S5L7q7u9sehuLz+Rz9JpeEHwAleWk8Hg8CgQAGBwfh8/kwMDBQssC1whvG6pCOQqFgSkxo5Lwkkhldv3Yb2c/uNNqPxWKxbk+yUCgEjuPK5mQx00/t9spqRVgSjWv9tYqiiEwmw8qlp9NpFIvFJR6Msiy3zauxWCyWlG03speiKJa3b3Z2FrlcDvl8nonaZAev12sL0baesWsHQcvFxcX5tOrNfid4ELRqsUvV4ppR9awZNFPMcpKg2GxRz0m2IBGLsHt7zeAKQzaHwjI4jkNvb68pMaCZOL0cei6Xg6Io4DiupBIRVSBavXo1eJ7H6tWrS4QhK8Ix6NxWkc/nTQlDuVyu7nNQiJ3R9Wu3eTyepifwtYJGbAE0FkpJc9ko1EpRFFNta3dYkNVj2Aga1/prLRQKWFhYgCAIEEURqVQKkiQtEcuLxWLbBHS9UJXL5ZbMUVmWLRfYZmZmsLi4yMQhRVGYHbxery3CYusZu072TnVxaRadID60mlaJHU70hNHT7MWuU3NkUQUqErSsxElzutkePU6yBbA0b6jd21sNVxiyORQaRJWBzIhClcIsGqXeUId2QyE82tAnsidVJyOvF/pXH5JlRRvKba8UMmO0D1B+0aQPV6p0DLPtNvqefptV46JaO8vZywzaMdCMtlX6Ds3lckl1zc5tPXRN1O9G16gf/7WgnzdWUc6WNHb141t/DbIsl1y7fkwYnaNSOJrejkbfqfWayoUNWi14kC2M+srj8VScM5XC8Rr5W6K3ab33HhcXl1KMKpW6VKZVb/ZJPDj99NMd4wljRDMXu05b+OshQcvK/DpOEhSb7dHjJFsAzmtvNZy3wl/mmPHKoPChRr0jOglRFJHNZuH3+8FxHHuzb7bEuxXeMMFg0DAxtN7LQFEU5lFAfWjkHUShSXoEQcDi4iKAo55m1PZ6xoPH40EwGDS8fu22RkPW9FQKO9Ffh7ZUejX8fn9DYTx+v79mjzltf5ajUoiZFqN+WFhYYJ5Ms7OzyGazhh4ic3NzdYUUkRcKUH4M10OhUDAUSGhch8Phku2BQADRaBSBQAA+nw89PT2QJAk8z7PwMuComE5l1vUhabQfzScaS4IgMO+efD5fMsbo+2bmjz7U1qi/vF6vZSXeid7eXkQiEYRCIQSDQXg8Hvh8PvA8D57nWQl4LXQ9RqF39Fkul0OhUECxWKx5fouiiMXFRTb+67mHOvElhItLs5mamir5vd0pBpxCK97sj46OYt++fdiwYYNjRSGguYtdJwubzRK1nCQotiLHkFNsATgrJ5IZ3KcuhxEOh6suzKhClCsMvQzlJ+F5Hh6PB5IkQRRFFAoFU4tlKyotles7feiLNtSEwi9qEYYo5AYoFYbqCeUgYcjo+rXbrKxKVi38Tf9ZLaE5gUCgIWGIFtq1YFYY0gshRhj1w/z8PBOGkskkMplMSZ4bYnZ2ti5hKJPJMJubuf+YpZowpL/WQCCAeDzO+qC3t5cJQ4IgMGHI5/OxB039WKL9KNyK5kShUEAmk2EhfdrKcSQYmZk/fr+/5CHXyF5er9fyB+G+vj7EYjFEIpElwlAgEIAkSUu8oMguRqF32msuFAqQJKlmYUgQBMzPz7N7Qz33UFcYcnEpxSj8xulvqFtFK3KjdFrp6mag/3vjJGGzWWPISYJiK+aRU2wBOCsnkhncpy4bQW73+pAPrRu+x+MpuzDThijQ/o2GznQaFJZX63esWKBU6rty6Bdz2vAZ2lYpNKXRttP3jdqu3ea0MUY2JE8KIxsabatn/JjBTD+V26cZttfah34nW1SqrmYFNK7oXzqXx+Nh1aooJM+oP6yar9XQ2kFrHwAs+bPR/GhG+3w+H5unZJ9Kc7cVVArjc3MHubjUh/7t/MjIiCMWT3bAzY1inmZeS6eF3jSK0wTFZuZacpotgM6a94ArDNkG7dtrfXiTIAiGHgBG5HI5lgg4HA67XkP/C8/ziEajLL8LlXcPBoNlc760Cq2HA2AcahIKhViIGIXDZDIZ5qWj9WYIBoOIx+NLzmOF11M5rEw+rfVyMkLvWVOLB4YoiuB5HtlsFrIsI5lMLvHO0mJFsmfyumoW3d3dJV400WjUMNwtkUiYHuvkzZNMJhEOh5mHSTabRTKZBNC4bcizpRr6cDAt5JFD4WV69J5YtF8oFILH42FzIhAIIBKJsHGsnSvlQtvm5+chCAIEQUAmkynxMspms0ilUlAUxTBBdqvR21p7PdrQO4LsGg6HEQwGWXL+WiGb+v1+FuZYqT9dXFwqo/9bNzQ01KaWOA83N4p5mp2s22kVyYhmiABOFRaakWvJibbopHkPuMKQbdCGKuiFIUmSTFeVyeVybGEdCoVcYeh/4XkekUiELYy1YRZ2EIa0CzMjISEUCrGcHTQ+stmsYf6TQCCAWCy25DzNrBpmtfhRqa36z2o5NwlD+XyeCUO0aDdarFqxgG22MKQNr0okEohEIoYiSU9PT83CUCqVYiJJLpdDLpdDKpWyZHFvhTBEY4Hn+bLCkHa80H4k9tBnFC5J2/TCELBUkKTcToIgIJvNllQgy2azmJubY15XZoX9ZmFka7ouvTCt/YyEIb/fX9cYJgHO5/MhnU6X5HFycXGpHTe/UP24uVHM06xk3U6tSEY0QwRworDQrLnkRFt00rwHXGHIVpC7v1FohNlQANpXG0ZAUOjDckQfmqKqaomtrEAfTkL2phCwSm3TtkH7Oy3ktX2q3xfAEm8AOiedl8JaKl1rI+PDSjtWC7UxsoHZc2vDbLThSHQco7Y0ipn2UX9VC7NRVXWJyKC9Jm2olb4NRtvLjU39eNPOGeqbemyjHWO13teM2q3vz3LXof9df33a/+vvm9rtWvTn1s5/2l9RFFPXaEV4lT7UlOa/PqxN2z4jG+mvWW/favcz7TH0Nq0011xcXCrj5hdqjFaVrO8UmpGs24keIVqaEY7oxOTFzRJwOk1kcSKuMGQTPB4PotEoADDXfaLc23Aj9OFC2t+1b7SXM/VU2DGDKIoli3ZtqE29nlva/qMQMQqH0Xqi6Ps9m82WJA02c36jBNedBnl9kPfYwMBAWRuW29YMKFSr2tik8C6rz6uHPD0GBgZKFvPRaJRtq8c29cwDozAuO3iddHd3IxAIIBgMIhaLlVTmi0ajSCQSEATB0CNHTy0J1CtBXoTaJNraZPRWYaYfA4EAC2n0er1IJBKIRqPweDymEq27uLiU4uYXaoxml6x3Yn6USrjeMUtpRjhipyUvXm502rx3hSGboF38UOUswu/3mxaG9GE22spVhUKh4xf+ZlAUpaHKVOXQh/zRQq+RRay2P6lcN8/zzDOEFpz6fqeqdHReM6JPuSpRnQTZiYSPnp6esjYst60ZkKhgVDpci6IoSKfTlp7bSJAIBALgOA49PT2sfcBRe9C2emxTzzzgOG5JGJNWhGkXsViM5SqjPEzUd+FwGPF4HKIoLilhb4Qsy5aEhOTzeQiCwCqB0e/a/EdWYKYf/X4/83j0er3o7u4uCd1zcXGpDf0i+tRTT21TS5xLM0vWO90bRo8TPVmajZtj6CjNarMTRRYn9l8lXGHIRujDHPTbzX5fv43Qhs0sZ5pVtUgfqqM9Rz15jKqFwWirMun71ev1sh+z518O46NSKFEjIZxWQPavNDY5jqsqMtSK0fm09gGO5qHRtq9e29Qz78qdq92lzI3mo348mbWVVfckagOAkipuZl8smMVMW7XXrbdVp99nXFxc7EkzPVb0nqFO84bR0wxPFqcvopsxfpw4bpo1j5w4PpzuBafH2qdFF1tDlWaWO0ZVv6yA5/kS+1KoTb1hN9Wo1J/ac9Pv1fpe613m0loovMbn81XsA4/Hg76+PsvOa3ZsRqNRS8aGVfPAjuFI8Xi8RICppY1W3ZOoCpjX62W29nq9lgtDrQqxdHFxeRmjRZPrxVEb5AUzOjpqaSgeiShEJ3jYNGO8bdiwATt27Cj53UlQDpydO3da8kzk1HFDdti3bx82bNhgWZudOD6sHhPtxhWGlhFuor2j6JPLWoV+8aVd6DXD9pWOqV9kmjm/Oz7aC9m/msdQV1dXU85bCauEVCsFWbuNV70IxHHckjLw5fB4PKb3rYTWvtr/W+1l5oaCubi0Hid6FtgN7UJ8cnISK1eutGRRqxdROqFanBMX6a2CvKf27NnTUJJkJ48buma6BqvEoZGREXAch61btzpCJCOsGhPtxg0lW0YsNxd+KhWtp1Y7qKqKTCZTNf9OtdAvq6l0XP15zYazNHt8FItFViWp1SiKYjge7EAtYyWbzbLqZI3mDKtlXFgxNlp1HG1FvlZBbaIE9LVcqxV2MQrXasb9x6rjFYtFN+edi4tJnOpZYDfcMtvmaUaFKCeGCumx8hqcPG6szgdExzOqvmh3OmFcE64w5NKxyLJcdzUwPQcOHGiLmNFp5HI5iKLYlopSsiy3vZJVo8iyjLGxMSiKUlL1zqUUSZKakmC+GiQiu4JHdUjgdHFxqY6TPQvshJMX4p1AJ9jfymtwcoJvq8UQJ4srnTCuCTeUzKVjIa8KK5idnYUsy5aHZCw3RFGE1+u1rF9qwcrx0C5UVUUqlYKqqu7CoALt9EZx+8UcgiAgFou1uxkuLo7ADeuxN52Y/4k8OABgx44dlnkNOTVUiLAyv06zQhtbgdX3JH2orN3SBVSiWbnL2oHrMeTSciRJqhiWZVUYCMdxliRdTafTiMfj8Hg8KBQKOHz4MA4ePIjFxUXk83kkk0kUi0WIoohcLoe5ubmGz9kpFItFLC4ulnhvcBwHVVVx4MABZDIZpNNp5PN5pNNpFItFFAqFpoR8WTUe2gnHcYZJx0n0EkWxJZ4y7QjVqhdRFFvqnWJFrqBWUSgUMD8/z7zpUqkUJElqiWed3+9vW1ipi4vL8qRZXglOXtSWw2pbOTlUqFk42UvGavQv1Zz0kq0ZFfzahSsMubScfD5fcTEgiqIlNwSrKhe99NJLWLduHXw+H2ZnZ/HUU0/h4YcfxqFDhzA7O4vnn38e+XweCwsLmJ6exosvvtjwOTsFQRBw6NChkvAan88HRVHw0EMP4fDhw9i7dy+SyST27t0LQRAwNzfXlD8IXq8XoVDI8uO2Eo7j0NfXtyRBNYVNZrPZloQyCYLQllCtelhcXMT09HRLhCGO4yyr4NYK0uk0Dh48CEEQkEqlsHv3bmSzWczOzjb93JFIBJIkOerhz8WlXbgLSGvQezVYJeA4eVFbDqtt1Slj2MrcOk4WFK3uT9cW9sAVhlwsRVVV9lOOamEeVnkjeDweS0K/5ubm0NXVBY/Hg3w+j/Hxcezfvx8LCwvI5XKYmZkp8RhqxaKq2Vi1iJZlGQsLCyUigsfjgaqq2Lt3LxYXFzE7O8s8rZrpMWTVeGg3kUjE0GOIxmCrPIaqJWM3Q7V7hRWQx1CraIbHULPsJAgC0uk0ExaTyWTLcoDxPF/iMdSKseDi4lQ6KYdFO6GQD8Kqt/ud2D9W26pTbGSlCDA1NVXyu5MERauFQyeLq80SnNuBKwy5WIqiKMjn8xBFsexDvt/vr/hG3ev12irkp7e3l/0/HA5j7dq1OOaYY9DV1YVIJILBwUH4fD4EAgFEIhH09fW1sbWNo6qqZeKC1+tFd3c3WyzzPM/KeI+MjCAej6O3txeRSAS9vb3w+XwIhUK26n87wXEcE7e0AgRt53m+JaFMXq8XXq+34eM0K8RLew8JBAKIRqOWn6NVqKqKbDaLQqFg+bGDwSB6enrg9XoRiUQwMDAAnuct8bQ0g3YcWVFlz8XFiWzfvh233XYbvvOd75RdeE9MTLS4VZ2LfsFpxdv9ZlTwsgPNsJXTsUrgMgqpc5JYZrVwqBdTlrMt2om7+nKxFFEUkUqlEA6HkUgkDPcJhUJLQmG02C1HxzHHHMP+n0gkcMYZZ0CWZcTjcSZkhEIhBAIBhMNhdHd3t6+xFpHJZCxRvIPBIFatWoVAIMDy41CI3wUXXICenh7Isgye5xGPxxEMBuHz+VxhqAwcxyESiQBAidjh9XoRDofZwrrZoUxWvQ2ZmZnBqlWrKt4P6kF7D4nFYgiFQo4J7zJiZmaG3WespLu7G+FwGIFAAL29vQiHw4hEIggGg5aepxxaD75cLucmo3ZZVmzfvh07duxgi+90Oo277757ibCgL1UPdEZy43bRjJCV0dFRS5IR2w0rEwx3SoJuEgF37tzZ0HOF3h5OTFpsJBzWcw36e5zTKrQB1tmi3bgeQy6WoigKBEGoWP3J5/NVXAha5Y1gFV1dXQCOvrnneR6Dg4MYHh5GNBplb9x9Ph94nkcoFGL7l8MJIRNWVe/yer2IRqNsAUj96vf7sWrVKkQiESYIxeNxeL1eBAIBW/W/ndB6DGk97yixtt/vb0m4nFVztFAoNM1jiEIWSbx1sjBU7Z5aL4FAALFYDF6vl93L/H5/y4Qh7ThqZyU5F5dWs337djz22GOG4RI7d+4s+d3IS8NJb9PthtUhK1bmnLEbVpZT75RQMoI8furtc/31n3rqqVY1rWVY1af6e5yTwsiIThnfrjDkYikkBLRqYdEqVFXF/Py8JSFWxWLR9pV4mtV/xWIRqVSqKcd2cR5U7c9qVFXFSy+9BFmWHZMkuxLk9dTJkFehi0unMzo6iieffLLs5/qcaJlMpuT3LVu2OPJNtF2wegHXSYln9VhdbWlkZASbN292fLidFX3eqeGH9dAJooqVImo7cYUhF0vheR6JRMLROT2MUFUVk5OTyOVyDR+rVQmCG6FZ/SeKIsbHx5tybBfn0dfX1zTvsN///vctTzzdLPr6+qp6IjqdaiHGLi6dAHmXmC2wMDo6iueff75kW6c9X7UaWpCTSNEonbCoLYdVolenlarv5D6vBavGRyeIKp1Sst59CusAKlUCU1UViqKUfKb/v9H3zYQ7GX2PQl0oR4yZKmXtoNY2UUJmqsRE363n+vT9YQXadtDxy/2U+y5BYUnNQFEUlkS33Jhr5lix63jsBGjsacd3NXs300tkfn6+pOpVK6j3vlkJjuMQCAQ6oqJeJXw+HziOc+eoS0djZuE0MTHBFhVuGFnzaDQUiOhkz49mhQo53avKij7vhBBEKxNxO11U6ZQx7gpDHUAul4MgCJidnTV8mJ6amiopLa3dr1gsYm5uDqlUquQNlizLVXNaUFlx7X6CIJS0oVAosLxDdkLf7mpwHIeenh6WpDCfz0NVVVaKvRYPIK1wZiVk66mpKebZtLi4yPpYVVXMzs4u+Z4kSS1bPPv9fvT397Pfte2hMWfURqsgUaoV5biXGwsLC9i7dy8OHDjA5vvs7GzbvHaOO+64lubLAczdNxVFQS6Xa0rOoE6A7s3z8/O2D7l1camVcomO9V5AlGdIv78bRmYNnbKIazZWiV6uh81SOmEMWjU+OsEWnTLGXWGoA1hYWEA+n8fU1JTh5wcPHiwRfbT7iaKImZkZHDlypGShUiwWq4o5+XwekiSVlFHO5XIlwlA2my3xErELxWKxJjHH4/FgcHCQ5fmghe7s7CwEQajp+nieb8rbf7L1wYMHWU6C2dlZSJKEmZkZqKqK6enpJd8TBMG0W3uj8DyPVatWsd+17ZEkCYIgGLbRKqjfOiG8yG6kUins2rULu3fvZsLk9PQ0CoUC5ufnW96eV77ylfD7/S0rvQ4cHcPV7iuyLGNxcdF2YrldoPtAKpVyxbMGyOfz+MxnPoORkREEg0EMDw/j2muvranseTqdxo9+9CNcddVVWL9+PXieRywWw+mnn47bbrutbP9cc8014Diu7M+3vvUtqy7TcejnfSQSwVVXXYWVK1eWbKe/Ufr93TAya7ByEdcJnh+VGBkZwYYNG7Bv376Ou7Z6saLPO0VIsIJOsEUnhMMBbrl6W1JryWkK3yj3dlWSpBKxRrufqqqQZXlJRRijMB99m7QhS9pt2u/QPtrtdqCeUAVtFSi6HlmWa76+ZiXbJVtLksTaQ9tI+DESgFoZtuHxeEregOrHIo3HZmHX8dgJyLLMFjFk32KxyO5PrYTjuLaUPjcbStaMcNJOQXsfcG1UH4VCAeeffz6eeuoprFixApdeeikOHDiAO++8E/fffz+eeuopUw/eX/rSl/D5z38eHMfh5JNPxumnn46ZmRk88cQT+P3vf49t27bh17/+dVnx9YILLsDQ0NCS7VbkdXEq+vLfl1xyCVtAaHOvUDiZPvG0FaXVXV5exI2OjjZcJrxTyrCXg0QQANixY0ddniGdZiOrrmdkZAQcx2Hr1q2OtIcVYwN42fNo37592LBhg2Nt8dhjjwEAJicnsXLlSkdehysM2RBBEODz+UyHG0UiEfj9fvT29hp+Pjw8XJLgVbuf3+9HIpFAsVgsOR/leyAURYEkSSVhGcFgcEnp+WAwWFJCOxQKsVLIdkLfbjPk83n2AEz/dnV1gef5ti9gtLYeHh5GJBIBcLTqk8/nQyKRAMdxhmOE5/m2lYfXtof6JJFINO18VLa8lV4ky4Xu7m5s2rSJlYcHjvbvclrImLmveL1eRCIR8DzfolY5C7/fD6/Xi+7u7qblOut0Pve5z+Gpp57CmWeeiYceeoh5mXzlK1/BjTfeiGuvvRaPPPJI1eNEIhF89KMfxfvf/36sWbOGbX/xxRfx2te+Fr/73e/wuc99Dv/0T/9k+P2Pf/zjOO+886y4pI5nZGQEK1euLPHoevTRR3H48OGS/VxPQ2uwchGn/xvnRG+HSlghgugFUafbqNHr0QoqALB161bL2tZKrBLIRkdHHS0KAZ0jfrqhZDakUCjU5DVBpYwHBgYMP1+9enXJA7Z2P57n0dfXh8HBwZKFis/nK/ldluUleVnC4TB4ni/5oxgOh0sEpUgkAo/HYzthyO/317QwU1W1pCIZCS+Ud8gO10e2Xr16dUn7eJ5Hf38/OI4zHCM8z7dtAabNN0R9Um4cWwHZhf51sY6enh5s2bIFxx57LBOGBgYGEAwGEY/H29y61mDmvuL1ehGNRl1hqAxkw0Qi4QpDdSCKIr7+9a8DAL7xjW+UhB7dcMMNOPHEE/Hoo4+yHDaV+MQnPoEvfvGLJaIQAGzatAk333wzAJQsblyqU0sujcnJySXbnL6gtgtWVtsigQmAo0NIytEJYT5W02hlu07IqQNYMzY6JRSzU+aJKwzZiHrzKXi9Xng8niVePsDLVcK027X7UQUq/T4cx1V98+3xeJbsR9u0xzBzrFZTT5u0XkF0XeQhYIfro/wN9Mad4zj2L/W50UJL22etbq+2PdQnzVwM2nU8dgI+nw/BYBCBQIDZl+ZHuzzSWo2ZsUXz0h2DxmjvA+24LzmdJ554AvPz89i4cSNOOeWUJZ9ffvnlAID77ruvofOcdNJJALDEo8WlMpW8S/T5g/QhuMPDwx0nOrSLZlXb6kSPLityp3SKEKKn3sp2nSIiWJF8ulPGRqNioV1wn0xtgqIoOHToEICjDw52W0jZMRysldg9/KiVCaRdXFxcXOzJs88+C6B8aAJtf+655xo6Dz28G+UQIu655x588IMfxHXXXYdbbrkFL7zwQkPndDrVvEuqhZOce+65TWubS310ygK/ElaUEu/EcLtOETQapdHk5J02h+oVC+2C66dtExRFwfj4ODZs2GBLAcaO4WCthsJj7IggCAgEAk2pdubi4uLi4gwOHjwIACXVH7XQ9rGxsYbOc9tttwEALr300rL7fO1rXyv5/WMf+xje97734bbbbqvJM3TLli2G2/fu3YuNGzeaPk67qeZdMjIygi1btuD5559f8l3XW8haOiUfSCto1FadGm7XSJ6hZ555puR3J4+/RhNQW5kIvt3oQ7R37tzpuOtxPYZsBHkJUUgQANtUZtG2aTnSjvAjbTWnapW0OI5reeWndlSbAirbgqqyVaPWqlCyLLPrtXtFM1mWTecoq7UKnNmKbuX2q3Q/K9cnzagiZ1VVMCPbNbOqnlnaVXnPzHn1+6iq2pHhF+2CqliV83Cl/GqLi4t1n+Nb3/oWfvOb36C7uxsf//jHl3x+yimn4Fvf+hZGR0eRy+Wwb98+fOMb30B3dzf+9V//FR/5yEfqPreT0XtNGCXmv/zyy0ty7xGut5C16Bfx9RZJMFrgdxqNenTobTQ1NdVwm5wMeZRocbKXTKOeU1Z4pNkF/To5m822qSX14wpDNsHj8SxJ8AigJOGxy/JCkiQmchgl/9bC83zLF1eSJEEUxZaes9p5VVVFMpmseoxaQ+8ymQxyuVxJn9gRVVWRzWZrum/Usq8syygUCnXvV+lc5fpEn/jdCnK5XMPCENlaexyjbe3AbD9ZjaIoFe9TwNL+VFUVBw4caHLLXKzi8ccfx/XXXw+O43DHHXdgeHh4yT7XX3893vOe92DTpk0IhUJYv349rrvuOjz++OPgeR5f//rXWei8GZ5//nnDHyd5CwFLF8Tl/mZfd9112LJlCwKBABKJRN25O1zKQ14KRD0L0k5b4Jej0TwyJFYT7f77aBX1CiL6/ZzuJdOocNhJIXn6cOCJiQnHCV2OFYZ27tyJm2++GX/913+NVatWmfZo+d73vofTTjsN0WgUiUQCF110EZ588smK33niiSdw0UUXIZFIIBqN4rTTTsMPfvADqy4FwFFhaOXKlUu2u8LQ8kUrQiiKUlH44Xm+5YJFsVhsi0hSLBYrCkNzc3NVjyGKYk2eHblcDoVCwfbCEHC0rdUW54SqqjUJCLIsmxIgy43XSu0SRbGsMGS1yFEoFCzxqDG6HrO2bybV7hftPK+qqktspC3R7dIYlMC43LMDvcGMxWI1H3vXrl249NJLIYoibrvtNlx22WU1fX/Lli245JJLUCwW8dvf/rbm8zuZWkWEyy+/HB//+MfxwQ9+0NGLRjujv1fVuiDttAV+MxgdHV1yfz/11FPb1BprqVcQ0e/ndHs0Khx2Uv4po8TTThO6HCsM/eM//iM+8YlP4N577zX9UPl3f/d3eMc73oFdu3bhta99LU477TT813/9F8455xz84he/MPzOz3/+c5x77rl48MEHceKJJ+LCCy/Eiy++iKuvvhof/vCHLbwiGIYq2S0Jda3UGqpSL4qi2H7BXiva8LVqoWyNhLrV20eNhhfqz0thWtXaUu28lXJXUChTrW2nynNOCKmsteJVLfvWMs6M7OTxeMqG41WyrdVhnFYdz+g4dqg2Vu84teJ+baYqm36fesM4XJZCnsfj4+OGn9P2tWvX1nTc/fv34/Wvfz3m5uZw00034YMf/GBd7du0aRMA4MiRI3V936m4IoL9aNTTodMW+OVopJx4J497K6q1LXc6Mf+U3mvIaUJX+59g6+TMM8/Epz/9afzqV7/CkSNHqj5Y/uY3v8Ftt92G3t5ePPvss/jFL36BBx98EI899hi8Xi/e8Y53IJ1Ol3xndnYW1157LWRZxrZt2/DII49g27ZteOGFF3DMMcfgy1/+Mh555JHmXSRezgfgVJoRBmJEsVhEKpVq+nlaCc/zLJm0x+Opmvy6kbFSTxwsz/MNL+i0LsaSJEEQhCVux3r8fn/Z83IcZ5ifgaDrDAaDNSU/jcViCIfD4HkePM+b/l47iEajpscCx3E1jRuz1Qm9Xq/heI1EImVDAcv1STMqAobDYUsEnGg0WiLAcBy3ZFs7MHO/MKLR+3W5fteiH3Mcx2H9+vV1n9OlFCojr8/rQdD2E0880fQxjxw5gte97nU4cuQIrr/+evz93/993e0jj06nP9vUiv7vWqVqbi6todGF/XIRBvTijj7BbiU6WTyrNzdOJ4VOAdYKh26+wfbjWGHoYx/7GD772c/ijW98o6k/sF/5ylcAAJ/61KfYGyvgqMD03ve+F+l0Gt/97ndLvvOd73wHCwsLuPTSS/HXf/3XbPvg4CD++Z//GQDw5S9/2YrLKYvTK4G1KrGoLMsNJdO0Iz6fjy2UPR5PVUGikbFST/iL1+utSVwxQhsiJMsyJEmqGjbk9XrLVl/jOA7d3d1Vz+f3+2sSBkKhEAKBQEmf2BGO4xAMBmsaC7WIe2bGYaX9gsEgisWiYciY3+839JDkOM5yj5JAINCweEO21mOHe7bZftLT6P2a4zhT59X354oVK+o+p0spZ511Frq6urB371788Y9/XPL5tv+/vfOOkqM60/7TOffkUZiRBBIawAIkJNYkYRBmCdbBYBPW8tpG4LAO2LCAveuPuMCuw2IMNsaBNYg1ts7a5OzFRhIYIcmIJYdBOU+ens7Vob4/5PdSXV3dXZ2ru9/fOXOkqXjr3lt37n3qDQ8+CAA499xzdV1vYmICZ511FrZu3YpLL70UP/7xj0suWzwex1NPPQWgcGr2ZmJwcDAr0xgvgOpPuUFvmylobj7U4s7g4GDTPmsxlCrw6AlC30iUI3Q1W6p6oPGFv4YVhoohGo3i+eefB3DQb1sNbXviiScyttMERuuc5cuXw+l04k9/+lNVg3w2gutKIWixl8tNSJblvIGA1eflOr6abneFylgMlDUq1/XoXsq2L9QPyu0npYgdleibyvuSi0mhsijvS3VFfSSVSuUtk1bmPz3Q8UZ9H5PJpAjoWEwZ0+l0xrmF0HvtXMdRG2uJcvnOUW6vxLuY7zkosx0JWPncG3OVt96U00+LGUeV7x3VGZGrnahsqVQKkiQZ9p1qVOx2Oy6//HIAwDe+8Y0Ma9Dbb78db7zxBk499dSML/d33XUXjjjiCHz3u9/NuFYkEsHy5cvx5ptv4uKLL8Y999xTsK3ee+89/OY3v8kSPkZGRvCZz3wGu3fvxsKFC3HyySeX+6gNg5b1VjMsgBqdchdwjb4A1Es5cVOauY5KFTXUY2Oji8TlZPhrRqu7Rhe7jPvpu4K8//77iMfj6OnpQX9/f9Z++nL1xhtvZGx//fXXM/YrsdvtOOqoo/DKK69gcHCwKLPsVsJsNgs3EEmSIMuypqtBKBTKaelBQY7J9JwydCmDZ+pxYSgHyjbU1tZW9rXIjUaSJM3rUUYhCiJaC+pl1q+8r81mK9oiJ51OIxKJwOFwiIVmPouhWtZpLYlEIvB4PEWLo9FoVPTDWsUzq4QrXr7xohKEQiEhYtntdqRSqZZwfVGO13qgsdlkMokPJMq+lK+dYrEYwuEwent7yy43k8l1112HP/3pT1i/fj3mz5+PU045BTt37sTGjRvR09ODe++9N+P40dFRvP/++1lxf6699lq8/PLLwjr0i1/8oub9Vq1aJf5/4MABfOELX8AVV1yB4447Dj09Pdi3bx82b96MYDCI/v5+/P73v28pMVAtvM+cObMpFkCNzty5c7Fx40bxe7GWG+rzG20BWAyLFy/OCJ6u91mbKbCwGgq6vHnz5qLGs2brNyTuUKygF154AX19fbrGOGWMoQMHDug+z8hQv9i2bRvmzp3bcM/TEsLQrl27AEBTFAIOLk7b29sxMTGBYDAIn8+HqakpBAKBvOf19/fjlVdewc6dO3UJQwsWLNDcvnXr1oZLu1oMtBDM95U/n2KuDiwty3JWjBK9LgzlUClVn+oh1/XS6XTN08DXy5RVeV9aTBYjDFFfsFqtIkZRPoweH6hUJEkqKQ4Pue75fL6aCUOVuE+1v7DF43GYTCZYLBZYLJamC2yfj2LeERqbTSYTotEoTCYT/H6/2J+vnZLJJGfdrBJOpxNr1qzB9773Pfzud7/Do48+is7OTqxcuRK33HJLzjmNGooHlEql8Lvf/S7ncUphaGBgAFdeeSU2bNiAN998E2NjY3A4HBgYGMC5556LK664Ah0dHWU9X6OxZMmSDNebU089tY6lYYhyFrTK8wcHB5sqqHKlaMbAwlrQu/3+++/rzso1MDAAk8mExYsXN0WdaGX40/NcWhZlzVAfjUxLCEMU9C/fwsnj8WByclIIQ8pAgbnOoy/IzRbbppIoVXSLxZLTZSVXzBjg4Fds5WLSZDJliQda2whyDcm14EkkErBarQUV/3xlLAZ6lnxxcmoZx6ZeX27V9y2lHFRX1EcKtVGzfqUutW9arVbYbLaa1ksl7lWpdzHf9ZVub42eHVIvxbaNcqyy2+1ZbmH52slisTR8bAUj43K5cPPNN+Pmm28ueOxNN92Em266KWv7qlWrMkQfPcycObOsOEQMU0tKXdACzWntkItSFvCtEFi42HqhQM1Es8RaK9UKqtmsp4DMNt64caNusdAotESMIaPw9ttva/40s7WQEpvNllOcyefio86EpOXuUMgFIl+mq0gkopk+W0mx2ZvyQZmtcl2v2m5xzQS1u81mg9PpbAl3Hy1cLldJWbacTif8fr8hUqwXQ7VdAr1eL7xer8hEZ4SA0kbEarXC4XCIfuTz+TL6Ur52cjqdVXUHZBijoI4x1ExxVhqdcgIBN3P8HDWlxE1p9Fgreij2GVupz7Qqjd7GjbUaKBGanOYzW6cAjRS3RjmhzXWe+pxKozcgbK2uUy654seQG1iucqotQUwmU9aXaLPZnPfrdD7XrEQiUbCOKumqRvWQq7yFnqWelNqXqtUHqV0oBkauSZ1R3oFyypHvXLvdXpK4Y7PZ4HA4DCEM0fPV8l3MhcPhEAKuHks0LSrd5/TWTy2huqF3T5ntrVA7Wa1WFsCZpmdwcDAjNgvQnAvkRqWcQMDNHD9HDcVN0QpEne+cZgssrKbYZ2xWsaxUMaTRRRQtGr2N678aqAGzZ88GAOzZs0dzfzgcxuTkJDo6OoTI4/f7RWDgXOfR9jlz5lS6yFlxdUpFKx6PESF3Lz3oEXLU5FugkAtELSnmeY0EZWkqFspcVC9KLXely1BOHdS7DquJLMuIRCIimHG9oCxt5VKN95v6cCgUMpQ4xDBMbtQLHY5FYyxKzajUKvFz1JDQuXr16oIp66mODhw4gBdeeKEpU9wX+4zNKpaVKoY0o7hKIurxxx/fcG5kQIsIQ4cffjgcDgdGRkawd+/erP1k5qsOIL1w4cKM/UoSiQTeeustOJ3OqjR6Op1GNBqtyLXyuVEZhXQ6nZFWNx96XL/U5LPqKtUNpxxkWW6IdlETjUZLEifi8XhdF/yl9JlKk0gkyhJp612H1WZ0dBSJRKKuAYmTyaTIrlUOlMWwklAfHhoaYmGIYRoE9UJnyZIldSoJowUt1Am9AkYrxM9RU6x1RzNag6gp9hlbQSzTSzOLqwMDA5g7dy62bdvWcG3cEsKQy+XC6aefDgD4wx/+kLX/wQcfBACce+65GduXL1+esV/Jk08+iVgshjPOOKMq8SdkWa7Il2sgfzawfPev9eJDbzmTyWRRZdNyPVNS7eC7VJfKH+DD59XaV+l7V+qcVCpVssVQpYQZrfos9JzF9plqUK7FTzl1WEqdVYJirh+LxZBKpWoufinrIp1OI5VKVaS+qmExJMuy+GBQr/6cr27U9VSPvyMMYyS0PkYyxkIrAHUhGt1dpBSKfeZy4jc1Chxj6CClPFczi6sUgHrjxo26rOuMREsIQwBw1VVXAQBuvfVWfPDBB2L7yy+/jF/+8pdob2/HF7/4xYxzvvSlL8Hv9+Oxxx7Dww8/LLYPDw/jO9/5DgDg6quvrkp5zWZzxeJolDIYV8qlQi8mk0l3Oevh+lUu8XgcqVQK4XBY/NDzRiIRJBIJJBKJilu1lOJ2l29wttlsJVlXWa3WimV2mpqaQjKZxOTkJJLJJEKhkHBDyoUR+kyuGFvFnF9OHe7evRuSJEGWZcTj8bJd2/QQj8d19z+fz5c3TlQ1mZqaQigUQjweh9VqRSgUQiqVEvWVSqWQTCbLij9RLtSH/X5/TdouH1NTU5iamkI8Hkc8HkcoFEI6nYYsyxlZOksZfximWVB/EQeaZyHYTJQi8rSi4FesG9TQ0FDG78208CeKjb3UjK5TAAcnV9PIAmDDCkNPPfUUTjjhBPFDLhrKbU899ZQ4/owzzsAVV1yBsbExLFq0COeffz4+8YlP4GMf+xiSySTuu+++rAwpnZ2duPfee2E2m3HhhRfi9NNPx0UXXYTDDz8cW7ZswVVXXYXTTjutKs9nNpsrFpizlAw+iUSiIi4VejGZTHmziilxu92GCJarF4qfIkkSJiYmMD4+jsnJSZFBKxAIiAVWpcW4Uly/8rm4uVyuksQJh8NRsYDaQ0NDiMVi2L9/P2KxGEZHRzE5OZm3v5Za7kpCwYxLpZw6lGUZb7zxBqLRqHDbrIVrWjHukl1dXbDb7brHgUohyzKGhoYwOjoqBNvx8XEkk0nhvpVIJBCPx3W7h1UyiyFBfXjatGlluyWWgyzLGB4extDQEILBIMLhsHADTKfTGB0dFWJQNBqt6QcGhjESWouBZlr8tCqtKvgV4wbVakHX9cReanbXqWLj6jRrvCWgsUWv0j9f15mRkRFs3Lgxa7ty28jISMa+O+64A4sWLcJdd92F5557Dna7HWeccQauv/56nHTSSZr3ueCCC/DCCy/g1ltvxYYNGyBJEj7ykY/g8ssvxyWXXFLZh1JgMpk0rQtowq3X+iHXdQpBbhW1gJ7JYrEI1wP18yl/L8fqotLobQ8KHEsWCGazWTxvIpEQ4g19ddfbvoXuT24xxVyLyqI8z2QyiXJr3Ut9rJpc52ldo9Bx8Xgc6XRa/CtJEkwmk+iv6uct9R0opnx6yl6umFmusDU1NSX6QzKZzHKhLHZsyYXyOnpESTqevqTVQ/QlyyayyqK+pXwvi7GiLLfPKeuQ/k/XczqdCAaDdRXHqb6SySTMZrMY19TJDuod14th6onaOmDBggVNtfhpFrS+7udrp1YV/Iqpp1YKuq63XprZdQqAeGZ6zkLtrRTKDhw4gL6+vqbtI/kYHBzEtm3bMHfuXEM8f+OYXahYuXJlwRgHK1eu1DzvlVdeQTgcxsTEBJ555pmcohBx8skn45lnnsHExATC4TD++te/VlUUygcthKuNxWKpekpoJdFoFIFAALIs48CBAxmLWCNnVdPjKmMymTLiUDmdTjidTuHS4/F4RF1PTExgcnJS9/0rGZNF/SyxWExzmxaxWAzhcFizrWRZ1mV9pvdZOjo6YLPZ0NnZCZvNBr/fD6/XK6xplO4/lbSIyXc9pbhnVA499FDYbDYEg0HhuqikUvVF/RqArvhrtbRM1MJkMqGjowN+vx8ej0eIOslkEk6nEyaTCYlEAjabrSrx5LRQ1mEymcwSpChFfL1ob29HW1ubsGz1+/2wWCwwm81oa2sT4qLdbm8o606GqSRbt27N+J2t54xJsV/31fubzdohF8XUUysFXdcbS6nZYy4VG1enkd2tCqF+ls2bN2seZ8RYRDxjazBSqVRNFlK1jvURCoWEC8K2bdswOjoq4mjUM0tRIcg1pxBKtxKv1wuv1ytczNrb24VQNDQ0lOWXnY9KZVECDsY6UopA4XA4K5tXLleaUCiEqampnGXRk2Jbr3tMb28vnE4npk+fDqfTie7ublGH9BwkclTyi0y+uq6GG2AlMZlMOProo+F0OjE+Pq5ZN5WqL+rXgD431kpn7yqF3t5edHd3w+/3A4AQhihjoSRJsNvtJbnllkI6nRZ1qOXyZ7fbK+aaWSwmk0nUl9VqhcfjEf83m83o6uoSxzqdzrq7cDJMPRgcHMyKQ8PxtpqTvr6+ehehJhTj+tPMbkJq1POmXPMovcc1KsUKPc0abwnIfpbBwUFN0ceI4hgLQw2G0sWrmhlfzGZzTb/0UnBXZWBcZWYbo0KuX/kwmUxicUT/JzeydDotFlSAtnVAPnL1gVL6hvJZqGzqa+QSwZTZnHLtL4Re90WyQnA4HDCbzcJ6gupQWYZK9p18daqnH9QTk8kEr9cLs9mckXVL7UpWiWdQtqPFYinomlZvdyOTySSEFqvVKt5RWZZF+ZXun7UiX2avWo/PSpT1RXVFQelpH7W5nvZXw5nMmGZAa4LfzFYTjQynYddHsTGGWiUtu15Lqma3GCrGoqyZ4y0B0AxGrscF1QjiGAtDDYbFYhGDCWW6agY8Hg86OjpgNpvR39+P9vZ24Zpg5MHT6XTqXqCR25NSyFC6pjgcDvT29qKzs1P3/a1Wa06Xv0gkUlT56Fi32w2TyQSXy5V1fq6A6C6XC16vN2db6Qmknu9ZioEEo0q7Q+Yrn91uN1Tsq1yYTCa0t7cLtyllmStV/+p+XYhKBdmvJB6PJ+MZah0QW+l+Wm+3sVxUa2xOJpNVD4rOMNWG4ws1DurFWKFxzYiLuVqg1z1G69hWEc/y0exZ2oqxEmv2eEsAsHjx4ozfG2WcYGGowbBYLGLB0GzCUFdXF0wmEw455BB0dXWJr9BGXDgS5GqiB5vNhvb29oyv7coFp9PpxMyZM9HT06P7/vlc/sLhcFGuHCQIUZncbjdcLlfGF/9cC2SPxwO/369ZFsrQVMhywGazVUSYoDap1PWIfHXtcDgMuXhXQ64+7e3t8Pl8Ge5IlaqvYjIMArUXXfTg8/kyxp1al1E57pWbza5aVGtsrmfGNYapFOqFTq3cUJnioQUt0ewWLqWi1z0GaG43ITV6RLBWyNJWjJVYK4ireoSyV199NeN3IwioLAw1GCaTSdNlBijPnUWvG08x2cqUWX1y7Sd3FovFItw4aJFtMpkynreaqN0XqGxKFymtutWTbUt5LFkK0XnKZ6Nt5MaiLFuuOi+UwazY8inLRBZb5EpD7jRakHtcvv2FqFRbU5nphzLClUu+8hVTz3rR6nMUVDtfn8wHBVam7FvUtuS+qMzuVirFtmM+d6N6uRVRX6Z3j8pYK5dBZR3mywSot62qkWUyXzsXGvsLwa5kTKPTSgvjZkAt5OVboBlxMVcL9LrHNLubkBo9IkcrZGkrxqKsFSgklBlVLGRhqIFxOBwZC+5ygzTrOV+SJN1Zs6ampjAxMZFzfzQa1Vu0qqMO6h2LxRCLxRAIBDAyMoJYLFYT66wDBw5gcnIySxjKFfQ4X5uVauWg9cU+kUggFAoZOsByLnbu3GnoAOa50Opz6XQa4+PjGBsbgyRJFbGskGUZe/fuhSRJiMfjhqqregf1TqfTGe9eIBAwlDWL3jFUb2bAShGNRjE8PFzSuZVyaWSYetFqC+NmQK8Fg1EXc7Vi2rRpGb9rWVG3gpuQkoGBAaxYsUJTOCPU9TR9+vRaFK2mFGNRphZX1b83A4UsyYwqFrIw1MCo3YRqIQwlEgkEAgFd1wsGg3mFIXUWrHqSSqUy/ngphaHR0dGaue3lEoZyLQCj0WjOOixHGFLH+GBhqPbE4/EsK490Oo2xsbGKCkPpdFoIQ5IkGaquJEmqq7uskYUhZfY3PcfWUoiPRCIYGRkp6dxKu4AyTK1ptYVxK2HUxVyt0JNZqxXchLQg0VAr7XizZyQD9FuUAQczFSsxylqwkhR6D4wqFrIw1MCQq4wWpbg86HWF0ZNliO6d79hKu96Ui7o8SnekWpW1Ui5J5bhlad2/UB0oXVXKdbeptLtOPbI3leO6k+tc2qZsi0r1S6qjWvb1cqF+Qu511SDXmGAUjFQWJeXUk9HqmGGKpdmzDzUjet1g1AtaoyzmakWxgbpbhULWIK3iWqon4PLg4CD27t2bsa0ZMzYWsiQzqljIwlAT4fF4xP9LscbRY2Fit9vR3t6e95hwOAwAaGtry5thi4IdGwFltjcAIiNXe3s7ent7s9z2qsWMGTPQ0dGRUS/5gvnqCepcLFpf7G02G3w+X84Ay+l0WlgkSJJUVlahSltnHXrooRnvRi0opw7IlU9tEUjWM93d3eju7q5YUGLKBEjXM1Iw6HxBvZVjXLWsnNQBlil4vBEoJsh3sQHBy8Xtdme5HDBMq2DUCT+TGz1uMIODg3j77bcztrVa2+oJ1N2KGcnyWYewa2kmrWZ1l8uSzKgfEFgYaiKUQks+F6N85xeCUq7ng+7t9XrzikhGyjamFoacTiccDgd8Ph+6urpqJgxNmzYNfr8/SxjKlf67GnVotVozslXRNnV6cyVKlxtJkspyOau0MNTf319zsaOclNvkyudwODKsnSRJQjqdRkdHBzo7O0V2u3IxmUyYMWOGIYUhu92e872LxWJVF4bU7546k1u90fv+5xtDqoHL5UJ3d3fN7scwRkJtVWKUCT+TGz1uMFpxUJrV8iMfhQJ1t6IrWb4MVK3kWqpHFFT3h2a0FiLy1YdRPyCwMNREKMWEYl2S9Jrv0zFaohNlSjKbzUin0yLjkRpy/ch1z3Q6XVYGnVJcS9RlUWZEU2a5qjbK++UqW75ylwvVWz63ulzlUGYuK6dMlXweyvJWa8u0SrjS1KpPKuuomGvWIkNXvvKoM/rV4v40tul57lQqVZJAr4XWmFZMW9XaPatYV9ZUKoVkMglJkpoy1gDTOrBVSeNSyA1GLfjNnDmzqS0dclFI+NGTprvZyJeByqiWIdWgFUXBfOSrD6PWFQtDTUo13bRisZimRQhlUfJ4PMKdjP5VUihoqlZWrGLRui9TmFLrjVJ7y7JctiWL0+nMaZnUKJQTQNdms2lOHBwOh6GsVXKNA7VCOcZ5vd6a3TcajeoSrqPRKLZv314x67dmHtNisRhCoRCGhobK+ijAMPVG6TJCGGXCz5SOVlyUU089tU6lMTaF0nQ3I/liVA0NDWXsa2ahWI8oqLa8a2ZXw0L1QZaKFIvICLAw1KRU020gV6YgyqLkdDqFm4dWiuRCqZO1smIVSy0z8DQTSvecYlBah9lstrLc7ux2e10CRlcSq9VasriV69xy67XS1DtjmMPhEMJQLd2k4vG4rnckHo9j//79FRE6ap1uvtZQNryJiQm2GGIaFi3xoFWtShqRfG4frRYXJR/FpuFu5oU/kStGFcWXyXdsM1FIFOT6GBTbKeaQuj7qTWOvvlqQdDqtazGWz3UgkUiU9aVf6ZqjLI/SHYUWsLkWsvkWuOQqk4tkMllw8ZBvUU5llmVZiFl6rgl8aCUhy3LRdZhOp8VimtxR9F4jmUyKAM+00FS7l6RSKSGqpVKpDKsr2haLxUT7az1vqcKDyWQSdV7IbUVZNqoL9bW0zqf6UpZdWYd621DrvnQu9YtSUJ5bCVcyZRlJFCjHCpCuR31eaxzRU4d0DLlVlUOxbp/K8mm53Knf51LGuXx1QC6wyuOU/9L/yYWskpab1RAFy6l/Olf57lDdq+tQ3d9kWRZjEn09lSQJDocDqVQqY4xkmEZBy1qIrUoah3wuP0ZNLV0PCmUmM6qLTDXJFaOq1QTFQqKg2lqor6+vJevDyOIpC0MNBsWtKIdQKFSWW4IyU1AymRQTe5fLJRYvXq8XJpNJMxuU2WzOmyWqULalSCRScEGa7/okkADA6OgoUqkUwuGwrkXI/v37Rd2p/c0LIUkSJiYmIEmSCCSsN2huJBKBJEnYv39/hqii7AvRaBTBYBChUAiSJGF8fFzsCwQCiEajGB4eRjAYzFmH5WQ507sIjsfjmJycBPCh+6EeSBhT1ruyDotpD7UbFJ0biURKtoKJRqMVtaBRXk9tilwKsVgMkiRhdHQUkiRpmjPrqUPq/w6Ho2yT6GLHs0Llo/eZjitlnMt3j2g0KoKC03GhUCirbx44cADAwQlxJQSdXGNpuZRT/6lUCpFIRGyLRqOQJCnrHQUO/p1QWjylUikEg0HEYjExTo2NjWHatGmIRCKIx+NlB7FnmFrC1kKNT75gsEYNFFsP9GQmM6KLTLVRZ+J0OBwtJygWEgXV66xaZwyuNbnEZiPHnWJhqMFIp9MVcbMq54+azWYTFj1kpULbSRjI1fmJfMKPxWLJa/GjJ0BpvpeMLHeADxd1eutjcnJSnFtsHSaTSYRCISSTSWFdojeWUjweRzKZxOTkpFgsKZ8DOFgvsVhMiB7KRXEkEkEikcDU1JRYwGnVYTmDk95zlWUjgUwPZOGlrHdlHRbjapNIJDLuS+eqtxdDMc+iB2VZAoFA2dcja7WpqSlh1aFGTx3SMTabreyxSN2HC1HonQsGg+J9LtX9Kt89EokErFYrTCaTuAdZKSnFtsnJSciyjN7e3opZDFVj4lBO/dO7p7T4IWtAdR2q/25R2yQSCQSDQQAHx+K2tjYhCJGVJMMYnQcffBCrV6/O2s7WQo1FPksYIy/k6kGuzGRGdpGpNlriYasJigMDA1ixYgWOP/54TVFQHSez2YWyXO1v5LhTLAwZCDKhzwe5aSUSCTExDwaDwjSfXBrUGXFoP3DwxSwnuC8tdBKJBMxmMywWCyKRCJLJZMbX53g8nmH1QM9nMpk0XQ2i0WiGKxRZb5B7AkELMzX0/LnceKheUqmUeH5yXchVH5Q6nRYpbrdbHKs8h6x0aLFIbUJtpKwrcqtQ1gEtqOiZSQhSPrPFYoHb7RainNJlDzhoiRWPx2E2mzOeSVmHZI2Vqw4pzTrVZTELf2W908JOKbgQFotFCIPqjGGJRALxeFwsGtXXt1qtGX9YTCaTWNxquR/SAlS9wFTfl65J2+n51ajfUWXfpPqmti93YWuxWISQQ++YFtRHlW2mdW96NovFAkmSRN9RxvSy2WxZbnbqulDWPz0zHUNWSXqem8qpHM8KoX5P1WOD0+kUfT+ZTAqXPBoLlX1aeU8aG5LJpHh/lP2P2p3qMBaLCVc6EsSVgrbL5RLvGL1TyvGA+kgxVNp6RunypZyU0FhMYxKNV7FYLKP+qX6sVqsQc6ju1e1EYx/1LZPJJGJmUbB5n88n3nEKZl/rbIIMUyx33313VhYy4OCX8FaxlGgW8lnCGHkhVw9yCWVGdpGpNlrWMq0oKA4MDGDu3LnYtm1bhiVZK2Zs1BKbjR5niYUhA0GL4nxYrVa4XC6EQiEhQOzYsSPDfYKsQ0ZHR8V5Spcbv99fdhYfup7VaoXD4cCBAwcQDAaFCwVw0K1jeHhYLCDIhYrKqFw8ptNpjIyMIBwOIxQKIR6PY3h4WCw4lF/+leKIkkLuYCQ8SZIkgtX29PRAkiS4XC7NRcjExESGFc6MGTOE6aOyDvfs2YNAIIDx8XGk02nRJsCHrnskypCbhFI0kyQJU1NTGBoaQiKRwOTkZMYzezwe2Gw2zJw5M0NUcbvd4hiHw4Hx8XE4nU7E43FRPhLaotEoOjo64PP58tZhKBQSC9dSXQ7JKm10dBSyLIv+SuXs6OgA8OECmgiFQpiYmMDY2FiWO4rJZILb7c4wPaVFfCAQyJmxa3R0NGtRrc58RnXldrthsVhyPreyDwPZrpQAsGPHDrHYLseihly1tm/fDrfbnfFuKRkfH0c8Hhf9PxQKabroUV07nU5MTU2JfhQKhURde73enG52BNW/yWQS9UbHjI6OCqudQoTDYUQiEbjdbt1ugOpxSz029PT0IBaLwePxIBQKCdGJ+qGyrMrxgsaGSCQCh8MBSZIyykRjM9Xh8PCwEEQ8Hg/MZjPcbrco38yZM0U90fsEHBznaMwuhnLexVxEo1FEIhHIspxhkZZOpzE6Oop4PI6pqSkhHI6NjWXUP43hXq8XU1NTCIfDiEajcLlcWe1EAhAJvmazGT6fD06nE11dXXA6nTjkkEMAHGxjEviMFGydYdQ8+OCDGBkZ0dy3ZMmSGpeGqQRaljBGX8jVg1yWEK0YXygfrSgoktXYxo0bhfUYAPzxj3/MOrbZ+4eW2KyOs2S0uFMsDBkI+mKdD/qiSoNLPB4XmVxoGwkByoWE8kt5uenEldczm82wWq0IBoNZiykSGdQWQ1RGtcVQOBwWVjfkdqVlMaR0WVNSyCVCbTFEQkMymcx5zWg0Kr74p9Np+Hw+cazSHS4QCCAWiwnLBGV2HRKCLBaL+GqutCKgssXjceHapl6c09d1n88nFktU9wRZlVgsFiSTSfFlguowkUjA6XSKtOe56pDKW6zFkLquk8mkECOVfwwtFosQUdSWS2RlRnFGlJjNZpEGns4hiyGy4NB6pnA4nCVUkFUCQdek7bn+eKsthpSWJdQW1PblWgyR1cv4+DhsNltO8YT6qNLFUcsljp7NarVmWH8oXX/sdnvWueq6oLoiqw+6BokXejPbkcimHM8KoWx7IHvMpPfZbrdDkiRhMaQcC6me1AIftSW9P8r9dB/qryQ60b3UfZPGCeVzAh+6Q5aSfasYly89kEgOZGZxpLGYLBfJYigSiWTUP41fdrs9I6i9+h0FPhyrqJ7NZrOIVUdWmCQW2+12WCwWEeCcYYyI1tdvYvbs2Vi2bFmNS8RUAi1ho9UCCOuhFS1hCqGVsr4VBUUtq7EHH3wwI+4p0Dox2NTzW/XHBKO50/GsyyCk0+mshb4SsgSIx+MZLiUOhwPt7e0Zk3USEZTWJEpKyZhECwPl7+RWkUql4HK5YLfbxZdichlTxiNSYrPZMiwq6Is7LSrIEslkMmXVS66yK4Uarfg9FosFsVgsQxShMpIrGHCwDskKgSxLyMVG6d5ALkfpdBp+vx8OhwMulwvJZBJutztDiCMBgwQl5Q+VzeFwwOv1wmw2w+l0irqle6kzMCkXuJQVyO/3i2uR21osFoPb7RbBwdXtr3bbstvtQtSgupFlGWNjY6Ifjo2NiYUgiSXK/kEiBC2OlW2jvL+6LHa7HS6XS/QndXuqM01Rf1cGRCeoftQikNZ9leVRlrfQYpxEzLGxMSFq+f1+EccpEAiIuFQk/imDnZOoo9VfqW92dHSIvqEFWbHY7Xak02nh0pTrme12e8bYQP2Q2lH5zkqSlBUPTFlvJAZZrVYhuCrTyCuPo+ejPkNlSafT2LNnj+hnZC0XiUQwOTmJQCCQ8R4oUccjU4tVWmOhVnwzctWk46k+1fehOvR4PBkCs7J+lf+neEeRSCQjtlNbW1uWOK50LyUxiVxTla5aJL4lEgmEQqEMV0BCTxw2aiubzSYsKIEPs0LKsiwCbVMdqt9VGtscDgfcbrdoe3U7aY1bVGb1uDY1NaXrIwnD1BOtDGQWiwUf+9jHcOmll9ahREy1UH+UMdpCrh6oF7tk0cyuZB+itvJtFUFRy31KS0RvlRhs6vpQC2SVSC5TSVgYMggktOQKyizLMoaGhjA5OSlcxOjL9CGHHCJEgHA4DJfLBZvNhp6enoqVjzJqEbFYTCwmJElCZ2cnvF6viMpPX+s9Ho/mM7ndbpGVBji4GOnp6YHX64XP54PD4RDWMeT+UghlRi0t1wuHw4HJyUlhraIsy9DQkBA2aBEHQCzKnU6nZuwUcqfo7+9HW1sbOjo6EIvF0NnZKe5PsTPIasjn88Hr9cLj8cDn84my+Xw+9Pb2wmazoa2tDWazOa8wQfemSYskSZg1axbsdjt8Pp9Y7AcCAXR2dqKzs1Pzqw5lLCO8Xq8QMDweD4aHh5FOp7F161bRDwcHB4VVDwlEY2Nj4hok7JCLHmWpK4TX60V7ezu6uroyhBBqT3UWpUgkAq/Xi7a2tqxno3pRu43pQekGlA8SMbZs2YKpqSmMj4+jr69PuMLt2rULu3fvFtZwU1NTkCQJIyMjSKfTGB8fF4t4dQwhen8OPfRQ+P3+nJNR6qMej0cIZcoMgUrMZjP8fn/G2ODxeOD1eoW7lLK+QqFQXrfTZDKJ0dFR4SLpdDrh9/uzRCmlKyuJHiQGJ5NJbNy4EUNDQ0in09i5c6eoy127dmHXrl053wOtsYH6WigUEmNhd3e36H9aWTDoOPrXbrdnHEfiI9Hb2yushfKRTCYxNTWFsbEx7NmzRwSjnDNnTlbfovqnvh4Oh4ULmlIMGhkZQSAQQDwex9DQkLBUVKInc6PL5RJupe3t7WI7CbpKC0mbzYbOzs6M830+n6ijtrY2dHV1ifEsHzQu5nL93b17txBZOV09Y0S0MpB1dnbiuuuuY0uhBkctZKxbt67l4qLoQb3YHRwcxODgYMHU9c2M2m1IPUa0qnvp1q1bs7YtWLCgJUQy4MN+MX36dPT19WXtN9o8p/QIxExFKWQxBByc7NtsNpEyGchO7U6m/ACyBJByoOCjZDGjjP+QTqfhdDozyqIOMKrGZrNBkiQ4HA5xTXWcH3LRoJ9CKN3j1JYlwIfBmdVudDabDeFwWHzBVrqRKBed6XQ66wWmL/zKBVE4HIbT6RT317IYUkNuZlQfDodDuATmGjSUsZuAg23k9XrFtWgbxUbJBVlWKOuD3M+cTqeIQ0KZlsiSI5FIZHztVy5OrVYrZFnWtBjKR77jyDpL6cpF1lnqNlUGYycrKXU9KkVE5e9UDj1Z45RZqCgr3PTp0zE+Pg6TyYRgMCjcBikmjTIYMglwWm579P60tbUByG2qTX2UgkrnG0eU/Y+CIVPdUcwr6jtUplxuh3RMNBoVsXzUljbK4+h9IGshct1LpVLYv3+/EAympqbQ1dWFaDSKqakpEeRZC62xwWazibJTPeixGKI61EJZJ8DBsTUYDAqXp3z1QxaIyqDzPp8vy5xY2bfp3aLxhayFKDA0uWIpA/Qr0eMCmsudWG0xRKjHEGU9Ko9Tvmfqd0xZtlxlDAaDbDHEGBp1jAgAOOuss+pQEqbSzJ07Fxs3bhS/79u3T/OYVofS0StdpTZv3pwRbPhjH/tYyyz+CbVoOHPmTKTT6ZaxFgKyxVW1QDZ79mxceOGFtSxSXRkcHNS0MCWMJhiyxZBByBUfRYnf7xdfebUWiSTOaJFLkNCLOtOM0t1EK728xWKBx+PJKCe5axAul0u422jFJVHHqSgGreelgKdatLe3Z4htWhZKJFQVKiOdr7wGxc3Q0wa0mCTXnl27diGVSgnzQ4pDRG4bFGxay20v3zMTZCUBfLjAI4EJONjvTCaTSL3t9/sxbdo04fJHQpTassRsNpfV59SQW4tyQZurj9DCcmpqCtFoFOFwGFNTU0KIUYpLZJWhhbofqPuw1+uF2+1Gb2+veDepLjweD3p6eoSlFlm3KDMwUXyVct9PZfn0Wkcp04wrgziT9Vc0Gi34/pnNZtFX1FY1SpTPR2Wk/mqxWHDkkUeira0NJpMJXV1dIoBxV1cXOjs7SwpCTIJaLkqJiUAB/0moGRoayisems1mYU3T0dEBm80m2l7dt5TjqMPhEOMIuWp5PB5hcUhiqN/vFxZOSsoZOwFoiq16oeyUygkybaOYQvSMWnR2dsJqtWZYgDKMkVCLup2dnS2z6Gt2SPDIBbf1hyxevDjjd/V43YqWVWrRcN++fThw4EBGhrtmp5BwOmPGjBqVxBjkc6c0omDIFkMGQSsmiBKTyYRp06aJL7lax9KCQwty2ygV9eJD6aqitaC12+1ZCzr1QqOtrQ379+/H2NgYuru7s+rA6XSWHHyU3HCUkLuaFjNmzMiwtNIShlwuV1Z5tFx2tM6nc/Us2smihFzPXnvtNfT09GD37t3o7OzE2NiYiBNDzxkIBNDe3p5VFovFgu7u7rz3U7r+0GKsq6tL1Edvby/MZjPmzZsn+mFnZ6ew8KI+19XVlXFds9lcMas1ek6Kv0Tkcpkid6VgMCgsLGKxGLq7u8Vim9piaGgop6ubug+p+zC5KFGbezweWK1WUeckdpCIR328u7sbZrMZHR0dQhjScnEqFpvNplsYCoVCsNvtCIfDcDgcCIVCaG9vRzwex86dOzFjxoyCYhX1L7pvPisUGn+UApHFYoHZbMbHP/5xUVdz5swRsYf8fn/GOcVAbq25KEV4oOyJ06ZNQyKRwK5du3DUUUflFDksFgtmzJiRYS1IFlhafUvdF0gs93g8GW5xJKhNmzZNWEiV+2xK2traSs4IFovFEAwGMwR22kblzVfGWbNmCSGVhSHGaAwODmbFiCj0N5ZpLKZNm5YVNJjgts6N2qW5FQNSk9vQ4OAgJEnKGCu2bdtmOBGgGgwMDGDBggU5g/O3Wr9QWyEqMZq1EMAWQ4ahUEBo+sJst9tzZpXKtyhULoRLQemeBGRmk1Lvo23qgMDq4ygGjjIArxK1UFSMH6bW82p9pSeUadNzLXC1Fiq5tlFcDtqnzAhVCAokLcsy0uk0JicnhQsJuTel02lxb2XgX62gr4XiM5Hlj/J5yDoHgBBSlJYOPp8vY2FPri3qe5fT57Supa7DXItHcvujuCzk5kVBtfNl3VLeU90P1H2YLDsoFguJmQ6HQwSMJrFIGdxYaQlCrm6VqCsSDPRArjpUJ8lkUrg8RiIREScs37hEQh3dV8ulj1ytlO5aymDOZrMZ06dPF0Kjx+MR1kcej0cIgsVAYl0+ShE+yP2P+pAy66IWJI56PB5hHUZtrx7DqQ6prmgcoWPpnaS/A9SPtCw2yxVV6PqlQNndlPWSTqeF0K0UBrXK6Ha7dVtXMrmJRqO44YYbMDAwAKfTiZkzZ+Kyyy7LMuvXw8TEBK644grMmTMHDocDc+bMwZVXXonJycmc56RSKfz4xz/G0UcfDZfLhZ6eHlx88cV49913y3iq+qPlEmDEyT1TOvksXbitP0RtCbFr166M340WVLcWkNvQgQMHsgTkVnJBzBebstUsydSxp5TbjSgUsjDE6KYaKq/X6xXWJ/kWf7TIbwXIBYvc0ebOnSusUEigUS/a9ATnbiWsViu8Xi86OjpEUNyOjg44nc4sAbWQy1GzQsIJubd5vV4hRvT29uYMHF8MlIXLiJQyOSHXMJvNBq/Xi5kzZ7bc169CUOBu5ZhE9cXUhlgshtNPPx233HILQqEQzjvvPMyaNQv33Xcfjj322KIyBY2OjuKjH/0ofvKTn8BqteL888+Hz+fDnXfeieOPPz5r8QMcFAIvuugiXHXVVdizZw+WL1+OBQsW4MEHH8Rxxx2HTZs2VfJxa4ZW0OlWSbncSuRawLdizJx8FBI6jBZUtxbkGluNKgJUi3x9o5UEMkJrvmlUkZldyRjdVGNi39HRIdwWCn2hpixDzY7FYoHL5RKWFosWLYLdbsesWbMAHHTZUlsIVMINqZmw2+2ib1EAaqWVlZJp06a1pMsKufLQv8r4SbNnzy7o3qoHsjoqNV5NNQmHw0XH4iF3VLLoUcdRY6Bp0UrbmNpw6623YsOGDTjxxBPxv//7v+Jv9+23346rr74al112GdauXavrWldeeSW2bNmCT3/60/if//kf8bfnW9/6Fn7605/iqquuwqpVqzLOuffee/HII49g/vz5ePHFF4Vb50MPPYQLL7wQ//iP/4h33323YhallWTNmjXYuHEjEokE2tvbcdZZZ4kF3R//+Mes41sl5XIrQV/41dZhrWgBk49c9UQYdeFbTXK5DeXKKtusaAUnp+2tJJAR+dzJjAZbDLUo5KZUDMrsTsWemwtykdDj+qC+Z6Fy0P5G+2phMpmEewgFmyUXEopTolywl+OGRK4+jUAx/Y6CVDscDmElRG5b6kxW5QbqbVTonaM6oWDQ5P6UK6NgMRi5f5UyhinfP5vNJtyemA8hl0K1GzELQ7VBkiTcddddAICf/exnGR90rrrqKhxzzDFYt24dNm/eXPBa+/fvx+rVq2G323H33XdntOl//ud/oqenBw888ACGh4czzrv99tsBAD/84Q8zYn1dcMEF+OQnP4ktW7bgscceK+s5q8GaNWvwwgsvCHfR8fFxrF69Gj/4wQ9w2223ZVlHeTyellzktAIHDhzI2mbUv2X1JJflbataV+VyG2pFUVEdnBxoTbEwF8VY7tYSFoZaFFmWMTExUfK5Wik8q42WtZCWGTuRSqU0/7gzmagDBhqVVCqFQCBQ72IwRVBMMOxaQ0IrwzQTL730EgKBAObNm4djjz02az+lCX7iiScKXuvZZ59FOp3GKaeckhXM3eFw4Nxzz0UqlcLTTz8ttm/fvh3vvvsuXC4Xli9fXtb9a02urEGxWAzhcDhrOy9ymhetvw3c3tloWczOnDkTy5Ytq0NpjAGLigcZGBjA7Nmz610MQ6D1IcaoLnUsDLUosixjdHS0pHPT6TR27NhR2QLpQMtdSv2lUkkymcTevXtbckAuBq0JrxFJpVJ5hUDGeFAQdiNSTpZGhjEqr7/+OgDtr7XK7W+88UZVrkXnHHXUUZrvfjH3rzXFWDh0dna29OK32VELoQsWLGhJC5hCaIkgre5eyaLiQdasWZMVkNyoVjLVRt0n+vr6DDueGPNTbgtDaY0B7cFFCQkeFIuG/qX/q6+hduugwLDkIlYMlMmI7qGnrKlUSpStGCsCOtdsNgvXMIobo8x8Q8co60MrYxCdT8eRW5G67rXqUOtahY6pFcr6VfcDABnbk8mkaAMtFz1A/zNRvan7WjqdznCzKXRdPfetlAtjLqgMqVSqpPei1HvKslx2PJ9ao3yPAIh3z2w2Z4wrRhVma+ECphxT9PQpI40ntUbt9tto74NRoIl4f3+/5n7avnPnzqpcq5L3JxYsWKC5fevWrZg3b57u6xSChJ7169cXDJp/1llnVey+jPFQu0hx8HxtGmnBWysWL16cEVunVd3qtCwwjWolU220+oRR4ZmXgZBlGZFIBPF4PG8KZIKOC4VCiEajiEQiYl8qlcrK4pVIJBAIBMRxbrcb+/bt03UvJRSANRwOIxAI6MruE4/HsWfPHoyPjxfthpZKpbBv3z6EQiHEYjGMjIxg3759SCQS8Pv94rjx8XFRh7FYDCaTCTNmzMj6wyVJEqampjAxMYFgMCi2R6NRSJIkJoSpVKrgs8VisaqLFXoZGhpCNBrFxMSEaOOJiQnxrAcOHEAkEoEsy9i2bZt4TrXlBKV310sgEMg6XpblLOueQv06mUzmva/FYkF7e7vucpUCpbevtatko7jzqYlGoxgaGsLIyAgkSRL9jsYVGnNaFWpXSZKwc+fOgmOtJElIJBK1KJrhiEQiGBsbw/79+zE8PIxEImGYsbWRCIVCAHJbxJHlrfJvXyWvVcn714Nly5bh2muvzTtxZ+uR5ke9gG3VBW0h1NaERl7w1oqBgQGsWLECxx9/PFasWNGyloXqMbKVx011nzByPbDFkMGIRCKw2+1wuVwFrWpisRhcLhdCoRCcTieSyaSYdKXTacTj8Yy4PJIkIRAIwO12i5+tW7di2rRpRVnwmEwmIQzFYjERGLlQWXfv3o3u7m5MTEwU5XeaTCaxZ88ecZ+hoSGEw2F0dnZmCAWjo6Po7OzMqMO+vr6s68XjcSFoud1uka48HA7D5XKJQKkkruV7tmg0mpHNqZ4cOHAANpsNExMTaGtrg8fjwcTEBOx2OyRJwuTkJGw2G1wuF7Zs2SIyT6ld9BKJBGRZ1p1tKRAIwGq1ZhyfTqcxNjaGnp4esY36a66+lkgkkEqlct7XYrGgs7NTV5lKJRaLweFwYM+ePejv76+Z5UYkEmm4zHIkwlK/c7vdiMVi8Hq92LNnD3p7e5FMJjE5OYmOjo56F7cuRKNRuFwuxONxbN++Hf39/XnH2kQiAbPZDLvdXsNSGoNwOIzx8XFMTU3B4XDA7/cb1tqMqS1vv/225vZclkSVYNmyZejr68PmzZsRDocRjUYhyzKOPvroll3otRK0kNu2bRvmzp1r6IVcPeF60qZVs28poXFycHAQAwMDLT9uNkqfYGGogSl30VqqmEHpp+PxeFFl0Osil+tcrfOVz6C+bq5sXbnuXw0RQMtNqBx3kXxuR1RHyusq60zP9lLRukal65MyaJVLPB5v2UxklSZX/9Hqa60O10N+Kj0mtSrk8qK0IFZCMeV8Pl9VrlXJ+9ebRpnIM9WB218fXE9MLpYtW9byglCjwcKQwfB4PLBYLLoWwJR+2+fzwWq1ZpjdWyyWLEsXu92O9vZ22Gw2mEwmuN1uzJo1q6TFNqUAdzqduixLnE4nZs+eDbfbXbSvttVqRX9/v3jOadOmoaOjI+urend3N0wmU8E6pHpIJpMZwTHdbjesVqsQXbTqUI3L5SoYCyMcDmdMgiVJEmmvS0F9PWL69Olwu90wmUyiTTo6OkQsJpfLBY/HA5PJhPnz5+e0XLDb7UV9qW9vb896FrPZjK6uroxtTqczb1+rRHp0PdDXC61+63Q6YbVaMWvWrJouThsxEDKNIdOnT4fFYhHjEQBhGWM2m6vu/mdklO/j3LlzC/bvVhYsaWzy+/3CapPjDBUPWePu2bNHcz9tnzNnTlWuVcn7MwzDMAxTO1gYMhC00NILLWxpQk3XAA4uzNULX5vNBr/fL45xuVyYOXNmSZNvp9NZlOWLw+FAX19fScFoLRYLZs6cKb4k03Opy93Z2amrDu12u2a2FPV5egS6QsIRcPDLqVLISSQSZQlD6usRvb29wt2O2kS5KFdaGh166KE5n63Y9OLKPkWYTKYst69CAmKt0pqTyXMuYQg4mG61ljSiMAQcHEMcDod4N6lP07hisVgy4oC1GuTKa7fbMXv27IJjrVEzuNUCt9sNl8uVEcy8VUWycli4cCEA4NVXX9XcT9uPOeaYqlyLznnrrbeQSCSy+nQx92cYhmEYpnbw5ziDoeUORNm1ZFkW8V+Ux9IEWu2+obVYVx5LrjlaGbzS6bRm4M90Oi0ykimvpzw/lUqJ85X/t1gsYrGYCwo4SvegTFt0Lv2fyq18RuVCQpkNSKuOzWaz+NGqM7qv8hqpVCoreKwet4dcbl+lkmtxSXWibGPlcyrrzGq1ZtQVtbUyW1sx5cnV19Tb8l23Vi4k+QQ59XtRCMq+pszSVyyN6jqjrCv1GKTsa9QPaAyTJCnjPVKPa5UgV0bCSh2vF62xNh+tHGyZ+opyfGeK5+STT0ZbWxu2bt2K1157LWv/gw8+CAA499xzC17r7LPPhtlsxosvvojh4eGMffF4HE888QQsFgs+8YlPiO2HHnoojjzySESjUTz11FNl3Z9hGIZhmNrBwlCDEA6HkU6nMTo6WrWAnOT7DxwM+KyVkUuSJExMTCAWi2UtpOj8cDgMSZIgSZLI8qTOkJaL4eFhxONxhEIhJBKJnHEKinmWYqGgulrXLOW66qDCuSyWSr1eucTjcZGhLJlM6m6rRuWII46oWHBfqq+pqamGzSxWKygjHgWPJxKJRFYGu0pQzLua652vNeWMWwwDHPz7cvnllwMAvvGNb2T0qdtvvx1vvPEGTj31VCxZskRsv+uuu3DEEUfgu9/9bsa1ZsyYgRUrVkCSJHz961/PSOH+ne98ByMjI/jc5z6H3t7ejPOuuuoqcYxSUHr44Yfx+OOP47DDDsN5551XuYdmGIZhGKZs2JWsQYhGo3C73QgEApg2bVrV7kFuH6lUCpIkZWQ1Aw4u4oLBICwWS8biWpZlxGIx+P1+kSreZDKJ9OPxeFyXoDE5OQmfz4dwOAyr1YpYLFZSkErls5SC1n1p4V/sddV1WK67iPp65SJJkmhLavdGdW3Sw5w5cypmjZBMJpFIJBAOh0V8K0abWCwGt9uN8fFx2O32jLEmEAhkLS7LpZgxgMavegfEjUajdS8D0/hcd911+NOf/oT169dj/vz5OOWUU7Bz505s3LgRPT09uPfeezOOHx0dxfvvv4/9+/dnXeuOO+7Ahg0b8NBDD+GII47Acccdh7fffhtvvfUW5s+fj9tvvz3rnMsuuwxPP/00HnnkERxxxBH4+Mc/jtHRUaxbtw4ulwsPPPBAzVyHGYZhGIbRB1sMNQjkfqV2zyH3DHK7qsQ9AG1XILq/MkCz8ng6n1xLlO5LZrMZsixnfHHUwm63Z9yj1GDEeiad+cqidV+9QcGpTYAPXbOUz16O65Cec5PJZFFWZUpXsFztXuw1jUwlY5dQP9d6J0pFz3vSiNC7owxSTe9GNWLrFDN2VCrjXbk06jump882a782Ik6nE2vWrMH1118Pt9uNRx99FDt37sTKlSvx6quvYu7cubqv1d3djU2bNuGb3/wmJEnCI488gkAggG9961vYtGlTViw54OC4+Ic//AE/+tGPMHPmTDz55JN48803ccEFF+CVV17B8ccfX8nHZRiGYRimApjkRp2JNhELFiwAALz99tua+2VZFim29+3blxEwOhgMwu12I5lMIpVKlWzpQfeg4LskBKgXbIlEAvF4HDabLSNrjPL8WCwmFlkUWyiVSsFutyMQCOTNUhQIBOB2u5FIJGC325FMJnUFeM73LLmOCQQCaGtryxIJcp0fi8Ugy3JBix1qE4vFgmg0CpPJBJvNljNodKUJBAKaAaFzQcGwrVariKOkdrWanJzUrKtWh+qLgqxWwkWN+mazZfOKxWJwOByYnJyEy+WC0+lEMpkU1lY+n69i/UvPGFDO8dXiwIEDmDZtWsO9Z7IsY2pqCm1tbXmPKbZfF/rbyLQ23D8YhmEYJpNy/jayLW+DQBmU1AtPSZLgdDqRSqXK/hqrzNKUL2NVLmscOl8r2xNdr1D8GnL9oHuU+hW/UAYsKkuuhYzW+XquCXzYJhaLBclkUliUxOPxmghD8Xi8qADSyvZUB+RWXpPJhuqr0hYvzRjnid4fpTBAlo4dHR0VFUOU2QuLLR9TGvnGU+UxDMMwDMMwjPFgV7IGQJnZRr0AVbpqlePKoiermbosuY5XH6PcV2gBneu8cp6FoOxHRK6yFHr2QpDQQqIQuS7VKqaCMuOYHrTaTuualUCWZQSDway2aFTK7au5qGXa8lq5CWrVVTEZ4IqBLID0ZvnSykBYjwxhtWx3pWsXBQbXe57Wu6un7LV8PoZhGIZhGEY/LAw1GG63O2MB43a7hcVCvd0g9OD1eut2b1mWMzK0eL3eqrhsuFwuyLKMaDQKh8MhXO5qFdC5GgGQK9Vu6XQaO3fuRDqdRigUatiYKtWmlu9JJBKpW5p0i8VS8WDqxNjYWMniYzwer4twWct2T6fTYjw8cOBAUedqZU/TM+7Uc/xnGIZhGIZhcsPCUIOhdiWz2WzCYsgIwVPzYTKZKpYmvBRkWRZZ0qpZFpvNJr7GKwNW1+preTWey263V0RES6fTGB8fFxYdTDa1fk8SiUTdhCEtK8hKEQ6HSw7ITzHbak2l3jO90HgYDAaLOk/97urps/Ue/xmGYRiGYZjccPBpA+Dz+ZBIJDBv3rx6F6XpSaVSNRHQKFOc0cW6WkOWVBQwnVMW159UKlXRTG1GQZIkIZwXSzqdrrh7oBGh8TAWixVlcVqrd3fr1q2w2WxFC1dMa8BzJ4ZhGIbJpJy5E1sMGYBoNNoU8VYagWoKNVu3bsXWrVsBGCf9tdEwmUzCpc6IopCyDVuFasT4qTdbt27F7t27S36uZhTKtKAxqlg35Fq9u4lEAtFotCb3YhoPj8dTcYvDVvwb0Chw2xgbbh/jwm1jbCrdPjabreSwIsZbmbUghx9+OABOudrocOrcxofbsDngdmwOqB0ZRotiY2PpgccO48JtY2y4fYwLt42xMVL7sMUQwzAMwzAMwzAMwzBMi8LCEMMwDMMwDMMwDMMwTIvCwhDDMAzDMAzDMAzDMEyLwsIQwzAMwzAMwzAMwzBMi8LCEMMwDMMwDMMwDMMwTItikmVZrnchGIZhGIZhGIZhGIZhmNrDFkMMwzAMwzAMwzAMwzAtCgtDDMMwDMMwDMMwDMMwLQoLQwzDMAzDMAzDMAzDMC0KC0MMwzAMwzAMwzAMwzAtCgtDDMMwDMMwDMMwDMMwLQoLQwzDMAzDMAzDMAzDMC0KC0MMwzAMwzAMwzAMwzAtCgtDDMMwDMMwDMMwDMMwLQoLQ3UkGo3ihhtuwMDAAJxOJ2bOnInLLrsMe/furXfRmCIYGRnBNddcg8MPPxwulwudnZ1YvHgxvv3tb9e7aMzf2Lx5M77//e/j05/+NPr7+2EymWAymTSPTafTePHFF/Gd73wHS5Ysgc/ng8PhwLx58/DVr34V27dvr3HpGaKYdiT27duHyy+/HIcddhgcDgfcbjeOOeYY3HjjjQgGgzUqOUNEIhE8+uij+OIXv4jDDz8cTqcTHo8HCxcuxM0334xQKJR1zk033STaWuvnX//1X+vwJEyzwHMx48PzrPrB8yfjwnMi49Kocx2TLMty1e/CZBGLxbBs2TJs2LABM2bMwCmnnIIdO3Zg06ZN6OnpwYYNGzB37tx6F5MpwObNm3HWWWdhbGwMCxYswFFHHYWpqSm888472LNnD5LJZL2LyAA4//zz8dhjj2Vt1xr+tmzZgvnz5wMApk+fjo9+9KOwWCzYtGkT9u7dC5/Ph6effhpLly6termZTIppRwD44IMPcPLJJ2NkZASHHHIIFi9ejFgshvXr12NychIf+chHsH79erS1tVW76Mzf+K//+i98+ctfBgAceeSRYsxcv349gsEgjjjiCKxbtw69vb3inJtuugn/9m//hpNPPhmHHXZY1jWXL1+Oiy66qGbPwDQPPBczPjzPqi88fzIuPCcyLg0715GZunDttdfKAOQTTzxRDgaDYvuPfvQjGYB86qmn1q9wjC6Gh4fl7u5u2e12y4899ljW/o0bN9ahVIwW3//+9+Xrr79efvzxx+X9+/fLDodDzjX8bdmyRf77v/97+c9//rOcTqfF9lgsJq9cuVIGIM+ePVuWJKlWxWf+RjHtKMuy/KlPfUoGIH/961+Xk8mk2D45OSmfcMIJMgD5hhtuqEXRmb+xatUq+Stf+Yr8zjvvZGzft2+ffOyxx8oA5BUrVmTsu/HGG2UA8n333VfDkjKtAM/FjA3Ps+oPz5+MC8+JjEujznVYGKoD8XhcbmtrkwHIr776atb+Y445RgYgv/LKK3UoHaOXr33tazIA+Wc/+1m9i8IUSaE/nrmIRCLi3V27dm0VSsYUQ6F27OrqkgHI+/fvz9r38MMPywDkc845p5pFZIpg/fr1MgDZ4XDI8XhcbDfCZIlpPnguZnx4nmU8eP5kXHhO1BgYea7DMYbqwEsvvYRAIIB58+bh2GOPzdp/4YUXAgCeeOKJWheN0Uk0GsUDDzwAj8eDSy+9tN7FYWqEy+XCwMAAgIN+2oyxcTgcBY/p6uqqQUkYPSxcuBAAEI/HMTY2VufSMM0Oz8WMDc+zmgueP9UfnhMZAyPPdaz1LkAr8vrrrwMAFi9erLmftr/xxhs1KxNTHK+88gqCwSCWLl0Kl8uFZ555Bs899xxisRgGBgZw8cUXY+bMmfUuJlNh0uk0du7cCeCg/zxjbM4880ysWrUKt9xyC37yk5/AYrEAAAKBAH74wx8CAC677LJ6FpFRsG3bNgCAzWZDZ2dn1v7nn38er732GmKxGPr7+3HOOedgyZIltS4m0yTwXMzY8DyrueD5U/3hOZExMPJch4WhOrBr1y4AQH9/v+Z+2k4DKGM83nnnHQBAb2+vZvC3//f//h9+/etfY8WKFfUoHlMlVq9ejeHhYfT09OCkk06qd3GYAnzve9/D5s2bcffdd+Ppp5/GkiVLEIvF8NJLL8HpdOKBBx7AsmXL6l1M5m/ceeedAICzzz5b88vmb37zm4zfr7/+elxwwQVYtWoVvF5vTcrINA88FzM2PM9qLnj+VH94TmQMjDzXYVeyOkAp6txut+Z+j8cDAJw20MBMTEwAAB5//HE8++yz+NnPfobh4WHs2LED11xzDaLRKC655BK89tpr9S0oUzF2796NK6+8EgBw88036zLJZerL9OnTsXbtWpx55pnYsWMHHnroITz11FOYnJzESSedxNYmBuLpp5/Gr3/9a9hsNtxyyy0Z+w477DDcdtttePvttxEKhbB792789re/RV9fHx566CF8/vOfr1OpmUaG52LGhudZzQPPn4wBz4nqj+HnOnWLbtTCfPnLX5YByNdee63m/g8++EAGIM+fP7/GJWP08u///u8yABmA/IMf/CBr/0UXXSQDkD/72c/WoXRMIYoNnhgKheTjjjtOBiCff/75VSwZUwyF2vH111+X+/v75Tlz5siPPfaYPDExIe/Zs0e+4447ZJfLJXd2dsrvvfdeDUvMaPHuu+/KHR0dMgD5jjvu0H3evn37RDDNl19+uYolZJoRnosZG55nGROePxkXnhMZm0aY67DFUB0gM7BIJKK5PxwOAwB8Pl/NysQUh9KUTysoIm1bt25dzcrEVIdEIoGLLroIr7zyCpYuXYrf/e539S4So4NEIoELL7wQ+/btw8MPP4xPfvKTaG9vR19fH6644grceuutGB8fxw033FDvorY0e/fuxdlnn42JiQlcddVVuOKKK3SfO2PGDDHWPvvss9UqItOk8FzM2PA8q/Hh+ZNx4DlRfWmUuQ4LQ3Vg9uzZAIA9e/Zo7qftc+bMqVmZmOKgtnG73ejp6cnaf8ghhwAAhoeHa1kspsKk02lccskleOaZZ7Bo0SI88cQTcLlc9S4Wo4MNGzbggw8+wKGHHqoZXPaiiy4CALzwwgu1LhrzN8bHx3HmmWdi586duPTSS3HbbbcVfY358+cDAPbv31/p4jFNDs/FjA3Psxobnj8ZC54T1Y9GmuuwMFQHKE3dq6++qrmfth9zzDE1KxNTHJTaNhqNIh6PZ+0fHx8HAA6I2uB885vfxOrVqzEwMIA//vGPaG9vr3eRGJ3Qoq6trU1zP22nOBZMbQmFQjjnnHPwzjvv4NOf/jTuuecemEymoq9D7UfxYBhGLzwXMzY8z2pseP5kLHhOVB8aba7DwlAdOPnkk9HW1oatW7dqBs178MEHAQDnnntujUvG6GX27NlYuHAhZFnWNGOmbTSxYRqP6667DnfffTdmz56N5557Dr29vfUuElMElA73/fff1wwe+9e//hXAh1+dmdoRj8dx3nnnYdOmTTjrrLOwevVqkTa3GGRZxiOPPAIgd8pxhskFz8WMDc+zGheePxkPnhPVnoac61Q1ghGTk2uvvVYGIJ900klyKBQS23/0ox/JAORTTz21foVjdPHb3/5WBiAfffTR8r59+8T2//u//5M7OztlAPLvf//7OpaQyUWhAH233367DECePn26PDg4WMOSMcWQrx2j0ajc29srA5C/8IUvyLFYTOzbu3evfPTRR+cNPMtUh2QyKX/qU5+SAcinnHKKHA6H8x4/PDws33XXXfLU1FTG9mAwKP/TP/2TeE8LXYdhtOC5mLHheZbx4PmTceE5kXFo1LmOSZZlubrSE6NFLBbDaaedho0bN2LGjBk45ZRTsHPnTmzcuBE9PT3YsGED5s6dW+9iMgVYuXIl7r//frS3t+Okk05CNBrF+vXrEY/H8eUvfxm/+tWv6l1EBsBTTz2VkRZy06ZNkGUZxx9/vNh2/fXXY/ny5XjttdewePFiyLKME088EQMDA5rX/NKXvoSlS5dWvezMhxTTjgDw6KOP4qKLLkIymURfXx+OO+44RKNRvPzyywgGg1i8eDHWrVvHrgg15M477xRpiz/1qU/B7/drHnfbbbehu7sbO3bswKGHHgqv14u/+7u/w4wZMzAyMoJXX30VY2NjaG9vx5NPPomTTz65hk/BNAs8FzM+PM+qLzx/Mi48JzIuDTvXqarsxOQlEonI119/vTxv3jzZbrfL06dPl1euXCnv3r273kVjdJJOp+Vf/epX8pIlS2S32y17PB75xBNPlFetWlXvojEK7rvvPpH2NtfPfffdJ8uyLK9Zs6bgscrjmdpRTDsSr776qvzZz35W7u/vl202m+zxeORFixbJ//Ef/yFHIpH6PEgLc+ONN+p6v7Zv3y7LsixPTU3J//Iv/yKfeuqpcl9fn+xwOGS32y0vWLBAvvrqq+U9e/bU94GYhofnYsaG51n1hedPxoXnRMalUec6bDHEMAzDMAzDMAzDMAzTonDwaYZhGIZhGIZhGIZhmBaFhSGGYRiGYRiGYRiGYZgWhYUhhmEYhmEYhmEYhmGYFoWFIYZhGIZhGIZhGIZhmBaFhSGGYRiGYRiGYRiGYZgWhYUhhmEYhmEYhmEYhmGYFoWFIYZhGIZhGIZhGIZhmBaFhSGGYRiGYRiGYRiGYZgWhYUhhmEYhmEYhmEYhmGYFoWFIYZhGIZhGIZhGIZhmBaFhSGGYRiGYRiGYRiGYZgWhYUhhmFqgslkKurnkEMOAQCcdtppMJlM2LFjR13LXwyrVq3KeBav11vytSYnJ7PqZu3atZUrLMMwDMMwhoTnTqXBcyeGKR5rvQvAMExrcMkll2Rt+8tf/oKtW7di4cKFWLRoUca+7u7uGpWsetBzOZ3Okq9ht9tF3VF9MQzDMAzT/PDcqTR47sQwxcPCEMMwNWHVqlVZ21auXImtW7fi/PPPx0033aR53n//938jEomgr6+vugWsAvmeSy9ut1vUHdUXwzAMwzDND8+dSoPnTgxTPCwMMQxjaGbPnl3vIjAMwzAMwzQMPHdiGKZYOMYQwzCGJpefPPnSJ5NJ3HLLLTjssMPgcrlw5JFH4r777hPHPf/881i2bBn8fj86OjrwhS98AWNjY5r3SiaT+PnPf44TTzwRfr8fLpcLixYtwh133IFkMlnR53rrrbfwuc99DnPnzoXT6URPTw8WLVqEK6+8Evv376/ovRiGYRiGaR147sQwTLGwxRDDMA3NxRdfLCYw8+bNw7p163DZZZcBAHw+H1asWIETTjgBZ511Fl5++WX85je/wfbt2/HCCy/AZDKJ60SjUSxfvhxr1qxBZ2cnTjjhBDidTmzcuBH//M//jDVr1uCRRx6B2Vy+nr5582YsXboUsVgMxxxzDM477zxEIhFs27YNd955J84//3zMmDGj7PswDMMwDMOo4bkTwzBqWBhiGKZh2blzJ3w+Hz744AP09PQAANasWYPTTz8d1157LSRJwqOPPorly5cDAKampnDSSSfhL3/5C9auXYtly5aJa11zzTVYs2YN/uEf/gG//OUv0dbWBgAIBoP4zGc+g8cffxy/+tWv8NWvfrXscv/kJz9BLBbDbbfdhquvvjpj33vvvSfuzTAMwzAMU0l47sQwjBbsSsYwTENzxx13iIkNACxbtgzHHnss9u/fj3POOUdMbADA7/fjK1/5CgBg3bp1Yvvw8DDuuecezJo1C/fdd1/G5MLn8+HXv/417HY7fv7zn1ekzCMjIwCAM844I2vfEUccwV+8GIZhGIapGjx3YhhGDQtDDMM0LDabDaeddlrW9rlz5wIAzjzzzJz7lL7oa9euRSKRwNlnnw2Xy5V1zvTp0zF//ny8+eabiEajZZd7yZIlAIBvfOMbWLt2bcV98BmGYRiGYbTguRPDMFqwMMQwTMMyffp0WCyWrO1erxcANNO00r54PC62UXDGe+65ByaTSfPn7bffhizLGB8fL7vc3/72t3HaaafhpZdewrJly9DR0YEzzzwTd955JwKBQNnXZxiGYRiG0YLnTgzDaMExhhiGaVgKBTPUG+wwnU4DABYtWoSFCxfmPdbhcOgrXB78fj+ef/55vPTSS3jiiSewdu1aPP/883juuefwve99Dy+++CLmz59f9n0YhmEYhmGU8NyJYRgtWBhiGKbl6e/vBwAsXboUP/3pT2tyT5PJhKVLl2Lp0qUADvrqX3nllVi9ejWuvfZa/P73v69JORiGYRiGYYqF504M01ywKxnDMC3PsmXLYLFY8OSTTyKRSNSlDL29vbjpppsAAG+99VZdysAwDMMwDKMHnjsxTHPBwhDDMC1PX18fLrvsMuzYsQMrVqzA0NBQ1jFbtmzBQw89VJH7/eIXv8D27duztj/99NMAgFmzZlXkPgzDMAzDMNWA504M01ywKxnDMAyAO++8Ezt27MBDDz2EZ599FosWLcLs2bMRDofxzjvvYMuWLTjvvPNwwQUXlH2vX/ziF/ja176Gj3zkIzjyyCNhtVrx3nvv4fXXX4fT6cQNN9xQgSdiGIZhGIapHjx3YpjmgYUhhmEYAC6XC8888wx++9vf4v7778drr72GTZs2oaenB3PmzMHnP/95fOYzn6nIvW655RY8+uij2LhxI/785z9DkiT09/fjS1/6Eq655hocfvjhFbkPwzAMwzBMteC5E8M0DyZZluV6F4JhGKaZWLVqFS699FLceOONwve9EqxcuRL3338/1qxZg9NOO61i12UYhmEYhqknPHdimPrCFkMMwzBV4tFHH8WOHTvgdDrxi1/8oqRrRCIRfP3rXwcA/OUvf6lk8RiGYRiGYQwFz50Ypj6wMMQwDFMlXn/9dbz++uvweDwlT24kScL9999f4ZIxDMMwDMMYD547MUx9YFcyhmEYhmEYhmEYhmGYFoXT1TMMwzAMwzAMwzAMw7QoLAwxDMMwDMMwDMMwDMO0KCwMMQzDMAzDMAzDMAzDtCgsDDEMwzAMwzAMwzAMw7QoLAwxDMMwDMMwDMMwDMO0KCwMMQzDMAzDMAzDMAzDtCgsDDEMwzAMwzAMwzAMw7QoLAwxDMMwDMMwDMMwDMO0KCwMMQzDMAzDMAzDMAzDtCgsDDEMwzAMwzAMwzAMw7QoLAwxDMMwDMMwDMMwDMO0KCwMMQzDMAzDMAzDMAzDtCgsDDEMwzAMwzAMwzAMw7QoLAwxDMMwDMMwDMMwDMO0KP8fg37LYBGyF14AAAAASUVORK5CYII=\n" }, "metadata": {} } @@ -181,6 +724,9 @@ }, "source": [ "### CEBRA-Behavior: Train a model with 3D output that uses positional information (position + direction).\n", + "\n", + "- Please be aware this is JUST a demo notebook; for details on reproducing our paper results, see the paper.\n", + "- Please see our [user docs](https://cebra.ai/docs/usage.html#quick-start-scikit-learn-api-example) for our suggestions on properly using CEBRA for experiments.\n", "- Setting conditional = 'time_delta' means we will use CEBRA-Behavior mode and use auxiliary behavior variable for the model training." ] }, @@ -217,6 +763,7 @@ }, "outputs": [], "source": [ + "#2. Define the model\n", "cebra_posdir3_model = CEBRA(model_architecture='offset10-model',\n", " batch_size=512,\n", " learning_rate=3e-4,\n", @@ -230,6 +777,28 @@ " time_offsets=10)" ] }, + { + "cell_type": "code", + "source": [ + "# 3. Split data and labels\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "(\n", + " train_data,\n", + " valid_data,\n", + " train_continuous_label,\n", + " valid_continuous_label,\n", + ") = train_test_split(hippocampus_pos.neural,\n", + " hippocampus_pos.continuous_index.numpy(),\n", + " test_size=0.2)" + ], + "metadata": { + "id": "_EMORvRizJBG" + }, + "id": "_EMORvRizJBG", + "execution_count": 7, + "outputs": [] + }, { "cell_type": "markdown", "id": "184df8b3", @@ -244,27 +813,558 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "f3923b23", "metadata": { "colab": { - "base_uri": "https://localhost:8080/" + "base_uri": "https://localhost:8080/", + "height": 153 }, "id": "f3923b23", - "outputId": "90d103f5-d872-4169-8725-283fcf1240b1" + "outputId": "aee27798-c49d-4b5a-989e-852528dde8a8" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ - "pos: -0.8980 neg: 6.4137 total: 5.5157 temperature: 1.0000: 100%|██████████| 10000/10000 [02:47<00:00, 59.76it/s]\n" + "pos: -0.4990 neg: 6.5274 total: 6.0284 temperature: 1.0000: 100%|██████████| 10000/10000 [01:30<00:00, 110.21it/s]\n" ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "CEBRA(batch_size=512, conditional='time_delta',\n", + " model_architecture='offset10-model', output_dimension=3, temperature=1,\n", + " time_offsets=10, verbose=True)" + ], + "text/html": [ + "
CEBRA(batch_size=512, conditional='time_delta',\n",
+              "      model_architecture='offset10-model', output_dimension=3, temperature=1,\n",
+              "      time_offsets=10, verbose=True)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 8 } ], "source": [ - "cebra_posdir3_model.fit(hippocampus_pos.neural, hippocampus_pos.continuous_index.numpy())\n", - "cebra_posdir3 = cebra_posdir3_model.transform(hippocampus_pos.neural)" + "# 4. Fit the model\n", + "cebra_posdir3_model.fit(train_data, train_continuous_label)" + ] + }, + { + "cell_type": "code", + "source": [ + "# 5. Save the model\n", + "import os\n", + "import tempfile\n", + "from pathlib import Path\n", + "tmp_file = Path(tempfile.gettempdir(), 'cebra.pt')\n", + "cebra_posdir3_model.save(tmp_file)" + ], + "metadata": { + "id": "MdSozcOZ0nmn" + }, + "id": "MdSozcOZ0nmn", + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# 6. Load the model and compute an embedding\n", + "cebra_posdir3_model = cebra.CEBRA.load(tmp_file)\n", + "train_embedding = cebra_posdir3_model.transform(train_data)\n", + "valid_embedding = cebra_posdir3_model.transform(valid_data)\n" + ], + "metadata": { + "id": "HHeBpZOC0w5g" + }, + "id": "HHeBpZOC0w5g", + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# 7. Evaluate the model performance on the validation set\n", + "goodness_of_fit = cebra.sklearn.metrics.infonce_loss(cebra_posdir3_model,\n", + " valid_data,\n", + " valid_continuous_label,\n", + " num_batches=5)\n", + "print(\" goodness of fit - validation:\",goodness_of_fit)\n", + "\n", + "# Evaluate the model performance on the train set\n", + "goodness_of_fit = cebra.sklearn.metrics.infonce_loss(cebra_posdir3_model,\n", + " train_data,\n", + " train_continuous_label,\n", + " num_batches=5)\n", + "print(\" goodness of fit - train:\",goodness_of_fit)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zX8gtfEf03GG", + "outputId": "92dfa2b2-1692-4030-f08f-3fa04352f442" + }, + "id": "zX8gtfEf03GG", + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 5/5 [00:00<00:00, 257.73it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " goodness of fit - validation: 6.353481006622315\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 5/5 [00:00<00:00, 279.45it/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " goodness of fit - train: 6.022118949890137\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + } ] }, { @@ -282,8 +1382,187 @@ { "cell_type": "code", "source": [ - "import cebra.integrations.plotly\n", - "\n", + "import cebra.integrations.plotly\n", + "\n", + "fig = cebra.integrations.plotly.plot_embedding_interactive(train_embedding,\n", + " embedding_labels=train_continuous_label[:,0],\n", + " title = \"CEBRA-Behavior Train\",\n", + " cmap = \"rainbow\")\n", + "fig.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "id": "kBmYvJcQPbmt", + "outputId": "5e0da111-dcb3-4917-def5-3d1bf52769b7" + }, + "id": "kBmYvJcQPbmt", + "execution_count": 13, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "
\n", + "
\n", + "\n", + "" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "import cebra.integrations.plotly\n", + "\n", + "fig = cebra.integrations.plotly.plot_embedding_interactive(valid_embedding,\n", + " embedding_labels=valid_continuous_label[:,0],\n", + " title = \"CEBRA-Behavior-validation\",\n", + " cmap = \"rainbow\")\n", + "fig.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 535 + }, + "id": "xC7KQUDr4Hsy", + "outputId": "802a174d-04e4-4be4-d198-e6d8cff4d478" + }, + "id": "xC7KQUDr4Hsy", + "execution_count": 14, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "
\n", + "
\n", + "\n", + "" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Using the full data\n", + "\n", + "- Now that we have checked our parameters are not causing overfitting, we will train on the full dataset so we can make comparisons below." + ], + "metadata": { + "id": "MeOfSYHb9tZS" + }, + "id": "MeOfSYHb9tZS" + }, + { + "cell_type": "code", + "source": [ + "cebra_posdir3_model.fit(hippocampus_pos.neural, hippocampus_pos.continuous_index.numpy())\n", + "cebra_posdir3 = cebra_posdir3_model.transform(hippocampus_pos.neural)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2AzAYHPG90Kj", + "outputId": "d7dfd0ed-e466-4055-a96e-a22e9f291764" + }, + "id": "2AzAYHPG90Kj", + "execution_count": 15, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "pos: -0.9097 neg: 6.4148 total: 5.5051 temperature: 1.0000: 100%|██████████| 10000/10000 [01:29<00:00, 111.44it/s]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ "fig = cebra.integrations.plotly.plot_embedding_interactive(cebra_posdir3, embedding_labels=hippocampus_pos.continuous_index[:,0], title = \"CEBRA-Behavior\", cmap = \"rainbow\")\n", "fig.show()" ], @@ -292,11 +1571,11 @@ "base_uri": "https://localhost:8080/", "height": 535 }, - "id": "kBmYvJcQPbmt", - "outputId": "e068d0f0-1151-4466-e4c4-ea152c1ebac5" + "id": "Wu2e587W-FMH", + "outputId": "27552928-404e-4a47-99be-1fd9fbd3269f" }, - "id": "kBmYvJcQPbmt", - "execution_count": 8, + "id": "Wu2e587W-FMH", + "execution_count": 16, "outputs": [ { "output_type": "display_data", @@ -306,9 +1585,9 @@ "\n", "\n", "
\n", - "
\n", - "
\n", - "
\n", - "
\n", - "
\n", - "
\n", - "