diff --git a/.github/workflows/nightly-test.yml b/.github/workflows/nightly-test.yml
index a0571d1..2816c92 100644
--- a/.github/workflows/nightly-test.yml
+++ b/.github/workflows/nightly-test.yml
@@ -16,12 +16,16 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       notebooks: ${{ steps.get_nbs.outputs.notebooks }}
+      has_notebooks: ${{ steps.get_nbs.outputs.has_notebooks }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - id: get_nbs
         run: |
-          # 1) Read ignore patterns from .github/ignore-notebooks.txt
+          # 1) Find all available notebooks
+          NBS=$(find python-recipes -name '*.ipynb')
+
+          # 2) Load notebooks to ignore
           IGNORE_LIST=()
           while IFS= read -r skip_nb || [ -n "$skip_nb" ]; do
             # Skip empty lines or comment lines
@@ -29,9 +33,6 @@ jobs:
             IGNORE_LIST+=("$skip_nb")
           done < .github/ignore-notebooks.txt
       
-          # 2) Find all .ipynb in python-recipes (or your path)
-          NBS=$(find python-recipes -name '*.ipynb')
-      
           # 3) Filter out notebooks that match anything in IGNORE_LIST
           FILTERED_NBS=()
           for nb in $NBS; do
@@ -42,29 +43,36 @@ jobs:
                 break
               fi
             done
-
             if [ "$skip" = false ]; then
               FILTERED_NBS+=("$nb")
             fi
           done
       
-          # 4) Convert the final array to compact JSON for GitHub Actions
+          # 4) Stuff into a single-line JSON array
           NB_JSON=$(printf '%s\n' "${FILTERED_NBS[@]}" \
             | jq -R . \
             | jq -s -c .)
       
-          # 5) Default to an empty array if there's nothing left
           if [ -z "$NB_JSON" ] || [ "$NB_JSON" = "[]" ]; then
             NB_JSON="[]"
           fi
       
           echo "All valid notebooks: $NB_JSON"
+
+          # 5) Check if there's anything in FILTERED_NBS
+          if [ "${#FILTERED_NBS[@]}" -gt 0 ]; then
+            echo "has_notebooks=true" >> $GITHUB_OUTPUT
+          else
+            echo "has_notebooks=false" >> $GITHUB_OUTPUT
+          fi
+      
           echo "notebooks=$NB_JSON" >> $GITHUB_OUTPUT
 
   # ---------------------------------------------------------
   # 2) Test all notebooks in parallel
   # ---------------------------------------------------------
   test_all_notebooks:
+    if: ${{ needs.gather_all_notebooks.outputs.has_notebooks == 'true' }}
     needs: gather_all_notebooks
     runs-on: ubuntu-latest
     strategy:
@@ -79,7 +87,7 @@ jobs:
           - 6379:6379
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       # Setup Python
       - uses: actions/setup-python@v4
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index d93f897..17af1c4 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -17,16 +17,18 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       notebooks: ${{ steps.get_nbs.outputs.notebooks }}
+      has_notebooks: ${{ steps.get_nbs.outputs.has_notebooks }}
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
-      - id: get_nbs
+      - name: Gather notebooks
+        id: get_nbs
         run: |
-          # Compare this commit/PR to 'main' and list changed .ipynb files
+          # 1) Compare this commit/PR to 'main' and list changed notebooks
           git fetch --depth=1 origin main
           CHANGED_NOTEBOOKS=$(git diff --name-only origin/main | grep '\.ipynb$' || true)
       
-          # 1) Read ignore patterns from .github/ignore-notebooks.txt
+          # 2) Load notebooks to ignore
           IGNORE_LIST=()
           while IFS= read -r skip_nb || [ -n "$skip_nb" ]; do
             # Skip empty lines or comment lines
@@ -34,11 +36,10 @@ jobs:
             IGNORE_LIST+=("$skip_nb")
           done < .github/ignore-notebooks.txt
       
-          # 2) Filter out notebooks in CHANGED_NOTEBOOKS that match ignore patterns
+          # 3) Filter out ignored notebooks
           FILTERED_NBS=()
           for nb in $CHANGED_NOTEBOOKS; do
             skip=false
-      
             # Check if in ignore list
             for ignore_nb in "${IGNORE_LIST[@]}"; do
               # Partial match:
@@ -47,33 +48,31 @@ jobs:
                 break
               fi
             done
-      
             if [ "$skip" = false ]; then
               FILTERED_NBS+=("$nb")
             fi
           done
       
-          # 3) Build a single-line JSON array
+          # 4) Stuff into a single-line JSON array
           NB_JSON=$(printf '%s\n' "${FILTERED_NBS[@]}" \
             | jq -R . \
             | jq -s -c .)
       
-          # 4) Fallback to an empty array if there's nothing left
           if [ -z "$NB_JSON" ] || [ "$NB_JSON" = "[]" ]; then
             NB_JSON="[]"
           fi
       
           echo "All valid notebooks: $NB_JSON"
 
-          # 5) Write to $GITHUB_OUTPUT
-          if [ "$NB_JSON" != "[]" ]; then
+          # 5) Check if there's anything in FILTERED_NBS
+          if [ "${#FILTERED_NBS[@]}" -gt 0 ]; then
             echo "has_notebooks=true" >> $GITHUB_OUTPUT
           else
             echo "has_notebooks=false" >> $GITHUB_OUTPUT
           fi
 
           echo "notebooks=$NB_JSON" >> $GITHUB_OUTPUT
-      
+
   # ---------------------------------------------------------
   # 2) Test each changed notebook in parallel
   # ---------------------------------------------------------
@@ -93,7 +92,7 @@ jobs:
           - 6379:6379
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       # Setup Python
       - uses: actions/setup-python@v4
diff --git a/.gitignore b/.gitignore
index 1a701dd..5dced20 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,222 @@
-.env
-node_modules/
+# Created by https://www.toptal.com/developers/gitignore/api/python,venv,macos
+# Edit at https://www.toptal.com/developers/gitignore?templates=python,venv,macos
+
+### macOS ###
+# General
 .DS_Store
-.pytest_cache/
\ No newline at end of file
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### macOS Patch ###
+# iCloud generated files
+*.icloud
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### venv ###
+# Virtualenv
+# http://iamzed.com/2009/05/07/a-primer-on-virtualenv/
+[Bb]in
+[Ii]nclude
+[Ll]ib
+[Ll]ib64
+[Ll]ocal
+pyvenv.cfg
+pip-selfcheck.json
+
+libs/redis/docs/.Trash*
+.python-version
+.idea/*
diff --git a/.python-version b/.python-version
index 2419ad5..2c07333 100644
--- a/.python-version
+++ b/.python-version
@@ -1 +1 @@
-3.11.9
+3.11
diff --git a/python-recipes/finetuning/00_text_finetuning.ipynb b/python-recipes/finetuning/00_text_finetuning.ipynb
new file mode 100644
index 0000000..224df6f
--- /dev/null
+++ b/python-recipes/finetuning/00_text_finetuning.ipynb
@@ -0,0 +1,741 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Fine tuning text embedding models using sentence_transformers\n",
+    "\n",
+    "If you're building an LLM application your system will likely include a text embedding model that transforms written text into vector embeddings. These may be used for classification, routing, document retrieval, semantic caching or search.\n",
+    "\n",
+    "One of the key measure of an embedding model is how well it can group semantically equivalent statements together, and similarly, how well it an distinguish between similar, but not equivalent statements.\n",
+    "\n",
+    "Because embedding models are not performing logical reasoning, but instead are often used to perform vector similarity calculations, we're not guaranteed that every pair of similar vectors will be relevant or equivalent, or that embeddings that are far apart in vector space aren't relevant to each other. This is why using the correct text embedding model is critical. Using a text embedding model specifically fine tuned to correctly match queries for your system can improve your overall app performance."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This notebook uses the [sentence_transformers](https://sbert.net/) library to fine tune a text embedding model on a custom dataset.\n",
+    "The training method used is [contrastive fine tuning](https://arxiv.org/abs/2408.00690), where two statements are assigned a label as either being similar {label=1.0} or dissimilar {label=0.0}.\n",
+    "Training then proceeds to minimize the cosine distance between similar statements, and maximize the cosine distance between dissimilar statements.\n",
+    "\n",
+    "This contrastive loss function is well suited to applications where we care about the metrics true positive, true negative, false positive, and false negative.\n",
+    "\n",
+    "## Let's Begin!\n",
+    "<a href=\"https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/finetuning/00_text_finetuning.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m25.0.1\u001b[0m\n",
+      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pip install  --quiet torch datasets sentence_transformers 'transformers[torch]' redisvl matplotlib seaborn scikit-learn ipywidgets"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Select our starting model and dataset to fine tune on\n",
+    "To perform finetuning you'll need a dataset that ideally is specific to your use case. For the type of training we'll be doing - contrastive fine tuning - you'll need to structure your dataset as a set of pairs of questions or statements and coresponding label indicating if they're equivalent or not.\n",
+    "\n",
+    "An example of what this looks like is in `sample_dataset.csv`\n",
+    "\n",
+    "| question_1 | question_2 | label |\n",
+    "|------------|------------|-------|\n",
+    "| What is AI? | What is artificial intelligence? | 1.0 |\n",
+    "| How to bake a cake? | How to make a sandwich? | 0.0 |\n",
+    "| Define machine learning. | Explain machine learning. | 1.0 |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# select the datasets to train and test on\n",
+    "# we've provided examples in the datasets directory of our public S3 bucket for what these files should look like\n",
+    "train_data = 'sample_dataset.csv'\n",
+    "test_data = 'sample_testset.csv'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import requests\n",
+    "import os\n",
+    "\n",
+    "if not (os.path.exists(f\"./datasets/{train_data}\") and os.path.exists(f\"./datasets/{test_data}\")):\n",
+    "    if not os.path.exists('./datasets/'):\n",
+    "        os.mkdir('./datasets/')\n",
+    "\n",
+    "    # download the files and save them locally\n",
+    "    for file in [train_data, test_data]:\n",
+    "        url = f'https://redis-ai-resources.s3.us-east-2.amazonaws.com/finetuning/datasets/{file}'\n",
+    "        r = requests.get(url)\n",
+    "        with open(f'./datasets/{file}', 'wb') as f:\n",
+    "            f.write(r.content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "from sentence_transformers.losses import ContrastiveLoss\n",
+    "import copy\n",
+    "\n",
+    "# load a model to train/finetune\n",
+    "model_name = 'sentence-transformers/all-MiniLM-L6-v2'\n",
+    "\n",
+    "model = SentenceTransformer(model_name)\n",
+    "\n",
+    "# make a copy of the weights before training if we want to compare how much they've changed\n",
+    "before_training = copy.deepcopy(model.state_dict())\n",
+    "\n",
+    "# this loss requires pairs of text and a floating point similarity score as a label\n",
+    "# we'll use 'hard labels' of 1.0 or 0.0 as that is shown to lead to the best separation\n",
+    "loss = ContrastiveLoss(model)\n",
+    "\n",
+    "# load an example training dataset that works with our loss function:\n",
+    "train_dataset = load_dataset(\"csv\", data_files=f\"datasets/{train_data}\", split='train')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define our training arguments"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sentence_transformers.training_args import SentenceTransformerTrainingArguments\n",
+    "from sentence_transformers.training_args import BatchSamplers\n",
+    "\n",
+    "args = SentenceTransformerTrainingArguments(\n",
+    "    # required parameters\n",
+    "    output_dir=f\"models/trained_on_{train_data}\",\n",
+    "    # optional training parameters\n",
+    "    num_train_epochs=1,\n",
+    "    per_device_train_batch_size=16,\n",
+    "    per_device_eval_batch_size=16,\n",
+    "    warmup_ratio=0.1,\n",
+    "    fp16=False,  # set to False if your GPU can't handle FP16\n",
+    "    bf16=False,  # set to True if your GPU supports BF16\n",
+    "    batch_sampler=BatchSamplers.NO_DUPLICATES,  # losses using \"in-batch negatives\" benefit from no duplicates\n",
+    "    # optional tracking/debugging parameters\n",
+    "    eval_strategy=\"steps\",\n",
+    "    eval_steps=100,\n",
+    "    save_strategy=\"steps\",\n",
+    "    save_steps=100,\n",
+    "    save_total_limit=2,\n",
+    "    logging_steps=100,\n",
+    "    run_name=f\"model-base-{train_data}\",  # used in Weights & Biases if `wandb` is installed\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Split your dataset to perform training validation\n",
+    "While our model is training both the training loss and validation loss will be recorded. These are printed to `stdout`, and also logged in\n",
+    "`models/model-base-all/checkpoint-<step_num>/trainer_state.json`.\n",
+    "\n",
+    "sentence_transformers uses the term 'evaluation' rather than 'validation'."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train Dataset({\n",
+      "    features: ['question_1', 'question_2', 'label'],\n",
+      "    num_rows: 41\n",
+      "})\n",
+      "validation Dataset({\n",
+      "    features: ['question_1', 'question_2', 'label'],\n",
+      "    num_rows: 11\n",
+      "})\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator, SimilarityFunction\n",
+    "\n",
+    "# split the dataset into training and validation sets\n",
+    "train_dataset = train_dataset.train_test_split(train_size=0.8, seed=42)\n",
+    "\n",
+    "validation_dataset = train_dataset['test']\n",
+    "train_dataset = train_dataset['train']\n",
+    "\n",
+    "print('train', train_dataset)\n",
+    "print('validation', validation_dataset)\n",
+    "\n",
+    "# initialize the evaluator\n",
+    "dev_evaluator = EmbeddingSimilarityEvaluator(\n",
+    "    sentences1=validation_dataset[\"question_1\"],\n",
+    "    sentences2=validation_dataset[\"question_2\"],\n",
+    "    scores=validation_dataset[\"label\"],\n",
+    "    main_similarity=SimilarityFunction.COSINE,\n",
+    "    name=f\"{train_data}-dev\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Train our model\n",
+    "This cell performs the full training for the number of epochs defined in our `SentenceTransformerTrainingArguments`, args. Losses are periodically printed out."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "aafb575008c049f391e1d074a59e91dd",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "8c4ce9fb5ce24bbc80fae2f63dc0950c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Computing widget examples:   0%|          | 0/1 [00:00<?, ?example/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'train_runtime': 2.2703, 'train_samples_per_second': 18.06, 'train_steps_per_second': 1.321, 'train_loss': 0.03720299402872721, 'epoch': 1.0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sentence_transformers import SentenceTransformerTrainer\n",
+    "\n",
+    "trainer = SentenceTransformerTrainer(\n",
+    "    model=model,\n",
+    "    args=args,\n",
+    "    train_dataset=train_dataset,\n",
+    "    eval_dataset=validation_dataset,\n",
+    "    loss=loss,\n",
+    "    evaluator=dev_evaluator,\n",
+    ")\n",
+    "trainer.train()\n",
+    "\n",
+    "# make a copy of the weights after training\n",
+    "after_training = copy.deepcopy(model.state_dict())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## That's it!\n",
+    "That is all it takes to produce a finetuned model on your dataset. Every application is different and you'll want to know how well this model can do with your system, and how much better it is now that you've tuned it. Here we compute some metrics to see the impact of fine tuning.\n",
+    "These will also help you choose the best similarity threshold for your app based on your criteria."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Evaluate the trained model\n",
+    "As the ultimate goal of this fine tuning is to improve performance for distinguishing equivalent and not equivalent statements, we'll evaluate our trained model to to see how well it correctly identifies pairs of statements as either equivalent or not. We have a labeled dataset for this, where statements are known to be either equivalent, and labelled `1.0`, or not equivalent and labelled `0.0`. If you have a background in data science or statistics you may recognize this as a binary classification problem. Pairs embeddings will be classified as similar, aka positive, or dissimilar, aka negative. Comparing to our known labels that means that every pair of interest will in one of four groups:\n",
+    "- true positives (TP): our model correctly determines two vector embeddings are equivalent\n",
+    "- true negatives (TN): our model correctly determines two vector embeddings are different\n",
+    "- false positives (FP): our model incorrectly determines two vector embeddings are equivalent\n",
+    "- false negatives (FN): our model incorrectly determines two vector embeddings are different\n",
+    "\n",
+    "Here we can also evaluate on different datasets we haven't trained on. We've again provided a `sample_testset.csv` file to illustrate this, but you should replace this with data relevant to your app."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "def evaluate_model(model, test_dataset):\n",
+    "    q1_embeddings = [model.encode(pair['question_1']) for pair in test_dataset]\n",
+    "    q2_embeddings = [model.encode(pair['question_2']) for pair in test_dataset]\n",
+    "    labels = [pair['label'] for pair in test_dataset]\n",
+    "\n",
+    "    # compute all the distances between all the vectors for quicker reference later\n",
+    "    distances = np.empty(shape=(len(q1_embeddings), len(q2_embeddings)), dtype=np.float32, order='C')\n",
+    "    for index_1, embedding_1 in enumerate(q1_embeddings):\n",
+    "        for index_2, embedding_2 in enumerate(q2_embeddings):\n",
+    "            # compute cosine distance between embeddings\n",
+    "            cosine_distance = 1 - np.dot(embedding_1, embedding_2) / (np.linalg.norm(embedding_1) * np.linalg.norm(embedding_2))\n",
+    "            distances[index_1, index_2] = cosine_distance\n",
+    "\n",
+    "    # for our range of thresholds see which embeddings fall within our threshold and so would be consindered equivalent\n",
+    "    metrics = {}\n",
+    "    thresholds = np.linspace(0.01, 0.6, 60)\n",
+    "    for threshold in thresholds:\n",
+    "        TP = 0\n",
+    "        FP = 0\n",
+    "        TN = 0\n",
+    "        FN = 0\n",
+    "        for index, label in enumerate(labels):\n",
+    "            # for question N find the most similar embedding, aka the one with the lowest distance\n",
+    "            distance_of_nearest = np.min(distances[index, :])\n",
+    "            index_of_nearest = np.argmin(distances[index, :])\n",
+    "            if distances[index, :][index_of_nearest] <= threshold: # if the distance is below our threshold our model thinks they're equivalent\n",
+    "                if label == 1: # check the label to see if it really is equivalent (label == 1) or if they're actually different (label == 0)\n",
+    "                    if index_of_nearest == index: # verify that we hit the correct matched pair, and not some other question\n",
+    "                        TP += 1 # we correctly found a matching entry\n",
+    "                    else:\n",
+    "                        FP += 1 # we found something we think is equivalent, but it's not what we should have found\n",
+    "                else:\n",
+    "                    FP += 1 # we think we found an equivalent statement, but shouldn't have\n",
+    "            else: # we didn't find anything\n",
+    "                if label == 1: # check it should be a miss\n",
+    "                    FN += 1 # we failed to find a matching pair\n",
+    "                else:\n",
+    "                    TN += 1 # correctly did not match any other embeddings\n",
+    "\n",
+    "        F1 = (2 * TP) / (2 * TP + FP + FN)\n",
+    "        accuracy = (TP + TN) / len(test_dataset)\n",
+    "        metrics[threshold] = {\"TP\": TP, \"TN\": TN, \"FP\": FP, \"FN\": FN, \"accuracy\": accuracy, 'F1': F1}\n",
+    "\n",
+    "    return metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Perform our final comparison on our models before and after fine tuning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# load the test dataset\n",
+    "test_dataset = load_dataset(\"csv\", data_files=f\"datasets/{test_data}\", split='train')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.load_state_dict(before_training)\n",
+    "metrics_before_training = evaluate_model(model, test_dataset)\n",
+    "\n",
+    "model.load_state_dict(after_training)\n",
+    "metrics_after_training = evaluate_model(model, test_dataset)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Visualize metrics\n",
+    "Since we're tracking multiple metrics - true & false positives & negatives, accuracy and F1 score - we want a way to quickly visually compare all of these.\n",
+    "We'll plot these metrics to see how they change after fine tuning, and also how we can influence them by selecting the best cosine similarity threshold."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from matplotlib import pyplot as plt\n",
+    "\n",
+    "def display_AUC(metrics_before, metrics_after):\n",
+    "    precision_before = [m['TP'] / (m['TP'] + m['FP']) if (m['TP'] + m['FP']) > 0 else 1 for m in metrics_before.values()]\n",
+    "    precision_after = [m['TP'] / (m['TP'] + m['FP']) if (m['TP'] + m['FP']) > 0 else 1 for m in metrics_after.values()]\n",
+    "\n",
+    "    recall_before = [m['TP'] / (m['TP'] + m['FN']) if (m['TP'] + m['FN']) > 0 else 1 for m in metrics_before.values()]\n",
+    "    recall_after = [m['TP'] / (m['TP'] + m['FN']) if (m['TP'] + m['FN']) > 0 else 1 for m in metrics_after.values()]\n",
+    "\n",
+    "    from sklearn.metrics import roc_auc_score\n",
+    "    y_true_before = []\n",
+    "    y_score_before = []\n",
+    "    y_true_after = []\n",
+    "    y_score_after = []\n",
+    "\n",
+    "    for m in metrics_before.values():\n",
+    "        y_true_before.extend([1] * m['TP'] + [0] * m['FN'] + [0] * m['TN'] + [1] * m['FP'])\n",
+    "        y_score_before.extend([1] * m['TP'] + [1] * m['FN'] + [0] * m['TN'] + [0] * m['FP'])\n",
+    "\n",
+    "    for m in metrics_after.values():\n",
+    "        y_true_after.extend([1] * m['TP'] + [0] * m['FN'] + [0] * m['TN'] + [1] * m['FP'])\n",
+    "        y_score_after.extend([1] * m['TP'] + [1] * m['FN'] + [0] * m['TN'] + [0] * m['FP'])\n",
+    "\n",
+    "    auc_before = roc_auc_score(y_true_before, y_score_before)\n",
+    "    auc_after = roc_auc_score(y_true_after, y_score_after)\n",
+    "\n",
+    "    plt.figure()\n",
+    "    plt.plot(recall_before, precision_before, scalex=False, scaley=False)\n",
+    "    plt.plot(recall_after, precision_after, scalex=False, scaley=False)\n",
+    "    plt.title(f'trained on {train_data}, test on {test_data}\\n Precision Recall curves with finetuning')\n",
+    "    plt.xlabel('Recall')\n",
+    "    plt.ylabel('Precision')\n",
+    "    plt.ylim([0,1.1])\n",
+    "    plt.legend([f'before finetuning auc={auc_before :.4f}', f'after finetuning auc={auc_after :.4f}'])\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "def display_accuracy(metrics_before, metrics_after):\n",
+    "    accuracy_before = [m['accuracy'] for m in metrics_before.values()]\n",
+    "    accuracy_after = [m['accuracy'] for m in metrics_after.values()]\n",
+    "    plt.figure()\n",
+    "    plt.plot(list(metrics_before.keys()), accuracy_before)\n",
+    "    plt.plot(list(metrics_after.keys()), accuracy_after)\n",
+    "    plt.title(f'trained on {train_data}, test on {test_data}\\n Accuracy')\n",
+    "    plt.xlabel('Threshold')\n",
+    "    plt.ylabel('Accuracy')\n",
+    "    plt.ylim([0,1.1])\n",
+    "    plt.legend(['before finetuning', 'after finetuning'])\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "def display_f1_score(metrics_before, metrics_after):\n",
+    "    F1_before = [m[\"F1\"] for m in metrics_before.values()]\n",
+    "    F1_after = [m[\"F1\"] for m in metrics_after.values()]\n",
+    "\n",
+    "    plt.figure()\n",
+    "    plt.plot(list(metrics_before.keys()), F1_before)\n",
+    "    plt.plot(list(metrics_after.keys()), F1_after)\n",
+    "    plt.title(f'trained on {train_data}, test on {test_data}\\n F1 Score')\n",
+    "    plt.xlabel('Threshold')\n",
+    "    plt.ylabel('F1 Score')\n",
+    "    plt.legend(['before finetuning', 'after finetuning'])\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHcCAYAAAAqQ4tyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8YElEQVR4nO3dd3hT5dsH8G+SNt0LuktpoYyWvUuZMrQoggwBAWUp6E/6glZQENkIIsMqQxBliANQhijIsALKko3IKGWW0Ql005U87x+hgZC0JCVp2uT7ua5cTc68z+lJcuc5z5AIIQSIiIiILITU3AEQERERGROTGyIiIrIoTG6IiIjIojC5ISIiIovC5IaIiIgsCpMbIiIisihMboiIiMiiMLkhIiIii8LkhoiIiCwKk5tyEhwcjGHDhpll38OGDUNwcLBZ9m0p9u7dC4lEgr1795bbPq9duwaJRILVq1eX2z6JLI05P3vJfJjcPHDw4EFMmzYN6enp5g6F6KlVtOt56dKlFpGk/fDDD4iJiTHpPm7fvo1p06bh1KlTJt0PPT1Luh7K41jKE5ObBw4ePIjp06eb7MsgLi4OK1asMMm2iR5n6uvZUExu9Hf79m1Mnz6dyU0lYEnXA5MbglKpRF5enkHr2NnZwdbW1kQRERERkZogMXXqVAFA63H16lUhhBAAxOjRo8V3330n6tWrJ2xsbMTmzZuFEELMmzdPREREiCpVqgh7e3vRrFkz8dNPP2ntIygoSAwdOlT9etWqVQKA2L9/v3j33XeFp6encHR0FL169RIpKSla62/fvl20a9dOODo6CmdnZ/HCCy+I//77T2u5zZs3i/r16ws7OztRv359sWnTJjF06FARFBSk17lYsmSJqFevnpDL5cLPz0+8/fbb4t69exrLdOzYUdSvX1+cPXtWPPPMM8LBwUH4+/uLuXPn6rWPXbt2ibZt2wo3Nzfh5OQk6tSpIyZOnKien5+fLyZPniyaNWsmXF1dhaOjo2jXrp34888/NbZz9epVAUDMmzdPLF68WNSoUUM4ODiIZ599ViQkJAilUilmzJghAgIChL29vejZs6e4c+eOxjaCgoJE9+7dxc6dO0Xjxo2FnZ2dCAsLExs3btRYbs+ePQKA2LNnj8b0w4cPi8jISOHq6iocHBxEhw4dxP79+/U6D4+6d++eGDp0qHB1dRVubm5iyJAh4uTJkwKAWLVqlXq506dPi6FDh4oaNWoIOzs74ePjI4YPHy7S0tLUyzzpel65cqXo1KmT8PLyEnK5XISFhYmlS5dqxXT06FHx3HPPiapVqwp7e3sRHBwshg8frrGMQqEQn332mahXr56ws7MT3t7eYtSoUeLu3bsa5/jxWDp27Fjq+VAoFCImJkY0aNBA2NnZCU9PTxEZGSmOHj2qXqa06ygpKUnIZDIxbdo0rW1fuHBBABCLFi0qNYbHdezYUes4Hn1f5eXliSlTpoiQkBAhl8tFtWrVxPjx40VeXp7GdkqLu/g6e/zx6DWgy4kTJ0S3bt2Ei4uLcHJyEp07dxaHDh3SWMbQz5zHJSYmimHDhomAgAAhl8uFr6+v6Nmzp/q6EkKILVu2iBdeeEH4+fkJuVwuatasKWbMmCGKioq0zmX9+vXF6dOnRYcOHYSDg4MICQlRf3bu3btXtGrVStjb24s6deqI3bt3a6xffI2fP39e9OvXT7i4uIgqVaqIMWPGiPv372ss+/hnrxCq99vYsWNFtWrVhFwuFyEhIeKTTz4RCoXiiefh0WMw9/Vw8eJF0adPH+Hj4yPs7OxEQECAGDBggEhPT9fYx9q1a0WzZs2Evb298PDwEAMGDBAJCQl6H0tJ1q5dK1q2bCkcHByEu7u7aN++vdi5c6d6fmmfIQUFBcLDw0MMGzZMa7sZGRnCzs5OvPfee0+MoSRMboTqC2PgwIECgPjss8/E2rVrxdq1a0V2drYQQpXchIWFCS8vLzF9+nSxZMkScfLkSSGEENWqVRNvv/22WLx4sVi4cKFo1aqVACB+++03jX2UlNw0bdpUdO7cWSxatEi89957QiaTif79+2us++233wqJRCK6desmFi1aJObOnSuCg4OFu7u7xgfLzp07hVQqFQ0aNBALFy4UkyZNEm5ubqJ+/fp6XajFHxhdu3YVixYtElFRUUImk4mWLVuKgoIC9XIdO3YU/v7+IjAwUIwdO1YsXbpUdO7cWQAQ27dvL3Uf//33n5DL5aJFixbi888/F8uWLRPjxo0THTp0UC+Tmpoq/Pz8RHR0tPjyyy/Fp59+KurWrStsbW3V512Ih8lNkyZNRL169cTChQvFRx99JORyuWjdurX48MMPRZs2bcQXX3whxowZIyQSidaXc1BQkKhTp45wd3cXEyZMEAsXLhQNGzYUUqlU7Nq1S72cruQmNjZWyOVyERERIRYsWCA+++wz0ahRIyGXy8U///zzxPNdTKlUig4dOgipVCrefvttsWjRItG5c2fRqFEjrS+2+fPni/bt24sZM2aIr776SowdO1Y4ODiIVq1aCaVSKYR48vXcsmVLMWzYMPHZZ5+JRYsWieeee04AEIsXL1bvJzk5WXh4eIg6deqIefPmiRUrVohJkyaJsLAwjdjfeOMNYWNjI0aOHCmWLVsmPvjgA+Hk5KRxzWzevFlUq1ZNhIaGqmN59NzqMmzYMAFAPP/88yImJkbMnz9fvPTSS+qERJ/rqHPnzqJevXpa254+fbqQyWQiKSlJ7/+REKovoSZNmghPT0/1cRT/yFEoFOK5554Tjo6O4p133hHLly8XUVFRwsbGRrz00kvqbTwp7qSkJDFjxgwBQIwaNUq9n8uXL5cY13///SecnJyEn5+fmDlzpvjkk0/Uye/hw4fVyxnymaNLmzZthJubm/joo4/E119/LWbPni06deok9u3bp16mV69eon///mLevHniyy+/FP369RMAxLhx4zS29ehnyPjx48WiRYtEvXr1hEwmE+vWrRO+vr5i2rRpIiYmRgQEBAg3NzeRmZmpXr/4s6phw4aiR48eYvHixeLVV18VAMRrr72msa/HP3tzcnJEo0aNRNWqVcWHH34oli1bJoYMGSIkEokYO3bsE89DMXNfD/n5+aJGjRrC399fzJo1S3z99ddi+vTpomXLluLatWvqfcyaNUtIJBIxYMAAsXTpUjF9+nTh6ekpgoOD1T9cSzuWkkybNk0AEG3atBHz5s0Tn3/+uRg0aJD44IMPhBD6fYaMGDFCuLu7i/z8fI1tr1mzRgDQ+DFjKCY3D8ybN0/j1+2jAAipVCrOnj2rNS83N1fjdUFBgWjQoIHo3LmzxvSSkpuuXbuqv5SEEOLdd98VMplMnXlnZWUJd3d3MXLkSI3tJSUlCTc3N43pTZo0EX5+fhpZ+65du/TKwlNSUoRcLhfPPfecxq+XxYsXCwBi5cqV6mnFWf63336rnpafny98fX1F3759S93PZ599JgCI1NTUEpcpKirSutjv3bsnfHx8xIgRI9TTipMbLy8vjWOeOHGiACAaN24sCgsL1dMHDhwo5HK5xi+n4lKFR0tqMjIyhJ+fn2jatKl62uPJjVKpFLVr1xaRkZEa/7/c3FxRo0YN8eyzz5Z6Hh61ZcsWAUB8+umnGuegffv2WsnN49ebEEL8+OOPAoD466+/1NNKu551bSMyMlLUrFlT/Xrz5s1P/HD5+++/BQDx/fffa0zfsWOH1vT69es/sbSm2J9//ikAiDFjxmjNKz7X+lxHy5cvFwDEmTNnNKbXq1dP6/2pr+7du+t8L61du1ZIpVLx999/a0xftmyZACAOHDigd9xHjx7Vq7SmWK9evYRcLtdIgG7fvi1cXFw0kj19P3N0uXfvnrqUtDS6rq0333xTODo6arzvij9DfvjhB/W04hI1qVSqkZTt3LlT63wUJzc9e/bU2Nfbb78tAIjTp0+rpz3+2Ttz5kzh5OQkLl68qLHuhAkThEwm0yjReBJzXg/FJbu67hQUu3btmpDJZOLjjz/WmH7mzBlhY2OjMb2kY9ElPj5eSKVS0bt3b63SruJrS5/PkOL/7a+//qox/YUXXtD4PCoL1rnRU8eOHVGvXj2t6Q4ODurn9+7dQ0ZGBtq3b48TJ07otd1Ro0ZBIpGoX7dv3x4KhQLXr18HAOzevRvp6ekYOHAg0tLS1A+ZTIbw8HDs2bMHAJCYmIhTp05h6NChcHNzU2/v2Wef1Rn34/744w8UFBTgnXfegVT68LIYOXIkXF1dsW3bNo3lnZ2d8eqrr6pfy+VytGrVCleuXCl1P+7u7gCAX375BUqlUucyMpkMcrkcgKp+0927d1FUVIQWLVroPK/9+vXTOObw8HAAwKuvvgobGxuN6QUFBbh165bG+v7+/ujdu7f6taurK4YMGYKTJ08iKSlJZ4ynTp1CfHw8Bg0ahDt37qj/Lzk5OejSpQv++uuvEo/vcdu3b4eNjQ3+97//aZyD//u//9Na9tHrLS8vD2lpaWjdujUA6H3NPbqNjIwMpKWloWPHjrhy5QoyMjIAPPw//fbbbygsLNS5nZ9++glubm549tlnNa7N5s2bw9nZWX1tGmrjxo2QSCSYOnWq1rzi94o+11GfPn1gY2OD9evXq6f9999/OHfuHAYMGFCm2Ery008/ISwsDKGhoRrnonPnzgCgPhf6xG0IhUKBXbt2oVevXqhZs6Z6up+fHwYNGoT9+/cjMzNTY50nfebo4uDgALlcjr179+LevXulLlcsKysLaWlpaN++PXJzc3HhwgWNZZ2dnfHKK6+oX9etWxfu7u4ICwtTv4eBh+9nXZ8to0eP1nhd/J7Zvn17iTH+9NNPaN++PTw8PDT+V127doVCocBff/1V4rr6Ko/rofgzb+fOncjNzdW5zKZNm6BUKtG/f3+NOHx9fVG7du0yv0e3bNkCpVKJKVOmaHxfANrv0dI+Qzp37gxPT0+N9+i9e/ewe/fup36PMrnRU40aNXRO/+2339C6dWvY29ujSpUq8PLywpdffqn+kniS6tWra7z28PAAAPUHSHx8PADVReDl5aXx2LVrF1JSUgBA/cFUu3ZtrX3UrVv3iXEUr//4snK5HDVr1tT64KtWrZrGB2Rx7KV98AHAgAED0LZtW7zxxhvw8fHBK6+8gg0bNmi9sdesWYNGjRrB3t4eVatWhZeXF7Zt26bzvD5+Dovf9IGBgTqnPx5jrVq1tI6lTp06AFR9zehS/H8ZOnSo1v/l66+/Rn5+vt7XwPXr1+Hn5wdnZ2eN6br+b3fv3sXYsWPh4+MDBwcHeHl5qa9Nffd34MABdO3aFU5OTnB3d4eXlxc+/PBDjW107NgRffv2xfTp0+Hp6YmXXnoJq1atQn5+vsY5yMjIgLe3t9Y5yM7OVl+bhrp8+TL8/f1RpUqVEpfR5zry9PREly5dsGHDBvW09evXw8bGBn369ClTbCWJj4/H2bNntc5D8XVUfC70vf71lZqaitzcXJ3XSlhYGJRKJW7cuKEx/UmfObrY2dlh7ty5+P333+Hj44MOHTrg008/1Ur+z549i969e8PNzQ2urq7w8vJS/wh6/PrU9Rni5uam9/sW0P68CwkJgVQqLfF9C6j+Vzt27ND6X3Xt2hUAynzdPr4PU18PNWrUQHR0NL7++mt4enoiMjISS5Ys0TjP8fHxEEKgdu3aWrGcP3/+qd6jUqm01B/O+nyG2NjYoG/fvvjll1/U0zdt2oTCwsKnTm5snrwIAZq/SIr9/fff6NmzJzp06IClS5fCz88Ptra2WLVqFX744Qe9tiuTyXROF0IAgPoiX7t2LXx9fbWWe7Rkojw9Ke6SODg44K+//sKePXuwbds27NixA+vXr0fnzp2xa9cuyGQyfPfddxg2bBh69eqF8ePHw9vbGzKZDHPmzMHly5f1jqWsMeqj+P8yb948NGnSROcyjycrxtC/f38cPHgQ48ePR5MmTeDs7AylUolu3brp9YF4+fJldOnSBaGhoVi4cCECAwMhl8uxfft2fPbZZ+ptSCQS/Pzzzzh8+DB+/fVX7Ny5EyNGjMCCBQtw+PBh9X69vb3x/fff69yXl5eXUY/9UfpcRwDwyiuvYPjw4Th16hSaNGmCDRs2oEuXLvD09DRqPEqlEg0bNsTChQt1zi/+wtY3blMq6/vinXfeQY8ePbBlyxbs3LkTkydPxpw5c/Dnn3+iadOmSE9PR8eOHeHq6ooZM2YgJCQE9vb2OHHiBD744AOt69MU79vHkyVdlEolnn32Wbz//vs65xcnIE+jvK6HBQsWYNiwYfjll1+wa9cujBkzBnPmzMHhw4dRrVo1KJVKSCQS/P777zq3ZYrPqGL6fIYAqvfo8uXL8fvvv6NXr17YsGEDQkND0bhx46faP5ObB/R5Uzxu48aNsLe3x86dO2FnZ6eevmrVKqPFFRISAgDw9vZW/7LQJSgoCMDDEoVHxcXFPXE/xevHxcVpFG8XFBTg6tWrpe7bUFKpFF26dEGXLl2wcOFCzJ49G5MmTcKePXvQtWtX/Pzzz6hZsyY2bdqk8X/RdZvCGC5dugQhhMa+Ll68CAAl9uxc/H9xdXV96nMTFBSE2NhYZGdna3zYPP5/u3fvHmJjYzF9+nRMmTJFPV3X/7yk6/nXX39Ffn4+tm7dqvELvqTi6datW6N169b4+OOP8cMPP2Dw4MFYt24d3njjDYSEhOCPP/5A27ZtdSb/+sSjS0hICHbu3Im7d++WWnrzpOsIAHr16oU333xTXex98eJFTJw4Ue9Y9D2OkJAQnD59Gl26dHnisT4pbkPOlZeXFxwdHXW+xy9cuACpVKpVEvI0QkJC8N577+G9995DfHw8mjRpggULFuC7777D3r17cefOHWzatAkdOnRQr3P16lWj7f9x8fHxGqXqly5dglKpLLVH9pCQEGRnZxvlM60iXA8NGzZEw4YN8dFHH+HgwYNo27Ytli1bhlmzZiEkJARCCNSoUeOJSZuh71GlUolz586V+OOuWGmfIQDQoUMH+Pn5Yf369WjXrh3+/PNPTJo0Se9YSsLbUg84OTkBgEGdnslkMkgkEigUCvW0a9euYcuWLUaLKzIyEq6urpg9e7bO+5apqakAVPfYmzRpgjVr1mgUS+7evRvnzp174n66du0KuVyOL774QuMX0jfffIOMjAx0797dCEejuq3yuOI3R3GxZPEvjEfj+Oeff3Do0CGjxPC427dvY/PmzerXmZmZ+Pbbb9GkSROdpWUA0Lx5c4SEhGD+/PnIzs7Wml/8f9HHCy+8gKKiInz55ZfqaQqFAosWLdJYTtd5AaCz462Srmdd28jIyNBKyO/du6e1n8f/T/3794dCocDMmTO19l9UVKSxbycnJ53vrcLCQly4cAGJiYnqaX379oUQAtOnT9davjgmfa4jQHXfPzIyEhs2bMC6desgl8vRq1cvrXX15eTkpPP2X//+/XHr1i2dHXXev38fOTk5esdtyGeRTCbDc889h19++UXjVkxycjJ++OEHtGvXDq6urk/czpPk5uZq9e0VEhICFxeXUt+3BQUFWLp06VPvvyRLlizReF38nnn++edLXKd///44dOgQdu7cqTUvPT0dRUVFeu/fnNdDZmamVqwNGzaEVCpVr9unTx/IZDJMnz5d6/0shMCdO3eeeCyAKlFOSEhQv+7VqxekUilmzJihVSJXvB99PkMAVXL38ssv49dff8XatWtRVFRklDpxLLl5oHnz5gCASZMm4ZVXXoGtrS169OihvrB06d69OxYuXIhu3bph0KBBSElJwZIlS1CrVi38+++/RonL1dUVX375JV577TU0a9YMr7zyCry8vJCQkIBt27ahbdu2WLx4MQBgzpw56N69O9q1a4cRI0bg7t27WLRoEerXr6/zC/hRXl5emDhxIqZPn45u3bqhZ8+eiIuLw9KlS9GyZUuNysNPY8aMGfjrr7/QvXt3BAUFISUlBUuXLkW1atXQrl07AMCLL76ITZs2oXfv3ujevTuuXr2KZcuWoV69ek88jrKoU6cOXn/9dRw9ehQ+Pj5YuXIlkpOTSy2Bk0ql+Prrr/H888+jfv36GD58OAICAnDr1i3s2bMHrq6u+PXXX/Xaf48ePdC2bVtMmDAB165dQ7169bBp0yatDxpXV1d1XYfCwkIEBARg165dOn8Zl3Q9P/fcc5DL5ejRowfefPNNZGdnY8WKFfD29tZIMNasWYOlS5eid+/eCAkJQVZWFlasWAFXV1e88MILAFT31N98803MmTMHp06dwnPPPQdbW1vEx8fjp59+wueff46XX35ZHc+XX36JWbNmoVatWvD29kbnzp1x69YthIWFYejQoeoejDt16oTXXnsNX3zxBeLj49W33P7++2906tQJUVFRel1HxQYMGIBXX30VS5cuRWRkpLqi46OKf+mXVlej+DjWr1+P6OhotGzZEs7OzujRowdee+01bNiwAW+99Rb27NmDtm3bQqFQ4MKFC9iwYQN27tyJFi1a6BV3SEgI3N3dsWzZMri4uMDJyQnh4eEl1vubNWsWdu/ejXbt2uHtt9+GjY0Nli9fjvz8fHz66aelHo++Ll68iC5duqB///6oV68ebGxssHnzZiQnJ6srBbdp0wYeHh4YOnQoxowZA4lEgrVr1xrlNnBJrl69ip49e6Jbt244dOgQvvvuOwwaNKjUWxrjx4/H1q1b8eKLL2LYsGFo3rw5cnJycObMGfz888+4du2a3rctzXk9nD59GlFRUejXrx/q1KmDoqIirF27FjKZDH379lWvO2vWLEycOBHXrl1Dr1694OLigqtXr2Lz5s0YNWoUxo0bV+qxAKr6Wx07dlSPrVerVi1MmjQJM2fORPv27dGnTx/Y2dnh6NGj8Pf3x5w5c/T6DCk2YMAALFq0CFOnTkXDhg0RFhZm0HWg01O1tbIwM2fOFAEBAUIqlWo0o8WDTvx0+eabb0Tt2rWFnZ2dCA0NFatWrVI3U3xUSU3BH28mV1JncXv27BGRkZHCzc1N2Nvbi5CQEDFs2DBx7NgxjeU2btwowsLChJ2dnahXr57BnfgtXrxYhIaGCltbW+Hj4yP+97//ldiJ3+P02U9sbKx46aWXhL+/v5DL5cLf318MHDhQo1mmUqkUs2fPFkFBQcLOzk40bdpU/Pbbb1rbf7QTv8fPFXQ0kdR1zh/txK9Ro0bq/+Pj65b0fzl58qTo06ePqFq1qrCzsxNBQUGif//+IjY2ttTz8Lg7d+6I1157Td2J32uvvaazE7+bN2+K3r17C3d3d+Hm5ib69esnbt++LQCIqVOnamyzpOt569atolGjRupOtebOnStWrlypscyJEyfEwIEDRfXq1dWd87344ota15sQQnz11VeiefPmwsHBQbi4uIiGDRuK999/X9y+fVu9TFJSkujevbtwcXEReKQTv+L/4eOdrBUVFYl58+aJ0NBQIZfLhZeXl3j++efF8ePHhRD6XUfFMjMzhYODgwAgvvvuO53n39PTU7Ru3bqU/5BKdna2GDRokHB3d9fqYqGgoEDMnTtX3Ymmh4eHaN68uZg+fbrIyMgwKO5ffvlF3WHo49eALidOnBCRkZHC2dlZODo6ik6dOomDBw9qLGPoZ86j0tLSxOjRo0VoaKhwcnISbm5uIjw8XGzYsEFjuQMHDojWrVurO/Z8//331c19H91+SZ8hxe/Hxz3+GVz8GXvu3Dnx8ssvCxcXF+Hh4SGioqL06sQvKytLTJw4UdSqVUvI5XLh6ekp2rRpI+bPn6/Rp9eTmPN6uHLlihgxYoQICQkR9vb2okqVKqJTp07ijz/+0Ipz48aNol27dsLJyUk4OTmJ0NBQMXr0aBEXF6fXsTz6nn3UypUrRdOmTdXH17FjR3WHi4Z8hiiVShEYGCgAiFmzZul9/ksjeRA4kVUKDg5GgwYN8Ntvv5k7FDKTc+fOoX79+vjtt9+MdvuVTGvatGmYPn06UlNTjV45nCwD69wQkVXbs2cPIiIimNgQWRDWuSEyEYVC8cSKxc7OziZtjklPNnr0aK3O4Mi63b17FwUFBSXOl8lkJu3qgJ4ekxsiE7lx40aJlUCLTZ06FdOmTSufgIhIL3369MG+fftKnB8UFPTEyudkXqxzQ2QieXl52L9/f6nL1KxZU6NfISIyv+PHjz9xmIm2bduWY0RkKCY3REREZFFYoZiIiIgsCpMbIiIisihMbojIqK5duwaJRKLz0bp1a/VycXFxePfdd9GmTRvY29tDIpEYVElTqVTi22+/RXh4OKpUqQIXFxfUqVMHQ4YMweHDh01wZERUWbC1FBGZxMCBA7W6WX+0+eyhQ4fwxRdfoF69eggLC8OpU6cM2v6YMWOwZMkSvPTSSxg8eDBsbGwQFxeH33//HTVr1tRIpIjIujC5ISKTaNasWaljkvXs2RPp6elwcXHB/PnzDUpukpOTsXTpUowcORJfffWVxryYmBiDBi59WkVFRVAqlZDL5eW2TyIqHW9LEZFZFN9KKourV69CCKGzOa5EIoG3t7fGtPT0dLz77rsIDg6GnZ0dqlWrhiFDhiAtLU29TEpKCl5//XX4+PjA3t4ejRs3xpo1azS2U3zLbf78+YiJiUFISAjs7Oxw7tw5AKrRk19++WVUqVIF9vb2aNGiBbZu3VqmYySismPJDRGZRG5urkbyAABubm6wtbV96m0HBQUBAH766Sf069cPjo6OJS6bnZ2N9u3b4/z58xgxYgSaNWuGtLQ0bN26FTdv3oSnpyfu37+PZ555BpcuXUJUVBRq1KiBn376CcOGDUN6ejrGjh2rsc1Vq1YhLy8Po0aNgp2dHapUqYKzZ8+ibdu2CAgIwIQJE+Dk5IQNGzagV69e2LhxI3r37v3Ux01EejLK8JtERA8Uj/St61HSyNPz5s3TGJVcH0OGDBEAhIeHh+jdu7eYP3++OH/+vNZyU6ZMEQDEpk2btOYplUohhBAxMTFao4YXFBSIiIgI4ezsLDIzMzWOzdXVVaSkpGhsq0uXLqJhw4YiLy9PY/tt2rQRtWvX1vu4iOjp8bYUEZnEqFGjsHv3bo1H48aNjbb9VatWYfHixahRowY2b96McePGISwsDF26dMGtW7fUy23cuBGNGzfWWXIikUgAANu3b4evry8GDhyonmdra4sxY8YgOztbqyv+vn37alSOvnv3Lv7880/0798fWVlZSEtLQ1paGu7cuYPIyEjEx8drxEREpsXbUkRkErVr10bXrl1Ntn2pVKoe9PLOnTs4cOAAli1bht9//x2vvPIK/v77bwDA5cuX0bdv31K3df36ddSuXRtSqebvvbCwMPX8Rz0+ZtilS5cghMDkyZMxefJknftISUlBQECAQcdIRGXD5IaIKr2qVauiZ8+e6NmzJ5555hns27cP169fV9fNMTYHBweN10qlEgAwbtw4REZG6lynVq1aJomFiLQxuSEii9KiRQvs27cPiYmJCAoKQkhICP77779S1wkKCsK///4LpVKpUXpz4cIF9fzSFA9+amtra9LSKiLSD+vcEFGlk5SUpG5+/aiCggLExsZCKpWqS0r69u2L06dPY/PmzVrLiwfjBr/wwgtISkrC+vXr1fOKioqwaNEiODs7o2PHjqXG4+3tjWeeeQbLly9HYmKi1vzy7HeHiFhyQ0RmkpGRgUWLFgEADhw4AABYvHgx3N3d4e7ujqioqBLXvXnzJlq1aoXOnTujS5cu8PX1RUpKCn788UecPn0a77zzDjw9PQEA48ePx88//4x+/fphxIgRaN68Oe7evYutW7di2bJlaNy4MUaNGoXly5dj2LBhOH78OIKDg/Hzzz/jwIEDiImJ0as/niVLlqBdu3Zo2LAhRo4ciZo1ayI5ORmHDh3CzZs3cfr0aSOcNSLSi7mbaxGRZSluLj1v3jy9ltP1CAoKKnXdzMxM8fnnn4vIyEhRrVo1YWtrK1xcXERERIRYsWKFuol3sTt37oioqCgREBAg5HK5qFatmhg6dKhIS0tTL5OcnCyGDx8uPD09hVwuFw0bNhSrVq0y6NguX74shgwZInx9fYWtra0ICAgQL774ovj5559LPR4iMi6JEA/KZYmIiIgsAOvcEBERkUVhckNEREQWhckNERERWRQmN0RERGRRmNwQERGRRWFyQ0RERBbF6jrxUyqVuH37NlxcXNQjAhMREVHFJoRAVlYW/P39tQa5fZzVJTe3b99GYGCgucMgIiKiMrhx4waqVatW6jJWl9wUd6N+48YNuLq6mjkaIiIi0kdmZiYCAwP1Gg7F6pKb4ltRrq6uTG6IiIgqGX2qlLBCMREREVkUJjdERERkUZjcEBERkUVhckNEREQWhckNERERWRQmN0RERGRRmNwQERGRRWFyQ0RERBaFyQ0RERFZFCY3REREZFGY3BAREZFFYXJDREREFsXqBs4kslqFeUBOSplWVSoF8m1c4eDqYeSgiKjMslOBovtlWzW/CFl5hUYO6CFbOwd4+lY32fafhMkNkTXIywCWtAaybpdpdSkAqbDFhRfXIbRlV+PGRkSGO/o1sO29Mq/u/OBhKhdswuD50WET7qF0TG6IrMHx1arERiIFZHKDVlUKgaKiIthJCuH4+xjkNTgKewcn08RJRE+WnQr8MV31XGYHSCR6ryoAFBYpoRTCNLE9oJCaN71gckNk6YrygcNfqp73XAw0HWzQ6uPWn0LsyTjstnsf1ZW3cOjbCYh4c5EJAiUivfw5A8jPBPwaAyP3AFKZ3qvu/C8Rb313AnIbKWKjOyKwiqNJQqxvkq3qjxWKiSzdmZ+ArETAxQ9o2M+gVW+l38fW07eRAWccCvsIANDq9lpcPLHPFJES0ZPcPgWcWKt63m2uQYlNXqECs7adBwCMal/TZIlNRcDkhsiSKZXAgS9Uz1v/D7Ax7JbUyv1XUaQUiKhZFS+9MhLHXLpAJhGQ/xaF/LxcEwRMRCUSAtgxAYAAGrwMBEUYtPrXf1/BzXv34etqj7c7hZgmxgqCyQ2RJYvfCaTFAXauQPNhBq2akVuIH48kAADe7FgTABAyZAnuwA3BygSc+G6SsaMlotL8txFIOATYOADPTjdo1aSMPCzZcxkAMOH5UDjKLbtWCpMbIktWXGrTYjhg72bQqt/9cx25BQqE+rqgYx0vAICHlx+uh6s+VFveWI1Lpw8YNVwiKkFBLrB7iup5+2jArZpBq3/y+3ncL1SgeZAHXmrib4IAKxYmN0SW6sYRIOEgILUFwv9n0Kp5hQqsOnANgKrURvJIa4xmzw/HCecOsJEoIdk6GgX5ecaMmoh0ORADZN4C3KoDbf7PoFWPX7+LLaduQyIBpvaop/F+tlRMbogs1YHPVX8bDwBc/QxadfPJW0jLzoe/mz1ebKT9K6/6q0txDy4IUVzF8R+mGiNaIipJesLD9/NzMwFbB71XVSoFpv96DgDQr3k1NKrmboIAKx4mN0SWKC0euLBN9bzNGINWVSgFVvx1BQDwevuasJVpf0x4+gbicvPJAIDm11bg6tl/ni5eIirZrslAUR4Q3B6o95JBq/584ib+vZkBZzsbjIusa6IAKx4mN0SW6OAiAAKo+wLgZdgH2u5zybiSlgM3B1u80jKwxOWadx+Jk45tIJcoULTpbRQVFjxl0ESk5dp+4NwWVQec3T4xqMO+rLxCfLojDgAwpksteLvYmyjIiseyq0sTWaOsZOD0j6rnbccatKoQAsv2qVpUvNY6CE52JX9ESKRSBL66DJlfRaC24hJOxPRFvqv5xpIxh2Snujhf9Vmd82QSCXo3DUBtH5dyjooshlIB/D5B9bz5cMC3gUGrL/7zEtKy81HD0wnD2tQwQYAVF5MbIkvzzzJAUQAEhgPVWxu06tFr93DqRjrkNlIMbRP8xOU9/YNwtMmHaHlqEprl/AXklDHmSuzXc+mIVTbXOe+XU7exfWx7uDnYlnNUZBFOrAGSz6haOnYyrOuFK6nZWHngKgBg8othkNtY140aJjdEliQ/Czj6jeq5gaU2ALD8QanNy82rwcvFTq91WvR8G/8U5kGkXTJ4f5WZ5/1rqJV5CF84rsRX9Tsjx7aKxvwdZ5Nw8959TPnlP3z+SlMzRUlmlXAY+GkYUFDGrL94vU6TAKeqBq06e/t5FCoEOtbxQqe63mXbfyXG5IbIkhxfA+RnAFVrA3WeN2jVi8lZiL2QAokEGNm+pt7rSaRShPcbZ2iklV9RPrCiM5yS/8O7uZ8DgzZo1Id4oZEf+i07hF9O3UbnUG+81CTAjMFSuVMqgW3jVEOfPA3fRkCLEQatcujyHfxxPgUyqQSTX7SOpt+PY3JDZCmKCoDDS1XP244BpIYVQ3/1oIVUt/q+qOHJUb+fyMYO6Ps1sLwjEL8LOPo10Gqkenaz6h74v861EPNHPD7a/B+aB3mgmofljuVDjzmzQXVLyc4VGL4dsC3j/94tEJDpf1tTqRSY87tq/KhBraqjlrdz2fZbyTG5IaosivJV9Wnu39M9P+OmqpMvZx+g0QCt2dvPJOLMrQydqyqFwC+nbgEARnXQv9TG6nmHAc/OAHZ8AOz6SNVU1ztUPTuqUy38dTEVJxLSEb3+NH4c1RoyqfX9irY6hXlA7EzV8/bRgG/Dctv1tjOJ+PdmBpzkMozpUrvc9lvRMLkhqiz+Wf6w+/XShL+lKlV4RFxSFt7+/sQTV21VowqaVvcoa4TWKfxNVcnN5Vhg0xvAG3+qByi1kUkRM6Apnv/8Lxy5dhfL9l3G6E61zBywiSiKgL/mARk3yrR6wt1cJGearrfrK46NcdT9eYOaUuvrmbpemp1dHlkOZN4EXANU78dykl+kwKc7LwAA3uwYone9OUvE5IaoMlAqgCMrVM/Deqi6YNfF0QOIGK01efXBawCABgGuCK+hu2KijUyCQa2sqym3UUgkQK+lwJdtgKQzwJ5ZqtKcB6pXdcS0nvUx/ud/8dnui2hf29Mye4k9uRbY90mZV6/+4GEqLdN/x5nryfhOobvp/tP4+fhNCAH0aOwP5N4F/lqgmtH5I4N6E35a3x9OwI279+HlYoc32ltX0+/HmT25WbJkCebNm4ekpCQ0btwYixYtQqtWrUpcPiYmBl9++SUSEhLg6emJl19+GXPmzIG9vfV0TkRWKO53ICMBcKgC9Flh0Admem4BNp+8CQCY8mJ9tKpR5QlrkMFcfIGei4B1g1SDldZ6FqjRXj375ebVsCcuBdvPJOGddafw25h2ljUqc1E+8Nd81fNGr2jcmtPHb/8m4r9bGfBzd0AdE/QL5J6bgLCkLZguX4tmTTog2a2x0bZ9LjETv56+jfd//he1fZwRenqBqlK/TwOdt4dNJeN+IRb9GQ8AiH62jmVdX2Vg1qNfv349oqOjsWzZMoSHhyMmJgaRkZGIi4uDt7d207UffvgBEyZMwMqVK9GmTRtcvHgRw4YNg0QiwcKFC81wBETl5Mhy1d/mQw3+Jbjh2A3kFSoR5ueKlsG85WQyod2BZkNVfZNsfhP43wHAQXW+JRIJZvduiBPX03ElLQeztp3H7N7lVw/D5E58q7oN4+IP9PgcsNX/x+aV1GyM2bYPSgFseaUtmgS6Gz8+IYCfh0N2djP6xE8A3vxLlZAagUIpkJ5bgL/j0zB1zXasK/gKEgB4djoglRllH/pYtu8y7uUWopa3M/o1N2zEcEtk1l59Fi5ciJEjR2L48OGoV68eli1bBkdHR6xcuVLn8gcPHkTbtm0xaNAgBAcH47nnnsPAgQNx5MiRco6cqBwlnwOu/gVIZECL1w1aVaEU+PbQdQDA8DbBVtkktFx1mwNUCVFV7P4tWvWl+oC7oxwL+qtKDH74JwG7zyWbK0rjKrwP/P3gNkyH9wxKbADgi9h4KAXQNczbNIkNoLp12HMx4BUGZCcDG4aoWhcagUwqwRevNEU1DwcMzF4DiaIAosYzQEgXo2xfH7fT72PlflWHfRO6hcJGx3hw1sZsJTcFBQU4fvw4Jk6cqJ4mlUrRtWtXHDp0SOc6bdq0wXfffYcjR46gVatWuHLlCrZv347XXnutxP3k5+cjPz9f/TozM9N4B0FUHo58pfob2h1wL3msJ11izyfj5r378HC0Rc8m2qN7k5HJnYC+K4BvngPObgKyUzQqd7cFEOudjZv37sNmgwT/2pet5+ICiR1+cx2AK3ZhRgpcf3V9nPHec3Vhb/ugVOLYKlVfLm6BQNOSP4t1iU/Owi+nbwMA3ulax9iharJzBl75HviqE3DjH2Dnh0D3+UbZtIeTHKsjbVFry0EAwHcur+O1cvwhsXD3ReQXKdGqRhV0CbO+Dvt0MVtyk5aWBoVCAR8fH43pPj4+uHDhgs51Bg0ahLS0NLRr1w5CCBQVFeGtt97Chx9+WOJ+5syZg+nTpxs1dqJyc/8e8O961fMytLoorkj8SqvqD7+MyLQCmgPPTAD+nAVc3681OwRASPG/4ikaB4XknsYL+XOQCMN6rn1af11MRXZ+Eeb0aaTqQXf/gyoBHcZptdJ7kpjYeAgBRNb3QYMANxNE+5iqIUCfr4AfBwBHVwABzYAmg55+u0Kg1qm5AIBNinaYfEQGn7pJeK6+cW59leZ8YiY2nlDVqfvwhTCWzj5QqWoc7d27F7Nnz8bSpUsRHh6OS5cuYezYsZg5cyYmT56sc52JEyciOjpa/TozMxOBgYb9+iUym5PfAYW5qsqJQW0MWvVichYOXr4DqQR4tXWQiQIkndqPA3waAnnpOmdn5RXiYnI2lI/ctjJErStr4ZFxDr/5fYO/2q6GkJbP2FV3cwrw8fbz+PHIDbSqUQW9czcBOamAexDQZLBB27qQlIlt/6p67333WROX2jyqbjfgmYnA3jnAr++o+iryf8rhMS79AVz7G5DJcb3+u8DxfERvOI1fopwR4mXaTvQ++f0ChAC6N/Iz3W29SshsyY2npydkMhmSkzXvOycnJ8PXV3e2O3nyZLz22mt44403AAANGzZETk4ORo0ahUmTJkGqo0dWOzs72NlZb1t/qsSUioe3pMLfNLh/juJSm8j6vghwL7/mqATV/6putxJnuwDQPdSmnu69ACzrgKr3TqH3na+ByI+fZmsGyc4vQswf8Zi16Sh6OH2m+hLp+IFBvegCwGe7LwJQfSmH+roaP9DSdHgfuH0SuLgDWP8aMGqfwWM3qSkVD/ufCn8TUV0649Cdf3Dk2l28ufY4toxuC2c703zV7o9Pw76LqbCVSfB+ZF2T7KOyMlutI7lcjubNmyM2NlY9TalUIjY2FhERETrXyc3N1UpgZDJV+a4o4y8gogrr4k4gPUHV4qZhP4NWzcgtxOYTqh6H9RndmyoZj2Cg1xLV80OLgQvbym3X/9e5NtrV8sQA5e+wybsLZZUQg5s8/3crAzvPJkMiAd4xRy+6UinQe7mq8nfGDeDn4apOCMvi9I9AyjnA3h1o/x5sZVIsHtwUPq52uJSSjfE/nTbJ99OjwywMDg9CUFUOmfIos96Wio6OxtChQ9GiRQu0atUKMTExyMnJwfDhwwEAQ4YMQUBAAObMmQMA6NGjBxYuXIimTZuqb0tNnjwZPXr0UCc5RBbjn2Wqv82GlKn59/1CBUJ9XRDOfm0sU1gPoPVo4PASYMv/VM2bPYJNvluZVIKYXiGwXaxKqH5wGIjBUhkMKVeM+UNVavNSY3/UNkG/NnpxcFdVMF7RBbi6D/jYF5CU4fe+4kGrqw7j1E3/vV3s8eWrzTFg+SH8/l8S6n60AwadIH0IoEChhIudDf6vs4X2ev0UzJrcDBgwAKmpqZgyZQqSkpLQpEkT7NixQ13JOCEhQaOk5qOPPoJEIsFHH32EW7duwcvLCz169MDHH5dfkSxRuUi5oPrAlUiBlm8YtKpCKfDt4WsAgGFs/m3Zuk5Ttfy5dQz4aTgwYqd66AdT8vzvGwDZuKT0x5TLoZAfu4n+LfWry3jqRjr+OJ8CqQTmH/vIOwzovUzVL1Fhbtm341kXaDlSY1Kz6h74uHdDfLT5PxQolE8ZaMneebYOqjqz6sXjJMLK7udkZmbCzc0NGRkZcHUt5/u8RPr67V3g2Eog9EXVr0sD7D6XjJHfHoObgy0OT+wCBzlLNS1aegKwrL2q8nL4W8Dzc027v/v3gJjGQH4GdobNwZsng2BnI8WW0W0R5vfkz9ShK49g38VU9G1WTd3vj9nlZQJ5ugeV1YuLb4l1jjLuFyI7v4y3vJ7AzkYKTytKbAz5/q5UraWIrML9dOD0OtXzMjT/XqNu/h3IxMYauFdX1R/5cYDqVmb1CKB+L9Pt79BS1fAC3vXw7MtvomPOcey7mIrR35/A1v9rV2rl2ePX72LfxVTIpBKMNXepzaPsXVUPE3BzsIWbQ/m0ZqOH2I0hUUVz6ntVEbl3PSC4nUGrxidnYf+lNEglwGts/m096nYD2o5VPd/6f8DdK6bZT+5d4PCXqufPTIRUJsNnA5rAz80eV9Jy8OGmM6VWnl34oIVUv+bVUL2qo2liJAJLbogqlqds/r3m0DUAwLP1fFDNg18eVqXzZCDhH+DGYeD7/gb3i6SXO5eAgizAt5GqQjOAKk5yLBrYFAO+Ooytp2+jUKGEu6N2SUVeoRIHLt2BrUyCKFaAJRNjckNUkcTvBu5dUzUrbdjfoFUz7hdiE5t/Wy+ZLfDySmB5e+BOvOphKp0+1Ei8WwRXwQfd6mL29gv4/b+kUlcd0DKQiTeZHJMbovJ08xhw9GugKF/n7KyrR+ECYLdDJH75WfcwJCVJzsxDboECdX1cEFGzfLvkpwrCLQAY+Sfw3yZAKEyzD/dgoI52B4Uj29dE9SpOuJSSVeKq9rYyvNKqumniInoEkxui8nJlL/DDK0DR/RIXcQFQKGSYntQGNxMTy7Sb4W3Z/NuqeQQD7aOfuJixSSQSdGvgC8D04ykRPQmTG6LycCkWWDcIKMoDanYC6j6vtciuc0k4cOkOCjzr441WHcu0Gw8nOXo04ujfRGTdmNwQmVr8H6rERpGvKs7v/63W6MkFRUp8uDsWaYoCLH+uOSLLYTRhIiJLxabgRKZ0cRewbqAqsanbXWdiAwB/nE9GWnYBvF3s0DnU2wyBEhFZDpbcEJlK3O+qEYeVhaqehl9eVWLX+D8eSQAA9GtRDbYy/uYgInoa/BQlMoUL2x4mNvVeAvqtLjGxuXE3F/svpQEABrRgSxIioqfFkhuyTvnZwP27Jc6+m1OA/KKyNaW1TzwG911jIFEWAQ36Ar2/AmQlv9XWH70BIYD2tT3ZaysRkREwuSHrk54ALI0ACrJLXKSKEXYjGvaDpNeyUhObIoUSPx2/AQB4pSVLbYiIjIHJDVmfUz+oEhuJTOdIvgUKJZTKksfHeRIFpPhZ0QEuwZPRp5TEBgD2xKUiOTMfVZ3keLaeT5n3SUREDzG5IesiBPDvetXz3suARtpDHAxedhBHr93D4kFN8WIZ+oxZsucS5u2Mg/u2OLSv4wsvF+3WUcWKKxK/3Lwa5DasAkdEZAz8NCXrcuu4asRkW0eg7gs6F0nMyAMA+LnZl2kXozrURD0/V6TnFmLa1rMlLnc7/T72xqUAUI23Q0RExsHkhqxLcalN6IuAnbPWbKVSIDlTldz4ujmUaRe2Mik+fbkRZFIJtp1JxI4SBhLccOwGlAJoXbMKanppx0JERGXD5Iash6JQNaAgADQaoHOROzkFKFQISCSAdym3k56kQYAb3uxQEwAw+Zf/kJFbqBmKUmDDUVVF4oEcSJCIyKiY3JD1uLwHyE0DnLyAms/oXCTpwS0pL2e7p+5Mb0yX2qjp6YTUrHx8vP2cxry/4lNxOyMP7o62HGqBiMjImNyQ9Si+JdXg5RKbZydmqEbsLmt9m0fZ28ow9+VGkEiADcdu4u/4VPW8H/9RVSTu07Qa7G1lT70vIiJ6iMkNWYf8LFWvwQDQqF+JiyWp69s8fXIDAC2Dq2BI6yAAwMRNZ5CTX4SUzDzEXlBVJB7YihWJiYiMjU3ByTqc/w0oug9UrQX4NytxsYctpcpWmViX8d1C8cf5FNy8dx/zd8XB09kOCqVAiyAP1PZxMdp+iIhIhSU3ZB2Kb0k1GgBIJCUulpxh3JIbAHC2s8HsPg0BAKsPXsM3+68CAF5hRWIiIpNgckOWLysJuLpP9bxhybekgKfv46YkHet4oW+zahBCNW6Vi70Nujf0M+o+iIhIhckNWb7/NgJCCQSGA1VqlLqous6Nq3GTGwCY/GIYPJ1Vzct7Nw2Ag5wViYmITIHJDVk+9S0p7aEWHiWEeKS1lPHq3BRzd5Rj2avN0KdpAKI61zL69omISIUVismypVwAEk8DUhugXu9SF824X4i8QiUAwNu17B34laZFcBW0CDbGmONERFQSltyQZTuzQfW31rOAU9VSFy2ub1PVSc6+Z4iIKjEmN2S5lErg359Uz59wSwp42DuxMVtKERFR+WNyQ5brxmEgIwGQuwB1n3/i4qZqKUVEROWLyQ1ZruKKxPVeAmyfXEE46UFlYpbcEBFVbkxuyDIV5QNnt6ielzLcwqOKS25M0QyciIjKD5Mbskzxu4G8dMDFDwhur9cqD8eVMn4zcCIiKj9MbsgyFd+SavgyINWv5RPr3BARWQYmN2SZru1X/a3XS+9V2FqKiMgyMLkhy5NzB7h/V/Xcu55eq2TlFSI7vwgA69wQEVV2TG7I8qRdVP11qw7IHfVapbjUxtXeBk527LibiKgyY3JDlictTvXXq47eqzysb8PKxERElR2TG7I8afGqv576Jzesb0NEZDmY3JDlKb4t5Vlb71XYUoqIyHIwuSHLo05uDCi5yWTvxEREloLJDVmWwjzg3nXVcwOSG5bcEBFZDiY3ZFnuXAIgAHt3wMlL79Ue1rlhhWIiosqOyQ1ZlkdvSUkkeq/GkhsiIsvB5IYsSxlaSt0vUCDjfiEA1rkhIrIETG7IspShpVTxgJlOchlc2IEfEVGlx+SGLEsZWkolZjxsKSUx4FYWERFVTExuyHIolU/VgR97JyYisgxMbshyZN4Eiu4DUlvAI1jv1YorE/twwEwiIovA5IYsR/EtqaohgEz/ujNJbClFRGRRmNyQ5VDfktK/MjHwsOSGLaWIiCwDkxuyHGWoTAw8HHqBJTdERJaByQ1ZjtQyJjcsuSEisihMbshylKHkJr9IgbTsAgBsLUVEZCmY3JBluH8PyElRPTegzk1KZj4AQG4jhYejrSkiIyKicsbkhixD2iXVXxd/wM5F79UeHVOKHfgREVkGJjdkGcow7ALwSO/E7OOGiMhiMLkhy5AWp/pbxsrEbClFRGQ5mNyQZSju48arrkGrPezjhpWJiYgsBZMbsgxlvC3FkhsiIsvD5IYqv6IC4O5V1XMDb0slZrKPGyIiS8Pkhiq/e1cBoQDkzoCLn0GrJmWwd2IiIkvD5IYqv9TiysS1AQOacxcqlEjJUvVzw5IbIiLLweSGKr8yjimVmpUPIQAbqQSeTnYmCIyIiMyByQ1VfurRwA2sb/OgMrGPqz2kUnbgR0RkKZjcUOVX1tHAOWAmEZFFYnJDlZsQT1Fy86B3YiY3REQWxezJzZIlSxAcHAx7e3uEh4fjyJEjpS6fnp6O0aNHw8/PD3Z2dqhTpw62b99eTtFShZOVBBRkARIZUKWGQauq+7jh0AtERBbFxpw7X79+PaKjo7Fs2TKEh4cjJiYGkZGRiIuLg7e3t9byBQUFePbZZ+Ht7Y2ff/4ZAQEBuH79Otzd3cs/eKoYiodd8AgGbAyrFJzEPm6IiCySWZObhQsXYuTIkRg+fDgAYNmyZdi2bRtWrlyJCRMmaC2/cuVK3L17FwcPHoStrS0AIDg4uDxDpoqmjMMuAI/2TsyhF4iILInZbksVFBTg+PHj6Nq168NgpFJ07doVhw4d0rnO1q1bERERgdGjR8PHxwcNGjTA7NmzoVAoyitsqmjKOOwC8Oi4Uiy5ISKyJGYruUlLS4NCoYCPj4/GdB8fH1y4cEHnOleuXMGff/6JwYMHY/v27bh06RLefvttFBYWYurUqTrXyc/PR35+vvp1Zmam8Q6CzK+MLaWUSoHkTI4rRURkicxeodgQSqUS3t7e+Oqrr9C8eXMMGDAAkyZNwrJly0pcZ86cOXBzc1M/AgMDyzFiMrkytpRKy8lHkVJAKgG8XNiBHxGRJTFbcuPp6QmZTIbk5GSN6cnJyfD19dW5jp+fH+rUqQOZTKaeFhYWhqSkJBQUFOhcZ+LEicjIyFA/bty4YbyDIPPKzwIyb6mel3E0cC8XO9jKKlWOT0RET2C2T3W5XI7mzZsjNjZWPU2pVCI2NhYRERE612nbti0uXboEpVKpnnbx4kX4+flBLpfrXMfOzg6urq4aD7IQxaU2Tt6Ag4dBqz6sb8PKxERElsasP1mjo6OxYsUKrFmzBufPn8f//vc/5OTkqFtPDRkyBBMnTlQv/7///Q93797F2LFjcfHiRWzbtg2zZ8/G6NGjzXUIZE5lvCUFsI8bIiJLZtam4AMGDEBqaiqmTJmCpKQkNGnSBDt27FBXMk5ISIBU+jD/CgwMxM6dO/Huu++iUaNGCAgIwNixY/HBBx+Y6xDInNhSioiIdDBrcgMAUVFRiIqK0jlv7969WtMiIiJw+PBhE0dFlUIZW0oBQNKDoRfYUoqIyPKwJiVVXk+R3LDkhojIcjG5ocpJUQTcuax6XobbUkmZ7J2YiMhSMbmhyin9OqAsBGwcADfD+i4SQqhLbnhbiojI8pi9zg1RmahvSdUCpNo5ulIpkJiZByGE1rzM+0UoKFJ1J+Dtyg78iIgsDZMbqpxSHwzRUUJ9m1Frj+GP8ymlbsLTWQ47G1mpyxARUeXD5IYqp+sHVX/9GmvNupdTgNgLqsTGzkb3nVeJBOjbrJrJwiMiIvNhckOVT1E+cG2/6nlIF63ZBy6nQQigro8Ldr7boZyDIyIic2OFYqp8bvwDFOaqhl3wqa81+++LaQCA9rU9yzsyIiKqAJjcUOVz+U/V35BOqvtLjxBC4O/4VABA+zpe5R0ZERFVAExuqPJRJzedtWel5uB2Rh7kMilaBVcp58CIiKgiYHJDlUtOGpB4WvW85jNas/c/KLVpWcMDDnK2hCIiskZMbqhyubJX9denAeDiqzX77/ji+ja8JUVEZK2Y3FDlcnmP6m9IJ61ZBUVKHLpyBwArExMRWTMmN1R5CFFqfZsTCfeQW6CAp7McYb6u5RwcERFVFExuqPJIjQOybgM29kD1CK3Zxa2k2tXyhFQq0ZpPRETWgckNVR7FpTZBbQBb7dG8Wd+GiIgAJjdUmZRyS+puTgHO3MoAwPo2RETWjskNVQ6PDrlQU7sy8YFLqiEXQn1d4O1qX87BERFRRcLkhiqHhMNA0f2Sh1x4pL4NERFZNyY3VDk8ektKx5AL+4vr23DIBSIiq8fkhiqHK8X925Qy5IINh1wgIiImN1QZPGHIheJbUq2Cq3DIBSIiYnJDlYB6yIWGgIuP1uyHTcBZ34aIiJjcUGWgrm+j3Uoqv0iBQ5eLh1xgfRsiImJyQxXdk4ZcuJ6O+4UKeDrbIdTXpZyDIyKiiojJDVVsqReArMQnDrnQvjaHXCAiIhUmN1SxaQy5oN05H+vbEBHR45jcUMX2hCEX/rutGnKBnfcREVExJjdUcRXlA9cOqJ7rSG445AIREenC5IYqruIhF5x9AO96WrMfrW9DRERUjMkNVVxPGHLhYX0bNgEnIqKHbMwdAFkxIYDMW4BQ6pytjN8NKYA7vm1x/16uxrwbd+8jsXjIhRoccoGIiB4qU3JTVFSEvXv34vLlyxg0aBBcXFxw+/ZtuLq6wtnZ2dgxkqX6ZTRw6vsSZxcXK0b+IkPaL3t0LhNeowrsbTnkAhERPWRwcnP9+nV069YNCQkJyM/Px7PPPgsXFxfMnTsX+fn5WLZsmSniJEujKATOblE9l9lp3XZSKAUKFUr8qoxAlo0H7HRswt5WhldbB5k8VCIiqlwMTm7Gjh2LFi1a4PTp06hatap6eu/evTFy5EijBkcWLPE0UJgDOHgA468AUs3qXzN++Q9rDl3H0IggxL3UwExBEhFRZWRwcvP333/j4MGDkMvlGtODg4Nx69YtowVGFu7a36q/QW21EhsAOHzlLgAgvGZVrXlERESlMbi1lFKphEKh0Jp+8+ZNuLhwbB/SU3H/NUFttWbdzSlAXHIWALCyMBERGczg5Oa5555DTEyM+rVEIkF2djamTp2KF154wZixkaVSFKn6sAGA4HZas49cVZXa1PZ2hqezrto2REREJTP4ttT8+fPRrVs31KtXD3l5eRg0aBDi4+Ph6emJH3/80RQxkqVJ+hcoyALs3QCf+lqz/7l6BwAQXpOlNkREZDiDk5vAwECcPn0a69evx+nTp5GdnY3XX38dgwcPhoODgyliJEtzbb/qb/U2gFS7Gfc/xfVtarC+DRERGc6g5KawsBChoaH47bffMHjwYAwePNhUcZElu/6gvk2wdn2bjNxCnE/KBMCSGyIiKhuD6tzY2toiLy/PVLGQNVAqgOuHVM91VCY+cu0uhABqejrB24WDYRIRkeEMrlA8evRozJ07F0VFRaaIhyxd8n9AfgYgdwF8G2nN/udKcX0b3pIiIqKyMbjOzdGjRxEbG4tdu3ahYcOGcHJy0pi/adMmowVHFqi4vk1QBCDTvvz+edBSqjVvSRERURkZnNy4u7ujb9++poiFrEEp/dtk5hXi7O0MAKxMTEREZWdwcrNq1SpTxEHWQKkEEg6qnuvo3+bYtbtQCiCoqiN83VjfhoiIyqZMo4IDQGpqKuLi4gAAdevWhZeXl9GCIguVcg64fw+wdQL8GmvNftgEnLekiIio7AyuUJyTk4MRI0bAz88PHTp0QIcOHeDv74/XX38dubm5poiRLIW6f5twQGarNfuwur4Nb0kREVHZGZzcREdHY9++ffj111+Rnp6O9PR0/PLLL9i3bx/ee+89U8RIluL6g+RGxy2p7Pwi/HfrQX0bJjdERPQUDL4ttXHjRvz888945pln1NNeeOEFODg4oH///vjyyy+NGR9ZCiGA6w/q2wTprm+jUApU83BAgDt7uiYiorIzuOQmNzcXPj4+WtO9vb15W4pKlnoByL0D2DgA/k21Zhc3AWcrKSIieloGJzcRERGYOnWqRk/F9+/fx/Tp0xEREWHU4MiCFNe3CWwF2Mi1Zj/svI+ViYmI6OkYfFvq888/R2RkJKpVq4bGjVUtXk6fPg17e3vs3LnT6AGShbhWcn2b3IIi/HtTVd8mgvVtiIjoKRmc3DRo0ADx8fH4/vvvceHCBQDAwIEDOSo4lUyIRwbL1E5uTlxPR5FSwN/NHtU8eA0REdHTKVM/N46Ojhg5cqSxYyFLlRYP5KQCNvZAQHOt2YcfGU9KIpGUd3RERGRhDK5zM2fOHKxcuVJr+sqVKzF37lyjBEUW5trfqr/VWgI2dlqz/7n6ILlh531ERGQEBic3y5cvR2hoqNb0+vXrY9myZUYJiizM9ZLHk8orVOD0DfZvQ0RExmNwcpOUlAQ/Pz+t6V5eXkhMTDRKUGRBhHg4WGawdnJzIuEeChRK+LjaIbiqYzkHR0RElsjg5CYwMBAHDhzQmn7gwAH4+/sbJSiyIHevANlJgEyuui31mIfjSbG+DRERGYfBFYpHjhyJd955B4WFhejcuTMAIDY2Fu+//z6HXyBtxfVtAloAttotoQ6zfxsiIjIyg5Ob8ePH486dO3j77bdRUFAAALC3t8cHH3yAiRMnGj1AquRKuSWVV6jAyRvpANgzMRERGY/ByY1EIsHcuXMxefJknD9/Hg4ODqhduzbs7LRbwZCVe7R/Gx2ViU/fSEdBkRKeznYI8XIq5+CIiMhSlamfGwBwdnZGy5Ytcf36dVy+fBmhoaGQSg2uwkOW7N41IPMWhNQG8fJ6EElZGrN3nk0GoLolxfo2RERkLHonNytXrkR6ejqio6PV00aNGoVvvvkGAFC3bl3s3LkTgYGBxo+SKqVzh35HPQDHi2ri5SXHSlyuNfu3ISIiI9K7qOWrr76Ch4eH+vWOHTuwatUqfPvttzh69Cjc3d0xffp0kwRJlVP2JdUtqdOSUHg6y3U+6vm54vmG2l0LEBERlZXeJTfx8fFo0aKF+vUvv/yCl156CYMHDwYAzJ49G8OHDzd+hFRpeWf8CwBo1jYSx5571szREBGRtdC75Ob+/ftwdXVVvz548CA6dOigfl2zZk0kJSUZNzqqtDLT76C64gYAILBRRzNHQ0RE1kTv5CYoKAjHjx8HAKSlpeHs2bNo2/ZhC5ikpCS4ubkZP0KqlK7/uw9SicBtiQ88fVkPi4iIyo/eyc3QoUMxevRozJw5E/369UNoaCiaN384wvPBgwfRoEGDMgWxZMkSBAcHw97eHuHh4Thy5Ihe661btw4SiQS9evUq037JdHIuHQIA3HZpaOZIiIjI2uid3Lz//vsYOXIkNm3aBHt7e/z0008a8w8cOICBAwcaHMD69esRHR2NqVOn4sSJE2jcuDEiIyORkpJS6nrXrl3DuHHj0L59e4P3SabnmHICAKDwb/GEJYmIiIxLIoQQ5gwgPDwcLVu2xOLFiwEASqUSgYGB+L//+z9MmDBB5zoKhQIdOnTAiBEj8PfffyM9PR1btmzRa3+ZmZlwc3NDRkaGRh0iMh6lQoHsmdXgilzE9/oNtZswASUioqdjyPe3WXvdKygowPHjx9G1a1f1NKlUiq5du+LQoUMlrjdjxgx4e3vj9ddff+I+8vPzkZmZqfEg07oRfxquyMV9IUdwvVbmDoeIiKyMWZObtLQ0KBQK+Pj4aEz38fEpseXV/v378c0332DFihV67WPOnDlwc3NTP9jJoOmlnFMNlnnVri5s5RyWg4iIylelGi8hKysLr732GlasWAFPT0+91pk4cSIyMjLUjxs3bpg4ShI3VBXCM6s2MW8gRERklco8tpQxeHp6QiaTITk5WWN6cnIyfH19tZa/fPkyrl27hh49eqinKZVKAICNjQ3i4uIQEhKisY6dnR0H9SxnxZ332dVobeZIiIjIGpm15EYul6N58+aIjY1VT1MqlYiNjUVERITW8qGhoThz5gxOnTqlfvTs2ROdOnXCqVOneMupAmDnfUREZG5GK7m5ceMGpk6dipUrVxq0XnR0NIYOHYoWLVqgVatWiImJQU5OjnoohyFDhiAgIABz5syBvb29Vl867u7uAFDmPnbIuK7/uw8NH3Te58/O+4iIyAyMltzcvXsXa9asMTi5GTBgAFJTUzFlyhQkJSWhSZMm2LFjh7qScUJCAqTSSlU1yKo92nmfv5ljISIi66R3crN169ZS51+5cqXMQURFRSEqKkrnvL1795a67urVq8u8XzI+dt5HRETmpndy06tXL0gkEpTW559EIjFKUFQ5KRUKBOedBwBUCW1n5miIiMha6X2/x8/PD5s2bYJSqdT5OHHihCnjpEpA1XlfDjvvIyIis9I7uWnevLl6VHBdnlSqQ5aPnfcREVFFoPdtqfHjxyMnJ6fE+bVq1cKePXuMEhRVTsWd92VUbWrmSIiIyJrpndw8afRtJycndOzIfk2sWXHnffY1ws0cCRERWTO9b0tduXKFt52oRI923le9MZNcIiIyH72Tm9q1ayM1NVX9esCAAVrDJpD1uv7vPkgfdN5X1Yed9xERkfnondw8Xmqzffv2UuvgkHV5tPM+IiIic2LXv2QUjiknAbDzPiIiMj+9kxuJRKLVSR877SOguPO+cwDYeR8REZmf3q2lhBAYNmwY7OxU/Zfk5eXhrbfegpOTk8ZymzZtMm6EVOHdiD+NIHbeR0REFYTeyc3QoUM1Xr/66qtGD4Yqp5RzfyMIqs776rHzPiIiMjO9k5tVq1aZMg6qxNh5HxERVSSsUExPjZ33ERFRRcLkhp6KZud9z5g3GCIiIjC5oadU3HnfLYkPqvpUM3c4RERETG7o6WRfOgwASGTnfUREVEEwuaGn4pRyAgA77yMioopD79ZSZJnuptxCwqoRcCy8W6b16xZeBSTsvI+IiCoOJjdW7tLfG9Dq/uGyb0ACpMGdnfcREVGFweTGyikykwAA/9q3gLLlyDJtw69uS9iy8z4iIqogmNxYOWlOCgAgp2pDRHR5xczREBERPT1WKLZytvdTAQBSFx8zR0JERGQcTG6snGPBHQCArZuvmSMhIiIyDiY3Vs65SNVKyqGKv5kjISIiMg4mN1auivIeAMClaoCZIyEiIjIOJjdWLCcrHY6SfACAB4dOICIiC8HkxordS74JAMgVdnBycTdvMEREREbC5MaKZd25BQC4K/UwcyRERETGw+TGit2/exsAkGVTxcyREBERGQ+TGytWmKHqnfi+3NPMkRARERkPkxsrpsxKBgAUOjC5ISIiy8HkxorJclVDLyidvM0cCRERkfEwubFidnlpAACZK3snJiIiy8HkxooVD70gd/czcyRERETGw+TGirkpVEMvOHHoBSIisiBMbqyUUqGAh8gAALh6cegFIiKyHExurFTG3RTYShQAAA8mN0REZEGY3Fip9FTV0Av34AK5nb2ZoyEiIjIeJjdWKjtN1TtxBodeICIiC8Pkxkrlp6uSm2xbDr1ARESWhcmNlSrKVA29kGfH3omJiMiyMLmxVg+GXihy8DJzIERERMbF5MZK2dxPVT1x5tALRERkWZjcWCn7fA69QERElonJjZVyLlT1TmzvwaEXiIjIsjC5sVJuynsAAOeqHHqBiIgsC5MbK1RYkA8PZAEA3LyqmTkaIiIi42JyY4Xupar6uCkSUrhXZZ0bIiKyLExurFDGg6EX7krcIZXJzBwNERGRcTG5sUK5d28BADJlHHqBiIgsD5MbK5R/T9U7cY68qpkjISIiMj4mN1ZIkaVKbvI59AIREVkgJjdWSJqdAgBQOLF3YiIisjxMbqyQbZ5q6AWJs4+ZIyEiIjI+JjdWyCH/DgDA1o29ExMRkeVhcmOFXIpUQy84VGFyQ0RElofJjRXyeDD0gotngJkjISIiMj4mN1YmJysdTpI8AICHN4deICIiy8Pkxsqkp6o68MsVdnBydjNzNERERMbH5MbKZD1Ibu5J3SGR8t9PRESWh99uVib3nmrQzCwb9k5MRESWicmNlSnMUPVOnMuhF4iIyEIxubEyyqxkAEChg5eZIyEiIjINJjdWRpajGnpByaEXiIjIQjG5sTLyvDQAgNSZyQ0REVkmJjdWxqlQNfSCnTt7JyYiIstUIZKbJUuWIDg4GPb29ggPD8eRI0dKXHbFihVo3749PDw84OHhga5du5a6PGlyfTD0gmNVfzNHQkREZBpmT27Wr1+P6OhoTJ06FSdOnEDjxo0RGRmJlJQUncvv3bsXAwcOxJ49e3Do0CEEBgbiueeew61bt8o58spHqVDAQ6QDAFw59AIREVkoiRBCmDOA8PBwtGzZEosXLwYAKJVKBAYG4v/+7/8wYcKEJ66vUCjg4eGBxYsXY8iQIU9cPjMzE25ubsjIyICrq+tTx1+ZpKclwX1xXQBA/oRE2Nk7mjkiIiIi/Rjy/W3WkpuCggIcP34cXbt2VU+TSqXo2rUrDh06pNc2cnNzUVhYiCpVqpgqTIuRnnoTAJABJyY2RERksWzMufO0tDQoFAr4+PhoTPfx8cGFCxf02sYHH3wAf39/jQTpUfn5+cjPz1e/zszMLHvAlVx2murWXbq0CjiqFBERWSqz17l5Gp988gnWrVuHzZs3w97eXucyc+bMgZubm/oRGBhYzlFWHHn3EgEA2TYs5SIiIstl1uTG09MTMpkMycnJGtOTk5Ph6+tb6rrz58/HJ598gl27dqFRo0YlLjdx4kRkZGSoHzdu3DBK7JVR0YPeie/beZo5EiIiItMxa3Ijl8vRvHlzxMbGqqcplUrExsYiIiKixPU+/fRTzJw5Ezt27ECLFi1K3YednR1cXV01HlbrQXJT5MihF4iIyHKZtc4NAERHR2Po0KFo0aIFWrVqhZiYGOTk5GD48OEAgCFDhiAgIABz5swBAMydOxdTpkzBDz/8gODgYCQlqQaCdHZ2hrOzs9mOozKQ3U9VPeHQC0REZMHMntwMGDAAqampmDJlCpKSktCkSRPs2LFDXck4ISEBUunDAqYvv/wSBQUFePnllzW2M3XqVEybNq08Q6907B8MvSBzLf2WHxERUWVm9uQGAKKiohAVFaVz3t69ezVeX7t2zfQBWSjnQlXvxPYeHHqBiIgsV6VuLUWGcVOqkhunquydmIiILBeTGytRWJAPd5EFAHDzYnJDRESWi8mNlUhPS4RUIlAkpHCvyjo3RERkuZjcWImMB0Mv3JO4QWZTIapaERERmQSTGyuRc+c2ACBDxt6JiYjIsjG5sRIF6aqhF3JsmdwQEZFlY3JjJRSZqt6J8+3ZOzEREVk2JjdWQpKjSm4UHHqBiIgsHJMbK2H7YOgFiYuPmSMhIiIyLSY3VsI+/w4AwNaNzcCJiMiyMbmxEi5Fqt6JHTz8zRwJERGRaTG5sRIeynsAAOeqHFeKiIgsG5MbK5CbnQFnyX0AgLt3oJmjISIiMi0mN1bgXoqqA788YQsXVw8zR0NERGRaTG6sQFaaauiFu1IPSKT8lxMRkWXjN50VuH9PVXKTxaEXiIjICjC5sQIF6UkAgFx5VTNHQkREZHpMbqyAyFL1TlzgwN6JiYjI8jG5sQLS3BQAgNLJ28yREBERmR6TGysgz0sDAEg59AIREVkBJjdWwLFANfSCnEMvEBGRFbAxdwBkHGlJCSjMv69znnuRquTGsQqHXiAiIsvH5MYCHPp2MiKufPHE5Vy9AsohGiIiIvNicmMB3G7uAQAUCBmUJdxpjLdvgPrVapVnWERERGbB5MYC+BQkAACu9/4FtZu017lMw/IMiIiIyIxYobiSy7iTjKrIAAD4hzCFISIiYnJTySVeOQMASEZVOLm4mzcYIiKiCoDJTSWXefMcACDFrrqZIyEiIqoYmNxUcoqUOABArktNM0dCRERUMTC5qeTsM66onnjWNm8gREREFQSTm0quat51AICjfz0zR0JERFQxMLmpxAoL8uGnSAIAeNdsYOZoiIiIKgYmN5XY7avnYStRIFfYwdu/hrnDISIiqhCY3FRid6//BwC4ZRMIiZT/SiIiIoDJTaWWl3geAJDhFGzeQIiIiCoQDr9QidncvQQAKPTgmFFEpD+FQoHCwkJzh0GkRS6XQ2qEOxFMbiox15yrAAA731AzR0JElYEQAklJSUhPTzd3KEQ6SaVS1KhRA3K5/Km2w+SmkhJKJfyKbgAAPILYUoqInqw4sfH29oajoyMkEom5QyJSUyqVuH37NhITE1G9evWnuj6Z3FRSd1JuwhO5UAgJ/GqwjxsiKp1CoVAnNlWrVjV3OEQ6eXl54fbt2ygqKoKtrW2Zt8MKxZVU8mXVgJmJUh/YOziZORoiquiK69g4OjqaORKikhXfjlIoFE+1HSY3lVT2LdWAmXfsg8wcCRFVJrwVRRWZsa5PJjeVlEi7CAC478oBM4mIiB7F5KaScsxUDZgp9apj5kiIiEzrmWeewTvvvPPU29myZQtq1aoFmUxmlO0Z6quvvkJgYCCkUiliYmIwbdo0NGnSpNzjKKvVq1fD3d3d3GHohclNJeWZnwAAcK7GysRERPp488038fLLL+PGjRuYOXNmue47MzMTUVFR+OCDD3Dr1i2MGjUK48aNQ2xsrFH3Y8oEZMCAAbh48aJJtm1sbC1VCd3PyYKvMhWQAL41G5o7HCKiCi87OxspKSmIjIyEv79/mbdTUFBQpj5YEhISUFhYiO7du8PPz0893dnZucyxlDcHBwc4ODiYOwy9sOSmErp95SykEoF0OMPD0+/JKxAR6SCEQG5BkVkeQgiDYi0qKkJUVBTc3Nzg6emJyZMna2wjPz8f48aNQ0BAAJycnBAeHo69e/cCAPbu3QsXFxcAQOfOnSGRSNTzNm7ciPr168POzg7BwcFYsGCBxn6Dg4Mxc+ZMDBkyBK6urhg1ahQAYP/+/Wjfvj0cHBwQGBiIMWPGICcnR2fsq1evRsOGqh+iNWvWhEQiwbVr17RuSw0bNgy9evXC/Pnz4efnh6pVq2L06NEavUk/6TiHDx+OjIwMSCQSSCQSTJs2DYCqou6WLVs04nJ3d8fq1asBANeuXYNEIsGmTZvQqVMnODo6onHjxjh06JDGcTxaKlQc/9q1axEcHAw3Nze88soryMrKUi+TlZWFwYMHw8nJCX5+fvjss8+MdpuxNCy5qYTSE1QDZibZVoc7B8wkojK6X6hAvSk7zbLvczMi4SjX/ytozZo1eP3113HkyBEcO3YMo0aNQvXq1TFy5EgAQFRUFM6dO4d169bB398fmzdvRrdu3XDmzBm0adMGcXFxqFu3LjZu3Ig2bdqgSpUqOH78OPr3749p06ZhwIABOHjwIN5++21UrVoVw4YNU+97/vz5mDJlCqZOnQoAuHz5Mrp164ZZs2Zh5cqVSE1NRVRUFKKiorBq1Sqt2AcMGIDAwEB07doVR44cQWBgILy8vHQe5549e+Dn54c9e/bg0qVLGDBgAJo0aaL3ccbExGDKlCmIi4sDYHjJ0KRJkzB//nzUrl0bkyZNwsCBA3Hp0iXY2Oj+X12+fBlbtmzBb7/9hnv37qF///745JNP8PHHHwMAoqOjceDAAWzduhU+Pj6YMmUKTpw4YfK6RkxuKqGCZNVFm8kBM4nISgQGBuKzzz6DRCJB3bp1cebMGXz22WcYOXIkEhISsGrVKiQkJKhvOY0bNw47duzAqlWrMHv2bHh7ewMAqlSpAl9fXwDAwoUL0aVLF0yePBkAUKdOHZw7dw7z5s3TSG46d+6M9957T/36jTfewODBg9WlD7Vr18YXX3yBjh074ssvv4S9vb1G7A4ODuqOE728vNT718XDwwOLFy+GTCZDaGgounfvjtjYWL2P083NDRKJpNR9lGbcuHHo3r07AGD69OmoX78+Ll26hNBQ3cP8KJVKrF69Wl0y9tprryE2NhYff/wxsrKysGbNGvzwww/o0qULAGDVqlVPdVtQX0xuKiH5PdWAmcqqtc0cCRFVZg62MpybEWm2fRuidevWGn2gREREYMGCBVAoFDhz5gwUCgXq1NFsPZqfn19qb8znz5/HSy+9pDGtbdu2iImJgUKhgEymirFFixYay5w+fRr//vsvvv/+e/U0IQSUSiWuXr2KsLAwg47tUfXr11fvFwD8/Pxw5oyq09ayHqchGjVqpLFvAEhJSSkxuQkODlYnNsXrpKSkAACuXLmCwsJCtGrVSj3fzc0NdevWNUqspWFyUwm5514DANj7lf0NREQkkUgMujVUUWVnZ0Mmk+H48eMaiQFgnAq7Tk6avcBnZ2fjzTffxJgxY7SWrV69+lPt6/EhByQSCZRKpXq/ZT1OiUSiVc9J18jwj+6/OJks3r+h8ZpT5b+qrYxSoYB/0U1AAlQN5oCZRGQd/vnnH43Xhw8fRu3atSGTydC0aVMoFAqkpKSgffv2em8zLCwMBw4c0Jh24MAB1KlTRyt5eFSzZs1w7tw51KpVy7CDeEr6HKdcLtc5dIGXlxcSExPVr+Pj45Gbm2uyWAFV5WlbW1scPXpUnfRlZGTg4sWL6NChg0n3zdqolUzyzUtwkBSgQMjgF2T6oj0iooogISEB0dHRiIuLw48//ohFixZh7NixAFR1ZQYPHowhQ4Zg06ZNuHr1Ko4cOYI5c+Zg27ZtJW7zvffeQ2xsLGbOnImLFy9izZo1WLx4McaNG1dqLB988AEOHjyIqKgonDp1CvHx8fjll18QFRVl1GN+nD7HGRwcjOzsbMTGxiItLU2dwHTu3BmLFy/GyZMncezYMbz11ltPNTClPlxcXDB06FCMHz8ee/bswdmzZ/H6669DKpWafBgQJjeVTOpVVUup2zJ/2Nga3tcCEVFlNGTIENy/fx+tWrXC6NGjMXbsWHWzbEBVUXXIkCF47733ULduXfTq1UujxECXZs2aYcOGDVi3bh0aNGiAKVOmYMaMGRqViXVp1KgR9u3bh4sXL6J9+/Zo2rQppkyZUi4VZZ90nG3atMFbb72FAQMGwMvLC59++ikAYMGCBQgMDET79u0xaNAgjBs3rlwGUV24cCEiIiLw4osvomvXrmjbti3CwsK0Kl0bm0QY2tlAJZeZmQk3NzdkZGTA1dXV3OEY7PAPs9D64jyccGqPZuN/M3c4RFRJ5OXl4erVq6hRo4bJv1iISpKTk4OAgAAsWLAAr7/+utb80q5TQ76/WeemkpHciQcA5LuHmDkSIiKi0p08eRIXLlxAq1atkJGRgRkzZgCAVis1Y2NyU8k4Z6kGzLThgJlERFQJzJ8/H3FxcZDL5WjevDn+/vtveHp6mnSfTG4qGe+CGwAAt+r1zRwJERFR6Zo2bYrjx4+X+35ZobgSyUy/Ay/cA8ABM4mIiErC5KYSSbqi6qUyFR5wdTdOb5RERESWhslNJZKRcBYAkCJ/uh4wiYiILBmTm0qkKEU1YGa2Sw0zR0JERFRxMbmpROwzLgMAhCdbShEREZWEyU0lUuX+dQCAkz8HzCQietSFCxfQunVr2Nvbo0mTJuWyzwMHDqBhw4awtbVFr169sHfvXkgkEqSnp5fL/p/WtWvXIJFIcOrUKXOHYnRMbiqJwoJ8+CluAwC8arClFBHRo6ZOnQonJyfExcUhNjYWq1evhru7u0n3GR0djSZNmuDq1atYvXo12rRpg8TERLi5uRltH6ZMQAIDA5GYmIgGDSxvEGYmN5VE0vULkEsUyBV28A6oae5wiIgqlMuXL6Ndu3YICgpC1arGa02qUCigVCpL3Gfnzp1RrVo1uLu7Qy6Xw9fX1+SDQhqLTCaDr68vbGwsr8s7JjeVxJ1rqpZSt22qQSqTmTkaIqLys2PHDrRr1w7u7u6oWrUqXnzxRVy+fFk9XyKR4Pjx45gxYwYkEgmeeeYZDB8+HBkZGZBIJJBIJJg2bRoAID8/H+PGjUNAQACcnJwQHh6OvXv3qrdVXOKzdetW1KtXD3Z2dkhISNCIp7g05c6dOxgxYgQkEglWr16tdVuqeFs7d+5EWFgYnJ2d0a1bNyQmJmps7+uvv1YPJhkaGoqlS5eq59WooWpA0rRpU/WxAcAzzzyDd955R2M7vXr10hj0Mzg4GLNnz8aIESPg4uKC6tWr46uvvtI6juJSoeL4Y2Nj0aJFCzg6OqJNmzaIi4vT2M+sWbPg7e0NFxcXvPHGG5gwYUK53QrUF5ObSiIv8TwAIN0x2LyBEJHlEAIoyDHPw4Axm3NychAdHY1jx44hNjYWUqkUvXv3VpeoJCYmon79+njvvfeQmJiIrVu3IiYmBq6urkhMTERiYiLGjRsHAIiKisKhQ4ewbt06/Pvvv+jXrx+6deuG+Ph49f5yc3Mxd+5cfP311zh79iy8vb014im+nePq6oqYmBgkJiZiwIABOmPPzc3F/PnzsXbtWvz1119ISEhQxwIA33//PaZMmYKPP/4Y58+fx+zZszF58mSsWbMGAHDkyBEAwB9//IHExERs2rRJ7/MGqEYDb9GiBU6ePIm3334b//vf/7SSlcdNmjQJCxYswLFjx2BjY4MRI0ZoxPvxxx9j7ty5OH78OKpXr44vv/zSoJjKg+WVRVko6d1LAIBCj1pmjoSILEZhLjDb3zz7/vA2IHfSa9G+fftqvF65ciW8vLxw7tw5NGjQQH1rxdnZGb6+vgAANzc3SCQS9WsASEhIwKpVq5CQkAB/f9Vxjxs3Djt27MCqVaswe/ZsAEBhYSGWLl2Kxo0b64yn+HaORCKBm5ubxj4eV1hYiGXLliEkRDXYcVRUlHrwSEBVV2jBggXo06cPAFVJzblz57B8+XIMHToUXl5eAICqVauWup+SvPDCC3j77bcBAB988AE+++wz7NmzB3Xr1i1xnY8//hgdO3YEAEyYMAHdu3dHXl4e7O3tsWjRIrz++usYPnw4AGDKlCnYtWsXsrOzDY7NlCpEyc2SJUsQHBwMe3t7hIeHqzPVkvz0008IDQ2Fvb09GjZsiO3bt5dTpObjmn0VACD3YTNwIrIu8fHxGDhwIGrWrAlXV1cEBwcDgNbtoic5c+YMFAoF6tSpA2dnZ/Vj3759Gre55HI5GjVqZJTYHR0d1YkNAPj5+SElJQWAqkTq8uXLeP311zXimTVrlkY8T+PR4yhO9or3r886fn5+AKBeJy4uDq1atdJY/vHXFYHZS27Wr1+P6OhoLFu2DOHh4YiJiUFkZCTi4uK0igIB4ODBgxg4cCDmzJmDF198ET/88AN69eqFEydOWGSNbwAQSiX8ilRvYvfqlnmMRGQGto6qEhRz7VtPPXr0QFBQEFasWAF/f38olUo0aNAABQUFBu0yOzsbMpkMx48fh+yxuovOzs7q5w4ODkarFGxra6vxWiKRQDy4JVdc2rFixQqEh4drLPd4fI+TSqXq7RQrLCzUa/8lVZDWtU7xeXjSOhWN2ZObhQsXYuTIkeoirmXLlmHbtm1YuXIlJkyYoLX8559/jm7dumH8+PEAgJkzZ2L37t1YvHgxli1bVq6xPyo/Lxd3k2+YZNu5GXcQghwohQT+NTkaOBEZiUSi960hc7lz5w7i4uKwYsUKtG/fHgCwf//+J64nl8uhUCg0pjVt2hQKhQIpKSnqbZmTj48P/P39ceXKFQwePFjnMnK5HAC0jsXLy0ujYrJCocB///2HTp06mS5gAHXr1sXRo0cxZMgQ9bSjR4+adJ9lYdbkpqCgAMePH8fEiRPV06RSKbp27YpDhw7pXOfQoUOIjo7WmBYZGYktW7boXD4/Px/5+fnq15mZmU8fuA5X/zuE0N/6mGTbxZKkXvB3cjHpPoiIKhIPDw9UrVoVX331Ffz8/JCQkKDzh+/jgoODkZ2djdjYWDRu3BiOjo6oU6cOBg8ejCFDhmDBggVo2rQpUlNTERsbi0aNGqF79+7lcESapk+fjjFjxsDNzQ3dunVDfn4+jh07hnv37iE6Ohre3t5wcHDAjh07UK1aNdjb28PNzQ2dO3dGdHQ0tm3bhpCQECxcuLBcOg/8v//7P4wcORItWrRAmzZtsH79evz777+oWbNidVFi1jo3aWlpUCgU8PHx0Zju4+ODpKQkneskJSUZtPycOXPg5uamfgQGBhon+MdIIEGesDXZI1fY4Xp10yZPREQVjVQqxbp163D8+HE0aNAA7777LubNm/fE9dq0aYO33noLAwYMgJeXFz799FMAwKpVqzBkyBC89957qFu3Lnr16oWjR4+ienXzDEj8xhtv4Ouvv8aqVavQsGFDdOzYEatXr1Y3AbexscEXX3yB5cuXw9/fHy+99BIAYMSIERg6dCiGDBmCjh07ombNmiYvtQGAwYMHY+LEiRg3bhyaNWuGq1evYtiwYbC3tzf5vg0hEY/ftCtHt2/fRkBAAA4ePIiIiAj19Pfffx/79u3DP//8o7WOXC7HmjVrMHDgQPW0pUuXYvr06UhOTtZaXlfJTWBgIDIyMuDq6mrkIyIiqpjy8vJw9epV1KhRo8J9EVHl9uyzz8LX1xdr16596m2Vdp1mZmbCzc1Nr+9vs96W8vT0hEwm00pKkpOTS2zy5uvra9DydnZ2sLOzM07AREREViw3NxfLli1DZGQkZDIZfvzxR/zxxx/YvXu3uUPTYNbbUnK5HM2bN0dsbKx6mlKpRGxsrEZJzqMiIiI0lgeA3bt3l7g8ERERGYdEIsH27dvRoUMHNG/eHL/++is2btyIrl27mjs0DWZvLRUdHY2hQ4eiRYsWaNWqFWJiYpCTk6NuPTVkyBAEBARgzpw5AICxY8eiY8eOWLBgAbp3745169bh2LFjGl1KExERkfE5ODjgjz/+MHcYT2T25GbAgAFITU3FlClTkJSUhCZNmmDHjh3qSsMJCQmQSh8WMLVp0wY//PADPvroI3z44YeoXbs2tmzZYrF93BAREZFhzFqh2BwMqZBERGQpWKGYKgNjVSiuEMMvEBFR+bCy37NUyRjr+mRyQ0RkBYq71M/NzTVzJEQlKx5S40nDTzyJ2evcEBGR6clkMri7u6sHQHR0dDTa+ElExqBUKpGamgpHR0fY2DxdesLkhojIShT3B/akUaGJzEUqlaJ69epPnXgzuSEishISiQR+fn7w9vbWOYI0kbnJ5XKNFtJlxeSGiMjKyGSyp67TQFSRsUIxERERWRQmN0RERGRRmNwQERGRRbG6OjfFHQRlZmaaORIiIiLSV/H3tj4d/VldcpOVlQUACAwMNHMkREREZKisrCy4ubmVuozVjS2lVCpx+/ZtuLi4GNyOPjMzE4GBgbhx4wbHpdITz5lheL4Mw/NlOJ4zw/B8Gc5U50wIgaysLPj7+z+xubjVldxIpVJUq1btqbbh6urKi9xAPGeG4fkyDM+X4XjODMPzZThTnLMnldgUY4ViIiIisihMboiIiMiiMLkxgJ2dHaZOnQo7Oztzh1Jp8JwZhufLMDxfhuM5MwzPl+EqwjmzugrFREREZNlYckNEREQWhckNERERWRQmN0RERGRRmNwQERGRRWFy85glS5YgODgY9vb2CA8Px5EjR0pd/qeffkJoaCjs7e3RsGFDbN++vZwirRgMOV9nz55F3759ERwcDIlEgpiYmPILtAIx5JytWLEC7du3h4eHBzw8PNC1a9cnXpOWxpDztWnTJrRo0QLu7u5wcnJCkyZNsHbt2nKMtmIw9HOs2Lp16yCRSNCrVy/TBljBGHK+Vq9eDYlEovGwt7cvx2grBkOvsfT0dIwePRp+fn6ws7NDnTp1TPt9KUht3bp1Qi6Xi5UrV4qzZ8+KkSNHCnd3d5GcnKxz+QMHDgiZTCY+/fRTce7cOfHRRx8JW1tbcebMmXKO3DwMPV9HjhwR48aNEz/++KPw9fUVn332WfkGXAEYes4GDRoklixZIk6ePCnOnz8vhg0bJtzc3MTNmzfLOXLzMPR87dmzR2zatEmcO3dOXLp0ScTExAiZTCZ27NhRzpGbj6HnrNjVq1dFQECAaN++vXjppZfKJ9gKwNDztWrVKuHq6ioSExPVj6SkpHKO2rwMPWf5+fmiRYsW4oUXXhD79+8XV69eFXv37hWnTp0yWYxMbh7RqlUrMXr0aPVrhUIh/P39xZw5c3Qu379/f9G9e3eNaeHh4eLNN980aZwVhaHn61FBQUFWmdw8zTkTQoiioiLh4uIi1qxZY6oQK5SnPV9CCNG0aVPx0UcfmSK8Cqks56yoqEi0adNGfP3112Lo0KFWldwYer5WrVol3Nzcyim6isnQc/bll1+KmjVrioKCgvIKUfC21AMFBQU4fvw4unbtqp4mlUrRtWtXHDp0SOc6hw4d0lgeACIjI0tc3pKU5XxZO2Ocs9zcXBQWFqJKlSqmCrPCeNrzJYRAbGws4uLi0KFDB1OGWmGU9ZzNmDED3t7eeP3118sjzAqjrOcrOzsbQUFBCAwMxEsvvYSzZ8+WR7gVQlnO2datWxEREYHRo0fDx8cHDRo0wOzZs6FQKEwWJ5ObB9LS0qBQKODj46Mx3cfHB0lJSTrXSUpKMmh5S1KW82XtjHHOPvjgA/j7+2sl1ZaorOcrIyMDzs7OkMvl6N69OxYtWoRnn33W1OFWCGU5Z/v378c333yDFStWlEeIFUpZzlfdunWxcuVK/PLLL/juu++gVCrRpk0b3Lx5szxCNruynLMrV67g559/hkKhwPbt2zF58mQsWLAAs2bNMlmcVjcqOFFl9cknn2DdunXYu3evVVZg1JeLiwtOnTqF7OxsxMbGIjo6GjVr1sQzzzxj7tAqnKysLLz22mtYsWIFPD09zR1OpRAREYGIiAj16zZt2iAsLAzLly/HzJkzzRhZxaVUKuHt7Y2vvvoKMpkMzZs3x61btzBv3jxMnTrVJPtkcvOAp6cnZDIZkpOTNaYnJyfD19dX5zq+vr4GLW9JynK+rN3TnLP58+fjk08+wR9//IFGjRqZMswKo6znSyqVolatWgCAJk2a4Pz585gzZ45VJDeGnrPLly/j2rVr6NGjh3qaUqkEANjY2CAuLg4hISGmDdqMjPE5Zmtri6ZNm+LSpUumCLHCKcs58/Pzg62tLWQymXpaWFgYkpKSUFBQALlcbvQ4eVvqAblcjubNmyM2NlY9TalUIjY2ViNLf1RERITG8gCwe/fuEpe3JGU5X9aurOfs008/xcyZM7Fjxw60aNGiPEKtEIx1jSmVSuTn55sixArH0HMWGhqKM2fO4NSpU+pHz5490alTJ5w6dQqBgYHlGX65M8Y1plAocObMGfj5+ZkqzAqlLOesbdu2uHTpkjpxBoCLFy/Cz8/PJIkNADYFf9S6deuEnZ2dWL16tTh37pwYNWqUcHd3Vzfze+2118SECRPUyx84cEDY2NiI+fPni/Pnz4upU6daXVNwQ85Xfn6+OHnypDh58qTw8/MT48aNEydPnhTx8fHmOoRyZ+g5++STT4RcLhc///yzRtPTrKwscx1CuTL0fM2ePVvs2rVLXL58WZw7d07Mnz9f2NjYiBUrVpjrEMqdoefscdbWWsrQ8zV9+nSxc+dOcfnyZXH8+HHxyiuvCHt7e3H27FlzHUK5M/ScJSQkCBcXFxEVFSXi4uLEb7/9Jry9vcWsWbNMFiOTm8csWrRIVK9eXcjlctGqVStx+PBh9byOHTuKoUOHaiy/YcMGUadOHSGXy0X9+vXFtm3byjli8zLkfF29elUA0Hp07Nix/AM3I0POWVBQkM5zNnXq1PIP3EwMOV+TJk0StWrVEvb29sLDw0NERESIdevWmSFq8zL0c+xR1pbcCGHY+XrnnXfUy/r4+IgXXnhBnDhxwgxRm5eh19jBgwdFeHi4sLOzEzVr1hQff/yxKCoqMll8EiGEME2ZEBEREVH5Y50bIiIisihMboiIiMiiMLkhIiIii8LkhoiIiCwKkxsiIiKyKExuiIiIyKIwuSEiIiKLwuSGiMrN3r17IZFIkJ6eXq77Xb16Ndzd3Z9qG9euXYNEIsGpU6dKXMZcx0dEmpjcEJFRSCSSUh/Tpk0zd4hEZCU4KjgRGUViYqL6+fr16zFlyhTExcWppzk7O+PYsWMGb9dUowYTkeViyQ0RGYWvr6/64ebmBolEojHN2dlZvezx48fRokULODo6ok2bNhpJ0LRp09CkSRN8/fXXqFGjBuzt7QEA6enpeOONN+Dl5QVXV1d07twZp0+fVq93+vRpdOrUCS4uLnB1dUXz5s21kqmdO3ciLCwMzs7O6Natm0ZCplQqMWPGDFSrVg12dnZo0qQJduzYUeoxb9++HXXq1IGDgwM6deqEa9euPc0pJCIjYXJDROVu0qRJWLBgAY4dOwYbGxuMGDFCY/6lS5ewceNGbNq0SV3HpV+/fkhJScHvv/+O48ePo1mzZujSpQvu3r0LABg8eDCqVauGo0eP4vjx45gwYQJsbW3V28zNzcX8+fOxdu1a/PXXX0hISMC4cePU8z///HMsWLAA8+fPx7///ovIyEj07NkT8fHxOo/hxo0b6NOnD3r06IFTp07hjTfewIQJE4x8poioTEw2JCcRWa1Vq1YJNzc3rel79uwRAMQff/yhnrZt2zYBQNy/f18IIcTUqVOFra2tSElJUS/z999/C1dXV5GXl6exvZCQELF8+XIhhBAuLi5i9erVJcYDQFy6dEk9bcmSJcLHx0f92t/fX3z88cca67Vs2VK8/fbbQoiHo9qfPHlSCCHExIkTRb169TSW/+CDDwQAce/ePZ1xEFH5YMkNEZW7Ro0aqZ/7+fkBAFJSUtTTgoKC4OXlpX59+vRpZGdno2rVqnB2dlY/rl69isuXLwMAoqOj8cYbb6Br16745JNP1NOLOTo6IiQkRGO/xfvMzMzE7du30bZtW4112rZti/Pnz+s8hvPnzyM8PFxjWkREhN7ngIhMhxWKiajcPXq7SCKRAFDVeSnm5OSksXx2djb8/Pywd+9erW0VN/GeNm0aBg0ahG3btuH333/H1KlTsW7dOvTu3Vtrn8X7FUIY43CIqIJhyQ0RVXjNmjVDUlISbGxsUKtWLY2Hp6enerk6derg3Xffxa5du9CnTx+sWrVKr+27urrC398fBw4c0Jh+4MAB1KtXT+c6YWFhOHLkiMa0w4cPG3hkRGQKTG6IqMLr2rUrIiIi0KtXL+zatQvXrl3DwYMHMWnSJBw7dgz3799HVFQU9u7di+vXr+PAgQM4evQowsLC9N7H+PHjMXfuXKxfvx5xcXGYMGECTp06hbFjx+pc/q233kJ8fDzGjx+PuLg4/PDDD1i9erWRjpiIngZvSxFRhSeRSLB9+3ZMmjQJw4cPR2pqKnx9fdGhQwf4+PhAJpPhzp07GDJkCJKTk+Hp6Yk+ffpg+vTpeu9jzJgxyMjIwHvvvYeUlBTUq1cPW7duRe3atXUuX716dWzcuBHvvvsuFi1ahFatWmH27NlaLb+IqPxJBG86ExERkQXhbSkiIiKyKExuiIiIyKIwuSEiIiKLwuSGiIiILAqTGyIiIrIoTG6IiIjIojC5ISIiIovC5IaIiIgsCpMbIiIisihMboiIiMiiMLkhIiIii8LkhoiIiCzK/wOJU70zlxrBcgAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "display_AUC(metrics_before_training, metrics_after_training)\n",
+    "display_accuracy(metrics_before_training, metrics_after_training)\n",
+    "display_f1_score(metrics_before_training, metrics_after_training)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Every use case is different\n",
+    "With vector embeddings we always have to keep in mind there is a tradeoff between true and false positives and negatives. You can cast a wide net with a large threshold and grab many seemingly similar vectors at the risk of getting some irrelevant ones, or you can be conservative and match only highly similar embeddings, and risk missing something important. You can control this tradeoff by selecting the similarity threshold that makes sense for your system.\n",
+    "\n",
+    "Where you set this threshold depends on your own use case and system, and your tolerance for different types of errors. Choosing the threshold that maximizes F1 score or accuracy are good places to start. Ultimately you'll want to optimize for your specific use case, and we have a [retrieval optimizer tool](https://github.com/redis-applied-ai/retrieval-optimizer) to help with that when you're ready for the next level of system improvements."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Choosing your threshold\n",
+    "To get a sense of how the choice of similarity threshold changes cache performance here's an interactive tool that lets you change the threshold and immediately see how the tradeoff between true and false positives and negatives balances out."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import precision_score, recall_score, f1_score, confusion_matrix, precision_recall_curve\n",
+    "\n",
+    "def compute_metrics_at_threshold(\n",
+    "    scores: np.ndarray,\n",
+    "    labels: np.ndarray,\n",
+    "    threshold: float,\n",
+    "    high_score_more_similar: bool = True\n",
+    "):\n",
+    "    if high_score_more_similar:\n",
+    "        predictions = (scores >= threshold).astype(int)\n",
+    "    else:\n",
+    "        predictions = (scores <= threshold).astype(int)\n",
+    "\n",
+    "    print(predictions)\n",
+    "    precision = precision_score(labels, predictions)\n",
+    "    recall = recall_score(labels, predictions)\n",
+    "    f1 = f1_score(labels, predictions)\n",
+    "    cm = confusion_matrix(labels, predictions)\n",
+    "\n",
+    "    return {'precision': precision, 'recall': recall, 'f1_score': f1, 'confusion_matrix': cm}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics.pairwise import cosine_similarity\n",
+    "\n",
+    "q1_embeddings = [model.encode(pair['question_1']) for pair in test_dataset]\n",
+    "q2_embeddings = [model.encode(pair['question_2']) for pair in test_dataset]\n",
+    "cosine_similarities = np.array([cosine_similarity([emb1], [emb2])[0][0] for emb1, emb2 in zip(q1_embeddings, q2_embeddings)])\n",
+    "labels = np.array(test_dataset[\"label\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "<style>\n",
+       "    /* Style only the slider with the custom class 'custom-slider' */\n",
+       "    .custom-slider .widget-label {\n",
+       "        font-size: 20px !important;\n",
+       "        font-weight: bold;\n",
+       "    }\n",
+       "    .custom-slider .widget-readout {\n",
+       "        font-size: 18px !important;\n",
+       "    }\n",
+       "</style>\n"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "663bbe8f3bd34492a26b59566de2a926",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "interactive(children=(FloatSlider(value=0.8114206194877625, continuous_update=False, description='Cosine Simil…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<function __main__.update_plots(threshold)>"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import seaborn as sns\n",
+    "from ipywidgets import FloatSlider, Layout, interact\n",
+    "from IPython.display import display, HTML\n",
+    "\n",
+    "\n",
+    "def update_plots(threshold):\n",
+    "    # set a pleasing style and update global font sizes\n",
+    "    plt.rcParams.update({'font.size': 16})\n",
+    "\n",
+    "    metrics = compute_metrics_at_threshold(cosine_similarities, labels, threshold, high_score_more_similar=True)\n",
+    "    precision = metrics['precision']\n",
+    "    recall_val = metrics['recall']\n",
+    "    f1 = metrics['f1_score']\n",
+    "    cm = metrics['confusion_matrix']\n",
+    "\n",
+    "    precision_curve, recall_curve, pr_thresholds = precision_recall_curve(labels, cosine_similarities)\n",
+    "\n",
+    "    # clear previous plots\n",
+    "    plt.clf()\n",
+    "\n",
+    "    # create subplots with a larger figure size for better readability\n",
+    "    fig, axs = plt.subplots(1, 2, figsize=(12, 6))\n",
+    "\n",
+    "    # Precision-Recall curve plot\n",
+    "    axs[0].plot(recall_curve, precision_curve, color='blue', linewidth=2, label='Precision-Recall Curve')\n",
+    "    axs[0].scatter(recall_val, precision, color='red', s=100, zorder=5,\n",
+    "                   label=(f'Threshold = {threshold:.4f}\\n'\n",
+    "                          f'Precision = {precision:.2f}\\n'\n",
+    "                          f'Recall = {recall_val:.2f}'))\n",
+    "    axs[0].set_title('Precision-Recall Curve', fontsize=20, fontweight='bold')\n",
+    "    axs[0].set_xlabel('Recall', fontsize=18)\n",
+    "    axs[0].set_ylabel('Precision', fontsize=18)\n",
+    "    axs[0].tick_params(axis='both', labelsize=16)\n",
+    "    axs[0].legend(fontsize=14)\n",
+    "    axs[0].grid(True, linestyle='--', alpha=0.7)\n",
+    "\n",
+    "    # confusion matrix heatmap\n",
+    "    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axs[1],\n",
+    "                cbar=True, annot_kws={'size': 16})\n",
+    "    axs[1].set_title('Confusion Matrix', fontsize=20, fontweight='bold')\n",
+    "    axs[1].set_xlabel('Predicted Label', fontsize=18)\n",
+    "    axs[1].set_ylabel('True Label', fontsize=18)\n",
+    "    axs[1].set_xticklabels(['Dissimilar (0)', 'Similar (1)'], fontsize=16)\n",
+    "    axs[1].set_yticklabels(['Dissimilar (0)', 'Similar (1)'], fontsize=16, rotation=0)\n",
+    "\n",
+    "    # overall figure title with metrics\n",
+    "    fig.suptitle(\n",
+    "        (f'Cosine Similarity Threshold: {threshold:.4f}\\n'\n",
+    "         f'Precision: {precision:.2f}, Recall: {recall_val:.2f}, F1 Score: {f1:.2f}'),\n",
+    "        fontsize=12, fontweight='bold'\n",
+    "    )\n",
+    "\n",
+    "    plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
+    "    plt.show()\n",
+    "\n",
+    "# add some CSS to increase the font size for the slider's description and readout\n",
+    "display(HTML(\"\"\"\n",
+    "<style>\n",
+    "    /* Style only the slider with the custom class 'custom-slider' */\n",
+    "    .custom-slider .widget-label {\n",
+    "        font-size: 20px !important;\n",
+    "        font-weight: bold;\n",
+    "    }\n",
+    "    .custom-slider .widget-readout {\n",
+    "        font-size: 18px !important;\n",
+    "    }\n",
+    "</style>\n",
+    "\"\"\"))\n",
+    "\n",
+    "# add a slider with the new description and custom styling\n",
+    "threshold_slider = FloatSlider(\n",
+    "    value=np.median(cosine_similarities),\n",
+    "    min=np.min(cosine_similarities),\n",
+    "    max=np.max(cosine_similarities),\n",
+    "    step=0.001,\n",
+    "    description='Cosine Similarity Threshold:',\n",
+    "    readout=True,\n",
+    "    readout_format='.4f',\n",
+    "    continuous_update=False,\n",
+    "    style={'description_width': 'initial'},\n",
+    "    layout=Layout(width='80%', margin='20px 0px 20px 0px')\n",
+    ")\n",
+    "\n",
+    "# add a custom class to the slider for our CSS targeting\n",
+    "threshold_slider.add_class(\"custom-slider\")\n",
+    "interact(update_plots, threshold=threshold_slider)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "redis-ai-res",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}