From 37b4c17f5983de3e357f98f68d599571a3a06024 Mon Sep 17 00:00:00 2001 From: Andras Schmelczer Date: Wed, 28 Oct 2026 12:50:43 +0000 Subject: [PATCH] Modernise docs --- docs/examples/scibert/additional-files.md | 43 +- docs/examples/scibert/data.ipynb | 2185 +++++++++++++- docs/examples/scibert/deploy.ipynb | 296 +- docs/examples/scibert/index.md | 4 +- docs/examples/scibert/train.ipynb | 485 ++-- docs/examples/simple-mag/train.ipynb | 3136 +++++++++++++++++---- docs/examples/simple/data.ipynb | 280 +- docs/examples/simple/deploy.ipynb | 224 +- docs/examples/simple/stacked-bars.ipynb | 82 +- docs/examples/simple/train.ipynb | 3118 ++++++++++++++++---- docs/how-to-guides/install.md | 30 +- docs/how-to-guides/use-service.md | 39 +- docs/index.md | 6 +- docs/surveys/surveys.ipynb | 1198 +------- docs/tutorial/deploy.ipynb | 186 +- docs/tutorial/train.ipynb | 260 +- 16 files changed, 8275 insertions(+), 3297 deletions(-) diff --git a/docs/examples/scibert/additional-files.md b/docs/examples/scibert/additional-files.md index 883c7d8..852cd2d 100644 --- a/docs/examples/scibert/additional-files.md +++ b/docs/examples/scibert/additional-files.md @@ -37,15 +37,19 @@ numpy==1.23.0 ## Dockerfile ```Dockerfile title="Dockerfile" +# syntax=docker/dockerfile:1 FROM schmelczera/great-ai:v0.1.6 +COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv + COPY requirements.txt ./ -RUN pip install --no-cache-dir --requirement requirements.txt +RUN uv pip install --system --no-cache --requirement requirements.txt + +RUN --mount=type=secret,id=config,target=/run/secrets/config.ini,required=true \ + large-file --backend s3 --secrets /run/secrets/config.ini --cache scibert-highlights COPY . ./ -RUN large-file --backend s3 --secrets s3.ini --cache scibert-highlights - CMD ["deploy.ipynb"] ``` @@ -59,6 +63,9 @@ CMD ["deploy.ipynb"] data .gitignore .env +config.ini +s3.ini +mongo.ini .vscode .dockerignore Dockerfile @@ -73,3 +80,33 @@ README.md !!! Note ".gitignore" A very similar looking `.gitignore` file should also be present. + +## Build and run with model caching + +Use [Docker BuildKit secrets](https://docs.docker.com/build/building/secrets/) to make the build configuration available to the model-cache command without copying credentials into the image. The application's `config.ini` above also refers to runtime environment variables such as `MONGO_CONNECTION_STRING`. For the build, prepare a separate `config.ini` outside the project, for example at `/secure/build/config.ini`, containing only these four S3 settings with your actual values: + +```ini title="/secure/build/config.ini" +AWS_REGION_NAME = eu-west-2 +AWS_ACCESS_KEY_ID = YOUR_BUILD_ACCESS_KEY_ID +AWS_SECRET_ACCESS_KEY = YOUR_BUILD_SECRET_ACCESS_KEY +LARGE_FILES_BUCKET_NAME = my-orgs-large-files +``` + +Use concrete values here: the build container does not inherit your shell's environment for resolving `ENV:` entries. After uploading `scibert-highlights` in the training notebook, build from the project's top-level directory: + +```sh +DOCKER_BUILDKIT=1 docker build --no-cache --progress=plain \ + --secret id=config,src=/secure/build/config.ini --tag scibert-highlights . +``` + +`--no-cache` makes Docker run the model-cache step even if a previous image layer exists. The model stays in the image, while the secret mount is removed after that step. The `.dockerignore` above also prevents the application's `config.ini` from being included by `COPY . ./`. + +At runtime, mount the application's `config.ini` and pass the environment variables it references from your configured shell: + +```sh +docker run --rm -p 6060:6060 \ + --mount type=bind,source="$(pwd)/config.ini",target=/app/config.ini,readonly \ + --env MONGO_CONNECTION_STRING --env AWS_REGION_NAME \ + --env AWS_ACCESS_KEY_ID --env AWS_SECRET_ACCESS_KEY \ + --env LARGE_FILES_BUCKET_NAME scibert-highlights +``` diff --git a/docs/examples/scibert/data.ipynb b/docs/examples/scibert/data.ipynb index e3368d3..4487b65 100644 --- a/docs/examples/scibert/data.ipynb +++ b/docs/examples/scibert/data.ipynb @@ -2,89 +2,158 @@ "cells": [ { "cell_type": "markdown", + "id": "cell-0", "metadata": {}, "source": [ "# Explore data and feasibility of approach\n", "\n", - "![screenshot fo the annotator tool](https://great-ai.scoutinscience.com/media/annotator.png)\n", + "The original annotations are proprietary. This notebook defaults to 60\n", + "clearly synthetic sentences with two simulated annotators so the entire\n", + "training/deployment workflow can run locally without credentials.\n", + "These data and their scores demonstrate execution only.\n", "\n", - "We had asked our clients and in-house experts to annotate sentences using a rigorous guideline. The aim is to decide on which sentences they would like to see in a summary for a paper.\n", + "To use your own JSON annotation files (each maps sentences to binary\n", + "labels), set `GREAT_AI_ANNOTATIONS_DIR` to their directory before starting\n", + "Jupyter. No private data or cloud configuration is included in this repo." + ] + }, + { + "cell_type": "markdown", + "id": "6da6bb8a", + "metadata": {}, + "source": [ + "## Local setup\n", "\n", - "The results are in JSON format, each annotator has a separate file. Let's load them." + "Use Python 3.12 or 3.13 and install this checkout with `uv pip install --editable '.[notebooks]'`.\n", + "See **Run notebooks locally** in the repository README for the kernel, execution order,\n", + "and full-data options. Generated artifacts stay under `.cache/notebooks/`.\n" ] }, { "cell_type": "code", "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "data/evaluation-experiment-2-stage #1-sa6a0y.json\n", - "data/evaluation-experiment-2-stage #1-2m6dmb.json\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "import json\n", - "\n", - "annotations = []\n", - "for p in Path(\"data\").glob(\"*.json\"):\n", - " with open(p, encoding=\"utf-8\") as f:\n", - " print(p)\n", - " annotations.append(json.load(f))\n", - "\n", - "evaluations = {\n", - " sentence: [\n", - " annotation[sentence] for annotation in annotations if sentence in annotation\n", - " ]\n", - " for sentence in {\n", - " sentence for annotation in annotations for sentence in annotation.keys()\n", - " }\n", - "}\n", - "\n", - "X = [s for s in evaluations.keys()]\n", - "y = [int(sum(e) > 0) for e in evaluations.values()]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Save the compiled and processed data for later use using LargeFileS3." - ] - }, - { - "cell_type": "code", - "execution_count": 2, + "id": "4bf6cce1", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[38;5;39mCopying file for summary-train-dataset-small-0\u001b[0m\n", - "\u001b[38;5;39mCompressing summary-train-dataset-small-0\u001b[0m\n", - "\u001b[38;5;39mUploading summary-train-dataset-small-0 to S3 as summary-train-dataset-small/0\u001b[0m\n", - "\u001b[38;5;39mUploading summary-train-dataset-small-0.tar.gz 0.04/0.04 MB (100.0%)\u001b[0m\n" + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.11): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook artifacts: /Users/schmelczer/Projects/great-ai/.cache/notebooks/scibert\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", + ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", + "\n", + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"scibert\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using synthetic demo annotations; scores are not research results.\n" ] } ], "source": [ - "from great_ai.large_file import LargeFileS3\n", "import json\n", + "from notebook_support import demo_annotations\n", "\n", - "LargeFileS3.configure_credentials_from_file(\"config.ini\")\n", + "annotation_dir = os.environ.get(\"GREAT_AI_ANNOTATIONS_DIR\")\n", + "if annotation_dir:\n", + " annotations = [\n", + " json.loads(p.read_text(encoding=\"utf-8\"))\n", + " for p in sorted(Path(annotation_dir).expanduser().glob(\"*.json\"))\n", + " ]\n", + " if not annotations:\n", + " raise ValueError(f\"No annotation JSON files found in {annotation_dir}\")\n", + "else:\n", + " annotations = demo_annotations()\n", + " print(\"Using synthetic demo annotations; scores are not research results.\")\n", "\n", - "with LargeFileS3(\"summary-train-dataset-small\", \"w\", encoding=\"utf-8\") as f:\n", + "evaluations = {\n", + " sentence: [\n", + " annotation[sentence] for annotation in annotations if sentence in annotation\n", + " ]\n", + " for sentence in sorted(\n", + " {sentence for annotation in annotations for sentence in annotation}\n", + " )\n", + "}\n", + "X = list(evaluations)\n", + "y = [int(sum(e) > 0) for e in evaluations.values()]" + ] + }, + { + "cell_type": "markdown", + "id": "cell-4", + "metadata": {}, + "source": [ + "Save the processed dataset using local versioned storage for the training notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cell-5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;39mFetching cached versions of summary-train-dataset-small\u001b[0m\n", + "\u001b[38;5;39mFetching cached versions of summary-train-dataset-small\u001b[0m\n", + "\u001b[38;5;39mFetching cached versions of summary-train-dataset-small\u001b[0m\n" + ] + } + ], + "source": [ + "from great_ai.large_file import LargeFileLocal\n", + "\n", + "with LargeFileLocal(\"summary-train-dataset-small\", \"w\", encoding=\"utf-8\") as f:\n", " json.dump((X, y), f)" ] }, { "cell_type": "markdown", + "id": "cell-6", "metadata": {}, "source": [ "Filter out sentences which don't have enough annotations." @@ -92,7 +161,8 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, + "id": "cell-7", "metadata": {}, "outputs": [], "source": [ @@ -102,6 +172,7 @@ }, { "cell_type": "markdown", + "id": "cell-8", "metadata": {}, "source": [ "Calculate [Cohen's kappa](https://en.wikipedia.org/wiki/Cohen%27s_kappa).\n", @@ -111,28 +182,30 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, + "id": "cell-9", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "0.3546448712421808" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "0.8\n" + ] } ], "source": [ "import sklearn.metrics\n", "\n", - "sklearn.metrics.cohen_kappa_score(y1, y2)" + "if y1:\n", + " print(sklearn.metrics.cohen_kappa_score(y1, y2))\n", + "else:\n", + " print(\"No sentences have exactly two annotations; kappa is unavailable.\")" ] }, { "cell_type": "markdown", + "id": "cell-10", "metadata": {}, "source": [ "Can we train anything on this data?\n", @@ -142,7 +215,8 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, + "id": "cell-11", "metadata": {}, "outputs": [], "source": [ @@ -152,16 +226,17 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, + "id": "cell-12", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([0.79, 0.75, 0.77, 0.69, 0.77])" + "array([0.41666667, 0.25 , 0.16666667, 0.41666667, 0.5 ])" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -173,11 +248,10 @@ "from sklearn.feature_extraction.text import TfidfVectorizer\n", "from sklearn.model_selection import cross_val_score\n", "\n", - "\n", "model = Pipeline(\n", " steps=[\n", " (\"vectorizer\", TfidfVectorizer(sublinear_tf=True, min_df=3, max_df=0.3)),\n", - " (\"classifier\", LinearSVC()),\n", + " (\"classifier\", LinearSVC(random_state=42)),\n", " ]\n", ") # baseline model\n", "\n", @@ -186,6 +260,7 @@ }, { "cell_type": "markdown", + "id": "cell-13", "metadata": {}, "source": [ "The cross-validation shows promising accuracies. But accuracy isn't everything, therefore, we should investigate the accuracy metrics." @@ -193,37 +268,1949 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, + "id": "cell-14", "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
Pipeline(steps=[('vectorizer',\n",
+       "
Pipeline(steps=[('vectorizer',\n",
        "                 TfidfVectorizer(max_df=0.3, min_df=3, sublinear_tf=True)),\n",
-       "                ('classifier', LinearSVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. 
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
"
+       "                ('classifier', LinearSVC(random_state=42))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "Pipeline(steps=[('vectorizer',\n", " TfidfVectorizer(max_df=0.3, min_df=3, sublinear_tf=True)),\n", - " ('classifier', LinearSVC())])" + " ('classifier', LinearSVC(random_state=42))])" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y, test_size=0.2, random_state=42, stratify=y\n", + ")\n", "model.fit(X_train, y_train)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, + "id": "cell-15", "metadata": {}, "outputs": [ { @@ -232,25 +2219,23 @@ "text": [ " precision recall f1-score support\n", "\n", - " False 0.78 0.78 0.78 51\n", - " True 0.78 0.78 0.78 49\n", + " False 0.00 0.00 0.00 5\n", + " True 0.58 1.00 0.74 7\n", "\n", - " accuracy 0.78 100\n", - " macro avg 0.78 0.78 0.78 100\n", - "weighted avg 0.78 0.78 0.78 100\n", + " accuracy 0.58 12\n", + " macro avg 0.29 0.50 0.37 12\n", + "weighted avg 0.34 0.58 0.43 12\n", "\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -258,7 +2243,7 @@ "y_predicted = model.predict(X_test)\n", "print(\n", " sklearn.metrics.classification_report(\n", - " [y > 0 for y in y_test], [y > 0 for y in y_predicted]\n", + " [y > 0 for y in y_test], [y > 0 for y in y_predicted], zero_division=0\n", " )\n", ")\n", "sklearn.metrics.ConfusionMatrixDisplay.from_predictions(\n", @@ -272,17 +2257,19 @@ }, { "cell_type": "markdown", + "id": "cell-16", "metadata": {}, "source": [ - "We get an F1-score of 0.78 without any hyperparameter-optimisation; this task may be feasible to solve with AI.\n", + "The report above describes the active dataset. The synthetic demo cannot\n", + "establish the feasibility or quality of a real summarisation system.\n", "\n", - "Next: [Part 2](https://great-ai.scoutinscience.com/examples/scibert/train)" + "Next: [Part 2](train.ipynb)" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", + "display_name": ".venv (3.13.5)", "language": "python", "name": "python3" }, @@ -296,15 +2283,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } + "version": "3.13.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } diff --git a/docs/examples/scibert/deploy.ipynb b/docs/examples/scibert/deploy.ipynb index 5b7d803..4f1363b 100644 --- a/docs/examples/scibert/deploy.ipynb +++ b/docs/examples/scibert/deploy.ipynb @@ -2,58 +2,93 @@ "cells": [ { "cell_type": "markdown", + "id": "cell-0", "metadata": {}, "source": [ "# Create an inference function\n", "\n", - "Everything is ready to wrap the previously trained model and deploy it. \n", + "Run `data.ipynb` and `train.ipynb` first in the same local/full mode.\n", + "This notebook loads their local model and tokenizer; no S3 credentials,\n", + "MongoDB server, or model downloads are needed for the default demo.\n", + "The tiny demo model's scores have no scientific interpretation." + ] + }, + { + "cell_type": "markdown", + "id": "85c2ee1d", + "metadata": {}, + "source": [ + "## Local setup\n", "\n", - "First, we need to configure the LargeFileBackend, the TracingDatabase and GreatAI." + "Use Python 3.12 or 3.13 and install this checkout with `uv pip install --editable '.[notebooks]'`.\n", + "See **Run notebooks locally** in the repository README for the kernel, execution order,\n", + "and full-data options. Generated artifacts stay under `.cache/notebooks/`.\n" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 9, + "id": "3775e11d", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "\u001b[38;5;226mThe value of `ENVIRONMENT` contains the \"ENV` prefix but `ENVIRONMENT` is not defined as an environment variable, using the default value defined above (`DEVELOPMENT`)\u001b[0m\n", + "\u001b[38;5;196mConfiguration has been already initialised, overwriting.\n", + "Make sure to call `configure()` before importing your application code.\u001b[0m\n", "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", - "\u001b[38;5;39mMongoDbDriver has been already configured: skipping initialisation\u001b[0m\n", - "\u001b[38;5;39mLargeFileS3 has been already configured: skipping initialisation\u001b[0m\n", - "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", - "\u001b[38;5;39m 🔩 tracing_database: MongoDbDriver\u001b[0m\n", - "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileS3\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.11): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", - "\u001b[38;5;39m 🔩 prediction_cache_size: 4096\u001b[0m\n", - "\u001b[38;5;39m 🔩 dashboard_table_size: 100\u001b[0m\n", - "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", - "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n" + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook artifacts: /Users/schmelczer/Projects/great-ai/.cache/notebooks/scibert\n" ] } ], "source": [ - "from great_ai.utilities import ConfigFile\n", - "from great_ai.large_file import LargeFileS3\n", - "from great_ai import configure, MongoDbDriver\n", + "import os\n", + "import sys\n", + "from pathlib import Path\n", "\n", - "configuration = ConfigFile(\"config.ini\")\n", + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", + ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", "\n", - "LargeFileS3.configure_credentials_from_file(configuration)\n", - "MongoDbDriver.configure_credentials_from_file(configuration)\n", - "\n", - "configure(\n", - " dashboard_table_size=100, # traces are small, we can show many\n", - " prediction_cache_size=4096, # predictions are expensive, cache them\n", - ")" + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"scibert\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "cell-3", + "metadata": {}, + "outputs": [], + "source": [ + "# The setup cell selects local model storage and a local TinyDB tracing database." ] }, { "cell_type": "markdown", + "id": "cell-4", "metadata": {}, "source": [ "For a pleasant developer experience, we create some typed models that will show up in the automatically generated OpenAPI schema specification and will also provide runtime type validation." @@ -61,7 +96,8 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, + "id": "cell-5", "metadata": {}, "outputs": [], "source": [ @@ -82,6 +118,7 @@ }, { "cell_type": "markdown", + "id": "cell-6", "metadata": {}, "source": [ "Even though `@use_model` caches the remote files locally and it also handles deserialising objects, we only use it to store a directory. In this case, it gives back a path, the path to that directory. So, we need to load the files from that folder ourselves. In order to only load it once per process, we create a small model loader helper function.\n", @@ -91,58 +128,44 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 12, + "id": "cell-7", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ + "\u001b[38;5;39mFetching cached versions of scibert-highlights\u001b[0m\n", "\u001b[38;5;39mLatest version of scibert-highlights is 0 (from versions: 0)\u001b[0m\n", "\u001b[38;5;39mFile scibert-highlights-0 found in cache\u001b[0m\n" ] } ], "source": [ + "from functools import lru_cache\n", "from great_ai import use_model\n", - "from pathlib import Path\n", - "from typing import Tuple\n", - "from transformers import (\n", - " PreTrainedModel,\n", - " PreTrainedTokenizer,\n", - ")\n", - "from transformers import (\n", - " AutoConfig,\n", - " AutoModelForSequenceClassification,\n", - " AutoTokenizer,\n", - ")\n", + "from transformers import AutoModelForSequenceClassification, AutoTokenizer\n", "\n", - "_tokenizer: PreTrainedTokenizer = None\n", - "_loaded_model: PreTrainedModel = None\n", + "\n", + "@lru_cache(maxsize=1)\n", + "def load_tokenizer_and_model(model_path):\n", + " tokenizer = AutoTokenizer.from_pretrained(model_path, local_files_only=True)\n", + " model = AutoModelForSequenceClassification.from_pretrained(\n", + " model_path, local_files_only=True, attn_implementation=\"eager\"\n", + " )\n", + " model.eval()\n", + " return tokenizer, model\n", "\n", "\n", "@use_model(\"scibert-highlights\", version=\"latest\", model_kwarg_name=\"model_path\")\n", - "def get_tokenizer_and_model(\n", - " model_path: Path, original_model: str = \"allenai/scibert_scivocab_uncased\"\n", - ") -> Tuple[PreTrainedTokenizer, PreTrainedModel]:\n", - " global _tokenizer, _loaded_model\n", - "\n", - " if _tokenizer is None:\n", - " _tokenizer = AutoTokenizer.from_pretrained(original_model)\n", - "\n", - " if _loaded_model is None:\n", - " config = AutoConfig.from_pretrained(\n", - " model_path, output_hidden_states=True, output_attentions=True\n", - " )\n", - " _loaded_model = AutoModelForSequenceClassification.from_pretrained(\n", - " model_path, config=config\n", - " )\n", - "\n", - " return _tokenizer, _loaded_model" + "def get_tokenizer_and_model(model_path: Path):\n", + " return load_tokenizer_and_model(model_path)" ] }, { "cell_type": "markdown", + "id": "cell-8", "metadata": {}, "source": [ "Finally, implement the inference function." @@ -150,76 +173,40 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 13, + "id": "cell-9", "metadata": {}, "outputs": [], "source": [ "from great_ai import GreatAI\n", "from great_ai.utilities import clean\n", - "\n", - "import re\n", - "import numpy as np\n", "import torch\n", - "from transformers.modeling_outputs import SequenceClassifierOutput\n", "\n", "\n", "@GreatAI.create\n", "def find_highlights(sentence: str) -> EvaluatedSentence:\n", - " \"\"\"Get the interestingness prediction of the input sentence using SciBERT.\n", + " \"\"\"Score a sentence and expose the final layer's CLS attention per token.\n", "\n", - " Run the SciBERT model in inference mode and evaluate the sentence.\n", - " Additionally, provide explanation in the form of the last layer's sum attention\n", - " between `[CLS]` and the other tokens.\n", + " Attention weights are a model diagnostic, not a causal explanation.\n", " \"\"\"\n", - "\n", - " tokenizer, loaded_model = get_tokenizer_and_model()\n", + " tokenizer, model = get_tokenizer_and_model()\n", " sentence = clean(sentence, convert_to_ascii=True, remove_brackets=True)\n", - "\n", " tensors = tokenizer(sentence, return_tensors=\"pt\", truncation=True, max_length=512)\n", - "\n", " with torch.inference_mode():\n", - " result: SequenceClassifierOutput = loaded_model(**tensors)\n", - " positive_likelihood = torch.nn.Softmax(dim=1)(result.logits)[0][1]\n", - " tokens = tensors[\"input_ids\"][0]\n", - "\n", - " attentions = np.sum(result.attentions[-1].numpy()[0], axis=0)[0][1:-1]\n", - " # Tuple of `torch.FloatTensor` (one for each layer) of shape\n", - " # `(batch_size, num_heads, sequence_length, sequence_length)`.\n", - "\n", - " explanation = []\n", - "\n", - " token_attentions = list(zip(attentions, tokens[1:-1]))\n", - " for token in re.split(r\"([ .,])\", sentence):\n", - " token = token.strip()\n", - " if not token:\n", - " continue\n", - " bert_tokens = tokenizer(\n", - " token, return_tensors=\"pt\", truncation=True, max_length=512\n", - " )[\"input_ids\"][0][\n", - " 1:-1\n", - " ] # truncation=True needed to fix `RuntimeError: Already borrowed`\n", - " weight = 0\n", - " for t1 in bert_tokens:\n", - " if not token_attentions:\n", - " break\n", - " a, t2 = token_attentions.pop(0)\n", - " assert t1 == t2, sentence\n", - " weight += a\n", - " explanation.append(\n", - " Attention(\n", - " token=token if token in \".,\" else \" \" + token, weight=round(weight, 4)\n", - " )\n", - " )\n", - " if not token_attentions:\n", - " break\n", - "\n", - " return EvaluatedSentence(\n", - " score=positive_likelihood, text=sentence, explanation=explanation\n", - " )" + " result = model(**tensors, output_attentions=True)\n", + " score = torch.softmax(result.logits, dim=1)[0, 1].item()\n", + " weights = result.attentions[-1][0, :, 0, :].sum(dim=0).cpu().tolist()\n", + " tokens = tokenizer.convert_ids_to_tokens(tensors[\"input_ids\"][0].tolist())\n", + " explanation = [\n", + " Attention(token=token, weight=round(weight, 4))\n", + " for token, weight in zip(tokens[1:-1], weights[1:-1])\n", + " ]\n", + " return EvaluatedSentence(score=score, text=sentence, explanation=explanation)" ] }, { "cell_type": "markdown", + "id": "cell-10", "metadata": {}, "source": [ "A simple test to see everything works. Note that the models list is filled by the `@use_model` call even though it's not on the main inference function." @@ -227,66 +214,61 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, + "id": "cell-11", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W1028 12:49:11.667000 52910 torch/distributed/elastic/multiprocessing/redirects.py:35] NOTE: Redirects are currently not supported in MacOs.\n" + ] + }, { "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6ef4b00220304248a94035042cb5fa15", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "(Trace[EvaluatedSentence]({'created': '2022-07-16T18:47:29.581701',\n", - " 'exception': None,\n", - " 'feedback': None,\n", - " 'logged_values': { 'arg:sentence:length': 51,\n", - " 'arg:sentence:value': 'Our solution has outperformed the '\n", - " 'state-of-the-art.'},\n", - " 'models': [{'key': 'scibert-highlights', 'version': 0}],\n", - " 'original_execution_time_ms': 7127.2063,\n", - " 'output': { 'explanation': [ {'token': ' Our', 'weight': 0.3993},\n", - " {'token': ' solution', 'weight': 0.3481},\n", - " {'token': ' has', 'weight': 0.2945},\n", - " {'token': ' outperformed', 'weight': 0.4011},\n", - " {'token': ' the', 'weight': 0.1484},\n", - " {'token': ' state-of-the-art', 'weight': 0.5727},\n", - " {'token': '.', 'weight': 7.775}],\n", - " 'score': 0.9991180300712585,\n", - " 'text': 'Our solution has outperformed the state-of-the-art.'},\n", - " 'tags': ['find_highlights', 'online', 'development'],\n", - " 'trace_id': '56e20e94-79df-4793-ae61-d20820ebe2d3'}),\n", - " Trace[EvaluatedSentence]({'created': '2022-07-16T18:47:37.020275',\n", - " 'exception': None,\n", - " 'feedback': None,\n", - " 'logged_values': { 'arg:sentence:length': 36,\n", - " 'arg:sentence:value': 'Their solution did not perform '\n", - " 'well.'},\n", - " 'models': [{'key': 'scibert-highlights', 'version': 0}],\n", - " 'original_execution_time_ms': 170.7057,\n", - " 'output': { 'explanation': [ {'token': ' Their', 'weight': 1.1475},\n", - " {'token': ' solution', 'weight': 0.8205},\n", - " {'token': ' did', 'weight': 0.3254},\n", - " {'token': ' not', 'weight': 0.2921},\n", - " {'token': ' perform', 'weight': 0.4293},\n", - " {'token': ' well', 'weight': 0.2772},\n", - " {'token': '.', 'weight': 4.4723}],\n", - " 'score': 0.12305451184511185,\n", - " 'text': 'Their solution did not perform well.'},\n", - " 'tags': ['find_highlights', 'online', 'development'],\n", - " 'trace_id': '7fcf8271-1738-4025-8305-d5a1e5100aea'}))" + "Loading weights: 0%| | 0/25 [00:00 /dev/null" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Load the training data from S3. (We have uploaded this to S3 in the `data` notebook.)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, + "id": "824837fa", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.11): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook artifacts: /Users/schmelczer/Projects/great-ai/.cache/notebooks/scibert\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", + ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", + "\n", + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"scibert\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-3", + "metadata": {}, + "outputs": [], + "source": [ + "# Dependencies are installed once with uv pip install --editable \".[notebooks]\"." + ] + }, + { + "cell_type": "markdown", + "id": "cell-4", + "metadata": {}, + "source": [ + "Load the dataset saved locally by `data.ipynb`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cell-5", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[38;5;39mFetching cached versions of summary-train-dataset-small\u001b[0m\n", "\u001b[38;5;39mLatest version of summary-train-dataset-small is 0 (from versions: 0)\u001b[0m\n", "\u001b[38;5;39mFile summary-train-dataset-small-0 found in cache\u001b[0m\n" ] } ], "source": [ - "from great_ai.large_file import LargeFileS3\n", + "from great_ai.large_file import LargeFileLocal\n", "import json\n", "\n", - "LargeFileS3.configure_credentials_from_file(\"config.ini\")\n", - "\n", - "with LargeFileS3(\"summary-train-dataset-small\", encoding=\"utf-8\") as f:\n", - " # splitting training and test data is done later by `datasets`\n", + "with LargeFileLocal(\"summary-train-dataset-small\", encoding=\"utf-8\") as f:\n", " X, y = json.load(f)" ] }, { "cell_type": "markdown", + "id": "cell-6", "metadata": {}, "source": [ "Finetune SciBERT, for more info about this step, check out [HuggingFace](https://huggingface.co/docs/transformers/training).\n", - "If you're only here for `great-ai`, feel free to skip the next cell." + "If you're only here for `great-ai`, feel free to skip the next cell.\n", + "\n", + "We use an 80/20 training/validation split. Early stopping and checkpoint selection both use validation binary F1 for positive label `1`. There is no independent test split in this example. The split and training seed is fixed for future runs, and the selected checkpoint's evaluation and run metadata are saved under `models/`.\n" ] }, { "cell_type": "code", - "execution_count": 22, - "metadata": { - "executionInfo": { - "elapsed": 118131, - "status": "ok", - "timestamp": 1656593941974, - "user_tz": -120 - }, - "id": "AL3etUQ3LtKN", - "outputId": "fe00589f-64dd-4b70-e612-3873b504c00a" - }, + "execution_count": 4, + "id": "cell-7", + "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "W1028 12:48:58.270000 53390 torch/distributed/elastic/multiprocessing/redirects.py:35] NOTE: Redirects are currently not supported in MacOs.\n" + ] + }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9c57de70e68a41ecbde5093bd671715a", + "model_id": "2c74823d6364447a96609229fbbc5512", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/1 [00:00\n", - " \n", - " \n", - " [130/650 01:43 < 07:01, 1.23 it/s, Epoch 10/50]\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
EpochTraining LossValidation LossF1
10.5868000.5121380.719101
20.4116000.4166750.849057
30.2456000.4170700.864000
40.1478000.5758780.852459
50.0568000.4742590.896552
60.0225000.7542360.843137
70.0010000.8576360.834783
80.0005000.9202320.869565
90.0003000.9707900.877193
100.0003000.9486890.862385

" - ], + "application/vnd.jupyter.widget-view+json": { + "model_id": "23492278f66e46f09e9eee0680c21b92", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "" + "Writing model shards: 0%| | 0/1 [00:00 Tuple[str, str]:\n", @@ -37,30 +103,28 @@ " return (clean(data_point[\"text\"], convert_to_ascii=True), data_point[\"label\"])\n", "\n", "\n", - "with open(\"../../tutorial/data/train.txt\", encoding=\"utf-8\") as f:\n", - " training_data = simple_parallel_map(preprocess, f.readlines())\n", - "\n", + "training_lines = mag_lines(DATA_DIR / \"train.txt\", None if FULL_RUN else 100)\n", + "training_data = simple_parallel_map(preprocess, training_lines, concurrency=2)\n", "X_train = [d[0] for d in training_data]\n", "y_train = [d[1] for d in training_data]\n", "\n", - "\n", - "with open(\"../../tutorial/data/test.txt\", encoding=\"utf-8\") as f:\n", - " test_data = simple_parallel_map(preprocess, f.readlines())\n", - "\n", + "test_lines = mag_lines(DATA_DIR / \"test.txt\", None if FULL_RUN else 30)\n", + "test_data = simple_parallel_map(preprocess, test_lines, concurrency=2)\n", "X_test = [d[0] for d in test_data]\n", "y_test = [d[1] for d in test_data]" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "id": "cell-4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "

" + "
" ] }, "metadata": {}, @@ -85,13 +149,14 @@ "ax.bar(domains, counts)\n", "ax.set_ylabel(\"Count\")\n", "fig.tight_layout()\n", - "fig.savefig(\"mag-distribution.png\", dpi=500)\n", + "fig.savefig(WORK_DIR / \"mag-distribution.png\", dpi=500)\n", "None" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, + "id": "cell-5", "metadata": {}, "outputs": [], "source": [ @@ -111,14 +176,15 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, + "id": "cell-6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Fitting 3 folds for each of 24 candidates, totalling 72 fits\n" + "Fitting 3 folds for each of 8 candidates, totalling 24 fits\n" ] }, { @@ -161,600 +227,216 @@ " \n", " \n", " \n", - " 12\n", - " 2.352721\n", - " 0.257936\n", - " 1.357399\n", - " 0.094580\n", - " 1\n", + " 4\n", + " 0.004115\n", + " 0.000260\n", + " 0.001606\n", + " 0.000055\n", + " 1.0\n", " True\n", - " 0.05\n", - " 5\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.677283\n", - " 0.670398\n", - " 0.665671\n", - " 0.671118\n", - " 0.004768\n", + " 0.9\n", " 1\n", - " \n", - " \n", - " 15\n", - " 2.544958\n", - " 0.051976\n", - " 1.245658\n", - " 0.137108\n", - " 1\n", - " True\n", - " 0.1\n", - " 5\n", " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.676970\n", - " 0.670244\n", - " 0.666123\n", - " 0.671112\n", - " 0.004470\n", - " 2\n", - " \n", - " \n", - " 18\n", - " 2.472888\n", - " 0.053978\n", - " 1.447181\n", - " 0.051170\n", + " 0.432466\n", + " 0.452735\n", + " 0.515415\n", + " 0.466872\n", + " 0.035308\n", " 1\n", - " False\n", - " 0.05\n", - " 5\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.675678\n", - " 0.669321\n", - " 0.665305\n", - " 0.670101\n", - " 0.004271\n", - " 3\n", - " \n", - " \n", - " 21\n", - " 2.467637\n", - " 0.005358\n", - " 1.216254\n", - " 0.048319\n", - " 1\n", - " False\n", - " 0.1\n", - " 5\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.675569\n", - " 0.669482\n", - " 0.665225\n", - " 0.670092\n", - " 0.004245\n", - " 4\n", - " \n", - " \n", - " 3\n", - " 2.477612\n", - " 0.134880\n", - " 1.428521\n", - " 0.017417\n", - " 0.5\n", - " True\n", - " 0.1\n", - " 5\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.675225\n", - " 0.668912\n", - " 0.665652\n", - " 0.669930\n", - " 0.003974\n", - " 5\n", - " \n", - " \n", - " 0\n", - " 2.484810\n", - " 0.067836\n", - " 1.249979\n", - " 0.209959\n", - " 0.5\n", - " True\n", - " 0.05\n", - " 5\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.675264\n", - " 0.668781\n", - " 0.665394\n", - " 0.669813\n", - " 0.004095\n", - " 6\n", - " \n", - " \n", - " 9\n", - " 2.452453\n", - " 0.049376\n", - " 1.279694\n", - " 0.089200\n", - " 0.5\n", - " False\n", - " 0.1\n", - " 5\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.674199\n", - " 0.668005\n", - " 0.664456\n", - " 0.668887\n", - " 0.004026\n", - " 7\n", " \n", " \n", " 6\n", - " 2.748628\n", - " 0.098077\n", - " 1.255213\n", - " 0.101334\n", - " 0.5\n", + " 0.004385\n", + " 0.000527\n", + " 0.001801\n", + " 0.000060\n", + " 1.0\n", " False\n", - " 0.05\n", - " 5\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.673996\n", - " 0.668048\n", - " 0.664572\n", - " 0.668872\n", - " 0.003891\n", - " 8\n", - " \n", - " \n", - " 13\n", - " 2.371907\n", - " 0.204820\n", - " 1.375143\n", - " 0.193984\n", + " 0.9\n", " 1\n", - " True\n", - " 0.05\n", - " 20\n", " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.656459\n", - " 0.647433\n", - " 0.644864\n", - " 0.649585\n", - " 0.004972\n", - " 9\n", + " 0.434901\n", + " 0.447344\n", + " 0.515260\n", + " 0.465835\n", + " 0.035316\n", + " 2\n", " \n", " \n", - " 16\n", - " 2.557486\n", - " 0.184332\n", - " 1.272137\n", - " 0.133980\n", - " 1\n", - " True\n", - " 0.1\n", - " 20\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.656196\n", - " 0.646960\n", - " 0.645436\n", - " 0.649530\n", - " 0.004754\n", - " 10\n", - " \n", - " \n", - " 4\n", - " 2.362093\n", - " 0.109796\n", - " 1.344960\n", - " 0.083562\n", + " 0\n", + " 0.009770\n", + " 0.003560\n", + " 0.002647\n", + " 0.000300\n", " 0.5\n", " True\n", - " 0.1\n", - " 20\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.654424\n", - " 0.644690\n", - " 0.644991\n", - " 0.648035\n", - " 0.004519\n", - " 11\n", - " \n", - " \n", - " 1\n", - " 2.668012\n", - " 0.131751\n", - " 1.383441\n", - " 0.049157\n", - " 0.5\n", - " True\n", - " 0.05\n", - " 20\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.654622\n", - " 0.644901\n", - " 0.644425\n", - " 0.647983\n", - " 0.004699\n", - " 12\n", - " \n", - " \n", - " 19\n", - " 2.517576\n", - " 0.154192\n", - " 1.374269\n", - " 0.026773\n", + " 0.9\n", " 1\n", - " False\n", - " 0.05\n", - " 20\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.655125\n", - " 0.645586\n", - " 0.643166\n", - " 0.647959\n", - " 0.005163\n", - " 13\n", - " \n", - " \n", - " 22\n", - " 2.386240\n", - " 0.069718\n", - " 0.967638\n", - " 0.076766\n", - " 1\n", - " False\n", - " 0.1\n", - " 20\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.654254\n", - " 0.645409\n", - " 0.643514\n", - " 0.647726\n", - " 0.004680\n", - " 14\n", - " \n", - " \n", - " 7\n", - " 2.416211\n", - " 0.138001\n", - " 1.316785\n", - " 0.036402\n", - " 0.5\n", - " False\n", - " 0.05\n", - " 20\n", " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.652727\n", - " 0.643691\n", - " 0.642749\n", - " 0.646389\n", - " 0.004498\n", - " 15\n", - " \n", - " \n", - " 10\n", - " 2.397768\n", - " 0.244951\n", - " 1.330007\n", - " 0.008983\n", - " 0.5\n", - " False\n", - " 0.1\n", - " 20\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.652290\n", - " 0.642975\n", - " 0.643421\n", - " 0.646229\n", - " 0.004290\n", - " 16\n", - " \n", - " \n", - " 14\n", - " 2.590127\n", - " 0.054396\n", - " 1.155976\n", - " 0.187602\n", - " 1\n", - " True\n", - " 0.05\n", - " 100\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.587097\n", - " 0.577411\n", - " 0.580170\n", - " 0.581560\n", - " 0.004075\n", - " 17\n", - " \n", - " \n", - " 17\n", - " 2.497556\n", - " 0.085952\n", - " 1.169808\n", - " 0.061336\n", - " 1\n", - " True\n", - " 0.1\n", - " 100\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.585713\n", - " 0.577197\n", - " 0.580763\n", - " 0.581224\n", - " 0.003492\n", - " 18\n", + " 0.439486\n", + " 0.455269\n", + " 0.487305\n", + " 0.460687\n", + " 0.019894\n", + " 3\n", " \n", " \n", " 2\n", - " 2.467611\n", - " 0.168399\n", - " 1.313936\n", - " 0.109695\n", + " 0.005172\n", + " 0.000944\n", + " 0.001999\n", + " 0.000186\n", + " 0.5\n", + " False\n", + " 0.9\n", + " 1\n", + " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", + " 0.438540\n", + " 0.451386\n", + " 0.488106\n", + " 0.459344\n", + " 0.021003\n", + " 4\n", + " \n", + " \n", + " 1\n", + " 0.004092\n", + " 0.001210\n", + " 0.002313\n", + " 0.000227\n", " 0.5\n", " True\n", - " 0.05\n", - " 100\n", + " 0.9\n", + " 3\n", " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.586346\n", - " 0.576987\n", - " 0.579852\n", - " 0.581062\n", - " 0.003915\n", - " 19\n", + " 0.369420\n", + " 0.389690\n", + " 0.453996\n", + " 0.404369\n", + " 0.036054\n", + " 5\n", + " \n", + " \n", + " 3\n", + " 0.003984\n", + " 0.000263\n", + " 0.001870\n", + " 0.000106\n", + " 0.5\n", + " False\n", + " 0.9\n", + " 3\n", + " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", + " 0.372802\n", + " 0.385098\n", + " 0.450138\n", + " 0.402679\n", + " 0.033932\n", + " 6\n", " \n", " \n", " 5\n", - " 2.339322\n", - " 0.092595\n", - " 1.209515\n", - " 0.132825\n", - " 0.5\n", + " 0.002690\n", + " 0.000284\n", + " 0.001573\n", + " 0.000183\n", + " 1.0\n", " True\n", - " 0.1\n", - " 100\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.585634\n", - " 0.576217\n", - " 0.580320\n", - " 0.580723\n", - " 0.003855\n", - " 20\n", - " \n", - " \n", - " 20\n", - " 2.644488\n", - " 0.119967\n", - " 1.238554\n", - " 0.048871\n", - " 1\n", - " False\n", - " 0.05\n", - " 100\n", + " 0.9\n", + " 3\n", " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.581096\n", - " 0.572833\n", - " 0.576280\n", - " 0.576736\n", - " 0.003389\n", - " 21\n", + " 0.366778\n", + " 0.391056\n", + " 0.444378\n", + " 0.400737\n", + " 0.032411\n", + " 7\n", " \n", " \n", - " 8\n", - " 2.456030\n", - " 0.072136\n", - " 1.240463\n", - " 0.092383\n", - " 0.5\n", + " 7\n", + " 0.003193\n", + " 0.000383\n", + " 0.001686\n", + " 0.000183\n", + " 1.0\n", " False\n", - " 0.05\n", - " 100\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.580841\n", - " 0.572391\n", - " 0.575731\n", - " 0.576321\n", - " 0.003475\n", - " 22\n", - " \n", - " \n", - " 23\n", - " 2.335796\n", - " 0.082338\n", - " 0.786187\n", - " 0.073499\n", - " 1\n", - " False\n", - " 0.1\n", - " 100\n", + " 0.9\n", + " 3\n", " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.579769\n", - " 0.572373\n", - " 0.576699\n", - " 0.576280\n", - " 0.003034\n", - " 23\n", - " \n", - " \n", - " 11\n", - " 2.530331\n", - " 0.107199\n", - " 1.247842\n", - " 0.078229\n", - " 0.5\n", - " False\n", - " 0.1\n", - " 100\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.579743\n", - " 0.571607\n", - " 0.576352\n", - " 0.575901\n", - " 0.003337\n", - " 24\n", + " 0.367218\n", + " 0.386159\n", + " 0.444473\n", + " 0.399283\n", + " 0.032876\n", + " 8\n", " \n", " \n", "\n", "" ], "text/plain": [ - " mean_fit_time std_fit_time mean_score_time std_score_time \\\n", - "12 2.352721 0.257936 1.357399 0.094580 \n", - "15 2.544958 0.051976 1.245658 0.137108 \n", - "18 2.472888 0.053978 1.447181 0.051170 \n", - "21 2.467637 0.005358 1.216254 0.048319 \n", - "3 2.477612 0.134880 1.428521 0.017417 \n", - "0 2.484810 0.067836 1.249979 0.209959 \n", - "9 2.452453 0.049376 1.279694 0.089200 \n", - "6 2.748628 0.098077 1.255213 0.101334 \n", - "13 2.371907 0.204820 1.375143 0.193984 \n", - "16 2.557486 0.184332 1.272137 0.133980 \n", - "4 2.362093 0.109796 1.344960 0.083562 \n", - "1 2.668012 0.131751 1.383441 0.049157 \n", - "19 2.517576 0.154192 1.374269 0.026773 \n", - "22 2.386240 0.069718 0.967638 0.076766 \n", - "7 2.416211 0.138001 1.316785 0.036402 \n", - "10 2.397768 0.244951 1.330007 0.008983 \n", - "14 2.590127 0.054396 1.155976 0.187602 \n", - "17 2.497556 0.085952 1.169808 0.061336 \n", - "2 2.467611 0.168399 1.313936 0.109695 \n", - "5 2.339322 0.092595 1.209515 0.132825 \n", - "20 2.644488 0.119967 1.238554 0.048871 \n", - "8 2.456030 0.072136 1.240463 0.092383 \n", - "23 2.335796 0.082338 0.786187 0.073499 \n", - "11 2.530331 0.107199 1.247842 0.078229 \n", + " mean_fit_time std_fit_time mean_score_time std_score_time \\\n", + "4 0.004115 0.000260 0.001606 0.000055 \n", + "6 0.004385 0.000527 0.001801 0.000060 \n", + "0 0.009770 0.003560 0.002647 0.000300 \n", + "2 0.005172 0.000944 0.001999 0.000186 \n", + "1 0.004092 0.001210 0.002313 0.000227 \n", + "3 0.003984 0.000263 0.001870 0.000106 \n", + "5 0.002690 0.000284 0.001573 0.000183 \n", + "7 0.003193 0.000383 0.001686 0.000183 \n", "\n", - " param_classifier__alpha param_classifier__fit_prior \\\n", - "12 1 True \n", - "15 1 True \n", - "18 1 False \n", - "21 1 False \n", - "3 0.5 True \n", - "0 0.5 True \n", - "9 0.5 False \n", - "6 0.5 False \n", - "13 1 True \n", - "16 1 True \n", - "4 0.5 True \n", - "1 0.5 True \n", - "19 1 False \n", - "22 1 False \n", - "7 0.5 False \n", - "10 0.5 False \n", - "14 1 True \n", - "17 1 True \n", - "2 0.5 True \n", - "5 0.5 True \n", - "20 1 False \n", - "8 0.5 False \n", - "23 1 False \n", - "11 0.5 False \n", + " param_classifier__alpha param_classifier__fit_prior \\\n", + "4 1.0 True \n", + "6 1.0 False \n", + "0 0.5 True \n", + "2 0.5 False \n", + "1 0.5 True \n", + "3 0.5 False \n", + "5 1.0 True \n", + "7 1.0 False \n", "\n", - " param_vectorizer__max_df param_vectorizer__min_df \\\n", - "12 0.05 5 \n", - "15 0.1 5 \n", - "18 0.05 5 \n", - "21 0.1 5 \n", - "3 0.1 5 \n", - "0 0.05 5 \n", - "9 0.1 5 \n", - "6 0.05 5 \n", - "13 0.05 20 \n", - "16 0.1 20 \n", - "4 0.1 20 \n", - "1 0.05 20 \n", - "19 0.05 20 \n", - "22 0.1 20 \n", - "7 0.05 20 \n", - "10 0.1 20 \n", - "14 0.05 100 \n", - "17 0.1 100 \n", - "2 0.05 100 \n", - "5 0.1 100 \n", - "20 0.05 100 \n", - "8 0.05 100 \n", - "23 0.1 100 \n", - "11 0.1 100 \n", + " param_vectorizer__max_df param_vectorizer__min_df \\\n", + "4 0.9 1 \n", + "6 0.9 1 \n", + "0 0.9 1 \n", + "2 0.9 1 \n", + "1 0.9 3 \n", + "3 0.9 3 \n", + "5 0.9 3 \n", + "7 0.9 3 \n", "\n", - " params split0_test_score \\\n", - "12 {'classifier__alpha': 1, 'classifier__fit_prio... 0.677283 \n", - "15 {'classifier__alpha': 1, 'classifier__fit_prio... 0.676970 \n", - "18 {'classifier__alpha': 1, 'classifier__fit_prio... 0.675678 \n", - "21 {'classifier__alpha': 1, 'classifier__fit_prio... 0.675569 \n", - "3 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.675225 \n", - "0 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.675264 \n", - "9 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.674199 \n", - "6 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.673996 \n", - "13 {'classifier__alpha': 1, 'classifier__fit_prio... 0.656459 \n", - "16 {'classifier__alpha': 1, 'classifier__fit_prio... 0.656196 \n", - "4 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.654424 \n", - "1 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.654622 \n", - "19 {'classifier__alpha': 1, 'classifier__fit_prio... 0.655125 \n", - "22 {'classifier__alpha': 1, 'classifier__fit_prio... 0.654254 \n", - "7 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.652727 \n", - "10 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.652290 \n", - "14 {'classifier__alpha': 1, 'classifier__fit_prio... 0.587097 \n", - "17 {'classifier__alpha': 1, 'classifier__fit_prio... 0.585713 \n", - "2 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.586346 \n", - "5 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.585634 \n", - "20 {'classifier__alpha': 1, 'classifier__fit_prio... 0.581096 \n", - "8 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.580841 \n", - "23 {'classifier__alpha': 1, 'classifier__fit_prio... 0.579769 \n", - "11 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.579743 \n", + " params split0_test_score \\\n", + "4 {'classifier__alpha': 1, 'classifier__fit_prio... 0.432466 \n", + "6 {'classifier__alpha': 1, 'classifier__fit_prio... 0.434901 \n", + "0 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.439486 \n", + "2 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.438540 \n", + "1 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.369420 \n", + "3 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.372802 \n", + "5 {'classifier__alpha': 1, 'classifier__fit_prio... 0.366778 \n", + "7 {'classifier__alpha': 1, 'classifier__fit_prio... 0.367218 \n", "\n", - " split1_test_score split2_test_score mean_test_score std_test_score \\\n", - "12 0.670398 0.665671 0.671118 0.004768 \n", - "15 0.670244 0.666123 0.671112 0.004470 \n", - "18 0.669321 0.665305 0.670101 0.004271 \n", - "21 0.669482 0.665225 0.670092 0.004245 \n", - "3 0.668912 0.665652 0.669930 0.003974 \n", - "0 0.668781 0.665394 0.669813 0.004095 \n", - "9 0.668005 0.664456 0.668887 0.004026 \n", - "6 0.668048 0.664572 0.668872 0.003891 \n", - "13 0.647433 0.644864 0.649585 0.004972 \n", - "16 0.646960 0.645436 0.649530 0.004754 \n", - "4 0.644690 0.644991 0.648035 0.004519 \n", - "1 0.644901 0.644425 0.647983 0.004699 \n", - "19 0.645586 0.643166 0.647959 0.005163 \n", - "22 0.645409 0.643514 0.647726 0.004680 \n", - "7 0.643691 0.642749 0.646389 0.004498 \n", - "10 0.642975 0.643421 0.646229 0.004290 \n", - "14 0.577411 0.580170 0.581560 0.004075 \n", - "17 0.577197 0.580763 0.581224 0.003492 \n", - "2 0.576987 0.579852 0.581062 0.003915 \n", - "5 0.576217 0.580320 0.580723 0.003855 \n", - "20 0.572833 0.576280 0.576736 0.003389 \n", - "8 0.572391 0.575731 0.576321 0.003475 \n", - "23 0.572373 0.576699 0.576280 0.003034 \n", - "11 0.571607 0.576352 0.575901 0.003337 \n", + " split1_test_score split2_test_score mean_test_score std_test_score \\\n", + "4 0.452735 0.515415 0.466872 0.035308 \n", + "6 0.447344 0.515260 0.465835 0.035316 \n", + "0 0.455269 0.487305 0.460687 0.019894 \n", + "2 0.451386 0.488106 0.459344 0.021003 \n", + "1 0.389690 0.453996 0.404369 0.036054 \n", + "3 0.385098 0.450138 0.402679 0.033932 \n", + "5 0.391056 0.444378 0.400737 0.032411 \n", + "7 0.386159 0.444473 0.399283 0.032876 \n", "\n", - " rank_test_score \n", - "12 1 \n", - "15 2 \n", - "18 3 \n", - "21 4 \n", - "3 5 \n", - "0 6 \n", - "9 7 \n", - "6 8 \n", - "13 9 \n", - "16 10 \n", - "4 11 \n", - "1 12 \n", - "19 13 \n", - "22 14 \n", - "7 15 \n", - "10 16 \n", - "14 17 \n", - "17 18 \n", - "2 19 \n", - "5 20 \n", - "20 21 \n", - "8 22 \n", - "23 23 \n", - "11 24 " + " rank_test_score \n", + "4 1 \n", + "6 2 \n", + "0 3 \n", + "2 4 \n", + "1 5 \n", + "3 6 \n", + "5 7 \n", + "7 8 " ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -766,14 +448,14 @@ "optimisation_pipeline = GridSearchCV(\n", " create_pipeline(),\n", " {\n", - " \"vectorizer__min_df\": [5, 20, 100],\n", - " \"vectorizer__max_df\": [0.05, 0.1],\n", + " \"vectorizer__min_df\": ([5, 20, 100] if FULL_RUN else [1, 3]),\n", + " \"vectorizer__max_df\": ([0.05, 0.1] if FULL_RUN else [0.9]),\n", " \"classifier__alpha\": [0.5, 1],\n", " \"classifier__fit_prior\": [True, False],\n", " },\n", " scoring=\"f1_macro\",\n", " cv=3,\n", - " n_jobs=-1,\n", + " n_jobs=2,\n", " verbose=1,\n", ")\n", "optimisation_pipeline.fit(X_train, y_train)\n", @@ -784,25 +466,2274 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, + "id": "cell-7", "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
Pipeline(steps=[('vectorizer',\n",
-       "                 TfidfVectorizer(max_df=0.05, min_df=5, sublinear_tf=True)),\n",
-       "                ('classifier', MultinomialNB(alpha=1))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + "
Pipeline(steps=[('vectorizer', TfidfVectorizer(max_df=0.9, sublinear_tf=True)),\n",
+       "                ('classifier', MultinomialNB(alpha=1))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ - "Pipeline(steps=[('vectorizer',\n", - " TfidfVectorizer(max_df=0.05, min_df=5, sublinear_tf=True)),\n", + "Pipeline(steps=[('vectorizer', TfidfVectorizer(max_df=0.9, sublinear_tf=True)),\n", " ('classifier', MultinomialNB(alpha=1))])" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -819,7 +2750,8 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 7, + "id": "cell-8", "metadata": {}, "outputs": [ { @@ -828,25 +2760,25 @@ "text": [ " precision recall f1-score support\n", "\n", - " business 0.6412 0.7258 0.6808 3198\n", - " economics 0.6635 0.7146 0.6881 3189\n", - " geography 0.7461 0.6791 0.7111 3207\n", - " medicine 0.8806 0.9021 0.8912 3187\n", - " politics 0.5563 0.5895 0.5724 3169\n", - " psychology 0.7654 0.6811 0.7208 3252\n", - " sociology 0.5165 0.4698 0.4921 3197\n", + " business 0.4286 0.6000 0.5000 30\n", + " economics 0.3878 0.6333 0.4810 30\n", + " geography 0.4615 0.2000 0.2791 30\n", + " medicine 0.6800 0.5667 0.6182 30\n", + " politics 0.5152 0.5667 0.5397 30\n", + " psychology 0.4167 0.3333 0.3704 30\n", + " sociology 0.3333 0.2667 0.2963 30\n", "\n", - " accuracy 0.6803 22399\n", - " macro avg 0.6814 0.6803 0.6795 22399\n", - "weighted avg 0.6817 0.6803 0.6796 22399\n", + " accuracy 0.4524 210\n", + " macro avg 0.4604 0.4524 0.4407 210\n", + "weighted avg 0.4604 0.4524 0.4407 210\n", "\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABSgAAATQCAYAAADwJ6tIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3gUVdvH8d9ussmmkARIpXeCEECkSBMQGwioIHYBUVGKvWFHRUV9LI8KKD4oYhcQESyogCgivCC995BAQhLS+7b3j02CMW2DwIT4/VxXLmXnzMlZ9nDP7D33nDG5XC6XAAAAAAAAAMAAZqMHAAAAAAAAAODfiwQlAAAAAAAAAMOQoAQAAAAAAABgGBKUAAAAAAAAAAxDghIAAAAAAACAYUhQAgAAAAAAADCMt9EDAAAAAAAAAE6HSwcE6Hiqw+hhnFahUf31ww8/GD2Mf4QEJQAAAAAAAGql46kO/d/SJkYP47TqPiTF6CH8Y9ziDQAAAAAAAMAwJCgBAAAAAAAAGIZbvAEAAAAAAFAruSQ55TR6GKgCFZQAAAAAAAAADEOCEgAAAAAAAIBhSFACAAAAAAAAMAxrUAIAAAAAAKCWcsnhYg3Kmo4KSgAAAAAAAACGIUEJAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMPwkBwAAAAAAADUSi5JTrmMHgaqQAUlAAAAAAAAAMOQoAQAAAAAAABgGBKUAAAAAAAAAAzDGpQAAAAAAACotZxyGj0EVIEKSgAAAAAAAACGIUEJAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMPwkBwAAAAAAADUSi655HC5jB4GqkAFJQAAAAAAAADDkKAEAAAAAAAAYBgSlAAAAAAAAAAMwxqUAAAAAAAAqLWcYg3Kmo4KSgAAAAAAAACGIUEJAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMPwkBwAAAAAAADUSi5JDh6SU+NRQQkAAAAAAADAMCQoAQAAAAAAABiGBCUAAAAAAAAAw7AGJQAAAAAAAGotJ2tQ1nhUUAIAAAAAAAAwDAlKAAAAAAAAAIYhQQkAAAAAAADAMKxBCQAAAAAAgFrJJcnhYg3Kmo4KSgAAAAAAAACGIUEJAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMPwkBwAAAAAAADUWk6jB4AqUUEJAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMOwBiUAAAAAAABqJZdccshl9DBQBSooAQAAAAAAABiGBCUAAAAAAAAAw5CgBAAAAAAAAGAYEpQAAAAAAAAADMNDcgAAAAAAAFA7uSQHz8ip8aigBAAAAAAAAGAYEpQAAAAAAAAADEOCEgAAAAAAAIBhWIMSAAAAAAAAtZJLktPoQaBKVFACAAAAAAAAMAwJSgAAAAAAAACGIUEJAAAAAAAAwDAkKAEAAAAAAAAYhofkAAAAAAAAoJYyySGT0YNAFaigBAAAAAAAAGAYEpQAAAAAAAAADEOCEgAAAAAAAIBhWIMSAAAAAAAAtZJLktNl9ChQFSooAQAAAAAAABiGBCUAAAAAAAAAw5CgBAAAAAAAAGAYEpQAAAAAAAAADMNDcgAAAAAAAFBrOWQyegioAhWUAAAAAAAAAAxDBSVqDN8QP/lH1jF6GDiLOA8TwlBNNpvRI8BZyOVwGj0EnGVMJqo0AJx+LpfL6CHgLJPvylGhK9/oYQDl4ts9agz/yDoaMHuE0cPAWSRnfKjRQ8BZxpSQZPQQcBZyZmYbPQScZUxWX6OHgLORk4shqB5XIRdeUT1rbD8YPQSgQiQoAQAAAAAAUCu5xBqUZwPWoAQAAAAAAABgGBKUAAAAAAAAAAxDghIAAAAAAACAYViDEgAAAAAAALWW08UalDUdFZQAAAAAAAAADEOCEgAAAAAAAIBhSFACAAAAAAAAMAwJSgAAAAAAAACG4SE5AAAAAAAAqJVckhziITk1HRWUAAAAAAAAAAxDghIAAAAAAACAYUhQAgAAAAAAADAMa1ACAAAAAACgVnLJJAf1eTUenxAAAAAAAAAAw5CgBAAAAAAAAGAYEpQAAAAAAAAADEOCEgAAAAAAAIBheEgOAAAAAAAAai2ny2T0EFAFKigBAAAAAAAAGIYEJQAAAAAAAADDkKAEAAAAAAAA/gU+/fRT9e3bV8HBwQoMDFTXrl01ffp0OZ3OaveVlpamxx57TDExMQoICJCvr6+aNm2qm2++WZs2bapWX6xBCQAAAAAAgFrJJckh1qCUpIkTJ2rGjBmyWq0aOHCgLBaLli1bpkmTJmnZsmWaP3++zGbPahkPHz6svn376vDhwwoNDdWAAQNktVq1adMmffzxx/r888/1+eefa8SIER71RwUlAAAAAAAAUIstWLBAM2bMUGRkpLZs2aIlS5Zo4cKF2rt3r9q1a6eFCxfqrbfe8ri/yZMn6/Dhwxo8eLBiY2O1ZMkSzZ8/X3v27NHTTz8tu92uO+64QzabzaP+SFACAAAAAAAAtdiLL74oSXrppZfUunXrktcjIiI0c+ZMSdK0adM8vtV7xYoVkqQnnnhC/v7+Ja+bzWY9+eST8vPz0/Hjx7V3716P+iNBCQAAAAAAANRS8fHx+vPPP+Xj46ORI0eW2d6vXz81bNhQiYmJWrNmjUd9+vr6VrrdZHLfVh8aGupRfyQoAQAAAAAAgFpq48aNkqT27dvLz8+v3DbdunUr1bYql112mSRp6tSpys3NLXnd5XLpueeeU25uroYNG6bw8HCP+uMhOQAAAAAAAKilTHK4/t31eQcPHpQkNW3atMI2TZo0KdW2KlOnTtXGjRv13XffqWnTpjr//PPl6+urzZs3KzY2VjfddJNmzJjh8RhJUAIAAAAAAAC1VHZ2tiQpICCgwjaBgYGSpKysLI/6DA0N1fLlyzVx4kR9+OGHWrJkScm2tm3bql+/fqpTp47HY/x3p5ABAAAAAACAs1hycrK6du1a8jNr1qzT/jt37dqlc889V0uXLtVHH32khIQEpaena9myZQoICNDtt9+usWPHetwfFZQAAAAAAADAWSosLEzr16+vcHtxdWROTk6FbYqrLD2perTb7RoxYoT27dun33//XT179izZduGFF+qnn37SOeecow8++EA333yzBgwYUGWfVFACAAAAAACgVnJJcspcq3+q0qxZM0lSbGxshW3i4uJKta3M2rVrtWPHDjVv3rxUcrJYvXr1NGjQIEnSzz//XGV/EglKAAAAAAAAoNY699xzJUnbt29XXl5euW3WrVtXqm1lDh8+LEkKDg6usE1ISIgkKTU11aMxkqAEAAAAAAAAaqnGjRurS5cuKiws1Lx588psX7lypeLj4xUZGVluReTfNWjQQJJ7Hcr09PRy26xZs0aS1Lx5c4/GSIISAAAAAAAAqMUeffRRSdIjjzyiffv2lbyelJSkCRMmSJImT54ss/lEqvDtt99WdHS0Ro0aVaqvnj17qkGDBsrLy9Ott96qzMzMkm1Op1NTp07VmjVr5O3trREjRng0Ph6SAwAAAAAAgFrLIZPRQzDc1VdfrfHjx2vmzJmKiYnRRRddJIvFomXLlikzM1NXXnmlJk2aVGqflJQU7d69W5GRkaVe9/Hx0Zw5c3TFFVfoq6++0sqVK9WtWzf5+flp06ZNOnjwoMxms9544w21bNnSo/GRoAQAAAAAAABquRkzZqhPnz6aPn26Vq5cKYfDoejoaI0dO1bjx48vVT1ZlYsvvlibN2/Wa6+9puXLl+uXX36R0+lURESErrvuOt1zzz06//zzPe7P5HK5XCfzpoBTrW50uAbM9qz0F5CknPGhRg8BZxlTQpLRQ8BZyJmZbfQQcJYxWX2NHgLORk6n0SPAWcZVaDN6CDjLrLH9oEzncaOHcca17WjVzG+aGj2M0+rhq+to/fr1Rg/jH2ENSgAAAAAAAACGIUEJAAAAAAAAwDCsQQkAAAAAAIBayeUyyeGiPq+m4xMCAAAAAAAAYBgSlAAAAAAAAAAMQ4ISAAAAAAAAgGFYgxIAAAAAAAC1llMmo4eAKlBBCQAAAAAAAMAwJCgBAAAAAAAAGIYEJQAAAAAAAADDkKAEAAAAAAAAYBgekgMAAAAAAIBaySXJQX1ejccnBAAAAAAAAMAwJCgBAAAAAAAAGIYEJQAAAAAAAADDsAYlAAAAAAAAaimTHC7q82o6PiEAAAAAAAAAhiFBCQAAAAAAAMAwJCgBAAAAAAAAGIYEJQAAAAAAAADD8JAcAAAAAAAA1EouSU7q82o8EpTAaWD7KV+2r/Pl2O+QnC6Zm3jLMthXliutMplN1e7P5XDJtjhf9p8L5DjokPJdMoWYZW7lJZ9hVnn39q2yj4J3c1T4cZ4kyXeCv3yu96/2OHD69B8Qq8uH7FPzFhkym12Ki6ujn5Y217dLWsnl8nzOhIblqkePo2rdJlVt2qSqSdNMeXm59L9ZnbRgfnS5+5hMLkW3O65u3RPUqdMxNW6SKT8/u7KyfLRvbz19/10L/bG60al6qzhF+g8+psHXHFHzNtkye0nxB/3109eR+vaLhtWaM8XO631cV42KU+v2WbL4OJUY76eV34drwZwmstvKntBddEWC7p+6q9I+b+zfS2nHq45POHP6X3FcQ25KUvPoPJm9XIrbb9VP80K15KPwk5s3/TI0/LZEtemYI4uvS4mHffXLN/W0YFakbIVl503L9jnq2j9DXfpmqmmbPAUGOZSXY9aBnf76eUF9/Tw/9KTGgdOn/5AkXX59opq3zXEfnw7666cF4fr2s6iTmzN90zR8zBG17pAti69TiXFWrfw2TAtmN5StnFhTni690/T8+9slSWtX1NWUO9tXexw4ffoPTXbPmehc95w54OeeM59GnvycGXtUrTvkFM0ZX61cEqYFsxuUG2e69UtT70uPq+U5OaoXXqg6wXbZCs2KP2DV6p/qa9HcKOXnep2Kt4pTiOMTABKUwCmW/1q2bAvzJR/J6zyLTN4m2f+0qeD1HDn+tMn6XJ1qJSldGU7lPpQp5067FGSSV3tvmfxMciY55Vhvk72uucoEpWOnTYWf5UkmuS8foUaZMOlPDR22TwUFXtq0MVwOh1mdOx/TxLs2qPO5x/T8c709PiHq0ydOd4zfVK3fHxmVrdfeWCZJysz00Z7d9ZWdbVFkZI66dU9Qt+4J+nFpM73+ane5JxGMNuHxPRpy3REV5Ju1eW1d2e0mde6RpgmP71WnHml64f4O1TqJvvqWWI29/4AcdpO2rA9Rdqa3Ys5L1+i7D6p7v+N67LbOKsgv/8vc0cN+2r4xuNxtBQV8AaxJJj4Xq6GjklSQb9Km34Nkt5nUuXemJj53WJ17Z2rqndW7IHL1HQm67bF4OezSljVBys7wUkyPLI156Ih6DEzX5Ovblpo3Zi+Xpn+3Q5KUm23Wni0BSk+2KDSqUB26ZalTzyz1H5qqKbe3lq2AKoeaYMJT+zX0xgQV5Ju16Y9gOewmde6ZoYlPH1Dnnhl6/u7o6s2Z2+J160OH3HPm/4LdsaZbpkbfF6vu/VP16JgOFcaaYv6Bdt0zdZ+cTsnMNKlxJjx9QENvSjwxZ2wmde6VoYlTDqpzrww9P6lt9ebM7Ud068Ox7jmztmjOdM/Q6PsPq/uAVD06qn2ZOdN/aLIuvCJF8QesOrgrQJnp3gqpZ1O7c7PUpuNhXTQ8SQ/f0EFpKT6n+u3jJHF8AiD9ixOUJpM7wLlcNS9bM2fOHN1yyy0aPXq05syZY/RwUA22XwpkW5gvUz2T/N8Okbmx+8DnTHUq7+4M2X8tlG1BvnxG+nnUn8vpUu5kd3LSMtIq3zsCZPI9cXB25TrlTHBW3kehS/nPZ8tU1yyvdt6y/1Z48m8Qp1zvPnEaOmyfUo9b9dADF+ro0TqSpJCQfL30ygr17nNEw67Yq0Vft/Gov8TEQH39VWvt3VtPe/fU0zXX7dBFF8dWvpPLpE0bwzV/XrQ2boiQ03nixCsmJknPTP1Nl1x6SNu2humnH1uc9HvFqdH7oiQNue6IUpN99PCYc3X0sLsaOqR+oabN3qjeF6Vo2A3xWvRJY4/6a31Opsbce0D5uWY9eltn7d7qTjZa/ex6ZsYWxXTN0Ki7D+i9l1uXu//2jcF6/Yl2p+bN4bTpPShVQ0clKTXJogdHRuvoIaskKSTUppc+36Xel6Vr2JhjWvRBpEf9tY7J0djJ8crPNeuR69tq96ZASZLV36FnP9irjudnafRDRzTruSal9tuzxV/zZkZpzc8hpSpYmrXN1fMf7dF5/TJ17YQEffx6w1P0znGyel+SoqE3Jig1yaKHbuqoo7Huc5eQ+oV6ae5W9b7kuIbdfFSL5nr2WbXukKVbHjik/FyzJo+O0e4t7uOd1d+hZ9/drpju7kTlrBcrP87c8dgB1Y8o0PdfROry6xP/2ZvEKdX70uMaelOie87c0KH0nPl4u3pfkqphoxK06MMGHvXXukO2bnkw1j1nRrXX7s1/mTPv7XTPmfsPa9YLzUvtt2B2Q733YjOlHy+dgAwMtumpGbsV0z1TYx+K1auPlH9cw5nF8QlAMdL/wClUcgv1+ICS5KQkmeuZ5ftAYFGbXLmcniXGbYvz5dxml1cvi6x3B5ZKTkqSyd8sr5aVX2conJ0rZ6xD1gcDpACq32qaa67bKUl6f3bHkuSkJKWnW/X2m+e521y7UyaTZ3NmzR8N9e47XbR8WTPFxQV5dLU5ISFQjz4yQH+ujyqVnJSkrVvD9eUX7lvDLxxYRaITZ8Q1tx2WJL3/esuS5KQkpR/30dtT3Ynskbce9njOjLz1sMxmad4HTUqSk5KUn+et159sJ4dDGnLtEQXUsZ3Cd4Ez7doJCZKk2S82KvnyJ0npKRa9/XjTojaJHs+bayYkyGyWvpwZWfLlT5Lyc7302oPN3PPm5iQFBNlLtjkdJt09tL1++65emdvrDu321+wX3UtJXHjV8ZN7kzilrrkjXpL0/n+alSSapKJYM6WVu83t8Z7Pmdvj3bHmf41KkpNS0Zx5tI17ztyQoIA69gr76HpBqi4ZkaSvP2ygXZvrVNgOxiiZM680LTtnnnYnnq8Zd8TzOXNH0Zx5r2FJclIqmjOTW7nnzI2JZebMgZ0BZZKTkpSdYdGHr7uTUuf2Tq/We8Ppw/EJZ4rDZarVP7UBCcoa6KqrrtLOnTv14osvGj0UVIMzySHnbrtkkbwHlL3l2vtci0xhZrlSXXJur/jk+69sX+VLknyu9azi8u8c220q/CJP3hf7erROJc6s0NBctWmTJluhWb/9WrbabevWcKUk+6le/XxFtzPuhGj/vrqSpNDQPMPGALf6Eflq3T5LtkKTVv0YVmb7tvV1lXLMV/XCChXdMbPK/ry9neraxz23ViwpW5mQGO+nXZuDZfFxqVvf1H/+BmCI0MhCtemYq8ICk377tl6Z7VvXBik5waJ64TZFd8musj9vi1Pd+mdIklZ8Xb/M9sQ4q3ZtCJSPr0vdBmR4PM792wJKxgtjhUYUqE2HbNkKTfrth9Ay27euC1ZKoo97znTOqrI/b4tTXS9IkySt+KZs7EqMt2rXpiB3rOlXfqwJqGPXPc/t05FDVs19o2k13xFOt9DIArWJyXHPme/LxoWt/3cycyZdUgVzJs6qXRvruOdM/zSPx+mwu7/El7cGIc48jk8A/orIXAMFBwcrOjpaUVFRRg8F1eDc6046mpt5lal0LOYV7a52dOytOkHpTHHKecAheUle7S1yHnaoYE6u8l/JVsE7ObKvLax0iQJXgUv5L2TLVMck37sDTuId4XRr2cp9Qh0bG6TCwvIrYffscZ+stWzp+cn3qdawofuLRGqqtYqWON1aRrtPzmP3BaiwgvUd92xzV5m0bFf1F8BGzXNl9XcqM91bifHlXwjZs93dX4vo8vtr0DhPo+46oLue3qVbH9in/oOPyern2UUYnBkt2+dKkg7v9VNhBWtn7dnsPk60KmpbmUYt8t3zJs1LCYfLjwu7q9FfsQbN3Rfl0pIsHu+D06PlOUWxZq9/xbFmq7syqWW7qpMGjZrnFc0ZbyXEVRBrivs7J6fc7Xc+fkD1wgv13ydaVzgmGKf4c6t0zmyp/DP+q1JzpoI4U9Wc+Turv0M3TIqTJK1ZXjYZhjOP4xOAvyJBKWnWrFk699xz5e/vr/r162v48OHatm1bmXaHDh2SyWRSs2bNKuzLZDKVrG/5V7t379bo0aPVtGlT+fj4qE6dOmrWrJmuuuoqLViwoFTbOXPmyGQyacyYMaVe/+WXX2QymdS/f3/ZbDY9//zzio6OltVqVXh4uG666SYdPny4wrHFxcXpnnvuUdu2beXn56egoCD17t1bc+bMKTfRlZ6erscee0zt27eXv7+/rFarGjVqpP79+5db3fnjjz/q8ssvV3h4uCwWi+rVq6fo6GiNHTtWGzZsqHBctUXxWpDmyIpPmk0R5lJtK+3vgPsLvinIJNvX+coZlabC2bmyfZOvwk/ylPdgpnInZMiZVn5fBe/lyHnYId97A2UO4Z96TRQR6T6hTkqqOIGclOS+hTcy0rOT71PN19euYVfulST9vooneRstsqH7BDkpoeJkcXLRtoiitpUpbpPsQX+RFfTXvkuGrhsXq0FXJ2jEmDg9/NIOffjTH+p9cVKVvx9nRmTjAknSsfiKHwiRfNS9LaKorSf9JR2tuDK/Ov25uTTyTvdtfqt+qOvhPjhdIhpV/RknJbi3RTaq+jOOaFQcayrpr+h3lRdregw4rouuStL3X0Rq67ryH8oFY5XMmSOnas6423g0ZxqVf3yK7pyl+1/aqwde3qvnZu/QR7+tV7d+6Vr3S4g+esOzdZpxenF8AvBX/9qH5BS777779Oabb6pv37664oortGHDBi1cuFBLly7V0qVL1adPn3/8O7Zu3arevXsrKytL0dHRGjp0qEwmk44cOaKlS5cqLy9PI0aM8Lg/m82mQYMGae3aterXr5/atWunP/74Q5988ol+/fVXbdmyRSEhIaX2WbFiha666iplZGSoVatWuuyyy5Sdna01a9bolltu0fLlyzV37tyS9rm5uerdu7d27Nih8PBwXXTRRQoICFBCQoJ27NihNWvW6NFHHy1pX/xgH7PZrB49eqhp06bKzs5WXFyc5syZozZt2qhLly7/+O+yJnPlFiV5rRWv/2DyK9qWW/UaKq5MV8l/C97OkfdFvvIZ7SdzuFmOXXYVvJYj5za78p/MlP/bIaX2dWy1yTYvX959fWQZyK3dNZWf1Z2Ezs+vOBTn57m3+fkbs/7fxLv+VFRUjmIPBen771oaMgacYPUvmjN5FV8Iyct1b/MLcFTZn5+/oxr9la6KTE320WfvNtWaFaFKjPeTw2FS4xY5uvqWw+p9UYomv7JdT0/w0obVZW+xwpllLZoLBXkVX6wq/pz9A6q+gGYtalOQW0l/OcX9VT0PJemme4/qnPNylJrkrS+mcweJ0TyJDfk5pzbW5FcQuwKD7Lrr2f1KOuqr2a80q/J3wRgnPuOK40J+jnubX6AHc6ZoHuRXEmdOzJny41ZUk3xdPDy51Gu/LAnVu1ObKTf7X/81uEbg+IQzxSWTHNTn1Xj/+sg8a9YsrVixQhdccIEk91O9H3vsMU2bNk033HCD9uzZI6v1n93W+PrrrysrK0svvPBCqaSeJGVnZ2vr1q3V6m/16tXq2rWr9u/fr/DwcElSRkaGLrzwQm3YsEHTp0/X448/XtI+ISFBI0aMUHZ2tubMmaNRo0aVVHnGxcVp2LBh+uijj3ThhReWVG3Onz9fO3bs0OWXX66vv/5a3t4nporD4dDKlStLjenZZ5+VJP3222/q1atXqW3x8fHKzKx6LTT8TXFVq0Py6ugtv6dPLA7u3cVH5te8lHNDmhyb7bJvKJR3F/fVQFeBS3kvZEn+JvneH1hez4BHrr9xuy6+5JCysy164flestm4pQ4nbFhdv0zycfeWYD1/X4xue3Cfho+O020P7teE4SQoUbmBw1N0wz1HVVhg0rS7WyozjVvocML4J/erfnihnrz9HOXl/Ou/uqAaVnwTphXfhMns5VJYVIG6XpCmm+6O07vfb9JzE9tqG9W4qALHJ+DM+tenkMePH1+SnJTct2hPnTpVLVq0UFxcXJnbr0/GsWPHJEmDBg0qsy0wMFA9e/asVn8mk0nvv/9+SXJScq9b+cgjj0iSli1bVqr9G2+8obS0ND3wwAMaPXp0qVvQGzdurPfee0+S9NZbb5UZ80UXXVQqOSlJXl5euvDCC8u8x5CQkDLJSUlq1KiRzjnnnHLfy6xZs9S1a1d17dpVBeln9wM4TP5Ff6/5lawLmVe0zb/qp2yZ/tLGMrRsktwc7iXvnu6kpGPDieq6gndz5Ip3yjopQObQf/0/8Rotr6hy0mqteL2+4rX88nLP7AnRVSN2a9TobcrN9daTj1+gw7GcxNcE+blFc8av4qv+xVUsxRUClSmuSvCsP88TA5/PaiqH3aRmrXMUFln1reY4vYor3Xz9Kq4+Kf6cc3OqPm4UV0H5+lfSX0Bxf5XPw76DU3X/KwfldJg07a6W2vJHUJW/H6efJ7GhuPLpVMUaazmx6/yBx3XhsGT9vDBc639lzcCa7MRnXHFcKK5uy8v2YM4UzQNrJXHmxJypPG45HSYdi7fq20+jNOWOdgqoY9fDr+6Vr9WzCjqcPhyfAPzVvz57cdNNN5V5zcvLS9dff70k97qP/1T37t0lSXfeead++uknFRR4ut5F+Zo0aaKYmJgyr0dHR0uSjh49Wur17777TpI0cuTIcvs777zzFBgYqE2bNik/3/1Fslu3bpKkl156SR9//LHS09MrHVP37t2Vnp6uUaNGaePGjZU+vOWvxo0bp/Xr12v9+vXyDTm5J1XXFObIovUlEys+2XElOUu1rYwpyqvc/y+vjSv1xEHY/luhZJZsP+Qr9670Uj+O/3M/ea7wa/e2/GlVP0QDp8+xRPfak+HhFa8vGRbmXsD72LEz96CjYVfs0bg7Nik/30tTnuyrXTvLPsEVxjh21H2xIjyq4qRfaFFCsLitJ/2FVdJfWDX6K5adaVF6qjupXj/inx3z8M8Vr+0V0ajip4+GNSgsalv1siDFbcIbVPzZnuiv4nXFel+WqkfePCBJeuW+5lq9lLW9aopjRzz4jIueZnuskjUHT/RXHGsq6a9oW3FbSep10XFJUrM2OXpp7pZSP9eMi5ckteucVfJaccIKZ15JXGjoyWfsyZzxLbVPpf3Fe3582r25jg7v91dYVKHadqr6AU84vTg+Afirf32Csnnz5uW+XvwgnPj4+H/8Ox566CENHDhQa9eu1SWXXKLg4GCdf/75euSRR6p9e7fkTlCWJyjIfVWnOMlY7MABd3Dt1q1byUN8/vpjNpuVnZ0tp9Op48fdJ4L9+/fXww8/rKSkJN18882qV6+ezjnnHI0bN05Lly4t87tnzJihFi1a6KOPPlKXLl1Ut25dXXLJJXr55ZeVmJhY7fd4NjK3dlcXOQ855CooP0Hr2GUv1bbS/pp4SUU5W1dG+VcBS173+1tFplNybLKX+XGlFq1redTpfm03T9o10v797pOdpk0z5eNT/mfRpm2qu+2+kDMypiFD92r8xI0qKPDSM0/30dat4VXvhDNm/073sg1NW+XIx7f8L+JtOrgvPBzYWfUSD/EH/JWfZ1ZQiF2RjcqvYi/ub/8uz5eMMJtdCggsWi8zl6UBjLZvu/thW01a58nHt/zjSZuO7gsl+4vaViZuv9U9b+o6FNWk/OR2207F/ZV/caXnJWma/NYBmcwuvfZgc61czFIANcn+HUWxpnVuxbEmpig2eBRr/IrmjF1RjcuPNW07Zhf1V3bOtGqfo449Mkv9NG7h7ieorr3kNS8vzy6Q49Tbv8P9uVU+Z7JLta1MqTlTUZypZM5UJiPVfR4eUt+Y9b1xAscnAH/1r09QnkpOZ/lB1d/fXz///LPWrFmjKVOm6IILLtD27dv18ssvq2PHjiXrN3rKbK7ex+ZwuE8Srr32Wo0ePbrSH1/fE1emXnrpJe3bt0+vv/66hg8frrS0NL333nu67LLLdOmll8puP5FQadeunXbt2qXFixfrvvvuU9u2bbVixQo98sgjatmypX744YdqjflsZI7wkrmNl2ST7CvKXrWzb7TJleSUqZ5JXh2qTlCavE0nbuH+s+wJlMvukmOz+3Wv6BP9Bc6rpzq/hZb7432Z+/P1neCvOr+FKuADrgYaKSXZX3v31pXFx6m+F8SV2R4Tk6SwsDylHrdq5xmoYhx8+T5NvGuDCgvNenZKb23aGHnafyeqJ+WYVXt3BMri41KfS5LLbO/QNU1hkQVKTfbRzs1V35Zvt5v15yr3ifeAIWUvJkU2ylN0pwzZCk1a96vnJ+jd+6XI6u9UbraX4g5W/YUCp1dKgq/2bvWXj69LfS9PLbM9pkemwhrYlJpk0c4/q0422W1mrf/FPb8GXHm8zPbIxvmK7pKtwgKT/m952XnYY2C6Hpu+X17eLr3xSDMtW0iVdk2TkuirvdsCZPFxqe9lKWW2x3TLUFhUoXvObKxTTg+l2W1mrf/Vfc4xYFjZ2BXZKF/RnTNlKzTp/345cSv3a4+20aC2fcr9eXVya0nS2hV1S17LyWKNSqOUmjODysaFmO4nM2dCJFUwZxrnK/rcLPecWeH5+ax/oF2tO7gTVEcO/bPnDOCf4/iEM8npMtfqn9qgdryLf+DQoUOVvt6wYcOS13x83Mmi7OzybweIjY2t9Hf16NFDTz/9tH788UcdP35cH3zwgby9vTVlyhTt3r27+oP3UOPGjSVJTz75pObMmVPpT2ho6SDcvHlz3XvvvZo/f74SEhL022+/qVGjRvrxxx/1/vvvl2prsVg0ZMgQvfbaa1q7dq2SkpJ0zz33KDc3V7feeutpe381ic9N7i/iBTNz5Iw/cfXYmeZUwWvZJW1M5hMVj4UL8pRzY5ryppa93drnZn/37dqL82Vfe+LWB5fDpYKZOXIdccoUZpb3BTyp+2z15eftJEljb92iqAYn5kBwSL4m3vWnu80X7eRynZgzQ4ft1azZ3+mBh9acsnFcNmi/Jt71pwoLzXrumT7a8CdPKaypvvxfU0nS2Pv2K6pxbsnrwfUKNfHxPZKkebOblJozQ66P17vfrNUDz+8o29/sJnI6pZG3HFabDiceaGb1s+veZ3fJy0ta8kVD5WSdWAfV1+rQ4GuOlKyR+lfd+qbo7qfdx7QlnzeUw/6vP9WoEb6Y4f43feuj8YpqeqKqJLi+TZOmxha1iSwda0Yf03vLturB1w6U6e/LGZFyOqVrxieqzV9uk7T6O3T/K4fc8+ajcOVklk4YdRuQrsdn7pOXt0tvPtpMP80LO6XvE6fOl7Pc549jHzykqCYnqh6D6xVq4tP73W3ea1R6ztx4VLO+/1MPvFT2vHbee43csea2+JLqS8k9Z+57YY97znwaRZLxLPblu+7vTWMfii07Z6a448iXsxqWnjM3JWjWDxv1wMt7y/Q3792G7jlz+xG16fi3OfPiPvec+SSy1JwJrleoy29IlH9g2eNTeMN8PfrfPQqo49CeLQEllcIwFscnAMX+9WcAn3zyiTp16lTqNYfDoc8//1yS+1bnYmFhYfLx8dHx48eVnJyssLDSQat4rUdP+Pj4aMyYMZo9e7ZWrVqlLVu2qG3btif/RioxaNAgvfXWW5o3b57at2//j/rq06ePxowZo6lTp2rz5s2Vtq1bt65eeeUVvfXWWzp69Gi5f2e1jWWArxxX2mT7Ol85o9Pk1dUik7dJ9j9tUo5L3n19ZBle+mqtK8Mp52GHTPXKPjjHq5W3fO8KUMGbOcp7KFPmdt4yh5nl2GuX66hTCjTJ79k6MvlW/dAd1EyrfmusJYtbasjQ/Zr57lJt2hghu92kzucmKSDAptW/N9Tib1qV2icouECNG2cpLbXslf+69fL01NOrSv4cFeWuEhh6xV716XuiSvPZZ/ooLdW9hkCLFmm66571MpulxMQAXdDvsC7od7hM35kZvvrfe51PxdvGP/D7T+Fa8nmahlx3VDO+WqdNa+q650yPNAXUcWj1slAt/qxRqX2CQ2xq3DxXaSll11vauz1Ic95oobH3H9CrH23Q5v8LUU6Wtzp0TVfd+jbt2hykuW+2KLWPt8WpSU/u0e0P7dP+nYFKTrTK2+JU4xa5atIit2icYfpoevnLqODMW/VdPS3+KFNDb07WOz9u08ZVQXLYTercK0sBQQ79/kOIFn8YUWqf4Lp2NW6Vr7Tksg/p2rMlUO9Pa6TbHovX61/t1KbVQcrJ9FJMjyzVDbNr54YAffhKw9L91bfpyXf2ycfXpeSjFrXvmqX2XctfC/nVB1uU+zrOnFVLQ7Xk00gNuSFRMxdv1KbVwbLbzercM90da36qp8UfNyi1T1Bdmxq3yCt/zmytow9ebaZbHzqk1z7frM1rQpSd5a2YbhmqG2rTrk119OHrTc/U28NpsOqHUC35JENDbjymmd9uLpozJnXumeGeMz/W0+KPSl8ADaprU+OWeUpLqWDO/Kepbn04Vq99sVWb1wQrO9NbMd0zi+ZMoD58rfTSV75+Tk165oDGPXZQB3YG6NgRX5nNUliDArU6J0feFpeOHLLqxXtPz/cuVB/HJwDF/vUJyhkzZmjYsGHq06ePJMnlcunpp5/W/v371bBhQ40YMaKkrcViUd++fbVs2TI9/fTTmj59eskTsVetWqWnnnqqwt8xcODAMgnIAwcOaPv27ZKkpk1P3wnZQw89pA8//FAvvPCCwsLCdMcdd5R5Mvf27du1e/duDR8+XJK0cOFC1a9fX3369Cl1S3leXp5+/vnnUmPOzc3VO++8o5tvvrlMAvLbb7+V0+lUUFCQQkJCTtt7rEmsDwTKq6O3Cr/Kl2OTXXK6ZG7iJcvlVlmutJaqnvSEz9V+Mrf0UuFneXLusMu+xy5TfbMsw6zyuclP5goeoIOzx/S3umr7tjANGbZXMTFJMnu5FBcXpB9/aK5vl7QqdcW4KhaLU9Htyt4iExGRq4iI3FLtigUE2lT8z7xJkyw1aVL+CdmxRH8SlDXEjOfbasfGEA25Ll4xXdNlNrsUd8hfPy2M0rdfNKzWnJGk+R801cE9gRo+Ok6tO2TJx8epxHirvvmkkRbMaSK7rXQVZEGelz57t6nadMhUo2Z5at42R94WpzJSLfpjRaiWLYrU6mW1+4LU2Wj6E820fV0dDR2VpJgeWfLycq/X9eOXoVryUXj15827UTq4y18jbk9Um0458vF1KvGwrxbNidCCWZGyFZaeN1Y/p3ys7jUCwxrYdPHIsrffFeMLYM0w/ZlW2v5nkIbcmKCY7pnuWHPATz8uiNC3n0VVf878r5EO7g7Q8FuOqHVMlnx8XUqMs+qbjxpoweyGstmouD7bTZ/SsmjOJJaeM/PD9e2nkdWfM+811MFd/hp+61G1jskumjO++mZulBbMblAmzmQct+i9F5uqQ7dMNWuTqyat8mTxcSo701vb1gVp9U/19MOXEWX2g7E4PgGQJJPL08ct1zLFicV7771Xb775pi644AJFRUVpw4YN2r17t/z8/PT999+rX79+pfZbvXq1BgwYoMLCQrVr107t27dXbGys/vzzTz322GOaOnWqJJV6inXnzp21efNmtWjRQh06dFBgYKASExO1atUqFRYW6rrrrtNnn31W0n7OnDm65ZZbNHr0aM2ZM6fk9V9++UUDBgxQv379yn26+KFDh9S8eXM1bdq0zK3rK1as0NVXX63U1FRFRUWpffv2Cg8PV3p6urZu3aq4uDhde+21JZWj9957r/773/8qLCxM5557rsLCwpSRkaHVq1crNTVV0dHRWrNmjYKDg5Wenq66devKy8tLMTExat26tcxms/bv36/169fLZDJpxowZuvPOOyv9TOpGh2vA7BGVtgH+Kmc868KgekwJSUYPAWchZyZPekX1mKwsvYKTUMF69kBFXIU86AfVs8b2gzKdFSdga6sWMQGaurCD0cM4rV67zqH169cbPYx/5F9fQfnaa6+pdevWevfdd7V27VpZrVZdeeWVevbZZxUTE1Omfa9evbRs2TJNmTJFa9euVWxsrNq3b6+5c+fqxhtvLElQ/tXUqVO1ZMkSrV27VqtXr1ZmZqYiIiLUr18/3X777aWqNE+XAQMGaPv27Xrrrbf07bffas2aNbLZbIqMjFSLFi00YcIEjRw5sqT9mDFjZLVatWrVKm3btk0pKSkKCQlRq1atdP311+vWW29VnTruBa4DAwM1c+ZM/fLLL9q0aZOWLl0qm82mhg0b6oYbbtDdd9+tHj16nPb3CAAAAAAAgLPPv7aCEjUPFZSoLiooUV1UUOJkUEGJ6qKCEieFCkpUExWUqC4qKGuv2lBByeIbAAAAAAAAAAxDghIAAAAAAACAYf71a1ACAAAAAACgdnLJJEc1nwaPM48KSgAAAAAAAACGIUEJAAAAAAAAwDAkKAEAAAAAAAAYhjUoAQAAAAAAUGs5qc+r8fiEAAAAAAAAABiGBCUAAAAAAAAAw5CgBAAAAAAAAGAYEpQAAAAAAAAADMNDcgAAAAAAAFAruVySw0V9Xk3HJwQAAAAAAADAMCQoAQAAAAAAABiGBCUAAAAAAAAAw7AGJQAAAAAAAGopk5wyGT0IVIEKSgAAAAAAAACGIUEJAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMPwkBwAAAAAAADUSi5JDhf1eTUdnxAAAAAAAAAAw5CgBAAAAAAAAGAYEpQAAAAAAAAADMMalAAAAAAAAKi1HNTn1Xh8QgAAAAAAAAAMQ4ISAAAAAAAAgGFIUAIAAAAAAAAwDGtQAgAAAAAAoFZyySSny2T0MFAFKigBAAAAAAAAGIYEJQAAAAAAAADDkKAEAAAAAAAAYBgSlAAAAAAAAAAMw0NyAAAAAAAAUGs5qM+r8fiEAAAAAAAAABiGBCUAAAAAAAAAw5CgBAAAAAAAAGAY1qAEAAAAAABAreSS5HRRn1fT8QkBAAAAAAAAMAwJSgAAAAAAAACGIUEJAAAAAAAAwDAkKAEAAAAAAAAYhofkAAAAAAAAoJYyySGT0YNAFaigBAAAAAAAAGAYEpQAAAAAAAAADEOCEgAAAAAAAIBhWIMSAAAAAAAAtZJLktNFfV5NxycEAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMOQoAQAAAAAAABgGB6SAwAAAAAAgFrLIZPRQ0AVqKAEAAAAAAAAYBgSlAAAAAAAAAAMQ4ISAAAAAAAAgGFYgxIAAAAAAAC1kstlktNFfV5NxycEAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMOwBiUAAAAAAABqLQdrUNZ4JChRYzgPeSn31mCjh4GzSOTcI0YPAWeZY5dbjB4CzkYup9EjwFnG5EOsQfU5s3OMHgLOMubAAKOHgLOMKYMkHWouZicAAAAAAAAAw5CgBAAAAAAAAGAYEpQAAAAAAAAADMMalAAAAAAAAKiVXJKcMhk9DFSBCkoAAAAAAAAAhiFBCQAAAAAAAMAwJCgBAAAAAAAAGIY1KAEAAAAAAFBLmeRwUZ9X0/EJAQAAAAAAADAMCUoAAAAAAAAAhiFBCQAAAAAAAMAwJCgBAAAAAAAAGIYEJQAAAAAAAGollySny1Srf6rj008/Vd++fRUcHKzAwEB17dpV06dPl9Pp9LiPQ4cOyWQyefTz66+/etQnT/EGAAAAAAAAarmJEydqxowZslqtGjhwoCwWi5YtW6ZJkyZp2bJlmj9/vszmqmsZAwMDNXr06Aq379ixQ+vWrVOdOnV03nnneTQ2EpQAAAAAAABALbZgwQLNmDFDkZGR+vXXX9W6dWtJ0rFjxzRgwAAtXLhQb731lu65554q+woNDdWcOXMq3D548GBJ0nXXXaeAgACPxsct3gAAAAAAAEAt9uKLL0qSXnrppZLkpCRFRERo5syZkqRp06ZV61bv8hw5ckRLly6VJN16660e70cFJQAAAAAAAGotx7+8Pi8+Pl5//vmnfHx8NHLkyDLb+/Xrp4YNG+rIkSNas2aNevXqddK/a86cOXI6nWrfvr169Ojh8X7/7k8IAAAAAAAAqMU2btwoSWrfvr38/PzKbdOtW7dSbU9W8a3f1amelEhQAgAAAAAAALXWwYMHJUlNmzatsE2TJk1KtT0ZK1eu1L59++Tj46Obb765WvtyizcAAAAAAABwlkpOTlbXrl1L/jxu3DiNGzeu5M/Z2dmSVOkDawIDAyVJWVlZJz2O999/X5I0bNgwhYaGVmtfEpQAAAAAAADAWSosLEzr1683dAyZmZmaP3++JGns2LHV3p8EJQAAAAAAAGoll0xyukxGD8NQxdWROTk5FbYprrKsU6fOSf2Ozz//XLm5uWrUqJEuvfTSau/PGpQAAAAAAABALdWsWTNJUmxsbIVt4uLiSrWtruLbu8eMGSOzufrpRhKUAAAAAAAAQC117rnnSpK2b9+uvLy8ctusW7euVNvq2LFjh9auXSuTyaRbbrnlpMZIghIAAAAAAACopRo3bqwuXbqosLBQ8+bNK7N95cqVio+PV2RkpHr27Fnt/mfPni1JGjBggFq0aHFSYyRBCQAAAAAAgFrLKXOt/vHEo48+Kkl65JFHtG/fvpLXk5KSNGHCBEnS5MmTS92e/fbbbys6OlqjRo2qsF+bzaaPP/5YknTrrbdW+7MpxkNyAAAAAAAAgFrs6quv1vjx4zVz5kzFxMTooosuksVi0bJly5SZmakrr7xSkyZNKrVPSkqKdu/ercjIyAr7XbJkiZKSkhQSEqLhw4ef9PhIUAIAAAAAAAC13IwZM9SnTx9Nnz5dK1eulMPhUHR0tMaOHavx48ef1MNtih+Oc8MNN8hqtZ702Ewul8t10nsDp1CwNUo9m402ehg4i0TMTTJ6CDjLHLvcYvQQcBZyZmQaPQScZczBQUYPAWchZ3aO0UPAWcbs72/0EHCW+SNjoTLsyUYP44yLbF9PN316sdHDOK1+uXW/1q9fb/Qw/hHWoAQAAAAAAABgGG7xBgAAAAAAQK3kckkOl8noYaAKVFACAAAAAAAAMAwJSgAAAAAAAACGIUEJAAAAAAAAwDCsQQkAAAAAAIBay8kalDUeFZQAAAAAAAAADEOCEgAAAAAAAIBhSFACAAAAAAAAMAxrUAIAAAAAAKBWcskkp4v6vJqOTwgAAAAAAACAYUhQAgAAAAAAADAMCUoAAAAAAAAAhiFBCQAAAAAAAMAwPCQHAAAAAAAAtZZDJqOHgCpQQQkAAAAAAADAMCQoAQAAAAAAABiGBCUAAAAAAAAAw7AGJQAAAAAAAGollySnizUoazoqKAEAAAAAAAAYhgQlAAAAAAAAAMOQoAQAAAAAAABgGBKUAAAAAAAAAAzDQ3IAAAAAAABQS5nkdFGfV9PxCQEAAAAAAAAwDAlKAAAAAAAAAIYhQQkAAAAAAADAMKxBCQAAAAAAgFrLKZPRQ0AVqKAEAAAAAAAAYBgSlAAAAAAAAAAMQ4ISAAAAAAAAgGFIUAIAAAAAAAAwDA/JAU6D/gPjNPiKA2reIkNmL5fiD9fRT9831beLWsjl8nxx3tCwXHXvmajWbdPUJjpNTZplycvLpf/N7KCvvmhT5f7ndU/UVSP3qXXbNFl8nEpMCNDKZY204IvWstu8/slbxCmWu9Sm3K9ssu1zSE7Ju6lZ/kMs8h9ukclc/QWdXQ6XchfZlPejXbYDDrnyJXOISZbWZgVc6SNr3/LDvyvfpex5hcpfbpc9zinZJHM9kyztvBRwrUW+nThs1BT9Bx/T4GuOqHmbbJm9pPiD/vrp60h9+0XDasWZYuf1Pq6rRsWpdfssd7yI99PK78O1YE4T2W1lr2dedEWC7p+6q9I+b+zfS2nHfas9Fpw+/a9I1ZCbk9U8OldmLyluv1U/fVlfSz4KO7l50y9Dw28/pjYdc2XxdSrxsK9+WVRPC2ZFyFZYdt4E1bXr/IvT1aZTjtp0zFWz6Dz5+Lr0zZwwzXiqyal4izjFiDWorv7DUjTkpiQ1b5sns5fLHWfmh2nJx+EnN2cuSNfw2xLVJiZHFl+XO84srq8F70WWG2danpOjrv0z1KVPhpq2yVNgkEN5OWYd2Omvn78K1c8LQk9qHDi9+l9+TIOvPVoUa1yKP+Cvn76O0refNzi5edPnuK4aFa/WHYpjjVUrv4vQgg8alx9rrkzQ/c/vrrTPG/v1VFoKseZs5HJJDv7d13h80wROsQn3bNKQqw6ooMCszRvCZbeb1LlLsibcu1mduiTrhad7eHyQ7d3vqO6YtOWkxnH1dXs09s5tcjhM2rIpVNlZPorplKLRt+1Q956Jeuz+PiooIATUBOmv5Ct3gU3ylXy7esnkbVLBOrsy/lOggnUO1X3RWq0kpTPDpeP35cq2wylTkOQT4yWT1SRHklMF6x3yqmcvN0FpP+rU8btz5Yh3yRxqku953pKX5Eh0Kn+lXZZWZhKUNcSEx/doyHVHVJBv1ua1dd1xpkeaJjy+V516pOmF+ztU62T+6ltiNfb+A3LYTdqyPkTZmd6KOS9do+8+qO79juux2zqrIL/8ixpHD/tp+8bgcrcVFHAhpCaZ+NxhDR2drIJ8kzb9HiS7zaTOvTM1cWqcOvfO0tQ7q3cR7eo7E3XbY0fksEtb1tRRdoaXYnpka8zDR9VjYIYmX99GBfmlvwS275at+/8Te6rfGk4TYg2qa+KzhzT05qQTccZuVudeGZr4bKw698rU1Amtqjdn7kjQbZPjiuJMkLIzvRTTPUtjHoxXjwvTNPnG6FJzxuzl0vRvt0uScrPN2rMlQOkpFoVGFapDtyx16pml/kOPa8rtbcpNbsIYE57YoyHXH3XHmjUh7nlzfpomPFEUa+5rX715M/awxj5wwD1v1oUoO9OimK7pGn1PUay5tVMlscaq7RsqiDUV7APg1OCb5r9Ys2bNFBsbq4MHD6pZs2ZGD6dW6H3BEQ256oBSj/vq4bv76eiRQElSSN18TXv9N/W+4KiGDd+vRQtaedTfsQR/fT2/pfbtrqu9u0N0zY17NPDSw1Xu17ptmsaM26b8PC89en9f7d5ZT5Jk9bPrmRdXK6ZzikbdtkPvTe948m8Wp0TecptyF9hkrm9S6Ex/eTdxnyw7jjt1fGKe8lfalTPPpsBrfTzqz+V06fiD7uRkwLUWBU3wlcn3xAmdM8clR4KzzH7OPJc7OXnEpToTfBR4o49MXn/ZL8MlZ4brH75bnAq9L0rSkOuOKDXZRw+POVdHD/tLkkLqF2ra7I3qfVGKht0Qr0WfNPaov9bnZGrMvQeUn2vWo7d11u6t7pNyq59dz8zYopiuGRp19wG993LrcvffvjFYrz/R7tS8OZw2vQelaejoZKUmeevBq9vq6CGrJCkk1KaXvtij3oPSNeyWJC16P8Kj/lp3zNHYyUeUn2vWI9e10e5NAZIkq79Dz87Zp47nZ2v0w0c069nS8zA9xVuL54Zp31Z/7d3qr76D03T93Ymn9s3ilCDWoLp6X5aqoTcnKTXJogevbVc6zny6U70vS9Ow0ce0aE6kR/21jsnW2Ifj3HHmxmjt3uQ+r7b6O/Ts+3vUsUeWRj8Yr1lTm5bab88Wf817t4HW/BxSKgnZrG2unv9wt867IFPXTjiqj99odIreOf6J3hcna8j1R92xZlTn0rHmg03qfXGKht14RIs+9uzzat0+U2PuK4o1Yztr99YgSZLV365nZmxVTLcMjbrnoN57qfzvY9s3BOv1x4k1gBG4bAScQtfc6L4t4P13O5QkJyUpPc2qt1/vLEkaecNumUyeJXrW/N5As97upOU/NVHc4SA5PcwPjbxht8xmad5nbUqSk5KUn+et1186Tw6HNOSKAwoILPSsQ5w22XPdn0HQRN+S5KQkedU3K/hh35I2Lg8//NxFNtm2OuXb20vB91lLJSclyRxgkqVV2au/2R8UyhHvUsAIi+qM8i2VnJQkc7Cp1PhgnGtuc1+keP/1liUn8ZKUftxHb091L/0w8tbDHseZkbcedseLD5qUJAykonjxZDt3vLj2iALq2E7hu8CZdu1EdxJw9ouNSpIGkpSeYtHbj7lvrb52QqLH8+aaCYkym6UvZ0aUJCclKT/XS6892Mw9b25OVkCQvdR+OzcEavoTTbT0i1Ad2OEvh4PbrWoqYg2q69rxRyVJs19qXDbOPNmsqE2C53FmfII7zrwTVZKclIrizEPN3XPmpiQF1DkRZ5wOk+6+ooN++65emQrJQ7v9NXuaO6F+4ZXHT+o94tS75jZ3Vf37r7UoG2ueLYo1t1Uj1txWFGveb1KSnJSk/Fxvvf5EtHveXEesAWoivm3+iy1btkw7d+5Uw4YNjR5KrVA/LFet26bLVmjWql/KXuHbtjlMKclW1atfoOhzUk/bOLy9nera/ZgkacXPZasaEhMCtGtHfVl8nOrW49hpGweq5khyyrbLKVkkvwvLFrT7dvGWOcwk53GXbNvKVj2WJ2e++2Qr8AbPKi4lyWVzr1cpSQHV2A9nXv2IfLVunyVboUmrfgwrs33b+rpKOearemGFiu6YWWV/3t5Ode3j/pK2YknZipbEeD/t2hwsi49L3fqevriF0ys0slBtOuaqsMCk35bULbN969o6Sk6wqF64XdFdcqrsz9viVLf+7vm14uv6ZbYnHvbVrg0B8vF1qduAquchah5iDaqrVJz5tl6Z7VvXBhXFGZuiz82usj9vi1Pd+mVIklYsKifOxFm1a0NgUZxJ93ic+7f7l4wXxqsfka/WHbLdsWZpebEmRCmJPu5Y08mDWGNxqmsfdwxZsaTsHQHuWBPkjjUXEGv+bZwuc63+qQ1qx7vASWnZsqWio6NlsViMHkqt0LKV+yQq9lAdFRaWvz7Jnl3uL4YtW6eftnE0apwlq59DmRk+SjwaWG6b4nG0OI3jQNVsu91JR0tzs0zW8quIfM5xzyXbHkeV/TlSnLLvd0pekk8HL9kPO5X1foHSp+Urc0aB8v+wy+Uqe/XZtsspZ4ZL5jCTvBuYVbjLocx3i/abVaCCTfZyfhuM0DLa/aUudl+ACitYc23Ptjrutu2yquyvUfNcWf2dykz3VmK8X/n9bXf31yK6/P4aNM7TqLsO6K6nd+nWB/ap/+BjsvoxZ2qSlh1yJUmH91hVWFD+qd+eze4qyFbtc6vsr1GLAve8SfNSQmz5DwvYXY3+UPMQa1BdLdu7L24c3utXcZzZ4j4v9SzO5J+IM4et5bbZvaX6caZBswJJUloy339qgpbtPIk1QaXaVqZRs7/EmrgKYk1Rfy2iy++vQZM8jbr7gO6aslu3PrhP/S8/Jqs/sQY4E86KBGVOTo5efvlldevWTUFBQfLz81P79u01ZcoUZWeXH1jWrl2rG2+8UU2bNpWvr69CQ0PVtWtXPf300zp+vGxJ/7fffqtBgwYpNDRUPj4+aty4sUaPHq2dO3eW23+zZs1kMpl06NAh/fTTTxo4cKCCg4Pl7++v888/X998802F7yclJUWPPPKIoqOj5efnp6CgIJ1//vmaMWOG7PaywW/OnDkymUwaM2aM0tLSdPfdd6tJkyby8/NTu3bt9M4775S03b59u6655hpFRETIz89P3bt319KlS6t8D3/ncrn05ZdfatCgQQoPD5ePj48aNmyogQMH6q233irVNj8/X9OmTVOXLl0UGBgoX19fRUVFqWfPnnriiSeUn59f4d9FbRIZ5T4xSzrmX2Gb5KJtEVGn7wtbRNE4kpPKPyi7x+HeVjxmGMN+1J2g9IqqOBR7RZhKta2Mbb+7jTnIpJyvbEq6PkdZswqV+7VN2XMLlXpfnlLG5cqR6vzbfu7kp1eYSRlv5itlTK6yPyja7/1CHb8zT6mP5MmZxxqURots6I6nSQnlf1mTpOSibRENq469xW2SPegvsoL+2nfJ0HXjYjXo6gSNGBOnh1/aoQ9/+kO9L06q8vfjzIhs7K4UOnak4iePJh91V09HNK66qiiyifsLftKRiiuuk4u2RRS1xdmFWIPqimzs/rfuWZypOi4U95d0tLL+fD3uz82lkXckSJJW/VC2yhNnXkmsOVpZbCj6nBvmVdlfRCNPYo27v8hG5ffXvkumrrvjsAaNTNCIW+L18Ms79eHPa9T7EmINcLrV+IfkxMfH69JLL9WOHTsUFhamnj17ymq1at26dXrmmWe0cOFC/fLLL6pb98QtSy+++KIef/xxuVwutW/fXj179lRWVpb27NmjZ599VgMGDFD//v1L2j/66KOaNm2azGaz+vTpo4YNG2rLli2aO3euvvzyS82fP1+XX355ueObPXu2nn/+eXXr1k2DBw/W7t27tXbtWl155ZX68ssvdfXVV5dqv2/fPl144YWKi4tTZGSkhg4dqtzcXK1YsUITJ07UwoULtWTJEvn6lj0Yp6enq2fPnsrMzFSfPn10/Phx/frrrxo/frwyMjJ0wQUX6JJLLlHTpk01YMAA7d27V+vWrdPll1+u5cuX64ILLvDo77ywsFAjR47UN998Iy8vL51//vlq0qSJjh07pm3btmn58uW66667JElOp7Ok/+DgYPXr10/BwcE6duyYdu/ereeff16TJk1SZKRni2GfzYqv4ufnV/zPKi/Pvc3P7/SteeLn56jGOLgaaCRXUcLPVPE5lEx+7gSly4OctivT3Z8z06XM/xbI7xJvBd7iI69ws2y7HMp4pUC2rU6lPZ6v0JknEunOov1se5zuh+tcZ1HA1T4yB5tUuNGh9Ffylb/SroxX8lX3qYoT3zj9iq/g5+dV/BTJvFz3Nr+Aqqtu/fwd1eivdLxITfbRZ+821ZoVoUqM95PDYVLjFjm6+pbD6n1Riia/sl1PT/DShtVlb83DmWUt+pwLciu+GJKX497mH1j1vLH6uy9yFORV0l/R7/IP8Gx5CtQsxBpUV/XigidxxoO4VY3+JOmme47onPOylZps0RczojzaB6eXtSQ2VPY5n0ysqX5/qcm++uydplqzor4S4/4Sa8bGqffFKZr8nx16ery3NvxOchs4XWp0gtLlcumaa67Rjh07NGnSJL388svy83N/Oc7Ly9O4ceP08ccf67777tOcOXMkSQsXLtRjjz2mwMBAffrppxo6dGipPtetW6eoqBMHpO+++07Tpk1TQECAvvvuu1JJvFdeeUUPP/ywbrzxRu3Zs0fh4eFlxvjyyy/ru+++02WXXVby2tSpU/Xkk0/q0UcfLZOgvOGGGxQXF6eRI0dq7ty5slrdmYm4uDhddNFF+vnnnzVlyhS9+OKLZX7XokWLdPXVV+ujjz4q2e/777/X4MGDNXXqVNWvX19TpkzRAw88ULLPQw89pP/85z965plntGzZMo/+3h9++GF98803atOmjRYtWqTo6OiSbQ6HQ99++23Jn1etWqXly5erS5cu+vXXXxUQcGKhfJfLpdWrVysoKEgATj9XcR7AIfl08lLdZ08kE33P81b9N81KGpmjwo0OFfxpl+95RYeA4v3skt9l3gq+90TG1HqBt+qF+SllbK7yvrerzlinvBudFcX3OM02rK5fJiGwe0uwnr8vRrc9uE/DR8fptgf3a8JwkgYATh6xBqfCwOEpuuHuoyosMGna3S2VmcYt3ihtw+/1yiQfd28J1vP3Buu2h/Zp+Jh43fbQPk34vbtBI8Q/4ZJJThcP5qvpavS3zB9++EF//PGHzj//fP33v/8tSU5Kkp+fn9555x2Fh4frk08+UVpamiTpmWeekeROLv49OSlJ3bp1U6NGJx5g8uqrr0qS7rnnnjIVhg899JDOP/98ZWRk6L333it3jHfddVep5KTkTvAFBwdr3759Onz4cMnrv/32m9atW6c6deronXfeKUkySlLjxo313//+V5I0ffr0cm+LrlOnjmbOnFlqv0GDBqlTp07Kzs5WgwYNSiUnJXd1qOROJNpsVVftJSUlaebMmTKbzfrqq69KJSclycvLS8OGDSv587Fj7oes9O3bt1RyUpJMJpN69+4tf/+Kb3muTfKLqhKt1oqrEosrFvPyTt9JUV5RdYJn46jR1yhqvZLqyErujiupsvTgn5HZ/8RB1/+KsnPMK9ws397uz7zgzxNXjU1V7OfTzkuWaLPkkgo3elalgNMjP7cozvhV/DkUVw/k5VRcqVSsuIrAs/48jxefz2oqh92kZq1zFBb571jmoybLL/qcff0rrmb0K6p0zM2uet7kF1Ut+fpV0l/R78rNqdGnmqgAsQbVVb244Emc8SBuedhf38Gpuv+lA3I63MnJLWsonqgp8ktiQ2Wf88nEmlPTX7HP320qh11q1jpXYVHEGuB0qdFnjd99950kacSIETKbyw41ICBAXbt2ld1u17p165SYmKjNmzfLYrFo9OjRVfZvt9v1+++/S5LGjBlTbptbbrlFkvTLL7+Uu33IkCFlXvPx8VGLFi0kSUePHi15feXKlZKkoUOHql69sqXhl112maKiopSVlaU///yzzPauXbsqNDS0zOutWrUq2f/v6tWrp/r166uwsLDctTf/bvny5SosLFTPnj3Vvn37Ktt36dJFXl5emj17tmbMmFGSsPTUrFmz1LVrV3Xt2lWFjrN7If1jie4MUnhExe8jNDyvVNvTMw53ojgsvOJ1WsJKxhFQYRucft5Fa086Eio+iXIcc5VqWxmvBqZy/79Umyj3687jJ9aT9G5gLvf/S/ddNNbj3K5ppGNFazSFV3JyHFr0Jf1YJes5/b2/yk62w6rRX7HsTIvSU93J7voRrEFotGPxReu+Naz4swiLKizVttL+4txtwhtWvF5lWIOi/uIqXj8ONRexBtV1LL54nUBP4kzVcaG4TXiDyvorqLK/3pem6pE39kuSXrm/hVb/yO25NUlJrGlQWawpKNW20v6OeBJrCkq19YQ71riPffXDiTXA6VKjE5QHDhyQ5K5kNJlM5f4UJzGTk5MVGxsrSSUPkKnK8ePHVVBQILPZrKZNm5bbpjjReOTIkXK3N2nSpNzXi29r/mslZHEfzZs3r3BMlf2+v1Z+/lVgYKBH2z15WE3x3+HfKycr0rJlS73++usqLCzUxIkTFRkZqZYtW+rmm2/W/Pnz5XBUXm01btw4rV+/XuvXr5eP19ldabl/b4gkqWmzLPn4lP++20S7K30PFLU9HeIP11F+vpeCggsV2aD8h0i1aecex/69wadtHKiapa07BNsOOuXKL/8BNIU73XPJu03V4dq7qVmmotDnzCi/v+LXTX8JkZa/9F3hfunF+3FrhJH273TH86atcuTjW0Gc6eB+Au6BoraViT/gr/w8s4JC7BUuFl/c3/5dVfdXzGx2KSCwaA27XM8rFHB67NvmPr42aZMvH9/yLzK06eR+aNr+7VUfi+P2W5WfZ1JQXYeimpb/Ra1t5+L+WLf2bESsQXXtK4odTVrnVRxnOlY3zpjdcaZJ+d9h2lYRt3penKbJb+6XyezSaw+30MolLANQ01Qv1tSpsr/4g3+JNY0riDUxmUW/u+r+ihFrgDOjRicoi5Nb/fr10+jRoyv9adq0qUymk//ifLL7llfZadTvOpmx/N3JjO2uu+5SbGysZs6cqRtvvFEOh0Mff/yxRo4cqa5duyozM/Mfj+tskJLsr727Q2TxcapP//gy2zt0SlZYeJ5Sj/tq5/bTd/XWbjfrz7URkqQBF8WV2R4ZlaPoc47LVmjWujW1/+FFNZlXhNmdpLRJecvL3pJfsMEuZ5JL5vom+cRUfTJk8jaV3MJduK7sSZ7L7lLhJvfrlnYn+vMKN8vS3h0/CsrZz5npkm23+3WfdpyUGSnlmFV7dwTK4uNSn0uSy2zv0DVNYZEFSk320c7NVV+AsNvN+nOV+wvbgCGJZbZHNspTdKcM2QpNWver51/suvdLkdXfqdxsL8UdPLsvPtUGKQk+2rvVXz6+LvUdklZme0yPLIU1sCk1yVs7/6y6st5uM2v9Cvf8GnBl2bszIpsUKLpLjgoLTPq/5VwIOxsRa1BdKQm+J+LM5alltsf0yFRYg0KlJlm0c0PVSWi7zaz1vxTFmSvKiTON8xXdJbsozoSU2d5jYJoee3ufvLxdemNycy1bWPYuNBgvJdGqvduLYs2l5cWadIVFFcWaTVXfmm+3mfXnKvf3rAFDyt7Z5441mUWxxvPvY937HSfWAGdAjU5QNm7cWJI0cuRIzZkzp9KfPn36lFQzxsXFKS+v4ttbi9WvX1++vr5yOp06dOhQuW2KqzgbNmz4j99PcR/FfZ7u33cyiv8Od+/eXa39IiMjdeedd+rjjz/WoUOHtGnTJsXExGjTpk2aNm3a6RhqjfTlp20lSWPv2KaohieqF4ND8jXx3k2SpHmftpXrLwv0Drlqv96d+6MeeHT9KRxHGzmd0sjr96hN9ImTRKufXfc+8qe8vKQli1ooJ7vqW/lwegWOdn8GmdMLZI87UXHgSHUq4xV3ZVLgKB+ZzCfmTM68QiVdm6O0Z8rGuTqjfSSzlLPIpvw1J5KeLodLmW8XyBHvkjnMJL9+pdf4qjPGfXtU1ocFJVWbkuQqcCn95Xy5siVLtFmWmBp92PhX+PJ/7or/sfftV1TjE0tKBNcr1MTH90iS5s1uUjrOXB+vd79Zqwee31G2v9lN3PHilsNq0+HEBSWrn133PrvLHS++aKicrBPrk/paHRp8zRFZ/com1rv1TdHdT7uPIUs+byiHnTlTE3wx3X1B6tZH4xXV9EQ1UnB9myY9714v+4sZkaXmzdDRSXpv+TY9+PrBMv19OSNSTqd0zfhjJdWXkvuJrPe/csg9bz4KU04max2frYg1qK4vZjaQJN36SFzZOPNsbFGbqNJxZtQxvffzFj346v4y/X35TpQ7ztyZoDadTpxXW/0duv/lg+4583G4crJKx5lu/dP1+HR3cvLNx5rpp/lhp/R94tT68n/u759j7z+gqCZ/izVPFsWa//0t1twQr3cXr9UDL+wstz+nUxo59nBJtaQkWf3tuve5oljzeTmx5tojsvqXE2suOK67nymKNZ8Ra85mTplq9U9tUKPPGgcNGqT//e9/mjdvniZOnFhl+8jISHXs2FFbtmzR3Llzdccdd1Ta3tvbW71799by5cs1d+5cPffcc2XaFD8dvH///ifzFkrp16+fJGnx4sVKS0tT3bp1S21funSpEhISFBgYqPPOO+8f/76TceGFF8pisWj16tXauXOn2rVrd1L9dOrUSffcc49uu+02bd68+RSPsub6fWVDLfm6uYZceVAz3v9Zm/4Ml91uVucuSQoItGv1b1FavLBlqX2CgwvUuEm20lLLroNSt16enpy6puTPUQ3cXwKHXbVfffqdWAbguSfOV1rqidvo9u6upzmzOmjsndv06vSV2rwhTDnZFnXolKK69Qq0a0ddzf3fOaf67eMk+F1oUcFwh3K/sinpphz5dvWSydukgvV2uXIkaz9vBVxd+sE1jnSX7LFOmeuVPRBZWnsp6F5fZb5eoNT78mQ5xyyvcLNsexxyHHHJFCjVe8FPJmvpfa19vRVwg0U5n9qUcnuufDp4yRxsUuEOh5zJ7qRm3Wf9/lGlOk6N338K15LP0zTkuqOa8dU6bVpTV3a7SZ17pCmgjkOrl4Vq8Well/wIDrGpcfNcpaWUvSixd3uQ5rzRQmPvP6BXP9qgzf8Xopwsb3Xomq669W3atTlIc99sUWofb4tTk57co9sf2qf9OwOVnGiVt8Wpxi1y1aRFbtE4w/TR9IqXNMGZteq7ulo8N0xDRyXrnZ92aOOqIDlsJnXunamAIKd+/yFEi+eEl9onuJ5djVsVKC257MOz9mwJ0PvTGuq2x47o9YW7tGl1HeVkeiumR5bqhtm1c0OAPny5/Iutr3+9q+T/Q4vWpOszOE2tO574Yjr9iSYlt6bDGMQaVNeq7+tp8UfhGnpzkt75Yas2/h7sjjO9MhUQ5NDvS+tq8dyIUvsE17Wpccv8CuJMoN5/ubFumxyn1+fv0KY/goriTKbqhtq1c2OAPvzP3+ZgfZuefGevfHxdSj7qo/Zds9W+a/lLHr36UItyX8eZ9fuP4Vryebo71ixc7441NpM6n18Ua34O1eJPSx9PgkNsatwir/xYsy1Ic15vobEPHNCrH2/Q5rV1T8SaUJt2ba6juf8tHTO8LU5Nemqvbn94vzvWJPjK2+Jyx5qWxbEmVB+93ey0/T0AqOEJyiuvvFLnnXeeVq5cqTvvvFMvvPBCmYfLJCYmavHixbr99tslSU8//bRGjBihhx56SI0bN9bgwYNLtV+/fr0iIyNL1mu8//77tXz5cr3xxhu67LLL1Lt375K2r732mv744w8FBwfrtttu+8fvp2/fvurWrZvWrVuniRMn6oMPPpCvr7tq6ciRI7r33nslSZMmTSr1pO4zKTw8XHfeeafeeustjRgxQl9//bXatGlTst3hcOi7774reUL68uXLlZ+fr0suuUTe3t5l2kmqcH3P2mrGG+dqx9ZQDblyv2I6pchsdinucB399H1TfbuoRamrf1Wx+DgVfU7Z2/HCI/MUHplXqt3fzf+8jQ4eCNLwa/apdXSafHwcSjwaoG++aqkFX7SW3catujVFyMNW+XTyUs78QvdTsp3u9ST9h1rkP9xSqnrSE4HX+MjS0qzsTwtl2+aUbbddXqEm+V9pUeAonwofhBN8t1U+MV7KmW+TbY9DrnzJK8KkgOvd+3nV5YpxTTHj+bbasTFEQ66LV0zXdHecOeSvnxZG6dsvGlYrzkjS/A+a6uCeQA0fHafWHbLk4+NUYrxV33zSSAvmNJHdVvqzL8jz0mfvNlWbDplq1CxPzdvmyNviVEaqRX+sCNWyRZFavYyKlZpm+hNNtH1doIaOTlJMjyx5ebnXefvxi/pa8lFY9efNO5E6uNNPI8YdU5tOufLxdSrxsK8WfRCuBbMiZCssP2a065JT5rV64XbVCz9RueIfWPka1jgziDWorulPNdP29YEaenOSYrpnnogz88K05OPw6s+Zd6Pcceb2RLXpmFMUZ6xaNCdSC96LLBNnrFanfHzd62aHNSjUxVenVNg3CcqaY8ZzbbRjQ7CGXH/kRKw5WBRrPm9Q/XnzfhMd3BOg4aPj3bHG9y+x5oPGZWNNvpc+e6ep2sRkqlGzXDVvmy1vi8sda5bXd8ean4k1wOlmcrlc5T8RoYaIj4/X4MGDtXXrVtWpU0edOnVS48aNlZ+frz179mjHjh0KDw9XYuKJ9WyeffZZPf3005KkmJgYtW/fXllZWdq9e7f27dunFStWlKqInDx5sl566SWZzWb17dtXDRo00NatW7Vt2zZZrVbNmzevzNO6mzVrptjYWB08eFDNmjUrM+7+/ftr5cqVZX7Xvn37NGDAAMXHxysqKkp9+/ZVbm6uVqxYoZycHA0cOFDffvttSeJScldx3nLLLRo9enRJRedfjRkzRh9++KE++OCDcp9GXtFYK3q9oKBAw4cP13fffSdvb2/17NlTjRo1UlJSkrZu3aqkpCQVT5s33nhD9913n4KDg9WlSxdFRUUpNzdXa9euVUJCgiIjI7VmzRqPkpTB1ij1bFb109eBYhFzk4weAs4yxy4vW6EBVMWZ8e9YSxmnjjm46rXSgL9zZpdN3gOVMftTaY7q+SNjoTLsZdf7rO3qtwvTZXOuNHoYp9XuiRu1fv2pWzbOCDW6glJyP5n6//7v/zR79mx9+eWX2rp1q9auXav69eurYcOGeuCBB3TVVVeV2uepp57ShRdeqDfffFOrVq3SggULFBwcrObNm2vKlCnq2LFjqfbTpk1Tnz599Pbbb2vdunVavXq1wsPDdfPNN2vy5Mk655xTdytsq1attHHjRr388statGiRFi1aJIvFovbt22vUqFEaN26cLBZjv0D7+vpq8eLF+vTTT/XBBx9o48aNWrNmjcLDw9WxY8dSf99Dhw5Venq6fv31V+3bt0+rV69WYGCgmjRpojvvvFPjx49XWBhXmwAAAAAAwJnnkuSsZiUuzrwaX0GJfw8qKFFdVFCiuqigxMmgghLVRQUlTgYVlKguKihRXf/WCsp67cJ06QdXVd3wLLZ30oazvoKSBcUAAAAAAAAAGIYEJQAAAAAAAADDkKAEAAAAAAAAYJga/5AcAAAAAAAA4GQ5XdTn1XR8QgAAAAAAAAAMQ4ISAAAAAAAAgGFIUAIAAAAAAAAwDGtQAgAAAAAAoHZymeR0mYweBapABSUAAAAAAAAAw5CgBAAAAAAAAGAYEpQAAAAAAAAADEOCEgAAAAAAAIBheEgOAAAAAAAAaiWXJKd4SE5NRwUlAAAAAAAAAMOQoAQAAAAAAABgGBKUAAAAAAAAAAzDGpQAAAAAAACotZwu1qCs6aigBAAAAAAAAGAYEpQAAAAAAAAADEOCEgAAAAAAAIBhWIMSAAAAAAAAtZJLrEF5NqCCEgAAAAAAAIBhSFACAAAAAAAAMAwJSgAAAAAAAACGIUEJAAAAAAAAwDA8JAcAAAAAAAC1Fg/JqfmooAQAAAAAAABgGBKUAAAAAAAAAAxDghIAAAAAAACAYViDEgAAAAAAALWSSybWoDwLUEEJAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMOQoAQAAAAAAABgGB6SAwAAAAAAgFrLKR6SU9NRQQkAAAAAAADAMCQoAQAAAAAAABiGBCUAAAAAAAAAw7AGJQAAAAAAAGonl+R0sQZlTUcFJQAAAAAAAADDkKAEAAAAAAAAYBgSlAAAAAAAAAAMQ4ISAAAAAAAAgGF4SA4AAAAAAABqJZd4SM7ZgApKAAAAAAAAAIYhQQkAAAAAAADAMCQoAQAAAAAAABiGNSgBAAAAAABQa7EGZc1HBSUAAAAAAAAAw5CgBAAAAAAAAGAYEpQAAAAAAAAADEOCEgAAAAAAAIBheEgOAAAAAAAAaiWXTDwk5yxABSUAAAAAAAAAw5CgBAAAAAAAAGAYEpQAAAAAAAAADMMalAAAAAAAAKi1XKxBWeNRQQkAAAAAAADAMCQoAQAAAAAAABiGBCUAAAAAAAAAw7AGJQAAAAAAAGotp1iDsqYjQYmaw2GXjqcZPQqcRZKu9Dd6CDjLXLlqq9FDwFnoq5gGRg8BZxuzl9EjAPBv0CDc6BHgbJNLCgjSp59+qpkzZ2rLli1yOByKjo7WLbfcovHjx8tsrv6N1g6HQ++9954+/fRTbd++XTk5OQoLC1Pnzp01btw4DR061KN+mJ0AAAAAAABALTdx4kTNmDFDVqtVAwcOlMVi0bJlyzRp0iQtW7ZM8+fPr1aS8vjx4xo0aJDWrVunevXqqWfPngoICFBcXJx+/vlnRUREkKAEAAAAAAAAIC1YsEAzZsxQZGSkfv31V7Vu3VqSdOzYMQ0YMEALFy7UW2+9pXvuucej/pxOp4YNG6Z169bpnnvu0bRp02S1Wku2Z2Vl6dChQx6Pj4fkAAAAAAAAALXYiy++KEl66aWXSpKTkhQREaGZM2dKkqZNmyan0+lRf++9955Wr16tIUOG6I033iiVnJSkOnXqKCYmxuPxUUEJAAAAAACAWsnlkpyuf/dDcuLj4/Xnn3/Kx8dHI0eOLLO9X79+atiwoY4cOaI1a9aoV69eVfb59ttvS5Luv//+UzJGEpQAAAAAAABALbVx40ZJUvv27eXn51dum27duunIkSPauHFjlQnKhIQEbdu2TV5eXurZs6f27NmjL774QvHx8apXr5769eunSy+9VCaT54lhEpQAAAAAAABALXXw4EFJUtOmTSts06RJk1JtK7N161ZJUv369TVz5kw9/PDDstvtJdunTZumXr16aeHChQoPD/dojKxBCQAAAAAAAJylkpOT1bVr15KfWbNmldqenZ0tSQoICKiwj8DAQEnuh9tUJTU1teS/999/v0aOHKkdO3YoMzNTy5cvV7t27bR69epybyevCBWUAAAAAAAAqLVctXwNyrCwMK1fv/6M/b7iB+nY7Xb16dNHn376acm2AQMG6Mcff1SbNm3066+/asWKFRowYECVfVJBCQAAAAAAANRSxdWROTk5FbYprrKsU6dOlf39tc3tt99eZnujRo10+eWXS5JWrFjh0RhJUAIAAAAAAAC1VLNmzSRJsbGxFbaJi4sr1bYyzZs3L/f/y2uTmJjo0RhJUAIAAAAAAAC11LnnnitJ2r59u/Ly8spts27dulJtK9O2bduS9SyPHz9ebpuUlBRJJ6o3q0KCEgAAAAAAAKilGjdurC5duqiwsFDz5s0rs33lypWKj49XZGSkevbsWWV/FotFQ4YMkSQtW7aszHabzaZff/1VktS1a1ePxkiCEgAAAAAAALWUSU5X7f7xxKOPPipJeuSRR7Rv376S15OSkjRhwgRJ0uTJk2U2n0gVvv3224qOjtaoUaPK7c9sNmvWrFlaunRpyesOh0OPPPKI9u/fr4YNG+qqq67yaHw8xRsAAAAAAACoxa6++mqNHz9eM2fOVExMjC666CJZLBYtW7ZMmZmZuvLKKzVp0qRS+6SkpGj37t2KjIws01+nTp30xhtv6J577tGgQYPUvXt3NWrUSBs3btSBAwcUHBysefPmyc/Pz6PxUUEJAAAAAAAA1HIzZszQJ598oi5dumjlypVaunSpWrVqpbffflsLFiyQl5dXtfq76667tHz5cg0ePFj79u3TN998I7vdrnHjxmnTpk0e3S5ezORyuVzVfUPA6RBsCVPPkOFGDwNnEZPFYvQQcJa5YsVWo4eAs9BXMQ2MHgLOMua6dY0eAs5CzsxMo4eAs4y5VTOjh4CzzB/7ZisjL8HoYZxxgW2iFPP2aKOHcVrZHvtZ69evN3oY/wi3eAMAAAAAAKDWcnm4TiOMwy3eAAAAAAAAAAxDghIAAAAAAACAYUhQAgAAAAAAADAMCUoAAAAAAAAAhuEhOQAAAAAAAKiVXJKcPCSnxqOCEgAAAAAAAIBhSFACAAAAAAAAMAwJSgAAAAAAAACGYQ1KAAAAAAAA1E4uyeUyehCoChWUAAAAAAAAAAxDghIAAAAAAACAYUhQAgAAAAAAADAMa1ACAAAAAACg1nLKZPQQTqva8O6ooAQAAAAAAABgGBKUAAAAAAAAAAxDghIAAAAAAACAYUhQAgAAAAAAADAMD8kBAAAAAABAreSS5HLVhsfIVKw2vDsqKAEAAAAAAAAYhgQlAAAAAAAAAMOQoAQAAAAAAABgGNagBAAAAAAAQC1lkrOWr0FZG6oPa8N7AAAAAAAAAHCWIkEJAAAAAAAAwDAkKAEAAAAAAAAYhgQlAAAAAAAAAMPwkBwAAAAAAADUWi6X0SNAVaigBAAAAAAAAGAYEpQAAAAAAAAADEOCEgAAAAAAAIBhWIMSAAAAAAAAtZbLZTJ6CKgCFZQAAAAAAAAADEOCEgAAAAAAAIBhSFACAAAAAAAAMAwJSgAAAAAAAACG4SE5AAAAAAAAqJVcLh6SczagghIAAAAAAACAYUhQAgAAAAAAADAMCUoAAAAAAAAAhmENSgAAAAAAANRaTtagrPGooAQAAAAAAABgGBKUAAAAAAAAAAxDghIAAAAAAACAYViDEgAAAAAAALWWy2X0CFAVEpTAadB/8DENvuaImrfJltlLij/or5++jtS3XzSU6yQW5z2v93FdNSpOrdtnyeLjVGK8n1Z+H64Fc5rIbitbCH3RFQm6f+quSvu8sX8vpR33rfZYcHr0uyxBg0fGqXmrbJm9XIo/FKCfvmmg7+Y1Prk50ytFV94Yq9bnZLjnzBE//bo0SgvmNit3zvzVBZck6KIrjqpl20wFBNqVmeGjw/sD9Mv3Ufp5ccOTfYs4xQ4v8dWBz/2UsdtbLqdUp7lDza7KV4vr82Ty8P6InCNm/XBRqEdtL5ibprButpI/73g7QDunB1TY3uzj0lWbkz0bCM6Y/lekasjNyWoenSuzlxS336qfvqyvJR+FnVys6Zeh4bcfU5uOubL4OpV42Fe/LKqnBbMiZCssOxFbts9V1/4Z6tI3U03b5iswyK68HC8d2OGnnxfU18/z65/UOHD69B+UqMHXxKt566wT5zSLGujbLxud9PHpqlGH1fqczJLj08rvI7Xgw6ZVH58uS9TFVxxVy+gs9/Ep3aLD+wO14rtI/fxNg5N9izjF+g9L0ZCbktS8bZ7MXi53nJkfpiUfh5/cnLkgXcNvS1SbmBxZfF3uOLO4vha8F1l+nDknxx1n+mSoaZs8BQY5lJdj1oGd/vr5q1D9vCCUOFMD9R8Qq8FD96t5iwyZzS7Fx9XRT0ub6dvFrar1eYWG5ap7j6Nq3SZNbdqmqknTTHl5ufS/dzvqq/nRp3w/AKcOCUrgFJvw+B4Nue6ICvLN2ry2rux2kzr3SNOEx/eqU480vXB/h2odZK++JVZj7z8gh92kLetDlJ3prZjz0jX67oPq3u+4Hrutswryvcrd9+hhP23fGFzutoKC8vfBmTd+8k4NuSbOPWfW1ZPdZlbn7sc1YfIude6eqhce6lStOTNi9EGNvWevHHaTtv5ZV9mZFnU4L1WjJu5Tt77JevzOruXOGYuPQ4+9slnd+6YoL9dLOzaHKDvDovrh+WrTPlMmk0hQ1hAbnw3Ugc/8ZfZ1Kfz8Qpm9paQ1Fm2aWkdJayw6/7+ZHiUpvf1danplXoXbM/d7K22rRd4BTtVtbyu3TXC0TSHR9jKvmzjDqHEmPndYQ0cnqyDfpE2/B8luM6lz70xNnBqnzr2zNPXOFtU7Pt2ZqNseOyKHXdqypo6yM7wU0yNbYx4+qh4DMzT5+jYqyD8xEc1eLk3/fqckKTfbrD2bA5Se4q3QKJs6dM9Wp17Z6j8sTVNuaylbAasQ1QQTHt2lIdfFu49P/1fPfU7TPVUTHtutTj1S9cIDHas3Z8Yc0tj79hWd09R1n9N0TdPou/ar+wUpemxclwqPT4+/ulXdLyg6Pm0KVlaGRaHhBWrTIUMyiQRlDTHx2UMaenPSiThjN6tzrwxNfDZWnXtlauqE6iWbrr4jQbdNjiuKM0HKzvRSTPcsjXkwXj0uTNPkG6NLzRmzl0vTv90uqSjObAlQeopFoVGF6tAtS516Zqn/0OOacnubcpObMMaEu/7UkGH7VVDgpc0bw93z5txjmnDXRnU6N0kvPNvL43nTu0+87piwqdpjONn9AJw6fH2AJGnOnDm65ZZbNHr0aM2ZM8fo4Zy1el+UpCHXHVFqso8eHnOujh72lySF1C/UtNkb1fuiFA27IV6LPmnsUX+tz8nUmHsPKD/XrEdv66zdW93JRqufXc/M2KKYrhkadfcBvfdy63L3374xWK8/0e7UvDmcFr0uPKYh18QpNdlHj9zWTUfj3BVpIfUK9OKs9ep1YZKGXndY33zW1KP+WrXL0Ji79io/z6zH7uiq3dtCJLnnzJQ3NyrmvDSNmrhX771a9krwfc9sV/e+KVq5NFLTn2+nnGxLyTZvi1NNW2b/8zeMf+zIj7468Jm/rKEOXfBRuuo0c0iS8lNM+nVMXR392ap9H9vUelTFicdivnVd6vpiVoXbV41zx5xGgwvk7V9+mwYDC3XOpJzqvxGcUb0HpWno6GSlJnnrwavb6ughqyQpJNSml77Yo96D0jXsliQtej/Co/5ad8zR2MlHlJ9r1iPXtdHuTe7YZfV36Nk5+9Tx/GyNfviIZj1b+ni3Z4u/5s2M1JqfgkslB5q1zdPzH+/Vef0yde3ERH38Gskmo/UeeExDrot3n9OM7XrinKZegab9b4N6D0zWsOvjtOjTJh711/qcTI25Z5/y88x69PbzSp/TvL1JMV3TNWrSPr33n7Zl9r3/uR3qfkGKVv4QobenRisni+NTTdT7slQNvTlJqUkWPXhtu9Jx5tOd6n1ZmoaNPqZFcyI96q91TLbGPhznjjM3Rmv3pkBJRXHm/T3q2CNLox+M16yppc+R9mzx17x3G2jNzyF/izO5ev7D3TrvgkxdO+GoPn6j0Sl65/gneveJ15Bh+5V63KqHHxigo0fqSJJCQvI17T+/qHefIxp25V4tWtjGo/6OJQbo669aa9/eutq7p56uuW6nBl4ce9r2A3DqcNkIOIWuue2wJOn911uWnMhLUvpxH7091X1QHXnrYZlMni2AMfLWwzKbpXkfNCk5kZek/Dxvvf5kOzkc0pBrjyigTvmVTaj5rhl7UJL0wZttSpKTkpSe6qvpL7iTyyPHHPR8ztxyUGazNH9O85LkpOSeM29MaS+HQ7p8ZJwCAkvPmS49U9Tv0kQd2F1H/3k8plRyUpLsNrP27wo6mbeIU2zXLHds6fBATklyUpKsoS6d+5Q72bjnPX+5nP/s9+QdM+vY7z6SpOYjqk52oma7dmKiJGn2i41KkgaSlJ5i0duPuRNM105I9DjWXDMhUWaz9OXMiJLkpCTl53rptQebuY9PNycrIOhEda3TYdLdQ9rpt2/rlqlcOrTbT7NfcFdoX3jV8ZN7kzilrrn1kCTp/TdalT6nSfXV28+7L3KNHHvI8+PT2ENF5zTNyp7TPHVO0TlNfJlzmi69jqvfZce0f1egXnm0Q6nkpMTxqSa5dvxRSdLslxqXjTNPNitqk+B5nBmf4I4z70SVJCelojjzUHP3nLkpSQF1/hZnruig376rV06c8dfsae6LJhdeSZypKa653l1Z//7/OpYkJyUpPd2qt9/sIkkaee0uj+fNmj8aatbMc7X852aKOxwkp4eVlye7H4BThwQlcIrUj8hX6/ZZshWatOrHsDLbt62vq5RjvqoXVqjojplV9uft7VTXPu6TpxVLyl5pToz3067NwbL4uNStb+o/fwM44+qH56v1OZnuOfNz2aqlbRvqnZgzMRlV9uft7VTX3imSpBXfR5XZnnjEX7u2hMji41LXPimltg251p1cX/RZEzmdnJDVVLmJZqVvt8hscanRZflltod1t8kvwqH8FC+lbv5nN0nELrRKTpOCWtlVr1PZW7hx9giNLFSbjrkqLDDptyV1y2zfuraOkhMsqhduV3SXqqthvS1OdevvPo6t+Lp+me2Jh321a0OAfHxd6jag6uNdsf3b/YvGy0U3o9UP/8s5zU/lHJ/+/Os5jYfHp6LjzopvyzmnOeKvXVuKzmn6lE4cDb0uTpL0zaccn2qyUnHm23pltm9dG1QUZ2yKPrfqildvi1Pd+rnn1opF5cSZOKt2bQgsijPpHo/zRJwp9HgfnD71Q3PVuk2abIVmrfq1bEXrti3hSkn2U736+YpuR1IZ/4zLZarVP7UBCUrgFGkZ7T7Zit0XoMIK1nfcs819VbBlu4pvqSzWqHmurP5OZaZ7KzHer/z+trv7axFdfn8NGudp1F0HdNfTu3TrA/vUf/AxWf1INNQULaPdX9xj9wdWPGe2u6tMWkRX/SW/YbMcWf2cyky3KDG+/Ptx9+4IKvW7JclsdqlTN3eSe/vGuqofnq/how5q4mM7dOu9u9XrwmMye/3DcjycEuk73UnHoFZ2eVnLb1O3g/vfePoOS/kNPHRoofsXNKuiejJ9h7e2/idAfz5VR1tfDdCRn3zk5HtfjdKyQ64k6fAeqworWNtxz2Z3FWSr9rlV9teoRYH7+JTmpYTY8h+2trsa/RVr0KxAkpSW9M/mLv654vOUyo9PxccTD85pmuVWeXzas83d31/Pacxmlzp1dx+ftm0IUf3wfI0YfUiTntipW+/fo94DOT7VFC3buy9uHN7rV3Gc2eKugvQszuSfiDOHyz/g7d7yD+JMMnGmJmjZKl2SFBsbpMLC8i+s7tldr6ht2pkaFgCDnBUJyk2bNumKK65QvXr1FBAQoPPOO0/vv/++JMlkMslkKpstzsnJ0csvv6xu3bopKChIfn5+at++vaZMmaLs7PKv2rlcLn300Ufq37+/6tatK6vVqpYtW2rixImKi4s7peP76+uzZ89Wjx49FBQUJJPJpPT0dEnSjh079NRTT6lXr15q0KCBfHx8FBYWpsGDB+uHH34odyxz5syRyWTSmDFjlJKSovHjx6tRo0Yl7+WJJ55Qbm7lB/GsrCw99NBDat68uXx9fdWwYUONHz9eqamlq/See+45mUwm3XnnnRX2tXjxYplMJnXv3r3S31kbRDZ0VzMlJVSQNZCUXLQtomHZyqe/K26T7EF/kRX0175Lhq4bF6tBVydoxJg4PfzSDn340x/qfXFSlb8fp19EA3fiJymh/AS0JCUnFn3GDaq+xba4TfE+5ffnV+p3S1JkI/cXR0lq3zlNsxau0q337tXgq+M1fFSsHv/PZk3/4g9FNfb8CwBOj9x4d6LAv0HFX8j9Grhv+845cvIPwkr+P4tyDnvLbHGpyRWVx6uEFb7aMztAh+b5ac//ArTm7hD9cGl9Jf8fX/5qisjG7ozxsSPlJxMlKfmo+3b+iMZVZ5cjm7i/4Ccd8am4v6JtEUVtq+bSyDvdt6Gv+j7Ew31wukQ2LD4+eXJOU/XxqbhNcmIlc7D4ePeX/qIa/+X4dG663vtmtW69f58GjzyiEaMP6/HXtmrGvLUcn2qAyMbuf+uexZmq40Jxf0lHK+vP1+P+3FwaeUeCJGnVD2WrPHHmRUa6v5cnHQuosE1ysvuiRkQk610DtV2NT1AuX75cPXv21DfffKOIiAgNGzZMQUFBGjdunB566KFy94mPj1f37t31yCOPKDY2Vj179tQll1yitLQ0PfPMM+rdu7fS0kpfgXG5XLrppps0atQorV69Wt26ddOVV14pl8ulGTNmqHPnzlq3bt0pGd9f3XXXXRo3bpx8fX01ZMgQnXfeeSWJy9dee03PPfec0tPT1alTJ1111VVq1qyZvv/+ew0aNEivvfZahf2mpaWpR48e+vLLL9WjRw9deumlSk5O1vPPP6+BAwdWmKTMyMhQ79699f7776tz58665JJLlJubq3feeUcXX3yxbLYTt12NGzdOPj4++uSTT5SZWX511/Tp0yVJEydOrPLv4mxn9XdXLeXnVZwUyMt1b/MLcFTYppifv6Ma/ZWuikxN9tFn7zbVPdedp2v79NHVPfvqvhu76PefQ1Un2K7Jr2xXl17cJmG04s+4oqewSyc+f0/mjLVac+ZEf3WCT/y7nvTEDu3cHKK7rj9fI3pfqHtv6qEdm0LUpEWOpvx3g7wtVKoYyZ7rPj54+Ve8DpN30TZ7zsnf6nHoK3eiIOrCAvnWLf93BTR2qMP92Rq4MFXD1iVryOpk9Z2TptBuhcpL9NLvd4YoY/fJJ0lx6hTHhoLcik/78nLc2/wDPYk17jhQkFdJf0W/yz/As5hx030JOqdrjlKTvPXF9LJLVODMsvqd3PGkIp6d03gX9XfinCbwL2uY3vXUTu3cFKJJ13bX8PP7654bumnHxmA1aZmjZ97exPHJYNWLC56f01Qat6rRnyTddM8RnXNetlKTLfpiBnGmJii+syu/knPhvLyi2MBdYECtV6MTlLm5ubrpppuUn5+vp556Sjt27NBnn32mFStW6Ndff9U777xTZh+Xy6VrrrlGO3bs0KRJkxQbG6ulS5dq0aJF2r9/v2666SZt2bJF9913X6n9Zs6cqU8//VQRERHauHGjfvzxR33++efau3ev7rrrLqWmpmrkyJEqKDhxhe5kxvd3H330kf744w/9+uuv+vTTT7V+/XoFB7tv6bz55pt18OBB7dixQ99//72++OILrVu3TmvWrFFQUJAmT56s+Pj4cvv95ptvFBUVpf3792vBggVatGiR9u7dq5iYGK1Zs0ZTpkwpd7+vv/5ajRs3VmxsrBYuXKjFixdr+/btaty4sTZs2KAvv/yypG1ERISuueYaZWdna+7cuWX62rdvn3788UfVr19f1157bZV/Fzh1Nqyur4/ebqG924OUlWFRbra3dm8J1vP3xeirDxvLy0u67cH9Rg8TNYT5L3mslESrptzdRQd2Byk/z1t7dwTryYldlJrso0bNctV/UIJxA8UZYcs26ciPRbd3D6+4erLpFflqe3uuQqLtsgS65FvXpfAeNvWbm66Gl+TLkWfSttcDK9wfKDZwxHHdcE+CCgtMmnZXC2Wm/bP1U1F7mM0nLpCkJFr19KTOOrCr6Pi0PVhPjD+35Pg0YHCigSNFTTdweIpuuPuoO87c3VKZaVT5A/8mLhm/RiRrUFatRico58+fr4SEBLVp00ZPP/10qVule/XqpQkTJpTZ54cfftAff/yh888/X//973/l53fi1kk/Pz+98847Cg8P1yeffFKqivLVV1+V5L5tuX379iWve3l56T//+Y+aNGmi2NhYzZ8//x+N7+8efvjhCm9/7tevn5o1a1bm9R49emjSpEmy2WxatGhRufuaTCbNnDlTISEhJa9FRETov//9ryTpnXfe0f+zd9/hURVtH8d/m94TSG+ETpCOgCBowF4QsWAXERVF4bH3hj4+tteKFEVFUBGkqAgWRASU3nuHEAhJSEJ6b/v+sUlg3ZQNJGyyfD/XleuCPefMzrLDzOQ+95kpKLD8xdPLy0tffvmlvLxO/lIZFhamMWPGSJKWLFlidv7YsWMlmQK8/zZ58mQZjUaNHDlSbm5VPyI0ZcoU9erVS7169VJRWe2PPTdmBeV3/iuyDqpSkUGQn1t7VlFFZoJ15Vn/y9ysKVEqLTGoZbtcBYY07X/zpq7iO3Z1q/47rvj+rWkzBXVqMyfLy8s7+eclC8NUUmI+NBTkO1VuutO1Fxsy2VJFdmRpXvWTkIosSydP63a7/Lejv7qqNN8g95BSBQ84vcUkOz5segwreZWLytjvxOYq+gZXjxqWBijPdMzLsaavMfURru41lFf+Xnm5NU81L7o2XU/832GVlUpvj2mlbau9azwfZ0dFpuPZndOUlJd3ck5z6p//XBBa5fj01y/l41Nvxidbqlu/YP2cpsZ+y8ryLromTU+8c0hlpabg5LY17PreWBSUZ0e61TAXrsicrMikBGC/GnWAcvny5ZKkW2+9VQ4OllW94447LF779ddfJUk33XRTldd4enqqV69eKikpqXxkOz4+XocOHZKDg4Puvvtui2tcXFx05513SpKWLVt2RvX7txtvvLHG49nZ2Zo1a5aee+45jRo1SiNGjNCIESMq67Fv374qr+vatau6dOli8fqgQYMUHh6u7Oxsbdy40eL4+eefr5AQy90Vo6OjJUkJCQlmr/fp00d9+vTRrl27zP5t8vPzNW3aNDk4OGj06NHVfr5Ro0Zpw4YN2rBhg1wcql/nqCk4nmCqf1Bo9UG/gPKAYMW51pQXWEN5gXUor0JOlrMy0kx3jf2DrV2zBw0hOcF0AyUotPr1uyq/4xrWqaxQcU5NgeeA4AKz9/73n5MSqn6f48dMrzfzZ/cTW/IIN03g8xJqeOQt0cHs3LqKm2f6rqOGFshwmrME71am9y4rNqgwvVFPNc4Jx+PL130Lr77PDwwtMju3xvKOms4JCq++PwgMKy/vaPXrx/W/Kl3Pjj8kSfq/x1pp1SLLHcZhGxV9vnVzGivGp4o5TUgNbbD82KlzGrM/H6tufDKd0yyA8cmWjseXrwdpVT9Tfb/w7/KCwmoqr7DW8vpfmaZnPzI9NfR/T7TWqj9Ye7IxOV6+9mRQcPXrSwYE5pmdC8B+NerbEMeOHZMkRUVFVXm8qtcPHTJNdJ9++ula14BMSUkxe5/Q0NBqM/1at25tdu7p1q8u58yfP18jR4602JzmVNWt/diqVatqr2nZsqWOHTtW5ePhLVq0qPIaHx/Tncaqsi7/85//6K677tKkSZM0cOBASdKsWbOUlpama6+9tsa62JODu01Zp1Ftc+XiWlrlrpftO5t2pjy0u/bHHuMPeagg30E+fiUKicivcifvivIO7rH+MUoHB6M8vcrXe8ljfThbOrjX9P8qqk1OtW2m3XmZpnP31J5VFB/rWd5mihUSkVflTqntO2WavbdkWvfrWJyHwqPy5ONbdbqbj5/p9ZrWD0PD8+to+r+bdcBJpQWqcifv9B3OZufWRdYBR6Vtc5YMRkXdWPvGF9UpzDgZlDzdTE7UnwM7TH1Bi/YFcnEtq3KH3fbdTL8cHtxZ9Q7Lpzp60E0F+Qb5NCtVaFRhlTt5d+heUV7VQaV+V2TouQmxMjhIHzzZUssXEDRoTCrGnJrGp/adTHPQQ/U1PnW2HO9OHZ+8qxufmhWXn8v4ZEsHyvuOFu3yq+9nuta1n3Ew9TMtCqrcybtDLf1Wv8vT9dz4gzI4GPXB0621fKG/1Z8HZ8fBA6YbU1FRWXJxKalyJ+/27U2/Cx86wE0swN41ibSGqnbBllRl1mJpqSlrIyYmRvfcc0+NP/8ODlb3PvVZv3879RH0U8XHx+v2229XWlqann/+eW3btk1ZWVkqLS2V0WjUZ599Jsm05mZ9sqbO/zZs2DAFBwfrp59+UmKiaX26SZMmSZJVj7nbi9Tjbtq/y0vOLkYNuCLF4njnXukKDClUWoqLdm/1rbW8khIHbVxhmkgNGmy5rlJIRL6iu2WquMig9X9bP+HqE5MqN48y5eU46mhs7RNENJzU4246sNvb1GYuO25xvHPPtMo2s2ebX63llZQ4aOOqAEnSoCrWigwJz1N01wxTm/knwOzYqr+CJEnd+lS9eVK3PqbJ4f5dPBZlSx6hZfI7r1hlxQbF/275y1rKOmflJznKLaBU/t3r/mz14fLsycALiuUVefobTsT/bgpYebUqkTMBSptLTXTR/u0ecnE16qLB6RbHu1yQrcCwYqUlO2n3xtozVEqKHbRhqWkcGzTUss8IaVGo6J65Kio0aN1fluPdBZdl6IVJh+ToZNRHz0RpyQ8EDRob05ymfHy6vIrx6fzTmNOsLJ/TXFvFnCY8T9FdM6scn1YuCZQkdb+g6hv23SvGp52MT7aUmuh6sp+51vK76nJBlgLDipSW7Kzdm2q/sV5S7KANy8r7meur6GciCxTdM6e8n/GzOH7Bpel6YcIBUz/zXCst+THA4hzYXmqKh/bvayZnlzINuNgyeaZz12QFBuUr7YSbdu9irADsXaMOUIaFhUmS4uLiqjx++PBhi9ciIyMlmYJm06ZNq/FnwIABkqTw8HBJpseXT90E51QVmZkV555u/ay1cOFC5efn66abbtKbb76pLl26yNvbuzKAeODAgRqvr+m9K46d+lnOhIuLix588EEVFxfr888/17p167Rhwwa1bt1aV111Vb28R1Mx+wtT0Hvk4wcVGnlyp3Tf5kV65EXT4/hzvmxhtojt4Nvj9dnPa/Xk/3ZZlvdlC5WVScPuPaL2nU9my7q5l+ix1/fI0VFa+H24crNPLvTt6laqa245Vrkr3ql6X5Sq/7y6V5K0cFa4SksadRdwTpg91ZRhfO9/9pm3mWaFevj53ZKkOdNambeZW4/o03kr9MTr2y3Km/NVK5WVSTePiK3MlpRMbebRV3fK0VH6ZU6kcnPMF4efPzNKebmOuuDiVF025JjZsaF3xqnL+enKz3PU4p/rp9/A6eswytROdrzvqZy4kxlDBScM2vy6KfOo/QN5Zo9nH5jhrkXXNNf6Z6vPdCorlo4sKN8c56aasyfzEhx0ZKGrSv/1RKXRKMXNd9PO8s1x2t2TV8XVsIXvJ5qWb7nv+XiFRp18GsLXv1hj/nfEdM6kELO+5rp7kvX5Xzv01IexFuXNnhSisjLpltHHK7MvJdPOu0/832HT+PRNoHKzzLNheg/K1IuTTcHJ8c9FafEcggaN1ewvW0qSRj52oIo5zR5J0pypLc3Hp9uO6rOfVunJN3ZYlje1Zfmc5nBltqRUPqd5bVf5nCbCbE4jSfNntDCNTzGpuvx686WGht4Vpy69Mkzj0/ywM/7MODPfTzZ9B/c9e9Syn3k9rvycUPN+Zvhxff7nNj31vuXmjbM/DTX1Mw8lqn23nMrX3TxK9cS7saY2822QcrP/1c8MzNCLE03ByfEvtNTiuYH1+jlRv2bPMi0lNvL+bQoNy6583devQI+M3SRJmvN9tHlfc/1+ffblb3rymbVnt7Jo0ox2/mMPGvUj3hdffLG++uorzZ49W6+++qpFdt/MmTMtrrn66qv1xRdfaM6cOXrkkUesep+IiAi1bt1ahw4d0rfffqv77rvP7HhxcbFmzJghSZWPMJ9u/axV8Vh3RcD1VIWFhZo3b16N12/dulU7d+402/BHMq2beezYMXl5een8888/7fr920MPPaS33npLU6ZMqVwXc/To0aeVkdmUrVwcpIWz0jX4tgRN+mG9tqxpppISg7pfkC5P71KtWhKgBTMjzK7x9StWZKs8padarvu1f6ePpn3UWiOfOKT3v9mkrev8lJvtpM69MtTMv1h7tvro6/Gtza5xci7TmJf36YGnD+jgbi+lJLnJyblMka3z1KJ1Xnk9A/XNxHPj0fvGbuWSEP0yO03X3hKvid+v0pZ1zVVa4qBuvdPk6V2iVX8FaeH35ksv+PgVmdrMCcvHKvfv8tW0T9pp5KP79d5X67R1fXNTmzk/Xc38i7Rnu6++ntjO4rr0VFd98EpnPff2Nj0+bqeuv/2IEo54KLJ1jqLa5Kqo0EHvv9xZ6am1rxuFhhVxZaFSbsvToVkeWnx9cwX1K5KDk1HJa1xUkuOgsEsL1fZO8wBjUbqDcmKd5BZQfVZk4jIXFZ5wkLNPmcIvr3l92qJMB61/2lebx5XJ77wSuQeVqTjXoKwDTsqLNwVN29yZp9a3shFXY7Hi12Za8HWgrhueok8X79LmFT4qLTaoe/8sefqUaeXvflowLcjsGt/mJYpsW6j0FMvdbvdt89TUt8N1/wvH9OGPe7Rllbdys5zU5YJsNQss0e5Nnpr+rvkNDV//Yr382UG5uBqVkuCsTr1z1Kl3jkXZkvT+ky3r7bPj9Kz8M1gLv0/X4FvjNWnuGm1Z29w0p+mTZprT/BWoBbPM56m+FeNTlXMaX037uK1GPn5A70/foK3rmyk3q2JOU6Q923z09YS2Ftelp7rq/Zc66fl3t+vx13dpyB2m8alFm9zK8em9FzsxPjUCK35rrgXfBOm6u5P16e/btXmlr6mfuTBLnj6lWrmomRZ8HWx2jW+zYkW2Kaimn/HS1Hcjdf9zR/Xh3F3astqnvJ/JUrOAEu3e7Knp7/1rXu1frJc/3V/ez7ioU68cdepVTT/zdOsqX8fZtfKfSC38OVmDhxzUpCl/aMumIJWUOqh7j2R5ehZr1YpwLZhv3jf4+hQqskW20tMtnyZp1jxfL49bWfn30FDTTbQhQw+YZWn+d1x/pae5n/F1AOpPow5QDhs2TM8995z27Nmj//3vf3rppZcqH6deu3atJk6caHHN0KFDdf7552v58uV66KGH9Oabb6p5c/N1jZKSkrRgwQI98MADla898cQTGjNmjF5++WX179+/clOY0tJSPfPMMzpy5IiioqJ08803n1H9rFXx/vPmzdNzzz2n4GDTYF5UVKSxY8dWZnRWx2g0avTo0VqwYIF8fU2PR6SkpOjRRx+VZNqcprrHy09HaGiobrrpJs2aNUszZsyQm5ubRo4cWW/lNyWT/tdBuzb7afBt8erSK0MODkYdPeyhxT+G6pfvw83u/llj7ldRit3npRvvOap2nbPl4lKmpHg3/TwjQvOmtVBJsXkQuDDfUTM/i1L7zlmKaJmvVh1y5eRcpsw0Z61eGqAl80O0agl3khuTSW+fp51bmmnwLUfVpWe6HByNij/sqT/mh+vXOZF1bjPzprfS4f3euuGuw2rfKVPOLmVKOuauBbNaaN7XLS3aTIXVS4P12F19dct9h9SlZ7oiW+coK8NFS38N0ZxprRR3gN11G4ser+bI//xiHfrOXanrnWUsM8i7VYla3pir1rfnn9bmNod/MI0JkdcWyLGW3/PdQ0rVfmSu0nc4K+eIo9K3O8tYJrkFlCni6gK1uiVfQX3ZvruxmfhSC+1c76Xr7klWlwuy5ehoWuftj+/9tfCbwLqPT5+GKHa3u24adVztu+XJxbVMSUdcNf+rIM2bEqziIvOG6OZeJhc30z3+wLBiXT6s6iUlJAKUjcWkN6NNc5pbj6rL+abx6Wispxb/FKZfZkfUvc1Ma2ma0ww/onadskxzmmPu+vm7SM2bHlX9+PRXkB69o49uvf+wOp+frhZtcpWV7qylv4RoztSWOnzA+rW40bAmvtJSOzd46bq7k9WlT9bJfmZOoBZ+G1T3NvNZqKmfeSBJ7bvmlvczbpo/LUTzPg+x7GfcyuTiWtHPFOnym1OrLZsAZeMx6ZPztWtHgAZff0BduqaYfn866qPFi1rqlwVt69RunJ3LFN3RcpmBoOA8BQXnmZ1XH9cBqD8GY30vYljPFi9erOuuu06FhYXq2LGjunfvrqSkJP3999/6z3/+ow8//FDOzs4qKjr5nFl8fLyuueYabd++Xd7e3urWrZsiIyNVUFCgffv2adeuXQoKClJS0sk1cIxGo+68807NnDlTLi4uGjhwoJo3b65169bp0KFDatasmRYtWqTevXufcf2kk+tWVvfPX1JSoj59+mjz5s3y9vbWwIED5ebmppUrVyozM1P33Xefxo8fr3vuuUfTpk2rvG7atGm69957NWTIEO3YsUOZmZkaOHCgSkpKtHTpUmVlZal3795aunSpPD09La77d3kVli1bpkGDBikmJsZst+5TrV69WhdeeKEkacSIEfrqq6+qPK86vs6B6udX867mwKkMzpZ324GaXL/U8rF4oDY/dOHRUdSNQzM2c0DdlVWz+SVQHYe2LW1dBTQxqw98qcx8y7Xq7Z1b23BFvfugravRoLzf/FkbNmywdTXOSKN//vbyyy/XqlWrdN111ykxMVE//fST0tPTNWnSJD3++OOSpIAA8/WLIiIitG7dOk2YMEE9evTQzp07NXfuXK1evVpubm568skn9cMPP5hdYzAYNGPGDH399de64IILtHbtWv3www8qKyvT6NGjtXXrVovg5OnWzxpOTk5avny5nnnmGYWGhuqPP/7QP//8o4svvlgbN25Ujx49ary+WbNmWrNmjW644QatXr1av/32m/z9/fXCCy9YBCfrS58+fSp3+7b28XoAAAAAAIAGY5SMRoNd/9iDRp9BWZNvvvlGw4cP1+DBg7VgwQJbV8eCLepXWyZkQ5o/f76GDh2qPn36aO3aui9YTAYl6ooMStQVGZQ4HWRQoq7IoMTpIIMSdUUGJerqnM2gbBOuFu8+ZOtqNCift+aTQdnQkpOTq9wle82aNXr66aclmR4ntpXGXr+zpaSkRP/9738lmdbzBAAAAAAAAKzRqDfJkaRt27bp8ssvV+fOndWqVSu5uLjo0KFD2rx5syTp7rvv1k033UT9bOSrr77S33//rXXr1mnXrl264IILdMstt9i6WgAAAAAAAGgiGn2AMjo6WqNHj9by5cu1YsUKZWdny8fHR5dccolGjBihu+66i/rZ0PLlyzV9+nQ1a9ZMt9xyiz766KPKDYAAAAAAAACA2jTpNShhX1iDEnXFGpSoK9agxOlgDUrUFWtQ4nSwBiXqijUoUVfn9BqU79j5GpRvswYlAAAAAAAAAJw2ApQAAAAAAAAAbIYAJQAAAAAAAACbafSb5AAAAAAAAACny2hkM9/GjgxKAAAAAAAAADZDgBIAAAAAAACAzRCgBAAAAAAAAGAzBCgBAAAAAAAA2Ayb5AAAAAAAAMBuGY22rgFqQwYlAAAAAAAAAJshQAkAAAAAAADAZghQAgAAAAAAALAZ1qAEAAAAAACAXTJKMhoNtq4GakEGJQAAAAAAAACbIUAJAAAAAAAAwGYIUAIAAAAAAACwGdagBAAAAAAAgH0ySmINykaPDEoAAAAAAAAANkOAEgAAAAAAAIDNEKAEAAAAAAAAYDMEKAEAAAAAAADYDJvkAAAAAAAAwG4ZjbauAWpDBiUAAAAAAAAAmyFACQAAAAAAAMBmCFACAAAAAAAAsBnWoAQAAAAAAID9Yg3KRo8MSgAAAAAAAAA2Q4ASAAAAAAAAgM0QoAQAAAAAAABgMwQoAQAAAAAAANgMm+QAAAAAAADAThlkNBpsXQnUggxKAAAAAAAAADZDgBIAAAAAAACAzRCgBAAAAAAAAGAzrEEJAAAAAAAA+2W0dQVQGzIoAQAAAAAAANgMAUoAAAAAAAAANkOAEgAAAAAAAIDNEKAEAAAAAAAAYDNskgMAAAAAAAD7ZJSMRoOta4FakEEJAAAAAAAAwGYIUAIAAAAAAACwGQKUAAAAAAAAAGyGNSgBAAAAAABgv4y2rgBqQwYlAAAAAAAAcA747rvvdNFFF8nX11deXl7q1auXJk6cqLKysjqVM27cOBkMhmp/3Nzc6lQeGZQAAAAAAACAnXvkkUc0adIkubm56dJLL5Wzs7OWLFmiMWPGaMmSJZo7d64cHOqWy9itWzd1797d4nVnZ+c6lUOAEgAAAAAAALBj8+bN06RJkxQSEqK///5b7dq1kyQdP35cgwYN0o8//qhPPvlEjz76aJ3KHTp0qMaNG3fG9eMRbwAAAAAAANgxg53/1O6tt96SJL3zzjuVwUlJCg4O1uTJkyVJb7/9dp0f9a4vBCgBAAAAAAAAOxUfH6+NGzfKxcVFw4YNszgeExOj8PBwJSUlac2aNTaoIY94AwAAAAAAAHZr8+bNkqROnTrJ3d29ynN69+6tY8eOafPmzbrwwgutLnvTpk169tlnlZ6erubNm+uCCy7QtddeKxcXlzrVkQAlAAAAAAAAYKdiY2MlSVFRUdWe06JFC7NzrbVgwQItWLDA7LWIiAh9++23iomJsbocHvEGAAAAAAAA7FROTo4kydPTs9pzvLy8JEnZ2dlWldmmTRu99dZb2rJlizIzM5WSkqK//vpLMTExio+P1zXXXKNt27ZZXUcyKAEAAAAAAGC/jLauQMNKSUlRr169Kv8+atQojRo1qkHf8+6777Z4bdCgQRo0aJBuvvlmzZs3Ty+88IIWLlxoVXkEKAEAAAAAAIAmKjAwUBs2bKj2eEV2ZG5ubrXnVGRZent7n3F9XnnlFc2bN0+LFy9WcXGxnJ2da72GR7wBAAAAAAAAO9WyZUtJUlxcXLXnHD161OzcMxEdHS1JKioqUmpqqlXXEKAEAAAAAAAA7FSPHj0kSTt37lR+fn6V56xfv97s3DNx4sSJyj9XZG/Whke80XiUGWUsKrZ1LdCElKal27oKaGLmdQq1dRXQBC2Kr/5xGaAqV4Z1t3UV0AQ5+vjYugpoYkp37rV1FdDEGI2Ftq6C7dj5GpS1iYyMVM+ePbVp0ybNmTNHw4cPNzu+fPlyxcfHKyQkRP369Tvj95s9e7YkqUOHDlY/Mk4GJQAAAAAAAGDHnn/+eUnSs88+qwMHDlS+npycrIcffliS9Nxzz8nB4WSocMKECYqOjrYIaB45ckTfffedCgvNg95Go1HffPNN5Xs9/vjjVtePDEoAAAAAAADAjt18880aPXq0Jk+erC5duuiyyy6Ts7OzlixZoqysLA0dOlRjxowxuyY1NVV79+5VSEiI2etpaWm688479dBDD6lnz54KCwtTdna2du7cqdjYWEnSmDFj9OCDD1pdPwKUAAAAAAAAgJ2bNGmSBgwYoIkTJ2r58uUqLS1VdHS0Ro4cqdGjR5tlT9YkMjJSTz/9tNavX68DBw5o3bp1KisrU0hIiG699VaNGjVKl1xySZ3qZjAajef4k/hoLHwdA9TXa4itq4EmpCwnx9ZVQFNjYGUT1N2i+I22rgKaGNagxOlgDUrUVWlWlq2rgCZmrXGJsoxptq7GWefaKkKhr461dTUaVMCEOdqwoWmvm04GJQAAAAAAAOyTUZLRYOtaoBakkgAAAAAAAACwGQKUAAAAAAAAAGyGACUAAAAAAAAAm2ENSgAAAAAAANgttodu/MigBAAAAAAAAGAzBCgBAAAAAAAA2AwBSgAAAAAAAAA2Q4ASAAAAAAAAgM2wSQ4AAAAAAADsF5vkNHpkUAIAAAAAAACwGQKUAAAAAAAAAGyGACUAAAAAAAAAm2ENSgAAAAAAANgvo8HWNUAtyKAEAAAAAAAAYDMEKAEAAAAAAADYTLWPeH/99ddnVPDw4cPP6HoAAAAAAAAA9q/aAOWIESNkMJz+M/oEKAEAAAAAAGBrBqOta4DaVBugHD58+BkFKAEAAAAAAACgNtUGKKdNm3YWqwEAAAAAAADgXMQmOQAAAAAAAABs5rQDlEVFRUpMTFRaWlp91gcAAAAAAADAOaTOAcqvv/5avXv3lqenpyIiIvTUU09VHvvxxx91xx13KDY2tl4rCQAAAAAAANSZ8Rz4sQN1ClCOGDFC9957rzZu3Ch3d3cZjeb/Ch06dNCsWbM0d+7ceq0kAAAAAAAAAPtkdYBy+vTp+vrrr9WtWzdt2LBBmZmZFuecd955ioyM1G+//VavlQQAAAAAAABgn6rdxfvfPv/8c3l7e2vBggUKDw+v9rwuXbpo165d9VI5AAAAAAAAAPbN6gDl9u3b1bdv3xqDk5Lk5+enpKSkM64YAAAAAAAAcGYMktFg60qgFlY/4l1cXCwvL69az0tOTpazs/MZVQoAAAAAAADAucHqAGWLFi20Y8eOGs8pLS3Vzp071aZNmzOuGAAAAAAAAAD7Z3WA8sorr9SBAwf07bffVnvOZ599psTERF177bX1UjkAAAAAAAAA9s3qAOXTTz8tb29vjRw5Ui+88II2bdokSSooKNDu3bv1+uuv64knnpC/v7/Gjh3bYBUGAAAAAAAAYD+sDlBGREToxx9/lJeXl9555x317t1bBoNB33//vTp37qxx48bJzc1Nc+fOVVBQUEPWGQAAAAAAALCO0c5/7IDVAUpJGjRokHbt2qWnnnpKnTp1kru7u1xcXNSmTRuNHTtWO3bsUExMTEPVFQAAAAAAAICdcarrBSEhIXrnnXf0zjvvNER9AAAAAAAAAJxD6pRBCQAAAAAAAAD1qc4ZlJJ07Ngx/f3334qPj5ckhYeH6+KLL1ZERES9Vg4AAAAAAAA4I3ayTqM9q1OAMiUlRWPHjtW8efNUVlZmdsxgMOjGG2/UhAkT2CQHAAAAAAAAgFWsDlCmpaXpoosu0v79++Xg4KALL7xQLVu2lCQdPnxYa9as0dy5c7V161atXr1azZs3b6g6AwAAAAAAALATVgcox40bp3379unSSy/Vp59+qjZt2pgdP3TokEaPHq0///xTr732mj7++ON6rywAAAAAAAAA+2L1Jjk//fSTAgMD9dNPP1kEJyWpdevW+uGHHxQQEKAff/yxXisJAAAAAAAAwD5ZHaBMTk5WTEyMPD09qz3H09NTMTExSklJqZfKAQAAAAAAAGfEaOc/dsDqAGV4eLiKiopqPa+oqEhhYWFnVCkAAAAAAAAA5warA5TDhg3TX3/9paSkpGrPSUpK0l9//aWbbrqpXioHAAAAAAAAwL5ZHaB85ZVX1KlTJw0aNEi//fabxfHff/9dl156qTp16qTXXnutXisJAAAAAAAAwD5Vu4v3JZdcYvGao6Oj9u7dq8GDB8vPz08tW7aUJB0+fFgZGRmSpH79+mnw4MFasmRJg1QYAAAAAAAAsIpRktFg61qgFtUGKJctW1btRUajUenp6UpPT7c4tmrVKhkMfPEAAAAAAAAAaldtgHLp0qVnsx4AAAAAAAAAzkHVBihjYmLOZj0AAAAAAAAAnIOs3iQHAAAAAAAAAOpbtRmUAAAAAAAAQFNnMNq6BqhNnQOU69ev19y5c7Vv3z5lZWXJaLT8lg0GA7t4AwAAAAAAAKhVnQKUjz32mD755JPKoKTBYDALUFb8nV28AQAAAAAAAFjD6jUoZ86cqfHjxysiIkJTpkzRFVdcIUlatGiRJk6cqAsvvFBGo1HPPvus/vrrrwarMAAAAAAAAAD7YXWA8vPPP5eTk5P++usv3X///QoNDZUkXX755Ro9erRWrFihcePG6YMPPpCnp2eDVRgAAAAAAACwmtHOf+yA1QHKrVu3qm/fvmrTpk2157z88suKjIzU//73v3qpHAAAAAAAAAD7ZnWAMjc3VxEREZV/d3V1lSRlZ2dXvmYwGNS7d2+tWrWqHqsIAAAAAAAAwF5ZHaAMCgrSiRMnKv8eGBgoSTpw4IDZeZmZmcrJyamn6gEAAAAAAACwZ1bv4t22bVvFxsZW/r13794yGo369NNP9dlnn0mS9u7dq6VLl6pdu3b1X1OgCRk4OFnX3p6kVh1y5eBg1NFYDy2eF6RfZobKaKz7LvfnX5SuG0ccU7vOOXJ2LVPSUTct/yVQ874MV3GxdfcZevZP1/+m7pQkrV3aTOMe6lTneqDhDBqarsHDU9WqY74cHKWjB1z1x/fNtfDrgNNqM70GZunGUSlq3zVPzm5lSopz1bL5fpr7aZCKiyzbjE+zEvW9IlMduuepXdc8tepYIBdXo37+KkATX4qo4h1ga4OGpmnw3SmntBk3/THb/wzaTKZufCBZ7bvlmfqZOFctm99Mcz8LrqHNZKhDt4o2k29qM9MCNfGlyPr4iGgAf/3gp4VfByh2t7vKSqXItoW64tY0Db4nVQ5W37Y2yc5w1JzJQVq72EeJcS4qKzWoWWCJuvTN0U0PpqhN5/x6vQ62MeiGdA0efsJyfJruf/rj04Mpat81/+T49JOf5n4aWGVfU6FDj1zdOiZZnXrnycOrVCkJzlr5u69mfhysvGzHM/mIqGcDByfrmtsSK+fB8bEeWvxD8OnPgwek6YZ7j6ldp3/Ng6dGqMTKeXCP/un635c7JEnrljVnHtwI0dcAMBiNRquW03zrrbf00ksvaceOHerYsaMKCwvVtm1bJSQk6Pzzz1dkZKT++usvZWVl6e2339bTTz/d0HWHnfF1DFBfryG2rsYZe/iVg7ruzkQVFjhoy2pflZYY1L1fpjy8SrXyD3/97z/RdRpkb74/Xvc9fVilJdK2db7KyXJSl95Z8vMv1u7N3np+RGcVFtQ8WHp4lWjygs0KCCmUg4P9BCjL7CRb+5H/xWvIiFQV5hu0ZaW3SooN6j4gW57eZVrxq6/eGNWyTm1m2Ojjuv+lRFObWe2l7ExHde2bK7+AEu3a6KHnbmmrwgLziVm/KzM0buphi7LsLkBpqGMEppF65I0jpjZTYNCWFd4qKTGoe//yNvObr94Y1bqObSZJ97+YUN5mvMvbTE55m/HUc7e2q7rNfHnIoix7DFAuit9o6yrUiwnPh2vB9EC5uJWp+4BsOTkZtWWFt/JyHNX/6gy99Plhq4OUyfHOevKGdko+5iLf5iXq0DNXLq5GHdzprsTDrnJ0Mur5yYd10bWZ9XJdU3NlWHdbV6FePPJmvIaMOGEan1Z4mfqaATknx6cHourW1zycbD4+ZTiqa7/y8WmDh567tY0K8y0b4cCh6Xpm/BE5Okk71nnoRJKzonvmKTiiWMcOuejx69sq84RzfX50m3D08bF1Fc7Ywy8f0ODyefDWNX6mOU2/jMp58JuPdqzbPPi+oxpZOQ/2K58HZ5rmwVu89cKILlbNgyf9vKlyHmxPAcrSrCxbV6Fe0NecPWuNS5RlTLN1Nc461xaRCnv6MVtXo0H5T5+pDRs22LoaZ8TqDMo777xTZWVlysvLk2Rag3L27Nm64YYbtGHDhsp/iMGDB+vxxx9vmNraucOHD6tVq1aKiorS4cOHzY4ZDKYO2cp4crVGjBih6dOn66uvvtKIESPOqCxY6n9Fqq67M1Fpyc56+q6uSohzlyT5+Rfpna+3q/8VJzTk7gTN/zrcqvLadc7WvU8eVkGeg567p4v2bvOWJLl5lOr1z3aqS58s3fN4nKa81brGch584ZD8gwv12/chuvb2pDP7kKhXA67J0JARqTpx3ElP3dROCbGm9X39Aor17pwDGnBNpq4fmaqfvgy0qrx2XfM08oVEFeQ56Jlb2mjvZk9Jpjbz368PqWu/XI14LlGfjTNvgxmpzlow3V/7t3lo/3Z3XXRtpu549Hj9fljUiwHXpJ9sMze3V0Ksm6TyNjN7vwZcnanrR6bopy+DrCqvXddcjXw+wdRmbm33rzZzUF375mjEswn67DXzQHVGipMWTA/Q/u0e2r/NQxddm6E7HqV/aaz++cVXC6YHqnlQsd77Yb/CWxdJktJTnPTMzW218jc/zZ8aoBvuT7WqvC/fDFPyMRf1uTRTL352WG4epvlJWZk044MQfftBiMY/E6l+V2TKyfnMr8PZZxqfTpj6mhvbmo9Pcw+e2fg0rLV5X/NNrGl8etZyfAoILdLj7x+VDNK4e1tq9SJfSZKDo1HPTjiigddn6NF34/X6fa3q8dPjdPS/IlWDy+fBz9zdzWwe/Pb0baZ58F0Jmv+N9fPgEeXz4OdHdNHebaYArptHqV77bIe69M7S8McO6/O3q9/EVZJGPc88uDGjrwFQwepUkhYtWujFF1/U+eefX/lav379FBsbq99++00zZszQxo0b9fPPP8vJyeq4J2BXbnkwXpI09b2WlZMySco44aIJ49qaznkgXgaDdYHmWx6Il4ODNOeLiMrgpCQV5Dnqg+fbq7RUGnxHojy9S6oto9fFabripmT9ND1Me7Z6V3sebOPWMaYg4NQ3wyonZJIpYPjJ86YstFseOW51m7l1zHE5OEizJwZVTsgkU5t5/4kWpjYzPFWePuZtZvdGT014IVKLZvnr0E4PlVbfpGBjtz5S0WbCK4OTUnmbeaG8zTycZH2beaS8zUwKrqLNRJW3mRTLNrPJSxNebKFFswJ0aJeHSkvP9JOhIX3/SbAkaeSLCZXBSUlqFliisW8flSTNnhCssjLrytu2ykuSdPujxyuDjJLk4CDd8XiSXN3KlJXupGOn9Gtnch3OvlvHJkuSpv4v1HJ8es50w+KWMcl1GJ+Sy8enQMu+5vFIU19zzwl5+ph3Jjc8kCo3d6P+nNOsMmAgSWWlBn38dIRysxzU/+ostWhXcNqfFfXjllGmvmTq+60s58GvmebBwx44anWbGfbA0VPmwSezSwvyHPWhtfPgi9J0xU3HNf/rcLMy0HjQ1wCocMbPurm7u+vKK6/U7bffrh49etRHnVCF3bt3a/fu3WdczltvvaXdu3frhhtuqIda4VQBwYVq3zlHxUUG/fN7gMXx7et9lZrkouZBxYrunl1reU7OZep1cbokaenPlncMk+LdtGeLj5xdjOodU3Wavqd3iR797wEdO+ymrz+KquMnQkMLCC1S+275Kio06O+FfhbHt6/xUkqis/yDS9Tx/Lxay3NyLlPvQaa29dePzSyOJx1x1e6NnnJxNarPJbW3QTQ+pjaTZ2ozv1h+x9vXeJ9sMz1zay3P1GZMj4f99WNzi+PmbcY+HiM7F6UkOGv/Ng85u5Tp4sEZFse79stVQGiR0pKdtXujh1VlOrvU8oti+S+Svs3NfwE83etwdlk1PiXUcXwqH3f++qG68cnD1Ndcat7XXHhlZrXX5eU4as1iU9Dpwqua9rIATZ1/cKHalc+DV1QxD96x3q/u8+CLyufBCyyfCEiKd7dqHvyf/+5nHtyI0dcAOJV9LMZ1DoiOjlZ0dPQZlxMaGqro6Gj5+vrWfjLqpM15pvUQ4/Z7qKiw6rVw9m03ZY606Vj72okRrfLl5mHKJEk86l7lOZXlnVd1IOKhFw+peVCRPn6pXbV1gu1UbAQRt89NRQVVd8f7tpiCBW061T4pi2hTWN5mHJUYV3X20b6t5eV1rr08ND4V7aDGNlP5Hde+0Yh1bcazvDzaTFN1cIdpDIlqXyBX96oDhO275ZWfa12A8vzywPbMj4NVkHdyXTCjUfruwxAV5juq7xWZ8gsoqZfrcHZZNT5tdTc7tyaVfU1aDX3NFsu+y8OrVGGtisyOW3Mdzj7r5sGmJ3nqNA/OcFJSLfPg1tWU9+CLB03z4JeZBzdW9DU4mwxG+/6xB9UGKI8cOXJGP42JwWCoXMNx2rRp6tWrlzw9PRUSEqL77rtPKSkpkqSCggK9+uqrat++vdzc3Cofay8uLq627EWLFmnIkCEKDg6Wi4uLQkNDdfvtt2v79u3VXvPPP//o8ssvl4+Pj7y9vdW/f3/9+OOPVn+GfysuLtaUKVM0aNAgNW/eXK6urmrRooUGDx6sGTNmmJ07YsQIGQwGTZs2zez1cePGyWAwaNy4cTp+/LgefPBBRUREyNXVVa1atdJzzz2ngoLq09nXrl2r2267TREREXJxcVFgYKCGDBmiFStW1Pi57ElwRKEkKTmh+sfSkhNNx0LKz625PNO/d0piDeWVv1dIuOV3c8GgE7rshmT99n2Itq8nIN0YhUSaJkLJ8S7VnpN8zLQIW0iLomrPsSjvWP2Uh8an4nur+Ts2HQuJrL2fqTjHqjYTSZtpqpKOmL7foIjqv8Og8GKzc2sz4plEdeiRq3VLfDW8Tye9MryV/vtAS40c0FGzPgnSpTel6dkJcfV2Hc6uyr4mvvqFQCv7GmvGp4ryEqwo75S+Jrj8z9kZjsrLqTrAVJd6oOGElM9bkxPcqj2nYk5bMcetSXD53Dalhnl1SqKb2Xufqs+gE7psqGkevGO9X63vB9ugrwFwqmoXi2zZsmW1AbHaGAwGlZQ0vjvfzz77rD766CPFxMToqquu0qpVqzR16lRt2LBBK1eu1JVXXqndu3crJiZGbdu21fLly/Xmm28qJSVFU6ZMsSjv0Ucf1fjx4+Xk5KTevXsrIiJCBw4c0KxZs/TTTz9p3rx5uuaaa8yumTlzpu666y6VlZWpR48eio6O1sGDB3XjjTee1uZC6enpuvbaa7V69Wq5urqqf//+CgoKUkJCglauXKkdO3bozjvvtLq8o0eP6vzzz5fRaNSFF16orKwsrVixQu+884527dqln3/+2eKa999/v3LX9p49e6pfv36Kj4/XL7/8ol9++UWffvqpHnjggTp/tqbG3cP0OFpBfvV3aAtyTcfcPWt/dM2q8vKqLs/Lp0RjXz+o5ARXffl/LWt9L9iGu6dpsbeCvOqT2Su/Y6/aF4azqrzKNmjlQnNoVNw9rPmOTcfqrc1U08+g6cgv/37dPKpvE27l329+rnUP1/j6l+rdOQc14YUILZ7dXGv/PHkjLKJNgbr0zZFHFW3wdK/D2VWnvsaaOY1V41NF33WyPOv6KOv7PDQct8p5a/XfVX4dxpOKc2qaB1f0bZbz4GKNfe2AkhNcNfU9NjRpzOhrAJyq2gBlixYtTjtA2VhNnz5dW7ZsUceOHSWZgnv9+vXTtm3b1K9fP/n5+Sk2Nrby8ectW7aod+/e+uKLL/Tiiy8qKurk2iWffvqpxo8fr06dOmnu3Llmj1//9NNPGjZsmO68804dOnRIzZqZ1rFISEjQqFGjVFZWpsmTJ+uhhx6qvOb777/XHXfcUefPdO+992r16tXq16+f5s6dq7CwsMpjBQUFWrp0aZ3Kmzp1qu6//35NnDhRLi6mu0S7d+9Wnz59tGDBAq1cuVL9+/evPP+3337TU089pbCwMP3www+64IILKo+tXLlS11xzjR555BHFxMSoffv2df58OD2jXz4o/6AivfzAecrPZdMqAED9OrLfVePubaX8HEc980mcelyULVe3Mu3f5qHP/xumj55uoV0bPPXkh0fr5ToAsNZDL5nmwa880Il5MAA0IdXeIjh8+LBiY2NP+6cxev311yuDk5LUrFmzyiDhrl27NGXKFLO1Gbt3765rrrlGRqNRy5cvr3y9tLRUr7/+uiRp9uzZFmtDDh06VA8++KAyMjL07bffVr7+5ZdfKicnRzExMWbBSUm69dZbNXTo0Dp9ni1btmj+/Pny9vbW/PnzzYKTkuTm5qarr766TmVGRkZq/PjxlcFJSerYsaPuvvtuSdKSJUvMzh83bpwk6YsvvjALTkpS//799fLLL6u4uFifffZZle83ZcoU9erVS7169VKRsWnviFZxV9jNvfq7eyczVGpfB8eq8jwsy+t76QldMiRFf/4YpA1/W256gcajIlOpxqymiu84p/asJqvKq2OWFBoX6zLhTMfqrc1U0c+gabEuQ8X67OrSEum/D7RUQqyrXv4iVpfelK7mQSXy9ClT9wE5emvWQTULLNYf3/try0qvM74OZ1+d+hpr5jRWjU8VfdfJ8qzro6zv89BwCirnrdV/V+51GE8qzqlpHlzRt5nNgy8pnwf/FKQN/zAPbuzoa3BWGQ32/WMHzqlbSldddZXFa23btpUkRUVFmQUvK7Rr106SKfuxwpYtW5SYmKhOnTrpvPPOq/K9YmJiNHHiRK1evVpjx46VpMog51133VXlNXfffbd++OEHqz/P77//LkkaMmSIAgMtd3k+HZdcconc3S0Xoq4Iwp7675Camqp169bJx8dHV1xxRZXlxcTESJJWr15d5fFRo0Zp1KhRkiRfR8sd/5qS48dMa+QEhVW/7ltgSJHZuTWXZ1pXJzC0hvLKj1WcK0kXXnZCktSyfa7e+Xqb2fnNAk1rjHXsnl157NWHOlVOKnF2HT9a+7pwgWHFZufWWF75WpZB4fVTHhqfyjZT43dc3s/UsLZpZXm0mXNCsBXr3aaUr9cVbMVao3s2eerIPneFRhXqvF6Wmyf5NCtVr0FZWjzbX5v/8VL3/jlndB3OvpPjU/XrsNdpfKooL6ym8iz7roo/e/uVysOrtMq14QLL+y/6KNs6Hm+aiwaFVZ9wEBBiOW+ttryKeXBN8+oq5sH9Lk+VJLVsl6u3/z0PDjC1lejuWZXHxjEPtin6GgCnOqcClBERERaveXl5VXvs1OOnbhBz6NAhSdLOnTtrfQy+YgMeSYqPj5cktWpV9VooLVu2rLGsf4uLMy0iXx+7e1do0aJFla/7+PhIMv93qMiUzcrKkpNTzU3p1H8He3Vwl6mtRLXLk4traZW7Bbbvkm06d3ftmSHxh9xVkO8gn2YlCo3Mr3In7w5dc8rL87Q41rZT1Tt7S5JPsxJ1vcC0k6qjo51s+dUEHdx5cmddF7eyKncv7NDd9Ev8gR1V72B5qqMHXFWQb5BPs1KFRhVWuXthXcpD41Oxw3KNbaZbxXdc+27MRw+4WdFmTH3JgZ3W7e6MxufUXVIL8w1V7uS9t3x30rZW7E5asXGSp3f1mU1evqZj2Rkn5wenex3OvlN3fq/X8al5DX1Nj/Lytp8sLy/bUQmxLgprVaT23fO0ZYV3tfU4yLhmUxVzW2vmwYd2Wc5b/y0+tnwe7FeikMj8KnfyrpxX77KcV9c4D/YrUdc+mZKYB9safQ2AU51Tsz8Hh+rTsWs69m+lpabJc3h4uC677LIaz63P4OG/NcQaoafz7+Dr61vr4+kBAU07O9IaqUmu2r/DU+065+qiq1K1ZH6w2fEuvTMVGFqktGRn7d5sOej9W0mxgzb83UwDrjyhQUNS9N1E8+BxSESBortnqbjIoHXLTj7C8sHz7fXB81Wv93nZDcf15Nv7tXZpM417qNNpfErUp5QEF+3f5q52XfN18eAM/TnX/FGkLn1zFBhWrBPHnbR7Y+2T+ZJiB234y0cDrs3UJTeka8ZHIWbHQ1oUquP5uSoqNGjdEp96/Sw4O1IST2kz16brz3n+Zse79M2ue5tZ6qsB12TokhvSNOOjULPjtBn7EBRerLZd8nRgu4f+Xuiny4elmx3fttpTqYkuah5UrI69qv+lvoJ/iCkz5egBN+VkOlYGFU+1Z5Op/Z26S+rpXoezr07j04bab16YjU83pmvGh1WNT3lV9jWrF/nqpodSdMmN6RZBAw+vUvW93HTDdeVvvoLtpCa5av9OL7XrlKMBV6Xqr3/Ngzv3zjg5D95S+3hSUuygjf80U/8rTmjQdcmaOSnK7HhIRH7lPHj98pPt88PnO+jD5ztUWeZlNxzXE2/t07plzZkHNxL0NQBOxQIKpyEyMlKSFBoaqmnTptX489xzz1VeFx4eLsm0vmdVqnu9OhXZjnv37q37h6gHFf8Ozs7Otf47vPfeezap49k2e4rp32TkU4cV2uJkFopv8yI98upB0zmfR8h4yhoR192ZoCm/bdST71h+j3M+j1BZmTTs/vjKu8SSaU24x9/cJ0dHaeF3ocrNPqfuNdiVWRNME/iRLyQorOXJx5h8/Ys19k1T1vXsicFmbWbIiBR9sXy3nv44zqK87ycGq6xMuuWR5MrMN8nUZp54/4ipzXwdoNws2kxTNWuiabI98oVjCmt5Mqvd179YY/9n2lhk9qSQf7WZZH2xbKee/uiwRXmVbebh41W0mbjyNhNIm2nibht7XJI09X9hOhZ78vG0jFQnffK86SmSW8Yc16n3KedPDdB9F0Xr3f+Y3yDreH6e/EOKVFjgoA+ejFRu9smLysqk7z4K1u6NnnJ0MmrAtRlnfB1sY9YnQZKkkS8mWo5Pb5WPTxOCzPuae1P1xd979PTHRyzK+35CUPn4lFKZiSSV9zUfHDX1NdP9lZtlnnn34xcBKsg36LJh6ep7RWbl6w6ORv3n3Xh5+pRp5W8+OrK/9seG0bBmTzH1JSOfjLWcB79imgfP+TzSrM0MvjNBn/26QU++bTkPnj0lstp58GNv7mcebCfoawBUoDc/DX369JG/v782b96sAwcOVK5jWZuYmBj99ddfmjFjhu677z6L4zNmzKhTPa688ko9//zzmj9/vlJTU896lmJ4eLi6dOmi7du3a9myZRo4cOBZff/GaMWiAC38LkSD70jS5AWbtWWVr0pKHNS9X4Y8vUu1anFzLfjWfDMjn2bFimydr/QUZ4vy9m331lfvt9R9Tx/WB7O2ausaP+VkO6lL70w1CyjWni3emv5hlMV1aDpW/OKnBdP9dd09J/Tpn3u0eYW3SooN6jEgu3wi5KufvzL/v+3TvESRbQuVlmzZhe/b6qGpb4bq/pcS9eH8/dqy0lu5WY7q0jdHzQJLtHuTh6a9HWpxnSR9tGBf5Z8DQk2ZTgOuzVC7bicndxOej7Dq0WE0nBW/NNOC6dm67p5Uffrnbm3+x1slJQb16F/eZn731c9fma9LXNlmqupntnpq6lthuv/FBH34096q28w7YRbXSdJHP++p/HNlm7kmXe26ngx0TnihBW2mEbhocKYG35OqhdMD9NCl0eoxIFtOzkZtXuGtvGxHXXhVhobcm2p2TVaak+IPuql5UInZ684uRj354RG9dm9rrfzVT9tXe6l99zy5upXp4E53JR1xlYODUQ+9dkxhLYvO+DrYxopf/LRgWo6uG3FCny7ZW8X45HP649PP+7VlpZdyMx3VpV+uqa/Z6KFp71iOTykJLvrwyUg9M/6IXp16WDvXeerEcWdF98xVSGSxjh1y0cfPVL1UE86ulYsCtfC7TA2+I1GTft6kLav9VFJsOGUe7K8FM8zHE9+KeXCq5bp++3d4a9r7LTXy6cN6f+YWbV3rp9wsJ3U+ZR789Uctz9KnQ0Ohr8FZYSz/QaNGgPI0ODs76+WXX9Zjjz2moUOHaurUqerTp4/ZOUVFRfr999/Vvn37yse877vvPr377rtaunSpPv/8cz3wwAOV58+dO7dOG+RIUo8ePXTddddpwYIFuuGGGzR79myFhp7sbAsKCrR06dI67+RdF//97381dOhQ3XXXXZo6darFZjmlpaVavny5PDw81Ldv3warR2My8bW22rnRR4PvTFSXPllycDDq6CF3/TEvWL/MDDW7+2eNuV9EKHavp26895jadcmWi6tRSUfd9PM3YZr3ZbiKi0mEbuomvBCpneu8dN2IVHXpmyNHR9MaOotmNdfCrwPq3GbmTA5W7G533fRgstp3y5OLa5mSjrhq/tQAzf00SMVFVbeZjj0tN61oHlRiFpzwqGHtOJw9E15soZ3rvXTdPSnmbeb7gNNsMyGmNjOqvM24lSkpzlXzpwZq7mfBtBk7MfateHXqnaMF0wK0fY2XSkulyLaFuvK2NA2+J1V1WOVF58fkaPKfezRvSpC2rvDSttVeMpZJfgElGnh9uoben6KO51u2j9O9DrYx4YUI7VzvWfX4NN2/7n3NpCDF7nLTTQ+lqH23/PLxyUXzvwzQ3E8Dq+1rlv3UTIlxLrptbLLO652rDj3ylJrgrNmTAjXz42DlZbPJSWMx6fW22rXJR4PvSFSX3pmmeXCshxaf7jz4y8iT8+DOOaY2UzEPnhqhEubBdoG+BoAkGYxGo93HkSvWaqzqoy5btkyDBg1STEyMli1bZnF83Lhxeu211/Tqq69q3LhxZseeeOIJffjhh5Kkrl27qk2bNnJxcdGxY8e0efNm5ebm6rfffjPbPfzbb7/VPffco7KyMvXs2VMdOnTQoUOHtHbtWj3++OP68MMPFRUVZfG4d3WfIS0tTVdddZXWr18vNzc3DRgwQIGBgUpISNDWrVvl6+trVtaIESM0ffp0ffXVVxoxYoRVn1OSpk2bpnvvvVf33HOPpk2bZnbsgw8+0DPPPKPS0lK1b99eHTp0kJeXl5KSkrR582ZlZGRo8uTJeuihhyzKPZWvY4D6eg2p8RzgVGU57PCKOjLwiwzqblH8RltXAU3MlWHdbV0FNEGOPqz1i7opzcqydRXQxKw1LlGWMc3W1TjrXCMjFf7k47auRoNq/u132rBhg62rcUbIoDwDH3zwgYYOHarJkydr5cqV+uWXX+Tu7q7Q0FANHjxYQ4YM0UUXXWR2zV133aWIiAi98cYbWrt2rfbt26fOnTtrzpw56tWrV2XA01rNmzfXP//8o88//1wzZ87UunXrVFhYqODgYF100UW644476vMjV+mJJ57QpZdeqk8++UTLli3T4sWL5eTkpNDQUF188cW67rrrdOONNzZ4PQAAAAAAAND0nBMZlGgayKBEXZFBiTojgxKngQxK1BUZlDgdZFCirsigRF2d0xmUT9h5BuWMpp9BWeff1A4cOKCnn35aAwYMUIcOHfTMM89UHlu7dq2mTJmijIyM+qwjAAAAAAAAADtVp0e8v/zySz3yyCMqKjLtrGgwGJSaenLHx7y8PI0ePVrOzs66995767emAAAAAAAAAOyO1RmUK1eu1IMPPig3Nzf93//9n9auXWuxYUtMTIx8fX31888/13tFAQAAAAAAANgfqzMo3333XRkMBv3222/q169flec4ODioR48e2r17d71VEAAAAAAAAID9sjpAuXr1avXp06fa4GSFkJCQJr8wJwAAAAAAAOyDge2hGz2rH/HOzMxURERErefl5OSopKTkjCoFAAAAAAAA4NxgdYAyKChIsbGxtZ63d+9ehYeHn1GlAAAAAAAAAJwbrA5Q9u/fX5s2barx8e3Fixdr3759GjhwYH3UDQAAAAAAAICdszpA+fjjj8toNOrGG2/UH3/8obKyMrPjf//9t0aOHCknJyeNHTu23isKAAAAAAAA1JnRzn/sgNUBygsuuEDvvvuu4uPjdfXVV8vf318Gg0E//fSTgoODNWjQIB07dkzvvvuuunTp0pB1BgAAAAAAAGAnrA5QStKTTz6pX375Rb169VJmZqaMRqMyMjKUkpKizp0766efftJjjz3WQFUFAAAAAAAAYG+c6nrB1VdfrauvvlonTpxQbGysSktLFRkZqbCwsIaoHwAAAAAAAAA7VucAZQV/f3/5+/vXZ10AAAAAAACA+mUn6zTaszo94g0AAAAAAAAA9cnqDMrXX3/d6kINBoNefvnl06oQAAAAAAAAgHOH1QHKcePGyWAwyGi0zIs1GAyVfzYajQQoAQAAAAAAAFjF6gDlq6++WuXrZWVliouL07Jly3TkyBGNHDlSkZGR9VZBAAAAAAAAAPbrjAOUFQoKCvTQQw/p999/16ZNm864YgAAAAAAAMCZMBhNP2jc6m2THDc3N3366acqLS3VSy+9VF/FAgAAAAAAALBj9bqLt5ubm3r16qVff/21PosFAAAAAAAAYKfqNUApSSUlJUpNTa3vYgEAAAAAAADYIavXoLTGvn379M8//yg8PLw+iwUAAAAAAABOj9Fg6xqgFlYHKL/++utqj+Xk5GjPnj365ptvlJ+fr9tuu61eKgcAAAAAAADAvlkdoBwxYoQMhuojzkajaUukwYMH17rjNwAAAAAAAABIdQhQDh8+vNoApYuLi8LDw3XppZeqf//+9VY5AAAAAAAAAPbN6gDltGnTGrAaAAAAAAAAAM5FVgcox48fLw8PD91///0NWR8AAAAAAACg/hhtXQHUxsHaE5944gnNnz+/IesCAAAAAAAA4BxjdYAyMDBQ3t7eDVkXAAAAAAAAAOcYqwOUAwYM0Pr16xuyLgAAAAAAAADOMVYHKF955RXFx8fr1VdfldHIw/sAAAAAAABo/AxG+/6xB1ZvkrN582bdfffdeuONNzR37lxdf/31ioqKkru7e5XnDx8+vN4qCQAAAAAAAMA+VRugHDlypAYMGKCRI0dKkkaMGCGDwSCj0ajdu3drz549NRZMgBIAAAAAAABAbaoNUE6bNk2SKgOUw4cPl8FgOCuVAgAAAAAAAHBusPoR74qAJQAAAAAAAADUF6sDlAAAAAAAAECTYycbydgzq3fxBgAAAAAAAID6RoASAAAAAAAAOAd89913uuiii+Tr6ysvLy/16tVLEydOVFlZ2RmXPWXKFBkMBhkMBo0ZM6ZO19b4iPfcuXO1bNmyOlfIYDDo4MGDdb4OAAAAAAAAQP175JFHNGnSJLm5uenSSy+Vs7OzlixZojFjxmjJkiWaO3euHBxOL5cxLi5OTz31lAwGg4zGuj9TX2OAMicnRzk5OXUulN2+AQAAAAAAYHNGycAalJo3b54mTZqkkJAQ/f3332rXrp0k6fjx4xo0aJB+/PFHffLJJ3r00UfrXLbRaNR9992nsrIyDR8+XNOnT69zGTUGKK+66io9++yzdS4UAAAAAAAAQOPw1ltvSZLeeeedyuCkJAUHB2vy5MkaOHCg3n77bY0dO7bOWZSffvqplixZovHjx+vEiROnVb8aA5QhISGKiYk5rYIBAAAAAAAA2FZ8fLw2btwoFxcXDRs2zOJ4TEyMwsPDdezYMa1Zs0YXXnih1WXHxsbqmWee0YABAzRmzBi99tprp1VHNskBAAAAAAAA7NTmzZslSZ06dZK7u3uV5/Tu3dvsXGsYjUaNHDlSJSUl+vLLL89oyccaMygBAAAAAAAANF2xsbGSpKioqGrPadGihdm51pgwYYKWLVumt99+W+3btz+jOhKgBAAAAAAAgP2y801yUlJS1KtXr8q/jxo1SqNGjar8e8UG2J6entWW4eXlJUnKzs626j0PHjyo5557Tr169dJTTz11OtU2Q4ASAAAAAAAAaKICAwO1YcOGs/Z+FY92FxcX68svv5Sjo+MZl1ltgLKsrOyMCwcAAAAAAABgOxXZkbm5udWeU5Fl6e3tXWt548eP199//61XXnlFXbt2rZc6kkEJAAAAAAAA2KmWLVtKkuLi4qo95+jRo2bn1uTHH3+UJC1evFjLly83O3b48OHKc3bs2CEvLy8tXLiw1jIJUAIAAAAAAMB+2fkalLXp0aOHJGnnzp3Kz8+vcifv9evXm51rjdWrV1d7LCEhQQkJCfL19bWqLAer3xUAAAAAAABAkxIZGamePXuqqKhIc+bMsTi+fPlyxcfHKyQkRP369au1vGXLlsloNFb58+qrr0qSHnnkERmNRmVkZFhVRwKUAAAAAAAAgB17/vnnJUnPPvusDhw4UPl6cnKyHn74YUnSc889JweHk6HCCRMmKDo6WsOHD2/w+vGINwAAAAAAAGDHbr75Zo0ePVqTJ09Wly5ddNlll8nZ2VlLlixRVlaWhg4dqjFjxphdk5qaqr179yokJKTB60eAEgAAAAAAAHbLcI6vQVlh0qRJGjBggCZOnKjly5ertLRU0dHRGjlypEaPHm2WPXm2GYxGI18TGgVfxwD19Rpi62qgCSnLybF1FdDUGFjZBHW3KH6jrauAJubKsO62rgKaIEcfH1tXAU1MaVaWrauAJmatcYmyjGm2rsZZ5xYeqaiHnrB1NRqU9/wZ2rBhg62rcUb4TQ0AAAAAAACAzRCgBAAAAAAAAGAzBCgBAAAAAAAA2AwBSgAAAAAAAAA2Q4ASAAAAAAAAgM0QoAQAAAAAAABgM062rgBQydFRDj7etq4FmhCH5n62rgKaGGNWjq2rgCboyrDutq4CmphjP3SydRXQBLUYcdTWVUATUzqop62rgKZm/Wpb1wCoFgFKAAAAAAAA2C+jrSuA2vCINwAAAAAAAACbIUAJAAAAAAAAwGYIUAIAAAAAAACwGQKUAAAAAAAAAGyGTXIAAAAAAABgn4ySgU1yGj0yKAEAAAAAAADYDAFKAAAAAAAAADZDgBIAAAAAAACAzbAGJQAAAAAAAOwXa1A2emRQAgAAAAAAALAZApQAAAAAAAAAbIYAJQAAAAAAAACbIUAJAAAAAAAAwGbYJAcAAAAAAAD2i01yGj0yKAEAAAAAAADYDAFKAAAAAAAAADZDgBIAAAAAAACAzbAGJQAAAAAAAOySQZKBNSgbPTIoAQAAAAAAANgMAUoAAAAAAAAANkOAEgAAAAAAAIDNsAYlAAAAAAAA7BdrUDZ6ZFACAAAAAAAAsBkClAAAAAAAAABshgAlAAAAAAAAAJshQAkAAAAAAADAZtgkBwAAAAAAAPbJKBnYJKfRI4MSAAAAAAAAgM0QoAQAAAAAAABgMwQoAQAAAAAAANgMa1ACAAAAAADAfrEGZaNHBiUAAAAAAAAAmyFACQAAAAAAAMBmCFACAAAAAAAAsBkClAAAAAAAAABshk1yAAAAAAAAYL/YJKfRI4MSAAAAAAAAgM0QoAQAAAAAAABgMwQoAQAAAAAAANgMa1ACAAAAAADAbhlYg7LRI4MSAAAAAAAAgM0QoAQAAAAAAABgMwQoAQAAAAAAANgMAUoAAAAAAAAANsMmOQAAAAAAALBfbJLT6JFBCQAAAAAAAMBmCFACAAAAAAAAsBkClAAAAAAAAABshjUoAQAAAAAAYJ+MYg3KJoAMSgAAAAAAAAA2Q4ASAAAAAAAAgM0QoAQAAAAAAABgM6xBCQAAAAAAALtlYA3KRo8MSgAAAAAAAAA2Q4ASAAAAAAAAgM0QoAQAAAAAAABgMwQoAQAAAAAAANgMm+QAAAAAAADAfrFJTqNHBiUAAAAAAAAAmyFACQAAAAAAAMBmeMQbaAAxVybompuOqFW7bDk4GBV/2FOLF0bo17ktZDQa6lze+f1SNPSOWLXrmCVn11IlHfPQ34tCNe/bViopdrQ4/5f1v1lV7vuvdtVfv4bXuT6ofzFXHNM1N8SpVdssU5uJ89LiXyL16w9Rp9dm+iZr6G2H1K5jppxdSpV0zFN/Lw7TvO9aV9lmJMnFtVTX3xKr/oMSFd4iR84uZcrKcNHenc00f3Yr7djsf6YfE/Vo4LXHdc2tCWrVPkcOjkbFH/LQ4p9C9cussNNrMwNO6Ibh8WrXOVvOLmVKinfT8l+DNe+rSJUUW97PvGxoop74394ay7wzpp/SU13rXBc0nEE3pGvw8BNq1TFfDo7S0QOu+uP75lo43f+02k2vgVm68cEUte+aL2e3MiXFuWrZT36a+2mgiouqvw/eoUeubh2TrE698+ThVaqUBGet/N1XMz8OVl521X0UbMP97wx5LkqXc1yBVCaVhLso7xI/5V7ZXHKwvs14z0qWz+yUao8bnQ1K+P686gsoLJPXr2lyX5Upp8QiqcSoMj8nFbdxV85gfxV19KjLx0IDGjg4WdfclqhWHXJNc5pYDy3+IVi/zAw9zfEpTTfce0ztOuXI2bVMSUfdtPyXQM2bGlHl+FSVHv3T9b8vd0iS1i1rrnEPdapzPdCwLrnwoK67dK9at0iTg4NRRxJ8tejvdlrwZ3Sd2k1g8xz17RGv9q1T1aF1qqLCM+ToaNRnM3ppzq9darzWy6NQtwzeoX49jygkMEeOjmVKz3TXtj0hmvtrJx2MYy4MNCQClEA9G/3MTg0edkSFBQ7aut5fJSUO6t47VQ8/s0vde5/Qm8/2qNMge9PdhzTyP3tVWmLQ9k3NlZPlrM490zT84f3qPSBFLz7cR4WF5r/M/bmw+qBjYHC+uvVOU1mZtH1T89P+nKg/o5/arsE3xamw0EFbNwSopMSg7r1O6OGndqh7r1S9+cL5dWszdx7QyDF7TG1ms79ysp3VufsJDX9or3r3P64Xx/azaDMensV6Z9JqtW6fpbxcJ+3e3lx5uU6KbJmjCwcm6cKBSfrsw/P08+zW9f3xcRoefmmfBt+eYOpn1viZ+pm+6Xr4pf3qdkG63ny8U53azM0jj2jkk4dUWiJtW++nnCxndemVoXsejVWfmBN64b5uKiyoOmiUcMRNOzf5VnmsumtgG4+8Ga8hI06oMN+gLSu8TH3NgByNefOYug/I0RsP1O2GyLCHk3X/S4mmdrPaS9kZjuraL1cjnktSn8uy9NytbVSYbxk8GDg0Xc+MPyJHJ2nHOg+dSHJWdM883fJwivpflanHr2+rzBPO9fnRcZp8pyTI6/d0GV0MKuziKaOjQa7bc+X3eZJct+Uq7enIOgUpJamopZuKW7lZHqihu3A8XqSA1+PklFik0mZOKuzsKTka5JhSLLd1WSpu6UaAspF4+OUDGnxn4snxqdig7v0y9PArB9Wtb4befLRj3can+45q5NOHTf3MOj/lZDmpS+9M3fN4nPoMStMLI7rUOtZ4eJXo0f/uV1mZ5MDzg43S2BGrdf3le1RY5KjNO0NVUuKgHp0T9Z8Ra9SjU4Je//gSq9vNRX3i9PDd6+pchyD/HH34yq8KDshVRpartu4OUVGxo9q0SNPlAw5qUN9D+t+Egfpnfcs6l43GwcAalI0eAcomZNq0abr33nt1zz33aNq0aZWvHz58WK1atVJUVJQOHz5cpzKXLVumQYMGKSYmRsuWLavX+p6LLhyUpMHDjigt1VXPjrpACUc9JUl+zQv11uS1unDQcV13a5x+ntXSqvLadszUiDF7VZDvqBdG99HenX6SJDf3Eo37aIO69EzX8If36fMPO5pd9+FrXast8+Fnd6pb7zRtWeevlCT30/qcqD8XDkzU4JviTG1mdD8lxHtJkvyaFeqtiat14cAkXTcs1urAYNvoDI14eI+pzYzpq727mkkqbzPvr1OXHmka/tAeff6xeebAzXcfVOv2WTqwx1cvPnqBcrJcKo9dcd0RPfrCNo0cs1t/Lw5XRjoZcbbU//IUDb49QWkpLnpmeHclHDH9Uu7nX6S3v9qi/penasidxzT/2wirymvXKUsjHj+kgjwHPT+yu/Zu95EkuXmU6LVJ29Wld6aGPxqrz99pW+X1Ozf56sMXO1Z5DI3HgGsyNGTECZ047qSnbmyrhFjT/2O/gGK9O/egBlyTqetHpuqnLwOtKq9d1zyNfCFRBXkOemZYa+3dbBrv3DxK9d9vYk2BymcT9dk48xtmAaFFevz9o5JBGndvS61eZApuOzga9eyEIxp4fYYefTder9/Xqh4/PU6H2+osef2erlI/J6W80VKlYaY245BRooBXDst9bbY8f01T7uC6ZRQV9PFW9m1BVp9vKChTwGtxcjxepMy7gpRzfYDkeDJQ4ZBdIofs0jrVAQ2j/xWpGnxnotKSnfXM3d2UEGeaZ/r5F+nt6dvU/4oTGnJXguZ/Y93TO+06Z2vEk4dN49OILtq7rWJ8KtVrn+1Ql95ZGv7YYX3+dpsayxn1/CH5Bxfqt+9DdO3tSWf2IVHvLup9WNdfvkcn0t31xH+v1rHjpnHBzydf77/0my7qfURDr9ilHxdZl/WalOKleb+dp/2H/bXvUIBuH7JNl190sNbr7r9to4IDcrV2c4ReHz9IhUWmUInBYNTdN2zR8Ju26LH7VmnVphYqLSXSDTQE/mfZuZYtW8pgMNQ5cInTc8sI0+D31ScdKoOTkpSR5qqJ75gG1WH3HJLByts3w+45KAcHae7XrSqDk5JUkO+kj17vqtJS6dqb4+TpVWxVec4upYq5IkGS9MfPkVZdg4Z1y/ADkqSvJnWsDE5KUka6qyb+n+kxlGF3H7S+zdx9wNRmvm1TGZyUytvMG91MbeZGyzbTtWeqJOmH71qbBScl6Y8FLRQf5ylnZ6PaRmfU+TOift1yf5wkaeoHrSuDk5KUccJFE15vL0kadv8R69vM/Ufk4CDNmdqiMjgpSQV5TvrwpWiVlkqDbzsmT2/r+hk0TreOTZYkTf1faGVwUpIyUp31yXOmYPYtY5Ktbje3jkmWg4M0e2JgZXBSkgryHPX+45GmdnPPCXn6mAeObnggVW7uRv05p1llcFKSykoN+vjpCOVmOaj/1Vlq0a7gtD8r6of3D6bHsTPvDq4MTkpSmZ+TMh4MLT8nVSpr2JQU77kpckoqUu5VzZVzY6BZcFKSyrydVBLGjbPG4JZRRyVJU99vVRmclMrHp9dMN7mGPXDU+vHpgaOm8emLiMrgpGTqZz58vr2pn7kjUZ7eJdWW0euiNF1x03HN/zrcrAw0HrcN2SZJ+mJWr8rgpCRlZLnr46kXms65brvV7WbVxihN/vYC/bmirY4k+KnMyszLbh0TJUnf/tStMjgpSUajQd/+2E0FhY7y9S5UeEiWVeUBqDsClHYgPDxcu3fv1pIlS+p8bZ8+fbR79259/fXXDVCzc4t/UL7anZel4iKDViwJsTi+Y5O/Uo+7qnlAoaK7ZNRanpNTmXpdaAoaLf0tzOJ40jEP7dneTM4uRvXqX/2aTqfqf0mSvHxKlJXhrNXLrM9eQMPwD8xXu46ZKi5y0Iq/Qi2O79jsr9RkN1Ob6Zxea3lOTmXq1c/UFpYussxOSErw1J4dzeTsUqZeFyabHSu2cg2nrEyX2k9Cg/EPLlC7zjmmfmaRZabbjg1+Sk1yUfPAIkV3q30C7eRcpl4D0iRJSxcGWxxPinfXnq0+cnYxqvfFaWf+AWATAaFFat8tX0WFBv290M/i+PY1XkpJcJZ/cIk6np9Xa3lOzmXqfUm2JOmvH5pZHE864qrdGz3k4mpUn0vN2+GFV2ZWe11ejqPWLDYFEC68KrPWeqDhOKQWy+VggYxOBuVfaBnUKerkqdLmTnLMKJHLvvyGq0hxmTwWm8a/nCGs/daY+QcXnhyffg+wOL5jffn4FFSs6O7ZtZbn5FymXheZvvulCyznrEnx7tqzpXx8iql6fPL0LtF//rtfxw676euPour4iXA2BDTPVYfWJ1RU7KDla1taHN+2J0QpaR7yb5avjm2TLQuoR8UlNS8VUPGIeVY2N0SAhkKA0g44OzsrOjpabdrU/HhDVTw8PBQdHa0WLVo0QM3OLW06mH4JizvkraLCqge4fbv8JEmtO9QeOAiPypWbe6myMpyVdMyzynP27/I1e+/aXD7kmCRp6e9h1W6UgrOnss3EelXfZnabvuPW7a1pMzmmNpNZQ5vZ7Wd67/bmv/xvWmOa/N94xyF5+RSZHbt88BFFROXqwF6fyuthG2065kiS4g54Vt9mdviYnVuTiJZ5cvMoU1aGk5KOVr3kQ0V5raOrLi+sRb6G/+eQxo7bq/ueOqCB1x6Xm0f12Sw4+9p0NgWQ4va5qaig6qnfvq3uZufWJKJNoandpDkqMa7qX9T2bfGwKM/Dq1RhrYrMjltzHc4+l1hTBmtxpKvkWnWbKWprajPOsXX7rpwPFcjn6yT5TU6QzzfH5bYmSyouq7oehwrkmF2q0uZOKg12kfPBfHl/d1x+kxPkPTNZLrtz6/TeaDhtzisfn/Z7VD8+bfc2nWvN+NQqv/bxabvpyZPW1ZT34IsH1TyoSB+/3K7aOsG22kadkCTFxfupqLjq1ef2HjQFvNu2bNgbpeu3mW7u3zV0q1xdTp3HGHXXDVvl7laiVRsjlZHFEllAQ2ENyjNkMJjupBiNRk2ZMkWTJ0/W3r175e7urpiYGL3++uvq3LlzldfGxcXpnXfe0e+//65jx47Jw8ND3bt31wMPPKA77rjD6jpUtQZlxXqVFVq1Ml/LKTY2Vi1btqx1DcoTJ07o448/1oIFC3Tw4EGVlpYqLCxM/fv316hRo3ThhRdWnrt37169+eabWrZsmRITE+Xq6ip/f3/16NFDd911l2666SarP1NTFBxmmqAnJ1Y/aKUcNy0KHxJW+2Q+JDzP7Joqy0tyK3/v2jNegkLz1PV80yTgj/nWrU2HhhUcavrekmtYC7RindAQK77jkNCKNlNTG3Q3e+8KP33fSud1S1Of/sn66oe/tGtbM+XlOqlFqxxFtszW+pVB+vjNrqe1+ybqT0i4KWiQnFBDv5BoChgFh9fezwRHFJRfU3t5IRFVl9epZ5Y69TQPoGdnOmn8uPZa+QeZ2o1BSAtTUDA5vvqNZ5KPuZida1V5CVaUF3myvODyP2dnOCovp+pgQV3qgYbjmGz69y8NrP47rjjmeLxuyz+4b8iWNpi/VuLvpPTHIlTUyfzmmlOcqY8q9XeWz7Qkef98wvzCOSnK7+Ot9MciZHQj78KWQiLqMD5F1L6EQ3D5eJeSUH22WsXYFVJFeX0GndBlQ5P1y8wQ7VjvV+v7wTZCgkzB5eOpXtWek3zC1C+EBNaeeXsmvprdU22jTuiCHvGa8fFs7T4QpOISB7VukabggFwtXtFG47/q16B1QANjk5xGjwBlPXn88cc1fvx4XXTRRbr++uu1adMm/fjjj1q0aJEWLVqkAQMGmJ2/Zs0aXX311crIyFCrVq10ww03KC0tTcuWLdOyZcv0+++/a/r06ZUB0Lpq27at7rnnHs2dO1e5ubm66aab5OV1suM/9c/V2bx5s6699lolJiaqefPmGjhwoNzc3BQXF6eZM2dKUmWAcvv27erfv7+ys7MVHR2t6667TgaDQceOHdOiRYuUn59v9wFKd3fTOls17SRYkGf6L+duRXaRW3l5BfnV/zfNz68or/bF4S+/7pgcHKR9u3x1+ABr8DQGFe2gsIbvuCC/Dm3Go6LNVN8G8/Mcy8szbzPFRY7677O9dM+De3XjnQcrHxWXpNRkN23b5M/j3Y3Aye+4+l/EK79jz9r7BfczKC8txVUzP43SmqX+SjrqrtJSgyJb5+rmkUfV//JUPffeLr062kmbVjavtR5oWO4epuy0grzqv+eCXNMxq9qNZx3K8zpZnlXX5VVcV3VGHc4OQ77p37+moF/FMYd8676rkhAXZd4VpIIe3ioNdpahxCinuEL5zE6W6848+b8Rp5S3Wquk5ckAl0OOqf04xxbIZX++cgY3V841/irzdpTrzlz5TUmU+7psGackKP0/3Hy1pXofnzytmdNU3W95+RRr7GsHlJzgqqnvseFWY+buarrBUVBYw+87BaabIR5uDbsWdlaOm55+8yqNHbFGV158QP16Hq08diTBV9t2h1TWBUDDIEBZT6ZMmaKlS5fq4osvlmTKqHzhhRf09ttv64477tC+ffvk5maacBUUFOiWW25RRkaGHnvsMb333ntydDQNvjt27NCll16qb775Rv3799eDDz54WvUZMGCABgwYoGXLlik3N1fvvfeeWrZsafX1OTk5GjJkiBITE/XQQw/pgw8+kLv7yayslJQU7d27t/LvH374obKzs/Xmm2/q+eeftyhr+/btp/U5UD8MBqMuGxwvSVr8s3U7J+Lc0sy/QC+9vUGRLXP02YedtObvEOVkOyuqdbaGP7hX943drZ4XpOiVxy9QWRlZlJA2rWxuEXzcu81X/3vMV/c/fUA3jojX/U8f0MMr+9iohgAak/yBfmZ/N0oq6uKk1C6t1Pzdo3JfkyXfGcd14sVT1gosj30aSozKi/FV5siT6zUX9PHRiebOCnz2kNyXZyrrliCVhnAjDdJDLx2Uf1CRXnmgk/Jz+XUX1okMzdB/n1wid7divTXpYm3aEaqiIie1a5WqUXds0JMPrFSndsl67/MBtRcG4LTwLEQ9GT16dGVwUjI9+v3GG2+odevWOnr0qObNm1d5bM6cOTp69Khatmypd999tzI4KUmdO3fWa6+9Jkl67733zt4H+JcvvvhC8fHx6tevnyZNmmQWnJSkwMBAs6zQ48ePS5Kuvvpqi7K8vLzUr5/9p8Pnl9/hdXWr/q5wxbps+Xm1T5Yq7hi7uVefOefuXlFezevqdO+TqqDQAhUUOGjZ75Yb7sA2KtqBaw3fsZt7HdpMXkWbqb4NVmTM/bvNPPHyFkV3ztCEd7po4dxWSk12V0G+k/bubKZXn+ijwwe91aNPqi65Or7WeqDhnPyOq89YqvyOc2tfbyu/nsurMOuzKJWWSC3b5SkwlN2Yba0iy8jNo/rv2a08u9GqdpNbh/JOeZTbqus8Kq5jimpLRnfTv7+hoPrvquJYmfuZf1dZt5g2/XLdmiuVnHwGz3hK2bmXWW6sVNzWXcWt3WQwSq47WY/Slup9fMq1Zk5j2W/1veSELhmSoj9/CtKGf8jgb+zyC00ZiW6uNfy+U545mdeA2YsODmV69bGlCgvO0riPLtGSlW2Unumh3HwXbdkVpmffulJpGe66auB+dTsvscHqAZzrmP3Vk7vuusviNUdHR91+++2SZLa+4/LlyyVJd9xxh5ydLTvaESNGyGAw6MCBAzp27FjDVLgWv//+uyRp5MiRVj1m3qePKUPmoYce0uLFi1VYWGjV+0yZMkW9evVSr169VFTWtBfEr1h7Mii0+s8RGGz6Rf14Qu2LK1ecU3FNVQLKjyUnVr3ZQIWKzXFW/RWivFweTWgsKttMiBVtpoa1TSscL28HgcHVlxcQVL5WatLJNuMfmK+eF6SadhNfarmbeEnJyV3Gu/e2bsd4NIzj5Wt7BYXV0C+EFJqdW2N5x0zn1BREDKwo71jt5VXIyXJWRpopk8k/yLrxAA3n+FHTdxEUUf3jcYFhxWbnWlVeWE3lmdYwPB5/sryKP3v7lcrDq+qgQ2B4kdX1QMOpXF8ypfrv2DHVdKw06MznFSXhpu/bUGKUQ9bJQEVpsEuVfza7tvx1h3Q257Kl4/F1GJ+sGE8qx6ew6seQwFDL8vpdnipJatkuV29/vc3sZ9gDpkd2o7tnVb7mZsUySWg4x1NMy44FB1S/cVKgf67ZuQ2hY9sUtYzIUFKKt3YfsFw/OzvXVeu2mp5C69kpocHqgQZkPAd+7AABynry701oKlQ8Vh0ffzLrqCLoWN01bm5uCgsLMzv3bIuLi5MkRUdHW3X+008/rUsvvVRr167VFVdcIV9fX/Xt21fPPvtsjY93jxo1Shs2bNCGDRvk4tC0d0Q7uNe0rmNU62y5uFY92Wl3XqbZuTWJP+ylggIH+fgVKyS86qyA9p0qyvOuthwvnyL1izFluLI5TuNycJ9ph+6oVjnVt5mOGWbn1iQ+rrzN+NbQZs4rL++UNlgRBC0ocFRZadXDQm6OKYPT26dh1/9BzQ7uNk3Oo9rmVttm2nc2LSJ/aHf1/UKF+FgPFeQ7yMevRCGRVQe223fJKn/v2sur4OBglKeXKVhQUEuGNxrewR2m8TWqfYFc3KrOburQ3bRx1oEdtY/FRw+4qiDfIJ/mpQqNqjp40KFHeXnbT5aXl+2ohFhTMKl996o3/qqox0Er6oGGU9y6fIfuo4VSYdVtxvmAqc8obnXm35VD9sn+7NSsyaJWp6xHmV11ANIxq9TiOpx9leNTu7zqx6cu5ePTLs8qj58qPtbdivHJVN7BXZaBq7adctW1T6bZT2RrUzk+fiWVrzk62slv9U3UgcOmLNeoiAy5OFf9f7xDa1PQ+UCcf4PVI6g8CJqbV/0Nl9w80/jl48WNV6ChMJLb0OlugHM21LVuHh4e+vPPP7VmzRqNGzdOF198sXbu3Kl3331XXbt21euvv95ANW08Uo+768BuHzm7GDXg0iSL4517nlBgcIHSUl21Z7tfreWVlDho4yrTI0+Drra8UxcSnqfoLukqLjJo/Yrqd8oddFWCXFzLlHDUQ9s38ahLY5Ka7K4De3zl7FKmAZdYPi7Sucepbcby0bZ/Kylx0MbVprYw6ErLmxshYbmK7pyu4iIHrV8VXPn6iVTTDpnePsUKi6z6DnZ05wxJ0vGEmrN10bBSk9y0f6eXqZ+50jKbtXOvDAWGFiotxUW7t9R+I6Sk2EEbV5j6hUGDj1scD4nIV3S3LFM/87f1/UefmBNy8yhTXo6jjsbSZmwtJcFF+7e5y8XVqIsHZ1gc79I3R4FhxTpx3Em7N9T+fZUUO2jDX6b2dcmN6RbHQ1oUquP5eSoqNGjdEvN2uHqRb7XXeXiVqu/lpoD4yt9qvymDhlMa4Kyi1m4ylBjlvirL4rjLzlw5nShRqZ+TijqceYCy4j2Kw11kdD95U6PM31lF7Uzlu26zvPFmyCmV86HyQGkbgtq2lJrkenJ8uirV4njn3hkKDC1SWrKz9ePTP6a5z6Drki2Oh0TkK7p7+fi0/OT49OHzHXRN9EVV/nzwfHtJ0rplzStfy81mjUpbSknz0r5Yf7k4lynmgsMWx7tGJynIP08n0t21a3/1v++cqRPpprEvMixTnh5VByA7tjXNuxJTrL9hC6BuCFDWk8OHD9f4enj4yY1JKv586NChKq8pKChQQkKCxXVnU4sWLSTJbCMca1xwwQV69dVX9ccff+jEiRP66quv5OTkpHHjxtW5rKZo9rTWkqR7x+5VaMTJibRvs0I9/OwuSdKc6a1lNJ4MAA8eFqdP5/ytJ8ZttShvzvTWKiuTbh4eW5n5JpnWJXz05e1ydJR+mRul3Jzq7/ZdPqRic5wISY03KH6umv11G0nSvQ/vtmwzT5myj+d808a8zdwcq09nLdUTr2y2KG/ON21Nbeaug2p/3skAgJt7iR59caupzfxg3mZSkjy0b5cpGPDYi1vl18x8YnbpNUd10aWmPmn5n6xhamuzvzD1zyOfOKTQFiez0HybF+mRl/dJkuZ80cK8zdwRr88WrNWTb+6usryyMmnYyCOV2ZKSac3cx/67R46O0sJZ4crNPtlmXN1Kdc2txyrX1T1V74tP6D+vmfr7hTPDVVrCVKMxmPWJ6Re7kS8mKqzlyf/jvv7FGvuWaZyYPSHIrN0MuTdVX/y9R09/fMSivO8nBKmsTLrlkZTKrEfJtJPvEx8cNbWb6f7KzTLPoP3xiwAV5Bt02bB09b0is/J1B0ej/vNuvDx9yrTyNx8d2W/9kgJoGNk3BkiSfL85LsfEk23GIaNEflMST57jcLLNeP56QkFj96vZx+brFTumFMn97wyp+F/ZmEaj3JdlyOdb0w2SnMGWGVLZN5tu1nrPS63M2pQkFZXJ77MEOeSVqaiNW70ESnFmZk8xPakz8slYhbY4+V35Ni/SI68clCTN+TzSfHy6M0Gf/bpBT75t+XvC7CmRpvHp/vjKbEnJ1M889uZ+Uz/zXShBxiZu5s9dJUn337ZBYcEn5yF+Pvn6z72rJUmzFnQxazfXX75LU//vBz370N/1Uodd+wOVmuYhN9dSPfXASnm4F1UeMxiMunPoFp3XLkUlJQb9sy6qhpIAnAl683oyY8YMdevWzey10tJSzZo1S5I0cODAytdjYmL05ZdfaubMmXrttdfk5GT+NUyfPl1Go1Ft27Y94wCli4spFb2kpG7r8lx55ZVatGiRpk6davU6lFW994gRI/Tll19qxYoV2rZtmzp06FDncpqSlX+F6pe5abr25iOaOHOFtqz3V2mJg7r1PiFPrxKtWhqshbPNBzUfvyJFtsxV+glXi/L27/LTtAkdNPI/e/Xel2u0dUNz5WY7q3PPNDXzL9Ke7b76elL7auvTun2m2nTIVmmJQX8uZPfuxmjl0jD9Mu+Err0pThO/Xa4t6wNMbaZXqqnNLA/Wwrnmy0H4+BYpMqqaNrPbT9MmRWvkmD1677NV2rrRX7k5zurc44SaNS/Snh1++vpTy6UbPn6zm96auFqduqXr8zlLtW+Xn3KyndWiVbZatDJlVc79po12bmm4x2tgnZV/BGnhrAwNvi1Bk37coC1rmqmk2KDufdPl6V2qVX8GaMF35v/fff2KFdk6X+mplmu47d/ho2kfttbIJw/p/W83aevaZsrNdlLnXhlqFlCsPVu99fXH5m3QyblMY17ZrweeOaiDu72UkugqJ2ejIlvnqUUbU7Bq5eIAfTOhZYP9O6BuVvzipwXTcnTdiBP6dMlebV7hrZJig3oMyK4MCv78VYDZNT7NSxTZtlBpyZbTxX1bPTT1zVDd/1KiPvx5v7as9FJupqO69MtVs8AS7d7ooWnvWK5pm5Lgog+fjNQz44/o1amHtXOdp04cd1Z0z1yFRBbr2CEXffwMy5E0BgUX+irnylx5LUpX8OMHVdDVU3I0yHV7rhzyypTfx1u5V5tnVjtklcr5WJHK/MzbjENOqZp/dExlnyWquLWbSps7y5BfKuejhXI6blo6JOfq5sq70jJTu6C3t7KH+Mv75xMKfCFWRe3dVeblKJcD+XJMK1FpcyelPR4hNeInk84VKxcFauF3mRp8R6Im/bxJW1b7mcanfhmm8WmxvxbMML/R6duspvHJW9Peb6mRTx/W+zO3aOtaP+VmOalz70zT+LTFW19/1PIsfTo0lH/WtdTPi6M15PI9+vztn7RpR5hKSg3q2SlRnh7FWrG+heb/0dHsGl/vQrUIy1R6huWNieZ+eXrt8b8q/x4aZAp6Dr1yty6+IK7y9Vc/vERpGabMyZJSR7372QC9/sQSXdQnTl07JmnvoQAVFjmqbVSaQoNyVFpm0KRvL1Bicu0ZwABODwHKejJp0iQNGTKkcmdro9GoV199VQcPHlR4eLhuuummynOHDRumF198UbGxsXr++ef1zjvvyMHBlGGya9cuvfrqq5Kkp5566ozrFR4erv3792v37t1q27at1dfdf//9eu+997Rq1SqNHTtW7733ntzcTmYzpKSkaO/evZWfd9KkSbr00kstApCHDh3Szp07JUlRUefG3aZJ73TSzi3NNHhYnLr0SJODoxR/2FN/LIjQr3PNs5qsMe+b1jp8wFs33Bmr9udlytmlTEkJHlrwfZTmfdtKJcXVr+92RfnmOJvWBCgtlWyUxmrSe120c1tzDb7psKnNOBgVH+elPxZG6tcfoureZma01eGDPrrh9kNq3zFTzq6lSjrmoQWzW2ned62rbDOHD/ro4TtjdMPth3R+3xRFd06Xk3OZsjJctObvYP36Y5Q2rmm4R2tQN5P+2167Nvlq8O3H1KVXhhwcjDoa66HFP4bql1lhdW4zc6e2UOw+T914T7zadc6Wi2uZkuLd9POMCM37KlIlxeZZkIUFjpr5aZTad8lSRMs8teqQIydnozLTnLX6L38tmR+iVX8G1udHRj2Y8EKEdq731HUjUtWlb44cHU3rSS6a1VwLp/vXud3MmRSk2F1uuumhFLXvlm9qN0dcNP/LAM39NFDFRVVnzy77qZkS41x029hkndc7Vx165Ck1wVmzJwVq5sfBystm3dLGIvPBMBV19JDnb2ly3ZknlRlVEu6qvEv9lHtlc7PsyZqUBjgre6i/KaiYWCTn/fkyGKVSPyfl9fdR7hXNVNSl+g0wskaEqCjaQ16/psk5Nl+GQqNKA52VfZ2/cm4MUJkvv9I0FpNeb6tdm3w0+I5EdemdeXJ8mhesX2aG1n18+jJSsXs9deO9x9Suc46pnznqpp+/CdO8qREW4xOapvHT+mnHviANuXyPunZMkoPBqKOJvvp9eTst+DO6Tu3G2am08nHsUwUH5Co4INfsvFNt2hGuB5+/Xjdfs1Pdz0tUt45JMhiMysh011+rWunHRedVuYEOmgaDeJawKTAYjUZWBj4DFZmFjz32mMaPH6+LL75YoaGh2rRpk/bu3St3d3f99ttviomJMbtuzZo1uvrqq5WRkaE2bdqod+/eSktL09KlS1VcXKy7775b06dPN8tcnDZtmu69917dc889mjZtWuXrhw8fVqtWrRQVFWXxqPn48eP16KOPytvbW1dccYX8/PwkSe+88478/f21bNkyDRo0SDExMWY7jUvShg0bdO211yo5OVn+/v7q37+/3NzcFBcXp82bN+v222+vrEf37t21detWtW7dWp07d5aXl5eSkpK0YsUKFRUV6bbbbtPMmTNr/Lf0dQnWhcG3Wf+PDzjxSyzqxphV/S6RQHVK0y3XSwRqcuyHTrauApqgFiOO2roKaGKKzrc+AQWQpA3rJyorK772E+2MR3Ck2t75hK2r0aBc/p6hDRs22LoaZ4TbjfXkgw8+ULt27fTZZ59p7dq1cnNz09ChQ/X666+rS5cuFuf37dtXW7Zs0dtvv63ff/9dP/zwg9zd3dWvXz+NGjVKd9xxR71sojNmzBhlZWVpxowZWrhwoQoLTWsIvfTSS/L3r/lRzV69emn79u368MMPtWDBAi1evFgODg4KCwvTHXfcoQcffLDy3DfeeEMLFy7U2rVrtWrVKmVlZSk4OFgxMTF64IEHzDJIAQAAAAAAgApkUJ6hiiAi/4xnjgxK1BkZlKgjMihxOsigRF2RQYnTQQYl6ooMStQVGZT2iwxKAAAAAAAAoDEjp6zRY1VhAAAAAAAAADZDgBIAAAAAAACAzfCI9xli7UkAAAAAAADg9JFBCQAAAAAAAMBmyKAEAAAAAACA3TLw8GujRwYlAAAAAAAAAJshQAkAAAAAAADAZghQAgAAAAAAALAZ1qAEAAAAAACA/WINykaPDEoAAAAAAAAANkOAEgAAAAAAAIDNEKAEAAAAAAAAYDOsQQkAAAAAAAD7xRqUjR4ZlAAAAAAAAABshgAlAAAAAAAAAJshQAkAAAAAAADAZghQAgAAAAAAALAZNskBAAAAAACAfTJKBjbJafTIoAQAAAAAAABgMwQoAQAAAAAAANgMAUoAAAAAAAAANsMalAAAAAAAALBfrEHZ6JFBCQAAAAAAAMBmCFACAAAAAAAAsBkClAAAAAAAAMA54LvvvtNFF10kX19feXl5qVevXpo4caLKysrqVM6MGTN09913q0uXLgoMDJSzs7OaNWumAQMGaMKECSouLq5TeaxBCQAAAAAAANi5Rx55RJMmTZKbm5suvfRSOTs7a8mSJRozZoyWLFmiuXPnysHBulzGyZMna/Xq1TrvvPPUu3dv+fr6KiEhQatXr9bKlSs1Y8YM/fnnn/L09LSqPAKUAAAAAAAAsFsGNsnRvHnzNGnSJIWEhOjvv/9Wu3btJEnHjx/XoEGD9OOPP+qTTz7Ro48+alV5H3zwgdq3by8/Pz+z1+Pj43X55ZdrzZo1evfdd/Xaa69ZVR6PeAMAAAAAAAB27K233pIkvfPOO5XBSUkKDg7W5MmTJUlvv/221Y969+nTxyI4KUkRERF64YUXJEmLFy+2un4EKAEAAAAAAAA7FR8fr40bN8rFxUXDhg2zOB4TE6Pw8HAlJSVpzZo1Z/x+Tk6mB7ZdXV2tvoYAJQAAAAAAAGCnNm/eLEnq1KmT3N3dqzynd+/eZueertTUVP3f//2fJGnIkCFWX8calAAAAAAAALBf5/galLGxsZKkqKioas9p0aKF2bnWWrBggebNm6fS0lIlJiZq5cqVKigo0IgRIzRmzBiryyFACQAAAAAAADRRKSkp6tWrV+XfR40apVGjRlX+PScnR5Jq3FHby8tLkpSdnV2n9966daumT59u9tpjjz2mcePGydnZ2epyCFACAAAAAAAATVRgYKA2bNhgk/d+6aWX9NJLL6moqEhxcXGaPXu23n77bf3444/69ddfdd5551lVDmtQAgAAAAAAAHaqIjsyNze32nMqsiy9vb1P6z1cXFzUrl07vfjii5o2bZri4uI0fPhwGY3WPV9PgBIAAAAAAACwUy1btpQkxcXFVXvO0aNHzc49EzfeeKN8fHy0ceNGHT582KprCFACAAAAAADAbhmM9v1Tmx49ekiSdu7cqfz8/CrPWb9+vdm5Z/TvbTDI399fkpScnGzVNQQoAQAAAAAAADsVGRmpnj17qqioSHPmzLE4vnz5csXHxyskJET9+vU74/c7dOiQDh8+LAcHB7Vu3dqqawhQAgAAAAAAAHbs+eeflyQ9++yzOnDgQOXrycnJevjhhyVJzz33nBwcToYKJ0yYoOjoaA0fPtysrF27dum7775TQUGBxfvs2LFDt9xyi4xGo2644QYFBgZaVT928QYAAAAAAADs2M0336zRo0dr8uTJ6tKliy677DI5OztryZIlysrK0tChQzVmzBiza1JTU7V3716FhISYvZ6cnKw777xTnp6e6tmzp8LDw1VYWKjDhw9ry5YtMhqN6tOnjz777DOr60eAEgAAAAAAAPbJWP4DTZo0SQMGDNDEiRO1fPlylZaWKjo6WiNHjtTo0aPNsidr0qlTJ73xxhv6559/tGfPHm3cuFElJSUKCAjQ1VdfrVtuuUV33XWXHB0dra6bwWjtft9AA/N1CdaFwbfZuhpoSpys7+wASTJm5di6CmiCStPTbV0FNDHHfuhk6yqgCWox4qitq4Ampuj8trauApqYDesnKisr3tbVOOs8AiMVfdMTtq5Gg3LYMEMbNmywdTXOCGtQAgAAAAAAALAZApQAAAAAAAAAbIY1KAEAAAAAAGC/WNyw0SODEgAAAAAAAIDNEKAEAAAAAAAAYDMEKAEAAAAAAADYDAFKAAAAAAAAADbDJjkAAAAAAACwSwZJBjbJafTIoAQAAAAAAABgMwQoAQAAAAAAANgMAUoAAAAAAAAANsMalAAAAAAAALBfrEHZ6JFBCQAAAAAAAMBmCFACAAAAAAAAsBkClAAAAAAAAABshgAlAAAAAAAAAJthkxwAAAAAAADYLYORXXIaOzIoAQAAAAAAANgMAUoAAAAAAAAANsMj3mg8jGUyFhTYuhZoQsqycmxdBTQxBjdXW1cBTZBTSLCtq4AmJvKeI7auApqgERu32boKaGK+GhZu6yqgiTGUlNm6CkC1CFACAAAAAADAPhnLf9Co8Yg3AAAAAAAAAJshQAkAAAAAAADAZghQAgAAAAAAALAZApQAAAAAAAAAbIZNcgAAAAAAAGC3DHa+SY49fDwyKAEAAAAAAADYDAFKAAAAAAAAADZDgBIAAAAAAACAzbAGJQAAAAAAAOyXPSzSaOfIoAQAAAAAAABgMwQoAQAAAAAAANgMAUoAAAAAAAAANsMalAAAAAAAALBbBjtfg9IePh4ZlAAAAAAAAABshgAlAAAAAAAAAJshQAkAAAAAAADAZghQAgAAAAAAALAZNskBAAAAAACA/bKHXWTsHBmUAAAAAAAAAGyGACUAAAAAAAAAmyFACQAAAAAAAMBmWIMSAAAAAAAA9skoGViDstEjgxIAAAAAAACAzRCgBAAAAAAAAGAzBCgBAAAAAAAA2AwBSgAAAAAAAAA2wyY5AAAAAAAAsF9sktPokUEJAAAAAAAAwGYIUAIAAAAAAACwGQKUAAAAAAAAAGyGNSgBAAAAAABglwySDKxB2eiRQQkAAAAAAADAZghQAgAAAAAAALAZApQAAAAAAAAAbIYAJQAAAAAAAACbYZMcAAAAAAAA2C8ju+Q0dmRQAgAAAAAAALAZApQAAAAAAAAAbIYAJQAAAAAAAACbYQ1KAAAAAAAA2C0DS1A2emRQAgAAAAAAALAZApQAAAAAAAAAbIYAJQAAAAAAAACbIUAJAAAAAAAAwGbYJAcAAAAAAAD2yVj+g0aNDEoAAAAAAAAANkOAEgAAAAAAAIDNEKAEAAAAAAAAYDOsQQkAAAAAAAC7ZSizdQ1QGzIoAQAAAAAAANgMAUoAAAAAAAAANkOAEgAAAAAAAIDNsAYlAAAAAAAA7JfR1hVAbcigBAAAAAAAAGAzBCgBAAAAAAAA2AwBSgAAAAAAAAA2Q4ASAAAAAAAAgM2wSQ4AAAAAAADsloFNcho9MigBAAAAAAAA2AwBSgAAAAAAAAA2wyPeQAMYeM1xXXPLMbVqnyMHRyk+1kOLfwrRL9+Hy2g01Lm88/uf0A3Dj6pdp2w5u5QpKd5dy38L0rxpLVRSbHmf4bLrE/XEG3tqLPPOgRcq/YRrneuChjHw+hMafFeyWkXny8HRqKMH3bR4ToAWfhN0em0mJlM33p+k9l1z5exqVNIRVy37ubnmTQlRcZFlm2nTKVe9Bmaq50VZimqfLy+fUuXnOujQbg/9Oc9ff84NOK16oOEMHJysa29PUqsOufp/9u47Korr7QP4dxeW3ntvNhSxgr1giUajxp5EEwvxtRtNMWqa/jSJMTHVGnuLmqixayyIFXtvoAjSe++w7L5/rKzZLMiiwiz4/ZzDOTJz5+6z7PXO7DN37hWL5YiJNMKxXXY4uM3x+dpM5wwMHhOHBk1zIdGXITHGAKcO2mLXWmeUlNPPlKdVxwx8s+4uAOBisCXmTfSpchxUvbq+noC+w2LgWT8XYh05Yh8b49g+Jxza4fp87aZDKgaOjEKDJlmK81OcIU4fccSuTR7lnp/+rUuvBPR8Mx71GmXD2ESK7Cw9RD8yxsnDjji+3/l53yK9ZEL3Nf5d0tGxdxrqNc6FlV0xTM2lKCkWIzbSECHHrLF3sxMK83Vexlull+TRfmPc32qG9DA9yGWAhVcJGgzOQeMRORBpODwmJ1YXf3V31ahs3z8S4Ohf+ELHkfACAh7jjTfC4emZpehrYkxx7JgXDh6sX6W+xsYmD23bxqNBg3Q0bJgON7ds6OjIsWZNC+za5V3uMSKRHN7eafD3j0fz5klwdc2GoaEUOTl6CA+3wuHD9XD+vMvLeqtEVAEmKIlessmfP0C/t+NQVCjGzYuWkEpFaNE2A5M/f4jmbTPw7UdNq3SSHTo2CoEfRaBUKsKtKxbIzdaFb+tMjP4gEm26puGzcS1QVFj+hXl8tCHuXjcvd19RES/mtcWUBVHoPyoZRYUi3DhnBmmJCC06ZmPKgmi06JiNrydW7cJs6IQEjPssFqVS4NYFM+Rm6cC3bQ7GzIxD2x6ZmP1OI5U2I9aRY9mhewCA/FwxHtwyRmaKBDaOxWjqn4Pm7XMQ0D8d8/6vAUqKOPBeG0z+6hH6j0xAUaEYN86bo1QqQov2WZgyNwIt2mfhmw+8q9ZmxsXi/ZmPFW3mkrmin/HPxugPo9AmIB1zxjStsJ8pY2QixfSvwyGTAWI2E600afZ99Bseozg/XbaCtESMFm3SMHl2KFq0Sce3M5tXqd0MGR2JwOkPUSoV4fZVS+RmS9C0dTpGTQmHf+cUfD7Rr9x2I9ErxWc/3ESbzqkoyNfBvZsWyM2SwNquEA19siESgQlKLaENfU1A/xR0H5CC2EhDRIYaIztTAgvrYjRukYOGvrnoOSgJn77bDBmpei/77dNzCJlnjftbzaCjL4NT+0KIdeWIP2+I8/NtEH/eED2WJGuUpJQYydBgUE6F+zPC9ZB6Wx8SYxlsfIpe+DgS1uTJV9C/fziKinRw44Y9SktFaNEiCVOmXEWLFkn45puOGvc1nTrFYsKE61V6fQeHXPz003EAQHa2Hh48sEZurh4cHHLh758Af/8EHD3qiZ9/bgOAN+xrJTkAOSehGVre8AAAtadJREFU1HZMUL5EGzZswNixYzF69Ghs2LCh2l8vICAAp06dQnBwMAICAqr99ahyHXsmo9/bcUhP0cOnY1oiPtoIAGBhXYzv1l5Hx56pGDAiFnv/0OzOboMm2RgzIwKF+WLMGdcCYbcVyUYDQyn+t/wWfP2yMOqDCKz+vkG5x9+9bo6fv2j8ct4cVYuOfdLRf1Qy0pMl+GSYN+IfGwAALGxKsGh7KDq+nokBY5Kwd72DRvU18M1D4OxYFOaLMeudRgi7YQIAMDAqxfz1D9GsXQ5Gz4zDqgVuKsc9uGWEHSscceG4hcoIS49G+fhm8wO07pqNtyYnYMvPTBoIrWOvVPQfmYD0ZAlmvtsM8VGGABT9zKJNt9GxVxoGvBePvZs0+6waNM3B2I8fozBfjNmjfRF2yxTAkzbz+134tlEkD1Yt9HpmPRM+i4C1fREO/+mAN95JfLE3SS9dh+5J6Dc8Bukpepg1zh/xMcYAAAurIixcdQUduiej/9vR2LfNXaP66jfOwphpD1FYIMZnE/wQdscCgOL8NO+36/BtnYFRUx5i9Y/qo1U+/N9dtOmcilNHHLDsm8bIy5Uo9+lKZHCvl/vib5hemLb0NbvWOmP1d57ITFNNQJqYl+Crpffh2yYbgZ88xo+zG76Ed00vIvKIEe5vNYOhrRRv/JEAcw8pAKAgVYxD7zki6pgx7m42Q9PR2ZXWZWAlQ5dFqRXuPzLOHgDg9UYuJEZPkw7PexwJp2PHGPTvH470dAPMnNkD8fGKvsHCohCLFp1Ax46xGDDgAfbubaRRfYmJxtizpyEePrTEw4dWGD78Pnr2fFzpcTdu2GHnzsa4ft0eMtnTa2Ff32T873+n0atXJO7cscWxY8++HiKi58cxDkQv0fBx0QCAdT/XUyYnASAzTQ9Lv1ZcOA97PxoiDZcQG/Z+NMRiYMd6N2VyEgAKC3Tx85eNUVoK9HsrDsamJS/xXVBNemtyAgBg7UIXZXISADJTJVj6ufuTMokat5nhkxMgFgN/rXBQJicBoDBfBz994qFoM+8lw9hMqtwnKxXhg/4+OHPISu3x78dhRli7UPFIS/dBac/3JumlGj4hFgCwbrGHMmEAPOln5tVXlPm/WM3bzP/FKvqZNS7KhAHwpM3MaahoMyMSYGwqrbAOvy7p6DUkGXs2OiH0pmmF5Ug4wwMjAQDrf2uoTE4CQGa6PpZ9q7iRNWxMpObnp7GREIuBnRs8lclJQHF++mWeD0pLgTeGxcDYRPX81Kp9Krr2TkREmCkWf+6rkpwEAGmJGI9CzZ7nLdJLpi19TUSoiVpyEgBysyTY+IviPNmyY2aV3htVj1u/WwAA/D/JUCYnAcDQRoYO/1NcQ9xaZQ657MVeJy9RB3FnFW2y4TDNb2g873FUvYYPVzzFs25dc2VyEgAyMw2wdKnfkzL3Ne5rLlxwwe+/t8KJE56IiTHXaNBcQoIp5szpjqtXHVWSkwBw+7Yd/vpLcZ7s3v2xRjEQ0fNhgpLoJbG2L0QDnxyUFItw9qit2v47VyyRmqQPK9tieDer/M6xrq4Mfp0UF3PBB9RHzyXGGiL0pjkkenL4d05/8TdANc7GoRgNm+WjuEiEMwet1PbfvmiGlAQJrOxK4N2q8gtpXYkM/gFZAIDgPdZq+xNjDBB6zQR6+nL4d8vSOM5Hd4yV8ZKwbOyL0LBpLkqKRTjzj43a/tuXzZGaqKdoMy0qfsStjK5EBr8uGQCA4H3q/VZirAFCb5gp+pmu5fczxqZSTF8QjrjHBtj0i2aj76hmWdsVokGTbMX56bi92v4716yenp98K+8bdHVl8OuoGKEUfNhRbX9inBFCb1lAoieHXyfVkUz93lLcyNu7zQ0yGR+T01ba2NeUp7RU0YZKitmWhJaXqIPUO/oQS+Tw7JOntt+xTSGM7KUoSNFF8o0XmwP94W4TyGUiWDQohl1zzR/Tft7jqPrY2OSjYcMMlJSIceaM+hNmt2/bITXVEFZWhfD2Fu5G+aNHlgAAG5sCwWIgehUwQUn0ktTzViSQosKNUVzB/I4P7ijuCtZrXPnFvItnPgyMZMjO1EVirGG5ZR7cVdTn5V1+fU6uBRg1LQLT5obi/Y/DEdA3CQaGFY+CoppVzycfABD90BDFFczt+OCmIjlY/0nZZ3HxKlS0mQwdJEQblFsmrAr1lXHyVEwgn5EsqaQkVbd6TZ70Mw+NKu5nbitGztZrXHlS28Wz4Emb0UVCTAX9TFl9TdS/cALAxM8jYGVXjF+/aFBhTCSset6Km2JRj0wqbjd3FaP0vbwrv4Hm7JEHA0MZsjMlSIw1KrfMw3tmKq8NAGKxHM39Fcmnu9ctYW1XiMGjIjHls3t4f0YYOnRPgljnBYdW0UuhjX3NfxkYlWLElBgAwIUT6jf5qGal3VOMcrVsUAxdg/KHrNn6FqmUfV4P/1Zc/zYaWvn19Ms4jqpPvXqKGxdRUeYoLi5/9rkHD6xUygrB2VnRZtLTy7++JqKXQysSlCKRCCKR4s7nqlWr0LJlSxgZGcHa2hqDBw/GnTt3yj0uLCwMo0ePhru7O/T09GBqagoPDw8MGjQIu3btUpZ7//33IRKJ8N1331UYw5IlSyASiTB8+HC1fRcvXsTIkSPh7u4OfX192NjYwM/PD3PnzkVaWvl3cnJycjBz5kx4enpCX18fzs7OmDRpEtLTK74rfPDgQfTp0wc2NjbQ09ODq6srRo8ejfv371d4TEVKSkqwdOlStG3bFmZmZjA0NETjxo0xe/bsCmMGgJMnT6Jnz54wMzODmZkZOnXqhL179+Lx48cQiUTw8PBQlj1z5gxEIhEaN654jsPU1FQYGBjA0NDwma9bFzg4K5I4yQkVn7hSnuyzd658xcCyMika1OdQQX0+rbLw9vgo9BmagCFjYvDponvYeOw8Or6WXOnrU/VzcFVcqCfFVnyhnhKv2GfvWvmd/rL6kuMrHplQlfoU5Bg2UfEY+tl/LDU8hqqLvUvln3FygmKfg0vln7G9S1k/84z6nrxWef1M225p6DkoGYf/dMDty+UvyEXCs3dSjPhITig/MQQAKYlPzidOlY8OKStTdkz59RmqvDYAOLjkw8BQkYD0aZGBVbvP4v0ZD9F3aCwGj4rC54tvYtmf5+HoqvkNFKoe2tbXAIB3i2x8tPABPl4UhgVr7mDzqUvw75KBy6cssZmjtwWXE6u4iWniVPGNcOMn+8rKPo+ESwbIjpJALJGj/puaP6b9vMdR9bK3V9yQSE4u/2aXYp/i5rqDgzCfm76+FAMGPAAAnDun2ToCpJ1E8rr9UxdoRYKyzIcffohJkybB3Nwcb775JmxsbLB79260bdsWZ8+eVSl7+/Zt+Pv7Y9OmTTAyMkL//v3Ru3dvODo64siRI1i9erWy7LRp0wAAv//+O2Sy8u/ML1++HAAwZcoUle0LFy5E+/btsXXrVpiammLQoEFo27YtsrKyMH/+fNy+fVutrqysLHTs2BHr1q1DixYt0KtXL+Tn52PlypV47bXXUFKiPl/gnDlz0K9fPxw9ehQ+Pj4YOnQozM3NsWnTJrRq1QoHDx7U+O9YWFiIXr16Ydq0abhz5w66dOmC/v37IzMzE4sWLULr1q0RERGhdtyWLVvQo0cPBAUFoUGDBujXrx9KS0sxcOBALFu2TK18586d0bx5c4SGhuLEiRPlxrJmzRoUFRXh7bffhrW1+iOndYmBkeKiq7Cg4hFEBfmKfYbGpZXWZ2hUWoX6VC8G01P0sO13d0x/uzXe6tQJQ9t3xocjW+HccRuYmksx+4e7aNWhbieMawODJ+2gqKDirrjsMzYyrnxUkcGTMkX5z6gvr6y+ytsgALw7Ix5NWuchPVkXfy5Tf5STapYm/UJh3svtZwor6LdMzKSYNv8RkuP1sfYHj0pfi4RT9jk/ayX2sjagSbsxqNL56Wl9puZPr3+mfnEP929aYNo77TCkY3fMeLct7t2wgJtXHub9eg26Eo6kFJI29TVlHN0K8drgZPQcmAK/zpkwMSvFyQM2+GlOA+Tncd1PoZXkKQab6D5j4ZmyRWnKyj6PBzsVI23deuTDwErzfuJ5j6PqZWioOC8UFlb8f7hsn6FAT4FNmXIFjo55iIoyw+HD9QSJgehVoVVn81WrViE4OBhdunQBAMjlcnz22Wf47rvvMGLECDx48AAGBoq79T///DNycnLw7bffYs6cOSr15ObmqiQOW7RogU6dOuHs2bM4dOgQ+vXrp1L+xIkTCA0NhY+PD7p27arcvnv3bnz22WcwMTHB1q1b0b9/f5XjLl++DEdH9S/se/bsQd++fRESEgITE8XJMD4+Hu3atcO1a9fw119/YeTIkcryhw4dwnfffQdjY2McOnRI+f4B4IcffsCnn36KkSNH4sGDB7Czs6v07/jVV1/h5MmT8Pb2xvHjx+HsrFhdsaCgAO+99x527dqFkSNH4vz588pj4uLiMHHiRMhkMqxduxaBgYEqf4dhw4aV+1rTpk3DuHHjsHz5cnTv3l1ln0wmw++//w5APfFL1etaiDWuhagmhMNumeObD30x7pNwDB4dg3GfPMLkwXU7aUwvpsfgVIyYHo/iIhG++6AesjP4iDc9NenLR7C2K8aX/9cEBUwOkAbE/8pJpCYaYN4HrSCVKm6oPLxnji+ntMLqPWfh4pGPgD4JOL5Ps9Wh6dUQvM8OwfvsINaRw9axCH5dMvDu1Gj8fvAaFkxtjDtXOIq7rivOFeHxEcVouoZDNH9M+3mPI3rnnTt47bXHyM2V4NtvO6KkhFPZEFUnrRpBOWnSJJXknEgkwtdffw0vLy/ExMSoPLadlJQEAOjTp49aPSYmJmjfvr3KtrJRlGUjJf+tbHTg5MmTVbb/73//A6BIEv43OQkA/v7+cHFxKff1165dq0xOAoCTkxOmTp0KAAgKClIp/+OPPwIApk+frvL+AWDmzJlo164dsrKyVEaFVqSgoAArVqwAAPz222/K5CQAGBoaYuXKlTAxMcGFCxdw7tw55b61a9ciLy8PPXr0UElOAsCgQYMwZMiQcl9vxIgRsLKywt69exEfH6+y7+DBg3j8+DH8/f3h5+dX7vGrVq2Cn58f/Pz8UCyr/LFnbVaYr/iCbmBY8UiCshEEZaPYnqVs9Ilm9WmeHNi+yh2lUhE8GuTB1qF2/81ru7LRJ/qGFd/JL/uM8/Mq764Ln5TRN3pGfcZl9T27DXbum46PfoiErFSE76bVw63zXFVXG2jSL5SNzH1Z/YxBOf1Wux5p6D4gBcd32+HKac79pu3KPmd9g2d8zoaat5vCKp2fntaXn//030EHnJTJSWW9BbrKRXea+XHxNyFpS19THlmpCEmxBji41RHzJjaBsakUny4Oe2b7puonMVaMjpTmVzw6suTJvrKyVRVxwATSAjGMHaRw6az5YiXPexxVv4ICxc1vA4OKR0eW7SsoqNmboYMGhWLUqDvIz9fFl192RXQ0b4IQVTetSlC+++67att0dHTwzjvvAFDMj1imTZs2AICJEyfi2LFjKCp69vw3gwcPhrOzM44cOaLyeHNcXBz27dsHU1NTvPfee8rtiYmJuHnzJiQSCUaPHl2l99G6dWs4OKivuuzt7Q0AKok8qVSqTBSOGTOm3PrGjh0LQPX9V+Tq1avIzc2Fk5MTXnvtNbX9NjY2ymTrv+s7deoUAEXCsTwVbTc0NMS4ceMglUqxatUqlX0VPTb/b+PHj8eVK1dw5coV6Ilr96TDSfGK+O0cK0762TxJCJaV1aQ+22fUZ1uF+srkZkuQma64GLC25wqGQiqbe9LepeLVsW2dip+UrXzFy7Iydk4Vf65P66t43suOr6dj1m+KfvKHDz0RcoRzT2qLpDgNPuMnq62XlX12fWX9zDPqe7KvrCwAdOipmCLCo2EeFm26pfIzfHwsAKBxixzltrLEAwkjOV4xH6SdY8VfzJXnk2fMU1mmrMyzbnLZ2BeqvPZ//50YX/7rJMUptltaV9wvUvXTlr6mMmG3TBH9yAi2jsVo1Jwj44Rk4qxIIuXGV5xEyktQ7DN1Vp/uShMPdikGfzQYnANRFb7FPu9xVP2SkhQjW+3sKp572NY2X6VsTRgw4AHGj7+BwkIdzJvXBaGhNjX22lSN5HX8pw7Qqi7a09Oz3O1lC7PExsYqt82cORM9evTAxYsX0atXL5ibm6Ndu3aYNWtWufNC6urqYtKkSZDJZFi5cqVy+6pVqyCVSjFq1CiYmpoqt0dFRQEA3NzcYGhY+cX6v7m5uZW73cxMMQKpsPDpBX1aWhqKioogFovh7l7+BN9eXl4AFMnUypSVqehvWVF9Zf+uKIaKtgOKBKSOjg5Wr14NqVRxcfLo0SMcOXIE1tbWeOuttyqNuy54dF9x8eNePw96+uV/GW/YVHHxHHHfpNz9/xYbYYTCAjHMLKRwcCn/S2VZfY9CK6+vjFgsh7HJk/ky8/mYgpDC7yomBHdrUAA9/fJHPTZsppg8/NHdiicPLxPzyEDRZixL4ehWfuKgUfOy+sq/yGvfKwOzl0RAJJbjp088cWo/pwHQJo/uPelnGuRX3M/4PukXNOpnDJ+0GSkcXcvvZxo1y31Sn3qbqe+Th2Zts1V+XL0U9ZhZSpXbdHTqyFVTLfUoTHH94V4vt8J206BJlqJsqGm5+/8tNtL4yfmpBA4u5X+pbOiTpfLaAFCQr4u4KEVfZmZefoLCzOLJfGTPmKuQqp+29TXPkvVk+hELq+dLetHLYd1EkWDOeKgHaWH5oyhTb+s/KVv1GxAZ4RKk3DQARHI0GKz5YinPexzVjEePLAAA7u5Z0NMrfxRlw4ZpT8rWzA3zfv0eYtKkaygq0sH//tcZt29XPsUaEb0cWpWgrAojIyMcP34cFy5cwLx589ClSxfcvXsX33//PZo1a4b58+erHTN+/Hjo6+tj3bp1KCoqQklJifKx6f8+3l22qvjzEIuf78/6Iq/5suqq6LhnvSc3NzcMGDAA8fHx2LNnDwBgxYoVkMvlCAwMVM4bWtelJhng4T0TSPTk6NQrRW1/U78M2DoUIT1FD/dvVv6IgFQqxtWziuRQt36JavsdXArg3TwLJcUiXD6teRKpTddUGBjJkJ+rg5jIypNeVH1SE/Tx8LYR9PTl6PyG+uOMvm2zYetUgvRkCe5frfwLoLREjCsnFW2r20D1RZAcXAvh3SoXxUUiXDqh3gbb9sjEZ8seQUdXjl9meSBoN+8Wa5vURH08vGMMiZ4cnV9PVdvv658FW8diRZu5XnmiSVoixpXTigv+bgPU+y0Hl0J4t8hGSbEIl04+fZT7pzkN0adRp3J/fpzdAABwMdhSuS0vh3NUCik1yQDh900V56eeSWr7m7ZKV56fQm9ZVFqfVCrG1RBF/9CtT4LafgfnfHg3y1Scn86o9iMhJxRf9Jq3KX+htuZtFH3hw3ucVkJI2tLXVMbIWIoGPoqkU1xU1QYU0Mtl4lgKa58iyEpEiDysnmROuGSAvERdGNpKYdey6k/wPNihaGeObQth5qb5YinPexzVjNRUYzx8aAmJRIbOnWPU9vv6JsPWtgDp6Qa4f7/6r0v79g3HlClXUVwsxvz5nXDjhvpTkURUfbQqQfn48eNnbv/3fIpl2rZti7lz5+Lo0aNIS0vD+vXroauri3nz5iEsLEylrK2tLd566y2kpaXhzz//xO7du5GQkICAgAA0adJEpWzZKMiYmBgUFFTfXCXW1tbQ19eHTCar8P2XPZJe3vv/r7IykZGRFZYprz4nJycAT0eO/ldFsZX59xyfhYWFWL9+PcRiMSZNmlRpzHXJX2sUI00DP3wER9eno0rMrYox5fMHAIAda90glz9NBPd7Jxa/77uIj7+5p17fWjfIZMCwsdFo2DRbud3AUIoZ80OhowMc+NMZeTlPFy/RNyhF3+FxMChnpTv/zqn4YK7i/8WB7c4olWpVF/BK+nO5Yr619+fEwtH96ahHc+sSTP066kkZB5U20390ElYH3cYnP0Xgv/5a7gCZDBg+KRENmz8dKWBgVIqPfnisaDOb7ZCXrZow8u+Wic9XhENHV47f5njg2A7bl/o+6eX5a5UrACDwk8dwdHt6fjK3KsaUuY8UZVa7qLaZkfFYdfgqPl6kel4EgB2rXRT9zLhY5YgoQNFmPvz2gaLNbHVkkrGW+2ud4smKsR88UD0/WRZh8pz7AIAdGzxVz09vRWPlrrP4aL76kyk71ntCJgOGjolUjpYEFOen6XPvQkcHOLjDFXm5qotr7d3mjvw8HbTtkoqeA1SfDBk4Mgq+rTNQkK+DY1wgR3Da0NeYWxXjjXcSYGSsfk1j51yIOb+Gwti0FA9umyhHfZJwmk/IBABcXmyJ7Kinn2NBmhgh8xQ305uNz1J5zPreZlPs7O2MUzMrTj7JSoDwfYrPt9EwzR/lf97jqGb99Zfie3hg4E04Oj79nMzNCzFlypUnZRqr9jX9H2DVqoP4+OMLLy2O119/hClTrqC4WIwFCzrh2jX1xXCJqHpp1beNP/74A82bN1fZVlpaiu3btwMAAgICnnm8np4exowZg7Vr1+Ls2bO4desWGjVqpFJm2rRp2LRpE5YvX64c2VfeHIkODg5o1qwZbt26hU2bNmHChAkv8M4qpquri44dO+LEiRPYtGkTFixYoFZmw4YNACp//4Bi/ksTExPExcUhKCgIPXr0UNmflpaG/fv3q9XXpUsXBAcHY9u2bco5L/9t27Ztz3zdbt26oWnTpggODsbcuXORnp6ON95445mPmtdF547Z4cD2DPR7Ox7L/76MGxcsIZWK0KJtBoxNSxESZIP921QXVjK3KIGrZz4yUtXnBHx41wwbfvFC4EcR+HHzNdy8ZIG8HF009cuEpXUJQm+aYdNvXirH6EpkmPrlA/zfzHA8um+ClEQD6EpkcPXKh5tX/pM4bbF52av12Wirs4essH9zNvq/l4KVR+/g+lkzlEpFaNEhB8ZmpTj3jwX2b7RXOcbcUgrX+oXISFFfVfvBLROs+84F4z6Lxc9/38eNEDPkZevAt20OLG2luH/NGBt/UP3ib25dgi9XhkNPX46UeAl8/HLg41f+hfyPn3iVu51qztkjNjiw1QH9RiRixf7ruBFiDqlUjBbtMxX9zDEr7N/ipHKMmWUJXL0Kym8zt02x/kcPvD/zMX7afhM3L1ggN0cXvv5ZsLQpQegNU2z8ueJpPqh2OBfkgIN/peON4bFY9mcIblyyQqlUjOb+6TA2lSLkhB0O/Kk6RY2ZRbHi/JSmPsfgw3vm2LCkAQKnP8Ti9Zdw87KV4vzUOgOW1sUIvW2OTcsaqB2XkaqPn75qitnf3cKH8+7izXeiER9tBFevXLjXy0NxkRg/ftkUGamVz2tI1Usb+hp9QxmmznuE8XMiEHHfBEnx+hCLFat412+SB12JHHGPDbBwhne1/i1IM56v58N7RDZCt5rh737OcOpQCLGuHPHnDVGSK4Z7zzw0eTdb5ZjCDB1kRerB0LbiuYqjg41QmKYDPbNSuPeqeK7Cl3Uc1ayzZ11x4EB99OsXjhUr/sGNG/aKvqZFEoyNSxAS4oz9+1XPJ2ZmRXB1zUFGhvqTepaWBfjqq7PK3x0dFTfs+/d/gE6dno7SnD+/EzIyFCOvvbwyMG3aZYjFQGKiCbp0iUaXLtFqdWdn62PNmpYv5X0TkTqtSlAuX74cAwYMQKdOnQAAcrkcc+fOxaNHj+Ds7KyykvTy5cvRo0cPtQRkREQE7t69C6D8eRP9/PzQrl07XLiguNvi5OSEgQMHlhvP3LlzMWTIEMycOROurq7o27evyv4rV67AwcGh3JW8q+Kjjz7CiRMn8Msvv+D1119Hx44dlft++uknnD9/Hubm5hg3blyldRkaGmLixIlYvHgxpk+fjmPHjsHRUXH3p7CwEJMmTUJubi7atWun8jrvv/8+vv/+exw7dgwbN25UWRho37592LFjR6WvPXXqVEycOBHff/89APXH5l8Vy79phHvXLdDv7Vj4+mVCLJYj5rERju12xME/nVXu/mli53p3RD4wweDRMWjQNAd6ejIkxhpg3x8u2LXBDdIS1VGQRQU62Pa7Oxo2zYaLRwE8G+VBVyJDVroE54NtELTXASFBHB2nTZZ94YG7l03Rf1QyfNvmQEdHMZ/k0b9scGCzXdXbzO+OiAw1wpD/S0TD5nnQ05chMVofezfYY9cqB5QUq7YZA0MZ9AwUcwTaOpXgtWHlP3oJMEGpLZb9rz7uXjVDv5EJ8G2TrehnIgxxdJc9Dm5zrHqbWeOCyDBjDB4bhwa+OdDTlyMxxgD7Njth11pnlJRwtHVdsPy7Jrh7wxL9hsfAt1UGxDpyxD42xtG9zji0w7XK7WbXRk88fmiKQe8+RkOfLEj0ZEiMM8T+7W7YtclD7fxU5nywPWa82w7D34+Ab6sMuHrlIjtTD8GHHLBjgyeiwit/ZJhqhtB9TVaaBKu/80BT/2x4NMiHW/18SPRkyM3WxZ0rZgg5Zo1/dqif10g4HeelwaF1Ie79YYbESwaQywBzrxI0HJKDxiOeb5GaB7sUfUK9fnnQ1dd8TuPnPY5q3rJlfrh71wb9+oXD1zdZ0dfEmOHoUS8cPFi/Sn2NRFIKb2/1a1l7+3zY2+erlCtjbFyMshnN3Nyy4eaW/d/DAQBJSUZMUNZSIgAidgNaTySXywX/mMrmPZwxYwZ+++03dOnSBY6Ojrh27RrCwsJgaGiIw4cPo2vXrspjWrRogZs3b8LLywtNmzaFiYkJEhMTcfbsWRQXF+Ptt9+ucNTftm3blKtSz5s3D3Pnzq0wtvnz5yv3+/r6wsfHBzk5OQgLC0N4eDiCg4OVIxE3bNiAsWPHYvTo0cpRj/928uRJdOvWDV27dlVbkXv27NlYtGgRxGIxOnfuDCcnJ9y+fRt37tyBgYEBduzYgX79+qkcExAQgFOnTqnEACgSkX369MHJkydhbGyM7t27w9DQEGfOnEFCQgLc3NwQHBysXCynzMaNGzF27FjI5XK0bt0ajRo1QmRkJM6fP48PP/wQP//8Mxo0aIAHDx6U+7fKz8+Hi4sLMjIy4OXlhYcPH1ZpPk5ziS3aWwzWuDyRLJuTnVPViAw4KouqTmzM+XqpamR5HK1FVTf26i2hQ6BaZv2wvpUXIvqXC2FrkJUfL3QYNc7U0hUtAqYLHUa1KojZjitXrggdxgvRqtuNP/30E5YsWYL09HTs2bMHycnJGDhwIC5evKiSnASAr7/+GhMmTICZmRlCQkKwc+dOPHz4EF27dsVff/2FP/74o8LX6dmzJwBAIpFg/Pjxz4zpq6++wpkzZzBs2DCkpqZi165duHjxIiwtLTFv3jw0a9bsxd84gO+++w779+/Ha6+9htu3b2Pnzp3IyMjAe++9h6tXr6olJ5/FwMAAR48exW+//YYmTZogODgYe/fuhZmZGT799FNcu3ZNLTkJAKNHj8bx48fRvXt3hIWFYd++fQCAnTt3YvBgReLQxqbi+WGMjIzQoUMHAMCkSZOee7EgIiIiIiIiIiJ6dWjVCMqaCuXXX3/FjBkzMHz4cPz555818pq13YIFC/DVV19h6tSpWLJkSbllkpOT4erqCh0dHcTGxsLKSvNVGAGOoKSq4whKqiqOoKTnwRGUVFUcQUnPgyMoqao4gpKqiiMo6666MIJSq+agrAnZ2dlYvHgxAMXcj/RUdHQ09PX1YW+vuiDHoUOHsHDhQohEIpW5Kf/rm2++QXFxMSZOnFjl5CQRERERERER0Usnlyt+SKu9MgnKH374AXfu3MHp06cRGxuLYcOGoW3btkKHpVWOHj2KCRMmoEWLFnB3d4dcLkdYWBju378PAPjiiy/g5+enckxISAjWrVuHR48e4eTJkzA3N8eXX34pRPhERERERERERFQLvTIJyoMHD+LUqVOwtbXF//3f/+HHH38UOiSt06FDB4wePRpnz55FUFAQ8vPzYWVlhb59+2LSpEnlzoP54MEDrF27FkZGRujUqRN++OEHODk5CRA9ERERERERERHVRlqRoKyJuSf/u2o2qWvSpAnWrVtXpWPGjBmDMWPGVE9ARERERERERERU52lFgpKIiIiIiIiIiKg6iDgFpdYTCx0AERERERERERERvbqYoCQiIiIiIiIiIiLBMEFJREREREREREREgmGCkoiIiIiIiIiIiATDRXKIiIiIiIiIiKju4iI5Wo8jKImIiIiIiIiIiEgwTFASERERERERERGRYJigJCIiIiIiIiIiegVs3boVnTt3hrm5OUxMTODn54dly5ZBJpNpXIdMJkNISAi++OILdOjQAZaWlpBIJLC3t0ffvn2xZ8+eKsfFOSiJiIiIiIiIiKjOEnEOSgDAlClTsHz5chgYGKBHjx6QSCQICgrC1KlTERQUhJ07d0IsrnwsY0REBDp27AgAsLKyQps2bWBpaYmIiAgcPnwYhw8fxpgxY7Bu3TqIRCKNYuMISiIiIiIiIiIiojps165dWL58ORwcHHDr1i0cOHAAu3fvxsOHD9G4cWPs3r0bS5Ys0agukUiE7t274/Dhw0hOTsaRI0ewfft2XLp0CSdPnoSxsTE2bNiADRs2aBwfE5RERERERERERER12MKFCwEAixYtQoMGDZTb7e3tsWLFCgDAd999p9Gj3vXq1UNQUBBef/116OjoqOzr2rUrZs+eDQDYsmWLxvExQUlERERERERERFRHxcbG4urVq9DT08OwYcPU9nft2hXOzs5ITEzEhQsXXvj1WrZsqXxdTTFBSUREREREREREVEddv34dAODj4wNDQ8Nyy/j7+6uUfREPHz4EADg6Omp8DBfJISIiIiIiIiKiukkOQPZqr5ITGRkJAHB3d6+wjJubm0rZ55Wfn4/ffvsNADBkyBCNj+MISiIiIiIiIiIiojoqNzcXAGBsbFxhGRMTEwBATk7OC73W5MmTERkZiSZNmmD8+PEaH8cRlERERERERERERLVUSkoK/Pz8lL+PHz++SsnBl2XBggXYuHEjzM3N8ddff0FfX1/jY5mgJCIiIiIiIiIiqqVsbW1x5cqVCveXjY7My8ursEzZKEtTU9PniuGnn37CV199BRMTExw+fBg+Pj5VOp4JSiIiIiIiIiIiqrte7Sko4eHhAQCIioqqsExMTIxK2apYsmQJPv74YxgaGuLAgQNo3759levgHJRERERERERERER1VMuWLQEAd+/eRUFBQbllLl++rFJWU8uWLcMHH3wAAwMD7Nu3D127dn2uGJmgJCIiIiIiIiIiqqNcXV3RqlUrFBcXY8eOHWr7T506hdjYWDg4OFRp9OPKlSsxdepU6OvrY8+ePejZs+dzx8gEJRERERERERERUR02Z84cAMCsWbMQHh6u3J6cnIzJkycDAGbPng2x+GmqcOnSpfD29saoUaPU6lu9ejUmT54MfX197N69G717936h+DgHJRERERERERERUR02dOhQTJo0CStWrICvry969uwJiUSCoKAgZGdnY+DAgZg6darKMampqQgLC4ODg4PK9hs3bmDChAmQy+Xw9PTEn3/+iT///FPtNW1sbLB48WKN4mOCkoiIiIiIiIiI6izRK75ITpnly5ejU6dOWLZsGU6dOoXS0lJ4e3sjMDAQkyZNUhk9+SyZmZmQyxV/1NDQUISGhpZbzt3dnQlKIiIiIiIiIiIiemrEiBEYMWKERmXnzZuHefPmqW0PCAhQJihfFs5BSURERERERERERIJhgpKIiIiIiIiIiIgEw0e8iYiIiIiIiIio7nrJjyPTy8cRlERERERERERERCQYJiiJiIiIiIiIiIhIMExQEhERERERERERkWA4ByUREREREREREdVZIk5BqfU4gpKIiIiIiIiIiIgEwwQlERERERERERERCYYJSiIiIiIiIiIiIhIME5REREREREREREQkGC6SQ0REREREREREdZP8yQ9pNY6gJCIiIiIiIiIiIsEwQUlERERERERERESCYYKSiIiIiIiIiIiIBMM5KImIiIiIiIiIqE4SARDJOQmltuMISiIiIiIiIiIiIhIME5REREREREREREQkGCYoiYiIiIiIiIiISDBMUBIREREREREREZFguEgOERERERERERHVXTKhA6DKcAQlERERERERERERCYYJSiIiIiIiIiIiIhIME5REREREREREREQkGM5BSUREREREREREdZZILhc6BKoER1ASERERERERERGRYJigJCIiIiIiIiIiIsEwQUlERERERERERESCYYKSiIiIiIiIiIiIBMNFcoiIiIiIiIiIqG6SP/khrcYRlERERERERERERCQYjqAk7SISCR0B1SJiE2OhQ6BaRqSvJ3QIVAtJE5OEDoFqmcz32gsdAtVCG3tZCh0C1TIPFhgIHQLVMoVf8vs2aS+OoCQiIiIiIiIiIiLBcAQlERERERERERHVUXJAzkkotR1HUBIREREREREREZFgmKAkIiIiIiIiIiIiwTBBSURERERERERERIJhgpKIiIiIiIiIiIgEw0VyiIiIiIiIiIiozhJxjRytxxGUREREREREREREJBgmKImIiIiIiIiIiEgwTFASERERERERERGRYDgHJRERERERERER1V1yTkKp7TiCkoiIiIiIiIiIiATDBCUREREREREREREJhglKIiIiIiIiIiIiEgznoCQiIiIiIiIiorpJDohkQgdBleEISiIiIiIiIiIiIhIME5REREREREREREQkGCYoiYiIiIiIiIiISDBMUBIREREREREREZFguEgOERERERERERHVXXK50BFQJTiCkoiIiIiIiIiIiATDBCUREREREREREREJhglKIiIiIiIiIiIiEgznoCQiIiIiIiIiorqLU1BqPY6gJCIiIiIiIiIiIsEwQUlERERERERERESCYYKSiIiIiIiIiIiIBMMEJREREREREREREQmGi+QQEREREREREVGdJZJzlRxtxxGUREREREREREREJBgmKImIiIiIiIiIiEgwTFASERERERERERGRYDgHJRERERERERER1V2cg1LrcQQlERERERERERERCYYJSiIiIiIiIiIiIhIME5REREREREREREQkGCYoiYiIiIiIiIiISDBcJIeIiIiIiIiIiOomOQCZ0EFQZTiCkoiIiIiIiIiIiATDBCUREREREREREREJhglKIiIiIiIiIiIiEgznoCQiIiIiIiIiojpJBDlEcrnQYVAlOIKSiIiIiIiIiIiIBMMEJREREREREREREQmGCUoiIiIiIiIiIiISDOegJCIiIiIiIiKiuotzUGo9jqAkIiIiIiIiIiIiwTBBSURERERERERERIJhgpKIiIiIiIiIiIgEwwQlERERERERERERCYaL5BARERERERERUd1V1xfJEQkdwIvjCEoiIiIiIiIiIiISDBOUREREREREREREJBgmKImIiIiIiIiIiEgwnIOSiIiIiIiIiIjqJjkAmdBBVDMdoQN4cRxBSURERERERERERIJhgpKIiIiIiIiIiIgEwwQlERERERERERERCYYJSiIiIiIiIiIiIhIMF8khIiIiIiIiIqI6SySXCx0CVYIjKImIiIiIiIiIiEgwHEFJVA0C+iai7/A4eDbIhVgHiI00wrE9jjj4lzPkclGV62vdMQ2D3otGA58cSPRkSIwzxKnD9ti1wQ3SEvX7DD0HJOCjr+8/s86R3ToiI02/yrFQ9Qh4Iwl934qHZ8NciHXkiI140ma2Oz1fm+mUhkGjYtGg6ZM2E2uAU4fssWu9a/ltZmACPvom7Jl1juzaHhmpbDPaouvrCeg7LAae9Z+0mcfGOLbPCYd2uD5fm+mQioEjo9CgSZaynzl9xBG7NnmU22b+rUuvBPR8Mx71GmXD2ESK7Cw9RD8yxsnDjji+3/l53yJVg26DMtBvVBo8GxdArAPEhOvj6J9WOLDR+rnajV9ANgZPSEHDZgWQGMiQGKWPk3sssHOlLUqK1duNmZUU7XploVHzAjRong/PxoXQ05dj33prLPvc5WW8RXrJerV4iCHt7qK+YzrEIhmiUixx4Eoj7Lrgo3GbEYnkaOqWhA6NouFXPw4ethkw0pciO18foXE22H2xCU7f81Q7ztEyG3tmb9XoNSasHIAbkU5Vem9UPbq+Fou+g6LgWT8bYrEcsVEmOHbQFYd2ezzf+altMga+8wgNvLMg0StFYrwxTh9zwq6t9SAt0Sn3GD29Urz5VgQ6BiTA2S0XEj0ZsjP1EHbXEnv/8sSdGzYv+jbpJTMJSYd5UCr0YgogkgHFTvrI6WyNrB42gFjzdmP1dwKsdidWuF8mESFiXQvVjVI5DMNyYXQzC4ahudBLKIKoRI5SM10U1jdG1ms2KGhs+pzvjIg0xQQl0Us2+bMw9Hs7DkWFYty8aAmpVIQWbTMw+fMHaN42A99+3LRKF2dDx0Yh8MNHKJWKcOuKBXKzdeHrl4nR0yLQpksqPvu/ligqLP/iLD7aEHevm5e7r6io/GOo5k3+4gH6vROvaDMXLCCVitGiXQYmf/FQ0WY+1PxLIAAMDYxG4McRKJUCty5bIDdbomgz0yPRpmsaPnu/+TPajAHuXqugzVRwDNW8SbPvo9/wGEWbuWwFaYkYLdqkYfLsULRok45vZzavUpsZMjoSgdMfolQqwu2rlsjNlqBp63SMmhIO/84p+HyiX7mfv0SvFJ/9cBNtOqeiIF8H925aIDdLAmu7QjT0yYZIBCYotciUb2MxYEwaigpEuHHWRHF+6pSLqd/GoUWnXHz9f+5VajfDJidj3BcJir7mvAlyMnXQrH0exsxORJue2Zj9Vj0UFagmKX3a5OHjn2Jf9lujajLzzTMY2uEuCkt0cCXcGdJSMfzrx2HmwLPwqx+HOVt6adRmnK2ysWbyHgBAVp4+7sXaIadAH05W2ejgHYMO3jE4cKURFuwIAPC0vvwiCQ5caVhhvZ72GfBxTUFeoQShsbYv+G7pZZj08W30G/IYRUVi3Lxio7im8UvF5E/uoIVfKr793K9q56eR4Qiccl9xfrpujdwcCZq2TMOoCWHw75iMz6e1Q1GR6ldaI+MSLFoWAq+G2cjP08X921bIz9OFq0cuOgQkokNAIn7/xQf7/vJ62W+fnpPNhhhYBKVCJhGhwMcUch0RjO7mwHZTLAzv5SBxmmeVkpQAUORmiCI3Q7Xtcl31egxDc+C86BEAQGquiwJvE8j0xdCLK4TJ5UyYXM5E+kAHpA9xfL43SEQaYYKyBgUEBODUqVMIDg5GQEDAC9cnEik6VznnUtAaHXsmo9/bcUhP0cOnY1shPtoIAGBhVYzv1l5Dx54pGDAiFnv/cNWovgZNsjFm+iMUFogxZ1xLhN1WJI4MDKX437Jb8PXLxKhpEVj9Q4Nyj7973Rw/f9nk5bw5qhYdX0tBv3fiFW1mVIunbca6GN+tv4GOr6ViwMg47N2i2ciiBj7ZGPNhBArzxZgT2AJht80AAAZGUvxv+W34+mdh1PRIrF5Uv9zj714zx8+fN345b46qRYfuSeg3PAbpKXqYNc4f8THGAAALqyIsXHUFHbono//b0di3zV2j+uo3zsKYaQ9RWCDGZxP8EHbHAoCin5n323X4ts7AqCkPsfpHb7VjP/zfXbTpnIpTRxyw7JvGyMuVKPfpSmRwr5f74m+YXopOfTMxYEwa0pJ08cng+oiPVIyGtrApwfc7H6FT3yy8GZiKPWs1S/I0aJaPwM8SUJgvxqfDvBB2XdEODYxKsWBzpCJROSsBv89TTVBnpuhi/wZrPLxtiIe3jND5jUyMmJH8ct8svRTdmkZgaIe7SM02wsSVAxCTZgEAsDLJx/Lx+9GtaSSGd7iNP881q7QuuRy4HO6MLaea49JDF8jkTxPXLT3j8dPYQ+jnF4brkY44cOVpX5OVb4gFO7pXWO/PYw8CAI7drI/CEkmF5ahmdAiIR78hj5Geqo9ZkzsgPtYEAGBhWYSFS0PQISAR/YdFapwYrO+diTGT7qOwQAefTWuPsHuWAJ6cnxZfhG/LdIyaEIrVvzVVOW7ou+HwapiN8FBzfD69HXJz9JT7evWLxvTPbiJwyj2cPuaMzAw+GSI048uZsAhKhdRcF3FfNECJgwEAQCerBM7fhsPkShbMj6Ugq7ddlerNa22O9MEaJhRFIuT6WyCzty0KG5mo7DK5kAH7FY9htScRBY1NUNCEIylrLeZNtB7noCR6iYa/HwUAWPdLPWWiCQAy0/Ww9OtGAIBhgVEQiTTrHIe9HwWxGNixzl2ZnASAwgJd/PxlY5SWAv3eioWxaclLfBdUk4aPe9JmfvJSbTNpelg6XzFqZNi4aM3bzLjoJ23GTZmcBIDCfF38/IW3os28Hcc2U4sND4wEAKz/raEyOQkAmen6WPatIrk8bEyk5m1mbCTEYmDnBk9lchJQ9DO/zPNBaSnwxrAYGJuotplW7VPRtXciIsJMsfhzX5XkJABIS8R4FGoG0g5vTVMkAdd946hMTgJAZqoES2YrboAMn5qscbt5a2oyxGLgr2W2yuQkABTm6+DHD10Vfc3oNBiblaocd/+qMZZ+5oIj26wRcdcQpaVVf9yTasbobtcBAEsPt1UmJwEgPdcIi3Z3BgCMCrihUZuJSzfH1NX9ceGBm0pyEgCuRzph08mWAIDXWz7UOD5bs1y0bagYjbvvsvoNFKp5w98LBwCsX95YmZwEgMwMfSz7wRcAMOzdcM3PT++FK85PW+ork5PAk/PTNy0U56fBUWrnp2at0wAAf2+rp5KcBICjB9wQG2UMiUSO+t6ZVX6P9PJZ7lc8jp32tpMyOQkApeYSJI9xeVImCZBVX3KpwMcUiR94qiUnASC3nSWyO1sDAEzPpVdbDETEBGWN2rRpE+7fv482bdoIHQpVA2v7QjTwyUFJsQhnj6rf4btz1RKpSfqwsi2Gd7PsSuvT1ZXBr5PiAiv4oL3a/sQ4Q4TeNIdETw7/zmkv/gaoxlnbF6JB01xFmzmiPmrpzhULpCbqKdpMcw3ajEQGv06KC6fgA+W0mVhDhN40U7SZLrzAqo2s7QrRoEm2os0cV/+M71yzetrP+GZVWp+urgx+HVMBAMGH1UcZJMYZIfSWBSR6cvh1SlXZ1++taADA3m1ukMmYZNJmNo7FaNi8AMVFIpw+YKG2//YFE6TES2BtL0Xj1vmV1qcrkcG/ew4A4MTflmr7E6P1cf+qEfT05WjTo/K+i7SPnXkuGrukoFgqxolb9dT2X490QnKWMWzM8tHULemFX+9BvI3ydTX1Rusw6IjleJRoibsx6v0h1Sxr2wI0aJyFkmIxzp5Qnwv0zg0bpCYbwMqmCN4+GZXWp6srg187xY2V4KPqU4Ukxhsj9I4lJHoy+LVXbYPlzX9bnuxMvcoLUbXSSS+GQWQB5Loi5LZRP58UNjaF1FIC3SwpDMLzBIhQodhd8ai4bgZv8BNVJyYoa5Cbmxu8vb1hZGRUeWGqdep5Ky6qox4Zo7iC+R0f3DF9Ujan0vpcPPNhYChDdqYuEmPLbzMP7ipGJ3l5l39B7+RagFFTH2HaV6F4/+OHCOibCANDaaWvTTWjXuMnbSb8WW3GTKXss7h45MPA6EmbiVGfc+ff9VXYZtwKMOqDCEybF4b3PwlHwBtJMDBim9EW9bwVyZ6oRyYVt5m7itHWXt6VJ4acPfKe9DOSCvuZh/fMVF4bAMRiOZr7K5Lcd69bwtquEINHRWLKZ/fw/owwdOieBLGOTPM3RtWqXtMCAEDUAwMUF5Z/6ffgpqFK2WdxqVek6GvSdZAQVf7jkQ9uGGlcH2mfhk6KGxIRSVYokpY/I9S9GMWNtUZOqeXurwpXG8UNldRsza+R+/kpFnbj6EntUK+h4jOMijRBcXEF56f7FgAAr4aV30BzdsuFgWEpsrMkSIwzLrfMwyf11Wuoer67dlHRNge/8wgmpsUq+157Ixou7nkIDzPDw1CLSuOg6qX/WHGOKHI2gFyv/PNToZeiX9CPqtr5RP9xPqy3x8F2bTSs/4yD8ZVMQPp81yaSpCIAgNScU0kQVac6naAMCwvD6NGj4e7uDj09PZiamsLDwwODBg3Crl27VMrK5XJs3rwZAQEBsLS0hIGBAerVq4cpU6YgJiamwtfIy8vD4sWL0b59e1hYWMDQ0BBeXl4YNmwYDh06pFI2ICAAIpEIJ0+eVKunpKQES5cuRdu2bWFmZgZDQ0M0btwYs2fPRlpa1UfHpaamYtasWfD29oahoSHMzMzQrl07LF++HFJp+ckGuVyOVatWoWXLljA0NIStrS0GDx6M27dvY8OGDRCJRBgzZoyy/IIFCyASiTBx4sQK49i/fz9EItErMWrUwVlx0kyON6iwTEqiYp+9S+UnWPsn9aUkPKO+BH2V1/4vn1ZZeHt8FPoMjceQ0TH49Lt72Hg0BB1f43xf2sDBuRBAJW3myWdsX8Fn/G/2LoVPjtGgzVTQBn1aZePtCdHoMywBQ8bG4tPv72Pj8Qvo2IttRhvYOz3pZxLKT0ADT/sZB6fK20xZmbJjyq/PUOW1AcDBRXEDBQB8WmRg1e6zeH/GQ/QdGovBo6Lw+eKbWPbneTi6Vj4aj6qfg5viC3pybMVfrJLj9FTKalRfvAb1uVZeH2kfJ0vFjdTEDPXHHcskZSr2OVlVftP1WfQlJRje4TYAIPiOZnMTtvSMh6tNNoqlYhy+VvEiOlRz7J0U/X1yYsVJ5pQkxfnEwanyc0NZmbJjnlWf/X/q2/OnFy6ds0N97yys/zsI//vxAmbNv4plm09i2uybuBxih3kft32uFcXp5ZKkPEn82VQ8mlVqrdinm1K184nx9WxYHkyG+ck0WB5IhuOvkXD/+B4M7letz9LJLIHpGcVN2Vx/iyodS0RVU2cXybl9+zY6duyInJwceHt7o3///hCJRIiLi8ORI0dQUFCAIUOGAFAk5t59911s3boVEokEAQEBsLKywqVLl7B8+XJs374d//zzD/z9/VVeIyoqCr1790ZYWBhMTEzQqVMnmJubIyYmBocPH0ZKSgr69u1baayFhYXo06cPTp48CSMjI3Tr1g1GRkY4c+YMFi1ahO3bt+PEiRPw8tLsoi08PBzdu3dHTEwMHBwc0L9/f+Tn5yM4OBhTpkzB7t27ceDAAejrq456mDBhAlavXg1dXV107doVtra2uHLlCtq2bYvAwEC11xk/fjy+/vpr/PHHH/j+++9hZqY+19iyZcsAAFOmTNEo9trMwEgxz1ZhQcUrHRfkK/YZGpVWWKaMoSb1FZRfX3qqHrb97oELJ22QGKuY48vVKw9Dx0SjY88UzP7+DuZOaY5rIdaVxkHV52mbqfhekbLNGFelzVS9vvQUfWxb6Y4LwdZIjPlXmwmMQcfXUjF78T3MnaSLa+esKo2Dqk/ZZ/ysFdXL+gxN2kyV+q1/1Wdq/vQRp6lf3MOdq5ZY92tDxEcbwdUzD+M/CUOTFpmY9+s1THmrA6Qldfp+qNYzNFIkkwvzK/4cCvMU+zTqa4yrUJ9J5fWR9jHUV/wfLyiuOAmd/2Sfkf6LJaE/HXgGztY5iEiyxJ6Lmi3s198/FABw5p4HsvIrTmBRzTE0rML5SYMnM8qe+Hn2dbBuufWVFOtgwWx/jJ4QisEjHsGvfYpyX2qyAW5dtUF2Fh/v1gbiIsX5RK5f8flEZqDYJy7U7HxSYqeP1OGOyG9mhhI7fYikcujHFMBqdyIMQ3PhtDgCsXMboricFb7VlMphv/IxdPJLke9jgvxW5pUfQ1pKzkVyaoE6m6D8+eefkZOTg2+//RZz5sxR2Zebm4vbt28rf1+xYgW2bt0Ke3t7BAUFwcfHBwBQWlqKDz/8EEuWLMGwYcMQFhamTOrJZDIMGjQIYWFhePPNN7F+/XpYWj6dNyMnJweXLl3SKNavvvoKJ0+ehLe3N44fPw5nZ8U8KwUFBXjvvfewa9cujBw5EufPn9eovhEjRiAmJgbDhg3Dpk2bYGCgGBkTExODnj174vjx45g3bx4WLlyoPGbPnj1YvXo1LCwsEBQUhFatWinf56xZs7B48WK117G3t8fw4cOxZcsWbNq0CVOnTlXZHx4ejqNHj8La2hpvvfWWRrHTy3EtxFot+Rh2yxzffOSLcR8/xODRMRj3STgmD2aCkhSunbNSSz6G3TLHNzPMMW5mOAaPicW4meGYfK7uj4amyon/NegkNdEA8z5oBalU8QXi4T1zfDmlFVbvOQsXj3wE9EnA8X3q84cREQX2uIp+fg+QU6CHz/54DSWlFSejyhjrF6O7bwQAYP8VPt5N6iytC/HFwstw9cjF7z83xYUzDsjNkcDdKwejxofi/Wn30KptMr76qB3nUK6DcjqpXs/KARQ0MUVcE1M4/BYJk8uZsN4Rj4SP1efX/S/b9TEwupuLEmsJkiZ6VE/ARKRUZ4c0JCUpJkvu06eP2j4TExO0b99e+fuPP/4IQPHIcllyEgB0dHSwePFiuLm5ISoqCjt37lTu27dvH65fvw4PDw9s27ZNJTkJAKampujRo0elcRYUFGDFihUAgN9++02ZnAQAQ0NDrFy5EiYmJrhw4QLOnTtXaX1nzpzB5cuXYWpqipUrVyqTkwDg6uqKX3/9FYBiZGNhYaFy32+//QYA+Pjjj5XJSQAQi8X49ttv4eLiUu7rTZs2DQCU7+HfVqxYAblcjsDAQJU4/m3VqlXw8/ODn58fimWF5ZapLQqfjDIyMKz47l7Z6KeyEUnPUqBJfYaa11dm+yoPlEpF8KifB1uH2v03r+2etpmK58NRtpm8qrSZl1Nfme2/u6NUCng0yIetI9uMkMo+Y32DivuFsj5Dk8+4Sv3Wv+rL/1efE3TASZmcVNZboKtcdKeZHxdkElrBk5GOBkYV9w0GT0ZFatTX5FWhvlzN+xrSHgVFitGRhnoVLwhh9GRfftHzjUR7p/NNTOh1GXlFEsxY1xeRSZqN0H+teTgM9aRIyjTGhQeuz/Xa9PKVPdWj0fkpv/IxMoVPRkc++zpYWm59H315Hd5NM7H0+2Y4sMsTqcmGKCzQRdhdS8z9uC0ePzJFyzap6N6n4mm8qGbInoycFBVVfD4RFyr2yQxe/HySPtABAGB0JweQPns0nc3mWJifSoPUXBfxs+uj1ILzTxJVtzqboCyb83DixIk4duwYioqKyi0XGxuLiIgIiMVivPfee2r79fT0MHLkSABQmTvyn3/+AQCMHDkShobP/2jJ1atXkZubCycnJ7z22mtq+21sbNC/f3+116/IqVOnAAD9+/eHlZX6hd7rr78OR0dH5OTk4OrVqwAAqVSKkJAQAIrRl/8lkUgwdOjQcl+vTZs2aNOmDe7du6cSX0FBATZs2ACxWIxJkyZVGO/48eNx5coVXLlyBXriiudAqw2SnswjaOdUcQLHxl7RDpPiKm8zZWWelRCydShSeW1N5OZIkJmuOMFa25X//4JqhkZtpgqfcVKcooxGbSauCm0mW4LMdMUXULYZYSXHK/oFO8eK55csu/GQ9Ix5KsuUlXnWzQob+7K5Up/W9+9/J8aX/zplfZilNecgFFpSjOL/r51LxckmW6cSlbIa1ef0rPoUn3tSLB+jrI0SMhSL+jlYVrxAm52FYkXd+HTTKtc/rMNtzOh3HoXFuvh4fR/ciXbQ+Niyx7sPXm3EOQS1SHKCYu5JO4eK55e0tVOcu5ISKl8MqayMrX3F5zvl+elf5ztrmwK0apOqWE082FHtGKn06fYWfi++wBO9mBJbxdOJuqkVXyvopiv2SW1f/HxS7KR4PZFUDp3ciqcasN4aC4ujKZCa6iJuTn2UONTu76lEtUWdTVDOnDkTPXr0wMWLF9GrVy+Ym5ujXbt2mDVrlsrj3XFxcQAAR0fHCkf5lc39WFYWUMw/CQDe3i/2aElZnZ6enhWWKe/1X2Z9qampKCoqglgshqtr+Xei3d3dK6zvgw8+AAAsX75cuW379u1IT09Hnz59nhlLXfLovuIC3b1eHvT0y7/b27CpYpXBiNCKJ50vExtphMICMcwspHBwKf9ir6y+stfWhFgsh7Fp5fP6UPV7dF/RDtzrP6vNKCbyjtDgM1ZpM67lX9A39H3ONmPypM1UYbQuvXyPwhRz/brXy62wzTRoolgd9VGoJm3G+EmbKam4n/HJUnltQDFaJS5K8eXRzLz8JJWZhWI7+xnhPbqj+PLu3rAQegblj1Jp1ELx+YffqTyxHROuj8ICEcysSuHoXv5Ni0Ytn9R3m/MD1kZh8TYAAC/7dOjrlv8lvomLYvG0B/FVmy5maPs7+OTNcygs0cEnG1/H9UgnjY/1tEtHU7dkyGR8vFvbPHqgmJvP3TMXenoVnJ8aZ6qUfZbYKBMUFophZl4CB+e8css0bJyhVp+tg+L6p7BQB7LS8r/q5uUqbtSbmvEGmtCK3RXnCP24QoiKyz8/6UcozidF7i9+PtHJfdo2ZRXMe2m9LQ6Wh1NQaqKD+Nn1UeLM81idIIdiDsq6/FMH1NkEpZGREY4fP44LFy5g3rx56NKlC+7evYvvv/8ezZo1w/z581XKi0RVuwNb1fK1pb6KjhOLK24qw4YNg729Pfbs2YOEhAQAT5OVkydPfq44aqPUJAM8vGcKiZ4cncpZ8bhp6wzYOhQhPUUP929WfmEmlYpx9Zzior/bG0lq+x2cC+DdPAslxSJcPqP5l4M2XVJhYChDfq4OYiIrv4NN1Sc10QAP75oo2kzvFLX9Tf0yYev4pM3cUF+E6r+kJWJcPasYOd2tXzltxqUA3s2zFW3mtOaL3bTpmgYDI7YZbZCaZIDw+0/6mZ7qn3HTVunKfib0lkWl9UmlYlwNUSQiuvVJUNvv4JwP72aZT/oZG5V9ISfsAADN26SVW3fzNopHux/eq7ztUvVKidfDw1uG0NOXo0u/TLX9vu1yYetUgrQkXdy/Uvn/cWmJGFdOKD7X7oMz1PY7uBWhcet8FBeJcCmIn39tlJxlgtBYG+jpytC92SO1/S0942FvkYfUbCPcrsLox0Ft72LmwLMoKtHBp5tex+Xw8qcQqkjZ6MmrEc6IT2fb0iapyYYIDzWHRE+GTt3j1fY3bZEKW/tCpKfqI/SOZTk1qJJKxbh6XnGe6dZLfZCGg1MevJtmoKRYjMsh9srtaamKASemZiVwci1/BLB3U0W/pclITqpeUms9FHoYQiSVw+SS+vnE4H4OJOklkJrrorC+8Qu/nslFxWsUO+pDbqh+A9X6zzhYHkpGqbEO4mbV12whHSJ6aepsgrJM27ZtMXfuXBw9ehRpaWlYv349dHV1MW/ePISFhSnnfIyPj6/wMfCICMVE3P+eH9LNzQ0AEBYW9kLxldUZGRlZYZnyXr+y+sqO0aQ+a2tr6OnpQSaTISam/LlYHj9+XGF9enp6mDBhAkpKSrB69WpcunQJV65cgZeXF15//fVKY65L/lqrGGkaOOMRHF2fjkYytyrGlM8fAAB2rHNXeSSp39ux+H3vBXz8zb1y65PJgGGBUcrRkoBiZcMZ8+9DRwc48KcL8nKezomib1CKvsNjlasf/pt/51R8ME9xcX9guwtKpXW+C9B6f61R9CWBH0XA0e0/bebLJ21mjZtqmxkRi9/3X8TH394vtz5Fm4lWjpYEAAMjKWYsCFW0me3O6m3mrTgYlLOqpn+XNHzwP0U/d2CbM9uMFvhrnWJU+tgPHqj2M5ZFmDxH0SZ2bPBUbTNvRWPlrrP4aP5t/NeO9Z6QyYChYyKVoyUBRT8zfe5d6OgAB3e4KkeclNm7zR35eTpo2yUVPQeofnkcODIKvq0zUJCvg2NcIEcrbF+i+KIf+HkCnDyeXu+YW5dg2sJYAMBfS+1U2s2AsalYczoUM3+NVqvvz6V2kMmA4VNSlKMvAcXK8B/9FKPoazZaIy+bI2hrq40nWwIApva5CBfrp32DpXEBPh10BgCw6WQLlTYztP0d/PnxdswdfkKtvjfb3MOnA8+gqEQHszb3xsUqzh+pIy5Fn5YPAQD7LnP0pDb6a3N9AMDYyffh+K9Rj+aWRZj8ieL8s2NLfdXz05BIrNx2Ah99eV2tvh1bGijOT++GK0dLAk/OT5/dVJyf/nZXOT+lJBrhwX3FQIAZn92AhaXq97sefWLQ+UkC9dRxnp+0QUZ/RYLZens8JElPPy+drBLYbox9WuZfK/SZH0uB26f3YLfysUpduqnFMAlJB0r+MxpTLofp2XRY/6X47DNft1OLw2pHPCwPJKPUSAfxs+qj2IMJbKKaVmdX8S6Pnp4exowZg7Vr1+Ls2bO4desWhg0bBi8vL0RERGDLli14//33VY4pKSnBH3/8AQAICAhQbu/duzd+//13bNmyBZ9//nmFj4dXpnXr1jAxMUFcXByCgoLUFtZJS0vD/v371V6/Il27dgUA7N+/HxkZGWqL9xw5cgQJCQkwMTFB69atASjmmGzfvj1OnTqFbdu24bPPPlM5pqSkBLt27Xrm606cOBELFy7EqlWr8OCBIqkyadKkZ468rIvOHbPDgT+d0e+tOCzfdQk3LlpCWiJGi7bpMDYtRUiQDfZvUx0tYG5ZDFfPfGSkqs+r8vCuGTb8Wg+BHz7Cj5uu4uYlC+TlSNDULwOW1iUIvWWGTUu8VI7Rlcgw9YsH+L9PwvHovilSEvWhK5HD1SsPbl6KL5Hnjtti8/JX49F7bXfuqB0ObM9Ev7fjsXz3Fdy4YAlpiQgt2mUo2sxxG+zfqnoBbW5RAlevgvLbzB0zbPjZC4EfR+DHLddw86Il8nJ00dQvE5Y2JQi9aYpNv6p+9roSGaZ+9RD/9+kjPLpvgpSEsjaTD7d6T9rMMRtsXupRbX8H0ty5IAcc/CsdbwyPxbI/Q3DjkhVKpWI090+HsakUISfscOBPN5VjzCye9DNp+mr1Pbxnjg1LGiBw+kMsXn8JNy9bKdpM6wxYWhcj9LY5Ni1roHZcRqo+fvqqKWZ/dwsfzruLN9+JRny0EVy9cuFeLw/FRWL8+GVTZKSqvybVvLMHLbB/Qy76j0nDyqAwXD9rCmmJCC075cDYTIZzh82wb73qKFkzKylc6xchPVn9cvHBTSOs+9YR475IwM/7HuLGORPkZenAt30eLG2luH/VCBsWqc//BgC/7H+o/LeNo2IqgE5vZKFBs6dTUyz9zBnht/nlUEgnbtfDzvNxGNr+Hv748C9cfugCqUwM//pxMDEoxsk7HtgR0lTlGAvjAnjYZSItR3XUUQPHVMwedBpiMRCfaoqezcLRs1m42mtm5Rvit4Pt1bYDQKfG0bAyLUB2vh5O3uE1jDY6F+yEg3+n4o3BUVi25SRuXLZFqVSE5n6pMDaRIuSUAw7sVP3szCyK4eqeh4w09e9SD+9bYMOKxgicch+Lfz+Hm9esFdfBLdNgaVWM0DsW2PS7erL6129bYOHSEPg0z8Dqv07gwT0L5OZI4OaZAzdPxajKnVvq4e6Nqk1PQNUjr40lsnrkwjwoFa5z7qPAxxRyXREM7+ZAp0CG3NbmyHrNVuUYnRwp9BKKUGquevNUnCeFw4ooyNbHoMjDCFJLCcQFpdCLK4QkRfFIf+ZrNsjurnq+M7qWBat9iidTSuz1YX5U/ckmQDGHZWZ/zUeNE1HV1NkE5fLly9GjRw80atRIZXtERATu3r0L4Om8ih999BGmTp2KL7/8Eh07dlTOK1laWopPP/0U0dHRcHd3V1ko5s0330SLFi1w48YNjBw5EuvWrYO5+dPHdnNycnDp0qVKV/I2NDTExIkTsXjxYkyfPh3Hjh2Do6Pigr6wsBCTJk1Cbm4u2rVrh44dO1b6vjt37gx/f39cvnwZU6ZMwfr166Gvr/hyGBcXhxkzZgAApk6dqpJUnTZtGk6dOoXFixejb9++aNGiBQBAJpPhiy++QHS0+uiJf3N0dMSQIUOwfft2/PHHHzAwMEBgYGCl8dZFy79phHvXzdHvrTj4ts6EWEeOmEhjHNvtiIN/OVd5Qved690R+cAEg0dFo0HTHOjpyZAYa4h9W12xa4MbpCWqSeCiAh1s+90DDZtmw8UjH56NcqErkSErXYLzwTYI2ueAkCD1u4YknOULGuLeNXP0eycOvn6ZEIvliIk0UrSZ7U5VbzPr3BD5wBiDR8cq2oy+DImxBtj3hwt2rXdVbzOFOti20h0Nff/dZuSKNnPCGkF7HRBy3LaCVyMhLP+uCe7esES/4THwbZUBsY4csY+NcXSvMw7tcK1ym9m10ROPH5pi0LuP0dAnCxI9GRLjDLF/uxt2bfJQazNlzgfbY8a77TD8/Qj4tsqAq1cusjP1EHzIATs2eCIqvOqLZ1D1WfqZC+5eNkb/ManwbZcLHR3FfJJHtlvhwEbrKrebHcvtEHnPAEMmpqBh8wJFXxOth71rbbBzpS1KistvN41bq893amUnhZXd01HcRiYVr+hKNeeHPV1w87Ejhra/g1Ze8RCL5YhKtsD+K97YdcFH4zZjaliEsnvWnnaZ8LTLLLdcfLpJhQnK/n6KJ0CO3miAYmmd/QpT6y1f3Ax3b1qh35DH8G2ZBrFYjtgoExw94IpDuz2qfn76oz4eh5th0DuP0NA7CxL9UiTGGWH/Dk/s2loP0hL1UdqPH5lh8rsBGPR2BFq3S4Z30wzoSmTIztTDhTP2OPS3B65e5LWwNkkZ44qChsYwP54Kw9BcQKZIBqZ3sUZWDxuV0ZPPIrXSQ0ZfO+hH5kOSVAT9iDxADpSaS5DT1gLZ3WxQ4KN+bfLvBXMMIvNhEFn+vNwF3iZMUBJVI5FcXkdm0/yPFi1a4ObNm/Dy8kLTpk1hYmKCxMREnD17FsXFxXj77bexbds2AIBcLsfIkSOxbds26OnpISAgAFZWVrh06RIiIiJgaWmJI0eOwN/fX+U1IiMj0atXL4SHh8PU1BSdOnWCubk5YmJicOPGDfj5+amsbB0QEIBTp04hODhYZTRkYWEh+vTpg5MnT8LY2Bjdu3eHoaEhzpw5g4SEBLi5uSE4OFi5uE2Zsvki//sRhoeHo1u3boiNjYWjoyM6d+6M/Px8BAcHIy8vDz169MDBgweVicsy77//PtatWwddXV0EBATA1tYWV65cQUxMDMaOHYsVK1bg//7v/7Bq1apy/+bnz59Hhw4dAABjxozB+vXrNf/AAJhLbNHeckiVjqFXXCm/wFLViPS5ojBVnTRRfb5PomfJfK/8JBvRs9icqXxBTKJ/C13AUaBUNfFfLkNRxKvX15gbOqK9V90eQJVqeARXrlwROowXUmdvP3799dc4cOAALl68iJCQEGRnZ8Pe3h5du3bF//3f/2HIkKeJMJFIhD/++AN9+vTB6tWrcfHiRRQUFMDJyQmTJk3CnDlzyl3d2tPTE9euXcOSJUuwa9cunDlzBqWlpXBwcEC/fv0wduxYjWI1MDDA0aNHsXLlSmzevBnBwcEoKSmBh4cH3nvvPXz66aewttb85FO/fn1cv34d33//Pfbu3Yu9e/dCIpHAx8cHo0aNwvjx4yGRSNSOW716Nfz9/bFy5UqcOXMGxsbG6NSpE3bs2KF8zNzGxkbtuDJt2rSBmZkZsrOzMWXKFI3jJSIiIiIiIiKiV1edHUFJL1fPnj0RFBSEnTt3qiR3/23v3r0YOHAg2rRpg4sXL1b5NTiCkqqMIyipijiCkp4HR1BSVXEEJT0PjqCkquIISqoqjqCsu+rCCMpXawUTeqa7d+8iP191vo2SkhJ8/fXXCAoKgq2tLfr27VvusVKpFAsWLACgmNOTiIiIiIiIiIhIE3X2EW+quoULF2L37t1o1aoVnJ2dkZmZidu3byM+Ph76+vrYsGEDDA1VV2Vcv349Tp8+jUuXLuHevXto27Ythg8fLtA7ICIiIiIiIiJSJeLDw0pbt27FihUrcOvWLZSWlsLb2xtjx47FpEmTIBZrPo4xJiYGBw4cwJUrV3D58mXcu3cPpaWl+OGHH/DJJ59UOS4mKEnpnXfeQW5uLq5du4Zr165BKpXC0dERo0aNwieffAJfX1+1Y06dOoWNGzfC0tISw4cPxy+//KJcvIeIiIiIiIiIiLTDlClTsHz5chgYGKBHjx6QSCQICgrC1KlTldP6aZqk3LVrFz788MOXFhsTlKT0xhtv4I033qjSMRs2bMCGDRuqJyAiIiIiIiIiInphu3btwvLly+Hg4IDTp0+jQYMGAICkpCR069YNu3fvxpIlSzB9+nSN6vP09MT06dPRunVr+Pn5YeHChdi8efNzx8c5KImIiIiIiIiIiOqwhQsXAgAWLVqkTE4CgL29PVasWAEA+O677yCTabYY7ZtvvolffvkF7733Hho3blylx8PLwwQlERERERERERHVXXJ53f6pRGxsLK5evQo9PT0MGzZMbX/Xrl3h7OyMxMREXLhwoTo+gUoxQUlERERERERERFRHXb9+HQDg4+OjtvhxGX9/f5WyNY0JSiIiIiIiIiIiojoqMjISAODu7l5hGTc3N5WyNY2L5BAREREREREREdVSKSkp8PPzU/4+fvx4jB8/Xvl7bm4uAMDY2LjCOkxMTAAAOTk51RTlszFBSUREREREREREVEvZ2triypUrQofxQpigJCIiIiIiIiKiukkOQFb5QjJ1WdnoyLy8vArLlI2yNDU1rZGY/otzUBIREREREREREdVRHh4eAICoqKgKy8TExKiUrWlMUBIREREREREREdVRLVu2BADcvXsXBQUF5Za5fPmyStmaxgQlERERERERERFRHeXq6opWrVqhuLgYO3bsUNt/6tQpxMbGwsHBAe3btxcgQiYoiYiIiIiIiIiozpID8jr+o4E5c+YAAGbNmoXw8HDl9uTkZEyePBkAMHv2bIjFT1OFS5cuhbe3N0aNGvUSP4/ycZEcIiIiIiIiIiKiOmzo0KGYNGkSVqxYAV9fX/Ts2RMSiQRBQUHIzs7GwIEDMXXqVJVjUlNTERYWBgcHB7X6EhISMGjQIOXvjx49AgAsWbIEO3fuVG7fvXs3HB0dK42PCUoiIiIiIiIiIqI6bvny5ejUqROWLVuGU6dOobS0FN7e3ggMDMSkSZNURk9WpqioCBcvXlTbHh0djejoaJVymmCCkoiIiIiIiIiI6BUwYsQIjBgxQqOy8+bNw7x588rd5+HhAbmGj5drgnNQEhERERERERERkWA4gpKIiIiIiIiIiOqulzjSj6oHR1ASERERERERERGRYJigJCIiIiIiIiIiIsEwQUlERERERERERESC4RyURERERERERERUd3EOSq3HEZREREREREREREQkGCYoiYiIiIiIiIiISDBMUBIREREREREREZFgmKAkIiIiIiIiIiIiwXCRHCIiIiIiIiIiqpvkAGRcJEfbcQQlERERERERERERCYYJSiIiIiIiIiIiIhIME5REREREREREREQkGM5BSUREREREREREdZQckMuEDoIqwRGUREREREREREREJBgmKImIiIiIiIiIiEgwTFASERERERERERGRYDgHJRERERERERER1V1yudARUCU4gpKIiIiIiIiIiIgEwwQlERERERERERERCYYJSiIiIiIiIiIiIhIME5REREREREREREQkGC6SQ0REREREREREdZMcgIyL5Gg7jqAkIiIiIiIiIiIiwTBBSURERERERERERIJhgpKIiIiIiIiIiIgEwzkoiYiIiIiIiIio7pJzDkptxxGUREREREREREREJBgmKImIiIiIiIiIiEgwTFASERERERERERGRYJigJCIiIiIiIiIiIsFwkRwiIiIiIiIiIqq7uEiO1uMISiIiIiIiIiIiIhIME5REREREREREREQkGCYoiYiIiIiIiIiISDCcg5KIiIiIiIiIiOooOeegrAU4gpKIiIiIiIiIiIgEwwQlERERERERERERCYYJSiIiIiIiIiIiIhIME5REREREREREREQkGC6SQ0REREREREREdZMcgEwmdBRUCY6gJCIiIiIiIiIiIsFwBCVpDYm5HKluV4QOQyulpKTA1tZW6DCoFmGboapim3kGJ6ED0F5sNxW4Gyl0BFqLbaZiKVZCR6Cd2GYqZv2z0BFoL7ab8uVkFwkdAlGFmKAkrZGamip0CFrLz88PV64weUuaY5uhqmKboefBdkNVxTZDVcU2Q8+D7Yao9mGCkoiIiIiIiIiI6i65XOgIqBKcg5KIiIiIiIiIiIgEwwQlUS0wfvx4oUOgWoZthqqKbYaeB9sNVRXbDFUV2ww9D7YbotpHJJdznCsREREREREREdU95hI7dLAeKnQY1SrF5VKtn3eVc1ASEREREREREVHdxbF5Wo+PeBMREREREREREZFgmKAkIiIiIiIiIiIiwTBBSURERERERERERIJhgpKIiIiIiIgEl5GRIXQIREQkECYoiWqZtLQ0lJaWCh0GaYni4mIkJyejsLBQZXtubi6++OIL9O/fH9OmTUNMTIxAEZI2ateuHbZs2YLi4mKhQyGiV9TDhw+xa9euWr/iKL1cLi4uGDduHK5duyZ0KFRL8JqGNCMHZHX8pw5ggpJIy9y4cQPff/89QkNDVbYfPXoUrq6usLOzg62tLVavXi1QhKRNFixYAEdHR1y/fl25TSaToUuXLli4cCEOHjyIZcuWoX379khLSxMwUtImly5dwujRo+Hi4oI5c+YgKipK6JCoFgkPD8fMmTPRqVMnNGrUCJ9++qly38WLF7Fq1SpkZmYKFyBpjb///ht9+/bFxYsXVbZ//fXXaNy4MYYPH462bdvi3XffFShC0jalpaVYt24d/P390b59eyaeqFK8piGqO5igJNIyS5YswWeffQYzMzPltqSkJAwePBhxcXEQiUTIzMzEpEmTcPnyZQEjJW0QFBQEZ2dntG/fXrlt9+7duHHjBpo2bYo1a9Zg0KBBiI+Px8qVKwWMlLTJ3r178dprryEtLQ2LFi1C/fr18eabb+LIkSNCh0Zabu3atWjatCl+/PFHhISEIDw8HKmpqcr9+fn5mDRpEnbv3i1glKQttmzZgtOnT8PX11e57c6dO/jqq68gFovRsWNHWFhYYNu2bfj7778FjJS0RVxcHL799lu4ubnh4sWLTDxRpXhNQ1R3MEFJpGVCQkLQrFkzODk5Kbdt2rQJ+fn5mDFjBgoLC/H3339DJpNhyZIlAkZK2uDx48do1KiRyra9e/dCJBJhy5YtCAwMxI4dO+Do6MiEASn1798f//zzDx48eIAPP/wQ5ubm2L9/P/r27YuGDRvi559/5gg4UnPu3DlMmDABBgYG+OGHH3Dx4kXI5aqPFHXt2hXm5ubYt2+fQFGSNrl+/TqaN28OIyMj5bYtW7ZAJBJhzZo1OH36NC5fvgyJRMInQwgAYG1tjdmzZyMiIgJ79+5Fr169mHiiZ+I1DVHdwQQlkZZJTk6Gq6uryrbjx49DIpFg7ty50NXVxcCBA+Hn56f2yBS9etLT02Fvb6+yLSQkBO7u7soRK2KxGG3btkV0dLQQIZIWq1evHn788UfExsZi7dq1aNWqFcLDw/HJJ5/A2dmZ84CRiu+//x4ikQiHDx/Gxx9/DH9/f7UyYrEYLVu2xP379wWIkLRNWloanJ2dVbadOnUKJiYmGDFiBADAy8sLnTp1YpshFSKRCP3798fhw4fx8OFDfPTRRzAzM1Mmnho0aMDEE6ngNQ09kxyQy2V1+qcuYIKSSMvk5OTAxMREZdulS5fQqlUrmJubK7fVq1cPcXFxNR0eaRmJRIKsrCzl78nJyYiIiECnTp1UyhkZGSE3N7emw6NawsDAAGPHjsXly5dx8eJFjBgxAgUFBVi/fj38/f3RoUMH7Ny5U+gwSWDnz59HmzZtVKaUKI+DgwMSEhJqKCrSZkVFRSqjbIuLi3Hjxg20b98eurq6yu0ODg5ISkoSIkSqBby8vLB48WLEx8fj008/hVwuR0REBD755BO4uLhg6tSpSExMFDpM0hK8piGqvZigJNIylpaWKnPs3LhxA1lZWejYsaNKOZlMBolEUtPhkZZp2LAhzp07p1zFe9euXRCJRGoJyoSEBNjZ2QkRItUiSUlJOHLkCE6dOgUAkMvlMDU1xYULF/DWW2+hY8eOTCK8wrKysuDi4lJpudzcXEil0hqIiLSdo6Mj7t27p/z99OnTKCoqUrumyc3NVZl7m+jfZDIZ/v77b7zxxhv44YcfAAAWFhbo27cvpFIpli9fDh8fH87NTip4TUNU+zBBSaRlyh7dLnt8++eff4ZIJEL37t1Vyj18+BCOjo5ChEhaZNiwYcjMzESXLl3w0UcfYdasWdDT08PAgQOVZUpLS3Ht2jXUr19fuEBJq50+fRpvv/023N3dMXfuXCQlJeHtt99GSEgI0tPTsXv3brRs2RLnz5/Hhx9+KHS4JBA7OztERkZWWi4sLEztsV56NXXt2hWhoaH4/vvvcevWLXz55ZcQiUR4/fXXVcrduXNHo+Q3vVoSExMxf/58uLu7Y9iwYThx4gR8fHywcuVKxMbGYv/+/YiJicG0adOQkZGBmTNnCh0yaQFe0xDVXiL5f2c3JyJBHT16FK+//jpEIhEsLCyQkZGBevXqITQ0FDo6OgCA1NRUODo6YtiwYdi6davAEZOQioqK0LdvXwQHBwMAdHR08Msvv2DKlCnKMocPH8Ybb7yBefPm4auvvhIqVNIyubm52LRpE1asWIF79+5BLpfD3t4eEyZMwMSJE+Hg4KBSvrS0FM2bN0diYqLKqs306nj77bexc+dOXLhwAX5+fgAUc06OGTMG69atAwAcO3YMvXv3xrhx47Bq1SohwyUt8ODBA/j7+yunGJHL5ejZsyeOHj2qUsbb2xsTJ07E8uXLhQqVtMjJkyexfPly7N27F1KpFGKxGAMGDMC0adMQEBBQ7jHdu3fH5cuXkZOTU7PBklbgNQ1VxlzXFu0tBgkdRrVK9biGK1euCB3GC9GtvAgR1aRevXph3bp1mD9/PpKTkxEQEIDly5crk5MAsHnzZpSWllZ4kUavDn19fRw/fhxnz55FUlISWrVqBS8vL5UyBgYG+PnnnzFgwACBoiRtM3nyZPzxxx/Izc2FXC5HmzZt8MEHH2DYsGEVTh2ho6ODNm3aYOPGjTUcLWmLDz/8EDt27MDgwYOxZs0a9OzZU2X/6dOnERgYCF1dXUybNk2gKEmblE1D8tNPPyE5ORlt2rRRG+UWFBSE5s2bo1+/fgJFSdrEx8cHoaGhkMvlsLKywrhx4zBlyhS1BST/y8vLS/koL71aeE1DGpNxbJ624whKolqooKAAxcXFMDExUUlcEhFpQiwWQ09PD8OHD8e0adPKXY25PBs2bMCpU6ewfv36ao6QtNWPP/6ImTNnQiQSwczMDNnZ2TA3N4dEIkFqairkcjl++uknzJgxQ+hQiagWEovFaN68OaZNm4YRI0bAwMBAo+POnz+PBw8eYPTo0dUcIWkbXtOQJsx1bdHebKDQYVSrVK/rtX4EJROUREREr5ivv/4a48eP58JJ9FwOHz6MefPmqS1I4evriwULFnC0NhE9t7Nnz6ot9Ef0LLymIU0wQVk7cJEcolpCJpNhzZo1mDZtGhYvXsw5dggAsHTpUujo6ODAgQMVljlw4AB0dHTw+++/12BkpM2++OILXsjTc+vTpw8uXryIlJQUXLp0CefPn0dsbCxu3rzJ5CSpOH/+PAIDAxESElJhmXPnziEwMBCXLl2qwchIWzE5SVXFaxqiuoMjKIm0zHfffYf58+fj0KFDKnNM9unTB0ePHoVcLodIJELjxo1x8eJFGBsbCxcsCa5nz564e/cu4uPjIRKJyi0jk8ng5OSE5s2b48iRIzUcIRERvarGjh2L7du3IzY2FtbW1uWWSU1NhYuLC959912sWbOmhiMkIqJXgbmuLdqbvil0GNUqtd6NWj+CkovkEGmZI0eOwMzMDF27dlVuO3r0KI4cOQIXFxeMGTMGx44dw6VLl7Bu3TouRPCKCw0NRdOmTStMTgKKuXl8fX1x//79GoyMtF1paSn++usvBAUFIT4+HoWFheWWE4lECAoKquHoiKguOHfuHFq0aFFhchIAbGxs0LJlS5w9e7YGIyNt9d+F/iqip6cHGxsb+Pn5YdSoUWjVqlU1R0baKjAwUKNyZW2mdevW6Nu3L/T19as5MiKqKiYoibRMeHg4mjRpopJw2rVrF0QiEbZv344OHTpgzpw5cHV1xdatW5mgfMWlpKRotJq7nZ0dzpw5U/0BUa2QkZGBXr164dq1a6jsQYpnJb/p1XT+/HmNEttr166t4chI28THx2uUOHJ3d8fdu3drICLSdo8fPwag6EMqOj+V7Xvw4AFCQkKwdOlSfPHFF5g3b17NBUpaY8OGDQCeXq/8t938d7tIJIKdnR02bNiA3r1711ygRFQpJiiJtExqaiq6dOmisu3s2bNwcHBAhw4dAACGhobo0KGD2gIF9OqxsLBAdHR0peViY2NhYmJSAxFRbfD555/j6tWrcHV1xdSpU+Ht7Q0zMzOhwyItV1RUhLfeegv79+8HoP4l8N+YoCQA0NHRqTCJ/W+FhYWQyWQ1EBFpu8jISCxbtgw///wzhgwZghEjRsDd3R1isRiPHz/G1q1bsXPnTkyfPh2DBg3CiRMn8N1332HBggVo27Yt+vTpI/RboBq2fv16XLlyBcuWLYOLiwuGDh2q0mZ27dqF6OhoTJ48GY6OjggODsaJEycwaNAgXL58GT4+PkK/BSJ6gglKIi0jFouRl5en/D0rKwuhoaEYMmSISjlzc3NkZmbWcHSkbVq1aoWgoCA8fPgQDRo0KLfMw4cPcf78eZVpA+jVtm/fPlhaWuLixYtwcHAQOhyqJebNm4d9+/bBxMQE7733HhPbVKl69erh3LlzKCoqqvBxyqKiIpw7d07jR3upbrt58yZ+/PFH/P3333jzTdX54nx9fdG/f3+88847GDRoEDp16oQvv/wSrVu3Rr9+/bBixQomKF9BrVu3xpQpUzBz5kx888030NVVTXEsWrQIn3/+OZYuXYoLFy7g888/x9dff42vvvoKP/74I9atWydQ5ET0X1wkh0jLNG3aFGlpaYiLi4NYLMYff/yB9957D7/88gs++OADZbnXX38dd+/eRUxMjIDRktD++usvvP322/D29sbff/8Nb29vlf1hYWEYPHgwQkNDsXnzZowYMUKgSEmbGBgYoHfv3ti7d6/QoVAt4uXlhZSUFFy5cgWNGjUSOhyqBb766it8/fXXmDx5MpYuXVpumWnTpmH58uWYPXs2vvnmmxqOkLRN586dIZPJcO7cuWeW69ixI0QikXLuUh8fH6SnpyMhIaEmwiQtMmTIENy5cwdhYWEVlpHL5fD29oaPjw/+/vtvSKVSeHh4QE9PDxERETUYLQnFXMcG7U0GCB1GtUptcKvWL5IjFjoAIlI1YMAAJCUlYdCgQfjtt98wc+ZM6OjoqNxFlsvluH79Ojw9PQWMlLTB8OHD0b9/f4SGhsLX1xddunTB+PHjMX78eHTt2hVNmzbF/fv30bdvXyYnScnJyUlthAFRZeLj49GpUycmJ0ljM2bMgIODA1asWIHOnTtj3bp1CAkJQUhICNavX4/OnTtj+fLlsLOzw4cffih0uKQFbt26pdH1raenJ27fvq38vVGjRkhPT6/O0EhLnTlzBn5+fs8sIxKJ4Ofnp5yPXVdXF76+vkxoE2kZfjsh0jKzZs3C3r17sX//fuU8X7NmzYK7u7uyzNmzZ5GSkoL3339fqDBJi+zcuRMzZ87EypUrcfbsWZWVUCUSCSZPnowffvhBwAhJ2wwZMgQbNmxAQUEBDA0NhQ6HaglbW1s+0k1VYmVlhYMHD2LAgAE4d+4cQkJCVPbL5XI4OTlh7969sLGxEShK0jbPGglXURmRSAQjI6PqCom0WG5uLlJSUiotl5KSojKNloWFBW/WEmkZ/o8k0jLm5ua4cuUKdu7ciaSkJPj7+6vNHZiWlobp06fj7bffFihK0iYSiQS//PILPv/8c5w4cQJRUVEQiURwc3ND9+7dYWtrK3SIpGXmzp2Lo0eP4q233sKaNWtgZ2cndEhUC/Tt2xeHDh2CVCrllzrSWMuWLREaGorVq1fjyJEjKueo3r17Y9y4cVzEjZT8/f0RHByMjRs3YvTo0eWW2bRpE65evYoePXoot0VFRcHe3r6mwiQt0qhRI5w6dQo3b95E8+bNyy1z8+ZNnDx5Ek2bNlVui4uLg7W1dU2FSUQa4ByUREREdVxgYKDatszMTOzZswempqZo3bo13NzcIBarz/zC1ZipTHJyMlq3bo033ngDv/76a4WLnhARPa+TJ0+iZ8+ekMvl6NmzJ9555x24u7tDJBIhKioK27Ztw7FjxyASiXD8+HEEBAQgOTkZTk5OGDNmDNasWSP0W6AatmrVKkycOBGWlpb45JNP8M4778DV1RUikQgxMTHYtm0bFi9ejIyMDKxYsQLjx49HQUEBbG1t0atXL/z9999CvwWqAeY6Nmhv3F/oMKpVasPbtX4OSiYoibRccXEx0tLSoK+vDysrK6HDIaJaqLzEo6ZEIhFKS0tfYjRUW82fPx/R0dFYv349XF1d0b1792cmtr/88ksBoiSi2m7Lli2YNGkS8vLyIBKJVPbJ5XIYGhpixYoVGDVqFAAgJiYGR48eRYcOHdC4cWMhQiaBjR8/HmvWrFG2l7LzkkwmA6BoN++//z5Wr14NALh37x4WLlyIESNGcOX3VwQTlLUDE5REWmrTpk1YsmQJbty4AZlMhtGjR2PdunUAgN27d2PHjh345ptvuFDOKyY6OhoA4OzsDB0dHeXvmnJzc6uOsEjLbdy48YWOr+gxO3q1iMViiEQiPOvSsWw/E9tE9CLi4+OxZs0anD59GnFxcQAUC7x16dIF77//PlxcXASOkLTNnj178Ntvv+H8+fMoKioCAOjp6aF9+/aYNm0aBg8eLHCEJCQmKGsHTiBEpIXGjBmDzZs3Qy6Xw8TEBLm5uSr7GzVqhO3bt6Nly5aYOXOmQFGSEDw8PCAWi3Hv3j00bNgQHh4eaqMLKiISiSCVSqs5QtJGTDDSyzB37lyhQyAt1717d4hEImzcuBEuLi7o3r27xseKRCIEBQVVY3RUmzg5OeGrr74SOgyqRQYOHIiBAweitLQUqampAABra2vOmUxUi/B/K5GW2bhxIzZt2oQWLVpgzZo1aNmyJXR0dFTKNGnSBK6urjh8+DATlK8YNzc3iEQiSCQSld+JiKobE5RUmZMnT0IkEiE/P1/5u6Z4LiOil0FHR4cLJhHVUkxQEmmZ1atXw9TUFPv374ezs3OF5Xx9fXHv3r0ajIy0wePHj5/5O1FVFRcX4+rVq4iNjQWgmD6gdevWXACFiKosODgYwNPpRMp+J3oe58+fx8mTJ5WPeDs7OyMgIADt27cXODLSVmXXNP9uM61bt4aenp7AkZE2kD+Zk5S0FxOURFrm9u3baNeu3TOTkwBgYWGBxMTEGoqKiOqawsJCzJs3DytXrkROTo7KPhMTE0yYMAH/+9//YGhoKFCERFTbdO3a9Zm/E2ni8ePHGDlyJC5cuAAAynlvy0bZtm/fHlu2bIGHh4dQIZKWKSkpwbx587Bs2bJyr2mmTZuGuXPnKp9AIiLtxAQlkZYpKSmBiYlJpeWSk5N5kiWi51JQUICePXviwoULkMvlcHZ2Vn7Re/z4MeLi4vDjjz/izJkzOHHiBJOUr6hNmzYBAAYNGgRTU1Pl75oqW2GXXl3R0dEwMTGBlZXVM8tlZGQgJyeHC7kR0tPT0a1bN0RFRcHExAT9+/eHl5cXACAiIgL79+9HSEgIunfvjqtXr8LS0lLgiElopaWl6NevH44fPw65XA5HR0eVNpOQkICFCxfi8uXLOHTokNrUWUSkPZigJNIybm5uuHPnzjPLlJaW4u7du6hXr14NRUW1QWlpKdLS0lBYWFhhGX75IwD49ttvcf78efj6+uLXX39FQECAyv5Tp05h+vTpuHTpEhYuXIj58+cLEygJasyYMRCJRGjXrh1MTU2Vv2uKCUry9PTEmDFjsHbt2meW+/TTT7F+/Xou5Eb44YcfEBUVhaFDh2LFihWwtrZW2Z+eno6JEydi586d+OGHH/Dtt98KFClpi1WrVuHYsWNo2LAhfv31V/Tu3Vtl/5EjRzBjxgwcP34cq1evxsSJEwWKlIgqwwQlkZbp3bs3li5dii1btuDdd98tt8zvv/+OhIQEBAYG1nB0pI3Onj2L//3vfzh79iyKi4srLMdVvKnMtm3bYGZmhuPHj8PW1lZtf9euXXHs2DE0aNAAW7duZYLyFTVq1CiIRCKYm5ur/E6kKblcrnw8V5OyRHv37oWjoyM2b95c7lzIVlZW2Lx5M86dO4c9e/YwQUnYtGkTjI2NERQUVO4UWb1798bx48fh7e2NjRs3MkH5ypIDPM9oPSYoibTMzJkzsXHjRgQGBuLevXsYOnQoAMV8cffv38eOHTvw7bffwtraGtOmTRM4WhLa0aNH0a9fP2Xi0draWqMpAujVFhcXh9dff73c5GQZW1tbdOvWDf/8808NRkbaZMOGDc/8nehlyczM5MJcBEAxzciAAQOe2R709fXRuXNn7Nu3rwYjI2117949dOvW7Znz9zs7O6Nbt244depUDUZGRFXFBCWRlnFxccHu3bsxZMgQLFq0CIsWLYJIJMKff/6JP//8E3K5HGZmZti5cyfs7OyEDpcE9uWXX0IqleKTTz7BnDlzOBcTacTGxga6upVfAujq6sLGxqYGIiKiuiI6Olrl99zcXLVtZaRSKe7fv4+jR4/C09OzJsIjLSeRSJCfn19puYKCAs7FTgAU8/cbGRlVWs7IyAglJSU1EBERPS8mKIm0ULdu3XDv3j38/PPPOHz4MCIiIlBaWgpXV1f06dMHM2fOhIuLi9Bhkha4ffs2Wrduje+//17oUKgW6devH3bu3ImcnByYmpqWWyY7OxsnT57E4MGDazg6IqrNPDw8VKYC2LVrF3bt2vXMY+RyOUaOHFndoVEt0LhxYwQHByMxMREODg7llklMTMSJEyfg4+NTw9GRNnJ3d8eZM2dQXFwMPT29cssUFxfjzJkzcHd3r+HoiKgqxEIHQETlc3BwwKJFi3Dr1i3k5uaioKAADx48wK+//srkJCmZmZmhQYMGQodBtczXX38Nc3Nz9OvXD/fu3VPbf//+fQwYMAAWFhac34uUtm7dCi8vLxw5cqTCMv/88w+8vLywY8eOGoyMtImbm5vyRyQSwcjISGXbv3/q16+Prl274tdff8WcOXOEDp20wLvvvou8vDz07NkTJ06cUNsfHByMXr16IT8/H++9954AEZK2GTBgABISEjB69GhkZmaq7c/KykJgYCASExPx5ptv1nyApB3kAGTyuv1TB4jknJGaiKjWGj58OEJDQ3Hr1i2hQ6FaJDAwEBkZGdi7dy/EYjGaNWumfLzy8ePHuHnzJuRyOQYMGKA2bYBIJKp0RV6qm/r374+QkBAkJCRUOEqlqKgIjo6O6NKlC/bs2VOzAZLWEYvFGDNmDNatWyd0KFRLSKVSvPbaazh16hREIhGcnJzg6ekJkUiEyMhIxMXFQS6Xo1u3bjh69Ch0dHSEDpkElpaWhpYtWyIuLg6mpqbo37+/ss1ERERg//79yMnJgYuLC65fvw4rKyuhQyYBmIut0U6/r9BhVKs0n/u4cuWK0GG8ECYoiYhqsbt376J9+/aYP38+ZsyYIXQ4VEuIxWKIRKLnWjVXJBKhtLS0GqIibefu7g4vLy8EBwc/s1y3bt3w+PFjREZG1lBkpK02btyI+vXro2PHjkKHQrVIUVERvvzyS6xcuRK5ubkq+0xMTDBx4kQsWLCACyuRUnh4OEaMGKFMzpRNM1F2nePv74+tW7eiXr16gsVIwmKCsnZggpJIC2VnZ2PZsmUICgpCfHw8CgsLyy0nEonw6NGjGo6OtM2FCxfwzjvvwNnZGa+//jpcXFwgFpc/g8eoUaNqODrSRhs3bnyh40ePHv2SIqHaxMDAAEOGDMEff/zxzHIjR47E7t27NVrogoioIoWFhbh69Sri4uIAKFZibt26NQwMDASOjLTV2bNncerUKZU207VrV3Tq1EngyEhoTFDWDlwkh0jLxMTEoHPnzoiJial0dNO/J6GnV9eZM2eQlpaG6OhonD9//pllmaAkgAlGej7GxsZITk6utFxKSgpHNhHRCzMwMODoW6qSTp06MRlJVIsxQUmkZT777DNER0ejVatWmDVrFry9vWFmZiZ0WKSlfv/9d8yaNQsA0Lx5c9SvXx8mJiYCR0VEdVGzZs1w7tw5JCUlwd7evtwyiYmJOHv2LFq3bl3D0ZE28PLygkgkwvHjx+Hp6QkvLy+Nj+VTIUREVK3kMqEjoEowQUmkZY4ePQoHBwcEBwfD1NRU6HBIy/3666+QSCTYu3cvXn/9daHDIaI67J133sGpU6cwdOhQ7N27V22hgfT0dAwfPhxFRUV45513BIqShPT48WOIRCKUlJQof9cUnwp5NZ0+ffqFju/SpctLioSIiITGOSiJtIyhoSH69u2LXbt2CR0K1QJGRkbo2LEjjh07JnQoVAvFx8dj7969ePDgAbKzs8udVoKrdlMZqVSKLl264MKFCzAzM8OAAQPg7e0NAAgLC8PevXuRnZ2NNm3a4MyZM5BIJAJHTDUtKioKgGLeN11dXeXvmnJ3d6+OsEiLlS3a9jxEIhGkUulLjoi03Yus3M428+oyF1ujnV7dHsyR1jSMc1AS0cvl4eGhHHlAVBlbW1tYW1sLHQbVQr/88gtmz56t0t+UJSj/vfolE5RURldXF4cOHcKYMWOwb98+bNmyRW2l1P79+2PDhg1MTr6i/ptgZMKRKtOlSxeOnqUqeZHxVRybRaTdmKAk0jLvvvsuvv/+e6SlpTHxRJV688038ffff6O4uBh6enpCh0O1xJEjR/DRRx/BzMwMn3zyCU6ePInz58/j999/R3h4OHbt2oXIyEhMnz4dLVq0EDpc0iIWFhbYs2cPbt68iX/++QdRUVEQiURwc3ND79692V6IqEpOnjwpdAhUy8hknEeQqk4OQC5jglrb8RFvIi0jlUrRp08fZGdnY/369WjSpInQIZEWy8zMRPv27dG8eXMsX75cbU44ovK88cYb+Oeff3DhwgX4+/tj7Nix2LRpE0pLSwEAxcXFmDp1KrZv346rV6+iQYMGAkdMRERERPR8zMTWaKfbW+gwqlV6swe1/hFvJiiJtEz37t1RUlKCc+fOQSwWw83NDW5ubhCLxWplRSIRgoKCBIiStEVgYCAyMzOxd+9emJqaws/PDy4uLhW2Fz6qSwBgZ2cHT09PXLx4EQDUEpQAUFJSAk9PTwQEBGDLli1ChUpEtUhgYOBzH8tzFBERVRcmKGsHJiiJtEx5iaWKiEQilYQCvXrKJpfXpCtne6Ey+vr6GDx4MLZt2wYAmDBhAtasWYPs7GwYGxsry7311ls4e/Ys4uLihAqViGqRqlzD/BfPUfRvqampWL16NU6ePKk8Bzk7O6Nbt254//33YWtrK3CEpI3Onz+v1mYCAgLQvn17gSMjoTFBWTtwDkoiLRMcHCx0CFSLrF+/XugQqBaysbFBdna28veyqQEeP34Mn/9v787Dcsz3P4C/75KSUrakUgmRxpJCKWUblSVhbNXIcIx+1jkOgzHE5JgztjN2MzXDoTC2rGVNNUoxjSQVRhsJ2VKW1vv3h6vnzDOtHJ77qd6v6+q69L0/d73vR5cen/t7f7+WlrLx169f4+nTpwrPR8pBVVUVgiAgKSkJ5ubmb7VzKndKrZ/4O4neh9DQUHh6eiI3N1fuBmxSUhLOnj2L1atXIzAwEK6urhKmJGWSnp4OT09PxMTEACi/6Z+dnR0CAwNhamoqVUQiqgHOoCQiIqpn7O3tkZubi8TERADAL7/8ggkTJmDx4sXw8/MDADx8+BAdOnSAgYEBkpOTpYxLEimbDZeSkgJzc/O3nh3HjQyI6G2lpKSgR48eeP36NWxtbfHZZ5/BzMwMAJCamort27cjJiYGjRo1QlxcHDp16iRxYpLakydPYG1tjYyMDGhpaWH48OFyPzPHjh1Dfn4+TE1NERcXh6ZNm0qcmKTQRGgG2waDpY7xQT3p9gdnUBIREVHtMnDgQPzzn/9EZmYmjI2NMXToUDRt2hQrV67EzZs3YWRkhIMHDyI/Px/u7u5SxyWJ/LXByIYjEX1o//rXv/D69WusXr0a//jHP+SODRw4EFOnTsW6deswb948fPfdd5y1S1i9ejUyMjLwySefYOvWrWjevLnc8SdPnsDHxwcHDhzA6tWrsXLlSomSElF1OIOSiKiOKCwsRFxcnNy6O9bW1mjYsKHEyUjZJCcnY926dZg4cSL69u0LADhy5Ag8PDzw6tUrWZ2VlRUiIyPl1qUkInpX2dnZcr+jWrduLXEiUjbGxsbQ1dVFQkJClXVdu3bFs2fPkJmZqaBkpKw6d+6M3NxcpKamQl1dvcKagoICmJmZQUdHB0lJSQpOSMqAMyhrB86gJJLY5MmTIQgCVq5ciVatWr3VDpjc8ZKAN7stL1u2DJs3b0ZeXp7cMS0tLcyaNQu+vr5QU1OTKCEpGwsLC/j7+8uNjRgxAjdv3sTx48fx5MkTdOrUCW5ubm+17iARUUX8/f2xZs0a/PHHH3LjHTp0wLx58/C3v/1NomSkbB48eABHR8dq67p06YKDBw8qIBEpu/T0dLi5uVXanATebA7Yt29fHD16VIHJiOhtcQYlkcTKdmFOTk5+6zW+uOMllZSUYMiQITh79ixEUUTr1q3l1t3Jzs6GIAgYNGgQQkJC2GwiAMDz588hCAK0tbWljkJEddykSZOwa9cuiKIIQRBgYGAAALh3755sbOLEiXxUlwAALVu2xEcffVTtppH9+/dHYmIicnJyFJSMlJWOjg6cnJyqbT6OGDEC4eHhyM3NVVAyUiZNhGborfKx1DE+qKdWtzmDkoj+N2VvyMsec+IbdHobP/74I86cOQNzc3OsX78ezs7OcsdPnTqFL774AmfPnoW/vz98fHwkSkrKRFdXFz179kRsbKzUUUiJld3seBeCIOD27dvvMQ3VRnv27MHOnTuhp6eH5cuXY9KkSbJZTgUFBdixYweWLVuGnTt3wtnZGePHj5c4MUnNxsYGZ8+eRVRUFOzt7SusiY6Oxq+//orBg+v245pUMxYWFjh//jzu378PfX39Cmvu37+PsLAwWFpaKjgdEb0NzqAkIqrF7OzskJiYiJSUFBgaGlZYk5WVhU6dOuGjjz7CxYsXFZyQlJGOjg6GDx+OwMBAqaOQEqtsRr8gCKjs7WPZMc7wJwAYMGAAoqOj8fvvv6Nz584V1iQlJcHKygr29vYICwtTcEJSNidOnMDw4cOhpaWFL774At7e3jAxMYEgCEhPT8fOnTvx/fffIz8/H8eOHcOQIUOkjkwS27RpE2bPno3OnTtjw4YNGDBggNzx8+fPY86cObh+/To2bNiAGTNmSJSUpMQZlLUDG5RERLVYTR9rcXNzQ0REBB9rIQCAra0tNDQ0EB4eLnUUUmIZGRnlxjZs2ID169fD3d0dn376KUxNTQG8WQMsMDAQwcHB+OKLLzBr1iyYmJgoODEpm2bNmqFXr144efJklXUuLi64dOkSnjx5oqBkpMwWLVqE7777DoIgAPjvzZLS0lIAgCiKWLhwIXdjJgBAcXExPv74Y0RERMiWkWjbti0EQUBaWhqysrIgiiL69++P06dPc7mjeooNytqBj3gT1SK3bt1CQkICTExMYGNjI3UcUgJFRUXQ1NSstk5TUxNFRUUKSES1wdSpUzFt2jTExcXB2tpa6jikpP7aYDx8+DC+//577N27F2PGjJE71q1bN4wYMQIHDhzAuHHjYG9vzwYl4eXLl2jWrFm1dc2aNcOrV68UkIhqg2+//RZ9+/bF2rVrER0djYKCAgBvNjqxt7fH3LlzOXOSZBo0aICTJ09iyZIl2LZtG7KyspCVlSU7rqWlBR8fH/j5+bE5SaTkOIOSSMkcOnQIAQEB8PX1Re/evWXjK1aswLJly2SP1U2YMIGPZxIsLCzw/PlzpKWloWHDhhXWFBYWom3btmjSpAmSk5MVnJCU1ezZsxEYGIgFCxZg5MiRMDExqXIHTCIHBweUlJRUu1SEnZ0dVFRUEBUVpaBkpKzatWsHQRBw69Yt2Wy4vxJFEebm5igtLeW6pVROSUkJHj9+DABo3rw5G0xUpdevXyMuLk7WoDQ0NIS1tTU0NDQkTkZSayI0Q29hoNQxPqinPdJq/QzKmm8XTEQKERgYiMjISHTp0kU2lpiYiKVLl0JFRQX29vbQ1dXFnj17cOjQIQmTkjJwc3NDdnY2vL298ezZs3LHc3NzMXnyZNy/fx8jRoxQfEBSSqqqqti8eTNyc3Px1VdfwcLCApqamlBVVS330aABH7agNxISEtCuXbtq68zMzJCYmKiARKTsnJ2dkZaWhvnz51e4JmlpaSkWLFiA1NRUuLi4SJCQlJ2qqir09PSgp6fH5iRVS0NDA/b29hg7dizGjh0Le3t7NieJahHOoCRSMm3btoWBgYHczJOFCxdi9erV2L59OyZOnIjU1FR07twZ/fv3R2hoqIRpSWqPHz+GlZUVsrKyoK2tjeHDh8vW3UlNTcWxY8eQl5cHIyMjXLlypUaP2lHdV9nmJ5UpW/eL6jcdHR106NCh2rvzNjY2uHXrFte8JWRmZqJ79+7Izc2FqakpPDw85H5H7dmzB2lpadDV1UV8fDzatGkjdWQiIqqDOIOyduC0CCIl8/jxY/Ts2VNuLCIiAlpaWvDw8ADwZnaKg4MDH9clNG/eHGFhYfDw8MBvv/2GoKAg2WN0Zfefevbsid27d7M5STJsONK76NWrF8LCwuDv74+pU6dWWBMQEIDff/8dgwYNUnA6UkbGxsYICQnB2LFjkZaWVm5TE1EU0aZNG+zbt4/NSZIpKSnBvn37cO7cOdy7dw+vX7+usE4QBJw7d07B6UhqkZGRAN78TtLQ0JB9XlOOjo4fIhYRvQecQUmkZNTV1eHm5ob9+/cDeLN+YNlOzX/eBdPLywsHDx7kovIkc+HCBURERMitu+Pk5AQHBweJkxFRXfDrr7+if//+EEUR/fr1g6enJ9q2bQvgzS7eQUFBOH/+PFRUVHDu3Dn+J5BkCgoKsH///gp/R40ZM4br35LM06dPMXjwYPz++++o7r+pgiBUuHQA1W0qKioQBAHJyckwNzeXfV4TgiCguLj4AyckZeTi4oJHjx5JHeODatGihVy/oDbiDEoiJdO6dWskJSXJPo+MjERBQQHs7e3l6vLz89GkSRNFxyMl5uDgwGYkEX0wffv2xa5duzBt2jScP38e4eHhcsdFUUTjxo2xbds2NidJjrq6Ory8vODl5SV1FFJyixcvRlxcHNq0aYOZM2eiU6dOfL9LchwdHSEIAjQ1NeU+J6pKbW/c1RecQUmkZLy9vREYGIhvv/0WLi4umDZtGi5duoSYmBi5R7/bt28PHR0dxMXFSZiWiIjqm+zsbAQEBCAyMhJ3794F8N/ZcFOmTIGBgYHECYmotjIyMsKrV69w/fp16OvrSx2HiIgUiA1KIiVz8+ZN9OzZE/n5+QDezEgZNGgQTp8+LVfTqVMn+Pj4YMuWLVJFJSVz9+7dKtdqArjuDr1R051Q1dTU0KJFC9jY2GDSpElwd3f/sMGIqE4qLCzEwYMHER4eLtfU7tevH0aPHs1HvElGQ0MDzs7OOHLkiNRRiIhIwdigJFJCiYmJWLduHR4+fIhevXph/vz5aNSokez41q1b8eOPP+Kf//wnhgwZImFSUgaHDh3CokWL8Mcff1RZx3V3qMzb7uINvPn5mThxIrZv3/4BEhFRXRUdHQ0PDw/cuXOn3JqCgiDAyMgIQUFBXKKEALzZCNLKygoHDx6UOgoRESkYG5RERLXYsWPHMHLkSJSWlkJHRwdmZmZVrtV0/vx5BaYjZfbll19i27ZtmD59Ojw8PGBiYgIVFRWkp6dj9+7d2LJlC6ZOnYovvvgC58+fx/z585GTk4Ndu3bBw8ND6vgkodzcXAQGBuLixYvIycnBwIED8eWXXwJ4M8M/PT0dffv2lbuxRvXT9evX0bt3b7x8+RJmZmaYMGECTE1NAbzZWGnv3r24ffs2NDU1ERsbC0tLS2kDk+Tmz5+PHTt2IDMzk/+GUI2EhoZi9erVWLJkCfr3719hTVhYGFasWIFFixbh448/VnBCIqopNiiJiGoxOzs7XLp0CX5+fpg/fz7U1NSkjkS1wPbt2zFt2jRERkbC1ta2wprY2Fj07dsXW7duxZQpUxATE4M+ffqUW3KC6peTJ0/C09MTz549gyiKEAQB3t7e+PnnnwG8uWni7u6O3bt3Y9y4cRKnJamNHj0awcHBWLRoEfz8/MrN3i4tLcXSpUuxcuVKjBo1CgcOHJAoKSmL/Px82Nvbw8TEBAEBAdDT05M6Eim5sWPH4uTJk8jOzkbjxo0rrMnPz0fr1q3h5uaGoKAgBSckoppig5KIqBZr3LgxLCws8Ntvv0kdhWoRGxsb6Ojo4Ny5c1XWDRw4EM+ePZNtxmVtbY3MzEzk5OQoIiYpmcTERPTq1QvFxcWYNm0aHB0dMW7cOEyaNEnWoCwqKkKzZs0wfPhw7N69W+LEJLUWLVqgZcuWSE5OrrLOwsICOTk5ePTokYKSkbKYPHlyubFnz57h8OHD0NbWhrW1NYyNjStcmkQQBPz000+KiElKrF27djAwMMCvv/5aZV3fvn2RnZ1d7ZJIRCSdBlIHICJ5Nd28AuCagvRmE5OOHTtKHYNqmZSUFIwYMaLaOn19fcTGxso+NzMzQ2Ji4oeMRkps5cqVKCgoQHBwMNzc3ACg3CxJNTU1WFlZ4erVq1JEJCXz6tUr9OjRo9q6Hj16cFOUemrHjh2VHsvLy0N4eHilx9mgJADIzs5G7969q61r06YNrly5ooBERPSu2KAkUjJvM6mZE6DJ2toaqampUsegWkZdXR3x8fHV1sXHx8vtrltYWAhtbe0PmIyUWXh4OKysrGTNycoYGhqykU0AgI4dOyI7O7vauuzsbHTo0EEBiUjZcOM1+l+pq6sjNze32rrc3Ny3mghCRIrHBiWRkiktLa1wXBRFZGRk4MSJE/D19cWMGTOwfPlyBacjZbNw4UK4uLjgzJkzXPSbaszBwQHHjx/HN998g6VLl1ZYs2LFCiQnJ8s1o9LS0tC6dWtFxSQl8/jxYzg6OlZbV1hYiFevXikgESk7Hx8fTJ8+HVFRUbC3t6+wJioqCpGRkdi0aZOC05Ey8Pb2ljoC1XIWFha4cOECcnNzoaOjU2HN8+fPceHCBZibmys4HRG9DTYoiWoJQRBgamqKGTNmoFu3bujfvz8sLCwwfvx4qaORhDp27IjFixfDzc0Ns2fPxtChQytdqwkAjI2NFZyQlNE333yDM2fOYPny5dizZw/GjRsHExMTCIKAjIwM7Nu3DykpKdDQ0MCyZcsAAJmZmUhMTMT06dOlDU+Sadq0Ke7evVtt3e3bt9GqVSsFJCJl9/nnnyMlJQUuLi6YPn06PD090bZtWwBvdvEOCgrCli1bMGfOHPj4+Eiclohqo1GjRiEmJgaTJ0/G7t275Z78AN7cNJs8eTLy8/MxevRoiVISUU1wkxyiWqp3794QBAExMTFSRyEJqaioQBAE2W66VeGapfRnYWFh8PLywv3798v97IiiiFatWmHXrl0YNGgQACAnJwcJCQno1KkTDA0NpYhMEnNzc8OpU6eQmJgoexxXRUVFbpOcy5cvo3fv3pgwYQJ3SqX/6XFK/s6qn54+fYpr166hffv2MDAwqLAmKysLt2/fRteuXaGrq6vYgKR0Xr58iR49euDWrVswNTWFp6cnOnXqBAC4ceMGAgMDkZ6ejvbt2+P333+vdKdvIpIeG5REtdTYsWMRGhqKvLw8qaOQhExNTattTP5ZWlraB0xDtc2rV69w4MABREREICsrCwBgYGAAR0dHjBkzBpqamhInJGVy6tQpuLq6okuXLti3bx86duwo16BMTU3FiBEjkJSUhIiICDg4OEgdmSRW2Wz+mqps2Ruqu5YtWwY/Pz9cunQJ1tbWFdbExcWhV69eWL58Ob7++msFJyRllJmZCXd3d8THx1d407V79+44dOgQTE1NpQlIRDXCBiVRLWVpaYm7d+/WaFFoIiKi92HOnDnYuHEjBEGApaUlrl+/DkNDQ7Ru3RpXrlxBcXEx5s6dizVr1kgdlYhqoZ49e+L58+e4ceNGlXXm5uZo1qwZnyQiGVEUcfToUZw8eRIZGRkQBAHGxsZwdnbGiBEj3uqGPhFJgw1Kolrm8ePH8PX1xdatWzFw4ECcPn1a6khERFSPbNu2Dd988w3u378vN968eXMsWbIEs2fPligZEdV2LVu2hK2tLY4dO1Zl3fDhw3Hp0iU8ePBAQcmIiOhD4yY5RErGzMys0mP5+fl4/PgxRFFEw4YNZZtXEBG9i6KiIhw4cADh4eGyR7wNDQ3Rr18/fPLJJ1BTU5M4ISkjHx8ffP7554iPj0dqaipKSkrQpk0b9OrVCw0a8K0lEb27vLw8aGtrV1unra3Np4iIiOoYzqAkUjLVrdfUsGFD9O3bF9988w3s7OwUlIqU3aNHj+Dv71+u0dS/f39MmTIFLVu2lDghKZu4uDiMGTMGGRkZ+OtbAUEQYGpqiv3796NHjx4SJSQiovrG1NQUTZo0QUJCQpV13bp1w+PHj3H37l0FJSNlx5uuRLUfG5RESiYjI6PSYw0bNkTLli05Q4XkhIaGwtPTE7m5uRU2mnR1dREYGAhXV1eJEpKyuXv3Lrp3744nT57A2NgYnp6estnbqampCAoKQmZmJpo3b474+Hju2k1ERArh6emJvXv34tixYxgyZEiFNaGhoRg6dCjGjh2LvXv3KjghKSPedCWqG9igJCKqxVJSUtCjRw+8fv0atra2+Oyzz+QaTdu3b0dMTAwaNWqEuLg4dOrUSeLEpAxmzpyJLVu2YPbs2Vi9enW5WQXFxcWYP38+1q9fjxkzZmDjxo0SJSVldOfOHURERODevXt4/fp1hTWCIGDJkiUKTkZEtd2lS5dgZ2cHLS0trFmzBhMnToS6ujoAoKCgADt37sT8+fORl5eHX3/9FX369JE4MUmNN12J6g42KImIarFJkyZh586dWL16Nf7xj39UWLNu3TrMmzcP3t7e2L59u4ITkjJq3749AODWrVuV7mpZWloKc3NziKKI27dvKzIeKani4mLMnDkTAQEBshkqFc1UEUURgiCgpKREiphEVMt9++23WLx4MQRBgJqaGoyNjQG8uTlSWFgIURTxzTff4Ouvv5Y4KSkD3nQlqjvYoCRSUoWFhTh48CDCw8Nl6+uUraMyevRo2d1kqt+MjY2hq6tb7VpNXbt2xbNnz5CZmamgZKTMGjVqhJEjR2L37t1V1nl4eCA4OBivXr1SUDJSZl9//TVWrlyJBg0aYMiQIejQoQO0tLQqrff19VVgOiKqS4KDg7F8+fJy72+6du0KX19fjBw5UqJkpGx405Wo7uBCdkRKKDo6Gh4eHrhz50652Sk//fQTFi1ahKCgIDg4OEiUkJTFgwcP4OjoWG1dly5dcPDgQQUkotqgUaNGePLkSbV1T548QaNGjRSQiGqDXbt2oXHjxoiKikLXrl2ljkNEddjIkSMxcuRIPHjwABkZGRAEAcbGxmjVqpXU0UjJZGVlYeTIkZU2J4E3m5D26tULwcHBCkxGRG+LDUoiJXP9+nUMHjwYL1++hJmZGSZMmABTU1MAQHp6Ovbu3Yvbt2/DxcUFsbGxsLS0lDYwSapJkyaynQqrcu/ePWhraysgEdUGXbt2RXh4OFJSUipdl/TGjRsIDw+Hra2tgtORsnr48CEGDhzI5iQRKUyrVq3YlKQq8aYrUd2hInUAIpK3dOlSvHz5EosWLcLNmzfh5+eHKVOmYMqUKfDz88ONGzfw1Vdf4eXLl3x8jmBjY4MLFy4gKiqq0pro6Gj8+uuv6NmzpwKTkTKbMmUKCgsLMWDAAPz8888oLCyUHSsqKsL27dsxcOBAFBUVYerUqRImJWVibGzM5UWI6IMaP348Lly4IHUMqkX+fNO1MmU3XXmDjUi5cQ1KIiXTokULtGzZEsnJyVXWWVhYICcnB48ePVJQMlJGJ06cwPDhw6GlpYUvvvgC3t7eMDExgSAISE9Px86dO/H9998jPz8fx44dw5AhQ6SOTErC09MTe/bsgSAIUFFRQevWrSEIAu7du4fS0lKIoggPDw8EBgZKHZWUhK+vLzZv3oz09PQq154kInpXKioqEAQBH330EaZPnw4vLy80btxY6likxHbt2gVvb2/o6+tjxYoV8PLyQsOGDQG8uekaGBiIJUuWIDs7Gzt37oSnp6fEiYmoMmxQEimZxo0bw93dHUFBQVXWeXp64siRI8jPz1dQMlJWixYtwnfffSdbe0dF5c3k+NLSUgBvdtlduHAhVq5cKVlGUk5btmzB2rVrkZaWJjduZmaGuXPnYvr06RIlI2VUUFCAAQMGoEGDBvD394e5ubnUkYiojtm4cSO2bNmCGzduQBAEaGtrw9vbG//3f/9X6ZIkRLzpSlQ3sEFJpGR69OgBXV1dhIWFVVk3YMAAPH36FFeuXFFQMlJmISEhWLt2LaKjo1FQUAAAUFdXh729PebOncuZk1SlrKws2VqmhoaGMDQ0lDgRKasXL17Azs4OycnJMDExgZGRkeymyJ8JgoBz585JkJCI6oKwsDBs3rwZx44dQ3FxMQRBQP/+/TFjxgyMGDGiwn93qH7jTVei2o8NSiIl8+OPP2L69OmIiIiAvb19hTVRUVFwcnLCpk2b4OPjo+CEpMxKSkrw+PFjAEDz5s2hqqoqcSIiqisePXqEjz/+GAkJCaju7aMgCCgpKVFQMiKqq+7du4cffvgBAQEByM7OhiAIMDAwwLRp0zB16lRuoEPl8KYrUe3FBiWREpo7dy78/f0xffp0eHp6om3btgDe7OIdFBSELVu2YOrUqVi7dq3ESYmotsvNzcXly5eRk5MDExMT9OnTR+pIpKT+9re/4eeff0bHjh3h4+OD9u3bV7kWpZOTkwLTEVFdVlxcjODgYGzZsgUREREQBAFqamoYNWoU/v73v3MjQKrQrVu3kJCQABMTE9jY2Egdh4iqwQYlkcT+lxlugiCguLj4Paah2ubp06e4du0a2rdvDwMDgwprsrKycPv2bXTt2hW6urqKDUhKKzc3F3//+98RFBQk+3fE29sbP//8MwAgICAAS5cuxaFDh2BraytlVFISrVu3hoqKCpKSkqCjoyN1HCKqR4qKivDLL79g8+bNiI2NlTsmCALGjh2LgIAAbqhTDx06dAgBAQHw9fVF7969ZeMrVqzAsmXLZDP+J0yYwDUoiZQcF+8gkpgoiu/8UbYJCtVf69evR//+/ZGdnV1pzf3799G/f39s2rRJgclImb148QL9+vXDjh070LRpU7i6upZ7ZHfYsGF48OABDh8+LE1IUjp5eXno06cPm5NEpDDp6elYuHAhDA0N4e3tjdjYWNja2mL37t14+PAh/v3vf8PAwAD79u3DvHnzpI5LEggMDERkZCS6dOkiG0tMTMTSpUuhoqICe3t76OrqYs+ePTh06JCESYmoOmxQEkmstLT0f/qg+u3EiRNo3749rK2tK62xtrZGu3btcPz4cQUmI2W2Zs0aXL16FV5eXkhNTa3wZ0NfXx+dO3eudsMuqj8sLCyQl5cndQwiqgdCQkIwbNgwdOjQAatWrUJeXh4+/fRTXL58GdHR0Rg/fjxatGiBOXPm4Pr16zAxMUFwcLDUsUkCV65cQbdu3aCpqSkbCwwMhCAICAgIQGRkJC5fvgw1NTX4+/tLmJSIqsMGJRFRLZaeng5zc/Nq6zp27FhuV0Oqv/bv3w8DAwP4+/vLvaH/K3Nzc9lC80QzZsxAeHg4bt68KXUUIqqjVq1ahXbt2mH48OEICQmBvr4+VqxYgTt37mDHjh0V3pBt0qQJHB0dkZOTI0Fiktrjx4/LbYQTEREBLS0teHh4AHizk7eDgwOSk5OliEhENdRA6gBERPTu8vLyoK2tXW2dtrY2cnNzFZCIaoPU1FQ4OztDXV29yjoNDQ3ZrvBEkyZNQkpKCvr16wc/Pz84OzvDyMhI6lhEVIcsXLgQAODg4IBZs2Zh1KhRNVqv/aOPPoKjo+OHjkdKqKCgQG6ZmsLCQsTHx8PJyQkNGvy33aGvr4+oqCgpIhJRDbFBSURUi+nr6yMxMbHauuvXr6NFixYKSES1gZqaGl6/fl1t3Z07d6rcpZnqlz83CT7//PMqa7mJGxG9i8mTJ2PWrFno1q3bW503b948rkFZT7Vu3RpJSUmyzyMjI1FQUAB7e3u5uvz8fDRp0kTR8YjoLfARbyKiWsze3h7Xr19HSEhIpTWhoaG4du0aHBwcFJiMlFnHjh1x5coVFBQUVFrz9OlTXL16VW7RearfuIkbEX1oAQEBb92cpPrNyckJKSkpWLVqFRISErBkyRIIggAXFxe5usTERM76J1JybFASEdVic+bMAQBMmDAB/v7+cg2ngoIC+Pv7Y8KECRAEAbNnz5YqJimZTz75BA8fPsSCBQsqrfnqq6+Qn5+PsWPHKjAZKTNu4kZEUrp16xYOHjyI3377TeoopEQWL14MLS0tLFq0CFZWVoiNjcXAgQPRs2dPWc3NmzeRmpqK3r17S5iUiKrDBiURUS3Wq1cvrFixAnl5efDx8YGOjg7Mzc1hbm4OXV1d+Pj44Pnz51i+fDn69OkjdVxSEjNnzoSFhQU2btwIBwcHrFu3DsCbTZe2bt2KAQMG4Mcff0SXLl0wZcoUidMSEVF9cejQIQwZMgSxsbFy4ytWrICFhQXGjh2L3r17w8vLS6KEpGzMzc0RFRUFb29vuLq6YtmyZThy5Ihczblz59CtWzcMGzZMopREVBOC+OcVZYmIqFYKDg7G8uXLkZCQIDfetWtX+Pr6YuTIkRIlI2WVlZWFMWPGICYmBoIgQBRFCIIA4M2jvNbW1jh8+HC5nTGJiIg+lFGjRuH06dN4+PAhNDU1Abx5NLdr165o0KABbG1tcf36dTx79gz79+/HqFGjJE5MRETvCxuURER1yIMHD5CRkQFBEGBsbIxWrVpJHYmU3MmTJxESEoLU1FSUlJSgTZs2cHV1hbu7u6xhSUREpAht27aFgYGB3G7LCxcuxOrVq7F9+3ZMnDgRqamp6Ny5M/r374/Q0FAJ0xIR0fvEBiURUR2Rm5uLy5cvIycnByYmJnykm4iIiGqVJk2awMXFBfv27ZON2dnZISkpCY8fP0aDBg0AAIMGDcIff/yB9PR0iZISEdH7xjUoiYhqudzcXEyePBl6enpwdnaGl5cXAgICZMcDAgJgYGCAmJgYCVMSERERVa2goAB/nj9TWFiI+Ph42NnZyZqTAKCvr48HDx5IEZGIiD4QNiiJiGqxFy9eoF+/ftixYweaNm0KV1dX/HVi/LBhw/DgwQMcPnxYmpCkdFRVVWv0oaGhASMjI7i7u/Pnh4iIPrjWrVsjKSlJ9nlkZCQKCgpgb28vV5efn48mTZooOh4REX1AbFASEdVia9aswdWrV+Hl5YXU1FQcP368XI2+vj46d+6MsLAwCRKSMhJFsUYfhYWFuHfvHo4ePYrRo0fjs88+kzo6ERHVYU5OTkhJScGqVauQkJCAJUuWQBAEuLi4yNUlJibCyMhIopRERPQhsEFJRFSL7d+/HwYGBvD395ftdlkRc3NzZGVlKTAZKbPS0lLMmzcPWlpa+PLLLxEfH4+nT58iNzcXV69exYIFC6CtrY25c+ciMzMT//nPf9CyZUvs3LkTu3fvljo+ERHVUYsXL4aWlhYWLVoEKysrxMbGYuDAgejZs6es5ubNm0hNTUXv3r0lTEpERO9bg+pLiIhIWaWmpsLZ2Rnq6upV1mloaODx48cKSkXKbvv27fj+++8RGRkJW1tbuWNdunTBt99+C3d3d/Tt2xcWFhaYMmUKOnTogD59+mDHjh3w8PCQKDkREdVl5ubmiIqKwrp16/Dw4UP06tUL8+fPl6s5d+4cunXrhmHDhkmUkoiIPgTu4k1EVIvp6OigT58+CA0NlY2pqKhg0qRJ+Pnnn2Vjjo6OSEpKwqNHj6SISUrGxsYGOjo6OHfuXJV1AwcOxLNnzxAXFwcAsLa2RmZmJnJychQRk4iIiIiI6gk+4k1EVIt17NgRV65cQUFBQaU1T58+xdWrV9GlSxcFJiNllpKSAn19/Wrr9PX1cePGDdnnZmZmeP78+YeMRkRERERE9RAblEREtdgnn3yChw8fYsGCBZXWfPXVV8jPz8fYsWMVmIyUmbq6OuLj46uti4+Pl1s+oLCwENra2h8wGRER0ZvfN3v27MG0adMwdOhQDB06FJ9//jl2795d5U1ZIiKqvfiINxFRLfby5Uv07NkTKSkpsLOzw6hRozBv3jz069cPY8aMwf79+xEREYEuXbrg0qVLaNiwodSRSQmMGDECx48fh6+vL5YuXVphzYoVK7B06VK4ubnh8OHDAICuXbtCFEVcu3ZNgWmJiKg+iY6OhoeHB+7cuYO//ldVEAQYGRkhKCgIDg4OEiUkIqIPgQ1KIqJaLisrC2PGjEFMTAwEQYAoihAEAQAgiiKsra1x+PBhGBoaSpyUlMXVq1dhZ2eHgoICmJubY9y4cTAxMYEgCMjIyMC+ffuQkpICdXV1REdHo3v37sjMzISpqSmmT5+OTZs2SX0JRERUB12/fh29e/fGy5cvYWZmhgkTJsDU1BQAkJ6ejr179+L27dvQ1NREbGwsLC0tpQ1MRETvDRuURER1xMmTJxESEoLU1FSUlJSgTZs2cHV1hbu7u6xhSVQmLCwMXl5euH//frmfD1EU0apVK+zatQuDBg0CAOTk5CAhIQGdOnVis5uIiD6I0aNHIzg4GIsWLYKfnx9UVORXJCstLcXSpUuxcuVKjBo1CgcOHJAoKRERvW9sUBIREdVTr169woEDBxAREYGsrCwAgIGBARwdHTFmzBhoampKnJCIiOqTFi1aoGXLlkhOTq6yzsLCAjk5OXj06JGCkhER0YfGBiURERERERFJrnHjxnB3d0dQUFCVdZ6enjhy5Ajy8/MVlIyIiD407uJNREREREREkuvYsSOys7OrrcvOzkaHDh0UkIiIiBSFDUoiIiIiIiKSnI+PDyIjIxEVFVVpTVRUFCIjIzFt2jQFJiMiog+tgdQBiIiIiIiIiD7//HOkpKTAxcUF06dPh6enJ9q2bQvgzS7eQUFB2LJlC+bMmQMfHx+J0xIR0fvENSiJiIiIiIhIcqqqqu98riAIKC4ufo9piIhIkTiDkoiIiIiIiCT3v8yd4bwbIqLajTMoiYiIiIiIiIiISDLcJIeIiIiIiIiIiIgkwwYlERERERERERERSYYNSiIiIqq3TE1NIQiC3IeGhgbatm2LiRMnIj4+XuqIMmX5/qrsGtLT0xUf6j1YtmwZBEHAsmXLanzOjh07IAgCJk2a9F4y9OvXD4IgIDw8/L18vaqkp6dDEASYmpp+8O9FREREVFuwQUlERET1nrOzM7y9veHt7Y3Bgwfj9evX2LVrF3r27Im9e/dKHU8h3qVRSERERET0PnAXbyIiIqr3Fi5ciH79+sk+f/XqFaZOnYqgoCBMmzYNgwcPRrNmzaQLWIVz586hqKgIhoaGUkchIiIiInonnEFJRERE9BeNGjXC1q1b0bhxYzx//hynTp2SOlKl2rVrh06dOkFNTU3qKERERERE74QNSiIiIqIKaGtrw9zcHACQkZEBQH79wOLiYqxZswbdunVD48aNoaurK3d+bGwsxo8fDyMjIzRs2BAtW7aEm5sbLly4UOn3vHbtGkaOHIlmzZqhcePG6NGjBwICAqrMWdUalKIoYt++fXB1dYWenh4aNmwIQ0NDDBw4EBs3bpTVCYKA5cuXAwCWL18utybnXx/5fvHiBVatWoWePXuiSZMmaNSoESwtLbFs2TLk5+dXmLGoqAhr1qxB586doaGhAX19fXz66aey1/V9OnjwICZPngxLS0vo6upCQ0MD7du3x4wZM3Dnzp1qzz9//jwGDRqEpk2bQktLCw4ODjh69Gil9aIoYu/evRg8eDBatGgBdXV1GBsbY+rUqbV2XVAiIiIiReMj3kRERESVeP78OQBAXV1dblwURYwePRonT56Eo6MjOnfujMzMTNnxtWvXYv78+QCAHj16wM7ODnfv3sWJEydw4sQJbNu2DVOnTpX7mhEREXB1dcWrV6/QsWNHWFlZITs7G9OmTUNSUtJbZy8sLMSYMWNw9OhRqKqqwtbWFsbGxnjw4AESExMRFhaGWbNmAQC8vb0RHx+Pq1evolu3bujevbvs6/z5z3fv3oWzszOSkpLQsmVL2NnZQUNDA5cvX8by5csRHByM8PBwNG3aVHZOaWkpRo0ahePHj0NDQwMDBgyAtrY2zp07h9DQUAwdOvStr60q48aNg4aGBjp37oxBgwahoKAA8fHx2LJlC/bt24eoqChZ4/mvgoODsWnTJlhaWsLV1RUZGRmIiorCiBEjsHbtWsydO1euvqioCOPHj8ehQ4fQqFEj2NjYoFWrVkhMTERAQAAOHjyI06dPw8bG5r1eIxEREVGdIxIRERHVUyYmJiIA8fz58+WOXblyRVRRUREBiGFhYaIoimJaWpoIQAQgGhsbi7du3Sp3XkhIiAhANDAwEGNiYuSOXbhwQWzSpImopqYm3rhxQzb+8uVL0dDQUAQgLlq0SCwtLZUdCw8PFzU1NWXft7JrSEtLkxufM2eOCEA0NzcXk5OT5Y4VFxeLR44ckRvz9fUVAYi+vr4VvlalpaWinZ2dCECcOXOm+PLlS7n8Xl5eIgDR29tb7rwNGzaIAERDQ0O51+vVq1fi6NGjZddV2fetyPbt2yv8XqIoir/88ov44sULubGioiLx66+/FgGILi4u5c5xcnKS5Vi9erXcsaNHj4oNGjQQVVVVxatXr8odW7BggQhAdHR0FO/cuSN3bOPGjSIAsV27dmJRUZFsvOxnyMTEpMbXS0RERFTX8RFvIiIioj95+vQpjh49ilGjRqG0tBTdu3eHk5NTubpvv/0W7du3Lzde9kh0QEAAevfuLXfM3t4eS5YsQVFREX744QfZ+IEDB5CVlYV27drBz88PgiDIjjk5OcHHx+etruHhw4fYunUrVFRUcOjQIXTq1EnuuKqqKtzc3N7qa548eRIXL16Era0t1q9fj0aNGsmONWrUCNu2bYOenh6CgoLw9OlT2bHvv/8eALBixQq510tDQwNbtmyR+zrvw9ixY6GpqSk31qBBA/j5+cHAwACnT59GXl5ehefa2Nhg3rx5cmPDhw+Hh4cHSkpK5B6Lf/LkCTZs2AAtLS3s378fRkZGcufNnDkTQ4cOxe3btxEaGvqero6IiIiobmKDkoiIiOq9/v37y9ZcbNasGUaMGIG0tDT06NEDhw8fhopK+bdMI0eOLDf26NEjXLp0CU2aNMHgwYMr/F5lzc6LFy/KxiIiIgAA48ePh6qqarlzPv3007e6nrCwMBQWFsLOzg6WlpZvdW5lQkJCAACjR4+u8PVo3LgxbGxsUFxcjMuXLwN480h4amoqVFRU4OHhUe4cPT29Sl+n/8XNmzexYcMGzJ49G5MnT8akSZMwadIkFBcXo7S0FH/88UeF53l6elY4Xvb6h4eHy8bOnz+PV69ewcnJCXp6ehWeV9HfNRERERGVxzUoiYiIqN5zdnaGvr4+gDfrTRoYGKBv376yxuVf6enpVTjzLy0tDcCbtSsbNKj6bVZOTo7sz3fv3gUAtG3btsJaU1PTGl1HmbLNZ/46c/J/kZqaCgCYP3++bH3NypRdW9l1GRgYoGHDhhXWvu21VaW4uBjTp09HQEAARFGstK5sbdG/qu71L7se4L+vx4kTJyr8GfmzP/9dExEREVF5bFASERFRvbdw4UL069evxvWVPZZcUlICANDR0YG7u3uVX6NFixY1/n5vq7qG2bsouzYnJ6dqm4omJibv/fvXxPr16+Hv7w8DAwOsW7cOffr0gZ6enmyToz59+uDixYtVNi9rquz16NixI2xtbaus/euj/kREREQkjw1KIiIiovekTZs2AAA1NTXs2LGjxucZGhoCANLT0ys8Xtl4ZYyNjQEAN27ceKvzqlJ2bWPGjMGMGTNqdE7Zdd27dw+FhYUVzqJ822uryv79+wEAP/zwA4YNG1bueGWPdleXpWy87HqA/74eXbp0eau/ayIiIiIqj2tQEhEREb0nhoaG6NKlCx49eiS3XmF1ytYq3Lt3r2xm3p8FBQW9VY4BAwZATU0N0dHRSE5OrtE5Zc3D4uLiCo+7uroC+G8TsCbatGmDtm3borS0FHv37i13PCcnB2fOnKnx16vOkydPZN/3r86cOVPto9aVvc5l43+eZTto0CCoqanh7NmzePbs2bsFJiIiIiIAbFASERERvVd+fn4AAC8vL5w+fbrc8ZKSEoSFhSEmJkY29sknn6B169b4448/sGzZMrlHkC9cuICtW7e+VQY9PT34+PigtLQUo0ePxs2bN8tlOHbsmNxY2ezAyhqa7u7usLa2RkREBHx8fGTNwD+7f/8+/P395cZmz54NAPj6669l6zYCQEFBAWbMmIGXL1++1bVVpWzNza1bt6K0tFQ2fvv27RrthH758mX8+9//lhsLCQlBYGAgVFVVMXPmTNl4q1atMGPGDDx79gxubm5ISUkp9/VevHiB3bt348GDB+96SURERET1Ah/xJiIiInqPRowYgbVr1+LLL7+Es7MzzM3N0bFjR2hpaeH+/fu4cuUKnj17hq1bt8rWLtTU1ERgYCCGDh2KFStW4MCBA7CyskJ2djYiIyMxZ86cco2z6qxevRq3b99GSEgILC0tYWdnByMjIzx8+BDXrl3Dw4cP5Rqhzs7O0NTUxKFDh+Do6Ih27dpBVVUVbm5ucHNzg4qKCg4fPowhQ4bghx9+wO7du9GtWze0adMGr1+/xs2bN5GUlAQ9PT1MnTpV9nVnzZqF06dPIzQ0FJaWlhgwYAC0tLRw4cIFvH79GhMnTsTOnTvfy2u/aNEinDx5Ej/88APOnz8PKysrPHnyBBEREbCzs4O+vj6io6MrPX/27NmYN28eduzYAUtLS2RmZiIqKgoAsGrVKnTv3l2uftWqVbh37x727duHjz76CN27d4eZmRkEQUB6ejquXr2KgoICJCcno1WrVu/lGomIiIjqIs6gJCIiInrP5s6di7i4OEyZMgUlJSU4c+YMjh07hrt378LR0RH+/v4YO3as3DkDBgxATEwM3NzccP/+fRw+fBhPnz7F5s2bsW7durfOoK6ujmPHjmHXrl1wdHREYmIiDhw4gJSUFHTt2hWbN2+Wq9fX18fx48fRr18/JCQk4D//+Q9++ukn/P7777IaIyMjXLp0CZs2bYKVlRWuX7+OAwcO4OLFi9DQ0MA//vEPHDp0SO7rqqqq4siRI/jXv/4FU1NTnD17FufPn4ejoyN+++23SnfOfhd2dna4fPkyhg4ditzcXBw5cgR3797F4sWLcerUKaipqVV5/siRI3Hq1Ck0b94cJ06cwJUrV9CnTx8EBwdXuHO5mpoafvnlFxw9ehTDhg3DvXv3cPjwYZw9exYvXrzAhAkTEBwcjHbt2r23ayQiIiKqiwTxfWxjSERERERERERERPQOOIOSiIiIiIiIiIiIJMMGJREREREREREREUmGDUoiIiIiIiIiIiKSDBuUREREREREREREJBk2KImIiIiIiIiIiEgybFASERERERERERGRZNigJCIiIiIiIiIiIsmwQUlERERERERERESSYYOSiIiIiIiIiIiIJMMGJREREREREREREUnm/wGsiWpwpBD/wwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -874,13 +2806,13 @@ " values_format=\".2f\",\n", ")\n", "plt.tight_layout()\n", - "plt.savefig(\"mag-confusion.png\", dpi=600)" + "plt.savefig(WORK_DIR / \"mag-confusion.png\", dpi=600)" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", + "display_name": ".venv (3.13.5)", "language": "python", "name": "python3" }, @@ -894,15 +2826,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } + "version": "3.13.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } diff --git a/docs/examples/simple/data.ipynb b/docs/examples/simple/data.ipynb index 2ad9193..3a048d3 100644 --- a/docs/examples/simple/data.ipynb +++ b/docs/examples/simple/data.ipynb @@ -2,141 +2,148 @@ "cells": [ { "cell_type": "markdown", + "id": "cell-0", "metadata": {}, "source": [ "# Simple example: data engineering\n", "\n", - "Here, we solve a problem similar to the tutorial's but with an explainable Naive Bayes classifier and more best practices. In short, we train a domain classifier on the [semantic scholar dataset](https://api.semanticscholar.org/corpus) by taking full advantage of `great-ai`. Subsequently, we create a production-ready deployment.\n", + "Train a scientific domain classifier with an explainable Naive Bayes model.\n", + "Run `data.ipynb`, `train.ipynb`, then `deploy.ipynb` in that order.\n", "\n", - "![position of this step in the lifecycle](https://great-ai.scoutinscience.com/media/scope-data.svg)\n", - "> The blue boxes show the steps of a typical AI-development lifecycle implemented in this notebook.\n", + "The original example downloaded large Semantic Scholar corpus shards.\n", + "For a reproducible local run, we use the bundled MAG sentences instead,\n", + "wrapping each domain in a list to keep the same multilabel data interface.\n", + "By default we take 60 examples per class; `GREAT_AI_NOTEBOOK_FULL=1` uses\n", + "the entire bundled training split. These results are not the original\n", + "Semantic Scholar experiment's metrics.\n", "\n", - "Since the true scope of `great-ai` is the phase between proof-of-concept code and production-ready service, it is predominantly used in the [deployment notebook](https://great-ai.scoutinscience.com/examples/simple/deploy). Feel free to skip there, or continue reading if you'd like to see the full picture.\n", + "### Extract" + ] + }, + { + "cell_type": "markdown", + "id": "0df47c23", + "metadata": {}, + "source": [ + "## Local setup\n", "\n", - "### Extract\n", - "\n", - "This can be achieved by downloading a public dataset (such as in this case), or by having a Data Engineer setup and give us access to the organisation's data.\n", - "\n", - "In this example, we download the semantic scholar dataset from a public S3 bucket." + "Use Python 3.12 or 3.13 and install this checkout with `uv pip install --editable '.[notebooks]'`.\n", + "See **Run notebooks locally** in the repository README for the kernel, execution order,\n", + "and full-data options. Generated artifacts stay under `.cache/notebooks/`.\n" ] }, { "cell_type": "code", "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "MAX_CHUNK_COUNT = 4" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'Processing 4 out of the 6002 available chunks'" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import urllib.request\n", - "from random import shuffle\n", - "\n", - "manifest = (\n", - " urllib.request.urlopen(\n", - " \"https://s3-us-west-2.amazonaws.com/ai2-s2-research-public/\"\n", - " \"open-corpus/2022-02-01/manifest.txt\"\n", - " )\n", - " .read()\n", - " .decode()\n", - ") # a list of available chunks separated by '\\n' characters\n", - "\n", - "lines = manifest.split()\n", - "shuffle(lines)\n", - "chunks = lines[:MAX_CHUNK_COUNT]\n", - "\n", - "f\"\"\"Processing {len(chunks)} out of the {\n", - " len(manifest.split())\n", - "} available chunks\"\"\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Transform\n", - "\n", - "- Filter out non-English abstracts using `great_ai.utilities.predict_language`\n", - "- Project it to only keep the necessary components (text and labels), clean the textual content using `great_ai.utilities.clean`\n", - "- We will speed up processing using `great_ai.utilities.simple_parallel_map`." - ] - }, - { - "cell_type": "code", - "execution_count": 3, + "id": "a800dc4d", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 4/4 [04:22<00:00, 65.51s/it] \n" + "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", + "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.11): configured ✅\u001b[0m\n", + "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", + "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", + "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", + "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", + "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook artifacts: /Users/schmelczer/Projects/great-ai/.cache/notebooks/simple\n" ] } ], "source": [ - "from typing import List, Tuple\n", - "import json\n", - "import gzip\n", - "from great_ai.utilities import (\n", - " simple_parallel_map,\n", - " clean,\n", - " is_english,\n", - " predict_language,\n", - " unchunk,\n", + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", "\n", + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"simple\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-3", + "metadata": {}, + "outputs": [], + "source": [ + "PER_LABEL = None if FULL_RUN else 60" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cell-4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded 420 bundled MAG sentences\n" + ] + } + ], + "source": [ + "import json\n", "\n", - "def preprocess_chunk(chunk_key: str) -> List[Tuple[str, List[str]]]:\n", - " response = urllib.request.urlopen(\n", - " f\"https://s3-us-west-2.amazonaws.com/ai2-s2-research-public/\"\n", - " f\"open-corpus/2022-02-01/{chunk_key}\"\n", - " ) # a gzipped JSON Lines file\n", + "records = [json.loads(line) for line in mag_lines(DATA_DIR / \"train.txt\", PER_LABEL)]\n", + "print(f\"Loaded {len(records)} bundled MAG sentences\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-5", + "metadata": {}, + "source": [ + "### Transform\n", "\n", - " decompressed = gzip.decompress(response.read())\n", - " decoded = decompressed.decode()\n", - " chunk = [json.loads(line) for line in decoded.split(\"\\n\") if line]\n", - "\n", - " # Transform\n", - " return [\n", - " (\n", - " clean(\n", - " f'{c[\"title\"]} {c[\"paperAbstract\"]} '\n", - " f'{c[\"journalName\"]} {c[\"venue\"]}',\n", - " convert_to_ascii=True,\n", - " ), # The text is cleaned to remove common artifacts\n", - " c[\"fieldsOfStudy\"],\n", - " ) # Create pairs of `(text, [...domains])`\n", - " for c in chunk\n", - " if (c[\"fieldsOfStudy\"] and is_english(predict_language(c[\"paperAbstract\"])))\n", - " ]\n", - "\n", - "\n", - "preprocessed_data = unchunk(\n", - " simple_parallel_map(preprocess_chunk, chunks, concurrency=4)\n", - ")" + "Clean the text with `great_ai.utilities.clean` and keep a list of accepted\n", + "labels for each publication. Duplicate texts are combined before splitting\n", + "to keep every copy of a paper in the same split." ] }, { "cell_type": "code", "execution_count": 4, + "id": "cell-6", + "metadata": {}, + "outputs": [], + "source": [ + "from great_ai.utilities import clean\n", + "\n", + "labels_by_text = {}\n", + "for record in records:\n", + " text = clean(record[\"text\"], convert_to_ascii=True)\n", + " labels_by_text.setdefault(text, set()).add(record[\"label\"])\n", + "preprocessed_data = [(text, sorted(labels)) for text, labels in labels_by_text.items()]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cell-7", "metadata": {}, "outputs": [], "source": [ @@ -145,58 +152,37 @@ }, { "cell_type": "markdown", + "id": "cell-8", "metadata": {}, "source": [ "### Load\n", "\n", - "Upload the dataset (or a part of it) to a central repository using `great_ai.add_ground_truth`. This step automatically tags each data-point with a split label according to the ratios we set. Additional tags can be also given.\n", - "\n", - "#### Production-ready backend\n", - "\n", - "The MongoDB driver is automatically configured if `mongo.ini` exists with the following scheme:\n", - "\n", - "```ini\n", - "mongo_connection_string=mongodb://localhost:27017/\n", - "mongo_database=my_great_ai_db\n", - "```\n", - "> You can install MongoDB from [here](https://www.mongodb.com/docs/manual/installation) or [use it as a service](https://www.mongodb.com/cloud/atlas/register)\n", - "\n", - "Otherwise, TinyDB is used which is just a local JSON file." + "Store the dataset in the local TinyDB tracing database. All notebooks in\n", + "this example share `.cache/notebooks/simple/` (or `simple-full/`). No S3 or\n", + "MongoDB credentials are needed. A dataset tag makes rerunning this cell\n", + "replace just this example's ground truth instead of duplicating it." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, + "id": "cell-9", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", - "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", - "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", - "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", - "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", - "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", - "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", - "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", - "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ - "from great_ai import add_ground_truth\n", + "import random\n", + "from great_ai import add_ground_truth, delete_ground_truth\n", "\n", - "add_ground_truth(X, y, train_split_ratio=0.8, test_split_ratio=0.2)" + "random.seed(42)\n", + "delete_ground_truth(\"local-domain-example\")\n", + "add_ground_truth(\n", + " X, y, tags=\"local-domain-example\", train_split_ratio=0.8, test_split_ratio=0.2\n", + ")" ] }, { "cell_type": "markdown", + "id": "cell-10", "metadata": {}, "source": [ "### Next: [Part 2](https://great-ai.scoutinscience.com/examples/simple/train)" @@ -205,7 +191,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", + "display_name": ".venv (3.13.5)", "language": "python", "name": "python3" }, @@ -219,15 +205,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } + "version": "3.13.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } diff --git a/docs/examples/simple/deploy.ipynb b/docs/examples/simple/deploy.ipynb index 61abb02..a7a57a7 100644 --- a/docs/examples/simple/deploy.ipynb +++ b/docs/examples/simple/deploy.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "cell-0", "metadata": {}, "source": [ "# Hardening and deployment\n", @@ -18,9 +19,22 @@ "Next to the prediction, we also return the top-n most influential words based on their weights." ] }, + { + "cell_type": "markdown", + "id": "e8e78891", + "metadata": {}, + "source": [ + "## Local setup\n", + "\n", + "Use Python 3.12 or 3.13 and install this checkout with `uv pip install --editable '.[notebooks]'`.\n", + "See **Run notebooks locally** in the repository README for the kernel, execution order,\n", + "and full-data options. Generated artifacts stay under `.cache/notebooks/`.\n" + ] + }, { "cell_type": "code", "execution_count": 1, + "id": "b7a9d250", "metadata": {}, "outputs": [ { @@ -28,21 +42,58 @@ "output_type": "stream", "text": [ "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.11): configured ✅\u001b[0m\n", "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", - "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", - "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", - "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n", + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook artifacts: /Users/schmelczer/Projects/great-ai/.cache/notebooks/simple\n" + ] + } + ], + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", + ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", + "\n", + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"simple\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-3", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ "\u001b[38;5;39mFetching cached versions of small-domain-prediction\u001b[0m\n", - "\u001b[38;5;39mLatest version of small-domain-prediction is 2 (from versions: 0, 1, 2)\u001b[0m\n", - "\u001b[38;5;39mFile small-domain-prediction-2 found in cache\u001b[0m\n" + "\u001b[38;5;39mLatest version of small-domain-prediction is 0 (from versions: 0)\u001b[0m\n", + "\u001b[38;5;39mFile small-domain-prediction-0 found in cache\u001b[0m\n", + "\u001b[38;5;39mFile small-domain-prediction-0 found in cache\u001b[0m\n" ] } ], @@ -120,110 +171,143 @@ }, { "cell_type": "markdown", + "id": "cell-4", "metadata": {}, "source": [ "## Check accuracy on the test split\n", "\n", - "Anything under `if __name__ == \"__main__\":` will not be run when the script is executed by the `great-ai` CLI app. This, combined with `query_ground_truth` and the `/traces/{trace_id}/feedback` endpoint are ideal for creating a continuous-integration job for checking the quality of the model before deployment." + "Anything under `if __name__ == \"__main__\":` will not be run when the script is executed by the `great-ai` CLI app. This, combined with `query_ground_truth` and the `/traces/{trace_id}/feedback` endpoint are ideal for creating a continuous-integration job for checking the quality of the model before deployment.\n", + "\n", + "We keep each paper's full set of accepted labels fixed. **Top-1 hit rate** is the fraction of papers whose highest-ranked returned label belongs to that set (an empty prediction is a miss). It is an application-specific hit criterion, not ordinary multiclass accuracy.\n", + "\n", + "We also report per-class and micro, macro, weighted and sample-averaged multilabel precision, recall and F1 for **all returned labels**, using the default `target_confidence=50`. The label vocabulary comes from the train/test annotations, independently of predictions. Each class's support is the number of test papers annotated with that class. A lower confidence target can return fewer labels and trade recall for precision. `zero_division=0` assigns zero to undefined metrics.\n", + "\n", + "The earlier report and confusion matrix used prediction-dependent targets. Those outputs have been removed; rerun this cell to generate the corrected report for your model.\n" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "id": "cell-5", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 12272/12272 [01:10<00:00, 174.77it/s]\n" + "100%|██████████| 84/84 [00:01<00:00, 81.74it/s] " ] }, { "name": "stdout", "output_type": "stream", "text": [ - " precision recall f1-score support\n", + "Top-1 hit rate (any accepted label): 0.405\n", + " precision recall f1-score support\n", "\n", - " Art 0.54 0.38 0.45 126\n", - " Biology 0.77 0.84 0.80 1215\n", - " Business 0.47 0.73 0.57 311\n", - " Chemistry 0.82 0.67 0.74 1205\n", - " Computer Science 0.77 0.76 0.76 1277\n", - " Economics 0.69 0.55 0.61 270\n", - " Engineering 0.55 0.52 0.53 754\n", - "Environmental Science 0.56 0.55 0.55 227\n", - " Geography 0.54 0.39 0.45 276\n", - " Geology 0.74 0.67 0.70 265\n", - " History 0.35 0.18 0.24 140\n", - " Materials Science 0.72 0.81 0.76 1011\n", - " Mathematics 0.77 0.70 0.74 498\n", - " Medicine 0.96 0.77 0.86 2835\n", - " Philosophy 0.57 0.06 0.10 71\n", - " Physics 0.66 0.75 0.70 611\n", - " Political Science 0.44 0.61 0.51 291\n", - " Psychology 0.52 0.84 0.64 574\n", - " Sociology 0.33 0.59 0.42 315\n", + " business 0.17 0.78 0.28 9\n", + " economics 0.22 0.82 0.35 11\n", + " geography 0.38 0.93 0.54 14\n", + " medicine 0.38 0.86 0.52 14\n", + " politics 0.14 0.36 0.21 11\n", + " psychology 0.28 0.69 0.40 16\n", + " sociology 0.17 0.67 0.27 9\n", "\n", - " accuracy 0.71 12272\n", - " macro avg 0.62 0.60 0.59 12272\n", - " weighted avg 0.74 0.71 0.71 12272\n", + " micro avg 0.25 0.74 0.37 84\n", + " macro avg 0.25 0.73 0.37 84\n", + "weighted avg 0.26 0.74 0.38 84\n", + " samples avg 0.27 0.74 0.39 84\n", "\n" ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] } ], "source": [ "if __name__ == \"__main__\":\n", " from great_ai import query_ground_truth\n", " from sklearn import metrics\n", + " from sklearn.preprocessing import MultiLabelBinarizer\n", "\n", - " data = query_ground_truth(\"test\")\n", + " data = query_ground_truth([\"test\", \"local-domain-example\"])\n", + " if not data:\n", + " raise ValueError(\"No test samples are available for evaluation\")\n", "\n", " X = [d.input for d in data]\n", " y_actual = [d.feedback for d in data]\n", "\n", + " # Retain the complete returned label set, in descending confidence order.\n", " y_predicted = [\n", - " d.output.labels[0].label\n", - " for d in predict_domain.process_batch(X, do_not_persist_traces=True)\n", + " [label.label for label in d.output.labels]\n", + " for d in predict_domain.process_batch(\n", + " X, do_not_persist_traces=True, concurrency=2\n", + " )\n", " ]\n", - " y_actual_aligned = [p if p in a else a[0] for p, a in zip(y_predicted, y_actual)]\n", + " top_1_hit_rate = sum(\n", + " bool(predicted) and predicted[0] in actual\n", + " for predicted, actual in zip(y_predicted, y_actual)\n", + " ) / len(y_actual)\n", + " print(f\"Top-1 hit rate (any accepted label): {top_1_hit_rate:.3f}\")\n", "\n", - " import matplotlib.pyplot as plt\n", - "\n", - " # Configure matplotlib to have nice, high-resolution charts\n", - " %matplotlib inline\n", - " plt.rcParams[\"figure.figsize\"] = (19, 18)\n", - " plt.rcParams[\"figure.facecolor\"] = \"white\"\n", - " plt.rcParams[\"font.size\"] = 16\n", - " plt.rcParams[\"axes.xmargin\"] = 0\n", - "\n", - " print(metrics.classification_report(y_actual_aligned, y_predicted))\n", - " metrics.ConfusionMatrixDisplay.from_predictions(\n", - " y_true=y_actual_aligned,\n", - " y_pred=y_predicted,\n", - " xticks_rotation=\"vertical\",\n", - " normalize=\"pred\",\n", - " values_format=\".2f\",\n", + " # Fix the label vocabulary from annotations, including classes absent in test.\n", + " label_binarizer = MultiLabelBinarizer()\n", + " label_binarizer.fit(\n", + " [d.feedback for d in query_ground_truth([\"train\", \"local-domain-example\"])]\n", + " + y_actual\n", " )\n", + " unknown_labels = {label for labels in y_predicted for label in labels}.difference(\n", + " label_binarizer.classes_\n", + " )\n", + " if unknown_labels:\n", + " raise ValueError(f\"Predictions contain unrecognised labels: {unknown_labels}\")\n", + " y_true_multilabel = label_binarizer.transform(y_actual)\n", + " y_pred_multilabel = label_binarizer.transform(y_predicted)\n", + " print(\n", + " metrics.classification_report(\n", + " y_true_multilabel,\n", + " y_pred_multilabel,\n", + " target_names=label_binarizer.classes_,\n", + " zero_division=0,\n", + " )\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "98ae85f1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'labels': [{'label': 'psychology', 'confidence': 17.0, 'explanation': ['neural', 'networks', 'features']}, {'label': 'medicine', 'confidence': 16.0, 'explanation': ['features', 'neural', 'networks']}, {'label': 'economics', 'confidence': 16.0, 'explanation': ['networks', 'neural', 'features']}, {'label': 'geography', 'confidence': 15.0, 'explanation': ['features', 'neural', 'networks']}]}\n" + ] + } + ], + "source": [ + "if __name__ == \"__main__\":\n", + " from fastapi.testclient import TestClient\n", "\n", - " plt.tight_layout()\n", - " plt.savefig(\"ss-confusion.png\", dpi=600)" + " with TestClient(predict_domain.app) as client:\n", + " response = client.post(\n", + " \"/predict\", json={\"text\": \"Neural networks learn useful features.\"}\n", + " )\n", + " response.raise_for_status()\n", + " assert response.json()[\"output\"][\"labels\"]\n", + " print(response.json()[\"output\"])" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", + "display_name": ".venv (3.13.5)", "language": "python", "name": "python3" }, @@ -237,15 +321,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } + "version": "3.13.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } diff --git a/docs/examples/simple/stacked-bars.ipynb b/docs/examples/simple/stacked-bars.ipynb index 5d0e296..2881941 100644 --- a/docs/examples/simple/stacked-bars.ipynb +++ b/docs/examples/simple/stacked-bars.ipynb @@ -1,8 +1,21 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "d395f076", + "metadata": {}, + "source": [ + "## Local setup\n", + "\n", + "Use Python 3.12 or 3.13 and install this checkout with `uv pip install --editable '.[notebooks]'`.\n", + "See **Run notebooks locally** in the repository README for the kernel, execution order,\n", + "and full-data options. Generated artifacts stay under `.cache/notebooks/`.\n" + ] + }, { "cell_type": "code", "execution_count": 1, + "id": "f0cae36d", "metadata": {}, "outputs": [ { @@ -10,37 +23,69 @@ "output_type": "stream", "text": [ "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.11): configured ✅\u001b[0m\n", "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", - "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", - "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", - "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n" + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook artifacts: /Users/schmelczer/Projects/great-ai/.cache/notebooks/simple\n" ] } ], "source": [ - "from great_ai import query_ground_truth\n", + "import os\n", + "import sys\n", + "from pathlib import Path\n", "\n", - "data = query_ground_truth(\"train\")" + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", + ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", + "\n", + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"simple\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 2, + "id": "cell-2", + "metadata": {}, + "outputs": [], + "source": [ + "from great_ai import query_ground_truth\n", + "\n", + "data = query_ground_truth([\"train\", \"local-domain-example\"])\n", + "if not data:\n", + " raise ValueError(\"Run data.ipynb first in the same local/full mode.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cell-3", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -54,7 +99,6 @@ "import numpy as np\n", "import matplotlib.ticker as mtick\n", "\n", - "\n", "first = Counter(d.feedback[0] for d in data if len(d.feedback) > 0)\n", "second = Counter(d.feedback[1] for d in data if len(d.feedback) > 1)\n", "third = Counter(d.feedback[2] for d in data if len(d.feedback) > 2)\n", @@ -82,14 +126,14 @@ "ax.legend()\n", "ax.set_ylabel(\"Ratio of all publications\")\n", "fig.tight_layout()\n", - "fig.savefig(\"ss-distribution.png\", dpi=500)\n", + "fig.savefig(WORK_DIR / \"ss-distribution.png\", dpi=500)\n", "None" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", + "display_name": ".venv (3.13.5)", "language": "python", "name": "python3" }, @@ -103,15 +147,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } + "version": "3.13.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } diff --git a/docs/examples/simple/train.ipynb b/docs/examples/simple/train.ipynb index 6e82e50..2b328a0 100644 --- a/docs/examples/simple/train.ipynb +++ b/docs/examples/simple/train.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "cell-0", "metadata": {}, "source": [ "# Optimise and train a model\n", @@ -9,16 +10,29 @@ "![position of this step in the lifecycle](https://great-ai.scoutinscience.com/media/scope-train.svg)\n", "> The blue boxes show the steps implemented in this notebook.\n", "\n", - "In the first part, we have cleaned and transformed our training data. We can now access this data using `great_ai.LargeFile`. Locally, it will gives us the cached version, otherwise, the latest version is downloaded from S3 or GridFS. \n", + "Run `data.ipynb` first. We read its ground truth from the shared local TinyDB database. The default uses a compact parameter search suitable for the bundled sample; `GREAT_AI_NOTEBOOK_FULL=1` enables the original larger search on the full MAG training data. \n", "\n", "In this part, we hyperparameter-optimise and train a simple Naive Bayes classifier which we then export for deployment using `great_ai.save_model`.\n", "\n", "## Load data that has been extracted in [part 1](https://great-ai.scoutinscience.com/examples/simple/data)" ] }, + { + "cell_type": "markdown", + "id": "d3495327", + "metadata": {}, + "source": [ + "## Local setup\n", + "\n", + "Use Python 3.12 or 3.13 and install this checkout with `uv pip install --editable '.[notebooks]'`.\n", + "See **Run notebooks locally** in the repository README for the kernel, execution order,\n", + "and full-data options. Generated artifacts stay under `.cache/notebooks/`.\n" + ] + }, { "cell_type": "code", "execution_count": 1, + "id": "d8ae0655", "metadata": {}, "outputs": [ { @@ -26,39 +40,72 @@ "output_type": "stream", "text": [ "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39mGreatAI (v0.1.6): configured ✅\u001b[0m\n", + "\u001b[38;5;39mGreatAI (v0.1.11): configured ✅\u001b[0m\n", "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", - "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", - "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", - "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n" + "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Notebook artifacts: /Users/schmelczer/Projects/great-ai/.cache/notebooks/simple\n" ] } ], + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", + ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", + "\n", + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"simple\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-3", + "metadata": {}, + "outputs": [], "source": [ "from great_ai import query_ground_truth\n", "\n", - "data = query_ground_truth(\"train\")\n", + "data = query_ground_truth([\"train\", \"local-domain-example\"])\n", + "if not data:\n", + " raise ValueError(\"Run data.ipynb first in the same local/full mode.\")\n", + "\n", "X = [d.input for d in data for domain in d.feedback]\n", "y = [domain for d in data for domain in d.feedback]" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "id": "cell-4", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABkEAAAH+CAYAAAArqakSAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUuVJREFUeJzt3QeUVdX5N+BNEbEAFhBFQLArKioWjBoL2MVewYpGjRULEdSo2EtUFHuJChHsDdD87V2x997BhljAAijCt96db0amIaMMM555nrXugnvPmczJTg73nPPb+30bTJs2bVoCAAAAAAAomIa1fQAAAAAAAAA1QQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQmqc/gSmTp2aPv3009SsWbPUoEGD2j4cAAAAAACgFk2bNi199913qU2bNqlhw4Z/7hAkApB27drV9mEAAAAAAAB1yOjRo1Pbtm3/3CFIrAAp+S/TvHnz2j4cAAAAAACgFk2YMCEvnijJD/7UIUhJCawIQIQgAAAAAABA+K0WGhqjAwAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCalzbB8Af06HfSENInfPhGVukus65Q130Zzh3AAAAAAq7EuTtt99OHTp0qPQ1ePDgCvtPnTo1XXLJJWnddddNyyyzTNp0003TnXfeOSuPHwAAAAAA4I+vBPnpp5/SRx99lM4+++y0ww47lNm24IILVth///33TzfccEMOQrp06ZKGDx+ett1223TxxRfnbQAAAAAAAHWqHFbLli3z6o8Zeeqpp9KVV16ZLrzwwtSrV6/82bLLLpveeuutdNRRR6Udd9wxLbDAAr/vqAEAAAAAAGqrMfqwYcPynzvvvHOZzyMQ+f7775XFAgAAAAAA6l4IcsYZZ+QeHyuttFLafffd09NPP11hn+effz4tvPDCedXI9FZYYYX85wsvvPB7jxkAAAAAAGDWl8PabLPN0r777ptDkNGjR6ezzjorrbXWWunqq69Oe+yxR+l+Y8eOrbTcVUnvkNhelcmTJ+dXiQkTJlT3MAEAAAAAgHquWiHIcsstl+66667S9506dUrdu3dPXbt2TQcffHBuet6sWbO8berUqalhw4oLTRo0aJBfv/zyS5W/5/TTT08DBgyo3n8TAAAAAACA31sOq1GjRhU+a9y4cdp1113Td999V6Ys1nzzzZc/Ky8+mzZtWpp//vmr/D39+/dP48ePL33FihMAAAAAAIDZ3hh97rnnzn9OmjSp9LPll18+ffLJJ2nixIll9n3nnXdKt1dlzjnnTM2bNy/zAgAAAAAAmO0hyP33359LXHXu3Ln0sx49eqQpU6ake++9t8y+I0eOzPtuueWWs+JXAwAAAAAA/PEQ5JRTTknDhw8vXd0Rf0bvjltuuSUddNBBqW3btqX7brfddmm11VZLffv2TR9//HH+LMplnXPOOelvf/tbWmKJJarzqwEAAAAAAGouBNliiy3Sddddl1q3bp1f8847bxo8eHAONs4///yy/8ENG+ZVHyuttFJaZpll0sILL5y6deuW9t577zRo0KDqHSUAAAAAAEA1Na7Ozqusskq6/vrrc2PzL774Is0111ypRYsWVe6/0EILpZtuuimvGPnmm29Sq1at0hxzzFHdYwQAAAAAAKjZEKRE9PSIlR0zK8KSeAEAf34d+o2s7UOAMj48Y4s/xYg4d6iL/iznDwAA1GpjdAAAAAAAgLpGCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJAa1/YBAAAAQFU69BtpcKhzPjxji1TXOXeoi/4M5w5QPFaCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIjWv7AAAAAAAA6oIO/UbW9iFABR+esYVR+QOsBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCH9oRDkhhtuSE2bNs2vL774osL2yZMnpxNOOCEttdRSqUWLFmnllVdOl19++R/5lQAAAAAAADOlcfqdPvvss3TggQfmcGPs2LFp2rRpFfbp2bNnevTRR9OwYcNSly5d0vDhw9M+++yTxo0bl4455pjf+6sBAAAAAABqbiVI7969U6dOndIOO+xQ6fb7778/3Xrrremss85K3bp1S/PNN1/afffd00EHHZROOumkSleOAAAAAAAA1GoIcskll6SHHnooXXnllalBgwaV7nPzzTfnbdtuu22Zz7fffvtcJuuOO+74fUcMAAAAAABQEyHIO++8k/r27Zt7fSy99NJV7vfSSy+lRRZZJJfLmt7yyy+f/3z55Zer+6sBAAAAAABqpifIL7/8kvbYY48cfhx11FEz3Df6fsw///wVPi/5LLZXJVaKxKvEhAkTqnOYAAAAAAAA1VsJcsYZZ6Rnn302XXXVValx49/OT6oqlRUqa6Re4vTTT88rSEpe7dq18z8VAAAAAABQMyHIJ598kgYMGJBXgKyyyiq/uf8CCyyQvv322wqfjx8/vnR7Vfr375/3K3mNHj16Zg8TAAAAAACgeiHIN998k37++ed07rnnpqZNm5a+Lr300ry9Q4cOqVOnTqX7r7jiiunTTz9N33//fZn/nDfffLN0e1XmnHPO1Lx58zIvAAAAAACAGglBIuCYOHFiXpkRKzxKXn/729/y9rfeeiu98MILpftvs802aerUqWnEiBFl/nNuv/32XEprq622qtaBAgAAAAAA1Ehj9OjvESs/ymvUqFHp6o0mTZqUfr7FFlukbt26pb59+6allloql9AaOXJkOv/889ORRx6Z2rZtW60DBQAAAAAAqJEQ5Pe47bbb0jHHHJM22WSTXE4rgo8TTjgh/eMf/6jJXwsAAAAAADDz5bCqMnDgwFwma+GFF66wrVmzZmnQoEFp3LhxuZ/IRx99lPr165caNvzDvxYAAAAAAKBmV4JEf494/RbBBwAAAAAAMDtZkgEAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAU0u8OQaZMmZImT548U/tOmzYtfffdd7/3VwEAAAAAANRsCPL999+nQYMGpVVXXTXNP//8qVmzZmnRRRdNRx99dBo/fnyF/b/99tu0zz775P0WWWSR1KpVq3T88cenX375pfpHCgAAAAAAUA2Nq7PzE088kT777LM0ZMiQtOyyy+bPhg8fnnr16pWefPLJ9Mgjj5RZ/bH11lunjz/+OD377LN5/wcffDD16NEjhynnnntudX41AAAAAABAza0E2XjjjdNpp52WOnXqlBo1apRf22yzTdpjjz3So48+mj766KPSfe+8884civzrX/8qDUw22GCDdPjhh6cLLrigzL4AAAAAAAB1sjF69AaJQKRFixaln91xxx35s0033bTMvltttVUuhxUrSAAAAAAAAOpEOawSP/zwQ5o4cWLuA3LXXXel6667Lp166qlpvvnmK93ntddey/1C5plnnjI/u/TSS+c/X3311T967AAAAAAAALM2BDn99NPTpZdemhufT506NR166KGpT58+Zfb55ptvUvPmzSv8bHzWoEGDvH1GK0viVWLChAm/5zABAAAAAIB67HeVwzrllFPSuHHj8mqQKHsVjdK7deuWy1yViKAjmqOXF5/Fq2HDqn91hCxRWqvk1a5du99zmAAAAAAAQD32h3qCzDHHHKlHjx7p5JNPTo8//ngaMWJE6baWLVumr7/+usLPlKwAie1V6d+/fy61VfIaPXr0HzlMAAAAAACgHpoljdGXWmqp/OeYMWNKP1t55ZXT559/XqHsVfQKKdlelTnnnDOXzZr+BQAAAAAAUGMhSGXlrcLDDz+c/+zcuXPpZzvttFPe/6abbiqz7/XXX5/mmmuutNVWW1XrQAEAAAAAAGqsMXrv3r1Tx44dU/fu3VP79u1zX5BbbrklnXnmmWm33XZL66yzTum+6623Xtpll11Sv379UuvWrVOXLl3S8OHD0+WXX573b9WqVbUOFAAAAAAAoMZCkIEDB6YrrrgiHXPMMem9997LPUGWX375dO2116Zdd921wv6DBw9O5557bjrhhBPS2LFjc4ByzTXX5MAEAAAAAACgzoQgLVq0SEcddVR+zYwISY4++uj8AgAAAAAA+NM1RgcAAAAAAKhrhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIf2uEGTq1Knpgw8+SF988cVM7T9u3Lj0xhtvpO++++73/DoAAAAAAICaDUFGjRqVevbsmeadd9604YYbphVXXDG1bt06DRw4ME2bNq3C/p988knaZJNN0mKLLZa23XbbvG/v3r3TxIkTq3+kAAAAAAAA1dC4OjufffbZacyYMemJJ55IK6+8cv7ssssuSwcccEBe7XHKKaeU7jtlypS02WabpQYNGqQPP/wwtWrVKq8GWXfddfO2wYMHV+dXAwAAAAAA1NxKkB133DE98sgjpQFI2H///dM666yTLrroojL73njjjemVV15JZ555Zg5AwnLLLZf69u2bhgwZkt58883qHSkAAAAAAEBNhSA777xzatKkSYXPW7Rokb799tv0888/l3521113pTnmmCNtsMEGZfaN8lhh5MiR1fnVAAAAAAAANVcOqzJRHuv+++9Pq6yySg49SsRKj0UXXTTNOeecZfZfcsklS7dXZfLkyflVYsKECX/0MAEAAAAAgHqmWitByvvll1/SXnvtlSZNmlSmH0gYP358atasWYWfiabq0SckVo5U5fTTT8+rS0pe7dq1+yOHCQAAAAAA1EN/KASJhuixCuTYY49Nm2++eZltjRo1yiFJeVOnTk3Tpk0rs2qkvP79++cQpeQ1evToP3KYAAAAAABAPfS7y2H16dMnXXnllenwww+vsAoktG7dutKSV19++WXp9qpECa3yZbQAAAAAAABqfCVIv3790vnnn58OO+ywdO6551a6z2qrrZbGjh2bvvjiizKfv/zyy/nPLl26/J5fDQAAAAAAUDMhyIknnpjOPPPMdMghh6SBAwdWuV/Pnj3zn0OGDCnz+bXXXpv7fPTo0aO6vxoAAAAAAKBmymHF6o8BAwakjTbaKPXu3Tu9+OKLZbZ36tSptNdHrPQ49NBD0/HHH5/mmmuu/H748OFp6NCh6ZprrslBCAAAAAAAQJ0IQV555ZXUuXPnXOZqr732qrD9nnvuSQsttFCZ0GSNNdZIw4YNyytAOnbsmB544IG0/vrrz5qjBwAAAAAAmBUhSDRCr65evXrlFwAAAAAAQJ1vjA4AAAAAAFDXCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQmr8e3/wjTfeSB999FFaYokl0lJLLTXDfV977bU0duzY1LFjx9ShQ4ff+ysBAAAAAABqZiXIxIkT08knn5xWWGGFtOmmm6bNNtssXXvttVXu/9Zbb6XOnTunbt26pQEDBqSVVlopbb755unbb7+tzq8FAAAAAACo2RDku+++Sz///HO6/vrr0//93//NcN9JkyblkGTeeedN77//fnrooYfSm2++mV5++eW0xx57VP9IAQAAAAAAaioEWWihhdJJJ52UV4L8lqFDh6YPPvggnXbaaWnuuefOn7Vp0yb17ds3DR8+PL344ovV+dUAAAAAAAB1ozF6rBSZc84509prr13m8+7du5duBwAAAAAAqHON0X/L22+/nRZddNHUuHHZXxHN0Uu2V2Xy5Mn5VWLChAk1dZgAAAAAAEBB1dhKkOgfMs8881T4PEpjNWjQYIbBxumnn55atGhR+mrXrl1NHSYAAAAAAFBQNRaCzDHHHGnKlCkVPv/ll1/StGnTUpMmTar82f79+6fx48eXvkaPHl1ThwkAAAAAABRUjZXDiiboL730UoXPv/jii9LtVYleIvECAAAAAACocytB1lhjjfTVV19VWMXxwgsvlG4HAAAAAAD404Ugu+++e2rYsGG66qqrynx+xRVXpIUWWihtscUWNfWrAQAAAAAAql8O66GHHkqTJk1KY8aMye/ff//99N///rd0dccCCyyQ/7788sunAQMG5Ff0AenSpUsaPnx4uuuuu9Itt9ySG6QDAAAAAADUmRAkVnZ8+eWX+e+bbLJJ+vrrr9PAgQPz+7POOqs0BAnHHXdcWmuttdKwYcPSv//979SxY8f0/PPPpxVWWGFW/ncAAAAAAAD44yHIkCFDqrV/t27d8gsAAAAAAKAQPUEAAAAAAABqkxAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKCQhCAAAAAAAUEhCEAAAAAAAoJCEIAAAAAAAQCEJQQAAAAAAgEISggAAAAAAAIUkBAEAAAAAAApJCAIAAAAAABSSEAQAAAAAACgkIQgAAAAAAFBIQhAAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAIQlBAAAAAACAQhKCAAAAAAAAhSQEAQAAAAAACkkIAgAAAAAAFJIQBAAAAAAAKKTGNf0LJk2alB5++OE0duzY1LFjx/SXv/wlNWwoewEAAAAAAP7EIchTTz2Vtt9++7TAAgukzp075zCkZcuWaeTIkalNmzY1+asBAAAAAIB6rsaWZEyYMCFtvfXWaZVVVkkvvvhi+s9//pNee+219OOPP6add965pn4tAAAAAABAzYYggwcPziWwjj/++NSoUaP8WfPmzdNRRx2VHnvssfTkk0/W1K8GAAAAAACouRDkgQceSHPNNVdabbXVyny+3nrr5T/vu+8+ww8AAAAAAPz5eoK89957adFFF63QBL19+/al26syefLk/Coxfvz40hJblDV18o+GhDrnz3CuOneoi/4M505w/lDXOHeg2OeP7x3qIucOOHfA907d+T6eNm3aDPdrMO239vidllhiiTTPPPOkl19+ucK2CEa22267dPPNN1f6syeeeGIaMGBATRwWAAAAAABQEKNHj05t27ad/StBmjZtmn7++ecKn0+ZMiUnM1Eqqyr9+/dPRxxxROn7qVOnpq+//jotuOCCqUGDBjV1yNTz1LBdu3b5hIneNYBzB3z3QN3kug2cO+B7B+o+12zMDpEzfPfdd6lNmzYz3K/GQpBIXkaNGlXh888++6x0e1XmnHPO/JrefPPNVwNHCWVFACIEgepz7sDv5/wB5w7MTr53wLkDvncokhYtWtReY/S//OUvuZfHO++8U+bzkmBk7bXXrqlfDQAAAAAAUHMhyJ577pmaNGmSLrzwwjLLUy666KLUoUOHtPHGGxt+AAAAAACgxtRYOawIOiLw+Pvf/55rwHXp0iWNGDEiPf/88+muu+7KAQnUFVF+7YQTTqhQhg1w7oDvHqhbXLeBcwd870Dd55qNuqTBtFieUYNee+21dNNNN6WxY8emjh07pl69ev1moxIAAAAAAIA6H4IAAAAAAAAUqicIAAAAAABAbRKCAAAAAAAAhSQEgXJUiIOqjRkzJt13333OE5iFfO+Acwdq0rhx49JVV12Vjj322PToo4/mzz799NP0+eefG3ioxOuvv55GjRplbKCavv322zR8+PA0ZcoUY0edIwSh3rrjjjvSU089Vfr+hhtuSC1btkwtWrRIl156aa0eG9TlEGSjjTZKiy++eDrppJPSxx9/XNuHBH8aX331VTrnnHPKPJRab7310hxzzJG6d++exo8fX6vHB3U5KDz11FPTDz/8kN9PnTo17bXXXqlp06Zp2WWXzQ+rgMrdeuutqWPHjmnfffdNp512Wnruuefy5++++27q2bOnYYNKvPzyy6lr165phRVWSOeee2768ssvjRPMZAiy1VZbpfbt26f+/fund955x7hRZwhBqLf/MB955JH5xjl89913ab/99sv/UPfo0SMdeuih6ZNPPqntw4Q6Z9VVV01DhgxJiyyySDrhhBPyTfWmm26abrrppvTTTz/V9uFBnXbKKafkwKNEPNR95pln8sPcuEE488wza/X4oK668cYb02uvvZbmmWee/D6+c6699tq0zTbbpGbNmqWDDz64tg8R6qTRo0fnoCMCkJi4Evc4Jf7617+msWPHprfeeqtWjxHqongmcPHFF6eGDRvm5waLLrpo2mGHHdLdd9+dg3igcvFM7ZZbbknLL798vrdZeuml86SvwYMHpx9//NGwUauEINRLjz/+eOrUqVOab7758vv7778/TZo0Kd17773puuuuS9tuu2268847a/swoc5p0qRJ2m233dITTzyRXnzxxXxT/dhjj6WddtoptWnTJh1++OHp1Vdfre3DhDppxIgR+aa6xG233ZaOOeaYdOWVV6brr78+3zAAM3fubLHFFnkV7wMPPJDDxK+//trQQTk333xz2mSTTdJ5552X2rVrlx/oTi9muU+/Mh74nwjd//73v+cVIY888kgOQKLEz+abb54WW2yx9M9//jN98MEHhgvKie+Z7bbbLpfQfvPNN1OfPn3SK6+8kvbcc888kfKAAw7I121QG4Qg1NtZUfHAtkRc2MRy1wUXXDC/X2WVVXLZH6BqnTt3TpdddlmuKT1o0KDUunXrNHDgwLTiiiumNddcM/373/9OP//8syGESr57YkbuRx99lB/k+t6B6l+3lZw7sRJkiSWWsIIXKhHXaGussUbp+wYNGlR40GtmLszYuuuum4YOHZq/i6KkXKNGjfLq3vju6datWw4b9XeDimIVSITwUWUl+lIttdRS+flBfC+ttNJK6cILL/QdxGwlBKFeWmihhUrrR8cFy8iRI9M666xTpk77AgssUItHCH8eEydOzL0MoqxciNlRcX7ts88++eImHvQCZb97YjZh8+bNc2gYfO/AzJ070c/gs88+c90GMyH6HcZM3KrEqt62bdsaS5gJ0Zcq7nlK+lMtueSSucLEjjvumNZee+1cchuoKKquxLkzYcKE/D4mtkQwcsghh+QS9bFSBGYHIQj10vrrr5+effbZXId91113TW+//XauK10itsVMdqBqMRN3l112yeUVjj/++Bx4RKAYS8OjxnTUcP/ll19yA3Ug5RIKvXr1yiWwoqfOlltumRo3bux7B2bi3DnuuONyg80opxCzb0sCxAhEYnZ71GsHytpss81yucUoKVd+Jcill16a+1FFbxCgctH/I86fWH0YoUc0Se/evXt69NFH8zOEL774Iq9+f//99/PKeCCVea7Wu3fvfI12xBFH5NA9+rrFJMm4fotzK6qx9OvXz7AxW/zvzhvqmVjlEY2Zon9BzNiIh1Grr7563hYpdKTU068MAX5d9REX+pdcckluUhszDOM8ipq5HTp0KB2mueaaK8+KijIlsVwc+F9j9N133z0vC49ycmeccUbpsMSNc9SXBiqKXlRPP/10uuiii/L3TjRFLxGlFA466CDDBpWICSr77bdf7qkT5UdiBnuLFi1yP53oBRLnT7wHyvrmm29y2Z54ffjhh/nh7YABA9Lf/va3XAK4RJw/e++9d5o8eXLukwj13ZQpU9KQIUPSxRdfnEOQWPkeFSIOPPDAtNxyy5XZN8LFCEii5w7MDg2mKV4IFZbqxez1qJELlBU3zGuttVa+kY4LmZ133jk1bdq0ymF6991388Oqk08+2VDCDHz11VelfamAmRcTV+KarWRVFVBW3O5H0B4hYsxcD8svv3w69thjU8+ePQ0XVCJWUMX5seGGG+agfauttsq9QKry5JNP5mbPhx56qPGkXovQsGPHjnnFbkyUjAlg8847b5X7f/nll7lyhJVUzA5CEKjkRqF800Dgf2LZajTZ7NKliyGBavrpp5/Sww8/nDbaaKMK2+6999603nrrpSZNmhhXqMSDDz6YS5XOPffcZT6PWYbt27fPfUOA3/4eCr5rYMaiVFyUwlpmmWUMFVRzcspLL72k1CJ1kp4g1Ft33HFHntVeIpaFR4mFWNIaNXKBihZZZBEBCPxO559/fg47KhOfR1kSoKIoMXLiiSdWCEDCxx9/nA4++GDDBjMhwg8BCPy2pZZaSgACv0M8T9NrirrKShDqpegDstpqq+XZg/PNN1/67rvvcp3PaLQZdQqjWVM0d9ZkE8qaMGFCev7556scllhFFf1AFltssTL1coH/lR+57bbbKr2pfvPNN3M93FdffdVQQTnRVDNWSkVT9Kp6vUWTzehDBVR+/RbfM7GaN+q1T2/llVfODZ+ByldPvf7662n06NG578f02rVrl1coAmXLy08/2biy5wVRTjuev3nexuymeC710uOPP546deqUA5Bw//3353+sYyZu1GSPm4M777wz1zAEfhU3ARtssMFMDUmUzLrgggvSX/7yF0MIKaX33nuvyov9+Dy2AxXFuTGj3gWxSvH9999PnTt3NnxQzplnnplOPfXUPOmrMuedd17q06ePcYNKKkcccsghOQCpTPRGjN4hwK8+//zzmX5eEBOQzz333LTpppsaQmYLIQj1UlzItGnTpvT9I488krp27VralHaVVVZJY8aMqcUjhLopLlRiJnvcUK+00ko54GjevHkuRzJs2LC07rrr5hlRsZLqqquuyr0PXnjhhbT00kvX9qFDrWvVqlV68cUX0zrrrFNhW9TOjdnsQNXnTvfu3Sts+/7773NI4vyBimKCV79+/dK+++6bGzvHKt2GDctWxI6eOkBZY8eOTbvuumu+Zjv77LPzqo/ypeR870BF8T0zYsSIdM455+RJXhGIxLkSKxFvvPHG/FwgQo9YwTtkyJDUo0eP9Oijj+bncVDThCDUS9E8M2a0lzRCHzlyZC5DUmLcuHF5ViFQscZnzHg65ZRTUrdu3cpsi5lScR7FTXb8efjhh+d6oBdffHEaOHCgoaTe22yzzdJhhx2W7r777jJNnONG+9BDDzULCmZw7vTt2zdtvPHGOYAvEat4DzjggFzONB5QAWU9+OCDabfddktXXHGFoYFqiHI+ERDGNVujRo2MHcykKI19zz33pH322Sf16tWrzLYDDzwwh/IhnhXEKsStt946PyuwqorZQWN06qX1118/9wPZa6+98gyPt99+O22zzTal22Ob+p5Q0SeffJLPj/IBSIiZhXvvvXcaNGhQft+4ceN00EEHpVdeecVQQkrp+OOPzysRo/b6tttum5s5x5/xADdWH0bjZ6Ci3XffPTepXXXVVXMQEjfRcf0W59INN9yQzj//fMMGlZh33nn1+4Dfee507NhRAALVFBNU/vOf/+TrtMrsv//+pRMkoz9ITBDzvIDZRQhCvRTL8QYPHpweeOCBdNddd6UTTjghrb766nlb/AM8fvz4SsuVQH335Zdfph9++KHK7VGWJPaZvoRJzAYB/tdAM2YWbrLJJrlEyUUXXZRnSsUs91GjRpnJDlWIEiT33XdfDtajLNYll1ySbr755vxwN2a6V1YmC/hfz4KHHnoo/fLLL4YDqiFK/H711Vd5tS4w87799tv8TCD67FbG8wJqU4NpUQsIKJNcx43CPPPMY1SgnAhAooxPBIf/+Mc/ymyL8CNWWUUfkJLZHWeccUb+mZNPPtlYQiXn09xzz51nQQEz78cff0xNmzat0NsAqPg9E2V/o59blCCJWuzlJ6fEjPc4n6A+++mnn9KECRPKfBb9puJeJkr6RM/QKAs8vTnnnDM1a9ZsNh8p1G1Tp05Nbdu2TT179kxnnXVWmWu1OMc233zzvL2k/NU111yTHn/8cWUbmS2EINRrkULffvvt6a233sorQaKXQfQDiRuGxRZbrLYPD+qk8847Lx1xxBGpU6dOZRqjx6qq+HuUy2rTpk2aOHFiboQWs3XjQgcAgNkn6q3/Vrm4uK6L/aA+iweyVZXvmdFKK30MoKKhQ4fmflSLL754Wm+99XIlliirHT12Yh5+rIxfdtllc2ASq3kvuOCCtMIKKxhKapwQhHrrscceS9ttt11p6Z6oRRiz1z/44INcmiQap5thCJW78cYb09lnn52ef/75fPEy33zzpR49eqTTTjtN4AH/34cffpj/7NChQ5n3M1KyL9Rnn332WZo8eXJaZJFF8kzbkvczUrIv8KsoF/fcc8/NcEg23HDD3G8H6rOYFDl8+PBq/Uw8xN1yyy1r7Jjgz+y///1vOvXUU3PgEaWxYtVhlASOz5ZZZpnaPjzqKSEI9XYFSDSijdQ5yvqMGDEiz2QvKeGzxRZb5FAkmm8CVYsLmngwpXwcVFRS5qqk8ujMlL1SpRRS6tq1a+6T8+STT+a/l7yfkZJ9AQCoG2LCZFSIUAKYuqBxbR8A1IZoSBvleoYMGZJXezRq1KjM9hVXXDHfTAtBoGrRnDYeSkX5uGj4HKHi/PPPb8jg/7viiitm+B6o3DHHHJOb0caElenfz0jJvgAA1L433ngj9/uIXiALL7xw6tatW2rdunVtHxb1mBCEeunTTz9Nq622Wmm5q/Kzc2NWe6wWASqKi5iomRs9QKYXS1wvueSSXP8TSLkJ7YzeA5WLHm0zeg9U7uuvv87XaVF/Pfq0lbyfkZJ9gYqi1+HFF1+cXnjhhdw8PXoc7LLLLrnp88ys8IX6KM6VvffeO/cGmV6ULT3zzDNz1RWoDf97Agz1TMuWLdObb75Z5fa4yNHIGSp30EEH5ZVSJ510UnrkkUfSyy+/nO644460/vrrp7322ivfLAAV3XfffX9oOwDMSFybdezYMf373/8u835Gr5J9gbLi3IgyizfddFOuHBGBYfTYiQlf0RRdCVOo3LHHHpufD/Tr1y/3pnrllVfyBMroydunT5/cIB1qg54g1EtRUqF9+/a5B8gBBxyQBg0alN577738Pv5x3nrrrfPSvSWXXLK2DxXqlPHjx+cQ8bHHHktrrrlmhe0xKypWhFx++eW1cnxQl8WMwRndMP/WdiDlPlTjxo2rcK4stNBCqUmTJoaIei0a0L766qtprbXWSp06dSp9PyMl+wK/+uqrr3K531jFG42cmzVrlj+P754bbrgh7bnnnunaa6/Nq0KAX/3yyy9pwQUXzKXne/ToUWFojjjiiPTuu++mO++807Ax2wlBqLfOPvvs9I9//COtsMIKaa655spL9uIf60iqjzzyyLwdqLhKKmY+vf3225UOTYSIZ511VnrooYcMHVQj5IjvoGgYOGXKFOMGlYhyJOeee256//33Kz2PNEYHYFYZMWJE6tu3b3r99dcrLXsVzxGi3NyVV15p0GE6n332WVp22WXTt99+W+m58/zzz+eJkzOqzAI1RU8Q6q24qFl00UXzA9so3xM31LEk/LzzzlOjEKoQgWHMjIrzpbKLmi+//DLvA/zPmDFjZvi+ZGb7yJEjc8NAoPIA5OCDD06bb7552mOPPXJJkvLiGg6ofAJLNKJt06ZNmc9jJm7M2F1mmWUMG5QTvQs6dOhQZd+PJZZYIv3444/GDcqJZwFxbsQreu2W53kBtclKEEgpz7yNV9OmTY0HzMDUqVPTIossknbfffd0xhlnpMaNf83SP/7449wXJJaNH3PMMcYR/v/qj5l1/PHHpwEDBhg3KKd79+5p3XXXTSeccIKxgWqI0nF/+ctf0jPPPJNatGhRZlusqtpqq63yrFyl5KCsiRMnpjXWWCPdf//9udzi9GIyWJw7Rx99dFpnnXUMHZQT1VZWW221dNlll+VAcfoAZOONN87XdBdccIFxY7azEgTiRGjcuMzDXKByDRs2zOFH79690y233JLWXnvtfFP90UcfpXvvvTe1bds2HXjggYYP/r/oOVXikEMOKfO+RMySipuF1Vdf3bhBFbMKo28BUD233npr6tatW4UAJCy++OL5uu2RRx7JQSPwq2iEfuGFF+Z7nijd06VLl/xdFCuoogRWnDNR8ieCxhLxsLekdwjUZ2eeeWYOCu+555603nrr5bLzn3zySX4f/UOjnBzUBitBSPV9hkfU+Yx/kKMe+/SWWmqp1Llz51o7NqjLbrvtthyGPPfcc7mUwvzzz5+23nrr/FmUXAAqOuqoo9K//vUvQwPVNHTo0DRq1Kh0/vnnGzuohpipHg9ljzvuuEq377PPPnm2+/77729cYTrXX3992nXXXas1JtE3MX4OSHkVVaxwj55tUXUlvos222yz/LxACVNqixCEeuuaa67JCXQsyavMYYcdlgYOHDjbjwv+TCIAiX4G0dAZAGrKaaedlj7//PO0yy67pPbt21dYwRuzDOeYYw7/A8B0Inh/6qmn0s0331zpuES5kghKdtxxR+MG03nrrbfS8OHDqzUmsTJkyy23NI5Qrpx2TD6urD8IzG5CEOrtRc3yyy+fttlmm9SrV6/cKLD8zXTMZm/Xrl2tHSMAf24ffvhh/jMaa07/fkZK9gXKuvHGG1Pfvn1z/6nKxEzDrl27GjaYzquvvppXtg8bNizttNNOZXoanHPOOXmFyOjRo1OrVq2MGwBQaJogUC89/PDDuUlg9DQAqharPD777LNqDVHUw43m6VDflSz1jodN07+fkZJ9gV9FeZGYtBLNNPfcc8+0wAILVBgeASJUFP2m9ttvv1ymJ1aFRCASZUmiUfprr72Wy5IIQAD4veI7ZcyYMdX6mZiAHD2pYHYTglAvRTOmJZdcsrYPA+q8F154odrNaNdcc81cegHquyuuuGKG74GZc+2116Z//vOf6cQTTzRkUE0XX3xx7nV40UUX5YbOJeFInFd77LGH8YQqTJo0KZ166qnpgQceSJ9++mmFiSo9evRIgwYNMn7UaxGAVLfHx2KLLTZTK+RhVlMOi3pp/PjxaaONNsoXNBGIAJWLnjl33HFHtYZnoYUWSltttZUhBWCWiBrrhx56aF4JAvyxFb4NGzbUPwdmQjRxjlVTsdIw7omWWWaZ9Prrr6evv/46fy+ts846+bsJ6rPvv/8+r9itjmiSHisUYXYTglBvZ3U8/vjjeWbU3nvvnWdDlQ9D5pprLs2bAABq2dChQ9Ozzz6bzj333No+FADqgXfffTd16tQpvfHGG+npp59Ot99+e37Q+8svv+RVVFFW+7bbbktNmjSp7UMFYCYph0W9dOmll6bDDz88//3WW2+tdJ/DDjssDRw4cDYfGfx5vPjii2nUqFHphx9+SO3atUvdu3dP888/f20fFtQZv2eZt74GUNEWW2yRH0T16dMn9ezZM7Vv3z7Xk57efPPNV+EzqG9ihvqECRNy35zmzZuXvp+Rkn2BX8WKj7XXXjstvvjieTXI1KlT8+eNGjVKvXv3zj11Igz529/+ZtigCnHtFpOP43to4YUXTt26dUutW7c2XtQadwrUS3/961/T2WefPcN9unTpMtuOB/5M4iJm1113TXfddVeZz2M11SWXXJJ22223Wjs2qEuqWx83aIwOFW2yySY5dA/nn39+pUP05JNPpq5duxo+6rWTTjopnyPnnXdeDg1L3s9Iyb7AryZOnJhatWpVWiEiymFNLypJxMNdIQhU9NNPP+WKK7GSd3pzzjlnOvPMM/OEY6gNQhDqpVVXXTW/gOo76KCD8sOmuLFef/318+zbDz74IDd93muvvdKyyy6bVlttNUNLvacROswaUXM9mtL+VpNNqO922WWX/HB2rbXWKvN+Rkr2BcpOSmnQoEH++9JLL51Xg0QQUhKMPPjgg2nBBRc0ZFCJY489NvcV7devX57I0rJlyzR69Og0ZMiQHLrHORU9d2B20xMEgJk2fvz4fBHz2GOPpTXXXLPC9ihTEitCLr/8cqMKAAD86UT/j5I+ICEmeEUIsummm6b3338/3Xfffenhhx/OFSaAX0XfnAgII/Do0aNHhaE54ogjcs+dO++807Ax21kJQr0p3xM1caPebdS9LXk/IyX7Ar+Ki/4o8VNZABKiFNZZZ51lyGAGPvroo/TQQw+lcePG5VAxVlSZxQ6/7ZtvvskPnmI24TzzzJO/i1ZeeWVDB8AsFeHGMsssU/r+pptuSvvvv3+67rrrUps2bdJVV10lAIFKjB07Nq+k2nLLLat8XhATJ6E2CEGoF/7973/nRuglzc5L3s+IxuhQUdTE/eqrr8osEZ9ezJCKfYCK4rw56qij8vdQSYPNkiabMStKgAhViwa0UY7xhx9+KPN53GQPGzYsr0KE+i5m144ZM6ZaP7Pkkkumtm3b1tgxwZ9RBB3xKhGTwO65555aPSb4M4hnAT/++GN+xYSV8jwvoDYph0W98Nprr+UeBlETN5pmlryfkZJ9gV/Fg9tFFlkk7b777umMM85IjRv/mqV//PHHeUb7vvvum4455hjDBuVcdNFFuQ5unCPbb799WnjhhdMXX3yRbrnlltw/5IILLkh///vfjRuU8/TTT+e+BZtvvnluQhsPo7799ttciuScc85JW221VQ5JoL6L75jfaoRensboUNGNN96Yz6coAbz44osbIqiGeJYWJeQuu+yy3Ax9+gBk4403Tuuuu26+74HZTQgCQLVcffXVqXfv3qlDhw5p7bXXTi1atMjlfe699948k/C5557LzdKBijcEUUrhkEMOqTA0cSNw5ZVXppdfftmwQTkRHMaMwqFDh1YYm6eeeiqXJInyclHKFOqzN998M3344YdlPnvrrbdyr7add945LbfccmnKlCnppZdeSsOHD8+rEzfccEMlGaGcaHweE77+7//+z9hANY0cOTJPUGndunVab731co+QTz75JK+mipW78bzACkRqgxAEyqmqzA/wq9tuuy3fGMQFTDQ/m3/++dPWW2+dP4uLHaCimAn12WefVdpvKvpURdmFSZMmGTooJ26gjz766LwSpDJLL710nrWrPwiUFd8522yzTbr77rsrfPe89957qVevXnlF1fQzdYGUfvrpp7T66qvnECRW7gLVc//996cBAwbkCiwRvjdr1ixtttlm+XlBrOiF2tCwVn4r1AF33HFHnj1Y4oYbbsgNamNW+6WXXlqrxwZ13bbbbptGjRqVJk+enOuzxwPcWCEiAIEZ18iNZeCVUR8Xft+5E5NXoleVflRQUaye6t69e6Xh+xJLLJHL/MSMXaCiCy+8MO2zzz5p8ODB6fXXX8/fQ7HqsOT13XffGTaoQrdu3dIjjzySnxd8//33acKECfmZmwCE2iQEoV6KOtJHHnlkWnbZZfP7uIDZb7/9Uvv27VOPHj3SoYcempfrATMWDZ3nnntuwwQzYZ111smlsOImYHrxHXTYYYfl+rhA5efOiSeeWKHMT6xE7NevX5pjjjnSUkstZeignHhoG5NVqhIPpqoKGKE+u/XWW3OpxbvuuivtueeeqVOnTmmhhRZKrVq1Kn1Fjypgxho2bFhpg3SoDb92tIV65PHHH88XMiV9C2KpXpQgiZ4GUa8wluvdeeedGtRS78XMjSilEGUSoiF6yfsZKdkXKOukk07KfXQWW2yxPDO3pDH6fffdl8+t+G4CKjrooIPSVVddlctebbTRRrknVYSJcc588MEHuSl63GQDZUWJuOhFFQ9xV1lllTLb4uFulMk67rjjDBuUE+fL2WefPcNxKZlQCcy4T1UE7tOLUCRKY8HsJgShXho9enSuvV4ilul17do1ByAlFz1jxoypxSOEuuGFF15Ia621VlpzzTVz+biS9zNSsi9Q1qqrrpof2sYDpxEjRuTwvWnTprkp7amnnqqfAVQh+k498cQTqX///rmcaTy8jZWIXbp0SQMHDszNN4GKdthhh1zSZ7XVVsvhezy0jRVU0Rj9scceSz179kxrrLGGoYNylllmmfwCqu+VV15Je++9d+4fWpmYEFZ+dS/MDkIQ6qVYyhp1PUtqSUct3LhJKBE1Ps1kh//Vi77iiivyOTP9+986v4Cqg5B4gBvfPT/++GMuJ9egQQPDBb8hrsuuueaa/Pc4d2LVYQQhQNUaN26c7rnnnnTKKaekIUOG5L+HKB8Xs9wPP/xwwwfALLXrrrvme514bhCreMuXz45rOKgNDabF/zOhnokmzu3atUs77rhjnokbDZqefvrptPrqq+ft66+/fr5ZiBrUAAAAf3Zx3xOl45o0aVLbhwJ12tixY0snTVYmJrBESZ+YIBarFYFfz52YuBIltE2OpK6xEoR6aYEFFkiDBw/Os5+iSfoJJ5xQGoDE0r3x48cLQKAK0cMgSspFaYXpxczcUaNGpQ022MDYQRW++uqrdMEFF+ReVPH3li1b5nJY0Rg9vpuAGX//vP322/kGu/w8rjiPnENQuVjlHqXk3n///bTpppumddddN3366ac5EIn+VEBZDzzwQJ7NPjPi3ueiiy5Kyy23nGGk3otVH9F7VwBCXWQlCFQyQypq5cbMDqCi7bffPvXq1Sttt912FbbFKqrobRDNn4Gy3nvvvbTeeuvlmVGxNLx169b5oe5bb72VFl100dyfqmPHjoYNKrk2i+bo0QA9rtEq8+STT+b+bkBZt956a26MXtKY9rzzzkt9+vTJ3zknnnhiftgLlPX555+nBx98MJeNi5AjeobONddc+Vpu6NChaaeddkqLL754euedd9Lll1+efvrpp/TGG28I4yGltPPOO6dDDjnExGLqHCEIADMtVknFQ9ooKVeZqNcejTavvPJKowrlRPPmWEU1bNiw3Jy2RNw077LLLvncuv32240blHPyySenM888Mx155JHpL3/5S1pwwQUrjFHMwDWBBcqK75zo//H3v/89HXHEEelf//pX/q6JECSssMIK6ZZbbtEAGsqJ1YbdunXLq3fjPCkfzG+22Wbpsssuy5NaJkyYkEOSeOhbcm5BfTF16tQKzwYidO/fv39edRiTJMuvComebsrIURuUw6JeiuXfsRx8RmJWrhm5UFacN23atJnheRMzpICKYrbto48+WiYAKXl4e/XVV6e//vWvhg0qEbNxIwSJ1SDAzLv55pvTJptskld/hCh/Nb14uPvUU08JQaCS1YXR96N8ABKaNm2aV8THpK+zzjorNW/ePPXu3TuX1Yb65uOPP67yudn1119f6eeLLbZY+vDDD2v4yKAiIQj10o033pj7gcxI1GcfOHDgbDsm+DNo1apVevfdd/PsjnnnnbfC9pdeeskycKjCnHPOmUsnVCYaa8ZNNVBRfN8sueSShgZ+x8SvNdZYo/R9PNSdXqyeip5uQFnRe+qHH36ocljiXujLL78sc48U5U6hvol+bFE2rjpatGhRY8cDMyIEoV7aeuutK9xMT5w4Mb355pvphhtuyDMNo247UFbbtm1zWYUDDjggz36a/qHtyy+/nE477bQ8WxeovD7u8OHD02677VZhWzSs7dmzp2GDSuy111753IkZ7cDMa9myZXr11Ver3P7iiy+mbbbZxpBCOSuttFJ65plncgnT8g3SY9V7lMk6+uijSz97/vnn0+qrr24cqXdiJdRRRx1V24cBM0VPECgn6hluu+22+YHUfPPNZ3ygnPvuuy/XwY2mzlHnM+p5xuqQKPXTpUuXXO6nSZMmxg3K+eSTT9I//vGPXD+6R48epY3R77zzzvT222/nWVSxWqT8Ayyo76If1aBBg/LM3AgR27dvnxo3LjuXK67Zyn8G9V1MUIlrs9tuuy1tueWWua9Ou3btct+CSy+9NH8nRd8Qs3Kh8soQEXasueaaZRqj33333XlS2NNPP51XU8V30xZbbJFLN1a2Uh7qm2+//Ta99tprae211y7z+S+//JLuvffetOmmm9basVG/CUGgEv369cu9DaK5GVBRBB3HHXdceuKJJ9KUKVPyEvCYJXXKKaekZs2aGTKo7KKrXBmSmW3MCfVd165d06hRo36zfnvsB5QVK9wvvvjiXBYryvtE4BGNbKMXyIUXXqjXDszgGizCwjhP3njjjfw+GjzvtNNO6aSTTtLYGWbwvdOpU6d04IEHVtgW588uu+yS++rA7CYEgUocccQReSb7GWecYXxgBuImetKkSWnuuec2TvAb/vWvf1V7jCwvh5SGDh2aexvMSK9evdIiiyxiuKCceHAbK6kuuuiivOowLL/88unYY49VhhFm0s8//5xf7nngt58PRKWI6JFT2fny3//+NweLI0aMMJTMdkIQKLds7/bbb8+J9RVXXJFvqIGq60jHzNyYVRilFbp3725GFABAHfXTTz/lP5UthZkXK9/jvifOn44dO6aNNtpIGAJViPBjxRVXTOPGjat0+yuvvJJXg8TqKpjdFM6lXorkufzs2kisY3ZHiJq50cAWqGjChAm59NVdd91V5vOogXvJJZdU2vQZAP6ob775Jvelih4GUYc96rSvvPLKBhZmkvADZl6sQIySPeXLMUYZ4Ouuuy6HIUBZsQokermNGTMmtW3btsLwvPTSS2mBBRYwbNQKK0Golx5++OHcIHB6jRo1Sm3atMk31Ouss06tHRvUdbvvvnsaOXJkOvzww9P666+fm9F+8MEHefVUNAqMGtOrrbZabR8mAAVy7bXX5hrTsfpwejFxZdiwYZrRwm+IhrRffvll7uU2vbiO08wZKlp33XXT+++/n/7xj3/knjpR2idKyp1//vl5Zcibb75Z6UNeqO8iIJxjjjnS9ddfn5o3b176eZxP8fzgb3/7W/rnP/9Zq8dI/SQEAWCmxayOli1bpsceeywHhuX17Nkz30hffvnlRhWAWeLpp59Oa621Vtp8883zjXOUI4kSpjGp5ZxzzklbbbVVDkmAVGn99RNOOCE999xzOQgp77zzzkt9+vQxdDCdV199NX/vxKz1xRdfvMzYRJC44YYbpk033TQdc8wxxg3KeeGFF/LE4li1G6FHrJ766KOP0r333ps6dOiQnnnmmTLhCMwuQhAAqnVBE6XiShprlhclss4666z00EMPGVUAZol99903/fjjj7lBenmx+vCvf/1rrj3thhrKigdNXbt2Tauuump+YBsPoho2bFhhtnvnzp0NHUwnqkZEmd977rmn0nG5+OKLc0B/zTXXGDeo4rlB//7904MPPpj76cSqw+233z6dccYZeVIl1AY9QajXYgZhzFiPmR7RE2SppZZKe+21V55RCFQ011xzpa+++ipNmzYtNWjQoML2KLMQ+wDArPLOO++ko48+utJt8YA3ZhVGiQX9QaCsO+64I4cfI0aMqPS6Dahc3M/EfU1V3PPAjK2yyip5JWI8N5g4cWIuJwe1rew0EKhHIoGOpXkxc71p06Z59mCU+Nl6663TwQcfXNuHB3XS0ksvnRo3bpz69u1boab0xx9/nAYMGJBnFALA7HgYFTfXEc4L4KHycyfKlwpAoHpWX3319Prrr+f+H/E9M72XX345XXDBBe55oBJRrnT48OGlzwri+0cAQl2hHBb1dkbhsssum44//vg8szBCkBD/UEdz5whB7r///hySAGVdffXVqXfv3nnm7dprr51atGhRWuMzmgNGzelY7goAs8Ipp5ySrrrqqlxSIb57SkR/g6jHHv1APv300wplfqC+i8bN+++/f3rggQdSo0aNavtw4E8leumcdNJJafnll8+hSISK8RwhvotWW2219Pjjj+fJYcCvPvzww9y7bZFFFkl77rlnfm4QFVegLhCCUC9deeWVaciQIbkcVmX22GOP1L59+3zTDVReJzdWU5U02Zx//vnzKqr4rHXr1oYMgFnmm2++yT0NPvnkk7TRRhvlIGTChAn5AdQHH3yQQ5C4dgMquv3229ONN96YS/7Gg6jyq6ZiNbxZulC5mCAZq0FiVUisCIn7nF133TWHI82aNTNsUE6UmY/vneibEwF8nDfRu22fffZJO+ywg+8bapUQhHopApD4BzlmtFcmSvrEbKnjjjtuth8b/JlEADJ58mQXMwDUqM8++yw32IweB1FqIa7TunTpko499li93GAGRo0alQ499NDcxLky5513XurTp48xhBn4+eefc9UIpRdh5r399tvpkksuyZNVYkJLhO4RIkYgEqurYHYTglAvRV3pmEkYPUDmnXfeMtvi4maDDTbIsz6iZBYwc6pqlg4As9KPP/6Y5pxzTuV9YCbKYUVz2ijns/HGG6dWrVpVKBu33nrr5X2AiiZNmpT7G7z66qu5N2KvXr3S+PHj8/OEJZdc0pDBTIjG6MOGDcurQ6KSRFhxxRXTfvvtl8tlWY3I7KKAIfXm4uX7778vfR8PaqPUVc+ePfPS8JVWWinfSMeNQoQf++67b2rXrl2tHjPUVS+88EKuh7vTTjuVvt95551z/c84dy666CJhCACzVNRgjwbPcaM8/c3ys88+m0uYLrTQQkYcyrnhhhtyj8O77rrLtRlU0yuvvJJ69OiRex+GuN+JECTK/XTv3j298cYbVobATD6Pi/AwSpmGNm3a5BKnhxxySDrrrLPSyJEjcygCNU33QOqFSy+9NM98mv4VFzQxq2P77bfP9XEXX3zxtPnmm+deBxGMRHkFoKIDDzywTGPaeB+zcqPxWZSai/MKAGaVWLl74oknVjpT8OOPP04HH3ywwYZKxCSvtdZaSwACv6Pkbzwn6NSpU3r55ZfTf/7zn9Jt0QuxW7du6aabbjKuMAMxUSVWeiy66KLpiCOOSG3bts3nTQSLUeZ0xIgRacEFF0z9+vUzjswWVoJQL0QjprPPPrtaPxN1poGyvv7669yEdo011sjvP//88/TUU0+le++9N8+IinILt9xyi/rsAMwy//73v/NNdGW22267vArxu+++06QWyokmtAcddFCeuV6+DBZQteihE7PXb7311lx+MRqjTy9mrT/55JNpjz32MIxQrrx8TIyM0lcRgkQfkOgBEhMnl1tuuTJjtcUWW+SAJL6rYHYQglAvrLrqqvkF/DEx43aRRRYpff/II4/kmblRaiFETemY0QEAs8p7772XS5hWJb6X3n///dS5c2eDDtOJ8r5777132n333fNDqFj9Xr6xc/RHbNq0qXGD6Xz66af5OyUCkFC+7+E888yTV8IDZY0ZMyZPXImgMIKQ+P4p34d3ehGCbLbZZoaR2UIIAsBMi5rr8aBp8uTJ+aYgSl917do1NW78v6+TcePGpQUWWMCIAjDLRBnTF198Ma84LC96vkVI4rsHKoryvueff37++9ChQysdovPOOy/16dPH8MF0WrZsmd566600bdq0SsvJRU/EKO0DlBXl4h5++OFcjWVmr/EGDRpkGJkthCAAzLRoYlbSPydmd1x//fXp3HPPLd0eS16jcS0AzCoxQ7Bv375p4403TiuttFLp51Gq5IADDkhLLLFEnvEOlLX11lv/5oPamX1QBfVJ3M989dVX6eSTT07//Oc/ywQhUQr46quvTg888ECtHiPURS1atKjye6WqUBFmlwbT4v+FADCTojlg1L+N2VFbbrlluu6661KTJk3SxIkT07LLLptnRpmRC8Cs8tNPP6V11103Pffcc2nDDTdMSy65ZPrmm2/So48+mr744ot09913V7pKBAB+r8GDB6e99torf+e0bt06f99E6H7fffelXXbZJfc9ACp69913c9nskn5u8T76frz66qtpxx13zOfWHHPMYeiY7YQgAMyyJmg//PBDnv0BALNSND4/7rjj0rBhw9KXX36ZyzCuvfba6ZRTTknrrLOOwQZglhs5cmReDfLMM8+kqVOn5lXx+++/fy4116hRIyMOldh2221zP6qtttqq9H1MXNluu+3Srbfemk477bS03377GTtmOyEIAADwpxHNaKORc8OGDWv7UACoB3755Ze8KnGuueaq7UOBOi3CwpgUGeXkolpElC6NPiFXXHFF2m233fJklmuuuSb93//9X20fKvWQOwcAAKDOe+edd9IFF1yQTjrppDRmzJj82dtvv51XiQBATYlVHwIQ+G1jx45N8847bw5AwtNPP50mT56ce4qGVVZZpfQaDmY3jdEBAIA67cQTT8wlSWKGYdhmm21S+/bt0+23356+/fbbXFoBAGbVg9zXX3+9yu3R3HmeeebJPUJiljvwPy1btkxff/11GjduXP778OHD03LLLVfaMzQ+1z+U2iIEAQAA6qw777wznXnmmWnQoEFpp512SltuuWXptqjNvvTSS+feIMpjATArPPDAA2nXXXedqX032GCDdNFFF+UHvVDfRc+2OCfiWu2vf/1rPjcOP/zw0u3PPvtsWnPNNWv1GKm/9AQBAADqrJ133jmtvPLKqX///vn9Wmutlc4777zUtWvX/L5Dhw65tvQyyyxTy0cKQBF8/vnn6cEHH0xnn312fqAbJXyiHNZ7772Xhg4dmgP5xRdfPJdpvPzyy3O/kDfeeMMMd0gpvf/++7n/xwsvvJCDkJtuuik1b948r+Zdfvnl08iRI/MqKpjdrAQBAADqrE8//TTtt99+ZcqQTC9KkkSzdACYFVq3bp0bOQ8ePDitsMIKZbYdeuihabPNNkuXXXZZ2mWXXdJhhx2WQ5LYt0+fPv4HoN6LgPCJJ56odByefPJJJeSoNRqjAwAAdVbUlH7zzTcr3TZhwoQ843DRRRed7ccFQDHFg9oI3MsHIKFp06Zpu+22S1deeWV+HzPce/funV555ZVaOFL484iypXroUJuEIAAAQJ0VM25PPfXUXGpk+pUgU6ZMSUceeWRaaaWV0kILLVTLRwlAkRqj//DDD1Vu//7779OXX35Z+r5Vq1a5XBbwP6NHj87XaFG6NEpgbbjhhulf//pXmjhxoiGi1ghBAACAOmuvvfZKiy22WO4LstFGG+Wa7BGKdOrUKQ0ZMiT3BwGAWSXC9WeeeSYNGzaswrb4DrrgggtS586dSz97/vnnc0ksIKWnn346r6IaNGhQDhNjosrHH3+c+vbtm5uif/3114aJWqExOgAAUKfFTfTxxx+frrvuuvTFF1+kRo0apbXXXjudccYZuVE6AMxK0esjwo54aDt9Y/S77747LbXUUvlBb/SkilUjW2yxRW6kPu+88/ofgXovQsToq3P11Ventm3blo7HqFGj0vbbb5922GGHNHDgwHo/Tsx+QhAAAOBPI0opNGnSJAchAFATpk2bli699NJ04YUX5nKM8T5mtO+0007ppJNO0tsAKjFu3LgcgEQ4uOCCC1bYfuutt+ZJLa+++qrxY7YTggAAAABAJX7++ef8mnvuuY0PzMCECRNShw4dqix59dJLL6V99tknPfvss8aR2U5PEAAAAACoxBxzzCEAgZnQvHnz3Az9scceq3T7HXfckXr27GksqRVWggAAAAAA8LtNnTo1vfvuu+noo49O6623Xtpwww1zWaxPPvkkXX/99WnSpElpwIABqUGDBqU/E+VN559/fqNOjROCAAAAAADwu3344YepY8eO1fqZxRZbLP8c1LTGNf4bAAAAAAAorAUWWCCdffbZ1fqZFi1a1NjxwPSsBAEAAAAAAApJY3QAAAAAAKCQhCAAAAAAAEAhCUEAAAAAAIBCEoIAAAAAAACFJAQBAAAAAAAKSQgCAAAAAAAUkhAEAAAAAAAoJCEIAAAAAABQSEIQAAAAAACgkIQgAAAAAABAKqL/B8IeNbfHYoL7AAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -84,14 +131,20 @@ }, { "cell_type": "markdown", + "id": "cell-5", "metadata": {}, "source": [ - "## Optimise and train Multinomial Naive Bayes classifier" + "## Optimise and train Multinomial Naive Bayes classifier\n", + "\n", + "Each paper may have several accepted labels. We expand it into one training row per label for this single-label classifier, but keep all rows with the same paper text in one cross-validation fold using `GroupKFold`. The final train/test split was already made by paper in Part 1, before expansion.\n", + "\n", + "The search uses macro F1 on the expanded single-label validation rows as a training surrogate. This differs from the top-1 hit rate and fixed-target multilabel metrics used to evaluate the deployed label sets in [Part 3](https://great-ai.scoutinscience.com/examples/simple/deploy). Rerun the search to obtain results for these grouped folds; the previous ungrouped outputs have been removed." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, + "id": "cell-6", "metadata": {}, "outputs": [], "source": [ @@ -111,14 +164,15 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, + "id": "cell-7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Fitting 3 folds for each of 24 candidates, totalling 72 fits\n" + "Fitting 3 folds for each of 8 candidates, totalling 24 fits\n" ] }, { @@ -161,622 +215,239 @@ " \n", " \n", " \n", - " 7\n", - " 14.549476\n", - " 0.361685\n", - " 8.476837\n", - " 0.222398\n", + " 2\n", + " 0.002468\n", + " 0.000398\n", + " 0.001431\n", + " 0.000171\n", " 0.5\n", " False\n", - " 0.05\n", - " 20\n", + " 0.9\n", + " 1\n", " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.518061\n", - " 0.514842\n", - " 0.511599\n", - " 0.514834\n", - " 0.002638\n", + " 0.455431\n", + " 0.434571\n", + " 0.423547\n", + " 0.437850\n", + " 0.013221\n", " 1\n", " \n", " \n", - " 10\n", - " 11.235289\n", - " 0.130426\n", - " 4.092868\n", - " 0.082518\n", - " 0.5\n", - " False\n", - " 0.1\n", - " 20\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.513897\n", - " 0.515661\n", - " 0.507867\n", - " 0.512475\n", - " 0.003337\n", - " 2\n", - " \n", - " \n", - " 19\n", - " 7.383645\n", - " 0.138110\n", - " 4.130709\n", - " 0.250048\n", - " 1\n", - " False\n", - " 0.05\n", - " 20\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.496825\n", - " 0.501045\n", - " 0.496854\n", - " 0.498241\n", - " 0.001983\n", - " 3\n", - " \n", - " \n", - " 11\n", - " 10.435154\n", - " 0.305144\n", - " 3.882101\n", - " 0.128886\n", - " 0.5\n", - " False\n", - " 0.1\n", - " 100\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.493247\n", - " 0.497814\n", - " 0.502245\n", - " 0.497769\n", - " 0.003674\n", - " 4\n", - " \n", - " \n", - " 8\n", - " 13.643193\n", - " 0.310696\n", - " 4.173707\n", - " 0.142980\n", - " 0.5\n", - " False\n", - " 0.05\n", - " 100\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.489609\n", - " 0.495207\n", - " 0.498154\n", - " 0.494323\n", - " 0.003544\n", - " 5\n", - " \n", - " \n", - " 22\n", - " 7.048340\n", - " 0.050070\n", - " 3.172948\n", - " 0.152418\n", - " 1\n", - " False\n", - " 0.1\n", - " 20\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.487456\n", - " 0.493865\n", - " 0.491157\n", - " 0.490826\n", - " 0.002627\n", - " 6\n", - " \n", - " \n", - " 23\n", - " 7.564685\n", - " 0.146092\n", - " 2.374111\n", - " 0.285026\n", - " 1\n", - " False\n", - " 0.1\n", - " 100\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.485160\n", - " 0.494039\n", - " 0.490127\n", - " 0.489776\n", - " 0.003633\n", - " 7\n", - " \n", - " \n", - " 20\n", - " 7.172353\n", - " 0.212599\n", - " 3.747219\n", - " 0.130217\n", - " 1\n", - " False\n", - " 0.05\n", - " 100\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.481303\n", - " 0.490002\n", - " 0.488269\n", - " 0.486524\n", - " 0.003759\n", - " 8\n", - " \n", - " \n", " 6\n", - " 14.276345\n", - " 0.456576\n", - " 8.318859\n", - " 0.268701\n", - " 0.5\n", + " 0.002088\n", + " 0.000166\n", + " 0.001113\n", + " 0.000053\n", + " 1.0\n", " False\n", - " 0.05\n", - " 5\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.482429\n", - " 0.487735\n", - " 0.484888\n", - " 0.485017\n", - " 0.002168\n", - " 9\n", - " \n", - " \n", - " 2\n", - " 14.902358\n", - " 0.737693\n", - " 5.975091\n", - " 0.171150\n", - " 0.5\n", - " True\n", - " 0.05\n", - " 100\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.469598\n", - " 0.474490\n", - " 0.473637\n", - " 0.472575\n", - " 0.002134\n", - " 10\n", - " \n", - " \n", - " 9\n", - " 12.677349\n", - " 0.145143\n", - " 4.374204\n", - " 0.175674\n", - " 0.5\n", - " False\n", - " 0.1\n", - " 5\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.468872\n", - " 0.476451\n", - " 0.470921\n", - " 0.472082\n", - " 0.003201\n", - " 11\n", - " \n", - " \n", - " 5\n", - " 13.423686\n", - " 0.482872\n", - " 8.008324\n", - " 0.442975\n", - " 0.5\n", - " True\n", - " 0.1\n", - " 100\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.465726\n", - " 0.474548\n", - " 0.471879\n", - " 0.470718\n", - " 0.003694\n", - " 12\n", - " \n", - " \n", - " 1\n", - " 13.819117\n", - " 0.838347\n", - " 6.161175\n", - " 0.336590\n", - " 0.5\n", - " True\n", - " 0.05\n", - " 20\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.463395\n", - " 0.473982\n", - " 0.471262\n", - " 0.469546\n", - " 0.004489\n", - " 13\n", - " \n", - " \n", - " 4\n", - " 13.281476\n", - " 0.588822\n", - " 8.335852\n", - " 0.254627\n", - " 0.5\n", - " True\n", - " 0.1\n", - " 20\n", - " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.458734\n", - " 0.468053\n", - " 0.464418\n", - " 0.463735\n", - " 0.003835\n", - " 14\n", - " \n", - " \n", - " 14\n", - " 7.282247\n", - " 0.444940\n", - " 3.567094\n", - " 0.044519\n", + " 0.9\n", " 1\n", - " True\n", - " 0.05\n", - " 100\n", " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.438189\n", - " 0.450160\n", - " 0.446180\n", - " 0.444843\n", - " 0.004978\n", - " 15\n", - " \n", - " \n", - " 17\n", - " 7.098797\n", - " 0.196241\n", - " 3.838628\n", - " 0.091128\n", - " 1\n", - " True\n", - " 0.1\n", - " 100\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.436488\n", - " 0.444503\n", - " 0.445900\n", - " 0.442297\n", - " 0.004147\n", - " 16\n", - " \n", - " \n", - " 18\n", - " 7.492791\n", - " 0.288889\n", - " 3.843224\n", - " 0.073438\n", - " 1\n", - " False\n", - " 0.05\n", - " 5\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.428196\n", - " 0.431945\n", - " 0.430160\n", - " 0.430100\n", - " 0.001531\n", - " 17\n", - " \n", - " \n", - " 21\n", - " 7.229826\n", - " 0.099823\n", - " 3.656332\n", - " 0.073780\n", - " 1\n", - " False\n", - " 0.1\n", - " 5\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.403130\n", - " 0.410170\n", - " 0.409801\n", - " 0.407700\n", - " 0.003235\n", - " 18\n", - " \n", - " \n", - " 13\n", - " 7.158370\n", - " 0.169818\n", - " 3.765632\n", - " 0.082924\n", - " 1\n", - " True\n", - " 0.05\n", - " 20\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.399237\n", - " 0.412872\n", - " 0.407982\n", - " 0.406697\n", - " 0.005640\n", - " 19\n", - " \n", - " \n", - " 16\n", - " 7.064643\n", - " 0.119529\n", - " 3.810983\n", - " 0.125897\n", - " 1\n", - " True\n", - " 0.1\n", - " 20\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.388060\n", - " 0.399247\n", - " 0.396325\n", - " 0.394544\n", - " 0.004737\n", - " 20\n", + " 0.458154\n", + " 0.415951\n", + " 0.406097\n", + " 0.426734\n", + " 0.022578\n", + " 2\n", " \n", " \n", " 0\n", - " 13.749660\n", - " 0.465174\n", - " 6.407841\n", - " 0.549166\n", + " 0.010547\n", + " 0.005423\n", + " 0.001438\n", + " 0.000207\n", " 0.5\n", " True\n", - " 0.05\n", - " 5\n", + " 0.9\n", + " 1\n", " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.384852\n", - " 0.386487\n", - " 0.386796\n", - " 0.386045\n", - " 0.000853\n", - " 21\n", + " 0.422790\n", + " 0.389784\n", + " 0.352330\n", + " 0.388301\n", + " 0.028784\n", + " 3\n", + " \n", + " \n", + " 4\n", + " 0.002662\n", + " 0.000426\n", + " 0.001162\n", + " 0.000068\n", + " 1.0\n", + " True\n", + " 0.9\n", + " 1\n", + " {'classifier__alpha': 1, 'classifier__fit_prio...\n", + " 0.381607\n", + " 0.382587\n", + " 0.285005\n", + " 0.349733\n", + " 0.045772\n", + " 4\n", " \n", " \n", " 3\n", - " 15.954147\n", - " 0.318013\n", - " 6.337361\n", - " 0.261697\n", + " 0.001664\n", + " 0.000016\n", + " 0.001354\n", + " 0.000081\n", + " 0.5\n", + " False\n", + " 0.9\n", + " 3\n", + " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", + " 0.348260\n", + " 0.358595\n", + " 0.329416\n", + " 0.345424\n", + " 0.012080\n", + " 5\n", + " \n", + " \n", + " 7\n", + " 0.002125\n", + " 0.000228\n", + " 0.001368\n", + " 0.000247\n", + " 1.0\n", + " False\n", + " 0.9\n", + " 3\n", + " {'classifier__alpha': 1, 'classifier__fit_prio...\n", + " 0.344794\n", + " 0.332797\n", + " 0.323581\n", + " 0.333724\n", + " 0.008685\n", + " 6\n", + " \n", + " \n", + " 1\n", + " 0.001997\n", + " 0.000104\n", + " 0.001105\n", + " 0.000051\n", " 0.5\n", " True\n", - " 0.1\n", - " 5\n", + " 0.9\n", + " 3\n", " {'classifier__alpha': 0.5, 'classifier__fit_pr...\n", - " 0.369785\n", - " 0.375645\n", - " 0.375858\n", - " 0.373763\n", - " 0.002814\n", - " 22\n", + " 0.349248\n", + " 0.328047\n", + " 0.277855\n", + " 0.318383\n", + " 0.029937\n", + " 7\n", " \n", " \n", - " 12\n", - " 7.120198\n", - " 0.050452\n", - " 3.833905\n", - " 0.069540\n", - " 1\n", + " 5\n", + " 0.002135\n", + " 0.000251\n", + " 0.001422\n", + " 0.000479\n", + " 1.0\n", " True\n", - " 0.05\n", - " 5\n", + " 0.9\n", + " 3\n", " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.277741\n", - " 0.280564\n", - " 0.285337\n", - " 0.281214\n", - " 0.003135\n", - " 23\n", - " \n", - " \n", - " 15\n", - " 7.497707\n", - " 0.183054\n", - " 3.870714\n", - " 0.062888\n", - " 1\n", - " True\n", - " 0.1\n", - " 5\n", - " {'classifier__alpha': 1, 'classifier__fit_prio...\n", - " 0.255578\n", - " 0.263381\n", - " 0.266184\n", - " 0.261714\n", - " 0.004487\n", - " 24\n", + " 0.337362\n", + " 0.306776\n", + " 0.292058\n", + " 0.312065\n", + " 0.018870\n", + " 8\n", " \n", " \n", "\n", "" ], "text/plain": [ - " mean_fit_time std_fit_time mean_score_time std_score_time \\\n", - "7 14.549476 0.361685 8.476837 0.222398 \n", - "10 11.235289 0.130426 4.092868 0.082518 \n", - "19 7.383645 0.138110 4.130709 0.250048 \n", - "11 10.435154 0.305144 3.882101 0.128886 \n", - "8 13.643193 0.310696 4.173707 0.142980 \n", - "22 7.048340 0.050070 3.172948 0.152418 \n", - "23 7.564685 0.146092 2.374111 0.285026 \n", - "20 7.172353 0.212599 3.747219 0.130217 \n", - "6 14.276345 0.456576 8.318859 0.268701 \n", - "2 14.902358 0.737693 5.975091 0.171150 \n", - "9 12.677349 0.145143 4.374204 0.175674 \n", - "5 13.423686 0.482872 8.008324 0.442975 \n", - "1 13.819117 0.838347 6.161175 0.336590 \n", - "4 13.281476 0.588822 8.335852 0.254627 \n", - "14 7.282247 0.444940 3.567094 0.044519 \n", - "17 7.098797 0.196241 3.838628 0.091128 \n", - "18 7.492791 0.288889 3.843224 0.073438 \n", - "21 7.229826 0.099823 3.656332 0.073780 \n", - "13 7.158370 0.169818 3.765632 0.082924 \n", - "16 7.064643 0.119529 3.810983 0.125897 \n", - "0 13.749660 0.465174 6.407841 0.549166 \n", - "3 15.954147 0.318013 6.337361 0.261697 \n", - "12 7.120198 0.050452 3.833905 0.069540 \n", - "15 7.497707 0.183054 3.870714 0.062888 \n", + " mean_fit_time std_fit_time mean_score_time std_score_time \\\n", + "2 0.002468 0.000398 0.001431 0.000171 \n", + "6 0.002088 0.000166 0.001113 0.000053 \n", + "0 0.010547 0.005423 0.001438 0.000207 \n", + "4 0.002662 0.000426 0.001162 0.000068 \n", + "3 0.001664 0.000016 0.001354 0.000081 \n", + "7 0.002125 0.000228 0.001368 0.000247 \n", + "1 0.001997 0.000104 0.001105 0.000051 \n", + "5 0.002135 0.000251 0.001422 0.000479 \n", "\n", - " param_classifier__alpha param_classifier__fit_prior \\\n", - "7 0.5 False \n", - "10 0.5 False \n", - "19 1 False \n", - "11 0.5 False \n", - "8 0.5 False \n", - "22 1 False \n", - "23 1 False \n", - "20 1 False \n", - "6 0.5 False \n", - "2 0.5 True \n", - "9 0.5 False \n", - "5 0.5 True \n", - "1 0.5 True \n", - "4 0.5 True \n", - "14 1 True \n", - "17 1 True \n", - "18 1 False \n", - "21 1 False \n", - "13 1 True \n", - "16 1 True \n", - "0 0.5 True \n", - "3 0.5 True \n", - "12 1 True \n", - "15 1 True \n", + " param_classifier__alpha param_classifier__fit_prior \\\n", + "2 0.5 False \n", + "6 1.0 False \n", + "0 0.5 True \n", + "4 1.0 True \n", + "3 0.5 False \n", + "7 1.0 False \n", + "1 0.5 True \n", + "5 1.0 True \n", "\n", - " param_vectorizer__max_df param_vectorizer__min_df \\\n", - "7 0.05 20 \n", - "10 0.1 20 \n", - "19 0.05 20 \n", - "11 0.1 100 \n", - "8 0.05 100 \n", - "22 0.1 20 \n", - "23 0.1 100 \n", - "20 0.05 100 \n", - "6 0.05 5 \n", - "2 0.05 100 \n", - "9 0.1 5 \n", - "5 0.1 100 \n", - "1 0.05 20 \n", - "4 0.1 20 \n", - "14 0.05 100 \n", - "17 0.1 100 \n", - "18 0.05 5 \n", - "21 0.1 5 \n", - "13 0.05 20 \n", - "16 0.1 20 \n", - "0 0.05 5 \n", - "3 0.1 5 \n", - "12 0.05 5 \n", - "15 0.1 5 \n", + " param_vectorizer__max_df param_vectorizer__min_df \\\n", + "2 0.9 1 \n", + "6 0.9 1 \n", + "0 0.9 1 \n", + "4 0.9 1 \n", + "3 0.9 3 \n", + "7 0.9 3 \n", + "1 0.9 3 \n", + "5 0.9 3 \n", "\n", - " params split0_test_score \\\n", - "7 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.518061 \n", - "10 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.513897 \n", - "19 {'classifier__alpha': 1, 'classifier__fit_prio... 0.496825 \n", - "11 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.493247 \n", - "8 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.489609 \n", - "22 {'classifier__alpha': 1, 'classifier__fit_prio... 0.487456 \n", - "23 {'classifier__alpha': 1, 'classifier__fit_prio... 0.485160 \n", - "20 {'classifier__alpha': 1, 'classifier__fit_prio... 0.481303 \n", - "6 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.482429 \n", - "2 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.469598 \n", - "9 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.468872 \n", - "5 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.465726 \n", - "1 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.463395 \n", - "4 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.458734 \n", - "14 {'classifier__alpha': 1, 'classifier__fit_prio... 0.438189 \n", - "17 {'classifier__alpha': 1, 'classifier__fit_prio... 0.436488 \n", - "18 {'classifier__alpha': 1, 'classifier__fit_prio... 0.428196 \n", - "21 {'classifier__alpha': 1, 'classifier__fit_prio... 0.403130 \n", - "13 {'classifier__alpha': 1, 'classifier__fit_prio... 0.399237 \n", - "16 {'classifier__alpha': 1, 'classifier__fit_prio... 0.388060 \n", - "0 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.384852 \n", - "3 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.369785 \n", - "12 {'classifier__alpha': 1, 'classifier__fit_prio... 0.277741 \n", - "15 {'classifier__alpha': 1, 'classifier__fit_prio... 0.255578 \n", + " params split0_test_score \\\n", + "2 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.455431 \n", + "6 {'classifier__alpha': 1, 'classifier__fit_prio... 0.458154 \n", + "0 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.422790 \n", + "4 {'classifier__alpha': 1, 'classifier__fit_prio... 0.381607 \n", + "3 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.348260 \n", + "7 {'classifier__alpha': 1, 'classifier__fit_prio... 0.344794 \n", + "1 {'classifier__alpha': 0.5, 'classifier__fit_pr... 0.349248 \n", + "5 {'classifier__alpha': 1, 'classifier__fit_prio... 0.337362 \n", "\n", - " split1_test_score split2_test_score mean_test_score std_test_score \\\n", - "7 0.514842 0.511599 0.514834 0.002638 \n", - "10 0.515661 0.507867 0.512475 0.003337 \n", - "19 0.501045 0.496854 0.498241 0.001983 \n", - "11 0.497814 0.502245 0.497769 0.003674 \n", - "8 0.495207 0.498154 0.494323 0.003544 \n", - "22 0.493865 0.491157 0.490826 0.002627 \n", - "23 0.494039 0.490127 0.489776 0.003633 \n", - "20 0.490002 0.488269 0.486524 0.003759 \n", - "6 0.487735 0.484888 0.485017 0.002168 \n", - "2 0.474490 0.473637 0.472575 0.002134 \n", - "9 0.476451 0.470921 0.472082 0.003201 \n", - "5 0.474548 0.471879 0.470718 0.003694 \n", - "1 0.473982 0.471262 0.469546 0.004489 \n", - "4 0.468053 0.464418 0.463735 0.003835 \n", - "14 0.450160 0.446180 0.444843 0.004978 \n", - "17 0.444503 0.445900 0.442297 0.004147 \n", - "18 0.431945 0.430160 0.430100 0.001531 \n", - "21 0.410170 0.409801 0.407700 0.003235 \n", - "13 0.412872 0.407982 0.406697 0.005640 \n", - "16 0.399247 0.396325 0.394544 0.004737 \n", - "0 0.386487 0.386796 0.386045 0.000853 \n", - "3 0.375645 0.375858 0.373763 0.002814 \n", - "12 0.280564 0.285337 0.281214 0.003135 \n", - "15 0.263381 0.266184 0.261714 0.004487 \n", + " split1_test_score split2_test_score mean_test_score std_test_score \\\n", + "2 0.434571 0.423547 0.437850 0.013221 \n", + "6 0.415951 0.406097 0.426734 0.022578 \n", + "0 0.389784 0.352330 0.388301 0.028784 \n", + "4 0.382587 0.285005 0.349733 0.045772 \n", + "3 0.358595 0.329416 0.345424 0.012080 \n", + "7 0.332797 0.323581 0.333724 0.008685 \n", + "1 0.328047 0.277855 0.318383 0.029937 \n", + "5 0.306776 0.292058 0.312065 0.018870 \n", "\n", - " rank_test_score \n", - "7 1 \n", - "10 2 \n", - "19 3 \n", - "11 4 \n", - "8 5 \n", - "22 6 \n", - "23 7 \n", - "20 8 \n", - "6 9 \n", - "2 10 \n", - "9 11 \n", - "5 12 \n", - "1 13 \n", - "4 14 \n", - "14 15 \n", - "17 16 \n", - "18 17 \n", - "21 18 \n", - "13 19 \n", - "16 20 \n", - "0 21 \n", - "3 22 \n", - "12 23 \n", - "15 24 " + " rank_test_score \n", + "2 1 \n", + "6 2 \n", + "0 3 \n", + "4 4 \n", + "3 5 \n", + "7 6 \n", + "1 7 \n", + "5 8 " ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.model_selection import GridSearchCV, GroupKFold\n", "import pandas as pd\n", "\n", "optimisation_pipeline = GridSearchCV(\n", " create_pipeline(),\n", " {\n", - " \"vectorizer__min_df\": [5, 20, 100],\n", - " \"vectorizer__max_df\": [0.05, 0.1],\n", + " \"vectorizer__min_df\": ([5, 20, 100] if FULL_RUN else [1, 3]),\n", + " \"vectorizer__max_df\": ([0.05, 0.1] if FULL_RUN else [0.9]),\n", " \"classifier__alpha\": [0.5, 1],\n", " \"classifier__fit_prior\": [True, False],\n", " },\n", " scoring=\"f1_macro\",\n", - " cv=3,\n", - " n_jobs=-1,\n", + " cv=GroupKFold(n_splits=3),\n", + " n_jobs=2,\n", " verbose=1,\n", ")\n", - "optimisation_pipeline.fit(X, y)\n", + "# Group by paper text so that expanded labels and duplicate texts stay together.\n", + "optimisation_pipeline.fit(X, y, groups=X)\n", "\n", "results = pd.DataFrame(optimisation_pipeline.cv_results_)\n", "results.sort_values(\"rank_test_score\")" @@ -784,25 +455,2274 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, + "id": "cell-8", "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
Pipeline(steps=[('vectorizer',\n",
-       "                 TfidfVectorizer(max_df=0.05, min_df=20, sublinear_tf=True)),\n",
-       "                ('classifier', MultinomialNB(alpha=0.5, fit_prior=False))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + "
Pipeline(steps=[('vectorizer', TfidfVectorizer(max_df=0.9, sublinear_tf=True)),\n",
+       "                ('classifier', MultinomialNB(alpha=0.5, fit_prior=False))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ - "Pipeline(steps=[('vectorizer',\n", - " TfidfVectorizer(max_df=0.05, min_df=20, sublinear_tf=True)),\n", + "Pipeline(steps=[('vectorizer', TfidfVectorizer(max_df=0.9, sublinear_tf=True)),\n", " ('classifier', MultinomialNB(alpha=0.5, fit_prior=False))])" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -819,6 +2739,7 @@ }, { "cell_type": "markdown", + "id": "cell-9", "metadata": {}, "source": [ "## Export the model using GreatAI" @@ -826,7 +2747,8 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, + "id": "cell-10", "metadata": {}, "outputs": [ { @@ -834,18 +2756,18 @@ "output_type": "stream", "text": [ "\u001b[38;5;39mFetching cached versions of small-domain-prediction\u001b[0m\n", - "\u001b[38;5;39mCopying file for small-domain-prediction-2\u001b[0m\n", - "\u001b[38;5;39mCompressing small-domain-prediction-2\u001b[0m\n", - "\u001b[38;5;39mModel small-domain-prediction uploaded with version 2\u001b[0m\n" + "\u001b[38;5;39mFetching cached versions of small-domain-prediction\u001b[0m\n", + "\u001b[38;5;39mFetching cached versions of small-domain-prediction\u001b[0m\n", + "\u001b[38;5;39mModel small-domain-prediction uploaded with version 0\u001b[0m\n" ] }, { "data": { "text/plain": [ - "'small-domain-prediction:2'" + "'small-domain-prediction:0'" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -853,12 +2775,12 @@ "source": [ "from great_ai import save_model\n", "\n", - "\n", "save_model(classifier, key=\"small-domain-prediction\", keep_last_n=5)" ] }, { "cell_type": "markdown", + "id": "cell-11", "metadata": {}, "source": [ "## Next: [Part 3](https://great-ai.scoutinscience.com/examples/simple/deploy)" @@ -867,7 +2789,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", + "display_name": ".venv (3.13.5)", "language": "python", "name": "python3" }, @@ -881,15 +2803,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } + "version": "3.13.5" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } diff --git a/docs/how-to-guides/install.md b/docs/how-to-guides/install.md index 9504d65..0849137 100644 --- a/docs/how-to-guides/install.md +++ b/docs/how-to-guides/install.md @@ -1,9 +1,11 @@ # Installation guide -Provided you already have [Python3](https://www.python.org/downloads/){ target=_blank } (and pip) installed, simply execute: +With [uv](https://docs.astral.sh/uv/getting-started/installation/){ target=_blank } installed, create and activate a Python environment, then install GreatAI: ```sh -pip install great-ai +uv venv --python 3.13 +source .venv/bin/activate +uv pip install great-ai ``` > Python 3.12 or later is required. Python 3.13 is supported. @@ -11,10 +13,13 @@ This will work on all major operating systems. ## Google Colab -To use GreatAI in [Google Colab](https://colab.research.google.com){ target=_blank }, select a runtime with Python 3.12 or later and install the package: +To use GreatAI in [Google Colab](https://colab.research.google.com){ target=_blank }, select a runtime with Python 3.12 or later, then run this notebook cell to install uv and GreatAI into the runtime's Python environment: -```sh -pip install --upgrade great-ai +```python +import sys + +!curl -LsSf https://astral.sh/uv/install.sh | sh +!~/.local/bin/uv pip install --system --python {sys.executable} --upgrade great-ai ``` ## Command-line tools @@ -26,20 +31,17 @@ After installation, `great-ai` and `large-file` are available as commands. The f To help with the confusion, a CLI executable called `great_ai` (and `large_file`) are also installed. Thus, if you prefer, you can always refer to GreatAI using its underscored name variant (`great_ai`). -!!! warning "Windows" - On Windows, you might encounter a similar warning from `pip`: - > `WARNING: The scripts great-ai.exe, great_ai.exe, large-file.exe and large_file.exe are installed in 'C:\Users\...\Scripts', which is not on PATH.` - - > `Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.` +!!! note "Windows" + Activate the environment with `.venv\Scripts\activate` in Command Prompt or `.\.venv\Scripts\Activate.ps1` in PowerShell instead of `source .venv/bin/activate`. - This means that `great-ai.exe` and `large-file.exe` are not in your `PATH`. Either add their containing directory ('C:\Users\...\Scripts' in this case) to your `PATH` or use `python3 -m great_ai` and `python3 -m great_ai.large_file` instead of the exe-s. + If `great-ai` or `large-file` is unavailable, check that the environment is active, or use `python -m great_ai` and `python -m great_ai.large_file` instead. ## Update -If you wish to update to the latest version, execute: +With your virtual environment active, update to the latest version: ```sh -pip install --upgrade great-ai +uv pip install --upgrade great-ai ``` ## Bleeding edge @@ -47,6 +49,6 @@ pip install --upgrade great-ai You can also install the latest (usually unreleased) version from GitHub. ```sh -pip install --upgrade git+https://github.com/schmelczer/great-ai.git +uv pip install --upgrade git+https://github.com/schmelczer/great-ai.git ``` > Python 3.12 or later is required. diff --git a/docs/how-to-guides/use-service.md b/docs/how-to-guides/use-service.md index fef170b..45f8003 100644 --- a/docs/how-to-guides/use-service.md +++ b/docs/how-to-guides/use-service.md @@ -86,16 +86,19 @@ Similar to the previous approach, your code will run in a container. However, in To this end, you can also create a custom Docker image. It is especially useful if you have third-party dependencies, such as [PyTorch](https://pytorch.org/){ target=_blank } or [TensorFlow](https://www.tensorflow.org/){ target=_blank }. ```Dockerfile +# syntax=docker/dockerfile:1 FROM schmelczera/great-ai:latest +COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv + # Remove this block if you don't have a requirements.txt COPY requirements.txt ./ -RUN pip install --no-cache-dir --requirement requirements.txt +RUN uv pip install --system --no-cache --requirement requirements.txt -# If you store your models in S3 or GridFS, it may be a -# good idea to cache them in the image so that you don't -# have to download it each time a container starts -RUN large-file --backend s3 --secrets s3.ini --cache my-domain-predictor +# Cache an S3 model using credentials available only during this RUN. +# Remove this step if your application does not use a remote model. +RUN --mount=type=secret,id=s3,target=/run/secrets/s3.ini,required=true \ + large-file --backend s3 --secrets /run/secrets/s3.ini --cache my-domain-predictor # Add your application code to the image COPY . . @@ -104,6 +107,32 @@ COPY . . CMD ["deploy.ipynb"] ``` +Create an `s3.ini` with the S3 keys described in the [configuration guide](https://great-ai.scoutinscience.com/how-to-guides/configure-service/#s3-compatible). Use concrete values in this build configuration: `ENV:` references are resolved inside the build container, which does not inherit your shell's environment. Replace `my-domain-predictor` with the key used when saving your model. + +Keep credentials and any local model cache out of `COPY . .` by adding these entries to your project's `.dockerignore`: + +```dockerignore +s3.ini +mongo.ini +.env +.cache +``` + +Build with [Docker BuildKit secrets](https://docs.docker.com/build/building/secrets/). This example disables Docker's layer cache so that the `large-file --cache` step runs and downloads the model into the image: + +```sh +DOCKER_BUILDKIT=1 docker build --no-cache --progress=plain \ + --secret id=s3,src=s3.ini --tag my-great-ai-service . +``` + +The secret mount is removed after the `RUN` instruction; the downloaded model cache remains in the image. Supply any configuration needed by the application separately at runtime. For example, an application that auto-configures S3 from `s3.ini` can use a read-only bind mount: + +```sh +docker run --rm -p 6060:6060 \ + --mount type=bind,source="$(pwd)/s3.ini",target=/app/s3.ini,readonly \ + my-great-ai-service +``` + ## Batch prediction Processing larger amounts of data on a single machine is made easy by the [GreatAI][great_ai.GreatAI]'s [process_batch][great_ai.GreatAI.process_batch] method. This relies on multiprocessing ([parallel_map][great_ai.utilities.parallel_map.parallel_map.parallel_map]) to take full advantage of all available CPU-cores. diff --git a/docs/index.md b/docs/index.md index e032d49..4d036cf 100644 --- a/docs/index.md +++ b/docs/index.md @@ -52,8 +52,12 @@ Applying AI is becoming increasingly easier, but many case studies have shown th ## Hello world +With [uv](https://docs.astral.sh/uv/getting-started/installation/){ target=_blank } installed: + ```sh -pip install great-ai +uv venv --python 3.13 +source .venv/bin/activate +uv pip install great-ai ``` ```python title="demo.py" diff --git a/docs/surveys/surveys.ipynb b/docs/surveys/surveys.ipynb index 17bd06a..cb80fe5 100644 --- a/docs/surveys/surveys.ipynb +++ b/docs/surveys/surveys.ipynb @@ -1,477 +1,62 @@ { "cells": [ { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
How many years of software engineering experience do you have?How many years of data science experience do you have?Write reusable scripts for data cleaning and mergingMake datasets available on shared infrastructureUse versioning for data, model, configurations and training scriptsContinuously monitor the behaviour of deployed modelsLog production predictions with the model’s version and input dataStore models in a single format for ease of useEquip with web interface, package image, provide REST APIProvide simple API for serving batch and real-time requestsIntegration with existing data infrastructureQuerying, visualising and understanding metrics and event loggingAllow experimentation with the inference codeKeep the model’s API and documentation togetherParallelise feature extractionCache predictionsAsync support for top-down chaining models
031Strongly agreeAgreeStrongly agreeNeither agree nor disagreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeStrongly agreeNeither agree nor disagreeStrongly agree
162Neither agree nor disagreeAgreeNeither agree nor disagreeAgreeAgreeNeither agree nor disagreeDisagreeStrongly disagreeDisagreeStrongly disagreeDisagreeStrongly disagreeDisagreeStrongly agreeStrongly disagree
215Strongly disagreeDisagreeDisagreeStrongly disagreeDisagreeStrongly disagreeStrongly disagreeNeither agree nor disagreeStrongly disagreeDisagreeNeither agree nor disagreeAgreeStrongly disagreeStrongly disagreeDisagree
333AgreeAgreeDisagreeNeither agree nor disagreeAgreeNot applicableNot applicableNeither agree nor disagreeAgreeDisagreeAgreeStrongly agreeNot applicableNeither agree nor disagreeAgree
417Neither agree nor disagreeDisagreeNeither agree nor disagreeDisagreeStrongly disagreeNot applicableNot applicableDisagreeStrongly disagreeDisagreeDisagreeNeither agree nor disagreeStrongly disagreeStrongly agreeNot applicable
560Strongly agreeStrongly agreeAgreeNeither agree nor disagreeAgreeStrongly agreeAgreeStrongly agreeAgreeStrongly agreeDisagreeStrongly agreeAgreeStrongly agreeNot applicable
622DisagreeNeither agree nor disagreeAgreeStrongly agreeNeither agree nor disagreeDisagreeStrongly agreeDisagreeDisagreeAgreeNeither agree nor disagreeNeither agree nor disagreeNot applicableDisagreeStrongly agree
712DisagreeNeither agree nor disagreeDisagreeAgreeDisagreeStrongly disagreeStrongly agreeStrongly agreeStrongly disagreeDisagreeAgreeStrongly disagreeNot applicableStrongly disagreeStrongly disagree
801Strongly disagreeDisagreeStrongly disagreeDisagreeStrongly disagreeDisagreeAgreeStrongly disagreeDisagreeStrongly disagreeDisagreeStrongly disagreeDisagreeDisagreeStrongly disagree
971Strongly agreeStrongly agreeAgreeStrongly agreeAgreeAgreeStrongly agreeStrongly disagreeStrongly agreeNot applicableAgreeAgreeStrongly agreeStrongly agreeAgree
\n", - "
" - ], - "text/plain": [ - " How many years of software engineering experience do you have? \\\n", - "0 3 \n", - "1 6 \n", - "2 1 \n", - "3 3 \n", - "4 1 \n", - "5 6 \n", - "6 2 \n", - "7 1 \n", - "8 0 \n", - "9 7 \n", - "\n", - " How many years of data science experience do you have? \\\n", - "0 1 \n", - "1 2 \n", - "2 5 \n", - "3 3 \n", - "4 7 \n", - "5 0 \n", - "6 2 \n", - "7 2 \n", - "8 1 \n", - "9 1 \n", - "\n", - " Write reusable scripts for data cleaning and merging \\\n", - "0 Strongly agree \n", - "1 Neither agree nor disagree \n", - "2 Strongly disagree \n", - "3 Agree \n", - "4 Neither agree nor disagree \n", - "5 Strongly agree \n", - "6 Disagree \n", - "7 Disagree \n", - "8 Strongly disagree \n", - "9 Strongly agree \n", - "\n", - " Make datasets available on shared infrastructure \\\n", - "0 Agree \n", - "1 Agree \n", - "2 Disagree \n", - "3 Agree \n", - "4 Disagree \n", - "5 Strongly agree \n", - "6 Neither agree nor disagree \n", - "7 Neither agree nor disagree \n", - "8 Disagree \n", - "9 Strongly agree \n", - "\n", - " Use versioning for data, model, configurations and training scripts \\\n", - "0 Strongly agree \n", - "1 Neither agree nor disagree \n", - "2 Disagree \n", - "3 Disagree \n", - "4 Neither agree nor disagree \n", - "5 Agree \n", - "6 Agree \n", - "7 Disagree \n", - "8 Strongly disagree \n", - "9 Agree \n", - "\n", - " Continuously monitor the behaviour of deployed models \\\n", - "0 Neither agree nor disagree \n", - "1 Agree \n", - "2 Strongly disagree \n", - "3 Neither agree nor disagree \n", - "4 Disagree \n", - "5 Neither agree nor disagree \n", - "6 Strongly agree \n", - "7 Agree \n", - "8 Disagree \n", - "9 Strongly agree \n", - "\n", - " Log production predictions with the model’s version and input data \\\n", - "0 Strongly agree \n", - "1 Agree \n", - "2 Disagree \n", - "3 Agree \n", - "4 Strongly disagree \n", - "5 Agree \n", - "6 Neither agree nor disagree \n", - "7 Disagree \n", - "8 Strongly disagree \n", - "9 Agree \n", - "\n", - " Store models in a single format for ease of use \\\n", - "0 Strongly agree \n", - "1 Neither agree nor disagree \n", - "2 Strongly disagree \n", - "3 Not applicable \n", - "4 Not applicable \n", - "5 Strongly agree \n", - "6 Disagree \n", - "7 Strongly disagree \n", - "8 Disagree \n", - "9 Agree \n", - "\n", - " Equip with web interface, package image, provide REST API \\\n", - "0 Strongly agree \n", - "1 Disagree \n", - "2 Strongly disagree \n", - "3 Not applicable \n", - "4 Not applicable \n", - "5 Agree \n", - "6 Strongly agree \n", - "7 Strongly agree \n", - "8 Agree \n", - "9 Strongly agree \n", - "\n", - " Provide simple API for serving batch and real-time requests \\\n", - "0 Strongly agree \n", - "1 Strongly disagree \n", - "2 Neither agree nor disagree \n", - "3 Neither agree nor disagree \n", - "4 Disagree \n", - "5 Strongly agree \n", - "6 Disagree \n", - "7 Strongly agree \n", - "8 Strongly disagree \n", - "9 Strongly disagree \n", - "\n", - " Integration with existing data infrastructure \\\n", - "0 Strongly agree \n", - "1 Disagree \n", - "2 Strongly disagree \n", - "3 Agree \n", - "4 Strongly disagree \n", - "5 Agree \n", - "6 Disagree \n", - "7 Strongly disagree \n", - "8 Disagree \n", - "9 Strongly agree \n", - "\n", - " Querying, visualising and understanding metrics and event logging \\\n", - "0 Strongly agree \n", - "1 Strongly disagree \n", - "2 Disagree \n", - "3 Disagree \n", - "4 Disagree \n", - "5 Strongly agree \n", - "6 Agree \n", - "7 Disagree \n", - "8 Strongly disagree \n", - "9 Not applicable \n", - "\n", - " Allow experimentation with the inference code \\\n", - "0 Strongly agree \n", - "1 Disagree \n", - "2 Neither agree nor disagree \n", - "3 Agree \n", - "4 Disagree \n", - "5 Disagree \n", - "6 Neither agree nor disagree \n", - "7 Agree \n", - "8 Disagree \n", - "9 Agree \n", - "\n", - " Keep the model’s API and documentation together \\\n", - "0 Strongly agree \n", - "1 Strongly disagree \n", - "2 Agree \n", - "3 Strongly agree \n", - "4 Neither agree nor disagree \n", - "5 Strongly agree \n", - "6 Neither agree nor disagree \n", - "7 Strongly disagree \n", - "8 Strongly disagree \n", - "9 Agree \n", - "\n", - " Parallelise feature extraction Cache predictions \\\n", - "0 Strongly agree Neither agree nor disagree \n", - "1 Disagree Strongly agree \n", - "2 Strongly disagree Strongly disagree \n", - "3 Not applicable Neither agree nor disagree \n", - "4 Strongly disagree Strongly agree \n", - "5 Agree Strongly agree \n", - "6 Not applicable Disagree \n", - "7 Not applicable Strongly disagree \n", - "8 Disagree Disagree \n", - "9 Strongly agree Strongly agree \n", - "\n", - " Async support for top-down chaining models \n", - "0 Strongly agree \n", - "1 Strongly disagree \n", - "2 Disagree \n", - "3 Agree \n", - "4 Not applicable \n", - "5 Not applicable \n", - "6 Strongly agree \n", - "7 Strongly disagree \n", - "8 Strongly disagree \n", - "9 Agree " - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], + "id": "7af82b40", + "cell_type": "markdown", "source": [ - "import pandas as pd\n", + "## Local setup\n", "\n", - "best_practices = pd.read_csv(\"Best practices assessment.csv\")\n", - "best_practices" - ] + "Use Python 3.12 or 3.13 and install this checkout with `uv pip install --editable '.[notebooks]'`.\n", + "See **Run notebooks locally** in the repository README for the kernel, execution order,\n", + "and full-data options. Generated artifacts stay under `.cache/notebooks/`.\n" + ], + "metadata": {} + }, + { + "id": "ba5f79ca", + "cell_type": "code", + "metadata": {}, + "execution_count": null, + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", + ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", + "\n", + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"surveys\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" + ], + "outputs": [] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(2.5, 2.0)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "SURVEY_DIR = ROOT / \"docs/surveys\"\n", + "best_practices = pd.read_csv(SURVEY_DIR / \"Best practices assessment.csv\")\n", + "best_practices" ], + "id": "cell-2" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "m = {\n", " \"Strongly agree\": 4 / 4,\n", @@ -505,36 +90,14 @@ "].median(), best_practices[\n", " \"How many years of data science experience do you have?\"\n", "].median()" - ] + ], + "id": "cell-3" }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-0.5440527060340572, 0.10399880919437814)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "from scipy import stats\n", @@ -546,41 +109,14 @@ "stats.pearsonr(\n", " [x for x, y in best_practice_score_ds], [y for x, y in best_practice_score_ds]\n", ")" - ] + ], + "id": "cell-4" }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.5157738095238095\n" - ] - }, - { - "data": { - "text/plain": [ - "(0.6722543326178704, 0.03321124881554773)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import re\n", "\n", @@ -625,334 +161,30 @@ ")\n", "plt.tight_layout()\n", "\n", - "plt.savefig(\"best-practices\", dpi=150)\n", + "plt.savefig(WORK_DIR / \"best-practices.png\", dpi=150)\n", "\n", "stats.pearsonr(\n", " [x for x, y in best_practice_score_se], [y for x, y in best_practice_score_se]\n", ")" - ] + ], + "id": "cell-5" }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
I believe the use of GreatAI improves the quality of AI deployments.I believe the use of GreatAI would increase my productivity.I believe the use of GreatAI can lead to robust and trustworthy deployments.Overall, I found GreatAI useful when working with AI.I found the GreatAI easy to learn.I found it is easy to employ GreatAI in practice.I found it is easy to integrate GreatAI into an existing project.Overall, I found GreatAI easy to use.Assuming GreatAI is applicable to my task, I predict that I will use it on a regular basis in the future.Overall, I intend to use the GreatAI in my personal or professional projects.
07777777777
17767567677
24456654454
36767767676
47767455566
56666666666
66664576677
77666453556
84555723333
97777565677
\n", - "
" - ], - "text/plain": [ - " I believe the use of GreatAI improves the quality of AI deployments. \\\n", - "0 7 \n", - "1 7 \n", - "2 4 \n", - "3 6 \n", - "4 7 \n", - "5 6 \n", - "6 6 \n", - "7 7 \n", - "8 4 \n", - "9 7 \n", - "\n", - " I believe the use of GreatAI would increase my productivity. \\\n", - "0 7 \n", - "1 7 \n", - "2 4 \n", - "3 7 \n", - "4 7 \n", - "5 6 \n", - "6 6 \n", - "7 6 \n", - "8 5 \n", - "9 7 \n", - "\n", - " I believe the use of GreatAI can lead to robust and trustworthy deployments. \\\n", - "0 7 \n", - "1 6 \n", - "2 5 \n", - "3 6 \n", - "4 6 \n", - "5 6 \n", - "6 6 \n", - "7 6 \n", - "8 5 \n", - "9 7 \n", - "\n", - " Overall, I found GreatAI useful when working with AI. \\\n", - "0 7 \n", - "1 7 \n", - "2 6 \n", - "3 7 \n", - "4 7 \n", - "5 6 \n", - "6 4 \n", - "7 6 \n", - "8 5 \n", - "9 7 \n", - "\n", - " I found the GreatAI easy to learn. \\\n", - "0 7 \n", - "1 5 \n", - "2 6 \n", - "3 7 \n", - "4 4 \n", - "5 6 \n", - "6 5 \n", - "7 4 \n", - "8 7 \n", - "9 5 \n", - "\n", - " I found it is easy to employ GreatAI in practice. \\\n", - "0 7 \n", - "1 6 \n", - "2 5 \n", - "3 6 \n", - "4 5 \n", - "5 6 \n", - "6 7 \n", - "7 5 \n", - "8 2 \n", - "9 6 \n", - "\n", - " I found it is easy to integrate GreatAI into an existing project. \\\n", - "0 7 \n", - "1 7 \n", - "2 4 \n", - "3 7 \n", - "4 5 \n", - "5 6 \n", - "6 6 \n", - "7 3 \n", - "8 3 \n", - "9 5 \n", - "\n", - " Overall, I found GreatAI easy to use. \\\n", - "0 7 \n", - "1 6 \n", - "2 4 \n", - "3 6 \n", - "4 5 \n", - "5 6 \n", - "6 6 \n", - "7 5 \n", - "8 3 \n", - "9 6 \n", - "\n", - " Assuming GreatAI is applicable to my task, I predict that I will use it on a regular basis in the future. \\\n", - "0 7 \n", - "1 7 \n", - "2 5 \n", - "3 7 \n", - "4 6 \n", - "5 6 \n", - "6 7 \n", - "7 5 \n", - "8 3 \n", - "9 7 \n", - "\n", - " Overall, I intend to use the GreatAI in my personal or professional projects. \n", - "0 7 \n", - "1 7 \n", - "2 4 \n", - "3 6 \n", - "4 6 \n", - "5 6 \n", - "6 7 \n", - "7 6 \n", - "8 3 \n", - "9 7 " - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "tam = pd.read_csv(\"Technology acceptance model questionnaire.csv\")\n", + "tam = pd.read_csv(SURVEY_DIR / \"Technology acceptance model questionnaire.csv\")\n", "tam" - ] + ], + "id": "cell-6" }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.8813771517996869, array([0.688, 0.967]))" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "import pingouin\n", "\n", @@ -963,24 +195,14 @@ " \"Overall, I found GreatAI useful when working with AI.\",\n", "]\n", "pingouin.cronbach_alpha(tam[pu])" - ] + ], + "id": "cell-7" }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.7729220222793487, array([0.403, 0.937]))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "peou = [\n", " \"I found the GreatAI easy to learn.\",\n", @@ -989,309 +211,115 @@ " \"Overall, I found GreatAI easy to use.\",\n", "]\n", "pingouin.cronbach_alpha(tam[peou])" - ] + ], + "id": "cell-8" }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.9538950715421304, array([0.814, 0.989]))" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "itu = [\n", " \"Assuming GreatAI is applicable to my task, I predict that I will use it on a regular basis in the future.\",\n", " \"Overall, I intend to use the GreatAI in my personal or professional projects.\",\n", "]\n", "pingouin.cronbach_alpha(tam[itu])" - ] + ], + "id": "cell-9" }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
pupeouitu
07.007.007.0
16.756.007.0
24.754.754.5
36.506.506.5
46.754.756.0
56.006.006.0
65.506.007.0
76.254.255.5
84.753.753.0
97.005.507.0
\n", - "
" - ], - "text/plain": [ - " pu peou itu\n", - "0 7.00 7.00 7.0\n", - "1 6.75 6.00 7.0\n", - "2 4.75 4.75 4.5\n", - "3 6.50 6.50 6.5\n", - "4 6.75 4.75 6.0\n", - "5 6.00 6.00 6.0\n", - "6 5.50 6.00 7.0\n", - "7 6.25 4.25 5.5\n", - "8 4.75 3.75 3.0\n", - "9 7.00 5.50 7.0" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "tam[\"pu\"] = tam[pu].mean(1)\n", - "tam[\"peou\"] = tam[peou].mean(1)\n", - "tam[\"itu\"] = tam[itu].mean(1)\n", + "tam[\"pu\"] = tam[pu].mean(axis=1)\n", + "tam[\"peou\"] = tam[peou].mean(axis=1)\n", + "tam[\"itu\"] = tam[itu].mean(axis=1)\n", "tam[[\"pu\", \"peou\", \"itu\"]]" - ] + ], + "id": "cell-10" }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "pu 6.125\n", - "peou 5.450\n", - "itu 5.950\n", - "dtype: float64" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "tam[[\"pu\", \"peou\", \"itu\"]].mean()" - ] + ], + "id": "cell-11" }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "pu 6.375\n", - "peou 5.750\n", - "itu 6.250\n", - "dtype: float64" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "tam[[\"pu\", \"peou\", \"itu\"]].median()" - ] + ], + "id": "cell-12" }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "pu 0.859990\n", - "peou 1.039498\n", - "itu 1.321825\n", - "dtype: float64" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "tam[[\"pu\", \"peou\", \"itu\"]].std()" - ] + ], + "id": "cell-13" }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.5515422017785757, 0.09838124227663879)" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "stats.pearsonr(tam[\"peou\"], tam[\"pu\"])" - ] + ], + "id": "cell-14" }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.8066270322592023, 0.004809023073123024)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "stats.pearsonr(tam[\"peou\"], tam[\"itu\"])" - ] + ], + "id": "cell-15" }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.7880605510627579, 0.006774486564715021)" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "stats.pearsonr(tam[\"pu\"], tam[\"itu\"])" - ] + ], + "id": "cell-16" } ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", + "display_name": "GreatAI (local)", "language": "python", - "name": "python3" + "name": "great-ai-local" }, "language_info": { + "name": "python", "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", - "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } + "pygments_lexer": "ipython3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } diff --git a/docs/tutorial/deploy.ipynb b/docs/tutorial/deploy.ipynb index 7a96491..d831505 100644 --- a/docs/tutorial/deploy.ipynb +++ b/docs/tutorial/deploy.ipynb @@ -9,36 +9,52 @@ "Finally, it's time to deploy your model. But before that, you have to make sure you follow AI deployment [best practices](https://se-ml.github.io/). In the past, this step was too often either the source of unexpected struggle, or worse, simply ignored.\n", "\n", "GreatAI's decorators add tracing and API scaffolding with a few lines of code. This brings the service nearly to production readiness, but does not establish the model's accuracy, fairness, or trustworthiness. Evaluate the model for its intended use, configure a production-suitable tracing database and storage, and review the remaining deployment best practices. The local TinyDB backend used below is for development, as the output warns." - ] + ], + "id": "cell-0" + }, + { + "id": "94c0cd76", + "cell_type": "markdown", + "source": [ + "## Local setup\n", + "\n", + "Use Python 3.12 or 3.13 and install this checkout with `uv pip install --editable '.[notebooks]'`.\n", + "See **Run notebooks locally** in the repository README for the kernel, execution order,\n", + "and full-data options. Generated artifacts stay under `.cache/notebooks/`.\n" + ], + "metadata": {} + }, + { + "id": "bf8f9a33", + "cell_type": "code", + "metadata": {}, + "execution_count": null, + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", + ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", + "\n", + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"tutorial\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" + ], + "outputs": [] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", - "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39mGreatAI (v0.1.4): configured ✅\u001b[0m\n", - "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", - "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", - "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", - "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", - "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", - "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", - "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n", - "\u001b[38;5;39mFetching cached versions of my-domain-predictor\u001b[0m\n", - "\u001b[38;5;39mLatest version of my-domain-predictor is 9 (from versions: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\u001b[0m\n", - "\u001b[38;5;39mFile my-domain-predictor-9 found in cache\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ "from great_ai import GreatAI, use_model\n", "from great_ai.utilities import clean\n", @@ -49,89 +65,55 @@ "def predict_domain(sentence, model):\n", " inputs = [clean(sentence)]\n", " return str(model.predict(inputs)[0])" - ] + ], + "id": "cell-3" }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Trace[str]({'created': '2022-07-12T13:34:26.743292',\n", - " 'exception': None,\n", - " 'feedback': None,\n", - " 'logged_values': { 'arg:sentence:length': 29,\n", - " 'arg:sentence:value': 'Mountains are just big rocks.'},\n", - " 'models': [{'key': 'my-domain-predictor', 'version': 9}],\n", - " 'original_execution_time_ms': 6.9699,\n", - " 'output': 'geography',\n", - " 'tags': ['predict_domain', 'online', 'development'],\n", - " 'trace_id': 'c80bdee3-602b-49dd-a84d-6eef80127e5a'})" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "predict_domain(\"Mountains are just big rocks.\")" - ] + ], + "id": "cell-4" }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Notice how the original return value is under the `.output` key. Additionally, a plethora of metadata has been added which will be useful later on.\n", + "Notice how the original return value is under the `.output` key, alongside\n", + "tracing metadata. Run `train.ipynb` first, using the same local/full mode.\n", "\n", - "Running your app in development-mode is as easy as executing `great-ai deploy.ipynb` from your terminal." - ] + "Start the development server in a separate terminal from the checkout root:\n", + "\n", + "```sh\n", + "source .venv/bin/activate\n", + "great-ai docs/tutorial/deploy.ipynb\n", + "```\n", + "\n", + "Open http://127.0.0.1:6060/dashboard. Stop the server with Ctrl+C.\n", + "The next cell tests the HTTP API in-process so that **Run All** can finish." + ], + "id": "cell-5" }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[38;5;39m2022-07-12 15:34:28 | INFO | Converting notebook to Python script\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:29 | INFO | Found `predict_domain` to be the GreatAI app \u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:29 | INFO | Uvicorn running on http://0.0.0.0:6060 (Press CTRL+C to quit)\u001b[0m\n", - "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | Environment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", - "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | Cannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", - "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | The selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", - "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | Cannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | GreatAI (v0.1.4): configured ✅\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 is_production: False\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 should_log_exception_stack: True\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 prediction_cache_size: 512\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | 🔩 dashboard_table_size: 50\u001b[0m\n", - "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | You still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", - "\u001b[38;5;226m2022-07-12 15:34:31 | WARNING | > Find out more at https://se-ml.github.io/practices\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Fetching cached versions of my-domain-predictor\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Latest version of my-domain-predictor is 9 (from versions: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | File my-domain-predictor-9 found in cache\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Started server process [199794]\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Waiting for application startup.\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:31 | INFO | Application startup complete.\u001b[0m\n", - "^C\n", - "\u001b[38;5;39m2022-07-12 15:34:33 | INFO | Shutting down\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:33 | INFO | Waiting for application shutdown.\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:33 | INFO | Application shutdown complete.\u001b[0m\n", - "\u001b[38;5;39m2022-07-12 15:34:33 | INFO | Finished server process [199794]\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ - "!great-ai deploy.ipynb\n", - "# leave this running and open http://127.0.0.1:6060" - ] + "from fastapi.testclient import TestClient\n", + "\n", + "with TestClient(predict_domain.app) as client:\n", + " response = client.post(\n", + " \"/predict\", json={\"sentence\": \"Mountains are just big rocks.\"}\n", + " )\n", + " response.raise_for_status()\n", + " assert isinstance(response.json()[\"output\"], str)\n", + " print(response.json()[\"output\"])" + ], + "id": "cell-6" }, { "cell_type": "markdown", @@ -146,34 +128,28 @@ "For more thorough examples, see the [examples page](https://great-ai.scoutinscience.com/examples/simple/data).\n", "\n", "### [Go back to the summary](https://great-ai.scoutinscience.com/tutorial/#summary)" - ] + ], + "id": "cell-7" } ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", + "display_name": "GreatAI (local)", "language": "python", - "name": "python3" + "name": "great-ai-local" }, "language_info": { + "name": "python", "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", - "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } + "pygments_lexer": "ipython3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 } diff --git a/docs/tutorial/train.ipynb b/docs/tutorial/train.ipynb index 7333ec2..4476833 100644 --- a/docs/tutorial/train.ipynb +++ b/docs/tutorial/train.ipynb @@ -6,25 +6,61 @@ "source": [ "# Train your model\n", "\n", - "The first step is, of course, to install `great-ai` in your Python environment." - ] + "Install the checkout's notebook dependencies first, following the README's\n", + "**Run notebooks locally** instructions. Select the `GreatAI (local)` kernel.\n", + "The default run uses a balanced subset of the bundled MAG data for speed.\n", + "Set `GREAT_AI_NOTEBOOK_FULL=1` before starting Jupyter to use the full splits.\n", + "Local subset results differ from the historical full-dataset results below." + ], + "id": "cell-0" + }, + { + "id": "37cb23a4", + "cell_type": "markdown", + "source": [ + "## Local setup\n", + "\n", + "Use Python 3.12 or 3.13 and install this checkout with `uv pip install --editable '.[notebooks]'`.\n", + "See **Run notebooks locally** in the repository README for the kernel, execution order,\n", + "and full-data options. Generated artifacts stay under `.cache/notebooks/`.\n" + ], + "metadata": {} + }, + { + "id": "42ed923c", + "cell_type": "code", + "metadata": {}, + "execution_count": null, + "source": [ + "import os\n", + "import sys\n", + "from pathlib import Path\n", + "\n", + "# Works when opened from the repository root or any notebook directory.\n", + "_start = Path(globals().get(\"__file__\", Path.cwd())).resolve()\n", + "ROOT = next(\n", + " p\n", + " for p in [_start, *_start.parents]\n", + " if (p / \"pyproject.toml\").is_file() and (p / \"great_ai\").is_dir()\n", + ")\n", + "sys.path.insert(0, str(ROOT / \"docs\"))\n", + "from notebook_support import setup_notebook, mag_lines\n", + "\n", + "FULL_RUN = os.environ.get(\"GREAT_AI_NOTEBOOK_FULL\") == \"1\"\n", + "WORK_DIR = setup_notebook(ROOT, \"tutorial\")\n", + "DATA_DIR = ROOT / \"docs/tutorial/data\"" + ], + "outputs": [] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Note: you may need to restart the kernel to use updated packages.\n" - ] - } - ], + "outputs": [], "source": [ - "%pip install great-ai > /dev/null" - ] + "# Dependencies are installed once in the environment; no in-kernel installation needed." + ], + "id": "cell-3" }, { "cell_type": "markdown", @@ -33,11 +69,12 @@ "First, we have to get some data. After downloading it [from here](https://github.com/allenai/scibert/tree/master/data/text_classification/mag), we might notice that the dataset is in [JSON Lines](https://jsonlines.org/) format (each line is a separate JSON document). \n", "\n", "Let's write a function which takes a single line and returns the sentence and the corresponding label from it. Before returning, the sentence is also [cleaned](https://great-ai.scoutinscience.com/reference/utilities/#great_ai.utilities.clean.clean) to remove any LaTeX, XML, unicode, PDF-extraction artifacts." - ] + ], + "id": "cell-4" }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -52,7 +89,8 @@ " label = data_point[\"label\"]\n", "\n", " return clean(sentence), label" - ] + ], + "id": "cell-5" }, { "cell_type": "markdown", @@ -61,58 +99,44 @@ "Now, we can load the dataset and extract the *training* samples from it. Since we're impatient, we can do it in parallel using the [`simple_parallel_map`](https://great-ai.scoutinscience.com/reference/utilities/#great_ai.utilities.simple_parallel_map) function.\n", "\n", "> Open files in Python are iterable: in text mode, each iteration returns the next line." - ] + ], + "id": "cell-6" }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 84000/84000 [00:09<00:00, 8960.63it/s] \n" - ] - } - ], + "outputs": [], "source": [ "from great_ai.utilities import simple_parallel_map\n", "\n", - "with open(\"data/train.txt\", encoding=\"utf-8\") as f:\n", - " training_data = simple_parallel_map(preprocess, f)\n", - "\n", + "training_lines = mag_lines(DATA_DIR / \"train.txt\", None if FULL_RUN else 100)\n", + "training_data = simple_parallel_map(preprocess, training_lines, concurrency=2)\n", "X_train = [d[0] for d in training_data]\n", "y_train = [d[1] for d in training_data]" - ] + ], + "id": "cell-7" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's do the same for the *test* data." - ] + ], + "id": "cell-8" }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 22399/22399 [00:03<00:00, 6078.02it/s]\n" - ] - } - ], + "outputs": [], "source": [ - "with open(\"data/test.txt\", encoding=\"utf-8\") as f:\n", - " test_data = simple_parallel_map(preprocess, f)\n", - "\n", + "test_lines = mag_lines(DATA_DIR / \"test.txt\", None if FULL_RUN else 30)\n", + "test_data = simple_parallel_map(preprocess, test_lines, concurrency=2)\n", "X_test = [d[0] for d in test_data]\n", "y_test = [d[1] for d in test_data]" - ] + ], + "id": "cell-9" }, { "cell_type": "markdown", @@ -121,39 +145,24 @@ "After obtaining some clean data, it's time to create and train a model on it. We are going to use [scikit-learn](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html) for this purpose.\n", "\n", "In this case, we opted for a [linear Support Vector Machine](https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html) because it's known to be an adequate baseline for simple classification tasks." - ] + ], + "id": "cell-10" }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
Pipeline(steps=[('tfidfvectorizer', TfidfVectorizer()),\n",
-       "                ('linearsvc', LinearSVC())])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "Pipeline(steps=[('tfidfvectorizer', TfidfVectorizer()),\n", - " ('linearsvc', LinearSVC())])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from sklearn.pipeline import make_pipeline\n", "from sklearn.feature_extraction.text import TfidfVectorizer\n", "from sklearn.svm import LinearSVC\n", "\n", - "model = make_pipeline(TfidfVectorizer(), LinearSVC())\n", + "model = make_pipeline(TfidfVectorizer(), LinearSVC(random_state=42))\n", "# todo: hyperparameter-optimisation\n", "model.fit(X_train, y_train)" - ] + ], + "id": "cell-11" }, { "cell_type": "markdown", @@ -161,11 +170,12 @@ "source": [ "It's already finished. Let's see how well it performs. But first, we need to [configure matplotlib](https://matplotlib.org/stable/tutorials/introductory/customizing.html) to make the charts more legible. \n", "> `ConfusionMatrixDisplay` relies on `matplotlib` for rendering." - ] + ], + "id": "cell-12" }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -175,51 +185,22 @@ "plt.rcParams[\"figure.figsize\"] = (30, 15)\n", "plt.rcParams[\"figure.facecolor\"] = \"white\"\n", "plt.rcParams[\"font.size\"] = 12" - ] + ], + "id": "cell-13" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we check the quality of the model on the `test` split. We can use the classification report to check the common metrics, such as the macro F1-score. We also draw the confusion matrix to get some insights into the types of mistakes being made by the model." - ] + ], + "id": "cell-14" }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " precision recall f1-score support\n", - "\n", - " business 0.67 0.69 0.68 3198\n", - " economics 0.69 0.71 0.70 3189\n", - " geography 0.70 0.73 0.72 3207\n", - " medicine 0.90 0.91 0.90 3187\n", - " politics 0.63 0.57 0.60 3169\n", - " psychology 0.73 0.73 0.73 3252\n", - " sociology 0.51 0.51 0.51 3197\n", - "\n", - " accuracy 0.69 22399\n", - " macro avg 0.69 0.69 0.69 22399\n", - "weighted avg 0.69 0.69 0.69 22399\n", - "\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from sklearn import metrics\n", "\n", @@ -228,7 +209,8 @@ "print(metrics.classification_report(y_test, y_predicted))\n", "metrics.ConfusionMatrixDisplay.from_predictions(y_test, y_predicted)\n", "None" - ] + ], + "id": "cell-15" }, { "cell_type": "markdown", @@ -241,86 +223,48 @@ "> Not coincidentally, this is the point where the scope of Data Science ends but it's still a grey zone for software engineering.\n", "\n", "In order to use this model in production, we have to make it available on some possibly shared infrastructure." - ] + ], + "id": "cell-16" }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[38;5;226mEnvironment variable ENVIRONMENT is not set, defaulting to development mode ‼️\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using ParallelTinyDbDriver\u001b[0m\n", - "\u001b[38;5;226mThe selected tracing database (ParallelTinyDbDriver) is not recommended for production\u001b[0m\n", - "\u001b[38;5;226mCannot find credentials files, defaulting to using LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39mGreatAI (v0.1.4): configured ✅\u001b[0m\n", - "\u001b[38;5;39m 🔩 tracing_database: ParallelTinyDbDriver\u001b[0m\n", - "\u001b[38;5;39m 🔩 large_file_implementation: LargeFileLocal\u001b[0m\n", - "\u001b[38;5;39m 🔩 is_production: False\u001b[0m\n", - "\u001b[38;5;39m 🔩 should_log_exception_stack: True\u001b[0m\n", - "\u001b[38;5;39m 🔩 prediction_cache_size: 512\u001b[0m\n", - "\u001b[38;5;39m 🔩 dashboard_table_size: 50\u001b[0m\n", - "\u001b[38;5;226mYou still need to check whether you follow all best practices before trusting your deployment.\u001b[0m\n", - "\u001b[38;5;226m> Find out more at https://se-ml.github.io/practices\u001b[0m\n", - "\u001b[38;5;39mFetching cached versions of my-domain-predictor\u001b[0m\n", - "\u001b[38;5;39mCopying file for my-domain-predictor-9\u001b[0m\n", - "\u001b[38;5;39mCompressing my-domain-predictor-9\u001b[0m\n", - "\u001b[38;5;39mModel my-domain-predictor uploaded with version 9\u001b[0m\n" - ] - }, - { - "data": { - "text/plain": [ - "'my-domain-predictor:9'" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from great_ai import save_model\n", "\n", "save_model(model, key=\"my-domain-predictor\")" - ] + ], + "id": "cell-17" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### [Let's continue by finishing the deployment in the next notebook.](https://great-ai.scoutinscience.com/tutorial/deploy)" - ] + ], + "id": "cell-18" } ], "metadata": { "kernelspec": { - "display_name": "Python 3.10.4 ('.env': venv)", + "display_name": "GreatAI (local)", "language": "python", - "name": "python3" + "name": "great-ai-local" }, "language_info": { + "name": "python", "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", - "name": "python", "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.4" - }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "02dd6d3afbfa9fbbe1037d64ad9014965528a1ccad21929d6e72f466389a68ad" - } + "pygments_lexer": "ipython3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 5 }