From 5993729a004274da1ae88ef5eada5e1ab64436de Mon Sep 17 00:00:00 2001 From: Tyler Blume Date: Sun, 3 Nov 2024 15:47:05 -0500 Subject: [PATCH 01/12] Added DynamicNBEATs notebook Supports several basis functions for the trend and adds a handler for these functions --- nbs/models.DynamicNBEATs.ipynb | 2424 ++++++++++++++++++++++++++++++++ 1 file changed, 2424 insertions(+) create mode 100644 nbs/models.DynamicNBEATs.ipynb diff --git a/nbs/models.DynamicNBEATs.ipynb b/nbs/models.DynamicNBEATs.ipynb new file mode 100644 index 000000000..2e3183472 --- /dev/null +++ b/nbs/models.DynamicNBEATs.ipynb @@ -0,0 +1,2424 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WjjQM4GGp9lQ", + "outputId": "607671c2-b238-46b0-96d7-b62a7192c954" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting neuralforecast\n", + " Downloading neuralforecast-1.7.5-py3-none-any.whl.metadata (14 kB)\n", + "Collecting datasetsforecast\n", + " Downloading datasetsforecast-0.0.8-py3-none-any.whl.metadata (1.1 kB)\n", + "Collecting coreforecast>=0.0.6 (from neuralforecast)\n", + " Downloading coreforecast-0.0.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.8 kB)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from neuralforecast) (2024.10.0)\n", + "Requirement already satisfied: numpy>=1.21.6 in /usr/local/lib/python3.10/dist-packages (from neuralforecast) (1.26.4)\n", + "Requirement already satisfied: pandas>=1.3.5 in /usr/local/lib/python3.10/dist-packages (from neuralforecast) (2.2.2)\n", + "Requirement already satisfied: torch>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from neuralforecast) (2.5.0+cu121)\n", + "Collecting pytorch-lightning>=2.0.0 (from neuralforecast)\n", + " Downloading pytorch_lightning-2.4.0-py3-none-any.whl.metadata (21 kB)\n", + "Collecting ray>=2.2.0 (from ray[tune]>=2.2.0->neuralforecast)\n", + " Downloading ray-2.38.0-cp310-cp310-manylinux2014_x86_64.whl.metadata (17 kB)\n", + "Collecting optuna (from neuralforecast)\n", + " Downloading optuna-4.0.0-py3-none-any.whl.metadata (16 kB)\n", + "Collecting utilsforecast>=0.0.25 (from neuralforecast)\n", + " Downloading utilsforecast-0.2.7-py3-none-any.whl.metadata (7.4 kB)\n", + "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (3.10.10)\n", + "Collecting fugue>=0.8.1 (from datasetsforecast)\n", + " Downloading fugue-0.9.1-py3-none-any.whl.metadata (18 kB)\n", + "Requirement already satisfied: numba in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (0.60.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (2.32.3)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (4.66.6)\n", + "Requirement already satisfied: xlrd>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (2.0.1)\n", + "Collecting triad>=0.9.7 (from fugue>=0.8.1->datasetsforecast)\n", + " Downloading triad-0.9.8-py3-none-any.whl.metadata (6.3 kB)\n", + "Collecting adagio>=0.2.4 (from fugue>=0.8.1->datasetsforecast)\n", + " Downloading adagio-0.2.6-py3-none-any.whl.metadata (1.8 kB)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.3.5->neuralforecast) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.3.5->neuralforecast) (2024.2)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.3.5->neuralforecast) (2024.2)\n", + "Requirement already satisfied: PyYAML>=5.4 in /usr/local/lib/python3.10/dist-packages (from pytorch-lightning>=2.0.0->neuralforecast) (6.0.2)\n", + "Collecting torchmetrics>=0.7.0 (from pytorch-lightning>=2.0.0->neuralforecast)\n", + " Downloading torchmetrics-1.5.1-py3-none-any.whl.metadata (20 kB)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from pytorch-lightning>=2.0.0->neuralforecast) (24.1)\n", + "Requirement already satisfied: typing-extensions>=4.4.0 in /usr/local/lib/python3.10/dist-packages (from pytorch-lightning>=2.0.0->neuralforecast) (4.12.2)\n", + "Collecting lightning-utilities>=0.10.0 (from pytorch-lightning>=2.0.0->neuralforecast)\n", + " Downloading lightning_utilities-0.11.8-py3-none-any.whl.metadata (5.2 kB)\n", + "Requirement already satisfied: click>=7.0 in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (8.1.7)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (3.16.1)\n", + "Requirement already satisfied: jsonschema in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (4.23.0)\n", + "Requirement already satisfied: msgpack<2.0.0,>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (1.1.0)\n", + "Requirement already satisfied: protobuf!=3.19.5,>=3.15.3 in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (3.20.3)\n", + "Requirement already satisfied: aiosignal in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (1.3.1)\n", + "Requirement already satisfied: frozenlist in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (1.5.0)\n", + "Collecting tensorboardX>=1.9 (from ray[tune]>=2.2.0->neuralforecast)\n", + " Downloading tensorboardX-2.6.2.2-py2.py3-none-any.whl.metadata (5.8 kB)\n", + "Requirement already satisfied: pyarrow>=6.0.1 in /usr/local/lib/python3.10/dist-packages (from ray[tune]>=2.2.0->neuralforecast) (17.0.0)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=2.0.0->neuralforecast) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=2.0.0->neuralforecast) (3.1.4)\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.10/dist-packages (from torch>=2.0.0->neuralforecast) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy==1.13.1->torch>=2.0.0->neuralforecast) (1.3.0)\n", + "Requirement already satisfied: aiohappyeyeballs>=2.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (2.4.3)\n", + "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (24.2.0)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (6.1.0)\n", + "Requirement already satisfied: yarl<2.0,>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (1.17.0)\n", + "Requirement already satisfied: async-timeout<5.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (4.0.3)\n", + "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba->datasetsforecast) (0.43.0)\n", + "Collecting alembic>=1.5.0 (from optuna->neuralforecast)\n", + " Downloading alembic-1.13.3-py3-none-any.whl.metadata (7.4 kB)\n", + "Collecting colorlog (from optuna->neuralforecast)\n", + " Downloading colorlog-6.9.0-py3-none-any.whl.metadata (10 kB)\n", + "Requirement already satisfied: sqlalchemy>=1.3.0 in /usr/local/lib/python3.10/dist-packages (from optuna->neuralforecast) (2.0.36)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->datasetsforecast) (3.4.0)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->datasetsforecast) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->datasetsforecast) (2.2.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->datasetsforecast) (2024.8.30)\n", + "Collecting Mako (from alembic>=1.5.0->optuna->neuralforecast)\n", + " Downloading Mako-1.3.6-py3-none-any.whl.metadata (2.9 kB)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from lightning-utilities>=0.10.0->pytorch-lightning>=2.0.0->neuralforecast) (75.1.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas>=1.3.5->neuralforecast) (1.16.0)\n", + "Requirement already satisfied: greenlet!=0.4.17 in /usr/local/lib/python3.10/dist-packages (from sqlalchemy>=1.3.0->optuna->neuralforecast) (3.1.1)\n", + "Collecting fs (from triad>=0.9.7->fugue>=0.8.1->datasetsforecast)\n", + " Downloading fs-2.4.16-py2.py3-none-any.whl.metadata (6.3 kB)\n", + "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from yarl<2.0,>=1.12.0->aiohttp->datasetsforecast) (0.2.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=2.0.0->neuralforecast) (3.0.2)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema->ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (2024.10.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema->ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (0.35.1)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema->ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (0.20.0)\n", + "Collecting appdirs~=1.4.3 (from fs->triad>=0.9.7->fugue>=0.8.1->datasetsforecast)\n", + " Downloading appdirs-1.4.4-py2.py3-none-any.whl.metadata (9.0 kB)\n", + "Downloading neuralforecast-1.7.5-py3-none-any.whl (254 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m254.8/254.8 kB\u001b[0m \u001b[31m9.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading datasetsforecast-0.0.8-py3-none-any.whl (27 kB)\n", + "Downloading coreforecast-0.0.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (271 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m271.4/271.4 kB\u001b[0m \u001b[31m14.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading fugue-0.9.1-py3-none-any.whl (278 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m278.2/278.2 kB\u001b[0m \u001b[31m27.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pytorch_lightning-2.4.0-py3-none-any.whl (815 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m815.2/815.2 kB\u001b[0m \u001b[31m45.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading ray-2.38.0-cp310-cp310-manylinux2014_x86_64.whl (66.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m66.0/66.0 MB\u001b[0m \u001b[31m32.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading utilsforecast-0.2.7-py3-none-any.whl (41 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m41.4/41.4 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading optuna-4.0.0-py3-none-any.whl (362 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m362.8/362.8 kB\u001b[0m \u001b[31m28.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading adagio-0.2.6-py3-none-any.whl (19 kB)\n", + "Downloading alembic-1.13.3-py3-none-any.whl (233 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m233.2/233.2 kB\u001b[0m \u001b[31m22.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading lightning_utilities-0.11.8-py3-none-any.whl (26 kB)\n", + "Downloading tensorboardX-2.6.2.2-py2.py3-none-any.whl (101 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.7/101.7 kB\u001b[0m \u001b[31m11.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading torchmetrics-1.5.1-py3-none-any.whl (890 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m890.6/890.6 kB\u001b[0m \u001b[31m60.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading triad-0.9.8-py3-none-any.whl (62 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.3/62.3 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading colorlog-6.9.0-py3-none-any.whl (11 kB)\n", + "Downloading fs-2.4.16-py2.py3-none-any.whl (135 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m135.3/135.3 kB\u001b[0m \u001b[31m15.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading Mako-1.3.6-py3-none-any.whl (78 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.6/78.6 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading appdirs-1.4.4-py2.py3-none-any.whl (9.6 kB)\n", + "Installing collected packages: appdirs, tensorboardX, Mako, lightning-utilities, fs, coreforecast, colorlog, alembic, utilsforecast, triad, torchmetrics, optuna, ray, adagio, pytorch-lightning, fugue, neuralforecast, datasetsforecast\n", + "Successfully installed Mako-1.3.6 adagio-0.2.6 alembic-1.13.3 appdirs-1.4.4 colorlog-6.9.0 coreforecast-0.0.13.1 datasetsforecast-0.0.8 fs-2.4.16 fugue-0.9.1 lightning-utilities-0.11.8 neuralforecast-1.7.5 optuna-4.0.0 pytorch-lightning-2.4.0 ray-2.38.0 tensorboardX-2.6.2.2 torchmetrics-1.5.1 triad-0.9.8 utilsforecast-0.2.7\n" + ] + } + ], + "source": [ + "# pip install neuralforecast datasetsforecast" + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from numpy.polynomial.legendre import Legendre\n", + "from numpy.polynomial.chebyshev import Chebyshev\n", + "from scipy.interpolate import BSpline\n", + "\n", + "def generate_legendre_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates Legendre polynomial basis functions.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of basis functions to generate.\n", + "\n", + " Returns:\n", + " - legendre_basis (ndarray): An array of Legendre basis functions.\n", + " \"\"\"\n", + " x = np.linspace(-1, 1, length) # Legendre polynomials are defined on [-1, 1]\n", + " legendre_basis = np.zeros((length, n_basis))\n", + "\n", + " for i in range(n_basis):\n", + " # Legendre polynomial of degree i\n", + " P_i = Legendre.basis(i)\n", + " legendre_basis[:, i] = P_i(x)\n", + "\n", + " return legendre_basis\n", + "\n", + "\n", + "def generate_polynomial_2_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates standard polynomial basis functions.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of polynomial functions to generate.\n", + "\n", + " Returns:\n", + " - poly_basis (ndarray): An array of polynomial basis functions.\n", + " \"\"\"\n", + " x = np.linspace(-1, 1, length)\n", + " poly_basis = np.zeros((length, n_basis))\n", + "\n", + " for i in range(n_basis):\n", + " poly_basis[:, i] = x ** i\n", + "\n", + " return poly_basis\n", + "\n", + "def generate_polynomial_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates standard polynomial basis functions.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of polynomial functions to generate.\n", + "\n", + " Returns:\n", + " - poly_basis (ndarray): An array of polynomial basis functions.\n", + " \"\"\"\n", + " return np.concatenate([np.power(np.arange(length, dtype=float) / length, i)[None, :]\n", + " for i in range(n_basis)]).T\n", + "\n", + "\n", + "def generate_changepoint_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates changepoint basis functions with automatically spaced changepoints.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of changepoint functions to generate.\n", + "\n", + " Returns:\n", + " - changepoint_basis (ndarray): An array of changepoint basis functions.\n", + " \"\"\"\n", + " x = np.linspace(0, 1, length)\n", + " changepoint_basis = np.zeros((length, n_basis))\n", + "\n", + " # Evenly space changepoint locations between 0 and 1\n", + " changepoint_locations = np.linspace(0, 1, n_basis + 1)[1:] # Avoid 0 to prevent all zeros\n", + "\n", + " for i, cp in enumerate(changepoint_locations):\n", + " changepoint_basis[:, i] = np.maximum(0, x - cp)\n", + "\n", + " return changepoint_basis\n", + "\n", + "def generate_piecewise_linear_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates piecewise linear basis functions (linear splines).\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of piecewise linear basis functions to generate.\n", + "\n", + " Returns:\n", + " - pw_linear_basis (ndarray): An array of piecewise linear basis functions.\n", + " \"\"\"\n", + " x = np.linspace(0, 1, length)\n", + " knots = np.linspace(0, 1, n_basis+1)\n", + " pw_linear_basis = np.zeros((length, n_basis))\n", + "\n", + " for i in range(1, n_basis):\n", + " pw_linear_basis[:, i] = np.maximum(0, np.minimum((x - knots[i-1]) / (knots[i] - knots[i-1]), (knots[i+1] - x) / (knots[i+1] - knots[i])))\n", + "\n", + " return pw_linear_basis\n", + "\n", + "def generate_spline_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates cubic spline basis functions.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of basis functions.\n", + "\n", + " Returns:\n", + " - spline_basis (ndarray): An array of cubic spline basis functions.\n", + " \"\"\"\n", + " x = np.linspace(0, 1, length)\n", + " knots = np.linspace(0, 1, n_basis - 2) # Internal knots\n", + " t = np.concatenate(([0, 0, 0], knots, [1, 1, 1])) # Knot sequence for cubic splines\n", + " degree = 3 # Cubic splines\n", + "\n", + " spline_basis = np.zeros((length, n_basis))\n", + " for i in range(n_basis):\n", + " coef = np.zeros(n_basis)\n", + " coef[i] = 1 # Each basis function has one coefficient set to 1\n", + " spline = BSpline(t, coef, degree)\n", + " spline_basis[:, i] = spline(x)\n", + "\n", + " return spline_basis\n", + "\n", + "def generate_chebyshev_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates Chebyshev polynomial basis functions.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of Chebyshev polynomials to generate.\n", + "\n", + " Returns:\n", + " - chebyshev_basis (ndarray): An array of Chebyshev polynomial basis functions.\n", + " \"\"\"\n", + " x = np.linspace(-1, 1, length)\n", + " chebyshev_basis = np.zeros((length, n_basis))\n", + "\n", + " for i in range(n_basis):\n", + " T_i = Chebyshev.basis(i)\n", + " chebyshev_basis[:, i] = T_i(x)\n", + "\n", + " return chebyshev_basis\n", + "\n", + "def generate_piecewise_2_basis(length, n_basis):\n", + " array_splits = np.array_split(np.zeros(length),n_basis+1)[:-1]\n", + " initial_point = 0\n", + " final_point = 0\n", + " changepoints = np.zeros(shape=(length, n_basis))\n", + " len_splits = 0\n", + " for i in range(n_basis):\n", + " len_splits += len(array_splits[i])\n", + " moving_point = 1\n", + " left_basis = np.linspace(initial_point,\n", + " moving_point,\n", + " len_splits)\n", + " end_point = 0\n", + " right_basis = np.linspace(moving_point,\n", + " end_point,\n", + " length - len_splits + 1)\n", + " changepoints[:, i] = np.append(left_basis, right_basis[1:])\n", + " # changepoints[:, i+1] = 1\n", + " return changepoints" + ], + "metadata": { + "id": "0EB19ilyu5Aq" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "SbrL4vyEpmwK", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "5cae4ca0-3146-4fc2-cf85-1125796bd9a8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.10/dist-packages/dask/dataframe/__init__.py:42: FutureWarning: \n", + "Dask dataframe query planning is disabled because dask-expr is not installed.\n", + "\n", + "You can install it with `pip install dask[dataframe]` or `conda install dask`.\n", + "This will raise in a future version.\n", + "\n", + " warnings.warn(msg, FutureWarning)\n" + ] + } + ], + "source": [ + "# -*- coding: utf-8 -*-\n", + "from typing import Tuple, Optional\n", + "\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "\n", + "from neuralforecast.losses.pytorch import MAE\n", + "from neuralforecast.common._base_windows import BaseWindows\n", + "\n", + "class IdentityBasis(nn.Module):\n", + " def __init__(self, backcast_size: int, forecast_size: int,\n", + " out_features: int=1):\n", + " super().__init__()\n", + " self.out_features = out_features\n", + " self.forecast_size = forecast_size\n", + " self.backcast_size = backcast_size\n", + "\n", + " def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n", + " backcast = theta[:, :self.backcast_size]\n", + " forecast = theta[:, self.backcast_size:]\n", + " forecast = forecast.reshape(len(forecast), -1, self.out_features)\n", + " return backcast, forecast\n", + "\n", + "def get_basis(length, n_basis, basis):\n", + " basis_dict = {\n", + " 'legendre': generate_legendre_basis,\n", + " 'polynomial': generate_polynomial_basis,\n", + " 'polynomial_2': generate_polynomial_2_basis,\n", + " 'changepoint': generate_changepoint_basis,\n", + " 'piecewise_linear': generate_piecewise_linear_basis,\n", + " 'piecewise_linear_2': generate_piecewise_2_basis,\n", + " 'spline': generate_spline_basis,\n", + " 'chebyshev': generate_chebyshev_basis\n", + " }\n", + " return basis_dict[basis](length, n_basis+1)\n", + "\n", + "class TrendBasis(nn.Module):\n", + " def __init__(self, n_basis: int,\n", + " backcast_size: int,\n", + " forecast_size: int,\n", + " out_features: int=1,\n", + " basis='polynomial'):\n", + " super().__init__()\n", + " self.out_features = out_features\n", + " # polynomial_size = degree_of_polynomial + 2\n", + " self.backcast_basis = nn.Parameter(\n", + " torch.tensor(get_basis(backcast_size, n_basis, basis).T, dtype=torch.float32), requires_grad=False)\n", + " self.forecast_basis = nn.Parameter(\n", + " torch.tensor(get_basis(forecast_size, n_basis, basis).T, dtype=torch.float32), requires_grad=False)\n", + "\n", + " def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n", + " polynomial_size = self.forecast_basis.shape[0] # [polynomial_size, L+H]\n", + " backcast_theta = theta[:, :polynomial_size]\n", + " forecast_theta = theta[:, polynomial_size:]\n", + " forecast_theta = forecast_theta.reshape(len(forecast_theta),polynomial_size,-1)\n", + " backcast = torch.einsum('bp,pt->bt', backcast_theta, self.backcast_basis)\n", + " forecast = torch.einsum('bpq,pt->btq', forecast_theta, self.forecast_basis)\n", + " return backcast, forecast\n", + "\n", + "class SeasonalityBasis(nn.Module):\n", + " def __init__(self, harmonics: int,\n", + " backcast_size: int, forecast_size: int,\n", + " out_features: int=1):\n", + " super().__init__()\n", + " self.out_features = out_features\n", + " frequency = np.append(np.zeros(1, dtype=float),\n", + " np.arange(harmonics, harmonics / 2 * forecast_size,\n", + " dtype=float) / harmonics)[None, :]\n", + " backcast_grid = -2 * np.pi * (\n", + " np.arange(backcast_size, dtype=float)[:, None] / forecast_size) * frequency\n", + " forecast_grid = 2 * np.pi * (\n", + " np.arange(forecast_size, dtype=float)[:, None] / forecast_size) * frequency\n", + "\n", + " backcast_cos_template = torch.tensor(np.transpose(np.cos(backcast_grid)), dtype=torch.float32)\n", + " backcast_sin_template = torch.tensor(np.transpose(np.sin(backcast_grid)), dtype=torch.float32)\n", + " backcast_template = torch.cat([backcast_cos_template, backcast_sin_template], dim=0)\n", + "\n", + " forecast_cos_template = torch.tensor(np.transpose(np.cos(forecast_grid)), dtype=torch.float32)\n", + " forecast_sin_template = torch.tensor(np.transpose(np.sin(forecast_grid)), dtype=torch.float32)\n", + " forecast_template = torch.cat([forecast_cos_template, forecast_sin_template], dim=0)\n", + "\n", + " self.backcast_basis = nn.Parameter(backcast_template, requires_grad=False)\n", + " self.forecast_basis = nn.Parameter(forecast_template, requires_grad=False)\n", + "\n", + " def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n", + " harmonic_size = self.forecast_basis.shape[0] # [harmonic_size, L+H]\n", + " backcast_theta = theta[:, :harmonic_size]\n", + " forecast_theta = theta[:, harmonic_size:]\n", + " forecast_theta = forecast_theta.reshape(len(forecast_theta),harmonic_size,-1)\n", + " backcast = torch.einsum('bp,pt->bt', backcast_theta, self.backcast_basis)\n", + " forecast = torch.einsum('bpq,pt->btq', forecast_theta, self.forecast_basis)\n", + " return backcast, forecast\n", + "\n", + "\n", + "\n", + "ACTIVATIONS = ['ReLU',\n", + " 'Softplus',\n", + " 'Tanh',\n", + " 'SELU',\n", + " 'LeakyReLU',\n", + " 'PReLU',\n", + " 'Sigmoid']\n", + "\n", + "class NPBEATSBlock(nn.Module):\n", + " \"\"\"\n", + " N-PBEATS block which takes a basis function as an argument.\n", + " \"\"\"\n", + " def __init__(self,\n", + " input_size: int,\n", + " n_theta: int,\n", + " mlp_units: list,\n", + " basis: nn.Module,\n", + " dropout_prob: float,\n", + " activation: str):\n", + " \"\"\"\n", + " \"\"\"\n", + " super().__init__()\n", + "\n", + " self.dropout_prob = dropout_prob\n", + "\n", + " assert activation in ACTIVATIONS, f'{activation} is not in {ACTIVATIONS}'\n", + " activ = getattr(nn, activation)()\n", + "\n", + " hidden_layers = [nn.Linear(in_features=input_size,\n", + " out_features=mlp_units[0][0])]\n", + " for layer in mlp_units:\n", + " hidden_layers.append(nn.Linear(in_features=layer[0],\n", + " out_features=layer[1]))\n", + " hidden_layers.append(activ)\n", + "\n", + " if self.dropout_prob>0:\n", + " raise NotImplementedError('dropout')\n", + " #hidden_layers.append(nn.Dropout(p=self.dropout_prob))\n", + "\n", + " output_layer = [nn.Linear(in_features=mlp_units[-1][1], out_features=n_theta)]\n", + " layers = hidden_layers + output_layer\n", + " self.layers = nn.Sequential(*layers)\n", + " self.basis = basis\n", + "\n", + " def forward(self, insample_y: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n", + " # Compute local projection weights and projection\n", + " theta = self.layers(insample_y)\n", + " backcast, forecast = self.basis(theta)\n", + " return backcast, forecast\n", + "\n", + "\n", + "#| export\n", + "class DynamicNBEATS(BaseWindows):\n", + " \"\"\" DynamicNBEATS\n", + "\n", + " The Neural Piecewise Basis Expansion Analysis for Time Series (DynamicNBEATS), is a simple and yet\n", + " effective architecture, it is built with a deep stack of MLPs with the doubly\n", + " residual connections. It has a generic and interpretable architecture depending\n", + " on the blocks it uses. Its interpretable architecture is recommended for scarce\n", + " data settings, as it regularizes its predictions through projections unto harmonic\n", + " and trend basis well-suited for most forecasting tasks.\n", + "\n", + " **Parameters:**
\n", + " `h`: int, forecast horizon.
\n", + " `input_size`: int, considered autorregresive inputs (lags), y=[1,2,3,4] input_size=2 -> lags=[1,2].
\n", + " `n_harmonics`: int, Number of harmonic terms for seasonality stack type. Note that len(n_harmonics) = len(stack_types). Note that it will only be used if a seasonality stack is used.
\n", + " `n_basis`: int, the number of basis functions for trend stack. Note that it will only be used if a trend stack is used.
\n", + " `stack_types`: List[str], List of stack types. Subset from ['seasonality', 'trend', 'identity'].
\n", + " `n_blocks`: List[int], Number of blocks for each stack. Note that len(n_blocks) = len(stack_types).
\n", + " `mlp_units`: List[List[int]], Structure of hidden layers for each stack type. Each internal list should contain the number of units of each hidden layer. Note that len(n_hidden) = len(stack_types).
\n", + " `dropout_prob_theta`: float, Float between (0, 1). Dropout for N-BEATS basis.
\n", + " `shared_weights`: bool, If True, all blocks within each stack will share parameters.
\n", + " `activation`: str, activation from ['ReLU', 'Softplus', 'Tanh', 'SELU', 'LeakyReLU', 'PReLU', 'Sigmoid'].
\n", + " `loss`: PyTorch module, instantiated train loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).
\n", + " `valid_loss`: PyTorch module=`loss`, instantiated valid loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).
\n", + " `max_steps`: int=1000, maximum number of training steps.
\n", + " `learning_rate`: float=1e-3, Learning rate between (0, 1).
\n", + " `num_lr_decays`: int=3, Number of learning rate decays, evenly distributed across max_steps.
\n", + " `early_stop_patience_steps`: int=-1, Number of validation iterations before early stopping.
\n", + " `val_check_steps`: int=100, Number of training steps between every validation loss check.
\n", + " `batch_size`: int=32, number of different series in each batch.
\n", + " `valid_batch_size`: int=None, number of different series in each validation and test batch, if None uses batch_size.
\n", + " `windows_batch_size`: int=1024, number of windows to sample in each training batch, default uses all.
\n", + " `inference_windows_batch_size`: int=-1, number of windows to sample in each inference batch, -1 uses all.
\n", + " `start_padding_enabled`: bool=False, if True, the model will pad the time series with zeros at the beginning, by input size.
\n", + " `step_size`: int=1, step size between each window of temporal data.
\n", + " `scaler_type`: str='identity', type of scaler for temporal inputs normalization see [temporal scalers](https://nixtla.github.io/neuralforecast/common.scalers.html).
\n", + " `random_seed`: int, random_seed for pytorch initializer and numpy generators.
\n", + " `num_workers_loader`: int=os.cpu_count(), workers to be used by `TimeSeriesDataLoader`.
\n", + " `drop_last_loader`: bool=False, if True `TimeSeriesDataLoader` drops last non-full batch.
\n", + " `alias`: str, optional, Custom name of the model.
\n", + " `**trainer_kwargs`: int, keyword trainer arguments inherited from [PyTorch Lighning's trainer](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).
\n", + "\n", + " **References:**
\n", + " -[Boris N. Oreshkin, Dmitri Carpov, Nicolas Chapados, Yoshua Bengio (2019).\n", + " \"N-BEATS: Neural basis expansion analysis for interpretable time series forecasting\".](https://arxiv.org/abs/1905.10437)\n", + " \"\"\"\n", + " # Class attributes\n", + " SAMPLING_TYPE = 'windows'\n", + "\n", + " def __init__(self,\n", + " h,\n", + " input_size,\n", + " n_harmonics: int = 2,\n", + " n_basis: int = 5,\n", + " basis: str = 'polynomial',\n", + " stack_types: list = ['identity', 'trend', 'seasonality'],\n", + " n_blocks: list = [1, 1, 1],\n", + " mlp_units: list = 3 * [[512, 512]],\n", + " dropout_prob_theta: float = 0.,\n", + " activation: str = 'ReLU',\n", + " shared_weights: bool = False,\n", + " loss = MAE(),\n", + " valid_loss = None,\n", + " max_steps: int = 1000,\n", + " learning_rate: float = 1e-3,\n", + " num_lr_decays: int = 3,\n", + " early_stop_patience_steps: int =-1,\n", + " val_check_steps: int = 100,\n", + " batch_size: int = 32,\n", + " valid_batch_size: Optional[int] = None,\n", + " windows_batch_size: int = 1024,\n", + " inference_windows_batch_size: int = -1,\n", + " start_padding_enabled = False,\n", + " step_size: int = 1,\n", + " scaler_type: str ='identity',\n", + " random_seed: int = 1,\n", + " num_workers_loader: int = 0,\n", + " drop_last_loader: bool = False,\n", + " **trainer_kwargs):\n", + "\n", + " # Inherit BaseWindows class\n", + " super(DynamicNBEATS, self).__init__(h=h,\n", + " input_size=input_size,\n", + " loss=loss,\n", + " valid_loss=valid_loss,\n", + " max_steps=max_steps,\n", + " learning_rate=learning_rate,\n", + " num_lr_decays=num_lr_decays,\n", + " early_stop_patience_steps=early_stop_patience_steps,\n", + " val_check_steps=val_check_steps,\n", + " batch_size=batch_size,\n", + " windows_batch_size=windows_batch_size,\n", + " valid_batch_size=valid_batch_size,\n", + " inference_windows_batch_size=inference_windows_batch_size,\n", + " start_padding_enabled=start_padding_enabled,\n", + " step_size=step_size,\n", + " scaler_type=scaler_type,\n", + " num_workers_loader=num_workers_loader,\n", + " drop_last_loader=drop_last_loader,\n", + " random_seed=random_seed,\n", + " **trainer_kwargs)\n", + "\n", + " # Architecture\n", + " blocks = self.create_stack(h=h,\n", + " input_size=input_size,\n", + " stack_types=stack_types,\n", + " n_blocks=n_blocks,\n", + " mlp_units=mlp_units,\n", + " dropout_prob_theta=dropout_prob_theta,\n", + " activation=activation,\n", + " shared_weights=shared_weights,\n", + " n_basis=n_basis,\n", + " n_harmonics=n_harmonics,\n", + " basis_type=basis)\n", + " self.blocks = torch.nn.ModuleList(blocks)\n", + "\n", + " def create_stack(self, stack_types,\n", + " n_blocks,\n", + " input_size,\n", + " h,\n", + " mlp_units,\n", + " dropout_prob_theta,\n", + " activation, shared_weights,\n", + " n_basis, n_harmonics, basis_type):\n", + "\n", + " block_list = []\n", + " for i in range(len(stack_types)):\n", + " for block_id in range(n_blocks[i]):\n", + "\n", + " # Shared weights\n", + " if shared_weights and block_id>0:\n", + " npbeats_block = block_list[-1]\n", + " else:\n", + " if stack_types[i] == 'seasonality':\n", + " n_theta = 2 * (self.loss.outputsize_multiplier + 1) * \\\n", + " int(np.ceil(n_harmonics / 2 * h) - (n_harmonics - 1))\n", + " basis = SeasonalityBasis(harmonics=n_harmonics,\n", + " backcast_size=input_size,forecast_size=h,\n", + " out_features=self.loss.outputsize_multiplier)\n", + "\n", + " elif stack_types[i] == 'trend':\n", + " n_theta = (self.loss.outputsize_multiplier + 1) * (n_basis + 1)\n", + " basis = TrendBasis(n_basis=n_basis,\n", + " backcast_size=input_size,forecast_size=h,\n", + " out_features=self.loss.outputsize_multiplier,\n", + " basis=basis_type)\n", + "\n", + " elif stack_types[i] == 'identity':\n", + " n_theta = input_size + self.loss.outputsize_multiplier * h\n", + " basis = IdentityBasis(backcast_size=input_size, forecast_size=h,\n", + " out_features=self.loss.outputsize_multiplier)\n", + " else:\n", + " raise ValueError(f'Block type {stack_types[i]} not found!')\n", + "\n", + " npbeats_block = NPBEATSBlock(input_size=input_size,\n", + " n_theta=n_theta,\n", + " mlp_units=mlp_units,\n", + " basis=basis,\n", + " dropout_prob=dropout_prob_theta,\n", + " activation=activation)\n", + "\n", + " # Select type of evaluation and apply it to all layers of block\n", + " block_list.append(npbeats_block)\n", + "\n", + " return block_list\n", + "\n", + " def forward(self, windows_batch):\n", + "\n", + " # Parse windows_batch\n", + " insample_y = windows_batch['insample_y']\n", + " insample_mask = windows_batch['insample_mask']\n", + "\n", + " # NPBEATS' forward\n", + " residuals = insample_y.flip(dims=(-1,)) # backcast init\n", + " insample_mask = insample_mask.flip(dims=(-1,))\n", + "\n", + " forecast = insample_y[:, -1:, None] # Level with Naive1\n", + " block_forecasts = [ forecast.repeat(1, self.h, 1) ]\n", + " for i, block in enumerate(self.blocks):\n", + " backcast, block_forecast = block(insample_y=residuals)\n", + " residuals = (residuals - backcast) * insample_mask\n", + " forecast = forecast + block_forecast\n", + "\n", + " if self.decompose_forecast:\n", + " block_forecasts.append(block_forecast)\n", + "\n", + " # Adapting output's domain\n", + " forecast = self.loss.domain_map(forecast)\n", + "\n", + " if self.decompose_forecast:\n", + " # (n_batch, n_blocks, h, out_features)\n", + " block_forecasts = torch.stack(block_forecasts)\n", + " block_forecasts = block_forecasts.permute(1,0,2,3)\n", + " block_forecasts = block_forecasts.squeeze(-1) # univariate output\n", + " return block_forecasts\n", + " else:\n", + " return forecast\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 555, + "referenced_widgets": [ + "bb8fb55556ac451fbe17df79d10c2b56", + "a0bedda309594a8587d725e23ab569e4", + "011a85465fb742b596cc725b4246aa01", + "94fb8d26156f4af3b1e21ba882b5a3fc", + "1b8af82b0f0d4ef39409262baf9360aa", + "945e8c93915747e1b99860966291da1b", + "47d8345be1ea47e8831a9e5d4386b7a8", + "7816477075504b2cb3ef6fa8aa57bf09", + "c01752b4d3b84a9b897360744a43375d", + "8f2cf806a1b5453cbabaa5871f9eb9bd", + "64a042cc36014ba0aa6b23606bda8554", + "c1a1d5b7043647a29aeb3ea4fdc34ecf", + "ef67032131af4828b82e47a5a710fef5", + "c4e4d98af60a420b804742db2c7a5e5d", + "d56f16d908504149948dbe7497980bc3", + "63ada147711b4c339004a99c353962eb", + "f8b2b298f2044b1abe670fc84b7658bd", + "d0b51366bc814f1c99cd4153c3fe4ec0", + "84857f37c01849d3a796bd1c07eebc54", + "0758c138f86540bbba775d599589deb2", + "27a657fb36f5489d8ae3e3c6180db997", + "6f32c5b55fb342fd985dbda4ade77b82", + "588d220a6d634b03ae463c2cc5902b58", + "d8302f528c1f4c018b7bd641d152b617", + "40063d0d85254615a05e68084d2dcafa", + "b560422245e94bb7b5804a6b8bd31dca", + "d4c66b4520ab40898ac04010fa926c5b", + "c53abfe7cf5f43daa0a8dd56853cc3a6", + "c4e26937963f48b994111d8b5a6e4a28", + "dbe2f9e88d2c4b649afc033bc8603083", + "2a5fe8a3fa2140a694d503bc00400f12", + "947b94882e8144beaca020c64f4588e2", + "b3eb5210e0d747c0a5abae14b4691997", + "1fbe190298c742fcb44273f22bff9e22", + "6217a4d543cb4a329ff1014735c563f1", + "e30a0a034d1a47f7b8134d78ea7eb0bf", + "5e2cef4d25e54553bd11d7adfb8dd2f9", + "095bbaae5e1d4789b9a370f074439027", + "f895197c32e646bda4e825796946807c", + "a7231112c75e4c89b5c2a234008ff080", + "7d289fa9ce354637bbb1e3d2798e3674", + "cabd9a2793c148c1b72e64d19da35ed5", + "7fd831200ddf4e3c9f44df09bee746c7", + "6d54edada0d34b71bc34b0c105712913" + ] + }, + "id": "tyFH2QP5qXxL", + "outputId": "ef18a25c-317f-4bde-91b4-ce8393895435" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "INFO:lightning_fabric.utilities.seed:Seed set to 1\n", + "INFO:pytorch_lightning.utilities.rank_zero:GPU available: True (cuda), used: True\n", + "INFO:pytorch_lightning.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", + "INFO:pytorch_lightning.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", + "INFO:pytorch_lightning.utilities.rank_zero:You are using a CUDA device ('NVIDIA A100-SXM4-40GB') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", + "INFO:pytorch_lightning.accelerators.cuda:LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "INFO:pytorch_lightning.callbacks.model_summary:\n", + " | Name | Type | Params | Mode \n", + "-------------------------------------------------------\n", + "0 | loss | MAE | 0 | train\n", + "1 | padder_train | ConstantPad1d | 0 | train\n", + "2 | scaler | TemporalNorm | 0 | train\n", + "3 | blocks | ModuleList | 2.5 M | train\n", + "-------------------------------------------------------\n", + "2.4 M Trainable params\n", + "1.0 K Non-trainable params\n", + "2.5 M Total params\n", + "9.802 Total estimated model params size (MB)\n", + "31 Modules in train mode\n", + "0 Modules in eval mode\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Sanity Checking: | | 0/? [00:00]" + ] + }, + "metadata": {}, + "execution_count": 5 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "plt.plot(np.append(Y_train_df['y'].values, y_hat_test_w_val))" + ] + }, + { + "cell_type": "code", + "source": [ + "if __name__ == '__main__':\n", + " # Example usage:\n", + " n_points = 100 # Number of points in time series\n", + " n_functions = 5 # Number of basis functions\n", + "\n", + " # Generate Legendre polynomial basis functions\n", + " legendre_basis = generate_legendre_basis(n_points, n_functions)\n", + "\n", + " # Generate standard polynomial basis functions\n", + " poly_basis = generate_polynomial_basis(n_points, n_functions)\n", + "\n", + " # Generate standard polynomial basis functions\n", + " poly_2_basis = generate_polynomial_2_basis(n_points, n_functions)\n", + "\n", + " # Generate changepoint basis functions\n", + " changepoint_basis = generate_changepoint_basis(n_points, n_functions)\n", + "\n", + " # Generate haar basis functions\n", + " pw_basis = generate_piecewise_linear_basis(n_points, n_functions)\n", + "\n", + " # Generate haar basis functions\n", + " spline_basis = generate_spline_basis(n_points, n_functions)\n", + "\n", + " # Generate haar basis functions\n", + " cheby_basis = generate_chebyshev_basis(n_points, n_functions)\n", + "\n", + " # Generate haar basis functions\n", + " pw2_basis = generate_piecewise_2_basis(n_points, n_functions)\n", + "\n", + "\n", + " # Plotting the basis functions for visualization\n", + " plt.figure(figsize=(12, 20))\n", + "\n", + " n_plots = 8\n", + "\n", + " # Plot Legendre basis functions\n", + " plt.subplot(n_plots, 1, 1)\n", + " for i in range(n_functions):\n", + " plt.plot(legendre_basis[:, i], label=f'Legendre {i}')\n", + " plt.title('Legendre Polynomial Basis')\n", + " plt.legend()\n", + "\n", + " # Plot Polynomial basis functions\n", + " plt.subplot(n_plots, 1, 2)\n", + " for i in range(n_functions):\n", + " plt.plot(poly_basis[:, i], label=f'Polynomial {i}')\n", + " plt.title('Polynomial Basis')\n", + " plt.legend()\n", + "\n", + " # Plot Polynomial 2 basis functions\n", + " plt.subplot(n_plots, 1, 3)\n", + " for i in range(n_functions):\n", + " plt.plot(poly_2_basis[:, i], label=f'Polynomial 2 {i}')\n", + " plt.title('Polynomial 2 Basis')\n", + " plt.legend()\n", + "\n", + " # Plot Changepoint basis functions\n", + " plt.subplot(n_plots, 1, 4)\n", + " for i in range(n_functions):\n", + " plt.plot(changepoint_basis[:, i], label=f'Changepoints {i}')\n", + " plt.title('Changepoint Basis')\n", + " plt.legend()\n", + "\n", + " # Plot Changepoint basis functions\n", + " plt.subplot(n_plots, 1, 5)\n", + " for i in range(n_functions):\n", + " plt.plot(pw_basis[:, i], label=f'PW {i}')\n", + " plt.title('Piecewise Basis')\n", + " plt.legend()\n", + "\n", + " # Plot Changepoint basis functions\n", + " plt.subplot(n_plots, 1, 6)\n", + " for i in range(n_functions):\n", + " plt.plot(spline_basis[:, i], label=f'Spline {i}')\n", + " plt.title('Spline Basis')\n", + " plt.legend()\n", + "\n", + " # Plot Changepoint basis functions\n", + " plt.subplot(n_plots, 1, 7)\n", + " for i in range(n_functions):\n", + " plt.plot(cheby_basis[:, i], label=f'Cheby {i}')\n", + " plt.title('Cheby Basis')\n", + " plt.legend()\n", + "\n", + " # Plot Changepoint basis functions\n", + " plt.subplot(n_plots, 1, 8)\n", + " for i in range(np.shape(pw2_basis)[1]):\n", + " plt.plot(pw2_basis[:, i], label=f'PW2 {i}')\n", + " plt.title('PW2 Basis')\n", + " plt.legend()\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n" + ], + "metadata": { + "id": "orrAIsdZpd6F", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "ee63042c-f9f7-428e-c6a5-f412b15c9f29" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "ncwrNSTLv1R1" + }, + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "colab": { + "provenance": [], + "machine_shape": "hm", + "gpuType": "A100" + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "bb8fb55556ac451fbe17df79d10c2b56": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a0bedda309594a8587d725e23ab569e4", + "IPY_MODEL_011a85465fb742b596cc725b4246aa01", + "IPY_MODEL_94fb8d26156f4af3b1e21ba882b5a3fc" + ], + "layout": "IPY_MODEL_1b8af82b0f0d4ef39409262baf9360aa" + } + }, + "a0bedda309594a8587d725e23ab569e4": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_945e8c93915747e1b99860966291da1b", + "placeholder": "​", + "style": "IPY_MODEL_47d8345be1ea47e8831a9e5d4386b7a8", + "value": "Sanity Checking DataLoader 0: 100%" + } + }, + "011a85465fb742b596cc725b4246aa01": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7816477075504b2cb3ef6fa8aa57bf09", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c01752b4d3b84a9b897360744a43375d", + "value": 1 + } + }, + "94fb8d26156f4af3b1e21ba882b5a3fc": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8f2cf806a1b5453cbabaa5871f9eb9bd", + "placeholder": "​", + "style": "IPY_MODEL_64a042cc36014ba0aa6b23606bda8554", + "value": " 1/1 [00:00<00:00,  2.15it/s]" + } + }, + "1b8af82b0f0d4ef39409262baf9360aa": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "945e8c93915747e1b99860966291da1b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47d8345be1ea47e8831a9e5d4386b7a8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7816477075504b2cb3ef6fa8aa57bf09": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c01752b4d3b84a9b897360744a43375d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8f2cf806a1b5453cbabaa5871f9eb9bd": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "64a042cc36014ba0aa6b23606bda8554": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "c1a1d5b7043647a29aeb3ea4fdc34ecf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_ef67032131af4828b82e47a5a710fef5", + "IPY_MODEL_c4e4d98af60a420b804742db2c7a5e5d", + "IPY_MODEL_d56f16d908504149948dbe7497980bc3" + ], + "layout": "IPY_MODEL_63ada147711b4c339004a99c353962eb" + } + }, + "ef67032131af4828b82e47a5a710fef5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f8b2b298f2044b1abe670fc84b7658bd", + "placeholder": "​", + "style": "IPY_MODEL_d0b51366bc814f1c99cd4153c3fe4ec0", + "value": "Epoch 99: 100%" + } + }, + "c4e4d98af60a420b804742db2c7a5e5d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_84857f37c01849d3a796bd1c07eebc54", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0758c138f86540bbba775d599589deb2", + "value": 1 + } + }, + "d56f16d908504149948dbe7497980bc3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_27a657fb36f5489d8ae3e3c6180db997", + "placeholder": "​", + "style": "IPY_MODEL_6f32c5b55fb342fd985dbda4ade77b82", + "value": " 1/1 [00:00<00:00, 18.75it/s, v_num=0, train_loss_step=8.660, train_loss_epoch=8.660, valid_loss=13.70]" + } + }, + "63ada147711b4c339004a99c353962eb": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "f8b2b298f2044b1abe670fc84b7658bd": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d0b51366bc814f1c99cd4153c3fe4ec0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "84857f37c01849d3a796bd1c07eebc54": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0758c138f86540bbba775d599589deb2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "27a657fb36f5489d8ae3e3c6180db997": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f32c5b55fb342fd985dbda4ade77b82": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "588d220a6d634b03ae463c2cc5902b58": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_d8302f528c1f4c018b7bd641d152b617", + "IPY_MODEL_40063d0d85254615a05e68084d2dcafa", + "IPY_MODEL_b560422245e94bb7b5804a6b8bd31dca" + ], + "layout": "IPY_MODEL_d4c66b4520ab40898ac04010fa926c5b" + } + }, + "d8302f528c1f4c018b7bd641d152b617": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_c53abfe7cf5f43daa0a8dd56853cc3a6", + "placeholder": "​", + "style": "IPY_MODEL_c4e26937963f48b994111d8b5a6e4a28", + "value": "Validation DataLoader 0: 100%" + } + }, + "40063d0d85254615a05e68084d2dcafa": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_dbe2f9e88d2c4b649afc033bc8603083", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2a5fe8a3fa2140a694d503bc00400f12", + "value": 1 + } + }, + "b560422245e94bb7b5804a6b8bd31dca": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_947b94882e8144beaca020c64f4588e2", + "placeholder": "​", + "style": "IPY_MODEL_b3eb5210e0d747c0a5abae14b4691997", + "value": " 1/1 [00:00<00:00, 114.27it/s]" + } + }, + "d4c66b4520ab40898ac04010fa926c5b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": "hidden", + "width": "100%" + } + }, + "c53abfe7cf5f43daa0a8dd56853cc3a6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c4e26937963f48b994111d8b5a6e4a28": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "dbe2f9e88d2c4b649afc033bc8603083": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2a5fe8a3fa2140a694d503bc00400f12": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "947b94882e8144beaca020c64f4588e2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b3eb5210e0d747c0a5abae14b4691997": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1fbe190298c742fcb44273f22bff9e22": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6217a4d543cb4a329ff1014735c563f1", + "IPY_MODEL_e30a0a034d1a47f7b8134d78ea7eb0bf", + "IPY_MODEL_5e2cef4d25e54553bd11d7adfb8dd2f9" + ], + "layout": "IPY_MODEL_095bbaae5e1d4789b9a370f074439027" + } + }, + "6217a4d543cb4a329ff1014735c563f1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f895197c32e646bda4e825796946807c", + "placeholder": "​", + "style": "IPY_MODEL_a7231112c75e4c89b5c2a234008ff080", + "value": "Predicting DataLoader 0: 100%" + } + }, + "e30a0a034d1a47f7b8134d78ea7eb0bf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7d289fa9ce354637bbb1e3d2798e3674", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_cabd9a2793c148c1b72e64d19da35ed5", + "value": 1 + } + }, + "5e2cef4d25e54553bd11d7adfb8dd2f9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7fd831200ddf4e3c9f44df09bee746c7", + "placeholder": "​", + "style": "IPY_MODEL_6d54edada0d34b71bc34b0c105712913", + "value": " 1/1 [00:00<00:00, 110.39it/s]" + } + }, + "095bbaae5e1d4789b9a370f074439027": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": "inline-flex", + "flex": null, + "flex_flow": "row wrap", + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "100%" + } + }, + "f895197c32e646bda4e825796946807c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a7231112c75e4c89b5c2a234008ff080": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7d289fa9ce354637bbb1e3d2798e3674": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": "2", + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cabd9a2793c148c1b72e64d19da35ed5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "7fd831200ddf4e3c9f44df09bee746c7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6d54edada0d34b71bc34b0c105712913": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From dc81923dc0ed5be0d063165c4d09955672a050a9 Mon Sep 17 00:00:00 2001 From: marcopeix Date: Thu, 12 Dec 2024 09:53:50 -0500 Subject: [PATCH 02/12] Option to choose basis in NBEATS + experiment --- .../nbeats_basis_experiment.ipynb | 419 +++ nbs/models.DynamicNBEATs.ipynb | 2424 ----------------- nbs/models.ipynb | 2 + nbs/models.nbeats.ipynb | 211 +- neuralforecast/_modidx.py | 18 +- neuralforecast/auto.py | 2 + neuralforecast/models/nbeats.py | 201 +- 7 files changed, 792 insertions(+), 2485 deletions(-) create mode 100644 experiments/nbeats_basis/nbeats_basis_experiment.ipynb delete mode 100644 nbs/models.DynamicNBEATs.ipynb diff --git a/experiments/nbeats_basis/nbeats_basis_experiment.ipynb b/experiments/nbeats_basis/nbeats_basis_experiment.ipynb new file mode 100644 index 000000000..4dd133df5 --- /dev/null +++ b/experiments/nbeats_basis/nbeats_basis_experiment.ipynb @@ -0,0 +1,419 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "env: PYTORCH_ENABLE_MPS_FALLBACK=1\n" + ] + } + ], + "source": [ + "%set_env PYTORCH_ENABLE_MPS_FALLBACK=1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from datetime import datetime, timedelta" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(42)\n", + "\n", + "def generate_time_series(n_points=1000, base_value=100):\n", + " start_date = datetime(2024, 1, 1)\n", + " timestamps = [start_date + timedelta(hours=x) for x in range(n_points)]\n", + " \n", + " x = np.arange(n_points)\n", + " trend = np.zeros(n_points)\n", + " \n", + " changepoints = [200, 400, 700]\n", + " slopes = [0.05, -0.03, 0.03, 0.01] # Different slopes for each segment\n", + " \n", + " current_pos = 0\n", + " for i, cp in enumerate(changepoints):\n", + " trend[current_pos:cp] = x[current_pos:cp] * slopes[i]\n", + " current_pos = cp\n", + " trend[current_pos:] = x[current_pos:] * slopes[-1]\n", + " \n", + " hours = np.arange(n_points) % 24\n", + " seasonality = 15 * np.sin(2 * np.pi * hours / 24) + \\\n", + " 5 * np.cos(4 * np.pi * hours / 24) \n", + " \n", + " noise = np.random.normal(0, 2, n_points)\n", + " \n", + " values = base_value + trend + seasonality + noise\n", + " \n", + " df = pd.DataFrame({\n", + " 'unique_id': 'series_001',\n", + " 'ds': timestamps,\n", + " 'y': values\n", + " })\n", + " \n", + " return df\n", + "\n", + "df = generate_time_series()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOx9eZxlVXX1elONXT1DNw3NjBABsUFFARFkEgU0qHxIVFSM+T4TI3EmRkWNYDABI8QpQSGiYoxiUJMoKIINyiSNTMoM3XQ3DT1Ud41vuPf7475z7z7n7n3OudVVXa+qz/r9+tdVr86777z37j13nbX3XrsUx3GMgICAgICAgICAGY/ydE8gICAgICAgICBgchCIXUBAQEBAQEDALEEgdgEBAQEBAQEBswSB2AUEBAQEBAQEzBIEYhcQEBAQEBAQMEsQiF1AQEBAQEBAwCxBIHYBAQEBAQEBAbMEgdgFBAQEBAQEBMwSVKd7Ap2AKIqwdu1aDAwMoFQqTfd0AgICAgICAgJSxHGMbdu2YdmyZSiX7ZpcIHYA1q5di+XLl0/3NAICAgICAgICRKxevRp77LGHdUwgdgAGBgYAJB/Y3Llzp3k2AQEBAQEBAQEZtm7diuXLl6d8xYZA7IA0/Dp37txA7AICAgICAgI6Ej7pYqF4IiAgICAgICBgliAQu4CAgICAgICAWYJA7AICAgICAgICZgkCsQsICAgICAgImCUIxC4gICAgICAgYJYgELuAgICAgICAgFmCQOwCAgICAgICAmYJArELCAgICAgICJglCMQuICAgICAgIGCWIBC7gICAgICAgIBZgkDsAgICAgICAgJmCQKxCwgICAgICAiYJQjELiAgICCgI/DohiFsHq5P9zQCAmY0qtM9gYCAgICAgCefH8aJl96c/Pz5103zbAICZi6CYhcQEBAQMO2488lN0z2FgIBZgUDsAgICAgKmHaVSabqnEBAwKxCIXUBAQEDAtKNckNfVmxHueXozWlE8NRMKCJihCMQuICAgIGDaUS6o2H38uvvwp1++DV+88eEpmlFAwMxEIHYBAQEBAdMOyuvi2K3Cff/uNQCAy3/56FRNKSBgRiIQu4CAgICAaQdV7EJ4NSBg4gjELiAgICBgWrHykefx9KaR9PdmIHYBARNG8LELCAgICJg2PLRuK9565e3aY41WhJ5axfsYj24Ywv67zpnsqQUEzEgExS4gICAgYNrw+HPDuccarWKK3V9++3fWvz/5/DAefnZboWMGBMxUBGIXEBAQEDBtWNBXyz3WbEXO53VXs9vXHy2kLY5jHPePv8LJl92CwZHGxCYZEDCDEIhdQEBAQMC0ocVUwDY8cux6u/xCtbQQ46lNeXUwIGC2IRC7gICAgJ0UT28cwSNTGKKM4xjD403rmAajzjWabsWup6oTO8kihRZiDI+3nMcNCJjpCMQuICAgYCfFsV+4CSdddgs2D9edY/9r1TO46L8f8vKYU/ib763CwZ/6mZU81pv54zUjN7EzFTspL48qdiN1O8kMCJgNCFWxAQEBATshaB7bM1tGsaC/yzr+/deuAgA8v20cAz1VfPL0g1Fx9AH70aq1AIArVz6Bz7/xRfw8GBLnUzyxoK+GJ8jv9VaErmpeq2iSYw3Xg2IXMPsRiF1AQEDALMJTG4dRq5SxbH6vdVydELsi3bx+eM8zAICX7L0Qpx+2zOs5NqLGhmI9iidMr7t6MwK6uXHZsUYcYeGAgNmAQOwCAgICZgm2jTXwqi/8CgDwxMWvRcnC2MYbbvKk8PhzQ7nH1g+OeT/fFlptMKFYH8XOHDPe5NU4GordOhaqYgNmP0KOXUBAQMAswbNbM7I17ihAoIqdK6Xt1f90s/X5HJ7eSDpJWIgadxwfu5OWMem68H6psrd1NCh2AbMfgdgFBAQEzBJQhc5F7Khi5yJp/PPt+WrHfuGm9GebYseROB/FziSLErGjit22oNgF7AQIxC4gICBgloAWrLqIV72V/V0iRYAc4hwvQAZtih1H4hoeVbHmGInIUsUu9KAN2BkwrcTulltuwemnn45ly5ahVCrhRz/6kfb3Cy+8EAcddBD6+/uxYMECnHjiibj9dr2n4Pj4ON73vvdh8eLF6O/vxxlnnIE1a9bswHcREBAQ0BmgBG3MkUNHiZBNsds2xocvi+To2QyHudf28bHLKXbCe6Ah28DrAnYGTCuxGx4exmGHHYYrrriC/fsLXvACXHHFFbjvvvuwcuVK7L333jj55JPx3HPPpWPOP/98XHfddbj22muxcuVKDA0N4bTTTkOrFcraAwICdi5QciMpbdnfCbGzEKmto3z40hXqpTDz4Sg4Nc9HWTPHSESTKoJFPPgCAmYqprUq9tRTT8Wpp54q/v2cc87Rfr/00ktx5ZVX4ve//z1OOOEEDA4O4sorr8S3vvUtnHjiiQCAa665BsuXL8eNN96IU045ZUrnHxAQENBJ8FXsvnfn07jpD9kG2WYvslVQ7Gxk0DxeUbuTv73uPrxkrwXYdW6P+DyVm9dVKaPeiiyKHSV24uECAmYNZkyOXb1ex9e//nXMmzcPhx12GADg7rvvRqPRwMknn5yOW7ZsGQ455BDcdttt0zXVgICAgGkBJVuSYhdFMT76g/vwvw+sZ59nQlLsbOHbIYMMtiwKHEfstow08OH//L34HCBT+vq6kw4UPlWxUWB2ATsBOt7H7ic/+QnOPvtsjIyMYLfddsMNN9yAxYsXAwDWr1+Prq4uLFiwQHvOkiVLsH79eu5wAJK8vPHx8fT3rVu3Ts3kAwICAnYgaEGEpNhxhQlWYidUktqKM4YMI2CbfYlEEO95erP4HCAjbH21CragYamKDTl2ATsXOl6xO/7447Fq1SrcdttteM1rXoOzzjoLGzZssD4njmOrMefFF1+MefPmpf+WL18+2dMOCAgI2OHQQ7Fuw970eRMonrA9xySDtlCsVDE76qjqVRYqfd2JPvH+a+/B6k0j+XEhxy5gJ0PHE7v+/n7sv//+ePnLX44rr7wS1WoVV155JQBg6dKlqNfr2LxZ39lt2LABS5YsEY95wQUXYHBwMP23evXqKX0PAQEBATsC41oo1h2aVLDanQgESyKOQD4Ua+08YRDENx6+R/vxWMz9i+M4JYv9XZX2a8T4ws/+mBur5diJswgImD3oeGJnIo7jNIx6xBFHoFar4YYbbkj/vm7dOtx///046qijxGN0d3dj7ty52r+AgICAmQ4fxY5TyGzqm1ShavOme9pQzop0nljQV0t/llS725/YlP5Mp8e950bIsQvYyTCtOXZDQ0N49NFH09+feOIJrFq1CgsXLsSiRYvwuc99DmeccQZ22203bNy4EV/+8pexZs0avPnNbwYAzJs3D+eddx4++MEPYtGiRVi4cCE+9KEP4dBDD02rZAMCAgJ2FtCQp6zYFcuxk4idzZvuf+7Xc5xthsMm6evtqqBcSgjbWL2FuT213HPO/vpv05/XDY6mP++5sC83NuTYBexsmFZid9ddd+H4449Pf//ABz4AADj33HPx1a9+FX/4wx9w9dVX4/nnn8eiRYvw0pe+FL/+9a9x8MEHp8+57LLLUK1WcdZZZ2F0dBQnnHACrrrqKlQqlR3+fgICAgKmE/UmLZ7wz7Gz2Z1IhQ82Mmjmuq3eNIpWFKNSzuc+m69dKpXQW6tguN7CSN3tR/r8UD2bK/PeKHEMil3AzoBpJXbHHXecNZn1hz/8ofMYPT09uPzyy3H55ZdP5tQCAgICZhx0g2JBsWPCotffuxYfPPlAdrxU+GCriuUI2QNrB/GiPeYzxzdagzVa6O2qYrjechZQAEBfVyV9PY60ao8FXhewE2DG5dgFBAQEdAq+eesT+Kvv/M5q57Ej4ZVjx5CfpzaOYNNwnRktFz7Yiic4Qmbm3SnUDeI41mihtyu5Nfkodlee+1IyV3sXi6DYBewMCMQuICBgp8ejG7bhgbWDhZ/36R8/iJ/8fh1+et+6KZhVhsgzOazu0f9VIqEyseNfe8wSih2p5y1SJNsUcz6jjRb6akkwSSKP+yzuBwBUyiW8Yr9F+PApidrItS5rBWIXsJMhELuAgICdGlEU48RLb8HrvrRSNON14dmtY5M8qwxX3foEXvyZn+P+Z9zEc5yQpEYBuxMAGB6XiJdA7ATSFUUxa45sWqAomKHYsUaEnraFiaTYqTDwD/5f4n5Qbefuce+NHj8UTwTsDAjELiAgYKcGrdh8btu4ZaQMibRMBi788YPYOtbEx390v3MsVeykggipvZdM7ORQLJcjPSa0MtsmkGYzFJsodpX0Zw6qs8WctjmxKsrglM3QKzZgZ0MgdgEBATs1aPRuop0JhsbduWDbi4rcTCfFuBaKFWxKBKJmtgFLxwtEMIr5wgpJZdsqKXZNU7Frobet2I0yId31g2PpsQZ6EmJnU+yaGrELzC5g9iMQu4CAgJ0azUnwOZPUrslErWJfrm9++Dl85/an098LK3YMiQKAVpu8dVfzr8+pc6MCsRNz7CKzKjZCr1LsmGN9/Lr70p9Txa792biqYkOOXcDOgEDsAgICdmpMxo1/SCBFE0Ecx6x61sUQKwC4/5lBnH/tPTj3G3doj0vEzlS1BtrkSFIdVahaqWgUXJ6dpNgNjfOhWKX6HbZ8PgDgQ6cciFpFVuB+9fBz6c+KAHorduwMAgJmFwKxCwgI2KlBw4m21lcmaFhvMhW7C69/AId86me488lN2uNdgmJ39td/ix+tWpt7XDIQ/m+jgnfXud0A3MUTPdU8sRtniiS4ilhAVuzUPD99xsG4/9On4GX7LEzVSa6y94SDdgWQdJkotwmdyrHjFbtQPBGwcyEQu4CAgFmH+9YM4rHnhrzGUjJg68Bge95kErurf/MUAODSnz+sPS6FYsXcOOa9NFsR/r19fIXFc+zETr1PH8Vu21gD7776LvY4rlBsrVJKQ6u1tjrZaMoK3F+9ev/0sZBjFxCQYVo7TwQEBARMNjZsG8PpV6wEADz5+dc5x9McL6nLAv+8bKytvdZEYYaFpVCsBK54gnt/qgDBRRDZHDtDsfvmrU9io+CHJ1W4qjlRRVL9zJHT8XZeH51Pptjlx1NyGHLsAnYGBMUuICBgVuHJ5/kOBxImqthRYie179oexNAJY1Fix/nYmaHNg5YO4NDd5wOwhGLb77OPU+yM4gmpAAPICJk0zyohdirHjiV2DUU0s/koYseF0n/5xw3pz4HXBewMCMQuICBgVoH6rvmE3jTlrUgotjWx5/nijic24W1X3p7+LoViOcIF8KSIPjbQU8V///UrMadHdXng34N6zh4L+nJ/M0Oxi/q72GPYjq8+uxrxc7Hl2CkS3V3LPo+qkGPXbEW4d/WW9Peg2AXsDAjELiAgYEYgjmNcfduTuO2x563jHly3Nf1Zsvag0BS7AspbQwvhTk2v2Nuf2OQcs6CPJ1MuYtdsxSiXS5m1iBAqVZ/PfrvMyf3NJGtze2riPMcdvWu7NMWuaCi2rB3LPLZCKJ4I2BkQiF1AQMCMwG8f34RPXf8AzvnX28Uxz20bx9//9KH0d6l9FkVzgsobJYSrN43it49vFMduHBrH9feuxY0PPjvhBP6ixsJceJjmmzVTG5PkNiC1CFOfz96L3Yqd7fPmesu2ojj9HKki2WUpnkgVOxKKVYqdqciZ8wnFEwE7AwKxCwgImBF4Zsuoc8xTG4e13wsrdhPMsQMS2xEJJ1x6M/76u/fg3f9+F37y+3XiOOvrMXOL4zjNjTv2BbvgmP0X45OnvRAA/14ocVVFCzYzYID42NXcVbF0jsfsv1h/7WaEb9+uV+TSOVa1UKxPjl2+eMLMsWu1TGKXO1xAwKxDIHYBAQEzAkqVsaFijPFS7GhIlVGITDw/NI4Pff9e3OkRJlXYMpKZ8/7byie8n0fBtfYab0bpe7z8LStwzbuPTI1+uQpYs8sDAPR2JTl2krGwIktcjp+pwqnXfPVBu7IK38ev0/vd0u+nxoRiOQVVFWz0eOTYNYz3G3LsAnYGBGIXEBAwI0BJG9fsHQDKJZ3Y+Sh2ZvHE4GgDz20bF8d/5scP4j/vXoPzv7fKeWwO967egiefH3YPNMApdrSStb9dRKGULDbHjiGuSokTQ7Htz6dSLmlkCsjnzSkitai/C687dBkAYOncHva4yXyyOXLErnBVrEHkzO8/5NgF7AwIxC4gIKDjcccTm/B3P8rUHslexFR4ODJkQsuxa0Y44rM34KWfu1HMXXtyY3FSZuK4f/wVPv3jBwo9h7PyUHPsrVVSuxAbKeIUMFfxhPoMq5US9l7Ur/0tH4ptq3vVMl6x3yL87PxjceMHXyW+JzXHckkn7qqQwnzPcRyzxRMqjJtT7Iz3G3LsAnYGBGIXEBDQ8Tjra7/B4GgWzvzP361hx5lGwT6hWEoGtozU0+dIqhrXWssGyb/tm7c+Weg4HClTId75fVk1qspPY4snOGLXLp4QiR0pbvjns1dgIbE0Mati1fFrbZJ24NKBtJsEh8zqRL8V1aol7e90LurrooqdUmrN79skeoHWBewMCMQuICBgxuETP7qffdwkUX6h2Iw8PLNlLP1ZqpDtrhVbNqVWWkXBKXZbRhWxy8iWTbHjHutxFU8oxa5cwoFLB3D3352Iv3jVvgDyip3KsasKnnsmmkzXCdt7oGRV97FLfs752OVCsYHaBcx+BGIXEBAwa2Aqdjf9cQPufmqz9TmUDPyAKIFUIaTgWmvZMGnEjil82DKStO+a35spdsoqhGtzxip2bWI33oxyuYsbto1hzeakGlmRp1KplKqWZueJhqDASUjHVyVip8+H5vRRMlgResWaZJj5CAMCZh0CsQsICJg1MMOPn/yvB/DGr9xmzbWTwrWDIxKx40OxBy0dYB/fNsYfhwOXA3buK/YCwFe5Do7mQ7G97SKKKAbuWzOoja9zxROkc8X9a/XxP7t/ffoztSPpSQsu+JxG2kXChjpRAymkXrG0S0WZPEfKsTPJcFDsAnYGBGIXEBAwazAutK2yeeBJ4dqiip3kgff8kFxh6zMX1cqLV+zyxG5uTw2v2HcRAODnD67XxtM5/tvbXwJAzxn8+588pI2nRHn/XbPOE6o61gzF1i3WKBwawvjU7sTMmWxlFboUFbGlWCByATsfArELCAiYkeAsT8YFcvWExV5EUuy2CIpdl0DsJIL4/bv4Qg8zr0yay+4LegHwViVqjvN69bZiL1w2N3mOQWwUsTv2BbvgxBcuAQBN+Rqu62FjJXCduWJ3jXy5FLuqp2KnxpufqWRQrBS3imFrI/aKDTl2ATshArELCAjoWDRaET74H/fyf2MULKkfqY3YtYTEK0mxkyARxIdI71oAuP1vT0helyEZnOq3qF2Fyr1fFeYd6NErTytCiy11/C6DeP2/4/YDoKtygO5hR6FUS7NYhev7CiBVEE3UhdBtrcrn2EnzCT52ARSbh+tY69GpZrYiELuAgICOxX+tWqsVNFBwOWdSJevm4br4GuZx9lyYhD6HxnliZ75GTcjvUthKiifedfQ+KemhfVIVzNBhX1fmT8eFFSUipew/zONLodJdB7rZ8Yr0mgqcRBylnLl/PvvFAABDaMuqaMv6fKQcu0ggdmJVbPCxK4x/+/XjePfVd7LFNzMFKz57A476/C+t171CHMe4/5lBsSp8JiIQu4CAgI6FLT+Nu/FIOXZcOy4FkwyofDUpP8skgqqYglPs4jjG1rbyd8uHj8cnT3+hFnY034Opyt32sVenxJErAGmJCpb+9/T4Tb5qtSoQNadCZipqaSjWOH779zjWQ+hNZ1WsocDFLsXOHooNvM6Nv//pQ7jxoQ24/t610z2V7cajzw05x/zk9+tw2uUr8ZZ/lXs9zzQEYhcQENCxsPnQ+XZWAPTWVSbMm/+8tnWIRAbNY6nuD9xcRxut9PiL5iQhVSuxa5kksyslOSONVk5xEoldyR6KNYldWSRqvKImH59XEKniRz9vKTSsyKz5+aj3a7aOU+/fJI75UGxgdr4YrU+OTc+OBv3+fTI9/+Ou1QCAVau3TM2EpgGB2AUEBHQspJ6wQDHFztaBomWQQWX2K1mkSNWv3Pito8nNsVIuoa9tK1Itl9KQ5HjLbMmVHeNjpx4EANh7UT+6qmVsGWngsef0XEFZseNDkymRqvoRQXdOG398M3RLQ7N0TnWBOEo+dkrQNOdDyTLtoJEvvsBOhzWbRyYWgjbj5gyefH4Y192zxnqd7mhQ1bvk8R7MtAEJT20cxn+temZGhPMDsQuYdZB6fAbMPHAFBgqcOie175KUPABYOzim/T6vNylEkMigdCxu/NZ2ccPcnmp6kymVSqmiJSl283pr+L+vSgoaersqeMleCwAAdz25iX1N31CsRKTKQlVpmmMnEDvzht4Ucvjo/OiNNw0NG6HYriofilXFEeb7ndNdTUPotJevej/q8453sqZi3/rNkzjmH27C5//nD4Wf68N3jvvHX+FvvncvfrTqmQnMbmpANwMuXjfWaOGmPz7nddzTvrQS7792VarwdTICsQuYVfj0jx/AIZ/6GX77+MbpnkrAJKCoYiclfEvqWxTF+Potj2uP9bd7mxZW7Dhi186vm0s6QwBydwhFXMwq0QVtFdH0jWsJREciapIdSWoXYryFiSp2uSpXQiRb5EXU+82HYsvp8ek5EAk5dgCw3y5JRe/jRNVU4XQ1n52t88Snrn8AAPA14xz3QckrkJnA1d1lR4KmSrjewZd+8Yj3cbe1BYPr7ukcEishELuAWYPv37U6baz+jz/74/ROJmBSYFPsfHuhJo/zx+Ea36scO0mxM491QTtkyuXYZYqdTuyUXYip/imvulxOm0C81O+mr5v63fz8WoIPXGbwy+e0SYpdLtQbyYqgeskmE4rNGxTzCp/6uMz5A8C+i/sB6NY26v0oRXAmhNEmE0UjpPTz8YhipvA1pN4RoGuA6/3f8cQm+wAGTz4/Uvg5Oxqd820EBGwnPvyfv09/NpOrA2YmpJw5QOiFKpIx/jimAvbJ016I5e1ODzJJ1B9/0xF7AEhIjkkcRtoWCrRtFwAxFKtCyaZhrxT6dNqRCFWhZVPhE+xRMsVOIJpS1S1j4syZCKvxZhUtJQqUSKfFE4xip0Kx1GTZDA13UCpYR4J+N56pZwD889R2BOhmyVZ8Bdg3jhLWbx1zD5pmBGIXMCtRDmf2rMCwxVuKy3UrGj41Fbt3HbMPsRcRcuwMMkbVqVxOW3us2YZMCsVu2JbYu+zS9pVTKEsKnFAlmo2H1/iMCBrjVU6eSRyF+aShZOZGr16DfhdS6Fkjdk2qwPCKY3L8sjbn5Pg7d45dUVA1tUgo1iTmk421W0bxrCehoteUrUc04CZ+MxXh9hcwKxEUu9kBm+UC16pLImPS47QlljLRVUTNV/2rCFYeQHFit65dyLF0Xo/+GkIxhCtUmlf4lAIHdnyeqPE5bVXBlDlVyBjFrsZU6kr2KJVyiSWCUhUwkH0G9DtIiV01KHZv/8YdTtNhullyLaFUnTaJue053/rNk7j5Yb+CBQAYqTdx1Od/iSMv+oUXEWswxJ5DFMX4/ZpB73nMJARiFzArEYjd7IBNseOSmCUyJlWyqlDs4jldeP2LdweQkRZZ/Ute44i9FuAn7ztGI1XmjWS8yfdCVb+bvW3XDyZtkHabaxI7F1HzK56IpRy7El8MIVXFyp0t+PFARoC1HLsmH0qmx+BCaxyx48LDTaOYY2fLsaO45eHn8GOH6bDN79HEOBlr5lRyaLYiHPDx/8En/usBnPuNOxAxqQsc1pOqdZ9uGJwizOHaO/PVrS6Fb6YgELuAWYnA62YHzBw4F6S+r79+5Hms3pRPelY5baoSFiAVmWLnieQ1Pn3GwThk93kayWgZz1E3IlORknLsJMXOFYrNt9iyF0+Y/l6ifUnhFl58MYQ2J8agmBvfxXjZ2XLsuEpdNT7k2CW49dHnrX+nn7XLzJm24OKIuYn7nhnUvptXXnIT3vvt3zmfR+dksy0CgA3bxvB3P7o//V26hgGwrQrHCxDbTkYgdgGzEtyOHgDuf2YQH/7+vdouMKBzUbRfpVT9CgB/+Z38TWS0nhy/p5oVNygCYrb3Sp/TJpuKLOiKnf4cdSPyLYbYMpJU0S7s7/IaL7bYEhS1tKrUU+GTQr1lITRsI2p8jh0figWycK4Wik0Vx9xwtrK3aRC7HanYbdg61nH9VmnfYg7cdyNhhGy6fD7XZ7fq7QGf2TKK/7l/vfN51JtSypVV+PufPKR1kLC9B27ONmJHz9FOz80LxC5gh2BHh0CkUOxpl6/E9+9eg7/70X07dD4BE4NrITehQilmThsAPLRua+4xpQj21LLxVYti99y2cWwZaaBUAvZY0AsgUb+kKtHxNMdOr4p1+cCZRFBS7NQcC4diPVuQqfnler86OlvwodX8cxTx4Ygg11YssoRi2Ry7lq6Y7qj78R/Xb8PLLvoFXv8vt+6YF2Rw9W1P5h5zFa9qxM6ySQJ0xa7uGAsAz20rvpletXoL7npyMzs/Do8ZvWGtxI55zBYhoGvKSIe3W5tWYnfLLbfg9NNPx7Jly1AqlfCjH/0o/Vuj0cBHP/pRHHrooejv78eyZcvw9re/HWvX6jkC4+PjeN/73ofFixejv78fZ5xxBtasyUusAdOHv/neKpx46c2Fw2rbA1eO3eNGa6aAzoS5MP/LOYdjydxuYXQ2vqdWyf2NU4XG2mpANxlfs+TYPbA2SbbeZ3G/Fr6ViFpdyLFLFTiJSIn2Ivp8JMNe9VbN4ytSZV4e0vzllmXtv3v2igVI7iITiuWIYNZWLK/Ycdc3m2OnFLsq/3lPFf6r3YmB20xMFPc/M4hHN2zzGhtFcWpOTOFKUfEtPAB0YueTm6Yqvn3x/NA43vAvt+IzP3kwfcylgO7d9jIsMi8Km2JHi6RGLbm/nYBpJXbDw8M47LDDcMUVV+T+NjIygt/97nf4xCc+gd/97nf44Q9/iIcffhhnnHGGNu7888/Hddddh2uvvRYrV67E0NAQTjvtNLRanf3B70y47p5n8Nhzw/j1I/b8ju3BfxktbVzV9wM9VfuAgI6AuZC/7kW74Tt//vL0dzM0qW5MVIFT6GbInqqK7a3RUKxcFas2BAcuGdAe5/LH6PzzxE7KUePtP1xE0CyGkIobXAbFUo5dvuo2by2SjJeJGke8JppjZyu20BU7MxSbe9qUYLKVwS0jdZx2+UqceOktXtEPiaC4nqordnZSRFWrRivCT36/Fu/85h3YPFzPjW1FMS7/5aP2FydYPziG869dZZ0fh10NmyCxLWAzwj1Pb8k9bhMf6HlrK+rqBEzr3e3UU0/Fqaeeyv5t3rx5uOGGG7THLr/8crzsZS/D008/jT333BODg4O48sor8a1vfQsnnngiAOCaa67B8uXLceONN+KUU06Z8vcQ4I+pNLF8v7EIuBS7e9cMYutYI9cRIKCzwC3k1OOtEUXoLmekTN2M+ruqAHSFgFORRtlQrKzYDbZbhC0QcuDyVbEt9rUVL8mHYvnQp0jUBKIjhYalUKakwEktyzgfuziO0/nbiieaTLiPzbHjFDvBhw8AKircqnW20EPzOyolxAwJbi+o2nXLI8/jCz/7A/7+DYfixcvns+O5jiqAW4UrkmOnroXkeTH+6jv3AACuuOlRfOK0F2pj739GthWJojhXDPOuq+7Eg4zaWW/a5yQV85j4ntDv1abY0WP//U8exFffdkRHddyg6MxZCRgcHESpVML8+fMBAHfffTcajQZOPvnkdMyyZctwyCGH4LbbbpumWQZQ0IvBp3JqssAt/GaD+LdfeceOmk7ABMHdXGjfUXPhVuN3m69XlQJZOI5iPCV2+eIJ7qagWoTNM3q/cqQFcCt2eYWMN/h1+djlDIeFnDn1dNHQWLgx5kLDTFiV/lxj7C/UMZoM8eJ80NT35Wt3wil26vNX3++OyLG75+nNuOHBZyf1mHRTfO437sD9z2zFO74pr1+S8uQmdnl1VMLDz2ZhYUoIh5gCjeeHMmL6pyt2d86JI3WAuyrWVPilKvlVjFoH+Ct2v/jDBvzyDxusc5lOzBhiNzY2ho997GM455xzMHfuXADA+vXr0dXVhQULFmhjlyxZgvXr5Wqb8fFxbN26VfsXMDWgF4pUqToV4AS7jUN6iIBWTwV0JjhfLbpBMMmXusHsPr839zyzgAEgxRNVmmOnQrH51946mty0TKW3wpAWIK8YZePBjpcUO4moZVWr+d6s9O/p+DRHTX9fUjGEmGOn5sOEPZP5M8SLMTXOcuwsip1354n88ZUCo77fHZFj99/3rfMeu3m47pV7zM1aVVBzkBQ7iegAiZpZpGvDQ+t4Yme2zwOAje3w7KtesAsWGWp3kQpTWyj20Q3bcPdTm7XHpCr5FyyZwz5+7jfuyAkACuY8P/PjB8Wx040ZQewajQbOPvtsRFGEL3/5y87xcRznfJooLr74YsybNy/9t3z58smcbgABXbSmSrbmwiscieQWO1MxCegscHluVL0wyZciF7vP78s9jy2eaChFhwvFyord3F49i8WVY5cndjxRk4oJXHYkpkAmzUcKxUr2JXKOHaOOkZuut92JVyiWqkhqvsUUu+6aainWOXhmyyiO+Ydf4l1X3ekc66pQNSEl99vsgD7wH/firVfenr1mIcUuG8sRu01tYreovyuXxiDZCnGQDJSjKMaJl96CRzboIXCJNEqpOuPNCD/8Xd74HMh/Hs9sGcW/FMgb3JHoeGLXaDRw1lln4YknnsANN9yQqnUAsHTpUtTrdWzerLP0DRs2YMmSJeIxL7jgAgwODqb/Vq/m4+0B248xxqpgsvHws/l8Fu7C5XZ7Yx264wpIQL+z1xy8FEBiLyKFS1Uo8/C95ueOZYZDgSxPaC4JrdKQoblp2KrGG4odV/EJuEOxuflLLbYmqtjlQrGx9vdsPvbjV4QcPiC7rpsasZOJl6bYWUKrXWyOnaWzBeNjp8imCsXuiBw710tEUYxL/vcPeNu/3Y7hegu3PbbRqVpxa5ctACKpgLbXMTu5uNpxPUUMvymp72WKlBSxW9jflfNoNAtwbLj1Mb4A7/lhvuJWIo3q8VcftGvub1woWbp3/dph+Dxd6Ghip0jdI488ghtvvBGLFi3S/n7EEUegVqtpRRbr1q3D/fffj6OOOko8bnd3N+bOnav9C5gajJMFZqpMHbkdL7ch43a9Ix1e3bSzQ+3Qf3b+sfjynx2ePq6IlHnDU8rBbvN68dO/PgZXvfOl6d84YrelTdTm92U3G0pKzJsbRwQBSlr0+UgtxdRL5KtcCyp2ToNi6OOV4iXk5BVV7OgYOpaLmHBefDZfuhrzHXt1nqCdCpoq1J6pfz5WFVvHGrjovx+yJv1PFL97ejO+/KvH8PjzmeUSzUHjwBE7W2rLRIsntLEWwrXeMF/eRsgQR+xUGszCOV1Y0KdfO9yc+hnVDwD+5abH2PDn2i28R55EGtV722VO3jqJO7foHI/eP+MhnWp0P63EbmhoCKtWrcKqVasAAE888QRWrVqFp59+Gs1mE29605tw11134dvf/jZarRbWr1+P9evXo15PTpJ58+bhvPPOwwc/+EH84he/wD333IO3vvWtOPTQQ9Mq2YCpw3izhZv+sMFq1kibrBdZVIrgmS2jXuO4xNuR8UDsOhlK0RnoqWoLbk3IaVOqUbVcwsHL5mH5wiwky5kWbxlJ1pL5VLGzOMyrG5hZPMGRCoC2FDMNiiWDX6FYQfKZEwyKJfsSKUdN9rETqmKpYtc+pq3vK30Ofc+SgggIodj2j1yOHacIZqHY7PP/wH+sYudHcenPH8bXb3kcp12+0jnWxERWuTWb7WsYt3ba0o0k8mrLsSsy9qmNens+dR0BWdibYnBUXWdduTA918+1r1s27OAqV9cJ9wCpd3RqXM2sCRxfphswSlzXBWKXx1133YUVK1ZgxYoVAIAPfOADWLFiBT75yU9izZo1uP7667FmzRq8+MUvxm677Zb+oxWvl112Gd7whjfgrLPOwtFHH42+vj78+Mc/RqXCM/6AycNnf/Ig3nnVnfjgf9zL/n1ovIl/uSnLQfBR7IbHm/jkf92P2wTJ3cRzguklJ51zO9DhDncQ39kh5ZxJliRZp4Tk7zRRmwvfqQT0Bf01dpyplKgcuzndZo4dT9TGCxZPiD52TLECkKlfuZZfjt6yYihWVOzMzhOyYsdVxGqvETPEjrmZci3FbAofV8DCFa/8z/3rceujz1s3pNtjVzKRaK9rc8oqdjZiJyl2BcKeEikCsutAYTMhdtzaqzpT9NTK2HOhnv/Kzcn23jiTYvPzU+FeiZw2jHVCe22HYsf5YXYappXYHXfccYjjOPfvqquuwt57783+LY5jHHfccekxenp6cPnll2Pjxo0YGRnBj3/841AMsYNwzW+fBgCx39/f/+RB/JRUiPkodv/+m6fw7795Cuf86+24/fGNuOyGh63VWU+0wxl7LuzD37/hEOtrcYtjp7eG2ZnRiuL0JmnmnFUZNQfI9wad39eFc47cU/sbhboh6aFY3k4ljuM0dG8Su7QwoGCOXc5gOb3hSDlz+vybBYmaRKRcRDBXbEFuvGpMajbMqCD0GPQzjYTQMCDk2Fk6T7A5fE1FKPSb8Z/92+144Sd/JlawmorsZILb4A6O5E19KTjyM5EcO2kN5tZYW+6bSa42D2dEj3uaSqmoVco4YMkAvv62I6xzWjIvb1ekwCl2Q+P6Oq6+P4nIZhsoTrHLf7D0s+hhqus7DR2dYxcws2F2mvAJA9Cd3//5+m/xz794BN+89Unn+EVz3CX0PLELodhOBf2+TKJTS0OH2Zg4jtmm9UfusxCAdENt59iRG3mlXEpzNGny9XgzSo/R360v7pmVh36OqRusWSnoVOxyOXPJ/zmiJubAJf9LxRNy6FZ7mPjYGYppWSZ2khE5VwASWYha2iuWybGzF09kxx83iidMvPfbv2Mfp8SuaMFF7AjGmt8JYK9WTf7OFE/YcuzEUCz/OvQzfv8JBwCwb8RNckWJFafYmR1GTj54Kea3c+24+0JvO5x78gvzRZCcYme+LxUuld5DQzivAd4Sh35nZlebd199pxaK7gQEYheww+Cj2C2Zm9+p/c/9si8Ud2MG+AWMDcWGHLuOhW6fYYZi84od/ZkSQXUzyVegRtjWviFRxQ4gOXzkOcPk5tXXxSt25muo5/SZxI4hOa0oTg10cz52DGmJ4zhT7HxbignjqwxRpuPz9ijZ739cn9hemO27TGQFIOT4tlBs6mOnf0bm65vvgcux41rM2UCJ3WS3j+L2t65WWSzxsyyn0pyl16FkSW1auNw3czxHjGzRki5iEs7Z0yio7/CQ3efl/sYVT5jHUNebFO3JipTy5wVHHNX4Uinvh3njQxvw1ZsfZ19nuhCIXcCUwUy18cmx42wSHntumBmZQCl2C/q6cNyBu1hfiy5qarcYQrGdC0qSzLwtLseO3ojoeVQRSAsljuaNn/OyU+puT62cIzo1IcdOPac/RwTz+WANC5Hl7EvoS+UVNX4+6leJqEWxrlCZOYsc3vKvv9Xmz13DAN+GTJpPchy5pRjHHbnvWVXFcubUNtAb/gU/vA8PrvU3sTcFHykvksJF7DiStW28iRuFDhe/fuQ59nFRsWuTmTIhLpzth4IiV1zImlO86gzprwqWP0BGZBczVateil2XXbFLNyHMeceFetXHXy2X2A42ox12HwnELmDKYKoCPom74438RWVr+6rsKub11bDHgj587NSDktfiiF37sVfsuygNz4VQbOdC3ewq5VJOoeGqYjXFrkwVO14ZoONNYqGIEg3FqkIbM7+OPr9pKGpq49DXzYditc4N5GdT9eKKJ+jNzPx8JMNh9XzzfkaT1elTbL5xJqSuGelrMHl/sSUU28UVT1g6T3CdLTIfu2K3OvqaP753LV77pV9bx0dRnCsoUJD671Lc+eRmPG1UmlJIa+eH/jNfuBZFMX77+Cb+OALR+edfPAIg+Y7U9/SLP2zAhm181aciV7svyHd4sW2q6XktVWLTY+w2vwefJbnTAE+8zM8nU+wcodhKGde9V7dGG2fyExWxLpdKbHEQR0CnE4HYBUwZzKXXR7HjLElsHSu2pKHYJJS2tB3KZRcXlcBbLacKSlDsOhf1pqwAcT52kkGuInlmOIueI+ZizYVvs7BqnthxpGK8GaUkKR+6zStqdP6Sb1wr5omdND5nOCwQKUoMWwzZrAiVrhTczZt7jRZDTrnNmy3HjvexY6pijV6xvuBCeL94SO7/+r5r78GLLvw5HiHdGMw5Z7/nn3/zw8/h2C/cJLaoUp9Bb62i+cCZRtmAvZODtAZ/+/akEK7RilMzYQBY+QjvTqDI1R7bQeykvFQ6vlou4W0v30v7G6/Y6Y+p9V3qLZv2ZK6UsGLPBTieRHvGmefQ3E5uj2N205huBGIXMGUwfZZ8cuy43Rgnlyuk/kjtxY7LRcpeP0tM76ryN/uAzoHNPqPKEK+MhOgGuZJ5sLp5l0t5osARR5WPaebLqdekc0jGy6atXPGETUHkzmtK8mSDYl6xkxTK3GtYihVM0JslBy4HrkgothXF+PKvHhPnY82xKxiK5daF866+C797ejM7/qe/T/KAr1z5hNi9Q/qd4hcP8Y3l1Xl+zAGL8b/nH5s+zhEr25rmCvkCiWekwmahH60ioLsO9OS+b9umuksLxaprTFbs1HnxnmP3zb02hXlvUcV02wQV1SwKos/mokZSrqmCLao0HQjELmC7IS36ecXOvahwuzEb9Xq+7WiudkxSj0xAz/MoMaGtgM6CzT6Dq4qVqjI5EgjI1iLJMfLqz4glFJu1OIvI+HZFbK3CELW23YmWz5YRI3NTxClwLQsRlDpVqF9znScosWNy7GxdDhRslYb0NbnOE3xVrF488dA6e56bOoatV6wvJAL08Pq8IkcxNN7MK8NCZTKHm//I58bRc4O25OJCgLSf6jH7L8ZrD12KE/8kaZ3lEzU56yWZXdjqTXx4mH6u5hy4HMJ6ei3nlXRuTuoxdQ587DUHpdcdd48wP9PetmKnOsWYyPwxk+PTa5pT+Six4z7BTruPBGIXkCKKYjz+3FDh8n4xVGqs1T+9b50m85uI41hTORS4C1nhmbZj++7zkxBsmbnhK6RdCSqZnN5h12MAgS0ZP1PU3OqSq2sDR0RqTHHGkFLsPHPsVE6eaY0CZIoaHZ+pCLK3lqjYCS3CzPNbCmVyvnT0Zy/Fzpljlz++uiFziofpY0fz5LaO5tcJa45dQcVOys3qt3REABKV1iSFph+cjVz99omN7OO0I0mtUk5ziTkC2kjzwYBr3n0kvvxnR+Azr0/y1HyiJv3d1TSvbc1mntipyEp3pYxdBnRixxoUEx87BaktIH0P6roql0s4tF0h65Njt+/ifgBZqk5ufEock+Nf8No/yd4bp9ilNkH6uf26Q3fTjtcpCMQuIMUn/ut+vPqfbsa3fvtUoedJFXPmLvy3j2/COe0KOg4f/P697GuLeRKtCOu3Jsm9eyxI3Mxtil1acl8pp3Oz7Z4DphdSey2A5MARAi+RFo6kAdnNgw3rMXYqaSEEk6/FqQ9Z6JYjgsn/9CYoddlIxiuFOXuMWjBIBsV5xa59g7IodmpO1BfQR7FrWQob9PeQJ3bcc7gcO4VNjG9YxVBNoyhOv7/CxRNCdIHrg0oxPN7KbUSLKHabhviNr5mjplQ7zoiYK2LhFGUbdmmHMqVQLG3VZloF8XYnyWNcKJZV7JhNl1JdOWKnjnH6YctwzXlHYv9d5wDwUOza1+3u83vxydNe2D4+E+pNW/fpVc/cZqITEIhdQAqVQHvZDQ8Xep7ZFUCBW97/YAll/PB3z7CPS4rdusExtKIYXZVy2syZSzJXyBa8TLErqk4G7Dhk3ldcqDSv2LnMd/NmwHq4hzs+JY6qT+zcXrl4ggvd8jl5clWvzQ1fD2Pqc9XGC9dB1pvVPH72s5qTXpzhvlXY2n0lr8G8BxUa5lRToyqWftecIaxJFCg5484hG6Q8NW5dobjjyU25Snvzpq/OuyP2WoCPE6UIsG9igYzsqhZpHMnh8tmyUD5jv8KQElWUsVUgRuPkNQYMFXMyqmK5Vnbq/YwwUR01/sXL5+OYAxanNiwSsWuSe4GCIo42O5VcD2chl3W6EYhdQA6uXSmgLw6SYrc9CaUHLR1Ifx5vRrj7qc25MaoB827ze9Ibg90bKVtcSkKoKqBzYA/F5r9ndU801Z9M3TNusEKDe+055PjqJsF5d2UKmW+xRfI/p9hx75dT4KgFgwlJDZEMikulUi6Pj35eFYuPnXlsidjZFDtrjl0rTzQ5Jcnc1NHvriixU0Tqs68/WHvcp/jgRqN6NvcdtOc3t6eKHuPckI7fMIiIqvLlFDuuiIWqdyY55V5zoE3stgledjTHzkw1MBXJKIpzoU86J26t5vwT1fd74Y8fFMmpOu/ntq/R8Wbk+IzyxJHrs9sim0baWcQmJEwnArELyMFsf8SBXvASESyxmp0f3vKyPfEZsqi+8Su35caoGy0NBUj+XYCu0IRQbOfDForlKl2lUGym7plVsbJCVmGeo9QLzmKCc9Hnbh7Z8duhW84MmHm/KRGk430UPqF4giNfpvpgs1OhUInnLmLHKXYZ0cyPN3PsTI9AE2Y4vKnNf2KKXbVS1siID7EzYatM7jIIcxTz4VIzdGhT7OrN/HkhVT0DvGKmVGnJm0+FK7sqZew+v0/7m3l8qpzSQiip2wlA8qHJvB97bij92SRf5iZtoLuaCgv0eemcmFDvrm2rrDuf3JTLBdeKJ8jbS4ldh7krBGIXkAOXE2SCStzcbhuQFTuzYTOH7moZbz5iuXUMp6DYKq2oIhKKJzofafiJUVu4qk9Feny7MGRthSzFE+Q56nybyyp27ddgijl4EqXmQMfL8+GImm3+XM4cYFfIzG4bmmLHvIer3vlSAEl+EiB75KXHZ02cIT5HEROlDlHC849vPiw33gztmb6Grzl4KTsvDlTd//ApB6aP+3Q9cP2dfk4cKefCwOo9KeXRptjZwp707+nvzHtSm5eReosls+NEsXvXMXvjFfsuSqtjc8SOKqda8YS7KpYS8tWbRtOf85Yy7WOSYosXtYstvnfn6tzxuU3XK/dfjF0GujHWiNI2een4VnYt01cOil1Ax6HZinD213+Dv/vRfdrjPoodJXZSorFp2aCwYSvvZk7RVS2zISmKTEHJiKhfjl05JQYhx65zkd6gLOoSvSdIfVO59mDJ8WXilZkaE8VuTA7FZp0q8qSFJXbtG4reSUJ/b9p4hsjaFE16DG+FrE0a6q1W7rW4OanWU+oma2v3Rd8DWzxhqUw2Fbv9dunHij0X5MannmSxHv5TvoaXvPlF/MQY0HDmn79yX/LZ5NcLW9U+wOQ5knlxxI7LszOtfKw5dkxI36bY0fX7xD9ZAgCYQ9ZUrrVYlmNXwUBPDd99z8vxrmP25o/fpASbK+hg1mr1GWmhW7JZMZ7SYtIq/nTF7gCA9YP5+w2XY1cul1Lz51w4mRT5sIpdhykEgdjtxLhn9Rb89vFNuOa3T2sExyfHbstoJlVL1gASLfNR7LqqZdE2QUHdaOdqip1lsdBy7JLHQii2c8H1l1QoM9+fpJC5GtzzBsj580hZbHDFE1yOXdZVQSamumLHh5LpeD4UyxVPZD9rqqZFRVRqylhDEanMNoObk3pIERcbSUvmpD6j/NzYzhOGibjpbWaCkoCmQezo+/MBJc2lUqb2ceqWk9hJeY4SsbPYeag1MVPsOGKX/5zodyIVEQHAV956ePpclRvKhWPTHDuipnO9gJP5ZOcRnYdPSzG6qfvynx2e/mzm2HE5ecrbdJjpLmSGthWkFAZ6LinCeMjucwOxC+g80IWOki0u2duEpthJxE5gdtxiZJubaw5UQfHtPFFmFJ+AzsJEQ7EmsVBqSxTroSubvUiNCRPZiie4MGNm/5F/b1zxhM36g3u/Dd9QbJyfExf6TKsCSaeH5L1JvnS6ApeFq4TxDDm15fyZOXa0dzAHU5VqGopvMWKnq15mFwwKqQ0YnQtFlktZQhfTUN72GopIZYqdXyi2VCqJm141vr+roj0nq4y1KHbVPHk032+dmU/yO7/hkmx2jtl/cfpzvv9u/txTbcU4xZEr5gCIfYlxfLVudFXLOHDpAO742xNw3XuPFsnsdCMQuxmAtVtGccw//BJfu/mxST0u7Z/4zJYsf8FHsaPEjkt+BWRix1YdGYuBTxVbqqD0MMTOEoqtVcus4hPQWSgaipXCjPN6aykZo4nUNkPdLLRK7U6Sc36AK55QRJDar9hy7Bi7E3sf1Pz7bTCmrwqS4bAPkcpy2uwKnFlZHlmILMCT09hCNNMcuxzRFBRBcoxmFOUUu3K55LW2AfnCFEXAbPlmEmxeghxp5l5DWaioTbdauzkzXam6misISn7nr4O+drUrp3jVDaJJjy/l2JnEWr0HM4IjFb2USiUx0pJ+1+QcUOFkLkIkXfspUTPI77Pt9CHVi3zXuT2oVcqpShyKJwIK44s3Pow1m0dx8f/8YVKPSy9AmphqK2Z9auMwnnx+WHP0lkOx/IFG6/IuU6EIuaShMZvppWqPM6+3lt4EAq/rXNhDsYz6IxCpUqmEA9v2OTQpumkhCpzdiZ/vXZ5EsaFYpso1s1TIDReKJ+RQsl48AfKzTKS62jlziti5iJR5I7cRU4AP1WUKYn682ZnA1d4sr9jlv6+Fns3aTTXXLOSgkLznls3rSedCoYaXyyXtb11VWRVUxE6pUN3VjPSaYUlOsbMdX+rx222cDxQ2xc4kXVJrwGXzkqKbtURUAIxqbGNO6XVvTIlT+FS1NkfspPaDkjCgrLWWtr/TdHxQ7AImCok4bQ+iKMaf//td6e9PbRxOf5byBVZvGsGrvvAr/OmXb8VG4pAuWQBIit3ND+f7IZrHOGDJQG6MCU5BSVuKGcfbNtbAXW0vvGP2X0zUhs66IAMyNC2hUk79sYUZ99slcaJ/cmPWIimtKuWKJ5h2R7ZQKadW2DoxVBi/xYhRHWzHt3aqMNSr3JyYlT8tEGgaRErsLJP8r1Q3V+cJNU8t/GwjmkavWHfLMj2PjPt8VHN4F0xylKmH+fVCyrFLfdosih1V+1TkgVMAVavFXkOx48ZLRteKqOXGM/YoyXibpYrKscvmIeWnqbHmdbb7goTYqbaQ2fyz18uZjQvrNrcJUcRO+UlSZKFYQ7EThAFVgLGbQexsQsJ0IhC7GQBpByzhtkefx7nfuAPX3bNGHPObxzdq4dcnCbGTiOR/3JWUjW8eaWD1ZnqDlHLs+Hl/946n8cizejm5mafns7NWId05xCBTutCe3Zp0qZjXW8PyhX0hFDsDQFvAmeD6jnIJ1ApKAaY3DbsCl78pZwpcfq5cgYY1FGvzdCtYPMERnXI5C1u1GFWTzbGr6Ddy39CnOn7aBsrRYpD7TO0GxXoxhzQfarLcimIy/+zzWdDnR+zMHCybmsYRu30W94sKFv2e6fG6jWIRCrXWKTNgGgI18+wkhUy1VTMtUqRcTZPoU3CKncsU27zOlE3OMzbFLqe+58fQ3+kmpJ8odpKqab5niditG0zmaCp23AazExCI3QyAtAOW8OH//D1ufvg5fPQH94ljzMXgKUbJMPEssSmhJeStKGZtQ2yzfnSDbhpJFba/fvX+lmdmSHexNbfdiSrYUItbKJ7ofNhabKlrIuZCsZa+oxwRtFlt0PMyVQRZ+xI13pOo2aw/2OIJ/ZjJ/OUcRHocLRRrIVJZ8URLO77LcFgd0+VjZysY4YldqT0fnWja+tbSGzPn87fINxRr5C/aiifU/Pq7Kth9fi+O2X8x/vP/vkIkCdQW5kV7zEsft5FHtdYpj9FqpZySHrMYTcpNlSpppQ2OrUCDq4qVSI604Vo2PyFJz24dZ8cDjGJHLG3Y1yDjB4hly4hpaKzes9kiTHgPypDfLJzqVMXO7UQbMO0oaJqe7oBcZfgUTzzvVuw2DWd5dfc9M6j9rdGKcxVetlO9z+gvqBbHrmoZHzj5QO4pOahcvX5NseNNL9XxVejADCMFdB5socZSUcWLSRw3+29SZKHY7PixLR/MUqXLjeesHmjulTSeqj9mmykT5XIJiGL2M/IpnihaFTuxXrHqO8uPz3WSsBD97Dkl1NvP4XwKzUiAxBFVyFXNoYsJzadj25/XHgv68LO/OTZ9XOojSj/XvRb143/e/0os6u/C2668I3kNZt02iyeAhFQ1660c8ZJyUyWilhFBfjyv2DHFE+n3q4+Vzjm1FksdYarlUi7qI+W0cT523dUyKu08xqGxZhqaBWRzbymcLEUPgmIXMGFIO2AOXGECB5PPrCF5DlJolWu8nT0nf/Gb8jdFjxEmUItwt3HhfKXtXURNiBWGmcVOrU3me1DVY2pXXGLUjIDOgpQEDtCddfaYTfHiiFfDQlyyUCzNsYN4fK7K1Z6Tp48B7Dlq6oZCqyBtLcvocTQTZIvqKObYicUT+ntwK3YM+VVklvuMjO4frvnQvzVJKJYSln126dfG77/rHPY4422FR+W01YwwNUWdCUvSudg6TwDAn+w2N6mybG+Mx61Vsdk6KCtwUiiWHy9toKScvGYrSq8FmmPHqdCAHEKXfOxs170UiuWqYkulUnpvGCGVvXEci5uidJ0wq26JowI7vsOIXVDsZgBsC5mJpzdlIdVuD8sQDlIodrOF2Nna4ACJmeO2sWYa8s1fOPxidNBucwHw1auKxPZ20arYcjo+iuL0BmbuMEOv2M6HWkw56xtOwbIpXlwiu604o2YJrXK5o1yo167A5YsnYot6lSaC15uI4xilUilNevetWo2iOCUh3FO6jGR5V45dyVA33EQw/51ZO0/kqm7tOXb0b60oYn3vzn7pnthncT+Gxpp4z7fuFlMxVE6bys3ssuS/bWz3FR0wNp8SscuUTf04abiXVewSYkKjE04FLkfUpPF2hc9U7CjR46piJSNw098w89XTx9ctSnoWihVUUDNPsJL/3uj34RuKVXMyzz1Ohe4EBMVuB+LRDUN4/RUr8YuHni30vCKK3cbhLF9hvBlNKNQohWI3j/ANoZPn5Bcj6sL/pbNXpMmy3GtIF47NzZzmtqTjqeUBeY6ZE5IVT4hvKWCaIZ0TQLZz59Qoa1Ups8DzVbH6DYFeR/bQql8VbY0Zn/nw5cer1IUozm6sDYdip+apPpcrVz6RzdemCnr62GV5jsnvkYMIcmEuNTduiaM3WV1lkW9bVDnNkvZL5O8lHLXfYsxvF1FwG7tGK/PAU8TORrqebhee7bWoT5w/hZQywJEQIFm71GM+il1DyB+TvO+klIQugQi6iJ2pC0i2QtSbMdI2XHLIXSJSEnnkCkA0nzzP4glpTpzNUScgELsdiL/+7j24d80gzrv6Lq+2Wgqa8aZgLaJghmIvvP4B7/Bs+hrMSRpFsTUUy4Uo1HH++oQDsO8uc4yLy69En0saB7LQBKD3tpV6IppVXJmPXWddkAEZbAs8X1UqK3Cc4bCNKJjEi55+fG9ZLswoK3BpoUIzT+y441NfR5VI78o5M0Njl97wcPo3TkU05+QqVshVxVoUSiD/GcVxnJJCjszSEDklaj6KXbNlJ4Lpxo5Z66iBek+XyrGTCxueakdJ9lyoh3mlUKO0ATF79SrQdZemnUjEK7UX8VXshJQEye6E2pfQc0MkXcIGgb4efY4tFFsWyKN0bpgm1/T43GvIJsv8nKTw83QjELsdiA3bMjXtkE/9zEqUKOi59KVfPmqN548YJO7q3zyFz/70wULz5IjdcL2ZU7f+9rUHYaCtJHDETs3zVS9YnBtjKnaKsEp5KubOWpHVarmkJbRKPRHHU8UuWRhDr9jOhxRSAvgFNSUWnj5w9uIJXT2h5wkfilVWEkwVLVeByuQvuXzyFLlT17ituCR5jh5+3ntxRjx4xa5tSGvai4jFGfq8bfNPxpvEjsyVI3bkdZMqVzvRpH+jVbHc+JQgWFI8KmRtUV0Mnhsaz41fnRI7P8VOKjLJVEF9/PfvTmyrdpvXoxELSbGT7EVEhU9VABtrr2R3whVOALJ6JSl25vebzsfmXyms29K5wSp25N6TVxH54ju5m0c+xaMTEIjdDoR5Mv76kee9nkdvDF/6xSP44e94f7r7nxnE55nuFL/6w4YCs+RVQY64vefY/dCdLhaMCaTRO/Ivj89sTMwLQQzFCoujanPT21XRbrRaKFYjdlKOXW7aAR0CqcckwH9/tqrMGpdjZxlfTXPsdPUqee38XFWawVObsupy23w4NcSlePUbTvrZDVNS7NRxk3H7EmLHd56QFDsp1KurJ4pIuTtPtOelhbdlMg60w6MWIm4+RwrF5ubObOzS3N1atrYoW5IH127VEvGBjGhLVhhmdEI670x7F4Un244Fqvm8gqTASRsKabxkmyMVT7iKRUz1SlJ+ze83+zkZz/pXFjAoBnibGqra5w2QwR5fiihxFj6dgEDsdiBMwsT1TOVgnmSPE2sSitMuX5kzewQyDx4Km1DFKYJSP0SbO7l5sb3mkKXYu52HIvUrzF045AZOw6ajRosdc7z5PtIcu5pudxIUu85F0Vwbm0KW3vCp3UmajM+FYnUiqKlLDHHZt93ZYs3m0XSTo04/G4kaJ2uAq3ODSpxXxMJFdMyb4GLSdWFeX77frVQV6yrOiIxQrHO8KuagxI65E9Hv3Vexo+HehrGxpPAJxdLuDrvP78UuA91oRjEeftbw4BTmlRbsGNEJSdmU2paptdK0apEUOKk4w5mT59l5wox+KMg+drwCJ6XNND1CsfkcOF6dtSl2tQpjpyIocFIFelDsAnLqkCv3LYpi/PqR53IGjkUNi/u6K7nHbISGbXQtkFDJzRzgF7w9FyWqgRSKNcMBkgKnKtHM90Yd9+lOOc2xa1+YZeOmFNB5sIdik//1UCx/QwP4HDi6wJtQj6k5RA51afGcLsztqSKOkav89g7FOoiLSpxXLZK8fOyQr1o9/8QD2PGmouPKsTM7Wzh97CyhWO4zoofRc+xsxRPZa7QEJYq+Hnc//tR/PZB7/VKplKadmMRLqsjkCmToeFPZrAprUpYD56fAScfvljpPCKFPKYdPEV9TsZPmLym/UtpM3RqKdb2G8R4Y/8HMJ4+rttePB9jtUTjbok5AsDvZgTAv8OG6vYDi+nvX4vzvrco9XsT+BOAVOFueXjHFjpfr1w+O4fl2PgpdkCTfH8ktnS5OrThOT9ib2uHlw/dckJtTtVxCoxVrr6EqwdTiFnzsOh+2zhPczt1mncElsjeFGw5Ac+zaYUktxy4/11KphAX9Xdg61sTQeFI9LiknQHZTbkYxmq0I1UrZarAMZNXfqWJnURyT19Vvgq4cONPixanYkarYOI7dPna5Ygs7WS6VSqiWS+3PKM5aX3nm2NmIry0Ue8eTmwDoOdGAhyIl5JCZVa6KY5jnqUuNMotAxBw74XuWfensip1JZM+/dhUA3VqLvp+c4bBwHtHvV8+xk697WknLvYao2DGhWLbHMvMd0O9PVOymoJ/79iAodjsQJokYcyh2NzzI26IUJXacTGyTjjmvJroY7LtLP7797iMByIrdD0mf2gpD7BrGhyG5pdPFiT7loXVbAQBH778oN1fu4szn2LWP2WE7rYAMDeGGBvCKi5nTSaHOK9/iCZPkxOTccxKX9lgbUVMbDCC76WTEiz18ankyZCh2nM9f0fkA+bAS5+ZPQT+HKLYrpvRx31AsQHIdoyirrrTk2NHxKSHiQrETUFqkNaMlKEBZKNYIlQrESzLHlXLOJMVOUk6ltVryjesSiCCX7pOMz5MowK78shsuy3UpGRSrz9T8DrjwtrXanlP2yY0nVzwRfOwCzC//8pseTSuqOIi5M47QSO51GaJWWLFrLwb77tKPX37wOBy9f1Lp2iMUT9ALaY8FWbVYTcg78QrFMq2RqA2EAtdWrG7khYTiic5HltfC3BAYxcVGjDg1wdZ5Ik26ZkiIpHiZXnbWHDtyUzGLFXwVu5T4eoY+XQqcSSxoayfb8YHk83EVW5jEMfIgy/Rads2fvoY23nr+iIfKQWw3JRVDCFWi0vfMeS0CcqhU7DwhhiV54pV+z545dgr7LNbtXdLxwnxYv0gm99VWNMVd93Gcfdfmqce9Z9t1wx2fVin72qNMNwKx24Ewv/w4Bs64YqU4XjLilIgdNQCm4NQ524nIjZcSZl0X/58duaemKFSZnAf6uxmK1YgdWfBsYTT1FM7uRM2FayIf0FmwGeRyYSsbMeJz7OSQTBqKbeZz7KQNlGnQam1xRpq4p50eHKFSMzQm3ZDT+Rg3KVcOnEks3FWx2c+tKCbzZ4fn8pFceYt0To1W7Aw9J3/LyJSt2MLsmuGDikF8FaQcO9MyJzfeDMUK6o+beBmKncMnLx8q5ddeVeW7eVi35VKE7h/e+CLt8dQA2cxBFAob6GO6Yief15wJcjPK/BC7K/r9SQkF1FhavRav2OWLIWh0yde1YboRiN00w9bNQTIelXasXHk4kM/tA1zEjimeMDo3KGRu5kYJvVgezl8IPqFYTrGzdQ2whWKDj13nIwuvcDtrfQxgJ0ZsSzHLOWQmvtMOCZyPHcAZ9toVOFPhsJn1AvmWX9INWcG8abYcxzd9yHyrYtXcncUTBpnSiR37FK1Vm49BseZjJzS3p+PM659u9I4/cBf+OUIOnGRfYoZiFbGSiid8848VaTGjH9J5l4UlzbWXV8h2m98DAFg3qIdepSpXdT6b0Rvrdcas1er9drGh2Pz3RokkTXEAst7jlFzbNnRcURYt4jKv/U7tFRuIXQeDO7EBeeGU8uaK5thxoVtFjHrMC0dQ7KSKRtNGIp2PEIrViic81RmOPOZbioVQbKcjDa9wFZPMjdlGLGxVsZwykG8pljxuq0jPzjszZ85F1PQqVIkImtYNrhZbOXsRS2iSm3+q2ElVt8amq+mYv3ld+pBlGkJv+OTYMYqdzejW3NfR8+MLbz7MeA6/ZkiEUymLDfKEwdEGft7OnTbPC6l4Qj3fJF6cR1vy/OR/0QDZMxS7bF4SAXp+qK6pglKInhZnxMwmnFN+MxuiPJGyVq0y7SKBvLjBd56wbBiZ+5Otilb6zqYbgdh1MGw9ETmok+uUg5fgdYfulj5Od9PZWLkc1CxsAEhVqRGKlXLspMqmoqFYgN9dWxU7rrLJGD+R5OmAHQsbEWH7jrZPKRvZ13bulhw+ye7E1rc5Iy4wnsOPN6sUXcUH5k3KZsALcDl2kfU9mAqfS7HTiyfijFg7jm/andjIMs2xcx1ff43ImiMo5cvRG7oZnRD7iKbnKb/WUcXuj+u3pT9v2DamjxdCvZLCxFl5ADafPH68VKwwv6+WfgbrB7O5SsbYdNM/zoQ+rTl2TKs/c5MPUFPsPLGrlkv5/rtsr1hLDp8ijvT4tg41gdgFFIW0s5ZOInXCvu/VB+Dyt6zAjR84lvxNXsByx7FUxZqLnUuxyy12zA4tGW/Le2Bu4pYbrXqMvkdTzcl6xeaeHtAhsCl2JokCHKFYQ40C7Dl8ZpGPOvdsFpI5RcoViq3pip2vwmcaCMtVusn/Zi9XZ45dOn9XVWz2c0Rz7MTiDD3s1nLMH6BVrrHVzsZ8D80WzbGTlRapNRVgM0vnQ59S1wN6THrIk164hJ2TGTGR0lqk0KqreMIkdlIaTKlUwtJ5STiWWr9IOYV00693VJGV1kolv1bbNvmcaip1wqDviSp2fkU1ecXO1yi9ExCIXQdD8sbh7Ejo+FqljHK5hGWkmMIkg67iCVPhS3PUan6KnZT/w+U6AeRirsoXGxeK5RPf5fFq8eRyNQI6CzZDWq74xUZEbDl2XA6WacuTqks2UmGcUy4iZebYOYmgcWP2Da2a9iK+xKtIjl0U220t6Dybxnx8yHKzFaU3cylsS+fa0ohgfpya4ngz0ooDqLqWK25g1BxakZlvcp9XyNSPy+b14OBl87TxknWG1IBeCq26etHWc8RRzjnrZooP1OtxOYXZ50pCt9Zc1nyOnb24Ib+2q9fiiF0XVzxhNShmiicsVbrcvaYTEIjdDgLXf9UF0xhSQQqjmguM1otP6FcovrYxX1GxE0ru1S7SlNO58ATgyqvIXzy2Bt/ceFMNUU8LxK5zkRGd/N/MrgfJ+OR/33PC1my8ZlQQFgnFZm3I7ApcGoo1TJD9FTuXoqYThXR98AyVpr5xQhUqJVg6kZKIo37t+5BljqhZhmuVqzaiTL/Hc795R/oz3TRLvU25lBA61/R3xtpJjVeehNp4oThDMtQ1z1HzNXLFEwzJAbLzgiu+U+txXSOn/IaoVCpl53SDjpdTALgcO3V+c5v8LDeSEjv+3pS8p1Ju/jafPFvxhG9KSCdgWondLbfcgtNPPx3Lli1DqVTCj370I+3vP/zhD3HKKadg8eLFKJVKWLVqVe4Y4+PjeN/73ofFixejv78fZ5xxBtasWZMbN90wiZLXcwRiJyl2ZkiAkiRT3nediOZikeXYGbtGJkeC/p4LTwjFEzazVXUIehNXL8fdpNRjdE4m6Q3FE50P9X37kn0bseBSAGzFE+l5OoFQrLoptByKlNkv1lVVahK7VkGi5jp+0apYeqw4jtPPyuVJp/JdvUKxZL1wVQ3T8bSKlvt86DF+v2Yw/ZnmXZrKIHcT18Os5lqXX4ds4fay8fmnr6EiMcZ1IOXYSRsEKccubeHFpiQw140ltGqmF9DxfLGCZcPFWlnlVU01f6ti5+lfySt2soIYcuwYDA8P47DDDsMVV1wh/v3oo4/G5z//efEY559/Pq677jpce+21WLlyJYaGhnDaaaeh1bJ3ddjRME0bfSCRQVeOXUZe6N/4xUJ87VzjZ2UXoodiJa+mhnCxmSau5nh+F5XfyRZV7MwwEbfzC+gs2IoJbOqJVRmIotx43jJH3QRV2BDisRXMYgVXaLLLuHZsxR90fKrwOY5vfkbO8ZVi8wf0TZfNngbIh618FDjaSaKIYtds2RVE6Rj2MJ28rnDP4dZGazW/kB4iKUZSaFVqZSfl2Ekty+hraJtkCxHsqeYjOLaOIel1xmzC+U1+fkOe5thZ5q8Vc2yH3Ul+fGcSu2ntFXvqqafi1FNPFf/+tre9DQDw5JNPsn8fHBzElVdeiW9961s48cQTAQDXXHMNli9fjhtvvBGnnHLKpM95orApdo1WxO4GJMVOtDUxdhalUgm1Sr5vKiCHc9V4c76SPC57NfELJLcDTMbbQrH5XVTRHDtzkS8Fxa7jYbNJ4Hr92ogg65dl6T1q5i/FjjAjPY5JXKTnSOFesZerUDzhyrEzVUeR2BlFRz69WZMbbazl2EnE1Mw5S8myZzFElpPn9x1Y7XKEY9jCbmxiPSV2OeKVXxuzApP8a1fEtZFXjEwTbXNO5nusiZtwSyjW3OBEcfq9cedRccWufV0yoVibwkeJV2Y+n+9CxL1ne0ux9nxo5wmPNCFXatOOxozOsbv77rvRaDRw8sknp48tW7YMhxxyCG677TbxeePj49i6dav2b6phU+xGG7y6qE7Yw5bP1x7n8vWkJF6ulRIgn4hpCxZhsch7NakdF0/UzF2OqPA15V0aV4JuC7NUmIRcU82xNQEP6AxYv2MmJGMjRjaHe26BN2/KmWInz9cMEynSKRERM5Tm9LEzrk1XKDNXzOHIEzQrh316s1L7CXVJi8TUINc+eYs0ud5HNaXfc2QhFNJnbEvczxRZMp78IvV+pWtjZPnOpOIJKSfMZXciK3xCfjNr+6MrdnRuXNFRD5tjJ2/QuLZrNjsSzjfO9CilUO9JU+AsGxb1EfDrhIVodth9ZEYTu/Xr16OrqwsLFizQHl+yZAnWr18vPu/iiy/GvHnz0n/Lly+f6qnm2r5QjNX5vz27NfEOetvL98Ijn8uUTY6U0YfoCcv1TTV/32NBLz5x2gtxxTkrxIRcsXG10OhaumlyvkVAdrH59gW1tQviLk71cqmPXUm9r9zTAzoENoWJC5nY7C3YHDvL8dMNiBGWtKlF5gbEVQxhhtJcoUYzX8hWNQzkiYirc4MZViqSY5f0irUXc5gKYpGClEYUp6qpT+i2FUWO4gn++T59RLkOOOUS00mCWRtt5FTqbCEZUcsGxfzn2lUVNvk2o+5UGIi1sYA9x25sO3Ls7P6Dyf/0XmCzO+FSMOyKXf47sN5r0nO6eKrVVGJGEzsJcRxbF+ALLrgAg4OD6b/Vq1dP+ZyU+jbQU8UHT3oBPn/moenfOMXu92u24L5nBgEkZKdWKeP9JxwAIE+KzMfozkuSiunvcQycd8w+OO1Fy7I8HrPfn7BIukKrMrETFi9Pd2/bTY0js6k5q1E8EXLsOhc2YscprlJuEaDnainYcm0kg2JfM13XfJLX0ENprtcwe8W6DI1NIuJrR5LPsZNvE2l1chQ7cwTNfCpKiiRQolZUsbP56knHmOhNn1uHuLXRvlkR1kZh0yvl2Emv0dXuo2qGbm0tvKoGedTuM1woNm0rlq+K5TdQzHWZphgw3wFz3ddbertI7fi24gxWgcun/WS5o7b55P40rZjRxG7p0qWo1+vYvHmz9viGDRuwZMkS4VlAd3c35s6dq/2baiiitKCvC+874QCc/bI9sXhOFwBgeDxP7K667clsvu0T1laBQxcPegLWKvxzpGRPzqkbsCh2TNscQL54ZIVP5fBZFlRup2xJrNcNjaHNX72NTpPQAzL43JjpPc2m0PBk3xKKbY+P4+Q5WUWmPF9zA+JSpEzFxRmKVddmepO1E69cla7j+OZNrZhiB2voM3k8+0yjyLfKNSNHXr53pHLV1qlCbssokxBKYhVsRI1bG33SBcx1Tv1qhj5FHzupKjZV7Ezi6E9ObfYuAF+F6pNjx5FfbjyXG63CvlyOINsizPJ+bZEA272GE1umEzOa2B1xxBGo1Wq44YYb0sfWrVuH+++/H0cdddQ0ziwPTi6e0/YyGq43c+P3IObC6uSU8tMAuexeOvGkE1HKsZNuCpIvneSN1N+d7BpNMmvbNXJeR1bFjiueMBbgLDco9/SADkHmo+YXtrKFPtkcOw8lAUjOzcy6xEJyjM2COl0l4mKGxlyGxkpxqRsKn9jySyCaMvEyFTt7aBXQlVNnDh/9TEmVq72TRHZj9lPssjUy/fwtJM1EFvb0I17Wdllc8YQPSWD6pnJzUuePufbK0ZVsY0AjFXbl2lTs+PtM9pic38x2eOFCsR4pGFqOXXtu3TXmXsCGem1VroxiZyWCnXkfmdaq2KGhITz66KPp70888QRWrVqFhQsXYs8998SmTZvw9NNPY+3atQCAP/7xjwASpW7p0qWYN28ezjvvPHzwgx/EokWLsHDhQnzoQx/CoYcemlbJdgoyu5Ds5BjoqQEAto01cuMXD3SnPz/XbudiU+yknVSV2RGZ4+lFnu249PHSAma2XlJIK5vM/oO9iUq5ZbSuj7fZDHC5LR5qDldFa4Zig2LXuWhZiAgXnvfxm1IKXKVcEv3BzGM0WsRqw7IVzhEpR+hTyrHzNihu6ee0CZNoOluQGeTXR7HTiJ3r/VJfzSgbb1PgUsWI5thZvgOqGGWKXX6c9BlL5rv0ORxJsBYekLXRRma5MCMldnLnCX5tl9ZqIPk8zXQDm0Fxek6QzRa3ybHlstpy7PS1Wv5MuRQam90JT5Zt5D35nyPvfCQgKHY53HXXXVixYgVWrFgBAPjABz6AFStW4JOf/CQA4Prrr8eKFSvwute9DgBw9tlnY8WKFfjqV7+aHuOyyy7DG97wBpx11lk4+uij0dfXhx//+MeoVPKlz9MJTrEb6El49baxvGJHF48X7TEPgL20Wi0wZhKvmGMn+Nhl4R5dUZNuUmbrpfT4QphrXl9CZreM6GTWKxQbZXOxudZzDu7mYqeeFnhd58K2oPJJ1HJrIXoMdS7YFnjtJtiKnV0kgHz+qCv0WTQUq27E40aOnbdi5yBeuc4TjvEA8bGLKLHjx2qdcFpxmlvMfV+5ObVIMYTlO1CN6McaLa8cTRPWLgMk7KzgU7BD10Yfr0WukACw9IoVDIrN86jL2KyYr8H72OmqoGQ8r8DlUGfV1XJ0hStuYL835jMatxRPsIpd+h4soVtKxi3XGT0nOilfe1oVu+OOO876YbzjHe/AO97xDusxenp6cPnll+Pyyy+f5NlNLri2JyoUu5UhdurC23dxPw7ZPSF2kmccIOcNSL3sNMWOPC6GYoUwiKTYSXYn83sTYjdoEDtbKFZqjQT4JyGbYaIivWJXbxpBFMfYa1G/c2zA5MG2oPLqRvIzrzzkiV3TVoldLqFUSoh/o2Difq43qyvHThG1dDx//FxVrG8LL0XULB5q9DhNI+zm13nCXWxBj9NsRXhm8ygAYHeSdmJ7Dz4+dr3tFoejjZZIcJJj8M+3kRzunLORa16xS/63m2iTc7p9jpZK+e9ZrorV55uNJ8S6GQNd+mtw14HpY+faTNBiFwWfHDvOxNlemZw9ZiN29qpYWRTgQsPcd2auK5Kn5I7GjM6xm0moMyaKKhQ7xBK75GR66d4L08e4+L+CtDuV7UUIsSOHc7uZG8cXvJQkB/f5fclqsm28qT3HGooVbpjcfOhjdHHJ59ghdywOzVaEV15yE171hV9hVLClCZgaWA1mmQXYx/YAIFWijl6oNNTlEzbM+di57EvMyluHQtZtFE94d57IhdHsxEt9pDalRYG22XIR2XK5pCl8a9rEbo8FfeLx02IrkmNnU017apmPmq14QiKHKdn3VIvsljn5tdH2HXM5fGl6AfOddRkbA9drqM0KoKt8ykOUT2FQn3+kzUc+5/JEzZbLWmPWapsKmkVamOueidJxwoZkHwMIKqtHSggd1wkIxG4HgVPsslBsPseOCwlIhQrSeICXls3X/Jc/W5H+LFXFisUTAtmsp4qdforN7clE4q2j2Rx8QrFm7k/y+sUUOzUd9T5c1+IwIXObR+qWkQGTicjzO6bfn43YUXKYhmIdYaVUoYncDe7pcVpRjPWDY7jzyc3Ja3vm2LlCsdQMGLDfMOl4k2i6esuq43rl2JGcJFv1oAL1B1y9eQRA4qMpjicqoo+Pna9iJ8En/0ovDJBDt9zaaCsw4fLBbIn+UpWr9BpJJ6K8ymc3KOYVO44EAnwxhNRnnB7HV7GzGhQzxRN8VaxM3jmVtdWyFFmRxzopzS4Qux0ELv9nriXHjvOBkzzgAODj193PHksquFA5bl996xE4Yq9MFRSJnVRCL1XFWjpPKEK7hRC7Iv34aPsZ28XG5aqoC91XsaMEw3ZTD5hc0HPclmNHd8njaTjfrtiZCpZ0k6LniI81B73pfPXmx7LXdrQI8/XKyxLH1ftI/ncZDuftTvj5m5YwRatiXYojnWurFadFYbvN6xHHa50k2u/bFort5nLsbDKrAVvXA9Yo3WKmy1ZuW/IQbekFtj6uZpWrTxUqJXZKdOixtuTSc+ycJtRaDhzfZzx5X/n52F6D6xWrjm9LwfBW7Jj5pFZZjlzNTiqgCMRuB2GMy7FrE5yh8TyxUwsGJYLcjk7hN49vZF83S07Vn6PUsgXtYgaFjNjpYUdpFyW2CLPcNPu7kvdNQ5s2g2KpNRL9mzaeKbk3b5q+vWLp51bg/hCwnaA3N96Bvlgolh6iFcdiCz7tOeSm4NV5gihk9JgSkSpaPGFWcqem2w4iaBoUS50qJlIVSzsT2EJWufFRZM2NUqBtyFyhbcBQ7NT8C+Q9NSxEzRaKtXmisW3vrCkklIRYFDvympwDgO9rjLWLWFQYm6JqKFg2IpuMz2/0bXYknILok2NXvPNEXgX1VllttkhBsdu5Mdwmb6pgArDbnaiLgZ44XCNzF8z+jwpKLVM5bwpdAlGTQ7F6+EbB7u6dX1ysFWxGCKRJEoq5m6BaUHm7k/YxPYsn9PwY69CASYRvgUykEbvkBsVtJkqlLL8rIkQtGe9QvGJ6Q5bnrFostVoxFs/plge2kcuxc6iCmal28r+LuJjWRb7FE8pAODu+m3g1SR6itfcrWcNcRJPOqdHy87FT5GS03nLO55UHLAYAHLR0IH3Mp3iCEjW751p+vbZtEGxVsax5cDU7BkeMfIhdsxWl74ENlQrheal/MEeM0lAs85mqc9S31V+Zu+5bedEkm49Mxnmbozwx9WkplozrnBtEIHY7CMqQt6+LEjt3VSwXiuUUPgl0YVSI4xiDKbEzFDuhhF66sWU7NFOxk8NiZQvx8kkqdlVmWRW79nOyJFz2ELn3AXRWcuxsB/3ufEMyDUblpkhvakStA2TiQsm/TyiW3vjpdbVpOL9xA0gorZ287iKP5YLXgVnh7iI6+k0q9lPsSJswH3uUbD2KrPlj6fHJxtTHx663q1080XQbIP+/4/ZrH5ve9N0pIXpo1bKBZVRlW3i4TM5PhbRitZofr3ktNuXoBPce1GvQ1pE2xS6XY+dQfTk7EpuBcF3bQFuIXfuhFqPYccSOq4q1iQ5cBMpVhMPNaboRiN0OQqbYZRePUu+4qliuJFvZnjy0fis2bB3zel2uldLQeDP9fV4vH4oVe8VKLcWMC1O9HF95lDxG1TKbT5hZAOK6QXG7NHNBnZhi1zkX7myHRuy4myCjntgWeO05Uayd39zmwxzvFYplbvwAsHmYL7rJ5S9Z1JlkPsn/6i27DIe702u5pc1LOr4WVvIwHKbHKqrYNVuxNdcpPT5JJSlkd+Kh2HEKnF/P6uwxm+caR3J8/Dc1M92mSvSXSRGgEyNbLqWZzqNdB2xxg65gqf9dFju0qjS7LuUcPl/FjrvG7D527fufVpAin3emabM2H4eyXySSNtUIxG4HYajdNqyfC8WOy6FYuitbNr8XB+w6B3EMPLhuq9frcjl2qnCiu1rO7dJqxi5fQVrka8zx6UXN7XzTHQ4lXuminX8P6hD5XCH/C81cLLKwlv1irJOdcCdduLMd1F6EdXxnbAzUNSMpdpTw0/NbDsUm/0exX34XJZt0Xm9YsTs73iyecBoOm7mmDqJmbtJcVasTUey6CDn1axGWrRcus9tkfHbjV8uKl0Fxs2VNeqePa31BmRSYdHxBHzs25cRWFcsVZ1jC7aVSSfv8zTn5dLdQ+XW1SslKNhXhdeWlKrJEidS4xTicI1K285pT6gvn2PlUxdJoj0Wxo6/RSfeHQOx2EJRiR4mdrSpWqtjra4cazJNIqX8fec2B2uPZhZldOOpiVmELCq6JMyDL+2ZybfLc7Ge2uowNaeh/s4339e9iL840FJtfIDiEUOz0wFXRyBlp21oLAXryOyWBkgJE+wmr88Sn8wRV+E45eAl2GeDz7cwcu4aj4tDcjKSfkSPHzuwt61JbgOTG7FMVS6sIXcSUjqe5XT7FFlSxs5FrmmOXXfP8WC70aSNSbBs7CwnhiidsVbF8mzy5Sjd5PK/y2YpYKsaGyFYRC8ibD2k+nHMDZ/WVzT+f+mPNsbMo9ZPqY+c5H4APuU83ArHbQbAVTwyNNXMdOKRqKK6tDZDtQs44bJn2OEfUbBd+UR+7tHxec/amaoi86/KtFpOq+1w3KG1nbeyUTU8wCdsTir3t0edxzW+fKvScgASurgoqX2ecVG+rc5bzQqTHiuIY4+3NDZfQrUDPu9iitKTjGWLHhZ8UJB87qRjC3Iw4ya9xLftuiIBkPXGFhpO5ZjlJal4237gaSQ2xhcSy46vPNPLKc0wNipuRM1RdIcRdoWjxhDXHjgkD2vLHilpzANm5zoZiLapgRuza1wGT/wZk35dZKS32J2Zy2sYtoVhOGLBdB1wvV2VzZM+xYxQ7z/6+rrWoExW7aW0ptjNhqF08QRU7ZXfSjGKMNSJNQZN2atzuII5j8eLhQqu2C7/bQewkuxNVSVcul9JFhmuDA9irYm3GnZGxuEgO+pwtjFpninaeqG+HYnfOv90OADhw6YDWQSTAjZYldwnIznPVFaJcIqFY4SaYXTtAE3JCdzqeEEFbqoA5vhW5SRSQbynmzrHLjhWTObk+o/FmUnjgUh1VIngU6+TU+h7af6ME26ZqpsUTUVyoeKLZojl24vA0xw4ARtrpL0VuyLYwXUoqtNCtO+zZYjaYnErMKogteT4AbxdiLT4w3vNYQyZdQN7XzaXK1gyFrEmUXI54mao1YPex4wz3xy09h61kmctbZHrXtlr299yJxC4odjsIaSiWkLf+rkpKMEzLE8kHzqyMU2PVr+aNiqtytV2cXM4DQBSvHLHLfleqncv41axyBfxa7ZjN1d0XWn6xUM9R72NwtJHeADhwjuhF8cTzwxN63s4MF2npIed5vRlp35OUY6eFYh1hW4CQ/4iQIo+wYSuKnPOn49W56c6xy35uRtk1L1bFkk2aq8o4m1Om0Pj4wKlrXFlaAA7FjoRiGx7EkXYOiDxUU/rdq5QTl+EzWzwhWOYA/IbUJ+wJ2PO10kgDWXrVZyStpWyOneVzMolOqlwLGxxTUXN1/zCJF73v8Dl2+SpUG5HiIkq23FpOQfTxsUvuqe37jaODSarMdlCqTiB2OwgjTPFEqVRKQ7Om5YnYIoxZXOhu2dwVpaFYpgiAO1HVQjFuEjuleJmdJ6hJZvuCbDh2mWrB0ZtjywtGrvNEwRw7qlao90zDWq+/4lb2OIDeh/Ghddvw1n+7HXc/tVkcz4EzlA6ww5XfRQnZeLOl3UCkqliaOG5LuFagRNArFJsSBXeY1Dw+4JNjRzZRLTeRops6etOxES+qdrtyi4BsfRoja5C9GCK7NptCVIKCKkA+oVj62soA3RU2ZIsnbHYn5HK2VnByRNAj5cSXhAD8RtyMTnCvoeYxZgmTau/BIDlSXqqZY0cJP+szxxBT22fKRZRs1zLnCpH62FlaqNHnuIWE9nE7aJ0PxG4HYYjJsQNoToje6SHtPGGGYhm1y2bdkOXxZMe35bN1tS9wMxQrKWp0wcmInT0vxCcHjsKs5HJWZhnHpwtxZneSPfbIhqHc+1WgC86Hvn8vVj76PN74ldvYsRJMc+gAN9THLjvcl9O/jTUi7fsTQ7GcYmchdhVC/mmVrjieEAVXYQMdry4DlyEw/SiowiF9RjQP0efzoc+pt1rOGxrAK3Z2IpjdyH2KJ6jvXcuhFgHtStH2d6rCjPIGMPmfK57g7EXsVbFMLjFz/HSDaTUozh5zF08oopMPJ7N5fGbxRNp1Qrpmkv9jYy2VvgPThUFtuCrlkre9iO0z5SJQNvWdy7Gzh2KJUOEpJHD2XdONkGO3AxDHMT76moMwPN7Ewn690wOtvKNIO08YJ6taD+gORIUcupkKP26HY8sLURea1Cs272NHVIT2m3AtRpwflHWXaYx3VfdJvnf0WOb7GB5voquqfzdA3qh5IjC7eAS44WqXBSTndrPe0jZF1XLJI7E7zvrK2hQ7ciP3CcXSsE+6+bAqfMn/6tpytWsqC4qdmGNH8mu1ULWF2CXVkQ2MNSJnX1A6V6rYub4zICGCrpQNevxW5OdjByTvu96MNFLBgWtLZzOvtVWt2sJ6NP/YVqnLdQmytTgD8jl2seNcNVVErtUlhRl+jh1rb5YTmRxXEX7pnCvqY8eFYtPKXosBMv0O7KFY/RrrqVWc6jtnuD/dCMRuB6BUKuGdR+/D/o1T4AC5Ktbq7O2bw2AxAxbtToSLjSZc55urCzdYS1Kxj/eSjZgmj7ePGcXa84DswjXf+tB4Ewv688RuoqQs1lQAOzlsRbH15rkzwtXgHgC6axUM11sYb0bpTdpGEvSqWHsICtBv5D75XVRxseWMpsc3bpouIlWU2NGboLoR2ogvQHzgaK9Vj6pYX8VOr1q1hxnpazej2Lr5o6hVy8B49rvLf4wrhmBtmgwiDtjVHPq6rThGGSVrGgxXIZqGqwXiZdqRPDeUvPFSKbPGojDJaZpj5wzFJr+7roOKUUXrrLotmAPOGejb7E6oYt6MYnSVSyQUK98vgXy3DVcbtU4ysA+h2GkGJ9cDllAsEw5Ib1JMSxjuQrAtkFJVrI8buHoPnLkyN173sbOEYg2vJvXeXS3FzBJ9af6A3KatOUHFjhJCGzn81H/dj5d+7kY8PzQujtkZkSp2NmJH1B+bcqKQKmRR7KygBUgVZByn56qNU9Br0yc/TQ7F8s+hlwa9+UvEhVbF+oSe6XMSxU5WlxRUVSNdX2yfkSJ2Y41Wel345PA1aUsxxx5ISl8xwRZPWEyTWSLoUTwBkHwtCzFSRGy4ntlfpUV0kmJHQtUAcNeTmwEABy2dq7WvVMgVTzgUu+wcba+97a9ZzLETfPKk49fI96tg2+CwoViL+q55M6pcVpsJdTlrEabWfqdip8YHYhegkHkp8YqdGYrlwpjprsiq2PlVTaW7/FzxhLwI55QHx03W3DVGDuJlKnwuf6qqQTS1UGz7OQPdeis1idiZyqULTz4/jDd95Tb8/MH16WO2atqrf/MUNg3X8e+3PVnodWY7XOQd0PNTfcbTG7NX8QQTirWFATmFr5hiZ1fI6Pmurs9yyVI8QRW7lmwJQdHD5OVxSohCpti1K1DLJetn1NN+fVqJLvUdBYhiR33yHKFY8z26euP6+thxodhsXZRz8ug4W1WsKqyL4owQpUTTlWPXnvcf2h2JXrx8Hjte8gR1bSbM6IeYY2cQTZuHHZ2/1utWqfXMnFKhopG1yctMk2UyDmSE0ZUCkOaBGmTcmWMXiF2AArdYALIDOhfGtPXK43ISbKaaUksxn8bS6oJsCGpj9h6gvQeqPnLXTr7zhJ04pgpiS19M6d/m9dXw/f/7inQhkohdvWAo9v3X3oO7ntqMv/rOPeljPqrfg+u24tu3P9VRi8N0Qp3TNvPabqJGu7wNAf2mVoTYtSL7+a9A1RBXuoA5H8Dtl6UXT7jz3/RQrP1mptBdyxQ7n8/IrIq1fT7J8ZNjKV9PegwONC/Sx8cOkNNXpGPrxRMWNYeJltgUO3oqmlWlHBnvIxEXtR65SEgaim1/V2q94tQ6IK+o2SIlQD71xx2KNRU7+4YiJXa+ip0hPNDvjjd9zl7XTHkQK42NPEGX+l4m52inYELErtls4sYbb8TXvvY1bNu2DQCwdu1aDA0NTerkdgZwRA2Q8wxseSEckeIMINWPrGLHSN10PmxjaeM9NHyJl7EjSo5vUQTTXaZ+HOn4Te745Ckv3XshXrL3AgBJ9w8OhRW7jSP5Y3hc8Dc+tAEfv+5+7Pu3/43B0Xzv4J0Nyqqin8kTUlDEbqzRchYeAGZVrFvBojl5aRjQsmKyip1HTl5sXDc+OXY+xDFVN1qRV+gZyFTQkXozvX5sn5FS21Q6iO3zAbLWVUOkP7ZP8URC7JLH3Iqdfs6ILcXY4glZweI24U0LwdZIRctYuwSD4jQc2yZ2Uq61grm+u5Ri8z07C9FK6hxFe7x+HBNmr1VXKNY0QKaekWxVrNAmDxBMn8lDak62qthkTnpeemQh7/TxGe1j99RTT+HQQw/F61//evzlX/4lnnvuOQDAJZdcgg996EOTPsHZDi4cAMi7Fs6g2Cu0ynSe8K06oq9nq1o1ixtcOXZZeIL8jVUE23MwFDtnUrQRbuDCRMp+RgzFCjYoErjjqKplX3z15scKjZ+NGKnL/YwVaA6ZT5cErXhC3XA8DYozuxPL8ckGxKeilOb80f+l64a+tFJCbGFMmi873pDTNbjn0P7VVmKnQrFN+zWpoIjjMFHsfHLsWlqO3eSGYgFa+NUmUpbQ6k1/fC4zr7WEAenbUmt0VlXKz73fWI9cJKRmhA3dhWXFFLiSsal2hWIzH8S2guggdl1GKNalwJk54JRLceNLpVIur9DV8cTM+3O1UUsJfwe5HxQmdu9///vxkpe8BJs3b0Zvb2/6+J/+6Z/iF7/4xaRObmcAl8ALyF4+FeNmANgr8LicuYkQO1sCKb0BAtSg2FE8EftdzFIxhLPk3rhhcnNXxG54knLsuHy6sUaxYwTFLsvBkkJKgO7T5tPpgYZW0xuOpaUYvTZ91CJ603SpykBeAXKd16VSKSV3ivhyBVMKlOAMtz9PVyhWEa+tpBOOTeVLQ7Ekx85+/DxxtKmsav17bMMwNg7XAfgUT3iGYo2qVUBOgQGyFpAA8MDardp4LgWgVCoxaST2DUK2HiWfp5uE6KFYl1JsenzaojfJ+9Ln77oOpOIMaXNgtvCi6yd3XnSboVgtf5p9iVwEp5F+x8KcDLusmajYFbY7WblyJW699VZ0denWEHvttReeeeaZSZvYzgIutArIizyr2Fl2FGyvWJvdCVNsYZsPfSwNxaYl+n7hAK64QT8+2PHuUK9+8XM8s7dLX0hNjBdU7DgUVeyKqoSzEYq4cJYNCqli14jIRshGErLzwq8qVl1r9h6i5vhWFFs3WwrqXI9jaJ0VbO+hXCqhFccZsbPlv5HjjNb9qmJ7GMXO1su1ZubYOVhXtxGKrTqKLdTxRsk15PKx81XstBy4KEatYi+eOP7AXdOf1efj7EpQKqGFOJcWIn1O/d1ZZSzgb1DcSPPB/ML5zZSo2RVEWhkOwJmSUDVDsQ47FfP+5HIwUIU8XCjWRjbHkSlqrv67ZnjYVazHdRiZbhRW7KIoQquVv1GtWbMGAwMDkzKpnQlS8YSUSE1Vh3RsStTyx+dy5rwUPs/OE/qc/HIYzHBA7FLsjKRl34Rf0x7F1p9R2m1tE5S8IlD5Yr4oqhLORvgRO1I84VOsUM6uHZclD0DNw2Nr7pUCvQl62Z0woVsA1m4V6nBjjo4B5muPWhqlUygFc2tbNe5iTM8pqkaOna9i99vHNyXPt7xXwB3i5OBrd0IfNxPruZt+V7WMg5YOaONcRCqfdmJX1Pq69AhCw7GJ7arqJMSlFKvjRMZ8fEOxLsWxaqy96jpzhWJTBa7lIHa5HLvsb677QSOK9Bw+l2myQX59c8Y7AYWJ3UknnYQvfvGL6e+lUglDQ0P41Kc+hde+9rWTObedApzpJSArZFxllo10mQaWtmMDFrsTSy6GmSfo6gEpEbXk+PnxUsjKJY37tCCTFFOFbUJRRZHq1aLdK0KnCr9QLG1f5JVjR25S6gZiJVHkvHMpJ8lrZyEcn+KJMiGC9Bqw5c2pG6oivj2WUCzdWI2moVgH8arqoVhbDiKQrS9K2Xblv5mhY5v5MWDfSEowyasXsTN848QwndEyy1W0ky8Ua78HYbyZGuJaS027E1ePZVOxcza4L+lruysUS0kUQDpPCMQuS6dIcii1DY5HznjkuHfQ5zRbsVZ9KxE107JFfceiIsh48U03ChO7yy67DDfffDNe+MIXYmxsDOeccw723ntvPPPMM/iHf/iHqZjjrAZVBSikcCPrpWQhXd1MKNZGBJVk3mjpN5sijaVdlVymF1/WWJrfCZpE0BXmMnPyvNRGSbEb4/PdioRoiypwvuMfWDuIS/73D2J+4EyGj2JHE7V9ihUoiffqU9r+UxTHzoKgZHx2nvoodrSdoI+JdvKc5H+fUCw9jBpvVoyaUERRbWhcCp9StpSCaPs86fEVXIod24PVQezM78gnxy4tnnBU9KdN5VVYz5GvlRbImGuX8Bb6jRw7Vw6cGcr0dQzwVRDNfOjYEh0CsvPR18dOPR7H+j2nXOLJJq30pvOiczVBw9XU2NuZA27cn6RNiGTqP50onGO3bNkyrFq1Ct/97nfxu9/9DlEU4bzzzsOf/dmfacUUAX7Icub0x6UblZlvRn+2K3Z+RLCXLLxjjVa60NhyQ6jyQF9LWuzyRE1/PDfe6DzhumnmcvIsczcrbk1Iit1oo5Wr2IwFclg0T89X4Xvdl1YCSOb42Tccwo5ZNziK/71/Pd78kuWpGjATMDLuJnY1QuB9DIqL2pFQg2LXZiU5PrLjF6jSbRHi6HwP7TkpBc6m2KmKwGYUZ6FYZ/FEOxQ7loVibUgNipVi5yB25p9dih1HsFw+djnFzqMqNquYbBN4yQrDSMR35dipz8fXXqRm5He5cuDM/rKpx6eD2KVrb6rA8ceXDYr5J9C8V8BdpERTCcabrbQl2rzeGju+ixBZ2hc3mauD/BrETjTQF8LP0ndAq/M7BRNa6Xt7e/Gud70L73rXuyZ7PjsdOB87m5cPG4q1LBZdjGJnW4yoAjBKiZ0lF8PsnuFKNE8NHVs68XKFA8ySezmHT69qss3dZS4pKXbc7kwiZJOt2I01Wnjblbenv//m8Y3i2Ld8/bd4cuMIHly7FV9482GF5jGdGGkoYucRim35GQLTtAdbwZECVZZdm5Xk+ISoedmdUIVPhTIdc1LEruEOxarXb0Zxmufptjtph2JH/RQ79Xd1fFeO3fPb9NZ5rtAwb/xrf475HqXEBlVlHMf5aIMrn8q0wvD1jXPlqNXMaIO3IXDyexrqdST6e4diBSIozZ+GVpP/7ecd3WiMNSI88fwwAGDfXebw48lxGi3aw5kdDoAUQzQjPRTres/GdyaZn2fdMGYwsfv3f/9369/f/va3T3gyOyNYw2FLWIZva9P+G1ccwMT/re3ByiX01MoYa0TpYk3nZltos8WLn7t5jHx4wu9CS3MePHPsbA3lzfJ8E5Jix5EvydakqETvyrH76e/X4c52T0ggS3TnoAyTb3jo2fSxZivSrBh2NLaONfDM5lH8yW5zxTGjaY6dLYcsO7d9GtbT88jLQJhV7NzWH952J+0/xTHN1bITqZzdiUtRKycVgWq8i0ipm5TyUXMpfHPaVZxqU+PysXvZPou0313nIPd5u05b8zkL+nj1B0jm24zjLD84UiF3SYEz1zpX6NYIfToUO7Mi01UoJip2DmJqFk+Ia296DcCYDzucFDS12v/bc+xKpRK6q2WMNyOMN1t44rmE2O2zuN96fPUaPq37MqeHWMuJlMhp/n7mUuz099wJKEzs3v/+92u/NxoNjIyMoKurC319fYHYFYSt/yDAdJ4QFD6AP7nTnBDm+BIx6q1VMNaI0rwZSjS550iKmr83kueu11hcXDuuzPdODhNxCiiFROw4dU66sDcN1xHHcW4hkUK3LsXOfNaGbeN4+NlteMESuSpd5QTVmxGOveQmLOzvwn+//5XW15kqnHzpLVi/dQw/+H+vwBF7LWTH+BgUU4f4zERUfl16XqQKn0dolSpqNrsTqs64ktjNvyny7yI6WSjWX7ED/KtiU2LnmWM3x+i57FLTXrhsLvbfdQ4e3ZB0KXL56vUz6QMu8kjJ6CVvepG7v28UZz52rq4ERjSgqCGwq6F8WpFpVvS7oh/G8Z2OAaYiKBy/ZCiOLpNoGpaM45godvJ52lOrtIldhGe2jAIAli/oY8fS77bejLx6ONO2ZS5FFsgXNLo2dZ2YY1e4eGLz5s3av6GhIfzxj3/EMcccg+9+97tTMcdZDa4qVqsMyuXYJb9TTuBTsUrJWaZW8HNSeXbqZuBKUDWTTSMHcZRyGKRr0yzRd3lBSe7qkkJJx1JEUSx3pOCInaDYrRscw9//9KH88QVhzkXsepmb+TdvfcL6nG3jTYw1Wnh0wxDWbx3Dg+u2isRyqrF+6xgA4H/uW4+v3fwYTr7sZmwc0kN0mXLio5BFzvA8oIeVbF6OCpSopb1WfVqQRXG6CbFXxRJip244njlqox52J3ROo3VPuxOjKt5N7HTi5Zo/ALxoj3ne4wd68sTO5WNHya5LcTTTSFw9eHNdDBybzDTvMjVjV4/bj69ChmpNlT6mvOGw36Y3CzOq4/tuwu3zV6FYVQzh6jxB/zbWaKXRCiknr1zOOknUWxGxaxEPn+Utkp7Stspz8z2POdIeVKV3J+XYFSZ2HA444AB8/vOfz6l5AW5woVibYmdT+Lg1LF2ISHjP1TC9p62SqJsBfS2+84RB1JxtZ5L/iyp2pju5K3SbjZfnblPsbB0guN2ZTYq/cmWeeEnhX9VeRwJXVr+ov9v6HAD44o2P4N41W9LfJWK5o9CMYlz8P3/Aw88O4fJfPqr9zaU8ANSWwC/HjhK1IsUNUWxvDm+ObxLFzqYM0PemzidXlah6ThaKdSl2ycXm23nCJHIuYmQSL1fFKqDfVG05i0By0zfDoi7uSMmu6/1KRM3VDrFh5Ni5FD6zCtVVbOGdfyzlE7s2vbG59rLDLdEYfrwZKnX1igX0vDxX8Qc9VqLYuTdoNS0U639dqvesUmx6hGtNXSOdROwmrUyuUqlg7dq1k3W4nQac3YY1x04pfJwCZ1HTmp5EEMgrdrSSyKcqVr2UK3yQy8nzTBB2hdHSXaxKKLYsdjbFbtNInT0+UCzHToJI7ByKHWd47AqBAcC//vrx3IZguvLsAD2cbZJoHzuSNCwW+XWeoEquK8mc/i0xKHYrWJoi6EFM6fme9lp15tjpCpytJRqQfR6rNyW5lrsM2DcAJpFzKXZmqNTnfKI3VVfOX6lUwkBPDZuGs2vRRR6psuI6fsXIQXaF6hRJ8M2xM9drV1FN2qe0PY/YQVxMBwDXdWMWT7iIkXo4X0XLj6fnz3gzSqMYdsWOdJDxuC67qmUM11uoN6OUCLvGA8l361UEZdwTXOr4rMixu/7667Xf4zjGunXrcMUVV+Doo4+etIntLLApdhUmwZNTmGw3ETPZl76WtLgoYqck6PF2p5FyiV8ozXCGy83c3AU6d5mmobHD2iLdVRsJyNx4jvgq0JuJiTqjqrku7Hoz0m6Ukneey+5klGlRNuLhZWcSSSmvcEeBtk4z266l56hHO6tWRHPs3EQqIV7Fdu6ubir0+EmOnZto0kOlip1nKFYZOEsqQjqn9hMeayel77uYrzZUMImcqzhDtcBK5+dB7Kga5kME53RXCxE7aoJsC50DdHOgr0UujzPfHDt1/HyFpX18wxgvh0rbRDNnzeEXWnVV6ZppNrFDsaPFEGONlldIv4f0fPZR0tMq1GaUztt2StDQbZHWgFGq2LlCsbNAsXvDG96g/V4qlbDLLrvg1a9+Nf7pn/5psua104BTjGwl9PZQrI24ZCedq0RfJawrAkHdw7kFwJyTf4m+364xr/Apawh+vOkrZMtBrBoLHYWV2E1AsVs/OIY9F2VJwS2h+tWl2I0wit1IwX60QAcQO/I+TbKanqM2xUvdBFuEqFmJVKb8eilqtHjCJ+laC8W6iaYWinXkdpnPGVVKiEuxM+a7/658taFCLhTrYY/SVS17E1NzjC3XScEM95YcT+ktkGNntsDKesXaowG5vtUFixucVbHp2qUfR5y/5/Gl4glnvnIuH1r+nrMq18irmlyt12Ok57PtuqHdkdTGw3bdUINiH8WOtu1MCkDaoViJ2M0GH7uog9pmzAZk6lX2mLrhc7sKq48dS1zaO8Y4IS/lcslJpNQJrBqHu9zDJUVNzrGTiCA/vmjCcp+RI+jXeSJ/nM0WYtdgLmJTdTKxZbSOPUGInVgVaydc3Ov4KHYmpru3IX2fkmJnIwo0bFWkpVii2ME5nusVayMKWvGEDzGdUI5d8v+4p+Gw+f6WzbebyJsKnev4ADDQXcXGZnKtuCpWAf2m6nq/QL5Awx2K9c+xM4lOw9MuRI1rpOedpPAl/5vESDqv03O6PS4NxQpvI92sGDl2vtZRto5CgByKtV033bUKMNZMQqse1yUNZfqkYFBv1laXe4OmVNumZ44d/YwoWZNCsZ3oYzcpxRMBE4c6f3UfO3n3bvWxsyh2gH/o08yxc1U2mS3CYsfFL/WKFatoTSLoCNOp+SdO4/ZdIBcKV9hoI3as3Yn9wjaJlNRbUIXZJHA5dsPMYy5Mxx6Nfs5U9TTVziItwpqRX4sweh6ldiQeVauJQXGx0G1adevRixbIrjVX6FMpJS5/MAXz83ARta6KvnlzESMAmEMUNTM0y4Gmc7iKJwBgoMewVHFwQRqedhogk8rqVhSna5fYeULl2Bm9WeW0EH28K2UgDcUW9bEzNtXeClysFDh2eHp9xHFCMl2hWEAnaj7ErodUlfoUQ6i2ePVmlK5hNgWxiyh2PlWx9DqmG05ZsZuhOXYf+MAHvA946aWXTngyOyOylmL50Cq36JmFBPS5vGJHiF0Uo1Zx7xpTYtcmGOqElW4iUs6crwGkMxxgHN8VpqPeZ6ONljUnz1Y8YTP+5UOx+oV9wkG74hd/2JD+nstxE4jVWCNK1VUObI4dQwZddiaTFYqN4xh/fHYb9ttljpMI0M+tqRE7/T353BBoBaHLHR7Qw1apHYmnwucTUqL5SK6CIIVyKVFBfFqEAVlenrom3YpU9vdSyR3qNUO7LuII6Iragr4u53iap+gTui1aeUuvf9+q2GYr1jZrrlBs6pHp8rFrP1xYsfPomkNfN2+m61hLzU2y4/jqOa40G4ASHaLY+YxvtJybfICEYikRtHzN6jOttzx97EhBitpwVsoli49dRjQ7BV7E7p577vE6mMtfKCAPznDYlgNnLZ5wKHY5E0vh4smqiJJxbsUu+T9O5Xr7xZZrg+Osik3+N4szpMWxu1pOWwWNksXCZnfChUVtChxvd6I/dtyBu2jEzizQkEKxAPClXz6C8098Qe7x797xNL59+9O5x7m8O6eC6EHsVCGA7Qb//bvW4CM/+D3ecdTeuPCMg63Ho3OioVhzri7lAchSFZpRRK4Z+bW1zhMexDFV0+NMEbQpQHonDL+cs0q5hKgVp03fXcUQZUOx8yUuaqxrjS5aFQvoxG6+B7GrVYliNwFi57rN0JCZW9HMqlzp9emyOzGtl2QiWKx4IjUojlRVbPK4d4swx/GLbqrpPSKK3S3FAD3nzOc6pkTQh6h1V/LjrbZISrFrks4TPhs0otj1WM4jWszRKfAKxd50001e/375y18WevFbbrkFp59+OpYtW4ZSqYQf/ehH2t/jOMaFF16IZcuWobe3F8cddxweeOABbcz4+Dje9773YfHixejv78cZZ5yBNWvWFJrHdMJWFeurMPn42AEkfOAsoddfIwv78Dcdsx+ib1WsdyhWUOxsbul9tSzPLjs+MxeDNFLYihi4PDhTddpzkZ6obr6GVDwBJJ5zHK69I0/qAGBknCF2jpwP7j3f+eQmnHjpzVj5yPOI4xiv+9Kv8ep/+pX1s/jID34PALjqtietrwfohJiGLszwcsuhhNC/0WIFb8XOp7iBXAd1DyKVqe/uc1RB3SCV4uoqhsgTOzdxVLBVAioULZ4AdOK1sF9u35XNwz8HDiieY9dd9Vfsspy5WFOQRZ85oVhB9LEjapHfeH1T3XIQHRpKpsd3GSxnvWKTx8XoCnlct/Hh5wOQKlGyqbYrZFllctou0sO+pN5qOe1XADMU666Kpfezsaa7w0v3TCV2U4Xh4WEcdthhuOKKK9i/X3LJJbj00ktxxRVX4M4778TSpUtx0kknYdu2bemY888/H9dddx2uvfZarFy5EkNDQzjttNPQanVOvNsGMz8NcCl2yf++xRO6Ype8iNMk07j4XSaT+WKI9nvzDMW6vJry/Rnt8wf0yl67z59ud0BhJ3b5v9HH/vyV++DYAxZrfy+i2IkQPqNhJhTLhWxdr/+ub96JRzcM4a1X3o7/vHsN/rB+G9ZsHsVT7Z6zJr4rEE0JNBRLSd5YU6iKtRZP5EOx1mIL4mflEyJKiycIUfOxO1Gv4ZoPfc6wZ4sw9RI+RBMwiJ0HScvZnXgQr/6Cil1Vy7Fzk02zX/Bk+thRYkQ3a3LVKp8z52sd5VKWs+KJ9lpd0GHAtyo2H4rl50PP6SQH0T8UO9aMvIgaLY7L0mbcChkNxdqKq9POExGtinVvGGko1o/YdQ7nmJBB8Z133onvf//7ePrpp1Gv6wnmP/zhD72Pc+qpp+LUU09l/xbHMb74xS/i4x//OM4880wAwNVXX40lS5bgO9/5Dv7iL/4Cg4ODuPLKK/Gtb30LJ554IgDgmmuuwfLly3HjjTfilFNOmcjb26HgQoG2MI4tJ49TB0qlUprHY1aVOt3J2/NwhWLlqlhJsdPn7Urgzcrh9U4YNnVGEbsRqtixxBfa3Cls1ak8sUvG/5+XLMfHX/fC3N/NHLvWBKoXxoQiCW636FpoGC6LbaS69sP/+fv0Zynp/oIf3pf+vHiO+6auK3bZz5LHnm2Bpw3TfXLyqO2BT4iIhmQyg2LLeHKzUO/Tpdip11BVzc4cO+McLkTsPEjaRBS7wjl2BX3szM/E9RSaY1fE7iRVcypyg3hZsROIHVmH6Hhp7aoSCx+ggCeoSew85+8OxWY/R3HsbCkGAH1dyfkwVm95XccVsnGPHMQX0KtiXZ8PQK77Jv2O3Rs0LRRrUdJ7ahX0d1XYVo/ThcKK3bXXXoujjz4aDz74IK677jo0Gg08+OCD+OUvf4l58+ZN2sSeeOIJrF+/HieffHL6WHd3N171qlfhtttuAwDcfffdaDQa2phly5bhkEMOScd0OrhQrC0h1wx7Au7QqmnC6ao8Mi0AXMUT+apY+8VZybm32xcXdeNQeUi20LNCulOu20vouc9TwWYUzBGpNMFeuPnnFLsJKPdKhXvtoUuNY+Xn7woNcKFYaXFqeJBQH+IgETsYU/HJmaM7fR+Fr0uFxZp+RJCeG67m8ICp2LkVRCDbzKgbvy2XJ5mT/rtTkSoaip1Ijh0JxS7wCsXSObmP322ck648QfqZuIhjlQkD+oX/I+1/l2I3amxK5ZZiimjqHpy+vnSp4iV1zlCqtfLJi9Sm2iMUG7mtqYCMzA7Xm0REkMfTPEGXKADohsBqCfNrKRZ5XZf0fuYyJwaAw5bPxwOfeQ1++tevFMfsaBQmdhdddBEuu+wy/OQnP0FXVxf++Z//GQ899BDOOuss7LnnnpM2sfXr1wMAlixZoj2+ZMmS9G/r169HV1cXFixYII7hMD4+jq1bt2r/pgtcSzFbHgZbFVtQfnflF5m+cS4fO5pkTp8nupkb79m1a1Q3jm1jSZWqq9ctkC2oI3W7m7n52VBwXnVnHr578jdLKFa6+ZsK3UR85NQNwlRGmsx8UtVIWMO41zfDXuaxbPBRX+hx6M/mTLIcO1vOXHvBjvwMitUCX2/5JWnT81qRfJ+qWIB+9p6KnWcodrsUO59QrEnsPMh6Xy0jdnsu7LOMTFDUx85Fdk3QzYnLToUSo3Rj5pGnmUsLkayXurINpnodQD4vTB+7zM5DmE9FFwZcoc+atMmX7h00FEsVO8t53d+VX3utGyISIfLqPMFcx7bLjLYU8yqeIIqdT6/bTkTh2T722GN43eteByBR0IaHh1EqlfA3f/M3+PrXvz7pEzTJQRzHzh2ba8zFF1+MefPmpf+WL18+KXOdCLjk/eJVscn/vu7kzn6CRuPqNBQryNFmC5Z0FyUcX3ldqf6g6fyF72ygrdgNjTcRx7HVvkSB5tjZdoHc56lgkrc9F/ZhbttTyxaKpSrHP5/94vRn8ykTIXZqB/mWl+2JFyyZgxP/ZIl4LLUo7bGgD9ecdyR+/FfHaH/n3nOvQOxc3TAAYMO2cXz0P3+Pu5/aLI6pk9xXW6jY5zum6oaP4bDeDNytDFA1vZkSO/d4wN9wOMuxU6FYv+IJhaJVsS6Ya4hUMEWxdSyzBdptnt0AOZlHsTm5yK6JgZ4a/u51f4K/fe1BmNdrVxBpjl3TQdKSv2V5nYC/9ZIi7pFDUcuFYl2hUqMq1hX6pOkLyXhY569Xxfr52KlQ7AhR7PyUd7/cWi3HziMUy7YU8/CXbEV+PaI7EYVnu3DhwrR4Yffdd8f9998PANiyZQtGRvgE64lg6dIk1GQqbxs2bEhVvKVLl6Jer2Pz5s3iGA4XXHABBgcH03+rV6+etHkXha3Klbv4ufHO0KpROeXaFZnFCuoGLCVSy1Wx7PC0X+Xjzw1pz3MpdlHcJmrqpmwjdqQq1tp5wqbYtV/nglMPwv991X74zp8fme7cuPy7BnPzf/2Ld8fR+y8CkDckthVPSAuJInaL5nTh53/zKnz69Qe3j82EkomJ7TEHLMahe+ipEiyxE26inGJnfmb1ZoTv3bUaZ3/9N+wxAD38+vxQlp9reu75VJWmYbRWjG/c+kT7MfcNoUGSrm1KAtcr1ic3ByAtwhyb0Kwq1lOxM17eXRVL1DEPRdWEzw1tGyF2PqptUR+7osQOAN79yn3xnmP385iL2hz4WWHkFDtH+NYMxaoNgmvtbabEyy/NJp8/LczfIKZZdIUfD+gm+j4txdTGfXicGhT7KXY+KRJ68QSc4+mGzqvnc/tPlNj5bEA6Cd6zXbVqFQDgla98JW644QYAwFlnnYX3v//9+PM//3O85S1vwQknnDBpE9tnn32wdOnS9LUAoF6v4+abb8ZRRx0FADjiiCNQq9W0MevWrcP999+fjuHQ3d2NuXPnav+mC4V97Jhkf//Qanu8Q07P5dg5+lLKLcL44+/X7lf5/FAdm4frzqrY3lolXVyGxppeak7qpdSKrJ+nuVBTqJvzHgv68LFTD8IeC/qycJ4lx85cNEwFVEER7b0W9eGsl+yh/Y0LrdIcEXXDsM0/zY0UFiVOhBNDsY4qYP1xmbBKIV3zGT4txdRN8I/PZlXytjsUtT2wWeAo0KpYr84Tlo2DBPXVjPgaFG+HYuerOnz0NQcVes67X7kvempl/MWx+3odn36Gts4cCiv2nO913IlAs9oo0CC+YRApiSgUzbHLfOw801qEKldpPl05xc5NpGi3Ch8ipRQ7ajVlu45pepFf5wmaY+cmmpzybq2KJVGcdHM8w4idd1Xs4YcfjhUrVuANb3gD3vKWtwBIlK9arYaVK1fizDPPxCc+8YlCLz40NIRHH300/f2JJ57AqlWrsHDhQuy55544//zzcdFFF+GAAw7AAQccgIsuugh9fX0455xzAADz5s3Deeedhw9+8INYtGgRFi5ciA996EM49NBD0yrZTgfvY2epip1A8UTeVNN+cptkQd3U/XvF6nM10ddVxZK53Xh26zjWbB7F9feuBSCH5kqlEvq7q9g21sS28abXri5VKR0Vk2WyaJngFLguS2l7o5kPxQJZFbBUPFEplXI5c1GckDuqHnDtbSgJN1MQqGLHgSOD0liOrHEqYTr/iO+cIRK7mP7sVwzBqVXPbRuTx1ezkIyP3QlNk/DduVfKJe1z9bU7UT6Evi3FFJzzKRj2BIAXEWXX54b2giUDuPdTJ4vrgwl6TJ/iicVzuvHD9x6FM788+QVxNE3Fp0F8zYh+pOeRsJaafatdxQFp2LBphEo986ddoU+al5oc332dJXNNSJ1fKDYrnvAphsjuN/b2jwrUQsbVl5weixZZWVuKkXOi7qHUdyK8id2tt96Kb3zjG/jHf/xHXHzxxTjzzDNx3nnn4SMf+Qg+8pGPTOjF77rrLhx//PHp76p12bnnnourrroKH/nIRzA6Oor3vve92Lx5M4488kj8/Oc/x8DAQPqcyy67DNVqFWeddRZGR0dxwgkn4KqrrkKlUly+nw6UiCqgYFfsmFCs58WcK57wroq1EwSzKtZnsaAO6/9zfxJuv3fNoDh+oE3shsaazrwWQF+wrT5/JX3uFFmVa/a+s0WFUbAEQi4rdtnn9N7j98cf1m/DKQcvxd9el1iI1A1ip3b9pVJGAMyWcZSsZ4Sc/964UKxEvNhQrEWZ++T19+Pv33Bo7vExjyIM+jHZiVf+fa3ZPCqOL2p3os7rRitTKooSO1fxhLr+h70VO/33IlWxvqFYal/imzTuS+qA4j52AHD4ngtw/V8dnea4ThaqZAPo1yDezLGzF+30SIqdVLVqdJ7w7eKTFVvYQ5+5qluP0GqqXEd+LcX60xw7P4NiSqR8FD5KlmMfxVFLqSig2EVxWkDnU3jUSfCe7Ste8Qr867/+K9avX4+vfOUrWLNmDU488UTst99++NznPjehbg/HHXdc2liY/rvqqqsAJCfbhRdeiHXr1mFsbAw333wzDjnkEO0YPT09uPzyy7Fx40aMjIzgxz/+8bQWQxQF72NnIXZs8YR9l5MriXckmks+dtJNhFYPAu4cO/oa9H3YQi4qz25ovJmFG6ztnTIyZSsu4RRThVSBI6tqj7ED18YLuzspXEq/53m9NVz9rpdpIVmTTI3Vk997a5V0IabEz1TQXIodR+wkixS2WMRigXLNb59mHx8ZzxspA0CM/PkM2EN13OJv83ymuTZevnftc2i0kc3ZtxjCe3xZV+ymsirWNxRLDYenImmchgmLKCEv2mM+9l7c7x5YaC7Z2uij5tDxsUdostdYL1xKdEa8/EKx5tri2vRSU28gq7q1b6Cy11Dv10YEs4KRZkogfRS7iBTGeeVPN1rp2m6bj2aL5JMryxRPuDZQnYbCV21vby/OPfdc/OpXv8LDDz+Mt7zlLfja176GffbZB6997WunYo6zGlxVbNafLr/I07ZFCm4fO/3id5a4l/XFJduVOqpizRw7p7yfvI+lc3sAAJ854xBxfG+X8rJrpvPxWSyoYmcNbVtDsXnFjuvqIO3uqAEnBRemqFbKKSE2iZ16Tc3OwVDsKDhj6c+8/mBxvPmaL9lrAXYZ6GbnAoB4u/kvesOCwTJXPATYbzjc4vzJ0/PG0Aqcsam1h2U7p3SItGtzhSbN47mKJ9R4ZQy9oM+uSOUVO8d8yOv7kijaImwqiB09vk+xxVSC5tj5NYjPq0uAfA300Q44UZxuPFzFEGkOnIOo5ays1NruUAQbnoogoG/cfUKfqnhipJ61/PLxjWu2Yi+iSVVQH189rcrVwxaJpuc0HFGPTsV2zXa//fbDxz72MXz84x/H3Llz8bOf/Wyy5rXTgKvKVLu7HiaR3Wz6DPj72PmW6EteTbJip5Mjl31J8jekx053yhZXf7qr8yEUlEw1LVW0NsWuzuzWbMROSr427WYUpFxHtfia6tkoY5apt4zTj8+F0N/+ir2xZG5C1rgUOfWcvzp+f1z9rpfhkGVJYZGteEK6EXIqn6TY0bnT6mHbjd+0Bjlo6QBesGRAGK2HYl1+YkC2mA+TOTtz5nJhePt48+VdilQ+x85+/KqWY+dHomgolrsuthcL+rN80olU6k4masw6Ya2KZexRAPl77iHV+XTzKBc36MUT6iV802acnSeM4oms64+b6Oh2JzZFLb8Jt10HWksxjw0XLc5wFd4lx0I6/0I+djM4x27Cs7355ptx7rnnYunSpfjIRz6CM888E7feeutkzm2nABeKHW1kITcTZo5E8tzkf99+gm4iWNbm1EhL+v0UO7+LLXuOIjjW8SQXzsdbSGv4bsuxE0gXwCt2ZjI0hbQIZHM37E4EAkwNNSmGxhKCoXbE5nuSFDtTZVILIx+KTd7X6YctQ393VbMWMEFDV99850vxd6/7E+3vz27NFzJIil0c0/Mze9x24zebw7vUJXUT1w2KbcQu+ZyVL1+p5CZqRYkd/f4q5RKWL7Ab/OYUO8d7pq/vMutVoJXRtu4rE8VCUig03Y3T6abXpyqWWuzoih3/2dIqV58Ug1wo1tELtWqQLhcxqhk5gi5FkP6tFWXXpi0ao9ruNSOiwNk24eR+41M01dulUiRaniICJe8FfOzincDuBABWr16Nz372s9hvv/1w/PHH47HHHsPll1+OtWvX4l//9V/x8pe/fKrmOWvBKUZcyE2BWjYo+PrSNc1KLmn89ip2Hm7gXIN1eyI70mO7ijnosZote9jN2nmCMRw2k6G18VIo1qXYGfNSSpF5U908kvi+0Ubr5XIpvdmbFilSNTNVS02k1jbtOdSY802BJpsff+CuePcrdbuLZ7eO556jbD04qNfwVexoKys6VwmUMPskaZvnV61cdpqjmzcYF7EbIUR32fweJznN5dg5qkop4fC1bKDvcVF/t9dzioCaYFNz4+lAtgGMyAbWvSGlOXm252ikwiN0mypq7WvAVRxQpuscuZxd94KGQRx9ioiSXrEeoU/tPbtDn9Q1wGfDRVXQyEF86bGSUKy67t2iQCui+eUzi9h5V8WedNJJuOmmm7DLLrvg7W9/O971rnfhwAMPnMq57RTISFH2mMqx4zzFsptTPidJLp7gq2J9Q7fqhusutkh+d4UP6N9acdb42aftTCKPu72FKDmNy/J8rJ0nmIvaTIamEEOxRtufbDz/vdFcMIot7U4dZh5WtVxuu6q7Q7GAPfycttBphzkl9TB5LB/W+NJbVuCvv3tPMt+Reu45w+O8Ygfkw0nlkj1E1F2toFYpkaIVO4mizcB9bBXMvBqfUGa+Itr+nGe2ZFW8qprQhnzxhP349D0USQD/5jteijVbRvHCdih+qrB1VCb6OwKsj53HuuKbY8eFGQF3yy+lYLscDOjx6XohbRBqxibf1bIseW2kr1FkbY/oeGvaTPv+1HK/X0BPh/Gp0tXTePzzKKnNUVeBa6cT4E3sent78YMf/ACnnXbajLESmQngbrI2s1LOINe3eMJsFO2zWABw5iWoa1btLn0S0zXTSDXeJo+TXSBnQ5I/frZgq0+R7+SB9LgmbDl2Y4xiJ4ZiBcVO3dRMCwcp/LlluK3Y9eqed9VKCfWWJRRrfE5ULaWgpFmpfBLJTN5Pnsiecdgy/Ofda3DLw89h03Ce2NkUu5ahItiIvsKc7io2jySEdyKKnS0EZSqdPlYtRUOx+uu53685Xdfxj95/Mb52y+Pec1A4/qBdCz9nItg2zYodzbHLNioWkqDl2CXnQ6nkdiQwiZ1LsQMMI21Xmk0ca9eW1EEm29yYxRPuUKyvYmeaOAMOo3HyHnzuHTTHzofY0bZrTY9NoN5xZpYrdtdff/1UzmOnBV880c6xYxQ7LjTm8rHLVU75KnaRCo3Zw1bme/BpzEx3gT5hMW5n6qvYZa/JKHZkN2eCy+WbSFWs6SOosHEoCVUu6teJmtTdQhGY+f06EZSIo4vYmZXANPSrFr50LmwLNZ7wK0Vxy0j+pi3l2AFZ+CkrdhGHppjT40/ssvfi52Nndlrx6e1rztlVFUvhU4FqnsOu0PAx+y9Of/7js0Pec5lq7LtLPx5/bhinHrLbtM5Dy7HzaDfF5dj5dFWgiqCNCNJzOLFU0Y8jHb8VxWlYv6tatoRiVVWscS/wKp6ga7ubGNH1y6rYMeFqax9wqth55PxpCpxXdAjp+Hr7859pvWK9iV3A1IArnhiz5dgR93wFXwXODHVJF0/ezdyeJ2G+B5/KJpqg6pNjR3emnI2HND6Ze7n9mGXuufy3LIyg+9hlibtmpwcpFGs26lbY2Fa0Fs3RiV2XkGO3ZTQZb3apoM7tFFJLMSkUS19PzcFaPCGENdT8NjOhWKkqNjmevjHwU+xqAJJwpjsU21YSWpFXUvdELA5Mi6Iiip0fsSs2H3rD28woqNOF6957NB55dhuO2GvBtM6D5ti10lCsJ1ErkJMXxX5WHnSNbZINiPQSdD62FB4FtTaZvWh9iBpdE30K46j44NdSzM/Hjq7BhTpPxJ7FE+R+Fqf55TOL2M2s2c5CcFWutuIJU0oH/BU4sw2Ov6Gx/eTOV8Umj9vk8dS2hShB1l2jForNFzWYoCEWa+cJh9oF6IqUCgPEcb6iL831MhU7IcdOEbuFgmJntvFSCtj8XlOx0y0SzPdgKk+cSgzo55Qig9biCXVeGAQsI3YFFbu0eMK9WCsMkMpYZyiWfK4+NgxFuikozCXfjStHUJqfDfSaOu7AXbyO+413vAS7DHRrHobTjXm9Nbxk74WFPp+pgLq2fVuKVcm6km2Q3RtMWkjgQwQB3Uhb3rRnOXnq2uqzmFyr9xbFBlHzJKep3YnlVFWHomuG1e6ErtUeCqK6L8ZxJoL43GsSRwX3d8waFAfFLqAIsmRWGoptEzvP4glXnkS6KzUUEZdJplpUXMUTUlWsT96DdvH7JLQSxc7uHp6FTMqlWHuMPa5BcraNJ6SkVNIXyh5ygY/UW1oepJSPIZHHTcNJKHbxHL3yUFLglJ+aWQ1qfr8KUpGJ+hrN8DMtQlA3XJtiJ/nYLWiHijmFSOoHDORTBXzsOehn4SJG6nvxbfk1kfDL3O0w3/V5PUqE/vqEA7yO++qDluDOjy8pNJedBelN3NvuJFP4vCINZEPqE7otlUppQVAzirJNsiNaAmT5itx9Q6Em5PD5GBTTTbJ1bU8Vu2Kb9mYUOe1dAH3Dpe6VVmKn5XN7VOmSe81MLZ6YWTR0FkKRKHrjHPFQ7OqtKN09uRNs9Ruaa0GScvIk+ToNcTV14miXx5G+DwVfd/I6k/tmgqte4xYvKd9ssK02zeutaYtqtVJOQ3RmIUBKdIz3IbUU2zjEK3ZVhuwDMlFzqY5mSFGqBC7aaUMyik6Tmy3PUR0ttL952vFQ0JuYM8eOOV8mOxRLFTuf+VMVzSf0TA852X1Td0aoc7dB7E58WhUWzbHzNd/NvYZjE043w8rnss9SXW3m8PmEYulGP6uidZNZ7TEfstzKcgp97EgAP3WfpvH4tBSj0aHxGWp3MrNmOwtBDSwVxiyKHT3B1ELkyhcyc+x8fe8yxU5WvIDMKHaoTXSKVMVSQuuz8x0jio+Xj11kt7bIdnP648paxAx7AllLpG1jJrHjQ8RmMYqCWjTM71kqtpDCAjVSqUchFk+kNxv9fdUZYpf26B3L58alu1/P3rhAlnLwNye+IPe31FvLIxyjQNUVW+cSgN+YTDqxI2TLZ/5vPDzrDYyCosDc3hBw2V5oodICYTpaDOGVG1yE2DFG2hLPoeeoSu2QKmKBfA6fT+iTdqvwymkzjuVKSVDrEd3ku4o51J/VGuqj2NHQqo/dCTXDD8QuoBBqTI6dIi9myyRAV2tMQ1dvBc7RH9BUgLIbOH/8Oe2bmSI66n7uE4rVctk8dmljJEfLWhVLyI5P5wmbYmciJbJGIYAUIpYKNKTvzfQRNI/fLSl2xnjRx05Q7Lj5DwjvNZk/r1iYbYsoVFXai5fPxykH6+FBX0VZf61srr45dhT2qtiJ5NgVC8Vq302eB+dAVdCg2G0/6MbaJxRbY3PsPEiCViTmlzLQaEXOfOVapZyuR+sHk04vtlAsPSfrrQhr28+x58BlCqJPSzHz7bmUaPX56VW01qdkSqsjTQjgTaKteZFkfWx4KHydiJk121mItPyc3JRtZfdmjgTgX+Wa6yconNyij51w/JTotHM8fMxfuRw7n8qmMSbBnwMlOzYFkb5XmmenFLt5RgUqAAy0b6hUxao3o5T85IobDAVUQfm2mcUHkuIlFmcICl8WijU6T6hyfiEUS/NJ1HfL+Y1JYQ0fxa5WKeHPjU4VufO5oCGwK8dO5S9R2NSN7VbsfIhpwTw81RkE4H0uA4qB5tgVSaxvEkNwn9xgXyJI/65FMyxESm0+17bNrm1VsaVSKb1Obv7jc+njPga/zcjPoNg8710kLY3eeBZbaM9pZhYyrrGFW4oRhW8ia8F0YmbNdhYiLT8nYTSbQlatlFMCVE8VO/uCZCbju0Jdso8df/y5RmiyiImlujAr5ZJX3oZKlq2WS1biSMmFreE7VUzowjI46lbsaDskZe1RKZdyzzFD4QoNgXA6fek8c+zGxeIJiTjmQ70qFLuNUeyksIY6TxosscvO1ZfsvRA3f/g47D6/V5t/kVCs3uTevZzRMR86+QVeuT9FME/LsStWDOGDw5bPAwAcuc/CYhMLYKEVQ3iE6dL8N9+qWPL91j3UJSA7R2nVvY1IzW/7Rq7zUOyA7P398g8bsuNbTlX6GXmt7SV+PRDHc4qd47pI15iWRyiWUeDs5B3peDUnn01mJyEkaUwzqMyt4FowapUyxptRLiepqGInXW9FiyfSPKxxndj5VEL5SOnJXNvErh2Kct3EqQUIZzSsYBI7pYIMqr6sHLHryYcnVSHEgr5ajnCaxSsKkjJl9vZVkBJ5pfFSjp35/Wbj8wrcgDXHjj9POQsfhYZRlbbXov5UYVDfkzRvDvS1/Yldcg7tOtBjHTsRK445WlVs4ac78ZHXHITTXrQMh+w+b/IPvhNCz5nzCK2SwiYvHztybas0EhdJUOusb2gyI3ZuxQ7I3t980prwgF0HLPPJ7lE+ip153RRV3+gcXc/xCsW2PztqOWMLt9ONrxT16HQExW6aQRNlFVw5RmabJ9f4NN/MtDvxLLZwXTwDQo6d3fQy+V+pSu4LOflf+Ra5bvpUsZNyzQBdzdIqk5UnVHf+gubIjlLsTPNgOhdTUWsKnyu1aqGQCKqck8d/VmrhMpttNBiFb6C7HXbmcuyEsIYUGqZzpCTMJJqq2tilPNDnAu7iCfN1fYjjte95uXMMBQ3t+lS5FkWtUsZhy+cXtlIJ4EEtcLKqdvl7q5Fz1SvHjqyBz7U7zXBrBEU1VeyyfErb9z2/fbxntybH73K0/FTveawd1n/zEXt4+cw1SLGF7dSWIhDi8ZUzxARCseMeoVi6HhUpkKH3jhCKDSiEGnMTbzly2lSobKI5dq6daaowtfQcO0kRocUEUeTX7y/dcTX9EuXNUKzrpkx3dLZOFTTnhBI722fEFRRIZsMAydkwiFeqhBqrZM0gOgrS+6gJREoitJLFiy0UO1Jv5RS4hqBYSMUTMUkg50Ko6jwb9XDQN18L8DP4pfmDPov1y/ddxH6nEiixK8rrYp/qiYBJBV0nfPqIahWWBQ2HN2zlWwiaYIsJbKHYdlRBXTduRTA5MUc9FUQtD9nDHsWM1LhJWvJ/g5A0l1qefW/uYg51/FacfWe296y6x4w1o4zYMYWMnYyZNdtZCC6M5lLgTKneVRVrKihuN3OeCMqKXRZ+Gqo3PX3slFKZ5czZoMimWrzcZrScnM4/hzPhtYWT5zB2J5uF9mAAWRgNIiUlX0s5c0UNkEUfOxKa4I7PFU8AwPC47kunPiPf4glaIESfYxJBpZb21tyZIvS88QrFks/Cd7Euoo71EDJapE9swPSgyhA1a+cJwtZVIYtPVSyQKXbcGkFRNMfONCz3tVNRa6mvotaI3J0wAKBkfHyu66BiKHZeubWpMOB+jlYVKxSsUfS317zh8abYlrHTMbNmOwuR9a8kVbGOXUWXqdg5mleblh4uRc0cn+YlCPPpJk2nR8ZbXv3+TLsTV6J50VAszbFzGRpzvVltlcPpjo5YT6gFwOwVCtjsTnhVkFq1KEQkB8h8H6bvoIJ6P3lip0Kx5vg8UeuqZobMqhuHOX9zkecqvZPx2fuh51KNfFcAIXY+it2EcuwS+ObNXPGWFeiulvHZNxziHEsVuxAu7XzQlmJeoVVy3qpr3sd/EwA2bE2KGxbNyZtz63NqhxlJBbTvawDuTXIWilWbakdaC8mZVddmv81SpaBil1mX+EVv6Ji0eMIjNBxFtHhCfo3+dvpNQuyUYjezcuxC8cQ0IwtDFVHs9BunM8fOUFCKjm+1ZJIDZDYSKk9F3b/tlUrQ3oPrnpwVT7jL1c33kClR/MXJhWJt3So4+xL19XFkVj1G7UXiWDYs5RQ4SjrN9+6uotXfd0kgmg2hOGOgp4rxoXouz066EdIqOu34hOjRm4k5/9F2jp2t56X5Wsm83TcEndj57WuP3HcRHvj0KV4tzgKxm1nQquc9PMvo+aZu+jZipMx04xjYsM0vFKs2OuMtqti530M21m9tHGu6FUdAT5XYoorK+mQPRfO8d12X5nx9bHzScLVHVSxNPRmzdHVS6O/OcqglJ4JOx8ya7SxEqm5EmZrmaqtiEhGX75eZXO8qnqB5JDHNS7AsAFR18aqKNS5MZ0l8qvD57TIpWXBVWaqk+3GG2LHdKpgcNdt7VofQiSAJS+Z87PJ5l5TY5RS79Pv1rIpN56/Pk+s8AVAvO57YmZ+RpCA2BXJqVtEWUuwKFkPQMUUq3XxIHaDP2XWDDZh+0Fwtn64EGrHzDmUmf1eV8/OdxRNKsUuO78o5y11/vopd+zqz+fABpGq1FaW2R/N65fdQlKiZn7fPhkvN6dePPM++Jje20YrTzakZvqZI1zuykQ05dgGFUDNuylR1cSl2Kj/NX4Hz87GjpIlWf9l2srSgI0uwFYczoVj/xQUokvAbWatiAbtixy2SVNo3x9valtHIp/Y9eyhwDTI3iQg2jPlIoVtu/gCtutXnI7UVE0PJqceUkFNY1j0LzeKJtCLZKxSbP44NWvHEFCzW9CZmVh1LeO9x+6GnVsYHTsq3WQuYWtB1Qp2ftvwruk6Ne65daq1TOW0u4lI1cux8Fbj09ZzETp+P7f3S8ZuH6+k5zfl7pq9vvLxrg2Z+fj7Xpbmx9/GjpBvNAQux6+/O/22mKXYhFDvNUBdxFOskCpAlbCUjq3J1d1VspqbFceZFJF0M9JppkrwEn4un3ozSsKRPXkhmMeC3ONY9FztKjsYdcnpXW7nRcuwsrXPKjOJlC90qEkNDsZS0SaFMmmOXqWl5Y+Y055KQP0pSzRuJeks+LcWAzPLENCmWcjVrgmInfdcmkR0rUBVbKUjsJhKKLQI6Z66lGoePvOYg/M1JL5hxbYtmA2iOnY9iVyqVUC2XtHXF35rDr1Cslo73KyYoqtip9zxWsHji+XbxR19XxatPt4It7Ank3x+Xp+x6DRsZzK2XlbJVredSQILdSUAh0EWk0Yq0vCTpglOVd0rZcFbFMv0NreNp5VeTD5+ZoD0X/foJFlPsTAsA9+KVhZ8lPzcFriq2qGJXOBTbkr+HrFKahGIt5DRTcHliJ4di+apV8zVcip2UI2gSGymHKe2XHJmhWPe+UyvCKJxjN/kJ0fT49Nop8ryAHQeapuLjcUafM97wreg3iJrn2qXa+LkUrIkWK4x6zl/NR1k6cabtFKVSSYvWuIhdLhTro9jlwrf+xRy2MCyQ3JtocUhXtTwhs/LpRFhNphlUBm8axEvKI1M7CnVhujpVUEWE3swlyV4PN/iZZGbVvVH6Grb1UR3Kl9gVJYK024NUHarQTZpuK0iFDXQu9LtKK0QtOXl6KFZ2Wec6VXAecwoqdEoVu/FWlp8jKWRSKNZ8jQGhX6wis+bxKcnnji+2IJtAKJYW9PiES+j3OdW78LqnYhcwfdBbD7bPf09iNFZUsWvwinju+O2/Kwsl2n/YdnzpdxNqo5cqdp5pLc+1iz+4/tm5OREi1OO4js2Np8+GyxQNbNeyuSbbwrAKfSQc2z0DN10zb8azDPQmRxtLA3IllMpZGKu3kuIGR6hUb3Sff1waD+gl99YcO0KOFGGwmlgaOXO+i6NvSTytzJyIj13h4glL3mKJGU+Jo/k5cZ0qbOHkLoaYUoXPPH5Wpasfh+s8AfAt1IBMgcu3UMvON2qp0hAUO3UNDI7U8aav3IYbH3oWQHGDYo70mqDhZ59ii+2Bbyg2YPpAfUR915acYudJjHzsUYCMSCiFzEVEcoq/59qYXo9Ou5Pk71tGGl7zAXTi5VLszPXGZ8Nlvkfbc8zPZw6TQ2eCjplphRNAyLGbdtATtNGKNRVEIkYqQXuk3tJuzj6dJ6hSJIVKaYk+DSfZFgzqXabunT6mkb6h1bQqtmAjbfoZTV4oNvmfK57g5pUqZEyOnW08DddKpIg+Ru0RpLAqkH2Wkj2K+Z4HGENm+n5yip2hQpuhVlMRUc//9u1PpzczwK1UmK/tOocAYHA0Ux19iOP24BX7LprS4wdsP7R2U5GfomamPrg8OMtpjm37NR1EUClcqlNFUWLnKp4wQ83OtbSsh4Z9rptyGaolM3ocxCiv2BVT3rljUJjrgg+xo3OYaYUTQCB20w6ajNuMIitBUOgloVgtJ09YMGgyPlXsXMUQjVasmfDaxnelOW2RtfBAQf3Np4kzUDxBmCMjrqrY8cLFE3F+PBe6bT9EiWCaz8OMT3fUEaPAMe8hrUhu+lXpmvYiCorEm/YEfV2qrZiZY8cXsugqdAx1uIaQw6R+N3P+bF5ZCkWLJ9TNEnC3LZoo/v4Nh+DWR5/H59/4oik5fsDkgUYCshy7YqFVX4Us+91+nqpUm2e3JYbGRUOxbrsT+XrloK7P4brbAy6d03YpdsWU+uQ5llCscZ37KI5aysYMMycGArHrCFQrbWJnKHYS1I5prNEycvIkxS6zk6A3T5uiVmkTu3Gi4thuhDQU67NAqmvZ18dOyhOTwJECuSpWVuysihotnrCEYrnQp63ghTt+0+IlyIVibV6FUg6cChWZi2Q38/kk8wM7J/qaybyT87Up5NgpRaC/q5qGewC+7670XgC/0Kpq6zSVeOvL98JbX77XlL9OwPaDMzL3XYvGPEOrUqqCBJXf5Rv6zBdPuOZftv6eO74xXx9iVyQUW62UUS5l66NL4Uvm5E8Gc/P3KMqiz5mJit3Mm/EsBJX2XZ50QJZjN1JvGrYZ/NfJJQiXSnbJXh3L24RTmWo2o5Ss2Ywp1WsrlWmyF8feWkXbmZZLcrXbZBA7u2KXD8XavAE54qXEO24+3PyblnyhLMfGUOwaqn2OPieu5VryHtqKnVA8QedB30/Oh6893vS7WuBB7IoqdiY5Ddi5QXPs0vPTpdgZLb+KKnau45uhzoHCxRPW4WJvZ3m8SYx8QrHZc1zFE+acvBS7AqFY8+0VLrKagTl2M2/GsxDUoDXrIiF/NT1pKDbS8rB8cuxSguDyRmr/We1KffNOaOjTtlMzc+ac4Y9cgYF9PqVSSTPRtF34k0LsBPUK4O1OiubY2foH04pkBZv9SpWcbxRpX0RjYeUMnOl7yLc0yo+h88tXxeaJL5BV49pQ1O7kC29KwqOfP/NQ59iA2Q/a5cXX7kRtTKZMscsRu2I5di7FTmpJKMFca71CseSYPuO1jjBeip1/KNaMNPko+3TdnIlWRCEU2wGgCopSd2y7qDTHrt5Kb5w2BU7zsbMoS/pzlGJXrFiBEjufvAd/w2Hj+R6J8nN7a3i+3cbHtktLDZ+JtYu1eIJR4CSzXjpeszvxyLFrRnmFjyNqXUTxzY3nQrHp8c0cu+T9m6EQtRCavmzSe1a9gxstvVhHunGq89Mkjj45cEXtTt78kuV4zSFLnSpIwM4BrrDMpWCpjbXydSyu2NnPU5MIuXzXClfFFsyxm5BiR+1OPIhdd7WMbeRnF4oodtxruUA/U5+irE7DzKOisxBqh1JvRVZCocDl2NnGV8iNvGUhFNxzMsXO7+JXVYfd1bKVfOV7xboUxGKLF6C3vbFVQikiM1onxM5WPGELxXranfjl2BFSZCNqnOKYEvjccK2CmUJU7ARiZ5sT1+829ckTkslt3TIk0CP57qwDqQtQoOuaOr9d55FaS7a01zrfqlgF1ybZbGnV78gJy1XFOluQFc2xMxQ7L2KX/eyTM9dVMBSbV+z8Cxy8FLuCKR6dhqDYdQDUSTneiFBq33NsppGZ3UnT2XUCIL5rRLFzhWJT76U0j8SRkNs++b9682MAPPoDFqyKLWrCCRjEzrLrzVq0ZcTOR4GjvCgbnz8+Z3diy7HjOk9EKYGXc/K0UKxF4eNCtwDJsRMMQ01FzVbow6mODeE9q/lQxfGH7z0qd0wOlJr6+NgFBFDQ63u47dPo2lSotURtYn2raBVcm1Jz7XTZi+TTVOzHl3pHSzDfX9FQbFfFI8eOzMmHCBbxsTNRVLHzudd0GsJK2AHoThURqsDZcuzaOR6NyGu81nnCYoPBPadoo+t0jo4dlDqc4jqTvTgCRRQ7vZMH4JcDF3kqduoQmt2J9fh5tcs2Xp0/Dc/xNTHHrl0VKxVPmIqdYFAM8JYqDcGyRb1f9feX7b0QBy+blzsmB0qWfXLsAgIo6Lqprh+Xzc4co2rV1yw9/d2hAJm9Svscil3RHD6pN7UE87ry8rHTctTc1yVV7HwUMqlftg+KFk+EUGzAhNBNQl0+VbHU3sJnPM2xS8NhrrY2KbHzC8XSMCbgVuzyi1GxknufHDtdsZMXazVXLRRbsKWYbXwpzclDbrxN7fI9fo0pbrApjlVJsXMVT7QKKHZMZW9dOPfUuaV8sgrZy5HP1OWgHxBgIh/GdPvGmaFSZxpJQSJlEjkXkSpqBSXluMrH18f75MzRp/go6ZSYuYhvMqftIHYFc/hcn08nIqyEHYA0FNv0y7FLDWk9c/KoAqTCjS65O82x8yyeMM1rXRd/UQWuaLgB0ImdrcKyl1HsbD5wbPGEbTwTirWFoGk7NAUfBU4rnrAoiIoAmT526twwQxWiYhfJr5G+BybHTvW2NccquHKEKOhn6kP2AwIozHNvXm/NeR6ZVaqTrZD1dRcLxRYljlKOq4RdBrq134saFPsoZJRs+Sh8phDges//e/4r2deSj08Vu5lHk2bejGchVOhrvNHyyjnrIsnvNr8yBaoAKaLmIl7qZFY3e5fCN2Iodi7iaE7XdTMvGm4A/EOxXI5d05Kjpq5zTlHzDcXabG2owqoQWQh8FyH65vEnQ7GjqQIU2XuQ51RvZc+h/WspKsbvRdZRwyElIKAQyuWSthbN92hwb64lxQu/7Ce4uQl1hWLNNcpFTE0FzbWW7rO4X/u9qI+dT2iVjvFZ283P3LUO0O+sMLELit3kY9u2bTj//POx1157obe3F0cddRTuvPPO9O9xHOPCCy/EsmXL0Nvbi+OOOw4PPPDANM64OGgo1kuxIwpN0arYMaG7gAl1Yfrm2JmKnWtXV7TKNeeu7qHqzPUsnlAGmqOFiyfyPnZs6JYJxUoecMlj6vv1zZlLHtNCsRYF0elj55ljZyOz6TndIG3RpFDsdih2S+b2eI8NCOBAiZZPGzuT2LnSSMyWVLbCOCBfte0iUkUVwaKGybsOdGsbda+q1YI5dvR+5JNSYa5ru823rwN0M+mXY1eMaHYaOp7Yvfvd78YNN9yAb33rW7jvvvtw8skn48QTT8QzzzwDALjkkktw6aWX4oorrsCdd96JpUuX4qSTTsK2bdscR+4c0FCsV45dNbuRp1WxlouHKnbj3oqdCsUmZMeV95BX7IqFYl2L3UhDP75rPFBcsaM5dkWLJ2yGwGxvWa/iBqrAyQSbaylmI5qij50QipVaimXkNH9uqO+fWqSoLiOmYmCeW0V6uB66xzx85vUH4xvveIn3cwICKOg1ssBDsTPh9L0zz3fX+FpZI0NFQ7EuxS5HNB3jS6US9ljQl/7uo3jpxRPF7E58FDL6GX71rUc4yWatYHEGnUIonphkjI6O4gc/+AEuueQSHHvssdh///1x4YUXYp999sFXvvIVxHGML37xi/j4xz+OM888E4cccgiuvvpqjIyM4Dvf+c50T98bRatia0zxhG9VrGRCKz0n9XZynNy54olJVuyO2m9RofHAREKxfsUHZfJ5KtiqjdUx4phR4DjD4Wo+VGojgnznjEg8fjVVfIv52OWKJzwqdWl4O82xMxbWlkEwi66jb3/F3nj1QUuKPSkgoA26Fvo0iD98rwXa7y5iZBIh19pVKpW0jbHLx66oYpcnmm4aQMmlj10IXQd9iGDR4gm6safrvAS6mfTZN1LFzmc+nYaOnnGz2USr1UJPjy6z9vb2YuXKlXjiiSewfv16nHzyyenfuru78apXvQq33Xbbjp7uhNFFwlZNS96SOb7Rijxz7JLxSY5dm9g5djimYudavPbfdY72u6stTNGcucVzunHte16ejfe4OmnS7ysMYkjRy4RiW7ZQpk2xY962OgSXM+db5WoL3XLES/3oa0XSJJuEXPEEyen0tWyhKrRCPS2e0I8/PK5vCoqEYgMCthc0r86HtLx4+Xx8+oyD099dClNR3zhAV5WKOwy4FMFiih2gfy5+OWrZz16KHSV2HvMpqvBRBdSvo032c1DsJhkDAwN4xStegc9+9rNYu3YtWq0WrrnmGtx+++1Yt24d1q9fDwBYskTfrS9ZsiT9G4fx8XFs3bpV+zed0Kti3TltNXKjTftvWsar/LItI41UlXIRr5xi57g4/+msw7TfJ9tUE9BVQFdeCwDst8sc/O1rD8JX/uxwHLK77IvGhWKtdieW0Kqt8wRnd8IRrxqjqNnGq/OHKo42I+ouJseOkkJz4aeLLh1nszvhCi7q6bmkjx9tmMQud7iAgCmDb09pikP3yNYTp2I3gVQDuo645pTLPy5I7HyIEVXxfXLUivrY0fuLz72AFpR4EWVyv/BZXkKO3RTjW9/6FuI4xu67747u7m586UtfwjnnnIMKcbM2L5Q4jq0Xz8UXX4x58+al/5YvXz5l8/dBWhXbbGGorV7YiBG9CHwUtd3mJYrnaKOFdYNjADwUu4pO7Fwn9x4L+vCCJZlq5w7FGr/7EDvymfhWKr3n2P1w6qG7WcdQg2IVLrX1Zs1afmWP2YggZ3eS5eTl58NVudoUu8yw2q/4I+1NTEKgtMjBvJHQ36kCZzMoZnPs0lCsfm4ox3+FIjl2AQHbC1ow4duaiq5vboPf4rfZ54fGvccWtY4y03B87EvoGuAVit0uuxP3+H5iCeNTbFHUCqmo4thp6PgZ77fffrj55psxNDSE1atX44477kCj0cA+++yDpUuXAkBOnduwYUNOxaO44IILMDg4mP5bvXr1lL4HF2hV7NZ2mxqbSSa9sJTaYbuYe2qVNCz52HNDyTGcxQ06WSjqLdTryAsxLxafXRolo5O5i6LvTREor+IJlqhxCl97DBO65RQ+rhgiI2pMoUL7c2lGcRpetSl8XFXsOFHTzPdMF2au8tam2FGymSp2ho/dS/deqP0+AzfIATMY8yeg2NGNtyt6UMQ8dyIo2ivWVOxchszma/i8HzqFqSieKKrYSXOTUA2K3Y5Bf38/dtttN2zevBk/+9nP8PrXvz4ldzfccEM6rl6v4+abb8ZRR8m9Jru7uzF37lzt33SC9opVxM6WEMopdq4Ezz0W9ALIiJ2reCLrPOGn2NHnAO5doKlI+oRWe7rIxTaJqg797BQhshZPkN675vM4IsXZnaifbaFYf8Uu+yzV92WzwakxOXZpOzFGsSiVSmwen82gOPNm5BQ7/bs+7sBdtPOx5BUsCQiYHNAcOx91CdCjB66nTETx+cvj9wMAfPYNhzjH5hU7++uZ0RqbFZQCfQUfVZNuYn06T1Cxwude0z+B6E16/IKhcFfhYCfC/Y1OM372s58hjmMceOCBePTRR/HhD38YBx54IN75zneiVCrh/PPPx0UXXYQDDjgABxxwAC666CL09fXhnHPOme6pe4PmI20dayt2FmJXKSemmlGc2Yy4LoYlA0k4ds2mUQD+diTjnsTRnIMrx85MCPZS7MicW5PoTEtfu9GK0FOrWIsn+F6x7b+xhsa2nLz8fGqpgXBSrFAul6yhXroojjVa6O+uWjtPqIW/EeUVOynMUiuXUIdOBlPTZGZh5YonVC9Oc8dfKpVwwp8swU9/vy6Z84zZbgbMBtBNtCv3WIEqRo2WfS3qmoDB7QdOOhB/umJ37LfLHOfYotZRdBPV31XxIlJ0GfFR7KhjQNEcOx8i3NddXLE78/Ddce/qLTj+oF2dY+ma5iM6dBo6ntgNDg7iggsuwJo1a7Bw4UK88Y1vxOc+9znUasnF+JGPfASjo6N473vfi82bN+PII4/Ez3/+cwwMDEzzzP2R5dhFiDwUOyC5uMYakVcoFsj6GyrFxZUnoQiKr92JOQe3YlesLQ+g7zQbhqfa9oAuJCo8ac2ZY4onfAyNYy50yylq5LtpRBG6y3aiWS4nilq9GWHMUOy4NTIjjtlnKLUT0+ZUb7Eqok2xo6FYWyEOJcQhxy5gR4Juor0VO7K+mR1cTOzejpYUQaVcwv67+t3Dipq30w2yj1oH6Cq6z1pNoxk+OXBFq2KpYufbI/rSs17szL9XoGvaTOw80fHE7qyzzsJZZ50l/r1UKuHCCy/EhRdeuOMmNclIe3e2IozWkwvCRexqlYTYjXkqdv1G/0GnYtc+mbPijGKKXY9DsTMVPZ+Lme78XItpEVTKJZRKSVsaVVBgK56wthRjQ7HJ/1oo1kKK6M2l0YrRXbWHVoHEm6rejNLvq2jniazrBP+90UpsBduceMXOQuzIMYLdScCOxByyNrpyjxXo+Woad5t44+F74KM/uG9ikys4F+53E1SVtPl7TtacfAoXihZPaDl2BYiX76aRrmnB7iRgQkh9xaIYg6p4otd+wambvwrFuk4+M/RpmlTm5mT42PnI6XRn0+dYIM35+IUDyGLqCH8URUauY8RxnJKwySieKHE5eSrHjhlPFzalTNoqUIGMqKvvy2a/klbF0hy7hl3J5btbyOSxh1R6p+9F8LEz5zkD19GAGYx+Qm66J5AP5yJ21UoZF/3poYWP64uixI5u6l0b/InCpyCDgm5mvXLsCBmfCuJF19mZWDzR8YrdzoC0M0QrznLsHBeGujmOeipqpnu5s7H0BIon9KpYB7GbgEkmRXMSFTsgIaX1VvIdUAJmDcWyil3+2PQYKhQQO3L4Ku28ukZa5Wr3K+wxumfY1DR17jS1HDtHKJYJ3/oYFFNvPXUD5HKO6P00KHYBOxJ0bZxIBauL2AHAm47YA7c8/ByOPmBx4eO7kCN2rlAsSWnxLewoekn69NylqGmKnfvF6P1lKpaLma7YBWLXAVAXVyuKU2XGdcGpv/vm2Jmhz36HBG9WxfosAFqO3RSEYikmMxQLZItjI4q03Dm7YpcRNZshMD1EK4pRrWTFENKiVGuPSatcLUQQIAqZqdhxxI6cb/VmhK5qWWwnppC2IWvmVUpfg2LfUGzgdQE7EppiNwFi59OGrKtaxlffdkThY/vAtCJxzYcSJ9/3W/Sa9GnzRUGVUp8WZ1ohXTS50RtA/0xnYkuxQOw6ABqpsKggFOriVN0SXHkGJpHr63bk2JE2ZIAf8aJzdhVP5EOxxS6eSQ/Fkrwzp2JHHjOJmq23LJDl2dmIoJrPWCMiip0jx04pdm0iZTv+/L4aemsVjDZaeGbLKPZZ3J8pdkJVIGvB0v6Z74aRFQQp1IWqWCDk2AVMH2hYr4hid9n/OQy/eGgDzn7ZnlMxLW/Qa3zPhX3OnDaa0vKSvRd4vUZRC6J5BRU7vVes+7UGuqs48U92xWijhaVze5zji6ISFLuA7YUiaa0ottpU6M/ZTsWuYGNpnwRV+hyX3YlZfVb04pn0UKwKh0eRFqJ0EbVWHKMKPx87IFO5lCgoEfjuahnbkBUrOHPsjNCnrUq3VCphz4V9+OOz2/DUxuGE2DXsil1XJft8FOqCLx19XbqZztrf2atiZ+A6GjCDQddC384TAPCnK/bAn67YYyqmVAh0TdhzYZ/Xc844bBkeWDuI9xy7n9+LFLwm91vstmmh0KtifQyQS/i3c19abFIFQO9HIccuYEJQahVtsu6sbFI5dp5VsWZOnYt4mVL6/N4uYWSGcgHFzqxOKnrxHL6X307TF1SxozkzLGmhRC1S/1takDHELgvFyoodkJGhliXsCeTtRRTvlYjgnosSYvf0phEAtCrWrtipUGwcx9bnKDIbe1rClINiFzBNoNEMn/yuTgNdE/bf1Y9QfektK7ytPyaCMw/fHfeu2YIj913kNV7rFdsB34He6zaEYgMmAOUR1yL5Xb5u5t4+dgaRc5W5L5qjE7l3Hr23fULQDXtddicmfIndTR86Dnc+uQlvPHxyd8pVokhluWAlduGrGIod/Z9XyLKf1UcUOb7nlEgZoVgpZJ0rnnAQQdU/+LltSU9KV/FE1SieaLTiVHXkKuvUe6aVw7ZzO/jYBUwXaCh2KvK1phpU7XrzEf7rYpHr7MV7zE8NxH1QrZTxuQKVwFpv1g4wBNYNimfeehSIXQeAVsVGDiVHQd34s84T9ouhr2CO3cL+jNj1d1W8yuJp/pVPY+mj9luE2x7bCMD/4tlncT/2WdzvNbYIMguQmFRv8p8p3c2pG4F667YWZHS8zccOyJQDNZe0AtVSbJGM06to5ePrlbGuUKypINKiCI4MWtuuOchy4HUBOxKa2fAMJHa1Shn//q6XoRXHOGDJ1Bjzn3vU3ogR45j9d5mS49P7XecpdtM/n6KYfmockBnGRsQ/zXF36zJCsU4fu1qxHLvFc7rTn31NO2lBg498/YU3H5b+PN0JqjQUmyp2gnpFSYgiaDZDYNPuBIAzlzIXim1/thXhc60SHz7ATjST8WozoYhaMR87amPim2PnH4plpxAQMCWgpGJhnzvlpBNx7At2wfEHultlTRRd1TLec+x+eOGyqemrTtfBTlDI9By7mUeTgmLXAaA3Wf+qWD2nyreKVsGlqFHFzmVmrFAnKo4P6HGnO/xGK5PHnYpd9nPLyJnjiJppdwLAaoAMZASr3vQLrarHWx5Ekz6uFLu6xTwYyHeeoKFb7rtTLxszoVhWsdOKJ6Z/YQ/YufDVtx6OpzeN4NA95k33VHZK0GWqE3La6EZzukWHiSAQuw4A7TyR3vwcJ1NXNfm7b+cJesPu76o4j7+IEDtfCwBXM2wTU+1FVARVTbGzewmWSiWUSwk5M0OrUhWqalmW5tilRNAxn0gnji6iZrZEk0iS2VZM/S8dX6mXDU+FT5E9+rVaw9WheCJgGvGaQ3ab7ins1OhsxW7651MU00+NA9IwWiuKrdWVFF1m8YRjl0PVJ5d5MAAMkM4XvpzLx4GdghI7aqMxHagR1bTuIC1APlTadHxv5ZTo6IqaRLArhgLnOr7aHLRaJhHk5181FLt0PlIOX5qD2CZ27VCslHvJ5dhZw9Va8QQ/h4CAgNmJTrvm6XxUodlMQiB2HQBacdhy3GAVTDWpiGLn5+ydjfH1jCvaDYLe4IuqfZMNqpraOiQodBmhUlsfVCAjLpndSfK4pE6p8U1DEZQSi9Mcu5zCZ69yVUUWtl63QD4UO+YwNFYfnRaKtRZPZD8HxS4gYOfCQUunJndvonhq40j68767FPPk6wSEUGwHgKon6j7oCpWaif2+OXmA3+6I5k01PSW7ooodxWS3CCuKrEo0U+xsIWhlIFxvRYiiOP2MpOdk9h/qf08FLlKKoL3K1VT4XJ0tsrxOI0dQDMXqVbquKlouFBuKJwICAjgs7O/Cyo8e7+xhvqNwwK5ZdfFMDMV2xqe4k6NqhPUA/1BseowCil1RRcSb2G0HOZvsThJFodmdEB87Cerzrzcj7X1LxC4NxZqhT1dxQ0spdvrj4vyVAucIxVYMhc9XsVME0+V7Z4aeATvZDMUTAQE7N/ZY4Nc1Y0fgNYcsxRf/z4tx+J4LpnsqE0Igdh0ASioU3MUThmLn8NrZnsoeXzVte1S3Xaeg318R0GICH8WOhmIpsZPIYGb/YVbRCvMxxzvsUSpCjp2owOV87+zju3JVsa4cO2jH1V+Dmb/mYxeIXUBAwPShUi7hDSt2n+5pTBiB2HUAXN5nHEwC4SJupe1ITvetWJ1IKPab73gp7lm9BSf9yZLCz51M0F6xPjl2NarYOVqQAdlnnrMjcYRWfatia2aOne/xfX3vDMNkZbPjUuxiGoq1FE+UNcWOPWRAQEBAgAdC8UQHgGuhUrR4ooiJYlFi1/QsbFA7nMP3nO997OMP2hUfOOkFToVyqlElipRPVWyq2LXcLciAvGGvCq1K75tWSgNZEYIcWtVz7Fw9h00i6F884Wd3woZibf10g91JQEBAwKQgKHYdAC6M6rq5mWHCIqHWEorm2PkpcR99zUE4Yq8FeOUUtZ2ZSlC7k0Yr+dm3KtbVggzIEx1naNVU1GJ7qzmqOAJZayTpvJAUQTl0q1cBZ8TOHopV7zeOs64q3GuUtVAse8iAgICAAA8EYtcB4G6+rlCsSSKKVO4UvXH6+tj11Co47UXLih28Q0DtTsZ9cuwqecXONt4kOpFDgTM7SaShUkeOXUoEW8oexc/uJAvd8vPpJgolAIw37HYnZVOhJOeQq3gi5NgFBAQETBwhFNsBYImd4+ZW1MeOwnfkC3dLvIWOP3DmKXBFQSuTXZ0nAF2xU0TQNj6rikX7f0/FrmBoNTM0Tl5IbkGmF0PEjipd1S9YKXbNVBG0t10zi0Wk19B97NhDBgQEBAR4ICh2HQCXrxeHXFVsgbuhbw7TN9/5Ulx3zzM46yXLvY89U1EjCpmvjx1ghGKtip0ZitUfNyEpar5EsOFQ7HK+dw6i2d0+jiKxTYcljNRpg742N942h4CAgIAANwKx6wCUSiVUy6X0puzD0XKKncPuRH9Bv2FL5vbg/75qP//jzmDQ4ok4dufM6cUTsXN8ToFzdBiRxruqVk37Eol4pXYnLTVef10TKuSq/OuaDgXRVCipYucunmAPGRAQEBDggRCK7RBQYuajvpk37EJVsf7T2mlQJUSn7pEzx9md+Cp8gDu0albFRg7SbxZbqLw/6fgicZQUu/b8VceJpiNcndmd6MUfQPCxCwgICJhKBMWuQ5DcyO1toyhMm4lCOXbhxpkDbesGh9oF6MUT9VaiYvkaGgPuzhPqHDB96cSq1VyOnT0HThGyXChWUuza1a+K9DYcOXypb1+sE1Mg2J0EBAQETCUCsesQFFfs9Bt2j1CdyCHcNvPIigkiKArSVeGtPADT7qRAsUWbBKrQpzvHzmgp5pljlxE7+3il7LmqdLsMxU5V3UodT0zfPi0U6ygWCqHYgICAgIkjELsOAb0BuypigXwrp10H/FtyBUEkjxqxC1EkRzW+58C1FLPm5FV4xc6/M0SxHDuVOyflXtYM4ugsnqjyOXacuTY9jhmKLZV4xbgcFLuAgICASUEgdh0CSgp8ujAM9Ohf3W7zChC7oNnlkBZPRFFKcryKJ5oRGsruxCMUO24QO4nDmL1io6KGxpFdRawYdicu4qhCsWr+DQdxzOxO2v+7FMftaHkXEBAQEJAhFE90CPZY0Jf+7BOKGuippT93VcpY2N/lfM5xbT+6dx69d+H5zXZUCTHyMRzu1nLs3Ipdt0HsXEQqC62aOXnS/PWcOVfxhGmA7CyeqOmKo6t4QqlyLc8cwZBjFxAQEDA5CIpdh2C/Xefgjic3AfDLsaOK3S4D3V4FEV972xF4dMNQajwckKFWyUKNRRW7Qr1l22NVkagv8bL1WaXjzRw7qQDEDN0qZU06j0xi6rI7qZiKo2P+eiiWHRIQEBAQ4IFA7DoE++86J/3ZR7GgxG5Ot9/X2F2t4OBl84pPbieAIjo/e+DZ9DFbMQT1vWs4zHoBoKuqd25QRE0iUipUaoZWRcUrl2Nnr4o1iaBLQezK5djZq2LVw4rAuo5PP7tQtR0QEBAwcYRQbIdgQV8WWvVR7Gjz9f5uuXozwA8cQbGFYqskVJqpV369ZQHam9U3VAqv8YrQKeLl9Mlr+fWuVedboxUjimJvH7vIKJ6QTm1aDBQUu4CAgICJIxC7DgElEUVzjPo9FbsAGZyyZVPs1N+arZioUfLxTbuQ2EGkCneeMH3sHMQrtTsxOlW4qmKBhJy6iGPqY+fZ67aHbFSCYhcQEBAwcQRi1yHQq2KLPbevKyh22wuuutOWM6fGN1oRIWkyIenO+djZQ7Gmj1023j4f06DYZY+Sy+ETq2Kzz2K8ERHiaDdYTkOxjs+I+jCG4omAgICAiSMQuw4BVex8fOwoaH5ewMTAKVtWxU7lwEVxajZsU5pyLcUcoVWpKtZVrNAwfOzE4glidxLHsbMqtloppyHSsWYLDUdnC7N4wqkIhlBsQEBAwKQgELsOAc2Z8/GxA4CvvvUInH7YMrz3uP2nalo7DQrn2BHFzpUvR4+liN3zQ+MAbPYlE6uKbbV0xa4qkFP6fqPYXZwBZES30YqcBshqmllVbPK7HIoNS1FAQEDAZCAkZ3UIJqLYveaQpXjNIUunako7FXjFzo/kuPLHAL144t7VW7Bm8ygAWcGivWITRa39uCPHzrelGCVkzSjKFEQHsRtvJmFYVy/arHgiySdsOQyWafGEqjIOCAgICCiOsE3uENAcJp+q2IDJBac82RQ72oLMRVroscYbEa667cn0cZ8cOJWnBthCpXR8VtAhEjtCyGgBiO090IIOl2JHjxPHBXP4moHYBQQEBEwUgdh1CCiJCFWBOx4c4bAZFKc5alFM2n3Jx0+JXSvCUtL+TW4RRqpuCbNztRRrtDL7FcASitUUO7/3QPvLugyQKQGNaA6fSGT1qtuAgICAgIkhELsOASURNtuMgKkBF4r1ybFreoZiu4lB8dK5GbEbHG3wx1c5c0R9A/xy8lTFKn3cBCVevu9BI48tu3dfiTys5fB57Fkazdg9KCAgICCARUdTiGazib/7u7/DPvvsg97eXuy77774zGc+gyjKdvRxHOPCCy/EsmXL0Nvbi+OOOw4PPPDANM56YuiuFc+xC5g8cATI38cuecxWeNDblYwfrbc08jRab7HjK4SoRUSxcylezShOK2OTx+UWXupQrcgvnEy98lS1bk3sPGEodh7EUUFZwgQEBAQEFEdHE7t/+Id/wFe/+lVcccUVeOihh3DJJZfgC1/4Ai6//PJ0zCWXXIJLL70UV1xxBe68804sXboUJ510ErZt2zaNMy8OqtiFUOyOR2HFjqhXLqsQAJjf2wUA2DJa1xS4171oN+vxm1GMRssdiqWKXUtT7DzaohHLFhvxov1l05ZlYueJ7OfIo3iCoh5y7AICAgImjI4mdr/5zW/w+te/Hq973euw9957401vehNOPvlk3HXXXQASte6LX/wiPv7xj+PMM8/EIYccgquvvhojIyP4zne+M82zLwZKIuiNP2DHgFO2vHrFRhmxsyl289ot47aMNNL8tDMOW6ZVg1KkhQqtCO+++s7c4+J4otiVSg6iRixSXDlw+pyy15DG64qdu3iCIhRPBAQEBEwcHU3sjjnmGPziF7/Aww8/DAC49957sXLlSrz2ta8FADzxxBNYv349Tj755PQ53d3deNWrXoXbbrtNPO74+Di2bt2q/ZtuUGIX7B52PDhly1Y8oVXFeuSPze9NiN3gSCMNS0r5b8nxs1DvnU9uTh93KXZA1ras5mhhQvvd+lTFaqbMnp0nAL14wkexC+d/QEBAwMTR0T52H/3oRzE4OIiDDjoIlUoFrVYLn/vc5/CWt7wFALB+/XoAwJIlS7TnLVmyBE899ZR43Isvvhif/vSnp27iEwAlEUGx2/HgCIqtpVjmY+fu2gAA8/uSUOy28SbGGkkOmdX3Lm1BppMc6Sk0JDredB+fPqcZ+eXA6aqgy8cu+zmO4JWHqLDHgj7nmICAgIAAHh2t2H3ve9/DNddcg+985zv43e9+h6uvvhr/+I//iKuvvlobZ+akxXFszVO74IILMDg4mP5bvXr1lMy/COh8A7Hb8ShBP1+6KmVHFwZG7bKMn9uT7aE2jdQByIUNyfH1ThXpPD0Uu7GG3WPOfA61VLGR0xqpBC7iY0cre21T+t57Xo4/f+U+OO+YfazzDggICAiQ0dGK3Yc//GF87GMfw9lnnw0AOPTQQ/HUU0/h4osvxrnnnoulS5OuC+vXr8duu2VJ6Bs2bMipeBTd3d3o7u6e2slvB5qB2O1wUK84QK9S5lAlPnM+XRuqlTLm9lSxdayJjUN153jaqcIH9FjD400AdsUREEKxlqdoBsWOcDIluT4+dgBw5L6LcOS+i6xzDggICAiwo6MVu5GREZSNO02lUkntTvbZZx8sXboUN9xwQ/r3er2Om2++GUcdddQOnetkIkYgdjsavUYRg1TUoEB7xUaeHm0DPUme3Wal2FlYlArF+uabUYI10rZQof2HOVQqGVFTvNZqd1Ihdidpjp38HtSUotivs0VAQEBAwPajoxW7008/HZ/73Oew55574uCDD8Y999yDSy+9FO9617sAJGGp888/HxdddBEOOOAAHHDAAbjooovQ19eHc845Z5pnP3GceghvgREwdVg6rwcv2mMefr9mEADQ41DsaK9YXysPRQZV1aeXYudZIVoqlVApl9CKYgzX/RS7GvGla3koatTiRfnY2cK95VIJUZyQRvWeXYQ5ICAgIGD70NHE7vLLL8cnPvEJvPe978WGDRuwbNky/MVf/AU++clPpmM+8pGPYHR0FO9973uxefNmHHnkkfj5z3+OgYGBaZz5xHDpWYfhnqe34AMnvWC6p7JT4j3H7ou/+s49ANxqlyI5UQzShcFO7NTfFcmxVcUWVezU8VtRnCp2Nh8+Op9Gy68qVlPsPIotkmMlat1ou2CkrysQu4CAgICpREcTu4GBAXzxi1/EF7/4RXFMqVTChRdeiAsvvHCHzWuqcObhe+DMw/eY7mnstKBEy6XY6VWobgUOyAoT6h7ja2mo1z8sXy2XUAcw4ptjRyp70zl6KHb1ZpSGbm2WKiUSih1rk00z5B0QEBAQMLno6By7gIAdCapW9TgUO2qPouxFXB1DMsXO3+6kCNTxhj1z7ChRS49hbSmW/E2pb4A9FKvmE8dZ3l9PUOwCAgICphSB2AUEtFHRFDsXscsunVSB8yR2fopd8UtTPWeknWPnG4pVRBOwV8UqEqfsVAB7AYgiylGchWKDYhcQEBAwtQjELiCgDWrR4WsVAtBQrP34pkJmzbGbALFLFbtxpdi5CkAYxc5qUJwcb8xTsVM8txXF6XMCsQsICAiYWgRiFxDQRrWAYlcqldLxirS4qmIVcVTedBWb2lUuWYkfhzRUqkKxjjzBChNatSmFNfV+icJnm2Om2GVz6g2h2ICAgIApRSB2AQFt0FCqixQBmVqlFC+n3YkKfTbcih1QPM9OEbUhFYp1qH5p6HZc5Qja56SOrwohKuWSNa8wy7HLQrHB7iQgICBgahGIXUBAG+UCih2QVYRuHHZ3kgAy4pcpdvbxRfPsMqKmqmIdBsVpsUVWRWsjaqqK1seuBaAGxQh2JwEBAQE7CIHYBQS0US2QYwdkit3gaAOAu8G9Gq8841y9XCeq2I14hmJV4YNvpwoz9OwiniVaPBHsTgICAgJ2CAKxCwhoo6hiVzWIjasq1gzVuhS7ogUUVYPYuZ6vxg+N+1XRKiKq1De3Qpn8Tw2KQyg2ICAgYGoRiF1AQBuUmPX5ELuySdSKjZ+qHLs0tOoqnmgTNW9D41SxS0KxNYfiqD7POBRPBAQEBOwwBGIXENAGVaB8CIhJa3wNihVcxRam4nbZ/znMOj5V7Mb9Qqs1U+Hz7FShQrE2DztAD8WqStqeCRgvBwQEBAT4I6yyAQFtUOLV1+Xutmc2+/I1KFZw5djVqvrfX7x8gXW8Il7D3gbF+njvHDtVPOGZIzjejNJ+umb4OiAgICBgchFW2YCANijx6u92K3axweycvWJzoVv75Wcqdi5bu9SXzjPHToVSfQ2NTbsTVyh5bk9CjreNNdBs+YVvAwICAgK2D4HYBQS0QUOjPtWbsaHZuapiTSLnIkamaujrk9dsV906c+DSUKyfwqeqYFVY1aW+DfTUAABbxxpoqEpgB5kNCAgICNg+hFU2IKCNatFQrKHYORU14+8uhc/M8yuqCLqIlyJqhRW7hqdi16sUu2ZQ7AICAgJ2EAKxCwhoo2jxRPEcu2KKXb8xB5diZ/rKOe1U2kRuyNPQ2KyKdeXYzVWK3Wgj5NgFBAQE7CCEVTYgoI3ydubYuUOx5u8uxc4IxTquVvN4LnVM5eBtHUsMln3tTkY9q2IH2jl2W8eaaXi4aP/bgICAgIBiCMQuIKANLRRbc4diTbhDpaZiZ7/8zPZbvjl2vsdXRE4RVCexaxNB1RvXRRw1xS7yU/kCAgICArYPgdgFBLRBedNEjHRdYlTe0LhYKNYV6jWJmUsdMw2M3S3Iis1/bi8pnmiF4omAgICAHYGwygYEtKHIBwD0OEhOAqMqtqCPXeFQrOP4ZrsuVz6baYfibEFm/N3VK3ZOdzJ/1Us3eU5Q7AIC/n97dx8VVZ3/Afx9ZxgRFBCRB0FRNESTDCXLfDZ/UmrmqquWZLLUmqlrbrWetXY3zULzlFtKuXpq0VITj5sdj9T6WD7kFqRbbEhtPgWl6IryoMjjfH5/2FyZQZ0ZufN0fb/O4QR37gzfed/p64fvvd/vJXIl5883EelUVHBLdAoLhMloUIuSG2nuOnYJUUE33N/2Oj97g13Oj9hZv77dO084eUs00y+vZ1lXD+DkCSIiV2NhR/QLo0HBrmeGwKAodm8PBjSdFevMiN3E5A4I+eVU5fXYrqVn7/VtCzV717PZFoL271Th5HIq6mQL89XncPIEEZFLsbAjasTe6cXGRG7+VKxl8d4bMdu8vr0RQdv7sNq7ns22kLN3Jwzb06h2R+xs7i3ryHOIiKh5eF6E6CY1WcfO3qlYpXFhZ/9vqqpGpzABV4zYWe9vcnZWr91r8qzvbHHlNVjYERG5Egs7opvU9Bq7G+9vPWJnv7Ab1zvG6md7NZHT19jZ7u9goWZhrxC0TMawXGNnMjp2ipuIiG4eCzuim2R7KtayCO/1NC7sHJmc0SawBQbcFnbN519LkxE7J0/F2pux6uxyJ5ZC0dEFjYmIqPnY0xJpxPbUqS2rws6BETvA+vSrvdGupiNw2q57Z1uYOTrCd3UNO47WERG5Ggs7optkOz4XEeR/w/2dHbGzfY49toWa3VuKNfdUrIO3LLve84mISHss7Ig08F763egQGnjDffycvMYOsH+3icZsFyi2N8u1yeQJzU/FOrc8ChERNR97WqKbFNxoyZLB3cLt7t/4tGpYqxuP7lk0Z8TO6ckTdgpB28ftLQ1j+7i9yRZERNR8LOyIbtKqqclIiAzCu9Pucmj/mvqrC/W2s3Pa1sK5wq55CxTb27/JAsX21rFz8po8IiJqPi5QTHSTEmNCsP33gx3e/0JVrfp9qxbGG+x5lcGJwk5srvqzNwLXpBB0doFieyN2fs4VgkRE1Hz8E5rITc5fulrYObqemzPX2F22mZVr75q5li1cO2LXdBYtCzsiIldjYUfkJmVVdU4/x5lTsf27tnPquS2MBqt97BWCttfM2SvUmt6CjN0NEZGrsaclcpO5/xcPk1HB9MFdHH6OM4VdQAsj/jS6h/qzvckNiqIgoNFMWnuFl21bbK+hs9Vk8gRH7IiIXI7X2BG5SWJMCP6z4P4my5LciDOnYgHrCRGOFIUtTUZcrLlyL1d7I3C2j3O5EyIi78OelsiNnCnqAOcmTwDWxZMjkxUCG03isDfC13S5EydnxXLyBBGRy7GwI/Jizg5yNS7OHJmgYX0qVtsRONui1F7hSEREzceelsiLOTvhwNnr2AKcGrFz7lSsLdt184iISHvsaYm8mMHJa+ycLQStRuycXO7E2SLS38TuhojI1by+p+3cuTMURWnyNWvWLACAiGDBggWIjo5GQEAAhg4dioKCAg+3mkgbzl6WdltEa6f2bzxi5/SdJJwsIm0XRCYiIu15fWGXl5eH06dPq187d+4EAEycOBEAsHTpUixbtgyZmZnIy8tDVFQURowYgcrKSk82m0gTRidHxRKigrB6ajK2zh7g0P7WhZ39a+YaDyA6PWLHU7FERC7n9T1teHg4oqKi1K9t27aha9euGDJkCEQEb7zxBl544QWMHz8eiYmJWLt2LaqqqrBhwwZPN52o2Zxd7gQAUnpGoVeHNg7t68ypWMB61M7o9PV/Xt/dEBH5PJ/qaWtra7Fu3Tqkp6dDURScOHECJSUlSElJUffx9/fHkCFDcPDgweu+Tk1NDSoqKqy+iLzR4G7hAJyfqOCoxoWdI4VX65ZXl750pBBs7X91f1e9ByIiusqnCruPPvoIZWVlSEtLAwCUlJQAACIjI632i4yMVB+7lsWLFyMkJET96tixo8vaTNQc/bqEYfOMe/HF/OEuef2w1i3U7x1ZZy66TUv1e3t3ngCAvX8Yqn7v7EQQIiJynk8Vdu+++y5GjhyJ6Ohoq+2263WJyA3X8Jo/fz7Ky8vVr+LiYpe0l0gLd3Vui/Agf5e8duewVur3jtwZon1IgPq9IyNwwQEm9XsO2BERuZ7P3FLsxx9/xK5du/Dhhx+q26KiogBcGblr3769uv3s2bNNRvEa8/f3h7+/a/6hJPIlncIC1e8dmQwRHdJoxM6B/RuPAvJULBGR6/nMiF1WVhYiIiIwevRodVtcXByioqLUmbLAlevw9u7di/79+3uimUQ+5fboYPj7GRDTJgAtHViOJLrN1RE7R0b4Go+cO3t7NCIicp5PjNiZzWZkZWVh2rRp8PO72mRFUTB37lxkZGQgPj4e8fHxyMjIQGBgIKZMmeLBFhP5Bn8/I/79lxEQcazwat+4sHOyUGNdR0Tkej5R2O3atQtFRUVIT09v8ti8efNw+fJlzJw5ExcuXMA999yDHTt2ICgoyAMtJfI9gS0c7wZiGk2ecGRWbGM3s3QLERE5xycKu5SUFIjINR9TFAULFizAggUL3NsooluQ1eQJJws1noolInI9n7nGjog8L6LR7NyaerNTz+VyJ0RErucTI3ZE5B38jAbMGtYVJ89V4fb2wU49lwN2RESux8KOiJzyh/u739Tzbo92rhAkIiLnsbAjIpfa9ruBOHKqAsMSIjzdFCIi3WNhR0QulRgTgsSYEE83g4jolsDJE0REREQ6wcKOiIiISCdY2BERERHpBAs7IiIiIp1gYUdERESkEyzsiIiIiHSChR0RERGRTrCwIyIiItIJFnZEREREOsHCjoiIiEgnWNgRERER6QQLOyIiIiKdYGFHREREpBN+nm6ANxARAEBFRYWHW0JERERkzVKfWOqVG2FhB6CyshIA0LFjRw+3hIiIiOjaKisrERIScsN9FHGk/NM5s9mMU6dOISgoCIqiuOR3VFRUoGPHjiguLkZwcLBLfsethplqj5lqi3nqH4+x9phpUyKCyspKREdHw2C48VV0HLEDYDAY0KFDB7f8ruDgYH5QNcZMtcdMtcU89Y/HWHvM1Jq9kToLTp4gIiIi0gkWdkREREQ6wcLOTfz9/fHiiy/C39/f003RDWaqPWaqLeapfzzG2mOmzcPJE0REREQ6wRE7IiIiIp1gYUdERESkEyzsiIiIiHSChR0RERGRTrCwIyIiItIJFnbklS5evOjpJujO4cOH1fsiExF5Cvt312Jh10xnzpxBTk4OuGqMNk6fPo3U1FQ88sgjePzxx3H48GFPN8nnnTp1CikpKRg2bBi+/vprTzdHF0pKSvDSSy/h7bffxscff+zp5pALsG/XHvt392Bh1wyZmZmIjo7GmDFjUFBQ4Onm+Lx169YhMTERtbW1GDlyJPbs2YNXX30VJSUlnm6az5o3bx46deqEwMBAFBYWYtCgQZ5uks9btGgRbrvtNuTm5mLNmjUYN24cNmzYAAAsAnSCfbv22L+7kZDTzGaz5OTkyPDhw+W1116TPn36yK9//WtpaGjwdNN8Vn19vYwYMUJefvlldVt2drZERkZKWVmZB1vmm2pra2X27NmiKIps3LhR3X7mzBkPtsq31dfXy5IlS6Rfv36Sk5MjIiIVFRXyxz/+UWJjYz3cOtIC+3bXYP/uXhyxuwmKoiAyMhJTp07Fk08+ib/+9a/4xz/+ge3bt3u6aT4rPz8fx48fR3R0tLqtqqoKEyZMQHl5uQdb5ntEBCaTCYMGDcLgwYNx7tw5fPfddxg3bhwmTJiAIUOGYPXq1aitrfV0U32K0WhEbW0t7rvvPjzwwAMAgKCgIAwZMgR+fn44duyYh1tIzcW+3TXYv7sXbynmgIqKChw5cgQdO3ZETEzMNfeZPHkyfvjhB+zduxdBQUFubqFvuVaetbW1GDRoEEwmEx577DHs2rULmzdvRr9+/XDkyBGkpaXh+eefR0REhIdb751qa2vR0NCAgIAANDQ0wGg0or6+Hr///e+xefNm1NXV4dFHH0WXLl1QUFCAtWvXIiMjA0899RQCAgI83XyvdOnSJZw6dQqRkZEIDg4GAFy+fFnNS0SgKAo2bNiAV155hafsfBD7du2xf/cCnh0w9H4ZGRkSHBwsiYmJEhwcLG+88Yb89NNPInJleNkyRH/s2DEJCAiQ5cuXe7K5Xu9aeZ48eVJERPbv3y9vvvmmjBo1Svr06SN5eXlSXl4uWVlZcu+998qLL77o2cZ7qSVLlki3bt3kn//8p7qtvr5eRET+9a9/ybRp02Tr1q1Wz5kzZ47ceeed8p///MetbfUVL730ksTFxUlSUpLExcWpp14tGp+amz17tqSmporIlVPg5BvYt2uP/bt3YGF3Ax9//LH06NFDtmzZIsePH5dXXnlFevbsKenp6eo+ZrNZ/f5Pf/qTREZGSnFxsYiIXLp0SS5evOj2dnur6+X5m9/8xmq/4cOHS2ZmptW2lJQUmTFjBv/hbKS0tFRmzJghvXr1kuDgYBk/frz873//ExHrz2V+fr5UV1eLyNWCpKSkRBRFkS+//NL9DfdiJ0+elIceekh69uwpOTk5snv3bpk2bZq0b99eSkpKrPa1fBb79u0ry5Yts3qscf7kfdi3a4/9u/dgYXcDc+bMkd69e1ttW7FihSQkJMjq1atF5OrIiIjIxYsXpVOnTjJnzhx57733ZODAgbJp0ya3ttmbOZLn0aNHpVOnTpKXl6fuc+nSJenXr59kZGS4tb3e7vjx4zJv3jzJycmR/fv3i6Io8sEHH6jF27WKC8u2Dz74QCIiIuSbb75xa5u93caNG2Xw4MFSWFhotT04OLjJqKeISFFRkYSHh6ujEp988ok88sgjcuLECXc0l24S+3btsX/3Hpw8cR1msxl1dXVISEhATU2Nun3ChAkYOnQo3nrrLVy8eBFGoxFmsxkA0KpVK6SlpWHFihV44oknMGjQIEycONFTb8Gr2MszMzMTlZWV6Nq1K9q0aYPnnnsO69atw7///W9MnjwZlZWVGD16tAffgfeJjY3FrFmzMGrUKAwcOBATJ07E4sWLUVRUBODKheCNyS/XhH333XfIysrC2LFj0atXL0803evIL5cap6Sk4He/+x26d++uPnbmzBm0b98eLVu2bPK8ffv2oVevXjAajRg1ahTGjBmD6OhodO7c2V1NJyexb9ce+3cv4+nK0htZRjUWL14sHTt2bPLX99atW+Wuu+5S/woRufIX3axZs0RRFHn88cflwoULbmyxd3M0z5UrV4qISGFhoSQnJ0tCQoJ06dJFJk2aJOfPn3d3s32GJd/S0lIxmUyyePFi9dSrxaVLl2ThwoWSlpYmgYGBkpqaKhUVFZ5orteyHeG0jHweOXJEwsLC5L///W+TfR977DFRFEVMJpOMHj1azp07574Gk9PYt2uP/bv34YjdNVj+Sps7dy7Ky8uxfv16q8eHDh0Kg8GA0tJSddu5c+cQFBSE/fv345133kGbNm3c2WSv5mieZWVlEBF0794de/bsQU5ODnbv3o3s7GyEhoZ6ouleSxpNZlcUBfX19Wjbti1eeOEFLFu2DIWFhVb7BgYGIjQ0FBcvXsTevXuxbt06zvBz0L59+xAXF4f4+PgmCxD7+fkhMTERubm52LZtG8LCwjzUSnIE+3btsX/3Qh4tKz2ktLRUvcjcduHJuro6q59fe+01CQoKsromQEQkKSlJZs6c6dqG+gjmqT1HM7VcB9T4eqCYmBiZPn26nD9/XrZv3y5r1qy55uvcapzN1DISkZqaKs8884z6eH5+vuTn54uISGVlpUvbTM45deqUHDx48JrXOLIvujnM1PfccoXd888/L+Hh4fLKK69cdx+z2Szz5s2T999/X0REkpOTZfjw4eqSB4cOHZI777xTduzY4ZY2ezPmqT1nMl23bp1apFgKkg8//FCMRqPccccdoiiKvPXWW25ptze7mUzNZrOUlZVJ9+7dZfv27XLq1CmZOHGiKIoi27Ztc2PryRFPP/20hIWFSd++fSUwMFDeeuutJnc1YF/kHGbqm26ZU7FlZWV4/PHHsWvXLsTGxuKLL77AV199BcD6tNbatWvRrl077NixAz179gQAvP/++wgODsa4ceNw//33Y9CgQejRowcGDBjgkffiDZin9m4m0169esFguPK/sdFoxM8//4wvvvgCZrMZPXv2RFFREWbOnOmR9+MNmpOpoij44YcfUFZWhi1btqBr164oLy/HyZMneaG3FykqKsJDDz2E3NxcbN26FZs2bcLMmTOxcuVK5ObmqvuxL3IcM/Vxnq0rXavxxdDV1dWycOFC2bJli3z22WfSp08fmT9/vtW6OZcuXZJFixbJypUrm5yOKS8vlx07dkhmZqYcOHDAvW/ESzBP7WmRqUVNTY3MnTtX2rZtK59++qm73oLX0TLTFStWiKIocvfdd3PEwYs0Psbbtm2TyZMny1dffWW1T1RUlGRnZ4vIlVPm7ItujJnqh24Lu6qqKquZgZbTKhbPPvusDBgw4IYrytNVzFN7rsjUdhHdW41WmVr+gaqoqJCsrCzXNZicZnuMi4uL5fPPP1d/bmhokNraWklOTpb169dbbadrY6b6ostTsfPnz8fAgQPx4IMPYvny5aioqICiKAgODlZn8MyZMwcA8NFHH+HcuXMArpyasZzWoquYp/ZclWlkZKTrG++ltMxUURSICIKCgpCWlubW90HXZ3uMy8vL0aFDB/Tv3x/AlRmaBoMBp0+fxvfff4/ExET1ueyLro2Z6o+ujkptbS0mTpyIrVu3Yt68eYiOjsaqVaswZcoUAFc6a4PBALPZjNjYWEycOBGHDx/Gtm3b1Mfll+tuLP8Q3MqYp/aYqfZclantAs/kOdc7xqmpqVb7WY7ZwYMHERcXZ1WEWIjNkjW3KmaqYx4aKXSJI0eOSHx8vNW1MAcOHJCAgABZunSpenrFMnxcXV0to0aNkkmTJkl+fr6sW7dOXn75ZY+03RsxT+0xU+0xU/1z9Bhb/vvcc8/J9OnT1X337NlzzVvC3cqYqX7pqrA7dOiQKIoipaWlImK9InZoaKjVyvGWTv6jjz6SLl26SFhYmLRo0UJee+019zfcSzFP7TFT7TFT/XPmGNfX10vv3r0lOztbjh8/Lvfdd5+0aNFCveifrmCm+qWrU7EGgwG33347NmzYYLX92WefRZs2bbBq1SoAQENDAwwGA44dO4YPP/wQJ06cwKRJk3D+/Hk8++yznmi6V2Ke2mOm2mOm+ufoMQaAgoICHD16FGvWrEG3bt0QHh6Oc+fOYdKkSe5utldjpvqlq8KuU6dOiI+Px4EDB3D69Gn1VksmkwmzZ8/GBx98ALPZDKPRCABYtWoV9uzZg2+++QZvv/02WrVq5eF34F2Yp/aYqfaYqf45eowB4OjRo7h48SJqamqQl5eHjRs38vZ518BM9ctnCrujR49i586d13ysvr4eABAaGooxY8bgu+++w6ZNmwBcuZcjAISEhCA0NBTFxcXqh3XJkiUoLi7GHXfc4YZ34F2Yp/aYqfaYqf5pdYx//PFHAED//v2xe/du7N69G0lJSa5/A16Imd7afKKwy8/PR7du3TBlyhT1gwZcncHm5+eH6upqbNy4Eenp6UhKSkJ2djY+/fRTdd+ffvoJ4eHh6NSpkzpF+1adqs08tcdMtcdM9U/LYxwXFwcAiIqKwrBhw9z7RrwIMyWf6OFqa2tx//33w8/PD0uXLlW3Wzro5cuXIyYmBhs3bgQAPPPMM+jSpQseeOABzJw5E08++SRef/11TJ48GQCnZjNP7TFT7TFT/eMx1h4zJZ+YFbtq1Sp55JFHZPfu3eLn5ydffvml+lhmZqZ07txZ1q9fb7UKttlsloyMDPntb38ro0aNslpF+1bHPLXHTLXHTPWPx1h7zJQUEe8sx0VEXRhx7dq1KCwsxJIlS9C/f3+EhoYiJycHdXV1MJlMuHz5MgICAq75XLqCeWqPmWqPmeofj7H2mCk15ufpBlisXr0aiqKgW7duGDJkCBRFUW9lcvjwYfX6gA0bNqBr164YOXIkLly4gKysLPTo0cPqtfghZZ6uwEy1x0z1j8dYe8yUbsgTw4SNbdiwQSIiIuTee++VpKQkCQ8PV1eBr6mpERGRhx9+WHbt2iUiIu+8844EBASIyWSSzZs3e6zd3op5ao+Zao+Z6h+PsfaYKTnCo4Xd+vXr5c4775S//e1vIiLy888/y4oVK6RVq1ZSUVGh7jdt2jSZOnWq9O3bV8LDw2XRokXSpk0bef311z3VdK/EPLXHTLXHTPWPx1h7zJQc5ZFTsfLLOf26ujrcc889eOyxxwAA0dHR6N27N2JiYlBYWIi7774bly9fRkVFBfbt24eHH34YW7ZsQUxMDEwmE5577jmMHz8enTt39sTb8BrMU3vMVHvMVP94jLXHTMlp7qwiDx06JBcuXFB/Lisrk/r6eqt9vv76a4mKipLz58+r23Jzc6WgoMBqv+rqalm6dKnVzJ5bDfPUHjPVHjPVPx5j7TFTulluKew2b94sHTp0kK5du0psbKz8+c9/lpKSEvXxxh+2ZcuWyYABA0TkyoeRmmKe2mOm2mOm+sdjrD1mSs3l8sIuLy9PunfvLm+88YZ888038vbbb0t4eLg89dRTUlpaKiJXPqh1dXUiIjJu3DiZNWuWq5vls5in9pip9pip/vEYa4+ZkhZcVtiZzWYREVm5cqV06NBBysvL1ccyMzOlX79+smjRInVbQ0ODmM1m6dq1q2zbtk1ERL7//nt5+OGHpaioyFXN9BnMU3vMVHvMVP94jLXHTElLLrulmGVtnBMnTqBbt27qzYUBIC0tDcnJyfjkk09QUFAA4MrtTvLy8hAYGIg+ffpg7ty56NWrF0pLSxEREeGqZvoM5qk9Zqo9Zqp/PMbaY6akJc0Ku507d2LOnDl48803kZubq24fMGAADh48iJKSEgBAQ0MDWrVqhbFjx0JRFOzYsUPd9+OPP8a3336LhIQE7Ny5E59//jl27NgBf39/rZrpM5in9pip9pip/vEYa4+Zkis1u7A7ffo0xowZg0cffRTnz5/Hu+++i5SUFPXDmpKSgs6dO+PVV18FcPUvkxEjRsBgMODo0aPqa5lMJrRr1w5r1qxBQUEBkpOTm9s8n8M8tcdMtcdM9Y/HWHvMlNyiOedxL126JNOmTZPJkyfL8ePH1e19+/aVtLQ0ERGpr6+X9957TwwGQ5MbC6empsrQoUPVn8+ePduc5vg85qk9Zqo9Zqp/PMbaY6bkLs0asQsMDIS/vz/S0tIQFxeH+vp6AMCDDz6IwsJCAIDRaMSkSZMwduxYPPHEE9i7dy9EBCUlJfjhhx/w6KOPqq8XHh7enOb4POapPWaqPWaqfzzG2mOm5C6KiEhzXqCurg4mkwnA1RWyp06dioCAAKxevVrdVl1djZEjR+LIkSNISkrCt99+i9jYWGzatAkdO3bU5M3oAfPUHjPVHjPVPx5j7TFTcodmF3bXMnjwYKSnpyMtLQ0iArPZDKPRiDNnziA/Px95eXno3LkzpkyZovWv1iXmqT1mqj1mqn88xtpjpqQ1zQu748ePo3///sjJyVEv5qytrUWLFi20/DW3DOapPWaqPWaqfzzG2mOm5AqaLXdiqQ8PHDiA1q1bqx/ShQsX4umnn8bZs2e1+lW3BOapPWaqPWaqfzzG2mOm5Ep+9ndxjGVadm5uLiZMmICdO3di+vTpqKqqwvvvv89FE53EPLXHTLXHTPWPx1h7zJRcSssptpcvX5bbbrtNFEURf39/WbJkiZYvf8thntpjptpjpvrHY6w9Zkquovk1diNGjEB8fDyWLVuGli1bavnStyTmqT1mqj1mqn88xtpjpuQKmhd2DQ0NMBqNWr7kLY15ao+Zao+Z6h+PsfaYKbmCS5Y7ISIiIiL302xWLBERERF5Fgs7IiIiIp1gYUdERESkEyzsiIiIiHSChR0RERGRCZb15AAAAphJREFUTrCwIyIiItIJFnZERDdhwYIFSEpK8nQziIiscB07IiIblnt5Xs+0adOQmZmJmpoahIWFualVRET2sbAjIrJRUlKifp+dnY2//OUv+P7779VtAQEBCAkJ8UTTiIhuiKdiiYhsREVFqV8hISFQFKXJNttTsWlpafjVr36FjIwMREZGok2bNli4cCHq6+vxhz/8AW3btkWHDh3w97//3ep3/fzzz5g8eTJCQ0MRFhaGsWPH4uTJk+59w0SkGyzsiIg0smfPHpw6dQr79u3DsmXLsGDBAjz44IMIDQ3Fl19+iRkzZmDGjBkoLi4GAFRVVWHYsGFo3bo19u3bhwMHDqB169Z44IEHUFtb6+F3Q0S+iIUdEZFG2rZti+XLlyMhIQHp6elISEhAVVUVnn/+ecTHx2P+/Plo0aIFPv/8cwDAxo0bYTAY8M477+COO+5Ajx49kJWVhaKiInz22WeefTNE5JP8PN0AIiK96NmzJwyGq38vR0ZGIjExUf3ZaDQiLCwMZ8+eBQAcOnQIR48eRVBQkNXrVFdX49ixY+5pNBHpCgs7IiKNmEwmq58VRbnmNrPZDAAwm81ITk7G+vXrm7xWeHi46xpKRLrFwo6IyEP69OmD7OxsREREIDg42NPNISId4DV2REQekpqainbt2mHs2LHYv38/Tpw4gb179+Lpp5/GTz/95OnmEZEPYmFHROQhgYGB2LdvH2JjYzF+/Hj06NED6enpuHz5MkfwiOimcIFiIiIiIp3giB0RERGRTrCwIyIiItIJFnZEREREOsHCjoiIiEgnWNgRERER6QQLOyIiIiKdYGFHREREpBMs7IiIiIh0goUdERERkU6wsCMiIiLSCRZ2RERERDrBwo6IiIhIJ/4f0Xba0hLlWSgAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "ax.plot(df['ds'], df['y'])\n", + "ax.set_xlabel('Time')\n", + "ax.set_ylabel('Value')\n", + "\n", + "fig.autofmt_xdate()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from ray import tune\n", + "from neuralforecast.auto import AutoNBEATS\n", + "from neuralforecast import NeuralForecast" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nbeats_config = {\n", + " \"max_steps\": 100,\n", + " \"input_size\": tune.choice([192, 384]),\n", + " \"basis\": tune.choice(['legendre', 'polynomial', 'changepoint', 'piecewise_linear', 'linear_hat', 'spline', 'chebyshev']),\n", + " \"n_basis\": 5,\n", + " \"random_seed\": tune.randint(1, 10),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from ray.tune.search.hyperopt import HyperOptSearch\n", + "from neuralforecast.losses.pytorch import *\n", + "\n", + "model = AutoNBEATS(\n", + " h=96,\n", + " loss=MAE(),\n", + " config=nbeats_config,\n", + " search_alg=HyperOptSearch(),\n", + " backend='ray',\n", + " num_samples=20\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-12-11 15:50:13,039\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:50:18,252\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:50:23,121\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:50:28,184\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:50:33,283\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:50:38,708\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:50:44,491\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:50:50,101\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:50:55,325\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:00,161\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:05,280\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:10,177\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:15,309\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:20,305\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:25,378\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:30,614\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:36,364\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:41,335\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:46,351\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:51,301\tINFO tensorboardx.py:308 -- Removed the following hyperparameter values when logging to tensorboard: {'loss': ('__ref_ph', 'de895953'), 'valid_loss': ('__ref_ph', '004b9a7a')}\n", + "2024-12-11 15:51:51,309\tINFO tune.py:1009 -- Wrote the latest version of all result files and experiment state to '/Users/marcopeix/ray_results/_train_tune_2024-12-11_15-50-07' in 0.0070s.\n", + "Seed set to 9\n", + "GPU available: True (mps), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "HPU available: False, using: 0 HPUs\n", + "\n", + " | Name | Type | Params | Mode \n", + "-------------------------------------------------------\n", + "0 | loss | MAE | 0 | eval \n", + "1 | padder_train | ConstantPad1d | 0 | train\n", + "2 | scaler | TemporalNorm | 0 | train\n", + "3 | blocks | ModuleList | 3.1 M | train\n", + "-------------------------------------------------------\n", + "3.0 M Trainable params\n", + "56.4 K Non-trainable params\n", + "3.1 M Total params\n", + "12.263 Total estimated model params size (MB)\n", + "30 Modules in train mode\n", + "1 Modules in eval mode\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/marcopeix/miniconda3/envs/neuralforecast/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:424: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=10` in the `DataLoader` to improve performance.\n", + "/Users/marcopeix/miniconda3/envs/neuralforecast/lib/python3.10/site-packages/pytorch_lightning/trainer/connectors/data_connector.py:424: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=10` in the `DataLoader` to improve performance.\n", + "/Users/marcopeix/miniconda3/envs/neuralforecast/lib/python3.10/site-packages/pytorch_lightning/loops/fit_loop.py:298: The number of training batches (1) is smaller than the logging interval Trainer(log_every_n_steps=50). Set a lower value for log_every_n_steps if you want to see logs for the training epoch.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 99: 100%|██████████| 1/1 [00:00<00:00, 43.83it/s, v_num=2, train_loss_step=4.480, train_loss_epoch=4.480]" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`Trainer.fit` stopped: `max_steps=100` reached.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 99: 100%|██████████| 1/1 [00:00<00:00, 41.37it/s, v_num=2, train_loss_step=4.480, train_loss_epoch=4.480]\n" + ] + } + ], + "source": [ + "nf = NeuralForecast(models=[model], freq='M')\n", + "nf.fit(df=df, val_size=192)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
losstrain_lossconfig/max_stepsconfig/input_sizeconfig/basisconfig/n_basisconfig/random_seedconfig/hconfig/lossconfig/valid_loss
172.3517075.403413100192changepoint5996MAE()MAE()
112.3517075.403413100192changepoint5996MAE()MAE()
142.3766425.127730100192spline5496MAE()MAE()
92.3913355.018386100192piecewise_linear5296MAE()MAE()
132.4993553.935876100384changepoint5196MAE()MAE()
\n", + "
" + ], + "text/plain": [ + " loss train_loss config/max_steps config/input_size \\\n", + "17 2.351707 5.403413 100 192 \n", + "11 2.351707 5.403413 100 192 \n", + "14 2.376642 5.127730 100 192 \n", + "9 2.391335 5.018386 100 192 \n", + "13 2.499355 3.935876 100 384 \n", + "\n", + " config/basis config/n_basis config/random_seed config/h \\\n", + "17 changepoint 5 9 96 \n", + "11 changepoint 5 9 96 \n", + "14 spline 5 4 96 \n", + "9 piecewise_linear 5 2 96 \n", + "13 changepoint 5 1 96 \n", + "\n", + " config/loss config/valid_loss \n", + "17 MAE() MAE() \n", + "11 MAE() MAE() \n", + "14 MAE() MAE() \n", + "9 MAE() MAE() \n", + "13 MAE() MAE() " + ] + }, + "execution_count": null, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results = nf.models[0].results.get_dataframe()\n", + "\n", + "config_cols = [col for col in results.columns if col.startswith('config')]\n", + "columns_to_keep = ['loss', 'train_loss'] + config_cols\n", + "existing_columns = [col for col in columns_to_keep if col in results.columns]\n", + "filtered_results = results[existing_columns]\n", + "best_runs = filtered_results.sort_values('loss', ascending=True).head(5)\n", + "best_runs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that allowing the choose between different basis allows the model to better adapt to different datasets. In this case, we simulated a dataset with trend changepoints and so the \"changepoint basis\" was selected as the best basis for this dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "python3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/nbs/models.DynamicNBEATs.ipynb b/nbs/models.DynamicNBEATs.ipynb deleted file mode 100644 index 2e3183472..000000000 --- a/nbs/models.DynamicNBEATs.ipynb +++ /dev/null @@ -1,2424 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "WjjQM4GGp9lQ", - "outputId": "607671c2-b238-46b0-96d7-b62a7192c954" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting neuralforecast\n", - " Downloading neuralforecast-1.7.5-py3-none-any.whl.metadata (14 kB)\n", - "Collecting datasetsforecast\n", - " Downloading datasetsforecast-0.0.8-py3-none-any.whl.metadata (1.1 kB)\n", - "Collecting coreforecast>=0.0.6 (from neuralforecast)\n", - " Downloading coreforecast-0.0.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.8 kB)\n", - "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from neuralforecast) (2024.10.0)\n", - "Requirement already satisfied: numpy>=1.21.6 in /usr/local/lib/python3.10/dist-packages (from neuralforecast) (1.26.4)\n", - "Requirement already satisfied: pandas>=1.3.5 in /usr/local/lib/python3.10/dist-packages (from neuralforecast) (2.2.2)\n", - "Requirement already satisfied: torch>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from neuralforecast) (2.5.0+cu121)\n", - "Collecting pytorch-lightning>=2.0.0 (from neuralforecast)\n", - " Downloading pytorch_lightning-2.4.0-py3-none-any.whl.metadata (21 kB)\n", - "Collecting ray>=2.2.0 (from ray[tune]>=2.2.0->neuralforecast)\n", - " Downloading ray-2.38.0-cp310-cp310-manylinux2014_x86_64.whl.metadata (17 kB)\n", - "Collecting optuna (from neuralforecast)\n", - " Downloading optuna-4.0.0-py3-none-any.whl.metadata (16 kB)\n", - "Collecting utilsforecast>=0.0.25 (from neuralforecast)\n", - " Downloading utilsforecast-0.2.7-py3-none-any.whl.metadata (7.4 kB)\n", - "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (3.10.10)\n", - "Collecting fugue>=0.8.1 (from datasetsforecast)\n", - " Downloading fugue-0.9.1-py3-none-any.whl.metadata (18 kB)\n", - "Requirement already satisfied: numba in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (0.60.0)\n", - "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (2.32.3)\n", - "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (4.66.6)\n", - "Requirement already satisfied: xlrd>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from datasetsforecast) (2.0.1)\n", - "Collecting triad>=0.9.7 (from fugue>=0.8.1->datasetsforecast)\n", - " Downloading triad-0.9.8-py3-none-any.whl.metadata (6.3 kB)\n", - "Collecting adagio>=0.2.4 (from fugue>=0.8.1->datasetsforecast)\n", - " Downloading adagio-0.2.6-py3-none-any.whl.metadata (1.8 kB)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.3.5->neuralforecast) (2.8.2)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.3.5->neuralforecast) (2024.2)\n", - "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.10/dist-packages (from pandas>=1.3.5->neuralforecast) (2024.2)\n", - "Requirement already satisfied: PyYAML>=5.4 in /usr/local/lib/python3.10/dist-packages (from pytorch-lightning>=2.0.0->neuralforecast) (6.0.2)\n", - "Collecting torchmetrics>=0.7.0 (from pytorch-lightning>=2.0.0->neuralforecast)\n", - " Downloading torchmetrics-1.5.1-py3-none-any.whl.metadata (20 kB)\n", - "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from pytorch-lightning>=2.0.0->neuralforecast) (24.1)\n", - "Requirement already satisfied: typing-extensions>=4.4.0 in /usr/local/lib/python3.10/dist-packages (from pytorch-lightning>=2.0.0->neuralforecast) (4.12.2)\n", - "Collecting lightning-utilities>=0.10.0 (from pytorch-lightning>=2.0.0->neuralforecast)\n", - " Downloading lightning_utilities-0.11.8-py3-none-any.whl.metadata (5.2 kB)\n", - "Requirement already satisfied: click>=7.0 in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (8.1.7)\n", - "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (3.16.1)\n", - "Requirement already satisfied: jsonschema in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (4.23.0)\n", - "Requirement already satisfied: msgpack<2.0.0,>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (1.1.0)\n", - "Requirement already satisfied: protobuf!=3.19.5,>=3.15.3 in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (3.20.3)\n", - "Requirement already satisfied: aiosignal in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (1.3.1)\n", - "Requirement already satisfied: frozenlist in /usr/local/lib/python3.10/dist-packages (from ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (1.5.0)\n", - "Collecting tensorboardX>=1.9 (from ray[tune]>=2.2.0->neuralforecast)\n", - " Downloading tensorboardX-2.6.2.2-py2.py3-none-any.whl.metadata (5.8 kB)\n", - "Requirement already satisfied: pyarrow>=6.0.1 in /usr/local/lib/python3.10/dist-packages (from ray[tune]>=2.2.0->neuralforecast) (17.0.0)\n", - "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=2.0.0->neuralforecast) (3.4.2)\n", - "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=2.0.0->neuralforecast) (3.1.4)\n", - "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.10/dist-packages (from torch>=2.0.0->neuralforecast) (1.13.1)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy==1.13.1->torch>=2.0.0->neuralforecast) (1.3.0)\n", - "Requirement already satisfied: aiohappyeyeballs>=2.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (2.4.3)\n", - "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (24.2.0)\n", - "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (6.1.0)\n", - "Requirement already satisfied: yarl<2.0,>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (1.17.0)\n", - "Requirement already satisfied: async-timeout<5.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasetsforecast) (4.0.3)\n", - "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.10/dist-packages (from numba->datasetsforecast) (0.43.0)\n", - "Collecting alembic>=1.5.0 (from optuna->neuralforecast)\n", - " Downloading alembic-1.13.3-py3-none-any.whl.metadata (7.4 kB)\n", - "Collecting colorlog (from optuna->neuralforecast)\n", - " Downloading colorlog-6.9.0-py3-none-any.whl.metadata (10 kB)\n", - "Requirement already satisfied: sqlalchemy>=1.3.0 in /usr/local/lib/python3.10/dist-packages (from optuna->neuralforecast) (2.0.36)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->datasetsforecast) (3.4.0)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->datasetsforecast) (3.10)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->datasetsforecast) (2.2.3)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->datasetsforecast) (2024.8.30)\n", - "Collecting Mako (from alembic>=1.5.0->optuna->neuralforecast)\n", - " Downloading Mako-1.3.6-py3-none-any.whl.metadata (2.9 kB)\n", - "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from lightning-utilities>=0.10.0->pytorch-lightning>=2.0.0->neuralforecast) (75.1.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas>=1.3.5->neuralforecast) (1.16.0)\n", - "Requirement already satisfied: greenlet!=0.4.17 in /usr/local/lib/python3.10/dist-packages (from sqlalchemy>=1.3.0->optuna->neuralforecast) (3.1.1)\n", - "Collecting fs (from triad>=0.9.7->fugue>=0.8.1->datasetsforecast)\n", - " Downloading fs-2.4.16-py2.py3-none-any.whl.metadata (6.3 kB)\n", - "Requirement already satisfied: propcache>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from yarl<2.0,>=1.12.0->aiohttp->datasetsforecast) (0.2.0)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=2.0.0->neuralforecast) (3.0.2)\n", - "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema->ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (2024.10.1)\n", - "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema->ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (0.35.1)\n", - "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema->ray>=2.2.0->ray[tune]>=2.2.0->neuralforecast) (0.20.0)\n", - "Collecting appdirs~=1.4.3 (from fs->triad>=0.9.7->fugue>=0.8.1->datasetsforecast)\n", - " Downloading appdirs-1.4.4-py2.py3-none-any.whl.metadata (9.0 kB)\n", - "Downloading neuralforecast-1.7.5-py3-none-any.whl (254 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m254.8/254.8 kB\u001b[0m \u001b[31m9.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading datasetsforecast-0.0.8-py3-none-any.whl (27 kB)\n", - "Downloading coreforecast-0.0.13.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (271 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m271.4/271.4 kB\u001b[0m \u001b[31m14.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading fugue-0.9.1-py3-none-any.whl (278 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m278.2/278.2 kB\u001b[0m \u001b[31m27.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading pytorch_lightning-2.4.0-py3-none-any.whl (815 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m815.2/815.2 kB\u001b[0m \u001b[31m45.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading ray-2.38.0-cp310-cp310-manylinux2014_x86_64.whl (66.0 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m66.0/66.0 MB\u001b[0m \u001b[31m32.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading utilsforecast-0.2.7-py3-none-any.whl (41 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m41.4/41.4 kB\u001b[0m \u001b[31m3.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading optuna-4.0.0-py3-none-any.whl (362 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m362.8/362.8 kB\u001b[0m \u001b[31m28.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading adagio-0.2.6-py3-none-any.whl (19 kB)\n", - "Downloading alembic-1.13.3-py3-none-any.whl (233 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m233.2/233.2 kB\u001b[0m \u001b[31m22.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading lightning_utilities-0.11.8-py3-none-any.whl (26 kB)\n", - "Downloading tensorboardX-2.6.2.2-py2.py3-none-any.whl (101 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m101.7/101.7 kB\u001b[0m \u001b[31m11.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading torchmetrics-1.5.1-py3-none-any.whl (890 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m890.6/890.6 kB\u001b[0m \u001b[31m60.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading triad-0.9.8-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.3/62.3 kB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading colorlog-6.9.0-py3-none-any.whl (11 kB)\n", - "Downloading fs-2.4.16-py2.py3-none-any.whl (135 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m135.3/135.3 kB\u001b[0m \u001b[31m15.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading Mako-1.3.6-py3-none-any.whl (78 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.6/78.6 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading appdirs-1.4.4-py2.py3-none-any.whl (9.6 kB)\n", - "Installing collected packages: appdirs, tensorboardX, Mako, lightning-utilities, fs, coreforecast, colorlog, alembic, utilsforecast, triad, torchmetrics, optuna, ray, adagio, pytorch-lightning, fugue, neuralforecast, datasetsforecast\n", - "Successfully installed Mako-1.3.6 adagio-0.2.6 alembic-1.13.3 appdirs-1.4.4 colorlog-6.9.0 coreforecast-0.0.13.1 datasetsforecast-0.0.8 fs-2.4.16 fugue-0.9.1 lightning-utilities-0.11.8 neuralforecast-1.7.5 optuna-4.0.0 pytorch-lightning-2.4.0 ray-2.38.0 tensorboardX-2.6.2.2 torchmetrics-1.5.1 triad-0.9.8 utilsforecast-0.2.7\n" - ] - } - ], - "source": [ - "# pip install neuralforecast datasetsforecast" - ] - }, - { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from numpy.polynomial.legendre import Legendre\n", - "from numpy.polynomial.chebyshev import Chebyshev\n", - "from scipy.interpolate import BSpline\n", - "\n", - "def generate_legendre_basis(length, n_basis):\n", - " \"\"\"\n", - " Generates Legendre polynomial basis functions.\n", - "\n", - " Parameters:\n", - " - n_points (int): Number of data points.\n", - " - n_functions (int): Number of basis functions to generate.\n", - "\n", - " Returns:\n", - " - legendre_basis (ndarray): An array of Legendre basis functions.\n", - " \"\"\"\n", - " x = np.linspace(-1, 1, length) # Legendre polynomials are defined on [-1, 1]\n", - " legendre_basis = np.zeros((length, n_basis))\n", - "\n", - " for i in range(n_basis):\n", - " # Legendre polynomial of degree i\n", - " P_i = Legendre.basis(i)\n", - " legendre_basis[:, i] = P_i(x)\n", - "\n", - " return legendre_basis\n", - "\n", - "\n", - "def generate_polynomial_2_basis(length, n_basis):\n", - " \"\"\"\n", - " Generates standard polynomial basis functions.\n", - "\n", - " Parameters:\n", - " - n_points (int): Number of data points.\n", - " - n_functions (int): Number of polynomial functions to generate.\n", - "\n", - " Returns:\n", - " - poly_basis (ndarray): An array of polynomial basis functions.\n", - " \"\"\"\n", - " x = np.linspace(-1, 1, length)\n", - " poly_basis = np.zeros((length, n_basis))\n", - "\n", - " for i in range(n_basis):\n", - " poly_basis[:, i] = x ** i\n", - "\n", - " return poly_basis\n", - "\n", - "def generate_polynomial_basis(length, n_basis):\n", - " \"\"\"\n", - " Generates standard polynomial basis functions.\n", - "\n", - " Parameters:\n", - " - n_points (int): Number of data points.\n", - " - n_functions (int): Number of polynomial functions to generate.\n", - "\n", - " Returns:\n", - " - poly_basis (ndarray): An array of polynomial basis functions.\n", - " \"\"\"\n", - " return np.concatenate([np.power(np.arange(length, dtype=float) / length, i)[None, :]\n", - " for i in range(n_basis)]).T\n", - "\n", - "\n", - "def generate_changepoint_basis(length, n_basis):\n", - " \"\"\"\n", - " Generates changepoint basis functions with automatically spaced changepoints.\n", - "\n", - " Parameters:\n", - " - n_points (int): Number of data points.\n", - " - n_functions (int): Number of changepoint functions to generate.\n", - "\n", - " Returns:\n", - " - changepoint_basis (ndarray): An array of changepoint basis functions.\n", - " \"\"\"\n", - " x = np.linspace(0, 1, length)\n", - " changepoint_basis = np.zeros((length, n_basis))\n", - "\n", - " # Evenly space changepoint locations between 0 and 1\n", - " changepoint_locations = np.linspace(0, 1, n_basis + 1)[1:] # Avoid 0 to prevent all zeros\n", - "\n", - " for i, cp in enumerate(changepoint_locations):\n", - " changepoint_basis[:, i] = np.maximum(0, x - cp)\n", - "\n", - " return changepoint_basis\n", - "\n", - "def generate_piecewise_linear_basis(length, n_basis):\n", - " \"\"\"\n", - " Generates piecewise linear basis functions (linear splines).\n", - "\n", - " Parameters:\n", - " - n_points (int): Number of data points.\n", - " - n_functions (int): Number of piecewise linear basis functions to generate.\n", - "\n", - " Returns:\n", - " - pw_linear_basis (ndarray): An array of piecewise linear basis functions.\n", - " \"\"\"\n", - " x = np.linspace(0, 1, length)\n", - " knots = np.linspace(0, 1, n_basis+1)\n", - " pw_linear_basis = np.zeros((length, n_basis))\n", - "\n", - " for i in range(1, n_basis):\n", - " pw_linear_basis[:, i] = np.maximum(0, np.minimum((x - knots[i-1]) / (knots[i] - knots[i-1]), (knots[i+1] - x) / (knots[i+1] - knots[i])))\n", - "\n", - " return pw_linear_basis\n", - "\n", - "def generate_spline_basis(length, n_basis):\n", - " \"\"\"\n", - " Generates cubic spline basis functions.\n", - "\n", - " Parameters:\n", - " - n_points (int): Number of data points.\n", - " - n_functions (int): Number of basis functions.\n", - "\n", - " Returns:\n", - " - spline_basis (ndarray): An array of cubic spline basis functions.\n", - " \"\"\"\n", - " x = np.linspace(0, 1, length)\n", - " knots = np.linspace(0, 1, n_basis - 2) # Internal knots\n", - " t = np.concatenate(([0, 0, 0], knots, [1, 1, 1])) # Knot sequence for cubic splines\n", - " degree = 3 # Cubic splines\n", - "\n", - " spline_basis = np.zeros((length, n_basis))\n", - " for i in range(n_basis):\n", - " coef = np.zeros(n_basis)\n", - " coef[i] = 1 # Each basis function has one coefficient set to 1\n", - " spline = BSpline(t, coef, degree)\n", - " spline_basis[:, i] = spline(x)\n", - "\n", - " return spline_basis\n", - "\n", - "def generate_chebyshev_basis(length, n_basis):\n", - " \"\"\"\n", - " Generates Chebyshev polynomial basis functions.\n", - "\n", - " Parameters:\n", - " - n_points (int): Number of data points.\n", - " - n_functions (int): Number of Chebyshev polynomials to generate.\n", - "\n", - " Returns:\n", - " - chebyshev_basis (ndarray): An array of Chebyshev polynomial basis functions.\n", - " \"\"\"\n", - " x = np.linspace(-1, 1, length)\n", - " chebyshev_basis = np.zeros((length, n_basis))\n", - "\n", - " for i in range(n_basis):\n", - " T_i = Chebyshev.basis(i)\n", - " chebyshev_basis[:, i] = T_i(x)\n", - "\n", - " return chebyshev_basis\n", - "\n", - "def generate_piecewise_2_basis(length, n_basis):\n", - " array_splits = np.array_split(np.zeros(length),n_basis+1)[:-1]\n", - " initial_point = 0\n", - " final_point = 0\n", - " changepoints = np.zeros(shape=(length, n_basis))\n", - " len_splits = 0\n", - " for i in range(n_basis):\n", - " len_splits += len(array_splits[i])\n", - " moving_point = 1\n", - " left_basis = np.linspace(initial_point,\n", - " moving_point,\n", - " len_splits)\n", - " end_point = 0\n", - " right_basis = np.linspace(moving_point,\n", - " end_point,\n", - " length - len_splits + 1)\n", - " changepoints[:, i] = np.append(left_basis, right_basis[1:])\n", - " # changepoints[:, i+1] = 1\n", - " return changepoints" - ], - "metadata": { - "id": "0EB19ilyu5Aq" - }, - "execution_count": 9, - "outputs": [] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "SbrL4vyEpmwK", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "5cae4ca0-3146-4fc2-cf85-1125796bd9a8" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.10/dist-packages/dask/dataframe/__init__.py:42: FutureWarning: \n", - "Dask dataframe query planning is disabled because dask-expr is not installed.\n", - "\n", - "You can install it with `pip install dask[dataframe]` or `conda install dask`.\n", - "This will raise in a future version.\n", - "\n", - " warnings.warn(msg, FutureWarning)\n" - ] - } - ], - "source": [ - "# -*- coding: utf-8 -*-\n", - "from typing import Tuple, Optional\n", - "\n", - "import numpy as np\n", - "import torch\n", - "import torch.nn as nn\n", - "\n", - "from neuralforecast.losses.pytorch import MAE\n", - "from neuralforecast.common._base_windows import BaseWindows\n", - "\n", - "class IdentityBasis(nn.Module):\n", - " def __init__(self, backcast_size: int, forecast_size: int,\n", - " out_features: int=1):\n", - " super().__init__()\n", - " self.out_features = out_features\n", - " self.forecast_size = forecast_size\n", - " self.backcast_size = backcast_size\n", - "\n", - " def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n", - " backcast = theta[:, :self.backcast_size]\n", - " forecast = theta[:, self.backcast_size:]\n", - " forecast = forecast.reshape(len(forecast), -1, self.out_features)\n", - " return backcast, forecast\n", - "\n", - "def get_basis(length, n_basis, basis):\n", - " basis_dict = {\n", - " 'legendre': generate_legendre_basis,\n", - " 'polynomial': generate_polynomial_basis,\n", - " 'polynomial_2': generate_polynomial_2_basis,\n", - " 'changepoint': generate_changepoint_basis,\n", - " 'piecewise_linear': generate_piecewise_linear_basis,\n", - " 'piecewise_linear_2': generate_piecewise_2_basis,\n", - " 'spline': generate_spline_basis,\n", - " 'chebyshev': generate_chebyshev_basis\n", - " }\n", - " return basis_dict[basis](length, n_basis+1)\n", - "\n", - "class TrendBasis(nn.Module):\n", - " def __init__(self, n_basis: int,\n", - " backcast_size: int,\n", - " forecast_size: int,\n", - " out_features: int=1,\n", - " basis='polynomial'):\n", - " super().__init__()\n", - " self.out_features = out_features\n", - " # polynomial_size = degree_of_polynomial + 2\n", - " self.backcast_basis = nn.Parameter(\n", - " torch.tensor(get_basis(backcast_size, n_basis, basis).T, dtype=torch.float32), requires_grad=False)\n", - " self.forecast_basis = nn.Parameter(\n", - " torch.tensor(get_basis(forecast_size, n_basis, basis).T, dtype=torch.float32), requires_grad=False)\n", - "\n", - " def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n", - " polynomial_size = self.forecast_basis.shape[0] # [polynomial_size, L+H]\n", - " backcast_theta = theta[:, :polynomial_size]\n", - " forecast_theta = theta[:, polynomial_size:]\n", - " forecast_theta = forecast_theta.reshape(len(forecast_theta),polynomial_size,-1)\n", - " backcast = torch.einsum('bp,pt->bt', backcast_theta, self.backcast_basis)\n", - " forecast = torch.einsum('bpq,pt->btq', forecast_theta, self.forecast_basis)\n", - " return backcast, forecast\n", - "\n", - "class SeasonalityBasis(nn.Module):\n", - " def __init__(self, harmonics: int,\n", - " backcast_size: int, forecast_size: int,\n", - " out_features: int=1):\n", - " super().__init__()\n", - " self.out_features = out_features\n", - " frequency = np.append(np.zeros(1, dtype=float),\n", - " np.arange(harmonics, harmonics / 2 * forecast_size,\n", - " dtype=float) / harmonics)[None, :]\n", - " backcast_grid = -2 * np.pi * (\n", - " np.arange(backcast_size, dtype=float)[:, None] / forecast_size) * frequency\n", - " forecast_grid = 2 * np.pi * (\n", - " np.arange(forecast_size, dtype=float)[:, None] / forecast_size) * frequency\n", - "\n", - " backcast_cos_template = torch.tensor(np.transpose(np.cos(backcast_grid)), dtype=torch.float32)\n", - " backcast_sin_template = torch.tensor(np.transpose(np.sin(backcast_grid)), dtype=torch.float32)\n", - " backcast_template = torch.cat([backcast_cos_template, backcast_sin_template], dim=0)\n", - "\n", - " forecast_cos_template = torch.tensor(np.transpose(np.cos(forecast_grid)), dtype=torch.float32)\n", - " forecast_sin_template = torch.tensor(np.transpose(np.sin(forecast_grid)), dtype=torch.float32)\n", - " forecast_template = torch.cat([forecast_cos_template, forecast_sin_template], dim=0)\n", - "\n", - " self.backcast_basis = nn.Parameter(backcast_template, requires_grad=False)\n", - " self.forecast_basis = nn.Parameter(forecast_template, requires_grad=False)\n", - "\n", - " def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n", - " harmonic_size = self.forecast_basis.shape[0] # [harmonic_size, L+H]\n", - " backcast_theta = theta[:, :harmonic_size]\n", - " forecast_theta = theta[:, harmonic_size:]\n", - " forecast_theta = forecast_theta.reshape(len(forecast_theta),harmonic_size,-1)\n", - " backcast = torch.einsum('bp,pt->bt', backcast_theta, self.backcast_basis)\n", - " forecast = torch.einsum('bpq,pt->btq', forecast_theta, self.forecast_basis)\n", - " return backcast, forecast\n", - "\n", - "\n", - "\n", - "ACTIVATIONS = ['ReLU',\n", - " 'Softplus',\n", - " 'Tanh',\n", - " 'SELU',\n", - " 'LeakyReLU',\n", - " 'PReLU',\n", - " 'Sigmoid']\n", - "\n", - "class NPBEATSBlock(nn.Module):\n", - " \"\"\"\n", - " N-PBEATS block which takes a basis function as an argument.\n", - " \"\"\"\n", - " def __init__(self,\n", - " input_size: int,\n", - " n_theta: int,\n", - " mlp_units: list,\n", - " basis: nn.Module,\n", - " dropout_prob: float,\n", - " activation: str):\n", - " \"\"\"\n", - " \"\"\"\n", - " super().__init__()\n", - "\n", - " self.dropout_prob = dropout_prob\n", - "\n", - " assert activation in ACTIVATIONS, f'{activation} is not in {ACTIVATIONS}'\n", - " activ = getattr(nn, activation)()\n", - "\n", - " hidden_layers = [nn.Linear(in_features=input_size,\n", - " out_features=mlp_units[0][0])]\n", - " for layer in mlp_units:\n", - " hidden_layers.append(nn.Linear(in_features=layer[0],\n", - " out_features=layer[1]))\n", - " hidden_layers.append(activ)\n", - "\n", - " if self.dropout_prob>0:\n", - " raise NotImplementedError('dropout')\n", - " #hidden_layers.append(nn.Dropout(p=self.dropout_prob))\n", - "\n", - " output_layer = [nn.Linear(in_features=mlp_units[-1][1], out_features=n_theta)]\n", - " layers = hidden_layers + output_layer\n", - " self.layers = nn.Sequential(*layers)\n", - " self.basis = basis\n", - "\n", - " def forward(self, insample_y: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n", - " # Compute local projection weights and projection\n", - " theta = self.layers(insample_y)\n", - " backcast, forecast = self.basis(theta)\n", - " return backcast, forecast\n", - "\n", - "\n", - "#| export\n", - "class DynamicNBEATS(BaseWindows):\n", - " \"\"\" DynamicNBEATS\n", - "\n", - " The Neural Piecewise Basis Expansion Analysis for Time Series (DynamicNBEATS), is a simple and yet\n", - " effective architecture, it is built with a deep stack of MLPs with the doubly\n", - " residual connections. It has a generic and interpretable architecture depending\n", - " on the blocks it uses. Its interpretable architecture is recommended for scarce\n", - " data settings, as it regularizes its predictions through projections unto harmonic\n", - " and trend basis well-suited for most forecasting tasks.\n", - "\n", - " **Parameters:**
\n", - " `h`: int, forecast horizon.
\n", - " `input_size`: int, considered autorregresive inputs (lags), y=[1,2,3,4] input_size=2 -> lags=[1,2].
\n", - " `n_harmonics`: int, Number of harmonic terms for seasonality stack type. Note that len(n_harmonics) = len(stack_types). Note that it will only be used if a seasonality stack is used.
\n", - " `n_basis`: int, the number of basis functions for trend stack. Note that it will only be used if a trend stack is used.
\n", - " `stack_types`: List[str], List of stack types. Subset from ['seasonality', 'trend', 'identity'].
\n", - " `n_blocks`: List[int], Number of blocks for each stack. Note that len(n_blocks) = len(stack_types).
\n", - " `mlp_units`: List[List[int]], Structure of hidden layers for each stack type. Each internal list should contain the number of units of each hidden layer. Note that len(n_hidden) = len(stack_types).
\n", - " `dropout_prob_theta`: float, Float between (0, 1). Dropout for N-BEATS basis.
\n", - " `shared_weights`: bool, If True, all blocks within each stack will share parameters.
\n", - " `activation`: str, activation from ['ReLU', 'Softplus', 'Tanh', 'SELU', 'LeakyReLU', 'PReLU', 'Sigmoid'].
\n", - " `loss`: PyTorch module, instantiated train loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).
\n", - " `valid_loss`: PyTorch module=`loss`, instantiated valid loss class from [losses collection](https://nixtla.github.io/neuralforecast/losses.pytorch.html).
\n", - " `max_steps`: int=1000, maximum number of training steps.
\n", - " `learning_rate`: float=1e-3, Learning rate between (0, 1).
\n", - " `num_lr_decays`: int=3, Number of learning rate decays, evenly distributed across max_steps.
\n", - " `early_stop_patience_steps`: int=-1, Number of validation iterations before early stopping.
\n", - " `val_check_steps`: int=100, Number of training steps between every validation loss check.
\n", - " `batch_size`: int=32, number of different series in each batch.
\n", - " `valid_batch_size`: int=None, number of different series in each validation and test batch, if None uses batch_size.
\n", - " `windows_batch_size`: int=1024, number of windows to sample in each training batch, default uses all.
\n", - " `inference_windows_batch_size`: int=-1, number of windows to sample in each inference batch, -1 uses all.
\n", - " `start_padding_enabled`: bool=False, if True, the model will pad the time series with zeros at the beginning, by input size.
\n", - " `step_size`: int=1, step size between each window of temporal data.
\n", - " `scaler_type`: str='identity', type of scaler for temporal inputs normalization see [temporal scalers](https://nixtla.github.io/neuralforecast/common.scalers.html).
\n", - " `random_seed`: int, random_seed for pytorch initializer and numpy generators.
\n", - " `num_workers_loader`: int=os.cpu_count(), workers to be used by `TimeSeriesDataLoader`.
\n", - " `drop_last_loader`: bool=False, if True `TimeSeriesDataLoader` drops last non-full batch.
\n", - " `alias`: str, optional, Custom name of the model.
\n", - " `**trainer_kwargs`: int, keyword trainer arguments inherited from [PyTorch Lighning's trainer](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.trainer.trainer.Trainer.html?highlight=trainer).
\n", - "\n", - " **References:**
\n", - " -[Boris N. Oreshkin, Dmitri Carpov, Nicolas Chapados, Yoshua Bengio (2019).\n", - " \"N-BEATS: Neural basis expansion analysis for interpretable time series forecasting\".](https://arxiv.org/abs/1905.10437)\n", - " \"\"\"\n", - " # Class attributes\n", - " SAMPLING_TYPE = 'windows'\n", - "\n", - " def __init__(self,\n", - " h,\n", - " input_size,\n", - " n_harmonics: int = 2,\n", - " n_basis: int = 5,\n", - " basis: str = 'polynomial',\n", - " stack_types: list = ['identity', 'trend', 'seasonality'],\n", - " n_blocks: list = [1, 1, 1],\n", - " mlp_units: list = 3 * [[512, 512]],\n", - " dropout_prob_theta: float = 0.,\n", - " activation: str = 'ReLU',\n", - " shared_weights: bool = False,\n", - " loss = MAE(),\n", - " valid_loss = None,\n", - " max_steps: int = 1000,\n", - " learning_rate: float = 1e-3,\n", - " num_lr_decays: int = 3,\n", - " early_stop_patience_steps: int =-1,\n", - " val_check_steps: int = 100,\n", - " batch_size: int = 32,\n", - " valid_batch_size: Optional[int] = None,\n", - " windows_batch_size: int = 1024,\n", - " inference_windows_batch_size: int = -1,\n", - " start_padding_enabled = False,\n", - " step_size: int = 1,\n", - " scaler_type: str ='identity',\n", - " random_seed: int = 1,\n", - " num_workers_loader: int = 0,\n", - " drop_last_loader: bool = False,\n", - " **trainer_kwargs):\n", - "\n", - " # Inherit BaseWindows class\n", - " super(DynamicNBEATS, self).__init__(h=h,\n", - " input_size=input_size,\n", - " loss=loss,\n", - " valid_loss=valid_loss,\n", - " max_steps=max_steps,\n", - " learning_rate=learning_rate,\n", - " num_lr_decays=num_lr_decays,\n", - " early_stop_patience_steps=early_stop_patience_steps,\n", - " val_check_steps=val_check_steps,\n", - " batch_size=batch_size,\n", - " windows_batch_size=windows_batch_size,\n", - " valid_batch_size=valid_batch_size,\n", - " inference_windows_batch_size=inference_windows_batch_size,\n", - " start_padding_enabled=start_padding_enabled,\n", - " step_size=step_size,\n", - " scaler_type=scaler_type,\n", - " num_workers_loader=num_workers_loader,\n", - " drop_last_loader=drop_last_loader,\n", - " random_seed=random_seed,\n", - " **trainer_kwargs)\n", - "\n", - " # Architecture\n", - " blocks = self.create_stack(h=h,\n", - " input_size=input_size,\n", - " stack_types=stack_types,\n", - " n_blocks=n_blocks,\n", - " mlp_units=mlp_units,\n", - " dropout_prob_theta=dropout_prob_theta,\n", - " activation=activation,\n", - " shared_weights=shared_weights,\n", - " n_basis=n_basis,\n", - " n_harmonics=n_harmonics,\n", - " basis_type=basis)\n", - " self.blocks = torch.nn.ModuleList(blocks)\n", - "\n", - " def create_stack(self, stack_types,\n", - " n_blocks,\n", - " input_size,\n", - " h,\n", - " mlp_units,\n", - " dropout_prob_theta,\n", - " activation, shared_weights,\n", - " n_basis, n_harmonics, basis_type):\n", - "\n", - " block_list = []\n", - " for i in range(len(stack_types)):\n", - " for block_id in range(n_blocks[i]):\n", - "\n", - " # Shared weights\n", - " if shared_weights and block_id>0:\n", - " npbeats_block = block_list[-1]\n", - " else:\n", - " if stack_types[i] == 'seasonality':\n", - " n_theta = 2 * (self.loss.outputsize_multiplier + 1) * \\\n", - " int(np.ceil(n_harmonics / 2 * h) - (n_harmonics - 1))\n", - " basis = SeasonalityBasis(harmonics=n_harmonics,\n", - " backcast_size=input_size,forecast_size=h,\n", - " out_features=self.loss.outputsize_multiplier)\n", - "\n", - " elif stack_types[i] == 'trend':\n", - " n_theta = (self.loss.outputsize_multiplier + 1) * (n_basis + 1)\n", - " basis = TrendBasis(n_basis=n_basis,\n", - " backcast_size=input_size,forecast_size=h,\n", - " out_features=self.loss.outputsize_multiplier,\n", - " basis=basis_type)\n", - "\n", - " elif stack_types[i] == 'identity':\n", - " n_theta = input_size + self.loss.outputsize_multiplier * h\n", - " basis = IdentityBasis(backcast_size=input_size, forecast_size=h,\n", - " out_features=self.loss.outputsize_multiplier)\n", - " else:\n", - " raise ValueError(f'Block type {stack_types[i]} not found!')\n", - "\n", - " npbeats_block = NPBEATSBlock(input_size=input_size,\n", - " n_theta=n_theta,\n", - " mlp_units=mlp_units,\n", - " basis=basis,\n", - " dropout_prob=dropout_prob_theta,\n", - " activation=activation)\n", - "\n", - " # Select type of evaluation and apply it to all layers of block\n", - " block_list.append(npbeats_block)\n", - "\n", - " return block_list\n", - "\n", - " def forward(self, windows_batch):\n", - "\n", - " # Parse windows_batch\n", - " insample_y = windows_batch['insample_y']\n", - " insample_mask = windows_batch['insample_mask']\n", - "\n", - " # NPBEATS' forward\n", - " residuals = insample_y.flip(dims=(-1,)) # backcast init\n", - " insample_mask = insample_mask.flip(dims=(-1,))\n", - "\n", - " forecast = insample_y[:, -1:, None] # Level with Naive1\n", - " block_forecasts = [ forecast.repeat(1, self.h, 1) ]\n", - " for i, block in enumerate(self.blocks):\n", - " backcast, block_forecast = block(insample_y=residuals)\n", - " residuals = (residuals - backcast) * insample_mask\n", - " forecast = forecast + block_forecast\n", - "\n", - " if self.decompose_forecast:\n", - " block_forecasts.append(block_forecast)\n", - "\n", - " # Adapting output's domain\n", - " forecast = self.loss.domain_map(forecast)\n", - "\n", - " if self.decompose_forecast:\n", - " # (n_batch, n_blocks, h, out_features)\n", - " block_forecasts = torch.stack(block_forecasts)\n", - " block_forecasts = block_forecasts.permute(1,0,2,3)\n", - " block_forecasts = block_forecasts.squeeze(-1) # univariate output\n", - " return block_forecasts\n", - " else:\n", - " return forecast\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 555, - "referenced_widgets": [ - "bb8fb55556ac451fbe17df79d10c2b56", - "a0bedda309594a8587d725e23ab569e4", - "011a85465fb742b596cc725b4246aa01", - "94fb8d26156f4af3b1e21ba882b5a3fc", - "1b8af82b0f0d4ef39409262baf9360aa", - "945e8c93915747e1b99860966291da1b", - "47d8345be1ea47e8831a9e5d4386b7a8", - "7816477075504b2cb3ef6fa8aa57bf09", - "c01752b4d3b84a9b897360744a43375d", - "8f2cf806a1b5453cbabaa5871f9eb9bd", - "64a042cc36014ba0aa6b23606bda8554", - "c1a1d5b7043647a29aeb3ea4fdc34ecf", - "ef67032131af4828b82e47a5a710fef5", - "c4e4d98af60a420b804742db2c7a5e5d", - "d56f16d908504149948dbe7497980bc3", - "63ada147711b4c339004a99c353962eb", - "f8b2b298f2044b1abe670fc84b7658bd", - "d0b51366bc814f1c99cd4153c3fe4ec0", - "84857f37c01849d3a796bd1c07eebc54", - "0758c138f86540bbba775d599589deb2", - "27a657fb36f5489d8ae3e3c6180db997", - "6f32c5b55fb342fd985dbda4ade77b82", - "588d220a6d634b03ae463c2cc5902b58", - "d8302f528c1f4c018b7bd641d152b617", - "40063d0d85254615a05e68084d2dcafa", - "b560422245e94bb7b5804a6b8bd31dca", - "d4c66b4520ab40898ac04010fa926c5b", - "c53abfe7cf5f43daa0a8dd56853cc3a6", - "c4e26937963f48b994111d8b5a6e4a28", - "dbe2f9e88d2c4b649afc033bc8603083", - "2a5fe8a3fa2140a694d503bc00400f12", - "947b94882e8144beaca020c64f4588e2", - "b3eb5210e0d747c0a5abae14b4691997", - "1fbe190298c742fcb44273f22bff9e22", - "6217a4d543cb4a329ff1014735c563f1", - "e30a0a034d1a47f7b8134d78ea7eb0bf", - "5e2cef4d25e54553bd11d7adfb8dd2f9", - "095bbaae5e1d4789b9a370f074439027", - "f895197c32e646bda4e825796946807c", - "a7231112c75e4c89b5c2a234008ff080", - "7d289fa9ce354637bbb1e3d2798e3674", - "cabd9a2793c148c1b72e64d19da35ed5", - "7fd831200ddf4e3c9f44df09bee746c7", - "6d54edada0d34b71bc34b0c105712913" - ] - }, - "id": "tyFH2QP5qXxL", - "outputId": "ef18a25c-317f-4bde-91b4-ce8393895435" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "INFO:lightning_fabric.utilities.seed:Seed set to 1\n", - "INFO:pytorch_lightning.utilities.rank_zero:GPU available: True (cuda), used: True\n", - "INFO:pytorch_lightning.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", - "INFO:pytorch_lightning.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", - "INFO:pytorch_lightning.utilities.rank_zero:You are using a CUDA device ('NVIDIA A100-SXM4-40GB') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", - "INFO:pytorch_lightning.accelerators.cuda:LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "INFO:pytorch_lightning.callbacks.model_summary:\n", - " | Name | Type | Params | Mode \n", - "-------------------------------------------------------\n", - "0 | loss | MAE | 0 | train\n", - "1 | padder_train | ConstantPad1d | 0 | train\n", - "2 | scaler | TemporalNorm | 0 | train\n", - "3 | blocks | ModuleList | 2.5 M | train\n", - "-------------------------------------------------------\n", - "2.4 M Trainable params\n", - "1.0 K Non-trainable params\n", - "2.5 M Total params\n", - "9.802 Total estimated model params size (MB)\n", - "31 Modules in train mode\n", - "0 Modules in eval mode\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "Sanity Checking: | | 0/? [00:00]" - ] - }, - "metadata": {}, - "execution_count": 5 - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAGdCAYAAADey0OaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB4PElEQVR4nO39eXhb9Z0+ft9Hq1d5XxPb2RdnJ4HEhJYWAgHSsmVKYVJIW6a0TGhZppThKdAOzDTATIHSSaH0oUAHKIV+gZawhgBJIRtx9n2PnXhf5V3b+f1x9DmSHMnWkXRky75f15VrEkuWzjGd6J339pFkWZZBRERENMwZhvoCiIiIiMLBoIWIiIgSAoMWIiIiSggMWoiIiCghMGghIiKihMCghYiIiBICgxYiIiJKCAxaiIiIKCGYhvoCIuHxeFBTU4P09HRIkjTUl0NERERhkGUZHR0dKC4uhsGgPW+SkEFLTU0NSkpKhvoyiIiIKALV1dUYO3as5u9LyKAlPT0dgHLTNpttiK+GiIiIwmG321FSUqJ+jmuVkEGLKAnZbDYGLURERAkm0tYONuISERFRQmDQQkRERAmBQQsRERElBAYtRERElBAYtBAREVFCYNBCRERECYFBCxERESUEBi1ERESUEBi0EBERUUJg0EJEREQJgUELERERJQQGLURERJQQGLQQERGNQO/vrcVbO89AluWhvpSYSchTnomIiCi0XqcbP3ltJ5xuGRuPNGH19bOQZDYO9WVFjZkWIiKiEaa9xwmnW8mwvLXzLG58bgsaOnqH+Kqix6CFiIhohOnodQIALCYDMpLN2FXdhtv+VDnEVxU9Bi1EREQjTHuPCwCQn27FK/+yEACw+0xbwve3MGghIiIaYUSmJT3JjAl5qQAAWQa6He6hvKyoMWghIiIaYTp6lUxLepIJyWYjDJLy9c4+1xBeVfQYtBAREY0wImixJZkgSRLSrKaArycqBi1EREQjjH95CIAatHQx00JERETDiX95CADSvP+X5SEiIiICAOysasUnh+qH+jLUTIutX6aF5SEiIiICAPzo5Up8/8XtON7YOaTXcW6mRQlemGkhIiIieDwyGjr6AACfHGwY0muxq0GLEqykezMtnd4MTKJi0EJERBQD3U43xO62Tw8PbdDia8T1Zlqs7GkhIiIiL//JnC9PtaiBw1Cwh2jE7WDQQkRERP5Nrk63jC+ONQ/htQQfee5kIy4RERH1L718NoQlIv/lcoAv48LyEBEREZ2zuO3Tww1DckChLMtqcGJLZqaFiIiI+hHZjZljbEg2G1Fv78PB2o64X0e3ww23RwmW2NNCRERE5xCZlpxUKxZPygEwNFNEIngyGiQkm40AuMafiIiI/IiSTJrVhK9NzQcwNH0t/uPOkiSpv/e/xkSlOWg5e/YsvvOd7yAnJwfJycmYNWsWtm/frj4uyzIeeughFBUVITk5GUuWLMHRo0cDXqOlpQUrVqyAzWZDZmYmbr31VnR2Du32QCIiomgEBi15AIDK063odbrjeh39x50BIHU09rS0trZi8eLFMJvNeP/993HgwAH8+te/RlZWlvqcxx9/HE8//TSeffZZbN26FampqVi6dCl6e3vV56xYsQL79+/HunXrsHbtWmzcuBG33XZb7O6KiIgozkTQkmo1oTgjGZIEeOT4n/ejZlqsZvVr6tlDCZ5pMQ3+FJ/HHnsMJSUleOGFF9SvjR8/Xv29LMt46qmn8MADD+Caa64BAPzpT39CQUEB3n77bdx44404ePAgPvjgA3z55ZdYsGABAOC3v/0trrrqKvzP//wPiouLY3FfREREcSWyGGlJJhgMElLMRnQ53Oh2uABY43YdwTItIoBxuDzoc7lhNRnjdj2xpCnT8ve//x0LFizAt771LeTn52PevHn4wx/+oD5+8uRJ1NXVYcmSJerXMjIysHDhQmzevBkAsHnzZmRmZqoBCwAsWbIEBoMBW7duDfq+fX19sNvtAb+IiIiGE5FpEef8pKjNr/EtD/VfLAcAqVZfkBLv64klTUHLiRMn8Mwzz2Dy5Mn48MMPcfvtt+MnP/kJXnrpJQBAXV0dAKCgoCDg+woKCtTH6urqkJ+fH/C4yWRCdna2+pz+Vq9ejYyMDPVXSUmJlssmIiLSnX95CABSLUqgoGRa4kddLJfsy7SYjAZ1kiiR+1o0BS0ejwfnnXcefvWrX2HevHm47bbb8IMf/ADPPvusXtcHALj//vvR3t6u/qqurtb1/YiIiLTyLw8BQIrFm2lxDE2mxeaXafG/ro6+xD3pWVPQUlRUhPLy8oCvTZ8+HVVVVQCAwsJCAEB9fX3Ac+rr69XHCgsL0dAQOALmcrnQ0tKiPqc/q9UKm80W8IuIiGg46XKI6SEloyFKMt1xbn7tCNLTAvjKVqMm07J48WIcPnw44GtHjhxBWVkZAKUpt7CwEOvXr1cft9vt2Lp1KyoqKgAAFRUVaGtrQ2VlpfqcTz75BB6PBwsXLoz4RoiIiIaSmmnxNr0OXaYleNCSNgJ2tWiaHrr77rtx4YUX4le/+hVuuOEGbNu2Dc899xyee+45AIAkSbjrrrvwn//5n5g8eTLGjx+PBx98EMXFxbj22msBKJmZK664Qi0rOZ1O3HHHHbjxxhs5OURERAmrw29PC+CXaYl7T8u5jbj+1zVqgpbzzz8fb731Fu6//348/PDDGD9+PJ566imsWLFCfc7PfvYzdHV14bbbbkNbWxsuuugifPDBB0hKSlKf88orr+COO+7ApZdeCoPBgOXLl+Ppp5+O3V0RERHFWVe/oEXNtMR5WifYyLP/dY2aoAUAvvGNb+Ab3/hGyMclScLDDz+Mhx9+OORzsrOz8eqrr2p9ayIiomHJ7ZHR7S0DiTLMUE8PnZNpSRplPS1ERER0ri6/wCRVbcQdokxLj+/sIX/pIyDTwqCFiIgoSiJ7YTEa1G2zImgZqp6W/iPP4nrifaxALDFoISIiipJ6WKJfdiPFWx6K5/SQLMvqtdhG4PQQgxYiIqIo+bbh+tblp6qNuPELErocbnhk5ff9e1pG3Z4WIiIiOlf/HS0AkOINYOIZtIjSkMkgIckc+BHPTAsRERGpgYnIZgC+TEt3HMtD/ovlJEkKeEwEVB0MWoiIiEavjiDlIV9PS/wzLf1LQ4DfnpbeUXL2EBEREZ3Ld1iiL1hQp4fiOPIcarGc/9dYHiIiIhrFfNtwhzrTIiaHBsq0MGghIiIatTr7rfAH/Pe0uCHLclyuw1ceOjfTIhpxuxxueDzxuZ5YY9BCREQUJd9hiX7TQ95Mi9sjo8/lict12HuCr/BXrs0XyMQz+xNLDFqIiIii1BW0EdcXJMRrgmigTIvVZIDZqEwUJWpfC4MWIiKiKHUGaYA1+u1KideuFl9Py7lBiyRJCd/XwqCFiIgoSr6NuIHBQrx3tQw08gz4+loSdVcLgxYiIqIoBWvEBfxOeo5TD0nHACPPgC+IYqaFiIholBJBS/9gQTTjxmtXiy9oCZ5pSfRdLQxaiIiIotQVqjwU50yL3VsesiUHz7Swp4WIiGiU6+gNXh5SF8zFuRE3dE9LYp8/xKCFiIhGjKc+PoL7/ronbsvcAMDp9qh7WM7pabH4FrrFw0AjzwAzLURERMPC0foOPPXxUfxlezVONnXF7X39syj9y0MpVtHTon+QIMuyGhz1D54EX09LYh6ayKCFiIhGhD9tPq3+viuOhxSKkkyS2QCzMfBjNZ6Zlj6XB27vev7+wZOgZlri+POJJQYtRESU8Dp6nXhzxxn1z/GcjhFNtsGyG/HMtPjfc4rZGPQ5vqCF5SEiIqIh8eaOswHZjO44nq3TGaIJF4hvpkWUqVIsRhgMUtDniOVynb0sDxEREcWdLMv40+ZTAV+LV+Mr4JvECVaSUfe0xCGIEiWxUKUhAEhnpoWIiGjobDrejOONXUi1GLFoQjaA+I0Y+79X0EyL2NMShx6SgcpUgrrGP0Gnh0LfGRERUQL4P28D7vXnjVWXq8UzaAl2WKIQz0xLp195KBT2tBAREQ2hvWfbAQBXzy1GSpwPKARCH5YIxLenpTuM8hCDFiIioiFk71GyKzmpFqTGeQMtEPqwRCC+00MDlakEXyOuK64L+GKFQQsRESUst0dWG2Ftyea4n/UDhDc9FI/Mj5bykMsjq1t8EwmDFiIiSlj+ZY70JBNSrfE9VRkYuAE2nkFUdxiNuCKIAhKzGZdBCxERJSxRGrKaDLCajGpPSzx7NtTDEoM04sYziOoMo6fFYJASuq+FQQsRESWs/qcaiw/keDbidg24p0X5msPtgUPncox6HQOUhwDfzyiefT+xwqCFiIgSlhhxtiUrH8SinyOuPS3eD//0AZbLAfqPPQ8UPPlL5F0tDFqIiChhifKQzZtpSR2CLIL48A8WLJiNBlhMyket3mPPIlAbNGhheYiIiCj+OvotdovnBtr+1xCspwXwlWv0Hnv2rfEfuDwkfladfYl3/hCDFiIiSli+8pA30xLHDbRCW7cDAJCVYgn6eEqcFsypS+4sYWZaWB4iIiKKH5HlsHmzBylxzrQ4XB41GMlKMQd9TmqcFsyFM/Ls/3gHy0NERETx07+nJS2O0zoA0NajZFkMku8a+otXpkUEailhNuIy00JERBRH/ctDyX7TOj1xGHtu61bePyPZDINBCvocNdOic8nKd5zAID0tbMQlIiKKv/6NuBaTARaj8tHWGYe+ltYuJdOSGaKfBfDLtOhcsuoOc3oolT0tRERE8admWvxKM/HqIQGANm95KjNEPwsQn+bgPpcbTrdyAGLKYI24SexpISIiirv+mRYgfj0kwOCTQ0B8moP9XzvcjbjMtBAREcWR2oibfG6mJR4L5lq7h0emRdxrktkAk3Hgj3YR4MVza3CsMGghIqKEFSzTEs+tuK1hZFricdLzQCdN95dmVQIsZlqIiIjiRJbl4D0tlvgdmtjW5c20JA+UafFej67lISUAGayfBeCeFiIiorjrdXrU5lP/8pA4pDAeI71iT0tm6kA9LfpfT6e6wn/woCWde1qIiIjiq8ObZTFIgc2nIpMQj1X+oqcl1DZcID6Zn+4wd7Qoz1Gup8fphsut/wK+WGLQQkRECUmUhtKTzJAk32K3FLURd5hMD3kDKj17Wjo1lIf8szHxPFgyFhi0EBFRQrIHacIFfJmNYTM9ZI1fT0s4jbgWkwFWk/Lx35FgJz0zaCEiooTU/9whwTeto28WQZZlNdMy8EZc/TMt4l5TwygPAX59LQnWjMughYiIEpLItNiSA7MLKXHYi6K8vm8L7YA9LVb9e1q0TA8BibtgjkELERElpA6/nhZ/8drTIna0WEwGJJtDZzhEgGDvccLjkXW5Fi3lIcD3M0q0sWdNQcsvf/lLSJIU8GvatGnq4729vVi1ahVycnKQlpaG5cuXo76+PuA1qqqqsGzZMqSkpCA/Px/33nsvXK7E+qEREZHPHz8/iR/+33Y4XPGdRLH3eDMtIYMWfctDbX6TQ/6NwP3lplkBAC6PrJ5VFGu+8tDIzrSEd3d+ZsyYgY8//tj3AibfS9x9991499138cYbbyAjIwN33HEHrr/+enzxxRcAALfbjWXLlqGwsBCbNm1CbW0tbrnlFpjNZvzqV7+Kwe0QEVE8dfQ68egHh+BwebCjqhWLJuTE9b2BYI248SkPhbMNF1AyMdmpFrR0OdDQ0YvsAXa6REpkWrT2tMSjWTmWNActJpMJhYWF53y9vb0dzz//PF599VVccsklAIAXXngB06dPx5YtW7Bo0SJ89NFHOHDgAD7++GMUFBRg7ty5eOSRR3Dffffhl7/8JSyW2P+HJCIi/XxyqEHNsMRjL4o/dRtuv220oq9D7yZTkWnJGGAbrpCfbkVLlwP19j5MO/cjNGriXlO19rQkWNCiuafl6NGjKC4uxoQJE7BixQpUVVUBACorK+F0OrFkyRL1udOmTUNpaSk2b94MANi8eTNmzZqFgoIC9TlLly6F3W7H/v37Q75nX18f7HZ7wC8iIhp67+2tVX8fj7X5/nzloX6ZFqvItOhdHgov0wIAeelKiajB3qvLtfgyLWEGLd6fWUeClYc0BS0LFy7Eiy++iA8++ADPPPMMTp48ia985Svo6OhAXV0dLBYLMjMzA76noKAAdXV1AIC6urqAgEU8Lh4LZfXq1cjIyFB/lZSUaLlsIiLSQVefC58dblT/rOcekmA6gpw7BMSzEdfb05IaTqYlCQDQ0NGny7V0axx5Vg9NTLBMi6by0JVXXqn+fvbs2Vi4cCHKysrw+uuvIzk5OeYXJ9x///2455571D/b7XYGLkREQ+yTQw3o82u+1XMPSTChRp7V5XION2RZHrBJNhqtYexoEQpsSqalUaegpVNjpiVRzx+KauQ5MzMTU6ZMwbFjx1BYWAiHw4G2traA59TX16s9MIWFhedME4k/B+uTEaxWK2w2W8AvIiIaWv6lISD+5aFQI89ijb/bIwcEVbEmeloGOuFZyBfloQ59y0PhjjyPmp4Wf52dnTh+/DiKioowf/58mM1mrF+/Xn388OHDqKqqQkVFBQCgoqICe/fuRUNDg/qcdevWwWazoby8PJpLISKiOOp2uPDpYeXv8gVlWerX4inkyLNfM6qegZSWnpZ8m1Ieqrfrk2kRI88plnDLQ6NgT8tPf/pTbNiwAadOncKmTZtw3XXXwWg04qabbkJGRgZuvfVW3HPPPfj0009RWVmJ733ve6ioqMCiRYsAAJdffjnKy8tx8803Y/fu3fjwww/xwAMPYNWqVbBarbrcIBERxd6nhxrR6/SgJDsZF4zPBhD/w/fUnpZ+5SGjQUKS2eC9Jv0+lMM5d0jQM9PidHvUCa6wMy1qeSixzh7S1NNy5swZ3HTTTWhubkZeXh4uuugibNmyBXl5eQCAJ598EgaDAcuXL0dfXx+WLl2K3/3ud+r3G41GrF27FrfffjsqKiqQmpqKlStX4uGHH47tXRERka4+2K8MT1w1s8hvTX38/tXucnvU7EL/8hCgZFt6nQ5d+2zUTEsYe1fURlx7X8z7bPwDs3DX+KcnaHlIU9Dy2muvDfh4UlIS1qxZgzVr1oR8TllZGd577z0tb0tERMPMsYZOAMCiCTk41dwFIL49Lf6juv2XywFKQ2pzl0PX7E+r30bcweR7G3H7XB7Ye11h7XYJlwjeLEYDLKbwCihpo7ERl4iIRqeWLqU3IzfNqvaQDEXQkmw2wmw896NMPVlZp0yC2yOry+0ykgfPtCSZjeo+mcYYl4i0bsMFRklPCxERkSzLaOlSSiPZaRYk6xwgBGMP0c8i6F2ysvc4IXvPPgynpwXQrxlX67gz4AtauvpckGV9DnHUA4MWIiLSpKPPBadb+aDLSbXEbQOtP3uIcWchVe3Z0OeaxI6WdKspaKYnGL2accVSv3BX+AO+8pBHBnqc8W2gjgaDFiIi0qSlU/nATrEYkWQ2qs2f8WzEDbXCX9D70ER1ciiMbbiCGrTolmkJvzyUbDbC4O0FTqS+FgYtRESkSbMoDXmnZlIsQ5dp6X9YoiACKb0acbXsaBFEeSjWq/y1njsEAJIkJWRfC4MWIiLSRPSz5KhBS3zO+vEnGnFDlYfSrPr22Wg54VkQmZb6GB+aKMa6tZSHAN/PjpkWIiIasZo7lUyByLSIskQ8eyPsPeKwxOAf1Cmi0VS38tBwyrSIwxK1BS2JuMqfQQsREWkiykM5aUrmQGRanG5Z3cyqt8EyLWpPi27lofB3tAgi0xLrQxN95w6F39MC+JpxO5hpISKikerc8pDvwzJezbjhjjx36pxpCeeEZ8HXiBvb8pDIlKQw00JERBSopV8jrtlogMU79tsVp2Zc9dyhkJkW70STXj0tPRFkWrzloS6HO6aBgggUwz13SEjE84cYtBARkSb9p4cAIEX0tcQr09IjykOhelq8jbg6BVFN3hKPlkxLmtWkZqVimW1Re1rCPOFZSMTzhxi0EBGRJmKFf06a7wM7VecR4/4Ga4RNteo30VTX3ovtp1sBADOKbZq+t0CHZtxoy0MceSYiohFLLJfLTrWqX1NX+ccp09LU6Tv7KBg9z0N6detpuD0yLhifjckF6Zq+N0/dihu7oCXa8lA8R9Wjpe0OiYhoSHk8MjYebcSLm06hqqUbL9+6EMWZyXF7f1mW0dSvERfwlSZ64tDT4vb4zj7KTQ+eadHrwESHy4NXt1UDAFZWjNP8/Xo043ZGO/KcQNNDDFqIiBLE9lMt+Nn/24MTjV3q17481YJr5o6J2zV0OdzqWLN/eUhdMBeHoKWlywGPDEgSkB2iPJSmU3no/X21aOrsQ4HNistnFGj+/vx0pTwUq7Hn6pZunGjsBBAYRIaD00NERKSb3288gRONXUi3mlDo7Y1o9WYc4kWUhpLMBjVQAfxW+cfhA7DZ21OTlWKBKcRhhaIRt9vphscTu1OM/7T5NADgny8oC/ugRH/5tthtxZVlGQ/9bR/6XB4smpCtub9GlIfsCZRpYdBCRJQgatp6AABP3TgXl07PB+A7uC9eRMCQkxrYSyKaQONx/lBTh7c0lBY6syB6WmRZCVxiYd/ZdlSeboXJIOGmC0oieo0CW+Q9LW/uOIOL//tTvLatCrIs48P9dfj0cCPMRgn/ee0sSJKk6fXEYr5EWi7H8hARUYIQ/zovykhGpnc/SHtPfIOW/jtaBL1PVfY3WBMuoGR+LCYDHC4PWrscmptUg/nLl0ovy5WzitSdK1qJ8lAkQcvaPbU43dyNf39zL9YfasDeM+0AgB9dPBGT8tM0v544N8ke5/8NRYOZFiKiBNDncqPJW5opzEhSR33F6G+8BNvRAsS3p0UELTkDBC2SJKk9Hi0xKqEdqe8AACzxZrkiIf67tUXw380/QF13oB519l6UZqdg1dcnRXQtImiJd+AbDQYtREQJoMGufFBbTAZkpZjVpWbxLg/1X+EvxLOnRQRvA5WHAF9gJUpa0arzy3RFKsMvQybL2nptRHDxwLLpmJyfBovRgP+6biaSzNqWyqnX4g1aOvtccLnjc2ZUtFgeIiJKAOIDs9CWBEmS1PXxkfyLPRqhykNq42scMy0DlYcAv6ClM/qfkSzLqG0XQUtkpSHAFyg43TJ6nR51v004RNBSMTEH31s8HvYeJ7I0Tgz58z8h297rOue/6XDETAsRUQKo835gFno/MEVPS7zLQ6FKM3oucwt1DXmDBC2xLA+1djvVUW8xARSJVIsRRoPSMKu1LCOen5FshtEgRRWwAIDJaFB7fRKlRMSghYgoAahBi00ELaI3YniUh+K5EdcXOA1WHlKCi1gELbXtyuRWbpoVVlNk5RhA6bURGQ4tgUKv07cfR2RrYiHR+loYtBARJQBfP4UStIiGzo7e+PYjhJ4eil+mpVntaRkk05ImelpiELS0RV8aEtSpHQ2nK4ugwmiQYjIJJaRHEEANJQYtREQJQGRaxIF7GclmiLUcbXH8wBEBQ3ZaqJ4WfTMtsiz7gpb0+JWHau2B5blo2ER2Q0OWTAQVtiST5n0sAwmWaenodaKt26G5UTgeGLQQESUAUZ4Q/9I3GiTYkuLfjBuqPKRmWnQ+5dne44LDm1kabG29b3oo+p9PXb+ffzQiKcn497PEUrBreXVrFeY+vA7/9vrumL5XLDBoISJKAPXekecCvw9NXzNufDItPQ43erzbZc/d0xKfnpZGbz9LutU06KivWh7qjH7k2Tc5FP3hlLZIykPd+gYt/gvmQu3iGQ4YtBARDXMej+y3Ddc/aIlvM67Yd2LxmzoR1D0tOve0iABksNIQENtG3LoYjDsL0WRabPEIWkKUAIcDBi1ERMNcU1cfXB4ZBilwzDcrzmPP4sMsJ81yTl9Fqt/ZQ3r2QoS7WA7wZQq6HW70Rnn+UG17DHtakoZ3eUgEp7mpkY9264VBCxHRMCf+lZ+Xbg041TialfCRCDU5BPgyLW6PjD6XftNM4S6WA5SmVbNRCa6i6WtRFsvFvqfF3hN+KU23oCXIGVb+welww6CFiGiY67+jRRAfYPHqaRmo10GcPQQovS960RK0SJKkXmtLFFtx23uc6HUqgVhBhAcl+hvujbjNYZztNFQYtBARDXN1IcZt459p8X6YBQlajAYJVpPykaJnM26TxiyA6GuJ5vwhURrKSbVEfM6PP1uyEuBpOV3ZrlPQYusXtMiyjKYQE2LDAYMWIqJhLlSmJStVjDzHO9MS/F/g/n0tetGSaQFis6ul/xEK0YpmuVzMg5Z+/TWdfS518y7LQ0REpJnvQzNw3NZ30nOcMi2DZDmSvVmILh1PetYatGTHIGipiWE/CzC8y0Pi55RiMQaU/IYLBi1ERMOcb3Il8IPad9JzfDItIjgSZan+Ur1bcePR05KXHm55yOL9vuGTaRmO00MdvS64PbLm8lu8MWghIhrmxI6WQlu/TEtyfDMtYtol1Aen+Jd5l45BizrZEuY4rq88FH1PSywWywG+n1+3ww2nd7tvdUs3rnhqI/6262zQ79F7TwugrO9Xm3CH4bgzwKCFiGhYU8Ztg/9L338jbjzOiRE9GKGCllSdzx/qdrjUfplwlssBvgmYWPS0xKo8JA4pBHwNtu/vq8Whug78z0eHg/631CvTYjEZ1LKevcel9i2FswdnKDBoISIaxuy9LnV1/rmNuMoHi8PlUUdy9eT7137wXodks76NuE0dygdqktmAVEt4UzyxOH9I7GiJVXnI5LdRWPxMRWBa3dKD/TX2gOf3Ot3q7huxVyWW/PtaRKZlOK7wBxi0EBENa+Jf+RnJZiT3+6BOtRjV5WnxKBGJrIDoyehPZFr0asRt9GvCDfekY9GbEWmmxT/TFavyEOA/QaT8rMR/ZwB4b29twHNFhssgAWk6NMf6By2+nhaWh4iISKO6IGcOCZIkISNOfS1Ot0ftVRmsp0W3TEsES8+iXS5n7/WVpPpnuqLRfz9Kbb+gxb9EZPfrZzEYwgvWtAjItAzjHS0AgxYiomGtzluaCLWJNV4TRB29vuyJf0+GP71PehZNuHka+i3Eh29Hnwt9Lu3BlMiAZKWcm+mKhi0psDzkn2k51dyNg7Ud6p/bB8lwRX0tyb5rEQ3L4Y6UxxuDFiKiYayuXfkQCdUEmhWnXS3igzPNago4/8if6DPRa+RZ644WQPmgN3qzE61d2gM7Xz9L7EpDQODpyi63Bw0dStAyrzQTgNKYK+jVhCvYAnpaOPJMREQRqvd+mOWHyLRkxinT4utnCd1TkeJtLu3qGz5Bi8Eg+e1q0T72HOvJIcG/JNPQ0QePDJgMEm5eVAYAeNevRKR30BK0p4Ujz0REpFW7NxjJCjE1Eq/zh8LZEyIyLXqNPDfYRU+LtixANKv8Q42bR8vml2kR71FgS8KS8gJYjAacaOzCkfpOAL7/DegdtLR1O/zKQ8y0EBGRRiJYyAwRtPjvatGTmGAZKGhJ1rkR91CdMgo8KT9N0/eFs8rf7ZHxxvbqgN4SQFn6BgBjMnUqD/U6A7I5tiQzvjolF4CvRNTuXeoX68Vy/a/ldHM3PN7+3yw24hIRkVZtPcoHrdh+21+8zh8abBsuoG+mxd7rxKlmJYCYUZyh6XvD2dXyx89P4t6/7sEj7x4I+PrRBiXboTVQGox/Sab/HpiLp+QBAHZVt6nP8f+eWBOve6JJudfMFDPMIfqWhtrwvCoiIgLg61UJ9a/seE0PhTPBomdPy0HvwrXijCTNi88GW+UvyzL+/GUVAGC3N1AAAI9HxjFv0DJZx6BFZFqKvdmc6UU2AMAh7wRRvIKWelF+G6ZZFoBBCxHRgD4+UI+LHvsEG440Dsn7D14eik9Pi688NEAjro6ZFrEltlxjlgUAslMHXuVfeboVJxq7AABnWnvQ4b3Xs2096HG6YTEaUJqdEsllhyR+jvYeF2rVs6WUTMvUwnQAyo6e1i5H3IIWYbg24QIMWoiIBvTOnhqcae3B/+/NvbqeXhyMy+1R96NkhvjAitf0UDgfnL6gJfY/JxG0zCi2af7ebG9TaXOIBXOvb68O+POReiXDcbRB+b8T8lJDjnlHKqA81KaUh8SEUnqSGSXZStblYJ1dndzSe+RZGK7jzgCDFiKiAdV4P1DOtvXguY0n4vredr+FbqHLQ/HqaRm8PJSqYyPu/pp2AMDMMdozLbkD9LR09rmwdo/S8JrnPYTxUJ03aPFO70wuSNd+wYMIVh7yn1CaXqgEZwdrO+KfaWHQQkSUmGrafNMkz2w4pgYx8eC/0C1UY6ToaWnvccLj0e+k57AyLVbfRtxYnjrd63SrDbERZVoGmB56d08Nuh1uTMhLxfXzxgDw9ZIc1amfBfAFf/ZeJ+o7xAJB34TSNLWvxc7ykB8GLUREIbjcHvXsnykFaeh1evDo+4fi9v6iT2WgDyvR0+KRfX0nehBZn4HGbsXZQ7IM9VTiSLT3OPHMZ8fR6P0wP1LfAbdHRlaKOaIlbzlqeejcRtzXt58BANywoATTipSMyuG6OAQt3p+jLCvj1kaDpGZ6AKDcey2H6vTPtCSZjbCYfOHAcN3RAkQZtDz66KOQJAl33XWX+rXe3l6sWrUKOTk5SEtLw/Lly1FfXx/wfVVVVVi2bBlSUlKQn5+Pe++9Fy6XPsuIiIgiVd/RB7dHhtko4dffmgtJAv6+u0YdRdVbWxgfVhaTQR011rOvJZy+imSz72yeaE56/vO2Kjz2wSH89I3dAIB9Z5V+lpljMsI+3dlfXpoS6Nh7Xeh1+kpXxxs7UXm6FUaDhOvPG4OpBd6STJ1dmRzy9rboUR5KMhth9QsUCtKt6nEDADDNWx46XNeBHufAB1XGgv9rD9cTnoEogpYvv/wSv//97zF79uyAr999991455138MYbb2DDhg2oqanB9ddfrz7udruxbNkyOBwObNq0CS+99BJefPFFPPTQQ5HfBRGRDmrUBslkzBqbgcumFwAAtp1sjsv72weZHBJEtqVFx74W30nDoaeHjAZJDVyiGXsWPR4bjjTiYK1d7Wcpj6A0BCjXnGRWPu7EVl0A2HOmDQAwvywL+elJmJifCpNBQkevC5VVrehyuGE2SijLie3kkO+6fP9d+2/cLc1OQYrFCIdbyVhJUuiDKmMhIGgZaSPPnZ2dWLFiBf7whz8gKytL/Xp7ezuef/55PPHEE7jkkkswf/58vPDCC9i0aRO2bNkCAPjoo49w4MABvPzyy5g7dy6uvPJKPPLII1izZg0cDn0byYiItDjbqgQtxZnKB4r48GoKMYUSayJzMljQIno2WiNYUx8OWZbV0tNg/9oXpZjGCM75Efybin+/4bjf5JD2JlwAkCRJPSVbnOUE+A6jHJul9JJYTUZMyEsFAKzdXQMAGJ+bqtuiNf+fZVG/AxkNBkkdfQaAdKsJBoP2LFMk1zLiMi2rVq3CsmXLsGTJkoCvV1ZWwul0Bnx92rRpKC0txebNmwEAmzdvxqxZs1BQUKA+Z+nSpbDb7di/f3/Q9+vr64Pdbg/4RUSkt7PeTMuYTCVYET0HotdCb21hnjmTFcXZOuHocbrhdCuNtQNNDwFQg4MGe++AzxuIf5nrnT21OOANWmZGmGkBgIJ0b9Bi9w9aAkeNAV9Z5t29dQCAyfmxLw0JGQNkWgDfkjkAyBgkcI3ltYyonpbXXnsNO3bswOrVq895rK6uDhaLBZmZmQFfLygoQF1dnfoc/4BFPC4eC2b16tXIyMhQf5WUlGi9bCIizWrUoEX5QIl30OJrwBz4QySaAwHDIVb4Gw2SuosllAKb8jOqiypoUe4j1WKE2yPD4fYg1WLEuJzUiF8zX1yX39lC6mGIfidoi2ZccSL05ILYN+EK/idmB2swnu6XadGzn8X/9Y0GadDAdChpClqqq6tx55134pVXXkFSUmxPvBzI/fffj/b2dvVXdXX14N9ERBQlkWkR69VFQ2fcMi3i3KEwy0N6BS3+0yuDNcKqZRh75D8j0YD8L1+ZoH5tepEtqvKICEwa/P7biaxLof+ocWFgZmXYZFp0DlpEAJWdatG1DBUtTUFLZWUlGhoacN5558FkMsFkMmHDhg14+umnYTKZUFBQAIfDgba2toDvq6+vR2FhIQCgsLDwnGki8WfxnP6sVitsNlvALyIivamZFm/Pg5ppiaJfQ4v2MMtD4RwIGA11hX8YjaCxKA+J3pxvzilCufeDO5L9LMGuy788FDTTUhj4PnpmWgbqaQEQ0NMSr0zLcG7CBTQGLZdeein27t2LXbt2qb8WLFiAFStWqL83m81Yv369+j2HDx9GVVUVKioqAAAVFRXYu3cvGhoa1OesW7cONpsN5eXlMbotIqLoyLLs14gbGLS0dDngdEe+hyRc6rlDYQYtejXihhs8AdGXh9weWd0Jk5liwerrZ+GSaflYeeG4iF5P6F8ecro9avDpn+UoykhSp3RMBimqktRgbAFBy7mZFv91/rpnWryvnzuMm3ABQNP8VHp6OmbOnBnwtdTUVOTk5Khfv/XWW3HPPfcgOzsbNpsNP/7xj1FRUYFFixYBAC6//HKUl5fj5ptvxuOPP466ujo88MADWLVqFazW4f3DIqLRw97jQpd3HX2x91/BmclmmAwSXB4ZzZ2OoCn9WFL3tIRZHtI90xJO0BKk4VULEagBygd1bpoVf/zu+RG9lr/+5aHGjj7IMmA2SgHZBUmSML3Qhm2nWjAuNzVg6VqsiUDEICFgsZy/aYU2VLf0hPWzj8bC8TlIs5rwtal5ur5PtGI+9P3kk0/CYDBg+fLl6Ovrw9KlS/G73/1OfdxoNGLt2rW4/fbbUVFRgdTUVKxcuRIPP/xwrC+FiChiop8lJ9WCZG/zqcEgITfNijp7Lxo7+vQPWsLMcOjdiNveoyFoyRDlochKaKIJN32Aowsi4V8ekmVZzQTlpyed08MxrSgd20616LIJ15/4eealW0Pe69VzirHtZAsumpSr67XMGpuB3b+4PGDB3XAUddDy2WefBfw5KSkJa9aswZo1a0J+T1lZGd57771o35qISDc1/Zpwhdx0ixK0dPYCiGxvSDhkWfZbLjdwn4HejbhieiicqRIRHHT0udDV50KqVdvHTGt3eNklrcR1dTvc6OhzBT2kULhhQQk2H2/GTReUxvQa+sv3ZldKs0Mvr/vmnGJ8Y3ZRRJuAtRruAQugQ6aFiGgk8E0OBX6o5aXFZ+y5x+lWt6GG29PS2edCn8sNq2ngsWStwl0sByiHO6ZajOhyuFFv78WEPG3ZinbvxFTWIIGaVskWI2xJJth7XWiw9w4YtMwck4F191wc0/cP5qJJubj/ymlYPEgWJR4BS6LggYlEREHU9FssJ8RrV4soDZnC2I1iSzKr/0pu7Yr9+UPtYazw9ydKRJGMPYvrH2zMOxL+49iiPOQ/ORRvJqMBP7x4ImaO0S9jN9IwaCEiCiJkpsUbtOi9yr/d79yhwf6lbTBIamaiuSv2wVQ4hyX6E824DR3am3HbwiyJRcK/r0WMO0dyajQNHQYtRERB+Fb4B/a0xKs8FG4TrqBnM66aaQlzU2pBkO2z4RKNuIOVxCKR7zeOXe+9toIhzLSQdgxaiIiC6L9YTshLj89W3HZ1G254GYesVOVDXo+gRexNCXfsNpqtuCJYy9KhPKSOPdv7UGs/99whGv4YtBAR9eNwedR9Hv2nh+K1FbddY0kmJ9W3+C7WNJeHgpyoHC5xwnOGjuWhuvZe1HtPeGamJbEwaCEi6qeuvReyDFhNhnPWmse7ETfcMomeY8/2nvDX+AN+QUsE5SERrOmRaRFlq0N1dnUyi0FLYmHQQkTUj38/S/8mWBG0dPa50O1w6XYN4W7DFfTaiuv2yOjoU+4z/EyL8jOKJtOi5/TQqeZuAMrKej033lLs8b8WEVE/oRbLAUCqxYhkszKC3NSh3wSR5vJQmjfTEuOppo5e3wh1JD0tsixrej81w6RjeUgozODRMYmGQQsRUT8iaAnWpClJkl9fS+QnGQ+mXWN5SIw8t3THNmgR23BTLMaw1+qLKR2HyxNwllA4tJbFtMhLt8I/cVZoOzcopeGNQQsRUT+ixBLqELtcb1ZDz76WNo3TQ3qNPGsddwYAq8mo9qRoOe3Z6fag01uKivVGXAAwGw1qwzLATEsiYtBCRNSPCFqyU4N/cMajGVdreSg7TZ+gRcsKf3+RjD2LLIskhV+K0kr02wBAUQYzLYmGQQsRUT8t3q2yok+kv3gELW0aDw4UAVZrtwNuj7Y+koFoXeEv+G+fDf+9lIDL/1iCWPPva+HkUOJh0EJE1E9zp8i0BC8f5KV5F8zpuMpfXeOvsadFlqG5j2Qg9gjKQ4DfBJGGsefWbv3OHRL8AxUulks8DFqIaFjqcbiH7L1Feaj/jhZB70yLy+1BR6+2MWOz0aDuUWmJ4flDWstUQiQL5vScHBL8y0PMtCQeBi1ENOx8cqge0x/6AC9vOR3395ZlGa0iaBmsPKTTVlyxNh/QFizkeM9Fao5hBkj0tGjtMYmkp6VVx3OHBP9ApZCZloTDoIWIhp0vjjUDAP7yZXXc39ve44LL2xMyWCNuk06ZFpHdSLeaYApzzBiIbituTVsPlj+zCe/vre33dSVTorVkE1FPi47nDgki05JuNSHNqq1Ph4YegxYiGnZE2WVfTbsua+kH0uwtraRZTbCajEGf418e0ro8LRzipGOt2Y1odrW8t7cWladb8dgHh9R7crk9+OxwAwBg4fgcTa+n9rQMELS43B787ydHsau6DYD/Nlz9ykPlRRmwmAyYV5al23uQfhi0ENGwI4IWWQa+ONYU1/duGWTcGfDtaXG4PerytVgSK/y1ZjfUXS0RlIfqvA2zp5q7cbC2AwBQeboVrd1OZKaYcf44bR/y4kTlxo6+kNNM7++rw/98dAT3/XUPgMjvW9N1ZSRhy/2X4vmVC3R7D9IPgxYiGnb8e0X+cbQxru/d1Dl40GI1GdVek2i34va53Odka+wRfniLXS2RnD/kvwTuPW+JaN2BegDAJVPzNZWpAKW/xiABHtmXvepvtzfDcri+A40dfWqGSc+eFkD5bxvudl8aXvhfjYiGHf+pnM+PNulSggmlZZDJIUFkWxqi6Gs53dyFOf/xEX76xp6Ar6s7WjR+eEezFbe+X9AiyzLWHVSClsvKCzS/ntEgqSPjoaas9pxtV3+/+USzet9Zg/zsafRi0EJEw0qv0602ohoNEmrae3G8sStu7z/YYjkhFmPPladb0ev04P/tOBOQUdp8XGlEzgmxJyYU0dPSGkFPi3+m5URTF9buqcXp5m5YTAZ8dUqe5tcDBv4ZeTwy9vsHLceb1D0tWoM1Gj0YtBDRsNLkLQ1ZjAYsHJ8NAPg8jiUi3wr/gQOGvHRfz0ak/DMiD79zAC63B+/vrcUH++tgNEj49vklml5PLQ9p7GmRZVkdTZ5WmA4A+I939gMAFk/MQWqEUzb53qAlWDbqRFMXuvx28Ww63ox2b7Clx7lDNDIwaCGiYUUEAXnpVvVf+P84Gr9m3HDLQ3lp0e9qafILLo42dOK3nxzDg3/bBwC4/eKJmDkmQ9PrRVoeau12wuHyAAC+t3hcwLVdVl6o6bX8DZRp2efNskwtSIfRIOF0c7ea7dGzEZcSG4MWIhpWxAdcbroVX5mcCwDYcqJZ/VDVWzjTQ0BsykOiFDU+NxUA8Jv1R9HU6cCUgjT8+NJJml/Pf0+Llj4g0c+SnWrBlbOKYPFrUl0yPV/zdQgD/Yz2nFGCloqJOZg9VgnOxJCRniPPlNgYtBDRsCIyF3lpVkwvtCEn1YIuhxs7q1rj8v7quUNh9rQ0RbF9VrzXv3xlvFqWMUjAf//TnJA7YgYighaH2xNQehmMyHAU2JJgSzKrweLckkzkR7HqfqBslMi0zByTgYoJvh0wBklZ/EYUDIMWIhpW/MtDBoOExZOUD9CtJ1vi8v5iPHfQ8lAMMi1N3qxOXpoV/3XdLOSmWfDTpVMxpyQzotdLsZiQbFaCnWYNZStxqGGhdyHcD746AXnpVtz21QkRXYcQ6mfk9sjYX6MELbPHZuDCibnqY5kpFhh0OuGZEh/DWSIaVsQHnGjinFqYDuwGTjXrP0Eky7KvpyVtkEbctNiVh3LSrJhfloXtD1wW8WsJBTYrTjV3o669F2U5qWF9j8i0iLN4Fk3IwZc/XxL1tYQ67uBkUye6HG4km42YmJeGkqwUWIwGONwe9rPQgJhpIaJhpcEv0wIApdkpAIDqlm7d37ujzwWnW2msCDfT0tIVeuPrYER5aLD30qIoIxlA4AjzYOr9ykOxFGp6aK+3NDSj2AajQUKyxYi5pZkA9F8sR4mNQQsRDSuNIYKWqjgELWL9fYrFiCTzwD0l2amWQTe+DqTH4Ua3t+9ksJ0wWhR5syW17aGDFk+/IKtOLQ/FNmgR/w07+1zodviOOxBNuP7TURdOVPpaBmuAptGNQQsRDSuhgpZ6ex96neE3l0aiOczJIUBZfJcTRYlIBDoWoyGmpw2LEk9tW0/Qxz8/2oQLfvUx7nl9l/q1Ou+OloKM2AYtaVYTkszKx0xTh69hWTThiqkhAPjnC0pxeXkBvnvh+JheA40sDFqIaNiQZTlgeghQdnaIaZIzrcE/iGMl3B0tQm4UQYuvd8YCSYpd4+lAmZbXt1fjuy9sQ1OnA2t316pj5Gp5KD22QYskSb5mXO8ZTW6PjH1n7QCAWX6ZlnxbEp67ZQEumpx77gsReTFoIaJhw97rUj9IxYedJEkYG6e+FtEYG26JIpoJouYwDmaMRGGInpbffHwUP/vrHri8pSGH24NDdXb0udxqAFUY40wLcG7D8onGTvQ43UixGDEhLy3m70cjG4MWIho2xAebLckU0FNSmq18EOvd1+I74Tm8M3+i2YrbHOaUklbBMi1n23rw5MdHAAA/vmSSuml4d3UbGrylIYvJgCwdJnf6B3aH6joAKFNhRo42k0YMWoho2GjoUD5oxQedEK9mXJFxyA2zMTa6TEt4+2C0EkFLU2efmrU6Uu8NFArS8W+XT8Vc7x6YXdXtfpND1piWqYR8b8lJTBCJaxHL9Ii0YNBCRMNG/yZcId5BSzzKQ1r7Z8KVnWqBxWiALPuCwBPeU7In5Cl7W+Z4G2B3n2nz7WiJ8eSQ0P9ndNibaZlSwKCFtGPQQkTDhi9oCfwALYlTT4uW6SHAf5W/9qClKczjArSSJMk3QeQtEZ1s6gTgO+No9thMAMDxxk4ca1Aei/WOFqF/0OKf9SHSikELEQ0b/SeHBP+gRctBgFr5NtSGGbRENT3kPRgyzP4ZLc4NWkSmRWl8zUu3YkxmMmQZ+PhgvfI9egUtfn0/vU43TnsDzyksD1EEGLQQ0bARqjw0JjMZkgR0OXyTLnpo0dqIG01Pi8asjhbF3qClrl0ZET/pLQ+JTAsAta9FjB/rMTkEBP6MjjV0QpaVe86NcQMyjQ4MWoho2Oh/7pCQZDaqmQC9+lpkWfZN9GgsD9l7XZoX36kr/GNcHgJ8Y8+17b3odrhQ4824TPALWuaUZAR8j97loabOPhysVQKkKQUcdabIMGghomEjVKYF8JWI9Apauhxu9HmnbcINJGxJJlhM3o2vGvtafKdJxz7jUKRmWnpxqkn5eWWmmJHlF4yJvhZBr6BFZFScbhnbvCd1s5+FIsWghYiGjYGCFr0PThSloSSzASmW8NbqS5IUUV9Lt8OFXqe2AEkLUeqpae9V+1n8S0OAso3Wf02KXj0t/vtfvjjWBID9LBQ5Bi1ENCw43R60dCuBQ9BMS5YIWvRZ5R9p5iM3gr4WURqymgxIsQx8MGMkisVW3PYedXJoQm5gSSbVasLkfF/wkG/Tr8dE/PcUZSpmWihSDFqIaFho6XJAlpWDCLNSzs0+lObouxVX644WIZKtuM3qEjt9FrqJTEtDRx+O1HuDlrzUc54n+lqyUsyDnmodjf5B6GQGLRQhBi1ENCyITEVOqiXoevdYLZiTZRl//PwkNh5pDPj6tlNKv4XmoCWiTIu2M460ykm1wGyUIMvA1pPNAM4tDwHAHO8EkV79LIL/CHuhLQkZybE/LoBGBwYtRDQsDNTPAvgacWvbe9T19JHYc6YdD689gFv+uA3PfHYcsizj1a1V+P2GEwCAb8wu0vR64QYtJxo7UectjzR36Tc5BAAGg6QGIvXes4WCBS1XzCjEgrIsrLxwnC7XIeT7BUXsZ6FohNdtRkSks1DnDgl5aVYkmQ3odXpQ09aDcUE+hMNxqrlL/f1jHxzClhPN2HhUybqs+vpEfGtBiabXCydoOdbQiaue/gdyUy3Y8LOv63bCs7+ijCScafX1/wQLWnLSrPjr7Rfqdg2Cf6ZlKsedKQrMtBDRsCAyAgXpwUsVkiSpzbjRlIhq2pTgSCys23CkEbIM/PPCUvz08qmaX098IA808vzkx0fgcHlQ096LLSeafdtwdVywVuRtxgWUe9WzZ2Uw/oEozxyiaDBoIaJhwf+04VBi0ddS690Se+28Yjx38wLkpVvx7QUleOSamRE1xaqZlhBBy8FaO97dU6v++b29tXHLtAjBsizx5B+0TGV5iKLA8hARDQtqpmWAdfJjs5Tswdm2yMeea7zfW5SRjMvKC7Bken5UEzz5fuUhWZbPea0n1h0BAIzLScGp5m58uL8e5UU2ALE/4dlf4TAMWiQJmJTP8hBFjpkWIhoW1ExLiPIQAIz1lof8ezW08i8PAYh65FiUeHqdHnT2uQIe23OmDesO1MMgAb+/eQGyUsxo6XKoEz16NeICwyvTMjEvDRdPycMti8rCXtxHFAz/10NEw4KvPBQ6aBkjMi2tUfS0eMtDxZnJgzwzPMkWI9KtJnT0udDY0Yf0JN84768/UrIs184dg6mF6Vg6oxCvfVkNp1s5qVqPFf5CoV9PS7AdLfFkNEh46fsXDOk10MigKdPyzDPPYPbs2bDZbLDZbKioqMD777+vPt7b24tVq1YhJycHaWlpWL58Oerr6wNeo6qqCsuWLUNKSgry8/Nx7733wuVy9X8rIhpFXG6P2shakBH6g1yUhyLNtHQ7XGjrdgIAijJjt5skz9uHU+cNvACgvceJDd5dMD+5dDIA4MpZgePUeva0FPtlWvpvwyVKVJqClrFjx+LRRx9FZWUltm/fjksuuQTXXHMN9u/fDwC4++678c477+CNN97Ahg0bUFNTg+uvv179frfbjWXLlsHhcGDTpk146aWX8OKLL+Khhx6K7V0RUUS6HS7Ishz3923qdMDj3YY7UPZBlHQaOvrQ59J2qjLgKw2lW02wJcVuwZlatvI7YkCckZSbZlXHsy+cmIPMFN/76lkeyk2zYk5JJmaNyVAzVESJTlPQ8s1vfhNXXXUVJk+ejClTpuC//uu/kJaWhi1btqC9vR3PP/88nnjiCVxyySWYP38+XnjhBWzatAlbtmwBAHz00Uc4cOAAXn75ZcydOxdXXnklHnnkEaxZswYOh0OXGySi8OyoasWMX3yI1e8fivt7i9JQXpo16DZcITvVgmTv6K4IQLRQm3BjmGUBgNLsc48YEL8vyfYFDGajAZeXFwAAks1GXfs7DAYJb91+If5+x+IBf6ZEiSTiRly3243XXnsNXV1dqKioQGVlJZxOJ5YsWaI+Z9q0aSgtLcXmzZsBAJs3b8asWbNQUFCgPmfp0qWw2+1qtiaYvr4+2O32gF9EFFubjjVBloHnPz+JU01dg39DDKn9LANMDgFK06w6QRRBiag2xv0sQrBRbJFpEY8Jy2YXA0Bcsh8Gg6TL2UZEQ0Vz0LJ3716kpaXBarXiRz/6Ed566y2Ul5ejrq4OFosFmZmZAc8vKChAXV0dAKCuri4gYBGPi8dCWb16NTIyMtRfJSXaNlYS0eBEn4jbI+Pp9Ufj+t6+yaHBG1PHqH0t2ptxz3qzM/EIWqpCBC1fnZyLx5fPxuP/NDum10A0GmgOWqZOnYpdu3Zh69atuP3227Fy5UocOHBAj2tT3X///Whvb1d/VVdX6/p+RKOR/+6Tt3adxbGGjri9t7qjJYyD+6JpxhXloeJBMjpaiXORqoOWhwKDFkmScMP5JTivNCum10A0GmgOWiwWCyZNmoT58+dj9erVmDNnDn7zm9+gsLAQDocDbW1tAc+vr69HYWEhAKCwsPCcaSLxZ/GcYKxWqzqxJH4RUWyJcktRRhJkGXjy4/hlW0SmpTCMYGJMphIERLJgTq/ykAhMmrsc6PLuaglVHiKiyEW9XM7j8aCvrw/z58+H2WzG+vXr1ccOHz6MqqoqVFRUAAAqKiqwd+9eNDQ0qM9Zt24dbDYbysvLo70UIoqQLMtqEPAfV88AALy7pxYHa+PTPyZGhfPDKA+NjaI8JJp3/c/liQVbklmdCqpu7Ybb4/t59s+0EFHkNAUt999/PzZu3IhTp05h7969uP/++/HZZ59hxYoVyMjIwK233op77rkHn376KSorK/G9730PFRUVWLRoEQDg8ssvR3l5OW6++Wbs3r0bH374IR544AGsWrUKVqt+S5aIaGBNnQ70uTwwSMDXpuZj2Wxln8ift1XF5f0bNJSHxkTYiCvLsloeGhPjTAvg19fS3I06ey+cbhlmo4TCMO6JiMKjad6uoaEBt9xyC2pra5GRkYHZs2fjww8/xGWXXQYAePLJJ2EwGLB8+XL09fVh6dKl+N3vfqd+v9FoxNq1a3H77bejoqICqampWLlyJR5++OHY3hURaSKyAgW2JFhMBnxtSh7e3VOLk3GaIqrvGHwbriAyLUpg4IHZGN6/vVq6lMBMkgZeYBepkuwU7DnTjqqWbnUr7tisFI4bE8WQpqDl+eefH/DxpKQkrFmzBmvWrAn5nLKyMrz33nta3paIdCayFiIDIbIGp5sjX5cfrl6nW91SG05WIjfVCovJAIfLg7r23rDLL6I0lJtmhdVkjPyCQyj1a8YVi+tYGiKKLR6YSERqf4govZTlKBtcz7b1wOn26PreojRkNRlgSx7831EGg4Sx3uCqWkNfS6zPHOrPf+zZN+7MTbREscSghYjU8pDItOSnW2E1GeD2+PpA9OJfGgp3EVokfS16jTsLaqaltSfkjhYiig6DFiLylYe8wYDBIMWtRKSOO2toWA1nV4vL7cHP39qLn7+1F26PjNp2fRbLCSVZvvLQabGjJYtBC1Es6XfwBREljP6ZFgAoy0nB0YZO9QNYL3XeYCLfFn5zrHpA4QBByxPrjuCVrcr008S8NPUe9QpaijKTYDRI6HN5cLBGGRVnTwtRbDHTQkRqpmWsX2agNFvpa6lq1neCqKEj/HFnQQRXZ9uCB1QfH6jH7z47rv758Q8PYXd1GwD9ykNmowHF3oMYHd4+oNIcBi1EscSghWiUa+9xosO7xdU/0xLs5GI9xLo8VNXcjXte3wUAWFlRhgsn5qDX6VGfq1emBQjsYclMMatTREQUGwxaiEY5kWXJSbUg2eIbBRYTRHr3tERSHhK9N3XtvXD1m2766Ru7Ye91YV5pJn6+rByPLZ+NFL/7KsrUb9mbf9DCJlyi2GPQQjTK9R93FkRpo6qlG7Is6/b+kZSH8tOTYDZKcHlk1Hu/HwAcLg++PN0CAHjihrmwmAwoyU7BfVdMAwAkmQ3ITdVv+7Z/Dwv7WYhij424RKNcsCZcQCnBSBLQ7XCjqdOBvDDOBdJKluWIykNGg4SijGRUtXTjbGuPeu319l7IMmAxGlDmFzTcvKgMnX0ujM1KhkHHDbX+00KcHCKKPWZaiIaRE42d6HO54/qe/bfhClaTEcUZoq9Fn2bcjj4Xuh3K/WopDwHBD06s8zst2j84MRgkrPr6JFwzd0y0lzwgloeI9MWghWiYeH17NS759QY8+v6huL6vmmnJOrdBtcTbjKtXX0uDN8hITzIhxaIt8Ts2yII5sUCuUKcJocEwaCHSF8tDRMNAe7cTq987CADYcbo1ru8dqjwEAGXZqdhyoiWmE0ROtwefHW7E1hPN2HKyGYC2fhZhTOa5u1rUBXJDFLRkppiRn25FU2cfJuWnDck1EI1kDFqIhoHfrD+KVu+hgdUaVtPHQrAdLYLajBuDTEtrlwOvbqvCy1tOq8GF8JXJuZpfTy0P+e1qqfUGYEU6jjUPRJIkvPC989Hc6RiybA/RSMaghWiIHWvowJ82n1L/3NLlQEevE+lx2PHR43CjucsBIHh5qMwbtES7Fberz4UlT2xQ3ys3zYIrZhZiXkkW5pZmYkJuqubXDHb+UM0QZ1oAYEZxxpC9N9FIx6CFaAjJsoyH1x6EyyNjyfQC7KhqRUuXA9UtPSgv1j9oERtl060mZCSf+35l2bHZ1XK4vgPNXQ6kW034xdUz8M05RbCajIN/4wBEpqWmrRcejwyDQUKt9yTnogyerkw0ErERl2gIVZ5uxcYjjTAbJTywbLq620PvLbTCmdbQTbiArzzU1NmHLu/W3EiI8lJ5sQ3/NH9s1AELoIxIGw0SHG4PGjuVXS21bUqmRc8FckQ0dBi0EA2hTceVRtSlMwoxLjdVnTipjlPQcrJJGWUuC3FGTkayWc3ARBNIie8N9T6RMBkN6m6XM63d6HX6Sl3FzLQQjUgMWoiG0M4qZVJoQVkWgPid9yOcaFSClgl5oSddynKiz/6I8lKsx4DH+J1BJI4DSDIbkJnCM3+IRiIGLURDRJZl7PSePDyvVAlaxBbV6tb4BC3HGzsBABMHCFpEoHE6itOexXK60hztDbcD8T84scbbz1KckQxJ0m/rLRENHQYtREPkZFMX2rqdsJoMmF5kA+ALEOKfaQkdTIz3TvacbIo+01IW40yLGNP2z7Rw1Jho5GLQQjREdla1AQBmjcmAxaT8v6JoxD3T0gOPR79DCgGgs8+lrr2fmBs60yICGpGV0arH4VYPRYxlTwsAjPXuYznb1qPufuHkENHIxaCFaIjs8PaznOftZwGAoowkmLwTMfUdvaG+NSZOerMsuWkWZAzQAyJKRyIro5UoddmSTMhMsUT0GqH4nz8kVvgXc3KIaMRi0EI0RESmZV5Jpvo1k9GgNpfGYgvtQETmZMIAWRbAVx5q6uxDe49T8/uoTbgxzrIAgQvmRNDCTAvRyMWghWgIdDtcOFRnB+BrwhVEM67efS0nRBNu/sDNselJZhR4T2A+EUGJSDTwikV1sVSUkQxJAvpcHuyrUX6e3NFCNHIxaCEaArur2+GRlXXz/RtHRV+L3mcQHRdNuINkWvyfE0mJSARfemRaLCYDCtKVn1+jt2+GO1qIRi4GLURDYGe10s/SP8sCIG4L5o6HmWnxf04kzbjqYrkYTw4JY/tt82WmhWjkYtBCNATUfpbSzHMei8fYs8cjq9twdc+06NjTAgQeQZBmNcEWh4MmiWhoMGghijNZlv2CltCZFj2DlrNtPehzeWAxGs7JVAQzMV8JWrRmWtweWZ0eivU2XMH/+ou4o4VoRGPQQqPe1hPNaj9EPFS39KCpsw9mo4QZxbZzHhcf7o0dfehxuHW5BhF8lOWkwGQc/K+BCbm+055dbs+Azz3Z1IU9Z9oAALXtPXC6ZZiNkm5TPWLBHAAUZbKfhWgkY9BCo9q6A/X49nNb8O//b0/c3vPjg/UAgHklWUgyn3vacUaKGelJJgDK/hE9hLMJ19+YzGRYTQY43B71ZOhg+lxufOvZzbh2zRfYd7ZdLQ2VZKXAaNBntf4Yv0ClyMZMC9FIxqCFRrVXtp4GAOw52x6393x/Xy0A4MpZhSGfo3eJKJwzh/wZDJK6r+VEU+gS0WeHG9HU2QePDDyx7oiuk0NCQHmITbhEIxqDFhq1att7sPFIIwClFNPV59L9Pevtvdh+WpkcumLm0AUt4Zzu3J/a19IQuhn3b7vOqr//5FAD/rarBoB+k0MAUOyXaeG4M9HIxqCFRq2/bj8D/+N9TsdoA+36g/V49P1DWLunBmdauyHLvjf5YF8dZBmYX5Y1YI+H72RlvTMt4S98mzhIpsXe68THBxsAKPcHAJtPNAPw7Z7RQ5LZiLx0ZfkdMy1EI5tpqC+AaCh4PDLeqDwDADBIgEdWNreWB2mM1UKWZdz1l13o6PVlbeaXZeGl71+ANKsJ7+71loYGyLIAvrLN0YaOqK7lB3/ajh6nG3/87vmwmpT+mY5ep3qAYSwzLR/sq4PD5cHk/DQ89e25uOTXn8HpVgK2spzYb8P1t+prE/GPo004f1y2ru9DREOLmRYalbacbEZVSzfSrCYsmV4AADgVg6xGa7dTDVhmjcmAySCh8nQr7vvrHjR09OLLUy0AgCtnFQ34OlML0wEAh2ojD1qaOh34+GADvjjWjBe+OKV+/R9HmwAAuWlWZCSHv9NE3dUSItPy9k6lNHTtvDEoyU7Bt88vUR+L9enO/X138Xg8/93zgzY2E9HIwaCFRqU3titZlm/OKcb0IiW7Is7IiYY4tC83zYp3fnwR/vLDCpgMEt7dW4sf/l8lZBmYW5IZMPESzJSCdEgS0NzliHgcu8HvlOjfrj+Kho5etHU78Iu/7wcAfGvBWE2vJyaNmjodaO8OPDixrr1XLQVdPacYAHDH1ycjxWJEZopZtx0tRDS6MGihUae9x4n3vGWab59fgnG5sesfEUHLGG9vxfyyLPx82XQAvi24Vw0wNSQkW4wY7y2piIMVtWrwC3a6HG789weH8fDaA2js6MOEvFTceelkTa+XajWh0DtSfLxftuWd3TWQZWBBWZbav1KYkYR3f/IVvPWvi5kBIaKYYNBCo87fd9egz+XBlII0zBmbofZbxDLT4j/R8t0Lx2HZbF856MqZA5eGBFEiOlwXWYmo0a4ELSKr80blGby54ywkCfjvf5odUSChnkHUEBi0rPUGgdfMGxPw9fG5qeqoNBFRtBi00KjzxvZqAMANC0ogSRLGeYOWmvZe9Dqj20Bb266UZPwngyRJwmPLZ+Oy8gL8y0Xjw56kmVaolK0ORtjXIspDF07MwfV+wcT3F4/H/LLIGlYn5yuB1JF63zU53R4cqFH23HxtSl5Er0tEFA5OD9GocrDWjj1n2mE2SrjO+0GelWJGutWEjj4Xqlu6MbkgPeLXP6tmWgJHb9OsJvzhlgWaXkvNtNRHVh6q92Za8m1W3FIxDhuPNiI3zYqfXj41otcDgGmiQdgv+3OyqQtOt4w0qymsc4yIiCLFoIVGlde9WZYl0wuQk6bs9pAkCWW5Kdh31o5TzdEFLSLTUhyDM3CmF4msRidcbk9YZwT5E5mWAlsSCmxJ+Py+S2CQJFhMkSdYpwYJWg7W2tXHJEmfVf1ERADLQzSK9LnceMs7lnuD3zgugJj1tQTraYlUSVYKUixGOFyeiMaxRSNuvnfxWpLZGFXAAvimmho7+tDcqby+6LkRAQ0RkV4YtNCose5APdq6nSi0JeGrkwN7L8Z594iciiJocbk9qLd7My0Z0W9mNRgkTCkQmQ3tJaIGb3koLz12W2JTrSZ1fFkEKyLrMp1BCxHpjEELjRqve3ez/NP8seecOOzLtEQ+9lzfoRwUaDZKyPWWnqI1LcIJIlmW1f0uItMSK/37Wg6p5aHotgkTEQ2GQQuNCs2dffjHUeVwxGBL1cSBftFkWkRpqCgjGQZDbHo7RICgdYKordsJh9sDAOq5PLEigpNDdXa09zhR4+3jYXmIiPTGoIVGhRNNXZBlYGxWctBzcMZ5d4mcbe2Bw+WJ6D18QUvsyjEiQNA6QST6WTJTzDFf7DbdL/sjMkDFGUmajgQgIooEgxYaFaq8ZZ9QZ+Dkp1uRZDbAI/vGlrWqaVMyDoOt6NdCZFqqW3rQ2eca5Nk+YnIo1qUhwH8Uu0PdzzKtiKUhItIfgxYaFapalKAl1Bk4/kvmIi0R1bZ7My2Zscu0ZKVaUGBTAg8tfS2iCTc/hk24QllOKpLMBvQ6PfjoQD0AloaIKD4YtNCoUO0NWsZmhd5GK7Iwp5siC1piOe7sb5pfD0m4+o87x5LRb6pJHJI4jUELEcUBgxYaFQbLtAC+CaJIdqIAwNm22C2W8yeyGMf6nfczEDF6nWeLfdAC+IIUWRZ/ZnmIiPTHoIVGhXCCFnGwX6SnKovyUHFGbIMWcV0nNWSAxLhzgQ7lISBwvNlslDAhj4ciEpH+GLTQiNfrdKvlkoGClvPHKYcI7qhq03xwYrfDhbZuJ4Bzzx2KViRBi9qIq1OmxX+R3KT8dJg1HjFARBQJTX/TrF69Gueffz7S09ORn5+Pa6+9FocPHw54Tm9vL1atWoWcnBykpaVh+fLlqK+vD3hOVVUVli1bhpSUFOTn5+Pee++FyxX+ZASRFmdalSxLutWEzJTQY7kT81KRn26Fw+XBjqpWTe8hJofSrSakJ8V29FdkMapbutHnCh5M7TnThk8O+f7/zNfTolemxRe0sJ+FiOJFU9CyYcMGrFq1Clu2bMG6devgdDpx+eWXo6vL9y/Au+++G++88w7eeOMNbNiwATU1Nbj++uvVx91uN5YtWwaHw4FNmzbhpZdewosvvoiHHnoodndF5EeUhkqyUwY80E+SJFw4MQcAsPl4s6b30KsJFwDy0qxIs5rgkX0NxUJHrxM/f2svrv7fL/D9F7fjy1MtkGXZb3pIn0xLTppVXVrHoIWI4kVT0PLBBx/gu9/9LmbMmIE5c+bgxRdfRFVVFSorKwEA7e3teP755/HEE0/gkksuwfz58/HCCy9g06ZN2LJlCwDgo48+woEDB/Dyyy9j7ty5uPLKK/HII49gzZo1cDgcsb9DGvXEjpaS7MEDiooIgxa1nyXGpSFACaZEiehEo+8fCDurWnH5kxvxytYq9WvrDtSjo8+FHm95S6/yEAB8fWoejAYJF03O1e09iIj8RVWIbm9XFktlZyu9AJWVlXA6nViyZIn6nGnTpqG0tBSbN28GAGzevBmzZs1CQUGB+pylS5fCbrdj//79Qd+nr68Pdrs94BclnoO1dqzdU4O1e2rw7p5aNHgnXPRW1aIEFAP1swgXTlQ+gHdVt6FLwzI3MTlUpEOmBQje1/LLv+9HbXsvynJScOtF4wEAnx1uULMs6VYTUiwmXa4HAB6+ZiY2//slmFGcodt7EBH5i/hvNI/Hg7vuuguLFy/GzJkzAQB1dXWwWCzIzMwMeG5BQQHq6urU5/gHLOJx8Vgwq1evxn/8x39Eeqk0DDR09OKa//1CPQ8HUMoK79/5lQFLNrEQzuSQUJKdgrFZyTjT2oMvT7Xga1Pzw3oPUR6K5TZcf/2Dlm6HC/tqlOD91R8sQprFhBc3ncKR+k7sqm4DoN+4s5BkNsb8iAAiooFEnGlZtWoV9u3bh9deey2W1xPU/fffj/b2dvVXdXW17u9JsbX9VCscbg9sSSYsmpANs1HCoboOHG8Mf/dIpEQjbkkYQQuAsPtadle34f//jxP4w8YT2Olt3I3luUP+RDOuKA/tPdMOt0dGoS0JYzKTkZFixvzSLADA618q//+hVz8LEdFQiSjTcscdd2Dt2rXYuHEjxo71nZhbWFgIh8OBtra2gGxLfX09CgsL1eds27Yt4PXEdJF4Tn9WqxVWK/8CTmTiQ/3qucX4z2tnYeUft2HDkUZ8dKAek/L1a+SUZVlTpgVQSkSvbz+jbnv153J78N6+OrzwxUnsrGo75/FwAyOtJuSmAVAOfgSAnd5syrzSTPU5X5uWh22nWrDtVAsA/SaHiIiGiqZMiyzLuOOOO/DWW2/hk08+wfjx4wMenz9/PsxmM9avX69+7fDhw6iqqkJFRQUAoKKiAnv37kVDQ4P6nHXr1sFms6G8vDyae6FhbIf3A35eiZINWFKulATXHagP9S2a7KxqxZ+3VUEWK1q9mrsc6Ha4IUnAmKzwSjeiGXff2Xa0e3evCKvfP4Sf/Hkndla1wWyUsGR6Aa6bNwbXzRuDOy+drGY7Ym1crhIMNXX2wd7rxI7TShB4nt/7fb1fKYuZFiIaaTRlWlatWoVXX30Vf/vb35Cenq72oGRkZCA5ORkZGRm49dZbcc899yA7Oxs2mw0//vGPUVFRgUWLFgEALr/8cpSXl+Pmm2/G448/jrq6OjzwwANYtWoVsykjlMPlwd6zStP2eWXKh+xl0wvw4Nv7sKu6DQ0dvVFlBVxuD37wp0o0dfYhJ9WCy2f4MnYiy1JkS4LVFF7/RYEtCRPyUnGisQtbTzYHvN7GI40AgFsqynDHJZPils1ITzIjL92Kxo4+nGzsCpppmVaYjkJbEuq8Dc4FNmZaiGhk0ZRpeeaZZ9De3o6vfe1rKCoqUn/95S9/UZ/z5JNP4hvf+AaWL1+Or371qygsLMSbb76pPm40GrF27VoYjUZUVFTgO9/5Dm655RY8/PDDsbsrGlYO1NrhcHmQmWLGOO+hhIUZSZg9NgOyDKw/2DDIKwzs82NNaOpUJmZe3x7Y76QelKixbKP2tfiViDp6nTjm7cH58SWT415+Ec24nx9rQmNHH0wGCTPH+CZ3JEnC16flqX/Wc9yZiGgoaMq09E+9B5OUlIQ1a9ZgzZo1IZ9TVlaG9957T8tbUwIT/SzzSjIDJoUum16APWfase5APW66oDTi139751n1958ebkSDvRf53ixDtcZ+FmHRhBy8vKUKW0+0qF/be7YdsqxMCOUNQellQm4qtp1swf/bcQYAMKPYds70ztem5uPP25TAbSiukYhITzwwhHQnGlbP69fvcdkMpa/l82NNmnai+Ot2uPCRty8mL90Kt0fGX70f6oC2cWd/F4xXdg8drLOjvUfpa9lzRilxzS3JjOhao9V/gmhekP6ZxZNyYfGeA6TX+DUR0VBh0EK6E+f49P+QnVqQjpLsZDhcHvzjaGNEr73uQD26HW6U5aTgp5dPAQC8sf2MmhWMNGjJT0/ChNxUyDJQeVrJtuz29pHMHjs0y9TGeyeIBP9+FiHNasJTN87FQ98oR1kOT14mopGFQQvpqqGjF2daeyBJwJySwA97SZJw2XSlyfWjCKeIRGnomjnFWDa7GCkWI042deHLU0qgVO3dhhvJKLLItogSkQha5gxRpkX0tAj9M1fCVbOK8P2Lxgd9jIgokTFoIV3t8paGpuSnBz39WDSObjvZcs5jg2nu7MPGo00AgGvmjUGa1YRvzC4CADz18RGs/OM2nG0TQYv2UokatJxsQYO9FzXtvTBIwKwxQ5NpKc1OgcHbEpSbZsHYMEe4iYhGCgYtpCt1P0uQUgbgy1qcae1RJ4DC9e7eWrg9MmaNycDEPKV08u3zSwAAm443Y8ORRkgScMOCsRFN+oigZd/ZdnWKaHJ+OlKt+p3nMxCLyaBmjOaWZOl+/AER0XDDoIUiJssyHC7PgM8Rk0OhShm2JDMmehtM95xpC/u9PR5ZnZK5Zm6x+vXzSrOweFIO0pNM+P7i8fjsp1/D4/80J+zX9Tc2KwVjMpPh8sh44YtTAIaun0WY5A3OzivLHNLrICIaCkPzT0YaER5ZexB/3laFt1ctxtTCc1fxN3T0qhM3oTItgJJtOd7YhV3V7bhkWkHI5/n7YH8dDtbakWY1Yfl5vqMkJEnCK/+ySNuNDGDh+Gy8ufOsegjhUPWzCHdfNgVjs5Jx86KyIb0OIqKhwEwLRezD/XXocbrx18pzD7B0uT34yZ93osfpxrTCdLV8E4wYIQ430+L2yHhy3REAwPcvGo+sVIvmaw+XKBEJQzXuLMwck4H/uGZm0P4gIqKRjkELRaSrz6U2ua47UH/O4sFfrzuCLSdakGox4n//+TwYDKH7L+aMzQSgTOeEs8Dwnd01ONrQCVuSCbfqPCXjH7RYTIagGSUiIooPBi0UkWMNnervTzV3B/x53YF6PPPZcQDA4/80B5PyQ2dZAGBaUTosRgNau53qiHIoLrcHT32sZFl+ePFEZCTrm3EYn5uqbpadWWyD2cj/lyEiGir8G3iEc3tkNHb0qb88nsEzGeE46hekAL49Kx29Tvzsr7sBAN9bPA7LvCPIA7GajJhebAMA7BqkRPT69jM41dyN7FQLvnvhOO0XrpEkSWq2ZbY3I0REREODjbgjmMvtwbKnP8fh+g71a/NKM/Hm7RdGPS57tEF5zYxkM9p7nFh3oB6rvj4JL3xxCq3dTkzIS8X9V04P+/XmjM3A7uo27Kluw9VzioM+Z/PxZvzynf0AgNsvnhi30eO7l0yB1WTADy+eEJf3IyKi4JhpGcGO1HeqAYuIUXZWtUW0yK2/Y/VKpuWWCmWKZVd1G47Wd+APG08AUD7oLabw/+el9rWEyLTsPdOOH/xpOxwuDy4vL8D3Fo+L+Nq1mpSfhidumIuiDC5zIyIaSgxaRjBx5s9Fk3JxcvUyfHuBsnjt9e1nBvq2sBzxZloWT8pVx4Bv+79KdPS5MK0wHctmDV4W8ideY+/ZdrjcgbtfTjV1YeUL29DZ58KiCdl4+qZ5MLG3hIho1OHf/CPYzn7baG/wbot9b28tOnqdEb9ut8OFM61Kw+zk/DRcNj0fAHCySTl9+O7Lpgw4LRTMhNxUpFtN6HV6cKQ+sF/mmc+Oo6XLgZljbPjDLQuQZDZGfO1ERJS4GLSMYDurA7fRnleaiUn5aehxuvHO7tqIX/dEYxdkGchOtSAnzYrLygvVx2aNycDl5eEtiPNnMEiY7T1Qsf++lm2nlHLWPZdN4X4SIqJRjEHLCNXW7cCJRiXzIRaiSZKEGxYo22Nf337uQrhwiSbcyd5R5ikFaervf7p0asRNvqKvRWyfBYCmzj41gzO/NDvIdxER0WjBoGWE2un94B+fmxqwMfa6eWNhMkjYVd2GI35TRVqI8s3kAiVQkSQJL3zvfLz+wwpcPCUv4mteME7JCH1+rEldMld5WskWTSlIQ0YKsyxERKMZg5YRqn8/i5CXbsUl05QelL98GVm25agIWvJ922HHZqWcs/Jeq4oJubCYDDjT2oPjjcp7iKBlfhmzLEREox2DlhFKnK48L8jpyjd4p4g+2FcX0Wsf61ceipVkixEVE3IAAJ8cagAAbPf2sywoC35KNBERjR4MWkYgj0fGLm+m5bwgpytfMEHJWpxt60Fbt0PTa/c63ahq6QYATC6I/Tk8X5+qlJc+PdSIXqcb+87aAfhKR0RENHoxaBmBjjd2oqPPhWSzEVODBBa2JDPGZimL0g7WautrOd7YCY8MZKaYkZsW+9OVvzZVKV19eaoFm483w+H2IC/ditLslJi/FxERJRYGLSOQ6GeZPTYj5BK28iLlrJ8DtXZNry0ORpycnxb1UQDBjMtNxYTcVLg8Mp5afxSAUhrS472IiCixMGgZgcQm3PMG6AOZ7g1aDmoMWkQT7qT82JeGBJFt2e2dgJrPfhYiIgKDFl20djmw5USz+qvB3hvX91cnh7z7WYIp956qfKAm/KCluqUbb1QqE0fTi/QMWgLHpheM4+QQERHxlOeYc3tkXPe7L3CquVv9WlaKGRt/9vW4bHPtdrjUc4HmDhS0eDMtxxo64XR7YB7kLJ/Gjj7c/PxW1Nv7MLUgHdfOGxOza+7vgvHZSDYb0eN0I8lswAxvgEVERKMbMy0xtuVEM041d8NiMmBSfhpSLUa0djuxdk/ka/O1OFjbAVkG8tOtyLclhXze2KxkpFtNcLg96k6UUOy9Tqz84zacau7G2Kxk/OnWC2DTMQBLMhuxeJIy+jy3JHPQgIqIiEYHfhrE2Ns7zwIA/mn+WHx8z8W4c8lkANGtzdfiQE07AAyanZAkSe1rGahE1ONw419e3I4DtXbkplnx8q0LUTBAMBQrKxaVwSAB1583Vvf3IiKixMCgJYZ6nW51Ydu1c5XyiVibv7OqDUcjXJuvhdhrMqM4Y9Dnir6UUM24TrcHq17dgW2nWpCeZMKfvn8BxuWmxu5iB/D1qfk4/qur1EV4REREDFpi6JNDDejoc2FMZrK6wTUWa/P9fbS/Djc9twWH64IHQPtrlUzLzDGD94H4JojOfS2PR8a9b+zGJ4caYDUZ8PzK89Xm3XjhmDMREflj0BJDojR09dxiGAy+D9xvn69kC97aeRYOlyeq93hi3RFsPtGM2/5vO9p7nAGPOVweHKlT+lPCybSoE0S1dvWAQuGvlWfw9q4amAwSnvnOeVGfK0RERBQtBi0x0t7txGeHGwH4SkPCxVPykJ9uRXOXA58cqo/4PapbunHIm2E53dyNn76xOyDYONrQAYfbA1uSSd14O5ApBekwSEBLlwMNHX0Bj2052QwA+MFXJ+CSaQURXzMREVGsMGiJkff21cLh9mBaYTqmFgbuMDEZDVg+X2kojaZEtO6AEvCMz02FxWjAugP1+P3GE+rj+2t8/SzhlFaSzEZMyFMOPezfjCvKTwONTRMREcUTg5YYEaWhUPtLvuUNWjYebYK91xn0OYMRQcuKhaX4xdXlAIDHPziEfWeVPpYDatASfu9JsHX+LrcHR73r+qcXckcKERENDwxawiDLMtq6Hef0fQgN9l5sO9UCAPjmnOKgz5mQl4bxualwe2RsOd6s+Rrauh3qe1xeXoh/vqAUV80qhEcGfvfZMQBQg5cZYTThCsHW+Z9q7oLD5UGKxRhWmYmIiCgeGLSE4aVNpzD34XX4/otfoqat55zHP9xfB1kG5pVmYkxm6A/5r0zOBQD842iT5mv49HAD3B4ZUwvSUZqTAkmScOelUwAA7++rw/HGTjXwCKcJVxBTRmL1P+CbJppamB7QUExERDSUGLQMQpZlvLT5NADg08ONuPzJjfi/LacDsi7v7lW23V41s2jA17pokhK0fH5Me9Dy8YEGAMBl5b6m2KmF6bhkWj5kGXjw7X3ocihr7ydo2KUyrzQLRoOEs209OOsNyEQ/y7RC/c4XIiIi0opByyAO1XXgZFMXLCYDzivNRGefCw++vQ9/8gYyjR192HZSKdtcMbNwwNeqmJgDo0HCyaYuVLd0D/hcf30uNz47rAQtS8oDJ3l++NUJAIBN3pLTtEIbTBrW3qdZTZjp7YH50nsfh+rs6msRERENFwxaBvGeN4ty8ZQ8/PVHF+Inlypr+X/90WG0dDnw4f46eGRgztgMlGSnDPha6UlmnFeaCUBbtmXz8WZ0OdzIT7di9pjA0s8F47Mxz/uagLYmXP/XAICt3jHnQ8y0EBHRMMSgZQCyLKuln2WzimAwSLjz0smYXmSDvdeFJ9Ydxvv7lMevnDVwaUi4aFIeAOAfRxvDvo53vYctLikvOKfHRJIk/PCrE9U/zxwTfj+LsHC8cjjh1pMtsPc6caZVKRMx00JERMMJg5YBHKnvxInGLliMBlw6XVnFbzRI+MU3lXHjV7dWYbO3LDNYP4vwlSlKX8sXx5rh9gSfRvLX2uXA33fXAACuDzFOfVl5AaYVpsNkkLAwgs2154/LhiQBJxq7sMmbASrKSEJGin4nORMREWnFoGUAojT01Sm5SE/yfYAvmpCDZbOK4JEBj6xM4JTmDFwaEmaPyUB6kgntPU7s9Y4oD+T17dXoc3kwo9iG+d7zjPozGiS8dtsifHDXV9VlcVpkpJgxtUApBf3fFqVXp/+CPCIioqHGoGUAImi5Kkjp59+vnAaLyRDy8VBMRgMWT/SOPh8ZuETk9sh4easSRNxSUTbgltvMFAsm5WsPWASRofnimK+hl4iIaDhh0BLC0foOHG3ohNkonTOxAwAl2SlYfd0sXDotHzedX6rptS8Ksa9FlmVsPdGMli4HAOCzww2obulBRrIZV88JXhqKlYUTcgL+zCZcIiIabkxDfQHDkSzL+N9PlS2zX5mcB1tS8N6O5fPHqmcKaXHxFKUZt7KqFW3dDmSmWAAop0Df8/puZCSb8eA3ytVelhsWjEWyxRjJrYTt/HGBvTDTihi0EBHR8MJMSxCvbK3C33bVwGiQ8K9fmzj4N2hUkp2CaYXpcHtkfHKoQf36mzuU84vae5z46Ru7sfFIIyQJ+M6isphfQ3956VZMyFOW0pkMEibkRl5qIiIi0gODln72nGnDw+8cAADcd8VULBinfRonHGKzrTgEsaXLgc0nlH6SH3xlvNov87UpeSjLCX/DbTREX8uk/DT1/YmIiIYLfjL5ae1y4PaXd8Dh9mDpjAL84CsTdHsvEbRsONKIXqcbH+2vg9sjY+YYG36+rBzv3/kV3L1kCh5dPlu3a+hPNBRfPDUvbu9JREQULva0+Hny4yM429aDcTkp+O9vzRlwWidas8ZkoNCWhDp7LzYfb1aX2F3p3fcyMS8Ndy6ZrNv7B/OVyXnYcv+lyEmzxPV9iYiIwsGgxc99V0xDt8ON7y8eH7L5NlYkScKS8ny8vKUKb1RWq2cHaRmf1kNhRtKQvj8REVEoLA/5SbWa8D/fmoPyCM7vicRl5coBi+/tVUpD04tsGK/hhGYiIqLRhEHLEFo0IRtpVl+ya9msgU+JJiIiGs00By0bN27EN7/5TRQXF0OSJLz99tsBj8uyjIceeghFRUVITk7GkiVLcPTo0YDntLS0YMWKFbDZbMjMzMStt96Kzs7OqG4kEVlNxoCm13APXSQiIhqNNActXV1dmDNnDtasWRP08ccffxxPP/00nn32WWzduhWpqalYunQpent71eesWLEC+/fvx7p167B27Vps3LgRt912W+R3kcCumKFkV6YX2TAxgnODiIiIRgtJluXBjxoO9c2ShLfeegvXXnstACXLUlxcjH/7t3/DT3/6UwBAe3s7CgoK8OKLL+LGG2/EwYMHUV5eji+//BILFiwAAHzwwQe46qqrcObMGRQXFw/6vna7HRkZGWhvb4fNlthn5MiyjDcqz2B+WRaDFiIiGtGi/fyOaU/LyZMnUVdXhyVLlqhfy8jIwMKFC7F582YAwObNm5GZmakGLACwZMkSGAwGbN26Nejr9vX1wW63B/waKSRJwg0LShiwEBERDSKmQUtdXR0AoKAg8IDBgoIC9bG6ujrk5+cHPG4ymZCdna0+p7/Vq1cjIyND/VVSUhLLyyYiIqIEkBDTQ/fffz/a29vVX9XV1UN9SURERBRnMQ1aCguVptL6+vqAr9fX16uPFRYWoqGhIeBxl8uFlpYW9Tn9Wa1W2Gy2gF9EREQ0usQ0aBk/fjwKCwuxfv169Wt2ux1bt25FRUUFAKCiogJtbW2orKxUn/PJJ5/A4/Fg4cKFsbwcIiIiGkE0r/Hv7OzEsWPH1D+fPHkSu3btQnZ2NkpLS3HXXXfhP//zPzF58mSMHz8eDz74IIqLi9UJo+nTp+OKK67AD37wAzz77LNwOp244447cOONN4Y1OURERESjk+agZfv27fj617+u/vmee+4BAKxcuRIvvvgifvazn6Grqwu33XYb2tracNFFF+GDDz5AUpLvTJtXXnkFd9xxBy699FIYDAYsX74cTz/9dAxuh4iIiEaqqPa0DJWRtKeFiIhotBhWe1qIiIiI9MKghYiIiBICgxYiIiJKCAxaiIiIKCEwaCEiIqKEwKCFiIiIEoLmPS3DgZjSHkmnPRMREY104nM70m0rCRm0dHR0AABPeyYiIkpAHR0dyMjI0Px9CblczuPxoKamBunp6ZAkKaavbbfbUVJSgurq6hG9uI73ObLwPkee0XKvvM+RZbD7lGUZHR0dKC4uhsGgvUMlITMtBoMBY8eO1fU9Rstp0rzPkYX3OfKMlnvlfY4sA91nJBkWgY24RERElBAYtBAREVFCYNDSj9VqxS9+8QtYrdahvhRd8T5HFt7nyDNa7pX3ObLofZ8J2YhLREREow8zLURERJQQGLQQERFRQmDQQkRERAmBQQsRERElBAYtftasWYNx48YhKSkJCxcuxLZt24b6kqKyevVqnH/++UhPT0d+fj6uvfZaHD58OOA5vb29WLVqFXJycpCWlobly5ejvr5+iK44Nh599FFIkoS77rpL/dpIuc+zZ8/iO9/5DnJycpCcnIxZs2Zh+/bt6uOyLOOhhx5CUVERkpOTsWTJEhw9enQIrzgybrcbDz74IMaPH4/k5GRMnDgRjzzySMB5JYl4rxs3bsQ3v/lNFBcXQ5IkvP322wGPh3NPLS0tWLFiBWw2GzIzM3Hrrbeis7MzjncxuIHu0+l04r777sOsWbOQmpqK4uJi3HLLLaipqQl4jUS/z/5+9KMfQZIkPPXUUwFfHyn3efDgQVx99dXIyMhAamoqzj//fFRVVamPx+rvYAYtXn/5y19wzz334Be/+AV27NiBOXPmYOnSpWhoaBjqS4vYhg0bsGrVKmzZsgXr1q2D0+nE5Zdfjq6uLvU5d999N9555x288cYb2LBhA2pqanD99dcP4VVH58svv8Tvf/97zJ49O+DrI+E+W1tbsXjxYpjNZrz//vs4cOAAfv3rXyMrK0t9zuOPP46nn34azz77LLZu3YrU1FQsXboUvb29Q3jl2j322GN45pln8L//+784ePAgHnvsMTz++OP47W9/qz4nEe+1q6sLc+bMwZo1a4I+Hs49rVixAvv378e6deuwdu1abNy4Ebfddlu8biEsA91nd3c3duzYgQcffBA7duzAm2++icOHD+Pqq68OeF6i36e/t956C1u2bEFxcfE5j42E+zx+/DguuugiTJs2DZ999hn27NmDBx98EElJSepzYvZ3sEyyLMvyBRdcIK9atUr9s9vtlouLi+XVq1cP4VXFVkNDgwxA3rBhgyzLstzW1iabzWb5jTfeUJ9z8OBBGYC8efPmobrMiHV0dMiTJ0+W161bJ1988cXynXfeKcvyyLnP++67T77oootCPu7xeOTCwkL5v//7v9WvtbW1yVarVf7zn/8cj0uMmWXLlsnf//73A752/fXXyytWrJBleWTcKwD5rbfeUv8czj0dOHBABiB/+eWX6nPef/99WZIk+ezZs3G7di3632cw27ZtkwHIp0+flmV5ZN3nmTNn5DFjxsj79u2Ty8rK5CeffFJ9bKTc57e//W35O9/5TsjvieXfwcy0AHA4HKisrMSSJUvUrxkMBixZsgSbN28ewiuLrfb2dgBAdnY2AKCyshJOpzPgvqdNm4bS0tKEvO9Vq1Zh2bJlAfcDjJz7/Pvf/44FCxbgW9/6FvLz8zFv3jz84Q9/UB8/efIk6urqAu4zIyMDCxcuTKj7BIALL7wQ69evx5EjRwAAu3fvxueff44rr7wSwMi6VyGce9q8eTMyMzOxYMEC9TlLliyBwWDA1q1b437NsdLe3g5JkpCZmQlg5Nynx+PBzTffjHvvvRczZsw45/GRcJ8ejwfvvvsupkyZgqVLlyI/Px8LFy4MKCHF8u9gBi0Ampqa4Ha7UVBQEPD1goIC1NXVDdFVxZbH48Fdd92FxYsXY+bMmQCAuro6WCwW9S8KIRHv+7XXXsOOHTuwevXqcx4bKfd54sQJPPPMM5g8eTI+/PBD3H777fjJT36Cl156CQDUexkJ/zv+93//d9x4442YNm0azGYz5s2bh7vuugsrVqwAMLLuVQjnnurq6pCfnx/wuMlkQnZ2dsLed29vL+677z7cdNNN6gF7I+U+H3vsMZhMJvzkJz8J+vhIuM+GhgZ0dnbi0UcfxRVXXIGPPvoI1113Ha6//nps2LABQGz/Dk7IU55Ju1WrVmHfvn34/PPPh/pSYq66uhp33nkn1q1bF1BDHWk8Hg8WLFiAX/3qVwCAefPmYd++fXj22WexcuXKIb662Hr99dfxyiuv4NVXX8WMGTOwa9cu3HXXXSguLh5x9zqaOZ1O3HDDDZBlGc8888xQX05MVVZW4je/+Q127NgBSZKG+nJ04/F4AADXXHMN7r77bgDA3LlzsWnTJjz77LO4+OKLY/p+zLQAyM3NhdFoPKeTub6+HoWFhUN0VbFzxx13YO3atfj0008xduxY9euFhYVwOBxoa2sLeH6i3XdlZSUaGhpw3nnnwWQywWQyYcOGDXj66adhMplQUFAwIu6zqKgI5eXlAV+bPn262qEv7mUk/O/43nvvVbMts2bNws0334y7775bzaSNpHsVwrmnwsLCc4YDXC4XWlpaEu6+RcBy+vRprFu3Ts2yACPjPv/xj3+goaEBpaWl6t9Lp0+fxr/9279h3LhxAEbGfebm5sJkMg36d1Os/g5m0ALAYrFg/vz5WL9+vfo1j8eD9evXo6KiYgivLDqyLOOOO+7AW2+9hU8++QTjx48PeHz+/Pkwm80B93348GFUVVUl1H1feuml2Lt3L3bt2qX+WrBgAVasWKH+fiTc5+LFi88ZWT9y5AjKysoAAOPHj0dhYWHAfdrtdmzdujWh7hNQJkwMhsC/noxGo/qvupF0r0I491RRUYG2tjZUVlaqz/nkk0/g8XiwcOHCuF9zpETAcvToUXz88cfIyckJeHwk3OfNN9+MPXv2BPy9VFxcjHvvvRcffvghgJFxnxaLBeeff/6AfzfF9LNGU9vuCPbaa6/JVqtVfvHFF+UDBw7It912m5yZmSnX1dUN9aVF7Pbbb5czMjLkzz77TK6trVV/dXd3q8/50Y9+JJeWlsqffPKJvH37drmiokKuqKgYwquODf/pIVkeGfe5bds22WQyyf/1X/8lHz16VH7llVfklJQU+eWXX1af8+ijj8qZmZny3/72N3nPnj3yNddcI48fP17u6ekZwivXbuXKlfKYMWPktWvXyidPnpTffPNNOTc3V/7Zz36mPicR77Wjo0PeuXOnvHPnThmA/MQTT8g7d+5Up2bCuacrrrhCnjdvnrx161b5888/lydPnizfdNNNQ3VLQQ10nw6HQ7766qvlsWPHyrt27Qr4u6mvr099jUS/z2D6Tw/J8si4zzfffFM2m83yc889Jx89elT+7W9/KxuNRvkf//iH+hqx+juYQYuf3/72t3JpaalssVjkCy64QN6yZctQX1JUAAT99cILL6jP6enpkf/1X/9VzsrKklNSUuTrrrtOrq2tHbqLjpH+QctIuc933nlHnjlzpmy1WuVp06bJzz33XMDjHo9HfvDBB+WCggLZarXKl156qXz48OEhutrI2e12+c4775RLS0vlpKQkecKECfLPf/7zgA+1RLzXTz/9NOj/T65cuVKW5fDuqbm5Wb7pppvktLQ02Wazyd/73vfkjo6OIbib0Aa6z5MnT4b8u+nTTz9VXyPR7zOYYEHLSLnP559/Xp40aZKclJQkz5kzR3777bcDXiNWfwdLsuy3YpKIiIhomGJPCxERESUEBi1ERESUEBi0EBERUUJg0EJEREQJgUELERERJQQGLURERJQQGLQQERFRQmDQQkRERAmBQQsRERElBAYtRERElBAYtBAREVFCYNBCRERECeH/A0ThojALEyadAAAAAElFTkSuQmCC\n" - }, - "metadata": {} - } - ], - "source": [ - "plt.plot(np.append(Y_train_df['y'].values, y_hat_test_w_val))" - ] - }, - { - "cell_type": "code", - "source": [ - "if __name__ == '__main__':\n", - " # Example usage:\n", - " n_points = 100 # Number of points in time series\n", - " n_functions = 5 # Number of basis functions\n", - "\n", - " # Generate Legendre polynomial basis functions\n", - " legendre_basis = generate_legendre_basis(n_points, n_functions)\n", - "\n", - " # Generate standard polynomial basis functions\n", - " poly_basis = generate_polynomial_basis(n_points, n_functions)\n", - "\n", - " # Generate standard polynomial basis functions\n", - " poly_2_basis = generate_polynomial_2_basis(n_points, n_functions)\n", - "\n", - " # Generate changepoint basis functions\n", - " changepoint_basis = generate_changepoint_basis(n_points, n_functions)\n", - "\n", - " # Generate haar basis functions\n", - " pw_basis = generate_piecewise_linear_basis(n_points, n_functions)\n", - "\n", - " # Generate haar basis functions\n", - " spline_basis = generate_spline_basis(n_points, n_functions)\n", - "\n", - " # Generate haar basis functions\n", - " cheby_basis = generate_chebyshev_basis(n_points, n_functions)\n", - "\n", - " # Generate haar basis functions\n", - " pw2_basis = generate_piecewise_2_basis(n_points, n_functions)\n", - "\n", - "\n", - " # Plotting the basis functions for visualization\n", - " plt.figure(figsize=(12, 20))\n", - "\n", - " n_plots = 8\n", - "\n", - " # Plot Legendre basis functions\n", - " plt.subplot(n_plots, 1, 1)\n", - " for i in range(n_functions):\n", - " plt.plot(legendre_basis[:, i], label=f'Legendre {i}')\n", - " plt.title('Legendre Polynomial Basis')\n", - " plt.legend()\n", - "\n", - " # Plot Polynomial basis functions\n", - " plt.subplot(n_plots, 1, 2)\n", - " for i in range(n_functions):\n", - " plt.plot(poly_basis[:, i], label=f'Polynomial {i}')\n", - " plt.title('Polynomial Basis')\n", - " plt.legend()\n", - "\n", - " # Plot Polynomial 2 basis functions\n", - " plt.subplot(n_plots, 1, 3)\n", - " for i in range(n_functions):\n", - " plt.plot(poly_2_basis[:, i], label=f'Polynomial 2 {i}')\n", - " plt.title('Polynomial 2 Basis')\n", - " plt.legend()\n", - "\n", - " # Plot Changepoint basis functions\n", - " plt.subplot(n_plots, 1, 4)\n", - " for i in range(n_functions):\n", - " plt.plot(changepoint_basis[:, i], label=f'Changepoints {i}')\n", - " plt.title('Changepoint Basis')\n", - " plt.legend()\n", - "\n", - " # Plot Changepoint basis functions\n", - " plt.subplot(n_plots, 1, 5)\n", - " for i in range(n_functions):\n", - " plt.plot(pw_basis[:, i], label=f'PW {i}')\n", - " plt.title('Piecewise Basis')\n", - " plt.legend()\n", - "\n", - " # Plot Changepoint basis functions\n", - " plt.subplot(n_plots, 1, 6)\n", - " for i in range(n_functions):\n", - " plt.plot(spline_basis[:, i], label=f'Spline {i}')\n", - " plt.title('Spline Basis')\n", - " plt.legend()\n", - "\n", - " # Plot Changepoint basis functions\n", - " plt.subplot(n_plots, 1, 7)\n", - " for i in range(n_functions):\n", - " plt.plot(cheby_basis[:, i], label=f'Cheby {i}')\n", - " plt.title('Cheby Basis')\n", - " plt.legend()\n", - "\n", - " # Plot Changepoint basis functions\n", - " plt.subplot(n_plots, 1, 8)\n", - " for i in range(np.shape(pw2_basis)[1]):\n", - " plt.plot(pw2_basis[:, i], label=f'PW2 {i}')\n", - " plt.title('PW2 Basis')\n", - " plt.legend()\n", - "\n", - " plt.tight_layout()\n", - " plt.show()\n" - ], - "metadata": { - "id": "orrAIsdZpd6F", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "outputId": "ee63042c-f9f7-428e-c6a5-f412b15c9f29" - }, - "execution_count": 10, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAfFCAYAAABAoX+MAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xV9f3H8dddSe7N3huSQELC3iiyRARx4FbQKg4crdo66vppa7Wto9bRatVaqlhFcYIDRUHAAcjekJAQsve6GTd3n98fN7nhkoSZnc/z8biPkHPPufd7L0nuve/z+X6+KkVRFIQQQgghhBBCCCGE6ELq7h6AEEIIIYQQQgghhOh/JJQSQgghhBBCCCGEEF1OQikhhBBCCCGEEEII0eUklBJCCCGEEEIIIYQQXU5CKSGEEEIIIYQQQgjR5SSUEkIIIYQQQgghhBBdTkIpIYQQQgghhBBCCNHlJJQSQgghhBBCCCGEEF1OQikhhBBCCCGEEEII0eUklBJCCCFEr6dSqfjTn/7U3cM4ZTNmzGDGjBndPYwOsWTJElQqFTk5Oad87E033URCQkKHj6mj/OlPf0KlUnX3MIQQQog+R0IpIYQQoo9rDgu2bdvW3UPp9Zqfy+aLj48PKSkp3H333ZSWlnb38Pq8GTNmeDz/Xl5eJCYmcvvtt5Ofn9/dwxNCCCHEKdJ29wCEEEIIIXqbp556isTERMxmMz///DOvv/46X3/9Nfv27cNgMHT38LrFDTfcwPz58/H29u7U+4mLi+OZZ54BwGq1cuDAAd544w2+/fZbDh482CnP/+OPP84jjzzS4bcrhBBC9HcSSgkhhBCiX2hoaMDX17dDbmvu3LmMHz8egEWLFhEaGsqLL77I559/zoIFCzrkPnobjUaDRqPp9PsJDAzkV7/6lce2xMRE7r77bjZs2MD555/f4fep1WrRauVtsxBCCNHRZPqeEEIIIQAoLCzklltuITIyEm9vb4YNG8Zbb73Var/c3FzmzZuHr68vERER3HfffXz77beoVCrWr1/vse/mzZu54IILCAwMxGAwMH36dDZs2OCxT3O/nqysLG666SaCgoIIDAzk5ptvxmQyeexrsVi47777CA8Px9/fn3nz5lFQUNBqjM23eeDAAa677jqCg4OZMmWK+/r33nuPcePGodfrCQkJYf78+Wc0/WvmzJkAHDlyBAC73c6f//xnBg0ahLe3NwkJCfzf//0fFoul3duor6/H19eX3/3ud62uKygoQKPRuCuEmqcRbtiwgfvvv5/w8HB8fX25/PLLKS8vb3X8a6+9xrBhw/D29iYmJoa77rqLmpoaj31mzJjB8OHD2bNnD9OnT8dgMDB48GA++eQTAH744QcmTZqEXq9nyJAhrFmzxuP4tnpKff7551x00UXExMTg7e3NoEGD+POf/4zD4Tjxk3oKoqKiADyCo9zcXH7zm98wZMgQ9Ho9oaGhXH311a16XtlsNp588kmSk5Px8fEhNDSUKVOmsHr1avc+bfWUWr16NVOmTCEoKAg/Pz+GDBnC//3f/3Xo4xJCCCH6OjnlI4QQQghKS0s566yzUKlU3H333YSHh/PNN99w6623Ultby7333gu4qo1mzpxJcXExv/vd74iKiuL9999n3bp1rW5z7dq1zJ07l3HjxvHEE0+gVqt5++23mTlzJj/99BMTJ0702P+aa64hMTGRZ555hh07drB48WIiIiJ47rnn3PssWrSI9957j+uuu47Jkyezdu1aLrroonYf19VXX01ycjJPP/00iqIA8Ne//pU//OEPXHPNNSxatIjy8nJeeeUVpk2bxs6dOwkKCjrl5+/w4cMAhIaGusf5zjvvcNVVV/HAAw+wefNmnnnmGQ4ePMjy5cvbvA0/Pz8uv/xyPvzwQ1588UWPqqMPPvgARVG4/vrrPY655557CA4O5oknniAnJ4eXX36Zu+++mw8//NC9z5/+9CeefPJJZs2axa9//WsyMjJ4/fXX2bp1Kxs2bECn07n3ra6u5uKLL2b+/PlcffXVvP7668yfP5+lS5dy7733cuedd3Ldddfx/PPPc9VVV5Gfn4+/v3+7z8uSJUvw8/Pj/vvvx8/Pj7Vr1/LHP/6R2tpann/++VN+ngEcDgcVFRWAK1A6ePAgTzzxBIMHD+acc85x77d161Y2btzI/PnziYuLIycnh9dff50ZM2Zw4MAB9zS/P/3pTzzzzDMsWrSIiRMnUltby7Zt29ixY0e7VVf79+/n4osvZuTIkTz11FN4e3uTlZXVKnAVQgghxAkoQgghhOjT3n77bQVQtm7d2u4+t956qxIdHa1UVFR4bJ8/f74SGBiomEwmRVEU5YUXXlAAZcWKFe59GhsbldTUVAVQ1q1bpyiKojidTiU5OVmZM2eO4nQ63fuaTCYlMTFROf/8893bnnjiCQVQbrnlFo/7vvzyy5XQ0FD397t27VIA5Te/+Y3Hftddd50CKE888USr21ywYIHHvjk5OYpGo1H++te/emzfu3evotVqW20/VvNzuWbNGqW8vFzJz89Xli1bpoSGhip6vV4pKChwj3PRokUex/7+979XAGXt2rXubdOnT1emT5/u/v7bb79VAOWbb77xOHbkyJEe+zWPY9asWR7P73333adoNBqlpqZGURRFKSsrU7y8vJTZs2crDofDvd+rr76qAMpbb73lMRZAef/9993b0tPTFUBRq9XKL7/80mqcb7/9dqsxHTlyxL2t+efmaHfccYdiMBgUs9ns3rZw4UJl4MCBrfY9VvMYj72kpaUp2dnZHvu2dd+bNm1SAOV///ufe9uoUaOUiy666Lj32/zz1Oyll15SAKW8vPyEYxZCCCFE+2T6nhBCCNHPKYrCp59+yiWXXIKiKFRUVLgvc+bMwWg0smPHDgBWrVpFbGws8+bNcx/v4+PDbbfd5nGbu3btIjMzk+uuu47Kykr37TU0NHDeeefx448/4nQ6PY658847Pb6fOnUqlZWV1NbWAvD1118D8Nvf/tZjv+YqrrYce5ufffYZTqeTa665xuNxRkVFkZyc3GbFV1tmzZpFeHg48fHxzJ8/Hz8/P5YvX05sbKx7nPfff7/HMQ888AAAK1euPO7txsTEsHTpUve2ffv2sWfPnlZ9lABuv/12j2llU6dOxeFwkJubC8CaNWuwWq3ce++9qNUtb/tuu+02AgICWo3Fz8+P+fPnu78fMmQIQUFBpKWlMWnSJPf25n9nZ2e3+1gA9Hq9+991dXVUVFQwdepUTCYT6enpxz22PQkJCaxevZrVq1fzzTff8PLLL2M0Gpk7d67H1MWj79tms1FZWcngwYMJCgpy/zwDBAUFsX//fjIzM096DM3VdJ9//nmrn2MhhBBCnDyZvieEEEL0c+Xl5dTU1PDmm2/y5ptvtrlPWVkZ4OrTM2jQoFb9dQYPHuzxffMH/IULF7Z7v0ajkeDgYPf3AwYM8Li++brq6moCAgLIzc1FrVYzaNAgj/2GDBnS7n0kJia2GpeiKCQnJ7e5/9FT2Y7nX//6FykpKWi1WiIjIxkyZIg79Gke57HPSVRUFEFBQe7AqC1qtZrrr7+e119/HZPJhMFgYOnSpfj4+HD11Ve32v94z1nzWKD1c+Tl5UVSUlKrscTFxbX6vw0MDCQ+Pr7VtqPvpz379+/n8ccfZ+3ate5wsZnRaDzuse3x9fVl1qxZ7u8vuOACpkyZwvjx43n22Wd54YUXAGhsbOSZZ57h7bffprCw0D1989j7fuqpp7j00ktJSUlh+PDhXHDBBdxwww2MHDmy3TFce+21LF68mEWLFvHII49w3nnnccUVV3DVVVd5hH9CCCGEOD4JpYQQQoh+rrnS41e/+lW7IdLxPqAf7zaff/55Ro8e3eY+fn5+Ht+3t3Lb0WHCqTq6WqZ5XCqVim+++abN+zt2TO2ZOHGie/W99hwb7pysG2+8keeff54VK1awYMEC3n//fS6++GJ3EHS0jn7O2ru907mfmpoapk+fTkBAAE899RSDBg3Cx8eHHTt28PDDD3dohdG4ceMIDAzkxx9/dG+75557ePvtt7n33ns5++yzCQwMRKVSMX/+fI/7njZtGocPH+bzzz/nu+++Y/Hixbz00ku88cYbLFq0qM370+v1/Pjjj6xbt46VK1eyatUqPvzwQ2bOnMl3333XJasQCiGEEH2BhFJCCCFEP9e8kp3D4fCoQGnLwIEDOXDgAIqieIQuWVlZHvs1VzMFBASc8DZP1sCBA3E6nRw+fNij8icjI+Okb2PQoEEoikJiYiIpKSkdMq5jNY8zMzOTtLQ09/bS0lJqamoYOHDgcY8fPnw4Y8aMYenSpcTFxZGXl8crr7xy2mMB13OUlJTk3m61Wjly5EiH/d+0Zf369VRWVvLZZ58xbdo09/bmFQo7msPhoL6+3v39J598wsKFC92VUwBms7nVqoMAISEh3Hzzzdx8883U19czbdo0/vSnP7UbSoGrqu28887jvPPO48UXX+Tpp5/mscceY926dZ36vAohhBB9idQXCyGEEP2cRqPhyiuv5NNPP2Xfvn2trj+6T8+cOXMoLCzkiy++cG8zm8385z//8Thm3LhxDBo0iL///e8eQUFbt3my5s6dC8A///lPj+0vv/zySd/GFVdcgUaj4cknn2xV5aMoCpWVlac8rmNdeOGFbY7rxRdfBDjuaoHNbrjhBr777jtefvllQkND3Y/9VM2aNQsvLy/++c9/ejze//73vxiNxpMay+lqrhY6+n6tViuvvfZah9/XunXrqK+vZ9SoUR73f+z/8SuvvILD4fDYduz/uZ+fH4MHD8ZisbR7f1VVVa22NVcEHu84IYQQQniSSikhhBCin3jrrbdYtWpVq+2/+93vePbZZ1m3bh2TJk3itttuY+jQoVRVVbFjxw7WrFnj/hB+xx138Oqrr7JgwQJ+97vfER0d7e55BC1T1tRqNYsXL2bu3LkMGzaMm2++mdjYWAoLC1m3bh0BAQF8+eWXpzT+0aNHs2DBAl577TWMRiOTJ0/m+++/b1WldTyDBg3iL3/5C48++ig5OTlcdtll+Pv7c+TIEZYvX87tt9/O73//+1Ma17FGjRrFwoULefPNN91T2LZs2cI777zDZZddxrnnnnvC27juuut46KGHWL58Ob/+9a9PutfVscLDw3n00Ud58sknueCCC5g3bx4ZGRm89tprTJgwoc3m6R1l8uTJBAcHs3DhQn7729+iUql49913z2g6Jrj6Qb333nsA2O12MjIyeP3119Hr9TzyyCPu/S6++GLeffddAgMDGTp0KJs2bWLNmjWEhoZ63N7QoUOZMWMG48aNIyQkhG3btvHJJ59w9913tzuGp556ih9//JGLLrqIgQMHUlZWxmuvvUZcXBxTpkw5o8cnhBBC9CcSSgkhhBD9xOuvv97m9ptuuom4uDi2bNnCU089xWeffcZrr71GaGgow4YN47nnnnPv6+fnx9q1a7nnnnv4xz/+gZ+fHzfeeCOTJ0/myiuvdIdTADNmzGDTpk38+c9/5tVXX6W+vp6oqCgmTZrEHXfccVqP4a233iI8PJylS5eyYsUKZs6cycqVK1s14j6eRx55hJSUFF566SWefPJJAOLj45k9e7bHqoJnYvHixSQlJbFkyRKWL19OVFQUjz76KE888cRJHR8ZGcns2bP5+uuvueGGG85oLH/6058IDw/n1Vdf5b777iMkJITbb7+dp59++rTDrpMRGhrKV199xQMPPMDjjz9OcHAwv/rVrzjvvPOYM2fOad9uQUGB+zlRqVQEBwczffp0nnjiCY/+Zf/4xz/QaDQsXboUs9nMOeecw5o1a1rd929/+1u++OILvvvuOywWCwMHDuQvf/kLDz74YLtjmDdvHjk5Obz11ltUVFQQFhbG9OnTefLJJ9vs/SWEEEKItqmUMz1dJYQQQoh+7+WXX+a+++6joKCA2NjY7h5On3D55Zezd+/eU6oEE0IIIYToTaSnlBBCCCFOSWNjo8f3ZrOZf//73yQnJ0sg1UGKi4tZuXLlGVdJCSGEEEL0ZDJ9TwghhBCn5IorrmDAgAGMHj3a3d8nPT2dpUuXdvfQer0jR46wYcMGFi9ejE6nO+1pjkIIIYQQvYGEUkIIIYQ4JXPmzGHx4sUsXboUh8PB0KFDWbZsGddee213D63X++GHH7j55psZMGAA77zzDlFRUd09JCGEEEKITiM9pYQQQgghhBBCCCFEl5OeUkIIIYQQQgghhBCiy/W56XtOp5OioiL8/f1RqVTdPRwhhBBCCCGEEEKIfkVRFOrq6oiJiUGtbr8eqs+FUkVFRcTHx3f3MIQQQgghhBBCCCH6tfz8fOLi4tq9vs+FUv7+/oDrgQcEBHTzaIQQQgghhBBCCCH6l9raWuLj490ZTXv6XCjVPGUvICBAQikhhBBCCCGEEEKIbnKitkrS6FwIIYQQQgghhBBCdDkJpYQQQgghhBBCCCFEl+vUUOrHH3/kkksuISYmBpVKxYoVK054zPr16xk7dize3t4MHjyYJUuWdOYQhRBCCCGEEEIIIUQ36NRQqqGhgVGjRvGvf/3rpPY/cuQIF110Eeeeey67du3i3nvvZdGiRXz77bedOUwhhBBCCCGEEEII0cU6tdH53LlzmTt37knv/8Ybb5CYmMgLL7wAQFpaGj///DMvvfQSc+bM6axh9lgN1gZWrPqBOVOnYfD16e7hCCGEEEIIIYQQojPYLWx8bSn+ozRMnHXLCRuE9xU9avW9TZs2MWvWLI9tc+bM4d577233GIvFgsVicX9fW1vbWcPrcu++8T2OA348vvVfrDFYsBtHA5ruHpYQQgghhBBCCCFOgxc2klTFJKsKSFYXkKwqRO1TSGZRAirHg2gPVDM4tZzQ+IjuHmqX6FGhVElJCZGRkR7bIiMjqa2tpbGxEb1e3+qYZ555hieffLKrhtilfFJsNByA4eXjyBz+MiVh32OpOBe7cSwSTgkhhBBCCCGEED2TN1YSVSWkqAoYrC4gRVVIsqqABFUJGpUCwB5vL94ICsQ73ZeRtTdg8gWN4wBK8KwT3Hrf0aNCqdPx6KOPcv/997u/r62tJT4+vhtH1HEWzrmClQW7yd1Wxcwj1/PR8GdRx3xKdPImFg69hYsT56HT6Lp7mEIIIYQQQgghRP9kN6OqzEJdkY66PANVRTrqigxU1UdQKc42D9nhH8wbIaFsUluZu9XJjMzzOJIYhZfKwhUvP0Cwb+uCnL6qR4VSUVFRlJaWemwrLS0lICCgzSopAG9vb7y9vbtieF1OpVJx3vyhvH9wM0ENkdytfoKlPv+kuKGIZ7f+hSUHFnPr8Fu5IvkKvDRe3T1cIYQQQgghhBCib7I1QkUmlKe7LmVNX6uPQDvhEz6BEJ4G4UMgIo1tXhreKPmJzeW7ACuXbla47Jdwtox39dCefssYQoINXfaQeoIeFUqdffbZfP311x7bVq9ezdlnn91NI+p+ej8vzrl6MN8vOYhjWwgf/t9yVlev5K19b1HSUMJfN/+V/+z9D7cMv4Urk6/ERysN0YUQQgghhBBCiNNiNUHFISjPgPKDrq9lB6E6B1DaPsYnCCKawqejQij8IlGALSVbeGP3G2wr3QaAVqXl0YODGb52PztHL0BR6xgwLITk8ZFt334f1qmhVH19PVlZWe7vjxw5wq5duwgJCWHAgAE8+uijFBYW8r///Q+AO++8k1dffZWHHnqIW265hbVr1/LRRx+xcuXKzhxmjzdkUhQZv5RQkF7NLx/mcP3vrufqIVfz6aFP+e++/1JmKuPZLc/ynz3/4aZhN3HNkGsw6PpXuiqEEEIIIYQQQpw0qwkqMlpCp+YQqjqXdsMnfbBn6NQcQvlFwDGr5SmKws+FP/PmnjfZVb4LAK1ayxWDLuf6DRosy9+jKOpsaoKS0Xqpmb5gSL9Zce9oKkVR2nm2z9z69es599xzW21fuHAhS5Ys4aabbiInJ4f169d7HHPfffdx4MAB4uLi+MMf/sBNN9100vdZW1tLYGAgRqORgICADngUPUNNmYllf96Cw+Zk1s1DGTIpCgCrw8qKrBUs3ruY4oZiAAK9A7kh7QYWpC0gwKvvPAdCCCGEEEIIIcQpsTY0BU7HVD7V5NF++BTSFDqlui4RTV99w1uFT8dyKk7W5q3lzT1vcrDqIABeai+uSL6CW4bfgvr196j671tYdX5smfY0VoeGyVcOZsz5Azr4gXevk81mOjWU6g59NZQC2PZNDps/z8bHT8f1fzoLH7+WJuc2h42vsr9i8d7F5NXlAeCn82NB6gJ+NfRXhPiEdNewhRBCCCGEEEKIzmWpb5p2d3TPp+bwqR2GMM/QqfniF37Kd2932vk251v+s+c/HDYeBkCv1XNNyjUsHLaQMH0YpU8/Q/W77wJw+Krnya0wEBbvx9WPjEetUZ/Ww+6pJJTqg6GUw+7ko6e3UlXUQOrZUZy3cGirfexOO9/lfMd/9v6HrBrX1Em9Vs/VKVezcNhCIgwRXT1sIYQQQgghhBCiY1jqXdPumhuNN1+OFz75hh8VOg1pqYLyDTvj4dgcNr7M/pL/7v1vqwKRG4beQLBPMIrTScmTT1Hz4YcAOH/7NOv3BKJSwVWPjCdiYN/KLkBCqT4ZSgGUZBv59PntoMCl944mLrXtCiin4mRd/jre3PMmByoPAKBT67gi+QpuHn4zsX6xXTlsIYQQQgghhBDi5FnqoPxQ05S75sqnDDCeZPgUkdrU/ykVfEM7fHhmu5nlWcvdi5ABBHkHccPQG5ifOt/dSkdxOCh+/A8Yly8HlYrwJ//K17sjqas0M2pmPFOuSe7wsfUEEkr10VAK4IcPMtj3QyGBEXrm/2EiWp2m3X0VRWFD0Qbe3PMmO8t2Aq5O/xcmXcgtw29hUNCgrhq2EEIIIYQQQgjhyVzrmnZX1hQ+lWe4vhrz2z/GN+KoKXdDOjV8Ola9tZ4PMz7k3QPvUmmuBCBMH8ZNw27i6pSrPRYdU6xWih55hNqvvwGNhphnn2W/NZWdq/PwC/FmwR8n4eXTqevPdRsJpfpwKGVptPP+n37BZLQy/sIEJs1LOuExiqKwrXQbb+55k1+Kf3Fvnxk/k0UjFjEifERnDlkIIYQQQgghRH9mNrYETkeveFdb0P4xfpGtm42Hp4Kh63smVzZWsvTgUpalL6POVgdAtG80twy/hcuTL8db4+2xv9NkouCe39KwYQPodMQ+/zyWYZP5+JltKE6Fi34zkoSRZz59sKeSUKoPh1IAh3eUserNfag1Kq55bAKhMX4nfey+in0s3ruY7/O+d2+bFD2JRSMWMSlqUr9chlIIIYQQQgghRAdorDkqfDqq6XhdUfvH+EUd1etpSLeGT8cqqi9iyf4lLM9cjtlhBiApMIlbht/ChUkXolPrWh1jr64m/847Me/eg0qvJ+6VVzBMnsynz22jLLeOQWPDueD2vl0YIqFUHw+lFEXh69f3krOngqikQK74/VhU6lMLk7Jrsvnvvv/ydfbX2BU7AMNDh7NoxCLOHXAualXf6v4vhBBCCCGEEKKDuMOng0dVPqVDXXH7x/hFHdXrqSmECkvpEeHTsQ7XHOatfW+d8udlW2kpebfeijXrMJrAQOL//Qb60aPZvTafnz/KxEuv5bo/TcI30LvN4/sKCaX6eCgFUFdl5oMnN2OzOJh+3RCGTzu95uVF9UW8s/8dPsv87KSTXyGEEEIIIYQQ/UBjted0u+YQ6njhk39MGz2fUkAf3HXjPk1nMrPImpND3i23YisqQhsRwYD/LsY7ObnDPrv3JhJK9YNQCujQtLWtObJRvlHcOPRGrky+0qNhmxBCCCGEEEKIPqSxummFu2Om3dWXtH9MQGwbPZ+GgE9g1427AzQvEPb2vrfZUrLFvf28AeexaMQihocNP+FtmA8cIG/RbTiqqvAaOJD4//4Xr7jYDpnl1BtJKNVPQimnU+nwealtrSYQ4BXA/NT5XJd6HaH6zl/RQAghhBBCCCFEJzBVeYZOzf+uL23/mIA4z0bj7vCpd3/mtjvtrMpZxdv73uZQ9SGgZbX6W4ffSlLQiRcVA2jYsoWCX/8GZ0MD3kPTGPCf/6ANdX1uPpN+0L2ZhFL9JJQCKM+vc3fwP//WoaRMiOqQ27U4LHx5+EuW7F9Cbm0uAN4aby4bfBkLhy4kPiC+Q+5HCCGEEEIIIUQHa6hsCpwOtjQeL0uHhrL2jwmM92w03tzzqZeHT8cy2Uwsz1rO//b/j6IGVwN2vVbPVSlXcePQG4nyPfnP1HVr11J4730oViuGCROIe/01NH6u4MlUa+WDpzZjrrcxbu5Azrp0UKc8np5IQql+FEoBbPnqCFu/OoK3Qcv8P0zEL9inw27b4XSwLn8db+17i70VewFQq9ScP/B8bh5+M8NCh3XYfQkhhBBCCCGEOAUNFU2B00HPVe8ayts/JnBAU6Px5qqnpp5P3v5dN+5uUG2u5v309/kg/QOMFiMAIT4hXJ92PdcOuZZA71ObdlizfAXFjz8ODgd+551H7IsvoPZ2tdQ5etpeaKwfVz8yHo2u/ywmJqFUPwulHA4nn/1tO2W5dcSlBjPvt6M7fJ6qoihsK93G2/ve5qfCn9zbJ0VP4pZht3B2zNnHbfomhBBCCCGEEOI01Ze37vdUng6mivaPCRrgOeUuItVV+dTHw6djFdQV8L8D/2N55nL34l7x/vHcNOwm5g2ah4/21Io6FEWh6u0llP3tbwAEXn450X9+CpVW697nwM9FrHsvHbVWxTWPTiA0tn9M22smoVQ/C6UAqksa+OivW7HbnEy9NpmR53be9LpD1YdYsm8J3xz5xr08ZnJwMjcNu4m5CXPRaWTFPiGEEEIIIYQ4JYriqnA6tt9TeTqYKts/Lmhgy7S7iDTX17AU8O5fQcix9pTv4Z3977Ambw1OxQnAsNBh3DL8Fs4bcB4ateaUb1NxOCh95lmq33sPgJCbbybioQc9CjSM5SaW/WUrdouDyVcMZszsAR3zgHoRCaX6YSgFsHd9AT8uO4RGp+aa/5tASLRvp95fcX0x/zvwPz7N/JRGeyMAEfoIrh96PVelXEWAV//7PxBCCCGEEEKI42oOn9xT7pq+lh2Exqp2DlJB8MC2K5+8OvdzX2/iVJz8kP8DS/YvYUfZDvf2c2LO4ebhNzMxauJpz/BxNjZS+PsHqf/+ewAiHvw9Ibfc4nF7TqfC8r/voCTbSExyEJfeNwZ1P1ht71gSSvXTUEpRFL56ZTd5B6oIH+DPlQ+PQ6Pp/HmrRouRTw59wtKDSylvdM1dNmgNXJF8BTcMvYEYv5hOH4MQQgghhBBC9CiKAvVlnqFTc9+n44ZPCU0VT0Oa+j0NaQqfDF05+l7FbDfzxeEvePfAu+TU5gCgVWu5KPEiFg5bSHJw8hndvr2ykvxf/wbznj2ovLyIee5ZAubObbXf9lU5/LIiG52Phvl/mEhAqP6M7re3klCqn4ZSAA01Fj54ajMWk53xFyYwad7JLWPZEWwOG18f+Zol+5eQVZMFgEalYfbA2SwctpBhYdIUXQghhBBCCNHHKArUl7Zd+WSuaecgFYQkeq501xw+6fpnkHE6qsxVfJj+IR+kf0C1pRoAfy9/rkm5huvSriPCEHHG92HJPkL+HXdgy89HExhI3Gv/wjBuXKv9yvPq+OS5bTgdCuctTCP17Ogzvu/eSkKpfhxKAWRuK+W7xftRqeCKB8cRlXRqqwicKUVR2Fi0kSX7l/BL8S/u7eMjx7Nw2EKmxU1Dreo/Kw8IIYQQQggh+gBFgbqStiuf2gufVGoITmyZbheeKuFTB8g2ZvPegff44vAXWBwWAGJ8Y7hh6A1cnnw5vrqOmdJo2r6dgt/chcNoRBcfT/y//413UmKr/ew2Bx89vY3q4gaSRodzwR3D+/VCYBJK9fNQCmD1W/s5tKWUwHA91z4+EZ33qTdx6wjpVem8s/8dVh1Z5W6KPjBgINenXc+lgy7FoJMSVCGEEEIIIUQPoihQW9TGancZYDG2fUxz+NTcaLw5hAodLOFTB1EUhV+Kf+HdA+96rAg/LHQYNw2/iVkDZqFVa49zC6emdtUqih56GMVqxWfUSOJfew1taGib+/78SSa71+SjD/BiwR8movf36rBx9EYSSkkohcVkY9mft1BfbWHYtFhmXDekW8dT0lDC++nv88mhT6iz1gEQ4BXAVSlXsSB1AVG+Ud06PiGEEEIIIUQ/oyhQW9jGancZYKlt+xiVGkKSjpl21xw++XTt+PsJq8PKyuyVvHvwXTKrMwFQoWJG/AxuGHoD4yPHd2hVkqIoVL31NmXPPw+A36zziH3+edT6tsPFgoxqPn9pJwAX3TWShBFhHTaW3kpCKQmlAMhPr+KLl3cBcPHdoxg4vO1UtyuZbCZWZK1g6cGl5NXlAaBVaZmdMJsbh94ofaeEEEIIIYQQHas5fHIHT83T7o4XPmmawqchntVPYcmg9e7a8fdTVeYqPsz4kGXpy6gyuxrD67V6Lht8Gb9K+xUDAgZ0+H0qDgelf32a6vffByD4hhuIfORhVJq2Zx5ZGu0se2oz9dUWhk6N4dzrUzt8TL2RhFISSrn99NEh9qwtwBDgxfw/TkTv1zPKCB1OBz8U/MC7B95lW+k29/axEWO5ceiNzIifgUbdPVMOhRBCCCGEEL2QooCx4Jgpd02VT02zNVpRayFk0FHhU9OKd6GDJHzqJlnVWbx38D2+PPwlVqcVgEhDJNelXceVyVcS6N05PZOdDQ0UPvgQ9WvXgkpF5CMPE7Jw4XGPWfP2ATI2lxAQrufaxybg5dNx0wd7MwmlJJRys1sdfPT0VqpLTAwaE86c23tew7UDlQd478B7fHPkG3ffqVi/WBakLuDy5MsJ8JL/SyGEEEIIIUQTRQFj/jFT7prDp/q2j1FrXVPsmkOn5hAqZBBoe8aJ+/7MqTj5qeAn3jv4nsdiWcNDh3PjsBuZNXAWOrWu0+7fVlhI/m/uwpKRgcrbm5i//Y2AObOPe0zW9jK+/c8+VCq4/PfjiB7UtQuM9WQSSkko5aE8r45Pnt2G06kw66Y0hpzVM5emLDOVsSx9GR8d+ghjUwNBvVbPvEHzuD7tehIDW69yIIQQQgghhOijnE5X+FSe4bniXcWhE4RPya0rn0KSJHzqgeqt9azIWsH76e+TX5cPgFqlZmb8TG4cdiOjw0d3elGFaccOCu6+B0dVFZqwMOJe+SeGMWOOe0yD0cIHT23G0mBn3AUDOeuyQZ06xt5GQikJpVrZ9nUOm7/IxstHw7WPTyQgrOeuANFob+Tr7K957+B7ZNVkubefE3sOv0r7FZNjJqNWqbtxhEIIIYQQQogO43SCMa8ldHKHUIfA1tD2MWqdq/IpIrWl31N4qmvanabzKmpEx8itzeWD9A9YkbWChqb/Y38vf65MvpL5qfOJ9YvtknHUfPopxX96Emw2vIemEf+vf6GLPn4Rh+JU+Opfu8nbX0VYvB9XPTwejVY+nx5NQikJpVpxOpwsf2EHJdm1hA/w58oHx6HR9exfHEVR2FKyhfcOvscP+T+g4PpxTQhI4Lq067h00KUYdIZuHqUQQgghhBDipDidUJPbduWTzdT2MWqdq7m4e7W7pq8hSRI+9TKKorCpeBNLDy7lp4Kf3J/vkgKTuD7tei5OurjLPt8pdjtlz/+dqnfeAcB/zhxinnkateHE97/tmxw2f56NRqvmmv+bQEiMb2cPt9eRUEpCqTbVVjby0dNbsTTYGT4tlunXDenuIZ20/Lp8Pkj/gOWZy6m3uUp1/XX+XJZ8GQuGLCA+IL6bRyiEEEIIIYQAwOloCZ+OrXyyN7Z9jMbLNe3u2MqnkCTQSPPo3sxkM/FV9le8f/B9DhsPu7dPi5vG9WnXc3b02V3a99hRV0fh/Q/Q8NNPAITdfTdhv/k1KvWJizYK0qv44h+7UBQ494ZUhp4T09nD7ZUklJJQql25+yv56tXdoMCsm4cyZFJUdw/plDTYGvg863PeT3+f3NpcAFSomBI7hQWpCzgn9hyZ2ieEEEIIIURXcDqgOqf1ancVmccPn8JSmkKnIU3VT2kQnCjhUx+TY8zhw4wPWZG1wl1YYNAauGzwZVyXdh0DAwZ2+ZisOTnk/+YurNnZqHx8iHn2WQIumHNSxzbUWPjwr1torLOROjma825M6+TR9l4SSkkodVybv8hm29c5aL3UXP1I7yw3dCpONhRu4P309/m58Gf39gH+A7h2yLVclnyZrNonhBBCCCFERzg6fCo72BJCVWSC3dz2MRpvCE/xrHoKT4XgBAmf+jCH08GGItfntA2FG9zbBwYMZP6Q+Vw6+FL8vfy7ZWwNGzdScN/9OI1GtFFRxP3rVfTDhp3UsQ6Hk89f2klxlpHQWD+ufHgcOi9NJ4+495JQSkKp43I6Fb785y4K0qsJjjJw1SPj8fLpvS8MebV5LMtYxorMFdTZ6gDXqn0XJ13M/NT5pASndPMIhRBCCCGE6AWcDqg60hQ6Nfd8Snf1fHJY2j5G69NS+RRxTPiklg/t/YXRYmRF1gqWpS+joL4AcM1omRY3jQWpCzg75uxum9GiKArVS9+n9JlnwOFAP2oUca++gjY8/KRvY+OnWexcnYfOR8M1j04gKFJ6Gx+PhFISSp2QqdbKR3/dQoPRSvL4CM6/dViXzuPtDM1zlT9I/8Bj1b7xkeNZkLqAcweci04tzRCFEEIIIUQ/57BD9RHPKXfNlU8nCp8i0pqm3TV9lfCpX8uoyuCD9A9Ymb0Ss8NVNefv5c8Vg6/g2iHXdnvvX6fFQulf/kLNx58AEHjppUQ99SRqb++Tvo3sXeV888ZeAC64fTiDxkZ0ylj7EgmlJJQ6KcVZNSx/cSeKU2Ha/BRGzIjr7iF1CEVR2Fa6jQ/SP2Bt3locigOAcH04V6VcxZXJVxLpG9nNoxRCCCGEEKKTNYdPR0+5K0uHykxwWNs+RqtvmnbXFDo1h1BBAyV8EgBYHBa+y/mOjzI+Ylf5Lvf2lOAUrku9jguTLkSv1XffAJvYCgsp+O3vMO/fDyoVEQ/cT8itt55SMYax3MRHT2/D2mhn1HnxTLk6uRNH3HdIKCWh1EnbtSaPDZ9kodaouOL344hM7FvPW0lDCR9lfMSnmZ9SZa4CQKPScG78uVybei2Toib1+goxIYQQQgjRzzlsTdPuDnqueHe88ElnOGba3dHhkywcJForqCvg40MfszxzOdWWagC0Ki0zB8zkurTrGBsxtsd8tqr/6WeKfv97HEYjmqAgYv7+d/ymnHNKt2G3Ovj0+e1U5NcTlRTIZQ+MQaOR342T0aNCqX/96188//zzlJSUMGrUKF555RUmTpzY5r5Llizh5ptv9tjm7e2N2dxO87xjSCh16hRFYdW/95G9qxy/EG+u/b+J+Pj1vSluNoeNNXlrWJa+jB1lO9zbEwISuGbINcwbNI9A78BuHKEQQgghhBAn4LBB5eGWqid35VMWOG1tH6MztKxy13yJSIXAARI+iRNqbly+LH0ZPxf+jIIrQog0RLpnoYQbTr43U2dTnE4q3niDildeBUXBZ/hw4v7xMrrY2FO+rXXvpXPg5yJ8/HRc+9gE/IJ9OmHEfdPJZjOd3tn6ww8/5P777+eNN95g0qRJvPzyy8yZM4eMjAwiItqehxkQEEBGRob7+56StPZVKpWKmQvTqCisp7a8kTVLDnDRb0aiUvet512n0TE3cS5zE+eSWZ3Jhxkf8lX2V+TU5vC3rX/jnzv+ydzEuVybei3DQk9uBQYhhBBCCCE6hd0KVYdb93yqzAKnve1jdL4t4dPRDccD4yV8EqessrGS5VnL+TjjY4oaitzbJ8dM5poh1zA9bjpadc9aLMthNFL00MPU//ADAEHXXEPkY/93Sv2jmqVvKubAz0Wggtm3DJNAqpN0eqXUpEmTmDBhAq+++ioATqeT+Ph47rnnHh555JFW+y9ZsoR7772Xmpqak7p9i8WCxdLSiK+2tpb4+HiplDoNFQV1fPLcdhw2J5MuTWL83ITuHlKna7A1sDJ7JcsylpFZnenePix0GFenXM3cxLkYdLKqghBCCCGE6CR2qytoOrbyqepw++GTl59no/Hmnk8BcRI+iTPS3Jv344yPWZO3BltT9V2AVwCXD76cq4dczcCAgd08yraZ09MpuOe32PLzUXl5EfXEEwRdecVp3VZlYT2fPLsNu83JxEsSmXBRYgePtu/rEZVSVquV7du38+ijj7q3qdVqZs2axaZNm9o9rr6+noEDB+J0Ohk7dixPP/00w4a1XbnyzDPP8OSTT3b42PujsDh/pi9IYe3/0tnyRTZRiQHEpYZ097A6la/Ol2uGXMPVKVezq3wXy9KXsTp3Nfsr97N/036e3/Y8FyddzNUpVzMkZEh3D1cIIYQQQvRWdkvTtLuDx1Q+HYamRXla8fJvCp2aq56awqfAOJDZJKID1Zhr+Pzw53xy6BNyanPc24eHDufa1Gu5IOECfLQ9t1KoZsUKSp74E4rFgi42lth//gN9OxnCiVgb7Xzz773YbU4GDA3pF8Ua3alTK6WKioqIjY1l48aNnH322e7tDz30ED/88AObN29udcymTZvIzMxk5MiRGI1G/v73v/Pjjz+yf/9+4uJarwwnlVIdb+3/DnJwYzF6fx3XPjYR36BTL3XszarMVXye5fqDnFeX594+MnwkV6dczZyEOT1iJQkhhBBCCNED2S2uyqfmRuPNjcePFz55B3j2fGoOoQJiJXwSnUZRFHaU7eDjQx+zOmc1VqerIb5Ba+DCpAu5OuVqhoYO7eZRHp/TaqX0mWeo+WAZAL5TpxL7/N/QBAWd1u0pisK3/9nP4R1l+AV7c81jE9D7eXXgiPuPHtHo/HRCqWPZbDbS0tJYsGABf/7zn0+4vzQ6P3N2q4NPnttOZWE9EQkBXH7/GLRe/W/pV6fiZEvJFj7O+Ji1eWuxK67yaX8vfy5JuoSrU65mcPDgbh6lEEIIIYToFjaz57S75hCqKvsE4dMx/Z7CUyEgRsIn0WWMFiNfZX/Fxxkfc9h42L09LSSNq1Ku4qKki/DV+XbjCE+OtaCAwvsfwLxnD6hUhP3mN4Td9RtUZzCFdfuqHH5ZkY1ao+LyB8YSlSQLYZ2uHjF9LywsDI1GQ2lpqcf20tJSoqKiTuo2dDodY8aMISsrqzOGKNqg9dJwwR3D+eS5bZTl1LJmyUHmLBrW5xqfn4hapeas6LM4K/osKhorWJG1gk8OfUJhfSHvp7/P++nvMyZiDFcmX8nshNlSPSV6DEVRwGZDsdtbLjY72D230XxOQqUCVKBq/lbl2nbURaXzQuWlQ6XTodJ5ofbSgU4nC1EIIYTo+2xmqMz0nHJXnt4UPjnbPsY7sCl4Oqbvk3+0hE+iWzRXRX2W+Rnf5nyLxeGabaTX6pmbOJerU65mWOiwXvPernbVKoof/wPO+nrUgYHE/u05/KZPP6PbzNpexi8rsgGYek2yBFJdpEsanU+cOJFXXnkFcDU6HzBgAHfffXebjc6P5XA4GDZsGBdeeCEvvvjiCfeXSqmOU5RZzecv78LpUBh3wUDOumxQdw+p2zkVJ78U/cLHhz5mXf46HE1nwfx0flyUdBFXJF/R40tcRc+kOBw4amtxGo04amtxGI04jLU4jDU4a2tx1NbhbDShNDbiNDXiNJlwNjbibGxEaf63yYTTbAZ7O01RO4NOh1rXFFZ5eaEy6FHrDagNTRe93vXV14Cq+d8GX9R+vmj8A9AEBqAOCEATGIgmIAC1n98Znd0SQgghTputESoOuaqd3FPv0qH6SPvhk09g62bj4WngHyXhk+gRKhsr+fLwl3ya+alHr6iU4BSuTrmai5Iuwt/Lv/sGeIqcjY2UPvMsNR99BIB+zBhi//48utjYM7rdkiNGVry4E4fNyaiZ8Uy5Jrkjhtuv9YjpewAffvghCxcu5N///jcTJ07k5Zdf5qOPPiI9PZ3IyEhuvPFGYmNjeeaZZwB46qmnOOussxg8eDA1NTU8//zzrFixgu3btzN06Ik/7Eso1bHSfynm+yUHAZh5Yxppk6O7eUQ9R7mpnM8Pf86nhz6loL7AvT0tJI0rk6/kwqQLe9UfeNHxnGYz9ooK7OXlrktFBY6KCuzlFS3f19TgMBpx1tV17mA0GlRarfvSXOWkoIBCS9WUonheAMXpRLHZUGw2cLQzHaGjqFSo/f3RBAS4LkGBaIJD0ISGoA0JQRMSgjY0FE1wCNpQ1/dqP79ec1ZPCCFED2A1tYRPzf2eyg5CdQ6uF8U2+AR5hk7hKRI+iR7LqTjZVLSJTzM/ZV3+OuxNqzg2V0VdkXwFI8NG9rr3T5bMTArvvx9LZhaoVITefjvh99ztem97BmorGvnkuW001tlIGBHK3F+PRN3PZgl1hh4xfQ/g2muvpby8nD/+8Y+UlJQwevRoVq1aRWRkJAB5eXmojzorXl1dzW233UZJSQnBwcGMGzeOjRs3nlQgJTpe6lnR1JSa2P5NLuuXphMQ5kNsSnB3D6tHCDeEs2jEIm4ZfgtbS7by6aFPWZO3hoNVB/nL5r/w921/Z3bCbK5MvpIxEWN63R99cXyK3Y69tBRbUZHnpbAIW3Ex9oqK0wqa1AYD6qBANAGB7uohTVAgaj//piojV7WRSt9ckaR3VyO5tuldFUtHB1BabYdVHykOhzugUqxWz68WC06zuamSqwGnqbmyy9RS3dV8qa93VYbVNlWE1daimM2gKDhra3HW1mI7yTGpdDo0oaFow8PRRkSgjQhHFxHR9O9I9zZNUJD8HgohRH/iDp+aez6lu0Ko6lzaDZ/0wa6wyd3zqSmE8ouQ8En0eCUNJSzPWs6KzBUUNRS5t48IG8EVyVcwN3Fur+gVdSxFUaj55BNK//o0itmMJiyM2L89h+/kyWd829ZGOytf20NjnY3QOD/Ov3WYBFJdrNMrpbqaVEp1PMWp8N1/95O1vQxvg5arHh5PUKShu4fVI9WYa/gq+ys+zfyUrJqWPmiJgYlcPvhyLhl0CWH6sG4coTgVjvp6rDm5WHNyXJe8XHf4ZC8tO6mqIZW3N9qwMFdgEh6GJizM9X1Y0/fBwWgCg9AEuiqDVDpdFzyynslptbqmL9bVuarHamtx1NRgr6rGUVWFvaoSR2UV9uoqHJVVOKqqcJpMJ337Kp3OFVBFRaGLjkYXE4MupulrdDTa6Bg0fr3vjZoQQvR71gZX+HRsz6fjhk8hTZVPx6x25xsu4ZPoVWwOG+sL1rM8czkbijbgbJpq2rw40xXJVzAkZEg3j/L0OerqKHniCWq//gYA33POIea5Z9GGnflnKqfDycrX9pC3vwpDoBdXPTwe/xCfM75d4dJjpu91NQmlOofd6mDFSzspPVJLYISeqx4aj49f//3wfCKKorCnYg+fHvqUVTmraLQ3AqBRaZgaN5XLB1/O1Lip6NTyHHY3xWbDml/gCp2OHGkJoHJysJeXH/9gne6ocOPoS7SrQic8TKaWdTJnY2NTYFXlmhJZVoa9rAxbWRn20jL3947q6pO6PXVgoMf/qVd8HLr4eLzi49HFxaHWy4IGQgjRbawNLX2e3JVP6VCTR7vhkyH0qODpqOl3fuFdOnQhOtqh6kMsz1zOyuyVVFta3udMiJrAFclXMGvALHy0vTtgadyzh8L7H8BWUABaLRH3/o6QW27pkBkAiqLw47JD7PuhEK2XmssfGEvEQMkPOpKEUhJKdThTrZVPnt1GXZWZmOQg5v1uNBqtNCQ+kXprPd/mfMvyrOXsLt/t3h7iE8K8QfO4bPBlDAqSJvKdTVEU7GVlWDIyMGdkYDmUiSUjA0t29nEbg2tCQ/FKTMArIQGv+AHoYmNdgUVsLNrwMGnK3Us4rVYc5eXYSsuwl5Y0VbwVu74WF2MrLsZpNJ7wdrTh4U0hVRy6+AEtXxMGogkOlgBSnDLFqeB0nPxbMZUa1Br5uyP6OEs9VGQc1XD86PCpHYawo0Kno0IoX6lQF32H0WLkmyPfsCJrBfsr97u3R+gjmDfY9bliYMDAbhxhx1CcTqqWvEPZiy+C3Y4uNpbYF/6OfvToDruP3Wvz+fmjTFDB3DtGkDRaguqOJqGUhFKdorKons/+th2r2UHqWVHMXJgmH8JOQXZNNiuyVvDF4S+oNFe6t48MG8llyZdxQcIF0hy9AzjN5lbhk/nQoXZDB5XBgFfCQLwTEvBKSGwJoQYORCN/R/oNR3099uKjgqrCQqz5Bdjy8rDm55+wR5g6IACvxISmn6MEvBIT3T9HUmHVuzkdTiwmO+YGG+Z6G5ZGOzaLw3UxO7Ca7a6vFgc2S9O/zQ7sVgcOuxOnQ8Fhc+JwOHHYFZx2Jw6HgtPmxOk89bdhKhWotWo0WjUarQqNVo1a0/S1abtWp0bnrUHno8HLW4POR4vOR4POW4OXj7bpq2u7j68WH18dPr46tF6aTngGhWiHpQ7KDzU1G09vCqHSwXic8Mk3vCV0cq94lyrhk+iznIqTzcWbWZ61nO9zv8fqtAKgVWs5N/5cLht8GZNjJqNVd3q76C5hKyqi6P8ew/TLLwD4z5lD9J+f6tD35Dl7Kvj69T0oCky+YjBjZg/osNsWLSSUklCq0+Ttr+Srf+1BcSpMujSJ8XMTuntIvY7NaePngp9ZnrWcHwt+xKG4ehP5aHyYNXAW8wbNY2LURDRq+XBwIordjuXwYRr37MG8dx+N+/ZiOZTZdvWTRoNXYgI+KUPwHjIE75RkfFJS0MbESLgqTshhNGLNy8dWkO/x1Zqfh724pGUFwzZoo6NdwWdiIl6DBuE9aDDeg5LQhIXJz143cDoVGuusmIxWGowWTEYrploL5no7jQ1WzPVNAVSDDUuDDYup/WrKvkbrpXYFVH46d1DV/L3e3wvfQC8Mgd5NX73Q6uR1SpwEc21Tz6ejqp7KM8CY3/4xvhFHhU7NK96lgm9o141biG6UV5vHF4e/4MvDX3o0LU8OTubywZdzUdJFhPiEdOMIO5aiKNR+8QUlf/4Lzvp6VHo9kQ8/TNC113Toe6WKgjo+fX4HdouDoVNimHH9EHkv1kkklJJQqlPt+6GAHz44BMDsRcNIHh/ZzSPqvSoaK1iZvZLPMj8j25jt3h5piGTeoHnMGzSPhMCE7htgD6IoCra8PBr37sO8dy+Ne/diPngQpbGx1b6akBB8UlNd4dOQFHyGDMErKQm1t3c3jFz0dU6zGWtuXuveZEeO4DjOtEB1YCDegwbhPSipJawaPAhtVJS8QTpNDpuTumozdZVm6qrM1Fdb3MFTQ40Fk9GCqc6GchoVSt4GLd6+Orz1R1UaHVWF5K5IarpO66VBo1OjOaaKqaW6SY1Gp0KtUXMy/9sKrul+DrvTVYFlP+rfx1Rj2a0tlVw2ix2r+ZjKrqZKL2tjcwBnP+3nxDfIG0OAF76B3vgGeeEb5I1/iA/+oT74h/jgbZD+if2G2XhU5dNRU+9qC9s/xi/yqNCpKYQKGyLhk+iX6qx1fJvzLV8c/oKdZTvd2/11/lyYdCGXJ1/O0JChfe49gr26mpI/PkHd6tUA+IwaSexzz+GVkNCh99NQY+GT57ZRX20hLjWYi+8ZhUamxHcaCaUklOp0P3+cye7v89Ho1Fx2/xiiEgO7e0i9mqIo7K3YyxeHv+DrI19TZ22ZKjQyfCSXDrqUOQlzCPTuP8+zYrdjPpiOafs2Grdvx7R9B46qqlb7qX198Rk+HP2I4fgMH4F+5Ai00dF97gVb9E726uqmgCoH65FsLFmHsWQfxpaX3251ldpgwDs5Ge+UlKMuyWiDg7t49D2Pw+6ktqKR2sqm4KkpfKqrbKSu0kxDrbXdfsceVLRU/gS4Kn/c1UHHfvXV4eOr7dO9nBRFwWp2YK63uacpHvvVVGfFZLTQ0FRh5rSf3FtIL722JaQK9SGgKazyD/UhMFwvoVVvZDYeFTpltIRQJwyfjmk2Hj4EDH2n0kOI0+FwOvil+Bc+P/w5a/PWYnFYAFCr1JwdczaXDrqUc+PP7fVNy9tTt349xY//AUdFBWi1hN99F6GLFqHSdux0RJvFwfIXdlCeV0dwlIErHxonrz+dTEIpCaU6ndOp8M0be8nZU4HeX8flD4wlOEqWU+8IFoeF9fnr+TzrczYWbXRP7/NSe3HugHOZN2hen5o73sxpsWDeswfTtm2Ytm2ncedOnCaTxz4qnQ7vtDT0I0bgM2I4+hEj8EpMlIbjotdxms1Yc3KwZB3Gmn3YFVYdPow1N7fd5vva8PBWQZX34MF9rgLQ6XBSV2WmpqwRY5mJmtKmr2Um6irNx5spCYBWp3YHIH7BPi1TzoK83SGUIUDXp0OmzqYoChaT3VWFVmOlodbing7ZUG2hrspMbaUZc73thLel99cRGG4gKFJPYISBoIimf4cb0HnL9MBu1VjjGTo1h1B1Re0f4x/dRuVTioRPQhwjuyabzw9/zleHv6Ksscy9fVDgIOYNnsfFSRcTYYjoxhF2LmdDA6XPPkfNxx8D4DV4EDHPPYd+2LAOvy+H3ck3/95L7t5KfPx0XPXweALDpd9nZ5NQSkKpLmE121nx4k7K8+rwDfLmit+PJSBMfsE7UvP0vhVZK8iqyXJvD9OHMTdxLpckXUJqSGqvrApyWq007thJw6ZNmLZuxbx3L4rN8wOM2t8f/dgxGMaNxzB+PD7Dh6H28uqmEQvR+RSbDWtODuZDh1yN+g8dwnLoELbCdioQNBq8k5LwTkvFJzUNn6FpeA8Z0iuqqmxWB9XFDVQVN1BV1EB1iYmaUhO1FY3HXZFO660hMKy52kbfqgrHx0/XK/8m9kU2i8Ozmq0prKqrdH1trLUe93jfQC8CIwwERxkIifElJNqXkBg/9P7yf9yhGqubwqd0V6Px5r5PdcXtH+MfAxGpRzUdb2o8rg/qsmEL0dtUNlayKmcVXx7+0mP1vEDvQOYmzOXSwZcyLHRYn//7Ztq+naJHHsWW7+orF7JwIeH339cpJ9mcDiff/fcAh3eUodWpmfe70UQPDurw+xGtSSgloVSXaay3svyFnVQXNxAQ5sPlD4zDL7hvnbXvCRRF4WDVQb44/AUrs1dSY6lxXzc4aDAXJV3ExUkXE+Ub1X2DPAFFUbBmZdGwcSP1GzZg2rqtVT8oTXiYO4AyjB+Hd3IyKo2cKRfCUd+AJfOooCrTtbJkez2rtNHR+KSm4pOWindqKj5paeji4rrlja7d6qC6xERVUb0rgCp2/bu20tzuVDuNVk1ghJ7AcD1Bka7qmcAI178NAV59/g17f2FttGMsb6SmzOSuinP9uxFzQ/tVVj6+uqNCKtfX4GhfDAFy0uK4Gqs9Q6fmEKq+pP1jAmJbQqeIo8Inn/7TTkCIM2G2m1mXv46vsr9iQ+EG9wwIjUrD1NipzBs8j+lx0/HS9P2/X06rlYpXXqFy8X9BUdDGRBPz9DP4njWpU+5PcSqsffcg6ZtKUGtVXPTrkQwYJv3quoqEUhJKdakGo4XP/r6D2vJGgqMMXHb/WHlj2IlsDhs/F/7MV9lfsT5/vXtpWBUqJkRN4OKkizl/4Pn4efl170ABe2UlDRs30bBhAw0bN2IvK/O4XhMWhu/ks/GdNAnD+PHoBgyQD5tCnCRFUbCXlmI+eBBLejrmg+mY09Ox5bW9nLo6MBCfoWn4DB2KftgwfIYN6/DfuQajhYqCeiry66jIr6eioJ6aMlO74ZOPn84jWAiKNBAUacAvyBuVWv4W9GfmBpsroCo1UVVioqrIVVVXW9HY7s+T3l9HWJwfYfH+hMX7ER7vT2CEAXV/+1kyVXmGTs3/ri9t/5iAuGNWu5PwSYjT5VScbCvZxpfZX7I6dzUNtgb3dcNDh3PxoIu5IOECQvX9JyBp3L2b4scfx5LpmvkReNllRD72f2j8/Tvl/hRF4adlh9j7QyEqtYoLbhtO0pjwTrkv0TYJpSSU6nK1lY0s//sO6qsthMX7cem9Y/DxleZxna3WWsvqnNV8lf0V20q3ubd7a7w5N/5cLhl0CWfHnI1O3TX/F4rTiXnfPurWrqX+hx+xHDzocb3K2xvD+PH4Tp6M75Rz8E5JkRBKiA7mqK/HkpHRFFIdxHLgIJbMzFbTY8E1RdYnLQ2fppDKZ+hQvBIGnrBPm+JUMJY3Uu4On1xfTe1Mx/L21bqnXh0dQskJDHGqbFYHNUdX3rnDKnOb+2t1akKbg6o4V1AVEuuLzqsPVOE2VDYFTsf0fGooa/+YgDjPaXfNPZ985H2zEGcqqzqLL7O/ZGX2SkpNLSFwjG+Ma1bDoItJCkzqxhF2PafJRPk//knV//4HioImJISoPz1BwOzZnXafiqLwy4rD7Pg2D1Qw66ahDJnUc2eT9FUSSkko1S1qSk189sIOGmutRCYGMO93o/Hy6VvNuHuyovoiVmav5MvsLzliPOLeHuQdxJyEOVyUdBGjwkehVnVsc1+n2UzDpk3Ur11H3fp1OMorPK73TkvDd/LZ+J1zDvpx4/pcU2YhegPFasWSlUXj/v2Y9+/HfMBVXaVYW4dIan9/fIYPQz/ctaCAz/DhmL2CKcutoyynltKcWsrz6rBZHK3vSAXBkQaPapXQWD+Zcic6nc3ioLKonsqCesrzXdV6lYX12K3OVvuqVBAS40vEwAAiEgKITAggJNa35y4N3lDRVPV0sKX3U3k6NJS3f0xg/DFT7tIgPAW8O6cqQYj+qri+mK+PfM3XR77mUPUh93Z/nT+zE2ZzyaBLGBMxpsPff/cGDRs3UvzHJ7AVFAAQMO8SIh99tNP7Xm77OofNX2QDMOP6IQybGtup9yfaJqGUhFLdprKwnuUv7sDSYCd2SBAX3zUKbV84G9mLKIrCgaoDfHX4K74+8jVV5ir3dTG+McxNnMuFSReSEpxy2vdhr6ig/ocfqFu7joYNG1DMLWeo1b6++E6div+5M/A95xy0YWFn8nCEEJ1EsdmwHD7sCqn2H3B9TU/H4tRS5z+QWv8EagMGUOufgM2r9QdZjU5NaKyfe5pUWJwrgJIV00RP4XQqGMtMHtV85fl1NNa1rhrU6NSExfkRmdASVAWG67t2GmlDRVPwdMzUO1NF+8cEDmiadtccPKVK+CREJ6s2V7M6dzUrs1eyo2yHe7tWrWVq7FQuGXQJ0+Km4a3pPydiFUXBbrfjcDhw1NVRuXgxdd+tBkATHk74PXfjO2FCp48jfVMx21flAjB2zgDSJsd0+n32VxqNBq1W2+5JRwmlJJTqVqU5tXz+8k5sZgcDh4cy984RaLT97+xAT2B32tlSsoWV2Sv5Pu97jzntzQ3S5ybOJdbvxGcQrAUF1K1aRd2a72ncvZuj12XXRkfjf+65+M2ciWHiBFkhT4hewulwUlnYQEm2keLDRkqzja4G5MdQOR34NRQQUJuHf10uAXW5BIbq8B05Av2oUehHjcQnNRWV/O6LHk5RFBpqrJTl1lKWU+v6mluHxWRvta+XXktkgj9RSYFEDwoiMjEAL/0ZVoArSlPl0zFT7soPgqmy/eOCBh5T+ZTqmnbn3f39I4XoD0w2E+vy1/H1ka/ZWLgRu+L6m6FCxfio8VyUeBGzBs4i0Lv/9WGzWq0UFxdjMplwNja6FmFxuqpU1QZf1AH+J2wL0BFsFgfmetdJBy+DFu8z/XstTshgMBAdHY1XG+//JJSSUKrbFWXW8OU/d2G3ORk0NoLZtw5F3VPL4vsJs93MjwU/sjJ7JT8V/oTN2XKmeEzEGOYmzuX8gecTpm+pbLIVF1O76ltqv/kG8549HrfnM3w4fufOwH/mTLxTU2VqjhC9gMVko+RILSWHm0KonFrsbUzDC4o0NFWM+BMe7Y1vbQH29H007t2Hec8erLm5rY5ReXm5+lONGtkUVI1CFxsrfxtEj6coCsayRspyXdNTy3LqKM+vw2E7ZuqfCkJj/IgaFEj0oECikgIJCPNp+2dcUVzT644OnZqn3rUbPqkgeGBL6NQcQoWlgJdvhz9uIcTxWR1WNhZt5Jsj37Aufx2N9pZVo9NC0rgo6SLmJMzp0atfdzan00lmZiZqlYoQtRq1yYQKUOm80EZGoDEYumQcFpON+moL4FpERdoGdC5FUbBarZSXl+NwOEhOTkZ9TPAooZSEUj1C3v5KVr6+B6ddIfWsKGbemCarKfUQRouR7/O+5+vsr9lSsgWlaSkjtUrNDP1ILs2NYMDWfGy797YcpFZjmDCBgAvm4DdzJrrIyG4avRDiZNVWNlKUWUPxYSMlh41UFTe0WrnMS68lKimAqCTXh+yIhIATnl10GI007t1H4+5dNO7Zg3n3Hhw1Na3204SGoh85Ev2YMehHj0I/YgRqvb4DH6EQncPhcFJV2EDpEVeAW5JtbLOZuiHAi6gB3kSF1RPjl0u4cw/qiqYpeI1VbdwyuMKnhLYrn7y65gOcEKJtNqeNLcVbWJWziu9zv6fOVue+Lt4/ngsTL+TCxAtJCupfDcvb02gykX3gIDF6H3wUBVChDQ9DGx7eJdVR4AqkjOWuwFDv54VfiLcEUl3EZDKRm5tLYmIiPj4+HtdJKCWhVI+RvaucVW/uQ3EqDJ8ey7T5stpaT1NmKmP1zk8o/Wo5A7cVkJoPzS8higrMQxOJvvQqwudegjZcllIVoqdqrvYoyqqh6FANhZnV1FdZWu0XGK73qPQIifY94xMGiqJgy8ujcc8eGnftdgVV6elw7Ip/Wi0+Q4agHz26KagajS42Rl4XRM+nKDQUFVCyJ5PirCpKCqHcGIhT8eyhplOZiNalE+O1nxivA0RE2NFEphxV/TREwichehiH08GOsh18c+Qb1uSuodpS7b4uXB/OnIQ5zE2cy4iwEfJ6dRRzRgaFr7xCw+WXMyA8HL3BgC42tktPPlkb7dSUm0ABH18d/qHtVK+KTmE2mzly5IiEUkeTUKpnythcwpolB0CBYdNimT4/RSqmegCnxUL9unXULF9Ow08/u+d+A+QN1PN9soVfUlVU+6vwUnsxJXYKcxPnMi1uGgadvJkWorspikJ1sYmizGqKMmsozKzBZPRcTU+lVhEx0J/owUHuEMoQ0DV9n5wWC+b9B2jcvZvGXbto3LkTe1nrpeq14eGukGr0aPRjx+AzbJj0pRPdR1GgrqTtnk9mo8eudkVHuW0QxdY0ihlHsXkwFrtnY2OtTk1kUiCxKUHEDHb1pZIFYITofoqisLt8N6tyVvFdzneUN7asZhnsHczshNnMSZjD2IixaNTyO3s0R309Fa+8QtV7S3FGROD4w+MkpabiGx3dpYGQxWTDWGEGRcHboCUgTC+BVBeTUKoNEkr1XAc2FLHuvXRQIHlCJOfdlNZzl17uwxRFwbx3LzXLl1O78muctbXu63xGjCBg7lwCLpiDLiaGbGM23x75lm9yvuGI8UjLfhofpsZNZXbCbKbFSkAlRFdRFAVjeSOFGdUUpFdTeKi61Spiaq2KyIQAYlOCXR+AkwLw8ukZjT4VRcFeXEzjrl2Ydu6icdcuzAcPgt2zwbTKywufESMwjB2DfsxY9GNGd/ry0aIfUhSoK27d86ksHSzGto9RqSE4ESLSXBVP4U1fw5JBp8fpVKgqqqfwUA1Fma5Lc9PdZmqtiqjEQOJSg4kbEkxEYoC8HxKiizgVJ3vK9/Bd7neszl1NSUOJ+zp/L39mDZjFBQkXMDF6Ilp1z3jt7EkURaF25deUPfcc9nJXiKe/+mpM115D0uDBrUKJzmRusFFb4Zqy56XXEhjWxaulCkBCqTZJKNWzZW4rZc3bB3A6FAaOCOWC24bL2cIuYistxfjFFxiXr8Cane3ero2KIvDSSwm89FK8kxLbPFZRFA5VH2JVzipWHVlFQX2B+zp3QDVwtlRQCdEJGmosFGRUuy7pVa2m43lUYSQHEZnQu6ownGYz5n37WoKqHTtwVFe32s8rKQn92DEYxoxFP3YMXgkJcjZUnBxFgdqiNiqfMo4fPoUkHdVsvCl8Ck0G3cl/6DqZakadt4aY5CBihwQTlxpMWKyffLASogM1B1Hf5nzL6tzVlJpK3dcZtAbOHXAucxPmMjlmMjqNrhtH2rNZDh+m5Kk/Y9q8GQCvgQOJfPxxtBPGtxtKdJbGOit1Va4ef/1xyt5NN91ETU0NK1as6O6hSCjVFgmler7c/ZWsemMvdpuTmOQgLvzNSFmus5M4LRbq1qzBuOJzGjZscE/PU/n44H/++QRdfhmGSZNQaU7+A6yiKByoOsB3Od/xXc53rQKqKbFTmJ0wm+lx0yWgEuI0WEw2CjNqKEivoiCjmuoSk8f1ao2KqKRA9wfYyIQANNq+U2WhKArWnBwad+zEtHMHjdt3YD1ypNV+mtBQDGPHoh83FsO48fikpaLSymtJv6YoUFvoajBeln7UancZYKlt+xiVBkIHeVY9hae6Kp+03m0fc0ZDdPV9K2iudsyoxtzgWUnl46sjdkgQcakhxKUGExgu01GEOFVOxcnu8t2u96u531Fmapk6btAamBE/g9kJszkn5hx8tF1X3dMbOU0mKl5/ncol74DNhsrbm7A77yDk1ltRe3kdN5ToDA1GCw01rhN0Z9LUvCcFO6eqM8e+Z88e7rrrLrZu3Up4eDj33HMPDz30ULv7SyjVBgmleoeirBpWvrobq9lB+AB/LrlnFHp/6R/SUay5uVR/+BHGzz7zWA1LP34cQZddhv8FF6Dx8zvj+1EUhYNVB90v+Pl1+e7rvDXeTImdwqyBs5geNx1/L/8zvj8h+iKnw0lZbh15B6rIP1BJ6ZFaPF6ZVRAe7++e6hM9OAidd++phOoI9upqGnfupHHHDkw7dmLeuxflmAbqKoMB/aiRGMaNxzBuLPpRo1B30TLUoospChgLjppy1xxCZYC1ru1j1FoIaQqfjp56FzqoU8Knk6U4FSoK691Tcosya7BZHB77BIT5EJ8WwoChocQOCcLbIJUcQrTF4XSws2wna/LWsDp3tUcQ5avzdQVRA2dzTuw5eGu67/e+t1AUhbrVqyl95lnsxcUA+J17LpGP/R9ecXHu/boqlFIUhYYaC6ZaV7WpIdAL38DTX2WvL4dSVqsVr9PozVlbW0tKSgqzZs3i0UcfZe/evdxyyy28/PLL3H777W0eI6FUGySU6j3K8+r48pVdNNbZCI4ycMlvR+MfImcqTpdit1O/fj3VHyxzVUU10UZHE3T5ZQReeileAwd23v0rCulV6XyX66qgyqvLaxmDWstZ0Wdx/sDzmRE/gxCfkE4bhxC9QW1FoyuEOlhFQXo11kbPnkpBkQbiU4OJSw0hJiUIH1/5EHo0p9WKed8+TNu207h9O6adOz364wGg0eAzdCiGceMwTBiPfuxY6UvV2ygKGPNbNxsvzwBrfdvHNIdPEaktlU8Raa5t2p5/8svhcFKWU+eqlEyvpiTbiNPR8lZdpXb1jIsfGsKAoSFEDPRHLf2oRD9mc9jYUrKFNXlrWJu3lipzlfs6P52fO4iaHDtZgqhTYD54kNLn/obpl18A0MXGEvnYY/jPPLf1vseEEoqi0GhztNrvTCiKQl2VBUtTZalvkHebi7bodZqTDqlOFOzs27ePBx98kJ9++glfX19mz57NSy+9RFhYGAB1dXXceeedrFixgoCAAB566CE+//xzRo8ezcsvvwyAxWLhscce44MPPqCmpobhw4fz3HPPMWPGDACWLFnCvffey4cffsi9995Lfn4+U6ZM4e233yY6OhoAh8PBgw8+yFtvvYVGo+HWW2+ltLQUo9HoHvuMGTMYPnw4Wq2W9957jxEjRrBu3boTPoZjvf766zz22GOUlJS4Q61HHnmEFStWkJ6e3uYxEkq1QUKp3qW6pIEv/rGL+moLfiHeXPq7MQRFypntU2ErLaPmk4+p+fgT7CVNzRpVKnynTiF4/gL8pk87pel5HUFRFDKqM/gu5zu+z/uebGNLDyu1Ss34yPGcN+A8zhtwHpG+kV06NiG6g83ioCCjmvz9leQdrMJY1uhxvbdBS1xqCAOGhRCfFiIB/SlSnE4smVk07tiOadt2TNu3t/w9PIp38mD048djaLroIuXvT4/gdDaFT+lNl6YQquLQ8cOn0MFH9Xxq+tpLwqeTZTXbKcqsaaqkrKKm1HM6r7dBS9yQYFdINSxU/naIfsFsN7OhaAPf537P+oL11B1VIRngFcCM+BmcP/B8JsdMxkvTd/4edAVbWRnl//gHxs+Wg6Kg8vIi5NZbCLv9dtR6fZvHHBtKmKx2hv7x2y4eucuBp+Zg8Dq5qfzHC6VqampISUlh0aJF3HjjjTQ2NvLwww9jt9tZu3YtALfddhurV6/mv//9L5GRkfzxj39kzZo17sqi5n0OHDjAs88+S0xMDMuXL+fxxx9n7969JCcns2TJEm6//XamT5/OM888g1qt5le/+hVjxoxh6dKlAPztb3/j2WefZfHixaSlpfHCCy/w0UcfMXPmTI9Qavv27fz617/m1ltvBSAyMvKEj+FYN954I7W1tR7Pybp165g5cyZVVVUEt3FyT0KpNkgo1fvUVZn54h+7qCk1offXMe93owmLk6lex6M4nZh++YXqD5ZRt3YtOFxnIzQhIQRdeQVB117rUVbb3bJrslmTt4Y1uWs4WHXQ47qR4SOZNWAWswbMIj4gvptGKETHUhSFmlITufsqyd1XSVFWDU67Z7VDVFIAA4aGEJ8WSvhAf9TS2LhD2QoLMW3fjmn7DkzbtmE9fLjVPrr4eHdAZRg/Dt2AAdK7pzM5nWDMa5pqd/TlENga2j5GrWsKn5qn3TWFT6GDoB82JK6tbKTgYDV5ByopSK/GYvKssgyJ8WXAsFAGDg8lelBgn+o3J/q3OmsdPxf+zOrc1fxc+DON9paTOyE+IZw34DxmDZzFhKgJ6NT972/DmXI2NlK1ZAkV/1mMYnKF3wEXXkjEA/eji4097rF9MZT6y1/+wk8//cS337Y8joKCAuLj48nIyCA6OprQ0FDef/99rrrqKgCMRiMxMTHcdtttvPzyy+Tl5ZGUlEReXh4xMTHu25k1axYTJ07k6aefZsmSJdx8881kZWUxaNAgAF577TWeeuopSppOrsXExHDffffx4IMPAmC320lMTGTcuHEeoVRtbS07duw46ceQkpLS6nHPnj2bxMRE/v3vf7c8pwcOMGzYMA4cOEBaWlqrYzoilJKOoKLb+Yf4cPkDY/nylV1U5Nez/IWdXHzXSKIHB3X30HocZ2Mjxs+/oOqddzwa/+rHjyN4/gL8Z5+P+jTmD3e2pKAkbg+6ndtH3k5BXQHf533Pmtw17CrfxZ7yPewp38OL219kcNBgZg6YycwBMxkaMlQ+HIpexWZxUJhR7Qqi9ldSV2n2uN4/1IeBw0KJHxpC3JBgvGSBh06li40lMDaWwHnzALBXVWHavp3Gbdswbd2GOT0dW34+xvx8jMuXA6CNiHAFVBMnYBg/Hq9Bg+Tv0OlwOqEmtyV0ag6hKg6BzdT2MWqdq7l4c68nd+VTUr8Mn9oTEKpn6BQ9Q6fE4HQqlOXWkn+girz9VZQeMVJV1EBVUQO7Vueh89YQlxrMwOGhUkUleqUyUxnr89ezNm8tm0s2Y3e2hLDRvtHuIGp0+Gg06v7Va7GjKE4ntStXUvbCi+4KY/2oUUQ88jCGMWNO6zb1Og0HnppzxmNzOhVqyxuxWRyoVCr8w3xOuDiWXtcxPwe7d+9m3bp1+LXRg/fw4cM0NjZis9mYOHGie3tgYCBDhgxxf793714cDker8MdisRAaGur+3mAwuAMpgOjoaMrKXP3QjEYjxcXFTJo0yX29Vqtl/PjxHFtbNG7cuFN6DG2FUt1F3hGLHsEQ4MVl941h5Wt7KM4y8sU/djHn9uEkjGh7vmt/Yy8vp/qDD6h+/wN343K1ry+Bl15K0Pxr8elBf1ROJM4/joXDFrJw2ELKTGWszVvLmtw1bCvdRlZNFlk1Wby5500iDZGcG38uMwfMZHzUeDnrJXqklmqoCgozPauh1FoVsclB7qqFoEiDBBzdSBsSQsD55xNw/vkAOOrrady5E9PWbZi2b8e8Zw/2sjJqv/6a2q+/BkATHOwKqSZMwDBhPN5DhqBSS+WJm9MJNTlt9Hw6BPbGto/ReEFocssqd829n0ISJXw6RWq1iqjEQKISA5lwUSLmBhv5B6rI3V9J3v5KGutsHNldwZHdFYCrimrgsFAGjgglalAgGulFJXqgbGM2a/PWsi5vHXsq9nhclxCQwHkDzuP8geczNFROXp4p0/btlD77HOa9ewHQxkQT8cADBFx44Rk9tyqV6qSrldrjsDsxVjaidYLOW0tguB4vn66LLurr67nkkkt47rnnWl0XHR1NVlbWSd2GRqNh+/btaI5ppXJ0UKTTeb72qVSqVoHTyfD19W11/8d7DG2JioqitLTUY1vz91FRUac8ppMloZToMbwNOi757WhW/Xsvefur+Pq1PUy+cjCjzovvty865oxDVL3zDrVffuleaUoXG0vIwhsJvOJKNH6+J7iFni3CEMH81PnMT52P0WLkx4IfWZe/jp8Lf6bUVMqyjGUsy1iGv5c/0+KmMTN+JlNip2DQSd8x0T0cDifFWUZy9laQu7eyVX+X5mqoAcNDiRsS3O9WyetNNH5++E2dit/UqQA4zWYad+/BtHUrpm3baNy1C0d1NXWrV1O3ejUA6oAADGPHukKqiRPwSUtDpe0Hb6WcDqjO8Ww0XnYQKjKPEz55Q1jKMeFTKgQngqYfPGfdwMdXR/KESJInRKI4Fcrz68jd5wqoSo/Uuquodq7Ow9ugZcDQEAaOCGPgsFB8/CQQFN3DqTjZW7GXtXlrWZu3lpzaHI/rR4aPZGb8TM4dcC5JgUndM8g+xpqXR9mLL1G3ahUAaoOB0DvuIGThjag7cfW8k2WzODCWN+J0OFGrVQRGGtB5de37qbFjx/Lpp5+SkJCAto3X+aSkJHQ6HVu3bmXAgAGAq6rp0KFDTJs2DYAxY8bgcDgoKytjatN7jVMVGBhIdHQ0mzdvdt+u3W5n+/btjB079oweQ1vOPvtsHnvsMWw2mzssW716NUOGDGmzn1RHkXcFokfReWm48Ncj+fGDDA5sKGbDJ1lUFtYz47pUNLr+cUZPURQaft5A1ZIlHqvo6UePJuSmm/CfdV6f/BAU6B3IJYMu4ZJBl2BxWNhcvNl1pix/HVXmKlZmr2Rl9kp0ah0ToycyI24GM+JnEOXbeam9EACN9Vby9lWSs9f14c5qbllRRq1WEZ0cRMII1/SY4Ciphuqt1D4++E6aiO8kVym+YrXSuG9/S0i1fTvO2lrq16+nfv161zG+vujHuUIq3wkT8Bk2DJWuF3+4d4dP6Z6VTxWZYDe3fUxz+BSR2jL1LjwVghMkfOpGKrWKiIEBRAwMcFVR1dvIO+jqcZe3rwpzg43MbWVkbitDpYKoQYEkjAhj4IhQQqJ95e+Y6FQmm4lfin9hff56fiz4kUpzpfs6rVrLpOhJriAq/lzCDeHdN9A+xlZaSsXrr1Pzyadgt4NaTdCVVxL+u9+ibWc1tq5mbrBRW2kGRUGjUxMYrkfbQVPy2mI0Gtm1a5fHttDQUO666y7+85//sGDBAh566CFCQkLIyspi2bJlLF68GH9/fxYuXMiDDz5ISEgIERERPPHEE6jVavffz5SUFK6//npuvPFGXnjhBcaMGUN5eTnff/89I0eO5KKLLjqpMf7ud7/j2WefJTk5mdTUVF588UVqmmbOHM+JHsOx1VsA1113HU8++SS33norDz/8MPv27eMf//gHL7300kmN9XTJuwXR42i0amb8KpWQWD82fJxJ+qYSakpNXHDHCHwD++5SrorVivHLL6lasgRLZlNJqFqN//nnE3LTwtOe190beWu8mRY3jWlx0/iD8w/sqdjjPoOWV5fHhsINbCjcwF83/5XUkFSmx01nRvwMhoYORa3qH+Gl6DyKolBV1EDO3gpy9lRScsQIR1VR6/11TVNgwogfGnLC/gaid1J5eWEYOwbD2DFwx+0odjvmg+mukKopqHLW1dHw4080/PgT5YDKYMAwejSGiRMxTJyAfvhwVD2wz587fCo76Nn3qeIQOCxtH6P1aer5lObZdDw4AaSXS4/n46cjZUIUKROicDoVSo/Uuis+KwvrKc4yUpxlZNPyw/iH+pAwPJSEkWHEpgT3m5OConOVNpTyQ8EPrM9fz+bizVidVvd1fjo/psZOZeYAV0W8n1frHjji9Nmrq6n8z2Kqly5Fsbj+xvtOmULEg7/H56geSN1JURQaaiyYal0/F156LQFh+k5fBGb9+vWMOeYz1q233srixYvZsGEDDz/8MLNnz8ZisTBw4EAuuOAC1E3T+F988UXuvPNOLr74YgICAnjooYfIz8/3aPb99ttv85e//IUHHniAwsJCwsLCOOuss7j44otPeowPPPAAxcXFLFy4ELVazS233MLll1+O0Wg87nExMTEnfAzHCgwM5LvvvuOuu+5i3LhxhIWF8cc//pHbb7/9pMd7OmT1PdGj5R+o4tvF+7CY7PgFe3Phr0cSPqBvrcznNJup+eRTKhcvdjcYVBsMBF51JSE33tijVtHrboqicMR4hHX56/ih4Ad2l+/GqTjd14frw5kWN40Z8TOYFD0JvbbtpWuFOJbD4aQos4ac3RXk7K2gtsKzKiQs3s9dRRA5MACVrJTX7ykOB5aMDExbt9KwdSuNW7fhOOYNosrHB/2Y0fhOnIhhwgR8Ro7s2sUoHPamyqeDRzUczziJ8CmlKXQa0hJCSfjUZ9VVmcndW0HOXteKfg57y+uqzlvDgGEhJI4MY+DwMJnmJ06aoigcrDrI+vz1rM9f32r15Vi/WGbEz2B63HTGR45HJz3lOpyjvoGqJUuoevttnA2uFU71Y8cScd+9GCZM6LD7Od7qayfD6VSoq2jE0uhqZG8I8MI3yLvXVWw2NDQQGxvLCy+8wK233trdw+kyHbH6XpeEUv/61794/vnnKSkpYdSoUbzyyiseneqP9fHHH/OHP/yBnJwckpOTee6557jwwgtP6r4klOp7akpNrHxtDzWlJrQ6NTMXppE8PrK7h3XGnA0NVC/7kMq338ZR4WpCqg0PJ+SmhQRdfTUa+fk9oWpzNT8V/sT6/PVsKNyAyd7S38dH48PE6IlMjZ3KtLhpxPjFtH9Dol+ymGzk7q8kZ3cFufursDa2rOqj0amJSw12BVHDZdUqcWKK04klMxPTlq3uaipHdbXHPipvb/RjxmCYMB7fiRPxGTWqY0Iqhx2qjxzTbDzDNe2u3fBJD+Eprmqn5ktEKgQNlPCpH7NZHBRkVJOzxxXQm4wt1SzN0/wSR4aTOCqMoEjp7yg8mWwmNhVv4qeCn/ip8CfKTGXu61SoGBk+0h1EDQ4a3OtCh97CaTZT/cEyKt980/065J2WRsR99+I7dWqHP+9nEko5bE5qyk04bE5QqQgI8cbHrwdWGLdh586dpKenM3HiRIxGI0899RTr168nKyuLsB4yHbIr9IpQ6sMPP+TGG2/kjTfeYNKkSbz88st8/PHHZGRkEBER0Wr/jRs3Mm3aNJ555hkuvvhi3n//fZ577jl27NjB8OHDT3h/Ekr1TZZGO98t3kfe/ioAxl+YwMSLE3tltYKjtpbqpUupWvKO+6y6NiaasNtuI/CKK1B7990pip3J6rCyrWQb6wtcZ+SKG4o9rh8cNJipcVOZGjuV0RGjZTW/fqq2otG1GtWeCooza3A6W14C9f46EkaEkTAyjPi0EGlSLs6IoihYDx+mYcsWd1DlqKz02Efl7Y1+1KiW6X6jRh3/NcBhg6rso6qemiqfKjPBYW37GJ2hqeH4Uc3Gw1MhaICET+K4mpulN//NrCyo97g+KNJA4sgwEkaFEZUU2OnTbETPlFuby48FP/JjwY9sL92OzWlzX6fX6pkcM5kZ8TOYGjuVUH1oN46071NsNmo+W07Fa69hb1oxzSshgfDf/Rb/OXM6bfXY0w2lrGY7xvJGFKeCWqMiMFyPzrv3tETYuXMnixYtIiMjAy8vL8aNG8eLL77IiBEjuntoXapXhFKTJk1iwoQJvPrqqwA4nU7i4+O55557eOSRR1rtf+2119LQ0MBXX33l3nbWWWcxevRo3njjjRPen4RSfZfTqbBp+WF2rc4DIGl0OOfdlNaly4OeCXt1NVX/+x/V776Hs971xk43cABht99B4LxLendz3B5GURQyazL5seBHfir4iV3luzym+fnr/JkcO5mpsVOZEjtF3iT1YYqiUJ7X9KFqdzmVhQ0e14fE+JIwMozEkWFEJsi0PNF5FEXBmp2NacsW15S/LVvdVbLNVF5erpBqwjgMQ2LRRyiojYdbQqjKLDjqA58HnaFlpbujK58CB0AnfRAR/UttZSM5eyrJ2VtBYUY1TodnqD9wRBhJo8KISwvp8pWyRNexOqxsK93mrobKrc31uD7OL87dF3R81Hi8NXKytbMpVivGL76g4s3/YMtzfU7SRkcTfvddBF56aacvkHQ6oVRjnZW6KlerBK2XhsBwPRqtvFb1Rj0+lLJarRgMBj755BMuu+wy9/aFCxdSU1PD559/3uqYAQMGcP/993Pvvfe6tz3xxBOsWLGC3bt3t9rfYrFgsbSUptfW1hIfHy+hVB+WvqmYdUvTcdoVQmP9uPDXIwgI67m9g+wVFVS+9TbVy5ahmFzTy7yTBxN6x50EXDCnT66k19MYLUY2Fm3kx4If+bnwZ2osNe7rVKgYFjqMc2LPYUrsFIaHDUerlv+T3sxhd1J0qIYju8s5sqeC+uqW1wiVWkXM4EASR4WTMDKUwHCZfiK6h6IoWLMyMa3/BtMvG2nYm4mjttFjH5VaQR9qxRBhxRBhQR9qRa33ParR+FE9nwLjJXwSXcbaaCfvQBVH9pSTu7cSi6ll+rNWpyZ+aIj776y+l0zFEe0rqCtgQ+EGfi76mc3Fm2m0t/yt0qq1jIsc526XkBCQINPyuojTbKbm00+pXPxf7MWuGQKa0FDC7riDoPnXdlkPw1MJpRRFob7KQmO9q7rX26AjINRHTgr2Yh0RSnXqJ6+KigocDgeRkZ79fyIjI0lPT2/zmJKSkjb3L2lqAH2sZ555hieffLJjBix6hdSzowmKNPD1G3upLKzno2e2MvOGNJJG96wlYx21tVT+9y2q/vc/lEbXi7fP0KGE/vpO/M87r9NKaEVrgd6BzE2cy9zEuTicDvZV7nNXUR2sOsi+yn3sq9zHv/f8G38vf86OPpspsVOYHDOZSN/e37+sP7A22sndX8mR3RXk7qv06A+l9dYwcGgIiaPDGTg8FB9fqUoUXcxuharDHj2fVOUZeFdm4e20ExwPShxY6zSYyrwxlXlhKvfB3qjGVO6Nqdwb9vuj0unwGTkS30kTMUROQD96NGp9zz0pI/ouL72WweMiGDwuAofDSXGWkSO7yjmyu4K6KnNTdWqFuw9V0mhXHyo5EdA7NNob2VayjQ1FrtWOc2pzPK4P04e5Q6izos+S1fK6mLOhgeoPP6Ly7bdwlB/Vl/bWWwi+5hrUhp75e+awOamtbMRmcQDgG+SNIcBLQkzRuaFUV3j00Ue5//773d83V0qJvi0qKZBrHh3PN2/spSy3jm/e2MuwabGcc9Xgbi8Zd5pMVL23lMrFi3HW1gLgM2IE4Xffhe+0afKHt5tp1BpGhY9iVPgo7hlzD2WmMjYWbeTnwp/ZVLSJWmst3+V+x3e53wGQHJzMlNgpTImZwpiIMbI6TA/SYLS4p+UVpB8zlSTAi8SRYSSOCiMuNRitTqaSiC5gt0Dl4ZZG480hVNVhcNrbPsbLH8JTUIWn4R2Rind4GsHhQ1ACYrHl5bX0pNqyBXtZGY3bt9O4fTvwOuh06EeMwDBxAr4TJ7pCqh76YUT0XRqNmrghwcQNCWbKNclUFtaTvcv1t7kiv57iLCPFWUY2fJJFSIyvO6AKH+Av74l6iObVjX8u/JkNRRvYVrINq7OlT51GpWF0xGj3CbvUkFTUKjm52tUcdXUtfWlraoDe05fW3GCjrtKMoiioVCoCwnzwNsh7auHSqaFUWFgYGo2G0qZGa81KS0uJiopq85ioqKhT2t/b2xvvHvwLKDqPX7APVzw4js2fZ7NzdR77fyyk6FA1sxcNIyzOv8vH47RaqfnoYyreeMPdJ8Q7eTDh996L38yZ8sarh4owRHDZ4Mu4bPBl2J129lXsc58Z3Fexj8zqTDKrM3l739votXomRE3g7OizmRwzmcTARPl/7WLVJQ0c2V1B9q5ySo/UelwXFGkgaXQYiaPCpT+U6Fx2i6u/07Gr3VUeBsXR9jFe/k2Nxpun3DX1fAqIdS1rdgwVrga1XgkJBF9zDYqiYMvNpWHr1paQqrSUxh07aNyxg8o3/g1arSukmjDB1Tx9zGjUvr6d+1wIcRSVSkVYnD9hcf5MvDixqQ+Vq2qq8FANVUUNVBU1sO3rHPyCvUkcFU7i6DBikoPQaCTk6ErV5mo2F29mU/EmNhZtpKTBc1ZKlG+U+6TcxOiJ+Ht1/Xtr4WKvrqb63Xepevc9nHV1QO/pS+t0KtRXmTE3uPoh6rw1BITq0ejk91206JJG5xMnTuSVV14BXI3OBwwYwN13391uo3OTycSXX37p3jZ58mRGjhwpjc5Fu/IPVrFmyQFMRitqrYrJlw9m5My4LgkMFLsd4xdfUvHqq9iKigDQxccT/tt7CLjwQlQaqdDorarN1Wwq2uQOqSrNnitnRRoiOTvGFVBNip5EiE9IN42071KcCqW5tRxpOuteXWLyuD4yMcB91j04Sj58iw5mM7vCp/L0lktZumsFvPbCJ++ApkbjQ45a8S4NAmLaDJ9Ol6Io2PLzPRqnN/cUcdNq8Rk2FN+JEzFMmIB+7Fg0fjLNRnQPc4ON3H2VHNlVTu7+SuzWlgVIvA1aEkaEkTg6jAFDQ2X1005gdVjZVbbLHUIdrDyIQsvHQC+1F+OjxnNOjKvHppx4637W/Hyq/vcuNZ9+6u5L6zV4EGF33EnA3At6TF/a9noK2SwOaisacdhdv+uGQG98A2W6Xl/T4xudA3z44YcsXLiQf//730ycOJGXX36Zjz76iPT0dCIjI7nxxhuJjY3lmWeeAWDjxo1Mnz6dZ599losuuohly5bx9NNPs2PHDoYPH37C+5NQqv9qrLOy9t10cva4qpQGDAvlvIVpGAI6p8mfoijUffsd5f/8J9bsbMA1nzvsrt8QdMUVqLqouaDoGk7FSWZ1JhuLNrKxaCM7Snd4lLYDpIWkuUOq0RGjZcWZ0+SwOyk8VO0OohqMLc+zWqMibkgwiaPDSRwZhm+QPMeiA9jMUHGoqerpqACqKhuOWrnTg3fgMZVPTc3H/aM7NHw6WYqiYCssxLR5izuoaj5R4qZW4zN0qKuKasJ4DOPGoZH3SqIb2K0OCtKryd5dTs6eChrrWlaV1OjUxKeFkDjKtTKq3l/eT50ORVE4XHOYTcWb2FS0iW2l2zwalAMMDhrM5JjJnB1zNuMix6HXSo+67qYoCo07d1G1ZAl1a9aA0/Ua5D00jbA778R/1qwe15f22FBCURRMtVYaalwLzag1agLCfHrNiuni1PSKUArg1Vdf5fnnn6ekpITRo0fzz3/+k0mTJgEwY8YMEhISWLJkiXv/jz/+mMcff5ycnBySk5P529/+xoUXXnhS9yWhVP+mKAr7fihkw6dZOGxO9P46zrtpKAOHhXbo/Zi2bqX0ub9h3rcPAE1gIKG3307w9dehPsmlUEXvZrab2VG6g41FG9lUvIlD1Yc8rvfWeDM6YjRnRZ/FpKhJDA0dikYtZ37bYzXbXWfQd1eQu7cCq7mlCkXno2Hg8FCSRoUzYHgo3np5UyNOk62xJXw6eupddU774ZNPoGfoFJbSreHTqbAWFGLautV9seXne+6gUuGdlorvhAmuSqpx49AGB3fPYEW/5XQqlBw2kr27nCO7yqmtMLuvU6kgenAQiaPCSBod3qNXW+4JiuqL2Fy8mV+Kf2FLyRYqGis8rg/xCXGfPDsr+iwiDBHdNFJxLMVup271aiqXLMG8e497u+/UqYTctBDfyZN7bIXR0aGETuvlambe9D7O26DDP8QbtUzP7VA33XQTNTU1rFixoruH0ntCqa4koZQAqCyqZ/V/91NZ2ADAqJnxnH35oDOev2zNy6Ps+b9Tt3o1AGqDgZCbbybkpoVo/GWufX9W0VjBpiLX2chNxZtavRH01/kzIWoCk6IncVb0WVIWD5hqrRzZ7VqtKT+9Cqf9mEblTWfJ41NDpPeAODXN4VPZ0dPumsIn2nnb4xPkCpvCU1um30WkgV9kjw+fTpatuBjTtm2uSqotW7Hm5rbaxzs52dWTasJ4DOPHow3vWSvbir5NURQqCxvcrw3leXUe14fG+rl6B44OJyzOr9+/jlabq9lSsoXNxZvZXLyZvLo8j+u9Nd6MiRjDOTHncHbM2SQHJ0uD8h7GUV9PzSefUP2/d93VrSqdjoBL5xG6cCHeycndPMITaw4lYqPisNS7Wi+oVCr8Qrzx8dX12N/TnhTsnKrOGrvZbObOO+9k+/btHDx4kIsvvviE9yGhVBsklBLN7DYHGz87zN51BQCExvlx3o1phA849fDIUVtLxRv/pvrdd1FsNlCrCbrmasLvuQdtaMdWYYneT1EUso3Z/FL8C5uLN7OtZBt1Ns831uH6cCZFT2Ji1EQmRE0gzj+um0bbtWpKTe4V84qzjR75QGCEnqTR4SSNlkbl4iRZTU2VT0f1eypPP374pA92VT5FpB4VQKWCX0SfCZ9Olq20DNO2pkqqbduwZh1utY9XYiKG8eMxTJyAYfx4dNHR3TBS0V/VVja6XzOKMo0ozpbfa/8QHxJHh5E0KpzowYH9ohKj3lrPjrIdbCnewuaSzaRXpXtcr1FpGBY2jElRrhNgoyJGSSuBHspaUEj10qXUfPwxzvp6ADTBwQQvWEDwdQvQhoV18whPXm11HYezjhAREoNO64XWS0NAmE+PX/m4L4dSVqsVr9NoJdPQ0MDvf/97xo4dy6effoqPj4+EUqdDQilxrJy9FXz/zkHM9TZUKhhxbhyT5iWd1LxmxW6n+sMPqXjlVffSq77nnEPEww/hk5LSySMXfYXdaedg5UE2l7hK6neV7cLisHjsE+Mbw/io8UyImsDEqInE+MV002g7luJUKMur48iucrJ3V1Bd3OBxfcRAfxJHh5M0KpzgaEOPPZsmupnVBBUZbUy7y6X98CmkqfLpmJ5PvuH9Lnw6WfbKSkzbtruqqbZuxZKRAce8TdTFxmIYPw79eFcllVdCgvzeii5hrreRs9e1+mr+gSrstqMapftqSRzhqqCKHxqCzqtnfxg+WQ22BraXbmdbyTa2lmzlQNUBnMdMNR4cNNjVKiB6EuMix8kqeT2Y4nBQ/+OPVC9bRsOPP7n/vnolJRGycCGBl87rVW1AFEUhc1spW1cdJvlcA7HR8QSG+LmamR/Tv6zL6Awn/Rp/omBn3759PPjgg/z000/4+voye/ZsXnrpJcKaAsO6ujruvPNOVqxYQUBAAA899BCff/45o0eP5uWXXwbAYrHw2GOP8cEHH1BTU8Pw4cN57rnnmDFjBgBLlizh3nvv5cMPP+Tee+8lPz+fKVOm8PbbbxPddBLI4XDw4IMP8tZbb6HRaLj11lspLS3FaDS6xz5jxgyGDx+OVqvlvffeY8SIEaxbt+6Ej+FMnp9mHRFKSWMO0ecljAhj/h8msuHjTDK3lbFnbQGHd5Qz9ZpkksaEt/lmWlEUGn78kdK/PY/1sOvMsdfgQUQ+/DB+U6d29UMQvZxWrWVE+AhGhI9g0YhFWBwWdpXtYnPxZraWbGVfxT6KGor44vAXfHH4CwBi/WIZHzmeidETmRA5gWi/3lOd4NGofE+Fu9ElgFqtIiYlyLUM+Kgw/EN6z5sv0QWsDU2BU1Po1BxC1eTRbvhkCPUMnZpDKN8wCZ9OkTY0lIA5swmYMxsAh9GIafsOd08q88GD2AoLMRYWYvzc9bdKExrqqqQaNw7DhPF4p6TIqrOiU/j46Ug9O5rUs6OxWR3kH6jiyK5ycvZWYm6wkf5LCem/lLgbpSeNDiNhRO9qlN5ga2Bn2U62lmx1hVCVB3Acs9LnAP8B7hNYE6MnEqbvPRU1/ZW9vJyaTz+l+qOPsBe1rJLqO/lsQhYuxHfq1B7XvPxEaspM/PhBBvkHq/EJVKPWqPAP88Ev0Mf1Wv50N51c/b8i8Drz1ZhramqYOXMmixYt4qWXXqKxsZGHH36Ya665hrVr1wJw//33s2HDBr744gsiIyP54x//yI4dOxg9erT7du6++24OHDjAsmXLiImJYfny5VxwwQXs3buX5KapmSaTib///e+8++67qNVqfvWrX/H73/+epUuXAvDCCy+wZMkS3nrrLdLS0njhhRdYvnw5M2fO9BjzO++8w69//Ws2bNhw0o+hp5BKKdGv5B2o5IcPDlFb7krvB44IZdq1KR6NM80Zhyh77jkaNm4EXKW0YffcTfA11/SYpVdF32KymdhVtoutpVvZUrKF/RX7W70JjfWLZVzkOMZHjmdc5Dji/eN7VHWCtdFO7v52GpV7axgwLJSk0WEMHB6Kt0HXjSMVPYKlvu3Kp5q89o8xhLmm2R097S6iKXwSXcJR30Djrl2Ytm+jces2GvfsQbF6rkKq9vdHP3YMhrHjMIwfh8+IEahlNVrRiZwOJ8WHjRzZVUH27nLqKj0bpUcNCiRptOtESGC4oRtH2prRYmRn2U52lO5ge+l29le2fv2P84tjYvRExke6qqmjfKO6abTiVCiKgmnLVqqXfUDd6jVgtwOgDgwk6PLLCbr2GrwTE7t5lKfOYXOy47tctn+Ti8PuRKNVM/6SOAzxVpKSklyVMr0klDpeJdBf/vIXfvrpJ7799lv3toKCAuLj48nIyCA6OprQ0FDef/99rrrqKgCMRiMxMTHcdtttvPzyy+Tl5ZGUlEReXh4xMS3Px6xZs5g4cSJPP/00S5Ys4eabbyYrK4tBgwYB8Nprr/HUU09RUlICQExMDPfddx8PPvggAHa7ncTERMaNG+dRKVVbW8uOHTtO+jGknGDWj1RKCdFJBgwNZcEfJrJ9VS47vs0ld28lH6RvZsLFiQyfFETVq69S/f774HSi0ukIvvEGwu64Q5bMFp3KoDMwOXYyk2MnA66QamfZTraUbGFbyTb2V+6nsL6QwvpCdyVVuD6ccZHjGBs5lnGR4xgcNLjLm5fWVZnJ2ePq9VF4qAano3Wj8qRR4cQOCerxfQVEJ7HUQfmhpqqn5p5PGWA8TvjkG9662Xh4qoRPPYDGzxe/KefgN+UcAJxWK+a9ezFt3YZp+3Yad+zAWVdHww8/0vDDjwCovLzwGTHCVUk1biz6MWPkNVV0KLVGTWxKMLEpwZxz9eBWjdKLs4wUZxnZ8EkWwdG+7kU0uqN3YUVjBdtLt7svmdWZKMdUgcb6xTIhaoLr0ssqpYWrD61xxedUf/ihe7YFgH7UKILmzydg7gW9aore0Qoyqvnh/QxqSk0AxA8NYdr8FHwC1Bw5cqRlR53BFQ51B13HBM+7d+9m3bp1+Pn5tbru8OHDNDY2YrPZmDhxont7YGAgQ4YMcX+/d+9eHA5Hq/DHYrEQelRPYoPB4A6kAKKjoykrKwNcQVdxcTGTJk1yX6/Vahk/fjzH1haNGzfulB7DiUKpriShlOh3tF4aJs1LImViJOuXZlCUWcOm5YfZ+0EpKQc2EuR04j97NhG/fwCvAQO6e7iiHzLoDJwTew7nxLo++NVb69ldvtv9JnZvxV7KG8tZlbOKVTmrAAjwCnAFVBHjGBM5hqEhQ9FpOrYiSVEUKvLrXW/291RQkV/vcX1QpMG1KtIoaVTe75hrm1a7O9jSdLw8A4z57R/jG3FU1dNRfZ8kfOo11F5eTWGT642wYrdjTs+gcfs217S/7dtxVFbSuH07jdu3UwmgUuGdkoJh3Dj048ZiGDcOXZRUfoiOoVKpCIvzIyzOjwkXJVJb2UjOngqyd1VQlFlDdXED1cUN7FiV6zp5MiKUhFHhxKcGo+3gPlSKolBQV8DO8p3u1+/c2tYrXiYEJDAucpz70ld6SvYnisNBw6ZfMC5fTt2aNSgWV9sClcFA4MUXEzz/WnyGDu3mUZ6+xjorGz7NIuMXV+WOPsCLqVcnM3h8BCqVCrPZ7HmAStUhU+i6U319PZdccgnPPfdcq+uio6PJyso6qdvQaDRs374dzTHT2o8OinQ6z/frKpWqVeB0Mnx9PZ/zEz2GnkRCKdFvBUf5MvcSP7Y98yUHVKOp94lkx9gHSB6sYdqdk/HykylGomfw8/LzCKnMdjN7K/ayvXQ7O0p3sKt8F7XWWtbnr2d9/nrAtQz08LDhjIkYw5iIMYwKH0Wgd+Ap37fD1tQfak8FOXsqqK9u6Q/VPC0icWQ4CSNDCY7q3W9AxEkwG4+qfDpq6l1tQfvH+EW2hE5HT70zhHTduEWXUGm16IcPQz98GCELF6IoCrbcXEzbtzeFVNuw5eZhycjAkpHhqkwGtDHRGMaMbZr2N1b6UokOExCqZ+S58Yw8Nx5zg428A65p5nn7KmmstXJgQzEHNhSj1amJHxpCwkhXHypDwKlPObU5baRXprOzbKf7Ummu9NhHhYqU4BR3ADU2cqz0hOrFLNnZGJevwPjFF9hLS93bvZMHEzR/PoHz5qHx772N551OhfSNxWz8LAuLyQ4qGD4tlrMuTerzrRiaV59LSEhA20b7lqSkJHQ6HVu3bmVAUxGD0Wjk0KFDTJs2DYAxY8bgcDgoKytj6mn2JA4MDCQ6OprNmze7b9dut7N9+3bGjh17Ro+hJ+nZoxOikzjqG6j417+oevddQu12zvb7jvw5v+dIZSCZWQ5yH9/ImNkDGDkz/qRW6ROiK/lofdyl/dDyRrj5TOyu8l3UWGrc3zcbHDTYHVKNjhhNnF9cm32pTLVWcvdVkLO3kvwDVdgsLf0ttF5qBgwNbXrjHtqrGsiKU2A2NvV5ap5y13SpLWz/GL8oz9CpuQJKwqd+S6VS4ZWQgFdCAkFXXgm4Gv6atu/AtGM7jdu2Y87IwF5UTG3RSmpXrgRA7euLftQo9GPHuqb8jRyJ2ldCb3FmfHx1pEyIImVCFA67k6JDNRxpmoJeX23hyO4KjuyuABVEJgSQMCKMhJFhhMb6tvlaWWutZXfZbnaW7WRX+S72lu/F7PCsGNGqtQwLHcbYiLGMjxrP6IjRBHjJ9NXezFFbS+3X32BcvpzG3bvd29WBgQRedBGBl1+Gz/DhParv56lSFIWcPRX88nk2VUWuVZPD4v2Yft0QohJP/QRnT2Y0Gtm1a5fHttDQUO666y7+85//sGDBAh566CFCQkLI+n/27ju+yvr8//jr7MxzsveGhIS9ZCgIAnWiFW0tioq7+pVWhYpaV7VWpT9Ba63aasU9OkStdRRZCiIiyIaEsDLITs45GSdn3r8/TnKSQxIIkM31fHgeJ+e+z33O5wQOnvO+r8/1yc/n/fff59VXXyU0NJT58+dz7733EhERQUxMDI8++ihqtdr3Z5+VlcW8efO4/vrrWbp0KWPGjKGiooJVq1YxcuRILrnkkk6N8a677uLpp58mMzOT7Oxsli1bhrlpVfjjOdFrOLZ6q9mePXtwOBxUV1dTW1vr+/20buDe1eTbtjijKIpC7RdfUPb0Et8ZjZBZM4l74AFGJCZyNN/M1+/nUVVUx6ZPDrFjTRHjLkpj+NRENLr+tSqGOHPo1Drf6n43DL8BRVE4ZD3EtvJtvkqqI9Yj5JvzyTfn88+8fwIQFRjFyKiRjIweRaZnOLrCcIp3Wyg7bPVb6CzIqCdtZBTpo6JIGtL1UxxEL7KZW8Kn5kv5Pqg9Ti+I0PimyqdWzcajh0BgeI8NW/Rf2uhojBdegPHCCwDw1Ndj27GDhq1bsW39Edu2bXjq66n/9lvfgiNoNBiGZBE0egyBY0YTOHo0uqT2Q3UhOkOj9VZGJQ+NYOovMqksqmvqkejtQ1V2yErZISubPjlISISB1OGRBAxycdS4nx0129lesZ0D5gNt+kGZDCZGR49mdMxoxsaMZVjUMAwaQy+9StFVFKeT+o0bsXz0EbVfrWpZ4EGjIWTqVExz5hBy3vQBsahDcW4N3318gNKDVgAMQVrGX5zGyPOSUGsG3nehtWvXMmbMGL9tN998M6+++iobNmzgvvvu4/zzz8dut5OamsqFF16IummlxGXLlnH77bcze/ZsjEYjixcvprCw0K/Z9/Lly3niiSdYtGgRxcXFREVFMWnSJGbPnt3pMS5atIiSkhLmz5+PWq3mpptuYs6cOVgsluMel5CQcMLX0J6LL76YI0dapho3/366c308WX1PnDHsBw9R9sQTvg+5uuRk4h56kJBp0/zup3gU8reUs+mTg1iaVukLiTAwYXYGQybFoZY+OaIfqrJVsa1iGz+W/ciPFT+SW5FHTE06aTXDSakZRqjDP1DQx3pIGxnFyHHpxKRIf6h+z2b2D52af64t6fiY0IRWjcabez5lSfgkupXidmPfv98XUjVs3eK3hHozTVQUgaNHETR6NIFjxhAwbFi/bR4s+pa6Gjv7thWxd2sh1kMucLV8eXOq7RSZcjkSvpuC8D1ERYYxOma0rwo53ZTe44uOiO6huN00bN6M9bPPqf3f/3C3qkwxZGZiuuIKTLMvQRsd3XuD7ELlR6x89/FBCvdUA6DVqRk5I5kx56cQEHz8qXrHW33tTFJfX09iYiJLly7l5ptv7u3h9JiuWH1PQikx4HkcDqpe/iuVr7wCTicqvZ7IW28l8tZbjvsB1u32sO/bEjZ/eoh6i/eMSHhcEBMvyyBjTLScoRX9jrXSxpFdVRzZXUXRvhrcTo9vn0vtpMi0z/tBO2wP9Qbv2ZeIgAhGRo9kZNRIhkcNZ1jUMJl60JfZavxDp+YQqq6042OMif6Nxpun3QWG9diwhTgeZ2kptm3bsP34Iw3bttG4Zy84nf530moJyMkhcPRo79S/0aPQJSbK/6vFCTk9TvbX7GdX5S52Vu5kR8UODloOAqB160iwZpJaM4y0muEEO8L8jo1OCSVlWASpw6OITTfKict+TnG7sW3divXzz7F++T/cVS09wTQRERgvuQTT5T8lYOjQAfNvS01pPZs+OciBrRUAqDUqhk1JYNzFaQSbOlfld6aGUj/++CP79u1jwoQJWCwWHn/8cdauXUt+fj5RUWdOrzgJpdohoZRoreHHHyl56GHfkqzB504l7qGHTmpVPZfDzc61xWz58jD2ehcAMamhTLp8EMk50itF9F1up4ej+80c2V3FkV1VviV8m4WEG0gbEUXqiEgSs8KodFawvcI7LWFHxQ72VO/B5XG1edw0YxojokYwPGo4I6JGMCRiCHpN/y9Z71caqpsCp6ZG482Nx+vKOj7GmNhqyl12S+VTwMDqDyEGPo/dTuPu3dh+3IZtmzeocldUtrmfJiLCG1CNGkngyJEEjBjRr5sOi9PXvCLezsqd7Kzcya7KXeyt3ovdbW9z3+TQZEZFj2JU9ChGRo8kMywT89FGjuz09lw8dqq7IUhL8tAIUodHkjI08pSapYuep3g82LZtx/r559R+8QWuigrfPo3JROj552O8+CKCzjoLVR9vFn0yaqsb2fzpIfZtLEFRABUMmRDHWbPTMUUHntRjncmh1C233EJubi56vZ5x48axbNkyRowY0dtD61ESSrVDQikB3h4V5X/6EzVvvQ2KgiYykriHHyL0ggtO+cyG3eZi28oCtq0qxNXU+DkhM4zRs5JJGxEl05tEn2CtslGwu5oju6ooyq3x/V0FUKlVxA8ykTo8ktThkUQktN+8tZndbWdv1V52VOzwnUEuqmu7yppWrSU7PNtXSTUschjppnS06oHz4a3X1Fc1VTwds9pdfXnHxxiT2m84HiD/TxQDk6IoOIuPYvvR25PKtmMHjfv2ta2mUqnQD8rwBlUjRxE4cgSGwYNR6Qb2KlJnsvKGcnZX7mZP9R5fCGWxt+3DEqoP9TvZMjJ6JBEBxz/x2GB1ULjHe9KnYE+1d3WyVmJSQ0kZ5v3/bUyaVFH1JYrTScMPP1C7Zg21K7/CVdIyRVhtNBI6axbGiy4ieNLEAffvQ01pPdtXF7H326N4XN4YIH1UFBMvyyAyMeSUHvNMDaWEl4RS7ZBQStSt30DpI4/gPOpt1Gu6/HJi778PTVhYlzx+g9XBli8Os+vrYt8/5qboQEbOSCZ7cpys1id6lKPRRXGemcK91RTuqW5TDRVk0ntDqGGRJOVEYAg8vb+fNY017Krc5QupdlXuosZe0+Z+AZoAsiOyGRo5lGFRwxgaMZR0UzoatTRJb1d9VVPwdEzPp/qKjo8xJbdMt4vJ8V5HZUn4JATeair73r3Ytm/Htn0Hth07cBa1DdVVBgMBOTkEjBxB4IgRBAwfjj41FdVxmsCKvqmioYI9VXvYXbXbd11pa1tBp1PryInIYXjUcIZHDWdk9EhSQlNOazqWx+2h7HAtBU2VyRUFtX77DUFakrIjSM4JJ3loBMbIk6tEEafPbbVS9/U31K1eTd033+CpbfkzUgcHEzprJqEXXUTI2WejGgANy1tTFIWivTVsW1VIwe6WKYmJQ8KY9NNBxGWcXsW0hFJnNgml2iGh1JnLbTZTtuSPWFasAECXkEDcY48RMnVKtzxfXU0jO9YUsWf9Ud/ZMX2glqFTEhh5XhKhEfKPsuh6Ho9CxZFaCvdWUbi3htIDFjyeln/GVWoVcRlGXzVUZGJIt/Y9UBSF4rpidlXuYkflDvZU7WFv1V4aXA1t7huoDSQ7IpthkcPIicwhOyKbDFPGmVVRVV/ZVO3UHDw1VT81tP3i5BOWckzVU7Z32p1BpiEJcTJcVVVNAdV2bNu307hrt98X02bq0FAChg8jcMRIAkYMJ3D4cLRxcQOmh0x/pygKZQ1l7Kvex96qveyp2sOeqj2U29pWkKpVajJMGQyNHMqIqBGMiBpBVngWOk33Vr/UW+wU7K6mYHcVhXvbVlGFxQaRnO0NqBKzwtGf5gkj0T5HYSF1a9ZQu3oNDT/8AK6WPwdNZCQh500ndMYMgs85B7Vh4K2S6HK4yfu+jO2rC6k+Wu/dqIL0kVGMmplMQmZYl/y7JqHUmU1CqXZIKHVmsn75P0p//3vclZWgUhF+7bXE3H0X6uDgbn9uR6OL3O9K2b66EEu5d7U+lVpFxuhoRs9KPu2zD0JYK23eSqi91RTtq2nz4dYYHUhKjndp68Qh4addDXW6PIqHw9bD3ikTTV8W9lbvxeaytbmvXq0nMzyT7IhsciJyyI7MJis8i0BtPz+LXFfRttl4xb4ThE+prfo9ZbdUPhlOrZxeCHF8iseD48gRGnftwrZzJ407dtK4dy+KvW1/IU1EBAHDhhEwdCgBw4YSOGwY2oQECaq6mUfxcMR6xBtAVe9lX9U+9lXva7dCt3UANTRyKMMihzEkYkiv///E4/ZQfqTWV9FcesiK0upkklqtIjbDSHJOBMk5EcSkhqLWSKXeqfA4HNi2/kj9hg3UrV2Lff9+v/2GzMGEnDeD0BnnETBy5ICtiKy32Nm1rphdXxfTWOedxqwzaMg5O56RM5IwRQd16fNJKHVmk1CqHRJKnVmc5eWU/f731K78CgB9RgbxTzxB0NgxPT4WxaNwZFcV21cXUrSv5cNSbLqRUTOSSR8dhVYnU5fEidVWN1KcV0Nxbg3FuWZqqxv99usDtSRlh/s+wJ5sQ8re4Pa4OWw97JtSsbdqL/uq97VbUaVWqUkzppEdkU12RDZDwoeQFZFFVGAfW8lEUbzT646dclexDxqqOjhIBeGp/lVPMU3hk777Q3QhxPEpTif2/HxvSLXTG1bZ8/P9KiyaacLCmkKqYU2XoeiSkiSoOkU2l438mnzyavLYV+0Nn3Jrcts9oaFRaUg3pfuqb4dGDiU7IpsgXdd+2e4OdpuL4twaX0hlqfB/fTqDhvjBYSQNCSdxSBhRyaHSj6oDiqLgyM+nbsMG6r/9lobNP6DYWv0+NRqCxo8ndMZ5hJx33kktdNTfKIpC+ZFadq4pYv8PZXjc3q/4oREBjJyRRM45Cd120lJCqTObhFLtkFDqzGH5738pffz3eCwW0GqJuu1WIm+/HXUfmAdeWVTH9tWF5H1f6us7ZQjSMmhMNFkT40gYHCaN0YVPvcXuDaH21VCUZ8Z6zAdUtVpFbLqR5KED6yyqR/FQWFvod/Z7b/Veqhur271/RECEN6AKzyIrIosh4UPIMGV0+zQMFAXqyts2G6/YB7b2x9oSPuV4+z75ej5lSvgkRD/jsdux5+bSuHs3jXv2YNu9G3ve/naDKnVICAHZ2RhycgjIziYgJxv94MF94rNJX6EoCiX1JeRW55JXk+e7HLEeQaHt15IATQBZ4VneExWR2WSHZ5MZnkmAdmB8+W2uhi7YU01xbttqaEOQ1i+kikwIOaM/Q7oqK6nfuJH69Ruo37gRV7n/tE1NdBQhZ59N8JQphJx7LhrTwJ6xYK20kfd9GXnfl1JT2nKiLy7DxKiZyWSMjur2z4wSSp3ZJJRqh4RSA5/bbKb08cexfvY5AAHDhhH/5B8IGDKkl0fWVoPVwa51RezZUEK9uWU6QEi4gawJcWRNjCUyQabmnEkURaG2upGSfAslBywczavx+xABoFJBdKqRpCFhJGaFEzfIdEY10K9oqPAGVU1nyvfX7O/wy4pWpSU9LJ2s8CwywzLJDM9kUNgg4oPjUatO8kOYokBdWavQqVUI1Wju4CAVhKc1hU5DWkKoqCzQ9/0z9kKIU+NxOLDn5vmCqsbdu7Hn5aEcu+IfgFaLISODgJxsDNk53ushQ9CGh/f8wHuYxW7hgPkA+eZ89tfsJ68mj/01+6l1tu3lBd6TD1nh3pMO2ZHead2pxtQzpveg4lGoLKrzVUsf3W/G0ej2u09AsI6ErDASBocRP9hEVFLIgDhR1RFXZSUNP2yhYcsWGr7/Hnturt9+lcFA0FlnEXz22QSfcw6GrMwBX63YWOckf2s5ed+XUpLfspqkRqcmY3Q0o2YkE5vec9+DJZQ6s0ko1Q4JpQa2um/WU/Lgg96zIhoNUXfcQdQvb+vzy7V6PApH95vJ21TKga3lfh8wopJDvAHVWbEEhw28JotnOo9HoaqojpIDFkoOmCnJt/gFlACoICophMQh4SQNCSdhcJg0PT1Gg7OBA+YD5NXkkVvTcna91tH+F5sgbRCDwwYzOHwwg0yDGBw+mMywTKICo1AB1Ja2U/m0FxrbLhXupYKI9GMqn5rCJ13fnz4phOh+itOJ/eAh7Pv20rh3H4379tG4d6+3orsdmugoAjKzMGS1ugwehLoffqlr/jc635zfcqnJb7f5OIBWrSXDlOELoJorYPvcNO1e5nF7qCis807nz6vhaL4Fl90/pNIaNMSlG4kbZCJhUBixGcZ+eyJLURScRUVNIdQP2Db/gOPIkTb3MwzN8VZDnXMOgWPHDsgm5cdyOd0c3lFF3velHNlV5ZuehwqShoSTNSGOQWOie+Xzo4RSPe+GG27AbDbz0Ucf9fZQJJRqj4RSA5OnoYHyZ56h5t33ANCnp5PwxyUEjhjRyyM7eS6Hm8M7O/6fyqAx0aQMi8QYJV90+yOHzUXZESulByyU5JspPWTFecxZTrVaRVRKKPGDTCRkhpGQGUZAcN8OVvsiRVEorS/1BVXNX4QOWQ7h8rSdVgNgVFQMdjpJb2wkw+lkkNNJhsNJnNvtDatUaghP94ZOUVn+0+4kfBJCnCRFUXCVljaFVHux7/UGVc6iovYPUKvRp6S0hFSZmRgGD0KfktInTsBZHVYOmg9yyHKIA+YDHLQc5KDlIMV1xR0eEx8c7z1JEDaYzPBMssKzembq9QDkdnsoP1xLcZ539d3Sg5Y20/1UKohMCiF+kLeSKi7DREi4oU9WDylOJ/b9+2nYtg3bD1to+OGHNtPxUKkwZGURNG4cQePHETRxItrIyN4ZcA9z2FwU5dZweEclB36swGFr+bOOTAphyIQ4Ms+KJSS8d0O5/hpK9aVg52R119jXrl3Ls88+y/fff4/VaiUzM5N7772XefPmdXhMV4RS/TNGF2cU2/btHF18n+9MSfi11xKzaCHqwP75BVGr1zB4XAyDx8W0lN9uKqXkgIWifTW+JulhsUGkDIsgdVgkCZlhaPXSJL2vcTndVBbVUX7YSvnhWsqPWKkpa+DYWWb6AA1xg0zEDzIRPyiMmHQjOvnzPG0qlYr4kHjig+OYZhwMQftAl4pT2UNhxR721x4hX+XigF7Hfp2OAp0Wqwq26rVs1ftPmw1U60gPSSIjIptBEVmkm9LJMGWQFJqETi1fnIQQp0alUqGLj0cXH0/ojPN829119Tjy99OYl4c9bz/2vDzseXm4zWYchw/jOHyY2v/9r+WBtFr0aakYMgZ5Q6pBgzAMHow+La3Lq0QURaHCVsEhyyFv6GQ+6AufKm0dryAaFRjlC59aV6qG6KVNQVfRaNRNnyW8fZIUj0J1Sb1fNXZtVSOVhXVUFtaxc603/AwM1RGTZiQm1UhMaiixaUYCQ3u2z1mnV7vU6QgcNoyg8eMIHDeOoLFjB3xfqGaKolBVXE/B7ioKdldRkm/B02qlRm/7j1iyJsQRmSjvK9Exh8OB/hR6GX777beMHDmS++67j9jYWD799FOuv/56TCYTs2fP7oaRekmllOizFKeTihdfpOqvfwOPB21sLPFP/oGQc87p7aF1C0uFjfwtZRzZVUXpQf/lgrU6NQlZ4b6QyhQT2CfPeA1kHreHmtIGyg5bvSHUkVqqiur8Piw0C40IaAmhBpuISAiRlXO6gqKAtbid1e5ywW5t/xiVBiIyICYbe1Qmh0IiOaDTcVCxcai2gAPmAxRYC3Ap7VdWaVVakkKTSDWmkmZMI82URqoxlXRTOpEBkfI+FEJ0GUVRcFVU+IVU9gMHsB84gNLQdqVSANRqdMlJGDIGoU9PR5+ehiEtDX1aGpqoqOP+G9XgbOCI9QiHrYc5bDnsvbYe5oj1CPXO+g6PiwmKIcOUwaCwQWSYMkg3pTM4bDDhAQO/R1Z/UFdjp+SA2VuxfcDS8WeVyABvSJUWSmyqkejU0C6b9qcoCq6ysqYAaheNO3dg27Ubj7Xt/6vVoaEEjhjuDaDGjSdw1Mh+e+L5VDTWOynaV+MLouotDr/9puhAUoZFMmhMNAmZfXOhpGMrZRRFaXfVzJ4QqO38d6QTVRvt2rWLe++9l2+++Ybg4GDOP/98nn32WaKivNOMa2truf322/noo48wGo0sXryYjz/+mNGjR/Pcc88BYLfbefDBB3nvvfcwm80MHz6cJUuWMH36dABef/117r77bj744APuvvtuCgsLmTJlCsuXLyc+Ph4At9vNvffey2uvvYZGo+Hmm2+mrKwMi8XiG/v06dMZPnw4Wq2Wt99+mxEjRrBmzZoTvobOuOSSS4iNjeW1115rd79USokBy56fz9HF99G4Zw8AxtmziXv4oQF9psQUHci4C9MYd2EadpuLor3VFOyu4sjuaurNdt//rNazH2NUAEk5EcSmGYlNNxIeFyyhRxdqsDqoKqqj6mgdVUV1VBbXUVPSgNvlaXPfwFCd78xj81nIIKOssnRaFAUsRa2ajTeHULnQQQ8pVBqIHOSdahedDTFN15GDQeutIjAA2U2X1pweJ4W1hRwyH+KA5YCvMuCw9TA2l833RW0d6/yOC9GFeMMqUxqpoakkG5NJCU0hJTQFk8EkgZUQ4qSoVCp0MTHoYmIImdJyAk5RFFwlJdgPHMR+IB/HgQPY871hlcdqxXmkAOeRAlizxu/x1CEh6FJTcCZGY4kNoSxSw2GTg72BNeQ6CylvaL/fE4BapSYpJMkbOoWlM8jUEkBJ5VPfFhJuIHN8LJnjYwFv24jKojrKj3irussOWzGXNVBb1UhtVSMHtrb8PTBGBRCZGNLqEowpJui4nzE99fXY8/NpzM3FnusNUxvz8trtpabS6wnIySFg5EgCRwwnYPgI9GmpqNQDt1H7seotdsoOeU9wHt3vbfNw7InoxOxwUoZGkjIsgrCY/rdois1lY+K7E3vluTdds4kg3en/zsxmMzNmzOCWW27h2WefxWazcd9993HVVVexevVqABYuXMiGDRv45JNPiI2N5ZFHHmHr1q2MHj3a9zgLFixgz549vP/++yQkJLBixQouvPBCdu7cSWZmJgANDQ0888wzvPXWW6jVaq699lp+85vf8M477wCwdOlSXn/9dV577TVycnJYunQpK1asYMaMGX5jfuONN7jjjjvYsGFDp19DZ1gsFnJyck7n13lCUikl+hRFUah57z3Kl/wRxW5HYzIR97tHMV50UW8PrdcoikL10XqO7K6iYHc1Jfnmlj5UTXQGjbccO91ITJqR2DQjIeH9Z053b7HbXFjKG6gqrqequM53sdW2s3oSoAvQEJPSEj7FpIUSGhEg4cOp8njAWtSq6qnVineOuvaPUWshYlBL6BTdOnzq2jBQURTKGsq8lQOWI75w6rDlMEfrj+JR2oaUzUL1ob6AyhdWGVNIDk2WCishRJdQFAV3ZSWW3N1U7P2R2gO5OA8XoCsqJ7iqHtVxPuFbA6E8DGoiDTjiItAmJRKSNojIwcNJyRhNiilVej4NYHabi4oj3qrv8sNWyo5Yqau2t3tfjU5NRHwwkfGBmALthDqrCCg/gPrQHux5eTgLCtp/Eo0Gw6BBBIwcQeDwEQSMGE5AVlaf6I3WUxyNLioKan0hVNlhK3U1bX/P4XFBpAyPJHVoJPGZJrS6/tXi4dhKmQZnQ78IpY5XKfXEE0/wzTff8OWXX/q2FRUVkZycTG5uLvHx8URGRvLuu+/ys5/9DPCGNwkJCdx6660899xzFBQUkJGRQUFBAQkJCb7HmTVrFhMmTODJJ5/k9ddf58YbbyQ/P59BgwYB8OKLL/L4449TWloKQEJCAvfccw/33nsvAC6Xi/T0dMaNG+dXKWW1Wtm6dWunX0NWVtYJf0f/+Mc/uO6669i6dSvDhg1r9z5SKSUGFLfFQslDD1O7ciUAwVOnEv/EE+hiY3p5ZL1LpVL5zliNPT8VR6OL4twaSvIt3qlkBbU47W6K88wU55l9xwWb9L7wJDw+iLCYIEzRgWdcbypHowtLhQ1LuQ1zWQOW8gbM5TYsFQ0dhk8qFZhigohMDPY7Y2iMDOiTZdN9nscDlsKW6XatQ6iOpoiotd6gKXqI/4p3EYO6PHzqiEqlIi44jrjgOCbFT/Lb53A7KKwt5LDlMIeshyiqLeKI9QgFtQWUN5RT66hld9VudlftbvO4AZoAEkMSSQpNanOdFJLUJWf4hBADh9PjpLS+lOK6Yopqi9pc19hrQA/kNF0AnUtDjBkSqhVSzXoG1waSUK0ivNyGwWrDaAOjDSixw64SoAT4AfgAp05HQWIiuqQkdAkJTZd473V8PNrYWFRa+QrRnxkCtSRlR5CUHeHb1ljnpLLISvmeEioPVlJd2oi5XoPbCRUFtVQUNFcqa4EhqN3pBMZMICi0nGDqMIXrCEsOJzI7gbARmRgGDTojVsUD70rLddWN3s+a5Q3eIOqwlZqSetqUf6ggIj6Y2HTvSeTkoREYIwfWdMVAbSCbrtnUa8/dFbZv386aNWsICWlbGXrgwAFsNhtOp5MJEyb4tptMJoYMGeK7vXPnTtxud5vwx263E9mqWX9QUJAvkAKIj4+nvKnhv8VioaSkhIkTW0I+rVbL+PHjOba2aNy4cSf1Gk4USq1Zs4Ybb7yRV155pcNAqqvI/1FEn9Cw9UeKf7MI19ES0OmI/c0iwq+/XqoJ2qEP0JI+Kpr0UdGA93+ENSX1lB22UnbIexamuriOeouDQ9srObS9VVNSlbesOyzGG1KFxQZhigkkLCaI0KgANJr+VT7t8SjYrA7qzHbqa+zea3MjdWY7ddV2zOUNNBwzN/9YQUY94fHBRCWGEJEYTFRSCOHxwdKI/FR4PGApOKbf0z6oyDtO+KRrCZ9iclpCqIiMHgufToVeo2dQ2CAGhQ1qs8/mslFUW0RBbQGF1kIKagu8F2sBpfWlNLobOWA5wAHLgXYfO9wQTlJoEvHB8SSEJBAfHN/yc0g8Rr1UAQsxkDjcDkrrSzlaf5SSuhKO1h/laN1RSupLOFp3lNL6UtyK+7iPYTKYvJWZocmkGFN81ZkpoSmEGcL8Pk+56+pxFhfhKCjAWViEo7DVdfFRFKfT12y9XWo12thYX0jVHFRpY6LRxcSgjYlBGxWF6hSa7IrupSgK7upqnEeP4iw+6r1uvhQW4jhyhECHg2QgGVBQYQuMoi44gbqQROpNqdQbk7BpjHg0eupDEqkPSaSi+Qma8k3dxgpM0XUYowIJCTMQHGYgJNz/ur9VAymKQoPV4Tu5aS5r8J7sbDrx2V6LB/B+7o5Na5rJkG4kOqXrenf1VSqVqt+fYKurq+PSSy9lyZIlbfbFx8eTn5/fqcfQaDRs2bIFjcb/73vroEh3TPWgSqVqEzh1RnBwcJvnP95rOJ5169Zx6aWX8uyzz3L99def9FhO1sB+R4g+T/F4qHrlVSqefx7cbnQpKSQuXUrgiOG9PbR+Q61uqaQaeo63NNRpd/vO0lQU1Pr+B+qwuair9gY2zav8tX6cQKOeIKOewFAdgaH6pouOoFC9d1/TbUOQDo1O3aV9rBRFwdHoxl7vxN7gwm5zYW9o+rm+5WdbnYO6Gjv1Zjv1FoffPPyOBIToCIsJxBQT1OraG8gN9A8G3cLjAfMR/+l25XuhMg+cHTXj1UFUZjuVTxkwwKaIBGoDyQzPJDM8s80+p9vJ0fqjFNcWU1RX5L20qniwOqzU2Guosdews3Jnu48fogshPiSehOCmwCokntigWGKDYokLjiMmKAa9Rr4MCtEXeBQP1Y3VlNWXUdpQ6rtuDp9K6kqotFWiHLts6zH0aj0JIQm+ysrk0GS/SstQfWinx6QJCUYzZAgBrc7oN1PcblylpTgKC3EWF+M8WuINLEq8166SEhSnE1dJCa6SEo7XylgTGekNqJrDqugYNFGRaCMi0USEo42MRBMRgcZkOqN6CnUXxenEVV2Nq6ISV2UF7spKXBUVOEtK/cInpbHxuI+j0unQpaagT0vDkJ6Ovqlxvj4tDU1EBCqVCrfbQ21lI+byBizlNu/nzArvdW1VI85Gt28FwI4EBOt8IVWQSY8hSIchSEtAkNb3c8u196LuwpOniqLgdnlwNrppqHVgq3Viq3U0XZzebVbv7YZaJw1WBy57x+GwWqPCFO39jBmREOzt+5pmJDjszKgWG2jGjh3Lv//9b9LS0tC2UxmakZGBTqdj8+bNpKSkAN6qpry8PM4991wAxowZg9vtpry8nKlTp57SOEwmE/Hx8WzatMn3uC6Xiy1btjB27NjTeg0dWbt2LbNnz2bJkiXcdtttpzTukyXfxkSvcVVUcPS++6j/diPQ1Mz8d4+iaafEUJwcnUFDQmYYCZlhvm2KotBY5/Se2WkqL7aUN2Au836IcDk93qDH3H5Pgfao1So0OjUanRqtTo1a673WaJtvq/C4lWMuHtxN1623OxtdbUucO0GlVhFs0ns/2DSdjQsO937IMUV5g6eA4IEVevQYjwfMh1tCJ18IlQcdraqi0UNkZtueTxHpAy58OhU6jY5UYyqpxtR291sdVopriymuK/ZVSbS+NtvN1Dnr2F+zn/01+zt8noiACOKC49qEVTFBMUQHRRMTGEOwLliqUYU4DQ63g0pbJeUN5VTYKihvKPcLn8oavBeXp/3VPVsL0AQQFxznq45sfZ0UkkR0UDRqVfcHNyqNBl1iIrrExHb3Kx4PrspKXE0hlfNoCc6SElzl5b6Ls6ICnE7cVVW4q6qw7917/CfVaNCEh6MND/cGWRHhaMLCUZuMaIwmNMZQ1Mamn01GNKGhqE0m1MED998wRVHw1NfjNlvwWC24LRbcFmvTtQW32Yy7qrIpgPJe3DU1dOqDlEqFNjq6ZWpmYoLvz1yfno4uPh6V5vhVTBqNmrBYb8X9sdxOD5bKpoCq2vu5ss7c6L2u8Va2u5weGuudNNY7qSruOLg6ltagQatVo9aoWl3Ufj9rmn5WFHA5PbidHtwuDy6nu+lnxbftZKlU3lULvSc2gwiLbTnRGRph6NLQTPQMi8XCtm3b/LZFRkZy55138sorr3D11VezePFiIiIiyM/P5/333+fVV18lNDSU+fPnc++99xIREUFMTAyPPvooarXa9+9SVlYW8+bN4/rrr2fp0qWMGTOGiooKVq1axciRI7nkkks6Nca77rqLp59+mszMTLKzs1m2bBlms/mEx53oNRxbvQXeKXuzZ8/mrrvu4sorr/T1tdLr9URERLS5f1eRUEr0irr1Gzh63324q6pQBQYS99BDmK6YM2A/XPQFKpXKV/0UPzjMb5/iUai3OGiw2mmwdnC2yHfGyOlbWtjjUfDY3TiPc+boZGm06lZnxXQYgrV+Z8sCQ3SEhAX4zq4FGvWy8uDp8ri9lU/l+46pfNp//PApKqvtanfh6aCR/7WcKqPeiDHSSE5k+6ucNDgb2oRVzV98y+rLKK0vxeFxUN1YTXVjNXuq9nT4XIHaQKIDo4kOivZdxwTGEBUURVRgFJEBkUQGRhJmCOuRL8NC9AWKotDgaqDKVkVVYxWVtkoqbZVUNHhDp0pbJeW2cioaKjDbzZ16TBUqogOjiQ32hsSxwbFtpudGBET0i89AKrXat0Jg4KhR7d5H8Xhwm83+QVV5Oa6yctzVVbiqa3BXVeGqqfGu0OZ2466sxF1ZCfs7Dtvb0GjQhISgCg5CHRSEOijYex0Y2HQ7CHVQIKrmnw0GVDodKr3ee93651bb0Gi8fxatL95X7/2v1Z+T4najOF0oTieKywkuF0rzxelCcTm9+xrteGw2PLYGlIYGPA22ptvN25p+rqvzhk5WK7hP4bOVRoM2MhJtVBSa6Ci0UVHoYuNagqeEBLRxcai7cWplc2P0iPjgdvcrioK9wdUUVnlDqwaLo6U6vsFbHd/Y0FIl72z0/i5cdvdxq5VOVUCwzm+WQFCojkBjy4wB7zY9oREBaHTy/8OBZO3atYwZM8Zv280338yrr77Khg0buO+++zj//POx2+2kpqZy4YUXom6q7Fy2bBm33347s2fPxmg0snjxYgoLC/2afS9fvpwnnniCRYsWUVxcTFRUFJMmTWL27NmdHuOiRYsoKSlh/vz5qNVqbrrpJubMmYOlnRUuW0tISDjhazjWG2+8QUNDA0899RRPPfWUb/u0adNYu3Ztp8d8smT1PdGjFKeTiuefp+qVVwEwZGWR+OwyDIPa9mURfZOiKLgc3jNMbqfnmLNQHtxOt/fa5b2o1S1nsDTHnM1qfaZLH+ANn860Ruw9yuOGmsNtG45X5oGrg3J+jcEbPsVkt5p6lw3haRI+9UGKomC2mylr8AZUzdUapfWlvi/SFQ0V1DprT/xgTTQqDeEB4X5BVfN1REAE4QHhhBvCvdcB4V3WZFSIruL0OLHYLVQ3VmNuNFNtr6amscYXPPld26podB9/elNrOrXOW4HYFOw2VybGBscSF+StVowKikKnlkrR9igOB64aM+6aalxVVbira3BVVeK2WPBYrLitVty11jY/K47j94scKFR6PRqTCU2YCbXR5P3ZaERjMqGNjkITFYU2KhptdBTa6Gg0YWEDciqkx+1pauvgwuNS8Hg8bSvwXf5V+Kqman6tVu1X1a/Rtvq5udJfKpxOy/FWXzuT1NfXk5iYyNKlS7n55pt7ezg9RlbfE/2Ko6iYo4sWYdu+HYDwa64mZvFi1GfwP179kUqlQmfQoDNIeNRnedxQfagpfGqufGoKn9wdTM/UBjT1fGo15S4mxxs+qeXPur9QqVS+cCg7IrvD+9lcNiobWio+jq0Aaf6SbrabcStuX7VIZwRoAggPCCfMEOYLrcIMYZgMJu9Fb/L72WgwEqoPlWoscUKKomBz2bA6rFjsFu/FYWnzc3P4VGOvobqxmlpH50PYZoHaQF/4GhUY5Rc8xQQ2TYMNisGoN/aLCqe+SqXXo4uNOemVlj2NjbgtVjy1Vm+FUX0DnoYGPDbvtbcaqakiqelnxW73Vi05nSgOR9ufm6/dbu80OEVp6fWl4Nvmvd10rdWg0jZVXWm1vgs6rXd787bAANSBTVVcgYGoggK9t32VXYGoAgPRBAejNpnQmMLQmIzyGbmJWqMmMERPYIj0SxR9x48//si+ffuYMGECFouFxx9/HICf/vSnvTyy/qdbQ6nq6mp+9atf8Z///Ae1Ws2VV17Jn/70p3aXJWw2ffp01q1b57ftl7/8JS+//HJ3DlV0s7qvv6b43sV4LBbURiPxT/we4/nn9/awhOjf3C6oOeRf9VSxzzvt7rjhU/O0u+YV77IlfDrDBGoDSTYmk2xMPu79nB4n1bbqttUkTdOaahprMNvNVDd6K0+cHieN7kZK6ksoqS/p9HhUqDAajBj13oAqVBdKqD6UEH1Ih7eD9cEEa4MJ0gURrAsmUBsowVYfpigKDo+Demc99c56GpwN1DvrqXPWUeuopdZRS52zDqvDSp2jaZuzabujzhdEOT3OU3p+FSrCDGF+gWnrqr9jr/v7ylEDnTogwBvYnGSYJYQQXemZZ54hNzcXvV7PuHHj+Oabb4iKiurtYfU73RpKzZs3j5KSElauXInT6eTGG2/ktttu49133z3ucbfeeqsvaQQICpIPBv2V4vFQ+eJLVP7lL6AoBIwcSeKyZeiT2m+gKYRoh9sF1QdbQqfmEKpqP7g7mMKgDYTorGMqn7IhLFXCJ9FpOrXO2wcnOPaE923uxXNslUrzz82hgtVu9atuaXA1oKD4bp8qFSoCtYEE64IJ1rWEVUHaIAK0AQRqAwnQeK8DtYEEaANatmsDCNQEotfoMWgM6DX6lp/Ver/bOrVuwFXGuDwuHG4Hdrcdh9vhvXj8b9vdduxuOzaXDZvLRqOr0XvtbvS73XxpDp3qXd4AqsHZgEs5ccPvztCqtYQZwjDqjX4Vd80/hweEExEQ4VetZ9Qb0ci/fUIIIbrImDFj2LJlS28PY0DotlBq7969fPHFF2zevJnx48cD8Oc//5mLL76YZ555hoSEhA6PDQoKIi4urlPPY7fbsdtbKgKsVuvpDVx0GbfZTPF991G/7msAwq6eS+wDD3Rrc0Uh+jW3syV8OrbyqaPqAF1QS+VTTDZEDZHwSfQKlUrlC4SSQ49fgdWa0+3E4mgJq3xVM446X6WMr1rG2VJF46u2cdXjUTwoeEOxBlcDFbaKbnyl3rBOq9aiVWu9P6u06DRN21Qt2zVqDRqVt2lye9dq1KhV3ktngi6laTqRW3F7lzNvde1RPH4Xt+LG5XHh9DhxeVz+PytNt91OXIoLj3Lyq1CdjkBtIEFab2jYXAFn1BsJ0YW0Xx2nC/VN+TTqjQRqAwdcMCiEEEKcqbotlNq4cSNhYWG+QApg1qxZqNVqNm3axJw5czo89p133uHtt98mLi6OSy+9lIcffrjDaqmnnnqKxx57rMvHL05P4549FP36LpxFRagMBuJ+9zvC5lze28MSom9oDp/Km/o9Nfd9OlH4FD2kbeWTKQUGYFNTcebQaXREBXpX/DsViqLQ6G70mxJW76ynwdXg29a6mufYCp/WVT4Oj8OvMqj5+tgpY06P85SnkfV1WpXWVxl2bLVY64qz5p99lWbHbG8OKH1Va9pg3zRLqVgSQgghRLNuC6VKS0uJifGf563VaomIiKC0tLTD46655hpSU1NJSEhgx44d3HfffeTm5vLhhx+2e/8HHniAhQsX+m5brVaSkzt/hlZ0PfOHKyh97DEUux1dcjJJz/+JgJz2lzcXYkBzOZoqn5qbjTddV+UfJ3wKbtXrqXm1uyFgSpbwSYh2qFQqXzhCNy3851E8OD1OX1DldHsrjpxKSxVS60vriqSOKpmaq5maf+6s5qoqjUrjq7JSq9TtVmC1V73lV+HV9HPztES9Ro9WLWvgCCGEEKLnnPQnj/vvv58lS5Yc9z579+495QHddtttvp9HjBhBfHw8M2fO5MCBAwwaNKjN/Q0GAwaD4ZSfT3Qdj8NB2R+exPzBBwCETJtGwh+XoDGZenlkQnQzlwOqD7StfKrKB08HPVT0Ie1XPhmTJHwSoo9Rq9QYNAYMGvm8IYQQQgjRlU46lFq0aBE33HDDce+TkZFBXFwc5eXlfttdLhfV1dWd7hcFMHHiRADy8/PbDaVE3+A8epSiu+6mcedOUKmI/vWviPzlL1HJl2sxkLgc3qDp2Ibj1QeOEz6FtoRPMa0CKFMSSE8UIYQQQgghxBnspEOp6OhooqOjT3i/yZMnYzab2bJlC+PGjQNg9erVeDweX9DUGdu2bQMgPj7+ZIcqekj9t99SvHARbrMZjclEwjPPEDJ1Sm8PS4hT57K3hE+tG45XHQDF3f4x+tCm0Km5+imnqfIpUcInIYQQQgghhGhHtzUOyMnJ4cILL+TWW2/l5Zdfxul0smDBAubOnetbea+4uJiZM2fy5ptvMmHCBA4cOMC7777LxRdfTGRkJDt27OCee+7h3HPPZeTIkd01VHGKFEWh5s03KVvyR/B4CBg2jMQ//Ql9UmJvD02IznE2+lc+NU+/qz7YcfhkMPpPu2uufpLwSQghhBBCCNHNbrjhBsxmMx999FFvD6VLdGs3y3feeYcFCxYwc+ZM1Go1V155Jc8//7xvv9PpJDc3l4aGBgD0ej1fffUVzz33HPX19SQnJ3PllVfy0EMPdecwxSnwOByUPvYYln97G9CbrriCuEcfQS39vURf5GyEqv3+VU8V+5rCpw4aDBtMx1Q+NYdPCRI+CSGEEEII0Y8NtGCnK+Tm5nL77bezZ88eLBYLCQkJXHPNNTz66KPodLpue95uDaUiIiJ49913O9yflpaGoii+28nJyaxbt647hyS6gKuqiqJf34VtyxZQq4m9/z7Cr7sOlXxRF73NaYPK/f79nir2Qc2hjsOnAFPLCnetV7wLjZPwSQghhBBCCNGvOBwO9Hr9SR+n0+m4/vrrGTt2LGFhYWzfvp1bb70Vj8fDk08+2Q0j9ZJ1f8VJaczNpfCOO3AdLUEdGkrismXSP0r0PKcNKvO8U+3K97aEUDWHjxM+hfmHTs0hVEishE9CCCGEEEJ0AUVRUGy2XnluVWBglxVK7Nq1i3vvvZdvvvmG4OBgzj//fJ599lmioqIAqK2t5fbbb+ejjz7CaDSyePFiPv74Y0aPHs1zzz0HgN1u58EHH+S9997DbDYzfPhwlixZwvTp0wF4/fXXufvuu/nggw+4++67KSwsZMqUKSxfvtzXU9vtdnPvvffy2muvodFouPnmm/0KewCmT5/O8OHD0Wq1vP3224wYMYI1a9ac8DUcKyMjg4yMDN/t1NRU1q5dyzfffNMlv9OOSCglOq32q68oXnwfSkMD+tRUkl56CUNGem8PSwxkjoaW8Klib0sIVXMYUNo/JjC8/cqnkBgJn4QQQgghhOhGis1G7thxvfLcQ7ZuQRUUdNqPYzabmTFjBrfccgvPPvssNpuN++67j6uuuorVq1cDsHDhQjZs2MAnn3xCbGwsjzzyCFu3bmX06NG+x1mwYAF79uzh/fffJyEhgRUrVnDhhReyc+dOMjMzAWhoaOCZZ57hrbfeQq1Wc+211/Kb3/yGd955B4ClS5fy+uuv89prr5GTk8PSpUtZsWIFM2bM8BvzG2+8wR133MGGDRs6/RpOJD8/ny+++IIrrrjidH+lxyWhlDghRVGo+utfqXjuTwAEnz2ZxGefRWMy9fLIxIDhaIDK3FaVT00hVM0ROg6fItqvfAqOlvBJCCGEEEIIcUpeeOEFxowZ4zdl7bXXXiM5OZm8vDzi4+N54403ePfdd5k5cyYAy5cv9y3oBlBQUMDy5cspKCjwbf/Nb37DF198wfLly32P7XQ6efnllxk0aBDgDbIef/xx3+M899xzPPDAA75g6OWXX+bLL79sM+bMzEz++Mc/+m4/8cQTx30NWVlZHb7+s88+m61bt2K327ntttv8xtMdJJQSx+VpbKTktw9i/ewzAMKvu47Y+xaj0spfHXEKHPVNgdMxlU/mAk4cPjU3G5fwSQghhBBCiL5IFRjIkK1beu25u8L27dtZs2YNISEhbfYdOHAAm82G0+lkwoQJvu0mk4khQ4b4bu/cuRO3290m/LHb7URGRvpuBwUF+QIpgPj4eMrLywGwWCyUlJQwceJE336tVsv48ePbTOEbN86/Ou1Er+F4odQHH3xAbW0t27dv59577+WZZ55h8eLFHd7/dEmyIDrkLCuj6M4FNO7aBVotcQ8/TPgvrurtYYn+wF7nrXw6drU7c0HHxwRFeiueYrL9V7sLie65cQshhBBCCCFOmUql6pIpdL2prq6OSy+9lCVLlrTZFx8fT35+fqceQ6PRsGXLFjQajd++1kHRsavaqVSqNoFTZwQHB7d5/uO9huNJTk4GYOjQobjdbm677TYWLVrU5nV0FQmlRLtsu3ZTdMcduCoq0ISFkfj8nwhulQQLAYC9Firymqqemle7ywXLccKn4Oi2VU9RQyR8EkIIIYQQQvS6sWPH8u9//5u0tDS07cwQysjIQKfTsXnzZlJSUgBvVVNeXh7nnnsuAGPGjMHtdlNeXs7UqVNPaRwmk4n4+Hg2bdrke1yXy8WWLVsYO3bsab2GzvJ4PDidTjwej4RSoufUrllD8cJFKDYbhsxMkl56EX1SUm8PS/Qme23TlLt9rXo+7QNLYcfHBMe0ajbeqvIpOLLjY4QQQgghhBCiB1gsFrZt2+a3LTIykjvvvJNXXnmFq6++msWLFxMREUF+fj7vv/8+r776KqGhocyfP597772XiIgIYmJiePTRR1Gr1b7V/7Kyspg3bx7XX389S5cuZcyYMVRUVLBq1SpGjhzJJZdc0qkx3nXXXTz99NNkZmaSnZ3NsmXLMJvNJzzuRK+hvYDpnXfeQafTMWLECAwGAz/88AMPPPAAv/jFL9pUdHUlCaWEn5r33qP090+Ax0PwOeeQ+Kfn0LQzD1UMUI3WlsCp+VK+D6xFHR8TEtsSOLWeehcU0XPjFkIIIYQQQoiTsHbtWsaMGeO37eabb+bVV19lw4YN3HfffZx//vnY7XZSU1O58MILUavVACxbtozbb7+d2bNnYzQaWbx4MYWFhQQEBPgea/ny5TzxxBMsWrSI4uJioqKimDRpErNnz+70GBctWkRJSQnz589HrVZz0003MWfOHCwWy3GPS0hIOOFrOJZWq2XJkiXk5eWhKAqpqaksWLCAe+65p9PjPRUq5VQmLPZhVqsVk8mExWLBaDT29nD6DcXjoWLZMqpe/TsApp9dSfyjj6LqxkRU9KJGS6vKp1YBlLW442NC4lpVPrVa8U7CJyGEEEIIIc5IjY2NHDp0iPT0dL9A5kxTX19PYmIiS5cu5eabb+7t4fSY4/35dzabkUopgcdup+SBB7B+9jkA0Xf9msjbb/eVHop+rDl88k252+sNoWqPdnxMaLx/6BSTA1FZEj4JIYQQQgghBPDjjz+yb98+JkyYgMVi4fHHHwfgpz/9aS+PrP+RUOoM5zabKbxzAbYtW0CnI+GJ32OSN1L/Y6tpp/IptxPhU3aryqemxuOB4T03biGEEEIIIYToh5555hlyc3PR6/WMGzeOb775hqioqN4eVr8jodQZzFFYSOFtv8Rx6BDq0FCS/vw8wZMm9fawxPE0VLff86mutONjQhP8ez35wqewHhu2EEIIIYQQQgwUY8aMYcuWLb09jAFBQqkzlG3nTgpvvwN3VRXa+HiS//oyAVlZvT0s0ayh2j90av65rqzjY4xJ7fR8yoIAU8+NWwghhBBCCCGE6CQJpc5AtatXU7xwEUpjI4acHJJffhldbExvD+vM1FDd1O/pmMqn+vKOjzElt5pul93S8ylAGvsLIYQQQgghhOg/JJQ6w9S89x6lv38CPB6Cp04l8dln0YQE9/awBr76qqbQaW+rxuP7oL6i42NMKU2VT81T7poqnwyhPTduIYQQQgghhBCim0godYZQFIXKF1+k8s8vABD2858R98gjqHS6Xh7ZAFNf2VTttLdV4/G90FDZ8TFhKf79nmKyvZVPEj4JIYQQQgghhBjAJJQ6AygeD2VPPkXN228DEHXnnUQtuBOVStXLI+vH6iraTrmr2NeJ8CnHv+l4VBYYQnpu3EIIIYQQQgghRB8hodQApzidHH3gt1g//RSA2IceIuLaeb08qn5CUbzT61pXPTVfGqo6Pi4s9Zhm40O8F71MkxRCCCGEEEIIIZpJKDWAeWw2iu66i/qvvwGtloSnnsJ06ezeHlbfoyhQV35Mv6dc721bTQcHqSA81b/ZePQQb+WThE9CCCGEEEIIIbrBDTfcgNls5qOPPurtoXQJCaUGKLfFQuHtd2D78UdUAQEk/ek5QqZN6+1h9S5Fgboy/9CpOYRqNHdwkArC01p6PUW3Dp+CenDwQgghhBBCCCG6wkALdrpafn4+Y8aMQaPRYDabu/W5JJQagJzl5RTeciv2vDzURiPJL79E0NixvT2snqMoUFvaTuXTvuOHTxHpTZVPQ1p6P0VmSvgkhBBCCCGEEKJfcDgc6PX6Uz7e6XRy9dVXM3XqVL799tsuHFn71N3+DKJHOQoKOHLNPOx5eWiio0h9682BG0gpCliPwoHVsPFF+OTX8PfzYUkqLMuGt+bAF/fD1jeg8DtvIKVSQ8QgyJ4NUxfBFa/CL7+BB0vg1z/C1e/BrN/BqF9A/CgJpIQQQgghhBCikxRFwWl398pFUZQuex27du3ioosuIiQkhNjYWK677joqK1sWtaqtrWXevHkEBwcTHx/Ps88+y/Tp07n77rt997Hb7fzmN78hMTGR4OBgJk6cyNq1a337X3/9dcLCwvjyyy/JyckhJCSECy+8kJKSEt993G43CxcuJCwsjMjISBYvXtzmdU6fPp0FCxZw9913ExUVxQUXXNCp19CRhx56iOzsbK666qpT/O2dHKmUGkAa9+2j4JZbcVdWoktOJuW1v6NPTu7tYZ2+5vCpzWp3uWC3tH+MSg0RGW17PkVmgi6gZ8cvhBBCCCGEEGcAl8PD3+5a1yvPfdufpqEzaE77ccxmMzNmzOCWW27h2WefxWazcd9993HVVVexevVqABYuXMiGDRv45JNPiI2N5ZFHHmHr1q2MHj3a9zgLFixgz549vP/++yQkJLBixQouvPBCdu7cSWZmJgANDQ0888wzvPXWW6jVaq699lp+85vf8M477wCwdOlSXn/9dV577TVycnJYunQpK1asYMaMGX5jfuONN7jjjjvYsGFDp19De1avXs0///lPtm3bxocffnjav8vOkFBqgGj44QcK7/g/PLW1GLKzSXnlb2ijo3t7WCdHUcBa3BQ8NU+7aw6frO0fo9J4w6eY7JYAKjobojJBa+jZ8QshhBBCCCGE6NdeeOEFxowZw5NPPunb9tprr5GcnExeXh7x8fG88cYbvPvuu8ycOROA5cuXk5CQ4Lt/QUEBy5cvp6CgwLf9N7/5DV988QXLly/3PbbT6eTll19m0KBBgDfIevzxx32P89xzz/HAAw9wxRVXAPDyyy/z5ZdfthlzZmYmf/zjH323n3jiieO+hqysrDaPUVVVxQ033MDbb7+N0Wg8+V/cKZJQagCoW7+BogULUBobCRw3juSXXkTTg3+JTpqigKWoVbPxVpVPjtr2j1FpIHJQq8qnpuvIwRI+CSGEEEIIIUQfoNWrue1PvbPAllbfNd2Jtm/fzpo1awgJCWmz78CBA9hsNpxOJxMmTPBtN5lMDBkyxHd7586duN3uNuGP3W4nMjLSdzsoKMgXSAHEx8dTXl4OgMVioaSkhIkTJ/r2a7Vaxo8f32YK37hx407qNbQXSt16661cc801nHvuuW32dScJpfq52jVrKP71XShOJ8HTziXpuedQBwb29rC8FAUshcdUPTWHT3XtH6PWens+RQ9pmXIXndMUPp16szYhhBBCCCGEEN1LpVJ1yRS63lRXV8ell17KkiVL2uyLj48nPz+/U4+h0WjYsmULGo3/76N1UKTT6fz2qVSqU+qNFRwc3Ob5j/ca2rN69Wo++eQTnnnmGcDbH8zj8aDVavnb3/7GTTfddNLj6gwJpfox68qVFC9cBE4noT+ZReLSpahOo8v+KfN4WsKn1iveVeYdP3yKHNwSOjWHUBGDJHwSQgghhBBCCNErxo4dy7///W/S0tLQattGJhkZGeh0OjZv3kxKSgrgrWrKy8vzVRmNGTMGt9tNeXk5U6dOPaVxmEwm4uPj2bRpk+9xXS4XW7ZsYewJFjM70Wtoz8aNG3G73b7bH3/8MUuWLOHbb78lMTHxlF5DZ0go1U9ZP/uM4nsXg9uN8eKLSFiyBNUxKWuX83jAUtCq8qk5hMoDZ337x6h1LeFT68qniAwJn4QQQgghhBBC9AqLxcK2bdv8tkVGRnLnnXfyyiuvcPXVV7N48WIiIiLIz8/n/fff59VXXyU0NJT58+dz7733EhERQUxMDI8++ihqtRqVSgVAVlYW8+bN4/rrr2fp0qWMGTOGiooKVq1axciRI7nkkks6Nca77rqLp59+mszMTLKzs1m2bBlms/mEx53oNRxbvQWQk5Pjd/uHH35ArVYzfPjwTo31VEko1Q+ZP/qIkt8+CB4Ppp9eRvyTT6Jq5y/VKWsOn8pbr3bXVPnkbGj/GLXO21z82J5PERmg6eawTAghhBBCCCGEOAlr165lzJgxfttuvvlmXn31VTZs2MB9993H+eefj91uJzU1lQsvvBC12tu3atmyZdx+++3Mnj0bo9HI4sWLKSwsJCCgZaX35cuX88QTT7Bo0SKKi4uJiopi0qRJzJ49u9NjXLRoESUlJcyfPx+1Ws1NN93EnDlzsFg6WIW+SUJCwglfQ1+hUk5lwmIfZrVaMZlMWCyWHu0Y31Nq/vlPSh95FBSFsJ//jLjf/e7UAymPB8xHWgVPTdfHC580eojMbLvaXUS6hE9CCCGEEEIIcQZpbGzk0KFDpKen+wUyZ5r6+noSExNZunQpN998c28Pp8cc78+/s9mMVEr1I9XvvEPZ758AIPyaa4h96EFUnUk5PW5v+NS68qlin3fancvW/jF+4VNOSwgVng4a+WsjhBBCCCGEEOLM9OOPP7Jv3z4mTJiAxWLh8ccfB+CnP/1pL4+s/+m2dOEPf/gD//3vf9m2bRt6vb5T8x4VReHRRx/llVdewWw2c8455/DSSy+RmZnZXcPsN6pef53yp72d8yNuuIGY+xb75qv6eNxQc7hlul1zz6fK/eBqbP+BNQaIymrq+dRc+ZQD4WkSPgkhhBBCCCGEEO145plnyM3NRa/XM27cOL755huioqJ6e1j9TrelDg6Hg5///OdMnjyZv//975065o9//CPPP/88b7zxBunp6Tz88MNccMEF7Nmz54wuBaz869+oePZZACJvu43ou36FqupAU7VT82p3TdPu3Pb2H6Q5fIrJbmo2LuGTEEIIIYQQQghxssaMGcOWLVt6exgDQrelEY899hgAr7/+eqfurygKzz33HA899JCv5O3NN98kNjaWjz76iLlz53bXUPssxeWkculTVC5/D4CoGclEBfwT1ZNPdRw+aQOaGo7ntFrxLtsbPqm7sBm6EEIIIYQQQgghxGnoMyUyhw4dorS0lFmzZvm2mUwmJk6cyMaNGzsMpex2O3Z7S0BjtVq7faw9peKen1G1Mg+A6JFWomI2QXnTTm0gRGc1VTwNaQmhJHwSQgghhBBCCNGDPB5Pbw9B9IKu+HPvM6FUaWkpALGxsX7bY2Njffva89RTT/mqsgaagJxs+CqX2HNDibjgXP8V78JSJHwSQgghhBBCCNFr9Ho9arWao0ePEh0djV6vb9v7WAw4iqLgcDioqKhArVaj1+tP+bFOKpS6//77WbJkyXHvs3fvXrKzs095QCfrgQceYOHChb7bVquV5OTkHnv+7mS87fcEXHQ7+vT03h6KEEIIIYQQQgjhR61Wk56eTklJCUePHu3t4YgeFhQUREpKCmq1+pQf46RCqUWLFnHDDTcc9z4ZGRmnNJC4uDgAysrKiI+P920vKytj9OjRHR5nMBgwGAyn9Jx9nlYvgZQQQgghhBBCiD5Lr9eTkpKCy+XC7Xb39nBED9FoNGi12tOujDupUCo6Opro6OjTesKOpKenExcXx6pVq3whlNVqZdOmTdxxxx3d8pxCCCGEEEIIIYQ4PSqVCp1Oh06n6+2hiH7m1GusTqCgoIBt27ZRUFCA2+1m27ZtbNu2jbq6Ot99srOzWbFiBeD9S3z33XfzxBNP8Mknn7Bz506uv/56EhISuPzyy7trmEIIIYQQQgghhBCiF3Rbo/NHHnmEN954w3d7zJgxAKxZs4bp06cDkJubi8Vi8d1n8eLF1NfXc9ttt2E2m5kyZQpffPEFAQEB3TVMIYQQQgghhBBCCNELVIqiKL09iK5ktVoxmUxYLBaMRmNvD0cIIYQQQgghhBDijNLZbKbbKqV6S3PGZrVae3kkQgghhBBCCCGEEGee5kzmRHVQAy6Uqq2tBSA5ObmXRyKEEEIIIYQQQghx5qqtrcVkMnW4f8BN3/N4PBw9epTQ0NDTXpqwL7BarSQnJ1NYWCjTEYXoJHnfCHFq5L0jxKmR944Qp0beO0Kcmv7w3lEUhdraWhISElCrO15jb8BVSqnVapKSknp7GF3OaDT22b9sQvRV8r4R4tTIe0eIUyPvHSFOjbx3hDg1ff29c7wKqWYdx1VCCCGEEEIIIYQQQnQTCaWEEEIIIYQQQgghRI+TUKqPMxgMPProoxgMht4eihD9hrxvhDg18t4R4tTIe0eIUyPvHSFOzUB67wy4RudCCCGEEEIIIYQQou+TSikhhBBCCCGEEEII0eMklBJCCCGEEEIIIYQQPU5CKSGEEEIIIYQQQgjR4ySUEkIIIYQQQgghhBA9TkIpIYQQQgghhBBCCNHjJJTqw/7yl7+QlpZGQEAAEydO5Pvvv+/tIQnRpzz11FOcddZZhIaGEhMTw+WXX05ubq7ffRobG7nzzjuJjIwkJCSEK6+8krKysl4asRB9z9NPP41KpeLuu+/2bZP3jRDtKy4u5tprryUyMpLAwEBGjBjBDz/84NuvKAqPPPII8fHxBAYGMmvWLPbv39+LIxai97ndbh5++GHS09MJDAxk0KBB/P73v6f1IvDy3hHC6+uvv+bSSy8lISEBlUrFRx995Le/M++V6upq5s2bh9FoJCwsjJtvvpm6uroefBUnR0KpPuqDDz5g4cKFPProo2zdupVRo0ZxwQUXUF5e3ttDE6LPWLduHXfeeSffffcdK1euxOl0cv7551NfX++7zz333MN//vMf/vnPf7Ju3TqOHj3KFVdc0YujFqLv2Lx5M3/9618ZOXKk33Z53wjRVk1NDeeccw46nY7PP/+cPXv2sHTpUsLDw333+eMf/8jzzz/Pyy+/zKZNmwgODuaCCy6gsbGxF0cuRO9asmQJL730Ei+88AJ79+5lyZIl/PGPf+TPf/6z7z7y3hHCq76+nlGjRvGXv/yl3f2dea/MmzeP3bt3s3LlSj799FO+/vprbrvttp56CSdPEX3ShAkTlDvvvNN32+12KwkJCcpTTz3Vi6MSom8rLy9XAGXdunWKoiiK2WxWdDqd8s9//tN3n7179yqAsnHjxt4aphB9Qm1trZKZmamsXLlSmTZtmnLXXXcpiiLvGyE6ct999ylTpkzpcL/H41Hi4uKU//f//p9vm9lsVgwGg/Lee+/1xBCF6JMuueQS5aabbvLbdsUVVyjz5s1TFEXeO0J0BFBWrFjhu92Z98qePXsUQNm8ebPvPp9//rmiUqmU4uLiHhv7yZBKqT7I4XCwZcsWZs2a5dumVquZNWsWGzdu7MWRCdG3WSwWACIiIgDYsmULTqfT772UnZ1NSkqKvJfEGe/OO+/kkksu8Xt/gLxvhOjIJ598wvjx4/n5z39OTEwMY8aM4ZVXXvHtP3ToEKWlpX7vHZPJxMSJE+W9I85oZ599NqtWrSIvLw+A7du3s379ei666CJA3jtCdFZn3isbN24kLCyM8ePH++4za9Ys1Go1mzZt6vExd4a2twcg2qqsrMTtdhMbG+u3PTY2ln379vXSqITo2zweD3fffTfnnHMOw4cPB6C0tBS9Xk9YWJjffWNjYyktLe2FUQrRN7z//vts3bqVzZs3t9kn7xsh2nfw4EFeeuklFi5cyG9/+1s2b97Mr3/9a/R6PfPnz/e9P9r7/CbvHXEmu//++7FarWRnZ6PRaHC73fzhD39g3rx5APLeEaKTOvNeKS0tJSYmxm+/VqslIiKiz76fJJQSQgwId955J7t27WL9+vW9PRQh+rTCwkLuuusuVq5cSUBAQG8PR4h+w+PxMH78eJ588kkAxowZw65du3j55ZeZP39+L49OiL7rH//4B++88w7vvvsuw4YNY9u2bdx9990kJCTIe0cIIY3O+6KoqCg0Gk2blY7KysqIi4vrpVEJ0XctWLCATz/9lDVr1pCUlOTbHhcXh8PhwGw2+91f3kviTLZlyxbKy8sZO3YsWq0WrVbLunXreP7559FqtcTGxsr7Roh2xMfHM3ToUL9tOTk5FBQUAPjeH/L5TQh/9957L/fffz9z585lxIgRXHfdddxzzz089dRTgLx3hOiszrxX4uLi2iyO5nK5qK6u7rPvJwml+iC9Xs+4ceNYtWqVb5vH42HVqlVMnjy5F0cmRN+iKAoLFixgxYoVrF69mvT0dL/948aNQ6fT+b2XcnNzKSgokPeSOGPNnDmTnTt3sm3bNt9l/PjxzJs3z/ezvG+EaOucc84hNzfXb1teXh6pqakApKenExcX5/fesVqtbNq0Sd474ozW0NCAWu3/tVOj0eDxeAB57wjRWZ15r0yePBmz2cyWLVt891m9ejUej4eJEyf2+Jg7Q6bv9VELFy5k/vz5jB8/ngkTJvDcc89RX1/PjTfe2NtDE6LPuPPOO3n33Xf5+OOPCQ0N9c2TNplMBAYGYjKZuPnmm1m4cCEREREYjUZ+9atfMXnyZCZNmtTLoxeid4SGhvr6rjULDg4mMjLSt13eN0K0dc8993D22Wfz5JNPctVVV/H999/zt7/9jb/97W8AqFQq7r77bp544gkyMzNJT0/n4YcfJiEhgcsvv7x3By9EL7r00kv5wx/+QEpKCsOGDePHH39k2bJl3HTTTYC8d4Rora6ujvz8fN/tQ4cOsW3bNiIiIkhJSTnheyUnJ4cLL7yQW2+9lZdffhmn08mCBQuYO3cuCQkJvfSqTqC3l/8THfvzn/+spKSkKHq9XpkwYYLy3Xff9faQhOhTgHYvy5cv993HZrMp//d//6eEh4crQUFBypw5c5SSkpLeG7QQfdC0adOUu+66y3db3jdCtO8///mPMnz4cMVgMCjZ2dnK3/72N7/9Ho9Hefjhh5XY2FjFYDAoM2fOVHJzc3tptEL0DVarVbnrrruUlJQUJSAgQMnIyFAefPBBxW63++4j7x0hvNasWdPu95v58+critK590pVVZVy9dVXKyEhIYrRaFRuvPFGpba2thdeTeeoFEVReikPE0IIIYQQQgghhBBnKOkpJYQQQgghhBBCCCF6nIRSQgghhBBCCCGEEKLHSSglhBBCCCGEEEIIIXqchFJCCCGEEEIIIYQQosdJKCWEEEIIIYQQQgghepyEUkIIIYQQQgghhBCix0koJYQQQgghhBBCCCF6nIRSQgghhBBCCCGEEKLHSSglhBBCCCGEEEIIIXqchFJCCCGEEEIIIYQQosdJKCWEEEIIIYQQQgghepyEUkIIIYQQQgghhBCix0koJYQQQgghhBBCCCF6nIRSQgghhBBCCCGEEKLHSSglhBBCCCGEEEIIIXqchFJCCCGEEEIIIYQQosdJKCWEEEIIIYQQQgghepyEUkIIIYQYcKZPn8706dN7exhd4vXXX0elUnH48OGTPvaGG24gLS2ty8fUVX73u9+hUql6exhCCCGE6CUSSgkhhBCi1zUHL82XgIAAsrKyWLBgAWVlZb09vAFv+vTpfr9/vV5Peno6t912G4WFhb09PCGEEEIMUNreHoAQQgghRLPHH3+c9PR0GhsbWb9+PS+99BKfffYZu3btIigoqLeH1yuuu+465s6di8Fg6NbnSUpK4qmnngLA4XCwZ88eXn75Zb788kv27t3bLb//hx56iPvvv7/LH1cIIYQQ/YOEUkIIIYToMy666CLGjx8PwC233EJkZCTLli3j448/5uqrr+7l0fUOjUaDRqPp9ucxmUxce+21ftvS09NZsGABGzZs4Cc/+UmXP6dWq0WrlY+jQgghxJlKpu8JIYQQos+aMWMGAIcOHQLA5XLx+9//nkGDBmEwGEhLS+O3v/0tdru9w8eoq6sjODiYu+66q82+oqIiNBqNr0KoeRrhhg0bWLhwIdHR0QQHBzNnzhwqKiraHP/iiy8ybNgwDAYDCQkJ3HnnnZjNZr/7TJ8+neHDh7Njxw6mTZtGUFAQgwcP5l//+hcA69atY+LEiQQGBjJkyBC++uorv+Pb6yn18ccfc8kll5CQkIDBYGDQoEH8/ve/x+12n/iXehLi4uIA/IKjI0eO8H//938MGTKEwMBAIiMj+fnPf96m55XT6eSxxx4jMzOTgIAAIiMjmTJlCitXrvTdp72eUitXrmTKlCmEhYUREhLCkCFD+O1vf9ulr0sIIYQQfYOEUkIIIYTosw4cOABAZGQk4K2eeuSRRxg7dizPPvss06ZN46mnnmLu3LkdPkZISAhz5szhgw8+aBPavPfeeyiKwrx58/y2/+pXv2L79u08+uij3HHHHfznP/9hwYIFfvf53e9+x5133klCQgJLly7lyiuv5K9//Svnn38+TqfT7741NTXMnj2biRMn8sc//hGDwcDcuXP54IMPmDt3LhdffDFPP/009fX1/OxnP6O2tva4v5fXX3+dkJAQFi5cyJ/+9CfGjRvHI488clpT4dxuN5WVlVRWVlJSUsLq1at59NFHGTx4MOecc47vfps3b+bbb79l7ty5PP/889x+++2sWrWK6dOn09DQ4Pf7eeyxxzjvvPN44YUXePDBB0lJSWHr1q0djmH37t3Mnj0bu93O448/ztKlS7nsssvYsGHDKb8uIYQQQvRhihBCCCFEL1u+fLkCKF999ZVSUVGhFBYWKu+//74SGRmpBAYGKkVFRcq2bdsUQLnlllv8jv3Nb36jAMrq1at926ZNm6ZMmzbNd/vLL79UAOXzzz/3O3bkyJF+92sex6xZsxSPx+Pbfs899ygajUYxm82KoihKeXm5otfrlfPPP19xu92++73wwgsKoLz22mt+YwGUd99917dt3759CqCo1Wrlu+++azPO5cuXtxnToUOHfNsaGhra/A5/+ctfKkFBQUpjY6Nv2/z585XU1NQ29z1W8xiPveTk5CgHDx70u297z71x40YFUN58803ftlGjRimXXHLJcZ/30UcfVVp/HH322WcVQKmoqDjhmIUQQgjR/0mllBBCCCH6jFmzZhEdHU1ycjJz584lJCSEFStWkJiYyGeffQbAwoUL/Y5ZtGgRAP/973+P+7gJCQm88847vm27du1ix44dbfooAdx2221+08qmTp2K2+3myJEjAHz11Vc4HA7uvvtu1OqWj1O33norRqOxzVhCQkL8qrmGDBlCWFgYOTk5TJw40be9+eeDBw92+FoAAgMDfT/X1tZSWVnJ1KlTaWhoYN++fcc9tiNpaWmsXLmSlStX8vnnn/Pcc89hsVi46KKL/KYutn5up9NJVVUVgwcPJiwszK8KKiwsjN27d7N///5OjyEsLAzwTk/0eDyn9DqEEEII0X9IKCWEEEKIPuMvf/kLK1euZM2aNezZs4eDBw9ywQUXAN5eRmq1msGDB/sdExcXR1hYmC8wao9arWbevHl89NFHvilm77zzDgEBAfz85z9vc/+UlBS/2+Hh4YB3Gl7zWMAbLrWm1+vJyMhoM5akpKQ2vZNMJhPJyclttrV+no7s3r2bOXPmYDKZMBqNREdH+8I1i8Vy3GM7EhwczKxZs5g1axYXXnghd911F5988gm5ubk8/fTTvvvZbDYeeeQRkpOTMRgMREVFER0djdls9nvuxx9/HLPZTFZWFiNGjODee+9lx44dxx3DL37xC8455xxuueUWYmNjmTt3Lv/4xz8koBJCCCEGKAmlhBBCCNFnTJgwgVmzZjF9+nRycnL8qpCaHRvudNb1119PXV0dH330EYqi8O677zJ79mxfENRaR6vdKYpySs/d0eOdyvOYzWamTZvG9u3befzxx/nPf/7DypUrWbJkCUCXBjjjxo3DZDLx9ddf+7b96le/4g9/+ANXXXUV//jHP/jf//7HypUriYyM9Hvuc889lwMHDvDaa68xfPhwXn31VcaOHcurr77a4fMFBgby9ddf89VXX3HdddexY8cOfvGLX/CTn/yky5u4CyGEEKL3yRq8QgghhOgXUlNT8Xg87N+/n5ycHN/2srIyzGYzqampxz1++PDhjBkzhnfeeYekpCQKCgr485//fMpjAcjNzSUjI8O33eFwcOjQIWbNmnVKj9sZa9eupaqqig8//JBzzz3Xt715hcKu5na7qaur893+17/+xfz581m6dKlvW2NjY5tVBwEiIiK48cYbufHGG6mrq+Pcc8/ld7/7HbfcckuHz6dWq5k5cyYzZ85k2bJlPPnkkzz44IOsWbOmW3+vQgghhOh5UiklhBBCiH7h4osvBuC5557z275s2TIALrnkkhM+xnXXXcf//vc/nnvuOSIjI7noootOaSyzZs1Cr9fz/PPP+1U1/f3vf8disXRqLKequbqq9fM6HA5efPHFLn+uNWvWUFdXx6hRo/ye/9hKrj//+c9tKpmqqqr8boeEhDB48GDsdnuHz1ddXd1m2+jRowGOe5wQQggh+ieplBJCCCFEvzBq1Cjmz5/P3/72N98Utu+//5433niDyy+/nPPOO++Ej3HNNdewePFiVqxYwR133IFOpzulsURHR/PAAw/w2GOPceGFF3LZZZeRm5vLiy++yFlnndVu8/SucvbZZxMeHs78+fP59a9/jUql4q233jrlqYXNLBYLb7/9NgAul4vc3FxeeuklAgMDuf/++333mz17Nm+99RYmk4mhQ4eyceNGvvrqKyIjI/0eb+jQoUyfPp1x48YRERHBDz/8wL/+9S8WLFjQ4Rgef/xxvv76ay655BJSU1MpLy/nxRdfJCkpiSlTppzW6xNCCCFE3yOhlBBCCCH6jVdffZWMjAxef/11VqxYQVxcHA888ACPPvpop46PjY3l/PPP57PPPuO66647rbH87ne/Izo6mhdeeIF77rmHiIgIbrvtNp588slTDrs6IzIykk8//ZRFixbx0EMPER4ezrXXXsvMmTN9TeFPRVFRke93olKpCA8PZ9q0aTz66KO+aiWAP/3pT2g0Gt555x0aGxs555xz+Oqrr9o8969//Ws++eQT/ve//2G320lNTeWJJ57g3nvv7XAMl112GYcPH+a1116jsrKSqKgopk2bxmOPPdZu7y8hhBBC9G8q5XRPqwkhhBBC9CNz5sxh586d5Ofn9/ZQhBBCCCHOaNJTSgghhBBnjJKSEv773/+edpWUEEIIIYQ4fTJ9TwghhBAD3qFDh9iwYQOvvvoqOp2OX/7yl709JCGEEEKIM55USgkhhBBiwFu3bh3XXXcdhw4d4o033iAuLq63hySEEEIIccaTnlJCCCGEEEIIIYQQosdJpZQQQgghhBBCCCGE6HEDrqeUx+Ph6NGjhIaGolKpens4QgghhBBCCCGEEGcURVGora0lISEBtbrjeqgBF0odPXqU5OTk3h6GEEIIIYQQQgghxBmtsLCQpKSkDvcPuFAqNDQU8L5wo9HYy6MRQgghhBBCCCGEOLNYrVaSk5N9GU1HBlwo1Txlz2g0SiglhBBCCCGEEEII0UtO1FZJGp0LIYQQQgghhBBCiB4noZQQQgghhBBCCCGE6HHdGkp9/fXXXHrppSQkJKBSqfjoo49OeMzatWsZO3YsBoOBwYMH8/rrr3fnEIUQQgghhBBCCCFEL+jWUKq+vp5Ro0bxl7/8pVP3P3ToEJdccgnnnXce27Zt4+677+aWW27hyy+/7M5hCiGEEEIIIYQQQoge1q2Nzi+66CIuuuiiTt//5ZdfJj09naVLlwKQk5PD+vXrefbZZ7ngggu6a5h9lqIo2Jzu3h6GEEIIIYQQQgghekigTnPCBuEDRZ9afW/jxo3MmjXLb9sFF1zA3Xff3eExdrsdu93uu221WrtreD3O5nQz9BGpEhNCCCGEEEIIIc4Uex6/gCB9n4pruk2fanReWlpKbGys37bY2FisVis2m63dY5566ilMJpPvkpyc3BNDFUIIIYQQQgghhDhtBhzkqI5wmfpbLlF/19vD6VH9Pnp74IEHWLhwoe+21WodMMFUoE7DnsfPvGmLQgghhBBCCCHEgONsQFWZh7oyF3VlLqrKXNSVeajMh1EpHgA8McNQ6R7v5YH2nD4VSsXFxVFWVua3raysDKPRSGBgYLvHGAwGDAZDTwyvx6lUqjOmZE8IIYQQQgghhBgQ7LVQkQcV+5ouud5rcwGgtLl7g0rF12FRfGWKJDo4gvvOkH5S0MdCqcmTJ/PZZ5/5bVu5ciWTJ0/upREJIYQQQgghhBBCtMNmbgmcWl9bizo+JigKorOxRmawLlDHSnsZ39bsw+5xENTYQJy9GpfHhVbdp+KabtOtr7Kuro78/Hzf7UOHDrFt2zYiIiJISUnhgQceoLi4mDfffBOA22+/nRdeeIHFixdz0003sXr1av7xj3/w3//+tzuHKYQQQgghhBBCCNG+huq2VU8VuVBb0vExIXEQPQSisyE6C6JzqDbGsrpyG18VfMWmkvW4alwAmOoVbtgewrRNDajHpqP5paaHXljv69ZQ6ocffuC8887z3W7u/TR//nxef/11SkpKKCgo8O1PT0/nv//9L/fccw9/+tOfSEpK4tVXX+WCC6SvkhBCCCGEEEIIIbqJokB9RdvgqWKfd3tHjImtwqchEJ3jDaECwwEoqy9jVcEqvsr9O1vKtuBp6h0FME5J5Zofg0hek4visFISP5mQ2iAUmw1VUFB3v+I+QaUoStsJjf2Y1WrFZDJhsVgwGo29PRwhhBBCCCGEEEL0FYoCtaWtQqe9LeGTrabj48JSWgVP2d5LVBYEtM0dCqwF3iCq4Ct2VOzw25cTkcOluvFM/KoI9xdrwOWiPiiWvDG3UqOLJzTCwNWPTkJn6N/VUp3NZs6MSYpCCCGEEEIIIYQ4cygKWItbwqfy5vApF+yWDg5SQXhqU7VTq+qnqCwwhBznqRT2m/ez6og3iMqryfPbPyp6FD9J/QnTG9PQvP0RtV+8jltRcKu1HJ1yGwf0o/B4QKtXM3JGMhqtNDoXQgghhBBCCCGE6Ns8HrAUtN9w3FHX/jEqDURk+Fc9RQ+BqEzQBXbuaRUPuyp38VXBV6w6soqC2pbWRBqVhrPizmJWyizOSzmPkH3FVD3/V+rWPe27T+P0q9hlOg+rxQMeSB0RyblzszBGdu75BwoJpYQQQgghhBBCCNG3edxQc7idhuN54LK1f4xaC5GDmwKnIRDTFEBFDgat4aSH4PQ42VK2hVVHVrG6cDXlDeW+fXq1nrMTz2ZWyiymJ0/HqDdSv349VX/4DVWbNzeNR03ABZeyP/1y9u9pAIuHIKOeqb/IYtDYaFSqM6dCqpmEUkIIIYQQQgghhOgb3E6oPtS26qkyD9z29o/R6L1T7Pwajmd7q6E0utMaTqOrkW+PfsuqglWsLVyL1WH17QvSBjEtaRozU2cyNXEqQbogFJcL65dfcuiVV7Hv2+e9o06H8bLLME/+BavXmmnc0wDAsHMTmXx5Boag0xtjfyahlBBCCCGEEEIIIXqWywHVB/zDp/J9UJUPHmf7x2gDmsKn7Jaqp6ghEJ4Gmq6LN6wOK+sK17G6YDUbjm7A1qoSK9wQznkp5zEzZSYT4ydi0Hgrrjx2OzXvv0/V31/DWVgIgCooiPCrrkJz6dVsWFlF0afeVfwiEoKZPi+b+EGmLhtzfyWhlBBCCCGEEEIIIbqHsxGq9reqemoKoaoOgOJu/xhdMERntW04HpYC6u5Zla68oZy1hWtZVbCK70u+x6W4fPvig+OZmTKTGSkzGBMzBq26JUpx19ZS8977VL/5Ju7KSgA0YWGEX38dpqvmsuN7Cz+8fBC304NGp+asS9IYPSsFjVbdLa+jv5FQSgghhBBCCCGEEKfHUe+dYndsw/Gaw6B42j/GYGwKnY5pOG5MAnX3hzaHLIdYVbCKNQVr2FG5w2/fINMgZqTMYGbqTIZGDG3T78lVUUH1m29R8957eOq8DdW1CfFE3ngTYVdeQfHhRr58PhdLubfKKik7nGnXDCEsJqjbX1d/IqGUEEIIIYQQQgghOsde620uXrEPKva2hE/mgo6PCQiDmBzv1LuYVtVPofHQg829PYqH3ZW7WVXgbVR+yHLIb//I6JHMSJ7BjJQZpJvS230M+8FDVC9/DctHH6M4vdMM9YMHEXXrrRgvvpiGeg8r391P/g/eJuhBRj3n/GwwmWfFnpGNzE9EQikhhBBCCCGEEEL4s5m9lU/le/2rn6xFHR8TFOXfaLz5OiSmR8On1pxuJ5tLN7O6cDVrCtf4rZinVWuZGDeRGSkzmJ48nZigmA4fp2Hrj1S99nfqVq0GRQEgcPRoIm+7lZDp01EU2LG2mE3/OYiz0Y1KBSOmJzHhsgwMgRK9dER+M0IIIYQQQgghxJmqodq/11PzdW1Jx8eExLYNnqKzITiq58Z9HHWOOtYXr2d14Wq+KfqGOmedb1+QNoipSVOZkTyDqUlTCdWHdvg4isdD3dq1VL36d2xbt/q2h8yYQeQtNxM0diwAJQcsrHs3l6pi7/PEphuZdvUQolM6fmzhJaGUEEIIIYQQQggxkCkK1Fe0DZ4q9nm3d8SY2DZ8isqCoIieG3snNTcqX12wmk2lm3B5WhqVRwZEMj15OjNSZjApfhJ6jf64j+VxOLB+8glVry3HcfAgACqdDuNPLyPyxhsxDBoEgK3OwcYVB9i7wRvgGYK0TJ4ziKHnJKBSy1S9zpBQSgghhBBCCCGEGAgUBWpL/Xs9NV/bajo+LiylbdVTVBYEGHtu7CdJURQOWg6ypnANqwtWs7Nyp9/+NGMa56Wcx4zkGYyMHoladeLG6W6LhZoP/kH1W2/irvCupKcODSV87lzCr7sWXYx3ep/Ho7B3w1E2fnQAe703/Mo5O57JcwYRGHr8wEv4k1BKCCGEEEIIIYToTxQFLEWtgqfm8CkX7JYODlJBeJo3cIpptdJdVBbog3ty9KfM5XGxrXwbawrXsLZwLQW1/s3VmxuVn5dyHhmmjE4/rqOwkOo33sT84YcoDQ0AaOPiiJg/n7Cf/xxNSMvvp/SQhW/ez6P8SC0AkYnBTLt6CPGDw0779Z2JJJQSQgghhBBCCCH6Io8HLAX+VU/le70NyB117R+j0kBEhn/VU/QQiMoEXWDPjr8LNDgb+Pbot6wpXMPXRV9jtpt9+3RqHRPiJzAzZSbTk6YTHRR9Uo9t27aNquWvU7typfd3DRiysoi46UZMF1+MSt9S9dRgdbBxRT77NpYCoA/QcNbsdEael4Rac+IqLNE+CaWEEEIIIYQQQoje5HFDzeG2Dccr94Ozof1j1FqIHOzf6ykmx7tNa+jR4Xe1ioYK1hatZU3BGjaVbMLhcfj2mQwmzk08l/NSzuPshLMJ1p1clZfidlO7ahXVy1/H9uOPvu3BU6YQceMNBJ99NqpWKwW63R52rS3m+/8cxNHoBiB7chyTLh9EsKl//577AgmlhBBCCCGEEEKInuB2QvWhYxqON4VPbnv7x2j03sDp2IbjERmg0fXs+LuJoijsN+9nbeFa1haubdMfKikkifNSzuO85PMYEzMGrfrkowxPQwPmD1dQ/eabOAu80/5UOh3GSy8l4ob5BGRltTmmaF813/xjP9VH6wGITgnl3LlZxGWYTvr5RfsklBJCCCGEEEIIIbqSyw5VB9qudleVDx5n+8doA5rCp2MajoengWbgfXV3up38UPYDawvXsq5oHcV1xX77R0SN4Lzk85iePJ3BYYP9qpdO6nnKyqh5+x1q/vEPPBZvvy2NyUTY1XOJmDcPbXTbKX+11Y1s+Fc+B7aWAxAQrGPS5RnknJOAWlbV61ID72+2EEIIIYQQQgjRE5w2b5XTsQ3Hqw+C4m7/GF0wRGdBdI5/9VNYCqg1PTv+HmaxW1hfvJ61hWtZX7yeOmdLXyyDxsCk+ElMT57OtKRpJ90f6li2nTupfuNNrF98AS7vCnm61BRv8/LLL0cdFNTmGJfTzbaVhWz5/DAupweVCoafm8iEyzIICB4YVWl9jYRSQgghhBBCCCHE8Tjqvc3FW1c9Vezz9oFSPO0fYzA2hU5DmgKopvDJmAjqM6cx9hHrEV811NayrbhbhXURARFMT57O9KTpTEqYRKD29BqxK243tV+tovqNN7Bt3erbHnTWWUTMv56Q885DpWkb/CmKwoGtFXz773xqqxsBiB9s4ty5WUQlhZ7WmMTxSSglhBBCCCGEEEIA2GuhIq9tw3FzAaC0f0xAmLfBePQQiBoCMU3T7kLj4RSnnPVnLo+LbeXbWFe0jrWFazlsPey3f3DYYG8QlTydEVEjUKtOP6Bz19Zi/te/qXn7bZzFTdMAdTpMF19E+PXXEzhsWIfHVhTU8s0/8ijJ907tCw4zcPYVg8g8K/aUpwyKzpNQSgghhBBCCCHEmcVmblv1VJEL1qKOjwmKOqbf0xBvGBUcfUaGT63VOmrZULyBtUVr+aboG6wOq2+fVq1lfOx4piVNY1ryNJJDk7vseR0FBVS/9TaWf/8bT4N3lUJNWBhhV88lfO7V6GJjOjy23mJn08cH2buxBBTQ6tSMOT+FMeenojMM7GmUfYmEUkIIIYQQQgghBqaGav+qp/K93uu60o6PCYk7ZqW7pp+Do3pu3P1AgbWAtYVr+broa7aUbcGluHz7wgxhTE2cyrTkaZydcDah+q6bAqcoCg3ffUf1m29Rt3YtKN4KNv3gQURcfz2myy5DHRDQ4fEup5vtqwrZ8vkRnHbvVMLMs2KZPGcQoREdHye6h4RSQgghhBBCCCH6L0WB+spW4VOr6qf6io6PMya2rHDnC6GyIDC858bejzg9Tu+0vMJ1rCta12ZaXoYpg2nJ05ieNJ1R0aPQdHHTdo/NhuWT/1Dz9lvY9+f7tgdPnUrE/PkEn3P2cafbKYrCwR8r+PbDfKyV3r5RMWlGpl6VSVyGqUvHKjqv20Opv/zlL/y///f/KC0tZdSoUfz5z39mwoQJHd7/ueee46WXXqKgoICoqCh+9rOf8dRTTxFwnKRTCCGEEEIIIcQApyhQW9p2yl3FPrBVd3xcWMoxwVM2RGVBgLHnxt5PmRvNfFP8DV8Xfc2G4g3UOmt9+1pPyzs36VxSjCndMgZncTHV776L+V//xmPx9n1SBQURNmcO4fPmYchIP+FjVBTUsv6f+zm63wxAsEnP5DmDyJoQh0p9Zk+97G3dGkp98MEHLFy4kJdffpmJEyfy3HPPccEFF5Cbm0tMTNu5ne+++y73338/r732GmeffTZ5eXnccMMNqFQqli1b1p1DFUIIIYQQQgjRFygKWIpaBU/N4VMu2C0dHKSC8LSWaqfoHG/D8ags0Af35Oj7NUVR2G/ez9dFX/N10ddsr9iOp9XqguGGcKYmTWVakndaXog+pNvG0bB5MzVvvU3tqlXg8Y5Bl5xMxLXzMF1xBZrQE08JrK1uZNMnB8ndVAoKaHRqxvwkhbEXSN+ovkKlKEoHSwicvokTJ3LWWWfxwgsvAODxeEhOTuZXv/oV999/f5v7L1iwgL1797Jq1SrftkWLFrFp0ybWr1/fqee0Wq2YTCYsFgtGoyTfQgghhBBCCNEneTxgKfDv9VSxDyrzwFHX/jEqDURk+Fc9RQ+BqEzQBfbs+AcIm8vG5tLNrCtcx9fFX1Na799vKys8y1cNNSJqRJdPy2vNY7Nh+fRTat55F/u+fb7tQZMnEXHd9YRMOxeV5sTP77C52PrlEbatKsTt9AZa0jeqZ3U2m+m2SimHw8GWLVt44IEHfNvUajWzZs1i48aN7R5z9tln8/bbb/P9998zYcIEDh48yGeffcZ1113X4fPY7XbsdrvvttVq7fC+QgghhBBCCCF6mMcNNYfb9nuqyAOXrf1j1FqIHHxMw/EciBwEWkOPDn8gKqkr4euir1lXtI7vS7/H7m75Tm3QGJgQN4Fzk85lWtI04kPiu308jsJCat59D/OHH7ZM0QsIwPTTnxJx7TwMmZmdehy328Pe9Uf5/tND2GqdACRkhnH2lYOJTZOilb6o20KpyspK3G43sbGxfttjY2PZ1yrxbO2aa66hsrKSKVOmoCgKLpeL22+/nd/+9rcdPs9TTz3FY4891qVjF0IIIYQQQghxktxOqD7UtudTZR60Cj38aPQQmemdate671NEBmh0PTv+AczlcbG9YrtvWl6+Od9vf1xwnK8a6qy4swjUdn/VmeLxUL9hAzVvv0Pd11/7VtHTJSURfvXVhF15BZqwsM49lqJweGcVGz/Mp6a0AYCw2CAmzxlE+qio4zZAF72rT62+t3btWp588klefPFFJk6cSH5+PnfddRe///3vefjhh9s95oEHHmDhwoW+21arleTk5J4ashBCCCGEEEKcWVx2qDrQNnyqygePs/1jtAHe/k7HNhwPTwNNn/paOmBUN1azvng93xR9w4ajG6h1tDQpV6vUjIoexblJ53Ju0rlkhmX2WHDjrq3FsmIFNe+8i+PIEd/24KlTCZ93DSFTp3Zqil6z8iNWvv13PsV5ZgACQnRMmJ3O0KkJaDTqrh6+6GLd9u6PiopCo9FQVlbmt72srIy4uLh2j3n44Ye57rrruOWWWwAYMWIE9fX13HbbbTz44IOo1W3/QhkMBgwGKd8UQgghhBBCiC7lbISq/f4Nx8v3QfVBUNztH6MLbgqdjun5FJYC3diLSIBH8bC3ei9fF33NN0XfsKtyFwotLaRNBhNTEqcwNXEq5yScQ1hAWI+OrzE3j5r33sXyyX9QGrzVTOqQEMKuvIKwuXMxpJ94Fb3WrJU2Nn1ykLzvvZmDRqtm1Mxkxl6YiiFQgs7+otv+pPR6PePGjWPVqlVcfvnlgLfR+apVq1iwYEG7xzQ0NLQJnjRNCWk39mMXQgghhBBCiDOXo947xa511VPFPm8fqFYrr/kxGFuFTzkt4ZMxEdopJhDdw+qwsvHoRtYXr2d98XoqbZV++3MicpiSOKVHmpS3x+NwUPu/ldS89x62LVt82w2ZmYTPm4fp0tmog09udURbrYMfPjvMrq+L8bi9OUHWxFgmXpaBMVKa3fc33RofLly4kPnz5zN+/HgmTJjAc889R319PTfeeCMA119/PYmJiTz11FMAXHrppSxbtowxY8b4pu89/PDDXHrppb5wSgghhBBCCCHEKbDXepuLV+z1D5/MBR0fExAGMTlNK9wNaen9FBoP0qenxymKQl5NHt8Uf8M3Rd+wvWI77lZVa0HaICYnTObcpHOZkjiFmKCYXhmns7iYmg/+gfnf/8ZdVeXdqNEQOnMm4fPmETThrJOeLuhodLF9VSE/rizA2eh9zUnZ4UyeM4iYVGli3l91ayj1i1/8goqKCh555BFKS0sZPXo0X3zxha/5eUFBgV9l1EMPPYRKpeKhhx6iuLiY6OhoLr30Uv7whz905zCFEEIIIYQQYuCwmb2VT+V7/aufrEUdHxMU5d/vqTl8Co6W8KmX1Tnq+K7kO74p/ob1xespbyj3259hyvBOy0uayriYceh6qUG8r3H5u+9Rt24deLxVdtqYGMJ+cRVhP/s5utiTD8ncbg97vjnK5s8OY7M6AIhOCWXy5YNIHhrRpa9B9DyVMsDmxVmtVkwmExaLBaNR0lIhhBBCCCHEANVQ3dLrqXX4VFvS8TEhca36PbW6Do7quXGL41IUhf3m/b4peT+W/YhLcfn2B2gCmBg/kSmJU5iSOIWk0KReHC24amqwfPghNe9/gLOw0Lc9aPIkwq++mtDzzkOlO/mgTPEo5G8tZ9PHB7FU2AAwRgcy6bIMBo+LQaWWsLQv62w2I92/hBBCCCGEEKKvUhSor2gbPFXs827viDHRu9pd89S75vApMLznxi46rdZRy3cl3/mCqGOroVKNqUxNnMrUxKmMixuHQdO7i30pioJtyxZqPvgHtV98geL0rrqoDg0l7Io5hP1iLoaMk2tc3lrhvmo2fniAigLvioGBoTrOuiSdoVMS0GilZ9lAIqGUEEIIIYQQQvQ2RfFWOLUXPtlqOj4uLOWYqqdsbxgVILNG+jJFUcityfWFUNvLt/tVQxk0Bs6KO8u3Wl6KMaUXR9vCbbFg+fgTav7xAY78A77tAUOHEn7N1Rgvvhh1UNApP37pQQvffXyQ4lzv33mdQcOY81MYNTMZfYDEFwOR/KkKIYQQQgghRE9RFLAUtQqemsOnXLBbOjhIBeFp3qqn1tVPUVmgP7mVy0TvsdgtbCzZyIbiDXxb/C3lNv9qqDRjmm9K3rjYcQRoA3pppP4URaFx+3Zq3v8A6+efo9jtAKgCAzFecjHhv5hL4Ijhp/UclUW1bPr4IId3epuiqzUqhp2byPiL0ggy6k/7NYi+S0IpIYQQQgghhOhqHg9YClrCp/KmAKoyDxx17R+j0kBEhn/VU/QQiMoEnSx139+4PW72VO1h/dH1bCjewM7KnXgUj29/gCaACfETfEFUcmhyL462LXddHdb//Iea9z/Anpvr227IyiJs7i8wXXopmtDQ03qOmtJ6vv/0EPk/eAM6lQqyJ8cz/pI0jJHyd/5MIKGUEEIIIYQQQpwqjxtqDrfTcDwPXLb2j1FrIXKwf6+nqKbwSdu7vYLE6am0VfLt0W9ZX7yejUc3Yrab/fYPMg3inMRzOCfhnD7RG+pYiqLQuGMHNf/8J9bPPkdpaABAZTBgvPBCwub+gsDRo1Gd5oqM1iobm/97mNyNJTQvvZY5PoYJl2YQFnvq0/9E/yOhlBBCCCGEEEKciNsJ1Qfb9nyq3A9ue/vHaPTeKXbHrnYXkQGak1+NTPQ9TreTbRXbvFPyjn7L3uq9fvtDdCFMTpjM2Qlnc07COcSHxPfSSI/PbbFg+eQ/mP/5T+x5eb7t+kGDCP/FVZguuwxNWNhpP0+9xc6Wz4+w+5ti2N1KvAABAABJREFUPG5vGpU2MoqJl6UTlXR6VVeif5JQSgghhBBCCCGauexQdeCY8Gmfd5vH2f4x2kCIzmrbcDwsFTTylWugKbAWsOGoty/U96Xf0+Bq8Ns/NHIo5yScw5TEKYyIHoFO3TcDSEVRsP3wAzX//Ce1X/6vpVeUwYDxwgsI+/nPCRw37rSrogBstQ5+/F8BO9cW4XJ6pzAmDgln0k8ziMswnfbji/5L/oUUQgghhBBCnHmcNm+V07ENx6sPguJu/xhdcFPo1BQ8NTccN6WAWpapH6jqnfVsKtnEt0e/ZUPxBorqivz2RwREcHbC2b5LZGBkL420c1zV1Vg++hjzP/+J49Ah33bDkCGE/fznmC6djcbUNUGRra5VGOXwhlGx6UYm/TSDpOyILnkO0b9JKCWEEEIIIYQYuBz13ubirafcle/19oFCaf8Yg/GYZuNNFVDGRAmfzgAexcPeqr3eEOroBraXb8eluHz7tWotY2LG+KbkDYkYglrVt/9eKG439d9uxPzvf1O7ahU4vVV/qqAgjBdfRPhVVxEwYkSXVEUBNNY5+XFlATvWFuGye0Pe6JRQJlyaTurwyC57HtH/SSglhBBCCCGE6P8arU3h0zENx80FHR8TENZS7RSd7e3/FJMDofHeZcDEGaO0vpSNRzfy7dFv+a7kuzYNypNDkzk74WymJE7hrLizCNYF985AT5KjqAjLhx9iXvERrpIS3/aA4cMJ+/nPMV5yCZqQrnstjfVOtq0sYMeaIpytwqizZqeTNkLCKNGWhFJCCCGEEEKI/sNW413Z7tiG49aijo8JivIPn5qvg6MlfDpD2Vw2tpRtYUPxBjYe3cgBywG//cG6YCbGTfRNyUs2JvfSSE+ex26nduVXmP/9Lxo2fufbrjaZMM2eTdjPriQgJ6dLn7Ox3sm2r5rCqEZvGBWVHMKE2emkjYySMEp0SEIpIYQQQgghRN/TUN1S9VTeqvqprrTjY0Li2gZP0UMgOKrnxi36JI/iYV/1Pm8l1NHv2Fq+FWerxvUqVIyIGuFbKa8vNyjvSOPevZj/9W8sn36Kx2LxbQ8+ezKmK68kdNYs1AZD1z5nvZPtqwrZsboQR1MYFZnkDaPSR0kYJU5MQikhhBBCCCFE71AUqK9oW/VUsc+7vSPGpKbV7lpXP2VBYHjPjV30ec1T8jYe3ch3Jd9RY6/x2x8XHOerhJoUPwmTof+tAueqqcH638+wfPghjXv2+LZr4+MJmzMH0xVXoE9K7PLnbbA62L6qgJ1ri33T9CITgzlrdjoZo6JRqSWMEp0joZQQQgghhBCieykK1Ja2Hz7Zqjs+LizlmKqnpr5PAcaeG7voN+qd9fxQ+gMbS7y9oQ5ZDvntD9IGMSFuApMSJnF2wtmkGdP6ZSWP4nJRv2ED5g9XULd6NUpz03KdjpBZMwm74kqCz56MSqPp8ueut9j58X8F7P66GJfTu5peZFII4y9KY9AYCaPEyZNQSgghhBBCCNE1FAUsRa2Cp+bwKRfslg4OUkF4mn/4FNMUPun7RzNp0TtcHhe7KnexsWQj3x39jh0VO/xWyVOr1AyPGs7k+MlMTpjMyOiR/W5KXmv2AwewrFiB5eNPcFW0VBIahuYQNucKjLMvQRvePdWCtdWNbP3yCHs3lOB2ecOomNRQxl8iDczF6ZFQSgghhBBCCHFyPB4wH2lb9VSZB4669o9RaSAiw7/qKXoIRGWCLrBnxy/6JUVROGw97JuOt7l0M3VO/79vyaHJTIr3VkKdFXdWv5yS15rbasX62WeYV6ygcfsO33ZNeDimyy7FNGcOAdnZ3fb8lgobW784zL7vSvG4FQDiB5kYf3EayUMjJIwSp01CKSGEEEIIIUT7PG6oOXxM1dM+7+p3Llv7x6i1EDm4KXxq7vk0xLtN27VNlsXAV2mrZFPJJr4r+Y7vSr6jtN6/0b3JYGJi3EQmJUxicvxkkkKTemmkXUdxuaj/9lssH31E7arVKHa7d4dGQ8i0aYRdMYeQc89Fpdd32xiqS+rZ+uUR8r4vQ/F4w6jEIWGMvzidxKwwCaNEl5FQSgghhBBCiDOd2wnVh44JnvZB5X5w29s/RqOHyEzvVLvWU+8iMkDTf6dIid5V76xnS9kWNh7dyKbSTeyv2e+3X6fWMTZmrDeESphMdng2GnXX907qDY25uVhWfITl009xV1b6thsyMzFdcQWmS2ejjerelSTLDlnZ8sVhDm1vef6UYRGMvyiN+MFh3frc4swkoZQQQgghhBBnCpcdqg60bThelQ8eZ/vHaAO8/Z38ej7lQFgqaOTrhDg9To+TnRU7fZVQOyt2+vWFUqEiOyKbifETmRw/mTGxYwjUDpzpnq7KSiyfforlo4+x79vn264JD8c4ezamy39KwNCh3VqZpCgKRXtr2PLlEYpzW1YozBgdzdgLU4lNk4UFRPeR/4sIIYQQQggx0Dht3iqnYxuOVx8Exd3+MbrgVv2eslqm3oWlwACpRBG9z6N4yKvJ803J21K2BdsxU0GTQpKYlDCJSfGTmBA3gfCA7mne3Vs8djt1q1dj+ehj6tavB7f3PanS6Qg57zxMl/+UkKlTUem6t+LQ41E4tK2CLV8coaKgFgC1WkXWhFjGXJBKRLwsNCC6n4RSQgghhBBC9FeOem9z8ebwqbwpgKo5DCjtH2Mw+lc9Nf9sTAS1uidHL84AiqJQWFvIdyXfsalkE5tLN1Njr/G7T7ghnInxE5kUP4mJ8RMHRF+oYykeDw2bf8Dyn0+o/eJLPHUtDdoDRo0k7PLLMV50EZqwsG4fi9vlIXdTKT/+rwBzWQMAWp2aoVMSGP2TFEIjArp9DEI0k1BKCCGEEEKIvs5e27bqqWIfmAs6PiYgzDvNzhc+NTUeD40DaVIsulFFQwWbSjexqcR7Kakv8dsfqA1kXOw4XwiVFZ6FWjUwA1H7/v1YPvkEy6f/xVXS8nvQxsdjuuwyTD/9KYaM9B4Zi6PRxZ71R9m+qpC6Gm+vOEOQlhHTkxh5XhKBof6N0xVFweVy4XZ3UF0pzmgajQatVnvaU0sllBJCCCGEEKKvsJn9ez01X/9/9u48PMr63v//c/aZzGSy7zsQQtg3QbAVsako2iP1nFqrRzbRrxU8sfz0Aqxae6zaVkSoVtB+a+jXS6vHc4mKdalgxTZuCCJbCFvYyb5Mksns9++PezLJkAQIkpX3w+u+7nvubT6TZCLzyufz/jhOdH1NRFy7We5GtBUetyZI+CR6RYO7ga3lW/ny9Jd8Vf4VhxsOhx3Xa/WMSxgX6g01On40Bu3gLYbvrazE8e7faNi4EXdJSWi/NjIS+7WzsP/oR0RMnoyml3omNte7+fbj4+z55yk8LWq9rogoI+N/kMmoK1MxmjvGAh6Ph9OnT+N0OnuljWJgioiIICUlBeN3mAmyx0OpP/7xjzz11FOUl5czbtw4nn32WaZMmdLl+fX19fzyl7/kzTffpLa2lqysLFavXs3s2bN7uqlCCCGEEEL0juaajr2eqkqhqbzra2zJZ/R6Cq6tPTsblxBnavY2s71ieyiE2le7D6XdcNHW4uStPaEmJE4gwhDRhy3uef6mJho3bcLxzkaav/gCAgH1gMGA7corifrRj7DNvAqtydRrbao52cSOTcfY/1UFAb/6/YlOimB8QQYjLk9BZ+g8FAsEApSVlaHT6UhNTcVoNPZooXUx8CiKgsfjoaqqirKyMnJzc9FeYMjao6HU66+/ztKlS1m3bh1Tp05l9erVzJo1i9LSUhITEzuc7/F4+OEPf0hiYiL/+7//S1paGkePHiW6F8bVCiGEEEIIcVEpCjRXdQyeKkvAWd31dfb0YOjUvubTcLAMrmLPYuBw+Vx8W/UtX5V/xVenv2J39e6wGfIAhkYNZUrKFKYmT2Vy8mSiTFF91NreE/B4aP7nP2nY+C5N//gHitsdOmaZMIGof/sRkddeiz6m9967iqJwcn893/z9GMf21IT2pwyLYsI1WWSPjkOjPXvA5PF4CAQCZGRkEBExuMNEceEsFgsGg4GjR4/i8Xgwmy+sFlmPhlKrVq3izjvvZMGCBQCsW7eOv/3tb7z00kssX768w/kvvfQStbW1fPbZZxiCMw1kZ2f3ZBOFEEIIIYT4bhQFGk93DJ+q9kFLXdfXRWd2LDgePxzMMv266Ftev5ed1TtDIdTOqp14Ap6wc9Jt6UxNmcqU5ClMSZlCvOXS6LGn+P04t36N42/v4vjw7wQcjtAxY3Y29htuIOrffoQxM7NX2xXwBzi0vYpvPjoWmklPo4EhExIY/8NMknO6HxJeaM8Xcem4GD8jPRZKeTwetm3bxooVK0L7tFotBQUFfP75551e88477zBt2jQWL17M22+/TUJCArfeeivLli1Dp+t8Glq32427XSLtaPdLQQghhBBCiItGUaDhRLvgqSS4XQrurv4NqoHYnLbwKT5PrfkUPxyMMt266B+8AS97qvewtXwrX5V/xY7KHbj8rrBzEi2JXJZyGVOTpzIlZQpptrQ+am3vUxQF1969ODa+i+O99/BVVoaO6RMTsV9/PfYbrsc8cmSvD3Nzt6jFy3f94wSNter3TG/Qkj89hXEFGUQlSE8n0b/1WChVXV2N3+8nKSkpbH9SUhL79u3r9JrDhw/z8ccfc9ttt/Hee+9x8OBB7rnnHrxeL7/61a86vebJJ5/k17/+9UVvvxBCCCGEuEQFAtBwrG2oXWsIVb0fPE2dX6PRQeyQM4bc5UF8Lhgsvdt+Ic7BF/BRUlPC1oqtbC3fyvaK7Th94QWtY82xTEmewmXJlzEleQpZ9qxLrq6Q+/BhHH97D8d77+EpKwvt19rt2Gddg/36G4i4bDKaLjpQ9KSGKic7Pz5ByWen8brV2fEskQbGXJXO6BlpWGwXXnhaiN7Ur2bfCwQCJCYm8uKLL6LT6Zg0aRInT57kqaee6jKUWrFiBUuXLg09djgcZGRk9FaThRBCCCHEQBXwQ92RTgqO7wdfS+fXaPUQNyw8eEoYAXFDQd97BYyF6A5/wM++2n2hnlDbK7fT7G0OOyfKFMVlSZeFQqih0UMvuRAKwHPiBI733sfx3nu423Wm0JhM2K6eSdQNN2D9/vfRfofZxi6UoiicOlDPt5uPU7azmtba8rGpVsb9IIPhlyWhN/Z+QDaYrF+/nvvuu4/6+vq+bso5Pfroo7z11lvs2LHjvK/RaDRs2LCBOXPm9Fi7uqvHQqn4+Hh0Oh0VFRVh+ysqKkhOTu70mpSUFAwGQ9hQvfz8fMrLy/F4PJ1OM2gymTD14gwGQgghhBBigPF7ofZwx5pP1QfA7+78Gp1RHWIXPxwS89vCp9ghoBu8U9mLwcEf8LOvbh9fl3/N1vKtbKvYRpM3vJdfpDGSyUmTuSxZDaKGxwxHq7k0awh5Kypp/OB9HO+9T8u337Yd0OuxXjEd+3XXEVlQgM5m65P2+X0BDn5dwY7Nx6k+3vZ9zBwVx/gfZJCeH3NJBoidmT9/Pn/5y18AMBgMZGZmMnfuXB588EH0+n7VJ+c7u//++7n33nsv+n3/+Mc/8tRTT1FeXs64ceN49tlnmTJlykV/nlY99l0xGo1MmjSJzZs3h1K4QCDA5s2bWbJkSafXXHHFFbz66qsEAoFQwaz9+/eTkpLSaSAlhBBCCCFEiM8NNYc6hk81ByHg7fwavUWd2e7MguPRWaAbXB9gxODlC/gorS1la/lWvq74mu0V22n0NoadE2mIZFLSJCYnT2ZK8hSGxwxHp710e9X4amtp/PtHOP72N5xff63WjAPQaomYMgX77OuI/OEPe3XmvDM5HR72/uskuz45idOhFprXG7TkTUth7Mx0YlOkLl1nrr32WoqKinC73bz33nssXrwYg8EQVu96MLDZbNguclD6+uuvs3TpUtatW8fUqVNZvXo1s2bNorS0lMTExIv6XK169P+0S5cuZd68eUyePJkpU6awevVqmpubQ7PxzZ07l7S0NJ588kkAfv7zn/Pcc89RWFjIvffey4EDB3jiiSf4r//6r55sphBCCCGEGEi8Lqg50C54ag2fDoHi7/wag7Vd6JTX1vspKhNkhikxwLSvCfV1+dedDsezGWxMSJyg1oVKuYwRMSMu6RAKwFdXR+NHH9H4wYc0f/kl+Nt+X1gmTsQ+ezb2WdegT0jow1ZC5VEHO/9xggNfVxDwqWGZNcrImJnpjPpeGmZb7/fWVBSFFm8Xv197mMWg61ZPMJPJFBqd9fOf/5wNGzbwzjvvsGLFCurq6igsLGTjxo243W5mzJjBH/7wB3Jzczvc58iRIwwZMoSvvvqKyZMnh/avXr2aZ555hrKyMj799FNmzpzJpk2bWLZsGXv37mX8+PEUFRWRl5cXumbt2rWsXLmS48ePk5OTw0MPPcTtt98eOq7RaFi3bh0bN27k448/Jisri5deeomEhAQWLVrE1q1bGTduHC+//DJDhw4FOg7f27p1Kw8++CDffPMNXq+X8ePH88wzzzBx4sTz/tqtWrWKO++8M5TZrFu3jr/97W+89NJLLF++/Lzv0x09Gkr99Kc/paqqikceeYTy8nLGjx/PBx98ECp+fuzYsbApBDMyMvjwww/5xS9+wdixY0lLS6OwsJBly5b1ZDOFEEIIIUR/5GlWi4u37/VUtU+tA6UEOr/GZD+j2HgwhIpKV+dHF2IA8vq97KnZw9cVX/N1xdd8U/FNh8Lk7XtCTU6aTF5sHnqt9Pbz19fTuGkTjvc/oPmLL8KCKPPIkerMedddiyE1tQ9bqQ7RO7S9kp3/OEFFWdtsnonZdsbOTGfYpER0+r4L0Fu8fkY+8mGfPPfe/55FhPHCf5YtFgs1NTWAOrzvwIEDvPPOO9jtdpYtW8bs2bPZu3cvBkN42JednU1BQQFFRUVhoVRRURHz588PyzJ++ctf8vTTT5OQkMDdd9/NwoULKS4uBmDDhg0UFhayevVqCgoKePfdd1mwYAHp6enMnDkzdI/HHnuMVatWsWrVKpYtW8att97KkCFDWLFiBZmZmSxcuJAlS5bw/vvvd/o6GxsbmTdvHs8++yyKovD0008ze/ZsDhw4QGRk5Dm/Th6Ph23btoX1KNNqtRQUFPD555+fx1f6wvT4b6klS5Z0OVzvk08+6bBv2rRpfPHFFz3cKiGEEEII0W+4HMHw6YyC4/XHur7GHB1e6ykhD+LzwJ4q4ZMY8Nx+NzurdrKtYhtfV3zNt5Xf4vK7ws6xG+1qCBWsC3WpD8drz9/QQOOmzTg++IDmzz8Hny90zDQyH/u112G/dhbGzMw+bKWqucHNnk9Psuefp0JD9LQ6DcMmJzL2qgyScux93MKBS1EUNm/ezIcffhgaifXOO+9QXFzM9OnTAXjllVfIyMjgrbfe4ic/+UmHeyxatIi7776bVatWYTKZ2L59O7t27eLtt98OO+/xxx9nxowZACxfvpzrr78el8uF2Wxm5cqVzJ8/n3vuuQdQR5R98cUXrFy5MiyUWrBgATfffDMAy5YtY9q0aTz88MPMmjULgMLCwlAPps5cffXVYY9ffPFFoqOj2bJlCzfccMM5v17V1dX4/f5QJ6JWSUlJ7GtX9P9ik+hcCCGEEEL0jpY6dWa7UPBUoq4dJ7u+xpqghk2JZ8x2Z02Q8EkMGk6vk2+rvg2FULuqduEJeMLOiTHFMClpEpOSJnFZ8mXkxuResoXJO+Ovr6dx88c4/v4hzZ99Dt62OnKmESOwX3utGkRlZ/ddI4MURaGiTB2id2hbJYGAOkQvIsrI6CvTGPX9NCLs/aumssWgY+9/z+qz5+6Od999F5vNhtfrJRAIcOutt/Loo4+yefNm9Ho9U6dODZ0bFxdHXl4eJSUlnd5rzpw5LF68mA0bNnDLLbewfv16Zs6cSfYZP0djx44NbaekpABQWVlJZmYmJSUl3HXXXWHnX3HFFaxZs6bLe7QGQ2PGjAnb53K5cDgc2O0dw8qKigoeeughPvnkEyorK/H7/TidTo4dO8sfePoBCaWEEEIIIcTF5axVg6fKkvChd03lXV9jSw7v9dQ69M4a13vtFqKXODwOdlTu4OuKr9lWsY291XvxKb6wc+It8UxOmhzqDTUkeoiEUGfw1dbSuGkTjR/+Xa0R1b5H1PDh2K+7lshZ12IaktOHrWzjdfvZ/1U5uz89GTaLXsrQKMbMTGfIhAR0uv75PdZoNN9pCF1vmjlzJmvXrsVoNJKamvqdZt0zGo3MnTuXoqIibrrpJl599dUOYRIQNvSvtf5VINDFMPMudHaP7tx33rx51NTUsGbNGrKysjCZTEybNg2Px9Pp+WeKj49Hp9NRUVERtr+ioiJUo6snDIyfKiGEEEII0b8oCjRXdZzprmqfur8r9rS2oXbtez9Z+m6GKyF6WnVLNdsrtrOtYhvbKraxv24/CkrYOcnW5LAQKsue1a3izpcKb2WlGkT9/SOcX30F7T6gm0aMwD7rGiKvuQZTsBh0f1B7qpnd/zxJ6een8bjUmlY6vZbcKUmMvSqdhMxz1/sR589qtTJs2LAO+/Pz8/H5fHz55Zeh4Xs1NTWUlpYycuTILu+3aNEiRo8ezfPPP4/P5+Omm27qVnvy8/MpLi5m3rx5oX3FxcVnfc4LUVxczPPPP8/s2bMBOH78ONXV1ed9vdFoZNKkSWzevJk5c+YAagC2efPmLksyXQwSSgkhhBBCiK4pCjSe7jx8aqnr+rrozI69nuKHg1nqo4jBTVEUTjadZHvl9lAQdcRxpMN52fbs0HC8SUmTSLX1baHt/sx7+jSNH23C8fcPadm2Xf29FGQeNYrIWbOwX/PDfjE0r5XfF+Dwjip2bznJqQP1of32BAujr0wjf1pKn8yidynLzc3lxhtv5M477+SFF14gMjKS5cuXk5aWxo033tjldfn5+Vx++eUsW7aMhQsXYrFYuvW8DzzwADfffDMTJkygoKCAjRs38uabb7Jp06bv+pLC5Obm8vLLLzN58mQcDgcPPPBAt9u6dOlS5s2bx+TJk5kyZQqrV6+mubn5rLWsvisJpYQQQgghhPohr+FEu+CpdehdKbgdXVykgdic8PApfri6bbT2avOF6CsBJcDB+oNsrwiGUJXbqHRWhp2jQcPwmOFMTJoYCqHiLfF91OKBwX24TO0R9dFHuHbtCjtmGTeOyFmziLzmhxjT0/uohZ1rrHWx558n2Vt8mpZg4XKNBrLHxjN6RhoZI2LRaKUHXF8pKiqisLCQG264AY/Hw5VXXsl7773XYea9M91xxx189tlnLFy4sNvPOWfOHNasWcPKlSspLCwkJyeHoqIirrrqqgt8FZ3785//zF133cXEiRPJyMjgiSee4P777+/WPX76059SVVXFI488Qnl5OePHj+eDDz7oUPz8YtIoiqKc+7SBw+FwEBUVRUNDQ6fFv4QQQgghLmmBANQf7djrqXo/eJo6v0ajaxc+BZfEERA3DAzd+yusEAOd1+9lb+3eUAi1vXI7Dk94cKvX6BkZP5JJiZOYmDSRCYkTiDJF9VGLBwZFUXCXlOD46CMaP/oIz8FDbQc1GiwTJ6pD8374QwzBQtL9RcAf4NieWvb86xRHd1WHOnJFRBkZ+b1URn0vFVuMuW8b2Q0ul4uysjJycnIwmwdOu3vSY489xhtvvMHOnTv7uin9ytl+Vs43m5GeUkIIIYQQg1HAD3VHgsHTPqgMrqsPgK+l82u0BjVoOrPgeNxQ0Jt6tflC9BdNnia+rfo2NBxvV/Uu3H532DkWvYVxCePUnlCJkxiTMAaLXgLbc1H8flp27KDx72oQ5T11qu2gwYD18suJLCgg8gdXo4/vfz3LHDUtlBSfpuSz0zTXt/1MpOXFMPrKNHLGx/fbwuXi/DQ1NXHkyBGee+45fvOb3/R1cwYlCaWEEEIIIQYyvxdqy9r1egoOu6s+AGd8cA7RGdVhdvHDITG/LXyKHQI6qXEiLm0VzRV8U/kN2yu3803lN+yv209ACZ/tKtoUzYTECaGheHmxeRi08t45HwG3m+bPPqNx82aa/vEJ/pqa0DGN2Yzt+98n8pofYpsxA10/HPni9wc4urOGPf86ybG9tbTWqzfbDIy4PJmR30slJlmGLw8WS5Ys4a9//Stz5sy5oKF74twklBJCCCGEGAh8bqg51LHgeM1BCHg7v0ZvgYThHQuOR2eBTv4ZKERACXCo/hDfVH4TWk42nexwXkZkBhMSJzAxcSITkiaQY8+RmfG6wV9fT9OWLTRu/pimf/0LxekMHdNGRhJ59Uwif/hDrFdcgbabhZl7S0NVC3uLT7Hvs9M4g7WiANJHxDDye6kMGZeAziC9ogab9evXs379+r5uxqAm/xoRQgghhOhPvC1qL6dQ8BQMn2oPg+Lv/BqD9Ywhd3lt4ZNWPiQJ0crlc7Grehc7KnfwTeU37KjaQaOnMewcrUZLXkxeqBbUxMSJJEQk9FGLBy7vqVM0bv6Yxs2bcW7dCv6231/65GQir76ayIIfEHHZZWjOUWS6r/i8fsp2VLO3+BQn9rXNNmqJNJA/PZX8K1KITozowxYKMfBJKCWEEEII0Rc8zW2z27Xv/VR3hNB4kDOZosJDp9YQKipdnd5JCBGmuqWabyvVelA7Knewt3YvvoAv7ByL3sLYhLFMSJzAhIQJjEsch9Ugw6+6S1EUXHv30vTxP2j8x8e495aEHTfl5mIr+AGRPyjAPGpkv+5pVnWskZLiU+zfWoHbGfx50UBmfiwjv5dK9th4dHoJ/IW4GCSUEkIIIYToSS6HOrNd+15PVfug/ljX15ijw2s9tS6RyRI+CdGFgBLgYP1BdlTuUJeqHRxvPN7hvERLIhOSJjAhcQLjE8eTF5OHXisfiy5EwOPB+eWXNH78MU3/+ARfeXnbQY0Gy6SJRP5ALVRuzMzsu4aeB1eTl9Kvyin57DQ1J9pmIrXFmBgxLYX86SnY4/vn0EIhBjL57SuEEEIIcTG01EHV/o41nxwnur4mIr4teGofQlkTJHwS4hycXic7q3eGQqidVTtp9IYPxdOgYVjMMCYkTAgFUanW1H7dS6e/89XV0fTJFpo+/pim4uKw+lAaiwXb967ANvNqbDOuRB8X14ctPbdAQOFESS17i09TtrOKgE/tparVaxg6PoH86amkjYhBq5WfFyF6ioRSQgghhBDd0VzTsddTVSk0lXd9jS35jJpPwbW1/01xLkR/pCgKJ5pO8G3Vt6EAqrSutMOseO2H4o1PGM/YhLFEGiP7qNWDg6IoeA4eVAuV/+MTWr75BgJtX3d9YiK2mTOJvHomEZdfjtZk6sPWnp+68mZKvyin9MtymuraZilNyIwkf3oKuZclYbb2zzpXQgw2EkoJIYQQQpxJUaC5Kjx4qgwGUc7qrq+zp7cLnYZDQr66tsT0XtuFGATcfjd7a/ayo3JHKIiqcdV0OC/FmsL4xPGMTxjPhMQJ5MbkylC8iyDgduP8aitNn3xC0yef4D0ZPiOhKT+fyJkzsc2cqdaHGgATKriavRz8uoJ9X5RTUeYI7TdZ9eRNSWbE9BQSMiTAFKK3yW9sIYQQQly6FAUay9uFTyVtIVRLXdfXRWed0etpBMTngtnee20XYhApby5nR5XaA+rbym87LUiu1+oZGTuScYnjGJegLsnW5D5q8eDjraykacsWmrZsofmzz8OH5RmNRFw+FduMGUTOnIkhNbUPW3r+/P4Ax3bXsO+Lco7sqg4Nz9NoNWSOimXE5SnkjI1HZ+j/oZroHevXr+e+++6jvr6+r5tyTo8++ihvvfUWO3bsOO9rNBoNGzZsYM6cOT3Wru6SUEoIIYQQg5+iQMOJdsPt9rXNfOdu6OIiDcTmhIdP8cPVbaPMzCXEhXL73ZTUlPBt1behpdJZ2eG8OHNcqBfUuMRxjIwbiUnX/4eGDRSK349r926atnxK05YtuPbsCTuuT0zENmMGtplXYb38crQREX3T0G5SFIXq403s+/w0+7dW4Gryho7FZ9jIm5rM8CnJRNiNfdhK0VPmz5/PX/7yFwAMBgOZmZnMnTuXBx98EL1+cMUf999/P/fee+9Fveenn37KU089xbZt2zh9+nSvBFiD67sihBBCiEtbIAD1R8NrPVXtU2e/8zR1fo1G1y58GtEWQsXngkFmWhLiu1AUhdPNp9UeUMEAqqS2pEMvKJ1Gx/CY4WoPqMRxjE8YT5otTQqSX2S+ujqaiz+j6dMtNP/zX/jrwnuEmseOxXbVDCKvugpTfv6A+vo7alo4sLWC/V9VUHuqObTfYjeSNyWJvMtTiE+39WELRW+59tprKSoqwu12895777F48WIMBgMrVqzo66ZdVDabDZvt4v5MNzc3M27cOBYuXMhNN910Ue/dFQmlhBBCCDHw+H1q+FRZckb4dAB8LZ1fozVA3LCOBcfjhoJeel8IcTE4vU721OxhZ9VOdaneSXVLxzpssebY0BC8sQljGRU3igjDwOiJM5AogQCukhKaP/2Upk//Scu334YVKddGRmK94gps3/++Olte/MCafMHV7OXgtkr2f1XO6YNtvV51ei054+MZcXkKGfkxaHUyPO87UxTwOs99Xk8wRHRrRlqTyURysjq09+c//zkbNmzgnXfeYcWKFdTV1VFYWMjGjRtxu93MmDGDP/zhD+Tm5na4z5EjRxgyZAhfffUVkydPDu1fvXo1zzzzDGVlZXz66afMnDmTTZs2sWzZMvbu3cv48eMpKioiLy8vdM3atWtZuXIlx48fJycnh4ceeojbb789dFyj0bBu3To2btzIxx9/TFZWFi+99BIJCQksWrSIrVu3Mm7cOF5++WWGDh0KdBy+t3XrVh588EG++eYbvF4v48eP55lnnmHixInn/bW77rrruO666877/ItBQikhhBBC9F9+L9Qe7jjTXfUB8Ls7v0ZnbBtm1773U2wO6GQ2JSEuloAS4KjjaFgAdaDuAH7FH3aeXqMnNyY31AtqXMI40m3pA6oXzkDir6+n+fPPafrnv2j656f4q8JDQVNeHrYrv4/tyiuxjB+PxjCwfi/6PH7Kdlaz/6sKju2pIeBX60ShgbTh0QyfkszQCQmYIgbW6+r3vE54oo9qiT146jsNm7dYLNTUqBMlzJ8/nwMHDvDOO+9gt9tZtmwZs2fPZu/evRjOeC9kZ2dTUFBAUVFRWChVVFTE/Pnz0bYr8P/LX/6Sp59+moSEBO6++24WLlxIcXExABs2bKCwsJDVq1dTUFDAu+++y4IFC0hPT2fmzJmhezz22GOsWrWKVatWsWzZMm699VaGDBnCihUryMzMZOHChSxZsoT333+/09fZ2NjIvHnzePbZZ1EUhaeffprZs2dz4MABIiP7bxF/CaWEEEII0fd8bqg51DF8qjkIAW/n1+jNwfBpBCS2C5+is0An/8QR4mKrc9Wxq3oXO6t2sqt6F7uqd9HoaexwXqIlkXGJ4xgbP5axCWPJj8vHopehsD1F8ftx7dlD0z//SfM//0XLzp3hvaEiIoiYPg3blVdiu/JKDMkDrzh8IKBwsrSO/V+Vc+ibKryutuAzPsPG8MuSyb0sEVuMuQ9bKfobRVHYvHkzH374Iffee28ojCouLmb69OkAvPLKK2RkZPDWW2/xk5/8pMM9Fi1axN13382qVaswmUxs376dXbt28fbbb4ed9/jjjzNjxgwAli9fzvXXX4/L5cJsNrNy5Urmz5/PPffcA8DSpUv54osvWLlyZVgotWDBAm6++WYAli1bxrRp03j44YeZNWsWAIWFhSxYsKDL13v11VeHPX7xxReJjo5my5Yt3HDDDd398vUa+RebEEIIIXqPt0UNmir3hRccrz0MZ/SuCDFYzxhyF9yOzgStrnfbL8QlwuP3sK92X1gIdbzxeIfzjFojo+JHhQKosQljZUa8XuCrqqKpuJjmf/6L5uJi/GfMFGbKzcX6/e9j+/73sEyahNY48Ip6KwGF04cbOLi1goPfVNHi8ISORcaaGT4lieFTkolNlYkneoUhQu2x1FfP3Q3vvvsuNpsNr9dLIBDg1ltv5dFHH2Xz5s3o9XqmTp0aOjcuLo68vDxKSko6vdecOXNYvHgxGzZs4JZbbmH9+vXMnDmT7OzssPPGjh0b2k5JSQGgsrKSzMxMSkpKuOuuu8LOv+KKK1izZk2X90hKSgJgzJgxYftcLhcOhwO7veNsvxUVFTz00EN88sknVFZW4vf7cTqdHDt27Gxfrj4noZQQQgghLj5Ps1pc/MyC43VHQAl0fo3JHl7rqXXbngZaqQciRE9RFIWjjqPsqt7F7urd7Krexb7afXg76aWYbc9mTPwYxiaMZUzCGIbHDMeglWFSPS3g8dCyfTvNxcU0/asY9xkfoLWRkVinT8f2/e9h/d73BmRvKFB/FiuPNnLw6woObqukqa5tmLbJqmfYpCSGT0kiZUgUGq0M/+xVGs2AmXl25syZrF27FqPRSGpq6neadc9oNDJ37lyKioq46aabePXVVzuESUDY0L/WocmBQBf/3ulCZ/fozn3nzZtHTU0Na9asISsrC5PJxLRp0/B4PJ2e31/0Sij1xz/+kaeeeory8nLGjRvHs88+y5QpU8553WuvvcbPfvYzbrzxRt56662eb6gQQgghusflCIZP+8LDp/qz/FXOHA2J+R1rPkUmd6uQqRDiwtS01LC7ejc7q3eyu3o3u6t34/A4OpwXbYpmTPwYxiSMYWz8WEbHjybKFNUHLb70KIqC59AhNYQqLsa59WuUlvBJHMyjR2P9/vewff/7WMaORTNAp7tXFIWak80c/LqCA19X4Kh2hY4ZzTqGjE9g2GVJpI+IQScFy8V5sFqtDBs2rMP+/Px8fD4fX375ZWj4Xk1NDaWlpYwcObLL+y1atIjRo0fz/PPP4/P5uj0rXX5+PsXFxcybNy+0r7i4+KzPeSGKi4t5/vnnmT17NgDHjx+nurrjRBP9TY//5nr99ddZunQp69atY+rUqaxevZpZs2ZRWlpKYmJil9cdOXKE+++/n+9///s93UQhhBBCnEtLHVTth6qS8N5PjpNdX2NNUMOm+OHhIZQ1QcInIXqJ0+tkb81eNXyq2c2uql2cau44BMeoNZIfl6+GUMElPVKKkfcmX10dzZ99RnPxZzQXF+OrqAg7rkuIxzb9CqzfuwLr9Ono4+L6qKUXR82pJg5tr+Lg1xXUlbfN6qY3askeG0/u5CQyR8WiN8gwbXFx5ObmcuONN3LnnXfywgsvEBkZyfLly0lLS+PGG2/s8rr8/Hwuv/xyli1bxsKFC7FYulcj74EHHuDmm29mwoQJFBQUsHHjRt588002bdr0XV9SmNzcXF5++WUmT56Mw+HggQce6HZbm5qaOHjwYOhxWVkZO3bsIDY2lszMzIva3lY9HkqtWrWKO++8M1SQa926dfztb3/jpZdeYvny5Z1e4/f7ue222/j1r3/NP//5T+rPGCMthBBCiB7irIXKko4Fx5vKu77Glhxe8ykxH+LzwDqwPzAJMdB4/V721+9nd5UaQO2u3s3hhsMEzhgyq0HDkKghjI4fzZj4MYxOGM3w6OEYZHbKXhVwudQheZ9/TvNnn+PauxcUJXRcYzIRMXky1iuuwHrFFZiG5w7okFBRFGpPNXNwWyWHtleGBVFavYasUXHkXpZE9ph4DCYJokTPKCoqorCwkBtuuAGPx8OVV17Je++912HmvTPdcccdfPbZZyxcuLDbzzlnzhzWrFnDypUrKSwsJCcnh6KiIq666qoLfBWd+/Of/8xdd93FxIkTycjI4IknnuD+++/v1j2+/vrrsOLrS5cuBdShgevXr7+YzQ3RKEq733wXmcfjISIigv/93/9lzpw5of3z5s2jvr6+Q8X6Vr/61a/YuXMnGzZsYP78+dTX13c5fM/tduN2t401djgcZGRk0NDQ0GnxLyGEEOKSpyjQXNUxeKrap+7vij29Xfg0HBLy1bUlpvfaLoQAwB/wc9RxNBQ+7anew77afXgCHWuHJEUkMTp+dCiEGhk3kkhj/50efLBS/H5cJfto/vwzmj/7jJZt21HOqPViGj4c6/e+h/WK6URMmoTWPLBnk1OH5jUFg6gq6ivaBVE6DRkjYxk2MZGc8QmYLANz+OFg5HK5KCsrIycnB/MA/xm8WB577DHeeOMNdu7c2ddN6VfO9rPicDiIioo6ZzbTo+/86upq/H5/qHJ8q6SkJPbt29fpNf/617/485//zI4dO87rOZ588kl+/etff9emCiGEEIOPokDj6c7Dp5a6rq+LzuxYcDx+OJjljz1C9AVFUTjRdII91XvYU7OH3dW72VuzF6fP2eFcu9EeCqBGx6nrhIiEPmi1UBQF7/HjNH/+Bc2ffYbziy/wNzSEnaNPTMQ6fTrW6dOIuPxyDGcpbzJQKIpC9fEmDm6v5NC2Shqq2mphafUaMkfGMWxiAtnjJIgS/V9TUxNHjhzhueee4ze/+U1fN2dQ6le/BRobG7n99tv505/+RHx8/Hlds2LFilCXMmjrKSWEEEJcMgIBcJxoFzy1hk+l4O5YvFilgdicM8KnPDV8GiCz6wgxGCmKQoWzgj01e0Ih1J6aPTS4Gzqca9FbyI/NZ2TcSKkD1U94KypxfvUlzZ9/gfOLL/CeCq/fpbVaiZg6Feu0aVinT8M4ZMig+H4FAgrlhxo4/E0Vh3dU0VjbVqxcp9eSOSqWYZMSyR4Tj1GCKDGALFmyhL/+9a/MmTPngobuiXPr0d8I8fHx6HQ6Ks4o0ldRUUFyJ9OUHjp0iCNHjvCjH/0otK91ukO9Xk9paSlDhw4Nu8ZkMmEymXqg9UIIIUQ/EwhA/dGOvZ6qSsHb3Pk1Gh3EDW1XbDwYPsUNA0P3il8KIS6+Smcle2v2hkKovTV7qXHVdDjPoDWQF5PHqPhRjIobxej40eRE5aDXygf8vuSvr6f5q69wfvElzV98gefw4fAT9Hos48ZhnT4N6/TpWMaMGbCz5J3J7w1worSOwzuqKPu2ipZGb+iY3qAlc3QcwyYmkjUmDqN5cLxmcelZv359j9VSEqoe/e1gNBqZNGkSmzdvDtWUCgQCbN68mSVLlnQ4f8SIEezatSts30MPPURjYyNr1qyRHlBCCCEuDQE/1B1p6/VUGVxXHwBfS+fXaA1q0NS+11PCCDWQ0ssfb4ToD6pbqkMB1N5qdV3V0rGOm06jY1j0MEbGjWR0/GhGxY+SQuT9hL+piZZt22j+8iucX3yBq6QkrDg5Gg3mkSOJuHwq1sunETFpItqIiL5r8EXmcfk4tqeWwzuqOLqrGo/LHzpmitCTPSaeIeMTyBgVi8EoxcqFEOfW45H10qVLmTdvHpMnT2bKlCmsXr2a5ubm0Gx8c+fOJS0tjSeffBKz2czo0aPDro+OjgbosF8IIYQY8PxeqD3csddT9QHwuzu/RmdUez0l5Kkz3CUGaz7FDgH5wCpEv1HlrGJvzd6wpbKlssN5Wo2WIVFDGBU3KtQLanjMcMx6KS7cH/ibmmn5ZjvOL7+k+autuPbsAb8/7BzjsKFYp16uBlFTpqCLiuqj1vaM5gY3R3ZWc2RnNcf31eH3ts3mGGE3MmR8AkPGJ5CaF41Op+3DlgohBqIeD6V++tOfUlVVxSOPPEJ5eTnjx4/ngw8+CBU/P3bsGFqt/PISQggxiPncUHOoXb2nYPhUcxACvs6v0VuCM9ydUXA8Ogt0MgxCiP5CURSqWjoGUJ31gNKgIScqJxRAjYwbSV5MHhGGwdOTZqALOJ04t3+D88svcX71FS27d3cIoQwZGURMuUztCTV1yqAoTt6eoijUnmqmLBhEVZSF1ya0J1gYOj6BIRMSSMq2o9EO/JpYQoi+o1GU9v1NB77znXZQCCGEuOi8LWovpzMLjtceBsXf+TVGW8chd/HD1fBJ/mgjRL+iKAqnmk9RUlPC3pq9lNSWUFJT0mkNKK1GS449h5FxI0PLiNgREkD1M6GeUF9txbl1qxpC+cL/WGBISyNi6lQ1iJoyBUNqah+1tucE/AFOHWzgyLfVlO2swlHtCjuemG0nZ1w8OWPjiU21Dori7KJrLpeLsrIycnJyMJul16bo2tl+Vs43m5E/tQohhBDd5WmG6v0dC47XHQEl0Pk1pqh2PZ9GtIVQUekg/7gXot8JKAGOOY6Fgqe9tXspqSnB4ek4o2XrELzW8Kl1CJ4EUP2Pv6EB57btOLeqIZRr7151Eol29CkpWKdMCQZRUzCmp/VRa3uWq9nLsT01HNlVw7E9NbidbWGcTq8lIz+G7LHxZI+NxxoltQmFED1DQikhhBCiKy5HMHzaFx4+1R/r+hpzdHCWuzxIyG/r/RSZLOGTEP2U1+/lUMMhSmpK2Fe7j5LaEkprS3H6nB3O1Wv15EbnMjJuJPmx+eTH5ZMbk4tFL7NZ9ke+mhqc27bh3Po1zq1bcZeWhhcmBwzp6URMnkzEZZcRMeUyDOnpg7InUOuwvCO7qjm6u4byQw1hXwqzzUD2WLU3VEZ+LAaTFCoXQvQ8CaWEEEKIljqo2t+x4LjjRNfXWBPahtoltgufrAkSPgnRjzm9TvbX7aekNhhA1ZRwsP4g3oC3w7lmnZnhMcPJj8sPhVDDoofJLHj9lKIoeE+exPn117Rs24bz6214yso6nGfMzibismAIddllGFJS+qC1vcPn8XOitI6ju2o4sruaptrwSTTi0qxkjY4ne0wcSUOi0Ep9KHGJW79+Pffddx/19fV93ZRzevTRR3nrrbfYsWPHeV+j0WjYsGEDc+bM6bF2dZeEUkIIIS4dzTUdez1VlUJTedfX2JLDaz4l5quz3lnjeq/dQogLUt1Szb7afaGltLaUo46jKHQsqRppjCQ/Np8RsSMYETuCkXEjybJnodfKP5f7KyUQwH3gIM5tX9Py9Tac27bhq6jocJ4pdxiWyZOxXnYZlsmTB11h8jM1VDk5uruWY3tqOFEaPluezqAlfUQM2aPjyBoTT2Ss1AsSg8v8+fP5y1/+AoDBYCAzM5O5c+fy4IMPotcPrt/n999/P/fee+9FveeTTz7Jm2++yb59+7BYLEyfPp3f/e535OXlXdTnaW9wfVeEEEIIRYHmqrbAqbKkLYByVnd9nT39jILjwcUS03ttF0JcEH/Az/HG4+yr28e+mn3sq1MDqOqWzt/zCZYERsSOID8uPxREpdnSBuWQrcEk4HLh2r0b57bttGzfjnPHDgINDeEn6fWYR40kYtJkIiZPwjJhAvqYwf173Ovxc7K0jmN71CCqoaol7LgtxkTWGLU3VFpeDAajDMsTg9u1115LUVERbreb9957j8WLF2MwGFixYkVfN+2istls2Gy2i3rPLVu2sHjxYi677DJ8Ph8PPvgg11xzDXv37sVqtV7U52oloZQQQoiBSVGgsbxdz6d2vZ9a6rq+LioTEtvNdNc6BM8sM7YKMRC0Dr/bX7df7f1UV8qBugO0+Fo6nKtBQ5Y9i/zYfPJi88iPzWd47HDiLfF90HLRXb6aGpzbt9Oy/Rtatm+nZe9e8IYPs9RERBAxfhyWSZOImDQZy7ixaC2Du76XoijUVzg5uruGY3trObW/Hr+vrTeUVqshZVgUmaPiyBwVR1yazJYnvjtFUTr9PdsbLHpLt36GTSYTycnJAPz85z9nw4YNvPPOO6xYsYK6ujoKCwvZuHEjbrebGTNm8Ic//IHc3NwO9zly5AhDhgzhq6++YvLkyaH9q1ev5plnnqGsrIxPP/2UmTNnsmnTJpYtW8bevXsZP348RUVFYb2L1q5dy8qVKzl+/Dg5OTk89NBD3H777aHjGo2GdevWsXHjRj7++GOysrJ46aWXSEhIYNGiRWzdupVx48bx8ssvM3ToUKDj8L2tW7fy4IMP8s033+D1ehk/fjzPPPMMEydOPO+v3QcffBD2eP369SQmJrJt2zauvPLK875Pd0goJYQQon9TFGg40W64XWv4VAruhi4u0kBMdnitp4Q8NXwy9sxfeYQQF5eiKFQ4K9hft5/S2lL21e5jf93+LoffmXQmcqNzGRE3ghExIxgRN4Lc6FyZAW+AUAIBPIcO4dyxIxRCeY4e7XCePiEBy8SJREycgGXiRMwjRqAxDP4aX65mLyf21XF8Xy3H99TSWOsKO26LNZEVDKHS82IwWuRjnri4WnwtTH11ap8895e3fvmdfpdbLBZqamoAdXjfgQMHeOedd7Db7SxbtozZs2ezd+9eDGf8LsnOzqagoICioqKwUKqoqIj58+ej1WpD+375y1/y9NNPk5CQwN13383ChQspLi4GYMOGDRQWFrJ69WoKCgp49913WbBgAenp6cycOTN0j8cee4xVq1axatUqli1bxq233sqQIUNYsWIFmZmZLFy4kCVLlvD+++93+jobGxuZN28ezz77LIqi8PTTTzN79mwOHDhAZGTkBX3tGoK9UWNjYy/o+vMhv62EEEL0D4EA1B8Nr/VUtU+d/c7T1Pk1Gh3EDgnv9ZSQB/G5YBjcfykXYjBx+90crD/I/lq1B1RpXSn76/bT0EXwHG+JJy82j7yYPEbEjiAvJo9Me6bUfxpA/E1NtHz7LS07dtDyzQ5avv2WQGNj+EkaDaZhw8JCqME6M96Z/P4AFYcdHC+p5XhJLZVHHGEz5Wn1GtJyo0O9oWKSIy6Jr4sQ3aEoCps3b+bDDz/k3nvvDYVRxcXFTJ8+HYBXXnmFjIwM3nrrLX7yk590uMeiRYu4++67WbVqFSaTie3bt7Nr1y7efvvtsPMef/xxZsyYAcDy5cu5/vrrcblcmM1mVq5cyfz587nnnnsAWLp0KV988QUrV64MC6UWLFjAzTffDMCyZcuYNm0aDz/8MLNmzQKgsLCQBQsWdPl6r7766rDHL774ItHR0WzZsoUbbrihu18+AoEA9913H1dccQWjR4/u9vXnS/7PLYQQonf5fVB3pOOQu+oD0FW3cK0B4oadUfNpBMQNBb2pV5svhLhw7Xs/7a/bHwqhjjiO4Ff8Hc7XaXTkROWQG5OrFiCPGSHD7wYgRVHwHj2q9oL6ZgctO3bg3r+fsJQF0FgsWMaMwTJhghpCjR+PLiqqj1rduxRFoaGyhWN71RDqZGkdXnf4eyImOYKMkbFk5MeSNjwGg0lqQ4neY9Fb+PLWL/vsubvj3XffxWaz4fV6CQQC3HrrrTz66KNs3rwZvV7P1KltPb7i4uLIy8ujpKSk03vNmTOHxYsXs2HDBm655RbWr1/PzJkzyc7ODjtv7Nixoe2U4IyelZWVZGZmUlJSwl133RV2/hVXXMGaNWu6vEdSUhIAY8aMCdvncrlwOBzY7R3LTlRUVPDQQw/xySefUFlZid/vx+l0cuzYsbN9ubq0ePFidu/ezb/+9a8Luv58SSglhBCiZ/i9UHu440x31QfA7+78Gp1RHWKXkAcJ+ZAwXF3H5oBMwS7EgOL0OjlUf6gtgAouDo+j0/OjTFHkxeQxPGY4ebHqemj0UEw6CZ4HGr/DQcuuXWpPqG+/xfXtTvydTK9uSEvDMmEClgnjsYwfjzkvD80gmx3rbJrr3ZworePEvlpO7KujqS78/41mm4GM/Fgy8mPIyI/FFiMz5Ym+o9FoBsxw6JkzZ7J27VqMRiOpqanfadY9o9HI3LlzKSoq4qabbuLVV1/tECYBYUP/WnstBgKBDuedTWf36M59582bR01NDWvWrCErKwuTycS0adPweDzdagfAkiVLePfdd/n0009JT0/v9vXdcen81hdCCNEzfG6oOXRG+LQPag5CwNf5NXqzGj6F1XwaAdFZoJP/NQkxkPgDfk40neBA3QF1qT/A/rr9HHMc67T2U6j3U3Quw2OHqyFUTB6JEYky/GgAUvx+3AcP0rLj21AI5Tl0qMN5GoMB8+jRagg1fhyW8eMxJCb2QYv7jqvZy6n99WoIVVpHXbkz7LhWryFlaDSZwd5Q8ek2NFp5TwjRXVarlWHDhnXYn5+fj8/n48svvwwN36upqaG0tJSRI0d2eb9FixYxevRonn/+eXw+HzfddFO32pOfn09xcTHz5s0L7SsuLj7rc16I4uJinn/+eWbPng3A8ePHqa4+y8zTnVAUhXvvvZcNGzbwySefkJOTc1Hb2Bn5l78QQojz421RezmdWXC89jB0MuwGAIO145C7hDyIzgStDDsQYiBRFIUaVw376/aHBVCH6w/j8rs6vSbOHMfwGDV4ag2ghkQNwagz9nLrxcWgKAq+8nJavt1Jy66duHbuomXPHhSns8O5howMLOPGqcv4cWovKOOl9X33uHyUH27gxL46Tuyro+p4I2E5rQYSMyNJy4shfUQMKcOiMRjl/41C9JTc3FxuvPFG7rzzTl544QUiIyNZvnw5aWlp3HjjjV1el5+fz+WXX86yZctYuHAhlm7O8PnAAw9w8803M2HCBAoKCti4cSNvvvkmmzZt+q4vKUxubi4vv/wykydPxuFw8MADD3S7rYsXL+bVV1/l7bffJjIykvLycgCioqK6fa/zJaGUEEKIcJ5mtbh4VSlUlrSFUHVHoJNeDwCY7GcUGw+GT/Y0aDcziRBiYGjyNHGw/mBoaQ2h6tx1nZ5v0pkYGj2U3OhccmNyGR4znNyYXKn9NMC1DsNz7dpFy85dtOzaib+q41/dtVYr5rFj1ABq7Dgs48aij4vrgxb3La/bz+lD9ZzcX8+p/XVUHmkkEAj//2ZMcgTpeTGkj4gldXg0ZqsMTReiNxUVFVFYWMgNN9yAx+Phyiuv5L333usw896Z7rjjDj777DMWLlzY7eecM2cOa9asYeXKlRQWFpKTk0NRURFXXXXVBb6Kzv35z3/mrrvuYuLEiWRkZPDEE09w//33d+sea9euBejQttYZB3uCRlGULj5hDEwOh4OoqCgaGho6Lf4lhBAiyOUIhk9nFByvP0sxREtMsNbTGb2fIpNBht0IMeC4/W7KGso4UHcgLIA63Xy60/M1aMi0Z4bCp9yYXHKjc8mIzEAnvR8HtEBLC66Sfbh276Zl9y5cO3fhOXKk44k6Haa84VjGjMUydgzmMWMwDR2KRnfpff+9bj/lhxo4ub+Ok/vrqTzi6BBC2WJNpA9Xe0Kl5cVii5EaaaL/c7lclJWVkZOTg9kstcwAHnvsMd544w127tzZ103pV872s3K+2Yz0lBJCiMGupQ6q9kNVSXjBccfJrq+xJrSFTvF5kBjs/WRNkPBJiAHIG/BytOEoBxsOcrDuIIfqD3Gw/iDHGo8RUDovmJpoSWRYzDCGRQ8LhU9Dood0exYk0f8oHg+u/Qdw7d5Fy+7duHbtxn3wIPg7DsU2ZGaqM+KNHYN5zFjM+SPQ9tAQjv7O3eKj/FADpw7Uc+pAFyFUjIm0vBjShkeTNjwGe/yl+bUSYrBoamriyJEjPPfcc/zmN7/p6+YMShJKCSHEYNFc07HXU1UpNJV3fY0tObzXU2K+GkJZL71hF0IMBr6Aj+ONx0Oh08F6NYA64jiCr4uJB+xGe1jw1BpERZmiern1oicoXi/ugwdx7dlDy549uHbvwb1vH4rX2+FcXUI8ltFjMI8ehWX0aMxjx6KPiemDVvcPToeH0wfrOXVQDaFqTjRx5hiTM0OoyDizFOwXYhBZsmQJf/3rX5kzZ84FDd0T5yahlBBCDCSKAs1VHYOnyhJwnmV2DXt6JwXHh6vD8YQQA4434A2FT4fqD3G4/jAHGw5ypOEI3kDHsAEgQh/BsOhhDIsZxtCooaHwKcGSIB+iBwnF41FnwtuzB9eePbj27MVdWorSyXTg2qgoNXgaPRrLmNGYx4xBn3jpzoCoKAqNNa5gCKX2hqqv6FjA3Z5gIXVYFCnDoknPkxBKiMFu/fr1rF+/vq+bMahJKCWEEP2RokDj6Y7hU9U+dTheV6Iyg0PtWoOnfIjPBbPU2BNiIPL6vRx1HOVQwyEONxwOhVBn6/lk0VvIicpRA6joYaEC5MnWZPnwPIgE3G7c+/fj2luCa+9eXHv2qAFUJz2gtJGRmEeOxDxqFJbRozCPGYMhPf2S/nnw+wPUnGji9MEGTh9qoPxQPc0NHcO72FQrqbnRpA6LJmVYtNSEEkKIi0xCKSGE6EuBADhOtAueWsOnUnA7urhIA7E5Z/R6yoP44WC09mrzhRAXR4uvhSMNR9Twqf5wKIA63ngcv9Kxzg+o4dPQqKEMiR7C0OihDIsexpCoIaTaUtFqZNbLwcTf2IirpAR3SUkohHIfPtxpDSit3Y551Egso0aFgihDRgaaS3wmVHeLj/LDDZQfauD0oXoqyhz4POH11LRaDfEZNjWEyo0mZWg0ZpvMjieEED1JQikhhOgNgQDUHz0jfNqnFiD3Nnd+jUYHcUPbFRsPznoXNwwMUjhViIGowd1AWUMZhxsOh8Knww2HOdV0CoXOJ0S2Gqyh8GlIVFsAlWxNlvBpkFEUBV9lJe59+9SZ8ErUAMp7/Hin5+tiYtTgaWQ+5lGj1ADqEu8BBaAEFOoqnFSUNVB+2EFFWQM1p5o58y1mitCTPCSK5CFRpAyNIjHHjsF46c0iKIQQfUlCKSGEuJgCfqg7ogZOle1mu6s+AL6Wzq/RGtSg6cyaT3FDQS/DBIQYaBRFocJZweH6w5Q5ysLCp1pXbZfXRZmi2no+tVsnRly6dX4GM8XrxV1WpgZQ+0px7yvBVbIPf13nQ7T1qSlqAJWfjzlfDaL0SUnyswG4nV4qyhyUlzmoONxAxREHbmfH4a32BAspQ9UAKnloFLHJVjRa+foJIURfklBKCCEuhN8LtYc71nyqPgB+d+fX6IzqELszw6fYIaCT4QFCDDRuv5ujjqOUNZSFLUccR2jpKoQGkiKSGBI1JNTzKScqhyFRQ4g1x0rAMEj56+txle7HXVqKq3Qf7n2luA8c6LQAOTodpiE5mPJGYM4fgXnkSEwjRlzSs+C1F/AHqDnVTOURRyiIqjvdscex3qAlIStS7QmVE0XSEDvWKPlDjxBC9DcSSgkhxNn43FBzsGP4VHMQuigyjN6izmwXVvNpBERngU5+7QoxkCiKQo2rJhQ2HWk4EgqfTjad7HLInV6jJz0yPSx8GhI1hOyobKwGqf02WCk+H56ysrYAan8p7n2l+CoqOj1fa7ViGjEC84gRmEbkYR6Rjyl3GFqzuZdb3j+1zohXccRBxREHlUccVB1txOcNdDjXHm8ODcVLyrETl25Dp5PhrUII0d/JpyMhhADwtqi9nM4sOF57GLooMozR1rHXU0KeOgPeJV5QVoiBxuVzcdRxNBQ8tV83eZu6vC7SEElOdA459hxyotqW9Mh0DFrpATlYhWo/7d+Pe/8BdRa8A/vxHDjY6ex3AIb0dEx5eZiG52IekY85f4Ra/0n+fxHidHioOtZI5VG1F1TFEQeupo5fT6NZR2K2ncQsO8lD7CTlRBFhN/ZBi4UQg8369eu57777qK+v7+umnNOjjz7KW2+9xY4dO877Go1Gw4YNG5gzZ06Ptau7eiWU+uMf/8hTTz1FeXk548aN49lnn2XKlCmdnvunP/2J//f//h+7d+8GYNKkSTzxxBNdni+EEN3iaYbq/eG9nqr2qXWglI5/eQXAFBUMnYZDQr4aPiWOAHsayFAbIQYMf8BPubM8FDYddRxVg6iGI5xuPt1lrycNGlJtqeRE5ZBtzw4Ln+LMcTLkbpDzOxy4DxxQl/37ce3fj/vAQQINDZ2er42IUMOnvOGY8/LU7dxcdJGRvdzy/s3V5KXymIPKo41UHVWDqKa6jsPftToN8ek2krLtJObYScq2E50YIbWghBCdmj9/Pn/5y18AMBgMZGZmMnfuXB588EH0+sHVJ+f+++/n3nvvvaj3XLt2LWvXruXIkSMAjBo1ikceeYTrrrvuoj5Pez3+XXn99ddZunQp69atY+rUqaxevZpZs2ZRWlpKYmJih/M/+eQTfvaznzF9+nTMZjO/+93vuOaaa9izZw9paWk93VwhxGDhcgTDp33h4VP9sa6vscQEQ6czej9FJkv4JMQAoSgKta7aUOAUCp4cRzjmOIYn0EkNn6BIYyQ59hyyo7LJtmeH1pn2TEw6qUUz2AWam3EfOoT7wEHcBw+qIdTBg/jKyzu/QKfDmJ2NKTdX7f00fDimvDwMaWnS++kMriYvVccbQ72gKo820ljj6niiBmKSIkjIilRDqGw7CemR6Azy9RRCnL9rr72WoqIi3G437733HosXL8ZgMLBixYq+btpFZbPZsNlsF/We6enp/Pa3vyU3NxdFUfjLX/7CjTfeyDfffMOoUaMu6nO10iiK0vmfBS+SqVOnctlll/Hcc88BEAgEyMjI4N5772X58uXnvN7v9xMTE8Nzzz3H3LlzOxx3u9243W1/VXE4HGRkZNDQ0IDdbr94L0QI0T+11HXs9VRVCo6TXV9jTWgLneLz1F5PCSPU/RI+CTEgODwOjjmOhcKm1vVRx9GzDrczaA1kRmaSZc8iKyqLbHu2um3Pkl5Pl4hASwvuQ4dxHzyA5+DBUAjlPdn1/zf0ycltwdPw4ZhyczEOGYLWJGFle4qi0Fzvoep4I9XBEKrqeCNNtZ1PABKVaCExy05iViQJmZEkZERitAyungxCDEQul4uysjJycnIwB2vcKYqC0tL1JB49SWOxnPf/n+fPn099fT1vvfVWaN8111xDY2Mjn3/+OXV1dRQWFrJx40bcbjczZszgD3/4A7m5uUD48L0jR44wZMgQvvrqKyZPnhy63+rVq3nmmWcoKyvj008/ZebMmWzatIlly5axd+9exo8fT1FREXl5eaFr1q5dy8qVKzl+/Dg5OTk89NBD3H777W2vUaNh3bp1bNy4kY8//pisrCxeeuklEhISWLRoEVu3bmXcuHG8/PLLDB06FOg4fG/r1q08+OCDfPPNN3i9XsaPH88zzzzDxIkTw56nu8P3YmNjeeqpp7jjjjs6HOvsZ6WVw+EgKirqnNlMj/7W93g8bNu2LSyR1Gq1FBQU8Pnnn5/XPZxOJ16vl9jY2E6PP/nkk/z617++KO0VQvRjzTUdez1VlUJTF3/BBohM6djrKT4PrHG9124hxAVr9DRyzHGMY41q2HS88ThHHUc55jhGnbuuy+s0aEixppBpV8On1l5PWfYsUq2p6LS6XnwVoq/4GxvxHDqk9n46dBj3oYN4Dh7Ce+oUdPE3WV18PKZhw9QlNxdT7jBMQ4eii4rq5db3f0pAoaGqJRhANakh1PFGWho7r6llT7CQmBlJQlYkiVl2EjJsmCKk7poQA4XS0kLpxEl98tx527ehiYi44OstFgs1NTWAGlodOHCAd955B7vdzrJly5g9ezZ79+7FYAj/nZSdnU1BQQFFRUVhoVRRURHz589H265X7C9/+UuefvppEhISuPvuu1m4cCHFxcUAbNiwgcLCQlavXk1BQQHvvvsuCxYsID09nZkzZ4bu8dhjj7Fq1SpWrVrFsmXLuPXWWxkyZAgrVqwgMzOThQsXsmTJEt5///1OX2djYyPz5s3j2WefRVEUnn76aWbPns2BAweIvIAh5H6/nzfeeIPm5mamTZvW7evPV4+GUtXV1fj9fpKSksL2JyUlsW/fvvO6x7Jly0hNTaWgoKDT4ytWrGDp0qWhx609pYQQA5CiQHOVGjhVnhFAOau7vs6e3knB8eHqcDwhRL/W4G7geOPxUPjUGjwdbzxOrav2rNfGW+JDvZxCS2QWGfYMGW53iVAUBX91Ne7DZXjKDuM+dBjPoYO4Dx7CV1nZ5XW6mJhg8DQM47BhmHNzMQ4bhj5G/r/RGY/LR+2pZqpPqOFT9Ykmak4143N3nAhEo9UQkxwR6vkUn2EjPiMSk/SAEkL0MkVR2Lx5Mx9++CH33ntvKIwqLi5m+vTpALzyyitkZGTw1ltv8ZOf/KTDPRYtWsTdd9/NqlWrMJlMbN++nV27dvH222+Hnff4448zY8YMAJYvX87111+Py+XCbDazcuVK5s+fzz333APA0qVL+eKLL1i5cmVYKLVgwQJuvvlmQM1Bpk2bxsMPP8ysWbMAKCwsZMGCBV2+3quvvjrs8Ysvvkh0dDRbtmzhhhtuOO+v265du5g2bRoulwubzcaGDRsYOXLkeV/fXf36/w6//e1vee211/jkk086dAVrZTKZMEnXaSEGFkWBxtMdez1V7VOH43UlOjN8uF3CCIgfDmYZqitEf6UoCjWuGo43Hg8PnxzHOd50nAZ358WiW8WZ48i0Z4aG3GXYM0LbVoO1l16F6GuKz4fn+HE8ZWW4Dx3Cc7gMz+HDuMvKCDgcXV6nT0zENGwoxqFqjyfT0CEYhw5F30UP/Eudoig01rioOdVMzQk1fKo+0URDVQudzQOgM2iJS7USHwygEjIiiUuzojdKb0QhBhuNxULe9m199tzd8e6772Kz2fB6vQQCAW699VYeffRRNm/ejF6vZ+rUqaFz4+LiyMvLo6SkpNN7zZkzh8WLF7NhwwZuueUW1q9fz8yZM8nOzg47b+zYsaHtlJQUACorK8nMzKSkpIS77ror7PwrrriCNWvWdHmP1o49Y8aMCdvncrlwOBydDoerqKjgoYce4pNPPqGyshK/34/T6eTYsbPU1O1EXl4eO3bsoKGhgf/93/9l3rx5bNmypceCqR4NpeLj49HpdFRUVITtr6ioIDk5+azXrly5kt/+9rds2rQp7JsjhBhAFAUaTrQLnkqC26Xg7upDhAZic87o9ZSnhk9G+QAqRH/kC/g43Xya443HOdF4IhRAtT52+pxnvT7eEk9mZCbpkelk2bPUYXeRWWREZmAzXtwCnqJ/89XV4Sk7gqesDM+RMtxlZerjY8fA2/mwMLRaDOnpmHJyMA4ZgmnYUExDh2IcOlRmvDsLV7OX2lNN1JxspvpkE7Un1d5PXlfH3k8AEVFG4tNtxKdHEp9uIy7dRnSiBa1OipALcSnQaDTfaQhdb5o5cyZr167FaDSSmpr6nWbdMxqNzJ07l6KiIm666SZeffXVDmESEDb0r7X+VSDQxczeXejsHt2577x586ipqWHNmjVkZWVhMpmYNm0aHk/Xk7x0xmg0MmzYMAAmTZrE1q1bWbNmDS+88EK37nO+ejSUMhqNTJo0ic2bN4cKaQUCATZv3sySJUu6vO73v/89jz/+OB9++GHY2E0hRD8VCED90Y69nqr3g6eLgsMaHcQOCQZPeeqsd4kjIG4YGLr31xAhRM9r8jRxsukkJxpPcKIpPHg63XQan+Lr8loNGpKtyWRGZpJhzyAjUu3tlBGpbkcYBsY/csXFEXC78R47hvvIkbYAKrj4G7ruOacxmzEOycGUM0RdDx2KMWcIxuwsKTh+Fl6Pn7rTzdSebqb2VDM1J9Ugqrm+8+LjWp2GmGQrcWnWsAAqwm7s5ZYLIcSFsVqtoVClvfz8fHw+H19++WVo+F5NTQ2lpaVn7QW0aNEiRo8ezfPPP4/P5+Omm27qVnvy8/MpLi5m3rx5oX3FxcUXvedRcXExzz//PLNnzwbg+PHjVFefpQTKeQoEAmGTy11sPT58b+nSpcybN4/JkyczZcoUVq9eTXNzc2gs5Ny5c0lLS+PJJ58E4He/+x2PPPIIr776KtnZ2ZQHp+HtiekOhRDd5PdB3ZGOBcerD4Cvi9k4tAY1aDqz5lPcUNDLhwgh+gtfwEeFs4KTjSc50XRCDZ+CAdSJxhNnLSwOYNQaSYtMCwVNrUt6ZDpptjSp8XSJUbxevCdP4jl6FM+RI23rI0fxnj7dZaFxAH1KCqacbIzZORizszHm5GAakoM+JQWNVnrldMXn9VNX7qT2lBo+qSFUE44aV6dD7wAiY83EpVmJTbMRl2YlLtVGdHIEOun9JIQYhHJzc7nxxhu58847eeGFF4iMjGT58uWkpaVx4403dnldfn4+l19+OcuWLWPhwoVYujmc8IEHHuDmm29mwoQJFBQUsHHjRt588002bdr0XV9SmNzcXF5++WUmT56Mw+HggQce6HZbV6xYwXXXXUdmZiaNjY28+uqrfPLJJ3z44YcXta3t9Xgo9dOf/pSqqioeeeQRysvLGT9+PB988EFojOSxY8fCqtavXbsWj8fDf/zHf4Td51e/+hWPPvpoTzdXCAHg90Lt4bbgqTI47K7mAPi76P6pM0F8blutp9YeULFDQCez6wjR1xRFodZVy8mmk6EeTyeb1ADqZONJypvLz9rbCSDGFEN6ZLq62NJDoVNGZAaJEYloNfJB9lKieL14T53Cc+wYnqPH8Bw7iufoUbxHj+E5cQJ8Xf88aW02jFlZGHNyMOZkq0PvcnIwZmWhHSDDQ/qKx+WjrtxJXXkzdafVde3pZhxVLV1mfWabgdgUK7GpVuLSbMSlqkGUFB8XQlxqioqKKCws5IYbbsDj8XDllVfy3nvvdZh570x33HEHn332GQsXLuz2c86ZM4c1a9awcuVKCgsLycnJoaioiKuuuuoCX0Xn/vznP3PXXXcxceJEMjIyeOKJJ7j//vu7dY/Kykrmzp3L6dOniYqKYuzYsXz44Yf88Ic/vKhtbU+jKGf5U9UA5HA4iIqKoqGhodPiX0KIdnxuqDnUrtdTa/h0EAJdfJjQW9TwKTG/Xe+nERCdBTr5x60QfUVRFBweByebTnKq6VQofGq/3dJVj8Ygg9ZAqi01PHSypYd6O0l9p0tPwO3Ge+IEnmPH8B4/Hgyfjqnh08mT4O+8/hAEh9tlZqq9nbKy1HW2utbFxoZqY4iOFEWhpdFLfUUztadbA6hm6sqdNNV1PYTCZNUHwydbKISKTbHK0DshRLe4XC7KysrIycnpcsKxS81jjz3GG2+8wc6dO/u6Kf3K2X5WzjebkU+QQlwKvC3qELtQzadgCFV7GJQuPlAYrOFD7lpDqKhMkOETQvS61tDpVNMpdWk+FQqcWtdN3i5quAVp0JAQkRAWNKXZ0kLb0tvp0qMoCv76ejVwOnYc74ng+pja28lXUXHWoXYasxljRgaGrEw1eMrMwpiZgTE7G31Skgy3Owe/N0B9lZP6iuBS7qQuuO12dt3TzGI3EpscQUyylZgUdR2bqoZPEvYJIcTF09TUxJEjR3juuef4zW9+09fNGZQklBJiMHE3qcXFzyw4XneELgtKmKKC4dNwtdh4awgVlQ7yD1sheo2iKNS4ajjddJrTzac7BE+nm0/T7G0+533izHGk2dJItaWGrVu3jTrpMXGpCbjdeE+ewnvyBJ7jx/GeOKmGUCdO4D1xgkBj41mv11qtGDIzMWZkqMFTVqb6OCsLfUKCBE/noAQUmurd1Fc4aah0Ul/ZQn2FGj41Vnc95A6NWvMpJtlKbEoEMSlWNYRKjsBslWHxQgjRG5YsWcJf//pX5syZc0FD98S5SSglxEDkcqjhU2VJu/CpFBqOdX2NJSYYOp1RcDwyWcInIXqBN+ClormC081toVPrury5nNPNp3H7zz2zSaw5ljRbGinWlLDgKd2WTootBYteZq+81Cg+H76KCjwnT6rhUzBs8pw8gff4CXyVlWft7QSgT0zEkJGh9nrKzMCYkYkxMwNDRga6mBjpfXMOiqLgbPBQX+mkobKF+kq1t1NDVQsNVS34vV1PC24064hOiiA6OYKYpAiik6zq40QLeqOuF1+FEEKIM61fv57169f3dTMGNQmlhOjPWuo69nqqKgXHya6vsSaEh04JeWoYZY2X8EmIHqIoCg3uhlDgdLr5dChoal1XOatQuuqxGKRBQ4IlgRSbGjilWlPVdXBJsUrodClqDZ28p04Fg6dg+HTypBpAlZeftbYTgCYiAmN6Oob0dIwZ6RjS0jFkpIf2abs5O8+lKBBQaKp1hYKmhqoWGiqdOKrVbZ+n6+BJq9Ngj7cQnRRBVKKF6MRgAJUcIUPuhBBCXNIklBKiP2iuCa/11LpuKu/6GltSW5HxxOA6Pg+scb3XbiEuEU6vk/LmcnVxlocFTuXN5VQ4K85ZRBzUQuIp1hQ1dLKmkmJLUXs8BbeTI5IxyGyVl5yAy4X31Ck1aDrVbjmtrn0VlecOnQwGDKmpGNLS2pbW0El6O503j8uHo9qFo7oluKghVOvjgP8s9bU0EBlnDgZPak8ndR1BZKwJrU6GOQohhBBnklBKiN6iKNBU2TF4qtoHzuqur7OndxxylzBcHY4nhPjOnF4nFc6KULhU0VwRetwaQDV6zl5zp1WcOY4UawrJ1mSSrcmhAKp1X6w5VgqJX2IUvx9fdTW+06fxnj6N91RwXX4aX3DbX1d3zvtoDAb0KSkY0lLVoKl9+JSWJrWdzpPfH6Cp1o2jpoXGahcN1S00VrfQEAyiXE3es16v1WuIircQlWDBnmAhKiGCqAT1cWScGZ1evgdCCCFEd0goJcTFpijQeDo8dKoM9oJy1Xd9XXRWu9CptedTLpi7nj5TCNG11tnqKpwVVDorqWgOrp0VlDvLQ+HT+QZONoMtFDYlW5NJjkgOC5+SrEmYdKYeflWiP1ECAfw1NXjLK9SQqf26ohzf6XK8FRXg63oWtVZaq1Xt6ZSaiiEttW07NRV9air6+HgJnc5Da+jUWNOCo8ZFY3Bx1LTQWOOiud59rvJamK0G7PFm7AkW7HEW7PFmohLV8MkabUKrlR5nQgghxMUioZQQF0pRoOFEu15PJW0Fx92Ozq/RaCEmOzx4SshTwyejtVebL8RA5g14qXZWU9lSSaWzMhQ2tQ+fKp2VuPyu87qfzWAjKSKJJGtS2Lp9+GQz2nr4VYn+RPF68VVV4S2vwFdZodZ0qqjEV64GTb7ycryVleA9e88aAHQ69EmJGFJSMaSkYEhJQZ+SrG6npmJITkZrt8vwuvPgbvHRVOuisVYNm5rqgsFTrZumuvMLnXQGLZGxZuzxFqLizUTGW4iKt2BPMGOPs2C0yD+PhRBCiN4i/9cV4lwCAag/2nHIXfV+8DR1fo1GB3FD23o+xeepdZ/ihoFBiskK0ZWAEqDWVUuVs4qqliqqnFVqwBQMn6qcVVQ4K6h11Z73PaNN0SRFJJEYkUhiRGIobGpdJ0YkSuB0CVEUhUBDgxowVQaXqko1aKqoDIZPFfhras45Yx0AGg36hAQ1ZEpKxpCSjD4pGUNyEvrkFAypKerQOp3MonYuPo+fpjo3TfVqwNQUDJqa6t3BIMqNp+Xcvc50Bi32ODORcWYi4yztttXQyRJpkABQCCGE6CcklBKild+nhk+VJWeETwegqwLGWoMaNLWv+ZSYD7FDQW/s3fYL0Y/5A37q3HWhsKm6pZpKZ2VoXeWsorKlktqWWnzKuT90Aui1ehItatCUEJGg9nBqHz5Z1W0ZUndpaA2bfFVVHZawAKqyEsXjOb+bGgwYEhLQJyerPZ0Sk9AnJbUFTynJ6rA6gxSnPxePy0dzvRo4Nde7aaprWzfVuWiqc5+znlMrs9WALdZEZKyZyFgztuBa3TbJbHZCCCEu2Pr167nvvvuor6/v66ac06OPPspbb73Fjh07zvsajUbDhg0bmDNnTo+1q7sklBKXHr8Xag93LDhefQD87s6v0ZkgfnjHguOxOSAzZYlLWIuvheqWampaaqhuqQ71bqpx1VDlrArtq3XVElC6ni69PQ0aYs2xJEYkEm+JD4VMZy7RpmgpGn4JUDwefDU1arHwqmp81VXB7fDgyV9VjXI+Q+mCdNHR6BMT1SUpEX1CAobkZPSJSWoAlZyszlgndZzOyu8P0OLw0FzvoblBDZpa163BU3O9G4/r7LMHttIbtNhizdhiTMEluN0aOsWYMJrln69CCCE6N3/+fP7yl78AYDAYyMzMZO7cuTz44IPo9YPr/x/3338/9957b4/d/7e//S0rVqygsLCQ1atX99jzDK7vihDt+dxQc7Bj+FRzEAJd9MTQW9T6Ton54UXHY7JBK0MvxKXB6/dS46pRl5bg4lJDpzOXZm/zed9Xq9ESa44lwZIQCpta1wmWBBIiEkiwJBBniUOvlf89DWaKx4OvthZfdQ3+2hp81TX4aqrxV9e0BVDVatDkb2jo1r11UVHoExPUIXWtS2JSWwCVmIg+IR6tSXrQnY3fG6DZ4cbp8OBs8OB0qKGTs95Nc0MwgGrw0NLogfMY5QhgMOuwRZuwRpva1q3BU6y6NkXopZeTEEKI7+Taa6+lqKgIt9vNe++9x+LFizEYDKxYsaKvm3ZR2Ww2bLaeKUGxdetWXnjhBcaOHdsj929P/tUvBj5vi9rLKRQ8BcOn2sOgdPGXWYO1bahd+95PUZkgfxUXg1CLr4VaVy21LbXUuGqoddWGwqb2oVNNSw0OTxeF+rtg0pmIt8QTZ4kLBU6tIVPrdrwlnlhzLDoJdwclRVEIOBz4amvx19biq6lR17W1+GuCj2uCgVNNDYFuBk3o9ejj40OLLj4uLHQyBNe6hAS0Rhk63ZWAP0BLkxenQw2TWhwenA4vTocaMKkBlBpEuZ3nN4wWQKvVEBFlJCLKhDXKiDXKhDUmPHiyRksPJyGEGMgURcHnOb9e7xeb3qjt1h8sTCYTycnJAPz85z9nw4YNvPPOO6xYsYK6ujoKCwvZuHEjbrebGTNm8Ic//IHc3NwO9zly5AhDhgzhq6++YvLkyaH9q1ev5plnnqGsrIxPP/2UmTNnsmnTJpYtW8bevXsZP348RUVF5OXlha5Zu3YtK1eu5Pjx4+Tk5PDQQw9x++23h45rNBrWrVvHxo0b+fjjj8nKyuKll14iISGBRYsWsXXrVsaNG8fLL7/M0KFDgY7D97Zu3cqDDz7IN998g9frZfz48TzzzDNMnDixW1/vpqYmbrvtNv70pz/xm9/8plvXXgj514EYODzNanHx1vCpMhhA1R2hyz/TmuzthtvlQUIwhIpKB/lLrBjAfAEf9e56alpqqHPXUdtSS527jpoWNXCqdQXDpxZ12+lzduv+eo2eWHMscZY4Yi2xxJvjQyFTnCWOeHM88RZ1sRqs0rNhkFH8fvwOB/7WkKmuDn9tHf66dtut+2tq8NXVnd8sdO3pdOhjY9HFx6OPi0MfF6eGTfEJaviUEB/cF48uKkqG0XVCURS8bj8tjV5amjzqurE1cPLibPSEAiinw4Or2XvevZoAtHoNVrtJDZzsatgUEWXEGm1q244yYbEZ0Gjld4AQQgxmPk+AFwu39Mlz37VmBgbThf9h02KxUFNTA6jD+w4cOMA777yD3W5n2bJlzJ49m71792I4o0ZkdnY2BQUFFBUVhYVSRUVFzJ8/H227f5v88pe/5OmnnyYhIYG7776bhQsXUlxcDMCGDRtCQ+AKCgp49913WbBgAenp6cycOTN0j8cee4xVq1axatUqli1bxq233sqQIUNYsWIFmZmZLFy4kCVLlvD+++93+jobGxuZN28ezz77LIqi8PTTTzN79mwOHDhAZGTkeX+9Fi9ezPXXX09BQYGEUuIS5XIEw6d94UPv6o91fY05ul2vp3a9nyKTJXwSA4Lb76bOVde2uM9Yu+pCYVOdu44Gdzd7mgBGrVENmcyxocApzhzXYR1vicdusku9pkFCCQQIOBz46+vVEKmuHn99Pf66Ovz1deq++np1f12dujQ0qDOPdpPWZkMXG6uGTXFxwXW7x3Hx6OPj0MXFSdDUCUVRcDt9uJq8uJqDAVOTF1eTV10HH6vBk7r2ebv3fdJowGwzEGE3YolUw6YIu9rLSQ2ejEQEgygZSieEEGIgUxSFzZs38+GHH3LvvfeGwqji4mKmT58OwCuvvEJGRgZvvfUWP/nJTzrcY9GiRdx9992sWrUKk8nE9u3b2bVrF2+//XbYeY8//jgzZswAYPny5Vx//fW4XC7MZjMrV65k/vz53HPPPQAsXbqUL774gpUrV4aFUgsWLODmm28GYNmyZUybNo2HH36YWbNmAVBYWMiCBQu6fL1XX3112OMXX3yR6OhotmzZwg033HBeX7PXXnuN7du3s3Xr1vM6/2KQUEr0nZa68FpPrWvHya6vsSaEFxpPyIP4PLAlSvgk+g2v30u9uz601LnqOmzXuetocDWEQqfu9mQCtUZTtCmaWHMsMeYYdW2KCQVPrUFTawglPZoGNiUQINDUhL+hAX99g7puqA8+VoOmQEMDvtbt+uB+hwOUbnSPaUdrt6OLiUYfE4suNhZdbAz6mBh0MbHoYmLQx8Wii40LrmOlTlM7gYCC2+kNBkw+XM1eXE0eXE3B7dalNYBq8uJu8hIIdP97pTNoiYg0Yok0YIk0YrEF162BU7tts82AVno1CSGE6Ca9Uctda2b02XN3x7vvvovNZsPr9RIIBLj11lt59NFH2bx5M3q9nqlTp4bOjYuLIy8vj5KSkk7vNWfOHBYvXsyGDRu45ZZbWL9+PTNnziQ7OzvsvPa1l1JSUgCorKwkMzOTkpIS7rrrrrDzr7jiCtasWdPlPZKSkgAYM2ZM2D6Xy4XD4cBut3doa0VFBQ899BCffPIJlZWV+P1+nE4nx46dpXNHO8ePH6ewsJCPPvoIs9l8XtdcDBJKiZ7XXBMMnErCw6emiq6vsSVD4ojwACo+D6xxvdducckLKAEaPY043A4aPA2hYKnBHdx2qdutx1r3d6f4d3t6rZ4YUwwx5pjQujV0ijZHh8Kl1sVutEuNpgFGURQCzc0EGhrU4XENDvyNDrUnU4MDv6Oh3bYjFDwF6hvwNzZeUO+lVtqICDVYio5GFxODLiZanYEuJkZ9HB2NLjq4P0YNnzQGmV3U5/GrvZecXtxOX3Dx4m5uC5fczV5cTp+6bm4770IZzDosNgNmWzBgshkwBxdLpDG4GIiIVEMmg0kngbMQQogepdFovtMQut40c+ZM1q5di9FoJDU19TvNumc0Gpk7dy5FRUXcdNNNvPrqqx3CJCBs6F/r/5MD3fx3W2f36M59582bR01NDWvWrCErKwuTycS0adPweDzn9fzbtm2jsrIyrAaV3+/n008/5bnnnsPtdqPTXfyfAQmlxMWhKNBcBZUlHXs/Oau7vs6eHt7rqXVtie61povBz+1343A7cHjUpcHdoG4Hw6bWdYNb3a5319PgaaDR00hAubAQQKvREmWMItocTYxJDZdizDFEmaLUx+bo0L7WAMpmsMkHy35O8fnU3kpNTQQaG/E3NhJo3XY0BgOm9utGNWRqbAydj7+LCRjOk8ZiQRcVpS52ezBMigquo9X9Z25HRaG5RAuA+/0BPE4f7hYfnhZfKDBq3fa42gVNYWt18fu+W1FXo0WP2arHbA0GS+3X7bYtkQbMVjWE0hlkWKMQQghxoaxWK8OGDeuwPz8/H5/Px5dffhkavldTU0NpaSkjR47s8n6LFi1i9OjRPP/88/h8Pm666aZutSc/P5/i4mLmzZsX2ldcXHzW57wQxcXFPP/888yePRtQez5VV5/ls/gZfvCDH7Br166wfQsWLGDEiBEsW7asRwIpkFBKdJeiQOPpjkPuqvapw/G6Ep0Z7O00PFj7KR/ic8HcsduhEGcKKAGavE00ehpDS2uo1Lrdfn/74w6PA5ff9Z2e36K3EGWKUkMmUzRRpvB1a8BkN9rVx6ZoqcnUzyh+PwGnU+2l1NQUDJaC283Bx41Nocdq6BQMm5ra1oqz+8MsO6MxGtFG2dHZo9BFRrZt2+3oouxoI4NhU5S9LYCKikIbFXXJzC6nBNQi3h6XD09LcN1+u8WHx+VX162BUyf7ultzqTMarQaTRY8pQl3MVgMmqwFzhF5dWw2YrHrMEcH9Vj2mCHWfTie/B4QQQoj+IDc3lxtvvJE777yTF154gcjISJYvX05aWho33nhjl9fl5+dz+eWXs2zZMhYuXIjFYunW8z7wwAPcfPPNTJgwgYKCAjZu3Mibb77Jpk2bvutLCpObm8vLL7/M5MmTcTgcPPDAA91qa2RkJKNHjw7bZ7VaiYuL67D/YpJQSnQuEADHiXbBU2v4VArurqaL10BsTic1n4aD0dqrzRf9R0AJ4PQ6afI20eRpCoVLTd6m0L7Wx42eRpo8TWqw5G0MO/ZdaTVaIo2R2I12ooxR2E127EZ1iTJFtS3GqLDHdqMdo+7SCAH6EyUQIOBsIeBsVoOk1kCpdd3pPmcwVGoOhU9+p7r/YoVJrTRmM9pIGzpbJNrISDVYskeii7Sjs0eqoZI9Eq0tMvxxZDB06sVx+r1FCSh4PX68bj9eV3AdXDwuX2h/2LbbF9znxxvc72k9x/XdepSdyWDWhYIlo0UNjYwWHSaLQd1n1mOytgZPhrYAKsKAwSzD44QQQojBoKioiMLCQm644QY8Hg9XXnkl7733XoeZ9850xx138Nlnn7Fw4cJuP+ecOXNYs2YNK1eupLCwkJycHIqKirjqqqsu8FV07s9//jN33XUXEydOJCMjgyeeeIL777//oj5HT9AoygVWP+2nHA4HUVFRNDQ0dFr8S5whEID6o2f0eiqBqv3QVV0cjQ7ihrYLnoI9oOJzwdC91Fj0T4qi0OJrwelz0uxtDi1Ob/Cxr5lmTzNN3qbQsdbtJm8TzR71nCaPuk/pzhzkZ2HSmbAZbNhN9lDA1Lpuvx1pjCTSGBkKlewmOzaDTXouXWRKIIDichFoaSHQ4kJpcarbzhYCLU6UlpZ2j4P7QtstBJxO9ZpmpxosBfcFnE4U13fr3dYlvR6t1YrOZkMbGYnWZkVntaG1qYsuMrhtbf84Ug2gIoMBlNU6YIfCBfwBfJ4AXo8fn8evbrvbbQdDJV9orR73evz42oVM6vFAuxDKh8/z3XskdUar1WC06DGYdRjNeowWHQaTHpNFh9GiDy0mix6juZN9wUWKewshhBDnx+VyUVZWRk5OTq8WvO7PHnvsMd544w127tzZ103pV872s3K+2Yz0lLpU+H3B8GlfeN2n6gPga+n8Gq0B4oa1hU+thcdjh4J+YH4gG4wCSgCXz4XT56TFqwZJrYFSi68Fp7dt3RoyOX3O0GOn1xl2rPX4hdZS6opeqyfSEInNaMNmsLWt2223Bko2o00NlgyRYY9NOpnZ61xCQZHbjeJyobjdoe2Ay43idhFo3e9yobjcBFwtKC0uAm7XGWu3Giy5XG3nuFwoTmfoHj1Oq0UbEYHWaj332mpFa7OGtnU2W7v96rbGaOw3PV4URSEQUPB7A/i9AXzt1j6vv22fR33s86qBUuhYu/1+T0ANlrzq2usJ4PcG18H9Xo+fgK/n/w6l0YDBpFMXs77dtg5j677WbVNr2KTuN5p0HQIonV7bb75nQgghhLi0NDU1ceTIEZ577jl+85vf9HVzBiUJpQYbvxdqD3es+VR9APxdfIDUmdSeTmcWHI/NAZ3MvPRd+AI+3H43Lp8rtHb5Xeq6/Xa7dYuvBZdPXbcurY9D6+B5Tq/zO9dLOpcIfQQ2g40IQwRWgxWrwUqEQd1nNVhDoVLrdmhttGLVW0OBklHbf8KAnqD4fCher7p4PKEl4PGgeNrt83o6Oe5Bcbfuc6v73R4Utzu0L+DxoLjcapjkcavnu91qgNR6rtuN4vX2yevXmM1ozWY0ERa0lgi0Fgtai6XDY22EBY0luC8iAq01uLZY0EZEoIkIPg4uGpPpov3cKAGFgE/B71fDGb8vgN8XIODvYrvdOeoSDJDO3Ne67T1jHdpW1OCo9bE3gM+nhkV91ldZA3qjDoNRq65NOvQGrbo26oL7tBiMapgUOie4Nph0oWOhx8FFZ5AQSQghhBCDw5IlS/jrX//KnDlzLmjonji3Xgml/vjHP/LUU09RXl7OuHHjePbZZ5kyZUqX57/xxhs8/PDDHDlyhNzcXH73u9+FKsiLIJ8bag52DJ9qDkKgi2mo9RZIGA7xeW29nhJGQHQW6AZfPukL+PAGvHgDXjx+Tygg8vg9eAIevH5vaNvj93Tc9ntw+91hS+u+9muX3xUWPIUWnxufcuFTgneXBg0WvQWL3kKEISK0bdFb1CBJH0GEIbjoI9oe69WwKXReu/DJorf0ypA3JRAAnw/F71fDHZ8PQtt+8PtC24rP23au19f22OdTH/t94Y+93uC1wfPC9qn7Fa8XvN62Y+daPJ7wtderDoXtbwwGtCaTGhgF1xqTEa3JjMZsQmu2dLI2g8msro3qNsbWxyYUgxmNyQQGE4rRBHojisEAaAj4FXUJKCh+Bb8/QCCg4A0obcf8ihoOBY8F/GpQFKgPEKhpPcdFwN9CIFCtntd6r9Z7tIZHfiV0vDVMCgT3+X3t1q37A/17tLpOr0VnUBe9XoveGNw26NAbtegNbY91wcdtx4LrYMikN2hD4ZK6HQyfjDr0Jq30PhJCCCGEOA/r169n/fr1fd2MQa3Hk4jXX3+dpUuXsm7dOqZOncrq1auZNWsWpaWlJCYmdjj/s88+42c/+xlPPvkkN9xwA6+++ipz5sxh+/btPVrxvT/yejz4XU1QewCqDkL1fpSa/eq67igofhTUDxVKcAFQDJEoccMIxA1DiRsGccNQ4nMIWFNRNBoUAuqwESWAgoK/7ri6HdwXCB73B/zBx35QFPyK+rh1f9vjQGi/X/ETCPjwhbb9+BQf/tB1PrwBH/6AD7/iIxAI4POr+wKKH1/Ahy/gIxDw4w148Qd8eP1efIoXn9+Pz+/Fp/jx+72h+/gCXnXx+fEFWvd7UZQAmnafQTWKRv1qKaCBM47R6bHW7a6uVY+p+wwKGBWwownu04BiQBs816QxYNIaMWoNmDQGjFojRq0eo8aISWPAgB6DzohJo8ekNWLQ6DEG9xs1BowaPYbgotcaMKDDoNFhxIAeHXp04AmAP4CiBFACCigBNfDxB9RtvwIBP0qgBcXvbDseaDsvEAjg8PtpCChqMKQE1wEFJeBXz/W3na8EFPD71CAi4Ae/ov5s+tR24A8Q8Lc9h+IPBO/Xeo9gb5HQB2SN+nOtaf0OEHzcxXbwsdL6HdNoQu+Ltu125wRDNiXsOi1oWvdpQ/dSNHrAEHYfRaMBvQbFoIEIrfq4dX9orQW9Xg17dXrQ61F0etDqgvt0oW0ltK1D0QbP0epQtNrgthZFo1PbpdWGHitoUDTaYHs1wfd2sJ2KhgAaFCXYOyigBL9/SrvHbcPHlCaFQKMaJHXdc8cXXLqoNTcAaTRqEKTVa9HpNeq2TtO2T6dRQyJ926INnte2aNrCpNZ9hmCA1H6/oe381gCpdV/ruRqpeSSEEEIIIS4xPV7ofOrUqVx22WU899xzAAQCATIyMrj33ntZvnx5h/N/+tOf0tzczLvvvhvad/nllzN+/HjWrVvX4Xy32427XV0Th8NBRkbGoCh0/uo9D1MXmNnXzRBCCAA0Wg1arQaNTl1rtRo0WsL36dRgp/VcrS64BLc1Wm2Hfeqi7fhY1/GxTqdBq287pgudFwyM2q91bUGTVqcGQu1DJyl8LYQQQgjRUWvx6uzsbCwWmchKdK2lpYUjR47030LnHo+Hbdu2sWLFitA+rVZLQUEBn3/+eafXfP755yxdujRs36xZs3jrrbc6Pf/JJ5/k17/+9UVrc7+i1UE/HBEkBrLwDPrMj+SdjeY5c1/7x2HHgg80mvYPNbR1egputz9Po2m3bne8dX/wxNCtOrk27HnOcU7rSERN6HmD+zVq4NL+vPb30WjbtUGrCV0fuo+27XFrO7Vn7A+ttepNWwOR1ucNXwePa4KBT+v+1ucOtk/buk/bem/13Lb9GrTtjml1mrbztG3nhdbB42GhUuv9g88thBBCCCEGN4NBrSvsdDollBJn5XQ6gbafmQvRo6FUdXU1fr+fpKSksP1JSUns27ev02vKy8s7Pb+8vLzT81esWBEWYrX2lBoMfvTLeTgb6iEiJvjBvO0DYefbrR+iNWg12uBgo+AHWzRt/7V9Sj+380kp2j33eZ3a2jshPNHoeFFrKNB+/xnH0ABabXDXuV/TeX+k/o6fvTtti6bTzU6OnZkCdd2usK9N2OOztEMIIYQQQgghuqDT6YiOjqayshKAiIgI+VwhwiiKgtPppLKykujoaHQ63QXfa8BXtzaZTJhMg3Oa+MiUHCJT+roVQgghhBBCCCEuJcnJyQChYEqIzkRHR4d+Vi5Uj4ZS8fHx6HQ6KioqwvZXVFR02fDk5ORunS+EEEIIIYQQQoiLR6PRkJKSQmJiIl6vt6+bI/ohg8HwnXpIterRUMpoNDJp0iQ2b97MnDlzALXQ+ebNm1myZEmn10ybNo3Nmzdz3333hfZ99NFHTJs2rSebKoQQQgghhBBCiHZ0Ot1FCR6E6EqPD99bunQp8+bNY/LkyUyZMoXVq1fT3NzMggULAJg7dy5paWk8+eSTABQWFjJjxgyefvpprr/+el577TW+/vprXnzxxZ5uqhBCCCGEEEIIIYToJT0eSv30pz+lqqqKRx55hPLycsaPH88HH3wQKmZ+7NgxtMFC1QDTp0/n1Vdf5aGHHuLBBx8kNzeXt956i9GjR/d0U4UQQgghhBBCCCFEL9EoiqKc+7SBw+FwEBUVRUNDA3a7va+bI4QQQgghhBBCCHFJOd9sZsDPvnem1ozN4XD0cUuEEEIIIYQQQgghLj2tmcy5+kENulCqsbERgIyMjD5uiRBCCCGEEEIIIcSlq7GxkaioqC6PD7rhe4FAgFOnThEZGYlGo+nr5nxnDoeDjIwMjh8/LsMRhThP8r4R4sLIe0eICyPvHSEujLx3hLgwA+G9oygKjY2NpKamhtURP9Og6yml1WpJT0/v62ZcdHa7vd/+sAnRX8n7RogLI+8dIS6MvHeEuDDy3hHiwvT3987Zeki16jquEkIIIYQQQgghhBCih0goJYQQQgghhBBCCCF6nYRS/ZzJZOJXv/oVJpOpr5sixIAh7xshLoy8d4S4MPLeEeLCyHtHiAszmN47g67QuRBCCCGEEEIIIYTo/6SnlBBCCCGEEEIIIYTodRJKCSGEEEIIIYQQQoheJ6GUEEIIIYQQQgghhOh1EkoJIYQQQgghhBBCiF4noVQ/9sc//pHs7GzMZjNTp07lq6++6usmCdGvPPnkk1x22WVERkaSmJjInDlzKC0tDTvH5XKxePFi4uLisNls/Pu//zsVFRV91GIh+p/f/va3aDQa7rvvvtA+ed8I0bmTJ0/yn//5n8TFxWGxWBgzZgxff/116LiiKDzyyCOkpKRgsVgoKCjgwIEDfdhiIfqe3+/n4YcfJicnB4vFwtChQ3nsscdoP9+WvHeEUH366af86Ec/IjU1FY1Gw1tvvRV2/HzeK7W1tdx2223Y7Xaio6O54447aGpq6sVX0T0SSvVTr7/+OkuXLuVXv/oV27dvZ9y4ccyaNYvKysq+bpoQ/caWLVtYvHgxX3zxBR999BFer5drrrmG5ubm0Dm/+MUv2LhxI2+88QZbtmzh1KlT3HTTTX3YaiH6j61bt/LCCy8wduzYsP3yvhGio7q6Oq644goMBgPvv/8+e/fu5emnnyYmJiZ0zu9//3v+8Ic/sG7dOr788kusViuzZs3C5XL1YcuF6Fu/+93vWLt2Lc899xwlJSX87ne/4/e//z3PPvts6Bx57wiham5uZty4cfzxj3/s9Pj5vFduu+029uzZw0cffcS7777Lp59+yl133dVbL6H7FNEvTZkyRVm8eHHosd/vV1JTU5Unn3yyD1slRP9WWVmpAMqWLVsURVGU+vp6xWAwKG+88UbonJKSEgVQPv/8875qphD9QmNjo5Kbm6t89NFHyowZM5TCwkJFUeR9I0RXli1bpnzve9/r8nggEFCSk5OVp556KrSvvr5eMZlMyl//+tfeaKIQ/dL111+vLFy4MGzfTTfdpNx2222Kosh7R4iuAMqGDRtCj8/nvbJ3714FULZu3Ro65/3331c0Go1y8uTJXmt7d0hPqX7I4/Gwbds2CgoKQvu0Wi0FBQV8/vnnfdgyIfq3hoYGAGJjYwHYtm0bXq837L00YsQIMjMz5b0kLnmLFy/m+uuvD3t/gLxvhOjKO++8w+TJk/nJT35CYmIiEyZM4E9/+lPoeFlZGeXl5WHvnaioKKZOnSrvHXFJmz59Ops3b2b//v0AfPvtt/zrX//iuuuuA+S9I8T5Op/3yueff050dDSTJ08OnVNQUIBWq+XLL7/s9TafD31fN0B0VF1djd/vJykpKWx/UlIS+/bt66NWCdG/BQIB7rvvPq644gpGjx4NQHl5OUajkejo6LBzk5KSKC8v74NWCtE/vPbaa2zfvp2tW7d2OCbvGyE6d/jwYdauXcvSpUt58MEH2bp1K//1X/+F0Whk3rx5ofdHZ/9+k/eOuJQtX74ch8PBiBEj0Ol0+P1+Hn/8cW677TYAee8IcZ7O571SXl5OYmJi2HG9Xk9sbGy/fT9JKCWEGBQWL17M7t27+de//tXXTRGiXzt+/DiFhYV89NFHmM3mvm6OEANGIBBg8uTJPPHEEwBMmDCB3bt3s27dOubNm9fHrROi//qf//kfXnnlFV599VVGjRrFjh07uO+++0hNTZX3jhBCCp33R/Hx8eh0ug4zHVVUVJCcnNxHrRKi/1qyZAnvvvsu//jHP0hPTw/tT05OxuPxUF9fH3a+vJfEpWzbtm1UVlYyceJE9Ho9er2eLVu28Ic//AG9Xk9SUpK8b4ToREpKCiNHjgzbl5+fz7FjxwBC7w/595sQ4R544AGWL1/OLbfcwpgxY7j99tv5xS9+wZNPPgnIe0eI83U+75Xk5OQOk6P5fD5qa2v77ftJQql+yGg0MmnSJDZv3hzaFwgE2Lx5M9OmTevDlgnRvyiKwpIlS9iwYQMff/wxOTk5YccnTZqEwWAIey+VlpZy7NgxeS+JS9YPfvADdu3axY4dO0LL5MmTue2220Lb8r4RoqMrrriC0tLSsH379+8nKysLgJycHJKTk8PeOw6Hgy+//FLeO+KS5nQ60WrDP3bqdDoCgQAg7x0hztf5vFemTZtGfX0927ZtC53z8ccfEwgEmDp1aq+3+XzI8L1+aunSpcybN4/JkyczZcoUVq9eTXNzMwsWLOjrpgnRbyxevJhXX32Vt99+m8jIyNA46aioKCwWC1FRUdxxxx0sXbqU2NhY7HY79957L9OmTePyyy/v49YL0TciIyNDdddaWa1W4uLiQvvlfSNER7/4xS+YPn06TzzxBDfffDNfffUVL774Ii+++CIAGo2G++67j9/85jfk5uaSk5PDww8/TGpqKnPmzOnbxgvRh370ox/x+OOPk5mZyahRo/jmm29YtWoVCxcuBOS9I0R7TU1NHDx4MPS4rKyMHTt2EBsbS2Zm5jnfK/n5+Vx77bXceeedrFu3Dq/Xy5IlS7jllltITU3to1d1Dn09/Z/o2rPPPqtkZmYqRqNRmTJlivLFF1/0dZOE6FeATpeioqLQOS0tLco999yjxMTEKBEREcqPf/xj5fTp033XaCH6oRkzZiiFhYWhx/K+EaJzGzduVEaPHq2YTCZlxIgRyosvvhh2PBAIKA8//LCSlJSkmEwm5Qc/+IFSWlraR60Von9wOBxKYWGhkpmZqZjNZmXIkCHKL3/5S8XtdofOkfeOEKp//OMfnX6+mTdvnqIo5/deqampUX72s58pNptNsdvtyoIFC5TGxsY+eDXnR6MoitJHeZgQQgghhBBCCCGEuERJTSkhhBBCCCGEEEII0esklBJCCCGEEEIIIYQQvU5CKSGEEEIIIYQQQgjR6ySUEkIIIYQQQgghhBC9TkIpIYQQQgghhBBCCNHrJJQSQgghhBBCCCGEEL1OQikhhBBCCCGEEEII0esklBJCCCGEEEIIIYQQvU5CKSGEEEIIIYQQQgjR6ySUEkIIIYQQQgghhBC9TkIpIYQQQgghhBBCCNHrJJQSQgghhBBCCCGEEL1OQikhhBBCCCGEEEII0esklBJCCCGEEEIIIYQQvU5CKSGEEEIIIYQQQgjR6ySUEkIIIYQQQgghhBC9TkIpIYQQQgghhBBCCNHrJJQSQgghxIBz1VVXcdVVV/V1My6K9evXo9FoOHLkSLevnT9/PtnZ2Re9Tf3FYH99QgghxKVOQikhhBBC9LjW4KV1MZvNDB8+nCVLllBRUdHXzRvUAoEA69ev59/+7d/IyMjAarUyevRofvOb3+Byuc7rHtnZ2R2+f7m5uTzwwAPU1tb28CsQQgghxGCl7+sGCCGEEOLS8d///d/k5OTgcrn417/+xdq1a3nvvffYvXs3ERERfd28PnH77bdzyy23YDKZeuT+TqeTBQsWcPnll3P33XeTmJjI559/zq9+9Ss2b97Mxx9/jEajOed9xo8fz//3//1/ALhcLrZt28bq1avZsmULX331VY+0/U9/+hOBQKBH7i2EEEKIviehlBBCCCF6zXXXXcfkyZMBWLRoEXFxcaxatYq3336bn/3sZ33cur6h0+nQ6XQ9dn+j0UhxcTHTp08P7bvzzjvJzs4OBVMFBQXnvE9aWhr/+Z//GXq8aNEibDYbK1eu5MCBA+Tm5l70thsMhot+TyGEEEL0HzJ8TwghhBB95uqrrwagrKwMAJ/Px2OPPcbQoUMxmUxkZ2fz4IMP4na7u7xHU1MTVquVwsLCDsdOnDiBTqfjySefBNqGERYXF7N06VISEhKwWq38+Mc/pqqqqsP1zz//PKNGjcJkMpGamsrixYupr68PO+eqq65i9OjR7Ny5kxkzZhAREcGwYcP43//9XwC2bNnC1KlTsVgs5OXlsWnTprDrO6sp9fbbb3P99deTmpqKyWRi6NChPPbYY/j9/nN/Uc9gNBrDAqlWP/7xjwEoKSnp9j1bJScnA6DXt/2dc+fOncyfP58hQ4ZgNptJTk5m4cKF1NTUhF3b2NjIfffdR3Z2NiaTicTERH74wx+yffv20Dmd1ZR67bXXmDRpEpGRkdjtdsaMGcOaNWsu+DUIIYQQou9IKCWEEEKIPnPo0CEA4uLiALX3zSOPPMLEiRN55plnmDFjBk8++SS33HJLl/ew2Wz8+Mc/5vXXX+8Q2vz1r39FURRuu+22sP333nsv3377Lb/61a/4+c9/zsaNG1myZEnYOY8++iiLFy8mNTWVp59+mn//93/nhRde4JprrsHr9YadW1dXxw033MDUqVP5/e9/j8lk4pZbbuH111/nlltuYfbs2fz2t7+lubmZ//iP/6CxsfGsX5f169djs9lYunQpa9asYdKkSTzyyCMsX7787F/QbigvLwcgPj7+vM73er1UV1dTXV3NiRMn2LhxI6tWreLKK68kJycndN5HH33E4cOHWbBgAc8++yy33HILr732GrNnz0ZRlNB5d999N2vXruXf//3fef7557n//vuxWCxnDck++ugjfvaznxETE8Pvfvc7fvvb33LVVVdRXFx8gV8FIYQQQvQpRQghhBCihxUVFSmAsmnTJqWqqko5fvy48tprrylxcXGKxWJRTpw4oezYsUMBlEWLFoVde//99yuA8vHHH4f2zZgxQ5kxY0bo8YcffqgAyvvvvx927dixY8POa21HQUGBEggEQvt/8YtfKDqdTqmvr1cURVEqKysVo9GoXHPNNYrf7w+d99xzzymA8tJLL4W1BVBeffXV0L59+/YpgKLVapUvvviiQzuLioo6tKmsrCy0z+l0dvga/p//83+UiIgIxeVyhfbNmzdPycrK6nDu+SgoKFDsdrtSV1d3znOzsrIUoMNyxRVXKNXV1WHndtb2v/71rwqgfPrpp6F9UVFRyuLFi8/6vGe+vsLCQsVutys+n++cbRZCCCFE/yc9pYQQQgjRawoKCkhISCAjI4NbbrkFm83Ghg0bSEtL47333gNg6dKlYde0Ftf+29/+dtb7pqam8sorr4T27d69m507d4bVQWp11113hRX3/v73v4/f7+fo0aMAbNq0CY/Hw3333YdW2/bPpTvvvBO73d6hLTabLaw3V15eHtHR0eTn5zN16tTQ/tbtw4cPd/laACwWS2i7sbGR6upqvv/97+N0Otm3b99Zrz0fTzzxBJs2beK3v/0t0dHR53XN1KlT+eijj/joo4949913efzxx9mzZw//9m//RktLS6dtd7lcVFdXc/nllwOEDc2Ljo7myy+/5NSpU+fd7ujoaJqbm/noo4/O+xohhBBC9F9S6FwIIYQQveaPf/wjw4cPR6/Xk5SURF5eXij0OXr0KFqtlmHDhoVdk5ycTHR0dCgw6oxWq+W2225j7dq1OJ1OIiIieOWVVzCbzfzkJz/pcH5mZmbY45iYGEAdhtfaFlDDpfaMRiNDhgzp0Jb09PQOM9hFRUWRkZHRYV/75+nKnj17eOihh/j4449xOBxhxxoaGs567bm8/vrrPPTQQ9xxxx38/Oc/P+/r4uPjwwqiX3/99eTl5fEf//Ef/N//+3+59957AaitreXXv/41r732GpWVlV22/fe//z3z5s0jIyODSZMmMXv2bObOncuQIUO6bMM999zD//zP/3DdddeRlpbGNddcw80338y111573q9DCCGEEP2H9JQSQgghRK+ZMmUKBQUFXHXVVeTn54f1Qmp1ZrhzvubOnUtTUxNvvfUWiqLw6quvcsMNN4SCoPa6mu1OaVfzqDu6ut+FPE99fT0zZszg22+/5b//+7/ZuHEjH330Eb/73e8ACAQCF9RGUGsyzZ07l+uvv55169Zd8H1a/eAHPwDg008/De27+eab+dOf/sTdd9/Nm2++yd///nc++OADILztN998M4cPH+bZZ58lNTWVp556ilGjRvH+++93+XyJiYns2LGDd955h3/7t3/jH//4B9dddx3z5s37zq9FCCGEEL1PekoJIYQQol/IysoiEAhw4MAB8vPzQ/srKiqor68nKyvrrNePHj2aCRMm8Morr5Cens6xY8d49tlnL7gtAKWlpWE9dzweD2VlZWE9hi62Tz75hJqaGt58802uvPLK0P7WGQov1JdffsmPf/xjJk+ezP/8z/+EzZh3oXw+H6DOgAhqD7DNmzfz61//mkceeSR03oEDBzq9PiUlhXvuuYd77rmHyspKJk6cyOOPP851113X5XMajUZ+9KMf8aMf/YhAIMA999zDCy+8wMMPP9yhl50QQggh+jfpKSWEEEKIfmH27NkArF69Omz/qlWrAHW42Lncfvvt/P3vf2f16tXExcWdNdw4m4KCAoxGI3/4wx/CejX9+c9/pqGh4bzacqFae1f9/+zdeZxU9ZX//1ftW+/7vkEDreyyoyBKNEGTEDMxiZMIOsZxgg6OkwxiTMaMk/j1O7jFjJr8ZgYyTkjm64ygEHcUCM0iq2xN0yxNN73v1Uvt9/7+uFXVXXQ3e29wno/HtW7durfqVoNN1fuez/n0fF2v18trr7122c9ZUlLCXXfdRV5eHhs3bozo+3QlNmzYAMCkSZOAvs8dev+ZBgKBXsMQU1JSyMjIwOPx9Pt6TU1NEff1ej0TJ04EOO9xQgghhBiepFJKCCGEEMPCpEmTWLJkCb/97W/DQ9g+//xzfve737F48WIWLFhwwee47777+Id/+AfWrVvH3/zN32AymS7rXJKTk1m5ciU///nP+fKXv8zXvvY1SktLee2115g+fXqfzdOvljlz5hAfH8+SJUv427/9W3Q6HW+++eZlDy1sb2/nzjvvpKWlhR//+Me9mrSPGjWK2bNnX/B5qqqq+K//+i9AC8m++OILfvOb35CUlBTuJxUTE8O8efP4v//3/+Lz+cjMzOSjjz7qVeXV3t5OVlYWf/EXf8GkSZOIiorik08+Yffu3bzwwgv9nsNDDz1Ec3Mzt912G1lZWZw5c4ZXX32VyZMnR1TXCSGEEGJkkFBKCCGEEMPGv/3bv1FQUMCaNWtYt24daWlprFy5kn/8x3+8qONTU1O54447eO+99/j+979/RefyzDPPkJyczK9//Wv+7u/+joSEBB5++GF++ctfXnbYdTESExPZuHEjf//3f8/TTz9NfHw83/ve97j99tu58847L/n5mpqaqKysBODJJ5/s9fiSJUsuKpQ6cOBA+Geq1+tJSkrinnvu4dlnnyUzMzO839q1a3nsscf413/9V1RV5Y477uD9998nIyMjvI/dbueHP/whH330EW+//TaKojB69Ghee+218zZf/973vsdvf/tbXnvtNVpbW0lLS+Pb3/42zzzzTJ/9yYQQQggxvOnUy73sJoQQQggxDH3jG9/g0KFDnDhxYqhPRQghhBBCnIdcUhJCCCHENaOmpoY//elPV1wlJYQQQgghBp4M3xNCCCHEiHf69GmKi4v5t3/7N0wmE3/913891KckhBBCCCEuQCqlhBBCCDHibdmyhe9///ucPn2a3/3ud6SlpQ31KQkhhBBCiAuQnlJCCCGEEEIIIYQQYtBJpZQQQgghhBBCCCGEGHQSSgkhhBBCCCGEEEKIQXfNNTpXFIXq6mqio6PR6XRDfTpCCCGEEEIIIYQQ1xVVVWlvbycjIwO9vv96qGsulKquriY7O3uoT0MIIYQQQgghhBDiulZZWUlWVla/j19zoVR0dDSgvfGYmJghPhshhBBCCCGEEEKI64vT6SQ7Ozuc0fTnmgulQkP2YmJiJJQSQgghhBBCCCGEGCIXaqskjc6FEEIIIYQQQgghxKCTUEoIIYQQQgghhBBCDLoBDaW2bt3KV7/6VTIyMtDpdKxfv/6Cx2zevJmpU6disVgYPXo0a9asGchTFEIIIYQQQgghhBBDYEB7SnV2djJp0iQefPBB7rnnngvuf/r0ae666y4eeeQRfv/737Np0yYeeugh0tPTufPOOwfyVIclt99N9dlW0jKShvpUhBBCCCGEEEIIMYA6G9tobzxD/oQpF+zFdK0Y0FDqK1/5Cl/5ylcuev833niD/Px8XnjhBQCKiorYtm0bL730Ur+hlMfjwePxhO87nc4rO+lh5O2PPqXpXTNfJB5km70Ld+dYUOxDfVpCCCGEEEIIIYS4bCrJtFGoP8soXSUO03HiK5NB/QuM/jLS/m0idvM1Ny9dn4bVu9yxYwcLFy6M2HbnnXfy+OOP93vMc889x89//vMBPrOhUV3WjI0MpjRNpqCjkS0F/02FUcXvnIC/4wbUgGOoT1EIIYQQQgghhBB9UkmmlUJ9FWN0ZxmjO8tofRUFurMctwf41GhHX5pKduu9tCZMBsCgZNHR1II9PXloT32QDKtQqra2ltTU1IhtqampOJ1OXC4XNput1zErV67kiSeeCN93Op1kZ2cP+LkOhr//279ka/FBDq2rJbYzia+V/JCS5J3syFtPIHM9N6VMY0HOQm7Nuo0Ea8JQn64QQgghhBBCCHH9UVV0HbXoGkvRN5Rqt43H0DeWonO3AuADdtisbHDY2amP5eZ9eqZVzOJszjdoTbCjUwOkJZ7k1uWLiU+5flr4DKtQ6nJYLBYsFstQn8aA0Ol0zL95ErOn3cjOdSc5tKWKooZZjHJOZHPuH/lc2cXndbv4lz3PcVPqTXwp90vcln0bqY7UCz+5EEIIIYQQQgghLp6qQnsNNByD+mPabWhxt/Xa3a3Tsd1u55P4ZDabddAV4K7dCs8cSaI87z7KC8YAkBDr50s/nElS7pcG+x0NuWEVSqWlpVFXVxexra6ujpiYmD6rpK4XZquRed8dS+H0VD77r2O01MIdxx9En9/JjlHr2N+5m9212vLLXb9kUvIkFuYsZGHuQrKis4b69IUQQgghhBBCiJFDVcFZDQ0l0FAK9cHbhlLw9A6fANDpIaGAzqRC/hwVzceKkz+3n8QV8BDbofD1bQp37NdTl3o7ByfehWIwYzCozFo8mom356DXXx+Nzc81rEKp2bNn895770Vs+/jjj5k9e/YQndHwkj46jnt/Mp29759h3wdnUE47uKV2KX99199TlraHTyo+5ouGL8LLC3tfoCihiNtzbmdh7kJGxY0a6rcghBBCCCGEEEIMD6oKzqoeVU89w6d+JlHTGSChAFLGQbK2tMVm8ZnrLJvObmF79Xa8zV4AkltV/mqflbn73HRZMjk44S/piM4BIGtcPLf+5Thik6/fAhwAnaqq6kA9eUdHBydOnABgypQpvPjiiyxYsICEhARycnJYuXIlVVVV/Od//icAp0+fZvz48SxbtowHH3yQTz/9lL/927/lT3/6U7+z753L6XQSGxtLW1sbMTExA/XWhlzj2Q4+e7OE+jPtAGSOiePWvxyHN7qDTRWb2HRmE3vq9hBQA+Fj8mPzwxVURQlF180Uk0IIIYQQQgghrmOqCm1nu4fahUOoUvC2932M3ggJoyB5LKQUabfJ4yBxNBgtNLoa+bTiUz4+8zG7a3dHfPee2ZXGd/dYSd95CkU1cDpvEZXZC1F1eiw2I3O/NZpxs9Ov6e/kF5vNDGgotXnzZhYsWNBr+5IlS1izZg1Lly6lvLyczZs3Rxzzd3/3dxw9epSsrCx++tOfsnTp0ot+zesllAJQFJWDn1ay651T+H0KBqOeKXfmcNOduRjNBlrcLWyu3MzHZz5mR80O/Io/fGy6I53bcm7j9pzbmZIyBaN+WBXNCSGEEEIIIYQQl0ZVoa2yx5C7nuFTR9/H6I1a0JQ8FpKLukOohFFgNEfsWuGs0IpAKjZxsOEgKt1xypj4MXzTdQNTPyxH3b4HgMbE8ZwY/z26dNEAjJqawi3fLsQRe232xe5pWIRSQ+F6CqVC2hpcbFl7jMqSFgBikqzc8u0x5E3o7tjf7m1n69mtfHLmE4qri3H5XeHH4ixxzM+az+05tzM7YzZWo3XQ34MQQgghhBBCCHFRFKU7fOrZ96nx+AXCp8JzKp+KtKF454RPIaqqUtJcwqaKTXxa8SknWk9EPD4haQILs2/n1spo9L9/B9e+fQC4rImcnvNDapU0ABxxFuZ9ZwwFk5Ov3s9gmJNQ6joKpUD7n+Xkvga2vVVGZ6sHgPxJSdx8byExiZFjVN1+Nzuqd7CpYhObz26mrUejNpvRxtyMudyWcxvzsuYRa4kd1PchhBBCCCGEEEIAwfCp4pxm4yXQcBx8nX0fozdplU8p486pfCoAg+mCL+lX/Oyv3x8Oomo6a8KPGXVGpqVN4/ac27k17RZsW/fS9P/9G56yMgBUs5W6hcso9Y4i4FfR63VMvD2b6XflYbZeX6OTJJS6zkKpEK/bz+4/lfPFpkpURcVo0jPtrjwmL8zBYNT32v9C/8PdlHYTC7IXcFv2baRHpQ/mWxFCCCGEEEIIcT1QFGg9EwydQn2fgpVPvq6+j9GbIKmwu+Ip1Hj8IsOnnrp8XWyv3s5nlZ+x9exWWj2t4cfOLdyI8hlofet/aH7zP/FXa9+f9Q4H3q//gC88N9LWpDU5zyiMY953x5CYEXVZP5KRTkKp6zSUCmmq6mDrH49TXdYKQFyqnXnfHUP2uIR+j7lQaeK4hHEsyF7AguwFjEsYd003ZRNCCCGEEEIIcZUpge7w6dzKpx4tZiIYzNqwux6z3XWHT5dffdToamRz5WY+q/yMndU78Sre8GN9tbjxVVfT/OZ/0frWWygd2hBBQ2Ii1u88wFHDVE4e1Nrp2GLMzP3maMbMSL2uvzNLKHWdh1KghUzHd9VS/L8ncLX7ABg9LYWb/6IQR9yFG6tVOCv4rPIzPq34lAMNB1BUJfxYuiOdW7NvZUH2AqalTcOkv7QkWgghhBBCCCHENUoJQEt5d+gUmu2usez84VPSmO5Z7pLHacPu4vOvKHzq6VTbKT6t+JTPKj/jUMOhiEblWVFZLMjRijB6TgbmOnyE5tWrcX7wAQS0GfbMo0YRd/8SKmJvYvf7lfg8AXQ6GH9rFjO/mo/FLt+PJZSSUCrM0+Vj17unObzlLKoKJouBm76Sy6TbszGaDBf1HM3uZrae3cpnFZ+xvXo77oA7/Fi0KZqbs27m1qxbuTnrZmLM8nMXQgghhBBCiGteOHw6Fln51FgGfnffxxgs3eFTuPqpCOLzrlr4FOJX/ByoP8CWs1vYXLmZcmd5xOPjE8eHg6jRcaPDlU2qotCxeQvNq1fTtXt3eH/7rFkkPrCUpsQb2f72SZqrtb5WqfkxzP/uWJJzoq/q+Y9kEkpJKNVLQ0U7W/5QSt1pJwDRiVbm3DOaUVOTL6ms0O13s7NmJ59Vfsbmys00u5vDjxl1RqamTmV+1nxuzb6VnJicq/02hBBCCCGEEEIMJiUAzaeD/Z5Cs90d03o+BTx9H2O0Bns+nTPsbgDCp57ave0UVxezuXIz26q2RUzsZdKbmJE+g9uyb2N+1nxSHamRb9Plou2dd2n+3e/wnj4dfB9GYhZ9hcSlS3El5FL8Pyc4c7gJAKvDxOx7RlE0Ox2d/vodqtcXCaUklOqTqqgc313HjnUnw7P0pY+O5eZvFZKSe+k/r4AS4FDjIT6r/IwtlVs42XYy4vGC2ALmZ8/n1qxbmZQ8CYP+4iqzhBBCCCGEEEIMsoA/WPlUEqx+6jHs7rzh0xhtqF2o6XjyWC18GqTvf5XtlWyp3MLms5vZW7sXv+oPPxZriWVe5jzmZ89nbsZcosy9G4/7qqpoXruW1v/5X5Q2LcTSR0cT/+17if/e9whEJfL5n05zeEsVqqLNqjdhQRbTFuVhdchQvb5IKCWh1Hn5PAH2f1zB/g/P4PdpvaLGzkpj1tdHERV/4X5T/al0VrL57Ga2VG5hb13kL4M4Sxy3ZN7C/Oz5zMmYQ7RZShuFEEIIIYQQYtAF/NBy+pxm46XByidv38cYbZA8pjt0CoVQcbmDFj6FT18JcLDxIFsqt7Dl7JZek3Tlx+Zza9atzM+ez6TkSeH+UD2pqkrX7t20vPkm7Zs+1WYABEzZ2SR8/3vE3vNNsNk4vKWK3RtP4+nSvtvmTUxi7jdHE5dqH/g3OoJJKCWh1EXpaHGzc/0pSnfVAmA065l6Zy6Tv5SDyXxlv1icXifbq7RpNbdVbcPpdYYfCw3zm5c1j3lZ88iLybuuZyYQQgghhBBCiKsu4AsOuyuJnPGuqaz/8MlkD/Z8Ghfs+dQzfNIP7vn30OZpo7iqmK1VW3sNyzPoDBFtZHJjcvt9HsXtxrlxI81v/hee0tLwdsecOcR//3tEzZsHej1nDjdR/D8naK3rAiAx08HcbxWed0Z70U1CKQmlLkndaSfb3iqj9pT2P3ZUvIVZi0cxZnrqVRkb61f87K/fz9azW9lydgun205HPJ4dnc38rPncknUL01KnYTaYr/g1hRBCCCGEEOK6EPBB08lgz6dj3UPvmk6A4uv7GJM9cqa7UAgVmzOk4VOIqqqcbD3J1qqtbKncwhcNXxBQA+HHY8wxzM2cy/ys+dyceTOxltjzPp+vpoaWtX+g9f/9PwLBIXo6m43Yr3+NhO99D8vo0QA0VXVQ/D9lVJa0AGCLNjHzawUUzc1AL32jLpqEUhJKXTJVVTmxt54db5+kvVmbKSE5J5rZ3xhFdtHVTYMrnZXhXy576vbg6/GL0m60MztjNvOy5nFz5s2k2FOu6msLIYQQQgghxIjk90Lzych+Tw2h8Mnf9zEmR3f4lNIjgIrNHhbhU08uv4vdtbv589k/8+eqP1PVURXx+Oi40eHRNv0Ny+tJVRS6du6k5Q9/pP3TTyGghVqmzEzi//IvifvmPRhitTCrvdnN5xtPU7qjBlUFvVHHpNuyuekreVhsA9eY/VoloZSEUpfN7w3wxaeV7H3/DD6P9j9t1rh4Zn9j1GU1Q7+QTl8nO6t3srVqK1vPbqXR1Rjx+LiEcdySeQu3ZN3ChKQJF/zFI4QQQgghhBAjmt+rBU3nVj41n7xw+JRSFFn5FJM17MKnnirbK8Mh1O7a3Xh6NFQ3683MSJ8RDqIyozIv6jkDbW20rltH6x/+iPfMmfB2+6xZJHz/e0Tdeis6g9auxt3hY88H5RzeXEXAr/WVGjUlmdn3jCY22XYV3+n1RUIpCaWumKvdy573yzm8tQrFr/01GTU1mZlfKyA+zTEgr6moCiXNJWyt1MYJH2o8hEr3X9FoczRzM+ZyS9YtzM2YS6ItcUDOQwghhBBCCCEGnN8THHZXck7l00noMVQtgjm6j8qnscM+fArxBrzsrdvLn6v+zJ/P/plyZ3nE42mONK0oIfMWZqbPxG66+IbirkOHaFn7B5zvvYfq0cItvcNB7Ne/Tvx3v4OlsLD7PNx+Dn5ayf6PKvC6tZ915pg4Zn1jFGn55x8KKC5MQikJpa4aZ6NLK2PcVQsq6PQ6iuakM/2u/Cuaqe9iNLubKa4q5s9Vf6a4qjiiWboOHTcm3sjNWTdzc+bNjE8cj2GQZ30QQgghhBBCiAvye7TKp3Nnuztf+GSJ6bvnU0wmjLBJoqo6qsLf63bV7MLld4UfM+qMTEmdEg6iRsWNuqRJsBSXC+ef/kTLH/6I+8iR8HbLuHHEf/e7xN59F3pHd1FFwK9wdFs1u98rx+XUmr0nZUcxe/Eosm9IkAm4rhIJpSSUuuqaqjrY+c4pyg9qw+sMJj0TF2Qx9c5crA7TgL++X/FzuPEwW89qVVQlzSURj8eYY5iTMYe5mXOZmzGXZHvygJ+TEEIIIYQQQoT53JHD7kIhVPOpC4RP43oPvYvJGHHhU4jb72Zv3V62VW2juLq410RXSbakcIuWWemziDZHX/prHD9O61v/Q9s776A4teIFnclE9Fe+TPx3v4tt8uSIgElVVMr21LHr3VM4G7UeyjHJNmZ9rYDRN6VclQm+RDcJpSSUGjA1J1rZsf4kNSe0GQssdiOTv5TDxAVZmK2D1++poauBbVXb2Fa1jR01O2j3tkc8PjZ+LDdn3szczLlMTp6MyTDwwZkQQgghhBDiOuBzQ1NZ5JC7hmPB8Enp+xhLbHC4XY/qp5QiiE4fseFTiKqqlDvLKa4qZlv1NvbU7onoDWXQGZiUPIm5mXO5JfMWxiWMu6yKJKWzE+f779P61v/g+uKL8HZTVhbx3/k2sffcgzEhcpIuVVUpP9TErndP0XS2AwB7jJnpd+VRdHMGBsPwH/I4EkkoJaHUgFJVlTOHm9i5/iRNVZ0AWBxGpnwphwm3Dm44Bd1VVNuqtlFcVcyRpiMRvagcJgcz02YyJ2MOczLnkB2dPajnJ4QQQgghhBiBfC5oPK5VO4WH3h2DltP9h0/WWEgu6lH5NFa7H5024sOnntq97Xxe+znbq7ZTXF3ca6a8VHtquEhgZvpMYsyX9/1cVVXch4/Q+tZbOP/0J5RO7fsnRiPRCxYQd++3cMydi+6cflqhMGr3xtM0VGgFDGargSl35jLptmxMFmn9MpAklJJQalAoikrZ7jr2vFdOa10XoIVTkxfmMPHWLMxDNHVms7uZ7dXbKa4qZnv1dprdzRGPZ0dnawFVxhxmpM0gyhw1JOcphBBCCCGEGAa8Xd3hU6jfU30JtJQD/XxlDoVPKeMi+z5dY+FTSEAJcKTpCNurt7O9ejsHGw4S6DEk0aQ3MTV1KrdkapNSXWpvqF6v53TStmEDrf/zv3hKulu3mHJziPuLvyBu8WKMyb1btqiqSvnBRnb/qTwcRhktBibemsmUL+VijZIRNINBQikJpQbVcA2noHtGv1BA9UX9F/jV7mlUjTojE5MnhvtRFSUUScN0IYQQQgghrkXh8CnU8+mYFkK1nKH/8CkustdTKISKSr0mw6eeajtrw9+jdtbsjJh4CiAvJo/ZGbPDF/svZaa8vqiKQtfuPbS9/TbODz9EdWu9n3RmM9F33EHcX/wF9pkz+gy7QmHU5xtP01ipDdPTwqgsJn8pG1uU+YrOTVwaCaUklBoSiqJyYk8du//UI5yyB8OpBUMbToV0eDvYXbs7nPBXtFdEPB5riWVm2kxmZ8xmdsZsMqMyh+hMhRBCCCGEEJfF26mFT+f2fDpf+GRLiBxuF+r9FJVyzYdPIR3eDvbU7WFH9Q521Ozo1aA82hTNzPSZzMmcw+z02WRFZ12V1/WePUvbuvW0rV+Pr6p7GKClcDRx3/oWMV/9Ksb4+D6PVVWV0180svtP3WGUyWJgwoIsJi+UMGqoSCglodSQ6j+cymbCrVlY7MOnZLKyvZId1TvYXr2dXTW76PB1RDyeHZ3N7HQtoJqeNp1YS+wQnakQQgghhBAigrezu89TuPLpGLRW0G/4ZE/su+eTI+m6CZ9CfIqPw42H2Vm9kx01OzjUcChiVIlep2dC0oRw65PxSeMx6q9OoYHS2Ynzo49pW7eOrs8/735Nh4OYRYuIvecbvWbQ60lVgmHUexJGDUcSSkkoNSwoisqJvXXs+VM5LbVaOGWyGrjxlkwm356NI84yxGcYKfRLeUf1DnbW7Ow1Tlqv03Nj4o3MSp/F7IzZMqufEEIIIYQQg8HTAY2l5zQcLwmGT/2wJ/UInXrMdudIGrzzHmZUVeW083T4+87u2t10+joj9gldlJ+VMYsZaTOu6kV5VVVx7dlD69vrtOF5Xdp3RHQ6HLNnEfuNbxC9cCF6m63f5wj4FY5/Xsv+jyq6v2NaDExckMXkhTnSM2qYkFBKQqlhJRRO7X3/DM3V2i89vVHH2JlpTPlSDvFpjiE+w76FhvrtrNnZZ/mqzWhjaspUZqbPZGb6TMYljEOvkylFhRBCCCGEuCyejh6VT6GG48eg7TzhkyO5d7+n5HHXdfjUU11nHbtqd7GrZhc7a3ZS31Uf8XjP9iWz0mddtSF5PXnLy2nbsJG2d9/FV1kZ3m7KzSHuG98g9mtfw5SRcf7ncPs58udqvthUSWerBwCzzciE+ZkSRg1DEkpJKDUsqarKmcNN7PvwDDUn2rSNOiiYnMzUO3NJzRvef2a1nbVaQBW8snDurH6xllhmpM1gZpoWUuXG5F7RjBNCCCGEEEJckzzt3eFTuPLpGLRV9n+MI6X3kLvkceBIHLzzHgHaPG3hC+u7anZR7iyPeNykNzE1ZSqzMrTRH+Pixw3IRE/+piac771P28YNuL84GN6udziI/sqXifvGN7BNnXrB70tdTi8HP6vk8JYqPF3a0EJHrJlJt+dw4y0Zw6JvsehNQikJpYa9mpNt7PvwDOUHG8PbMsfGMfXOXLKLEoZ9mKOqKmWtZeyq0a467Knb06v0NdWeysz0mcxKn8X0tOmkOdKG6GyFEEIIIYQYAm5nZM+nUN8n59n+j4lKjWw2Hpr5zp4weOc9gnT5ujhQf4CdtVoIVdJUgtqjn5Zep+eGhBvCozumpEzBarQOyLkoLhftmz6lbcO7dG4rhkCwFYpej2PuXGK/erc2PM9+4Vn6nI0u9n9cQcn2GgI+BYC4VDtT7shh7Iw0DCYZoTKcSSglodSI0VTdwYGPKjj+eR2Kov11TMqOYvLCHEbflILBODJ+2fgUH0caj2ghVe0uDtQfwKf4IvbJjclletp0ZqTNYHradJJsUlIshBBCCCGuAe623v2eGkrBWdX/MVFpkDxGC59SxnWHUBI+nZfb7+aLhi/4vPZzdtfu5lDjIfyKP2KfgtiCcAg1PW06MeaB+26sBgJ07tyJ890NtH/8MUqoTxRgHT+e2K99lZivfAVjcvJFPV9duZMvNlVyYm89avD7YUpeDFPvzCF/UjJ6/fAuXhAaCaUklBpx2pvdfPFJJUe2VeH3akm4PdbMhPmZ3HhLJrbokTV7gsvvYn/9fnbV7OLzms852nwURVUi9imILWBG2gxmpM9gWuo04q19T3MqhBBCCCHEsOBqjQydQiFUe3X/x0Sn9658Shoj4dNF8gV8HGw8GA6hvqj/Aq/ijdgn3ZGutREJBlEp9pQBPSdVUXAdOIDzT+/h/OhDAg3do19MWVlaEHX3V7EU5F/U8ykBhZP7Gzj46VlqT7WFt+fckMCUO3PJHBM37EfSiEgSSkkoNWK5O3wc3nqWQ5ur6HJqv2wNRj1jZqQy8bZskrKihvgML0+7t529dXvD/5iUNpdGlNUCjIkfw4w0LaC6KfUm4qxxQ3OyQgghhBDi+uZq6dHzqcfQu/aa/o+JzujRaLxHCGWLG7TTvhb4Aj4ONx1mT+0edtfuZn/9ftwBd8Q+ybZkZqTPCI/AyIrKGvDQRlVV3IcP43zvfZzvv4+/tjb8mCE2luhFXyH2q1/DNmXyRZ+Lu9PH0W3VHNp8lo4WrXm53qCjcFoqk27PJjknekDeixh4EkpJKDXiBfwKJ/bWc/DTSurPtIe3Z46NY+KCbPImJo3o0s1Wdyt76vaEQ6oTrSd67VMYX8j01OlMS9NCqgSrXE0SQgghhBBXkaslMnQKhVAdtf0fE5PZx2x3Y8EaO3jnfQ3xBrwcajykhVB1WiXUuSFUgjWBaanTwsPx8mLyBqVySFVVPMePaxVR778fMXOe3uEgeuFCYhZ9Bcfs2ejMFz+ypbm6k4OfVVK6sxZ/sF+ULdrEjfMyGT8vE0es5aq/FzG4JJSSUOqaoaoqtae0ccWnDjSExxXHJFmZuCCbcXPSsVwDMy40uhrZU7uHPXXaFZFTbad67TM6bjTTUqcxLW0a01KnkWiTmUaEEEIIIcRF6GqODJ1C6x11/R8Tk3XObHcSPl0NnoCHgw0H2VO3hz21e/ii4Qs8AU/EPvGW+PCF6RlpMxgdN3rQhq+pqor3xAmcH3yI8/338Z7q/l6is9mIXnArMYsW4bjlFvSWiw+PVEWl4mgzX3xaSeXR7lnMk7KjmLggm8LpKRhNV38WQDE0JJSSUOqa1N7s5vCWsxz5c3V4OlCjxcCYGamMvyXzmirvbHQ1srdubzio6quSKj82n5tSb9KWlJtIj0ofgjMVQgghhBDDRih86tlwvP4YdNb3f0xMVo+Kp3HdPZ+s8n3qauj0dfJF/RfsqdvD3rq9HGo81GtCpFAl1LS0aUxPnU5BXAF63eBN+KSqKu6jR2n/6GPaP/oI7+nT4cd0ZjNR8+cR85WvEHXrrRc1c15PrnYvJdtrOPLnKpyNwQowHRRMSmbibVlkFEq/qGvRsAql/vVf/5V/+Zd/oba2lkmTJvHqq68yY8aMPvdds2YNDzzwQMQ2i8WC2+3uc/9zSSh1ffB5ApTuquXgp5W01HbP7pCSF8ONt2RQOD0Vk/naStmb3c3hkGp33W7KWsp67ZPhyOgOqVJvIjcmV37BCyGEEEJcizqbgs3Gz6l86mzo/5jY7HOG3BVps99Zrp0Lu8NBq7uVffX72Fu3l311+yhpLiGgBiL2SbIlMS11GtPTpjMtdRr5sfmD/rldVRTcBw/iDAZRvrNnw4/pTCYcc+cS/eU7ib79dgzRl/Z3RFVVak60cnhrNSf316P4tdjBbDVQdHMGE2/NIibJdlXfjxhehk0o9d///d/cf//9vPHGG8ycOZOXX36Zt956i9LSUlJSes8IsGbNGpYvX05paWn3Sep0pKamXtTrSSh1fVFVleqyVo5sreLk/gaUQPCXnc3I2Flp3HhLBokZI7Mx+oW0edrYV6f9Y7e3bm+f/9glWhOZmjqVm1JvYkrKFMbEj8GoH/lDHYUQQgghrhudjcGqp1DwFJzxrqux/2Nic4LBU6jZ+DgJnwZQbWct++r2hYOovkY4ZEZlRlw8zonOGZKLx2oggGvfPpwffkT7xx/jr+sevqmzWomaN4/oO+4g6tb5GKIu/XuUu9NH6a5ajmytiiweyI3mxnmZFE5LxWS5tooHRN+GTSg1c+ZMpk+fzq9//WsAFEUhOzubxx57jCeffLLX/mvWrOHxxx+ntbX1sl5PQqnrV5fTy7Ed55SFAumjYxk/L5NRU1IwmAavBHawdfm6ONBwIBxSHWo41GuqWLvRzqTkSUxJncLUlKlMSJqA3XRp5bdCCCGEEOIqU1UtfGoo6Q6dQkPvupr6Py4u95zKp3HasDvLtXlRdjhQVIUTrSfYX7efffX72F+/n5rO3jMSFsQWRIRQaY60IThbjeJy0bl9O+2bPqVj82YCzd39nPQOB1G33qoFUbfcfMlD80ArFKgrd3Lkz9Wc2F0XblxuNOsZM0MrFEjJle/m15thEUp5vV7sdjv/8z//w+LFi8PblyxZQmtrK++8806vY9asWcNDDz1EZmYmiqIwdepUfvnLX3LjjTf2+RoejwePp7spnNPpJDs7W0Kp65iqqFQea+bI1mpOH2wMN0a3OkyMmZHKuDnpJGdf+1eJPAEPhxsPs7duL/vr93Og/gAdvo6IfYw6I0WJRUxJ0UKqSSmTSLIlDdEZCyGEEEJc41RVG17XM3QKhVCu5n4O0kF8bnfoFAqhksaA2TGop389cvvdHGk6wv76/eyr28eBhgO0e9sj9jHoDIxLGKd9pk6dytSUqUM+IZG/uZmOzzbTvmkTndu3o/Zoh6OPjSV6wQKi77wDx5w5l9SsvCdXu5fjn9dRsqOGprPd3zMSMx3ceEsmY2amXRMTUonLMyxCqerqajIzM9m+fTuzZ88Ob/+Hf/gHtmzZwq5du3ods2PHDsrKypg4cSJtbW2sWrWKrVu3cuTIEbKysnrt/8wzz/Dzn/+813YJpQRAR4uHku3VHN1WTUdLd3iZlB3FuFnpjJmZii3q4qcuHckCSoATrSe0Kzp1+9lbv5f6rt4NL7Ojs5mSMoVJyZOYnDKZ0XGjB7XJohBCCCHEiKeq0FHfY8hdj75P5w2f8vqufDJLZftgaehq4EDDAQ7Ua8vR5qP4FX/EPjajjUnJk5iaMpUpqVOYmDRxWIw+8JaX077pU9o//RTX/v2gKOHHTBkZRN1+O9G334b9ppvQmUyX9RqBgELFkWaOba+h/FBjuH2Kwahn9LQUbrwlk7SCGOlrK0ZuKHUun89HUVER3/3ud3n22Wd7PS6VUuJiKAGFypIWSrbXcPpgQ7jRnt6gI29iEuNmp5N7YwJ6w/UTvqiqSk1nTTik2le/j5OtJ1GJ/JUQbYpmYvJEJqdMZnLK5GHzj64QQgghxJBTVeio691svOEYuFr6OSgYPqUUdfd8ShkHiYUSPg2y0EXbA/UH2N+gjSyo6qjqtV+oT2uoEmps/Nhh0adV9fno2refji1b6NiyBe/JkxGPW24oIvr224m+/XYsY8deUVDUVN3Bse01lH5eh8vZ3SIkJTeacbPTKZyeitVxeUGXuDZdbCg1oP8nJSUlYTAYqOvRPA2grq6OtLSLG1NrMpmYMmUKJ070bhYH2sx8lsssNxTXD71BT+74RHLHJ+Lu8FG2p46S7TU0VLRzan8Dp/Y3YIsxM3ZmGuNmp12zzdF70ul0ZERlkBGVwd0FdwPg9Do52HBQuzLUcICDDQdp97VTXF1McXUxAHqdnjHxY5iUPIlJyZOYmDxxyBo1CiGEEEIMClWF9tq+K5/crX0fo9MHK5+C4VMohEoaAyaZdWwotHna+KLhCw42HOSLhi841HiITl9nxD46dIyJH8PklMlaL9aUKWRGZQ6bz7r+piY6tv6Zji1b6CwuRmnvMZTQaMQxYzpRt91O9G0LMGVkXNFruTt9lO2u49iOGurPdL+OLdrEmJlpFM1OJzHz2v/eJAbWoDQ6nzFjBq+++iqgNTrPycnh0Ucf7bPR+bkCgQA33ngjixYt4sUXX7zg/tLoXFyKpqoOSnbUcHxXLa52X3h7ck40hdNTKZyWQlS8dQjPcGj5FT9lLWVaT6qGA3xR/wXVndW99ou3xDMxeSITkycyKXmSNFAXQgghxMikqtBe06PnU48Qyt3W9zE6PcTnR1Y+JY+FpEIJn4ZQqArqi4YvwkFUubO8134Ok4OJSZGjAqLMwydoUVUV99GjWjXU5i24Dx3S/p4GGeLjiZp3C1Hz5+O4+WYMV/gd2O8NUH6oibLddZQfbuweYaLXkTshkaI56eSMT8RwHY0wEZdnWAzfA/jv//5vlixZwm9+8xtmzJjByy+/zP/7f/+PY8eOkZqayv33309mZibPPfccAP/0T//ErFmzGD16NK2trfzLv/wL69evZ+/evdxwww0XfD0JpcTlCAQUzhxq4tiOGs4cakIJNkdHBxmj4xgzI5VRU1KwRklJal1nXcQ/7kebjvaa5U+v0zM6bnQ4oJqYPJH82HzpTSWEEEKI4UFVwVndx2x3peA5T/iUUBDs9XTOsDvT9XsRc7hodDVyqOEQhxoPcbDhIIcaD9Hl7+q1X15MXvhC6qTkSYyOG41BbxiCM+6fv6WFzu3b6dxWTOe2bfgbGiIet9xQRNT8+UTPn491wgR0his7fyWgcPZYC8d313HqQAM+dyD8WGJmFEVz0hkzIxVb9PXRi1dcHcNi+B7At7/9bRoaGvjZz35GbW0tkydP5oMPPiA1NRWAiooK9PruL6otLS384Ac/oLa2lvj4eG666Sa2b99+UYGUEJfLYNBTMDmZgsnJuDq8nNzXwPHPa6k50UZ1WSvVZa1s/cNxcm5MoHBGKvkTkzFZhtc/XoMl1ZHKHY47uCPvDgC8AS/Hmo9FlELXdNZwvOU4x1uO89bxtwCIMkVxY9KNTEyayISkCUxIniAz/QkhhBBiYKkqOKt6DLfrGT45+z5GZ4DEUZFVT8njtMono7QNGQ7cfjclzSXh8OlQw6E+q/ntRjsTkid0t51ImkicNW7wT/gCVL8f18GDdPz5z3RuK8Z9+HBENZTObscxezZR8+cRNX8+puB36St6TVWl9pSTss9rObGvPmLUSHSClcLpqYyZkSrD88SAG/BKqcEmlVLiampvdlO2p46y3XU0VnZPc2o068mflEzh9FSyi+Ixmq7PgKo/9V314YDqYMNBSppLcPldvfbLcGQwIXmCFlIlTWBcwjgZ9ieEEEKIS6eq0HY2GDiV9AihSsHb3vcxOgMkjo7s95Q8Ttsm4dOwoagKp9tOc7jxcLgKqqylDL8aOSOeDh0FsQVMSJ4QroQaFTtq2FVBhfiqqugIVkJ17twZ2RsKsBQW4rjlFqJunott2jT05iuvUlJVlcbKDk7sradsdx3tze7wY7ZoE6OnplA4I01mzxNXxbAZvjfYJJQSA6W5ppOy3XUc312Hs6E7YDFZDeSNT2TU1BRybky8biuozsev+DnReiLiataptlO9ZvoLDfsbnzSeGxNvZELSBEbHj8akl2GTQgghhCAYPlWeM+QueOvt6PsYvRESRmlD7ZKDS0qRts0ow5GGk9Ds0IcaD3Gk8QiHmw5ztOlor2bkoM2INyF5glaFnzyB8Ynjh1UvqHMF2tro3LWLrp076dy+A295ecTjhthYHHPn4Jh7M46b516VaijQfqZ15U5O7Wvg5P56nI3dQZTJYqBgSjJjpqeSNS7+upqJXAw8CaUklBIDRFVV6svbKdtdx8n99XS0eMKPGU16csYnMmpKMnkTkjDbhn6q2OGqw9vBkaYj4StehxsP0+Bq6LWfxWBhbMJYxieOZ3yStuTG5Ep/KiGEEOJapijgPBs55K6+BBqPnz98ShzdI3gK3kr4NGw1uZo40nSEI43aZ8IjTUdodjf32s9mtFGUUBRuATExaSJpjrRhXc2juN249u2jc8dOOnfswH3kSMSQPPR6bJMm4bh5LlE334x1/Pgr7g0Vfm1FpfZkGyf31XPqQEPv7ys3JlI4PZW8CYkYzXJBXQwMCaUklBKDQFVU6s70feVBb9SRU5RAwZQU8iclYXVItc+F1HXWcbjpcMQHk/Y+Su4dJgdFCUXckHgDNybeyA2JN5ATkyNBlRBCCDHSKAq0VXTPdFcfmu2uFPqojgFAbzpn2F0wfEocBQb5vDVcNbubOdp0lKNNRznSeISjzUep7azttZ9RZ6QwvpDxSeOZkDSBG5NupCC2AKN+eF/sVf1+3EeOaCHUzp249u1D9UZOBmQuKMAxezaO2bOwz5hxxTPl9aQEFKqOt3JyfwOnDjTgcna/tsliIG9CIgVTUsgdLyM7xOCQUEpCKTHIQmO0T+6v5+S+Blrrumf70Ol1ZIyOJW9iEnkTkohLlb5JF0NVVSraKzjceDi8HGs+hjvg7rVvlCmKosQibki4gRuTtKAqOzpbgiohhBBiOFAUaD0TOdwuVPnk6z1DGqCFT0mFkTPdJY/TZsCT8GlYa3W3auFT05HwbU1nTa/9dOjIi81jfOJ4bkzSWjeMTRiLxTD8e3qpPp8WQu3eTdfnu3Ht3YvSFfl32ZiaimPWLOyzZ+GYPfuqDckL8XT5qDjSzOmDjVQcacLT1d1ny2I3kjcxiVFTksm+IUF64IpBJ6GUhFJiCKmqSnNNJ6f2N3ByXwNNVZFl5nGp9mBAlUj6qFgZv30J/Iqf022nIz7klDaX4gl4eu0bZYpibMLYcFVVUUIRebF5w/5KmxBCCDFiKQq0lvfR8+k49DHpCQAGMyQWntNwvAgS8iV8GuZUVaXB1UBJUwlHm49yrOkYJc0lfQZQAHkxeRGV7kWJRThMjkE+68sTDqE+303X55/TtW8f6jkhlD42Fvv0acFqqNmY8/Ov+hDD1vouyg82Un6okZqyNhSl++u8NcpEwaQkRk1NIXNsPAajfMcQQ0dCKQmlxDDS1uAK/+NRXdaKEuj+385iN5JzYyL5E5PIuTEBi10+fF0qv+LnZOvJcEhV0lTCseZjeBVvr32tBitj4sdQlFhEUUIRRYlFjI4bjdkgvSaEEEKIi6YEoKW8j8qnsvOHT0ljukOnUAgVnw8GuWA03KmqSlVHFSXNJZQ0lYRvm9xNfe6fG5MbGUAlFA3rRuTnUlwuXAcP4dq3l649e+nav7//EGrGDOwzZmAZMwad/uoGQUpAofaUM/xdoqU28hzi04IXuycmkVYQi14/fPtsieuLhFISSolhyuPyU3m0mfKDjZw53IS70xd+TK/XkTYqluwbEsi5IYHk7Gh08g/LZfEpPk63nY740HSs+Rhd/t5DBIw6IwVxBYxLGMfY+LHabcJYYi2xQ3DmQgghxDASDp+ORVY+NZaBv/dwegAMlu7wqeeMdxI+jRi+gI+TbSc51nyM0uZSSppLON58nHZf716fep2egtiC8MW+ooQixiWMG1EBFIC/pQXXvn107d1H1949uI8cBb8/Yh9DbCz2GdOxT58+YCEUQEeLh4qjTVQebabyWDOezu7z0Ot1ZIyJI29CEnkTE4lNlrYgYniSUEpCKTECKIpK7ak27crHwd5XPmzRJrLGJZBzYwLZRQk4Yof/+PrhTFEVKpwV4ZDqaPNRSppKcHqdfe6f7khnbIIWUo2L14KqzKjMYT3TixBCCHFZQuFTfUmw0XhwOV/4ZLQGez6FhtyN0yqf4nIlfBpB2jxtHG85zrHmY+EQ6mTbSfyKv9e+Rr2RwrjCcOVTUWIRhfGF2Iy2ITjzy6eqKr6KCrr278e1dy9de/fhPXWq137GlBTs027CNmUq9hnTsRQWDkgI5fcFqC5rpeJoM5VHm2mujmzyb3EYyR2fSN6EJHJuTMQiM3yLEUBCKQmlxAjU1uCi8mgTFUebOVvags8diHg8MSuKnGAVVfqoOAwmGSd+pVRVpbazVvsg1qJ9EDvWfIyqjqo+93eYHIyJH9NrsZvkKpUQQogRIOAPVj6V9JjtrlRrON5Hf0YgGD6Niez3lDwW4vNAL82TRwq/4qfCWcHxluOUtpRqt82l1HXV9bl/tDlauzAXXMbGj6UgtgDTCOzzpXR24jp0CNeBL3AdOIDriy8ItLT02s88ehT2qTdhv2kqtptuwpQ5MBcjVVWlpaYrXA1VVdZKwKd076CDlNyY8Of+1PwY6UErRhwJpSSUEiNcIKBQd6qNiiPNVBxtpqEislzaaNKTPjqWzLHxZI6NJyUnWv6xuoqcXifHm7UPbaGhf/1dNQTIjs5mTPwYxsaPZUz8GArjC8mKzpLZ/4QQQgyNgB9aTp/TbLxUq3zqN3yyQfKY4HC7HjPexeVK+DTCtLhbKGspiwigTrae7HNiGIAMR0Z3+BSsEk93pI/I6nBVVfGeLsf1RTCAOnAAT1mZ1oS/B53JhPXGG7HdNBX7TTdhmzIFY3z8gJ2Xs9HF2dIWqoJLZ1tk71NHrJnsGxPJuSGB7HEJWKNGXvgnRE8SSkkoJa4xXU4vlSVaSW9FSTMuZ+Q/ZCargYzRcWSOjSdrbDyJWVHS6PAq8yk+ytvKwx/ujjcf53jLcRpcDX3ubzPaGBU7itHxoymMK6QwXlsSrYkj8kOeEEKIYSjgg+ZTPaqegpVPTWUQ6D3hBxAMn0LD7Xr0fIrLkfBphHH5XZxsPUlZSxllrWXabUtZv83HbUYbhXGFjEkYE76YVhhfSLQ5epDP/Orx1dfjPnQI16FDuA8dxnX4MEpbW6/9jBnp2CZNwj55MrbJk7EUFaE3D9xENx0tbqpKWzh7vJWqYy20N0cOgzUY9WQUxpJ9gxZEJWQ45POhuKZIKCWhlLiGqapKc3UnVcdbOHusheqyVjxdkRU8FruRjEItpMoojCMxU0KqgdLsbo4IqUJXI/ua/Q8g3hJPYXwho+NGMzp+NKPjRjMqbhQxZvmdJYQQoh8BHzSdjOz3VH8Mmk6A4uv7GJP9nGF3ofApFwagL44YOL6Aj3JnOSdbT3Ki9QRlLWWcaD1BZXslKn1/ncuKyqIwvpCxCWPDAdRIr+IOOJ24Dx/GdegwrkMHcR86jL+u9/BDndmMdfx4bJMnY5s0CdvkyZhSUwb03Dpa3NScaNM+n5e20FYfOQulXq8jJS+GzLFxZI2NJ60gFqNZQmBx7ZJQSkIpcR1RFJWmsx1aSfBxLaQ6tx+VyWogvSCW9NGxpI+KIyU/BpP8QzhgAkqAivaK8AfH0IfHivYKFFXp85gUWwqj4kaFl1BYNZKvXgohhLhEfm+w8qmkR+VTKHzqewg5Jntkr6dQCBWbI+HTCOML+DjjPMOJthOcbD0ZXiqcFfjVvv/8E6wJWjV2qCo7rpBRcaNGfL/LQGsr7pIS3EeP4j5yFPeRI3jPnOm9o16PZdQorBMmYJswHuuEiVjHFKIbwCooVVFpru2k5kQbNSdaqTnR1qsSSqeD5JzocKuN9FGxmK1D26A8EAjg8/UTYgtxiUwmEwZD/98nJZSSUEpcx5SAQn1FO1WlLVQfb6X2VBvec0IqvV5Hcm406aNiSR8dR/qoWGzRA/ePt9C4/W5Otp3kREvwKmfwQ2dtZ22/x6TYUxgVqwVV+bH5FMQWMCpuFPHWget7IIQQYoD5vdB8snfPp/OFT+aoyIqnUO+n2GwJn0YYt9/NGecZTrae5FTbKW1pPcUZ55l+w6coU1T4otXouNHhqutEW+Ign/3V529q6g6fjmoBlK+q70lnTFlZ2CZOwDo+GELdcAN6h2NAzy/gU6g/46TmZDCEOtnWa5SCTgdJ2dFaO41x8WSMjsViHx59oVRVpba2ltbW1qE+FXGNiYuLIy0trc+hpxJKSSglRJiiqDRVdWhXc062UlPW2qu5IkBsso3U/BhS82NJzY8hKSsKg1E+5A6GDm8HJ9tOhsvyQ7f1XfX9HhNviSc/Np9RcaMoiC3QlrgCUu2p0pNACCGGC79XC5pCoVMohGo+eZ7wKbrvnk+xWdo3XzFitHvbw4HT6bbTnGo7xcnWk1R1VPU77M5hcoQvRvWsnL4W/n1XAwG8Z87gOXYMd+lx7fbYsT6H4AGYsrOx3nBDcCnCOn78gDYjBy3AcTa6qStvo+60k7rTThoq21H8kX9eRrOe1HxtFELG6DhS82OGvBKqPzU1NbS2tpKSkoLdbh/xf4/E0FNVla6uLurr64mLiyM9Pb3XPhJKSSglRL9UVaW9yR2+2lN9oo2Wms5e+xmMepKyo0jNjyEtGFRFJ1rlH7JB5PQ6OdV6qteV1OrO6n6PsRlt5MXkkRebR35sPvkx+eTH5pMTk4PNaBvEsxdCiOuI3xMMn0INx0OVTydBDfR9jDk6GDqFht4FQ6iYTAmfRpCAEqC6s5rytnJOt52m3Nl92+hq7Pe4GHNMuPo5VAk9Om40aY6+qw5GmoDTiae0FPexUjzHg7dlZahud++ddTrM+fk9AqgbsBaNwxAbO+Dn6enyUV/eTu3pNurKndSXO3G19x7iZos2hUcXpI+OIyk7CsMImPk6EAhw/PhxUlJSSEwc+VV1Ynhpamqivr6eMWPG9BrKJ6GUhFJCXBJ3p4+6cmf4ilBdeRuezt5XcG3RJlLyYkjOiSY5O5qU3GgccZZr4sPTSNLl66LcWd7r6uv5ek6ANuVzXmxeOLTKjcklLyaPNEfaiG58KoQQg8bn7g6fejYcbz7Vf/hkiekeaheufiqCmAwJn0aQNk8b5c5yKpwVEeFThbOi38lNQOsZmR+Xz6jYUeGq5vzY/GtmNl7F7cZ76hSesjI8ZWW4y8rwlp3AV933BTSdzYZlTCHWMWOxjBuLddw4rOPGDfgQPACv209jZQcNFe00VLRTf8ZJS21Xr/30Bh1J2dHaCIK8GFLzY4hNto3IPy+3283p06fJy8vDZpOLk+LqcrlclJeXk5+fj9VqjXhMQikJpYS4Iqqq0lbv6hFUtdF4tgMl0PtXhi3aRHJ2tBZUBRepqBoaPsXH2faz2tVa5+nwVdvTztO0eXpPjxxiMVjIjs4mLyaPnJgc8mK0wCo3JpcEa4L8WQohrj8+NzSVRTYbbwiFT31PWIElNthofFxk3ycJn0aMLl8Xle2VlDvLOeM8E7G0elr7Pc6sN5Mbq13oyY/NJy8mj4LYAnJjcokyRw3eGxhAqterDb0rK8Nz4oR2e7wMb2UlKH3/P2HMSMc6dhyWsWOwjhuHZexYzDk56M7THPlq8XT5guFTBw2VWgjVWt9FX6MmY5KsWvuKvBhSC2JIzorGYLo2LtaFQqm+QgMhrtT5/n5JKCWhlBBXnd8XoLGyg/oz7do/7mfaaa7pRFV6/xqx2I0k50STmBVFUmYUiZlRxKfbMZpkxr+h0uJuCV/VPd12Ovwhu6K9An9/fU2AaFM02THZ5ETnkB2dTU5MDjnROeTE5FwzV3mFENcxnwsayyKrnhpKoKX8/OFTz+AptB6dLuHTCNDp66SyvZIKZwUV7RUR6+fr5QiQak8NX7QJBVD5sfmkO9Ix6K+NzziBjg6t8unkKe321Cm8J09q4VOg72pAQ2wsljFjsBSOxlJYGF4GY/idqqg4m9w0VXVoy1kthHI29jFMEIiKt0RcSE3Ni7mmJ/uRUEoMpKsRSg3PTmxCiGHJaDKQVhBLWkH3Bwy/L0DT2c7wFaiGinaaqjrwdPk5e6yFs8dawvvq9DriUu0kZTpIzNKCqsTMKKLiZfjfYIi3xhNvjWdKypSI7X7FT01nTTikKm8rD4dV1R3VtPvaOdp0lKNNR3s9p81oCwdU2dHZZEdnkxWdRXZ0Nqn2VIx6+WdGCDFM+FzQeLx35dP5widrrDbM7tzKp+g0CZ+GMVVVafG0cLb9LGfbz1LZXhleKtorztvnCSDOEterajgvJo/s6GzsJvsgvYuBpSoK/poaPOXleMvL8Z4ux3vqJJ6Tp/ptOg6gt9uxFBZiLhyNtWf4lJQ0KJ/lPC5/OHgKh1BVnfg8fYdlMUnW7gAqWNV/LQdQItKaNWt4/PHHR8Ssg8888wzr16/nwIEDF32MTqdj3bp1LF68eMDOazDItwUhxBUxmgzBGfu60++AX6G5WguqQh8YGs924On001LTSUtNJ2V7uq9EWuxGEtIdxKc7tNs0O/HpDgmrBolRbwwHSjdn3hzxmCfgodLZ/UG+59Xkms4aXH4XpS2llLaU9n5enZH0qHQtqIrKCodVWdFZZEVlXTPDGYQQw4y3SwufIiqfguFTP7OdYYsPNho/Z8a7qFQJn4YpX8BHTWcNle2VWvjUcTZivdPXewKXnuIt8eEq4JzonIj1OGvc4LyJAaaqKoGWlu7QqbzHUlGB6vH0e6whOQlLfgHmUQVYCkZhGVWAuaAAY+rgzADocWmfGZuDnxtbartoru6kvbnv6ie9UUdCukOrzs/SluTsaKwO04Cfqxg4S5cu5Xe/+x0AJpOJnJwc7r//fp566imMxmsryvjRj37EY489dlWf87nnnuPtt9/m2LFj2Gw25syZw/PPP8/YsWPPe9xbb73FT3/6U8rLyyksLOT5559n0aJFV/Xcerq2/iSFEMOCwagPX5UKUVWVrjYvjedc3Wqp6cLT5ddmAjwZ2fPIZDEQn2YPB1bxwcAqJtGKfgTMdnItsBgsjI4fzej40b0e8wV8VHVUhcOqM84z4S8DVe1VeBVv+Mp0X2LMMWRGZYaXjKgMsqKzyIzKJN2Rfs1cjRZCDBBvFzSWajPc1QdnumsogZYz9B8+JUBKUY/Z7sZq9x3JEj4NM37FT31XPVUdVd1Le/d6fVc9an9/zoAOHSn2lPCFkNDQ8+wY7SJMjPnaaPOhKgr+ujq8FZX4KivwnqnAW1mJr0K7Vdrb+z/YZMKck4M5Lw9zbm44eLIUFAzOsDtVxdXuo7Wuk+aarogQqrOt/8bxUfGWcMV9qEVEbKptRMyEJy7dl7/8ZVavXo3H4+G9995j2bJlmEwmVq5cOdSndlVFRUURFXV1L9hu2bKFZcuWMX36dPx+P0899RR33HEHR48exdHPxALbt2/nu9/9Ls899xx33303a9euZfHixezbt4/x48df1fMLkZ5SQoghFfArtNRGfhBpru2ira4LpY9eVaDNiBKTZCMu1U5cSujWTlyqHXusWaqrhgFFVajvqu/z6vXZ9rM0u5sv+BwJ1oRwQJURldHrNtocfcHnEEJcA7ydwcApGDqFQqjWCvoNn+yJkaFTKIRyJEn4NEx4A15qO2up7qympqOGms4aqjuqqemsoaqjirrOuvPOJgvaEPLMqMzuStxgVW7oAofFYBmkdzOwAh2d+KrO4quqwnf2LN6zZ/FVVGrhU2Ulqrf/AAedDlN6uhY8hZZ87daUno5uEKpNvC4/rfVd2lLnorWui7b6LlrruvC6+5mxEnDEWUhIt/eopHeQkOGQ6qdLNJJ7Si1dupTW1lbWr18f3nbHHXfQ3t7Ojh07aGlpYfny5WzYsAGPx8P8+fP51a9+RWFhIRA5fK+8vJyCggI+//xzpk2bFn6+l19+mZdeeonTp0+zdetWFixYwCeffMKKFSs4evQokydPZvXq1RHVRa+//jqrVq2isrKS/Px8nn76ab7//e+HH9fpdLzxxhts2LCBTz/9lNzcXP7jP/6D5ORkHnroIXbv3s2kSZN48803GTVqFNB7+N7u3bt56qmn2L9/Pz6fj8mTJ/PSSy8xderUiNe5lOF7DQ0NpKSksGXLFubNm9fnPt/+9rfp7Oxk48aN4W2zZs1i8uTJvPHGG732l55SQogRz2DUk5QVRVJW5JWBQEChrd4VLNnWrqA1V3fSWt9FwKfQWqd9mDmX0WLQgqoUOzHJNmKTbMQkWYlJshGVYEWvly8jg0Gv05PmSCPNkcY0pvV6vMvXRXVHNVUdVZztOBteDy3t3naa3c00u5s51Hioz9eINkWTHpVOuiO4RKWTZk8Lv26yPRmTXj64CjFieDr6rnxqrej/GHtS5HC7UPgUlTx45y16CfV0qu2s7V66aqnpqAmHUI2uxvNWOgGY9CYyojLC1bSZUZlkRWWF16+V2WEDHZ34a6rxVVdrgVNVNb6z3SFUoK3/2XMBMBoxZWZgzs7BnJONKSdHq4DKzsaUnY1+gIMIVVVxd/pwNrhxNrpoa3DhbHQFgygXLuf5QjOITrD2aONgD1bGO7DY5KvqQFFVFZev/0BwoNhMhiv+f9Zms9HU1ARooVVZWRnvvvsuMTExrFixgkWLFnH06FFMpsjPgHl5eSxcuJDVq1dHhFKrV69m6dKl6PXdlXY/+clPeOGFF0hOTuaRRx7hwQcfpLi4GIB169axfPlyXn75ZRYuXMjGjRt54IEHyMrKYsGCBeHnePbZZ3nxxRd58cUXWbFiBffddx8FBQWsXLmSnJwcHnzwQR599FHef//9Pt9ne3s7S5Ys4dVXX0VVVV544QUWLVpEWVkZ0dGXd2G2Lfi7JCEhod99duzYwRNPPBGx7c4774wIBq82+T9dCDEsGQx6EoJXxnpSFZWOVg+t9Vo1VWtd8ENPXRfOJjd+jzZDYGNlR6/n1Ot1RCdaiUm2EZMUDKySrcQk2ohOsGJxGK+JD7cjgd1k73dYIIDT66SqvYrqjmqqO6vDV8+rO6qp7aylxdNCu6+d9pZ2jrcc7/M59Do9SbYkLaTqEValOdJIsaeQak8lyZYkzdiFGGyedmg4Hqx6CvV8KoW2C4RPKUXdwVNo3ZE0eOctAO3LbJunjbquuvASCp7qOuuo7dLWPYH++xWFWA1W0qPSyXBkhG/THGnhYd3J9mT0upE9JEv1+/E3NOCrqcFXXYOvphp/eF1bFKfzgs9jiIvDlJmJKSsLU2amFj5lZ2POyRmUiie/N0B7s5v2ZjfORnc4eHI2unA2uM5b8QRgizH3qm6PTbERm2yTmZmHgMsX4IaffTjor3v0n+7Ebr68v6uqqrJp0yY+/PBDHnvssXAYVVxczJw5cwD4/e9/T3Z2NuvXr+db3/pWr+d46KGHeOSRR3jxxRexWCzs27ePQ4cO8c4770Ts94tf/IL58+cD8OSTT3LXXXfhdruxWq2sWrWKpUuX8sMf/hCAJ554gp07d7Jq1aqIUOqBBx7g3nvvBWDFihXMnj2bn/70p9x5550ALF++nAceeKDf93vbbbdF3P/tb39LXFwcW7Zs4e67777UHx+KovD4448zd+7c8w7Dq62tJTU1NWJbamoqtbW1l/yaF0s+iQshRhSdXkd0gpXoBCvZ4yJT/oBfob3JrVVR1XfhbHDR1qhdtXM2uVD8Km0N2hW8vhgtBqLjLUQnas8fnWglKt4avu+Is0il1SCJMccQkxhDUWJRn493+brCwz5CgVXoS1FNZw11XXXhfiT1XfUc5GCfz6PX6UmyJpHqSA0HVSn2FFIdqaTaU0m2JZNiT5H+VkJcDrczONtdSY/Z7kqhre8+c4DW2yl53Dl9n8aBI3Hwzvs65lN8NLmawr87Q6FTfVc9dZ114W0XEzgBJFoTSXOkke5ID18UyIjKCIdQ8Zb4EX0xSPF48NfV4autxV9Xj7+uFl9dPf7aWnx1dfjr6vA3NIDSz+yOPehjYjClp2PKysKclRkRQJkyMzFc5V4zPamqiqfLT3uTFjq1N7lpb3HTEbrf7MbV7rvg8zjiLMQkWYMX/bTAKRRCmaXqSVymjRs3EhUVhc/nQ1EU7rvvPp555hk2bdqE0Whk5syZ4X0TExMZO3YsJSUlfT7X4sWLWbZsGevWreM73/kOa9asYcGCBeTl5UXsN3HixPB6eno6APX19eTk5FBSUsLDDz8csf/cuXN55ZVX+n2OUMgzYcKEiG1utxun09nn0La6ujqefvppNm/eTH19PYFAgK6uLioqznMB5zyWLVvG4cOH2bZt22UdP5Dkt4MQ4pphMOq1Dz+pvQMERVHpbPWEr+ppV/i0K33tzW5cTi9+T0Drb1Xbe1ggaIGYI9aMI85CVJwFR7xFW48P3o+z4ogzyxW/QWA32SmIK6AgrqDPxxVVodndHA6pegZWoS9VDV0NBNQA9a566l31fT5PiMPkINmWTLI9WbsNrqfYU0iyJZFsSybJloTD5BjRX7CEuCxuZ3CoXWi2u+DQO+fZ/o9xpERWPIUWCZ8GhC/go8ndRENXAw2uBhq6Gqh31dPoaqS+qz68/WL6/YXEW+JJsaeQYk+JCJ1CS6o9FbPBPIDvauAoLhf+hobupb7hnPv1+BsaCFzsNPNGI6a0NC10ykjHmJ6OKT0DU0Y6pvR0jGnpGKL6bjp8pVRFpavdS2erh44WT+Rtqzu87vdeODgzWQxaxXmwNUJssPI8JslGTKIVo1k+/4wUNpOBo/9055C87qVasGABr7/+OmazmYyMjCuadc9sNnP//fezevVq7rnnHtauXdsrTAIihv6FPtcpFxEuX+g5LuV5lyxZQlNTE6+88gq5ublYLBZmz56N93w95Prx6KOPsnHjRrZu3UpWVtZ5901LS6Ouri5iW11dHWlpaZf8uhdLQikhxHVB36PCKnNMfK/H/b4AHc2e8BXBnlcLO1rcdDR7UBSVjhbtw1xdH68RYo0y4Yg1Y4+1YI8xa+sxFuyxketmq/wKHiihoXtJtiTGJ/VdohxQAjS7m6nvqqe2qzaiEiAcXLka6PR1hpdyZ/l5X9dmtJFoTQy/dqKtez3JlkSiNZFEWyIJ1gSsxpHVbFQI3G3d4VP9se4QylnV/zFRab2bjSePBXv//SzExfErflo9rTS5mmhyN9HkaqLR1RhewvfdjbR5LtCTqAej3hgO3lPtqd0VpD0qSVPsKSOuibjicuFvaiLQ2Ii/qQl/YxP+pkYCTc3nbG88/4x159DZbJhSUjCmpWFMTcGUmoYxNRVTWirG1FSMKakYkxLRGa5uYBPwK3Q5vdrS5qGzre/1rjZvvxPHnMsWbequFA9+Zgrdj06wYrFLm4NrhU6nu+xhdIPN4XAwenTvdg9FRUX4/X527doVHr7X1NREaWkpN9xwQ7/P99BDDzF+/Hhee+01/H4/99xzzyWdT1FREcXFxSxZsiS8rbi4+LyveTmKi4t57bXXWLRoEQCVlZU0NjZe0nOoqspjjz3GunXr2Lx5M/n5+Rc8Zvbs2WzatInHH388vO3jjz9m9uzZl/Tal2Jk/E0UQogBZjQZ+q2yAq3SqqtNu9IYurrY11VHv0/B3eHD3eGjqarz/K9pMWCPNmGLNmOLNkes22KC61FmbNEmbFEm9DLV8VVl0Bu0yid7MjdyY7/7dfo6I6oLGlwNEZUF9V31NLmb6PR14vK7tBkGO85TIRJkN9pJsCaEQ6rQErofb40n3hIfvjUZpGm7GCSu1sjKp1AI1V7d/zHR6T0qnnqEULbeFwFE3xRVwelx0uJpocXdQounRZvwwaVN+tDkboq43+ppvWCj8J6MeiOJ1kRS7CkRlZ8p9pTuKlB7MnGWuGHfx0lVVZSODgKtrQSam/E3NxNobiHQ0oy/uUXb1hLapt1Xuvqugu6PzmrFmJysLSkp3es9FlNaKvqYmKsS1Kiqitflx9Xuo6vdi6vdi6vdd86tl67gurvjwsPpwu9FB/bY7urucMX3Ofel0kmMJIWFhXz961/nBz/4Ab/5zW+Ijo7mySefJDMzk69//ev9HldUVMSsWbNYsWIFDz74IDab7ZJe98c//jH33nsvU6ZMYeHChWzYsIG3336bTz755ErfUoTCwkLefPNNpk2bhtPp5Mc//vEln+uyZctYu3Yt77zzDtHR0eG+ULGxsf0+1/Lly5k/fz4vvPACd911F3/84x/Zs2cPv/3tb6/4PfVHQikhhLgIer1OG6YX3/+V4VBPhs5WD53Bq5NdTm94vbPNE7xy6cXnCeD3BHB6Ajgb3Rd1Dha7EYvDhNWhhVTW4Lo1KrgE1y12Ixa7EavdhMl65bOcXO8cJgeOWAd5sXnn3a/L19WrWqHB1RC+Hxoa0+Rqwqf46PJ30dXRdVEBFmizDcZZ43qFVXHWOOIsccRaYomzdK/HWmJl9kFxfuHwqaTHjHfHoL2m/2OiM/qofBoj4dM5FFWh3dtOm6eNVk8rrZ7WiPVWd2t3+BQMoNo8bQTUS5sNS4eOeGs8CdaEiKrMiEpNq3Y/1hI77P49UBUFpb2dgNNJoM2J4mwLrwdaW7uXtrZe9wlc+sxhOrMZQ1IixsQkjImJEevGpEQMiUkYkxIxpqSgj4q67J+X3xfA0+XH0+nH0+XD3aktrg4fnk7twpWrI7Tdj7vDi6fTf9EVTSF6vQ57rBl7TLA6O9aMI7geqsx2xFmwx8iFLXFtWr16NcuXL+fuu+/G6/Uyb9483nvvvV4z753rr/7qr9i+fTsPPvjgJb/m4sWLeeWVV1i1ahXLly8nPz+f1atXc+utt17mu+jbv//7v/Pwww8zdepUsrOz+eUvf8mPfvSjS3qO119/HaDXuYVmHOzLnDlzWLt2LU8//TRPPfUUhYWFrF+//rzN0a+UTlXVS/vtN8w5nU5iY2Npa2vrs2GYEEIMB163n6627iuh4auiHd1XQ8NXRjt8XMLF8Ag6vS4cUlnsJqw91s12IxabEbPNiNlmwGzteT+4WAzopLn7VaWqKp2+zoiqhya3NvwmtN7sbg5/aW31tKKol9bHIMRhckQEVjHmGG2xxPRaj7XEhrfZTfZhXykhLoGrpUfo1COEOl/4FJMZOdwupQiSxoAtbtBOe6ipqoon4KHd247T66TN04bT69QWj7PXeih0avO00eZtu+z/b6NMURHhc6h6MtEarKq0da/HWeIw6IemukVVVVSvF6WjQwuW2jtQOtoJtLejhNeDj3W0ozi1xwLONpQ2JwGnE6WjA67gq4jOZsMYH48hIQFDfDzGhHgM8QkYEhKC69p9Y0I8hsTEiwqaVFXF71PwuvzBJYDX5cfj8uN1+7vXXX4teOrSgidPlx93p3Yb8F3enz2AyWroXT0dXLf3XI81Y7Wb5N9ocUFut5vTp0+Tn5+P1SqtAwCeffZZ3nrrLQ4e7HsiHHHxzvf362KzGamUEkKIIWC2GjFbjf0OF+xJUVRtSGDwSmt4vb9twQ/Iil9FDR3b4QP6nnXwvHRgthgwWY2YrQZMPdetBswWo3ZrNWAKrpvMBowWAyazHpPFiNGix2QOHmsxYDDph93V+sGk0+mIMkcRZY4iNyb3gvv3GtITrKpocWtDe3p+EW71tNLmbcPpcaKihnthVXWcp+dPX+eIdo7RpmiizdHaujk64n6MOQaHyUGUKUqrJgsuUeYookxR2E12qdQabF3NfVQ+lULHeaZxjsnsHnaXMq678skaO3jnPQAUVaHL10WHryN823O909dJu7eddm87Hb6O8Pq5933KxQ+R6ovNaIuoYAzdRlQ8DtJQXdXvR3G7UTq7UF1dKF09F1f3euixzs7g0qUFT52d3bednQQ6O8HvvyrnprPZMMTEYIiJQR8TgyE2FkNcnLb0XI9YYtFbLAT8ilZ97A0EbxW8Hj+dHiVclewrD+ArbcbrrsfnDuD1BPC5/XjdPW8DeD1+fO4ASuDKr9nrdGgXf4IXhKxRZqxRxohqZ0uwwrln9bMMoRNi4HR0dFBeXs6vf/1r/vmf/3moT0cEDUoo9a//+q/8y7/8C7W1tUyaNIlXX32VGTNm9Lv/W2+9xU9/+lPKy8spLCzk+eefDzf4EkKI641er9NK82Mufhaj0JXe0NCBnldyPV1+3F0+vF3+c67+BsJXf70uv/ahXAWvO4DXHeD8HbIunk4HBrMWWhlMWmBlNBswmvQYzXoMJu2x0DZDcDGaDMHb4DZjcH9jcJuxe7veoIu4ry26ETl8Qa/Ta0P0rHHkx164QSVoTdzbve0Rw4ZCYVV/FR+hbT7Fh4oa/lJ+JX/wFoMlHFbZjXbsJnv41ma09bnNZrRhNVq71w3WXttMetN1HWzS1dw91K5nCNVxnikYYrKCodO4yN5P1qGtKvcrftx+N+6AG5fPhSvgwu134/IHbwMubbvfpQ159XVFrPe69XXR6dfC2KtFh45oc3RENWFfFYYxlpheQ2n7m31O9ftRPR4UrxfV60Xt8KA2O/F7GvB5vageL6rPi+J2a+set7bu9qB4gtvcbm09tM0V3Mfl0sIntwu1K7TuBt+VBWzn/Rk5oiAmDl10LETFaIs9GhzRYI9CtUWhWu1gtaNa7ahmG4rJimqyohjMBFQdfp9CILj4fQp+b6D79qyC/1TofiN+b334sasRIPX9poIXkGyGyCriHlXFPSuRLQ5t2Hxom9lqlComIYaZRx99lD/84Q8sXrz4sobuiYEx4MP3/vu//5v777+fN954g5kzZ/Lyyy/z1ltvUVpaSkpKSq/9t2/fzrx583juuee4++67Wbt2Lc8//zz79u27qHGMMnxPCCGunKqqBHwKHpd21djr9vdxdbn7qrLP7ccbuiLtDeDzaF8WfG7tvt+jfZkYajod6I16DAYd+lB4ZdCjDwZWhohbbV2vD62f/76u5+151nV6bVilThe6H9x27v3wPtqJ6/U60GkhpU7XvY5OO1YXvI24r9duQXtO7Wdw7r7a82tfnVTciodOXycd/nY6vB3hCpN2vxZSdfo6cHqddPg76PR2hqtOOn3d656AZ0D/HPU6PRaDBavBitlgxmq0YjFYei9GC2a9GbMhuOjNmAymiG0mvQmT3oTZYMaoN2LUGzHpTRG3Rp0x/FhoMegM2qLXbvU6fcT90LYrCs86m4KB0zmz3XU29H9MbDYkj0NJGkMgZSyBxEKUhAL8FjuKouBX/SiqQkAJEFC1xa/4w4tP8UXc+hU/frX7MW/Aizfg7V5XIu+Hbj0BD26fC6/fiyfgxuf34vG78fg9eP0efAEPHr8bv+JHr4IuuJxvXX/Odr1yzvYe9/WKikEBIwbsOgt2vRW7wYJdZ8WqM2PVmbHpLNqCCavOghUTFp0Ji2rErBoxY8SkGjAqOggEUH0BFL8f1edHDWjr+P0oPj+qP4Dq7/F4j+1KcP+e21QV0OlQdXpAh6rToaIPb1PRgU4fXle1XwoR98PbetxXdYZz1nW9t+mNqGYLGM2oJrN2azChGo3arcGEqg/upzOi6AwoOj0qehT0KKoORQVFASUASkC95F5IA0Fv0IUrco3m0K1e22bWqntNVmOw+lcbst6z4tfUY7vFZsQkw9fFNUKG74mBdDWG7w14KDVz5kymT5/Or3/9awAURSE7O5vHHnuMJ598stf+3/72t+ns7GTjxo3hbbNmzWLy5Mm88cYbvfb3eDx4PN0ffp1OJ9nZ2RJKCSHEMKMqajCw0oZX+H3B255Xw709boOPB3wKfn/o6nkg4kp6wK9o+wQfD/hDixpev9x+XOJSdP+Qdefcj1hX+9qu9rjp77hzHwNdf3+wfWzud9+LOfgydol87aFxsad58ed3Ke+kj3372KSe9zl7PKbr/beq1xNG7KPr3kfXx2tJv7QBpzfqelSpakF/qHq1u9q1uxo2oio2WAXbXUEbWU2r3deqZ0Ohk9FiwDACK2GFGAwSSomBNOx7Snm9Xvbu3cvKlSvD2/R6PQsXLmTHjh19HrNjxw6eeOKJiG133nkn69ev73P/5557jp///OdX7ZyFEEIMDJ1eF+6lNZiUQGRIFfArKH4VJaASCGjr2q0S3Kai+BVtW0A9Z1FQlO77qhLcFqwUUBWCjyvBCokAAZ9WHaH4Aij+AGpAQfEHtH0UBTX4vKoSfL7grarSfasGmwqrwS/e2shKrUIinOno0OIXrfwp4jZYiTFwX8a7v/Cr59zvZ7dLe6wPkjWK4SX4f1qo8jBchRhZnajrWfGo1wcrIyMf765y1CocwxWU597vUU3Zq1JTr0Nn6K6+DN/X9az0DFZ7htb1kfd1+u5gSRsSHaok7d5HW9djMGlVpwajVnl6XQ+vFUIIcUkG9JtBY2MjgUCA1NTUiO2pqakcO3asz2Nqa2v73L+2tu8mnStXrowIsUKVUkIIIQQQ/JIFJkvfzWNVvz/YwNdFoLMTxRts7htuANyp9Wjp6tIa/nZ1obgimwJ3921xaX1dXK7Lmq58wBgM6IxGdCYTGI1gMqEzaus6kxmMJnTB7aF1ncGAajKi0xvRGYyoRoN2jN4ARgMYjOj0Bu259XrQ68FgAL0end6g7a8zgEEHOgMY9Np+Oj06Q3DYUXBfdDp0htBwpNAXd31wvKW+O0zT69Dp9MGALbhfaAyiTh8OACITgeC2HlUzPdKCHmFY6BjO2a/HBh1aGnbOF24VFUVVUFQVFYWAuwWl7SxKWzWqsxq1XbvF14kKKETWiSk6wJYI0WkQkw6OVIhJ026NkT2JdDo9OkIhhrauRx98LBhcoIUPOp0Bg06PPrhos7T1Dgv0oSFKvd5v37e60H96bj/nZ6z9WXf/THXhP8tz/kyCfxe0wEX7M0Sv7/Ej1vV86Ujhl498UKfrfjD0Mt2P6SL304Gu53n3HM4afi+64NsN7hcKkKDHexFCCCHE5Rjxs+9ZLBYsFstQn4YQQoghoHg8BNraUJxObRryc6cmd7Z3T0cempo8PKOUNpOU6hnY/kcYDOhtNnQ2K3qLFZ3VEry1oreY0UVss6C3WNCZLeisFnRmM3qzGZ3Fgs4UvDWbgvuYIxeTqXs5975BZnO66lQVOuq7+zw19uj75Gruvb8NsOkgPjc4w91YSAneJo0Bs2PQ34IQQgghxFAb0FAqKSkJg8FAXV3kbDB1dXWkpaX1eUxaWtol7S+EEGJkUxVFC4taWwm0tWm34aWNgNNJwNmG0ubU1tud4fWrGSjpzGb0Doe2REWht9u1dZtNW7fb0dtt6MLrdvQ2bZvebtdCJpsNvdWKzmZHb7Oit1q1qiSppBi5VFWb1S6i2XhwxjtXSz8H6SA+T5vhLmVcdwiVNAbM9sE8eyGEEEKIYW1AQymz2cxNN93Epk2bWLx4MaA1Ot+0aROPPvpon8fMnj2bTZs28fjjj4e3ffzxx8yePXsgT1UIIcRVoKoqalcX/pYWAi0tBJqb8Tdrt4GW4HrosVDw5HRq0zhdLr0eQ3Q0+uBiiIrSbqOj0EdFo4+O0h6PCm0LLg4HekcUeocdg8OBztz31O3iOqGq0F4bnO2uNDKEcrf2c5AOEvL7rnwy2Qbz7IUQQgghRqQBH773xBNPsGTJEqZNm8aMGTN4+eWX6ezs5IEHHgDg/vvvJzMzk+eeew6A5cuXM3/+fF544QXuuusu/vjHP7Jnzx5++9vfDvSpCiGE6IOqKFoFU2Mj/qYm/I1NBJoa8Tc1429qJNDYpG1vaiLQ3HzZ1Us6ux1DXCyGuDgMsT1uY+MwxESjj4nBEBOLITYGQ0wM+uC63uHQetEIcTFUFdproL6ku+IpFEK52/o+RqeH+Hyt8ikcPo2DpEIJn4QQQohhas2aNTz++OO0trYO9alc0DPPPMP69es5cODARR+j0+lYt25duABopBrwUOrb3/42DQ0N/OxnP6O2tpbJkyfzwQcfhJuZV1RUoO/xZWLOnDmsXbuWp59+mqeeeorCwkLWr1/P+PHjB/pUhRDiuqL6/VqYVN+Av6E+eNtjqa/Xbpubwe+/pOfWWSwYEhIwxMdhjE/AkJCAMSEeQ3wChvh4DPFxWujUY9FLpZK4mlQVnNXdPZ/ClU+l4OkvfDJAQoEWPCWP6658SiwEk0yjLYQQQgympUuX8rvf/Q4Ak8lETk4O999/P0899RRG44hvjx3hRz/6EY899thVfc7nnnuOt99+m2PHjmGz2ZgzZw7PP/88Y8eO7feYI0eO8LOf/Yy9e/dy5swZXnrppYhRbANhUP4kH3300X6H623evLnXtm9961t861vfGuCzEkKIa5fS2Ymvrh5/XS2+ujr8tXX46+vw1dbhr6vDV1dHoKlJ++J+kQyxsRiSkjAmJGBISsSYmIQxKRFDYo/1hASM8fHo7HbpoyQGh6qCs+qcnk+h8MnZ9zGh8Klnv6dQ5ZNRJk8RQgghhosvf/nLrF69Go/Hw3vvvceyZcswmUysXLlyqE/tqoqKiiIqKuqqPueWLVtYtmwZ06dPx+/389RTT3HHHXdw9OhRHI6+J1jp6uqioKCAb33rW/zd3/3dVT2f/lxb8aIQQlwHVJ9PC5xqqvHV1OCrrtFua6rx19Tgq61DaW+/uCczGDAmJmJMScGYnNy9RNzXgijpuSSGVCh8CgdPJd2VT95+/r7rDJA4KjjsLtR0fBwkjpbwSQghxPVLVcHXNfiva7LDJV60tFgs4UnP/uZv/oZ169bx7rvvsnLlSlpaWli+fDkbNmzA4/Ewf/58fvWrX1FYWNjrecrLyykoKODzzz9n2rRp4e0vv/wyL730EqdPn2br1q0sWLCATz75hBUrVnD06FEmT57M6tWrI6qLXn/9dVatWkVlZSX5+fk8/fTTfP/73w8/rtPpeOONN9iwYQOffvopubm5/Md//AfJyck89NBD7N69m0mTJvHmm28yatQooPfwvd27d/PUU0+xf/9+fD4fkydP5qWXXmLq1KkX/bP74IMPIu6vWbOGlJQU9u7dy7x58/o8Zvr06UyfPh2AJ5988qJf60pIKCWEEMOM4vHgq6rGV3UWX1UVvrNn8VVXh8Mnf339RVU46R0OjGlpmFJTMKamYUxNwZSWhjElVVtPTcUQH4/OYBiEdyXERVJVaDt7zpC7C4RPeiMkjOoOnZJ7hk8SpgohhBARfF3wy4zBf92nqsHcd4XOxbLZbDQ1NQHa8L6ysjLeffddYmJiWLFiBYsWLeLo0aOYTKaI4/Ly8li4cCGrV6+OCKVWr17N0qVLI1oK/eQnP+GFF14gOTmZRx55hAcffJDi4mIA1q1bx/Lly3n55ZdZuHAhGzdu5IEHHiArK4sFCxaEn+PZZ5/lxRdf5MUXX2TFihXcd999FBQUsHLlSnJycnjwwQd59NFHef/99/t8n+3t7SxZsoRXX30VVVV54YUXWLRoEWVlZURHR1/Wz66tTWtfkJCQcFnHDxQJpYQQYpCpgQC+mlp8lRV4z57Fd7aqO3yqqsLf0HDB59CZzZjS0zFmpGNKz8CUno4pI10LodLSMKamYrjKJcBCXFWKAm2V3U3Gew6783b0fYzeqAVNyWO1YXehECphlIRPQgghxDVMVVU2bdrEhx9+yGOPPRYOo4qLi5kzZw4Av//978nOzmb9+vV9tgN66KGHeOSRR3jxxRexWCzs27ePQ4cO8c4770Ts94tf/IL58+cDWrXQXXfdhdvtxmq1smrVKpYuXcoPf/hDQJvYbefOnaxatSoilHrggQe49957AVixYgWzZ8/mpz/9KXfeeSegTfAWmvytL7fddlvE/d/+9rfExcWxZcsW7r777kv98aEoCo8//jhz584ddv26JZQSQogBoLjd+M6exVtRqYVPZyrwVlbiq6jAW10NPt95j9fb7ZiysrQlMxNTZgamjAwtgMpIx5CQID2bxMigKNBWoYVNETPeHQdfZ9/H6E3d4VOo2XhykdYHSsInIYQQ4sqY7FrV0lC87iXauHEjUVFR+Hw+FEXhvvvu45lnnmHTpk0YjUZmzpwZ3jcxMZGxY8dSUlLS53MtXryYZcuWsW7dOr7zne+wZs0aFixYQF5eXsR+EydODK+np6cDUF9fT05ODiUlJTz88MMR+8+dO5dXXnml3+cITfI2YcKEiG1utxun00lMTEyvc62rq+Ppp59m8+bN1NfXEwgE6OrqoqKi4nw/rn4tW7aMw4cPs23btss6fiBJKCWEEJdJ9fnwnj2Lt7wcb/mZ4G053jNn8NfWnvdYncmkBU7ZWuhkzsrClBkMoLIyMcTFSegkRhZFgdYzPUKnYAjVeLz/vhV6k9ZcPBQ6hUKohAIwmPo+RgghhBBXRqe74mF0g2XBggW8/vrrmM1mMjIyrmjWPbPZzP3338/q1au55557WLt2ba8wCYgY+hf6PK4oyiW9Vl/PcSnPu2TJEpqamnjllVfIzc3FYrEwe/ZsvF7vJZ0HaBPPbdy4ka1bt5KVlXXJxw80CaWEEOI8VFUl0NiI5+QpvOWn8Z4u7w6fzp6FQKDfY/VRUZhysjFn52DOycaUnY05JwdzTg7G1FTp5SRGJkWB1vK+K5/8rr6PMZghsbB3z6eEfAmfhBBCCNEvh8PB6NGje20vKirC7/eza9eu8PC9pqYmSktLueGGG/p9voceeojx48fz2muv4ff7ueeeey7pfIqKiiguLmbJkiXhbcXFxed9zctRXFzMa6+9xqJFiwCorKyksbHxkp5DVVUee+wx1q1bx+bNm8nPz7+q53i1SCglhBAE+zxVVeE5eRLvqVNaCHXyJJ7Tp1Gc/UwrD+hsNsx5eZjzcrXb3FxtycuTaicxsikBrfKp/tg5lU9l5w+fksb0nu0uPh8M8pFDCCGEEFdHYWEhX//61/nBD37Ab37zG6Kjo3nyySfJzMzk61//er/HFRUVMWvWLFasWMGDDz6IzWa7pNf98Y9/zL333suUKVNYuHAhGzZs4O233+aTTz650rcUobCwkDfffJNp06bhdDr58Y9/fMnnumzZMtauXcs777xDdHQ0tcGRHLGxsf0+l9fr5ejRo+H1qqoqDhw4QFRUVJ/h4NUgnxCFENcVNRDAV1mJu6wM74kTeMrK8Jw4ibe8HLW/cli9HlNWFpb8fMz5+cEQKg9zfh7GlBQJnsTIpgSgpbz3bHeNx8Hv7vsYgyU47C4UPBUFw6c8CZ+EEEIIMShWr17N8uXLufvuu/F6vcybN4/33nuv18x75/qrv/ortm/fzoMPPnjJr7l48WJeeeUVVq1axfLly8nPz2f16tXceuutl/ku+vbv//7vPPzww0ydOpXs7Gx++ctf8qMf/eiSnuP1118H6HVuoRkH+1JdXc2UKVPC91etWsWqVauYP38+mzdvvqTXv1g6Vb2IecVHEKfTSWxsLG1tbX02DBNCXB9UVcVfXY0nFDyVlWlB1MlTqB5Pn8foLBbM+flYCvIxF4zCMqoAc8EozHm56C2WQX4HQlxlofCpviRytrvGsv7DJ6O1O3wKVz8VaeGTXoafCiGEEMOd2+3m9OnT5OfnY7Vah/p0hoVnn32Wt956i4MHDw71qYx45/v7dbHZjFzOFEKMeEpnpxY6HSvFXXoMz7FSPMePo3T2PbOXzmrFMmoUltGjsRSOxjx6NJZRozBlZEifJzHyBfzByqeSHpVPpVrlU6DvQFYLn0LD7kIz3o2T8EkIIYQQ14yOjg7Ky8v59a9/zT//8z8P9emIIAmlhBAjRqj6yV1aivuYFj65S4/hq6iEvoo+TSYseXlYCguxjCkMhlCFmLKyJHwSI1/AD82nIquewuFTP0NRjTZIHnNO5dM4iMuV8EkIIYQQ17RHH32UP/zhDyxevPiyhu6JgSGhlBBiWFIVBW/5GdxHj0Ys/TUdNyYnYxk7Fuu4sVjGjsMydgyW/Hx0FxhTLsSwF/B1h0/1PQKophMXET4V9ah8GivhkxBCCCGuW2vWrGHNmjVDfRriHBJKCSGGnOr34zl5KiJ88pSUoHR19d7ZZMJSUBAOn7TbsRgTEwf/xIW4mkLhU31wpruGEi2EajoBiq/vY0x2bdhdKHRK7hk+6Qf3/IUQQgghhLhEEkoJIQaVqqr4zpzBdegQrkOHcB86jPvo0T6bj+usVqxjx2K98QasN2iLZfRodGbzEJy5EFdJwAdNJ4M9n0q7Q6jzhk+OviufYnMkfBJCCCGEECOWhFJCiAHlq6vHfeggrkOHcR86hOvw4T6H4OkdDqxFRREBlDk/H51Rfk2JEcrvheaTfQ+7U/x9H2OOClY8ndPzKSZLwichhBBCCHHNkW97QoirRnG7cR85guvAF7gOHMD1xRf46+t77aczm7UAauJEbBPGYx0/AXNeLjr50i1GIr9XC5p6NhyvP6YFUv2GT9Hd4VNKjwAqNgt0usE9fyGEEEIIIYaIhFJCiMuiqiq+qqruAOrAAdzHjoH/nC/hej2WwkKsE8ZjGz8B28QJWAoLpQG5GHn8Hi18Cvd8ClU+nQQ10Pcx5uhg6BTq9xSqfMqU8EkIIYQQQlz3JJQSQlwU1evFdeQIrn376Nq/H9eBLwg0Nvbaz5CchH3yZGyTJ2ObNAnrDTegt9uH4IyFuEw+d2TlUx6Wf0IAAQAASURBVCiEaj7Vf/hkiYkcdheqfpLwSQghhBBCiH5JKCWE6FOgvR3XgQN07dmLa+9eXIcO9W5GbjRiLSrSAqjJk7BNmowpMwOdfAkXI4HPDU1lkf2eGo4Fwyel72MsMb2H3CWPg5gMCZ+EEEIIIYaRNWvW8Pjjj9Pa2jrUp3JBzzzzDOvXr+fAgQMXfYxOp2PdunUsXrx4wM5rMEgoJYQAwFdXR9eePbj27qNr3z48paWgqhH7GOLjsd00FfuUqdimTNaqoKzWITpjIS6SzwWNZZH9nhqOQcvp84RPscFZ7sZFzngXnS7hkxBCCCHEIFi6dCm/+93vADCZTOTk5HD//ffz1FNPYbzGJkP60Y9+xGOPPXZVn/O5557j7bff5tixY9hsNubMmcPzzz/P2LFj+z3m//v//j/+8z//k8OHDwNw00038ctf/pIZM2Zc1XPr6dr6kxRCXDRfTQ1dn39O5+7ddH2+G19FRa99TLk52KfehP2mqdim3oQ5P0+qoMTw5XNB43FtqF19SXcI1VLef/hkjdVCp3Mrn6LTJHwSQgghhBhiX/7yl1m9ejUej4f33nuPZcuWYTKZWLly5VCf2lUVFRVFVFTUVX3OLVu2sGzZMqZPn47f7+epp57ijjvu4OjRozgcjj6P2bx5M9/97neZM2cOVquV559/njvuuIMjR46QmZl5Vc8vREIpIa4TvupqOj//nK7Pd9O1eze+ysrIHfR6bSjeTVPDQZQxOXloTlaI8/F2dYdPDSXdIVRLOaD2fYwtvrviKTz8rgiiUiR8EkIIIcR1RVVVXH7XoL+uzWi75AvcFouFtLQ0AP7mb/6GdevW8e6777Jy5UpaWlpYvnw5GzZswOPxMH/+fH71q19RWFjY63nKy8spKCjg888/Z9q0aeHtL7/8Mi+99BKnT59m69atLFiwgE8++YQVK1Zw9OhRJk+ezOrVqyOqi15//XVWrVpFZWUl+fn5PP3003z/+98PP67T6XjjjTfYsGEDn376Kbm5ufzHf/wHycnJPPTQQ+zevZtJkybx5ptvMmrUKKD38L3du3fz1FNPsX//fnw+H5MnT+all15i6tSpF/2z++CDDyLur1mzhpSUFPbu3cu8efP6POb3v/99xP1/+7d/43//93/ZtGkT999//0W/9qWQUEqIa5Svrp6unTvo3PU5XZ9/ju/s2cgdDAasN96IY8Z07DNmYJs6FcNVTueFuCLeLmgs7VH5FAyhWs5wwfDp3MonCZ+EEEIIIQBw+V3MXDtz0F931327sJuubAIkm81GU1MToA3vKysr49133yUmJoYVK1awaNEijh49iumcmb7z8vJYuHAhq1evjgilVq9ezdKlS9Hr9eFtP/nJT3jhhRdITk7mkUce4cEHH6S4uBiAdevWsXz5cl5++WUWLlzIxo0beeCBB8jKymLBggXh53j22Wd58cUXefHFF1mxYgX33XcfBQUFrFy5kpycHB588EEeffRR3n///T7fZ3t7O0uWLOHVV19FVVVeeOEFFi1aRFlZGdHR0Zf1s2trawMgISHhoo/p6urC5/Nd0jGXSkIpIa4RgfZ2bTjejp107tiB9+TJyB0MBqzjb8QxYwb26dMlhBLDh7czGDidU/nUWkH/4VOC1uMpHDwFez45kiV8EkIIIYS4xqiqyqZNm/jwww957LHHwmFUcXExc+bMAbQqn+zsbNavX8+3vvWtXs/x0EMP8cgjj/Diiy9isVjYt28fhw4d4p133onY7xe/+AXz588H4Mknn+Suu+7C7XZjtVpZtWoVS5cu5Yc//CEATzzxBDt37mTVqlURodQDDzzAvffeC8CKFSuYPXs2P/3pT7nzzjsBWL58OQ888EC/7/e2226LuP/b3/6WuLg4tmzZwt13332pPz4UReHxxx9n7ty5jB8//qKPW7FiBRkZGSxcuPCSX/NiSSglxAileL249u2nc+cOOnfswH3oMCg9+ubodFhvuAHH7FnYZ87ENmUqhqi+xw4LMSg8HVrl07mz3bX27mcWZk+MbDQernySoaVCCCGEEJfDZrSx675dQ/K6l2rjxo1ERUXh8/lQFIX77ruPZ555hk2bNmE0Gpk5s7viKzExkbFjx1JSUtLncy1evJhly5axbt06vvOd77BmzRoWLFhAXl5exH4TJ04Mr6enpwNQX19PTk4OJSUlPPzwwxH7z507l1deeaXf50hNTQVgwoQJEdvcbjdOp5OYmJhe51pXV8fTTz/N5s2bqa+vJxAI0NXVRUUffYAvxrJlyzh8+DDbtm276GP+z//5P/zxj39k8+bNWAdwcisJpYQYIVRVxXviBB3biuncto2uvXtR3e6Ifcy5udjnzMYxazaOmTMwxMUNzcmK65unHRqOB6ueQrPdlULb+cKnpGDoNLY7eEopAkfS4J23EEIIIcR1QKfTXfEwusGyYMECXn/9dcxmMxkZGVc0657ZbOb+++9n9erV3HPPPaxdu7ZXmAREDP0L9cBSlH4mzelHX89xKc+7ZMkSmpqaeOWVV8jNzcVisTB79my8Xu8lnQfAo48+ysaNG9m6dStZWVkXdcyqVav4P//n//DJJ59EBGwDQUIpIYaxQFsbnTt20LFtG53bivHX1kY8bkhO0gKo2bNxzJ6FKZjkCzEoPO3BIXfHevR8OgZtlf0f40juETr16Pkk4ZMQQgghhDiHw+Fg9OjRvbYXFRXh9/vZtWtXePheU1MTpaWl3HDDDf0+30MPPcT48eN57bXX8Pv93HPPPZd0PkVFRRQXF7NkyZLwtuLi4vO+5uUoLi7mtddeY9GiRQBUVlbS2Nh4Sc+hqiqPPfYY69atY/PmzeTn51/Ucf/3//5ffvGLX/Dhhx9G9N8aKBJKCTGMqIEA7kOHwtVQroMHI4bk6SwW7NOm4bj5Zhxz52ApLLzkGSyEuGRuZ3fgFFrqj4HzbP/HRKUGq57OqX5yJA7eeQshhBBCiGtSYWEhX//61/nBD37Ab37zG6Kjo3nyySfJzMzk61//er/HFRUVMWvWLFasWMGDDz6IzXZpQwp//OMfc++99zJlyhQWLlzIhg0bePvtt/nkk0+u9C1FKCws5M0332TatGk4nU5+/OMfX/K5Llu2jLVr1/LOO+8QHR1NbbDAITY2tt/nev755/nZz37G2rVrycvLCx8TFRVF1AD1I5ZQSoghFmhtpePP2+jYvJnObdsIBGdFCDGPGkXUzTfjuPlm7NOnoR/A8bziOudu61H51COAclb1f0xUWo9+Tz1CKPvAzdAhhBBCCCHE6tWrWb58OXfffTder5d58+bx3nvv9Zp571x/9Vd/xfbt23nwwQcv+TUXL17MK6+8wqpVq1i+fDn5+fmsXr2aW2+99TLfRd/+/d//nYcffpipU6eSnZ3NL3/5S370ox9d0nO8/vrrAL3OLTTjYH/HeL1e/uIv/iJi+z/+4z/yzDPPXNLrXyydqqr9TG00MjmdTmJjY2lra+uzYZgQQ01VVTzHj9OxeQsdW7bgOnAgohpKHx2tDce75Wai5s7FlJExdCcrrk2uVmg83mPIXYkWQrVX939MdHpk6JRSBEljJHwSQgghhBjG3G43p0+fJj8/f0CbVY8kzz77LG+99RYHDx4c6lMZ8c739+tisxmplBJiECguF507d9KxZQsdW7bir6mJeNwyZgxR8+cTdet8bJMmobuCBn5ChLla+q58aq/p/5jo9O4m4+EQagzY4gfvvIUQQgghhLjKOjo6KC8v59e//jX//M//PNSnI4IG9Jtvc3Mzjz32GBs2bECv1/PNb36TV1555bxjEW+99Va2bNkSse2v//qveeONNwbyVIW46vyNjbR/9hkdmz6lc8cOVI8n/JjOYsExaxZRt84nav58qYYSV8bVEhk6hUKojtr+j4nO6DHsLtRwfCzY4gbttIUQQgghhBgsjz76KH/4wx9YvHjxZQ3dEwNjQEOpv/zLv6SmpoaPP/4Yn8/HAw88wMMPP8zatWvPe9wPfvAD/umf/il8324fGdNVCuE5dYr2TZvo2PQpri++gB6jY40Z6UTNn0/0rbdinzlTekOJS9fVHBk6hdY76vo/Jiazj9nuxoI1dvDOWwghhBBCiCG2Zs0a1qxZM9SnIc4xYKFUSUkJH3zwAbt37w5PI/jqq6+yaNEiVq1aRcZ5KkPsdjtpaWkDdWpCXDVqIIDri4O0b/qEjk2f4i0vj3jcOn480bffRtRtt2MZIzPliYvU1Rzs93RO5VNnff/HxGRpoVPS2GD4FBx+Z5XeekIIIYQQQojhacBCqR07dhAXFxcOpAAWLlyIXq9n165dfOMb3+j32N///vf813/9F2lpaXz1q1/lpz/9ab/VUh6PB0+PYVFOp/PqvQkh+qB6vXTu2kX7Rx/R/ulnBJqauh80mXDMnBkMom7DlJo6dCcqhr/OpmDoFGw4HgqiOhv6PyY2J9jrqcfQu6QxEj4JIYQQQgghRpwBC6Vqa2tJSUmJfDGjkYSEBGpr++9zct9995Gbm0tGRgYHDx5kxYoVlJaW8vbbb/e5/3PPPcfPf/7zq3ruQpxL8XjoLC6m/cOPaP/sM5Qe4ac+Oloblnf7bThuuQXDeXqmietUZ2Ow2qmku/H4hcKnuJwevZ5CyxiwRA/eeQshhBBCCCHEALrkUOrJJ5/k+eefP+8+JSUll31CDz/8cHh9woQJpKenc/vtt3Py5ElGjRrVa/+VK1fyxBNPhO87nU6ys7Mv+/WFCFG6uujY+mfaP/qIjs2bUbq6wo8ZkpOIXriQmC99Cfv06ehMpiE8UzFsdDT0HnLXcAy6Gvs/Ji6ne6hdz8oni4SbQgghhBBCiGvbJYdSf//3f8/SpUvPu09BQQFpaWnU10f2P/H7/TQ3N19Sv6iZM2cCcOLEiT5DKYvFgsViuejnE+J8Ah2ddHz2Ge0ffUjHn7ehut3hx4xpaUTf8SVi7rgD25Qp6AyGITxTMWRUNVj51HPIXal2v6up/+PicoOh09juECp5LJgdg3fuQgghhBBCCDGMXHIolZycTHJy8gX3mz17Nq2trezdu5ebbroJgE8//RRFUcJB08U4cOAAAOnp6Zd6qkJcFMXlomPLVpzvvUfHli2oPXqUmbKzw0GUdcIEdHr9EJ6pGFSqqg2v6xk6hUIoV3M/B+kgPrfHbHfB8ClpjIRPQgghhBBCCHGOAespVVRUxJe//GV+8IMf8MYbb+Dz+Xj00Uf5zne+E555r6qqittvv53//M//ZMaMGZw8eZK1a9eyaNEiEhMTOXjwIH/3d3/HvHnzmDhx4kCdqrgOKV4vndu24fzTe7R/9hlqj6F55txcor/yZWLuuANLUZHMmHetU1XoqIscbhdaXC39HKSD+Lxg8NSj51PSGDD3PSmDEEIIIYQQYvCsWbOGxx9/nNbW1qE+lQt65plnWL9+fbgo52LodDrWrVvH4sWLB+y8BsOAhVKgzaL36KOPcvvtt6PX6/nmN7/Jr371q/DjPp+P0tJSuoKBgNls5pNPPuHll1+ms7OT7OxsvvnNb/L0008P5GmK64Tq89G5cyfO996n/ZNPUNrbw4+ZMjKIuWsRMV/5igRR1ypVhfbavns+uVv7OUgHCfmRzcZTxkFioYRPQgghhBBCDKClS5fyu9/9DgCTyUROTg73338/Tz31FEbjgEYZg+5HP/oRjz322FV9zueee463336bY8eOYbPZmDNnDs8//zxjx47t95i3336bX/7yl5w4cQKfz0dhYSF///d/z/e///2rem49DeifZEJCAmvXru338by8PFRVDd/Pzs5my5YtA3lK4jqjqiqu/ftp27CB9vc/INAjJTempBDzlS8Ts2gR1okTJYi6VqgqtNf0Xfnkbuv7GJ0eEgqCwVOPnk9JhWCyDe75CyGEEEIIIQD48pe/zOrVq/F4PLz33nssW7YMk8nEypUrh/rUrqqoqCiirvIs7lu2bGHZsmVMnz4dv9/PU089xR133MHRo0dxOPpuLZKQkMBPfvITxo0bh9lsZuPGjTzwwAOkpKRw5513XtXzC7m24kUhgjynTtG2YQPODRvxnT0b3m5ISCDmy3cS85WvYLvpJukRNZKpKjir+6h8KgXPxYRPPXo+JRaCyTq45y+EEEIIIcQQUFUV1eUa9NfV2WyXXAhgsVjCE6X9zd/8DevWrePdd99l5cqVtLS0sHz5cjZs2IDH42H+/Pn86le/orCwsNfzlJeXU1BQwOeff860adPC219++WVeeuklTp8+zdatW1mwYAGffPIJK1as4OjRo0yePJnVq1dHVBe9/vrrrFq1isrKSvLz83n66acjKol0Oh1vvPEGGzZs4NNPPyU3N5f/+I//IDk5mYceeojdu3czadIk3nzzzfBkbucO39u9ezdPPfUU+/fvx+fzMXnyZF566SWmTp160T+7Dz74IOL+mjVrSElJYe/evcybN6/PY2699daI+8uXL+d3v/sd27Ztk1BKiAvxNzTgfO892t7dgPvIkfB2vd1O9Je+RMxXv4pj1kx011ip5zUvHD6dO9vd+cIngxY+9ez3lDxOq3wyymydQgghhBDi+qW6XJROvWnQX3fsvr3o7FfWAsNms9HUpM14vXTpUsrKynj33XeJiYlhxYoVLFq0iKNHj2IymSKOy8vLY+HChaxevToilFq9ejVLly5F36NY4Sc/+QkvvPACycnJPPLIIzz44IMUFxcDsG7dOpYvX87LL7/MwoULw5VEWVlZLFiwIPwczz77LC+++CIvvvgiK1as4L777qOgoICVK1eSk5PDgw8+yKOPPsr777/f5/tsb29nyZIlvPrqq6iqygsvvMCiRYsoKysjOjr6sn52bW3ad6eEhISL2l9VVT799FNKS0t5/vnnL+s1L4Z8OxcjmtLZSfumTbS9u4HO7dtBUbQHDAaibr6ZmK99lejbbkNvkyFYw56qgrOqx5C7nuGTs+9jdAZIHBXZ7yl5HCSOlvBJCCGEEEKIa4SqqmzatIkPP/yQxx57LBxGFRcXM2fOHEDraZ2dnc369ev51re+1es5HnroIR555BFefPFFLBYL+/bt49ChQ7zzzjsR+/3iF79g/vz5ADz55JPcdddduN1urFYrq1atYunSpfzwhz8E4IknnmDnzp2sWrUqIpR64IEHuPfeewFYsWIFs2fP5qc//Wm42mj58uU88MAD/b7f2267LeL+b3/7W+Li4tiyZQt33333pf74UBSFxx9/nLlz5zJ+/Pjz7tvW1kZmZiYejweDwcBrr73Gl770pUt+zYsloZQYcVRFoWv3HtrWrcP50UcRM+fZJk0i5qtfJWbRVzBeZAIsBpmqQtvZvofdedv7PkZvhIRRwX5PofCpKBg+mQf3/IUQQgghhBjBdDYbY/ftHZLXvVQbN24kKioKn8+Hoijcd999PPPMM2zatAmj0cjMmTPD+yYmJjJ27FhKSkr6fK7FixezbNky1q1bx3e+8x3WrFnDggULyMvLi9hv4sSJ4fX09HQA6uvrycnJoaSkhIcffjhi/7lz5/LKK6/0+xypqakATJgwIWKb2+3G6XQSExPT61zr6up4+umn2bx5M/X19QQCAbq6uqioqDjfj6tfy5Yt4/Dhw2zbtu2C+0ZHR3PgwAE6OjrYtGkTTzzxBAUFBb2G9l0tEkqJEcN79ixt69+hbf36iD5RptwcYr/6NWK/ejfm3NwhPEMRQVGgrTJY7RSqegqFTx19H6M3akFTz2bjKUVaICXhkxBCCCGEEFdMp9Nd8TC6wbJgwQJef/11zGYzGRkZVzTrntls5v7772f16tXcc889rF27tleYBEQM/Qv1wFJCI3IuUl/PcSnPu2TJEpqamnjllVfIzc3FYrEwe/ZsvF7vJZ0HwKOPPsrGjRvZunUrWVlZF9xfr9czevRoACZPnkxJSQnPPfechFLi+qR0deH88CPa1q2j6/PPw9v1DgcxixYR+41vYJsyWWbOG0qKAm0V5/R7KoGG4+Dr7PsYvak7fEopgqQxEj4JIYQQQgghIjgcjnBA0lNRURF+v59du3aFh+81NTVRWlrKDTfc0O/zPfTQQ4wfP57XXnsNv9/PPffcc0nnU1RURHFxMUuWLAlvKy4uPu9rXo7i4mJee+01Fi1aBEBlZSWNjY2X9ByqqvLYY4+xbt06Nm/eTH5+/mWdi6IoeDyeyzr2YkgoJYYdVVVx7dlD67r1tH/wAUpoeJ5Oh2P2LGK/8Q2iFy6UPlGDLRQ+1fccdlcCjcfh/2fvzsOaOrM/gH+TECDELIBAWAUVQVnEZXSU1k5H5qfj0trFbTqjVqttwarVttpVbbXWhRZrrbWLOnaztYutY9URl864O1UQXFBUisgmYBKQPbm/PwIX0qCiFYLm+3keH8zNm5uTyFVzOOe8NeVNP0YqtwwX/+3MJ4+OgEze9GOIiIiIiIiuIzQ0FA8++CAmT56M1atXQ6VSYc6cOfD398eDDz54zcd17doVf/zjHzF79mxMnDgRipv8TPn8889j1KhR6NGjB+Li4rB582Z89913SE5O/r0vyUpoaCg+/fRT9O7dG0ajEc8///xNx5qQkIAvvvgCP/zwA1QqFfLz8wEAGo3mmudatGgRevfujU6dOqGqqgo//fQTPv30U6xatep3v6ZrYVKK2ozaoiIYNm2CfuM3qP71V/G4vEMQtA89BM0DD0Du52fHCB2E2Qzof/3NvKfT108+yZwBz1Db3e48OgIy/jVDRERERES319q1azF9+nQMGzYM1dXVGDBgAH766Sebnfd+a9KkSdi/fz8mTpx40885YsQILF++HMuWLcP06dMREhKCtWvX3vbWtk8++QRTpkxBz549ERgYiDfffBPPPffcTZ2jPpH029jqdxxsytWrVxEfH4+cnBwoFAqEh4fjs88+w+jRo2/lZTSLRBAEocXObgdGoxEajQYGg6HJgWHUtggmE67u3w/9xm9QumsXUFsLAJC6uUH118HQPvwwFD17sj2vJZjNgD7LuvLp8mlL211tRdOPkTlbWu1+O/PJPYTJJyIiIiKiNqayshIXLlxASEgIXF1d7R1Om/DGG29g48aNOH78uL1DueNd7/urubkZfooku6jJz4f+22+h//Zb1Obmicddu0dD++ij0AwZAqlSaccI7yJmE3Aly3rgeOEpoOjsdZJPLg3JJ7H6qSvgHszkExERERER3XHKysqQlZWF9957DwsWLLB3OFSHny6p1Qi1tSjbswf6jd+g7L//tVTqAJCq1dA88AC0Ix+Fa1iYnaO8g9UnnwpPNexyd7k++VTZ9GNkLoBXl7qkU131k3dXQNuBySciIiIiIrprTJ06FV9++SVGjBhxS6171DL4qZNaXE1BAfRfb4R+40bUFhaKx93+8AdoR42E6i9/gZSlpM1nqq2rfDrVaOZThmXmk+kauyI4udYNHG/UcucVbql8kspaM3oiIiIiIqJWt27dOqxbt87eYdBvMClFLUIQBJQfPIgrX3xpmRVlMgEAZB4e0Dw0AtpHH4XLLW5J6TBMtcCVC3WVT41a74rOAKbqph/jpLCtfPIKY/KJiIiIiIiI2hwmpei2MhkMMGzahCtfbkB1VpZ4XNG7F9zHjIXq//4CqbOz/QJsi0w1QMkF63lPlzOA4rPXTj7J3RoqnxrveKcNYvKJiIiIiIiI7ghMStFtUZGWjitffgnjTz9BqLTML5IqldA8+AC0Y8bAtUsXO0fYBphqgJLzjVru6iufzgLmmqYfI3erq3hqlHjyDgc0QYBU2rrxExEREREREd1GTErRLTNXV6N02zaUfPoZKtPSxOMuYWFwHzsG6mHDIWvngDvomWqA4nN1w8ZPNyShijOvk3xSNiSfGlc+aQKZfCIiIiIiIqK7EpNSdNNqCguh/+prXPnqK5iKigAAErkcqsGD4T52DBQ9ekAikdg5ylZQWw2UnGtU+VT3qzgTMNc2/Rjndk1XPqkDmHwiIiIiIiIih8KkFDVbxfHjKPn0Mxi3bQNqLBU/Tt7ecP/bWGhHjoSTp6edI2whtdWWRNNvK59KzjUj+dTVugKKySciIiIiIiIiAExK0Q0I1dUwbv83Sj77FJWpx8Xjih494PGPv0P1l79AIpfbMcLbqLbKknz67W53xecAwdT0Y5xVlqST2HJXl4TSBACOUC1GRERERETUBq1btw4zZsyAXq+3dyg3NG/ePGzatAkpKSnNfoxEIsH333+PESNGtFhcrYFJKWpSbUkJrmzYAP2XG1B7+TIAS4ueesgQuP/971BERdo5wt+hptK68qk+CVVy/trJJxe1ddtdfRJK7c/kExERERER0W02YcIE/POf/wQAyOVyBAUFYdy4cXjppZfg5HR3pTKee+45PPPMM7f1nIsWLcJ3332H06dPQ6FQoH///li8eDHCwsKa9fgNGzZg7NixePDBB7Fp06bbGltjd9efJP1uVefPo2TdP2HYtAlCdTUAQObVHu5jxsB99Gg4tW9v5whvQk0lUHzWknAqPNWQhCo5Dwjmph/TOPnk3bWhBU/tx+QTERERERFRKxo8eDDWrl2Lqqoq/PTTT0hISIBcLseLL75o79Buq3bt2qFdu3a39Zw///wzEhIS8Ic//AG1tbV46aWX8H//9384efIklMrrb0iWlZWF5557Dvfee+9tjakpHG5DEAQBVw8dxsWnnsb5IUOh//prCNXVcI2MhN/SJQjduRNeCQltNyFVUwnkHQeObwR2vg5seAx4tyfwpi/wwT3At5OA/y4DTv/LUiElmAEXDRDYF+g5Hhi0CPjH98DMU8CcbOCJZODB94B+CUDnOEDDaigiIiIiIro7CIKAmipTq/8SBOGmY3VxcYFOp0OHDh3w9NNPIy4uDj/++CMA4MqVKxg3bhzc3d3h5uaGv/71rzh79myT58nKyoJUKsX//vc/q+NJSUno0KEDzGYz9uzZA4lEgp07d6J3795wc3ND//79kZGRYfWYVatWoVOnTnB2dkZYWBg+/fRTq/slEglWr16NYcOGwc3NDV27dsWBAweQmZmJP/3pT1Aqlejfvz/OnTsnPmbevHmIiYkRbx85cgR/+ctf0L59e2g0Gtx33304evToTb1327Ztw4QJExAREYHu3btj3bp1yM7Oxi+//HLdx5lMJjz22GOYP38+OnbseFPPeStYKeXAhJoaGLdtR8natag8edJyUCJBu/vvh+fjE6Do3btt7aJXUwEUnWlU+VQ39+lK1rUrn1w1lkon73DrHe9UOiaaiIiIiIjI4dRWm/Hh9J9b/XmnLL8PchfZ7zqHQqFAcXExAEt739mzZ/Hjjz9CrVZj9uzZGDJkCE6ePAn5b+YeBwcHIy4uDmvXrkXv3r3F42vXrsWECRMgbbQZ1csvv4zExER4eXnhqaeewsSJE7Fv3z4AwPfff4/p06cjKSkJcXFx+Ne//oXHH38cAQEBuP/++8VzvPHGG3j77bfx9ttvY/bs2fjb3/6Gjh074sUXX0RQUBAmTpyIqVOnYuvWrU2+ztLSUowfPx4rVqyAIAhITEzEkCFDcPbsWahUqlt67wwGAwDAw8Pjuutef/11eHt7Y9KkSfjvf/97S891M5iUckCm0lLov96Iks8+Q21eHgBA4uoKzUMj4DFuHFxCQuwbYHW5pe2u8LT13KcrWQCukV131da12/1m5lM7HyafiIiIiIiI7mCCIGDnzp3Yvn07nnnmGTEZtW/fPvTv3x8A8PnnnyMwMBCbNm3CyJEjbc7xxBNP4KmnnsLbb78NFxcXHD16FGlpafjhhx+s1i1cuBD33XcfAGDOnDkYOnQoKisr4erqimXLlmHChAmIj48HAMycORMHDx7EsmXLrJJSjz/+OEaNGgUAmD17Nvr164dXX30VgwYNAgBMnz4djz/++DVf75///Ger2x9++CG0Wi1+/vlnDBs27GbfPpjNZsyYMQOxsbGIjLz2fOi9e/fik08+uamB678Xk1IOpKagACXr/gn911/DfPUqAEDWvj08HvsbtGPGwMndvXUDqi4HijKaqHz6FddMPincm658aufN5BMREREREdENODlLMWX5fXZ53pv1r3/9C+3atUNNTQ3MZjP+9re/Yd68edi5cyecnJzQt29fca2npyfCwsJw6tSpJs81YsQIJCQk4Pvvv8eYMWOwbt063H///QgODrZaFx0dLf7e19cXAFBYWIigoCCcOnUKU6ZMsVofGxuL5cuXX/McPj4+AICoqCirY5WVlTAajVCr1TaxFhQU4JVXXsGePXtQWFgIk8mE8vJyZGdnX+/tuqaEhASkp6dj796911xTWlqKf/zjH/joo4/QvhVH9zAp5QCqzl9A8ZpPYPjhR6CmBgDgEtoZHhMmQD1sGKQuLi0bQPXVuoRTfeVTXRJKn41rJ588rAeNe4VZbiu9mHwiIiIiIiK6RRKJ5He30bWW+++/H6tWrYKzszP8/Px+1657zs7OGDduHNauXYuHH34YX3zxhU0yCYBV61/9OBuz+RrjYq6hqXPczHnHjx+P4uJiLF++HB06dICLiwv69euH6rrNyG7G1KlT8a9//Qv/+c9/EBAQcM11586dQ1ZWFoYPHy4eq4/PyckJGRkZ6NSp000//40wKXUXq0hLQ/FHH6N0xw6gbqic2x/+AM/JT0B57723f15UVdlvKp/qklD662Rz3Tytk071SShleyafiIiIiIiIHJhSqUTnzp1tjnft2hW1tbU4dOiQ2L5XXFyMjIwMdOvW7Zrne+KJJxAZGYn3338ftbW1ePjhh28qnq5du2Lfvn0YP368eGzfvn3Xfc5bsW/fPrz//vsYMmQIAODixYsoKiq6qXMIgoBnnnkG33//Pfbs2YOQG4zpCQ8PR1pamtWxV155BaWlpVi+fDkCAwNv7kU0E5NSdxlBEHB1/34Uf/Qxyg8eFI+3GzgQnk9MgluPHr//SarKGlU+1bXdFZ4GDNdLPrVvlHSqn/tUl3wiIiIiIiIiaqbQ0FA8+OCDmDx5MlavXg2VSoU5c+bA398fDz744DUf17VrV/zxj3/E7NmzMXHiRCgUipt63ueffx6jRo1Cjx49EBcXh82bN+O7775DcnLy731JVkJDQ/Hpp5+id+/eMBqNeP7552861oSEBHzxxRf44YcfoFKpkJ+fDwDQaDRNnsvV1dVm3pRWqwWA686h+r2YlLpLCCYTSnfsQPGHHzXspOfkBM2wYfB8YhJcmsgu31BVKXD5jCXxJM58Og0YLl77MUrv31Q91SWgmHwiIiIiIiKi22Tt2rWYPn06hg0bhurqagwYMAA//fSTzc57vzVp0iTs378fEydOvOnnHDFiBJYvX45ly5Zh+vTpCAkJwdq1a/GnP/3pFl9F0z755BNMmTIFPXv2RGBgIN58800899xzN3WOVatWAYBNbPU7DrYVEkEQrjHU585kNBqh0WhgMBiaHBh2txFqamD4cTOKP/wQ1b/+CgCQKBTQjnwUnhMmQO7nd+OTVBqBojPWLXeFpwFjzrUf087Het5TfeWT2/W3lyQiIiIiIqLWUVlZiQsXLiAkJASurq72DqdNeOONN7Bx40YcP37c3qHc8a73/dXc3Awrpe5Q5upqGL77HsUffYSaS5cAADKNBu5//zvc//5Y0zvpVRoaKp8a73h3w+RTuO3QcSafiIiIiIiI6A5RVlaGrKwsvPfee1iwYIG9w6E6TErdYcyVldBv/AbFn3yC2rqeUJmnJzwnPg73MWMgVSotyaeLhxu13NUnny5d+8TtdIB3eEO7nVc4k09ERERERER0V5g6dSq+/PJLjBgx4pZa96hltFhSauHChdiyZQtSUlLg7OwMvV5/w8cIgoC5c+fio48+gl6vR2xsLFatWoXQ0NCWCvOOYS4vx5UNX6F4zRqY6qbuO3m1h+ejg6Dt4wOpIRP49jFL8qk099onUvk2VDx5N0o+KZqorCIiIiIiIiK6C6xbtw7r1q2zdxj0Gy2WlKqursbIkSPRr18/fPLJJ816zJIlS/Duu+/in//8J0JCQvDqq69i0KBBOHnypMP2v5rKynBl3Sco+fQzmAxlAAC5xgmekTXQ+B2H9MpxYHsTD1T7W7fbeXcF2ncBFNpWjZ+IiIiIiIiIqCktlpSaP38+ADQ7EykIApKSkvDKK6+IWziuX78ePj4+2LRpE8aMGdPk46qqqlBVVSXeNhqNvy/wNqTkjSm4/M1/YK6SAADk7WrRvlspNMEVkEjrFqn9m5j51AVw1dgvcCIiIiIiImoz7rL9zaiNuB3fV21mptSFCxeQn5+PuLg48ZhGo0Hfvn1x4MCBayalFi1aJCbA7jpmwFwlgbO6Bu17OUPdLwoSn67WM59c7/4dBomIiIiIiOjmyeVyAEB5eTkUCoWdo6G7TXl5OYCG77Nb0WaSUvl1Q7t9fHysjvv4+Ij3NeXFF1/EzJkzxdtGoxGBgYEtE2Qr0z41G06hMVA9OBYSJWc+ERERERERUfPJZDJotVoUFhYCANzc3CCRSOwcFd3pBEFAeXk5CgsLodVqIZPJbvlcN5WUmjNnDhYvXnzdNadOnUJ4ePgtB3SzXFxc4OLi0mrP15qkPp2g/lu8vcMgIiIiIiKiO5ROpwMAMTFFdLtotVrx++tW3VRSatasWZgwYcJ113Ts2PGWAql/IQUFBfD19RWPFxQUICYm5pbOSUREREREROTIJBIJfH194e3tjZqaGnuHQ3cJuVz+uyqk6t1UUsrLywteXl6/+0mbEhISAp1Oh507d4pJKKPRiEOHDuHpp59ukeckIiIiIiIicgQymey2JBGIbifpjZfcmuzsbKSkpCA7OxsmkwkpKSlISUlBWVmZuCY8PBzff/89AEv2dsaMGViwYAF+/PFHpKWlYdy4cfDz88OIESNaKkwiIiIiIiIiIrKDFht0/tprr+Gf//yneLtHjx4AgN27d+NPf/oTACAjIwMGg0Fc88ILL+Dq1auYMmUK9Ho97rnnHmzbtg2urq4tFSYREREREREREdmBRBAEwd5B3E5GoxEajQYGgwFqtdre4RAREREREREROZTm5mZarFLKXupzbEaj0c6REBERERERERE5nvqczI3qoO66pFRpaSkAIDAw0M6REBERERERERE5rtLSUmg0mmvef9e175nNZuTm5kKlUkEikdg7nN/NaDQiMDAQFy9eZDsiUTPxuiG6Nbx2iG4Nrx2iW8Nrh+jW3AnXjiAIKC0thZ+fH6TSa++xd9dVSkmlUgQEBNg7jNtOrVa32W82oraK1w3RreG1Q3RreO0Q3RpeO0S3pq1fO9erkKp37XQVERERERERERFRC2FSioiIiIiIiIiIWh2TUm2ci4sL5s6dCxcXF3uHQnTH4HVDdGt47RDdGl47RLeG1w7Rrbmbrp27btA5ERERERERERG1fayUIiIiIiIiIiKiVsekFBERERERERERtTompYiIiIiIiIiIqNUxKUVERERERERERK2OSak2bOXKlQgODoarqyv69u2Lw4cP2zskojZl0aJF+MMf/gCVSgVvb2+MGDECGRkZVmsqKyuRkJAAT09PtGvXDo888ggKCgrsFDFR2/PWW29BIpFgxowZ4jFeN0RNu3TpEv7+97/D09MTCoUCUVFR+N///ifeLwgCXnvtNfj6+kKhUCAuLg5nz561Y8RE9mcymfDqq68iJCQECoUCnTp1whtvvIHG+23x2iGy+M9//oPhw4fDz88PEokEmzZtsrq/OddKSUkJHnvsMajVami1WkyaNAllZWWt+CpuDpNSbdRXX32FmTNnYu7cuTh69Ci6d++OQYMGobCw0N6hEbUZP//8MxISEnDw4EHs2LEDNTU1+L//+z9cvXpVXPPss89i8+bN2LhxI37++Wfk5ubi4YcftmPURG3HkSNHsHr1akRHR1sd53VDZOvKlSuIjY2FXC7H1q1bcfLkSSQmJsLd3V1cs2TJErz77rv44IMPcOjQISiVSgwaNAiVlZV2jJzIvhYvXoxVq1bhvffew6lTp7B48WIsWbIEK1asENfw2iGyuHr1Krp3746VK1c2eX9zrpXHHnsMJ06cwI4dO/Cvf/0L//nPfzBlypTWegk3T6A2qU+fPkJCQoJ422QyCX5+fsKiRYvsGBVR21ZYWCgAEH7++WdBEARBr9cLcrlc2Lhxo7jm1KlTAgDhwIED9gqTqE0oLS0VQkNDhR07dgj33XefMH36dEEQeN0QXcvs2bOFe+6555r3m81mQafTCUuXLhWP6fV6wcXFRfjyyy9bI0SiNmno0KHCxIkTrY49/PDDwmOPPSYIAq8domsBIHz//ffi7eZcKydPnhQACEeOHBHXbN26VZBIJMKlS5daLfabwUqpNqi6uhq//PIL4uLixGNSqRRxcXE4cOCAHSMjatsMBgMAwMPDAwDwyy+/oKamxupaCg8PR1BQEK8lcngJCQkYOnSo1fUB8LohupYff/wRvXv3xsiRI+Ht7Y0ePXrgo48+Eu+/cOEC8vPzra4djUaDvn378tohh9a/f3/s3LkTZ86cAQCkpqZi7969+Otf/wqA1w5RczXnWjlw4AC0Wi169+4tromLi4NUKsWhQ4daPebmcLJ3AGSrqKgIJpMJPj4+Vsd9fHxw+vRpO0VF1LaZzWbMmDEDsbGxiIyMBADk5+fD2dkZWq3Waq2Pjw/y8/PtECVR27BhwwYcPXoUR44csbmP1w1R086fP49Vq1Zh5syZeOmll3DkyBFMmzYNzs7OGD9+vHh9NPX/N1475MjmzJkDo9GI8PBwyGQymEwmLFy4EI899hgA8NohaqbmXCv5+fnw9va2ut/JyQkeHh5t9npiUoqI7goJCQlIT0/H3r177R0KUZt28eJFTJ8+HTt27ICrq6u9wyG6Y5jNZvTu3RtvvvkmAKBHjx5IT0/HBx98gPHjx9s5OqK26+uvv8bnn3+OL774AhEREUhJScGMGTPg5+fHa4eIOOi8LWrfvj1kMpnNTkcFBQXQ6XR2ioqo7Zo6dSr+9a9/Yffu3QgICBCP63Q6VFdXQ6/XW63ntUSO7JdffkFhYSF69uwJJycnODk54eeff8a7774LJycn+Pj48LohaoKvry+6detmdaxr167Izs4GAPH64P/fiKw9//zzmDNnDsaMGYOoqCj84x//wLPPPotFixYB4LVD1FzNuVZ0Op3N5mi1tbUoKSlps9cTk1JtkLOzM3r16oWdO3eKx8xmM3bu3Il+/frZMTKitkUQBEydOhXff/89du3ahZCQEKv7e/XqBblcbnUtZWRkIDs7m9cSOayBAwciLS0NKSkp4q/evXvjscceE3/P64bIVmxsLDIyMqyOnTlzBh06dAAAhISEQKfTWV07RqMRhw4d4rVDDq28vBxSqfXHTplMBrPZDIDXDlFzNeda6devH/R6PX755Rdxza5du2A2m9G3b99Wj7k52L7XRs2cORPjx49H79690adPHyQlJeHq1at4/PHH7R0aUZuRkJCAL774Aj/88ANUKpXYJ63RaKBQKKDRaDBp0iTMnDkTHh4eUKvVeOaZZ9CvXz/88Y9/tHP0RPahUqnEuWv1lEolPD09xeO8bohsPfvss+jfvz/efPNNjBo1CocPH8aHH36IDz/8EAAgkUgwY8YMLFiwAKGhoQgJCcGrr74KPz8/jBgxwr7BE9nR8OHDsXDhQgQFBSEiIgLHjh3D22+/jYkTJwLgtUPUWFlZGTIzM8XbFy5cQEpKCjw8PBAUFHTDa6Vr164YPHgwJk+ejA8++AA1NTWYOnUqxowZAz8/Pzu9qhuw9/Z/dG0rVqwQgoKCBGdnZ6FPnz7CwYMH7R0SUZsCoMlfa9euFddUVFQI8fHxgru7u+Dm5iY89NBDQl5env2CJmqD7rvvPmH69OnibV43RE3bvHmzEBkZKbi4uAjh4eHChx9+aHW/2WwWXn31VcHHx0dwcXERBg4cKGRkZNgpWqK2wWg0CtOnTxeCgoIEV1dXoWPHjsLLL78sVFVViWt47RBZ7N69u8nPN+PHjxcEoXnXSnFxsTB27FihXbt2glqtFh5//HGhtLTUDq+meSSCIAh2yocREREREREREZGD4kwpIiIiIiIiIiJqdUxKERERERERERFRq2NSioiIiIiIiIiIWh2TUkRERERERERE1OqYlCIiIiIiIiIiolbHpBQREREREREREbU6JqWIiIiIiIiIiKjVMSlFREREREREREStjkkpIiIiIiIiIiJqdUxKERERERERERFRq2NSioiIiIiIiIiIWh2TUkRERERERERE1OqYlCIiIiIiIiIiolbHpBQREREREREREbU6JqWIiIiIiIiIiKjVMSlFREREREREREStjkkpIiIiIiIiIiJqdUxKERERUZsjkUgwdepUe4fRZq1btw4SiQRZWVn2DqXF7NmzBxKJBHv27LF3KERERNRCmJQiIiKiVnPu3Dk8+eST6NixI1xdXaFWqxEbG4vly5ejoqLC3uE5hJMnT2LevHnNTmjNmzcPEolE/CWVSuHr64thw4bh4MGDLRssERER3dWc7B0AEREROYYtW7Zg5MiRcHFxwbhx4xAZGYnq6mrs3bsXzz//PE6cOIEPP/zQ3mHeEf7xj39gzJgxcHFxuenHnjx5EvPnz8ef/vQnBAcHN/txq1atQrt27WA2m3Hx4kV89NFHGDBgAA4fPoyYmJibjuNGBgwYgIqKCjg7O9/2cxMREVHbwKQUERERtbgLFy5gzJgx6NChA3bt2gVfX1/xvoSEBGRmZmLLli12jPDOIpPJIJPJWvU5H330UbRv3168PWLECERGRmLjxo0tkpSSSqVwdXW97eclIiKitoPte0RERNTilixZgrKyMnzyySdWCal6nTt3xvTp022Ob9q0CZGRkXBxcUFERAS2bdtmdf+vv/6K+Ph4hIWFQaFQwNPTEyNHjrRpTaufwbRv3z7MnDkTXl5eUCqVeOihh3D58mWrtWazGfPmzYOfnx/c3Nxw//334+TJkwgODsaECROs1ur1esyYMQOBgYFwcXFB586dsXjxYpjNZnFNVlYWJBIJli1bhnfeeQcdOnSAQqHAfffdh/T0dJvXvGvXLtx7771QKpXQarV48MEHcerUqSZfT+PXGRwcjGHDhmHv3r3o06cPXF1d0bFjR6xfv97qcSNHjgQA3H///WJL3q3MbdLpdAAAJ6eGn3FWV1fjtddeQ69evaDRaKBUKnHvvfdi9+7dNo/fsGEDevXqBZVKBbVajaioKCxfvly8v6mZUmfPnsUjjzwCnU4HV1dXBAQEYMyYMTAYDDcdPxEREdkfK6WIiIioxW3evBkdO3ZE//79m/2YvXv34rvvvkN8fDxUKhXeffddPPLII8jOzoanpycA4MiRI9i/fz/GjBmDgIAAZGVlYdWqVfjTn/6EkydPws3NzeqczzzzDNzd3TF37lxkZWUhKSkJU6dOxVdffSWuefHFF7FkyRIMHz4cgwYNQmpqKgYNGoTKykqrc5WXl+O+++7DpUuX8OSTTyIoKAj79+/Hiy++iLy8PCQlJVmtX79+PUpLS5GQkIDKykosX74cf/7zn5GWlgYfHx8AQHJyMv7617+iY8eOmDdvHioqKrBixQrExsbi6NGjN2y3y8zMxKOPPopJkyZh/PjxWLNmDSZMmIBevXohIiICAwYMwLRp0/Duu+/ipZdeQteuXQFA/Ho9JSUlACxJu0uXLuGNN96Aq6srRo0aJa4xGo34+OOPMXbsWEyePBmlpaX45JNPMGjQIKs2vx07dmDs2LEYOHAgFi9eDAA4deoU9u3b12RyErAkvAYNGoSqqio888wz0Ol0uHTpEv71r39Br9dDo9Hc8DUQERFRGyMQERERtSCDwSAAEB588MFmPwaA4OzsLGRmZorHUlNTBQDCihUrxGPl5eU2jz1w4IAAQFi/fr14bO3atQIAIS4uTjCbzeLxZ599VpDJZIJerxcEQRDy8/MFJycnYcSIEVbnnDdvngBAGD9+vHjsjTfeEJRKpXDmzBmrtXPmzBFkMpmQnZ0tCIIgXLhwQQAgKBQKIScnR1x36NAhAYDw7LPPisdiYmIEb29vobi42Op1S6VSYdy4cTav58KFC+KxDh06CACE//znP+KxwsJCwcXFRZg1a5Z4bOPGjQIAYffu3TbvXVPmzp0rALD5pdVqhW3btlmtra2tFaqqqqyOXblyRfDx8REmTpwoHps+fbqgVquF2traaz7v7t27reI8duyYAEDYuHFjs+ImIiKito/te0RERNSijEYjAEClUt3U4+Li4tCpUyfxdnR0NNRqNc6fPy8eUygU4u9rampQXFyMzp07Q6vV4ujRozbnnDJlCiQSiXj73nvvhclkwq+//goA2LlzJ2praxEfH2/1uGeeecbmXBs3bsS9994Ld3d3FBUVib/i4uJgMpnwn//8x2r9iBEj4O/vL97u06cP+vbti59++gkAkJeXh5SUFEyYMAEeHh5Wr/svf/mLuO56unXrhnvvvVe87eXlhbCwMKv37FZ9++232LFjB/79739j7dq16NKlCx555BHs379fXCOTycTB5GazGSUlJaitrUXv3r2t/jy0Wi2uXr2KHTt2NPv56yuhtm/fjvLy8t/9eoiIiMj+mJQiIiKiFqVWqwEApaWlN/W4oKAgm2Pu7u64cuWKeLuiogKvvfaaONOpffv28PLygl6vb3LO0G/P6e7uDgDiOeuTU507d7Za5+HhIa6td/bsWWzbtg1eXl5Wv+Li4gAAhYWFVutDQ0Nt4unSpYs4F6r+ucPCwmzWde3aFUVFRbh69arNfdd7ffWvsfF7dqsGDBiAuLg4/OUvf8GECROwc+dOqFQqm4TdP//5T0RHR8PV1RWenp7w8vLCli1brP484uPj0aVLF/z1r39FQEAAJk6caDMv7LdCQkIwc+ZMfPzxx2jfvj0GDRqElStXcp4UERHRHYwzpYiIiKhFqdVq+Pn5NTnU+3qutbucIAji75955hmsXbsWM2bMQL9+/aDRaCCRSDBmzBirYeM3c87mMpvN+Mtf/oIXXnihyfu7dOly0+f8vW7n67uRdu3aoW/fvvjhhx9w9epVKJVKfPbZZ5gwYQJGjBiB559/Ht7e3pDJZFi0aBHOnTsnPtbb2xspKSnYvn07tm7diq1bt2Lt2rUYN24c/vnPf17zORMTEzFhwgT88MMP+Pe//41p06Zh0aJFOHjwIAICAm77ayQiIqKWxaQUERERtbhhw4bhww8/xIEDB9CvX7/bdt5vvvkG48ePR2JionissrISer3+ls7XoUMHAJaB4SEhIeLx4uJim2qjTp06oaysTKyMupGzZ8/aHDtz5ow4vLz+uTMyMmzWnT59Gu3bt4dSqWzWc11P4/bF36u2thYAUFZWBqVSiW+++QYdO3bEd999Z/U8c+fOtXmss7Mzhg8fjuHDh8NsNiM+Ph6rV6/Gq6++alOp1lhUVBSioqLwyiuvYP/+/YiNjcUHH3yABQsW3LbXRURERK2D7XtERETU4l544QUolUo88cQTKCgosLn/3LlzWL58+U2fVyaT2VQBrVixAiaT6ZbiHDhwIJycnLBq1Sqr4++9957N2lGjRuHAgQPYvn27zX16vV5M2NTbtGkTLl26JN4+fPgwDh06hL/+9a8AAF9fX8TExOCf//ynVVItPT0d//73vzFkyJBbek2/VZ/YutXEXb2SkhLs378fOp0O3t7eABoqtRr/mRw6dAgHDhywemxxcbHVbalUiujoaABAVVVVk89nNBpt3tOoqChIpdJrPoaIiIjaNlZKERERUYvr1KkTvvjiC4wePRpdu3bFuHHjEBkZierqauzfvx8bN27EhAkTbvq8w4YNw6effgqNRoNu3brhwIEDSE5Ohqen5y3F6ePjg+nTpyMxMREPPPAABg8ejNTUVGzduhXt27e3qv55/vnn8eOPP2LYsGGYMGECevXqhatXryItLQ3ffPMNsrKy0L59e3F9586dcc899+Dpp59GVVUVkpKS4OnpadX+t3TpUvz1r39Fv379MGnSJFRUVGDFihXQaDSYN2/eLb2m34qJiYFMJsPixYthMBjg4uKCP//5z2Ji6Vq++eYbtGvXDoIgIDc3F5988gmuXLmCDz74QHxfhg0bhu+++w4PPfQQhg4digsXLuCDDz5At27dUFZWJp7riSeeQElJCf785z8jICAAv/76K1asWIGYmBh07dq1yefftWsXpk6dipEjR6JLly6ora3Fp59+CplMhkceeeS2vDdERETUupiUIiIiolbxwAMP4Pjx41i6dCl++OEHrFq1Ci4uLoiOjkZiYiImT5580+dcvnw5ZDIZPv/8c1RWViI2NhbJyckYNGjQLce5ePFiuLm54aOPPkJycjL69euHf//737jnnnvg6uoqrnNzc8PPP/+MN998Exs3bsT69euhVqvRpUsXzJ8/X9wtrt64ceMglUqRlJSEwsJC9OnTB++99x58fX3FNXFxcdi2bRvmzp2L1157DXK5HPfddx8WL15s1U74e+h0OnzwwQdYtGgRJk2aBJPJhN27d98wKfX000+Lv1cqlYiOjsbChQsxcuRI8fiECROQn5+P1atXY/v27ejWrRs+++wzbNy4EXv27BHX/f3vf8eHH36I999/H3q9HjqdDqNHj8a8efMglTZdyN+9e3cMGjQImzdvxqVLl+Dm5obu3btj69at+OMf//j73hQiIiKyC4nQEpMviYiIiO4ier0e7u7uWLBgAV5++eWbemxWVhZCQkKwdOlSPPfccy0UIREREdGdhzOliIiIiBqpqKiwOZaUlAQA+NOf/tS6wRARERHdxdi+R0RERNTIV199hXXr1mHIkCFo164d9u7diy+//BL/93//h9jYWHuHR0RERHTXYFKKiIiIqJHo6Gg4OTlhyZIlMBqN4vDzBQsW2Ds0IiIiorsKZ0oREREREREREVGr40wpIiIiIiIiIiJqdUxKERERERERERFRq7vrZkqZzWbk5uZCpVJBIpHYOxwiIiIiIiIiIociCAJKS0vh5+cHqfTa9VB3XVIqNzcXgYGB9g6DiIiIiIiIiMihXbx4EQEBAde8/65LSqlUKgCWF65Wq+0cDRERERERERGRYzEajQgMDBRzNNdy1yWl6lv21Go1k1JERERERERERHZyo7FKHHROREREREREREStjkkpIiIiIiIiIiJqdS2elFq5ciWCg4Ph6uqKvn374vDhw9ddn5SUhLCwMCgUCgQGBuLZZ59FZWVlS4dJREREREREREStqEVnSn311VeYOXMmPvjgA/Tt2xdJSUkYNGgQMjIy4O3tbbP+iy++wJw5c7BmzRr0798fZ86cwYQJEyCRSPD222/ftrgEQUBtbS1MJtNtOyfR9cjlcshkMnuHQURERERERG2YIAg3nMN0N5EIgiC01Mn79u2LP/zhD3jvvfcAAGazGYGBgXjmmWcwZ84cm/VTp07FqVOnsHPnTvHYrFmzcOjQIezdu7fJ56iqqkJVVZV4u37Cu8FgaHLQeXV1NfLy8lBeXv57Xx5Rs0kkEgQEBKBdu3b2DoWIiIiIiIjaAJNZQGZhGVJz9Ei9qMfxHAP8tK5Y/Y/e9g7tdzMajdBoNNfMzdRrsUqp6upq/PLLL3jxxRfFY1KpFHFxcThw4ECTj+nfvz8+++wzHD58GH369MH58+fx008/4R//+Mc1n2fRokWYP39+s2Iym824cOECZDIZ/Pz84Ozs7FAZSLIPQRBw+fJl5OTkIDQ0lBVTREREREREDkYQBGSXlCM1x4DjdQmo9FwDyqutO7jyDBUOVS3VYkmpoqIimEwm+Pj4WB338fHB6dOnm3zM3/72NxQVFeGee+4RW+yeeuopvPTSS9d8nhdffBEzZ84Ub9dXSjWlurparNZyc3O7hVdFdGu8vLyQlZWFmpoaJqWIiIiIiIjucoXGSksCKkcvftWX19isUzrLEOmvQfdALaIDNOgeoG39YO2oRWdK3aw9e/bgzTffxPvvv4++ffsiMzMT06dPxxtvvIFXX321yce4uLjAxcXlpp5HKuWmg9S6HCXLTURERERE5GgM5TU4fslS/VTfhpdvtN2wzVkmRVdfFaIDtOgeqEX3AA06erWDTOq4nxdbLCnVvn17yGQyFBQUWB0vKCiATqdr8jGvvvoq/vGPf+CJJ54AAERFReHq1auYMmUKXn75ZSaTiIiIiIiIiMhuKqpNOJFrQKqYgNIjq9h2ZrVUAnT2bofuAVpE1yWgwnQquDixc6axFktKOTs7o1evXti5cydGjBgBwDLTaefOnZg6dWqTjykvL7dJPNW3OrXgPHYiIiIiIiIiIis1JjMy8kuRmqPH8YsGpObocbawDCazbX4iyMNNbL+LDtAg0l8DpUubak5rk1r0HZo5cybGjx+P3r17o0+fPkhKSsLVq1fx+OOPAwDGjRsHf39/LFq0CAAwfPhwvP322+jRo4fYvvfqq69i+PDhnMPTTBKJBN9//72YCLzbZWVlISQkBMeOHUNMTIy9wyEiIiIiIqI7kNks4HzRVRzPqWvDy9HjZK4RVbVmm7VeKhd0D9Agui4BFR2ghYfS2Q5R3/laNCk1evRoXL58Ga+99hry8/MRExODbdu2icPPs7OzrSqjXnnlFUgkErzyyiu4dOkSvLy8MHz4cCxcuLAlw7xj5OfnY+HChdiyZQsuXboEb29vxMTEYMaMGRg4cKC9w7OLwMBA5OXloX379s1+zLx587Bp0yakpKT8rufes2cPZs6ciRMnTiAwMBCvvPIKJkyY8LvOSURERERERC1LEATkGipx/GLDEPK0HANKq2pt1qpdnayST90DNdCpXTk3+DZp8VqyqVOnXrNdb8+ePdbBODlh7ty5mDt3bkuHdcfJyspCbGwstFotli5diqioKNTU1GD79u1ISEi45o6GdzuZTHbNGWUt6cKFCxg6dCieeuopfP7559i5cyeeeOIJ+Pr6YtCgQa0eDxERERERETWt5Gq1VQve8Rw9isqqbda5yqWI8NMgOkCDmEAtogO06ODhBqkDDyJvaQ4/OVwQBJRX19rl183MyYqPj4dEIsHhw4fxyCOPoEuXLoiIiMDMmTNx8OBBq7VFRUV46KGH4ObmhtDQUPz444/ifSaTCZMmTUJISAgUCgXCwsKwfPlyq8dPmDABI0aMwLJly+Dr6wtPT08kJCSgpqZh+8q8vDwMHToUCoUCISEh+OKLLxAcHIykpCRxjV6vxxNPPAEvLy+o1Wr8+c9/Rmpqqnj/vHnzEBMTg9WrVyMwMBBubm4YNWoUDAaDuMZsNuP1119HQEAAXFxcxGq7ellZWZBIJGLV0549eyCRSLBz50707t0bbm5u6N+/PzIyMgAA69atw/z585GamgqJRAKJRIJ169ZBEATMmzcPQUFBcHFxgZ+fH6ZNm3bNP48PPvgAISEhSExMRNeuXTF16lQ8+uijeOedd5rxp0lEREREREQtoayqFgfPF2P1z+eQ8PlR3LN4F3q+sQOPrz2Cd5LPYNfpQhSVVcNJKkGEnxpj+wThrYej8NO0e5E+bxC+fbo/5g6PwIMx/ghpr2RCqoU5/NStihoTur223S7PffL1QXBzvvEfQUlJCbZt24aFCxdCqVTa3K/Vaq1uz58/H0uWLMHSpUuxYsUKPPbYY/j111/h4eEBs9mMgIAAbNy4EZ6enti/fz+mTJkCX19fjBo1SjzH7t274evri927dyMzMxOjR49GTEwMJk+eDMAyD6yoqAh79uyBXC7HzJkzUVhYaBXHyJEjoVAosHXrVmg0GqxevRoDBw7EmTNn4OHhAQDIzMzE119/jc2bN8NoNGLSpEmIj4/H559/DgBYvnw5EhMTsXr1avTo0QNr1qzBAw88gBMnTiA0NPSa79nLL7+MxMREeHl54amnnsLEiROxb98+jB49Gunp6di2bRuSk5MBABqNBt9++y3eeecdbNiwAREREcjPz7dKoP3WgQMHEBcXZ3Vs0KBBmDFjxjUfQ0RERERERLdPVa0Jp/JKcTxHj9SLlja8zMtlaKr+o6OXUhxCHh2gRYSfGq5yzq62N4dPSt0JMjMzIQgCwsPDm7V+woQJGDt2LADgzTffxLvvvovDhw9j8ODBkMvlmD9/vrg2JCQEBw4cwNdff22VlHJ3d8d7770HmUyG8PBwDB06FDt37sTkyZNx+vRpJCcn48iRI+jduzcA4OOPP7ZKEu3duxeHDx9GYWEhXFxcAADLli3Dpk2b8M0332DKlCkAgMrKSqxfvx7+/v4AgBUrVmDo0KFITEyETqfDsmXLMHv2bIwZMwYAsHjxYuzevRtJSUlYuXLlNd+DhQsX4r777gMAzJkzB0OHDkVlZSUUCgXatWsHJycnq7a/7Oxs6HQ6xMXFQS6XIygoCH369Lnm+fPz88XZaPV8fHxgNBpRUVEBhUJxzccSERERERHRzTGZBWQWlontd8dzDDiVZ0SNyTYD5adxtcyBCtQgJkCLyAAN1K5yO0RNN+LwSSmFXIaTr9tnBpCimVnZm2nzA4Do6Gjx90qlEmq12qqKaeXKlVizZg2ys7NRUVGB6upqm53rIiIirHY89PX1RVpaGgAgIyMDTk5O6Nmzp3h/586d4e7uLt5OTU1FWVkZPD09rc5bUVGBc+fOibeDgoLEhBQA9OvXD2azGRkZGXBzc0Nubi5iY2OtzhEbG3vdKqbfvge+vr4AgMLCQgQFBTW5fuTIkUhKSkLHjh0xePBgDBkyBMOHD4eTk8NfIkRERERERK1KEARkl5RbhpBftCSg0nMNKK822ax1d5Oje938p/od8bxULnaImm6Fw3/ilkgkzWqhs6fQ0FBIJJJmDzOXy60zwBKJBGazZRvLDRs24LnnnkNiYiL69esHlUqFpUuX4tChQ80+R3OUlZXB19fXZpg9YNtu2BIax1+/K8L14g8MDERGRgaSk5OxY8cOxMfHY+nSpfj5559t3gsA0Ol0KCgosDpWUFAAtVrNKikiIiIiIqKbUGisFHfBS7moR9olA/TlNTbrlM4yRPpr6pJQGnQP0CLAXcGd8O5gbTsbQwAADw8PDBo0CCtXrsS0adNs5krp9fpmJ3r27duH/v37Iz4+XjzWuHKpOcLCwlBbW4tjx46hV69eACwthleuXBHX9OzZE/n5+XByckJwcPA1z5WdnY3c3Fz4+fkBAA4ePAipVIqwsDCo1Wr4+flh3759Yite/Wu4XmvdjTg7O8Nkss2wKxQKDB8+HMOHD0dCQgLCw8ORlpZmVRFWr1+/fvjpp5+sju3YsQP9+vW75biIiIiIiIjudobyGhy/ZKl+Sq2rgso3Vtqsc5ZJ0dVPLVY/dQ/QoKNXO8g4ePyuwqTUHWLlypWIjY1Fnz598PrrryM6Ohq1tbXYsWMHVq1ahVOnTjXrPKGhoVi/fj22b9+OkJAQfPrppzhy5AhCQkKaHUt4eDji4uIwZcoUrFq1CnK5HLNmzYJC0ZChjouLQ79+/TBixAgsWbIEXbp0QW5uLrZs2YKHHnpInEXl6uqK8ePHY9myZTAajZg2bRpGjRolznt6/vnnMXfuXHTq1AkxMTFYu3YtUlJSxEHotyI4OBgXLlxASkoKAgICoFKp8OWXX8JkMqFv375wc3PDZ599BoVCgQ4dOjR5jqeeegrvvfceXnjhBUycOBG7du3C119/jS1bttxyXERERERERHeTimoTTuQaxCqo4zkGXCi6arNOKgFCvVWWIeSBlgRUuE4NZyepHaKm1sSk1B2iY8eOOHr0KBYuXIhZs2YhLy8PXl5e6NWrF1atWtXs8zz55JM4duwYRo8eDYlEgrFjxyI+Ph5bt269qXjWr1+PSZMmYcCAAdDpdFi0aBFOnDgBV1dXAJaWuZ9++gkvv/wyHn/8cVy+fBk6nQ4DBgywGhDeuXNnPPzwwxgyZAhKSkowbNgwvP/+++L906ZNg8FgwKxZs1BYWIhu3brhxx9/vO7OezfyyCOP4LvvvsP9998PvV6PtWvXQqvV4q233sLMmTNhMpkQFRWFzZs328zEqhcSEoItW7bg2WefxfLlyxEQEICPP/4YgwbZZz4ZERERERGRPdWYzMjIL8XxugRUao4BZwpKYTLbzkgO8nBD98CGGVARfmooXZiecEQS4WanaLdxRqMRGo0GBoMBarXa6r7KykpcuHABISEhYvKEbo+cnBwEBgYiOTkZAwcObNZj5s2bh02bNiElJaVlg2sD+L1HRERERER3C7NZwIXiq5bk00VLEupErhFVtbZzfL1ULuheP4Q8UItofw3clc52iJpa0/VyM40xFUm3ZNeuXSgrK0NUVBTy8vLwwgsvIDg4GAMGDLB3aERERERERHSbCIKAXEMljl/Ui214aTkGlFbV2qxVuzohOsAyhDw6QIvugRro1K4cRE7XxKQU3ZKamhq89NJLOH/+PFQqFfr374/PP/+8yZ3qiIiIiIiI6M5QXFZlGUJeNwPqeI4eRWXVNutc5VJE+GnEXfCiAzQI9lRCykHkdBPYvkfUCvi9R0REREREbU1ZVS3SGg0hT83RI+dKhc06mVSCMB8VugfWJ6C06OLTDk4yDiKnprF9j4iIiIiIiIgAAFW1JpzKK7WaA5V5uQxNlal09FKK1U/1g8hd5bLWD5ruekxKEREREREREd1FTGYBmYVlSM3RI/WipQrqdL4RNSbbDJSfxtUyB6quCirSXwONgmNZqHUwKUVERERERER0hxIEAdkl5ZYh5HUJqPRcA8qrTTZrPZTODUPI6756qVzsEDWRBZNSRERERERERHeIQmOluAte/Vd9eY3NOqWzDJH+GnQP1IqteAHuCu6ER20Kk1JEREREREREbZChvAbHL9UNIa+rgso3Vtqsc5ZJ0dVXhe6BWrEKqqNXO8i4Ex61cUxKEREREREREdlZRbUJJ3INDVVQF/XIKi63WSeVAKHeKksbXqAlARWmU8HFiYPI6c7DpNRdRiKR4Pvvv8eIESPsHUqryMrKQkhICI4dO4aYmBh7h0NERERERHRDNSYzMvJLxQqo1Bw9zhaWwWS2HUQe5OGG6ACN2IIX6a+B0oUf5enuwO/kO0h+fj4WLlyILVu24NKlS/D29kZMTAxmzJiBgQMH2js8uwgMDEReXh7at2/f7MfMmzcPmzZtQkpKyi0/b15eHmbNmoX//e9/yMzMxLRp05CUlHTL5yMiIiIioruT2SzgfNFVHM+pa8PL0eNkrhFVtWabtV4qF3EAef1Acg+lsx2iJmodTErdIbKyshAbGwutVoulS5ciKioKNTU12L59OxISEnD69Gl7h2gXMpkMOp2u1Z+3qqoKXl5eeOWVV/DOO++0+vMTEREREVHbIwgCcg2VOH6xYQh5Wo4BpVW1NmvVrk5WyafugRro1K4cRE4ORWrvAOxOEIDqq/b5JdiWZl5LfHw8JBIJDh8+jEceeQRdunRBREQEZs6ciYMHD1qtLSoqwkMPPQQ3NzeEhobixx9/FO8zmUyYNGkSQkJCoFAoEBYWhuXLl1s9fsKECRgxYgSWLVsGX19feHp6IiEhATU1DTs65OXlYejQoVAoFAgJCcEXX3yB4OBgq2ohvV6PJ554Al5eXlCr1fjzn/+M1NRU8f558+YhJiYGq1evRmBgINzc3DBq1CgYDAZxjdlsxuuvv46AgAC4uLggJiYG27ZtE+/PysqCRCIRq5727NkDiUSCnTt3onfv3nBzc0P//v2RkZEBAFi3bh3mz5+P1NRUSCQSSCQSrFu3DoIgYN68eQgKCoKLiwv8/Pwwbdq0a/55BAcHY/ny5Rg3bhw0Gk0z/gSJiIiIiOhuU3K1GrszCrE8+SwmrTuCPyxMRuxbu/D050fxwc/nsP9cMUqrauEql6JXB3dMjA3B8jEx2P3cn5A69//w2RN98cLgcAyO1MFXw53xyPGwUqqmHHjTzz7P/VIu4Ky84bKSkhJs27YNCxcuhFJpu16r1Vrdnj9/PpYsWYKlS5dixYoVeOyxx/Drr7/Cw8MDZrMZAQEB2LhxIzw9PbF//35MmTIFvr6+GDVqlHiO3bt3w9fXF7t370ZmZiZGjx6NmJgYTJ48GQAwbtw4FBUVYc+ePZDL5Zg5cyYKCwut4hg5ciQUCgW2bt0KjUaD1atXY+DAgThz5gw8PDwAAJmZmfj666+xefNmGI1GTJo0CfHx8fj8888BAMuXL0diYiJWr16NHj16YM2aNXjggQdw4sQJhIaGXvM9e/nll5GYmAgvLy889dRTmDhxIvbt24fRo0cjPT0d27ZtQ3JyMgBAo9Hg22+/xTvvvIMNGzYgIiIC+fn5Vgk0IiIiIiJybGVVtUi/1LALXmqOHjlXKmzWyaQShOtU4i540QFadPFpBycZa0KIfotJqTtAZmYmBEFAeHh4s9ZPmDABY8eOBQC8+eabePfdd3H48GEMHjwYcrkc8+fPF9eGhITgwIED+Prrr62SUu7u7njvvfcgk8kQHh6OoUOHYufOnZg8eTJOnz6N5ORkHDlyBL179wYAfPzxx1ZJor179+Lw4cMoLCyEi4sLAGDZsmXYtGkTvvnmG0yZMgUAUFlZifXr18Pf3x8AsGLFCgwdOhSJiYnQ6XRYtmwZZs+ejTFjxgAAFi9ejN27dyMpKQkrV6685nuwcOFC3HfffQCAOXPmYOjQoaisrIRCoUC7du3g5ORk1faXnZ0NnU6HuLg4yOVyBAUFoU+fPs16v4mIiIiI6O5SVWvCqbzSul3wLG14mZfLmmx26eilFIeQRwdoEeGnhqucO+ERNQeTUnI3S8WSvZ67GYSbaPMDgOjoaPH3SqUSarXaqopp5cqVWLNmDbKzs1FRUYHq6mqbnesiIiIgkzX8Rerr64u0tDQAQEZGBpycnNCzZ0/x/s6dO8Pd3V28nZqairKyMnh6elqdt6KiAufOnRNvBwUFiQkpAOjXrx/MZjMyMjLg5uaG3NxcxMbGWp0jNjb2hlVMjd8DX19fAEBhYSGCgoKaXD9y5EgkJSWhY8eOGDx4MIYMGYLhw4fDyYmXCBERERHR3cxkFpBZWCbugnc8x4DT+UbUmGw/h/lpXC1zoAItu+FF+mugUcjtEDXR3YGfuCWSZrXQ2VNoaCgkEkmzh5nL5dZ/KUokEpjNlp0dNmzYgOeeew6JiYno168fVCoVli5dikOHDjX7HM1RVlYGX19f7Nmzx+a+37YbtoTG8df3ZV8v/sDAQGRkZCA5ORk7duxAfHw8li5dip9//tnmvSAiIiIiojuTIAjILim3DCGva8NLzzWgvNpks9bdTS624HUP1CI6QAsvlYsdoia6ezEpdQfw8PDAoEGDsHLlSkybNs1mrpRer292omffvn3o378/4uPjxWONK5eaIywsDLW1tTh27Bh69eoFwNJieOXKFXFNz549kZ+fDycnJwQHB1/zXNnZ2cjNzYWfn2Wu18GDByGVShEWFga1Wg0/Pz/s27dPbMWrfw2/p7XO2dkZJpPtPzoKhQLDhw/H8OHDkZCQgPDwcKSlpVlVhBERERER0Z2j0FiJ1ByDWAWVdskAfXmNzTqlswyR/vXJJ0sVVIA7B48TtTQmpe4QK1euRGxsLPr06YPXX38d0dHRqK2txY4dO7Bq1SqcOnWqWecJDQ3F+vXrsX37doSEhODTTz/FkSNHEBIS0uxYwsPDERcXhylTpmDVqlWQy+WYNWsWFIqGv7Tj4uLQr18/jBgxAkuWLEGXLl2Qm5uLLVu24KGHHhJnUbm6umL8+PFYtmwZjEYjpk2bhlGjRonznp5//nnMnTsXnTp1QkxMDNauXYuUlBRxEPqtCA4OxoULF5CSkoKAgACoVCp8+eWXMJlM6Nu3L9zc3PDZZ59BoVCgQ4cO1zxP/Y5/ZWVluHz5MlJSUuDs7Ixu3brdcmxERERERHRrDBU1SKsbQF4/jDzfWGmzzlkmRVc/tTiEvHuABh292kEmZQKKqLUxKXWH6NixI44ePYqFCxdi1qxZyMvLg5eXF3r16oVVq1Y1+zxPPvkkjh07htGjR0MikWDs2LGIj4/H1q1bbyqe9evXY9KkSRgwYAB0Oh0WLVqEEydOwNXVFYClZe6nn37Cyy+/jMcffxyXL1+GTqfDgAED4OPjI56nc+fOePjhhzFkyBCUlJRg2LBheP/998X7p02bBoPBgFmzZqGwsBDdunXDjz/+eN2d927kkUcewXfffYf7778fer0ea9euhVarxVtvvYWZM2fCZDIhKioKmzdvtpmJ1ViPHj3E3//yyy/44osv0KFDB2RlZd1ybEREREREdGMV1SacyDVY2vDq5kBdKLpqs04qAUK9VZYh5IGWBFS4Tg1nJ+6ER9QWSISbnaLdxhmNRmg0GhgMBqjVaqv7KisrceHCBYSEhIjJE7o9cnJyEBgYiOTkZAwcOLBZj5k3bx42bdokVhzdzfi9R0RERER0a2pMZmTkl+J4XQIqNceAMwWlMJltP8oGebiJ7XfdAy074SldWItB1Nqul5tpjFcn3ZJdu3ahrKwMUVFRyMvLwwsvvIDg4GAMGDDA3qEREREREdEdymwWcL7oqlj9lJqjx8lcI6pqbTct8lK5WIaQB2gRHahFtL8G7kpnO0RNRLeqxZNSK1euxNKlS5Gfn4/u3btjxYoV1x1Srdfr8fLLL+O7775DSUkJOnTogKSkJAwZMqSlQ6WbUFNTg5deegnnz5+HSqVC//798fnnn3OnOiIiIiIiahZBEJBrqMTxi3qxDS8tx4DSqlqbtSpXJ0vyqX4OVKAGOrUrB5ET3eFatH3vq6++wrhx4/DBBx+gb9++SEpKwsaNG5GRkQFvb2+b9dXV1YiNjYW3tzdeeukl+Pv749dff4VWq0X37t2b9Zxs36O2iN97REREROToisuqxOqn+la8orJqm3UuTlJE+mvENrzoAA2CPZWQchA50R2jTbTvvf3225g8eTIef/xxAMAHH3yALVu2YM2aNZgzZ47N+jVr1qCkpAT79+8XK26Cg4NbMkQiIiIiIiK6zcqqapHWaAh5ao4eOVcqbNbJpBKE+ajQPbB+Jzwtuvi0g5OMg8jJwZSXAJeOAoIJ6DLI3tG0mhZLSlVXV+OXX37Biy++KB6TSqWIi4vDgQMHmnzMjz/+iH79+iEhIQE//PADvLy88Le//Q2zZ8+GTCZr8jFVVVWoqqoSbxuNxtv7QoiIiIiIiOiaqmpNOJVXahlCftGSiMq8XIamenI6eimt2vAi/NRwlTf9WY/orlVVBuSlArlHLYmo3KPAlSzLfbpoJqVuh6KiIphMJvj4+Fgd9/HxwenTp5t8zPnz57Fr1y489thj+Omnn5CZmYn4+HjU1NRg7ty5TT5m0aJFmD9//m2Pn4iIiIiIiKyZzAIyC8uQmqNH6kVLFdTpfCNqTLYZKD+NK6IDtIgOtLThRfproFFwBi05mNpqoCC9IQF16ShQlAEItsP74dEJ8IkEBAFwkHlpbWr3PbPZDG9vb3z44YeQyWTo1asXLl26hKVLl14zKfXiiy9i5syZ4m2j0YjAwMDWCpmIiIiIiOiuJAgCskvKLUPI6xJQ6bkGlFebbNZ6KJ0bhpAHaBAVoIG3irNUycGYTUDRmYbqp0tHLQkpk+3sNKj9Ab8egH9PwK+n5fcKbauHbG8tlpRq3749ZDIZCgoKrI4XFBRAp9M1+RhfX1/I5XKrVr2uXbsiPz8f1dXVcHa23d7TxcUFLi4utzd4IiIiIiIiB1NorBR3wav/qi+vsVmndJYh0l+D7oFacRh5gLuCO+GRYxEES8ud2IJ3zNKSV11mu1bhbkk81Seg/HsCqqbzIo6mxZJSzs7O6NWrF3bu3IkRI0YAsFRC7dy5E1OnTm3yMbGxsfjiiy9gNpshlVoG2505cwa+vr5NJqSIiIiIiIjo5hnKa3D8Ut0Q8roqqHxjpc06Z5kUXX1Vlja8AA1iArXo6NUOMu6ER46mtMB6BtSlo0BFie06uRLw7W5JPNUnodyDHaYd72a1aPvezJkzMX78ePTu3Rt9+vRBUlISrl69Ku7GN27cOPj7+2PRokUAgKeffhrvvfcepk+fjmeeeQZnz57Fm2++iWnTprVkmHcViUSC77//XkwE3u2ysrIQEhKCY8eOISYmxt7hEBERERG1ORXVJpzINTRUQV3UI6u43GadRAKEereztOAFWtrwwnQquDhxEDk5mEqDpfKpcQLKeMl2nVQO6CKtq6C8wgApr5nmatGk1OjRo3H58mW89tpryM/PR0xMDLZt2yYOP8/OzhYrogAgMDAQ27dvx7PPPovo6Gj4+/tj+vTpmD17dkuGecfIz8/HwoULsWXLFly6dAne3t6IiYnBjBkzMHDgQHuHZxeBgYHIy8tD+/btm/2YefPmYdOmTUhJSbnl5/3uu++watUqpKSkoKqqChEREZg3bx4GDXKcXRKIiIiIqO2pMZmRkV+K43UJqJSLepwtLIPJbDuIPMjDTWy/iw7QINJfA6VLmxo7TNTyaiqA/DTg0i8NSajizCYWSiwJp8YJKF0k4MRxQr9Hi/+NM3Xq1Gu26+3Zs8fmWL9+/XDw4MEWjurOk5WVhdjYWGi1WixduhRRUVGoqanB9u3bkZCQcM0dDe92MpnsmjPKWtJ//vMf/OUvf8Gbb74JrVaLtWvXYvjw4Th06BB69OjR6vEQERERkeMxmwWcL7qK4zl1bXg5epzMNaKq1nZXLy+VC7rXDyIP1CLaXwN3JUekkIMx1QKFJ63b8ApPAeZa27XaDtYzoHy7Ay6q1o/5LufwaXBBEFBRW2GX51Y4NX8YYHx8PCQSCQ4fPgylUikej4iIwMSJE63WFhUV4aGHHsL27dvh7++PxMREPPDAAwAAk8mEKVOmYNeuXcjPz0dQUBDi4+Mxffp08fETJkyAXq/HPffcg8TERFRXV2PMmDFISkqCXG7ZwjUvLw9PPPEEdu3aBZ1Oh4ULF+Kll17CjBkzMGPGDACAXq/Hc889hx9++AFVVVXo3bs33nnnHXTv3h1AQ8XS008/jQULFqC4uBjDhg3DRx99BI1GA8Ayh2zBggX48MMPcfnyZXTt2hVvvfUWBg8eDMC2fW/Pnj24//77kZycjNmzZ+PkyZOIiYnB2rVrERYWhnXr1mH+/PkAIL73a9euxfjx4zF//nysWbMGBQUF8PT0xKOPPop33323yT+PpKQkq9tvvvkmfvjhB2zevJlJKSIiIiK67QRBQK6hEscvNgwhT8sxoLTK9sO02tVJnAFlSUJpoFO7chA5ORazGSg5b52AyjsONPX5X+ltnYDy6wkoPVs/Zgfk8EmpitoK9P2ir12e+9DfDsFN7nbDdSUlJdi2bRsWLlxolZCqp9VqrW7Pnz8fS5YswdKlS7FixQo89thj+PXXX+Hh4QGz2YyAgABs3LgRnp6e2L9/P6ZMmQJfX1+MGjVKPMfu3bvh6+uL3bt3IzMzE6NHj0ZMTAwmT54MwDIPrKioCHv27IFcLsfMmTNRWFhoFcfIkSOhUCiwdetWaDQarF69GgMHDsSZM2fg4eEBAMjMzMTXX3+NzZs3w2g0YtKkSYiPj8fnn38OAFi+fDkSExOxevVq9OjRA2vWrMEDDzyAEydOIDQ09Jrv2csvv4zExER4eXnhqaeewsSJE7Fv3z6MHj0a6enp2LZtG5KTkwEAGo0G3377Ld555x1s2LABERERyM/PR2pq6g3/bOqZzWaUlpaKr4uIiIiI6PcouVqN1Bw9jl+s3w1Pj6Iy223lXeVSRPhpxCHk0QFadPBwg5SDyMmRCAJgzP3NIPJjQJXBdq2LGvCLqUtA9bIkodT+HERuJw6flLoTZGZmQhAEhIeHN2v9hAkTMHbsWACWCp53330Xhw8fxuDBgyGXy8VKIQAICQnBgQMH8PXXX1slpdzd3fHee+9BJpMhPDwcQ4cOxc6dOzF58mScPn0aycnJOHLkCHr37g0A+Pjjj62SRHv37sXhw4dRWFgIFxdLj+2yZcuwadMmfPPNN5gyZQoAoLKyEuvXr4e/vz8AYMWKFRg6dCgSExOh0+mwbNkyzJ49G2PGjAEALF68GLt370ZSUhJWrlx5zfdg4cKFuO+++wAAc+bMwdChQ1FZWQmFQoF27drBycnJqu0vOzsbOp0OcXFxkMvlCAoKQp8+fZr1fte/trKyMqv3kIiIiIioOa5W1SLtUn3yybIbXs4V22oOmVSCMB+VOIQ8OkCLLj7t4CSTNnFWortYeUlDAqo+CVVWYLvOyRXQRVtXQXl0AqS8ZtoKh09KKZwUOPS3Q3Z77uYQBNuhhNcTHR0t/l6pVEKtVltVMa1cuRJr1qxBdnY2KioqUF1dbbNzXUREBGSyhh0DfH19kZaWBgDIyMiAk5MTevbsKd7fuXNnuLu7i7dTU1NRVlYGT0/rkseKigqcO3dOvB0UFCQmpADLTDGz2YyMjAy4ubkhNzcXsbGxVueIjY29YRVT4/fA19cXAFBYWIigoKAm148cORJJSUno2LEjBg8ejCFDhmD48OFwcrrxJfLFF19g/vz5+OGHH+Dt7X3D9URERETkuKpqTTiVV1q3C54lEZV5uQxN/Ze/o5dSHEIeHaBFhJ8arnLu6kUOpqoMyEu1roK6kmW7TiIDvLsB/j0aElDe3QCZvNVDpuZz+KSURCJpVgudPYWGhkIikTR7mHn93Kd6EokEZrNl2OGGDRvw3HPPITExEf369YNKpcLSpUtx6NChZp+jOcrKyuDr69vkMPvfthu2hMbx1/fOXy/+wMBAZGRkIDk5GTt27EB8fDyWLl2Kn3/+2ea9aGzDhg144oknsHHjRsTFxd2+F0BEREREdzyTWUBmYRlSL1ra747nGHA634gak20Gyk/japkDFWjZDS/SXwONgh+mycHUVgEF6XXJp2OWr0UZgNDEZzmPTo0qoHoBuijAuW1/tidbDp+UuhN4eHhg0KBBWLlyJaZNm2YzV0qv1zc70bNv3z70798f8fHx4rHGlUvNERYWhtraWhw7dgy9evUCYGkxvHLlirimZ8+eyM/Ph5OTE4KDg695ruzsbOTm5sLPzw8AcPDgQUilUoSFhUGtVsPPzw/79u0TW/HqX8PNtNb9lrOzM0wmk81xhUKB4cOHY/jw4UhISEB4eDjS0tKsKsIa+/LLLzFx4kRs2LABQ4cOveV4iIiIiOjOJwgCskvKLUPIL1oSUOm5BpRX2/6/091NLu6CV9+G56XitvLkYMwmoOhMoxlQRy0JKZPt7DSo/QG/Hg1JKL8YQOFuu47uOExK3SFWrlyJ2NhY9OnTB6+//jqio6NRW1uLHTt2YNWqVTh16lSzzhMaGor169dj+/btCAkJwaeffoojR44gJCSk2bGEh4cjLi4OU6ZMwapVqyCXyzFr1iwoFA27CcbFxaFfv34YMWIElixZgi5duiA3NxdbtmzBQw89JM6icnV1xfjx47Fs2TIYjUZMmzYNo0aNEuc9Pf/885g7dy46deok7qKXkpIiDkK/FcHBwbhw4QJSUlIQEBAAlUqFL7/8EiaTCX379oWbmxs+++wzKBQKdOjQoclzfPHFFxg/fjyWL1+Ovn37Ij8/H4AlsVW/cyARERER3b0KjZXiLnj1X/XlNTbrlM4yRPpr0D3Q0obXPUCLAPfm78JNdFcQBED/q3UCKi8VqC6zXatwtx5C7tcTUPm0fszUKpiUukN07NgRR48excKFCzFr1izk5eXBy8sLvXr1wqpVq5p9nieffBLHjh3D6NGjIZFIMHbsWMTHx2Pr1q03Fc/69esxadIkDBgwADqdDosWLcKJEyfg6uoKwNIy99NPP+Hll1/G448/jsuXL0On02HAgAHw8Wn4C6Vz5854+OGHMWTIEJSUlGDYsGF4//33xfunTZsGg8GAWbNmobCwEN26dcOPP/543Z33buSRRx7Bd999h/vvvx96vR5r166FVqvFW2+9hZkzZ8JkMiEqKgqbN2+2mYlV78MPP0RtbS0SEhKQkJAgHh8/fjzWrVt3y7ERERERUdtjqKhBWo6hrgXPMgsq31hps85ZJkVXX1VdAspSBdXRqx1k3AmPHE1ZYd0Q8l8sSajcY0B5se06ubJuJ7xGVVDuwdwJz4FIhJudot3GGY1GaDQaGAwGqNVqq/sqKytx4cIFhISEiMkTuj1ycnIQGBiI5ORkDBw4sFmPmTdvHjZt2oSUlJSWDa4N4PceERER0Z2hotqEk3kGpNQNIT+eY8CFoqs266QSINRbZRlCXteGF65Tw9mJu3qRg6k0ALkpDQmoS8cAY47tOqkc0EU2DCH36wl4hQFSDu+/G10vN9MYK6XoluzatQtlZWWIiopCXl4eXnjhBQQHB2PAgAH2Do2IiIiIqFlqTGZk5JfieKM2vDMFpTCZbX9uH+ThJrbfRQdoEOmvgdKFH6fIwdRUAPlp1m14xWebWCixJJzqE1D+PQGfSMCJs9PIGv8WpVtSU1ODl156CefPn4dKpUL//v3x+eefX3enOiIiIiIiezGbBZwvuipWP6Xm6HEy14iqWttdvbxULuIA8u6BWkT7a+CudLZD1ER2ZKoBCk81JJ9yj1pum2tt12qDrOdA+XYHXFStHzPdcdi+R9QK+L1HRERE1HoEQUCuoRLHLzYMIU/LMaC0yvbDtMrVydKCVzcDqnugFjq1KweRk2Mxm4GS83UJqF8sSaj840Ct7ew0KL0b2u/8e1rmQSnbt37M1KaxfY+IiIiIiBxCydVqpObokXpRL7biFZXZbivv4iRFpL/Gqg0v2FMJKQeRkyMRBMCY22gG1FHLTKgqg+1aF3XdIPJGc6A0ARxETrcNk1JERERERHTHKKuqRVqOwaoNL+dKhc06mVSCMB8VugdaqqCiAzTo4qOCXMZB5ORgykusZ0DlHgXKCmzXObkCuijrBJRnZ0DKa4ZaDpNSRERERETUJlXVmnAqr9QyhLxuN7zMy2VoagBJRy+lWP0UHaBFhJ8arnLu6kUOpqoMyEu1TkBdybJdJ5EB3t0A/x4NSSjvboCMM4KpdTEpRUREREREdmcyC8gsLENqjl6sgjqVZ0SNyTYD5adxtVQ/BVra8CL9NdAo+GGaHExtNVCQXpeAOmZpxyvKAATb4f3w6NQwhNyvp6Uiytmt9WMm+g0mpYiIiIiIqFUJgoDsknLLEPK6OVDpuQaUV5ts1rq7yS074NUNIo8O0MJLxW3lycGYTUDRGes2vIJ0wGQ7Ow1qf8vw8foElF8PQKFt9ZCJmoNJKSIiIiIialGFxkqk5hiQelGP1Bw90i4ZoC+vsVmndJYh0l9Tl4SyVEEFuCu4Ex45FkGwtNyJLXjHLC151WW2axXu1jOg/HsCKl2rh0x0q5iUustIJBJ8//33GDFihL1DaRVZWVkICQnBsWPHEBMTY+9wiIiIiByeobwGxy/VDSGvq4LKN9puK+8sk6Krr0ocQt49UItOXu0g40545GhKC6xnQF06ClSU2K6TKwHf7nUJqB6Wdjz3YO6ER3c0JqXuIPn5+Vi4cCG2bNmCS5cuwdvbGzExMZgxYwYGDhxo7/DsIjAwEHl5eWjfvn2zHzNv3jxs2rQJKSkpt/y8e/fuxezZs3H69GmUl5ejQ4cOePLJJ/Hss8/e8jmJiIiI7jQV1SacyDVY2vDq5kBdKLpqs04iAUK924kteN0DtQjTqeDixEHk5GAqDZbKp8YJKOMl23VSOeATYUlA+feyVEF5hQFSXjN0d2FS6g6RlZWF2NhYaLVaLF26FFFRUaipqcH27duRkJCA06dP2ztEu5DJZNDpWr88ValUYurUqYiOjoZSqcTevXvx5JNPQqlUYsqUKa0eDxEREVFLqzGZkZFfiuN1CajUHAPOFJTCZLYdRB7k4Sa230UHaBDpr4HShR89yMHUVAD5aZYB5PVJqOLMJhZKLAmnxm14ukjAibPT6O7n8P8yCIIAoaLCLs8tUTS/Pz4+Ph4SiQSHDx+GUqkUj0dERGDixIlWa4uKivDQQw9h+/bt8Pf3R2JiIh544AEAgMlkwpQpU7Br1y7k5+cjKCgI8fHxmD59uvj4CRMmQK/X45577kFiYiKqq6sxZswYJCUlQS637GqSl5eHJ554Art27YJOp8PChQvx0ksvYcaMGZgxYwYAQK/X47nnnsMPP/yAqqoq9O7dG++88w66d+8OoKFi6emnn8aCBQtQXFyMYcOG4aOPPoJGowEAmM1mLFiwAB9++CEuX76Mrl274q233sLgwYMB2Lbv7dmzB/fffz+Sk5Mxe/ZsnDx5EjExMVi7di3CwsKwbt06zJ8/3/L+1733a9euxfjx4zF//nysWbMGBQUF8PT0xKOPPop33323yT+PHj16oEePHuLt4OBgfPfdd/jvf//LpBQRERHd8cxmAReKr1qSTxcNSM3R42SuEVW1trt6ealc0L1+CHmgFtH+Grgrne0QNZEdmWqBwpPWbXiFpwBzre1abQfrGVC+3QEXVevHTNQGMClVUYGMnr3s8txhR3+BxO3G23CWlJRg27ZtWLhwoVVCqp5Wq7W6PX/+fCxZsgRLly7FihUr8Nhjj+HXX3+Fh4cHzGYzAgICsHHjRnh6emL//v2YMmUKfH19MWrUKPEcu3fvhq+vL3bv3o3MzEyMHj0aMTExmDx5MgBg3LhxKCoqwp49eyCXyzFz5kwUFhZaxTFy5EgoFAps3boVGo0Gq1evxsCBA3HmzBl4eHgAADIzM/H1119j8+bNMBqNmDRpEuLj4/H5558DAJYvX47ExESsXr0aPXr0wJo1a/DAAw/gxIkTCA0NveZ79vLLLyMxMRFeXl546qmnMHHiROzbtw+jR49Geno6tm3bhuTkZACARqPBt99+i3feeQcbNmxAREQE8vPzkZqaesM/m3rHjh3D/v37sWDBgmY/hoiIiKgtEAQBeYbKuiHkliqotBwDSqtsP0yrXZ3EGVDRAVp0D9RAp3blIHJyLGYzUHLeOgGVdxyobaLYQeltnYDy6wkoPVs/ZqI2yuGTUneCzMxMCIKA8PDwZq2fMGECxo4dCwB488038e677+Lw4cMYPHgw5HK5WCkEACEhIThw4AC+/vprq6SUu7s73nvvPchkMoSHh2Po0KHYuXMnJk+ejNOnTyM5ORlHjhxB7969AQAff/yxVZJo7969OHz4MAoLC+HiYik7XbZsGTZt2oRvvvlGrCaqrKzE+vXr4e/vDwBYsWIFhg4disTEROh0OixbtgyzZ8/GmDFjAACLFy/G7t27kZSUhJUrV17zPVi4cCHuu+8+AMCcOXMwdOhQVFZWQqFQoF27dnBycrJq+8vOzoZOp0NcXBzkcjmCgoLQp0+fG77XAQEBuHz5MmprazFv3jw88cQTN3wMERERkT2VXK1Gao4exy82tOEVlVXZrHOVSxHhp7Fqwwv2VELKQeTkSAQBMOZaJ6Byj1lmQ/2Wixrwi6lLQPWyJKHU/hxETnQdDp+UkigUCDv6i92euzkEwbZP/3qio6PF3yuVSqjVaqsqppUrV2LNmjXIzs5GRUUFqqurbXaui4iIgEzWMETP19cXaWlpAICMjAw4OTmhZ8+e4v2dO3eGu7u7eDs1NRVlZWXw9LT+KUBFRQXOnTsn3g4KChITUgDQr18/mM1mZGRkwM3NDbm5uYiNjbU6R2xs7A2rmBq/B76+vgCAwsJCBAUFNbl+5MiRSEpKQseOHTF48GAMGTIEw4cPh5PT9S+R//73vygrK8PBgwcxZ84cdO7cWUwIEhEREdlbWVUt0i81JJ+O5+hxscS2mkMmlSDMR4XugRqxEirMRwUnmdQOURPZUXmJ9RDy3KNAWYHtOpkL4BvdMITcvyfg0QmQ8pohuhlMSkkkzWqhs6fQ0FBIJJJmDzOvn/tUTyKRwGy29P9v2LABzz33HBITE9GvXz+oVCosXboUhw4davY5mqOsrAy+vr7Ys2ePzX2/bTdsCY3jry8nv178gYGByMjIQHJyMnbs2IH4+HgsXboUP//8s8170VhISAgAICoqCgUFBZg3bx6TUkRERGQXVbUmnMorFedAHc/RI/NyGZr6+WZHL6VY/RQdoEWEnxqucu7qRQ6mqgzIS21IQF36BdD/artOIgO8uwH+PRoSUN7dANm1PycQUfM4fFLqTuDh4YFBgwZh5cqVmDZtms1cKb1e3+xEz759+9C/f3/Ex8eLxxpXLjVHWFgYamtrcezYMfTqZZnHlZmZiStXrohrevbsifz8fDg5OSE4OPia58rOzkZubi78/PwAAAcPHoRUKkVYWBjUajX8/Pywb98+sRWv/jU0p7XuWpydnWEymWyOKxQKDB8+HMOHD0dCQgLCw8ORlpZmVRF2PWazGVVVtqXvRERERLebySwgs7AMqTl6pF7U43iOAafzjagx2Wag/DSuluqnQEsbXqS/BhoFP0yTg6mtAgrS66qfjlm+FmUAQhM/uPbo1GgOVC9AFwU4t+1CBqI7FZNSd4iVK1ciNjYWffr0weuvv47o6GjU1tZix44dWLVqFU6dOtWs84SGhmL9+vXYvn07QkJC8Omnn+LIkSNixU9zhIeHIy4uDlOmTMGqVasgl8sxa9YsKBrtJhgXF4d+/fphxIgRWLJkCbp06YLc3Fxs2bIFDz30kDiLytXVFePHj8eyZctgNBoxbdo0jBo1Spz39Pzzz2Pu3Lno1KmTuIteSkqKOAj9VgQHB+PChQtISUlBQEAAVCoVvvzyS5hMJvTt2xdubm747LPPoFAo0KFDhybPsXLlSgQFBYlzvv7zn/9g2bJlmDZt2i3HRURERNQUQRCQXVJuab+rS0Cl5xpQXm37QzYPpXPDEPK6r14qbitPDsZsAorOWLfhFaQDpmrbtWp/wK9HQxLKLwZQuNuuI6IWwaTUHaJjx444evQoFi5ciFmzZiEvLw9eXl7o1asXVq1a1ezzPPnkkzh27BhGjx4NiUSCsWPHIj4+Hlu3br2peNavX49JkyZhwIAB0Ol0WLRoEU6cOAFXV1cAlpa5n376CS+//DIef/xxXL58GTqdDgMGDICPj494ns6dO+Phhx/GkCFDUFJSgmHDhuH9998X7582bRoMBgNmzZqFwsJCdOvWDT/++ON1d967kUceeQTfffcd7r//fuj1eqxduxZarRZvvfUWZs6cCZPJhKioKGzevNlmJlY9s9mMF198ERcuXICTkxM6deqExYsX48knn7zluIiIiIgAoNBYKc5/qv+qL6+xWad0liHSX4PugVpxGHmAu4I74ZFjEQRLy52YgDoG5KUA1WW2axXuDe13/r0sySiVznYdEbUaiXCzU7TbOKPRCI1GA4PBALVabXVfZWUlLly4gJCQEDF5QrdHTk4OAgMDkZycjIEDBzbrMfPmzcOmTZuQkpLSssG1AfzeIyIioqYYKmqQlmOw7IZXNwsq31hps85ZJkVXX5WlAirQUgXV0asdZNwJjxxNWWGjBNQvlla88mLbdXJl3U54jaqg3IO5Ex5RK7lebqYxVkrRLdm1axfKysoQFRWFvLw8vPDCCwgODsaAAQPsHRoRERFRm1RRbcLJPANSL9YnoQy4UHTVZp1UAnT2bmeVgArTqeDixEHk5GAqDQ3zn+qroIw5tuukckAX2VAF5dcT8AoDpLxmiNo6JqXoltTU1OCll17C+fPnoVKp0L9/f3z++efX3amOiIiIyFHUmMzIyC/F8UZteGcKSmEy2zYpBHm4ie130QEaRPproHThf9PJwdRUAPlpDbvg5R4FijObWCixJJwaJ6B0kYATZ6cR3YlapX1v5cqVWLp0KfLz89G9e3esWLGiWbunbdiwAWPHjsWDDz6ITZs2Neu52L5HbRG/94iIiO5eZrOA80VXcbyu+ik1R4+TuUZU1dru6tW+nQtiAi0DyOsHknsone0QNZEdmWqAwlMNQ8hzj1pum2tt12qDrOdA+XYHXFStHzMR3ZQ207731VdfYebMmfjggw/Qt29fJCUlYdCgQcjIyIC3t/c1H5eVlYXnnnsO9957b0uHSERERETULIIgINdQieMXG4aQp+UYUFpl+2Fa5epktRNe90AtdGpXDiInx2I2AyXnGxJQl34B8o8Dtbaz06D0qktA9aqrguoBKNu3fsxE1GpaPCn19ttvY/LkyXj88ccBAB988AG2bNmCNWvWYM6cOU0+xmQy4bHHHsP8+fPx3//+F3q9/prnr6qqQlVVlXjbaDTe1viJiIiIyHGVXK22zH+6WN+Gp0dRme228i5OUkT4qetmQFmqoII9lZByEDk5EkEAjLkNQ8gvHQVyU4Aqg+1aF3XdIPJGbXiaAA4iJ4ciCAIull5EelE60ovTkV6UDh83Hyy9b6m9Q2s1LZqUqq6uxi+//IIXX3xRPCaVShEXF4cDBw5c83Gvv/46vL29MWnSJPz3v/+97nMsWrQI8+fPv20xExEREZFjKquqRfolA1IvNrTh5VypsFknk0oQ5qNC90ZteF18VJDLpHaImsiOyksaDSGv+1pWYLvOyRXQRVkqoOqTUB6dACmvGXIsBVcLkF6cjhNFJ5BelI4TxSdgrLYurPF09YQgCA5TVduiSamioiKYTCb4+PhYHffx8cHp06ebfMzevXvxySefICUlpVnP8eKLL2LmzJnibaPRiMDAwFuOmYiIiIjuflW1JpzOK0Vqjh6pdVVQmZfL0NS01Y5eSrH6KTpAiwg/NVzl3NWLHExVGZCXap2AupJlu04iA7y7Af49GhJQ3t0AGTdEIsdiqDJYkk91FVAnik6gsKLQZp2z1BnhHuGIaB+ByPaRiPSMtEO09tOmtvUoLS3FP/7xD3z00Udo3755vcMuLi5wceFOC0RERETUNJNZQGZhmaUNr24Y+ak8I2pMthkoP42rpfop0LIbXqS/BhoFP0yTg6mtAgrS65JPxyxfizIAwXZ4Pzw6NQwh9+tpqYhydmv9mInsqLymHKdLTlva8Opa8S6WXrRZJ5VI0UnbCVHtoxDhaUlChWpDIXfgpG2LJqXat28PmUyGggLrEs6CggLodDqb9efOnUNWVhaGDx8uHjObLX/xOTk5ISMjA506dWrJkImIiIjoDiYIArJLyi1DyOva8NJzDSivNtmsdXeTW4aQB1oGkUcHaOGl4g87ycGYTUDRGes2vIJ0wGQ7Ow0qv7oEVN0MKL8YQOHe6iET2VONuQZnr5y1SkCd05+DuYmkbZAqyFIB5RmJyPaRCPcIh5ucSdvGWjQp5ezsjF69emHnzp0YMWIEAEuSaefOnZg6darN+vDwcKSlpVkde+WVV1BaWorly5ezLa8ZJBIJvv/+e/H9vttlZWUhJCQEx44dQ0xMjL3DISIiolZWaKwUd8FLuahH2iUD9OU1NuvcnGWI8rfsgBcdYKmCCnBXOMzMDiIAlkHk+l8bDSE/ZmnJqy6zXatwtx5C7t8TUNkWFhDdzcyCGVmGLKsWvNMlp1Fttk3aeiu8rVrwItpHQOOisUPUd5YWb9+bOXMmxo8fj969e6NPnz5ISkrC1atXxd34xo0bB39/fyxatAiurq6IjLTun9RqtQBgc9wR5efnY+HChdiyZQsuXboEb29vxMTEYMaMGRg4cKC9w7OLwMBA5OXlNbvdEwDmzZuHTZs2NXtu2Y3s27cP9913HyIjI2/bOYmIiMiWoaIGaXUDyOuHkecbbbeVd5ZJ0dVXJQ4h7x6oRSevdpBxJzxyNKUF1jOgLh0FKkps18ndAN+YugRUD8tX9xDuhEcORRAE5F7NFZNP6cXpOFl8EldrrtqsVTurxfa7+kooH6VPE2elG2nxpNTo0aNx+fJlvPbaa8jPz0dMTAy2bdsmDj/Pzs6GlLsu3FBWVhZiY2Oh1WqxdOlSREVFoaamBtu3b0dCQsI1B8ff7WQyWZOtoK1Fr9dj3LhxGDhwoE2bKhEREd26imoTTuQaxCqo4zkGXCiy/WAgkQCh3u0sbXh1CagwnQouThxETg6m0tAw/yn3KHDpGGDMsV0nlQM+EZYZUPVVUF5hgJTXDDmW4opinCg+IbbhnSg+gZJK26StwkmBrh5drdrwAlWBrLS9TSSC0NQeI3cuo9EIjUYDg8EAtVptdV9lZSUuXLiAkJAQuLq6ArBkQ2urmxjY1wqcnKXN/kYeMmQIjh8/joyMDCiVSqv79Hq9WFEmkUjw0UcfYcuWLdi+fTv8/f2RmJiIBx54AABgMpkwZcoU7Nq1C/n5+QgKCkJ8fDymT58unm/ChAnQ6/W45557kJiYiOrqaowZMwZJSUmQyy0D2PLy8vDEE09g165d0Ol0WLhwIV566SXMmDEDM2bMEON67rnn8MMPP6Cqqgq9e/fGO++8g+7duwNoqFh6+umnsWDBAhQXF2PYsGH46KOPoNFYyhzNZjMWLFiADz/8EJcvX0bXrl3x1ltvYfDgwQBs2/f27NmD+++/H8nJyZg9ezZOnjyJmJgYrF27FmFhYVi3bp1YpVdv7dq1GD9+PObPn481a9agoKAAnp6eePTRR/Huu+9e989lzJgxCA0NhUwmu271VVPfe0RERGRRYzIjI78Ux+sSUKk5BpwpKIXJbPvf1CAPN7H9LjpAg0h/DZQubWrvHqKWV1MB5Kc1SkD9AhRnNrFQYkk4NW7D00UCTpydRo6lrLoMJ4tPim146UXpyLuaZ7POSeKEUPdQRLaPtAwjbx+BjpqOcJLy35mbdb3cTGMO/87WVpvx4fSf7fLcU5bfB7nLjX8iUVJSgm3btmHhwoU2CSmgocWx3vz587FkyRIsXboUK1aswGOPPYZff/0VHh4eMJvNCAgIwMaNG+Hp6Yn9+/djypQp8PX1xahRo8Rz7N69G76+vti9ezcyMzMxevRoxMTEYPLkyQAsbZdFRUXYs2cP5HI5Zs6cicJC6+0tR44cCYVCga1bt0Kj0WD16tUYOHAgzpw5Aw8PDwBAZmYmvv76a2zevBlGoxGTJk1CfHw8Pv/8cwDA8uXLkZiYiNWrV6NHjx5Ys2YNHnjgAZw4cQKhoaHXfM9efvllJCYmwsvLC0899RQmTpyIffv2YfTo0UhPT8e2bduQnJwMANBoNPj222/xzjvvYMOGDYiIiEB+fj5SU1Ov++eydu1anD9/Hp999hkWLFhw3bVERERkYTYLuFB81ZJ8umhpxTuZa0RVre0PCb1ULuIA8u6BWkT7a+CudLZD1ER2ZKoFLp9qNAfqKFB4CjDX2q7VdrCeAeXbHXBRtX7MRHZUZaoSd8Krb8PLMmRBgPUPOiSQIEQTYmnBq2vFC/MIg4uMSdvW5PBJqTtBZmYmBEFAeHh4s9ZPmDABY8eOBQC8+eabePfdd3H48GEMHjwYcrkc8+fPF9eGhITgwIED+Prrr62SUu7u7njvvfcgk8kQHh6OoUOHYufOnZg8eTJOnz6N5ORkHDlyBL179wYAfPzxx1ZJor179+Lw4cMoLCyEi4vlol62bBk2bdqEb775BlOmTAFgqSBav349/P39AQArVqzA0KFDkZiYCJ1Oh2XLlmH27NkYM2YMAGDx4sXYvXs3kpKSsHLlymu+BwsXLsR9990HAJgzZw6GDh2KyspKKBQKtGvXDk5OTlZtf9nZ2dDpdIiLi4NcLkdQUBD69OlzzfOfPXsWc+bMwX//+184OfEyIiIiaoogCMg1VOL4Rb3YhpeWY0Bple2HabWrkzgDypKE0kCndmV7BDkWQQBKzlsnoPKOA7UVtmuV3tYJKL8egLL5c1aJ7ga15lqc05+zasM7e+UsagXbf2f8lH5Wg8i7eXZDO+d2doiaGnP4T9NOzlJMWX6f3Z67OW62wzI6Olr8vVKphFqttqpiWrlyJdasWYPs7GxUVFSgurraZue6iIgIyGQNVVy+vr7izogZGRlwcnJCz549xfs7d+4Md/eG7WBTU1NRVlYGT09Pq/NWVFTg3Llz4u2goCAxIQUA/fr1g9lsRkZGBtzc3JCbm4vY2Firc8TGxt6wiqnxe+Dr6wsAKCwsRFBQUJPrR44ciaSkJHTs2BGDBw/GkCFDMHz48CYTTiaTCX/7298wf/58dOnS5bpxEBEROZKSq9VWQ8iP5+hRVGa7Q5GrXIoIP41VG16wpxJSDiInRyIIgDHXehB57jHLbKjfclEDfjENCSj/XoDan4PIyaEIgoCLpReRXpSOtKI0nCi27IRX0UTS1sPVAxGeEWILXoRnBDwVnk2clezN4ZNSEomkWS109hQaGgqJRNLsYeb1c5/qSSQSmM2WkvgNGzbgueeeQ2JiIvr16weVSoWlS5fi0KFDzT5Hc5SVlcHX1xd79uyxue+37YYtoXH89T9hvV78gYGByMjIQHJyMnbs2IH4+HgsXboUP//8s817UVpaiv/97384duwYpk6dKp5bEAQ4OTnh3//+N/785z+3wKsiIiJqO8qqapHWaAh5ao4eOVdsPxjIpBKE+ajQPbA+AaVFF592cJJxoxtyMOUl1rvg5R4FyprYKEfmAvhGWxJP9Ukoj04AN4ciB1NwtQDpxXUteHWDyI3VRpt1SrkSEZ4RVoPIfZW+rLS9Qzh8UupO4OHhgUGDBmHlypWYNm3adQed38i+ffvQv39/xMfHi8caVy41R1hYGGpra3Hs2DH06tULgKXF8MqVK+Kanj17Ij8/H05OTggODr7mubKzs5Gbmws/Pz8AwMGDByGVShEWFga1Wg0/Pz/s27dPbMWrfw3Xa627EWdnZ5hMJpvjCoUCw4cPx/Dhw5GQkIDw8HCkpaVZVYQBgFqtFqvG6r3//vvYtWsXvvnmG4SEhNxybERERG1RVa0Jp/JKxTlQx3P0yLxchqaKuTu2V1oqoAItCagIPzVc5W37B4BEt11VGZCX2pCAuvQLoP/Vdp1EBnh3A/x7NCSgvLsBMrntWqK7mKHKIM5/SitKw4miE7hccdlmnbPUGeEe4VZteMGaYEglTNreqZiUukOsXLkSsbGx6NOnD15//XVER0ejtrYWO3bswKpVq3Dq1KlmnSc0NBTr16/H9u3bERISgk8//RRHjhy5qURKeHg44uLiMGXKFKxatQpyuRyzZs2CQqEQs9FxcXHo168fRowYgSVLlqBLly7Izc3Fli1b8NBDD4mzqFxdXTF+/HgsW7YMRqMR06ZNw6hRo8R5T88//zzmzp2LTp06ibvopaSkiIPQb0VwcDAuXLiAlJQUBAQEQKVS4csvv4TJZELfvn3h5uaGzz77DAqFAh06dLB5vFQqRWRkpNUxb29vuLq62hwnIiK605jMAjILy6za8E7nG1Fjss1A+WlcLXOg6qqgIv010Cj4YZocTG01UJBuSTzlHrMkoYoyAKGJKn2PTo3mQPUCdFGAs1vrx0xkR+U15ThVcspqEPnF0os266QSKTppO4nVTxHtI9BF2wVyJm3vKkxK3SE6duyIo0ePYuHChZg1axby8vLg5eWFXr16YdWqVc0+z5NPPoljx45h9OjRkEgkGDt2LOLj47F169abimf9+vWYNGkSBgwYAJ1Oh0WLFuHEiRNwdXUFYGmZ++mnn/Dyyy/j8ccfx+XLl6HT6TBgwAD4+PiI5+ncuTMefvhhDBkyBCUlJRg2bBjef/998f5p06bBYDBg1qxZKCwsRLdu3fDjjz9ed+e9G3nkkUfw3Xff4f7774der8fatWuh1Wrx1ltvYebMmTCZTIiKisLmzZttZmIRERHdTQRBwMWSCqTk6HG8LgGVnmtAebVtRbGH0rlhCHndVy8VdygiB2M2AUVnrNvwCtIBk+3sNKj9LcPH65NQfjGAwt12HdFdrMZUgzP6M2ILXnpxOs7pz8HcRNI2UBWISM9IsQqqq0dXuMmZtL3bSYSbnaLdxhmNRmg0GhgMBqjVaqv7KisrceHCBYSEhIjJE7o9cnJyEBgYiOTkZAwcOLBZj5k3bx42bdqElJSUlg2uDeD3HhERtQWFxkpxF7zUHAPScvS4Ul5js07pLEOkf30LnqUKKsBdwfkc5FgEwdJyJyagjgF5KUB1me1ahXujXfDqvqp0tuuI7mJmwYwsQxbSi9PFKqjTJadRbbZN2norvK1a8CLaR0DjorFD1NRSrpebaYyVUnRLdu3ahbKyMkRFRSEvLw8vvPACgoODMWDAAHuHRkRERAAMFTVIqxtAXj+MPM9QabPOWSZFV1+VpQIq0FIF1dGrHWTcCY8cTVlhowRUXSteebHtOrkS8O1etwteXRLKPZg74ZFDEQQBeVfzxOqnE0UncKL4BK7WXLVZq3ZWW9rvPOuSUO0j4e3mbYeoqS1iUopuSU1NDV566SWcP38eKpUK/fv3x+eff26zUx0RERG1vIpqE07mGcQh5Kk5Blwosv1gIJUAnb3bWXbBq0tAhelUcHHiIHJyMJWGhvlP9VVQxhzbdVI5oIu0roLyCgOkvGbIsRRXFONEcV0LXt1OeCWVJTbrFE4KdPXoarUTXqAqkJW2dE1s3yNqBfzeIyKi26XGZEZGfimON2rDO1NQCpPZ9r90QR5uYvtddIAGkf4aKF34M0lyMDUVQH5awy54uUeB4swmFkqA9l0sA8jrE1C6SMCJs9PIsZRWl+Jk8Ukx+ZRelI68q3k265wkTgh1DxWrnyI8I9BJ2wlOUv47Q2zfIyIiIrrjmc0CzhddFdvvUnP0OJlrRFWt7YBYL5WLOIC8fiC5h9LZDlET2ZGpFig82TCEPPcoUHgKMNfartUGWVdA+cUALqpWD5nInqpMVThdctpqJ7wLhgs26ySQIFgTLM5/imofhTCPMLjImLSl38chk1J3WXEY3QH4PUdERDciCAJyDZU4flEvDiNPyzGgtMr2w7Ta1ckq+dQ9UAOd2pXtEeRYzGag5Lx1AirvOFBbYbtW6dWQgPLvZdkVT9m+9WMmsqNacy3O6c9ZteGdvXIWtYLtvzO+Sl+xAirSMxLdPLuhnXM7O0RNdzuHSkrVzzsqLy+HQqGwczTkSKqrLTtOyGScP0BERBYlV6stQ8jFOVB6FJXZ7lDkKpciwk8jtuF1D9Sig4cbpBxETo5EEABjbkMC6tIvlp3wKg22a13UlqqnxlVQmgAOIieHIggCLpZeRHpROtKK0nCi2LITXkUTSVsPVw+rIeQRnhHwVHjaIWpyRA6VlJLJZNBqtSgsLAQAuLm58SeK1OLMZjMuX74MNzc3ODk51CVHRER1yqpqkX7JgNSLDW14OVdsPxjIpBKE+ajEXfCiA7To4tMOTjKpHaImsqPykkYJqLoqqLIC23VOroAuqq76qS4J5dEJkPKaIcdSWF5oST4VnRBnQRmrjTbrlHIlIjwjrAaR+yp9+bmY7MbhPiHrdDoAEBNTRK1BKpUiKCiIf9kTETmAqloTTuWVWqqf6qqgMi+XoalO7o5eSnEIeXSAFhF+arjKWVVLDqaqDMhLtW7Du5Jlu04iA7y7Af49GhJQ3t0AGXd/JsdiqDKI85/qZ0EVVth+vnWWOiPcI9ySgKqrggpWB0MqYdKW2g6HS0pJJBL4+vrC29sbNTU19g6HHISzszOk/IkdEdFdx2QWkFlYZmnDqxtGfirPiBqTbQbKT+NqmQMVaGnDi/TXQKPgh2lyMLVVQEF6XfLpmOVrUQYg2A7vh0enhvY7/16Wiihnt9aPmciOymvKxUHk6cWWBFR2abbNOqlEik7aTmL1U2T7SIRqQyFn0pbaOIdLStWTyWSc70NERETNJggCskvKLUPI69rw0nMNKK822ax1d5NbBpAHaNA9UIvoAC28VNyhiByM2QQUnWmofrp01JKQMtnOToPKr24IeaOd8BTurR4ykT3VmGpwRn9GbMFLL07HOf05mJtI2gaqAsUh5JHtIxHuEQ43OZO2dOdx2KQUERER0fUUGivFXfDqv+rLbaus3ZxliPTXICZQKw4jD3BXsGWbHIsgAPpfrRNQealAdZntWletpfJJrILqCah0rR4ykT2ZBTOyDFlWLXinS06j2mybtPVWeDe04HlGIqJ9BDQuGjtETXT7MSlFREREDs9QUYO0ugHk9cPI842VNuvkMgm6+qrFOVDdA7Xo5NUOMu6ER46mrLBhF7zcula88mLbdXI3wDemLgHVw/LVPYQ74ZFDEQQBuVdzxeRTenE6ThafxNWaqzZr1c5qcSe8+mHkPkofO0RN1DqYlCIiIiKHUlFtwolcg1j9dDzHgAtFth8MJBIg1LudVRtemE4FFye2/5ODqTQ0zH/KPQpcOgYYc2zXSeWALrKh+smvJ+AVBkh5zZBjKa4oxoniuha8up3wSipLbNYpnBTo6tHVaie8QFUgK23JoTApRURERHetGpMZGfmlON6oDe9MQSlMZttB5EEebmL7XXSABpH+Gihd+F8lcjA1FUB+mnUbXvHZJhZKLAmn+gSUf0/AJxJw4uw0cixl1WU4WXxSbMNLL0pH3tU8m3VOEieEuociqn2UWAXVUdMRTlL+O0OOjVcAERER3RXMZgEXiq9akk8XLUmoE7lGVNXaDoj1Urmge4DGUgUVqEW0vwbuSmc7RE1kR6Za4PKpRgmoX4DCU4C51natNsgyB6o+CeXbHXBRtX7MRHZUZapCRkkG0orSxDa8LEMWBFj/oEMCCUI0IZbkU10rXphHGFxkTNoS/RaTUkRERHTHEQQBuYZKHL/YMIQ8LceA0irbD9MqVyex+smShNJAp3ZlewQ5FkEASs5bz4HKOw7UVtiuVXrVJZ96NcyCUrZv/ZiJ7KjWXItz+nNWbXhnr5xFrWD774yf0s9qEHk3z25o59zODlET3XmYlCIiIqI2r7isCsfrBpHXt+IVldnuUOTiJEWkv8aqDS/YUwkpB5GTIxEEwJjb0H5XP4i80mC71kUN+MVYz4HSBHAQOTkUQRBwsfQi0ovSLVVQxZad8CqaSNp6uHqI1U/1lVCeCk87RE10d2BSioiIiNqUsqpapDUaQp6ao0fOFdsPBjKpBGE+KnQPrKuACtCii087OMmkdoiayI7KS6xnQOUeBcoKbNfJXADf6EZzoHoBHp0AKa8ZciwFVwuQXly3E17dIHJjtdFmnVKuRDfPbuIQ8sj2kfBV+rLSlug2YlKKiIiI7Kaq1oRTeaVWc6AyL5dBsJ1Djo7tlY1a8LSI8FPDVc5dvcjBVJUBeanWCagrWbbrJDLAuxvg36MhCeXdDZDJWz1kInsyVBnE+U/1s6AuV1y2WSeXyht2wqtrwwvWBEMqYdKWqCUxKUVEREStwmQWkFlYVteCZ0lCnc43osZkm4Hy07giOkCL6EBLG16kvwYaBT9Mk4OprQYK0hsSUJeOAkUZgGA7vB8enRqqn/x6AroowNmt9WMmsqPymnKcLjltNYj8YulFm3VSiRSdtJ3ECqiI9hHoou0COZO2RK2OSSkiIiK67QRBwMWSCqTm6JF60dKGl55rQHm1yWath9K5oQKq7quXijsUkYMxm4Cisw1DyC8dtSSkTLaz06D2twwfr58B5RcDKNxbPWQie6ox1eCM/ozYgpdenI5z+nMwN5G0DVIFWSqg6pJQ4R7hcJMzaUvUFjApRURERL9bobFS3AUvNceAtBw9rpTX2KxTOssQ6f//7N13fFNl+8fxT5KmSfegdNAWWtm0zCJDUASRIQ8/F7IEQVwPQ1FcuCcC4kAZAqKiIoK4FQQBy/ARFJktUCjQQgsdtKUpHUkzzu+PQLAGZEh7Oq7369UX5PROzpXCaZtv7vu6A2gbHehqRh4V5CX9OUTdoihQeOQvfaB2QNZOKC92H+sVVLEJeWQH8Auv8pKFUJNDcZBuSic537kL3p48ZyPycod7aBvqFVphCV5cSBwBhgAVqhZCXAwJpYQQQghxSUxlVpJcO+E5Z0Flmcxu4zx1WlpG+DmX4UU5g6jG9X3RyU54oq4pznVvRF6a7z5O7wMRbU8HUKdnQgXFyk54ok5RFIXjJcdd4VNyfjJ78/dSYi1xG+vv6V9hJ7z4kHhCvUNVqFoIcbmqJJSaM2cOM2bMIDs7m7Zt2zJr1iw6dep0zrHvv/8+n3zyCcnJyQAkJCTw2muvnXe8EEIIISpPWbmdPcdNrllQuzNNpOW5vzDQaKBpqK+rCXnbqACah/th8JBG5KKOMZvg+I6Ks6CKMt3HafUQFufsAXVmFlT95qCVa0bULfll+ezJP70E7/ROeAXmArdxRp2RVvVaVViGF+0XLTNthajhKj2UWrZsGZMmTWLevHl07tyZmTNn0rdvX/bv309oqHuKvX79eoYNG8Y111yD0Whk+vTp9OnThz179hAZGVnZ5QohhBB1ltXuYH/2KXb/ZRnegZxT2B3ujcijg71oGxVI29OzoOIjA/AxyARsUcdYyyA76XQT8tO9oPIPnmOgxhk4/XUZXng8eEjvNFG3FJcXszd/r7MR+ekgKqsky22ch8aDpkFNXbOf4urF0TiwMR5a+TkjRG2jUZRzbbp85XTu3Jmrr76a2bNnA+BwOIiOjubBBx9k8uTJF7y/3W4nKCiI2bNnc9ddd11wfFFREQEBAZhMJvz9/f91/UIIIURt5HAopOWXuJqQ78osZO/xIiw29wax9f0MrgbkZxqSB/t4qlC1ECqy2yB3b8UleLn7wGFzHxvYsGIA1aAdGPyqvGQh1GSxW0gpSKmwDC/dlI5CxZefGjTEBMS4+j+daURu0EloK+oWe3EJ5j17UGxWfLt1U7ucf+1is5lKjZrLy8vZtm0bTz31lOuYVquld+/ebN68+aIeo7S0FKvVSnBw8Dk/b7FYsFgsrttFRUX/rmghhBCillEUheMmM7szCl3L8JIyTZyyuL+Y9jN6uGY/OZfiBRDub5TlEaJucTig4HDFACprN9jK3Mf61D8bQEUmOHtB+YRUfc1CqMjmsHGo8FCFZXipJ1OxKe4/Zxr4NKjQiLxlvZb4eUpoK+oWR3k5lpQUypKSMCclU5acRPmhw6AoGFu1qhWh1MWq1FAqLy8Pu91OWFhYheNhYWGkpKRc1GM8+eSTNGjQgN69e5/z81OnTuWll17617UKIYQQtUVBSbmzCXnG2WV4ecUWt3FGvZa4BgG0iQqgXXQgbaICaRTsjVYakYu6RFGg6HjFAOrYDrCY3Mca/J2znv46CyogShqRizpFURQyTmWQnJfsWoaXUpBC2TlC22BjcIVG5HH14qjnVU+FqoVQj2K3Yzl0yBk+Je3GnJSM+cABsLrvUuwREYFnTAyKotSZNwSr9aLcadOmsXTpUtavX4/RaDznmKeeeopJkya5bhcVFREdHV1VJQohhBCqKrbYSD52OnzKcC7Dyzzp/sJAp9XQPMzP1YS8TVQgzcJ88dBpVahaCBWVFpwNns70gSrOcR+nM0BEm9MB1Olm5MGNQSvXjKhbckpySM4/vQTvdCPyonL31Sk+eh/i6sVVaEQe4RNRZ15YCwHO0NaakVFhBpR57z6U0lK3sbqgIIyt4/GKb+38s3VrPELq3kzbSg2lQkJC0Ol05ORU/EGfk5NDeHj4P973jTfeYNq0aaxdu5Y2bdqcd5zBYMBgkPXGQgghaj+Lzc6+rFOuAGp3ZiEHTxRzru6QV9X3qbAML66BP0a97Ool6hhLMWTtqjgL6mS6+ziNDkJbQWT7s7OgQluBTl/lJQuhJpPF5Or/lJSXxJ68PZwoO+E2zlPrSYvgFhWW4cUExKDVSGgr6hZrbi7m5GRXCGVOSsJucp9pq/X2xhgXh7F1a7xax2Ns3Rp9ZKSEtlRyKOXp6UlCQgLr1q3jlltuAZyNztetW8eECRPOe7/XX3+dKVOmsHr1ajp27FiZJQohhBDVkt2hcDC32LkML9PZjHxfVhFWu3sC1SDA6GxCHh1A26hA4iMDCPCSF9OijrFZICf5dPi0w/ln3n5Q3Jv3E9z47PK7yA4Q3gY8vau+ZiFUVGotZV/BvgqNyDNOZbiN02q0NA5s7Jr9FB8ST9PApugltBV1jL2o6HQAlYw5OYmypGRs2dlu4zR6PYYWLU6HT23wah2PZ2wsGp28OXgulb58b9KkSYwaNYqOHTvSqVMnZs6cSUlJCXfffTcAd911F5GRkUydOhWA6dOn8/zzz7NkyRJiYmLIPv2P7Ovri6+vb2WXK4QQQlQ5RVE4WlDqbEJ+eje85OMmSsvtbmODvPXOBuRndsOLDiDU79xL3IWotRx2yDvwlx5Q252BlL3cfaxfg9MBVPvTjcjbgVdQlZcshJqsdisHCg+4luAl5SVx2HQYxzlC22i/6AoBVIvgFnjrJbQVdYujrAzzvn2Yk5zhkzkpifIjR9wHarUYGjc+OwMqvjWG5s3QesouxRer0kOpIUOGcOLECZ5//nmys7Np164dq1atcjU/P3r0KNq/rM1/7733KC8vZ9CgQRUe54UXXuDFF1+s7HKFEEKISpdbZHbtgnfmz8JS92aX3p464iPPNCF3zoKKCvKSqd6iblEUKDxSsQl51k4oL3Yfawz8yy54p2dB+f1zywghahuH4iDdlE5yfrJrJ7z9Bfspd7iHtqFeoRWW4MWFxBFgCFChaiHUo1itWFJTKdud5OwBlZSM5eBBsLu/OaiPjnaFT16t4zG2aoXWx0eFqmsPjaKcqxNFzVVUVERAQAAmkwl/f3+1yxFCCFHHmcqsJGU6G5DvOj0LKrvI7DbOU6elZYSfc/ZTVABtowNpXN8XneyEJ+qa4ty/BFDbnEvxSvPdx+l9IKLtX2ZBdYCgWNkJT9QpiqKQVZLl6v+UnJ/M3vy9lFhL3Mb6e/q7dsI704w8zCfsHI8qRO2lOByUp6dXmAFlTklBsbjvUqyrH4LX6eV3xvjWGOPj8AiSmbYX62KzmWq9+54QQghRk5SV29mbZWLn6SbkuzNNpOW5vzDQaKBpqK9rGV7b6ECah/th8JBeA6KOMZvO9n86MwuqKNN9nFYP4fFnZz816AD1m4NWrhlRt+SX5bMnf49rBtSe/D0UmAvcxnl5eNEyuGWFnfCi/aJlpq2oUxRFwZaVVaEHlDk5GUex+0xbrb8/XvFxzvDpzE54YWFyzVQBCaWEEEKIy2C1O9iffYrdf1mGdyDnFHaH+wTkhsHeruV3baICiI8MwMcgP4JFHWMtg+ykin2g8lPPMVDjDJz+GkCFx4OH7LYs6pbi8mL25u+tsAwvqyTLbZyHxoOmQU2JD4mndUhr4kLiuCrgKjy08nNG1C22kydPz4ByLsErS0rCnu8+01ZjNGJs2RKvNq1dy/D0jRpJAKUS+U4lhBBCXIDDoXA4r8Q1+2lXZiF7jxdhsbk3iK3vZzjbhPz0n8E+0uxS1DF2G5zYVzGAyt0LDpv72MCGpwOoBGcIFdEWDH5VX7MQKrLYLewv2O+a/ZSUl0S6KR2Fim90aNAQExBToRF58+DmGHQS2oq6xV5cgnnPnrMzoJKSsB475j7QwwNDs6Z4/WUGlKFJEzQeEoVUF/IvIYQQQvyFoigcN5nZnXG2CXlSpolTFvcX035Gj7/MgAqkbXQA4f5GeadN1C2KAgWHKwZQWbvAVuY+1if07OynM72gfEKqvmYhVGRz2DhUeKjCMrzUwlRs5whtG/g0qNCIvFW9Vvh6yo7kom5xlJdjSUk5OwMqOYnyQ4edP3/+xjM21hk+nQ6hjC1bojXKLsXVmYRSQggh6rSCkvIKTch3ZxaSV+y+Q5HBQ0t8ZECFZXgx9XzQSiNyUZcoChQdPxs+Hd/u7AllNrmPNfhDg3YVl+EFREkjclGnKIrC0VNHK/SASilIoewcoW2wMdjViDw+JJ64enHU86qnQtVCqEex27EcPHR6BpQzhDIfOABW912KPSIi8IqPx9i6tXMpXlwcOj+ZaVvTSCglhBCizii22Eg+ZnIFULsyC8k86f7CQKfV0DzMj7bRZ5fhNQvzQ6/TqlC1ECoqLag4A+r4dijOcR+nM0BEm4oBVL0moJVrRtQtOSU5JOcnO3fCOx1CFZUXuY3z0fsQVy+uQiPyCJ8ImWkr6hRFUbBmZFSYAWXesxel7By/mwUGOsOn1n9pRB4iM21rAwmlhBBC1EoWm519WaecTchP74Z38ETxuWZ6c1WIj3MGVLRzGV5cA3+MetnVS9QxlmLnsru/BlAn093HaXQQ2goi258NoUJbgU5f5SULoSaTxeQMn/7SiPxE2Qm3cZ5aT1oEt6iwDC8mIAatRkJbUbdYc3MxJzsbkJt3J2FOTsZucp9pq/H2xqtVK4xt2uDV2jkTSh8ZKaFtLSWhlBBCiBrP7lA4mFvMrsxCVzPyfVlFWO3uCVSDAKNz9lO0cxlefGQAAV7yYlrUMbZyyEk+HUDtcP55IgUU9+b9BDc+24S8QQcIbw2e3lVfsxAqKrWWklKQ4gqfkvOTyTiV4TZOq9HSJLCJa/ldfEg8TQObopfQVtQx9qIiZwC1O8k5AyopGVuO+0xbjV6PoUULZ/h0eic8z6uuQqOTNwfrCgmlhBBC1CiKopBRUOYKoHZlmEg+bqK03O42Nshb75r9dGZHvPp+skORqGMcdshLPR1AbXPOgspJBrt77zT8I53Nx88EUA3ag1dglZcshJqsdisHCg+4luAl5ydzqPAQjnOEtg39GlZYgtciuAXeegltRd3iKCvDvC8Fc9Ju10545UeOuA/UajE0bnx6GZ4zhDI2b4bGU3YprssklBJCCFGt5Z4yszvD2f9pV6aJpMxCTpa6N7v09tTROvLMEjznLKioIC+Z6i3qFkWBwqPO8OnMLKisnVBe7D7WK6hiD6jIDuAXXuUlC6Emh+Ig3ZTuWoK3J8/ZiLzc4R7ahnqFVliCFxcSR4AhQIWqhVCPYrViSU11hk/JSZQlJWNJTQW7+5uD+ujoszOg2rR27oTn46NC1aI6k1BKCCFEtWEqs5J0ugH5mWV4WSaz2zhPnZaWEX6uJuRtowNpXN8XneyEJ+qa4lz3RuSl+e7j9D4Q0fZ0ANXeuRwvKEZ2whN1iqIoHC857gqfkvOT2Zu/lxJridtYf0//CjvhxYfEE+odqkLVQqhHcTgoT0/HnJTkmgFlTklBsVjcxurqh+B1JnyKb40xPg6PoCAVqhY1jYRSQgghVFFWbmfPcRO7Mk2uACotz/2FgUYDTUN9XUvw2kYH0jzcD4OH9BoQdYzZBMd3/CWE2gFFme7jtHoIi3MGUJEJzllQ9ZuDVq4ZUbfkl+WzJ3+Pqw/Unvw9FJgL3MYZdUZa1mvpCqFah7Qm2i9aZtqKOkVRFGxZWWdnQO1OwrxnD45i95m2Wj+/s8vvzuyEFxYm14y4LBJKCSGEqHRWu4P92afYfTqA2pVp4kDOKewO90bk0cFetI0KpO3pWVDxkQH4GOTHlahjrGWQnfSXAGob5B88x0ANhDT7WyPyePCQ3mmibikuL2Zv/l6S8pJcQVRWSZbbOA+NB02DmrpmP8XVi6NxYGM8tPJzRtQttoKCCjOgypKTsee7z7TVGAwYW7VyhU/G+Hg8GzVCo5XdI8WVId99hRBCXFEOh0JafomrCfmuzEL2Hi/CYnNvEFvfz+BqQN7m9J/BPtLsUtQxdhuc2He2Cfnx7ZC7Dxw297EBDU/PgDodQEW0BaN/1dcshIosdotrJ7wzy/DSTekoVHyjQ4OGmIAYV/+nM43IDToJbUXdYi8uwbxnj6sHlDkpCeuxY+4DdToMzZrhFR/vCqEMTZui8ZDYQFQe+d8lhBDisimKQpbJzO7MQnZmOGdBJR0zccrs/mLa3+hRIXxqGx1AuL9RpnqLusXhgILDFXtAZe0GW5n7WJ/67o3IfUKqvmYhVGRz2DhUeKjCMrzUk6nYFPefMw18GlRoRN6qXit8PX1VqFoI9TjKy7GkpFCWlIQ5KZmy5CTKDx12boTxN56xsc7w6fQyPGPLlmiNRhWqFnWZhFJCCCEuWkFJubMJecbZZXh5xe7NLo16LXENAly74LWJCiCmng9aaUQu6hJFgaLjFQOoYzvAYnIfa/CHBu0qhlABUdKIXNQpiqKQcSrDGT7lO2dB7SvYR9k5QttgY3CFRuRx9eKo51VPhaqFUI9it2M5dMgVPpl3J2E+cACs7rsUe0REOJffnVmGFxeHzs9PhaqFqEhCKSGEEOdUbLGRfOxs+LQ7s5CMAvcXBjqthuZhfrSNPhNABdIszBcPnfQaEHVMacHZ4OnYNuffi3Pcx+kMENHmbBPyyA4Q3BikP4eoY3JKclzh05lG5EXlRW7jfPQ+tKrXyjUDKj4kngifCJlpK+oURVGwZmZStnv32RBq7z6U0lK3sbqgoAozoLxat8YjRGbaiupJQikhhBBYbHb2ZZ1y9YHanVnIwRPF55rpzVUhPrSNPrsML66BP0a97Ool6hhLMWTtqjgL6mS6+ziNDkJbQWT7swFUaCvQ6au8ZCHUZLKYXP2fkvKS2JO3hxNlJ9zGeWo9aRHcosIyvJiAGLQaCW1F3WLNzcWcnOxahmdOTsZeWOg2TuvtjTEuDmPr1s4d8Vq3Rh8ZKaGtqDEklBJCiDrG7lA4mFvsXIaXWcjuTBP7soqw2t0TqIgAo3MJXrRzN7z4yAACvOTFtKhjbBbIST4dPu1w/pm3HxT35v0EN67YAyq8DXh6V33NQqio1FrKvoJ9FRqRZ5zKcBun1WhpHNjYNfspLiSOZoHN0EtoK+oYu8lEWXLy2RlQScnYctxn2mr0egwtWpwOn9rg1Toez9hYNDp5c1DUXBJKCSFELaYoCkcLSp3L7zKcAVTycROl5Xa3sUHeemcD8jO74UUHEOonzS5FHeOwQ96Bv/SA2u4MpOzl7mP9GpwOoNqfXorXDryCqrxkIdRktVs5UHjAtQQvOT+ZQ4WHcJwjtI32i3bthNc6pDUtglvgrZfQVtQtjrIyzPv2YU46uxNe+ZEj7gO1WgyNr8IY3xqvNq0xxrfG0LwZWk/ZpVjULhJKCSFELZJbZHb1fzrzZ2Gpe7NLb08d8ZEBrgCqXXQgUUFeMtVb1C2KAoVHKjYhz9oJ5cXuY72CnOHTmRlQkQngF17lJQuhJofiIN2UTnJ+smsWVEpBCuUO99A21Cu0whK8uJA4AgwBKlQthHoUqxVLaiplScmUJTl7QVkOHgS7+5uD+uho5wyo+NPL8Fq1Quvjo0LVQlQtCaWEEKKGMpVZSco0uZbh7cowkV1kdhvnqdPSMsLPOfvp9FK8xvV90clOeKKuKc79SwC1zbkUrzTffZzeByLa/mUWVAcIipWd8ESdoigKWSVZztlPp2dA7c3fS4m1xG2sv6e/awe8M7vhhXqHqlC1EOpRHA7K09MrzIAyp6SgWNx3KfaoX/9sD6j41hjj4/AIkpm2om6SUEoIIWoAs9XOnuMmdmWcCaFMpOW5vzDQaKBpqK9rGV7b6ECah/th8JBeA6KOMZvg+M6zAdSxHVCU6T5Oq4fw+LMzoBp0gPrNQSvXjKhb8svy2ZO/xxVC7cnfQ4G5wG2cl4cXLYNbOmdBne4FFe0XLTNtRZ2iKAq2rCxn+JR8OoRKTsZR7D7TVuvvj1d8nDN8ah2PV5s26MPCVKhaiOpJQikhhKhmrHYH+7NPsfsvy/AO5JzC7nBvRN4w2Ns5++n0LKj4yAB8DPKtXdQx1jLITqrYByo/9RwDNc7A6a8BVHg8eBiqvGQh1FRcXsze/L0VluEdLznuNs5D40HToKau2U/xIfFcFXAVHlr5OSPqFtvJk6dnQDmbkJclJWHPd59pqzEaMbZs6QyfTjci1zdsiEYru0cKcT7yE0UIIVTkcCgczitx7YK3K7OQvceLsNjcG8TW9zOcbUJ++s9gH2l2KeoYuw1O7KsYQOXuBYfNfWxgw4o9oCLagsGv6msWQkUWu4X9Bftds5+S85JJM6WhUPGNDg0aYgJiXP2f4kPiaRHcAoNOQltRt9iLSzDv2XN2BlRSEtZjx9wH6nQYmjXDq/XpGVCtW2No0gSNh7zEFuJSyBUjhBBVRFEUjpvM7M4424Q8KdPEKYv7i2k/o4creDoTREUEGGV5hKhbHA4oOHw2fDq+HbJ2g63MfaxP/dMBVMLZXlA+IVVfsxAqsjlsHCo8VGEZXurJVGyK+8+ZCJ+IszOg6sXTql4rfD19VahaCPU4ysuxpKScnQGVnET5ocPOjTD+xjM21hk+nV6GZ2zZEq1RdikW4t+SUEoIISpJQUm5s/9TxplleIXkFbvvUGTw0BLXwJ+20YGuZXgx9XzQSiNyUZcoChQdrxhAHdsBFpP7WIM/NGhXcRleQJQ0Ihd1iqIoZJzKICkvyTULKqUghbJzhLbBxuAKTcjj6sVRz6ueClULoR7Fbsdy8NDpGVDOEMp84ABY3Xcp9oiIwCs+/mwz8rg4dP7+KlQtRO0noZQQQlwBxRYbycdMrl3wdmUWknnS/YWBTquheZgfbaPPLsNrFuaHXie9BkQdU1pQcQne8e1QnOM+TmeAiDYVA6h6TUD6c4g6Jrc0l6S8JPbk7XGFUEXlRW7jfPQ+xNWLq9CIPMInQmbaijpFURSsGRkVZkCZ9+5DKS11G6sLDKywE55X63g86tdXoWoh6iYJpYQQ4hJZbHZSsk6x63QAtTuzkIMnis8105urQnycjcijA2kTFUhcA3+MetnVS9QxlmLI2lUxgDqZ7j5Oo4PQVhDZ/mwIFdoKdPoqL1kINZksJmf49JdG5LlluW7jPLWetAhu4eoBFV8vnpiAGLQaCW1F3WLNzcWcnHx2BlRSEnaT+0xbrbc3xri4syFU69boIyMltBVCRRJKCSHEP7A7FA7mFjuX4Z1uRr4vqwir3T2BahBgdM5+inbuhhcfGUCAl7yYFnWMrRxyks8uvzu+HU6kgOLevJ/gxmebkDfoAOGtwdO76msWQkWl1lJSClKcPaBOh1AZpzLcxmk1WhoHNqZ1SGvXUrymgU3RS2gr6hh7UZEzgNqd5JwBlZSMLcd9pq1Gr8fQosXZGVBtWuMZG4tGJ28OClGdSCglhBCnKYpCRkGZK4DalWki+ZiJ0nK729ggb72zCXn02Ubk9f1khyJRxzjskJd6dgbUsW3OQMru3jsNvwanA6jTS/AatAOvoCovWQg1WR1WUk+mupqQJ+cnc6jwEI5zhLYN/RpWWILXIrgF3noJbUXd4igrw7xvH+akszvhlR854j5Qq8XQuHGFZXjG5s3QeMouxUJUdxJKCSHqrNxTZlcT8p2ZJpIyCzlZ6t7s0ttTR3xkAG1PL8NrGxVIVJCXTPUWdYuiQOFRZ/B0ZhZU1k4oL3Yf6xVUsQdUZAfwC6/ykoVQk0NxkG5Kr7AEL6UghXKHe2gb6hVaYQleXEgcAYYAFaoWQj2K1YolNbXCDCjLwYNgd39zUB8dXaEHlLFVK7Q+PipULYT4t6oklJozZw4zZswgOzubtm3bMmvWLDp16nTe8cuXL+e5554jPT2dpk2bMn36dG666aaqKFUIUUuZyqwkZZoqLMPLMpndxul1GlpF+LuakLeNDqRxfV90shOeqGuKc90bkZfmu4/Te0NEu9MBVHvnn0GxshOeqFMUReF4yXFX+JScn8ze/L2UWEvcxvp5+rlmP52ZCRXmE6ZC1UKox15cTPnBg1gOHcK8LwVzUhLmlBQUi8VtrK5+CF7xrTG2jserdRuM8XF4BMlMWyFqi0oPpZYtW8akSZOYN28enTt3ZubMmfTt25f9+/cTGhrqNv63335j2LBhTJ06lf/85z8sWbKEW265he3btxMfH1/Z5VYriqJgKz9HDw4hRAWKomCxOSgrt1Nms1NWbqOw1Mqe40UkHzORdMzEkXz33VY8NdC4vg/xkYG0buBPfGQAzcL9MHhU7DXgsDqQK1HUGooCliJnwFSSD2X5UJLnvF2aD6ZMyNoNRcfc76v1hdCWzqV3Ee2cf4Y0A+3f+nPIzy5RyyiKQoG5gOMlx8kqznL9mVWSRXaJ80/LOZat+ur8aB7cglb1WtEquBWtQloR5RvlNtPWanGfCSJEbWAvPkX54TTKDx/CcvAwlrTDWA4dxn6OHlAA2oBgjHGtMLaKxxDXCq+4ODxCQytcMwpyzYjaz8NTW2dWZWgU5Vz7RV05nTt35uqrr2b27NkAOBwOoqOjefDBB5k8ebLb+CFDhlBSUsKPP/7oOtalSxfatWvHvHnz3MZbLBYsf0nUi4qKiI6OxmQy4e/vXwnPqOosmzyEvMIH1C5DCCGEEEIIIYQQVeT+d3qgN9TspvxFRUUEBARcMJup1P1iy8vL2bZtG7179z57Qq2W3r17s3nz5nPeZ/PmzRXGA/Tt2/e846dOnUpAQIDrIzo6+so9AZU58vPULkEIIYQQQgghhBCiUlTq8r28vDzsdjthYRXXyYeFhZGSknLO+2RnZ59zfHZ29jnHP/XUU0yaNMl1+8xMqdqg4c0j8NjxudplCFGtaDTgodGg1WrQaTV4aM/+XafRSBsbIc5H6wEeXqA//aGVbeSFuBhGDwNBhiACjYFoNTX7XWshqpJHcD0MjWPR+dXs1StCqMHDs1LnD1UrNX73PYPBgMFQO7dh7/afu+E/d6tdhhBCCCGEEEIIIcQVV6nxW0hICDqdjpy/NbLLyckhPPzcW0OHh4df0nghhBBCCCGEEEIIUfNUaijl6elJQkIC69atcx1zOBysW7eOrl27nvM+Xbt2rTAeYM2aNecdL4QQQgghhBBCCCFqnkpfvjdp0iRGjRpFx44d6dSpEzNnzqSkpIS773YuS7vrrruIjIxk6tSpAEycOJEePXrw5ptvMmDAAJYuXcqff/7JggULKrtUIYQQQgghhBBCCFFFKj2UGjJkCCdOnOD5558nOzubdu3asWrVKlcz86NHj6LVnp2wdc0117BkyRKeffZZnn76aZo2bcq3335LfHx8ZZcqhBBCCCGEEEIIIaqIRlEURe0irqSioiICAgIwmUz4+8tOD0IIIYQQQgghhBBV6WKzmRq/+97fncnYioqKVK5ECCGEEEIIIYQQou45k8lcaB5UrQulTp06BUB0dLTKlQghhBBCCCGEEELUXadOnSIgIOC8n691y/ccDgfHjx/Hz88PjUajdjn/WlFREdHR0WRkZMhyRCEuklw3QlweuXaEuDxy7QhxeeTaEeLy1IRrR1EUTp06RYMGDSr0Ef+7WjdTSqvVEhUVpXYZV5y/v3+1/c8mRHUl140Ql0euHSEuj1w7QlweuXaEuDzV/dr5pxlSZ5w/rhJCCCGEEEIIIYQQopJIKCWEEEIIIYQQQgghqpyEUtWcwWDghRdewGAwqF2KEDWGXDdCXB65doS4PHLtCHF55NoR4vLUpmun1jU6F0IIIYQQQgghhBDVn8yUEkIIIYQQQgghhBBVTkIpIYQQQgghhBBCCFHlJJQSQgghhBBCCCGEEFVOQikhhBBCCCGEEEIIUeUklKrG5syZQ0xMDEajkc6dO/PHH3+oXZIQ1crUqVO5+uqr8fPzIzQ0lFtuuYX9+/dXGGM2mxk/fjz16tXD19eX22+/nZycHJUqFqL6mTZtGhqNhocffth1TK4bIc7t2LFjjBgxgnr16uHl5UXr1q35888/XZ9XFIXnn3+eiIgIvLy86N27N6mpqSpWLIT67HY7zz33HLGxsXh5edG4cWNeeeUV/rrfllw7Qjht3LiRgQMH0qBBAzQaDd9++22Fz1/MtVJQUMCdd96Jv78/gYGB3HPPPRQXF1fhs7g0EkpVU8uWLWPSpEm88MILbN++nbZt29K3b19yc3PVLk2IamPDhg2MHz+eLVu2sGbNGqxWK3369KGkpMQ15pFHHuGHH35g+fLlbNiwgePHj3PbbbepWLUQ1cfWrVuZP38+bdq0qXBcrhsh3J08eZJu3bqh1+v56aef2Lt3L2+++SZBQUGuMa+//jrvvvsu8+bN4/fff8fHx4e+fftiNptVrFwIdU2fPp333nuP2bNns2/fPqZPn87rr7/OrFmzXGPk2hHCqaSkhLZt2zJnzpxzfv5irpU777yTPXv2sGbNGn788Uc2btzI/fffX1VP4dIpolrq1KmTMn78eNdtu92uNGjQQJk6daqKVQlRveXm5iqAsmHDBkVRFKWwsFDR6/XK8uXLXWP27dunAMrmzZvVKlOIauHUqVNK06ZNlTVr1ig9evRQJk6cqCiKXDdCnM+TTz6pdO/e/byfdzgcSnh4uDJjxgzXscLCQsVgMCiff/55VZQoRLU0YMAAZcyYMRWO3Xbbbcqdd96pKIpcO0KcD6B88803rtsXc63s3btXAZStW7e6xvz000+KRqNRjh07VmW1XwqZKVUNlZeXs23bNnr37u06ptVq6d27N5s3b1axMiGqN5PJBEBwcDAA27Ztw2q1VriWWrRoQcOGDeVaEnXe+PHjGTBgQIXrA+S6EeJ8vv/+ezp27Mgdd9xBaGgo7du35/3333d9Pi0tjezs7ArXTkBAAJ07d5ZrR9Rp11xzDevWrePAgQMA7Nq1i19//ZX+/fsDcu0IcbEu5lrZvHkzgYGBdOzY0TWmd+/eaLVafv/99yqv+WJ4qF2AcJeXl4fdbicsLKzC8bCwMFJSUlSqSojqzeFw8PDDD9OtWzfi4+MByM7OxtPTk8DAwApjw8LCyM7OVqFKIaqHpUuXsn37drZu3er2ObluhDi3w4cP89577zFp0iSefvpptm7dykMPPYSnpyejRo1yXR/n+v1Nrh1Rl02ePJmioiJatGiBTqfDbrczZcoU7rzzTgC5doS4SBdzrWRnZxMaGlrh8x4eHgQHB1fb60lCKSFErTB+/HiSk5P59ddf1S5FiGotIyODiRMnsmbNGoxGo9rlCFFjOBwOOnbsyGuvvQZA+/btSU5OZt68eYwaNUrl6oSovr744gs+++wzlixZQlxcHDt37uThhx+mQYMGcu0IIaTReXUUEhKCTqdz2+koJyeH8PBwlaoSovqaMGECP/74I4mJiURFRbmOh4eHU15eTmFhYYXxci2Jumzbtm3k5ubSoUMHPDw88PDwYMOGDbz77rt4eHgQFhYm140Q5xAREUGrVq0qHGvZsiVHjx4FcF0f8vubEBU9/vjjTJ48maFDh9K6dWtGjhzJI488wtSpUwG5doS4WBdzrYSHh7ttjmaz2SgoKKi215OEUtWQp6cnCQkJrFu3znXM4XCwbt06unbtqmJlQlQviqIwYcIEvvnmG3755RdiY2MrfD4hIQG9Xl/hWtq/fz9Hjx6Va0nUWTfccANJSUns3LnT9dGxY0fuvPNO19/luhHCXbdu3di/f3+FYwcOHKBRo0YAxMbGEh4eXuHaKSoq4vfff5drR9RppaWlaLUVX3bqdDocDgcg144QF+tirpWuXbtSWFjItm3bXGN++eUXHA4HnTt3rvKaL4Ys36umJk2axKhRo+jYsSOdOnVi5syZlJSUcPfdd6tdmhDVxvjx41myZAnfffcdfn5+rnXSAQEBeHl5ERAQwD333MOkSZMIDg7G39+fBx98kK5du9KlSxeVqxdCHX5+fq6+a2f4+PhQr14913G5boRw98gjj3DNNdfw2muvMXjwYP744w8WLFjAggULANBoNDz88MO8+uqrNG3alNjYWJ577jkaNGjALbfcom7xQqho4MCBTJkyhYYNGxIXF8eOHTt46623GDNmDCDXjhB/VVxczMGDB12309LS2LlzJ8HBwTRs2PCC10rLli3p168f9913H/PmzcNqtTJhwgSGDh1KgwYNVHpWF6D29n/i/GbNmqU0bNhQ8fT0VDp16qRs2bJF7ZKEqFaAc3589NFHrjFlZWXKuHHjlKCgIMXb21u59dZblaysLPWKFqIa6tGjhzJx4kTXbbluhDi3H374QYmPj1cMBoPSokULZcGCBRU+73A4lOeee04JCwtTDAaDcsMNNyj79+9XqVohqoeioiJl4sSJSsOGDRWj0ahcddVVyjPPPKNYLBbXGLl2hHBKTEw85+ubUaNGKYpycddKfn6+MmzYMMXX11fx9/dX7r77buXUqVMqPJuLo1EURVEpDxNCCCGEEEIIIYQQdZT0lBJCCCGEEEIIIYQQVU5CKSGEEEIIIYQQQghR5SSUEkIIIYQQQgghhBBVTkIpIYQQQgghhBBCCFHlJJQSQgghhBBCCCGEEFVOQikhhBBCCCGEEEIIUeUklBJCCCGEEEIIIYQQVU5CKSGEEEIIIYQQQghR5SSUEkIIIYQQQgghhBBVTkIpIYQQQgghhBBCCFHlJJQSQgghhBBCCCGEEFVOQikhhBBCCCGEEEIIUeUklBJCCCGEEEIIIYQQVU5CKSGEEEIIIYQQQghR5SSUEkIIIYQQQgghhBBVTkIpIYQQQgghhBBCCFHlJJQSQgghhBBCCCGEEFVOQikhhBBC1GijR48mJiZG7TIu2/XXX8/111+vdhlVoqb/WwkhhBDiypJQSgghhBDV0qJFi9BoNK4Po9FIs2bNmDBhAjk5OWqXV6PFxMS4fW2bNm3K448/TkFBgdrlCSGEEKKO0CiKoqhdhBBCCCHE3y1atIi7776bl19+mdjYWMxmM7/++iuffvopjRo1Ijk5GW9vb6xWKw6HA4PBoHbJl6W8vBwAT0/PKjtnTEwMQUFBPProowCYzWa2bdvGwoULad++PX/88UelnLem/1sJIYQQ4sryULsAIYQQQoh/0r9/fzp27AjAvffeS7169Xjrrbf47rvvGDZsGHq9XuUK/52qDKP+KjIykhEjRrhu33vvvfj6+vLGG2+QmppK06ZNr/g5a/q/lRBCCCGuLFm+J4QQQogapVevXgCkpaUB5+5T5HA4mDlzJnFxcRiNRsLCwnjggQc4efKk2+P99NNP9OjRAz8/P/z9/bn66qtZsmRJhTG///47/fr1IyAgAG9vb3r06MH//vc/1+d3796NRqPh+++/dx3btm0bGo2GDh06VHis/v3707lzZ9ftc/WUmjVrFnFxcXh7exMUFETHjh3dajp27BhjxowhLCwMg8FAXFwcH3744QW+ev8sPDwcAA+Ps+9b7t69m9GjR3PVVVdhNBoJDw9nzJgx5OfnV7jvqVOnePjhh4mJicFgMBAaGsqNN97I9u3bXWPO9W+1dOlSEhISXF//1q1b88477/yr5yGEEEKImkFmSgkhhBCiRjl06BAA9erVO++YBx54wLX876GHHiItLY3Zs2ezY8cO/ve//7lm7CxatIgxY8YQFxfHU089RWBgIDt27GDVqlUMHz4cgF9++YX+/fuTkJDACy+8gFar5aOPPqJXr15s2rSJTp06ER8fT2BgIBs3buT//u//ANi0aRNarZZdu3ZRVFSEv78/DoeD3377jfvvv/+8tb///vs89NBDDBo0iIkTJ2I2m9m9eze///67q6acnBy6dOmCRqNhwoQJ1K9fn59++ol77rmHoqIiHn744Qt+Ha1WK3l5eYBz+d6OHTt46623uO6664iNjXWNW7NmDYcPH+buu+8mPDycPXv2sGDBAvbs2cOWLVvQaDQA/Pe//+XLL79kwoQJtGrVivz8fH799Vf27dvnFsz99bGHDRvGDTfcwPTp0wHYt28f//vf/5g4ceIFn4MQQgghajhFCCGEEKIa+uijjxRAWbt2rXLixAklIyNDWbp0qVKvXj3Fy8tLyczMVBRFUUaNGqU0atTIdb9NmzYpgPLZZ59VeLxVq1ZVOF5YWKj4+fkpnTt3VsrKyiqMdTgcrj+bNm2q9O3b13VMURSltLRUiY2NVW688UbXsQEDBiidOnVy3b7tttuU2267TdHpdMpPP/2kKIqibN++XQGU7777zjWuR48eSo8ePVy3b775ZiUuLu4fvzb33HOPEhERoeTl5VU4PnToUCUgIEApLS39x/s3atRIAdw+unXr5vaY53qszz//XAGUjRs3uo4FBAQo48eP/8fz/v3fauLEiYq/v79is9n+8X5CCCGEqJ1k+Z4QQgghqrXevXtTv359oqOjGTp0KL6+vnzzzTdERkaec/zy5csJCAjgxhtvJC8vz/WRkJCAr68viYmJgHOWzqlTp5g8eTJGo7HCY5yZ/bNz505SU1MZPnw4+fn5rscqKSnhhhtuYOPGjTgcDgCuvfZatm/fTklJCQC//vorN910E+3atWPTpk2Ac/aURqOhe/fu532+gYGBZGZmsnXr1nN+XlEUvvrqKwYOHIiiKBWeY9++fTGZTBWWzJ1P586dWbNmDWvWrOHHH39kypQp7Nmzh//7v/+jrKzMNc7Ly8v1d7PZTF5eHl26dAGocJ7AwEB+//13jh8/fsFz//U+JSUlrFmz5qLvI4QQQojaQ5bvCSGEEKJamzNnDs2aNcPDw4OwsDCaN2+OVnv+99VSU1MxmUyEhoae8/O5ubnA2WWA8fHx//hYAKNGjTrvGJPJRFBQENdeey02m43NmzcTHR1Nbm4u1157LXv27KkQSrVq1Yrg4ODzPt6TTz7J2rVr6dSpE02aNKFPnz4MHz6cbt26AXDixAkKCwtZsGABCxYs+Mfn+E9CQkLo3bu36/aAAQNo3rw5gwYNYuHChTz44IMAFBQU8NJLL7F06VK3xzWZTK6/v/7664waNYro6GgSEhK46aabuOuuu7jqqqvOW8O4ceP44osv6N+/P5GRkfTp04fBgwfTr1+/C9YvhBBCiJpPQikhhBBCVGudOnVy7b53MRwOB6GhoXz22Wfn/Hz9+vUv6bEAZsyYQbt27c45xtfXF4COHTtiNBrZuHEjDRs2JDQ0lGbNmnHttdcyd+5cLBYLmzZt4tZbb/3Hc7Zs2ZL9+/fz448/smrVKr766ivmzp3L888/z0svveSqacSIEecNy9q0aXPRz/GvbrjhBgA2btzoCqUGDx7Mb7/9xuOPP067du3w9fXF4XDQr18/Vy1nxl177bV88803/Pzzz8yYMYPp06fz9ddf079//3OeLzQ0lJ07d7J69Wp++uknfvrpJz766CPuuusuPv7448t6DkIIIYSoOSSUEkIIIUSt0rhxY9auXUu3bt0qLD071ziA5ORkmjRp8o9j/P39K8wqOhdPT086derEpk2baNiwIddeey3gXNZnsVj47LPPyMnJ4brrrrvgc/Dx8WHIkCEMGTKE8vJybrvtNqZMmcJTTz1F/fr18fPzw263X7CmS2Wz2QAoLi4G4OTJk6xbt46XXnqJ559/3jXuzAyyv4uIiGDcuHGMGzeO3NxcOnTowJQpU84bSoHz6zZw4EAGDhyIw+Fg3LhxzJ8/n+eee+68/y5CCCGEqB2kp5QQQgghapXBgwdjt9t55ZVX3D5ns9koLCwEoE+fPvj5+TF16lTMZnOFcYqiAJCQkEDjxo154403XEHNX504caLC7WuvvZbff/+dxMREVygVEhJCy5YtXbvLnTl+Pvn5+RVue3p60qpVKxRFwWq1otPpuP322/nqq69ITk6+YE2X4ocffgCgbdu2AOh0OuDs1+OMmTNnVrhtt9srLOUD5yyoBg0aYLFYznu+vz9XrVbrmuX1T/cTQgghRO0gM6WEEEIIUav06NGDBx54gKlTp7Jz50769OmDXq8nNTWV5cuX88477zBo0CD8/f15++23uffee7n66qsZPnw4QUFB7Nq1i9LSUj7++GO0Wi0LFy6kf//+xMXFcffddxMZGcmxY8dITEzE39/fFeSAM3CaMmUKGRkZFcKn6667jvnz5xMTE0NUVNQ/1t+nTx/Cw8Pp1q0bYWFh7Nu3j9mzZzNgwAD8/PwAmDZtGomJiXTu3Jn77ruPVq1aUVBQwPbt21m7di0FBQUX/DodO3aMxYsXA1BeXs6uXbuYP38+ISEhrqV7/v7+XHfddbz++utYrVYiIyP5+eefSUtLq/BYp06dIioqikGDBtG2bVt8fX1Zu3YtW7du5c033zxvDffeey8FBQX06tWLqKgojhw5wqxZs2jXrh0tW7a84HMQQgghRM0moZQQQgghap158+aRkJDA/Pnzefrpp/Hw8CAmJoYRI0a4GoYD3HPPPYSGhjJt2jReeeUV9Ho9LVq04JFHHnGNuf7669m8eTOvvPIKs2fPpri4mPDwcDp37swDDzxQ4bzXXHMNOp0Ob29v12wjcIZV8+fPv+AsKYAHHniAzz77jLfeeovi4mKioqJ46KGHePbZZ11jwsLC+OOPP3j55Zf5+uuvmTt3LvXq1SMuLs41I+tCdu7cyciRIwHnDKWQkBBuu+02XnnllQo7Gy5ZsoQHH3yQOXPmoCgKffr04aeffqJBgwauMd7e3owbN46ff/6Zr7/+GofDQZMmTZg7dy5jx449bw0jRoxgwYIFzJ07l8LCQsLDwxkyZAgvvvjiPzazF0IIIUTtoFH+Ph9bCCGEEEIIIYQQQohKJm9BCSGEEEIIIYQQQogqJ6GUEEIIIYQQQgghhKhyEkoJIYQQQgghhBBCiConoZQQQgghhBBCCCGEqHISSgkhhBBCCCGEEEKIKiehlBBCCCGEEEIIIYSoch5qF3ClORwOjh8/jp+fHxqNRu1yhBBCCCGEEEIIIeoURVE4deoUDRo0QKs9/3yoWhdKHT9+nOjoaLXLEEIIIYQQQgghhKjTMjIyiIqKOu/na10o5efnBzifuL+/v8rVCCGEEEIIIYQQQtQtRUVFREdHuzKa86l1odSZJXv+/v4SSgkhhBBCCCGEEEKo5EJtlSq10fnGjRsZOHAgDRo0QKPR8O23317wPuvXr6dDhw4YDAaaNGnCokWLKrNEIYQQQgghhBBCCKGCSg2lSkpKaNu2LXPmzLmo8WlpaQwYMICePXuyc+dOHn74Ye69915Wr15dmWUKIYQQQgghhBBCiCpWqcv3+vfvT//+/S96/Lx584iNjeXNN98EoGXLlvz666+8/fbb9O3bt7LKFEIIIYQQQgghhBBVrFr1lNq8eTO9e/eucKxv3748/PDD572PxWLBYrG4bhcVFVVWeUIIIYQQQgghhKjBHA4H5eXlapdR4+n1enQ63b9+nGoVSmVnZxMWFlbhWFhYGEVFRZSVleHl5eV2n6lTp/LSSy9VVYlCiOrOYYc930DqGujyX2jQXu2KhBBCCCHqjPIyG79/fxiDj542PaMw+ujVLkkIl/LyctLS0nA4HGqXUisEBgYSHh5+wWbm/6RahVKX46mnnmLSpEmu22e2HRRC1DEOB+z9FjZMhxMpzmN7v4Nb50HcLWpWJoQQQghRJxTllbFi7m4KjpcAsHPtUdr2iqbtDdESTgnVKYpCVlYWOp2O6OhotNpKbbFdqymKQmlpKbm5uQBERERc9mNVq1AqPDycnJycCsdycnLw9/c/5ywpAIPBgMFgqIryhBDVkcMB+76D9dPhxD7nMWMA1GsKx/6E5aMg71m47jH4Fwm+ELWN1W7lSNERDpoOcqjwEIcKD3Gw8CDl9nLGtxvPwMYD1S5RCFWVHznC8aefwZqRgaFJYzybNMHQpAmGJk0xNG2Czs9P7RKFqFayDhby0/wkyk5Z8Q7wxMvXk/xjxfy5Mp3dv2TQ5oZo2t0QjcFbwimhDpvNRmlpKQ0aNMDb21vtcmq8MxlNbm4uoaGhl72Ur1qFUl27dmXlypUVjq1Zs4auXbuqVJEQotpyOCDlB2cYlbvHecwQAF3HO5ftefrCz8/ClrmQ+Crk7Yf/mw16o7p1C6GC/LJ8tuVscwVPhwoPcaToCDbFds7xT//6NGmmNCa0n4BWI+8iirqnZMvvZE6ciMNkAsCWm0vJb5srjPEICzsdUjXB0LQJxtatMTZvrka5Qqhu/5YsflmcgsOmEBLty4BxbfAJMHB41wm2/phG/rES/lyRzu5fMml7g3PmlMGrWr0UFXWA3W4HwNPTU+VKao8z4Z7Vaq2eoVRxcTEHDx503U5LS2Pnzp0EBwfTsGFDnnrqKY4dO8Ynn3wCwH//+19mz57NE088wZgxY/jll1/44osvWLFiRWWWKYSoSRwO2L8C1k+DnGTnMYM/dBkHXcaCV+DZsf2mQkgzWPkYJC2HgjQYugT8ws750ELURv879j8e2/AYxdZit8/56H1oHNCYxoHOjyaBTfgj+w8+TP6Q95PeJ82UxpTuU/DWy7uJou44+cUXZL/8CthsGNu2IfSRSVgzM7CkHsRy0Plhy8lxfZT873+u+waPHk3o44+huQKNX4WoCRSHwpbvD7N91REArmpfn96jW6E3OK+Bxu1DuaptfQ7tOMHWFWkUHC9h649p7P4lg7Y3RNOml4RTour9m/5HoqIr8bXUKIqiXIFazmn9+vX07NnT7fioUaNYtGgRo0ePJj09nfXr11e4zyOPPMLevXuJioriueeeY/To0Rd9zqKiIgICAjCZTPj7+1+BZyGEqDYOJcKa5yA7yXnb088ZRHUdB15B57/f4Q3wxV1gLgT/KBi+DMLjq6RkIdSiKApLUpbw+tbXcSgOYvxjaFu/LU0Cm7gCqHCfczem/O7gd7y4+UVsDhstg1syq9cswnwkzBW1m2K3k/v6DAo+/hgA/wEDiJjyKlqj+wxbe1ERloOHsBxMdQZVB1Ip3bIFAN8ePWjw5hvofH2rtH4hqprVYmftor0c3nECgIR+jej8f1eh0Z77RariUCqEUwAGbw/a92lI+xsbotXJzFxRucxmM2lpacTGxmI8x/d2cen+6Wt6sdlMpYZSapBQSohaSFHgt3dhzQuAcjqM+q9zdpR38MU9Rt5B+HwI5B8EvQ8M+gCa96/UsoVQi9VhZfof01m2fxkA/9f4/3ih6wt46i5+uvr2nO08nPgwJy0nqe9Vn1m9ZhEXEldZJQuhKntxMccefZSSDRsBCHlwAiHjxl3SO8BFK1dy/KmnUSwWDE2bEvXee3hGRVZWyUKoqvikhZXv7ebE0VNoPTT0GtGC5l0urtGx4lA4uD2XrT+mcTK7FIDolkH0vS9e+k2JSiWh1JV3JUIpiaOFENWbrRy+mwBrngcU6HAXPLwbej178YEUQEgTuHctxF4H1hL4fBj8711n4CVELWKymBi3dhzL9i9Dg4ZHEh7h1W6vXlIgBdAhrANLBiyhSWATTpSdYPSq0fyc/nMlVS2Eesozj3Fk2HBKNmxEYzAQ+fZb1B8//pKXJPjfdBONPv0EXf0QLKmppA8eTOn2HZVUtRDqyT1SxPJpWzlx9BRefnpuebj9RQdSABqthqYdwxj6fGduGN0SD4OOjH0n+er1bRTmllZi5ULUTKNHj0aj0aDRaPD09KRJkya8/PLL2Gw2iouL0ev1LF26tMJ9hg4dikajIT09vcLxmJgYnnvuufOe6+jRowwYMABvb29CQ0N5/PHHsdnO3YP0SpFQSghRfZXkw6e3wM7FoNFC/9dh4LuXFkb9lVcQjPgaEu4GFOdSwO8mOIMvIWqBI0VHGLFyBFuytuDl4cXMnjMZEz/mstf7R/lF8Wn/T+ke2R2z3cyjGx5l/q751LJJ1qIOK92+nfTBg7GkpuJRvz6NFn+Kf//Ln0Xr1aYNscuXY2jZEntBAUdHjcL0/fdXsGIh1HVwWy5fv7GdUlM5wQ18GPRkRyKaBF7WY2m1Glp0ieC2xzrgG2TgZHYpX07/k2P7T17ZooWoBfr160dWVhapqak8+uijvPjii8yYMQNfX186duxYoSUSONsiRUdHVzielpbGkSNH6NWr1znPYbfbGTBgAOXl5fz22298/PHHLFq0iOeff74Sn5mEUkKI6io3BRb2giP/czYyH74cOj8A/7aZnk4P/3kb+k13Bl07FzuDr5L8K1K2EGrZmr2V4SuGk16UTrhPOJ/0/4ReDc/9S8el8PX0ZXav2YxoOQKA2TtnM3nTZCx2y79+bCHUZPruO46OGo29oABDq5bELP8Cr9at//Xj6sPDiflsMb69b0CxWjn+xJPkvj0TxeG4AlULoQ5FUdi6Io3V7ydjtzpoFF+P2x9PwD/E618/dv1oPwZN7khYrD+WEhvfv7OTvf87fgWqFuKfKYpCablNlY9LfYPPYDAQHh5Oo0aNGDt2LL179+b702969OzZs0L4tG/fPsxmM2PHjnXr320wGOjates5z/Hzzz+zd+9eFi9eTLt27ejfvz+vvPIKc+bMoby88t7El60OhBDVz8G1sPxusBRBUAwMWwahLa7c42s0zp5U9Ro7z3Pkf84A7EqfR4gq8tWBr3h1y6vYFBttQtrwTq93CPEKuWKPr9PqeLLTk1wVeBWvbXmNlWkryTyVecXPI0RVUBwOTsx8h/wFCwDwu7E3DaZPR+t95XaZ1Hp7E/Xuu67z5M+fT3laGg2mTb2i5xGiKtjK7fzyaQqpW3MAaHtDNNfc3gTteRqaXw6fAAO3PNLedZ7ET1M4mVVC19uu7HmE+Ksyq51Wz69W5dx7X+6Lt+flxzFeXl7k5zvfVO/ZsydTp04lKyuLiIgIEhMT6d69O7169WL+/Pmu+yQmJtK1a9fz9tPavHkzrVu3Jizs7OY2ffv2ZezYsezZs4f27dtfdr3/RGZKCSGql98XwGd3OAOphtfAvb9UXlDU9Ea4dw0ENoKT6fDBjc5ATIgawu6wM2PrDOdOeYqN/rH9+aDvB5UWFN3R7A7m3TgPf09/duftZtiKYewv2F8p5xKiMjhKSzk2caIrkKr3wANEvvNOpQRFGq2W0EmPEDFtKhq9nlM//8yRESOx5uRc8XMJUVlKTBa+fXsHqVtz0Go1XH9nc7rf0bRSgiIPTx03jmlFp4GxAOxcm8FP7+2m3Fy5/WyEqEkURWHt2rWsXr3atQyvW7dueHp6umZFrV+/nh49epCQkEBeXh5paWkAbNiwgZ49e573sbOzsysEUoDrdnZ2diU8GyeZKSWEqB7sVlg1GbYudN5ud6dzmZ2HoXLPG9oS7vsFlo2Ao5udgVi/6dD5/so9rxD/UnF5MU9uepKNmc7dwsa1G8d/2/z3svtHXazOEZ1ZMmAJE9ZNIL0onZE/jeT1617n+ujrK/W8Qvxb1uxsMsaNw7J3Hxq9nvBXXibwllsq/byBt9yCZ3Q0mRMexLx3L+mD7iBq7ly8WsdX+rmF+DfyMk+xYs5uik9aMHh70O+B1kQ1D6rUc2o0Gq4eEEtgmDfrPt5HelI+X8/Yxk3j2uBf798vFRTir7z0Ova+3Fe1c1+KH3/8EV9fX6xWKw6Hg+HDh/Piiy8C4O3tzdVXX8369esZNmwYGzZs4PHHH8fDw4NrrrmG9evXoygKR48e/cdQSi0yU0oIob6yk/DZoNOBlAZufBlunlP5gdQZPiFw13fQdjgoDvjpcVjxqDMoE6IaOlZ8jJE/jWRj5kYMOgMzesxgbNuxlR5IndHIvxGLb1pM54jOlNnKeOiXh1iUvEgaoItqqywpifQ7BmPZuw9dcDANP15UJYHUGd4JCcQs/wJD0ybYTpzgyMiRFK1SZ8mIEBcjbdcJvpqxneKTFgLDvBn0ZMdKD6T+qmnHMG6d1AFvf0/yj5Xw5bQ/yTpkqrLzi7pBo9Hg7emhysel/s7Ws2dPdu7cSWpqKmVlZXz88cf4+PhU+HxiYiJ79uyhrKyMDh06ANCjRw8SExNJTEzE29ubzp07n/cc4eHh5PxtNu+Z2+Hh4ZdU76WQUEoIoa78Q7DwRji8HvQ+MPQz6Dbx3zc0v1QeBrhlLvR+CdA4A7LPBjkDMyGqkZ25Oxm+YjgHCw9S36s+i/otol9MvyqvI8AQwHu932Nws8EoKLy57U2e/+15rBLmimqmaNUqjowYie3ECQxNmxDzxRd4n/5lvSp5RkXR6PPP8elxHYrZzLGHHybvvfckzBXViqIobF99hJXzkrBZ7ES1COL2JxIIDKv6Xmhhsf7c8VRHQqJ9KTtl5du3t7P/98pbQiREdebj40OTJk1o2LAhHh7uC9569uxJamoqS5YsoXv37uh0zplY1113HRs2bGD9+vWuZX7n07VrV5KSksjNzXUdW7NmDf7+/rRq1erKP6nTJJQSQqgnbRO83wvyU8E/Cu5ZDS0GqFePRgPdH4Yhi0Hv7QzKFt7oDM6EqAZ+OPQDY1aPocBcQMvgliwZsIT4EPWWAOm1ep7t8iyTO01Gq9Hy7cFvuW/NfZw0S5gr1KcoCifmzuXYw4+gWCz49LiORp9/jmdUpGo16Xx9iZ47l+BRdwFw4p13Of74EzgsspulUJ/d5uCXT1PY/M0hUCD+ukj+82BbjD561WryDTJy22MJXNWuPg6bwtqP9rLl20MoDglzhfira665BoPBwKxZs+jRo4freKdOncjNzeW777674NK9Pn360KpVK0aOHMmuXbtYvXo1zz77LOPHj8dgqLwVLBJKCSHUse1j+PQWMBdCZEdnX6fwf78V9xXR8j8wZjX4RzoDs/d7QdpGtasSdZhDcfDO9nd4+tensTqs9G7Ym0X9FhHuU3lTqS+WRqPhzpZ3MueGOfjqfdmWs43hK4ZzuPCw2qWJOsxhsXD88SfIe3cWAMGjRhE9dy46X1+VKwONTkfYU08R/tJL4OFB0Y8/cuSuu7CdOKF2aaIOKysu57uZO0j5LQuNBq4d0pTrhjVDp1P/5aLeoKPf/fF06NcIgG2rjrD6/WSsFrvKlQlRfRiNRrp06cKpU6e4/vrrXccNBoPr+IVCKZ1Ox48//ohOp6Nr166MGDGCu+66i5dffrlSa9cotWzOcFFREQEBAZhMJvz9/dUuRwjxdw47/PwcbJnjvB0/CG6eDfpq2LzyVA4sHQbHtoHWAwa8CQmj1a5K1DGl1lKe+fUZ1h517gx5X+v7mNB+AlqN+i8U/u5Q4SHGrxvPseJj+On9eKPHG1wTeY3aZYk6xnbiBBkTJmDetRs8PAh//jmCBg9Wu6xzKtnyO5kTJ+IwmfCIiCB63nsYmzdXuyxRxxQcL2HF3F0U5ZnxNOroc188jeLqqV3WOaVsySJxcQoOm0L9hn7cNLYNvkFV1INU1Hhms5m0tDRiY2MxGo1ql1Mr/NPX9GKzmer3G60QovYyF8Hnw84GUtc/DbcvrJ6BFIBfGIxeAfG3g8MGP0yEVU87gzUhqkBOSQ6jV41m7dG16LV6Xuv+Gg91eKhaBlIAjQMbs2TAEjqEduCU9RTj1o1jyb4lapcl6hBzSgppg4dg3rUbbUAADRcurLaBFIBPl87ELluKZ0wMtqws0ocN59QviWqXJeqQI3vy+er1PynKM+MfYuT2JzpW20AKoEWXCG5+uD1GXz0njp5i+bSt5B4pUrssIcS/UD1/qxVC1D4nj8CHfSF1NXgYYdBHcP2TVd/Q/FLpveD2D5wBGjgDtc+HOQM2ISrRnrw9DFsxjH0F+wg2BvNB3w8Y2Hig2mVdULAxmPf7vM//Nf4/7IqdqX9M5dUtr2J1SAN0UblO/ZJI+vA7sWVl4RkTQ+yypfh0Of8uQ9WFZ0wMMcuW4t21C0ppKZnjx5P/wYfSAF1UKkVR2J2YwYrZuyg324loEsCgJzsS3MDnwndWWYMmgdwx2Vlrqamcb97YzsFtuRe+oxCiWpJQSghR+Y5ucfZlyt0LvuFw90qIv03tqi6eRuMM0AZ95AzUUlc7A7aTR9SuTNRSq9NXM3rVaE6UnaBJYBOWDFhC+9D2apd10Tx1nrza7VUeSXgEDRqW7V/GuLXjKCqXMFdceYqikP/BB2SOH49SWop31y7EnJ59VFPoAgJouGABgcOGgqKQO2MGWc8+i1JernZpohay2x1s/PwAm5aloijQoms4N09sj5ff+Xflqm78Q7y4/fEEGsXXw2Z1sPr9ZP5cmSZhrhA1kIRSQojKtWspfDwQSvMgvI2zoXlkgtpVXZ7422D0SvANcwZs7/eCo7+rXZWoRRRFYd6ueTy24THMdjPXRV3Hp/0/JdJXvd3CLpdGo2FM/Bhm9pyJl4cXW7K2cOeKOzladFTt0kQtopSXk/XMs+TOeAMUhcChQ2i4YAG6gAC1S7tkGr2e8OefJ+yZZ0CrxfTV1xwdcw+2k7KbpbhyzCVWfpy1i+SNx0ADXW9rTK+7WqLT17yXhZ5eHtw0rg1te0UD8Pv3aaz5cC82q7RZEKImqXnffYQQNYPDAWtfgm8eAHs5tPgPjFkFATXvxXUFUQlwX6Jzp8DSPPj4P7BrmdpViVrAYrcwedNk5ux09lwb2Wok7/Z8F19P9XcL+zd6NezFJ/0/IdwnnPSidIavHM7W7K1qlyVqAdvJkxwdcw+mr78GrZawZ54h/IUX0OjV277+39JoNASPHEH0/HlofX0p/fNP0gcPwXLokNqliVqgMKeUr17fRmbKSTwMOvo/0JoOfRqhqe6tFP6BVquh++CmXH9nc7RaDalbc/j2rR2UFsksQyFqCgmlhBBXXnkJLL8Lfn3Lebv7JBj8KXhW/z4FFyUgEsasdgZt9nL45n5Y97IziBPiMuSV5TFm1RhWpq3EQ+PBi11f5Imrn0Cn1ald2hXRIrgFnw/4nDYhbTBZTNz/8/18nfq12mWJGsxy8CDpg4dQ+uefaH19iZ4/j+CRI2r0i+u/8r32WmKWfo4+OhprRgbpQ4ZSvOlXtcsSNdix/Sf5cvqfFOaU4htk4PbHO3BVu/pql3XFxF0bycCH2mLw9iAnrYjlU7eSl1msdllCiIsgoZQQ4soyHYMP+8G+H0DnCbfMg94vgLaWfbvx9HEGbd0nOW9vehOWj3IGckJcgv0F+xm2Yhi783bj7+nP/Bvnc3uz29Uu64oL8Qrhg74f0D+2PzbFxgu/vcCMrTOwy26W4hIVb/qV9KHDsGZkoI+OJmbp5/hee63aZV1xhiZNiPliGV4dE3AUF5PxwAMULP5M7bJEDbT31+N8/85OLKU2wmL9GTS5IyFRfmqXdcVFtQhm0JMdCQzzpvikha9mbCNtd57aZQkhLqCWvUoUQqjq2DZnn6Xs3eAdAqN+gHbD1K6q8mi1zsDtlnnOAG7f9/BRfyg6rnZlooZIPJrIyJ9Gkl2STYx/DEsGLKFTRCe1y6o0Rg8j06+dzrh24wD4ZO8nTEycSIlVwlxxYYqiUPDpYjIeeABHcTFeHROI+WIZhiZN1C6t0ngEBdHwww8JuPVWcDjIefVVsl9+GcUqu1mKC3M4FH79MpXExSk4HApNrw7jlkfa4xNgULu0ShMY5s3tTyQQ1SIIm8XOyvd2s+Pno9IAXYhqTEIpIcSVkfw1fHQTFGdD/ZbOhuYNu6hdVdVoNwzu+h6860HWLljQE45tV7sqUY0pisJHyR8xMXEiZbYyukR0YfFNi2nk30jt0iqdRqNhbNuxzOgxA4POwIbMDYz8aSTHiyXMFeenWK1kv/wyOVOmgMNBwG230fDDD/EIClK7tEqn9fQk4rUphD7+GGg0nFzyORkPPIDdZFK7NFGNlZfZWPnebnatzQCg08BYbhzTCg/P2rEs/J8YffT858G2xF0XCQr89vVBfvk0BbtN2iwIUR1JKCWE+HcUBdZPhy/vBpsZmvaBe36GoNr/4rqCRl2dQVz9ls5g7qObYM+3alclqiGr3crzvz3PW9veQkFhSPMhzO09lwBDzdst7N/oF9OPRf0WUd+rPqknUxm2Yhg7c3eqXZaohuwmExkPPEDh50tBoyH08ceImPIqWs+as339v6XRaKh3zz1EzZ6Fxtubkt82kz50GOXp6WqXJqqhorwyvpqxjSNJ+ej0WvrcG8fVA2JrTc+1i6HTaekxrBndBzdFo4GU37L4/p2dlBVLA3QhqhsJpYQQl89aBl/dC+tfc97uMg6GLQWjv7p1qSUoxhnINe0DtjJnj6kNM5zBnRDASfNJ7v35Xr49+C1ajZbJnSbzTOdn0Gtr7m5h/0Z8SDxLBiyhZXBLCswFjFk9hh8O/aB2WaIaKU9PJ33oMEp+24zG25uoObOpd889derF9V/53XADMZ8txiMigvK0NNKGDKXk9z/ULktUI1mHTHw5/U8KjpfgHeDJrY92oGnHMLXLUoVGo6Ftr2gGjG+L3qjjeGohX05zfm2EqElGjx6NRqNBo9Hg6elJkyZNePnll7HZbBQXF6PX61m6dGmF+wwdOhSNRkP63968iImJ4bnnnjvvuR566CESEhIwGAy0a9euEp6NOwmlhBCX51QOLPoPJH8JWg/4z0zoNxVqyW5hl83o7wzmujh75pD4Knx9H1jN6tYlVHeo8BDDVwxne+52fPW+zLlhDne2vLPOvrg+I9wnnEX9FnFDwxuwOqw8/evTvLv9XRyKLLOo60q2/E7akKGUp6XhERFBzJLP8OvVS+2yVGds2ZLYL5ZhbNMGh8nE0Xvu4eTy5WqXJaqB/Vuy+Pbt7ZSdshIS7csdkzsSFlNH3yj8i0bx9bj9iQT8Q4wU5Zn56vU/ObonX+2yhLgk/fr1Iysri9TUVB599FFefPFFZsyYga+vLx07dmT9+vUVxq9fv57o6OgKx9PS0jhy5Ai9LvCzdMyYMQwZMqQSnsW5VXooNWfOHGJiYjAajXTu3Jk//vjnd3NmzpxJ8+bN8fLyIjo6mkceeQSzWV7MCVGtZCc5G5of+xOMgTDyG+h4t9pVVR9anTOg+89MZ2CXtBwWDXAGeaJO+vXYr4xYOYLM4kwifSNZfNNiukd2V7usasNb781b17/Ffa3vA+D9pPd5bMNjlFpLVa5MqOXkF19w9N57cZhMGNu2cYYwLVqoXVa14VG/Po0++Rj/m24Cm43s554nZ+o0FLvsZlkXKQ6Fzd8eYu2ifThsCle1r89tjyXgG2RUu7Rqo14DXwY92ZGIJgGUm+38OHsXuxMz1S5LqE1RnDtnq/FxiSspDAYD4eHhNGrUiLFjx9K7d2++//57AHr27FkhfNq3bx9ms5mxY8dWOL5+/XoMBgNdu3Y973neffddxo8fz1VXXXVJ9f0bHpX54MuWLWPSpEnMmzePzp07M3PmTPr27cv+/fsJDQ11G79kyRImT57Mhx9+yDXXXMOBAwdcU9XeeuutyixVCHGxUlY6l+xZS6BeExj+BdRrrHZV1VPHuyH4KvjiLmeA934vGL4MwuPVrkxUEUVRWJKyhNe3vo5DcdAhtANv93ybYGOw2qVVO1qNloc6PERsQCwv/PYCa46sIfNUJrN6zSLMp24uPamLFLud3NdnUPDxxwD4DxhAxGtT0Bpq725hl0trNNLgzTfwvOoq8mbPpuDjjylPT6fBm2+g8/VVuzxRRawWO2sX7eXwjhMAJPRrROf/uwqNtm7Pwj0XLz9Pbp7YnvWfpZCyJZtNyw5wMquE7kOaotPJAqI6yVoKrzVQ59xPHwdPn8u+u5eXF/n5zhl/PXv2ZOrUqWRlZREREUFiYiLdu3enV69ezJ8/33WfxMREunbtitFYvQLrSr363nrrLe677z7uvvtuWrVqxbx58/D29ubDDz885/jffvuNbt26MXz4cGJiYujTpw/Dhg274OwqIUQVUBT4dSYsHe4MpGJ7wL1rJZC6kKt6OBug12sCRZnwQR9nsCdqPavDypTfpzDtj2k4FAc3N76Z9/u8L4HUBQxsPJAP+n5AsDGYfQX7GLZiGHvy9qhdlqgC9uJiMsaNcwVSIQ89SIM3Zkgg9Q80Gg31J4wn8q030RgMFG/YwJFhwynPPKZ2aaIKFJ80882b2zm84wRaDw29R7ekyy2NJZD6Bzq9ll6jWtL11saggeSNx/hx1i7MJVa1SxPioiiKwtq1a1m9erVrGV63bt3w9PR0zYpav349PXr0ICEhgby8PNLS0gDYsGEDPXv2VKv086q0mVLl5eVs27aNp556ynVMq9XSu3dvNm/efM77XHPNNSxevJg//viDTp06cfjwYVauXMnIkSPPex6LxYLFYnHdLioqunJPQgjhZCuHHx+BnYudtzuOgf6vg65uNme+ZPUaOwO8L0ZB2gZnsHfjS3DNQ1DH+wnVViaLicc2PMaWrC1o0PBIwiOMjhtd5/tHXaz2oe1ZMmAJE9ZN4GDhQUavGs2U7lPoE9NH7dJEJSnPPEbm2LFYUlPRGAw0mDYV//791S6rxvC/6Sb0UVFkjB+PJTWV9MGDiZo9G+8O7dUuTVSSnPQiVr63m1JTOV5+evr/tw0RjevWLq6XS6PR0KFvIwLDvFnz0V4yU07y1evbGDCuDYFh3mqXJ6qS3ts5Y0mtc1+CH3/8EV9fX6xWKw6Hg+HDh/Piiy8C4O3tzdVXX8369esZNmwYGzZs4PHHH8fDw4NrrrmG9evXoygKR48erZahVKXNlMrLy8NutxMWVnHKfVhYGNnZ2ee8z/Dhw3n55Zfp3r07er2exo0bc/311/P000+f9zxTp04lICDA9REdHX1Fn4cQdV5JPnxyszOQ0midYdSAtySQulReQTDiK2eghwJrnofvJjgDP1GrHCk6woiVI9iStQUvDy9m9pzJ3fF3SyB1iSJ9I/m0/6dcG3ktZruZRzc8yvxd81FkN8tap3T7dtIHD8aSmurslbT4UwmkLoNXmzbELl+OoWVL7AUFHB01CtN336ldlqgEB7fl8s2b2yk1lRPcwMfZK0kCqUt2Vbv63PZYB3yDDBTmlPLl9D/J3H9S7bJEVdJonEvo1Pi4xN8Le/bsyc6dO0lNTaWsrIyPP/4YHx+fCp9PTExkz549lJWV0aFDBwB69OhBYmIiiYmJeHt707lz5yv6JbwSqtXi2fXr1/Paa68xd+5ctm/fztdff82KFSt45ZVXznufp556CpPJ5PrIyMiowoqFqOVyU+D9nnD0NzD4w/Dl0PkBmd1zuXR6Z6DX/3VnwLdzsTPwK5EdYGqLP7L+YPiK4aQXpRPuE84n/T+hV0PZLexy+Xr6MqvXLEa0HAHA7J2zmbxpMha75QL3FDWF6bvvODpqNPaCAgytWhKz/Au8WrdWu6waSx8eTsxni/G7sTeK1crxJyeT+9bbKA7ZzbI2UBSFrSvSWP1+Mnarg0at63H74wn4h3ipXVqNVT/aj0GTOxIa44+l1MYP7+xkzyZZ/iqqHx8fH5o0aULDhg3x8HBf8NazZ09SU1NZsmQJ3bt3R6dz7oh+3XXXsWHDBtavX+9a5lfdVFooFRISgk6nIyen4m5TOTk5hIeHn/M+zz33HCNHjuTee++ldevW3Hrrrbz22mtMnToVx3l+mBoMBvz9/St8CCGugNS18MGNUHgEgmLgnjXQtLfaVdV8Go0z2Bu+3Bn0Hf0NFvZyBoCiRvvywJc8sOYBisqLaBPShs8HfE6LYNkt7N/SaXU82elJnu/6PB4aD1amrWTMqjHkleWpXZr4FxSHg9y33ub4k5NRrFb8buxNzOLF6M/zO6K4eFpvbyLfeYd6998PQP6CBRyb+DCOUtnNsiazldtZ8+Fe/vjB2Rum7Q3R3DS2DZ5elbpvVZ3gE2Dg1kntadoxFIdDYf1n+/l1eSoOh8zMFTXHNddcg8FgYNasWfTo0cN1vFOnTuTm5vLdd99d1NK9gwcPsnPnTrKzsykrK2Pnzp3s3LmT8vLKW91RaaGUp6cnCQkJrFu3znXM4XCwbt26825BWFpailZbsaQzCZ9M1xeiiigK/D4fltwBliJoeA3c+wuEyovrK6ppb2fQFxQDJ9OdAeDBtWpXJS6D3WHn9a2v89Lml7ApNvrH9ueDvh8Q4hWidmm1yh3N7mDejfPw9/Rnd95uhq0Yxv6C/WqXJS6Do7SUYxMfJn/BAgDq3X8/ke+8g9ZberlcKRqtltBJjxAxbSoavZ5Ta9ZwZMRIrH97s1jUDCUmC9++vYPUrTlotRquv7M53e9oilYaml8xHp46brwnjk4DYwHYtS6DlXN3U15mU7kyIS6O0WikS5cunDp1iuuvv9513GAwuI5fTCh177330r59e+bPn8+BAwdo37497du35/jxyuu9pVEqMe1ZtmwZo0aNYv78+XTq1ImZM2fyxRdfkJKSQlhYGHfddReRkZFMnToVgBdffJG33nqLBQsW0LlzZw4ePMjYsWNJSEhg2bJlF3XOoqIiAgICMJlMMmtKiEtlt8JPT8Cfp3fIbHcn/Odt8JCdjypNST4sG+GcMaXRQr/p0Pl+tasSF6m4vJgnNz3JxsyNAIxvN54H2jwg/aMqUbopnQd/eZD0onS8PLyYfu10ejasfk07xblZs7PJGDcOy959aPR6wl95mcBbblG7rFqtdPt2Mic8iL2gAI/69YmaO0eWSNYgeZmnWDFnN8UnLRi8Pej3QGuimgepXVatlvpnDus+3ofd6iC4gQ8DxrWRJZK1hNlsJi0tjdjYWIxGo9rl1Ar/9DW92GymUkMpgNmzZzNjxgyys7Np164d7777rqu51vXXX09MTAyLFi0CwGazMWXKFD799FOOHTtG/fr1GThwIFOmTCEwMPCiziehlBCXqezk2d3h0MjucFXJZjm9u+FnzttX3wv9pkkz+WruWPEx1+5wBp2BV7u/Sr+YfmqXVSeYLCYe3fAov2f9Lrsb1iBlSUlkjhuP7cQJdMHBRM2ehffpRqyicjl3N/wvltSDzt0Np0/Dv598v6ru0nad4OcP92Kz2AkM85bd4aqQ2+6GD7Qmokmg2mWJf0lCqSuvRoRSVU1CKSEuQ/4hWDIY8g+C3gduXwgtblK7qrpFUeC3d2HNC4ACV10Pdyxy7tonqp0duTt4OPFhCswF1Peqz7u93iU+JF7tsuoUq8PKtN+n8cWBLwC4pcktPN/lefQS5lZLRT/9xPHJT6FYLBiaNiHqvXl4RkWqXVadYi8u5tijj1KywTmzM+ShBwkZO1bC3GpIURR2rDnK5m8OgQJRLYLoe188Rh/5/laVik+aWTF3N3kZxWg9NPQa0YLmXSLULkv8CxJKXXlXIpSqVrvvCSFUcHgDvN/LGUj5R8E9qyWQUoNGA90mwtDPnMHg4fWw8EZnYCiqlR8O/cA9q++hwFxAy+CWLBmwRAIpFei1ep7t8iyTO01Gq9Hy7cFvuW/NfZw0y3be1YmiKJyYM4djj0xCsVjw6XEdjT7/XAIpFeh8fYmeO5fgUaMAyHt3FscfexyH2axyZeKv7DYHv3yawuavnYFU/HWR/OfBthJIqcA3yMhtjyVwVbv6OGwKaxftY/O3h1CkAboQV5SEUkLUZX9+BItvA3MhRHaE+36BcOkzoaoWA2DMKmdAmJ/qDAzTNqldlQAcioN3tr/D078+jdVhpXfD3izqt4hwH9ktTC0ajYY7W97JnBvm4Kv3ZVvONoavGM6hQglzqwOH2czxxx4nb9ZsAIJHjSJ67lx0vr4qV1Z3aXQ6wp6aTPjLL4GHB0UrVnBk1ChsJ06oXZoAyorL+W7mDlJ+y0KjgWuHNOO6Yc3Q6eQlm1r0Bh397o+nQ79GAGxfdYRVC5KxWuwqVyZE7SHf4YSoixx2WPUU/PgwOGwQPwhG/wh+YWpXJgAi2jgDwsiOzsDw01tg28dqV1WnlVpLmbR+EguTFgJwX+v7ePP6N/HWS2+P6qB7ZHcW37SYSN9IMoszGbFyBP879j+1y6rTbCdOcGTUKIpWrAAPD8JffomwpyajOb2rslBX0ODBNFy4EG1AAOZdu0kbPARzSoraZdVpBVklfDntT7IOmvA06vjPhLa06RklyyurAY1WQ9dbGtN7dEu0HhoO7zzB129so/i2a7B2AAEAAElEQVSkzDIU4kqQUEqIusZcBJ8PhS1znbd7PuPsIaWXXUWqFb8wZ1AYP8gZHP7wEKx+xhkoiiqVXZLN6FWjWXd0HXqtnte6v8ZDHR5Cq5EfodVJ48DGLBmwhA6hHSi2FjNu3TiW7Fuidll1kjklxRly7NqNNiCAhgsXEjR4sNplib/x6dKZ2GVL8YyJwZaVRfrwOzn1yy9ql1UnHdmTz1fT/6Qoz4x/iJHbn+hIw7h6apcl/qZ5lwhuebg9Xn568jKKWT7tT3LSi9QuS4gaT36jFqIuOXkEPuwLqT+DhxEGfQQ9npAd9qorvZczMLz+aeftzbPh82HOYFFUieS8ZIatGMa+gn0EG4P5oO8HDGw8UO2yxHkEG4N5v8/73Nz4ZhyKg6l/TOXVLa9idVjVLq3OOPXLL6QPvxNbVhaeMTHELluKT5fOapclzsMzJoaYZUvx7toFpbSUzPETyF+4kFq2D1K1pSgKuxMzWDF7F+VmOxFNAhg0uSPBDXzULk2cR0STQAY96fw3KjWV882b2zm4LVftsoSo0SSUEqKuOLrF2Z8ody/4hsPdKyH+NrWrEhei0cD1TzoDRA8jpK52Bosnj6hdWa23Kn0Vo1eNJq8sjyaBTVgyYAntQ9urXZa4AE+dJ690e4VJCZPQoGHZ/mWMWzsOk8Wkdmm1mqIo5C9cSOb4CSilpfhc05WY07NwRPWmCwig4YIFBA4dAopC7htvkvXMsyjl5WqXVqvZ7Q42fn6ATctSURRo0TWcmye2x8vXU+3SxAX4h3hx++MJNIqvh93qYPX7yWxdkSZhrhCXSUIpIeqCXUvh44FQmgfhZ/oVJahdlbgU8bc5g0TfcGew+H4vZ9AorjhFUXhv13s8vuFxLHYL10Vdx6f9PyXSV3YLqyk0Gg13x9/NzJ4z8fLwYkvWFkasHMGRIglzK4OjvJysp58h9403QVEIHDqE6Pnz0QUEqF2auEgavZ7wF14g7JlnQKvF9PXXHBkzBttJ2c2yMphLrPw4axfJG4+BBrre1phed7VEp5eXZjWFp5cHN41rQ9te0QD88UMaaz7ci80qbRaEuFTynU+I2szhgLUvwTcPgL0cWvzHubNbgLy4rpEiE07vkNjGGTB+PNAZOIorxmwz8+SmJ5m709lzbWSrkbzb8118PWW3sJqoV8NefNL/E8J9wkkvSmf4iuFszd6qdlm1iu3kSY6OGYPpm29AqyXsmWcIf+EFNHrZvr6m0Wg0BI8cQfT8eWh9fSn7cxvpg4dgOXhQ7dJqlcKcUr56fRuZKSfxMOi46b+t6dCnkTQ0r4G0Wg3dBzfl+jubo9VqSN2aw7dv7aDEZFG7NCFqFAmlhKitykvgi5Hw61vO290nweBPwVP6FNRoAZHOYLHFf5xB4zcPOINHh0Ptymq8vLI87ll9Dz+l/YSHxoMXur7AE1c/gU4ru4XVZC2CW/D5gM9pE9KGovIi7v/5fr468JXaZdUKloMHSb9jMGV/bkPr60v0/HkEjxwhL65rON9rryVm6efoo6KwZmSQPnQYxZs2qV1WrZC5/yRfTv+TwpxSfIMM3P54B2Lb1le7LPEvxV0bycCJ7TB4e5CTVsSX0/4kL7NY7bJELTJ69Gg0Gg0ajQZPT0+aNGnCyy+/jM1mo7i4GL1ez9KlFd+oHjp0KBqNhvT09ArHY2JieO655855nl27djFs2DCio6Px8vKiZcuWvPPOO5X1tFwklBKiNjIdg4/6Q8qPoPOEW+dD7xdAK5d8reDp4wwYu09y3v71LVh+lzOIFJdlf8F+hq0Yxu683fh7+jP/xvkMajZI7bLEFRLiFcIHfT+gf2x/bIqNFze/yOtbX8cuu1letuJNm0gfOgxrZib66Ghiln6O77XXql2WuEIMTZoQs/wLvDom4CguJuOB/1Lw6WLpmfMv7Nl0jB/e2Yml1EZYrD+DJnckJMpP7bLEFRLVPIhBT3YkMMyb4pMWvpqxjbRdJ9QuS9Qi/fr1Iysri9TUVB599FFefPFFZsyYga+vLx07dmT9+vUVxq9fv57o6OgKx9PS0jhy5Ai9evU65zm2bdtGaGgoixcvZs+ePTzzzDM89dRTzJ49uxKfGWiUWvbTpaioiICAAEwmE/7+/mqXI0TVO7YNPh8OxdngHQJDP4OGXdSuSlSWnZ/DDw85Z02Ft4FhS2V55iVKPJrIk5uepMxWRox/DLNvmE0j/0ZqlyUqgaIozNs9z7U887qo65h+7XRZnnkJFEXh5KeLyZk2DRwOvDomEDVrFh5BQWqXJiqBo7yc7BdedC7PBAKHDSX86adleeYlcDgUfvvyILt+yQCg6dVh9BrZAg9PmYVbG5lLrKx+P5nMlJPOfmG3Nqb9jQ1lBmk1YTabSUtLIzY2FqPRiKIolNnKVKnFy8Prov9fjB49msLCQr799lvXsT59+nDq1Ck2b97M008/zddff01KSgoA+/bto2vXrjz55JPs37+fRYsWAfDRRx8xduxYCgsLMRqNF3Xu8ePHs2/fPn755Zdzfv7vX9O/uthsxuOiKhFC1AzJX8O3Y8FmhtBWzoAiSF5c12rthkFwLCy9E7J3OxugD1sijewvgqIofLTnI2Zum4mCQpeILrzR4w0CDNKcubbSaDSMbTuW2IBYnv31WTZmbmTkTyOZfcNsaWR/ERSrlewpUyhcugyAgFtvJfylF9F6ym5htZXW05OI16ZgaNKY3DfepPDzpViPHCHy7belkf1FKC+z8fMHeziSnA9Ap4GxdLwpRgKKWszoo+c/D7Zl07JU9mw8xuavD3Eyu5TrhzdH5yErFqqbMlsZnZd0VuXcvw//HW+992Xf38vLi/x85/eWnj17MnXqVLKysoiIiCAxMZHu3bvTq1cv5s+f77pPYmIiXbt2vehACsBkMhEcHHzZdV4MuTKEqA0UBdZPhy/vdgZSTfvCmNUSSNUVDbs4G6DXb+mcIffRTc6AUpyX1W7l+d+e5+1tb6OgMKT5EOb2niuBVB3RL6Yfi/otor5XfQ4WHmT4iuHsyN2hdlnVmt1k4uj99zsDKY2G0McfI+K1KRJI1QEajYZ699xD1OxZaLy9KfltM+lDh1H+tz4loqKivDK+mrGNI8n56PRa+twbx9UDYiWQqgN0Oi09hjXj2iFN0Wgg5bcsvn9nJ2XF5WqXJmoBRVFYu3Ytq1evdi3D69atG56enq6leuvXr6dHjx4kJCSQl5dHWloaABs2bKBnz54Xfa7ffvuNZcuWcf/991/x5/FXsnxPiJrOWgbfTYDkL523u4yHPq+ANGeue8xF8NU9kPqz8/b1T0OPJ0B+Aa7gpPkkDyc+zPbc7Wg1Wp68+kmGtxyudllCBdkl2Tz0y0PsK9iHXqvnpWteYmDjgWqXVe2Up6eT8d+xlKeno/H2JvKNGfidpx+FqN3MKSlkjB2HLSsLbUAAUe++i0/nTmqXVe1kHSxk5bwkzMVWvAM8uWlsG8Ji5HVJXXRkTz4/v59MudmOf4iRAePaEtxANh1SS01evrd48WKMRiNWqxWHw8Hw4cOZO3cuPj7O/0/du3cnLi6O+fPnExYWxo8//sjVV19Nnz59GDZsGD169KBx48Zs3LiRay+iB2RycjI9e/Zk4sSJPPvss+cddyWW78lMKSFqslM5sOg/zkBK6wED34F+r0kgVVcZ/Z1LNruMd95e/xp8da8zuBQAHCo8xPAVw9meux1fvS9zb5grgVQdFu4TzqJ+i7ih4Q1YHVae/vVp3tn+Dg5FdrM8o2TL76QNGUp5ejoeERHELPlMAqk6zNiiBbFfLMPYtg0Ok4mj99zDyeXL1S6rWtm/JYtvZ+7AXGwlJNqXOyZ3lECqDmsUV4/bn+iIf4iRojwzX73+J0f35KtdljhNo9HgrfdW5eNSZ0327NmTnTt3kpqaSllZGR9//LErkDrz+cTERPbs2UNZWRkdOnQAoEePHiQmJpKYmIi3tzedO194ueLevXu54YYbuP/++/8xkLpSJJQSoqbKTnL2Dzr2JxgDYeQ3kDBa7aqE2rQ6ZzA58B1nUJn8pTO4PJWjdmWq+9+x/zFi5QgyizOJ8o1i8U2L6RbZTe2yhMq89d68df1b3Nv6XgAWJi1k0vpJlFpLVa5MfSeXfcHRe+/FYTJhbNvGGUa0aKF2WUJlHvXr0+jjj/EfMABsNrKfe56cadNR7HV7N0vFobD520OsXbQPh03hqvb1ue2xBHyDLr53i6idghv4MOjJjkQ0CaDcbOfH2bvYnZghu1mKS+Lj40OTJk1o2LAhHh7urcF79uxJamoqS5YsoXv37uh0zkkK1113HRs2bGD9+vWuZX7/ZM+ePfTs2ZNRo0YxZcqUSnkufyehlBA1UcpK+KAvFGVCvSbOfkKx16ldlahOEkY7g0pjoDO4fL+XM8isgxRF4bN9nzFu3TiKrcV0CO3AkgFLaBzYWO3SRDWh1WiZ2GEir3V/Db1Wz7qj6xi9ajTZJdlql6YKxW4nZ+pUsl94AWw2/AcMoNHHH+NRv77apYlqQms00uCNGYQ89CAABYsWkTluPPbiYpUrU4fVYmfVgmS2rzoCQEK/RvS7Lx69QWauCycvP09untieFl3DURTYtCyVjZ8fwG6XmbniyrjmmmswGAzMmjWLHj16uI536tSJ3Nxcvvvuuwv2kzqzZK9Pnz5MmjSJ7OxssrOzOXHiRKXWLqGUEDWJosCvM2HpcLCWQGwPuHct1JMX1+IcYq9zBpb1mjgDzA/6OgPNOsTqsDLl9ylM+2MaDsXBLU1uYWGfhQQZZft64W5g44F80PcDgo3B7CvYx/AVw0nOS1a7rCplLy4mY9w4Cj7+BICQhx6kwRsz0F7CTj2ibtBoNNQfN47It99CYzBQvGEDR4YNpzzzmNqlVanik2a+fmMbh3eeQOuhoffolnS5pTEarfRzFBXp9Fp63dWSrrc1Bg0kbzzGj7N2YS6xql2aqAWMRiNdunTh1KlTXH/99a7jBoPBdfxCodSXX37JiRMnWLx4MREREa6Pq6++ulJrl0bnQtQUNgv8+Ajs/Mx5u+M90H866PTq1iWqv7KTsHw0HF4PaKD3i9BtYq1vgG6ymHhsw2NsydqCBg2PJDzC6LjRsvORuKBjxceYsG4CBwsPYtAZmNJ9Cn1j+qpdVqUrzzxG5tixWFJT0RgMNJg2Ff/+/dUuS9QAZUlJZI4bj+3ECXTBwUTNno13h/Zql1XpctKLWDl3N6VF5Xj56en/3zZENJZdXMWFHd55gjUf7cVmsRMY5s2AcW0IDPNWu6xa75+acovLI43OhagrSvLhk1ucgZRGC/1nwH/ekkBKXByvILjzS2eQiQJrX3Du2GirvVsTHyk6woiVI9iStQUvDy/e6fkOd8ffLYGUuCiRvpF82v9Tro28FovdwmMbHmPernm1uv9H6fbtpA8ejCU11dkzaPGnEkiJi+bVujUxy7/A0Kol9oICjo4ahem779Quq1Kl/pnDN29up7So/GzPIAmkxEW6ql19bnusA75BBgpzSvly+p9k7j+pdllCqEJCKSGqu9wUeL8nHP0NDP5w53LofL/aVYmaRqeHAW86A02NFnYuhk9udgaetcwfWX8wfMVw0ovSCfcJ59P+n9Kz4T9PVxbi73w9fZnVaxYjW40EYM7OOTy56UnMNrPKlV15pu++4+io0dgLCjC0aknM8i/wat1a7bJEDaMPDydm8WL8buyNYrVy/MnJ5L71NoqjdvXMURSFrSvS+HnhHuxWB41a1+P2xxPwD/FSuzRRw9SP9mPQ5I6ExvhjKbXxwzs72bOpbi1/FQIklBKiektdCx/cCIVHICgG7lkDTXqrXZWoqTQaZ6B553JnwHn0N1jYyxl81hJfHviSB9Y8QFF5EW1C2vD5gM9pHtxc7bJEDaXT6nji6id4oesLeGg8+CntJ+5ZfQ95ZXlql3ZFKA4HuW+9zfEnJ6NYrfjdeCMxixejDw9XuzRRQ2m9vYl85x3q3e988yx/wQKOTXwYR2nt2M3SVm5nzYd7+eOHNADa3hDNTWPb4OnlvhOWEBfDJ8DArZPa07RjKA6HwvrP9vPr8lQcjto7M1eIv5NQSojqSFHg9/mw5A6wFEHDa+DeXyBUtuIWV0CT3s6AMygGTqY7g8/UtWpX9a/YHXZe3/o6L21+CZtio39sfz7o+wEhXiFqlyZqgUHNBjH/xvn4e/qzO283w1YMY3/BfrXL+lccpaUcmziR/AULAKj3wANEvjMTrbf0NBH/jkarJXTSI0RMm4pGr+fUmjUcGTESa3bN3s2yxGTh27d3kLo1B61WQ88RLeh+R1O00tBc/EsenjpuvCeOTgNjAdi1LoOV7+2mvMymcmVCVA0JpYSobuxWWPEo/PQEKA5oNwLu+g586qldmahNQls4g86G1ziDzyV3OIPQGtgzp7i8mAd/eZBP934KwPh245l+7XSMHtLAUlw5nSI6sWTAEmL8Y8guyWbkTyNJPJqodlmXxZqdTfqIEZxasxaNXk+D6dMIfeRhNFr5tVBcOYG33ELDjxehCw7GvHcv6XcMpiwpSe2yLkte5im+nPYnOWlFGLw9GDixHa26N1C7LFGLaDQarh4QS59749DptRxJyuerGdsoyitTuzQhKl2l//YxZ84cYmJiMBqNdO7cmT/++OMfxxcWFjJ+/HgiIiIwGAw0a9aMlSvr1hbmog4rOwmfDYI/PwA0cOPLcPNs8PBUuzJRG/nUg7u+hXZ3OgPQn55wBqL2mrM18bHiY4z8aSSbjm3CoDMwo8cM/tv2v9LQXFSKRv6NWHzTYrpEdKHMVsbExIl8lPxRjWqAXpaURPodg7Hs3YcuOJiGH39MwM03q12WqKW8O3Qg5osvMDRtgu3ECY6MGEnRqlVql3VJ0nad4KsZ2yk+aSEwzJtBT3YkqnmQ2mWJWqppxzBundQBb39PCo6X8OX0P8k6WKh2WUJUqkoNpZYtW8akSZN44YUX2L59O23btqVv377k5uaec3x5eTk33ngj6enpfPnll+zfv5/333+fyMjIyixTiOoh/xAsvBEOrwe9DwxdAt0mOvsACVFZPAxw8xxnAIrGGYh+NsgZkFZzO3J3MHzFcA4WHqS+V30W9VtEv5h+apclarkAQwBze89lSPMhKCi8te0tnv/teaw1IMwt+uknjowYie3ECQxNmxLzxRd4d2ivdlmilvOMiqTR55/j0+M6FIuFYw8/wom5c6t9mKsoCttXH2HlvCRsFjtRLYK4/YkEAsNkiauoXGGx/tzxVEdCon0pO2Xl25k72L8lS+2yhKg0GqUSfyJ07tyZq6++mtmzZwPgcDiIjo7mwQcfZPLkyW7j582bx4wZM0hJSUGvv7it7i0WCxaLxXW7qKiI6OhoTCYT/v7+V+aJCFHZ0jbBshFgLgT/KBi+FMJl5yNRxVJWwlf3grUE6jWF4cugXmO1qzqnHw79wAu/vYDVYaVlcEve7fUu4T7SnFlUHUVRWJKyhNe3vo5DcdAhtAMze84kyFj9ZlAoikLe3LnkzXL+PubbowcN3nwDna+vypWJukSx28l9/XUKPv4EAP8BA4iY8ipaY/Vbam23OVi/ZD8pvzmDgPgekXQf3BSdTpa4iqpjtdhZ+9FeDu88AUCHfo3o8n9XoZE+ZpfNbDaTlpZGbGwsxmr4vacm+qevaVFREQEBARfMZirtO2t5eTnbtm2jd++zO4VptVp69+7N5s2bz3mf77//nq5duzJ+/HjCwsKIj4/ntddew263n/c8U6dOJSAgwPURHR19xZ+LEJVq2yL49BZnIBXZEe77RQIpoY4WN8E9q53BaH4qvN8L0jaqXVUFDsXBO9vf4elfn8bqsNK7YW8W9VskgZSochqNhjtb3smcG+bgq/dle+52hq8YzqHCQ2qXVoHDbOb4Y4+7AqngUaOImjtHAilR5TQ6HWFPPUX4Sy+BhwdFK1ZwZNQobCdOqF1aBWXF5Xw3cwcpv2Wh0cC1Q5rRY1hzCaREldMbdPS7P54O/RoBsH3VEVa9n4zVcv7XxkLURJX23TUvLw+73U5YWFiF42FhYWSfZ/eNw4cP8+WXX2K321m5ciXPPfccb775Jq+++up5z/PUU09hMplcHxkZGVf0eQhRaRx2WPU0/DARHDaIHwSjV4Bf2IXvK0RlCW/tDEYjOzqD0k9vdQan1UCptZRJ6yexMGkhAPe1vo83r38Tb70spRDq6R7ZncU3LSbSN5LM4kxGrBzB/479T+2yAJw9fEaNomjFCvDwIPzllwh7ajIanU7t0kQdFjRkMA0XLkQbEIB5127SBg/BnJKidlkAzh4+0/4k66AJT6OO/0xoS5ueUWqXJeowjVZD11sac8Polmg9NBzecYKv39hG8Umz2qUJccVUq8jf4XAQGhrKggULSEhIYMiQITzzzDPMmzfvvPcxGAz4+/tX+BCi2jMXwedDYcsc5+2ez8DtC0Ev00hFNeAXBqN/dAalDpszOF31tDNIVUl2STajV41m3dF16LV6Xuv+Gg91eAitplr9GBN1VOPAxiwZsIQOoR0othYzbt04Ptv3mao9c8wpKc4X+7t2ow0IoOHChQQNHqxaPUL8lU+XzsQuW4pnTAy2rCzSh9/JqV9+UbWmI3vy+er1PynKM+MfYuT2JzrSME52PhbVQ4suEdzycHu8/PTkZRSzfNqf5KQXqV2WqCKjR49Go9Gg0Wjw9PSkSZMmvPzyy9hsNoqLi9Hr9SxdurTCfYYOHYpGoyE9Pb3C8ZiYGJ577rlznic/P59+/frRoEEDDAYD0dHRTJgwgaKiyv2/Vmm/zYeEhKDT6cjJyalwPCcnh/Dwcy+ziIiIoFmzZuj+8g5ey5Ytyc7Opry8vLJKFaJqnTwCH/aF1J/BwwvuWAQ9npCG5qJ60Xs5g9Kezzhvb5kDnw9zBqpVLDkvmeErhrOvYB/BxmA+6PsBAxsPrPI6hPgnwcZg3u/zPv/X+P9wKA6m/TGNKb9Pweqo+gbop375hfThd2LLysIzJobYZUvx6dK5yusQ4p94xsQQs2wp3l27oJSWkjl+AvkffFDlYa6iKOxOzGDF7F2Um+1ENAlg0OSOBDfwqdI6hLiQiCaBDHrS+X+z1FTON29uJ/XPnAvfUdQK/fr1Iysri9TUVB599FFefPFFZsyYga+vLx07dmT9+vUVxq9fv57o6OgKx9PS0jhy5Ai9evU65zm0Wi0333wz33//PQcOHGDRokWsXbuW//73v5X4zCoxlPL09CQhIYF169a5jjkcDtatW0fXrl3PeZ9u3bpx8OBBHA6H69iBAweIiIjA09OzskoVouoc3eLs05O7F3zD4e6VEHer2lUJcW4ajTMwHfQReBghdbUzUD15pMpKWJW+itGrRnOi7ARNApuwZMAS2ofKbmGievLUefJqt1d5JOERNGhYtn8Z49aOw2QxVcn5FUUhf+FCMsdPQCktxbtrF2JOz0YRojrSBQTQcMECAocNBUUhd8YbZD3zLEoVvRlttzvY+PkBNi1LRVGgxTUR3Pxwe7x85XWHqJ78Q7y4/fEEGsXXw2518PPCPWxdkVbtd7OsrhRFwVFaqsrHpf6bGQwGwsPDadSoEWPHjqV37958//33APTs2bNC+LRv3z7MZjNjx46tcHz9+vUYDIbz5jFBQUGMHTuWjh070qhRI2644QbGjRvHpk2bLvlreyk8KvPBJ02axKhRo+jYsSOdOnVi5syZlJSUcPfddwNw1113ERkZydSpUwEYO3Yss2fPZuLEiTz44IOkpqby2muv8dBDD1VmmUJUjV1L4fsHwV4O4W1g2FIIiFS7KiEuLP42CGoEnw93Bqrv94Khn0HDLpV2SkVRmL97PnN2Ope4Xhd1HdOvnY6vpzRnFtWbRqNhTPwYYvxjmLxpMluytjBi5Qhm3zCbRv6NKu28jvJysl94EdM33wAQOHQI4c88g+YidzMWQi0avZ7w55/HcFVjcqZOxfT115QfPULUrFl4BFXebpbmEiur308mM+UkaKDrrY1pf2NDNDJzXVRznl4e3DSuDb99dZBd6zL444c0TmaX0mtkCzw8pWfgpVDKytjfIUGVczffvg2N9+X3RfXy8iI/Px9whlJTp04lKyuLiIgIEhMT6d69O7169WL+/Pmu+yQmJtK1a9eL3nnw+PHjfP311/To0eOy67wYldqMY8iQIbzxxhs8//zztGvXjp07d7Jq1SpX8/OjR4+SlZXlGh8dHc3q1avZunUrbdq04aGHHmLixIlMnjy5MssUonI5HLD2JfjmAWcg1XIgjFklgZSoWSITTu8M2QZK8+Djgc6gtRKYbWae3PSkK5C6q9VdvNvzXQmkRI3Sq2EvPun/CeE+4aQXpTN8xXD+yPqjUs5lO3mSo2PGOAMprZawZ54h/IUXJJASNYZGoyF45Aii589D6+tL2Z/bSB88BMvBg5VyvsKcUr56fRuZKSfxMOi46b+t6dCnkQRSosbQajV0v6Mp19/ZHK1WQ+rWHL59ewclJovapYlKpigKa9euZfXq1a5leN26dcPT09M1K2r9+vX06NGDhIQE8vLySEtLA2DDhg307NnzgucYNmwY3t7eREZG4u/vz8KFCyvt+QBolFo216+oqIiAgABMJpM0PRfqKy+Br++HlB+dt7tPgl7PgVaaM4saqrzEGbDu+8F5+wr/n84ry2PiLxPZnbcbD40Hz3R5hkHNBl2RxxZCDXlleTz0y0Mk5SVVyv9py8GDZPx3LNbMTLS+vkS+/Ra+1157xR5fiKpmOXiQjLHjsGZkVMr/6cz9J/+fvfuOj6Jc1Dj+200vpNCSQAKJgNJ7701pB7siCAICKr0oigVQFBEQAemCigdFAbs0RToKKL0ICEgogQQCKaRvduf+sZp7EFBamE3yfD+f/dw7m5mdJxwnyT77zvuycs5eMtOy8Q/2okP/qhQNL3TLXl/kdvv7f9Pt+1WlWIT+m76SjIwMjh07RlRUFN7e3hiGgZGebkoWi4/PNRfhPXr04OOPP8bb2xubzYbD4aBLly7MnDkTPz/n/HeNGzemUqVKzJkzh5CQEJYuXUqdOnW455576Ny5M82aNaNMmTJs2LCBJv/yMzU2NpbExER+//13XnzxRZo1a8bMmTOvuO/f/03/17V2MyqlRHJLUoxzhb3YPeDmCfdOh2qdzE4lcvMcDlj7Bmyc5Nyu0BEemAOeNzcp7KELhxiwZgCxqbEEeAYwuflk6obVvQWBRcyVkZ3BqJ9GsSJ6BQDdKnbj2VrP4ma9udssUjZuJGboMBwpKXhERBAxayZeZcveisgipspOSODUwIGkb9vuHP334osEd338pkcy7d8Yw4ZPf8fhMAiJCqDdM1XwC/S6RalFzJMYl8aymXtIjEvD3cuNe56sSFS1YmbHcjn/VKC4sh49ehATE8OsWbPw9PSkRIkSuLtfOhPTyJEjWbRoEV999RUNGjQgISEBNzc3xo4dy6FDh2jWrBmDBg0iISHhuubr3rRpE02aNOH06dOEhYVd9vVbUUppuIZIbojZ7px3J3YP+BaF7ktVSEn+YbVCq1HOIsrN0zlq6sN2ziL2Bq09sZZuK7oRmxpLZEAkCzssVCEl+Ya3uzfjm46nX/V+ACz4bQED1wwkJSvlhl7PMAwu/HcBJ59+BkdKCj61axG5eJEKKck33IODKfXBBwQ+8AA4HMSNHUvsmDEYthtbzdLhMNi05DDrPjmEw2FQrk4I9w+roUJK8o2gEF8eer4W4eWDyc60s3z2XnZ8f1wToOcjfn5+lC1bllKlSl1WSIFzXqnDhw+zcOFCGjdujJub84Ovpk2bsn79etatW5dzm9/1+GsRuszM3Ls1VKWUyK2270v4sD2kxELxis55eEppKW7Jh6o9Bt2/cxavZ3Y7i9iY7df1EoZh8MG+Dxi8djDp2enUD6vPx+0/ztUJoUXMYLFY6FutLxObTcTLzYuNMRvptqIbMSnXV+YaNhuxr71G3JtvgsNB4AMPUOqDD3J1QmgRM1g9PQl7cyzFhz8HFguJn37Gyaefxp50fatZZqVns3zWHnavPglA3Y5R3P1kRdw9NCG05C/efh78Z2A1KjctCQZs/uooaxYcxJ7t+PeDJc9r2LAhXl5eTJs27ZKJyevWrcvZs2f55ptv/nU+qeXLl/Phhx+yb98+oqOjWbZsGc888wyNGjUiMhdX8lUpJXKrGAasGw+f94TsDCjXBp783rlqmUh+Vaq+s3gtVsFZxH7YHvZ/dU2HZtmzGPnTSCZvn4yBQae7OjGz9UwCvQJzObSIedpGtmV+2/kU8ynGkcQjdFnWhZ1nd17TsfakJE489RSJny0Ci4Xiw58j7M2xWK/zU0+RvMJisVCkVy/Cp0/D4utL6s+bie70GFnR0dd0fHJ8Ol9M3M7xvedx87ByT+9K1OkQpQnNJd9yc7PStPOdNOlUDosFDv58hm+m7CQ9JcvsaJLLvL29qV+/PhcvXqR58+Y5z3t5eeU8/2+llI+PD3PnzqVx48ZUqFCBoUOHcu+997J06dJcza45pURuBVs6fDMA9n3u3K7fH+55HW5yvhCRPCMjGb7oDYe/d263eBmaDoer/OGfkJHAkLVD2HF2B1aLlRfqvECXCl1uY2ARc8WmxjJozSAOXDiAh9WD1xq+RscyHa+6f1Z0NCef6UtWdDQWX19Kvj2RQn+uuiNSEGQcPMjJvv3IPnMGa2Ag4VOn4lf/6iPRzxxJZMWcvaRftOEb6En7vlUJidR7Ayk4ju8/zw9z95GVYSegqDcd+lWjcImbm/8zr8urc0q5Ms0pJeIKLsbB/P84CymrO3ScCm3fVCElBYt3AHT+1FnIAqwd6yypbJevaHI08Sidl3Vmx9kd+Hv4M7PVTBVSUuCE+oUyv+18Wpdqjc1h46VNLzF1x1QcxuW3WaRu2cKxP0eHuIeFEbnwExVSUuB4ly9P1OJFeFeriiMpiRO9e5OwePEV9z205QxfT9lJ+kUbRSP8eWREbRVSUuCUrlSEh56vTUBRb5LjM/hiwjZO7D9vdiyRy6iUErkZsXv/nEdnG3gHQbevoFYPs1OJmMPq5ixkO051FrT7PncWthfjcnbZFLOJrsu7EpMSQ7h/OB+3/5hGJRuZGFrEPL4evkxqPok+VfoAMG/vPIatG0aaLS1nn4RFiznRuw+OpCS8q1V1vikvX96syCKmci9WjNIffURAhw6QnU3sqNHEjRuHYbcDYDgMNn99lB/nH8CRbXBHjWI8+Fwt/IM1IkIKpsIl/Hh4RG3CygaSlWFn6fTd7Fl7yuxYIpfQ7XsiN+rg8j9HgqRCkbLQZTEUKWN2KhHXcGwDLOoGGYkQEI7R+VMWJu5lwq8TcBgOahavyZQWUwj21uTMIgDfHf2O0T+PxuawUaFwBaY2m4x1xn+58NF/AQjo0ME5f5SXVgsTMQyD+JkziZ82HQC/Zk0p/uYE1i45wR+7zgFQq21p6t17Bxar5o8SsdscrFt4kIObYwGo3KwkjR8th5tbwRqjotv3br1bcfueSimR62UY8PO7sGo0YEBUM3j0I/DRm2uRS5w/CgsfxXb+CG8VK85if+cvqvvL3s+o+qPwcPMwOaCIa9l5didD1g4hPek8w79zp/Jh5/LLRQcNpGjfvpqcWeRvkles4PSIF0nHh321BpPsWRyru4WWXctzV/0ws+OJuBTDMNi56gSbvzoKBoSXD6ZNn8p4+xWcv8dUSt16t6KUcs/tkCL5SnYWLB0Kuz52btfuBe3Gg95ci1yuSBmSnviKZ79+iK1kYDEMhhapS48Gr2GxFqxP5kSuRY3iNfi4+iSOPtWLkLhMstwh6fknqPBEP7OjibikgHbtSPQIYeOnJ8nyKIRHdgp33xtKlAopkctYLBZq3lOaoOK+rPrwN04dTOCLCdvp0K8qQSG+ZseTAkzvCkSuVep5+O99zkLKYoV2E6DDJBVSIldxPPk4Xdf0ZysZ+ODG1LPx9Nz+BZZvBzoLXhG5RNqOHaT3GERIXBYpAZ6MftyN/sZCZu2eRT4b2C5ySxzeFsfyb5LJ8iiEf/Z5am8bT+YLvUn65huzo4m4rDuqF+Oh4TXxD/YiMS6Nz8dv49ShBLNjSQGmUkrkWpw9CPNawomfwSsAuiyBek9fdbl7kYLulzO/0GVZF6KTown1C2XBfz6jRbPXnIXuro+dBW+qVoAR+UvSN99wonsP7AkJeFWsQJWvl9Ow9RMAzNw1kxc2vkBGdobJKUVcg2EY/LrsGD/M24/d5qB0lSJ0mtCG4k1qYdhsnH5hBGffmYzhuHw1SxGBouGFeHhEbUKiAshMy+a7qbvYvzHG7FhSQKmUEvk3h3+E9++GhGgIjoReq6Bca7NTibisz3//nKdXPU1yVjJVi1Xl0w6fcleR8s4it8sSZ7F74meY28JZ+IoUYIbDwdl3JnP6hREYNhuF7r6byI8/xrtESZ6v8zyjG4zG3eLOimMr6PV9L+LT482OLGKq7Cw7q97fzy/fHQOgWqsI2vetinfhAEpOnUKRp58G4Px77xEzeAiOtLR/ejmRAssv0Iv7h9agXJ0QHA6DdZ8cYtOSwzgcGpkrt5dKKZGrMQzYOgcWPgKZyVCqIfReA8W1FLfIldgddib8OoHXNr9GtpFN+6j2fNDmA4r6FP3/ncq1dha7wZGQeNxZ+B7+0bTMImZypKURM3gw5997D4AiTz9NyalTsPr+/9weD9/5MHPunkOAZwB74vfQeVlnDl04ZFZkEVOlJmXy9eSdHN52FqvVQvPH76LxI+Ww/rnCnsVqpfjQIZQY/xYWDw8urlrF8a7dsMXFmZxcxDW5e7px95MVqdsxCoDdq0+yfOYestKzTU4mBYlKKZErsdtg2bOw4nkwHFD9cXjia/ArYnYyEZeUaktl0NpBLPhtAQADqg/grSZv4eV2heXri5d3FrylGjoL34WPOAtgzZkjBYgtNpbox7tycdWPWDw8KDH+LYoPHXLFRQDqhtVlYYeFRAZEEpsaS7cV3Vh7Yq0JqUXME3/qIp+/tY24Y8l4+brTcXB1KjUpecV9A++7j1IffYRb4cJk/PYb0Q8/Qvrefbc5sUjeYLFYqNMhint6V8LNw8rxfef5YuJ2kuPTzY4mBYRKKZG/S0+Ajx+Cbe8DFrh7DNw3A9yv8OZaRIhJiaHr8q5sOLUBbzdv3m72Nk9Xe/qfl6/3K+Iseqs/7ix+VzzvLILtttuWW8Qs6Xv3cuyRR8g8cAC3woUp9dF8Au+77x+PKR1Qmo/bf0y9sHqkZ6czeO1gPtj3gSZAlwLhj13n+GLiDlISMgkK8eXhF2oTflfwPx7jW7MGkYsX41WuHNnnznG8WzeSV668TYlF8p5ytUN44Nma+AZ6cuF0Kp+P38aZI4lmxxKgR48eWCwWLBYLnp6elC1bljFjxpCdnU1KSgoeHh589tlnlxzz2GOPYbFYiI6OvuT5yMhIRo4c+a/nPH/+POHh4VgsFhITE2/hd3M5lVIi/+v8UZjXGo6tBw8/eGwhNBqsCc1FrmLn2Z10WdaFI4lHKOZTjPlt59Mmss21Hezu5Sx87x4DWJxF8McPOYthkXwqecUKjnfthv1cPF7lyhG5eDG+NWte07GBXoHMaj2LTnd1wsBg8vbJjPp5FDaVuZJPGYbBju+Ps2LOXrIz7YSXD+ah52td8/L1nuElKf3pQvybNcPIyCBmyFDOzZypMlfkKkIiA3hkRG2KRviTftHG11N2cmjLGbNjCdC2bVvOnDnD4cOHefbZZ3n11VeZOHEi/v7+1K5dm3Xr1l2y/7p164iIiLjk+WPHjnH8+HFatmz5r+fr1asXVatWvcXfxZWplBL5yx/rYW5LOH8EAsKh1/dQvr3ZqURc1ndHv6PX9724kHGBCoUrsLDDQioVrXR9L2KxOIvfxxY6i+Bj653F8PmjuRNaxCSGYXBuxgxihg7DyMzEv1kzSn+6EM/wK99+dDUeVg9ervcyI+qOwGqx8vWRr+n9Q28SMlTmSv5itzlY898DbP7qKBhQuVlJ/jOwGt5+Htf1Om7+/oTPnEHh7t0BiH93GqeHP48jMzM3Yovkef7B3jz4XC3uqF4MR7bBj/MPsPnroxj5cAJ0wzCwZdpNeVxvOe7l5UVoaCilS5emb9++tG7dmm+//RaAFi1aXFI+HThwgIyMDPr27XvJ8+vWrcPLy4sGDRr847lmzZpFYmIizz333HVlvFHut+UsIq5u24ew/DlwZEPJ2s43yIVCzE4l4pIchoNpO6cxb+88AFqXas3YxmPx9bi2T66vqHx7ZxG88DFnMTy3JXRaAFFNb1FqEfM4MjI489LLJC9fDkDhHj0oPvw5LG5uN/R6FouFxys8TumA0gxfP5wdZ3fQeVlnZrSaQZmgMrcyuogp0lOyWDF7L2eOJGGxQONH76Rqi/Abfj2LmxshL47As8wdxI55neSlS8k6eYKI6dNxL1bsFiYXyR88vNxo+1Rltnz7BztWHmfHyuMkxqbRumdFPLxu7HeXK8rOcvDe4PWmnPupqc1u6t/Sx8eH8+fPA85Saty4cZw5c4awsDDWrl1L48aNadmyJXPmzMk5Zu3atTRo0ABvb++rvu5vv/3GmDFj2Lp1K3/88ccN57seGiklBZvDDitfhKVDnIVU5Yehx1IVUiJXkWZLY9i6YTmFVJ8qfZjUfNLNFVJ/Ca0CfdY4i+GMRFjwAGyff/OvK2Ki7HPnON69u7OQcncn9PUxhIx44YYLqf/VuGRjPm7/MeH+4Tlzu22K2XQLUouY58LpVD5/axtnjiTh6e3GfwZUu6lC6n8FP/oopebNwxoYSMbuPRx7tBMZBw/ektcWyW8sVgsN7i9D6x4VsLpb+GPXOb58ezspCRlmRyvQDMPgxx9/5Pvvv8+5Da9Ro0Z4enrmjIpat24dzZo1o1atWsTHx3Ps2DEA1q9fT4sWLa762pmZmXTu3JmJEydSqlSpXP9e/mIx8tlN1cnJyQQGBpKUlERAQIDZccSVZSTDF73g8A/O7RYvQ9Phmj9K5CpiU2MZtGYQBy4cwMPqwWsNX6NjmY63/kS2DPimP+z73Lldvz/c8zpY888nc1IwZBw8yMm+/cg+cwZrYCDhU6fiV7/eLT9PQkYCQ9YOYcfZHVgtVp6v8zxdynf558UGRFzQ8f3n+WHuPrIy7AQU9aZD/2oUDvO75efJio7m5DN9yYqOxuLrS8m3J1LoGuZYESmozhxJZMWcvaRftOEb6En7vlUJicx777UzMjI4duwYUVFReHt7YxgG2VkOU7K4e1qv+fd0jx49+Pjjj/H29sZms+FwOOjSpQszZ87Ez8/5M7Jx48ZUqlSJOXPmEBISwtKlS6lTpw733HMPnTt3plmzZpQpU4YNGzbQpEmTK55n2LBhnD59OmfS9HXr1tGiRQsSEhIICgq64jF//zf9X9fazWiklBRMCcfhgzbOQsrdGx7+EJo9r0JK5Cr2xe+jy7IuHLhwgMLehfmgzQe5U0gBeHjDQ/OcRTHAlhnw6WPOIlkkj7i4Zg3RXR4n+8wZPKOiiFr0Wa4UUgDB3sHMvWcu95e9H4fh4K1f3mLs1rHYHJoAXfIGwzDYveYky6bvJivDTljZQB4eUTtXCikAz8hIIhd9hl/DBhhpaZzqP4Dz77+vCdBFriKsbBAPv1CbwiX8SEvK4qtJOzi8Lc7sWDfNYrHg4eVmyuN6Pzhq0aIFu3bt4vDhw6Snp/PRRx/lFFJ/fX3t2rXs37+f9PR0av65iEqzZs1Yu3Yta9euxdfXl3r1rv63yJo1a1iyZAnu7u64u7vTqlUrAIoWLcro0aNv4F/42qiUkoLnxBbnfDVnfwP/UOi5HCo/aHYqEZe1MnolPVb24Fz6OcoGlWVhh4VUL149d09qsTiL4oc/dBbHh39wFskJx3P3vCI3yTAMzs+bx6n+AzDS0vBr2IDIzz7FMzIyV8/r6ebJmIZjGFZrGBYsLDq0iH4/9iMpMylXzytys+x2B+s//Z1Niw9jGFC+YRj3DamBj79nrp7XLTCQiDlzCOr8GBgGZye+zZmXX8HIysrV84rkVQFFfXhoeC1KVy6C3ebgh3n7+XXZMZW5t4mfnx9ly5alVKlSuLtfPjV4ixYtOHz4MAsXLqRx48a4/TlNQNOmTVm/fj3r1q3Luc3var744gt2797Nrl272LVrF/PmOafr2LhxI/3798+db4zbVErNmDGDyMhIvL29qVevHr/88ss1HffZZ59hsVi4//77czegFBy7P4OPOkJaPIRW/XP+mlpmpxJxSYZhMGv3LIavH06mPZOm4U1Z0G4BJf2vb7Wwm1L5QWdx7B/qLJLntnQWyyIuyJGVxZmXXubs25PAMAjq/BgRc+bgFhh4W85vsVjoWbknU1tMxcfdhy1nttB1eVeOJ6vMFdeUkWpj6bTd7N8QAxZo+GBZWnYrj5v77fnc3OLhQeioUYS8/DJYrSR9+SXHn3yS7AStZilyJZ4+7rTvV5VqLSMA+OW7Y6z64Deys+wmJ5OGDRvi5eXFtGnTaNasWc7zdevW5ezZs3zzzTf/OJ8UQJkyZahcuXLOIyoqCoAKFSpQvHjxXMue6z/xFy1axLBhwxg9ejQ7duygWrVqtGnThrNnz/7jcdHR0Tz33HNXvd9R5Lo4HPDja/DV02DPggod4cmVEHgb31yL5CEZ2Rm8sOEFZu6aCUC3it14t8W7+Hv63/4wJWs5C+TQqs5C+aOOzoJZxIVkJyRw4sknSfrqK7BaCXnlFcJGj8bicX3L198KLUq1YEG7BYT6hRKdHE2XZV345cy1fSAocrskxqXxxYTtnDqYgLuXG+2fqUKNe0rd9rnQLBYLhbt1JWLObKz+/qRv2070o53IPHLktuYQySusVguNHy1H88fvwmq1cPjXOL6evJPUpEyzoxVo3t7e1K9fn4sXL9K8efOc5728vHKe/7dSyiy5PtF5vXr1qFOnDtOnTwfA4XAQERHBwIEDGTFixBWPsdvtNG3alCeffJKNGzeSmJjI119/fU3n00TncpmsVPjyKTi41LndeBi0HAlW3b0qciXx6fEMXjOYPfF7cLe483L9l3n4zofNjuW8lr96Gg5859zWtSwuIvPIEU4+0xfbqVNY/f0pOXky/k0amx3Lda9lKfBOHUpg5Zy9ZKZl4x/sRYf+VSkaXsjsWFe4lt/BXx+Qi1yVq17LV/NPk3LLjXH5ic6zsrLYvn07rVu3/v8TWq20bt2azZs3X/W4MWPGULx4cXr16vWv58jMzCQ5OfmSh0iOpBj4oK2zkHLzhAfeg9aj9SZW5CoOXThE52Wd2RO/hwDPAObcPcd13sR6+sEj/4Umzzq3N70Di7s5yyoRk6Rs3Ej0Y52xnTqFR0QEkZ996hKFFEBRn6K83+Z92kW1I9vI5rXNrzHh1wnYHbrNQsyzf2MM303dRWZaNiFRATw8orbLvIn1KluWyCWL8aldC0dKCieffoYLCz7WnDkiVxF+VzAPv1CboBBfUhIy+WLiDo7tPmd2LMljcvWdeXx8PHa7nZCQkEueDwkJITY29orHbNq0iffff5+5c+de0znGjRtHYGBgziMiIuKmc0s+EbPdOf9M7B7wLQrdl0K1TmanEnFZa0+spduKbsSmxhIZEMnCDgupG1bX7FiXslqh1Sh4YI6zaD641Fk8J8WYnUwKGMMwuLDgY04+/QyOlBR8atcicvEivMqWNTvaJbzdvRnfZDz9qzsnKF3w2wIGrhlISlaKycmkoHE4DDYtPsy6Tw7hcBiUqxPC/cNq4BfoZXa0S7gHB1Pqgw8IfOABcDiIGzuW2DFjMGxazVLkSoJCfHno+VqElw8mO9PO8tl72fH9cZW5cs1carjIxYsX6datG3PnzqVo0aLXdMyLL75IUlJSzuPkyZO5nFLyhH1fwoftISUWild0zkdTKneW4hbJ6wzD4IN9HzB47WDSs9OpH1afj9t/TOmA0mZHu7pqjzmLZt+izuJ5bktnES1yGxg2G7GvvUbc2LHgcBD44IOU/uAD3IODzY52RRaLhWeqPcPEZhPxcvNiY8xGuq3oRkyKyly5PbLSs1k+cw+71zj/Tq93bxR3P1kRdw83k5NdmdXTk7A3x1J8+HNgsZD46WecfPpp7ElazVLkSrz9PPjPwGpUaloSDNj81VHW/PcAdpvD7GiSB+RqKVW0aFHc3NyIi4u75Pm4uDhCQ0Mv2//o0aNER0fTsWNH3N3dcXd357///S/ffvst7u7uHD169LJjvLy8CAgIuOQhBZhhwLrx8HlPyM6Acm3gye8h2IXfXIuYKMuexcifRjJ5+2QMDDrd1YmZrWcS6HV7Vgu7KaXqOQvn4hWdBfSH7WH/V2anknzOnpTEiaeeIvGzRWCxUHz4c4SNfQPLPyyx7CraRrZlftv5FPMpxpHEI3RZ1oWdZ3eaHUvyueT4dL6YuJ3j+87j7mGlTZ/K1G4fddsnNL9eFouFIr16ET59GhZfX1J/3kx0p8fIio42O5qIS3Jzs9Ks85006VQOiwUObo7lm6k7SU/JMjuauLhcLaU8PT2pVasWq1evznnO4XCwevVqGjRocNn+5cuXZ+/evezatSvnce+999KiRQt27dqlW/Pkn9nS4YtesO5N53aDAdD5U/BWUSlyJQkZCfT5oQ/fHP0Gq8XKi3Vf5JX6r+Bhvf2rhd2w4NLO4rlcG2cRvaQHrJ/gLKhFbrGs6GiiOz1G2uYtWHx9CZ8xnSK9ern8m+v/VbloZRZ2WEiFwhW4kHGBXt/34ruj35kdS/KpM0cS+Xz8Ni6cTsU30JMHnqtJ2Vq5t6x4bijUqhWRCz/BPSyMrOhojnV6jNQtW82OJeKSLBYLVVtE0GFANTy93ThzJInP33L+DHAlurXw1rkV/5a5fvvesGHDmDt3Lh999BEHDhygb9++pKam0rNnTwCeeOIJXnzxRcC5jGHlypUveQQFBVGoUCEqV66MZx74FFJMcjEO5v8H9n0BVnfo+C60GQtW1xwWLmK2o4lH6bysMzvO7sDfw5+ZrWbSpUIXs2PdGO8AZwHdYIBze+1Y+KK3s6gWuUVSt2zl2J+jJNzDwohc+AmFWrY0O9YNCfULZX7b+bQq1Qqbw8ZLm15i6o6pOAzdZiG3zqEtZ/h6yk7SL9ooVqoQj4yoQ/HSefODQu/y5YlavAjvalVxJCVxondvEhYvNjuWiMsqXakIDz1fm4Ci3iTHZ/DFhG0c33/e7Fi4uTnfG2ZlafTWrZKWlgaAh8eNf6jtfqvCXE2nTp04d+4co0aNIjY2lurVq7Ny5cqcyc9PnDiBVSuhyc2I3QsLH4PkU+AdBJ0WQFRTs1OJuKxNMZsYvn44KbYUwv3Dmd5qOmWCypgd6+ZY3ZxFdNE7Ydkw2Pc5JETDYwuhUMi/Hi7yTxIWLSb29dchOxvvalWJmD4d92LFzI51U3w9fHmn+TtM2zmNeXvnMW/vPI4lHePNxm/i6+FrdjzJwwyHwZZv/2DHyuMA3FGjGK17VMTDK29/UOherBilP/qIMy+/QvKyZcSOGk3W0T8o/vxwLG55+3sTyQ2FS/jx8IjarJi9lzNHklg2fTeNHilH1Rbhpo0wdnd3x9fXl3PnzuHh4aEe4iYYhkFaWhpnz54lKCgop/C7ERYjn41dS05OJjAwkKSkJM0vVRAcXP7niIhUKFIWuiyGInn8zbVILjEMg4UHFzLh1wk4DAc1i9dkSospBHu75uTMN+zYBljUDTISISAcunwGoVXMTiV5kGG3c3bCBC589F8AAjp0IGzsG1i9vU1Odmt9d/Q7Rv88GpvDRoXCFXi35buE+l0+96fIv7Fl2vnxw9/4Y5dzSfhabUtT7947sFjzzi2u/8YwDOJnzSL+3WkA+DVrSslJk3Dz9zc5mYhrstscrFt4kIObYwGo1LQkTTqVw83NnEIoKyuLY8eO4XBodPCtEBQURGho6BWLxmvtZlRKSd5kGPDTVPjxVcCAqGbw6Efgk8/eXIvcIjaHjbe2vsXi3523G9xf9n5G1R+Fh1semj/qepw/Cgs7wfnD4OEHD82D8u3NTiV5iD0lhZhnnyV1/QYAig4aSNG+ffPU/FHXY+fZnQxZO4QLGRco5lOMd1u+S+Wilc2OJXlISkIGy2buIf5kClZ3Cy27VeCuevm33ExesYLTI17EyMzEq1w5wmfNwjO8pNmxRFySYRjsXHWCzV8dBQPCywfTpk9lvP3M+TvU4XDoFr5bwMPD4x9HSKmUUimVf2VnwtKhsOsT53btXtBuPOTXN9ciNykpM4ln1z/L1jNbsWBhaK2h9KjUI9++uc6RnuCc+PyPdYAFWr8KjQZDfv++5aZlnTrFqb59yTx8BIuXFyXeGkdAu3Zmx8p1MSkxDFg9gCOJR/By8+KNxm/QNrKt2bEkD4iLTmb5zD2kJWfhU8iD9n2rEnpHHljF9Sal793LqX79yT53DrfChQmfPg3fmjXNjiXiso7tPscPH/xGdqadoBBfOvSrSlCIbhnPr1RKqZTKn1LPw6KucOJnsFih7Xio95TZqURc1vHk4wxYPYDo5Gh83H0Y32Q8LUq1MDvW7WO3wcoR8Os853b1rvCfyeCuhTPkytJ27OBU/wHYExJwL1aM8Jkz8KlScG7/TMlK4fkNz7MxZiMA/ar345mqz+T/Eltu2OFtcaz+6AB2m4PCJfzo0L8qAUV8zI5129hiYznZrx+Zvx3A4uFB2BuvE3jffWbHEnFZ8acusmzGHlISMvHydaft01UIv0t3u+RHKqVUSuU/Zw/Cwkch8Th4BcAjH0LZ1manEnFZW89sZdi6YSRnJRPqF8r0ltO5q/BdZscyx9b3YOULYDigVEPo9DH4FTE7lbiYxK+/JnbkKAybDa+KFYiYOROP0Px7+9HV2B12Jm2fxILfFgDQLrIdYxqNwds9f82lJTfHMAy2LY/ml++OARBZpQh396qEp3eur6PkchxpaZx+YQQXV60CoMhTT1FsyGAsmkRZ5IpSkzJZMXsvcceSsVotNO18J5Wa6PbX/EallEqp/OXwj/B5T8hMhuBI6LwIipc3O5WIy1ry+xLe3PIm2UY2VYtVZWqLqRT1KWp2LHMdWe28nU8/R+RvDIeDc5OncH7uXAAK3X03Jca/hdW3YN9S8PnvnzN2y1jnz5GiVZnaUj9HxCk7y86a/x7g8LazAFRrHUHDB8tizUcTml8vw+Hg3NR3OT9nDgCF7m5NifHjC/zPEZGryc6ys2bBQQ7/GgdAtZYRNHy4YP8cyW9USqmUyh8MA7bOge9fdI5wKN0IHl2gEQ4iV2F32Hl729t8fOBjANpFteP1Rq/j5eZlcjIXce6Qc8RlQrRzxOXDH0I5jbgsyJwjHF7g4qofASjy9NMUGzxIIxz+9MuZXxi6bijJWcmE+IYwvdV0yhdWmVuQ/X2EQ7PH76JioxJmx3IZSd98w5lXRhb4EZci1+LvIy5LVy7CPb0q4elT8EZc5kcqpVRK5X12G6x4HrZ94NzWXDAi/yglK4XhG4azKWYTAP2r9+fpqk9rLpi/Sz0Pi7vB8Z/+nJvuLaj7lCZAL4BssbGc7NuPzAOaC+afFPi56STHJXPB+LnT7qkqlNRcMJdJ27GDUwMGYr9wAbdiRYmYObNAzU0ncr0um5uuX1UCihacuenyK5VSKqXytvQEWNwdjq0HLHD3GGg4UG8aRa7i1MVTDFwzkCOJR/B28+aNxm/QJrKN2bFcV3bWn6t4OkeUaRXPgid9zx5O9u+P/Vz8n6tmTce3Zg2zY7mspMwknlv/HFvObMGChSG1htCzUk+V3gXIH7vOserD/1k1q39Vgorr1rSryToV8+cqnocL1CqeIjcqLjqZ5bP2kJbkXMWz3dNVCCsbZHYsuQkqpVRK5V3njzpvrzl/BDz84KF5UL692alEXNbOszsZvGYwCZkJFPMpxrst36Vy0cpmx3J9hgE/vwurRgMGRDWDRz8CH33qn98lL1/O6RdfwsjMxKtcOcJnzcIzXBOs/hubw8b4X8az6NAiAO4rcx+jGozC000jmPMzwzDY+cMJNn99FAwILx9Mmz6V8fZTif9v7CkpxDz7LKnrNwBQdOAAivbrpzJX5CpSEjJYNnMP8SdTsLpbaNm1PHfVDzM7ltwglVIqpfKmYxtgUTfISISAcOjyGYRquLPI1Xx39DtG/zwam8NGhcIVeLflu4T6ae6K63JwOXzRG2ypUKQsdFkMRcqYnUpygWEYxM+YSfz06QD4N2tGiUmTcPP3MzlZ3mEYBgsPLmTCrxNwGA5qFq/JlBZTCPZWmZsf2W0O1i08yMHNsQBUblaSxo+Ww81Nc65dK8Nu5+yEiVz46CMAAjp0IGzsG1i9tZqlyJXYMu38OP83/th5DoCabUtT/947sGgC9DxHpZRKqbxn24ew/DlwZEN4Hej0CRQKMTuViEtyGA6m7ZzGvL3zAGhdqjVjG4/F10O3UtyQ2L2w8DFIPgXeQdBpAUQ1NTuV3EKOjAzOvPQyycuXA1C4Rw+KD38Oi5ubycnypk0xmxi+fjgpthRK+pdkRqsZlAlSmZufpF/MYsWcvZw5koTFAo0fvZOqLcLNjpVnJSxeTOyY1yE7G+9qVYmYPh33YsXMjiXikgyHwdZv/2D7yuMA3FGjGK17VMTDS7+z8xKVUiql8g6HHX54BbbMdG5XeQTunQ4e+gRJ5ErSbGm8tOklVp9YDUCfKn0YUGMAVos+ub4pF+Pgsy4Qsw2s7tD+bajd0+xUcgvYzp7l1ICBZOzZA+7uhI4eRfAjj5gdK887mniUAasHcCrlFP4e/kxsNpHGJRubHUtugfOnU1g+cw/J8Rl4ervRpk9lSlXSysc3K3XLVk4NHowjKQn3sDAiZs3Eu7xWsxS5mkNbzrDm44M4sg2KRvjToV9V/IP1HjGvUCmlUipvyEiGL3rB4R+c2y1egabPaUJzkauITY1l0JpBHLhwAA+rB681fI2OZTqaHSv/sGXAN/1h3+fO7fr94J43wKpP5vKqjAMHONm3H9mxsbgFBlLy3Xfxq1fX7Fj5RkJGAkPWDmHH2R1YLVaer/M8Xcp30Zw5edjx/ef5Ye4+sjLsBBT1pkP/ahQO0y2ut0pWdDQnn+lLVnQ0Fl9fSr49kUItW5odS8RlnTmSyIo5e0m/aMM30JP2fasSEqn3+XmBSimVUq4vIdp5u8y5A+DuAw/MgkoPmJ1KxGXti9/HwDUDiU+Pp7B3Yaa2mEr14tXNjpX/GAZsmAhrxzq3y90DD70P3vqdktdcXL2amOHPY6Sl4RkVRcTsWXiWLm12rHwny57FmM1j+OboNwA8euejjKg3Ag+rJsLOSwzDYM/aU/y05DCGAWFlA2n3TBV8/DWR/a1mT0oiZuhQUn/eDBYLxZ8dRuFevVTmilxFcnw6y2bu4cLpVNw8rLTqXoFytTXNi6tTKaVSyrWd2OK8TSbtPPiHQudPoWRNs1OJuKyV0St5ZdMrZNozKRtUlhmtZlDCv4TZsfK3fV/C130hOwOKVXAuvBAcaXYquQaGYXDh/fc5O+kdMAz8Gjak5JTJuOnvglxjGAbz989n8vbJGBjUC6vHpGaTCPQKNDuaXAO73cHGRYfZvyEGgPINw2je5S7c3HVbeG4xbDbixo0jYeGnAAQ++CBhr47G4qkSUORKstKz+eGD/Rzfex6Auh2jqN0+UmWuC1MppVLKde3+DL4dCPYsCKsGnT+DAL25FrkSwzCYs2cOM3bNAKBpeFMmNJ2An4dupbgtYrbDp10gJRZ8i8BjC6FUfbNTyT9wZGURO/pVkr76CoDgLp0JeeklLO7uJicrGNaeWMsLG18gPTudyIBIpreaTukAjU5zZRmpNr6fu49TBxPAAg0eKEONu0vpjd5tcuHjT4h7801wOPCpXYvwadNwD9ZqliJX4nAY/PzlEXb/eBKAcnVCaNmtPO6emmbBFamUUinlehwOWPM6bHrHuV2hIzwwBzz15lrkSjKyMxj18yhWHFsBQPeK3Rlaayhumt/o9kqKgU8fg9g94OYJ906Dao+ZnUquIPvCBU4NGkT6tu3g5kbISy9S+PHHzY5V4By6cIgBawYQmxpLgGcAk5tPpm6Y5vFyRYlxaSybuYfEuDTcvdy458mKRFXTinC3W8rGTcQMHYojJQWPiAgiZs3Eq2xZs2OJuKzfNp1m/cJDOBwGIVEBtHumCn6BXmbHkr9RKaVSyrVkpcKXT8HBpc7tJs86JzW3ali4yJXEp8czeM1g9sTvwd3iziv1X+GhOx8yO1bBlZUKXz0NB75zbjceBi1H6meYC8k8fJiTffthO3UKq78/JadMwb9xI7NjFVh//xn2Uv2XeOROrXjoSk4dvMDK9/aRmZaNf7AXHfpXpWh4IbNjFViZR49y8pm+2E6edP4Mm/wO/k2amB1LxGWdOpTAyjl7c36Gte9XlWIR+hnmSlRKqZRyHZeNMpgO1TqZnUrEZf3vKINAr0AmN59MndA6ZscShwPWvgEbJzm3y/8HHnxPoz1dQMrGjcQMHfb/owxmz8KrTBmzYxV4mfZMRv40Mme0Z9cKXXmu9nMa7ekC9m+MYcOnv2uUgYvJTkggZuAg0rZtA6uVkBdfJLjr47qVUuQqNNrTtamUUinlGmK2w6edISUOfIv+OR9LPbNTibisv8/HMqPVDEoFlDI7lvyv/50XL7Sqc168wJJmpyqQDMMgYcHHxL31Fjgc+NauTclp72o+Fhfy93nxmpRswoSmE/D39Dc5WcHkcBj8/PkRdq/5n/lYniiPu4eKQldhZGVx5tXXSPrySwCCOj9G6EsvYfHQapYiV3LZvHj3l6HGPZoXzxWolFIpZb7/XbmqeEXosgiC9OZa5EoMw+DD/R8yZfsUDAwahDXg7eZvE+Cpn2Mu6cTWP1cQjQf/kD9XEK1ldqoCxbDZiB07lsTPFgEQ+NCDhI3WylWu6vvo73ll0ytk2DMoG1SW6a2mU9JfZe7tlJWezQ/v7+f4PufKVfXujaJWO61c5YoMw+DCBx9y9u23/1xBtAElJ0/GLVCrWYpcid3uYNPiw+xb/+cKog1Cad6lPG4emmbBTCqlVEqZxzBg/XhYN865Xa4NPPw+eOkeX5ErybJnMWbzGL45+g0Ane7qxIi6I3C3arUwl5Zw3Hlr8tnfwN0b7p8FlR80O1WBYE9K4tSQIaRt3gIWC8Wfe47CT/bUm2sXtz9+PwPXDORc+jkKexdmSosp1Chew+xYBUJyfDrLZu7hwulU3D2stOpRkbK1ipsdS/7FxTVriHluOEZaGp6RkUTMnoVnZKTZsURc1p61p9i0+HcMA8LKBtLumSr4+OvDKrOolFIpZQ5bOnzTH/Z94dxuMADuHgOaP0LkihIyEhiydgg7zu7AzeLGC3VfoHP5zmbHkmuVkQxf9IbD3zu3m78EzZ4HlSO5Jis6mpPP9CUrOhqLry8l355IoZYtzY4l1yg2NZZBawZx4MIBPKwevNbwNTqW6Wh2rHztzJFEls/eS0aKDd9ATzr0q0rx0vobOa/IOHiQk337kX3mDNbAQMKnTsWvvqbCELmaE/vP8/3cfWRl2Ako6k2HftUoXELzf5pBpZRKqdvvYpzzdpaYbWB1h/9MhppPmJ1KxGUdTTxK/9X9iUmJwd/Dn0nNJtGwZEOzY8n1cthh1SjYPN25XflhuG86ePiYmysfSt2yhVODh+BISsK9RBgRs2bhfdddZseS65RmS+PlTS/z44kfAehdpTcDawzEatFtFrfaoS1nWPPxQRzZBsVKFaJ936r4B2tC87wm+9w5Tg0YSPru3eDuTuiokQQ/+qjZsURc1oXTqSybuZvk+Aw8vd24p09lSlcqYnasAudau5nb8tt/xowZREZG4u3tTb169fjll1+uuu/cuXNp0qQJwcHBBAcH07p163/cX1zEmT0wt6WzkPIJhm5fq5AS+QebYjbRdXlXYlJiCPcP55P2n6iQyqusbtBmLHR811nI7/sc5v/HWdTLLZOwaDEnevfBkZSET7VqRC1apEIqj/L18GVS80n0qdIHgHl75zFs3TDSbGkmJ8s/DIfB5q+P8uP8AziyDe6oUYwHnq2pQiqPci9WjFL//YiADh0gO5vYUaOJGzcOw243O5qISypcwo+HR9QmrGwgWRl2lk3fzZ61J8ln43HyjVwvpRYtWsSwYcMYPXo0O3bsoFq1arRp04azZ89ecf9169bRuXNn1q5dy+bNm4mIiOCee+4hJiYmt6PKjTq4DD5oC8mnoOid0Hs1RDUxO5WISzIMg08OfEL/1f1JsaVQK6QWCzss5I6gO8yOJjerVnfo9hV4BzkL+rktIXav2anyPMNuJ27cOGJHj4bsbAL+8x9K/fcj3Itpyee8zGqxMqjmIN5s/CYeVg9Wn1hNj5U9iE2NNTtanmfLtLPyvX3sWHkcgFptS9O2T2U8vDSVQl5m9fKixNsTKTpoIAAXPvovJ/v1w56SYnIyEdfk4+/JfYNrUL5BKIYBGxcdZsOnv2O3O8yOJn+T67fv1atXjzp16jB9uvO2BofDQUREBAMHDmTEiBH/erzdbic4OJjp06fzxBOXj7zJzMwkMzMzZzs5OZmIiAjdvnc7GAb8NBV+fBUw4I4W8Mh88AkyN5eIi7I5bLy19S0W/74YgAfKPsDI+iPxcNMyz/nK+aOwsBOcPwwefvDQPCjf3uxUeZI9JYWYZ58ldf0GAIoNGUyRp5/WhOb5zK6zuxi8djAXMi5QzKcY77Z8l8pFK5sdK09KSchg2cw9xJ9MwepuoWW3CtxVL9TsWHKLJa9cyekRL2JkZOBVrhzhs2bhGa7VLEWuxDAMdq46weavjoIB4eWDadOnMt5++vs7t7nE7XtZWVls376d1q1b//8JrVZat27N5s2br+k10tLSsNlsFC5c+IpfHzduHIGBgTmPiIiIW5Jd/kV2pnNC8x9HAwbU6Q2Pf65CSuQqkjKT6PtjXxb/vhgLFp6t9SyvNXxNhVR+VKQM9F4FdzQHW6pzrr1NU5xFvlyzrFOnON65M6nrN2Dx9qbklCkUfeYZFVL5UPXi1VnYYSFlg8pyLv0cPVb2YGX0SrNj5Tlx0cksGbeN+JMp+BTy4IFhNVVI5VMBbdtSesEC3IsVI/PwYaIffZS0HTvMjiXikiwWCzXvKU27p6vg7uXGqYMJfDFhO4lxumXcVeRqKRUfH4/dbickJOSS50NCQoiNvbbh2S+88AIlSpS4pNj6Xy+++CJJSUk5j5MnT950bvkXqfHw3/tg1ydgcYP2b0OHSeCm5etFruR48nG6Lu/K1jNb8XH3YWqLqfSo3ENvrvMzn2BnUV+nN2A4C/xvBkB2ltnJ8oS0HTuIfuRRMg8fwb14cUovWEBA2zZmx5JcVNK/JAvaLaBpeFMy7ZkMXz+cWbtnaf6Pa3R4WxxfTdpBWnJWzlwqoXcEmh1LcpFPlcpELlmMV8UK2C9c4ET3HiR9843ZsURc1h3Vi/HQcOfceolxaXw+fhunDiWYHUu4TROd36i33nqLzz77jK+++gpvb+8r7uPl5UVAQMAlD8lFZw8450k5sRm8AuHxJVC3j9mpRFzW1jNb6bKsC9HJ0YT6hbKg3QJalGphdiy5Hdw8nIV9u4lgscKuj52Ffup5s5O5tKRvvuFE9x7YExLwrliRyCWL8amiW7kKAn9Pf95t8S5PVHRO1zBz10xe2PgCGdkZJidzXYZh8OuyY/wwbz92m4PSVYrw0PO1CCii1T8LAo/QUCI//phCd9+NYbNx+oURnH1nMoZDc+aIXEnR8EI8PKI2IVEBZKZl893UXezfqLmrzZarpVTRokVxc3MjLu7SFYji4uIIDf3n4cRvv/02b731Fj/88ANVq1bNzZhyrQ7/CO/fA4nHITjKeXtK2VZmpxJxWUt+X8Izq54hOSuZqsWq8mmHT7mrsFYLK3DqPeUs8L0C4MTPMLcFnD1odiqXYzgcnH1nMqdfGIFhs1Honnso/cnHePxttLXkb25WN4bXGc6rDV7F3eLOimMr6PV9L+LT482O5nKys+ysen8/v3x3DIBqrSNo37cqnt4auV6QWH19KTl1CkWefhqA8++9R8zgwTjSdGuSyJX4BXpx/9AalKsTgsNhsO6TQ2xafBiHQyNzzZKrpZSnpye1atVi9erVOc85HA5Wr15NgwYNrnrchAkTeP3111m5ciW1a9fOzYhyLQwDtsyGhY9AZjKUbgR91kAxvbkWuRK7w874X8YzZvMYso1s2ke154M2H1DUp6jZ0cQsZVtDr1UQHOks9t+/21n0CwCOtDRiBg/m/HvvAVDkmacpOWUyVh+N9iioHrrzIebcPYcAzwD2xO+h87LOHLpwyOxYLiM1KZOvJ+/k8LazWK0WWnQtT+OHy2G16rbwgshitVJ86BBKTBiPxcODi6t+JLprV2zXOF2KSEHj7unG3U9WpG7HKAB2rznJ8pl7yErPNjlZwZTrq+8tWrSI7t27M2fOHOrWrcuUKVNYvHgxBw8eJCQkhCeeeIKSJUsybtw4AMaPH8+oUaNYuHAhjRo1ynkdf39//P39//V81zrDu1wjuw2WD4ftHzq3a3SFDpPB3dPcXCIuKiUrheEbhrMpZhMAA6oP4KmqT2n+KHFKPQ+Lu8Hxn5y39LV9C+o+BQX4vw9bbCwn+/Yj88ABLB4ehI19g8B77zU7lriI48nHGbB6ANHJ0fi4+zC+yfgCfwt0/KmLLJuxh5SETLz83Gn3VBVK3hVsdixxEWk7dnJqwADsFy7gXqwY4TNn4FOlitmxRFzW4W1xrP7oAHabg8Il/OjQryoBRfWh2K1wrd1MrpdSANOnT2fixInExsZSvXp13n33XerVqwdA8+bNiYyMZP78+QBERkZy/Pjxy15j9OjRvPrqq/96LpVSt1B6AizuDsfWAxa453VoMKBAv3kS+SenLp5iwOoBHE06irebN280foM2kZqcWf4mOwuWDnXOMQVQuxe0G++cg6qASd+7l5P9+mE/F49bkSKET5+Gb40aZscSF5OUmcRz659jy5ktWLAwpNYQelbqWSDL/j92nWPVh7+RnWknKMSXDv2rElTc1+xY4mKyTsVwqm9fMg8fxuLlRYm3xhHQrp3ZsURcVlx0Mstn7SEtKQtvfw/aP1OFsLJBZsfK81yqlLqdVErdIuePwsJH4fwR8PSHh+bBXfplJnI1O+J2MGTtEBIyEyjmU4xpLadRqWgls2OJqzIM+HkarBoFGBDVDB79yLlqXwGRvGIFp0e8iJGZideddxIxayYeJUuaHUtclM1hY/wv41l0aBEA95W5j1ENRuHpVjBGbhuGwc4fTrD566NgQESFYNr0qYyXb8Ers+Xa2FNSOP3sc6SsXw9A0YEDKNqvX4Esc0WuRUpCBstm7iH+ZApWd+dt0eXrh5kdK09TKaVS6sYd2wCLukFGIgRGQOfPIFQrH4lczbdHv+XVn1/F5rBRoXAFprWcRoifJmeWa3BwOXzRG2ypUKQsdFkMRcqYnSpXGYZB/IyZxE+fDoB/8+aUePtt3Pz9TE4mecHCAwsZ/+t4HIaDmsVrMqXFFIK983eZa7c5WLfwIAc3O+cHqtysJE0eLYfVzaUX0RYXYNjtnJ34Nhf+vCMloH17wt4ci/Uqq5qLFHS2TDs/zv+NP3aeA6Bmm9LUv+8OLJqv74aolFIpdWO2fQjLnwNHNoTXgccWgn9xs1OJuCSH4eDdHe/y/r73AWhdqjVjG4/F10O3Ush1iN0LCx+D5FPgHQSdFkBUU7NT5QpHRgZnXnqZ5OXLASjcsyfFn3sWi5ubyckkL/kp5ieeW/8cKbYUSvqXZEarGZQJyp9lbnpKFitm7+XMkSQsVgtNHi1HlebhZseSPCZhyRJiXxsD2dl4V6tKxPTpuBcrZnYsEZdkOAy2fvsH21c6pxS6o3oxWvesiIeX/la5XiqlVEpdH4cdvn8Zts5ybld5FO6dBh76JEXkStJsaby48UXWnFwDQJ8qfRhQYwBWiz65lhtwMQ4WPQ6nfgWrO3SYBLV6mJ3qlrKdPcupAQPJ2LMH3N0Je3U0QQ8/bHYsyaOOJh5lwOoBnEo5hb+HPxObTaRxycZmx7qlLpxOZdnM3STHZ+Dp406bPpUoVbGI2bEkj0rdspVTgwfjSErCPSyMiFkz8S5f3uxYIi7r0JYzrPn4II5sg6IR/nToVxX/YL03vh4qpVRKXbuMZPj8STiyyrnd8hVo8pwmNBe5itjUWAauGcjBCwfxsHrwWsPX6Fimo9mxJK+zZcC3A2DvEud2/X5wzxtgzfufzGUcOMDJvv3Ijo3FLTCQku++i1+9umbHkjwuISOBIWuHsOPsDqwWK8/XeZ4u5bvkizlzju8/zw9z95GVYSegmA8d+lWlcJhucZWbkxUdzcln+pIVHY3F15eSEydQqFUrs2OJuKwzR5NYMXsP6Rdt+AZ40r5fVUIi1TFcK5VSKqWuTUK087aRcwfA3QcemA2V7jc7lYjL2ntuL4PWDiI+PZ7C3oWZ2mIq1YtXNzuW5BeGARvehrVvOLfL3QMPvQ/eeff32cXVq4kZ/jxGWhqeUVFEzJ6FZ+nSZseSfMJmtzFmyxi+PvI1AI/e+Sgj6o3Aw5o3JwA3DIM9a0/x05LDGAaUKBdEu6er4O2fN78fcT32pCRihg4l9efNYLFQ/NlhFO7VK1+UuSK5ITk+nWUz93DhdCpuHlZada9AudqaO/ZaqJRSKfXvTmyBz7pA2nkoFOacP6pkTbNTibislcdW8spPr5Bpz6RsUFmmt5pOSX+tFia5YP9X8FVfyE6H4hWdC04E560ixzAMzs+bx7l3JoNh4NewASUnT8YtMNDsaJLPGIbB/P3zmbx9MgYG9cLqManZJAK98tZ/a3a7g42LDrN/QwwAFRqG0azLXbi567ZwubUMm43YN98k8dPPAAh84AFCX3sVq2fBWM1S5HplpWfzwwf7Ob73PAB1O0ZRu32kytx/oVJKpdQ/2/0ZfDsQ7FkQVs35hieghNmpRFySYRjM3j2bmbtnAtA0vCkTmk7Az0O3UkguitkBn3aGlFjwLQqPfQKl6pud6po4srKIHTWapK+/BiCo82OEvvQSFg+N9pDcs/bEWl7Y+ALp2elEBkQyvdV0SgfkjTI3I9XG93P3cepgAlig4QNlqX53hN7wSK668PEnxL35Jjgc+NSqRfj0abgH5+/VLEVulMNh8POXR9j940kAytUJoWW38rh75v1pFnKLSimVUlfmcMCa12HTO87tCvfCA3PAU6uFiVxJRnYGI38aycrolQA8UfEJhtUahls+mOdH8oDk0/DpY3BmN7h5OhegqPaY2an+UfaFC5waOIj07dvBaiXkpZco3PVxs2NJAXHowiEGrBlAbGosAZ4BvNP8HeqF1TM71j9KjEtj2cw9JMal4eHlxt29KhFVtajZsaSASNm4iZihQ3GkpOARHk7E7Fl4lS1rdiwRl/XbptOsX3gIh8MgJCqAds9UwS/Qy+xYLkmllEqpy2WlwpdPwcGlzu0mz0GLl8GqYeEiV3Iu7RyD1w5mb/xe3C3uvFz/ZR6+U6uFyW2WlQpfPQ0HvnNuNx4GLUe65M/uzMOHOdm3H7ZTp7D6+1NyyhT8GzcyO5YUMPHp8QxeM5g98Xtwt7jzUv2XeOTOR8yOdUWnDl5g5Xv7yEzLxr+wFx36VaNouL/ZsaSAyTxyxPmz++RJ58/uye/g36SJ2bFEXNapQwmsnLPX+bM72IsO/atSNLyQ2bFcjkoplVKXSoqBTztB7N4/P22fDtU6mZ1KxGUdvHCQAasHEJcWR6BXIJObT6ZOaB2zY0lB5XA4Jz/fOMm5Xf4/8OB74Ok6t5CmbNhAzLBnnZ+2R0Q4P20vU8bsWFJAZdozGfnTSFYcWwFA1wpdea72cy41ynX/xhg2fPp7zqft7ftWxTdAc/qIObITEjg1cCDp2/4c5TpiBMHduuoWUpGr+N9Rru5ebtzzZEWiqhUzO5ZLUSmlUur/xWz/c16SOPAr5pzQPEJLcYtczZoTaxixcUTOvCQzWs2gVEAps2OJwO5F8O0A53yAoVWg8yIINHeyfcMwSFiwgLi3xoPDgW/t2pSc9q7mJRHTGYbBnD1zmLFrBgCNSzZmYtOJ+HuaOxLJ4TD46fPD7FlzCvhzXpInyuPu4TqFmRRMRlYWZ159jaQvvwQg6LFOhL78suYDFLmKv88H2OD+MtS4p5TK3D+plFIp5bTvS/i6L2RnQPFK0OUzCNKba5ErMQyDD/d/yJTtUzAwqB9Wn7ebvZ3nVnCSfO7E1j9XTo0H/xDo/CmUrGVKFMNmI/aNsSQuWgRA4EMPEjZ6NBat4CQuZGX0Sl7Z9P8rp05rOY3wQuGmZMlKz+b7efs5sd+5glO9e6Oo1U4rOInrMAyDCx98wNm3J4Fh4NugPuFTpmjlVJGrsNsdbFp8mH3rnSunlm8YRnOtnAqolFIpZRiwfjysG+fcvrMtPDQPvHSvq8iVZNmzGLN5DN8c/QaATnd14oW6L+Bh1aeD4oISjjsnQD/7G7h7w/2zoPKDtzWCPSmJU0OGkLZ5C1gsFH/uOQo/2VNvrsUl7Yvfx6A1gziXfo5gr2CmtpxKjeI1bmuG5Ph0ls3cw4XTqbh7WGnVoyJlaxW/rRlErtXFNWuIeW44RloanpGRRMyehWdkpNmxRFzWnrWn2LT4dwwDwsoG0u6ZKvj4F+wP6VRKFeRSypYO3/SHfV84txsMgLvHgAvNoyDiSi5kXGDo2qHsOLsDN4sbL9R9gc7lO5sdS+SfZSTDF73g8A/O7eYvQrMX4DaUQlnR0Zx8pi9Z0dFYfX0p8fbbFGrZItfPK3IzYlNjGbRmEAcuHMDD6sGrDV/l3jL33pZznz6SyIrZe8lIseEb6En7vlUJiSygf6dKnpFx8CAn+/Yj+8wZrIGBhE+dil99117NUsRMJ/af5/u5+8jKsBNQ1JsO/apRuITrzP95u6mUKqil1MVY520dMdvB6g7/mQw1nzA7lYjLOpJwhAFrBhCTEoO/hz+Tmk2iYcmGZscSuTYOO6waBZunO7crPwT3zQAPn1w7ZeqWLZwaPARHUhLuJcKImDUL77vuyrXzidxKabY0Xt70Mj+e+BGA3lV6M7DGQKyW3LvN4uCWM6z9+CCObINipQrRvm9V/IO1fLjkDdnnznFqwEDSd+8Gd3dCR40k+NFHzY4l4rIunEll2YzdJMdn4Ontxj19KlO6UhGzY5lCpVRBLKXO7HHezpEcAz7B8OgCiNJyriJXsylmE8PXDyfFlkK4fzgzWs3gjqA7zI4lcv22fwTLhoEj2zm/1GMLoVDoLT9NwqLFxL7+OmRn41OtGuEzpuNetOgtP49IbnIYDqbvnM7cvXMBaFWqFW82fhNfD99beh7DYbDlmz/Y8f1xAO6oUYzWPSri4aWR65K3ODIzOfPyKyQvXQpA4e7dKf78cCxu+m9Z5ErSU7JYOWcfpw8nYrFA40fLUaV5eIGb4kClVEErpQ4shS/7gC0NipSDLougiJbiFrkSwzBYeHAhE36dgMNwUCukFlOaTyHIO8jsaCI37tgGWNQNMhIhoCR0/gzCqt6SlzbsduLGjyfhvwsACPjPfwgb+wZWL432kLzru6PfMfrn0dgcNsoXLs+0ltMI9bs1ZW5WRjY/fvgbx3bHA1CrbWnq3XsHFmvBekMi+YdhGJyfPZtzU98FwK9ZU0pOmoSbv7mrWYq4Knu2g3ULD3Hw5zMAVGpakiadyuHmVnAmQFcpVVBKKcOAn6bAj68BBtzRAh6ZDz5B5uYScVE2h41xW8ex5PclADxQ9gFG1h+Jh5smNJd84PxRWNgJzh8GDz94aC6U73BTL2lPSSFm2DBSN2wEoNiQwRR5+ukC92mf5E+7zu5i8NrBXMi4QFGfokxrOY3KRSvf1GtevJDB8ll7iD+ZgtXdQstuFbir3q0fuShihuSVKzk94kWMjAy8ypUjfNYsPMNLmh1LxCUZhsGuVSf5+asjYEB4+WDa9KmMt1/BeN+hUqoglFLZmfDdENi90Lldpze0fQv05lrkipIyk3h2/bNsPbMVCxaerf0sT1R8Qm+uJX9JT4AlPeCPdYAFWo+GRkNuaAL0rFOnONW3L5mHj2Dx9qbEW28R0LbNLQ4sYq6YlBgGrB7AkcQjeLl58UbjN2gb2faGXivuWDLLZ+0hLTkLn0IetO9bldA7Am9xYhFzpe/dx6n+/ck+exa3woUJnz4N35o1zY4l4rKO7Ynnh/f3k51pJyjElw79qhIUcmtvGXdFKqXyeymVGg+LusKJzWBxg3bjoW4fs1OJuKzjyccZsHoA0cnR+Lr7Mr7peJpHNDc7lkjusNtg5Qj4dZ5zu1oX6DgF3K/9dru07ds5NWAg9oQE3IsXJ3zGDHyq3NwIEhFXlZKVwgsbX2DDqQ0A9KvWj2eqPXNdH1oc/jWO1f89gN3moHAJPzr0r0pAkdxbdEDETLa4OE717UfGb79h8fAg7I3XCbzvPrNjibis+FMXWTZjDykJmXj5utP2qcqEly9sdqxcpVIqP5dSZw84b89IPA5eAc7b9cq2MjuViMvaemYrw9YNIzkrmTC/MKa1nMZdhbVamBQAW9+DlS+A4XBOgH73GIhs/K+HJX79NbEjR2HYbHhXrEj4rJl4hITchsAi5rE77Lyz/R3++9t/AWgX2Y4xjcbg7e79j8elJmaybXk0+zbEABBZpQh396qEp7d7rmcWMZMjLY3TL4zg4qpVABR56imKDRmMxVpw5swRuR6pSZmsmL2XuGPJWK0Wmna+k0pN8u/tryql8mspdXgVLOkJWRchOBK6LIZienMtcjVLfl/Cm1veJNvIpmqxqkxtMZWiPlotTAqQI6udt/NlJju3o5pC85egdIPLdjUcDs5NnsL5uc5VyQrdcw8l3hqH1Tf/DzEX+csXv3/BG1vecP7eKFqVqS2v/HsjNSmTHSuPs3/jaezZDgCqt46gwYNlsWpCcykgDIeDc1Pf5fycOQAUurs1JcaP1+8NkavIttlZ89+DHP41DoCqLcNp9HC5fPl7Q6VUfiulDAO2zobvX3J+4l26EXT6GHzz95A/kRtld9h5e9vbfHzgYwDaR7VnTKMxeLlptTApgJJOwcZJsGMBOGzO5+5oDs1fxIioR8a+/SSvXMHFld9ji3GO9ijyzNMUGzRIn3hLgfRr7K8MXTeUpMwkfNx9aB7enDaRbWhUshH2VAs7vz/Bvo0x2G3OMiqsTCB1OkYRkc9vxRC5mqRvv+XMy69g2Gx4VaxAxMyZeIRqgn+RKzEMg+0rotn67TEASlUqQpvelfD0yV8jbF2qlJoxYwYTJ04kNjaWatWqMW3aNOrWrXvV/ZcsWcLIkSOJjo6mXLlyjB8/nvbt21/TufJlKWW3wfLhsP1D53aNrtBhMrh7mptLxAUlZSbxR9IfzN0zl40xztXCBtYYSJ8qfTShuUjiCdg4CWPHx2Sct3DxpDfJZwpjS7Tl7GL18yN09CgC773XxKAi5juRfIKh64bye8LvAPhkFaJObFvKxzbAancDIPSOAOr+5w7CKwTrd4wUeGk7dnJqwADsFy7gVqwooa+MxKdyJdxLlND1IXIFR7afZfX838j+ay7CflUJKJp/5iJ0mVJq0aJFPPHEE8yePZt69eoxZcoUlixZwqFDhyhevPhl+//88880bdqUcePG8Z///IeFCxcyfvx4duzYQeXK/z7Ban4qpQzDID05Hq8ve+J2fCMGFmwtXyW7Xv8bWkVJJD9JybrIH0lH+SPpD/5IOsqxpKP8kXyU+PT4nH283LwZXX8MrUrdbWJSEddgGAa2Q4dI/f570lYuIzvmTM7XLG4O/O4MxPfBJ/C6tztWn/zzB5HIzTAMg90n97J1xUGsB4rg7nCucBzrf4y9kWspV6kkrUrfTf2whni66cNCkezTpzk7oD+2I0dynrP4+uJxRxk8ypbBs0xZPMqUwaNMGdxCQ1VWSYEXf+IiP763n/TkLLz8PGjVuyIhZQLx8XDL89eHy5RS9erVo06dOkyfPh0Ah8NBREQEAwcOZMSIEZft36lTJ1JTU1m6dGnOc/Xr16d69erMnj37sv0zMzPJzMzM2U5OTiYiIiJflFLfTZzCub0ZWC0GhgGZeODAzexYIuayOAD7n//3KgwrGG4YDh8w8tcwWJEbVSgrFd/s//99abdYSfL2x8vPRqhPAlar88+Bc0YgGejNtQiAgRuZmXdg4CyjDI8YjoWsYmvIHpI87Tn7edkt3JHujYeRt99AiNwKnlkGLTZnUDrGTpFEB25X+ZMt0wPOFXYjKcCCI4+/+Ra5GXZrIMmFe5PtGQFGNh5pn9P1/Zn4eubt9zHXWkrl6neZlZXF9u3befHFF3Oes1qttG7dms2bN1/xmM2bNzNs2LBLnmvTpg1ff/31FfcfN24cr7322i3L7EqSj8aR7qsRHiIicvMu/vn4OxtwJOs2hxHJY4p7HKau/2eU8tyBJRscMbDHy5Mf/Hz53s+Xs+7uHPBPNzumiMvY9h8AK252C6EJEB5vEHEOIuINwuMNwi6Alw3C4+yEx5mdVsRs8dit7/BbhSc4V6wGDq//kJlqy/Ol1LXK1e8yPj4eu91OyN+WkQ4JCeHgwYNXPCY2NvaK+8fGxl5x/xdffPGSEuuvkVL5QekW1XHbsBLDrxhYC8Z/kCL/xs3qhp+7H74efrjruhC5ZhZ/fzzuuAOr5z+Mgkq7gDX+EJCv1kARuSnBQRmUDM3CYnkQGw/mPF/xz8cgw2BPRhy/ZZ7D0LUjcrniwP8sFh4DnM524B2fjk9cOp5JmVc7UqRA8TdWY8vMoFDR8wQFdTQ7zm2T59/ReXl54eWVP1fTatypE3TqZHYMEREpMCKBmmaHEMlz6v75EBERkeuTq+s8Fy1aFDc3N+LiLh2TGRcXR+hVlggNDQ29rv1FRERERERERCTvydVSytPTk1q1arF69eqc5xwOB6tXr6ZBgwZXPKZBgwaX7A+watWqq+4vIiIiIiIiIiJ5T67fvjds2DC6d+9O7dq1qVu3LlOmTCE1NZWePXsC8MQTT1CyZEnGjRsHwODBg2nWrBmTJk2iQ4cOfPbZZ2zbto333nsvt6OKiIiIiIiIiMhtkuulVKdOnTh37hyjRo0iNjaW6tWrs3LlypzJzE+cOIHV+v8Dtho2bMjChQt55ZVXeOmllyhXrhxff/01lStXzu2oIiIiIiIiIiJym1gMw8hXy4QkJycTGBhIUlISAQEBZscRERERERERESlQrrWbyfOr7/3dXx1bcnKyyUlERERERERERAqevzqZfxsHle9KqYsXLwIQERFhchIRERERERERkYLr4sWLBAYGXvXr+e72PYfDwenTpylUqBAWi8XsODctOTmZiIgITp48qdsRRa6RrhuRG6NrR+TG6NoRuTG6dkRuTF64dgzD4OLFi5QoUeKSecT/Lt+NlLJarYSHh5sd45YLCAhw2f/YRFyVrhuRG6NrR+TG6NoRuTG6dkRujKtfO/80QuovV6+rREREREREREREcolKKRERERERERERue1USrk4Ly8vRo8ejZeXl9lRRPIMXTciN0bXjsiN0bUjcmN07YjcmPx07eS7ic5FRERERERERMT1aaSUiIiIiIiIiIjcdiqlRERERERERETktlMpJSIiIiIiIiIit51KKRERERERERERue1USomIiIiIiIiIyG2nUsqFzZgxg8jISLy9valXrx6//PKL2ZFEXMq4ceOoU6cOhQoVonjx4tx///0cOnTokn0yMjLo378/RYoUwd/fn4ceeoi4uDiTEou4nrfeeguLxcKQIUNyntN1I3JlMTExdO3alSJFiuDj40OVKlXYtm1bztcNw2DUqFGEhYXh4+ND69atOXz4sImJRcxnt9sZOXIkUVFR+Pj4UKZMGV5//XX+dxF4XTsiThs2bKBjx46UKFECi8XC119/fcnXr+VauXDhAo8//jgBAQEEBQXRq1cvUlJSbuN3cX1USrmoRYsWMWzYMEaPHs2OHTuoVq0abdq04ezZs2ZHE3EZ69evp3///mzZsoVVq1Zhs9m45557SE1Nzdln6NChfPfddyxZsoT169dz+vRpHnzwQRNTi7iOX3/9lTlz5lC1atVLntd1I3K5hIQEGjVqhIeHBytWrOC3335j0qRJBAcH5+wzYcIE3n33XWbPns3WrVvx8/OjTZs2ZGRkmJhcxFzjx49n1qxZTJ8+nQMHDjB+/HgmTJjAtGnTcvbRtSPilJqaSrVq1ZgxY8YVv34t18rjjz/O/v37WbVqFUuXLmXDhg089dRTt+tbuH6GuKS6desa/fv3z9m22+1GiRIljHHjxpmYSsS1nT171gCM9evXG4ZhGImJiYaHh4exZMmSnH0OHDhgAMbmzZvNiiniEi5evGiUK1fOWLVqldGsWTNj8ODBhmHouhG5mhdeeMFo3LjxVb/ucDiM0NBQY+LEiTnPJSYmGl5eXsann356OyKKuKQOHToYTz755CXPPfjgg8bjjz9uGIauHZGrAYyvvvoqZ/tarpXffvvNAIxff/01Z58VK1YYFovFiImJuW3Zr4dGSrmgrKwstm/fTuvWrXOes1qttG7dms2bN5uYTMS1JSUlAVC4cGEAtm/fjs1mu+RaKl++PKVKldK1JAVe//796dChwyXXB+i6Ebmab7/9ltq1a/PII49QvHhxatSowdy5c3O+fuzYMWJjYy+5dgIDA6lXr56uHSnQGjZsyOrVq/n9998B2L17N5s2baJdu3aArh2Ra3Ut18rmzZsJCgqidu3aOfu0bt0aq9XK1q1bb3vma+FudgC5XHx8PHa7nZCQkEueDwkJ4eDBgyalEnFtDoeDIUOG0KhRIypXrgxAbGwsnp6eBAUFXbJvSEgIsbGxJqQUcQ2fffYZO3bs4Ndff73sa7puRK7sjz/+YNasWQwbNoyXXnqJX3/9lUGDBuHp6Un37t1zro8r/f2ma0cKshEjRpCcnEz58uVxc3PDbrczduxYHn/8cQBdOyLX6FquldjYWIoXL37J193d3SlcuLDLXk8qpUQkX+jfvz/79u1j06ZNZkcRcWknT55k8ODBrFq1Cm9vb7PjiOQZDoeD2rVr8+abbwJQo0YN9u3bx+zZs+nevbvJ6URc1+LFi/nkk09YuHAhlSpVYteuXQwZMoQSJUro2hERTXTuiooWLYqbm9tlKx3FxcURGhpqUioR1zVgwACWLl3K2rVrCQ8Pz3k+NDSUrKwsEhMTL9lf15IUZNu3b+fs2bPUrFkTd3d33N3dWb9+Pe+++y7u7u6EhITouhG5grCwMCpWrHjJcxUqVODEiRMAOdeH/n4TudTw4cMZMWIEjz32GFWqVKFbt24MHTqUcePGAbp2RK7VtVwroaGhly2Olp2dzYULF1z2elIp5YI8PT2pVasWq1evznnO4XCwevVqGjRoYGIyEddiGAYDBgzgq6++Ys2aNURFRV3y9Vq1auHh4XHJtXTo0CFOnDiha0kKrFatWrF371527dqV86hduzaPP/54zv+v60bkco0aNeLQoUOXPPf7779TunRpAKKioggNDb3k2klOTmbr1q26dqRAS0tLw2q99G2nm5sbDocD0LUjcq2u5Vpp0KABiYmJbN++PWefNWvW4HA4qFev3m3PfC10+56LGjZsGN27d6d27drUrVuXKVOmkJqaSs+ePc2OJuIy+vfvz8KFC/nmm28oVKhQzn3SgYGB+Pj4EBgYSK9evRg2bBiFCxcmICCAgQMH0qBBA+rXr29yehFzFCpUKGfetb/4+flRpEiRnOd13YhcbujQoTRs2JA333yTRx99lF9++YX33nuP9957DwCLxcKQIUN44403KFeuHFFRUYwcOZISJUpw//33mxtexEQdO3Zk7NixlCpVikqVKrFz507eeecdnnzySUDXjsj/SklJ4ciRIznbx44dY9euXRQuXJhSpUr967VSoUIF2rZtS58+fZg9ezY2m40BAwbw2GOPUaJECZO+q39h9vJ/cnXTpk0zSpUqZXh6ehp169Y1tmzZYnYkEZcCXPHx4Ycf5uyTnp5u9OvXzwgODjZ8fX2NBx54wDhz5ox5oUVcULNmzYzBgwfnbOu6Ebmy7777zqhcubLh5eVllC9f3njvvfcu+brD4TBGjhxphISEGF5eXkarVq2MQ4cOmZRWxDUkJycbgwcPNkqVKmV4e3sbd9xxh/Hyyy8bmZmZOfvo2hFxWrt27RXf33Tv3t0wjGu7Vs6fP2907tzZ8Pf3NwICAoyePXsaFy9eNOG7uTYWwzAMk/owEREREREREREpoDSnlIiIiIiIiIiI3HYqpURERERERERE5LZTKSUiIiIiIiIiIredSikREREREREREbntVEqJiIiIiIiIiMhtp1JKRERERERERERuO5VSIiIiIiIiIiJy26mUEhERERERERGR206llIiIiIiIiIiI3HYqpURERERERERE5LZTKSUiIiIiIiIiIredSikREREREREREbntVEqJiIiIiIiIiMhtp1JKRERERERERERuO5VSIiIiIiIiIiJy26mUEhERERERERGR206llIiIiIiIiIiI3HYqpURERESuwfz587FYLERHR+c817x5c5o3b25aJjNERkbSo0cPs2OIiIhIPqBSSkRERPKlvXv38vDDD1O6dGm8vb0pWbIkd999N9OmTTM72k2Ljo7GYrFc8ggICKB69epMnz4du91udkQRERGRf+VudgARERGRW+3nn3+mRYsWlCpVij59+hAaGsrJkyfZsmULU6dOZeDAgbfkPD/88MMteZ0b1blzZ9q3bw9AUlISy5cvZ+DAgRw/fpyJEyfmyjkPHTqE1arPNUVEROTmqZQSERGRfGfs2LEEBgby66+/EhQUdMnXzp49e8vO4+npecte60bUrFmTrl275mz369ePevXqsXDhwlwrpby8vHLldUVERKTg0cdcIiIiku8cPXqUSpUqXVZIARQvXvySbYvFwoABA/jkk0+466678Pb2platWmzYsOFfz/P3OaXWrVuHxWJh8eLFjB07lvDwcLy9vWnVqhVHjhy57PitW7fStm1bAgMD8fX1pVmzZvz000/X/f3+7/cSEhKCu/ulnzt+8803dOjQgRIlSuDl5UWZMmV4/fXXL7vN7/Dhwzz00EOEhobi7e1NeHg4jz32GElJSTn7/H1OKZvNxmuvvUa5cuXw9vamSJEiNG7cmFWrVt3w9yEiIiIFg0ZKiYiISL5TunRpNm/ezL59+6hcufK/7r9+/XoWLVrEoEGD8PLyYubMmbRt25Zffvnlmo7/u7feegur1cpzzz1HUlISEyZM4PHHH2fr1q05+6xZs4Z27dpRq1YtRo8ejdVq5cMPP6Rly5Zs3LiRunXr/ut50tLSiI+PByA5OZkVK1awcuVKXnzxxUv2mz9/Pv7+/gwbNgx/f3/WrFnDqFGjSE5OzhlRlZWVRZs2bcjMzGTgwIGEhoYSExPD0qVLSUxMJDAw8IoZXn31VcaNG0fv3r2pW7cuycnJbNu2jR07dnD33Xdf97+diIiIFBwWwzAMs0OIiIiI3EqrVq2iXbt2ANStW5cmTZrQqlUrWrRogYeHxyX7WiwWALZt20atWrUAOHHiBHfddRft2rXjyy+/BJzFTs+ePTl27BiRkZEAOaOk1q1bl/N/W7RoQYUKFdi1a1fO7X3vvvsugwcPZu/evVSuXBnDMLjrrru44447WLFiRU6G9PR0KlWqRNmyZf9xvqro6GiioqKu+LW+ffsyY8aMnNf863V9fHwu2e+ZZ55hwYIFXLhwAS8vL3bt2kWNGjVYsmQJDz/88FXPHRkZSfPmzZk/fz4A1atXJzw8nKVLl171GBEREZEr0e17IiIiku/cfffdbN68mXvvvZfdu3czYcIE2rRpQ8mSJfn2228v279BgwY5hRRAqVKluO+++/j+++9vaCW7nj17XjLfVJMmTQD4448/ANi1axeHDx+mS5cunD9/nvj4eOLj40lNTaVVq1Zs2LABh8Pxr+d56qmnWLVqFatWreKLL76gf//+zJkzh2HDhl2y3/8WUhcvXiQ+Pp4mTZqQlpbGwYMHAXJGQn3//fekpaVd8/caFBTE/v37OXz48DUfIyIiIgK6fU9ERETyqTp16vDll1+SlZXF7t27+eqrr5g8eTIPP/wwu3btomLFijn7litX7rLj77zzTtLS0jh37hyhoaHXde5SpUpdsh0cHAxAQkICQE6B071796u+RlJSUs5xV1OuXDlat26ds/3ggw9isViYMmUKTz75JFWqVAFg//79vPLKK6xZs4bk5OTLzgMQFRXFsGHDeOedd/jkk09o0qQJ9957L127dr3qrXsAY8aM4b777uPOO++kcuXKtG3blm7dulG1atV/zC4iIiKikVIiIiKSr3l6elKnTh3efPNNZs2ahc1mY8mSJbl6Tjc3tys+/9esCX+Ngpo4cWLOSKe/P/z9/W/o3K1atQLImag9MTGRZs2asXv3bsaMGcN3333HqlWrGD9+/CVZACZNmsSePXt46aWXSE9PZ9CgQVSqVIlTp05d9XxNmzbl6NGjfPDBB1SuXJl58+ZRs2ZN5s2bd0P5RUREpODQSCkREREpMGrXrg3AmTNnLnn+Sree/f777/j6+lKsWLFbnqNMmTIABAQEXDLS6VbIzs4GICUlBXDOc3X+/Hm+/PJLmjZtmrPfsWPHrnh8lSpVqFKlCq+88go///wzjRo1Yvbs2bzxxhtXPWfhwoXp2bMnPXv2JCUlhaZNm/Lqq6/Su3fvW/idiYiISH6jkVIiIiKS76xdu5YrreWyfPlyAO66665Lnt+8eTM7duzI2T558iTffPMN99xzz1VHPd2MWrVqUaZMGd5+++2c8uh/nTt37oZf+7vvvgOgWrVqwP+P2vrff4+srCxmzpx5yXHJyck5hdZfqlSpgtVqJTMz86rnO3/+/CXb/v7+lC1b9h+PEREREQGNlBIREZF8aODAgaSlpfHAAw9Qvnx5srKy+Pnnn1m0aBGRkZH07Nnzkv0rV65MmzZtGDRoEF5eXjmFzWuvvZYr+axWK/PmzaNdu3ZUqlSJnj17UrJkSWJiYli7di0BAQE55dI/2bFjBx9//DHgnMB89erVfPHFFzRs2JB77rkHgIYNGxIcHEz37t0ZNGgQFouFBQsWXFbarVmzhgEDBvDII49w5513kp2dzYIFC3Bzc+Ohhx66aoaKFSvSvHlzatWqReHChdm2bRuff/45AwYMuIl/IRERESkIVEqJiIhIvvP222+zZMkSli9fznvvvUdWVhalSpWiX79+vPLKKwQFBV2yf7NmzWjQoAGvvfYaJ06coGLFisyfPz9XJ+tu3rw5mzdv5vXXX2f69OmkpKQQGhpKvXr1ePrpp6/pNT799FM+/fRTANzd3SlVqhTDhw9n1KhRWK3OAfFFihRh6dKlPPvss7zyyisEBwfTtWtXWrVqRZs2bXJeq1q1arRp04bvvvuOmJgYfH19qVatGitWrKB+/fpXzTBo0CC+/fZbfvjhBzIzMyldujRvvPEGw4cPv4l/HRERESkILMaVxraLiIiIFBAWi4X+/fszffp0s6OIiIiIFCiaU0pERERERERERG47lVIiIiIiIiIiInLbqZQSEREREREREZHbThOdi4iISIGm6TVFREREzKGRUiIiIiIiIiIictvlu5FSDoeD06dPU6hQISwWi9lxREREREREREQKFMMwuHjxIiVKlMBqvfp4qHxXSp0+fZqIiAizY4iIiIiIiIiIFGgnT54kPDz8ql/Pd6VUoUKFAOc3HhAQYHIaEREREREREZGCJTk5mYiIiJyO5mryXSn11y17AQEBKqVEREREREREREzyb9MqaaJzERERERERERG57VRKiYiIiIiIiIjIbZerpdSGDRvo2LEjJUqUwGKx8PXXX//rMevWraNmzZp4eXlRtmxZ5s+fn5sRRURERERERETEBLlaSqWmplKtWjVmzJhxTfsfO3aMDh060KJFC3bt2sWQIUPo3bs333//fW7GdGmGYZgdQURERERERERyWUF8/5+rE523a9eOdu3aXfP+s2fPJioqikmTJgFQoUIFNm3axOTJk2nTps0Vj8nMzCQzMzNnOzk5+eZCu5DYpAwGfrqDNx+oQrmQf56xXkRERERERETyJrvNwQ/v7+fOeiGUqVHc7Di3jUvNKbV582Zat259yXNt2rRh8+bNVz1m3LhxBAYG5jwiIiJyO+ZtM2bpfn6NTuCx97ZwMDb/lG0iIiIiIiIi4pSdZWf57D38sescqz86QEaqzexIt41LlVKxsbGEhIRc8lxISAjJycmkp6df8ZgXX3yRpKSknMfJkydvR9TbYuz9VahcMoDzqVl0fm8L+2KSzI4kIiIiIiIiIreILcvOspl7OLH/Au6eVto/UwVvPw+zY902LlVK3QgvLy8CAgIueeQXwX6efNK7PtUigkhIs9Fl7hZ2n0w0O5aIiIiIiIiI3KSsjGyWTtvNqYMJuHu50XFgNcLLFzY71m3lUqVUaGgocXFxlzwXFxdHQEAAPj4+JqUyV6CPBx/3qkut0sEkZ2TTdd5Wth9PMDuWiIiIiIiIiNygrHRnIXX6cCKe3m7cO6g6JcoFmx3rtnOpUqpBgwasXr36kudWrVpFgwYNTErkGgp5e/DfJ+tSN6owFzOzeeL9rfxy7ILZsURERERERETkOmWm2fhm6i7OHE3Cy9edewfXIKxMoNmxTJGrpVRKSgq7du1i165dABw7doxdu3Zx4sQJwDkf1BNPPJGz/zPPPMMff/zB888/z8GDB5k5cyaLFy9m6NChuRkzT/Dzcmd+zzo0KluE1Cw73T/4hZ+PxJsdS0RERERERESuUUaqjW+m7OJsdDJefu7cN6QGIVH5Zxqi65WrpdS2bduoUaMGNWrUAGDYsGHUqFGDUaNGAXDmzJmcggogKiqKZcuWsWrVKqpVq8akSZOYN28ebdq0yc2YeYavpzvvd69D0zuLkW6z03P+r2z4/ZzZsURERERERETkX6RfzOLryTs5d+Ii3v4e3D+0JsVKFTI7lqkshmEYZoe4lZKTkwkMDCQpKSlfTXr+vzJsdvp/soPVB8/i6WZldreatCwf8u8HioiIiIiIiMhtl5acxTdTdnLhdCo+AZ7cN6Q6RUr4mx0r11xrN+NSc0rJtfH2cGNW11q0qRRClt3B0wu288P+WLNjiYiIiIiIiMjfpCZm8vU7O7hwOhW/QE8eGFYjXxdS10OlVB7l6W5lepeadKgahs1u0O+THSzbc8bsWCIiIiIiIiLyp4sXMvhq0g4SYtPwD/bi/mdrEhzqZ3Ysl6FSKg/zcLMytVN1HqhRkmyHwcBPd7B420mzY4mIiIiIiIgUeIlxaXz59naSzqVTqIg3Dzxbk6DivmbHcikqpfI4dzcrbz9SjU61I3AY8Pzne/hg0zGzY4mIiIiIiIgUWPGnUvhy0g5SLmQSFOLLA8/WJKCoj9mxXI5KqXzAzWrhrYeq0KdJFABjlv7G5FW/k8/msBcRERERERFxebF/JPH1OztIT86iaIQ/Dzxbk0KFvc2O5ZJUSuUTFouFl9pX4Ll77gRg6urDjFn6Gw6HiikRERERERGR2+Hkbxf4ZspOMtOyCSsTyP1Da+Ab4Gl2LJelUiofsVgsDGhZjtfurQTAhz9F8/wXe8i2O0xOJiIiIiIiIpK//bHzHEtn7iY7y0FExcJ0HFQdL18Ps2O5NHezA8it171hJP5e7jz/xR4+336KlIxspnaujpe7m9nRRERERERERPKdg5vPsOa/BzAMKFOzGHf3rISbh8YB/Rv9C+VTD9UKZ+bjNfF0s7Jyfyy9P9pGWla22bFERERERERE8pXda06y+iNnIVWhYRj39K6sQuoa6V8pH2tTKZQPe9bB19ONjYfj6TpvK0lpNrNjiYiIiIiIiOR5hmHw67JjbFp8GIBqrSJo0a08VqvF5GR5h0qpfK5R2aJ83LsegT4e7DiRSKf3NnPuYqbZsURERERERETyLMMw+OnzI/zy3TEA6naMotHDZbFYVEhdD5VSBUDNUsEsero+xQp5cTD2Io/O2czJC2lmxxIRERERERHJcxx2B2sWHGT36pMANOlUjjodolRI3QCVUgVE+dAAljzdgJJBPhyLT+XBWT+z/3SS2bFERERERERE8gxbpp3ls/dy8OczWCzQqkcFqraIMDtWnqVSqgCJLOrHl/0aUj60EOcuZtJpzhZ+PhJvdiwRERERERERl5eeksU3U3ZyfO953DystHumCuXrh5kdK09TKVXAhAR4s+jpBtSLKkxKZjbdP/yF73afNjuWiIiIiIiIiMtKjk/ny4k7iDuWjJefO/cNqUFUtWJmx8rzVEoVQIE+Hnz0ZF3aVwnFZjcY+OlOPth0zOxYIiIiIiIiIi4n/tRFvpiwncS4NPwLe/Hgc7UIKxNodqx8QaVUAeXt4ca0zjXp3qA0AGOW/sa4FQdwOAyTk4mIiIiIiIi4hlOHEvjq7R2kJWdRpKQfDw2vTeEwP7Nj5RsqpQowN6uFV++txPA2dwEwZ/0fPLdkNza7w+RkIiIiIiIiIuY6vC2O76btIivDTolyQTzwbE38g73MjpWvqJQq4CwWC/1blGXiw1Vxs1r4cmcMvT7aRmpmttnRREREREREREyxe81Jfnh/P45sgzI1i9FxUDW8fD3MjpXvqJQSAB6pHcG8J2rj4+HGht/P0XnuFuJTMs2OJSIiIiIiInLbGIbB5q+OsGnxYTCgSrOS3NO7Mu4ebmZHy5dUSkmOFuWLs7BPPYJ9PdhzKomHZv1MdHyq2bFEREREREREcp0928Hqjw6w4/sTANS//w6aPHYnVqvF5GT5l0opuUSNUsF80bch4cE+HD+fxoOzfmb78QtmxxIRERERERHJNZlpNr6btptDW2KxWC20fKICtdpGYrGokMpNFsMw8tVya8nJyQQGBpKUlERAQIDZcfKss8kZPPnRr+yLScbT3cqkR6rRsVoJs2OJiIiIiIhIAWK327HZbLl6jpSEDNZ9cpCkcxm4e1pp/Eg5St4ZnKvnzOs8PDxwc7v6LY3X2s3keik1Y8YMJk6cSGxsLNWqVWPatGnUrVv3qvtPmTKFWbNmceLECYoWLcrDDz/MuHHj8Pb2vqbzqZS6ddKyshn06S5+PBAHwPA2d9GveRk1xSIiIiIiIpKrDMMgNjaWxMTEXD2PPdtB+sUsDAdYrBZ8Cnng5q6byq5FUFAQoaGhV+wIrrWbcc/NgIsWLWLYsGHMnj2bevXqMWXKFNq0acOhQ4coXrz4ZfsvXLiQESNG8MEHH9CwYUN+//13evTogcVi4Z133snNqHIFvp7uzOlWi7HLDvDBT8eY+P0hTpxP440HKuPhpotUREREREREcsdfhVTx4sXx9fXNlcERmWk2UhKzCPY1cPOwUqiwtwqpa2AYBmlpaZw9exaAsLCwG36tXB0pVa9ePerUqcP06dMBcDgcREREMHDgQEaMGHHZ/gMGDODAgQOsXr0657lnn32WrVu3smnTpiueIzMzk8zM/18lLjk5mYiICI2UusU++jma177bj8OARmWLMPPxWgT6aDlMERERERERubXsdju///47xYsXp0iRIrf89Q3DIC05i9REZ5fg6eNOQFEfTWh+nc6fP8/Zs2e58847L7uV71pHSuVaBZiVlcX27dtp3br1/5/MaqV169Zs3rz5isc0bNiQ7du388svvwDwxx9/sHz5ctq3b3/V84wbN47AwMCcR0RExK39RgSA7g0jmftEbXw93fjpyHkenvUzJy+kmR1LRERERERE8pm/5pDy9fW95a9tGAYXL2TkFFI+/p4EFlMhdSP++t/nZub8yrVSKj4+HrvdTkhIyCXPh4SEEBsbe8VjunTpwpgxY2jcuDEeHh6UKVOG5s2b89JLL131PC+++CJJSUk5j5MnT97S70P+X6sKISx+ugEhAV4cPpvCAzN/YtfJRLNjiYiIiIiISD50q2/ZczgMks6mk5HiLFH8g73xL+yleZNv0K34d3OpmyXXrVvHm2++ycyZM9mxYwdffvkly5Yt4/XXX7/qMV5eXgQEBFzykNxTuWQgX/dvRIWwAOJTsnjsvc2s3HfG7FgiIiIiIiIiV2XPdpAYm0pWRjYWi4XAYj74BniqkDJZrpVSRYsWxc3Njbi4uEuej4uLIzQ09IrHjBw5km7dutG7d2+qVKnCAw88wJtvvsm4ceNwOBy5FVWuU1igD0ueaUCLu4qRYXPQ95MdzFl/lFxeyFFERERERETkutky7STEppJtc2B1sxAU4ouXr+ZIdgW5Vkp5enpSq1atSyYtdzgcrF69mgYNGlzxmLS0NKzWSyP9NVmWCg/X4u/lztwnatOtfmkMA8atOMjwz/eQmW03O5qIiIiIiIgIABmpNhLi0nDYnSvsBYf64eHl9u8Hmig6OhqLxcKuXbsA511lFouFxMREU3Plhly9fW/YsGHMnTuXjz76iAMHDtC3b19SU1Pp2bMnAE888QQvvvhizv4dO3Zk1qxZfPbZZxw7doxVq1YxcuRIOnbseNlM7mI+dzcrY+6rxKj/VMRqgc+3n6Lze1s4ezHD7GgiIiIiIiJSgBmGQUpCBsnx6WAYePq4Exzqh5t77s5idO7cOfr27UupUqXw8vIiNDSUNm3a8NNPP93wazZs2JAzZ84QGBh4C5Ne2YwZM4iMjMTb25t69erlLESXW9xz88U7derEuXPnGDVqFLGxsVSvXp2VK1fmTH5+4sSJS0ZGvfLKK1gsFl555RViYmIoVqwYHTt2ZOzYsbkZU26CxWLhycZRlC3uz4CFO9hxIpH7pv/E3CdqU7lk7l8wIiIiIiIiIv/L4TC4GJ9OZno2AL4BnvgF3Z4JzR966CGysrL46KOPuOOOO4iLi2P16tWcP3/+hl/T09PzqtMg3UqLFi1i2LBhzJ49m3r16jFlyhTatGnDoUOHKF68eK6c02Lks/vikpOTCQwMJCkpSZOe32Z/nEuh93+38ce5VLw9rEx6pDodqoaZHUtERERERETykIyMDI4dO0ZUVBTe3t6Ac+RTuu3fp4ux2xwkxadjtznA4lxhz8f/5uaP8vFwu6ZCKzExkeDgYNatW0ezZs2uup/FYmHmzJl8++23rFu3jrCwMCZMmMDDDz8MOG/fi4qKYufOnVSvXp1169bRokULEhISCAoKYv78+QwZMoRFixYxZMgQTp48SePGjfnwww8JC/v/9+Dz5s1j0qRJHDt2jMjISAYNGkS/fv2umqtevXrUqVOH6dOnA84pmCIiIhg4cCAjRoy4bP8r/e/0l2vtZnJ1pJQULHcU8+erfo0Y9OlO1v9+jv4Ld3AorhxDWpXDatWKBiIiIiIiInJj0m12Ko763pRz/zamDb6e/16f+Pv74+/vz9dff039+vXx8vK66r4jR47krbfeYurUqSxYsIDHHnuMvXv3UqFChWvKlJaWxttvv82CBQuwWq107dqV5557jk8++QSATz75hFGjRjF9+nRq1KjBzp076dOnD35+fnTv3v2y18vKymL79u2XTLFktVpp3bo1mzdvvqZMNyJ3b6aUAifQx4MPetShd+MoAN5dfZh+n+wgNTPb5GQiIiIiIiIiucfd3Z358+fz0UcfERQURKNGjXjppZfYs2fPZfs+8sgj9O7dmzvvvJPXX3+d2rVrM23atGs+l81mY/bs2dSuXZuaNWsyYMCASxaaGz16NJMmTeLBBx8kKiqKBx98kKFDhzJnzpwrvl58fDx2uz1nuqW/hISEEBsbe825rpdGSskt52a18Mp/KnJnaCFe+WofK/fHEj0rlXndaxMe7Gt2PBEREREREcljfDzc+G1Mm8ued05onkVGShYAnr4eFCrsdUvv1vHxuPaF1x566CE6dOjAxo0b2bJlCytWrGDChAnMmzePHj165OzXoEGDS45r0KBBzmp718LX15cyZcrkbIeFhXH27FkAUlNTOXr0KL169aJPnz45+2RnZ9+WydKvh0opyTWP1o6gTDE/nl6wnYOxF7lv+k/M7laLOpGFzY4mIiIiIiIieYjFYrnsFjqH3UFSfAaWTDs+Hm74BXnhG+B5WyY0/yfe3t7cfffd3H333YwcOZLevXszevToS0qpm+Xhcek8WRaLhb+mDE9JSQFg7ty51KtX75L93NyuXLAVLVoUNzc34uLiLnk+Li4uVydZ1+17kqtqlS7MNwMaUzEsgPOpWXSZu4UFW46Tz+bXFxERERERkdvIlmUnITYNW0Y2FouFwGI++AXenhX2rlfFihVJTU295LktW7Zctn2t80n9m5CQEEqUKMEff/xB2bJlL3lERUVd8RhPT09q1ap1yS2ADoeD1atXXzaq61bSSCnJdSWDfPi8bwOGL9nDsr1nGPn1PnafTOSN+yvjfR3DIEVEREREREQyUm1cPJ+BYRhY3a0EFvPBw9P895bnz5/nkUce4cknn6Rq1aoUKlSIbdu2MWHCBO67775L9l2yZAm1a9emcePGfPLJJ/zyyy+8//77tyzLa6+9xqBBgwgMDKRt27ZkZmaybds2EhISGDZs2BWPGTZsGN27d6d27drUrVuXKVOmkJqaSs+ePW9Zrr9TKSW3ha+nO9O71KDKhkAmrDzI59tPcTA2mVmP1yKisOaZEhERERERkX/mnD8qk/SLf84f5e1OQFFvrG6ucROYv78/9erVY/LkyRw9ehSbzUZERAR9+vThpZdeumTf1157jc8++4x+/foRFhbGp59+SsWKFW9Zlt69e+Pr68vEiRMZPnw4fn5+VKlShSFDhlz1mE6dOnHu3DlGjRpFbGws1atXZ+XKlZdNfn4rWYx8dh9VcnIygYGBJCUlERAQYHYcuYKfjsQzYOEOEtJsBPl6MK1zDZqUK2Z2LBEREREREXEBGRkZHDt2jKioKLy9vQGwZztIjk/HlmkHwDfAE78g17xd799YLBa++uor7r//frOj3JQr/e/0l2vtZlyjTpQCpVHZoiwd1ISq4YEkptno/sEvzFx3RPNMiYiIiIiIyGVsmdkkxKZiy7TnzB/lH+ydJwspuZRKKTFFySAfFj/dgE61I3AYMGHlIZ75eDsXM2xmRxMREREREREXYBgGaRezSIhNw2E3cPOwEhzmi5evx78fLHmC5pQS03h7uDH+4apULxXE6G/28/3+OA6f/Yk5XWtRLqSQ2fFERERERETEJIZhkJqYiSPLOZbGy9eDQkW8sVrz/ugo3SX0/zRSSkzXuW4pFj/TgLBAb/44l8r9M35ixd4zZscSERERERERE6QkZJCWnEVmWjYA/sFezgnN80EhJZdSKSUuoXpEEN8NbEyDO4qQmmWn7yc7GLvsN2x2h9nRRERERERE5DaJ3hvPivf24sg2sFotBIX44huQNyc0l3+nUkpcRlF/Lxb0qstTTe/g/9g77/A4qnNxv9tXuyut+qp3yZZsy5bk3oAACYQESIAAIXScXy4QQripJMAlkAuBFLghEC4kOOFCIEAooYQkBoM7lizZsmzJVu9du5K2l/n9MdLKa8kNJKv4vM8zz5Q9s3MWo92Z93zfdwCe2dLAlU/voN3qnOaeCQQCgUAgEAgEAoFgKvH7A+x4vZZ3frcPj8OPUq0gIi4MrV5UHZrLCCklmFGoVUru/mI+v/9GCeF6NXuarXzxf7bwQXXXdHdNIBAIBAKBQCAQCARTwPCAizd/Xc6e95sBmLfCgiFCi0otlMVcR/wLC2YkFyxM4N071lGYYsbq8HLTxlIeeu+gSOcTCAQCgUAgEAgEgjlE0/4+Xn5wNx11NrR6FRd8cyFLv5gp0vXOEISUEsxYUqMNvPKtVdywOgOApz+q5+r/3SnS+QQCgUAgEAgEAoFglhPwB9jxeh1vP7EXl91LXFo4X/vJMrKL46e7a4LTiJBSghmNTq3ivy5ewFPXFBOuU1PaNMBF/7OFD6u7p7trAoFAIBAIBAKBQCD4FAwPuHnjN+Xseb8JgEVnp3DZ90swxxmmuWczg8bGRhQKBRUVFQBs3rwZhUKB1Wqd1n5NBUJKCWYFFy5K5O071rIo2cyAw8uNG3fz8HvV+EQ6n0AgEAgEAoFAIBDMGpqq+nj555/QUWtDo1fxhQ0LWX9VHirN3NATPT09/Md//AdpaWnodDoSEhL4whe+wLZt2z71e65evZqOjg7MZvMk9nQ8H3/8MV/+8pdJSkpCoVDwxhtvTOn1QEgpwSwiPcbIq/+xiutXpQPw+4/quPqZnXTYRDqfQCAQCAQCgUAgEMxkAv4AO9+o4+3f7sU17CU21cTX7l5GTsncSte77LLLKC8v509/+hOHDh3irbfe4uyzz6avr+9Tv6dWqyUhIWHK62zZ7XYWL17M7373uym9zpEIKSWYVejUKu6/ZCG/+3oxJp2a3Y0DfPHxLfyzqnO6uyYQCAQCgUAgEAgEggkY7HXyxq/LKfuHnK63cH0yl/2ghMj4U0jXkyTw2KdnkaST6qLVamXLli384he/4JxzziE9PZ3ly5fz4x//mIsvvjjYTqFQ8NRTT3HhhRcSFhZGVlYWr7766jHf9+j0vY0bNxIZGcn7779Pfn4+JpOJCy64gI6OjpDznn32WfLz89Hr9cyfP58nn3zyuP2/8MILefDBB/nKV75yUp93MlCftisJBJPIRYWJLEiK4Pa/7GF/2yDffL6Ma1ak8dOLCgjTqqa7ewKBQCAQCAQCgUAgAA7v7mLzC9V4XH40ehXnfGM+uUstp/5GXgf8d9Lkd/BkuLsdtMYTNjOZTJhMJt544w1WrlyJTqc7Ztt77rmHhx9+mMcff5znn3+eq666isrKSvLz80+qSw6Hg1/+8pc8//zzKJVKvvGNb/C9732PF154AYAXXniBe++9lyeeeIKioiLKy8vZsGEDRqOR66+//uQ+92lAREoJZi0ZsUZe+4/VfHN9FgAv7Grmy09s5UD74DT3TCAQCAQCgUAgEAjObDwuH5s2HuCff6jC4/JjyYzgyp8s/3RCapagVqvZuHEjf/rTn4iMjGTNmjXcfffd7Nu3b1zbK664gltuuYW8vDweeOABli5dym9/+9uTvpbX6+X3v/89S5cupbi4mNtvv51NmzYFX7/vvvv41a9+xVe/+lUyMzP56le/yne/+12efvrpSfmsk8WUR0r97ne/49FHH6Wzs5PFixfz29/+luXLlx+zvdVq5Sc/+Ql/+9vf6O/vJz09nccee4wvfvGLU91VwSxEp1Zx9xfzWZcby3/+dS+13cNc+rtt/PDC+dy4OgOlcmpzbgUCgUAgEAgEAoFAEEpXwyD//GMVgz1OFAoouTCDZRdloFR9hrgYjUGOWJoONCefZnjZZZdx0UUXsWXLFnbu3Ml7773HI488wrPPPssNN9wQbLdq1aqQ81atWhWcbe9kMBgMZGdnB/cTExPp7pZnqbfb7dTV1XHzzTezYcOGYBufzzflxdJPlSmVUi+//DJ33XUXv//971mxYgWPPfYYX/jCF6ipqSE+fnwxM4/Hw/nnn098fDyvvvoqycnJNDU1ERkZOZXdFMwB1uXG8d531vHD1/bx74PdPPD2AT4+1MMvr1hMXPixQyYFAoFAIBAIBAKBQDA5BAIS5f9s4pO3GggEJEzROs6/cQFJuZGf/c0VipNKoZsJ6PV6zj//fM4//3zuuecebrnlFu67774QKfVZ0Wg0IfsKhQJppPbV8PAwAM888wwrVqwIaadSzaxyN1MqpX7961+zYcMGbrzxRgB+//vf88477/DHP/6RH/3oR+Pa//GPf6S/v5/t27cH/wNnZGQc9xputxu32x3cHxwUqVtnKjEmHc9ct5T/29XMg28f4KNDPVzw2Mf88orFnDN/bs3oIJgCJAn8HnnxecDvBp97ZN8Nfi8EfGPtgzNfKMbvKwCVDtSjix5UWnmt1h3RViAQCAQCgeDTI0kSeL0EPF4kjxvJ40Fyuwm43UgeLwT8YwWajyjULAWPySuFUgEaDUqtFsXootGMbWu1KJSi8ovg+Az1u/j3cwdoP2wFIKcknrOvmYfOoDn+iWcABQUFvPHGGyHHdu7cyXXXXReyX1RUNCnXs1gsJCUlUV9fzzXXXDMp7zlVTJmU8ng8lJWV8eMf/zh4TKlUct5557Fjx44Jz3nrrbdYtWoVt912G2+++SZxcXF8/etf54c//OExbd5DDz3E/fffPyWfQTD7UCgUXLsynRWZ0dzxl3KqO4e4ceNublidwY8unI9eM7OssGAS8fvA0Qv2HhjuBkcfuGzy4h4E9xC4BuVt18i+e2Tf65Tl0+liVFCptPJojy4CdOGgH1nrwseOBV8zgyEGjLHyWm8WcksgEAgEgllMwOXC39+Pb2AAf/8AfpuNwPAwAfsw/qEhAsP2I/aH5e3hYfz2YSS3JyigTnZWsM+MWo1Sq0VpNKIMD0dpMqEymeTtcBMqo7ytCjehNIWjiopEHRODKiYWdWwMSr3+9PRTMC3U7enmw/+rxu3wodapWH9lHvNXJaA4w+5X+/r6uOKKK7jpppsoLCwkPDyc0tJSHnnkES655JKQtq+88gpLly5l7dq1vPDCC3zyySf84Q9/mLS+3H///dxxxx2YzWYuuOAC3G43paWlDAwMcNddd014zvDwMLW1tcH9hoYGKioqiI6OJi0tbdL6diRTJqV6e3vx+/1YLKFFzCwWC9XV1ROeU19fzwcffMA111zDu+++S21tLbfeeiter5f77rtvwnN+/OMfh/wHHRwcJDU1dfI+iGBWkmcJ543b1vCLf1Tz3LZGNm5vZGd9H7+5cgn5iRHT3T3BqRDww1AHWJvB2gKDbWPiyd4Nwz3y2tFPcLhvMlCqR6KdtPJapQWlShZBwZu/o0cej9j3e8DnkqOufK7Qvo1GZIEs0j5t/wwxYIgFQ/SIrIqV1yYLRCRBeAKEJ8ntxOimQCAQCARTjn/Yjq+7C193N76uLrzd3fj7+vEP9OPrH8A/MCCLKKsVyeGY9OsrNBoUOt1YdNPowL7i6MjuI48B/gCS1yuLrtHF6w19c5+PgM9HwOGAnp5T7pvSYEAVG4s6JgZ1bAyqmBjUMbGo4+LQJCehSU5Gk5iIMizs1D+4YNrwuHxse+UwB7Z1ABCfHs75Ny0g0nLyNZjmEiaTiRUrVvCb3/yGuro6vF4vqampbNiwgbvvvjuk7f33389LL73ErbfeSmJiIn/5y18oKCiYtL7ccsstGAwGHn30Ub7//e9jNBpZtGgRd9555zHPKS0t5Zxzzgnuj7qW66+/no0bN05a345EIUlTo9bb29tJTk5m+/btIQW8fvCDH/DRRx+xa9eucefk5eXhcrloaGgIRkb9+te/5tFHH6Wjo+Okrjs4OIjZbMZmsxERIeSDAD6s7ub7r+6ld9iDRqXgu+fn8c11Wag/S5E9weQRCICtBaxNsnSyNo/sN8vLYFto2txxUchSxhgvr/Xmkegj8xGRSBFHRCSNHNeEyWl1Ku3YWjmJUXWSJKf/jaYE+twjwsoNHvtYJFdwfURU1+hxp1WO/nL0gWf41K6v1IwIqkR5HZEkb5tTIDINItPBFC8irwQCgUAgOA7+YTvetja8ba1429qD8snbJQsoX3c3Abv91N5Uo0EdFYUqKgpVZORYxJHJJG+bRrZN4ShNxuC+QqeTU+1GBZROJwupSRyEkiRpRFR5kbxjkVmB4ZHILfswgaGhkSiuobHjQ0P4h4fwD1jx9fXi7+1D8px8RLoqJgZN0oikSkqShdXIvjYtTURczSDaDw+w6U8HGex1gQKKP5/O8i9nolJ/9v8PR71AZmYm+jn4b65QKHj99de59NJLp7srn4nj/TudrJuZskip2NhYVCoVXV1dIce7urpISEiY8JzExEQ0Gk1Iql5+fj6dnZ14PB60Wu1UdVcwhzlnfjzvfWc9d79eyb8OdPHIP2r414Eufv21JWTGzo5CeXMCrxP6aqH3EPQeltc9h+RjPufxz1WqZYFiTpXXxjhZohjjwRQ3so4fiQiagSmaCoUccaXWyhLss+J1jQiqXnltP3K7B4Y65eiywQ55P+CVRZ+t5djvqdbL/32j0kdE1YisikyXjxlihLQSCAQCwZwm4HTibW3F09aGt7VtREC14W1txdvWht9mO6n3UZpMqOPjUVvi0cTHy9FBUVGooqJRRUfJ29HRqKKjURqNMza9SaFQoNBqQasFPv09syRJBIaH8fX24u/rw9fbJ8uq0e3ubrzt7Xjb2gjY7fj7+vD39eGqrJyoU7Kcys5Cl5mFNisTXXY22qws1FFRn/7DCk4Jn8fPzjfr2ftBC0gQHq3n3OvzSZ4n/g0Ep86USSmtVktJSQmbNm0K2r9AIMCmTZu4/fbbJzxnzZo1vPjiiwQCAZQjlv/QoUMkJiYKISX4TMSF6/jfa0t4bU8b979VRXmzlQsf/5gfX5jPtSvTUSpn5s3ArMTvg94a6NgHXfuhp0YWUNZmjplep9KOiRBz6vjt8ISZKZumC40ezMnyciL8XhjukgXVULssrAbbZWllax2LRvO5oO+wvEyEzgwx2SNLDkRnj+3rZ9a0sgKBQCAQHAvJ48HT2oansRFPU1PI2tfZecLzVZGRwQgedUICGku8LKDiLUEJpTSKQc8jUSgUqMLDUYWHQ2bmMdtJkkRgcFAWgSOSytvejre9PSgKA4ODsiRsbcX+0cch56siI9FmZaHLzkKXm4s+Px9dfj4qk2mqP+IZRXfTIP9+7gADnXL6af6aRNZenos2bErnUBPMYaYsfQ/g5Zdf5vrrr+fpp59m+fLlPPbYY/z1r3+luroai8XCddddR3JyMg899BAALS0tLFiwgOuvv55vf/vbHD58mJtuuok77riDn/zkJyd1TZG+JzgRbVYnP3h1L9tq+wBYmxPLI5cXkhQp8tdPGa8LuqtkAdWxFzr3QVfVSA2lCdCbIXYexOVBbJ68HZsrR+OoxA/ZtOHzyGJqNGXS2nTEdrMssY5Xr8sYNyaq4vIgLh/i5slSUdSyEggEAsE04LfZcNfW4q6tw11XK8unxia8bW3g9x/zPGVEBJqUZLTJyWiSktGkpMgSKjkZTXKSEBzTiCRJ+Pv7cdfV4alvwNNQj7uuHk99Pd729mOep0lPQ19QIC/5BegL8lFHR5/Gns8N/P4Ape82UvZeE1JAwhCh5Zxr55OxKHZKrjfX0/fmCpORvjelUgrgiSee4NFHH6Wzs5MlS5bwP//zP6xYsQKAs88+m4yMjJCCWTt27OC73/0uFRUVJCcnc/PNNx939r2jEVJKcDIEAhLP72ziofcO4vIGCNepue/iBVxWnDxjQ6innYBfFk4tu6Btjyygug+CNMGNndYECYWQsAji548JKGOsSAGbjXhdMNAgp1r21UJfnbz018lRWMdCYxyRVPNlSTUqqyLThawSCAQCwaTgGxjAU1uLu65OFlC1tbjravH3HHsiEYXBgDY9HW1GOtqMDLTp6egyMtCkp4sUsFlKwOHA09iIu74BT30druoaXAcP4jtGXWJ1QoIsqRYUYCgqQl+4GJVJRLgdi772YTZtPEhP8xAAOSXxnHX1PPQmzZRdU0ip2cGskFKnGyGlBKdCfc8w//nKXsqbrQB8vsDCf391EbEm3fR2bCbgHoa2UmjeBS07oWU3eIbGtwuLhsTFI0shJC6BqEwhHc4UXIPQXz8mrHpqoKdarhsW8E58jjpMllMJC8GyaGS9EMIiT2vXBQKBQDB7kDwe3PX1uKqrcdccwl1TjavmEP6+vmOeo05KRJedM1JzKHNEQGWgjo8Tg5BnCL7+flwHDuI6eADXgQO4DxzE09Q0vqFSiX7+fMKKizEUFxFWXIzmGHWQzyQCAYm9/25h11v1+H0BdAY1Z109j9xllim/tpBSswMhpSZASCnBqeLzB3j643oe+/chvH6JaKOWBy9dyBcXJU53104vgx3QvEOOhGreCZ2V46OgtOGQshRSl4+JqIhkEf0kGI/fJ8uqnuoRUXVwrL6Y/xgz8JhTZTk1KqkSFgnBKRAIBGcgvv5+3NXVuKprZPlUXYO7vh68Ew92aJKS0ObmBAWULjcHbVa2iHwRTIh/eFj+/+vAAZx79+Eo34OvfXxElTopEUNxCWHFRRiKi9Hl5U3q7IYzHWu3gw/+fJCOWrnAf9qCGD537XyMkadn8F5IqdmBkFITIKSU4NNyoH2Qu/5aQXWnHA10wYIEfnbJAuIj5uiXoHsYmrZB3YdQ/6EsD44mIgXSVkDqSkhbCZYFouC44LPh98mpgF1VciH8zv3y+lgzA2qMYxF4SUvkdWyu+P9QIBAI5gi+nh6cVVW49lfhqpIXX3f3hG2V4eHo5uWhnzcf3fx56OfNQ5edLQqLCz4z3s5OnHv24NhTjmNPGe7qGggEQtqooqIwrlqJcfVqjKtXo0lKmqbeTi0Bf4C9m1rZ9fd6/N4AGp2KNZfnULA26bRGGAopNTsQUmoChJQSfBbcPj9PfFDLU5vr8AUkIvRq7vlSAZeXpMz+MO+AH9oroP4DqNssR0SFpFcp5AiVUQGVugIiU6eps4IzDqf1CFFVKa+7D05cNF9jlKOokoqEqBIIBIJZhLe7e0Q8HTi+gFIo0KSljsmn+fPR5c1Dk3x6H4oFZy7+YTuufXtx7CnHuacMR8VeJIcjpI02M1MWVGtWY1i+fE4Uwe9rG+aDPx+ku0kepE+ZH8U535hPROzpnxBKSKnZgZBSEyCklGAyONA+yA9f20dlmxyuui43lv/+yiJSow3T3LNTxNYGh/8pR0LVfwQua+jrkWmQdQ5knwOZZ4FBzEQimEH4fXKdqo4KaC+XpWrnPvA6xrfVGGVBlVwMyUvlNFORWioQCATThn/Yjmv/fpz79uGq3IdzXyW+rgkmx1Aq0WZlErZgAfrRZf58Ef0kmFFIXi/OvXuxb9+Ofdt2nJWVoZFUajVhixdjXL0K07p16BcunFWpfn5fgLL3Gin7RxMBv4Q2TM2ay3PIX504bSL4TJdSjY2NZGZmUl5ezpIlS9i8eTPnnHMOAwMDREZGTnf3gggpNQFCSgkmC58/wLNbG/j1vw7h8QUwaFX88IL5XLsyHaVyhj7oSpIcXVLzDlS/Iz/IH4kuAjLXyxIq6xyIzhIP7YLZRcAvF1HvqJAlVUcFdOydWFSZEmQ5lVwir5OKQBd+mjssEAgEcx/J78ddW4tz715ZQu3dh7uublz60zgBtXChLKAMs2zQT3DG4x8cxL5rF/Zt27Bv34G3uTnkdXV8PKbPnUP4uedhXLEchVY7TT09MV0Ng3zw/EH62+0AZC6O5ayr55222lHHYjZLqZ6eHu69917eeecdurq6iIqKYvHixdx7772sWbPmpN7jaCnl8Xjo7+/HYrFMqSh86KGH+Nvf/kZ1dTVhYWGsXr2aX/ziF8ybN2/C9kJKTYCQUoLJpr5nmB+9Vsknjf0ALE2P4heXF5IdN0NCdAN+ORWvekREDTQc8aICUpZBznmyiEoqBpV62roqEEwJAb9cQL2tDFpL5Vkjuw6ML9SvUELc/JFi/SO10mKyhZgVCASCU8Q3MICzogLnnnJ5XVU1LrUJ5ELRYYWLCVu0iLDFhegLCoSAEsxJPK2t2LdtlyXV1q0Ejvh7UJpMmNavw3TuuZjWr0cVPjMGyLweP5+8Vc/eTS1IEoSFa1h3ZR45JfEzIk12Nkup9evX4/F4eOihh8jKyqKrq4tNmzaxYMECLr744pN6j6Ol1Oniggsu4KqrrmLZsmX4fD7uvvtu9u/fz4EDBzBOEMEqpNQECCklmAoCAYkXdjXx8HvV2D1+tGold56Xy4Z1WWhU0xCa63XKBcqr34FD74HjiOmQVTrIOhvmXwTzLgRT/Onvn0Aw3XgccgRVW+mIqCqbuJi6IWZEUC2X10lFoDn9dRMEAoFgpiIFAngaGnCWl+MoL8e5pxxPQ8O4dkqjEf2iRYQVFsoCatEiNPHiHkRw5hHweHDs3MnQpg8Y+mAT/p7esRc1GozLl2M693OEn3suGotlWvrYVjPAB/9XzWCPE4C8FRbWXpFLmGnmRHTNVilltVqJiopi8+bNnHXWWcdsp1AoePLJJ3nrrbfYvHkziYmJPPLII1x++eXAidP3Nm7cyJ133snLL7/MnXfeSUtLC2vXruW5554jMXFsFvlnn32WX/3qVzQ0NJCRkcEdd9zBrbfeetKfp6enh/j4eD766CPWr18/7vXJkFIiZEIgOAmUSgXXrsrgnPnx/OT1/Xx0qIdH/lHD23s7+O+vLmJJauTUd8Lvg/rNUPkKVL8NnuGx1/SRkPcFWURlnwu6GRLFJRBMF1oDpK+Sl1GGumRJ1fKJvLTvkYVuzbvyAqDUQOLiMVGVvlqIXYFAcEYRcLlw7tsnR0GVy5FQfpttXDttdjZhRUswLFlC2OLFaLOyUKjEhBMCgVKrxbR+Pab160m4715c+/bJgmrTJjz19XI01bZtdP3sAQxLlxLxpS8RccEXUJ2GOkEuu5cdf6vlwLYOAExROs76+jwyFsVO+bUnA0mScPqc03LtMHXYSUWQmUwmTCYTb7zxBitXrkSnO3Ya5D333MPDDz/M448/zvPPP89VV11FZWUl+fn5J9Unh8PBL3/5S55//nmUSiXf+MY3+N73vscLL7wAwAsvvMC9997LE088QVFREeXl5WzYsAGj0cj1119/UtewjXz/R0dPXe1hESklEJwikiTxenkb9//9ADanF4UCrl2Zzve+MI8IvWayLwatu2URtf9v4DhipCUiRZZQ8y+SH5xVk3xtgWCu4/PIhdNbdkHzTnk9PEER3pgcSFsF6WtkyRWZLlL+BEiShDfgxelz4vK5cPldoeuRbV/AF7pI8tob8AaP+Y9ONT0OChRolBrUSvX4RSGvNUoNGpWGMFUYerU+uBy5r1PpUCpmTxFewdThHxqSo6B2l+IoK8NVWYnk9Ya0Uej1cgpecTFhRbKEUkdFTVOPBYLZi7u+geEPNjH07004KyrGXtBoMK1dS8SXLiL8c59DGTa5UduSJFGzq5Ntr9biGpb/vhesT2b1V7LRhs3MOJWJInAcXgcrXlwxLf3Z9fVdGDQnl3782muvsWHDBpxOJ8XFxZx11llcddVVFBYWBtsoFAq+9a1v8dRTTwWPrVy5kuLiYp588smTipS68cYbqa2tJTs7G4Ann3ySn/3sZ3R2dgKQk5PDAw88wNVXXx28xoMPPsi7777L9u3bT/g5AoEAF198MVarla1bt07YRkRKCQTTgEKh4KvFKazPi+O/3znI38rb+POOJt7b38k9Xyrgy4WTMEtFd7UsoipfAWvT2HFDDCz4Kiy6Qo7iEA/GAsGnR62V60ulLIVVt8kS2Nosy6lRUdVVJc8A2FcL5c/L50Ukj0iq1fISOw9m0Qw7grGRVqvbGlwG3YMMeYewe+zy2mtnyCOvhz3DDHtHFs+wLKL8LgJS4MQXm8HoVbKgMmqMmDQmjBoj4drwCdcmjYkIbQRmnZlIXSSRukjCteGolCIyZrbh6+3FUVqGo6wMR1kp7uqacQXJ1XFxhJWUYCguIqyoGP38eSg0YvBLIPis6LIy0WXdQswtt+Dt6GDw3Xex/f1t3NXVDH/4IcMffojCYCD8vHMxf+lLGFet+sx/ewOddj56sYa2Q1YAopOMnPX1eSTlRH72DySYkMsuu4yLLrqILVu2sHPnTt577z0eeeQRnn32WW644YZgu1WrVoWct2rVKiqOlJUnwGAwBIUUQGJiIt3d3QDY7Xbq6uq4+eab2bBhQ7CNz+fDbDaf1Pvfdttt7N+//5hCarIQUkog+JTEmnT8+solXF6Swk/f2E99r507/lLOK6UtPHDJQjJiT3Eq4+Fu2PsSVP4VOivHjmuMcjRU4dfkWlEiIkogmBoUCohKl5fCr8nHnAPQvAuat0PTdnlGy8E22P+qvACERctyKmMdZKyF+AIhqU4zkiQx6Bmkz9lHn6svuO519jLgGgiKJ5vbFlx7A94Tv/FJolKo5AikEckTpg5Dr9KjVWlPGNU0uig4uUEGv+QfF301GnXllcair7x+77ioLZfPhSfgCb6Xyy8ft7qtn+pzK1AQoYsgUhcZIqsidZHEhMUQo48JWUfpo9AoxW/Y6cbb3Y1j924cn+zG8cknE9aD0qSlYVi6FENJCYZlS9Gkps6IQscCwVxGk5hIzM03E3PzzbgPH8b2zjsMvv0O3tZWBt/6O4Nv/R1VdDQRF1yA+StfQb9wwSn9Xfo8fsr+0cSe95sI+CXUGiXLvpTJ4nNTUaln531KmDqMXV/fNW3XPhX0ej3nn38+559/Pvfccw+33HIL9913X4iU+qxojhKWCoWC0US44WG51MszzzzDihWh0WWqk0i1vv3223n77bf5+OOPSUlJmaQeT4yQUgLBZ2R1Tizv3bmOpz+q54kPa9lyuJfPP/Yx3z4nh2+elYVOfZw/+kAA6j+Asj/JNW0CPvm4Ug0558Oiy+Vi5dpTFFwCgWByCIuCeRfIC8gF1Ft3Q/MOWVK17gZnv1znrfrtsXPS1whJNQlIksSAe4BuRzdd9i66HF10O7rpdnTT6+wNEVC+0e/PU0Cj1ASFillnJlwbTrhmfISQSWsKro0aI0a1cSwtTqWXpdIseYD3B/y4/e5gtJfT68TuOyIabGQdEinmHWbIM8SgZzAo9uxeOxISNrcNm3t8vaFjEaWLCoqq6LBoLAYL8YZ44g3xwe24sDg0YgDmU3NCCaVQoMvLkwXU0hLCSpaisYjaeQLBdKLLzSX+zjuJ+853cFZUMPj2Owy+9x7+/n4GXnyRgRdfRJefT9TXriDiS1864Qx+zQf6+Ogvh4KFzNMXxbD+yjwiYmf3ZC4KheKkU+hmGgUFBbzxxhshx3bu3Ml1110Xsl9UVDQp17NYLCQlJVFfX88111xz0udJksS3v/1tXn/9dTZv3kxmZuak9Od4CCklEEwCOrWKO87N5cuLk7jnjf1sre3lV/86xOsVbTx46UJWZx9VPHCwA8r/D8r/LKcLjZK8FJZ8HRZ8BQxTV0xOIBB8SrQGyDpLXgD8XmivgKat0LgVmnbI0VUhkioaMo6SVLNEYEwlo9FN7cPttNvb6RjuoMPeIQuoI+TTqUQ0hWvCZeFxVHROlC5qXDSPWWc+6aKlcwmVUoVBafjMN/Vevxebx4bVFRqFNrocGa3W5+xjwD1AQAow4B5gwD1ALbXHfG8FCqL10SGiKsGYQKIpkSRjEkmmJOLC4kTq4Ai+3l4cn3yCfdcnx5RQ+vx8DMuXY1i+DENJCaqTTN0QCASnF4VCgaGoCENREZYf/RD7zp3Y3niToX/9C/fBg3Te/zO6HnmUiAsvJPKKywlbsiTkd8xuc7P1lcPUlsopXMZIHeuuzCVrSdwZ93s3XfT19XHFFVdw0003UVhYSHh4OKWlpTzyyCNccsklIW1feeUVli5dytq1a3nhhRf45JNP+MMf/jBpfbn//vu54447MJvNXHDBBbjdbkpLSxkYGOCuu+6a8JzbbruNF198kTfffJPw8PBgfSqz2UzYJNc6G0VIKYFgEsmMNfL8zct5a287D7x9kPoeO19/ZhdfLUrmxxfkEdf5Mez5Exx6H0YL2+rNUHglFF8PCQun9wMIBIJTQ6WB1GXysva7sqTq2AuNW46QVP1w8O/yAmCIhcz1stjKXA9RmXNSUkmSRL+rn9bhVtqG2oLi6UgB5fA5Tuq9ovVyRM2RUTVxhriQ9LDosGh0qmPPcCOYXDQqDbFhscSGndyMTf6AX5ZVR6ZXOnrpdnYHBeSokPQFfHI7Vx8H+w9O+H5qhRqL0UKiMZEkUxIJxoSgsEoJTyHRmIhaOTdvc/2Dgzh278a+cxeOnTtwHz5K8IVIqOUYSoqFhBIIZiEKjQbTunWY1q3DNzDA4FtvMfDKK3hq67D97W/Y/vY3dLk5RF7xNcIv+hIH99nZ9WYdHpcfhQIKz0ll+cWZaPVz87twpmIymVixYgW/+c1vqKurw+v1kpqayoYNG7j77rtD2t5///289NJL3HrrrSQmJvKXv/yFgoKCSevLLbfcgsFg4NFHH+X73/8+RqORRYsWceeddx7znNHC62effXbI8eeee25SUw+PRMy+JxBMETanl1++X8O/dpVzleoDrlJ9RIKib6xB2ioouQEKLgHN7A6lFQgEx2A0kmpUUjXvAO9RIsacCpkjgipzPUQkTktXPw3egJeO4Q5ah1ppGWqhZaiF1mF5u3Wo9aSkU7Q+miRjEommRBKNibJ4MsaTYEgQqVxnIAEpwIBrIERSdTm66LR30mHvoH24nS57Fz7p+OmaaoWaRFMiKaYUUsNTSQkPXRs1syctPuB04tizB8fOXdh37sRVVRVamFyhQDd/PsblyzGsWC4ioQSCOYwkSTjLK7D+9a8M/uMfSC4XA+YcDud9jWFjMgDx6eGcfc184tKOn+I30znerG5zAYVCweuvv86ll1463V35TEzG7HtCSgkEU0XbHtj5JNL+11GM3Dz3SyY+0H6OjC/cytKlq07wBgKBYM7h80BbGTR8BA0fQ8sncHR6WmyeLKmyzpbT/cIip6OnQfwBPx32DpoHm2kcbKRpsImmwSYaBxvpsHccdwY6BQosRgvJpuSgeDpSQCUaE9Gr596NpmBq8Qf89Dh7gpLqyHXbcBttQ20hBd0nIkoXRXpEOukR6WSYM0gLTyM9Ip20iLRTLmY72Ug+H87KSuw7duDYsRNnRQWSN/R7QpuZiWHlCowrV2FYvgx1VNQ09VYgEEwXtuZePv7fXTT3yt9Zaq+drIa/kx01QMwN1xHxhS+g0GqnuZefHiGlZgdCSk2AkFKCaSXgl+vI7HgSWnYGD0tpq9kRcyl37U2l0yH/yX2+wMJPLyogLWZ2FusTCASTgMcOzTvHJFV7BXDEz7JCCUnFkH2OLKlSloN6am4wbW4b9bZ6GmwNsnyyyfKpeaj5uHWd9Co9KeEppJhSxkWjJJmSREqd4LQTkAJ0O7qDEXyj0XttQ220DLUw4B447vkJxgRZVkVkBNdZkVkkGhNRKiZ/0gJJkvA0NGLfvl0WUbt2ERiZNWkUdWIixpUrMa5cgWHlSjQWy6T3QyAQzA58Xj8V/2qh7B+N+DwBUMD8Aj1ZHf/E/c4bSG43AOr4eKK+/nUir/zarBTXQkrNDoSUmgAhpQTTgmsQyp+HXb8fK1yu1MDCy2Dlf0DSEkBO6Xvs34f4844m/AEJrVrJt9Zn8R9n5xCmFQVbBYIzHucANG6D+s3y0nc49HWNQZ7Zb1RSnWLRdEmS6HZ0U2+rDwqoOmsd9bZ6+l39xzxPo9QEI0nSzfJD+uh+bFisKJ4qmFUMe4ZpGWqhaagpKF+bBptoGGxgyDN0zPPC1GFkRGSQac4kOzKbLHMWWeYsUiNS0ShPLcXU19uLfcdO7Dt2YN+xA19HR8jrSrNZllCrVmFctRJNWpr4OxMIznAkSaJhby/bXj3MYK8LgMQcM+u+lhdM1fMNDGB9+WUGXngRX08PAAq9HvMllxB9/XXosrKmrf+nylyXUnMFIaUmQEgpwWmlvwF2PS3PpDd6IxsWDUtvgmW3HLM2zKGuIf7rrSq218k1ppLMeu6+KJ+LFiWKm06BQDCGrXVMUNVvBntP6OvGeFlQZX8Oss6BcDl6QpIkepw91A7Ucth6mFprLXXWOhpsDQx7h4++SpAEYwJZ5qyQCJF0czoJhgQx05lgziNJEla3NSipRtNUR6MHfYGJ61ipFWpSI1LJNmeTE5VDTmQOuZG5IbIq4HLhKCvDvm079m3bcNfUhLyHQqMhrKQE4+rVGFetQl+Qj0Il/uYEAoHMQKedrX89TPMBeQDJaNay+vIccpdaJnx2kDweBt97j74//Qn3gbEJI4zr1xF93fUY16ye8c8cQkrNDoSUmgAhpQSnhY698PEvR2bTGvkTipsvR0UVXnlShcslSeL9qk4eePsgbVYnACuzornvywvITxT/7woEgqMIBKD7wIig+lCOqPI5sSmVHNZqqNVoqDVbOGyMoDbgZPAYRcZVChWp4anjoj0yzZkYNCKdWCCYCF/AR+tQ67gowwZbw8QF/SWJrD41Z7VHUtgQIOHwACpvqNTS5edjXL0K46rVGEqKUU7RVNsCgWD24nb6KH2ngX0ftBIISCjVCpacl0bJBeknNaueJEk4S0vp+9OfGN70AYw8+utyc4jZsIGIL34RhXpmzs4npNTsQEipCRBSSjCltJbCR4/A4ffHjmWfC6tuldefYsTB6fHz9Md1PLW5DrcvgEIBV5Sk8J+fn4clQnwBCwQCGV/AR6OtkZqBGmoGajjUV8Ohvip6PLYJ2ysliXSFlhxTCrkJJWQlrSQ7Mpu0iDS0qtlb+FQgmElIkkSXo4t6az2NjXtx7dyFsfwwqdUDRA2H3mL3hcO+TAXV2TqcS3JJSVvAvKh5zIueR15U3qyaEVAgEEwtfn+Aqo/b2f12Ay67XNcxozCWNZfnEBn/6QaQPM3N9D//f9hee42AQ5bpmvQ0Yr/5Tcxf/vKMK4oupNTsQEipCRBSSjAlNG6Djx+RIxRALj688HJYdxfE50/KJVoHHDz0XjXv7JPrSoRpVHxzfRbfXJ+FUTczRzAEAsHUYHPbqOkfkU8Dh6jpr6HOWnfMGcWSjEnkhKeRI6nIGewlr72KDFs7uiN/4U0Jcppfzrny2hB9ej6MQDBHkTweHOUV2LduZXjb1pAUGQB0OtyFObQtiGNvhoKysE7qBxuOmQaYYkohLyqPedHzmBc1j7zoPJJNyVNSXF0gEMxMRutG7Xi9DmuXLI6iEgysviyHjEWxk3IN/9AQAy/+hf6NG/EPyBM/qJMSid2wAfNXv4pSNzMmKBFSanYgpNQECCklmDQkSU6R+ehRaN4uH1OqYfFVsPYuiMmeksuWNQ3w83cOsKfZCkB8uI7//Hwel5ekolLO7NxvgUBwaowWHj/Yf1Be+g5S3V9Nh71jwvZh6jD5ofWI6IqcyBxMWtPRbww9NVD3gbw0bgWf84gGCkgqgpzzZEmVvBRUQn4LBCfC09zM8Nat2Lduw7FzZzDaYBRdQT6mNWswrllDWHExyqMiD7wBL82DzUHZXDNQw6H+Q3Q7uye8nkljYl70PPKj88mPySc/Op9McyZqpfh7FQjmGt1Ng2x7tZb2w1YAwsI1LP9yFgVrElGqJl9OBxwOBl56mb4//hF/by8gz9gXc/NNRH7ta9OeUiyk1Oxg1kip3/3udzz66KN0dnayePFifvvb37J8+fITnvfSSy9x9dVXc8kll/DGG2+c1LWElBJ8ZiQJDr0PHz8KbaXyMZUWir4Ba+6EqPTT0AWJ9/Z38vB71TT3yze88xPCufuL+azPi5vy6wsEgsknIAVoHWrlQP8BqvuqOdgvC6hjzXqXbEoORk2MiqiU8JRPFzXhdUHLTqj9N9R+AN1Voa/rzJC1XpZU2edCZOqn+IQCwdwjYLdj3/VJMBrK29Qc8roqJgbjmtWY1q7FuHo16thPF8kw4BoIFVUDh6iz1uENeMe11al05Ebmkh+Tz/zo+RTEFJAblYtONTOiGwQCwakx1O9i5xt1HPqkCwCVRsmSc1Mp/kI62rCpF9ABlwvrq6/R9+yz+Do75T5ERxN94w1EXf11VKbpSS0WUmp2MCuk1Msvv8x1113H73//e1asWMFjjz3GK6+8Qk1NDfHx8cc8r7GxkbVr15KVlUV0dLSQUoKpR5Lg8L/ggwegc598TK2Hkhth9bfBnHzau+T2+Xl+RxO//aAWm1O+MV2fF8dPvpjPvITw094fgUBwckiSROtQK1V9VVT1VXGg7wAH+g5MOPOdSqEi05xJfrT8gJkfk8+86HlEaKfwN2ywQ46gqv23HBHqHAh9PXaeLKhyz4O01aARN4OCMwNJknAfOox96xaGt2zFUVYG3iPEkFqNoagI49q1GNeuQZ+fj0I5Nel13oCXemt9UGCPRlJOVFhdpVCRE5nDgtgFFEQXsCB2AXlReaJ+nEAwg/E4fZT9o4m9m1rw+wIAzFuRwIpLsgiPPv2/uwGPB9vrb9D3v/+Lt60NAJXZTPRNNxF93bWnPXLqTJdSjY2NZGZmUl5ezpIlS9i8eTPnnHMOAwMDREZGTnf3gswKKbVixQqWLVvGE088AUAgECA1NZVvf/vb/OhHP5rwHL/fz/r167npppvYsmULVqv1mFLK7XbjdruD+4ODg6SmpgopJTg1WnbDv++Dpm3yvsYIy26WZZTp2PL0dGF1ePjtB7X8eUcjXr+EUgFXlKRy5/m5JJrFbD0CwXQiSRJtw21B+TS6HvIMjWurVWrJi8pjfsx8OR0nOp/cqFz06mm82Qr4ob0C6jbJkqp1N0iBsdfVYZC5biTV77wpS10WCKYL/+Ag9u07GN66BfuWrfi6ukJe16SkYFy3FtPatRhWrEBlMh3jnaaegBSgZaglJN33WBGXaqWa3MhcCmJkSVUQU0BeZB4alWYaei4QCEbx+wJUbWmn9N0GnEOy9E7KjWTN5TnEp0//86vk9WJ7+x36nn4aT2MjAOq4OGJvu43Iy76KQnN6vkNms5Tq6enh3nvv5Z133qGrq4uoqCgWL17Mvffey5o1a07qPY6WUh6Ph/7+fiwWC4pPMbnWyfLUU0/x1FNP0Tjyb79gwQLuvfdeLrzwwgnbz3gp5fF4MBgMvPrqq1x66aXB49dffz1Wq5U333xzwvPuu+8+9u3bx+uvv84NN9xwXCn1X//1X9x///3jjgspJTgpempg08+g+m15X6WDFd+ENd8FY8z09m0CGnvtPPJ+Ne9WyqG1WrWS61amc+s5OUQbxWioQHA66HP2sb93P5W9lezv28/+3v3Y3ONnwNMoNcHUmgUx8gNhVmQWGuUMfyB0DkD9R1D7L6jdBENH1beKyhwTVJnrQCtmDBPMLqRAANeBg8FoKGdFBfj9wdcVej2GFcsxrV2Had1aNOnpU/oA8FkZnQGwqq+Kqt4xOW51W8e11Sg1zIuax8LYhSyKW8TC2IVkRGSIYuoCwWkgEJA49Eknn/y9gaE+FwCRFgOrv5pNRmHsjPuekfx+Bt95h57H/ycYOaVNTyfuu3cS/oUvTHl/Z7OUWr9+PR6Ph4ceeoisrCy6urrYtGkTCxYs4OKLLz6p9zhaSp0u/v73v6NSqcjNzUWSJP70pz/x6KOPUl5ezoIFC8a1n/FSqr29neTkZLZv386qVauCx3/wgx/w0UcfsWvXrnHnbN26lauuuoqKigpiY2NPKKVEpJTgU2FrhQ8fgr0vyhEBCiUs+Tqc/WMwp0x3705IWVM/v/hHDZ80yCOjJp2aW9Zlcsu6LExipj6BYNJweB0c6DswJqF699Nubx/XTq1UkxeVF5RPC2IWkBOZM/sjEiQJug/IEVSH/wXNO+HIGjcqLaSvhpzzZUkVNw9m2E21QADgGxjAvm079i0fM7x1G/6+vpDXtdnZcl2odeswLFs6Y2af+rRIkkSHvWOcqBr0DI5ra9KYWBCzQBZVsbKoshgt09BrgWBuMjqj3q636ulvtwNgMGtZ9sUM8tcmoZqCIuaTScDjwfryX+l96in8/fKzh37BAuL/8y6Mq1dP2XVnq5SyWq1ERUWxefNmzjrrrGO2UygUPPnkk7z11lts3ryZxMREHnnkES6//HLgxOl7Gzdu5M477+Tll1/mzjvvpKWlhbVr1/Lcc8+RmJgYvM6zzz7Lr371KxoaGsjIyOCOO+7g1ltvPaXPFB0dzaOPPsrNN9887rXJkFIz6ul1aGiIa6+9lmeeeYbYkywUqdPp0M3yGwfBacTRD1t+BZ88A/4RmTn/S3DuvfLD1CyhJD2al7+5ko8O9fDo+zVUtQ/y2L8P8+cdTdx6djbfWJmOXqOa7m4KBLMKf8BPva2efT37qOytZF/vPuqsdQSOTGUDFCjINGeGPMDN2dotCgVYFsjLmu+AewgatowUTP8XWJuhfrO8/PMnYE4di6LKOgt0ovadYHqQ/H5c+/czvGUrw1s+xrWvUpasIygNBgyrV41FQyWf/rqRU4lCoSDJlESSKYnz088HxmrdjUZ47u/dH6x1t6tzF7s6xwaL48PiWRi7kMK4QgrjClkQswCDxjBdH0cgmLW0VPez8416uhtlIawzqCn+QjqLzklBo50d9+pKrZboa7+B+StfoX/jRvr/+EdcVVU033QzxtWriLvrPwlbOD6CZiqQJAnJ6TxxwylAERZ2UtFhJpMJk8nEG2+8wcqVK4/rKu655x4efvhhHn/8cZ5//nmuuuoqKisryc/PP6k+ORwOfvnLX/L888+jVCr5xje+wfe+9z1eeOEFAF544QXuvfdennjiCYqKiigvL2fDhg0YjUauv/76E76/3+/nlVdewW63hwQZTTYzKn2voqKCoqIiVKqxP9BAQH4YUCqV1NTUkJ19/FoWotC5YEI8Dtj5JGz7HxhNs0lfC+f9F6Qum9aufVYCAYl393fw638eor5XHn1JMuv5znm5XFacgnqGj74IBNNFn7NPlk89+9jXu4/9vfuxe+3j2lkMlqB8WhS7iIKYAkza6aspM2OQJOirlSOoav8FjdvGZD+AUgNpK0cKpp8P8QUiikowpfj6+uRZ8rZsxb51K36rNeR1XV4epvXrMK5bj6FoCQrtHBTJp4gv4KPOWheMBN3fu59aay1+yR/STqlQkhuZG5RUhXGFIu1PIDgOXY2D7HyjjtZqeSIRtVbJ4nNTKTo/DZ1hdkdR+/r66P390wy89FJwIojwCy8g/jvfQZuRMWnXmSgCJ+BwUFNcMmnXOBXm7SlDaTg5Of/aa6+xYcMGnE4nxcXFnHXWWVx11VUUFhYG2ygUCr71rW/x1FNPBY+tXLmS4uJinnzyyZOKlLrxxhupra0NOpInn3ySn/3sZ3SOzKKYk5PDAw88wNVXXx28xoMPPsi7777L9u3bj9n/yspKVq1ahcvlwmQy8eKLL/LFL35xwrYzPn0P5ELny5cv57e//S0gS6a0tDRuv/32cYXOXS4XtbW1Icd++tOfMjQ0xOOPP05eXh7aE9xACCklCEGSYP9r8K97YVDOhcayCM67T35QmkMPSD5/gFfLWnl802E6bHKeelackf88fx4XLkxAqZw7n1UgOFW8AS+H+g9R0VPB3p697OvZR9tw27h2YeowFsUuojCukEWxi1gUu4g4Q9w09HgW4nFA41ZZUB3+Fww0hL4ekQw558qpfllng178Rgs+G5Lfj3PfPuxbtjD88RZcVVWh0VAmE8bVq0dE1Do0FpGSdjI4vA6q+6up7K0Mfl92ObrGtQvXhLMoTv6+XBy3mMK4wqmdNVQgmAX0t9vZ9VY99RU9AChVChasT6bkgnSM5rmV3eNpbaX3t7/F9tbf5e9ejYboa68l9tb/mJQJIWazlAK5/1u2bGHnzp289957fPLJJzz77LPccMMNgCyl/vSnP3HdddcFz/nud79LRUUFH3744UlJqdtuuw27fWxA9fXXX+eyyy4jEAhgt9sxmUyEhYWhPGKWWJ/Ph9lspqtr/Pf6KB6Ph+bmZmw2G6+++irPPvssH330EQUFBRN+zhmfvnfXXXdx/fXXs3TpUpYvX85jjz2G3W7nxhtvBOC6664jOTmZhx56CL1ez8KFC0POH53u8OjjAsEJ6dgH7/0QmkcssDlNTtNbeBlM0fTN04lapeSq5WlcWpTM/+1s4ncf1lLfY+e2F/cwPyGc75ybyxcWCDklODPod/Wzt3tvUEJV9Vbh8rvGtcs2ZwdH/RfFLiInMgeVcnaE0884tAbI+7y8APTVjdWiatwqDwzs+bO8KNWQumIsisqycE4NEgimDl9vrxwJteVjhrdtJ2ALnWRAl5+Pad06TOvXEbZ48WmbJWouYdAYKLYUU2wpDh7rsncFI0v39uyVZxj1DrG9fTvb28dG27PN2SyJX8LiuMUsjl8soqkEZwz97XZK323gcFk3SPJP2rwVCSz7UiYRsXNzpmxtSgpJv/gF0TfdRPevfoX94y30//GP2N56i/i77sJ86SUoJvmZSxEWxrw9ZZP6nqdy7VNBr9dz/vnnc/7553PPPfdwyy23cN999wWl1GSgOeo3TqFQMBpzNDw8DMAzzzzDihUrQtodmZk2EVqtlpycHABKSkrYvXs3jz/+OE8//fRkdT2EKZdSV155ZXBKxM7OTpYsWcI//vEPLCOjVc3NzSHmTiD4zNj74MMHoWyjXMRcHQbr7oLV3wbN3PxROBK9RsUt67K4clkqz25p4A9bG6juHOI/XtjDPEs43zkvlwuEnBLMIfwBP7XWWvb27GVvz14quitoHmoe1y5CGxEyor8wdqEY1Z9KYrLlZcX/A68TmrbB4ZFaVH218n7TNth0P4QnhkZRhUVOd+8FMwTJ58O5bx/DH3+M/eMtuA4cCHldGRGBcc1qTOvWY1y7Bk18/DT1dG5jMVqwGC2cl34eIEef1g7UBiXV3p69NA81U2ero85Wx2uHXwPk793FcYtZHLeYJfFLWBS7SNSmEswp+tqHKX23kdoRGQWQtSSOFRdnEZ10ZsxOq583j7T//V+GP/qIrocextPYSMfddzPw0ksk/ORuwhYvnrRrKRQKFKcQrTSTKCgoGDd5286dO0MipXbu3ElRUdGkXM9isZCUlER9fT3XXHPNZ3qvQCAQMrncZHNaCp3ffvvt3H777RO+tnnz5uOeu3HjxsnvkGBu4vdB6R/gw5+Da2TkdOFlcP7PZsWMepNNuF7Dd8/P48Y1GfxxawPPbWukpmuIW0fk1B3n5oq0PsGsxOF1sK93H+Xd5VR0V7CvZx/D3uFx7bLN2SyOX8ySOHnUPsMsRuynDU3YWAF0Hob+hrEoqoaPYagDyv9PXhQqSF0+1j6hcE5GtwqOjbere6Q21Bbs27cTGAydMU5fUIBx/TpM69cTVliIQj2j5u05I9AoNeTH5JMfk8+V868E5Dp9+3r2BSNU9/fuZ9AzyJa2LWxp2wKASqEiLyqPovgiiuKLWBK/hARjwnR+FIHgU9HXNiKj9oTKqKUXZRCXemZO8mE66yyMq1bR//z/0fvkk7j27aPxyqswX3opcXd994wZNOjr6+OKK67gpptuorCwkPDwcEpLS3nkkUe45JJLQtq+8sorLF26lLVr1/LCCy/wySef8Ic//GHS+nL//fdzxx13YDabueCCC3C73ZSWljIwMMBdd9014Tk//vGPufDCC0lLS2NoaIgXX3yRzZs38/77709av45G/IoL5gb1H8E/fiRPXQ5y3agLfwEZa6a3XzOASIOWuz4/j5vXZvGHbQ08t7WBmq4hbntxD3kWE3ecm8sXFyYKOSWYsXTaO6norqC8u5zy7nIODRwaV4TXoDawKG4RS+KWBEfjzTrzNPVYcEKiM2H5BnnxuuQ069Eoqt5D0LxDXj54AIzxI4LqXMj+HBiip7v3gklG8npxlJdj3yKLKHd1dcjrKrMZ45rVGNetx7R2Deo4UedtJhITFsM5aedwTto5AHj9XmoGaoIRrBU9FXTaOznYf5CD/Qd5sfpFABKNiSyJXxIUVbmRuSKNWjBj6WsbZvc7jdTt6Q4eyyqKY9lFGcSmnJky6kgUWi0xN9+E+eIv0/3r32B7/XVsb7zB0D//SexttxJ97bVzfpIJk8nEihUr+M1vfkNdXR1er5fU1FQ2bNjA3XffHdL2/vvv56WXXuLWW28lMTGRv/zlLxPWbfq03HLLLRgMBh599FG+//3vYzQaWbRoEXfeeecxz+nu7ua6666jo6MDs9lMYWEh77//Pueff/6k9etoprzQ+elGFDo/wxhokqchP/h3eT8sGj73Uyi5AcQNzYTYHF7+uK2BP25rYMjlAyA3fkROLUpEJeSUYBoJSAHqrHXs6drDnu49lHeX02HvGNcuwZhAUVxR8EEmNyoXtVKMs8wJBprkKKraf8sDDkfOiKhQQnKJnOaXex4kFokoqlmKt6NDjoTasgX79h0E7Ef+OyvQL1wYrA2lX7QIxQnqXwhmB532zuAAQ0V3BTUDNQSkQEgbo8ZIYWwhRZYiSuJLWBS3iDD13C+/IJjZyDKqgbo9PcFj2UVxLL0ok9gUMSPvsXDu3Uvnz/8b1759AGjT04n/8Y8IP/vsE557vALacwGFQsHrr7/OpZdeOt1d+UzMitn3TjdCSp0h+L2w43ew+WHwOeV0j2W3wNk/EqPoJ4nN6eW5bXLNqVE5lRVn5Fvrs7m0KBmtWjzoCaYej99DVV9ViIQa8gyFtFEqlMyLmhcyki7SPc4QfB45YmpUUnWH1hPCECNHT+WcJ69NZ0ZqwGwk4HbjKC2Vo6G2bsFTWxfyuio6GuPaNZjWrcO4Zg3qaPFbfiZg99qDKX8V3XLan/1IEQ2oFWoKYgrk739LEcXxxUTpo6apx4Izjc56G2X/aKJxX2/wWHZxHMsuyiQmWciok0EKBLC9+Rbdv/oV/l75v2P4+edh+elPjzsrqpBSswMhpSZASKkzgLYyeOs70FUp72esk1P1LAumt1+zFJvTy8Ztjfxhaz2DI3IqIULPLesyuXp5GkadiD4RTB5DniEquivY072HPV172N+7H0/AE9ImTB1GYVwhxfHFFMUXURhXiFFzZhQLFZwAWyvUbpLT/Oo/AndorSESF4/VokpZBiox89p04mlqYnjLVoa3fIxj1ydIriNmwFQqCSsslGtDrVuHfsGCSZ+lSTD78Af8HLYelqOpusop6y6j29E9rl2mOZPieHmGwOL4YpJNySjEDJ6CSUKSJJoP9LPnH020H7bKBxWQXRTPsosyhIz6lPiHh+l98in6//xn8PlQmkzE/+ddRF555YTf/0JKzQ6ElJoAIaXmMO5huYj5rt/Ls+qFRcHnfw5Lvi6mEp8Ehlxe/vJJM89uaaB7SJ5dIdKg4fpVGdywOoMo49zO/xZMDb3O3mAU1J6uPROmakTro4MCqthSzLzoeWiUQiYIToDfC627x6KoOvaGvq6LgKyzIPtcuR5VZNr09PMMImC3Y9/1iVykfOtWvM2hs2Cq4+IwjqTkGVetQmUWdd8Ex0eSJNrt7WPRtF3l1NnqxrWLN8RTYimhJL6EEksJWZFZYmILwSkTCEjU7elmz/tN9LbIE6goVQrmrUig6PNpRCWIAbLJwFVTQ8c99wZT+sKKikj82f3ocnND281xKTVXEFJqAoSUmqMceh/e+U+wtcj7i74GX/hvMIlip5ON2+fnb3vaePqjOhr7HACEaVRcvTyNW9ZlkhQp6joIJkaSJNqG29jTvYeyrjL2dO2hcbBxXLvU8FSK4ososZRQHF9MekS6GOEWfHaGu6HugxFJtQmc/aGvx+aNCar0NaCdnVNKzySkQAB3TQ3DW7Zi37oVR3k5eL1jDTQaDMXFmNatxbhuHbq8PPG3LvjMWF3WYF2qsu4yDvQewCf5QtqYdWb5d2ZEUs2PmS8GOwTHxOf1U7Ozkz3/bGawxwmAWqdiwdokFp+bSni0ECKTjeT3M/DiX+j5zW8IOByg0RBzy83EfutbKHU6QEip2YKQUhMgpNQcY6gL/vFDqHpd3o9Mg4t+Ixe4FUwp/oDEP/Z38uTmWqra5RQZtVLBpUXJfOusLHLixQwjZzqSJNFga6C0q5SyrjLKusrocnSFtFGgICcqJ/hgUGwpJt4g6v4IppiAHzoq5Bn96jbJEVVHRuipdJC+emRGv3MhPl9E3J4kvr4+7Nu3y9FQ27YH64OMoklJkWtDrV+PYfkKVCYRWSCYWhxeB5W9lezp2kNZdxn7evbh9DlD2oSpw1gct5gSSwlLLUtZFLcInUo3TT0WzBQ8Th/7t7Sx998tOAblUgJ6o4bCz6Ww6KwU9CYhMqcab0cHnT97gOEPPwRAm5FBws/ux7h8uZBSswQhpSZASKk5giTBnj/Dv+4Bl02ecWnVbXD2j0ErbnBPJ5IkseVwL09trmNHfV/w+Dnz4rh5bRZrcmLEyPcZQkAKcHjgcIiE6neFRqOoFWoKYguCEmpJ/BLMOpGiI5hmnANyDaq6TVD7AQy2hr4enjRSMP1zkHk2GGOmo5czEsnjwVFegX3bNuxbt+I6EFpsXmEwYFy+HOPatZjWrkGTLiIfBdOLN+DlYN/BYMTunu49DHpC689plBoWxS5iacJS+bcqbgkGjYiePFMY7HWy78NWDmxrx+vyA2CK0rHkvDQK1iah0YnZPk8nkiQx9M9/0fngA/h75IEO8+WXYf7Od2ju7RVSaoYjpNQECCk1B+irg7fugKat8n7iYvjy/0DSkmntlgDKmwd4anMd/zrYxeg3x/yEcG5am8klS5LQqcWP+FzCF/AFb+xLu0rZ071n3Mx4OpWOwrhCllqWUmwppjC2UNzYC2Y2kgS9h+QUv7pN0LhNnsU1iEL+3cn+nLykrgD1mVNTT5IkPA0N2Lduk0XU7t1IDkdIG11+Pqa1azCuWUtYcRFK7Znz30cw+xgdUBlNLS/tLKXP1RfSZnSGvxKLPKBSZCkiQiueI+YSkiTRWT/I3k3N1Jf3BO9joxIMFH0+nbzlFlRi5ulpxT84SPevfo315ZflAwUFBH76E7ILCoSUmsEIKTUBQkrNYiQJSv8I//wpeB2gMcA5P4EV3wKVmAFuJtHYa2fj9kb+WtqCwyOPMMWatFy7MoNvrEwjxiRC4mcjXr+Xqr4qSrtKKe0spby7HIcv9GHUoDZQFF8UHF1eELMArUo8kApmMV4XNG+XJVX9ZujaH/q6xggZa8YkVWzenEv18w0M4Nixg+Ft27Bv34GvoyPkdVVMDMbVqzGuWY1pzRrUcaKeo2D2IkkSTYNNwYjf0q5SOuyh/88rUDA/er6c7pewlJL4EiL1kdPTYcFnIuAPUFfeQ8W/W+huHIuYSy2IZvG5qaTlR6NQzq3v9NmOo6yMjnvvw+Vw4P/pT8jIyiI8NRWFWjwPzkSElJoAIaVmKYPt8Obt8qg1QMY6uOQJiMqY1m4Jjo/N4eWl3c1s3N5Ih02e6lurVvKVJcncvC6TPIuoOzWTcfvd7OvZJ6fjdZaxt2cvLr8rpE2ENoLi+GKWJixlqWUp86LnoVaKmwLBHGaoU5ZTdR9A3YdgP2o6+ohkyDoHss6WZ/czzb4aaQG3G2d5OfbtO7Bv346rqgqOuB1UaLUYlpZgXLMG45o1coHyCabrFgjmCu3D7UFBVdZVRtNg07g2uVG5LLXIv4UllhJiwkSa70zG7fBStbWdyg9bGR6QZ5VWqZXkrbCw+HOpxCSbprmHguMR8Hjo2LiRvuxs0uLi0Gt1aJKTUYWLf7eZhpBSEyCk1CxDkmD/a/DOXXLtKLUezvsvWP7/QNwAzxq8/gDv7e/kD1vq2dtqCx5flxvLDaszOHtePCoxCjXtuHwu9vbspbSrlN2du6nsqcQT8IS0idJFBUeGl1qWkhuVK6bVFpy5BALQXSXLqboPoGk7+N2hbSwLRwTV2XLx9BlY91AKBHBXV8sFyrfvwFFWhuQO/Ry6vDxZQq1ejWFpCcowMdOq4Myl29EdTPUr7Sql3lY/rk2mOZNllmXB38s4g4ggnAkMdNqp/KiNg9s78LnlaP6wcA0Lz0ph4fpkDBEiunu24HK5qK+pIVmrReuX/y1V0dFoLBYUqrlfMqSxsZHMzEzKy8tZsmQJmzdv5pxzzmFgYIDIyMjp7l4QIaUmQEipWYS9T5ZRB96Q95OK4Cv/C3F509otwadHkiTKmgb4w9YG3q/qJDDy7ZISFcY1K9K5clkq0UZxM3C6cPqcVHRXBNPxKnsr8Qa8IW1i9DHBG+qllqVkR2aLIsUCwbHwOmUxVb8Z6j+EzsrQ15UauQbVqKRKKpq29HNPa6ssoXbswLFjJ36rNeR1dVwcxtWrMKxahXHVajSW2RfxJRCcLvqcfcFIqtKuUg4PHB7XJiMiI+T31GK0TENPz0wC/gAN+3qp3NxGW81A8Hh0kpHF56aSt9yCWjP3JcZcY1R2ZKSno7ba8PXLteAUWi2a5BRUxplbw7Snp4d7772Xd955h66uLqKioli8eDH33nsva9asOan3OFpKeTwe+vv7sVgsp+1e/eGHH+bHP/4x3/nOd3jssccmbCOk1AQIKTVLOPQ+vPVtGO4CpRrW/wDW3QUqMfXqXKGl38GfdzTy19JWbE5ZhGjVSr5UmMi1K9NZkhop5Mck4/A6ghJqd+du9vftxxfwhbSJN8TLN8wjN84ZERni30Eg+LTYe6Hho5F0v81gaw59XRcB6Wsgc728xBdMWRSwr6cH+65PcOzaiX3nLrwtLSGvKw0GDMuXy7WhVq9Cmy0EtEDwabG6rJR1y5FUZV1lVPdXIxH6SJUWnsayhGWUWEpYlrCMBGPCNPV27mK3uTmwtZ2qLe3YrXL0p0IBGYWxLDo7hZT5UeJ7bhZztOzwDw/jbWtD8srPFerYWNTx8TMyvXz9+vV4PB4eeughsrKy6OrqYtOmTSxYsICLL774pN7jaCl1utm9ezdf+9rXiIiI4JxzzhFS6lQQUmqG4x6C9++GPX+W9+Pmw1d+L48mC+YkLq+ft/a28/yOJirbxlL7FiWbuXZlOhcvSUIvRq8+FQ6vg/LucnZ37qa0q5Sq3ip8UqiESjAmsNSylGUJy1hqWUpqeKq4QRMIpgJJgv76kSiqzdDwMbisoW0MsZC5bkRSnQXRWZ+6aLrfZsOxezf2HTux79qJp7YutIFaTdjixRhXrcK4ehVhixah0IiBH4FgKrC5bSG/x9X91QSkQEib1PDU4O+xkFSfHkmS6Ki1UflRK/V7egiMhOWHhWsoWJPEgvXJhEeLmdrmAhPJDsnvx9vREYz+Ver1aFJSUM6g2fmsVitRUVFs3ryZs84665jtFAoFTz75JG+99RabN28mMTGRRx55hMsvvxw4cfrexo0bufPOO3n55Ze58847aWlpYe3atTz33HMkJiYGr/Pss8/yq1/9So46y8jgjjvu4NZbbz3uZxgeHqa4uJgnn3ySBx98kCVLlkyplBLVagWnj6Yd8Po3wdoMKGDVbfC5e0Azc75EBJOPXqPia0tT+drSVCparDy/o4m/72unss3GD17bx8/fPcjXlqbw9RXpZMbOvFosMwm71z5209tZSlVfFX7JH9ImyZgUjIJalrCMZFOykFACwelAoYCYbHlZdjME/NC5T5ZTDR/LaX+OXqh6XV5ALpo+GkWVsQ4iU4/59v5hO87yPdh37sSxcxeuAwdCipOjUKDLn49xxUqMK1cQVrIUlUl8pwoEpwOzzszZqWdzdurZAAx5hijvLqe0U45cPtB/gJahFlqGWni9Vv77TzGlsDRhRFJZlpFoSjzOFQQel49Dn3Sx/6NW+trsweMJWWYWnpVMTnE8Ks3Mi5gRTDJKJYq4RBR6I972DqQhJ+7qWtRxcahjYqb0nletVZ7U+5tMJkwmE2+88QYrV65Epzv2rOT33HMPDz/8MI8//jjPP/88V111FZWVleTn559UnxwOB7/85S95/vnnUSqVfOMb3+B73/seL7zwAgAvvPAC9957L0888QRFRUWUl5ezYcMGjEYj119//THf97bbbuOiiy7ivPPO48EHHzypvnwWRKSUYOoJ+GHLr2Hzf4MUgMg0uPQpyFg73T0TTBP9dg9/LW3h/3Y20TrgDB5fmRXNVcvSuGBhgoieAoY9w+zp3hOsCXWg78A4CZVsSh6LhEpYSrIpeZp6KxAIjovPA21lY5Kq9RPwh040QGSaLKcy1uKPK8JZ14Pjk0+wf7JbniHPH/r3r83KwrhyBYaVKzEsW4Y6Kuo0fiCBQHCyDHuG5UGlrt2UdZZNOKgkfs/HI0kSXQ2DHNjazuGy7mDhcrVWSd7yBBaelUxcqpjpea4yUQSO1+3nf7/z0bT055uPn4VGd3LPJ6+99hobNmzA6XRSXFzMWWedxVVXXUVhYWGwjUKh4Fvf+hZPPfVU8NjKlSuDEUonEyl14403UltbS3Z2NgBPPvkkP/vZz+js7AQgJyeHBx54gKuvvjp4jQcffJB3332X7du3T9j3l156iZ///Ofs3r0bvV7P2WefLSKlBLOcoU742wb5Bhxg8dXwxUdBJ35AzmSijVq+dVY2G9Zl8dGhbp7f0cRHh3rYWd/Pzvp+It5U85WiZK5clkZB0pkjlycaWT06/D/FlBK8YV1qWUqSKWmaeisQCE4JtRbSV8nL2T8EjwNado1Iqo/wN+3FeaAL++a/4+h+H9eABqTQEVlNSopcF2rVSgzLV4ji5ALBLMGkNbEuZR3rUtYBY5HPpZ2l7O7aTVVvFW3DbbQNt/Fm3ZvAWOTzaPr9mRT57Bz2ULOzkwPbOhjoGIuKikowsGBdMvNXJaAziHRkwczlsssu46KLLmLLli3s3LmT9957j0ceeYRnn32WG264Idhu1apVIeetWrWKioqKk76OwWAICimAxMREuru7AbDb7dTV1XHzzTezYcOGYBufz4fZbJ7w/VpaWvjOd77Dv/71r3GCaSoRUkowddT+G/72/+R0BY0RLvoVLLn6xOcJzhhUSgWfm2/hc/MttFudvFrWysu7W2izOvnTjib+tKOJwhQzVy5L5eLFSYTr59YNyJBniD1de4KFyQ/2H5ywBsXoDelSy1IR3i8QzBF8djfOBj+OUj2O0hhcBxIgEPr3rzH6MMS7McZ7MMR70CSpIb0XkvpAaQUp7lPXpBIIBNOHUWNkbfJa1ibLWQOjNSJH7weqeqtot7fzVt1bvFX3FgCJxsSx+4GEpaSYUuaUpJICEq3VAxzY1k793h4CPjmZR61VklMST8GaJBKyzXPqMwtOHbVWyTcfH1+nKeBy4W1rI+CWC96rY2JRx8dN6v8vau2ppYfq9XrOP/98zj//fO655x5uueUW7rvvvhAp9VnRHFUrUqFQMJoINzw8DMAzzzzDihUrQtqpVBNHfJWVldHd3U1xcXHwmN/v5+OPP+aJJ57A7XYf89zPgpBSgsnH74UPHoRtj8n7loVwxUaIzZ3OXglmOEmRYdxxbi63n5PDtrpeXtrdwj+rOtnXamNfq40H3z7IRYWJXLkslaXps3M2lUHPIHu69hy3EGpaeFpITShRCFUgmBt429txlJXhKC3DUVY6vjA5oElLw7B8GcblyzEsLkDjbYTGbdC4Fdr3yLP77WuGfS/JJxhi5cirtNXy2rIIVOLWTiCYbRg0BtYkr2FNsjxV/Ohsuru75BqS+3v302HvCJFUR05kssyyjJTw2Smphvpd1Ozs4MC2Dob6XMHj8enh5K9JIneZBV2Y+F4TyCgUiolT6HRGtOE5eDs78ff3w2Afks+JOiUFpVZ7+js6AQUFBbzxxhshx3bu3Ml1110Xsl9UNDkTgFksFpKSkqivr+eaa645qXPOPfdcKisrQ47deOONzJ8/nx/+8IdTIqRASCnBZGNthldvlmtlACy7BT7/c1HMXHDSKJUK1uXGsS43jn67h7/tkaOnDncP82pZK6+WtZIWbeArRcl8tTiZ9JiZW8jX5rZR1lUWrAl1vCmjR0WUkFACwexHCgTw1NePCChZQvnaO8a10+ZkYyhZimFpCYZly9AkHP33nwM558mb7mE53a95hzxxSOtuORL54N/lBUBrgtTlY5IqqRi0hqn9sAKBYNIxaAysTl7N6uTVwIik6qmgtLOU0q5SKnsq6bR38nb927xd/zYA8Yb4YCTVsoRlpIWnzVhJ5XH5qC/voXpnJ22HBhi9NdIZ1OQtTyB/TaKoFSU4ZRRKJdqkJPxGoxw15XDgqatDk5yM6jTWmu7r6+OKK67gpptuorCwkPDwcEpLS3nkkUe45JJLQtq+8sorLF26lLVr1/LCCy/wySef8Ic//GHS+nL//fdzxx13YDabueCCC3C73ZSWljIwMMBdd901rn14eDgLFy4MOWY0GomJiRl3fDIRUkoweRz8O7x5G7hsoDPDJb+FgktOfJ5AcAyijVpuWZfFzWsz2dNs5eXdzbyzr4PmfgePbzrM45sOszQ9iq8UJ/OlRUmYp7m+gNVlHZNQXaXU9NeMk1AZERmUWEqCN44Wo2WaeisQCCaLgNOJs7IS555yHOV7cFbsJWCzhTZSqdAXFGAoKcGwtISwkpJTK0yuM0HOufIC4HNDe7k8q1/zDmjeCe5BqPtAXgCUakhcDKkrR2TVSggX4lsgmG0YNAZWJ61mddKYpNrbs5fdnbsp6ypjX+8+uh3dvFP/Du/UvwNAfFg8JQklQUmVEZExrZIqEJBoPdhPza5O6st78HnHIsWT8yLJX5NEdlEcaq2Y6Ebw2VCZzSjCwvC2tBBwOvE0N6OOjkGdYEGhnPoZGk0mEytWrOA3v/kNdXV1eL1eUlNT2bBhA3fffXdI2/vvv5+XXnqJW2+9lcTERP7yl79QUFAwaX255ZZbMBgMPProo3z/+9/HaDSyaNEi7rzzzkm7xmQgZt8TfHa8LvjnT2H3M/J+8lK4/A8QlTGt3RLMTZweP/880Mlre9rYeriHwMg3mFal5LyCeL5SlMJZeXFo1VP/o9Pn7AuRUIcHDo9rk2nODN4QllhKiDeIwsQCwWzH29WNs3wPzvJyHHvKcR08CD5fSBuFXk9YYWFQQBmWLEFpnMLIzoAfuqpGIqm2y5JquHN8u8h0WU6lLpdlVXw+KMVDoEAwm3H6nOzt2RucKKWytxJvwBvSJkYfE1IeIMucdVokVW/rMDW7Ojn0SScO29iMo5EWA/NWJpC33EJETNiU90Mw+zjerG4ngxQI4OvqxtfXC4BSr0eTmopSp5vsrn4qFAoFr7/+Opdeeul0d+UzMRmz750WKfW73/2ORx99lM7OThYvXsxvf/tbli9fPmHbZ555hj//+c/s378fgJKSEv77v//7mO2PRkip08xAI7x8LXTuk/dX3wHn3guquVWQWjAz6R508WZFO6/taaW6cyh4PNqo5cuFiVy8JJnitMhJu+nqdfYGQ+dLO0ups42vCZNlzgqZ0jk2LHZSri0QCKYHyePBVV2Ns6ICZ8VenHv34m1rG9dOHR9PWHExhqIlhBUXo58/H4VmGn8LJQmsTdC8S077a9klS6ujojfRRUByCaQsG1mWgiF6WrosEAgmB5fPxb6efcGaVPt69uEJeELaROujKbGUUGKRo6lyo3JRKiZnQG+o30VtWTc1uzrpax0OHtcbNeQujWfeykTiM8JnbHqhYGbwWaXUKP6hIbytrUh+PwqlUk7nO8bsc6cTIaXGmHIp9fLLL3Pdddfx+9//nhUrVvDYY4/xyiuvUFNTQ3z8+IiBa665hjVr1rB69Wr0ej2/+MUveP3116mqqiI5OfmE1xNS6jRSuwleuxmcA2CIga88DbnnT3evBGcoB9oH+dueVt7c207PkDt4PDkyjC8VJvLlxUksSIo4pRugTntnUECVdZXRONg4rk1uVG5wZrwSSwkxYTGT8XEEAsE04e3owLl3ryygKipwHTiA5Al9mEOpRJeXh6G4iLCiYsKKitAkJ838ByyXDVpLR2pT7ZS3vfbx7WJyjpBUyyC+QBRQFwhmMW6/m8qeyuA9zd6evbj8rpA2Zp2Z4vji4Ox+86LmoTqFKEq7zU3dnh5qS7voqBtLX1aqFGQUxjJvRQLpC2NQnYZIdsHcYLKkFEDA65XT+RwOANSxsagtlmn93RZSaowpl1IrVqxg2bJlPPHEEwAEAgFSU1P59re/zY9+9KMTnu/3+4mKiuKJJ54IqUx/LISUOg1IEmz9DXzwAEgBuZDqlc+DOWW6eyYQ4PMH2FrbyxvlbfzrQBd2jz/4WkaMgS8vTuJLhUnMSwgtoClJEq3DrUEBVdpVSttwaDSEAgXzoucFJVSxpZgo/SnUhBEIBDMK/7AdV1UVrv2VOPfuw7l3L76urnHtVJGRhC1eTNiSxYQtXoy+sBCVyTQNPZ5k/D7orpKLpreWyuu+2vHtNEZILpYjqkaXiCSY6RJOIBBMiNfvZX/f/mD0d3l3OU6fM6SNSWOiKL6IpQnyoFtBTAEaZWj0p2vYS115N4dLu2k/NMCRT5WJOWbyllnIWWpBbxQZFIJTZzKlFMj3+r6uLny9I+l8JhPalBQUajHo8lmY8VLK4/FgMBh49dVXQwzg9ddfj9Vq5c033zzhewwNDREfH88rr7zCl770pXGvu91u3O6xqIjBwUFSU1OFlJoq3ENyMfMDI/92RdfCF38pZtcTzEhcXj8fVnfz9r4ONlV34TqiqGauxci6fIm4uDYa7fLoYbejO+R8lUJFfnS+HNqesJSi+CLMuukP9xUIBKeO5PXiOnQIV2Ulzn2VuCr34a6tg6Nvg1Qq9PPmBQVU2OLFaNLTZ34U1GTh6B8TVK27oa1MLqB+NKaEEVE1IquSiiBMSHqBYDbiDXg52HcwGElV3l3OsHc4pE2YOozFcYspiVxOev8CPIfCaK+2EgiMfYdaMiPIKYknpyQeU5R4NhB8NiZbSo3it9nwtLVBIIBCo0GbloYyTNQ1+7RMhpSaUi3Y29uL3+/HYgmdXcpisVBdXX1S7/HDH/6QpKQkzjvvvAlff+ihh7j//vs/c18FJ0FvLbx8DfRUg1IDX3wESm4UI6WCGYteo+LCRYlcuCiRQaebF8p38s7hbdQP7ac9rJ5XuuxwRFCESqFmUezCYCHQJfFLMGqmsDCxQCCYEiS/H09jI66qKpyV+3FVVk6chgeokxIJW1RI2KKFchTUwoVn9s2pIRryPi8vAIEA9B6C1k9kQdVWBl0H5CLqNe/KyygxOSOCqliWVAmLQGuYns8hEAhOGo1SQ2FcIYVxhdy08Cb8AT81AzXB6PHK1oNEt6cRVVmIx5ZOveQC5PQ/KcZJ8uJwVq1bQEKiKGEgmHwmO4ZGZTaj0+nwNDcjeTy46+vRJCejjoyc1OucKUzGv8+MjlV7+OGHeemll9i8efMx7eiPf/xj7rrrruD+aKSUYJKp+Qf8bYM8WmpKkNP1Uk+u+LxAMB14/V6q+qoo6yqjrKssZNRPNZK5p5A0+Jyp+OyZ+B2Z+J1ptERHUqBIICw2gTCVeJgSCGY6UiCAp7EJV9V+XPurcFbtx33gYLBuxJEoIyIIW7QIfeGioIhSx8VNQ69nEUolxM+Xl+KRMgoeB3RWjkmqtjIYaJBT//pqYd/LcjuFEuLmQ+ISWVIlLQHLQiGqBIIZjkqpIlWRhbcrnIiKhcw7bA0JKh009FATvZva2HJsYd3gBNW/xqLLSywlFFuKRXS54DOhGZksxOFwEDbJg0VKvR5dVhae1lYCw8NyIXSnU64zpRR1z04Fx8j9luYzTO4yY9P3fvnLX/Lggw/y73//m6VLl570NUVNqUkmEICPfgEf4seDQgABAABJREFUPSzvp66Er/0JwhOmt18CwVE4vA4qeirY07WH8u5y9vXsG1fE06gxUhRfFJxppiCmALsL/n2wi/erOvn4cC8e31iKnyVCx+cLErhgYQLLM6PRqMSPlEAwnUh+P56mJlwHDuLav1+uB3XgAAH7+GLdirAw9Pn56BcsIKywkLDCRWjS0s6cNLzTjaMf2vbIgqp9D7SXw/D4+lwoVLKoGpVUiYvBsgC0IipVIJhuBjrt1Ff0UF/eQ3fTUMhrsakmsoviyFwSR1SCgZbhluDAX1lX2bg6nAA5kTkUxxdTbCmmxFJCglE8PwhOjY6ODqxWK/Hx8RgMhkn/DZckCV9fH/7+fgCUYWFoEhKmd/bcWYIkSTgcDrq7u4mMjCQxMXFcmxlRUwrkQufLly/nt7/9LSAXOk9LS+P2228/ZqHzRx55hJ///Oe8//77rFy58pSuJ6TUJOKywd++CYf+Ie8v2wBf+G9Qa6e3XwIB0Ofso7y7nD3de9jTtYfq/mr8kj+kTZQuKjhiV2IpIS8q77gzydjdPjbX9PB+VScfVHcz7PYFXzOHaTg3P57z8i2sy40lXC9+rASCqSTg8eA+fBj3wYO4DhyQRVRNDZLTOa6tQqcLCij9woWELVyANisLherkZ44STAGDHdBRIQuq9pG1vXt8O4VSTv1LKJQlVWKhvG2IPt09FgjOKAIBia6GQRore2mo6GGg84gIUwUkZpvJWhJH1pI4ImKPH6nSae8MkVT1tvpxbZKMSRRbioMDhFnmLDFQIDgukiTR2dmJ1Wqd0usEXC78AwNynUmlEnV0NAqteOY9GSIjI0lISJjwb3nGSKmXX36Z66+/nqeffprly5fz2GOP8de//pXq6mosFgvXXXcdycnJPPTQQwD84he/4N577+XFF19kzZo1wfcxmUyYTmKmGyGlJomeQ/CXq6C/DlQ6+PJjsOTr090rwRmKJEm0DrVS3lPOnq49lHWV0TjYOK7d6M1OsaWYkvgSMs2Zn/pmx+3zs722j/erOvnngS767WO1aNRKBcszo/nc/HjOzbeQGStG+AWCz4J/aAh3TQ2ug9W4RiSUu64OvN5xbRV6Pfp582QBNSKhdNlZYvac2YAkwWB7qKjq2DuxqAIwp8qSKqFQrk+VsFA+Jh5iBYJPjdvhpflAP02VfTTt78NlH/ueVaoUpMyPImtJHJmL4zBEfPqH8n5XP+Vd5ZR1lx1z8DBSFxkUVEXxReRH56NRiUE/wXj8fj/eCe4JJhNPSwudDzyIt6UFhUZN7O23E/H5z0/pNWc7Go0G1XEGAGeMlAJ44oknePTRR+ns7GTJkiX8z//8DytWrADg7LPPJiMjg40bNwKQkZFBU1PTuPe47777+K//+q8TXktIqUmgfjO8fB24bfLN35XPy2H2AsFpwhfwUdNfE4yEKu8up9fZO67d6QoL9wckdjf2s+lgF5uqu6nvCU0Vyoo18rn58XwuP55lGSLNTyA4FlIggLe1FVd1Ne7qGlw1NbgPHsTb3j5he2VEBPqCAjkKqiAffX4+2sxMEQE11xjqhI590LlXXnfsBev4e0EA9Ga5LpVloSypLAshPh80Z3BxeoHgOEiShLXLQWNlH02VvbTX2pCOmDFPZ1CTVhBN+qJYMhbFoDNMjRSye+3s7dnLnq497Onew76efbj97pA2epWehbELKYovothSzOK4xYRrw6ekPwLBRPiHh2n/0Y8Y/vcmAGJuuZm4u+4SdaY+JTNKSp1OhJT6jJRthHf+EwI+uX7UVS+AMXa6eyWY44zeqFR0VwRvVJy+0BQdtVLNgpgF8o1KvBz6HamPnJb+NvTa+aC6mw+qu9hV34/viJu7cJ2a9fPiOCsvjvW5cSSYxZTIgjMT/9CQnH536JAsn6prcNfUTFiAHECdmIg+Lw/9ggJ0+fno8wvQJCeJ1I4zFadVLqbeOSKpOvdDb418f3I0CtVI+t+IpLIsgPgCMKeIqCrBGYnX46f9kJXmA300VfZh6wm9p4pKMJCxKJaMwhgSsswop2EwbXRCmj3deyjvKqe8pxyb2xbSRoGC3Kjc4L1fsaVY1KUSTDlSIEDvE7+j98knAQg//3ySHvnFmT0z76dESCkhpU6NgB/+fR9sl2t/segKuPgJ0IgHasHkIkkS7fZ2KrorKO8uZ2/PXg4NHCIgBULahWvDWRK3JFh7YEHMAvTqmff/46DLy9bDvWw62M3mmm767KFTzudZTKzLjWNdbiwrMmMI04oID8HcQvJ4cDc04D50SBZQhw7hPnQYX0fHhO0VWi26nBx08+ejnz8P3bz56OfloRJTMQtOhM8NPTXQtV+WVF2V8trZP3F7nVmOorIUyJLKskDeD4s6vf0WCKYYSZLoaxumuaqfloP9tNdaCfjGHvGUKgXJeZHBaChz3MybATMgBWi0NQYj5Mu7y2kZahnXzmKwUBRfxJL4JSyJW0JedB4apUj5E0w+tr//nY67f4Lk9aJfsICUJ59EY4mf7m7NKoSUElLq5PHY4bUNUPOOvH/23XDWD8ToomBS8Pq9HOw/SEV3BRU9FVR0V9Dj7BnXLtmUTFF8UXDJjsxGqZhdobL+gMTeViubq7v5+HAve1tDp1DWqpUsz4hmfV4s63LjmJ8QLqJABLMGyefD09yCu/Yw7tpaPLV1uA8fwt3QCL4JolcAdUICurxc9Hl5snyaP09OvxP1nwSThSTBUMeYpOqqgu6D0Hto4qgqgPCkEVGVL88EGJcPcfNAd+LapQLBTMEx6KHlYD/NB/poOTiAczB0UMwUrSOtIIa0gmhSC6LR6mff926vs1cu5dC1h4ruCg72HxxXl+rIlL8l8UtYHLcYs848TT0WzDUcZWW03v5t/AMDqBMSSP39U+jnz5/ubs0ahJQSUurkGGyXC5p37JULml/6JCy6fLp7JZjF9Dp72du9l7098lLVVzWuZoBaoSY/Jj84yrUkfgnxhrk38mB1eNhW28eWwz18fKiHdpsr5PW4cB1rsmNYlR3D6uxYUqNn3sil4MxjQvlUW4unoQHpGEVGleHh6PLyxgRUXh66nBxUZvFgIJgmfB7oOwxdB6C7amR9EGzNxz7HnCpLqvj5QlYJZhxup4+Ow1ZaDw3QVjNAb8twyOtqrZLkeVGyhMqPJtJimHMDXw6vg6q+qpBo+0HP4Lh2meZMFsctDi6zcaBTMHPwNDfT8q3/wFNfj8JgIPlXvyT8nHOmu1uzAiGlhJQ6MR174cWrYKgdDLFw1YuQtmK6eyWYRXj9Xqr7q9nXuy8ootrt4wsWR+oiWRK3hMXxi2d0Kt5UIkkSdT12Pj7Uw5bDPeys78fpDR3tS44MY1V2DKuyZFGVFCly1wVTR8DpxNPQgLuuHk9Dvbyur8fT2HhM+aQIC0OXnS2n3+Vky/IpNxf1MaYCFghmHK5BWU51V8mpgN0HoacahruOfU5ECsTlQew8iM2VRVXsPLnmpvj/XjBFeFw+OupstNXIEqqneYijn9ri0sJJzY8mrSCahCwzKs2ZJV5GU/7Ku8uD0fgTzc5s0phYGLswKKkK4wpFNJXglPAPDtL6ne/g2LETlEosP/ohUddeK+59ToCQUkJKHZ+a9+DVm8Frl2+srvkrRGVMd68EMxhJkuhydLGvZ5+89O7jQN+BcVFQChTkROVQGFvI4rjFLIlfQkZEhvjSPgq3z09Z0wA76vrYUddHRYs1pGA6QHqMgZWZsqBalR2DJeLMEnmCz44kSfh7e/E0NuKub8BTXyev6+qOOeMdHCWfcnPQZmejy8lFk5QoZqARzE0c/bKk6jl48rJKHzkiqHJHhFWevB2ZDqrZlyolmF68Hj+doxLq0ADdjUMEjrovMMeFkTwviuR5kaTMi8YQoZ2m3s5cBlwDVHRXyAOmPXvZ37t/3OQ5ABkRGUFBVRhXSE5kDmql+LsVHBvJ66XzZw9gfeUVAKK+fjWWu+8WJQmOg5BSQkpNjCTBzifh/Z8AEmSdA1dshLDIae6YYKZh99rZ37ufyt5KKnsqqeytnLAWlFlnDgqoxfGLWRizEJNWpDqcKna3j9JRSVXfR2WrlaPuRUmLNrA0I4plGdEsy4giO84kZJ8AgIDDgaexUZZPDQ14GpvwNDTgaWwkMDx8zPNUUVFos7LQZWWhzR5ZZ2UL+SQQjOLol+tT9R6SZdXo9kATcIxbaKUaojJlQRWTDTG58uyAsblgjBPRVQJArgnVWWejvc5KR62N3ubxEio8Rk/yvChS8iJJnheFKUoMTp0qvoCPWmste7v3BkVV02DTuHZh6jDyo/MpjCtkUewiCuMKsRgs4j5LEIIkSfQ/t5HuRx8FScK4di3Jv/k1qvDw6e7ajERIKSGlxhPww3s/gN3PyvslN8IXHwWVmLHiTMcX8FFnrWNf776ggKqz1iEddcOtUqjIi8oLCYFOj0gXP9hTwJDLy+7G/qCkqmofHBe2H2XQUJIuC6qlGdEsSjajVQuRMFcJuN14W1rwNDXJ0qm5Wd5uaMDXdZxoDoUCTXIy2szMUPmUnY06SsxCJhB8KrxO6KsdkVWHoLcGeg9DXx1MEJURRBchC6qYbIjOgujssW1D9Onrv+C0IkkSth4nHbWygOqos2HtcoxrZ4zUjURBRZGcF0VErEjjnwoGXANU9lYGI6qqeqsY9o4fwIkNiw0KqkWxiyiIKSBcK+SDAIb+/W/avv8DJKcTXW4Oqc88gyYhYbq7NeMQUkpIqVC8LvjbBjj4FqCAL/wcVt4qRuvOQAJSgKbBJvb37qeqr4r9vfup7q8el4YHkGhMDPkxzo/JJ0wtbpCmg0GXl/JmK6WN/exu7KeixYrLGwhpo1MrWZwaSVFaJEWpkSxJjSLBLEZVZxMBpxNva+uIcBqRTk1NeJqb8HV0Ms5MHoEqKgptRgbazMyRdQa6jAw0aWkodbrT+CkEgjOYQAAG22RhNbr0HpbX1maOGV0FcjrgRLIqKgMMMeKebRbhcfnoaR6iq2GQrsZBOups42bHA4hOMpKYbSYxJ5LEbDPhMXox0DcNjNamOnJw9tDAoXEz/YGc9rcwdiELYxeyIGYB86Pnn3F1UgUyzqoqWv/jVnzd3agTE0l79hl02dnT3a0ZhZBSQkqN4bLBS9dA4xZQaeGrz8CCS6e7V4LTgCRJdNg72N+7n/19+6nqreJA34EJR4NMGhMLYhdQGFvIwtiFFMYVEhsWOw29FpwMHl+AqnYbpY0D7G7sp6xpgD77+BvehAg9S1IjWZIWyZLUSBYlmzHqRO77dCFJEv7+fjzNzXLUU0sL3uaRdUsLvp7xKbJHojSZ0Kano01PQ5OejjYtHW1GOrrMTFSRkafnQwgEgk+H1wUDDbKk6q+H/jroq5e3h45d4w0AbThEZ8iCKipTXkdnytvmVFHDahoJBCQGOux0NQ7KEqphkP724XFjCEq1AktGBInZkSTmmEnIMqM3imyFmYrT5+Rg30G5jMVIKYuJJvNRKVTkRObIkip2AQtjFpITlYNGKf5tzwS87e0037IBT309KrOZlN8/haGoaLq7NWMQUkpIKZmhTvi/y6GrUr6hufpFyFw/3b0STAGSJNE63MrBvoMc6DvAwf6DHOw7yIB7YFxbnUrH/Oj5wVGehbELSY9IF9PlzmIkSaKh105p4wDlLVYqWqzUdA6Oq0ulVECeJZyitEgKU2RJlWsxoVOrpqfjcxD/sB1vWyve1la8bW14WlvxtrbJ+62tBBzjUzaORBkejjY1FW1G+ph4GhFRquhoMYouEMxFPHbobxiTVf31srAaaJAjr46HQgWRqXKB9cg0iEqHyIyRdTqY4kWU1SQhSRJDfS56mofobhqiq9FGd+MQXvf4iBpTlA5LRgTxmREkZJmJTw9HrRG/tbOZPmcfVX1V8tIrZxv0ufrGtdMqteRF5ZEfk09BTAH5MfnkRuaiVYnC9HMR38AALd/6Fq69+1Do9SQ/9hvCzz57urs1IxBSSkgpua7B818BaxMY4+Ebr0Li4unulWASCEgBWodaOdB3QF76D3Cw7yCDnsFxbdUKNblRucHRm4WxC8mOzBYzjJwBODw+KlttVIxIqvJmK52DrnHtNCoF8xLCWZhkZmGyvMxPCEcvbp4nxD88jLetHW97G972dnlpbcPbJosnv9V6/DdQKFAnJKBNTUWTmoI2NQ1tWiqa1FS0qaki4kkgEITidcn3cgONsrgaaDhiuxEmSL8PQa2XZVVkuiyqzKmyxDKnyWtjPIiJDcYhBeQ6UD0tQ/Q0Dcnr5iHcDt+4tmqdCkt6OJbMCCwZZiyZERgjRdr0XGd0Zur9vfuDZTGq+qoY8gyNa6tWqsmNzJUlVbQsq/Ki89CpxP8nc4GAw0HrnXdi/3gLqFQk/vxBIi+9dLq7Ne0IKXWmS6n2cjlCytErh3Zf+ze5LoFg1uHxe6i11lLTX0N1fzXV/dUcGjg0YQqeWqmWR2ZGfuwKYgrIjcoVP3iCIJ02FxUtcjTV/jYb+9sGsTm949qplApy402ypEqKYH5iBPMTwok0zO1RPikQwNfTi6+zA29HB972jjHxNLIEBsfL36NRmc1oUlJGlmS50PjofnKyqPEkEAgmh0AAhjtlQWVtHpFXTfLa2ixHWUmB47+HSgvmlPGyypwCEcnyopnbNXP83gADXXb6WofpaR2mp2mI3pYhPK7xEVBKlYKYZBNxqSbiMyKwZJqJTjKiVIpoNMFI5sJQK1X9VcHshQN9ByYcOFYpVGSaM5kfPZ/50fOZFz2P+VHzidRHnv6OCz4zktdLx09/iu3NtwCI//73iL7ppjM6wl1IqTNZStV9CC9/AzzDkFAI33hNDt0WzHhsbltQPNX011A9UE2DtQGfNH5UTqvUMi96XlBAjYYGa8RsioJTQJIkWgecsqBqt1HZNsj+Nhv9E9SnAkg065mfEB6UVPmJEWTGGtGoZv4ouyRJ+K1WfJ2deDs68XZ24OvolOXT6HZ3N3jHS7qjUZnNqJOT0CTJizY5eUxCJSejMplOwycSCASCE+DzwGCrLKiCsqoFbC3yeqj9xNIKwBgny6lRUWVOAXMyRIysTQmzoq6VJEnYrR762obpaxumt1VeWzsdBI7OdwdUaiUxKSbi0sKJTwsnLi2c6EQjKs3M/80TzBwkSaLd3i6X1zhCVE1UYgMgwZjA/KgRSTUiq5JNyaLMxixACgTo/uWv6P/jHwGIvuEG4n/wfRRnaDSqkFJnqpTa/xr87f9BwCvXjrryBdCfgf8dZjgev4cGWwOHBg5xeOAwh6yHONx/mG5n94TtzTrzuB+nTHOmKKIomBIkSaJz0EVlq4397YMcaLdR3TlE68DE05xrVUpy4k3MTwgn1xJObryJnHgTqdEGVKdp5Fjy+/H19uLr6sLb2Ymvswtfdxfezi75WJe8ltwnSHMBUCpRx8ejSUiQpdMR8ml0URqNU/+hBAKBYKrxe2GwfUxS2VpkgWVrAVsr2NrAN/F3fwgKJZgsEJ4IEUljS3hS6L7m9M3g6xzy0N9hZ6DDTn+HQxZR7cO47eMH+gB0BjUxySY5CmpEQEUlGlDNgkEXwexjNPVvNBOiZkBetwy1TNjeoDaQE5VDXlQeuZG58joqF7POfJp7LjgZ+v7wR7offRSAiC9/maSfP4hCO7ezDSZCSKkzUUrtehre+yEgQcGl8NX/BbVIEZlOAlKADnsHddY6Dg0cCkqoRlvjhNFPACmmlLEQ3pFwXovBckaHfgpmBoMuL4c6hzjYOUR1xyDVI2u7Z3x6A4BWrSQ7ThZUuSNLTryJ9BgjWvXJ3eRLgQD+/n583d14u7vx9fTg6+7G1z26HjnW2yunsZwEquhoNAkJqJMS0SQkoklMQJ2QgCYxUT4eH49CPfNH/AUCgWDKkSRw9MvRVrY2OR3Q1jqyHtkeaofAxPc049BHQnjCyJIYujYljL12kvevcuSTm4EOhyygOu0jIsqByz5x1KtCqSDSYiA22UhMiikookxROnGvJZh2hj3DQUE1KqxqrbV4AxP//2wxWMiNGpNUuZG5ZJgzROmOGYDtzTdp/8lPwefDuHYtKY8/dsYNagopdSZJKUmCDx6ELb+U95dtgAt/AUpRpPh0caR8qrPWUWutpd5aT52tDucxRhjDNeHyj8fID0leVB45kTmYtCLtRzB7CAQk2qxODo5IqtruYQ53D1PfM4zbN7EkUisV5ESoKNB5yVV7SMVJot9OlHsQ/aAVf2+vHPXU24uvrw98J/mwo1LJEU4WC2qLBU2CBXW8BXWCRT42IpyUZ+BIlUAgEEwZgQDYe2Q5NXjEMtQhy6vBDnnfaz/59wyLkiWVKR5MFtzaJKyBFKyeOGzOCKxDemxWBdYez4R1nwBQQESMnqhEI1EJRmKSjMQkm4hKNIhZ8ASzCm/AS/Ng81iGxci63d4+YXulQklaeBrZkdlkmbPIicwhOzJbyKppYPjjj2n9zp1ITif6RYtI/d+nUUdFTXe3ThtCSp0pUkqS5OioT56W98/5Kaz/npj6d4rwBry0DrXSaGukYbCBOmvdCeWTWqkmIyIjRD7lReWJ6CfBnEKSJAKDg/j6+vD39eHp6aW3tZO+lk6GO7vx9PahGOhHN2Qlwj2MwXcSaXSj761QoIyOQWuJRxMfjzo+HnVcnLyOjxvbj4lBoRIPGgKBQDDjkCRw2WC4S5ZVQ51HrDuRBjtx22wMWmHQG4XNl4DVn4TNl4TVn4QzcOwUJQV+zLp+ok2DRJndREVDtEVHZGI4msg4WWwZ48AQOyvqXgkEJ8uQZ4haay2H+g9x2CrLqtqBWoa842f/g/GyKtOcSaY5k4yIDDEoPoU4Kypo+X/fwm+zocvNIe2551DHxk53t04LQkqdCVIqEIB3vgtlG+X9i34Fy26Z1i7NFawuK42DjTTYGmgYbKDB1kCjrZHWodZjpt2NyqecyByyIkdGJczZpEakitpPglmH5PPhHxzEPzCAf2AAX3+/nEbX34+/f0DeHpC3ff19+AesJx/RNIJfq8MZHok1LIJutYl2pYE+XTj9unAG9OEM6CMY0IUzoDMRUKrQqBSkRBlIjTaQFh1GWrSB1NH9GAMRevF3JhAIBDMVvy/AUJ+LwV4ng71ObL0uhnqd2HqdDPa68DiP/xti0DqJ1PURqe7ATCORUi1mVQeR6g5UilNIHzTGyoLKGBu6bYgFY4y8NsSAIfq01sASCCYDSZLocfaEZm/Y6qm11jLkmVhWAcSFxQUFVaY5kwyzvE40JooC65OAu66O5htuxNfTgzYzk7SNz6GxWKa7W1OOkFJzXUr5ffDW7bD3L3JxyYufgKJrprtXswqb20bzYDPNQ/LSMthC01ATLYMtx5wNAyBMHUZGREbwy3o0JDYtPA21UozACWYeAZcLv9WK32bDb7WNbFvl7YEBeX9EPvmtVnxWKwGb7VNdSxkejjomBlVMzMg6GnVMLOqYaPlYbCzq6GhUsbEojcaQaEGvP0DrgJOG3mEaeh009A7T2OugZcBB24AT3wQzIx1JuF5NcmQYSZFhJEXqSYoMI3lkSYoMIz5ch1oUrBUIBIJJR5Ik3HYfQ/0uhvpdDA+4GOp3MzyyP9TvwjHogRM8dRgitETE6omICyMy3iAvFgPm+DC0+qPusXxuOW3Q3gPDPWDvPmJ7ZH9029F7crMMHo3GMCaowqLHtg0xI/vREBYpb4dFyYveLDIWBDMOSZLodfZSa62VhZWtjkZbI42DjfQ6e495nk6lIzU8lbTwNNIiRpZwebEYLUJYnQKepiaabrwRX3sHmtRU0jc+hyY5ebq7NaUIKTWXpZTfC3/bAFWvg0IlFzRfdPl092rG4Q/46XH20DrUSru9ndahVllAjYgom/v4D90JxoSx0YKRdaY5U6TdCaYFyeuVI5dsgwQGbcFt/6CNwOj20KC8HRRPNvw228nNOHcMlGYz6shIVNHRqKKjUUdHoYqKliVTdLS8HR0VfH2q6jX5/AE6B1009zto7XfS3O8ILq0DDnqHPSd8D5VSQUKEngSznoQIPZYIPZYIHQlmPfHhY8fDtCIFUCAQCEYJ+AM4Bj3YrR7sVjfDVjd2mxu7dWwZ6nfh85xY+qi1SiJiw0YWPRGxYZhjwwiP1RMRE4ZGN0XfvwE/OK1jgsreO7LuG1n3jBzrk9fO/pMv3n40CtWIqBqRVGEj4kofObI2H7F91FpjEEJLcNoZ9AzSZGsKyQ5psDXQPNR8zALrAFqlltTwVFIjZGmVGp5KsimZ5PBkkk3Jon7VBHjb2mi64Ua8LS2oExNJ3/gc2vT06e7WlCGk1FyVUj43vHIj1LwDSg1c8Rzkf3m6ezUtBKQA/a5+2ofbaRtuo224TRZQI/vt9nZ8J7ihiAuLIzU8lfSIdNIi0oIjAekR6Rg0htP0SQRzHcnnI2C3Exgexj9sJzA8JG8PDRMYHsI/NERgcEiWSkPDI3JpCP/w6PEhJOdJTMl9PNRqVGZz6BIVhSoyUl5HRaIO2Y9CFRExa2ahs7t9dNictFldtFudtFudtB2x7rC6ThhpNUq4Xh2UVnHhOmJNWmJNupHtsXW0UYtKKR4eBALB7EOSJDwuP85BD45BN45BL46RbfmYB7tNllCOoRNHOI0SFqElPEpHeLQeU7Se8JHFFK3DFKUnLFwzOwb2JAncg/LMg45+WVY5R9aOviOODciyy9kvb3sdn+26Ss2ItIoYWZtBd8R2yLEI0IXL26NrfYSYeVswafgCPtqH20MG9ZsHm2kZajluSZNRYsNiZUk1sqSEp5BsSibJlESCIQGN6swsu+Dt6qL5hhvxNDSgjosjbeNz6LKzp7tbU4KQUnNRSnmd8PI3oPbfoNLBlf8HeZ+f7l5NCZIkMegZpNPeSae9kw57h7zt6Awe63Z0H9feA6gVahKMCUFjHww9HbH5QjwJJkKSJCS3m4DDIS92BwGHXV7b7UcswyH7/uC2g8DQiHiy25Ecn/Em9QiU4eGoIiJQmiNQhUeMbUeYUUVEoDJHyMIpMhKl2YzKHIkq0jwuVe5Mwx+Q6B120zrgpGvQRafNRdeQiy6bi85BF92DbjoHXTg8x5jFaQKUCog2jkmrKKOWaIOGaKOOaKO8jjJqiBlZRxm0aET6oEAgmAKkgITb6cM17MU57MU17BlZj+wPeXDavTiHvLJ0GvLg9558OptSqcBg1mKM1I0tZi2mSB2GyBEJFaUTs9p5XeCyytLKOTCy9MviymU9xtomb3/ayKyjUWlHJNURwkprAp3piO0jjk20rzXKi+b/s3ffgVFUax/Hv7M1vXeSEDqh9yKKDcWG196pgg0r77VeuyIXvSoWFLFhwwIoVlREQJHee2iBQEJ62dRtM+8fm2wSSCBAkk15Pt69sztl9wSY7Oxvz3mOL+jkfUscz6E6OFp8lMOWw6QUpnDIcogjRUdcHQUKUylxnPzaN9QrlCjfKPct2jeaSN9Ionxcj8O9w9G30NnkHdnZpIyfgHXvXvQhIcR//BFeXbp4uln1TkKplhZK2Yrhy5sg+S8weMPNX0KH8z3dqlOmaRoF1gKySrPIKs0iuzSbrBLX/ayS8sfl62ubza4qBYUInwh3+h7jF1MtkY/wiZA6Ty2U5nCglpWhlZailpWhlpailZWhlpahWctQS0pRS0tRS0tc+5SWVd6vuq3ifkl54FQeRKGeRu2Jk1DMZnR+fuj9/NBV3Pz9ysMlf3R+/q6lf0D19f7+6P1dS5ldruFomkaR1VEeWlnJsJSRXWQlu8hKVqGV7CJb+dJKbomN03n39PcyEOhtJMjH6Fp6mwh0369cH+BtJMDLiL+XAf/ypQRaQrRsmqphszqxlTqwlTqwljqwlTiwltgpK3ZQVmLHWuLAWuxalpUvK7ZrdewNWpXRS4+PvwmfQBM+/ia8A0z4VNwCza7QqXybIj1DG46mua71y/KhzOIKqqzly6q3quusha59rYWu2wmKWJ8Ro09lSFURWFWsM/qAyccVXpl8aljv4yoWf+zS4OW6bzDLcMUWqOLzXmpRKkeKKkexHCk6QmphKkeLj2J1nry0hF7RE+oVSphPGOHe4YT7hBPuHU6Yd/XHod6hzfLzniMvj5Tbb8e6cxf6wEDiPvwQ7x7dPd2setWkQqmZM2fyyiuvkJ6eTu/evXnrrbcYNGhQrfvPmzePp556ioMHD9KpUyemT5/OZZddVqfXapGhVJkF5t4AKatcbwa3zoO2Z3m6VYCrblORvYh8az55ZXnklOWQV5ZHXlkeuWW55Fnzqj3OLcs9ae+mqoLNwdUS9CjfKHd6HuUbRbhPuMxs5yGapoHdjmqzo9ltaLYqN6sVzWZDtdnQbHY0m9XV88hqRbNWbC9/XFZ+v8zqCpVs5eusZZXrrMcvsdf939GZULy90fn4VN58favcfFwBU7V15beK8Mnf33Xf1xelgeoticbncKrkFtvIrAipim3kFtvIK7FV3i+2k1NsJa/ETt5phlhVeRl17oDK38tIgJcBfy8DfmYDPqbypVlf5bEe36rbTHq8TXq8ja6bTj5gCnFGNE3D6VBx2FTsVicOmxO71YmtzIm9zFF531rlsdWJveyY4KniZnXWeZhcbYxeerz9jHj5GvH2N+HlZ3Q99jPi7ed6XBE6eQeYMEoNvZZDdYKt6JiwqmpoVQTWIld4ZS2qfFwRaFmLXMMPbcWubadTGP6UKeVBlZfrS/dqS6/yAMtc8zaD+ZjlMev0ZjCYypdmVw+yakuz9ALzEE3TyLPmuUe/VB0Nk1GcwdHio2SWZOLU6tZ7XUEhyBxEsFcwIV4h1ZbB5ir3y9cHmAIw6ZvGNbnTYiFl0iTKtmxF5+dH3Puz8enb19PNqjdNJpT6+uuvGTNmDLNmzWLw4MHMmDGDefPmkZSURERExHH7r1y5kuHDhzNt2jSuuOIK5s6dy/Tp09m4cSM9evQ46eu1uFCqNA8+vxZSN4A5EG5bAHEDz/hpNU3D6rRS4iihxF5Suay47yih2F5Moa0Qi9WCxWZx3be57lusrseF9tP7VibQHOhOuiN8ItyJtzsJ9w4nwicCL4PXGf+sTYWmaeB0oqkqOBzVl04nmtPpXmoOJzgdNdx3uPZxONEcdtdjhwPN4XCvw+FAs1esc1RfZ3cd41pWrLdXbjv2ZrPVft928sLSjUJRXMGRlxc6Ly/XfbPZtay4+XiX71PlvrePe1tF4KS4w6fyYMnbS3omiXrhVDXyS2zkl9opKLVTUOJa1riu/HFhmZ3CMscpDSk8FWaDzhVUGcvDKpMeH6MBL5Mes0GHl7FiqcNsOHada2kqvxn1rqVZr8No0GHSV643ly8NegWjrnyp12HUK616SKk4M5qmoaoaqrPipqI6XSGR6nAtnY7ydXbXfWeV+6pTxWlXcZTfKu47bU4cjiqP7aorbLK5lhXBk6P8cUNcRev0CiZvA2ZvAyZvA15+Rsw+Brx8XEuzb/ljXyNevgbMPkbMPka8/AwyfE7UD00DR1llQGUtqrxvK64Mr+wlYCsBe3H5smJ9qeu+vaTK/dLK2yl8Qd2gdAZXiKU3usIqvbnKfWNliKU3Vm7TGaqsM7rqgFW7bwK9wbVfxTadoXK7Tl/9OJ2+fN/abvrKpVLlvvtx+TpF36JCNqfqJLs0m+zSbDJLMitH2JRmkV2S7R51k1OaU+fwqiovvRcBpgD8Tf4EmAMIMAUc99jP6Ie30Rsfgw8+Bh98jb74GF33fYw+eBu862X2QWdRMYfvupPS9RvQ+fgQ994sfAae+ef9pqDJhFKDBw9m4MCBvP322wCoqkpcXBz33Xcfjz322HH733jjjRQXF/PTTz+51w0ZMoQ+ffowa9ask75eSwql/vxoDmkrd6M57aDowDsETW8ENDQ0yv/neqy51mmahoqGpqmo5etUTS3f5lqqqoqKysn+6k/4UaHKoQqgU3QYdAYMSvlNp0evq7xvUCofG3V6lIpn18rbf+zzutumufepaZumVXnseuDar3yddty2qturHH/MsVrFumNuWrV9NVCP2VdVj38Mrm+bWtZI2eMpOhS93hXiuJc6FL3Bdd9gqLZNMRgq71dsN+hR9AYwVGyvXKcYKp9DMRpd+xkNKDr9Sf6xCtG8qZqGzaFhc6hYHc7ypYrNoWJzOLGrrm12p4rdqWFzlt93qOX3tfJtKg5n0/o9pCgKOsU1M6JOqbhVrlcU0CmKe1l1u1K+XaFyu0L1dUq1dUDFetfd8mX5PlXXVfx/+e8Wxd3e8ueo9kPU8HOd9Oeuce1JjuL03kdOdkjV9/Njn1+r7X7V9+Qa2lb+Nqm433OrbK/6uLb91Bq2q1W2qRpK0/qnjKYABgXNoAODUu2+ZlDAoCtfKqBX0Iw6NKMOjOX7GZXyxzrQIUOaRIumUx0Y1DIMahlG1YpRLcOgWjGoZehVW/l9K8byZcU2g2pFr9oxqDb0mhWDanPdV60YNFu1Y/WqHb1mw1C+1Ks2DFoTCcMaiIaCqujQ0KEpOjT0rsfV7uvR0FXZTylfp1Qep+hcjyvWVzym6jbXkornATRFByjl2xWodb3rPgBKxf2atiuu362uHautB9fvXRUoxEmBYqNQcWJR7BRW3HBQqNhd67BTqDgoxl7lOc+cWdNjQocBHUZ0GLTyJccsNQUDOnSuKxR0KK5f9eX3jTaVkd9l0uZQKQ6DwuobOjPp6YX111APqWs206CDL202Gxs2bODxxx93r9PpdIwYMYJVq1bVeMyqVauYMmVKtXUjR45k4cKFNe5vtVqxVpnu3GKxnHnDm4j0tbspMFxc+bfkLL+dhoqLcoCG7PjhKL+5Lhob7nVOW+XvMeEpGlX+odT1AHv5TQhRE1P5rXa68ltzdGz6IUTNVDRUXJdKDgWcaKiK6+3GqVRcRmmV9xVwoOEo38ehaOXLiudwPbYrrvt2wK649q+4by8/Vj322kLeuoQ4RSd/JztzGiYcmLBXLhUHRhyYcC2NODAplY9N2N3rjDgxuPdzYsSBQXFiwoGh/HHFfb3iLN/ftdRXve/e5kCPVr5Uy48rX+LEgIq+/BgdqmsfpfYPWAoaeq38A6O8ZdZIBYp0ChadDotOR2H50qLTYdFXf1ys01GiKJToFEoUnWtZvk4t/2BtVZxYq35AP93Pmd6w5AaN//tWod9+jQHzk3Den48+KOhMf+RmoUFDqezsbJxOJ5GRkdXWR0ZGsnv37hqPSU9Pr3H/9PT0GvefNm0azz33XP00uIkJ79UOx/q/wOTn6g1S/g1v9W9pK+8riq7822MF93+KK311byv/T6/ToyjlaW2dv4075ivjGjbVvN+xByjVVlX8TMesqH6/ytfVVX7i6mnbSZZKxdfqFevKk3ilpufQ6SpfS9FVvk6Vm1L1eXSubwMU97ebCuh05Xd15Y8r91UUXeVxik5yMiFEi+fqBKPh1DRUtXz4lebqCea+qa79VE0r74yqufdzdZypuO9aomnl+5e/RvlxFa9VsXRtq+yMU3Fc1c61VfrsVuu9W6Vvbo0X+TV1XqrhmU76Z1N3Z/COUduhtbyvazW97ytVl1W+xT5mqVV0SavSzUyr7XH5vlrFfV35n4numPUKaBXrdK7tVY85Ue+iilhWqlAKIc5URT+BMk+8uKahoKLTXEGVTnOiaM7yx04UTStfqug0FeXYdaiu/VFRyp9L0dTypeZ+jor1uvLAxbWPVrmsdr/yuXBv06rdd2/TXOsq3mEUrfIYcAVrlO+jVHkHrujJW21dxcgVqr5NHb+fq/21bQdfNHyB6GPWuy8ajskBNTTsqJShYlWc2HDiQMWBhl1RcaBiP+a+Q1Gxu8YqlT+lVt7Tq8pjYOMolcBfckntGU7fVhJIQQOHUo3h8ccfr9azymKxEBcX58EW1Z+L7rnT000QQgghhBBCCCFEY7jL0w1ofA0aSoWFhaHX68nIyKi2PiMjg6ioqBqPiYqKOqX9zWYzZrO5fhoshBBCCCGEEEIIIRpFgxaYMJlM9O/fnyVLlrjXqarKkiVLGDp0aI3HDB06tNr+AIsXL651fyGEEEIIIYQQQgjR/DT48L0pU6YwduxYBgwYwKBBg5gxYwbFxcWMHz8egDFjxtCmTRumTZsGwAMPPMC5557Lq6++yuWXX85XX33F+vXrmT17dkM3VQghhBBCCCGEEEI0kgYPpW688UaysrJ4+umnSU9Pp0+fPvz666/uYuYpKSnodJUdts466yzmzp3Lk08+yRNPPEGnTp1YuHAhPXr0aOimCiGEEEIIIYQQQohGomhaTfPGNF8Wi4XAwEAKCgoICAjwdHOEEEIIIYQQQgghWpW6ZjPNfva9Y1VkbBaLxcMtEUIIIYQQQgghhGh9KjKZk/WDanGhVGFhIQBxcXEebokQQgghhBBCCCFE61VYWEhgYGCt21vc8D1VVUlLS8Pf3x9FUTzdnDNmsViIi4vj8OHDMhxRiDqS80aI0yPnjhCnR84dIU6PnDtCnJ7mcO5omkZhYSExMTHV6ogfq8X1lNLpdMTGxnq6GfUuICCgyf5jE6KpkvNGiNMj544Qp0fOHSFOj5w7Qpyepn7unKiHVIXa4yohhBBCCCGEEEIIIRqIhFJCCCGEEEIIIYQQotFJKNXEmc1mnnnmGcxms6ebIkSzIeeNEKdHzh0hTo+cO0KcHjl3hDg9LencaXGFzoUQQgghhBBCCCFE0yc9pYQQQgghhBBCCCFEo5NQSgghhBBCCCGEEEI0OgmlhBBCCCGEEEIIIUSjk1BKCCGEEEIIIYQQQjQ6CaWEEEIIIYQQQgghRKOTUKoJmzlzJgkJCXh5eTF48GDWrl3r6SYJ0aRMmzaNgQMH4u/vT0REBFdddRVJSUnV9ikrK2Py5MmEhobi5+fHtddeS0ZGhodaLETT89///hdFUXjwwQfd6+S8EaJmqamp3HbbbYSGhuLt7U3Pnj1Zv369e7umaTz99NNER0fj7e3NiBEj2Lt3rwdbLITnOZ1OnnrqKdq1a4e3tzcdOnTghRdeoOok8HLuCOHy119/MWrUKGJiYlAUhYULF1bbXpdzJTc3l1tvvZWAgACCgoK4/fbbKSoqasSf4tRIKNVEff3110yZMoVnnnmGjRs30rt3b0aOHElmZqanmyZEk7F8+XImT57M6tWrWbx4MXa7nYsvvpji4mL3Pg899BA//vgj8+bNY/ny5aSlpXHNNdd4sNVCNB3r1q3jvffeo1evXtXWy3kjxPHy8vIYNmwYRqORRYsWsXPnTl599VWCg4Pd+7z88su8+eabzJo1izVr1uDr68vIkSMpKyvzYMuF8Kzp06fz7rvv8vbbb7Nr1y6mT5/Oyy+/zFtvveXeR84dIVyKi4vp3bs3M2fOrHF7Xc6VW2+9lR07drB48WJ++ukn/vrrL+64447G+hFOnSaapEGDBmmTJ092P3Y6nVpMTIw2bdo0D7ZKiKYtMzNTA7Tly5drmqZp+fn5mtFo1ObNm+feZ9euXRqgrVq1ylPNFKJJKCws1Dp16qQtXrxYO/fcc7UHHnhA0zQ5b4SozaOPPqqdffbZtW5XVVWLiorSXnnlFfe6/Px8zWw2a19++WVjNFGIJunyyy/XJkyYUG3dNddco916662apsm5I0RtAO27775zP67LubJz504N0NatW+feZ9GiRZqiKFpqamqjtf1USE+pJshms7FhwwZGjBjhXqfT6RgxYgSrVq3yYMuEaNoKCgoACAkJAWDDhg3Y7fZq51LXrl2Jj4+Xc0m0epMnT+byyy+vdn6AnDdC1OaHH35gwIABXH/99URERNC3b1/ef/999/bk5GTS09OrnTuBgYEMHjxYzh3Rqp111lksWbKEPXv2ALBlyxZWrFjBpZdeCsi5I0Rd1eVcWbVqFUFBQQwYMMC9z4gRI9DpdKxZs6bR21wXBk83QBwvOzsbp9NJZGRktfWRkZHs3r3bQ60SomlTVZUHH3yQYcOG0aNHDwDS09MxmUwEBQVV2zcyMpL09HQPtFKIpuGrr75i48aNrFu37rhtct4IUbMDBw7w7rvvMmXKFJ544gnWrVvH/fffj8lkYuzYse7zo6brNzl3RGv22GOPYbFY6Nq1K3q9HqfTydSpU7n11lsB5NwRoo7qcq6kp6cTERFRbbvBYCAkJKTJnk8SSgkhWoTJkyezfft2VqxY4emmCNGkHT58mAceeIDFixfj5eXl6eYI0WyoqsqAAQN46aWXAOjbty/bt29n1qxZjB071sOtE6Lp+uabb/jiiy+YO3cu3bt3Z/PmzTz44IPExMTIuSOEkELnTVFYWBh6vf64mY4yMjKIioryUKuEaLruvfdefvrpJ5YuXUpsbKx7fVRUFDabjfz8/Gr7y7kkWrMNGzaQmZlJv379MBgMGAwGli9fzptvvonBYCAyMlLOGyFqEB0dTbdu3aqtS0xMJCUlBcB9fsj1mxDVPfzwwzz22GPcdNNN9OzZk9GjR/PQQw8xbdo0QM4dIeqqLudKVFTUcZOjORwOcnNzm+z5JKFUE2Qymejfvz9Llixxr1NVlSVLljB06FAPtkyIpkXTNO69916+++47/vzzT9q1a1dte//+/TEajdXOpaSkJFJSUuRcEq3WhRdeyLZt29i8ebP7NmDAAG699Vb3fTlvhDjesGHDSEpKqrZuz549tG3bFoB27doRFRVV7dyxWCysWbNGzh3RqpWUlKDTVf/YqdfrUVUVkHNHiLqqy7kydOhQ8vPz2bBhg3ufP//8E1VVGTx4cKO3uS5k+F4TNWXKFMaOHcuAAQMYNGgQM2bMoLi4mPHjx3u6aUI0GZMnT2bu3Ll8//33+Pv7u8dJBwYG4u3tTWBgILfffjtTpkwhJCSEgIAA7rvvPoYOHcqQIUM83HohPMPf399dd62Cr68voaGh7vVy3ghxvIceeoizzjqLl156iRtuuIG1a9cye/ZsZs+eDYCiKDz44IO8+OKLdOrUiXbt2vHUU08RExPDVVdd5dnGC+FBo0aNYurUqcTHx9O9e3c2bdrEa6+9xoQJEwA5d4SoqqioiH379rkfJycns3nzZkJCQoiPjz/puZKYmMgll1zCpEmTmDVrFna7nXvvvZebbrqJmJgYD/1UJ+Hp6f9E7d566y0tPj5eM5lM2qBBg7TVq1d7uklCNClAjbePP/7YvU9paal2zz33aMHBwZqPj4929dVXa0ePHvVco4Vogs4991ztgQcecD+W80aImv34449ajx49NLPZrHXt2lWbPXt2te2qqmpPPfWUFhkZqZnNZu3CCy/UkpKSPNRaIZoGi8WiPfDAA1p8fLzm5eWltW/fXvvPf/6jWa1W9z5y7gjhsnTp0ho/34wdO1bTtLqdKzk5OdrNN9+s+fn5aQEBAdr48eO1wsJCD/w0daNomqZ5KA8TQgghhBBCCCGEEK2U1JQSQgghhBBCCCGEEI1OQikhhBBCCCGEEEII0egklBJCCCGEEEIIIYQQjU5CKSGEEEIIIYQQQgjR6CSUEkIIIYQQQgghhBCNTkIpIYQQQgghhBBCCNHoJJQSQgghhBBCCCGEEI1OQikhhBBCCCGEEEII0egklBJCCCGEEEIIIYQQjU5CKSGEEEIIIYQQQgjR6CSUEkIIIYQQQgghhBCNTkIpIYQQQgghhBBCCNHoJJQSQgghhBBCCCGEEI1OQikhhBBCCCGEEEII0egklBJCCCGEEEIIIYQQjU5CKSGEEEIIIYQQQgjR6CSUEkIIIYQQQgghhBCNTkIpIYQQQrRqiqJw77331tvzLVu2DEVRmD9/fr09Z1NS8fMtW7bM000RQgghRDMnoZQQQgghWqT9+/dz55130r59e7y8vAgICGDYsGG88cYblJaWerp5Z+zZZ59FURT3TafTER0dzRVXXMHq1as93TwhhBBCiJMyeLoBQgghhBD17eeff+b666/HbDYzZswYevTogc1mY8WKFTz88MPs2LGD2bNne7qZ9eLdd9/Fz88PVVU5fPgw77//PsOHD2ft2rX06dOn3l9v+PDhlJaWYjKZ6v25hRBCCNG6SCglhBBCiBYlOTmZm266ibZt2/Lnn38SHR3t3jZ58mT27dvHzz//7MEW1q/rrruOsLAw9+OrrrqKHj16MG/evAYJpXQ6HV5eXvX+vEIIIYRofWT4nhBCCCFalJdffpmioiI+/PDDaoFUhY4dO/LAAw8ct37hwoX06NEDs9lM9+7d+fXXX4/bJzU1lQkTJhAZGene76OPPqqxHU6nkyeeeIKoqCh8fX258sorOXz4sHv7M888g9FoJCsr67hj77jjDoKCgigrKzuVHx2AqKgoAAyGyu8ebTYbTz/9NP379ycwMBBfX1/OOeccli5detzxX331Ff3798ff35+AgAB69uzJG2+84d5eU02pvXv3cu211xIVFYWXlxexsbHcdNNNFBQUnHL7hRBCCNF6SE8pIYQQQrQoP/74I+3bt+ess86q8zErVqzg22+/5Z577sHf358333yTa6+9lpSUFEJDQwHIyMhgyJAh7sLo4eHhLFq0iNtvvx2LxcKDDz5Y7TmnTp2Koig8+uijZGZmMmPGDEaMGMHmzZvx9vZm9OjRPP/883z99dfVCq3bbDbmz5/PtddeW6ceSbm5uQCoqkpqaiovvPACXl5e3HDDDe59LBYLH3zwATfffDOTJk2isLCQDz/8kJEjR1Yb5rd48WJuvvlmLrzwQqZPnw7Arl27+Oeff2oM8iraO3LkSKxWK/fddx9RUVGkpqby008/kZ+fT2BgYJ3/HoQQQgjRukgoJYQQQogWw2KxkJqayr/+9a9TOm7Xrl3s3LmTDh06AHD++efTu3dvvvzyS3dg9J///Aen08m2bdvcQdVdd93FzTffzLPPPsudd96Jt7e3+zlzc3PZtWsX/v7+APTr148bbriB999/n/vvv5+OHTsydOhQPv/882qh1M8//0xeXh6jR4+uU9u7dOlS7XFQUBALFy6ke/fu7nXBwcEcPHiwWh2oSZMm0bVrV9566y0+/PBD92sHBATw22+/odfr6/T6O3fuJDk5mXnz5nHddde51z/99NN1Ol4IIYQQrZcM3xNCCCFEi2GxWADcQVBdjRgxwh1IAfTq1YuAgAAOHDgAgKZpLFiwgFGjRqFpGtnZ2e7byJEjKSgoYOPGjdWec8yYMdXacd111xEdHc0vv/xSbZ81a9awf/9+97ovvviCuLg4zj333Dq1fcGCBSxevJjff/+djz/+mM6dO3PttdeycuVK9z56vd4dSKmqSm5uLg6HgwEDBlRrd1BQEMXFxSxevLhOrw24e0L99ttvlJSU1Pk4IYQQQggJpYQQQgjRYgQEBABQWFh4SsfFx8cfty44OJi8vDwAsrKyyM/PZ/bs2YSHh1e7jR8/HoDMzMxqx3fq1KnaY0VR6NixIwcPHnSvu/HGGzGbzXzxxRcAFBQU8NNPP3HrrbeiKEqd2j58+HBGjBjBRRddxLhx41iyZAn+/v7cd9991fb75JNP6NWrF15eXoSGhhIeHs7PP/9cre7TPffcQ+fOnbn00kuJjY1lwoQJNdbWqqpdu3ZMmTKFDz74gLCwMEaOHMnMmTOlnpQQQgghTkpCKSGEEEK0GAEBAcTExLB9+/ZTOq62oWqapgGu3kUAt912G4sXL67xNmzYsFNub3BwMFdccYU7lJo/fz5Wq5XbbrvtlJ+rgp+fH4MHD2bjxo0UFxcD8PnnnzNu3Dg6dOjAhx9+yK+//srixYu54IIL3D8bQEREBJs3b+aHH37gyiuvZOnSpVx66aWMHTv2hK/56quvsnXrVp544glKS0u5//776d69O0eOHDntn0MIIYQQLZ/UlBJCCCFEi3LFFVcwe/ZsVq1axdChQ+vlOcPDw/H398fpdDJixIg6HbN3795qjzVNY9++ffTq1ava+jFjxvCvf/2LdevW8cUXX9C3b99q9aBOh8PhAKCoqAhfX1/mz59P+/bt+fbbb6v1wHrmmWeOO9ZkMjFq1ChGjRqFqqrcc889vPfeezz11FN07Nix1tfs2bMnPXv25Mknn2TlypUMGzaMWbNm8eKLL57RzyKEEEKIlkt6SgkhhBCiRXnkkUfw9fVl4sSJZGRkHLd9//79vPHGG6f0nHq9nmuvvZYFCxbU2AsrKyvruHWffvpptWGE8+fP5+jRo1x66aXV9rv00ksJCwtj+vTpLF++/Ix6SYGrwPrKlSuJiooiIiLC3X6o7PkFsGbNGlatWlXt2JycnGqPdTqdO0SzWq01vp7FYnGHYBV69uyJTqer9RghhBBCCJCeUkIIIYRoYTp06MDcuXO58cYbSUxMZMyYMfTo0QObzcbKlSuZN28e48aNO+Xn/e9//8vSpUsZPHgwkyZNolu3buTm5rJx40b++OMPcnNzq+0fEhLC2Wefzfjx48nIyGDGjBl07NiRSZMmVdvPaDRy00038fbbb6PX67n55ptPqV3z58/Hz88PTdNIS0vjww8/JC8vj1mzZrl7RV1xxRV8++23XH311Vx++eUkJycza9YsunXrRlFRkfu5Jk6cSG5uLhdccAGxsbEcOnSIt956iz59+pCYmFjj6//555/ce++9XH/99XTu3BmHw8Fnn33mDvKEEEIIIWojoZQQQgghWpwrr7ySrVu38sorr/D999/z7rvvYjab6dWrF6+++upxwVBdREZGsnbtWp5//nm+/fZb3nnnHUJDQ+nevTvTp08/bv8nnniCrVu3Mm3aNAoLC7nwwgt555138PHxOW7fMWPG8Pbbb3PhhRcSHR19Su26++673fd9fX3p1asXU6dO5frrr3evHzduHOnp6bz33nv89ttvdOvWjc8//5x58+axbNky93633XYbs2fP5p133iE/P5+oqChuvPFGnn32WXS6mjvY9+7dm5EjR/Ljjz+SmpqKj48PvXv3ZtGiRQwZMuSUfhYhhBBCtC6KVrUftxBCCCGEaHRbtmyhT58+fPrpp4wePdrTzRFCCCGEaBRSU0oIIYQQwsPef/99/Pz8uOaaazzdFCGEEEKIRiPD94QQQgghPOTHH39k586dzJ49m3vvvRdfX19PN0kIIYQQotHI8D0hhBBCCA9JSEggIyODkSNH8tlnn+Hv7+/pJgkhhBBCNBoJpYQQQgghhBBCCCFEo5OaUkIIIYQQQgghhBCi0bW4mlKqqpKWloa/vz+Koni6OUIIIYQQQgghhBCtiqZpFBYWEhMTg05Xe3+oFhdKpaWlERcX5+lmCCGEEEIIIYQQQrRqhw8fJjY2ttbtLS6UqigQevjwYQICAjzcGiGEEEIIIYQQQojWxWKxEBcXd9JJXFpcKFUxZC8gIEBCKSGEEEIIIYQQQggPOVlZJSl0LoQQQgghhBBCCCEanYRSQgghhBBCCCGEEKLRNWgo9ddffzFq1ChiYmJQFIWFCxee9Jhly5bRr18/zGYzHTt2ZM6cOQ3ZRCGEEEIIIYQQQgjhAQ0aShUXF9O7d29mzpxZp/2Tk5O5/PLLOf/889m8eTMPPvggEydO5LfffmvIZgohhBBCCCGEEEKIRtaghc4vvfRSLr300jrvP2vWLNq1a8err74KQGJiIitWrOD1119n5MiRDdXMJutIagaffvsjlw4/ny6JbT3dHCHEadIcDtSSYrTiEtTiYrTiYvdjzWZD01RwqqCpaE4VVCeoGqhONLV8m6KgmEwoZhOK0YRiNqOYTGCquG9EMZlRzGZ0/v7o/P1R9HpP/+hCiHKqU8Ve5sRudWIrc2Ivc7gel68DrU7PozfoMHoZMHrpMXrpMVXcN+vRG3UnLSYqhBBCiCZG06A4E3vqNn56YyuB3Yu47P5n0elbR7WlJjX73qpVqxgxYkS1dSNHjuTBBx+s9Rir1YrVanU/tlgsDdW8RvfFl78TuK89c9IX8otfIfaCAYBcbArhUZqGt8NKsLWQkDILwdZCgssKKx+XFRJsLcLHUYa3w4q3w4qX0+6RphYbvCg0eVNk9KHI6E2hybUsMnlTaPQh3+xHjncg2V6B5HoFUGT0BvlAK0Sd6TXwUxX8NAV/VcFPVfDXFPxU8FcVfDQFk6Zg0sDYCO/fTjRsClgVDasChYpGkU6jUKdRVOV+oU7DBnJJIYQQQjQqjXDy6aRLpbNyhE5KKp10rmWm2crPh8/DbLiHou2FHE07TJu41tExpUmFUunp6URGRlZbFxkZicViobS0FG9v7+OOmTZtGs8991xjNbFRDR/Rh437suiQ25PAdk9RHLCVsqPXoDmCPd00IVo0b3sZ0cU5RBfnEFOcXX4/m8iSfIKtltMOmew6PSUGMyUGL0oNZkoNZuw6A6qioCo6VEVBQ8Gp6FAVHVqV9YqmYVQdGFUHJqfDfb/isUm1Y3Q6MDvteDttAPg6yvB1lAF5dWpfmd5IjlcgOV4B5HiXL70CyfIO4qhvKEd9Qyk1ep3Wzy5Ec2XSIMSpEKrqCHUqhDh1BGiuAMpXO/VUx4ErMLIprgDJVh4k1aWflILrwq0i6DJpCmYNTOXpkh4Fbw28y9sVWftTYaM8rNJp5Oo0cvSqe1mkIIGVEEIIcdpc4VPn8sCps3KEjuVBVJBSXG1PO/B+UCA/qpGMzjmHvBBwso2giMs803QPaFKh1Ol4/PHHmTJlivuxxWIhLi7Ogy2qP4N7dedg7DpyjxTTLWcom6KWEJH4FpP7PMA1Ha9Dp7SO7nxCNATN6cSRcghb0h7shw7iSDmM48hh7CkpqDk5Jz1e8fFBHx6OPjQUfVhY+S0cfVgo+tBQFD9/dL4+6Hz9UHx90fn6ohiNjfCTgWa3oxYWolosqAUFqBYLTktBtcdqgQVnTg7OzAycmZmoFlfY1qY4mzbF2bU+ty4kBGN8PIbYOAzxcRjj4jHExWGIj0cXGChDh0SzVWqxkZ9eQn5GCQUZJeSnu5YlBbYTHqc3KPgEmvEJMuEbZC6/b8Y30IRXgAlT+TA7o5fBNcTOUP/v3ZqqYbeWDwUsc2C3OikrtlOSb6OkwEpxvpWSfBvFBa6lrdSBCYVQVSFUhWO/hzWa9QRG+hAY5U1QpA+BkT4ERfngH+aNTifnuBBCCAGApqEUpaNk70aXtQdd9m6U7CTXsqyg5kMUHVpwO9SwzuwIiOTZ4m0cKMnk6S/9SW/XHYCrnr4XH1Ozj2rqrEn9pFFRUWRkZFRbl5GRQUBAQI29pADMZjNms7kxmtfodDodPc9pw/Iv93BhybUo4XlszNrIK+unsfTwYp476zniA+I93Uwhmjy1uJiypD1Yk3ZTtms3Zbt3Y92zB62srNZj9EFBGNvGY4pviyk+HlN8HMbYWAzh4RhCQ9H5+jbiT3CKTAbw9YaoiDofopaV4cjMxJGRgT0zE0eG674jKxN7ahq2w4dx5uai5uZizc3Funnzcc+hCwjA3KED5k6dKm9dOmMIlt6dommxlTrIPGQh46CFjGQLmQctFJ8gfPIJMBEc7UNwlC/BUb4EhHnhF2zGN8iMl6+xaYSxXkYIrNuudquT4nwrRflWCnPKyM8oIS+9mLz0EgqySrFbnWSnFJKdUljtOINZT0S8PxEJAUQmBBDZLgC/YHPT+PmFEEKIhqJpYEmDrN2QlQRZu8qXu6GW8AlFByHtIbxr5S2iK0poJ2w6hXc2v8OcHXNQNZVb13nhrQwBRUd0Wx9i2gY16o/naU0qlBo6dCi//PJLtXWLFy9m6NChHmqR53UaFMU/C/ZRlGHnpc4zWN5uETM2zmB9xnqu/eFa7ut7H7cm3opeJwWNhQBQS0oo3bqV0s2bKdu1G+vu3dhSUlxvJsdQvL0xd+6EuUNHTPFxmOLjMca3xRQfhz4gwAOt9xydl1d5+FZ70O0sLMSWkoL98GFsh1KwpRzCnnIYW0oKjowMVIuF0k2bKN20qdpx+rAwzJ06Yu7UCa/Ond2Blc7Hp6F/LCFwOlVyjhSRebA8hDpYSF568fHj5RQICPMmJMoVPgVF+RAS7UtwlA9mn8bp5dhYjGY9QZE+BEUefw46HSr5ma6eYnnpxeQedS3z00twWJ2k7c0nbW++e3/vAJMroErwJzIhkPC2/nj5tqw/LyGEEK2EpoEl1RU2Ze4uD6HKgyhrLbWrFX15+NQFIhIrA6jQjlBD2YvNmZt56p+nOGg5CMCt+rO48q+VrBwwDIDuFyQ00A/XdCmaVsMntXpSVFTEvn37AOjbty+vvfYa559/PiEhIcTHx/P444+TmprKp59+CkBycjI9evRg8uTJTJgwgT///JP777+fn3/+uc6z71ksFgIDAykoKCCghXyoXPLpLnavPErXIVFcOK4bRwqP8OzKZ1mTvgaA3uG9eX7Y87QPbO/hlgrR+BxZWZRs3ETpxg2UbNxE2c6d4HQet58hIgJz1y54dU3Eq2sXzF0TMbWNlxnq6olaWoot5TDWfXux7tmLda/rZj98uOYDdDrMHTrg1aMHXj26492zJ+YuXdC10J6vovE4nSqZyRaOJOVxZHceGckWnA71uP38Q7yIbBfg7vUTHu+P0Sy/D2qjqhr56SVkHCwg42AhmQct5BwpQlWPv4wMjvKhTZdgYrsG06ZzsIRUQgghmhZNg4IjVXo9VYRQSWArrPkYRQ+hHVzhU3hiZQgV2hEMJ79+LXWU8tamt/h85+doaIR5h/FUv8dIeOht0nJMbOk1GbOPgXHTh2EwtozrkbpmMw0aSi1btozzzz//uPVjx45lzpw5jBs3joMHD7Js2bJqxzz00EPs3LmT2NhYnnrqKcaNG1fn12yJoVT6gQIWvLwBg1HHuOnDMPsY0TSN+Xvn8+r6Vym2F2PSmbi7z92M7T4Wo04u/kTLpGkatuSDrgBqw0ZKNm7AfijluP0M0dH49O2LV/fueCV2xdy1K4aQEA+0WKjFxVj373eFVHv2Yt27h7I9e3Fm11C3ymjEq1MnV1DVswfePXpg7tix0WpxieZJUzVy0oo5sjuXI0l5pO3Jx26tHkybfQxEJlQGUBEJAfgEmDzU4pbDYXOSfaSIjOSKXmgWLFml1XdSIDzOn7jEYGK7hBDVMRCjqWVcbAshhGji3OHTbsjcVX3ona2o5mN0BgjpABFdqw+9C+0IhtO7dliXvo5nVj7D4ULXl7VXdriSRwY+Qtkbs8n96CO2951MZmA3ep0fyzk3dj7dn7bJaRKhlCe0xFBK0zS+emEtuWnFDL+pMz3Pi3VvSy9O57lVz7EidQUAXUO68txZz9EttJunmitEvXIWFFC8ciVFf/1N0Yq/cWYdE2YoCubOnfHp3w/vfv3x6dcXY0yMZxor6syekUnZju2Ubd9O6TbX0pl3/CyBipcX3r164d2/Hz79+uPdtw96Pz8PtFg0JZbsUo7sznMHUaWF1WfE9PI1VumpE0RQpI/UPWokpUU2ju4rcP/95KWXVNuuMyhEtw8ktmswsV1DiEgIkOLpQgghzoyqguXIMUPudp88fArtWK3eE+FdXYHUaYZPx7LYLLy2/jUW7F0AQKRPJM8MfYZzYs+hZN06Do0Zi9Xoz8ph09A0uOmpQYS2aTnXuRJKtaBQCmDLn4dZ8c1eQtv4ceOTA6tdXGuaxo8HfuTldS9TYC1Ar+gZ020Md/e5G29DzQXihWiqNFWlbMdOilf8TdFff1O6ZYvrjaacYjZXhhT9++Pdu3erq//UEmmahiMtzRVQ7dhO6fbtlG3fgVp4TBdqnQ5zly749OvnCiL798cYeaKJ70VLoGka2YeLOLAli+TN2eSkVr/ANJh0xHQKIrZLCLGJwYS18UORoKNJKM63usLD3XkcScqjKM9abbu3v5GEXmG07x1ObNdgDNKLSgghRG1UFQoOV4ZOmVXCJ3txzcfojK7w6bieTx1A33C98ZccWsLUNVPJKs0C4IbON/Bg/wfxN/njLCom+V//wp6aSvplU9hZ0oGo9gFc+8iABmuPJ0go1cJCqbJiO3Me/QenQ+W6RwcQ2e74ny27NJvpa6fz68FfAYjzj+PZoc8yKHpQYzdXiFPiyMujeMU/FP39F8Ur/sGZm1ttu7lTR3zPPge/4efg3b8/OpMMu2kNNFXFlpxMycaNlG7YSMnGjdhTjh+uaWzTBu/+/fAdNAjfoUMxtmnjgdaK+qY6VdL2FZC8OYsDW7Ioyq0MMxSdQlS7ANp0DSauawiR7QLQG3QebK2oC03TKMgs5fAuVw+31KQ8rCUO93aDWU98txDa9w6jbc8wqUUlhBCtlapCQYorbMrcVaXn054Th09hnSprPrl7PrVv0PDpWNml2by05iUWH1oMQEJAAs8MfYYBUZWB09GnniJ/3nwMbdqweshzWHKsXDAmkcSzohutnY1BQqkWFkoBLP54B3vWZNBtWDTnj06sdb9lh5fxwuoXyCzJBODaTtcyZcAUAkwt689DNG+O3FwKf1+M5bdfKVmztlpvKJ2vL75nDcX3nHPwO/tsGY4n3OyZmZRu3ETJxg2UbthI2a5d1f7tABjj4/EdMgTfs4biM3gwhuBgD7VWnCq71cnhnbkc2JLFwW3ZWIurBBZGHfHdQ2nXJ4yEHmF4+Ulg0dw5nSpH9+ZzYEs2yZuzqvWiUnQKMZ2CaN8njHa9w/EPOX4GIyGEEM2cqkL+oeN7PmXvAXtJzcfoTRDaqcpsd108Ej4dS9M0Fu5byCvrX6HQVohe0TOhxwTu7H0nZn1lIfTCpUs5cvc9oCgYpn3A77+WYfLSM2762S1uwhUJpVpgKJW2N4/vXt2Ewaxn/PRhmLwMte5baCvkjY1v8HXS1wCEe4fzn8H/4cK2FzZWc4U4jiM3l8LFf1D4268Ur1lbbZY8c9eu+J1zDr7nnI1P375S3FrUibOomLKtWyhZv57iVasp3br1uNkXzYmJlSFV//7ofHw81FpRE6dDJWVHDklrMji4LRunvTJk9PI1ktA7jPa9w4hNDJEC2S2Ye4jm5iySt2SRk1r9m/CItv50HhxFpwGRUqReCCGaG9UJeQerFxqv6PnkKK35mIrwKaJr9dnugtuBvvbPwZ5w2HKY51Y9x5r0NQB0C+3G82c9T5eQLtX2c+TlcWDUlTizswkZP57NIZexb0MmPYa34dxbutT01M2ahFItMJTSNI25z64hP6OE827tQvdzTj5EZUPGBp5d+SwHLQcBuKjtRTwx+AnCvMMauLVCuDjy8ihcvJjCX48Porx69CDgkpH4X3IJptjYEzyLEHXjLCqiZN06SlavpnjVaqx79lTfwWjEp08f/M4djt+552Lq2FEKYHuApmlkJFtIWpPOvvWZlBVXFir3D/WifZ9w2vcJI6p9IDq9DMtrjfIzS0jekk3yliyO7i+A8qtVRacQ3y2ELoOjSOgdJkGlEEI0Je7w6ZjZ7rL3gqOs5mP0JgjrfEzB8UQITmhy4dOxHKqDz3d+zszNMylzluGl92Jyn8nc1u02DLrqbdc0jdQHHqTw998xdexA1Cdf8enT61CdGjf8ZyDhcf4e+ikajoRSLTCUAti0OIWVC/YR0daf6x8fWKdjrE4r7215j4+3f4xDc+Bv8mdK/ylc0+kadIpc7Iv6p5aVUfj77xR8/wPFq1dXD6K6dcP/0ksIuOQSTHFxHmylaA0c2dkUr15D8epVlKxchT0trdp2Q0w0fsNdAZXv4MHSi6qB5WeUsGdtOklrM7BkVX4z6hNgotOgSLoMiiIszk+CQlFNicXG3vUZ7FmTTuahyskPjGY9HfqG03lIFG06B8ssfkII0Vgqwqdq9Z52nyR8MpeHT12q9H7q2izCp5rsytnFs6ueZWfOTgAGRw3mmaHPEBdQ8+ebgh9/JO3hR8BgIOHrr9id5n/Kn+ubGwmlWmgoVVpoY85j/7gS1ScGEh5f90Q1KTeJp1c+7T5x+kX045mhz9A+qH1DNVe0MqU7dpA/fz6Wn36uNmuauVsiAZdcSsAlIzHFx3uwhaI10zQNe0oKRX+voOiv5ZSsWYtmrVLDxmTCZ9AgV0h13rnyb7WelBbZ2Lc+k6Q16WQkW9zrDWY9HfqE03lwJLFdgqVHlKiTvPRi9qzNIGlNOoU5lR98fANNdBoURZfBUYTFtpzptIUQwqNUJ+Qmlw+5q6j5lOSq+eS01nyMwauy51PVGe+CE0DX/Hu3lthLeGfzO3y26zNUTcXf5M+/B/ybqzteXeuXavb0dA6MuhK1sJDwB+4n9K67TnkEVHMkoVQLDaUAfnt/+2mPPXWoDubumsvbm9+m1FGKQWdgYs+JTOw5sVoBNiHqyllQQMGPP5G/YAHWXbvc641t2hB4zdUEXnEFprZtPdhCIWqmlpZSsnYtRcuXU7Rs+XG9qEwJCfhdeAH+I0bg3bs3ik5Ck7rSNI2j+wvY8Vcq+zZmojpclxqKAnHdQug8KIr2fcJbXEFP0Xg0TSN9fwFJazPYtz6j2ix+ke0C6H5OGzoNiMAgw/uEEOLknA7IS65ebLyi51Ot4ZM3hFcZdlcRQgW1bRHhU03+OvIXU1dPJa3Ydc14ScIlPDro0ROWxtGcTlIm3E7JmjV49epFwtwvOJpcWOda0c2ZhFItOJQ6vDuXH2ZsxuilZ/xpVulPK0pj6pqp/HXkL8A1VeXTQ59mYFTL7Doo6pemqpSsXUv+vPkULl6MZrMBoBiN+F90EUHXXYvPkCHyIV40G5qmYTtwgKLlf1G0fDklGzaAo/JDrj48DP8LLsR/xAh8Bw9CMUmh5ZpYSx3sWZPO9r9SyU2rLFQdFudH1yHRdBwQgW+gfAEi6pfTrnJoRw5Ja9I5uDUb1em6tDX7GOg6JJruw2MIjvL1cCuFEKIJcDog90D1IXeZuyFnLzhtNR9j8K6c4a5qz6eg+BYbPh0ruzSb6Wun8+vBXwGI8Y3hP0P+w/DY4Sc/dtZ7ZM2YgeLjQ7sF8zG3a8fij3awZ20G3YZFc/7oxIZuvsdIKNWCQylN1fj86VVYssu4YExXEs+KOb3n0TR+P/Q709ZMI6csB4CrO17N/w34PwLNgfXZZNFCOPLyyJ83n/xvvsF+5Ih7vblLF4KuvZaAUVdgCA72YAuFqB/OoiKK//6bwj+WULR8OWpRkXubzs8Pv3PPxf+iEfidcw46X/mwm3nIwo6/UtmzLgOHzTV7nsGoo9OgSHoMb0NE25b5fiyanhKLjV0r09jxd1q14X1tOgfRfXgb2vcJR2+QL0yEEC2c0+4Kn6oWG89KcvV8Uu01H2P0cQ27iyif6a5ixrugttBKv2hWNZVv937Laxteo9BWiE7RMTpxNPf0uQcf48nrkJZs2sSh20aD00n0tGkEXX0VZcV25jz6D06HynWPDSAyoeVeI0ko1YJDKYANvx5k9cIDRLUP4NpHBpzRc1lsFmZsmMG8PfMACPEK4ZGBj3BZu8uk2KwAwHrgALmffErB99+jlbku8nV+fgRccTlB116HV4/u8m9FtFiazUbxmrUU/vEHhX8uwZmV7d6mmEz4Dh2K/8iR+I+4EH0Lft85lt3qZO/6DHb8lVqt+HRwtC89hrehy+BIzD5GD7ZQtGaaqpGyK5fty1M5tC2biqtdb38jicNi6H52DAFh3p5tpBBCnCmHrbznU3noVBFC5ew7cfhUNXSqCKEC41tt+FSTA/kHeG7Vc2zM3AhAt9BuPDP0GbqFdqvT8U6LheSrrsaelkbAFVcQ88rLKIrClj8Ps+KbvYTG+nHjfwa26M9QEkq18FCquMDKp4+vRFU1bnpqEKFtzryo58aMjTy36jkOFBwAYFjMMP4z5D/E+csMaa2RpmmUrFpFziefULz8L/d6c2IiIaNHE3DpJei85YJetC6aqlK6eQuFS/6g8I8/sB9KqdxoNOI3bBgBl12K3wUXoPdrmcWWi/KsbF16mJ0r0tx1fHQGhQ59I+gxvA3RHQNb9AWWaH4Kc8vY+U8aO1ekUVJQPjxFgYSeYfS9KF7+zQohmj6HDXL3H9/zKWcfqI6ajzH6Vg+dKkKowDgJn07A6rTy4bYPeX/b+zhUB94Gb+7tcy+3JN6CQVe32k+appE6ZQqFi37FGBtLu4XfoffzQ9M0vnphLblpxQy/qTM9z4tt4J/GsySUauGhFMCiWds4sDmLXufHcs6NnevlOW1OGx9t/4jZW2djV+2Y9Wbu7HUn47qPw6iXb7xbA9VqxfLTT+R+8inWPXtcKxUFv/PPJ2TsWHwGtexEX4i60jQN2759WH7/ncJff8W6d597m2Iy4Tv8HAIuvRT/889H53PyLt5NXfaRQjYvPszedRmoquvSISDcm+7nxJA4NBpvf6mzJZo2p1Pl0NYctv91hMO78tzrI9r60+eieDr0DZdZIIUQnuWwuYImd72n8vApd3/t4ZPJr7LmU0X4FNEVAmIlfDpFq9JWMXXNVA5ZDgEwPHY4/xn8H2L8Tq1cTv78+Rx98ikwGEj44nO8e/cGIP1AAQte3oDBqGPcy2dj9m6ZBc4rSCjVCkKpQzty+OmtLZh9DIz777B6nWEmuSCZF1e/yNr0tQC0D2zPk0OelELoLZgjO5u8L78i76uvcOa4aowpPj4EXX01IaNvw5SQ4NkGCtHEWffuxbLoVyyLFmFLTnavV7y88DvvPAIuuQS/c4c3qx6GmqaRsjOXzYtTOLK78kN8TKcg+lwUT0KPUBSdhNSi+clLL2bzksMkrU7HaXfVQfMP8aL3hXEkDotusTMhCSGaCIe1MnyqOttdzn7QnDUfY/IvLzReEUBV9HyKdU1vK05bdmk2r6x7hV+SfwEg3DucRwY9wsi2I0/5y3jr/v0kX3c9Wmkp4f83hbBJk9zblnyyk92r0uk6JIoLx9VtGGBzJqFUKwilVFXjsydXUpRrZcT4bnQZHFWvz69pGj8d+In/rf8fuWW5AFzZ4Ur+b8D/EeIVUq+vJTzHnpFBzvsfkP/NN+5Z9AzR0YTcditB112HPlCK3gtxKjRNw5qU5A6o7CmVQ/x0vr74X3wxgVeOwmfQIBR905y1xmlX2bMunc1/HHbPoqfoFDr2C6fPRfFSuFy0GKWFNrYtT2XbsiOUFbnqr5i8DfQYHkPP8+LwC5bZIoUQZ8BhdRUXP3a2u9wDtYdP5oDKXk9Vh94FxEj4VM+cqpP5e+bzxsY3KLS7Cpnf1OUm7u17L/4m/1N+PtVq5eCNN2HdvRvfs4YS98EH7tnIraUO5jyyAodd5ZqH+xPdoeV/xpJQqhWEUgDrfk5m7Y/JxHQK4ur/69cgr1FgLeCNjW+4C6EHmAKY0n8KV3e6Gp0iXUKbK3tGBjmz3yd/3jx3GOXVqxeh48bif9FFKEYZrinEmdI0jbKdOylctAjLL4uwp6W5txkiIgi44goC/3UlXl26eLCVlcqK7Wz/K5VtS49QYnH9XjCa9XQ7O4ZeF8QSENp8enkJcSocNidJa1xBbH5GCQA6nUKngZH0uSiesNiWWSNOCFFP7GWQs7e83lPFsLvdkJt88vApomt5CFV+k/CpUezK2cULq19gW/Y2wFXI/OkhT9M9rPtpP2f61JfI++wz9CEhtFv4HcaICPe27cuPsPzLPQRH+3Lz04NaRTkUCaVaSShVlFfGp0+sRNPglmcHExzVcFOTb87czAurX2BPnqvOUJ/wPjw19Ck6B9dPPSvROOzp6ZVhlN31rbB3//6E3zsZnyFDWsUvSCE8QdM0SjdtouCHH7As+hW1oMC9zdy5M4FXjiLgiiswRtVvr9e6KCuys+XPw2z98zC2MtfFs2+QmV4XxNL97BiZRU+0GpqqcXB7DpsXp5C2N9+9vl3vMAZe3o7w+FP/5lwI0YLYS4/p+VQ+411eMmhqzceYA6sHTxX3/aMlfPKAIlsRMzfPZO7uuaiaiq/Rl/v73s+NXW5Erzv9HuyFfy7lyD33ABD33iz8zj3XvU3TNL55aR3Zh4s4+/pO9L6wdUwkJqFUKwmlAH6euYWD23LoMyKOYdd1atDXcqgOvtj1BTM3z6TUUYpe0TOm2xju6n0XPsbmX8i3JasxjBrQn/B778Vn8GAJo4RoRKrNRvFff1Hww48ULV3qPidRFHwGDSLwyivxHzkSvV/DfdEArqFLm/84zLZlR7BbXWFUaBtf+l7clo4DItBL0WfRimUesrDp9xT2bcyE8qvlhJ6hDLi8HZEJreMaU4hWy14K2Xuq13vK2g15B2sPn7wCK+s8RSRWhlD+URI+NQGaprH40GKmr51OZmkmAJckXMLDAx8mwifiJEefmD0jg+R/XYUzP5+QsWOJfPyxatszD1mYN209eoOOcdOH4eXbOr7sk1CqFYVSyVuy+OXdbXj5Ghk77ax6LXhem/TidP679r8sSVkCQJRvFI8OfJQL4y+UcKOJsR89Ss7775M/b777g6/PgAGE3XsvPoNbR9dRIZoyZ0EBlt9+w/LDj5SsX+9er/j4EDByJEHXXI33gAH1eq6WWGxsWpzC9uVHcNhcF9dhcX4MvKwd7XqHSfFyIarISy9m/aKD7F2bQcVVc3z3UAZenkBU+5ZfE0SIFs1W4gqfqtZ7qgifqOVjsldQ9VpPFSGUX6SET01UiiWFl9a+xD+p/wAQ6xfLk0OeZFibYWf83JrTScqE2ylZswZzt0QSvvoKnan6jMR/fraLXf8cpdPASC6+/fSHBzY3Ekq1olBKdap8/tRqCnPLOO/WLnQ/p02jvfayw8uYtmYaacWuOinD2gzjiUFPEB8Q32htEDVz5OWR/e675H/5VWUYNXAgYffei+/gQR5unRCiJvbUVAp+/ImChQuxHTzoXm9sG0/Q1VcTeNVVZzS8rzjfyqbfU9jxdyqO8hnHItr6M+DydiT0DJWQWogTyM8oYcOigyStzUBTXZfPcYnBDLi8HTEdgzzbOCHEidlKIDupcrhdVhJk7YK8Q9QaPnkHV4ZO7mF3ieAXIeFTM1HmKOODbR/w0faPsKt2DDoDt/e4nYk9J+Jl8KqX18ie9R5ZM2ag+PjQbsF8zO3aVdteYrHx6RMrcTpUrvl3P6Jb0fuFhFKtKJQC2LQ4hZUL9nmkcFqpo5T3t77PnB1zsKt2TDoTE3pO4PYet9fbyS7qTrXZyPv8C7JnzUK1WADwGTSIsMmTJYwSoplw1Z/aTP63Cyj8ZRFqiavwMjodvsOGEXTN1fhdeOFx38TVpijPysbfDrFzRRpOhyuMimwXwIDLEmjbQ8IoIU5FQVYJG349RNKqdNTycKpNlyAGXt6ONp2DPdw6IVo5W3F54FQeOlWEUPkp1B4+hVQfbldR88k3XMKnZmz54eVMWzuN1KJUAIZGD+WJwU+QEJhQb69RsmkTh24bDU4n0S+9RNA1Vx+3T8XEZBFt/bnusfrt+d7USSjVykIpa6mDTx77B7vVyaj7exPfLbTR23Cw4CAvrXmJVUdXAdDGrw2PD3qcc+POPcmRoj5omkbhokVkvvY69iNHADB36ULEIw/jN+zMu6YKITxDLSnB8tvvFCxYUG14nz4wkIArriDo+uvw6tq1xmPLiuxs+PUg25alusOoqPaBDLwigbjEkFZ1YSREfbNkl7Lht0PsXnkU1VnZc2rIVR2IaNt6rkGF8AhrUeWwu6o9n/JTaj/GJ6zm2e78whuv3aLBHSk8wvS101l2ZBkAkT6RPDLwES5qe1G9Xvc48/NJvuZa7GlpBFx+OTH/e+W453faVT75z0pKLTYuur0bnQc2/mQ2niShVCsLpQD+/noPW5ceIb57CKPu6+ORNlQUkHt53ctklGQAcF7seTw66FFi/WM90qbWoGTjRjKmT6dsy1bANdV8+AMPEHjVv1D0DV9jTAjROGyHDpH/3XcULPweR3q6e71Xr14E33gDAZdeis7HB1uZg61/HmbT7ynu2fSiOwYy8Ip2xHYJljBKiHpUmFvGxl8PsfOfNHc41aFfBEP+1Z6gSJkERogzYi1yDbs7tuD4ycInd8+nKkXHfcMar92i0VmdVj7e/jEfbPsAq9OKQTEwuvto7upV/xNyaarK4bvuovivvzHGxdHu2wXo/Y+fnXX3qqMs+WQXvkFmRk8d2uomkJFQqhWGUgVZJXz+9GrQ4OZnBhMS3bCzNp1Iib2EWVtn8dmOz3BoDsx6MxN7TmR8j/GY9WaPtaulsR06ROarr1H4+++AqzBy6MTbCR03Dp2PXAgL0VJpTifFK1eRv2ABhUuWQMXsff6B5Jw/gT2OzpSWuHpGhcb6MfSqDsR3l55RQjQkS3Ypa39MJmltOmig6BQSh0Uz8LJ2+AXLtY8QJ2QthKw95UPuKgqOJ0HBCcIn3/Djh9xJ+NQq/ZP6Dy+teYmUQte/l0FRg/jP4P/QPqh9g7xe9rvvkvXGmyhmMwlffYlXYuJx+2iaxtdT15FzpIghV7Wn/yUJDdKWpkxCqVYYSgH88u5Wkrdk0+2cGM6/tebhHI3pQP4Bpq6Zytr0tQDE+8fz6KBHGR473MMta94ceXnkzJpF7twvXR9GdTqCrruO8PvuxRAuXZCFaE0cOTnkf/sdOxftYK//UMq8XRfjPs4C+vbW03PsBej9/TzcSiFaj+wjRaz5fj8Ht+UAoDfq6HV+LP1Gtm0104ALUasyi2vYXeauKj2fkqDgcO3H+EYcP+QuvCv4Nn65EtG0pBal8r91/+OPlD8ACPcO598D/s2l7S5tsC/iileuJOX2iaBpRE+dStC119S435GkPL5/fRMGk46x04a1yt//Ekq10lAqdU8eC1/bhN6oY+y0s/D2q1sR3IakaRqLkhfxv/X/I6s0C4BzY8/lkYGPyCx9p0hTVQq+/ZbMV/6Hs6AAAN/h5xDx73/j1bmzh1snhGhsmqZxaHsOqxceICe1CAAzZbTd/yMxR/5GpznR+foScOUogm+4ocZv8oQQDSNtXz6rv9vP0f2u92uTt4F+I+PpdX4cRrMMrRctXFlBeZ2n3dVnvLMcqf0Yv8iaez75hDReu0WzUOYo4+PtH/Ph9g+xOq3oFT23JN7CPb3vwc/UcF/E2dPTSb76Gpx5eQRedy0xL75Y674/v7OVg1uz6TG8Defe0qXB2tSUSSjVSkMpTdP45qV1ZB8uYvC/2jPg0gRPN8mtyFbEe1vf4/Odn+PQHBh1RsZ1H8fEnhPrfZxvS1SWtIf0Z5+ldNMmAMydOxPx6CNSxFyIVirjoIV/5u/l6L7yD7xeevqObEvvC+JQivIp+O478r6Zhz2lcuiDd9++BN9yM/4jR9Z55j4hxOmrDI73k5NaDIBPgIlBo9qROCwGnU6G1IpmrjS/Svi0u3LoXWFa7cf4RR3T86mLhE+iTjRN48+UP3ll/SvuWfUGRg3ksUGP0Tm4Yb+g12w2Do0ZS+nmzZgTE0n4ci46r5pnms/PKOGLZ11ldW55djDBUZ4rq+NJEkq10lAKIGn1Uf6YswufQBNjpp6F3tC0CqodKDjA9LXTWZm2EnDNiPDvAf9mZMJIqXdSA7W4mKyZ75D7ySfgdKLz8SHs/vsIue02FIPB080TQjSyorwyVi88QNIaV6FzvVFHr/PKhwb5Ve8arqkqJWvXkvf11xQu/gMcDtcxISEEXX89wTfegDEmptF/BiFaG1XV2Lsug7U/HsCSXQZAaBs/hl3fkbiu8kFcNAPu8GlXlZ5Pu6HwaO3H+EeX93pKrAyewruAd3CjNVu0HDV+hhz4b0a2bZzPkOlTXyLvs8/Q+fvT7tsFmOLiat33r6/2sG3ZEdr2DOWKyb0bvG1NlYRSrTiUcjpUPv3PSkoKbIwY340ug5ve1JOapvHn4T95ZV3jp9zNhaZpFC1ZQvrUl3Acdb3h+198MZFPPI4xqun9nQohGpbd6mTT4hQ2/XYIh91VxLzLkCiG/Ks9fsE1f1NX7fjMTPLnzyf/629wZLhmR0Wnw+/88wm+5WZ8hw5F0TWtLzGEaGmcDpXty1NZ93My1hJXSJzQK4xh13aUmfpE01CaV324XUUIdcLwKaa851Ni5Wx3YZ3BO6jRmi1ariJbEbO2zOKLXV94bLSN5ZdfSJ3yfwDEvjMT/wsuqHVfa4mdOY+vxGF1cuUDfYhLbL1fPEgo1YpDKYD1vxxkzQ8HCI/35/rHBzTZHkg1jQe+scuNTO47mQBT6/37sx1JJePFFylatgwAY2wsUU89id+553q2YUKIRqepGnvWZbDqu/0U51sBiO4QyLDrOxGZcOq/JzW7ncI/l5I3dy4la9a415sSEgi++SYCr74afSt+/xSiMZQV2Vn7czLbl6eiqRo6vULP82IZcFlCqyyGKzygJLeGnk9JUJRe+zEBbcp7PCVWGX7XBbwCG6/dotVQNZWfDvzE6xteJ7s0G/BMXWLrgQMcvO561JISQidNIuL/ppxw/42/H2LVt/sJbePLjU8OarKfwxuDhFKtPJQqLbLxyeMrcdpVrv6/vsR0atrdZI+dOSHYHMwD/R7gqo5Xode1nmKgms1GziefkD3zHbSyMjAaCZ0wgbC77kTn7e3p5gkhGtnR/QWs+GYPmYcKAfAP8WLoNR3o2D+iXi5yrPv3kzf3SwoWLkQtdtW7Uby9CbzySkJG34a5Y8czfg0hRO1yjxazcsE+Dm13zdTn5Wtk0Kh2dD8nBp1eei6KelCSW73WU8X9oozajwmIrWG2uy7g1Xo/W4nGtSNnB/9d8182Z20GPDeDu1pcTPKNN2Lbtx+fwYOJ//CDE5ZPUZ0qnz25iqI8K+eP7kq3Ya27RIKEUq08lAJY+vludq5Io32fcC69q6enm1Mnq9JWMW3tNJILkgFIDEnk0UGP0j+yv4db1vBKt2zh6JNPYt27DwCfgQOJevYZzB06eLhlQojGZskpZdV3+9m3PhMAo1lP/0vb0vvCOAzG+g/q1eJiCn78kbwv5mLdu9e93vesswgefRt+554rQ/uEaEApO3JYMX8feUdd4XBwtC/DrutI2+4y5b2oo+Kc6sXGK0Ko4szajwmMq1LrqWvlsDsJn4SHZJdm88bGN/h+3/doaHgbvLmj1x2M6TYGk75xJ2jRNI20hx/B8tNPGMLDaffdtxjCwk54zN71Gfz+wQ68/Y2MeemsBrlma06aVCg1c+ZMXnnlFdLT0+nduzdvvfUWgwYNqnHfOXPmMH78+GrrzGYzZWVldXotCaUq5aYV8+Xza0CB254fSmB48+hpY1ftfLnrS2ZtmUWh3dU7YGTCSKb0n0KMX8tLm1Wbjey3Z5LzwQegquhDQoh89BECrryyVXf3FKI1stucbPz1EJt+T8HpUEGBbmdFM+jK9vgGmhv89TVNo2TdOvI++4zCJX+C6qpdZWwbT8ittxF4zdXo/RpuqmUhWjPVqbJzRRprfkimrNgOQNseoZx9QyeCIqTelChXnF0eOO2qPutdcVbtxwTGl9d6quj1lAjhncHs33jtFuIEbE4bn+/6nNlbZ1Nsd4Xzl7e/nAf7PUiUr2dq6ebOnUvG8y+AXk/bT+bgM2DASY+ZP309GckWBlyewOBR7RuhlU1bkwmlvv76a8aMGcOsWbMYPHgwM2bMYN68eSQlJREREXHc/nPmzOGBBx4gKSmpspGKQmRkZJ1eT0Kp6n58czMpO3PpdUEs59zQvAqI55bl8vamt1mwdwGqpmLWmxnfYzzju49vtKJ2Da1s507SHnsc6549AARccQVRT/4HfVCQZxsmhGhUmqZxcGs2f3+zl8Ic15cwbToHMez6ToTHeeZDg+1IKnlz55I/fz6qxQKAzteXwGuuIeTWWzAlJHikXUK0dNYSO+t/OcjWpUdQnRo6g0K/i9vS75K2GE2t+1v3VqUo6/heT1m7oCSn9mOC4iuLjYd3dYVQYRI+iaZL0zSWHl7K/9b/j8OFhwHoEdqDRwc9Sp+IPh5rV+nWrRy89Taw24l49FFCx4876THpBwpY8PIGdAaFsS8NwyegcXt2NUVNJpQaPHgwAwcO5O233wZAVVXi4uK47777eOyxx47bf86cOTz44IPk5+fX6fmtVitWq9X92GKxEBcXJ6FUuZQdOfz41haMZj1j/zsMs3ftY2CbqqTcJKavm8669HUARPhEMKX/FC5rd1mz7Umk2e1kvzeb7FmzwOFAHxJC1LPPEHDxxZ5umhCikRVklfD3N3s5tM31QcMv2Myw6zrRoV94k/gdp5aUUPDDD+R+9jm2/ftdKxUFv+HDCRk7Bp+hQ5tEO4VoafIzSvjr6z0c3pkLuGrKnX1DJ9r1DpNzrqXQNFcPp2PrPWXtPkn41NY11K6i6Hh4F9fN5Nt4bRfiDO3N28vL615m9dHVAIR7h/Ng/we5ov0V6BTPlQxw5OWRfM21OI4exf/ii2nzxow6/c797f3t7NuQSdehUVw4tlsjtLTpaxKhlM1mw8fHh/nz53PVVVe5148dO5b8/Hy+//77446ZM2cOEydOpE2bNqiqSr9+/XjppZfo3r17ja/x7LPP8txzzx23XkIpF03T+PK5NeSllzDsuo70GdF4MxXUJ03T+CPlD15d/yqpRakA9Anvw2ODHqN7WM3/Npoq6969pD36GGU7dwLgf/HFRD37DIaQ1jtdqBCtkcPmZONvh9j4m2uonk6v0GdEPAMuS8Bobnq9ITRNo3jlSvI+/Yyi5cvd681duhAybhwBl1+GziTfCgpRnzRN48DmLFZ8s5eiPNeXsG17hHLOjZ0IDG8ZvcZbhYrwyT3kbldlCFWaW8tBCgS3rQydKkKosM4SPolmrcBawMzNM/km6RucmhOTzsTY7mOZ2HOix0fDaHY7KbdPpGTtWkxt25KwYH6dyhYU5pbx2ZOr0FSNG58cSFis9E6EJhJKpaWl0aZNG1auXMnQoUPd6x955BGWL1/OmipTUVdYtWoVe/fupVevXhQUFPC///2Pv/76ix07dhAbG3vc/tJT6uR2/J3Ksi+S8A/x4rYXhjTr2VysTiuf7viU97e9T6mjFIB/dfgX9/e7nwif44eDNiWa00nORx+R/eZbaHY7usBAop56ioDLm2+PLyHE6XEN1duDJds1VC+2azDDb+pMcFTz+KBhO3iQ3M8+J/+779BKSgDQh4cRcuutBN14I4bgpj3jqxDNjd3qZP2ig2xenILq1NAbdPQdGU//kW0xyJC+pkPToCjTFTplJVUPoUrzajlIgeCE43s+hXUGkwSPouWwq3a+SfqGd7e8S4G1AIAR8SOYMmAKcf5xHm6dS/rzz5M390t0vr4kfP1VnWch/mfBPjYvTqFNl2CueqhvA7ey+Wi2odSx7HY7iYmJ3Hzzzbzwwgsn3V9qSh3PYXPyyeMrKSu2c8kdPejQr2mHN3WRUZzBGxvf4McDPwLgbfBmfI/xjO021uMJe02sB5I5+vjjlG7ZAoDfeecR9fxzGGuoqyaEaLks2aX8/c1eDm7NBpreUL1T5SwoIH/ePHI/+xxHhmt6ccXLi8CrryJkzBjM7dp5uIVCtCx56cX8/fUeDu9yBRwBYV6cfUNn2vU68YxQop5pGhRlVA+dKkKosvxaDlIgpF31me4qwidj85iMSIjToWkay48s59X1r3LQchCATsGdeGzgYwyKrnnyM0/I++pr0p99FhSF2Jkz8b/g/DodZytz8MnjK7GVOrjsnl7y+7iKJhFKnc7wvZpcf/31GAwGvvzyy5PuK6FUzVZ/v58Niw4R3SGQax7u7+nm1JutWVt5Zd0rbM7aDLjqTT3Q7wGPj0WuoGkaeXPnkvnyK2hWKzo/PyIff5zAa65ulh9AhRCnx2lX2fj7ITb8eginXUWnU+hzURz9L03A5NX8av0dS7Pbsfz6K7kfz3EPTUZR8DvvPELGj8Nn4ED5nSdEPdE0jf0bs/hnfuWQvoSeoZxzY2cCwiTcqFeaBoXpNfR82l17+KToILhdZaHxihAqrJOET6LVScpN4pX1r7DmqKszSohXCJP7TOaaTtdg0DWd65+Sdes4NH4COByEP/QQYXfeUedjty49wt9f7yEwwptbnx2CopPrnQpNIpQCV6HzQYMG8dZbbwGuQufx8fHce++9NRY6P5bT6aR79+5cdtllvPbaayfdX0KpmhUXWPn0iZWoTo3rHhtAZELL+bPRNI3fDv3GjA0z3PWmuoV24+EBDzMg6uRTdzYUZ0EBR598ksLFfwDge9ZZRE99EWN0tMfaJIRofGl781n2xW7y0l3D3Np0cQ3VC4luHkP1ToWmaZSsW0funE8oWrrU9YEO8OrWjZDbJxAwciSKoelchArRnNnKHGxYdJDNiw+jqhoGk45Bo9rT+4LYZl2qwSM0DSxpNcx2lwTlw4yOUxE+RSRW6f3UFUI7SvgkWr2skize3vw23+39Dg0Nk87E6G6jmdhzIn6mk9doakz21FSSr7seZ14eAZddRsyr/6vzF2maqvHFM6spyCpl+E2d6Xne8eWGWrMmE0p9/fXXjB07lvfee49BgwYxY8YMvvnmG3bv3k1kZCRjxoyhTZs2TJs2DYDnn3+eIUOG0LFjR/Lz83nllVdYuHAhGzZsoFu3k1exl1Cqdn98vJOkNel0GhjJxbc3r+LgdWF1Wvli1xfM3jqbYnsx4Bqn/FD/h4gPaNwC7yWbNpH6f/+HI+0oGI1E/vv/CB4zRnoKCNGKlBXbWfXdfnauSAPAO8DEOdd3ouOAiFbxu8CanEzeZ5+R/+13aGWu2lnGNm0IGTuWoOuuRefT9IZaC9Ec5R4tZvncJNL25gMQFufH+bd1JaKtXAcfR9PAklrDbHdJYLXUfIyih5D2VYqNlwdQoR3B6NW47ReiiStzlPHJjk/4cPuH7vq/lyRcwoP9H6SNXxsPt+54akkJB2++BWtSEl7dutH2i8/Redc9VE7eksUv727D7GNgzEtntYje7/WpyYRSAG+//TavvPIK6enp9OnThzfffJPBgwcDcN5555GQkMCcOXMAeOihh/j2229JT08nODiY/v378+KLL9K3b90KhkkoVbuslEK+eWkdOp3CbS8OxT+kZb6R5pTm8M7md5i/dz6qpmLQGbil6y3c2ftOAkwN+29CU1VyPvyQrBlvgNOJMT6eNq++infPHg36ukKIpkPTNPZtyOTvb/ZSarEB0O3sGIZe3QEvX6OHW9f4HHl55H/1FbmffY4z1zXLlC4wkOBbbibk1lsxhEntBSHOlKZq7Fp1lJUL9mEtcaAo0OuCOAaNatc6PyRVhE/u4GlXZc8nW2HNxyh6CO1QWWw8okr4ZDA3bvuFaGZUTeWX5F94Y+MbpBenA9ArrBcPD3yYPhF9PNu4WmiqSuqDD1H4++/oQ0NpN3/eKY9oWfjaRlL35NP34njOuqZuRdFbkyYVSjUmCaVO7LtXN5K2N59e58dyzo2dPd2cBrUvbx//W/8//kn7B4AgcxB39rqTG7vciFFf/x8MHTk5pD36GMUrVgAQcNllRD3/XJ2mERVCtAyWnFL++nIPh7bnABAc5cN5t3YlplOQZxvWBKhlZRQs/J6cjz/CfigFAMVkIvCqqwgZP06KogtRD0osNlbM28veda6JB/xCzJx7cxcSerbQ8FfToODIMUPuThI+6QwQ0qF6vSd3+GRq3PYL0QKsT1/Pq+tfZXvOdgCifaN5qP9DXJJwSZPuGZ41cybZb70NRiNtP5mDT79+p3T80f0FfPvKhhbf4eNMSCgloVSNDu/K5Yc3NqM36hj94lB8A1v+Nz8rUlfwv3X/Y3/BfgDi/ON4oN8DXNz24nr7RVm8ejWpDz+MMysbxcuLyP88QdB11zXpX8RCiPqjOlW2Lj3Cmh8O4LCp6AwKAy5NoN/FbdEbpbZLVZrTSeGSJeR8+CFlW7a6VioKfhdeQOjtt+NTx57RQojaHdqRw/K5SRTmuIbOdugXwTk3dmq+132aBgWHqxQbrxo+FdV8jM7gCprCu1Sf8S6kg4RPQtSDAwUHeH3D6yw7vAwAH4MPk3pN4rbE2/AyNO2AxrJ4Man33Q9A9IsvEHTddaf8HD++uZmUnbkkDovmgtGJ9d3EFkFCKQmlaqRpGt++spH0AwX0vjCOs6/v5OkmNQqH6uC7fd8xc9NMcspcPRh6hffi3wP+Td+I0/8ApDkcZL/zDtnvzgJNw9SxA7Gvv465U+v4cxVCQOYhC8u+SCIrxfWtfEynIM67tQvBUS2vkHl90jSN0g0byPnwI1dR9HLeA/oTNmkSvsOHS7AvxBmwW52s+ymZzUsOo6kaJm8DZ13TgW7DYpru7FCqWhk+VZ3xLnvPCcInY2X4FJFYOfwupL2ET0I0gOzSbN7d/C4L9i7AqTnRK3qu63wdd/W+izDvpt8rsyxpDwdvvhmtpITg224j6sn/nPJzpCcXsGD6BhSdwq3PDSEwXCY3qImEUhJK1SplRw4/vrUFg1HH6Kln4RPQet6wS+wlzNkxhzk75riL710YfyEP9nuQhMCEU3oue3o6qf/+N6XrNwAQdP11RD7xxCkVxxNCNF8Om5O1PyWzeXEKmgZmHwNnXduRxKHRTfcDXxNl3b+fnI8+ouCHH8FuB8DcpQuhEycScOklMmOfEGcg63Ahyz7fTeYhV3Ae3TGQC0YnEhTpwckGVBUKUo4pNr4bsvZA+WQ1x6kInyK6ukKnih5QoR2gAcoyCCGqK7GX8MnOT/h4+8fuz1Hnx53Pg/0fpH1gew+3rm4ceXkcvO567Kmp+AwdQvz775/WNcZPM7dwaFsOXYdGceHYk0/G1lpJKCWhVK00TWP+9A1kHrTQ56J4hl3b+oqyZZVkMXPzTL7b9x2qproT/rt7302od+hJjy9evYbUhx7CmZeHzteXqOefI/Dyyxuh5UKIpuDovnz+/Gw3+RklAHQaEMHZN3RuVSF/Q7BnZJD7yafkf/UVaonrz9YYG0vIhPEEXXMNOq+mPRxAiKZKVTW2LTvC6u8P4LA60Rt1DL6yPb0vjEPXkCG6qkL+oeNrPmXvAXtJzcfojBDWqcqQu/JlSHsJn4TwAKfqZOG+hczcPJOs0iwAeob1ZEr/KQyIGuDh1tWdZreTcvtEStauxRgXR8I3X2MIDj7l58k8ZGHetPUoCtzy7BDPBvxNnIRSEkqd0MFt2fw8cysGk44xU8/C2791fpDal7eP1ze+zl9H/gLA1+jLhB4TGN1tNN6G43s8aZpG3mefkTH9ZXA6MXdLJPb11zG1bdvYTRdCeIDd6mT1wv1sXXYENPANNHHurV1p16vpd1dvTpwFBeR9+SW5n3yKMy8PAH1oKCFjxhB8803o5f1diNNiyS5l2Re7ObzLdV5FtgvggtGJhMSc4XBj1ekKn2rq+VTeo+I4ehOEdjq+4HhIe9BL70ghPE3TNP5O/ZvXN7zOvvx9ALTxa8OD/R5kZMLIZjXEXtM00p99jvyvv0bn40PC11+ddrmVn9/ZysGt2XQZHMWI8dJL6kQklJJQ6oQ0TWPetPVkpRTSb2Q8Q69ufb2lqlp7dC3/W/8/duXuAiDCO4K7+tzF1R2vxqBzXRipZWWkP/MsBd9/D0DAlaOIfv55+eZeiFbiyO5cln6+G0u2q3Bw4rBohl3bEbOPfHPfUNTSUvK//ZbcDz/CnpYGgM7Xl6CbbiRk7FiMEREebqEQzY+maexaeZR/5u3FVuZEZ1AYeFk7+o6MR68/ycQMqhPyDtbc88lRVvMxehOEda6s9VQRQgW3k/BJiCZqa9ZWXt/wOusz1gMQYArgzl53clPXmzDpm19nhpwPPiDzf6+CohA78238L7jgtJ4nK6WQb15aBwrc8sxgqR96EhJKSSh1Uslbsvjl3W0YzHrGTB2Kt1/z+wVTn1RNZVHyIt7c+CZpxa4PPwkBCdzf737ONXYn9b77KduxA/R6Ih95mOAxY5rVNwRCiNNjLXWw8tt97Pzb9XvBL8TM+bd1Jb7byYf6ivqh2e1Yfv2VnNnvY927FwDFZCLwmqsJnTgRU2ysh1soRPNTlGdl2dzdHNrmmgAmLM6PC8YkEh7nXz18qjrbXfbeE4RPZgjvXN7jqTyACu8KwQkSPgnRTBwoOMBbG9/ij5Q/ADDpTNySeAsTe04k0Bzo4dadHssvv5A65f8AiHzicULGjDnt51o0axsHNmfRaWAkF9/evb6a2GJJKCWh1ElpmsY3L60j+3AR/S9ty5B/dfB0k5oEm9PGN0nf8N7W98i35pOYovHI9wq+RQ70QUG0mfE6vkOGeLqZQohGcGh7Dsu+2E1RnhWAHue2YejVHTB5yQcsT9A0jaLly8l5bzalmza5Vur1BF5xOaGTJmHu2Lp7/QpxqjSngz1Ld/D3T9lYyxR0ikq/iL8YoP8AvVpLwXGDV3nPp67Vh94FJ4BO36jtF0LUj4ziDN7d8i4L9y3EqTnRKTpGtR/F5D6TifaL9nTzTlvJhg2kjBuPZrcTPGY0UU88cdrPlX2kiK9fXAsK3PzU4DMf9twKSCgloVSdHNiUxaL3tmH00jNm6ll4+cowlAqF1kKWzPg3HT75C4MKyZGw9J7BTLzocbqEdPF084QQDais2M6KeXtJWp0OQECYFxeMTqRNl1MviCnqn6ZplK5fT/Z7sylescK93v+iEYTecSfePXt4sHVCNEFOB+QlVx9yV9HzyWml2BnEX5Y7OGAdCkCIIYULQmYTGaOHiMTqQ++C2kr4JEQLUWAt4KPtH/HFri+wOl1fwJ0Xdx4P9H2AjsHN+4se64FkDt18M86CAvwvGkGbGTNQ9Kf/u+vX2dvYvzGLjv0jGDlJrjPqQkIpCaXqRFM1vp66lpzUYgZcnsDgUc1jOs+GplqtpD//PAULvgUgZUhbnj4nnRKDEwWFy9pfxr197iXWX4aMCNHSHNyWzdLPd1NSYAMFel8Qx+Ar22M0y4ewpqh023ZyZs+mcPFi9zrfYcMIvfMOfAYOlGHWonVx2iE3uXqx8czdkLMXnLaajzF4lw+7S2Rf6SD+Wp9AaamCokC/kW0ZeHk79MaT1JoSQjQrZY4yvtz9JR9s+wCLzQJA34i+PNjvQfpF9vNw686cIyeHgzfdjP3wYbx69aLtJ3PQeR8/iVVd5aQW8dULawG46alBhLbxq6+mtmgSSkkoVWf7NmTy2/vbMXkbGDN1aKsv2mvPyODIffdTtnUr6HRE/PvfhIwfx+HCw7y96W0WHVwEgEFn4IbONzCp1yTCvGXmLSGaO1upg3/m72XnP0cBCIr04YIxiUR3aJ41FFob67595Lz/PgU//QxOJwDe/foRducd+A4fLuGUaFmcdsg9UF7vKQmyypfZe0G113yM0QfCOlUpNl7eAyqoLegqQ6fSIht/f72XvesyAAht48eI8YmExfo3xk8mhGhADtXBD/t/4J3N75BR4jrHOwZ15IF+D3Bu7Lkt4r1SLS3l0LhxlG3ZijE2loSvv8IQemZ1QH//YDt712fSoW84l9zZs55a2vJJKCWhVJ1pqsaXL6wl72gxg0a1Y+Dl7TzdJI8p3bqVw5Mn48zKRhcYSJvXXsVv2LBq++zI2cEbG95g1dFVAHgbvLkt8TbGdh/bbAsACtHaHdmdy5JPd1GUa3X1jjo/jsFXtcdokt5RzY3tyBFyPvyQggXfotlcPUPM3RIJu+su/EeMQNFJjw/RjDjtkLO/MnSqCKFy9p04fArvUlnrqaL2U2B8tfDpZPZvzGTZ3CTKiuzo9AoDL29Hv5Hx6E42Q58QoslRNZXfD/7OzM0zOWg5CECUbxST+0xmVPtR6JvokFxVVbHZaunlWQPN6SRj2jSK/1mJzt+fNq++iinuzEa25GeW8PM7W0GDS+/qSUi01JKqYDQa0Z9gSKSEUhJKnZK96zL4/cMdmH0MjJl6Fibv1lfE17J4MWkPP4JWVoa5c2diZ76NKS6u1v1XH13NmxvfZFv2NgD8Tf5M6DGBW7rego/Rp7GaLYQ4A3abk1Xf7Wfb0iNAee2oMYm06Sy1o5o7e2YmuXM+Ie+rr9BKSgAwd+pI6J13EXDpJWdUV0KIeuewQe7+42s+5ewD1VHzMUbfKuFTl/LaT10hMO6UwqcTKbHYWPbFbpK3ZAMQ0dafEeO7yTToQjQTmqbxd+rfvLnxTZLykgAINgdze8/buanrTZj1Zg+3sHY2m43k5GRUVa3zMc6CAtRi1yQN+tBQdOYz//lKi+w4rE4MJh3e/q17tvqaBAUFERUVVWMvOwmlJJQ6Jaqq8dXza8hLL2Hwv9oz4NIETzepUeV+8gkZ/50OmobvucOJfe01dL4nv+DSNI2lh5fy1qa32Je/D4BQr1Am9ZrE9Z2vx6SXX1xCNFXpBwr4Y85OCjJLAeh+TgxnXdtRZtZrYRx5eeR++il5n32OWlQEgKltW0LvuIPAK0ehGFv3kHXRyBw2V9B0bM2n3P21h08mv8pC4+7wqQsExNZb+HQimqaxZ20Gf321B1upA71Rx5B/taf3BXEouuY/1EeIlmpd+jre3Pgmm7M2A+Bn9GNs97GM7jYaX2PTDpY1TSMlJQW73U5MTAy6Ovyuc+Tl4cjKAsAQFYWhHrIAh93pvk4MCPeWHvRVaJpGSUkJmZmZBAUFER19/CyNEkpJKHXKktak88fHOzH7lveWagUfzDSnk4z/Tifvs88ACLrpRqKefBLFcGo/u1N1sujgImZumsmRIlePi2jfaO7ufTejOozCoGv5f5ZCNBdOu8ranw6w6fcUNA18g8xcMLor8d3PrN6AaNqcFgt5c+eSO+cTnPn5ABhjYgidNJHAa66pl29ThXBzWCvDp2o9n/aD5qz5GJN/eehUMeyuPHwKjIUmUOelKK+MpZ/tJmVnLgAxnYK4YEwigeGnXzxYCFH/dmTv4M1Nb7IybSUAZr2ZWxJvYUL3CQR5BXm2cXVkt9vZt28fMTExBAaevDyK02LBlpICgCEyEmN4eL20w5JdSlmxHZO3gaAIGQlTk5ycHDIzM+ncufNxQ/kklJJQ6pSpTpW5z62hILOUoVd3oN/Itp5uUoNSS0pIffgRipYsASDi4X8TMmHCGRX4s6t2vtv7He9teY/M0kwAEgISuLfvvVzU9iJ0itRhEMKTslIK+WPOTnLTXF27uwyJ4pwbOrX6CR5aE7W4mLyvvyHno49wZruGJBnCwwm5fQLBN9yAzkcuOsUpqAifqhYcz9ztKkJ+ovAp4ph6T+FdIaBNkwifTkTTNHauSOOf+fuwW50YzHqGXduR7ufEtIgCyUI0Z/vz9/P2prf5I+UPAAyKgWs7X8sdve4gwifCw607NWVlZSQnJ5OQkID3SWbNU0tKsCYfBE1FHxyMMaZ+fh857E739WJwlK/MwlyL0tJSDh48SLt27fDy8qq2TUIpCaVOy+7VR1kyZxdefkbGTD2rxZ58juxsDt99D2XbtqGYTMRM/y8Bl15ab89f5ijj66Sv+WDbB+Rb8wHoEtyFe/rcw/lx58uFmxCNTHWqbPw9hXU/JqOqGt7+Rs67tSvt+9TPN2mi+VHLysifv4CcDz7AkZ4OgD4khNAJ4wm++eY6DeEWrYi9DHL2Vik2Xt7zKTe59vDJHFA9dKq4BcQ0+fDpZCzZpSz5ZBdpe/MBiO8ewgVjEvENlB6HQjS2gwUHmbV1Fr8c+AUNDQWFUR1GcVfvu4jzr70+blNWEUrVFHRUpVqt2A4kozkd6Pz8MLVtW2+fs9y9pLwMBEXKF1a1OdHflYRSEkqdFtWp8sUzq7Fkl3HWNR3pe3G8p5tU76z793P4jjuxp6aiDwoi9p2Z+PTr1yCvVWQr4tOdn/Lpzk8ptruS9m6h3ZjcZzLntDlHwikhGkFBVgl/fLyL9AMFAHToG865t3SRYpUCAM1mI//778mZ/T72w4cB0AcFETJuLMG33ore39/DLRSNyl4G2Xsqez1VhFB5yaDVUmzXHFgePB1T98k/utmHTyeiqRpblx5h1cL9OO0qZl8D59/alQ79mlePDCGaq8OFh3lvy3v8eOBH1PLfTxfGX8i9fe6lY3BHD7fuzNQllFJtNmzJyWh2OzovL0zt2tXbJCZOu0pOmqsOZXCUD0azlGKpjYRSNZBQ6szt/CeNpZ/txtvfyOipZ7Wogm7Fa9Zy5L77UC0WjPHxxM9+D1NCQoO/boG1gDk75vDFri8odbiK5fUK78XkPpMZGj1UwikhGoCmaexaeZQV3+zFbnVi8tIz/KbOdB5c8wwhonXTHA4KfvqJnHdnYTt0CABdQAAho0cTMmY0+jrUtBDNiL20MnyqOvQu72Dt4ZNX4PHFxsMTwT+qRYdPJ5ObVszij3eQfdj1Aa7LkCjOubEz5lY4k7MQjSGtKI3ZW2fz/b7vcWiuCRLOjT2Xe/rcQ7fQbh5uXf04WSilORxYk5PRrFYUkxlz+3anXBP4RCw5pZQVSS+pupBQqgYSSp05p1Pli6dXU5hTxrDrOtJnRMvoLVXwww+k/edJsNvx7tOH2HdmYggJadQ25Jbl8vH2j/lq91eUOcsA6BfRj3v73svAqIGN2hYhWrJjpzGP6RTEheMSCQiVgrzixDSnE8svi8ieNQvb/v0A6Hx9CR59GyFjx2IIDvZwC8UpsZXU0vPpIFDLJbBXUPXQqSKE8ots1eHTiTgdKut+Smbjb4fQNPAP8WLE+ERiOsn5IkR9ySjO4P1t77Ng7wIc5bN1DosZxuQ+k+kZ3tPDratfJwo6NKcTW/JB1LJSFKMRU7t26Ez11/u9ai+poEifBpn8S1EUvvvuO6666qrTfo7zzjuPPn36MGPGjHpr1+mQUKoGEkrVj50r0lj6+W7MvgZGvzC0WRcB1jSNnNnvk/X66wD4X3IJMf+dhu4E45MbWnZpNh9u+5Bvkr7BptoAGBw1mMl9J9M3oq/H2iVES5C8NZuln+2itNCOTq8w+F/t6TMiHp1MXS5OgaaqFP7+O9nvvIt1zx4AFB8fQm65mZDx4zGEymyNTYo7fNpdZca7XZB3iFrDJ+9gV+h0bM0nvwgJn07T0X35/DFnJ5bsMlCg74h4Bl/ZHr1RJnoR4nRll2bzwbYPmJc0r/JzQ/RgJvdpuZ8bags6NFXFdvAQakkxil6PqX37ep89t6KWlNHLQPBp9JJKT09n6tSp/Pzzz6SmphIREUGfPn148MEHufDCC4GmHUqlpKRw9913s3TpUvz8/Bg7dizTpk3DUEtPtPoIpaRfrahR16FRbF5ymLyjxaxfdIhh1zbPccmappH5v/+R++FHAIRMmEDEv/8PRefZi6Mw7zAeHfQo47qPc3/jsSZ9DWsWrWFo9FDu7nN3i32TEaKh2Moc/DN/HztXpAEQEuPLRRO6ERYrNYHEqVN0OgIuuQT/iy+m6M8/yXrnHaw7d5HzwYfkfv4FwTfdROjtEzDU07TToo5sxa7wKXN3ZQCVtfsk4VNIec+nY2a78w2X8KmeRXcM4sYnB7Him73sWnmUTYtTSNmZy0UTuhHaxs/TzROiWckuzeaj7R8xL2mejLDAFUjZDx92BVI6HaaEhHoPpOxWJ2XFdgD8gk79uQ8ePMiwYcMICgrilVdeoWfPntjtdn777TcmT57M7t2767W99c3pdHL55ZcTFRXFypUrOXr0KGPGjMFoNPLSSy812OtKTylRq4Pbsvl55lZ0BoVbnx1CQFjzGvaiOZ2kP/sc+fPmARDx6KOEjh/n2UbV4mjRUWZvm83CvQvdY8MHRw/m7t530z+yv4dbJ0TTl36ggMUf78SS5arZ1ntEHEP+1R6DseXUxBOepWkaRcuXkz3zHcq2bQNAMZsJvulGQm6/HWOEFHeuV9aiGno+7Yb8FGoNn3xCqwRPVUIoPwkOPeHA5iyWfr6bsiI7OoPC0Ks60PuCOBTptSrECWWVZLnCqD3zsDqtgKsW7b197mVI9JBWURfz2N43qqpiOXQYZ0EBoGBq2xa9b/3WetI0jYLMUuxWJ2YfIwFhrl4/3kZ9nf/ML7vsMrZu3UpSUhK+x8zim5+fT1BQEODqKfX+++/z888/89tvv9GmTRteffVVrrzySvf+27dv5+GHH+bvv//G19eXiy++mNdff52wsDDA1VOqR48eAHz22WcYjUbuvvtunn/+eRRF4fnnn+ebb75h+/bt1drRp08fRo0axQsvvHBc+xctWsQVV1xBWloakZGRAMyaNYtHH32UrKwsTDUMk5ThezWQUKr+aJrGD29s5sjuPDoOiGDkxB6eblKdaTYbaY89huWXRaDTEf38cwRdd52nm3VSRwqP8MG2D6oVLhwUNYi7et/VKr8REeJkVKfK+l8Osv6Xg2ga+AWbuXBsIrFdG7denGg9NE2jeMUKst+eSemWLQAoJhNBN9xA6KSJGMsv4kQdWYvK6z3trqz55A6fauETVqXmU5UQyjes8dot6qS4wMrSz3dzaFsOAG26BDFiXDf8gj1XQkGIpiqjOIOPtn/E/D3z3cP0eof35u7ed3NWzFmtIoyqUDXoMJvNWA6n0vudLR5py87nR+JjOvkAs9zcXMLCwpg6dSqPP/74CfdVFIXY2FhefvllBg4cyFtvvcVHH33EoUOHCAkJIT8/n86dOzNx4kTGjBlDaWkpjz76KA6Hgz///BNwhVIbNmzg9ttv5+6772b9+vXccccdzJgxg0mTJnHkyBHatm3L6tWrGTjQ9Tly06ZN9O/fn3379tG+ffvj2vX000/zww8/sHnzZve65ORk2rdvz8aNG+nb9/iRPBJK1UBCqfqVfaSQr6euAw2ufaQ/Ue2b/uxDamkpRx54gOK//gajkTavvELAJSM93axTklqUygfbPmDhvoXuQoYDIgdwT597JJwSolxBVgmLP9pJRrIFgM6DIhl+U+dmXQNPNB+aplH8z0qyZ86kdNMmABSjkaDrr3eFU9HRHm5hE2MtrAycMquETwWHaz/GN7xKraculb2fJHxqVjRNY+eKNFbM24vDpmL2MXDerV3p2F96FwoBkF6czofbPuTbvd+6w6i+EX25q/ddrXaW7qpBh95iwZKWTv+vTvB+0YDqGkqtXbuWwYMH8+2333L11VefcF9FUXjyySfdvZWKi4vx8/Nj0aJFXHLJJbz44ov8/fff/Pbbb+5jjhw5QlxcHElJSXTu3JnzzjuPzMxMduzY4f438thjj/HDDz+wc+dOwNVzKyEhgXfeeQeA+++/n23btrF06dIa23XHHXdw6NChaq9bUlKCr68vv/zyC5deeulxx0hNKdHgwmL96To0mt0rj/LP/H1c83C/Jv2L0VlYyOG776Z0/QYULy9i33oLv3PO9nSzTlkbvzY8M/QZ7uh5Bx9s+4Bv933L+oz1TPhtAv0j+3N377sZFDWoSf9dCNFQNE0jaXU6f321B7vVicnbwLm3dKbzwChPN020Ioqi4Hf2MHyHnUXJ6tVkzZxJ6foN5M2dS/68eQReew1hkyZhbNPG001tXGWWKj2fqgy9sxyp/RjfiOOLjYd3BV8pJt8SKIpC93Pa0KZzML9/uIOslEJ+e387h3ZEc84NnRpkZishmoP04nTXdf7eb7GrrjpG/SL6cXefuxkcNViu8wFHXh5aTg7eeoWtDwzEENowPeFLLHaK88vQ6RSCY3yrTY7jXcdSEKfa16dXr17u+76+vgQEBJCZmQnAli1b3IXGj7V//346d+4MwJAh1YdzDh06lFdffRWn04ler2fSpElMmDCB1157DZ1Ox9y5c3m9fPKvpkTeBcRJDR7Vnn3rM0g/UMD+jVlN9pstR24uhydOomznTnT+/sTNehef/s27HlO0XzRPDX2KSb0mud+0NmRsYOLvE+kX0Y87et3R6rrzitatrNjO8rlJ7NvgetOO7hjIiPHdCAhtXjXvRMuhKAq+Q4fiM2QIJWvWkj1zJiXr1pH/1dfkL/iWoKuvJvSOOzDFtrBwqqwAsvZUDrnL3OUKoCyptR/jF1m951PFsDsfGW7bGgRF+nDtI/1Z+1MyG387xO6VR0nbm89FE7oR1a7p98QXor4cKTzCR9s/4rt931UbEXF377sZGDVQruvLqSUlOOx29DodxshIfBqodqPqVCkudeBt1OMf4oW31+n1uO/UqROKotS5mLnRWP11FEVBVVUAioqKGDVqFNOnTz/uuOhT6Ik9atQozGYz3333HSaTCbvdznUnKGkTFRXF2rVrq63LyMhwb2soEkqJk/ILNtPnonjW/3yQVd/to13vMPSGpjW1rz09nZQJt2M7cAB9SAjxH36AV2Kip5tVb6J8o3hyyJNM7DmRj7Z/xII9C9iYuZG7/riLbqHduKPXHZwfdz46pWn9vQhRn1KT8vhjzk6K8qzodAoDR7Wj38i21b7NEsJTFEXBd8hgfIcMpnjtWrLfeZeS1avJ/+Yb8r/9lqCrryL0zjsxxcZ6uqmnpqygSuiUVBlCnTB8iqqh51MXCZ8EeoOOoVd1IL5bCH+UT07x7SsbGXRFAv0uSZDf56JFO1BwgA+3fcjPB37GqTkBGBg10B1GiUpF//yDEyA8HENoaIPOdFtisaGpGnqjDi+/0y8BERISwsiRI5k5cyb333//CQudn0y/fv1YsGABCQkJGAy1RzZr1qyp9nj16tV06tQJvd7Vu8tgMDB27Fg+/vhjTCYTN910E97etX+RO3ToUKZOnUpmZiYR5SHg4sWLCQgIoFu3bnVq++mQmlKiTmxlDr54ejUlFhvDrutInxHxnm6Sm+3gQVIm3I49LQ1DdDTxH36IuX07TzerQWWWZDJnx5xqU8R2DOrIpJ6TGJkwEr1OZhwTLYfTobL2x2Q2/n4INAgM9+aiCd2JbCe/40XTVrJhA9kzZ1K8cpVrhcFA4FX/IuzOOzHFxXm2cccqza8eOlWEUIVptR/jH11lprsuEJ4I4Z3BO7jRmi2ar7JiO8u/TGLf+io9X8d1a3azPQtxMkm5SczeOpvFhxajlc8eOixmGJN6TZJZtmtgWbyYwy+/gvOxR0no0AH/tm0brPeY066Sc7TIfX15pnVJDxw4wLBhwwgJCeH555+nV69eOBwOFi9ezLvvvsuuXbsA1xdZ3333HVdddZX72KCgIGbMmMG4ceNIS0ujT58+nHvuuTzyyCOEhISwb98+vvrqKz744AP0er270PmkSZO488472bhxI5MmTeLVV1/lzjvvdD/v3r17SSzvrPHPP/8wePDg2v88nE769OlDTEwML7/8Munp6YwePZqJEyfy0ksv1XiMFDqvgYRSDWfnijSWfr4bs4+B214Yipev54sJlyUlkXL7RJzZ2ZgSEoj/6EOMMTGeblajyS3L5fOdnzN391yK7cUAtA1oy+09bueKDldg1Hn+70iIM5GXXszij3aSlVIIQOKwaM6+XmqQiOalZONGst+eSfHKla4Ver0rnLrrrsYPp0rzqhQcr1L3qfBo7cf4x9Tc88k7qNGaLVomTdPYsyad5V/twV7mxOSl59xbutB5kNQIFM3f1qytvL/1fZYdWeZed0HcBUzqNYkeYc1nVvPGVPjHHxx58CHU8HDUqS/SsW/fE/bsOVMFWaVYS+yYvAwERnjXS/h19OhRpk6dyk8//cTRo0cJDw+nf//+PPTQQ5x33nnAyUMpcIVJjz76KEuXLsVqtdK2bVsuueQSXnvtNRRF4bzzzqN79+6oqsrcuXPR6/XcfffdvPjii8f9HMOHDyc3N5ft27eftP2HDh3i7rvvZtmyZfj6+jJ27Fj++9//1tpjS0KpGkgo1XBUVePrF9eSm1ZM7wvjOPv6Th5tT+mOHaRMuB21oABzYiLxH7yPIbR1FkUtsBbw5e4v+XzX5xRYCwCI9o1mQo8JXN3pasx6s4dbKMSpOW62Jl8D59/WlQ59m2ZNOyHqomTTJrJnvkPxihWuFXo9gVdeSdhdd2Jq27Z+X6w0r3roVBFCFaXXfkxAm8rQKaJK+OQl9X5EwyrIKuWPj3eQfqDKbKo3d8HsLV9AiOZF0zTWZ6xn9tbZrD66GgCdomNk25FM7DWRzsGdPdzCpqtwyRKOPPAgOBz43HwzJddfR7v27Y8LOuqL3eogL70EgOBoX4ymljnSRNM0OnXqxD333MOUKVPq/fmbTSg1c+ZMXnnlFdLT0+nduzdvvfUWgwYNqnX/efPm8dRTT3Hw4EE6derE9OnTueyyy+r0WhJKNayUHTn8+NYWdHqFW54dTGC4j0faUbbz/9m77/CoyrSP49+p6b33EEijht4EQi8rCFZERSyoqOu67lrYdYusrKu+KK5rWxULygIqSAcRIiC9txQSQnrvySQzmXLePyaZEEggQJJJeT7XlSvhzDkzT4CZOfM793M/8aQ/8iim8nLsYmII+u8nKMS/N9X6atYmreXL819SrC0GwNPOk/m953NPxD04qq9ewUEQOhqtRk/cN4mkniwEIDDKjYkP98bRTYSrQtdQc+oUhR98iGbfPvMGhQKXmTPxXPTUjYdT1SWNQ6f6n6vymz/GOdAcNjWadhcJtuJ9VLAek9HEsW3pHNuahmSScPa0ZfKjffANE6Go0PFJksS+7H18dvYzThacBEApU3J7z9t5rO9jhLqEWneAHVzl7jiyfvc70OtxnjED9yWvkZaZ2WTQ0RokSaIsvxq9zoitg6rLThsuLCxk9erVLF68mMzMTNzcWn96facIpdasWcP8+fP5+OOPGT58OMuXL+e7774jKSnJ0jzrcgcOHGDs2LG88cYb3H777axatYo333yTEydO0Lfv9cscRSjV9jb9+xQZ8SX0HOTFtCf6tfvjaxMSyFjwCMb6QOqzT1E0sVxmd6Y1aFmfsp4V51aQpzFfFXdSOTE3ai4PRD+Ah133rCgTOr7spFJ2fhGPpkyHXCFjxB09iZkUhEw0vxW6oJrTpyn88EM0e/aaN8jlDeFUaGjjnTXFdYHTFT2fNAXNP4BLUMMqd/W9nzwjRPgkdGh5qeX89Pl5Kou1yOQy0QRd6NAMJgPb07bz+dnPSSlLAUAlV3Fn+J080vcRAhy72MqrbaAyLo6s5+oDqen4v/UWOoOh2aCjNWg1eiqKapDJZLj7O3S4Rbxai0wmw9PTk/fee4958+a1yWN0ilBq+PDhDB06lP/85z8AmEwmgoKC+O1vf8srr7xy1f733XcfGo2GzZs3W7aNGDGCmJgYPv744+s+ngil2l5xdhVrXj+CJMGdLw7Gr2f7XcHSJiaS8fACcyA1YABBn38mAqlr0Bv1bLm0hRXnVnCp/BIANgob5vSaw4K+C8QbpdBhGI0mjm66xPEd5mbmrj72THmsD17BTtYemiC0uZqzZyn6zwdU7dlj3iCX4TwiCs8x3tjIssxhlKaw+TtwCa6rfKqfchcNnuEifBI6LV2NgT2rkkg+aq748+vlwuRH++Dk3jbTeAThRtVfAP7q/FdkV5lXI7VX2nNf5H082PtBvO1Fu4GWqPzlF7J/+xySXo/T9GkEvP02MqXymkHHrZIkiZIcDUaDCXsXGxxdRSX+rWiNUKpNJ2rX1tZy/PhxFi9ebNkml8uZNGkSBw8ebPKYgwcPXjXXcerUqfz4449N7q/T6dDpdJY/V1RU3PrAhWvyCHAkepQf8ftz2f99Mne9NLjNVkS4nDYx0VIhZTugv6iQagGVQsXsXrOZ1XMWcRlxfHb2M84Vn2N10mq+u/Ad03pM47G+jxHuZt3+YEL3Vl5YzU+fx1OQZn79Fs3MhW5BU1RX7ZSIXWEiQSOzqHHWU3TcSFWOLRUHEqg4GI9zcA2efSqxcQZcgxtXPXlFgmck2Ij3QqFrsbFTMuWxPoT09WDPqiRyU8pZ8/oRYh+Iotdg8WFfsJ6K2grWJK7hm4RvKNGWAOBu686D0Q9yb+S9uNiI6aYtVbVnT0MgNa0hkGprNZV6jAYTcoUMe2d1mz+ecH1t+q9eVFSE0WjEx8en0XYfHx8SExObPCYvL6/J/fPymm7M+cYbb/Daa6+1zoCFFhs2K4wLxwrIv1RByvECwof4XP+gW6BNSjIHUmVl2PbvT/Bnn6FwEhUULSWXyZkYMpEJwRM4mneUz85+xsHcg2xJ3cKW1C2MCxzH4/0eJ8Y7xtpDFboRy6pL/7uAXmfExl4pPnAIXYskmcOnK6fcFSZAdfFVu9s5QNBYqKkNouicPVUXKqlIt6ci0wHnaVPxnP9bbMLCrPCLCIJ1RA73xTfM2XLhYsen58iI92PMvRGobLpmU2KhYyqsLmRlwkrWJq21rHjt7+DPgr4LmNNrDrZKUcV3I6r27iXr2d+aA6kpUwh4+612CaRMRhOacnNBi4OLjZgW3EF0+svQixcvblRZVVFRQVB7L6/cDTm42DBoSjBHNl3i0I8XCRvghULVNnNxtUkXGgKpfv0I/uxTEUjdJJlMxjC/YQzzG8b54vOsOLuCnek72ZO1hz1ZexjoPZAFfRYQGxSLXNY151YLHYOYmiF0KZJknl53eehUH0LVlDRzkAzcQhpWuPOKNk+/84zATu1AEFBz7jxFH35I1e7dVGzdTsW2HTjPmIHn04uw6dmzPX9DQbAaFy977nxxkGWKd8L+XHJTysUUb6FdpJan8vX5r9l4cSN6kx6AXq69eKzfY0wNnYpKrrLyCDufqn37GgdSy/4Pmap9/h415bVIJgmFSo6to/i36yjaNJTy9PREoVCQn994BZj8/Hx8fX2bPMbX1/eG9rexscHGRswDtYaYScGc35tNRZGWM79kMXBycKs/hvbCBTIWLMBYWopt374Ef/6ZWGWvlfTx6MOy2GWklafx5fkv2XhxIycLTnKy4CShzqE83OdhZvaciY1CPL+E1iWa2AqdliRBVcFlq91dFkLVlDZzkAzcQuum3EU1TL/zjAD1tVewtevbh6APP6Dm/HmKPvyIql27qNiyhYqtW3GePt0cTvXq1eq/piB0NAqFnBGzexIU7c7OL+Ipy6/m+zePicUwhDYhSRInCk7w5bkv+SXrF8v2GK8YHu/3OGMDx7ZL65KuqGrfPrKeeRapthanyZPaNZAy6E3UVNYC4OhmK/4NO5B2aXQ+bNgw3n//fcDc6Dw4OJhnn3222Ubn1dXVbNq0ybJt1KhR9O/fXzQ674ASDuSy++sE1HZK5v19OA4urRdgmAOpRzCWlGDbpw/BKz5H4SLmabeVguoCViWsYm3SWir1lYB5jvy8qHncF3kfrrau1h2g0OmZTBLHt6VxdIt5uW8nD1umPCaW+xY6IEmCqvyrK58KE68dPrn3aAid6iugWhA+tZQ2Pp7CDz+k6udddQ8pw3n6NDwXLcImXPQGFLoHrUZP3DeJpJ40N/8PinZj4oLerXoOKnRPRpORXRm7+Or8V5wpOgOADBnjg8azoO8CBnoPtPIIO7eK7TvIfvFF0OtxnDSRwHfeQaZuuqdTazc6lySJisIadDUG1LZKXH1a531Z6CSr761Zs4aHH36YTz75hGHDhrF8+XLWrl1LYmIiPj4+zJ8/n4CAAN544w0ADhw4wLhx4/jXv/7Fb37zG1avXs0///lPTpw4Qd++fa/7eCKUal8mk8QPbx6jIL2SnoO8mfbE9f+NWkKXnEz6wwvMgVTv3gR/sUIEUu1Eo9fww4UfWJmwkjyNuZebndKOOb3m8FDvhwh0CrTyCIXOqLJEy89fxJOTXAZA+FAfxs2LxMau088iFzozSYLK3Lqqp8SGCqjCRNCWN3NQffhU12jcO7qu8ikcVHbtMmxtQgJFH35I5c6f64Ykw2nqVDyfXoRtRES7jEEQrEmSJOJ/zeHXtckY9CbsnFRMmB9NaD9Paw9N6IRqDDVsSNnA1/Ffk1mZCYBarmZWr1nM7z2fHi49rDzCzq/shx/I/ctfwWQyr7L35pvNBlLQ+qGUtlpPRWENAO5+DijVoidda+kUoRTAf/7zH95++23y8vKIiYnh3//+N8OHDwcgNjaW0NBQvvzyS8v+3333Ha+++ippaWmEh4fz1ltvMWPGjBY9lgil2l9RViVr/3kMySQx4+n+9Oh/aycEutRU0h+aj7G4GJve0YSsWIHC1bV1Biu0mN6k56e0n/jy/JcklpgXJpDL5EwOmcwjfR6hj2cfK49Q6CxSTxaye2UCumoDKhsFY++PIHK4ryibFtqPJEFFTuPQqSDRXP2kayZ8ksnBPaxx5ZN3FHj0arfw6Xq0iYkUffgRlT/9ZNlmDqeexjZShFNC11eSq+Gnz89TnFUFQP8JgYyc0xOlSnzgFK6vRFvC/xL/x+rE1ZTpygBwsXFhbuRc5kbNxdNOhJytofiLLyl4800AXO+5B9+//w2Z4trP0dYMpUwmiZKcKkxGCXsXGxxdrV9VKZPJWL9+PbNnz77p+4iNjSUmJobly5e32rhuRqcJpdqTCKWs4+D6FE7syMDRzYb7/zb8ppdy1+fkkDbvAQx5edhERxPyhQikrE2SJA7lHuKr81+xP2e/Zfsg70HM7z2f2KBYFHJx8idcTV9rZP93yZzflwOAd4gTkx/rg6u3KJkW2oglfLpytbtrhU+KuvDpsqonr/rwqXM03tcmJZnDqR07LNucJk/G85mnsY2KsuLIBKHtGfRGDq67yJm4LAA8Ah2Z8lgf3P0crDwyoaNKKU3hm4Rv2HRxE7Umc4+hAMcA5veez+xes7FXifOU1iBJEkXvv0/Rhx8B4P7Yo3j/8Y8tuijZmqFUZbGWmqpaFEo57n4Obd6DLi8vj6VLl7Jlyxays7Px9vYmJiaG559/nokTJwIdO5R67rnn2L9/P+fOnSM6OppTp05dc//WCKXEvAmhVQz5TQ9SjhdQUaTl8IZUxtx341doDcXFZDz6GIa8PNRhYeYeUiKQsjqZTMZI/5GM9B9JUkkSX53/im2XtnGi4AQnCk4Q6BjIA9EPMCd8Dg4qcQIomBVlVfHT5+cpzTUvmzxwSjDDZ4WhUIpVHYVWIElQkX3ZlLvLw6eKpo+RKcCjZ+OV7urDJ6X1r5reCtvISALfW472wgWKPvqIyu07qNy5k8qdO3GcNBGvp5/Gtndvaw9TENqEUqVgzH0RBPV2Z/fXCRRnVfHdP49y273h9L7NX1TlCoA5INmfs5+V8Ss5kHPAsr2vR18W9F3ApOBJ4iJrK5JMJvL/+Qal33wDgNfvf4/HEwvb/flYqzVQU2UOHp08bNs8kEpLS2P06NG4urry9ttv069fP/R6PTt27OCZZ54hMTGxTR+/tTz66KMcPnyYM2fOtMvjiUopodVkxpew8d+nQAZ3vzQEnx4t//s3VlaS/vDD6OITUPr7EbpqFapmVlwUrK+guoDViatZe2Et5XXVB44qR+4Kv4t50fPwd/S38ggFa5EkibO/ZHHgh4sYDSbsndVMeqQ3QdHu1h6a0BlJEpRnXdZs/LJpd7WVTR8jV4J7z8sqn+pCKI+enT58aildcjJFH31MxbZt5r9DwHH8eDyffhq7fq3T+1EQOiJNuY5dX8aTmWBekKDnQC9iH4zC1kEs/d5daQ1aNqdu5pv4b7hYfhEwt6OYGDyRh3o/RIxXjAguW5lkMJD75z9TvmEjAD5//Qvu8+bd0H1cVX0jSaCvvrFxmCRK8qsx6k3YOipxdr/Jqfcqe2jh/5EZM2Zw5swZkpKScHBofLG+rKwM17qCC5lMxqeffsqWLVvYsWMHAQEBLFu2jFmzZln2P3fuHC+++CL79u3DwcGBKVOm8O677+LpaZ5WGhsba+m5vXLlSlQqFYsWLWLJkiXIZDKWLFnC2rVrOXfuXKNxxMTEMHPmTP7xj39c83f5+9//zo8//tgulVIilBJa1c9fxpN0KA+PAAfu+dNQFIrrV0WYtFoyHn+cmmPHUXh4EPLNSmx6iIaCnUGNoYZNFzexMn4laRVpAChkCiaFTOKh3g8xwGuAdQcotKuaylp2f51A2tliAEL6eTBxfjR2Ts03shQEoC58yrxiyl3d99qqpo+RK81VTvWhU30I5d4TlOL/HIDu4kVzOLV1K5hMADiMG4vXM89g17+/lUcnCG1DMkmc+jmTQxsuYjJKOLrZMPnR3viHu1l7aEI7KqopMl9ATVpLqc4cUjqoHJjTaw4PRD8gFu5pIyadjuw//MG8SqxCgf+/3sBl5swbvp+rgo5aDfzTShe9/5QD6uvPBikpKcHT05OlS5eyePHia+4rk8kIDAzkrbfeYujQobz//vusWLGC9PR03N3dKSsrIyIigscff5z58+dTU1PDyy+/jMFgYPfu3YA5lDp+/DiPPfYYixYt4tixYzzxxBMsX76chQsXkpWVRUhICIcOHWLo0KEAnDx5ksGDB5OSkkJYWNg1xyhCqVsgQinrqqmqZdXfDqPV6BkxO4zB00Kvub+k15P17G+p2rMHuaMjISu/xjY6un0GK7Qak2Ti1+xf+Tr+aw7nHrZs7+/Vn4eiH2JiyERUcnGVsivLTCjh5y/jqS43z9kfdVdP+sUGiquPQmMmU134VD/tri6EKrrQgvDpsmbjXlEifLoButRLFH/yMeWbNjeEU2PG4Pn0IuwHiiXOha6pIL2Cnz47T3lhDTIZDJ4eytDfhCJvwQVTofOKL47n24Rv2XZpG3qTHgB/B3/mRc/jzvA7cVI7WXmEXZdJoyHzmWepPnQImVpNwPLlOE0Yf1P31RlDqSNHjjB8+HDWrVvHnDlzrrmvTCbj1VdftVQraTQaHB0d2bZtG9OmTeP1119n37597LisV2RWVhZBQUEkJSURERFBbGwsBQUFnD9/3nK+/corr7Bx40bi4+MBc+VWaGgoH374IWDuF3X27Fni4uKu+/u0ZyglekoJrcrOUc1t9/Ti5y8TOLoljZ6DvJttaiyZTOQs/hNVe/Ygs7Ul6JOPRSDVScllcsYGjmVs4FiSSpJYGb+SrZe2cqbwDC8Wvoi3nTf3Rd3H3RF3424rpnF1JUaDicMbUjm5MwMAN197pjzeF89ARyuPTLAqkwnKMy7r+VT/dQH0mqaPkavM4VN96GRpON4TFCLUvhU2YT3wf/NNPJ9+mqKPP6F840Y0+/ah2bcPh1Gj8HzmaewHD7b2MAWhVXmHOHPvn4eyb/UFEg/lcWxrGlmJJUx+tA/Onh1jBU2hdehNenZl7GJVwipOFpy0bB/gNYD5veczIXgCSrn42NuWjGVlZDz5JNrTZ5Db2xP44Yc4jBjeeg+gsjeHQy0gSRJlBTXodUbUdkpcPG1v7SJpCxvf32itT//LKpYdHBxwdnamoKAAgNOnTxMXF4ej49Xn0xcvXiQiwty/ecSIEY1+t5EjR7Js2TKMRiMKhYKFCxfy6KOP8s477yCXy1m1ahXvvvvuDY2zPYhnp9DqIob7knQ4j8yEUn75Nok7nr96rrYkSeS/vpSKzZtBqSTwveXihLiLiHSP5PXbXuf5wc+zNmkta5PWUlBTwPsn3+eT058wvcd05kXPo7eHaLrb2ZXlV7NzxXkK0s29ffqM8Wf0PeGo1KJRaLdhMkFZekPoVB9CFV1ovveDQg0e4Vf0fIoyr4Anwqc2pQ4Jwf+Nf+K56CmK/vtfyn/cgObAATQHDmA/fDieTz+N/bChosJR6DLUtkomLuhNUB939nybRF5qBWteP0LsA1GED/Wx9vCEW1SiLeGHCz+wOmk1BdXmD/NKmZLJoZN5IPoB0Uainehzc8l84kl0yckoXFwI+uxT7Pr1a90HkclaVK0EoK2sRW8yIVPLcPJxQNZOi+yEh4cjk8la3MxcpWp8ziOTyTDVVTNXVVUxc+ZM3nzzzauO8/Pza/GYZs6ciY2NDevXr0etVqPX67n77rtbfHx7EaGU0OpkMhnj5kWxeslhspNKSTqUR9TIxk+eovffp3TVKpDJ8P/Xv3AcN85KoxXaiqedJ0/HPM3j/R7np/Sf+Db+W84Vn2PDxQ1suLiBgd4DmRc9j4nBYmpfZyNJEkmH8tiz+gIGnREbeyXjH4qi50Bvaw9NaCsmE5SlNV35ZKhp+hiFGjwjGkInryhzCOXWAxTi9MOa1MHB+L/+Op5PPUXxJ/+l7McfqT58mIzDh7EbPBjPpxfhMGqUCKeELiNiqC++PVzYueI8eakV/PT5eTLiixlzXwRqW/F61NkkliTybcK3bE3dSq3JvLKau60790beyz0R9+BtL85H2os2Pp7MJ5/CUFiI0suL4BWfYxMebrXxGA0mqsp0ADi42rTrqs/u7u5MnTqVDz74gOeee+6ajc6vZ9CgQfzwww+EhoaiVDb/GnX48OFGfz506BDh4eEoFOYLxEqlkocffpgvvvgCtVrN3LlzsbPreJWi4lVYaBMuXnYMvb0HB9df5Nfvkwnu44G9s7n3R8lXX1H04UcA+P71L7jc/htrDlVoY2qFmtvDbuf2sNs5XXiabxO+ZWfaTk4WnORkwUm87b2ZGzmXuyLuElP7OgFdjYE93yaSfMx8RdI/3JXJj/bG0c32OkcKnYLJCKVpjRuNFyRAUfI1wiebhvDJMvUuGtxCRfjUwakDA/H7xxI8Fz1F8WefU/bdd9QcP07mY49jN2CAOZwaO1aEU0KX4Oxpx5w/DOLoljSOb0sj8WAeuRfLmfJYH7xDRB/ajk5v0hOXEce3Cd9youCEZXtvj948GP0gU0OnolaIPoPtqWrPHrJ+/wJSdTU24eEEffIxKn/rrsBdVapDMkko1QrsnNr/ovcHH3zA6NGjGTZsGEuWLKF///4YDAZ27tzJRx99REJCQovu55lnnuHTTz/l/vvv56WXXsLd3Z2UlBRWr17NZ599ZgmdMjIyeOGFF3jyySc5ceIE77//PsuWLWt0X48//jjRdS1y9u/ff93HTklJoaqqiry8PGpqaiw9pXr37o1a3TbPMdHoXGgzRqOJ7944RnFWFRHDfJj8aB/K1v9Ibt1qBF7P/w7Pp56y8igFayioLmBt0lq+u/AdJdoSAFRyFVNDpzI3ai79PfuLD0EdUF5qOT99fp7KYi0yuYxhM3swaGoIcrn4t+p0LOFTYuPV7oqSwaBt+pj68Mk76rLqJxE+dSX6/HyKP/+csjVrkXTmK822ffrg+fQiHCdMEK/LQpeRk1zKzhXxVJXqkCtkDL8jjIGTgpGJ97MOp7C6kO+Tv+f7pO8pqLlsil7IZOZFz2OA1wDx2mQFpatXk7fkH2Ay4TBqJAHvvYfCqfWayF+reXZzdNV6ygvNF9DcfB1Q2VinnURubi5Lly5l8+bN5Obm4uXlxeDBg/n9739PbGwsYJ5ZtH79embPnm05ztXVleXLl7NgwQIAkpOTefnll4mLi0On0xESEsK0adN45513kMlkxMbG0qdPH0wmE6tWrUKhULBo0SJef/31q54TY8eOpaSkhHPnzl13/LGxsezZs+eq7ZcuXSI0NPSq7WL1vSaIUKpjyU+r4Ic3jyFJMHGMhPTP34HRiPuCBXi//JJ4E+nmao21bE/bzrcJ3xJfHG/ZHu0ezdyouUzvMR07ZccrMe1uTCaJ49vSOLolDckk4expy+RH++Ab5mLtoQnXUx8+FSQ07vtUdAGMuqaPUdqCZ7g5cLL0fYoyh09y0S+sOzAUFlL8xZeU/u9/SDXmE3ybqCg8n3oKpymTkcnF6mVC56fV6In7JpHUk4UABEa5MemR3ji42Fh5ZIIkSRzLP8aapDXsSt+FQTIA5il6d0fczb0R9+LjIHqCWYNkMlH4zjsUf/Y5AC5z5uD32t+RtXIFzY2GUiaTREmOBpPRhL2zWlTwX0aSJMLDw3n66ad54YUXWv3+RSjVBBFKdTy/rk3m9O5MbLXFDD/yOu53/Aa/fy4VgZTQyNnCs6xOWs32S9st/QGc1E7M7jWb+yLvI8Q5xMoj7J4qS7T8/EU8OcllAEQM82Hc/ZGo7URlTIdiNEDppcbNxgsTzZVP1wyfIi5rNl73XYRPQh1DSQklX3xJ6bffYqo2N65X9+yJ51NP4jx9OrJr9LkQhM5AkiQS9ueyb+0FDLUmbB1VTJwfTWh/T2sPrVvS6DVsuriJNUlrSClLsWwf6D2Q+yLvY3LIZDFFz4pMOh05r7xC5bbtAHg+91s8Fy1qk890NxpKVZZoqamsRaGU4+bnIKr46xQWFrJ69WoWL15MZmYmbm5urf4YIpRqggilOh5NShqr/3kCrdqVnlIiUz94QpzICs0q1ZbyY8qPrElaQ3ZVtmX7KP9R3Bd5H+MCx6EQH5jbRcrxAn75NhFdtQGVjYJx8yKJHO5r7WF1b0YDlKQ2bjZekAjFyWCsbfoYpR14RTQ0G/eKMk/Bcw0R4ZPQIobSUkpXrqRk5TeYKs2rbaqCg/F8YiEus2a1+hVyQWhvpXkafvr8PEWZVQD0GxfAqLt6oRSrybaLlNIUVietZtPFTVQbzAG4ndKO34T9hvsi7yPKPcrKIxQMpaVkPfMsNSdOgEqF/9LXcZk1q80e70ZCKb3OSGmeBgAXb3tsxIVTC5lMhqenJ++99x7z5s1rk8cQoVQTRCjVsRhKS0m/fx45FQ6c6f80Mhnc9dIQfHqIfxvh2kySif3Z+1mdtJp9WfuQML9U+Tr4clf4XdwZfqdYXaWN1GoN7FubTOKBXAC8Q52Z8lhvXLzsrTyybsSobwifrqx8MumbPkZlX9dwPOqyhuNR4BoswiehVRgrKyn9dhUlX36JsawMAKW/Hx6PP47rXXchtxHTnoTOy6g3cfDHi5zelQmAm58DUx7rg2ego5VH1jXVGmvZmb6T7y58x/H845btoc6hzI2ay6yes3BSt16PIuHm1aank/nEk9SmpyN3ciLw/fdxGDG8TR+zpaGUZJIozdNg0JuwdVDh7CnafrQ3EUo1QYRSHYdJpyPj0ceoOX4cpb8fF+96m4tny3H2suO+Pw0V03+EFsuqzOK7C9+xLnkdZboyABQyBeMCx3FP5D2M8h+FXCZ6nLSG/EsV/LTiPBWFNSCDwdNCGHp7DxQK8ffbJox6KL7YROVTyrXDJ0uj8csqn1yCQfT6EdqBSaOhdO13FK/4HGNhEQAKL088Hn0Mt/vuRW4vAmyh88o4X8yurxKorqhFrpQxak4v+o8PFE3QW0laeRrfX/ieDRc3NDqnGx80nvui7mO473DR4qMDqT5xkqynn8ZYVobK35+g/36CTa9ebf64LQ2l6qftyeQyPPwdkIvz1XYnQqkmiFCqY5BMJnL++Ecqtm5D7uhI6P9WIfmHsmbpEapKdEQM82HSI73Fm45wQ3RGnfmqWtJ3jZYDDnAM4K7wu5gTPgdPO9EH4maYTBIndqRzdNMlTCYJRzcbJj/aG//w1p973i0ZausqnxIaVz4Vp4DJ0PQxKofLGo1f1vPJJUiET0KHYNJqKfvhB4o/+xxDrrmyUuHmhvvDD+P2wLxWXYlJENpTTWUtu79OIO1sMQDBvd2Z8HC0aIJ+k/RGPbsydvHdhe84knfEst3H3sdy/ubrINoDdDTlmzaR++pfkHQ6bPv2JeijD1F6ebXLY7cklLp8tT0XLzts7FXtMjahMRFKNUGEUh1DwbJlFH/6GSiVBH/6XxxGjgQg92I565edQDJJTHw4mqiRflYeqdBZXSy7aLnSVllr7nGilCkZHzyeuyPuZoTfCFE91UJXNjPvNdibcfMisXUQb+43zFBrDpqurHwqudh8+KR2bBw61YdQzoEifBI6Bam2lvKNGyn676foMzIAkDs64vbAA7g/PB+lu7uVRygIN06SJM7vzebX71Mw6k3YOamY8JBogn4jMisy+S75OzakbKBEWwKADBljAsdwT8Q93BZwG0q5mDnR0UgGAwX/t4ySL78EwHHCBAL+7+12rYK9XihlNJgoydUgmSTsnNQ4uYvV9qxFhFJNEKGU9ZWuXkPe3/8OgN8bb+A6Z3aj249tvcThjZdQ2ii4709DcfURZf7CzdMatOxI28F3F77jdOFpy/YgpyDuDL+TO3regZd9+1zV6YySj+WzZ1WSpZn52LkRRI7wFVWM12PQNYRPjSqfLoJkbPoYtVNd6FQ/7a6+8ikQxN+30AVIBgMVW7dS9N//UptyEQCZrS2u996Dx6OPovIVlRBC51OSo+GnFecpzhJN0Fui1ljL7szdrLuwjoO5By3bvey8uDP8Tu4Kvws/R3FRuqMylJaS/cILVB88BIDHU0/i9dxzyNr5Itm1gg5JkijLr0avM6JUK3DzsRfTa61IhFJNEKGUdVXt2UPmoqfBZMLz2WfxevaZq/YxmSQ2Lj9J9oUyPIMcufulIShUohpAuHUXSi/wXdJ3bE7dTJXefPKokCkYEziGO3vdyZjAMeKKXJ1arYF9ay6QeDAPMDczn/xob1y9RUjcSH34VJBwReVTavPhk41z455P9SGUc4AIn4RuQTKZqNy1i+KPP0F7/rx5o0qF6+w78Hj8cdQhIdYdoCDcINEE/fqSS5NZl7yOzambLb2iZMgY5T+KeyLuYWzQWFRyUYHdkWkTE8l65ln02dnI7O3xf+MNnKdOsc5YrhF0aMp1aMp0yGQy3PzsUapEQGxNIpRqggilrEcbH0/agw8hVVfjMmcOfv9c2my1RVWpjjWvH0Gr0TNgQhC33RvezqMVurJqfTU70nawPmU9JwtOWrZ72Xkxq+cs7gy/k2DnYCuO0LryUsvZ+UU8FYU1yGQweHooQ34T2r2bmeu1jafdFSRAYdJ1wieXKyqf6sMnfxE+CQLmq9maAwco/vgTqo8eNW+Uy3GeNg2PJ5/ENjLCugMUhBuUEV/Mri8bmqCPnN2TAROCum2VhkavYdulbaxPXs+ZojOW7d723szuNZs5veYQ6BRoxREKLVWxdSs5f/ozklaLKiiIwA/+g22E9V6jmws6arUGyvKrAXDysMXOUW2tIQp1RCjVBBFKWYc+J4e0++ZiKCzEfuQIgj/5BJn62i8SaWeK2PKh+Q3sN8/0J7SfmKMvtL7UslTWp6xn48WNln4GAEN8hnBn+J1MDpmMrbJ7zEM3Gk0c35rGsW3pSCYJR3cbJj/SB/9wV2sPrf3otVB0wRw4FdYFTwUJUHoJJFPTx9i4NA6e6n928hPhkyC0UPWJExR/8l+q9uyxbHMcPx6PJxZiP3CgFUcmCDemprKW3SsTSTtjXnkyINKNSQuicXTrHucSkiRxuvA065LXsT1tOzUGc6NppUzJuKBx3Bl+J6P9R6OQi+qVzkAyGil8912KP/scAIfRowlY9n8oXF2tOq6mgg6T0URJbjUmowlbBxXOnnZWHeOtkMlkrF+/ntmzZ9/0fcTGxhITE8Py5ctbbVw3Q4RSTRChVPszVlaSPu8BdMnJ2ISHE7Lq2xavuLNv7QXO7M7C1lHF3FeH4eAqVjUR2obeqOeXrF9Yl7yOAzkHMNUFEE4qJ2aEzeCOnnfQ17Nvl+2lVJZfzc4v4ilIqwAgYpgPY+dGdN2VSvQ1UJTcuOqpMAFK05oPn2xdzH2eLAFUXfNxJ18RPglCK9EmJFD03/9SuX0H1J2C2g8ZgscTC3EYM6bLvgYLXYskSZzfl8P+75Mx1JqwsVcybl4k4UN8rD20NlNYXciW1C2sT1lPanmqZXuocyh3ht/JzJ4zxQrInYyxrIzsP/wRzf79AHgsfByv559HprB+oHhl0CFJEhVFNeiqDSiUctz8HJB30ArFvLw8li5dypYtW8jOzsbb25uYmBief/55Jk6cCHTcUOr06dP861//4tdff6WoqIjQ0FCeeuopfve73zV7TGuEUqK5inBLJL2e7N/9Dl1yMkovL4I++fiGloAeNacXOcllFGVWsfOL88z63cAO+wIjdG4qhYrJIZOZHDKZPE0eP6b8yPrk9eRocliTtIY1SWvo6dKTO3rdwe1ht3eZ5uiSJBH/aw6/fnfZifP9kYQP7SInzrXVUJzcuNl4YeJ1wifXuhXurqh8cvQR4ZMgtDHb6GgC330X3XOXKP7sM8o3bqL62DGqjx3DJioKj8cfx3naVGRKcYoqdFwymYy+YwMIjHSzXPD56bPzpJ0tYuzcSGzsusb/31pjLb9k/sKGixvYn70fY910djulHVNCpnBn+J0M9B4owuROSJt0gaxnn0WfmYnM1hb/fy7FecYMaw+rWdoqPbpq8yrGzp52HfbzYlpaGqNHj8bV1ZW3336bfv36odfr2bFjB8888wyJiYnWHuI1HT9+HG9vb7755huCgoI4cOAATzzxBAqFgmeffbbNHldUSgm3JG/JPyhdtQqZvT0hK7/Grk+fG76P0jwNa984hkFnZPgdYQyZHtr6AxWEJpgkE4dzD7Ph4gZ+Tv8ZnVEHgFwmZ7T/aO7odQfjg8ajVnTO+erVFbXEfdN4isHEh6M757K5tdVQlFRX8XTZinelaUAzb2N2bldUPtWHT94ifBKEDkKfn0/Jl19RumYNUrW5T4gqMBCPxx7FZc4c5E0sBS4IHYnRaOLY1jSOb01DksDR3YZJC3oTEOFm7aHdFEmSiC+O58eUH9l6aSsVtRWW22K8YpjVaxbTQ6fjqBZN3juriq1byXn1L0jV1agCAsz9o6KirD2sRi6vvlHKVRTnatAaa3B0tcHOqX3Py+2Udi0OXmfMmMGZM2dISkrCwcGh0W1lZWW41k2LlMlkfPrpp2zZsoUdO3YQEBDAsmXLmDVrlmX/c+fO8eKLL7Jv3z4cHByYMmUK7777Lp6e5orE2NhY+vbtC8DKlStRqVQsWrSIJUuWIJPJWLJkCWvXruXcuXONxhETE8PMmTP5xz/+0aLf6ZlnniEhIYHdu3c3ebuYvtcEEUq1n9I1a8n7298ACPzgPzjVlSPejIQDuez+OgGZXMacPwzCr6dLaw1TEFqksraSn9J+YsPFDY2aozurnZnRYwaze82mt0fvTnM1MO1MEbtXJlBTqe9czVhrNXXB0xU9n8oyaD58cq+rfIpsHEI5eInwSRA6CWNZGaX/+x8lX6/EWFoKgMLDA/f583G7fy4KcU4ndHCXLyKCDAZODmb4zLBOs8J0UU0RW1K38GPKj6SUpVi2+9j7MKvnLGb1nEWoS6j1BijcMpNWS/4/36Bs7VoA7EeOIOCdd1C6dbwAtT7oCAkJpabMSJVWw+37JlllLIfnHcZedf3VqUtKSvD09GTp0qUsXrz4mvvKZDICAwN56623GDp0KO+//z4rVqwgPT0dd3d3ysrKiIiI4PHHH2f+/PnU1NTw8ssvYzAYLOFQbGwsx48f57HHHmPRokUcO3aMJ554guXLl7Nw4UKysrIICQnh0KFDDB06FICTJ08yePBgUlJSCAsLa9Hv/+CDD6LVavn++++bvF2EUk0QoVT7qD52jPQFj4DBgNfzv8Pzqadu6f4kSWLniniSj+bj5G7Lfa8O7bq9boQOL608jY0XN7Lx4kbyq/Mt23u69OT2nrdze9jt+Dr4WnGEzdPrjOz/Ppnz+3IA8AhwYNIjHXDZal1VQ+XT5T2fyjKaP8bewxw6eUU2nn7n2DWmWgqCAKaaGsp+WEfJihXoc8yvY3IHB1zn3of7/PmofLrI1GOhS6rVGtj/XTLx+3MB8Ah0ZPKjvfHw72DvwXW0Bi1xmXFsTt3caHqejcKGCcETmN1zNsP9houm5V2ALiWF7N+/gC45GWQyPBYuxOu533bYqdL1QYe3qx/GWjk6tMz45eYLIG5FS0OpI0eOMHz4cNatW8ecOXOuua9MJuPVV1+1VCtpNBocHR3Ztm0b06ZN4/XXX2ffvn3s2LHDckxWVhZBQUEkJSURERFBbGwsBQUFnD9/3nLR/JVXXmHjxo3Ex8cD5sqt0NBQPvzwQwCee+45zp49S1xcXIt+9wMHDjBu3Di2bNnClClTmtxH9JQSrEKfnU3Wc78DgwGn6eZlnW+VTCYjdl4k+WkVVBTWEPdNIlMXdt2m00LHFuoSynODnuOZmGc4nHeYDSkb2JWxi4vlF3nvxHv8+8S/Geo7lNvDbmdyyOQOU8Ked6mcn7+Ip7zAvBLOgElBjLgjDKXKiieTuqqGKXeWyqdEKL9W+OTZuNeTV5Q5hHIQDVQFoauT29nh/uADuN13LxXbtlH86WfokpMp+XwFJV+vxOX22/F49BFswsOtPVRBuIraVsn4h6IJ6edJ3DeJFGdV8d0/jzFyTk/6jw/sENXKJsnEsbxjbErdxM70nWj0GsttA7wGcEevO5gaOhVntbi43xVIkkT5unXk/eN1JK0Whacn/m/+C8fRo609tOvS1xrRVhtQKdV4e7lxeN5hq4zDTtmyVf5utNanf//+lp8dHBxwdnamoKAAMDccj4uLw9Hx6s8YFy9eJCIiAoARI0Y0+rw8cuRIli1bhtFoRKFQsHDhQh599FHeeecd5HI5q1at4t13323R+M6dO8cdd9zB3/72t2YDqdYiQinhhpiqq8l89rcYS0qw6R2N/9KlrRYcqe2UTHmsD+veOs7FE4Wc35dD37EBrXLfgnAzFHIFo/xHMcp/FBW1FexM28nm1M0cyz/GkbwjHMk7wtLDSxkfNJ6ZPWcy0n8kKnn7V/gZDSaObr7EiR3pSBI4uNowcUE0QVHu7TcIXeVl/Z4SGn4uz2z+GAevy3o9XVb9JMInQej2ZCoVLrNm4TxzJlW//ELJ5yuoPnaM8vXrKV+/HodxY/F47DHshw4VF7CEDicsxgufHs7s/jqRjPPF/PpdMpdOFzJhfrTVlrFPKU1hU+omtqRuaVQF7u/gz2/CfsPMnjPp4dLDKmMT2oaxSkPe3/9OxebNADiMGon/m2+i9Or4FeZVpVq0VXpwBHtndd0Mmo49iyY8PByZTNbiZuYqVePfRyaTYTKZF+mpqqpi5syZvPnmm1cd5+fn1+IxzZw5ExsbG9avX49arUav13P33Xdf97j4+HgmTpzIE088wauvvtrix7tZIpQSWkySJHL+9Gd0CQkoPDwI+s9/kNtfv5TxRviEOjNidk8OrEth3+oLuHrbEdieH6wFoRnOamfuiriLuyLuIqcqhy2pW9iUuolL5ZfYnrad7Wnbcbd1Z1roNGb2nEkfjz7t8kGpKKuKn7+MpzirCoCIYT6MuS8CW4c2euPWVkDRhbrgKbGh6XhFVvPHOHhfFjpFNkzBE+GTIAjXIZPJcBo/Hqfx46k5fZriz1dQuXMnmj170ezZi22/fng89ihOkyd3iGXMBaGeg4sNtz/bn/P7ctj/fTLZF8pY/foRbrsnnOhRfu1yjlBYXcjWS1vZnLqZxJKGD8pOKiemhE5hZs+ZDPQeiFzWOfpeCS1Xc/482S+8gD49AxQKvH77WzyeWIhM3vH/rXXVen75NpHgETYoVHIcXG2sPaQWcXd3Z+rUqXzwwQc899xz12x0fj2DBg3ihx9+IDQ0FOU1plgePty4euzQoUOEh4ejqHs/VCqVPPzww3zxxReo1Wrmzp2Lnd21g/Hz588zYcIEHn74YZYuXdqi8d4q0VNKaLGijz6i8L1/g0pFyJdfYD94cJs8zuX9pWzsldz10mDcfB2uf6AgtDNJkogviWfzxc1svbSVEm2J5bYQ5xCm95jO9B7TCXNpWSPBG2Eymji5M4Mjmy5hMkrYOqgYNy+SXoO9W+cBtBWXTbtrYfjk6HN1s3GvKLAXwbIgCK2nNi2N4i+/pHz9j0g686qpquBg3Bc8jOucOcivc8ItCO2tvLCaXV8mkHuxHICQfh6MfzAKB5fW/7BdritnV8Yutl7aytG8o5gkc+WFUq5kTMAYZvacydjAsdgoOscHfeHGSJJE6cpvKHj7bSS9HqWfHwHL/g/7QYOsPbQWMRpNbPnPaQpzyul/hyu9+0fg4Ni6RRBtKTU1ldGjR+Pu7s6SJUvo378/BoOBnTt38tFHH5GQkACYL7isX7+e2bNnW451dXVl+fLlLFiwgJycHGJiYhg3bhwvvfQS7u7upKSksHr1aj777DMUCoWl0fnChQt58sknOXHiBAsXLmTZsmU8eVl7neTkZKKjowHYv38/w4cPb3b8586dY8KECUydOpW3337bsl2hUODVTIWdaHTeBBFKtY3KXbvIeuZZAHz/sQS3e+5p08cz6I1sePcUeanlOHvacvcrQ7BzbN/lPwXhRuhNeg7mHGRz6mbiMuLQGrWW26Lco5jRYwbTe0xvlQbpZfnV/PxlPPmXzMs0h/b3ZPyDUdg738RzRFt+2bS7ywKoiuzmj3H0bRw61U+/E+GTIAjtyFBcTOm3qyj99luM5eYP+wo3N9zun4vbvHkoPUU1ptBxmEwSp3/O5NDGi5gMEjYOSsbdH0n4kFtv3l9jqGFP5h62XtrKr9m/ojfpLbf19+rPzLCZTAudhqut6y0/ltBxGcvKyPnzq1Tt2gWA44QJ+P9zKYoWVudYmyRJ7FmVxPl9OTh6KRl8rwe9wnteFXR0dLm5uSxdupTNmzeTm5uLl5cXgwcP5ve//z2xsbHA9UMpMIdJL7/8MnFxceh0OkJCQpg2bRrvvPOOuR9zbCx9+vTBZDKxatUqFAoFixYt4vXXX7+qEnPs2LGUlJRw7ty5a47973//O6+99tpV20NCQkhLS2vyGBFKNUGEUq1Pe+EC6XPvx1RdjdsDD+D7l7afVwpQU1nL928eo6JIi18vF+743cBOs6yu0L1p9BriMuPYmrqVgzkHMUgGy22DvAcxo8cMJodOxt32xkIcySRxdk8WB9ddxKA3obZVMOa+CCJH+F5/GkBNWdOVT5U5zR/j5HdZo/HLwie7jrd0sCAI3Zepupqydesp+fJL9Fnmak6ZSoXzrJm4P/wwtnUNYQWhIyjOqWLXlwkUZlQC0GuwN+Puj8TW8cam3ddfDNt6aSu7M3ZTY6ix3NbLtRczesxgWo9pBDkFter4hY6pav9+cv/8Koa8PGQqFd4vvojbQw92qp57p37OYP/3KSCDqU9Fo1eXNRl0CDdGkiTCw8N5+umneeGFF1r9/kUo1QQRSrUuQ2kpaffciz4rC/sRIwj+9L/IVO3XZK4kV8MPbx2ntsZAxHAfJi3o3aleXAWhVFvKzvSdbL20leP5xy3bFTIFI/xHMKPHDGKDYq+7yk1liZZdXyWQnVQKQGCUGxPmR+PkfsUbdU1p3Qp39c3G675X5jZ/507+Tfd8snO92V9bEASh3UkGA5U/76Lkiy+oOX3ast1h9GjcFyzA4bbR4hxC6BCMRhPHt6ZxbFs6kknC3lnN+IeiCO137eo+o8nI8fzjbE/bzs70nZTpyiy3BTgGWNoGRLiJILa7MGk05L/9NmWr1wCgCgkm4J13sOvTx8ojuzGppwrZ9slZkGD03b2Ius272aBDaLnCwkJWr17N4sWLyczMxM2t9S8sd/hQqqSkhN/+9rds2rQJuVzOXXfdxXvvvdfk0ob1YmNj2bNnT6NtTz75JB9//HGLHlOEUq1H0uvJeHwh1YcPowoKInTtGpRt8B/5ejITStj0/mkkk8SwmT0Y+huxMojQOeVp8tiRtoMtqVtIKEmwbFfJVYz2H82U0CmMDxqPo7rhNVKSJBIP5vLr2mRqtUaUajmj7uxF3yF2yIovNIRO9SFUVV7zA3AOaBw6WSqfXNvwtxYEQWh/1SdPUvLlV1Tu3Al1qxnZhPfCfcECnG+/HbmN6KcjWF9BegU/fxFPaV41ANGj/Bh9Tzg2dg2NjY0mIycKTrAjbQc/p/9MsbbYcpuHrQdTQ6cyvcd0BngNEKFrN6M5coTcP/3ZUiHq9sADeP/hhVZfiKqtFWZUsu7/jmOoNdFnbADj7o9Ap9OJUKoVyGQyPD09ee+995g3b16bPEaHD6WmT59Obm4un3zyCXq9nkceeYShQ4eyatWqZo+JjY0lIiKCJUuWWLbZ29u3OGASoVTryfvH65R++y1ye3tCVv/PquXv5/dl88u3SQBMeawP4UNvff69IFhTWnka2y5tY3vadlLLUy3b1XI1owNGMzV0KkMcRnJ41UUyk8wl/r5upUwM+RHXykOgKWj+zp0D6qbcXV75FAG2Lm39awmCIHQotVlZlK5cSdl332OqNn/wV3h44DbvftzmzkXp4WHlEQrdnUFv5PCGVE7tygQJHFxtGDcvghKfDHak7WBn+k6Kaoos+zurnZkQPIHpPaYzzHcYSrlYTL27MdXUUPDuu5R+vRIApb8f/kuX4jBypJVHduOqSnV8/6+jaMprCertzm+e6Y9CIb9m0CF0LB06lEpISKB3794cPXqUIUOGALB9+3ZmzJhBVlYW/v7+TR4XGxtLTEwMy5cvb9Hj6HQ6dHUrr4D5Fw8KChKh1C0q+2EduX/+MwCBH/wHp4kTrTwi2P99Mqd+zkShlDP7hYH4hokP2ELXkFKawo7kH9mRvoNL1XkgyeidP4qR6bNQmWyRyWoZ7Pg/htpvRC4zNRzoEnRZxVNdCOUZAbbitU8QBOFyxspKyr77npKVKzHkmqczy9RqnH/zG9wfehDb3r2tPEKhu8u6UMKOr86gLTa/zyd5HuFA6Hp0qmqc1E5MDJ7I1NCpDPcdjkrRfq00hI6l+uRJchf/idq6ptOu99yN98svo7jGTKSOqlZrYP2yExRlVuHm58BdLw22VAmKUKrz6NCh1IoVK/jDH/5AaWmpZZvBYMDW1pbvvvuOOXPmNHlcbGws58+fR5IkfH19mTlzJn/5y1+wb6YMsbkO8SKUunnahATS5t6PpNPh+dxv8Xr6aWsPCTCvWrL9k7NcOl2EnZOKu18egrOnWPZZ6GQ0xXVT7q5Y7U5TiASckQWyr/xpZNXmpVtznVL5pecqauyKGGXjw2TvwYzrMQMX/4Fg42Td30UQBKGTkfR6KnfupPjLr9CeOWPZbjdkMO4Pzcdp4gRkSlF5IrQPg8nA8fzj/Jz+M7szdlNSVcqQzOn0zx2PHDlGWx09brdj2vjRIojq5ky1tRS9/z7Fn68Akwmltzd+r/8Dx7FjrT20m2IySWz7+CxpZ5r+XCdCqc6jNUKpNnvXzcvLw9vbu/GDKZW4u7uTl9d8z5N58+YREhKCv78/Z86c4eWXXyYpKYl169Y1uf/ixYsbdZGvr5QSbo6xooKs536HpNPhOG4cnk89Ze0hWcjlMiY/2od1/3ecoswqNv/ntDlRtxdv0kIHpCmq6/NUHzzV9X2qLmpyd5Mk56z0AIeKZiIzqVAqTYTdpsMUVo5rtj3lFRK/6PL4JXMLyqwdDPMbxsTgiUwInoCnnVj2XBAEoSVkKhXOM2bgPGMGNadPU/L1Sip27KDm2HGyjx1H6e+H+7x5uN59d6dZRl3oXGqNtRzKPcTP6T8TlxnXqFm5o60j3hMhXKWieJsNZXmQ8b2JXalJjJ0bgb2z2noDF6ym5tx5che/gi45BQCXO2bh86c/oXDpvLNGDqxLIe1MEQqlnBmL+otCg27uhiulXnnlFd58881r7pOQkMC6dev46quvSEpKanSbt7c3r732GosWLWrR4+3evZuJEyeSkpJCz549r7u/6Cl18yRJIuvZ31K1axeqgAB6rPuhQ77YVZXq+P7NY2jKdARFu/GbZwegUMitPSyhO5Ikc/h0ZbPxwgSoLm7+ONeQuul25ml3pbJwdm+TyEurAiAg0o3xD0bh4mVX9zASyWXJ/Jz+Mz9n/ExyabLlrmTIGOg9kMkhk5kYPBE/R782/ZUFQRC6Gn1+PqWrV1O2eg3Gugp/ma0tLrNm4f7Qg9iEh1t5hEJnV62vZn/Ofnam72Rv1l40eo3lNlcbVyYET2BS8CSG+w1HrTAHT0a9iWPb0ji+3bxCn62DijFzwwkf4iMamncTpupqCj/4gJIvvwKjEYWHB35LXusQbVVuxbm92exZVdcr+PE+hA+5ulewqJTqPKwyfa+wsJDi4mt82ALCwsL45ptvbmr63pU0Gg2Ojo5s376dqVOnXnd/EUrdvOLPPqPg/5YhU6kI+d//sOvbcZcSvXyVht5j/ImdFyneoIW2I0mgKWwcOtWHUDUlzRwkA7eQhn5P9SGUZwSoHQAwGU2c3JnB0c1pGA0mVLYKRt/Vi963+V/z/3N6Rbo5oEr/mXPF5xrd1sejDxOCJzA+aDy9XHuJ54UgCEILmXQ6KjZvoWTlSnSJiZbt9iNG4DbvfpwmiKl9QsuVakvZm7WXuMw49mfvR2vUWm7ztvNmYshEJgVPYpDPoGs2Ky/MqGTX1wkUZ5kvXIX29yR2XiQOrmIFya6sctcu8pYuxZBj7oHnNH0avn/9q1VWQm9NGeeL2fzBmeuuqi5Cqc6jQ/eUqm90fuzYMQYPHgzATz/9xLRp067Z6PxK+/fv57bbbuP06dP079//uvuLUOrmaA4fIeORR8Bkwve113C7715rD+m6Lp0uZOvHZ0GCfuMDGXNvuPgALtwaSYKqgqYrn2pKmzlIBm6hjSqf8KoPn5pfkrcwo5K4bxIpzDCvrBfcx4PYByJxcr+xN97cqlx2Z+5mZ/pOTuSfQKLhJT3IKYjYoFjGB41noPdAsUKPIAhCC0iSRM2xY5R8vZLKXbvAZG48rfT1xe2+e3G9+26UXl5WHqXQEWVUZBCXGUdcZhwnC05ikhoWJwlwDGByyGQmhUyin2c/5LKWV/kbjSZO7kjn6JY0TEYJtZ2SUXf2pPdof2Ryce7bleizs8lb+k+qdu8GQOXvj89fXsVp/Hgrj+zWZcaXsOWjMxj1JiKG+zBpQe9mP7uJUKrz6NChFMD06dPJz8/n448/Rq/X88gjjzBkyBBWrVoFQHZ2NhMnTuTrr79m2LBhXLx4kVWrVjFjxgw8PDw4c+YMv//97wkMDGTPnj0tekwRSt04fUEBl+68C2NRES533IHfv97oNOFO/P4c4r5JNAdT4wIYMzei04xdsCJJgqr8piuftGXNHFQXPnlH1614F20OoTzCrxk+XalWa+DIpkuc2Z2JJIGNvZLb7g0ncrjvLf/fLaop4pfMX4jLjONQziFqTbWW21xtXBkbOJbxQeMZ5T8Ke1XLxywIgtBd6bOzKV2zlrLvv8dYUlcZq1LhPHkybg/Mw27QIHHe0Y2ZJBPnis6Zg6iMOC6WX2x0e6RbJBOCJzAheAKRbrde1V+cXcXurxMoSDdf0PLr5ULsvCjc/R1u6X4F65P0ekq++orCDz5EqqkBpRKPRx7B8+lFyO06f7+ljPPFbP3oLEaDidB+Hkx7oh8KVfPBbFcPpWQyGevXr2f27Nk3fR+xsbHExMSwfPnyVhvXzejwoVRJSQnPPvssmzZtQi6Xc9ddd/Hvf/8bx7olK9PS0ujRowdxcXHExsaSmZnJgw8+yLlz59BoNAQFBTFnzhxeffXVFgdMIpS6MZJeT/ojj1Bz7Dg2ERGErlnd6V74Lg+m+o4NYOzcCHHVSDCTJKjMa7rySVve9DEyObj1aKLyKRxUt/bcuHS6kL2rL1BVqgMgfIg3o+8Jx8Gl9Uvwq/XVHMg5QFxmHHuy9lCua/h91XI1I/xHEBsUy9iAsfg4XD2XXxAEQWhgqq2lcvt2Slf9j5pTpyzbbSIjcbv/flxm3o7cQQQD3UGNoYajeUf5JfMXfsn8hcKaQsttCpmCIT5DGB88ntigWAIcA1r98U1GE2d/yebQxlQMOiNyhYyBU4IZMj0UpVrR6o8ntL3qY8fIe+01SyNz+yFD8P3bX7tMP7v088Vsqw+k+nsybWHfawZS0LlDqby8PJYuXcqWLVvIzs7G29ubmJgYnn/+eSbW9QPrqKFUcXExDzzwAGfOnKG4uBhvb2/uuOMO/vnPfzabrXT4UMoaRCh1Y/LfepuSFSuQOzgQ+v132PRoel5vR5dwIJfdKxNAgj5jAxgngqnuRZKgMvey0Cmx4eta4ZN72NU9nzx63XL4dKWqUi371iSTesp84ursacvY+yMJ6ePRqo/THIPJwMmCk+zO2E1cZhzZVdmNbo92j2ZM4BjGBY6jr2ffG5pSIAiC0N3UnD9P2erVlG/ajKQ19wmSOzriMmcObvfdi02vXlYeodDacqty2Zu1l73ZezmcexidUWe5zV5pz20BtzE+eDxjAsbgYtM+iwRVlmjZu/oCaWfMq/o6e9kRe38kQb3d2+XxhVtnKC2l4O3/o7xulXmFmxveL72Ey+w7ukwFZtrZIrZ9chaTQaLHAE+mLuyLQnn988zOGkqlpaUxevRoXF1dWbJkCf369UOv17Njxw7++9//kljXr7CjhlKlpaWsXr2aoUOH4uXlRUpKCs888wyDBg2yzHa7kgilmiBCqZar2LmT7N8+B0DAv9/DecoUK4/o1iQeymXXV+ZgqvcYf2LvjxTBVFcjSVCR00TlUxLoWhg+eUebv3v0AlXbvsmZTBJnf8ni8IZU9DojcrmMmMnBDPlNKCorXc2sX8kvLiOOvdl7OVt4tlEfKndbd24LuI1xgeMY5T8KR7WjVcYpCILQ0RnLyylbv57S//0PfXqGZbvd4MG43XsPTlOnIu9EH6aEBkaTkbNFZ9mTtYe9WXu5UHqh0e1+Dn6MDRxLbFAsw3yHWVbMs4bUU+YqbE2ZOSiLGObD6LvDsXe23piEa5MMBsq+/57Cd5djLDefv7recw9eL/y+0zcyv9zlgVRYjBdTHu/TokAKrg46JEkyT2u0ApmdXYtDwhkzZnDmzBmSkpJwuKJ6tqysDFdXV/N9ymR8+umnbNmyhR07dhAQEMCyZcuYNWuWZf9z587x4osvsm/fPhwcHJgyZQrvvvsunp6egDmU6tu3LwArV65EpVKxaNEilixZgkwmY8mSJaxdu5Zz5xovihQTE8PMmTP5xz/+0aLf6d///jdvv/02mZmZTd4uQqkmiFCqZWrT0rh09z2Yqqpwf+QRfF5+ydpDahVJh/PY9WU8kgS9R/sR+0CUCKY6I0mCimwoqK94ujx8qmj6GJnCHD5dPuWuftqdsv1XqCnMqOSXbxMtfR98w5yJfSAKj4COFfIU1xSzP2c/ezL3cCDnAFX6KsttSpmSwT6DGRM4hjEBY+jh0qPLXLkTBEFoLZLJhGb/AcrWrqFydxwYjQDIXVxwuWMWbveK6qnOoExbxoGcA+zL3sev2b9Spiuz3CaXyRngNYCxgWMZGziWcNeOtbhOrdbA4Y2pnI3LsvSrHHVnL6JH+Ynz4A5EkiQ0e/eS//bb1KaY+4/ZRETg+/e/Yz9ooJVH17ounSli+ydnMRkleg70YvLjfVAoWl6Jf2XQYaquJmnQ4DYccfMiTxxHbn/9XqwlJSV4enqydOlSFi9efM19ZTIZgYGBvPXWWwwdOpT333+fFStWkJ6ejru7O2VlZURERPD4448zf/58ampqePnllzEYDOyua4IfGxvL8ePHeeyxx1i0aBHHjh3jiSeeYPny5SxcuJCsrCxCQkI4dOgQQ4cOBeDkyZMMHjyYlJQUwsLCrvs75eTkMG/ePAIDA/nmm2+a3EeEUk0QodT1mWpqSJt7P7qkJOwGDybkyy+QqVTWHlaruXAkj5+/MAdTUaP8mPCgCKY6LEmC8qzLmo0n1gVRSVBb2fQxMgV49Gw85a6+8skK4dOVarUGjmy+xJld5kbmajslI+f0pM9tHX+FHL1Jz8n8k+zN2suerD2kVaQ1ut3PwY/RAaO5zf82hvsNF1VUgiAIV9DnF1C+fh1la79Dn5Nj2S6qpzoeo8nIueJz7M/ez6/Zv3Ku6FyjymEntRO3BdzG2MCx3OZ/G662rtYbbAsVpFfwy7dJlpV9/Xq5MG5eJB7+4v3a2rQJCeS/9RbVBw8BoHBxwfOZZ3C7f26X+hwG5h6q2/97zhxIDfJm8mO9byiQgs4ZSh05coThw4ezbt065syZc819ZTIZr776qqVaSaPR4OjoyLZt25g2bRqvv/46+/btY8eOHZZjsrKyCAoKIikpiYiICGJjYykoKOD8+fOWkPyVV15h48aNxMfHA+bKrdDQUD788EMAnnvuOc6ePUtcXNw1x3f//fezYcMGampqmDlzJmvXrm12GqUIpZogQqlrkySJ3MV/ovzHH1F4etLjhx9Q+Xhbe1itLvloPjtXnDcHUyN9Gf9QNPIOHgh0aSYTVGRd3Wy8MAlqq5o+Rq4E956NK5+8o83blB2vJF2SJC4cyefAuhSqy82r3rVlI/P2kFGRwd6svfya/StH8442Ws1PKVMywHsAtwXcxmj/0US6R4peVIIgCHUkoxHNgQOUrllDVdwvV1VPud59N7YREdYdZDdUWF3I/pz97M/ez4GcA1TUNq6+jnCLYHTAaMYFjmOA1wCUcqWVRnrzrmyELpPL6B8byNDbQ7Gx71rhR2egz8ujcPl7lG/YAJKETKXCbf5DeD75JIou+Fk19VQhOz41B1K9hngz+ZHeyG8wkILOOX3v8OHDjBgxosWh1Nq1a7nnnnss21xcXHj//feZP38+99xzDxs2bECtbvyZR6PRsHXrVqZPn05sbCxhYWGsWLHCcvuGDRu4++670Wq1KBQK1q9fz6OPPkpubi5yuRx/f3/effddHnrooWuOLy8vj7KyMi5cuMDixYsZN26cJdi6UmuEUp3vlVa4JWXff0/5jz+CXE7AsmVdMpACCB/qAzLYuSKexIN5SBJMmC+CqTZnMkF5ZkOTccv0uyTQa5o+plH4FN0QQnXQ8KkphRmV7F19gbxUc18AZy87xt4XQUjf9mlk3laCnYN5sPeDPNj7QWoMNRzLO2Y5mU+rSON4/nGO5x/nvRPv4WHrweiA0Yz0H8kIvxF42nlae/iCIAhWI1MocBwzBscxY66qnir9eiWlX6/Etm9fXO+6E+cZM1C4tE9z7O5GZ9RxsuAkB3MOsj97P0mlSY1ud1I7Mcp/FKP9RzPKf1SXWI1WrpAzYGIQYQO92LfmApdOF3F6dyYXjuYxYnZPokeKKX3twVilofjzzyj54kvLggjOM2bg9cLvUQcGWnl0bSP1ZF0gZZIIH+LNpJsMpJoik8mQtaBayZrCw83TeuubmV+P6ooKOZlMhslkAqCqqoqZM2fy5ptvXnWcn59fi8c0c+ZMbGxsWL9+PWq1Gr1ez913333d43x9ffH19SUqKgp3d3fGjBnDX/7ylxt67BshQqluRJecTP7rSwHwev55HIYPs/KI2lb4EB9kMhk/fX6epEN5SJLExPnRrfbi2K2ZTFCecVnoVP914Rrhk8rc38krsnHPJ4+eoOicV+5qKms5tDGV+F9zQAKljYIh00OImRh83aVuOxs7pZ25t1TgGAAyKzM5kH2AX3N+5XDuYYq1xWy8uJGNFzcCEO4Wzki/kYz0H8lgn8HYKVt3RUNBEITOQuXjjedTT+GxcCGaAwcoW7uWyrhf0J47R965c+S/8S+cJk3C5a47cRgxApnCOgthdAUmycSF0gsczDnIwZyDnCg40WilPBky+nj0MU9FD7iNvp59O2U1VEs4udsyY1F/MuKL+XVtMqV51cStTOT83mzG3BeBb5gIQtuCuYn5DxS+/z7G4mIA7AYNwufll7AbMMDKo2s7F08U8NNn582B1FAfJi3ofp+53N3dmTp1Kh988AHPPffcNRudX8+gQYP44YcfCA0NRals/jXq8OHDjf586NAhwsPDUdS9jyiVSh5++GG++OIL1Go1c+fOxc7uxs7J64MynU53nT1vnpi+102YtFrS7rkXXXIyDmPGEPTJx8jk3eOF4vIXyaDe7kx5rA+2Dp0zBGl3JhOUpTeebleQAEUXQF/d9DEKNXhcFj7VV0C59+i04dOVTEYT5/Zmc2TTJXTVBsBcnTfqzl44unXOqXq3otZYy6mCU/ya8yuHcg6RUJLQ6HaVXEWMd4wlpIp2j0YhFx+6BEHovgwlJVRs2kTZD+vQXWhY2U3p54frnNm4zJmDOijIiiPsPHKrcjmUe4iDOQc5nHeYEm1Jo9u97LwY6W9+/xnlPwp3W3crjdR6jEYTZ+OyOLr5ErVa81TSqBG+jJjTs9O2GOhoJKORiu3bKfrgQ2pTUwFQhQTj/Yc/4DR5codqjN+aJEni1M5MDqxPAQkihvsw8eHetzw75VpTwjqy1NRURo8ejbu7O0uWLKF///4YDAZ27tzJRx99REKC+RxZJpOxfv16Zs+ebTnW1dWV5cuXs2DBAnJycoiJiWHcuHG89NJLuLu7k5KSwurVq/nss89QKBSWRucLFy7kySef5MSJEyxcuJBly5bx5JNPWu43OTmZ6OhoAPbv38/w4cObHf/WrVvJz89n6NChODo6cv78eV588UXc3d359ddfmzxG9JRqggilmpb72muU/W81Ck9Pwn5cj9Kze02tST1VyM4V5zHUmnDxtmPGov64+zlc/8DuwmSCsrQmej5dAEMz87frw6crV7tzDwNF17zqCJCVWMK+tcmU5JgrwjyDHBlzXwT+vVytO7AOpERbwpHcIxzMNV+pztXkNrrdWe3MMN9hDPUdynC/4YS5hHXZkzVBEIRrkSQJ7fl4ytf9QPnmLZgqGnoc2Q8bhsucOThNnozCUZyz1CvRlnA07yhH845yOPfwVYty2CntGOo71HIhRLzHNKiuqOXQjxdJOGB+X1bZKhg6owf9JwSiUHaPi9WtTTIaqdi2naIPG8IocxPzp3GbOxeZunO0orgZBr2RuG8SuXA4H4DeY/wZd39kq7RL6ayhFEBubi5Lly5l8+bN5Obm4uXlxeDBg/n9739PbGwscP1QCsxh0ssvv0xcXBw6nY6QkBCmTZvGO++8g0wmIzY2lj59+mAymVi1ahUKhYJFixbx+uuvX/WaN3bsWEpKSjh37tw1xx4XF8ef//xn4uPj0el0BAUFceedd/LKK680W+UlQqkmiFDqahU7d5L92+cACPr8MxxHj7byiKyjMLOSrR+doapEh9pWweTH+hDar3uFc5iMUJrWROVT8rXDJ8+Iusqn6IYKqC4ePl2poriGAz+kcPFEIQC2DiqG3xFG79v8Ra+ya5AkiYzKDMtUiiN5R6jSN25u72HrwVDfoQz1Hcow32GEOIeIDxCCIHQ7Jp2Oyp9/pnzdejQHDphXqAVktrY4TZyIyx2zcBg1Ctk1pnJ0ReW6co7lH+NI7hGO5B0hpSyl0e1ymZy+nn0tIVR/z/6oukhldlvJv1TB3jUXKEgzh6CuPvbcdk94p++F2Z4ko5GKrdso+ugjSxgld3bG/eH5uD/0UJdsYn45TZmOrR+fpSCtAplcxm33hNMvNqDVzt86cyjV0UiSRHh4OE8//TQvvPBCq9+/CKWaIEKpxvS5uaTOnoOpvByPxx/D+49/tPaQrKq6opbt/z1Lbko5yGDknJ4MnBzc9T4AW8KnKxqOF10Ag7bpYxQ25vDJO+qyACoK3EK7Vfh0JW2VnuPb0zjzSxYmg4RMBn3HBTJsZg8xDfQmGEwGzhWd42jeUY7kHeFkwclG/T4AvO29GeY7zFJNFeDYeic5giAInYE+J4fyDRso37CR2rQ0y3aFhwfOM2bgMmsmtn37dsnXxqraKk4UnOBw7mGO5h0lsSQRicYfV8Ldwi3vEUN9h+KsFuf8N0oySSQeyuPgjxepqTCvrhsY5cbIOT3xDhF/n80xh1FbKfrwI2ovXQLMq2p6LHgYtwcfROHkZOURtr38SxVs/fgM1eW12DgombawL4FRrTstVoRSraOwsJDVq1ezePFiMjMzcXNza/XHEKFUE0Qo1UAyGkl/+GFqjh3Htl8/Qr/9pkuXkLaU0WBi75oLxO/LAcxzn8c/EIVS3Ql73JiMUHKpLnyqn3aXWFf51Ez4pLStazheV/XkfVn4JPr8WBhqjZyJy+L49nRqa8x9owIiXbntngg8Ax2tPLquo9ZYy5nCM+ZpGHmHOVN4Br1J32gfXwdfBvsMZpD3IIb4DKGHS48u+UFMEAThSpIkoT13jvING6nYuhVjSUO/JHWPHrjMmonzzJmdejWvEm0JJ/NPciz/GMfzj5NUmoRJMjXap4dLj0YhVHfsC9VWdDUGjm25ZLn4BuY+mcNnheHiJRYpqScZDOYw6qOPG4dRjywwh1GO3ePcMOlwHnErEzEaTLj7OzBjUT9cvFp/VTwRSrUOmUyGp6cn7733HvPmzWuTxxChVBNEKNWg8IMPKHr/P8gdHOixfh3q4GBrD6nDkCSJc3uy2bc2Gckk4R3ixPSn+nfcJtVGA5Realz1VB8+GZtZCUFpWzftLqpx3ycRPl2TySSReDCXI5suoSkz/916BDgy8s6eBPd2F2FIG6sx1HC68LRlmsb5ovMYJEOjfdxt3RnkPYjBPoMZ7DOYCLcI0ThdEIQuT9Lr0Rw4QPmGjVTu2oV02UpIdoMG4TxjBs5Tp6D08rLiKK8vT5PH8fzjlq/U8tSr9glyCrKEUMN8h+Fl37F/p66goqiGw5tSuXAkHySQK2T0GRvA0Bmh2Dl134vaJq2W8g0bKfniC0vVosLFBfdHHsHtwQe6TRhlMkkcWn+RkzszAAjt78nkR3ujtm2b2RQilOo8RCjVBBFKmVUfP076Q/PBZML/7bdwmTnT2kPqkLISS9j+6Tl0GgP2LmqmP9UP3x5WXCLXaICS1IbQqT6EKk4GY23TxyjtwCviisqnSHANEeHTDZAkibSzxRxcf5HSXHMTc0d3G0bMCiN8mK/oG2Ul1fpqzhSd4UT+CY7nH+d04emrpvs5qhyJ8Y5hkPcgYrxj6OvZFzuluLorCELXZayqonLnz5Rv3ED1ocOW/lPI5dgPHYrz9Gk4TZmC0t26FUUmycTFsoucKjzFqYJTHM8/TnZV9lX79XLtZbnQMMh7ED4OPlYYrQDmHqyH1l8kI95claeyVTBwcjAxk4JR2XSf80p9QQGlq1ZRtnoNxrIyoC6MevRR3B54oFstPqCrMbDz8/OknysGYPD0EIbPDEPWhufGIpTqPEQo1QQRSoGxrIzUOXdiyM3F5Y478H/zX9YeUodWXljD1o/OUJKjQaGUM/7BSCJH+LXtgxr1DeHT5ZVPxSnNh08q+4Ym415RDT+7hoBcrJhyK/JSyzmwLsXcawywcVAyZHoofccFoFR1nxOwzkBv1HO++DzH8o9xIv8EJwtOXtU4XSlTEukeyUDvgQzwHkCMVwy+Dr5WGrEgCELb0ufnU7F1GxXbt6E9fabhBoUCh+HDcZ4xHadJk1A0s3JSa6rWV3O26CwnC05yqvAUZwrOUKmvbLSPQqYgyj2qUQjlatv2YxNuTGZiCQfXXaQww/zvZ++sZujtPYge7YdC0XXPO7Xx8ZR89RXlW7eB3txOQBUQgNtDD+J69z3dKowCKMuvZsuHZyjLr0apkjPh4WjCh7R9aCxCqc5DhFJN6O6hlCRJZD/3Oyp37kQdEkLoDz90uxfPm1GrNfDzF/FcOl0EQN+xAYy8s+etl6TWh08FCQ0r3hXUhU9X9M2xsIRPV1Q+uQSL8KmVFWZWcmxLGqmnzCvqKVRyBkwIYtDUYGzsRRPzzsBoMnKh9ALH849zqvAUJwtOUlBdcNV+fg5+xHjFEOMdwwDvAUS4RaCSi39jQRC6ltqsbCq3b6Ni6za08fENNyiVOIwaifP0GThNGI/C5darwiVJIkeTw5nCM+YQquAUF0ovYJSMjfazU9rR37M/A7wHMNh7MAO8B+CgEuemnYFkkkg5UcChHy9SUWTuVerqY8/Q34TSa4hPl6kil0wmqn75hZIvv6L6yBHLdrtBg3B/+GGcJk7odqteSpJE8tF89q6+gK7agKObDTMW9ccruH0auYtQqvMQoVQTunsoVbp6DXl//zuoVIT+73/Y9e1j7SF1GpJJ4sjmSxzbmgaAk7st4x+KIii6BaXvhtq6yqe68Kk+hLpm+OTQOHSqD6FcgkT41Mby0yo4tjWNtDPmEFImgzonDPYAAQAASURBVKhRfgy7vQeObuKNr7PLrcq1BFTNfUiyUdgQ7R5NP69+9PM0f4lV/gRB6Epq09Op2Ladim3b0CUlNdygVOIwbCiOkybhNHEiKp+WVT1U1FZwrugcZwvPcq7oHGeKzlCiLblqv8svAsR4xxDhFoFS3r0+0Hc1RoOJ8/tyOLb1EjWV5vNaF287Bk8LJWK4T6etnDJpNJT9+CMlX3+NPt3cKwmFAuepU3Ff8DB2/ftbd4BWoinT8cuqJMt5sm+YC9Of6oe9c/v1FhOhVOchQqkmdOdQSpeczKW770HS6fB++WU8Hllg7SF1SpkJJcR9k0hlsfmKUO/Rfoy6OxwbO2Vd+HSxceWTJXwyNH2Hakdzw/H6Ve7qG487B4rwqZ3lpJRxfGuapU+CTAa9hvgwZHoo7v7iqm1XVT+d5FTBKU4WnuRs4Vkqaiuu2s/d1t0SUPXz6kdfz75imXFBELoEXWoqFdu2Ubl9O7rklEa32fbvj9OkSThNmohNWBgAepOe5NJkzhae5UzRGc4WneVS+aWr7lcpVxLpJqZLdxe1WgNndmdxalcGOo35vNfJw5bB00KIGuGHQtXxz2slSaLm1CnKfviByq3bMFVXAyB3dsbt3ntwe+ABVH5t3Majg5Ik82I/v36XQm2NAblCxtDfhDJwaki7B48ilOo8RCjVhO4aSpm0WtLuuRddcjIOY8YQ9MnHyETgcdNqNdUcWnOas0dqAHCw0RDru5ZQ/dZrhE9ODX2eLl/tziXQnH4IViFJEtlJpRzbmkb2hTIAZHIZkcN8GDw9FFef1l/GVujYJEkivSKds0VnOVNo/rCVVJqEoYnndohzCL3de9PHsw+9PXoT7R6No7p7rLQjCELXVJuWRuWuXVTu/JmaU6ca3Vbh58zZaDt2BJeR5GtAuuL8JcAxgP6e/S1VptEe0dgoOujKxUKbqdUaOLc3m1M7MyyVU45uNgycEkzv0f4o1R2vH6ehpITyDRsp+/57ai9etGxXh4aa+0XNno3cofteoKws0RL3TSKZdRduvUOcmDA/Go8A65zziFCq8xChVBO6ayiVt2QJpav+h8LTk7Af16P09LT2kDoHgw6Kkq9e7a4kFSQjObW92V3+DOVGfwAibeO4zWMttn5BlzUdj66rfAoQ4VMHIkkSGedLOLY1jbxUcwNzuUJG1Eg/Bk0NwcVLrM4mNNAZdSQUJ3C26KylMqCpFaIAQp1D6e3Rmz4edUGVR7TojyIIQqdgMBm4VH6J88XniS+OJ/3SKVwOX2BgYi190yWUpoZ9yxxlZPb1xjQyBv9x0+gTMhQPOw/rDV7ocPS1RuL35XDyp3Q05eaFeuyd1cRMDqbv2ACrr9YnGY1o9u+n7PsfqIyLszQul9na4jx1Kq5334XdkCHdeuq+ZJI4/2sOB35IQa8zolDKGTarBzETg5BbcVpmVw+lZDIZ69evZ/bs2Td9H7GxscTExLB8+fJWG9fNaI1QSkzw7gIq4+IoXfU/APzf/JcIpJqi10Jx8mX9nuoCqJJUkExNH2PjjH+gA/e5H+VI1mhOJ3iQpB1PRuVUxt0eQc+B3u37OwgtYjSaSD1ZyKmdGRSkm1eMUSjl9L7Nn4FTgnFy73pvbMKts1HYWPqf1CvVlhJfHE98cbzlA1yuJpe0ijTSKtLYemkrADJkhDiHEOkeSZR7lOXL0068FguCYD3V+mqSy5JJKkkisSSRpJIkLpReQGvUNt4xBvYOdSbGPoKxGQ6EnynF8cQFXKtqcD2UD4d2wH92UzV4MIwdi+O4sajDwrr1B3nBTKVWMGBiEH3HBpBwMJcT29OpLNFy4IcUTuxIp//4QPqMCWjXXkQAtZmZlK9fT9m69Rjy8izbbfv1w/Wuu3D+zQwUTu3TsLsjKy+sJm5lomUmgV9PF8Y/FIWbr7jQdivy8vJYunQpW7ZsITs7G29vb2JiYnj++eeZOHGitYfXYsXFxQwYMIDs7GxKS0txbcMVXEUo1ckZSkvJ/ctfAXBfsADH0aOtPCIrqw+fChIbNx0vvXSN8MmlbrpdfeVTXdNxZ3+QyVABo4Gel8rZ/XUipbkatn9yjl6DvRlzX0S7v9EKTauuqOX8vmzO7822XK1TquX0GRvAwMnBOLiI6QXCjXGzdWN0wGhGBzS8rpZoS8whVZE5pIoviSdPk2cJqnak7bDs62HrQZR7lCWsinSPJMQpBIW8401rEAShcyuqKWoUPiWUJJBekY7E1RMi7JX2RHtEW6o9+3j0Idg5GLmsoSrCpNNRffQYVXv3oNmzl9r0dKoPHaL60CEK3noLVUAAjuPG4ThuLPbDhiG3E9XH3ZlCJafv2ACiR/uRdCiP49vTqSis4cimSxzblkb4YB/6jQ/EJ7TtZrHUZmVTuWM7Fdt3oD17tmFsLi443zEL17vuxjYyos0evzMxmSTOxmVxaMNFDLUmlGo5I+f0pN+4QGRdZEVFa0lLS2P06NG4urry9ttv069fP/R6PTt27OCZZ54hMTHR2kNssccee4z+/fuTnd30zIHWJKbvdWKSJJH9u+ep/Okn1L160uOHH5DbdJMP3vqaxtPuCuq+Xyt8snVpWOHu8hXvnHxbPO3OqDdxdOslTuzIQDJJqO2UxEwKov+EIHMjdKHd5adVcDYui+Tj+ZgM5pczO2c1fcb40z82EDsnERoKbau4ptj8YbA00fKBMK0iDVMTr0W2ClvCXMPo5dqLCLcIern2ItwtHC87L1F1IAjCdVXrq0kpSyG5NNnyPbksuclV8AC87LwaBeORbpGEOIc0CqBaojYtjaq9+6jas4fqI0eQ9A0rC8tsbLAbNBCHESNxGDUS2969kSlE+N6dmYwmUk4UcGZ3FvmXGhYW8enhTP/xgfQc5I1CeetTw/TZ2VRs30HFjh1oz5xpuEEux2HECFzvuRvHiRORq8W5IJin6qWeLuTo5jSKs6sACIh0Y/yDUR2urcWVU8IkScJQ28xnvDamVMtbfI42Y8YMzpw5Q1JSEg5X9CgrKyuzVBvJZDI+/fRTtmzZwo4dOwgICGDZsmXMmjXLsv+5c+d48cUX2bdvHw4ODkyZMoV3330Xz7pZUbGxsfTt2xeAlStXolKpWLRoEUuWLEEmk7FkyRLWrl3LuXPnGo0jJiaGmTNn8o9//KPZ3+Ojjz5izZo1/PWvf2XixInXrJQSPaWa0J1CqfJNm8h58SVQKgldsxq7Pn2sPaTWp6+BogsNoVP9V2naNcIn18ahU30I5ejTaj2fCjMq2b0ygaJM8wu6jb2SmEnB9J8QiNpWhFNtzWgwcfFEAWfirj7Z6RcbSK/BrXOyIwg3q8ZQQ0ppComliZbqhQulF6gx1DS5v4uNizmgcg0n3M38FeYShouNSzuPXBCEjqDWWEtaRRoXyy5agqfk0uRme93JkBHqEkqUmzl8inaPJsI9ok2mEZuqq9EcOkzV3j1U7dmLITe30e1yZ2cchg/DfsQIHEaORN2jhwjduzHLxcNj+ZiM5o+d9nUXD/uMDbjhSnZ9Tk5dELUd7enGQZT90KE4T5+G0+TJKD1E/7N6kiRx6XQRR7dcsnx2UdsqGHVXL3rf5t8hn59XBh16nZH//m6PVcbyxHvjWtQfraSkBE9PT5YuXcrixYuvua9MJiMwMJC33nqLoUOH8v7777NixQrS09Nxd3enrKyMiIgIHn/8cebPn09NTQ0vv/wyBoOB3bt3A+ZQ6vjx4zz22GMsWrSIY8eO8cQTT7B8+XIWLlxIVlYWISEhHDp0iKFDhwJw8uRJBg8eTEpKCmF1q61eKT4+nokTJ3L48GFSU1MZP368CKVuVHcJpfR5eaTOnIWpshKv3z2H56JF1h7SramtNodPluCpftpdGjRReg6AnVvTlU+O3u3ScFwySaScKODo5kuU5pmXk7VxUDJwcjD9YkU41RY0ZTrO/5rD+b3ZVFeYp+jJFTJ6DfGmf2wQPj267nNe6PyMJiPZVdkklyZzoewCKaUpJJclk16R3mRVFZinAIa5hhHmEkYPlx70dO1JmEuYqKwShC5Co9dwqfwSqeWpXCy7SGp5KpfKL5FZmdns64KnnWejADvcNZww1zDslO1f6SBJErWpqWgOHkJz6CDVh49gqqxstI/SxweHESOwHzkCh2HDUPn7t/s4Beurb7Nwbm821eUN53A9B3nTf3wgPj2cm3xfk0wmtPEJaPbtpfKXXxoHUTJZ4yBK9NVtRJIk0s8Wc2TzJQozzM9Lla2CAROCGDAxCFsHlZVH2LzOGEodOXKE4cOHs27dOubMmXPNfWUyGa+++qqlWkmj0eDo6Mi2bduYNm0ar7/+Ovv27WPHjoa2EFlZWQQFBZGUlERERASxsbEUFBRw/vx5y3PnlVdeYePGjcTHxwPmyq3Q0FA+/PBDAJ577jnOnj1LXFxck+PS6XQMGzaMF198kQcffJBffvmlXUIp8am5E5JMJnL/9CdMlZXY9u+Px8KF1h5Sy9Vqmql8Sqf58Mm96conBy+rrnYnk8sIH+JDz0HepBzP5+jmNMryqzn0Yyqnfs5k4JRg+o0LtPrKI51drdZA6slCLhzJIyuxlPoY3d5FTd+xAVZpoCkIN0MhVxDsHEywczATQxoaXeqMOlLLUhtNxUkpSyFPk0extpjivGKO5h1tdF+OKkdLUNXDpQehzqEEOwcT5BSErVI08xeEjsQkmcjT5JFekW75qg+h8qvzmz3OSeVEmGsY4W7hjab8utm6tePor00mk2HTsyc2PXvi/uADSAYD2vh4NAcOojl0iJoTJzDk51O+YQPlGzYAoPTzw37QIOwGD8J+8GBswsORyUV1c1dn76xm6G96MGhqCKknCzkTl0VeajnJR/NJPpqPi7cdkcN9iRjmg4NSh+bX/Wh+3UfVr/sxFhc33JFMhv2QIThNn4bz5Mkovbys90t1UPUrUB/ZlGpZ9Edpo6D/+EAGTgrG1rHjhlHNUarlPPHeOKs9dkvcaK1P//79LT87ODjg7OxMQUEBAKdPnyYuLg5HR8erjrt48SIREeb+aCNGjGgU5o4cOZJly5ZhNBpRKBQsXLiQRx99lHfeeQe5XM6qVat49913mx3T4sWLiY6O5sEHH7yh3+VWiVCqEyr93//QHDiIzNYW/3/9C5myA/4z6qqgKOmy1e6SzI3HyzKaP8YSPkWZv7zrvls5fLoeuVxGxFBfeg3yJvloPke3pFFeWMPBdRc5tTODQVND6DM2AJVahFMtZTSayDxfwoUjeVw6XYRB33C12K+nC/1iAwkb6CWm6Aldgo3ChmiPaKI9ohttv7yCIrUs1VJBkVGZQZW+ijNFZzhTdKbRMTJk+Dn4EeIcQrBzMKHOoYQ4hxDiHIK/oz9KeQd8vxCELkCSJIq1xWRUZJBekU5aRRoZFRmkVaSRWZmJzqhr9lgPWw96uvakh0sPwlzCCHMNo6dLTzztPDtdRaRMqcSuf3/s+vfH86knMWm11Jw4UVdJdQhtfDyG3FwqtmyhYssWAOROTtgNGoj9oMHYDx6Ebb9+3adHajekUMoJH+pD+FAfCtLNU/tSjhdQXmBujH5k0yWcKy7hm3cE78ITqPVVyO3tsR81EsfbxuA4YTwqb7ECdlMkSSIzoYQjmy5Z2lso1XL6xQYycHJwp+6zKpPJOvyF/vDwcGQyWYubmatUjcNBmUyGyWT+zFNVVcXMmTN58803rzrOz8+vxWOaOXMmNjY2rF+/HrVajV6v5+677252/927d3P27Fm+//57oCFo8/T05M9//jOvvfZaix/7Roiz005Gd+kSBW//HwDef/wjNmE9rDyguvDp8sqngkQov0b4ZO/ZOHSq/3Ls3Fc65Ao5kSP8CB/qQ9LhfI5tvURFkZb936dw4qcMokb4EjncF4+AqxNvwfyil3+pgguH80g+XoC2qqGJqquPPRHDfIgY5oOLl70VRykI7cdB5UBfz7709ezbaHutsdZSaZFanmquvCg3V19U6ivJ0eSQo8nhYO7BRscpZAr8HPwIcgoi0CnQ8j3Q0fyzo1q8NgnCteiNenI0OWRVZpFZmUlWZRZZVQ0/Vxuqmz1WKVcS5BRkDomdQhpNy+3KvePktrY4jBqFw6hRAJg0GmrOnqX6+HFqjh+n+tRpTJWVaPbsRbNnLwAylQrb3r2x7dcP2759sOvb19yXSjRP7zIkvR5tYhLKE8eJPHECv2MnyVP3IN9nKCVuUVQ496DCuQfJEfcSEKgkemIvfAf7igu8zdBq9KQcyyfhYB4FaeYwSqGS029cAAOnhIgZBe3E3d2dqVOn8sEHH/Dcc89ds9H59QwaNIgffviB0NBQlNcoQDl8+HCjPx86dIjw8HAUda+XSqWShx9+mC+++AK1Ws3cuXOxu8ZqqT/88AM1NQ39T48ePcqjjz7Kvn376NmzZ4vGfjNEKNWJSAYDOa+8gqTV4jBqJG7z7m+/B9dVQuEFc7WTZbW7pGuHTw5el4VOdVPuPCM7ffh0PXKFnOhRfkQM9yHpUB7HtqZRWazl5E8ZnPwpA88gRyKH+xI+1OeGmzt2NSaTREFaBennirlwNJ+KwoYXQTtnNRFDfIgY7oNXsFOnu1osCG1FrVBbeslcTpIkSnWl5iqN8jQyKhtXbOiMOrKqzB+iyb36fl1tXAl0DCTQKRA/Rz/8Hfzxd/THz8EPf0d/HFQOVx8kCF2I3qQnX5NPriaXnCpzuJtblUt2VTZZlVnkVec12+cJzJWK/o7+lurEy7/8HPxEpSIgd3DAYcQIHEaMAMznttrEJGpOHKf6+AmqTxzHWFhEzenT1Jw+3XCcvb05qOrbF9t+fbHr2xdVcLA4N+gkjFUaak6foub4CapPnKDm9Gmkyz74yoAAJy0Rfm4ohvuTax9FSryGwoxKsrKMZH2VhGp1CmEDvQgb4EVglBvqbr7qtVFvIv1cMUmH80g7W2RpIq9Qyuk7NoCBU4O7/ecMa/jggw8YPXo0w4YNY8mSJfTv3x+DwcDOnTv56KOPSEhIaNH9PPPMM3z66afcf//9vPTSS7i7u5OSksLq1av57LPPLKFTRkYGL7zwAk8++SQnTpzg/fffZ9myZY3u6/HHHyc62lyNv3///ms+7pXBU1FREQDR0dEtDtRuRvd+NncyxZ99hvb0GeROTvgtXdo28++1FQ0Nxy3T7hKhPLP5Yxy8L2s2flnlk0P3XvVCoZDTe7Q/kcN9ST/b8KZRlFlFUWYKB9ZdJCjancgRPvQY4NVtrv5oynVknC8hI76YzPgSdNUGy21KGwU9Y7yIGOZDYJQbcoWYnicILSWTyXC3dcfd1p2B3gMb3WaSTBRWF5orOqoaV3lkVWZRoi2hTFdGma6Mc8Xnmrx/Z7Vzo5DKz8EPXwdffOx98LH3wdPeE5W88/WpELoHSZIo05WRX51PQXUBeZo8S/hU/72wpvCaoROAndKOAMeAhmrDuiA3yCkIf0d/bBTiQ+CNkCmV2PXtg13fPrjPn48kSegzM6k5fQbtuXPUnDuHNj4eU3U11ceOUX3smOVYubMztn16YxsRiU1EODbh4dj06oXcXlRUW5NkNFKbno42IYGaU6epOX4cbWIimBo/t+TOztgPHIjd4MHYDxmMXf/+lpYkfsCg2VCap+HCkXySDudRWawl6VAeSYfykMtl+PZ0IbiPO8G9PfAMdEQm7/oBZf2sgqRDeSQfy290Dl1/0TtimK+ojLKisLAwTpw4wdKlS/nDH/5Abm4uXl5eDB48mI8++qjF9+Pv78/+/ft5+eWXmTJlCjqdjpCQEKZNm4b8sgygfmW+YcOGoVAo+N3vfscTTzzR6L7Cw8MZNWoUJSUlDB8+vNV+19YkVt/rJLTx8Vy69z4wGPB/81+43HHHLd5h+WWVT5f1farIav4YR5+r+z15RYG9+62NpRvRVulJOZ5P4qE8y1xvMK+E0XOQN5HDffEPd0Xehd5YjQYTeRfLyYgvJv18CcVZVY1ut7FXEhjlTliMpzmc6+DzxQWhK9LoNeaQqi6ourxKJEeTQ2Vt5XXvQ4YMDzsPfOx98Lb3NodVDuafve298bT1xNPOExcbF1HdILSqan01xTXFFGmLKKwupKC6gPzqfPOXxhxCFVQXUGuqve59qeVq/Bz9GoWvAY4BlumuHrYe4v9vO5OMRmpTU6k5e84cVJ0/hy4hEam26X9PVVCQOaCq/4oIxyY0FJlafFBvbSaNBm3SBXRJiWgTEtEmJaJLuoCk1V61ryogwNzcftAg7AYNwqZXrxZfYJckibzUClKO5ZMRX0JZfuOpsnbOaoJ7uxPcx52gaHfsHLvWv3V5YbU5nDuUR/llswocXNREDO+a7UGutaKbcGMkSSI8PJynn36aF154odXvvzVW3xOhVCdg0ulIu/tudMkpOE2eTMC/32v5CZG2/Ipm43V9nyqymz/G0dccOnlG1oVPdSveifCpVZXlV5N0JI8Lh/OoKGp481bbKvANc8Gvlwu+PV3x6eHcqaqotFV6CjMrKcyoJC+1nKzEUvQ6Y8MOMvAOdiK4jwfBfTzwCXUSFVGC0MFV1VaRq8m9alpTfdVJfnU+BpPh+neEubeOh60Hnnaeli8PO/OfPWw9cLN1w93WHTdbN1zULijknef1T2gdkiSh0Wso1ZZSqiulVFtKsbaYopoiy1dxTcOfr9XL6Urutu6W4NQSPF02XdXd1h25TLwndXRSbS26lBS08fHokpPRJSejvZCMsW6qyVWUStSBgahCglEHBaMODkYdEowqKBh1YIAIrK7DWFlJbUYG+owMatPS0CYmoU1MQJ+RCU18lJTZ2WETEY5dn77mKqhBg1D5+rbaeMoLa8g4X0xGfAlZSaUYrjzPDHEmIMIVr2AnvEOccPa06zRhsmSSKMnVkHuxnNyUMnIvllNZ3PA5QWmjoOdALyKH+xIQ6dalLmRfToRSraOwsJDVq1ezePFiMjMzcXNr/dVbO3QotXTpUrZs2cKpU6dQq9WUlZVd9xhJkvjb3/7Gp59+SllZGaNHj+ajjz4iPDz8usfW64qhVP5bb1OyYgUKDw/CNm1E6d5EOFRT1rDC3eUhVGVO83fs5NdE5VMk2HWcpYa7A0mSyL1YTtLhPC4eL2hUigvm1f08g53w6+WCX08X/Hq6dpiy3OqKWgozKht9VZZcfXXMzklFUG9ziXVwb/dOvfqHIAhXM0kmSrWlDSGVJr9RYFUfHpTpym7ofmXIcLFxwc3WDTcbN9xs3XC1ccXd1h0XGxec1c442zibv6udLdvslJ3nA0hXpzfqKa8tp6K2ggpdBRW1FZTr6v5cW0GZtoxSbSkluhLLz6W6UvQm/fXv/DJ2SjtLyFlfqXdVxZ6dNyqFmGLalRlKStAlp1iCKt2FC+iSkzFVVTV/kFyOys8PVXAQ6uAQVIEBqHx8UHr7oPTxRuXtjdyha/fUkyQJY2kptenp5uApI5PajAxqM9LRZ2RiLC1t9liltzc20VHYRkZhGx2FTWQU6pDgdmtMb9SbyL1YZmkNUZytuWoftZ0SryBHPIOd8A52wivYCRdv+w4R6Bj0RgrSKsm9WEZuSjl5qeVXfRaQySAwyo3IEX6ExXSPWQUilGodMpkMT09P3nvvPebNm9cmj9GhQ6m//e1vuLq6kpWVxeeff96iUOrNN9/kjTfe4KuvvqJHjx785S9/4ezZs8THx7f4P2NXC6Wqjx4lff7DIEkEfvgBTiMHXlH5VB8+NdG1tp6TfxM9nyLBzrXdfg+hZUwmiZKcKnJTGq6OVJVevYy0i7cdXsFOOLnZ4uBmg5ObLY7uNji62WLnqGq1efUGvZHq8lo0ZTqqynSWn0vzqynMqERT1vQS185edngFma9OBUa54RXk1C3m+guCcG16o55ibXGjKhdL5UtdJUyptpQSbQkVtRXXv8NmKOVKS1DlrHbGQeVg+XJUO2KvtMdR7YijyrHRbfZKe2yVttgqbbFT2mGrMP/cnSpnJElCb9JTY6ihxlCD1qA1fzdq0eg1lq+q2qqGn/VVlu/V+mpL4FRZW0mNoeb6D9oMO6WdJYx0s3XDy86rUWVd/ZeXnRf2KtFHSGiaJEkY8vKoTU+nNj0DfWYGtekZdaFLRqOG282ROzqi9PFB5eON0ssbpY8PSm9vFK6uKFycUbi4oHB2Ru7igsLJydIbyZokSUKqrcVYXIyhqMj8VViEobAQQ1EhhqIijJY/FzU7HbKewtPTXGEWFIRNZCS2UZHYREU1fbHciqpKtWTEl1CQVkFhRiVF2VWYDFd/3FXaKPAKcsQjwBFHNxscXGxwcK3/rkZtp2y1ixu1WgNVJTqqSrVUlTZ8L83TUJBRedX4lDYKfHs4my9G9zLPmlDbWv//VHsSoVTn0aFDqXpffvklzz///HVDKUmS8Pf35w9/+AN//OMfASgvL8fHx4cvv/ySuXPntujxulIoZUw7waWHnkZfWI7LAGf8h5ZBVV7zBzj5N+715B0NnhEifOrkKku05oAqpZzci2UU52jgGs9auVKGo6s5oHJ0s8HeWY1ccf03VckENRo91WU6NOXmEEqnuc50HBm4+djjGWS+6uQV7IRXkCM29uJKtCAIt8ZgMlCmM1fOlOnKzM3YtWWU6Eoo1ZY2qrapr8Cp0FVgkFo2jfBG1IdT9WGVjcIGlVyFSq5CrVCbv+RqVAoVarn5z/W3K+QKFDIFcpnc8nP91+XbZLTgdRoJk2TCJJkwSkbzl8n83SSZMJgMltsMJgN6k55aYy21plpqjbXojXrztro/1xprLQHU5eHT9Zp93wwntVNDUHhZdZu7rTuuNq6WaZuutq6425i/2ymbX7ZaEFqDJEkYi4rMAVV6XWVQTg6GgkIM+fkY8vMxVbd8emg9uaOjOaRydUHh7ILczg6ZjQ0ytQq5jQ0yldr8Zxs1MrXasg2lAkwSmIxIRhOYTEgm49XbjEZMGk0TX1UYNRpMmmpMGg0Ybuz1UOnnZw6egoMtlWPqkGBUgUEoHDtntZjRaKI0V0NBeiVFGZUUZlZSlFmFQX/t1zmlWn5ZUKXG3sUGhbIFr9MS6KoNDQFUiZZarfGax9g7q+tmRLji18sFz0DHbt/aoj7oCA0Nxc5OvBd0ZDU1NaSlpd1SKNVhItdLly6Rl5fHpEmTLNtcXFwYPnw4Bw8ebDaU0ul06HQN1RoVFTd/ZbWjKfjHX9AXlqOyN+DTKwmq6pII58DLKp8i63o+RYCti3UHLLQJJ3dbnIaZV9MA0Gr05KWWU5ZfbbnqUlmqQ1OqRVNRi8kgUVGkbdSn6lYolHIcXNUNV49cbHDytMUr2AnPQMdud+VGEIT2oZQrLZUwLSVJEjWGmkZTxCprK6+q6GlU7WPQoKk136Y1ai3hjM7YcG6hNWrRGrXQdHFol6WUK7FT2JmDOKVNQ7WZyhF7lT2OKsdGP19ejeaibphe6ahyFL3BhA5JJpOh9PJC6eWF/eDBTe5jrNJgKDAHVIaCAvT5BeafCwsxlpdjrKjAVF6OsbzcHAQBpqoq85TBnGu00WgvKhVKT8+GLy+vuu+eKDw9UXl5ofD0Qunlidym660eqVDI8Qx0wjPQCUabt5mMJkrzqynKqKQkr9pyQVZTNyNAV23AUGuivLCmUWPxW2FjrzRXZLmaZzc4udng5GGHb5gLzp62Ysr5FRR10z9ra2tFKNXBVdcF9yrVzRcldJhPk3l55gogHx+fRtt9fHwstzXljTfe4LXXXmvTsVmL6+zbqU76BN/7x6AYOaah8sm2c1eACbfG1kFFaD9P6Hf1bUajyTzV7rLS4JqK2msVVjW+b3uVOXxyVVuuDtnYt175siAIQluSyWTYq+yxV9nj63BrTXVNkqlR9VD9zzWGGkuVUa3JXGmkNzauSKo1NVQl1VcxNVXRZJAMlttu5HdUypTI5fKGqit54+orpVyJQqawVHFdr6rLVmmLrcK20fRFW6UtKrmoehUEhaMDCscwbMLCrruvpNdjrKw0B1R1gZWxvAKTtgZJV4uk0yHpazHpdEi1tQ3bamsx1erAYASFwtzyQK5AppCDTA4KuXmluvptcgVye3vkDg7IHR3M3x0cUDg6Wn62fDk6ivO4K8gVcjz8HfHwb3rFOn2tkepyHZqyWnNYVdfCwtTCCUZqW3MAZf4yz1wQF3FvjFKpxN7ensLCQlQqFfIWrtQotB9JkqiurqagoABXV1dLkHgzbujZ8corr/Dmm29ec5+EhASioqJuekA3avHixY2WNqyoqCAoKKjdHr8t2c1cRNiMJ9qtUaDQ+SkUcpw97HD2EFcUBEEQboVcJrcEXIIgCC0hU6lQurt3uD5Lwo1RqRW4eNnj4iVe/61FJpPh5+fHpUuXSE9Pt/ZwhGtwdXXF9xZX17yhUOoPf/gDCxYsuOY+YS24itCU+l8kPz8fPz8/y/b8/HxiYmKaPc7GxgabLlhqWk8EUoIgCIIgCIIgCEJ3olarCQ8Pp/Y6TfgF61GpVLdUIVXvhkIpLy8vvLy8bvlBm9KjRw98fX3ZtWuXJYSqqKjg8OHDLFq0qE0eUxAEQRAEQRAEQRCEjkcul4vV97qBNpucmZGRwalTp8jIyMBoNHLq1ClOnTpFVVWVZZ+oqCjWr18PmEv0nn/+eV5//XU2btzI2bNnmT9/Pv7+/syePbuthikIgiAIgiAIgiAIgiBYQZt1XPvrX//KV199ZfnzwIEDAYiLiyM2NhaApKQkysvLLfu89NJLaDQannjiCcrKyrjtttvYvn27SEcFQRAEQRAEQRAEQRC6GJkktXAZgU6ioqICFxcXysvLcXYWq9QJgiAIgiAIgiAIgiC0p5ZmM11ubcr6jK2iosLKIxEEQRAEQRAEQRAEQeh+6jOZ69VBdblQqrKyEoCgoCArj0QQBEEQBEEQBEEQBKH7qqysxMXFpdnbu9z0PZPJRE5ODk5OTshkMmsP55ZVVFQQFBREZmammI4oCC0knjeCcHPEc0cQbo547gjCzRHPHUG4OZ3huSNJEpWVlfj7+yOXN7/GXperlJLL5QQGBlp7GK3O2dm5w/5nE4SOSjxvBOHmiOeOINwc8dwRhJsjnjuCcHM6+nPnWhVS9ZqPqwRBEARBEARBEARBEAShjYhQShAEQRAEQRAEQRAEQWh3IpTq4GxsbPjb3/6GjY2NtYciCJ2GeN4Iws0Rzx1BuDniuSMIN0c8dwTh5nSl506Xa3QuCIIgCIIgCIIgCIIgdHyiUkoQBEEQBEEQBEEQBEFodyKUEgRBEARBEARBEARBENqdCKUEQRAEQRAEQRAEQRCEdidCKUEQBEEQBEEQBEEQBKHdiVBKEARBEARBEARBEARBaHcilOrAPvjgA0JDQ7G1tWX48OEcOXLE2kMShA7ljTfeYOjQoTg5OeHt7c3s2bNJSkpqtI9Wq+WZZ57Bw8MDR0dH7rrrLvLz8600YkHoeP71r38hk8l4/vnnLdvE80YQmpadnc2DDz6Ih4cHdnZ29OvXj2PHjllulySJv/71r/j5+WFnZ8ekSZNITk624ogFwfqMRiN/+ctf6NGjB3Z2dvTs2ZN//OMfXL4IvHjuCILZ3r17mTlzJv7+/shkMn788cdGt7fkuVJSUsIDDzyAs7Mzrq6uPPbYY1RVVbXjb3FjRCjVQa1Zs4YXXniBv/3tb5w4cYIBAwYwdepUCgoKrD00Qegw9uzZwzPPPMOhQ4fYuXMner2eKVOmoNFoLPv8/ve/Z9OmTXz33Xfs2bOHnJwc7rzzTiuOWhA6jqNHj/LJJ5/Qv3//RtvF80YQrlZaWsro0aNRqVRs27aN+Ph4li1bhpubm2Wft956i3//+998/PHHHD58GAcHB6ZOnYpWq7XiyAXBut58800++ugj/vOf/5CQkMCbb77JW2+9xfvvv2/ZRzx3BMFMo9EwYMAAPvjggyZvb8lz5YEHHuD8+fPs3LmTzZs3s3fvXp544on2+hVunCR0SMOGDZOeeeb/2bvP8Liqc//736nqvXe59y65V2xJIYQAOTkBU2zTq03JkxjIn4QkdDiE0A2c2JSYOMmhJECQ5N5tuXcbY3VZvWs00pT9vNijLY0lg7EtjyTfn+uaC7z3Gs0aW9N+c6973a/92eFwKLGxscqzzz7rwVkJ0bOVl5crgLJhwwZFURSltrZWMZlMyj/+8Q9tzNGjRxVA2bZtm6emKUSP0NDQoAwaNEjJzs5WZs2apTz44IOKosjjRoizWbp0qTJ9+vSznnc6nUp0dLTy4osvasdqa2sVLy8v5eOPP74UUxSiR7rqqquU2267ze3Yz372M+Wmm25SFEUeO0KcDaB8+umn2p/P5bFy5MgRBVBycnK0Mf/5z38UnU6nFBcXX7K5/xBSKdUDtba2snv3bubNm6cd0+v1zJs3j23btnlwZkL0bHV1dQCEhoYCsHv3bmw2m9tjaejQoSQmJspjSVz27r//fq666iq3xwfI40aIs/nXv/5FSkoK//3f/01kZCTjxo3j3Xff1c7n5uZSWlrq9tgJCgpi0qRJ8tgRl7WpU6eyZs0aTpw4AcD+/fvZvHkzV155JSCPHSHO1bk8VrZt20ZwcDApKSnamHnz5qHX69mxY8cln/O5MHp6AqKzyspKHA4HUVFRbsejoqI4duyYh2YlRM/mdDp56KGHmDZtGiNHjgSgtLQUs9lMcHCw29ioqChKS0s9MEsheoa//e1v7Nmzh5ycnE7n5HEjRNdOnTrFW2+9xSOPPMLjjz9OTk4OS5YswWw2s3DhQu3x0dX7N3nsiMvZo48+Sn19PUOHDsVgMOBwOHj66ae56aabAOSxI8Q5OpfHSmlpKZGRkW7njUYjoaGhPfbxJKGUEKJPuP/++zl06BCbN2/29FSE6NEKCwt58MEHyc7Oxtvb29PTEaLXcDqdpKSk8MwzzwAwbtw4Dh06xNtvv83ChQs9PDsheq6///3v/PWvf2XlypWMGDGCffv28dBDDxEbGyuPHSGENDrvicLDwzEYDJ12OiorKyM6OtpDsxKi53rggQf44osvWLduHfHx8drx6OhoWltbqa2tdRsvjyVxOdu9ezfl5eWMHz8eo9GI0Whkw4YNvPrqqxiNRqKiouRxI0QXYmJiGD58uNuxYcOGUVBQAKA9PuT9mxDufvWrX/Hoo49yww03MGrUKG655RYefvhhnn32WUAeO0Kcq3N5rERHR3faHM1ut1NdXd1jH08SSvVAZrOZCRMmsGbNGu2Y0+lkzZo1TJkyxYMzE6JnURSFBx54gE8//ZS1a9fSr18/t/MTJkzAZDK5PZaOHz9OQUGBPJbEZWvu3LkcPHiQffv2aZeUlBRuuukm7f/lcSNEZ9OmTeP48eNux06cOEFSUhIA/fr1Izo62u2xU19fz44dO+SxIy5rFosFvd79Y6fBYMDpdALy2BHiXJ3LY2XKlCnU1taye/dubczatWtxOp1MmjTpks/5XMjyvR7qkUceYeHChaSkpDBx4kReeeUVmpqauPXWWz09NSF6jPvvv5+VK1fy+eefExAQoK2TDgoKwsfHh6CgIG6//XYeeeQRQkNDCQwMZPHixUyZMoXJkyd7ePZCeEZAQIDWd62Nn58fYWFh2nF53AjR2cMPP8zUqVN55pln+MUvfsHOnTt55513eOeddwDQ6XQ89NBDPPXUUwwaNIh+/frxxBNPEBsby7XXXuvZyQvhQVdffTVPP/00iYmJjBgxgr179/Lyyy9z2223AfLYEaKjxsZGTp48qf05NzeXffv2ERoaSmJi4vc+VoYNG8aPfvQj7rzzTt5++21sNhsPPPAAN9xwA7GxsR66V9/D09v/ibN77bXXlMTERMVsNisTJ05Utm/f7ukpCdGjAF1eli9fro1pbm5W7rvvPiUkJETx9fVVrrvuOuX06dOem7QQPdCsWbOUBx98UPuzPG6E6Nq///1vZeTIkYqXl5cydOhQ5Z133nE773Q6lSeeeEKJiopSvLy8lLlz5yrHjx/30GyF6Bnq6+uVBx98UElMTFS8vb2V/v37K7/5zW+UlpYWbYw8doRQrVu3rsvPNwsXLlQU5dweK1VVVcr8+fMVf39/JTAwULn11luVhoYGD9ybc6NTFEXxUB4mhBBCCCGEEEIIIS5T0lNKCCGEEEIIIYQQQlxyEkoJIYQQQgghhBBCiEtOQikhhBBCCCGEEEIIcclJKCWEEEIIIYQQQgghLjkJpYQQQgghhBBCCCHEJSehlBBCCCGEEEIIIYS45CSUEkIIIYQQQgghhBCXnIRSQgghhBBCCCGEEOKSk1BKCCGEEEIIIYQQQlxyEkoJIYQQQgghhBBCiEtOQikhhBBCCCGEEEIIcclJKCWEEEIIIYQQQgghLjkJpYQQQgghhBBCCCHEJSehlBBCCCGEEEIIIYS45CSUEkIIIYQQQgghhBCXnIRSQgghhBBCCCGEEOKSk1BKCCGEEEIIIYQQQlxyEkoJIYQQQgg3ixYtIjk52dPTEEIIIUQfJ6GUEEIIIS4rK1asQKfTaRdvb28GDx7MAw88QFlZGQA7d+5Ep9Pxpz/9qdP1r7nmGnQ6HcuXL+90bubMmcTFxQHgdDpZsWIFP/3pT0lISMDPz4+RI0fy1FNPYbVaz2muycnJneY6aNAgfvWrX1FdXX0BfwtCCCGEEJ6nUxRF8fQkhBBCCCEulRUrVnDrrbfyhz/8gX79+mG1Wtm8eTMffvghSUlJHDp0CLPZTFBQED/60Y/4v//7P7frR0REUFtby8KFC3nvvfe0462trQQFBXH11Vfz97//ncbGRgICApg8eTI/+clPiIyMZNu2bbz//vvMnDmTtWvXotPpvnOuycnJhISE8Mtf/hIAq9XK7t27ee+99xg3bhw7d+68+H9BgM1mw+l04uXl1S0/XwghhBACwOjpCQghhBBCeMKVV15JSkoKAHfccQdhYWG8/PLLfP7558yfP59JkyaxZcsWt+scP36cyspKbrzxRjZv3ux2bvfu3VitVqZPnw6A2Wxmy5YtTJ06VRtz5513kpyczO9+9zvWrFnDvHnzvneecXFx3Hzzzdqf77jjDvz9/XnppZf45ptvGDRo0Hn/HZyNyWS66D9TCCGEEOJMsnxPCCGEEAK44oorAMjNzQVg+vTplJWVcfLkSW3Mli1bCAwM5K677tICqo7n2q4HaijVMZBqc9111wFw9OjR855rdHQ0AEZj+/eLBw4cYNGiRfTv3x9vb2+io6O57bbbqKqqcrtuQ0MDDz30EMnJyXh5eREZGUlaWhp79uzRxnTVU+pvf/sbEyZMICAggMDAQEaNGsWf//zn874PQgghhBBSKSWEEEIIAXz77bcAhIWFAe3h0ubNmxk4cCCgBk+TJ09m0qRJmEwmtm7dyk9/+lPtXEBAAGPGjPnO2yktLQUgPDz8nOZls9m08MtqtbJ3715efvllZs6cSb9+/bRx2dnZnDp1iltvvZXo6GgOHz7MO++8w+HDh9m+fbu2VPCee+7hn//8Jw888ADDhw+nqqqKzZs3c/ToUcaPH9/lHLKzs5k/fz5z587l+eefB9RQbcuWLTz44IPndD+EEEIIIc4koZQQQgghLkt1dXVUVlZitVrZsmULf/jDH/Dx8eEnP/kJAFOmTMFgMLB582YWLVoEqMHTjTfeiLe3N+PGjWPz5s1uodTkyZMxGAzfebsvvPACgYGBXHnllec0z6ysLCIiItyOTZs2jU8++cTt2H333af1nmozefJk5s+fz+bNm5kxYwYAX375JXfeeSf/8z//o4379a9//Z1z+PLLLwkMDCQzM/N7758QQgghxLmS5XtCCCGEuCzNmzePiIgIEhISuOGGG/D39+fTTz/Vds8LCAhg9OjRWu+oyspKjh8/ri3JmzZtmrZk78SJE1RUVGjVVWfzzDPPsHr1ap577jmCg4PPaZ6TJk0iOzub7OxsvvjiC55++mkOHz7MT3/6U5qbm7VxPj4+2v9brVYqKyuZPHkygNvSvODgYHbs2EFJSck53X7bdZqamsjOzj7n6wghhBBCfB8JpYQQQghxWXrjjTfIzs5m3bp1HDlyhFOnTpGRkeE2Zvr06VrvqK1bt2IwGLSgZ+rUqezevZuWlpZO/aS6smrVKv7f//t/3H777dx7773nPM/w8HDmzZvHvHnzuOqqq3j88cd577332Lp1q9vuf9XV1Tz44INERUXh4+NDRESEtryvrq5OG/fCCy9w6NAhEhISmDhxIk8++SSnTp36zjncd999DB48mCuvvJL4+Hhuu+02vv7663O+D0IIIYQQXZFQSgghhBCXpYkTJzJv3jxmz57NsGHD0Os7vy1qC5m2bNnCli1bGDVqFP7+/oAaSrW0tJCTk8PmzZsxGo1aYHWm7OxsFixYwFVXXcXbb799wXOfO3cuABs3btSO/eIXv+Ddd9/lnnvu4ZNPPiErK0sLjpxOp9u4U6dO8dprrxEbG8uLL77IiBEj+M9//nPW24uMjGTfvn3861//4qc//Snr1q3jyiuvZOHChRd8X4QQQghx+ZJQSgghhBDiLDo2O9+yZQvTpk3TzsXGxpKUlKQFVuPGjcPX17fTz9ixYwfXXXcdKSkp/P3vf3fbMe982e12ABobGwGoqalhzZo1PProo/z+97/nuuuuIy0tjf79+3d5/ZiYGO677z4+++wzcnNzCQsL4+mnn/7O2zSbzVx99dW8+eabfPvtt9x999188MEHbrsTCiGEEEL8EBJKCSGEEEKcRWxsLP369WPNmjXs2rVL6yfVZurUqXz22WccP368y6V7R48e5aqrriI5OZkvvvjCre/Thfj3v/8NoO3019Z8XFEUt3GvvPKK258dDofbUj5Qq6BiY2NpaWk56+1VVVW5/Vmv1zN69GiA77yeEEIIIcR3kd33hBBCCCG+w/Tp0/nwww8B3CqlQA2lPv74Y21cRw0NDWRkZFBTU8OvfvUrvvzyS7fzAwYMYMqUKd97+8XFxXz00UcAtLa2sn//fpYtW0Z4eDiLFy8GIDAwkJkzZ/LCCy9gs9mIi4sjKyuL3NzcTnOKj4/n5z//OWPGjMHf35/Vq1eTk5Pjthvfme644w6qq6u54ooriI+PJz8/n9dee42xY8cybNiw770PQgghhBBdkVBKCCGEEOI7tIVScXFxJCUluZ3rGFKdGUpVVVVRWFgIwKOPPtrp5y5cuPCcQql9+/Zxyy23AGqFUnh4OD/72c/44x//qO0UCLBy5UoWL17MG2+8gaIopKen85///IfY2FhtjK+vL/fddx9ZWVl88sknOJ1OBg4cyJtvvvmdzddvvvlm3nnnHd58801qa2uJjo7m+uuv58knn+yyF5cQQgghxLnQKWfWeQshhBBCCCGEEEII0c3kqy0hhBBCCCGEEEIIcclJKCWEEEIIIYQQQgghLjkJpYQQQgghhBBCCCHEJSehlBBCCCGEEEIIIYS45CSUEkIIIYQQQgghhBCXnNHTE7jYnE4nJSUlBAQEoNPpPD0dIYQQQgghhBBCiMuKoig0NDQQGxuLXn/2eqg+F0qVlJSQkJDg6WkIIYQQQgghhBBCXNYKCwuJj48/6/k+F0oFBAQA6h0PDAz08GyEEEIIIYQQQgghLi/19fUkJCRoGc3Z9LlQqm3JXmBgoIRSQgghhBBCCCGEEB7yfW2VpNG5EEIIIYQQQgghhLjkJJQSQgghhBBCCCGEEJdct4ZSGzdu5OqrryY2NhadTsdnn332vddZv34948ePx8vLi4EDB7JixYrunKIQQgghhBBCCCGE8IBu7SnV1NTEmDFjuO222/jZz372veNzc3O56qqruOeee/jrX//KmjVruOOOO4iJiSEjI6M7pyqEEEIIIYQQQohezuFwYLPZPD2NPs9kMmEwGC7453RrKHXllVdy5ZVXnvP4t99+m379+vE///M/AAwbNozNmzfzpz/9SUIpIXqIwmoLBdUWhscEEuJn9vR0hPhhyg5DSyPEjgOj/P6K3sPmtHGw4iCB5kAGBA/43qahQvQkjtparEeP4jVwIMaICE9PRwgcNidVJY3YbU5iBgTJc2ofoSgKpaWl1NbWenoql43g4GCio6Mv6DHUo3bf27ZtG/PmzXM7lpGRwUMPPXTW67S0tNDS0qL9ub6+vrumJ8Rlb09BDQv+dyeNLXYA4oJ9GBUXxMi4QEbGBTEqLogwfy8Pz1KILhTsgPXPwql16p+NPpAwEZJnQPI0iJsARvndFT2LzWFj2+ltZOdns7ZgLfWt6nuc/kH9yUjOICM5gwHBAzw8SyE6s1dVYcnZhSUnB0tODi0nTgCg8/IiZP58wu68A2NYmIdnKS4X9lYHlcWNVBY0UF7QQEVBA9XFTTidCgApVyUz6er+Hp6luBjaAqnIyEh8fX0lbOxGiqJgsVgoLy8HICYm5rx/Vo8KpUpLS4mKinI7FhUVRX19Pc3Nzfj4+HS6zrPPPsvvf//7SzVFIS5bB4vqWPgXNZAK9DZSb7VTXNtMcW0zXx8u1cbFBHkzMi6IkbFBjIpXw6rIAG8Pzlxc1gq2u8Ko9eqf9UbwCoTmasjdoF4AjN7tIVXSNIhPkZBKeESLo4VtJWoQta5gHQ22Bu1csFcwTbYmTtWd4q39b/HW/rcYGDyQ9OR0MpIz6B8kH6qEZ9jKyrUAypKTQ+upU53GGCLCcVRUUr1iBTV//zuhN99M2G23YggOvvQTFn2WrdVBVVEj5fkNVBTUU1HQSPXpJhRXANWRl6+RFoudXV/mYTDoSflx8qWfsLhoHA6HFkiFSeh9SbTlM+Xl5URGRp73Ur4eFUqdj8cee4xHHnlE+3N9fT0JCQkenJEQfc+Rknpu/t8dNFjtTEwOZcVtqdidCoeL6zlUXMehkjoOFteRW9nE6Torp+usZB8p064fFejFyNggrZpqVHwQkQFe8u2F6D7522DDc+5h1NgbYcYvITgJKo5B3ub2i6UScjeqF1BDqvjUDpVUKWCScFV0D6vdypaSLWTnZ7O+cD1NtibtXIRPBPOS5pGWlMb4yPFY7BbWF64nMy+TLSVbOFl7kpP7TvLmvjcZFDKIjKQM0pPT6RfUz2P3R/R9tuJimnJysOxSq6Fs+QWdxngNHoxvaqrrkoIhNJSmzZupeOXPWA8fpuqdd6hZuZLQRYsIXbgAQ0CAB+6J6M1arXYqixqpcFU/VRQ0UHO6CaVz/oRPgImIxAAiEgOITAwkPNGfgFBv9mYVsO3Tb9nxr1MYjHrGpSde+jsiLoq2HlK+vr4ensnlpe3v22aznXcopVOUrh62F59Op+PTTz/l2muvPeuYmTNnMn78eF555RXt2PLly3nooYeoq6s7p9upr68nKCiIuro6AgMDL3DWQogTZQ3c8M52qptaGZcYzIe3T8Lfq+s8u7HFzpGSeg4W13GoWA2qTlU00sWXU4T7ezEqLtC1/E+9xAR5S1AlLkz+Vlj/XHsFlN4IY29Sw6iQpK6voyhQeQLyNrWHVE0V7mMMXq5KqunqRUIqcYEsNgubizeTnZ/NhqINNNubtXORvpGkJ6WTlpTG2Mix6HVdb5Zc31rPuoJ1ZOVnsbVkK3anXTs3OGSwtsQvKfAsv/tCnANFUbAVFKgB1E61EspWUuI+SK/He+hQNYCamIrP+PEYQ0LO+vMa166l4s+vasv69EFBhN1+O6E334RePlCKLrRa7VQWNqgVUIUNVOQ3UFNmgS7eY/oGmrUAKiIxgMikAPyCz/5laM6Xuez8dy4A038xiDFXSIFDb2S1WsnNzaVfv354e8t7tEvlu/7ezzWb6VGh1NKlS/nqq684ePCgduzGG2+kurqar7/++pxuR0IpIS6ebysauX7ZdiobWxgVF8RHd0wiyMf0g36GpbU9qDpYXMfh4nq+KW/oMqgK8zO7Aqr2sCou2EeCKvH98reqy/TaKp30Jhh3E0x/5Oxh1NloIVWHSqqmcvcxBi9XJZUrpIpPlZBKfK8mWxMbizaSnZ/NpqJNWB1W7VyMXwxpSWmkJ6czKnzUWYOos6lrqWNd4Toy8zLZXrIdu9IeUA0NHUpGcgbpSekkBkoVgPhuiqLQmpurBVCWXbuwl5W5DzIY8B45At+UFDWImjDhB1c6KU4nDZmZVLz2urbczxAaSthddxJyww3o5UPlZaul2e5W/VRR0EBtedcBlF+QmYikQFcFlBpC+QX/8OX32z//lt3/yQdg1o1DGDkz7kLvhrjEJJTyjB4fSjU2NnLy5EkAxo0bx8svv8ycOXMIDQ0lMTGRxx57jOLiYj744AMAcnNzGTlyJPfffz+33XYba9euZcmSJXz55ZfnvPuehFJCXBz5VU38Ytk2yupbGBYTyMd3TiLY9+LsVtbc6uDI6XoOl9RxsEgNq74pb8TRRVIV4mtiZFwQI2JdS//igkgIlaBKuORtViuj8japf9abYNzNMOMRCL5IH74VBapOuldSNZ75Ac3cRUjVuQ+iuPw0tDawoWgD2XnZbCnZQoujfXOWeP940pLTSEtMY2T4yIv2vFbXUsfagrVqQHV6Ow7FoZ0bFjpMDaiS00kIkGoAoYZDLd+cbO8JtWsXjqoq90EmEz6jRrUvxxs3Fr2f38W5fYeD+i++oOL1N7AVFgJgjIwk7J67Cf75z9GbZafUvszaZNMqn9oCqLqK5i7H+od4uVVARSQG4Bd0cfo/KorC1k++ZV+2uhT1igVDGTY19qL8bHFpSCjlGT0+lFq/fj1z5szpdHzhwoWsWLGCRYsWkZeXx/r1692u8/DDD3PkyBHi4+N54oknWLRo0TnfpoRSQly4ohoL1y/bTnFtM4Oj/Pn4zsndvque1ebgWGmDuvSvSO1TdaKsAZuj81NUoLdR60/VtvQvKdQXvV6CqstG7ibY8Lx7GDX+FrUyKribP2hrIdVmV1C1BRpL3ccYzOoSv7aQKmGihFSXkbqWOtYXric7P5utJVuxOW3aucSARNKT00lPSmdo6NBuD9hrrbWsKVhDZl4mO0t3ugVUw8OGaxVU8QHx3ToP0XMoDgfWY8do3rWLppwcmnftxnHG9uk6Ly98xozRQiifMaPRd7Hh0EWdl81G7WefUfnmW9hPnwbAFBtL+H33EnTNNehMP6xSW/Q81kYb5QX1bhVQ9ZXWLscGhHoTkdQhgEoIwDewewNKRVHY/PdvOLCuCHQwb9FwhkyK7tbbFBePhFKe0eNDKU+QUEqIC3O6rplfLNtGYXUz/cP9+Nvdkz22e16L3cGJ0kZt6d+h4jqOlzbQ6nB2GhvgZWTEGT2q+oX5SVDV1+RuUiuj8jerfzaYYdwtMP3h7g+jzkZRoOpbdU5tlVQNp93HGMwQN6FDJdVEMEvflL6k1lqrLp/Lz2RHyQ635XP9gvppPaIGhwz2WKVntbWaNQVryMrLYmfpTpxK+3PpyLCRWgVVrL9UB/Qlis2G9ehRtQpqZw6WPXtwNjS4jdH5+OA7bhy+E1PxTUnBe/Roj1UoOVtbqf3HP6h6exn2CrW/nykpkYj77yfwqqvQnWcjXXFpNTe0Ul7gXgHVUN11ABUY7k1EYiARif5EJqpL8bz9PRNCKorCho9PcHhjMTodpN8xkoETIj0yF/HD9NZQatGiRbz//vsAmEwmEhMTWbBgAY8//jhWq5WQkBA+/PBDbrjhBu06N9xwA6tWrSI3N5fk5GTteHJyMrfccgt//OMfeffdd/nggw84dOgQABMmTOCZZ55h4sSJ3zmf9evX88gjj3D48GESEhL4f//v/31nkZCEUl2QUEqI81deb+X6d7aTW9lEUpgvq+6aQnRQz3pSb7U7OVHW0GHXv3qOnq6n1d45qPL3MjI8NpCRsUGMilcDq37h/hgkqOpdFEWtSFr/HORvUY8ZzDB+gRpGBfWwCg9FgepT7j2pGs5sCmxyD6kSJklI1QtVNVextnAt2XnZnaqQBgYPVHtEJaUzMGSgB2fZtarmKi2gyinLcQuoRoWP0iqoYvxjPDhLcT6cra1YDx1q7wm1dy+KxeI2Ru/nh8+E8fimpuKXmor3iBE9rhLJabVS8/HfqHr3XRzV1QCYBwwgYvFiAtLT0Ol/WN810X2a6lo69YBqrGnpcmxQpE+HXfACCE8IwNuvZ/3uKU6FdR8d4+jW0+j1OjLuGkn/sRGenpb4Hr05lCorK2P58uW0tLTw1Vdfcf/99/P000/z2GOPMWXKFMaMGcPbb7+tXSc6Ohqz2cwf/vAHLTDKzc2lf//+rF27ljlz5nDTTTcxbdo0pk6dire3N88//zyffvophw8fJi6u655pbe2U7rnnHu644w7WrFnDQw899J3tlCSU6oKEUkKcn8rGFm54ZzsnyxuJD/Fh1d1TiAvuHcuNbA4n35Q1cqikfde/IyX1tHQRVPmaDQyPCdSqqUbFBTEgwg+jQd7c9jiKojYuX/8cFGxVjxnMMH6hK4zqJU1IO4ZU+VvU/9YXu49xC6mmuUKqi9OvRVxclc2VrMlfQ3Z+dqcwZ0jIENKT05mXNI/+Qf09OMsfpu0+ZeZnsqt0F0qHbsKjI0aTkaRWUEX7yTKWnshptdK8/4DWE6p53z6UFvdAQB8UhO+ECdpyPO+hQ9AZu95Jt6dxNjVR/dFfqfrLX3C6duP2GjqUiCVL8J8zW3pMXkKKotBU2+rqAdW+DK+prrXzYB0ER/q6B1CJAXj59JLfO6fCmvePcGJHGXqDjivvGUXyqHBPT0t8hzPDEUVRaLY5vv+K3cDHZDjn56ZFixZRW1vLZ599ph1LT0+noaGBbdu28fjjj/PJJ59w7NgxAI4ePcqUKVNYunQpx48fZ8WKFQAsX76ce++9l9ra2i5DOYfDQUhICK+//joLFizoci5Lly7lyy+/1KqrQK3Kqq2tPevGcxcjlOodzwpCiG5V09TKze/t4GR5IzFB3nx85+ReE0gBmAx6hscGMjw2kF+kqEu47A4n31Y0acv+DhXXcbikHkurg135NezKr9Gu723SMyymfenfqLggBkb6Y5KgyjMUBXI3uMKobeoxgxdMWAjTHuo9YVQbnQ7CBqiXCQvV+1eT515JVV8EhdvVy6aXQG9UQ6qkae2VVF7+nr4nl62ypjJWF6wmOz+bPWV73EKb4WHDSUtKIy0pjaTAH7jTYw8R7hPO9UOv5/qh11PZXEl2fjZZeVnsLtvNgYoDHKg4wIu7XmRsxFgykjNIS0ojyi/K09O+bDmbmrDs2+cKoXZhPXAAxWZzG2MIDW3fGW9iKl6DBvXayiK9nx/hd99FyI3zqV7xPtUrVtBy7BhF992H9+jRRCxejN/0aRJOXWSKotBY414BVV7QQHN95wBKp4PgaL8Oy+/8CU8IwOzdez9q6vU65i4YhtOucHJ3OV8vO8RV940mYXiop6cmzlGzzcHw32Z65LaP/CEDX/P5//77+PhQ5dpwYs6cOTz77LOcPn2amJgY1q1bx/Tp07niiitYtmyZdp1169YxZcqUs1aJWSwWbDYboaFn/x3etm0b8+bNczuWkZHBQw89dN735Vz03mcKIcRFUWexcfP/7uBYaQORAV6svHMyCaG9fxmR0aBnSHQAQ6ID+PkEdXmXw6mQW+nqUVVUz6GSOg4X19HU6mBvQS17C2q163sZ9QyNCWRUnLr8b2RcEIOjAjAbe+eb+l5BUeDUejWMKtyuHjN4wYRFMP0hCOwjfW50Ogjtp17G36Le79p895CqrhAKd6iXzS+rIVXseLWKKnk6JEyWkKqblTaVkp2fTXZ+NnvL97qdGxU+ivQktSKqrzUID/cJZ/7Q+cwfOp8KSwVZ+Vlk5WWxt3wv+yr2sa9iH8/nPM+4yHFaQBXpK/1WupOjsZHm3bux5OTQlJOD9fARsNvdxhgjIrQAyjc1FXP//n0upDEEBBCx+AFCbr6J6r8sp/qjj7AeOEDhnXfiM2ECEQ8uwe97eqWIrimKQkO1VQ2f2npAFTbQ3GDrNFang5AYPyITA9RG5AnqEjyTV9/r9aU36Jl323CcDoVT+yr48q0DXP3AGOKGhHh6aqKPUhSFNWvWkJmZyeLFiwGYNm0aZrOZ9evXM3/+fNavX8+sWbOYMGEClZWVWpXShg0buP3228/6s5cuXUpsbGyn0Kmj0tJSoqLcv3SKioqivr6e5uZmfLppwwtZvifEZazBauPm/93J/sJawvzMrLp7MgMjAzw9rUvK6VTIrWrSqqkOFtdxuLiehhZ7p7Fmg56hMQGMiFWrqUbFBTE42h8vY997I3ZJKQqcWucKo3aoxwxekHKrWhkVeBn2tKnJU3f1y9usNlCvLXA/rzNA7DjXcr8ZkDgJvC6vx253KG4sJjtPDaIOVB5wOzc2YqxWEXU59llqqxbLzMt0C+l06NwCqghf6btyoRy1tVh278aSswtLTg7Wo0fB6b4c3Rgbg59rKZ5vaiqmxMQ+F0J9H3tVFVXvvkfNypUorWr1ju+UyUQsWYLvuHEenl3PpSgK9ZXWDhVQ9VQUNGJt6iKA0usIjfXTlt9FJAYQFu+PyXx5ve9x2J38Z9lB8g9WYfQy8NPFY4gZGOzpaYkz9Oblex999BHe3t7YbDacTic33ngjb775Jn5+aiuH6dOnM2LECJYtW0ZUVBRffPEFqamppKenM3/+fGbNmsWAAQPYuHEjM2bM6HQbzz33HC+88ALr169n9OjRZ53L4MGDufXWW3nssce0Y1999RVXXXUVFouly1BKekp1QUIpIc5NU4udBX/Zye78GkJ8TXx812SGRstjBtSgKr/a4hZUHSquo97aOagyGXQMjgpQq6ni1aBqaHQA3qbL6w3beVEU+HatGkYV7VSPGb1hwq0w7cHLM4w6m5r89n5UeZu+I6Sa5gqpJktIdY4K6gu0iqjDVYe14zp0jI8aT1pSGvMS58lytQ5Km0pZna8GVPsq9mnH2/7O2gKqcB/pv3Iu7FVVWHbt1npCtZw4oT4/dmBKTMQ31bUcLyUVc3wvW8bcjWxlZVQtW0bNP/4JrmWMfrNmErF4CT4jR3h4dp6lOBXqKppdPaDU5XeVhQ20WDq/n9Eb1ACqLXyKSAwkLN4Po7yfAcBuc/DVWwcpPFKNydvATx8cS3S/IE9PS3TQmxudFxcX89Zbb2E2m4mNjcV4Rs+/J554glWrVvHpp58yZcoUampqMBgMPP300xw/fpxZs2axZMkSampqMJ+xc+pLL73EU089xerVq0lJSfnOucycOZPx48fzyiuvaMeWL1/OQw89RJ2rp9+ZJJTqgoRSQny/5lYHt67YyfZT1QR6G1l552RGxskL63dRFIXC6mY1oOrQUL3W0vmbRYNex6BIf7WaKj6IEbFBDI8JxOcy+2bxrBQFvl3jCqNy1GNGb0i5TQ2jAqSZ8veqLXAFVFtcIVW++3mdAWLHtldSJUwCb3lNbJNbl6sFUceqj2nH9To9KVEppCelMzdproQq56C0qZSsvCwy8zM5UNFeXaZDR0p0ChlJGfJ3eQZbebkWQFlydtH67bedxpj793cFUCn4TkzFFCWh6PexFRdT8dZb1H36GTjU6oiAtHmEP7AY7yGDPTu5S0BxKtSWW7TeT5WuSqhWa+dKEb1RR3icP+EdK6Bi/TGYpEXBd7G1Ovjyjf0UH6/F7GPkmofGEpkkr609RW8Opc5sdH6mtWvXMnfuXB5//HH27t3LV199BcCmTZu4+eabmTlzJmVlZWRlZbld74UXXuDpp58mMzOTyZMnf+9cli5dyldffcXBgwe1YzfeeCPV1dXd2uhcQikhLjNWm4M73t/F5pOVBHgZ+eiOSYxJCPb0tHolRVEorm3uUE1Vz6HiOqqaOjcBNeh1DIzwd+36pzZVHx4beEFNEHsdRYGTa2D9s1C8Sz1m9IaU22HaEgmjLkRtgRpQ5bt6UtXkuZ/X6SFmbIflfpMvu5Dq29pvtf5IJ2tPascNOgMToycyL2kecxPnEuYT5sFZ9m6nG09rf8cdlz/qdXpSo1K1nQlDvS+vRsG2khKtH1Rzzi5a8/M7jfEaNKi9J1RKCsZwCfHOV2t+PhVvvEH9v79QX3d0OgKv/BHhDzyAV//esyvmd3E6FWrLLFoPqPKCeioLG7G1dA6gDEY9YfH+bj2gQmP9MEiPzPNia3Hw79f2cfpkHV5+Rq59eBzh8VKZ3BP05VDKarUSHByM2WzmN7/5DUuXLgWgpaWF4OBgTCYTjz32mNuyu+eff57f/va3rFy5kmnTpmnH/f398ffvui9pbm4uI0eO5P777+e2225j7dq1LFmyhC+//JKMjIyzzk1CqTNIKCXE2bXYHdz94W7WH6/A12zgw9snMiHp8vpw0N0UReF0ndVt6d/B4noqG1s6jdXrYIAWVAUxMjaQEXFB+Hv1saBKUeDkalcYtVs9ZvSB1Nth6hIIkAqAi662sMNyv81Qk+t+XqeHmDFnhFR9q1pSURRO1JzQKqJO1Z3Szhl1RibFTiIjKYM5CXMI9g723ET7qLb+XJl5mRyqat9a2qAzkBqdSkZyBnMT5xLi3bcaBiuKgq2wUOsHZcnJwVZc7D5Ip8Nr2FCtJ5TPhAkYQ/rW30NP0HLyJBWvv0FD27f7ej1BV19N+AP3Y05I8OzkfgCnw0lNqcVtF7yKokbsXQRQRpOe8AR/IhJcAVRiICExvhhkN+GLqrXZzr9e3UdZbj3e/iaue2Q8obF+np7WZa8vh1IAs2fPZsOGDWzfvp1JkyZpx+fMmcP69evZtm2bWzVUcnIy+V18CfK73/2OJ5988qy3s379eh5++GGOHDlCfHw8TzzxBIsWLTrreAmluiChlBBdszmc3PfXPWQfKcPbpOf9Wycyqb9UBFwKiqJQ3tDCwaL2/lSHSuooq+8cVOl00C/cj5GuZuoj44IYERdIoLfJAzO/QIoC32SrYVTJHvWYhFGeUVfkXklVfcr9vE4P0aNdIdV0SJwCPsEemeqFUBSFo9VHtSAqv779zZhJb2Jq7FTSktKYnTCbIK++FcL1ZEUNRWTlZ5GZl8mRqiPa8bYqtbaAqjeGg4qi0Jqb12E5Xg72sjL3QQYD3iNGqD2hUlLwnTABg7xHvWSsR49S8eprNK5bpx4wGgn+2c8Iv/ceTDE9q3ehw+Gk5nQT5fnq8rvyggaqihqx25ydxhrNejV8Smy/hET7opcA6pJosdj4/JV9VBQ04Bto5rpfjic4qvfvXt2b9dZQqreTUKoLEkoJ0Znd4WTJ3/by1cFSzEY9f1mYyvRBsjTA08rrrRwqqeNgUb3Wp+p0nbXLsclhvlpF1ai4IEbGBhHk20ODKkWBb7LUnlFnhlHTHgR/2T7e4+qK3Supqs/saaODmNFqFVXSNEiaAj49s5JDURQOVx0mKz+L7LxsihqLtHNmvZlpcdNIT05nVvwsAsyyxMLTChsK1R5UeZkcrT6qHTfoDEyOmUxGcgZXJF7RY0NDxemk5eRJrR+UZdcuHJWV7oNMJnxGjtR2xvMZNw6Dv1RReFrzgQNUvPoaTZs3A6AzmQi+/nrC7roTU+Slf11y2J1UlzRpPaAqXAGUw945gDJ5GQhP8CcyMVBbghcc7Ytef3ntuNjTWJtsfPanvVQVNeIX7MV1vxxHUIQEU54ioZRnSCjVBQmlhHDncCo88vd9fL6vBLNBz7IFE5gzREKBnqqysYWDxXUc7tCnqri2ucuxiaG+jHJVUrUFVSF+5i7HXhKKAicyYcNzUOLaMt7k214ZJWFUz1V/2hVSbYLcTV2HVNGj3CupfD239NepODlQcUCriDrddFo7523wZkb8DNKS0pgZPxM/k4QBPVVBfYFWQdWx4XzH5ZWeDqgUh4OW48ex7NqlBVGO2lq3MTqzGZ8xY7SeUD5jxqDvYtts0TNYdu+m4pU/Y8lRN9rQeXsTcuONhN1xO8bQ7nlec9icVJU0tgdQ+Q1UlTTitHf+GGb2NhCRGODWhDw40hedBFA9UnNDK5/9aS/VJU34h3px3S/HExgmj39PkFDKMySU6oKEUkK0czoVfv1/B/jn7iKMeh1v3TyBtOGyZKq3qW5q7dBMXV36V1jddVAVH+KjLv2Lb+9TFebv1b0TVBQ48bVaGXV6n3rM5Aupd7jCqIjuvX1x8WkhlauSquqbMwboIGpke0iVNLXbQyqn4mRf+T4tiCqztC+R8jH6MDN+JmlJacyIm4GvSb6p7m3y6/O1CqrjNce140a9kSkxU8hIzmBO4hwCzd373k6x27EeOdLeE2rPHpz19W5jdD4++I4bq1VCeY8ejd7swS8ExA+mKAqW7dup+POrNO/bB4De15eQBbcQduutGILOPwi12xxUFTVRUVCvhVDVJU04HZ0/cnn5GglPaA+fIhIDCIrwkQCql2mqa+Gzl/dSW2YhMNyb6345Hv8QCUUuNQmlPENCqS5IKCWESlEUfvPZIVbuKMCg1/Ha/HH8eFTP6p0gzl+tpZXDJfWuRupqZVVelaXLsbFB3oxwLftrq6yKDLgIL9aKAsf/o1ZGnd6vHjP5wURXGOUnS0T7jIZSNZxqC6oqT5wxoC2kmuYKqaZdlJDK4XSwp3wP2fnZrM5fTUVzhXbO1+jL7ITZpCelMzVuKj5G+Wa6r8ity1UDqvxMvqlpD0SNeiPTYqeRkZzB7ITZF2U5ptLaSvOhQ1oI1bxnD06L+3Op3s8Pnwnj8U1NxS81Fe8RI9CZeujyafGDKIpC06ZNVLzyZ6xH1H5n+oAAQm9dROiCBRjOskNVG1urg6oi9wqo6tNNKM4uAig/Y4fwKZCIxAACw73R6SSA6gsaa1r49OU91Fc0ExTpw3W/HI9fUDd/KSjcSCjlGRJKdUFCKSHUN1m///cRVmzNQ6+DP10/lmvGxnl6WqKb1TXbOFxSx+Hieq2q6lRlU5djowK91IDK1VB9VHwQUYHn+AKuKHD8K7UyqtS17bvJDybeCVMXSxh1OWgoczVNbwupjnce01ZJlTRNvfid28YKdqedXWW7yM7LZnXBaqqt1do5f5M/cxLmkJaUxtS4qXgZ5A1/X3eq9hSZeZlk5WdxsvakdtykNzEtVu0XNidhDv7m7w4P2jhbWmjetx/LLnUpXvO+fShW915++qAgfCdMaK+EGjoEnbGP7Yoq3CiKQuOaNVS8+hotJ9TQ3RAURNiddxBy443ofX1ptdqpKmrU+j9VFDRQc7qJrj5Jefub2gMoVw+ogDAJoPq6hmorn760h4ZqKyHRvlz7yHh8A6WK8lKRUMozJJTqgoRS4nKnKArPfHWUdzflotPBiz8fw88nxHt6WsJDGqw2DpfUq8v+XFVVpyq7fhMdEeDFyNhAbde/UfFBRAd2eBPdVRhl9lfDqCmLzzl0EH1QY3n7Ur/8LVBxrPOYyBEdlvu5h1Q2p42c0zlk5WextmAtNS012rlAcyBXJF5BWlIak2MmYzbIG/zL1cmak1oPqlN17TtItjW0b6ug6thHzGmx0LxvH02unfGs+w+g2GxuP9cQGqruiufqCeU1aBA6vexgdjlSnE4avv6a068vo6rKSWNAAo3hg2iKGU691QRdvHb6BJiISAwkMql9CZ5/iJcEUJepuopmPnt5D401LYTF+XHtw+Px9pfKyktBQinPkFCqCxJKicuZoii8lHWcN9apTYqf/dko5k9M9PCsRE/T2GLnSFtQ5dr172R5I12sNiDc38yImECu893HFWXLCax17ZZl9oeJd8GUBySMEp01lrv3pOoipLJFDmNbzFCyzQpr676h3tagnQv2CmZu4lzSktKYGDMRk17e0It2iqJwslYNqL7O/Zq8+jztXJDNxLXNQ5lWHkzk8UpajxwFu93t+saICHxTU7RKKPOAARIgXMZamu1UdtgBr6KggdpyS9cBlNlB5KBwIpODtGV4fsFm+f0RbmrLLHz68h4sda2EJ/hzzUPj8PaT17HuJqGUZ0go1QUJpcTl7M+rv+FPq9Wy8z9cM4IFU5I9OyHRa1ha7Rw93eDWUP1keT1z2cWDxk8Yrs8HoFHx5m+6K9kdexPJiQnarn8JoT7yplycXWMF5G+hJXcD24o2kW2vYp2vLw2G9mqUUCfM9Y0nPXEeKSNuwhgY7cEJi97CXlvLtxv/zakNX2LYd4y4khb0Z7yztUcEEzRpKgGTJuOXmoopKUmery5T1iYbFYVq76e2/9ZVdL1xiH+IFxHx/vg3FmDc+C98Cw/g1VqPKS6O8PvuI+ian8qyTnFW1aeb+OzlPTQ32IhMDuSaB8di9pHfl+4koZRnSCjVBQmlxOXqzfUneeFrta/L/7tqGHfM6O/hGYley+mEY//Guf559OWHAbDqffnMfDUv1c+l0tm5d0uQj4mRcYGMjHUt/YsLIinMVz74Cax2K1uKt5CVn8WGog002dr7nIXrvZjX4iS9sojx1hYMHa8YMdR9uZ9/5CWfu+h57NXValPyXWpj8pbjxzlzPbIlMpBDCU5yoi0cSdRREazD2+DNjPgZZCRnyA6Nlwlro83VgLxeq4Cqr7R2OTYg1FtbetfWA6pjLyBnSwu1f/8Hle8sw1FRCYA5KYnwB+4n8Mc/RmcwdPlzxeWtqriRz17ei7XJRnT/IK5eMgaztwRT3UVCKc+QUKoLEkqJy9F7m07x1Jfqsqpf/2gI980e6OEZiV7J6YSj/4INL4ArjMIcAJPvgcn3gW8oVpuDE2UNWjXVweI6jpc2YOtiq+sAbyMjOvaoigsiOcwPvWx13edZbBY2F28mOz+bDUUbaLa3VyJE+kaSnpROWlIaYyPHotfpoamqfblf/hYoO9T5h4YPcYVU0yBpOgREXcJ7JDzFVl5O865dWk+o1pPfdhpj7tfPtRRPXZJnio5GURSO1xwnMy+TzLxMChsKtfE+Rh9mxs8kPSmdGfEzZOfGPqC5odVt+V1FfgMN1V0HUIHhHQIo18XH/9x61Tmbm6lZ+TFV772Ho0btfWceOICIxUsISJsnvchEJxUFDXz+yl5aLHbiBgdz1QNjMJklxOwOEkp5hoRSXZBQSlxuPtiWx28/VwOEh+YN4qF5gz08I9HrOJ1w9HNXGKVuiY1XIEy6BybfC76h33n1VrvTLag6VFzH0dIGWu3OTmP9vYwMdwVValgVSL9wfwwSVPV6TbYmNhZtJDs/m01Fm7A62j8QxvjFkJaURnpyOqPCR6lB1HexVHfoSbUFyg52HhM+uL2KKnk6BMhyv77Advo0FlcAZdmZQ2t+fqcxXoMGtfeESknBGBHxnT9TURSOVh/VAqrixmLtnI/Rh1nxs8hIzmB63HS8jfJBpqez1LdSnt9e/VRR0EBjTUuXYwMjfNp3wXNdLkZvH0djEzUffUjVX5bjrK8HwGvYMCKWLMZ/9mypEhZuynLr+fzPe7FZHSQMC+HH943GaJJg6mLrraHUokWLeP/99wEwmUwkJiayYMECHn/8caxWKyEhIXz44YfccMMN2nVuuOEGVq1aRW5uLsnJydrx5ORkbrnlFv74xz/y7rvv8sEHH3DokPpF34QJE3jmmWeYOHHiWedy+vRpfvnLX7Jr1y5OnjzJkiVLeOWVV75z/hJKdUFCKXE5+XhnAY99on5Yu2/2AH6VMUTeCIlz53TCkc/UMKrC1cDcK1ANoibfCz4h5/2jbQ4n35Q1tveoKqnjSEk9LV0EVb5mAyNiAxkRqwZVo+KDGBAhQVVv0NDawPrC9WTnZ7OleAutzlbtXLx/PGnJaaQnpTMibMSFPTdZqiF/a3vj9LJDdOpCHDaofbmfhFS9gqIo2IqKsOzM0Zbj2YqK3AfpdHgNHeoeQoWc/3OToigcqTpCZn4mWXlZbgGVr9GXWQntAZWXweu8b0dcHE21La4leG0VUPU01bV2OTY4yte9AirBHy/f7m0u7aivp3rFCqrf/wBnk7o02XvMaCKWLMFv6lR5TyY0p7+t41+v7sPe4iBpZBhX3j0Kg0kq6y6m3hxKlZWVsXz5clpaWvjqq6+4//77efrpp3nssceYMmUKY8aM4e2339auEx0djdls5g9/+AOLFi0CIDc3l/79+7N27VrmzJnDTTfdxLRp05g6dSre3t48//zzfPrppxw+fJi4uLgu55KXl8ef/vQnJkyYwJ/+9CdmzZolodT5kFBKXC7+ubuIX/1zP4oCd0zvx2+uGiZvfsS5cTpcYdSLHcKoIFcYdc8FhVHfxe5wcrKikYNFdRwuqedgsRpUNdscncb6mAwMiwloX/oXH8TACH+MBnkD52l1LXVaELW1ZCs2p007lxSYpC3NGxo6tPuekyzVULDNFVJtgtKuQqqBroBqhlpNFRjTPXMR50xRFFpz87DsytH6QtlPn3YfZDDgPXx4+3K88eMxBAV123wOVx3WKqhON7XPxc/kx+yE2WQkZTA1bqoEVN1MURSaalsob2tA7lqCZ6nvIoDSQUiHACoyKYDw+ACPNpG219RQ/Ze/UP3hRyhWtUrUNyWFiAeX4Jua6rF5iZ6l+EQNX7y2H7vNSb8x4WTcNRKDvK+5aDqFI4oCNotnJmPyhXN8D7Ro0SJqa2v57LPPtGPp6ek0NDSwbds2Hn/8cT755BOOHVN3Mj569ChTpkxh6dKlHD9+nBUrVgCwfPly7r33Xmpra7sM5RwOByEhIbz++ussWLDge+c1e/Zsxo4de0lCqW5/9n7jjTd48cUXKS0tZcyYMbz22mvfWTL2yiuv8NZbb1FQUEB4eDg///nPefbZZ3tV2ilEd/t8XzG/dgVSC6ckSSAlzo3TAYc/hY0vQoX6woZXEEy5T12q5xPcrTdvNOgZGh3I0OhA/tt1zOFUOFXRyMEOu/4dLqnH0upgT0Etewpqtet7GfUMiwnUlv2NjAticFQAJnlD1+1qrbWsLVxLVn4WO0p2YFfs2rl+Qf20IGpwyOBL81zkGwpDr1IvAM01kN8xpDoIVSfVy+4V6pjQAe0hVfI0CIzt/nle5hSnk5aTJ7UqKMuuXVqTaI3RiM/IkWoINTEVn3HjMfj7XZL56XQ6RoaPZGT4SB6Z8AgHKw+SlZdFZn4mpU2lfHnqS7489SX+Jn/mJMwhPTmdqbFTMRvOrf+Q6JqiKDRUW6ksaHRrQt7cYOs0VqeDkBg/V+WT2oQ8PN6/xzWLNoaEEPnLXxK6cCFV775Lzcd/w7JrF/m3LMBv6lQiHlyCz5gxnp6m8LC4werSvS/fOEDu/kqy//cI6bcPRy/vY7qHzQLPeOi1/vESMJ//a5mPjw9VVVUAzJkzh2effZbTp08TExPDunXrmD59OldccQXLli3TrrNu3TqmTJly1tzEYrFgs9kIDf3uthye0K3P6KtWreKRRx7h7bffZtKkSbzyyitkZGRw/PhxIiM776KzcuVKHn30Uf7yl78wdepUTpw4waJFi9DpdLz88svdOVUheo3/HDzNI3/fj1OB+RMT+N3VF7gsRvR9bWHUhhegUt2h8VKGUd/FoNcxKCqAQVEB/Gx8PKAGVbmVTe1L/1xBVWOLnX2FtewrrNWubzboGRoTwMi4IEa6lv8NjvbHyyi9Gi5UVXMVawvXkp2Xzc7SnTiU9oq2gcEDSU9OJy0xjYEhPWBjBZ8QGPpj9QLuIVX+Zjh9AKq/VS971L4Nakg1zRVSTZeQ6iJQHA5ajh9vD6FyduGorXUbozOb8RkzRluO5zN2LHofzzca1+l0jI4YzeiI0TySogZUmXnqEr8ySxn/PvVv/n3q3/ib/Lki8QoykjOYEjMFk6F7l4f1doqi0FBlVSugClxVUPkNWJu6CKD0OkJjOi7BCyQ83h+TV+95PjeGhxP12GOE3norlcuWUfvP/6Np61aatm7Ff/ZsIpYsxnv4cE9PU3hQwrBQrrxnFF+9fYBv95Sz2qBj3q3DZRMYAajPmWvWrCEzM5PFixcDMG3aNMxmM+vXr2f+/PmsX7+eWbNmMWHCBCorK7UqpQ0bNnD77bef9WcvXbqU2NhY5s2bd6nuzjnr1uV7kyZNIjU1lddffx0Ap9NJQkICixcv5tFHH+00/oEHHuDo0aOsWbNGO/bLX/6SHTt2sHnz5nO6TVm+J/qy7CNl3PvRbuxOhZ9PiOeF/xotL2Li7JwOOPQJbHwBKk+ox7yDYPL9MOluj4ZRP5TTqZBfbXFrpn6ouI56q73TWJNBx5DoAEbGtu/6NyQ6AG9pKvq9KpsrWZ2/muz8bHaV7cKptPcAGxo6lLSkNOYlzaN/UH8PzvI8NNd2WO63GUoPgHJGf7PQ/q6m6a5KqqB4j0y1N1HsdqxHj6o9oXJysOzejbOhwW2MzscH33Fj8UlJwS81Fe/Ro9F79Z6lcE7FyYGKA2pAlZ9FuaVcOxdgCmBO4hwJqFwURaGuotmtAXlFQQMtls7P03q9jtA4tQIqMjGA8MQAwuP8MfaxXclai4qpfPNN6j7/HBxqsB+Qnk7E4gfwGjTIw7MTnpS7v4Kvlx3C6VQYOiWaK24Zhk7e01+Q3rx876OPPsLb2xubzYbT6eTGG2/kzTffxM9PrbaaPn06I0aMYNmyZURFRfHFF1+QmppKeno68+fPZ9asWQwYMICNGzcyY8aMTrfx3HPP8cILL7B+/XpGjx59TvPqE8v3Wltb2b17N4899ph2TK/XM2/ePLZt29bldaZOncpHH33Ezp07mThxIqdOneKrr77illtuOevttLS00NLSvuNGvWsHDCH6mnXHy7nvr2ogdc3YWJ6XQEqcjdMBh/5PrYyq+kY95h0MUx6ASXepwVQvo9fr6BfuR79wP346Rq1oURSFgmoLh4rrtbDqYHEddc02DhXXc6i4HnLUbeCNroqsUXHq8r8RcUEMjwmUoAooaypjdYEaRO0p24PSoTfT8LDh6q55SekkBiZ6cJYXyCcYhlypXgCsdVCwXV3ql7cZTu+H6lPqZe+H6piQZPeeVMEJnpp9j6G0ttJ86LC2O17znj04Le5v+PV+fviMH6/1hPIZMQKdufcud9Pr9IyNHMvYyLH8KvVX7K/Yr1VQVTRX8K9v/8W/vv0XAeYA5ibOJSM5g0kxkzDp+3ZApTjVAEpdftdIheu/rc1dBFBGHWGx/m49oMJi/S+LJs/m+Dhin3ma8LvupOKNN6n/4gsasrJoyM4m8Mc/JvyB+/Hq18/T0xQe0G9MBGm3jyDrfw9zbFspBqOeWTfKhkUXlU53QUvoLqU5c+bw1ltvYTabiY2NxWg0djq/atUqDh8+THNzM+PHjwdg1qxZrFu3DqfTia+vL5MmTer0s1966SWee+45Vq9efc6B1KXWbaFUZWUlDoeDqKgot+NRUVFak64z3XjjjVRWVjJ9+nQURcFut3PPPffw+OOPn/V2nn32WX7/+99f1LkL0dNs/qaSuz/cjc2h8ONR0fzPf4+RnclEZw67GkZtfEHtpQNqGDX1AZh4N3j3repRnU5HUpgfSWF+XDVabWKtKApFNc0ddv2r51BxHdVNrRw9Xc/R0/X8fZe6u5dBr2NQpL9r6V8go+KDGBYTiK+5Z/Uq6Q6lTaVk52eTlZfFvop9budGhY8iPSmdeUnziA/oo9VC3kEwOEO9QIeQylVJdXof1OSpl70fqWOCk9qX+iVPg+BeHNKdI2dLC83792v9oJr37tOaOLfRBwbiO2GCK4RKxXvYUHTGvvkY0uv0jIscx7jIcfw69dfsLd9LZl4m2fnZVDZX8tnJz/js5GcEeQWpAVVSBqkxqb0+oHI6FWrLLO4VUIUN2KydN6kwGPWExfkRkRRIpCuECo31w2Ds+wHUdzEnJxP34gtqOPX6GzRkZlL/5ZfU/+c/BF1zDeH334c5vo8+34qzGjghEqfDSfbyIxzeVILeqGfGLwZJMHUZ8vPzY+DAs7dDmDNnDk899RQrV65k+vTpGAzql6ozZ87knXfeQVEUbZlfRy+88AJPP/00mZmZpKSkdOt9uBDdtnyvpKSEuLg4tm7dypQpU7Tjv/71r9mwYQM7duzodJ3169dzww038NRTTzFp0iROnjzJgw8+yJ133skTTzzR5e10VSmVkJAgy/dEn7H9VBWLlu/EanOSNjyKN28aL42dhTuHHQ79U62Mqv5WPeYTolZGTbyrz4VRP5SiKJTUWTlY5Fr2V6L+t7Kx865Oeh0MiPDXqqlGxQUxIjYQP6/e/yG7qKFIW5p3oPKA27mxEWNJS0ojLSmNGH/ZpQ5rPRTuaK+kKtkHyhkfwIMTO4RU0/tESOW0WGjet0/tCbUzh+YDB1Ba3R8nhpAQfFNStMbkXoMHo9Nf3q9JDqeDPeV7tICq2lqtnQv2CtYqqFKjUzHqe/ZzidPhpKYtgGrbCa+wEXtLFwGUSU94vHsFVEiMn+wmdg6sR45Q8eprNK5frx4wGgn+r/8i/J67McXIc/Dl5ti206z54CgoMHZeAlP/a6AEU+fhu5aR9WRd7b53JqvVSnBwMGazmd/85jcsXboUULOQ4OBgTCYTjz32mNsqteeff57f/va3rFy5kmnTpmnH/f398ff3P+tt7du3D4A77riDIUOG8Ktf/Qqz2czws/TDuxjL97otlGptbcXX15d//vOfXHvttdrxhQsXUltby+eff97pOjNmzGDy5Mm8+OKL2rGPPvqIu+66i8bGRvTn8KZHekqJvmR3fjW3/O9OLK0O5gyJ4O1bJkgDZ9HOYYeD/1B30zszjJp0N3gFeHZ+PZiiKJTVt2i7/h12/be8oaXTWJ0O+of7af2pRrqCqgDvnl/9UFBfQHZ+Ntn52RyuOqwd16FjfNR4tUdU4jyi/KK+46cIWhqgoC2k2nT2kCppentIFZLkkan+EI7GJpr37tF6QjUfOgR29+VXhohw/FJTtZ5Q5oHyYem7OJwOdpftJis/q1NAFeIVwtwkNaBKiUrxeEDldDipPt2xAqqeysJG7DZnp7FGs57weHX3u7YKqJBoX9k17AI1799PxZ9fpWnrVkDdCCD4+usJv+tOjBERHp6duJQObypm/V/VzWgm/CiJSdf0l+faH6gvh1Kg9njasGED27dvd1umN2fOHNavX8+2bduYPHmydjw5OZn8/PxOP+d3v/sdTz755Flvp6vfu6SkJPLy8roc36NDKVAbnU+cOJHXXnsNUBudJyYm8sADD3TZ6HzChAnMmzeP559/Xjv28ccfc/vtt9PQ0KCVqX0XCaVEX7G/sJab39tBQ4ud6QPDeW9hivS/ESotjHpB7YED4BMKUxfDxDsljLoA5fVWDpXUcbBI7VN1uKSO03XWLsf204KqQEbGqpVVQT6eD6py63K1IOpYdftyeb1OT2pUKmlJacxNmku4T7gHZ9nLtYVU+a7lfsV7OodUQYmu3f3aKqmSzrnpaXdx1Ndj2bVb6wllPXIEnO4BhDE6WusH5Zuaijk5WT4YnSe7087ust1k5mWyOn81NS012rlQ71DmJc4jIzmDCVETMOi79/Xd4XBSXdLktgSvsqgRRxcBlMnLQHiCv9aEPCIxkOBoX+lj2Y0sOTlU/PlVLLt2AaDz9ib05psIvf12jCEhHp6duFQOri9i49/UjWkmXt2P1Kuk39gP0VtDqd6ux4dSq1atYuHChSxbtoyJEyfyyiuv8Pe//51jx44RFRXFggULiIuL49lnnwXgySef5OWXX+add97Rlu/de++9TJgwgVWrVp3TbUooJfqCQ8V13Pjuduqtdib1C2XFrRPx6WM70ojz4LDDwb+7KqM6hFHTlkDqHRJGdZOKhhZ1yV9R29K/eoprm7scmxTm67br38i4QIJ9u7/J88mak2qPqPwsTtae1I4bdAYmRk8kPTmdOQlzCPMJ6/a5XJZaGl3L/VwhVckecJ7R8DkoQQ2nklxBVUhyt4dU9poaVwC1C8uuXbQcO6buRtSBKT5e6wflOzEVU1ychFDdwO60k1OaQ1Z+FqvzV1PbUqudC/UOJS0pjYzkDMZHjr/ggMphc1JV0ugeQBU34rR3fstv8jYQkeBeARUc6Su7gHmAoig0bd1KxauvYt2vLrHW+/oSsnABYbfeikE+11wW9q0uYMs/1dfxKdcNYHxGz6+67SkklPKMHh9KAbz++uu8+OKLlJaWMnbsWF599VWt3Gz27NkkJyezYsUKAOx2O08//TQffvghxcXFREREcPXVV/P0008THBx8TrcnoZTo7Y6V1nPDO9uptdiYkBTCB7dN7BP9bMQFcNjhwCo1jKrJVY/5hsHUtjDq7OvCRfeoamzRmqi3NVUvquk6qIoP8dGW/bWFVaF+FxZUKYrCiZoTWkXUqbpT2jmjzsjk2MmkJ6lBVLB38AXdljgPrU1q4/T8La5Kqt2dQ6rA+Pam6cnTIaTfBYdU9ooKtR+UqxKq5ZuTncaYk5O1AMo3JUX613iAzWlTA6q8LFYXrKaupU47F+YdpgVU4yLHfW9AZbc5qCp2VUDl11NR2EhVcSNOR+e392YfIxGJ/kQktjchD4rwkQCqh1EUhcYNG6h49VVajhwF1A0Fwm5dRMgtCzD4947dxMT52/11Hts/U1/Xp/18IGPn9f6ehZeChFKe0StCqUtNQinRm50sb+D6ZdupamplTEIwH94+kcBe0LdGdBOHrUMYlace8w2DaQ9Cyu0SRvUwtZZWDhXXu3b9U8Oq/CpLl2Pjgn0YERuohlXxalAV7u/1nT9fURSOVh/Vgqj8+vY+ASa9iamxU0lLSmN2wmyCvIIu6n0TF6i1CQp3tldSFe8Gp819TGBc+1K/pGkQ2v97QypbaakaQLl6QrV20e/Ba9BArR+UT0oKpsjIi3jHxIWyOW3sPL2TzLxM1hSsob61XjsX7hPuFlA5bQqVRe0VUOUFDdSUNOF0dn4r7+Vr1JqPRyQGEpHoT2C4j1TB9SKKotCQnU3la69pAbMhOJiwO+8k5Mb56H18PDxD0Z12fpFLzhfqF5EzbxjMqNmyO+P3kVDKMySU6oKEUqK3yq1s4vpl2yhvaGFEbCAr75hMkK8EUpclhw32/00No2pdwYNvuBpGpd4OZvmWtLeoa7ZxuKStmqqew8V1nKps6nJsdKC327K/UXFBRAR4cbjqMFl5WWTlZ1HcWKyNN+vNTI+bzrykecxOmE2AWZZv9hqtFijqEFIV7eocUgXEdqikmoES0g9bSYkaQLmqoWyFhe7X0enwGjKkvSdUSgrG0NBLd7/EBbE5bGw/vZ3MvEw25G7Cqy6QiMYEIpoSiLYkE2iJRKd0DpW8/U1a5VPbJSDMWwKoPkJxOKj/z9dUvv66FjwbIsIJv+tugq//BXpz9y8RF5eeoihs//wUe75W3wfOvmkII2bEeXhWPZuEUp4hoVQXJJQSvVFhtYVfLNvG6TorQ6MD+PjOyYRc4PIe0Qs5bLD/Y9j4UnsY5Rfhqoy6TcKoPqLBauPwGUv/TlU2dWj140TvXYQp8ABeQYdRjO3Nkb0MXsyIm0F6cjoz42fiZ5LfiT6h1QJFOR1CqhwUh43WBgOWCi8s5WYslT7Ym84IGfR6vIcPb+8JNWE8hiCpkuttWq12KgvdK6BqS5vObP8FgMXUQH1gGaHxvowePpjUkSMJCJUKqMuBYrdT969/U/nmm9iKigB1Y4Lwe+8l+GfXoTPJF5l9jaIobP2/k+xbXQg6mLtgGEOnyJLrs5FQyjMklOqChFKitymubeYXb2+juLaZgZH+/O2uyd+7jEf0MfZWNYza9BLUFqjH/CJg2kOuMMrXo9MT3a/e2sq/j20lMy+LI3VbaKF9G3nFacbeMBR7wyjsjUMI9/NX+1O1NVSPDyI2SKoiejtFUWg9eZKmnByad+6gacd2HDX17oN0Cj6hNnwjW/BN9MMndTKGobMgeQaEDfT47n7i+7U226kodIVP+Q1UFjZQU2aBLt6N+waZiUgMICzel0r/YnbYN7C68j802durLaN8o0hPTicjOYPR4aPleeAyoLS2UvvJp1S+/Tb20lJA3bAg/P77Cbr6J+iM0oe0L1EUhU2rvuHg+iJ0Oki7bQSDUqM8Pa0eSUIpz5BQqgsSSonepLTOyvXvbCO/ykK/cD9W3TWZyEB5Er1s2Fth/0rY+D9Q1xZGRcL0h2DCrRJG9XEOp4M95XvIystiTcEaKportHO+Rl9mxM1isP9UdM1DOV7awqHiOr4pb8TRRf+YUD+z1qOqral6fIhUT/RkitNJy/HjbrvjOWpq3MbozGZ8Ro/Gd8I4fJP88PEtRX96p7r0z9Hq/gP9ozrs7jcDwgdJSOVhLRabVvlU6fpvXXnXGyL4h3gRntDWA0q9+AV1/oKqxdHC1uKtZOZnsq5gHRZ7e9+6GL8Y0pPUgGpk+Eh5/PdxzpYWalf9ncp33sFRWQmoGxmEP/AAgT++Ep1e7+EZiotFcSqsX3mcI5tL0Ol1ZNwxggHjpT/gmSSU8gwJpbogoZToLcobrNzwznZOVTSRGOrLqrsnExMkTSsvC/ZW2PdX2PRyexjlH6VWRk1YJGFUH2Z32tlVtovsvGxWF6ym2tpeERVgCmB2wmzSk9OZEjsFL0PnD6RWm4Ojp9uW/qlN1U+UNWDvIqgK9jVp1VRtPaoSQ33lg6qHKHY71qNH1QAqJwfL7t04690roXTe3viMG6suxUtJwWfMGPReXVTO2prVPlR5m9Ud/gp3gqPFfYxfZHvjdAmpup21yda+/C6/gYrCBuorzhJAhXoRmRjo1gPKN/CHL9lvcbSwuXgzWXlZrC9c7xZQxfrFkpGcQUZyBsPDhsvjvg9zNjdTs3IlVe++h6O2FgCvQYMIX/wAAWlp8m/fRyhOhbUfHuXYtlL0eh0/umcU/UaHe3paPYqEUp4hoVQXJJQSvUFVYws3vLOdb8obiQv2YdXdk4kPkSCiz7O3wr6PXGGUq0GxfxRMf1gNo0wSSvZFNqeNnNM5ZOWrFVG1LbXauUBzIFckXkFaUhqTYyZjNvzwD6ZWm4PjpQ3ajn8Hi+s4XtqArYst4QO8jYyMVZf8qUsAA0kO80MvW8JfdIrNRvOhQ1oI1bxnD84m9yb3el9ffCZMwDclBd/UVHxGjkB3Pk2LbVYo3gV5WyBvk9qfym51H+MX6Wqa3hZSDZaQ6jw1N7ZSke9eAdVQZe1ybGC4NxEJAUR0qIDy8b/4PSOtditbireQmZfJ+qL1NNvbA7E4/zgtoBoWOkxCij7K0dhEzYcfUPWX5TgbGgDwGj6MiCVL8J81S/7d+wCnU2H18iN8k1OG3qjjx/eOJmlEmKen1WNIKOUZEkp1QUIp0dPVWlqZ/+4Ojp6uJzrQm1V3TyYpTJoV92n2FtjrCqPq1eak+Ee7wqiFEkb1QTaHjW2nt5Gdn83agrVu27wHewUzN3EuaUlpTIyZiEl/8ZvTttgdfFPWyEFXSHWouI5jpxtodTg7jQ3wMjI8NrDDzn9B9Av3wyBB1Q/ibGnBeuAATTk5agi1bz9Ks3uljD4gAN8JE9RKqImpeA8b1j39X+wtULzb1Th9k1pJ1SmkinAt9XOFVBFDJKTqgqW+1VUBVa9WQBU00FjT0uXYwHBvIhID3Zbgeftd+ubTzfZmrYJqQ9EGt4AqISBBW+I3NHSoBBV9kKOujqoVK6h5/wOcFrV6zmfMGCIeXILvlCnyb97LOR1Osv73MN/uqcBg1HPVA6NJGCq7rIKEUp4ioVQXJJQSPVlds42b39vBweI6wv29WHX3ZAZE+Ht6WqK72Ftg74euMKpYPeYfDTMegfELJIzqY1ocLWwr2aYtpWmwNWjnQr1DmZc4j3lJ80iNTsWov/SNaG0OJyfKGtyW/h09XU+LvXNQ5Wc2dAqqBkT4S1DVgbO5meZ9+7SeUM3796O0uvd5MgQH45uaou2O5zV4MDqD4dJPVgupXJVUhTs6h1S+4a5KqhlqUBUx9LILqZrqWrQKqLaleE21XQdQwVG+RCT4E5EYqFZBJfjj5dvzdj9rtjezqWgTX+d9zaaiTVgd7f/uiQGJWgXV4JDBElb0MfaaGqrefY+alStRrOq/u29qqhpOpaR4eHbiQjgcTr5edoi8A5UYTXquXjKG2EEhnp6Wx/XWUGrRokW8//77AJhMJhITE1mwYAGPP/44VquVkJAQPvzwQ2644QbtOjfccAOrVq0iNzeX5ORk7XhycjK33HILf/zjH3n33Xf54IMPOHToEAATJkzgmWeeYeLEiWedyyeffMJbb73Fvn37aGlpYcSIETz55JNkZGSc9ToSSnVBQinRUzW22Lnlf3ewt6CWUD8zf7trMoOjAjw9LdEd7C2w5wPY/Kf2MCogBqa3hVG954VSfDer3cqWki1aRUKTrX15VrhPOPMS55GenM74yPEY9B4II76H3eHkZEUjB4vqOFyiBlVHSupptjk6jfUxqUHVqLggtal6fBADI/wxGi6PZrqOxiaa9+51hVA5NB86BDab2xhDeHh7CJWSgtfAgT2z2bC9BYr3nFFJdUb/I9+w9qbpydMgYhj0xPtyHhRFoam2Va1+agug8huw1Ld2HqyDkChft/5PEQkBmH163w5nFpuFjcUbycrLYmPRRlo69CFLDkzWdvEbFDxIAqo+xFZeTtU771K7ahWK6znLb9o0Ih5cgs/o0R6enThfDpuTr94+SMHhKkxeBn764Fii+wd5eloe1ZtDqbKyMpYvX05LSwtfffUV999/P08//TSPPfYYU6ZMYcyYMbz99tvadaKjozGbzfzhD39g0aJFAOTm5tK/f3/Wrl3LnDlzuOmmm5g2bRpTp07F29ub559/nk8//ZTDhw8TFxfX5VweeughYmNjmTNnDsHBwSxfvpyXXnqJHTt2MG7cuC6vI6FUFySUEj2RpdXOwr/sJCevhiAfEx/fOZnhsfL72efYrO2VUQ0l6rGAWHWZnoRRfYbFZmFz8Way87M7LY2J9I0kPSmdtKQ0xkaORa/rfR/iHU6Fbysatf5Uh4rVwMrS2jmo8jLqGRbTvuvfiLhABkcFYOoDQZWjvh7L7t1aTyjrkSPgcP87MEZFaVVQvqmpmPsl984P8/ZWKNmjBlR5m9WQymZxH+MTqoZTSa7m6ZHDe0VIpSgKjTVtFVD1VBQ0UlFQT3ODrdNYnQ5CYvy04CkiKYDweH/M3r0vgPo+FpuFjUUbyczLZFPxJreAql9QP22J38Dggb3zd1p0Yjt9msq3l1H7f/8HdjsA/nPmELFkMd7Dhnl4duJ82FsdfPnmAYqO1WD2NvDTh8YRlXz5fr44MxxRFMXtPdql5GM89x2QFy1aRG1tLZ999pl2LD09nYaGBrZt28bjjz/OJ598wrFjxwA4evQoU6ZMYenSpRw/fpwVK1YAsHz5cu69915qa2u7DOUcDgchISG8/vrrLFiw4Jzvy4gRI7j++uv57W9/2+X5ixFK9b1XWSF6GKvNwR3v7yInr4YAbyMf3T5JAqm+xmZ1VUa9DA2n1WMBseoyvXG3SBjVBzTZmthYtJHs/OxOS2DatmFPS05jVPioXhlEdWTQ6xgcFcDgqAB+Nj4eUIOq3MomLahqq6hqbLGzr7CWfYW12vXNRj3DogMY4QqqRsUFMTgqALOxZ/+92GtqsOxy7Yy3axctR4/BGd/bmeLi2kOoiamY4uP7xgd2oxkSJ6uXmb9yhVR7O4RUO6C5Go7+W70A+IR0qKTqGSGVoig0VFm13e/aluBZG7sIoPQ6QmM6VkAFEh7vj8mr51U0dgdfky8/6vcjftTvRzTZmthQuIHMvEw2F28mty6XZQeWsezAMvoH9deW+A0IHuDpaYsLYIqJIeb3TxJ2x+1UvvkWdZ9/TuO6dTSuW0dARgYRix/Aa+BAT09T/ABGs4Ef3zeaL17bT8k3tfz71X1c8/A4IhJkJQaoy5cnrZzkkdveceMOfE3nv4mVj48PVVVVAMyZM4dnn32W06dPExMTw7p165g+fTpXXHEFy5Yt066zbt06pkyZctYqMYvFgs1mIzT03HuQOZ1OGhoaftB1zodUSgnRjaw2B3d9uJuNJyrwMxv48I5JjE+UNd99hs0Ke95Xl+lJGNXnNLQ2sL5wPdn52Wwp3kKrs31pT7x/PGnJaWQkXb7brTudCnlVTVo11aHieg6V1NFgtXcaazLoGBIdoPWnGhkbxJDoALxNngsA7JWVagi1U12O1/LNN53GmJOS8J2Yqi3HM8XGemCmPUBbSJW/WQ2pCnaAzX0nwfaQqq2SakS3hlSKolBf2aw1H2+7tFg6//7p9TpCYv2I7LAELzzeH6P58gigfojG1kY2FG3g67yv2VK8BZuzPdAbGDxQq6DqH9zfg7MUF0PLqVwq33iD+q++UgN4nY7An/yEiPvvw9yhR43o+Vqtdv796j5KT9Xj7Wfi2kfGERZ3+fWsPbNix2Kz9IpQqmOllKIorFmzhp/85CcsXryYF198EYvFQkhICCtWrGD+/Pn84he/IDU1lYcffpjg4GAOHjxIv379SEpK4vbbbz9rRdN9991HZmYmhw8fPufljS+88ALPPfccx44dIzIysssxsnyvCxJKiZ6i1e7kno92s/ZYOT4mA+/fNpGJ/WR3jD7B1gy734ctr7SHUYFx7WGU0cuj0xPnr66lTguitpZsdftAlhSYpC3Nk12ruuZ0KhRUW9SgqkQNqw4W1VHfRVBldFVkjYwL1MKqYTGB3RZU2crKtADKkpNDa25upzHmgQO0AMo3JRVTVNdvwC57DhuU7GuvpCrY3jmk8g52D6miRp53SKU4FeoqmqkoaGtCri7Da23uIoAy6AhtC6CSAolIDCAszg+jBwPQ3qotmM/Ky2JLSeeAKiM5g/TkdPoHSUDVm1lPnKDytddpyM5WDxgMBF17DeH33oc5vuu+M6LnaWm2869X9lKe34BPgInrfjmekOjLa3fv3rx876OPPsLb2xubzYbT6eTGG2/kzTffxM9P/TecPn06I0aMYNmyZURFRfHFF1+QmppKeno68+fPZ9asWQwYMICNGzcyY8aMTrfx3HPP8cILL7B+/XpGn2MvuZUrV3LnnXfy+eefM2/evLOOk1CqCxJKiZ7A5nDywMo9ZB4uw8uoZ/mtqUwdEO7paYkLZWuG3Stg8yvQWKoeC4x3hVE3SxjVS9VYa1hXuI6s/Cx2lOzArrR/0G3rrZKWlCa7U50nRVEoqmnWlv0dcl1qLJ2XVBn0OgZF+nfY9S+Q4TFB+JxHRUtrUbFrKZ66O56toMB9gE6H1+DBHXpCpWDs5vL0Psthg9P73UOq1kb3Md5BakjVFlRFj4Iumv87nQp15Ra3CqjKwgZarZ17mumNOsLj/N2akIfF+mMw9eylor1RfWs96wvXk5mXydaSrdid7c+Tg0IGkZGkLvFLDkr22BzFhWk+fJjKV1+jccMG9YDJRPDP/4vwe+7BFBXl2cmJc2JtsvH5K3upLGzEN8jMdY+MJzjq/JeQ9Ta9udF5cXExb731FmazmdjYWIxG9y5LTzzxBKtWreLTTz9lypQp1NTUYDAYePrppzl+/DizZs1iyZIl1NTUYDab3a770ksv8dRTT7F69WpSznHnzb/97W/cdttt/OMf/+Cqq676zrESSnVBQinhaXaHk4dW7eOLA6cxG/S8tzCFmYMjPD0tcSFszbBruVoZ1VimHgtKUMOosTdJGNULVTVXsbZwLVl5WeSU5uBQ2j/wDgweSHpyOmmJaQwMkf4a3UFRFIprm9Ulfx3Cqqqmzruf6XUwMNKfkbFqNdWo+CCGxwTi52V0+3m2/HyaXFVQll27sJecPuMH6fEeNkzrB+U7fjyG4OBuvqeXKYe9PaTK3wL526C1wX2MVxDOxKnUhFxBhW40FfUhVBQ2UlHYiL2lcwBlMOkJj3cPoEJj/TD0gab6vU1dSx3rCteRmZfJ9pLtbkH+kJAhWg+qxMBED85SnK/mffuoePVVmrZuA0BnNhMy/wbC7rwTY7h8wdrTNTe28vmf9lJV3IR/iBfX/XI8geE+np7WJdGbQ6kzG52fae3atcydO5fHH3+cvXv38tVXXwGwadMmbr75ZmbOnElZWRlZWVlu13vhhRd4+umnyczMZPLkyec0n48//pjbbruNv/3tb1xzzTXfO15CqS5IKCU8yeFU+NU/9vPJ3mJMBh3LbpnAFUPl26Veq8swKrFDGGX+zquLnqWyuZI1+WvIys9iV9kunIpTOzc0dChpSWnMS5onS1E8RFEUSuutHCyq41BJe1hV0dDSaawOhanGBmY1FzK0/FvCvj2MvrrKfZDRiM+IEfimpuCbmorP+PEYAqT5q0c47DhL9lGzfxflJ4qoKHFQ0ZJApT0Zu9L5g4PRCOEJgdryu4jEAEJifCWA6oHqWupYW7CWzPzMTpWmw0KHkZ6cTkZSBgmBCR6cpTgfTTt3UvHqqzTv2g2AzseH0JtvIvS22zCGSH/UnsxS38pnL++hptRCQJg31/1yPAGhvSekOV99OZSyWq0EBwdjNpv5zW9+w9KlSwFoaWkhODgYk8nEY489xmOPPaZd5/nnn+e3v/0tK1euZNq0adpxf39//P277jm2cuVKFi5cyJ///Gd+9rOfacd9fHwICgo669wklDqDhFLCU5xOhUc/OcDfdxVh1Ot446bxZIyI9vS0xPlotcDu5eoyvaZy9ZiEUb1SWVMZqwtWk52fzZ6yPSi0v+QNDxtOWlIa6Unp8o1+D1ZWb+VQYQ15OQew7tpF4ImDDCw9SXCrew8jm95AfmQ/ageNxGvCBOJnTGLkgGgCvU0emvnly+FwUl3S5NaAvLKoEYfN2WmsUW8jwnSKCMM3RJi+JcL4LSHGYvTe/pA4pb0nVfRoMMim0T1ZrbWWtYVryczLZMfpHW4VqMPDhqs9qJLSiQ+I9+AsxQ+hKApNW7ZS8eqrWA8cAEDv50fowoWELlqIQT5r9VhNdS18+j97qCtvJjDCh+seGY9/SN+u7O/LoRTA7Nmz2bBhA9u3b2fSpPYG7nPmzGH9+vVs27bNrRoqOTmZ/Pz8Tj/nd7/7HU8++eR33saZFi5cyIoVK7q8joRSXZBQSniCoig88fkhPtpegF4Hr80fz1WjYzw9LfFDtVpg119gy5/bw6jgRJjx/8GY+RJG9RKlTaVk52eTlZfFvop9budGh49mXtI80pLS5INRD6bY7ViPHtOW4ll278ZZV+c+xuxFdfIQjkcNZLNvPFvMMbQaOgdQSWG+Wo+qUa6d/4J8Jai6WBx2NYAqz69Xl9/l11NV3ITD3jmAMnkbiEgIcFuCFxzlix4nlB5Q+1HlbYb8rdBS735lcwAkdQypxkhI1YPVWGvUCqq8THaW7nQLqEaGjSQ9OZ305HTi/KWRdm+gKAqN69ZT8eqrtBw7BoA+MJCw224j9Jab0ftdXg21e4vGGiuf/s8e6iutBEf5cu0j4/AL6rvBVG8NpXo7CaW6IKGUuNQUReEPXxxh+ZY8dDr40y/Gcu04eZPVq7Q2dQijKtRjwUkw0xVGdfFBV/QsRQ1FrM5XK6IOVB5wOzcucpy6NC9xHjH+Ehb3RIrNhvXwYa0nVPPuPTib3Cuh9L6++IwfrzUl9xk5El2HZp5VjS3ty/6K1N3/imq63nUnIdRH2/FvZKwaVoX4Sej8fRw2J1UljW5NyKuKG3E6Or+VNPsYiUj0JyIxkIhEfyITAwmK8EGnP4fNApwOV0i1pUNI5R5KYg6AxMmukGoGxEhI1VNVW6tZU7CGzNxMcspy3JZOjwofpVVQyfNzz6c4nTRkZVHx2uu0fvstAIaQEMLuvJOQG+ejlyCgx6mvbObTl/fQWN1CaKwf1z48Dp+Avvl6J6GUZ0go1QUJpcSlpCgKz319jGUbTgHwwn+N5hep0jeh12htgpz/VcMoS6V6LCTZVRl1g4RRPVxBfYFaEZWfxZGqI9pxHTrGR43XgqgoP+nr1tM4W1uxHjigVkLl5GDZuw+l2T1A0gcE4Dt+vNqUPDUV7+HD0Rl/WOhQ09TKoZI6t4bqBdWWLsfGBftoO/61VVaF+ffdb5S/j73VQWVxI5UFDZS7Aqjq4iaczs5vG718jW7VTxGJAQSFn2MAdS6cDig9qDZNz9us/td6Zkjl30VIJc/hPU1Vc5UaUOVldurtNzpiNBlJGaQnpxPtJ+0PejLF4aD+q6+oeP11bPnqzqbGiAjC7r6b4F/8N3pz3ww9equ6CgufvrSHprpWwuL9ufbhcXj79b3nRwmlPENCqS5IKCUupZezjvPq2pMAPHXtSG6enOThGYlz0toEOe/Bllfdw6iZv4LR18sHmR4sty6X7PxssvOzOVZ9TDuu1+lJjUolLSmNuUlzCfeRHYJ6EmdzM83792PZqS7Ha96/H6XFvYG5ISgIn9QU/FLVEMpryBB0BsNFn0udxcbhEjWgatv1L6+q66AqJsi7vZoqXg2rIgP63htdW6uDysJGV/VTvRpAnbagdBFAefuZiEgK0JbhRSYFEBDmjU53kQKoc+F0QNnhDsv9toC11n2M2R8SJrWHVLFj5bm9h6lsrmR1/moy8zLZXbbbreffmIgxZCRnkJaUJgFVD6bY7dR9/jmVb7yJraQEAGNMDOH33UvwtdeiM8ljrqeoKW3i05f30lzfSkRiANc8NBavPraUXUIpz5BQqgsSSolL5bU13/A/2ScA+N3Vw7l1Wj8Pz0h8r5ZGyHkXtr4GFtdOXSH91GV6Ekb1WN/WfktWfhZZeVmcrD2pHTfoDEyMnkh6cjpXJF5BqHeoB2cpOnI2NWHZu0+rhGo+eBBsNrcxhrAwbSmeb0oqXoMGotN7Zne1equNw65qqkOuwCq3somu3iFFBnhpS//a/hsV6HVpQ5kL0Gq1U1nUSEV+AxWFagVUzemu76tPgKlTBVRA6CUOoM6F0wnlZ4RUzTXuY0x+kNgxpBonz/k9SIWlQnue31u+1y2gGhc5TguoIn0jPThLcTZKayu1//d/VL71NvZytSenKSGBiAfuJ/AnP+mWLxjED1dV0shnL+/F2mgjql8gP31wLGbvvrPsWUIpz5BQqgsSSolLYdmGb3n2P2qVxuM/HspdMwd4eEbiO7U0wE5XGNVcrR4L7a9WRo36hfQh6WEUReGb2m+0ZuWn6k5p54w6I5NjJ5OelM6chDkEewd7bqJC42howLJ7tyuE2oX18GFwONzGGKOi1BAqJQXfiamY+/XreeFGB40tdo6U1GvVVIeK6/i2opEuiocI9/diVFwgo+KCGOEKq2KCPB/etDbbqSxqcOsBVVNmgS7ug2+gWa2ASlSroCKTAvAL7j1hmxunE8qPuEKqTWcJqXzPqKQaJ5tZ9BDllnLt+X9P+R7tuA6dW0AV4RvhwVmKrjitVmpXraLynXdxVKlf/pn79yfigfsJ+NGPPPbFg2hXWdTAZy/vpcViJ2ZgEFcvHovJq2+EhhJKeUavCKXeeOMNXnzxRUpLSxkzZgyvvfYaEydOPOv42tpafvOb3/DJJ59QXV1NUlISr7zyCj/+8Y/P6fYklBLd7S+bc/nDF2r/mv8vfTAPXDHIwzMSZ9XSADvfga2vdwijBrjCqP+WMKoHURSFY9XHtKV5efV52jmT3sTU2KmkJaUxO2E2QV5BnpuoAMBeU0NzxxDq2DE1COjAFBurhlCunlCmhITeGXB0YGlVgyq1P5X632/KG7oMqsL8zK6AyhVWxQYRH+LTbX8HLc12LXhqu9SWdx1A+QV7aZVPkYkBRCQF9OkdmXA6oeJoe0iVt6X9NaGN0eeMSqrxElL1AGVNZWTnZ5OZl+m2m6oOHROiJpCenE5aUpos2e5hnBYL1X/9K9Xv/S8O186pXkOGELFkMf5XXNHrXwt6u/L8ej5/ZR+tzXbihoTwk/tHYzT3/mBKQinP6PGh1KpVq1iwYAFvv/02kyZN4pVXXuEf//gHx48fJzKyc/lta2sr06ZNIzIykscff5y4uDjy8/MJDg5mzJgx53SbEkqJ7vTR9nz+32eHAFhyxUAeSR/i4RmJLlnr1TBq2+vt346HDoBZv4aRP5cwqodQFIXDVYfJys8iOy+bosYi7ZxZb2Z63HTmJc1jdsJsAswBHpypsFdWYtm1C0vOLiw5ObScONFpjCkpEd/UVLUnVEoKprjLYxfS5lYHR0vbd/07WFzHN+WNOLpIqkJ8TYx0BVSjXBVVCaE/PKiyNtncwqfyggbqK7readA/xEvr/RSeEEBkUiC+gZd52KKFVFvaK6nalnS3MfpAwkQ1oEqeDnHjwdiHg7teoLSpVAuo9lfs147r0JESnUJGUob0FOxhHI2NVL//PtXLV+BsbATAe+RIIh5cgt/06RJOeVDpqTr+9ed92FocJA4P5cp7R2E09e5gSkIpz+jxodSkSZNITU3l9ddfB8DpdJKQkMDixYt59NFHO41/++23efHFFzl27Bim82yMJ6GU6C5/zynk1/+nbjV/96z+PPqjofJi2tNY62HnMtj2RnsYFTYQZv4aRv6XhFE9gFNxcqDigFYRdbrptHbO2+DNjPgZpCWlMTN+Jn4mPw/O9PJmKytv3xkvJ4fWU6c6jTH37+/qCeWqhIqSXi9trDYHx0obOFhcx2FXQ/UTZQ3YHJ3fcgV6G7X+VG1L/5JCfdG7dq5rbmxtD6BcfaDqK61d3m5AmLdb/6fIxIA+u/X3ReV0QsUxVz8qV1+qs4ZU010h1QQJqTzodONpNaDKz+RAxQHteNumF+nJ6cxNnEuYT5gHZynaOGprqVq+guoPP0SxqBtL+IwbR8SDD+I3eZKHZ3f5KjlZy79f3Ye91UnyqDB+dPcoDMbeu8RSQinP6NGhVGtrK76+vvzzn//k2muv1Y4vXLiQ2tpaPv/8807X+fGPf0xoaCi+vr58/vnnREREcOONN7J06VIMZ2mQ19LSQkuHHXzq6+tJSEiQUEpcVJ/sKeKX/9iPosBt0/rxxE+GSSDVk1jrYccytTKqbQemsEGuyqj/An3v/uant3MqTvaV79OCqDJLmXbOx+jDrPhZpCWlMT1uOr4mXw/O9PJlKy6mSQuhdmErKOg0xmvw4A4hVArGMPmw90O02B2cKG3Udv07XFLHsdMNtDralz36OiHSoScJI/2NJkJawdDs7PLnBYZ7E5EYSGSHnfC8/aVx90WhKO0hVdtyv7adWtsYvdsrqZKmQXyKhFQeUtJYolVQHaw8qB3X6/SkRqeSkZzB3MS5shlGD2Cvrqbq3feoWblS24HVd9IkIh5cgu/48R6e3eWp6Fg1X7xxAIfNSf9xEaTfMQKDoXcGUxJKeUaPDqVKSkqIi4tj69atTJkyRTv+61//mg0bNrBjx45O1xk6dCh5eXncdNNN3HfffZw8eZL77ruPJUuW8Lvf/a7L23nyySf5/e9/3+m4hFLiYvn3/hIe/NtenArcMjmJP1wzQgKpnsJa5wqj3mgPo8IHuyqjfiZhlAc5nA72lO8hKy+LNQVrqGiu0M75mfyYGT+TjKQMpsZNxcfo48GZXn4URcFWUKBVQTXl5GAvOe0+SK/He+jQ9p5QEyZgCA72yHz7qqa6Fk7n1nP8WBUlp+poLm/GYO06gKrWO6kyKejDvAhPCGDIsFBG9wulf4Q/Br28HnU7RYGK4+1L/fI2Q1OF+xijN8Snupb7TYO4FDDJh6JLraihSAuoDlcd1o4bdAa3gCrEO8SDsxS28nKqlr1D7d//juLamdVvxgwilizBZ9RID8/u8lNwpIov3zyA064wKCWSebcOR98LgykJpTyjz4VSgwcP1u5UW2XUyy+/zIsvvsjp06c7jQeplBLd6+tDpdy/cg8Op8INqQk8c90obUmF8CBrHWx/G7a/of4/qGHUrKUw4joJozzE7rSzq2wX2XnZrC5YTbW1vZFwgCmA2QmzSU9OZ0rsFLwMUlFwqSiKQuupU1oVlCUnR9uyW2Mw4D1yBH6pqfikpKghVID08boYFEWhqbaVioJ6tx5QlrrWzoN1EBTpg3ekD42+egoVOweaLBwsb8Bq6xxY+ZoNDI8JZGRckLYEcECEH8Ze+GGiV1EUqDzRXkWVtxmaznxMeamVVEnT1OV+8akSUl1ihQ2FZOVlkZmXydHqo9pxg87ApJhJWkAlm2d4jq2khMq33qb200/BbgfAf+5cIpYsxnuI9G29lPIOVvKftw/idCgMmRTNFQuH9brPPL01lFq0aBHvv/8+ACaTicTERBYsWMDjjz+O1WolJCSEDz/8kBtuuEG7zg033MCqVavIzc0lOTlZO56cnMwtt9zCH//4R959910++OADDh1S+yFPmDCBZ5555js3ndu8eTNLly7l2LFjWCwWkpKSuPvuu3n44YfPep2LEUp1W4OV8PBwDAYDZWVlbsfLysqIjo7u8joxMTGYTCa3pXrDhg2jtLSU1tZWzObOfRG8vLzw8pIPN+LiW3O0jMUfq4HUz8bFSSDVEzTXqpVRbmHUEHWZnoRRHmFz2sg5nUNWfhZrC9ZS09K+7XqgOZArEq8gLSmNyTGTMRukt82loDidtHzzDZadOWpz8l27tK252+hMJrxHj8Y3NUWthho7Fr2f9PC6UIqi0FjT0h4+uXpANdd3DqB0OgiO9iMi0Z/IxEAiEgMIT/DH7N35rZnd4eTbiiYOFtdxyHU5XFKPpdXBrvwaduW3P+68TXqGxag7/o2MVcOqQVH+mCSounh0OogYol5S73CFVN+4V1I1lrlCq02wATWkik9p70kVnwomqRLtTgkBCdw+6nZuH3U7BfUFZOVnkZWXxdHqo2wt2crWkq38cdsfmRQ7iYykDK5IvEICqkvMFBtLzB//QNidd1D5xpvU/fvfNK5ZQ+OaNQRc+SMiHngArwEDPD3Ny0LyqHAy7hjJ1+8e4viOUvRGHXNuGopOPvtcEj/60Y9Yvnw5LS0tfPXVV9x///2YTCYee+wxUlJSWL9+vVsotX79ehISEli/fj2LFi0CIDc3l/z8fK644gptzPz585k6dSre3t48//zzpKenc/jwYeLOshmNn58fDzzwAKNHj8bPz4/Nmzdz99134+fnx1133dVt97/bG51PnDiR1157DVAbnScmJvLAAw902ej88ccfZ+XKlZw6dQq9Xn3z9Oc//5nnn3+ekpKSc7pNaXQuLoYNJyq48/1dtDqc/GR0DK9cP1a+efak5lrY8TZsexNaOoRRs5fC8GsljLrEbA4b205vIzs/m7UFa6lvrdfOBXsFMzdxLulJ6aTGpGLSS4+b7qY4HFiPHlMroXbtonnXLm0L7jY6Ly98xo7VekL5jBmNvhd9i9gTKYpCQ5WVikJXA/ICVwDVYOs0VqeDkBg/IhMDiHD1gApPCMDkdf7PXQ6nQm6lq0dVUT2HStSm6k2tjk5jzUY1qBoZ6wqr4oIYHBWAuRc3tO3RFAWqTrpXUjWWuo8xmNUlfm0hVcJECakukfz6fK2C6njNce24UW9kSswUMpIzmJM4h0CzfI641FpOnaLy9dep/+o/6gG9nqCrf0L4/fdjTkz07OQuE9/sKiP7fw+jKDByZhwz5w/uNW1LzqzYURQFpbnrnWm7m87n3HfWXbRoEbW1tXz22WfasfT0dBoaGti2bRuPP/44n3zyCceOHQPg6NGjTJkyhaVLl3L8+HFWrFgBwPLly7n33nupra3tslLM4XAQEhLC66+/zoIFC875vvzsZz/Dz8+PDz/8sMvzPbpSCuCRRx5h4cKFpKSkMHHiRF555RWampq49dZbAViwYAFxcXE8++yzANx77728/vrrPPjggyxevJhvvvmGZ555hiVLlnTnNIVws/VkJXd9oAZSGSOi+JMEUp7TXAvb31IvbWFUxFC1MkrCqEuqxdHCtpJtZOVlsb5wPQ22Bu1cqHco8xLnMS9pHqnRqRj1ssthd1JsNqyHD6uNyXftonn3Hm2r7TY6X198x43TekJ5jxyJvotqY3FuFEWhvtLqqoBqW4bXiLWpcwCl1+sIiXUFUK5LWLw/JvPFfb4y6HUMjAxgYGQA141TjzmdCrlVTVo1lbr7Xz0NLXb2F9ayv7BWu77ZoGdIdIC27G9kXCBDogPwMsrz6gXT6SB8kHpJuc0VUn3bXkmVu0kNqQq2qpeNL5wRUk2D+Ilglo0fukNSYBJ3jr6TO0ffSW5dLll5WWTlZ3Gi5gSbijexqXgTxm1GpsVOIyM5g9kJswkwy3LmS8Grf3/iXn6ZsLvvpuK112hcvYa6z/9F3RdfEvyz6wi/915MsbGenmafNiglCqdDYfWKIxzaWIzBqGfafw/sNcFUR0pzM8fHT/DIbQ/Zsxud7/k/h/v4+FDlqnKfM2cOzz77LKdPnyYmJoZ169Yxffp0rrjiCpYtW6ZdZ926dUyZMuWsSxctFgs2m43Q0HPf9GHv3r1s3bqVp5566rzvy7no1k8O119/PRUVFfz2t7+ltLSUsWPH8vXXXxMVFQVAQUGBVhEFkJCQQGZmJg8//DCjR48mLi6OBx98kKVLl3bnNIXQ7Myt5vb3d9FidzJ3aCSvzR8vSx48obmmQxjlqsKJGNYhjJJ/k0vBareypXgLWflZbCjaQJOtSTsX4RPBvKR5pCWlMT5yPAYJCLuNs7UV64ED6lK8nTlY9u3TttRuo/f3x2fCePxclVDew4ejM0mV2vlQnAp1Fc1u/Z8qCxtosdg7jdUbdIS2BVBJ6hK8sDg/jCbPPB70eh0DIvwZEOHPNWPV0nynU6Gg2tK+9K+kjoNFddRb7dpOgB+7rm8y6BgcFaAu+4tXw6qh0QF4e+j+9Bk6HYQPVC8pt6ohVfUp90qqhpIOIRWgN7Uv90uaBgmTJKTqBv2C+nH3mLu5e8zdnKo7RWZeJll5WZysPcmGog1sKNqASW9iWuw00pPTmZMwB3+zv6en3ed5DxlCwuuv03zwEBWvvUrTxk3U/uOf1H72OSH//d+E3X03pqhIT0+zzxoyKRqH3cm6D4+xf20heqOOKdcN6JXBVG+jKApr1qwhMzOTxYsXAzBt2jTMZrO2HG/9+vXMmjWLCRMmUFlZqVUpbdiwgdtvv/2sP3vp0qXExsYyb968751HfHw8FRUV2O12nnzySe64446Ldh+70q3L9zxBlu+J87WnoIZb3ttBU6uDmYMjeHfBBPnG+FKzVKtB1I6328OoyOFqGDXsGgmjLgGLzcKm4k1k52ezsWgjzfb2suco3yjSktJIS0pjbORY9Dr59+gOTquV5n37td3xmvfv17bObqMPCsI3JUXrCeU9dCg6gzxf/VCKU6G23KKFTxX5agDVau28BE5v1BEe5094YoBWBRUW64/B1PseB4qiUFjdrAZUHaqqai2dK78Meh2DIv21ZX8j44IYHhOIz0Wu/LqstYVUbf2ocjepIVVHehPETXBf7meWPnDd5dvab7Ulft/WfasdN+vNTI2bqlZQxc+WgOoSsezZS8Wrr2LZvh1Ql6SHzJ9P2J13YAwL8/Ds+q5DG4vZsFJd4ppyVTKTru7v4Rl9t968fO+jjz7C29sbm82G0+nkxhtv5M0338TP1e9z+vTpjBgxgmXLlhEVFcUXX3xBamoq6enpzJ8/n1mzZjFgwAA2btzIjBkzOt3Gc889xwsvvMD69esZPXr0984pNzeXxsZGtm/fzqOPPsrrr7/O/Pnzuxzbo3ff8xQJpcT5OFhUx43vbafBamfqgDD+sihVvhm+lCzVsP1NdUe9VteysMgRrjDqpxJGdbMmWxMbizaSnZ/NpqJNWB1W7VysXyzzkuaRnpzOqPBREkR1A2dTE5a9+7SeUNYDB7QtstsYQkO1flC+qal4DRqITh4XP4jTqVBbanEtv2ukvKCeysJGbC2dAyiDSU94vD8RCa4eUIkBhMb4YejDPZgURaG4tlkLqA4V13OouI6qps5N2vU6GBQZwIg4tUfVqLgghsUE4uclS3cvCkWBmlw1oMrbolZU1Re7j9EbzwipJklI1U1O1pwkMz+TzLxMcutyteNmvZnpcdPJSM5gVsIs/Ezy99/dmnbspOLPf6Z5zx5AXaoeevPNhN12K4bgYM9Oro/av6aQzf/4BoBJP+1Pyo+TPTuh79Cbd98rLi7mrbfewmw2Exsbi9Ho/nr6xBNPsGrVKj799FOmTJlCTU0NBoOBp59+muPHjzNr1iyWLFlCTU1Np83hXnrpJZ566ilWr15NSkrKD57fU089xYcffsjx48e7PC+hVBcklBI/1JGSeua/u526ZhsTk0NZcVsqvmZ5Y31JWKph2xvqjnptYVTUSDWMGnq1hFHdqKG1gfWF68nOz2ZL8RZane0fPOP940lLTiMjKYPhYcOlXPsiczQ0YNm9m+Zdu2jKycF6+Ii2FXYbY2SkK4BSK6HM/fvLv8MP4HQ4qSltr4CqLGigoqgRexcBlNGkJzzBnwjXDngRiQGExPhikKXbKIpCab2Vg0Xt1VQHi+upbGzpNFangwERHSqqYgMZEReEvwRVF05RoCbPvZKqvsh9jN4IsePdQyovqeK5mBRF4Zvab7QKqrz6PO2cl8GLGXEzyEjOYGb8THxNstSyuyiKQtPmLVT8+c9YXVvd6/39CV20iNBFCzH4y+/9xbYnK59tn6gVg1N/NpBx6T2z6XxvDqXObHR+prVr1zJ37lwef/xx9u7dy1dffQXApk2buPnmm5k5cyZlZWVkZWW5Xe+FF17g6aefJjMzk8mTJ5/X/P7whz/wl7/8hby8vC7PSyjVBQmlxA9xoqyBG97ZTnVTK+MSg/nw9knyBvpSsFTDttdhxztnhFFLYehPJIzqJnUtdawrXEd2fjbbSrZhc7ZX4yQFJpGelE5aUhpDQ4dKAHIROWprsezerfaDysnBeuwYOJ1uY0yxsW4hlCkxUf4NzpHD4aTmdBPl+Wr4VF7QQFVRI3abs9NYo5eBiHh/NXxyVUCFRPmilwDqBylrC6pK2sOqsvqug6p+4X6MjA3SwqoRcYEEeku/swuiKFCb715JVVfoPkZvhNhxrp5U0yFxEnhJs+6LRVEUTtScIDNPraAqaCjQznkbvJkRrwZUM+JmSEDVTRRFoXHdOir+/CotrgoOQ1AQoXfcTuhNN6G/gCbTorNdX+Wy419qpeD0XwxizBUJHp5RZ305lLJarQQHB2M2m/nNb36j9dxuaWkhODgYk8nEY489xmOPPaZd5/nnn+e3v/0tK1euZNq0adpxf39//M8S3r7xxhskJiYydOhQADZu3MjDDz/MkiVLztrsXEKpLkgoJc7VtxWNXL9sO5WNLYyKC+KjOyYR5CNvlLtVU5UaRu18B1pdu4VFj4JZj8KQH0sY1Q1qrDWsK1xHVn4WO0p2YFfaK3L6BfUjPSmd9OR0BgUPkhDkIrFXVWHJ2aX1hGo5caLTGFNSohpCpaTgl5qKKS7OAzPtfRx2J9UlTR16QNVTVdyEw945gDJ5GdTwqcMSvOAoX/R6+T3vDuUNVg4X12vN0w8V13G6ztrl2OQwX60/1ai4IEbGBhHkK6+/F6QmTw2o8l0hVW2B+3mdwRVSTYPkGZA4WUKqi0RRFI7XHNcCqsKG9oDQx+ijVVDNiJ+Bj9HHgzPtmxSnk4bMTCpee53WU6cAMISFEXbnHYTccAP6XhRO9HQ7/nWKXV/lATDrxiGMnNmz3rv05VAKYPbs2WzYsIHt27czadIk7ficOXNYv34927Ztc6uGSk5OJj8/v9PP+d3vfseTTz7Z5W289tprLFu2jNzcXIxGIwMGDODOO+/k7rvvdtugriMJpbogoZQ4F3mVTVz/zjbK6lsYFhPIx3dOIthXtkvvNk1VsO012Pmuexg1+zE1jJIw5KKqaq5ibeFasvKyyCnNwaG0L1kaFDKItKQ00pPSGRA8wIOz7DtsZeVaAGXJydHeFHdkHjDA1ZhcrYYyuXahFWfnsDmpKmmkPL+BikK1CXlVSSNOe+e3LWZvg7b0LiJJDaKCI33RSQDlUZWNLRwqruNwST0Hi9Swqri266azCaE+WjVVW1AV4ievy+etJr99uV/eZrWyqiOdAWLHupb7zVCX+3nL++YLpSgKx6qPaQFVUWP7Mksfow+z4meRkZzB9LjpeBt7z4fm3kBxOKj/4gsq3ngTW4EayhojIwm7525Cfv5zdGZ5PrlQiqKw7dNv2Zul/v3OuWUow6fFenhW7XprKNXbSSjVBQmlxPcprLZw/bJtlNRZGRzlz9/umkKovPHtHk2VsNUVRtma1GPRo2H2oxJGXWSVzZWszl9Ndn42u8p24VTaK0eGhg7Vds3rF9TPg7PsG2zFxTRpIdQu7c1vR16DB3doTJ4iuwN9D3urg6riJioK6tUKqIIGqoubcDo7v0Xx8jW2B1CuS1C4jwRQvURNU6vbrn+HiuspqLZ0OTYuuC2oCtTCqjB/r0s84z6itqB9qV+XIZUeYsa2h1SJkyWkukCKonCk+giZeZlk5WVR3NjerN7H6MPshNlaQOVlkN/ri0Wx2aj97DMq33oLe8lpQF0iH37fvQRdcw06k1RlXghFUdj8j284sLYIdDBv0XCGTIr29LQACaU8RUKpLkgoJb5LSW0z17+zjcLqZvpH+LHqrilEBMgbgYuuqRK2vgo732sPo2LGuJbpXSlh1EVS1lTG6gI1iNpTtgeF9qfz4WHDtR5RiYE9syFlb6AoCraCAi2AsuTkYCs5c6t2PV5Dh+DnCqF8JkzAGBLimQn3ArZWB1VF7hVQ1aebULoIoLz9TFrlU0RiAJFJAQSEectS0z6mzmJz6091qLiOvKqug6rYIG9GuAKqUa4eVZEB8uHjB6stbF/ql7dF3e2vI51efd12C6mCPDPXPkBRFI5UHdEqqEqa2l9HfI2+WkA1LW6aBFQXibO1ldp//IOqt5dhr6gA1KXzEfffT+BVV6EzyC7b50tRFDZ+fIJDG4vR6SDt9hEMSvF8BbiEUp4hoVQXJJQSZ1Neb+X6d7aTW9lEUpgvq+6aQnSQPGFdVI0VahiV8x7YXB8oYsaqlVGDfyRh1EVwuvE02fnZZOdns69in9u50eGjmZc0j7SkNOID4j0zwV5OURRaT51y6wllLy93H2Qw4D1yRPtyvAkTMARIb5autFrtVBY1UuGqfqooaKDmdBNdvfPwCTBp4VNbD6iAUAmgLld1zTaOlNS7BVWnKpu6HBsV6KUGVB0aqkcFesnvzg9RV+TqSeVa7ld9xjJknV6tdG7b3S9xCvgEe2SqvZ2iKByqPKQGVPmZlDaVauf8TP9/e3ceH1V57w/8M/s+k22yJxP2JQECZCEsIkiSWrVqF5daxaUuVQH1d28Xb9d7a63a9lpAC2rrUktFvUWrtSZh3yEBAkmAsGay78ns+zm/P87kTIYZJGyZSfJ9v168KOc8k3mSeiZnPvN9vo8KSzKWoDSrFPNT50Mqokr+q8U4nej74AP0vPEmfL29ALgl9foVT0NTUgIB9TO9IizDYtvfTuLEnjYIhAJ87bEcjM/VR3ROFEpFBoVSYVAoRcLptrpwzxv7cabTivRYBTY+XoS0GGo2ec1Yu4C9fwQq/0xh1HXQYm1BRQMXRB3rPhZ0Llefi5KsEizLXIYUdUqEZjhysQwD1+nTgRCqqgq+np7gQRIJFDNnBkKo2bkQqlSRmXAUczu96G6ycBVQAwFUhx0IF0BppUi8YAmeOpZCBPLVLE4uqOKX/rWacbbLGjbkTFDLMCNN66+m4sKqFB2FnENmagGMewPL/XrPXjBAAKTM5Hb2y1oIGIoABVWIXi6WZXGs+xi/xK/D3sGfU0vUfEBVlFpEAdVVYmw29P5tA3r+/GcwJhMAQDZ1KvQrV0C9ZAm9NlwBhmGx9d0TqD/QDqFIgJufmIGsGQkRmw+FUpFBoVQYFEqRC/XZ3Lj3zf042W5Bik6ODx8vQkYcbRN7TVg7gT1/BKr+EgijUudwYdSkEgqjrkKjuRHlxnJUGCtwvOc4f1wAAeYkzUGxoRjLMpchSRX5cumRhPX54Dx5kl+O56iqgs9/czpAIJNBMWsW3xNKkTuLdu+5gMvhRffADnj+P/2d4QMolU46qAm5FomZGih1UnoDQK4Jm8uL421cI/WBJYBnOq0IsxoU8Sqpf9c/LV9RlRajoP8Wh8LcGuhJZdwD9Jy5YICA28AkaxG3w59hPoVUl4lhGRzr8gdUxnJ02gNVuhqJBksy/QFVShEkIuqLdKV8Fgt6330Pve+8A8bKbb4jnzED+pUroVq4gF4PLhPjY1Dx9nGcqeqEUCzALU/OROb0yPTRpFAqMiiUCoNCKTKYye7Bd9/aj7pWMxI1Mnz4eBGyEqjC4apZOvzL9P4MeP07KaXN5XpGTSqmMOoKnTed55fmnew9yR8XCoSYmzQXJYYSLDMsQ4Iicp9CjTSsxwPn8eOwV1bCVlkJx+EjYCyWoDEChQLK2bOhLOBCKPmMGRDSLj08p83D934a+NvUFX4HNXWsLKQJuUpH/VHI8LK7vTjRZgla+ne60wpfmKQqVinxB1Xcjn8z0nTIiKOg6pLMbYN6Uu2+SEiV4w+p/Mv9lHERmepIxLAMjnYd5Suouhxd/DmNVIObMm9CaVYpClMKIRFSQHUlfP396PnL2+h9/32wdu6DVcXcuVw4VVgQ4dmNLD4fg/I363CuugsiiRC3Pj0L6VOGP5SmUCoyKJQKg0IpMsDs9OD+tw7gaLMJCWopPnisCBMT1ZGe1shm6QhURg0Oo278CTBxGYVRV+Bs/1mUG8tR3lCOM/2Bm3qRQISC5AIUZxVjacZSxCto97ahYNxuOGtqAsvxjhzhbzYHCFUqKObOgTI/H6r8fMizs2k3Hj+n1YPORnNQDyhztzPsWE2cPNCE3P+3UkthHolOTo8PJ9rMqG01o7aZC6tOdVjgDRNUaeVifre/gcDKEKeEkHZ4vDhLOxdODfzpOX3BAAGQlBPoSWWYTyHVEDEsgyOdR1DWUIYKYwW6Hd38Oa1UywdUBSkFFFBdAW9PD3refAt9f/87WJcLAKAsmgf9ypVQzp4d4dmNHD4vgy/X16ChpgdiqRC3rcxF6sSYYZ0DhVKRQaFUGBRKEQCwurxY/peDOGTsQ6xSgg8eK8KUZGpEfMUs7YPCKP8b1LQ8fxh1E4VRl4FlWZzqO8VXRJ0zBZrJigVizEudhxJDCZZkLEGMPCZyEx0hGKcTjqPH+Kbkjupq/qZygFCng3LuXH45nnzqFAjE4gjNOHo4LG5u+d2gHlCW3vABlDZBzlc+JWZqkZCphkJNARQZ2VxeH+rbLf5qKq6pen27BW4fEzJWIxMje9Cyv5w0HcbFqyiouhhLu7+Syh9SdZ8KHRMUUi2gkGoIfIwPhzsPo6yhDJuNm9HjDPRA1Ml0WJa5DCVZJShILoBYSL/nLoenoxM969ej76OPAI8HAKBafAP0K1ZCkZMd4dmNDF6PD1/8qQZNx3shkYvwjVW5SB43fLt2UigVGRRKhUGhFHG4fXjw7YM4cL4XWrkYGx6dh5w02sb4iljagd2vAofeDoRR6fncMj0Ko4aMZVmc6D3BB1FGs5E/JxFKMD91PooNxbgx40boZPTf6ldh7HbYjxzhe0I5jx0D6795HCCKiws0JS/Ih2zSpDG/u47d7EanMbgCytrnCjtWq1cEmpD7K6DkKvr0nYwNbi+DUx3BS/9OtFvg9oYGVWqZGNNTtdyyv3QusBqXoIaIgqpQlg7/zn7+oKq7PnRMYnZwSKWiCuGvMjigqjBWoNfZy5+LkcXwFVT5yfkUUF0GT0sLutetQ/8/NgE+HwBAU7wMCU+vgHzK5AjPLvp53T58/tpRtNT3Q6oQ4/ZncpFoGJ735BRKRQaFUmFQKDW2OT0+fP/dKuw+0w2NTIz3v1+IWRkxkZ7WyGNuA/a8ClS9Dfj8b1zTC7gG5hOWUhg1BCzLoq6njmtW3lCBZmszf04qlGJh2kIUZxVjcfpiaKRUxXcxPqsVjkOHYK+qgv1gJRx1dYDXGzRGrNf7q6C4IEo6YcKY7QfDsizspoEKKDO6mqzoMpphM7nDjo9JUgb3gMpQQ6akAIqQwTw+Bqc7rIGgqtWE461muMIEVUqpCNNTtEHL/yboVRCLxnYwHsLaGVxJ1XUydExiNtc0nQ+pqJ/ixXgZLw51HOIrqPpcffy5WFkslhmWoTSrFHOT5lJANURuoxFdr70G82efAywLCATQ3nwzEp5+GrLx4yI9vajmcfnw2ZpqtJ0xQaYS445nZyMh/frf647UUOrBBx/Eu+++CwCQSCTIzMzEAw88gOeffx5OpxOxsbH461//invuuYd/zD333IONGzfi/PnzyMrK4o9nZWXh/vvvx//8z//gzTffxHvvvYfa2loAwNy5c/Gb3/wGBQVD65m2Z88eLF68GDk5Oaiurr7oOAqlwqBQauxyeX14/K+HsL2+C0qpCH99pABzDVQKflnMrf7KqHcCYVRGIRdGjV9CYdQlDOycM1AR1WZr48/JRXIsSl+EEkMJFqUvgkpCDffD8fX3w374MOwHueV4zhMnACb4jZ84NQWq/Hwo8vKgys+HxGAYkyEUy7Kw9rmCqp86Gy1wmMMEUAIgNknJVz4lGjRISNdAqqA3J4RcCa+PwdkuG19NVdtiQl2rGQ6PL2SsXCLkg6qBhuqTktSQUFAVYO26IKQ6ETpGPy24kkqtH/55jgBexovK9kqUG8ux2bgZ/a5+/lycPA7FhmKUZpViTuIciISiyE10hHCdOYOuta/B8uWX3AGhELpvfAMJTz0JaUZGZCcXxdxOL/75x2p0nDdDrpbgjudmIz71+vb2HcmhVEdHB95++224XC588cUXeOqpp/DCCy/gJz/5CYqKijBr1iysW7eOf0xycjKkUin++7//Gw8++CAA4Pz58xg/fjy2bt2KJUuW4L777sOCBQswf/58yOVyvPTSS9i0aRPq6uqQlpb2lXPq7+/H3LlzMXHiRHR0dFAodbkolBqb3F4GT/7tMDaf6IBcIsS7DxWgcDyVfQ+ZuRXY/b/AoXcHhVHz/GHUjRRGfQWGZVDdWc1VRBkrgrZwVogVWJy+GMWGYixMWwilRBnBmUYnb08P7FWH+J5QrlOnuE8kB5FkZgaW4+XnQ5r+1b9IRyOWZWHpdXLh00APqCYLHBZPyFiBAIhNUQ3qAaVBfLoaUjkFUIRcTz6Gxbkua1CPqrpWE2zu0KBKKhZiWooWM9K45X85aTpMTtJAKqagCgBg6w4OqTqPh47RTx0UUi2kkCoMD+PhAqqGcmxu3AyTy8Sfi5fH8wHV7MTZFFBdgvPECXStWQvr1q3cAbEYMd/8JhJ+8AQkKSmRnVyUctk9+PTVanQ1WqDQSnHnc7MRm3z9PpQdyaFUf38/PvnkE/5YSUkJLBYL9u3bh+effx7/+Mc/cPIkV1F64sQJFBUV4Uc/+hHq6+vxzjvvAADefvtt/OAHP0B/f3/Y79/n8yE2NhZr167FAw888JVzuueeezBp0iSIRCJ88skn1z2UojtUMuJ5fQxWfXAEm090QCYW4s/L8ymQGipTCxdGHX4X8PmrKzKLuDBq3GIKoy5ioI9DeUM5tjRuCdqqWSVR4Yb0G1BqKMWCtAWQi0fOL8Xh4OnohL2qku8J5T57NmSMdNw4PoBS5udBkpwcgZlGDsuyMHc7B1VAmdHVaIXTFiaAEgoQl6KCPlMNfaYWiQYugJJI6c0FIcNNJBRgUpIGk5I0+OYc7hjDsDjXbUNdqwk1/l3/6lrNsLq8ONrUj6NN/fzjpSIhpqZokJ3KLf2bkabD5GQ1ZOIxeD2rEoDpt3N/AMDWc0FIVcct+es6CVS+xY1JmBIIqbIWAurEyM0/Sgz0rZyfOh//Ne+/cLDtIF9B1ePswQf1H+CD+g+gV+j5JX6zE2dDKKBw9ELyadOQ8fprcNTUoGv1Gth27UL/hx/CtGkTYu66C/GPPwZJIv03N5hMKcE3VuXik/89gp5mKz793yO48z/mQKcfng9pWZaF1x26zHo4iKXCq6riVygU6OnhNjJYsmQJXnzxRbS1tSElJQXbtm3DwoULsXTpUqxfv55/zLZt21BUVHTRQM5ut8Pj8SAu7qtXEr399ts4d+4c3n//ffz617++4u/hclClFBnRfAyLZzdW459HWyEVCfHGA3Nx4xT6hXBJpmZ/GPXeoDBqPnDjjyiMuggv40VVRxUqGiqwuXFzUENRjUSDJZlLUGwoRlFqEWQiWQRnGl08ra2wV1bC5q+E8hgbQ8bIJk3im5Ir586FWD92Pu1mWRamLkegAqqJC6Jcdm/IWKFQgLg0FV/9lJCpQUKaGmIKoAgZURiGhbHXHrT0r7bFBLMz9LqXiASYnKTh+1PNSNNhSrIGcskYv+5tPUDjXuD8Li6s6qgNHZMwZVBPqoWAJmn45xmlPIwHB9oOoKyhDFsat8DitvDnEhWJKM7iKqhm6WdRQHUR9sOH0fXqH2E/eBAAIJDJEHvffYj//iMQX+JN/1jjsLjxyf8eQW+rDeo4Ge78f3OgjVdc8+e5sGLH4/LhjVU7rvnzDMVjf1wMiWxor9ODK6VYlsWWLVtw6623YsWKFXjllVdgt9sRGxuLd955B/feey/uuusu5Ofn49lnn0VMTAxqamowbtw4GAwGPPLII/j5z38e9nmefPJJlJWVoa6u7qLB1enTp7Fw4ULs2rULkydPxi9/+cthqZSiUIqMWAzD4of/dwwfH2qGWCjAuu/NxbLpdMPxlUzNwK4/AEf+GgijDAu4yqisRRRGXcDDeHCw7SAqjBXY0rglqC+DVqrF0sylXBCVUgSJiJpDsywLT1MTVwXl7wnlaW0NHiQQQDZtamA5Xl4exLGxkZnwMGMZLoDqbDQPCqCscDvCBFBiAeJT1UE9oOJT1RBJ6M0BIaMRy7Jo6nWgpmWgmor7u98eWiEp9ldkzUjjdvzLTtNheop2bAdV9l5/JZW/mqqjJnRMwmTunmegkkoztqpwL8bj82Bf2z6UN5Rja+NWWDyDAiplIkoMJSjNKsVM/UwKqMKw7d+Prj+uhuPIEQCAQKlE3P33I/7hhyDS0Y7KA2wmFz75wxH0d9ihTZDjzv83B+rYa7uaYCSHUu+//z43Z48HDMPgu9/9Ll5//XWoVNxyx4ULFyI7Oxvr169HUlISPv/8c+Tn56OkpAT33nsvFi9ejAkTJmDnzp1YtGhRyHP89re/xcsvv4zt27dj5syZYefh8/kwb948PPLII3jiiScAgEKpK0Wh1NjAsiye31SLvx9shEgowNp7Z+PmGbSe+6IGwqjD7wGM/wbXsNC/TC/0hWssG7g5qzBWYGvjVpjdZv7cwBbLJYYS5KfkQyIc20EUy7Jwnz8Pe2UV3xPK29ERPEgkgjw72x9C5UE5dy5EY+C1mWFY9HfYg5qQdzVZ4HGG9pYRiYWIT1NBb9Ai0d8HKi5VBRH1liFkTGNZFs19Dq6SqtWEGn+fql5b6GYGIqEAkxLV/qV/WsxI12FaihZK6Rjt1GHvBYx7/UHVLqC9FsAFb3niJwU3TtfSfaTb58b+tv0oayjD1satsHqs/LkkZRJKsvwBVcLMMbnByMWwLAvbrl3o+uNqOOvqAABCjQZxDy5H3PLlEKmvb4PvkcLa58KmPxyGucsBXaICd/6/OVDprt3qggvDkZGyfO/BBx9ES0sL/vSnP0EqlSI1NRVicfBr989+9jNs3LgRmzZtQlFREfr6+iASifDCCy+gvr4eixcvxsqVK9HX1wepVBr02N/97nf49a9/jc2bNyMvL++i8+jv70dsbCxEokCYxjAMWJaFSCRCeXk5li5dGvI4CqXCoFBq9GNZFr/8Zx3e3WeEUAD87925uD137DU+HpL+JmD3H4DDfw2EUVmLgMU/ojBqEJfPhb0te1FhrMD2pu1BnxLGyeOwLHMZirOKkZeUN6a3UmYZBq4zZ/h+UPaqKvi6u4MHSSRQzJjBV0EpZs+GSD26dxpkfAz62u1c5dNAE/JmK7yuMAGURIiEdDW//C7RoEFsigoi2oWLEDIELMui1eTkl/wNLAHstoYGVUIBMEGv5qupZqTpMD1VC7VsDP4es/cCjfv8lVS7gPYahIZUEwNL/bIWjvmQyu1zY2/rXpQ1lGFb0zbYPDb+XIoqha+gyknIoYDKj2VZWLdsQdfqNdzGLQBEOh3iH/0+Yr/7XQiVtOGNpdeJTb87DEuvE7HJStzx3BwotdJLP3AIRlOj8wtt3boVN910E55//nkcOXIEX3zxBQBg165d+N73vocbbrgBHR0dKC8vD3rcyy+/jBdeeAFlZWWYN2/eV86DYRgcPx68qcTrr7+OrVu34uOPP8a4ceP4yq3BKJQKg0Kp0Y1lWbzwrxN4a/d5CATAK9+ehW/PTY/0tKJPf6N/md77wWHUjT/mbrQInF4n9rTsQbmxHDuadwTdbA00/Cw2FI/pLZNZnw+u+nq+J5Sj6hB8/f1BYwRSKRS5uVwlVEE+FLNmQai49n0CogXjY9DbZueaj/uX4HU3WeH1hH4SJ5YKoc/wh0/+CqjYZCWEFEARQq4hlmXRYXYF9aiqaTGh0+IKGSsQAOMSVHwj9exUHXLStNDIx1jlr6MPMO4LVFK1HUNISBU3IbhxujY1IlONBi6fC3ta9qCsoQzbm7bD7rXz51JVqSjNKkVJVgmy47MpoAL3IZ7lyy/RtWYt3OfPAwBE8fFIePwxxNx9N4Sysd171NTlwCd/OAxrnwvxaSrc8ewcyNVX/xo0mkMpp9OJmJgYSKVS/Nd//Rd+9KMfAQBcLhdiYmIgkUjwk5/8BD/5yU/4x7z00kv4+c9/jg0bNmDBggX8cbVaDfUQq/dG1fK91157Da+88gra29sxa9YsrFmzBgUFBZd83AcffIB7770Xt99++1f+nzQYhVKjF8uyeKWsHq9v53br+u03Z+CegswIzyrK9DcCu34PHPnbBWHUT7hmn2Oc3WPH7pbdqDBWYEfzDji8Dv5ckjIJxYZilGSVjNnGnqzXC+fx44FKqEOHwFgsQWMECgWUs3P53fHkM2dCKL02n3BFG5+PQW+rjW9C3tloQU+LFb4wAZREJkJChhqJmVp+J7yYZCWEQro5J4RERqfZyS37azajtpULq9pMzrBjxyWo/I3UtchJ5SqrdIoxFFQ5+oHG/VxA1bAbaD8GsBe81seN9/ekWsTdU+nG5oeiAx/qlRm5gGrwvVSaOo1f4jc9bvqYD6hYrxemzz9H92uvw9PUBAAQJyUh4QdPIOab34RglN4/DUV/hx2b/nAYdpMbCRlq3P7MbMhVV/eaM5pDKQC48cYbsWPHDuzfvx+FhYX88SVLlmD79u3Yt29fUDVUVlYWjEZjyNf5xS9+gV/+8pdDmtuoCaU2btyIBx54AOvWrUNhYSFeffVVfPTRR6ivr0fiV2yb2dDQgIULF2L8+PGIi4ujUIrg1c2n8Orm0wCA/749Gw8UZUV2QtGkz8iFUdV/Axh/0+Rxi7nKKMP8yM4twmweG3Y270SFsQK7mnfB6QvckKeqUlFsKEZxVjFmJMwYc0EU63bDUVvL94RyHD4Mxm4PGiNUqaCYOwfK/Hyo8vMhz86GQDL63qj4PAx6Wq1BPaB6WmzweUMDKKlcBH1mcAVUTKISAgqgCCFRrtvqumDpnxkt/Y6wYw3xSuSkBnb9y0nTIkY5Rt5EO03BIVXb0dCQKjbLX0W1iPt7DIZUTq8Tu1t2o6yhLOTDvnR1OkqzSlGaVYqpcVPHdEDFejzo37QJ3X9aB29bGwBAkpaGhCefhO72b0AgHoNLagH0ttnwyR8Ow2HxIDFLi9tX5UKquPKfxUgNpUa6ERFKFRYWIj8/H2vXrgXArVXMyMjAihUr8OMf/zjsY3w+H2644QY8/PDD2LVr15CSwwEUSo1Or28/g5e/rAcA/PSWafj+ovERnlGU6Gvwh1EbAmHU+BuBxT8GDEWRnFlEWdwW7GjegYqGCuxp3QOXL7CEIV2djpKsEpQYSjA9fmx9ise4XHAcPcpXQjmqq8E6gz81F+p0UM6dy++OJ582ddTdLHk9PvQ02/w9oMzobLSgt9UGxhf661CmFCMhIxA+6TM10OkVFEARQkaNXps7qD9VbasJTb3hg6r0WIU/oPL/SdUiXj0GliLxIdVuf0hVHT6kMgxa7heTEYmZRozD68Cu5l0oN5ZjZ/POoIAqU5PJL/GbEjtlTN17Dca43ej/8CN0r18HXxfXk1NqMCDh6aeh/frNEIjGXruInhYrPvnDEThtHiSP1+G2lbMglV/ZfSeFUpER9aGU2+2GUqnExx9/jDvuuIM/vnz5cvT39+PTTz8N+7hf/OIXOHbsGDZt2nTJcjaXywWXK/CG02w2IyMjg0KpUeStXefw63+dAAD86GtT8YMbJ0R4RlGgrwHY+Tvg6N8HhVFLuMqozK9uYjdamVwmbG/ajgpjBfa27oWHCWyjbdAaUGIoQbGheEx9WsfY7XBUV8Pm3xnPefQYWE/w9uKi2Fg+gFIW5EM2eTIEwtFTMeZ1+9DdzFVAdforoPpabWCYMAGUSgx9Btd8XO9fhqdNUIyZ/14IIWRAv92N2hazf9c/Lqwy9tjDjk3VyQdVU3F/9JpRHlQ5zVxIZfSHVK3VAHvB5hYxhsBSv6yFQMzYaTlh99ixs2UnyhvKQ6rUB+7JSrNKMTl28pj8Hcs4HOjb8Hf0vPUWfH19AADpxAnQr1gJTfGyUXUfNhRdjRZ8+uoRuOxepE6Kwa0rZkEivfyAjkKpyIj6UKq1tRVpaWnYu3cviooCVRs//OEPsWPHDhw4cCDkMbt378Y999yD6upqJCQkXDKU+uUvf4lf/epXIccplBod3t3bgF/8k9ta9dllk7Fq2aQIzyjCes8Du34HVP89cPMzYSlXGZVZ+NWPHYX6nH3Y1rQN5cZyHGg9AC/r5c+N041DiaEEJVklmBQzaUzc9PisVjgOHw5UQtXWAl5v0BiRPgEqfz8oZX4+pBMmjJqfjcc1EECZ+R5Qfe12sGECKLlaElT9pM/UQBMvHzU/C0IIudZMDg/qWgeaqZtR22LCuW5b2LHJWrk/oNLyTdUTtaP4TaLTDDQdCFRStR4JE1JlBpb6GRYAsYbIzHWY2T127GzeibKGMuxq2RVUvZ6lzeJ7UI2Ve7XBfFYb+t5/Hz1/+QsYsxkAIJs2DfqVK6C+8cYx9fPoaDDjn68egdvpQ/rUWNzy1EyIJZcXTFEoFRmjLpSyWCyYOXMmXn/9ddx8880ALt34iyqlRq8NBxrx/KYaAMBTSybgP0rGbrkves8BO3/PVUYNDqNu/AmQcelNA0aTHkcPtjZtRXlDOSrbK+EbdNM3KXYS16zcUIIJMaO/os5nMsF+6BDfE8p5/DjABC8nEKekQJmfx/eEkhgMo+I6cju96G4K9IDqbLSgv92GcL/RFFppSACljpWNip8DIYREksXpQV2rOahP1bnu8K/FiRoZX0k10KMqWTtKPwxwWYJDqpbDoSGVLjN4d78xEFLZPDbsaNqBsoYy7G7ZDTfj5s+N043jelAZSjExdmIEZzn8fGYzet95F73vvgvGxgW98lkzoV+xEqoF80fnNRJG21kT/rm6Gl6XD5nZ8fj6EzMgkgy9aoxCqciI+lDqcpfvVVdXY/bs2RANWk/L+N9gCYVC1NfXY8KEr36jST2lRoePDzXjPz8+CpYFHl00Ds9/fdqYeUEO0nOW6xl19IPAzczEZVxlVEZ+ZOc2jLod3dhs3IwKYwWqOqrADOrjMDVuKtes3FCMcbpxEZzl9eft7eUCqCouhHLV1+PCO39JRgZfBaXMz4c0PS1Cs712XA4vuhst6GqyoNPIhVD9nfaQ3bsBQKm7MIDSQhUjHZuvH4QQEgE2lxfH28yoaQ70qDrTaUWYolUkqKX+3lT+sCpdh1TdKAyqXNYLKqkOB9ovDNBlBIdUMQZgtP0cBrG6rdjRvANfNnyJPS17gtouTNBN4Jukj48ZO31kvX196P3LX9D7/t/AOrieXIq8uUhctQrK/LFx3996ug+frT4Kr4fBuFkJKH0sByLR0IKpgXAkKysLCoXiOs+UDHA4HGhoaIjeUArgGp0XFBRgzZo1ALiQKTMzE08//XRIo3On04kzZ84EHfvpT38Ki8WCP/7xj5g8eTKkl9g6k0Kpke/T6hY8u7EaDAs8OD8Lv7htbDWjBsCFUTt/BxzbOCiMKuZ6RqXnRXZuw6TD1oHNjVwQdbjjMNhBCUR2fDYfRGVqR2+PBk9nJxxVVXxPKPeZsyFjpOPG+QMorhpKkpwcgZleO06bB91Ngf5PXY0WmDrDN9xVx8q4JuQGDfQZGugNGqh0o7yPCSGEjEB2txcn2syobTHzPapOd1rhC5NUxamkyE7V8hVVM9J0SI8dZf393LYLKqkOhYZU2vRBIdUCIHbcqA2pLG4LtjdtR3lDOfa0BgdUE2Mm8gHVaP/wcYC3uxs9b76Jvr9/ANbNVZOp5hdBv3IlFLm5kZ3cMGg60Yt/vXYMPi+DCXP0KHkkG8IhBFM+nw+nTp1CYmIi4uPjh2GmBAB6enrQ2dmJyZMnBxUXAVEUSm3cuBHLly/H+vXrUVBQgFdffRUffvghTp48iaSkJDzwwANIS0vDiy++GPbxl1q+dyEKpUa2L2rasOLvR+BjWNxbkInf3Jkzum5CLqXnLLDzFX8Y5a8GGkNhVJu1DRXGClQYK1DdVR10bmbCTBQbirHMsAzpmtG57bKnrc3fD6oS9oOVcBuNIWNkkyYGKqHy8iDW6yMw02vDafOgyzi4AsoMc7cz7FhNnDxQ/eQPoZTaMbI1OSGEjEJOj88fVJn4sOpUhwXeMEFVjFKCnFQdsgf1qMqMU46ee0Q+pNozKKQK3pgE2rRAP6qshUDc+FEZUpndZmxv2o6yhjLsbd0L76CwbnLsZL5JepYuK2JzHC6ejg50r1uH/o//D/BvVKNevBgJK1dAkZ0d4dldX8baHnyx7hgYL4tJ+UlY9tB0CIew83FbWxv6+/uRmJgIpXIUvUZEIZZlYbfb0dnZiZiYGKSkpISMiZpQCgDWrl2LV155Be3t7cjNzcXq1atRWMg1Zb7xxhuRlZWFd955J+xjKZQaO8rr2vHk3w7Dy7D4ztx0vPStmUN68RkVus9wYVTNh4EwalIJt0wvfW5k53adNVuasdm4GeXGctR01wSdm504mwuiMpchRR36QjeSsSwLT3Mz7Acr+SDK09ISPEgggGzqVK4KKo/7I46Li8yEr5LD6uabj3f7e0BZesIHUNoEeVD/J32mBgo1BVCEEDLaOT0+1LdbUNsa6FFV326Bxxf6dkUjFyMnlVvyxy0B1CIrXjU67h3dNqDpIBdQGfcAzVWhIZUmNVBFlbVoVIZUZrcZ2xq3oayhDPta9wVtaDMldgpKs0pRklUCg3Z09+NyN7eg+0+vw/TJp4CPW0GhKS5GwoqnIZ88OcKzu37OH+vGl+tqwDAsphYlY+n90yC4xPXNsiza29vR398/PJMkiImJQXJyctgAMKpCqeFEodTItK2+E4+9VwWPj8Uduan4/V25EI2Gm4pL6T7tD6M+GhRGlQI3/ghIG71hVKO5EeXGclQYK3C85zh/XAAB5iTN4YOoJFVSBGd5bbEsC/f5hkAlVFUVvO3twYNEIsinT+eroJRz50Ck00VmwlfBbnaj02jmluH5e0BZ+1xhx2r1ikAPKH8FlFwlGeYZE0IIiVZuL4NTHRZ+2V9tiwkn2i1we5mQsWqZGNNTA9VUOWlajEtQj/x7SrcdaPaHVA17gObKMCFVyqDlfqMvpDK5TNjauBXlxnLsb90fFFBNi5uGkqwSlBhKRnVbB3dDA7peex3mzz/neooKBNB+/etIePopyMaNzqWNZw93ouytOrAMi+mLUnHjd4e28ZXP54PH47nkOHJ1JBJJyJK9wSiUolBqxNh9uhsPv1sJt5fBLTNS8Md7ciEeYkO7Eav7NLDjZaD240AYNflrwOIfAWlzIju36+S86TwqjBUobyhHfV89f1woECIvKY9fmpegSIjgLK8dlmHgOnOGD6DsVVXwdXUHD5JIoMjJ4XtCKWbPgUitisyEr5Ct38XvftfVaEGX0QybyR12bEySkgufMgYCKDVkSgqgCCGEXB6PjwuqBi/9O9FmhitMUKWUipCdqkV2qr9HVboOE/QjPKhy27lgiq+kqgR8F/zuVScHh1TxE0ZNSDUQUJU1lGF/2/6gnZinxU3jK6gyNBkRnOX14zp9Gl1rX4OlrIw7IBRCd/vtSHjqSUjTR1+Li1OV7dj8l+NgWWDGjelYdPckWpY3QlAoRaHUiLD/XA8efPsgnB4GxdOT8Pp9cyAZzYFU1ylg58tA7f8NCqNu5iqjUmdHdm7Xwdn+syhvKEe5sRxn+gObGIgEIhQkF6A4qxhLM5YiXjHymxGyPh9cp04FKqEqq+C7oHRYIJVCMWsW35RckZsL4QjZHYRlWdj6XVzlU9NAAGWB3RwmgBIAsQMBVCbXiDwhXQOpQjz8EyeEEDImeH0MznRZUdNsQl0rF1QdbzXD4fGFjFVIRJiWovFXU3FB1US9euR+KOpxBEKqhj1cVVVISJUUCKkMC4GESaMipOpz9vEB1cH2g0EBVXZ8Nh9QpalH/m7EF3KeOIGu1Wtg3baNOyAWI+bb30LCE0+M+I1vLnRyXxu2vHcCYIHcZRmY/62JFEyNABRKUSgV9Q4Ze3H/nw/C7vZhyRQ91t0/FzLxxcv/RrSBMKrmY/D72E/5OrD4h6MqjGJZFqf6TvHNys+ZzvHnxEIx5qXMQ4mhBEsyliBGHhO5iV4DrNcL54kTgZ5Qhw+DMZuDxgjkcihm50KZnw9Vfj7kM2dCKIv+3eFYloW1z+XvAWVGV6MVXY1mOCyhZdACARCbogqqgEpIV0MqpwCKEEJIZPkYFue6rKjx96eqazGjrtUEmzs0qJKJhZiWElj6l52mxeQkzcj8sNTj4PpQDVRSNR0EfBcso1clBvekSpg84kOqXmcvtjRuQdn5MlR2VIJhA5VzMxJmoDSrFMWGYqSqUyM4y2vPcfQoulavgW3PHgDch6Ax99yNhEcfHdEb4lyoblcLtv+NW20x92sGFN4+noKpKEehFIVSUe1oUz++99YBWFxeLJyYgLeW50EuGYWBVFe9f5ne/yEQRt3iD6NyIzmza4ZlWZzoPcEHUUZzYMc4iVCCBakLUJxVjMXpi6GTjbz+SANYtxuO2jq+Espx+DAYuz1ojFCphGLuXL4nlCInGwJpdDfoZlkWlh5ncAVUowVOa5gASihAXIoK+kw19JlaJBo0iE9TQyIbhdcuIYSQUcnHsDjfbeP7U9W0cJVVVpc3ZKxULMS0ZA2y/UHVjDQdJiWpR96HqB4n0FLl391v10VCKn1gZ7+sRYB+yogOqXocPVxA1VCGqo6qoIBqZsJMlGRxu/glq0ZPRZG9qgpdr/4R9qoqANyHo7H3fRfx3/8+xLGxEZ7dtVGzvRk7PzgFACi4bRzybxmdvbRGCwqlKJSKWrUtJnz3zf0wO72YNz4Obz9YAIV0hP1yv5TOk/5lev8AH0ZNvZULo1JmRXRq1wLLsqjrqeOX5rVYA7vGSYVSLExbyAdRGqkmgjO9cozLBeexY7ANhFDVR8E6HEFjhFotlHPnck3JC/IhnzYNAnH0VgixLAtTl4MPngb+uOyhN+JCoQBxaSqu+snfhDwhTQ3xaLtWCSGEjHkMw6Khx8YHVDXNJtS2mmBxhv5+lIgEmJKsQU6qf+lfmg5TkjUj68NVjxNoOeRf7reLW/rnvWBHXGXCoJ5UCwH91BEbUnU7urHFuAVlxjJUtVeBReDt7yz9LL6CajQEVCzLwr5vH7r+uBqOo0cBcB+axi5/APEPPQTRKHh/XL25EXs+5tqCzLtjPOZ+LSuyEyIXRaEUhVJR6WS7Gfe8sR/9dg/yDLF49+ECqGTR+yb+snWe4Cqj6jYhOIz6EZAyM6JTu1oMy+BY1zG+IqrN1safk4vkWJS+CCWGEixKXwSVZGQ16wYAxuGAo7qaq4Q6WAnHsWNg3cH9GEQxMXw/KGV+PmSTJ0PwFTtORBLLcAHU4OV3XY1WuB1hAiiRAPFpar4HlD5Tg/g0FcQj6QabEEIIuYZYlkVjr51f+jfQVN3kCK0kFgsFmJSkwYw0Ld+nalqKduQEVV5XcEjVdPAiIdUCrh/VQEglHHlLG7sd3fzGO4c6DgUFVLMTZ6PEUIJiQ/GI3wGaZVlYd+xA1+rVcB0/AYD7MDX+oQcRe/8DI25jnQsd+rIB+z/h2oQs+PZE5C4bvbsujmQUSlEoFXXOdFpw9/r96LG5MSsjBu8/UgCNfJTsvNVxHNjxEnD8U/Bh1LTbuDAqeUZEp3Y1fIwP1V3VfBDVae/kzynECixOX4xiQzEWpi2EUqKM4Ewvn89qg+PIYa4nVFUVHLW1wAVbx4oSEvgQSpWfD+mECRBE4Q0Yw7Awddq5JXj+6qfuJgvcztCeGUKxAAkXBlCpaogk0fd9EUIIIdGEZVk09zkuCKpM6LOHBlUioQCTEtV8NVVOmhbTU3QjY3WA1wW0HL4gpAquFocy3r/cb9GIDam67F2oMFagrKEMRzqPBAVUcxLnoCSLC6gSlYkRnOXVYVkWls2b0b16NVynueoiUUwM4h/9PmK/+90Rs+FOOAc/P4/Kz88DAG64ZzJm3Dj6dh4c6SiUolAqqpzvtuHu9fvQaXEhO1WLDd+fB91o2Aq+o25QGOU37Rv+MConcvO6Cj7Gh8Odh1HeUI7NjZvR7ejmz6kkKixOX4wSQwkWpC2AXCyP4Ewvj89shr3qEOxVVbBXVsJ5/DjgCw5txMnJ/iqoPCjz8iEdlxV1DRQZH4O+DnvwErwmK7yu0ABKJBEiIT04gIpLVUE0Epu2EkIIIVGIZVm0mpzckr8WbtlfbYsJ3dbQ3WmFAmCCXs1XU+Wk6ZCdqo3+VQNeN9B6mAuozl8kpFLEBZqmZy0E9NNGVEjVYevA5sbNfEA1QAABZifO5pf46ZUjs3E46/PB/O8v0b12LdwNDQC4D18THnsMMXffNSI24rkQy7LY/+k5HP6S62d7431TkL1o9O2yOJJRKEWhVNRo6rXjrvX70GZyYmqyBn9/dB5iVdHd/PmSwoVR02/nwqik7MjN6wp5GS+qOqpQ3lCOLY1b0Ovs5c9pJBosyVyCYkMxilKLIBONjF9a3r4+PoCyV1bBdfIkcMHLnSQ9nW9KrizIhyQ9PapCKMbHoLdtcABlRneTFV4PEzJWLBUiIT0QPiUaNIhNVkJIARQhhBAyrFiWRbvZidoWM19RVdNiQpfFFTJWIADGJ6gGVVRxQVVUrybwuoHWI1xI1bAbaDoAeII3f4EiDjDMD4RUidNHTEjVbmvnK6iOdh3ljwsgwNykuSjNKsUywzIkKBIiOMsrw3q9MP3zM3S//jo8zc0AuA9lE554AjHfvDPqN+i5EMuy2PN/Z3B0cxMgAG56YBqmFqVEelrEj0IpCqWiQku/A3et24eWfgcmJqrxwWPzkKAeGaFGWO01XBh14jP/AYE/jPrhiAujPIwHB9sOosJYgS2NW9Dv6ufPaaVaLM1cygVRKUWQiKL4xsjP29U1KISq5EuUB5NmZQUqofLzIUmJnl9aPh+D3lYbFz75d8LrbrbCFy6Akomgz+AqoBIzNUjI1CA2WQWhMHoCNUIIIYQE6zQ7Q3pUtZudYceO44MqLXJSdchO00GniNL7Ma8baKsOhFSNBwCPLXiMInbQ7n4LgcTsERFStVnbUG4sR3lDOY51H+OPCwVC5CXlocRQgpsMN424gIp1u9H/j03oXrcO3vZ2ANyHtQlPPgndN26L6o17LsSyLHZtPI2a7c0QCIBlD0/H5PyR37R+NKBQikKpiGs3OXHX+n1o7LVjXIIKGx+bh0TtyFnuFaTtGBdGnfzcf0AAZN8B3PBDIGl6JGd2WTw+D/a17UN5Qzm2NW2D2W3mz8XKYrE0cylKDCXIT8mHRBilNz5+nvZ2vim5vaoK7vPnQ8ZIJ07g+0Ep8vIgSYyOngA+LxdAdRrNgR5QLVYw3tCXY4lcFNgBz/8nJklJARQhhBAyCnRZXHwl1UCPqlZT+KDKEK/klv2lBvpUxSijsLLF5/FXUu32h1T7Q0MqeYw/pPIHVUk5gDC6+221Wlv5Cqqa7hr+uFAgRH5SPkqySrDMsAxx8rgIzvLyMC4X+jd+iO433oCvm2vZIc3KQsLTT0P79ZujspdqOCzDYvvf63F8VysEQgFKv5+NCXOi475/LKNQikKpiOq0OHHP+v04121DZpwSGx+fhxTdCGykFzaMupOrjEqcFtGpDZXL58Lelr2oMFZge9N2WDwW/lycPA7LMpehOKsYeUl5EAuj81MRlmXhaWmBvTJQCeVpagoeJBBANmXKoJ5QeRDHRf6mwOvxoafFFtQDqqfFCsYX+tIrVYihz1RDn6lFoj+A0ukVEFAARQghhIwZPVYXalvNfEhV02JCc58j7NiMOAVyUgM9qmak6RAXbW0yfB6g7eigSqr9gNsaPEauC66kivKQqsXagvKGcpQ1lKGup44/LhKIkJ+cj9KsUtyUeRNi5bERnOXQMQ4H+jZsQM+bb8HX3w8AkE2ahISVK6BZtiyq2ltcDMuw2PrXEzi5rx1CoQBfezwH42aNzB5gowWFUhRKRUyP1YV73tiP051WpMUosPHxeUiPHVk7s6HtKLD9JaD+X/4DAiDnm1xlVOLUiE5tKJxeJ/a07EG5sRw7mnfANujTKb1Cj2WGZSg2FGNO4hyIovAXPsuycDc0BPWE8ra1BQ8SCiGfPt0fQuVDOXcORDpdZCbs53X70N1s5cOnzkYL+lptYJjQl1mZUhxU/ZRo0ECboBgRv/QJIYQQMrz6bG7UtQZ6VNW2mmDssYcdmxajQHaqlqumSucqq/SaKGqf4fNeEFLtCw2pZDp/Typ/SJU8I2pDqiZLE8obylFuLMfxnuP8cZFAhILkAj6gipHHRG6SQ+Sz2tD31/fQ85e3wVi4D7Ll06dDv2olVDfcEPX3qQzDYvPbx3G6sgNCsQBf/8FMGLLjIz2tMYtCKQqlIqLf7sa9bx7AiTYzkrVybHx8HgzxqkhPa+haq4EdL18QRn2Lq4zST4nkzC7J7rFjV8suVBgrsLN5JxyDdkVJVCaixMBta5ubmAuhILpKcVmWhfvMmeAQqqsreJBYDEVODl8JpZgzByK1OjITBuBxDQRQZr4HVG+bHWyYAEqukkBv0PA9oPSZGmji5VH/i50QQggh0ctk96Cu1b/0z19Zdb7bFnZsslY+qJk6F1hFTVsNnxdoPxpY7mfcB7gtwWNkOsBQNCikmhmVIVWTuQllxjKUN5TjRO8J/rhIIMK8lHkozSrF0syl0Mki+0HqpfhMJvS88w763n0PjJ0LPxWzZkG/aiWURUVRfQ/L+BiU/7kOZw93QSQW4panZyJjauRXT4xFFEpRKDXsTA4PvvfWAdS0mJCglmHj4/MwQR+50OCytB7hKqNO/Zv7t0DIhVE3/GdUh1E2jw07m3eiwliBXc274PQFehCkqFJQbChGsaEYM/UzoyqIYhkGrlOnuH5QlVxPKF9fX9AYgUQCxaxZUBZwu+MpcnMhVEam4s7t9HIBlDFQAdXfbrtwMz8AgEIjCVQ/ZWqhN2igjpVF9S9vQgghhIwOZqcHdS1mPqyq8QdV4e5ZEjUyzEjjmqjP8P9J0kbBPUtQSLUHMO4NE1JpgcwLQipRdLWhaDQ3otzILfE72XuSPy4WiDEvdR5KDCVRH1B5+/rQ89Zb6PvbBrBO7n2GMj+fC6fy8iI8u4vz+Rh8ub4WDce6IZYIceuKWUibPDKWUo4mFEpRKDWsLE4P7v/zQVQ39SNeJcUHj83DpCRNpKd1aS2HuZ5Rp77k/i0QAjnf9odRkyM7t4uwuC3Y3rQdFcYK7GnZAzfj5s+lq9NRnFWMEkMJsuOzI39T4cd6vXCeOMn3g7IfOgTGbA4aI5DLoZidC2UetzOeYtYsCGXDX2rudnjR1WQJ6gHV12EHwrxSKrVSvgJKn8EtwVPFRMHNHCGEEEKIn9XlxXH/0r86f1B1tsuKMMXdSFDL+EqqgcqqFF2Eq7t9XqD9mL+Kyh9SuYLvIwMhlb8vVfKsqAqpGkwNfEB1qu8Uf1wsFKMopQilWaVYkrkEWml0vn/1dnWh+4030f/BB2A9HgCAasEC6FethGLmzAjPLjyfh8EX62rQWNcDsUyEb6zMRcqE6A0ARyMKpSiUGjY2lxcPvn0QlQ19iFFK8PdH52FaSpT/7FsOcZVRp8u4fwuEwIzvcGFUwqTIzi0Mk8vEB1F7W/fCw3j4cwatgV+aNzVualQEIqzHA0dtLb8cz3HoMBhbcDm5UKmEYs4cvieUIicbAunwNuZ0Obxc8ORfftfVaEF/R/j+DKoYGd/7SZ+hgd6ggUoXRf0ZCCGEEEKGyO724kSbGTXNJtT4K6tOd1rhC5NUxauk/moqLd9UPT02gn0wGV8gpBqopHKZgsdINdxyP8MCIGsRkBI9IdU50zm+SfqZ/jP8cbFQjAWpC1CaVYobM26ERhp9H/B72trQvW49+v/v/wCvFwCgXrIE+pUrIJ8WfZtAeT0+/Ou1Y2g+2QepXIRvPDMbSVlR/j51FKFQikKpYeFw+/DwO5XYd64HGrkYf390HnLSojiBbj4E7PgtcLqc+7dACMy4yx9GTYzs3C7Q5+zDtqZtKDeW40DrAXhZL39uvG48ig3FKMkqwaSYSREPohi3G85jxwKVUEeqwTqCd4kRajRQzp3LhVAF+ZBPmwaBePhuDpw2T1D1U2ejBeau8DvZqGMHBVCZWugzNVBqo2wnG0IIIYSQa8jh9uFE++Bd/8w43WGBN0xQFauUICdNh+zUwNK/jLgIBVWMD+ioHdSTag/gvDCkUgOZ8/zL/QZCKsnwz/UC5/rP8T2oBgdUEqEEC9L8AVX6jVBLo6sliru5Gd2vvQ7Tp58CDAMA0JSUQL/iacgmRdcH/B63D5+vOYrW0/2QKcW4/ZnZ0GdGX+A3GlEoRaHUdef0+PDoe1XYdbobapkYf32kALMzo3StbrgwaubdwKL/iKowqsfRg61NW1HeUI7K9kr4WB9/blLsJC6IMpRgQsyECM6S2zbWcfQo3xPKcfQoWLc7aIwoJgbK/Dx+OZ5syhQIRMPTkNJhdQeqn4xcAGXpcYYdq4mXD+oBxf2t0FAARQghhBDi9Phwst0yKKgy4VSHBR5f6FtIrVyMHP+yv4Glf4Y4JYTCYQ6qGB/QUXdBSNUfPEaqBjIKAyFVam7EQ6ozfWf4JX7nTOf441KhFAvTFqI0qxSLMxZDJYmeTaRc586j+7XXYP7iC4BlAYEA2ltvhf6pJyHNyor09HhupxefrzmKtrMmyFUS3PHcbMSnRVfQNxpRKEWh1HXl9jJ44v1D2HqyE0qpCO8+XID8rCjc1aCpkgujzmzm/i0QcWHUDf8BxEc22BnQZe/ClsYtqDBWoKqjCgzL8OemxU1DsaEYywzLME43LmJz9FltcBw5wldCOWprAY8naIwoISE4hJo4EQLh9W+ubje7/dVPZnQ1WtHZaIa11xV2rFav4Hs/DfSBkqsj/ykZIYQQQshI4fL6cKrd6t/1jwurTrZZ4PYxIWM1MjGmp3I9qmakc2HVuHjV8AZVDAN0DgqpGnaHhlQSFZA5OKSaHbGQimVZnOnnAqovz3+JBnMDf04mkgUCqvTFUEoiswnQhZynTqF77WuwlPsLAEQi6O64HQk/eBLS9LTITs7P5fDin3+sRmeDGQqNBHc8NwdxKdET8I1GFEpRKHXdeHwMnt5wGGV1HZBLhHj7wQIUTYiP9LSCRXkY1WHrwObGzShvKMeRziNgB3XRnh4/ne8RlanNjMj8fGYz7IcOwV7J9YRyHj8O+HxBY8TJydxSPH8IJR2Xdd1Ltm0mV2D5ndGC7iYLrH3hAyhdosJf+aSFPlONhAwN5CoKoAghhBBCrjW3l8HpzoGKKq6p+ok2M1ze0KBKJRUhO3WgoooLrMbr1RANV1DFh1R7gIZdXCWVI3gXaEiUF1RSzQbEw19Jz7IsTvWd4iuojGYjf04mkuGG9BtQklWCG9JuiIqAylFXh+7Va2DdsYM7IJEg5tvfQsITT0CSlBTZyYFr5/Hpq0fQ3WSFUifFnc/NQUxS5H9uoxWFUhRKXRdeH4NVG6vxr2NtkIqF+PPyPCyapI/0tAKaDgLbfwuc3cL9WyACZt0L3PD/gLjxEZ1am7UNFcYKVBgrUN1VHXRupn4mSgwlWGZYhjT18H+a4O3r45uS2yur4Dp5EhfuHSxJT+cDKGVBPiTp6dcthGJZFrZ+t7/6KdADym5yhw4WALFJSiRcUAElVURHM0tCCCGEkLHI42NwptMatPTveJsZTk9oUKWUijA9RTto+Z8WE/VqiEXXv+qeC6mOc+FUwy4urHL0Bo/hQyp/4/TUOcMeUg0EVGUNZShrKEOjpZE/JxfJsSh9EUqzSrEobVHEAypHdTW6Vq+Gbe8+AIBAKkXsvfcg/tFHIU5IiOjcnFYPPvnfw+hpsUEdK8Od/28OtAmKiM5ptKJQikKpa87HsPiPj45i05EWSEQCvHF/HpZMTYz0tDhNB4HtLwJnt3L/jpIwqtnSjM3GzSg3lqOmuybo3OzE2Sg2FKPYUIxkVfKwzsvb3R1oSl5ZCdfpMyFjpFlZ3HI8/+54kpSU6zIXlmVh7XPxPaA6/X87zKEBlEAAxCQpoTdokOhvQJ6QoYZUTgEUIYQQQki08/oYnOu2+Xf948KqulYzHB5fyFi5RIhpKdyOfzP8YdWkJDUk1zuoYhig66R/qZ+/ksreEzxGrLhgud/whlQsy+Jk70k+oGq2NvPnFGIFbki/AaVZpViYthAKceQCF9vBg+havRqOqkMAAIFCgbjv3Ye4hx+GODZyvYjtZjc++cNh9LXboYmT487/mANNnDxi8xmtoiqUeu211/DKK6+gvb0ds2bNwpo1a1BQUBB27Jtvvon33nsPtbW1AIC5c+fiN7/5zUXHX4hCqeuDYVj8+B/H8GFVM8RCAV67bw5Ks4c3SAmr8QC3TG9wGJV7L9fAPC4yPZgazY0oN5ajwliB4z3H+eMCCDA3aS6KDcW4KfMmJKmGr4TV09HBNyW3V1bCff58yBjpxAlQ5udDlZ8PRV4eJInXPnBkWRaWHidf+TRQBeW0ekLGCoQCxKUooc/QQG/gqp8SMjSQyIanWTohhBBCCLn+fAyL893+HlX+pX/HW82wurwhY6ViIaYla/hG6jlpOkxO0kAqvo5B1UBIxVdS7Q4fUmUUcAFV1kIgbQ4gll2/OQ3CsiyO9x5HWQO3i1+LtYU/pxArcGP6jSjNKsWCtAWQi4c/eGFZFrY9e9G1ejWcx44BAIQqFeKWL0fcQw9CpInMTng2kwubfn8Ypk4HtHoF7nxuDtSxw/P/2VgRNaHUxo0b8cADD2DdunUoLCzEq6++io8++gj19fVIDPOm97777sOCBQswf/58yOVyvPTSS9i0aRPq6uqQlnbpZU0USl17LMviZ5/W4v39jRAKgDX3zsEtM69P1cyQNe7nKqPObef+LRRzlVGL/l9EwqjzpvOoMFagvKEc9X31/HGhQIj8pHyUZJVgaeZSJCiGp1zV3dwSVAnlaWoKHiAQQDZlir8KimtOLo67to3qWZaFudvJNyEfqIBy2UJvMIRCAWJTVfzud/pMDeLT1ZBIKYAihBBCCBlrGIZFQ48NNf5Kqppmrqm6xRkmqBIJMcUfVA30qJqSrIFMfJ3uI1kW6KoPBFQNuwF7d/AYsTwQUhkWAOl5wxJSsSyL4z3H+QqqVlsrf04pVuLGjEBAJRMNbwDDsiys27aja80auE6cAAAIdTrEP/QQ4u7/HoSq4W86bu1zYtPvD8Pc7URMkhJ3PDcbKh0FU9dK1IRShYWFyM/Px9q1awEADMMgIyMDK1aswI9//ONLPt7n8yE2NhZr167FAw88cMnxFEpdWyzL4r8/P4639zRAIAD+965c3DE7gjsoGPdxYdR5f/M8oRjI/S4XRsVmDetUzvafRXlDOcqN5TjTH1j+JhKIUJhSiGJDMZZmLkWc/PruSsiyLDxGI2yVlXBUVcFWWQlva1vwIKEQ8mnT+H5QyjlzIIqJuXZzYFiYuhxBFVDdTRa47GECKJEA8Wlq6DPU0Bu4JXjxaSqIJRRAEUIIIYSQ8BiGRWOvHbWtgaV/tS1mmByhFfdioQCTkzRcNVU6V1U1NVkD+fW43xwIqYy7gfP+5X62rgsmJAfS8/3L/RYCaXmA5PpWLbEsi9ruWq6CyliONlvg/YFKouICKgMXUElFw7j0kGFgqdiMrjWr4T5zFgAgio1F/KOPIvbeeyBUDO9yQ3O3A5v+cBjWXhfiUlW449nZUGiGv6n9aBQVoZTb7YZSqcTHH3+MO+64gz++fPly9Pf349NPP73k17BYLEhMTMRHH32EW2+9NeS8y+WCyxXYfctsNiMjI4NCqWuAZVn89suTWL/jHADg5W/NxF35GZGZjHGvP4zayf1bKAZy7/OHUYZhmcJAc8GBZuXnTOf4c2KhGPNS5qHEUIIlGUsQI4+5rvNwnz3LNSb3L8nzdl34i08MRXY23xNKMWfONSuNZRkW/Z12vvKpy78LntsZ2gtAKBYgIU3NVz/pMzWIT1VDJBmGppWEEEIIIWRUY1kWzX0O1LQEgqqaFhP67aFBlUgowKREddDSv+kpWiiudWU+ywLdpwJN0xt2A7bOCyYjCw6p0vOva0jFsixqumv4gKrd1s6fU0vUWJKxBKVZpShKLRq2gIr1+WD+4gt0rV0Lj5Fr2i7SJyDh8ScQc9d3IJQOXzBk6rJj0+8Ow2ZyIz5djTuenU27dl8DURFKtba2Ii0tDXv37kVRURF//Ic//CF27NiBAwcOXPJrPPnkkygrK0NdXR3k8tAL9Ze//CV+9atfhRynUOrq/aG8Hqu3chVAL9yZg/sKhyf8CdKwm9tNr2EX92+hBJj9PWDRc0BM5nV/epZlcaL3BB9EDd6GVSKUYH7qfJRklWBx+mLoZLrrMweGgev06UBPqKoq+HqDdwQRSCSQz5oZ2B0vN/ealMAyDIv+dju3/I6vgLLC4woNoEQSIRLS1YEeUJkaxKWoILqea/wJIYQQQggZhGVZtPQ7+EqqgbCqxxa6iY5QAEwME1SpZNdwEx2WBbpPB5b7GfcA1o7gMUEh1QJ/SHV9KoYYlsGxrmN8QNVpDwRmGokGSzL9AVVKESSi6x/MsF4vTJ/+E92vvQZPK7fcUJySgoQnnkDMN++EQDI84VBfuw2b/nAEDrMb+kwNbn8mFzIlBVNXY1SEUr/97W/x8ssvY/v27Zg5c2bYMVQpdX2s3Xoavys/BQD4xW3T8dCCYe7TFC6MmnM/sPA5IOb6VmsNlLpWGCtQbgxuFigVSrEwbSEfRKml6mv//D4fnCdOBnpCHToExmQKGiOQy6GYNYvfGU8xayaEYULby8H4GPS12wNL8IwWdDdb4HWHbtsrlgiRkKGG3r8Dnj5Tg9gUJUTDsW0vIYQQQgghl4FlWbSbnVxvqhYTalu5sKrL4goZKxAAE/RqzEjTITuV61GVnaaD+loFVSwL9JwJrqSytgePEUnDVFJd+5CKYRkc7TrKtSRpKEenY1BAJdVgacZSlGaVYl7KvOseULFuN/r/8Q90/2kdvB1caCfJyEDCU09Cd9ttEIiuf6uPnlYrPvnDETitHiSN0+Ibq3Jpl++rEBWh1NUs3/vd736HX//619i8eTPy8vKG/JzUU+rqrd9xFi/++yQA4PmvT8VjN0wYvic/v4sLo4y7uX8LJcCcB4CFz17XMGrgE4NyYzk2GzcHrbmWi+RYlL4IJYYSLEpfBJXk2jbhYz0eOOvqYPNXQTkOHQZjtQaNESiVUM6ezfeEUuTkQHAVJa0+H4O+Nhs6jRZ0+0OonmYrvJ4wAZRMxPV/GlQBFZukhJACKEIIIYQQMoJ1mJ38kr+BvzvM4YOqcfEqvqIqO02LnDQdtPJrENSwLNBzlgupjHu490PhQqq0vOCQSqq8+ucehGEZVHdW8xVU3Y5A83atVIubMm9CaVYpClIKIBFev4CKcbnQv3Ejute/AV8Pt8uhdNw46Fc8Dc3XvgaB8Pq+B+lutuCTPxyBy+5FykQdbluRS7t/X6GoCKUArtF5QUEB1qxZA4BrdJ6ZmYmnn376oo3OX375ZbzwwgsoKyvDvHnzLuv5KJS6On/ZfR7//flxAMB/lEzG00snXf8nZVnuRXj7b7kXYoB74Z19P7dMT5d+XZ7Wx/hQ3VXNL80bXLqqECuwOH0xig3FWJi2EErJtXvRZ9xuOI8dC1RCHakG63AEjRGq1VDOncs1Jc/Ph3zatCsuXfV5GfS22gZVQJnR02KDzxsaQEnkIi58GtQDKiZJCaFQcEXPTQghhBBCyEjSaXGizr/sr6bFhLoWE1pNzrBjs+KVyPYHVQOVVTHKq+yFxLJA77lBlVS7AMuFmxhJuB39+JCq4JqGVD7GhyOdR/Blw5fYbNyMHmcPf04n03EBlaEU+Sn51y2gYux29G3YgJ4334LPv2pENnky9CtXQH3TTRAIrt/7k06jGZ++Wg23w4u0KbG49amZENOu4JctakKpjRs3Yvny5Vi/fj0KCgrw6quv4sMPP8TJkyeRlJSEBx54AGlpaXjxxRcBAC+99BJ+/vOfY8OGDViwYAH/ddRqNdTqSy+VolDqyr2/34ifflILAFi5dCKeK5lyfZ+QZbnG5dt/CzTu5Y6JpMCc5VxllO7a7/LnY3w43HkY5Q3l2Ny4OegTAJVEhcXpi1FiKMGCtAWQi69Ns0HG4YDj6FGuJ1RVFRxHj4J1BX8CI9LpoMjP43tCyadOvaISVZ+HQU+rlWtC7u8B1dNqBeMNvcylCjH0mYMqoDI0iElUQkABFCGEEEIIIbxuqwu1LSbUtZpR08yFVS39jrBjM+IUfH+qnFQurIpVXUVQxYdUuwOVVJbW4DFCCZA2NxBSZRQA0muzumPg/VNZQxkqjBXodQZ628bIYvgKqvzkfIiF136pm89qRe9776H3L2/zq0nkOTnQr1wB1aJF1y2caj9nwj//WA2Py4fM6XG4+QczaLfwyxQ1oRQArF27Fq+88gra29uRm5uL1atXo7CwEABw4403IisrC++88w4AICsrC0ajMeRr/OIXv8Avf/nLSz4XhVJX5sPKJvzw/44BAJ5YPAE/+tqU65c+syxwfgew/aXgMGrug8CCZ655GOVlvKjqqEJ5Qzm2NG4JeiEdaOZXbChGUWoRZCLZVT8fY7PBfvgItzteZSUcNTWAJ3gHEFF8PLcUzx9CySZNvOxSVK/bh+4WK7/8rqvRgt4WGxgm9JKWKcVB1U/6TA10CQoKoAghhBBCCLkCfTY3alsHqqm4yqrGXnvYsWkxA0GVll8CGK++wvcdLAv0nedCqoFKKnNL8BihBEibMyikKrwmIZWP8eFQxyGUNZRhc+PmoPdVsbJYLDMsQ2lWKeYmzb3mAZXPZELP22+j972/grVzP2fF7NnQr1oF1bzCa/pcA1rP9OOz1dXwuhlkzYjH1x6fQZs4XYaoCqWGE4WZRMSIAAAoDElEQVRSl2/TkWY89+FRsCzw8IJx+Nmt065PIMWywLntwI6XgMZ93DGRDJi7/JqHUR7Gg4NtB1FhrMCWxi3od/Xz53QyHZZmLEWxofiaNO3zWSywHzrkX45XBWddHeAL3p1OnJjINyVXFuRDOm7cZf2MPW4fepr9FVBNXBPy3jYb2DABlFwl4Suf9JkaJBo00MTLr2uJKyGEEEIIIWOdye5BnT+oGuhT1dATPqhK0ckH7frHhVWJmitYqcGyQF9DcCWVuTl4jFAMpM4J7O6XMQ+QXd2GTYM/+N9s3Iw+Vx9/Lk4eh2WZgYBKJLx2FUbe3l70vPkW+jZs4FefKAsLoV+1Eso5c67Z8wxoru/D52uPwudhMD5Xj5JHs2lzpyGiUIpCqSH57GgrVn1wBAwL3D/PgP++PfvahxcsC5zbxlVGNe3njolkXGXUwmcAbeo1eRqPz4N9bftQ3lCObU3bYHab+XOxslgszVyKEkPJVa999vb1weEPoWyVlXCdrAeY4P5MktRUPoBS5udDkpEx5J+r2+lFd7MVXQMBVKMFfW02hLtSFRoJX/mUmKlFQqYamjgKoAghhBBCCIkGZqcHdS3mQEP1VhPOd4e/t0/SypCTqhsUVumQpJVd3r09ywL9Rn8llf+PqSl4jFAMpM4eVEl1dSGVl/Gisr0SZQ1lIQUB8fJ4voJqTuKcaxZQeTo70bP+DfR/+CFY/6oU1aJF0K9cCcWMnGvyHAMaj/fgX68fA+NlMTEvEcUPTadNn4aAQikKpS7py9p2PLXhMHwMi3vyM/CbO2dc24bWLAuc3cr1jGo+yB0TyYC8h7jKKG3KVT+Fy+fC3pa9qDBWYHvTdlg8Fv7cwAtgsaH4qkpIvd3d3FI8f08o16lTIWMkhkwo8/Oh8i/Jk6QNrerL7fCiu9kS1AOqr8MOhAugtFIkXrAETx17mb+kCCGEEEIIIRFldXlR12JCbWsgrDrbZQ0bVCWoZchJ0/Ih1Yw0HVJ0l/khdN/gkGpXaEglEA0KqRYBmYWATHNF35uH8aCyrRJlxjJsNm4OKhRIUCTwFVSzE2dfk4DK09qK7nXr0f+PfwBeLwBAfdNN0K9cAfmUa9cjuaGmG/9eVwPGx2JKYTKWLp9Gm0FdAoVSFEp9pS0nOvDE+4fg8bH45uw0/O47s67dRcWywNkt/jCqkjsmlgNzHwIWrLrqMMrpdWJPyx6UG8uxo3kHbB4bf06v0PNB1JUm8Z6ODj6AsldWwn3uXMgY6YQJUObnQZmXD2V+HiRJSZf8ui6Hlw+eBv70d4Qv51XppNAbtNBnqKE3aJGYqYEq5ur7XRFCCCGEEEKij83lxfG2QRVVLSac6bQiTLcOxKuk/l3/AmFVWoxi6EFVn5Fb6jcQUvU3Bp8XiIDU3EBIlVEIyC//vbWH8eBA2wG+gsriDhQQ6BV6FBuKUZpVitzEXAgFV1d55G5sRPdrr8P02Wf8KhbN174G/YqnIZsw4aq+9oBzR7rw5Zu1YBkW0xakYMl9U6lH71egUIpCqYvacaoLj75bBbePwW2zUvHq3bkQXYuLiWWBM1uA7S8CLVXcMbEcyHuYC6M0yVf8pe0eO3a17EKFsQI7m3fC4Q3sdpGoTESJoQTFhuIrekHztLTAVlnJ94TyNDaGjJFNmcI3JVfm50EcH/+VX9Np8/C9nwb+NnWF36FDHSsLaUKu0lEARQghhBBCyFjmcPv4oGogrDrdaYUvTFIVq5RwO/4N2vUvI26IQVV/o79p+m7AuJvrUTWYQASkzBpUSTXvskOqgVYrZQ1l2Na4LWiFS6IiESVZJSjNKsVM/cyrCqhc586he+1amL/4N3dAKIT21lugf+opSA2GK/66A05XdaDiz3VgWSDnhjTccO9kWrlyERRKUSgV1t6z3Xjo7Uq4vAy+lp2MNd+dDcnVrodlWeDMZn8YdYg7JpYDeY8AC1ZecRhl89iwo2kHKowV2N2yG06fkz+XqkpFsaEYxVnFmJEwY8gvXCzLwtPY6A+guJ5Q3ta24EFCIeTTpnEhVEE+lHPnQhQTc9Gv6bC6QyqgzN3OsGM1cXKuCflAAJWhgVJ7FVvEEkIIIYQQQsYMp8eHk+0WrpqqmetRVd9ugTdMUKVTSLgm6oP6VGXGKS+9Qqa/yV9JtYsLq/rOB58XCAMhlWEhYCgC5Lohfw9unxv72/ajrKEMWxu3wuqx8ueSlEkoySpBiaEEs/SzrjjwcdafQvfaNbBUbOYOiETQ3XkH9D/4wZBbrVxM/YF2bH7nOMACM5emY+F3JlEwFQaFUhRKhTh4vhfL/3IQDo8Py6Yl4vX75kJ6NVtasixwugLY8dtBYZQCyH8EmL8S0Fx6SduFLG4LtjdtR7mxHHtb9sLNuPlz6ep0/gVqevz0IV34LMvCff48txzPH0R5OzuDB4nFUGRnc8vx8vOhmDMHIk34NdR2c3AA1dlohrXXFXasNkEOfaYW+kw1EjO10GdqIFdf3U5/hBBCCCGEEDKYy+tDfbsFtS1mfulffbsFbh8TMlYjFyM7NbDsLydNh3Hxqq8OqkzN/kqqXVxY1XtBexOBEEieGVxJpYgZ0tzdPjf2tu5FeUM5tjZtDWrNkqJK4Zf4zUiYcUXBj6O2Dl1rVsO2Yyd3QCJB7He+jfjHn4AkKfGyv96A43tase2vJwEAs0syUXTnBAqmLkChFIVSQQ4Z+/DAnw/A5vbhhsl6vPnAXMjEV9hYjmWB0+VcZVTrEe7YQBi1YBWgvryL2+QyYVvTNlQYK7C3dS+8jJc/Z9Aa+KV5U+OmXvJCZxkGrtOnYa/k+kHZq6rg6+kJGiOQSCCfOZMPoZS5uRCqVCFfy2ZyhVRAWfvCB1A6vSKkAkquogCKEEIIIYQQMvzcXganOiyoa+WW/dW0mHGizQy3NzSoUsvEmJ7KVVTNSOcCq3EJ6ou3eDG1DKqk2h0aUkEApMzkAqqshUBm0ZBCqoFNrMqM3BI/uzfQfzdVlcov8cuOv/wd4+2Hj6BrzWrY93G7wQtkMsTecw/iH3v0kq1ZLqZ2Zwt2bKgHAOR9PQuF3xh/RV9ntKJQikIp3rHmftz35gFYXF7MnxCPvzyYD7nkCgIplgVOlXGVUYPDqILvc5VRlxFG9Tn7sK1pG8obynGg7QC8bCCImqCbgOKsYizLXIbJsV+9Rpf1+eA8eZLvB+WoqoLPZAoaI5DJoMjN9feDyodi1kwI5fJB3xYLW7/b3/vJzAdQNpP7wqcDAMQkKYN7QGWoIVNSAEUIIYQQQgiJXh4fgzOdVr6aqqbFhBNtZjg9oUGVUirC9BQtX001I02HCXoVxOFav5hbA5VUDbuB3rMXDBAAyTMCIZWhCFDEfuVcnV4n9rTuQVlDGbY3bQ/qKZymTkOJgQuohrqCZoDtwEF0rV4NxyFupY9AqUTc976H+Icf+sqWLRdzdGsTdn94GgBQ+I3xyPt61mV/jdGKQikKpQAAda0mfPfNAzA5PCjIisM7D+dDKRVf3hcZCKO2vwi0VXPHJEogfyCM0g/py/Q4erClcQsqjBWobK+Ej/Xx5ybFTkKxoRglhhJMiLn47gisxwPn8eN8PyjHocNgrNagMQKlEsrZs7kQqiAf8pwcCKVS/7fCwtrnumAJngUOc5gASgDEJim5CqgMDRINGiSkayBVXObPjxBCCCGEEEKikNfH4GyXjQ+qaltMqGs1w+HxhYyVS4SYluJf+ufvUzUpSR3ao3ggpDLu5kKqnjMXfKWBkGphoJJKGXfROQ7svl7WUIbtzaEBVWlWKUqzSjEtbtqQW7zYdu9B1+rVcNbUAACEajXiHnwQccsfuGgrl4s5Ut6Ivf/gvseib07AnJKrb6g+GlAoRaEU6tstuPfN/ei1uTEnMwbvPVIItewyAhWWBU59CWz/7aAwShWojFIlXPJLdNm7sLlxMyqMFTjUcQgMG0jhp8VNQ7GhGMsMyzBONy7s4xm3G86aGr4Syn7kCFi7PWiMUK2Gcu5cril5Xh7k06dDIJGAZVlYepyBXfAauZ3wHBZPyPMIBEBsiiqoAiohXQ2pnAIoQgghhBBCyNjhY1ic6xqoqDL7gyoTbO7QoEoqFmJasoavpspJ02Fykia4d7G5zb/cbzdXTRU2pMrhmqZnLQQM8y8aUjm8Duxu2Y2yhrKQXdkzNBl8QDUldsqlW7+wLKzbtqFr9Rq4TnL9oYQ6HeIfeQRx37sPQqVyaD8wAFVfNODAP7lljAu/MwmzbsoY8mNHKwqlxngodbbLirvX70e31YWZ6Tq8//1CaOVDXGLGskD9v7llem1HuWMSFVDwKDB/xSXDqHZbO7Y0bkF5QzmOdB4Bi8B/YtPjp/M9ojK1mSGPZZxOOI4e45uSO6qrwbqC+ziJdDoo8vL4nlDyqVMBoRDmbuegCigzuhqtcNrCBFBCAeJSVNAbNEj0B1Dx6WpIpFfYY4sQQgghhBBCRjGGYXG+x8Yt+2vmlv7VtZphdXlDxkpFQkwJCqq0mJKsCfQ0trRzAdVAUNV96oKvIACScoCsBf6QakHYkMrusWNny06UN5RjV/OuoN3aB3oTl2aVXrolDMPAUl6OrtVr4D7HBUuiuDjEP/YoYu+5J6j1y1c58M9zqPqiAQCw+LtTkHPD1e3yN9JRKDWGQ6mGbhvufmMfOswuTE/RYsOjhYhRSi/9QJYF6r/gKqPaj3HHpGoujCpaAagu3gCuzdqGCmMFKowVqO6qDjo3Uz8TJYYSLDMsQ5o6+MJkbDbYq6v5SijnsWNgPcFBkiguju8HpczPh3TCBJh7/UvwjNzyu+4mC1z20BdEoUiAuFQVHz7pM7WIT1dBfCU9tQghhBBCCCGEAOCCKmOvnQuo/D2qaltMMDtD35dJRAJMTtJgRpoO2f6wamqyhut1bOkYVEm1G+iuD32ypBwunBoIqS54b2r32LGzeSfKGsqwq2UXXL5AYUOWNotvkj4pZtJFAyrW54P5X/9C19rX4GlsBACIExMR//hjiPnOd/iWMBfDsiz2bTqLI+XcY5fcPxXTF6R+5WNGMwqlxmgo1dRrx93r96HV5MTkJDU+eKwIcapLBFIsC5z8F1cZ1c6tqeXCqMeAoqcvGkY1W5r5IKqmuybo3OzE2dzSvMxlSFGn8Md9Fgschw/zPaGcdccBb/CLlliv5/tBKfLyYFeloLt58BI8K9yOMAGUWICENDUSMgdVQKWqIZKEacZHCCGEEEIIIeSaYlkWTb0O/45/Jn73v3576AoWsVCASUka5KRqMSOdW/o3PUULuasnuJKq62ToEyVOD/SkMiwIWs1j99ixo3kHF1A174KbCfQPHqcbxy3xM5RiYuzE8N+DxwPTp5+i6/XX4W1t4+aamgL9k09Cd/vtEEguvgKJZVns/ug0jm1tBgTAsgenY0ph8lB/fKMKhVJjMJRq7XfgrvX70NznwHi9ChsfK4JeI7v4AxgGqP8XsP0loGNQGFX4OBdGhSmRbDQ3otxYjgpjBY73HOePCyDA3KS5KDYU46bMm5CkSgIA+Pr7YT90CPaD3HI858mT3PMOIk5NgSo/H/K8fHjGz0KfR43uJivfA8rjDF27LBILEZ+uHlQBpUFcqgoiMQVQhBBCCCGEEBItWJZFc5+DD6hq/H2qem2hm02JhAJM1Kv9S/+43f+m61xQth4IVFJ1nQh9Ev204JDKvxmXzWPD9qbtKG8ox+6W3UEB1QTdBL6CKtxmW4zbjf6PP0bPuvXwdnYCACSZmdA/9SS0t94KgSj86huWZbHz76dQu7MFAgFQ/Eg2JuUlXcFPbmSjUGqMhVIdZifuXr8PDT12GOKV2PhYEZJ1F1n7yjDAyc+BHS8BHbXcManGH0Y9FRJGnTedR4WxAuUN5ajvC5RSCgVC5Cflc0GU4SYkKBLg7enhGpL7e0K5Tl24Ppi7kOV5+fBOK4A1biL6rGIugGq2wusKDaDEkkEBlIFbghebooQo3HakhBBCCCGEEEKiGsuyaDM5g3b9q2kxo9vqChkrFAAT/EFVTpoOs+M8mOaphaJlH3B+11eEVAPL/RYCaj2sbiu2N29HWUMZ9rTsgYcJVG9NjJnIB1TjdeODvhTjdKLvgw/Q88ab8PX2AgCkEyZA//RT0JSWQiAMfV/KMiy2/e0kTuxpg0AowNcey8H43KHtWj9aUCg1hkKpLosL97yxD2e7bEiPVWDj40VIi1GEDmQY4ORnXGVUZx13TKoB5j0BzHsyKIw6238W5Q3lKDeW40x/YHcEkUCEguQClGSVYGnmUmhMXj6AsldVwX32bMjTisdPhC/3BtgzZsAkS0ZPlxc9zVZ4PUzoWKkQ+gxN0BK82GQlhBRAEUIIIYQQQsioxbIsOsyuwNI//9+dltCgSiAAxiWoMCNNh7wEHwqEJ5Flq4asaW/gve5g+qmBnlRZC2GRKrC9yR9Qte6Blwm0h5kYM5HfxW/wLvGMzYbev21Az5//DMZkAgDIpkyBfuUKqJcuDelVxTAstr57AvUH2iEUCXDzEzOQNePSO9iPFhRKjZFQqtfmxr1v7Ed9hwUpOjk+fLwIGXEXbF3JMMCJf3KVUZ3+JXcyLVD4BDDvB4AyDizL4lTfKb5H1DnTOf7hYqEY81LmocRQgkWiqRAfq4e9iquG8hgbg59KIIJ72jw4JxfAGjsO/R41ejpc8IUJoCQyERIy1EjM1HIVUBkaxCQrIRR+9dadhBBCCCGEEELGhk6zE7WtJtQ0m1HbylVVtZmcYceOS1ChIInFTYrTmOGpQWLvIYi6woRUCVP8AdUCmFNysa2vFmUNZdjXug9eNhBQTY6djNKsUpQYSpClywLA9Unuffc99L7zDhirFQAgz8mBftVKqBYuDAqnGB+DireP40xVJ4RiAW55ciYyp198A7HRhEKpMRBK9dvd+O6bB3C8zYxEjQwfPl6ErARVYADDACc+BXa8HBxGzfsBMO8HYOUxONF7gg+ijGYj/1CJUIIFKfNxs3Q2ZrfKwB6p5UKo1tbAlxeIYdWkwTkxH7bU6TBLEtFnFoLxhf4nJZWLoM8MroCKSVRCQAEUIYQQQgghhJDL0G11DVr2Z0Jtixkt/Y6wY2fEenFbTAPmCY9jvK0a6v4wjdMTJgNZC2FKn4utIh/KO/Zjf+v+oIBqatxUlBi4JX6Z2kz4+vvR8/Y76P3rX8Ha7QAAxZw50K9aBVVhAf84n49B+Zt1OFfdBZFEiFufnoX0KbHX9gcShSiUGuWhlNnpwffeOoBjzSYkqKX44LEiTExUcycZBjj+CRdGDayvlem4IKrwcdTaWrgeUcZytFhb+K8pFUhwq3gObupNguGsDe7D1fB2dAAAfEIxbKo0mHVZcGTMgEVjgNmrvLBnOfdUSjESMjSDekBpoEtQUABFCCGEEEIIIeS66LW5+ZBqoKl6U29oUBUDC27WnscyxSnM9NUhwXoKAlwQi8RPgimzEFu1MShztmJ/1xH42ED/42lx07geVIZSpHiU6HnzLfT9/e9gXdxSQ+W8edCvXAnlnNkAAJ+XwZfra9BQ0wOxVIjbVuYidWLMdftZRAMKpUZxKGV1efHAnw/gcGM/YpUSfPBYEaYkawDGNyiM8qe/Mh2YeT/AsYmLUNG+DxXGCrTZuG0tBSyLCb1S3GIah9wWCTTHm8D09sInlMCqTodFnQGLLgvWhImwiuLAIjRUkqnEg3bA00KfqYE2QR6ynpYQQgghhBBCCBlO/XY3alu4ZX8DTdWNPfagMTpYUSA8iZsUpzFfdAIZ7rMhIVV/wgRsSZqAcpEbB6wN8LGB6ozp8dNRmlWKZco5kL7/Gfo++gjwcE3UVTcsgn7lKihysuH1+PDFn2rQdLwXErkI31iVi+Rxuuv/Q4gQCqVGaShld3vx4NuVOHi+FzqFBBseLUR2shqo28SFUd3c7ng+uQ7Vud9BhVaLipad6LR3QsCwMHQCs1rEWNgZg/RzVrA2L6yqNFg0mbBoMmDRGmBTJAGC0MbiCo2EC58yNHwPKE08BVCEEEIIIYQQQkYGk8ODutaBXf/MqG0x4Vy3jT+vhRX5wnrME57AIslJTGbPQzgopOoTCrFFb8CXWg0qvSYwg85lx2fjNtU8FJY1wvNZOeDjqqvUy26CfsVKiMdNwOevHUNLfR+kCjFufyYXiYbRl1sAFEqNylDK6fHhkXcrsedMDzQyMf72SB5mmrZxDcy7T8EH4LA2DmVZc7DF04M+WzfGtQPTmljMaBZicqsMLnEKrJoMmNVcCGVXXiSA0koHVUBxf9SxMgqgCCGEEEIIIYSMKhanB8dbzXw1VW2rGWe7rGBZQAsb8oUnMU94AoXCE8gWGiECVynVKxRis0qJsph4VIlZDO5ucwMm4569AiTsPA6wLCAQQHvz16B77EmUf25C2xkTZEox7nhuNhLSNZH5xq8jCqVGWSjl8vrw2HuHsONUFzRSAT69sRPjj78Gb/cpVMplqNDGYIdCi9hWJ6Y3spjSJEOaKR0uhb8CSpMBuyIxbACl0kkD4ZNBi8RMDVQxsgh8l4QQQgghhBBCSOTZXF4cbzMPaqZuwplOK9SsDXn+SqpC4QnkCM5DJGDRLRRii0qJcpUSlXI5WH89R1o3i+9XapBd3c8dEAqhvPUOHNTcgs4WJ+RqCe54bjbiU9UR+16vh6gKpV577TW88soraG9vx6xZs7BmzRoUFBRcdPxHH32En/3sZ2hoaMCkSZPw0ksv4etf//qQnms0hlJuL4Mn/3YIW0+041vS/fh5zL9w1NOGrTIljCYFDE1KTOhKR4wzA3ZVBizqTDiUiWG/lipGCn2mFomGQAWUSkcBFCGEEEIIIYQQ8lXsbi9OtFmCgqq2zk7MwUnMEx5HofAEZgjOo08swGalEmUqJQ7JZWAFAhg6WNy1i0H+aS6C8UjVqLnhp+j3aqDQSnHnc7MRm6yK8Hd47URNKLVx40Y88MADWLduHQoLC/Hqq6/io48+Qn19PRITQ4OTvXv34oYbbsCLL76IW2+9FRs2bMBLL72Ew4cPIycn55LPN9pCKa+PwaoNVRCd/BiL5J+hwySBq3cC9OYMyNhMWNUZcCr0YR+r1oigHx+LRIOW7wGl1EqH+TsghBBCCCGEEEJGJ6fHhxNtZtS2mlHbbMKZ5jbEdFUhX3AC84THkSQ2YqtajnKVEkdkMoxvA+7axWD2ORYesRKHc1fBpk6HUiPGnf+Zh5hEZaS/pWsiakKpwsJC5OfnY+3atQAAhmGQkZGBFStW4Mc//nHI+Lvvvhs2mw2ff/45f2zevHnIzc3FunXrLvl8oymU6m5qxsY/vgpZtxdCTwYYSQZc8oSwY1VyLxIzNUiansJXQCnUFEARQgghhBBCCCHDyeX1ob7dgpoWE041tkPQuA+p/YcwQVyHFnUXtqjlsHXLcPdOBpNbVTiSuwo2VSpErAm531aicFnJiO/nPNRsRnw9J+F2u3Ho0CH85Cc/4Y8JhUIsW7YM+/btC/uYffv24bnnngs6Vlpaik8++STseJfLBZfLxf/bbDZf/cSjxKc/exOQfx0uOQB54LgcZiQmSpE8PRXJszKgz9RCrpJEbJ6EEEIIIYQQQgjhyMQizEyPwcz0GKDQAKAQbi+DUx0W9BlbseT0bjDSnThXUoPqXhNmV64Gm/wM7Mpk1P6tG9NmdEOXHH5F1GhzXUOp7u5u+Hw+JCUlBR1PSkrCyZMnwz6mvb097Pj29vaw41988UX86le/ujYTjjKqdDmY5g6Ihe1InBCH6YvnIXXOeMiUFEARQgghhBBCCCEjhVQsRE6aDjlpOmD+NACPwuNjcLapHScLP4Nzz4eQdN0LAXsM2qTvRHq6w+a6hlLD4Sc/+UlQZZXZbEZGRkYEZ3TtfPtX/wmL1YJYXWykp0IIIYQQQgghhJBrSCISYmpWKqZmPQ5843E4bW4I2JtH/NK9y3FdQ6mEhASIRCJ0dHQEHe/o6EBycnLYxyQnJ1/WeJlMBplsdO4eJxaJKZAihBBCCCGEEELGALlKCmBs9YYWXs8vLpVKMXfuXGzZsoU/xjAMtmzZgqKiorCPKSoqChoPABUVFRcdTwghhBBCCCGEEEJGnuu+fO+5557D8uXLkZeXh4KCArz66quw2Wx46KGHAAAPPPAA0tLS8OKLLwIAVq1ahcWLF+P3v/89brnlFnzwwQeoqqrCG2+8cb2nSgghhBBCCCGEEEKGyXUPpe6++250dXXh5z//Odrb25Gbm4svv/ySb2be2NgIoTBQsDV//nxs2LABP/3pT/H8889j0qRJ+OSTT5CTk3O9p0oIIYQQQgghhBBChomAZVk20pO4lsxmM3Q6HUwmE7RabaSnQwghhBBCCCGEEDKmDDWbGfG7711oIGMzm80RngkhhBBCCCGEEELI2DOQyVyqDmrUhVIWiwUAkJGREeGZEEIIIYQQQgghhIxdFosFOp3uoudH3fI9hmHQ2toKjUYDgUAQ6elcNbPZjIyMDDQ1NdFyREKGiK4bQq4MXTuEXBm6dgi5MnTtEHJlRsK1w7IsLBYLUlNTg/qIX2jUVUoJhUKkp6dHehrXnFarjdr/2AiJVnTdEHJl6Noh5MrQtUPIlaFrh5ArE+3XzldVSA24eFxFCCGEEEIIIYQQQsh1QqEUIYQQQgghhBBCCBl2FEpFOZlMhl/84heQyWSRngohIwZdN4RcGbp2CLkydO0QcmXo2iHkyoyma2fUNTonhBBCCCGEEEIIIdGPKqUIIYQQQgghhBBCyLCjUIoQQgghhBBCCCGEDDsKpQghhBBCCCGEEELIsKNQihBCCCGEEEIIIYQMOwqlCCGEEEIIIYQQQsiwo1Aqir322mvIysqCXC5HYWEhDh48GOkpERJVXnzxReTn50Oj0SAxMRF33HEH6uvrg8Y4nU489dRTiI+Ph1qtxre+9S10dHREaMaERJ/f/va3EAgEeOaZZ/hjdN0QEl5LSwu+973vIT4+HgqFAjNmzEBVVRV/nmVZ/PznP0dKSgoUCgWWLVuG06dPR3DGhESez+fDz372M4wbNw4KhQITJkzA//zP/2DwJvB07RDC2blzJ2677TakpqZCIBDgk08+CTo/lGult7cX9913H7RaLWJiYvDII4/AarUO43dxeSiUilIbN27Ec889h1/84hc4fPgwZs2ahdLSUnR2dkZ6aoREjR07duCpp57C/v37UVFRAY/Hg5KSEthsNn7Ms88+i88++wwfffQRduzYgdbWVnzzm9+M4KwJiR6VlZVYv349Zs6cGXScrhtCQvX19WHBggWQSCT497//jePHj+P3v/89YmNj+TEvv/wyVq9ejXXr1uHAgQNQqVQoLS2F0+mM4MwJiayXXnoJf/rTn7B27VqcOHECL730El5++WWsWbOGH0PXDiEcm82GWbNm4bXXXgt7fijXyn333Ye6ujpUVFTg888/x86dO/HYY48N17dw+VgSlQoKCtinnnqK/7fP52NTU1PZF198MYKzIiS6dXZ2sgDYHTt2sCzLsv39/axEImE/+ugjfsyJEydYAOy+ffsiNU1CooLFYmEnTZrEVlRUsIsXL2ZXrVrFsixdN4RczI9+9CN24cKFFz3PMAybnJzMvvLKK/yx/v5+ViaTsX//+9+HY4qERKVbbrmFffjhh4OOffOb32Tvu+8+lmXp2iHkYgCwmzZt4v89lGvl+PHjLAC2srKSH/Pvf/+bFQgEbEtLy7DN/XJQpVQUcrvdOHToEJYtW8YfEwqFWLZsGfbt2xfBmRES3UwmEwAgLi4OAHDo0CF4PJ6ga2nq1KnIzMyka4mMeU899RRuueWWoOsDoOuGkIv55z//iby8PHznO99BYmIiZs+ejTfffJM/f/78ebS3twddOzqdDoWFhXTtkDFt/vz52LJlC06dOgUAOHr0KHbv3o2bb74ZAF07hAzVUK6Vffv2ISYmBnl5efyYZcuWQSgU4sCBA8M+56EQR3oCJFR3dzd8Ph+SkpKCjiclJeHkyZMRmhUh0Y1hGDzzzDNYsGABcnJyAADt7e2QSqWIiYkJGpuUlIT29vYIzJKQ6PDBBx/g8OHDqKysDDlH1w0h4Z07dw5/+tOf8Nxzz+H5559HZWUlVq5cCalUiuXLl/PXR7j7N7p2yFj24x//GGazGVOnToVIJILP58MLL7yA++67DwDo2iFkiIZyrbS3tyMxMTHovFgsRlxcXNReTxRKEUJGhaeeegq1tbXYvXt3pKdCSFRramrCqlWrUFFRAblcHunpEDJiMAyDvLw8/OY3vwEAzJ49G7W1tVi3bh2WL18e4dkREr0+/PBD/O1vf8OGDRuQnZ2N6upqPPPMM0hNTaVrhxBCjc6jUUJCAkQiUchORx0dHUhOTo7QrAiJXk8//TQ+//xzbNu2Denp6fzx5ORkuN1u9Pf3B42na4mMZYcOHUJnZyfmzJkDsVgMsViMHTt2YPXq1RCLxUhKSqLrhpAwUlJSMH369KBj06ZNQ2NjIwDw1wfdvxES7D//8z/x4x//GPfccw9mzJiB+++/H88++yxefPFFAHTtEDJUQ7lWkpOTQzZH83q96O3tjdrriUKpKCSVSjF37lxs2bKFP8YwDLZs2YKioqIIzoyQ6MKyLJ5++mls2rQJW7duxbhx44LOz507FxKJJOhaqq+vR2NjI11LZMy66aabUFNTg+rqav5PXl4e7rvvPv5/03VDSKgFCxagvr4+6NipU6dgMBgAAOPGjUNycnLQtWM2m3HgwAG6dsiYZrfbIRQGv+0UiURgGAYAXTuEDNVQrpWioiL09/fj0KFD/JitW7eCYRgUFhYO+5yHgpbvRannnnsOy5cvR15eHgoKCvDqq6/CZrPhoYceivTUCIkaTz31FDZs2IBPP/0UGo2GXyet0+mgUCig0+nwyCOP4LnnnkNcXBy0Wi1WrFiBoqIizJs3L8KzJyQyNBoN33dtgEqlQnx8PH+crhtCQj377LOYP38+fvOb3+Cuu+7CwYMH8cYbb+CNN94AAAgEAjzzzDP49a9/jUmTJmHcuHH42c9+htTUVNxxxx2RnTwhEXTbbbfhhRdeQGZmJrKzs3HkyBH84Q9/wMMPPwyArh1CBrNarThz5gz/7/Pnz6O6uhpxcXHIzMy85LUybdo0fO1rX8Ojjz6KdevWwePx4Omnn8Y999yD1NTUCH1XlxDp7f/Ixa1Zs4bNzMxkpVIpW1BQwO7fvz/SUyIkqgAI++ftt9/mxzgcDvbJJ59kY2NjWaVSyd55551sW1tb5CZNSBRavHgxu2rVKv7fdN0QEt5nn33G5uTksDKZjJ06dSr7xhtvBJ1nGIb92c9+xiYlJbEymYy96aab2Pr6+gjNlpDoYDab2VWrVrGZmZmsXC5nx48fz/7Xf/0X63K5+DF07RDC2bZtW9j3N8uXL2dZdmjXSk9PD3vvvfeyarWa1Wq17EMPPcRaLJYIfDdDI2BZlo1QHkYIIYQQQgghhBBCxijqKUUIIYQQQgghhBBChh2FUoQQQgghhBBCCCFk2FEoRQghhBBCCCGEEEKGHYVShBBCCCGEEEIIIWTYUShFCCGEEEIIIYQQQoYdhVKEEEIIIYQQQgghZNhRKEUIIYQQQgghhBBChh2FUoQQQgghhBBCCCFk2FEoRQghhBBCCCGEEEKGHYVShBBCCCGEEEIIIWTYUShFCCGEEEIIIYQQQobd/wfjPRbKCNc3gQAAAABJRU5ErkJggg==\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "ncwrNSTLv1R1" - }, - "execution_count": null, - "outputs": [] - } - ], - "metadata": { - "colab": { - "provenance": [], - "machine_shape": "hm", - "gpuType": "A100" - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "bb8fb55556ac451fbe17df79d10c2b56": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_a0bedda309594a8587d725e23ab569e4", - "IPY_MODEL_011a85465fb742b596cc725b4246aa01", - "IPY_MODEL_94fb8d26156f4af3b1e21ba882b5a3fc" - ], - "layout": "IPY_MODEL_1b8af82b0f0d4ef39409262baf9360aa" - } - }, - "a0bedda309594a8587d725e23ab569e4": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_945e8c93915747e1b99860966291da1b", - "placeholder": "​", - "style": "IPY_MODEL_47d8345be1ea47e8831a9e5d4386b7a8", - "value": "Sanity Checking DataLoader 0: 100%" - } - }, - "011a85465fb742b596cc725b4246aa01": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7816477075504b2cb3ef6fa8aa57bf09", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_c01752b4d3b84a9b897360744a43375d", - "value": 1 - } - }, - "94fb8d26156f4af3b1e21ba882b5a3fc": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8f2cf806a1b5453cbabaa5871f9eb9bd", - "placeholder": "​", - "style": "IPY_MODEL_64a042cc36014ba0aa6b23606bda8554", - "value": " 1/1 [00:00<00:00,  2.15it/s]" - } - }, - "1b8af82b0f0d4ef39409262baf9360aa": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "945e8c93915747e1b99860966291da1b": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "47d8345be1ea47e8831a9e5d4386b7a8": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7816477075504b2cb3ef6fa8aa57bf09": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c01752b4d3b84a9b897360744a43375d": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "8f2cf806a1b5453cbabaa5871f9eb9bd": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "64a042cc36014ba0aa6b23606bda8554": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "c1a1d5b7043647a29aeb3ea4fdc34ecf": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_ef67032131af4828b82e47a5a710fef5", - "IPY_MODEL_c4e4d98af60a420b804742db2c7a5e5d", - "IPY_MODEL_d56f16d908504149948dbe7497980bc3" - ], - "layout": "IPY_MODEL_63ada147711b4c339004a99c353962eb" - } - }, - "ef67032131af4828b82e47a5a710fef5": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_f8b2b298f2044b1abe670fc84b7658bd", - "placeholder": "​", - "style": "IPY_MODEL_d0b51366bc814f1c99cd4153c3fe4ec0", - "value": "Epoch 99: 100%" - } - }, - "c4e4d98af60a420b804742db2c7a5e5d": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_84857f37c01849d3a796bd1c07eebc54", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_0758c138f86540bbba775d599589deb2", - "value": 1 - } - }, - "d56f16d908504149948dbe7497980bc3": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_27a657fb36f5489d8ae3e3c6180db997", - "placeholder": "​", - "style": "IPY_MODEL_6f32c5b55fb342fd985dbda4ade77b82", - "value": " 1/1 [00:00<00:00, 18.75it/s, v_num=0, train_loss_step=8.660, train_loss_epoch=8.660, valid_loss=13.70]" - } - }, - "63ada147711b4c339004a99c353962eb": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "f8b2b298f2044b1abe670fc84b7658bd": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "d0b51366bc814f1c99cd4153c3fe4ec0": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "84857f37c01849d3a796bd1c07eebc54": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0758c138f86540bbba775d599589deb2": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "27a657fb36f5489d8ae3e3c6180db997": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6f32c5b55fb342fd985dbda4ade77b82": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "588d220a6d634b03ae463c2cc5902b58": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_d8302f528c1f4c018b7bd641d152b617", - "IPY_MODEL_40063d0d85254615a05e68084d2dcafa", - "IPY_MODEL_b560422245e94bb7b5804a6b8bd31dca" - ], - "layout": "IPY_MODEL_d4c66b4520ab40898ac04010fa926c5b" - } - }, - "d8302f528c1f4c018b7bd641d152b617": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_c53abfe7cf5f43daa0a8dd56853cc3a6", - "placeholder": "​", - "style": "IPY_MODEL_c4e26937963f48b994111d8b5a6e4a28", - "value": "Validation DataLoader 0: 100%" - } - }, - "40063d0d85254615a05e68084d2dcafa": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_dbe2f9e88d2c4b649afc033bc8603083", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_2a5fe8a3fa2140a694d503bc00400f12", - "value": 1 - } - }, - "b560422245e94bb7b5804a6b8bd31dca": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_947b94882e8144beaca020c64f4588e2", - "placeholder": "​", - "style": "IPY_MODEL_b3eb5210e0d747c0a5abae14b4691997", - "value": " 1/1 [00:00<00:00, 114.27it/s]" - } - }, - "d4c66b4520ab40898ac04010fa926c5b": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": "hidden", - "width": "100%" - } - }, - "c53abfe7cf5f43daa0a8dd56853cc3a6": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c4e26937963f48b994111d8b5a6e4a28": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "dbe2f9e88d2c4b649afc033bc8603083": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2a5fe8a3fa2140a694d503bc00400f12": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "947b94882e8144beaca020c64f4588e2": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "b3eb5210e0d747c0a5abae14b4691997": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "1fbe190298c742fcb44273f22bff9e22": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_6217a4d543cb4a329ff1014735c563f1", - "IPY_MODEL_e30a0a034d1a47f7b8134d78ea7eb0bf", - "IPY_MODEL_5e2cef4d25e54553bd11d7adfb8dd2f9" - ], - "layout": "IPY_MODEL_095bbaae5e1d4789b9a370f074439027" - } - }, - "6217a4d543cb4a329ff1014735c563f1": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_f895197c32e646bda4e825796946807c", - "placeholder": "​", - "style": "IPY_MODEL_a7231112c75e4c89b5c2a234008ff080", - "value": "Predicting DataLoader 0: 100%" - } - }, - "e30a0a034d1a47f7b8134d78ea7eb0bf": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7d289fa9ce354637bbb1e3d2798e3674", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_cabd9a2793c148c1b72e64d19da35ed5", - "value": 1 - } - }, - "5e2cef4d25e54553bd11d7adfb8dd2f9": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7fd831200ddf4e3c9f44df09bee746c7", - "placeholder": "​", - "style": "IPY_MODEL_6d54edada0d34b71bc34b0c105712913", - "value": " 1/1 [00:00<00:00, 110.39it/s]" - } - }, - "095bbaae5e1d4789b9a370f074439027": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": "inline-flex", - "flex": null, - "flex_flow": "row wrap", - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "100%" - } - }, - "f895197c32e646bda4e825796946807c": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "a7231112c75e4c89b5c2a234008ff080": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7d289fa9ce354637bbb1e3d2798e3674": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": "2", - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "cabd9a2793c148c1b72e64d19da35ed5": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "7fd831200ddf4e3c9f44df09bee746c7": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "6d54edada0d34b71bc34b0c105712913": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - } - } - }, - "accelerator": "GPU" - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/nbs/models.ipynb b/nbs/models.ipynb index 018525399..73ca254a0 100644 --- a/nbs/models.ipynb +++ b/nbs/models.ipynb @@ -1348,6 +1348,8 @@ " default_config = {\n", " \"input_size_multiplier\": [1, 2, 3, 4, 5],\n", " \"h\": None,\n", + " \"basis\": tune.choice([\"polynomial\", \"spline\"]),\n", + " \"n_basis\": tune.choice([2, 3, 4, 5]),\n", " \"learning_rate\": tune.loguniform(1e-4, 1e-1),\n", " \"scaler_type\": tune.choice([None, 'robust', 'standard']),\n", " \"max_steps\": tune.choice([500, 1000]),\n", diff --git a/nbs/models.nbeats.ipynb b/nbs/models.nbeats.ipynb index 9504770d5..b278fc3d8 100644 --- a/nbs/models.nbeats.ipynb +++ b/nbs/models.nbeats.ipynb @@ -1,5 +1,15 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "75372ec2", + "metadata": {}, + "outputs": [], + "source": [ + "%set_env PYTORCH_ENABLE_MPS_FALLBACK=1" + ] + }, { "cell_type": "code", "execution_count": null, @@ -62,8 +72,11 @@ "from typing import Tuple, Optional\n", "\n", "import numpy as np\n", + "from numpy.polynomial.legendre import Legendre\n", + "from numpy.polynomial.chebyshev import Chebyshev\n", "import torch\n", "import torch.nn as nn\n", + "from scipy.interpolate import BSpline\n", "\n", "from neuralforecast.losses.pytorch import MAE\n", "from neuralforecast.common._base_windows import BaseWindows" @@ -84,6 +97,141 @@ "import matplotlib.pyplot as plt" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "b3b21a80", + "metadata": {}, + "outputs": [], + "source": [ + "#| exporti\n", + "def generate_legendre_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates Legendre polynomial basis functions.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of basis functions to generate.\n", + "\n", + " Returns:\n", + " - legendre_basis (ndarray): An array of Legendre basis functions.\n", + " \"\"\"\n", + " x = np.linspace(-1, 1, length) # Legendre polynomials are defined on [-1, 1]\n", + " legendre_basis = np.zeros((length, n_basis))\n", + " for i in range(n_basis):\n", + " # Legendre polynomial of degree i\n", + " P_i = Legendre.basis(i)\n", + " legendre_basis[:, i] = P_i(x)\n", + " return legendre_basis\n", + "\n", + "def generate_polynomial_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates standard polynomial basis functions.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of polynomial functions to generate.\n", + "\n", + " Returns:\n", + " - poly_basis (ndarray): An array of polynomial basis functions.\n", + " \"\"\"\n", + " return np.concatenate([np.power(np.arange(length, dtype=float) / length, i)[None, :]\n", + " for i in range(n_basis)]).T\n", + "\n", + "\n", + "def generate_changepoint_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates changepoint basis functions with automatically spaced changepoints.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of changepoint functions to generate.\n", + "\n", + " Returns:\n", + " - changepoint_basis (ndarray): An array of changepoint basis functions.\n", + " \"\"\"\n", + " x = np.linspace(0, 1, length)[:, None] # Shape: (length, 1)\n", + " changepoint_locations = np.linspace(0, 1, n_basis + 1)[1:][None, :] # Shape: (1, n_basis)\n", + " return np.maximum(0, x - changepoint_locations)\n", + "\n", + "def generate_piecewise_linear_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates piecewise linear basis functions (linear splines).\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of piecewise linear basis functions to generate.\n", + "\n", + " Returns:\n", + " - pw_linear_basis (ndarray): An array of piecewise linear basis functions.\n", + " \"\"\"\n", + " x = np.linspace(0, 1, length)\n", + " knots = np.linspace(0, 1, n_basis+1)\n", + " pw_linear_basis = np.zeros((length, n_basis))\n", + " for i in range(1, n_basis):\n", + " pw_linear_basis[:, i] = np.maximum(0, np.minimum((x - knots[i-1]) / (knots[i] - knots[i-1]), (knots[i+1] - x) / (knots[i+1] - knots[i])))\n", + " return pw_linear_basis\n", + "\n", + "def generate_linear_hat_basis(length, n_basis):\n", + " x = np.linspace(0, 1, length)[:, None] # Shape: (length, 1)\n", + " centers = np.linspace(0, 1, n_basis)[None, :] # Shape: (1, n_basis)\n", + " width = 1.0 / (n_basis - 1)\n", + " \n", + " # Create triangular functions using piecewise linear equations\n", + " return np.maximum(0, 1 - np.abs(x - centers) / width)\n", + "\n", + "def generate_spline_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates cubic spline basis functions.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of basis functions.\n", + "\n", + " Returns:\n", + " - spline_basis (ndarray): An array of cubic spline basis functions.\n", + " \"\"\"\n", + " x = np.linspace(0, 1, length)\n", + " knots = np.linspace(0, 1, n_basis - 2)\n", + " t = np.concatenate(([0, 0, 0], knots, [1, 1, 1]))\n", + " degree = 3\n", + " # Create basis coefficient matrix once\n", + " coefficients = np.eye(n_basis)\n", + " # Create single BSpline object with all coefficients\n", + " spline = BSpline(t, coefficients.T, degree)\n", + " return spline(x)\n", + "\n", + "def generate_chebyshev_basis(length, n_basis):\n", + " \"\"\"\n", + " Generates Chebyshev polynomial basis functions.\n", + "\n", + " Parameters:\n", + " - n_points (int): Number of data points.\n", + " - n_functions (int): Number of Chebyshev polynomials to generate.\n", + "\n", + " Returns:\n", + " - chebyshev_basis (ndarray): An array of Chebyshev polynomial basis functions.\n", + " \"\"\"\n", + " x = np.linspace(-1, 1, length)\n", + " chebyshev_basis = np.zeros((length, n_basis))\n", + " for i in range(n_basis):\n", + " T_i = Chebyshev.basis(i)\n", + " chebyshev_basis[:, i] = T_i(x)\n", + " return chebyshev_basis\n", + "\n", + "def get_basis(length, n_basis, basis):\n", + " basis_dict = {\n", + " 'legendre': generate_legendre_basis,\n", + " 'polynomial': generate_polynomial_basis,\n", + " 'changepoint': generate_changepoint_basis,\n", + " 'piecewise_linear': generate_piecewise_linear_basis,\n", + " 'linear_hat': generate_linear_hat_basis,\n", + " 'spline': generate_spline_basis,\n", + " 'chebyshev': generate_chebyshev_basis\n", + " }\n", + " return basis_dict[basis](length, n_basis+1)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -107,19 +255,19 @@ " return backcast, forecast\n", "\n", "class TrendBasis(nn.Module):\n", - " def __init__(self, degree_of_polynomial: int,\n", - " backcast_size: int, forecast_size: int,\n", - " out_features: int=1):\n", + " def __init__(self, \n", + " n_basis: int,\n", + " backcast_size: int,\n", + " forecast_size: int,\n", + " out_features: int=1,\n", + " basis='polynomial'):\n", " super().__init__()\n", " self.out_features = out_features\n", - " polynomial_size = degree_of_polynomial + 1\n", " self.backcast_basis = nn.Parameter(\n", - " torch.tensor(np.concatenate([np.power(np.arange(backcast_size, dtype=float) / backcast_size, i)[None, :]\n", - " for i in range(polynomial_size)]), dtype=torch.float32), requires_grad=False)\n", + " torch.tensor(get_basis(backcast_size, n_basis, basis).T, dtype=torch.float32), requires_grad=False)\n", " self.forecast_basis = nn.Parameter(\n", - " torch.tensor(np.concatenate([np.power(np.arange(forecast_size, dtype=float) / forecast_size, i)[None, :]\n", - " for i in range(polynomial_size)]), dtype=torch.float32), requires_grad=False)\n", - " \n", + " torch.tensor(get_basis(forecast_size, n_basis, basis).T, dtype=torch.float32), requires_grad=False)\n", + "\n", " def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:\n", " polynomial_size = self.forecast_basis.shape[0] # [polynomial_size, L+H]\n", " backcast_theta = theta[:, :polynomial_size]\n", @@ -130,8 +278,10 @@ " return backcast, forecast\n", "\n", "class SeasonalityBasis(nn.Module):\n", - " def __init__(self, harmonics: int, \n", - " backcast_size: int, forecast_size: int,\n", + " def __init__(self, \n", + " harmonics: int, \n", + " backcast_size: int, \n", + " forecast_size: int,\n", " out_features: int=1):\n", " super().__init__()\n", " self.out_features = out_features\n", @@ -191,8 +341,6 @@ " basis: nn.Module, \n", " dropout_prob: float, \n", " activation: str):\n", - " \"\"\"\n", - " \"\"\"\n", " super().__init__()\n", "\n", " self.dropout_prob = dropout_prob\n", @@ -209,7 +357,6 @@ "\n", " if self.dropout_prob>0:\n", " raise NotImplementedError('dropout')\n", - " #hidden_layers.append(nn.Dropout(p=self.dropout_prob))\n", "\n", " output_layer = [nn.Linear(in_features=mlp_units[-1][1], out_features=n_theta)]\n", " layers = hidden_layers + output_layer\n", @@ -245,7 +392,8 @@ " `h`: int, forecast horizon.
\n", " `input_size`: int, considered autorregresive inputs (lags), y=[1,2,3,4] input_size=2 -> lags=[1,2].
\n", " `n_harmonics`: int, Number of harmonic terms for seasonality stack type. Note that len(n_harmonics) = len(stack_types). Note that it will only be used if a seasonality stack is used.
\n", - " `n_polynomials`: int, polynomial degree for trend stack. Note that len(n_polynomials) = len(stack_types). Note that it will only be used if a trend stack is used.
\n", + " `basis`: str, Type of basis function to use in the trend stack. Choose one from ['legendre', 'polynomial', 'changepoint', 'piecewise_linear', 'linear_hat', 'spline', 'chebyshev']
\n", + " `n_basis`: int, the number of basis functions for the trend stack. Note that it will only be used if a trend stack is used.
\n", " `stack_types`: List[str], List of stack types. Subset from ['seasonality', 'trend', 'identity'].
\n", " `n_blocks`: List[int], Number of blocks for each stack. Note that len(n_blocks) = len(stack_types).
\n", " `mlp_units`: List[List[int]], Structure of hidden layers for each stack type. Each internal list should contain the number of units of each hidden layer. Note that len(n_hidden) = len(stack_types).
\n", @@ -291,7 +439,8 @@ " h,\n", " input_size,\n", " n_harmonics: int = 2,\n", - " n_polynomials: int = 2,\n", + " n_basis: int = 2,\n", + " basis: str = 'polynomial',\n", " stack_types: list = ['identity', 'trend', 'seasonality'],\n", " n_blocks: list = [1, 1, 1],\n", " mlp_units: list = 3 * [[512, 512]],\n", @@ -364,18 +513,23 @@ " dropout_prob_theta=dropout_prob_theta,\n", " activation=activation,\n", " shared_weights=shared_weights,\n", - " n_polynomials=n_polynomials, \n", - " n_harmonics=n_harmonics)\n", + " n_harmonics=n_harmonics,\n", + " n_basis=n_basis,\n", + " basis_type=basis)\n", " self.blocks = torch.nn.ModuleList(blocks)\n", "\n", - " def create_stack(self, stack_types, \n", + " def create_stack(self, \n", + " stack_types, \n", " n_blocks, \n", " input_size, \n", " h, \n", " mlp_units, \n", " dropout_prob_theta, \n", - " activation, shared_weights,\n", - " n_polynomials, n_harmonics): \n", + " activation, \n", + " shared_weights,\n", + " n_harmonics, \n", + " n_basis, \n", + " basis_type): \n", "\n", " block_list = []\n", " for i in range(len(stack_types)):\n", @@ -389,14 +543,17 @@ " n_theta = 2 * (self.loss.outputsize_multiplier + 1) * \\\n", " int(np.ceil(n_harmonics / 2 * h) - (n_harmonics - 1))\n", " basis = SeasonalityBasis(harmonics=n_harmonics,\n", - " backcast_size=input_size,forecast_size=h,\n", + " backcast_size=input_size,\n", + " forecast_size=h,\n", " out_features=self.loss.outputsize_multiplier)\n", "\n", " elif stack_types[i] == 'trend':\n", - " n_theta = (self.loss.outputsize_multiplier + 1) * (n_polynomials + 1)\n", - " basis = TrendBasis(degree_of_polynomial=n_polynomials,\n", - " backcast_size=input_size,forecast_size=h,\n", - " out_features=self.loss.outputsize_multiplier)\n", + " n_theta = (self.loss.outputsize_multiplier + 1) * (n_basis + 1)\n", + " basis = TrendBasis(n_basis=n_basis,\n", + " backcast_size=input_size,\n", + " forecast_size=h,\n", + " out_features=self.loss.outputsize_multiplier,\n", + " basis=basis_type)\n", "\n", " elif stack_types[i] == 'identity':\n", " n_theta = input_size + self.loss.outputsize_multiplier * h\n", @@ -658,6 +815,8 @@ "Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test\n", "\n", "model = NBEATS(h=12, input_size=24,\n", + " basis='spline',\n", + " n_basis=3,\n", " loss=DistributionLoss(distribution='Poisson', level=[80, 90]),\n", " stack_types = ['identity', 'trend', 'seasonality'],\n", " max_steps=100,\n", diff --git a/neuralforecast/_modidx.py b/neuralforecast/_modidx.py index 25f008ce4..b8f2542a0 100644 --- a/neuralforecast/_modidx.py +++ b/neuralforecast/_modidx.py @@ -886,7 +886,23 @@ 'neuralforecast.models.nbeats.TrendBasis.__init__': ( 'models.nbeats.html#trendbasis.__init__', 'neuralforecast/models/nbeats.py'), 'neuralforecast.models.nbeats.TrendBasis.forward': ( 'models.nbeats.html#trendbasis.forward', - 'neuralforecast/models/nbeats.py')}, + 'neuralforecast/models/nbeats.py'), + 'neuralforecast.models.nbeats.generate_changepoint_basis': ( 'models.nbeats.html#generate_changepoint_basis', + 'neuralforecast/models/nbeats.py'), + 'neuralforecast.models.nbeats.generate_chebyshev_basis': ( 'models.nbeats.html#generate_chebyshev_basis', + 'neuralforecast/models/nbeats.py'), + 'neuralforecast.models.nbeats.generate_legendre_basis': ( 'models.nbeats.html#generate_legendre_basis', + 'neuralforecast/models/nbeats.py'), + 'neuralforecast.models.nbeats.generate_linear_hat_basis': ( 'models.nbeats.html#generate_linear_hat_basis', + 'neuralforecast/models/nbeats.py'), + 'neuralforecast.models.nbeats.generate_piecewise_linear_basis': ( 'models.nbeats.html#generate_piecewise_linear_basis', + 'neuralforecast/models/nbeats.py'), + 'neuralforecast.models.nbeats.generate_polynomial_basis': ( 'models.nbeats.html#generate_polynomial_basis', + 'neuralforecast/models/nbeats.py'), + 'neuralforecast.models.nbeats.generate_spline_basis': ( 'models.nbeats.html#generate_spline_basis', + 'neuralforecast/models/nbeats.py'), + 'neuralforecast.models.nbeats.get_basis': ( 'models.nbeats.html#get_basis', + 'neuralforecast/models/nbeats.py')}, 'neuralforecast.models.nbeatsx': { 'neuralforecast.models.nbeatsx.ExogenousBasis': ( 'models.nbeatsx.html#exogenousbasis', 'neuralforecast/models/nbeatsx.py'), 'neuralforecast.models.nbeatsx.ExogenousBasis.__init__': ( 'models.nbeatsx.html#exogenousbasis.__init__', diff --git a/neuralforecast/auto.py b/neuralforecast/auto.py index b3c85892a..1f32c831e 100644 --- a/neuralforecast/auto.py +++ b/neuralforecast/auto.py @@ -628,6 +628,8 @@ class AutoNBEATS(BaseAuto): default_config = { "input_size_multiplier": [1, 2, 3, 4, 5], "h": None, + "basis": tune.choice(["polynomial", "spline"]), + "n_basis": tune.choice([2, 3, 4, 5]), "learning_rate": tune.loguniform(1e-4, 1e-1), "scaler_type": tune.choice([None, "robust", "standard"]), "max_steps": tune.choice([500, 1000]), diff --git a/neuralforecast/models/nbeats.py b/neuralforecast/models/nbeats.py index 02280fb79..6861f6dc1 100644 --- a/neuralforecast/models/nbeats.py +++ b/neuralforecast/models/nbeats.py @@ -3,17 +3,165 @@ # %% auto 0 __all__ = ['NBEATS'] -# %% ../../nbs/models.nbeats.ipynb 5 +# %% ../../nbs/models.nbeats.ipynb 6 from typing import Tuple, Optional import numpy as np +from numpy.polynomial.legendre import Legendre +from numpy.polynomial.chebyshev import Chebyshev import torch import torch.nn as nn +from scipy.interpolate import BSpline from ..losses.pytorch import MAE from ..common._base_windows import BaseWindows -# %% ../../nbs/models.nbeats.ipynb 7 +# %% ../../nbs/models.nbeats.ipynb 8 +def generate_legendre_basis(length, n_basis): + """ + Generates Legendre polynomial basis functions. + + Parameters: + - n_points (int): Number of data points. + - n_functions (int): Number of basis functions to generate. + + Returns: + - legendre_basis (ndarray): An array of Legendre basis functions. + """ + x = np.linspace(-1, 1, length) # Legendre polynomials are defined on [-1, 1] + legendre_basis = np.zeros((length, n_basis)) + for i in range(n_basis): + # Legendre polynomial of degree i + P_i = Legendre.basis(i) + legendre_basis[:, i] = P_i(x) + return legendre_basis + + +def generate_polynomial_basis(length, n_basis): + """ + Generates standard polynomial basis functions. + + Parameters: + - n_points (int): Number of data points. + - n_functions (int): Number of polynomial functions to generate. + + Returns: + - poly_basis (ndarray): An array of polynomial basis functions. + """ + return np.concatenate( + [ + np.power(np.arange(length, dtype=float) / length, i)[None, :] + for i in range(n_basis) + ] + ).T + + +def generate_changepoint_basis(length, n_basis): + """ + Generates changepoint basis functions with automatically spaced changepoints. + + Parameters: + - n_points (int): Number of data points. + - n_functions (int): Number of changepoint functions to generate. + + Returns: + - changepoint_basis (ndarray): An array of changepoint basis functions. + """ + x = np.linspace(0, 1, length)[:, None] # Shape: (length, 1) + changepoint_locations = np.linspace(0, 1, n_basis + 1)[1:][ + None, : + ] # Shape: (1, n_basis) + return np.maximum(0, x - changepoint_locations) + + +def generate_piecewise_linear_basis(length, n_basis): + """ + Generates piecewise linear basis functions (linear splines). + + Parameters: + - n_points (int): Number of data points. + - n_functions (int): Number of piecewise linear basis functions to generate. + + Returns: + - pw_linear_basis (ndarray): An array of piecewise linear basis functions. + """ + x = np.linspace(0, 1, length) + knots = np.linspace(0, 1, n_basis + 1) + pw_linear_basis = np.zeros((length, n_basis)) + for i in range(1, n_basis): + pw_linear_basis[:, i] = np.maximum( + 0, + np.minimum( + (x - knots[i - 1]) / (knots[i] - knots[i - 1]), + (knots[i + 1] - x) / (knots[i + 1] - knots[i]), + ), + ) + return pw_linear_basis + + +def generate_linear_hat_basis(length, n_basis): + x = np.linspace(0, 1, length)[:, None] # Shape: (length, 1) + centers = np.linspace(0, 1, n_basis)[None, :] # Shape: (1, n_basis) + width = 1.0 / (n_basis - 1) + + # Create triangular functions using piecewise linear equations + return np.maximum(0, 1 - np.abs(x - centers) / width) + + +def generate_spline_basis(length, n_basis): + """ + Generates cubic spline basis functions. + + Parameters: + - n_points (int): Number of data points. + - n_functions (int): Number of basis functions. + + Returns: + - spline_basis (ndarray): An array of cubic spline basis functions. + """ + x = np.linspace(0, 1, length) + knots = np.linspace(0, 1, n_basis - 2) + t = np.concatenate(([0, 0, 0], knots, [1, 1, 1])) + degree = 3 + # Create basis coefficient matrix once + coefficients = np.eye(n_basis) + # Create single BSpline object with all coefficients + spline = BSpline(t, coefficients.T, degree) + return spline(x) + + +def generate_chebyshev_basis(length, n_basis): + """ + Generates Chebyshev polynomial basis functions. + + Parameters: + - n_points (int): Number of data points. + - n_functions (int): Number of Chebyshev polynomials to generate. + + Returns: + - chebyshev_basis (ndarray): An array of Chebyshev polynomial basis functions. + """ + x = np.linspace(-1, 1, length) + chebyshev_basis = np.zeros((length, n_basis)) + for i in range(n_basis): + T_i = Chebyshev.basis(i) + chebyshev_basis[:, i] = T_i(x) + return chebyshev_basis + + +def get_basis(length, n_basis, basis): + basis_dict = { + "legendre": generate_legendre_basis, + "polynomial": generate_polynomial_basis, + "changepoint": generate_changepoint_basis, + "piecewise_linear": generate_piecewise_linear_basis, + "linear_hat": generate_linear_hat_basis, + "spline": generate_spline_basis, + "chebyshev": generate_chebyshev_basis, + } + return basis_dict[basis](length, n_basis + 1) + +# %% ../../nbs/models.nbeats.ipynb 9 class IdentityBasis(nn.Module): def __init__(self, backcast_size: int, forecast_size: int, out_features: int = 1): super().__init__() @@ -31,39 +179,23 @@ def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: class TrendBasis(nn.Module): def __init__( self, - degree_of_polynomial: int, + n_basis: int, backcast_size: int, forecast_size: int, out_features: int = 1, + basis="polynomial", ): super().__init__() self.out_features = out_features - polynomial_size = degree_of_polynomial + 1 self.backcast_basis = nn.Parameter( torch.tensor( - np.concatenate( - [ - np.power( - np.arange(backcast_size, dtype=float) / backcast_size, i - )[None, :] - for i in range(polynomial_size) - ] - ), - dtype=torch.float32, + get_basis(backcast_size, n_basis, basis).T, dtype=torch.float32 ), requires_grad=False, ) self.forecast_basis = nn.Parameter( torch.tensor( - np.concatenate( - [ - np.power( - np.arange(forecast_size, dtype=float) / forecast_size, i - )[None, :] - for i in range(polynomial_size) - ] - ), - dtype=torch.float32, + get_basis(forecast_size, n_basis, basis).T, dtype=torch.float32 ), requires_grad=False, ) @@ -140,7 +272,7 @@ def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: forecast = torch.einsum("bpq,pt->btq", forecast_theta, self.forecast_basis) return backcast, forecast -# %% ../../nbs/models.nbeats.ipynb 8 +# %% ../../nbs/models.nbeats.ipynb 10 ACTIVATIONS = ["ReLU", "Softplus", "Tanh", "SELU", "LeakyReLU", "PReLU", "Sigmoid"] @@ -158,7 +290,6 @@ def __init__( dropout_prob: float, activation: str, ): - """ """ super().__init__() self.dropout_prob = dropout_prob @@ -175,7 +306,6 @@ def __init__( if self.dropout_prob > 0: raise NotImplementedError("dropout") - # hidden_layers.append(nn.Dropout(p=self.dropout_prob)) output_layer = [nn.Linear(in_features=mlp_units[-1][1], out_features=n_theta)] layers = hidden_layers + output_layer @@ -188,7 +318,7 @@ def forward(self, insample_y: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor] backcast, forecast = self.basis(theta) return backcast, forecast -# %% ../../nbs/models.nbeats.ipynb 9 +# %% ../../nbs/models.nbeats.ipynb 11 class NBEATS(BaseWindows): """NBEATS @@ -203,7 +333,8 @@ class NBEATS(BaseWindows): `h`: int, forecast horizon.
`input_size`: int, considered autorregresive inputs (lags), y=[1,2,3,4] input_size=2 -> lags=[1,2].
`n_harmonics`: int, Number of harmonic terms for seasonality stack type. Note that len(n_harmonics) = len(stack_types). Note that it will only be used if a seasonality stack is used.
- `n_polynomials`: int, polynomial degree for trend stack. Note that len(n_polynomials) = len(stack_types). Note that it will only be used if a trend stack is used.
+ `basis`: str, Type of basis function to use in the trend stack. Choose one from ['legendre', 'polynomial', 'changepoint', 'piecewise_linear', 'linear_hat', 'spline', 'chebyshev']
+ `n_basis`: int, the number of basis functions for the trend stack. Note that it will only be used if a trend stack is used.
`stack_types`: List[str], List of stack types. Subset from ['seasonality', 'trend', 'identity'].
`n_blocks`: List[int], Number of blocks for each stack. Note that len(n_blocks) = len(stack_types).
`mlp_units`: List[List[int]], Structure of hidden layers for each stack type. Each internal list should contain the number of units of each hidden layer. Note that len(n_hidden) = len(stack_types).
@@ -251,7 +382,8 @@ def __init__( h, input_size, n_harmonics: int = 2, - n_polynomials: int = 2, + n_basis: int = 2, + basis: str = "polynomial", stack_types: list = ["identity", "trend", "seasonality"], n_blocks: list = [1, 1, 1], mlp_units: list = 3 * [[512, 512]], @@ -328,8 +460,9 @@ def __init__( dropout_prob_theta=dropout_prob_theta, activation=activation, shared_weights=shared_weights, - n_polynomials=n_polynomials, n_harmonics=n_harmonics, + n_basis=n_basis, + basis_type=basis, ) self.blocks = torch.nn.ModuleList(blocks) @@ -343,8 +476,9 @@ def create_stack( dropout_prob_theta, activation, shared_weights, - n_polynomials, n_harmonics, + n_basis, + basis_type, ): block_list = [] @@ -369,14 +503,13 @@ def create_stack( ) elif stack_types[i] == "trend": - n_theta = (self.loss.outputsize_multiplier + 1) * ( - n_polynomials + 1 - ) + n_theta = (self.loss.outputsize_multiplier + 1) * (n_basis + 1) basis = TrendBasis( - degree_of_polynomial=n_polynomials, + n_basis=n_basis, backcast_size=input_size, forecast_size=h, out_features=self.loss.outputsize_multiplier, + basis=basis_type, ) elif stack_types[i] == "identity": From 18155ad232aad39d3d904843f117820e80d83de4 Mon Sep 17 00:00:00 2001 From: marcopeix Date: Thu, 12 Dec 2024 14:31:45 -0500 Subject: [PATCH 03/12] Fix spline basis function to ensure minimum n_basis --- nbs/models.nbeats.ipynb | 5 +++-- neuralforecast/models/nbeats.py | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/nbs/models.nbeats.ipynb b/nbs/models.nbeats.ipynb index b278fc3d8..0b86969f3 100644 --- a/nbs/models.nbeats.ipynb +++ b/nbs/models.nbeats.ipynb @@ -191,6 +191,7 @@ " Returns:\n", " - spline_basis (ndarray): An array of cubic spline basis functions.\n", " \"\"\"\n", + " n_basis = max(4, n_basis)\n", " x = np.linspace(0, 1, length)\n", " knots = np.linspace(0, 1, n_basis - 2)\n", " t = np.concatenate(([0, 0, 0], knots, [1, 1, 1]))\n", @@ -815,8 +816,8 @@ "Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test\n", "\n", "model = NBEATS(h=12, input_size=24,\n", - " basis='spline',\n", - " n_basis=3,\n", + " basis='polynomial',\n", + " n_basis=2,\n", " loss=DistributionLoss(distribution='Poisson', level=[80, 90]),\n", " stack_types = ['identity', 'trend', 'seasonality'],\n", " max_steps=100,\n", diff --git a/neuralforecast/models/nbeats.py b/neuralforecast/models/nbeats.py index 6861f6dc1..2e8912717 100644 --- a/neuralforecast/models/nbeats.py +++ b/neuralforecast/models/nbeats.py @@ -119,6 +119,7 @@ def generate_spline_basis(length, n_basis): Returns: - spline_basis (ndarray): An array of cubic spline basis functions. """ + n_basis = max(4, n_basis) x = np.linspace(0, 1, length) knots = np.linspace(0, 1, n_basis - 2) t = np.concatenate(([0, 0, 0], knots, [1, 1, 1])) From 2aed1531d93117bfba83c983aff6dc158d479f6f Mon Sep 17 00:00:00 2001 From: marcopeix Date: Thu, 12 Dec 2024 15:13:50 -0500 Subject: [PATCH 04/12] Fix default NBEATS config --- nbs/models.ipynb | 2 +- neuralforecast/auto.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/nbs/models.ipynb b/nbs/models.ipynb index 73ca254a0..959121100 100644 --- a/nbs/models.ipynb +++ b/nbs/models.ipynb @@ -1349,7 +1349,7 @@ " \"input_size_multiplier\": [1, 2, 3, 4, 5],\n", " \"h\": None,\n", " \"basis\": tune.choice([\"polynomial\", \"spline\"]),\n", - " \"n_basis\": tune.choice([2, 3, 4, 5]),\n", + " \"n_basis\": tune.choice([2, 5]),\n", " \"learning_rate\": tune.loguniform(1e-4, 1e-1),\n", " \"scaler_type\": tune.choice([None, 'robust', 'standard']),\n", " \"max_steps\": tune.choice([500, 1000]),\n", diff --git a/neuralforecast/auto.py b/neuralforecast/auto.py index 1f32c831e..8c44dbf27 100644 --- a/neuralforecast/auto.py +++ b/neuralforecast/auto.py @@ -629,7 +629,7 @@ class AutoNBEATS(BaseAuto): "input_size_multiplier": [1, 2, 3, 4, 5], "h": None, "basis": tune.choice(["polynomial", "spline"]), - "n_basis": tune.choice([2, 3, 4, 5]), + "n_basis": tune.choice([2, 5]), "learning_rate": tune.loguniform(1e-4, 1e-1), "scaler_type": tune.choice([None, "robust", "standard"]), "max_steps": tune.choice([500, 1000]), From 8a7f65d75e6bf4bd58f7d54c0e5fd7f57c0a898f Mon Sep 17 00:00:00 2001 From: marcopeix Date: Thu, 12 Dec 2024 16:13:15 -0500 Subject: [PATCH 05/12] Validation for spline basis, default auto config --- nbs/models.ipynb | 2 +- nbs/models.nbeats.ipynb | 23 +++++++++++------------ neuralforecast/auto.py | 2 +- neuralforecast/models/nbeats.py | 15 +++++++++------ 4 files changed, 22 insertions(+), 20 deletions(-) diff --git a/nbs/models.ipynb b/nbs/models.ipynb index 959121100..66fabec7d 100644 --- a/nbs/models.ipynb +++ b/nbs/models.ipynb @@ -1348,7 +1348,7 @@ " default_config = {\n", " \"input_size_multiplier\": [1, 2, 3, 4, 5],\n", " \"h\": None,\n", - " \"basis\": tune.choice([\"polynomial\", \"spline\"]),\n", + " \"basis\": tune.choice([\"polynomial\", \"changepoint\"]),\n", " \"n_basis\": tune.choice([2, 5]),\n", " \"learning_rate\": tune.loguniform(1e-4, 1e-1),\n", " \"scaler_type\": tune.choice([None, 'robust', 'standard']),\n", diff --git a/nbs/models.nbeats.ipynb b/nbs/models.nbeats.ipynb index 0b86969f3..03942e244 100644 --- a/nbs/models.nbeats.ipynb +++ b/nbs/models.nbeats.ipynb @@ -1,15 +1,5 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "75372ec2", - "metadata": {}, - "outputs": [], - "source": [ - "%set_env PYTORCH_ENABLE_MPS_FALLBACK=1" - ] - }, { "cell_type": "code", "execution_count": null, @@ -191,7 +181,8 @@ " Returns:\n", " - spline_basis (ndarray): An array of cubic spline basis functions.\n", " \"\"\"\n", - " n_basis = max(4, n_basis)\n", + " if n_basis < 4:\n", + " raise ValueError(f\"To use the spline basis, n_basis must be set to 4 or more. Current value is {n_basis}\")\n", " x = np.linspace(0, 1, length)\n", " knots = np.linspace(0, 1, n_basis - 2)\n", " t = np.concatenate(([0, 0, 0], knots, [1, 1, 1]))\n", @@ -817,7 +808,7 @@ "\n", "model = NBEATS(h=12, input_size=24,\n", " basis='polynomial',\n", - " n_basis=2,\n", + " n_basis=5,\n", " loss=DistributionLoss(distribution='Poisson', level=[80, 90]),\n", " stack_types = ['identity', 'trend', 'seasonality'],\n", " max_steps=100,\n", @@ -847,6 +838,14 @@ "plt.legend()\n", "plt.plot()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c87058ca", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/neuralforecast/auto.py b/neuralforecast/auto.py index 8c44dbf27..d45ee875b 100644 --- a/neuralforecast/auto.py +++ b/neuralforecast/auto.py @@ -628,7 +628,7 @@ class AutoNBEATS(BaseAuto): default_config = { "input_size_multiplier": [1, 2, 3, 4, 5], "h": None, - "basis": tune.choice(["polynomial", "spline"]), + "basis": tune.choice(["polynomial", "changepoint"]), "n_basis": tune.choice([2, 5]), "learning_rate": tune.loguniform(1e-4, 1e-1), "scaler_type": tune.choice([None, "robust", "standard"]), diff --git a/neuralforecast/models/nbeats.py b/neuralforecast/models/nbeats.py index 2e8912717..af2d5a52b 100644 --- a/neuralforecast/models/nbeats.py +++ b/neuralforecast/models/nbeats.py @@ -3,7 +3,7 @@ # %% auto 0 __all__ = ['NBEATS'] -# %% ../../nbs/models.nbeats.ipynb 6 +# %% ../../nbs/models.nbeats.ipynb 5 from typing import Tuple, Optional import numpy as np @@ -16,7 +16,7 @@ from ..losses.pytorch import MAE from ..common._base_windows import BaseWindows -# %% ../../nbs/models.nbeats.ipynb 8 +# %% ../../nbs/models.nbeats.ipynb 7 def generate_legendre_basis(length, n_basis): """ Generates Legendre polynomial basis functions. @@ -119,7 +119,10 @@ def generate_spline_basis(length, n_basis): Returns: - spline_basis (ndarray): An array of cubic spline basis functions. """ - n_basis = max(4, n_basis) + if n_basis < 4: + raise ValueError( + f"To use the spline basis, n_basis must be set to 4 or more. Current value is {n_basis}" + ) x = np.linspace(0, 1, length) knots = np.linspace(0, 1, n_basis - 2) t = np.concatenate(([0, 0, 0], knots, [1, 1, 1])) @@ -162,7 +165,7 @@ def get_basis(length, n_basis, basis): } return basis_dict[basis](length, n_basis + 1) -# %% ../../nbs/models.nbeats.ipynb 9 +# %% ../../nbs/models.nbeats.ipynb 8 class IdentityBasis(nn.Module): def __init__(self, backcast_size: int, forecast_size: int, out_features: int = 1): super().__init__() @@ -273,7 +276,7 @@ def forward(self, theta: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: forecast = torch.einsum("bpq,pt->btq", forecast_theta, self.forecast_basis) return backcast, forecast -# %% ../../nbs/models.nbeats.ipynb 10 +# %% ../../nbs/models.nbeats.ipynb 9 ACTIVATIONS = ["ReLU", "Softplus", "Tanh", "SELU", "LeakyReLU", "PReLU", "Sigmoid"] @@ -319,7 +322,7 @@ def forward(self, insample_y: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor] backcast, forecast = self.basis(theta) return backcast, forecast -# %% ../../nbs/models.nbeats.ipynb 11 +# %% ../../nbs/models.nbeats.ipynb 10 class NBEATS(BaseWindows): """NBEATS From 7b1bcdb0722bf74f248204424ee10966c1fc6308 Mon Sep 17 00:00:00 2001 From: marcopeix Date: Tue, 28 Jan 2025 09:26:34 -0500 Subject: [PATCH 06/12] Add deprecation warning --- nbs/models.nbeats.ipynb | 19 ++++++++++++++++--- neuralforecast/models/nbeats.py | 14 +++++++++++++- 2 files changed, 29 insertions(+), 4 deletions(-) diff --git a/nbs/models.nbeats.ipynb b/nbs/models.nbeats.ipynb index c6382517e..7af87481d 100644 --- a/nbs/models.nbeats.ipynb +++ b/nbs/models.nbeats.ipynb @@ -59,6 +59,7 @@ "outputs": [], "source": [ "#| export\n", + "import warnings\n", "from typing import Tuple, Optional\n", "\n", "import numpy as np\n", @@ -384,8 +385,9 @@ " `h`: int, forecast horizon.
\n", " `input_size`: int, considered autorregresive inputs (lags), y=[1,2,3,4] input_size=2 -> lags=[1,2].
\n", " `n_harmonics`: int, Number of harmonic terms for seasonality stack type. Note that len(n_harmonics) = len(stack_types). Note that it will only be used if a seasonality stack is used.
\n", + " `n_polynomials`: int, DEPRECATED - polynomial degree for trend stack. Note that len(n_polynomials) = len(stack_types). Note that it will only be used if a trend stack is used.
\n", " `basis`: str, Type of basis function to use in the trend stack. Choose one from ['legendre', 'polynomial', 'changepoint', 'piecewise_linear', 'linear_hat', 'spline', 'chebyshev']
\n", - " `n_basis`: int, the number of basis functions for the trend stack. Note that it will only be used if a trend stack is used.
\n", + " `n_basis`: int, the degree of the basis function for the trend stack. Note that it will only be used if a trend stack is used.
\n", " `stack_types`: List[str], List of stack types. Subset from ['seasonality', 'trend', 'identity'].
\n", " `n_blocks`: List[int], Number of blocks for each stack. Note that len(n_blocks) = len(stack_types).
\n", " `mlp_units`: List[List[int]], Structure of hidden layers for each stack type. Each internal list should contain the number of units of each hidden layer. Note that len(n_hidden) = len(stack_types).
\n", @@ -430,6 +432,7 @@ " h,\n", " input_size,\n", " n_harmonics: int = 2,\n", + " n_polynomials: Optional[int] = None,\n", " n_basis: int = 2,\n", " basis: str = 'polynomial',\n", " stack_types: list = ['identity', 'trend', 'seasonality'],\n", @@ -493,6 +496,15 @@ " dataloader_kwargs=dataloader_kwargs,\n", " **trainer_kwargs)\n", "\n", + " # Raise deprecation warning\n", + " if n_polynomials is not None:\n", + " warnings.warn(\n", + " \"The parameter n_polynomials will be deprecated in favor of n_basis and basis and it is currently ignored.\\n\"\n", + " \"The basis parameter defines the basis function to be used in the trend stack.\\n\"\n", + " \"The n_basis defines the degree of the basis function used in the trend stack.\",\n", + " DeprecationWarning\n", + " )\n", + " \n", " # Architecture\n", " blocks = self.create_stack(h=h,\n", " input_size=input_size,\n", @@ -796,7 +808,7 @@ "import matplotlib.pyplot as plt\n", "\n", "from neuralforecast import NeuralForecast\n", - "from neuralforecast.models import NBEATS\n", + "# from neuralforecast.models import NBEATS\n", "from neuralforecast.losses.pytorch import DistributionLoss\n", "from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic\n", "\n", @@ -804,8 +816,9 @@ "Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test\n", "\n", "model = NBEATS(h=12, input_size=24,\n", + " n_polynomials=2,\n", " basis='polynomial',\n", - " n_basis=5,\n", + " n_basis=2,\n", " loss=DistributionLoss(distribution='Poisson', level=[80, 90]),\n", " stack_types = ['identity', 'trend', 'seasonality'],\n", " max_steps=100,\n", diff --git a/neuralforecast/models/nbeats.py b/neuralforecast/models/nbeats.py index e5c805947..baf6c60eb 100644 --- a/neuralforecast/models/nbeats.py +++ b/neuralforecast/models/nbeats.py @@ -4,6 +4,7 @@ __all__ = ['NBEATS'] # %% ../../nbs/models.nbeats.ipynb 5 +import warnings from typing import Tuple, Optional import numpy as np @@ -337,8 +338,9 @@ class NBEATS(BaseWindows): `h`: int, forecast horizon.
`input_size`: int, considered autorregresive inputs (lags), y=[1,2,3,4] input_size=2 -> lags=[1,2].
`n_harmonics`: int, Number of harmonic terms for seasonality stack type. Note that len(n_harmonics) = len(stack_types). Note that it will only be used if a seasonality stack is used.
+ `n_polynomials`: int, DEPRECATED - polynomial degree for trend stack. Note that len(n_polynomials) = len(stack_types). Note that it will only be used if a trend stack is used.
`basis`: str, Type of basis function to use in the trend stack. Choose one from ['legendre', 'polynomial', 'changepoint', 'piecewise_linear', 'linear_hat', 'spline', 'chebyshev']
- `n_basis`: int, the number of basis functions for the trend stack. Note that it will only be used if a trend stack is used.
+ `n_basis`: int, the degree of the basis function for the trend stack. Note that it will only be used if a trend stack is used.
`stack_types`: List[str], List of stack types. Subset from ['seasonality', 'trend', 'identity'].
`n_blocks`: List[int], Number of blocks for each stack. Note that len(n_blocks) = len(stack_types).
`mlp_units`: List[List[int]], Structure of hidden layers for each stack type. Each internal list should contain the number of units of each hidden layer. Note that len(n_hidden) = len(stack_types).
@@ -385,6 +387,7 @@ def __init__( h, input_size, n_harmonics: int = 2, + n_polynomials: Optional[int] = None, n_basis: int = 2, basis: str = "polynomial", stack_types: list = ["identity", "trend", "seasonality"], @@ -451,6 +454,15 @@ def __init__( **trainer_kwargs, ) + # Raise deprecation warning + if n_polynomials is not None: + warnings.warn( + "The parameter n_polynomials will be deprecated in favor of n_basis and basis and it is currently ignored.\n" + "The basis parameter defines the basis function to be used in the trend stack.\n" + "The n_basis defines the degree of the basis function used in the trend stack.", + DeprecationWarning, + ) + # Architecture blocks = self.create_stack( h=h, From 9e99819b1e6e0f54cc29f1de1d033b58022c792c Mon Sep 17 00:00:00 2001 From: Olivier Sprangers Date: Wed, 5 Feb 2025 10:42:27 +0100 Subject: [PATCH 07/12] fix_example --- nbs/models.nbeats.ipynb | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/nbs/models.nbeats.ipynb b/nbs/models.nbeats.ipynb index 7af87481d..ae712972e 100644 --- a/nbs/models.nbeats.ipynb +++ b/nbs/models.nbeats.ipynb @@ -808,7 +808,7 @@ "import matplotlib.pyplot as plt\n", "\n", "from neuralforecast import NeuralForecast\n", - "# from neuralforecast.models import NBEATS\n", + "from neuralforecast.models import NBEATS\n", "from neuralforecast.losses.pytorch import DistributionLoss\n", "from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic\n", "\n", @@ -816,8 +816,8 @@ "Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test\n", "\n", "model = NBEATS(h=12, input_size=24,\n", - " n_polynomials=2,\n", - " basis='polynomial',\n", + " n_polynomials=5,\n", + " basis='changepoint',\n", " n_basis=2,\n", " loss=DistributionLoss(distribution='Poisson', level=[80, 90]),\n", " stack_types = ['identity', 'trend', 'seasonality'],\n", @@ -848,14 +848,6 @@ "plt.legend()\n", "plt.plot()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c87058ca", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 38930b4ac180f629611a336532bcf69740e5bcb6 Mon Sep 17 00:00:00 2001 From: Olivier Sprangers Date: Wed, 5 Feb 2025 10:47:59 +0100 Subject: [PATCH 08/12] fix_example --- nbs/models.nbeats.ipynb | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/nbs/models.nbeats.ipynb b/nbs/models.nbeats.ipynb index ae712972e..f5e798df5 100644 --- a/nbs/models.nbeats.ipynb +++ b/nbs/models.nbeats.ipynb @@ -808,7 +808,7 @@ "import matplotlib.pyplot as plt\n", "\n", "from neuralforecast import NeuralForecast\n", - "from neuralforecast.models import NBEATS\n", + "# from neuralforecast.models import NBEATS\n", "from neuralforecast.losses.pytorch import DistributionLoss\n", "from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic\n", "\n", @@ -816,7 +816,6 @@ "Y_test_df = AirPassengersPanel[AirPassengersPanel.ds>=AirPassengersPanel['ds'].values[-12]].reset_index(drop=True) # 12 test\n", "\n", "model = NBEATS(h=12, input_size=24,\n", - " n_polynomials=5,\n", " basis='changepoint',\n", " n_basis=2,\n", " loss=DistributionLoss(distribution='Poisson', level=[80, 90]),\n", From d0817e5ee765b70857d35b9bbe221d7a438174e5 Mon Sep 17 00:00:00 2001 From: Olivier Sprangers Date: Mon, 24 Feb 2025 21:08:18 +0100 Subject: [PATCH 09/12] merge_main --- nbs/models.nbeats.ipynb | 4 ++-- neuralforecast/models/nbeats.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/nbs/models.nbeats.ipynb b/nbs/models.nbeats.ipynb index 4615ecf45..763ebd2c5 100644 --- a/nbs/models.nbeats.ipynb +++ b/nbs/models.nbeats.ipynb @@ -825,7 +825,7 @@ "import matplotlib.pyplot as plt\n", "\n", "from neuralforecast import NeuralForecast\n", - "# from neuralforecast.models import NBEATS\n", + "from neuralforecast.models import NBEATS\n", "from neuralforecast.losses.pytorch import DistributionLoss\n", "from neuralforecast.utils import AirPassengersPanel, AirPassengersStatic\n", "\n", @@ -843,7 +843,7 @@ "\n", "fcst = NeuralForecast(\n", " models=[model],\n", - " freq='M'\n", + " freq='ME'\n", ")\n", "fcst.fit(df=Y_train_df, static_df=AirPassengersStatic, val_size=12)\n", "forecasts = fcst.predict(futr_df=Y_test_df)\n", diff --git a/neuralforecast/models/nbeats.py b/neuralforecast/models/nbeats.py index 3e79ef712..629ef4e1c 100644 --- a/neuralforecast/models/nbeats.py +++ b/neuralforecast/models/nbeats.py @@ -323,7 +323,7 @@ def forward(self, insample_y: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor] backcast, forecast = self.basis(theta) return backcast, forecast -# %% ../../nbs/models.nbeats.ipynb 9 +# %% ../../nbs/models.nbeats.ipynb 10 class NBEATS(BaseModel): """NBEATS From c61187868a8dfd7eb7d08b0e4b6efd354fdd3d2e Mon Sep 17 00:00:00 2001 From: marcopeix Date: Fri, 28 Mar 2025 10:10:16 -0400 Subject: [PATCH 10/12] Hide polynomial basis in AutoNBEATS --- nbs/models.ipynb | 2 -- neuralforecast/auto.py | 2 -- 2 files changed, 4 deletions(-) diff --git a/nbs/models.ipynb b/nbs/models.ipynb index 200e850ce..8ba720109 100644 --- a/nbs/models.ipynb +++ b/nbs/models.ipynb @@ -1349,8 +1349,6 @@ " default_config = {\n", " \"input_size_multiplier\": [1, 2, 3, 4, 5],\n", " \"h\": None,\n", - " \"basis\": tune.choice([\"polynomial\", \"changepoint\"]),\n", - " \"n_basis\": tune.choice([2, 5]),\n", " \"learning_rate\": tune.loguniform(1e-4, 1e-1),\n", " \"scaler_type\": tune.choice([None, 'robust', 'standard']),\n", " \"max_steps\": tune.choice([500, 1000]),\n", diff --git a/neuralforecast/auto.py b/neuralforecast/auto.py index 50faa5300..eeefad917 100644 --- a/neuralforecast/auto.py +++ b/neuralforecast/auto.py @@ -631,8 +631,6 @@ class AutoNBEATS(BaseAuto): default_config = { "input_size_multiplier": [1, 2, 3, 4, 5], "h": None, - "basis": tune.choice(["polynomial", "changepoint"]), - "n_basis": tune.choice([2, 5]), "learning_rate": tune.loguniform(1e-4, 1e-1), "scaler_type": tune.choice([None, "robust", "standard"]), "max_steps": tune.choice([500, 1000]), From 7a143b0ae1b8e41c7e5eb1b3c4357936ccb5eef7 Mon Sep 17 00:00:00 2001 From: marcopeix Date: Fri, 28 Mar 2025 10:42:55 -0400 Subject: [PATCH 11/12] Fix linter --- .github/workflows/lint.yaml | 2 +- settings.ini | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml index fe9789c23..259f90fd7 100644 --- a/.github/workflows/lint.yaml +++ b/.github/workflows/lint.yaml @@ -19,7 +19,7 @@ jobs: python-version: "3.10" - name: Install dependencies - run: pip install black nbdev==2.3.25 pre-commit + run: pip install black nbdev<2.3.26 pre-commit - name: Run pre-commit run: pre-commit run --files neuralforecast/* diff --git a/settings.ini b/settings.ini index a2c955028..68318f48c 100644 --- a/settings.ini +++ b/settings.ini @@ -18,7 +18,7 @@ status = 2 requirements = coreforecast>=0.0.6 fsspec numpy>=1.21.6 pandas>=1.3.5 torch>=2.0.0 pytorch-lightning>=2.0.0 ray[tune]>=2.2.0 optuna utilsforecast>=0.2.3 spark_requirements = fugue pyspark>=3.5 aws_requirements = fsspec[s3] -dev_requirements = black gitpython hyperopt ipython<=8.32.0 matplotlib mypy nbdev==2.3.25 polars pre-commit pyarrow ruff s3fs transformers +dev_requirements = black gitpython hyperopt ipython<=8.32.0 matplotlib mypy nbdev<2.3.26 polars pre-commit pyarrow ruff s3fs transformers nbs_path = nbs doc_path = _docs recursive = True From d862d22b14c055bdd57d7caddce41e0190c0294c Mon Sep 17 00:00:00 2001 From: marcopeix Date: Fri, 28 Mar 2025 10:47:40 -0400 Subject: [PATCH 12/12] Remove nbdev constraint --- .github/workflows/lint.yaml | 2 +- settings.ini | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml index 259f90fd7..39a9a9d0a 100644 --- a/.github/workflows/lint.yaml +++ b/.github/workflows/lint.yaml @@ -19,7 +19,7 @@ jobs: python-version: "3.10" - name: Install dependencies - run: pip install black nbdev<2.3.26 pre-commit + run: pip install black nbdev pre-commit - name: Run pre-commit run: pre-commit run --files neuralforecast/* diff --git a/settings.ini b/settings.ini index 68318f48c..d02ae41ec 100644 --- a/settings.ini +++ b/settings.ini @@ -18,7 +18,7 @@ status = 2 requirements = coreforecast>=0.0.6 fsspec numpy>=1.21.6 pandas>=1.3.5 torch>=2.0.0 pytorch-lightning>=2.0.0 ray[tune]>=2.2.0 optuna utilsforecast>=0.2.3 spark_requirements = fugue pyspark>=3.5 aws_requirements = fsspec[s3] -dev_requirements = black gitpython hyperopt ipython<=8.32.0 matplotlib mypy nbdev<2.3.26 polars pre-commit pyarrow ruff s3fs transformers +dev_requirements = black gitpython hyperopt ipython<=8.32.0 matplotlib mypy nbdev polars pre-commit pyarrow ruff s3fs transformers nbs_path = nbs doc_path = _docs recursive = True