From 26b2875778f2018070759a69de631109b753e4f3 Mon Sep 17 00:00:00 2001 From: Andreas Motl Date: Tue, 7 Nov 2023 22:13:58 +0100 Subject: [PATCH 1/2] Improve testing Jupyter Notebooks In order to improve the development experience when authoring Jupyter Notebooks, this patch pulls in generalized utility functions from other libraries, mostly `cratedb-toolkit` and `pueblo.testing`, so they don't need to be repeated as boilerplate code over and over again. Rename example `timeseries-basics` to `mlops-mlflow`. Add Jupyter Notebook about MLflow/Merlion to `mlops-mlflow` directory from `ml-sandbox` repository. --- .github/dependabot.yml | 6 +- .github/workflows/test-mlflow.yml | 72 +++ .../llm-langchain/conftest.py | 4 +- .../llm-langchain/document_loader.py | 2 +- .../llm-langchain/requirements-dev.txt | 17 +- .../llm-langchain/requirements.txt | 6 +- topic/machine-learning/llm-langchain/test.py | 111 +---- .../.gitignore | 3 + .../mlops-mlflow/pyproject.toml | 46 ++ .../readme.md | 0 .../mlops-mlflow/requirements-dev.txt | 11 + .../mlops-mlflow/requirements.txt | 3 + topic/machine-learning/mlops-mlflow/test.py | 41 ++ .../mlops-mlflow/tracking_merlion.ipynb | 430 ++++++++++++++++++ .../tracking_merlion.py | 15 +- .../timeseries-basics/requirements.txt | 3 - 16 files changed, 656 insertions(+), 114 deletions(-) create mode 100644 .github/workflows/test-mlflow.yml rename topic/machine-learning/{timeseries-basics => mlops-mlflow}/.gitignore (52%) create mode 100644 topic/machine-learning/mlops-mlflow/pyproject.toml rename topic/machine-learning/{timeseries-basics => mlops-mlflow}/readme.md (100%) create mode 100644 topic/machine-learning/mlops-mlflow/requirements-dev.txt create mode 100644 topic/machine-learning/mlops-mlflow/requirements.txt create mode 100644 topic/machine-learning/mlops-mlflow/test.py create mode 100644 topic/machine-learning/mlops-mlflow/tracking_merlion.ipynb rename topic/machine-learning/{timeseries-basics => mlops-mlflow}/tracking_merlion.py (93%) delete mode 100644 topic/machine-learning/timeseries-basics/requirements.txt diff --git a/.github/dependabot.yml b/.github/dependabot.yml index 10829f8e..dfc6f6a8 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -63,14 +63,14 @@ updates: schedule: interval: "weekly" - # Frameworks. + # Topics. - - directory: "/framework/langchain" + - directory: "/topic/machine-learning/llm-langchain" package-ecosystem: "pip" schedule: interval: "weekly" - - directory: "/framework/mlflow" + - directory: "/topic/machine-learning/mlops-mlflow" package-ecosystem: "pip" schedule: interval: "weekly" diff --git a/.github/workflows/test-mlflow.yml b/.github/workflows/test-mlflow.yml new file mode 100644 index 00000000..035ee7ab --- /dev/null +++ b/.github/workflows/test-mlflow.yml @@ -0,0 +1,72 @@ +name: MLflow + +on: + pull_request: + branches: ~ + paths: + - '.github/workflows/test-mlflow.yml' + - 'topic/machine-learning/mlops-mlflow/**' + - 'requirements.txt' + push: + branches: [ main ] + paths: + - '.github/workflows/test-mlflow.yml' + - 'topic/machine-learning/mlops-mlflow/**' + - 'requirements.txt' + + # Allow job to be triggered manually. + workflow_dispatch: + + # Run job each night after CrateDB nightly has been published. + schedule: + - cron: '0 3 * * *' + +# Cancel in-progress jobs when pushing to the same branch. +concurrency: + cancel-in-progress: true + group: ${{ github.workflow }}-${{ github.ref }} + +jobs: + test: + name: " + Python: ${{ matrix.python-version }} + CrateDB: ${{ matrix.cratedb-version }} + on ${{ matrix.os }}" + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: [ 'ubuntu-latest' ] + python-version: [ '3.10' ] + cratedb-version: [ 'nightly' ] + + services: + cratedb: + image: crate/crate:nightly + ports: + - 4200:4200 + - 5432:5432 + + steps: + + - name: Acquire sources + uses: actions/checkout@v4 + + - name: Set up Python + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + architecture: x64 + cache: 'pip' + cache-dependency-path: | + requirements.txt + topic/machine-learning/mlops-mlflow/requirements.txt + topic/machine-learning/mlops-mlflow/requirements-dev.txt + + - name: Install utilities + run: | + pip install -r requirements.txt + + - name: Validate topic/machine-learning/mlops-mlflow + run: | + ngr test --accept-no-venv topic/machine-learning/mlops-mlflow diff --git a/topic/machine-learning/llm-langchain/conftest.py b/topic/machine-learning/llm-langchain/conftest.py index 25107dac..99fdcf49 100644 --- a/topic/machine-learning/llm-langchain/conftest.py +++ b/topic/machine-learning/llm-langchain/conftest.py @@ -1,4 +1,6 @@ -from pueblo.testing.notebook import monkeypatch_pytest_notebook_treat_cell_exit_as_notebook_skip +# Initialize nltk upfront, so that it does not run stray output into Jupyter Notebooks. +from pueblo.testing.nlp import nltk_init # Make `pytest.exit()` called in notebook cells gracefully skip testing the whole notebook. +from pueblo.testing.notebook import monkeypatch_pytest_notebook_treat_cell_exit_as_notebook_skip monkeypatch_pytest_notebook_treat_cell_exit_as_notebook_skip() diff --git a/topic/machine-learning/llm-langchain/document_loader.py b/topic/machine-learning/llm-langchain/document_loader.py index 70934820..24f2e479 100644 --- a/topic/machine-learning/llm-langchain/document_loader.py +++ b/topic/machine-learning/llm-langchain/document_loader.py @@ -37,7 +37,7 @@ def main(): loader = CrateDBLoader( - query="SELECT * FROM mlb_teams_2012 LIMIT 3;", + query="SELECT * FROM doc.mlb_teams_2012 LIMIT 3;", url=CONNECTION_STRING, include_rownum_into_metadata=True, ) diff --git a/topic/machine-learning/llm-langchain/requirements-dev.txt b/topic/machine-learning/llm-langchain/requirements-dev.txt index 1f1a8ead..ed7a3fd0 100644 --- a/topic/machine-learning/llm-langchain/requirements-dev.txt +++ b/topic/machine-learning/llm-langchain/requirements-dev.txt @@ -1,6 +1,11 @@ -coverage~=7.3 -ipykernel -pytest<8 -pytest-cov<5 -pytest-env<2 -pytest-notebook<0.9 +# Real. +# cratedb-toolkit[io] +# pueblo[testing] + +# Development. +cratedb-toolkit[io] @ git+https://github.com/crate-workbench/cratedb-toolkit.git@amo/add-import-csv +pueblo[testing] @ git+https://github.com/pyveci/pueblo.git@main + +# Workstation. +#--editable=/Users/amo/dev/crate/ecosystem/cratedb-retentions[io] +#--editable=/Users/amo/dev/pyveci/sources/pueblo[testing] diff --git a/topic/machine-learning/llm-langchain/requirements.txt b/topic/machine-learning/llm-langchain/requirements.txt index e6a4473d..fa93608d 100644 --- a/topic/machine-learning/llm-langchain/requirements.txt +++ b/topic/machine-learning/llm-langchain/requirements.txt @@ -1,11 +1,13 @@ +# Real. crash crate[sqlalchemy] # langchain[cratedb,openai] -pueblo[env,nlp]==0.0.2 +# pueblo[env,nlp]==0.0.3 +pydantic>=1,<2 python-dotenv<2 requests-cache<2 unstructured<0.11 # Development. langchain[cratedb,openai] @ git+https://github.com/crate-workbench/langchain.git@cratedb#subdirectory=libs/langchain -# pueblo[env,nlp] @ git+https://github.com/pyveci/pueblo.git@develop +pueblo[nlp] @ git+https://github.com/pyveci/pueblo.git@main diff --git a/topic/machine-learning/llm-langchain/test.py b/topic/machine-learning/llm-langchain/test.py index 39f41de8..1f04fbc5 100644 --- a/topic/machine-learning/llm-langchain/test.py +++ b/topic/machine-learning/llm-langchain/test.py @@ -1,96 +1,38 @@ -import importlib -import io import os -import sys +import time from pathlib import Path -from unittest import mock import pytest -from _pytest.python import Function - -HERE = Path(__file__).parent - - -def list_files(path: Path, pattern: str): - """ - Enumerate all files in given directory. - """ - files = path.glob(pattern) - files = [item.relative_to(path) for item in files] - return files - - -def list_notebooks(path: Path): - """ - Enumerate all Jupyter Notebook files found in given directory. - """ - return list_files(path, "**/*.ipynb") - - -def list_pyfiles(path: Path): - """ - Enumerate all regular Python files found in given directory. - """ - pyfiles = [] - for item in list_files(path, "**/*.py"): - if item.suffix != ".py" or item.name in ["conftest.py"] or item.name.startswith("test"): - continue - pyfiles.append(item) - return pyfiles +from cratedb_toolkit.io.sql import DatabaseAdapter +from pueblo.testing.folder import str_list, list_notebooks, list_python_files +from pueblo.testing.snippet import pytest_module_function, pytest_notebook -def str_list(things): - """ - Converge list to list of strings. - """ - return map(str, things) +HERE = Path(__file__).parent -@pytest.fixture(scope="session", autouse=True) -def nltk_init(): - """ - Initialize nltk upfront, so that it does not run stray output into Jupyter Notebooks. - """ - download_items = ["averaged_perceptron_tagger", "punkt"] - import nltk - for item in download_items: - nltk.download(item) +@pytest.fixture() +def cratedb() -> DatabaseAdapter: + return DatabaseAdapter(dburi="crate://crate@localhost:4200") @pytest.fixture(scope="function", autouse=True) -def db_init(): +def db_init(cratedb): """ Initialize database. """ - run_sql(statement="DROP TABLE IF EXISTS mlb_teams_2012;") + cratedb.run_sql("DROP TABLE IF EXISTS mlb_teams_2012;") + time.sleep(0.01) -def db_provision_mlb_teams_2012(): +def db_provision_mlb_teams_2012(cratedb): """ Provision database. """ - run_sql(file="mlb_teams_2012.sql") - run_sql(statement="REFRESH TABLE mlb_teams_2012;") - - -def run_sql(statement: str = None, file: str = None): - """ - Run SQL from string or file. - """ - import crate.crash.command - sys.argv = ["foo", "--schema=testdrive"] - if statement: - sys.argv += ["--command", statement] - if file: - sys.stdin = io.StringIO(Path(file).read_text()) - with \ - mock.patch("crate.crash.repl.SQLCompleter._populate_keywords"), \ - mock.patch("crate.crash.command.CrateShell.close"): - try: - crate.crash.command.main() - except SystemExit as ex: - if ex.code != 0: - raise + cratedb.run_sql(Path("mlb_teams_2012.sql")) + time.sleep(0.01) + cratedb.run_sql("REFRESH TABLE mlb_teams_2012;") + time.sleep(0.01) @pytest.mark.parametrize("notebook", str_list(list_notebooks(HERE))) @@ -101,22 +43,15 @@ def test_notebook(request, notebook: str): Not using `NBRegressionFixture`, because it would manually need to be configured. """ - from _pytest._py.path import LocalPath - from pytest_notebook.plugin import pytest_collect_file - tests = pytest_collect_file(LocalPath(notebook), request.node) - for test in tests.collect(): - test.runtest() + pytest_notebook(request=request, filepath=notebook) -@pytest.mark.parametrize("pyfile", str_list(list_pyfiles(HERE))) -def test_file(request, pyfile: Path): +@pytest.mark.parametrize("pyfile", str_list(list_python_files(HERE))) +def test_file(request, cratedb, pyfile: Path): """ From individual Python file, collect and wrap the `main` function into a test case. """ - # TODO: Make configurable. - entrypoint_symbol = "main" - # Skip `vector_search.py` example, when no `OPENAI_API_KEY` is supplied. if str(pyfile).endswith("vector_search.py"): if "OPENAI_API_KEY" not in os.environ: @@ -124,10 +59,6 @@ def test_file(request, pyfile: Path): # `document_loader.py` needs provisioning. if str(pyfile).endswith("document_loader.py"): - db_provision_mlb_teams_2012() + db_provision_mlb_teams_2012(cratedb) - path = Path(pyfile) - mod = importlib.import_module(path.stem) - fun = getattr(mod, entrypoint_symbol) - f = Function.from_parent(request.node, name="main", callobj=fun) - f.runtest() + pytest_module_function(request, pyfile) diff --git a/topic/machine-learning/timeseries-basics/.gitignore b/topic/machine-learning/mlops-mlflow/.gitignore similarity index 52% rename from topic/machine-learning/timeseries-basics/.gitignore rename to topic/machine-learning/mlops-mlflow/.gitignore index e368aa27..82febb2a 100644 --- a/topic/machine-learning/timeseries-basics/.gitignore +++ b/topic/machine-learning/mlops-mlflow/.gitignore @@ -1,3 +1,6 @@ +.idea +.ruff_cache +.venv* /mlartifacts /mlruns /model diff --git a/topic/machine-learning/mlops-mlflow/pyproject.toml b/topic/machine-learning/mlops-mlflow/pyproject.toml new file mode 100644 index 00000000..49643c74 --- /dev/null +++ b/topic/machine-learning/mlops-mlflow/pyproject.toml @@ -0,0 +1,46 @@ +[tool.pytest.ini_options] +minversion = "2.0" +addopts = """ + -rfEX -p pytester --strict-markers --verbosity=3 --capture=no + """ +env = [ + "CRATEDB_CONNECTION_STRING=crate://crate@localhost/?schema=testdrive", + "PYDEVD_DISABLE_FILE_VALIDATION=1", +] + +#log_level = "DEBUG" +#log_cli_level = "DEBUG" + +testpaths = [ + "*.py", +] +xfail_strict = true +markers = [ +] + +# pytest-notebook settings +nb_test_files = true +nb_coverage = true +nb_diff_replace = [ + # Compensate output of `crash`. + '"/cells/*/outputs/*/text" "\(\d.\d+ sec\)" "(0.000 sec)"', +] +# `vector_search.py` does not include any output(s). +nb_diff_ignore = [ + "/metadata/language_info", + "/cells/*/execution_count", + "/cells/*/outputs/*/execution_count", + # Ignore images. + "/cells/*/outputs/*/data/image/png", +] + +[tool.coverage.run] +branch = false + +[tool.coverage.report] +fail_under = 0 +show_missing = true +omit = [ + "conftest.py", + "test*.py", +] diff --git a/topic/machine-learning/timeseries-basics/readme.md b/topic/machine-learning/mlops-mlflow/readme.md similarity index 100% rename from topic/machine-learning/timeseries-basics/readme.md rename to topic/machine-learning/mlops-mlflow/readme.md diff --git a/topic/machine-learning/mlops-mlflow/requirements-dev.txt b/topic/machine-learning/mlops-mlflow/requirements-dev.txt new file mode 100644 index 00000000..ed7a3fd0 --- /dev/null +++ b/topic/machine-learning/mlops-mlflow/requirements-dev.txt @@ -0,0 +1,11 @@ +# Real. +# cratedb-toolkit[io] +# pueblo[testing] + +# Development. +cratedb-toolkit[io] @ git+https://github.com/crate-workbench/cratedb-toolkit.git@amo/add-import-csv +pueblo[testing] @ git+https://github.com/pyveci/pueblo.git@main + +# Workstation. +#--editable=/Users/amo/dev/crate/ecosystem/cratedb-retentions[io] +#--editable=/Users/amo/dev/pyveci/sources/pueblo[testing] diff --git a/topic/machine-learning/mlops-mlflow/requirements.txt b/topic/machine-learning/mlops-mlflow/requirements.txt new file mode 100644 index 00000000..77a8bab2 --- /dev/null +++ b/topic/machine-learning/mlops-mlflow/requirements.txt @@ -0,0 +1,3 @@ +mlflow-cratedb==2.7.1 +pydantic<1 +salesforce-merlion>=2,<3 diff --git a/topic/machine-learning/mlops-mlflow/test.py b/topic/machine-learning/mlops-mlflow/test.py new file mode 100644 index 00000000..3cc4dc5e --- /dev/null +++ b/topic/machine-learning/mlops-mlflow/test.py @@ -0,0 +1,41 @@ +from pathlib import Path + +import pytest + +from cratedb_toolkit.util import DatabaseAdapter +from pueblo.testing.folder import str_list, list_notebooks, list_python_files +from pueblo.testing.snippet import pytest_module_function, pytest_notebook + +HERE = Path(__file__).parent + + +@pytest.fixture() +def cratedb() -> DatabaseAdapter: + return DatabaseAdapter(dburi="crate://crate@localhost:4200") + + +@pytest.fixture(scope="function", autouse=True) +def db_init(cratedb): + """ + Initialize database. + """ + cratedb.run_sql("DROP TABLE IF EXISTS machine_data;") + + +@pytest.mark.parametrize("notebook", str_list(list_notebooks(HERE))) +def test_notebook(request, notebook: str): + """ + From individual Jupyter Notebook file, collect cells as pytest + test cases, and run them. + + Not using `NBRegressionFixture`, because it would manually need to be configured. + """ + pytest_notebook(request=request, filepath=notebook) + + +@pytest.mark.parametrize("pyfile", str_list(list_python_files(HERE))) +def test_file(request, pyfile: Path): + """ + From individual Python file, collect and wrap the `main` function into a test case. + """ + pytest_module_function(request, pyfile) diff --git a/topic/machine-learning/mlops-mlflow/tracking_merlion.ipynb b/topic/machine-learning/mlops-mlflow/tracking_merlion.ipynb new file mode 100644 index 00000000..0bcf4fe8 --- /dev/null +++ b/topic/machine-learning/mlops-mlflow/tracking_merlion.ipynb @@ -0,0 +1,430 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create a Time Series Anomaly Detection Model using Salesforce Merlion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Connect to CrateDB" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import warnings\n", + "import pandas as pd\n", + "import numpy as np\n", + "from crate import client\n", + "\n", + "# Before starting, silence a particular warning on recent versions of NumPy.\n", + "# TODO: Stop using `swapaxes`.\n", + "warnings.filterwarnings(\"ignore\", message=r\"'DataFrame.swapaxes' is deprecated\", category=FutureWarning)\n", + "\n", + "\n", + "# Download the data from the Numenta Anomaly Benchmark\n", + "data = pd.read_csv(\"https://github.com/crate/cratedb-datasets/raw/main/timeseries/anomaly/nab-machine-failure.csv\")\n", + "\n", + "# Connect to a self-managed CrateDB instance.\n", + "CRATEDB_HTTP_URL_DEFAULT = \"http://crate@localhost:4200/\"\n", + "\n", + "# Connect to CrateDB Cloud.\n", + "# CRATEDB_HTTP_URL_DEFAULT = \"https://:@.azure.cratedb.net:4200?ssl=true\"\n", + "\n", + "CRATEDB_HTTP_URL = os.getenv(\"CRATEDB_HTTP_URL\", CRATEDB_HTTP_URL_DEFAULT)\n", + "\n", + "conn = client.connect(CRATEDB_HTTP_URL)\n" + ] + }, + { + "cell_type": "markdown", + "source": [ + "2. Import data into CrateDB" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Split the data into chunks of 1000 rows each for better insert performance\n", + "chunk_size = 1000\n", + "chunks = np.array_split(data, int(len(data)/chunk_size))\n", + "\n", + "# Insert the data into CrateDB\n", + "with conn:\n", + " cursor = conn.cursor()\n", + " # Create the table if it doesn't exist\n", + " cursor.execute(\"CREATE TABLE IF NOT EXISTS machine_data (timestamp TIMESTAMP, temperature DOUBLE);\")\n", + " # Insert the data in chunks\n", + " for chunk in chunks:\n", + " cursor.executemany(\"INSERT INTO machine_data (timestamp, temperature) VALUES (?, ?);\", list(chunk.itertuples(index=False, name=None)))\n", + " cursor.execute(\"REFRESH TABLE machine_data;\")" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "is_executing": true + } + } + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. Read back the dataset from CrateDB\n", + "\n", + " Also, prepare data to be used for the model training approach." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "from crate import client\n", + "\n", + "conn = client.connect(CRATEDB_HTTP_URL)\n", + "\n", + "with conn:\n", + " cursor = conn.cursor()\n", + " cursor.execute(\"\"\"SELECT \n", + " DATE_BIN('5 min'::INTERVAL, \"timestamp\", 0) AS timestamp,\n", + " MAX(temperature) AS value\n", + " FROM machine_data\n", + " GROUP BY timestamp\n", + " ORDER BY timestamp ASC;\"\"\")\n", + " data = cursor.fetchall()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "# Convert crate returned data to pandas DataFrame\n", + "time_series = pd.DataFrame([{'timestamp': pd.Timestamp.fromtimestamp(item[0] / 1000), 'value': item[1]} for item in data])\n", + "# Set the timestamp as the index\n", + "time_series = time_series.set_index('timestamp')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Plot the dataset using matplotlib" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ4AAAKsCAYAAACtcXd2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddXwT9xsH8E+bFkoLpUVKcXf34lAo7htjsME2GDZchg/YBgM2bLjDsA0Zw4a7DC2uxZ0WKtRLJb8/8rvkNLm7XKTleb9evEguJ99eksvdc8/3+bro9Xo9CCGEEEIIIYQQQgjRmKujG0AIIYQQQgghhBBCMiYKPBFCCCGEEEIIIYQQm6DAEyGEEEIIIYQQQgixCQo8EUIIIYQQQgghhBCboMATIYQQQgghhBBCCLEJCjwRQgghhBBCCCGEEJugwBMhhBBCCCGEEEIIsQkKPBFCCCGEEEIIIYQQm6DAEyGEEEIIIYQQQgixCQo8EUIIIYQQgfPnz6N06dKcf2PHjnV0swghhBCSzrg5ugGEEJIeBQYG4uXLl1avp1atWli/fr0GLSIk4wgNDcW+fftw/vx5PHjwAFFRUUhISED27NmRI0cOVK1aFXXr1kWzZs3g5kanMgCwfft2jBs3TpN1rVu3DrVr19ZkXYQQQgghdLZGCCGE2EDp0qU5z/Pnz4+jR486qDXpQ1xcHGbPno2tW7fiw4cPgtffvXuHd+/eISQkBJs3b0b+/PkxfPhwtGvXzgGtJYQQQgghclDgiRBCCCEO9/z5cwwYMAD379+XvczLly8xatQoXLlyBRMnToSrK1UQ0JK/vz969uzJmVapUiUHtYYQQggh6RUFngghRIXOnTvj/fv3gumxsbHYvn276PxZs2YVTC9cuLBN2kdIehIbG4s+ffrg8ePHgtdy586N2rVrI2vWrHjx4gXOnz+P5ORkzjwbN25E1qxZMWLECHs12emUKFFCECRinDlzBg8fPuRMK168OOrVqyc6v7+/PwDD8WnChAnaNpQQQgghHx0XvV6vd3QjCCEko3jx4gWaNm0qmH7kyBEUKFDAAS0ijkJd7eQbM2YMduzYIZg+dOhQ9OvXDzqdzjjtzZs3GDFiBIKDgwXzU20icWPHjsU///zDmdapUyfMmDHDQS0ihBBCyMeEMp4IIcQJvHz5Etu2bcOFCxfw9OlTREVFwcPDA3nz5kWtWrXQpUsXlClTRnL5Hj164MKFC5xpR44cga+vL1avXo39+/fjxYsXyJYtG6pVq4Y+ffqgYsWKxnlDQkKwatUqnD9/Hu/evUPOnDlRt25d9O/fXzIrS+xidt26dahVqxZ27tyJ7du3IyQkBPHx8cibNy8CAwPRp08f5MiRw+L+uHr1Knbt2oXg4GC8efMGcXFxyJYtGwoXLoz69evj888/R65cuSSXFyv+fu/ePURFRWHNmjU4evQoXr58ibi4OEyfPh2dO3cGAFy7dg3Xrl3DzZs38eDBA7x//x7v379HQkICPD09kTNnTpQtWxbNmjVDUFAQMmXKxNmGuQLPL1++NBuMElt20KBBGDx4sGBdcoJa5tZ34sQJ/PXXX7hx4wYiIiLg7+8vGhR78OAB/v77b1y6dAkvX75EdHQ0vLy8kD9/fgQEBKBbt24oWLCg6N8r19OnT7F7927B9N69e+O7774TTPf398fy5cvRqVMnPHv2jPPawoULjYGnM2fOoFevXpzXv/zyS/zwww+i7bh69Sq6du3Kmda+fXv89ttvgnkjIiKwbds2nD171lj83N3dHblz50aNGjXQqVMn1KhRQ/JvXrBgARYuXMiZxnwOd+/eje3bt+PevXuIjIxEjRo1HDYAwfnz5wVZVGIBK0ccf9js8TklhBBCiHoUeCKEEAdKSUnBvHnzsGbNGqSkpHBeS05ORkxMDEJCQrBx40Z069YN48ePh7u7u6x1P3/+HF999RVevHhhnJaYmIgDBw7g6NGjmDFjBtq2bYudO3di4sSJnGLOb968wfbt23HgwAGsWrUKVatWlbXNxMREfPvttzh9+jRn+pMnT7B69Wr8888/WLlyJSpUqCC6fEREBMaPH49jx46JvhYREYErV65g1apVGD9+PLp06SKrXYDh4rZXr154+/at5Dx9+/ZFVFSU6GvR0dGIjo7G48ePsXfvXhQrVgzz589HyZIlZbfBGUydOtViICMhIQE//fQT/vnnH/ATo6OiohAVFYVbt25h3bp1GDBgAAYOHKi6PX///TdSU1M507Jnz45BgwZJLpM1a1YMGTIEo0aN4ky/cOECnjx5giJFiqBOnTrImzcvXr9+bXx9//79GD9+PCeDirF3717BtE6dOgmmrV27FnPnzkViYiJn+ocPHxAXF4cnT55g27ZtaNGiBaZPnw4vLy/Jv4MtNTUVgwYNwqFDh2TN7+zscfyx5+eUEEIIIepRFU5CCHEQvV6PYcOGYcWKFYKgk9i8mzZtwrBhwwQXWFKGDRvGuehjS05OxsSJE7F161aMGzdOdAQxwDDK2KhRowQ1daRMmTJFEHRii4yMRO/evREaGip4LSIiAp9//rlo0IkvPj4eEydOxNq1a2W1CwD69OljNuik1KNHj9CnTx/RWl/Oatu2bRaDTklJSfj666+xfft2i5+15ORkzJ8/H1OnTlXdpnPnzgmmNW3aFJ6enmaXCwoKgoeHh2D6+fPnAQCurq5o374957V3794JMnMAw/dr//79nGl58+ZFQEAAZ9q0adMwffp0QdBJzIEDB/D1119Lfrf4Fi5cmGGCToDtjz/2/pwSQgghRD3KeCKEEAdZvXq14ELT1dUVtWrVQuHChREeHo6TJ09yLsoOHz6MDRs2oEePHhbXHxUVBU9PTwQGBiItLQ2HDh3iXMAlJCRg4sSJAIA8efKgYcOGeP36tSBw9OLFCxw/fhxBQUEWt/nq1Su4uLigXr16KFiwIB4+fCi40I+KisL06dMxb948zvRx48bh6dOnnGmenp6oV68ecuTIgcePHwvW9dtvv6FmzZooX768xba9efMGAFC+fHlUqFABcXFxuHHjhmA+FxcXlCpVCnny5IGPjw+8vb3x4cMHvHz5EpcuXUJSUpJx3tevX2P9+vXG7Bx2ged169Zx1uvl5YVPPvmEMy179uwW260lZh9kzZoV9erVg4+PD16+fMkJEMycORNXr17lLOfu7o66devC398fr169wn///cfJUlq/fj3q1q2LwMBAxW26ffu2YBq7G5YUDw8PlCxZUvAe3rp1y/i4U6dOWLZsGef1vXv3ok6dOpxpwcHBgmBohw4dOKPk7d+/X/CeAkDVqlVRokQJxMbG4tSpU4iNjTW+dv36dcyZMwdjx461+Pcw702OHDlQt25deHp64smTJ+l2pD5bH3/s/TklhBBCiHoUeCKEEAdISEjA8uXLOdOyZcuGNWvWcC66nz59iq5duyIyMtI4bdmyZejataugvhCfl5cXtmzZghIlSgAA/vzzT0yZMkUwX5kyZYyjggGGrKU///yTM8+FCxdkBZ5cXFywePFizoXd5s2bMWnSJM58Bw8exOvXr5E3b14AhtpKx48fF7RrzZo1nJpQhw4dwuDBg40ZDikpKVi8eDEWLVokq22//PKLsZ4TIz4+3vh4+vTpqFKlimQdqufPn6NTp06IiYkxTjt8+LAx8FSpUiXjcPP8IIWPj49TjBBWqVIlLFu2jPM3xsXFATAE0rZs2cKZP2/evFi/fj2nRs7Vq1fRs2dPThBu/vz5ii/oY2NjRbNZmFHVLMmTJ48g8MTuKlm0aFFUqVKFE6A4ePAgJk+eDDc30ymQnG52v//+O+e5u7s7Fi1ahEaNGhmnRUREoFu3bnjy5Ilx2qZNm9C7d2/kzp3b4t/TpEkTzJ49m9M9j3lv0htbHn/s/TklhBBCiHXS5200QghJ5y5cuCCoJdSjRw9BpkfhwoUFWTJv374VHdGLr2vXrsaLPgCoX7++6HzDhw83XvQBQOvWrQXz8At1S2nevLngoq5r167GYAwjNTWVk9lw4MABwbrGjh0rCAAFBQUJ9tGJEyeQkJBgsW2dOnUSBJ0AcLp0BQYGIkeOHAgLC8OhQ4ewYsUKzJ07F7/88gumTZuGdevWIUuWLJzlQ0JCLHaVdBY6nQ5z5swR7Fcm0HH06FFBIGjQoEGCwsxVqlQRvM937twRFPu2RCqowt/HUsS647GDgoAwgBQVFYUzZ84Yn6empgo+f1WrVkWRIkWMzx88eIBHjx5x5mndujUn6AQYspW++uorzrSkpCRBUFVM9uzZ8euvvwpqQsmtEeVsbHn8sffnlBBCCCHWoYwnQghxgGvXrgmmLV68GIsXL5a1/JUrVwTdhfj4F3piGReurq6C9YjNx+4+ZE6DBg0k23L9+nXOtLt37xof818DgK+//lrWNpOTk3Hr1i2zo4gBEA068d25cwczZszA+fPnZdfSSk1NRXR0tKzR+hytRo0aZkf3EnsfJkyYIDtT68qVKyhUqJDs9kgFVeQEEqXmy5YtG+d569at8csvv3CyXvbt22cMGl24cAHv3r3jLMP/rIh9X3fu3ImdO3fKaufVq1ctFsJv2rQpvL29Za0vPbDl8cfen1NCCCGEWIcyngghxAEiIiKsWj48PNziPPzuSpkzZxbMkyNHDsF0sVHz5AZhmK5zltoCgNN90B77o3Tp0mZfv3btGrp164Zz587J/nsZcgMljmZpH9jjfWDLmjWr6OeNqXdkidh8Pj4+nOfe3t5o2rQpZ9rhw4eNtdP43ew8PDwEWTfO8PlMb2x5/LH355QQQggh1qHAEyGEpEPsukRS+Bd0Li4uFuexltg2APHAldS8asjZH/xMGL6ffvpJdQBJaaBKrrS0NME0dsBOKUv7wFpy3ge+cuXKCaaJFX3nS0xMxP379wXTxQrNd+zYkfM8JiYGJ0+eREpKCg4ePMh5rVmzZpyuX1qQU6fJ1u+NvTni+COXms8pIYQQQtSjrnaEEOIAOXPmFExr0KABihYtKmt5fs0kZ/Hq1SvR6fwRwwBuZkrOnDnx8OFDzutdunSRXeunePHiFucxF+gKDQ3FzZs3OdPc3NwwbNgwtGnTBrlz5zZmYnTt2lUwmpYWxEYvS0xMFEyT2sdyWAr2iX0uW7VqJaswNqDucxkQECDoynb06FEkJCSYff8PHz4sun9q164tmFa/fn3kzp0bb9++NU7bu3cvMmXKJKi1xq8JBYjvl6pVq8oafQ8w1GqzRMtAbEbniM8pIYQQQtSjwBMhhDiA2AVrwYIFZdUoSU1NhU6ns0WzrHbq1CnRWjbsYs6MMmXKGB9XqFABFy5c4Lxer149tGrVyuI2tdgfr1+/Fkxr0KAB+vTpw5kWHx+PkJAQWet0dXXlZCyxh3UXI1YoOywsTDBtz549sravRsWKFfHPP/9wplWoUAHffvutxWXVvg+ffPIJVq5cydk/UVFRWLx4MUaOHCm6TFxcHObPny+YXqtWLU5RcIZOp0P79u2xatUq47Rjx44JMsr8/f1Rt25dwfJi31dvb29Z31e9Xm+zjLiPlSM+p4QQQghRj7raEUKIA9SqVQvZs2fnTNu8eTP++ecfyYvUu3fvYv78+WjSpIk9mqjKwYMHcezYMc60rVu3CjJadDod6tWrZ3zevHlzwbp+/vlnyS5XycnJOHfuHH744QcMHDjQ6naL1ZV5/PgxJ6MmISEB48aNk91Nhx9ICg8PF2TXsBUoUEAw7dSpU3j+/Lnx+Z07d7B582ZZ21ejSZMmcHPj3pNatGgRTp48KTp/Wloarl69ihkzZlgsni2lcOHCaNeunWD68uXLsXTpUkHALjQ0FP369cPTp08Fy5j7LPALhsfHx2Pfvn2caR06dBDNPCtZsqQgG/HEiRNYtmyZYHQ1xpMnT7By5Uq0bNnSqiw1IuSIzykhhBBC1KOMJ0IIcQBPT0/06dMHs2bNMk5LTU3F2LFjsWjRIpQvXx45cuRAYmIi3rx5g3v37qWLgrh6vR4DBgxA/fr1UaBAATx8+FCQyQQY6ujky5fP+Lxq1apo2LAh58IxPDwcn376KSpWrIiiRYsiW7ZsiImJwfPnz3Hv3j1jAKhWrVpWt7tEiRLw8PDgBJqePHmC1q1bIyAgAElJSbhw4YJoBpKUwoUL49atW8bnycnJ+Oyzz1CrVi1jF7KmTZsiICAAgCG44ePjwwlOvX//Hl27dkXTpk3x/v17HD9+nDM6m9by5cuHLl264M8//zROi4+PR58+fVCyZEmUKlUKPj4+iI+Px8uXL3Hv3j28f/8eAJA/f37V2/3hhx9w9epVPHnyhDN97ty52LhxI2rVqoVs2bLhxYsXOH/+vLEwOFu/fv2M+1JMiRIlUKFCBUGXSjZ+LSi2IUOGYPjw4Zxpc+bMwfr161G1alXkypULSUlJePv2LUJCQmQXSCfKOepzSgghhBB1KPBECCEO0rt3b1y9ehWHDx/mTH/+/DknyyU9KVGiBB48eIBTp05JzpM9e3aMHz9eMH3mzJno2rUrnj17xpl+48YNWcWmrZE5c2Z06dIF69ev50x/+fIl/v77b+Nzf39/ZMuWTbSoNV+jRo04gScAePr0KSdTx9/f3xgscXd3R9euXbFs2TLOMuHh4diyZYvxua+vr1UFxi0ZO3Ysbt++LchSu3//vqy/W42sWbNi5cqV6N+/Px48eMB5LSwszGL3wu7du2PYsGEWt9O5c2fJwFOVKlVQrFgxyWVbt26Ny5cvCz4jb9++FRQoJ7bniM8pIYQQQtShrnaEEOIgrq6u+P3339G/f3/Rrl5Sy9SpU8fGLVNv/PjxaNGiheTrPj4+WLlypWCodcAwtPrmzZvRrFkz2dvLkiULqlevrqqtfKNGjULNmjUlX8+dOzeWLFkCX19fWev76quvFGdXDBgwAFWrVpV8vUCBAtiwYYOidSrl4eGBtWvXokuXLqLdzsS4u7uLFvVWomDBgti8eTO6d++OTJkyyVomf/78+O233zB58mRZbW3Tpo3kd02sqDjfxIkTMWHCBNF6XFKqVKmi+Sh5xHGfU0IIIYQoRxlPhBDiQG5ubhg+fDi++OILbN++HRcuXMCDBw/w/v17pKamwsvLC/ny5UOJEiVQq1YtNGzYEHny5HF0syW5ublh/vz52LNnD7Zt24a7d+8iLi4OefPmRWBgIPr27YscOXJILp8jRw4sWrQId+7cwc6dO3H58mW8ePEC0dHRcHV1hbe3NwoWLIgyZcqgTp06qFevHry8vDRpu4eHB9asWYM///wTO3fuxMOHD+Hi4gJ/f380bdoU33zzjehoWlJ8fHywbds2rFy5EqdOncKLFy8s1ofKkiUL1q5di3Xr1mHPnj14+vQpXF1dUbRoUbRs2RI9evSQPdKfNTw9PTF16lT06dMH27dvR3BwMJ48eYL3799Dr9cjW7ZsKFCgAEqVKoXatWujQYMGsgNy5mTNmhWTJ09G//79sW/fPpw7dw4PHjxAZGQkkpKS4O3tjZw5c6Jy5cqoV68emjVrJjtoCxjek8DAQBw4cIAzPXPmzGjdurWsdfTs2RMdOnTAP//8g3PnzuHevXuIiorChw8f4OnpCX9/fxQvXhw1atRAw4YNUahQIUX7gMjnqM8pIYQQQpRx0dNQK4QQQlQYO3asYGSpdevWUUYBIYQQQgghxIi62hFCCCGEEEIIIYQQm6DAEyGEEEIIIYQQQgixCQo8EUIIIYQQQgghhBCboMATIYQQQgghhBBCCLEJCjwRQgghhBBCCCGEEJugUe0IIYQQQgghhBBCiE1QxhMhhBBCCCGEEEIIsQkKPBFCCCGEEEIIIYQQm6DAEyGEEEIIIYQQQgixCQo8EUIIIYQQQgghhBCboMATIYQQQgghhBBCCLEJCjwRQgghhBBCCCGEEJugwBMhhBBCCCGEEEIIsQkKPBFCCCGEEEIIIYQQm6DAEyGEEEIIIYQQQgixCQo8EUIIIYQQQgghhBCboMATIYQQQgghhBBCCLEJCjwRQgghhBBCCCGEEJugwBMhhBBCCCGEEEIIsQkKPBFCCCGEEEIIIYQQm6DAEyGEEEIIIYQQQgixCQo8EUIIIYQQQgghhBCboMATIYQQQgghhBBCCLEJCjwRQgghhBBCCCGEEJugwBMhhBBCCCGEEEIIsQkKPBFCCCGEEEIIIYQQm6DAEyGEEEIIIYQQQgixCQo8EUIIIYQQQgghhBCboMATIYQQQgghhBBCCLEJCjwRQgghhBBCCCGEEJugwBMhhBBCCCGEEEIIsQkKPBFCCCGEEEIIIYQQm6DAEyGEEEIIIYQQQgixCQo8EUIIIYQQQgghhBCboMATIYQQQgghhBBCCLEJCjwRQgghhBBCCCGEEJugwBMhhBBCCCGEEEIIsQkKPBFCCCGEEEIIIYQQm6DAEyGEEEIIIYQQQgixCQo8EUIIIYQQQgghhBCboMATIYQQQgghhBBCCLEJN0c3ID3Q6/VIS9M7uhlmubq6OH0bHe1j2Ud6PRAfD6SlKVvO3P5xdQU8PQEXFw0amE59LJ8fa9A+Mo/2j3m0f8yj/cMl9ltn7T7K6L91zvYZUnu+Yona99HZ9o8z+hj2kaurC1wy6kGAEAeiwJMMaWl6RETEOboZktzcXOHr64Xo6HikpGj8651BfEz7KDoa2L7dDZkzAx4e8k4OdDpXeHl5IC4uCamp3P2TmOiCpCSgc+cUeHvbosXO72P6/KhF+8g82j/m0f4xj/aPEP+3ztzvmBwZ/bfOGT9Das5XLFH7Pjrj/nE2H8s+ypHDCzodBZ4I0RoFngjJoDw89PD0lDevTgd4eRnuPqam8l/VIymJfoAJIYQ4H+a3zvzvmBz0W+coSs5XLKP3kRBCnBHVeCKEEEIIIYQQQgghNkGBJ0IIIYQQQgghhBBiExR4IoQQQgghhBBCCCE2QTWeCCGEEEIIIYSQDCw1NRXJycmObgbJINzd3aHT6WTPT4EnQgghhBBCCCEkA9Lr9Xj9+jWioqKg12YASULg4gL4+Pggb968cHGxPKgDBZ4IIYQQQgghhJAM6PXr14iMjEK2bD7InDkzABr5kVhLj6SkJERGRgEA8uXLZ3EJCjwRQgghhBBCCCEZTGpqKqKiDEGnbNmyO7o5JAPJlMkDABAVFYU8efJY7HZHxcUJIYQQQgghhJAMJjk5GXo9/p/pRIi2MmfODL0esmqHUeCJEEIIIYQQQgjJsKh7HbEF+Z8rCjwRQgghhBBCCCGEEJugGk+EEEIIIYQQQghxSgEB1SzOM3HiFLRt294OrXGs4OBLuHHjGr7+urejm6IIBZ4IIYQQQgghhBDilFauXMt5/u23X6NLl8/RokVL47T8+QvauVWOcfnyJWzatJ4CT4QQQgghhBBCCCFaqFChkmCav7+/6PT0KDExER4eHg7ZdnJyMnQ6HVxdbVuFiWo8EUIIIYQQQgghJN3as2cXvvjiMzRsGIB27VpgyZKFSElJ4bweEFANt27dxKBB/dCoUV106dIR5879h7S0NCxbthitWwehVaumWLx4AdLS0ozLrlixFE2a1MPt27fQq1cPNGwYgK5dO+P06ZOCdpw5cwq9evVEo0Z10LJlIGbO/AUJCQnG14ODLyEgoBrOnDmFceO+R2BgA0yYMBoAsHfvHvTt2wvNmzdGUFAjDBjQB7du3eS0Y9Wq5UhISEBAQDUEBFTDgAF9AAA//TQZ3bt34bQlKioSAQHVsGfPLuO0jh3bYNasGdiw4Q907NgajRrVwfv372XtQ2tQxhMhhBBCCCGEEELSpU2bNmDRot/x+efdMWTICDx58hjLli1CWloaBg4cwpn3558no3PnLvjyy6+wbt1ajB8/Gq1bt0N8fBwmTfoRt27dxIoVS1G8eAm0aNHKuFxKSgomThyL7t2/RL58+fH331sxZsworFu3CcWLlwAAHD16GBMnjkWbNu3Rp08/hIe/w6JFCxATE42pU2dw2jFjxjS0bNkanTt/asw2ev36FVq3boP8+QsgOTkFBw/uw4AB32LDhs0oVKgwOnTohLCwMBw8uB+LFi0FAHh5ZVW8v44dO4pChQph+PDv4erqCg8PD0X7UA0KPBFCCCGEEEIIIR8JvV6P+Ph4h23f09MTLi4umqwrLi4OK1cuxZdf9sSAAYMBALVrB0Cn02HBgnn48sueyJ7dxzj/Z591Q+fOnwIAcuf2wxdffIY7d25h1ap1AICAgLo4deoEjh49zAk8JScn45tveqNdu47/30YdfPppB/zxx2r89NMv0Ov1mD9/Lpo1a44JEyYZl8uRIydGjhyKXr36oFix4sbpDRs2EgR0evfua3yclpaGWrVq486d2/j3310YMGAw/PzywM/PD66uLlZ1M0xNTcHcuQvg4ZFF1T5UgwJPhBBCCCGEEELIR0Cv16NVqyBcuHDOYW2oXbsO9u49qEnw6caNa4iPj0dgYBCnW1iNGjWRlJSIhw8folq16sbpNWvWMj4uVKjw/6fV5qyzUKHCePbsqWBbjRoFGh/rdDo0aNDI2N3u2bOnePPmNYYPH8VpR9Wq1eHi4oI7d25zAk9169YXrP/x40dYunQRrl+/hsjICOP0Z8+eWd4RClSrVsMYdAKU70M1KPBECCGEEEIIIYR8JLTKNnIGUVFRAICvvuou+npo6BvO82zZshkfu7u7C6YBgJubOz58+MCb5gZvb2/ONF9fX4SHv+O0Y8yYkRLtCOUtm4PzPC4uDkOHDoSPjy+GDh0Bf/+8yJw5M3755Sd8+JAkuk61fH19Oc+V7kM1KPBECCGEEEIIIYR8BFxcXLB378EM09XO2zs7AGDGjFnIk8df8Hq+fPk02U5KSgqio6M5wafIyEjkzJnr/+0wTB81agzKl68oWD5Xrtyc5/y//+bN6wgLC8Xs2b+jZMlSxumxsbHw8/Oz2L7MmTMhOTmZMy06Olp0Xv627bEPKfBECCFOJioqElFRUShSpKijm0IIIYQQQjIYFxcXeHl5OboZmqhUqRI8PDwQFhaGxo0DLS9ghRMnjhprPKWmpuLUqROoUMEQZCpSpCj8/PLg5cuX+PTTrorXnZRkyGpyczOFaK5fv4bXr1+hWLFixmnu7u748CFZsHzu3HkQFhaG+Ph4eHp6AoDs7pT22IcUeCKEECdTqpShv3lw8E0ULFjIwa0hhBBCCCHEOWXNmg19+gzAokW/IywsFNWr14CrqytevnyJkyePY8aM3zj1jNRyd3fHmjWrkJT04f+j2m1BWFgYevb8BoAhmDd06AhMmjQBiYkJqFu3PrJkyYI3b17jzJnTGDBgkLGmlJjy5SvC09MTs2bNQM+e3+Dt2zCsXLkMuXNzs52KFCmK1NQUbN68CRUrVoaXlxcKFy6CJk0CsWLFEkyb9iPat++Ex48fYufOf2T9bfbYhxR4IoQQJxUcfJECT4QQQgghhJjxxRc94Ofnhz//3ICtWzfDzc0N+fMXQP36DeDm5q7JNtzc3PDTT79g1qwZePjwAfLly4/p03/jdItr2jQIWbNmw9q1q7B//14AQN68+RAQUBc5cuSQWjUAIGfOnJg2bSYWLJiH0aNHoGDBQhg9egLWr1/Lma9+/Yb45JMu+OOPNYiMjECVKtWwZMkKFC1aDJMm/YhVq1Zg9OgRqFy5CiZP/glff/2lrL/P1vvQRa/X661eSwaXmpqGiIg4RzdDkpubK3x9vRAZGYeUlDRHN8cpfUz7KDoa2L7dDdmz6/H/LEuLdDpXZM3qgdjYRKSmcvdPfDzw/r0LOndOAa+e3kfD3p8fPz/Djl6xYi06dOhs8+1p4WP6jqlB+8c82j/m0f4R4v/WmfsdkyOj/9Y542dIzfmKJWrfR2fcP87mY9lHOXJ4QadzdXQzNJOYmIiHDx8hVy5/ZMqU2dHNSbdWrFiKTZvW49ixM45uilP58CEJ7969QfHixeDh4WF23ozzrSKEkAzG1ZUO0YQQQgghhJD0ja5qCCHESVFCKiGEEEIIISS9o8ATIYQ4qQ0b/nB0EwghhBBCCPmo9enTn7rZWYkCT4QQ4qSOHz/q6CYQQgghhBBCiFUo8EQIIU6EutcRQgghhBBCMhIKPBFCiBNJS8u4I8UQQgghhBBCPj4UeCKEECeSmprq6CYQQgghhBBCiGYo8EQIIU6EAk+EEEIIIYSQjIQCT4QQ4kSoqx0hhBBCCCEkI6HAEyGEOJG0NMp4IkSO5ORkKsZPCCGEEJIOuDm6AYQQQkyoqx0hlkVEhKN27aoIDGyKZcvWOLo5hBBCSLqTkAAkJztm2+7uQJYs6pfv2bM7QkLuYtGi5ahevYZ2DXOAAQP6wNMzC2bPnm/Vep4/f4ZNm9bj5s0bePToIQoXLoJNm7Zq1ErrUeCJEEKcyIcPDjoDICQd2bZtM96/j8I///xNgSdCCCFEoYQEYN8+HaKiXByyfR8fPVq1SlUVfHry5DFCQu4CAA4c2JfuA09aefz4Ec6cOY3y5SsgLS3N6bLCKfBECCFOZPfufxzdBEKcnk5Hpy+EEEKIWsnJQFSUCzw89PDwsO+2ExMN205OVpf1dODAPuh0OlStWh3Hjh3G99+Phbu7u/YNTWfq12+Ihg0bAwB++mky7t697dgG8VCNJ0IIcSLh4eGc5/Hx8Q5qCSHOi2qhEUIIIdbz8AA8Pe37z9pA18GD+1G9ek107/4lYmJi8N9/pzmvv3r1CgEB1bBv37+YNWsGgoIaoU2b5pg/fy5SUlI48169ehl9+/ZCo0Z10Lx5E0yZMpFzLs6sa+/ePfjll5/RrFlDtGwZiI0b1wEADh06gM8+64TAwAYYM2YkYmJijMsmJCRg1qwZ+OyzTmjUqC46dmyDmTOnITY2BlLu3w9BQEA1XLhwnjM9LS0NHTq0xrx5syWXdXV17tCOc7eOEEI+Mqmp3B/EDx+SHNQSQpzXypXLHN0EQgghhNjZzZvX8fLlCzRv3gK1agXAx8cHBw7sE5132bJFcHFxxdSpM9GxY2ds2rQeu3btML5+9+5tDB48AJkyZcLUqTMwdOgIXLx4AYMG9UNSUhJvXYvh5eWFadN+RdOmQViwYB4WLZqPzZs3YdCgofj++zEIDr6IhQvnGZdJTExEamoa+vcfiLlzF6Bfv+9w+XIwxowZKfn3lSxZCuXLV8Du3Ts408+fP4vQ0Ddo376j0l3mNChXnRBitQ8fPsDNzc1ipF2v1+Ps2TOoXbsOdDqdnVqXvoSHRzi6CYQ4vaxZszm6CYQQQgixs/379yFTpkxo3DgQbm5uaNo0CHv27EJcXCy8vLJy5i1fviJGjhwNAKhdOwAXL17A0aOH0bnzpwCANWtWwdc3B+bOXWDsqleoUCH06fMNDh06gLZt2xvXVbFiJQwdOgIAUKNGTRw7dhTbtm3Gjh3/Int2HwDA/fv3sXv3Dowb9wMAwNfXF2PGjDeuIyUlBfny5Ue/fr3w7NlTFCpUWPRv7NChM2bPnono6Gh4e3sDAPbs2YXy5SugWLHi1u5Ch6GMJ0KIVR49eogCBXLB398Hfn7eZuZ7gDx5sqNjx9bIm9fXji1MX9atW+3oJhDi9Nq16+DoJhBCiNPYtGk9atSohPv3QxzdFEJsJjU1FUeOHELduvWNN6BatGiNpKQkHDt2VDB/rVoBnOdFixbF27dhxufXrl1Bw4aNOfWhKlasDH//vLh27Qpn2Zo1axsf63Q65M+fHyVLljYGnQBD0ComJoZTJmPfvj3o2bMbmjSph/r1a6Ffv14AgGfPnkr+nUFBLaDTueHgQUMm1/v3UTh16gTatesouUx6QIEnQhxs69a/MGnSeKcbeUCugICqnOdPnjwWzKPX6xEQUM1eTcpQ3r9/7+gmEOJ00uvxkhBCbGHYsIF49uwJunX7xNFNIcRmLlw4h8jICNSv3xAxMTGIiYlB0aLF4OeXR7S7XbZs3Oxod3d3The6mJgY5MyZU7Bczpw5ER0dbXZdbm7uyJYtq2AaYCqTcfz4Ufz44ySUK1ce06bNxMqVf2DmzNn/n+eD5N+ZJUsWNG/eArt27QQA7N+/FzqdDkFBLSSXSQ8o8ESIgw0c2BdLly7E4cMHNFunXq9HYqJ04TqtXLkSLJjWtm1zwbRx40YJpqWlpdmkTRnN/v3/OroJhDid4OCLxsePHj1wYEsIIcR5mMuiICS9Y4JLU6dOQVBQI+O/sLBQBAdfRHj4O0Xr8/b2RkSEsMRFeHi4sYubNY4ePYxSpUpj7NiJqFu3PipUqIhs2eStt0OHzggJuYuQkHvYs2cXAgObwcvLy+o2ORIFnghxoIgI7qgJWtm4sQeGDvXH8+e3NFunmO3btwmmhYWFci4E4+PjsXr1CsF8WgbaMrIffhjn6CYQ4nQOHtxvfBwaGurAlhBCCCHE1hITE3Dy5HE0atQEixYt5/ybNm0m0tLScOiQsmuLSpWq4OTJ40hJSTZOu3nzBt68eY3KlauaWVKepKQkYxYU48CBvbKWLVu2HEqVKo25c3/D/fsh6b6bHUCBJ0Icavz40cbH7P7A1rp+fTsA4ODBJZqtU6/X4/HjR0hMTERsbCwuXbqArVv/FJ2X3a2uSBF/0XnCwsJEpxNCiBL8oZEJIYQQkrGcOnUS8fHx+Oyzz1G9eg3Ov6ZNg1CuXHnJ0e2kfPNNb0REhGP48CE4ffok9u7dg3HjRqFo0WKadGurWbM2bt++iVWrluPChfP4/fc5uHTpouUF/699+064cuUyChUqjCpVLAfCEhMTcPToYRw9ehhv3rxGXFyc8XlkZKQ1f4omKPBEiANt376V8/zt27f49tuvcOLEMU3W7+oqb+S4d++eIS7OfC2h+fOno3btKihUyA/FiuVD69bNRNNTGcOGDUTZskXNbPOtrLZ9bDp06OzoJjhUamoqdcMkilDgiRBCCFEnMRGIj7fvv8RE5e3cv38v/P39Ua1aDdHXW7duizt3bivqblqmTDnMn78YiYmJGD9+NObNm4Vq1Wpg4cKlyJw5s/JG8nTq9Am6d++Bbds2Y+zYUQgNfYMff5wme/nGjZsAkD+gSkREJMaPH43x40fj8uVLCA19Y3z+6NFDVX+Dllz0VKHTotTUNERExDm6GZLc3Fzh6+uFyMg4pKTQBZsYNfsoOTkZqamp8PDwsFm72KPATZkyDdevXzF2Xzt27D+UL19B8Tqjo4ESJQzrbdasH776ao7Z+SMiXmHo0JJwddVhw4ZYpKZy9098PPD+vQtGj/ZU3BZLXr4M54wk4azs+R0TGxkwLCxaZE7nosU+Sk1NRYMGteDu7o7jx8/CxcVF41Y6TkY/ToeHh2PcuJHo1q0HmjRpqnh5pfuH/T3ZtGkrmjVL3wU3Lcnonx81oqOB7dvdkD27Hp6egE7niqxZPRAbmyj4HZOD+a3r3DkFGpT2cDrO+Bniv4daUPs+Wrt/9Ho9vvuuD7JkyYI5cxYoXt5a7GOirc4ZnPEzZAs5cnhBp8s4uRmJiYl4+PARcuXyR6ZMpmBKQgKwb58OUVGOOdfy8dGjVatUZMnikM2nC7t378CMGb9g1669yJkzl6ObI+rDhyS8e/cGxYsXs3jN7GanNhGSruj1elSvXgFRUZG4f/+5JlFvS0JD33BqJjVpUlf05OHBg/u4d+8u2rRpZ3Gdrq6Wfzjv3z8HAEhLS1XQWm18910frFix1u7bJc7pzZvXePDgPgAgOvo9Z4ha4tx+/HEiduzYjh07tts9UJqSYv9jFyHEvHfv3mHlyiX4/PMvUaSIdPZzRvHu3Tv8/fcWAMCkST/Bx8fXYW1JSkqyy3krSd+yZAFatUpFcrLleW3B3R0UdJLw6tUrPH/+DKtXr0SzZkFOG3RSKuOEcwnRkF6vx5s3r5GYmIgnTx7bZZtLlgjvkP344w+CaXXrVsc333yBkyePW1yni4vlr3hycoLx8fv39i3Su3Pndrtuzxndvn0Lt27ddHQznMLTp0+Mj69du+qwdhDlXr584bBt37lj20EUCCHKDRnSH3Pm/IbWrZVnQKZHbm6m0gbPnz9zYEuAEyeOOnT7JP3IkgXw9nbMPwo6SVu5chlGjhwCf/+8GDJkhKOboxkKPBEigt0DNTXVcXfTFy36XfK1q1evWFxeTsYTeySHDx9UdLq20sfc2zcpKQmNG9dBkyZ1NS0un16x++V/+ml7B7aEKOe4bpFyjoWEEPs6fPggAEMm0MeAfS7z22/THdgS4CM+rSIkQ5g06UecPn0BS5asQM6cOR3dHM1Q4IkQEUx3HwDYt2+PA1sCyWJwcurfuLhYLi7OLuSckvJBfsM0smfPLrtv01kkJZkCfZGR0oXaX716aY/mONzr168c3QSikj3rcSXyqpL26PGV3bZNCCFi0tJM0Z6YmBgHtoQQQpwTBZ4IEfHmzWvjY0d3+QkIsDx8phQ5o9qxazvdvn1S9bbUmjRpnN236SzYGWnmRnJLTEyQfC0jmT79Z87zt29p5ENn9fz5M/j5eaNcuWIAAFvFnZKTkzF69HDs3r3DOO39+yjOPDodlaskhDjWjh2mGp1nzpxyYEuAQ4cOmH39Y840J4Q4DgWeCBGRnGzK/EnP2SZyAk+Rkaa/z5oC4/ny5Ve1nCNrwzjaixemvz04+KIDW+Kcnj61T301olz16oYRN9+9e4cxY0bYLONpx46/sXbtKvTu3dN4scTv/qzXZ9zRlQhhpKam4sMHZVnJ58+fw7fffoWwsDAbterjFRkZgXPn/jMelx4+fKDp+t+8eY3790NULbtu3WrJ1/7+ewvKli2Kc+f+U9s0QghRhQJPhIj48MFU9+j69auOa8j/vXjxXDBNzh0rOTWedu36zfjYmsDToUOWs6W+/baf6vVnRKdPnzA+7tv3G8n52F0/PyY0Wplz4l/Erlmz0mZ30KOjTSPkbd68CYAw8GQuW5CQjCIwsB4qVSqFpKQk2cu0a9ccu3b9gwoVStiwZZb5+Xnjk08sj8RrSzdv3kD//r01GzCmXr2aaN++JbZs+RMAFAcFQ0Lu4dNPO+DcubOC127duolKlUqjXr0aePRI24DWgAHfIiIiAt26farpegkhxBKHB56ePn2KSZMmoUOHDihXrhzatm0rOt+JEyfQsWNHVKxYEUFBQdi4caPofKtWrUJgYCAqVqyITz75BOfPn7dl80kGZY8RQZiTFTkWLpwnMtXyhZ6cGk9smTN7Kpqfcf36PeTOndvifH37fqdq/RlVcnIK5zm/dg3jypXL9miO0wkJuevoJhAR0dHv7batTJkyGR9PnjwegDDQRN1GSEan1+tx585tRERE4O7d245ujiqnTp2wPJMNNWvWANu3b0WtWpWtXpder8e7d4au4IMH98eTJ4+xfv1azjzh4eFm19Gz5+c4efIY2rdvIXitSZO6xscBAdUUB7XkiIuL1XydhBBijsMDT/fv38eJEydQuHBhFC9eXHSeK1eu4LvvvkO5cuWwYsUKdOrUCVOnTsXWrVs5861atQpz587FF198geXLl6Nw4cLo06cP7t27Z48/hWQga9astPk2Bg2Sn/2zevUKAEBKiilQIXWxxb4baqmr3cuX3At7tV1W/P3zAjAEoKT89NMvKFKkKObMWaBqGxlRcnIy57nUCIqzZ8+0R3OczqhRQx3dBCLCnkN1s7M2IyMjAQBXr3IDseyivoRkROyR4cLDP45R4rTGDlhbG6zmD4oiFswyV5tRr9dLDhwjplGjAPmNMyMmJtryTIQQYiMODzwFBgbixIkTmD9/PsqXLy86z6JFi1CuXDn88ssvCAgIwHfffYdPP/0Uv//+u/GH5MOHD1iyZAl69uyJ3r17o06dOvjtt99QoEABLF261J5/EiE2c/68KSVb6sTp3r2bxseWutrdvn2c89zTM7viNrGDTf7+efHokbAmVvv2ndC//yAAQFCQ8O5efHy84u1mBBcvnuM8P3LkoPHxgAGD7d0cp+Pu7u7oJhARYnfyHz+2TT0usdpRx44d4TynrnYko3v92vS7On36VFXroO+JibWBJzk1Gd++la6rtW/fv4q2p1X9qGfPnmmyHkIIUcPhgSdLF8YfPnzAuXPn0KZNG870du3a4e3bt7h925ByfPnyZcTExHC66ul0OrRu3RonTpygVHyS7j169JAzehPzmU5LS8ODB/eNz9+9M53sWPp+vX/PPTHKmbOArLZ07dodhQsXwT///GvMdmJkzZoNEyZMBgBUrVoN/foNxLJlpkKXefL4C9YnlmEWGvoGsbEZOxU8Li6O85z99+bMmcvezXE6/Iww4ryePXtik/Uy3VnY+N1OqEguyejY2bBqRzllBy9SU1Nx7doVySzbjM7armtnz54WTMuSJQvnOftGIZ+516Q8f/4Mw4YNxNKlC/Hs2VPB65kzZxZMe/r0CSezasGCuYq3SzK2hAQgOtox/xKsHLC5Z8/uCAiohuDgS9rsDAcaMKAPRo4cYvV6jhw5hNGjR6B9+1Zo3LguvvjiM/z991anufHg9GMQP3v2DMnJyShWrBhneokShkKJDx8+RIUKFfDwoeHAyp+vePHiiIuLQ2hoKPz9hRe8hDib0qXL4N49YW2bDh1aYcOGzcbnCQkJ0Ov1KFgwN5KTk9GwYRNs27YTx4+bsmZcXMwHno4c4QZ85BYXX7DAfBbh0KEjMXToSMnXg4NvGkfFAoCjRw9j4EDTATc0NBQVK5YCAGzYsBnNm7eS1a70hh8QZ18EVKtW3d7NcUp6vd5mI6YRdez5fkydOkUwjR+QXLJkAX78cZqdWkSI/bF/G+R+//i/L1u2/IVataoCMNRLW758Cbp374F58xZp19B0ol+/Xvjjj02qlw8PjxBMS+BdRUvVbAQMxywpt2/fEp3OPmeaNGk8/vsvGCVKlDRO4wcR/fy8Oc/DwqKxfTu3RAn5uCUkAPv26RAV5ZhzLB8fPVq1SgUvZivLkyePjXVADxzYh+rVa2jcuvRp06b18PfPi8GDhyFHjhwIDr6EOXN+w6tXLzB48HBHN8/5A0/v3xuKmHp7cw+gzHPm9ejoaGTKlAkeHh6c+bJnN3QdioqKsirw5Obm8OQwSTqdK+d/ImTtPrLn+3/27CW0ahUkuCMWGvoG9+7dMT53d3fD2rUrjBdhJ08eg5ubK1JTTXWgXF1dzf7NSUncjJuIiBcoVaoOZ5pOB7i6mn6UxowZb/X+KFy4EOf5qVPHOesMDjYNCvDll10REeHYzCdbfcf4x6vt27cYH9euXZvzmjMfgwDr91FUVKTo9B9+GIsZM34TfS09sdVnaOHC+cifPz86dfpE0/Wa4+dnfiABNZ9VufvHcIwTZsI5+/fDWvQ7L+TmxvzG6Tm/U4b/1XwGDcu6ubnCzenOjk1BpPv3Q2R93vmBiNmzf8WsWTOh07li+fIlAAwXKePGTUT+/Pm1bS6Axo0Dcfw4tx4cv93891ALct7Hffv2CNqi5DsmJ8NzxoypGDnye4vzAdz9EhEhr4ZX3brVOedGljIagoMvmN2uHHQcyliSk4GoKBd4eOjBOx21ucREw7aTk6Eq8HTgwD7odDpUrVodx44dxvffj6XyDABmzfodvr6+xufVq9dEfHw8tm3bgn79BnIGbHEEp/tplSJ1h4c9XWwe5o6PNXdoXV1d4OvrpXp5e/H2VvHN/cjI3Udubm7GQt5169a16/vv6+uFGTN+QZMmTQSvDRrU3/j40KH9uHr1Kuf1U6eO4NYt07TMmTMha1bpXxM3Nzewkwc2bRqPZs16cOZxcQE+fADq1KmPs2dPo2bNajbZH+x1njlzQvI1R9L6O/b8OTdd/swZU/p+zpzZOK85yz6wRO0+io4WP9levnwJli1bbE2TnIqWn6Hz589j0iTDSG/dunURdPWwlYCAmmZft+azamn/+Pp6CS56xo8fn26+H9ai33kTV1fA0xPw8jL8Y3h6CrscycH81vn4ZEZ25eUObcrLy3SxkJqaKuvzHhMTIzqd/xnas2c7xo4da10DRbx8+VwwLVu2zHBjRYOk3kNriL2P7IFZGFL7UKvvmNz3id8W9nutZDlLgadWrZqZXV4JOg5lLB4ehu+hvZlJCrTo4MH9qF69Jj7/vDtGjBiC//47jUaNTNdNr169QufObTF58s+4desGDhzYh0yZMqNFi1b47rvBnOPQ1auXsXjxQty7dweZM3ugbt16GDx4OHLmzMlZ16RJP+Hq1Ss4evQQ3Nzc0KPH1/jii544dOgAVqxYinfv3qFmzVqYOHEKsmUznMMnJCRg0aLfceHCeYSGhsLX1xd16tTFwIFDkDUr9zyfcf9+CHr0+Bzz5y9BrVqmm9BpaWno1KktmjRpimHDxHuVsINOjNKlSyMpKQnR0e+RK5flEchtyekDT0zGEpPZxIiONozMwGQ+eXt7IykpCUlJSZx+zsx82a04i0hL0yM62nmLH+t0rvD2zoLo6ASkpjpHH05no3QfDRs2ErNmGUYS+++//xAZGWdhCW3cvBmCyMg4VK5cE7ly5eKMZMPHDzoBQIcOHXhT3BAba+7Izg3IxsVFC+aPjwfi412QkGAYLS8xMcUm+4O9zhUrVki+5gi2+o6FhIRIvhYTk8R57uh9YIm1+yg6Wrqzv7P/7XLY4jN06NAx4+PHj18ib968ZubWzt69B8y+rub9krt/IiPjEB/PPUZ5enpniM+IOfQ7LxQdDcTHuyFTJj30esNNQk/PzIiPT1I10iHzWxcVlQInKYdhdP48t4aJnM/7tm3bRKfzj7U3btxGRESs5l1o79+/L5gWHh7DuePOfw+1IPY+skf7ZfD3oS2+Y2Lvk1hAkD3fgwdPFK9fbv2W3Llz4+1bU908pcfNj+U45O2dhbK6nNjNm9fx8uULfPNNb9SqFQAfHx8cOLCPE3hiLFu2CA0aNMbUqTNx/fpVrFq1HAUKFETnzp8CAO7evY3BgwegcuWqmDp1BqKjo7F48QIMGtQPa9du5MQUli1bjMDAZpg27VecPHkMCxbMQ1RUFK5cCcagQUMRFxeL2bN/xcKF8zBu3A8ADF1uU1PT0L//QPj4+CI09A3Wrl2FMWNGYtGi5aJ/X8mSpVC+fAXs3r2DE3g6f/4sQkPfoH37jor219WrV+DtnR2+vjkULWcLTh94KlSoENzd3fHo0SM0bNjQOP3BA0ORxOLFi3P+f/jwIcqVK2ec7+HDh/Dy8kKePHmsakdKivMfYFNT09JFOx1J7j7KkSMn57nW+/XWrZui0/38/I3bunbtHvLnzyk6n1ypqWkWTg64J5ouLi6C+VNTgbQ0F2OXPldXnU0+Z+bW6Syfa3t+x/R67nuTkJCULtKI1e6jFy+EoyEy0svfLoeWn6F582YZHyckJNrts2lpVC1r2mFp/6SkpAkKAyclfXCaY4St0e+8SUqK4YI7NVUPQ68yw4ViWppe1UUx81uXkpIGkQQZhzp06CDnubzPgHggib9vNm1aj2fPnmL79j1qmydbYuIHuLqaLj2E76H1xN7H69evC+Z7/PgJChYsJJiu5XcsOTlVENCbOXO6YD729oYNGyR7/cxyYhldYthBJ/52laDjEHGk/fv3IVOmTGjcOBBubm5o2jQIe/bsQlxcLLy8snLmLV++IkaOHA0AqF07ABcvXsDRo4eNgac1a1bB1zcH5s5dYDzPLFSoEPr0+QaHDh1A27btjeuqWLEShg4dAQCoUaMmjh07im3bNmPHjn+RPbsPAEPAfffuHcbAk6+vL8aMGW9cR0pKCvLly49+/Xrh2bOnKFSosOjf2KFDZ8yePRPR0dHGJJs9e3ahfPkKKFasuOx9defObezZsxu9e/eFTqv+zFZw+nBupkyZEBAQgH379nGm79mzB7lz5zYGmapVq4Zs2bJh7969xnlSU1Oxb98+NGrUiIrTEkVsPQri4sXzOc9v3LiP0FBuVp8WF9p6vfkTA37x8dath0rOm5JiCDy5uWkTALh4UXgiCNh+36dXV65cdnQTbOrTT/nZeibXr1+1X0PSkfDwcONj5vv5MeAXF2fXtSMkI1IzwqfURUbdusKusqdPnxQd1ERrjhpZKSlJOIpdcrJ1I9vJkSdPdvz7727OtEuXhLWW2JS818zIuB/r6ITk45OamoojRw6hbt36xq5qLVq0RlJSEo4dOyqYv1atAM7zokWL4u1b04je165dQcOGjTnXXBUrVoa/f15cu3aFs2zNmqbsI51Oh/z586NkydLGoBNgCFrFxMQgPt7UU2rfvj3o2bMbmjSph/r1a6Ffv14AIDo6JSMoqAV0OjccPGiIf7x/H4VTp06gXbuOksvwhYe/w7hxo1CuXHn07PmV7OVsyeGBp4SEBOzfvx/79+/Hy5cvERsba3weEWEYNWLgwIG4efMmJk6ciPPnz2PJkiXYunUrhg4dahwuPlOmTBgwYADWrl2L1atX49y5cxg9ejSeP3+O/v37m2sCIQJiJyla2rr1L87zPHnyiAZHf/nlV6u2YynwFB8fxXl+4IB0LR3mwlarzJPChYtwnjMX0fwDvTO4du2qceRMLQUFtZA9b0aPncfHS6f8Dxs20I4tSZ8ycrcHvipVqnGeq7koJyQ9kZvRwiZ2Eyc8PBx3794RmRto0KCWxaCIEmK1RO7fv6fZ+pUQC04/fSp90aelb775gvNcav+rER1tuGHpLEOlE2JrFy6cQ2RkBOrXb4iYmBjExMSgaNFi8PPLgwMH9gnmZ2otMdzd3Tldb2NiYoy1nNhy5sxpLNcjtS43N3dky5ZVMA0APnwwbOP48aP48cdJKFeuPKZNm4mVK//AzJmz/z+P9LVmlixZ0Lx5C+zatRMAsH//Xuh0OtnXDbGxMRg+fDAyZ/bArFlzNUsasJbDu9qFh4dj6FBulgXzfN26dahduzaqVq2KxYsXY86cOdixYwf8/f0xceJEdOnShbNcr169oNfrsX79erx79w6lSpXC8uXLUbp0abv9PSRjiI2NtjyTRkaMkB71pH37zhg/frTqdSvNHoqJka4pxVzc2erg9f59JHLmzInYWMeOYMf3+vUrNGlSHwA0H10vX74Csuc1NzRzRmePO/Hp3cd0x7tIkaKc5x9Tthf5OKkZiSgqKkowzdLozq1bN0NYmDbnP+/evRVMCwm5h6pVq2uyfiXEAnddu3ZS9beau1iUgwkWyfHJJ5/h77+3SL5+584t5M2b76M6/pOPGxNcmjp1CqZOncJ57d27twgPf4ecOXPJXp+3t7cx0YUtPDxcUZc2KUePHkapUqUxduxE47TLl4NlLduhQ2fs2LEdISH3sGfPLgQGNoOXjFEYkpKS8P33wxEREY4VK9ZyMrIczeGBpwIFCuDePct3QBo1aoRGjRqZncfFxQXffvstvv32W62aRz5SUqPB2EK3bj0kX/Pz87Nq3ZYynpRgTtzc3W1z2GACWv/8IyyI+vffW/DJJ5/ZZLuW3L8vXQDcWswdETm2b9+KBg3MHwMziu+/H4fffhPWwSDSPqY73uw0eQBITqaudiRj69jxExw9etj4PDY2FlmzZjWzBDBz5jTBNDWZU2pI3UByVFd6LYPTu3fv0GxdlgwdOtJs4Im5YNbyXI8QZ5WYmICTJ4+jUaMm+OyzbpzXoqIiMWHCGBw6dACff/6FxBqEKlWqgpMnj2Po0OHG65CbN2/gzZvXqFy5qtVtTkpKEtywP3Bgr8TcXGXLlkOpUqUxd+5vuH8/BCNHjrG4TEpKCiZMGIP790OwZMlK5M2bT1W7bcXhXe0IcUYZJbtEy5M8rbvaAdxhP5mhTdevXyuYb8CAbxEWFiaYbg9a7sOIiHDExJjusP755waz8/ftO8D4WM5djoyiTp16jm6C0+MHmjLiHW+pYBo/KJmQ4LyjzhKiBX69ps2bN1lchh+gtSepmyqOOk49fvxIs3Vt3LhOs3Xx8Y95lgZGYs5P0svx39ArZa1TllQgzu/UqZOIj4/HZ599jurVa3D+NW0ahHLlyot2tzPnm296IyIiHMOHD8Hp0yexd+8ejBs3CkWLFlNUDkNKzZq1cfv2TaxatRwXLpzH77/PwaVLF2Uv3759J1y5chmFChVGlSqWA2GzZs3A6dMn8fXXvZGUlIibN68b/8XFOb5HCQWeCBFhz8CTLTMVLN0Fa9iwp+x1MXdKtexqx97PlkZbOH36hGbbVUKrwFNcXBzKlCmK4sXld68bNGiY8bGn58cTeMqXz7nu0DijtWtXcZ4nJTlPsDwk5J4m35unT5/Imm/VKvEhiQnJKPiBBWu7e9ma1NffUQESqZIFr1+/Uryu06dPWtscUX5+3vD39+FM8/XNgYYNhUPEMxYunAcAePLksU3aZK3nz59h6dKFxkLLBw7sw8iRQxAU9HFkb6cXiYlAfLx9/6m5zNq/fy/8/f1RrVoN0ddbt26LO3dumy3azVemTDnMn78YiYmJGD9+NObNm4Vq1Wpg4cKlyJw5s/JG8nTq9Am6d++Bbds2Y+zYUQgNfYMffxRmo0pp3Njw/W/XTnoAHrZz584CABYu/B3ffvs159/du44vW+HwrnaEOCN7ntSJDefLlj9/Abx8+ULVui0FnnLmLCh7XaaudtoFnthBt7//3orvvhssOe+hQwfQuXMXyddtRavAE/s9TEpKkvWDxh51cN68WRg/fpImbXF2xYqVwKFDJ+jk1IyZM6dyns+YMQ3btu20eztWr96AXr2+5EyrX78mOnbsjOXL19q9PYRkRPwucr/++gsGDBjkoNZYJhVgcrYuwR06tMKFC9esWse1a3dRuXIZjVoktHnzdpQsWQixscISEHfu3AZgyARhrFq1Hr17S5dwYNPr9TYd9btXrx64du0Krl+/hsWLV+DYscOWFyJ24+4O+PjoERXloioQZC0fHz2UXFLMnv272dc//bQrPv20q/H5uXPC0aBHjRqLUaPGcqZVrVodK1askVxvvnz5RNe1ZMkKwbS2bdujbdv2xuc6nQ5DhgzHkCHDOfPx1ye2LgA4e/YMdDo3tG7dVrJ9bDt2/CtrPkehwBMhImyZPfDixXPOc6aLmZSdO/ehRo2KqrZlKWiipC5AdHQUAMvtVWLixCn44YdxAIApUyaYDTydOXNKs+1ev34VGzeuw5o1KzFz5hx88410XTitaiewA3YHD+6TNSSquXpaaWlpePPmNfLly69F85yOh0cWRzfBqUVGRnKenzx5TJP1hoTcQ758+UXrx+za9Q+GDuWOMFitmnih4B07tlsdeEpLSx/dRwixNX7gyRm6TJiTnCx+847dvd4ZWJspNH36LEENlfHjJ+GXX36yar1sOp0Ojx69BGDIEu/QoSWuXOFetLLPU9q164A3b6Lg6uqKd+/eoVy5YpLrTk1N1fScjo/pUrdz53YsXrwCa9astNm2iHJZsgCtWqXCUQPDursb2kCEXr16hefPn2H16pVo1ixIUcF0Z0Zd7QgRwR5qU2sREeGK5i9UqLDqbWkVeIqKMmXraJnx1LNnL9nzvnnzWpNtXr58Cc2aNTSeAI0ZMwJ+ft64ceO66PzsfWjN3Vr2eh48uC9rmRw5hEO8MgYM6I0qVcpi7949qtvkzNzczHe9JNo7d+4/1K9fE8WKCbs6pqSk4NtvvxJc8Noyg2Hnzn8E027fvmWz7RHirFJT01cB/apVy4lOL1y4iH0bYmO9evURTCtaVDrQYy0PDw9MmvSzYDr/OOzqari8y5UrFzp27Cy5PnsVm092VGSDWJQlC+Dt7Zh/FHSStnLlMowcOQT+/nkxZMgIRzdHMxR4IkSEtV3tQkNDMX/+XLx9KxxO2BYXas+eiRcR1SrwFB9vGmpUy7tjWXi/OkzfZFs6cuSQ6PSmTeuLTmfvw/Pn1bePva/FhplW6p9//gYAzJ8/2+p1OaNixUo4ugnpSrZs3lavg13Yn39Bsm+fePq2VD08Pz/zRXHlEPueSH1PCcnIbBEgyJcvP7y9s2u+XnPSSxFsucS6qel0ys+RHj4U3oxq1qy56LxiA42YO6+cN2+xZGaqlqP9EUK0M2nSjzh9+gKWLFmBnDmlb0KnNxR4IkSEtcXFAwKqYurUyejYsZXgNTWBJ3MjKzx48BweHh4IC4sWvGYpsCS3LamppkCclhlPfO3bWz+ChNa0y3gyPV6xYqk1TeJISclYJ/IM/gl9XFycg1qSPnh6elq9jq1b/zI+TkxM4LwWHy++//39/UWnaxGgvnnzhmBaRrtwJUQOWxzng4NvYs+eg5qv1/w25Y/mZC9aj5grNlDKo0cPBNMaNGhsfPz+/XvB68OGfS+6/goVKgmmFSlSVLI9np6e2LXrgOhrdDwlhNgTBZ4IEWFtxhPTHeX+/RDBa2qCF+wuabNnzzc+Xrt2k9k7lnIznrJkyQYAKF5cfKQId3fTRa2Xl7D2S3qi9EQrKcn0WbBmRD9bneBlhBR2saKpfGoL7H8sQkPfWLU8/1ixYcMfnOfPnz8TLNOoURNkzZrNqu2aExUVaXkmQj4Ctvj90Ol0KFOmLEJDhUEPWwkJEZ4TOdoff6yyPJMCbm46dOvGHXCBXZPPw8MDADBt2kzjNLHyDlI1HsWC+ky3fKnM10yZMolOf/z4keh0QgixBQo8ESIiLCzUZutmX8CVLi1vJJTmzVti6dJVOH78LOrVa2Cczs+EmjBhMue5pYwn5nVPT0PwysNDPKjk7m7qEqfF8KKOdOOGshFs2HcvmUKZavCLo2sVMMoIqfJLliy0OI9WowtmBLa4CI2MjOA8f/jwIef5r7/+IlimZ89vABhG3uR79eql1W1q1Eh6GHFCPiZSxbq1YMtRzQCgQAHT6Lnr1q226bbkWLVqHec5P8hurcTEJEEGE/v3izl+Z8tmCtrnySPsmqzkfWEGYjCX+bR+/WYUKlSYk/20ffs22dsghBBrUeCJEBHs7AGxDJ979+5iy5Y/RbOXLKVt9+tnyl6Sm0Hj4uKCzp27oFy58ihWrDg2btyC/fuPCrq9DR06EnfvRqBu3X4A5HS1M5ysuLq6mZ2fmW7L7AZ7OXRIPOVcCrueQnDwJdXb/eMP7gn3pEnjJOft1OkT2eu1NjvPnuLj4xEeLiyuzw5S8IOnDAo8mWzZ8qdgmlj3CyVSU7nf/fv371lcpm3bDgBMhWy1pkX3QUIygvj4eNXLVqxYGfPnLzE7T8GChYyPta4ndemSsMusI5Upwy18/vr1K01rb8bFxWLv3t2caWlpwi77bm5urGOcWK0o+QNsMO+ZuUE5WrRohUuXbiAgoI5x2unTJ3Hz5g3KLiWE2AUFngixgAm6vH79Cn5+3vDz80aDBrUwaFA/0UyNHTvk30FSe0c/KKglqlUT7xbn5uYGFxfDV1tuVzumGKbU8OWm+T6+kcbY2SURERFm5jQvIYF74bBq1XLJeWvVCpC9XluOKqa1IkX8UbZsUezevZMzfeNG0x3oihUriy7LP5H/mIl14Y2OFtZ4U4J/rPjvv9MWl2HuyDPHG2skJCSgTp06+OknU+CxWrWaZpeR6j5CSEbAPrYrvcEQHW3KuMmUyR2ff/4F53X+aLktW7Y2Pta6+7atAtNq+frmEEzz9/eR9Vs6YcJo42NPT2GRbwB48uSxYNrlyxcxZMgAvHnz2nhO4eLiagwoinVlLl++osX2MJgbB66uys7Rbt68jsDAeihVSv7oyXq9Hnfv3kH79i0xffpPirZHCPm4OdevASFOKCHBUGS3cmVht7gff5zIeR4bG4OJE8dKrmvFCu5dx7FjJ0rMaS3DBaHljCfDxaYp8CQ+vykzyrYp+Wzffy/MCBIrNmxr7GCc1Ih4cijpHsWet3Xrdpqt11n07t1D8rPG7so5a9bvxsdqRhTctesf9O/f26psAa3cvx8CFxcX/PbbDKvXde/eHcG0Z8+eWLVOsTvecrPMtOips23bFpw7dw7z5plGaXzwQDjSExtlRJGM6tixIyhWLB/+/nsLAOVdV69cuWx87O4uDNAePcoNLLNHYrPFb0rnzl0ASI/UZk+5cuUSnf7+fZTx8dOnT3Dw4D7BPOyBQaQGXAgMDELfvgM40yZNGo+//tqI778fZpzGvpE3Z86vgvXIDdiNHDmUlfGkflCH27dvyZpv4cKFqFu3Js6d+w9z586Svf7Ro4erbRohJIOgwBMhPPyLLb1ebww+iWF3HYqKipKcLyUlBRMmjOFMY4pMak15xpM757nUfPa8c8m+A8uIibEuq0MNrU7C2UPDFypUxOy87P3800+m2jpiwZr0GHgCpOtlZc1q6tpar15942M1XQG+/fYrbN++FUuWLABgyBqYOXMa7t27q3hd1urQwfB5nj59qtXrUtpdVI769YXZRWKZVWK0OC4kJQlHEuUH9vkyZ7bN8ZMQR+vatRPi4+MxYMC3AIDdu3coWp5dH4jfJb948RKCQUnYAQupzGdrMNmJhw/bdxQ9JcqUKY4LFy4AAGrWrIQvv+yKo0cPS84vddzLlSunZBmFAwdMwSz2jTxz546WrF+/xvieWZOVfvmyvFIC48ZJlwkwZ+1abYu4E9KzZ3cEBFSzqgyGsxgwoA9Gjhxi9XrOnfsPAwZ8i5YtA9GgQW107twO8+bNljWIjz1Q4IkQHrGL+ytXgiXnj4gwBZ7MpWpPn/6zdQ1TwBR4kldcnKnxJN3VzjBdrD6Ptfr1+050uthofY6o88OvfaMWO3jJr+E0dOhIzvOmTU13hdknt3fvCjNd0kttBnbXDwA4efK46HyVKlURnc6+g6/UzJnTABjuuM6ePRMNGtRSvS613rx5w3r82u7bN0cqsN6xYytZy2sReFJzwcSuS0MIEcdkkb59+x7Xr1/HhQvCoD97BDVb3MwQyx5yJLFBUpKTk1G7dm2cPXvGOO3ixfOS6/j55+mi04sWLS6r2x77mKc02Ofr68t5zrxn7Mw1pcQyacV8jCUXMrKEBCA62jH/zNzTt+jJk8cICTHcRGQHdD920dHRqFixMsaOnYh58xahW7cvsG/fvxg/fozlhe1A/RGKkAxK7KTLXM2D7t0/xcWL1wGY66qWhgUL5mrTQBmYu52WTn6YwBNzt1MqUHXz5i4NW8fVsGFjLFu2WDDdwyOLYJoj6hnZ4iSc/3lq2bI1fv/d1MWIfYeafVEfGxsrWJfYMMzO6OnTJ5zn06b9KAi4Adw79VrHGTdtWq/tClVat24NRo8er/l69Xq9qhGq2BdabO/evZNc5sGD58bHWoyKxf6ehYaGCkZ5Gjx4uOAYWrVqNVy6ZMhQuHjxPGrWrG11O+ztxo3ryJkzJ/Lly+/oppAMhH2Tplix4gAMAYOKFSsiMjIOAPfgys7QsfZmC7s4+YwZszVZp9Y2bNiCLl06iL7Wpo1ptGBzx7bixUsYH+fLl9/YHdLFxUXWTTL2b7vS84yiRYshMtJ0Q5TZ5zqd+psAy5Ytxs8/W98VnKQfCQnAvn06REXZr4wGm4+PHq1apSKL8HTfogMH9kGn06Fq1eo4duwwvv9+rCC782PUvHlLNG/e0vi8evUacHfPhBkzpuLt27fInTu3A1tHGU+ECCg9AWBfUEt1herSpaOVrVLGVOzX/MkP015TxpP4/CEhRzRrG5+SAppaB54CAuoaH7dr11F0HltkFKWmckcN4p/csp+zT04TE624PeRgUsENc5gLpoxGbhc2pdSmUluqH8MPlJ49G8zJSBTLeKpRQ1lWGfszHxcnDLD+8MOPgmns40GbNkG4deum5PpfvHiuedFka927dxdNm9ZHUFAjRzeFZDCbN28yPh48eITF+atVq258bG2XjP379xofm0a+NH2/zQW0ba1q1WoAuKPVqsUeVIH/G24p2xzgFgJXesHMr9vFHimPELmSk4GoKBd4eOjh42Pffx4eekRFuUDtz/LBg/tRvXpNdO/+JWJiYgQDorx69QoBAdWwb9+/mDVrBoKCGqFNm+aYP3+uYOTOq1cvo2/fXmjUqA6aN2+CKVMmcnp4MOvau3cPfvnlZzRr1hAtWwYaB8Y5dOgAPvusEwIDG2DMmJGIiTEdQxMSEjBr1gx89lknNGpUFx07tsHMmdPMHmfv3w9BQEA1XLjAzbhMS0tDhw6tObUw5cie3XC+lpLi+HMgCjwRwiMWeJLblUTsZCNvXl+cOnXcukYpxJwEWS4ubvhbmbudSUnixTKTk20X8JC60+/n5yeYpnXgadeu/cY7slKY4q5a4l8A809ac+bMxXrN9NnTephrrSQmJlq8w7txo/JsI2cbDUkrSkeoMof//YmICMejRw8UrWPEiMGSr/n5eSN//pycacWLl+Q8F8sKUHphx36vw8LCRI/D/NpohQtzny9cOA8AsGzZInTu3BZxcYbj2X//nUa1auUFf4ejMV24374Nc3BLiLNr376TYNqyZYsk59+2bbPxsZzvYmBgkPHx8uXCDGQlRo40HU+YmyzsY8SXX3axav3WYAI2VatWtzCngbmMJ3aXs5o1uYF2pRlPYl3/zOGP6GnKeLKuG5zS3w5z0tOIux87Dw/A09O+/6wpcXvz5nW8fPkCzZu3QK1aAfDx8ZHsbrds2SK4uLhi6tSZ6NixMzZtWo9du3YYX7979zYGDx6ATJkyYerUGRg6dAQuXryAQYP6CXoULFu2GF5eXpg27Vc0bRqEBQvmYdGi+di8eRMGDRqK778fg+Dgi8ZzEcBwfpyamob+/Qdi7twF6NfvO1y+HIwxY4QZ/4ySJUuhfPkKgtp+58+fRWjoG7Rv39HiPkpNTUVSUhLu3r2D1atXoH79hsibN5/F5WwtY57VE1WSkpIE3WE+Ruxgjb9/XgDyhxeWyhiyN6XFxSMjDfVnXr82ZWLExUUhJOQc9Ho9UlO1u1CWS+yEzxYnMszJn1SmW/Pm8urcKPHXXxs5zwsW5A5lzC46zz45daaMjbi4ODRqFIBevXqgUCE/DBjQB6mpqShUyF+0C4NYECkk5J49mirp+vWruHTpAt6+fYsrV4Lttn/5GW/WYN/h1uv1KFOmKAICqokOz20rYu+t0mPh4cOmESMXLJiDn3+eLJiHP3Jf9ercguhMkPiHH8bh9OmTmD17JgAYCzQT4kxu375lDI5aIvb79MMP49CuXQuRubnkZMGwf28jI63L8mUvz4w8yT5GXL4sXTPT1pjMIrkBmjVrVkq+xv6bBg82jNjGZHDLCTyx26C0KyL/PWVG2LOmxhMABARUE0z78OEDIiLCce7cWYwd+72gyz+/fiPDXO+BmTPnWNVO8nHbv38fMmXKhMaNA+Hm5oamTYNw5swp0Wzp8uUrYuTI0ahdOwB9+vRHpUpVOIMGrFmzCr6+OTB37gI0aNAIbdq0w4wZv+Hx40eCgVwqVqyEoUNHoHbtAIwYMRo5cuTEtm2bMXv272jYsDFatWqL9u07cdbv6+uLMWPGIzCwGapVq46goBYYP34SgoMv4dmzp5J/Y4cOnXHy5HFER5sGVdqzZxfKl68gqzdAx45t0KhRHXz99RfImTOXZE06e6PAEzFq0yYINWtWwunTJx3dFIdi/1gyJylyL0hv35bu6sG3b5/tuq/JzXhiXmcHnBg//FAPP//cFMHB25GSYv/AkxgtaskwF6vTp/8GwHTyJxXUUnonUo74+HjOc6nhnQFuzYZnz57YNaBgzrZtm3Hnzm3s2bMTALBly1/Ytm0bYmNjceLEMeza9Q9nfrEUX0cW2b569TKaNWuI1q2boXz54mjRogl69Ohql21rmbnGvvhhX/CZGxBBa+ysPIacriZs+/b9a3z84sVzLF483+Iy/Lv+fMxdx9evXylqCyG29ttv09G4cR0ULZpX1vxSF/Hnz5+1uKyl74ktZc/uAwDIksXTYW1gy6KwmMy7d29x9+4dwW82wD32VqxYGTdu3MehQycAKM94KlmypJk5hfhdmSdOHAsACAsLVbQeOerVq4EyZYqiffsWWL58ieBciT1wBpu5wFPr1u00bSP5eKSmpuLIkUOoW7c+smbNBgBo0aI1kpKScOzYUcH8tWoFcJ4XLVqUk2V87doVNGzYmNPdtWLFyvD3zysYfZldR1Kn0yF//vwoWbK08TgHAIUKFUJMTAznmLFv3x707NkNTZrUQ/36tdCvXy8AMBt4CgpqAZ3OzTgww/v3UTh16oRkWRC+OXPmY/nyNRg7diIeP36EUaOGOsUo2BR4IkbXr18FIMzG+Niw7zwxd5UsBZ6Ykwwl3bIKFLDliExMcXF5GU9i3r59AgAIDt6OTJnse9I4YsRo0ene3t5Wr5vJJsqRw9DthjkQBwdfFJ1fi+wUa7pW+frmMD6eMGEMqlevIBiFTO5dcy19+CAsas7+of32269w/LjpJIDJHmRbuXKpVW24ceMa/Py8MWGC+OfFnJMnTwimmRs6W0tapjt/8slnxsdHjhwyM6c2PETy48UCwtac4Ny5c1vWfOwuqc4oNjbGISNxqhUWFma2ThbRzm+/Kbv7vH//v5KvWTqOKu2y/PffW3Dz5g1Fy1gyadJPmq5PrSFDTN1b+F11pTRsWButWgUKprNrNAFAnjx5jOeMcrKzXV1djTed5B7zGF980VN0OjPYghYSEhKwYsUSiz0hpI715n4D2KMoEqLEhQvnEBkZgfr1GyImJgYxMTEoWrQY/PzyiHa3y5YtG+e5u7s7pwtdTEwMcuYUdsPPmTMnJ9tIbF1ubu7Ili2rYBpgOkc+fvwofvxxEsqVK49p02Zi5co/MHPm7P/PI31tkCVLFjRv3gK7dhlu7u7fvxc6nQ5BQZazXAFDd71KlSqjY8fOmDlzFoKDL+HEiWOylrUlCjwRgfR0omwLN25cMz5mTiIsFWRjLvyVdAXjj9qkJaXFxS2sDa9fa3sSyse/Cyk14pcWI+MwKenMHdg//lgNQLrOyvbt2zjPpdLKzeEHaZRkbonNyy94npxs/4w0sc9Or169OM83bVpnfNyyZRvB/OwitGo0bdoAALBihfIAlhbZc2oVLGhd0Jld2FuqOL/cY5HS4vn8oraAVFc79d9Vud1gcuUSjs5i6fdLizt+qampuHPntui2bty4hq5dO+Hw4QMoViw/BgzoLWudzvC7W6FCCTRpUhf37t11dFM+KuwitmqMH6888G5JYGA9s6+npqZi/fq1srtL58kjL7PLVphjZu7cpmD12LETZS8v9n03F9CT8312cXFBmTLljOtnK1HCfAaU2A0Arf366y+YMMHyEOzSozlLH2sdmYVH0jcmuDR16hQEBTUy/gsLC0Vw8EWEhysbvMDb2xsRERGC6eHh4Zrc7D569DBKlSqNsWMnom7d+qhQoSKyZZO33g4dOiMk5C5CQu5hz55dCAxspmpghJIlS0On0+HFi+eWZ7YxCjwRga1b/3J0Exzq2DFTFzjmAujBg/tmlxk92tC/31mKPzMX1ZYu/piMp1Kl6kjO8+LFde0aJuGzz7pznkud0GmRfZSSYjgZypTJcFfi3r07ZufnZ0KtXLlMxVa5QY46dYQn9W3atAcA/PbbPMtr4wVNzp8/p6JN1pFzYs3OxLK26KnWduz422HbZhe2VKNDh84AgFGjxnLeB3ZQlH+nTgpz7GKsXbtJYk4D9uhXDK0DT/zgULduX4rOJ/aZstTVRIuuKN9/PwyNGgVgwYK5gteaNm2AY8eOoHt3QwFlfuCajf09doYUeMbFi+ctz0Q0Y2lUSTnsnan2118bMXLkENSvX9PyzHD8aErM94udpdS5s7Ii548fP+I8Z4/Uxye3xh0/a4qxceNWs8tZe+PkyJFTFuc5dUqYFSxG6lhv7pjGZIUQokRiYgJOnjyORo2aYNGi5Zx/06bNRFpamqAukyWVKlXByZPHOceomzdv4M2b16hcuarVbU5KShJ83g8ckHfTtWzZcihVqjTmzv0N9++HyO5mx3fjxnWkpqZKDuZkTxR4IoSHHdxgMoeWLjWNHnPixDncuvWQswwzEojS7AFbMRUXtxR4MpwclS5dV3KesLCHkq9phV3HyBwtLs5Mo78YstmUnsDNmDFV1nw7d27HyZPH//+MexIq9nesWbMBT5+G4quvegle4+O32RGfOzkn1ocOHTB2v9OyoLYau3fv5DxnZzbam5JacGKYO8mZMmVCnjz+xunsgpNyAz87dmznPPf19TU7/y+//CaYJvYV0nIgAHaGF5tYwEvsu8XOMNPiGLJhwx8AgFmzZli9LgZ/KGhHYh9f0tLSMHXqFKuzE4m0tWulC1jL1aSJ9G+4LVy5cll0utT3nn9TTsvR0yx59+6d8ZjJDla7uLjg9u1Hsus+8QPN5m6myM1gPHlSvOsLu96MGGtv5FSsWBlhYdEIC5O+QSH/GG74W2NiohEQUBV+ft6YPHkChgwZILkEZTwRNU6dOon4+Hh89tnnqF69Budf06ZBKFeuvOTodlK++aY3IiLCMXz4EJw+fRJ79+7BuHGjULRoMdnd2sypWbM2bt++iVWrluPChfP4/fc5uHRJvLSHmPbtO+HKlcsoVKgwqlSxHAgbM2Yk1q5dhdOnT+LixfPYtGkDxo8fjRIlSqJRoybW/CmaoMATITzsek6PHxuCLkz3LMAQgc6dOzf69x9knKbTueHKlWDZo7Vcv27b0bzkd7UznIy5uWXiLWdfYhlAYrTpJmM4AWa6USqtfyHHs2dP0afP1/j0U0MWE/8kVKogrNwTYP7INXKDYVqSe2JtbTYgO+hgTUZh7949VC/rbNjB01q1TMUu2dk1agu3Fy5cBD/++Ivk6yVLlhJME/sOKS0uzq5lxifVZYO/3TJlynKeN2xoOMliF+SX+gzp9Xrs3r3TYSO79uz5OWJjY+y+3aioSIwcOZQzGAB7ZKBdu/7B/Plz0LPn5wAMXZO/+eZLwTDTxLLU1FT8+ecGPHr0gPM9snRcW7VKTZatbYnV+AOkM0n5N0u6du2seZvE+Pl5o1y5Ysa6iPyATa5cuVCzZoDYogIbN67jPDff1c66wLul8xJ7ZAyZK3zMlpqaipiYaBQvXgCPHhnOmZcsWWA2WG2L8y6iXmIiEB9v33+JicrbuX//Xvj7+6NatRqir7du3RZ37tyW/dkFgDJlymH+/MVITEzE+PGjMW/eLFSrVgMLFy7VZHChTp0+QffuPbBt22aMHTsKoaFv8OOP02Qv37ix4TymXTvhaNFiypevgKNHD2PSpAkYPXoE9uzZiY4dO2PZslUWA9r2QNXdCOF5+fKF8XHi/4+MYieG7OyCp0+foEULeZHkXLlyiRZa1pLSrnZM4EmvT0NaWprdTwo6dOiMPn2+FkzfunUntm79C//9dxovXjyXFXi6du0K/P3zSdbQ4mc8FS1aDHfvmu9upxR/lBetu9Hw31f2Z9Zezp07I2u+LVv+xMKFy0RHBQKki7ozatcOMKZOz58/R7LwfHpSv35Dq5ZnPk/8i6i9e3cbH8+fP0dRDRNGvnz50aFDJ0yeLF5nTYxYwJr9Gf377y2YOXMa/vjjT5QtW050HQMHDsbUqT+Kvla8uHi9E/7F7MOHDzgB0UyZ3PH+fRRnHqmL/AoVShrrvJnLAtAS+7MfHx+PMmWK4tChk5L7yBZKlSoMAFi/fo1xGruL7KtX3BEBv/9+GADgzz834Ouv5dWvUuunnybBw8NDsuZferN+/VpjIL5OnXq4f98wmqylwUvGjfve5m0z58mTx7hz5zZatmwNFxcXPH36RHQQmtjYGPTvL/6ZqFevAee5PQK8S5bMFkwTyxQy12XOHHPnSYMHD8fmzZtkj4jMZykT2x4XkHLrWS5fvgTbtm22cWuILbi7Az4+ekRFuagKBFnLx0cPJR/l2bN/N/v6p592xaefmkYnPndOmJk5atRYjBo1ljOtatXqWLFijWBeRr58+UTXtWTJCsG0tm3bo23b9sbnOp0OQ4YMx5Ah3LIG/PWJrQsAzp49A53ODa1bt5VsH1vPnt+gZ89vZM3rCBR4Ig7z118bcfv2Lfz44zSHFvrlO3hwv6z5ypYtb3yspG7IqVPyUyzVUlpcnH33LC0t1aF3owYOHGp83KhREzRq1AR+foZCfDdv3kBgYDPJZW/cuI6goEYApC8emTtybm6GE9BRo8bi22+/klxngQIFFRfk4weGzAUA1RQJjY+PQ65cufDunbIiimLevHmN69evolmzFored6XpzNOn/yw6/e3bt8bHYpk27DZFRgoLQDL0ej3nOKKmCLy9nD590qrlmZN8dmYKnzXBTqXd5MRHtTOtY8CAbwEAAwf2xdGj4l3KzHXxa9++k+Rrrq6uxvYmJydz2nL48EGMHDmUM7/UKDJSgwuYw8/6U9LldceOv7F27SpB2xo1CrBb4EsKO6NSKrPR1t+vV69eYuHCeQCAYcNGZYiuORcumGrxnT1rCtxv27YZixeLX3SoVb9+Q5w+fRI+Pj5Wr6tWrcoAgE2btqJZsxbo0kV4533Llj8xaFA/yXUwGcb2NHu2eCCb7/XrV5ZnEiFVnwkw3NB6/Pg1ChQwP/Kmj48PoqKiBNMtZT87Yn9KoaBT+pUlC9CqVSpUxket5u5uaAMRevXqFZ4/f4bVq1eiWbMgpx/FVy7KdSQOM2TIACxduhBHj9p+CHAl5N5trl1bXno2n9iwnVpjAk9KM54MyzimyC0zxPx33w2RnCciwjD6T2xsDJYuXSg4YTx//j+z22BfRDFBm8yZzQd+zJ1cStm5k9vdwFw9pC5duilef0pKimbdIqtXr4Avv+yK7dvNFzO1FXbWB7vbGENuUJofaGG6VjiDRBvdSly2bLHka0WKFFW9XqUXq2LvkdixJylJej+YC5QxQ46L4W+Hn9HE7kIGiI8AqbZGGr+7mdTxdsoUYeZZ377SdyRt9XmRi50VIhV40rKGl5iEBFOGpK23ZS9yA/vmsmSqVxfvYsLHHEvZd/+tdeGCoej8kyePBa+ZCzo5E7HPktpRHC29n3KCpZ988plg2qxZv8PHx3ytPWe6WUvStyxZAG9vx/yjoJO0lSuXYeTIIfD3z4shQ0Y4ujmaocBTBqLX6zF27EjMny8caceZnT5teXQNe+rVqy8AQ5cTubWHxHz//TjBtFevpDM2tGU4KbFcXNzwuk7HznhyTBHo8+ev4u7dx8idWzhEOpOmX7FiJQDA559/gkmTxqNy5TKc+TZt2mB2G+yLWyZb5N9/d5ld5tmzJxbbzrdq1XLj49jYWLMXTmqyy2Jioq2uIcFgLnKOHj2syfqU+v13U3eImBhhjZv8+QvIWg8/cKEmYGgr/NogWjFXE6hAgYKK13fsmCFwmzVrNtHXe/QQD5bIDTyZIydDi13DKXt2H9F5xAJLbGIZT1oFNqQuYBcvnq9oPY6qM8VgD/bAbgt7P4WHh9u0DeyMuYwSeJIbLChZUvq727XrF2jcONDiOuTW4FPC2liHMwRLmBtcWpDz292jx9dmX+fvkyJFitq9m0zVqtXsuj0tsvAIyegmTfoRp09fwJIlK+ySsGAvFHjKQG7evIHVq1dg6tTJsuZPSUnBtWtXHD6Mc0iIurtNtsLsj2rVanDqOCn1/ffjcONGCPr2NYzssWjRcrulR5tGtTN/8sm8zs54ctToYx4eHsiRQ/zgytw5ZLIZ2F0W2G7evG52G+xsCFt13eAPax0fH282SNSggfJ6Pz/9NMnixdjLly8wa9YM2dkTphH4tCf3IkisbgW7vou5oen5mS5qu4sePXoI169fVbWsFH6dIa38/PN0yddKlBCvi8TG7ubIXyYsLBq3bz/Ctm27kCePP0aPHm+xvgLbnTu3ZM8LcAMNUk6cOIc//vgT8+YtwsWL4qMS9u//rdl1sLNJXr16iWfPniIkRJvBHthFzPmWLVuEjRvXyfouJCY6NluvcGFTttyxY6aANLvty5Ytgi2xj2+OysLVmtxjklQ9PADo3PlTrFolP5CtZbCHP6gFQ+6Ih/yAtjWDRVjy/v1L0ena7g/LNzfYgyaULVteUCqA3x5rR6tbvly6To0UdtkIALh9+5ZoDS+tOEMAkhDiGM7TSZhYTWnXkq++6mYs2rt//1FbNEmWOnXqO2zbYkwjvemsHjkkTx5/TJ06E1OnztSiabKZAk/y7hSzs0PS0lIkgxpiaeH2wJyMWXvnm32iy7y3np6ekvOruWv86hW30DdTsF1KhQqVFG/jzJlTFu8aVq1q6DL666+/yKoZo6ROmVJ58mS3PBPER+phn7ibq8MTGRkBLy8v43O157aff/4JACA09L3TniD7++fFmzevERAgPYR6kybStdAAQzex8uW5gXX+CC65cuVCw4aNceNGiNl1abGfpC5C2Z9zFxcXtGrVxux6rl27Yvb16GjDdyEtLQ1VqpQ1O68l/EwBc4GFH34wZMD+8ccqHDx4wux6xY4XN2/ewI4dWzFw4DBky+ajvLEKsL9H7NGB7Jl5xN6Wo2+OacXc78mZM6cEBbjFMKN8BgffRPXqFcxsS3n7+PgDjUgFRZgRD/lq1uR2na5UqTLOnDFluF+4cA4VKmh//peamoJp0ywH3q0l57DHzh7U6XSC7xD/2GltfU2pm3fm8N/Xxo3rWNUGS8wFVgkhGRtlPGUg7BNEORfMTNAJAFq2tJy6bSu2SAm3BnMB5OqqMxaglvLll9JFqR2JOZmx3NVO///5TYeC+Pj3iIsTr3lSvnxFjVqoDHNiJHYBcuVKMMqWLYq9e/dwposNp8q+c541a1YAgKenl2A+hpqio/zgyfv3781esBUtWkzxNgB5GSJa2r17J/z8vAU1c9SQGqXK0vfNHKaANSMsTHmxaDYtuztpfYzjj8woxlKQoFKlUmZfV4J98aR2xD6prJZBg4apWp+U+HjDiG1qsi0aNKhlHOgAAK5c4Y5KI2cQgqtXzQfGAOF7p9fr0bBhHcyZMwejRg2XWEo7Up8d/t9rrzZklMDT9eviWXqA+WxOMQULFpI1nzVBYX4Gn9KgyJ9/cv+muXMXcp7bKuMpNtb6QTfkkLNv2Tf13Nx0gt8CrQNPaspDWJtlpRS/Nh6xJ+e63iIZhfzPFQWeMpA//zSlxqanEzWtatVohbmgd3Nzs9g1zpnqyLDJ7Wpnmt908nPp0i7cvSs+8pSjRrtjLrDFPtctWjRBeHg4vv66O2c6MxIPG/tEl8kWYd/d55P6HoWGSmcH8bvwbdjwh9nvo9oLA3vXPenduwcAGEcA9PPLIzkv/4KDT6ruhTVDRPP3R8OGwkLljqJ14InpDmvu+GTu8xEfH4/ISHUFtS0pXLiI5Gvm9oPUd4QJFGmFOYaZ+96J1YGKi4uzWIT4l19+sq5xrG2xPXz4wPj4yBHb12KTCgLOmiXdtVNr7C7f9g6y24q5c5316w1dpJR0cbpwQTqQpcUx5/ZtbndZpRngTHYWg39ssNV56tWreyzPZCfs44xO5yaS8cQ9p7L2HEvNb6i9A0/E/tzd3eHiQkE/YhtJSUlwcZF3/KGudhkI+wcrOTnZqYZbNcfZMp6YE16dTmfxxIidRu1MlHa1YzNcdIi/J+a6pdkSc2KUkpKCixfPy1pG7MKbfQHDfD/YgSe9Xs85UTx3TnyUvOvXryAoqKXoa/yT8+TkDzhwQF4NDCUcHbA11zWvadPmkq+NHDkGefL4i75mTSDXmYea1T7jydQdWHoe6ZGxihQR7v/u3Xuobg/7O2Pu4tRcMEwq++HcubOq2yXm2TNDFoe59+TDhw+CAHJsbKym7TBn+vSf0bBhY+NzdkArOvq9zbcv9T4dP26/Lvl//mkaKCKj1HiSY+rUKbLnlTNypZIbG23atOcMtsE//7E2QMFviy1+w6Kj32LTpqGKlqlevQaCgy8p3lZysuWMrb//3mJ8rNPpcOoUt5utMOPJ/kEgd3fb1LskzkOn08HHxweRkVEAmG71zllKgKQneiQlJSEmJgq+vj6yfiPSR2SCyMIefthw0aFunMpChQpr1CJ5nG3EGuZky83NDStXLjM778uXL8y+7iimrnaWLniFr3t5+ULqB6ljx85WtkwdJsCXlpaKNm2CVK+HHVRk9hE7Qh8eHs4Zul0q8JiWJr1f+cGAsLAwzS+eDW2w/nvDL3p97txZBARYV9/hxg3zhZpr1Kgp+Zo1Bd8fPDBfh0gpLYNFXl5ZOc9r17ZuH5s+x9I/4Uq7sXz2WTfV7WFfPHXr9gX++GOV6HyPHj3EqVMn0KBBI8Fr5gJlWpo6dTKGDBlu9v0VuyD+6y/hiJn58uVX1YY3b16bfZ2fWbVnz05V21HLGTKM/vvPlHWbnjK4zblz57bFeZTW2hs+fBTmzp2ltkkcefJws1gfPAjhfE/OnTuD774brMm2ANvcdIyJUT7aopqgEwB8+GA5e+Tx40fGx2I3g7XuaqdGo0aNsXTpQsszknQtb968AICoqCiIDCBMiCouLoCvr4/x82UJBZ4ykP/+O2N8zB65RylbZSCFh4fDx8cHrq6unJG2XrxwruANu8aTJVKjIU2ZMk3TNiklP/BkXML4qFChitDpxLMWfHx8rW2aKsx7IecOoznM5459IcP+m/gXv1L7T6wrDn8bjN27dwhGjdECO/DUsqX5gstS+F0pdu78W1bgydyFYP78+ZGSkoY//9yGbt0+Fbxu7ntVsqT6ukMPHtwHYDj2xcVxs1MOHDiG33+fg5YtW2PIkAGy1qflcXDTJu4oVFoVyTeX1SoVeIqJES80by6IZQn74onpXiN1AfXJJ+1Ei93Pnv2b6Py2uhAz9x6IvTZt2o+Caa9eiY+cZYml7oOxsfa5KggPF79Il/v5jIgIV1XMWA52d0MqRmzg4eEhmNa16xeYO3eWILit5vjFz3xZuXIZBg40ZQ/JHb3OnBs37qNiRUPhb9uca9ovg15unS0GO5jKcIbAkzXHfpJ+uLi4IF++fMiTJ49V14iEsLm7uyvKhqWjTQblTIGn0NBQ44kGo1+/79hbFG3Dgwf3Ubx4Cbv/EDMFYuXczXry5LFgWunSZTS9K6iGmq52efOWwOvXD5CWliqoO+Bo27dvBQBMmTLBqvXs2bNLMI09aha/mxB7FLWcOXMaL9RCQu4C6CC6jU6dhEEgPz8/xcPLs+XKlQvv3nELprKDXzly5OAvIgv/hFPud3/fvn8tzlOoUBHR6cz3edas3zFqFLdLhLWjo/377258880XgulVq1bH2rWG2ilyA0+TJ4/H+vWbrWoPgx+gtuYYq9frje+9ucCTVHCwePECotOtKezOft+Y9zctLQ2dOrXhjEpo7bq1dPjwQcnXbJ2FGxBQzfJMNhYbG4uyZcW7asnNMLJlvRB2cO6PP1bj55/tV1/KWdWoUUswzfJNJvnfH/65VlpaqupzyWzZvEWnM4N6AMprRsmh5tjat+8ALF++RPFyam7EtW/fiTNAB3+fW3O444+yKVehQsoCaOY0bhyILVt2cKaxB2QgjqfT6aiuF3EY57q6JJpxpsDTr78Ks3+WLVtsfCwW5Ojduyfq1asBf38fu9/tZGpLsGtMKDF4sO1HHbJM2ah2gCkTJS0tNUPV1FixYgl+/302ACB79uyC1zNnNt1F5l9wsettTJo0yfh45kxlGW1duogPNy2Xv38+s6+rvVB2d+cGLqKixAtO87+DM2dOtbhuqYDBwoXzAAD+/uJ1nqwhFnRS68CBfZqti8+a2ibsYLe5Y7XSrnbWnIhyC+ia1nPmzCm7dxOTa+/e3ZKvmetKy1aihO2HbLcV9rD2fHI/n7YKCgLcbCx71LVyBpcvm+/yJRYQNL0H3M+smvM4fhAkNTWVU+RdidWr14tOZ9dUVHvDxBw1f3fevMq7zPbo8Y3iZQBh1pqWGU/9+w9StZyl8wslHDUADSEkfaAjRAblyJoI8fHxnC4I/CF5+bJly8Z5/u+/uzkXK6tWLde2gTZWoUIlRzdB1ah23MCTbYY5trfY2FhMmDAG06b9iMuXL6FcOWGXN2Z0O8D8BVeJEiU4z7dv34qICGFXlcqVqwqmMSeXjRo1kd12Nn6AiE9tsJifMSM1pDc/+8/S6F6A9N1g5k642i46Wg/BbSiyaV/WZNSwAztZsxqOnTlzCvel8sCTNgnQ9h7UQu3xll30l0/u++NsA2Mo0b9/b8nX2OcPrVu3k5xPqque1tj1KzMypruwFHOBJ6nPopLgID9okJKSqvp4K6eOXWjoG1XrNk+4H8yNtAmoy/acPft3xcuI0TJ46wxZLBR4IoSYQ0eIDMqawJO1BbOLFPFHlSpljUUVLQWeSpcuw3nOz1qwdBfQlsyddEuxpkCyVtR0tWMHntTe5XQ27HpLLVsGGovmskcDcnNzM75n5i44mzVrxnnev39vfP65sNi62AUAs161J4YNG5oPWKkNZNiynz+7SDtb/foNAQDVq0sXGTdH6/o3jggU82trqcV0Wxk5cozgNaXf4Xfv3lrREvGMJy188UVPs68HBUmPoKgW//vErjfEZsvAk627+/HroElt21zR9z//FM9q0dqOHdvtsh1Hs1R0XmzgF6nAkxYZTzEx0cYRNJUSq0fFN3bsKFXrNkfs87py5R8oVKgIVqxYK7qMPQM2zPGM+f3TMvAk1b3REi2DRXLWxdwwIYR8fCjwlEFZe9LKL5AsFzvTiRl6+eHDB1a1xZFp9g8fmr8DKcbed/zFMCczlj8H4l3tMkrg6fjxI5znzN/Ff4+YkyVzAVv26HeMq1evCKbVq9dAMI15H9Se4HXrZr4Lmdrvu9zvuZYXwcw+UHLCPXmyqWuftRf727aZ6nzlypXLIXeJramNw2QgsC8yxGqlKC3Eb65gviXcrnbaHv+CglrI3rZW+AH7/fvFa5rZMvDkyOKv7OOguXY4Yuj39MxSMWpLATaxLttaZjyxu8ExbNnt3tJNSTWyZBEGNSpXropLl66jQwfxUXmVHLPKlCmL+fPl14Pi1yarU6cegoNvYteu/QCsq+nE17hxoKrlPDw8MGCAvLqkxYoVR9++fTFy5Peir1s6x/Hzy4PLl28qbiMhJGOgwFMGZW1XO7Xp1UePHjY+lntSbqmttixgaomaoJkzpDub6mbJ72rHtDstLRV6fcao8fTdd304z5nPGv89MgXdpAMsck/g/fzyCKZZm/FkqQaF2gvgjh1by5pPbs0bPrGTWfY+YAfzNm6U7vrEzp5ityV/fvFC2eY0bNgYbdsaCsMPHDgs3XUNYI6H7NHpxD63SoPHlrpzyqXTWbc/+UPyqr2Lbw3+/rR19pGYsLBQu2+Twf5NNncuoHZUv4+VWKH9RYtMpQRu3rxudvlixYoLpmmZ8SRWt0jNuaAzZH0zli1bbXEeJb/LJ0+ex+efy68lWLFiZePjjh0Nga+CBQsZf/u0Gsjl7Nlgq4LwP/wgHLVTzMWLV7Fs2TJMmDAZz56Ficxhvg03b9532OjIhBDHS19n3EQ2awNPajNeXr9+ZXws905ZWloaoqPfY8aMn0VHvxA72bKXLFk8HbZtazAnM0oumNjBF7HPz7ZtRwTT0hvmDiv/DicTfHj+/BnOnj1j1TbEUv2Z/ck/yZRbDNRScMRSl8qxY0fK2o4UuSPyFStWjPN83LgfBPOwg00PH75EcPBN3Lz5AEFBLSXXy74wYH821R7nli5dhcOHT2LAgEE2LZBszuTJEzjHS7k2bvxDMK1hw8aCaWIXjHfv3pFcrzUjTLF3odrgatu2hm7NI0eOxqtXEVi6dBUuX5bzuTNt/M2bKGzduhNffSVdv0gOuYEnW2Y8TZ/+s9nXY2NjUbt2Ffj5eZstFK4G+7Nz8eJ5yfnYo3NpoUuXDmjUqI5DAn32kJwszCqUUwuJIVaryJYZT0FBLWQHnjZvNn0WZs6cI3ubWktJ4e7jTp0+tbiMLW8WsrMCxTLatPr9KV7cuoEO2Fng8+YtMmZk8bHbK9ad8s0b5b9phJCPBwWeMihLF2QbNggvXpQsL4WdnSS38Oi2bZtRokRBzJnzm+jrjqrx1KBBY9FR0NjE7uw56kJWrA3KRrUznHikpaWIBh6rVFFXk8eZDB36HQDg9m1uqjcT2OncuS06dGhl1WeOPQw448SJYwCA4OCLnOliRaHFWDoxtpSRtHr1Csk6NVIGDuyLYsXyQ6/XW7wIZvCPG2InpuwTXA8PDxQsWAh+fn5m15snj2kEPPZnWu0FaqZMmVCpUhW4uroiKUldt2JrLVmyAJUrl8H9+yGKlgsJuSeYJlZPS+yC0VzxYluMaqcEcyxyddXBzc0NnTt3QYECBRVt29XVFY0aNUH37l9Kzi9W/F+qLVLP7WHbts0AgISEBMFrb9++RbFi+Yx1FDt1aqPptkeMMGQqRkZGqO52r9ShQ/tx4sQx3LlzS/OAlr0lJibi2bOnguli3RatDXpomfHE74JevnxFwbnA4sULRJf18fExPnZkxlNysvIMebnvwaefdlWxbvOXWc5wvsiXL19+1YN/xMZK144jhBAKPGVQlgIOzImlFLUFJf/8c4Px8ezZM2Wd/FjKMBG70LKlWrUCAABff90bzZtLZ2EAwLJlawTTnOFEQmlXO8AUfNHr0xAT884GrVJv0KBhNl2/qyv3Pbt06YLqdYl9d3bv3gEAePtWLDXdMssZT5bf57VrVyna5tatfyE2NgazZ8+Unb0oJ2Ct5kKLKUjO34acdvn75zX7utgFoj0pvch+8uSxrPnEgsfmPid586ofUpsb/FF3Ic0ET7U4fnp4ZDGzHcvBSmfIeDK37ZcvnwumWSpMrca7d+Z/B8SKXauRkpKCL774zPi8b19hl687d25rsi17aNKkLmrUqIhr17g1AMUCT9Z+3rXMeHJzc8OKFWuRI4ehS2BycrJxQA7GlCkTLG7HkeUG1NSkkttescxSSywdr53hfFGMWE1LOTw9hXXC5AT7CSEfBwo8ZVCO6mqXK1duzvP0mDLPnOC6ubmhadMgzmsjRnALKrZu3Ra//jrXbm2TS01XO6bLil6vx+rV8rqA2Yul4ZCtxc8qiIlRP3Kape8ee0S9TJkyy1qnpZNTOe+zuVGszLl8+RIiIyNlzSunW4aaUeRcXFyM2VPsv1XOce7kyXNmX8+cWXr0JWuPo3xiGZRi3W/MkRt4EguAmhuogf25VIr9+VQ7uIK1BfjZSpUqjfLlK5rdjjnx8fGc58HB4hmQT58+Udw2pcQupMW6TFaqVFrzbVvK1tAq8CanVlSjRgGabMsemNqQu3fv5ExXE3hq1sz8qI2WAk9KdejQGe3bdwIA/PXXBtld7dgjdWbUwJOlzFwxN26Yr9vlrIEnLbPWli9fg4oVK8uqt0UIydgo8JRBKblgYgrtql2ejR+oSY+BJ6Zo78uXzwUXQSVKlOI8d3Fxwddfc+uJmLuQtR81Xe1cBdOcha1PZPkF7GfOnKZ6XZaCtuw7iXJP7rQIPL1791bWtgDuZ+Dw4YPGLj2WzJo1y+I8JUuWsjiPGP7Ig3q9XlZAzFIh05w5hd3UGDNmTJV8Ta7376OMj8eNGyd4XYvvm1iwRuyCcdGi3xWtQw21F1IHDuwDoLyrhtj2dDodjhwRr3skZ38vWMC9mbB+vTCzVcn6rCH2W/zo0UObbhMAXr58gbdv7ZP5+u23PWXNZykDy9mwA3d6vd4YYNuwYbNxuqen+TqSYhkkbFp2tWMw2bHh4eGyA0/cc4n0FXgyFyz/66+/ERjYDN9/Pw5NmjRTvG5L3emdcXALvV4Pd3fhuYlYVuzYsRMFy/IVLVoMR46cklVvixCSsTnfEY9ogp8ebY7YD4XaUe34d/SuXr2saj3O4M2bN8iXjztqVt269S0uJ1Zvxd6YjCe5J58uLi6y60I5gjOMFCiXkqBtmzbtNNmmnMCTkq52ampcFS5cBF98IX+0H6WYixlm/9pjuPnff59t9ToSE01BTbGLDLUjBrJ5ewszqcSK3LO7FWp5p529LhcXF7Rr11H1upYsWahofqnuXvx9PWWKIZgs5/imJJNJ6rdSzjFrwYKl+Oeff83OI/ZbLjWa44sXwi54cri5uWHnzn2cabVrV8Ho0cPMLhcQUFfV9thSU1Nx9eoVyzMCmDx5vNXbsyf2IBa3bpnqChYpUgwrV/6BpUtXIXt2H7PrCAiwVHxcu652YuQGctifd0cGU9LSlJ+7mguUBQYG4a+/tuP778ep2peNGjUxPha76eJMGU9t2rRHiRIlUbdufWTKZLpBdvZsMFatWo9Dh04KlhkxYjSePHljz2YSQtIxCjxlUEru+mTLlk0w7dGjB6q2u2zZIs7zsDBuTZshQ0aoWq8juLnpULZsOcybtwjVq9fEokXLkS+f+WHtnYWa7CWlwSp7cpa7gpUqVbY4D3MhWqqUeNeXyMgI42OxgIE6wvfMyyur6rWxs3Tk8vPLo3p7cjAXNkuWLMTq1SvMBserVzcUwudfTItx9In/q1cvcerUCbx58xohIffw/n0UfvhhHC5cOI89e3Zxvo83blyTXM+LF+/w55/bMGCAoX4fe/+8evUSJ04cw4cPpm59zZo1x8CBQzX5G/iBp19/nYtOnT5RtS6lxd67dPkcw4eP4oyqJaZs2XIA5B3f+AEVc0EksaBv4cJF8Po1NxtvzZqNGDZslPF5jx5f47PPuqFevQYIC4vGTz/9gjVrNgrWJRbIlsqSqVGjIvR6PW7cuCZalFzK3buPUadOPc60Dx8+mB0FEbDcDcyS2NgYXLkSLHv+rVv/0rz7qy2xM2nY3Tfd3NzQvn0ndO7cxeI66tdvhL/++hsXLoh/96WOX1r9jsu5CVmqVGnO740jj6lqMp6UZAMrxR4tVOx46+jfH7bVq9fj9OmLyJw5MyfjyXAzoYNkV0NLWXuEEMJQV4yBOD0lJ2diwZRlyxYjMDBIZG5l2BcRLVu2xsSJUzB/vuOG2lWCOWHo3r0Hunfv4eDWKGMKIlm6u286OaWMJ2nMkNdyapEwGQqGLlzCwvjsEzq19XD40tLScP78ORQpUhR58hgCQGIXHrdv30K5cuUtru/DB+XZRDVq2HbUQ6YA/B9/GDK3Llw4Kznvzp37HDqyEhu766XYRdzWrX9h69a/BNOZIH6uXLlx+7aha9WYMSMlt5MpUyY0bdrcmD3CrvFUpUpZwfyff/4Frl27Ku+PUMDFxQU5c+bEsmVrUL58JUydOlnR8kq/6zqdDuPGTZK9XnPZgRUrVsaNG9cEQWNzyxw6dAA1atTkFLEXGwyhTZt2aNOmHcaPF29r//7idfXYn5+WLVti//79ghs67HauWrUM48ePhpdXVjx+bHlo84YNm0gGwC0FL6wJbqSlpaFYMeU3cvLm9UVYWLTq7Sr18uUL+PvnVfUbxF6GHRBRUrjZzc3N7LkYO3Ch1+sFgQxrAxtyBprJksUT9es3MD4/e/YMWrdua9V21VITeDp3zvwAN9Zg3zQTu4FmzfszZMgIzJ8/Bz//PF31OvhtYdrD/owq6UFBCCHmOEcaAdEEuwBzSMg92SeFYidUake142PfYecXHnd2akf1cCZyg0iGEw7pjCdf30KatkspRweecuUy1GkQ+0zw9xdzocgvUMz44YcfjY+tDY4ULVoMAHD27H9o1645KlUypfKLvfeNG9fBoUP7La53zZoVitsi9X1hj2gzYYKyIAQb/6R9+/ZtkvMq2a/sDDRb+PffXcbHarowv3v3Fvfu3QUgb7RFJpi5fv0alCtXTHJU0MDAIM2yIvgZTww1xXhNI3Jqi10LJzRUvGsIE7Q1F2jKk8ef87xXry9RrZohmFugQEEAQMWKygvoS9mxY7vxMfMdWLRonuT848ePBmB+MAH2jakePb6SnI8dgDt//qrgdWtqOM6Z86vqZe3l0KH9qFq1HL76qpuq5dlduDZuXGd8rOSGA3/EVeHr3DpSYo+tIWegGVdXF87fFBUlbzAKW1ATeNLqfFeMpcCSNce7iROnICwsGv36DVS9Dinu7u7w9s4OFxcXRaNXOlMGFyHE+VDgKQNhX9SMHTsSy5cvFp2Pf7IolpKv5sdbDHsEplq1xEel+eabbzXZlhbYJ2vs+gzpjZpR7aQynvLmLYPevXeKLWI3cgJPI0eOsdn2mew3sZNEfnYh85w/lDbjk08+w8qVf+DiRfOj3cgxePBwAKaC+OzPr9R7v23bZtHpbGqKF0u9R+whqGvXVl8TxlYBCXbdI1s4dOiA8bGPj4+qdTRoUEv2hSS7a8e7d+/Qvn0L0fm8vLxkBSHlkAo8qcno0zLgz87mZdqSlpaG336bITo/8xnmf6dz5zYF0JiujGzMby9TY0mrTEbANEIaYNq37LpharCDoQ0aNJKcz8vLVNiaCXKzWRPc+PXXX1QvyxzvbI2pN3bwoLrvCfuYeP26qaucsq7jlgIXpsdix3xrAwHmsueZmkVNmzbnBNkc29XOtA8mT7Y82AXA/Ru//PJLzdtkjrMGalxcXHDz5n08evQKmTPLG32XEEIsocBTBsK/MzVzpviJHf/kZOHCeSLr0ibwxL6r2bGjeM0PqUKuzPDp9sT+u93c0k9Baz7TRbr8rhJSy0yZEgw/P+2H6lZCzig5/fp9hxcv3qnqhmGpSC5zISl2ocX/rljKanFxcUH79p04GYpqmbtIlwo8yblYzJpVWPfNEqmLKfb+qFWrtuL1Mpz1BN2S48ePGh9bU3y9d295I3/xj1sREdIZXVodY6XeGzUBGC2DNmzsjM5168SH9eYXsGf07TvA+FiqnklcXJzxMX+UTLX0ej3nJtDhw4cBGGojWYM9GqS5/W1pKHhH1QNMSvpgeSYNWDsqLztbKTnZ1GYlQXTLGTPcrnYmtq/xtGnTNsyePR8jR45xmjqMzHmwr29h9OjRV9Yy7ADrsmXLUKJESc3aIxWUNzfNWXh4eHD2jRzOWCOUEOI8nOOXgmiCPww1+wfg4cP7GDZsIB4/fiTrh0HtqHbmSGVESNWrcMSJDPvvTs9d7ZiTGfknzi4qlrEfORlPbm7uqruuiRXYZ+8H5rMglrHC31/MhWKLFq0E80rVcZHj0KET6N69B86du4w5cxbg0aOXZr8jlt5HdlFfpoYVYMiAFNsfllSrVl10eps27QEYhmK25jvtLBc21siRI4fqZffskZd1qCRwU61aDbXN4ZC6eFKTNapFQJbBDaxbPr5JZTzNnDnN+DhLliyiy7IDT1rduHn8+BFn9EatAlrsfcDOkFu4cBlnPv55wP79R9G4caAxk8xRvxWnTh23y3b++++0VcuzvxfsfWXp96xYseKi67C0DbFzOzWBjRkzTKN5mutqV7hwEfTo8TV0Op3Du8Mz9HrDdy97dvn1w8qWNdU99PT0RJcuXTVrT/bspvpp6S3wRAghWkv/Z/IEgOEEkR94Ytd4GD16BDZtWo8uXTpwToBu3RLvUiOnX79SUj+wYifp//zzL+di2F7YbalZU312hqPJzXjiLsO8P853x0qns3yoYgcm7tx5bGZOeQ4fNnWRYi7OduzYI5hPmPFkeO7hIbxAtSabo3Llqpg3bxGKFSuBL7/8ClmzZpP8Tp09e0by4pe5NmEXlh4zZoLx8dOnT1C1qngQiY9dt00qm6lWrdo4ffoizpy5JGudUhwVeGJf+Gth9Ohxmq6PT0mwR7t9Kv45LFCggOI1jRz5vbWNMQoLCzU+ZrJPzN14MRUg53532J+BTp0+RcOGTcDH7qKs1U2LtLQ0q24CSQWG2H8f+5jUpcvnZtdXrVoNbNmyQ9YABbZkixtjtsCu88fuvpwzZ06zyzGjcgLWB57UYG4WAEB4eLjoPPyu4uxjCTtwZm/MZ1tOljTjq696oXr1GvjhhykAtM3ayZs3n/ExBZ4IIR87CjxlEM+ePTP7+qlTJ/4/31POyWiWLOJdLYoUKaq4DdOn/2T2demuOKaT+pcvwxEWFo169Rpg9OjxittgLfYJeenSwpGg0g95I9SJdbVLS3O+wNP9+/ctzsPuNmTpxJ6PXYeHwT7hZrovsWu9MPj7mAn4iAWZvvxSupCvGmLfqbCwMHToYMq26tHjG87rzHnu6dMnjdPYFwrHjh2RfWHp7e1tfGzujnepUqWRNWtWydflcFTgKX9+6c/S0aOHsHPndsnXxYwdO8Gmo3IpK1xs231apUo12fMyF2hqunlKYQdf2cXF2djHDSbAPX78aPj5eYt2A8+UKRO2bPlHMP3p06ecedjUBqKuX7+KypWrmJ2nUKEikq9JBWjev39vfMz+vMi9CGZnjwUHX8SgQf0QGhpqYSntvH371m7bssaFC+dULVe5chW0bt0OLVq0QsGC5gf2kAo8WRM8YR/LJ0wQr53Iz0xkL9OiRWvV27aWmsBT1qxZsW/fUQwfPgoAUL58BZu0Tew9sVQ8nhBCMhIKPGUQZ87IHw6WHXiSqjXg7e2jaPv16tXA3LnmCznKqQHDPonKlMlU0NDSSW1iYqKcZlrEbouzpI6rwexruV0h2MPoOmPG061bNyzOY+4i2t3dHa1bt1O0TfZnoVs36YKjwuLihuXEuv1pfSdYPPDE/a7wuwcy5767dpkuntndbQ4fPiB5wcquheXm5obMmdkX7bYtxu/IO8NS2WOff/4J+vT5Gq9fm4at1+v1WLFiCc6etd0Q3YBhKG0xSvaTVgXbpbappC2mC0bbnJYw6+Vf/N2+/Qi+vr6YPHkqZzAMAKhZU3x0OldXV0Gtp+PHjxgfM9+FDh06A+COZKnEvXt3jN3aSpcuIzrPsmWrJJeX+h7Pnz/H+FjN/mYH8Vq1aootW/7EyJHCoutaaN68pWDalCkTROZ0PkeOHJI1365d3BsfvXv3w9q1G7F+/WaL748tutqxM4yjo98LXmdGb+Rvp2TJUsiVKxeKFy+heJtaYY4jLi7qz99at26L2bPn4+hRbY/hYvuF//5QBhQhJCOjwFMGwb6DaQn75MTV1RXt2nUUzJMrVy7Z61uzZiXu3w+RPf+PP3KLnrMv0Nk/uuzAz19/bZBc36JF81GokB8OHNgnuw1SUlPl12Fgs6Z2iy2o62qnfCQ8e7H2YvSnn6Yr7rrJ7l5TqVJlyfn4QzEzn8N372x/V17sJJX/ue3Z8xvBPHzsgtQJCQmSF6zLlpmKMut0Ok4XPVsVhWbI/QysXPmH6m3UqFELf/0lzGDavXuHYBo7GBUZGYmYmGikpqbiyJGDmDBhDCfrTExQkPhoc3INHDhEdPqJE0dFp7M1a9YcgHPVzWKOO7Zqk1SNp6xZs+LevacYOHAILl8OFizHjFTH5+XFzeC7ffuW8THzNyxevALHjv2naLhzdnc3FxcX43cxT548ovOzu2Xx/fPPNtHp7C5gaogF8ZSMhBkRId59a9iwUYJpY8ZMVNi69KdoUW6GuZJzD1tnPIlhl3FgO3nyPK5du6e61qIWmBs/SjKe+FxcXNCjx9eoUKGiJm3av/8olixZKfpd5f+GU3FuQkhG5jxnncQq7FFqLGF3DXJ1dcUXX/QQzGMpvZttzBjxO+9S/P39Oc9z5jQFudgnPOwL2WnTpO8Y//ij4cS0Vy/rh8FlLia5GUCWXbx4HatXb8CzZ+KF0u1PeaFwdsZTtmyG96Rnz9nSC9iRtRej5cqVR+vWbY3Py5Sx3I2S3QXUXFBl797dotP53ffYQRutiO0XflvZxU2lsJe5dOmCZODJx8eXs232d9nWgSe530exQLpce/ceRmBgM8H0vn2FwTt2YPLu3dsoXrwA8ub1xePHj4zT+XX32KzNqPT1FQ92v3r1SnQ627Rpv2rSBoYWd+mZY6+9M54sqVZNvNvp27fcYz03k9iwP9zd3VG+fAVF+4c9gt6xY0eM+0VNRuHYsSMVLyOP8PdFyfe/enXxC/qxY4VBpjx5/HH+/FVlzUt3rPn+WMp4Ur5GS581qfNNnU7n8EFZ4uMNN2Hfv3/p0HawVatWA5988pnoaxktw4kCZ4QQcyjwlEHcunXL8kz/xz9BFutuYcvinfzaAMzIMX5+3Du6/AsQS93ttCgCzNwtU3oRnS2bN9q2ba/Z8OTWUprxxP4c6PV65MplCDzmzl3EBq1TTuxi1FIhXLZatQJQuHAR/PLLr6hbtz4OHz5lcZnkZNN3wNzFcHj4O9HpAwZwu54w3W60JPbd5QcT+J9lsRND/oUGO+jGxh7Ry9VVJ5mhaAtSJ+j844nSE3m5o6idP8+t18LuSte/f2/jY3b3mpgY6VpO1gTIzJEzMETu3Iai8J06fQrAUIPLGtoEngy/S7b6HNl61M7ChQsbH1sTPPP3z2t8fOXKZbM14xhitecAdaPgHT9+1uI8YkG8u3fvyN6GWMZMpUpV4Orqio4ducdJPz8/FC1aDN98863s9dtCQkKCrPnUXHhb8/1xRMaTMztyZAUA4M0b+efEjsQ/VmS0QBQhhLBR4CmD2Lx5s+x5+V3txE4ybBl4khrCm1+bhv+DPHr0cJu1iWG6u5x+T7wA+d3mxIYb1+vTVBXotCWx92P27Pmyl2c+S99+2x87duyV1RWAHXxhnwyOG/cDp+4Iv/5PpUpVAAANGjQ0TtuxY69NMjnETlKFJ7KWt8u/qOV3HxTj6urKqfFk625bUuvPndsPkyb9DACYNet3xeuV2y2kXbvmnOdSQaWjRw8bH5u7+GvUKFDWdsVMnDhF8jVL7/eAAYONBbwrVqyEK1du48gR64aN1wJzrLJd4EldxpNcuXObbpz4+YkHguTgv3/Mb7FY4Inp4n3hwjXV2+MrW7acxXlsEcRbtWodAOC778S7kH7/vf0HG2GT2z1Rqh6cOR4emS3PJIH7G6BVjSfn+N1Xo3JlQxdmT09lA4w4DnW1I4R8PGzbN4I4JfbJolTgSc5dc1vjX2ju2yccyl5rzEmjVsXKHUVqBCczS3AuzNLSrK+ToKUaNWph/fq1nGkeHh7YtesAnj17IpnGzlBz8i11AT98uGG4dz8/w4hu/CAtu2vMkydv8Pr1SxQvXlLx9uWQE+yRMw8/+LJq1TKLy+h0rihbthy6dPlckK1oC1J/h6urKwYNGoovv+zJ6Qool9jxr23bDtizZ6fZ5eRcYJoL4LPragFAaOh7zgV9QkICihbNK7aoZGFxwPxF47lzl1GsGLfAbf78BSTnl0uLoKOti4uz921gYDMcPXpYVpBFrpMnjxsfZ8/uo3o9mTNzv4vMZ4hd8Jkxe/YCAICXl5fs9e/fv9fs63KOlcp/X8zbu/ewMfNQaiREJXUnHUlNMM7b23J3aCmU8cTl42Po/l22rPkae4QQQuyPMp4yuIsXz6NJk3qcaWlp3CwX8Ywn5XfttOaIk59r167YfZu2wJx0vnp1V/Yy3IwnJvvAOWLTNWrU4jxnAk0BAXXw2WfdNP+sFC5cBFOnTpY1r9Sodm5ubvD09LRZ0AkQv0jnX3Dw55Ez8pFUQWU2nc7Q1W7RouWYPPlnOc21ilRAghmyXE3QCRAPMPK7+yhpD5tUl0VAmMHCfg9cXV3h5eWFU6cuWNwGn7nvAj/opBUtuofYOuOJ3T2MyUq7c+e2Zus/efKYJuvhB62Y44nYsdjX1/SZr1u3vqz19+wpv4syo2XLNpznzL6MipJfW1JKmzbtBcf39ExNxpM1LI1qp6Z+lDMNOqCUrQPYtkZd7QghGVn6PDIT2Tp0aCUYip5f40ksq8WWXe3kcsTIKOaKmKcnT578J2s+8a52erx8aajX4erqHIEn/smYnM+Gkov2c+eucLaj5G6xdMaT7QOnrq7Ck1T24AGGebiH+d27d6i6G850hWFEREQoXoc1bHVCPmKEIYOtc+dPjdPq1WsoNbtR6dKWC9T/+edGydfkBHVLly4jmNayZWuzy0h97goVKiw63VmYBnawbcYT//uhVuPG6rtKKsGu8cTP+mEXcv755+k2a0OxYsU5z5l9KbfuERv/2FO0aDFVbXLWLkn2HhXWcuDp48LsfxeX9Jm1ld7fw/TefkKIbVHgKYMTCyDxfxjErue07mpnqSuUmDx5/C3O8/59lIrWSOMPkZ1eMXf95GIXF2cvGxHxQtN2qcX/zLq7Ww48lS5dBkuWrMS2bbsszlusWHGEhUXjwAFD1oKSi4dTp05wnt+/HwLAPt0UxYIxTJFmhtid3yNHDiraTvXqNQTFsO19gmmrO9gdOnTG5cu3sHjxSuO0nDnF64Owjzdy/v4lSxYYu3PxAxVyA5MXL17nPJ8zZ6HZ+aWOYd9800fW9tQwFxSUGwC2RcB29eoNAIB+/QaKFsSuXl283qCUatWqGx8fP35UgxZaxmQfu7m5oXRpbhF4dgDe3z+fzdrAH6mMCXgnJsoLPLHPQ/iDgPTo8bWqNl24cF7VcmrJzWRS+ttrLVt0tUvPnK0+JSGEEBMKPH2Ebty4ynl+756wO1Zo6BtNt1m2LHdIavYJvDXkFvyUyxlqWzkKcwKbmmq6MPjwQfkdbVvgB4IyZZI3ZPMnn3yGhg0by94Oc3GqJPB0/fpV0elXrwbLXodaYsEYfrBZbJ7u3bvIXmdYWDT27bPPRbY5tsqEAYACBQrKCmwtXmwqaC/nwu7Dhw/GwRTq12/AeY3d1c5c9kzhwkWMBesBIGtW88HxHj2+Ep1esqTtunyaS0YTy9oS23fMd07LAGPbtu1x794T/PTTL5waT0zXsW7deiha34oVf2jWNrlMNZ7ccObMGc5r7AA8M1KhLfDrSzH7ctOmDRaXDQm5h0KF/PDzz4auy8HBFzmvi2U8yblR9ejRA4vzaElq9FK+M2eEhfqZkXvlGDZslOx5AcsZTx9b1y29Pn0Hnj6294sQ8nGhwNNH6PBhbraD2J28VauWa7pN/sXErl0H0L//IKvX6+HhYXkmBZyhi6EW5J+8sLvaCTOenKXGE//vkZPxpG47ygNPv/46V3R6XFycJm0yRywYw/8My/0sDBo0DADQtWt3q9tlC/au2bFr1wHBtGvXrhofv3v3VtZ6mItBfvvZmT358uU3u469ew01idzc3Cx2My1TRrxgdvPmjiu227t3X9SrZwq88b9fer3euJ/Eimhbw9c3x/+7lDMZT6baW/xMnlKlSguWZytYsJCmbZPDVDNOh6lTp3Je47f/1asI/PDDT5q3Qfg7YDimSI3syNaz5+dISUnBggWG4+S2bVssLjNq1BgAhiL/bA0aNDY+XrRI+QiWSkRHv+c8v3RJXubelCkTBNMuXbooMifX69eRuHz5FsaPnySvgf/niIynkiVL2Wzd1jJ1taPLG0IIcTZ0ZP4I8esySJ2grFmzEn5+3rIKDTNWrvwDz58LL8j4JyqZMmVCw4aNZK9XypMnj61eB1tGCTzpdPIyghiGrnaGE9h790x31Z2lxhP/or19+4423Y6cwFOdOoai/cyQ5nz2qPEk3tVO2Wc4a9ZsAAwX6ID9a5TIZe87wQEBdVChQiXONKYoNQBMmDBa1npMF0Lc9rOfM/teSqZMmfDo0Ss8ePDCYgCuYMFCmD79N8yePd/sfFqy9N5Mnz4La9ea6l39/vtszg0P9mfOVt8bpolpaWn48EE88LRnj7IuqPZgynjSoVevXpzX+O13c3PD4MHDrN5m3rzcbnv8YKfYZ9DT0zCyXnT0e7x69dI4/dGjh5z51q9fY3H7xYuXxOPHrwV15cqVMwVVQ0LuWVyPNZ49e8Z5XqFCRVnL8f/eDx8+cAaqqFixsuhyOp0OBQoUVNhKfuDJ/OtaOXnSvt0clWBunKWfGk8Zq0skZWwRQsyhwNNHiH9iL1V0dswYw5Dd1aqVl11LqX37TsicObNgemBgM8E0ORkMK1asNfv67NkzZbVLLqnaLulN2bLmCxCLYe4Q3rtnKkyuNIBlK/zPqKXMBLWUBJ6Y75FU7Y82bdpr1zAJYt8hpaMqzZljCFAwXb/YyzuiwL8UR4xSNHy4sNsLk8km1kVZDBPYN3dCLifYkjVrVnh6esraZu/e/VTXzrEV9vs3Y8ZU9O/f2/g8Pj5OdD4tMcc3vV4vmfHk4+OLsLBohIVZzuSRIhVYUItdXJxPzvfz+fNnFufh4++XTJm4v+lin+X4+DisXLkUJUoURJUqZfH69SvF22Xz8vISbMeedYv4I/ZdvKgu2ML/LVHalc4SR2Q8OWLEYbmoxhMhhDgvCjxlAHK7fDCYmiOMGjVqWlymZEnruhiInajIOTHo0MH8sOZaZyh1795T0/U5SpYsPgAsB47ER7UznSj7+tquYK0Swjvuth5y3XLg6fz5swCEQ7Iz+9Hb21vj1gmJXaQrHWmK6YLFdC3Ztm2z8bXKlata0TptsUfw0/riXkrNmrUF09asWSkypzSmpo25rh9iwfr0RM5dbv7fv3PnduPjY8eOGB/b6rvNrvHEFLh2c5M+Pv73n7oabTduXFO1nBRT0XU32YMsfPmlqc7XtGlTFG+TyYJkFChQgPNcKjg4frwpC3DAgG8Vb9cSe2ZT8AunT5w4VpP1Vq1aTZP1MKjGE1d6r/GU3ovCp/f2E0JsiwJPGcDPP/+oaP6kpCQAQLlyFQA4bvQt/smrmosvpdkdligpAurMTHf35XabchFdpmRJ4YW3MxC7+68F5jMp53PFXLzOmzfLOI1dq8YeNSbEvlf//LNNMM1c8Womi2btWmFApV27DoJpjsL+W22V8cbn759XMC0hQTiggVTWKAA8eHAfgPh71bfvABQqVAR9+vS3opXOwPLFrbksCXZWiK0ynkzr1SM5+QMA84MUlChREkFBLYzPx46daJN2iWHX/GJurri5uQk+Q1Ltb9q0ufHx6dOnjI8/fPgga/tLl67iPG/QgNstXk4wQ+y3lH9R2qPHN7Law8iSRV7GnxYSE5M0WQ//b9b6t0s640nTzaQbpq52dHlDCCHOho7MGcD69WsVzZ+YmAjAdAIk90SfWU4NOYEncxfHUth1HurXb6i8YTx//2258Gl6wAQT09JSZd+BYmcE8Kc5G9sFnph9oOysPTU1Ffv2/cvpXmKP7ghi392IiAjBtPr11dVTCwioq2o5W2BfSLCD1L169bHpdsuXt1zb5dmzpxbnEfsuTZ06ExcvXoOPj6+qtllSrFhxALbPqJJznDD3O8MO9NquxpPp+Hb16pX/Pzb/PZ8zZ6HxMb8OV6FCRbRtIMv69aasQ3bgid/VUirjib2vw8JCjY9jYmI4833zjXhWEr8mI/+9U/u7wC/QPWPGLIk5xQ0f/r2q7aqRlKT+fIeN//trywE7bJnxxGS/du4sPSKqMzCNjpk+M54IISQjo8DTR4g5oXJ3VxZ42rRpvabt4G/3wIF9ovMNHjxcch3sC31nDZI4AruLHXuUOiHTiWp0tGG46NTUZFs1SzO2y4pgAnbKCmznzeuLr77qhipVyhqnaT06lxixu7pibZfz3RDrdiS2HJMF0qXL53KaqBn2e86+4LZ1gG/jRm2C0VKfWVsetzZs2II2bdobR8WzlfQQeDJ1ozUd8yzV7cmTJw9KlCgJQDjCGlMnyhaYGku5cuUyDhag07kie/bsnPmkajzJrY3Er90ktTz/udzjL3+7/IL8/FpSlmTJkkXR/NZgMsOtJeweqX3gyfT+2K7GU9eu3XDr1kMsWaKsq7G9pb/i4oQQ8vGgwNNHiAk8MXfe5J5ExsbGmH1daTBA7vx9+35nfPz06RPJ+U6dOqFo+xmZq6vphF5OIMnFxQXnz++0ZZM0ZauLdSXFxeWuy5bE9kPWrFllL8++kJNbSHzJkpVYvnwNfv11ruztaIG9P93c7HdRwe72BEgHyC3RuvaPHCVKlMSaNRtsXhPL2sAT+yLZVtmMYhmdefLksbjcqVMX8Pjxa+TOnZszXW6hdzXYbWXXeOKTCtKx66EBwLt3hpsKFy6c40wfMmSE2e2bnotnPBUtWkx0ecbjx9wR3phMM63Ysp4MP8O7Ro1aFpcR66LNbyMz+p+WTPUZtct44g+O4eLigty5czv9DT4qLk4IIc6LAk8fIaZ2AXO3Ue4dZksX4926fSk6Xaq7jtw++Oz2hYaGmpmTMNgZT+khg8lZMBfH7FG2GjVqonJd9uhqJ7wIqFu3vmCa1MVC9uw+xsdv34bJ2qa3d3Z07PgJvLy0v4Ayh/035Mnjb9dts12/flXVcn/9tUnbhqQz5gJP7K5dtg4qsy/O+VlMYnQ6nehnXSpoowV2ICElRXpUO6l9xd/XT548AsCt47Zx4xZBME1qvVKBqNRU8+cE9+/fN/u6tWwZeOJnPDVtGmRxmXPn/hOZym2jLUYKNRd4UqtWrQDeNtLH5UJ6DzxRcW5CSEaWPn5JiGw+Pj4W52FGa1Ga8WSp4LJU2rxUwErsolkMu8sS0+2AmMcOPJnrEkInOVxi34Wff56hal2OqvGk5K43u2CyWA03Z7q7zf5bmZH4AOdq48dK3qh20vMwn9kiRYpo1STJ7bN/x6S6msnh7Z1ddPrEiVNUr5PBDiQwv3lKMsH4+7pNmyDo9XrjgAgAULhwUdXrM2VkmT8nmDfvN9nbUEOLzFQp/BpPcgacWLx4vmBaXJxwMAKtiQWerP1t37yZGyi3RwavFpjBUdJLoCyjoXNKQog5dGTOYIoXL2FxHmZkGyagI/fCLSIi3Ozr7CGc2ZgRhPjknsiwL+CZQqvEPFdXHetCS07GE128A+KfSbU1ORwVeLp3745gmtR3vHv3HsbHrVq11a5hNsDtame7Ar1i2rfvZNftpTfWBv9MBYFtd0piGrWT3a1P/XdUKuihRaF45qaMXm/6zVNSlFrsojs1NRWnT580PlcyMqRUcXFLgZ/g4EuSr5UtW0729qXYs6udpSAbALx//14w7flzywMPWMsWXe1u377Jea71CMK2lz7PaehGCiEkI6PAUwbj4WG5+CZz11PpD9yKFUtFpzOZTrlz+4m+npRkXeCJPR8FnuRjsp4oS0w+sc+k2junjqrxtGzZYsE0OcGzzz//QjAtVy7xrjiOwP5b7VG4nW3IENMAB66urqouePv2HaBlk5yKms/6V1/1Nj5mRpezbeBJ+F2xZoQxJrOCT4uuVOzAjinwJD9IJrYfExLUZ94Ii4sLs8eUEusSrJRtM564Xe3mzLGcvSX2GbNHBoh44Enb7c6fP0fT9RED/ueDMoYIIRkZBZ4yGDnDDR86tB+AdndWLN2RLVSosOh0/slx1qzZROdjd4dIL+nezsDV1fB+mMt4opMcLvEgk7p95KiMJzFS9dfYqlWrLpjGL6ztSOz3hn3ssscd4kqVqhgf9+s3UNUFd82alosTp1ceHh6KlylQoIDxMRPEseXxXWzd1mTO1akjHjjRJhvPFEhgMm2UZGeJfSeOHDmkujVSGU/WBJ4KFCikellGbGy01ev4H3v3HeZEubYB/E7ZLLssyy5VQHqR3lSKNBFBBREEEY+oYKeoWLCjRxQLx4YFsBcEPxQLFsACSFFAKSoqVXoHaQtsTTLfH3EmkzZpM5mZzP27Li5mk0ny5smUd555SyTBXe1iEa678t9/azvOFaBNi6dg8hmEjYx1GiIi4zLNVfyCBQswZMgQtG/fHueddx5uu+02bNu2LWS9JUuWYODAgWjVqhV69+6NmTNn6lBa/ZxxRo2o6xw7dgwAsGTJD0l/ntfrlU70kSrGzZuHb1IfXJm95ZaRYdeT30GuXLlKxLLEMr6VlYiDa8ZSEWPzbp9wF6eRBtBVmuXIZrOlJKaxtsbKyamAmTM/Vlwn3qnNU00+Jpwe43cMGnQFAKBmzZoJXXCn8z6WSMJI3lpFbIW7efNm1coULNyYgskkiapUqYLNm3eGDHSvRvJMnkgQZ2tNtsVTQUHiSZrQFk/i7J+JJ55uvPGWhF8r+uij95N+j0iCWzzF4vffQ2ftE4c20JIWYzyZnVmOt2YpJxGRGkyReFq+fDluu+021K9fH6+88goeeeQRbN++Hddffz1OnTolrffrr79i9OjRaN68Od58801cfvnlmDhxImbPnq1j6VMrnpNYLN3W3njjXcXnT506KS1HqsSPGHFT2MeDLx6VLuTFhJpSRVfsrhH6uBeffvpx2ERlOhPjm8zFgdWEuziN1J1jwIDI4/6kqtIfz/4e7YJYi9mW1CQvfypak4V+vu8zvV4hoS6/6dxaM5GLp7lzv5L2kw8+UD7PqCF8V7vktqO8vPyQ44Aa26Z/Bj4vjhzxja04d+7Xcb9ebty4sUmXRxTrGE9KEmklBwCjRt0uLa9YsSThz48mXOulRMjrRfXqxT6gezxS0eLJLMyWcEuXrnZit/xYZn8kIusyRU147ty5qFmzJiZNmoQuXbrgkksuwdNPP40DBw5gzZo10npTpkxB8+bN8dRTT6FTp04YPXo0rrjiCrz00kuajgWgp8JCbWdMycnJUXz+1ltvkJbl09fKBw6N1AoruDLbq1efiJ8jVuaVWhpE+o1nz56Fm2++AQ0bNoz42nTkb/GktO2bs5KjlXAXbBUrhp+9KtUDXIcTTzIjWiuhjAxjJ57kF1CB3zs1F1b+Vh7ehJK56Zx4SuS7rVv3G7788nMAwK+/rlW7SCHCj9+W/LYTfMNE7RZPom3btsb9erVEmtUuUmtQLfXocb60rGXiKZEWT3K1a/u6EmZl+cfd/O9/Jyb1npFo0eIpO7t8Uq8na1m4cBkmT56Ce+99UO+iEJGBmaIm7Ha7Ub58+YDKT4UKgeMBlZaWYuXKlejXr1/A4/3798fhw4exfv36lJQ11YqKigL+VntMFnkyKZz9+/dLy/IL8VhmgZJX0MuVK6dYWU4m8fTzzyuilkXUsWNnAMDTTz8X82uMKp4WT1a7KxpJuNYKkROnqW91E1qG2A/hwesGz2Jn/K529rDLqf58r9ffCiWSihXzMHjwlWFfn44S7fq4dKl2iYNgwce4/PzkZ58DgB49egb8rcZxQSyr/Pwez80ztbe10MST7/31mOksmQHhRYIg4Ntvp+DPPxdFXCeRMZ7kxJiNHOkfRD8zU6vkvvotniZNej7g7379LkvoffRjzjqNWetiNWrUxNVXX5twS0YisgZT1ISvuOIKbNu2DR988AEKCgqwZ88eTJo0CQ0bNkTnzr5Ewa5du1BWVoYGDRoEvLZRo0YAgK1bY79baCZud+DA0eXLJ3aX6osv5uPqq6/FTz8FTn8crdtAaan/rqB83dtuuxMAUKvWmcEvkRw6dFBajnayFSvSwXdY5TPpFRaeDvvanTt3SMvRKsrZ2dkAQhObZiTvrkGxiecCWo/uXsGS6WoX7W+jkZdPj8q5fH+K1tWuYsW8MAkJY8c3GYnuC2JSPFJ3bDUFx1+NBAYQ2vJRjd853HvE04Il0nGsRYtWCZcp8P3FREfqzy2ZmZnRV4pi/folmDHjPkya1B8AUFJSiN9//xZlZf5kU7TkcjThjlFNmjRN6j0j8R+b1GvBfOLE8YC/b7rpVtXeW1vmbsVt1q52RESx0L+vSAzOPfdcvPrqq7jnnnswcaKvqXKjRo3wzjvvSOOSnDhxAgCQm5sb8Frxb/H5RDmdxrxokNdt7rprHJxOO5YvX4Xhw6/Gli3RZ1MRv1e3bt3QrVs3HDhwIOB5l8sZdn2RfMaWrKxM2XpZOHToOBwOR8SLxMJC//hcgiAoxlis3Nts3qD1Ak/SBw7sxZln1g54TBycFQB++GEBLrzwooifI570MzKchv3No3E6fRVR8eLDZlOafl74d53Q3yg7Ow8Ohx0Oh2/sI6fTDgP0LgOg3f4YvL2LnyXGTx5Hl0u5hVAqtp+MjOgX/GI5gtd1OOxRyxjPdwgXIzXJL8blExmI26bW/MkVAYKgnMDOz8/D8ePHgl6vbXz0JP894v0tnE476tXzzXzarVs3zeITPPmFWttNcCuWjAxH0u8bbqKOyy4bEGa98J8T6fF27drjr7/+wLhx98dVxuB1xfIl0+Ip0Rh16tQp4G+73Q6HQ5DOU77HbFC6r3rkyE5p2WYDXn/9Jqxa9QW6dbseAwZMg9Npx+rVvyRV5nDJ2AYNtB3jyW4PLaN8O4/nGHTkyD8Bf2dnZ2lynHU67QG/YbL8sbDHXWfR4xgdPK6kzZaa81mi0vk8RkTaM8hlpLK1a9fi3nvvxeDBg3HBBRfg1KlTeO2113DzzTfj//7v/wLGIYqU5EjmDrndbkN+vjH7u5886U/29OnTC/n55dG58zno06dPxMSTy+VCaWkpmjVrFvK9PJ7A8Wzy8nKC/s6OGMt4YyR/b4/Ho/j6jAzfppqd7QpYL7gsGRnK5XA6lX/L/fv3AgAqVMgy7G8ejd0OZGf7K77lyjmRkxO++bN4MV+uXGgXgHr1WiEnpxxsNqC0FMjLy0SE4Y5STqvfJisrtOYr/6zc3CzZcrbie6Vi+8nPVx6DTV6OihUDy5OVlRlSxvfeew8jRowAAIwfPz6h7yCPkZoyM/2JPnm5srJcKYl1Vpbr33I4kZMTvtXFbbfdhpUrV2LGjBk455xzAp7LyfHFRav46EmMDRDfdu9yOZCfXx7ly/viabPZNNx+QmdmU2O7yc4OrEZVrFg+6fctLAx9/fDh14Y8Fulz8vLCP75q1UoAvm0xnjIGryv+3skkntTaZ7OzM1G+PCBv7J2drdwqSp6EHzeuNQ4c8LWIX7bsXfznP+8gLy/86+Mpc7jkoVbHKTF5kZvr/10zM8U6U+hxPpZ9TL5PA0DFitmalD8vrzyysxHyGyZKjHtGhhN5eeUTqrOk8hgdvK06HOocl7SWjucxItKeKRJPEydORKdOnfDwww9Lj5199tno3r07Zs+ejeuvv14aADi4ZZM4hXBwS6h4eL0CCgq0HcQ7UceO+VsNFRaW4tgxX3ezsrLIFcKKFSvi8OHD6NTpPGl90cmTgeMaFBYGduXbv/9IwGCZgWUJ39UtkqIif3eVsrIyxddv2LABAPDbb3+gbVv/YK7B414cPXpS8X28Xpvi85s2bQIALFiwCBdfbLYxDXwKCoDCQifEO76nTxfh1Knw41WI8SspKQt5zu0uw6lTxSgsBAoLbTh+3A2jjNEf77YWK3Fa9+DPcjjsyM3NQkFBkdTds7hYubuVVmWUKygoirqOWI7TpwMHyx048IqQMvbvPxj33rsRDRo0xNCh/4nrO4SLkZrcbv97Hj/uPx4XFysfO9QiHlNPny4OOO7K9ezZB48//gyA0MGJi4t925ZW8dFTaan/fBPPb1FS4saxY6dx8qRvO7bb7ZrFJ3g8REEQVNlugpMvp0+XJv2+J06E7tdFReGPTeGcOhV+YGzx/Pb666/jjjvGxVye4M8pKfEd+xKdtOXii/uqEvtzz+2MwsISuFwCBMGXgMnOzkRhYUnEWW4BoKSkVFoWk06iwsISHD8e/tgeT5nDdZnS7jjlSzwdP35a+gzxeFNU5N8e4zlGV6xYKeDvU6dKNCn/8eOnUVjolH7DZJWVuaX/jx8/HVedRetzWDinTwfWzdxuT0rOZ4nSI0Z6yM3NYqsuIg2YIvG0detWXHDBBQGPVapUCdWqVcOuXbsAAHXq1EFGRga2bduG7t27S+v9/fffAJD0jGbyix4jkScMBMFfTvkYD+3bn421a/2z/5WWiq+xhXwvpzP4Tl/gXWK32xsxFvHHKPS9oxk37i5cc8310t/BlbuSkjLF93G5MmP6nBUrlhv2N4/G7fZdEIjbgNvtiVhBECvn4Srp+fm14PF44fH4Ena+3167csdDq98mXCVV/lkej3z7V25FmYrtJ5ZKtVgOrzewvM2atQxbxnvvfSjgdfEKjJF65Mc0j8e/vXq9Qor2VV/83G5PwIWrXPPmraSyTJjwJB566D7pOUHwzwRm1mNLLOL5boIg/Htc8SVvbDabZvEJ3VdCz3+JCL5Ylp+HExVuvw7+HLvdHvFzlJIugG9SkHjKGLpu5MGsq1SpgvvvH497770z4vt17HheUjG6994H8eyzT6Nx4+bwer3weAT48n/iBACC4kWx0nNeb+Ttr6ioBEePHsXzzz+D4cNvRIsWLaXngmMRbpwtrfZ7seG3vH4mlsfrDf3cWPaxCy4InGVYq+Os2+0N+g2TI35vcT9MpM6SymN08L6qxvEjFdL9PEZE2jBFOrdmzZr466+/Ah47fPgwDh06hFq1fLO4uVwudOrUCfPnzw9Y7+uvv0bVqlXRvHnzlJU3leSDe3bp0lVals+sI086Af5WHeHGIAiekcLhcARMj5roHc5wOnU6L+7XBH9+cGUveLD1YJmZsc24YYQZy5KV7Kx2ffveqXaRDC+egYGDBxXWQzzlDb57V6lSZbWLoyn5NhppWUv79vm64W7atDFiF6PKlf0xrV8/cKKLdB5cPNFZ7fwXiZHHmlNL6Mxs6nyWb0wW/7FAjUkHwpUtnvJrva0pfXbDho1x6aWh41HJJVs+McbhWqjGIpZzYjirV/+Cu+++De+99zZ69gysv8jrJn379k/pBAj+wd799aFkB6kO3o7NOtua2TDMRJTOTFETHjZsGBYtWoTHH38cP/30E+bPn4+bb74Z2dnZuOwyf3eoMWPG4M8//8T48ePx888/Y9q0aZg9ezbGjh2btpV+8c5dXl5ewGwvSpXfsjLf3fpIMbnlllEB73P77XfJPk+9Ji+RuuzFIzTxpFy+WMekqFmzZsJlMgoxeZbozEP16rVRszimYLPZYq5gGyE5Gc9xLXhds017LB+EVY+LoG+/9d3U+OqrOdi/f1/U9YOTMel84ZZosiWViafg7V/Nz5InntSoa8SSeIr39Ym+VzjBAyLLOZ3OsOMbyVWtWjWpz1+0aAEAYPbs6Qm9/qef/i+h1x07dgx//fVn2OfkiacuXbqmtM4ZLvEU/Fy8gvfpaHUr4zD3rHCc1I6I0pn+t+xjMGzYMGRkZODDDz/E559/juzsbLRq1QqTJk1CtWrVpPXatWuHqVOn4oUXXsCcOXNwxhlnYPz48RgyZIiOpdeWWNmJZ0pn8S5hpLvUWVn+QZPtdgcyMvyD+iYzmKgWQhNPyuWL9U7nbbfdmWiRDCO2Fk+s5QSz2+0xbedKF9tqTVseTTwXFWZPvuvRyimSp556POo6wfFWulg3u2R/D/E8puU2qm1Sy38s0KrFk5qxqVcvudnVorW2crkCu+xXrlwZR44ckf5u1659Up//yy8rk3r91q2rFJ8vKQk/JiLgb/kYTH7OyMhwIVpXbDVp0eIpeHuLVrcyGr3PEbFK9nciIjITUySebDYbhg4diqFDh0Zdt0ePHujRo0cKSmUMYmUnuJIQy6B4YsunYF9++bnsfRwB76135SO4Uh98zt64cT3q16+P6tXPkB4rXz4Hp0/7BgOO1lXwjDNq4MCB/QEzJZrVwYObAQAnThyMum74Spo5Km5qizXx9Pvvvyq+Ryok0+LJbPTuaidXWBh9songY5XZ468k2e+WTi2eEu12KBcuSRlcXqUL1mjnuYcf/m9iBZPKEvk7Xn31tcjKysKwYddh5kxfi6QqVaoGJJ6MLlJsY415RkaG7l3tgp+LV3CL3tq1ayf0PkRERKL0rQlbhHiBHHqRE/2u6zvvvBn28e3bt0nLTqcTNptNen81u9rFo2LFPADAnXcGzsQTXNG67767MGzYlQGP9erVW1qOllDwJ/L070allg8+uDem9YK/s1nuGKot1hYL//zzT8TnUhW7eC741bggNgo9Ns3evS8CALRq1Samse5CWzylT/yDmaGrnVZjPAEI6FqmXVe7wL+TaSmRl5ef8Gt9ZYkcu9at2wIAXnzxVVx++WA0b94SXbt2D1inQYNGSX3+oEHJtWJv376f4vOR9u9y5YInXwn/GqfTmeL9PXLiKVHBNy/NUh9gCyIiIuNK35qwRYjj94S2eFIncSK+r3hHV69+/hdddAkAICenQsDj4SoZ69b9FvC3vMzRZvsRu6Wl00WiUosnefy0bBFgJrH+9kpdp1IVOyt1tdO7Bd4553QAALRt2w49evQMeX78+McC/rZSiyf5+ILxSGXiScv3dzjkg4trk3iKZ/uPdvGd7Lao9PrGjZtIy6+//i5++OEnLFjwXcA6yf4O55/vm+W4R4/eUdYMr3btlorPy29QycfCq1UrcqsfeZd2l8sV8h1T0Y1Uy6525qsPmKO8TJQRkZWkb03YIiK1eFIr8SS+j1ixdrvd2Lp1C4qKigAA11wzXJXPiWb16l8AAD//vCLg8VhO2vIKYawtntSKn3nY0qqVVzLkLYMmTHgq4npKFxKpqqPH04rJ7IkPvbvXifHzer3o2bNXyPNOZ0bA36WlgV2ZzXfhFrtrrhmBli1b4+67Y2tdGUw8jqdyNjY1fw/5e6nxHcK9R/BjyXS10zLxFMxms2Hnzh1JfV649wTUnWVXTl5ncDozUKVK1aifF9jVzhUSo8mTp6hcSr9UDC6ezscvIiJKDXNfiVDEQVnVqsCLlQ+xxdOPPy5F585no08f3zhatWqdCQC47robVPm8SLZt2woA+OabuQGPixUtpant5cmmaIOLi7MEqnHX2mzkSQwrVzLl+06bNm0jrhc8gK6cEbvaMfGkzud7vd6wF3hr164O+Ds4SZ5OXR2D5eTkYNGiH/HAA4/E9bpUt3iS7wNqftahQ/5WpVoNLi4+1rq1b7bRvn37R3y9fPtctWpdyPPJHgv0Pj+I5deqtYhYDwACx7lUunElTzzl5OSE3Hzo3v18Vcso5/891GvxpOXxSssbe2ZvQWT28hMRKUnfmrBF+BMl8Y/xdP31N0Vdx9/Vzvd+s2bNBABs2rQRgDzxlVhFNNkKbCyJp8Cudsp3SNNxjCdlkbraWTfxJE86Kl2g3XTTrRGfS1WSx0pd7fQeXFy8EBMEIexxRD4pA2CtMZ6SpUdXO60+S40LdqXE08cff4annvofXnopcgsa+cXrmWeGdg9LtozxbstKx8pkPl+ri3RxCAPfZ/nHuJQ/HkyerOrQoVNKu6qlosWTmnUC+UzJWtE7ORorJpqIyEpYEza5SC2e5JWGZ5+djO7dQ8ckqVOnXtT393c9c/77tzvs84leVCV/0hUTT5ErMvIKYbSudmKLqHTqaudyZUVdx1dJM0dFTWvybVkpAVmpUmWFd0lVi6d4Ek/qdgdKNb1bPMm72nFwcXXo2eJJK4mOdxUocuKpWrXquOmmkdKEG+HIT6t2ux1NmpwV8HyiN4qCyxKrpk2bJ/V5kT4/0a520covrycETq4SW4un7Oxs04/xpGVXu4wMl2rvRURE5sGasMlFSpTIW21Ur34GZs+egzvuuDtgnVgqEmJrIf/g4oEVr0iDm6daRoZSVzu3bNk6YzyVK5cLAOjb986Y1g9Mslj3Lpx8W1bqcqnUys6IXe3M3pXSSImnWC7qmHiKXaQbKGoL3G602YbUaM0RyxhPSuTbpzxxksh7hRPcYmrw4CtRp049PPhg+K6W06e/m9TnBZPvi4lYtmyG4vPB9YRYPk+sC4mxDm1VZq4WT1q22HK5tGzxZK66Cxs8EZGVRL5yIlOIZYwnh8MOm82Gf/45HLBOpIpEXl4ejh8/HvBYpFntxFni9LqoEita8lmFggWO8aRcUU3VBVAqtG8/AMuXfwCXq1zEdQIrqurdLTWzf/75R1pWSkAaIfGUaFe7dEo8pS7Wvv8jtXiK1t3ZjDHXmr5jPGn/GYlS6moXi+Djd/C2qPYYT9WqVcfq1aFjSYmOHPkn4nOJSLar3ZEjexSfDx4L0j/GkxdVqlQJOEeIgm9aBcco1V3t1G7xpCalFupqMcvx1sp1LSKyHvNfXVtcpBY68oqmWGn68MMPYnrPO+64R1r2J3bEpubBiSffBZheA+eK5VO6y7xy5XJpOVqLp1TNrpQK4jYQ7TsDvkpajRqNtC6S6ShtB0oV81RtP4kOLm6WSrmR+OMnhL1YCE5EXnhhnwivp2CpSzxp35JVje+QbOIpNzc34O/gWeWS3RaD6wHRqJ3EEOsb0SYLSVRwYtnf4smD0tIyxdeI6+qdePI/l9x7Rvo7GS6Xdl3tzJbIMVt5iYiSwZqwyUUaY+nYsaPS8pIli8O+NlI9QhxIHPCNVeB7LFKLp9S3EFqw4Fu89dZrAGJLPMlFa/HkvwAy/65ht/t+M6XKubzSc+ed0zUvk9koXaiG68Iify4V4tlOA8euMt/2nYpuUkqijfEkHitFlSpVCvt6CpWq84h8f9VqHzVCi6fmzVtg3LgH8PzzLwMATp06GfB8smWcNu2VuMq2a9fOpD4vmHzMpaKiE/jqq6ewf/9m1d4/+GaN+Hk33HAtCgpOhH1N8Das9+DiaiQ0tGpZqtRa2GqCfycmoogonbEmbHLB4wqInnvuGWn50KEDAIDbb78rYJ1IFYm2bc+Wls84owYA/RNPV1wxVCrP1VcPwUMP3Yc1a1aFtMgSRTp5x554Mn+LEDFp4vXGcnfahmrV6mpbIBOKdqc+UgXaiGM8pVPiSc9Z7bze8LPaPfHEM8GvCPgr2QGd01Nqu9rJx2wzcuIp2TGeAOC++x7CtdeOCPtcsjdWjh49GvB3qs+X4nHZ6/Xgq6/uw9dfP4n772+v2vtHavEUPFyBXPCMuMZp8ZT452rVNVXLFk9+PN4SERmN+a4+KECkFk/yipM4/lHwtMqRKiSdOnXG9OmzsHz5mpD3CL4TmGziqX79BjGtd+65HQEAZ599rvTYgQMHIrZ4+vvvLWHfR6nbWfCArGYn7x4Qi3Ro5aW2aImnSGOLGX2Mp1R0OVJbpGRTLF1J1fz8SC2egmcJDW3xwP0rmP+Ym/qudkZOPCXb4ikatRPP8ZTt+utvSvrzxASix+PFjh0rAajbUiR0cPHox8vgiVZC93+VChdW5MRTMrTqnq3lGE9mazB09dXXID8/X+9iEBGlBGvCJicO7q10gSw+F884Cxdf3BeNGjWW/hZbdgRXyJKd1S7Wyoz/DmfgBZ9Y0QquyERq2RTrdMjp0Dohlq528gHFzdgKRmtKs9oBkVs8GXGMJ3niw4yzNkZKPH388Ycp+Xz5gMbicS/c85H+Todktlb0GFxcK2okGM2WeIpHmzbtkn6PeMYvTETw/h3L8dI/0Yrvd0ptiyff/4FJl+QzMFptJ0qzEFtNpUqVsX79Nr2LQUSUErzSNLlILZ4yMzOlZXHskWQuhMRxn4Irev7PV2fK3mjryZMovgtAMfEUWJGJlHhSng453Vo8xd7VzmazsUVGGNFiEikxZfyudubbviMlnsLNMKUF+RhPR44cCXk+eFsoKysN+3oKxTGeAoUvW2oTT0rxCU4eRYvl8OE3Sss5OTlRPzsa8Xzvqw+o38TlwIF9AX/HEq/QWe30HeNJjc/VqsVTRob2Xe3MVIcz440gIqJEsCZscmKFPfjENWHCU9LytddeH3adeE7M0braJZq0iPWEG73FU+D7RE48xdbVLh0uEmNr8eTHxFOo6F3tIj1vvK52eoyLpK7wZS5fPvkL2Vj4Wzx5A8bQC35elJ/PwcWDtW0bmLDweLwoKDiRwjGetE88aTWrnZrbTyzvpdRt65ZbRgX8He07V67s3xfatk1+LCbxdwwec1It8+Z9Ji2XlbmjtnwFQutCwTHRcv832+Di2o7xZLK+dkE4uDgRpTPWhE1OTCoEV2pq1/aP5yTeYUymxZN8ME+5ZC8YNm3aGNN64vuHdvXzff7atWsCHpfPKFW9+hnSslKLJ/lz5rwwD+Rv8RRbKy9eGIeKlniKlKwzYoundNimRfLvMnjwlSn5THmLp3CCtxV5q1P5661szpz5Ab/Xl19+jkaNauPvv/8GkNoxnrT7DG0ST2rGJtm3ivcmljzuubm5yX04ItdH1NK37yBp+eTJgpj23dBZ7VI/uHi4pEsynys/v6nb4km7MZ6IiMi4WBM2uUgtnuSVhMhjPMXT1U6c1S448eP7P1VdJCK1eAoW6fFYBxdPh4tE/zgYsXa1M0dionLlyin7rGiJp0jbSaq6ssXX4sm/PGLEjZFXNKhI3T5q1qyZks+XDy4uzrIpF+1OdTocU5KVnZ2N1q3bhjz+f//3AQDOaqdE3cRTcmWM9yaW/DgabWbZ2D5f2zGegruCrVmzOuprxK61YjJM71nt1Gg5o90YT0w8ERFZEWvCJhc8roBo4cLvpWXxuWQqEZESP/7m5akZFNbjia3SunHjemlZXgFTen3gdzNHEkZJvF3tzMLlyoy+UhLkLTKi7TORnjd6Eu+GG27Ruwhxk4fUZrPhzTffw8CBgzBy5G0p+nz/xV2dOnVCnl+16ueYXm914cIgHqM5xlNkyZS3ceMmAX8nW8Z4X9+lS3dpuUIFNVo8yVsfqv87hps8IJqJEycA8I85F/p7cYwnkZZjPJm9qxrPE0SUzph4MrlIg4sfOHBAWhbvDiYzxlPgYJ5yqblgOHrUN5jvsmWL/Z+sUMF47723wz5urcHFxcp55BZPZqykpXIcmGhdc/bv3xf2caNvP2Yfz8tms2HAgEF44433pMkTtCbvahduv6lVq3bIY+Feb3Xh4qDHGE9a0ep3TqYVZcuWrYLeK7kyhrbmUV6/U6fOePbZyZg9+wtVWruIv6Ov/hP/Oaxu3TaKzyfSKmvZssUBf6dyVsvwLZ6Sf1/5NqfuGE/at3gy+jmYiMiKWBM2ObGiETq+iP+Okr/FU/KJp8iDi2t7kn/nnTdDHjt5siDi+iUlJdJyYIsnK3W1i6fFEytpIvlvH8ugsuEYsdKbnV1eWlZjZqlU03tw9MDEU+jzZ599ruLrzZ7sU0u4304cJDqVYzxp91nGG7Q8+NyffOIp/qTK8OE3oEePnkl9rkg+xlMss7YGc7myFJ8PTjz163dZ3J+hd1c7NT438LXqld/pZFe7SNKh7klEFIkz+ipkZA0aNILNZkPz5s0DHpc3ZRYvntWY1S54FplU3aneuvXvkMfuvHNMxPVLS0vDPq48q126Di6eXl3ttP5two2PFi8jVh7LlSuHBQuWQhCElLUSUpPeiSf/GE9C2Au8jAzl06kRtwk9KP12qeqyreVnGbGrndozrKWyG1k48vqIIMTfbSvaOTG4q120fTscvVs8qUG7rnbaJZ7M2IpbLitLOSlKRGRmrAmbXIcOHbFhw9949tlnAx6XT1cbaYynZFs8CYKQsrE54iW/wyuviFhphrfYBmA1TyXtmWeeh8vlwtSpoa3f1CTfLxLdDlKZGKlWrXrM67Zu3RZt2rSLvqIB6Z0MDtfdVy7RgegJKF8+/MyrarPqGE9qJ5703pblLZ6CW18VF5/G9OnjsGnTTxFfHy3xFFxPSOT76t3iSY0EjFatNLUc48nPXDcPX3nlNTRs2AgvvPCK3kUhItIMa8JpoFq16iGVGvkdJbHSlGi3Id9rQ8eJKi4ullXQjHWSHzToCtlfsXW1k1c29b7IVUM8Xe3M8H1vuOFm7NhxAJ07d9H0c+QXGYlOv57KeOp9EagHPbbX116bIi2Hu6gTW2FEkkiriXQULnapG+NJ+31FuzGeEn/f0CSI2mM8pbrFk3hTxRtyjP7kk6fxzTdTMHFin4ivj554CtxGE4lX8Gu0PE4rt3gy3uDiqRjjyWyGDr0aK1asRaNGjfUuChGRZqx3xWIR8jtKag4urnaLp+rVz0joddFEutsX6xhPZkjERCP+7oKQPl3txO1QS2p0tUvl9pMO22osUtFNSkmfPhdLy+KxYtiw6wAAHTt2Rvny5cO+TlSpUmXtCmdykaagV1tgkoItnhIVPNB5qvdHsUV3SUkxgn/H/ftDu+UHizYulPwmVJ069VRp8aTtDQJtWjyZcVY7M7XiJiKyGiae0lS4rnZHjhwJWCeRxJOcIAhJDy5es2bNmNYbPvzGuN534sT/Ssvsapdes9ppT43EU+q2n3TYVmOhd4JtwIBBAIC8vDxpv6lQIReHDhXgq6++VXztiy++qnv5jSxVg4unoqudEd9X6zGeUr1tiy26vV5PyHeJpZVqtFnr5GM82e22hOKVyjGexM/ScnBxs4zxJOLxlojIeKxxxWJB1apVk5bFynZWVuCAwokMLi4nCN6ku0gEN2mP/PnxbapHjx6N8HlKXe3Ss8VTunS1SxX5thbPBcf99z8sLbOrXfoR96eKFfNS1jUsHYVLDIiJgFSO8aQV7b6Dmomn6O81e/YXqFOnLn78cVXIc6lMqoQjfr7HEzrGk9jFXEk8YzzZbIklnlLZ4snf1c5fbrVbPKmJg4sTEVkTr1jSlNhCqEqVqlJrpRo1agSsE1+Lp/AXC/6udokmnpTvPMa7XjjyiojHE1uLp3S4oEzXWe20FjjGU+yHyAsuuFBaZlc79en9PcWEpPy4F2uZatSIrWWnFYTbp5JtORsrtnjyieW41qNHT6xe/QeaNDkrzPvpW3X0n9u8CE7IxdbiKfbEU4cOnUw5uLgan6vdGE+pGFyciIiMhomnNFWuXDkcOlSA9eu3So8lc7d3//59IY8JgoCCghMAEq+UXH65bxDws85qqrhe167dFZ/v1q1HxOdi7WqXqoufVBFbqSmNZ8G7g6ESvTiVvy6VA0mny/Yanb7fU7wIiyfx9H//9wkefvi/6Nmzl+blMwuli/hUjvFktv1GzcHFzd7VTikhEks9J1riSd5y6MknJyXY1U6bbmrhaDernTbfwelMxeDi5tq/iYisgIknC0lmcPFvvpkX8lhRUREWLPgu7veSGzlyDGbN+jTqGCktWrRUfH7atLcD/u7YsXPY9ZQGFxcHpTTbBUkkNpv8rnDUtbUtjInEc5Fx6aUDZK+TJ55Sd0fXKl3t9N4v/TNpeWJOPPXq1Qdjx96je9mNRCkxoH3iSZsL6VR04VOzxVOyLZb072rn/7zgBIuaLZ66deuB3NyKCc5qp2/iSY3P1qrFk7aThPBmGhGRUXF+ZwsJrjwlW5HYs2e3tOx2J9ady+l04oILekddL9rNu+zswPGr2rRpK3ttfIOLp8uFfCyDi1OoWC5c/Ov6txV5ZToVg6eKrJLU0Pt7yrv3cIynxCklacw6xlP58jlS61+tcHBxv8DfMbhyEL0ssSaexDpTpKEEBEGI+N3l9S2tt2uxCGZp8eRype78SERExpEeV9gUk2RaPIUjv9B2u8uSeq9oKlTIVXw++Lu88cY0DBs2JGQ95cHF07WrHcd4ikc8Fwnygcjl+1dquhL4pEuiNBq990t/VzsP0q11ZCopxcysYzwNGTIUgG88ILVUrVot4O9kyrt27ZqAv5M9Zuh9zEm2u2a07uf+we5tip+nlNzRp8WTuu+r3eDi2rcI5rGZiMh4rHHFQgCSq0TIZ+wSySvxpaWlCb93LKpXrx7QrSlYuErG999/i/379wVUxpS62qVbiyd/VzvOahePeFpFyO9qy5NQqRzjKV2212j03kYT6WpHocrKIt+kMOsYT48++gTeeut9zJjxkWrvOXfu9wF/J7Of//XXH6q9F6B/iyf5cTc4+RNb4ilyy+dTpw5JYzyJcYoUL6X3SXSSikSYraudloOLc9xKIiLjssYVCwFIrpvBlCkvhzymdrPuaN5554OIz0WqFO3Zs9vCg4uLiSd2tYuHPIEUTeDFhX//KioqUrVMStJle41G7+/p358EJp6SMG/eVxGfS2WLJzVlZWXhsssuR15evmrvWa9effTq5e+GrmZs1G7xZKyudtFF72oXeBMq2cSTWQcXT8UYT0wUERFZBxNPFpJMZfHUqZMhj7nd/oRGbANYq6t167bScqTv8t57gYOOx9LiKV0uJv1j0kT/zuQndlGMRaQxnnbv3qVqmWItA2lH7HYjb/FE8VOKXSrHeDLDYV6rC3+zt3hSLn9yYzzZbDZZVzv7v48Zu8WT+J3VbvEk/95atXjS7lhqgh2ciMhieMViIWrfpZQPKC6ffjhV5JW+SN9l27atARUbjyf64OLJzvhjFMl0tcvOztOiSKYQX1c7f9zkiaf27c9RtUxRSpHCz9KP3gnh8IOL61kic0p2fJ5kyFsz6r09xUKrxFOy7xV6jjRO4im2rnZK58TQxNM//xyO8D6R6xOB5xGtu5CK48/5y6P24OJqko/xpPZNS94UICIyrvS4wqaYqD24uLzyJjZN15r8Tllw4unaa0eErB9cwbRWV7vEBxcvLDyucmnMI57Ek/wCSN5Sas2aVaqWSUm6bK/R6P09AwcX99G7TGbUp88lEZ8z6xhPWlFrZrQbb7wl6H2T++6RZnlLFfkxOp4xnvbsWY9HH+2GkpLTEdex253SjTQx/p9++nHYdUtLS/79P3SMS/m2pnWLJ/GmR7hzvRHHeJKPgahHa3kiItIHE08WonblR97VLlV3mc45p4PsMwMrLM8/HzoOldOZETTGk3UGF4+lq10i42OkO/kFQzSBM9n5l3/8camqZVJihgtoNej9PcMNLm6V1mZq6t69R8TntE88mevYrtaF/xln1FCjOBK9u9ol+nmvvnodtm9fG2UtIaTFUyR//fUngPAD5qeydZ382OSX/Lldq9mK5bO+alV31Pt8QUREocxVC6OkJNPi6b77Hgp5TF7JSdVdq+XLfwz7mZG+S05OTlBXO6XEU3q1eLLb42nxlB7fWQ3yLnPRBM5qp83AxdGY7WI6UXrvl/7Bxb1pNx5cKjVo0AgDBw4K+1xqx3gy/m+nVjzU/q56Dy4uL0M8LZ5iacn7zz9bY0481ahRI2wZgl+r9XYt3iyR3wwUJfPbbNy4IeHXKgkc40ntuiNvphERGZU1rlgIQOi4DPFUSDp37hLymB6JJzl5JSvSdzl+/FjA30rlFOuOZrggiYVYGfV4OKtdPCpVqhTzupG62qVSumyv0ej9NcXjp7zFk1Vir7Yrr/xP2MdTO6ud8X87tZLZao9bqHeLJ0Aem8BEQ0lJobRcWloc9Kro5dy+/ScpGRItYaQ0xEAqB7IXW1fJ62RGHusoI8Pf4knpZiAREaUXfa6USBfJtHhq0aJlyGPyhIYeiaetW/+WliN9l19/XYvs7PLS37HMaqf3+BVqCTcmTTAjV071MnjwlfjhhwU477xuUdc9duyotBxPSyk1WSX5off3lB8/xQtOvctkVpEu6FM5xpMZqBUOtVvcGKnFU7CiIv8MvGVlRXC5ykl/x1JOm80ha/GkvL6/3hOuxVPqxngShavfGPEYJW/xpN2NMeN9byIiq2OLJwuRjzkAxFchycvLD3lMPkOc3gNEit8leBDVYEqJp3QbXNzf1S56xS5NvrIqMjIy8Prr72L48Buirvvll59Ly/olnnT5WB3oPbi4//PFZG66HCtSLVILHM5qF8ioXe30at0pF6mrnZJYWn5lZGTK6gLRWjx5I5ZBq4G5w/nhh4UAgBde+J+q79ujR09V308kn9WurEzdxBNvphERGRcTTxai5eDieverFyt24cck8JdNaTyBdB1c/MSJQzqXxBr02m7McAGtBr2/p7zFk3js07tMZhVpX+EYT4HUaqGlditetWfITYQ/KRRc94hclljKWbHimVKLxuhd7ULrE3Xq1AUQvK2l5tywe/cuaVmNBIxW+6O8q51WA5ibYf8mIrKa9LjCppioXVmUd+EySoun7OzskOcCBxePXE7/d0iPCktBgT/hVFx8Kuw6vDuYnPr1G0jL8v2pTZt2KSuDVSrYeieEmXhST6Sxi1I5xpMZfjujtngKbt2pRyhjG/8quGDRC5qTUyWOMZ5CWzzl5FQIKZ+e21oyny22pFKbfPtRO/HEOg0RkXEx8WQhyQwuDgDXXDM84O9Vq36RllOVeOrYsbPi85dddrni87GM8WSGC5JYyFt3Ra+MBX7n3NyqGpQo/QwefGXYx/v165+yMqTqbrre9N4v5XFmV7vkcIyn2Bg18ZRMt321RPpM+ePB68QSz5KSUzHPahdu/ETxM1M5q104Rk7AyMd4Kisr1bEkRESUSta4YiEAybd4qlo1MBmxatVKaTlViadPP/1K8fl27c4OeUxeAVOe1S49u9oB8f/W2dl5KpcmPUXaVlJZ6bdK8kPv7xnY4omJp2Tol3iy5hhP6g8urn8Cr6DgBADg6NEdcbwq+m/+ww/PhySeevXqHXZdo4zxpMSI27nT6e9qp/YYTyIjfm8iIqtLjytsikmyJ2L5gJAAcNFFfaVlpWmF1eRyufDOOzMiPh98J7Z9+8BElHKLp/QaXNxmi+XiIPzvli4x0FqnTueFfZyJJ/Xp/T3lF5KcAjw5kVrpaZ3037Yt+kyoRqJWPBo3PkuV9xGFdrXTL5ZK4zYGiyWeBQX7Q7ravfHGu2HXVbqRJU9Um7XF08CBg1QoSSh5bNRv8WTcll5ERFbHxJOFyJs3A/FXFuUDQgKBM9ukcoyn4HLIBd+JXbt2TUAFzEqDi7tcWdJyuC4BcsHbglW6byWra9fumDXrU6xatS7g8UgJKS2Y4QJaDXp/T/nFkjgFuN5lMqvgGwQireP5zTfzNH1/tal1HO7e/XxV3kdkhMHFI6latY607PEEjx8Uy+DiNUNmtatQITfsukotnlI5xtPFF/cDANxyy6iQ55L57EjfO1lOp7z1qDaDixMRkfHw6tJCbDZb0ODb8VVI5M2jgcAKQyqTNUoz9IQbcDRwcPHICRh/ZdM4lehk1KzZXFr+5ZfPw64T6a5ousQgFS64oDfq1q0HAPjttw347LOvcd55XVP2+Vb5rfT+nvJjHAcXT45eXe30+qxEqTnGU7NmzaOvGKPg84aRYpmVVUFaXrNmbsBzscSzXbur4hjjKXLrmlSO8XTmmWcCALKzy0uPqdHi6YMP3kv6PcKRt5grK9Mq8WScbZKIiHyYeLIYeauneCuLq1b9HPC3ePEFAF26pO5Cu1q16hGfi1bBs9Lg4vLWXwUFh3UsiXXUrFkLXbt2T+lnyrfXs85qmtLPTiW9WyLabDYp1v7jSHocK1It0m+Zyt/YDMd5pZss8VPvvUpKSgLfWcdYOp3lpOXgZEtpaWHA37G0ILPZbLLEk/L3Uh7jKXUtnmbOnA4AmDz5OU0/Ry3y1vKlpep2tTPyoOpERFbHxJPFJNP8e/HiRQF/i91NAGDAAG3GAghHaar6aC2elO5QpltXO4fD30Jt794NiuuGdrUz/kUZ+ci318qVq+hYEm3JE916EY8vHk96tY5MNb1aPF155X9S9llqUPNctGHDX6q9V2Zmpmrvlah27dqHPOb1ehQTD7H85oLgDRnjSWld3//+zyxXzhebVHa1Kyoq0vT91abtGE9ERGRU6XGFTTFLZsyI4PGRxIuvBg0aprwSn5tbMezj4WbbkTfljqWrXbq0YpD/JsuXfxR2HXa1Mz+r/FZGuLgSL0TFMdOsEnu1RZoVTet4tm0b+aaFERn1Jkhoq+PU7wf+2PjPYTt2/BawDclvjgGB25d85tZ69dpKy4LglW5QRe9qFzpm5IsvTgEQOI6Z1r9j1arVQh4zcsufwBlCtelqx2MzEZHxGLNWQ5pJ5i5c8IWfnuOciFMpB4teUYze1U7d7g1mEfydrRgDc/rpp2V6FyElzj23g95FkI6fHOMpOXq1eJLfeDHDb2fUxFMwPWIZ7ibau++ODfg7eHBx+Wvkyc/evW9F+/a+Abq9Xm/UMZ7E8bLEG1nyHE+TJmeFvFbr+IwZ4/vegwdfGfKcEbfzcOPlqcXICTciIqszR62GVKNm82/xbqKRKseRZksSKc2+J97lNGJFLdUYAzKa3r0vxgcffIQ1a/7UrQzixSoTT8nRa4ynVHZ/UoNRZxc1QtfscNvKtm1rAxIPwa1p5OUMfL1NirUgeKTW3ZHiLz4erj4hfoY8saX1dp2R4RszSd7Cy8gJGPnvwK52RETWYcxaDWlGzbtw4sWXkRJPHFw8XpG62hnnNyUCfPvlRRddgtq160RfWSPsaqeOcGPxAdrHM9LnGpWRzq1yRtjuxdgEn6vkCZczzwycyS9Siye73S5LPEVv8eQ/DkQeXDyVSU5xsG63O7R+k8xn33TTrQm/NlbadaHWfxslIqJACdVqjh49iueffx5Dhw7FRRddhC1btgAAZs2ahfXr16taQFJXMjOtBA8oKlZyjFQ5jnaXTynxJCZhjPR9UsUId7Apeffcc7/eRUhrYotK8djH3SQxkbozpzbxZPwfz6iJMiOcL/zn6eDP9tcBKlSoHPBMYIsnf2wbNjwXp04dBQCcPn0kbOJp6NCrQz47eNxL+WfIX6t1ncLpFBNP6rZ4atWqTdLvEc2HH76l8jsat6UXEZHVxX023L17Ny677DJ88MEHsNls2LVrlzQd6qZNm/DBBx+oXkhSzz//HE74tWPG3BHw97ZtfwMANmzQN9l4113jpOVEBgMNfo5JF8bATOQDy5599rk6liT9iccXdrVLTuQuTNrGM5Xj7qjBqDdBjJR4EoTAm0k//vixtOz1Bo8fFJh4euWVvzFx4grUqNEEGzf6xsr77rsnwiaeHn74vzjrrKZ48slJWLfuNwC+m7C+Mujb4klMPAUPpp6Kz07W1q1b9C4CERGlSNy1mmeffRa5ubn49ttvMWPGjIAT7tlnn421a9eqWkBSV2HhaWk53vpIvXoNAv5etmyJGkVKWvv2/ovtihXzMHTo1ejQoVPYdWPpamfUyr4WIt8VNXZllfy6du0mLRv9IsPsxFYS7GqXHGOM8aTpR6lCzRZPWrae0mdwcd9nBk8YsmvXX9Ky1+sJuNkU2NXOiby8Gqhbt3XIe4stmeTb4xln1MCyZb/g5ptHSY899tj4iOULTHJqu13/888/AIDvv/9WekyNFk9qD/wdTnFxoSbvy2MzEZHxxH02XLlyJW677TZUr1495MBetWpVHDp0SLXCkbbiPTFfeullGpUkOcGtmF555TVMmfJGTOuGe86KFRbxO2dmZgMAWrQ4X8fSUDwiTU1P6gue1Y4SwzGeYiO2ZDE6PWe1C27xJLd8+ce45ZYzsG7dd/++JnxXu2D+Fk/K3+vw4UP/lkHfFk/vvBO+vpPsZ19++WA0atQYt946JuH3iEZ5+IP4GXlQdSIiq4s78VRSUoKKFSuGfa6oqMiSF+1mFe9vlZHh0qgkyQlXcalcuXKYNZUTT9YcXDzQ//63FsOHv4jLL39Y76JQjMzWfcjMxFiLxxzGW12pTDyZ4bczS+JJD2JSSCnRsHTpdJSUnMazz14OIPLg4gDQvHkPAECLFv1lN6FiqyKHqzukcoynceMeCFOm5N83J6cCli9fgyeeeDr5NyMiIsuL+2xYv359LF++POxzq1atQpMmTZIuFKVG/ImnDI1KkpxwA3zm5FQIu25ss9pZt6td1ap1ceGFt8DlKqdTiShehw4dlJbNcDFtZmLigomn5Lhc4W9iaD/Gk7kST2q2Zuze/XwA0GRWSH0HF49dpMQQADRpch4AoGLFmgl3u5e/fyqTnDVq1AAAtGnTTrFM1mLV701EZFxxn7mHDBmC6dOn4/3338eJEycAAGVlZfjmm2/w4YcfYujQoaoXkozBqGMfdejQOeZ12dUuEit+5/SwZMkP0rI1t93U4eDi6ihXLnxiO5VjPJmBmi2epkx5E/fd9xDmzJmnyvs1aXKWtGyexFPkFk/+rnvesIOLK1Puaqf1di2WXal+Yx3sakdEZFRx12qGDRuGjRs34umnn8akSZMAAFdffTUEQcCQIUNw+eWXq15I0ka6XDRVr1495nU5uDhZySeffKl3EdJKcFc7JmwTE+nco/3sX+Zq8SQvb7KqVKkStktWovTutpjIeVqebApOPInvJx+QPJkWT/Ikl9bhCT0ucawjIiIynoRupz3xxBMYPHgwFi9ejCNHjiA/Px/nn38+2rdvr3b5SGV9+lyM77775t+/jF/xVlvwDDhyYpc9M1yQxGrIkMcwe/ZjqFz5zAhrsHKaToK3XbF7DamDXe3UEemCnmM8BerYMfbWvKmmd5f0ZLvaeTxlQc8l3uIp2uDiWt/MEt8/3LADZtjO1cSxOomIjCuuxFNxcTF69+6NCRMm4IILLkDbtm01KhZpZePGDdKyFU/MVhtcvGbNpgCA/Pxaiuul03e2Mv6O2pK3igAY78Tp0+LJbGM8tWnTDl9++Q3OPLO23kUJoXe3xUQSX/LffPfuv8I+Jwhe2U2oZMZ4St2kD/7jkrx+w5tKRERkLHElnsqVK4eSkhJkZWVpVR7S2K5dO/Uugq5i62pn/AuSWDkcvl3c6+X071ZghotpMxMvtt1uJp60wDGeQnXqdJ7eRQhL79k058//Ou7XKJVTTEpq0eJJ69Zh4meFu7FmhmMUuwUSEVlD3GfDTp06YcWKFVqUhVIskQrJ2LH3SMtVqlQFAFxxhXkGlPd4lAYXT78WT2LiyeMJn3hihc/88vLypOV02naNSLw45eDiycnJyQn7uNbxLCkpTtlnpTt5ix6zUEoAyQfoVmOMp9LSsrCPayHc4OJmOrd7PKWqvZf/e3P/JiIymrhrDiNHjsTcuXPx6quvYvPmzTh27BiOHz8e8I/MIZHK0MMP/xcDBgwC4O9uUr58+IsII4qtq535KtSR+BNPZYrr8SLMvG677S69i2AZ7GqnLa3juWbN6pR9VroLHDzbHLFUbvHkHydJ7GoXqfVz//4DAQAXX9z339eEJnlWr/4l5L21Em5wcZEZfpvdu9foXQQiIkqBuAcXHzTIl3R49dVXMWXKlLDrbNiwIezjZCyJVkjEypjY3cRMXdNKS0siPicmpcxQUYuVw5EBANizZ73OJSGt6N3lxUr8Xe3Y4kkLqRxcnJJjxljG0uIplq52rVq1xldfzUHlylX+fU1oa2l5Ekj7MZ587y+22paXyQzKl6+i+nvy2ExEZDxxJ57GjBnDA3qaSPR3FCtoes7sNG/eAkyc+BieeOLpuF5XUlKCY8eOIj+/Ushz6Ti4eHHxKWm5pKQQmZnZQWuYp3JK4QVO4Z0+264RiRd4nNUueXPnfo/7778Hf/65TnosVS1DAP52ydL6t9JCbF3tPFICJ9J33LRpIwBg5szpePHFV2XvET7xxFntQr388jTccceof/9Ssx7COg0RkVHFnXi6/fbbtSgHmYh/SnHfXX89KqDnnNMBc+bMS+i1n332CW688ZaQx/2Di5uvQh1JaWmRtLx27dfo3PnKCGsas3JK0Rn1wiId+Qcg5sVNss49tyMWLfoR1arlSo+lssUT95vkmK3FU2lpcRyDiyt3u//0048D/g53PBgyZChefz18rwC1KQ0ublQVK+ZJy5z8hIjIGtLnCpvilnhXO/1bPMWiS5duYR8Pd1dQ/rhRv08i5NOHFxWdUliTzMpMXV3NLvhiO52OFVYgPx4y2Z4cs7UeW7Dg9Zi72vnHeEp8cPG6detJy0qz6apBLOfevXukx4yeHHc6/fuiOGaeuoy/TRIRWU3cLZ5effVVxedtNhvGjBmTcIFIW/fd9xD+97+nACTeskd8nTjOiVFbCPXseSF++mlZyOPTpr2Km24aGfJ4OrZ4kl9o/fLLZ7jgghsCnjd65ZSiM8NFX7oIPjYw9ur6/PPPMXBgpFaZyXO5MjR7b6sx23lyy5afYx5cPFpXu2DhzqPixB6A9i2RDhzYH/E5ox6j5En8Eyf2AmilyvuyTkNEZFxMPFnMJ598JC0n2+LJ6NPWRqo07tu3N+zj6Ti4uDzxtGPHbxHXS6fvbDX87VKHLZ7UV6dOXezatRMAsHXrVk0/6+KL++HRRx8CwN8uWUZKPN1330L873+9FNdZvfoLnH12/4jPB47x5HssmRZPTmfqEk/Hjh0LeczoCRh53eTddwejU6fTOpaGiIhSIe7E08aNG0MeO378OBYsWID3338fb7zxhioFI22UlZVJy8kmniL9bRSRyhXp8XQcXFz+XbRpzk56M+r+l47Y4kl9jzwyATffPAKA9ttyVlaWtMzfLjlGGi+rQYOOMa2n1NXO5SoHACgrK4LXmwkguRZP8sTTP/8cjul9EqUUf71/m0jOPTe23yxRRv3eRERWpkotLy8vD1dccQX69++PiRMnqvGWpJFOnc6T/ZXcrHb+v415go9ULnnyTc6feEqfC/latZpJy+EST0a/K0rRGXX/S0dM8qlv9epfpGXtZ//yJ0t47EuO3vvCQw89Ki3Hcgw899yBiud2p9OXbPJ63VHHeBo1KnCSnXA3reSJuZ07d0QtXzLk5RTLYvTtu3z58pq8r9G/NxGRlalac2jVqhVWrFih5luSyq6++lppOfExnmxBfxvzYizeQZfTsatdxYrVpWWlFk/p9J2t5p9//tG7CJbBrnbq2759m7Ss9bnE4Qi9QKfEyJN4euwHd945DkuXrsekSbF10XI6XYrblzgmk9frjloXuOCCCwEAzZq1CHrGv34qYxIu8eTHYxQRERmDqrW8TZs2ITs7W823JJXl5laUlhOtF82d+1XA30a9+KpUqXJc6/sHFzfm90mE/OIgOztXYU0yq4ULv9O7CJbBrnbqk8c0OLGn5WcBTDwlwwg3nGrWPDOOfVCAUhLGbvclnk6ePCglniJ9x4wM3yD1brev9bTeSUwztnjSHo/NRERGE/cYT3PmzAl5rLS0FJs2bcKnn36Kyy67TI1yhTV79mx88MEH2L59O3JyctCmTRu89tpr0vNLlizBiy++iK1bt+KMM87AiBEjMGzYMM3KY0ZqjMtw+PChgL+NUAENp1+/yzBmzC0xr5+OLZ7kM+sMGHB/mDWsXjk1P48ncODaBg0aYts2bQdptiq2eNKCP4Yul0vTT5L/flpPcZ/ujDTGUyy8XkHxZtuhQ76Wd0eObIMg1AUQuW4jnlfFmX1FesVBfpOtqKgQOTkVpL/N8NsQEZE1xJ14euCBB8I+npmZicsuuwz33Xdf0oUK55VXXsF7772HkSNHok2bNjhx4gSWLVsmPf/rr79i9OjRGDBgAB544AGsXbsWEydOhMvlwpAhQzQpkxnt2bNLWlbrjphRKzbxtr5Lx8HFAaB9+35Yu3YuMjLKKayVXt/ZSoL343Tbfo3ELOPbmUlBwQlpWevEk7wFqNYzjaU7o95wiqSg4BDy8qpHfH7r1lXScrS6gNhlU9yG9G5d1KRJU2l5x44daNmylY6lISIiCi/uxNPChQtDHsvMzESVKlVUKVA4W7duxbRp0/DGG2+ga9eu0uO9e/eWlqdMmYLmzZvjqaeeAgB06tQJ+/fvx0svvYTBgwebrpKkleDWEWpIp65pgPkq1NGIXQg8HneUNYlICVs8qe/Agf3Scu3atTX9rHQ7tutJPl6WeUTeX10u/4yH0braiY+XlpYGvrtOxwNxMHTAXza9k2F6SdcbiERE6SDumoPNZkO1atVQq1Yt6Z+YdHK73di3b5/qhfzss89Qu3btgKSTXGlpKVauXIl+/foFPN6/f38cPnwY69evV71MZhU4uKpa75oeJ/h07GoHBA6aGsyqldN00rRps4C/0237NRImntR37bXXS8tjx47V9LPkvx+PfcmRtxgzwn4wdepOxecPHPhbsZwdOw6WlleuXAogcqs4t9vXTXP/fl99N9q2dM45HRSfT1ZGhr+loNMZeD/ZCL9NLLg/EhGlv7gTT7169cKGDRvCPrdx40b06tUr6UIF+/3339GkSRNMmTIFnTt3RsuWLXHNNddI5di1axfKysrQoEGDgNc1atQIgK/FFPnIK95qdTVIl7vI/sHF0+P7iA4c+BsAsGHDjxHXMUvllEJddtnlehfBMtKtdacRlCuXKS1nZWUprJk8rQcvt5L16//SuwgBKlRQbnWfkVFO8Tx35pnNQx77+usvw667fbu/TilPmER6/4oVK4Z9XC2VK/vHeMrMzAwplxmcOHFA7yIQEZHG4u5qp3Qy83q9mlzAHj58GH/99Re2bNmCCRMmICMjA6+++iquv/56fPfddzhxwjdGRG5u4Kxd4t/i88lwOo2bjBBbMcXS9F2cjQUA7HZBle/lcNgNHZ9wwpfXn3gy2/eRczp938HhEOBwADt3/g4AWLXq84jbiHhB7fs/cB2Hw/e402mHM+4jRnqIZx9LNfm26nTaAwbQTeV2bOQYqSW4NUE8xz4rxCcR8m76Xq9X0/g4HP6d46+//jDVcd5o20/37j2wefMmAPj33JD6cgWf65SUL58XUj+Vx1Lct202u9R17dSpk2G/lzxZarMJAdtVpDikKj5r1vyChg0bSN9V/tsYbRuSmzfvGdx66ysqvFNgPS6eOouR42MUjBERJUO1y8jS0lIsXboU+fn5ar2lRBAEFBYW4pVXXkHjxo0BAC1atECvXr3w0UcfoX379gAi321KNhlmt9uQn18+qfdIhdzc6HeLmzSpLy3n5JRT5XuVL6/O+6RSuPJmZ/uaq7tcTtN9Hzm7HcjOBsqX9/2Ty8kJHGBc3DXKlfN99+zsTASz2YDSUiAvLxMa37g1vFj2sVTr1q2ztJyfXz6gxZ4e27ERY6QWcT8RVaiQFXeM0zk+ibjyykG4+WZfdzuv15uy+Bw8eNCUx3mjbD95ef4bfXrVAZTOdcHOOediHDoU2B1Pfj50u31vIB8vKSsrM+z3ys/3zxpXoUKm9JtEqis6nfaUxefVVyfj1ltvlJJh4ep5RtmG5HbsWBVSP0mEmBDJzMxAXl75hOosRoyP0TBGRJSImBJPr776KqZMmQLAl8QZOnRoxHW1mEGuYsWKqFKlipR0AoBq1aqhQYMG+Pvvv9GzZ08AoS2bCgoKAIS2hIqX1yugoKAwqffQksNhR25uFgoKiqIOHn7GGXWk5VOninHs2Om4P699+3Owdu1q6e/i4rKE3kdP4cp7+nQxAN8A7Gb7PnIFBUBhoRMulxAyjtepU8UBf4vPFxeXAQAKC0vg9Qa+qLAQKCy04fhxN6w6EVQ8+1iqlS+fj59/XouKFSvi2LHTAV1oU7kdGzlGatmzJ3AMw9OnS2KOsRXikwjx2AMAHo8npfEx03HeaNtPWZm/DPHsB2pSOtcFKyvzoKwscJxD+fmwqKgs+CWw251hv1dJiUdaPnz4BI4fF9exRVg/dXWkP//8E8eOnYbb7ft95L+N0bah+vUbYPv2bQAAm80RUj9JhPi9SkrKcPz46bjqLEaLjxFZJUa5uVls1UWkgZgST61atcLVV18NQRDw4Ycf4qKLLgqZxc7lcqFJkya49NJLVS9kw4YNww5aLggC7HY76tSpg4yMDGzbtg3du3eXnv/777+l1ydLPIkbmcfjjVpOQbDhnHM6oKDgBNq0OTuh7zVp0vPo3buH7BGbKeIjF668ZWW+yqQgmO/7yLndvpYDHo8AjyfwueCKgth1Vvzf6xVC1vF4AK/XFxO3xSfGi2Uf00P9+r7x7Nxub8AFmB5lNWqM1LB48aKAvwUh/hinc3wS46/cezyelMbHjL+DcbYff0tyr1fQpUzB57q77voIL74Y/sao2+2G1xt4QpSf6wQhtGW8w+EM+73ECTsAoLCwSKo72O3h6w6pjo/b7ZVuQHg8oZ9tlG1o2rS3cPHFF/z7l12VRIa/ToOE6yxGiY+RMUZElIiYEk89evRAjx6+RENRURFGjx6t+bTHcueffz4+//xzbN68GU2aNAHgaya/bds2DBo0CC6XC506dcL8+fMxYsQI6XVff/01qlatiubNQweNtCqbzYavvvoWdrs94S6IrVu3DXlPM3jzzTdx8803AwBKSkqkQThFr7zyIgBg7tzwA4qmJ3MNQErRmWV/NCO73W642bzMTj7gd4UKFRTWJCORD7RvlP2gRo3GIY/16nULFi58A16vR7FVVLhJRTIywleR5bPIlZSU4IknHgUAHDt2LOz68u57qWaU3yacWrXOlJaNXE4iIlJH3O0In3766ZQmnQCgd+/eaNGiBW6//XbMmzcPCxYswMiRI1GpUiVceeWVAIAxY8bgzz//xPjx4/Hzzz9j2rRpmD17NsaOHZt2s5Qly+FwJHWSt9lsAa83S4VB3kqvpCS0SfeePbtTWRyDMcdvSNHdeec4AMDllw+OsibFK3QmUO43ybLZbHjssScxduzdaNq0qd7FoRjZ7cabIfD06dDET7ly4thNHsUEkM0W+n2GDLkq7LotWrSUlgVBwLffzlcsl1ozCMfH+DeVKlf218m2b1+lY0mIiCgVEh5cfPPmzdi6dStKSkpCnhs4cGAyZQrhcDjw5ptv4qmnnsKjjz4Kt9uNc889F88//zyys7MBAO3atcPUqVPxwgsvYM6cOTjjjDMwfvx4TcacIt9v4v63DbPNZo7EXps2baRlT3AfNIsy25TLFN2QIVehQ4dOqF27TvSVKSlmSbob3ejRt5tqhjkK30JIb/L9sXLlM3HFFf/Fvn2+mfd8LZ4in+/CJdJq164bdt1KlSpLy0VF0cf/1PM8a+RjVPAsoWoQY23k701EZFVxH/WLioowatQorFy5EjabLexBXu3EEwBUrlwZzz//vOI68i6BpC23rOO8WU7wdev6K5Fut3UST40bd8KWLSsV1zHLb0ixqVu3nt5FsATuN2RV8sSTUfYDefLonns+Re3aLfHJJ48D8LU6UmrxFC7xFO7GarDZs2dFXadGjZpR1yEiIkp3cd+ymjp1Kvbu3YsZM2ZAEAS8+uqrePfdd9G7d2/UrVsXn3/+uRblJAMz4p3PcGw2m3SHze0OncEmXV111ZN6F4EoLRnlgpso1eRjcxlFYOtr374pJpR8A4vH1+Iplv17z549EZ9744130a1bD0yY8FTU91EbWzMTEZHRxJ0xWLhwIW6++Wa0a9cOAFCjRg107twZL7/8Mlq0aIEPP/xQ9UKSsRn54qtPn4ul5cDEk3WmZ8vK8g3Y63JlhzzHyilR4ox87CPSkhFbPGVm+s9xFSpUAhCYeFq92j9xyNVXPxPw2nA30GI5P5aVlUZ8buDAwfj0069QrVq1qO+jFYP8NCnEOg0RkVHFnXjau3cvGjRoIA1QXVRUJD3Xv39/LFy4UNUCkvHJZ7cxmuAZ+IqLfYOKb9mySYfS6KOszNddoLS0MGJF2igXDkREZHxGHNuxVq1msNlsyMqqgLy8GgCA9euXAAB++OEdab1WrS7EJZfcHvX9YpmN7uTJkwmWVlu8qUREREYTd82hQoUKKCz0DaZYuXJl7Ny5U3rO7XZLz5F1GDlpMW7cAwCANm3aBjx+1VXWmfHrn3/8++iOHb/pVxCiNGPkYx+Rlow4s63NZsMXX3jx9tuHpMc2bFgasl5RUfhkUV5e4FhMNWueGfUzFyz4Ls5SppZRfptUs+r3JiIysrgTT2eddRZ27NgBAOjYsSNef/11rF69GuvWrcOUKVM4HbIFGXmMJ7vdjkOHCvDDDz/qXRTdyMeuOHRou44lIUovvLghq5o9+//0LkJMzjijcchj+fk1wq57/Pi+gL+rVKmiSZlSwYwtnjye5IdAMOP3JiKyirgzBoMHD8bp06cBAHfeeSeKiopw7bXXYujQodi3bx8eeOAB1QtJxsaLL2Oz2/2TVy5Z8n6EtfgbEkXz4IOPBPzNQ5/5/PLL77j88sHYsmWX3kUxtQ0b1utdhJj07393yGOxJCfy8/O1KE5KeL3+LoJmqp8tWvS23kUgIiINOaOvEqhv377Scu3atfHtt99i5cqVsNlsaNeuHfLy8tQsH5mAEcd6ID95izSv1zqDqhOprWPHzgF/m+mijnzq1auP119/V+9ipBnj7gcOhyvksVjGbnI4lKvHdevWw86dOxItluruumscXnzxOQDAypXLYcaGPxs2LEPv3req9G7G3SaJiKwqroxBcXEx7rnnHqxevVp6LDs7GxdccAF69uzJpJNFpcvF15ln1gbgq8ClE3niqV69dgHPsVk6UeyCj3XpcuwjSlfyruYir9cT9XXiDLiRhEs6o/quaQAAVcVJREFUbdyoX1f2ypX93QKXLFkkLRv9GDVixChpedWqz5N+P9ZpiIiMK67EU7ly5bBw4UIe2CmAkcd4iseePbsBAA0aNNK5JOpq3NjfSqNRow5h1zF65ZTICJh4Igpl5P0gXOLJ4ymL+rpoiadw8vL0655XqVJlaVls+WQGLVu2i74SERGlhbgzBk2bNsXmzZu1KAuZlJErnbESk05A+iTSRFlZFZCT46uUZmRk6lwaIjNj4onITMKdzzMyykV9nbxOECs9jwfBiTKz3CDu1q2Xyu/o+948NhMRGU/cV9jjxo3D22+/jV9++UWL8pAJpUOiprCwUFpeseInHUuijapV6wIIVxk1R+WUyAhCj3W8uCEy8kW+zRba4qldu0tU/5xmzZrrGof8/EphHzfyb0NERNYSd1viCRMm4PTp0xg+fDhyc3NRrVq1gOdtNhu+/PJL1QpIxpcOFZuZM6dLyyUlJTqWRBsnTx4BAJw6dTTCGub/DYm0Vq9e/YC/0+HYR5TOwnW169btWtU/p3v381V/z2Q+3ywtnnJz8/QuAhERpUjcTVXy8vLQpEkTnHPOOWjSpAny8vIC/lWsWFGLcpKBmanF0/Dh14d9fNq0V6Rls1TY4vHPPzsBAK+/frPOJSEyr3A3WoisqE6dutKykfeDcPUTLeos4RJcqRT5NzDubwMAGRkZqr6fv/5m7O9NRGRFcbd4+uCDD7QoB5lMrVpnYu/ePQCMXekMNmzYdXj//XdRp049vYtiCOmYZCNKFTMd+4jUlJlpjvEC40kIdehwJX755eOEPsfh0DfxFIzndiIiMhrzNFUhQxkx4kZp2UwXX+IAnLt27ZAeKyg4EbCOmVpwqcVMvyEREekrJydH7yLExGaL/XyeTKsloyWeRDy3ExGRUSR0hX306FE8//zzGDp0KPr06YMtW7YAAGbNmoX169erWkAypowMl7RspoqNPKkkzlqzd+/eiOsQEUXCVgVkVffe+6C0bOQ6QDzJJLs97k4AEofDWPUGqx6bxO9t5G2SiMiq4j5T7t69G5dddhk++OAD2Gw27N69G6WlpQCATZs2sSueRbhc6vbLTxV5ZeTbb+cBAB599MGAdeRjV6Q7q1ZOidRw+PAhvYtApIuqVatFX8kAtEo8NWvWPOHPSSUmYIiIyCjiTjw9++yzyM3NxbfffosZM2YEXLieffbZWLt2raoFJGNyOv2Jp8LCQh1LEh95JWzlyhUAgCVLfghY55ZbRqW0TEbAyikREcXqyJF/pOXi4iIdS6IsOCF07rmXR1zX4Yg98TRs2HVBrzVm4omIiMgo4k48rVy5ErfddhuqV68ecrFatWpVHDrEO8BW4HL5u9q9++6bOpYkPvJtNlJrn9xczsxIREQUSXFxibRs5JazBw/+HfB3VlaFiOvabP7k0V13jVN830svHRDwt9EST0b+TbTFWe2IiIwq7sRTSUkJKlYMf2FeVFTElhMWIU88HTt2TMeSxIebZzCrVk6JiChRTqc/0eLxeHQsibKSksDWWE6nK8KagcmjaF3natasFfA3u9qp4+jRvdFXIiIiU4o78VS/fn0sX7487HOrVq1CkyZNki4UGV/PnhdKy263W8eSxEc+w4117wiGY67KKZEReL1evYtApAt5d3sjJ56CE0IOR+TxKeVjPMXbgsloLZ48HvPUy2rUaCUt//PPbh1LQkREWoo78TRkyBBMnz4d77//Pk6c8E1DX1ZWhm+++QYffvghhg4dqnohyXgqVaokLZupghOtq139+g1SWZyUiWdKaSKKDRNPZFXyRIuRE0/B5z55wiyYfIyn+BNPxjrHnjp1CoA5Wjxdeukz0rIgJLctcVY7IiLjinvu2GHDhmHjxo14+umnMWnSJADA1VdfDUEQMGTIEFx+eeSBGyl9xDJWkhFlZ2dLy+EuGj/77OtUFidlMjIyUVoaOgCsmX47IqMpKyvTuwhEurDb/YkWIyee5OUElFs8ycd4iiXx1L792Vi7dk3M66fS3r179C5CzKpWbSwtl5WVKKxJRERmFnfiCQCeeOIJDB48GD/88AOOHj2K/Px8nH/++Wjfvr3a5SMTuPjifnoXIWZ16tSVlo8dOxryfK1aZ6ayOClTvXoD7N79V8TneXeQKH5MPJFVmaXF09ln98fbb4+R/o61xVMsYzbJ1zHCGE9nnlkbe/YEdlUz27l91qyHMXHiCr2LQUREGkgo8QQAbdu2Rdu2bVUsCplVx46d9S5CQlas+MnQFWY1DRs2Cc88c6nexSBKK+naNZcomg4dOknLJ08W6FgSZcGz2Cl1O493jCd5a6ply5bgxhtvSaCE6jFC8isR8t9k5851Sb4bZ7UjIjKqhDul//rrr3jttdfwzDPP4LXXXsPatWvVLBeZSGlpqd5FSFhBwQm9i5ASublVA/4XsasdUeK6dOmmdxGIdOF0+pM0H3/8fzqWRJk8meQTOSEhTzbFMmaTvDXRokXfx102tQ0adEXIY2Zo8RTcHZKIiNJT3C2eiouLcdddd2Hx4sUBF602mw09evTA5MmTUa5cOVULScbWpMlZehchYVdeaY0xycTKd0HBYQiCEFIZNUPllMhojDauC5EejDyzbXBS48CBzRHXjXeMp59/9ncJy8hwJVA6dbVq1VrvIiQkJ6e6au/FwcWJiIwr7tsMzz77LJYtW4Y777wTCxcuxLp167Bw4UKMHTsWP/74I5599lktykkGtHDhj5g27S1T3/X//fdf9S5CSsgrYQcPbtWxJETmVqWKv9WgvNUHkVVVqJCrdxFitmLF7IjPxTvGk1xGhv7HgnAtmM2QgDFDGYmIKHlxJ57mzZuHUaNG4dZbb0WtWrXgcrlQq1YtjBw5EiNHjsTcuXO1KCcZUKtWrTF48JV6F4NiIK+QBs5ux652RPFYuvRnAMB99z2kc0mIjKFbtx56FyFm8uRSsHjHeIr1fVOlfPnyeheBiIgoooS62kWava59+/Z4++23ky4UEaktsFtsKN5xJIpFlSpVcOiQcQdTJqLInM7MiM/Jk0e7d++K630zMiLPlpcq3bqdr3cRVOH1ehIeKJ1d7YiIjCvuFk9t2rTBH3/8Efa5P/74A61atUq6UER6mDDhKb2LkBJKs/oQERHFw+v16l2EmLlcWRGfk4/x9PXXX8T1vldffW3CZVKLyxU6zpQZEzBerzVmGyYispq4r0DHjx+PWbNmYebMmThxwjcj2IkTJzBjxgx89NFHeOSRR1QvJFEqVKpUSe8iaCZ4IoBwjxMREcXLTImn6tUbRHxO3r0ulvHbRoy4UVru1at3cgUjCRNPRETpKe6udkOGDIHb7cbEiRMxceJEOBwOeDy+k4TT6cTQoUOldW02G9asWaNeaYlUUL9+A2zfvi3kcTMPkh5NtWr1peWlS2fgP/95MuB5M94VJSIi/dWtW1fvIsSsTp3IM7/Jx3iKpauXfMY8o85wacZze3KJJ/Fmmvm+NxFRuos78XTRRReZ8kRGJOrbtz+mTHkp5PFatc7UoTSpIe9eMG/e5JDEExERUTw+++xr/PDDQlx33Q16F0VRgwbnYNu21ahQoQoGDYo8KYB8jKeOHTtFfV8zJJ7MaOXKT3H++cP1LgYREaks7sTTM888o0U5iFImXAWxcuXKlkyosqsdERElomvX7ujatbvexYhqwoQlMQ1YLR/j6dprr4/6vvIuhkYdO9Es9ZqsrIooKvIN3/H226OZeCIiSkPGPFMSaUh+l1I0c+ZsHUpiHGapnBIREcUrlq5z8hZPsYzx9M47b8peyxZPyRgw4FFV3oez2hERGVfcLZ4AoLS0FMuXL8fevXtRWloa8JzNZsOIESPUKBuRJuz20ApJXl6+DiXRj9fr/TcBxxZPRERE8jGe4k0kGTfxZI4EjMuVrXcRiIhIY3Ennv7880+MHDkSR44cCdtNh4knMjqnMyPkMavdHVuy5H307Bm9KwEREZEVyOsBDkd8HQLiXZ8CtWp1sd5FICIijcWdeJowYQJycnIwYcIENGzYEBkZoRfxREbWt29//O9/T+ldDF3NmzcZPXtezzGeiIiIABw4sElajnfMJqOO8WQWubnVVHkff53GWjcTiYjMIO7E099//43nnnsOvXr10qI8RJqrV69+yGNWa/FUVlYS8LfVvj8REZGcfBwo+cDhsTBqVzue24mIyCjivkVTo0YNLcpBlDLZ2aFjCVSpUlWHkujnyJHd/y6xxRMREZHD4ZKWy8rKoq7fsWNn2WuNkXi6994H9S4CERFRWHEnnm666Sa88847IYOKE5lZTk6O3kUgIiIinTgc/qEjYpnVbtSo22WvNUbiKT8/cKIU67V44qx2RERGFXdXu0GDBmHv3r248MIL0aFDB+Tl5YWsM378eDXKRpQSn3zypd5F0A2nHiYiIgrUqFHjqOuUlvq7rMu76ekp3OQpRERERhB34mnx4sV4/fXX4Xa78fXXX4c8b7PZmHgiU7HqAPler0fvIhARERlCtWoNpeVYbsZ8/PH/Sct2uzEGFw8eNoD3lIiIyCjiTjz973//Q4sWLTirHaUNq7T2ueSSOzB//svS3z///JnsWWvEgIiIKJymTc/HoEEvY+jQpjGtLx8HyuEwRuIpK6uc3kXQFWe1IyIyrrjPlHv37sVtt92Gpk2bMulEpiXfditWzNOvICnUs+f1AX/v3btBVkkjIiKyLpvNhk6dbsLZZ3eKaf2qVatJy5mZxkj49OhxQcDfZrqx1rfvndLykSN79CsIERFpIu7EU4MGDXDq1CktykKUMh9/PAcA0L792WjWrLm+hUmRihWrB/z9xReTpGUzVU6JiIj0Nnz4jdKyUQYXj2VQdKPq2HGwtHz06N6E3oM304iIjCvuM9TYsWPxwgsv4JxzzkHVqtaagp7SR5cu3XDw4AlLJVyysyuGeZSVNCIioniVK5cpLVupLqEdf30k2QQSfw8iIuOJO/E0a9YsFBQUoE+fPmjatCkqVgy8mLXZbJg2bZpqBSTSCismHGCciIgoEfIBxY1anzBqucJhayUiovQWd+Jp8+bNsNvtyM/Px8GDB3Hw4MGA5810kiOyOrGix/2WiIgoHv7zJs+hyRMEr7Ts8ZQprBkL/h5EREYTd+Jp0aJFWpSDiFJgzJj3MWXKcL2LQUREZGryZJNRE09GLVc4tWr5ZxOcM+dpNGvWTcfSEBGR2owx/ysRpUTt2i0jPGOeyikREZHezJB4MpOsrFxpef36JTqWhIiItJBQ4qm0tBSzZs3C3Xffjeuvvx47duwAACxYsAC7d+9Ws3xEpKKaNc/SuwhERESmZ4bEk1HLpRUOH0BEZFxxd7U7evQohg8fji1btqBKlSo4cuQITp8+DQBYuHAhfvzxRzz22GNql5OIVBCpMsZKGhERUewcDoe0zHMoERGRsrhbPD377LMoKCjAp59+isWLFwfMQtGxY0esWrVK1QISERERERlJ48ZN0K1bDwwYMMiwiSejlouIiKwn7hZPixcvxrhx49CiRQt4PIFTsVevXh0HDhxQrXBEpD6HwwmPxx3wGCunREREsbPb7fj006/0LgYFEG+Gs05DRGQ0cbd4OnXqFGrWrBn2ObfbHZKMIiJjufzyh/UuAhEREWmgUaPG0jJvKhERkVHEnXg688wz8dtvv4V9bt26dahfv36yZSIiDXGKYiIiovRUt249vYtAREQUIqbE06pVq6QBxPv3748333wTCxYsCJg9Yt26dZg+fToGDBigXWmJKGkNGpwT5lHeFSUiIjK7u+++T+8iqMLtLov7NZzVjojIuGJKPF133XXYunUrAODmm29G+/btcdttt6FLly4AgBtvvBFDhw5FmzZtcN1112lXWiJKmtOZoXcRiIiISANnnFFDWjZzAmbPnj/1LgIREakopsHF5TPXZWRk4M0338S8efOwePFiHDlyBPn5+Tj//PPRr18/2O1x994johQrXz4fp08fk/42c+WUiIiIfBwOh7S8ceMGtG7dVr/CJOHDDx/CQw/N17sYRESkkrhntQN8F6n9+vVDv3791C4PEaXANddMwuuv36J3MYiIiEhFXq9XWna73QprGtuGDUvjfg272hERGRebJxFZUEZGuaBHWEkjIiIyu9LSUmm5XLngc72x9ex5g95FICIijcTc4mn48OEx3UGw2WxYs2ZNUoUiIq0x0URERJRu6tSpKy1nZLh0LEn8Wrfugx9+eCeJdxCir0JERLqIOfHUoUMHVKpUScuyEFGKsBk6ERFR+nE65VV7cyVi2rW7RKV3Yh2HiMhoYk48jRkzBq1bt9ayLESUIsGJJyaiiIiI0ovd7oi+koE4HAkNPUtERCbAMZ6ILImJJiIionRUuXJlAEDHjp11LklqyWfhJiIiY+GtBSILYosnIiKi9LR27XoUFRWiUqXKehdFF6zTEBEZDxNPRBZks7GxIxERUTrKyspCVlaW3sUgIiKSxJR42rhxo9blIKIUCr0byLuDREREZF7sakdEZFxs9kBkSUw0ERERUTpiHYeIyGiYeCKyII5/QERERERERKnAxBORBQUnnrxej04lISIiIlIDu9oRERkVE09EBK/XrXcRiIiIiCTHju1P6HVs1U1EZDxMPBFZUHClTBC8OpWEiIiIKNShQ9v1LgIREamEiSciC+KsdkRERGQ0vXuPkpZ37VoX12v9s9qxTkNEZDRMPBFZUmClLD+/hk7lICIiIvKpXr2BtDx9+j06loSIiNTExBORBclbPFWtWk+/ghARERH9y+0u0bsIRESkAVMmnk6fPo3u3bvjrLPOwh9//BHw3JIlSzBw4EC0atUKvXv3xsyZM3UqJZFx2Wym3PWJiIgojbVpc1HCrxW72nFscSIi4zHl1efUqVPh8YRO//7rr79i9OjRaN68Od58801cfvnlmDhxImbPnq1DKYmMizO+EBERkdGceWZzvYtAREQaMF3iaevWrfjwww9x++23hzw3ZcoUNG/eHE899RQ6deqE0aNH44orrsBLL70Er5ezdhH5+RNPTEIRERGR+QnRVyEiIl2YLvH05JNP4qqrrkL9+vUDHi8tLcXKlSvRr1+/gMf79++Pw4cPY/369aksJpGhMdlERERE6Yl1HCIiozFV4umbb77Bxo0bMWbMmJDndu3ahbKyMjRo0CDg8UaNGgHwtZQiIh8mnoiIiIiIiCgVnHoXIFZFRUV45plncPfddyMnJyfk+RMnTgAAcnNzAx4X/xafT5TTadwcncNhD/ifQlkpRk4nYLfb4XAIcDjCr+OQPWGz2WC3+xJRvv/tQev6Hnc67XCa5oihLittP4lijJQxPsoYH2WMT6jgc53SeSwW6X6uM+I2FFt9JZ7y+rra2e32uH9HI8bHaBgjIkqGaU6t06ZNQ+XKlTFo0CDF9SK15EimhYfdbkN+fvmEX58qublZehfB8KwQI7sdyM4Gypf3/QsnKytTWrbZbMjO9v0t/i9nswGlpUBeXiYqVtSkyKZhhe0nWYyRMsZHGeOjjPHxi3SuC3cei4VVznVG2oZiqa/k5JSL+f3Eun65cpnIyyuf0O9opPgYFWNERIkwReJp7969eOeddzBlyhScOnUKAFBYWCj9f/r0aVT89+wS3LKpoKAAQGhLqHh4vQIKCgoTfr3WHA47cnOzUFBQBI+Hg6iHY6UYFRQAhYVOuFwChAjjbBYXl0rLggAUFpYgOzsThYUl8HoDX1RYCBQW2nD8uBtWHaPfSttPohgjZYyPMsZHGeMTKvhcZ7fbIp7HYpHu5zojbkOx1FdOnSqO+f2Ef9+kuLgUx4+fjut3NGJ8jMYqMcrNzWKrLiINmCLxtGfPHpSVleGWW24Jee66665DmzZtMGPGDGRkZGDbtm3o3r279Pzff/8NAGjYsGFSZXC7jX+A9Xi8piinnqwQI7cb8Hq98HgEeDzh1wmujImVdK9XCKlMeDyA12uD2+2F261Fic3DCttPshgjZYyPMsZHGePjF3qu810ohjuPxcIq5zojbUOx1Ffcbk/MvRbExJMgeBP+HY0UH6NijIgoEaZIPDVr1gzTp08PeGzDhg14+umnMWHCBLRq1QoulwudOnXC/PnzMWLECGm9r7/+GlWrVkXz5s1TXGoi4+Lg4kRERGREjRt3wpYtKwEAHo8bTmdGnO/AOg4RkdGYIvGUm5uLjh07hn2uRYsWaNGiBQBgzJgxuOaaazB+/Hj0798fa9euxezZs/H444/DbmeTSSKRzWaXLbOCRkRERMbQrds1UuLJ7S5JIPFERERGk1bZmHbt2mHq1Kn4448/cOONN+LTTz/F+PHjMWTIEL2LRmQoTDYRERGREblc/sGri4tPxvw6IdJAUUREpDtTtHgKp2PHjti0aVPI4z169ECPHj10KBGRmTDxRERERMbjcPgvT159dQTGj/82rtfz5hoRkfGkVYsnIopNYKWMFTQiIiIynk2bftS7CEREpAImnogsiHcDiYiIyIgqVKgiLdeq1Szm17GrHRGRcTHxRGRJTDwRERGR8TRv7h8yY+/eDQm8A+s4RERGw8QTkQXJWzyx9RMREREZBeslRETph4knIgtinY6IiIjSC7vaEREZFRNPRJbEzBMRERGlH7aYIiIyHiaeiCyIXe2IiIiIiIgoFZh4IrIkJpuIiIjI+AoLT8S0njirHW+oEREZDxNPRBZkt3PXJyIiIuM7dGib3kUgIqIk8eqTyJJsEZaJiIiI9JWfX1Na3rBhWUyvEVs8ERGR8TDxRGRBbIZORERERuVwZEjLJ04cCnm+rKwE+/ZtivBq1nGIiIyGiSciC2LiiYiIiIyquPik4vM33FAJ99/fHr/+Oj9FJSIiomQw8URkSZzVjoiIiIzp4otvl5aPHt0T8Nzx4wek5fffv1P2DLvaEREZFRNPRBbEZBMREREZVf36baXlFStmBzxXXHxKWj5yxJ+U4qx2RETGxcQTkQWxUkZERERG1bBhh4jPlZYWhX3cn3ji5Q0RkdHwyExkSUw8ERERkTHZ7Y6Iz3322ZNhH/fPasc6DhGR0TDxRGRBbPFERERERlWuXE7E59at+z7g7+3bf/13iS2eiIiMikdmIgti4omIiIiMSqmeUlZWHPD35s0rAABerzfqa4mISB9MPBFZkPxuICtoREREZAb+7nR+DodTfBYAWzwRERkRj8xElsRkExEREZmL1+sJeWzGjPv+fU5s8cTLGyIio+GRmciC2MqJiIiIzObkycMhj3k8Zf8uiS2eWMchIjIaJp6ILEheKWMFjYiIiMxg3Lg2EZ9jiyciIuPikZnIkphsIiIiInMpKTkd4fFCiC2eWMchIjIeJp6ILCiwlRMraERERGRc4QYVl5s9+zEIAls8EREZFY/MRBbE7nVERERkZC5XtrTs9XoUk0/ffTdNep51HCIi42HiiciSWCkjIiIi4zrvvKHScmHhcfz3v90jrisIXlmLJ9ZxiIiMhoknIgvi4OJERERkZFde+Zi0/Msvc7B9+1rF9f0tolivISIyGiaeiCyIuSYiIiIysszMHGn5iy+eibq+1+sBANjtvLwhIjIaHpmJLIgDbxIREZGR2e0OafnYsf1xvJJ314iIjIZXn0SWxK52REREZFzyxFM49947J+zjvLlGRGQ8PDITWZA82RRtimIiIiKiVIvWZa5q1XphH+cNNSIi42HiiciCWCkjIiIisxo79v9Qo0ZjvYtBREQxYuKJyJLY4omIiIjMKVo3PCIiMhYmnogsKLDFExNPREREZB516rTWuwhERBQHJp6ILIhd7YiIiMisqlSprXcRiIgoDkw8EVkSu9oRERGRud166xt6F4GIiGLAxBORBXFWOyIiIjKje+/9XFru2nVYmDXYqpuIyGiYeCKyIHa1IyIiIqOz2UIvVVq37qP4mqysfK2KQ0RECWLiiciCwlXkiIiIiIxk8OBH4n6N3c46DhGR0fDITGRJ8q52Xh3LQURERBTeGWc0Cvj73HMH6lMQIiJKChNPRBbErnZERERkdMGtlzyespB1hgx5LEWlISKiRDn1LgARpR4HFyciIiLjC7xRtnbt3JA1+vQZjT/+WIj8/DNw7bVv4dSpVJWNiIhixcQTkSUx8URERETG1qxZt6jrlCtXHg8//A0AoLBQ6xIREVEi2NWOyILY1Y6IiIiMLienkt5FICIiFTDxRGRBgYkntngiIiIiIiIibTDxRGRJ7GpHRERERERE2mPiiciC2NWOiIiIiIiIUoGJJyIL4qx2RERERERElApMPBFZEls8ERERkbm0aHG+3kUgIqIEMPFEZEEcXJyIiIjMJisrV+8iEBFRAph4IrIgeeLJ6/XqWBIiIiKi2Gzc+JPeRSAiogQw8URERERERIbXuHFHvYtAREQJYOKJyPLY1Y6IiIiMKSMjU1r+88+FOpaEiIgSxcQTkcVxVjsiIiIyqt69R0rLZ53VRceSEBFRoph4IrI8Jp6IiIjImBo2PFda7t9/nI4lISKiRDHxRGRxbPFERERERlWrVlNpuUmT83QsCRERJYqJJyKLY+KJiIiIjMrhyJCW7XaHjiUhIqJEOfUuABERERERUTjVqzdEly7/QU5OPux23jMnIjIjJp6ILI8tnoiIiMiYbDYbRo58S+9iEBFREnjbgMji2NWOiIiIiIiItMLEE5HFMfFEREREREREWmHiicjymHgiIiIiIiIibTDxRGRxbPFEREREREREWmHiiYiIiIiIiIiINMHEE5HFscUTERERERERaYWJJyKLY+KJiIiIiIiItMLEExERERERERERaYKJJyLLY4snIiIiIiIi0gYTT0QWx652REREREREpBUmnogsjoknIiIiIiIi0goTT0SWx8QTERERERERaYOJJyKLY4snIiIiIiIi0goTT0REREREREREpAkmnogsji2eiIiIiIiISCtMPBFZHhNPREREREREpA0mnogsji2eiIiIiIiISCtMPBFZHBNPREREREREpBVTJJ7mz5+P0aNHo0ePHmjbti369++PDz/8EF6vN2C9JUuWYODAgWjVqhV69+6NmTNn6lRiIiIiIiIiIiJy6l2AWLz77ruoWbMm7rvvPlSuXBk///wznnzySezevRv3338/AODXX3/F6NGjMWDAADzwwANYu3YtJk6cCJfLhSFDhuj8DYiMjC2eiIiIiIiISBumSDy99tprqFSpkvR3p06dUFhYiJkzZ+Kuu+6Cy+XClClT0Lx5czz11FPSOvv378dLL72EwYMHw243ReMuopQTBG/0lYiIiIiIiIgSYIpsjDzpJGrWrBlKSkpw/PhxlJaWYuXKlejXr1/AOv3798fhw4exfv36VBWViIiIiIiIiIj+ZYrEUzhr1qxBXl4eKleujF27dqGsrAwNGjQIWKdRo0YAgK1bt+pRRCJT4ODiREREREREpBVTdLUL9scff+Czzz7DmDFj4HA4cOLECQBAbm5uwHri3+LzyXA6jZujczjsAf9TKCvFyOkE7HY7HA4BDkf09QVBgN1uA4B//w+MkcPhe9zptMNpyiNG8qy0/SSKMVLG+ChjfJQxPqGCz3VK57FYpPu5zojbULz1lVgk+jsaMT5GwxgRUTJMd2o9fPgw7rjjDrRq1Qo333xzwHM2my3sayI9Hiu73Yb8/PJJvUcq5OZm6V0Ew7NCjOx2IDsbKF/e9y86AdnZmQAg/S9nswGlpUBeXiYqVlS3rGZjhe0nWYyRMsZHGeOjjPHxi3SuC3cei4VVznVG2obir69El+zvaKT4GBVjRESJMFXi6eTJk7j55ptRrlw5TJs2DRkZGQCAiv+eWYJbNhUUFAAIbQkVL69XQEFBYVLvoSWHw47c3CwUFBTB4+FA0eFYKUYFBUBhoRMul4BYetEJgoDCwhJkZ2eisLAEXm/giwoLgcJCG44fd8Ob3qGLyErbT6IYI2WMjzLGRxnjEyr4XGe32yKex2KR7uc6I25D8dZXYpHo72jE+BiNVWKUm5vFVl1EGjBN4qmkpASjRo3CP//8g48++gj5+fnSc3Xq1EFGRga2bduG7t27S4///fffAICGDRsm/flut/EPsB6P1xTl1JMVYuR2A16vFx6PAI8n+vqCIEiVdK9XCKlMeDyA12uD2+2F261Fic3DCttPshgjZYyPMsZHGePjF3qu810ohjuPxcIq5zojbUPx1ldikezvaKT4GBVjRESJMEU61+12Y+zYsdi4cSPeeust1KpVK+B5l8uFTp06Yf78+QGPf/3116hatSqaN2+eyuISERERERERERFM0uLp8ccfxw8//IB7770XxcXF+O2336TnGjVqhJycHIwZMwbXXHMNxo8fj/79+2Pt2rWYPXs2Hn/8cdjtpsivEemEs9oRERERERGRNkyRePrxxx8BAM8++2zIc9OnT0fHjh3Rrl07TJ06FS+88ALmzJmDM844A+PHj8eQIUNSXVwiUxHUGliBiIiIiIiIKIgpEk+LFi2Kab0ePXqgR48eGpeGiIiIiIiIiIhiwT5oRERERERERESkCSaeiIiIiIiIiIhIE0w8ERERERERERGRJph4IiIiIiIiIiIiTTDxREREREREREREmmDiiYiIiIiIiIiINMHEExERERERERERaYKJJyIiIiIiIiIi0gQTT0REREREREREpAkmnoiIiIiIiIiISBNMPBERERERERERkSaYeCIiIiIiIiIiIk0w8URERERERERERJpg4omIiIiIiIiIiDTBxBMREREREREREWmCiSciIiIiIiIiItIEE09ERERERERERKQJJp6IiIiIiIiIiEgTTDwREREREREREZEmmHgiIiIiIiIiIiJNMPFERERERERERESaYOKJiIiIiIiIiIg0wcQTERERERERERFpgoknIiIiIiIiIiLSBBNPRERERERERESkCSaeiIiIiIiIiIhIE0w8ERERERERERGRJph4IiIiIiIiIiIiTTDxREREREREREREmmDiiYiIiIiIiIiINMHEExERERERERERaYKJJyIiIiIiIiIi0gQTT0REREREREREpAkmnoiIiIiIiIiISBNMPBERERERERERkSaYeCIiIiIiIiIiIk0w8URERERERERERJpg4omIiIiIiIiIiDTBxBMREREREREREWmCiSciIiIiIiIiItIEE09ERERERERERKQJJp6IiIiIiIiIiEgTTDwREREREREREZEmmHgiIiIiIiIiIiJNMPFERERERERERESaYOKJiIiIiIiIiIg0wcQTERERERERERFpgoknIiIiIiIiIiLSBBNPRERERERERESkCSaeiIiIiIiIiIhIE0w8ERERERERERGRJph4IiIiIiIiIiIiTTDxREREREREREREmmDiiciibDbu/kRERERERKQtXnkSWZTNZtO7CERERERERJTmmHgiIiIiIiIiIiJNMPFEZFFs8URERERERERaY+KJyLKYeCIiIiIiIiJtMfFEZFFs8URERERERERaY+KJyKKYeCIiIiIiIiKtMfFEZFlMPBEREREREZG2mHgiIiIiIiIiIiJNMPFEZFE2G3d/IiIiIiIi0havPIksimM8ERERERERkdaYeCIiIiIiIiIiIk0w8URkUWzxRERERERERFpj4onIsph4IiIiIiIiIm0x8URkUWzxRERERERERFpj4onIoph4IiIiIiIiIq0x8URERERERERERJpg4onIstjiiYiIiIiIiLTFxBORRbGrHREREREREWmNiScii2LiiYiIiIiIiLTGxBORZTHxRERERERERNpi4onIoho16gAAyMjI1LkkRERERERElK6ceheAiPRx883TMG/eS+je/Vq9i0JERERERERpioknIovKza2Kq66aqHcxiIiIiIiIKI2xqx0REREREREREWki7RJP27dvx4033oi2bduic+fOmDhxIoqLi/UuFhERERERERGR5aRVV7uCggIMHz4cNWvWxMsvv4yjR4/i6aefxvHjx/Hcc8/pXTwiIiIiIiIiIktJq8TTrFmzUFBQgDlz5qBSpUoAAIfDgXHjxmHUqFFo2LChziUkIiIiIiIiIrKOtOpqt3TpUnTu3FlKOgHARRddBJfLhSVLluhYMiIiIiIiIiIi60mrxNPWrVtDWjW5XC7UqVMHW7du1alURERERERERETWlFZd7QoKCpCbmxvyeG5uLk6cOJHUezudxs3RORz2gP8plJVi5HQCdrsdDocAhyO219jtNtn/gTFyOHyPO512ONPqiBE7K20/iWKMlDE+yhgfZYxPqOBzndJ5LBbpfq4z4jaUSH0lmkR/RyPGx2gYIyJKRhqeWkMJggCbzZbw6+12G/Lzy6tYIm3k5mbpXQTDs0KM7HYgOxsoX973Lx7Z2Zkhj9lsQGkpkJeXiYoVVSqkSVlh+0kWY6SM8VHG+ChjfPwinevCncdiYZVznZG2oWTqK5Ek+zsaKT5GxRgRUSLSKvGUm5uLgoKCkMdPnjyZ1MDiXq+AgoLCZIqmKYfDjtzcLBQUFMHj8epdHEOyUowKCoDCQidcLgGCENtr7HYbsrMzUVhYAq838EWFhUBhoQ3Hj7vhTe/QRWSl7SdRjJEyxkcZ46OM8QkVfK5TOo/FIt3PdUbchhKpr0ST6O9oxPgYjVVilJubxVZdRBpIq8RTw4YNQ8ZyKi0txa5duzB48OCk3tvtNv4B1uPxmqKcerJCjNxuwOv1wuMR4PHE+irfCdbrFUIqEx4P4PXa4HZ74XarW1azscL2kyzGSBnjo4zxUcb4+IWe6yKfx2JhlXOdkbahxOorypL9HY0UH6NijIgoEWmVzu3evTtWrlyJY8eOSY99//33KC0tRY8ePXQsGRERERERERGR9aRV4umqq65ChQoVMHr0aCxbtgxz5szBE088gf79+yfV1Y6IiIiIiIiIiOKXVl3tcnNz8f7772PixIm4/fbbUa5cOVx66aUYN26c3kUjIiIiIiIiIrKctEo8AUD9+vXx9ttv610MIiIiIiIiIiLLS6uudkREREREREREZBxMPBERERERERERkSaYeCIiIiIiIiIiIk0w8URERERERERERJpg4omIiIiIiIiIiDTBxBMREREREREREWmCiSciIiIiIiIiItKETRAEQe9CGJ0gCPB6jR0mh8MOj8erdzEMzSox8nqB06cBm833L1Z2ux1eb2h8BMH3r3x5wG7hVLVVtp9kMEbKGB9ljI8yxidQuHNdpPNYLKxwrjPaNpRofUVJMr+j0eJjRFaIkd1ug02tDZKIJEw8ERERERERERGRJtL0ng4REREREREREemNiSciIiIiIiIiItIEE09ERERERERERKQJJp6IiIiIiIiIiEgTTDwREREREREREZEmmHgiIiIiIiIiIiJNMPFERERERERERESaYOKJiIiIiIiIiIg0wcQTERERERERERFpgoknIiIiIiIiIiLSBBNPRERERERERESkCSaeiIiIiIiIiIhIE0w8ERERERERERGRJph4IkpjJSUl+Oabb/QuhmF5vd6A/4nixX1MGfcxIm1xHyMiIjNg4smgfvrpJ6xZswZ79+6VHhMEQccSGcuSJUuwbt06HDlyRHqMla5Ab775Jrp27Yrx48dj3759ehfHcGbOnIk777wTR48ehd1u5/YT5ODBg3oXwfC4jynjPqaM+5iy+fPnY/bs2Vi7di1OnjwJAPB4PDqXyli4jynjPqaM+xgRpZJT7wJQoGXLluGZZ57BqVOnUFxcjKysLIwZMwZDhgyBzWbTu3i6+/XXX3H//ffj1KlTAICcnBxcf/31+M9//gO7nXlUAFi8eDEmTJgAAGjevDm2bNkCt9utc6mMZcOGDXj66adRvnx5zJkzBzfccAO3n3+tXr0aDz74IJo1a4bx48ejWrVqehfJcLiPRcd9LDLuY8pWr16NRx55BIWFhXA6nTh27Bguu+wyPPbYY3A4HHoXzzC4j0XGfUwZ9zEi0gPPUAZRVFSESZMm4cEHH0Tnzp0xefJkvPXWW6hbty6mT5+O9evX611E3RUUFOCVV15Bu3bt8N577+Gdd95B06ZN8eKLL+L999/Xu3i6O3jwIAYNGoSxY8eiV69emDVrFu68804cP34c27dvB8BWYSKxYlWvXj0sXLgQW7ZsAWDt+Hg8HsybNw/jx4/H6dOnsWzZMqxZs8bSMQnGfSx23MdCcR+LbseOHXjyySfRsWNHvP3223j//fcxdOhQLFiwAEuWLNG7eIbCfSwU97HouI8RkV6YeDKIsrIy/Pbbb7j11ltx9913o3Xr1mjVqhVuvfVW7NmzB5mZmXoXUXd79uzB6tWr0bt3bzRp0gRNmzbFww8/jAEDBuC5557DX3/9pXcRdSMIAlatWoUqVapgxowZeOihh1C9enVkZGSgUqVKWLNmDQDwbui/iouLceGFF6Jfv344cOAAPvnkEwDWjk9ZWRk++eQTZGdn46WXXkKrVq3w1ltvBXT3tTLuY/HhPhaK+1h0P/74I/bu3YuBAweiUaNGOPPMMzFgwAB4PB52AQrCfSwU97HouI8RkV6se3YyEK/Xi9zcXNx///0YPHgwsrOzpW51brcbLVu2RKVKlaT1rTrW0/79+1GuXDnUqFFDeqx69eq47rrr0LhxYzz//PMoLS3VsYT6sdls6NOnD6ZOnYpWrVpJFc+WLVsiIyMDx48fB2DdbSdYWVkZVq1ahWuuuQbnnHMOfvrpJyxfvhyANe8WC4KAcuXK4cYbb8Rbb72Fc889F+PGjcP69evx3XffWXa/kuM+Fh/uY4G8Xi/3sRgcP34cTqcTNWvWlB7LzMxEzZo1Ub9+fekx7mfcx4LxPBYb7mNEpBcmnnSwbt06zJo1Cz/99JM0ICQAtG3bFtnZ2QB8d6x+/PFHPPLII9i/fz9GjRqFN998E4cOHYLNZkvrE8KOHTukASHllad27dqhqKhIak4ujqlSu3ZtjBw5EitWrMBPP/0U8rp0FC5GLpcLTqd/2DbxztW5556L1atXA4BlxgnbuHEjVqxYgQ0bNqC4uBiAvxIlCAKcTifOPPNMeL1eDBkyBIIgBNwtTve7fn/++Sc++ugjLF68GLt375a2iy5duqBSpUpwu91o3bo1rrjiCrz//vv4+++/dS5x6gUfpwHA6XRyH/tXpOM0wH0MCD0Gied57mM+4Y7RAHDZZZehoKAAzz77LJYtW4alS5fi+uuvx/79+zFmzBg8/vjj2Lt3b9rXg4DwxyBxX+M+FnoM4nksUHB8xP2F+xgR6YWJpxQqKirCfffdh2uvvRaffvopbr75ZowaNQp//vmntI5Yqfjmm28wcuRIdO7cGbfccgvq16+PDz74AA8++CCA9Ly4KSgowAMPPID+/fvj008/BRDYZNzlcqFLly546623APguAsWT4jnnnIOOHTvi9ddfD3ldOpHHKFqzenH8h8qVK6OgoAAbNmxIWTn1cvToUYwdOxYjRozAhAkTcPnll+Phhx+Wkitutxs2mw0ej0d67JxzzsH555+Pv/76C1OnTsXjjz8uJTfTzZEjR3D77bdj+PDh+OijjzBy5EjcfffdUoVcPP6IyZXbbrsNxcXF+OSTT6QB/dO9Iqp0nBb3NTEGVtzHoh2nAVh6H1M6BgHcx6LFp06dOpg4cSL27duHKVOm4NZbb0W3bt0wadIkXHTRRVixYgVuv/12AOlZDwICj0GffPKJdAz666+/pH3NyvtYrPUgq+5jkY7R4v7CfYyI9JKeV+cG9eOPP+L333/Hyy+/jLfffhvTpk2Dy+XCHXfcIV2wiCfPFi1a4KuvvsJTTz2FK6+8Ek8//TRGjBiBFStWYNWqVXp+DU3s3r0b//3vf/Hzzz8jLy8PK1aswLp16wD4K+o5OTm4+OKLsWPHDulkKrZ6ys3NRY8ePbB79+60rWwFx2jlypVSjMJVosS4tW3bFkePHk37VmDr1q3DbbfdhhMnTmDy5MmYMmUKHnjgAfz666946aWXAPgroiUlJahVqxaOHTsGABg4cCBOnz6NV199FWvWrEGlSpXSLl4rV67E9ddfjxMnTuDVV1/FtGnT8NJLL6GkpAQvv/wygNDKe/Xq1XHrrbfi008/xW+//QYg/SuisRynxRhYbR9TOk4HH4OsuI/Fcgyy8j6mFJ/JkydL6w0cOBAzZ85EvXr1cOmll2L8+PHo1q0bxo4dizvvvBPr16/HokWLAKRnAkF+DHrnnXekY9Dtt98ekNwuLi623D4Wbz0IsNY+FktdGuA+RkT6YOJJY7///jtOnjwJwNeKKSsrCz169JASJc8++yy8Xi9eeukl7NmzR3pd7dq1Ub9+fdjtdumg3759e5QrV056v3Tw+++/o7CwEPv27cOmTZtw/fXXY8KECdiyZQu++eYblJWVBTQZ79ChA84//3w8//zzKCkpQUZGBrxeL5xOJ+rUqQO3241y5crp/K3UFUuMwjWJFi9wmjZtioyMDKnClW4V0d9//x1FRUVYtGgRDhw4gHvvvRcdOnRAw4YNMWLECHTt2hV//fWXdEcd8MXmxIkTqFy5Mj788EMMGzYMbrcbeXl56NmzJ6pVq5Y2reZ+//13lJSU4NChQ2jZsiXGjx+PTp06oXr16rjoootQt25dCIKAsrKysBXMYcOGoVatWpgxYwaOHj0Kt9uNnTt36vBNtJPIcVoQBEvtY/Eeg6y2j8V7DJJL930slvisX78+ID5Hjx7FihUrcOmllyIzM1O6ydSsWTNUqVIFGzduBJA+CYR4jkFinGw2m6X2sUTqQSIr7GOx1KXl8bHaPkZE+kuPM5JBLV26FOPHj8emTZvg9Xpht9ulfueAb3yQM844A48++igWL16MJUuWSAkWQRCkE4TYpHrNmjVwOp2oW7eubt9JTUuXLsVDDz2E7du3o1mzZpg8eTKuu+46XHDBBejSpQt++OEHaaBMsfJUs2ZN/Oc//4HdbsdDDz2EU6dOSc8dOHAATqdT6v6SDqLFaNGiRVKMIrHb7ahWrRo2bNgQcLGcDsT47Nq1C71798aDDz6IFi1awG63S/vZWWedhSNHjiAnJ0d6XVFREdxuN7p27Ypnn30W1113HT788EO0bt0aCxcuxB9//KHXV1KVGJ+tW7eiR48eGD16NJo0aRJQkfR4POjUqRMyMjJCKpjiYK333nsvli5dis8++wyTJ0/GLbfcIo2nZnaJHqflFzlW2MdiOU7LWW0fi+UYVL58+ZDXp/s+lsgxWtyHBEHAjz/+CMDfWnXLli0oLi5Gq1at9PlCGoj3GLR06VJ4PB6UlZWhrKzMMvtYovUgq+xj8R6jrbSPEZExpE/t2IBatWqFAwcOwO12w263o0KFCti9e7c0ravD4YAgCNLJYfbs2di3bx8AX7LJZrPB6/Xi1KlTWLRoEb788ksMHToUDRs21PNrqaZVq1Y4dOgQTp06hdzcXDRp0kSqaI0dOxanT5/GvHnzcPToUWl8HsA3kO8jjzyCuXPn4oEHHsDHH3+MBQsWYMaMGejTp0/ArHdmFy1GhYWFATEKd7evdu3aqFGjBvbv3y9tU+lCjM/x48fRokUL9O7dW3pOrER5vV5kZ2cHzGhTt25dVK1aFb169cLMmTNxyy23oEGDBrjsssvgdDpRUlKS8u+iBTE+J0+eRMWKFXHmmWdKzx05cgRjxozBokWLMHPmTAwdOhQzZswIeL24TbVs2RINGjTAc889hw8++ABXXXUVunTpkuqvo4lkj9OANfaxWI/T4s0Tq+1jsRyDysrKQl6f7vtYIsdom80Gl8uFvn374sMPP8ScOXOwevVqLFy4EC+//DI6dOiA5s2b6/J9tBDvMeijjz7CiRMnUK9ePUvtY4nWg6yyj8V6jJZPSGOVfYyIjIGJJ414PB7k5+fj7LPPxuzZswEA11xzDfbu3YuVK1cGrAcAd911FzZu3IjNmzcD8N2hWbt2LZ566incd999uPvuu9GpUydpwD+zk8dHHK8J8FVEvV4v6tSpgyuuuALLly+X+pmLlVSXy4WLLroIL774IoqKivD666/jv//9L9q3b48HH3wwbZoFJxKj4O8uVjDq1q2LNWvWoLS0NG1aY0SKj0isfO7Zswf5+fmoXr261JKwfv36eOGFF3DfffehefPmcLlcAIC+ffti9uzZOOecc1L6XbSgFJ+ysjLceeed2L17N1544QXccsstaNq0KSZOnIgFCxYEvMfatWulAchHjBiBX375Bddffz0A84/9kOxx2uv1WnIfUzoGORwOeL1ey+9jQORjUPB7pOs+lkx8srOzMWzYMPTr1w8PPPAA7r33Xvz3v/9F69atMXnyZFSuXDml30UriRyDNm/ejDVr1qBOnTp47rnnLLmPxVMPsuI+phQfsaWTVfYxIjKO9Kgd60ycJUPk9Xqlyne7du1QXFyMI0eOoEGDBrjooovwzjvv4NChQwD8J4fGjRujVatWmDdvHgDfyeT06dPYt28fsrKy8Pnnn+PBBx+Ey+Uy3UkyWnxOnz6NI0eOhLxu5MiRyMvLw/z587Ft27aQ5y+55BK8+eabeOedd/DZZ5/hySefNGV8AO1iJF4AX3LJJZgzZ45UMTWbROIj3tlbvXo1WrZsKb1OrJTWqlUroPudSNwnzSTe+GRkZOD555/HRx99hL59+2LgwIG45557cO655+L999+X1nM4HFi2bBkyMjLwxRdf4IEHHkBmZqZ0EWSmJK94XJAfH5I9Ttvt9rTZx6LFJ55jkBiTdNrHEolPpGOQXLrsY1rEp3bt2vjf//6HOXPm4NFHH8WsWbPwxBNPwOVymW77AdStK86fPx+Ab4aydNnHtKoHpcs+pkV80m0fIyJjc+pdADPbunUrJk+ejOLiYgiCgN69e2Po0KHSYNgOhwPVq1fHjh07pIr4jTfeiOHDh+P999/H6NGjUb58edjtdmRmZqJy5coQBAGlpaVwuVzo0qULWrZsifz8fAD+i2aznCRjjc/OnTsDvpP4vMvlwo033ohnnnkGCxcuRP369bF7925kZmaievXqUpzEMa/MFh8gdTE677zzAEB6T7NIND6A7wLo+PHj2LdvH6688koAvgroqVOnUFpaKo2hIbakkzNLi5Vk4lOtWrWAv3Nzc1GvXj2sXbsWJ06cQMWKFQEAN910k3Rh4/F4YLfbTbUN7dy5E6+88grOPvts/Oc//wl4ThxLJpnjtCAIsNlspt3HYo1PosegSPEwyz6WaHzE56MdgwBz72Nax8ftdqNp06Zo2rQpAP953izbD6BNXRGAdAyKxCwx0roeBJh7H9M6PumwjxGROfCokgCv14u33noLV199NQRBQJs2bXD8+HE888wzmDp1qrQOAFx00UXYu3evNJ1ps2bNMGrUKLz33nv44osvpPcsKCjA7t27Ubt2bakiYbfbpaSTWIEzQ1Il3vjs2bNHGgRTfFw84Q0cOBDNmzfH/Pnz8corr2D48OG48847ASCkwmWW+AD6xcgsFS014mOz2XDw4EEUFBTg3HPPBQD8/PPPuOqqqzB69GgACJt0MgM14iPe7QV8x5ddu3bh119/Rbdu3aSkE4CAAX8dDodp9jFBEPDFF19g2LBh+Prrr/Htt9/i4MGDYcdgSuY4HRwPs+xj8cYn0WOQWeIRTI34xHIMAsy5j6UqPsHH6HQ+zyd6DDKrVNWDAHPuY6mKj5n3MSIyFyaeEvD999/jq6++wqhRo/DMM8/gtttuw7vvvou+ffvi/fffx8mTJ5GRkSE1g+3ZsyeWLVsGwFcJv+mmm9CrVy+89tprGDlyJD755BNMnDgRhYWFOP/888N+pplOAsnERzxJygeI7NmzJ9avX4+pU6eiXbt2mDJlim7fTS2MkTI14gMAy5Ytk1p+3XPPPRgxYgQaNGggVdrMSo34iAmB06dPY8OGDZg8eTIyMjIwYMCAsJ9ppmMQAGzbtg3Tp09H/fr1MWzYMOzZs0caQ0W+DwFQ7ThtJsnExwrHIDXiA8R3DDLTPqZHfMxGj7qimehRDzLTPsZ6IhGlG3Pe7tfZ0aNHkZ+fj4EDB0p3USpUqIC2bdti8eLF2Lp1K9q2bQu73Q6Xy4WKFSvi9OnTKCwsRGZmJhwOByZOnIjFixfjvffew8yZM5GZmYmXX345LaYvTTQ+RUVFyMrKkt7nxIkTmDJlCmbOnIn27dvj0UcfDWgKbOZmwIyRsmTjIw4i/scff2Dfvn0YNmwYatSogVmzZqFNmzYArB0fACgsLMTjjz8Or9eLZcuWoW7dunj66ael7cesxK5vYkV8wIABqF27Nvbu3YtFixbh/PPPR8uWLQN+fysdp5ONT7ofg9SKT7oegxif6MRys64YXrLxSfdjEONDRGlLIEXFxcWCIAhCWVmZ4PV6pcc9Ho+07Ha7BUEQhJUrVwrNmjUTtm3bFvD4119/LXTo0EF6jfy1JSUlwqFDh8K+rxloER/R7t27hYceekj46KOPAt5X/jlmwBgp03IfGzt2rNC2bVth7ty5Ae9r9fiI7/PGG28It99+uzB//nzpvcwUG9GRI0eE7du3S7EKZ+HChUKfPn2ERx55JOBxMSbpfJzWIj6idDgGabn9pMMxiPGJLlKMxGOwfNmKdUUt4iNK52MQ40NE6YSJJwWTJk0S+vTpI/0dfJAO/nvmzJlChw4dhEOHDgUc+P/55x/h/PPPF7777ruwr4v0fkanVXwiVajMFh9BYIyi0So+YkXsyJEjiu9ndFrHR16pDfd+ZjBx4kShU6dOwgUXXCBccsklwty5c6XKu8fjCfiODz/8sHDxxRcL33//vfS8KF2P01rFJ12OQVrFJ12OQYxPdNFiZPW6olbxscoxyOrxIaL0wfaVYWzduhVjxozBBx98gJ07d4YM4icS+4qLj+/evRs1atRA1apVA5quut1uNGvWDDt27Ah4XTCz9D3XOj7BzX6Ff/unmyU+AGMUjdbxEccvEmeNMtu0yamKj/i/2bYf0YsvvojFixfjsccew+233442bdrgoYcewnvvvSd1IRBn9gGAa665BhkZGZgzZw5OnTqV1sdpQNv4mP0YBGgbH7MfgwDGJxaxxEhktboioG18rHIMElkxPkSUXjjGk0xhYSGys7OxcOFCLFmyBLfeeiv27t2LN998E4MHD444NbR4cP/ll1/QunXrgOcEQUD16tXhcrmwfv16AObtU61XfMx0kmSMlOkVH7PMrMXtJzoxRkePHsXChQtx4YUX4qKLLgLgm7nH6/Xis88+Q8WKFXHVVVdJsxgBQNOmTdG7d2988cUX+PLLL3H11VejtLRUmvI9IyMjbY7TqY6PWbYhveJjtmMQ4xNZIjGST09vlbpiquOTzscgK8WHiNKX+c5oGpk5cyauu+46AECXLl0wadIk3H777Rg6dCgqVaqEp59+GkDoHQTR0aNHsX37dnTs2BEAUFxcjHnz5uHVV1+V3nPdunXweDymrEgwPtExRsoYH2WMT3QzZ87EtddeC8A3YPHOnTvRrl07AEBJSQkA4I477kDdunUxc+ZMHDx4EHa7HV6vV7pbLA5iPG/ePKxduxYff/wxJk+eDADo2rWrqWPE+ChjfJQxPtElEyMg/Y/TjI8yxoeIrIxHpX9lZ2fD5XJhz549aNGiBfr16wcAOOuss3D55ZdjwYIFWL16NWw2m9QkXG7z5s0oLi5G7dq1sWHDBtx99924++67cejQIQDAJZdcgu+//95Ud/XkGJ/oGCNljI8yxie67OxslCtXDrt374YgCGjatCkWLFgAAMjMzIQgCKhVqxb69++P0tJSTJ8+HQCkLkGAr2vPxRdfjB07dmDUqFGYOHEiTp48CcD8MWJ8lDE+yhif6JKJEZD+x2nGRxnjQ0RWxsTTv6pUqYKCggKcPn1aeszr9SI7OxsXXnghWrRoIbU4cDgcUl9p8f9NmzYhLy8PX3zxBYYMGYKCggJ8++23eOKJJwAAOTk5pr77wPhExxgpY3yUMT7RValSBcePH0dJSQnKly+P+vXrY/v27di4cSMA/zgxF154IZo2bYrVq1dj165d0utLS0uxbt06/Prrr/jnn39w9tln4/vvv8eECRMAmD9GjI8yxkcZ4xNdsjFK9+M046OM8SEiK7Pc0Uk+OK/gm9UPANCtWzccO3YM69atA4CAZqpNmzbFoEGD8Pfff+Pjjz+WXgv4+0yvXLkSR48excqVK/HSSy9hxowZqFu3Lrxer7SuGTA+0TFGyhgfZYxPdAcPHsTRo0cBIKDs3bp1w/Hjx7Fq1SrY7XZceOGF2L9/v3TH2Ol0wu12IysrCz179sTOnTtx4MAB6fVFRUV44YUXsGTJErz55puYOnUqateubboYMT7KGB9ljE90WsUoXY7TjI8yxoeIKJRlEk+nTp3C5MmTMWHCBLz44os4ePAgbDZbQLeViy++GEuWLAEQOttTt27d0L17d7zyyisAfM1eCwoKcOrUKQDAiBEjcN9992Hu3Lno1auX9Fq73W6KAf0Yn+gYI2WMjzLGR5mYhHvllVdw8cUXY/78+QD8iTUxDhdffDF+/PFHAECfPn3QvHlzLFy4EMuXLwfgT+z17dsXJSUlOHz4sPQZOTk5GD9+PFatWoVu3bpJ72uGGDE+yhgfZYxPdKmI0fXXX2/a4zTjo4zxISJSZonE0wcffIDu3btj5cqV2L17N6ZPn45Ro0bhzz//BOC/wKtSpQo8Ho/UVxrwnzBq1qyJyy+/HG63GxMnTsS6deswfvx4LF26FF6vFx07dsQNN9wAwH/SMMtJgPGJjjFSxvgoY3yiE5NwixcvRlFREZYuXYotW7YAgDSrD+CLkdfrxf79+wEAY8eORVFREd577z0cPXoULpcLALB+/Xo4nc6AsS4cDgcaNWoEwHwxYnyUMT7KGJ/oUhGjDh06mPY4zfgoY3yIiJSldeLJ4/Hgtddew3vvvYe77roL06ZNw7Rp0/DNN99g8+bN+P333wEAbrcbANCuXTup+SsQ2DwWAFq3bo3zzjsPM2bMwFVXXYVt27ahTZs2If2pzdK/mvGJjjFSxvgoY3xi5/F4UFpaimbNmuHqq6/GkiVL8MMPP6C0tBQ2my0kRk6nEwDQokULDB8+HDt37sS9996LX3/9FTt27MDXX3+NWrVqoUOHDmE/z2wxYnyUMT7KGJ/oGCNljI8yxoeIKAohzc2dO1d45ZVXhJMnTwqCIAgej0cQBEHo27ev8OKLL4as36dPH2HGjBmCIAiC1+uVHt+9e7cwdepUoV27dsKFF14oLFiwQPvCpwDjEx1jpIzxUcb4xOeCCy4Q/vrrL+GRRx4RunXrJqxZsyZkHXmMBEEQSkpKhB9//FG44IILhI4dOwrdu3cXunbtKixZsiSVRU8JxkcZ46OM8YmOMVLG+ChjfIiIwnPqnfjSWs+ePdG3b1/pb7vdjg0bNiAjIwNdunTBwYMHUb16dQBAQUEBzj77bGzfvh1lZWXIyMiQXrdt2za89NJLGDNmDG6//Xbpca/Xa+q7DoxPdIyRMsZHGeMTG6/XC4/Hg3r16uHIkSO488478emnn+Krr75CvXr1UKlSJQiCgNOnT4fEyOVyoUuXLvj4449x+PBh7Nu3DxdccIHeX0lVjI8yxkcZ4xMdY6SM8VHG+BARKTP/1cq/5syZg/nz56OsrAyAv4tKVlYWAH9f6Pfffx9DhgzBoUOHcNddd+Gyyy7D1KlTUVpaitzcXGRnZ2PHjh3IyMgImH2qe/fuWLVqlXTBJz5nlgs+xic6xkgZ46OM8YkuOEZydrsdGRkZ2LJlC4qKilCpUiXcdNNN+Oyzz7Bp0yYAvunac3JyIsaoUqVKaNq0qVRhlz9nBoyPMsZHGeMTHWOkjPFRxvgQESVBn4ZW6tm1a5cwcuRI4ayzzhIGDRokbNu2LeK6mzdvFm655RZh+vTpwtatW4VDhw4JDzzwgNCzZ09h1qxZgiAIwm+//Sa0aNFCOHLkiCAI/q4u4v9ut1vjb6Quxic6xkgZ46OM8Ykulhi53W6hpKREGDFihDB37lzp8a5duwpXXHGF0KJFC+Hpp58WBEEQfv/997AxMivGRxnjo4zxiY4xUsb4KGN8iIiSZ55b5WEcPXoUU6dOxd9//41rrrkGW7Zswfz581FSUhJ2/caNG+P555/Htddei/r166Nq1aoYO3YsHA4HNm/eDI/Hg2rVqqFt27b49ttvAfhnixD/l88uYXSMT3SMkTLGRxnjE12sMXI4HHA4HNi0aRPy8/MBAIcPH0bFihXx119/oVWrVhg0aBAA36xA4WJkRoyPMsZHGeMTHWOkjPFRxvgQEanD1GM8VapUCSdPnsQ111yD4cOHIyMjAzNmzEDXrl3RunXrsK/JyckB4D/In3HGGfB4PCgsLITD4UBOTg5OnDiBEydOwO12S7NOmBHjEx1jpIzxUcb4RBdrjARBQFFREZo3b44DBw7g0UcfxezZs9G1a1cAQElJidTtoHz58mkTI8ZHGeOjjPGJjjFSxvgoY3yIiFSiY2uruIlNUuVKSkqk5UOHDgmdO3cWHnzwQeHEiRNR36+srEz44osvhJ49ewo///yz9PjcuXPDfpbRMT7RMUbKGB9ljE90icRI3s2gY8eOwllnnSX069dP+PTTTwVBEIQNGzYIZ511lvDss88Kp0+fFgTBvDFifJQxPsoYn+gYI2WMjzLGh4hIG6ZIPP3222/CVVddJQwdOlS4+eabha+++irgeY/HI01RPmPGDKFFixbCDz/8EPH9jhw5ImzcuFF46623hF69egkPP/ywcPLkSVOOnSIIjE8sGCNljI8yxie6ZGNUWloqCIIgLFq0SHjllVeEffv2Bbz+5ZdfFn7//Xdtv4SGGB9ljI8yxic6xkgZ46OM8SEi0pZNEP6desmgVq5cibvuugs9evRAixYtMH/+fKxfvx4333wzbr311pDmqWVlZbjyyitRsWJFTJo0SZqmXLRq1Sp8/PHHWL9+PY4fP47Ro0dj2LBhqfxKqmJ8omOMlDE+yhif6NSOkTjFNAB4PB7TjWsVjPFRxvgoY3yiY4yUMT7KGB8iohTQO/MVzfjx44Wrr75aKCgoEARBEE6dOiW89tprQvPmzYXPP/9cusMgb+a6dOlS4ayzzpJmiRIEfzPZw4cPC59//rnwf//3f9JrBUGQ7mKYDeMTHWOkjPFRxvhEp3aMIs3wY9aZfxgfZYyPMsYnOsZIGeOjjPEhItKeoUez83g82L9/P6pUqYIKFSoAALKzs3Hrrbdi7dq1mDp1Kho0aIDWrVtLA/UKgoBu3bqhT58+ePfdd9GqVSt4vV4sX74cQ4cORZUqVXDZZZfBbrdLn+FwOKS/zYTxiY4xUsb4KGN8olM7RldddRVyc3PDfpYZZ/5hfJQxPsoYn+gYI2WMjzLGh4goNQxzpbNt2zZ8/PHHWLBgATZs2ADAd2AvKytDWVkZjh8/Lj0GAI8//jj27NmD+fPno7CwUHpOPKjfcccdOHjwIB5//HFcd911mDNnjvQe8gs8szR/ZXyiY4yUMT7KGJ/oUhkjM2J8lDE+yhif6BgjZYyPMsaHiEhH6jeiik9xcbHw6KOPCm3bthWuvPJKoWXLlsJ5550nzJ07VxAEQXjjjTeEc845R9i0aZP0mrKyMkEQBOGZZ54RunTpImzbti3gPQ8fPizMmTNHaNmypdCuXTvhjTfeSN0XUhnjEx1jpIzxUcb4RMcYKWN8lDE+yhif6BgjZYyPMsaHiEh/uiaeDhw4INxzzz3CkCFDhB9++EE4dOiQsHbtWmHUqFFC586dhZKSEuGff/4ROnToIDzzzDNS32hxLJS9e/cKbdq0ET7//HPp8aKiIuG5554TzjrrLGHcuHHStKXy15kF4xMdY6SM8VHG+ETHGCljfJQxPsoYn+gYI2WMjzLGh4jIGHRNPP3xxx/ChRdeKHz99dfSnQVBEISffvpJaNmypTSV6csvvyy0bds2YBpSr9crnDx5UvjPf/4jPPDAAwHv+9133wmbN2+W/jbrFOWMT3SMkTLGRxnjEx1jpIzxUcb4KGN8omOMlDE+yhgfIiJj0HWMp+bNm+O+++5Dv3794HQ64fV6AQBVq1aFy+WS+lhfeeWVqF27Np5//nns2LEDgG+AvoyMDOzfv1+axtTtdgMAevfujcaNG8Pr9UIQBFONoSLH+ETHGCljfJQxPtExRsoYH2WMjzLGJzrGSBnjo4zxISIyBl0TT3a7Hb179wYAeL1e2O12CIKAChUqoKysDFlZWQCA6tWrY+LEiVi7di2ef/55bNmyBadOncLKlSuRmZmJdu3aAQCcTmfI+5t5BgnGJzrGSBnjo4zxiY4xUsb4KGN8lDE+0TFGyhgfZYwPEZExOKOvkhriLE82mw3bt2+H1+tF27ZtAfimOm3dujUee+wxfPzxxxgwYABatGiBjRs3YuDAgejcubOOJU8Nxic6xkgZ46OM8YmOMVLG+ChjfJQxPtExRsoYH2WMDxGRfmyC2MbUQF5++WV8/fXX+Oqrr5CRkREw9fiJEyewfPlyHDhwAO3bt0ebNm10LKk+GJ/oGCNljI8yxic6xkgZ46OM8VHG+ETHGCljfJQxPkREqWWYFk/4//buF6eROA7j8Es6CaqpQxWD4xDge4AaDK5HQKA5A2fgOpA0OExtTV1N6Qqyu2Gz+f7WTDubPo+eJs3HTPLOv3w9N911XV5fX3N1dZXz8/MkyXa7zWq1ynQ6zWQyyWw2+/Wbz8/PnJ2dncRtrvq0aVTTp6ZPm0Y1fWr61PRp06imT00fgOM46jue/tR1Xfb7fd7f33Nzc5MkeXt7y2KxyP39fdbr9bfj9/v9ST1brU+bRjV9avq0aVTTp6ZPTZ82jWr61PQBOI5BDU9Jslwus9vtMh6P8/T0lLu7u3Rdl5eXl1xeXn479hRPAvq0aVTTp6ZPm0Y1fWr61PRp06imT00fgMMb1KN2SfLx8ZHNZpPHx8dcXFzk+fk5t7e3SX5/jeKU6dOmUU2fmj5tGtX0qelT06dNo5o+NX0ADm9ww9P19XXG43EeHh4yn8+TfN3mmsSJIPr8C41q+tT0adOopk9Nn5o+bRrV9KnpA3B4g/yq3c8X/yWuPPyNPm0a1fSp6dOmUU2fmj41fdo0qulT0wfgsAY5PCXJbrfLaDQ69t8YLH3aNKrpU9OnTaOaPjV9avq0aVTTp6YPwOEMdngCAAAA4P/mvlIAAAAAemF4AgAAAKAXhicAAAAAemF4AgAAAKAXhicAAAAAemF4AgAAAKAXhicAAAAAemF4AgAAAKAXhicAAAAAemF4AgAAAKAXPwBp/rl6ilKyuQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "\n", + "anomalies = [\n", + " [\"2013-12-15 17:50:00.000000\", \"2013-12-17 17:00:00.000000\"],\n", + " [\"2014-01-27 14:20:00.000000\", \"2014-01-29 13:30:00.000000\"],\n", + " [\"2014-02-07 14:55:00.000000\", \"2014-02-09 14:05:00.000000\"]\n", + "]\n", + "\n", + "plt.figure(figsize=(12,7))\n", + "line, = plt.plot(time_series.index, time_series['value'], linestyle='solid', color='black', label='Temperature')\n", + "\n", + "# Highlight anomalies\n", + "ctr = 0\n", + "for timeframe in anomalies:\n", + " ctr += 1\n", + " plt.axvspan(pd.to_datetime(timeframe[0]), pd.to_datetime(timeframe[1]), color='blue', alpha=0.3, label=f'Anomaly {ctr}')\n", + "\n", + "# Formatting x-axis for better readability\n", + "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y/%m/%d')) \n", + "plt.gca().xaxis.set_major_locator(mdates.DayLocator(interval=7)) \n", + "plt.gcf().autofmt_xdate() # Rotate & align the x labels for a better view\n", + "\n", + "plt.title('Temperature Over Time', fontsize=20, fontweight='bold', pad=30)\n", + "plt.ylabel('Temperature')\n", + "# Add legend to the right\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "from merlion.utils import TimeSeries\n", + "\n", + "train_data = TimeSeries.from_pd(time_series[time_series.index < pd.to_datetime('2013-12-15')])\n", + "test_data = TimeSeries.from_pd(time_series[time_series.index >= pd.to_datetime('2013-12-15')])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. Visualize the test/train split" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "anomalies = [\n", + " [\"2013-12-15 17:50:00.000000\", \"2013-12-17 17:00:00.000000\"],\n", + " [\"2014-01-27 14:20:00.000000\", \"2014-01-29 13:30:00.000000\"],\n", + " [\"2014-02-07 14:55:00.000000\", \"2014-02-09 14:05:00.000000\"]\n", + "]\n", + "\n", + "plt.figure(figsize=(12,7))\n", + "line, = plt.plot(time_series.index, time_series['value'], linestyle='solid', color='black', label='Temperature')\n", + "\n", + "# Highlight anomalies\n", + "ctr = 0\n", + "for timeframe in anomalies:\n", + " ctr += 1\n", + " plt.axvspan(pd.to_datetime(timeframe[0]), pd.to_datetime(timeframe[1]), color='blue', alpha=0.3, label=f'Anomaly {ctr}')\n", + "\n", + "# Add vertical line for train/test split\n", + "plt.axvspan(pd.to_datetime('2013-12-03'), pd.to_datetime('2013-12-15'), color='red', alpha=0.3, linewidth=2, label=\"Train data\")\n", + "\n", + "# Formatting x-axis for better readability\n", + "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y/%m/%d')) \n", + "plt.gca().xaxis.set_major_locator(mdates.DayLocator(interval=7)) \n", + "plt.gcf().autofmt_xdate() # Rotate & align the x labels for a better view\n", + "\n", + "plt.title('Temperature Over Time', fontsize=20, fontweight='bold', pad=30)\n", + "plt.ylabel('Temperature')\n", + "# Add legend to the right\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. Training the model" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture\n", + "from merlion.models.defaults import DefaultDetectorConfig, DefaultDetector\n", + "model = DefaultDetector(DefaultDetectorConfig())\n", + "model.train(train_data=train_data)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": { + "nbreg": { + "diff_ignore": [ + "/outputs" + ] + } + }, + "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", + "
anom_score
time
2013-12-16 20:05:003.153673
2014-02-03 13:15:003.209799
2014-02-09 13:10:003.260402
\n", + "
" + ], + "text/plain": [ + " anom_score\n", + "time \n", + "2013-12-16 20:05:00 3.153673\n", + "2014-02-03 13:15:00 3.209799\n", + "2014-02-09 13:10:00 3.260402" + ] + }, + "execution_count": 87, + "metadata": { + "nbreg": { + "diff_ignore": [ + "/outputs" + ] + } + }, + "output_type": "execute_result" + } + ], + "source": [ + "test_pred = model.get_anomaly_label(time_series=test_data)\n", + "test = test_pred.to_pd()\n", + "test[test[\"anom_score\"] > 0]" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "time\n", + "2013-12-15 00:00:00 0.0\n", + "2013-12-15 00:05:00 0.0\n", + "2013-12-15 00:10:00 0.0\n", + "2013-12-15 00:15:00 0.0\n", + "2013-12-15 00:20:00 0.0\n", + " ... \n", + "2014-02-19 16:05:00 0.0\n", + "2014-02-19 16:10:00 0.0\n", + "2014-02-19 16:15:00 0.0\n", + "2014-02-19 16:20:00 0.0\n", + "2014-02-19 16:25:00 0.0\n", + "Freq: 5T, Name: anom_score, Length: 19206, dtype: float64" + ] + }, + "execution_count": 123, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "fig, ax = model.plot_anomaly(time_series=test_data, filter_scores = True)\n", + "# Change the title\n", + "ax.set_title('Temperature over time with anomalies', fontsize=20, fontweight='bold', pad=20)\n", + "ax.set_ylabel('Temperature')\n", + "\n", + "# Show the plot\n", + "plt.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "crate", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/topic/machine-learning/timeseries-basics/tracking_merlion.py b/topic/machine-learning/mlops-mlflow/tracking_merlion.py similarity index 93% rename from topic/machine-learning/timeseries-basics/tracking_merlion.py rename to topic/machine-learning/mlops-mlflow/tracking_merlion.py index f17c9a4d..603b7712 100644 --- a/topic/machine-learning/timeseries-basics/tracking_merlion.py +++ b/topic/machine-learning/mlops-mlflow/tracking_merlion.py @@ -30,9 +30,7 @@ def provision_data(): """ Download Numenta Anomaly Benchmark data, and load into database. """ - data = pd.read_csv( - "https://raw.githubusercontent.com/numenta/NAB/master/data/realKnownCause/machine_temperature_system_failure.csv" - ) + data = pd.read_csv("https://github.com/crate/cratedb-datasets/raw/main/timeseries/anomaly/nab-machine-failure.csv") # Connecting to CrateDB. conn = connect_database() @@ -53,14 +51,15 @@ def provision_data(): # Create the table if it doesn't exist. cursor.execute( "CREATE TABLE IF NOT EXISTS machine_data " - "(timestamp TIMESTAMP, temperature DOUBLE)" + "(timestamp TIMESTAMP, temperature DOUBLE);" ) # Insert the data in chunks. for chunk in chunks: cursor.executemany( - "INSERT INTO machine_data (timestamp, temperature) VALUES (?, ?)", + "INSERT INTO machine_data (timestamp, temperature) VALUES (?, ?);", list(chunk.itertuples(index=False, name=None)), ) + cursor.execute("REFRESH TABLE machine_data;") def read_data() -> pd.DataFrame: @@ -73,10 +72,10 @@ def read_data() -> pd.DataFrame: cursor.execute( """SELECT DATE_BIN('5 min'::INTERVAL, "timestamp", 0) AS timestamp, - max(temperature) as value + MAX(temperature) AS value FROM machine_data - group by timestamp - order by timestamp asc""" + GROUP BY timestamp + ORDER BY timestamp ASC;""" ) data = cursor.fetchall() diff --git a/topic/machine-learning/timeseries-basics/requirements.txt b/topic/machine-learning/timeseries-basics/requirements.txt deleted file mode 100644 index 51e8c377..00000000 --- a/topic/machine-learning/timeseries-basics/requirements.txt +++ /dev/null @@ -1,3 +0,0 @@ -mlflow-cratedb -pydantic<1 -salesforce-merlion From dda4d0b25c94fa24afb35de9c80047889950ca70 Mon Sep 17 00:00:00 2001 From: Andreas Motl Date: Tue, 7 Nov 2023 23:06:32 +0100 Subject: [PATCH 2/2] Dependencies: Use Git ref for langchain and mlflow-cratedb --- topic/machine-learning/llm-langchain/requirements.txt | 2 +- topic/machine-learning/mlops-mlflow/requirements.txt | 6 +++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/topic/machine-learning/llm-langchain/requirements.txt b/topic/machine-learning/llm-langchain/requirements.txt index fa93608d..a3f2b2d2 100644 --- a/topic/machine-learning/llm-langchain/requirements.txt +++ b/topic/machine-learning/llm-langchain/requirements.txt @@ -9,5 +9,5 @@ requests-cache<2 unstructured<0.11 # Development. -langchain[cratedb,openai] @ git+https://github.com/crate-workbench/langchain.git@cratedb#subdirectory=libs/langchain +langchain[cratedb,openai] @ git+https://github.com/crate-workbench/langchain.git@testing#subdirectory=libs/langchain pueblo[nlp] @ git+https://github.com/pyveci/pueblo.git@main diff --git a/topic/machine-learning/mlops-mlflow/requirements.txt b/topic/machine-learning/mlops-mlflow/requirements.txt index 77a8bab2..e825a8c0 100644 --- a/topic/machine-learning/mlops-mlflow/requirements.txt +++ b/topic/machine-learning/mlops-mlflow/requirements.txt @@ -1,3 +1,7 @@ -mlflow-cratedb==2.7.1 +# Real. +# mlflow-cratedb==2.7.1 pydantic<1 salesforce-merlion>=2,<3 + +# Development. +mlflow-cratedb @ git+https://github.com/crate-workbench/mlflow-cratedb.git@testing