From e57fabd8dfb4f85b53ab3202eb5eff5169f1394e Mon Sep 17 00:00:00 2001 From: Gavin Chan Date: Wed, 5 Jul 2023 10:23:21 +0100 Subject: [PATCH 1/7] Experimental Feature - Accelerated NumPy --- .gitignore | 1 + arch/covariance/kernel.py | 4 +- arch/experimental/__init__.py | 10 + arch/experimental/engine.py | 172 ++++++ arch/unitroot/unitroot.py | 23 +- doc/source/experimental/accelerated_numpy.rst | 68 +++ doc/source/index.rst | 1 + examples/experimental_accelerated_numpy.ipynb | 549 ++++++++++++++++++ 8 files changed, 819 insertions(+), 9 deletions(-) create mode 100644 arch/experimental/__init__.py create mode 100644 arch/experimental/engine.py create mode 100644 doc/source/experimental/accelerated_numpy.rst create mode 100644 examples/experimental_accelerated_numpy.ipynb diff --git a/.gitignore b/.gitignore index 162bb2a86f..c6fb760b07 100644 --- a/.gitignore +++ b/.gitignore @@ -18,3 +18,4 @@ dist/ doc/build/ doc/source/**/generated/ arch/univariate/recursions.c +**/.DS_Store diff --git a/arch/covariance/kernel.py b/arch/covariance/kernel.py index 368c7fc06d..b05806fbc9 100644 --- a/arch/covariance/kernel.py +++ b/arch/covariance/kernel.py @@ -4,13 +4,14 @@ from functools import cached_property from typing import SupportsInt, cast -import numpy as np from pandas import DataFrame, Index from pandas.util._decorators import Substitution +from arch.experimental import numpy as np from arch.typing import ArrayLike, Float64Array from arch.utility.array import AbstractDocStringInheritor, ensure1d, ensure2d + __all__ = [ "Bartlett", "Parzen", @@ -398,6 +399,7 @@ def cov(self) -> CovarianceEstimate: sr = x.T @ x / df w = self.kernel_weights num_weights = w.shape[0] + x = np.asarray(self._x) oss = np.zeros((k, k)) for i in range(1, num_weights): oss += w[i] * (x[i:].T @ x[:-i]) / df diff --git a/arch/experimental/__init__.py b/arch/experimental/__init__.py new file mode 100644 index 0000000000..c0c5483c65 --- /dev/null +++ b/arch/experimental/__init__.py @@ -0,0 +1,10 @@ +from .engine import ( + backend, + set_backend, + use_backend, + NumpyEngine, + LinAlgEngine, + numpy, + linalg, + fori_loop, +) diff --git a/arch/experimental/engine.py b/arch/experimental/engine.py new file mode 100644 index 0000000000..dcdb4534bc --- /dev/null +++ b/arch/experimental/engine.py @@ -0,0 +1,172 @@ +from contextlib import contextmanager +from typing import Any + +_BACKEND_ENGINE = "numpy" + + +def backend(): + return _BACKEND_ENGINE + + +def set_backend(library_name): + """ + Set backend engine. + + The function sets the backend engine in global level. + + Parameters + ---------- + library_name : str + Library name. Default is `numpy`. Options are `numpy`, `tensorflow`, + `cupy` and `jax`. + """ + assert library_name.lower() in ["numpy", "tensorflow", "cupy", "jax"], ( + "Only `numpy`, `tensorflow`, `cupy` and `jax` are supported, but not " + f"{library_name}" + ) + global _BACKEND_ENGINE + _BACKEND_ENGINE = library_name + + +@contextmanager +def use_backend(library_name="numpy"): + """ + NumPy engine selection. + + The function is a context manager to enable users to switch to a + specific library as a replacement of NumPy in CPU. + + Parameters + ---------- + library_name : str + Library name. Default is `numpy`. Options are `numpy`, `tensorflow`, + `cupy` and `jax`. + """ + assert library_name.lower() in ["numpy", "tensorflow", "cupy", "jax"], ( + "Only `numpy`, `tensorflow`, `cupy` and `jax` are supported, but not " + f"{library_name}" + ) + global _BACKEND_ENGINE + _original = _BACKEND_ENGINE + try: + _BACKEND_ENGINE = library_name + if _BACKEND_ENGINE == "tensorflow": + import tensorflow.experimental.numpy as np + + np.experimental_enable_numpy_behavior() + yield + finally: + _BACKEND_ENGINE = _original + + +class NumpyEngine: + """ + NumPy engine. + """ + + @property + def name(self): + """ + Get engine name. + """ + global _BACKEND_ENGINE + return _BACKEND_ENGINE + + def __getattribute__(self, __name: str) -> Any: + global _BACKEND_ENGINE + try: + if _BACKEND_ENGINE == "numpy": + import numpy as anp + elif _BACKEND_ENGINE == "tensorflow": + import tensorflow.experimental.numpy as anp + elif _BACKEND_ENGINE == "cupy": + import cupy as anp + elif _BACKEND_ENGINE == "jax": + import jax.numpy as anp + else: + raise ValueError(f"Cannot recognize backend {_BACKEND_ENGINE}") + except ImportError: + raise ImportError( + "Library `numpy` cannot be imported from backend engine " + f"{_BACKEND_ENGINE}. Please make sure to install the library " + f"via `pip install {_BACKEND_ENGINE}`." + ) + + try: + return getattr(anp, __name) + except AttributeError: + raise AttributeError( + "Cannot get attribute / function from numpy library in " + f"backend engine {_BACKEND_ENGINE}" + ) + + +class LinAlgEngine: + """ + Linear algebra engine. + """ + + @property + def name(self): + """ + Get engine name. + """ + global _BACKEND_ENGINE + return _BACKEND_ENGINE + + def __getattribute__(self, __name: str) -> Any: + global _BACKEND_ENGINE + try: + if _BACKEND_ENGINE == "numpy": + import numpy.linalg as alinalg + elif _BACKEND_ENGINE == "tensorflow": + import tensorflow.linalg as alinalg + elif _BACKEND_ENGINE == "cupy": + import cupy.linalg as alinalg + elif _BACKEND_ENGINE == "jax": + import jax.numpy.linalg as alinalg + else: + raise ValueError(f"Cannot recognize backend {_BACKEND_ENGINE}") + except ImportError: + raise ImportError( + "Library `linalg` cannot be imported from backend engine " + f"{_BACKEND_ENGINE}. Please make sure to install the library " + f"via `pip install {_BACKEND_ENGINE}`." + ) + + try: + return getattr(alinalg, __name) + except AttributeError: + raise AttributeError( + "Cannot get attribute / function from linalg library in " + f"backend engine {_BACKEND_ENGINE}" + ) + + +def fori_loop(lower, upper, body_fun, init_val=None): + global _BACKEND_ENGINE + if _BACKEND_ENGINE in ["numpy", "cupy"]: + val = init_val + for i in range(lower, upper): + val = body_fun(i, val) + return val + elif _BACKEND_ENGINE == "jax": + import jax.lax + + return jax.lax.fori_loop(lower, upper, body_fun, init_val) + elif _BACKEND_ENGINE == "tensorflow": + import tensorflow as tf + + i = tf.constant(lower) + while_condition = lambda i: tf.less(i, upper) + + def body(i, val): + return [tf.add(i, 1), body_fun(val)] + + return tf.while_loop(while_condition, body, [i, init_val]) + + raise ImportError(f"Cannot recognize backend {_BACKEND_ENGINE}") + + +numpy = NumpyEngine() +linalg = LinAlgEngine() diff --git a/arch/unitroot/unitroot.py b/arch/unitroot/unitroot.py index 6d1b4e33e1..cfe8522ee5 100644 --- a/arch/unitroot/unitroot.py +++ b/arch/unitroot/unitroot.py @@ -37,7 +37,7 @@ squeeze, sum as npsum, ) -from numpy.linalg import LinAlgError, inv, lstsq, matrix_rank, pinv, qr, solve +from numpy.linalg import LinAlgError, inv, lstsq, matrix_rank, pinv, solve from pandas import DataFrame from scipy.stats import norm from statsmodels.iolib.summary import Summary @@ -86,6 +86,8 @@ invalid_length_doc, ) from arch.utility.timeseries import add_trend +from arch.experimental import numpy as anp, linalg as alinalg + __all__ = [ "ADF", @@ -337,8 +339,13 @@ def _autolag_ols( max_lags=maxlag, lag=max(exog_rank - startlag, 0) ) ) - q, r = qr(exog) - qpy = q.T @ endog + + endog = anp.asarray(endog) + exog = anp.asarray(exog) + q, r = alinalg.qr(exog) + # Convert it to 2-d so as to adapt to linalg.solve input format for all + # engines + qpy = (q.T @ endog)[:, anp.newaxis] ypy = endog.T @ endog xpx = exog.T @ exog @@ -347,12 +354,12 @@ def _autolag_ols( nobs = float(endog.shape[0]) tstat[0] = inf for i in range(startlag, startlag + maxlag + 1): - b = solve(r[:i, :i], qpy[:i]) - sigma2[i - startlag] = squeeze(ypy - b.T @ xpx[:i, :i] @ b) / nobs + b = alinalg.solve(r[:i, :i], qpy[:i]) + sigma2[i - startlag] = anp.squeeze(ypy - b.T @ xpx[:i, :i] @ b) / nobs if lower_method == "t-stat" and i > startlag: - xpxi = inv(xpx[:i, :i]) - stderr = sqrt(sigma2[i - startlag] * xpxi[-1, -1]) - tstat[i - startlag] = squeeze(b[-1]) / stderr + xpxi = alinalg.inv(xpx[:i, :i]) + stderr = anp.sqrt(sigma2[i - startlag] * xpxi[-1, -1]) + tstat[i - startlag] = anp.squeeze(b[-1]) / stderr return _select_best_ic(method, nobs, sigma2, tstat) diff --git a/doc/source/experimental/accelerated_numpy.rst b/doc/source/experimental/accelerated_numpy.rst new file mode 100644 index 0000000000..cd90fd9afd --- /dev/null +++ b/doc/source/experimental/accelerated_numpy.rst @@ -0,0 +1,68 @@ +.. module:: arch.experimental.engine + :noindex: +.. currentmodule:: arch.experimental.engine + +Accelerated NumPy +================= + +The feature is to allow users to choose alternative NumPy-like engine +to run on CPU and GPU. Currently, the following engine are supported in +CPU and GPU runtime + + +* `JAX `_ + +* `TensorFlow `_ + +* `CuPy `_ + +There are two options users can switch the backend engine. + +1. Context Manager + +Users can use function ``use_backend`` in a ``with`` statement to temporarily +switch the NumPy engine. + +In the below example, assume that ``data`` object is a timeseries in NumPy array. +The covariance estimation (NeweyWest) is computed in TensorFlow. Since the +output is in TensorFlow Tensor type, the last line convert the long term +covariance from Tensor to NumPy array type. + +.. code-block:: python + + import numpy as np + + from arch.experimental import use_backend + from arch.covariance.kernel import NeweyWest + + with use_backend("tensorflow"): + cov = NeweyWest(data).cov + + long_term_cov = np.asarray(cov.long_term) + +2. Global + +Users can also configure the backend engine in global level with function +``set_backend``. + +.. code-block:: python + + from arch.experimental import set_backend + + set_backend("tensorflow") + + # Output is already in TensorFlow Tensor type + long_term_cov = NeweyWest(data).cov.long_term + +For further examples, please refer to the example +`notebook `_. + +Configure +--------- + +.. autosummary:: + :toctree: generated/ + + use_backend + set_backend + diff --git a/doc/source/index.rst b/doc/source/index.rst index 88627d7d1c..3e420cca63 100644 --- a/doc/source/index.rst +++ b/doc/source/index.rst @@ -35,6 +35,7 @@ routines relevant for the analysis of financial data. Multiple Comparison Problems Unit Root Tests and Cointegration Analysis Long-run Covariance Estimation + Experimental features API Reference Change Log diff --git a/examples/experimental_accelerated_numpy.ipynb b/examples/experimental_accelerated_numpy.ipynb new file mode 100644 index 0000000000..2c5572783e --- /dev/null +++ b/examples/experimental_accelerated_numpy.ipynb @@ -0,0 +1,549 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "H1doh35B3vRA" + }, + "source": [ + "# Accelerated Numpy\n", + "\n", + "The notebook demonstrates the performance in switching between various underlying\n", + "engine, e.g. JAX / Tensorflow, to run NumPy operations in CPU and GPU.\n", + "\n", + "In Google Colab, please follow the following steps to change to GPU runtime type\n", + "\n", + "1. Click \"Runtime\" -> \"Change runtime type\" at the top bar\n", + "2. Choose \"GPU\" in \"Hardware accelerator\" and \"T4\" in \"GPU type\"\n", + "3. Press \"Save\" button to switch runtime type" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "e2bSb8nb3vRB" + }, + "source": [ + "(Currently the functionality is only available in the feature branch `feature/tnp`)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "erbuAiRs3vRC", + "outputId": "c1d995de-7687-473b-ed85-c68f6e614e31" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting git+https://github.com/gavincyi/arch.git@feature/tnp\n", + " Cloning https://github.com/gavincyi/arch.git (to revision feature/tnp) to /tmp/pip-req-build-x_5egqd7\n", + " Running command git clone --filter=blob:none --quiet https://github.com/gavincyi/arch.git /tmp/pip-req-build-x_5egqd7\n", + " Running command git checkout -b feature/tnp --track origin/feature/tnp\n", + " Switched to a new branch 'feature/tnp'\n", + " Branch 'feature/tnp' set up to track remote branch 'feature/tnp' from 'origin'.\n", + " Resolved https://github.com/gavincyi/arch.git to commit d351c541fe5065f0fee1f32c79ba66b28838d974\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (1.22.4)\n", + "Requirement already satisfied: scipy>=1.3 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (1.10.1)\n", + "Requirement already satisfied: pandas>=1.0 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (1.5.3)\n", + "Requirement already satisfied: statsmodels>=0.11 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (0.13.5)\n", + "Requirement already satisfied: property-cached>=1.6.4 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (1.6.4)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.0->arch==0.1.dev1038+gd351c54) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.0->arch==0.1.dev1038+gd351c54) (2022.7.1)\n", + "Requirement already satisfied: patsy>=0.5.2 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.11->arch==0.1.dev1038+gd351c54) (0.5.3)\n", + "Requirement already satisfied: packaging>=21.3 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.11->arch==0.1.dev1038+gd351c54) (23.1)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from patsy>=0.5.2->statsmodels>=0.11->arch==0.1.dev1038+gd351c54) (1.16.0)\n", + "Building wheels for collected packages: arch\n", + " Building wheel for arch (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for arch: filename=arch-0.1.dev1038+gd351c54-cp310-cp310-linux_x86_64.whl size=1802322 sha256=4d31c2cea2fde6e59546f8f04ee4327b1fbe34302a6cbf22d446cf3950b7d0e5\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-0uirgqcj/wheels/e0/96/b7/674f6b3592bc98941ccfa3c74700acca078de257ddd554cdbe\n", + "Successfully built arch\n", + "Installing collected packages: arch\n", + " Attempting uninstall: arch\n", + " Found existing installation: arch 0.1.dev1036+g906cf00\n", + " Uninstalling arch-0.1.dev1036+g906cf00:\n", + " Successfully uninstalled arch-0.1.dev1036+g906cf00\n", + "Successfully installed arch-0.1.dev1038+gd351c54\n" + ] + } + ], + "source": [ + "!pip install git+https://github.com/gavincyi/arch.git@feature/tnp" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "Rhuk-ebE3vRC" + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "gn_T2Wf_3vRC" + }, + "outputs": [], + "source": [ + "from typing import Tuple\n", + "from time import time\n", + "import warnings\n", + "\n", + "import pandas as pd\n", + "\n", + "from arch.experimental.engine import use_backend\n", + "from arch.covariance.kernel import NeweyWest\n", + "from arch.typing import ArrayLike\n", + "from arch.unitroot import ADF\n", + "\n", + "warnings.filterwarnings(\"ignore\", category=UserWarning)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "S7pe1H2Ste8O" + }, + "source": [ + "# Engines\n", + "\n", + "If the CUDA library is installed with physical GPU, the below cell will return the\n", + "following output.\n", + "\n", + "```\n", + "Supported engines: numpy, tensorflow, jax, cupy\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HGRbhqtRte8O", + "outputId": "8c31301e-b85e-4a3a-e670-35c94188c265" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Supported engines: numpy, tensorflow, jax\n" + ] + } + ], + "source": [ + "ENGINES = [\"numpy\", \"tensorflow\", \"jax\"]\n", + "\n", + "try:\n", + " import tensorflow.test\n", + " if len(tensorflow.config.list_physical_devices(\"GPU\")):\n", + " ENGINES.append(\"cupy\")\n", + "except ImportError:\n", + " raise ImportError(\"Tensorflow should be installed\")\n", + "\n", + "print(f\"Supported engines: {', '.join(ENGINES)}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "UJORee683vRD" + }, + "source": [ + "# Covariance\n", + "\n", + "The following benchmarks measure the average runtime of covariance computation.\n", + "\n", + "We will measure the runtime performance on 1-d and 2-d arrays.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "AMpUvdsu3vRE" + }, + "outputs": [], + "source": [ + "def cov_get_data(size: Tuple[int, ...], burn: int = 500, use_pandas: bool = False) -> ArrayLike:\n", + " import numpy as np\n", + " rs = np.random.RandomState([3894830, 432841, 323297, 8927821])\n", + " e = rs.standard_normal(size)\n", + " ndim = len(size)\n", + " if ndim == 1:\n", + " phi = rs.uniform(0, 0.9, 1)\n", + " for i in range(1, size[0]):\n", + " e[i] += e[i - 1] * phi\n", + " else:\n", + " phi = np.diag(rs.uniform(0, 0.9, size[1]))\n", + " for i in range(1, size[0]):\n", + " e[i] += e[i - 1] @ phi\n", + " e = e[burn:]\n", + " if use_pandas:\n", + " if ndim == 1:\n", + " return pd.Series(e, name=\"x\")\n", + " else:\n", + " return pd.DataFrame(e, columns=[f\"x{i}\" for i in range(e.shape[1])])\n", + " return e" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "m2GuzwHD3vRE" + }, + "outputs": [], + "source": [ + "def cov_timeit(\n", + " library: str,\n", + " size: Tuple[int, ...] = (5000, ),\n", + " estimator: object = NeweyWest,\n", + " use_pandas: bool = False\n", + "):\n", + " import numpy as np\n", + " data = cov_get_data(size, use_pandas=use_pandas)\n", + "\n", + " def _func():\n", + " cov = estimator(data).cov.long_run\n", + " if library == \"cupy\":\n", + " cov = cov.get()\n", + " if not use_pandas:\n", + " # Force to convert back to numpy array\n", + " cov = np.asarray(cov)\n", + " return cov\n", + "\n", + " with use_backend(library):\n", + " # Warm start (e.g. JAX to compile the function first) and\n", + " # estimate the runtime to determine the total number of runs\n", + " start = time()\n", + " cov = estimator(data).cov\n", + " end = time()\n", + " elapsed = end - start\n", + "\n", + " # Generally the total runtime should not be more than 10s\n", + " if elapsed < 0.01:\n", + " n_run = 1000\n", + " elif elapsed < 0.1:\n", + " n_run = 100\n", + " elif elapsed < 1.0:\n", + " n_run = 10\n", + " else:\n", + " n_run = 1\n", + "\n", + " # Get total runtime\n", + " runtimes = [0.0] * n_run\n", + " for index in range(n_run):\n", + " start = time()\n", + " ret = _func()\n", + " end = time()\n", + " runtimes[index] = end - start\n", + "\n", + " return 1000 * np.percentile(runtimes, 90), n_run, ret\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "FXaw2b-cte8Q" + }, + "source": [ + "First, we measure the runtimes on covariance computation on 1-d array of size\n", + "from 1000 to 7500.\n", + "\n", + "For 1-d array, even with GPU activated, the NumPy still produces the best performance." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 490 + }, + "id": "wSPb40Nc3vRE", + "outputId": "8fdb696a-a1d7-4068-ca1f-6a26d9cefc47" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Runtime (ms)')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACNjElEQVR4nOzdd1QUVxsG8GcX2KUuRZogInZRbGgUe9SI2GIvsYAlxVhjoonJF1sSTWISY0k0TTTWxBq7sYENjV2xImIHsdE7e78/VlaWJn0WeH7nzIGde/fOO7PL8u6dO3dkQggBIiIionJKLnUARERERCWJyQ4RERGVa0x2iIiIqFxjskNERETlGpMdIiIiKteY7BAREVG5xmSHiIiIyjUmO0RERFSuMdkhIiKico3JDlEOqlWrBj8/P+3jgIAAyGQyBAQESBZTSenQoQM6dOggdRg6Tp06hVatWsHMzAwymQznz5+XOiS9c/v2bchkMqxYsULqUIosJCQEXbp0gaWlJWQyGbZu3Sp1SJLI+rlDxYfJjgTOnDmDrl27QqVSwcLCAl26dMn1w/z48eNo06YNTE1N4ejoiIkTJyIuLk6nzoMHD9C9e3eoVCq4u7tj+/bt2drZvHkz7O3tER0dXRK7VCYdP34cs2bNQlRUlNShlLgrV65g1qxZuH37ttShvFJqaioGDBiAZ8+eYcGCBVi1ahVcXV2lDotKkK+vLy5duoSvvvoKq1atQrNmzaQOKU9fffUVevXqBQcHB8hkMsyaNUvqkOhVBJWqM2fOCGNjY1GrVi3x3XffiW+//VZUq1ZNqFQqce3aNZ26586dE8bGxqJJkyZi6dKl4rPPPhNKpVJ07dpVp16nTp1E3bp1xc8//yyGDh0qlEqlCAsL05YnJiYKNzc38csvv5TGLpYZ8+fPFwB0jlWGpKQkkZKSon186NAhAUAcOnSo9AIsRhs2bMg1/uTkZJGcnFz6QeXi6tWrAoD47bffpA5Fr6nVapGYmCjS0tKkDqVIEhISBADx2WefSR1KvgEQjo6OwtvbWwAQM2fOLJZ2XV1dha+vb7G0RboMJcyzKqTPP/8cJiYmCAoKQqVKlQAAw4YNQ+3atfHpp59i06ZN2rqffvoprK2tERAQAJVKBUDTzfn222/j33//RZcuXZCYmIiDBw8iICAA7dq1w3vvvYfjx49j7969ePfddwEA3333HSwtLTFmzJjS3+E8CCGQlJQEExMTqUPJRqlUlvo2k5KSoFAoIJeXboerQqEo1e29SmRkJADAysqq2NqMj4+HmZlZsbUnpbS0NKjVaigUChgbG0sdTpE9fvwYQP5eb315HcPCwlCtWjU8efIEdnZ2UoeTb2q1GikpKTm+b/Tl2JYYqbOtisbCwkIMGDAg2/ru3bsLhUIhYmNjhRBCREdHC0NDQzF16lSdesnJycLc3FyMHj1aCCHEs2fPBABx8eJFbZ0mTZqIH374QQghxP3794WZmZkIDAwsUJy+vr7CzMxMhIaGii5dughTU1NRuXJlMXv2bKFWq3XqpqeniwULFgh3d3ehVCqFvb29eOedd8SzZ8906rm6uoru3buLPXv2CE9PT6FUKsWCBQuEEEI8f/5cTJ48Wbi6ugqFQiGcnZ3F8OHDxePHj7XPT0pKEjNmzBA1atQQCoVCVKlSRUydOlUkJSXpbAeAGDdunNiyZYuoX7++UCgUwt3dXezevVtbZ+bMmQJAtiWjlyfrN6zcenZOnDghvL29hUqlEiYmJqJdu3bi6NGjrzy+Ge2tW7dOfPbZZ8LJyUnIZDLx/PlzbWxZ+fv7Z+uJyjimR44cEc2bNxdKpVK4ubmJlStXZnte1iVjX9q3by/at2+fLba//vpLzJo1Szg5OQlzc3PRr18/ERUVJZKSksSkSZOEnZ2dMDMzE35+ftleAyGEWLVqlWjatKkwNjYW1tbWYtCgQeLu3bt5HhdfX99scWaO7cCBA6JNmzbC1NRUWFpail69eokrV67otJFx/C5fviyGDBkirKysROPGjfPcbn7ef48ePRKjRo0S9vb2QqlUioYNG4oVK1Zoy1NSUoS1tbXw8/PL1n50dLRQKpXiww8/FEJo/o4///xz0bRpU6FSqYSpqalo06aNOHjwoM7zwsLCBAAxf/58sWDBAlG9enUhl8vFuXPntGX+/v7a+hcuXBC+vr7Czc1NKJVK4eDgIEaOHCmePHmS4zEKCQkRvr6+wtLSUqhUKuHn5yfi4+Ozxb9q1SrRvHlzYWJiIqysrETbtm3F3r17ders2rVL+9qYm5uLbt26ieDg4DyPe05/h66urjplOb2OqampYs6cOaJ69epCoVAIV1dXMX369Gzvw4y/j0OHDglPT09hbGwsGjRooH3vb9q0STRo0EAolUrRtGlTcfbs2Tzjzerx48eF6tlRq9Xiiy++EM7OzsLExER06NBBBAcH57tnZ/78+cLLy0vY2NgIY2Nj0bRpU7Fhw4Zs9TI+C1evXi3c3d2FoaGh2LJli/YzISAgQIwdO1bY2dkJKysrIYQQt2/fFmPHjhW1a9cWxsbGwsbGRvTv31/ncyc0NFQA0P6fyezYsWMCgFi7dm2BjklJY89OKUtOTs6xJ8PU1BQpKSkIDg5Gy5YtcenSJaSlpWU7d61QKNC4cWOcO3cOAGBtbY0aNWpg7ty5mDt3Lo4fP47z589j8eLFAIBp06bBx8cH7dq1K3Cs6enp6Nq1K1q2bIlvv/0We/bswcyZM5GWloY5c+Zo67377rtYsWIFRo4ciYkTJyIsLAxLlizBuXPncOzYMRgZGWnrXr9+HUOGDMG7776Lt99+G3Xq1EFcXBzatm2Lq1evYtSoUWjatCmePHmCbdu24f79+7C1tYVarUavXr1w9OhRvPPOO6hXrx4uXbqEBQsW4MaNG9kGNB49ehSbN2/G+++/DwsLCyxatAj9+vXD3bt3UalSJfTt2xc3btzAunXrsGDBAtja2gJAgb6lHTx4ED4+PvD09MTMmTMhl8vh7++Pjh074siRI3jttdde2cYXX3wBhUKBjz76CMnJyYXqZbl58yb69++P0aNHw9fXF8uXL4efnx88PT1Rv359tGvXDhMnTsSiRYvw6aefol69egCg/ZmbefPmwcTEBJ988glu3ryJxYsXw8jICHK5HM+fP8esWbNw4sQJrFixAm5ubpgxY4b2uV999RU+//xzDBw4EGPGjMHjx4+xePFitGvXDufOncv1W/y7774LZ2dnzJ07FxMnTkTz5s3h4OAAANi/fz98fHxQvXp1zJo1C4mJiVi8eDFat26Ns2fPolq1ajptDRgwALVq1cLcuXMhhMh1P/Pz/ktMTESHDh1w8+ZNjB8/Hm5ubtiwYQP8/PwQFRWFSZMmwcjICH369MHmzZvxyy+/6LyWW7duRXJyMgYPHgwAiImJwe+//44hQ4bg7bffRmxsLP744w94e3vjv//+Q+PGjXVi9Pf3R1JSEt555x0olUrY2NhArVZn25d9+/bh1q1bGDlyJBwdHXH58mX8+uuvuHz5Mk6cOAGZTKZTf+DAgXBzc8O8efNw9uxZ/P7777C3t8c333yjrTN79mzMmjULrVq1wpw5c6BQKHDy5EkcPHgQXbp0AQCsWrUKvr6+8Pb2xjfffIOEhAQsXboUbdq0wblz57K9Nhn69u0LKysrfPDBBxgyZAi6desGc3PzV76OY8aMwcqVK9G/f398+OGHOHnyJObNm4erV69iy5YtOs+/efMm3nrrLbz77rsYNmwYvvvuO/Ts2RPLli3Dp59+ivfffx+A5v0+cOBAXL9+vcR7V2fMmIEvv/wS3bp1Q7du3XD27Fl06dIFKSkp+Xr+woUL0atXLwwdOhQpKSlYv349BgwYgB07dqB79+46dQ8ePIi///4b48ePh62tLapVq6YdI/r+++/Dzs4OM2bMQHx8PADNxQHHjx/H4MGDUaVKFdy+fRtLly5Fhw4dcOXKFZiamqJ69epo3bo11qxZgw8++EBne2vWrIGFhQXefPPNoh+o4iR1tlXReHh4iNq1a+ucZ09OThZVq1YVAMTGjRuFEC/HWBw+fDhbGwMGDBCOjo7axwcOHBDW1tbab0aTJ08WQmgybBMTE3H79u0Cx5nxDXvChAnadWq1WtsDlfGN98iRIwKAWLNmjc7z9+zZk229q6urACD27NmjU3fGjBkCgNi8eXO2ODJ6kVatWiXkcrk4cuSITvmyZcsEAHHs2DHtOgBCoVCImzdvatdduHBBABCLFy/WrstrzM6renbUarWoVauW8Pb21unpSkhIEG5ubuKNN97I1mZmGe1Vr15dJCQk6JQVtGcn6/skMjJSpxdBiLzH7OTWs9OgQQOdcUtDhgwRMplM+Pj46Dzfy8tL+21cCM03QwMDA/HVV1/p1Lt06ZIwNDTMtj6rjO1n/abauHFjYW9vL54+fapdd+HCBSGXy8WIESO06zKO35AhQ/LcTob8vP9+/PFHAUCsXr1aW5aSkiK8vLyEubm5iImJEUIIsXfvXgFAbN++Xaedbt26ierVq2sfp6WlZRsn9fz5c+Hg4CBGjRqlXZfRe6NSqURkZKRO/Zx6drK+l4QQYt26ddneIxnHKPO2hBCiT58+olKlStrHISEhQi6Xiz59+oj09PQcj01sbKywsrISb7/9tk55RESEsLS0zLY+q8y9V5nl9jqeP39eABBjxozRWf/RRx8JADq9Yxl/H8ePH9euy3iNTExMxJ07d7Trf/nllwKPyytMz05kZKRQKBSie/fuOp8dn376qQCQr56drK9zSkqKaNCggejYsaPOegBCLpeLy5cv66zP+Cxp06ZNtjFfOb2HgoKCBADx559/atdlHK+rV6/qxGFra6uX4454NVYpe//993Hjxg2MHj0aV65cQXBwMEaMGIHw8HAAQGJios7PnMaOGBsba8sBoGPHjrh79y5OnDiBu3fvYsGCBVCr1Zg4cSI+/PBDuLq6YunSpahbty7q1KmDZcuW5Tve8ePHa3+XyWQYP348UlJSsH//fgDAhg0bYGlpiTfeeANPnjzRLp6enjA3N8ehQ4d02nNzc4O3t7fOuk2bNqFRo0bo06dPtu1nfBPdsGED6tWrh7p16+psp2PHjgCQbTudO3dGjRo1tI8bNmwIlUqFW7du5Xvf83L+/HmEhITgrbfewtOnT7XxxMfHo1OnTjh8+HCO37yz8vX1LfKYJXd3d7Rt21b72M7ODnXq1Cnyvo4YMUKnV65FixYQQmDUqFE69Vq0aIF79+4hLS0NgObKP7VajYEDB+q8Vo6OjqhVq1a21yo/wsPDcf78efj5+cHGxka7vmHDhnjjjTewa9eubM9577338tV2ft5/u3btgqOjI4YMGaItMzIy0l4dGRgYCEDzt2hra4u//vpLW+/58+fYt28fBg0apF1nYGCg7flRq9V49uyZtif37Nmz2eLo169fvnodM7+XkpKS8OTJE7Rs2RIAcmw36zFq27Ytnj59ipiYGACaHim1Wo0ZM2Zk6+3IODb79u1DVFQUhgwZovN6GxgYoEWLFoV6vfOKMeO1njJlis76Dz/8EACwc+dOnfXu7u7w8vLSPm7RogUAzWtVtWrVbOuL6zMiN/v370dKSgomTJig09M2efLkfLeR+XV+/vw5oqOj0bZt2xxf4/bt28Pd3T3Hdt5++20YGBjk2nZqaiqePn2KmjVrwsrKSqf9gQMHwtjYGGvWrNGu27t3L548eYJhw4ble19KC09jlbL33nsP9+7dw/z587Fy5UoAQLNmzTBt2jR89dVX2i7cjDdccnJytjZyGtRrbm6u/WMFNN3eERER+OSTT7B//35MnToVq1evhkwmw1tvvYU6derg9ddfzzNWuVyO6tWr66yrXbs2AGgvYQ4JCUF0dDTs7e1zbCNjsGkGNze3bHVCQ0PRr1+/PGMJCQnB1atXc/3Az7qdzB9iGaytrfH8+fM8t5NfISEhADTJSm6io6NhbW2dZzs5HY+CKql9zdqupaUlAMDFxSXberVajejoaFSqVAkhISEQQqBWrVo5tps5gcqvO3fuAADq1KmTraxevXrYu3dvtgGW+T22+Xn/3blzB7Vq1cr2Dz/jVGBGfIaGhujXrx/Wrl2L5ORkKJVKbN68GampqTrJDgCsXLkS33//Pa5du4bU1NQ8487vvjx79gyzZ8/G+vXrs/1N5DTtRNbXOOP9+vz5c6hUKoSGhkIul+f6zxJ4+beQ8cUjq4yLKwor677fuXMHcrkcNWvW1Fnv6OgIKysr7WuRoSDvYwDF9hkRFxenM02IgYEB7OzstPFl/fuws7N75edFhh07duDLL7/E+fPndf5HZD1NCeT93smpLDExEfPmzYO/vz8ePHigcwo483vIysoKPXv2xNq1a/HFF18A0JzCcnZ2zvW9ICUmOxL46quv8NFHH+Hy5cuwtLSEh4cHPv30UwAvk4nKlSsDgLbHJ7Pw8HA4OTnl2n5MTAw+++wzfPfddzAzM8O6devQv39/9O7dGwDQv39/rFmz5pXJTn6o1WrY29vrZPeZZU1OCtuLoVar4eHhgR9++CHH8qwfXFm/rWQQeYzdKGg8ADB//vxs4ysyZB17kJOcjkdOH1iAZgxVTkpqX3Nr91XbU6vVkMlk2L17d45183NcioNUV/kNHjwYv/zyC3bv3o3evXvj77//Rt26ddGoUSNtndWrV8PPzw+9e/fG1KlTYW9vDwMDA8ybNw+hoaHZ2szvvgwcOBDHjx/H1KlT0bhxY5ibm0OtVqNr16459jQWx3sno91Vq1bB0dExW7mhYdH+zeS277n9nWRV2PdxUX333XeYPXu29rGrq2uxzHN15MgR9OrVC+3atcPPP/+MypUrw8jICP7+/li7dm22+nm9d3IqmzBhAvz9/TF58mR4eXlpJ3ocPHhwtvfQiBEjsGHDBhw/fhweHh7Ytm0b3n///VK/ojQ/mOxIxNraGm3atNE+3r9/P6pUqYK6desCABo0aABDQ0OcPn0aAwcO1NZLSUnB+fPnddZlNWfOHLi5uWHo0KEAgIcPH6JJkybacicnp3zNSKtWq3Hr1i1tAgYAN27cAADtgMMaNWpg//79aN26daH/udSoUQPBwcGvrHPhwgV06tQp3x9yr1KUdjJOkalUKnTu3LlY4smQ8e0uKipKZyBv1m+sBVFcxyw/atSoASEE3NzcdN47RZExqeD169ezlV27dg22traFvmw2P+8/V1dXXLx4EWq1WueD/Nq1azrxAUC7du1QuXJl/PXXX2jTpg0OHjyIzz77TKe9jRs3onr16ti8ebPOazNz5sxC7QOg6ZE4cOAAZs+erTNYPKPnpTBq1KgBtVqNK1eu5JrUZ/wt2NvbF/vfQk5cXV2hVqsREhKiM8j+0aNHiIqK0psJKEeMGKHzGZ/x+ZgRX0hIiE7P+ePHj/PVq7Rp0yYYGxtj7969OsMc/P39iyXujRs3wtfXF99//712XVJSUo6Tr3bt2hV2dnZYs2YNWrRogYSEBAwfPrxY4ihu+pd+VUB//fUXTp06hcmTJ2s/SC0tLdG5c2esXr0asbGx2rqrVq1CXFwcBgwYkGNbN27cwJIlS7Bw4ULth6iDg4P2QxkArl69muM3sJwsWbJE+7sQAkuWLIGRkRE6deoEQPNNMj09XduNmVlaWlq+Zifu168fLly4kO0qioxtZmznwYMH+O2337LVSUxM1F5JUBAZ/xwLM4Oyp6cnatSoge+++y7bjNbAy7lDCiPjn8fhw4e16+Lj47WnPQujKPtaUH379oWBgQFmz56d7VuyEAJPnz4tcJuVK1dG48aNsXLlSp19CA4Oxr///otu3boVOt78vP+6deuGiIgInbE4aWlpWLx4MczNzdG+fXvterlcjv79+2P79u1YtWoV0tLSsp3CyuhVyHx8Tp48iaCgoELvR05tAsCPP/5Y6DZ79+4NuVyOOXPmZPtWn7Edb29vqFQqzJ07V+d0XIai/C3kJOO1zrpfGb2+Wa9Gkkr16tXRuXNn7dK6dWsAmvGERkZGWLx4sc5rld/XycDAADKZTKen9/bt28V2iw0DA4Ns76HFixfn2LNsaGiIIUOG4O+//8aKFSvg4eGBhg0bFkscxY09O6Xs8OHDmDNnDrp06YJKlSrhxIkT8Pf3R9euXTFp0iSdul999RVatWqF9u3b45133sH9+/fx/fffo0uXLujatWuO7X/wwQcYNGiQzmXP/fv3x5tvvqk9VbZ9+3bs2LHjlbEaGxtjz5498PX1RYsWLbB7927s3LkTn376qfb0VPv27fHuu+9i3rx5OH/+PLp06QIjIyOEhIRgw4YNWLhwIfr375/ndqZOnYqNGzdiwIABGDVqFDw9PfHs2TNs27YNy5YtQ6NGjTB8+HD8/fffeO+993Do0CG0bt0a6enpuHbtGv7++2/s3bu3wFPMe3p6AgA+++wzDB48GEZGRujZs2e+egjkcjl+//13+Pj4oH79+hg5ciScnZ3x4MEDHDp0CCqVKsfbduRHly5dULVqVYwePRpTp06FgYEBli9fDjs7O9y9e7dQbTZu3BgGBgb45ptvEB0dDaVSiY4dO+Y61qooatSogS+//BLTp0/H7du30bt3b1hYWCAsLAxbtmzBO++8g48++qjA7c6fPx8+Pj7w8vLC6NGjtZeeW1paFmm6/vy8/9555x388ssv8PPzw5kzZ1CtWjVs3LgRx44dw48//ggLCwudNgcNGoTFixdj5syZ8PDwyHaZf48ePbB582b06dMH3bt3R1hYGJYtWwZ3d/cck+f8UKlUaNeuHb799lukpqbC2dkZ//77L8LCwgp9bGrWrInPPvsMX3zxBdq2bYu+fftCqVTi1KlTcHJywrx586BSqbB06VIMHz4cTZs2xeDBg7Xv1Z07d6J169Y6X5qKqlGjRvD19cWvv/6KqKgotG/fHv/99x9WrlyJ3r17F8vp+VdZtWoV7ty5g4SEBACaz/Uvv/wSADB8+PA8e5fs7Ozw0UcfYd68eejRowe6deuGc+fOYffu3dopMPLSvXt3/PDDD+jatSveeustREZG4qeffkLNmjVx8eLFIu9bjx49sGrVKlhaWsLd3R1BQUHYv3+/dhLcrEaMGIFFixbh0KFDOlMW6J1Svvqrwrt586bo0qWLsLW1FUqlUtStW1fMmzcv1+n6jxw5Ilq1aiWMjY2FnZ2dGDdunPYy16x27twpzM3NxcOHD7OVzZs3Tzg5OYnKlSuLb7755pVx5jSpoIODg5g5c2a2S1CFEOLXX38Vnp6ewsTERFhYWAgPDw8xbdo0nVgyJvjKydOnT8X48eOFs7OzdsJAX19fncnQUlJSxDfffCPq168vlEqlsLa2Fp6enmL27NkiOjpaWw8vJtLKKqcJuzIm9pLL5YWaVPDcuXOib9++olKlSkKpVApXV1cxcOBAceDAgdwOrU57OU0EJoTmtiItWrQQCoVCVK1aVfzwww95TiqYVdbLyYUQ4rfffhPVq1cXBgYG+ZpUMGtsGds/deqUzvqMS4QzT8AnhGbCtjZt2ggzMzNhZmYm6tatK8aNGyeuX79e6GOzf/9+0bp1a2FiYiJUKpXo2bNnrpMKZo0nL/l5/z169EiMHDlS2NraCoVCITw8PHQu+85MrVYLFxcXAUB8+eWXOZbPnTtXuLq6CqVSKZo0aSJ27NghfH19dS7jz+2y7MxlmWO4f/++6NOnj7CyshKWlpZiwIAB4uHDh9kuj87tGOX0HhNCiOXLl4smTZpo/+7at28v9u3bp1Pn0KFDwtvbW1haWgpjY2NRo0YN4efnJ06fPp3jMXrVPub1OqamporZs2cLNzc3YWRkJFxcXPKcVDCrnD4j8jrWWbVv3z7bZIgZS34uXU9PTxezZ88WlStXLtSkgn/88YeoVauW9n+Iv79/jlNW5PZZmNvfshCaKRAy3ufm5ubC29tbXLt2Lc/Y6tevL+Ryubh///4rY5eKTIhiGo1F5Yqfnx82btxY6G+ZRERUMTRp0gQ2NjY4cOCA1KHkimN2iIiIqFBOnz6N8+fPY8SIEVKHkieO2SEiIqICCQ4OxpkzZ/D999+jcuXK2Qbh6xv27BAREVGBbNy4ESNHjkRqairWrVuX453U9QnH7BAREVG5xp4dIiIiKteY7BAREVG5xgHK0NwW4eHDh7CwsCjVafWJiIio8IQQiI2NhZOTU5735GKyA829o7LeSJKIiIjKhnv37qFKlSq5ljPZAbRTvd+7dw8qlUriaIiIiCg/YmJi4OLiku2WLVkx2cHLO0KrVComO0RERGXMq4agcIAyERERlWtMdoiIiKhcY7JDRERE5ZqkY3aWLl2KpUuX4vbt2wCA+vXrY8aMGfDx8QEAJCUl4cMPP8T69euRnJwMb29v/Pzzz3BwcNC2cffuXYwdOxaHDh2Cubk5fH19MW/ePBgaFu+uqdVqpKSkFGubpD8UCkWely0SEVHZJWmyU6VKFXz99deoVasWhBBYuXIl3nzzTZw7dw7169fHBx98gJ07d2LDhg2wtLTE+PHj0bdvXxw7dgwAkJ6eju7du8PR0RHHjx9HeHg4RowYASMjI8ydO7fY4kxJSUFYWBjUanWxtUn6RS6Xw83NDQqFQupQiIiomOndvbFsbGwwf/589O/fH3Z2dli7di369+8PALh27Rrq1auHoKAgtGzZErt370aPHj3w8OFDbW/PsmXL8PHHH+Px48f5/scVExMDS0tLREdHZ7saSwiBu3fvIjU19ZWTFlHZlDGppJGREapWrcqJJYmIyoi8/n9npjeXnqenp2PDhg2Ij4+Hl5cXzpw5g9TUVHTu3Flbp27duqhatao22QkKCoKHh4fOaS1vb2+MHTsWly9fRpMmTXLcVnJyMpKTk7WPY2Jico0rLS0NCQkJcHJygqmpaTHsKekjOzs7PHz4EGlpaTAyMpI6HCIiKkaSd1NcunQJ5ubmUCqVeO+997Blyxa4u7sjIiICCoUCVlZWOvUdHBwQEREBAIiIiNBJdDLKM8pyM2/ePFhaWmqXvGZPTk9PBwCe3ijnMl7fjNebiIjKD8mTnTp16uD8+fM4efIkxo4dC19fX1y5cqVEtzl9+nRER0drl3v37r3yOTy1Ub7x9SUiKr8kP42lUChQs2ZNAICnpydOnTqFhQsXYtCgQUhJSUFUVJRO786jR4/g6OgIAHB0dMR///2n096jR4+0ZblRKpVQKpXFvCdERESkjyTv2clKrVYjOTkZnp6eMDIywoEDB7Rl169fx927d+Hl5QUA8PLywqVLlxAZGamts2/fPqhUKri7u5d67ERERKR/JO3ZmT59Onx8fFC1alXExsZi7dq1CAgIwN69e2FpaYnRo0djypQpsLGxgUqlwoQJE+Dl5YWWLVsCALp06QJ3d3cMHz4c3377LSIiIvC///0P48aNY88NERERAZA42YmMjMSIESMQHh4OS0tLNGzYEHv37sUbb7wBAFiwYAHkcjn69eunM6lgBgMDA+zYsQNjx46Fl5cXzMzM4Ovrizlz5ki1S0REJSo5PRkKuYLjzIgKQNLTWH/88Qdu376N5ORkREZGYv/+/dpEBwCMjY3x008/4dmzZ4iPj8fmzZuzjcVxdXXFrl27kJCQgMePH+O7774r9tmTy6IOHTpg4sSJmDZtGmxsbODo6IhZs2YBAG7fvg2ZTIbz589r60dFRUEmkyEgIAAAEBAQAJlMhr1796JJkyYwMTFBx44dERkZid27d6NevXpQqVR46623kJCQoLPd8ePHY/z48bC0tIStrS0+//xzZEznNGfOHDRo0CBbvI0bN8bnn39eYseDqDw4++gsWq1thX7b+yHwXiD0bJo0Ir2ld2N29J0QAgkpaZIsBf1gW7lyJczMzHDy5El8++23mDNnDvbt21egNmbNmoUlS5bg+PHjuHfvHgYOHIgff/wRa9euxc6dO/Hvv/9i8eLF2bZraGiI//77DwsXLsQPP/yA33//HQAwatQoXL16FadOndLWP3fuHC5evIiRI0cWKDaiiubn8z8jRZ2CkOchGH9wPHz3+OLMozNSh0Wk99gFUkCJqelwn7FXkm1fmeMNU0X+X7KGDRti5syZAIBatWphyZIlOHDgAGrVqpXvNr788ku0bt0aADB69GhMnz4doaGhqF69OgCgf//+OHToED7++GPtc1xcXLBgwQLIZDLUqVMHly5dwoIFC/D222+jSpUq8Pb2hr+/P5o3bw4A8Pf3R/v27bVtElF2l59cxsmIkzCUGWJgnYHYFLIJ5yLPwW+PH9o4t8GkppNQ16au1GES6SX27JRjDRs21HlcuXJlnSvXCtqGg4MDTE1NdZISBweHbG22bNlSZzyBl5cXQkJCtBP2vf3221i3bh2SkpKQkpKCtWvXYtSoUQWKi6iiWR68HADg4+aD6S2mY2efnRhQewAMZAY4+uAoBmwfgGmB03A35q7EkRLpH/bsFJCJkQGuzPGWbNsFkfW2BzKZDGq1Wnt/r8ynxVJTU1/Zhkwmy7XNgujZsyeUSiW2bNkChUKB1NRU7f3PiCi7uzF3sf/ufgCAXwM/AICDmQNmeM2AX30/LDm/BLvDdmP37d3Yd2cf+tTqg/cavQd7U3sJoybSH0x2CkgmkxXoVJI+srOzAwCEh4dr7x+WebByUZ08eVLn8YkTJ1CrVi0YGGiSNUNDQ/j6+sLf3x8KhQKDBw+GiYlJsW2fqLz588qfUAs12jq3RW3r2jplVVVV8W27bzGqwSgsOrsIRx4cwYYbG7AtdBveqvcWRjcYDUulpUSRE+mHsv1fmwrFxMQELVu2xNdffw03NzdERkbif//7X7G1f/fuXUyZMgXvvvsuzp49i8WLF+P777/XqTNmzBjUq1cPAHDs2LFi2zZRefM08Sm23twKABjZIPdB/HVt6uLnzj/jzKMzWHh2Ic5FnoN/sD82Xt+IkQ1GYmi9oTA14s2MqWLimJ0Kavny5UhLS4OnpycmT56ML7/8stjaHjFiBBITE/Haa69h3LhxmDRpEt555x2dOrVq1UKrVq1Qt25dtGjRoti2TVTerL22FsnpyfCw9UAzh2avrO/p4ImVXVfip04/obZ1bcSmxmLRuUXotrkb1l1bh9T0nE9ZE5VnMsGJGhATEwNLS0tER0dDpVLplCUlJSEsLAxubm4wNjaWKMKyo0OHDmjcuDF+/PHHPOsJIVCrVi28//77mDJlSukElwe+zqSPElIT8MbGNxCTEoMFHRags2vnAj1fLdTYHbYbS84twf24+wAAZ3NnjGs8Dt3cusFAXrBxgET6Jq//35mxZ4dK3ePHj7FkyRJERERwbh2iPGwK2YSYlBi4qlzxusvrBX6+XCZH9+rdsa33Nvyvxf9ga2KLB3EP8OnRT9F/e38E3AvgxIRUIXDMDpU6e3t72Nra4tdff4W1tbXU4RDppVR1Kv688icAwLe+b5F6YYwMjDCo7iD0rNETa6+txfLg5bgZdRMTDk5AI7tGmNR0Epo7Ni+u0In0DpMdKlYZt5vIC79JEr3anrA9iIiPQCXjSuhVo1extGlqZIoxHmMwoPYA+Af7Y83VNbjw+AJG7R2F1s6tManJJNSrVK9YtkWkT3gai4hIzwghtJMIDnMfBqWBsljbt1RaYrLnZOzquwuD6gyCocwQxx4cw8AdAzE1cCruxNwp1u0RSY3JDhGRnjn64ChuRt2EqaEpBtQeUGLbsTO1w/9a/g/bem9DN7dukEGGPbf34M2tb2LW8VmIiI8osW0TlSYmO0REeiajV2dA7QGlMiGgi8oF37T7Bht6bkC7Ku2QLtKxKWQTemzpge9Pf4+opKgSj4GoJDHZISLSIxcfX8TpR6dhKDPEMPdhpbrtOjZ18FOnn7Cy60o0tW+K5PRkrLi8Aj6bffDLhV+QkJpQqvEQFRcmO0REemTF5RUAgG7Vu8HRzFGSGJo6NMWKrivwU6efUMe6DuJS47Dk/BL4bPbBmqtrkJKeIklcRIXFZIeISE/cjr6N/Xc0N/wcWV/aOahkMhnaVWmHv3v+jW/afgMXCxc8S3qGr//7Gr229sK20G1IV6dLGiNRfjHZIb0wa9YsODg4QCaTYevWrfDz80Pv3r2lDouoVK28shICAu2rtEdN65pShwNAMzFht+rd8E/vf/B5y89hZ2KHB3EP8NnRz9B/e38cvHuQ00mQ3mOyU0516NABkydPljqMfLl69Spmz56NX375BeHh4fDx8ZE6JKJS9yTxCbbd3AYAGNVglMTRZGckN8LAOgOxs+9OTG46GRYKC9yMuolJhyZh2O5hOBVxSuoQiXLFZIckk56eDrVajdDQUADAm2++CUdHRyiVxTunCFFZsObqGqSoU9DIrhGa2DeROpxcmRiaYLTHaOzuuxtjPMbAxNAEFx9fxKi9o/Duvndx+ellqUMkyobJTjnk5+eHwMBALFy4EDKZDDKZDLdv30ZwcDB8fHxgbm4OBwcHDB8+HE+ePNE+r0OHDpg4cSKmTZsGGxsbODo6YtasWdpyIQRmzZqFqlWrQqlUwsnJCRMnTtSWP3/+HCNGjIC1tTVMTU3h4+ODkJAQbfmKFStgZWWFbdu2wd3dHUqlEqNGjULPnj0BAHK5HDKZLMd9Sk5OxsSJE2Fvbw9jY2O0adMGp069/CbZrFkzfPfdd9rHvXv3hpGREeLi4gAA9+/fh0wmw82bN4t2cIlKQHxqPP669hcAYGSDkbn+HegTS6UlJjWdhF19d2FwncEwlBni+MPjGLxjMD4M+BBh0WFSh0ikxWSnoIQAUuKlWfJ5XnzhwoXw8vLC22+/jfDwcISHh8PCwgIdO3ZEkyZNcPr0aezZswePHj3CwIEDdZ67cuVKmJmZ4eTJk/j2228xZ84c7Nu3DwCwadMmLFiwAL/88gtCQkKwdetWeHh4aJ/r5+eH06dPY9u2bQgKCoIQAt26dUNqaqq2TkJCAr755hv8/vvvuHz5MhYtWgR/f38A0Maak2nTpmHTpk1YuXIlzp49i5o1a8Lb2xvPnj0DALRv3157qwohBI4cOQIrKyscPXoUABAYGAhnZ2fUrKkf4yCIMtt4YyNiU2NRTVWtUDf8lJKtiS0+a/kZtvXZhh7Ve0AGGf698y/6/NOHExOS3uC9sQoqNQGY6yTNtj99CCjMXlnN0tISCoUCpqamcHTUXLr65ZdfokmTJpg7d6623vLly+Hi4oIbN26gdu3aAICGDRti5syZAIBatWphyZIlOHDgAN544w3cvXsXjo6O6Ny5M4yMjFC1alW89tprAICQkBBs27YNx44dQ6tWrQAAa9asgYuLC7Zu3YoBAzSzwKampuLnn39Go0aNtHFYWVkBgDbWrOLj47F06VKsWLFCO57nt99+w759+/DHH39g6tSp6NChA/744w+kp6cjODgYCoUCgwYNQkBAALp27YqAgAC0b98+34eaqLSkpr+84efIBiMhl5XN76AuFi6Y13YeRjYYicVnFyPgfgA2hWzC9tDtGFJ3CMZ4jIGVsZXUYVIFVTb/qqjALly4gEOHDsHc3Fy71K1bFwC0Y2YATbKTWeXKlREZGQkAGDBgABITE1G9enW8/fbb2LJlC9LS0gBoBhkbGhqiRYsW2udWqlQJderUwdWrV7XrFApFtm28SmhoKFJTU9G6dWvtOiMjI7z22mvattu2bYvY2FicO3cOgYGBaN++PTp06KDt7QkMDESHDh0KtF2i0rArbBciEyJhZ2KHHtV7SB1OkdW2ro3FnRZjlc8qeDp4IkWdgpVXVsJnsw+WXVjGiQlJEuzZKSgjU00Pi1TbLqS4uDj07NkT33zzTbayypUrv9yEkZFOmUwmg1qtBgC4uLjg+vXr2L9/P/bt24f3338f8+fPR2BgYL7jMDExKZHxCFZWVmjUqBECAgIQFBSEN954A+3atcOgQYNw48YNhISEsGeH9I5aqOEfrDmNO8x9GBQGCokjKj6N7RvD39sfxx4ew8KzC3Ht2TX8dP4nrLu2Du80fAcDag8oV/tL+o09OwUlk2lOJUmxFCBJUCgUSE9/OeFX06ZNcfnyZVSrVg01a9bUWczMXn1qLIOJiQl69uyJRYsWaROLS5cuoV69ekhLS8PJkye1dZ8+fYrr16/D3d093+3npEaNGlAoFDh27Jh2XWpqKk6dOqXTdvv27XHo0CEcPnwYHTp0gI2NDerVq4evvvoKlStX1p6qI9IXR+4fQWh0KMyMzEr0hp9SkclkaOPcBn/1+AvftvsWVS2qaicm7LmlJ/65+Q8nJqRSwWSnnKpWrRpOnjyJ27dv48mTJxg3bhyePXuGIUOG4NSpUwgNDcXevXsxcuRInaQoLytWrMAff/yB4OBg3Lp1C6tXr4aJiQlcXV1Rq1YtvPnmm3j77bdx9OhRXLhwAcOGDYOzszPefPPNIu2LmZkZxo4di6lTp2LPnj24cuUK3n77bSQkJGD06NHaeh06dMDevXthaGioPUXXoUMHrFmzhr06pJcybvg5sPZAWCgsJI6m5Mhlcvi4+WBr762Y4TUD9ib2eBj/EP879j/029YPB+4c4MSEVKKY7JRTH330EQwMDODu7g47OzukpKTg2LFjSE9PR5cuXeDh4YHJkyfDysoKcnn+3gZWVlb47bff0Lp1azRs2BD79+/H9u3bUalSJQCAv78/PD090aNHD3h5eUEIgV27dmU7NVYYX3/9Nfr164fhw4ejadOmuHnzJvbu3Qtra2ttnbZt20KtVuskNh06dEB6ejrH65DeOR95Hmcjz8JQXvo3/JSKkdwIA2oPwM6+OzHFcwpUChVCo0MxOWAyhu4aipPhJ1/dCFEhyATTacTExMDS0hLR0dFQqVQ6ZUlJSQgLC4ObmxuMjY0lipBKGl9nKm2TDk7CwXsH0admH8xpPUfqcCQRkxKDFcErsPrqaiSmJQIAvCp7YVLTSahvW1/i6KgsyOv/d2bs2SEiKmW3om/h0L1DAAC/Bn7SBiMhlUKFiU0nYlffXRhSdwgM5YYICg/C4J2DMSVgCm5F35I6RConmOwQEZWylZc1N/x83eV1VLesLnU4krM1scWnLT7F9t7b0bN6T8ggw747+9Dnnz6YeXwmJyakImOyQ0RUiiITIrE9dDsA/bzhp5SqWFTB3LZzsanXJrzu8jrUQo3NIZvRfXN3zD81H8+TnksdIpVRTHaIiErRmqtrkKpORVP7pmhs31jqcPRSLetaWNRxEVb5rEIzh2ZIUafgzyt/wmezD5aeX4r41HipQ6QyhskOEVEpiU2Jxd/X/waguTUE5a2xfWMs916OZZ2XoZ5NPcSnxuPnCz/DZ5MPVl1ZheT0ZKlDpDKCyQ4RUSnZeGMj4lLjUMOyBtpVaSd1OGWCTCZDa+fWWN9jPea3nw9XlSueJz/Ht6e+Rc8tPbElZAvS1GlSh0l6jskOEVEpSElPwaorqwBorsAqqzf8lIpcJkfXal2x5c0tmOk1E/am9giPD8eM4zPQd1tf7L+znxMTUq7410ZEVAp23tqJx4mPYW9ij+5u3aUOp8wykhuhf+3+2NlnJz70/BCWSkuERYfhg4AP8NbOt3Ai/ITUIZIeYrJDRFTC1EIN/8uaG34Odx8OI4Oizype0RkbGsOvgR92992Ndxu+CxNDEwQ/Dcbb/76NMf+OQfCTYKlDJD3CZKcc8/PzQ+/evaUOg6jCC7gXgLDoMFgYWaB/7f5Sh1OuWCgsML7JeOzquwtD6w2FodwQJ8NPYsjOIfjg0Ae4FcWJCYnJTrm2cOFCrFixQuowiCo8/2BNr87AOgNhrjCXOJryydbEFp+89gl29NmBXjV6QS6TY//d/eizrQ8+P/Y5wuPCpQ6RJMRkpxyztLSElZWV1GEQVWjnIs/h/OPzMJIbVZgbfkrJ2dwZX7X5Cpt6bkJHl45QCzW23tyK7lu645v/vsGzpGdSh0gSYLJTjmU+jbVnzx60adMGVlZWqFSpEnr06IHQ0FBt3T///BPm5uYICQnRrnv//fdRt25dJCQklHboROXG8kvLAQC9avSCrYmtxNFUHDWta2Jhx4VY3W01mjs2R6o6FauvrobPJh/8fP5nxKXESR0ilSImOwUkhEBCaoIkS1Euq4yPj8eUKVNw+vRpHDhwAHK5HH369IFarQYAjBgxAt26dcPQoUORlpaGnTt34vfff8eaNWtgampaXIePqEIJjQpFwP0AyCCDX30/qcOpkBrZNcIfXf7AL51/gXsldySkJWDphaXw2eyDPy//yYkJKwhDqQMoaxLTEtFibQtJtn3yrZMwNSpc4tGvXz+dx8uXL4ednR2uXLmCBg0aAAB++eUXNGzYEBMnTsTmzZsxa9YseHp6FjluoopqxeUVAIBOVTuhmmU1SWOpyGQyGVo5t4KXkxf23dmHxecW43bMbcw/PR+rrq7C2EZj0atGLxjK+S+xvGLPTgUREhKCIUOGoHr16lCpVKhWrRoA4O7du9o61tbW+OOPP7B06VLUqFEDn3zyiUTREpV9EfER2HFrBwDeGkJfyGQydKnWBVve3ILZrWbDwdQBEfERmHl8Jvr80wf77uzjxITlFNPYAjIxNMHJt05Ktu3C6tmzJ1xdXfHbb7/ByckJarUaDRo0QEpKik69w4cPw8DAAOHh4YiPj4eFhUVRwyaqkNZcXYM0dRo8HTzR0K6h1OFQJoZyQ/St1Rfdq3fH+mvr8ful33E75jamBExB/Ur1ManpJHg5eUkdJhUjSXt25s2bh+bNm8PCwgL29vbo3bs3rl+/rlOnQ4cOkMlkOst7772nU+fu3bvo3r07TE1NYW9vj6lTpyItrWTulSKTyWBqZCrJIpPJChXz06dPcf36dfzvf/9Dp06dUK9ePTx//jxbvePHj+Obb77B9u3bYW5ujvHjxxf1cBFVSDEpMdhwYwMAYFSDURJHQ7lRGijhW98Xu/vuxnuN3oOpoSkuP72Md/a9gzF7x+DS40tSh0jFRNJkJzAwEOPGjcOJEyewb98+pKamokuXLoiPj9ep9/bbbyM8PFy7fPvtt9qy9PR0dO/eHSkpKTh+/DhWrlyJFStWYMaMGaW9O3rL2toalSpVwq+//oqbN2/i4MGDmDJlik6d2NhYDB8+HBMnToSPjw/WrFmDv/76Cxs3bpQoaqKy6+/rfyM+NR41rWqirXNbqcOhVzBXmGNc43HY1XcXhtUbBiO5EU5GnMRbu97C5EOTERoV+upGSK9Jmuzs2bMHfn5+qF+/Pho1aoQVK1bg7t27OHPmjE49U1NTODo6aheVSqUt+/fff3HlyhWsXr0ajRs3ho+PD7744gv89NNP2U7RVFRyuRzr16/HmTNn0KBBA3zwwQeYP3++Tp1JkybBzMwMc+fOBQB4eHhg7ty5ePfdd/HgwQMpwiYqk5LTk7Hm6hoAmrE6he2RpdJXyaQSPn7tY+zoswNv1ngTcpkcB+4eQN9tffG/o//Dw7iHUodIhaRXA5Sjo6MBADY2Njrr16xZA1tbWzRo0ADTp0/XmfclKCgIHh4ecHBw0K7z9vZGTEwMLl++XDqB66nk5GSYm2tma+3cuTOuXLmCpKQkXLhwAe3bt4cQQjsPz/Lly3Hx4kUolUrt86dMmYKnT5/C2dlZivCJyqTtodvxJPEJHM0c4ePmI3U4VAhO5k74ss2X2NxrMzpV7QS1UOOf0H/QY0sPfP3f13ia+FTqEKmA9GaAslqtxuTJk9G6dWvtpdAA8NZbb8HV1RVOTk64ePEiPv74Y1y/fh2bN28GAEREROgkOgC0jyMiInLcVnJyMpKTX86tEBMTU9y7I6m0tDTcuHEDQUFBePfdd6UOh6jCSFenY+XllQCA4fWGw0jOG36WZTWsauDH13/ExccXsejsIpyMOIk1V9dgc8hmjHAfAd/6vrBQ8CKOskBvkp1x48YhODgYR48e1Vn/zjvvaH/38PBA5cqV0alTJ4SGhqJGjRqF2ta8efMwe/bsIsWrz4KDg9GqVSu8/vrr2QZzE1HJCbgXgNsxt6FSqHjDz3KkoV1D/O79O4IeBmHh2YW4/PQyfrn4C/66/hfGeIzB4LqDoTRQvrohkoxenMYaP348duzYgUOHDqFKlSp51m3RQjOh382bNwEAjo6OePTokU6djMeOjo45tjF9+nRER0drl3v37hV1F/RK48aNkZCQgJ07d8La2lrqcIgqBCEElgdrbg0xqM6gQk8ASvrLy8kL67qvww8dfoCbpRuikqPw3env0H1zd2y6sQlp6pK5CpiKTtJkRwiB8ePHY8uWLTh48CDc3Nxe+Zzz588DACpXrgwA8PLywqVLlxAZGamts2/fPqhUKri7u+fYhlKphEql0lmIiIrizKMzuPjkIhRyBd6q95bU4VAJkclkeMP1DWzutRlzWs2Bo5kjHiU8wqygWejzTx/svb0XaqGWOkzKQtJkZ9y4cVi9ejXWrl0LCwsLREREICIiAomJiQCA0NBQfPHFFzhz5gxu376Nbdu2YcSIEWjXrh0aNtRM0tWlSxe4u7tj+PDhuHDhAvbu3Yv//e9/GDdunM5gWyKikuR/2R8A0Ltmb97wswIwlBuiT60+2NFnB6Y1nwZrpTVux9zGR4EfYcjOITj+4DhnY9YjMiHhq5HbJZn+/v7w8/PDvXv3MGzYMAQHByM+Ph4uLi7o06cP/ve//+n0xty5cwdjx45FQEAAzMzM4Ovri6+//hqGhvkbkhQTEwNLS0tER0dn6+VJSkpCWFgY3NzcYGxsXPidJb3G15mKIuR5CPpu6wsZZNjRZweqqqpKHRKVsriUOKy6sgorLq9AQprmiuHmjs0xqekkNLJrJHF05Vde/78zkzTZ0RdMdoivMxXFZ0c/w7bQbXjD9Q380OEHqcMhCT1LeobfL/2O9dfWI1WdCgB43eV1TGwyETWta0ocXfmT32RHLwYoExGVVeFx4dh1axcA3hqCABtjG0xrPg07++xEn5p9IJfJcejeIfTd1hefHf0MD+I4SasUmOwQERXBqqurkCbS8Jrja2hg2+DVT6AKobJ5ZcxpPQdbem3BG65vQEBgW+g29NjSA/NOzsOTxCdSh1ihMNkhIiqk6ORobLyhuX/cyAYjJY6G9FF1q+r4ocMPWNd9HVpWbok0dRrWXluLbpu7YfG5xYhNiZU6xAqByQ4RUSH9df0vJKYlorZ1bbR2ai11OKTHGtg2wG9dfsNvXX5Dg0oNkJiWiF8v/gqfzT5YEbwCSWlJUodYrjHZISIqhKS0JN7wkwqsZeWWWNt9LX7s8COqW1ZHdHI0vj/zPbpv6Y6NNzZyYsISwmSnHFOr1fj2229Rs2ZNKJVKVK1aFV999RUCAgIgk8kQFRWlrXv+/HnIZDLcvn0bALBixQpYWVlh69atqFWrFoyNjeHt7a2dbfr27duQy+U4ffq0zjZ//PFHuLq6Qq3mpFpUvm0L3YZnSc9Q2awyvKt5Sx0OlSEymQydXDthc6/N+KL1F6hsVhmRCZGYHTQbvf/pjT2393BiwmKmN/fGKiuEEBAvJj0sbTITkwJ9e5w+fTp+++03LFiwAG3atEF4eDiuXbuW7+cnJCTgq6++wp9//gmFQoH3338fgwcPxrFjx1CtWjV07twZ/v7+aNasmfY5GXMkyeXMo6n8ynzDT9/6vrzhJxWKgdwAvWv2Rje3bvj7+t/49eKvuBNzB1MDp2K5zXJMbDoRrZ1as9ewGDDZKSCRmIjrTT0l2Xads2cgM83f/XZiY2OxcOFCLFmyBL6+vgCAGjVqoE2bNggICMhXG6mpqViyZIn2fmQrV65EvXr18N9//+G1117DmDFj8N577+GHH36AUqnE2bNncenSJfzzzz+F2j+isuLA3QO4G3sXlkpL9KnZR+pwqIxTGCgwzH0Y+tTqgz+v/ImVl1fi6rOrGLt/LJo5NMOkppPQ2L6x1GGWafz6XU5dvXoVycnJ6NSpU6HbMDQ0RPPmzbWP69atCysrK1y9ehUA0Lt3bxgYGGDLli0ANKe+Xn/9dVSrVq1IsRPpMyEE/IM1t4YYUncIb/hJxcbMyAxjG43F7r67McJ9BBRyBU4/Oo3hu4djwsEJCHkeInWIZRZ7dgpIZmKCOmfPSLbt/DLJo27GKabMk2enpqYWOB6FQoERI0bA398fffv2xdq1a7Fw4cICt0NUlpyKOIXgp8FQGigxpO4QqcOhcsja2BpTm0/FcPfhWHphKbbe3IqAewEIvBeIHtV74P3G76OKRRWpwyxT2LNTQDKZDHJTU0mWgpy3rVWrFkxMTHDgwIFsZXZ2dgCA8PBw7bqMu8lnlpaWpjMA+fr164iKikK9evW068aMGYP9+/fj559/RlpaGvr27ZvvGInKouWXlwPQ3PDTxthG4mioPHM0c8TsVrOx5c2XExNuv7UdPbf2xNyTczkxYQEw2SmnjI2N8fHHH2PatGn4888/ERoaihMnTuCPP/5AzZo14eLiglmzZiEkJAQ7d+7E999/n60NIyMjTJgwASdPnsSZM2fg5+eHli1b4rXXXtPWqVevHlq2bImPP/4YQ4YMybNHiaisu/7sOo49OAa5TA7f+r5Sh0MVRHVLzcSE63usRyunVkhTp2HdtXXotrkbFp1dhJiUGKlD1HtMdsqxzz//HB9++CFmzJiBevXqYdCgQYiMjISRkRHWrVuHa9euoWHDhvjmm2/w5ZdfZnu+qakpPv74Y7z11lto3bo1zM3N8ddff2WrN3r0aKSkpGDUKN4XiMo3/8uasTpdXLvAxcJF4miooqlfqT5+eeMX/NHlDzS0bYjEtET8duk3+GzywfLg5UhMk+ZK4bKAdz0H73qekxUrVmDy5Mk6c/Hk5osvvsCGDRtw8eLFkg+shFTU15ny72HcQ3Tb3A3pIh1/9fgL7pXcpQ6JKjAhBA7eO4jFZxcjNDoUAGBvYo93G72LPrX6VJjpEHjXcypxcXFxCA4OxpIlSzBhwgSpwyEqUX9e+RPpIh0tK7dkokOSk8lk6FS1Ezb12oQvW38JJzMnRCZG4osTX6D31t7YHbabExNmwmSHCm38+PHw9PREhw4deAqLyrWopChsDtkMgDf8JP1iIDfAmzXfxPY+2/HJa5/AxtgGd2PvYtrhaRi0YxCO3D8CnsDhaSwAPI1FfJ0pb8suLMNP539CPZt6+KvHX5zRlvRWfGo8Vl1ZhZWXVyIuNQ4A0NS+KSZ7TkYT+yYSR1f8eBqLiKgYJKYlYu3VtQB4w0/Sf2ZGZniv0XvY3Xc3/Or7QSFX4GzkWYzYPQLjD4zH9WfXpQ5REkx28okdYOUbX1/KzT83/8Hz5OdwNnfGG65vSB0OUb5YGVvhw2YfYmffnehXqx8MZAYIvB+IAdsH4JMjn+Be7D2pQyxVTHZewcDAAACQkpIicSRUkjJe34zXmwgA0tRpOjf8NJRz0nkqWxzNHDGr1SxsfXMrvKt5Q0Bg562d6LWlF7488SUeJzyWOsRSwTE7yPucnxACd+/eRWpqKpycnHg373JIrVbj4cOHMDIyQtWqVXmagrT2hO3B1MNTYaW0wr/9/4WJISfNpLLtytMrWHR2EY49PAYAMDE0wdB6QzGywUioFLmPedFX+R2zw2QHrz5YKSkpCAsLg1rNy/jKK7lcDjc3NygUCqlDIT0hhMCgHYNw9dlVvN/ofYxtPFbqkIiKzamIU/jx7I+4+FgzP5qFwgKjG4zGW/XeKlNJPZOdAsjPwVKr1TyVVY4pFAr22pGOE+En8Pa/b8PE0AT/9vsXVsZWUodEVKyEEAi4F4BF5xbhZtRNAICdiR3ea/RemZmYkMlOAeT3YBFRxfHOv+8gKDwIb9V9C9NbTJc6HKISk65Ox66wXfjp/E94EPcAAOBi4YJxjcfBx80Hcpn+fhHkpedERIV09elVBIUHwUBmgBH1R0gdDlGJMpAboGeNntjWexumvzYdNsY2uBd7D58c+QQDtw/E4fuHy/wVq0x2iIiy8A/W3PDTu5o3nM2dJY6GqHQoDBR4q95b2N13NyY0mQBzI3Ncf34d4w6Mg98eP5x9dFbqEAuNyQ4RUSb3Y+9j7529AHhrCKqYTI1M8U7Dd7C7726MrD8SSgMlzkaehe8eX4w7MK5MTkzIZIeIKJM/r/wJtVCjlVMr1LWpK3U4RJKxMrbClGZTsLPPTvSv3R8GMgMcvn8YA7YPwMeHP8a9mLIzMSGTHSKiF54lPcOWkC0AgFENeHNbIgBwMHPATK+Z+Kf3P/Cp5gMBgV1hu9Bra9mZmJDJDhHRC+uvrUdSehLcK7njNcfXpA6HSK+4qlzxbftv8XePv9HGuQ3SRBr+uv4Xum3uhgVnFiA6OVrqEHPFZIeICEBCagLWXVsHQNOrw5m0iXJWr1I9LO28FP7e/mhs1xhJ6UlYHrwcPpt98Pul35GQmiB1iNkw2SEiArDl5hZEJUehinkVdK7aWepwiPReM8dm+NPnTyzuuBg1rWoiNiUWC88uRPct3bH+2nqkpqdKHaIWkx0iqvDS1Gn48/KfAAC/+n4wkPOGsET5IZPJ0MGlAzb23Ii5bebC2dwZTxKf4KuTX6HX1l7YcWsH1EL6Wy0x2SGiCu/f2//iYfxD2Bjb4M2ab0odDlGZkzEx4fbe2/Fpi09RybgS7sfdx/Qj0zFg+wAE3guUdGJCJjtEVKEJIbA8eDkA4K26b8HY0FjiiIjKLiMDIwypOwS7+u7CpKaTYGFkgRvPb2D8wfE4dO+QZHEx2SGiCi3oYRCuP78OE0MTDK47WOpwiMoFUyNTjPEYg939dmNUg1Fwr+SOdlXaSRaPoWRbJiLSAxm9Ov1q9YOl0lLiaIjKF0ulJT7w/ADp6nRJx8KxZ4eIKqzLTy7jZMRJzQ0/3XnDT6KSIvWgfyY7RFRh+V/W3PDTx80Hlc0rSxwNEZUUJjtEVCHdi7mHfXf2AeANP4nKOyY7RFQhrbyyEmqhRhvnNqhtXVvqcIioBDHZIaIK52niU2y9uRUAb/hJVBEw2SGiCmfttbVITk+Gh60Hmjk0kzocIiphTHaIqEJJSE3A+mvrAWjG6vCGn0TlH5MdIqpQNodsRkxKDFxVrujo0lHqcIioFDDZIaIKI1Wdij+vaG746VvfV/K5P4iodDDZIaIKY0/YHoTHh6OScSX0qtFL6nCIqJRImuzMmzcPzZs3h4WFBezt7dG7d29cv35dp05SUhLGjRuHSpUqwdzcHP369cOjR4906ty9exfdu3eHqakp7O3tMXXqVKSlpZXmrhCRnhNCaCcRHOY+DEoDpcQREVFpkTTZCQwMxLhx43DixAns27cPqamp6NKlC+Lj47V1PvjgA2zfvh0bNmxAYGAgHj58iL59+2rL09PT0b17d6SkpOD48eNYuXIlVqxYgRkzZkixS0Skp44+OIqQ5yEwNTTFgNoDpA6HiEqRTAghpA4iw+PHj2Fvb4/AwEC0a9cO0dHRsLOzw9q1a9G/f38AwLVr11CvXj0EBQWhZcuW2L17N3r06IGHDx/CwcEBALBs2TJ8/PHHePz4MRQKxSu3GxMTA0tLS0RHR0OlUpXoPhKRNEbtHYVTEacwwn0EpjafKnU4RFQM8vv/W6/G7ERHRwMAbGxsAABnzpxBamoqOnfurK1Tt25dVK1aFUFBQQCAoKAgeHh4aBMdAPD29kZMTAwuX76c43aSk5MRExOjsxBR+XXp8SWcijgFQ5khhrsPlzocIiplepPsqNVqTJ48Ga1bt0aDBg0AABEREVAoFLCystKp6+DggIiICG2dzIlORnlGWU7mzZsHS0tL7eLi4lLMe0NE+iRjrE636t3gaOYocTREVNr0JtkZN24cgoODsX79+hLf1vTp0xEdHa1d7t27V+LbJCJp3Im5g/139gMARtbnDT+JKiJDqQMAgPHjx2PHjh04fPgwqlSpol3v6OiIlJQUREVF6fTuPHr0CI6Ojto6//33n057GVdrZdTJSqlUQqnklRhEFcGKyysgINC+SnvUtK4pdThEJAFJe3aEEBg/fjy2bNmCgwcPws3NTafc09MTRkZGOHDggHbd9evXcffuXXh5eQEAvLy8cOnSJURGRmrr7Nu3DyqVCu7u7qWzI0Skl54kPsG2m9sAaG4NQUQVk6Q9O+PGjcPatWvxzz//wMLCQjvGxtLSEiYmJrC0tMTo0aMxZcoU2NjYQKVSYcKECfDy8kLLli0BAF26dIG7uzuGDx+Ob7/9FhEREfjf//6HcePGsfeGqIJbe3UtUtQpaGTXCE3tm0odDhFJRNJkZ+nSpQCADh066Kz39/eHn58fAGDBggWQy+Xo168fkpOT4e3tjZ9//llb18DAADt27MDYsWPh5eUFMzMz+Pr6Ys6cOaW1G0Skh+JT47H+Om/4SUR6Ns+OVDjPDlH5s/LySnx3+jtUU1XDP73/gVymN9djEFExKZPz7BARFYfU9FSsurIKgKZXh4kOUcXGTwAiKnd2he3Co4RHsDWxRY/qPaQOh4gkxmSHiMoVtVBjxeUVAIBh9YZBYfDqW8YQUfnGZIeIypUj94/gZtRNmBmZYWCdgVKHQ0R6gMkOEZUry4OXAwAG1h4IC4WFxNEQkT5gskNE5cb5yPM4G3kWhnJDDK03VOpwiEhPMNkhonLDP1hzw8+e1XvCwczhFbWJqKJgskNE5cKt6Fs4dO8QAMCvvp+0wRCRXinUDMphYWE4cuQI7ty5g4SEBNjZ2aFJkybw8vKCsbFxccdIRPRKf17+EwICr7u8jupW1aUOh4j0SIGSnTVr1mDhwoU4ffo0HBwc4OTkBBMTEzx79gyhoaEwNjbG0KFD8fHHH8PV1bWkYiYi0vE44TG2hWpu+DmqwSiJoyEifZPvZKdJkyZQKBTw8/PDpk2b4OLiolOenJyMoKAgrF+/Hs2aNcPPP/+MAQMGFHvARERZrb66GqnqVDSxb4LG9o2lDoeI9Ey+7421d+9eeHt756vRp0+f4vbt2/D09CxScKWF98YiKrviUuLwxsY3EJcah8UdF6ODSwepQyKiUpLf/9/57tnJb6IDAJUqVUKlSpXyXZ+IqLA23NiAuNQ4VLesjnZV2kkdDhHpoUJdjXX27FlcunRJ+/iff/5B79698emnnyIlJaXYgiMiyktKegpWX1kNQHMFFm/4SUQ5KdQnw7vvvosbN24AAG7duoXBgwfD1NQUGzZswLRp04o1QCKi3Oy8tRORiZGwN7HnDT+JKFeFSnZu3LiBxo0bAwA2bNiAdu3aYe3atVixYgU2bdpUnPEREeVILdTwv6yZRHC4+3AYGRhJHBER6atCJTtCCKjVagDA/v370a1bNwCAi4sLnjx5UnzRERHlIvBeIMKiw2BhZIH+tftLHQ4R6bFCJTvNmjXDl19+iVWrViEwMBDdu3cHoJls0MGBU7QTUcnT3vCzzkCYK8wljoaI9Fmhkp0ff/wRZ8+exfjx4/HZZ5+hZs2aAICNGzeiVatWxRogEVFW5yLP4fzj8zCSG/GGn0T0SoW6XUTDhg11rsbKMH/+fBgYGBQ5KCKivGT06vSq0Qt2pnYSR0NE+q5QyU5mcXFx2vE7GYyMOFCQiEpGaFQoAu4FQAYZfOv7Sh0OEZUBhTqNFRYWhu7du8PMzAyWlpawtraGtbU1rKysYG1tXdwxEhFprbi8AgDQsWpHuFm6SRsMEZUJherZGTZsGIQQWL58ORwcHCCTyYo7LiKibB7FP8KOWzsA8IafRJR/hUp2Lly4gDNnzqBOnTrFHQ8RUa5WX12NNHUaPB080dCuodThEFEZUajTWM2bN8e9e/eKOxYiolzFpMRgw40NANirQ0QFU6iend9//x3vvfceHjx4gAYNGmQbkNywIb9xEVHx+vv634hPjUdNq5po69xW6nCIqAwpVLLz+PFjhIaGYuTIkdp1MpkMQgjIZDKkp6cXW4BERMnpyVhzdQ0AYGSDkRwnSEQFUqhkZ9SoUWjSpAnWrVvHAcpEVOJ2hO7Ak8QncDB1gE81H6nDIaIyplDJzp07d7Bt2zbtzMmUs4B7Abgfex9v1XsLclmhhkcRVXjp6nTt5eYj3Efwhp9EVGCF+g/csWNHXLhwobhjKVdiUmIw6/gsfHPqG4zcMxJ3Y+5KHRJRmRRwLwC3Y27DQmGBfrX7SR0OEZVBherZ6dmzJz744ANcunQJHh4e2QYo9+rVq1iCK8vMjcwxttFYfH/me5yNPIt+2/phUtNJ7OUhKgAhhPbWEIPrDIaZkZnEERFRWSQTQoiCPkkuz/2fdVkcoBwTEwNLS0tER0dDpVIVa9sP4h5g5rGZOBlxEgDQ1L4pvmj9BaqqqhbrdojKo9MRpzFy70go5Ars7b8Xtia2UodERHokv/+/C9XFoFarc13KWqJT0pzNnfFrl1/xecvPYWpoqu3lWX1lNdRC/eoGiCow/8v+AIA3a77JRIeICo3nU0qBXCbHwDoDsfnNzWjh2AJJ6Ukcy0P0CiHPQ3D4/mHIIINffT+pwyGiMizfyc769evz3ei9e/dw7NixQgVUnjmbO+O3Lr+xl4coFwmpCTh49yBmHZ+Fd/a9AwDo7NqZp32JqEjyPWanffv2iIyMxMiRI9GzZ0/Uq1dPpzw6OhrHjh3D6tWrsW/fPvzxxx9lZqBySY7ZyU1OY3nmtJ4DV5VrqWyfSB8IIXAn5g4O3z+MIw+O4MyjM0hVp2rLbYxt8EeXP1DTmtNcEFF2+f3/XaABytu2bcPixYtx8OBBmJmZwcHBAcbGxnj+/DkiIiJga2sLPz8/fPDBB3BwcCiWHSkNUiQ7gOaDfsONDfj+9PdISEuAsYExJjadiKH1hvKKLSq3ktOTcTritDbBuRere5+9KuZV0K5KO7Sr0g7NHJtBaaCUKFIi0nclkuxkePLkCY4ePYo7d+4gMTERtra2aNKkCZo0aZLnlVr6SqpkJ8ODuAeYeXwmToazl4fKp4dxD3Hk/hEceXAEJ8NPIik9SVtmKDdEM4dmaOvcFu2qtIOrypWzshNRvpRoslPeSJ3sAOzlofIlVZ2K85HntQnOzaibOuX2pvba5KZF5RacP4eICoXJTgHoQ7KTgb08VFY9SXyiTW6CHgYhLjVOWyaXydHYrjHaVmmLts5tUdu6NntviKjImOwUgD4lO0DuvTxv1X0LBnIDqcMjAqC5Z1Xw02BtgnPl6RWdcmulNdo4t0G7Ku3g5eQFS6WlRJESUXnFZKcA9C3ZyfAw7iFmHp+JE+EnAABN7Jvgi9ZfsJeHJBOdHI1jD47hyIMjOPbgGJ4nP9cpr1+pPtpWaYt2zu1Q37Y+T8ESUYlislMA+prsANl7eZQGSkxsohnLw14eKmlCCNx4fkN75dSFxxd05oSyMLKAl5MX2lVph9bOrTnLMRGVqlJJdlJSUhAWFoYaNWrA0LBQ9xTVC/qc7GRgLw+VlvjUeJwIP6E5PXX/CCITI3XKa1rVRLsq7dDWuS0a2TeCkdwol5aIiEpWiSY7CQkJmDBhAlauXAkAuHHjBqpXr44JEybA2dkZn3zySeEjl0BZSHYAzbfsjSEb8d2p79jLQ8VGCIHbMbd1JvZLU6dpy00MTdDCsYV2cHFl88oSRktE9FKJJjuTJk3CsWPH8OOPP6Jr1664ePEiqlevjn/++QezZs3CuXPnihR8aSsryU6GnHp55rSag2qW1aQNjMqMpLQknIo4hSMPNL039+Pu65RXtaiq7b3xdPTkxH5EpJdK9K7nW7duxZIlS9CmTRudy0fr16+P0NDQfLdz+PBh9OzZE05OTpDJZNi6datOuZ+fH2Qymc7StWtXnTrPnj3D0KFDoVKpYGVlhdGjRyMuLg7lmZO5E35941fM8JoBU0NTnIs8h/7b++PPy38iXc27zlPOHsQ9wPpr6zHuwDi0Xd8W7x94H+uurcP9uPswkhvBq7IXPm7+MXb02YGdfXfi49c+RivnVkx0iKjMK9RAm8ePH8Pe3j7b+vj4+ALNnREfH49GjRph1KhR6Nu3b451unbtCn9/f+1jpVL3g3fo0KEIDw/Hvn37kJqaipEjR+Kdd97B2rVr8x1HWSSTyTCg9gC0dmqt7eWZf3o+9t/dz14eAqCZ2O/co3Pa3pvQaN0vIg6mDtremxaVW8DUyFSiSImISlahkp1mzZph586dmDBhAgBoE5zff/8dXl5e+W7Hx8cHPj4+edZRKpVwdHTMsezq1avYs2cPTp06hWbNmgEAFi9ejG7duuG7776Dk5NTvmMpqzJ6eTLG8mT08nAsT8X0OOExjj44muPEfgYyAzSya6RJcKq0RS2rWpzYj4gqhEIlO3PnzoWPjw+uXLmCtLQ0LFy4EFeuXMHx48cRGBhYrAEGBATA3t4e1tbW6NixI7788ktUqlQJABAUFAQrKyttogMAnTt3hlwux8mTJ9GnT58c20xOTkZycrL2cUxMTLHGXNoy9/LMOj4LQeFB7OWpIDIm9jt8/zCO3D+Cq8+u6pTbGNugjXMbtK3SFl6VObEfEVVMhUp22rRpg/Pnz+Prr7+Gh4cH/v33XzRt2hRBQUHw8PAotuC6du2Kvn37ws3NDaGhofj000/h4+ODoKAgGBgYICIiItvpNENDQ9jY2CAiIiLXdufNm4fZs2cXW5z6wsncCb+88Qs2hWzCd6df9vJMaDIBw+oNYy9PORGVFIXjD4/j8IPDOPbgGKKSo3TKG1RqoO29ca/kzon9iKjCK/TkODVq1MBvv/1WnLFkM3jwYO3vHh4eaNiwIWrUqIGAgAB06tSp0O1Onz4dU6ZM0T6OiYmBi4tLkWLVFzKZDP1r99eO5QkKD8J3p7/D/jv78UXrL9jLUwYJIXD9+XVt783FJxezTezXyrkV2lVph1ZOrTixHxFRFkWaCTAyMhKRkZFQq9U66xs2bFikoHJTvXp12Nra4ubNm+jUqRMcHR0RGak74VlaWhqePXuW6zgfQDMOKOtA5/KmsnllnV6e84/Ps5enDIlPjceJhydw+MFhHL1/NNvEfrWsa6Gds6b3ppFdIxjKy+6knkREJa1Qn5BnzpyBr68vrl69iqzT9MhkMqSnl8zlz/fv38fTp09RubJmUjMvLy9ERUXhzJkz8PT0BAAcPHgQarUaLVq0KJEYyhL28pQdQgiExYRpZy0+E5l9Yr+WlVtqJ/ZzNMs9mSciIl2FmlSwUaNGqFGjBj7++GM4ODhku6LD1TV/tzCIi4vDzZs3AQBNmjTBDz/8gNdffx02NjawsbHB7Nmz0a9fPzg6OiI0NBTTpk1DbGwsLl26pO2Z8fHxwaNHj7Bs2TLtpefNmjUr0KXnZW1SwcIQQmh7eeJT46E0ULKXR2Kp6ak49egUDt8/jMB7gdkm9nNVuaKtc1u0rdIWzRyaQWGgkChSIiL9VKIzKFtYWODcuXOoWbNmkYIMCAjA66+/nm29r68vli5dit69e+PcuXOIioqCk5MTunTpgi+++AIODg7aus+ePcP48eOxfft2yOVy9OvXD4sWLYK5uXm+46gIyU6G8LhwbS8PADS2a4w5refAzdJN4sgqhmdJz3Dk/hEE3g/E8YfHEZ8ary0zkhuhuWNztKvSDm2c2/C+Z0REr1CiyU7v3r0xfPhw9OvXr0hB6ouKlOwA7OUpTUIIhESF4PD9wwi4F4CLjy9C4OWfnK2JLdpVaYf2VdqjZeWWnNiPiKgASjTZefLkCXx9ffHaa6+hQYMGMDLSvetxr169Ch6xhCpaspMhPC4cs4Jm4fjD4wDYy1NcUtJTcCriFALuBeDw/cN4GP9Qp7yeTT20d2mP9lXa89JwIqIiKNFkZ/v27Rg+fHiOk/GV5ADlklJRkx1A0/OwOWQz5p+ez16eIniS+ETn9FRiWqK2TGmgRIvKLdC+Snu0q9KOg4uJiIpJiSY71apVQ48ePfD555/rjJ8pqypyspOBvTwFI4TAjec3tL03l55c0jk9ZW9ij3YumtNTLSq3gImhiXTBEhGVUyU+QPn8+fOoUaNGkYLUF0x2NNjLk7fk9GT8F/4fAu8HIvB+ICLidWfprl+pPtpXaY/2Lu1Rz6Ye7ztFRFTCSjTZ8fX1Rdu2bTFmzJgiBakvmOzoCo8Lx+yg2Tj28BgAoJFdI3zR+osK2cvzOOGx5tLw+4E4EX5C5/SUsYExWjq11J6esje1z6MlIiIqbiWa7Hz11Vf48ccf0b17d3h4eGQboDxx4sSCRywhJjvZCSGw5eYWzD81H3GpcRWml0cIgavPrmp6b+4F4vLTyzrlDqYO2t6b1xxfg7GhsUSREhFRiSY7bm65f8OXyWS4detWQZuUFJOd3EXER2DW8VnlupcnKS0JJ8NPak9PRSbo3prBw9YD7aq0QweXDqhjXYenp4iI9ESJJjvlDZOdvOXUyzO+8XgMdx9eZnt5IhMiEXg/EIfvHcaJ8BNISk/SlpkYmsCrshc6uHRA2ypteWNNIiI9xWSnAJjs5E/WXp6Gdg3xResvUN2yusSRvZpaqHH1qeb0VMC9AFx9dlWn3NHMEe2rtEcHlw5o7tgcSoPyfaNYIqLyoNiTnSlTpuCLL76AmZkZpkyZkmfdH374oWDRSozJTv5l7eVRyBWY0GSCXvbyJKYl4sTDE5oenPuH8TjxsbZMBhk87Dw042+qtEdt69o8PUVEVMbk9/93vu96fu7cOaSmpmp/p4pJJpOhb62+aOXUStvL8/2Z77Hv7j696OWJiI/Q3prhv4j/kJyerC0zNTRFK6dWaO/SHm2c2/D0FBFRBcHTWGDPTmHpQy+PWqhx+cllBNzXTO537dk1nXInMye0d2mPDlU6oJkj7xxORFSelOiYnVGjRmHhwoWwsLDQWR8fH48JEyZg+fLlBY9YQkx2iqa0x/IkpCYgKDwIgfc0p6eeJj3VlskgQyO7Rtp7T9W0qsnTU0RE5VSJJjsGBgYIDw+Hvb3uJGpPnjyBo6Mj0tLSCh6xhJjsFJ0QAltvbsW3p77V9vKMbzIeI9xHFEsvz8O4h9pLw0+Fn0KKOkVbZmZkhlZOrdDBpQPaOLeBjbFNkbdHRET6r9jH7GQ0KoSAEAKxsbEwNn45oVp6ejp27dqVLQGiikEmk6FPrT7wcvLCrKBZOPbgGH448wP2391fqF6edHU6gp8GI/BeIALuByDkeYhOeRXzKujg0gHtqrRDM4dmMDIwyqUlIiKq6ArUsyOXy/M8JSCTyTB79mx89tlnxRJcaWHPTvEqbC9PfGo8jj88jsB7gTjy4AieJT3TlsllcjS2a6wdf+Nm6cbTU0REFVyJnMYKDAyEEAIdO3bEpk2bYGPz8nSBQqGAq6srnJyciha5BJjslIyI+AhtLw+Q81ieB3EPEHAvAIH3AnHq0SmkqV+eArUwskBr59ZoV6Ud2jq3hZWxVSnvARER6bMSHbNz584duLi4QC6XFylIfcFkp+Tk1MszpuEYJKclI/B+IG5G3dSpX9WiqnZwcVOHpjCS8/QUERHlrMRnUI6KisJ///2HyMhIqNVqnbIRI0YUpknJMNkpeVl7eTIYyAzQxL6J9uaa1VTVeHqKiIjypUSTne3bt2Po0KGIi4uDSqXS+eckk8nw7NmzPJ6tf5jslI6MXp6NNzbC2cIZ7atoJvezVFpKHRoREZVBJZrs1K5dG926dcPcuXNhampapED1AZMdIiKisie//78LNejmwYMHmDhxYrlIdIiIiKh8K1Sy4+3tjdOnTxd3LERERETFrkCTCmbo3r07pk6diitXrsDDwwNGRrpXzPTq1atYgiMiIiIqqkKN2cnrknOZTIb09PQiBVXaOGaHiIio7CmR20VkyHqpOREREZG+Kh+zAhIRERHlolA9O3PmzMmzfMaMGYUKhoiIiKi4FSrZ2bJli87j1NRUhIWFwdDQEDVq1GCyQ0RERHqjUMnOuXPnsq2LiYmBn58f+vTpU+SgiIiIiIpLsY3ZUalUmD17Nj7//PPiapKIiIioyIp1gHJ0dDSio6OLs0kiIiKiIinUaaxFixbpPBZCIDw8HKtWrYKPj0+xBEZERERUHAqV7CxYsEDnsVwuh52dHXx9fTF9+vRiCYyIiIioOBQq2QkLC8u1LDExsdDBEBERERW3Yhuzk5ycjB9++AFubm7F1SQRERFRkRUo2UlOTsb06dPRrFkztGrVClu3bgUALF++HG5ubliwYAE++OCDkoiTiIiIqFAKdBprxowZ+OWXX9C5c2ccP34cAwYMwMiRI3HixAn88MMPGDBgAAwMDEoqViIiIqICK1Cys2HDBvz555/o1asXgoOD0bBhQ6SlpeHChQuQyWQlFSMRERFRoRXoNNb9+/fh6ekJAGjQoAGUSiU++OADJjpERESktwqU7KSnp0OhUGgfGxoawtzcvNiDIiIiIiouBTqNJYSAn58flEolACApKQnvvfcezMzMdOpt3ry5+CIkIiIiKoICJTu+vr46j4cNG1aswRAREREVtwIlO/7+/iUVBxEREVGJKNYbgRIRERHpGyY7REREVK5JmuwcPnwYPXv2hJOTE2QymXZG5gxCCMyYMQOVK1eGiYkJOnfujJCQEJ06z549w9ChQ6FSqWBlZYXRo0cjLi6uFPeCiIiI9JmkyU58fDwaNWqEn376Kcfyb7/9FosWLcKyZctw8uRJmJmZwdvbG0lJSdo6Q4cOxeXLl7Fv3z7s2LEDhw8fxjvvvFNau0BERER6TiaEEFIHAQAymQxbtmxB7969AWh6dZycnPDhhx/io48+AgBER0fDwcEBK1aswODBg3H16lW4u7vj1KlTaNasGQBgz5496NatG+7fvw8nJ6d8bTsmJgaWlpaIjo6GSqUqkf0jIiKi4pXf/996O2YnLCwMERER6Ny5s3adpaUlWrRogaCgIABAUFAQrKystIkOAHTu3BlyuRwnT57Mte3k5GTExMToLERERFQ+6W2yExERAQBwcHDQWe/g4KAti4iIgL29vU65oaEhbGxstHVyMm/ePFhaWmoXFxeXYo6eiIiI9IXeJjslafr06YiOjtYu9+7dkzokIiIiKiF6m+w4OjoCAB49eqSz/tGjR9oyR0dHREZG6pSnpaXh2bNn2jo5USqVUKlUOgsRERGVT3qb7Li5ucHR0REHDhzQrouJicHJkyfh5eUFAPDy8kJUVBTOnDmjrXPw4EGo1Wq0aNGi1GMmIiIi/VOg20UUt7i4ONy8eVP7OCwsDOfPn4eNjQ2qVq2KyZMn48svv0StWrXg5uaGzz//HE5OTtorturVq4euXbvi7bffxrJly5Camorx48dj8ODB+b4Si4iIiMo3SZOd06dP4/XXX9c+njJlCgDNDUdXrFiBadOmIT4+Hu+88w6ioqLQpk0b7NmzB8bGxtrnrFmzBuPHj0enTp0gl8vRr18/LFq0qNT3hYiIiPST3syzIyXOs0NERFT2lPl5doiIiIiKA5MdIiIiKteY7BAREVG5xmSHiIiIyjUmO0RERFSuMdkhIiKico3JDhEREZVrTHaIiIioXGOyQ0REROUakx0iIiIq15jsEBERUbnGZIeIiIjKNSY7REREVK4ZSh0AERHlU0o8cPMAoE4DjFWA0hJQWrz43QJQmAMymdRREukdJjtERPouIhg44w9c/BtIjsm9nkyuSXqUqhdLRiKk0k2KlJaZfs9c9iJ5MlSU3r4RlQImO0RE+ig1Ebi8FTi9HLj/38v11tUAlTOQFKNJfJJjNL+LdECogaRozVIUhsYvEyGdpEiVQ/Kkyl7PWAUYmQFyjpQg/cBkh4hInzy+oenFOb8WSIrSrJMbAnW7A54jAbf22ZMIITTJUXIMkBz7IhGKzvR77MukKCNB0pZl+j01XtNeWpJmiX9chB2RvaJ3SaWbLGWrl9HLpCxCDEQaTHaIiKSWlgxc3Q6c9gfuHH253rIq4OkLNBkOWDjk/nyZDFCYahYLx8LHkZ4GpGRJkF6ZPMVmKYvRjCmCeLE+GsjjzNsrGShzOOVmWbDkSWHOXqYKjskOEZFUnoYCZ1YA59cACU8162RyoHZXoNkooEZHQG5QevEYGAIm1pqlsITQ9AplToRyTJ5isvQ2ZUmkUuI07aUna3qYitzLZJHzqbnM45hy7IXKdJqOvUxlFpMdIqLSlJ4KXNupOVV1K+DlegsnoOkIzWLpLFl4RSaTAUYmmiWv3qhXUafnkiDFasYkZetdyqVMnQpNL9OL5+NB4WMyUORvvFJeY5wUFuxlkgCTHSKi0vD8DnB2JXBuNRD36MVKGVCzM9BsJFDLW9OzQhpyA8DESrMUlhCaU4SvHK+UV/IUozm1BwDpKUDCE81SFAqLXK6GyzJeKVsilWm9oZLTDBQA/7KIiEpKehoQ8q/miqqb+wEIzXoze6DpcKCpL2DtKmmI5ZpMBhgZaxZz+8K3o07XnFYryGBvndN0L56TnqJpLyX2ZQJVWHKj/CVIeY1xUlqU7mlSCTHZISIqbtEPgHOrgLN/AjGZTptU76C5oqpud8DASLLwqIDkBpqEwdiyaO2kJeeeCOU22DvrWKbkWABCc3ou4enLsV6FpTDP46q5HE7TZZ2TyVilmapAz3uZmOwQERUHdToQelBzRdWN3Zo5bwDAxAZoMgzw9AMq1ZA0RJKYoRIwt9MshaVWa3qZXtWLpJMg5TAQPD1Z015KnGYpSkeT3Cj7pJU5JU+NhxVt34uAyQ4RUVHEPnrRi7MSiLr7cr1ra80VVfV68ioeKj5yuSZxMFYVrZ205OzjlfKdPGWql9HLlPhMs+Slbg8mO0REZYZaDdw+rBmLc23ni3lloDnN0egtzYBjuzrSxkiUF0OlZjGzLXwbarVmIsr8jmUyrVR88RcQkx0iovyKf6qZE+eMP/Ds1sv1VV7TJDj1+2guuSaqCOQZ92KzkDqSV2KyQ0SUFyGAO8c1Cc6Vf15eUaOwABoN0gw4dmwgbYxElCcmO0REOUl8DlxYrxlw/OT6y/WVG2vG4jToByjNJQuPiPKPyQ4RUQYhgPunNAnO5c2a2x4AgJEp4NFf04vj3FTaGImowJjsEBElxQCX/tYkOY+CX653aKC5ZLzhwKLPsUJEkmGyQ0QV18NzmgTn0kbNVSWAZoK0+n01p6qqNNP7ydKI6NWY7BBRxZISr0luzvhrkp0MtnU0V1Q1Gly0u34Tkd5hskNEFUNEsCbBufj3i8nQoLmLtfubmrE4rq3Yi0NUTjHZIaLyKzURuLxFc6rq/n8v19tU1yQ4jYcCZtJNdEZEpYPJDhGVP49vaHpxzq8FkqI06+SGmhtwNhsFVGunmRCNiCoEJjtEVD6kJQNXt2tu4XDn2Mv1VlU1V1Q1HgZYOEgWHhFJh8kOEZVtT0OBMys0t3FIeKpZJ5MDtX00A45rdATkBpKGSETSYrJDRGVPeqrmBpxn/IFbAS/Xq5yBpiOAJsMBS2fJwiMi/cJkh4jKjud3gLMrgXOrgbhHL1bKgFpvaAYc1+oCGPBjjYh08VOBiPRbehoQ8q9mLM7N/QCEZr2ZvaYXp+kIwNpV0hCJSL8x2SEi/SME8Pg6cGUrcGYlEPvwZVn1Dporqup0AwyMpIqQiMoQJjtEJD0hgOe3gbDDL5f4yJflppU0c+J4+gGVakgVJRGVUUx2iEgaMQ8zJTdHgOi7uuWGxppZjRsPBer1BAyV0sRJRGUekx0iKh3xT4DbR14mOE9v6pbLjTQ33nRrp1mqNGeCQ0TFgskOEZWMxCjgznFNYnP7CPAoWLdcJgcqN36Z3FRtCSjMpIiUiMo5vU52Zs2ahdmzZ+usq1OnDq5duwYASEpKwocffoj169cjOTkZ3t7e+Pnnn+HgwFlSiUpdSjxw98TLnpvw84BQ69axr/8yuXFtBZhYSREpEVUwep3sAED9+vWxf/9+7WNDw5chf/DBB9i5cyc2bNgAS0tLjB8/Hn379sWxY8dyaoqIilNaMnD/1Mvk5v5pQJ2qW6dSzZfJTbW2gJmtNLESUYWm98mOoaEhHB0ds62Pjo7GH3/8gbVr16Jjx44AAH9/f9SrVw8nTpxAy5YtSztUovItPU3TWxMWqElu7p4A0pJ061i66CY3nMWYiPSA3ic7ISEhcHJygrGxMby8vDBv3jxUrVoVZ86cQWpqKjp37qytW7duXVStWhVBQUF5JjvJyclITk7WPo6JiSnRfSAqk9RqzTibjJ6bO8eBlFjdOmb2L5Mbt3aAdTVAJpMkXCKi3Oh1stOiRQusWLECderUQXh4OGbPno22bdsiODgYERERUCgUsLKy0nmOg4MDIiIi8mx33rx52cYCEVV4QgBPbrxMbm4fARKf69YxtgLc2gLVXiQ3dnWY3BCR3tPrZMfHx0f7e8OGDdGiRQu4urri77//homJSaHbnT59OqZMmaJ9HBMTAxcXlyLFSlQmZZ3IT3u/qRcU5pqBxBk9Nw4NeAdxIipz9DrZycrKygq1a9fGzZs38cYbbyAlJQVRUVE6vTuPHj3KcYxPZkqlEkol5++gCijmoWYCv7DDwO3DQFQOE/m5tHiR3LQHnBrzlgxEVOaVqWQnLi4OoaGhGD58ODw9PWFkZIQDBw6gX79+AIDr16/j7t278PLykjhSIj0R/zTLRH4huuVyQ8A5y0R+RsbSxEpEVEL0Otn56KOP0LNnT7i6uuLhw4eYOXMmDAwMMGTIEFhaWmL06NGYMmUKbGxsoFKpMGHCBHh5efFKLKq4kqJfTuQXdgR4dClLBZmmtyYjuXFpCSjNpYiUiKjU6HWyc//+fQwZMgRPnz6FnZ0d2rRpgxMnTsDOzg4AsGDBAsjlcvTr109nUkGiCiMlAbiXaSK/h+dymMjPPctEftbSxEpEJBGZEEJIHYTUYmJiYGlpiejoaKhUKqnDIcpdWrJm8j7tRH6nsk/kZ1NDd64bcztpYiUiKmH5/f+t1z07RBVeehoQfiHLRH6JunVUVTLNddMWsKwiTaxERHqKyQ6RPlGrgcjLuhP5JWeZ9NLMLstEfm6c64aIKA9MdoikoE4HYiOAmAdA9H3N8uC0ZlBx4jPdusaWmtNRGcmNXV0mN0REBcBkpyQFfKP5Vm7uAFhUBiwyfjoCSgupo6OSolYD8Y+BmPtA9IOXCU3Mwxe/PwBiwwGRnvPzjcx0J/Jz9OBEfkRERcBkpyRdXA88u5VzmZGZJunJWMwdc36stOC3eH0iBJDwTDeRyUhgMpKa2HAgPeXVbckMAJUToHLW3DDTrp4muXFuyon8iIiKEZOdktTyfSDqDhD7SPMPMO6R5tRFcgyQGg88C9UseTEyzZIMZeohytxjpFQxKSoqITTz1Gh7YO5nSmQykpuH2QcI50imeb0yEhlVlRc/nTUDiFVOmtePPTZERCWOyU5Jeu3tnNenxGuSntgIIC7i5e86jx8BydFAaoKmdyi3HqIMRqbZT5flePqsAidFKfFZEpesCc0DICUuf22Z2WVKXJxfJjIZv1tUZu8MEZGeYLIjBYUZUKmGZslLSkKm5Cc8Sw9RxuOIl0nR8zDNkhdDk/ydPjO2LFtJUWpSllNKmROaF4+TovPXlom1bk+Mykk3qbFw4i0ViIjKECY7+kxhCthU1yx50UmK8ugxSorWnILJV1JknL/TZ8ZWJZ8UpafqDu7NabxMwpP8taVUZeqJccr59JLCrGT3h4iIShWTnfKgQEnRo5c9RTo9RJkeJ0UDaUnA89uaJS+GxnmcPsvUY5RbUpT1EuyYF+NiMp9einsEIB8TfRuaZElcchgvY8wZsomIKhomOxWJwhSwcdMseUlNzMeYogggKUqTFEXd0Sx5MVC+THxMKwEJT199CbbO8xU59MRkSWRMrMvWqTciIioVTHYoOyOT/CdFmXuKchxTFK5JitKTc0+Ksl6CnVPPjGklQC4vkd0lIqLyjckOFZ6RCWBdTbPkRScpitCMrzG1fZnM8BJsIiIqQUx2qOTlNykiIiIqATwvQEREROUakx0iIiIq15jsEBERUbnGZIeIiIjKNSY7REREVK4x2SEiIqJyjckOERERlWtMdoiIiKhcY7JDRERE5RqTHSIiIirXmOwQERFRucZkh4iIiMo1JjtERERUrjHZISIionKNyQ4RERGVa0x2iIiIqFxjskNERETlGpMdIiIiKteY7BAREVG5xmSHiIiIyjUmO0RERFSuMdkhIiKico3JDhEREZVrTHaIiIioXGOyQ0REROWaodQBEBGRhhACIjER6bFxUMfGID02Fuq4OKhjYzXr4mKRHhsLpKszPytrI9na1F2RbaMFewyp2y/K9kqy7RweS36s9Kt9x1kzYeTgACkw2SEiKgZCCIjk5JeJSWyMToKijo1DemwM1LEvkpeMJCYuFuqYWO06pKdLvStEJUI9bapk22ayQ1SKRHo61ImJUCckQCQman5PTIRITIQQAnKFArKsi5FR9scymdS7Uu6oU1Kgjn2RdGh/5pKsxGUkNJnqxsUBqanFE4yBAQzMzSG3sIDcwkLzu0ql+WluDplhlo/urO+HVz7OWvyK+tmfUKD2s5Znf/+WcPt5bU/PjpXkr0WBt5f/9g1tbSEVJjtEmQghIJKSXiQkiRBJidrf1YkvEpSERKiTEl/+npi1LEnzOOFlMqNNaFJSiiXObAlQtqTISJM4GeWQPGnraurrJFg69Y20dXNMwvQoAROpqS97SnQSlkzJSsyLXpRckpXiem0gk71MUCwsILcwh4H5i6QlI3mxMIfc/EWZSgW5ufnLMnNzyExNmdASFSMmO1TmiJSUbElEtoQkMSl7EpL4InlJyPzchEwJiqat7OetS4BMBrmJCWSmppAbG0NuYgLIZBApKZolNVWzny9+Ii1N9xikpkKkpgLx8SUfa34ZGUGeUxKWYwJmlEsippuAATKo4+N0TwvFvkxaMnpaRFJSse2G3MxMJzF5mayYw8BC9cpkRW5qCpmc134Q6RMmOyXowZQPkfrwISCXA3IZZJBpfpfJNI9lMkAmf7EOkMkyyjQ/ZfIX5fmqD80HbE71tY9zqJ8RU071M5dnqa+JLbf4ZC/iz+H5Ms0/AZGclL1XJHOCkpBDMvNiyfqPv6TIlMoXCYkJ5MYmkJuYvHxsYqr53cRY+7vc1AQyk4wy4xflLx6bmkBubKxJbkxMIFMqC/TNXaSnaxOgzIs6U2IkUl78TM2hTk71Mi+pmeqlpOa4LW17uSRgSE2FOjUVSEgo5lci/2SmptoelRx7USxUL35aQG7+oizj9JCFBeRmZpAZGEgWPxGVDCY7JSjpyhWk3L4tdRjll6GhNgF5mVhkT0jkJsaZkpAXSYmx5ufL52ZKSF4kK/r0T09mYKCJx9hY6lC0hFqda1KkkzhlTrRyS8QyJ2CZ2xTqF+NUMvWwqCx0k5WMxCansSxERChHyc5PP/2E+fPnIyIiAo0aNcLixYvx2muvSRqT48wZUMfHay7XUwtAqAEhINRqzSV7mR+rheb0iVBnqv/icUZ9tRpAIetnPM6pfsbjnOrntT1t+YuyzI/VL/btxT5mfb5cafyyJ8Q4a69IRkJi/LJXJCOZyXTaR3Oag6Qik8shUyoBpVLqUIiI8lQukp2//voLU6ZMwbJly9CiRQv8+OOP8Pb2xvXr12Fvby9ZXGZeXpJtm4iIiDRkItssQWVPixYt0Lx5cyxZsgQAoFar4eLiggkTJuCTTz555fNjYmJgaWmJ6OhoqFSqYovrekQsktNezpkhy3SNXl7DNTKXybJc16dTlt96ebSPPGLK/DDz+JK82svvPuYk8ztRZJqtSnd95voil/U6reajnXxsNx91dLZahH3Jj4L+0Ras+QLGUoDqhYlbLQTUaqHpTBQC6UJACAFNh6N4sbwoU4uXzxF48TzN7y+fJ5AuNMdcW6Z+UZbl95fbw4vnZW5fIF39sh2d31/UyYhTu+0X7asztZM55vQXdXJsM1O9DDn+Xcp0H+dUR6atI9N5nFnG87I9J4e/d1mWbSLPbeY/Lp0rxPMR+6v2K+9tvroOctpmIeIq2GuUex3ktc0CxJV1v3Q/+3N+fk5xveo5YzvUgK158fYE5/f/d5nv2UlJScGZM2cwffp07Tq5XI7OnTsjKCgox+ckJycjOTlZ+zgmJqZEYhu75gxuPdajq2WIiIgkMrRF1WJPdvKrzCc7T548QXp6OhyyTEHt4OCAa9eu5ficefPmYfbs2SUem4OFMZJTNdO656cXQmSbmjtzWc7rc+u5yP6cfGw/6zTzuTzIT7vZ2s4SZ356g17Zs5SfugVpL0v9vL7FZV9fsG3qbCWHb8z5kbU375X1C1C9gKEU6MqygrYtl8sglwFymUyzyAEDmebqP+36THUM5FnKZFnL8HKd/GV55ue9bD+HsiztZ25T87yX6zUXJspePNb9XS7LaXt48TzddnR+h+a1zOnzIWNdxt9lTn/r2r9F3R851hFZ6uT4957Lc/J6fs6fQTlvMz9xZY0tr+fkN67c9qugcSFL2/l7jXLep/xuM699f1knt9c4U53ctpGP91dOcVmaGGUPpJSU+WSnMKZPn44pU6ZoH8fExMDFxaXYt7PunZbF3iYREREVTJlPdmxtbWFgYIBHjx7prH/06BEcHR1zfI5SqYSSV5AQERFVCGV+mk+FQgFPT08cOHBAu06tVuPAgQPw4tVQREREFV6Z79kBgClTpsDX1xfNmjXDa6+9hh9//BHx8fEYOXKk1KERERGRxMpFsjNo0CA8fvwYM2bMQEREBBo3bow9e/ZkG7RMREREFU+5mGenqEpqnh0iIiIqOfn9/13mx+wQERER5YXJDhEREZVrTHaIiIioXGOyQ0REROUakx0iIiIq15jsEBERUbnGZIeIiIjKNSY7REREVK4x2SEiIqJyrVzcLqKoMiaRjomJkTgSIiIiyq+M/9uvuhkEkx0AsbGxAAAXFxeJIyEiIqKCio2NhaWlZa7lvDcWALVajYcPH8LCwgIymazY2o2JiYGLiwvu3bvHe25lwuOSHY9JdjwmOeNxyY7HJLuKckyEEIiNjYWTkxPk8txH5rBnB4BcLkeVKlVKrH2VSlWu32yFxeOSHY9JdjwmOeNxyY7HJLuKcEzy6tHJwAHKREREVK4x2SEiIqJyjclOCVIqlZg5cyaUSqXUoegVHpfseEyy4zHJGY9Ldjwm2fGY6OIAZSIiIirX2LNDRERE5RqTHSIiIirXmOwQERFRucZkh4iIiMo1JjuvcPjwYfTs2RNOTk6QyWTYunWrTrkQAjNmzEDlypVhYmKCzp07IyQkRKfOs2fPMHToUKhUKlhZWWH06NGIi4vTqXPx4kW0bdsWxsbGcHFxwbffflvSu1Zo8+bNQ/PmzWFhYQF7e3v07t0b169f16mTlJSEcePGoVKlSjA3N0e/fv3w6NEjnTp3795F9+7dYWpqCnt7e0ydOhVpaWk6dQICAtC0aVMolUrUrFkTK1asKOndK7SlS5eiYcOG2km8vLy8sHv3bm15RTwmmX399deQyWSYPHmydl1FPCazZs2CTCbTWerWrastr4jHBAAePHiAYcOGoVKlSjAxMYGHhwdOnz6tLa+In7XVqlXL9l6RyWQYN24cgIr7XikUQXnatWuX+Oyzz8TmzZsFALFlyxad8q+//lpYWlqKrVu3igsXLohevXoJNzc3kZiYqK3TtWtX0ahRI3HixAlx5MgRUbNmTTFkyBBteXR0tHBwcBBDhw4VwcHBYt26dcLExET88ssvpbWbBeLt7S38/f1FcHCwOH/+vOjWrZuoWrWqiIuL09Z57733hIuLizhw4IA4ffq0aNmypWjVqpW2PC0tTTRo0EB07txZnDt3TuzatUvY2tqK6dOna+vcunVLmJqaiilTpogrV66IxYsXCwMDA7Fnz55S3d/82rZtm9i5c6e4ceOGuH79uvj000+FkZGRCA4OFkJUzGOS4b///hPVqlUTDRs2FJMmTdKur4jHZObMmaJ+/foiPDxcuzx+/FhbXhGPybNnz4Srq6vw8/MTJ0+eFLdu3RJ79+4VN2/e1NapiJ+1kZGROu+Tffv2CQDi0KFDQoiK+V4pLCY7BZA12VGr1cLR0VHMnz9fuy4qKkoolUqxbt06IYQQV65cEQDEqVOntHV2794tZDKZePDggRBCiJ9//llYW1uL5ORkbZ2PP/5Y1KlTp4T3qHhERkYKACIwMFAIoTkGRkZGYsOGDdo6V69eFQBEUFCQEEKTRMrlchEREaGts3TpUqFSqbTHYdq0aaJ+/fo62xo0aJDw9vYu6V0qNtbW1uL333+v0MckNjZW1KpVS+zbt0+0b99em+xU1GMyc+ZM0ahRoxzLKuox+fjjj0WbNm1yLednrcakSZNEjRo1hFqtrrDvlcLiaawiCAsLQ0REBDp37qxdZ2lpiRYtWiAoKAgAEBQUBCsrKzRr1kxbp3PnzpDL5Th58qS2Trt27aBQKLR1vL29cf36dTx//ryU9qbwoqOjAQA2NjYAgDNnziA1NVXnuNStWxdVq1bVOS4eHh5wcHDQ1vH29kZMTAwuX76srZO5jYw6GW3os/T0dKxfvx7x8fHw8vKq0Mdk3Lhx6N69e7a4K/IxCQkJgZOTE6pXr46hQ4fi7t27ACruMdm2bRuaNWuGAQMGwN7eHk2aNMFvv/2mLednLZCSkoLVq1dj1KhRkMlkFfa9UlhMdoogIiICAHTeSBmPM8oiIiJgb2+vU25oaAgbGxudOjm1kXkb+kqtVmPy5Mlo3bo1GjRoAEATs0KhgJWVlU7drMflVfucW52YmBgkJiaWxO4U2aVLl2Bubg6lUon33nsPW7Zsgbu7e4U9JuvXr8fZs2cxb968bGUV9Zi0aNECK1aswJ49e7B06VKEhYWhbdu2iI2NrbDH5NatW1i6dClq1aqFvXv3YuzYsZg4cSJWrlwJgJ+1ALB161ZERUXBz88PQMX9+yks3vWcimTcuHEIDg7G0aNHpQ5FL9SpUwfnz59HdHQ0Nm7cCF9fXwQGBkodliTu3buHSZMmYd++fTA2NpY6HL3h4+Oj/b1hw4Zo0aIFXF1d8ffff8PExETCyKSjVqvRrFkzzJ07FwDQpEkTBAcHY9myZfD19ZU4Ov3wxx9/wMfHB05OTlKHUiaxZ6cIHB0dASDb6PdHjx5pyxwdHREZGalTnpaWhmfPnunUyamNzNvQR+PHj8eOHTtw6NAhVKlSRbve0dERKSkpiIqK0qmf9bi8ap9zq6NSqfT2n4JCoUDNmjXh6emJefPmoVGjRli4cGGFPCZnzpxBZGQkmjZtCkNDQxgaGiIwMBCLFi2CoaEhHBwcKtwxyYmVlRVq166NmzdvVsj3CQBUrlwZ7u7uOuvq1aunPb1X0T9r79y5g/3792PMmDHadRX1vVJYTHaKwM3NDY6Ojjhw4IB2XUxMDE6ePAkvLy8AgJeXF6KionDmzBltnYMHD0KtVqNFixbaOocPH0Zqaqq2zr59+1CnTh1YW1uX0t7knxAC48ePx5YtW3Dw4EG4ubnplHt6esLIyEjnuFy/fh13797VOS6XLl3S+XDat28fVCqV9kPPy8tLp42MOhltlAVqtRrJyckV8ph06tQJly5dwvnz57VLs2bNMHToUO3vFe2Y5CQuLg6hoaGoXLlyhXyfAEDr1q2zTV9x48YNuLq6Aqi4n7UZ/P39YW9vj+7du2vXVdT3SqFJPUJa38XGxopz586Jc+fOCQDihx9+EOfOnRN37twRQmguh7SyshL//POPuHjxonjzzTdzvByySZMm4uTJk+Lo0aOiVq1aOpdDRkVFCQcHBzF8+HARHBws1q9fL0xNTfX2csixY8cKS0tLERAQoHNZZEJCgrbOe++9J6pWrSoOHjwoTp8+Lby8vISXl5e2POOSyC5duojz58+LPXv2CDs7uxwviZw6daq4evWq+Omnn/T6kshPPvlEBAYGirCwMHHx4kXxySefCJlMJv79918hRMU8JlllvhpLiIp5TD788EMREBAgwsLCxLFjx0Tnzp2Fra2tiIyMFEJUzGPy33//CUNDQ/HVV1+JkJAQsWbNGmFqaipWr16trVMRP2uFECI9PV1UrVpVfPzxx9nKKuJ7pbCY7LzCoUOHBIBsi6+vrxBCc0nk559/LhwcHIRSqRSdOnUS169f12nj6dOnYsiQIcLc3FyoVCoxcuRIERsbq1PnwoULok2bNkKpVApnZ2fx9ddfl9YuFlhOxwOA8Pf319ZJTEwU77//vrC2thampqaiT58+Ijw8XKed27dvCx8fH2FiYiJsbW3Fhx9+KFJTU3XqHDp0SDRu3FgoFApRvXp1nW3om1GjRglXV1ehUCiEnZ2d6NSpkzbREaJiHpOssiY7FfGYDBo0SFSuXFkoFArh7OwsBg0apDOfTEU8JkIIsX37dtGgQQOhVCpF3bp1xa+//qpTXhE/a4UQYu/evQJAtn0VouK+VwpDJoQQknQpEREREZUCjtkhIiKico3JDhEREZVrTHaIiIioXGOyQ0REROUakx0iIiIq15jsEBERUbnGZIeIiIjKNSY7RER58PPzQ+/evaUOg4iKgJMKElGJCwoKQps2bdC1a1fs3LlT6nAKJDo6GkIIWFlZSR0KERUSkx0iKnFjxoyBubk5/vjjD1y/fh1OTk651hVCID09HYaGhjrrU1JSoFAoSjpUIiqHeBqLiEpUXFwc/vrrL4wdOxbdu3fHihUrdMoDAgIgk8mwe/dueHp6QqlU4ujRo+jQoQPGjx+PyZMnw9bWFt7e3gCAH374AR4eHjAzM4OLiwvef/99xMXFAQDi4+OhUqmwceNGnW1s3boVZmZmiI2NzTHGjRs3wsPDAyYmJqhUqRI6d+6M+Ph4ALqnsW7fvg2ZTJZt6dChg7ato0ePom3btjAxMYGLiwsmTpyobYuIpMFkh4hK1N9//426deuiTp06GDZsGJYvX46cOpQ/+eQTfP3117h69SoaNmwIAFi5ciUUCgWOHTuGZcuWAQDkcjkWLVqEy5cvY+XKlTh48CCmTZsGADAzM8PgwYPh7++v07a/vz/69+8PCwuLbNsNDw/HkCFDMGrUKFy9ehUBAQHo27dvjjG6uLggPDxcu5w7dw6VKlVCu3btAAChoaHo2rUr+vXrh4sXL+Kvv/7C0aNHMX78+KIdRCIqGqnuQEpEFUOrVq3Ejz/+KIQQIjU1Vdja2opDhw5pyw8dOiQAiK1bt+o8r3379qJJkyavbH/Dhg2iUqVK2scnT54UBgYG4uHDh0IIIR49eiQMDQ1FQEBAjs8/c+aMACBu376dY7mvr6948803s61PTPx/O/cSktwWhgH4tcRJN2oQ3aBB0j2lCyVEI8MobGJEBF1IpRo0aRASRFAIXcAGWTQI6V4QSBBBhDWoRoZSRgjVoJpYECFRGJTpP4gTp99OERz5D/u8D6zJ8vNjbwf6stZyPwXLysqCarU6+Pr6GgwGg0GdThdsb2//ULe/vx+MiIgIPj09fXsvRBQeXNkhorA5PT3FwcEBGhsbAQBisRgNDQ2wWCwhtSUlJSFzxcXFIXPb29tQKpVITU1FTEwMmpubcXd3B5/PBwAoLS1FXl4e5ubmAACLi4tIT09/X335nVwuh1KpREFBAerr6zE9PQ2v1/vtvWm1Wjw8PGB5eRkREW9fpS6XC7Ozs4iOjn4fVVVVCAQCuLi4+LYnEYUHww4RhY3FYoHf70dKSgrEYjHEYjGmpqZgtVpxf3//oTYqKirk/b/PXV5eQq1WQyaTwWq1wul0YnJyEsDbAea/6PX697NBMzMzaGtrg0gk+vQaIyMjYbPZsLm5idzcXJjNZmRlZX0ZToxGI7a2trC+vv5ha+zx8REdHR04Ojp6Hy6XC+fn58jIyPj6wyKisGHYIaKw8Pv9mJ+fh8lkCvnxT0lJwcrKyo97Op1OBAIBmEwmKBQKZGZmwuPxhNQ1NTXh6uoK4+PjcLvdaG1t/bKvSCRCeXk5BgYGcHh4CIlEgrW1tU9rrVYrBgcHsbq6GhJgioqK4Ha7IZVKQwb/SUb054i/LyEi+rmNjQ14vV7odDrExcV9eK2urg4WiwWdnZ0/6imVSvHy8gKz2Yza2toPB5f/Lj4+HhqNBj09PVCpVEhLS/vHnna7HTs7O1CpVEhMTITdbsft7S1ycnJCak9OTtDS0gKDwYC8vDzc3NwAACQSCRISEmAwGKBQKNDV1QW9Xo+oqCi43W7YbDZMTEz86F6J6N/DlR0iCguLxYLKysqQoAO8hR2Hw4Hj4+Mf9ZTL5RgbG8PIyAjy8/OxtLSEoaGhT2t1Oh2en5+h1Wq/7BkbG4u9vT3U1NQgMzMTfX19MJlMqK6uDql1OBzw+XwwGo1ITk5+HxqNBgAgk8mwu7uLs7MzVFRUoLCwEP39/V8+V4iIwo8PFSQiQVpYWEB3dzc8Hg+3kIj+57iNRUSC4vP5cH19jeHhYXR0dDDoEBG3sYhIWEZHR5GdnY2kpCT09vb+6cshov8AbmMRERGRoHFlh4iIiASNYYeIiIgEjWGHiIiIBI1hh4iIiASNYYeIiIgEjWGHiIiIBI1hh4iIiASNYYeIiIgEjWGHiIiIBO0X6kW8ByPKy9sAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "runtimes_1d = {}\n", + "\n", + "for library in ENGINES:\n", + " runtimes_1d[library] = {}\n", + " for dim in [1000, 2000, 3000, 4000, 5000, 7500]:\n", + " runtime = cov_timeit(library=library, size=(dim,))\n", + " runtimes_1d[library][dim] = runtime[0]\n", + "\n", + "ax = pd.DataFrame(runtimes_1d).plot(title=\"90% percentile runtime for covariance from 1-d array\")\n", + "ax.set_xlabel(\"Array size\")\n", + "ax.set_ylabel(\"Runtime (ms)\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "SVN1ryaWte8Q" + }, + "source": [ + "For 2-d array, we measure the runtimes of covariance computation on matrix\n", + "with size (5000, N), where N ranges from 100 to 1000.\n", + "\n", + "With GPU availability, the engines running on GPU runtime perform much better than\n", + "NumPy compatible only on CPU runtime." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 490 + }, + "id": "nC2W8YtE3vRE", + "outputId": "0df4cb32-c62a-4fdf-fdb4-f97da14b3fe0" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Runtime (ms)')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "runtimes_2d = {}\n", + "\n", + "for library in ENGINES:\n", + " runtimes_2d[library] = {}\n", + " for dim in [100, 200, 300, 400, 500, 750]:\n", + " runtime = cov_timeit(library=library, size=(5000, dim))\n", + " runtimes_2d[library][dim] = runtime[0]\n", + "\n", + "ax = pd.DataFrame(runtimes_2d).plot(title=\"90% percentile runtime for covariance from 2-d array (5000, N)\")\n", + "ax.set_xlabel(\"Size (N)\")\n", + "ax.set_ylabel(\"Runtime (ms)\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": { + "id": "SCwiobb7te8Q" + }, + "source": [ + "# Unitroot" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "ucxcOyMgte8Q" + }, + "outputs": [], + "source": [ + "def unitroot_get_data(size: int):\n", + " import numpy as np\n", + " rnd = np.random.RandomState(12345)\n", + " return np.cumsum(rnd.standard_normal(size))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "DdOesd7Mte8R" + }, + "outputs": [], + "source": [ + "def unitroot_timeit(\n", + " library: str,\n", + " size: int,\n", + " estimator: object = ADF,\n", + "):\n", + " import numpy as np\n", + " data = unitroot_get_data(size)\n", + "\n", + " def _func():\n", + " return estimator(data).summary()\n", + "\n", + " with use_backend(library):\n", + " # Warm start (e.g. JAX to compile the function first) and\n", + " # estimate the runtime to determine the total number of runs\n", + " start = time()\n", + " _func()\n", + " end = time()\n", + " elapsed = end - start\n", + "\n", + " # Generally the total runtime should not be more than 10s\n", + " if elapsed < 0.001:\n", + " n_run = 10000\n", + " elif elapsed < 0.01:\n", + " n_run = 1000\n", + " elif elapsed < 0.1:\n", + " n_run = 100\n", + " elif elapsed < 1.0:\n", + " n_run = 10\n", + " else:\n", + " n_run = 1\n", + "\n", + " # Get total runtime\n", + " runtimes = [0.0] * n_run\n", + " for index in range(n_run):\n", + " start = time()\n", + " ret = _func()\n", + " end = time()\n", + " runtimes[index] = end - start\n", + "\n", + " # Output: time in ms, number of runs and estimation result\n", + " return 1000 * np.percentile(runtimes, 90), n_run, ret\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 490 + }, + "id": "XdPgU4Y1te8R", + "outputId": "0dabd93e-510b-44ea-9b2f-9e64e4a289b4" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Runtime (ms)')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "runtimes = {}\n", + "\n", + "for library in ENGINES:\n", + " if library == \"cupy\":\n", + " continue\n", + "\n", + " runtimes[library] = {}\n", + " for dim in [1000, 2000, 3000, 4000, 5000, 7500, 10000]:\n", + " runtime = unitroot_timeit(library=library, size=dim)\n", + " runtimes[library][dim] = runtime[0]\n", + "\n", + "ax = pd.DataFrame(runtimes).plot(title=\"90% percentile runtime for unitroot\")\n", + "ax.set_xlabel(\"Array size\")\n", + "ax.set_ylabel(\"Runtime (ms)\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "N25CSEyXte8R" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "T4", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 0 +} From ede216185836164a634986ca7995ab8f0c9e7558 Mon Sep 17 00:00:00 2001 From: Gavin Chan Date: Wed, 5 Jul 2023 13:42:38 +0100 Subject: [PATCH 2/7] Fix unit test --- arch/tests/test_examples.py | 5 +- examples/experimental_accelerated_numpy.ipynb | 131 +++++++++--------- 2 files changed, 66 insertions(+), 70 deletions(-) diff --git a/arch/tests/test_examples.py b/arch/tests/test_examples.py index 1638916402..4f81ec2055 100644 --- a/arch/tests/test_examples.py +++ b/arch/tests/test_examples.py @@ -37,7 +37,10 @@ except ImportError: # pragma: no cover pytestmark = pytest.mark.skip(reason=REASON) -SLOW_NOTEBOOKS = ["multiple-comparison_examples.ipynb"] +SLOW_NOTEBOOKS = [ + "multiple-comparison_examples.ipynb", + "experimental_accelerated_numpy.ipynb", +] if bool(os.environ.get("ARCH_TEST_SLOW_NOTEBOOKS", False)): # pragma: no cover SLOW_NOTEBOOKS = [] kernel_name = "python%s" % sys.version_info.major diff --git a/examples/experimental_accelerated_numpy.ipynb b/examples/experimental_accelerated_numpy.ipynb index 2c5572783e..f914122ae7 100644 --- a/examples/experimental_accelerated_numpy.ipynb +++ b/examples/experimental_accelerated_numpy.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "metadata": { "id": "H1doh35B3vRA" @@ -20,7 +19,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": { "id": "e2bSb8nb3vRB" @@ -31,50 +29,50 @@ }, { "cell_type": "code", + "source": [ + "import locale\n", + "locale.getpreferredencoding = lambda: \"UTF-8\"" + ], + "metadata": { + "id": "4__UNucy4od9" + }, "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "erbuAiRs3vRC", - "outputId": "c1d995de-7687-473b-ed85-c68f6e614e31" + "outputId": "cd82fe2c-f538-48ca-b7e4-2ef7e1ad3369" }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Collecting git+https://github.com/gavincyi/arch.git@feature/tnp\n", - " Cloning https://github.com/gavincyi/arch.git (to revision feature/tnp) to /tmp/pip-req-build-x_5egqd7\n", - " Running command git clone --filter=blob:none --quiet https://github.com/gavincyi/arch.git /tmp/pip-req-build-x_5egqd7\n", + " Cloning https://github.com/gavincyi/arch.git (to revision feature/tnp) to /tmp/pip-req-build-46p2j9ii\n", + " Running command git clone --filter=blob:none --quiet https://github.com/gavincyi/arch.git /tmp/pip-req-build-46p2j9ii\n", " Running command git checkout -b feature/tnp --track origin/feature/tnp\n", " Switched to a new branch 'feature/tnp'\n", " Branch 'feature/tnp' set up to track remote branch 'feature/tnp' from 'origin'.\n", - " Resolved https://github.com/gavincyi/arch.git to commit d351c541fe5065f0fee1f32c79ba66b28838d974\n", + " Resolved https://github.com/gavincyi/arch.git to commit e57fabd8dfb4f85b53ab3202eb5eff5169f1394e\n", " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (1.22.4)\n", - "Requirement already satisfied: scipy>=1.3 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (1.10.1)\n", - "Requirement already satisfied: pandas>=1.0 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (1.5.3)\n", - "Requirement already satisfied: statsmodels>=0.11 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (0.13.5)\n", - "Requirement already satisfied: property-cached>=1.6.4 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1038+gd351c54) (1.6.4)\n", - "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.0->arch==0.1.dev1038+gd351c54) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.0->arch==0.1.dev1038+gd351c54) (2022.7.1)\n", - "Requirement already satisfied: patsy>=0.5.2 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.11->arch==0.1.dev1038+gd351c54) (0.5.3)\n", - "Requirement already satisfied: packaging>=21.3 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.11->arch==0.1.dev1038+gd351c54) (23.1)\n", - "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from patsy>=0.5.2->statsmodels>=0.11->arch==0.1.dev1038+gd351c54) (1.16.0)\n", - "Building wheels for collected packages: arch\n", - " Building wheel for arch (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for arch: filename=arch-0.1.dev1038+gd351c54-cp310-cp310-linux_x86_64.whl size=1802322 sha256=4d31c2cea2fde6e59546f8f04ee4327b1fbe34302a6cbf22d446cf3950b7d0e5\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-0uirgqcj/wheels/e0/96/b7/674f6b3592bc98941ccfa3c74700acca078de257ddd554cdbe\n", - "Successfully built arch\n", - "Installing collected packages: arch\n", - " Attempting uninstall: arch\n", - " Found existing installation: arch 0.1.dev1036+g906cf00\n", - " Uninstalling arch-0.1.dev1036+g906cf00:\n", - " Successfully uninstalled arch-0.1.dev1036+g906cf00\n", - "Successfully installed arch-0.1.dev1038+gd351c54\n" + "Requirement already satisfied: numpy>=1.19 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1078+ge57fabd) (1.22.4)\n", + "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1078+ge57fabd) (1.10.1)\n", + "Requirement already satisfied: pandas>=1.1 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1078+ge57fabd) (1.5.3)\n", + "Requirement already satisfied: statsmodels>=0.12 in /usr/local/lib/python3.10/dist-packages (from arch==0.1.dev1078+ge57fabd) (0.13.5)\n", + "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.1->arch==0.1.dev1078+ge57fabd) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.1->arch==0.1.dev1078+ge57fabd) (2022.7.1)\n", + "Requirement already satisfied: patsy>=0.5.2 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.12->arch==0.1.dev1078+ge57fabd) (0.5.3)\n", + "Requirement already satisfied: packaging>=21.3 in /usr/local/lib/python3.10/dist-packages (from statsmodels>=0.12->arch==0.1.dev1078+ge57fabd) (23.1)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from patsy>=0.5.2->statsmodels>=0.12->arch==0.1.dev1078+ge57fabd) (1.16.0)\n" ] } ], @@ -84,7 +82,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": { "id": "Rhuk-ebE3vRC" }, @@ -96,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": { "id": "gn_T2Wf_3vRC" }, @@ -117,7 +115,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": { "id": "S7pe1H2Ste8O" @@ -135,20 +132,20 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "HGRbhqtRte8O", - "outputId": "8c31301e-b85e-4a3a-e670-35c94188c265" + "outputId": "2724269f-5c84-4f8d-f842-020772a12476" }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Supported engines: numpy, tensorflow, jax\n" + "Supported engines: numpy, tensorflow, jax, cupy\n" ] } ], @@ -166,7 +163,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": { "id": "UJORee683vRD" @@ -181,7 +177,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "id": "AMpUvdsu3vRE" }, @@ -211,7 +207,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "id": "m2GuzwHD3vRE" }, @@ -265,7 +261,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": { "id": "FXaw2b-cte8Q" @@ -279,35 +274,35 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 490 }, "id": "wSPb40Nc3vRE", - "outputId": "8fdb696a-a1d7-4068-ca1f-6a26d9cefc47" + "outputId": "f19fbc36-4d52-47ac-d078-ace76f2d840b" }, "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "Text(0, 0.5, 'Runtime (ms)')" ] }, - "execution_count": 7, "metadata": {}, - "output_type": "execute_result" + "execution_count": 8 }, { + "output_type": "display_data", "data": { - "image/png": "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", "text/plain": [ "
" - ] + ], + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} } ], "source": [ @@ -325,7 +320,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": { "id": "SVN1ryaWte8Q" @@ -340,35 +334,35 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 490 }, "id": "nC2W8YtE3vRE", - "outputId": "0df4cb32-c62a-4fdf-fdb4-f97da14b3fe0" + "outputId": "d7c11dec-73d8-4c9c-e2f3-14f980325713" }, "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "Text(0, 0.5, 'Runtime (ms)')" ] }, - "execution_count": 8, "metadata": {}, - "output_type": "execute_result" + "execution_count": 9 }, { + "output_type": "display_data", "data": { - "image/png": "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", "text/plain": [ "
" - ] + ], + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} } ], "source": [ @@ -386,7 +380,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": { "id": "SCwiobb7te8Q" @@ -397,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 10, "metadata": { "id": "ucxcOyMgte8Q" }, @@ -411,7 +404,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "metadata": { "id": "DdOesd7Mte8R" }, @@ -462,35 +455,35 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 490 }, "id": "XdPgU4Y1te8R", - "outputId": "0dabd93e-510b-44ea-9b2f-9e64e4a289b4" + "outputId": "5824a70e-c46c-4d4e-ff72-e35e8705f7bc" }, "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "Text(0, 0.5, 'Runtime (ms)')" ] }, - "execution_count": 8, "metadata": {}, - "output_type": "execute_result" + "execution_count": 12 }, { + "output_type": "display_data", "data": { - "image/png": "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", "text/plain": [ "
" - ] + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACFl0lEQVR4nO3deVxUVf8H8M8MMMO+LwMKiIoighsq4p6SiEspLmXmkqZmmplP5mNPmVamWU9l9qQtpv4qW0w0s9TUXFIRFVfUFHHBhQER2WGAmfP7Y+TKCCogMDB83q8XL5l7z9z5zgwyH8499xyZEEKAiIiIyETJjV0AERERUU1i2CEiIiKTxrBDREREJo1hh4iIiEwaww4RERGZNIYdIiIiMmkMO0RERGTSGHaIiIjIpDHsEBERkUlj2CGiR9KkSROMHz9eur17927IZDLs3r3baDXVlN69e6N3797GLsPA4cOH0bVrV9jY2EAmk+H48ePGLqlSTPnnheoOhh2q0+Li4tC/f3/Y29vDzs4O/fr1u+8v8wMHDqB79+6wtraGSqXCjBkzkJOTY9Dm+vXrGDhwIOzt7REYGIjffvutzHGio6Ph7u6OzMzMmnhK9dKBAwcwf/58ZGRkGLuUGnfmzBnMnz8fly9fNnYpD1VUVIQRI0YgPT0dH3/8Mb799lv4+voau6xHtnbtWnzyySdGraEh/cw3CIKojoqLixOWlpbC399ffPjhh2LJkiWiSZMmwt7eXvzzzz8GbY8dOyYsLS1F+/btxfLly8V//vMfoVQqRf/+/Q3a9e3bVwQEBIjPP/9cjB49WiiVSnHp0iVpf35+vvDz8xNffPFFbTzFeuODDz4QAAxeqxIFBQWisLBQur1r1y4BQOzatav2CqxG69atu2/9Go1GaDSa2i/qPs6ePSsAiK+++srYpVSZVqsV+fn5QqvVStsGDhwofH19jVeUePDPPNU/5kZNWkQP8Oabb8LKygoxMTFwcXEBADz77LNo0aIFXn/9daxfv15q+/rrr8PJyQm7d++Gvb09AP3plUmTJuHPP/9Ev379kJ+fj7/++gu7d+9Gz5498cILL+DAgQPYtm0bpkyZAgD48MMP4eDggOeff772n/ADCCFQUFAAKysrY5dShlKprPXHLCgogEKhgFxeu53TCoWiVh/vYVJTUwEAjo6O1XbM3Nxc2NjYVNvxHkYul8PS0rLK9zfWzwLVM8ZOW0T3Y2dnJ0aMGFFm+8CBA4VCoRDZ2dlCCCEyMzOFubm5mD17tkE7jUYjbG1txcSJE4UQQqSnpwsA4uTJk1Kb9u3bi48++kgIIcS1a9eEjY2N2LNnT6XqHDdunLCxsRGJiYmiX79+wtraWnh6eooFCxYInU5n0Far1YqPP/5YBAYGCqVSKdzd3cXkyZNFenq6QTtfX18xcOBAsXXrVhESEiKUSqX4+OOPhRBC3L59W8ycOVP4+voKhUIhGjVqJMaMGSNu3rwp3b+goEDMmzdPNGvWTCgUCtG4cWMxe/ZsUVBQYPA4AMS0adPEhg0bROvWrYVCoRCBgYFiy5YtUpu33npLACjzVfIXr6+vrxg3bpzU/n49OwcPHhQRERHC3t5eWFlZiZ49e4p9+/Y99PUtOd4PP/wg/vOf/wgvLy8hk8nE7du3pdrutWrVqjJ/lZe8pn///bfo1KmTUCqVws/PT6xZs6bM/e79KnkuvXr1Er169SpT208//STmz58vvLy8hK2trRg2bJjIyMgQBQUF4uWXXxZubm7CxsZGjB8/vsx7IIQQ3377rejQoYOwtLQUTk5O4qmnnhJJSUkPfF3GjRtXps7Ste3cuVN0795dWFtbCwcHB/HEE0+IM2fOGByj5PU7ffq0GDVqlHB0dBTt2rW772NW9+td+jUs/Rrf+7xKenke9LMghBA///yz9Dq6uLiI0aNHi2vXrpWp92GvzcN+5qn+Yc8O1Vkajabcngxra2sUFhYiPj4eXbp0walTp1BcXIyOHTsatFMoFGjXrh2OHTsGAHByckKzZs3w3nvv4b333sOBAwdw/PhxLFu2DADw2muvITIyEj179qx0rVqtFv3790eXLl2wZMkSbN26FW+99RaKi4vx9ttvS+2mTJmC1atX47nnnsOMGTNw6dIlfPbZZzh27Bj2798PCwsLqe25c+cwatQoTJkyBZMmTULLli2Rk5ODHj164OzZs5gwYQI6dOiAtLQ0bNq0CdeuXYOrqyt0Oh2eeOIJ7Nu3D5MnT0arVq1w6tQpfPzxxzh//jw2btxoUPu+ffsQHR2NF198EXZ2dvj0008xbNgwJCUlwcXFBVFRUTh//jx++OEHfPzxx3B1dQUAuLm5Vfj1+euvvxAZGYmQkBC89dZbkMvlWLVqFfr06YO///4bnTt3fugx3nnnHSgUCrz66qvQaDRV6mW5cOEChg8fjokTJ2LcuHH45ptvMH78eISEhKB169bo2bMnZsyYgU8//RSvv/46WrVqBQDSv/ezaNEiWFlZ4d///jcuXLiAZcuWwcLCAnK5HLdv38b8+fNx8OBBrF69Gn5+fpg3b55034ULF+LNN9/EyJEj8fzzz+PmzZtYtmwZevbsiWPHjt2312bKlClo1KgR3nvvPcyYMQOdOnWCh4cHAGDHjh2IjIxE06ZNMX/+fOTn52PZsmXo1q0bjh49iiZNmhgca8SIEfD398d7770HIUSlX9f7edjrXZ7//Oc/yMzMxLVr1/Dxxx8DAGxtbQ3alPezUPL/qlOnTli0aBFSUlKwdOlS7N+/3+B1rMhrUx0/81THGDttEd1PcHCwaNGihSguLpa2aTQa4ePjIwCIX375RQhxd4zF3r17yxxjxIgRQqVSSbd37twpnJycpL/UZs6cKYQQYv/+/cLKykpcvny50nWW/IX90ksvSdt0Op3UA1XS4/L3338LAOL77783uP/WrVvLbPf19RUAxNatWw3azps3TwAQ0dHRZeoo6UX69ttvhVwuF3///bfB/hUrVggAYv/+/dI2AEKhUIgLFy5I206cOCEAiGXLlknbHjR+4WE9OzqdTvj7+4uIiAiDnq68vDzh5+cnHn/88TLHLK3keE2bNhV5eXkG+yrb03Dvz0lqaqpQKpXiX//6l7TtQWN27tezExQUZDBuadSoUUImk4nIyEiD+4eFhRmMRbl8+bIwMzMTCxcuNGh36tQpYW5uXmb7vUoef926dQbb27VrJ9zd3cWtW7ekbSdOnBByuVyMHTtW2lby+o0aNeqBj3Nv+3s9yutdXk/g/cbs3O9nobCwULi7u4ugoCCRn58vbd+8ebMAIObNmydtq+hrwzE7poUnOanOevHFF3H+/HlMnDgRZ86cQXx8PMaOHYvk5GQAQH5+vsG/5Y0dsbS0lPYDQJ8+fZCUlISDBw8iKSkJH3/8MXQ6HWbMmIF//etf8PX1xfLlyxEQEICWLVtixYoVFa53+vTp0vcymQzTp09HYWEhduzYAQBYt24dHBwc8PjjjyMtLU36CgkJga2tLXbt2mVwPD8/P0RERBhsW79+Pdq2bYuhQ4eWeXyZTCY9TqtWrRAQEGDwOH369AGAMo8THh6OZs2aSbfbtGkDe3t7XLx4scLP/UGOHz+OhIQEPPPMM7h165ZUT25uLvr27Yu9e/dCp9M99Djjxo175DFLgYGB6NGjh3Tbzc0NLVu2fOTnOnbsWINeudDQUAghMGHCBIN2oaGhuHr1KoqLiwHor/zT6XQYOXKkwXulUqng7+9f5r2qiOTkZBw/fhzjx4+Hs7OztL1NmzZ4/PHH8ccff5S5zwsvvFDpx6mImnq97/1ZOHLkCFJTU/Hiiy8ajP8ZOHAgAgIC8PvvvwOo2mtDpoGnsajOeuGFF3D16lV88MEHWLNmDQCgY8eOeO2117Bw4UKpa7vkl55GoylzjPIG9dra2iI0NFS6vWrVKqjVavz73//Gjh07MHv2bHz33XeQyWR45pln0LJlSzz22GMPrFUul6Np06YG21q0aAEA0iXMCQkJyMzMhLu7e7nHKBlsWsLPz69Mm8TERAwbNuyBtSQkJODs2bP37XK/93F8fHzKtHFycsLt27cf+DgVlZCQAED/AXU/mZmZcHJyeuBxyns9Kqumnuu9x3VwcAAAeHt7l9mu0+mQmZkJFxcXJCQkQAgBf3//co9bOkBV1JUrVwAALVu2LLOvVatW2LZtW5lByNXx2panpl7ve+t90HMOCAjAvn37Htrufq8NmQaGHarTFi5ciFdffRWnT5+Gg4MDgoOD8frrrwO4GyY8PT0BQOrxKS05ORleXl73PX5WVhb+85//4MMPP4SNjQ1++OEHDB8+HEOGDAEADB8+HN9///1Dw05F6HQ6uLu74/vvvy93/73hpKq9GDqdDsHBwfjoo4/K3X/vB7CZmVm57UQ1jd0o6bX54IMP0K5du3Lb3DsmozzlvR4lvVn30mq15W6vqed6v+M+7PF0Oh1kMhm2bNlSbtuKvC7VoaI/a3Xl9a6LVyVS3cawQ3Wek5MTunfvLt3esWMHGjdujICAAABAUFAQzM3NceTIEYwcOVJqV1hYiOPHjxtsu9fbb78NPz8/jB49GgBw48YNtG/fXtrv5eVVoRlpdTodLl68KAUwADh//jwASINBmzVrhh07dqBbt25V/mXdrFkzxMfHP7TNiRMn0Ldv3/t+OFXWoxyn5BSZvb09wsPDq6WeEiW9QRkZGQYDeUv+gq+K6nrNKqJZs2YQQsDPz8/gZ+dRlEwqeO7cuTL7/vnnH7i6ula556ImXu/yVPY9KP2cS07Xljh37py0vzKvTW3+HFDN45gdqld++uknHD58GDNnzpTm1XBwcEB4eDi+++47ZGdnS22//fZb5OTkYMSIEeUe6/z58/jss8+wdOlS6Rebh4cH/vnnH6nN2bNnoVKpKlTbZ599Jn0vhMBnn30GCwsL9O3bFwAwcuRIaLVavPPOO2XuW1xcXKGZWocNG4YTJ05gw4YNZfaV/LU8cuRIXL9+HV999VWZNvn5+cjNza3Q8ymt5AOgKrPJhoSEoFmzZvjwww/LzGgNADdv3qz0MUuUBKm9e/dK23Jzc6XTnlXxKM+1sqKiomBmZoYFCxaU6e0QQuDWrVuVPqanpyfatWuHNWvWGDyH+Ph4/PnnnxgwYECV662J17s8NjY2lZrBvGPHjnB3d8eKFSsMTmdv2bIFZ8+excCBAwFU7rWpzZ8Dqnns2aE6a+/evXj77bfRr18/uLi44ODBg1i1ahX69++Pl19+2aDtwoUL0bVrV/Tq1QuTJ0/GtWvX8N///hf9+vVD//79yz3+K6+8gqeeesrgsufhw4fjySeflE6V/fbbb9i8efNDa7W0tMTWrVsxbtw4hIaGYsuWLfj999/x+uuvS6enevXqhSlTpmDRokU4fvw4+vXrBwsLCyQkJGDdunVYunQphg8f/sDHmT17Nn755ReMGDECEyZMQEhICNLT07Fp0yasWLECbdu2xZgxY/Dzzz/jhRdewK5du9CtWzdotVr8888/+Pnnn7Ft27Yyl+k/TEhICAD9ZcFPP/00LCwsMHjw4Ar1EMjlcnz99deIjIxE69at8dxzz6FRo0a4fv06du3aBXt7+3KX7aiIfv36wcfHBxMnTsTs2bNhZmaGb775Bm5ubkhKSqrSMdu1awczMzO8//77yMzMhFKpRJ8+fe471upRNGvWDO+++y7mzp2Ly5cvY8iQIbCzs8OlS5ewYcMGTJ48Ga+++mqlj/vBBx8gMjISYWFhmDhxonR5tYODA+bPn1/lemvi9S5PSEgIfvrpJ8yaNQudOnWCra0tBg8efN/2FhYWeP/99/Hcc8+hV69eGDVqlHTpeZMmTfDKK69IbSv62jzKzzzVQUa6CozooS5cuCD69esnXF1dhVKpFAEBAWLRokX3na7/77//Fl27dhWWlpbCzc1NTJs2TWRlZZXb9vfffxe2trbixo0bZfYtWrRIeHl5CU9PT/H+++8/tM7yJhX08PAQb731lsEU+CW+/PJLERISIqysrISdnZ0IDg4Wr732mkEtJROylefWrVti+vTpolGjRtKEgePGjRNpaWlSm8LCQvH++++L1q1bC6VSKZycnERISIhYsGCByMzMlNrhzqSC97r3cnIhhHjnnXdEo0aNhFwur9KkgseOHRNRUVHCxcVFKJVK4evrK0aOHCl27tx5v5fW4Hj3Xl5dIi4uToSGhgqFQiF8fHzERx999MBJ7u517+XkQgjx1VdfiaZNmwozM7MKTSp4b20lj3/48GGD7SWXbpeeAFIIIdavXy+6d+8ubGxshI2NjQgICBDTpk0T586dq/Jrs2PHDtGtWzdhZWUl7O3txeDBg+87qeC99TxIdb/e5f285OTkiGeeeUY4OjqWO6ng/X4WfvrpJ9G+fXuhVCqFs7PzfScVrMhrI8T9f+ap/pEJUY0zSBE1QOPHj8cvv/xS7ikaIiIyPo7ZISIiIpPGsENEREQmjWGHiIiITBrH7BAREZFJY88OERERmTSGHSIiIjJpnFQQ+qn+b9y4ATs7O04RTkREVE8IIZCdnQ0vLy9pVv3yMOxAvx7SvYsjEhERUf1w9epVNG7c+L77GXYA2NnZAdC/WPb29kauhoiIiCoiKysL3t7e0uf4/TDs4O7qtvb29gw7RERE9czDhqBwgDIRERGZNIYdIiIiMmkMO0RERGTSOGangnQ6HQoLC41dBtUQhULxwMsWiYio/mLYqYDCwkJcunQJOp3O2KVQDZHL5fDz84NCoTB2KUREVM0Ydh5CCIHk5GSYmZnB29ubf/2boJJJJZOTk+Hj48OJJYmITAzDzkMUFxcjLy8PXl5esLa2NnY5VEPc3Nxw48YNFBcXw8LCwtjlEBFRNWI3xUNotVoA4OkNE1fy/pa830REZDoYdiqIpzZMG99fIiLTxbBDREREJo1hh4iIiEwaww4RERGZNIYdIiIiqjEFxQU4oj5i1BoYdkxU7969MWPGDLz22mtwdnaGSqXC/PnzAQCXL1+GTCbD8ePHpfYZGRmQyWTYvXs3AGD37t2QyWTYtm0b2rdvDysrK/Tp0wepqanYsmULWrVqBXt7ezzzzDPIy8szeNzp06dj+vTpcHBwgKurK958800IIQAAb7/9NoKCgsrU265dO7z55ps19noQEVHtOnvrLBYeXIg+6/pg0p+TkF6QbrRaOM9OJQkhkF9knMuTrSzMKnXV0Jo1azBr1izExsYiJiYG48ePR7du3eDv71/hY8yfPx+fffYZrK2tMXLkSIwcORJKpRJr165FTk4Ohg4dimXLlmHOnDkGjztx4kQcOnQIR44cweTJk+Hj44NJkyZhwoQJWLBgAQ4fPoxOnToBAI4dO4aTJ08iOjq64i8GERHVOZmaTPxx6Q9sSNiAs+lnpe2eNp5IykqCs6WzUepi2Kmk/CItAudtM8pjn3k7AtaKir9lbdq0wVtvvQUA8Pf3x2effYadO3dWKuy8++676NatGwBg4sSJmDt3LhITE9G0aVMAwPDhw7Fr1y6DsOPt7Y2PP/4YMpkMLVu2xKlTp/Dxxx9j0qRJaNy4MSIiIrBq1Sop7KxatQq9evWSjklERPWHTuhwSH0IGxI2YMeVHSjU6deRtJBboI9PH0Q1j0KoZyjM5GZGq7HOnMZavHgxZDIZZs6cKW0rKCjAtGnT4OLiAltbWwwbNgwpKSkG90tKSsLAgQNhbW0Nd3d3zJ49G8XFxbVcfd3Upk0bg9uenp5ITU2t8jE8PDxgbW1tEEo8PDzKHLNLly4GPVBhYWFISEiQJuybNGkSfvjhBxQUFKCwsBBr167FhAkTKlUXEREZlzpXjRUnVmBA9ABM+nMS/rj0Bwp1hfB38secTnPw14i/8GGvD9G1UVejBh2gjvTsHD58GF988UWZD+dXXnkFv//+O9atWwcHBwdMnz4dUVFR2L9/PwD9bLcDBw6ESqXCgQMHkJycjLFjx8LCwgLvvfdejdRqZWGGM29H1MixK/LYlXHvsgcymQw6nU5a36tkHA0AFBUVPfQYMpnsvsesjMGDB0OpVGLDhg1QKBQoKirC8OHDK3UMIiKqfUXaIuy6ugvRF6IRcyMGOqH//W9rYYtIv0hE+UehtUvrOjdRq9HDTk5ODkaPHo2vvvoK7777rrQ9MzMTK1euxNq1a9GnTx8A+tMdrVq1wsGDB9GlSxf8+eefOHPmDHbs2AEPDw+0a9cO77zzDubMmYP58+fXyBIPMpmsUqeS6iI3NzcAQHJyMtq3bw8ABoOVH1VsbKzB7YMHD8Lf3x9mZvqwZm5ujnHjxmHVqlVQKBR4+umnYWVlVW2PT0RE1evC7QuIvhCNzYmbcVtzW9oe4hGCKP8oPO77OKzM6+7vcaN/ak+bNg0DBw5EeHi4QdiJi4tDUVERwsPDpW0BAQHw8fFBTEwMunTpgpiYGAQHB8PDw0NqExERgalTp+L06dPSBzkZsrKyQpcuXbB48WL4+fkhNTUVb7zxRrUdPykpCbNmzcKUKVNw9OhRLFu2DP/9738N2jz//PNo1aoVAEg9dUREVHfkFOZg6+Wt2JCwASfTTkrb3azc8GTzJzGk+RD42vsascKKM2rY+fHHH3H06FEcPny4zD61Wg2FQgFHR0eD7R4eHlCr1VKb0kGnZH/JvvvRaDTQaDTS7aysrKo+hXrrm2++wcSJExESEoKWLVtiyZIl6NevX7Uce+zYscjPz0fnzp1hZmaGl19+GZMnTzZo4+/vj65duyI9PR2hoaHV8rhERPRohBA4mnoU0QnR2H5lO/KL8wEA5jJz9GzcE1H+UejWqBvM5UbvK6kUo1V79epVvPzyy9i+fTssLS1r9bEXLVqEBQsW1Opj1raS+XJK27hxo/R9q1atcODAAYP9pcfw9O7d2+A2AIwfPx7jx4832DZ//nxp/p4SFhYW+OSTT7B8+fL71ieEwI0bN/Diiy8++IkQEVGNS8tPw68XfsXGCxtxOeuytL2JfRNE+UdhcLPBcLVyNV6Bj8hoYScuLg6pqano0KGDtE2r1WLv3r347LPPsG3bNhQWFiIjI8OgdyclJQUqlQoAoFKpcOjQIYPjllytVdKmPHPnzsWsWbOk21lZWfD29q6Op0UVcPPmTfz4449Qq9V47rnnjF0OEVGDVKwrxt/X/kb0hWj8fe1vaIX+ilkrcytENIlAlH8U2rm1q3ODjavCaGGnb9++OHXqlMG25557DgEBAZgzZw68vb1hYWGBnTt3YtiwYQCAc+fOISkpCWFhYQD0lzQvXLgQqampcHd3BwBs374d9vb2CAwMvO9jK5VKKJXKGnpm9DDu7u5wdXXFl19+CScnJ2OXQ0TUoFzOvIwNFzZgU+ImpOWnSdvbuLVBVPMo9PfrDxsLGyNWWP2MFnbs7OzKLBtgY2MDFxcXafvEiRMxa9YsODs7w97eHi+99BLCwsLQpUsXAEC/fv0QGBiIMWPGYMmSJVCr1XjjjTcwbdo0hhkjKe/02b3uPT1GREQ1K68oD9uvbEd0QjSOph6VtjtbOmNw08EY6j8UzRybGbHCmlWnRxh9/PHHkMvlGDZsGDQaDSIiIvD5559L+83MzLB582ZMnToVYWFhsLGxwbhx4/D2228bsWoiIiLjE0IgPi0e0ReiseXSFuQW5QIA5DI5unl1Q5R/FHo17gULM4uHHKn+kwn+mY2srCw4ODggMzMT9vb2BvsKCgpw6dIl+Pn51fpAaqo9fJ+JyFTcLriN3xJ/w4YLG3Ah44K0vbFtYwz1H4onmj0Blc39x7XWJw/6/C6tTvfsEBER0cNpdVrEJMcgOiEau67uQrFOv2yS0kyJcN9wRDWPQkdVR8hldWaVqFrFsENERFRPXcu+ho0XNuLXxF+hzr07v1wr51aI8o/CgKYDYK+4f49HQ8GwQ0REVI9otBrsvLIT0ReiEZt8d3kee4U9BjYdiCj/KAQ4BxixwrqHYYeIiKge+Cf9H0QnROP3i78jq/DuzP+hnqGIah6Fvr59oTTjlcjlYdihOmH+/PlYvnw5UlNTsWHDBmzcuBEZGRkGsz4TETU0WYVZ+OPiH4hOiMbZ9LPSdpWNCkOaD8GQ5kPQyLaRESusHxh2TFTv3r3Rrl07fPLJJ8Yu5aHOnj2LBQsWYMOGDejSpQucnJwYcoiowdIJHQ6rDyM6IRo7k3ZCo9Wv5WguN0cf7z6I8o9CF88uMJObGbnS+oNhh4xGq9VCJpMhMTERAPDkk0+axLTkRERVoc5VS+tTXcu5Jm1v7tgcUf5RGNR0EJwsOet8VTTMa9BM3Pjx47Fnzx4sXboUMpkMMpkMly9fRnx8PCIjI2FrawsPDw+MGTMGaWl3pwrv3bs3ZsyYgddeew3Ozs5QqVQGi3wKITB//nz4+PhAqVTCy8sLM2bMkPbfvn0bY8eOhZOTE6ytrREZGYmEhARp/+rVq+Ho6IhNmzYhMDAQSqUSEyZMwODBgwEAcrn8vmFHo9FgxowZcHd3h6WlJbp3747Dhw9L+zt27IgPP/xQuj1kyBBYWFggJycHAHDt2jXIZDJcuHChzLGJiIylSFuE7Ve2Y+qOqYhYH4HPjn+GaznXYGNhg+EthmPtgLWIfiIaYwLHMOg8AoadyhICKMw1zlcF539cunQpwsLCMGnSJCQnJyM5ORl2dnbo06cP2rdvjyNHjmDr1q1ISUnByJEjDe67Zs0a2NjYIDY2FkuWLMHbb7+N7du3AwDWr1+Pjz/+GF988QUSEhKwceNGBAcHS/cdP348jhw5gk2bNiEmJgZCCAwYMABFRUVSm7y8PLz//vv4+uuvcfr0aXz66adYtWoVAEi1lue1117D+vXrsWbNGhw9ehTNmzdHREQE0tPTAQC9evWSlqoQQuDvv/+Go6Mj9u3bBwDYs2cPGjVqhObNm1foNSQiqkmJGYn44PAHCP8lHLN2z8K+6/ugEzp0cO+Ad7u9i79G/IW3wt5CsFswe7yrAU9jVVZRHvCel3Ee+/UbgOLhi7M5ODhAoVDA2tpaWv393XffRfv27fHee+9J7b755ht4e3vj/PnzaNGiBQCgTZs2eOuttwAA/v7++Oyzz7Bz5048/vjjSEpKgkqlQnh4OCwsLODj44POnTsDABISErBp0ybs378fXbt2BQB8//338Pb2xsaNGzFixAgAQFFRET7//HO0bdtWqqNkVfv7rVSfm5uL5cuXY/Xq1YiMjAQAfPXVV9i+fTtWrlyJ2bNno3fv3li5ciW0Wi3i4+OhUCjw1FNPYffu3ejfvz92796NXr16VfilJiKqbrlFudh6aSuiL0Tj5M2T0nZXK1c82exJDGk+BE0cmhivQBPGsNNAnDhxArt27YKtrW2ZfYmJiQZhpzRPT0+kpqYCAEaMGIFPPvkETZs2Rf/+/TFgwAAMHjwY5ubmOHv2LMzNzREaGird18XFBS1btsTZs3evIFAoFGUe42ESExNRVFSEbt26SdssLCzQuXNn6dg9evRAdnY2jh07hgMHDqBXr17o3bs3Fi9eDEDfszN79uxKPS4R0aMSQuD4zeOITojGtsvbkF+cDwAwk5mhZ+OeiPKPQvdG3WEu58dxTeKrW1kW1voeFmM9dhXl5ORg8ODBeP/998vs8/T0vPsQFoYLwslkMuh0OgCAt7c3zp07hx07dmD79u148cUX8cEHH2DPnj0VrsPKyqpGumQdHR3Rtm1b7N69GzExMXj88cfRs2dPPPXUUzh//jwSEhLYs0NEtSYtPw2bEjdhQ8IGXM66LG1vYt9EWp/K1crVeAU2MAw7lSWTVehUkrEpFApotVrpdocOHbB+/Xo0adIE5uZVf9utrKwwePBgDB48GNOmTUNAQABOnTqFVq1aobi4GLGxsdJprFu3buHcuXMIDAx8pOfSrFkzKBQK7N+/H76+vgD0p8MOHz6MmTNnSu169eqFXbt24dChQ1i4cCGcnZ3RqlUrLFy4EJ6enlLvFRFRTSjWFWPf9X2ITojG3mt7oRX638FW5lbo59sPUf5RaO/enmNwjIBhx0Q1adIEsbGxuHz5MmxtbTFt2jR89dVXGDVqlHS11YULF/Djjz/i66+/hpnZw+drWL16NbRaLUJDQ2FtbY3vvvsOVlZW8PX1hYuLC5588klMmjQJX3zxBezs7PDvf/8bjRo1wpNPPvlIz8XGxgZTp07F7Nmz4ezsDB8fHyxZsgR5eXmYOHGi1K53795YtmwZ3NzcEBAQIG377LPPpDFDRETV7UrWFWxI2IBNiZtwM/+mtL2NaxsM9R+K/k36w1ZRdggB1R6GHRP16quvYty4cQgMDER+fj4uXbqE/fv3Y86cOejXrx80Gg18fX3Rv39/yOUVuyjP0dERixcvxqxZs6DVahEcHIzffvsNLi4uAIBVq1bh5ZdfxqBBg1BYWIiePXvijz/+KHNqrCoWL14MnU6HMWPGIDs7Gx07dsS2bdvg5HT3UswePXpAp9MZnK7q3bs3li5dit69ez9yDUREJfKL87H9ynZEJ0QjLiVO2u6kdMKgZoMQ1TwKzZ149WddIROigtczm7CsrCw4ODggMzMT9vaGq8MWFBTg0qVL8PPzg6WlpZEqpJrG95mIHkYIgdO3TiM6IRpbLm1BTpF+Hi8ZZOjaqCuimkfhMe/HYGH26H/gUcU86PO7NPbsEBERPcDtgtvYfHEzNlzYgITbdydKbWTbCEObD8WTzZ+Eyqb8qTOobmDYISIiuodWp8XB5IOITojGrqu7UKTTT46qkCsQ7huOKP8odFJ1glzGuXnrA4YdIiKiO67nXMfGCxux8cJGqHPV0vZWzq0w1H8oBvgNgIPSwYgVUlUw7BARUYOm0WrwV9JfiE6IRmxyLAT0Q1ntFHYY6DcQUf5RaOXSyshV0qNg2CEiogbpXPo5RCdEY/PFzcgqzJK2h6pCMdR/KPr69IWlOS9YMAUMO0RE1GBkFWZhy8UtiL4QjTO3zkjbPaw9MKT5EDzZ/El423kbsUKqCQw7RERk0nRChyPqI9hwYQO2X9kOjVYDADCXm+Mx78cQ5R+FMM8wmMkfPrkq1U8MO0REZJJSclPwa+Kv2JCwAddyrknbmzs2x9DmQzGo2SA4WzobsUKqLQw7RERkMoq0RdhzbQ+iE6Kx/8Z+6IR+IWMbCxv0b9IfUf5RCHYN5vpUDQzDjgkbP348MjIysHHjRmOXQkRUoy5mXER0QjR+u/gb0gvSpe0d3DtgqP9Q9PPtB2sLayNWSMbEsGPCli5dCq4GQkSmKrcoF9sub0N0QjRO3DwhbXexdMETzZ/A0OZD4efgZ8QKqa5g2DFhDg6c+IqITIsQAidunkB0QjS2Xt6K/OJ8AICZzAw9GvfA0OZD0aNxD1jIuT4V3cV5rk3Y+PHjMWTIEADA1q1b0b17dzg6OsLFxQWDBg1CYmKi1Pb//u//YGtri4SEu+u+vPjiiwgICEBeXl5tl05EZCAtPw2r4lfhyV+fxJgtY7DhwgbkF+fD194XMzvMxPbh27GszzL08enDoENlsGenkoQQ0l8Stc3K3KrKg+pyc3Mxa9YstGnTBjk5OZg3bx6GDh2K48ePQy6XY+zYsdi8eTNGjx6NAwcOYNu2bfj6668RExMDa2ue5yai2lesK8b+6/sRnRCNvdf2olgUA9D/Lnzc93FE+Uehg3sHDjamh2LYqaT84nyErg01ymPHPhNb5QF2w4YNM7j9zTffwM3NDWfOnEFQUBAA4IsvvkCbNm0wY8YMREdHY/78+QgJCXnkuomIKiMpKwkbLmzApgubkJqfKm0Pdg3GUP+hiGwSCVuFrRErpPqGYaeBSEhIwLx58xAbG4u0tDTodPrLMZOSkqSw4+TkhJUrVyIiIgJdu3bFv//9b2OWTEQNSH5xPnZc2YHohGgcSTkibXdUOmJQ00GI8o+Cv5O/ESuk+syoYWf58uVYvnw5Ll++DABo3bo15s2bh8jISABA7969sWfPHoP7TJkyBStWrJBuJyUlYerUqdi1axdsbW0xbtw4LFq0CObmNfPUrMytEPtMbI0cuyKPXVWDBw+Gr68vvvrqK3h5eUGn0yEoKAiFhYUG7fbu3QszMzMkJycjNzcXdnZ2j1o2EVG5hBA4c+sMohOi8celP5BTlAMAkEGGrl5dMdR/KB7zfgwKM4WRK6X6zqhhp3Hjxli8eDH8/f0hhMCaNWvw5JNP4tixY2jdujUAYNKkSXj77bel+5QeP6LVajFw4ECoVCocOHAAycnJGDt2LCwsLPDee+/VSM0ymazezdVw69YtnDt3Dl999RV69OgBANi3b1+ZdgcOHMD777+P3377DXPmzMH06dOxZs2a2i6XiExcRkEGNl/cjA0XNuD87fPS9ka2jfBk8ycxpNkQeNp6GrFCMjVGDTuDBw82uL1w4UIsX74cBw8elMKOtbU1VCpVuff/888/cebMGezYsQMeHh5o164d3nnnHcyZMwfz58+HQsG/BgD96SkXFxd8+eWX8PT0RFJSUplTVNnZ2RgzZgxmzJiByMhING7cGJ06dcLgwYMxfPhwI1VORKZACIGk7CTEJsci5kYM9lzbgyJdEQBAIVegr29fRPlHobOqM+QyXiRM1a/OjNnRarVYt24dcnNzERYWJm3//vvv8d1330GlUmHw4MF48803pd6dmJgYBAcHw8PDQ2ofERGBqVOn4vTp02jfvn25j6XRaKDRaKTbWVlZNfSs6ga5XI4ff/wRM2bMQFBQEFq2bIlPP/0UvXv3ltq8/PLLsLGxkXrEgoOD8d5772HKlCkICwtDo0aNjFQ9EdVHyTnJiFXH4rD6MGKTY5GSl2KwP8A5AEObD8XApgPhoOScYFSzjB52Tp06hbCwMBQUFMDW1hYbNmxAYGAgAOCZZ56Br68vvLy8cPLkScyZMwfnzp1DdHQ0AECtVhsEHQDSbbVafd/HXLRoERYsWFBDz6ju0Gg0sLXVX7EQHh6OM2fOGOwvPbvyN998U+b+s2bNwqxZs2q2SCIyCWn5aVKwOaQ+hKvZVw32W8gt0NatLTp7dkavxr0Q6BJopEqpITJ62GnZsiWOHz+OzMxM/PLLLxg3bhz27NmDwMBATJ48WWoXHBwMT09P9O3bF4mJiWjWrFmVH3Pu3LkGH+JZWVnw9vZ+pOdRlxQXF+P8+fOIiYnBlClTjF0OEZmgTE0mjqQcwaHkQzikPoQLGRcM9stlcgS5BKGzZ2d0VnVGO/d2j3SRBdGjMHrYUSgUaN68OQAgJCQEhw8fxtKlS/HFF1+UaRsaqp/f5sKFC2jWrBlUKhUOHTpk0CYlRd9Ver9xPgCgVCqhVCqr6ynUOfHx8ejatSsee+wxvPDCC8Yuh4hMQF5RHo6mHsWh5EOIVcfi7K2zEDBcey/AOQCdVfpw08GjA+wUvJqT6gajh5176XQ6g/E0pR0/fhwA4OmpH6UfFhaGhQsXIjU1Fe7u7gCA7du3w97eXjoV1hC1a9eOSzwQ0SPRaDU4kXoCsepYHEo+hPi0eGkG4xJ+Dn7orOqMUM9QdPToCCdLJyNVS/RgRg07c+fORWRkJHx8fJCdnY21a9di9+7d2LZtGxITE7F27VoMGDAALi4uOHnyJF555RX07NkTbdq0AQD069cPgYGBGDNmDJYsWQK1Wo033ngD06ZNM+meGyKi6lakK8LptNM4pD6EQ8mHcCz1GAp1hvNwedl4IdQzVDo15W7tbqRqiSrHqGEnNTUVY8eORXJyMhwcHNCmTRts27YNjz/+OK5evYodO3bgk08+QW5uLry9vTFs2DC88cYb0v3NzMywefNmTJ06FWFhYbCxscG4ceMM5uWpLqUH85Lp4ftLDY1O6HAu/RwOqQ8hNjkWcSlxyCs27BF2tXKVem46qzqjsV1jI1VL9Ghkgr/lkZWVBQcHB2RmZsLe3t5gX1FRES5cuAAvLy84OPDySFOVmZmJGzduoHnz5rCw4IrJZHqEELiUeUk6LXU45TAyNZkGbRyUDtKYm86eneFn78dFNqlOe9Dnd2l1bsxOXWNubg5ra2vcvHkTFhYWkMs54ZWp0el0uHnzJqytrWtsmREiY7iWfU3quTmkPoS0/DSD/dbm1uio6ij13rRwasFJ/cgk8Tf7Q8hkMnh6euLSpUu4cuWKscuhGiKXy+Hj48O/YqleS8lN0Y+5uTPu5kbuDYP9SjMl2rm3Q6hKP+4m0CUQFnL2ZJLpY9ipAIVCAX9//zKLZpLpUCgU7LWjeud2wW0cVh+Wem8uZ1022G8uM0ewW7DUc9PGrQ2UZrx4gxoehp0KksvlsLS0NHYZRNSA5RTmIC4lThp3c+72OYP9MsjQyqWV1HPTwb1DvVu4mKgmMOwQEdVR+cX5OJ56XDotdfrWaWiF1qBNc8fm0tVSIR4hXGeKqBwMO0REdUSRtggn005K4ebEzRPS6uAlfOx80NmzM0JVoeio6ghXK1cjVUtUfzDsEBEZiVanxdn0s9LVUsdSjyG/ON+gjYe1h9Rz01nVGZ62nkaqlqj+YtghIqolOqHDhYwL0vpSceo4ZBdlG7RxtnRGZ1VndFJ1QqhnKHzseJUg0aNi2CEiqiFCCCRlJ0k9N4fVh5FekG7Qxs7CDh1VHaXem+aOzRluiKoZww4RUTVKzklGrDoWh9WHEZsci5S8FIP9VuZW6ODeQRp3E+AcADO5mZGqJWoYGHaIiB5BWn6aFGwOqQ/havZVg/0Wcgu0dWsrhZtg12BYmHEiP6LaxLBDRFQJmZpMHEk5gkPJ+pmKL2RcMNgvl8kR5BIkrQzezr0drMytjFQtEQEMO0RED5RXlIejqUelQcVnb52FgOH6yQHOAdLVUh08OsBOYWekaomoPAw7RESlaLQanLx5UjotdermKRSLYoM2fg5+0hIMHT06wsnSyUjVElFFMOwQUYNWpCvC6bTT0kR+x28eh0arMWjjZeOlv1rqzqkpd2t3I1VLRFXBsENEDYpO6HAu/Zy0eGZcShzyivMM2rhauUo9N51VndHYrrGRqiWi6sCwQ0QmTQiBS5mXpMUzD6ccRqYm06CNg9JBGnPT2bMz/Oz9ONcNkQlh2CGqZ0pOu1iZW0Flo4K9wp4fzPe4ln1N6rk5pD6EtPw0g/3W5tboqOoo9d60cGoBuUxupGqJqKYx7BDVI1ezr2LO3jk4lXZK2mZtbg1PG0+obFXwtPHUf2+jkv5VWatMfl6X1LxUaczNIfUhXM+5brBfaaZEO/d2CFXpx90EugTCQm7arwkR3cWwQ1RPbL20FQtiFiCnKAdW5lawNLPEbc1t5BXnITEzEYmZieXeTwYZXK1c9cHH5m4gKglIKmsVnC2d61Xv0O2C2zisPiz13lzOumyw31xmjmC3YKnnpo1bGyjNlMYploiMjmGHqI7LL87H+4fex/qE9QCA9u7t8X6P9+Fp64n84nyoc9XSV3JusvSVkpuC5NxkaLQa3My/iZv5Nw16hEpTmikNwlB5/xpzYrycwhzEpcRJ427O3T5nsF8GGVq5tJJ6bjq4d4C1hbWRqiWiukYmhBAPb2basrKy4ODggMzMTNjb2xu7HCLJ+dvnMXvPbFzMvAgZZJjUZhKmtp0Kc3nF/k4RQuC25jaSc5OhztGHoZJQVPLvzfybFTqWo9LRIABJp8nu3Ha1cq22NZ7yi/NxPPW4dGrq9K3T0AqtQZvmjs2lq6VCPELgoHSolscmovqjop/fDDtg2KG6RwiBdefXYcnhJdBoNXCzcsOiHosQ6hla7Y9VpC1CSl6KQQAq3Tt0I+dGmUuzy2MuM4eHjUeZ02Wle4fuN7NwkbYIJ9NOSuHmxM0TKNIVGbTxsfOR1pfqqOoIVyvXann+RFR/VfTzm6exiOqYTE0mFsQswPYr2wEA3Rt1x8LuC+Fs6Vwjj2dhZoHGdo3vO5eMEALZRdlIzinbK1Tyb2peKopFMa7nXC8zOLg0WwtbgyDkoHTA6VuncSz1GPKL8w3aelh7SD03nVWd4WnrWa3Pm4gaDvbsgD07VHccTz2OOXvn4EbuDZjLzTGzw0yMCRxT5y+LLtYVIy0/zbBn6E44Uufpt907t829nC2d0VnVGZ1UnRDqGQofO596NWiaiGofe3aI6hGd0OGb+G/w2bHPoBVaNLZtjA96fYAg1yBjl1Yh5nJz6fRVO7Qrt01eUZ5BGFLnqpGWnwZ/J390VnVGc8fmDDdEVCMYdoiMLC0/DXP/nouDyQcBAJF+kZjXZR5sFbZGrqx6WVtYo6ljUzR1bGrsUoiogWHYITKi/df34/V9ryO9IB1W5laY23kuhjQfwh4OIqJqxLBDZARF2iIsO7YMq06vAgC0cGqBD3p+wF4PIqIawLBDVMvuXfLhqZZP4dWOr8LS3NLIlRERmSaGHaJaVHrJBzuFHd7p+g76+vY1dllERCbNqNezLl++HG3atIG9vT3s7e0RFhaGLVu2SPsLCgowbdo0uLi4wNbWFsOGDUNKSorBMZKSkjBw4EBYW1vD3d0ds2fPRnFxcW0/FaIHyi/Ox/wD8zF772zkFOWgnVs7/DL4FwYdIqJaYNSw07hxYyxevBhxcXE4cuQI+vTpgyeffBKnT58GALzyyiv47bffsG7dOuzZswc3btxAVFSUdH+tVouBAweisLAQBw4cwJo1a7B69WrMmzfPWE+JqIzzt89j1OZRWJ+wXr/kQ/AkrOq/Cl62XsYujYioQahzkwo6Ozvjgw8+wPDhw+Hm5oa1a9di+PDhAIB//vkHrVq1QkxMDLp06YItW7Zg0KBBuHHjBjw8PAAAK1aswJw5c3Dz5k0oFIoKPSYnFaSacO+SD65WrljcY3GNLPlARNQQVfTzu85My6rVavHjjz8iNzcXYWFhiIuLQ1FREcLDw6U2AQEB8PHxQUxMDAAgJiYGwcHBUtABgIiICGRlZUm9Q0TGkFWYhX/t+RfeOfgONFoNujfqjl8G/8KgQ0RkBEYfoHzq1CmEhYWhoKAAtra22LBhAwIDA3H8+HEoFAo4OjoatPfw8IBarQYAqNVqg6BTsr9k3/1oNBpoNBrpdlZWVjU9G6J7lnyQmWNmSP1Y8oGIyFQZPey0bNkSx48fR2ZmJn755ReMGzcOe/bsqdHHXLRoERYsWFCjj0ENT31f8oGIyFQZ/U9NhUKB5s2bIyQkBIsWLULbtm2xdOlSqFQqFBYWIiMjw6B9SkoKVCoVAEClUpW5Oqvkdkmb8sydOxeZmZnS19WrV6v3SVGDk5afhinbp2Dp0aXQCi0im0Ri3eB1DDpERHWA0cPOvXQ6HTQaDUJCQmBhYYGdO3dK+86dO4ekpCSEhYUBAMLCwnDq1CmkpqZKbbZv3w57e3sEBgbe9zGUSqV0uXvJF1FV7b++H8M2DcPB5IOwNLPE213fxvs93ze5ta2IiOoro57Gmjt3LiIjI+Hj44Ps7GysXbsWu3fvxrZt2+Dg4ICJEydi1qxZcHZ2hr29PV566SWEhYWhS5cuAIB+/fohMDAQY8aMwZIlS6BWq/HGG29g2rRpUCqVxnxq1AAU6e4s+RCvX/LB38kfH/b8kEs+EBHVMUYNO6mpqRg7diySk5Ph4OCANm3aYNu2bXj88ccBAB9//DHkcjmGDRsGjUaDiIgIfP7559L9zczMsHnzZkydOhVhYWGwsbHBuHHj8PbbbxvrKVEDcS37GubsnYOTaScBcMkHIqK6rM7Ns2MMnGeHKmPr5a1YcODukg9vd30b4b7hD78jERFVq4p+fhv9aiyi+iK/OB/vH3of6xPWAwDaubXD+z3f50zIRER1HMMOUQUk3E7A7D2zkZiZCBlkeD74ebzY7kWYy/lfiIioruNvaqIHKG/Jh0U9FqGLZxdjl0ZERBXEsEN0H1mFWZh/YD62X9kOAOjWqBsWdlsIFysXI1dGRESVwbBDVI4TN0/gtT2vSUs+vNzhZYxtPZZLPhAR1UMMO0Sl6IQOq+JXYdmxZdKSD0t6LkGwW7CxSyMioipi2CG6Iy0/Da///TpikmMAAP2b9Me8sHmwU9gZuTIiInoUDDtEAA5cP4C5++YivSAdlmaWmBs6F0ObD4VMJjN2aURE9IgYdqhBK9IV4bNjn+Gb+G8A6Jd8+KDnB2jm2MzIlRERUXVh2KEGi0s+EBE1DAw71CBtu7wN8w/Ml5Z8WNB1AR73fdzYZRERUQ1g2KEGJb84H0sOL8Ev538BALR1a4slPZdwyQciIhPGsEMNxombJzD/wHxcyLggLfkwtd1UWMgtjF0aERHVIIYdMnlHU45ixYkV0iXlXPKBiKhhYdghkySEwJGUI1hxYgUOqQ8BAMxl5hjcbDBe7vAyl3wgImpAGHbIpAghcDD5IFacWIGjqUcBAOZycwxtPhQTgyeikW0jI1dIRES1jWGHTIIQAvtv7MeKEytw4uYJAICF3ALD/IdhYvBEqGxURq6QiIiMhWGH6jUhBPZe24sVJ1Yg/lY8AEBppsSIFiMwvvV4eNh4GLlCIiIyNoYdqpd0QoddV3fhixNf4Gz6WQCAlbkVRrYYifFB4+Fq5WrkComIqK5g2KF6RSd02HFlB744+QXO3z4PQB9yRgWMwtjAsRx4TEREZTDsUL2g1Wmx7fI2fHnySyRmJgIAbCxs8EzAMxgTOAZOlk5GrpCIiOoqhh2q04p1xdhyaQu+PPklLmddBgDYWdjh2cBnMbrVaDgoHYxbIBER1XkMO1QnFemKsDlxM7469RWuZl8FANgr7DE2cCyeafUM7BR2Rq6QiIjqC4YdqlOKtEX4NfFXfH3qa1zPuQ4AcFI6YWzrsRgVMAo2FjZGrpCIiOobhh2qEwq1hdiQsAFfx38Nda4aAOBs6YznWj+HkS1HwtrC2sgVEhFRfVWlsHPp0iX8/fffuHLlCvLy8uDm5ob27dsjLCwMlpaW1V0jmbCC4gKsT1iPb+K/QWpeKgDAzcoNE4ImYFiLYbAytzJyhUREVN9VKux8//33WLp0KY4cOQIPDw94eXnBysoK6enpSExMhKWlJUaPHo05c+bA19e3pmomE5BfnI9159Zh1elVSMtPAwB4WHtgYvBERPlHQWmmNHKFRERkKiocdtq3bw+FQoHx48dj/fr18Pb2Ntiv0WgQExODH3/8ER07dsTnn3+OESNGVHvBVL/lFeXhp3M/YfXp1UgvSAcAeNp44vng5zGk+RAozBRGrpCIiEyNTAghKtJw27ZtiIiIqNBBb926hcuXLyMkJOSRiqstWVlZcHBwQGZmJuzt7Y1djknKKczBj+d+xJrTa5ChyQAANLJthMltJmNw08GwMLMwboFERFTvVPTzu8I9OxUNOgDg4uICFxfOZEtAVmEWvj/7Pb478x2yCrMAAL72vpgUPAkDmg6AhZwhh4iIalaVBigfPXoUFhYWCA4OBgD8+uuvWLVqFQIDAzF//nwoFDwV0dBlajLx7Zlv8f3Z75FTlAMA8HPww+Q2k9G/SX+Yy3khIBER1Q55Ve40ZcoUnD+vX5fo4sWLePrpp2FtbY1169bhtddeq9YCqX65XXAbS48uRb9f+uGLk18gpygHzR2b44OeH2DDExswqOkgBh0iIqpVVQo758+fR7t27QAA69atQ8+ePbF27VqsXr0a69evr/BxFi1ahE6dOsHOzg7u7u4YMmQIzp07Z9Cmd+/ekMlkBl8vvPCCQZukpCQMHDgQ1tbWcHd3x+zZs1FcXFyVp0ZVlJafho+OfISI9RH4+tTXyCvOQ0unlvio90dY/8R69PfrDzO5mbHLJCKiBqhKf2ILIaDT6QAAO3bswKBBgwAA3t7eSEtLq/Bx9uzZg2nTpqFTp04oLi7G66+/jn79+uHMmTOwsbk7U+6kSZPw9ttvS7etre9OMKfVajFw4ECoVCocOHAAycnJGDt2LCwsLPDee+9V5elRJdzMu4lVp1dh3bl1KNAWAAACXQLxQpsX0NtbH1SJiIiMqUphp2PHjnj33XcRHh6OPXv2YPny5QD0kw16eHhU+Dhbt241uL169Wq4u7sjLi4OPXv2lLZbW1tDpVKVe4w///wTZ86cwY4dO+Dh4YF27drhnXfewZw5czh+qAapc9VYFb8Kv5z/BYW6QgBAsGswXmj7Ano06sGQQ0REdUaVTmN98sknOHr0KKZPn47//Oc/aN68OQDgl19+QdeuXatcTGZmJgDA2dnZYPv3338PV1dXBAUFYe7cucjLy5P2xcTEIDg42CBkRUREICsrC6dPny73cTQaDbKysgy+qGJu5NzAuwffxYDoAVj7z1oU6grRzq0dvgj/At8P+B49G/dk0CEiojqlSj07bdq0walTp8ps/+CDD2BmVrVxGTqdDjNnzkS3bt0QFBQkbX/mmWfg6+sLLy8vnDx5EnPmzMG5c+cQHR0NAFCr1WV6k0puq9Xqch9r0aJFWLBgQZXqbKiuZl/FylMr8euFX1Es9OOhOnp0xAttX0BnVWcGHCIiqrMe+bKYnJwcafxOCQuLys+dMm3aNMTHx2Pfvn0G2ydPnix9HxwcDE9PT/Tt2xeJiYlo1qxZlWqeO3cuZs2aJd3OysoqMyM06Vcg//v639h8cTP+SvoLWqEFAIR6hmJKmynopOpk5AqJiIgersoLgU6fPh27d+9GQUGBtF0IAZlMBq1WW6njTZ8+HZs3b8bevXvRuHHjB7YNDQ0FAFy4cAHNmjWDSqXCoUOHDNqkpKQAwH3H+SiVSiiVXHupPEIInLh5ApsvbsbWy1uRqcmU9nXz6oYpbaegvXt7I1ZIRERUOVUKO88++yyEEPjmm2/g4eFR5VMYQgi89NJL2LBhA3bv3g0/P7+H3uf48eMAAE9PTwBAWFgYFi5ciNTUVLi7uwMAtm/fDnt7ewQGBlaproboStYVbL64GZsTN+NazjVpu5uVGwb4DcDgZoPR0rmlESskIiKqmiqFnRMnTiAuLg4tWz7ah9+0adOwdu1a/Prrr7Czs5PG2Dg4OMDKygqJiYlYu3YtBgwYABcXF5w8eRKvvPIKevbsiTZt2gAA+vXrh8DAQIwZMwZLliyBWq3GG2+8gWnTprH35iFuF9zG1stbsTlxM06mnZS2W5lbIdwnHIOaDUKoKpTz4xARUb1WpbDTqVMnXL169ZHDTskl67179zbYvmrVKowfPx4KhQI7duzAJ598gtzcXHh7e2PYsGF44403pLZmZmbYvHkzpk6dirCwMNjY2GDcuHEG8/LQXQXFBdh9bTd+T/wd+67vkwYby2VyhHmFYVDTQejj3QfWFtYPORIREVH9UOFVz0tLTEzECy+8gGeffRZBQUFlBiSX9LrUF6a+6rlO6BCXEoffEn/D9ivbpbWqAKCVcysMbjYYkX6RcLVyNWKVRERElVPtq56XdvPmTSQmJuK5556TtslksioPUKaakZiRiN8Sf8Pvl36HOvfuZfieNp4Y2HQgBjUdhGaOVbuijYiIqL6oUtiZMGEC2rdvjx9++OGRBihT9buZdxNbLm3B5oubcTb9rLTd1sIW/Zr0w6CmgxDiEQK5rErzSRIREdU7VQo7V65cwaZNm6SZk8m48orysDNpJ36/+DtikmOgE/p5j8xl5ujeuDsGNR2E3t69oTTjgG0iImp4qhR2+vTpgxMnTjDsGJFWp0Vscix+u/gbdibtRH5xvrSvjVsbDG46GBFNIuBk6WTEKomIiIyvSmFn8ODBeOWVV3Dq1CkEBweXGaD8xBNPVEtxZEgIgX/S/8Hmi5vxx6U/kJZ/d4V5bztvDGo6CIOaDoKPvY8RqyQiIqpbqnQ1llx+//Ee9XGAcl2/Gkudq8bmi5vx+8XfcSHjgrTdQemA/k36Y1DTQWjr1pZjp4iIqEGp0aux7l0Li6pfdmE2dlzZgd8u/oYj6iMQ0GdShVyBXt69MLjpYHRv1B0WZpVfh4yIiKgheeSFQKn6FOmKsP/6fmy+uBm7r+6GRquR9oV4hGBw08F4vMnjsFfUvd4nIiKiuqrCYefHH3/E008/XaG2V69eRVJSErp161blwhoKIQROpZ3Cb4m/YdvlbbituS3t83Pww+CmgzGw6UB42XoZsUoiIqL6q8JhZ/ny5ViwYAGee+45DB48GK1atTLYn5mZif379+O7777D9u3bsXLlymov1pRczbqKzZf043CuZF2RtrtYuiDSLxKDmg1CoHMgx+EQERE9ogqHnT179mDTpk1YtmwZ5s6dCxsbG3h4eMDS0hK3b9+GWq2Gq6srxo8fj/j4eHh4eNRk3fVSRkEGtl3ehs0XN+P4zePSdkszS/Tx6YPBzQaji2cXmMt5dpGIiKi6VOlqrLS0NOzbtw9XrlxBfn4+XF1d0b59e7Rv3/6BV2rVVTV5NVahthB7ru3B5sTN2Ht9L4p1dxfeDFWFYlCzQejr0xc2FjbV+rhERESmrkavxnJ1dcWQIUOqWluDoNFqsCh2Ef688ieyC7Ol7S2dWkoLb7pbuxuxQiIiooaB50tqiEKuwImbJ5BdmA13a3dp4c0WTi2MXRoREVGDwrBTQ2QyGWaFzILCTIGOHh1hJjczdklEREQNEsNODerRuIexSyAiImrw6t9oYiIiIqJKeKSwU1hYiHPnzqG4uLi66iEiIiKqVlUKO3l5eZg4cSKsra3RunVrJCUlAQBeeuklLF68uFoLJCIiInoUVQo7c+fOxYkTJ7B7925YWlpK28PDw/HTTz9VW3FEREREj6pKA5Q3btyIn376CV26dDFYzqB169ZITEystuKIiIiIHlWVenZu3rwJd/eyE+Ll5uZyLSciIiKqU6oUdjp27Ijff/9dul0ScL7++muEhYVVT2VERERE1aBKp7Hee+89REZG4syZMyguLsbSpUtx5swZHDhwAHv27KnuGomIiIiqrEo9O927d8fx48dRXFyM4OBg/Pnnn3B3d0dMTAxCQkKqu0YiIiKiKqvSquempiZXPSciIqKaUaOrnpdITU1FamoqdDqdwfY2bdo8ymGJiIiIqk2Vwk5cXBzGjRuHs2fP4t6OIZlMBq1WWy3FERERET2qKoWdCRMmoEWLFli5ciU8PDx4uTkRERHVWVUKOxcvXsT69evRvHnz6q6HiIiIqFpV6Wqsvn374sSJE9VdCxEREVG1q1LY+frrr/HNN99gwYIFWL9+PTZt2mTwVVGLFi1Cp06dYGdnB3d3dwwZMgTnzp0zaFNQUIBp06bBxcUFtra2GDZsGFJSUgzaJCUlYeDAgbC2toa7uztmz57NldiJiIgIQBVPY8XExGD//v3YsmVLmX2VGaC8Z88eTJs2DZ06dUJxcTFef/119OvXD2fOnIGNjQ0A4JVXXsHvv/+OdevWwcHBAdOnT0dUVBT2798PANBqtRg4cCBUKhUOHDiA5ORkjB07FhYWFnjvvfeq8vSIiIjIhFRpnp0mTZpg0KBBePPNN+Hh4VFtxZSsubVnzx707NkTmZmZcHNzw9q1azF8+HAAwD///INWrVohJiYGXbp0wZYtWzBo0CDcuHFDqmXFihWYM2cObt68CYVC8dDH5Tw7RERE9U9FP7+rdBrr1q1beOWVV6o16ABAZmYmAMDZ2RmA/hL3oqIihIeHS20CAgLg4+ODmJgYAPpepuDgYINaIiIikJWVhdOnT1drfURERFT/VCnsREVFYdeuXdVaiE6nw8yZM9GtWzcEBQUBANRqNRQKBRwdHQ3aenh4QK1WS23uDV0lt0va3Euj0SArK8vgi4iIiExTlcbstGjRAnPnzsW+ffsQHBwMCwsLg/0zZsyo9DGnTZuG+Ph47Nu3ryolVcqiRYuwYMGCGn8cohqhLQLSEgD3VgDnuCIieqgqhZ2vv/4atra22LNnT5lVzmUyWaXDzvTp07F582bs3bsXjRs3lrarVCoUFhYiIyPDoHcnJSUFKpVKanPo0CGD45VcrVXS5l5z587FrFmzpNtZWVnw9vauVM1EtS7nJhC3GjiyEshOBkLGA4M+YeAhInqIKoWdS5cuVcuDCyHw0ksvYcOGDdi9ezf8/PwM9oeEhMDCwgI7d+7EsGHDAADnzp1DUlISwsLCAABhYWFYuHAhUlNT4e7uDgDYvn077O3tERgYWO7jKpVKKJXKankORDXu+lHg0JdA/HpAW3h3e9xqwCMI6DzJaKUREdUHj7QQ6KOaNm0a1q5di19//RV2dnbSGBsHBwdYWVnBwcEBEydOxKxZs+Ds7Ax7e3u89NJLCAsLQ5cuXQAA/fr1Q2BgIMaMGYMlS5ZArVbjjTfewLRp0xhoqP4qLgTObgJivwCuleq5bNQRCJ0CZCQBf70DbP034BYA+PUwXq1ERHVchS89nzVrFt555x3Y2NgYnAIqz0cffVSxB79P9/uqVaswfvx4APpJBf/1r3/hhx9+gEajQUREBD7//HODU1RXrlzB1KlTsXv3btjY2GDcuHFYvHgxzM0rluV46TnVGTmpwJFVwJFvgJw7A+zlFkBQFNB5CtA4RL9NCCB6MnDqZ8DKGZi8G3DyNVrZRETGUNHP7wqHncceewwbNmyAo6MjHnvssQe2re4rtWoaww4Z3fU4fS9OfDSgK9Jvs/UAOk7Uj82xK2eah6J84Jv+QPJx/emsCdsApW1tVk1EZFTVHnZMGcMOGUVxIXBmoz7kXD9yd3vjTkDoC0CrJwDzh0yKmXkd+LI3kJuqbz9iDSCv0owSRET1To1OKjhhwgRkZ2eX2Z6bm4sJEyZU5ZBEDUe2Gti1CPgkCIiepA86ZgqgzdPApL+A53cAwcMfHnQAwKER8NR3+lNdZzcBf39Y8/UTEdUzVerZMTMzQ3JysnT1U4m0tDSoVKp6twgne3aoVlw7AsSuAE5vLHWqSgV0unOqytb9Qfd+sKP/B2x6Sf/9U98DrQY9arVERHVeRT+/K3U1VlZWFoQQEEIgOzsblpaW0j6tVos//vijTAAiatCKNcDpDfpTVTeO3t3uHaq/qqrVE4CZxf3vX1EdxgLqeODQF8CGKYDzdsCj/KkXiIgamkqFHUdHR8hkMshkMrRo0aLMfplMxpmJiQAgK1l/RVXcKiD3pn6bmQIIGg6ETga82lf/Y0YsBFLPAJf/Bn4cBUzaBVg7V//jEBHVM5UKO7t27YIQAn369MH69eulBTsBQKFQwNfXF15eXtVeJFG9IARw7bD+VNWZXwHdndO5dl5ApwlAh/GArVvNPb6ZBTDy//QDlm9fBtaNB56NBsyMOp0WEZHRVWnMzpUrV+Dt7Q25iVz1wTE79EiKNfpLxmNX6C8DL+ETBnSeDLQaXD2nqioq5TTw9eNAUS4QOhWIXFx7j01EVItqZMxOCV9fX2RkZODQoUNITU2FTqcz2D927NiqHJaofsm6ARxeqV+2IS9Nv81MCQSP0J+q8mxrnLo8WgNRXwA/PQvELgdUQUD7Z41TCxFRHVClnp3ffvsNo0ePRk5ODuzt7Q1mQpbJZEhPT6/WImsae3aowoQArsbqe3HO/nb3VJV9I/1VVR3GAzYuRi1RsnsxsHuRfqzQ+N8B787GroiIqFrV6KSCLVq0wIABA/Dee+/B2tr6kQqtCxh26KGKCvQLccauANQn72737aY/VRUwqO6NjdHpgJ/HAP9s1s/GPHk3YM8xdURkOmo07NjY2ODUqVNo2rTpIxVZVzDs0H1lXgeOlJyquqXfZm5551TVFEAVbNTyHkqTA6x8XH+Vlld74LktgIWVsasiIqoWNTpmJyIiAkeOHDGZsENkQAggKUY/N87Z3wCh1W+3bwx0fh7oMK7+XNKttAWeXgt89Rhw4xjw28vA0C+A+yzCS0RUrbTFQNZ1ICMJ8O0KyM2MUkaVws7AgQMxe/ZsnDlzBsHBwbCwMLzS5IknnqiW4ohqVVE+cOoXfchJOXV3u293fS9OywF171RVRTj76dfM+nYocPInfW9U15eMXRURmYLSYaa8r6zrd/9gfOWMfokbI6jSaawHXXIuk8mg1WofqajaxtNYDVzG1TunqtYA+XcG15tbAW1GAJ2n6K9mMgWxXwJbZgMyOTB6HdA83NgVEVFdV5kwcz9mSsDRGxj5bbXP7F6jp7HuvdScqN4RAriyX9+L889mQNz5mXbwBjpPAtqPqT+nqiqq8yT94Opj3wLrJugXHXVtbuyqiMiYqjPMOPqU+vK9+72NO2DkefnqYZ880SMozANOrQMOfQmkxN/d3qSH/lRVi8j6eaqqImQyYOB/gbTz+svnfxylX2Hd0sHYlRFRTWkgYeZhqvRb/e23337g/nnz5lWpGKIadfY3/crg+bf1t82tgLZP6S8d92ht3Npqi7lS35X81WP60LN+EjDqB6MNGiSiR8QwUyFVGrPTvr3hIoZFRUW4dOkSzM3N0axZMxw9evQ+96ybOGanAVDHA1+HA8X5+v+8nSbpZxU2tVNVFXX9KLAqEiguALrPAsLfMnZFRFSeagkzinuCjOmEmRods3Ps2LFyH3D8+PEYOnRoVQ5JVHPyM/ST6xXnA836As/8bLqnqiqqUQfgic+A6OeBfR/pe7aChxu7KqKGh2GmVlSpZ+d+Tp06hcGDB+Py5cvVdchawZ4dEyYE8ONo4Nzv+sHHU/Y23N6c8myfB+xfqj+lN2Er4NXO2BURmRaGmRpVoz0795OZmYnMzMzqPCTRo9m/VB90zBTAyDUMOvfq+xaQcga4sF0fCifvAmzdjV0VUf3BMFMvVCnsfPrppwa3hRBITk7Gt99+i8jIyGopjOiRXdoL7Fyg/z7yfaBRiHHrqYvkZsCwr/XjmW4lAD+PBcZuAswVxq6MqG5gmDEJVTqN5efnZ3BbLpfDzc0Nffr0wdy5c2FnZ1dtBdYGnsYyQVk3gC96Ark3gbbPAEM+5xIJD5KWAHzVB9BkASHjgUGf8PWihoFhpl6r0dNYly5duu++/Pz8qhySqPpoi4B14/VBxyNIP7cMP7gfzNUfGLYSWDtSv+ipR5B+EkKi+o5hhlCNY3Y0Gg3+97//YcmSJVCr1dV1WKLK2z5PP2me0gEY+X+AwtrYFdUPLfoB4fOBHW8BW/8NuAUAfj2MXRXRgzHMUAVUKuxoNBrMnz8f27dvh0KhwGuvvYYhQ4bgm2++wRtvvAEzMzO88sorNVUr0cPFRwMHP9d/P3Q54NLMuPXUN91e1s8sfWodsG4cMGkX4ORr7KqoIWOYoWpQqbAzb948fPHFFwgPD8eBAwcwYsQIPPfcczh48CA++ugjjBgxAmZmnImVjOTmOeDX6frvu78CBAw0bj31kUwGPLFMP7ty8gngx2eAiX8CChtjV0amqrrCjMMDZgC29WCYaeAqFXbWrVuH//u//8MTTzyB+Ph4tGnTBsXFxThx4gRkHBNBxqTJBn56FijK1a9z9dgbxq6o/rKwAp5eC3z5mL6XZ+NUYMQajnuiR1OYC1yPA64eAm4lMsxQrarU1VgKhQKXLl1Co0aNAABWVlY4dOgQgoODa6zA2sCrseo5IYBfJgCnowE7T2DK34Ctm7Grqv+SDgKrBwG6In147DXb2BVRfZJ1Q/8zdDVW/5V88v6hhmGGqqhGrsbSarVQKO7Ov2Fubg5bW9uqV0lUHWJX6IOO3FzfA8GgUz18ugCDPtIvnrrrXcAjkKcGqXw6LZBy+m6wSYoFMpPKtrNvBHiH6n+WHJswzFCtqVTYEUJg/PjxUCqVAICCggK88MILsLExPJ8fHR1dfRUSPUjSQeDPO6es+i0EfEKNW4+p6TAWUJ8CDn0JRE8GJm7Xf1BRw6bJBq4duRNsDuq/L8w2bCOT69dc8+6iD87eofqVtYmMoFJhZ9y4cQa3n3322WothqhSclL18+noioHWUUDoFGNXZJoi3gNSzwKX/wZ+HKW/QovLbjQsGVfvBpurB/W9OEJn2EZhBzTueDfYNO4IKOvXBLNkuqp1IdDK2rt3Lz744APExcUhOTkZGzZswJAhQ6T948ePx5o1awzuExERga1bt0q309PT8dJLL+G3336DXC7HsGHDsHTp0kqdXuOYnXpIWwx8O0T/AezaEpj0F6DkKdUak3sL+Kq3fkBp097A6PVcOd5UaYuBlFP6U1Elp6Wyrpdt5+Cj70n1DtUHHPdA/fIjRLXIKAuBVlZubi7atm2LCRMmICoqqtw2/fv3x6pVq6TbJafQSowePRrJycnYvn07ioqK8Nxzz2Hy5MlYu3ZtjdZORvbXO/qgo7AFnvqOQaem2bgAo34Evn4cuLgb2P4m0H+Rsaui6lCQCVw7fCfcHASuxemvaixNZgZ4trlzSupOwLH3Mk69RFVg1LATGRn50IVDlUolVCpVufvOnj2LrVu34vDhw+jYsSMAYNmyZRgwYAA+/PBDeHnxP6NJOrsZ2P+J/vsnPwPcWhi1nAbDozUwdAXw8xj9xI0eQUD70cauiipDCCDjyt1gkxQLpJ4BcE8Hv9IB8O58p9cmVL+ILudaonqszvdD7969G+7u7nByckKfPn3w7rvvwsXFBQAQExMDR0dHKegAQHh4OORyOWJjYzF06NByj6nRaKDRaKTbWVlZNfskqPrcStTP+wIAXaYBrct/j6mGBD4B9Po3sGcxsHkm4NoC8O5k7KrofrRF+ku+rx68M97mEJBTznI+Tk1K9dp00S8VwqujyITU6bDTv39/REVFwc/PD4mJiXj99dcRGRmJmJgYmJmZQa1Ww93d3eA+5ubmcHZ2fuD6XIsWLcKCBQtqunyqboV5wM9j9Stze3cBHud7aBS95ugnG/xnM/DTaGDybp7SqCvybwNXD9/ttbkeBxTfsziz3ALwbHt3ILF3KGDnYZx6iWpJnQ47Tz/9tPR9cHAw2rRpg2bNmmH37t3o27dvlY87d+5czJo1S7qdlZUFb29eElmnCQFsfkX/IWvjDoxYDZhZGLuqhkkuB4Z+Aax8XH8K5MfRwHN/6GdeptojBJB+sdRVUrHAzX/KtrNyuhtqvEOBRh34XlGDU6fDzr2aNm0KV1dXXLhwAX379oVKpUJqaqpBm+LiYqSnp993nA+gHwd070BnquPiVgEnf9QPlByxCrD3NHZFDZvSVr+kxFePATeOAr+9rA9AXFKi5hRr9OuVlZ6VOPdm2XYuzfU9n96d9b03Lv48JUUNXr0KO9euXcOtW7fg6an/oAsLC0NGRgbi4uIQEhICAPjrr7+g0+kQGsrJ5UzG9Thgyxz99+FvAU26G7ce0nP2089Y/e1Q4ORPgCoY6PqSsasyHbm37oaaq7HA9aOAVmPYxkwBeLW/e/m3dyhg42qceonqMKOGnZycHFy4cEG6fenSJRw/fhzOzs5wdnbGggULMGzYMKhUKiQmJuK1115D8+bNERERAQBo1aoV+vfvj0mTJmHFihUoKirC9OnT8fTTT/NKLFORewv4eRygLQQCBgFdZxi7IiqtaS/9JehbXgO2zwPcWwHNw41dVf0jBJCWcCfY3BlvcyuhbDtrF8OBxF7tAHP2UhM9jFEnFdy9ezcee+yxMtvHjRuH5cuXY8iQITh27BgyMjLg5eWFfv364Z133oGHx93BdOnp6Zg+fbrBpIKffvopJxU0BTot8P1wIPEvwLkZMHkXYOlg7KroXkIAm6YDx77Tvz+TdgEuzYxdVd1WVADcOHY32FyNBfLTy7ZzbXk32HiH6l9XniokklT089uoYaeuYNipo3Yt0l/ibG4FTNqpn+eF6qZiDbBmsP5D27UF8PxOwJL/lyQ5N0td/h0L3DiuX02+NHNL/Xw23p3vjrnhshxED1QvZlAmuq+E7cCe9/XfD17KoFPXmSuBkd8CX/YG0s4D0ZP0A5gb4vIBOh2Qdu7uvDZXD+qvmrqXjfvdXhufLoCqDWCuqP16iRoAhh2qe25fAdY/D0AAHScCbZ8ydkVUEXYewNPfA6sigfNbgb/e1Q8oN3WFefor0qSrpA4BBRn3NJLpxzOVHkjs1ISnpIhqCcMO1S1FBfqJAwsy9F36XH+pfmnUAXhimb5nZ99HgCoICBpm7KqqV7b6brBJOgioTwK6YsM2Ftb6n19pBfBOgJWjUcolIoYdqmu2zgGSjwNWzvrLmnmlSf3TZiSgPgUc+BTYOE0/uNyrnbGrqhqdFkg9qz8VdfWQPtxkXCnbzs7TsNdGFcxJL4nqEIYdqjuOfQ/ErQYgA4Z9DThyVut6K3y+fnblCzv0MyxP3g3Yuhm7qofT5OjndSrptbl2WL88SWkyOeDeutR4m1DAwZunpIjqMIYdqhuSTwK/31nC47HXgeZVXw6E6gC5GTBsJfB1X+DWBf1K6WM31b0BuJnXS13+fRBQxwNCa9hGYQs07ng32DTqyCvNiOoZhh0yvvwM/YdhcQHg3w/o8aqxK6LqYOUIjPoR+KoPkBSjn3hw8CfGq0dbDKSevhtsrh4CMq+WbefgbXhKyj0QMOOvSqL6jP+Dybh0OmDDC8Dty4Cjj359Ja7jYzpc/fU9PGtH6tc3UwUBnZ6vnccuyNKfhiq5/PvaEaAwx7CNzEw/vsany935bRwa1U59RFRrGHbIuPZ/DJzfApjdmaeFk6iZnhb99Jeg75ivX+PMLaD61zcTQt9Lk1RquYXU04DQGbZT2uuvjCrptWkUol/UlIhMGsMOGc/F3fq5WABg4If194oderhuM/XjYeJ/0U8tMGkX4ORb9eNpi/RXfJUMJL4aC2Qnl23n6Hs32Ph00QethjjRIVEDx7BDxpF5Hfhlov4v7/bPAh3GGrsiqkkymX7+nVsJQPIJ4MdngIl/Agqbit0/P0N/Sqok2FyPA4ryDNvIzQHPtqUWygwF7FTV/lSIqP5h2KHaV1wIrBsH5KXpp8gf8KGxK6LaoLDWLyHxZW8gJR7YOFU/l9K9l2wLAdy+dHeBzKux+rlucM8yfpaOd3ps7gQbrw76xyAiugfDDtW+P9/Q/5Vu6QCM/D/AwsrYFVFtcWgMPPUdsHoQcOZXYO+HQLeX9bMQJx28O94mN7XsfZ2blQo3XfQLjnIwOxFVAFc9B1c9r1WnfgHWT9R/P+onoGV/49ZDxhG3Bvhthv57c0v9tAOlmSkAz3Z3g413aP2YlJCIahVXPae6J/UssOkl/fc9XmXQachCxulPZR36Uh90rJwNBxJ7tgMsLI1dJRGZCIYdqh0FWcBPY/SDSpv21s+STA1b//eBlgP0p7ZcmnO5BSKqMQw7VPOEADZN11+JY99IP8kcL/8luRxo9pixqyCiBoCj+6jmHfxcPxhVbqG/+sbG1dgVERFRA8KwQzXrygHgzzf13/dfBHh3Mm49RETU4DDsUM3JTgHWjdevIh08svbWRCIiIiqFYYdqhrYY+OU5ICcFcGulX+2aA1CJiMgIGHaoZuxcAFzZDyjs9JPIVXRZACIiomrGsEPV78wm4MCn+u+HfA64NjduPURE1KAx7FD1SrsAbHxR/33Xl4DAJ4xbDxERNXgMO1R9CnOBn8cAhdmAbzeg73xjV0RERMSwQ9VECGDzK0DqGcDWAxj+DWDGOSuJiMj4GHaoehz+Gjj5EyAzA0asBuxUxq6IiIgIAMMOVYdrR4Ctc/XfP/424NvVuPUQERGVwrBDjyY3Dfh5LKArAgKfBMKmGbsiIiIiAww7VHU6LbB+IpB1HXDxB574jBMHEhFRncOwQ1W3exFwcTdgYQ089S1gaW/sioiIiMowatjZu3cvBg8eDC8vL8hkMmzcuNFgvxAC8+bNg6enJ6ysrBAeHo6EhASDNunp6Rg9ejTs7e3h6OiIiRMnIicnpxafRQN1fhuw9wP9908sA9xbGbceIiKi+zBq2MnNzUXbtm3xv//9r9z9S5YswaeffooVK1YgNjYWNjY2iIiIQEFBgdRm9OjROH36NLZv347Nmzdj7969mDx5cm09hYbp9mUgepL++85TgODhRi2HiIjoQWRCCGHsIgBAJpNhw4YNGDJkCAB9r46Xlxf+9a9/4dVXXwUAZGZmwsPDA6tXr8bTTz+Ns2fPIjAwEIcPH0bHjh0BAFu3bsWAAQNw7do1eHl5Veixs7Ky4ODggMzMTNjb81TMAxXlAyv7AeqTQONOwPg/AHOFsasiIqIGqKKf33V2zM6lS5egVqsRHh4ubXNwcEBoaChiYmIAADExMXB0dJSCDgCEh4dDLpcjNja21mtuEP6YrQ861i7AiDUMOkREVOfV2Slu1Wo1AMDDw8Ngu4eHh7RPrVbD3d3dYL+5uTmcnZ2lNuXRaDTQaDTS7aysrOoq27Qd/T/g2LeATK6fIdmhkbErIiIieqg627NTkxYtWgQHBwfpy9vb29gl1X3JJ4Df9acT0ecNoGlvo5ZDRERUUXU27KhU+uUGUlJSDLanpKRI+1QqFVJTUw32FxcXIz09XWpTnrlz5yIzM1P6unr1ajVXbwKEAIoKgLx04FYi8NMYQKsBWkQC3V4xdnVEREQVVmdPY/n5+UGlUmHnzp1o164dAP3pptjYWEydOhUAEBYWhoyMDMTFxSEkJAQA8Ndff0Gn0yE0NPS+x1YqlVAqlTX+HGqMtggoytMPFpb+Lf1V3r57t5W37579uGfsulMTYOgKQF5nMzIREVEZRg07OTk5uHDhgnT70qVLOH78OJydneHj44OZM2fi3Xffhb+/P/z8/PDmm2/Cy8tLumKrVatW6N+/PyZNmoQVK1agqKgI06dPx9NPP13hK7Fq1K1EQJNVgeBRyW264tp9HnILwLkpMHwlYOVYu49NRET0iIwado4cOYLHHntMuj1r1iwAwLhx47B69Wq89tpryM3NxeTJk5GRkYHu3btj69atsLS0lO7z/fffY/r06ejbty/kcjmGDRuGTz/9tNafS7m+GwbcvlSDDyADFDaAhdWdL+t7/i1nm7nVA9qXdz8rwMyiBp8DERFRzaoz8+wYU43Ns/NNJJBxpXJhpDL7zBRci4qIiBqsin5+19kxOyZhwhZjV0BERNTgcaQpERERmTSGHSIiIjJpDDtERERk0hh2iIiIyKQx7BAREZFJY9ghIiIik8awQ0RERCaNYYeIiIhMGsMOERERmTTOoExERETVTqsTOHI5HVvi1Th8OR2/TusGczPj9LEw7BAREVG1KNLqcPDiLWyJV+PP02qk5RRK+w5dTkfXZq5GqYthh4iIiKqsoEiL/RfSsCVeje1nUpCZXyTtc7CyQHgrD0QGqdDBx8loNTLsEBERUaXkFRZj97mb2BKvxq5/UpGjKZb2udoq8HigCpFBKoQ1c4GFkU5dlcawQ0RERA+VVVCEv86mYkt8Mvacv4mCIp20z9PBEhGtVegfpEKnJs4wk8uMWGlZDDtERERUrtu5hdh+JgVb4pOx/8ItFGrvBhwfZ2tEBukDTtvGjpDXsYBTGsMOERERSVKzC7DtdAq2xifj4MV0aHVC2tfc3VYKOIGe9pDJ6m7AKY1hh4iIqIG7npGPrfFqbI1PxpErtyHu5hsEetojMkiFyGAVmrvbGa/IR8CwQ0RE1ABdSsvFlvhkbI1X4+S1TIN97bwdpR4cXxcbI1VYfRh2iIiIGgAhBM6n5EgB5x91trRPJgM6NXFGZJAKEa1V8HK0MmKl1Y9hh4iIyEQJIRB/PUsKOBfTcqV95nIZwpq5oH+QCv0CVXCzUxqx0prFsENERGRCdDqBY1dvY8spNbaeVuPa7Xxpn8Jcjp7+rugf5InwVu5wtFYYsdLaw7BDRERUzxVrdTh0OR1b49XYdlqNlCyNtM/KwgyPBbihf5An+gS4w1bZ8D76G94zJiIiMgGFxTrsT0zD1lNqbD+bgvTcu+tQ2SnN0beVO/oHeaJXCzdYKcyMWKnxMewQERHVEwVFWuw5fxNb49XYcTYF2QV3l2lwsrbA44EeiAzyRNfmLlCaN+yAUxrDDhERUR2WoynGrn9SsTVejV3nUpFXqJX2udkpEdFaH3BC/ZxhXgfWoaqLGHaIiIjqmMy8Iuw4m4It8WrsTbiJwuK7yzQ0crRCRGv9JH8hPk51epmGuoJhh4iIqA64laPBn2f0AefAhTQUl1qmwc/VBv2D9CuJBzdyqDfLNNQVDDtERERGos4swNb4ZGyJV+Pw5XSUyjdo6WGnDzjBKrT0sGPAeQQMO0RERLXoanoettwJOMeSMgz2BTdykHpwmrrZGqdAE8SwQ0REVMMupOZIPTinb2QZ7AvxdZKWafB2tjZShaaNYYeIiKiaCSFwNjlbCjgJqTnSPrkMCPVzQWSwPuB42FsasdKGoU6Hnfnz52PBggUG21q2bIl//vkHAFBQUIB//etf+PHHH6HRaBAREYHPP/8cHh4exiiXiIgaMCEETlzLlNahunIrT9pnYSZDt+auiAxSIbyVB1xsTXcdqrqoTocdAGjdujV27Ngh3TY3v1vyK6+8gt9//x3r1q2Dg4MDpk+fjqioKOzfv98YpRIRUQOj1QnEXbmNLfHJ2Bavxo3MAmmf0lyOXi3cEBmsQp8ADzhYWRix0oatzocdc3NzqFSqMtszMzOxcuVKrF27Fn369AEArFq1Cq1atcLBgwfRpUuX2i6ViIgagCKtDgcv3sKWeDX+PJ2CtJy761DZKMzwWIA7IoM80bulG2wa4DpUdVGdfxcSEhLg5eUFS0tLhIWFYdGiRfDx8UFcXByKiooQHh4utQ0ICICPjw9iYmIeGHY0Gg00mrs/nFlZWfdtS0REpCnWYl9CGrbcWaYhI69I2mdvaY7wO8s09PB3haUFl2moa+p02AkNDcXq1avRsmVLJCcnY8GCBejRowfi4+OhVquhUCjg6OhocB8PDw+o1eoHHnfRokVlxgIRERGVlldYjD3nbmJLvBp//ZOKHM3ddahcbBTo19oD/YM8EdbUBQpzLtNQl9XpsBMZGSl936ZNG4SGhsLX1xc///wzrKysqnzcuXPnYtasWdLtrKwseHt7P1KtRERU/2UXFOGvf1Kx5ZQau8+noqDo7jINKntL9A9SoX+QCp2aOMOMyzTUG3U67NzL0dERLVq0wIULF/D444+jsLAQGRkZBr07KSkp5Y7xKU2pVEKp5Eh4IiICbucWYvvZFGyNV2NfQhoKtXcDjrezFSKDPNE/SIV2jR25DlU9Va/CTk5ODhITEzFmzBiEhITAwsICO3fuxLBhwwAA586dQ1JSEsLCwoxcKRER1WWp2QX487Q+4MRcvAVtqXUamrnZSAGntZc9l2kwAXU67Lz66qsYPHgwfH19cePGDbz11lswMzPDqFGj4ODggIkTJ2LWrFlwdnaGvb09XnrpJYSFhfFKLCIiKuN6Rj62xquxLV6Nw1fSIUqtQ9XK0x6Rd5Zp8PewM16RVCPqdNi5du0aRo0ahVu3bsHNzQ3du3fHwYMH4ebmBgD4+OOPIZfLMWzYMINJBYmIiADgcloutsSrsTU+GSeuZRrsa+vtiMggFfq3VqGJq42RKqTaIBOidLZtmLKysuDg4IDMzEzY29sbuxwiIqoiIQQSUnOw5ZQaW+KT8Y86W9onkwGdfJ2lQcZejlW/0IXqhop+ftfpnh0iIqKHEULg9I0saSXxizdzpX1mchnCmrqgf5AK/Vp7wN2O61A1RAw7RERU7+h0AseuZkgLbV67nS/tU5jJ0cPfFf3vrEPlZKMwYqVUFzDsEBFRvVCs1eHw5dvYGp+MrafVSMm6OxO+lYUZerd0Q/8gFfoEuMPOkutQ0V0MO0REVGcVFutwIDENW+PV2H4mBbdyC6V9tkpz9G3ljsggFXq1cIeVgss0UPkYdoiIqE4pKNJi7/mb2HpnHaqsgrvLNDhaW+DxVh6IDFahW3NXKM0ZcOjhGHaIiMjocjXF2HUuFVvi1dj1TyryCrXSPldbJSJa6xfaDG3qDAszrkNFlcOwQ0RERpGZX4SdZ1OwJV6NvedvQlN8d5kGLwdLRASpEBnkiRBfJ65DRY+EYYeIiGqFpliLtJxC/H1ev5L4gcQ0FGnvTvXWxMUa/YM8ERmkQpvGDlymgaoNww4REVVasVaHjPwi3M4tRHpuIW7nFSI9t+jOv4X67Xml/y1Cjqa4zHFaeNhKASdAZceAQzWCYYeIqIETQiArvxjp9w0qd4NMybbM/CJUZf59M7kMrTztpIU2m7nZVv8TIroHww4RkQkRQiCvUFuqt6VUr4tBeDHsjSm96ndlOFpbwNlaAScbBZysFXC2sYCTjULaVvKvi43+XzulOeQcf0O1jGGHiKgO0xRrcTu3qJzwUtLLcu+ppEKDgb6VYas0h5ONRZmg4lw6yFjrbzvbKOBgZQFzXhlF9QDDDhFRLansOJf0nELklroEuzIU5nJ9b8qdcKIPLxb3hBf9vy62CjhaW3DOGjJZDDtERFWg0wlkF1R8nMutXP04l6owk8vK9KwY9rwY9rg42yhgZWHGwb5EdzDsEFGDV/lxLoW4nVfEcS5E9QTDDjUIuZpiJGfmIyOvCG52SqgcLNllb8IqOs7lVqkemUKOcyEyWQw7VO8VaXVQZxYgObMANzLycSMzHzcy8pGcUYDrGflIziwo9/SBm50SXo5W8HKw1P97z/cuNgr+NV0HVHScS3ru3dsc50JEpTHsUJ2m0wncyi3Uh5fMfFzPKEDynQBz/c621GxNheb7sLM0h6O1BW5ma1BQpMPNbA1uZmtw4mr57RVmcng6WsLLwQqejpZodCcEeTrov/d0tIKtkv+FKkOnE8gqKJJOA91vnEt6rga38/TtOM6FiB4Vf1OTUWUXFOFGRoFBb0xJ70xyZgGSMwpQqH346QWFuRyeDobBxNPBCl6OllJAsbO0AKAfn3E7r0j/OCVfJeEpIx83MgqQkq1/3Cu38nDlVt59H9fe0hxejlZ3wo+l9H3JY3rYW5rsooUlwaUklJQEloxSY11u5xmOccnIK0QVh7lUeJxLSXDhOBciKsGwQzVGU6yFWgoRBXd7ZkoFm+xypo+/l0wGuEunnPQBRh9k7oYZFxtFhf8il8lk0gdiUCOHctsUaXVIySrQB7FSp8ak2xn5yCoo1n+ps/GPOrvc48hlgIe9pT6IlYSi0qfNHK3gZG1h9N6E8q4suhtUiu4EmLvBJSNPfxqpqsGlZJyL1LPygHEuTjYKOHKcCxE9AoYdqhKtTiAtRyMFGak3RuqlKUBajqZCx3K0ttCHlzsh4N6eGWP0jliYydHYyRqNnazv2ya7oOjuOKFyQpE6U987lHxnPNHRpIxyj2NpITcIcne/v3vb0qLi40JKB5fb91xFdLvUBHQZeUXSqaPqCi6lx7Q4lRrr4mhtIYUaR2sFFOYMLkRUexh2GjAhBDTFOuRqipFXqEVuYTFyNVrkFRYjV1Pq+0ItMvKKkFwqzKgzC1BcgU9HSwu59MHt6WAJT0crNLqnZ8ZaUT9/DO0sLWBnaYEWHnbl7tfpBNJyNbhxZ5zR9TshqKRn6/qdQFhQpMPFm7m4eDP3vo/lbKOQerQaOVrBzU6JHE3x3R6Y3LvBJSO/6pdE2yrNpWBiEFhKnT5ysrkbXBw4QJeI6oH6+SnTAAkhUFCkQ25hMfI0+mCSV1iMHI0WeRp9IMkzCCtafWApvBNkSgWau/fXVvlDEdAPAPW4c3rJs6QXwsHwNE1dOEVjLHK5DO52lnC3s0Q7b8dy25Q+1VcSim6UGoh9PSNfmv8lPbcQ8dezKvz4NgqzUj0rpa4qslbAUQowd08X8coiIjJVDDs16FaOBjmaYuRo7gkc9wQP/f47gaVUcLm7T9+2KisMV5SVhRlslGawVpjDWmEGG6X+X1ulOawV5rCzNC8VYvQ9DO52So6jeERKczP4utjA18Wm3P0lq1HfPT2mH0x9M1sDW6W54RVG95w2YnAhItJj2KlBQz7fj6vp+dV+XGuFPpSUhBObO+Gk9G1r5Z1/Feb6wKI0g809QUZ/H3NYWZjBjFet1EkymQwO1hZwsLZAK097Y5dDRFQvMezUIJt7goeN0lwfOO4XPKS2ZdvY3LltZWHGy2mJiIgqgWGnBm15uUeDHa9CRERUV3DARQ1i0CEiIjI+hh0iIiIyaQw7REREZNIYdoiIiMikmUzY+d///ocmTZrA0tISoaGhOHTokLFLIiIiojrAJMLOTz/9hFmzZuGtt97C0aNH0bZtW0RERCA1NdXYpREREZGRmUTY+eijjzBp0iQ899xzCAwMxIoVK2BtbY1vvvnG2KURERGRkdX7sFNYWIi4uDiEh4dL2+RyOcLDwxETE1PufTQaDbKysgy+iIiIyDTV+7CTlpYGrVYLDw8Pg+0eHh5Qq9Xl3mfRokVwcHCQvry9vWujVCIiIjKCeh92qmLu3LnIzMyUvq5evWrskoiIiKiG1PvlIlxdXWFmZoaUlBSD7SkpKVCpVOXeR6lUQqlU1kZ5REREZGT1vmdHoVAgJCQEO3fulLbpdDrs3LkTYWFhRqyMiIiI6oJ637MDALNmzcK4cePQsWNHdO7cGZ988glyc3Px3HPPGbs0IiIiMjKTCDtPPfUUbt68iXnz5kGtVqNdu3bYunVrmUHLRERE1PDIhBDC2EUYW2ZmJhwdHXH16lXY29sbuxwiIiKqgKysLHh7eyMjIwMODg73bWcSPTuPKjs7GwB4CToREVE9lJ2d/cCww54d6Ac037hxA3Z2dpDJZMYup84pSc7s+ao7+J7ULXw/6ha+H3VLTb4fQghkZ2fDy8sLcvn9r7lizw70My43btzY2GXUefb29vzFUcfwPalb+H7ULXw/6paaej8e1KNTot5fek5ERET0IAw7REREZNIYduihlEol3nrrLc46XYfwPalb+H7ULXw/6pa68H5wgDIRERGZNPbsEBERkUlj2CEiIiKTxrBDREREJo1hh4iIiEwaw04DsWjRInTq1Al2dnZwd3fHkCFDcO7cOYM2BQUFmDZtGlxcXGBra4thw4YhJSXFoE1SUhIGDhwIa2truLu7Y/bs2SguLjZos3v3bnTo0AFKpRLNmzfH6tWra/rp1XuLFy+GTCbDzJkzpW18P2rX9evX8eyzz8LFxQVWVlYIDg7GkSNHpP1CCMybNw+enp6wsrJCeHg4EhISDI6Rnp6O0aNHw97eHo6Ojpg4cSJycnIM2pw8eRI9evSApaUlvL29sWTJklp5fvWJVqvFm2++CT8/P1hZWaFZs2Z45513UPp6Gr4fNWvv3r0YPHgwvLy8IJPJsHHjRoP9tfn6r1u3DgEBAbC0tERwcDD++OOPyj8hQQ1CRESEWLVqlYiPjxfHjx8XAwYMED4+PiInJ0dq88ILLwhvb2+xc+dOceTIEdGlSxfRtWtXaX9xcbEICgoS4eHh4tixY+KPP/4Qrq6uYu7cuVKbixcvCmtrazFr1ixx5swZsWzZMmFmZia2bt1aq8+3Pjl06JBo0qSJaNOmjXj55Zel7Xw/ak96errw9fUV48ePF7GxseLixYti27Zt4sKFC1KbxYsXCwcHB7Fx40Zx4sQJ8cQTTwg/Pz+Rn58vtenfv79o27atOHjwoPj7779F8+bNxahRo6T9mZmZwsPDQ4wePVrEx8eLH374QVhZWYkvvviiVp9vXbdw4ULh4uIiNm/eLC5duiTWrVsnbG1txdKlS6U2fD9q1h9//CH+85//iOjoaAFAbNiwwWB/bb3++/fvF2ZmZmLJkiXizJkz4o033hAWFhbi1KlTlXo+DDsNVGpqqgAg9uzZI4QQIiMjQ1hYWIh169ZJbc6ePSsAiJiYGCGE/odfLpcLtVottVm+fLmwt7cXGo1GCCHEa6+9Jlq3bm3wWE899ZSIiIio6adUL2VnZwt/f3+xfft20atXLyns8P2oXXPmzBHdu3e/736dTidUKpX44IMPpG0ZGRlCqVSKH374QQghxJkzZwQAcfjwYanNli1bhEwmE9evXxdCCPH5558LJycn6f0peeyWLVtW91Oq1wYOHCgmTJhgsC0qKkqMHj1aCMH3o7bdG3Zq8/UfOXKkGDhwoEE9oaGhYsqUKZV6DjyN1UBlZmYCAJydnQEAcXFxKCoqQnh4uNQmICAAPj4+iImJAQDExMQgODgYHh4eUpuIiAhkZWXh9OnTUpvSxyhpU3IMMjRt2jQMHDiwzGvG96N2bdq0CR07dsSIESPg7u6O9u3b46uvvpL2X7p0CWq12uC1dHBwQGhoqMH74ejoiI4dO0ptwsPDIZfLERsbK7Xp2bMnFAqF1CYiIgLnzp3D7du3a/pp1htdu3bFzp07cf78eQDAiRMnsG/fPkRGRgLg+2Fstfn6V9fvMIadBkin02HmzJno1q0bgoKCAABqtRoKhQKOjo4GbT08PKBWq6U2pT9YS/aX7HtQm6ysLOTn59fE06m3fvzxRxw9ehSLFi0qs4/vR+26ePEili9fDn9/f2zbtg1Tp07FjBkzsGbNGgB3X8/yXsvSr7W7u7vBfnNzczg7O1fqPSPg3//+N55++mkEBATAwsIC7du3x8yZMzF69GgAfD+MrTZf//u1qez7w1XPG6Bp06YhPj4e+/btM3YpDdbVq1fx8ssvY/v27bC0tDR2OQ2eTqdDx44d8d577wEA2rdvj/j4eKxYsQLjxo0zcnUNz88//4zvv/8ea9euRevWrXH8+HHMnDkTXl5efD+oStiz08BMnz4dmzdvxq5du9C4cWNpu0qlQmFhITIyMgzap6SkQKVSSW3uvRqo5PbD2tjb28PKyqq6n069FRcXh9TUVHTo0AHm5uYwNzfHnj178Omnn8Lc3BweHh58P2qRp6cnAgMDDba1atUKSUlJAO6+nuW9lqVf69TUVIP9xcXFSE9Pr9R7RsDs2bOl3p3g4GCMGTMGr7zyitQLyvfDuGrz9b9fm8q+Pww7DYQQAtOnT8eGDRvw119/wc/Pz2B/SEgILCwssHPnTmnbuXPnkJSUhLCwMABAWFgYTp06ZfADvH37dtjb20sfFGFhYQbHKGlTcgzS69u3L06dOoXjx49LXx07dsTo0aOl7/l+1J5u3bqVmYrh/Pnz8PX1BQD4+flBpVIZvJZZWVmIjY01eD8yMjIQFxcntfnrr7+g0+kQGhoqtdm7dy+KioqkNtu3b0fLli3h5ORUY8+vvsnLy4NcbvjxZGZmBp1OB4Dvh7HV5utfbb/DKjWcmeqtqVOnCgcHB7F7926RnJwsfeXl5UltXnjhBeHj4yP++usvceTIEREWFibCwsKk/SWXOvfr108cP35cbN26Vbi5uZV7qfPs2bPF2bNnxf/+9z9e6lxBpa/GEoLvR206dOiQMDc3FwsXLhQJCQni+++/F9bW1uK7776T2ixevFg4OjqKX3/9VZw8eVI8+eST5V5q2759exEbGyv27dsn/P39DS61zcjIEB4eHmLMmDEiPj5e/Pjjj8La2pqXOt9j3LhxolGjRtKl59HR0cLV1VW89tprUhu+HzUrOztbHDt2TBw7dkwAEB999JE4duyYuHLlihCi9l7//fv3C3Nzc/Hhhx+Ks2fPirfeeouXntP9ASj3a9WqVVKb/Px88eKLLwonJydhbW0thg4dKpKTkw2Oc/nyZREZGSmsrKyEq6ur+Ne//iWKiooM2uzatUu0a9dOKBQK0bRpU4PHoPu7N+zw/ahdv/32mwgKChJKpVIEBASIL7/80mC/TqcTb775pvDw8BBKpVL07dtXnDt3zqDNrVu3xKhRo4Stra2wt7cXzz33nMjOzjZoc+LECdG9e3ehVCpFo0aNxOLFi2v8udU3WVlZ4uWXXxY+Pj7C0tJSNG3aVPznP/8xuESZ70fN2rVrV7mfGePGjRNC1O7r//PPP4sWLVoIhUIhWrduLX7//fdKPx+ZEKWmpCQiIiIyMRyzQ0RERCaNYYeIiIhMGsMOERERmTSGHSIiIjJpDDtERERk0hh2iIiIyKQx7BAREZFJY9ghInqA8ePHY8iQIcYug4geAScVJKIaFxMTg+7du6N///74/fffjV1OpWRmZkIIAUdHR2OXQkRVxLBDRDXu+eefh62tLVauXIlz587By8vrvm2FENBqtTA3NzfYXlhYCIVCUdOlEpEJ4mksIqpROTk5+OmnnzB16lQMHDgQq1evNti/e/duyGQybNmyBSEhIVAqldi3bx969+6N6dOnY+bMmXB1dUVERAQA4KOPPkJwcDBsbGzg7e2NF198ETk5OQCA3Nxc2Nvb45dffjF4jI0bN8LGxgbZ2dnl1vjLL78gODgYVlZWcHFxQXh4OHJzcwEYnsa6fPkyZDJZma/evXtLx9q3bx969OgBKysreHt7Y8aMGdKxiMg4GHaIqEb9/PPPCAgIQMuWLfHss8/im2++QXkdyv/+97+xePFinD17Fm3atAEArFmzBgqFAvv378eKFSsAAHK5HJ9++ilOnz6NNWvW4K+//sJrr70GALCxscHTTz+NVatWGRx71apVGD58OOzs7Mo8bnJyMkaNGoUJEybg7Nmz2L17N6Kiosqt0dvbG8nJydLXsWPH4OLigp49ewIAEhMT0b9/fwwbNgwnT57ETz/9hH379mH69OmP9iIS0aOp9NKhRESV0LVrV/HJJ58IIYQoKioSrq6uYteuXdL+ktWVN27caHC/Xr16ifbt2z/0+OvWrRMuLi7S7djYWGFmZiZu3LghhBAiJSVFmJubi927d5d7/7i4OAFAXL58udz948aNE08++WSZ7fn5+SI0NFQMGjRIaLVaIYQQEydOFJMnTzZo9/fffwu5XC7y8/Mf+lyIqGawZ4eIasy5c+dw6NAhjBo1CgBgbm6Op556CitXrizTtmPHjmW2hYSElNm2Y8cO9O3bF40aNYKdnR3GjBmDW7duIS8vDwDQuXNntG7dGmvWrAEAfPfdd/D19ZV6X+7Vtm1b9O3bF8HBwRgxYgS++uor3L59+6HPbcKECcjOzsbatWshl+t/lZ44cQKrV6+Gra2t9BUREQGdTodLly499JhEVDMYdoioxqxcuRLFxcXw8vKCubk5zM3NsXz5cqxfvx6ZmZkGbW1sbMrc/95tly9fxqBBg9CmTRusX78ecXFx+N///gdAP4C5xPPPPy+NDVq1ahWee+45yGSycms0MzPD9u3bsWXLFgQGBmLZsmVo2bLlA8PJu+++i23btmHTpk0Gp8ZycnIwZcoUHD9+XPo6ceIEEhIS0KxZswe/WERUYxh2iKhGFBcX4//+7//w3//+t8yHv5eXF3744YdKHzMuLg46nQ7//e9/0aVLF7Ro0QI3btwo0+7ZZ5/FlStX8Omnn+LMmTMYN27cA48rk8nQrVs3LFiwAMeOHYNCocCGDRvKbbt+/Xq8/fbb+Pnnn8sEmA4dOuDMmTNo3rx5mS9eSUZkPOYPb0JEVHmbN2/G7du3MXHiRDg4OBjsGzZsGFauXIkXXnihUsds3rw5ioqKsGzZMgwePNhg4HJpTk5OiIqKwuzZs9GvXz80btz4vseMjY3Fzp070a9fP7i7uyM2NhY3b95Eq1atyrSNj4/H2LFjMWfOHLRu3RpqtRoAoFAo4OzsjDlz5qBLly6YPn06nn/+edjY2ODMmTPYvn07Pvvss0o9VyKqPuzZIaIasXLlSoSHh5cJOoA+7Bw5cgQnT56s1DHbtm2Ljz76CO+//z6CgoLw/fffY9GiReW2nThxIgoLCzFhwoQHHtPe3h579+7FgAED0KJFC7zxxhv473//i8jIyDJtjxw5gry8PLz77rvw9PSUvqKiogAAbdq0wZ49e3D+/Hn06NED7du3x7x58x44rxAR1TxOKkhEJunbb7/FK6+8ghs3bvAUElEDx9NYRGRS8vLykJycjMWLF2PKlCkMOkTE01hEZFqWLFmCgIAAqFQqzJ0719jlEFEdwNNYREREZNLYs0NEREQmjWGHiIiITBrDDhEREZk0hh0iIiIyaQw7REREZNIYdoiIiMikMewQERGRSWPYISIiIpPGsENEREQm7f8BXUmQbyxSZ9AAAAAASUVORK5CYII=\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} } ], "source": [ @@ -512,7 +505,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "id": "N25CSEyXte8R" }, @@ -546,4 +539,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file From 0a59c177c0bd92a7ba62c28cf35d508569931647 Mon Sep 17 00:00:00 2001 From: Gavin Chan Date: Wed, 5 Jul 2023 14:17:39 +0100 Subject: [PATCH 3/7] Revert the change to add new axis before solving --- arch/unitroot/unitroot.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/arch/unitroot/unitroot.py b/arch/unitroot/unitroot.py index cfe8522ee5..762e15e59e 100644 --- a/arch/unitroot/unitroot.py +++ b/arch/unitroot/unitroot.py @@ -345,7 +345,7 @@ def _autolag_ols( q, r = alinalg.qr(exog) # Convert it to 2-d so as to adapt to linalg.solve input format for all # engines - qpy = (q.T @ endog)[:, anp.newaxis] + qpy = q.T @ endog ypy = endog.T @ endog xpx = exog.T @ exog From ec69fecbc1fa0b3467ed599cb2388e95944dcbd8 Mon Sep 17 00:00:00 2001 From: Gavin Chan Date: Wed, 5 Jul 2023 16:22:49 +0100 Subject: [PATCH 4/7] Fix lint and styling issues --- arch/covariance/kernel.py | 1 - arch/experimental/__init__.py | 21 ++++++++++++++++----- arch/experimental/engine.py | 2 +- arch/unitroot/unitroot.py | 3 +-- 4 files changed, 18 insertions(+), 9 deletions(-) diff --git a/arch/covariance/kernel.py b/arch/covariance/kernel.py index b05806fbc9..ef39f98f8c 100644 --- a/arch/covariance/kernel.py +++ b/arch/covariance/kernel.py @@ -11,7 +11,6 @@ from arch.typing import ArrayLike, Float64Array from arch.utility.array import AbstractDocStringInheritor, ensure1d, ensure2d - __all__ = [ "Bartlett", "Parzen", diff --git a/arch/experimental/__init__.py b/arch/experimental/__init__.py index c0c5483c65..57bd500a73 100644 --- a/arch/experimental/__init__.py +++ b/arch/experimental/__init__.py @@ -1,10 +1,21 @@ from .engine import ( + LinAlgEngine, + NumpyEngine, backend, + fori_loop, + linalg, + numpy, set_backend, use_backend, - NumpyEngine, - LinAlgEngine, - numpy, - linalg, - fori_loop, ) + +__all__ = [ + "LinAlgEngine", + "NumpyEngine", + "backend", + "fori_loop", + "linalg", + "numpy", + "set_backend", + "use_backend", +] diff --git a/arch/experimental/engine.py b/arch/experimental/engine.py index dcdb4534bc..18038b4e7c 100644 --- a/arch/experimental/engine.py +++ b/arch/experimental/engine.py @@ -158,7 +158,7 @@ def fori_loop(lower, upper, body_fun, init_val=None): import tensorflow as tf i = tf.constant(lower) - while_condition = lambda i: tf.less(i, upper) + while_condition = lambda i: tf.less(i, upper) # noqa def body(i, val): return [tf.add(i, 1), body_fun(val)] diff --git a/arch/unitroot/unitroot.py b/arch/unitroot/unitroot.py index 762e15e59e..a7d0d0925b 100644 --- a/arch/unitroot/unitroot.py +++ b/arch/unitroot/unitroot.py @@ -45,6 +45,7 @@ from statsmodels.regression.linear_model import OLS, RegressionResults from statsmodels.tsa.tsatools import lagmat +from arch.experimental import linalg as alinalg, numpy as anp from arch.typing import ( ArrayLike, ArrayLike1D, @@ -86,8 +87,6 @@ invalid_length_doc, ) from arch.utility.timeseries import add_trend -from arch.experimental import numpy as anp, linalg as alinalg - __all__ = [ "ADF", From 61c9fc62d15c79d5d33f7cbef45ab72747055619 Mon Sep 17 00:00:00 2001 From: Gavin Chan Date: Tue, 18 Jul 2023 22:53:09 +0100 Subject: [PATCH 5/7] Add unit test cases --- arch/experimental/__init__.py | 2 - arch/experimental/engine.py | 60 +++++++------------------- arch/tests/experimental/test_engine.py | 59 +++++++++++++++++++++++++ 3 files changed, 74 insertions(+), 47 deletions(-) create mode 100644 arch/tests/experimental/test_engine.py diff --git a/arch/experimental/__init__.py b/arch/experimental/__init__.py index 57bd500a73..8a9c4189db 100644 --- a/arch/experimental/__init__.py +++ b/arch/experimental/__init__.py @@ -2,7 +2,6 @@ LinAlgEngine, NumpyEngine, backend, - fori_loop, linalg, numpy, set_backend, @@ -13,7 +12,6 @@ "LinAlgEngine", "NumpyEngine", "backend", - "fori_loop", "linalg", "numpy", "set_backend", diff --git a/arch/experimental/engine.py b/arch/experimental/engine.py index 18038b4e7c..15dc5c35dd 100644 --- a/arch/experimental/engine.py +++ b/arch/experimental/engine.py @@ -2,6 +2,7 @@ from typing import Any _BACKEND_ENGINE = "numpy" +_SUPPORTED_ENGINES = ["numpy", "tensorflow", "cupy", "jax"] def backend(): @@ -20,7 +21,8 @@ def set_backend(library_name): Library name. Default is `numpy`. Options are `numpy`, `tensorflow`, `cupy` and `jax`. """ - assert library_name.lower() in ["numpy", "tensorflow", "cupy", "jax"], ( + library_name = library_name.lower() + assert library_name in _SUPPORTED_ENGINES, ( "Only `numpy`, `tensorflow`, `cupy` and `jax` are supported, but not " f"{library_name}" ) @@ -42,7 +44,8 @@ def use_backend(library_name="numpy"): Library name. Default is `numpy`. Options are `numpy`, `tensorflow`, `cupy` and `jax`. """ - assert library_name.lower() in ["numpy", "tensorflow", "cupy", "jax"], ( + library_name = library_name.lower() + assert library_name.lower() in _SUPPORTED_ENGINES, ( "Only `numpy`, `tensorflow`, `cupy` and `jax` are supported, but not " f"{library_name}" ) @@ -64,16 +67,12 @@ class NumpyEngine: NumPy engine. """ - @property - def name(self): - """ - Get engine name. - """ - global _BACKEND_ENGINE - return _BACKEND_ENGINE - def __getattribute__(self, __name: str) -> Any: global _BACKEND_ENGINE + + if __name == "name": + return _BACKEND_ENGINE + try: if _BACKEND_ENGINE == "numpy": import numpy as anp @@ -96,7 +95,7 @@ def __getattribute__(self, __name: str) -> Any: return getattr(anp, __name) except AttributeError: raise AttributeError( - "Cannot get attribute / function from numpy library in " + f"Cannot get attribute / function ({__name}) from numpy library in " f"backend engine {_BACKEND_ENGINE}" ) @@ -106,16 +105,12 @@ class LinAlgEngine: Linear algebra engine. """ - @property - def name(self): - """ - Get engine name. - """ - global _BACKEND_ENGINE - return _BACKEND_ENGINE - def __getattribute__(self, __name: str) -> Any: global _BACKEND_ENGINE + + if __name == "name": + return _BACKEND_ENGINE + try: if _BACKEND_ENGINE == "numpy": import numpy.linalg as alinalg @@ -138,35 +133,10 @@ def __getattribute__(self, __name: str) -> Any: return getattr(alinalg, __name) except AttributeError: raise AttributeError( - "Cannot get attribute / function from linalg library in " + f"Cannot get attribute / function ({__name}) from linalg library in " f"backend engine {_BACKEND_ENGINE}" ) -def fori_loop(lower, upper, body_fun, init_val=None): - global _BACKEND_ENGINE - if _BACKEND_ENGINE in ["numpy", "cupy"]: - val = init_val - for i in range(lower, upper): - val = body_fun(i, val) - return val - elif _BACKEND_ENGINE == "jax": - import jax.lax - - return jax.lax.fori_loop(lower, upper, body_fun, init_val) - elif _BACKEND_ENGINE == "tensorflow": - import tensorflow as tf - - i = tf.constant(lower) - while_condition = lambda i: tf.less(i, upper) # noqa - - def body(i, val): - return [tf.add(i, 1), body_fun(val)] - - return tf.while_loop(while_condition, body, [i, init_val]) - - raise ImportError(f"Cannot recognize backend {_BACKEND_ENGINE}") - - numpy = NumpyEngine() linalg = LinAlgEngine() diff --git a/arch/tests/experimental/test_engine.py b/arch/tests/experimental/test_engine.py new file mode 100644 index 0000000000..372c160cf6 --- /dev/null +++ b/arch/tests/experimental/test_engine.py @@ -0,0 +1,59 @@ +import pytest + +from arch.experimental.engine import _SUPPORTED_ENGINES, linalg, numpy, use_backend + + +def test_numpy_name(): + for engine_name in _SUPPORTED_ENGINES: + if engine_name == "tensorflow": + continue + + with use_backend(engine_name): + assert engine_name == numpy.name + + +def test_linalg_name(): + for engine_name in _SUPPORTED_ENGINES: + if engine_name == "tensorflow": + continue + + with use_backend(engine_name): + assert engine_name == linalg.name + + +def test_numpy_getattribute(): + import numpy as np + + with use_backend("numpy"): + array = numpy.array + assert array == np.array + + +def test_linalg_getattribute(): + import numpy.linalg + + with use_backend("numpy"): + inv = linalg.inv + assert inv == numpy.linalg.inv + + +def test_numpy_getattribute_failed(): + with use_backend("numpy"): + with pytest.raises(AttributeError) as exc: + numpy.xyz + + assert str(exc.value) == ( + "Cannot get attribute / function (xyz) from numpy library in " + "backend engine numpy" + ) + + +def test_linalg_getattribute_failed(): + with use_backend("numpy"): + with pytest.raises(AttributeError) as exc: + linalg.xyz + + assert str(exc.value) == ( + "Cannot get attribute / function (xyz) from linalg library in " + "backend engine numpy" + ) From f205cc41ec4d86880c0ac2b257c80669fa37c984 Mon Sep 17 00:00:00 2001 From: Gavin Chan Date: Wed, 19 Jul 2023 07:19:59 +0100 Subject: [PATCH 6/7] Fix styling issue and improve coverages --- arch/experimental/engine.py | 5 +-- arch/tests/experimental/test_engine.py | 45 +++++++++++++++++++++++--- 2 files changed, 41 insertions(+), 9 deletions(-) diff --git a/arch/experimental/engine.py b/arch/experimental/engine.py index 15dc5c35dd..107ae2be6c 100644 --- a/arch/experimental/engine.py +++ b/arch/experimental/engine.py @@ -28,6 +28,7 @@ def set_backend(library_name): ) global _BACKEND_ENGINE _BACKEND_ENGINE = library_name + return _BACKEND_ENGINE @contextmanager @@ -68,8 +69,6 @@ class NumpyEngine: """ def __getattribute__(self, __name: str) -> Any: - global _BACKEND_ENGINE - if __name == "name": return _BACKEND_ENGINE @@ -106,8 +105,6 @@ class LinAlgEngine: """ def __getattribute__(self, __name: str) -> Any: - global _BACKEND_ENGINE - if __name == "name": return _BACKEND_ENGINE diff --git a/arch/tests/experimental/test_engine.py b/arch/tests/experimental/test_engine.py index 372c160cf6..98e6632fa4 100644 --- a/arch/tests/experimental/test_engine.py +++ b/arch/tests/experimental/test_engine.py @@ -1,6 +1,13 @@ import pytest -from arch.experimental.engine import _SUPPORTED_ENGINES, linalg, numpy, use_backend +from arch.experimental.engine import ( + _SUPPORTED_ENGINES, + linalg, + numpy, + use_backend, + set_backend, + backend, +) def test_numpy_name(): @@ -21,6 +28,10 @@ def test_linalg_name(): assert engine_name == linalg.name +def test_set_backend_eq(): + assert set_backend(backend()) == backend() + + def test_numpy_getattribute(): import numpy as np @@ -37,10 +48,10 @@ def test_linalg_getattribute(): assert inv == numpy.linalg.inv -def test_numpy_getattribute_failed(): +def test_numpy_getattribute_failed_attr(): with use_backend("numpy"): with pytest.raises(AttributeError) as exc: - numpy.xyz + numpy.xyz # noqa assert str(exc.value) == ( "Cannot get attribute / function (xyz) from numpy library in " @@ -48,12 +59,36 @@ def test_numpy_getattribute_failed(): ) -def test_linalg_getattribute_failed(): +def test_linalg_getattribute_failed_attr(): with use_backend("numpy"): with pytest.raises(AttributeError) as exc: - linalg.xyz + linalg.xyz # noqa assert str(exc.value) == ( "Cannot get attribute / function (xyz) from linalg library in " "backend engine numpy" ) + + +def test_numpy_getattribute_failed_import(): + with use_backend("jax"): + with pytest.raises(ImportError) as exc: + numpy.array # noqa + + assert str(exc.value) == ( + "Library `numpy` cannot be imported from backend engine " + "jax. Please make sure to install the library " + "via `pip install jax`." + ) + + +def test_linalg_getattribute_failed_attr(): + with use_backend("jax"): + with pytest.raises(ImportError) as exc: + linalg.array # noqa + + assert str(exc.value) == ( + "Library `linalg` cannot be imported from backend engine " + "jax. Please make sure to install the library " + "via `pip install jax`." + ) From 9f75b8e04915c23fcb384cf512c43b688ec4d800 Mon Sep 17 00:00:00 2001 From: Gavin Chan Date: Wed, 19 Jul 2023 07:38:58 +0100 Subject: [PATCH 7/7] Fix lint --- arch/tests/experimental/test_engine.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/arch/tests/experimental/test_engine.py b/arch/tests/experimental/test_engine.py index 98e6632fa4..430b2a2c49 100644 --- a/arch/tests/experimental/test_engine.py +++ b/arch/tests/experimental/test_engine.py @@ -2,11 +2,11 @@ from arch.experimental.engine import ( _SUPPORTED_ENGINES, + backend, linalg, numpy, - use_backend, set_backend, - backend, + use_backend, ) @@ -82,10 +82,10 @@ def test_numpy_getattribute_failed_import(): ) -def test_linalg_getattribute_failed_attr(): +def test_linalg_getattribute_failed_import(): with use_backend("jax"): with pytest.raises(ImportError) as exc: - linalg.array # noqa + linalg.inv # noqa assert str(exc.value) == ( "Library `linalg` cannot be imported from backend engine "