From e5a62888f095d21fe7b4fda89cc13aa9f966f1af Mon Sep 17 00:00:00 2001
From: swagataroy123 <39256293+swagataroy123@users.noreply.github.com>
Date: Wed, 23 Aug 2023 16:19:34 +0200
Subject: [PATCH] Added outlier detection tutorial (#262)

---
 .../007-Benchmark_outlier_detection.ipynb     | 805 ++++++++++++++++++
 .../008-Himmelblau_with_outliers.ipynb        | 746 ++++++++++++++++
 2 files changed, 1551 insertions(+)
 create mode 100644 tutorials/benchmarks/007-Benchmark_outlier_detection.ipynb
 create mode 100644 tutorials/benchmarks/008-Himmelblau_with_outliers.ipynb

diff --git a/tutorials/benchmarks/007-Benchmark_outlier_detection.ipynb b/tutorials/benchmarks/007-Benchmark_outlier_detection.ipynb
new file mode 100644
index 000000000..a4b6fa1c4
--- /dev/null
+++ b/tutorials/benchmarks/007-Benchmark_outlier_detection.ipynb
@@ -0,0 +1,805 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ca0699f0",
+   "metadata": {},
+   "source": [
+    "## Outlier detection benchmark\n",
+    "\n",
+    "Tutorial for benchmarking Robust Iterative trimming GP that detects outliers. It is benchmarked against standard GP and Student-t GP. Here, we compare on neal dataset.\n",
+    "The idea is adapted from https://www.sciencedirect.com/science/article/pii/S2213133721000378?via%3Dihub. Their code is available at https://github.com/syrte/robustgp/"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0a85382",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "11eb14eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from bofire.data_models.surrogates.api import SingleTaskGPSurrogate\n",
+    "from typing import Annotated, Literal\n",
+    "import os\n",
+    "from pydantic import Extra, Field\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib import cm\n",
+    "from bofire.data_models.domain.api import Inputs, Outputs\n",
+    "from bofire.data_models.features.api import (\n",
+    "    ContinuousInput,\n",
+    "    ContinuousOutput,\n",
+    ")\n",
+    "from bofire.data_models.outlier_detection.api import IterativeTrimming\n",
+    "import bofire.outlier_detection.api as outlier_mapper\n",
+    "import bofire.surrogates.api as surrogate_mapper\n",
+    "from bofire.data_models.kernels.api import (\n",
+    "    RBFKernel,\n",
+    "    ScaleKernel,\n",
+    "    MaternKernel,\n",
+    "    AnyKernel,\n",
+    ")\n",
+    "from bofire.data_models.priors.api import (\n",
+    "    BOTORCH_LENGTHCALE_PRIOR,\n",
+    "    BOTORCH_NOISE_PRIOR,\n",
+    "    BOTORCH_SCALE_PRIOR,\n",
+    "    AnyPrior,\n",
+    ")\n",
+    "from bofire.data_models.surrogates.api import (\n",
+    "    ScalerEnum,\n",
+    "    SingleTaskGPSurrogate,\n",
+    ")\n",
+    "from bofire.data_models.surrogates.botorch import BotorchSurrogate\n",
+    "from scipy.stats import t, norm, uniform\n",
+    "import base64\n",
+    "import io\n",
+    "from typing import Dict, Optional\n",
+    "\n",
+    "import botorch\n",
+    "import dill\n",
+    "import gpytorch\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import torch\n",
+    "from botorch.fit import fit_gpytorch_mll\n",
+    "from botorch.models.transforms.outcome import Standardize\n",
+    "from gpytorch.likelihoods import StudentTLikelihood\n",
+    "from gpytorch.mlls import VariationalELBO\n",
+    "\n",
+    "import bofire.kernels.api as kernels\n",
+    "import bofire.priors.api as priors\n",
+    "from bofire.data_models.enum import OutputFilteringEnum\n",
+    "from bofire.surrogates.botorch import BotorchSurrogate as BotorchSurrogate1\n",
+    "from bofire.surrogates.single_task_gp import get_scaler\n",
+    "from bofire.surrogates.trainable import TrainableSurrogate\n",
+    "from bofire.utils.torch_tools import tkwargs\n",
+    "\n",
+    "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a26538c",
+   "metadata": {},
+   "source": [
+    "## Class for Student-t GP "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "1b5dcd11",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class DataModel(BotorchSurrogate):\n",
+    "    class Config:\n",
+    "        arbitrary_types_allowed = True\n",
+    "        extra = Extra.allow\n",
+    "\n",
+    "    type: Literal[\n",
+    "        \"SingleTaskVariationalGPSurrogate\"\n",
+    "    ] = \"SingleTaskVariationalGPSurrogate\"\n",
+    "    num_outputs: Annotated[int, Field(ge=1)] = 1\n",
+    "    kernel: AnyKernel = Field(\n",
+    "        default_factory=lambda: ScaleKernel(\n",
+    "            base_kernel=MaternKernel(\n",
+    "                ard=True,\n",
+    "                nu=2.5,\n",
+    "                lengthscale_prior=BOTORCH_LENGTHCALE_PRIOR(),\n",
+    "            ),\n",
+    "            outputscale_prior=BOTORCH_SCALE_PRIOR(),\n",
+    "        )\n",
+    "    )\n",
+    "    noise_prior: AnyPrior = Field(default_factory=lambda: BOTORCH_NOISE_PRIOR())\n",
+    "    scaler: ScalerEnum = ScalerEnum.NORMALIZE\n",
+    "\n",
+    "\n",
+    "class SingleTaskVariationalGPSurrogate(BotorchSurrogate1, TrainableSurrogate):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        data_model: DataModel,\n",
+    "        **kwargs,\n",
+    "    ):\n",
+    "        self.kernel = data_model.kernel\n",
+    "        self.scaler = data_model.scaler\n",
+    "        self.noise_prior = data_model.noise_prior\n",
+    "        self.num_outputs = data_model.num_outputs\n",
+    "        super().__init__(data_model=data_model, **kwargs)\n",
+    "\n",
+    "    model: Optional[botorch.models.SingleTaskVariationalGP] = None\n",
+    "    _output_filtering: OutputFilteringEnum = OutputFilteringEnum.ALL\n",
+    "    training_specs: Dict = {}\n",
+    "\n",
+    "    def _fit(self, X: pd.DataFrame, Y: pd.DataFrame):\n",
+    "        scaler = get_scaler(self.inputs, self.input_preprocessing_specs, self.scaler, X)\n",
+    "        transformed_X = self.inputs.transform(X, self.input_preprocessing_specs)\n",
+    "\n",
+    "        tX, tY = torch.from_numpy(transformed_X.values).to(**tkwargs), torch.from_numpy(\n",
+    "            Y.values\n",
+    "        ).to(**tkwargs)\n",
+    "        self.output_transform = Standardize(m=tY.shape[-1])\n",
+    "        tY, _ = self.output_transform(tY)\n",
+    "        self.model = botorch.models.SingleTaskVariationalGP(  # type: ignore\n",
+    "            train_X=tX,\n",
+    "            train_Y=tY,\n",
+    "            likelihood=StudentTLikelihood(noise_prior=priors.map(self.noise_prior)),\n",
+    "            num_outputs=self.num_outputs,\n",
+    "            learn_inducing_points=False,\n",
+    "            inducing_points=tX,\n",
+    "            covar_module=kernels.map(\n",
+    "                self.kernel,\n",
+    "                batch_shape=torch.Size(),\n",
+    "                active_dims=list(range(tX.shape[1])),\n",
+    "                ard_num_dims=1,  # this keyword is ingored\n",
+    "            ),\n",
+    "            # outcome_transform=Standardize(m=tY.shape[-1]),\n",
+    "            input_transform=scaler,\n",
+    "        )\n",
+    "\n",
+    "        # self.model.likelihood.noise_covar.noise_prior = priors.map(self.noise_prior)  # type: ignore\n",
+    "\n",
+    "        mll = VariationalELBO(\n",
+    "            self.model.likelihood, self.model.model, num_data=tX.shape[-2]\n",
+    "        )\n",
+    "        fit_gpytorch_mll(mll, options=self.training_specs, max_attempts=10)\n",
+    "\n",
+    "    def _predict(self, transformed_X: pd.DataFrame):\n",
+    "        # transform to tensor\n",
+    "        X = torch.from_numpy(transformed_X.values).to(**tkwargs)\n",
+    "        self.model.model.eval()  # type: ignore\n",
+    "        self.model.likelihood.eval()  # type: ignore\n",
+    "        with torch.no_grad() and gpytorch.settings.num_likelihood_samples(128):\n",
+    "            preds = self.model.posterior(X=X, observation_noise=True).mean.mean(dim=0).cpu().detach()  # type: ignore\n",
+    "            variance = self.model.posterior(X=X, observation_noise=True).variance.mean(dim=0).cpu().detach()  # type: ignore\n",
+    "\n",
+    "            preds, variance = self.output_transform.untransform(preds, variance)\n",
+    "            preds = preds.numpy()\n",
+    "            stds = np.sqrt(variance.numpy())  # type: ignore\n",
+    "        return preds, stds\n",
+    "\n",
+    "    def _dumps(self) -> str:\n",
+    "        \"\"\"Dumps the actual model to a string via pickle as this is not directly json serializable.\"\"\"\n",
+    "        buffer = io.BytesIO()\n",
+    "        torch.save(\n",
+    "            {\"model\": self.model, \"output_transform\": self.output_transform},\n",
+    "            buffer,\n",
+    "            pickle_module=dill,\n",
+    "        )\n",
+    "        return base64.b64encode(buffer.getvalue()).decode()\n",
+    "\n",
+    "    def loads(self, data: str):\n",
+    "        \"\"\"Loads the actual model from a base64 encoded pickle bytes object and writes it to the `model` attribute.\"\"\"\n",
+    "        buffer = io.BytesIO(base64.b64decode(data.encode()))\n",
+    "        path = torch.load(buffer, pickle_module=dill)\n",
+    "        self.model = path[\"model\"]\n",
+    "        self.output_transform = path[\"output_transform\"]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c5285dcc",
+   "metadata": {},
+   "source": [
+    "## set up inputs, outputs and surrogate models for different GPs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "3b3c2096",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inputs = Inputs(\n",
+    "    features=[\n",
+    "        ContinuousInput(\n",
+    "            key=f\"x_{1}\",\n",
+    "            bounds=(-3, 3),\n",
+    "        ),\n",
+    "    ]\n",
+    ")\n",
+    "outputs = Outputs(features=[ContinuousOutput(key=\"y\")])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "14cbb042",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "kernel = ScaleKernel(base_kernel=RBFKernel(ard=True))\n",
+    "scaler = ScalerEnum.NORMALIZE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "b8e7f493",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_GP = SingleTaskGPSurrogate(\n",
+    "    inputs=inputs, outputs=outputs, kernel=kernel, scaler=scaler\n",
+    ")\n",
+    "model_GP = surrogate_mapper.map(model_GP)\n",
+    "model_tP = DataModel(inputs=inputs, outputs=outputs, kernel=kernel, scaler=scaler)\n",
+    "model_tP = SingleTaskVariationalGPSurrogate(data_model=model_tP)\n",
+    "model_ideal_GP = SingleTaskGPSurrogate(\n",
+    "    inputs=inputs, outputs=outputs, kernel=kernel, scaler=scaler\n",
+    ")\n",
+    "model_ideal_GP = surrogate_mapper.map(model_ideal_GP)\n",
+    "model_ITGP = SingleTaskGPSurrogate(\n",
+    "    inputs=inputs, outputs=outputs, kernel=kernel, scaler=scaler\n",
+    ")\n",
+    "model_ITGP_final = SingleTaskGPSurrogate(\n",
+    "    inputs=inputs, outputs=outputs, kernel=kernel, scaler=scaler\n",
+    ")\n",
+    "model_ITGP_final = surrogate_mapper.map(model_ITGP_final)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "f6ec720c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ITGP_detector = IterativeTrimming(base_gp=model_ITGP)\n",
+    "ITGP_detector = outlier_mapper.map(ITGP_detector)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "444fdeed",
+   "metadata": {},
+   "source": [
+    "## Neal dataset\n",
+    "We create neal dataset for benchmarking from the paper  https://www.sciencedirect.com/science/article/pii/S2213133721000378?via%3Dihub."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "af358efe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def neal_func(x):\n",
+    "    return 0.3 + 0.4 * x + 0.5 * np.sin(2.7 * x) + 1.1 / (1 + x**2)\n",
+    "\n",
+    "\n",
+    "def neal_dataset(\n",
+    "    n=100, s1=0.1, s2=1, m2=0, f2=0.15, t2=\"n\", sampling=\"rand\", **args_extra\n",
+    "):\n",
+    "    n2 = int(n * f2)\n",
+    "    n1 = n - n2\n",
+    "\n",
+    "    if sampling == \"randn\":\n",
+    "        x = np.random.randn(n)\n",
+    "    elif sampling == \"rand\":\n",
+    "        x = np.random.rand(n) * 6 - 3\n",
+    "    elif sampling == \"grid\":\n",
+    "        x = np.linspace(-3, 3, n)\n",
+    "    else:\n",
+    "        raise ValueError\n",
+    "    y_tr = neal_func(x)\n",
+    "\n",
+    "    y_ob = np.zeros(n)\n",
+    "    label = np.zeros(n, dtype=int)\n",
+    "\n",
+    "    ix1 = np.zeros(n, dtype=bool)\n",
+    "    ix1[np.random.choice(n, n1, replace=False)] = True\n",
+    "    ix2 = ~ix1\n",
+    "\n",
+    "    y_ob[ix1] = y_tr[ix1] + norm(0, s1).rvs(n1)\n",
+    "    if t2 == \"n\":\n",
+    "        y_ob[ix2] = y_tr[ix2] + norm(m2, s2).rvs(n2)\n",
+    "    elif t2 == \"t1\":\n",
+    "        y_ob[ix2] = y_tr[ix2] + t(1, m2, s2).rvs(n2)\n",
+    "    elif t2 == \"t3\":\n",
+    "        y_ob[ix2] = y_tr[ix2] + t(3, m2, s2).rvs(n2)\n",
+    "    elif t2 == \"u\":\n",
+    "        y_ob[ix2] = uniform(m2, s2).rvs(n2)\n",
+    "    else:\n",
+    "        raise ValueError\n",
+    "\n",
+    "    label[ix1] = 0\n",
+    "    label[ix2] = 1\n",
+    "\n",
+    "    dic = dict(x=x, y_ob=y_ob, y_tr=y_tr, label=label)\n",
+    "    return dic\n",
+    "\n",
+    "\n",
+    "# np.random.seed(5)\n",
+    "sample = 10 if not SMOKE_TEST else 1\n",
+    "n = 100"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c2cc5780",
+   "metadata": {},
+   "source": [
+    "## Adding outliers\n",
+    "We use 9 outlier noise conditions to test our models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "8ecb0fa6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "args_list = [\n",
+    "    (\"zero\", dict(n=n, s1=0.1, s2=1.0, m2=0, f2=0, t2=\"n\")),\n",
+    "    (\"rare\", dict(n=n, s1=0.1, s2=1.0, m2=0, f2=0.05, t2=\"n\")),\n",
+    "    (\"fiducial\", dict(n=n, s1=0.1, s2=1.0, m2=0, f2=0.15, t2=\"n\")),\n",
+    "    (\"abundant\", dict(n=n, s1=0.1, s2=1.0, m2=0, f2=0.45, t2=\"n\")),\n",
+    "    (\"skewed\", dict(n=n, s1=0.1, s2=1.0, m2=2, f2=0.15, t2=\"n\")),\n",
+    "    (\"extreme\", dict(n=n, s1=0.1, s2=5.0, m2=0, f2=0.15, t2=\"n\")),\n",
+    "    (\"uniform\", dict(n=n, s1=0.1, s2=6.0, m2=-3, f2=0.3, t2=\"u\")),\n",
+    "    (\"t3\", dict(n=n, s1=0.1, s2=0.1, m2=0, f2=1, t2=\"t3\")),\n",
+    "    (\"t1\", dict(n=n, s1=0.1, s2=0.1, m2=0, f2=1, t2=\"t1\")),\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "6276785e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\S31990\\AppData\\Local\\Temp\\ipykernel_20244\\2875415920.py:6: UserWarning: No data for colormapping provided via 'c'. Parameters 'vmin', 'vmax' will be ignored\n",
+      "  ax[i, j].scatter(\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 9 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(3, 3, figsize=(10, 10))\n",
+    "k = 0\n",
+    "for i in range(3):\n",
+    "    for j in range(3):\n",
+    "        d = neal_dataset(**args_list[k][1])\n",
+    "        ax[i, j].scatter(\n",
+    "            d[\"x\"],\n",
+    "            d[\"y_ob\"],\n",
+    "            facecolor=cm.tab20.colors[1],\n",
+    "            edgecolor=cm.tab20.colors[0],\n",
+    "            vmin=-0.5,\n",
+    "            vmax=1.5,\n",
+    "            s=5,\n",
+    "            lw=0.5,\n",
+    "            alpha=0.8,\n",
+    "        )\n",
+    "        x = np.linspace(-3, 3, 51)\n",
+    "        ax[i, j].plot(x, neal_func(x), \"k-\", lw=1.5, zorder=-1)\n",
+    "        ax[i, j].set_ylim(-3.5, 3.5)\n",
+    "        ax[i, j].text(0.7, 0.1, args_list[k][0], transform=ax[i, j].transAxes)\n",
+    "        k = k + 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "52ff9f2d",
+   "metadata": {},
+   "source": [
+    "## Run fitting\n",
+    "We use standard GP for dataset without outliers, standard GP for outliers, Iterative gp (ITGP) and student-t GP"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "2aaa6651",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n",
+      "c:\\Users\\S31990\\AppData\\Local\\anaconda3\\envs\\bofire\\lib\\site-packages\\botorch\\models\\model.py:212: RuntimeWarning: Could not update `train_inputs` with transformed inputs since SingleTaskVariationalGP does not have a `train_inputs` attribute. Make sure that the `input_transform` is applied to both the train inputs and test inputs.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
+   "source": [
+    "def loss_RMSE(y, y0):\n",
+    "    return np.sqrt(np.mean((y - y0) ** 2))\n",
+    "\n",
+    "\n",
+    "cols = [\n",
+    "    \"zero\",\n",
+    "    \"rare\",\n",
+    "    \"fiducial\",\n",
+    "    \"abundant\",\n",
+    "    \"skewed\",\n",
+    "    \"extreme\",\n",
+    "    \"uniform\",\n",
+    "    \"t3\",\n",
+    "    \"t1\",\n",
+    "]\n",
+    "rmse_GP, rmse_ideal, rmse_ITGP, rmse_tP = (\n",
+    "    pd.DataFrame(columns=cols),\n",
+    "    pd.DataFrame(columns=cols),\n",
+    "    pd.DataFrame(columns=cols),\n",
+    "    pd.DataFrame(columns=cols),\n",
+    ")\n",
+    "test_data = neal_dataset(\n",
+    "    **dict(n=1000, s1=0, s2=0, m2=0, f2=0, sampling=\"grid\", mode=\"test\")\n",
+    ")\n",
+    "test_experiments = pd.DataFrame()\n",
+    "test_experiments[\"x_1\"] = test_data[\"x\"]\n",
+    "test_experiments[\"y\"] = test_data[\"y_tr\"]\n",
+    "\n",
+    "for j in range(len(cols)):\n",
+    "    GP, ideal_GP, ITGP, tP = [], [], [], []\n",
+    "    for i in range(sample):\n",
+    "        train_data = neal_dataset(**args_list[j][1])\n",
+    "        experiments = pd.DataFrame()\n",
+    "        experiments[\"x_1\"] = train_data[\"x\"]\n",
+    "        experiments[\"y\"] = train_data[\"y_ob\"]\n",
+    "        experiments[\"valid_y\"] = 1\n",
+    "        ideal_experiments = experiments.copy()\n",
+    "        ideal_experiments.loc[train_data[\"label\"] == 1, \"valid_y\"] = 0\n",
+    "        experiments_trimmed = ITGP_detector.detect(experiments)\n",
+    "        model_GP.fit(experiments)\n",
+    "        model_tP.fit(experiments)\n",
+    "        GP_test = model_GP.predict(test_experiments)\n",
+    "        tP_test = model_tP.predict(test_experiments)\n",
+    "        if cols[j] != \"t3\" and cols[j] != \"t1\":\n",
+    "            model_ideal_GP.fit(ideal_experiments)\n",
+    "            ideal_GP_test = model_ideal_GP.predict(test_experiments)\n",
+    "            ideal_GP.append(\n",
+    "                loss_RMSE(ideal_GP_test[\"y_pred\"], test_experiments[\"y\"])\n",
+    "            )\n",
+    "        else:\n",
+    "            ideal_GP.append(np.NaN)\n",
+    "        model_ITGP_final.fit(experiments_trimmed)\n",
+    "        ITGP_test = model_ITGP_final.predict(test_experiments)\n",
+    "\n",
+    "        GP.append(loss_RMSE(GP_test[\"y_pred\"], test_experiments[\"y\"]))\n",
+    "\n",
+    "        ITGP.append(loss_RMSE(ITGP_test[\"y_pred\"], test_experiments[\"y\"]))\n",
+    "\n",
+    "        tP.append(loss_RMSE(tP_test[\"y_pred\"], test_experiments[\"y\"]))\n",
+    "\n",
+    "    rmse_GP[cols[j]] = np.array(GP) / 0.032\n",
+    "    rmse_ideal[cols[j]] = np.array(ideal_GP) / 0.032\n",
+    "    rmse_ITGP[cols[j]] = np.array(ITGP) / 0.032\n",
+    "    rmse_tP[cols[j]] = np.array(tP) / 0.032"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cdad4f24",
+   "metadata": {},
+   "source": [
+    "## Performance comparision\n",
+    "Here we plot the performance comparision similar to fig 4 in paper  https://www.sciencedirect.com/science/article/pii/S2213133721000378?via%3Dihub. ITGP performs better than other GPs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "1d371558",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x251ceb4e020>"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABMwAAAG+CAYAAABvZpgOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABqHUlEQVR4nO3deXhTZf7+8Tu0tGmgFDAgIIQyIk2UpbQ6KJVlFEEZGXGBcamKKyqouOAyMyK4IV/FfUZxA6QyLsjiDwVFZRXcwqJoU5ChU1RQylZKm0Lb8/ujNpPQLS0nTdO+X9fFFXLOyZNP0zQ5ufMsFsMwDAEAAAAAAACQJDULdwEAAAAAAABAQ0JgBgAAAAAAAPghMAMAAAAAAAD8EJgBAAAAAAAAfgjMAAAAAAAAAD8EZgAAAAAAAIAfAjMAAAAAAADAD4EZAAAAAAAA4IfADAAAAAAAAPBDYAYAAABJUmlpqXr27KlHH3003KXUm5deekkOh0NFRUXhLgUAADQgBGYAACBiWSyWoP6tWLHimO+roKBAkydPNqWthurf//63duzYofHjx9fr/b799ttKT0/XSSedJIvFosGDB1d5bFFRke6991516tRJcXFx6tevn5YtW1bpsWvXrtWZZ54pm82mDh066LbbblN+fn7AMWPGjNHhw4c1Y8YMM38kAAAQ4aLDXQAAAEBdzZkzJ+D6G2+8oWXLllXY7nK5jvm+CgoKNGXKFEmqNtCJZE888YQuvfRSJSQk1Ov9vvjii3K73TrttNO0Z8+eao8dM2aM5s2bpwkTJuikk07SrFmzNHz4cC1fvlxnnnmm77iNGzfq7LPPlsvl0lNPPaWffvpJTz75pLZu3aolS5b4jrNarbr66qv11FNP6dZbb5XFYgnZzwkAACKHxTAMI9xFAAAAmGH8+PH65z//qVCc3uTm5qpdu3Z68MEHNXnyZNPbD7cNGzYoJSVFn3zyic4+++x6ve8dO3bohBNOULNmzdSzZ0/Z7fZKe/J99dVX6tevn5544gndfffdkiSv16uePXuqffv2Wrt2re/Y4cOHa+PGjfJ4PGrVqpUk6dVXX9UNN9ygjz76SEOHDvUd63a7deqpp+rTTz/VWWedFdofFgAARASGZAIAgEattLRUzzzzjE455RRZrVYdf/zxGjt2rPbt2xdw3DfffKNhw4bJbrcrLi5O3bp107XXXitJys7OVrt27SRJU6ZM8Q31rCk4279/v+644w4lJiYqNjZWnTt31lVXXaXc3FxJ0uHDhzVp0iSlpqYqISFBLVq00IABA7R8+fIKbb311ltKTU1VfHy8WrVqpV69eunZZ5+tcH8TJkxQly5dFBsbq+7du2vatGkqLS2t8XFauHChYmJiNHDgwIDtkydPlsVi0Y8//qgxY8aodevWSkhI0DXXXKOCgoIa2w1Gly5d1KxZzael8+bNU1RUlG688UbfNqvVquuuu07r1q3Tjh07JEl5eXlatmyZ0tPTfWGZJF111VVq2bKl3nnnnYB2U1NT1bZtWy1atMiUnwcAAEQ+hmQCAIBGbezYsZo1a5auueYa3Xbbbdq+fbteeOEFbdiwQZ9//rmaN2+u3377TUOHDlW7du103333qXXr1srOztb8+fMlSe3atdOLL76om2++WRdeeKEuuugiSVLv3r2rvN/8/HwNGDBAmZmZuvbaa5WSkqLc3Fy9//77+umnn2S325WXl6dXX31Vl112mW644QYdPHhQr732moYNG6avvvpKycnJkqRly5bpsssu09lnn61p06ZJkjIzM/X555/r9ttvl1Q2ZHTQoEH6+eefNXbsWDkcDq1du1b333+/du7cqWeeeabax2nt2rXq2bOnmjdvXun+0aNHq1u3bpo6darWr1+vV199Ve3bt/fVI0kHDhzQkSNHavydWK1WtWzZssbjjrZhwwb16NEjIASTpD/+8Y+SyoZhdunSRd99952Ki4t16qmnBhwXExOj5ORkbdiwoULbKSkp+vzzz2tdEwAAaJwIzAAAQKO1Zs0avfrqq3rzzTd1+eWX+7b/6U9/0rnnnqt3331Xl19+udauXat9+/bp448/DghZHnnkEUlSixYtdMkll+jmm29W7969lZ6eXuN9P/HEE9q8ebPmz5+vCy+80Lf9H//4h2/IaJs2bZSdna2YmBjf/htuuEFOp1PPP/+8XnvtNUnSBx98oFatWumjjz5SVFRUpff31FNPadu2bdqwYYNOOukkSWVhYadOnfTEE0/orrvuUpcuXaqs1+PxqF+/flXu79u3r68eSdqzZ49ee+21gMDsggsu0MqVK6t7WCRJV199tWbNmlXjcUfbuXOnOnbsWGF7+bZffvnFd5z/9qOPXb16dYXtf/jDHyrMfQcAAJouAjMAANBovfvuu0pISNA555zjGwYplQ3Ba9mypZYvX67LL79crVu3liQtXrxYffr0qbKXVW2899576tOnT0BYVq58YvmoqChfAFZaWqr9+/ertLRUp556qtavX+87vnXr1jp06JCWLVumc889t8qfdcCAAWrTpk3AzzpkyBA9/vjjWrVqla644ooq692zZ4/atGlT5f6bbrop4PqAAQO0YMEC5eXl+Xp8TZ8+vcJQ18p06tSpxmMqU1hYqNjY2ArbrVarb7//ZVXHlu/316ZNGxUWFqqgoEA2m61O9QEAgMaDwAwAADRaW7du1YEDB9S+fftK9//222+SpEGDBuniiy/WlClT9PTTT2vw4MEaOXKkLr/88kpDl2Bs27ZNF198cY3HzZ49W9OnT5fH4wkYztitWzff/2+55Ra98847Ou+883TCCSdo6NChGj16dEB4tnXrVn377be+udaq+lmrU91iCQ6HI+B6ebi2b98+X2CWmppa430ci7i4OBUVFVXY7vV6ffv9L6s6tny/v/KfnVUyAQCARGAGAAAasdLSUrVv315vvvlmpfvLwyWLxaJ58+bpiy++0P/7f/9PH330ka699lpNnz5dX3zxRZ3m2wpGRkaGxowZo5EjR2rixIlq3769oqKiNHXqVG3bts13XPv27bVx40Z99NFHWrJkiZYsWaKZM2fqqquu0uzZs30/6znnnKN77rmn0vvq0aNHtbUcd9xx1fYOq2ooqH/ItnfvXh0+fLja+5HKAq2EhIQajztax44d9fPPP1fYXj4Es7znWvlQzPLtRx9bWQ+3ffv2yWazVRqmAQCApofADAAANFonnniiPvnkE6WlpQUVhJx++uk6/fTT9eijj2ru3Lm64oor9NZbb+n666+vdc+jE088UZs3b672mHnz5ukPf/iD5s+fH9D+gw8+WOHYmJgYjRgxQiNGjFBpaaluueUWzZgxQw888IC6d++uE088Ufn5+RoyZEit6izndDq1ffv2Ot223EUXXRTSOcySk5O1fPnygGGgkvTll1/69ktSz549FR0drW+++UajR4/2HXf48GFt3LgxYFu57du3y+Vy1bomAADQONW8fjcAAECEGj16tEpKSvTwww9X2FdcXKz9+/dLKutddPRwxPLwpXxYX/m8VuW3qcnFF1+sTZs2acGCBRX2ld9Xea8t//v+8ssvtW7duoDj9+zZE3C9WbNmvhU6y+sbPXq01q1bp48++qjC/e3fv1/FxcXV1nvGGWdo8+bNlQ5jDNb06dO1bNmyGv9V1QuuJpdccolKSkr08ssv+7YVFRVp5syZ6tevn29Rg4SEBA0ZMkQZGRk6ePCg79g5c+YoPz9fo0aNqtD2+vXr1b9//zrVBQAAGh96mAEAgEZr0KBBGjt2rKZOnaqNGzdq6NChat68ubZu3ap3331Xzz77rC655BLNnj1b//rXv3ThhRfqxBNP1MGDB/XKK6+oVatWGj58uKSyYYQnn3yy3n77bfXo0UNt27ZVz5491bNnz0rve+LEiZo3b55GjRqla6+9Vqmpqdq7d6/ef/99vfTSS+rTp4/OP/983yqaf/7zn7V9+3a99NJLOvnkk5Wfn+9r6/rrr9fevXt11llnqXPnzvrvf/+r559/XsnJyb5eURMnTtT777+v888/X2PGjFFqaqoOHTqk7777TvPmzVN2drbsdnuVj9UFF1yghx9+WCtXrtTQoUPr9HjXdQ6zVatWadWqVZKk3bt369ChQ74VSgcOHKiBAwdKkvr166dRo0bp/vvv12+//abu3btr9uzZys7ODljBU5IeffRR9e/fX4MGDdKNN96on376SdOnT9fQoUMrLJzgdru1d+9eXXDBBXWqHwAANEIGAABAIzFu3DijstObl19+2UhNTTXi4uKM+Ph4o1evXsY999xj/PLLL4ZhGMb69euNyy67zHA4HEZsbKzRvn174/zzzze++eabgHbWrl1rpKamGjExMYYk48EHH6y2nj179hjjx483TjjhBCMmJsbo3LmzcfXVVxu5ubmGYRhGaWmp8dhjjxldu3Y1YmNjjb59+xqLFy82rr76aqNr166+dubNm2cMHTrUaN++vRETE2M4HA5j7Nixxs6dOwPu7+DBg8b9999vdO/e3YiJiTHsdrvRv39/48knnzQOHz5c4+PXu3dv47rrrgvY9uCDDxqSjN27dwdsnzlzpiHJ2L59e43t1qT8Pir7d/RjXFhYaNx9991Ghw4djNjYWOO0004zli5dWmm7q1evNvr3729YrVajXbt2xrhx44y8vLwKx917772Gw+EwSktLj/lnAQAAjYPFMKpZDgkAAABNxpw5czRu3Djl5OSodevW4S6nXhQVFSkxMVH33Xefbr/99nCXAwAAGgjmMAMAAIAk6YorrpDD4dA///nPcJdSb2bOnKnmzZvrpptuCncpAACgAaGHGQAAAAAAAOCHHmYAAAAAAACAHwIzAAAAAAAAwA+BGQAAAAAAAOCHwAwAAAAAAADwEx3uAkKptLRUv/zyi+Lj42WxWMJdDgAAAAAAAMLEMAwdPHhQnTp1UrNm1fcha9SB2S+//KIuXbqEuwwAAAAAAAA0EDt27FDnzp2rPaZRB2bx8fGSyh6IVq1ahbkaAAAAAAAAhEteXp66dOniy4uq06gDs/JhmK1atSIwAwAAAAAAQFDTdjHpPwAAAAAAAOCHwAwAAAAAAADw06iHZAIAAAAAADQ1JSUlOnLkSLjLCKvmzZsrKiqqzrcnMAMAAAAAAGgk8vPz9dNPP8kwjHCXElYWi0WdO3dWy5Yt63R7AjMAAAAAAIBGoKSkRD/99JNsNpvatWsX1OT2jZFhGNq9e7d++uknnXTSSXXqaUZgBgAAAAAA0AgcOXJEhmGoXbt2iouLC3c5YdWuXTtlZ2fryJEjdQrMmPQfAAAAAACgEWmqPcv8HetjQGAGAAAAAADQSFksoflXG0eOHNGUKVPkdDp1yimnqG/fvho5cqQ2btyoFStWKC4uTsnJyerdu7fOPPNMffvtt6F5MGqBIZkAAAAAAAAImWuuuUb5+flat26d2rRpI0n65JNPlJWVpeOPP15JSUnauHGjJOmpp57SNddcI7fbHcaKCcwAAAAAAAAQIlu3btWCBQu0Y8cOX1gmSUOGDJEkrVixIuD4c889V5MmTarPEivFkEwAAAAAAACExIYNG9S9e3e1bds2qOPfeustpaamhriqmhGYAQAAAAAAoF5s27ZNycnJSkpK0jXXXCNJysrKUnJyspKTk+XxeDR79uwwV8mQTAAAAAAAAIRI37599eOPP2rfvn1q06aNTjzxRG3cuFGzZs3SwoULJSlgDrOGgh5mAAAAAAAACImTTjpJF1xwga677jrt37/ft/3QoUPhKyoI9DADAAAATFRQUCCPxxOwrbCwUNnZ2UpMTFRcXFzAPqfTKZvNVp8lAgBQr2bNmqVHH31U/fr1U3R0tNq0aaN27drp3nvvVVFRUbjLq5TFMAwj3EWESl5enhISEnTgwAG1atUq3OUAAACgCVi/fn2tJit2u91KSUkJYUUAgKbC6/Vq+/bt6tatm6xWa7jLCavKHova5ET0MAMAAABM5HQ65Xa7A7ZlZmYqPT1dGRkZcrlcFY4HAAANC4EZAAAAYCKbzVZljzGXy0VvMgAAIgCT/gMAAAAAAAB+CMwAAAAAAAAAPwRmAAAAAAAAgB8CMwAAAAAAAMAPgRkAAAAAAADgh1UyAQAAAAAAGinLFEtI2jUeNII6LjExUd27d1dubq4k6YcfflC3bt0UFxcnSVq9erWsVqsee+wx/fvf/1ZUVJRiYmLUtWtXTZ48WcnJyVqxYoXOO+88JSUlqbS0VK1atdK//vUv9e7dOyQ/m0RgBgAAAByTnBzp988AVcrMDLysjt0uORzHXhcAAA3Fk08+qeTkZEllAdrbb7/tuy5J6enpys/P17p169SmTRtJ0ieffKKsrCzfcUlJSdq4caMk6amnntI111wjt9sdspoJzAAAAIA6ysmRkpIkrze449PTaz7GapWysgjNAABNw9atW7VgwQLt2LHDF5ZJ0pAhQ6q8zbnnnqtJkyaFtC4CMwAAAKCOcnODDcuckty/X1bP6y1rl8AschUUFMjj8QRsKywsVHZ2thITE33DkMo5nU7ZbLb6LBEAGowNGzaoe/fuatu2bdC3eeutt5SamhrCqgjMAAAAgHpgk5QS7iJQTzweT60+yLndbqWk8PwAAEnatm2bLr74YhUWFqp///6aOXOmJAUMz+zRo4dmz54d0joIzAAAAADARE6ns8K8OpmZmUpPT1dGRoZcLleF4wGgqerbt69+/PFH7du3T23atNGJJ56ojRs3atasWVq4cKHvOP85zOoDgRkAAAAAHIOKCz9U16PQVWHfUaM3WfgBQJNy0kkn6YILLtB1112n119/Xa1bt5YkHTp0KKx1EZgBAAAAQB2x8AMAHLtZs2bp0UcfVb9+/RQdHa02bdqoXbt2uvfee8NWE4EZAAAAANQRCz8AqMrRC4CEa/EP40EjJO0GKzs7u9rrkhQTE6MpU6ZoypQplbYxePDgeh2OKRGYAQAAmIrV8QBUjoUfgKamNguAsPhHw0NgBgAAYCJWxwMAAFLFBUBY/COyEJgBAACYiNXxAACAJNlstkq/FHO5XHxZFgEIzAAAAExU1cmxxAkyAABApCAwAwAAOAY5OWWTc1cnMzPwsip2O5N8RxpLcYH6dtgSgnZ7qGzOKwAAEA4EZgAAAHWUkyMlJQW7Qp6Unl79fqtVysoiNIsk1vwtWj92kOntZuavlJRsersAACA4BGYAAAB1lJsbbFjmlOT+/bJqXm9ZmwRmkcPbsodSZqw0vd3XhvcwvU0AQBNlsYSmXcMI6rDExEQtXLhQycnJAdsvueQSnX/++RozZkydS6iqbTNERGBWUFAgl8ulUaNG6cknnwx3OQAAALVkk8TcZY2REW3Thl3JQRxZIMmjstC05qGWRkScpQMA0HhFxFvxo48+qtNPPz3cZQAAAAQIxfxVzF0VWez2sqG0Nfc09EhKVVlPw+rDU6u1rF0AABoTj8eja6+9VgcOHNBJJ52kgoIC376DBw/qzjvv1KZNm+T1enX66afrhRdeUExMjJ566in9+9//1pEjR9S8eXM999xzOuOMM0Jeb4MPzLZu3SqPx6MRI0Zo8+bN4S4HAADAJxTzVzF3VWRxOMrmnQtm4Yf0dCkjQ3K5qj+WxR8AAI3RlVdeqZtuuknXXXedvvvuO5166qm6/PLLJUl33XWXBgwYoFdeeUWGYeiGG27Qs88+q4kTJ+rKK6/UnXfeKUn64osvNGbMGHk8npDXG/bAbOrUqZo/f748Ho/i4uLUv39/TZs2TUlJSZKku+++W0888YTWrl0b5koBAAAChWL+KuauijwOR/ABl8slpTA6t1FhpVQAqFleXp42btzom6+sV69eOvPMM337Fy5cqHXr1umpp56SJBUWFioqKkqStGHDBj366KPas2ePoqOjlZWVpcLCQsXFxYW05rAHZitXrtS4ceN02mmnqbi4WH/72980dOhQ/fDDD/rkk0/Uo0cP9ejRg8AMABARCgoKKnzjVVhYqOzsbCUmJga8sTudTtlsfBiKZMHPX1WbNk1tDkCIsVIqANSNxW8xAsMw9N5776lHj8AvDg8fPqyLLrpIy5cv12mnnaa8vDwlJCSoqKio8QdmS5cuDbg+a9YstW/fXm63W1988YXeeustvfvuu8rPz9eRI0fUqlUrTZo0qdK2ioqKVFRU5Luel5cX0toBADiax+NRampqUMe63W6l0NUEACIaK6UCQM1atWqlvn376o033tA111yj77//XmvWrFF6erokaeTIkZo2bZpmzJih6Oho7du3T3v27FH79u11+PBhOX7vyv3888/XW81hD8yOduDAAUlS27ZtNXXqVE2dOlVSWZC2efPmKsMyqWx455QpU+qlTgAAKuN0OuV2uwO2ZWZmKj09XRkZGXL5TV7kdDrruzwAgMlC0dO0rF3TmwSAsCoPy6ZPn66TTjpJAwcO9O17+umndd999yk5OVnNmjVTdHS0/u///k/du3fXI488oj/+8Y+y2+269NJL663eBvUyXFpaqgkTJigtLU09e/as9e3vv/9+30RwUlkPsy5duphZIgAA1bLZbFX2GnO5XPQoAwAAQP0yjLDefXZ2tu//69atq/SYli1b6oUXXqh03z333KN77rnHd33ixImVtm22BhWYjRs3Tps3b9aaNWsq7CufGK46sbGxio2NDUFlAAAAAAAAaCoaTGA2fvx4LV68WKtWrVLnzp3DXQ4AAAAAAACaqLAHZoZh6NZbb9WCBQu0YsUKdevWLdwlAQAAAHVW2Wq5mZmZAZf+WDEXAICGJ+yB2bhx4zR37lwtWrRI8fHx2rVrlyQpISEh5EuEAgAAc1UWFBQWFio7O1uJiYkV3tsJCtAYVbdabvlqYP5YMRcAgIYn7IHZiy++KEkaPHhwwPaZM2cGNW8ZAABoOKoLCipDUIDGqLLVcmsKjgEAQMMS9sDMCPNqDQAAwDyVBQWZmZlKT09XRkaGXC5XheOBxqaq1XLT0tLCUA0AAKiLsAdmAACg8agqKJAkl8tFbzIAAABEhGbhLgAAAAAAAAChYbFYQvIvWJMnT5bX661yf35+viZMmKDu3burV69e6tOnj9LT07V9+3ZJ0qxZs5SQkKDk5GSdcsopOu+885STk3PMj0tN6GEGAAAAAABwjHJypNzcqveXL5RcyYLJFdjtksNhTl3hNmXKFE2YMEFWq7XCPsMwNHz4cLlcLn333XeKi4tTaWmp5s2bp23btqlbt26SpD/96U9auHChJOn222/XHXfcoffeey+kdROYAQAAAEDIFUjySHJKYnVgoLHJyZGSkqRqOlL5VLJgcgVWq5SVFfmh2U033SRJGjBggKKiovTxxx+rffv2vv2ffvqpsrOz9emnn6p58+aSpGbNmmn06NFVtjls2DDdc889oS1cDMkEAAAAgDqz28s+2NbMIyn198vqWa1l7QKIHLm5wYRlTknu3y+r5/VW31stUrz00kuSpNWrV2vjxo0BYZkkrV+/Xn379vWFZTUpKSnRu+++W6tV2euKHmYAAAAAUEcOR1kvkJo+2GZmlvUqyciQjlowuILGNBQLgD+bJBZAqs7q1at16623Kj8/X5dffrkeeughSdLy5cuVnJwsSUpJSdH06dNDXguBGQAAAAAcA4cj+IDL5ZJYMBgAyvTt21cvvPCCjhw5oubNm2vAgAHauHGjJk+erP379/uO85/DrL4wJBMAAAAAAAAhER8frwMHDlS6b8iQIerSpYtuv/12FRYW+rYfOnSovsqrEoEZAAAAAAAAQuKuu+7SOeeco+TkZP32228B+ywWi5YsWaLo6Gj17NlTvXv3Vlpamnbt2qUbb7wxTBWXYUgmAAAAAABAI2UYRljv/8EHH9SDDz5Y5f5WrVrpueee03PPPVfp/jFjxmjMmDEhqq5qBGYAAByDnJzgJnr2v6wKkzwDAAAADQOBGQAAdZSTIyUlBbOEeJn09Or3W61lK61FUmiWk5Oj3BoSw8zfk8LMmhJDSXa7XY5IegAAAADQKBGYAQBQR7m5wYZlTknu3y+r5vWWtRkpeVFOTo6SkpLkDTIxTK8pMZRktVqVlZVFaAYAAICwYtJ/AABCziYp5ffLxiM3NzfosCxYXq+3xh5rAAAAqF645y1rCI71MaCHGQAAAAAAQCPQvHlzWSwW7d69W+3atZPFYgl3SWFhGIZ2794ti8Wi5s2b16kNAjMAAAAAAIBGICoqSp07d9ZPP/2k7OzscJcTVhaLRZ07d1ZUVFSdbk9gBgAAAAAmKigokMfjCdhW3QIoTqdTNlvjGrYPIHxatmypk046SUeOHAl3KWHVvHnzOodlEoEZAACoI0uxV307mD8dqqXY3HnRAKC+eTwepaamVrqvsgVQ3G63UlJSQl0WgCYkKirqmMIiEJgBAIA6subnaP3Ylqa3m5mfI6m/6e0CQH1xOp1yu90B2woLC5Wdna3ExETFxcVVOB4A0LAQmAEAgDrxtnQoZUa+6e2+NtxhepsAUJ9sNlulPcbS0tLCUA0AoC4IzAAAQJ0Y0VZt2FUaknYBAACAcDJ/4hEAAAAAAAAgghGYAQAAAAAAAH4IzAAAAAAAAAA/BGYAAAAAAACAHwIzAAAAAAAAwA+BGQAAQMgVSFr/+yUAAAAaOgIzAACAOrLbJas1mCM9klJ/v6ya1VrWJgAAAMIrOtwFAAAQqSzFBerbYYvJbfaQZDO1TYSOwyFlZUm5udUfl5kppadLGRmSy1X1cXZ7WZsAAAAILwIzAADqyJq/RevHDjK1zcz8lZKSTW0ToeVwBB9yuVxSSkpo6wEAAMCxIzADAKCOvC17KGXGSlPbfG14D1PbAwAAAFB7BGYAANSREW3Thl3JJrdpanMAAAAA6oBJ/wEAAAAAAAA/BGYAAAAAAACAHwIzAAAAAAAAwA+BGQAAAAAAAOCHwAwAAAAAAADwQ2AGAAAAAAAA+GHxegAAAAAAgGNgKS5Q3w5bTG6zhySbqW0ieARmAAAAAAAAx8Cav0Xrxw4ytc3M/JWSkk1tE8EjMAMAAAAAADgG3pY9lDJjpaltvja8h6ntoXYIzAAAAExUUFAgj8cTsC0zMzPg0p/T6ZTNxnALAAAimRFt04ZdySa3aWpzqCUefgAAABN5PB6lpqZWui89Pb3CNrfbrZSUlFCXBQAAgFogMAMAADCR0+mU2+0O2FZYWKjs7GwlJiYqLi6uwvEAAABoWAjMAAAATGSz2SrtMZaWlhaGagAAAFAXzcJdAAAAAAAAANCQEJgBAAAAAAAAfgjMAAAAAAAAAD8EZgAAAAAAAIAfAjMAAAAAAADAD4EZAAAAAAAA4IfADAAAAAAAAPBDYAYAAAAAAAD4ITADAAAAAAAA/DTowGz//v069dRTlZycrJ49e+qVV14Jd0kAAAAAAABo5KLDXUB14uPjtWrVKtlsNh06dEg9e/bURRddpOOOOy7cpQEAAAAAAKCRatA9zKKiomSz2SRJRUVFMgxDhmGEuSoAAAAAAAA0ZmEPzKZOnarTTjtN8fHxat++vUaOHKmsrCzf/v3796tPnz7q3LmzJk6cKLvdHsZqAQAAAAAA0NiFPTBbuXKlxo0bpy+++ELLli3TkSNHNHToUB06dEiS1Lp1a23atEnbt2/X3Llz9euvv4a5YgAAAAAAADRmYZ/DbOnSpQHXZ82apfbt28vtdmvgwIG+7ccff7z69Omj1atX65JLLqm0raKiIhUVFfmu5+XlhaZoAAAAAAAANFph72F2tAMHDkiS2rZtq19//VUHDx70bV+1apWSkpKqvO3UqVOVkJDg+9elS5d6qRkAAAAAAACNR4MKzEpLSzVhwgSlpaWpZ8+e+u9//6sBAwaoT58+GjBggG699Vb16tWrytvff//9OnDggO/fjh076rF6AAAAAAAANAZhH5Lpb9y4cdq8ebPWrFkjSfrjH/+ojRs3Bn372NhYxcbGhqg6AAAAAAAANAUNJjAbP368Fi9erFWrVqlz587hLgcAAAAAAABNVNgDM8MwdOutt2rBggVasWKFunXrFu6SAAAAAAAA0ISFPTAbN26c5s6dq0WLFik+Pl67du2SJCUkJCguLi7M1QEAAAAAAKCpCfuk/y+++KIOHDigwYMHq2PHjr5/b7/9drhLAwAAAAAAQBMU9h5mhmGEuwQAAAAAAADAJ+w9zAAAAAAAAICGhMAMAAAAAAAA8ENgBgAAAAAAAPghMAMAAAAAAAD8EJgBAAAAAAAAfgjMAAAAAAAAAD8EZgAAAAAAAIAfAjMAAAAAAADAD4EZAAAAAAAA4IfADAAAAAAAAPBDYAYAAAAAAAD4ITADAAAAAAAA/BCYAQAAAAAAAH4IzAAAAAAAAAA/BGYAAAAAAACAHwIzAAAAAAAAwA+BGQAAAAAAAOCHwAwAAAAAAADwQ2AGAAAAAAAA+IkOdwEA0JgUFBTI4/H4rhcWFio7O1uJiYmKi4sLONbpdMpms9V3iQAAAACAGhCYAYCJPB6PUlNTgzrW7XYrJSUlxBUBAAAAAGqLwAwATOR0OuV2u33XMzMzlZ6eroyMDLlcrgrHAgAAAAAaHgIzADCRzWartNeYy+WiNxkAAAAARAgm/QcAAAAAAAD8EJgBAAAAAAAAfgjMAAAAAAAAAD8EZgAAAAAAAICfWgdmpaWlVW7Pyck55oIAAAAAAACAcAo6MMvLy9Po0aPVokULHX/88Zo0aZJKSkp8+3fv3q1u3bqFpEgAAAAAAACgvkQHe+ADDzygTZs2ac6cOdq/f78eeeQRrV+/XvPnz1dMTIwkyTCMkBUKAAAAAAAA1Iege5gtXLhQM2bM0CWXXKLrr79e33zzjXbv3q0RI0aoqKhIkmSxWEJWKAAAAAAAAFAfgg7Mdu/era5du/qu2+12ffLJJzp48KCGDx+ugoKCkBQIAAAAAAAA1KegAzOHw6HMzMyAbfHx8fr4449VWFioCy+80PTiAAAAAAAAgPoWdGA2dOhQzZw5s8L2li1b6qOPPpLVajW1MAAAAAAAACAcgp70f8qUKfrll18q3RcfH69ly5Zp/fr1phUGAAAAAAAAhEPQgVmbNm3Upk2bKvfHx8dr0KBBphQFAAAAAAAAhEvQQzIlKTMzUzNnzpTH45EkeTwe3Xzzzbr22mv12WefhaRAAAAAAAAAoD4F3cNs6dKluuCCC9SyZUsVFBRowYIFuuqqq9SnTx+VlpZq6NCh+vjjj3XWWWeFsl4AAAAAAAAgpILuYfbQQw9p4sSJ2rNnj2bOnKnLL79cN9xwg5YtW6ZPP/1UEydO1OOPPx7KWgEAAAAAAICQCzow+/777zVmzBhJ0ujRo3Xw4EFdcsklvv1XXHGFvv32W9MLBAAAAAAAAOpTreYws1gsZTdq1kxWq1UJCQm+ffHx8Tpw4IC51QEAAAAAAAD1LOjALDExUVu3bvVdX7dunRwOh+96Tk6OOnbsaG51AAAAAAAAQD0LetL/m2++WSUlJb7rPXv2DNi/ZMkSJvwHAAAAAABAxAs6MLvpppuq3f/YY48dczEAAAAAAABAuNVqDjN/RUVFKioqMrMWAAAAAAAAIOyC7mEmScuWLdPTTz+tdevWKS8vT5LUqlUrnXHGGbrzzjs1ZMiQkBQJAA1VTo6Um1v1/szMwMvq2O2S39SQaFQKJHkkOSXZwlwLAAAAgJoEHZjNnj1b119/vS655BI9/fTTOv744yVJv/76qz7++GMNHz5cr732mq688sqQFQsADUlOjpSUJHm9NR+bnl7zMVarlJVFaBZJ7Pay31vNzwGPpFRJbkkpVR5ltZa1CQAAACC8gg7MHn30UT3zzDMaN25chX1jxozRmWeeqYceeojADECTkZsbTFDiVFlI4qyxPa+3rE0Cs8jhcJSFnNX1MpTKehimp0sZGZLLVfVx9DIEAAAAGoagA7OcnJxqh1yeffbZuuuuu0wpCgAaD5uq61GEyOdwBB9yuVxSCk8HAAAAoMELetL/U045Ra+99lqV+19//XWdfPLJphQFAAAAAAAAhEvQPcymT5+u888/X0uXLtWQIUMC5jD79NNP9Z///EcffPBByAoFAAAAAAAA6kPQgdngwYO1efNmvfjii/riiy+0a9cuSVKHDh103nnn6aabblJiYmKo6gQAAAAAAADqRdCBmSQlJiZq2rRpoaoFAAAAAAAACLug5zADAAAAAAAAmoJa9TCrztVXX60dO3bos88+M6tJ7dixQ1deeaV+++03RUdH64EHHtCoUaNMax8AgEhQUFAgj8cTsK2wsFDZ2dlKTExUXFxcwD6n0ymbzVafJQIAAACNimmB2QknnKBmzcztsBYdHa1nnnlGycnJ2rVrl1JTUzV8+HC1aNHC1PsBAKAh83g8Sk1NDfp4t9utlJSUEFYEAACA2iuQ5JHklMSXmw2daYHZY489ZlZTPh07dlTHjh0llS0uYLfbtXfvXgIzAECT4nQ65Xa7A7ZlZmYqPT1dGRkZcrlcFY4HAABA/bHbJatV8nqrO8ojKVWSW1L1X25arWVtInxMC8zqaurUqZo/f748Ho/i4uLUv39/TZs2TUlJSQHHud1ulZSUqEuXLmGqFACA8LDZbFX2GHO5XPQmAwAACDOHQ8rKknJzqz4mM1NKT5cyMqSjvu+swG4vaxPhU6vA7IcfftALL7ygdevWadeuXZLKen6dccYZGj9+vE4++eRaF7By5UqNGzdOp512moqLi/W3v/1NQ4cO1Q8//ODrSbZ3715dddVVeuWVV2rdPgAAAAAAQKg5HMGFXC6XxPedDV/QgdmSJUs0cuRIpaSk6IILLtDxxx8vSfr111+1bNkypaSkaNGiRRo2bFitCli6dGnA9VmzZql9+/Zyu90aOHCgioqKNHLkSN13333q379/tW0VFRWpqKjIdz0vL69WtQAAAAAAAABBB2b33Xef7r33Xj300EMV9k2ePFmTJ0/WxIkTax2YHe3AgQOSpLZt28owDI0ZM0ZnnXWWrrzyyhpvO3XqVE2ZMuWY7h8AAAAAAABNW9CB2ZYtW3TFFVdUuf+yyy7TtGnTjqmY0tJSTZgwQWlpaerZs6fWrFmjt99+W71799bChQslSXPmzFGvXr0qvf3999+vO++803c9Ly+POc8AhIyluEB9O2wxuc0eYsWcyFZQUCCPxxOwLTMzM+CynNPplM3G7xsAAABoaIIOzBITE/XBBx9UmIy/3AcffKCuXbseUzHjxo3T5s2btWbNGknSmWeeqdLS0qBvHxsbq9jY2GOqAQCCZc3fovVjB5naZmb+SknJpraJ+uXxeJSamlrpvvT09IDrbrebCfsBAACABijowOyhhx7S5ZdfrhUrVmjIkCEBc5h9+umnWrp0qebOnVvnQsaPH6/Fixdr1apV6ty5c53bAYD64m3ZQykzVpra5mvDe5jaHuqf0+mU2+0O2FZYWKjs7GwlJiYqLi4u4FgAAAAADU/QgdmoUaN0wgkn6LnnntP06dMrrJK5YsUKnXHGGbUuwDAM3XrrrVqwYIFWrFihbt261boNAAgHI9qmDbuSTW7T1OYQBjabrdJeY2lpaWGoBgAAAEBd1OqjWf/+/WtcqbK2xo0bp7lz52rRokWKj4/3BXEJCQkB38IDAAAAAAAA9aFZuAt48cUXdeDAAQ0ePFgdO3b0/Xv77bfDXRoAAAAAAACaoLAP/jEMI9wlAAAAAAAAAD5h72EGAAAAAAAANCQEZgAAAAAAAICfoAOzq666Su+9957y8/NDWQ8AAAAAAAAQVkEHZt27d9djjz2mdu3a6bzzztOLL76on3/+OZS1AUAjUCBp/e+XAAAAAIBIEHRgNmnSJLndbm3dulUjRozQwoULdeKJJyo1NVUPPfSQNm7cGMIyAaDhsdslq7WmozySUn+/rJ7VWtYmAAAAACC8ar1KZufOnXXLLbfolltu0cGDB7VkyRItWrRIZ511luLj4zVixAjdfPPNOuWUU0JRLwA0GA6HlJUl5eZWfUxmppSeLmVkSC5X9e3Z7WVtAgAAAADCq9aBmb/4+HiNHj1ao0ePVklJiVasWKH3339f69atIzAD0CQ4HMGFXC6XlJIS+noAAAAANF4FBQXyeAJHrxQWFio7O1uJiYmKi4sL2Od0OmWz2eqzxEYj6MDst99+U/v27as9Jj4+Xs8+++wxFwUAAAAAAIBAHo9HqampQR/vdruVwjf3dRJ0YNaxY0ft3LnTF5r16tVLH374obp06SJJys3N1RlnnKGSkpLQVAoAAAAAANCEOZ1Oud3ugG2ZmZlKT09XRkaGXEfNA+N0OuuzvEYl6MDMMIyA69nZ2Tpy5Ei1xwAAAAAAAMAcNputyh5jLpeL3mQmCnqVzGBYLBYzmwMAAAAAAADqnamBGQAAAAAAABDpgh6SabFYdPDgQVmtVhmGIYvFovz8fOXl5UmS7xIAAAAAAACIZLWaw6xHjx4B1/v27RtwnSGZAAAAAAAAiHRBB2bLly8PZR0AAAAAgEaioKBAHo8nYFthYaGys7OVmJiouLi4gH1Op1M2m60+SwSAagUdmA0aNCiUdQAAAAAAGgmPx6PU1NSgj3e73azuB6BBCTowKy4uVklJiWJjY33bfv31V7300ks6dOiQ/vKXv+jMM88MSZEAAAAAgMjhdDrldrsDtmVmZio9PV0ZGRlyuVwVjgeAhiTowOyGG25QTEyMZsyYIUk6ePCgTjvtNHm9XnXs2FFPP/20Fi1apOHDh4esWAAAAABAw2ez2arsMeZyuehNBqDBaxbsgZ9//rkuvvhi3/U33nhDJSUl2rp1qzZt2qQ777xTTzzxREiKBAAAAAAAAOpL0IHZzz//rJNOOsl3/dNPP9XFF1+shIQESdLVV1+t77//3vwKAQAAAAAAgHoUdGBmtVpVWFjou/7FF1+oX79+Afvz8/PNrQ4AAAAAAACoZ0EHZsnJyZozZ44kafXq1fr111911lln+fZv27ZNnTp1Mr9CAAAAAAAAoB4FPen/pEmTdN555+mdd97Rzp07NWbMGHXs2NG3f8GCBUpLSwtJkQAAAAAAAEB9CTowGzRokNxutz7++GN16NBBo0aNCtifnJysP/7xj6YXCABAU5NzIEe5BbnVHpO5O/N/lzurb89us8uR4DCrPAAAAKDRCzowk8qW/3W5XJXuu/HGG00pCACApiznQI6SXkiSt9hb/YG/lF2kz0+Xvqj+UGu0VVnjswjNAAAhk5OTo9zcGr7sycwMuKyK3W6Xw8F7FoDwCjowW7VqVVDHDRw4sM7FAADQ1OUW5NYclkmSXdKNv1/WwFvsVW5BLoEZACAkcnJylJSUJK83iPcvSenp6dXut1qtysrKIjQDEFZBB2aDBw+WxWKRJBmGUekxFotFJSUl5lQGAACqFiOJtXYAAA1Abm5u0GFZMLxer3JzcwnMAIRV0IFZmzZtFB8frzFjxujKK6+U3R7EV9oAAAAAAABAhGkW7IE7d+7UtGnTtG7dOvXq1UvXXXed1q5dq1atWikhIcH3DwAAAAAAAIhkQQdmMTEx+utf/6qPPvpIHo9HvXv31vjx49WlSxf9/e9/V3FxcSjrBAAAAAAAAOpF0IGZP4fDoUmTJumTTz5Rjx499PjjjysvL8/s2gAAAAAAAIB6V+vArKioSHPnztWQIUPUs2dP2e12ffDBB2rbtm0o6gMAAAAAAADqVdCT/n/11VeaOXOm3nrrLSUmJuqaa67RO++8Q1AGAAAAAACARiXowOz000+Xw+HQbbfdptTUVEnSmjVrKhz3l7/8xbzqAAAAAAAAgHoWdGAmSTk5OXr44Yer3G+xWFRSUnLMRQEAAAAAADR1OQdylFuQW+0xmbsz/3e5s/r27Da7HAkOs8pr1IIOzEpLS0NZBwAAAAAAAH6XcyBHSS8kyVvsrf7AX8ou0uenS19Uf6g12qqs8VmEZkGo0yqZVSksLDSzOQAAAAAAgCYptyC35rBMkuySbvz9sgbeYm+NPdZQxpTArKioSNOnT1e3bt3MaA4AAAAAAADBiJHU6fdLmCbowKyoqEj333+/Tj31VPXv318LFy6UJM2cOVPdunXTM888ozvuuCNUdQIAAAAAAAD1Iug5zCZNmqQZM2ZoyJAhWrt2rUaNGqVrrrlGX3zxhZ566imNGjVKUVFRoawVAAAAAAAACLmgA7N3331Xb7zxhv7yl79o8+bN6t27t4qLi7Vp0yZZLJZQ1ggAAAAAAADUm6CHZP70009KTU2VJPXs2VOxsbG64447CMsAAAAAAADQqAQdmJWUlCgm5n8zyEVHR6tly5YhKQoAAAAAAAAIl6CHZBqGoTFjxig2NlaS5PV6ddNNN6lFixYBx82fP9/cCgEAAAAAACJMQUGBPB6P73pmZmbApT+n0ymbzVZvtaFmQQdmV199dcD19PR004sBgEjHmyKOleWIV32NoDuA16pdAAAA1B+Px+Ob2spfZXmK2+1WSkpKfZSFIAUdmM2cOTOUdQBAo8CbIo6VdX+O1sv8KQ8y9+dIjv6mtwsAAIDKOZ1Oud1u3/XCwkJlZ2crMTFRcXFxFY5FwxJ0YAYAqBlvijhW3tYOpSjf9HZfa+0wvU0AAABUzWazVfiCPC0tLUzVoLYIzADARLwp4lgZza3aYCkNSbsAAAAAgkNgBpjk6LmrpJp7FzF/FQAAAAAADQ+BGXAMcnKk3Nyy/2dmepSeXnHuqqpkZLjlcv2vJ5LdLjkYMQUAAAAAQNgRmAF1lJMjJSVJXt/Cc05J7qOOypSULilDkitgT3p64PxVVquUlUVoBgAAAABAuBGYAXWUm+sflkmSTdLRKx6Wh2jO3/dXzesta5PADAAAAACA8CIwA0KqshANAAAAAAA0ZM3CXQAAAIhMdrtdVqu5q29arVbZ7XZT2wQAAABqq8H3MLvwwgu1YsUKnX322Zo3b164ywEAAL9zOBzKyspSbvnqJ1XIzMxUenq6MjIy5HK5qj3WbrfLwdh0AAAAhFmDD8xuv/12XXvttZo9e3a4SwEAAEdxOBxBB1wul0spKQxTBwAAQMPX4IdkDh48WPHx8eEuAwAAAAAAAE1E2AOzqVOn6rTTTlN8fLzat2+vkSNHKisrK9xlAQAAAAAAoIkK+5DMlStXaty4cTrttNNUXFysv/3tbxo6dKh++OEHtWjRItzlAQAAAA1CQUGBPB6P73phYaGys7OVmJiouLi4gGOdTqdsNlt9lwgAQKMR9sBs6dKlAddnzZql9u3by+12a+DAgbVqq6ioSEVFRb7reXl5ptQIAAAAhJvH41FqampQx7rdbuYMbISODk2lqoNTQlMAODZhD8yOduDAAUlS27Zta33bqVOnasqUKWaXBAAAAISd0+mU2+32Xa9uBVqn01nf5aEeEJoCQP1pUIFZaWmpJkyYoLS0NPXs2VOSNGTIEG3atEmHDh1S586d9e677+qMM86o9Pb333+/7rzzTt/1vLw8denSpV5qBwAAAELJZrNVGoCwAm3TcXRoKlUdnBKaAsCxaVCB2bhx47R582atWbPGt+2TTz4J+vaxsbGKjY0NRWlABZbiAvXtsMXkNntIous8AAAApJwDOcotyA3c2PGog3b/fmkP3Oc54JEO/O+63WaXI8ERgioBoHFqMIHZ+PHjtXjxYq1atUqdO3cOdzlAjaz5W7R+7CBT28zMXykp2dQ2AQAAEHlyDuQo6YUkeYu91R/4S9lF+vx06YuqD7NGW5U1PovQDACCFPbAzDAM3XrrrVqwYIFWrFihbt26hbskICjelj2UMmOlqW2+NryHqe0BAAAgMuUW5NYclkllPctu/P2yGt5ir3ILcgnMgAhiOeJVX6NZSNqtD7VZqERqeIuVhD0wGzdunObOnatFixYpPj5eu3btkiQlJCRUePCAhsSItmnDrmST2zS1OQCod5WdGGVmZgZc+mtoJ0YAEHFiJHUKdxEAQsG6P0fr1dL0djP350iO/qa3e7TaLFQiNbzFSsL+8fzFF1+UJA0ePDhg+8yZMzVmzJj6LwgAANRZdSdG6enpFbY1tBMjAACAhsLb2qEU5Zve7mutQ9PTNCcnR7m5/5t3sbCwUBkZGQHHbN++XQ888IAefvjhCiMMCwsLtX79et91u90uhyN8vWLDHpgZhhHuEgAAgEkqW8Gtpq73AAAAqMhobtUGS2lI2jVbTk6OkpKS5PUGN9zzgQceqPEYq9WqrKyssIVmYQ/MAABA42Gz2SrtMZaWlhaGagCES23mrWFoNhqjSJ+7Cait3NzcoMOyYHm9XuXm5hKYAQAAAGgcajNvDUOz0RhF+txNAAjMAAAAAByjY5m3pqHNWYPasxR71beDuSv5WYJZIbQBq2yKgszMTKWnpysjI0Mul6vC8QAaFgIzAGjg6NIPAGjIzJ63Jtxz1qD2rPk5Wj/W3JX8MvNzJIV+Fb9QqWqKAklyuVz0JgMiAIEZADRwdOkHADRkZs9bE+45a1B73pYOpcwwdyW/14bz+wcQXgRmANDA0aUfAAA0ZEa0VRt2mbuSnxFt/ip+QKN1WFKuJLukmDDX0ogQmAFAA0eXflSKEyMAAIBGzW6zyxptlbemOf1yJb0s6UZJnao/1Bptld1mN6nCxo3ADACABoQTIwAAAEiSI8GhrPFZyi3Irfa4zG8zlf5yujIuypCrt6vaY+02uxwJDHkOBoEZEFIFkjySnJKYhB1AzTgxQmVCtfgHi4oAgHlycqTcat6+MzMDL6tjt0tM4wep7NywxvO4nWUXrnYupXQMz+iTUKyWW95uuBCYAXVkt0tWq1T9HLceSamS3JKqf+GyWsvaBIBIOTFC/QnV4h8sKgIA5sjJkZKSavpsUCY9veZjrFYpK4vQDJEjFKvlSuFdMZfADKgjh6PsTaymb5HS06WMDMlVfQcQvkUCAFQpVIt/hKrdo3uu0WsNaLjoaWqO3NxgwjKnyr5Ir/m11OstazOSPx/w3GpaQrFarhTeFXMJzIBj4HAE9ybmckl8IQ8AqKtQLf4RqnZr03ONXmtAeNHTtD7ZVNOok5pEUgjFc6tpCcVqueXthguBGQAAAEx1dM81M3qtITQi6cM3QiNUPU0RGpEUQvHcQqQjMANMUtkJZ+bvM3pmVjKzJyecAIDGqqqea8fSaw2hEUkfvhEaoeppitCIpBCK5xYiHYEZYJLqTjjTK5nZkxNOVCXnQE7NKyTuzvzf5c7q26tqhcRQzDFETwUAiCyR9OEbACEUUJ8IzACTVHbCWVNQABwt50COkl5Ikrem5ZN/KbtIn58ufVH9odZoq7LGZ1UIzUIxxxA9FQAgsvDhGwCAyhGYASap6oQzLS0tDNUgUuUW5NYclkmSXdKNv1/WwFvsVW5BboXALBRzDNFTAQDMU1OPYzN6G6Phshzxqq/RzPQ2AQDBITADGjiGuKFSMZI6HVsToZhjiJ4KAGCOoHocm9DbGA2XdX+O1qulqW1m7s+RHP1NbRMAGisCM6CBY4gbAABNT1A9jk3obYyGy9vaoRTlm9rma635/UcaM+e2DXVP05ycHOXm1lBrNYuiHc1ut8vh4DmL8CEwAxo4hrgBAIBKmdDbGA2X0dyqDZZS09tE5NhZkKM0E+e2DWVP05ycHCUlJcnrDW7Yb2WLoh3NarUqKyuL0OwolY1Aqi6IZARS3RGYAQ1cKIa4McwTgFS71wJeBwAAqF/7D5s7t20oe5rm5uYGHZYFy+v1Kjc3l8DsKNWNQKosiGQEUt0RmAFNEMM8YRa63keYnBzJ7/flycxUahDf8EqSOyNDKf49Wu12id8VEHmOeh2oVPnrdRCv27LbZSn2qm8HkyenDyYkAFCG3qZNSmUjkGrq/IC6ITADmiCGecIMdL2PMDk5UlKS5Pf7ckpyH3VYpqR0SRmS/F8JnEf//qxWKSuL0AyIIM1/2ikNTAt4HahWMIG61Srr7Ce0fqzJk9Pn50hicnoAOFpVI5DS0tLCUE3jRmAGNEGsZAgz0PU+wuTmVviQbJN09F97eYjm/H1/lbzesjb5XUE19zalp2nDEL13f1Bhmf/rQI28XnmLWihlhsmT0w/nOQAACC8CMwAA4FNZiAZUpza9TelpGhlq+zpgNIvRhl0mT04fzeT0AIDwIjADAABAnZnd25SepgBQJqrEq76GyfMDHmF+QISG3W6X1Wo19ZzAarXKbq9hNYsQIjADAKApKPZKJk/KLSblBoDIE4KFH8z+oBzuD8kNRauCHK2XyfMD7s+RHMwPCPM5HA5lZWUFtSBYVXNnHy3c0zQQmAENTM6BHOUW1PAiszvzf5c7qz7ObrOHZNloABEoP0cyeVJuMSk3AESUUC384MjKMvWDcrg/JNeFpbhAfTtsMbXNQ7HtlSKT5wdsHVmPKyKLw+EI+m83EubOJjAzSUFBgTweT8C2mpZ2tdmqnU45ZCKp1qYm50COkl5IkremXhu/lF2kz0+Xvqj6MGu0VVnjswjNIojliPld78vbRRPX0iGZPCm3mJQbACJKqBZ+UG6uHCkpjeqDcm1Z87do/dhBprb5YdEMbbCYPD9gc+YHBIJFYGYSj8ej1NTUoI93u91he5OIpFqbmtyC3JrDMkmyS7rx98tqeIu9yi3IJTCLINb95ne9l37vfq/O1Q/BqOXwC0uxV33NHuInycIwv9CItkomT8otJuWOPCEYigWg8WEBmNrztuyhlBkrTW3znjcKTG0PQO0QmJnE6XTK7XYHbKuuy7HTGdT3NSERSbWiCjGSOoW7CISCt7XD9K73kvRGQYzULym4IRhBDr+wzn5C680e4icpk2F+QGjk5EhJQb4OSEG/FmjevGOrCwAaASPapg27kk1tsyRqvantAfWtstFtmb9/IZdZyRdzDW10G4GZSWw2W5W9sBpal+NQ1cpQT+DYGc2tpne9l6SoA4U1fkiu7fALb1ELpZg9xE/SawzzA0IjNzc0Q7H27z+2ugAAQKNU3ei29Eq+mGtoo9sIzGAahnoCka22wy+MZjHaYPYQP0kGw/wASTUvAhPsAjDS74vABHm/DMUCAABmqGx0W02dahoSAjOYhqGeAACYI6hFYIJcAEYqWwTmP2fOU0fzSgQA1FqBJI/K+vAy0gaNX1Wj29LS0sJQTe0RmME0kTQsFQCAhiyoRWCCXABGKlsEZr93P4EZAISI3V42rWP1I989klJVNvC9+s9GVqvUurVp5YUci0GhMSIwA5qKmlZGq+2qaJUsG848dgBQj1gABgAaDIdDysqq+XQ7PV3KyJCOGnxTgd0u5TY3t8ZQsubnsBgUGh0CM6ApqM3KaMGuipaVpRxJuX5nBeVDcIN19FBdu90uRyVBHAAAANDQORyVfqdcgcslBTP4JreG+SkbEm9LB4tBodEhMGtgjp7gt7CgUNk/Zgd128TuiYqz/a8Hj91mlyOBFxgoqJXRarsqWs533ynpkkvkDSaEq8LR4ZrValVWVhahGQAAABBBjGgri0Gh0SEwa0AqneD3F0kvB9nAjQoYmmGNtiprfBahGYJS21XRcvfvP6awrDJer1e5ubkEZgCAJs9yxKu+hrnzAVlKDpvaHgAAjRmBWQNS6QS/5RP6BuOoSX+9xV7lFuQSmAEAAEQY6/4crZe58wFtL9xlanvl7K1by2q1mvZFmtVqld0exGoWqDVLyWEpBBOzi4nZATRCBGYNHRP6Nikh+Tb5iFcSXZkBAIgk3tYOpcjc+YDmxnUwtb1yjo4dlZWVFTCvaWXK5zo9eg7TozGnaejEFu6SQjAxu5iYPbwOS8pVWQeKmDDXAjQiBGZAAxKKb5Mz9+dI6mFqm2gAGsCJkdk9CiR6FQCRyFJ6WH1N7rFiobeKjOZWbbCYOx+QERW6NwyHwxF0yOVyuZQSzIznCE4tzgmK4jpIIZiYXUzMHhJ2m13WaGvFUUhHy1XZND5HTdFzNGu0VXYb51lAsAjMGpDQ9S5CpAjFt8mvtXaUvYkiIph9YiSVnRy1trY2p0A/ZvcokOhVAJSLpPmrrId3ab3JPVYy6a0ChCQsSWjRXgrBxOxiYvaQcCQ4lDU+K2BRuMpkfpup9JfTlXFRhly9q+m9yaJwQK0QmDUgIetd5OCEM1KE5Nvk5pzARBKzT4ykspOjjlk/mT9nSbGXHgVAiETS/FXemA5KMbnHymv0VgFCEpZ03Ma3qJHGkeCoOeTaWXbhaudSSkfOtQCzEJjVUU6OVEOnCmVmBl5Wx24PYe+iUBTrcCgnJyeoniX+l1U3Sa+SSBOKITgSw3CkEJ0Y5a81f84SeoAAIRNJ81cZzWK0weQeKwa9VUKCCd8jj/nnBARmABAsArM6yMmRkpKkYKftSU+v+RirVZr3ufm9i6J/3ScNPNv0YnM++0xJZ50V9NxF6TW0a7ValZWVRWgWrAYwf1UohuBIDMMJmZYO8+csoQcIEDKRNn8VIgMTvgMAEDwCszrIzQ02f3JKcv9+WT2vV9q//9jqqkz03v1BFRt8pZK8XuX+5z+mTvTt9XqVm5vb5AOz0E3saf63iaEYgiMxDCdkoq3mz1lCDxAgooSqd5GlNDRzo8F8TPgOAEDwCMxCyiYpMsaQR06ljVvoJvY0PzALxRAciWE4ABAqoepdZD0cmrnRYD4jKoYJ3wEACBKBWR1YigvUt8MW09uNKjF//ge+TY48TOwJAAiFUPUu8v5faOZGAxDZCgoK5PF4ArZVN7+x0+mUzWarl9pgPrvdLqvVauooJKvVKrvdblp7QG0RmNWBNX+L1o8dZHq7HxbMML1Nvk0GEKwCSR6VDc3mdBVofELVu8hoxtxoACryeDxKTU2tdF9l8xu73W5W045gDodDWVlZQS0Kl56eroyMDLlcNaz0zsJwCDMCszrwtuyhlBkrTW/3njcKTG8zVN8mFz3e1vQVElkdEQghu71sdZFqvvXzSEpV2XyGNZ6uWq1lbQIAAFTC6XTK7XYHbCssLFR2drYSExMVFxdX4XhENofDEXTA5XK5CEjR4BGY1YERbdOGXcmmt1sStT64A2uxQmKovk2OLd5r+gqJrI4YQsVe04fmMiw3wjgcUlZW2aolVcnMLFspNyNDquEbP9ntZW0CAABUwmazVRqIpKWlhaEaAKg9ArMGpHWM+Ssktra2Nq9AP6FYIZHVEUMoP8f0obkdYg8xT0GkcTiCC7lcLolv/AAAAAA0YQRmDUhHm/krJHbcZv7qiFJoVkhkdcQQaukwfWhux0UpzFMAAAAAAGiUGnxgtnjxYt11110qLS3Vvffeq+uvvz7cJYWU+SskhiYwQ4SJtpo/NDfayjwFqIAVsSIfiz8AAAAADTwwKy4u1p133qnly5crISFBqampuvDCC3XccceFuzSg0eFDMszAilgNWBALP0i1WPyBhR/wO3vr1qYO0Wd4PgAAaAgadGD21Vdf6ZRTTtEJJ5wgSTrvvPP08ccf67LLLgtzZcGKnAgiciptekzpscMKiagnrIjVgAWz8IMU/OIPLPyA3zk6dqxxiD7D8wEAQKQJe2A2depUzZ8/Xx6PR3Fxcerfv7+mTZumpKQk/fLLL76wTJJOOOEE/fzzz2GstkyQX9KrNhFEyPIHs3sUSGXttW5tSnmomSk9dlghEfWEFbEauGAXfpBY/AG1EuwQfYbnAwCASBH2wGzlypUaN26cTjvtNBUXF+tvf/ubhg4dqh9++CHcpVXJ7C/ppRDmD6Eqtqb2YBrTeuywQiIAAACCwOgTAGgAgdnSpUsDrs+aNUvt27eX2+1Wp06dAnqU/fzzz/rjH/9YZVtFRUUqKiryXc/LyzO/4N9F1Jf0ISjWLjFfST2hxw4AAKjUYZWt72SXFBPmWhAZQjX6hPN4AI1Q2AOzox04cECS1LZtWzmdTm3evFk///yzEhIStGTJEj3wwANV3nbq1KmaMmVKfZXapDkcjhrnK5GCn7OE+UoAAAD+x26zyxptlbe4mmAjV9LLkm6U1Kn69qzRVrW2tjavQESmiBoqAwDh1aACs9LSUk2YMEFpaWnq2bOnJGn69On605/+pNLSUt1zzz3VrpB5//3368477/Rdz8vLU5cuXUJed1MV7HwlEnOWAAAA1IYjwaGs8VnKLahmMYVvM5X+croyLsqQq3cNiynY7Oq4jSk1oAgbKgMA4dOgArNx48Zp8+bNWrNmjW/bX/7yF/3lL38J6vaxsbGKjY0NVXkAAABAvXEkOORIqCbY2Fl24WrnUkrHYEKN4AIz5q8CAKABBWbjx4/X4sWLtWrVKnXu3Dnc5TQYBQUF8ng8AdsyMzMDLss5nU7ZbJzWAAAAoBLMXwUAQNDCHpgZhqFbb71VCxYs0IoVK9StW7dwl9SgeDwepaamVrovPT094Lrb7Q7rsMfahHsSAR8AAEC9Yv4qAACCFvbAbNy4cZo7d64WLVqk+Ph47dq1S5KUkJCguLi4MFcXfk6nU263O2BbYWGhsrOzlZiYGPAYOZ3O+i4vQG3CPSn8AR8ARAq+kABgGuavAgAgKGEPzF588UVJ0uDBgwO2z5w5U2PGjKn/guooVB9mbDZbpaFSWlpaHSsNXa21CffKjwcA1IwvJFCpwyqbksouKSbMtQAAADQyYQ/MDMMIdwmmiKQPM6GqNRThHgCALySaIrvNLmu0Vd7iauaaypX0sqQbJXWqvj1rtFWtra3NKxAAUC16hwORL+yBWWMRSR9mIqlWAABfSDRFjgSHssZnKbeg6rmmMr/NVPrL6cq4KEOu3tXPM2W32dVxW3ArJAIAjl0kdagIFUJDRDoCM5NE0oeZSKoVQOhONo5ulxMYoGFxJDjkSKhmrqmdZReudi6ldAzmQ1ZwgVmBylZJdErirx4A6oZOCoSGiHwEZgDQwIXqZKOqdjmBARopu12yWiVvNcM8VRaWpUpyS6rxr95qLWsXABCATgqEhoh8BGZAE0T36MgSqpONo9vlBAZo5BwOKStLyq2hp1lmppSeLmVklK2SWB27vdIVF+nBGho8rgAiCaEhIh2BGdAE0T06soTqZKOydjmBARo5h6PSgKtSLpdUx9d+erCGRigeV75EAwCgcgRmQBNE92gAQCjRgzU0QvG48iUaAACVIzADmiC6RwMAQokerKERiseVL9EAAKgcgRkAAADQRPElGhBZGEYN1B8CMwCm4Q0cAEKD11cAgMQwaqA+EZgBMA1v4AAQGry+ApBqF54TnDdODKMG6g+BGQDT8AYOAKHB6ysAqXbhOcF548QwaqD+EJgBMA1v4AAQGry+ItLQEyo0ahOeE5wDwLEhMAMAAABgKnpChQbhOQDUHwIzAAAAAKaiJxQAINIRmAEAAAAwFT2hAACRjsAMAACgiarNPFMSc00BAICmg8AMAACgiarNPFMSc00BAICmg8AMAACgiarNPFPlxwMAADQFBGYAADRRtRmOx1C8xol5pgAAACpHYAYAQBNVm+F4DMUDAABAU0JgBgBAE1Wb4XgMxQMAAEBTQmAGAEATxXA8AAAAoHLNwl0AAAAAAAAA0JAQmAEAAAAAAAB+CMwAAAAAAAAAPwRmAAAAAAAAgB8CMwAAAAAAAMAPgRkAAAAAAADgh8AMAAAAAAAA8ENgBgAAAAAAAPghMAMAAAAAAAD8EJgBAAAAAAAAfgjMAAAAAAAAAD8EZgAAAAAAAIAfAjMAAAAAAADAD4EZAAAAAAAA4IfADAAAAAAAAPBDYAYAAAAAAAD4ITADAAAAAAAA/ESHuwAAAAAAQHgUFBTI4/EEbMvMzAy49Od0OmWz2eqlNgAIJwIzAAAAAGiiPB6PUlNTK92Xnp5eYZvb7VZKSkqoywKAsCMwAwAAAIAmyul0yu12B2wrLCxUdna2EhMTFRcXV+F4AGgKLIZhGOEuIlTy8vKUkJCgAwcOqFWrVuEuBwAAAAAAAGFSm5yISf8BAAAAAAAAPwRmAAAAAAAAgB8CMwAAAAAAAMAPgRkAAAAAAADgh8AMAAAAAAAA8ENgBgAAAAAAAPghMAMAAAAAAAD8EJgBAAAAAAAAfgjMAAAAAAAAAD8EZgAAAAAAAIAfAjMAAAAAAADAD4EZAAAAAAAA4IfADAAAAAAAAPATHe4CQskwDElSXl5emCsBAAAAAABAOJXnQ+V5UXUadWB28OBBSVKXLl3CXAkAAAAAAAAagoMHDyohIaHaYyxGMLFahCotLVWPHj3kdrtlsVjCXQ7C5LTTTtPXX38d7jIQRjwHwHMAPAcg8TwAzwHwHADPgabOMAylpqZqy5Ytatas+lnKGnUPs2bNmikmJqbG1BCNW1RUlFq1ahXuMhBGPAfAcwA8ByDxPADPAfAcAM8BSDExMTWGZRKT/gMAAAAAAAABCMwAAAAAAAAAPwRmANAAGIahG2+8UW3btpXFYlHr1q01YcKEam+TmJioZ555xrQaxowZo5EjRwZ9fHZ2tiwWizZu3GhaDU1VuB/LwYMH1/h8Q/jU9m8zHCKhRqCxW7FihSwWi/bv3+/btnDhQnXv3l1RUVG8zgNALTX6wGzcuHHhLgFhxnMAkfAcWLp0qWbNmqXFixdr586d2rJlix5++OF6reHZZ5/VrFmz6vU+60skPAcam8mTJys5OTncZfjwHIDU+J4HlQUkqF5jew7469+/v3bu3Bkwf/PYsWN1ySWXaMeOHfV+XtFQNebnwNGO/kJsz549Ovfcc9WpUyfFxsaqS5cuGj9+vPLy8sJXZBg05eeAJN12221KTU1VbGxsgzpXq0/BPgca9aT/UtP6Y6iNw4cPKyYmJtxl1IvG/hyoy++ypKREFoslqIkOG4NIeA5s27ZNHTt2VP/+/cNWQ2NeICUSngMILZ4DkJru86ApnffVpDE/B2JiYtShQwff9fz8fP32228aNmyYOnXqVOd2G9vzpzE/B2rSrFkzXXDBBXrkkUfUrl07/fjjjxo3bpz27t2ruXPnhru8etOUnwPlrr32Wn355Zf69ttvw11KWAT7HGgan5YbgfLhOkf/Gzx4sCRpzZo1GjBggOLi4tSlSxfddtttOnTokO/2iYmJevjhh3XVVVepVatWuvHGGyVJ7733nk455RTFxsYqMTFR06dPD8ePh1oYPHiwxo8frwkTJshut2vYsGF66qmn1KtXL7Vo0UJdunTRLbfcovz8fN9tZs2apdatW+v999/XySefrNjYWOXk5KioqEh33323TjjhBLVo0UL9+vXTihUrwvfDNVFjxozRrbfeqpycHFksFiUmJlb4Nui3337TiBEjFBcXp27duunNN98MaKOyIX379++XxWIJ+J1+//33Ov/889WqVSvFx8drwIAB2rZtm68O/yFVS5cu1ZlnnqnWrVvruOOO0/nnn+87FrUXzOPp8XjUv39/Wa1W9ezZUytXrvTtK/879rdw4UJZLBbf9fJeXXPmzFFiYqISEhJ06aWX6uDBg75jDh06pKuuukotW7ZUx44dK33dnzNnjk499VTFx8erQ4cOuvzyy/Xbb7/59pf3avn000916qmnymazqX///srKyvLVOmXKFG3atMn3ftVYey+aad68eerVq5fi4uJ03HHHaciQIQHv5eW+/vprtWvXTtOmTZNU9rd+/fXXq127dmrVqpXOOussbdq0SZJ04MABRUVF6ZtvvpEklZaWqm3btjr99NN97WVkZKhLly6+6zt27NDo0aPVunVrtW3bVhdccIGys7N9+0tKSnTnnXf6nsv33HOPDMMIxUPSJJSWlmrq1Knq1q2b4uLi1KdPH82bN0+GYWjIkCEaNmyY7/Hdu3evOnfurEmTJik7O1t/+tOfJElt2rSRxWLRmDFjJFV+riBJmzdv1nnnnaeWLVvq+OOP15VXXqnc3FxfLYMHD9att96qCRMmqE2bNjr++OP1yiuv6NChQ7rmmmsUHx+v7t27a8mSJQE/Q03tIjiVTbWQnJysyZMnS5IsFoteffVVXXjhhbLZbDrppJP0/vvv+47173G4YsUKxcfHS5LOOuusgPOBms7/K/vcUP4etHjxYiUlJclms+mSSy5RQUGBZs+ercTERLVp00a33XabSkpKQvYYIXhjxozRypUr9eyzz/reiw8cOKCbb75Zp556qrp27aqzzz5bt9xyi1avXh3uchEClT0HsrOz9dxzz2ncuHH6wx/+EO4SGzwCswjRpUsX7dy50/dvw4YNOu644zRw4EBt27ZN5557ri6++GJ9++23evvtt7VmzRqNHz8+oI0nn3xSffr00YYNG/TAAw/I7XZr9OjRuvTSS/Xdd99p8uTJeuCBB/hQEwFmz56tmJgYff7553rppZfUrFkzPffcc/r+++81e/ZsffbZZ7rnnnsCblNQUKBp06bp1Vdf1ffff6/27dtr/PjxWrdund566y19++23GjVqlM4991xt3bo1TD9Z0/Tss8/qoYceUufOnbVz5059/fXXFY4ZM2aMduzYoeXLl2vevHn617/+FRBgBOPnn3/WwIEDFRsbq88++0xut1vXXnutiouLKz3+0KFDuvPOO/XNN9/o008/VbNmzXThhReqtLS0Tj9nUxfM4zlx4kTddddd2rBhg8444wyNGDFCe/bsqdX9bNu2TQsXLtTixYu1ePFirVy5Uo8//njAfaxcuVKLFi3Sxx9/rBUrVmj9+vUBbRw5ckQPP/ywNm3apIULFyo7O9v3Qdzf3//+d02fPl3ffPONoqOjde2110qS/vrXv+quu+7SKaec4nvf+utf/1qrn6Op2blzpy677DJde+21yszM1IoVK3TRRRdVCKI+++wznXPOOXr00Ud17733SpJGjRql3377TUuWLJHb7VZKSorOPvts7d27VwkJCUpOTvZ9UP7uu+9ksVi0YcMG3xcrK1eu1KBBgySV/e6HDRum+Ph4rV69Wp9//rlatmypc889V4cPH5YkTZ8+XbNmzdLrr7+uNWvWaO/evVqwYEE9PVKNz9SpU/XGG2/opZde0vfff6877rhD6enpWrVqlWbPnq2vv/5azz33nCTppptu0gknnKBJkyapS5cueu+99yRJWVlZ2rlzp5599llfu0efK+zfv19nnXWW+vbtq2+++UZLly7Vr7/+qtGjRwfUM3v2bNntdn311Ve69dZbdfPNN2vUqFHq37+/1q9fr6FDh+rKK69UQUGBJAXdLswxZcoUjR49Wt9++62GDx+uK664Qnv37q1wnP+XGO+995527typ/v37B33+f/TnBqnsXPK5557TW2+9paVLl2rFihW68MIL9eGHH+rDDz/UnDlzNGPGDM2bNy/kjwNq9uyzz+qMM87QDTfc4Hsv9v9yRJJ++eUXzZ8/3/cegMYlmOcAamAg4hQWFhr9+vUzzj//fKOkpMS47rrrjBtvvDHgmNWrVxvNmjUzCgsLDcMwjK5duxojR44MOObyyy83zjnnnIBtEydONE4++eTQ/gA4JoMGDTL69u1b7THvvvuucdxxx/muz5w505BkbNy40bftv//9rxEVFWX8/PPPAbc9++yzjfvvv9/colGjp59+2ujatavv+qBBg4zbb7/dMAzDyMrKMiQZX331lW9/ZmamIcl4+umnDcMwjO3btxuSjA0bNviO2bdvnyHJWL58uWEYhnH//fcb3bp1Mw4fPlxpDVdffbVxwQUXVFnj7t27DUnGd999V+V9Inj+j2f5Y/n444/79h85csTo3LmzMW3aNMMwyv6OExISAtpYsGCB4f9W/uCDDxo2m83Iy8vzbZs4caLRr18/wzAM4+DBg0ZMTIzxzjvv+Pbv2bPHiIuL8z3fKvP1118bkoyDBw8ahmEYy5cvNyQZn3zyie+YDz74wJDke9958MEHjT59+tTuQWnC3G63IcnIzs6usK/8b3P+/PlGy5Ytjbfeesu3b/Xq1UarVq0Mr9cbcJsTTzzRmDFjhmEYhnHnnXcaf/7znw3DMIxnnnnG+Otf/2r06dPHWLJkiWEYhtG9e3fj5ZdfNgzDMObMmWMkJSUZpaWlvraKioqMuLg446OPPjIMwzA6duxo/N///Z9vf/lztbrXD1TO6/UaNpvNWLt2bcD26667zrjssssMwzCMd955x7BarcZ9991ntGjRwtiyZYvvuPK/xX379gXcvrJzhYcfftgYOnRowLYdO3YYkoysrCzf7c4880zf/uLiYqNFixbGlVde6du2c+dOQ5Kxbt26oNtFcLp27ep7Xy/Xp08f48EHHzQMwzAkGf/4xz98+/Lz8w1Jvr/lo58PR58HGEZw5/+VfW4oP5f88ccffdvGjh1r2Gw233uDYRjGsGHDjLFjx9b6Z0do+J9P+rv00kuNuLg4Q5IxYsQI33s3Gp+qngOGwblaMOhhFoGuvfZaHTx4UHPnzlWzZs20adMmzZo1Sy1btvT9GzZsmEpLS7V9+3bf7U499dSAdjIzM5WWlhawLS0tTVu3bqUrdQOXmpoacP2TTz7R2WefrRNOOEHx8fG68sortWfPHt+3v1LZvBa9e/f2Xf/uu+9UUlKiHj16BDx3Vq5cybC7BiYzM1PR0dEBv3en01lheF5NNm7cqAEDBqh58+ZBHb9161Zddtll+sMf/qBWrVopMTFRkpSTk1Or+0WZYB7PM844w/f/6OhonXrqqcrMzKzV/SQmJvqG4UhSx44dfb0Rt23bpsOHD6tfv36+/W3btlVSUlJAG263WyNGjJDD4VB8fLzvm+ejf/f+rykdO3aUpFr3fESZPn366Oyzz1avXr00atQovfLKK9q3b59v/5dffqlRo0Zpzpw5Ab31Nm3apPz8fB133HEBr+Xbt2/3vZYPGjRIa9asUUlJiVauXKnBgwdr8ODBWrFihX755Rf9+OOPvikeNm3apB9//FHx8fG+ttq2bSuv16tt27bpwIED2rlzZ8BzqPy5itr78ccfVVBQoHPOOSfg9/fGG2/4fn+jRo3ShRdeqMcff1xPPvmkTjrppKDaPvpcYdOmTVq+fHnA/TidTkkKeN/3/7uOiorScccdp169evm2HX/88ZL+97cebLswh//vp0WLFmrVqlWtXneDPf+v7G/aZrPpxBNP9F0//vjjlZiYqJYtWwZs432g4Xv66ae1fv16LVq0SNu2bdOdd94Z7pKABqnRT/rf2DzyyCP66KOP9NVXX/k+EOXn52vs2LG67bbbKhzvcDh8/2/RokW91YnQ8v9dZmdn6/zzz9fNN9+sRx99VG3bttWaNWt03XXX6fDhw7LZbJKkuLi4gLmO8vPzFRUVJbfbraioqID2/U98EBnKF3Aw/IZvHTlyJOCYuLi4WrU5YsQIde3aVa+88oo6deqk0tJS9ezZ0zcsC7VzrI9ns2bNKgzPO/p3LKlCIGqxWGo1jPbQoUMaNmyYhg0bpjfffFPt2rVTTk6Ohg0bVqFW//sqf31hyG7dREVFadmyZVq7dq0+/vhjPf/88/r73/+uL7/8UpJ04okn6rjjjtPrr7+uP//5z77HPj8/Xx07dqx0/snyUH3gwIE6ePCg1q9fr1WrVumxxx5Thw4d9Pjjj6tPnz7q1KmTL4TJz89XampqhXkSJaldu3ah+eGbsPJhsR988IFOOOGEgH2xsbGSyobBlb9X12bKhKPP+/Lz8zVixAjf3Hf+ygNvqfLXkOr+1oNtFzUL5nX+WF/jg1XZ54aanhuhrAfm6tChgzp06CCn06m2bdtqwIABeuCBB/ibBY5CYBZB3nvvPT300ENasmRJwLc7KSkp+uGHH9S9e/datedyufT5558HbPv888/Vo0ePCgEKGi63263S0lJNnz7dF5q88847Nd6ub9++Kikp0W+//aYBAwaEukwcA6fTqeLiYrndbp122mmSyuar2b9/v++Y8g+yO3fuVN++fSUpYAEAqexb6dmzZ+vIkSM19jLbs2ePsrKy9Morr/ieH2vWrDHpJ2p6gn08v/jiCw0cOFCSfL/z8vko27Vrp4MHD+rQoUO+DzJH/45rcuKJJ6p58+b68ssvfV+o7Nu3T1u2bPH1IvN4PNqzZ48ef/xx3zwX5RPG10ZMTAy9lWvJYrEoLS1NaWlpmjRpkrp27eqbG8xut2v+/PkaPHiwRo8erXfeeUfNmzdXSkqKdu3apejoaF+vxaO1bt1avXv31gsvvKDmzZvL6XSqffv2+utf/6rFixcHzF2TkpKit99+W+3bt1erVq0qba9jx4768ssvKzxXU1JSzH1AmgD/hXiqmkPorrvuUrNmzbRkyRINHz5cf/7zn3XWWWdJkm/lwmD+1lJSUvTee+8pMTFR0dHmfQQIVbtNUbt27bRz507f9by8vIDRImbg/L9pCea9uDzgLCoqqo+SUM84Hzs2DMmMEJs3b9ZVV12le++9V6eccop27dqlXbt2ae/evbr33nu1du1ajR8/Xhs3btTWrVu1aNGiCpP+H+2uu+7Sp59+qocfflhbtmzR7Nmz9cILL+juu++up58KZujevbuOHDmi559/Xv/5z380Z84cvfTSSzXerkePHrriiit01VVXaf78+dq+fbu++uorTZ06VR988EE9VI5gJSUl6dxzz9XYsWP15Zdfyu126/rrrw/oMRYXF6fTTz9djz/+uDIzM7Vy5Ur94x//CGhn/PjxysvL06WXXqpvvvlGW7du1Zw5c3yTAvtr06aNjjvuOL388sv68ccf9dlnn9Fd/xgE+3j+85//1IIFC+TxeDRu3Djt27fPN5F+v379ZLPZ9Le//U3btm3T3Llza71IS8uWLXXddddp4sSJ+uyzz7R582aNGTPGF7ZLZT2TY2JifK8p77//vh5++OFa/8yJiYnavn27Nm7cqNzcXE7Ea/Dll1/qscce0zfffKOcnBzNnz9fu3fvlsvl8h3Tvn17ffbZZ/J4PLrssstUXFysIUOG6IwzztDIkSP18ccfKzs7W2vXrtXf//73gKBz8ODBevPNN32hTNu2beVyufT2228HBDVXXHGF7Ha7LrjgAq1evVrbt2/XihUrdNttt+mnn36SJN1+++16/PHHtXDhQnk8Ht1yyy0BAT6CFx8fr7vvvlt33HGHZs+erW3btmn9+vV6/vnnNXv2bH3wwQd6/fXX9eabb+qcc87RxIkTdfXVV/uG63bt2lUWi0WLFy/W7t27A1bIPtq4ceO0d+9eXXbZZfr666+1bds2ffTRR7rmmmuO6cNUqNptis466yzNmTNHq1ev1nfffaerr77a9BCL8/+mJTExUV9++aWys7OVm5urDz/8UDNnztTmzZuVnZ2tDz74QDfddJPS0tKq/NIFke3o50Bpaal+/PFHbdy4Ubt27VJhYaE2btyojRs3MoqkEgRmEeKbb75RQUGBHnnkEXXs2NH376KLLlLv3r21cuVKbdmyRQMGDFDfvn01adIkderUqdo2U1JS9M477+itt95Sz549NWnSJD300EOVroSGhqtPnz566qmnNG3aNPXs2VNvvvmmpk6dGtRtZ86cqauuukp33XWXkpKSNHLkSH399dcBQ3nRMMycOVOdOnXSoEGDdNFFF+nGG29U+/btA455/fXXVVxcrNTUVE2YMEGPPPJIwP7jjjtOn332mfLz8zVo0CClpqbqlVdeqbS3WbNmzfTWW2/J7XarZ8+euuOOO/TEE0+E9GdszIJ9PB9//HHfMLk1a9bo/fffl91ul1QWcGRkZOjDDz9Ur1699O9//1uTJ0+udS1PPPGEBgwYoBEjRmjIkCE688wzA+Y6ateunWbNmqV3331XJ598sm/epNq6+OKLde655+pPf/qT2rVrp3//+9+1bqMpadWqlVatWqXhw4erR48e+sc//qHp06frvPPOCziuQ4cO+uyzz/Tdd9/piiuuUGlpqT788EMNHDhQ11xzjXr06KFLL71U//3vf31zTUll85iVlJT45iqTykK0o7fZbDatWrVKDodDF110kVwul6677jp5vV5fj7O77rpLV155pa6++mqdccYZio+P14UXXhjSx6cxe/jhh/XAAw9o6tSpcrlcOvfcc/XBBx8oMTFR1113nSZPnuzrvTdlyhQdf/zxuummmyRJJ5xwgqZMmaL77rtPxx9/fLVflnbq1Emff/65SkpKNHToUPXq1UsTJkxQ69atA0Lz2gpVu03R/fffr0GDBun888/Xn//8Z40cOTJgVIkZOP9vWu6++25FRUXp5JNPVrt27fTrr7/qlVde0ZlnnimXy6U77rhDf/nLX7R48eJwl4oQOfo5kJOTo+uvv159+/bVjBkztGXLFvXt21d9+/bVL7/8Eu5yGxyLcfRAeQAAAAAAAKAJ42sfAAAAAAAAwA+BGQAAAAAAAOCHwAwAAAAAAADwQ2AGAAAAAAAA+CEwAwAAAAAAAPwQmAEAAAAAAAB+CMwAAAAAAAAAPwRmAAAAAAAAgB8CMwAAAAAAAMAPgRkAAAAAAADgh8AMAAAAAAAA8ENgBgAAAAAAAPj5/9pO5SFqrmC+AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1500x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.ticker as ticker\n",
+    "from matplotlib.patches import Patch\n",
+    "\n",
+    "# Define the groups\n",
+    "groups = [\"GP\", \"ITGP\", \"Ideal\", \"t GP\"]\n",
+    "\n",
+    "datasets = [rmse_GP, rmse_ITGP, rmse_ideal, rmse_tP]\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 1, figsize=(15, 5))\n",
+    "# Set x-positions for boxes\n",
+    "x_pos_range = np.arange(len(datasets)) / (len(datasets) - 1)\n",
+    "x_pos = (x_pos_range * 0.5) + 0.75\n",
+    "# Plot\n",
+    "colours = [\"blue\", \"green\", \"red\", \"black\"]\n",
+    "for i, data in enumerate(datasets):\n",
+    "    bp = plt.boxplot(\n",
+    "        np.array(data),\n",
+    "        sym=\"\",  # whis=[0, 100],\n",
+    "        widths=0.6 / len(datasets),\n",
+    "        labels=list(datasets[0]),\n",
+    "        patch_artist=True,\n",
+    "        positions=[x_pos[i] + j * 1 for j in range(len(data.T))],\n",
+    "    )\n",
+    "    k = i % len(colours)\n",
+    "    for box in bp[\"boxes\"]:\n",
+    "        box.set(facecolor=colours[k])\n",
+    "    for element in [\"boxes\", \"fliers\", \"means\"]:\n",
+    "        plt.setp(bp[element], color=colours[k])\n",
+    "# Titles\n",
+    "plt.title(\"Test case (n=100)\")\n",
+    "plt.ylabel(\"RMSE/ 0.032\")\n",
+    "# Axis ticks and labels\n",
+    "plt.xticks(np.arange(len(list(datasets[0]))) + 1)\n",
+    "plt.gca().xaxis.set_minor_locator(\n",
+    "    ticker.FixedLocator(np.array(range(len(list(datasets[0])) + 1)) + 0.5)\n",
+    ")\n",
+    "plt.gca().tick_params(axis=\"x\", which=\"minor\", length=4)\n",
+    "plt.gca().tick_params(axis=\"x\", which=\"major\", length=0)\n",
+    "# Change the limits of the x-axis\n",
+    "plt.xlim([0.5, len(list(datasets[0])) + 0.5])\n",
+    "# plt.ylim(0.25,16)\n",
+    "plt.yscale(\"log\", base=2)\n",
+    "legend_elements = []\n",
+    "for i in range(len(datasets)):\n",
+    "    j = i % len(groups)\n",
+    "    k = i % len(colours)\n",
+    "    legend_elements.append(Patch(facecolor=colours[k], label=groups[j]))\n",
+    "plt.legend(handles=legend_elements, fontsize=8)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tutorials/benchmarks/008-Himmelblau_with_outliers.ipynb b/tutorials/benchmarks/008-Himmelblau_with_outliers.ipynb
new file mode 100644
index 000000000..c56ea8d04
--- /dev/null
+++ b/tutorials/benchmarks/008-Himmelblau_with_outliers.ipynb
@@ -0,0 +1,746 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Himmelblau Benchmark with outliers\n",
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from bofire.benchmarks.single import Himmelblau\n",
+    "from bofire.benchmarks.benchmark import run\n",
+    "from bofire.data_models.strategies.api import (\n",
+    "    SoboStrategy,\n",
+    "    RandomStrategy,\n",
+    "    PolytopeSampler,\n",
+    ")\n",
+    "from bofire.data_models.domain.api import Outputs\n",
+    "from bofire.data_models.acquisition_functions.api import qEI\n",
+    "from bofire.data_models.outlier_detection.api import IterativeTrimming, OutlierDetections\n",
+    "from bofire.data_models.surrogates.api import SingleTaskGPSurrogate, MixedSingleTaskGPSurrogate\n",
+    "from bofire.data_models.features.api import CategoricalInput\n",
+    "import bofire.strategies.api as strategies\n",
+    "from bofire.data_models.api import Domain\n",
+    "from functools import partial\n",
+    "import pandas as pd #type: ignore\n",
+    "import os\n",
+    "from bofire.benchmarks.benchmark import UniformOutlierPrior\n",
+    "from matplotlib import pyplot as plt\n",
+    "from bofire.data_models.surrogates.api import SingleTaskGPSurrogate\n",
+    "from bofire.data_models.domain.api import Domain\n",
+    "from bofire.data_models.acquisition_functions.api import qEI\n",
+    "\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from matplotlib import pyplot as plt\n",
+    "from bofire.data_models.domain.api import Outputs\n",
+    "from bofire.data_models.features.api import (\n",
+    "    CategoricalInput,\n",
+    ")\n",
+    "from bofire.data_models.outlier_detection.api import IterativeTrimming, OutlierDetections\n",
+    "from bofire.data_models.strategies.api import SoboStrategy\n",
+    "from bofire.data_models.surrogates.api import (\n",
+    "    SingleTaskGPSurrogate,\n",
+    "    MixedSingleTaskGPSurrogate\n",
+    "    \n",
+    ")\n",
+    "\n",
+    "\n",
+    "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## sample set of Himmelblau example to start optimization\n",
+    "we use the same set of example as initial data for comparision of three models. One case is where there is no outlier, while for other two models, we introduced outliers at a fixed probability. Using same initial example data helps us to compare the efficiency of outlier detection compared to the no outlier model that works on the dataset with no outliers. Further, using same sampled set with same outliers help starting both models with and without outlier detection from same value and we can see their evolution with iterations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sample(domain):\n",
+    "    datamodel = PolytopeSampler(domain=domain)\n",
+    "    sampler = strategies.map(data_model=datamodel)\n",
+    "    sampled = sampler.ask(10)\n",
+    "    return sampled\n",
+    "\n",
+    "def best(domain: Domain, experiments: pd.DataFrame) -> float:\n",
+    "    return experiments.y.min()\n",
+    "\n",
+    "bo_results_set=[] # stores progress of model on data with no outliers (no outliers model)\n",
+    "bo_results_outliers_set=[] # stores progress of model with no outlier detection on data with outliers (baseline model)\n",
+    "bo_results_no_outliers_set=[] # stores progress of model with the outlier detection on data with outliers (our model)\n",
+    "\n",
+    "Benchmark = Himmelblau()\n",
+    "sampled = sample(Benchmark.domain)\n",
+    "sampled_xy = Benchmark.f(sampled, return_complete=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Adding outliers\n",
+    "Here we show an example of adding outliers with uniform priors between range of 50 and 100. We consider three cases of outliers; outliers not outrageous with range of 50 to 100, outliers moderately outrageous with range of 500 to 1000 and outliers too outrageous with brange of 5000 to 10000. The model should detect the more outrageous outliers easily and vice versa. Here is an example of not outrageous outlier addition with a probability of 0.2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Benchmark = Himmelblau(outlier_rate = 0.2, outlier_prior = UniformOutlierPrior(bounds =(50,100))) # not outrageous\n",
+    "sampled_xy1 = Benchmark.f(sampled, return_complete=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Outliers not outrageous\n",
+    "Now we run optimization to compare the three models for not outrageous outliers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "run 00 with current best 50.130:   0%|          | 0/50 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "run 00 with current best 4.056: 100%|██████████| 50/50 [00:00<00:00, 84.74it/s] \n",
+      "run 00 with current best 0.021: 100%|██████████| 50/50 [02:42<00:00,  3.24s/it]\n",
+      "run 00 with current best 0.015: 100%|██████████| 50/50 [02:43<00:00,  3.27s/it]\n",
+      "run 00 with current best 0.280: 100%|██████████| 50/50 [03:12<00:00,  3.85s/it] \n",
+      "run 00 with current best 14.618: 100%|██████████| 50/50 [00:00<00:00, 77.40it/s]\n",
+      "run 00 with current best 0.041: 100%|██████████| 50/50 [02:40<00:00,  3.21s/it]\n",
+      "run 00 with current best 0.018: 100%|██████████| 50/50 [02:33<00:00,  3.07s/it]\n",
+      "run 00 with current best 6.035: 100%|██████████| 50/50 [03:09<00:00,  3.79s/it] \n",
+      "run 00 with current best 2.752: 100%|██████████| 50/50 [00:00<00:00, 72.78it/s] \n",
+      "run 00 with current best 0.001: 100%|██████████| 50/50 [02:39<00:00,  3.18s/it]\n",
+      "run 00 with current best 0.689: 100%|██████████| 50/50 [02:30<00:00,  3.01s/it]\n",
+      "run 00 with current best 0.583: 100%|██████████| 50/50 [03:01<00:00,  3.62s/it]\n",
+      "run 00 with current best 0.167: 100%|██████████| 50/50 [00:00<00:00, 74.84it/s]\n",
+      "run 00 with current best 0.016: 100%|██████████| 50/50 [02:41<00:00,  3.23s/it]\n",
+      "run 00 with current best 3.396: 100%|██████████| 50/50 [02:30<00:00,  3.01s/it]\n",
+      "run 00 with current best 0.038: 100%|██████████| 50/50 [03:24<00:00,  4.09s/it]\n",
+      "run 00 with current best 3.681: 100%|██████████| 50/50 [00:00<00:00, 62.97it/s]\n",
+      "run 00 with current best 0.034: 100%|██████████| 50/50 [02:51<00:00,  3.44s/it]\n",
+      "run 00 with current best 0.119: 100%|██████████| 50/50 [02:57<00:00,  3.54s/it]\n",
+      "run 00 with current best 0.533: 100%|██████████| 50/50 [02:59<00:00,  3.59s/it]\n",
+      "run 00 with current best 12.861: 100%|██████████| 50/50 [00:00<00:00, 64.84it/s]\n",
+      "run 00 with current best 0.003: 100%|██████████| 50/50 [03:06<00:00,  3.73s/it] \n",
+      "run 00 with current best 0.835: 100%|██████████| 50/50 [02:36<00:00,  3.14s/it]\n",
+      "run 00 with current best 0.014: 100%|██████████| 50/50 [03:04<00:00,  3.70s/it]\n",
+      "run 00 with current best 15.964: 100%|██████████| 50/50 [00:00<00:00, 73.20it/s]\n",
+      "run 00 with current best 0.057: 100%|██████████| 50/50 [02:37<00:00,  3.15s/it]\n",
+      "run 00 with current best 0.277: 100%|██████████| 50/50 [02:32<00:00,  3.05s/it]\n",
+      "run 00 with current best 0.980: 100%|██████████| 50/50 [02:52<00:00,  3.44s/it] \n",
+      "run 00 with current best 2.132: 100%|██████████| 50/50 [00:00<00:00, 74.84it/s]\n",
+      "run 00 with current best 0.002: 100%|██████████| 50/50 [02:33<00:00,  3.07s/it]\n",
+      "run 00 with current best 0.116: 100%|██████████| 50/50 [02:31<00:00,  3.03s/it] \n",
+      "run 00 with current best 0.024: 100%|██████████| 50/50 [02:57<00:00,  3.55s/it] \n",
+      "run 00 with current best 5.147: 100%|██████████| 50/50 [00:00<00:00, 77.63it/s]\n",
+      "run 00 with current best 0.015: 100%|██████████| 50/50 [02:40<00:00,  3.21s/it]\n",
+      "run 00 with current best 0.304: 100%|██████████| 50/50 [02:44<00:00,  3.28s/it] \n",
+      "run 00 with current best 2.384: 100%|██████████| 50/50 [03:16<00:00,  3.93s/it]\n",
+      "run 00 with current best 8.071: 100%|██████████| 50/50 [00:00<00:00, 67.29it/s] \n",
+      "run 00 with current best 0.017: 100%|██████████| 50/50 [02:52<00:00,  3.45s/it] \n",
+      "run 00 with current best 0.181: 100%|██████████| 50/50 [02:46<00:00,  3.33s/it]\n",
+      "run 00 with current best 7.181: 100%|██████████| 50/50 [03:23<00:00,  4.08s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "bo_results_set=[]\n",
+    "bo_results_outliers_set=[]\n",
+    "bo_results_no_outliers_set=[]\n",
+    "n_iterations = 10 if not SMOKE_TEST else 1\n",
+    "for kk in range(n_iterations):\n",
+    "    Benchmark = Himmelblau()\n",
+    "    sampled = sample(Benchmark.domain)\n",
+    "    sampled_xy = Benchmark.f(sampled, return_complete=True)\n",
+    "    random_results = run(\n",
+    "        Himmelblau(),\n",
+    "        strategy_factory=RandomStrategy,\n",
+    "        n_iterations=50,                     # random strategy \n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    bo_results = run(\n",
+    "        Himmelblau(),\n",
+    "        strategy_factory=partial(SoboStrategy, acquisition_function=qEI()),\n",
+    "        n_iterations=50 if not SMOKE_TEST else 1,\n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    Benchmark = Himmelblau(outlier_rate = 0.2, outlier_prior = UniformOutlierPrior(bounds =(50,100)))\n",
+    "    sampled_xy1 = Benchmark.f(sampled, return_complete=True)\n",
+    "\n",
+    "    bo_results_outliers = run(\n",
+    "        Benchmark,\n",
+    "        strategy_factory=partial(SoboStrategy, acquisition_function=qEI()),\n",
+    "        n_iterations=50 if not SMOKE_TEST else 1,\n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy1,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    domain = Benchmark.domain\n",
+    "    detectors = []\n",
+    "    for output_feature in domain.outputs.get_keys():\n",
+    "        if len(domain.inputs.get(CategoricalInput, exact=True)):\n",
+    "                detectors.append(IterativeTrimming(\n",
+    "                        base_gp=MixedSingleTaskGPSurrogate(\n",
+    "                            inputs=domain.inputs,\n",
+    "                            outputs=Outputs(features=[domain.outputs.get_by_key(output_feature)]),  # type: ignore\n",
+    "                        ))\n",
+    "                    )\n",
+    "        else:\n",
+    "            detectors.append(IterativeTrimming(\n",
+    "                base_gp=SingleTaskGPSurrogate(\n",
+    "                    inputs=domain.inputs,\n",
+    "                    outputs=Outputs(features=[domain.outputs.get_by_key(output_feature)]),  # type: ignore\n",
+    "                ))\n",
+    "            )\n",
+    "    outlier_detection_specs = OutlierDetections(detectors=detectors)\n",
+    "\n",
+    "    bo_results_no_outliers = run(\n",
+    "        Benchmark,\n",
+    "        strategy_factory=partial(SoboStrategy, acquisition_function=qEI(), outlier_detection_specs = outlier_detection_specs,\n",
+    "                                min_experiments_before_outlier_check = 10, \n",
+    "                                frequency_check = 2),\n",
+    "        n_iterations=50 if not SMOKE_TEST else 1,\n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy1,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    bo_results_set.append(bo_results[0])\n",
+    "    bo_results_outliers_set.append(bo_results_outliers[0])\n",
+    "    bo_results_no_outliers_set.append(bo_results_no_outliers[0])\n",
+    "\n",
+    "## Collecting data evolution over iterations\n",
+    "\n",
+    "bo_results_itr = np.zeros((len(bo_results_set),50))\n",
+    "bo_results_outliers_itr = np.zeros((len(bo_results_set),50))\n",
+    "bo_results_no_outliers_itr = np.zeros((len(bo_results_set),50))\n",
+    "for i in range(len(bo_results_set)):\n",
+    "    bo_results_itr[i] = bo_results_set[i][1].to_numpy()\n",
+    "    bo_results_outliers_itr[i] = bo_results_outliers_set[i][1].to_numpy()\n",
+    "    bo_results_no_outliers_itr[i] = bo_results_no_outliers_set[i][1].to_numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Performance of models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'outliers not outrageous')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGzCAYAAAA1yP25AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACrvUlEQVR4nOzdd3yb1fX48c/zaNuS907s7DjOIiGBkARCWAmzjLS0hZZNB7PQ0l9py+qX2ZZVdoEm0BZoKasUAoEwAgQCZO/pxE4cx3Y8ZVv7+f3x2IoVL8mWLTk+79fLL9vS1aNrx7GO7z3nXEXTNA0hhBBCiAFIjfUEhBBCCCF6SgIZIYQQQgxYEsgIIYQQYsCSQEYIIYQQA5YEMkIIIYQYsCSQEUIIIcSAJYGMEEIIIQYsCWSEEEIIMWBJICOEEEKIAUsCGSEGkE8++QRFUfjkk0+Ct1122WUMHz48ZnMSQohYkkBGiDj05JNPsmjRolhPIy5s2rSJO++8k927d8dsDvfeey9vvvlmzJ5fCNE5CWSEiEORBDLPPvssW7du7dsJxdCmTZu46667JJARQnRIAhkhBjiTyYTFYonKtTRNo7m5OSrXGqwaGxtjPQUhBhUJZISIgtWrV3PGGWeQlJSE3W7nlFNO4auvvgoZc+edd6IoSrvHLlq0CEVRgisOw4cPZ+PGjXz66acoioKiKMydO7fT5+4oRyYQCPDII48wYcIErFYr2dnZ/PSnP6WmpiZk3PDhwzn77LN5//33mT59OjabjWeeeQaADz74gOOPP56UlBTsdjuFhYX89re/7fZ7oSgK1113HW+++SYTJ07EYrEwYcIE3nvvvYi/b4sWLeJ73/seACeddFLw+9E2R6gjH330ESeccAKJiYmkpKRw7rnnsnnz5m6/b9D+30lRFBobG3nhhReCz3/ZZZeFjN20aRMXXXQRqampHH/88QCsW7eOyy67jJEjR2K1WsnJyeGKK67g4MGD7Z7zk08+Yfr06VitVkaNGsUzzzzT6c/LP/7xD6ZNm4bNZiMtLY0f/OAHlJaWthv36quvBsdlZGTwox/9iH379oWMmTt3boc/Wx19b1555RWmTZuGw+EgKSmJSZMm8eijj7Z7rBD9zRjrCQgx0G3cuJETTjiBpKQkfv3rX2MymXjmmWeYO3cun376KTNmzIjoeo888gjXX389drud3/3udwBkZ2dHdI2f/vSnLFq0iMsvv5wbbriB4uJiHn/8cVavXs0XX3yByWQKjt26dSs//OEP+elPf8rVV19NYWEhGzdu5Oyzz2by5Mn84Q9/wGKxsGPHDr744ouwnv/zzz/n9ddf55prrsHhcPCXv/yFBQsWUFJSQnp6OhDe923OnDnccMMN/OUvf+G3v/0tRUVFAMH3Hfnwww8544wzGDlyJHfeeSfNzc089thjzJ49m1WrVkWcGP33v/+dq666imOPPZaf/OQnAIwaNSpkzPe+9z3GjBnDvffei6ZpgB4I7tq1i8svv5ycnBw2btzIX//6VzZu3MhXX30VDFJWr17N6aefTm5uLnfddRd+v58//OEPZGZmtpvLPffcw2233caFF17IVVddRWVlJY899hhz5sxh9erVpKSkAAT/7Y855hjuu+8+Dhw4wKOPPsoXX3wRMi5cH3zwAT/84Q855ZRTeOCBBwDYvHkzX3zxBTfeeGNE1xIi6jQhRK+cd955mtls1nbu3Bm8raysTHM4HNqcOXOCt91xxx1aR//lFi5cqAFacXFx8LYJEyZoJ554YruxH3/8sQZoH3/8cfC2Sy+9VBs2bFjw888++0wDtH/+858hj33vvffa3T5s2DAN0N57772QsQ8//LAGaJWVld19+e0Amtls1nbs2BG8be3atRqgPfbYY8Hbwv2+vfrqq+2+5q5MmTJFy8rK0g4ePBjy/KqqapdccknwtsO/b606+ndKTEzULr300k7H/vCHP2x3X1NTU7vbXn75ZQ3Qli1bFrztnHPO0RISErR9+/YFb9u+fbtmNBpD5rF7927NYDBo99xzT8g1169frxmNxuDtHo9Hy8rK0iZOnKg1NzcHx/3vf//TAO32228P3nbiiSd2+HN2+Pfmxhtv1JKSkjSfz9durBCxJltLQvSC3+9nyZIlnHfeeYwcOTJ4e25uLhdddBGff/459fX1/TqnV199leTkZE477TSqqqqCb9OmTcNut/Pxxx+HjB8xYgTz588Pua31L/a33nqLQCAQ8RxOPfXUkFWLyZMnk5SUxK5du4C++77t37+fNWvWcNlll5GWlhby/KeddhrvvvtuxNcMx89+9rN2t9lstuDHLpeLqqoqjjvuOABWrVoF6N+HDz/8kPPOO4+8vLzg+NGjR3PGGWeEXO/1118nEAhw4YUXhvy75uTkMGbMmOC/67fffktFRQXXXHMNVqs1+PizzjqLcePG8c4770T89aWkpNDY2MgHH3wQ8WOF6GsSyAjRC5WVlTQ1NVFYWNjuvqKiIgKBQIf5C31p+/bt1NXVkZWVRWZmZsib0+mkoqIiZPyIESPaXeP73/8+s2fP5qqrriI7O5sf/OAH/Pvf/w47qCkoKGh3W2pqajBHp6++b3v27AHo9LpVVVV9kozb0fewurqaG2+8kezsbGw2G5mZmcFxdXV1AFRUVNDc3Mzo0aPbPf7w27Zv346maYwZM6bdv+vmzZuD/65dfQ/GjRsXvD8S11xzDWPHjuWMM85g6NChXHHFFR3mPAkRC5IjI0Q/6ShxE/S/yqMpEAiQlZXFP//5zw7vPzz3ou3KQdvbli1bxscff8w777zDe++9x7/+9S9OPvlklixZgsFg6HIOnd2vteSPxINo/nt09D288MILWb58ObfccgtTpkzBbrcTCAQ4/fTTe7TKFQgEUBSFxYsXd/j9tdvtEV9TUZQO/00O/x5kZWWxZs0a3n//fRYvXszixYtZuHAhl1xyCS+88ELEzytENEkgI0QvZGZmkpCQ0GEfly1btqCqKvn5+YC+IgFQW1sbkmzZ0V/Inb3IhmPUqFF8+OGHzJ49u8MX2HCpqsopp5zCKaecwkMPPcS9997L7373Oz7++GNOPfXUHl8XIvu+RfK9GDZsGECn183IyCAxMRHQ/z1qa2vbjYvGv0dNTQ1Lly7lrrvu4vbbbw/evn379pBxWVlZWK1WduzY0e4ah982atQoNE1jxIgRjB07ttPnbvs9OPnkk0Pu27p1a/B+0L8Hrdt9bXX0PTCbzZxzzjmcc845BAIBrrnmGp555hluu+22DleUhOgvsrUkRC8YDAbmzZvHW2+9FdKw7cCBA7z00kscf/zxJCUlAYcqXZYtWxYc11rWe7jExMQOX2TDceGFF+L3+/m///u/dvf5fL6wrltdXd3utilTpgDgdrt7NK+2Ivm+tQYe4cw7NzeXKVOm8MILL4SM37BhA0uWLOHMM88M3jZq1Cjq6upYt25d8Lb9+/fzxhtvtLtupP8erSsmh692PPLII+3GnXrqqbz55puUlZUFb9+xYweLFy8OGXvBBRdgMBi466672l1X07RgWff06dPJysri6aefDvm3Wrx4MZs3b+ass84K3jZq1Ci2bNlCZWVl8La1a9e2q047vGRcVVUmT54MROfnQYjekBUZIXrp7rvvDvZcueaaazAajTzzzDO43W7++Mc/BsfNmzePgoICrrzySm655RYMBgN/+9vfyMzMpKSkJOSa06ZN46mnnuLuu+9m9OjRZGVltfvrujMnnngiP/3pT7nvvvtYs2YN8+bNw2QysX37dl599VUeffRRvvvd73Z5jT/84Q8sW7aMs846i2HDhlFRUcGTTz7J0KFDg31Seivc79uUKVMwGAw88MAD1NXVYbFYOPnkk8nKyurwun/6058444wzmDlzJldeeWWw/Do5OZk777wzOO4HP/gB/+///T/OP/98brjhBpqamnjqqacYO3ZsMBm31bRp0/jwww956KGHyMvLY8SIEV2W1SclJTFnzhz++Mc/4vV6GTJkCEuWLKG4uLjd2DvvvJMlS5Ywe/Zsfv7zn+P3+3n88ceZOHEia9asCY4bNWoUd999N7feeiu7d+/mvPPOw+FwUFxczBtvvMFPfvITfvWrX2EymXjggQe4/PLLOfHEE/nhD38YLL8ePnw4N910U/CaV1xxBQ899BDz58/nyiuvpKKigqeffpoJEyaEJFtfddVVVFdXc/LJJzN06FD27NnDY489xpQpU7oshReiX8SwYkqII8aqVau0+fPna3a7XUtISNBOOukkbfny5e3GrVy5UpsxY4ZmNpu1goIC7aGHHuqw/Lq8vFw766yzNIfDoQHBEtlwyq9b/fWvf9WmTZum2Ww2zeFwaJMmTdJ+/etfa2VlZcExw4YN084666x2j126dKl27rnnanl5eZrZbNby8vK0H/7wh9q2bdu6/V4A2rXXXtvu9mHDhrUrYQ73+/bss89qI0eO1AwGQ1il2B9++KE2e/ZszWazaUlJSdo555yjbdq0qd24JUuWaBMnTtTMZrNWWFio/eMf/+iw/HrLli3anDlzNJvNpgHBr6N1bEdl6nv37tXOP/98LSUlRUtOTta+973vaWVlZRqg3XHHHSFjly5dqk2dOlUzm83aqFGjtOeee0775S9/qVmt1nbXfe2117Tjjz9eS0xM1BITE7Vx48Zp1157rbZ169aQcf/617+0qVOnahaLRUtLS9Muvvhibe/eve2u949//EMbOXKkZjabtSlTpmjvv/9+u5+p//znP9q8efO0rKys4M/uT3/6U23//v2d/RMI0W8UTYuj7DshhBAAnHfeeWzcuLFdXo0QIpTkyAghRIwdfr7V9u3beffdd7s8mkIIoZMVGSGEiLHc3NzguUx79uzhqaeewu12s3r1asaMGRPr6QkR1yTZVwghYuz000/n5Zdfpry8HIvFwsyZM7n33nsliBEiDLIiI4QQQogBS3JkhBBCCDFgSSAjhBBCiAHriM+RCQQClJWV4XA4etX2XQghhBD9R9M0GhoayMvLQ1U7X3c54gOZsrKy4JktQgghhBhYSktLGTp0aKf3H/GBjMPhAPRvROvZLUIIIYSIb/X19eTn5wdfxztzxAcyrdtJSUlJEsgIIYQQA0x3aSGS7CuEEEKIAUsCGSGEEEIMWBLICCGEEGLAOuJzZIQQQsQ3v9+P1+uN9TREPzMYDBiNxl63RpFARgghRMw4nU727t2LnJYzOCUkJJCbm4vZbO7xNSSQEUIIERN+v5+9e/eSkJBAZmamNC0dRDRNw+PxUFlZSXFxMWPGjOmy6V1XJJARQggRE16vF03TyMzMxGazxXo6op/ZbDZMJhN79uzB4/FgtVp7dB1J9hVCCBFTshIzePV0FSbkGlGYhxBCCCFETEggI4QQQogBSwIZIYQQ4gi2aNEiUlJSgp/feeedTJkyJWbziTYJZIQQQogjxPDhw3nkkUe6HPOrX/2KpUuX9s+E+oFULQkhhBCDiN1ux2639+oaXq8Xk8kUpRn1jgQyvfDlphI27NnX7TibMZGhCWOwGvqnvDAjAwoKoBf9hYQQov9pGjQ1xea5ExIgzOqpuXPnMnnyZKxWK8899xxms5mf/exn3HnnncExJSUlXH/99SxduhRVVTn99NN57LHHyM7O7vS669ev58Ybb+TLL78kISGBBQsW8NBDDwWDjrlz5zJlypSQFZfzzjuPlJQUFi1axNy5c9mzZw833XQTN910E0CHjQbvvPNO3nzzTdasWRO87bnnnuPBBx+kuLiY4cOHc8MNN3DNNdcAsHv3bkaMGMErr7zCk08+yYoVK3j66ac56aSTuO666/j888/xeDwMHz6cP/3pT5x55plhfR+jRQKZXvh2+27eWPMJDkvXkW1AC5CkrGeo4Wgy1NEYlL6LYjVN/7+YnQ0TJsCIEZCc3GdPJ4QQ0dPUBL1cKegxpxMSE8Me/sILL3DzzTezYsUKvvzySy677DJmz57NaaedRiAQ4Nxzz8Vut/Ppp5/i8/m49tpr+f73v88nn3zS4fUaGxuZP38+M2fO5JtvvqGiooKrrrqK6667jkWLFoU1p9dff52jjjqKn/zkJ1x99dVhfy3//Oc/uf3223n88ceZOnUqq1ev5uqrryYxMZFLL700OO43v/kNDz74IFOnTsVqtXL11Vfj8XhYtmwZiYmJbNq0qdcrPT0hgUwvJVmTmJQ3qssxAc1PjXc/lYF3USzDGJkwlWzzCFSlb1KUvF6orIQPPoCUFBgzRn/LzYUolOwLIcSgN3nyZO644w4AxowZw+OPP87SpUs57bTTWLp0KevXr6e4uJj8/HwAXnzxRSZMmMA333zDMccc0+56L730Ei6XixdffJHEloDq8ccf55xzzuGBBx7ociWnVVpaGgaDAYfDQU5OTthfyx133MGDDz7IBRdcAMCIESPYtGkTzzzzTEgg84tf/CI4BvRVpwULFjBp0iQARo4cGfZzRlPcvKzdf//9KIrCL37xi+BtLpeLa6+9lvT0dOx2OwsWLODAgQOxm2QPqYqBdPNQss3DqfaU8XXd26ysf5cqT9+cL2IyQV4eFBaCxQKrVsFrr8Gbb8KWLdDcHPWnFEKI3ktI0FdGYvGWkBDRVCdPnhzyeW5uLhUVFQBs3ryZ/Pz8YBADMH78eFJSUti8eXOH19u8eTNHHXVUMIgBmD17NoFAgK1bt0Y0t0g0Njayc+dOrrzyymDujN1u5+6772bnzp0hY6dPnx7y+Q033MDdd9/N7NmzueOOO1i3bl2fzbMrcbEi88033/DMM8+0+8G46aabeOedd3j11VdJTk7muuuu44ILLuCLL76I0Ux7x6iaybaMwBNopsy1nQPu3Qy1jmOE7SiSTZlRfz5FgdRU/a25GcrKYNcuyMyEE06AGAXPQgjRMUWJaHsnlg5PdFUUhUAg0KfPqapquz9+e3tquNPpBODZZ59lxowZIfcZDIaQzxMP+7e56qqrmD9/Pu+88w5Llizhvvvu48EHH+T666/v1ZwiFfNAxul0cvHFF/Pss89y9913B2+vq6vj+eef56WXXuLkk08GYOHChRQVFfHVV19x3HHHxWrKvWZWbeRaRtPsb6C4aQ3l7p0MsRZiUro+Z8KomCiwTcCsRn4ehc0Gw4aB3w+7d8PatXr+jHQGF0KI6CoqKqK0tJTS0tLgqsymTZuora1l/PjxnT5m0aJFNDY2BgOGL774AlVVKSwsBCAzM5P9+/cHH+P3+9mwYQMnnXRS8Daz2Yzf7w97rtnZ2eTl5bFr1y4uvvjiiL/W/Px8fvazn/Gzn/2MW2+9lWeffXbwBTLXXnstZ511FqeeempIILNy5Uq8Xi+nnnpq8LZx48ZRUFDAl19+2Wkg43a7cbvdwc/r6+v7bvK9ZDM4GGIoxOmrYWfTKuhml8mPDwWFUYlH9/g5DQY9EXj/fqiq0ldnhBBCRM+pp57KpEmTuPjii3nkkUfw+Xxcc801nHjiie22Z1pdfPHF3HHHHVx66aXceeedVFZWcv311/PjH/84mB9z8sknc/PNN/POO+8watQoHnroIWpra0OuM3z4cJYtW8YPfvADLBYLGRkZ3c73rrvu4oYbbiA5OZnTTz8dt9vNt99+S01NDTfffHOnj/vFL37BGWecwdixY6mpqeHjjz+mqKgo/G9UlMQ0kHnllVdYtWoV33zzTbv7ysvLMZvNId0IQY8ey8vLO73mfffdx1133RXtqfYpuzEVuzG123G13gp2Nq8m2zISuzGl589nh3379K0mCWSEECK6FEXhrbfe4vrrr2fOnDkh5dedSUhI4P333+fGG2/kmGOOCSm/bnXFFVewdu1aLrnkEoxGIzfddFPIagzAH/7wB376058yatQo3G53WHmYV111FQkJCfzpT3/illtuITExkUmTJoXkrHbE7/dz7bXXsnfvXpKSkjj99NN5+OGHu32+aFO0vsg2DUNpaSnTp0/ngw8+CObGtK2Rf+mll7j88stDVlcAjj32WE466SQeeOCBDq/b0YpMfn4+dXV1JCUlRfVreOytZSzdsqrbqqVo0TSNfe6tFCbOYIJjTq+utXev3m9mwQKpZBJCxIbL5aK4uJgRI0ZgtUa+ZS4Gvq5+Burr60lOTu729TtmL2ErV66koqKCo48+GqPRiNFo5NNPP+Uvf/kLRqOR7OxsPB5Pu2WzAwcOdFlWZrFYSEpKCnk7UiiKQqophz2ujdR4O1+VCkdaGhw4AC1J9kIIIcSAFLNA5pRTTmH9+vWsWbMm+DZ9+nQuvvji4McmkynkPIitW7dSUlLCzJkzYzXtmEs0pOAJNLOraQ0BrecZ8gkJ4HLpW0xCCCHEQBWzHBmHw8HEiRNDbktMTCQ9PT14+5VXXsnNN99MWloaSUlJXH/99cycOXNAVyxFQ7ppCPvcWxniKSTHMqLH13E4YNs2mDJFTwIWQgghBpqYVy115eGHH0ZVVRYsWIDb7Wb+/Pk8+eSTsZ5WzFnUBBRNYVfTajLMQzH28MiD9HQ94be8HIYMifIkhRBCiH4QV4HM4WdQWK1WnnjiCZ544onYTCiOpZuGcMC9izLXdgpsHfcl6I7FAh4PlJZKICOEEGJgknqVAcqomrGqdnY2rcId6PlpscnJsGOHfj6TEEIIMdBIIDOApZpyqPHup6R5U4+vkZamN8Zr0yxSCCGEGDAkkBnAVMWAw5jOruY1OH01PbqG2awfW1BSEuXJCSGEEP1AApkBLsmQQaO/huLmtT2+Rmoq7NwJh/UeFEIIIeKeBDIDnKIopBnzKG3exEFPWY+ukZoK1dV6BZMQQoiuzZ07t9v2/X3psssu47zzzoub+cRaXFUtiZ5JMCRR6ztAcfNqUk05qEpk8anRCJoGe/boJ2ILIYQYOF5//XVMpp614TgSyIrMESLDNJQy93YOeIp79Pi0NNi1C5p6XgAlhBAiBtLS0nA4HLGeRsxIIHOEMKs2VAzsalqFN+CJ+PEpKVBbK9tLQojY0TRobIzNW6THJ/t8Pq677jqSk5PJyMjgtttuC540/fe//53p06fjcDjIycnhoosuoqLNwXY1NTVcfPHFZGZmYrPZGDNmDAsXLgzeX1payoUXXkhKSgppaWmce+657N69u9O5HL61NHz4cO69916uuOIKHA4HBQUF/PWvfw15TKTPEc8kkDmCpJmGUOEp6dGqjMGgn4Jd3LMFHSGE6LWmJrDbY/MW6Wr0Cy+8gNFo5Ouvv+bRRx/loYce4rnnngPA6/Xyf//3f6xdu5Y333yT3bt3c9lllwUfe9ttt7Fp0yYWL17M5s2beeqpp8jIyAg+dv78+TgcDj777DO++OIL7HY7p59+Oh5P+H+kPvjgg0yfPp3Vq1dzzTXX8POf/5ytW7dG9TniheTIHEGMigkjJspc2xliGYuiKBE9Pi1Nz5NpaNDPYRJCCNGx/Px8Hn74YRRFobCwkPXr1/Pwww9z9dVXc8UVVwTHjRw5kr/85S8cc8wxOJ1O7HY7JSUlTJ06lenTpwP6Ckqrf/3rXwQCAZ577rng7/CFCxeSkpLCJ598wrx588Ka35lnnsk111wDwP/7f/+Phx9+mI8//pjCwsKoPUe8kEDmCJNkzKDKW0qD/yBJxoyIHtva5besDAoL+2iCQgjRiYQEcDpj99yROO6440L+WJw5cyYPPvggfr+fNWvWcOedd7J27VpqamoIBAIAlJSUMH78eH7+85+zYMECVq1axbx58zjvvPOYNWsWAGvXrmXHjh3tcl5cLhc7d+4Me36TJ08OfqwoCjk5OcHtrWg9R7yQQOYIYzM4OOjdR5Vnb8SBjKrqFUy7dkkgI4Tof4oCiYmxnkXvuFwu5s+fz/z58/nnP/9JZmYmJSUlzJ8/P7htc8YZZ7Bnzx7effddPvjgA0455RSuvfZa/vznP+N0Opk2bRr//Oc/2107MzMz7HkcXsWkKEowoIrWc8QLCWSOQAmGJPa6NjPMNhGDEtk/cXq63uW3tlZPABZCCNHeihUrQj7/6quvGDNmDFu2bOHgwYPcf//95OfnA/Dtt9+2e3xmZiaXXnopl156KSeccAK33HILf/7znzn66KP517/+RVZWFklJSX0y9/54jv4kyb5HIIchnRrvAaq9kR+glJSk58js29cHExNCiCNESUkJN998M1u3buXll1/mscce48Ybb6SgoACz2cxjjz3Grl27+O9//8v//d//hTz29ttv56233mLHjh1s3LiR//3vfxQVFQFw8cUXk5GRwbnnnstnn31GcXExn3zyCTfccAN79+6Nytz74zn6kwQyRyCTaiGAnwp35CVIigIWi35kQaTliEIIMVhccsklNDc3c+yxx3Lttddy44038pOf/ITMzEwWLVrEq6++yvjx47n//vv585//HPJYs9nMrbfeyuTJk5kzZw4Gg4FXXnkFgISEBJYtW0ZBQQEXXHABRUVFXHnllbhcrqitnvTHc/QnRdOO7Jer+vp6kpOTqauri/o/0GNvLWPpllVMyhsV1etGQ72vCg2NOWk/wKJGlsXW0AB1dXDhhfpWkxBC9AWXy0VxcTEjRozAarXGejoiBrr6GQj39VtWZI5QdkMqTn8NVZ7Ilwntdr1yQLaXhBBCxDsJZI5QqmLAgJH97u1EuuimKHows3Ej1Nf30QSFEEKIKJBA5giWZMygwlNCg7864sfm5uorMsuXg8/XB5MTQgghokACmSOYTXXg8js52IPtJYMBhg2DDRtg1ao+mJwQQggRBRLIHMEURcGmOtjr2oJf80f8eKsVsrLg66/1KiYhhBAi3kggc4RLMmZQ4y2npgc9ZQBSU/WOv59/DgcPRnlyQgghRC9JIHOE03vK+Djg2d3jawwdClVV8Nln4HJFb25CCCFEb0kgMwgkGlLZ79qOO9Dco8crCowYAdu3w4oV0HJchxBCCBFzEsgMAg5DGg2+6h4l/bYymWDIED3xd/PmKE5OCCGE6AUJZAYBVTFgUAyUuXf06joOh95f5osvoKwsSpMTQggxYMydO5df/OIXYY9ftGgRKX18ArEEMoNEkjGTSs8eGnyR95RpKycHmppg2TK9+68QQgw2l112Geeddx6gV4d29XbnnXcGH/faa69x8sknk5qais1mo7CwkCuuuILVq1cHxyxatCj4WFVVGTp0KJdffjkVFRX9/FUOHBLIDBI21UFzoIEqT2mvrzV8OJSW6isz0ixPCDGY7d+/P/j2yCOPkJSUFHLbr371KwD+3//7f3z/+99nypQp/Pe//2Xr1q289NJLjBw5kltvvTXkmq3X2Lt3L88++yyLFy/mxz/+cSy+vAFBAplBQlEUbIqdva6tPeop01Zrs7z162HNmujMTwghNE2j0dMYk7eenp+ck5MTfEtOTkZRlJDb7HY7X331FX/84x956KGHeOihhzjhhBMoKChg2rRp/P73v2fx4sUh12y9Rl5eHmeccQY33HADH374Ic3NHRdszJ07l+uvv55f/OIXpKamkp2dzbPPPktjYyOXX345DoeD0aNHt3ueTz/9lGOPPRaLxUJubi6/+c1v8LX567SxsZFLLrkEu91Obm4uDz74YLvndrvd/OpXv2LIkCEkJiYyY8YMPvnkkx59L3vK2K/PJmLKYcygxrufWm856eYhvbqWzQZpaXogM26cnjsjhBC90eRtwn5fbH6ZOG91kmhO7JNrv/zyy9jtdq655poO71cUpcvH22w2AoFASJBxuBdeeIFf//rXfP311/zrX//i5z//OW+88Qbnn38+v/3tb3n44Yf58Y9/TElJCQkJCezbt48zzzyTyy67jBdffJEtW7Zw9dVXY7Vag9tht9xyC59++ilvvfUWWVlZ/Pa3v2XVqlVMmTIl+LzXXXcdmzZt4pVXXiEvL4833niD008/nfXr1zNmzJiIv1c9ISsyg4hZteLTPL3qKdNWWpp+qKRs3QohROe2bdvGyJEjMRoPrR089NBD2O324FtdXV2Hj92+fTtPP/0006dPx+FwdPocRx11FL///e8ZM2YMt956K1arlYyMDK6++mrGjBnD7bffzsGDB1m3bh0ATz75JPn5+Tz++OOMGzeO8847j7vuuosHH3yQQCCA0+nk+eef589//jOnnHIKkyZN4oUXXggJpkpKSli4cCGvvvoqJ5xwAqNGjeJXv/oVxx9/PAsXLozSd697siIzyNiNaex3bWd0wjTMqrVX1zIY9Pfl5TByZBQmJ4QY1BJMCThvjU0VQYIpoV+f74orruA73/kOK1as4Ec/+lHI1lZdXR12u51AIIDL5eL444/nueee6/J6kydPDn5sMBhIT09n0qRJwduys7MBgknDmzdvZubMmSGrQbNnz8bpdLJ3715qamrweDzMmDEjeH9aWhqFhYXBz9evX4/f72fs2LEhc3G73aSnp0fy7egVCWQGGYchjf2eXZS7d5JvHd/tkma313PA7t0wY8ahwEYIIXpCUZQ+296JpTFjxvD555/j9XoxmUwApKSkkJKSwt697ft7ORwOVq1ahaqq5ObmYrPZun2O1uu2UhQl5LbW3/WBKHY0dTqdGAwGVq5cieGwFwB7P+YbyNbSIKMqBqyKjbX1S1lT/wG13t7tCyUnQ02NnMMkhBCd+eEPf4jT6eTJJ58Ma7yqqowePZqRI0eGFcT0RFFREV9++WXIStAXX3yBw+Fg6NChjBo1CpPJxIoVK4L319TUsG3btuDnU6dOxe/3U1FRwejRo0PecnJy+mTeHZEVmUEo3TwUl9/JHtd6yj27KLBNZLhtEomG5IivZbNBc7OeJ5OV1QeTFUKIAW7mzJn88pe/5Je//CV79uzhggsuID8/n/379/P8888He8b0p2uuuYZHHnmE66+/nuuuu46tW7dyxx13cPPNN6OqKna7nSuvvJJbbrmF9PR0srKy+N3vfhcyz7Fjx3LxxRdzySWX8OCDDzJ16lQqKytZunQpkydP5qyzzuqXr0UCmUHKarCTZxiL01fDVueXlLm2MdI2haG2IixqZH8BmM1QUgITJ/bRZIUQYoD785//zLHHHstTTz3F3/72N5qamsjOzmbOnDl8+eWXJCUl9et8hgwZwrvvvsstt9zCUUcdRVpaGldeeSW///3vg2P+9Kc/4XQ6Oeecc3A4HPzyl79sl5S8cOFC7r77bn75y1+yb98+MjIyOO644zj77LP77WtRtJ4Wzw8Q9fX1JCcnU1dXF/UflMfeWsbSLauYlDcqqtftb5qmUeerxOmvJs2Ux6iEo8m1jsaomLp/MPrWkscDP/whJB5529tCiD7icrkoLi5mxIgRWK29Kz4QA1NXPwPhvn5LjoxAURRSTFnkWcbQ7K/n27p3+br2bQ569oX1+KQkvQy7srKPJyqEEEIcRgIZEaQqBtLNQ8k2D+eAexdbGr8M63EGA2iaXoYthBBC9CcJZEQ7RtVMsjGLRn8t7kDHLbEPZ7dDcTFEsbJPCCGE6JYEMqJDVjURt7+JJn/H3SYPl5IC1dVShi2EEKJ/SSAjOmRUzfjw0uSvD2t8QoJehi15MkKISB3hNSeiC9H4t5dARnRKQaHRVxv2eJMJOmhSKYQQHWrtBuvxeGI8ExErTU1NQPvOxJGQPjKiUybFQo0v/Aze5GQ9kGlu1hvlCSFEV4xGIwkJCVRWVmIymfq9KZyIHU3TaGpqoqKigpSUlHZHHERCApne8HqguQkawtt+6ZLRCLb+PbSsOxY1EaevGp/mDaunTHKyfu5SZSUUFPT9/IQQA5uiKOTm5lJcXMyePXtiPR0RAykpKb0+zkACmd7Yuxf27oOqxt5fKzERxo8HNX5OXrSqCdT5Kmny15FkzOh2vNGoVy0dOCCBjBAiPGazmTFjxsj20iBkMpl6tRLTSgKZ3gj49fcpKb27jtcLbo/+3hI/gYxJseIJuGjy14cVyMChMuxp00BWiYUQ4VBVVTr7ih6TQCYaevuKbTTqiSU+H1iiM6VoUBQFFGgMswQb9C6/Bw/qxxakp/fh5IQQQgikaik+GAzg9+srMnHGiIk6b0XY4xMTobFRPw1bCCGE6GsSyMSTOAxkLGoidb4K/Jo/rPGKoi8wSRm2EEKI/iCBTDzxxV8gY1UTcAUaafY3hP2YlBQ9kHG5+m5eQgghBEggEz8MBnC5Yz2LdsyqDU+gieZA+CXmSUlQVyddfoUQQvQ9CWTihcEQl0sYqmIgoGkRJfyaTHrKz4EDfTgxIYQQAglk4ofRoDfYC4SXi9KfVMVAgy+y0yATEvQybDlCRQghRF+SQCZeqEbw+fUS7DhjUROo8e6P6HCvlBSoqoLa2j6blhBCCCGBTNwwqHFbgm1RE2gOOHEFwu9gnJgITU1Shi2EEKJvSSATL4K9ZOJvRcaqJuDyN9IUQZ6Mouhf0r59fTgxIYQQg54EMvFCUfT3cViCbVBMBDQ/Tf7IDsdMSoKSEpAjVIQQQvQVCWTiTRxuLYF+XIHTXxPRY5KT9RwZKcMWQgjRVySQiSeqGrfLFxbFRo23PKLHmM167rLkyQghhOgrEsjEkzjtJQP6UQWN/lo8gcjml5goZdhCCCH6jgQy8cRgALcbtECsZ9KOpeWogp7kyVRUQHlkizlCCCFEWCSQiSdGo165FIe9ZEyqBZ/miahyCcDhgOZmWLpUOv0KIYSIPglk4kmwBDtOE34Bp782sscoMHKknvD7wQcSzAghhIguCWTiiarG7YoMgEmxUu+NPHNXVfVgpqoKliyRbSYhhBDRI4FMPFFVPSs2TldkLGoCdb5K/FrkgZaqwogRcPCgHszs398HExRCCDHoSCATd+I7kHEHmiJO+G3VujJTXa0HM2VlUZ6gEEKIQSemgcxTTz3F5MmTSUpKIikpiZkzZ7J48eLg/S6Xi2uvvZb09HTsdjsLFizgwJGeZKHEby8Zs2LFrTXTGGHCb1utOTM1NXrOjAQzQggheiOmgczQoUO5//77WblyJd9++y0nn3wy5557Lhs3bgTgpptu4u233+bVV1/l008/paysjAsuuCCWU+57xpYS7DikKPqPS6SVS+2vowcztbV6MCPnMQkhhOgpYyyf/Jxzzgn5/J577uGpp57iq6++YujQoTz//PO89NJLnHzyyQAsXLiQoqIivvrqK4477rgOr+l2u3G3CQTq63u2DRIzBmNLUzwNvU4ovhgxUefr/ZkDiqLnzOzerQczp54KQ4f2fn5CCCEGl7jJkfH7/bzyyis0NjYyc+ZMVq5cidfr5dRTTw2OGTduHAUFBXz55ZedXue+++4jOTk5+Jafn98f04+e1hLsOK1cMqs26rwVBKLQtE9RYPhwaGjQc2bWrtWTgaULsBBCiHDFPJBZv349drsdi8XCz372M9544w3Gjx9PeXk5ZrOZlJSUkPHZ2dmUd1G/e+utt1JXVxd8Ky0t7eOvIMoMBvD7wBufgYxVTcQVcOIKOKNyPUWBYcP0/OYlS+Df/4a334ZNm6CudztYQgghBoGYbi0BFBYWsmbNGurq6vjPf/7DpZdeyqefftrj61ksFiwWSxRn2M8MBvC1NMWz2WI9m3YsagI1vnIa/XUkGJKick1Fgbw8yM0FpxP27IGtW/XjDQoK9HyaIUPAbo/K0wkhhDiCxDyQMZvNjB49GoBp06bxzTff8Oijj/L9738fj8dDbW1tyKrMgQMHyMnJidFs+0FrLxlffJZgq4oBDa0l4Te623aKoh9p4HDo34L6eti2DTZuhJQUfRsqM1Mf11tmM4waBSZT768lhBAidmIeyBwuEAjgdruZNm0aJpOJpUuXsmDBAgC2bt1KSUkJM2fOjPEs+0Gcbi0BqKg4fdV9+hyKAsnJ+lsgoFc4bdigpw9Fy4QJMGuWvvIjhBBiYIppIHPrrbdyxhlnUFBQQENDAy+99BKffPIJ77//PsnJyVx55ZXcfPPNpKWlkZSUxPXXX8/MmTM7rVg6YigKeOOzlwzo20vV3nI0TUOJxvJIN1QV0tL0t2hxuWD9er2fzQknSMWUEEIMVDENZCoqKrjkkkvYv38/ycnJTJ48mffff5/TTjsNgIcffhhVVVmwYAFut5v58+fz5JNPxnLK/cNggGZXrGfRKYuaQFOgHo/WjEVJiPV0esRqhTFj9Hycd97RV2YmTNCDJiGEEANHTAOZ559/vsv7rVYrTzzxBE888UQ/zShOGOK3KR6ARU3E6amh0V+HRR2YgQzo3+aRI6GiQu9lU1UFxx0XlznWQgghOiF/f8Yjg0FP9vXHZ56MUTHh07y97vAbL7Ky9Iqpb76BxYuhsvf9/oQQQvQTCWTiUWtTvDg9PBJAURScvtpYTyNq7HYYPVrvNPz227B9uzTmE0KIgUACmXhkNOqdfeM4kDErNmp9nTcmHIhMJj2Ycbv1lZkVK/S+NkIIIeJX3JVfC9r0konPrSUAi2qjwVeNN+DGpA7gBoSHURS9gqm2Fj77TC/5HjNGz6XJzdVjTCGEEPFDfi3HszhekbGoidT5Kmjy15OsZsZ6OlGXkqL3l6mpgZUrYfVqPZAZN07vNpyaGusZCiGEAAlk4peixHUgY1IseDQXjf46kk1HXiAD+sJYerr+5nbrVU1LlugBzogR+jbU0KF6l2AhhBCxIYFMvFLVuC7BVhQFNGgO1Md6Kv3CYtHPe2o9OmHTJn3bKScHTj1Vr3wSQgjR/ySQiVcGA7jjtykegEm1UOs9EOtp9Ku2Ryd4vbBzJxw4IIGMEELEilQtxSujATxeCETxcKEos6gJ1Pkq8WvxO8e+ZDLp8WZDQ6xnIoQQg5cEMvFKNbb0konfyqXWPBlPoDnWU4kZi0VPCBZCCBEbEsjEK2NLUzxffCf8+gKeQR3IWK1QXa2f0C2EEKL/SSATr1Q17rv76kcVePBogzeQsVj0k7SbB++3QAghYkoCmXilKPr7OA5kFEVF0zTcg3xFxuWCpqZYz0QIIQYnCWTiXRx39wVAYVBvLZnN4PFAY2OsZyKEEIOTBDLxzGDQ/9yPYyoqzYHBeyBR68KZBDJCCBEbEsjEswEQyBgVM02+ulhPI6YURQ6XFEKIWJFAJp4ZDOD1xHUvGaNipslfh6ZpsZ5KzJjNcPBgrGchhBCDkwQy8cxgAJ8/rvNkWnvJ+DRPrKcSMxaLflr2II7lhBAiZiSQiWcGQ/yXYKtmvJp70FcuNTXF/S6gEEIckSSQiWcGg95pLa5XZMx6U7xB3EvGatXP95SEXyGE6H8SyMQzRdH3K+J4RcagmPBrvkFfgi2BjBBCxIYEMgNBHK/IAIO+l4yq6vGmBDJCCNH/JJCJd4qi/7kf5wZzjkwrKcEWQoj+J4FMvDMa4z6L1IiJJv/g7iVjNuuVS0IIIfqXBDLxzmDQV2S0+D1e2aiYaRzkgYzVKr1khBAiFiSQiXetJdhxnCdjVM00BxoIxHGw1dcsFinBFkKIWJBAJt4ZjXEfyJgUCz7NM6gTfi0WOQVbCCFiQQKZeKeq8d8UT3rJSC8ZIYSIEQlk4l1rbW9cBzKmQd/dV0qwhRAiNnoUyPh8Pj788EOeeeYZGhoaACgrK8Mp9ad9J463llTFgIY2qLeWQAIZIYSIBWOkD9izZw+nn346JSUluN1uTjvtNBwOBw888ABut5unn366L+Y5uCkKuOP7UEaFwd0UD/QS7JqaWM9CCCEGl4hXZG688UamT59OTU0NNpstePv555/P0qVLozo50cJoAHe8l8MouAKDeznCYpFARggh+lvEKzKfffYZy5cvx2w2h9w+fPhw9u3bF7WJiTYMrU3xNPS1j/hjUiw0+mtjPY2YslqhoQE8Hn11RgghRN+LeEUmEAjg9/vb3b53714cDkdUJiUO01q5FMd5MkbFPOi7+0rlkhBC9L+IA5l58+bxyCOPBD9XFAWn08kdd9zBmWeeGc25iVZGI/h94I3vQMYdaMYbiO9cnr7U2ktGAhkhhOg/EW8tPfjgg8yfP5/x48fjcrm46KKL2L59OxkZGbz88st9MUdhMIDPDz4vYOt2eCyYFDONgTo8WjMmBue+isEAgYAEMkII0Z8iDmSGDh3K2rVreeWVV1i3bh1Op5Mrr7ySiy++OCT5V0TRQOglo1rw+fTuvomG5FhPJ6YkkBFCiP4TcSADYDQa+dGPfhTtuYjuxPHWkgEjPryDuike6LuAdYM7VUgIIfpVxIHMiy++2OX9l1xySY8nI7qgKOCN3/wTRdGrqQZ7Lxk5BVsIIfpXxIHMjTfeGPK51+ulqakJs9lMQkKCBDJ9xWAYEEcrD+bzlkBP+G1o0HcBTaZYz0YIIY58EVct1dTUhLw5nU62bt3K8ccfL8m+fclgAJc71rPokgEjTb76WE8jpiwWvQRbTsEWQoj+EZVDI8eMGcP999/fbrVGRJHBoFct+eM3T6a1cmkws1qlBFsIIfpT1E6/NhqNlJWVRety4nAGg94UL84rl5r99QS0QKynEjNGo/7PJIGMEEL0j4hzZP773/+GfK5pGvv37+fxxx9n9uzZUZuYOIzRqHf29XjAGp9l7kbFjEdz4dVcWJSEWE8npiSQEUKI/hFxIHPeeeeFfK4oCpmZmZx88sk8+OCD0ZqXOFxrLxl3/ObJmFqOKXAHmrGogzeQMRikBFsIIfpLxIFMIDB4tw1iTlGgOX6rgoyKGZ/mGfQl2HIKthBC9J+o5ciIfmAyxfWehaoYCBAY9IGM1Qq1tXqujBBCiL4V1orMzTffHPYFH3rooR5PRnTDZNK3lnxeMMZvk5LB3t3XaoX6ej3mTEqK9WyEEOLIFlYgs3r16rAu1trdVfQRk0mv7XW74zaQUVFwBwZ3E5W2p2BLICOEEH0rrEDm448/7ut5iHC0lmC7XJBoj/VsOmRQzDT5a2M9jZgymfQq+TjeBRRCiCOG5MgMRHFcuWRUzDT6pWRHUSSQEUKI/tCj06+//fZb/v3vf1NSUoLHE3qQ4euvvx6ViYlOGI3gdMZ6Fp0yKWbcgSZ8mhejEp/bX/1BVfUzl4QQQvStiFdkXnnlFWbNmsXmzZt544038Hq9bNy4kY8++ojk5OS+mGPc8Xj9PPLmJ7y6Zy07tSp8nZSk+wIBVtSWsrhqMytqSzscFwjA7gM2Nuyxs/uAjY4uFTKmPpVAkwsC/vZj9sCGDfr7WFXJGxWLlGAjp2ALIUR/iXhF5t577+Xhhx/m2muvxeFw8OijjzJixAh++tOfkpub2xdzjCu/Xvg6D226Eb99L6QBabCx6UNmOL/Lqeljg+M+PLiNFfb/oKVXH7qtKS1k3ObSRJaszqKh+dDKhcPmZd7UCoryGzsfY3UzT/VRNNmgj9kCS94PXQFwOGDefCga1xffhc6ZFDP1ATfuQDMJhsGb6Wqx6E3xAgF9dUYIIUTfiPhX7M6dOznrrLMAMJvNNDY2oigKN910E3/961+jPsF48uuFr/OnPd/Fn7g35HbNVs1XmX/lw4PbAD2I+Srzr2i26k7HbS5N5LXleTQ0h8aSDc1GXluex+bSxM7HuMy89l8zm7foQcxr/2m/jdHQoN++eUuUvvgwGRQTPryDfkWmtXJJTsEWQoi+FXEgk5qaSkPLq+aQIUPYsGEDALW1tTQdwb+1PV4/D226EdDg8Crzls9X2F/D7fexwv6fkNs7Gvf+mgy6GrRkdRZLVmd1PeZ9/a0rS5b07zZTawn+YA9k5BRsIYToHxFvLc2ZM4cPPviASZMm8b3vfY8bb7yRjz76iA8++IBTTjmlL+YYF5585zN9O6nV7hMgbWfIGA34k+8xwAoNefqNASOsvwhWX0ZrAKIBzqZ08Fs6fb5w8kQ7HGN0Q9YGsNTrY+qhpBSGDwvjgtGiaXi0wR3ImM1Sgi2EEP0h4kDm8ccfx+VyAfC73/0Ok8nE8uXLWbBgAb///e+jPsF4sfPA/vY3JpWF9+AT7tcDi8V/Ac0Q3YkdzmuHktmQsxoc5QA4+7l6RlWMNPmlZAckkBFCiL4WcSCTlpYW/FhVVX7zm99EdULxalR2LpS3uSF5D5RPajcuq+5YKpK/PnSDpR5S9sCxT8LEV+DgGD2Y+fanUDMyupPUFKgeC02ZsP8Y8GyBtO3YHdF9mu6YFMugb4oHei8ZKcEWQoi+FXEgc+qpp/KjH/2ICy64gKRB1H/9mrNO4FdfDMWfuA8UDVJLQgdooDSnc2naGP7se0NP9D08tSWhGmwroDkVu5qA01ZN+0H6xRw2H0BLom8nYxIDoBpCXyxtK6ByPNSOhIPjMGoOcrPWAv13gqFRMdPkr0fTtEF9bIWcgi2EEH0v4mTfCRMmcOutt5KTk8P3vvc93nrrLbxeb1/MLa6YTQZuHv+o/ol22Iuzpr+b4VyAxWBkhvO7IbeHjFPAZtY4YZpe4YTih6z1MOxT/b2iBxzzplYwb2pF12NmOZk3/7DnUDTI2ghZa4EAvuoh/OO+WdRXW/ut14xJNePV3Hi1+O1A3B+sVqiujl1PHyGEGAwUTdMOf7ntViAQ4MMPP+Sll17ijTfewGAw8N3vfpeLL76YE088sS/m2WP19fUkJydTV1cXlRWkkD4yLZSmdGY4F3TcRyahTQl2czJmsw+PoRGHlsTw6tPYYPs4ZIxyWK+Zjq6jNKUxo/JsTh11DBQM67iPTBJMLUznm7em0+w0Y7W7UId+Q1Og9tCYPuo14w400eA7yAlpP8BhTOv+AUeo+nq9/PqiiyAxMdazEUKIgSXc1+8eBTJtuVwu3n77be655x7Wr1+P399/WxjhiHYgA3op9pPvfMbrH79OjfMAZ+dOx9hB1zNfIMDK+n1U+5ykGe1MSxpCo1rPK+qzVCoHDq3YtF3gabltQeASAF5TX+x8jO9HFBVeCOh/9ZeU6om9dgcU5OuN2Goqbfz9vmOpr0rSV3Ky10LSvpB5LvhudIOZgObngGc3x6d+j3TzkOhdeIBxu2H/fvj+9yErq/vxQgghDgn39btHZy21Ki8v55VXXuEf//gH69at49hjj+3N5QYMs8nAL86bi2HXTpZuWtVhEANgVFVmpOSH3JZMCj8K/Jy/qP+HX+kg6FMADZaob4Xe1uGY/1LoPRfVZEFVOy6xTk5vJjD0C2ieCo05UH40uB2QsSV43SVLoHBs9DrQqoqBAH7cg7yXjNkMHo9ULgkhRF+K+KWrvr6ehQsXctppp5Gfn89TTz3Fd77zHbZv385XX33VF3M84lRS3nEQ00qBBqWOBqWu4zzf1jGGekoa1nb5XCWl4GzyQd43kLpdv7FmDFROCI5p7TUTVRqDvpdMa57zEdwnUgghYi7iFZns7GxSU1P5/ve/z3333cf06dP7Yl5HNCf10buWu7Lr+1vzZhQgcwuYnXBgql7VZG6AlJLQcVGiKOD2yyu4osT1YeVCCDHgRbwi89///pe9e/fy8MMP9zqIue+++zjmmGNwOBxkZWVx3nnnsXXr1pAxLpeLa6+9lvT0dOx2OwsWLODAgQO9et5YsxO9snW7LwGAAH52N69ng/NTdjevJ9BSbt2uh0zyXkhvOYCpYhI0pXc8rpcMmGgM1EX3ogOQxSKnYAshRF+KeEXmtNNOi9qTf/rpp1x77bUcc8wx+Hw+fvvb3zJv3jw2bdpEYkuZx0033cQ777zDq6++SnJyMtdddx0XXHABX3zxRdTm0d8KGIlDS6aBTraONHCQDND5mJZx+93baHSa+PDg8zT4D71iOgzpzMu4msL8WTgchzVmS9sOHgc0DIGy6SROWEZBfnS3gUyqhSa/BDJmM9TWgqYd2moSQggRPb1K9u2t9957L+TzRYsWkZWVxcqVK5kzZw51dXU8//zzvPTSS5x88skALFy4kKKiIr766iuOO+64WEy711RU5gXO1SuSWnrLBLVUJM0LnAvQ5RgUWKq8AxXvtHuOBv9BXjtwPwuyf8O8+bN47T9t7lSA7DXgSQR3Cob9x+J1f4GlpQlfNBgVC25/I37Nh0GJ6Y9ZTFmteo6MywU2W6xnI4QQR54o1alER12d/hd86zEIK1euxOv1cuqppwbHjBs3joKCAr788ssOr+F2u6mvrw95i0dFTGZB4JLgyksrByksCFxCEZO7HHNB4Mec5T2/fdO9wyypeo7CcX4WfFfvGxOkBkgs/Aar3UV9VRJvPjU1qo3bTIreFM8TcEXvogOQ1aqXYUvlkhBC9I24+VM5EAjwi1/8gtmzZzNx4kRAL+82m82kpKSEjM3Ozqa8vLyDq+h5N3fddVdfTzcqiphMYWAiJezCST12kihgJGqb+LKrMbvVHZ1vO7Vo8FdR0ryJonGTKBx7eK8ZF/uLv+HFe2exfU0On7w6jpO/vyUqX5tRMePVPHgCzdgM9qhccyAymw8FMhkZsZ6NEEIceeImkLn22mvZsGEDn3/+ea+uc+utt3LzzTcHP6+vryc/P7+LR8SWispwRvdoTLjVT06/3hW4o14zQ0bVcs6Va3nz6aNZ/s4YMoY6mThzb4fN9SJhVEz4Ne+gL8FWVT0/RlZkhBCib/QokFm6dClLly6loqKCwGH7EX/7298ivt51113H//73P5YtW8bQoUODt+fk5ODxeKitrQ1ZlTlw4AA5OTkdXstisWCxWCKew0AUbvWT3dD1MQETZ+2jcp+DL94ew/+em8yHnzhp0mqD9/fkKANFUdE0DXdASrBVFXbtgmHD5KgCIYSItohzZO666y7mzZvH0qVLqaqqoqamJuQtEpqmcd111/HGG2/w0UcfMWLEiJD7p02bhslkYunSpcHbtm7dSklJCTNnzox06kecAkbi8Du6zJNxGDIosI3v9lpzF2whd2w5Ab+Bph3HgNcavK+hAV77D2zuwa7TYO/uC5CfD5s3w/vv6xVMQgghoifiFZmnn36aRYsW8eMf/7jXT37ttdfy0ksv8dZbb+FwOIJ5L8nJydhsNpKTk7nyyiu5+eabSUtLIykpieuvv56ZM2cO2IqlaFJRmec7h9fML3U65rT0K1AxdHstDWhIWAXm2eBJhrJjIf8LUA91II70KANVUXH5o9xpbwCyWGDUKH1VxueDk06CzMxYz0oIIY4MEa/IeDweZs2aFZUnf+qpp6irq2Pu3Lnk5uYG3/71r38Fxzz88MOcffbZLFiwgDlz5pCTk8Prr78elec/EhSpU1jQsACHevj2kZ4F3OALrxubfpSBH4Z8AwY3uJNh91yoHg0+s36tNkcZBAKwew9s2KC/76jiyaiYcUovGQBMJhg9Gvbu1VdmyspiPSMhhDgyRLwic9VVV/HSSy9x22239frJwzl422q18sQTT/DEE0/0+vmOSKpKkWsshYnzKbFX4vRXYzekcdC7l8VVT/Fxzd8ZnTC921Oog0cUmJr1c5n2HQu+BKgqgqpCsJdD8h4a6qvYvAWWvB/aZK+jPBqjYqbZX4+maSjSDQ6DQV+Z2b0b3nsPTj4Zhg+P9ayEEGJgiziQcblc/PWvf+XDDz9k8uTJmEymkPsfeuihqE1OhElRUJs9DM+cFLxpmHUiWxq/pLh5DW9XPsolefehKp1vMYUcUWCrgZEfQkMu1A0DVxo488CZx/vPNOIy74GkUjB6gg9pzaNZ8N1DwYxJseDV3Hg1N2bFitC35UaMgNJSfWVm7lwoLIz1rIQQYuCKOJBZt24dU6ZMAWDDhg0h98lf3TFiMkFj6MmEiqJwdub1PFN6HXvdW/i67r8cl3J+p5coyCf0KAPVr5/LlLwX3ElQWwANQ3HVJwLjoWoc2PdD+jawHHrutnk0JtWCy9+IJ9CMWZVAppWiQEGBvr304Yd6n5lJk+QIAyGE6ImIA5mPP/64L+YhesNo1F8NfV4wHlohSzZmclr6lbxT9Tgf1/yD0QnHkGEe2uElVFXfGgo5yqCVpR6yNzD7/M18sTgPaoeBOxWcQ6A5XV+9UfRtwtY8muHDWpriBdx4tMHd3bczeXlQWQkffaQfYTB9euT9eoQQYrDr1a/NvXv3snfv3mjNRfSU2Qxerx7MHGaK4zRG2qbi17z8t/IRdjWtbXdCdquicbQ/ygBwJOm3Z2b5IbkUhn0OBZ+CwQV+KzhDe/q05tsYFCMBzYdHSrA7lZkJaWnw2WfwzTexno0QQgw8Ea/IBAIB7r77bh588EGcTn1LweFw8Mtf/pLf/e53qPInZf8zGMDv1wOZxNDjAFq3mJ4s/Tll7m28VH4oSbv1hOyixENVaEXj6OAoA32lYPeeNhe21kNyCVSP1fNoHPuDd4Xk26BIINON1FRobtbLs2fMiPVshBBiYIk4kPnd737H888/z/3338/s2bMB+Pzzz7nzzjtxuVzcc889UZ+kCIOi6PsTHdjn3oZPa79a0/aE7LbBTEdHGUAHeTTJJVA9BpoywZMA5iYcSfq4Q/NCuvuGwWbTgxmPR19gE0IIEZ6Il09eeOEFnnvuOX7+858zefJkJk+ezDXXXMOzzz7LokWL+mCKIiwGQ4cH+gTws6Tq2S4fuqTquXbbTB1pzaMJMjVDQqX+cX0BAPPmheZ5GDHRKL1kutV6uGSTxHxCCBGRiAOZ6upqxo1rf+jOuHHjqK6ujsqkRA+YTNDcBIHQgKSkeRMN/q6b4rWekB2Odnk0ySUAKA35nH++0u48JqNiptFfG9a1BzOLRQ9kmmUXTgghIhJxIHPUUUfx+OOPt7v98ccf56ijjorKpEQPmEzgaZ/w23rydXfCHQd6MHP99fCjH8N3LirHmuhG81oxurLbjTWqZlx+J36t+xWfwcxo1NOcZEVGCCEiE3GOzB//+EfOOussPvzww+DBjV9++SWlpaW8++67UZ+gCJPBoB/k43aDLSF4c3cnX7fyBA7l1wTwU9K8KdgluMA2vt15TcE8mmEalXNL+fKd0az+pIDCaeUh40yKBZfWiDfgwmCQo5+7I4GMEEJEJuJA5sQTT2Tbtm088cQTbNmiH4d8wQUXcM0115CXlxf1CYowtSamHLYiU2Abj8OQ3u320uKqp6jx7ifLMoKPDi4KGd9RdVNbU08s4ct3RrNjXRZ1VTaSMw7tj5gUC3W+Smp85eQaRvXwixscFEUCGSGEiFTEgUxJSQn5+fkdVieVlJRQUFAQlYmJHjAY2r0SqhiYl3E1rx24v9OHDbGMY597C1/WdXwYZ2fVTa3SchoZVlTFns0ZrFmWz4kXbAveZ1ItGBUTm51f4DCkYTem9vCLO/KZzVBTE+tZCCHEwBJxjsyIESOorKxsd/vBgwcZMWJEVCYlesho1CuXtNCjqIsSZ7Eg+zc4DOkhtzsMGSzI/g2XD/kj38v+LUo3Pw5dVTdNnas3mVmzrKDdSdgZpqHUeSvY3PgFPs0b4Rc1eJjNUCcFXkIIEZGIV2Q6O8nY6XRitcp5OjFlMoPHrSf9WiwhdxUlzqIwcUanuS8WNRGNQEdXDWqtbhpum9TuvnHTyrElemiotrFzXRZjplQE71MUlSzzcEqbN+MwZDDOflwUvtgjj8Wix6Fer567LYQQonthBzI333wzoHeKve2220hIOJRQ6vf7WbFiRfAwSREjJqN+eOSBA2Bqf9K1CgwnDUiDhESwHRrT2+omoznA5ONLWfH+KFZ/MiwkkAF9iynFmM32pm9INmWSa5F8mcO1rsg0NUFycqxnI4QQA0PYgczq1asBfUVm/fr1mNu0HzWbzRx11FH86le/iv4M45Hfrx+Os3WbHjgEAh2f9hcIQGUVuJrBaoPMjPbjwhkTLlUFowHK9nU9TtP0V82CAv2wH5Swq5u6Gjd1bgkr3h/F9jVZNNRYcKSGJh7bjam4PE42NXyO3ZCKwxjecw4Wrb1kJJARQojwhR3ItJ56ffnll/Poo4+SlJTUZ5OKa6+/DjfeCHv3QsEkyE2Bzbth6lTIb9Obv7QUVq8O7XBms4WOC2dMpJLCfAVsbNQP9/F4IDc3rOomhyGDAtv4Tu/PGOJk6Jhq9m5PY+1nBRz/ne3txqSbhlDm3s5m5xdMTZqPSZV+/K1MJn1bSZriCSFE+CL+03/hwoWDO4j57nf1IKat5mZYvlwPTEB/v3x5+1ektuPCGdOXEhP1oKllLqpfY17G1V0+ZF7GVe36yRzu6JNakn4/zT885xjQ82WyzSPY69rCzqaVaJrW4y/hSCQl2EIIEZmwVmQuuOACFi1aRFJSEhdccEGXY19/veMS3gHP79dXYrp64V29GvLy9Pdd6e7+1jFDhvR8mykcNhuoBigrA5+PooLpLMj+DUuqnm23MnN8yvc77SPTVtEx+3n/HxOprUykeFMGIydWtRtjVM2kmnLY3vgNScZM8qyjo/YlDXQSyAghRGTCCmSSk5ODlUrJg3Xz/rPP2q3EnHRwL4XNlaR62pQkv1IBB7tuPteRTfZUdiS2+d42N+u5M9lZPZ1xeCxmMKRARQV4vRQNn0rhsOeC1U1bnF+ypWk5xc1rOFG7qMOKtbZMFj+TZu3l2w9HsPqTYR0GMgCJhhSa/U69v4wxTfJlWphMUFsb61kIIcTAEVYgs3Dhwg4/HlT2729308TGGiYefuB0XfseO+GY2FDN/aOmEmgbKLj6KVnCaIS0NKiphh1+1OHDGG7XS6yHWyezo/Rb9rm3srN5JaMTpnd7ualzS/j2wxFsXZlDY72ZxCRPh+PSTUPY79nOJufnHJ00H5Nq6XDcYGKxSFM8IYSIRMR9ZIqLi/H5fIwZMybk9u3bt2MymRg+fHi05hZfcnPb3fRlcjY7HVZymn2h4zoIeroyq6achICf/GYnexIch+6w2no628ipKqSm6csBO3bA8OGQkordmMr0pLP4qu4NPq1+iVG2ad2uymQX1JM3soayXal88nY+w47aid0BBfmhO2WKopBlGs4+11YcxnSKEmd1e+0jndmsby1JLxkhhAhPxIHMZZddxhVXXNEukFmxYgXPPfccn3zySbTmFl9OOAGGDoV9+4J5Mt8mZ7E0N4VJNS0HLtpscNZZ8M47XZee2FoClJYxGR4XUxoOMrax9lAgY2spxe5PqgqpqVBfDzt36jk6iYnMtJ/DyvrF7PfsYFvTCgoTu29olzOuhLJdqaz+qIDVu3aCAg4HzJuvn57dSs+XyWVn0yoyzQVkmntYrXWEsFj0XjLNzRLICCFEOCLOJF29ejWzZ89ud/txxx3HmjVrojGn+GQwwKOP6h93tmowdao+burUrq81dWrImG0tuTFjG+tCx/Rlom9nFEVvYmIwwO7dsGkTiZtLOcann3S+rPLvaE1OCHR8VAHA5i2wats+UHzgtUOzfjRCQwO89h/9/rYSDcn4NA9On+ypWCx6Rbwk/AohRHgifqVUFIWGhoZ2t9fV1eH3d/7idkS44AL4z3/0lYq2bDaYNetQ75f8fP1zm63zcW3G7EhMJgDkeJpJMqih14qVxERITw8GNcc1TMMcMHMgUMqW7a/Dhg2wayeU74fKCjhYBbU1BGrrWPKeH1QfJLU05qsLPUh0yRLancekotLkr+2fry2OtfaSkUBGCCHCE/HW0pw5c7jvvvt4+eWXMRj0niJ+v5/77ruP448/PuoTjDsXXADnnqtXMb28GOrLYdTE9qsn+fl6wNNV196WMc2VVZTWlzOscj9jRgxlZayDmLYMBjAYSLDmMIMT+YwPWJb4GYXOCagHD+rVTm2U1CTR4Jygf5K8B+qGgTMXnGVgPwBAQz2UlMLwYYceZ1Zs1Pk6rnAajKQpnhBChCfiQOaBBx5gzpw5FBYWcsIJJwDw2WefUV9fz0cffRT1CcYlgwHmzoVVO2GTs/MtIFXtvny6Zcz2CUcx7JP9jN25lZXTZkZ9ytEwQ5vDN9rnVKoH2GzfwQSt/Raa02k/9ImlDhLLoTEHyo6BjE2QugsUcO7YD1YVEmxgs2FWrTT56/BpXozK4E4OURS98bIQQojuRby1NH78eNatW8eFF15IRUUFDQ0NXHLJJWzZsoWJEyf2xRwHhW2j9QzYUcXbMfh83YyODSs2ZmgnAvCpsoRdbGMDq9jNDgItJ2fbrW22FxUg71tI3q1/UjUBDhwFmoLdVwfFu2DTJtiwAfOe/Xiaa3H5nf3+dcUbo1FP+BVCCNG9iFdkAPLy8rj33nujPZdBrTwnjwa7A4ezgWGlxewaMab7B8XAsdrxfKl9RLVSyUuGvwZvd2jJzAucS2HmZBw2Lw3NRkABRYOs9WBugMqJUF+AwW8jI6sE7KreMdnjxnSgBo8aoDnbiZ3U2H2BccBikaZ4QggRrh4FMrW1tXz99ddUVFQQOCxr85JLLonKxAYbTVHZNmoc09Z+w9gdm+M2kNnFNjy0b3DXQB2vqS+ygEuYNzWR15bnARp6MAOk7gazE/ZPx9+YyaJFF/GD779BWno1JfXpOJ1puL1baczbT2Z2HOUIxYDFom8tSS8ZIYToXsSBzNtvv83FF1+M0+kkKSkppIGZoigSyPTC9tEtgcz2Lbx32ndiPZ12AgRYor7V8Z0KoMES9b9cnz+RBbPKWLI6i4bmQ6/Ejoz9HHfM63zzyXxqa1J47vmLMA39hmZTS9l1mpsvlvm4ZoFeuDVYWSx6Kx/pJSOEEN2LOJD55S9/yRVXXMG9995LQkJCX8xp0Noxcix+RSXzYAWpNQepSU2P9ZRClLCLBqWL5A0FGqilhF0U5Y+mcEgxJZU2nC4DdqufgsxmVBUmjnyJF/9xPgcrcvEVz4bMDfqKjd9CvVbD/fdr/OY3yqANZsxmcLv1EuzBetC8EEKEK+Jk33379nHDDTdIENMH3FYbJQXDARizY0vXg2PASX1E41QVhmc3M3GYk+HZzcHiLputGXf2CkgqARSonAQHJkNjOiRUgxLguef09BnQ369fD59+qr/vrF1ROOPCvVYstfaSkRJsIYToXsQrMvPnz+fbb79l5MiRfTGfQW/b6CJG7NnF2B2b+fqY9h2UY8lOeMsD3Y0rqbThdBsge62eN1NVpPebqRuml2urXqqqDGzapHcDfvbZ0APF09Ph6qtDt5+WL+9+XDhj4kHrbq00xRNCiO5FHMicddZZ3HLLLWzatIlJkyZhOmwT/zvfib/cjoFk2+hxzF/6DiN378Do9eKLoySJAkbi0JJpoE7PiTmcBg5SKKDrINfp0hspogBpO8HSANWjoTlN7znT4s9/7vgk6IMH4f774Te/0QOQ5cv1z7saB92PiadgBmRFRgghwhFxIHP11VcD8Ic//KHdfYqiHPnHFPSxiswcapNSSKmvZfienewYPa77B/UTFZV5gXN5TX0xWJAUpJ+jybzAd1C72bEM6TUDkFihv/ksEDDC3pngs3UYxLT1+ON6mfLf/971uMce6/p+gOeegxkz9F6H8cBkkhJsIYQIR8Q5MoFAoNM3CWKiQFGCzfHGxmGeTBGTWRC4BAfJIbfbSWZB4BKKmNztNQoym3HYvASjn1ZGN+SuhozN2M2ubq/jdMLTT3ffBbexsfsxVVV6b754Ib1khBAiPDE4Xll0Z/voIgAKd2wGTetmdP8rYjLXB37HRf6fYND0JYwfBq4KK4gBPQl43tTWM5oO+/r8RrBWc/K4/WFdKzs73Fl3r7o6etfqLYtFD9TitMmzEELEjYi3ljraUmrr9ttv7/FkhG7XiNH4DAbSag6SXl3FwfTMWE+pHRWVkYxlCMMoYRf7lVKytdywH1+U39hhr5lEo4lTT17Psa5c/ruu++ucfTY8/3xPvoL27C3HRPn9+upMdTWkpcH48f2/5WQ264nOzc3gcPTvcwshxEAScSDzxhtvhHzu9XopLi7GaDQyatQoCWSiwGO2sLtgJKOLtzN2x2a+jMNAptUQrYASZRf7KGEKx0b02KL8xna9ZtIyKwioXkb7q0lPbOZgo5WOM4shIwPOPBPefDO0Eulw6S3teLoaA/DMM3DSSbBkSewrmywWfburqUkCGSGE6ErEW0urV68OeduwYQP79+/nlFNO4aabbuqLOQ5K21q2l+IxT6atIdowAMqUkh49/vBeM1bVjBcPXrWZq+ftaRnV8fbaVVfpSbEt+eeduvrq7sc4HFBeDi+/3D7gaa1sWr48vK8pGqSXjBBChCcqOTJJSUncdddd3HbbbdG4nEA/rgBg+J6dmD3uGM+mc3kUAFDBfjz0fp4mzHjw0EwTsybU85vTVpLuCD3bKSMjtFx61iz98/TDGiG3HdfdmKef1ldButK2SV9fk14yQggRnh4dGtmRuro66uq6aF8vIlKVnkl1ajppNQcZWbyDLYUTYj2lDiWRrPeWUerYz16GMapX11NatpFc6EsRs452MyP/fTalHk81aZ3mrMyapZdPd5Xb0tWY9ev1YwG60lrZNGlS/+XRSCAjhBBdiziQ+ctf/hLyuaZp7N+/n7///e+cccYZUZvYoNdShn3cN18wZsfmuA1kAIZQwBbWs08pYZjWu0AG9GDGSYP+icmEQdGYlLADpk0neM5BBwwGPcjoSmdjwq1Yqq7uvw7BJhPI3wZCCNG1iAOZhx9+OORzVVXJzMzk0ksv5dZbb43axATBQGbsji16GbbScdJrrA3RCtiirNfzZKJQLW7GQoNSe+haaWlQfkCPHDL7JvE5LS28cf/4Bxw40P72vugQbLF03NlYCCHEIWEFMuvWrWPixImoqkpxcXFfz0m0KB42Gq/RSEp9LVmV5VRkhV/e3J/yND1PZh89S/g9nBkzjTjx48OAUX9F9/uhtFRPaumDgG78eH1VpbvKpo6CmLai2SHYbNZ7yfj98dNxWAgh4k1Yyb5Tp06lqqoKgJEjR3Kwu9/2Iip8JhO7ho8G4rt6KZehKJpKg1JHPbW9vp4ZC27cNNOmZCc1Ffbv199qarp+a448scRg6L6y6dxzu79ONDsEWyx63o5ULgkhROfCWpFJSUmhuLiYrKwsdu/eTSAQ6Ot5iRbbRhdRuGMLYzet4/MhI8Fqg8yMLnNF+psZC1nkcIAy9lFCEim9vJ4ZL25cNGGnpYmKzab37F+5svsL2O0weXL7EqVutFY2HZ7/kpGhl3p7veFdJ1odgs1m8Hj0hN/WZn1CCCFChRXILFiwgBNPPJHc3FwURWH69OkYOlnr3rVrV1QnONhtT9TPNCrYX4rli89xG4z6i/rUqZCfH+PZHTJEK+CAUkaZUkKRFt5RBZ1RMRBAC1YuBeXkhFf/fPCgHvBMnqw/JgLdVTaFI9x8m+60DWSEEEJ0LKxA5q9//SsXXHABO3bs4IYbbuDqq6/GIe1G+15pKTXrN1JptpLpcTGqqZ5NjjR9r2H5cv1VN06CmTwKWMVX7ItSwq8CNHHYK7iigDGMH9nsbKiqhNWrYeLEiL9HnVU2hZNHk5Ghj4uG1lQg2VoSQojOhV21dPrppwOwcuVKbrzxRglk+logoL8QA9sSk8n0uBjbWKcHMq1Wr4YhQ+Jim2lIS8LvfkoJ4Eeld9mpRkw4lbqeB0UZmXq+zJo1+rLGyJG9ThJuzaO5//7Ox1x1VfQTc2VFRgghOhfxK+DChQsliOkPlVXBP8W3JejbS2Mb60JPw25u1sfFgQyysGhWvIqXCsp7fT0zFuqpQ+vN8k5qqr4Nt2EDbN0alba8nXUIttmiW3rdymiE+vroXlMIIY4ksf9TXnTMdWg/YY/NgVtRcfi9DHE1djoulhRU8tC3cPb18NyltvTKJRduXL27UFKS/rZ5s/7m8/V6brNm6WXW99yjH1oJ+m5WXxwqKb1khBCiaxLIxCurLfihX1XZ1pL0O95Z0+m4WDvUT2ZPNyO7Z8aMBxfNh+fJ9ERiop6Bu32bnrHr8XT/mG605tFcdJG+Y7V7d/c9aHrCbIaGhv4740kIIQYaCWTiVWaGvl/RYrM9FYDxztpD20u2llLsONGaJ9PTk7DbMmLChy86gQy0fK8yobgY1q6JWgZtUhKMGaN/3JLSFFXSS0YIIbomgUy8UlW9xLrFtsQUfIpChtdFpqdlu2Xq1LhI9G01pOUk7Coq25dO94gSpeu0MFv0cuzSvbB2bdSWOY4+Wn8fToubSEkgI4QQXYufV0HRXn6+nnhhs+E2GNiZkATAeLczrkqvWyXiIEVLA0WjjNJeX8+AgcbWwyOjxWjUM3VraqIWHbQGMmvWRH8LyGzWG/FJ5ZIQQnRMApl4l58PZ58Nc09i0+RpABThjbsgplUwTyYqCb9m6pQ+yHS1WPQ8GVcvE4lbjBmjd95tbIRt26JyySBF0XcSZUVGCCE6JoHMQKCqkJ3FlplzCCgKQ8r3kVIbpT74Uda6vVSmRCPh10IzTXjpfXJuCFXV+/REKTowGA7tAq5aFZVLtiMrMkII0TEJZAaQpkQ7ewpGAFC0dUOMZ9OxIdowQD8Ju1c9YNADGc/hh0dGi6LoSyhR0rq91BeBjMEAdXXRv64QQhwJJJAZYDaN03vnj98S5sE//SyHPFTNQJPSSC29WzUyYcKLB1e0KpdCLm6Kaqe51hWZHTuiH3RYLBLICCFEZySQGWA2F04EoKBkN4nOKCfCRoEREznkAb3Pk1FQ0SC6lUutzGZoqI9adm5aGowYoeezRLsMuzWQkUPnhRCiPQlkBpi65FT25g5FRWPcto2xnk6HWhN+y+h9wq+KQhPR2wIKMpvB7YlqFm1fbS+15iZLwq8QQrQngcwAtDnOt5eG0JInE4XKJRNm6pTaXl+nHYtFr2uOYnQwTS8qY/Xq6K6etPaSkYRfIYRoTwKZAag1T2Zk8Q4scXLWUlutHX7L2YeP3p1tZMKCk3r8RLlBS5QrlwAKC/UGwnV1sGtX1C6LySQrMkII0RkJZAagqowsKjKyMAb8FG7fHOvptJNKOjYtAb/i4wBlvbqWGTNe3Lj7qnIpisscJhMcdZT+cTS7/KqqnnsjKzJCCNFeTAOZZcuWcc4555CXl4eiKLz55psh92uaxu23305ubi42m41TTz2V7du3x2aycWZzob4qE49l2AoKeUTn3CX9FGx39M5caivKlUvQt2XYEsgIIUR7MQ1kGhsbOeqoo3jiiSc6vP+Pf/wjf/nLX3j66adZsWIFiYmJzJ8/H1eUOrIOZJuK9EBm7I7NGL3eGM+mvSHBk7B7F8gYMBAg0De9ZKJcuQSHApmtW8HpjNplMRj0U7CFEEKEimkgc8YZZ3D33Xdz/vnnt7tP0zQeeeQRfv/733PuuecyefJkXnzxRcrKytqt3AxGZTlDqE1Owez1MnpXlPviR0GwMV4UOvwq0De9ZPqgcikrSz89IhDQz6WMFotFPx5KCCFEqLjNkSkuLqa8vJxTTz01eFtycjIzZszgyy+/7PRxbreb+vr6kLcjkqKwqXV7KQ6rl/LQz4KqUQ6ykuXsZgcBelbKY8BIA33w79hHdc19cRq2xaLvgkkvGSGECBW3gUx5eTkA2dnZIbdnZ2cH7+vIfffdR3JycvAtP04PV4yGzeP05njjtm1Ejfaxy720mx0omv7jtdjwOv8wPM1j6j1sZl3E1zJjoV6p6fWRB+20ZtH2USCzapV++Wgwm/USbKlcEkKIUHEbyPTUrbfeSl1dXfCttLQ01lPqM3vyR+BMSCTB1czwkijW+/bSZtbxmvoi2mErMA3U8Zr6YsTBjBkLLtx4cEdzmrooVy4BTJigBx7V1bCn9ztrgDTFE0KIzsRtIJOTkwPAgQMHQm4/cOBA8L6OWCwWkpKSQt6OVJqqsqXlyIJ4aY4XIMAS9S39E+WwO1s+X6L+N6JtpkOHR/ZFnkz0K5fMZpg8Wf84WtVLrSsyUrkkhBCh4jaQGTFiBDk5OSxdujR4W319PStWrGDmzJkxnFl82dQSyBRt3YCixT6BooRdNCh17YOYVgo0KLWUEP4KkhEjPrx9c+aSKfqVSxD9Muw+2gUTQogBzxjLJ3c6nezYsSP4eXFxMWvWrCEtLY2CggJ+8YtfcPfddzNmzBhGjBjBbbfdRl5eHuedd17sJh1ndo0Yg8tsIamhniH7Stk7dFhM5+MMMyk33HGg96UB+mhFxgyNjXqEYLdH7bKtgcymTfoqSkJCdK4rKzJCCBEqpisy3377LVOnTmXq1KkA3HzzzUydOpXbb78dgF//+tdcf/31/OQnP+GYY47B6XTy3nvvYbVaYzntuOI3Gtk2pgiIj+0lO+Ft5YU7rpWKShNRbMzSqo+ST3JzITsbfD54+WVYv773iz4GQ9R3wYQQYsCL6YrM3Llz0boo61AUhT/84Q/84Q9/6MdZDTybxk1i8sY1jN+4hiWjJ4ItATIz9P2ItgIBqKwCVzNYbR2P6aUCRuLQkmmgk+0lDRykUMDIiK5rxkKtUkO0C5f6as/myy+htlb/+K239Lf0dLj6apg1q2fXtFgOXVMIIYQupoGMiI7tVjteRSG9vpbsZR9zwJKgn144darenQ2gtFQ/lrntC/bhY6JARWVe4FxeU1/Ug44OEn7HBMahRrgYaMZMM4148WLCFLX56nOKbuXS8uVw//3tbz94UL/9N7/pWTBjNusrMps29X6OigIFBZCY2PtrCSFELEkgM9CVluL55lt2JiQzrrGWImeNHsg0N+uvqK2vmMuXt39s2zFRDGaKmMyCwCUsUd/SV2ZamDULHsXNKmUFwxnNeG1K2Nc0Y6GBelw0YSI5anPVL27Sj6yOAr8fnn226zHPPQczZuhbRa2P2bRJL9dOS4Px4w/d15bDASUlsHhxdOY5eTKceioY5beAEGIAk19hA1kgoK+yAJvsqYxrrGW8s4ZP0occGtNyf5dWr4YhQ6K6zVTEZAoDEylhF07qsZNEPiN4X3mDVepXvMnLWDQrIxgbMqaAkR2u1pgx48GNi2Yc0Q5kTGZwNuiv7h1FEBHYtElfeelKVZU+btIkPY589tnQx3S2BWWzQWFhr6YX5HLBxo16Hk9LipoQQgxIEsgMZJVVwa2iLfYU/Acg193ML4rXdZlK4lYNLE0fwnZ7in5Dc7N+reysqE5PRWU4o0NuO127AFfAxSZ1Df9WF2LGSrPSGLzfoSUzL3AuRUwOeZyCikaAWqqDVUydsZKAHUf4E41i5VJ1dXjjFi/WV1eeeab9fb3dggqH1aqv/qxYoZ8PNWRI948RQoh4JIHMQOY6lO/SbDCyLTGFosZa0r3dd8D9Udl2/ps1nJUpme2u1ZdUVM7VfsBBrZIDyj6atcaQ+1u7/y4IXNIumDFiYqOyptvnyCCbmdqJGML98W49kTEKgUxaWnjjPv9cf+vK4VtQ0ZaRATt3whdfwNlnR69EXAgh+pMEMgOZ1Rby6b9zR5HrbuxmvQKm1VVxdH0V51XsJtnn4aP0vHbX6ksKKo00dJoMjKZ3/y0MTAzZZsomr92xB4fz4aeKA1RRQTZ54U0oipVL48frW0NdbS/Z7fqWzs6dXV+r7RZUXxk+HLZtg6+/hjlzol7EJoQQfU4CmYEsM0NPnGh5AfapKqW2w7ZUbC0BSpsX6RKrnTqjmZOqyzipuoxkzc9baak9PJs6ciXswql00RBFgQb07r+Hb00p3VQ7mVruL1NKydbCDGQgapVLBoOe39JR1VKr664DrxcefLD764W7VdVTBoOe571mDeTkwLhxfft8QggRbfL310Cmqt1nak6d2n6MovBRxhDezBqOHzi65gA/+vdCzG6Xfn8gAAcq9BMPD1Ton0dRX3T/bSuZVMrZRz0RVCJFsXJp1iw9vyU9PfT2jIxDeS/hbkGFO6437HY93l2+XF8FEkKIgURWZAa6/Hz9lbG7HjEdjFmZW0DDpMl8f9lixuzaxpUvPsXf55yBc+u2Pu0301fdf1slkEg1lRygjKRwK5zMlqhVLoH+7Z4xo/Oy6nC2oDIy9HH9ITcXtm/Xg5nTT9fzn4UQYiCQQOZIkJ+vl5101bW3kzHbVJW/DR/Oj15+nrzyffzk9Rf5+5CxVFra5MxEud9MX3X/bSsRB6VKMcO0kZixdP8AkynqZy4ZDJ3nt4SzBXXVVX2X6Hs4RTmUL5OdrQdhQggxEMjW0pFCVfXy6WHD9PcdZW12MmZfXgF/vew6qsw2Un0erirdTEFzQ/vHr14dlW2m1u6/QPsjB1o+nxf4TsTdf9tKIoU6aqjkQHgP6KMzl7rS2RaUxdK3pdedMZv1Uuxvv4Xdu/v3uYUQoqckkBEA1Pg0nh1aSKk1kYSAn8v2bmVOdRl2n+fQoNZ+MxBeHk0XY1q7/3bU3O47gR+0K72OlAEDRozsVXYTCCeNuY/OXOrOrFl6mfU998BFF+m3BQJ9W6nUldRU/fm/+EIOqBRCDAyytSR0rmaajCYWDi3ke/t3UdRYy2lV+zi5ah/bE1NYlZzB1sRkAq7m8M5tCmNMEZMp9I2npH41Db4aPkn/ijpjPV7FG5XDIVNIo5JyaqkmjYzuHxDlM5fC1boFNXGifthkcTEsXQrnndfvUwH0f57t2+Grr+CUU/pve0sIIXpCAhmha+kj41UNvJw3mqn1VRxdV8Uwl5NxjbWMa6zFaTCyRnOx2qtQYTms70xPznYqLUVdvZrhLcFO47hkPjy6nrXez5lmnNnrL8mCFS8e9lMaXiATxcqlnlAUOOMMePJJeO89OPdc/bb+ZjDoB0quXw8+n94F2GjUt56MRn3xymA49JaQAEOHSsAjhIgNCWSErk1PGk1RWJWcyarkTDI8zRxdV8WU+iocfh/H79jI8UCpNZFVSRnsTnDgVg24VQMeRQ3/bCdoF+xMKk7noyl7KbMcoGLfarJyen8IkIMU9ikljNDGkkA3Rz1HuXKpJ+bMgYULoawM1q2Do46KyTRISNCTfnft0reaWt9A34Fry2DQE4UnTdLfS0AjhOhPEsgIXWtPmsOCiyqzjSWZ+XyYMYQx6SkcvX4lhY115LsayXeFHi8QgGBQ41YNuFrfGww4DSYaDUacRhNOp4nGZXU4NY1GgwlfS9JxotvEmH3JbM2vZW3zJ5wWOKrXrWYdONhHCRXsb9dcrx2zGZzOqFYuRSohAebO1c9ieu+92AUyAMnJ+lt3XC793KjiYj2PfPJkPaCRU7WFEP1BftWIQ7roSROYOpWtgQBbq+tJ9Hk5qv4gUxoOkux1Ywn4MaBnjtsCfmwBf0RP61JVyi0JvJYzkik7M9maX8v6oQc4ufIAhuzcXn1JCio2EihVisnXhnd9/pLZfKhyKUaBDOh9XBYv1nNUamr0BNx4ZrXCiBHgdsPevXpu97Bh+grNiBES0Agh+pb8ihGhuupJc6ACgEajieVpOSxPy9Efo2mYtACWQABLwI8l4Mca8GPx6++tAR92n5dEvw+730uiz4u95WOjpmENBBje7OTC/TupNRVibzLhTPCyzbCJInoXyIDe6bcynPOXYlS5dLgRI/SjArZsgQ8+gAsvjOl0wmaxHApo9u3TS7gLCvRVpeHD9VY9PaVp7be0uiJnRgkxeEggI9pr7TdzuMPOdgpSFLyKAa9qwGlr6cbbVTBgtoDHDZqGJeAn3evmsr1byXc1clplGR8Vp7N8Qjlrk7dSxCm9/nKM6K+gYZ2/FKPKpcOdcYYeyCxZAgsWDKy8E4tFD1w8Hti/X992yswMb2WmNWBpG7h09r4rmZlQVKTH5b0JoIQQ8U/+bhHh6+nZToebNk0PiBQFt8FImTWRN7OHAzCnppxzNloB2Gkpjuy8pC6Eff5SjCuXWs2aBQ4HVFTAqlWxnk3PmM36FtOwYfoqjdPZ/Vtrc2W3Ww+EvF69csrn03OwA4H2wc7hb4GAXj7+5pvw+uuwYYN+XSHEkUlWZERkenG2U8gYhZDE4k2ONFY01TOjrpJrt+7lmaYcdieUs075luO13q/KhH3+UhxULoG+qnHyyfDWW3rS7zHHxGwqvWY26xVQ/SkzUw+EKir0fKP0dP3cqlGj9PuEEEcOCWRE5HpxtlNwTAcB0XuZBQxzN5HjauRnqzV+MxvWKl8zWzsZpcNDmSIT1vlLcVC51Gr+fD2Q+fZb/QU5q4PdPtE5s1nvbxMI6Idzfv65/uM2ahQUFuo/nt3l0ihKbHr5CCHCJ4GM6JnO8mgiGXNYsOOz2vg3c/nZ3/7CdZ8c4K4ZBmqMBylhF8MY1espJ5FCOfuo5ABDKOh4UJxULoH+Ijx5st5PZskS+NGPYjqdAUtV9VWYzEz92IWNG/VTyVNSug9SLBa9+mr0aP1jIUT8kRwZEVuHHWRZmZ3Lu/PPJdELF63Ty7jXKF9H5anCOn8pTiqXWp1xhv7+gw/0PBHRO0lJelAydOihfJqu3mpq9K2911/Xgx+Pp/vnEEL0L1mREXFn5dQZjCrezpWr1vL80bBFWcfp2vlYsPb62mGdvxQnlUsAM2bofWRqauDVVyEvD9LS9HyPw1N4/H79xba6undjBgOLJfwVFp8Pysvh3Xf1AGjKFBg5Ul+8E0LEngQyIv4oCm+d9V2ueXYPRZW1bM70srF+GUfXFHacj9MqEOg6b4cwz1+Kk8ol0EuWi4r0vOiXXz50e3o6XH116NFWzz6r54L0Zoxoz2jUAxivFw4cgP/971B/nJEjpbxbiFhTNC2SNlMDT319PcnJydTV1ZGUlBTVaz/20PMs3bSKSXkjo3pdoRu6dw91Wx/j/82DEZUmjtqWj73ZRIEzC3XK0YcqpABKSwmsWUWJvQKnzdv5OKCBetw0M1mbzlCGt3/i+nq9qmruSTFfrli+HO6/v/P7f/Mb/X00xkgwEx6vV++P43brP1qTJ+urW62rPGazJAgLEQ3hvn7LioyIW3s1lZy6FIz+WoozvWDYRXEaOBp3MW9VGUWcHTxFe3Pp/1hyWgkNid7g49uNa72dJLx4WK18jVtzM4IxqG3TxeKkcsnv11dQuvLYY91fJ5wxzz2nb2MNxm2mSJlM+opMa0Dz9tt6AGMy6T86JhMkJuo/Ona73nWgNcAxmfQVnrbvWz+WoxyE6Bn5ryPiUyDA5vIPuGdBLTP3wvICOKEExlcCeHFl7SRh3esMbTyFvTuX4iosZc5e8Kvw1VCotUFDgpfXjt/JghUfUDTkspBtpjQyqKeODcoq3JqLQiYcOocpTiqXNm0K3QbqSDiN3sIZU1WlP9+kSeHNTRwKaAIBPahp+1ZRoR/T4PV2fFq4quqBi8Ggv7UGMgZD96s5inJofNu3tsFRuEc0qOqhOXT0pqrxedyD2awfsGqxyOqXkEBGxKlAZQVLJm1HU2BTSyrL4jGw9yEwB8+kLIVVi/QP23S/rbPAozPg4ZlQa4Ulk7ZTWFmBmp0TkkeTZLVhzExmq7oer+ZlPJMxYY6byqXq6iP7+Y4UqhpZ8rDfr7+1ditufXO5wjt+oW0H49ZOx4d/HA2Kon9t8RgotK5+WSx6JVpKit4J22rVV8BstkMBXduA7PDP4/FrE5GTQEbEpRJ2BreJahPA5IPKRBhxI5jaHK5t0BT8yqHf/jYf3LYMbl8GN66AR46Dh4/zUsJOhpd623UbTrDZMBw9np1DN+PFzUTtaKzY4qJyKS3tyH6+wap1tSPeq55ag6N4o2n6SpfHo7+VlUFxsR4MtjKZDgUsrQFZ68eHfx5PFAXGjtUboEsSefgkkBFxyWnzhnzubflJLWuX79X+T9gfXQBuFS5fC3d8Cjd+Be8VrWRnw25chsN+5JubsXyxkuzZx1IydBdexcMkbRp2swlqa6P29fTE+PF6VVFX20vp6fr73o4xGPr/GAER3+J1Wwn0F/mEhI7v07TQs7nans/l9x/62OeL7ET1/uD3w7Jl+tbkrFnyx0W4JJARccnuGBrWuOm+mXxr/DLkNk2BK86D/4yHBz6EiZXwgzUlNKv7+DI1m+Up2bgPC2hMq9aTm3cG5eo+PIqHyZZxpDZaYnrmksGgl0Z3VW109dX6+96O8fvht7+FP/xBD2ik14wYqBTlUBL1QJSWBlu26H94zJqlN3CMt5WjeCPl170g5dd9J0CAxwJ30WBspMNjljRw+Oxcq/6eJwL/1/m4AFyyzsIf31XI9rgAaFYNLM7MZ3XyYacHzj2JQHYGBygj0Wtlcv1YsrKn6BmUbRMGVBVUBWj5ODu7T5OCO+r/kpEBV13VdY+YcMd897v6mU779+t/5ZoOa6MjvWaE6F+adihZ/OijYfp0Pf9nsAn39VsCmV6QQKZvbWYdr6kv6p+0DVJafmIXBC6hiMmdj2sZu+DAmYxfWsEEZzUnHSwjy+PCh8JDIyfTYGyTqHDccTBsGBoalVo5amMzeZ4ccnw5pPtSMWE6tBbd+t7n00tXjj66T/8EjFbX3s7G1NTALbfoS9qdObzXjHQJFqJv1dfrAc3o0XD88YPv4FjpIyMGvCImsyBwCUvUt2jg0BKBg2TmBc6liMldjgNAAb9FRVMUNjjS2WhP48rSLQxzOZlRW8GHGW22sKy2locoZCm5OO0N7OEgezhIEqnkaflkkUsyqYf6zvh8+m8ah0NvwdtHa8AGQ/el0b0Zk5Sk//XXlba9ZqRLsBB9LylJr8DavVv/g2HWLBg3Ln5zl2JFAhkR14qYTGFgIiXswkk9dpIoYGRoA7tOxu1StrFc/Yh3Ut4nK2syWRV6QPNFag7D9u/gmNoKPk3Lxasa9N8WmaFHFthxYMeBHx/11LFRWcMONpNKBkO1YWSQRYLRrh+GtHOnXgOal9eP353o2bRJX5XpSlUVfP21njz5wAPt7z94UM/Dabty09crSYeTVSJxpDGZ9BWZ8nJ4/339mIxjj9WbLgqdBDIi7qmoDGd0xOMKtJHs1/ZSrGzjPyfu5Io3R2D1GtliT+GgyUK6183U+oN8nZKl1zt28meOASOppJNKOm5c1FDFAWUfCdjJ1nKxJyaBtxa27QXThA5/wxgwYlZtmFUbFtWGWdE/VpX4+NMq3B4y993X/aJT68rNihXROf8p3NUfWSUSRypFgdxcveH4N9/owcyMGTB8uCQCg+TI9IrkyMS/Jhp5Tn2YeqWWsU0jWbAkj1J7JSdUVvGTrQepMlv5yw+uRhs2LKLragRopBEn9fjx63k79XWQlAxDh7RbBlDQhygomBQLRtWMUTFjUx0kGpJJMCSTZMwg2zI8Wl96RNavh9/9LnrXmz9f/+uxM9E+IyqcM6mivUokRCz4/VBaqqfpHXUUTJsW0wbkfUqSfVtIICPKKOUF9XH8ih+zZsGjuEl0Q+nDkOqCBy6ci7Pw7N4/kd+v78/kF+jBTAdlVAHNj0/z4tM8eDU3voBH/xgPVjWRqUnzyLWM6v1cejD1q67qutdMRgb88Ifhnd3UHZuejtRl82SHQ/9rs76+8zFpafDgg3DzzV1vjWVk6Ks10VolEiLW6uv1ZoB5efrqzKhRR97qTLiv3/Gxri1EH8ojn6O0YwDw4Aag0QJPT9fvP27FJ2xmXXB8gAC72cEGVrGbHQQIs72pwaD/abS/rNO9GlUxYFatJBiSSDZmkm4eQrZlBEMthaDB+oZPOOjZ1+Ovtadae9Z05aqrICcnOs/X3Nz9CRANDV0HMaB/my+/PLz8nldf1VdtDg/WWnN7li8/tLLT1ZhWfr++kvXpp/r7tp1lhehrSUkwZozet/Odd+Djj7v//3KkkhwZccQLEGCbsql1byfo8WPhV8vhxD1we/nrFOZMZCsb9OonpU2VlBZaJdUlq1Xvm753L9gSDi09hCHDPJRyzy7WNXzMtOQzSDKmR/BV9t6sWfoWTFf9aPz+7rsN2+36Xn68efXVru/v7qRxiCz/B2SLSvQtg0Hv/uB0wsqVegHlscfqAc5gqmySraVekK2lgWE3O/iH4ekO77t8lX4u0/Kh8Mz581imLtHv6KJvTbc0DaoPQnoGjBwJhx+L0OVDA5R5dpBlHsbUpPkkGBxhPzZaunvx7S4f5aKL4KWX+n6era64Av72t/57vu6+vrZ5O+FuUfVndZcEV0emQEDfanK5YMIEmDKlf7sbJydHP3iSPjJCtHDS+XrrwqP1t9EHodL3IZhpn9rSkqm7RP0vhYGJ7Uq/21EUSEnV9zNsCZ3my3T8UJUc80jKPTvZ0PApU5JOxaz2b0vP7vrRdLdyM2OGnujbH2dEZWTAWWfpnYm7Gme16r/go+Hf/+76/uee02PZcEvUo1W5Fc0KsGiWu8fbmHicUzSCS1WFoUP1s27XrYPt2/tvVcZohDlzoLCwf57vcLIi0wuyIjMwdLUiA6AGIBDmf/gf+X/GcEYTINBtb5uAq4kS3zaceXbsSfkU2Maj0v63UwA/Jc2bcPqrsRvSKLCNJxDws9+zk1EJRzPJMReDEn9/c3T1yzecKiLov6ql/l4lsljA7e78/rbJx/31fQpnTCQrSfEWgB3p846EpnWfgxZNpaVwxhn6SlA0SdVSCwlkRIAAj6n36F1/O1gYOW07XP8NvDMG/joNtC6CmvP8F2HA2G0ezWbWtR+jpjHP/mOKrMcGb9vs+polzr/TEKgOHZd0KSMtR1Hl30uh7TjGJc5AVY2HyhIUJbREoe3nh9/e0cf9oK/PiGo7prtxM2Z0X5UVzgpQNFd28vP1JmdddVQOp7orOVn/p+3qsPZwV7euvLLjlaRWkZS7Q3yNGcjzjnfbtsHpp0sg02ckkBHQ9blNigbFTyQw7GATv5gPj87s/DqJmp1GnB1eB/Q8GqDrM6IaFlDkLmSzZSuvOV7rfFzj9xjmG0adWsdE32RG+Ua3XysOCWxC7mg/5vDPDYZDxwQbjWA2g8kIqkG/z2AIP/jpZJw/AJt2mKl2Wkgb5mD8BCVmWwbReBHr75Wd/mY06qdudMZmg3nz9K3DrgK61gMO+2OM3a7/+DU0dD4mIwOeeQZ+8pP+2fKM5tbps8/Gfw6TBDJ9TAIZ0arDVRIthXmB7/CjVU7Oe+d1ilNgzPXgP/wXR+v/kq5e1zUwYwFayrw7ObU7ATtX+W7gb8bH9fydzk731pK53vNrnFo9zUozU33TGOrPbzPmsAMsWyepHXZ/u2u3eVwgEPrW7ppRYrPpyyKpqdG9boR6uwIUzspOUlJ4ZbCtKwSifyQnh57qPlDcc0/3Z6jFWqwDmfjbeBeij3R1btPaSV5O+vgdRtS6OX8z/Gdimwe2vKbPDJzEl4aPO38C5VCfmq7GNOHkL6Z7ux3XoNRRYiplOKPxUcUG02aMWhIp9F8wYMSEMRq/Jvbtg5KSmAcys2bpwUhXqzvdjbn66q5XbX72M3j++e7/0j7jjIEZyIwcCbt2xXoWkRuIQQyEtqSSirOOSSAjBpXOzm3ymUysmjaHkz77gFu+MvCfiYe6mznQV238dLHm3kdaK67SyKCC/axSlneYMNxXTJhwkEyKloYdBwnYSSAxuPIUttRUPZgZVqBXdMVQb08SD6ffjqp2HexcdRVMnNh9T57+3MYIdyXppJMGZiBz5pnw7ruxnkXkysr0ACbc3kWDkQQyQrRYMX0WJyz/iGP3+rlzwymsyTRiN6ZQkDQVVTWymx1Re65T/Gez1PC/bsfZ0ZdTAwRoxEkNB0nEzlCGt6+SIsBedtNIA4k4ojLGio10stmnlAAaRsxYsWIniVQtHTsOLNi6Ly5PAOrLYc+3kFDU7dfdFVUxYFRMqBgxKiYMigmDYuzXAzi7W7UJJ9iB7ld3Wrst98eYcFeSzjwT3nwzfgKwSBKZV6yInzmFMwbg5Zdh8eKOk7k7KucfjCSQ6SUPfspdXWSZAWbNipn+6QWiKGAz+wdVV8doabQ7WDuykGnbN/Hd91bhyxsNVINtP0ydSkH+SBxacqfVT2jgIBmgmzEpHMPxfK191vk4QNEUmmnqJLcnjCqpPhjjxYMLFzUc5ICyL3gQZljSPVDzNZSNAFvP/j8oKCioqIoBVTHoAQz6xybFjEmxYlItGBVzWNczoAdAqmLEoBhbrq2ioL8ZFAMm1YpFTcCs6CeXm1R9NSqcfjvhbGOFE/D015hwVpJMpvgKwMIZM1DnPXs2rF3bdUUaHOo4bTDEpv/Npk36mHHjYrPVJcm+vfD3x/7JxxtW62uyXWhUaknxZ2Eh/Hb1PaVp0OQxkpvqOuIOEOtzpaVkfbyU6/dsIAA8MnwSNeY2L7izZrE5YQevZb6jf95RpVHlWZCe3nXVUkuH4K4qqUJu6yjROJIqqSiOadvZuLWXTgN1LflGIzpc3Smh+FBO0sEk1NyhUDCszZjWPjo12A2pHfbbaTsm0ZDCEOtYNDQCmp+A5sePr+VATg/7XNtoDNSSoCaTax3V4Zz2u3bSFKjDpjrIsYzQv2ANNOVQwrSitHzpmoaqGDGpFkyKBbNiI9GYTKIhBauaiEVNIN08BIuaQE/FU/O1aJS7R7u8vr/K9ONx3itXwl130a177tErt2LZ/2boUHj0Ubjggu7nGw6pWmrRl4FM4JNPaf5mtZ791gkNjS8aN7KqeQcjzTmY+rixWaPLwMqdybg8BjKTPX36XEeUQAD+9z9obuaSvVsZ01TPV8lZLMkcik9R0RQl2NRjc8Y+lhxdQkPioQYgjkYT81YVUFQ1BM4+m81qR2c26bk2bYOBziqpTg6cSaWyn+XKx51XSmmHtp66qn6K1hgHKVwf+C0qas9XdwJJzGs+naLRF4Atgc2Ny1lS9SwN/kO/DR2GdOZlXE1Rov4bM5wx4Y4L91qHNykcYh2DX/PjC7ScWq558AbcwcAnyZDBMNtE8qxjSDBE9/dMLBzpHXLjbU5djfn0U/2E9+6ccYa+BdWZ/uh/0/rH83/+E51gRgKZFn0ZyLBsGaxapZ+f3gVXwMN79SvZ4SpnjCUPtY+XSg7Umlm5MxmzMUBSgr/7B/RAQIOGJiMur0pmkmfgb2UdqIBP9IqkUY11XLZvW8jdXkXBq6j4FBWvquJVVJwWjSqbyjt5mQSaM1G1ln/XuSdBdlZY3X+BTsd115E4Fi7yX40bd+9XdwxXQmYmrx3o/Dfmgmz9N2Z3Y4oSZ7G5cXlUrxVOsNMqoPmp91XpQY8xjQLrBIZYC3EY0zp9LiHCtX49/O53vb9Of+X2KIq+MlNc3PttJglkWsRDIANQ7Wvg3bpvqfE3MtycFd15dGBneQLr9zhItXuxmQNRu25Ag/omIw3NRkwJdTiNFVhdOQxN6sfTyfrCnj3w1Vf6x5rGj8q2U9gYXr1mAPg6JYsP04fgNhjhuONg2LBuH9edDaziTUN8dV8zaPpvJj/+3q0ABexgNOHUajp9LruSBgo423Q9PpzDkMG1Bc/wRMlPQgKPduPUdL2kvasxhgxOy7iS1w903tq2NdiB9qs2+dZxNPrrqfdVkmBIYoh1HEOt40gxZqHIPq/oIb+/+95FqqovKseTjz+GuXN7dw3pIxNn0owOTrBP4N36b6n01ZFpTO7T5xuR3USTW2XbPju5aW6Mht7Fq4EA1DWZaHQZSErwMmFYNS5HMRne4SwprkbxGMgzp6F0d6BivLK2yV9SFBblj6bZ7MXhUUj0KBi1ACYtgCmgvzcGApi1ABMbqjmqoZrjaiuY0FDD4sx81lta8moCAaisAlezfv3MjI5PcetkXGtAEE/8SjcrfErXh3QGxxich3J/OuHUqrsd0+Cv6jaIAWgIdFMa0nKttyse7XLMkqrnKEycwdbGFV2u2jh9Nexo/IbS5o3kWkaTbxtPoiElOFY71LWw3W168rQS/Lg1mVoPhsIPiFRUlJbEZf1jCaYGIoOh+yTls86Ct9/uvzmFY//+/nsuWZHpjQhWZFqtayrmw4a15BpTsRv6NvnX41NYvSuZsmoruWku1B78HgsEoLbRRJPbQHKil+FZzeSmNrOPfYy0ZDPfMY1XN3j5X/kuElLLyVZyIu8xEg8CAQLvvI1Tq8dp86CgkOgy4jb58RgDmH0GEnFg8xhRmkP7pY9srOOcihIyvPrtO0aM4X9TZnJw1+7QQ3JsNpg6VT9kp1VpKaxe3eG4QP6QLs+IQgOHov9MN2hd5La0jukswAiz2spOMscGjucjwzsdX2eQOCbpHL6p7/xVo+2qTaO/li2NX9IcaCTZkEGudXS77UU9aTnAfvcOGv11JBqSybOMOVROrujBjD5mO42+OhKN+hhFCV271zQ/Ze7tNPrqsRtTGGItxIAhGNAYFANqS6WXQTFAm7m0nZfS8rwAFjUBm8GBWbFiUq3B9xbVhkmx9mvZ+2DWVVKwwxGd7ado6s8VGQlkeqMHgUxAC/CZcxNfN25jpDkHsxq9RbFqXwNVfv3FKllNJNVgx+Ox8M32ZJwuI9kp4Sf/+gMKtU4jLo+BFLuX4VlN5KW7sRgDlHmrMSkGzkk+lkxTMg1NBl5akcA6/yaak7eSiJ0Uop8f0EDdoXOOuqCiYsYSfOuqM61GgCYaaaAef8V+7Cs2kVuTQFZtAimNFposPmrsbg6kNFJ7wgSaVBfGtRtIdJlIdJmCeTGGQIATasqZU1OOKeDHpyh8lprLsrRcfIevwsyapQczpaVdt3YNo0rqN77jALjf+FXXY4YO4f7yzs91mlt3JRaTxvsJf+t0zILAJdhIiLu8nan2eax2Lon1NIIchgyuH/Zsh6s2djWVk9IvYWzCsbR+k7c1fc3HB1/AGag5bNyljE04Bg2NbU3f8PHBF2lsMyZRTeWk9B8zJuEYALY3fcPHB//ebsyJaRcxKuFoNE1DI4AfH2Wu7TT6a0gwpJBrCa3s0ke1VnbVYlXtZJmHobQELCp6Hx+jasaomLGqiRgVS/hl+F1QUDCoRoyYMKgmjJgxqIdK7Fvft12pAgVFOezzCOfSdnz7lavOr9Wb5+lqlKqoqC0BqP416+8DAZWtmw3U1CikpULR+EMl1z/9KVR3sfCY1pLb0mdjAnp6geTI9IF4C2QA3AEvS+pXs9W1LyrJv/X+JvZ7q0kyJjDROowAAYrdFVT7GvDiw9PkoLh4KFbVQkpi191pfX6FGqcJj08lze5hRHYTOaluzEb9x6TB30yFv47Tk45mnHVo8HHb9iXy9so0fGlbKLGsxUUzWeRGp709+mpCEw3kax0nzLblVTzUU4cbF17c+PABCkaMweBGQcFJPR48JJBIFjnkaENI31KN5f1PoaHN6oUjCW3eaTQW5VPLQapKvqFy22c0tqxwGAIqWCwwbhyZJjM/fPl1Jtbo91VaTLxSkMveBCuKpqBqCorZgjpzNsrny1FdHhRADSgEMKBpBvy0HNbYRZVURiNctQpm1ToAWJ7SwLNHw8FE2o+pc8Bp81j+9WsdjrlklZFhhZexuy6VNeWf8PXR62hMPHTUQrAiK/9sfZUocBcNxsbOV4B8+hN0O8ag0qA0dPo6EW5eS7RyZGxqEs2BMFrbhmGS/WTWOz/q9P5oJymHMybcRObuxrSWufs0Lx6tmZLmTXpQFCx3b18631ruHs4Ym5pEtmU4oKBpAb0yTNP/6DjgKabJX0+CIYls8whURQ3dfdQbG6GgtNm+i1y0grKePlJFBUUJbg+GfI7a4bV37Oi6c/GZZ+rv+2RMwACls1Fq9ddCqVqKsngMZABqfU7+V/cNNX4nw83ZPXr6poCbfd6DWBQT4235TLINJ8Oof41ezUeFt4793mp2uctZV+lm3V4jqVYjGeZEbNhC8lk8PoXqBjOaBulJHoZnNZOd4sbUJrfGq/nZ4S5jRmIhc+wTQv5yCQTgo3XprClOJjOvhK3qOsrZRzJ6a/vecNHMQSqZqB3NaMaF9QsiQAA3LpppwkUTzTRRTx31Si0uXGj4SSGdPC2fdLJIxN7mwQH9XCCnUz9at6CgXW6LO9BETdkGaj1luBMMkJ0Figrl5fDBEsY11TCvejdJfi894VYVPKqKW9WrpJpVI01mDYOhCVWDBC9oCgRaep0EFPCrcNAGzUb4/+2deXBc9ZXvP7f31r5YqyXZBryx2OBFiiEEgg0OIQzEMMMkVMVvkjwmiZ2CkFcJqXqEUFNTdmAqAQwP/Cqp8CZ5hQ1mDJO8kMHxBgRjbNkGG9vygvGmzbKtraXe7v29P37dLbWlllpya2lxPlW3Wup7+nd/fSx3f+/5nXN+LhPy/VojKEA57aiwiTKgOQM6XWBTUNANYRsEs7x02x3UB7wcdVRyoMig2+untMtiRlOGjjx5vXDXXRza8394veagnmh/kZudVwMMbrNgPq/bf59QyIx21dKy4p+w6fxvBxE7WXRbg0cFByPDlss3y57klYZf4LNaE9olJeZSmMgMyfkbUlfuPpJl8/31JErWzsLkZNcn/diofsZJpgfSBTLtBVR5ZyewOYTPvECmPZ8K7ywMpcWYwsJSViyadqb7cCyaVuGZgdFrrKPHYNt2ky73EfC0gj+PzOAMbvmSnelXjaBN3in49HYqLnyLZ39tlz4yqWa8ChmA08Fz/LmtFjs2Spx5Sb8uYIWoD1/AUhYzPZOZ651Guaswob2lLFpCHbxVZ7L1TAeu/LOE7J0UUYoVyKDV58QwoCQvQFVRN8W5Qey2vn8WRwP1THEVcVfuQjy2vp1T27scbNxRQnfQQXFhO8ep47hxGAuLIkoHjaT0R4ggTdQzXV3N1VyP/TL3GVIoggQIESKTrJTcecVx4AC8sREAO2FmUkcVp7FzSZKsYQMVX2Zgu4w7yFRjAt12O2bkjlenmSpsdgeEw4RtiqBTC6NYvz4FrrAdh6l9GrYrgg5ts7MCfroE6jMi0Z3TBXDrlzmUd5K33X+mw97THTvbPok7Jn13kC+xeJtk7QazGUwQfSnvm7zTOr4qyZLFYbgJq8SbmmYYuXpTUytxtV7vZbPRiiQlYzOUsvnxJsAm0rwrsit49s5nWTY7NUpGhEyE8SxkAA50n2RT+z5KHHlkD5T8GwgQbmygIcfAn+FkqquEGzKmMcVVnHSyXTBk8NePJrHrjEVnwT4Ohz4jx/AyIy+Lykl+CrODCROCG0MXMQy4O7eaEmfiTf8On8nirdoiygv8ZLgtmmngkPEx5zlHCeU4Sb5M28SkgdNUcQVzVfWQXjtmfPYZ/OH3g9vdfgdsujSvQ6EXlvThIBwTQOco5AvG38i3x991G5f87x1IlvVna6iex9hzg89+WIQNeCdvMn8pnIrf7oAb5sHkyagLLdRnN+FzdZHtLaZq8s243M64IFjvO9YsewFTMq69rDvtgWwGEjszM2tYc/K7KYna2A0nphpexG4smZ9zJwc736PbSrw1S8oiSSkumx/NpbxU2aTTvKM3hhv+YUNKxIwImQjjXchYyuJ93yE+9B1NfD9uWXDuHBQXU34xzLycmVxZfg0OY+jRifYuB3/eXcTFLhuusk+4mFeLzd3JVHcxzgTjdZp+GsMXuSPnBq7xVg38fiz460eT+PhEDtMn+7AZ0EUnnxj7OM0JCinGy+Ct3BUWDZyhiFLmqUVJvWZcYFmwZk18js2lZOfAihXwwguD2wEtHVrAfYN1eLjkjjqV2xoPQhteTi5dxskP9vGpJ4/GLAi4wyhHQOf3XGJvw8KGidcMs6y+nvkXW/U4DgfrqyrYdtuXUaYJR49DOKiXyLBhebIJz7keVTo5NpaBhf1iC/ZAF2R4UJMKwWbXe3Jog8gamgUtLRj+bmwZHuylRdjsNmx2sNsihTiWBU1N0NWFkZGJrbQcw+aMJVUa6GhZw9mddPsvkO+pYOqU2wAn4TAc6nyfP7Ym/qBf6Pkmu/yDR21uL/gOmy78dgj/AkIiHLgIk7iYwWVksCjv6+xo3UhQdSW0cxs6vyugfAltPEYWGOAfQKx6jWwwGFDsJWOTacvnuxW/5rdnHh24n9JoCsdBbAwMKnIqOPHwCey2y4ugi5CJMN6FDOh8ltPBFqxLlhpinDwJZWXYvnwb5c3deP62U++AVlY2rOu1djowLYPCnBCNoYu833mY44EGyp0F5NjjBUNYmRwLNLAg8ypuybo2qehPa6eDN3eW4g/ZKC/QX7whQhzhAMeMw2SQSS6JozoATTSQRTbz1Y3kMLI9d1LOoUPw+obE5++7H2bPTs4OOPb6Xm5gH7eyva9NMj3Ff/KTwbc1TnYL4bVr4aGHCJzvoJFijrmLqHflkEEXGXTjJIQ7x4uLIK72Zv07AZyE8IQVBQGLaH/GQEkRF9rPE3D0xIBCOAngwY+H4L8+TeDGLxPc/B5d/+t3+C504yObkGHDysvFun8Z1pxrsTBRysTa/xHWH9/A6mwlbERiWln5mEuWYl45E9MEdeQobN8Gvg4UYNpNzGwv4ZurMadVElYBrFPHCe/ZCX4fpt3E7w6Bx0vG1TVkT7sOj8vNiTOv8y7r6MjoEZY5XS6WOB9gatUy1jZ9F595PmGyc6Yxifvda9kQeAgfiX2eaegvDd8AfXBGO5G50FnB+dCZlIwlTFy2Lt/KrVNvvawxpCFeGuE0HFzhLu3/ZH09FFwFt38NiouhHPBk6SL9M2d0ndsQycvqqVwqdebz1dz57O46yh7fp7SZXUx2FsYqqU4Gm5nqLqEmc2bSS1h5WWGqZ7TyVm0RXQEbGW4LJ05mM5dMlc1B4yOaaaCIkn4b6F2gBSdOrlXz0k/EgBYp990Pb7/dp/qJO+7Q55O0My2wvjyJyr3vQWuva6R6W+MhbiHsXr2aKZxhSuAMlwaJWJGEuHK5cDedo68UN4FIn55//R/6ff30R31f3w786g9aWH31q3qTmV89FDut0KIoiIvgkT8RXPO/CZp2gr95nABugrgIxz7+DL3RzS9/CUYWvPiUTqy0Qchh4sv00ZrdRfP5nXTN/HuUEWTWln/nG37FyTy46NVJ01e3BLGr38Njk3EWfIlfntsYq6KJmxjwgHMJs69xEjz333nl1OrYNC61uyVb/7v8uT2xzUK7ttkSTmzzRff3eN//Wy2IEomriCAaSIBlOyZxR8E/80rT4/0YjG9EgI0uDR2j1xEvLSIyL7zwAk8//TSNjY3MnTuXNWvWUF1dndRr0yEik5C2Nr2L2Fe+AjNmxJ87dkyLmUBAV9VcZgm3UorjgQbe9x2mOdTKFFcx7WYXpmFxd241Zc6h9YWxLNi0r4j9J7OZUe6Lm14zDRww9tLORUoox95LT+sy605uUF+ggstv8z+mJFH9NJjdhQ4nIdPgGzedJvPT/SO/rfFobSFsGLBq1eA+dDohNEAeidcLd9+t25r2bip4KVmRqrTOAXJXiov1vJqa+j0dssG5K0tp8pocD53jXKT6y2npCjAzUjlm5OYCiv3udt6YBW29Ut9yu+Hew3C9Pw/3k/+Ca/9BPnr9Rf7vdXChV1l8oQ++s8dGzT/+FICd637Jb+ZZcTYFPoNv7Mli7l2PEjJt1P7leV6fd4G2zJ7E8myfk6V7Kpn9hX/mkLGfDfY/6BP9iJ2vdi1HKYO3Ml9OaLO47dtMLb+bdR3/hM/WmlDwZFj6BqTLlrjBYtI2dgddKrG48hg5+AfrJg0stH+HXWb6LeUtzv8nNl/83VhPY8iMZkRm3AuZ9evX861vfYuXXnqJmpoannnmGV577TXq6uooLh58z6K0FTKBgO4o9MUv6r17+hMqJ0/C5s167/Zp0y5bzIAuC9/hO8wn/tPYMLg953qu804d1lgXOpy88UEJYdNGWUH8bXsHbRww9sTyYNx46KaLi7REyqxnX/Z7mQgcb8zg6ooO7pjXkpoBx8sWwslu6TtOUUDQDn4HdEV0uF1pQWOLJFDblDa84NV2TgvyuyFsh4Adur4wn+66AwRDAQIOOJsN7W7da7egSwujcE4GYZtBqNtHwAbHC+BChi6/n9oa6cubG4latrVhASfy9Tg5AZh+HjwmuHLycFoGe10X+fe58aIp2m+opqsIEzvvZ7Tw8rxwH9H0zT0ZLPCVwtNPsfvffsDz10cEXz+CZ+U+3VIiJTZfvJnnOzcktHk4dxm/79zEBTNBTyIF+bZs/uWml/mf7/03WlViu2wV6YJtDNApexRtMq08/iHrt7za+W18Awi+bHp17x5jG0NBhauQE481SY5MlJqaGhYuXMjzzz8PgGVZVFZW8sMf/pDHovkBA5CWQsay4OhR/aF/++36rjQRZ89qMXP+PFxxRf93/EMkrEz2d31Gp/JzU+bsy2pB/smpLP5rTxHFuUFyL2nGF8DPIfZzwjhCBpn46GRGpMx6OKXaEw1LwbH6TL62sImZFYmTD9OSVG3pC1BUpJPhP2dY9O0lpIz4502b7hMUtkV+jxw+lxZidqunJ5ECiI4FdLghZNcCLNcPTlOLNfuVV8GxY5zLgCOFEHBE8qwN3b9oxnko7tRjNWbCwSLodurzAN4QzD4HpZHgWGOWtvFHPuYU4Dbh6mYo6wTldlHvDvJRCXQ5e+aaEYI5TTA57OFshsWO4mDsGkTmExU7Nza7qLjla5zZ/ifeL44kBRs914vO/6Ym3Vbi3dJg7LnYmJGxvtSobd4p7Rnn0i/RPja95hS93i2NLhSwtTz+Wr3HqjmTT+GCezm56784UFmf8HpzTpdhAB9Vxi/n9L7e3NNlYBjsqapP+N7mnSoHYE9Vz7V6Bou3qZ1SH3etd6dA3ST984bNhSzb1nTZrX0nhJAJBoNkZGSwYcMG7r333tjzy5cvp7W1lTfffLPPawKBAIFAz91/e3s7lZWV6SVkPvtMJ1/edVfP3dZANDXBX/+qH6+44vL7QqcQ04QP6vLY+2keCqic1I29l0YxMfmUIxw1DlJMGXPVwvQosx4F2nwOfAE7/3hzfR8RmPYks6VvRgZ0Ja4wifF3fwf/+Z+pm9toMXmyvhERhAnAQ1+Dv0yHZ/4Cyw6Rks2WJkSyb0tLC6ZpUlIS3/m2pKSEw4cP9/uaVatW8eSTT47G9EaGc+d0BObmm5MTMQAlJTqPZvNmnTuTxJIbmZng6tvULtXY7XDj7FYmFwbYcTifI2czqZzkJ8ur1/Ht2JnObApUIVnkiIjpxUWfk2nFXRNPxEByW/o+/jj8+tfQ3JzYprhYV2Xt2DFwVGZS5FaxZYAlumRsiop0yXcqxvnZz2DlysQ244ywoaMv/huuw39oPz6nzhEK2nW0B+J7EkV/RyXfmyhqF+trpPp/HuKjSESuowxoi0SSXCbk+HtdOz8PIi0AFNDuidiFITfQ/1w7Iu/PZeqlun76hNLuHthGGT3juCM2Rj8+6XD1mndkHEPpnCujtS1mf+mcLGXDxBHrQBU0nHS4FSG7hcO04/U7Y/Ft7T89wYA7SNhu4TBteALOPs1BFQq/OzSgDREbvyvEbQedvPj/2og1gx/F7a/HtZAZDj/72c949NFHY79HIzJpQWcntLbCkiXxOyQnQ2GhrnTZuhUuXhzc/sQJfUcYTYIcQQwDppZ0U5QbZNfRXD46kUOrT1Fe2LMjdyFJiK/PEUpBIGRjWmkSEYl05cYb4eGH4eWXdWJ7lMpKeOYZvVnLjBlwvy5Dp3fwOJoP9uKLcNNN8NJLA9utXasfL9fmpZdSN84992ghd/ZsvE1v28mRXjrjwMaBgaO0gsx3d+so9NmzKKXwuXTOT89Y9LSGaGjouw6ShE1syaOwENUrahdbKokskVn9HFmhnuW2OL7zEPzyqdiv3shqbfR1ygDLppfVostwdqWX1pQBrd4ewWYBKmIbHcPvgDZPZJ7R90iv10Qemwb5yDUjgjEUXQ785lcw16/X79fW8757sOCSHjoKelXljTxOC5ae6MLe2+nDbA8yHCbc0tKlpE2OTCgEx4/DggVwyy3Dz3WxLAgPcgdvmvDhh1Bbq+8e8/OHd61hoBQca8hkx+E8mlvdVBZ1k+FO0D/nc0xnt51Wn4MHbm6gIDv9ur8mxfnzOgl4/nz993/unP7wu/nm+OXR//gPLXjO9Cqd7S12hmI3Hm0GEjwbIkmu48lm2bLRm/f69fDoo5cv0ioqdLQ6IsDGWhQmY6MMMCsrCB/6hPA1swk31hPuT8gYQGlENDQOIBxH2KawW0eJUrn99YTIkQGd7FtdXc2aNWsAnexbVVXFypUrx0ey74cfDj160h9nz8LUqXDnnbFdj0cU04Tdu3VIPidHh7pHkTafg51H8jhwMpssj0lpfiAVRVcThlPnPJTlB/j6osaJ6ZeGBvD7dTTlhhsGF+6mCe++q1/Xn9gZit14sxmP4mo8CcdUiabRFGDpKhxTPe/LZMIImfXr17N8+XLWrl1LdXU1zzzzDK+++iqHDx/ukzvTHyMqZD74APbuTc1Y2dmwdOnoCgql9CaH77yjP1yjdwijhGXBoTNZ7KzL56LPSVm+nyyPOTG/uIdI3dlMbr++hbnTUtONddyglO6Z43TqyOPMmSlpG5D2jDdxNd6EYzoKMJn3ZTNhhAzA888/H2uId/311/Pcc89RU1OT1GtHVMiEQgM32BoKbreu0hgLjh6Fbdt0Q7GpU0f9i+V8u5OdR/I42ezFF3DgclgUZIXIzggn3MQybYgu9VlJLJ8ZBthsdIUctHR6+fsvNlCcl3j/mLTDNHW4uaBAVzNMmTLWMxLSiXQUYDLvy2JCCZnLYUSFzETi9GnYsqWnH80ol3ArBRc7nTRedPNpUwb15z10dDuw2xX5mSFyM0NxZdsjTnSjTsvSvrDZeg67DQxbz/OmqcVKOKzFrWn2hFttNnA4kheHlsXZCx4KvH7uv66u74pLdA4R0RN7jP7c+/mofZTo+d7jOBz6iL6XkSIUgk8/1VG/227TlXaCIAgDMCHKr4VRpLJS5+ds2aKT4q64YuBGfCnGMKAgO0RBdoirqzpp73LQcMHNqXNeTp7z8mlDBtjA67KSLuUcCLtNMSkniMOeQMefO6dzhwoL9ZdwMKgfQyGwIsIlGNRCx2YDp0NXgGVm6siay6WjbC6XPpIRhkqBaeI7Aguqu7DNnt0jjqKPgYAWStHnoiKqt5iKCqnoER07GhWKPn/pay+9p4mKomQYTKgFAroC6dZbIS8vuTEFQRCSQISM0ENxse5H01vMuN1jMpWcjDA5GWFmVvjw+e00XnRzusVDa2dqxFWn386xhgzyMsMU5wXil7CiTdhmzYSSfjbzNM34w+HQoi8FUaxAAJyToHxert4gdLj0FjGW1VfQKNUjjnqLtN4/+/0D73M02PV74/HAnDljt3wqCMKERYSMEE9enk469nr1HjlZWXoZYAy7BWd6TK4s6+LKstT1VPEHbRw5m8neT3OpO5tFUU6AwuwQhrJ0SfCMGVCcYPnDbh8xf1y8qINAyfQ0HJBLl5EEQRAmKPIJJ/QlMxMWL9YN9jwenQzc0tJ/P4Q0xeOymDOtg/tubODWa1swTYO6s5m0nunQSuKqq8akmqatTbe6cMgthiAIQlLIx6XQPy4XXHedXl765BP4+GOoq9OZ6clunZAGZHlNqme0Mb28i48P2jl42MY51zWUhT2MfM/jeEIhLWDKL2dJSRAE4XOGCBlhYDIzoboapk/XYubgQb33TXm5PjdByPf6uSXnKLO+cSMfZRVSV6f34KyoGL00odZW3WS5tJ+0HEEQBKF/RMgIyZGf39PA7KOPdHRGKS1o3O7hLcNEq2WiJcuZmWO3plJfD2VllNw+h9uzDGbPhn374MgR3auwpGTkU01aW/UOFaOwl6cgCMKEQYSMMDRKS/W3+qxZuqvxqVP9l+5CfI8T0+zbFM5u7+lj4nDopkpFRTpHZTTp7NTVOjU1kJ2Nga5GLyvTK2u7duk0ofJyLWpGAlNvBk5FxciMLwiCMFERISMMHcPQXVknT9b9VqI9TS49epfwejy6EiraVyV6RHutGIaO8tTWatVQWalfM9JYlm6xPX9+n80/HQ645hotLvbsgf37dc5zZWVqA0d+v3ZjXp4sKwmCIAwVETLC8HE4UrtV+4IFUFWlQyB1dbrnSFnZyK7p1Ndr9bBgQcLr5ObqPm7Tpuk9Qo8f15uGDzdw1N0NHR36CIe1vsvJ0aJJ2qwIgiAMDREywvgi2pTvyiu1ajhyRK/pjMT2Ej6f7kC3ePGg4xuG3oaqtFTvs1lbq6dWVRUfOIr2m7Os+J553d16Bau3cLn+er1KV1iotx+SkmtBEIShIx+dwvjDbtc5OJMn913TSdW2CZal95e64QbdMyZJPJ6ewNHu3Tpw1F/qj80W/+j16suUlOhoTn6+CBdBEIRUIB+lwvglOxu+9CW9prNrl17TSaYW2mbTgid6uFz6sffmjQ0NOvqzcOGwlq6Ki3UD5JkzdZ5w77zl/n72eES4CIIgjATy0SqMbwxDhz9KS3UPm5aWwV8TDusElK4uvXTU2dmTkBytrrLbdeLLZTT3s9v75AcLgiAIo4wIGSE9cLl0UslQsCwtZAIBXRrU+2e7Xe+nJAiCIKQ1ImSEiYvNppNTvN6xnokgCIIwQsimkYIgCIIgpC0iZARBEARBSFtEyAiCIAiCkLaIkBEEQRAEIW0RISMIgiAIQtoiQkYQBEEQhLRFhIwgCIIgCGmLCBlBEARBENIWETKCIAiCIKQtImQEQRAEQUhbRMgIgiAIgpC2iJARBEEQBCFtESEjCIIgCELaMuF3v1ZKAdDe3j7GMxEEQRAEIVmi39vR7/FETHgh09HRAUBlZeUYz0QQBEEQhKHS0dFBbm5uwvOGGkzqpDmWZVFfX092djaGYaRs3Pb2diorKzl9+jQ5OTkpG1foH/H36CL+Hn3E56OL+Ht0GY6/lVJ0dHRQXl6OzZY4E2bCR2RsNhsVFRUjNn5OTo78JxhFxN+ji/h79BGfjy7i79FlqP4eKBITRZJ9BUEQBEFIW0TICIIgCIKQtoiQGSZut5snnngCt9s91lP5XCD+Hl3E36OP+Hx0EX+PLiPp7wmf7CsIgiAIwsRFIjKCIAiCIKQtImQEQRAEQUhbRMgIgiAIgpC2iJARBEEQBCFtESEjCIIgCELaIkJmmLzwwgtMnToVj8dDTU0NH3744VhPaULwzjvvcPfdd1NeXo5hGLzxxhtx55VS/PznP6esrAyv18uSJUs4evTo2Ex2ArBq1SoWLlxIdnY2xcXF3HvvvdTV1cXZ+P1+VqxYQWFhIVlZWdx33300NTWN0YzTmxdffJE5c+bEupsuWrSIt956K3ZefD1yrF69GsMweOSRR2LPib9Tyy9+8QsMw4g7Zs2aFTs/Uv4WITMM1q9fz6OPPsoTTzzBnj17mDt3LkuXLqW5uXmsp5b2+Hw+5s6dywsvvNDv+aeeeornnnuOl156iZ07d5KZmcnSpUvx+/2jPNOJwfbt21mxYgUffPABmzZtIhQKcccdd+Dz+WI2P/rRj/jjH//Ia6+9xvbt26mvr2fZsmVjOOv0paKigtWrV1NbW8vu3bu57bbbuOeee/jkk08A8fVIsWvXLtauXcucOXPinhd/p55rrrmGhoaG2PHee+/Fzo2Yv5UwZKqrq9WKFStiv5umqcrLy9WqVavGcFYTD0Bt3Lgx9rtlWaq0tFQ9/fTTsedaW1uV2+1Wr7zyyhjMcOLR3NysALV9+3allPav0+lUr732Wszm0KFDClA7duwYq2lOKPLz89VvfvMb8fUI0dHRoaZPn642bdqkbrnlFvXwww8rpeRveyR44okn1Ny5c/s9N5L+lojMEAkGg9TW1rJkyZLYczabjSVLlrBjx44xnNnE58SJEzQ2Nsb5Pjc3l5qaGvF9imhrawOgoKAAgNraWkKhUJzPZ82aRVVVlfj8MjFNk3Xr1uHz+Vi0aJH4eoRYsWIFd911V5xfQf62R4qjR49SXl7OFVdcwYMPPsipU6eAkfX3hN/9OtW0tLRgmiYlJSVxz5eUlHD48OExmtXng8bGRoB+fR89Jwwfy7J45JFHuOmmm7j22msB7XOXy0VeXl6crfh8+Ozfv59Fixbh9/vJyspi48aNXH311ezbt098nWLWrVvHnj172LVrV59z8redempqanj55ZeZOXMmDQ0NPPnkk9x8880cOHBgRP0tQkYQBEDfuR44cCBuTVtIPTNnzmTfvn20tbWxYcMGli9fzvbt28d6WhOO06dP8/DDD7Np0yY8Hs9YT+dzwZ133hn7ec6cOdTU1DBlyhReffVVvF7viF1XlpaGyKRJk7Db7X0yrZuamigtLR2jWX0+iPpXfJ96Vq5cyZ/+9Ce2bt1KRUVF7PnS0lKCwSCtra1x9uLz4eNyubjqqquYP38+q1atYu7cuTz77LPi6xRTW1tLc3Mz8+bNw+Fw4HA42L59O8899xwOh4OSkhLx9wiTl5fHjBkzOHbs2Ij+fYuQGSIul4v58+ezefPm2HOWZbF582YWLVo0hjOb+EybNo3S0tI437e3t7Nz507x/TBRSrFy5Uo2btzIli1bmDZtWtz5+fPn43Q643xeV1fHqVOnxOcpwrIsAoGA+DrFLF68mP3797Nv377YsWDBAh588MHYz+LvkaWzs5Pjx49TVlY2sn/fl5Uq/Dll3bp1yu12q5dfflkdPHhQPfTQQyovL081NjaO9dTSno6ODrV37161d+9eBahf/epXau/everkyZNKKaVWr16t8vLy1Jtvvqk+/vhjdc8996hp06ap7u7uMZ55evL9739f5ebmqm3btqmGhobY0dXVFbP53ve+p6qqqtSWLVvU7t271aJFi9SiRYvGcNbpy2OPPaa2b9+uTpw4oT7++GP12GOPKcMw1Ntvv62UEl+PNL2rlpQSf6eaH//4x2rbtm3qxIkT6m9/+5tasmSJmjRpkmpublZKjZy/RcgMkzVr1qiqqirlcrlUdXW1+uCDD8Z6ShOCrVu3KqDPsXz5cqWULsF+/PHHVUlJiXK73Wrx4sWqrq5ubCedxvTna0D97ne/i9l0d3erH/zgByo/P19lZGSor3/966qhoWHsJp3GfPvb31ZTpkxRLpdLFRUVqcWLF8dEjFLi65HmUiEj/k4tDzzwgCorK1Mul0tNnjxZPfDAA+rYsWOx8yPlb0MppS4vpiMIgiAIgjA2SI6MIAiCIAhpiwgZQRAEQRDSFhEygiAIgiCkLSJkBEEQBEFIW0TICIIgCIKQtoiQEQRBEAQhbREhIwiCIAhC2iJCRhAEQRCEtEWEjCAIgiAIaYsIGUEQBEEQ0hYRMoIgCIIgpC3/HymrdeWr+0VzAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if not SMOKE_TEST:\n",
+    "    plt.plot(bo_results_itr.mean(0),color = 'red', label = 'no outliers')\n",
+    "    plt.scatter(range(50),bo_results_itr.mean(0), color = 'red')\n",
+    "    plt.fill_between(range(50),(bo_results_itr.mean(0)-bo_results_itr.std(0))\n",
+    "                    (bo_results_itr.mean(0)+bo_results_itr.std(0)), alpha = 0.3, color = 'red' )\n",
+    "    plt.plot(bo_results_outliers_itr.mean(0),color = 'blue', label = 'baseline')\n",
+    "    plt.scatter(range(50),bo_results_outliers_itr.mean(0), color = 'blue')\n",
+    "    plt.fill_between(range(50),(bo_results_outliers_itr.mean(0)-bo_results_outliers_itr.std(0)),\n",
+    "                    (bo_results_outliers_itr.mean(0)+bo_results_outliers_itr.std(0)), alpha = 0.3, color = 'blue' )\n",
+    "    plt.plot(bo_results_no_outliers_itr.mean(0),color = 'green', label = 'ITGP model')\n",
+    "    plt.scatter(range(50),bo_results_no_outliers_itr.mean(0), color = 'green')\n",
+    "    plt.fill_between(range(50),(bo_results_no_outliers_itr.mean(0)-bo_results_no_outliers_itr.std(0)),\n",
+    "                    (bo_results_no_outliers_itr.mean(0)+bo_results_no_outliers_itr.std(0)), alpha = 0.3, color = 'green' )\n",
+    "\n",
+    "    plt.ylabel('funciton value')\n",
+    "    #plt.yscale('log',base=10)\n",
+    "    plt.legend()\n",
+    "    plt.title('outliers not outrageous')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Outliers moderately outrageous\n",
+    "Now we run optimization to compare the three models for moderately outrageous outliers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "run 00 with current best 4.188: 100%|██████████| 50/50 [00:00<00:00, 79.35it/s]\n",
+      "run 00 with current best 0.045: 100%|██████████| 50/50 [03:07<00:00,  3.75s/it]\n",
+      "run 00 with current best 1.023: 100%|██████████| 50/50 [02:51<00:00,  3.43s/it] \n",
+      "run 00 with current best 0.933: 100%|██████████| 50/50 [03:32<00:00,  4.25s/it]\n",
+      "run 00 with current best 11.852: 100%|██████████| 50/50 [00:02<00:00, 22.12it/s]\n",
+      "run 00 with current best 0.012: 100%|██████████| 50/50 [03:37<00:00,  4.35s/it]\n",
+      "run 00 with current best 1.843: 100%|██████████| 50/50 [03:02<00:00,  3.66s/it] \n",
+      "run 00 with current best 3.134: 100%|██████████| 50/50 [03:31<00:00,  4.24s/it]\n",
+      "run 00 with current best 4.840: 100%|██████████| 50/50 [00:01<00:00, 37.90it/s]\n",
+      "run 00 with current best 0.060: 100%|██████████| 50/50 [03:26<00:00,  4.13s/it]\n",
+      "run 00 with current best 5.150: 100%|██████████| 50/50 [03:14<00:00,  3.89s/it]\n",
+      "run 00 with current best 0.406: 100%|██████████| 50/50 [03:54<00:00,  4.68s/it]\n",
+      "run 00 with current best 1.410: 100%|██████████| 50/50 [00:01<00:00, 30.63it/s]\n",
+      "run 00 with current best 0.099: 100%|██████████| 50/50 [03:33<00:00,  4.26s/it]\n",
+      "run 00 with current best 37.368: 100%|██████████| 50/50 [02:50<00:00,  3.41s/it]\n",
+      "run 00 with current best 0.111: 100%|██████████| 50/50 [03:37<00:00,  4.36s/it] \n",
+      "run 00 with current best 3.450: 100%|██████████| 50/50 [00:00<00:00, 53.60it/s] \n",
+      "run 00 with current best 0.052: 100%|██████████| 50/50 [03:56<00:00,  4.74s/it]\n",
+      "run 00 with current best 13.047: 100%|██████████| 50/50 [03:18<00:00,  3.96s/it]\n",
+      "run 00 with current best 1.298: 100%|██████████| 50/50 [03:50<00:00,  4.60s/it] \n",
+      "run 00 with current best 4.837: 100%|██████████| 50/50 [00:01<00:00, 42.03it/s]\n",
+      "run 00 with current best 0.040: 100%|██████████| 50/50 [03:26<00:00,  4.13s/it]\n",
+      "run 00 with current best 0.256: 100%|██████████| 50/50 [03:15<00:00,  3.91s/it]\n",
+      "run 00 with current best 1.666: 100%|██████████| 50/50 [03:42<00:00,  4.46s/it]\n",
+      "run 00 with current best 1.025: 100%|██████████| 50/50 [00:01<00:00, 34.97it/s]\n",
+      "run 00 with current best 0.048: 100%|██████████| 50/50 [03:19<00:00,  3.99s/it]\n",
+      "run 00 with current best 7.478: 100%|██████████| 50/50 [02:52<00:00,  3.45s/it]\n",
+      "run 00 with current best 2.796: 100%|██████████| 50/50 [03:43<00:00,  4.46s/it]\n",
+      "run 00 with current best 17.331: 100%|██████████| 50/50 [00:01<00:00, 47.37it/s]\n",
+      "run 00 with current best 0.004: 100%|██████████| 50/50 [03:09<00:00,  3.79s/it]\n",
+      "run 00 with current best 4.328: 100%|██████████| 50/50 [03:33<00:00,  4.26s/it]\n",
+      "run 00 with current best 0.041: 100%|██████████| 50/50 [04:17<00:00,  5.14s/it]\n",
+      "run 00 with current best 14.295: 100%|██████████| 50/50 [00:01<00:00, 39.10it/s]\n",
+      "run 00 with current best 0.000: 100%|██████████| 50/50 [03:16<00:00,  3.93s/it] \n",
+      "run 00 with current best 7.074: 100%|██████████| 50/50 [03:38<00:00,  4.37s/it]\n",
+      "run 00 with current best 0.047: 100%|██████████| 50/50 [03:55<00:00,  4.71s/it]\n",
+      "run 00 with current best 0.386: 100%|██████████| 50/50 [00:01<00:00, 39.47it/s] \n",
+      "run 00 with current best 0.045: 100%|██████████| 50/50 [03:16<00:00,  3.93s/it]\n",
+      "run 00 with current best 1.059: 100%|██████████| 50/50 [02:55<00:00,  3.52s/it] \n",
+      "run 00 with current best 0.023: 100%|██████████| 50/50 [03:33<00:00,  4.26s/it] \n"
+     ]
+    }
+   ],
+   "source": [
+    "bo_results_set=[]\n",
+    "bo_results_outliers_set=[]\n",
+    "bo_results_no_outliers_set=[]\n",
+    "n_iterations = 10 if not SMOKE_TEST else 1\n",
+    "for kk in range(n_iterations):\n",
+    "    Benchmark = Himmelblau()\n",
+    "    sampled = sample(Benchmark.domain)\n",
+    "    sampled_xy = Benchmark.f(sampled, return_complete=True)\n",
+    "    random_results = run(\n",
+    "        Himmelblau(),\n",
+    "        strategy_factory=RandomStrategy,\n",
+    "        n_iterations=50,                     # random strategy \n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    bo_results = run(\n",
+    "        Himmelblau(),\n",
+    "        strategy_factory=partial(SoboStrategy, acquisition_function=qEI()),\n",
+    "        n_iterations=50 if not SMOKE_TEST else 1,\n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    Benchmark = Himmelblau(outlier_rate = 0.2, outlier_prior = UniformOutlierPrior(bounds =(500,1000)))\n",
+    "    sampled_xy1 = Benchmark.f(sampled, return_complete=True)\n",
+    "\n",
+    "    bo_results_outliers = run(\n",
+    "        Benchmark,\n",
+    "        strategy_factory=partial(SoboStrategy, acquisition_function=qEI()),\n",
+    "        n_iterations=50 if not SMOKE_TEST else 1,\n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy1,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    domain = Benchmark.domain\n",
+    "    detectors = []\n",
+    "    for output_feature in domain.outputs.get_keys():\n",
+    "        if len(domain.inputs.get(CategoricalInput, exact=True)):\n",
+    "                detectors.append(IterativeTrimming(\n",
+    "                        base_gp=MixedSingleTaskGPSurrogate(\n",
+    "                            inputs=domain.inputs,\n",
+    "                            outputs=Outputs(features=[domain.outputs.get_by_key(output_feature)]),  # type: ignore\n",
+    "                        ))\n",
+    "                    )\n",
+    "        else:\n",
+    "            detectors.append(IterativeTrimming(\n",
+    "                base_gp=SingleTaskGPSurrogate(\n",
+    "                    inputs=domain.inputs,\n",
+    "                    outputs=Outputs(features=[domain.outputs.get_by_key(output_feature)]),  # type: ignore\n",
+    "                ))\n",
+    "            )\n",
+    "    outlier_detection_specs = OutlierDetections(detectors=detectors)\n",
+    "\n",
+    "    bo_results_no_outliers = run(\n",
+    "        Benchmark,\n",
+    "        strategy_factory=partial(SoboStrategy, acquisition_function=qEI(), outlier_detection_specs = outlier_detection_specs,\n",
+    "                                min_experiments_before_outlier_check = 10, \n",
+    "                                frequency_check = 2),\n",
+    "        n_iterations=50 if not SMOKE_TEST else 1,\n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy1,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    bo_results_set.append(bo_results[0])\n",
+    "    bo_results_outliers_set.append(bo_results_outliers[0])\n",
+    "    bo_results_no_outliers_set.append(bo_results_no_outliers[0])\n",
+    "\n",
+    "## Collecting data evolution over iterations\n",
+    "\n",
+    "bo_results_itr = np.zeros((len(bo_results_set),50))\n",
+    "bo_results_outliers_itr = np.zeros((len(bo_results_set),50))\n",
+    "bo_results_no_outliers_itr = np.zeros((len(bo_results_set),50))\n",
+    "for i in range(len(bo_results_set)):\n",
+    "    bo_results_itr[i] = bo_results_set[i][1].to_numpy()\n",
+    "    bo_results_outliers_itr[i] = bo_results_outliers_set[i][1].to_numpy()\n",
+    "    bo_results_no_outliers_itr[i] = bo_results_no_outliers_set[i][1].to_numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Performance of models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'outliers moderately outrageous')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGzCAYAAAA1yP25AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAACs0klEQVR4nOzdd2Bb1dn48e+9V9O2vHdiZ+9BaFgJkIQACWGTtLSMhhn6FigjFF7SvpQy2pS2rEKhrAb6a1IoEDaFMLIYgYYkZG/HTpx4xPGSbcmydH9/XFux4iXbkmXFz4eqjq6O7j2Whx6fc57nKLqu6wghhBBCRCE10h0QQgghhOgqCWSEEEIIEbUkkBFCCCFE1JJARgghhBBRSwIZIYQQQkQtCWSEEEIIEbUkkBFCCCFE1JJARgghhBBRSwIZIYQQQkQtCWSECMKKFStQFIUVK1b4j1177bUMHDgwYn3qbY6H10NRFH77299GuhtCiE6QQEaIZp555hlefvnlSHdDdEFf+NotWbKEJ554ItLdEKJXkUBGiGY682b4wgsvsGPHjvB2SARNAhkh+iYJZIToIrPZjNVqDcm5dF2nrq4uJOc6Hsjr0X0ulwufzxfpbggRdhLIiKi2fv16Zs2aRXx8PHFxcZx99tmsWbMmoM1vf/tbFEVp8dyXX34ZRVHYt28fAAMHDmTLli2sXLkSRVFQFIVp06a1ee3W1oT4fD6eeOIJxowZg81mIyMjg5/97GeUl5cHtBs4cCAXXnghH3/8MSeddBJ2u53nnnsOgE8++YQzzjiDxMRE4uLiGDFiBL/61a86fC0UReHWW2/l9ddfZ/To0djtdiZNmsSmTZsAeO655xg6dCg2m41p06b5P+/mXn/9dSZOnIjdbic1NZWrr76awsLCFu3efvttxo4di81mY+zYsbz11lut9ikUr8eiRYuYPn066enpWK1WRo8ezbPPPtvi+e197SoqKrjjjjvIycnBarUydOhQHnnkkXbf6JcvX46iKK1+bkuWLEFRFL7++us2nw+wd+9efvSjH5GcnExMTAynnXYaH3zwQUCbY78Pmxy7LmvatGl88MEH5Ofn+z/Hpu+/pravvvoq//d//0e/fv2IiYmhqqqKI0eO8Mtf/pJx48YRFxdHfHw8s2bN4vvvv2/R3/z8fC6++GJiY2NJT0/nzjvv5OOPP26xPgzgm2++4bzzziMhIYGYmBimTp3Kl19+2eKcofwZBVi7di0zZ84kNTUVu93OoEGDuP7669v4Coi+wBTpDgjRVVu2bOHMM88kPj6ee+65B7PZzHPPPce0adNYuXIlp556aqfO98QTT/CLX/yCuLg4fv3rXwOQkZHRqXP87Gc/4+WXX+a6667jtttuIy8vj6effpr169fz5ZdfYjab/W137NjBFVdcwc9+9jPmzZvHiBEj2LJlCxdeeCHjx4/nwQcfxGq1snv37lbfIFqzevVq3n33XW655RYAFi5cyIUXXsg999zDM888w80330x5eTl//OMfuf766/n888/9z23q98knn8zChQspLi7mySef5Msvv2T9+vUkJiYCsGzZMubMmcPo0aNZuHAhZWVlXHfddfTv3z/krwfAs88+y5gxY7j44osxmUy899573Hzzzfh8Pv/n2d7Xrra2lqlTp1JYWMjPfvYzcnNz+eqrr1iwYAGHDh1qc6pm2rRp5OTksHjxYi677LKAxxYvXsyQIUOYNGlSm1+L4uJiJk+eTG1tLbfddhspKSm88sorXHzxxbzxxhstztmRX//611RWVnLgwAEef/xxAOLi4gLaPPTQQ1gsFn75y1/idruxWCxs3bqVt99+mx/96EcMGjSI4uJinnvuOaZOncrWrVvJzs4GoKamhunTp3Po0CFuv/12MjMzWbJkCcuXL2/Rl88//5xZs2YxceJE7r//flRV9Qecq1ev5pRTTgFC/zNaUlLCjBkzSEtL49577yUxMZF9+/axdOnSTp1HHGd0IaLUpZdeqlssFn3Pnj3+YwcPHtQdDoc+ZcoU/7H7779fb+1bfdGiRTqg5+Xl+Y+NGTNGnzp1aou2y5cv1wF9+fLl/mPXXHONPmDAAP/91atX64C+ePHigOd+9NFHLY4PGDBAB/SPPvoooO3jjz+uA3ppaWlHn34LgG61WgM+n+eee04H9MzMTL2qqsp/fMGCBQGfe319vZ6enq6PHTtWr6ur87d7//33dUD/zW9+4z82YcIEPSsrS6+oqPAfW7ZsmQ6E/PXQdV2vra1tcWzmzJn64MGDA4619bV76KGH9NjYWH3nzp0Bx++9915d0zS9oKDAfwzQ77//fv/9BQsW6FarNeBzLSkp0U0mU0C71txxxx06oK9evdp/rLq6Wh80aJA+cOBA3ev16rre+vehrrf+PXfBBRcEvMbHth08eHCL18vlcvmv1SQvL0+3Wq36gw8+6D/26KOP6oD+9ttv+4/V1dXpI0eODOiHz+fThw0bps+cOVP3+Xz+trW1tfqgQYP0c889138s1D+jb731lg7o//3vf1u0FX2XTC2JqOT1elm2bBmXXnopgwcP9h/Pysriyiuv5IsvvqCqqqpH+/T666+TkJDAueeey+HDh/23iRMnEhcX1+Iv20GDBjFz5syAY02jHu+8806X1jecffbZAdNdTX/xzpkzB4fD0eL43r17AWO4vqSkhJtvvhmbzeZvd8EFFzBy5Ej/dMihQ4fYsGED11xzDQkJCf525557LqNHjw756wFgt9v9/66srOTw4cNMnTqVvXv3UllZ2eFr8vrrr3PmmWeSlJQU0I9zzjkHr9fLqlWr2nzu3LlzcbvdvPHGG/5jr732Gg0NDVx99dXtXvfDDz/klFNO4YwzzvAfi4uL46abbmLfvn1s3bq1w7531jXXXBPwegFYrVZU1fhV7/V6KSsr809Zrlu3zt/uo48+ol+/flx88cX+YzabjXnz5gWcb8OGDezatYsrr7ySsrIy/+tZU1PD2WefzapVq/D5fGH5GW36+Xj//ffxeDydeq44fkkgI6JSaWkptbW1/umH5kaNGoXP52P//v092qddu3ZRWVlJeno6aWlpATen00lJSUlA+0GDBrU4x49//GNOP/10brzxRjIyMvjJT37Cv//976CDmtzc3ID7TcFGTk5Oq8eb1qrk5+cDtPp6jhw50v9408dhw4a1aHfsc0PxegB8+eWXnHPOOcTGxpKYmEhaWpp/zVAwgcyuXbv46KOPWvThnHPOAWjRj2M/95NPPpnFixf7jy1evJjTTjuNoUOHtnvd/Pz8Nr8/mx4PtdZeQ5/Px+OPP86wYcOwWq2kpqaSlpbGxo0bA16//Px8hgwZ0mKtyrGf565duwAjaDr2NX3xxRdxu91UVlaG5Wd06tSpzJkzhwceeIDU1FQuueQSFi1ahNvt7tR5xPFF1siI415riwjB+Os0lHw+H+np6QFves2lpaUF3D/2L+emY6tWrWL58uV88MEHfPTRR7z22mtMnz6dZcuWoWlau31o6/G2juu63u75uiMUr8eePXs4++yzGTlyJI899hg5OTlYLBY+/PBDHn/88aACPJ/Px7nnnss999zT6uPDhw9v9/lz587l9ttv58CBA7jdbtasWcPTTz/d4XWDFcrvz9Zew9///vfcd999XH/99Tz00EMkJyejqip33HFHl0b9mp7zpz/9iQkTJrTaJi4urlPBRbCvgaIovPHGG6xZs4b33nuPjz/+mOuvv55HH32UNWvWtFgzJPoGCWREVEpLSyMmJqbVOi7bt29HVVX/KERSUhJgZK40DU1D638Rt/ULNRhDhgzh008/5fTTT2/1DSVYqqpy9tlnc/bZZ/PYY4/x+9//nl//+tcsX77cP4oQagMGDACMBbfTp08PeGzHjh3+x5s+Nv1Vfmy75kLxerz33nu43W7efffdgNGm1hagtvW1GzJkCE6ns8uv3U9+8hPmz5/Pv/71L+rq6jCbzfz4xz/u8HkDBgxo8/uz6XEI/P5sLlTfn2+88QZnnXUWL730UsDxiooKUlNTA/q7detWdF0PuM7u3bsDnjdkyBAA4uPj231Nw/UzCnDaaadx2mmn8bvf/Y4lS5Zw1VVX8eqrr3LjjTe22R9x/JKpJRGVNE1jxowZvPPOOwGpmcXFxSxZsoQzzjiD+Ph44Ogv3uZrIWpqanjllVdanDc2NrbFG0qwLr/8crxeLw899FCLxxoaGoI675EjR1oca/qrN5zD5yeddBLp6en87W9/C7jOf/7zH7Zt28YFF1wAGOsbJkyYwCuvvBIwLfHJJ5+0WPMRitejaSSp+chRZWUlixYtatG2ra/d5Zdfztdff83HH3/c4rGKigoaGhra7UNqaiqzZs3in//8J4sXL+a8884LCADacv755/Ptt98GpGjX1NTw/PPPM3DgQP+aota+P71eL88//3yrn2Mw02nNaZrWYuTt9ddfb5FWP3PmTAoLC3n33Xf9x1wuFy+88EJAu4kTJzJkyBD+/Oc/43Q6W1yvtLTUf91Q/4yWl5e3+Fx64udD9G4yIiOi1sMPP+yvuXLzzTdjMpl47rnncLvd/PGPf/S3mzFjBrm5udxwww3cfffdaJrG3//+d9LS0igoKAg458SJE3n22Wd5+OGHGTp0KOnp6S1GKNoydepUfvazn7Fw4UI2bNjAjBkzMJvN7Nq1i9dff50nn3ySH/7wh+2e48EHH2TVqlVccMEFDBgwgJKSEp555hn69+8fsGg01MxmM4888gjXXXcdU6dO5YorrvCnXw8cOJA777zT33bhwoVccMEFnHHGGVx//fUcOXKEp556ijFjxgS8sYXi9ZgxYwYWi4WLLrqIn/3sZzidTl544QXS09M5dOhQQNu2vnZ333037777LhdeeCHXXnstEydOpKamhk2bNvHGG2+wb9++DgOTuXPn+vvaWmDWmnvvvZd//etfzJo1i9tuu43k5GReeeUV8vLyePPNN/0LcMeMGcNpp53GggULOHLkCMnJybz66qutBlgTJ07ktddeY/78+Zx88snExcVx0UUXtduPCy+8kAcffJDrrruOyZMns2nTJhYvXhywABeMVPmnn36aK664gttvv52srCwWL17sX/zdNEqjqiovvvgis2bNYsyYMVx33XX069ePwsJCli9fTnx8PO+99x4Q+p/RV155hWeeeYbLLruMIUOGUF1dzQsvvEB8fDznn39+UF8XcRyKaM6UEN20bt06febMmXpcXJweExOjn3XWWfpXX33Vot13332nn3rqqbrFYtFzc3P1xx57rNW016KiIv2CCy7QHQ6HDvjTeYNJv27y/PPP6xMnTtTtdrvucDj0cePG6ffcc49+8OBBf5sBAwboF1xwQYvnfvbZZ/oll1yiZ2dn6xaLRc/OztavuOKKFqnDrQH0W265JeBYXl6eDuh/+tOfAo43fT6vv/56wPHXXntNP/HEE3Wr1aonJyfrV111lX7gwIEW13rzzTf1UaNG6VarVR89erS+dOnSsLweuq7r7777rj5+/HjdZrPpAwcO1B955BH973//e9BfO1030p4XLFigDx06VLdYLHpqaqo+efJk/c9//rNeX18f8Bq2llbtdrv1pKQkPSEhISA9vSN79uzRf/jDH+qJiYm6zWbTTznlFP39999vtd0555yjW61WPSMjQ//Vr36lf/LJJy2+55xOp37llVfqiYmJAenubX09dd1Iv77rrrv0rKws3W6366effrr+9ddf61OnTm2Rrr537179ggsu0O12u56Wlqbfdddd+ptvvqkD+po1awLarl+/Xp89e7aekpKiW61WfcCAAfrll1+uf/bZZwHtQvkzum7dOv2KK67Qc3NzdavVqqenp+sXXnihvnbt2iC+GuJ4peh6GFf7CSHEcaChoYHs7GwuuuiiFmtNjndPPPEEd955JwcOHKBfv36R7o4QLcgaGSGE6MDbb79NaWkpc+fOjXRXwurY/a1cLhfPPfccw4YNkyBG9FqyRkYIIdrwzTffsHHjRh566CFOPPFEpk6dGukuhdXs2bPJzc1lwoQJVFZW8s9//pPt27e3mUIvRG8ggYwQQrTh2Wef5Z///CcTJkzg5ZdfjnR3wm7mzJm8+OKLLF68GK/Xy+jRo3n11VeDSjcXIlJkjYwQQgghopaskRFCCCFE1JJARgghhBBR67hfI+Pz+Th48CAOh6Nb5eeFEEII0XN0Xae6uprs7Gx/AcnWHPeBzMGDB1vs/CuEEEKI6LB//3769+/f5uPHfSDjcDgA44Vo2tdDCCGEEL1bVVUVOTk5/vfxthz3gUzTdFJ8fLwEMkIIIUSU6WhZiCz2FUIIIUTUkkBGCCGEEFFLAhkhhBBCRK3jfo2MEEKI3s3r9eLxeCLdDdHDNE3DZDJ1uzSKBDJCCCEixul0cuDAAWS3nL4pJiaGrKwsLBZLl88hgYwQQoiI8Hq9HDhwgJiYGNLS0qRoaR+i6zr19fWUlpaSl5fHsGHD2i161x4JZIQQQkSEx+NB13XS0tKw2+2R7o7oYXa7HbPZTH5+PvX19dhsti6dRxb7CiGEiCgZiem7ujoKE3COEPRDCCGEECIiJJARQgghRNSKaCDz7LPPMn78eP/2AZMmTeI///mP/3GXy8Utt9xCSkoKcXFxzJkzh+Li4gj2WAghhIguL7/8MomJif77v/3tb5kwYULE+hNqEQ1k+vfvzx/+8Ae+++471q5dy/Tp07nkkkvYsmULAHfeeSfvvfcer7/+OitXruTgwYPMnj07kl0WQggheq2BAwfyxBNPtNvml7/8JZ999lnPdKgHRDRr6aKLLgq4/7vf/Y5nn32WNWvW0L9/f1566SWWLFnC9OnTAVi0aBGjRo1izZo1nHbaaa2e0+1243a7/ferqqrC9wkIIYQQUSYuLo64uLhuncPj8WA2m0PUo+7pNWtkvF4vr776KjU1NUyaNInvvvsOj8fDOeec428zcuRIcnNz+frrr9s8z8KFC0lISPDfcnJywtbn/ZX7OVh9MGznF0KIPkXXoaYmMrdOFOSbNm0at912G/fccw/JyclkZmby29/+NqBNQUEBl1xyCXFxccTHx3P55Zd3uDRi06ZNTJ8+HbvdTkpKCjfddBNOpzPgunfccUfAcy699FKuvfZa/+P5+fnceeedKIrSZjZYa1NLL774IqNGjcJmszFy5EieeeYZ/2P79u1DURRee+01pk6dis1mY/HixeTn53PRRReRlJREbGwsY8aM4cMPP2z/xQuDiNeR2bRpE5MmTcLlchEXF8dbb73F6NGj2bBhAxaLJWBeDyAjI4OioqI2z7dgwQLmz5/vv19VVRW2YCavIo8jdUe4eMTFqEqviQmFECI61dZCN0cKuszphNjYoJu/8sorzJ8/n2+++Yavv/6aa6+9ltNPP51zzz0Xn8/nD2JWrlxJQ0MDt9xyCz/+8Y9ZsWJFq+erqalh5syZTJo0if/+97+UlJRw4403cuutt/Lyyy8H1aelS5dywgkncNNNNzFv3rygP5fFixfzm9/8hqeffpoTTzyR9evXM2/ePGJjY7nmmmv87e69914effRRTjzxRGw2G/PmzaO+vp5Vq1YRGxvL1q1buz3S0xURD2RGjBjBhg0bqKys5I033uCaa65h5cqVXT6f1WrFarWGsIftK6gs4FD1IfrF9+uxawohhIis8ePHc//99wMwbNgwnn76aT777DPOPfdcPvvsMzZt2kReXp7/D+l//OMfjBkzhv/+97+cfPLJLc63ZMkSXC4X//jHP4htDKiefvppLrroIh555BEyMjI67FNycjKapuFwOMjMzAz6c7n//vt59NFH/WtQBw0axNatW3nuuecCApk77rgjYJ1qQUEBc+bMYdy4cQAMHjw46GuGUsQDGYvFwtChQwGYOHEi//3vf3nyySf58Y9/TH19PRUVFQGjMsXFxZ36AoVbWW0Zu8p2SSAjhBDdFRNjjIxE6tqdMH78+ID7WVlZlJSUALBt2zZycnICZgNGjx5NYmIi27ZtazWQ2bZtGyeccII/iAE4/fTT8fl87NixI6hApitqamrYs2cPN9xwQ8AoTkNDAwkJCQFtTzrppID7t912Gz//+c9ZtmwZ55xzDnPmzGnxuvSEiAcyx/L5fLjdbiZOnIjZbOazzz5jzpw5AOzYsYOCggImTZoU4V4epSoqO4/sZELWBBJtiZHujhBCRC9F6dT0TiQdu9BVURR8Pl9Yr6mqaovNNbu7a3jTGpwXXniBU089NeAxTdMC7sce87W58cYbmTlzJh988AHLli1j4cKFPProo/ziF7/oVp86K6ILOxYsWMCqVavYt28fmzZtYsGCBaxYsYKrrrqKhIQEbrjhBubPn8/y5cv57rvvuO6665g0aVKbGUuREG+Np9JVyd4jeyPdFSGEEL3AqFGj2L9/P/v37/cf27p1KxUVFYwePbrN53z//ffU1NT4j3355ZeoqsqIESMASEtL49ChQ/7HvV4vmzdvDjiPxWLB6/UG3deMjAyys7PZu3cvQ4cODbgNGjSow+fn5OTwP//zPyxdupS77rqLF154Iehrh0pEA5mSkhLmzp3LiBEjOPvss/nvf//Lxx9/zLnnngvA448/zoUXXsicOXOYMmUKmZmZLF26NJJdbkFBIcGawNbDW3E3uDt+ghBCiOPaOeecw7hx47jqqqtYt24d3377LXPnzmXq1KktpmeaXHXVVdhsNq655ho2b97M8uXL+cUvfsFPf/pT/7TS9OnT+eCDD/jggw/Yvn07P//5z6moqAg4z8CBA1m1ahWFhYUcPnw4qP4+8MADLFy4kL/85S/s3LmTTZs2sWjRIh577LF2n3fHHXfw8ccfk5eXx7p161i+fDmjRo0K6pqhFNGppZdeeqndx202G3/961/561//2kM96pq02DTyKvLIr8xneMrwSHdHCCFEBCmKwjvvvMMvfvELpkyZgqqqnHfeeTz11FNtPicmJoaPP/6Y22+/nZNPPpmYmBjmzJkTEExcf/31fP/998ydOxeTycSdd97JWWedFXCeBx98kJ/97GcMGTIEt9vdYiqqNTfeeCMxMTH86U9/4u677yY2NpZx48a1SPU+ltfr5ZZbbuHAgQPEx8dz3nnn8fjjj3d4vVBT9GA+yyhWVVVFQkIClZWVxMfHh/Tcq/JXse7gOoYkDyGvIo8BCQO4aMRFkoothBBBcLlc5OXlMWjQIGw2W6S7IyKgve+BYN+/5R03RDJiMyioLKDI2XaNGyGEEEKElgQyIRJjjqHeW8+usl2R7ooQQgjRZ0ggE0JpMWnsLNtJpasy0l0RQggh+gQJZEIo0ZZIhauCveWSii2EEEL0BAlkQkhRFOKt8Wwp3UK9tz7S3RFCCCGOexLIhFhaTBrFzmLyK/Ij3RUhhBDiuCeBTIiZNTNm1cy2w9vw6eEtVy2EEEL0dRLIhEFGnKRiCyGEED1BApkwiDHH4G5ws+uIpGILIYQQ4SSBTJikxqSy6/AuqtxVke6KEEKIEJo2bVqH5fvD6dprr+XSSy/tNf2JtIjutXQ8S7Ilsb1sO3nleZyQeUKkuyOEEOI4tXTpUsxmc6S7ETEyIhMmimLsir25ZLOkYgshhAib5ORkHA5HpLsRMRLIhJGkYgshRPB0HWpqInPr7PbJDQ0N3HrrrSQkJJCamsp9993n32n6//2//8dJJ52Ew+EgMzOTK6+8kpKSEv9zy8vLueqqq0hLS8NutzNs2DAWLVrkf3z//v1cfvnlJCYmkpyczCWXXMK+ffva7MuxU0sDBw7k97//Pddffz0Oh4Pc3Fyef/75gOd09hq9mUwtdcOuzwv478Y95HtdbbYp1Q6xOfZf2LNHEa+lE6clY1Mc2NV4bKoDkxLa4UBFAYcDkpMhIQHi4iA21vgYEwOqhK5CiF6qttb4XRUJTqfxuzJYr7zyCjfccAPffvsta9eu5aabbiI3N5d58+bh8Xh46KGHGDFiBCUlJcyfP59rr72WDz/8EID77ruPrVu38p///IfU1FR2795NXV0dAB6Ph5kzZzJp0iRWr16NyWTi4Ycf5rzzzmPjxo1YLJag+vfoo4/y0EMP8atf/Yo33niDn//850ydOpURI0aE7Bq9hQQy3VBb7qay3EdKTNttklwp1NW7qE4qpsxUiK57AQWzYsOixBCrJhOvpWNTHSgdDJCpqCRruVhUe5ttdB0OHYJ9+8DrNY6ZzWCzgd0OSUmQkgJWqxH0tCc2FoYMAU1rv50QQvQ1OTk5PP744yiKwogRI9i0aROPP/448+bN4/rrr/e3Gzx4MH/5y184+eSTcTqdxMXFUVBQwIknnshJJ50EGCMoTV577TV8Ph8vvvgiSuMv6UWLFpGYmMiKFSuYMWNGUP07//zzufnmmwH43//9Xx5//HGWL1/OiBEjQnaN3kICmW4ymSAhtZ1RFZ9GYoUbLPGQmASArvuo1124fbXU+w5QpO9GJ7hxzWRTNsNiTybTOhhVCW54pb4eXC5wuyE/H3buDG4YVVFg1Cg45RQj+BFCiHCKiTFGRiJ17c447bTT/EEAwKRJk3j00Ufxer1s2LCB3/72t3z//feUl5fj8xnFUQsKChg9ejQ///nPmTNnDuvWrWPGjBlceumlTJ48GYDvv/+e3bt3t1jz4nK52LNnT9D9Gz9+vP/fiqKQmZnpn94K1TV6Cwlkwq1pLqeqyh/IKIqKVYnBqnbuJ8eneynzFPLfqvfJsY5iaOxJxJs6jjAsFuPWWS4XbNkCBw8awcyoUUbgJoQQ4aAonZve6Y1cLhczZ85k5syZLF68mLS0NAoKCpg5cyb19Ubix6xZs8jPz+fDDz/kk08+4eyzz+aWW27hz3/+M06nk4kTJ7J48eIW505LSwu6H8dmMSmK4g+oQnWN3kLelnqC1QoVFdCvH2hdf8lVRSPNkovbV0t+3SZKPQUMtU8k1z4Gs2oNXX8b2WwwfDgUF8PHHxujOaeeClH4fS6EECH1zTffBNxfs2YNw4YNY/v27ZSVlfGHP/yBnJwcANauXdvi+WlpaVxzzTVcc801nHnmmdx99938+c9/5gc/+AGvvfYa6enpxMfHh6XvPXGNniRLP3uCzQZ1dVBTG5LTWdUYsq3DUdH4vvpzvq18l2L3Pv+K+VBSFMjMhIEDYccOePtt2LABPJ6QX0oIIaJGQUEB8+fPZ8eOHfzrX//iqaee4vbbbyc3NxeLxcJTTz3F3r17effdd3nooYcCnvub3/yGd955h927d7Nlyxbef/99Ro0aBcBVV11Famoql1xyCatXryYvL48VK1Zw2223ceDAgZD0vSeu0ZMkkOkJmga6D2qqQ3ZKRVFIMKWRZR3MEU8R31a8yybnCpwNFSG7RnNWqzE6o2nw6afwn/9AkWwlJYToo+bOnUtdXR2nnHIKt9xyC7fffjs33XQTaWlpvPzyy7z++uuMHj2aP/zhD/z5z38OeK7FYmHBggWMHz+eKVOmoGkar776KgAxMTGsWrWK3NxcZs+ezahRo7jhhhtwuVwhGz3piWv0JEUPx5/xvUhVVRUJCQlUVlaG/Av01GMv8dnWdYzLHtxx4+pqsFhh9ChQQ58GVOetpqyhEIeWQozW0eepMMg+nmzbsC5dq77emGaKjYUTTuj8IrnuyMqSqS0hjhcul4u8vDwGDRqEzWaLdHdEBLT3PRDs+7eskekpdhs4a40pptjQF0qwaw76qSOo8h6muqGs3bbOhnLiTaldDmQsFhg2DA4fhi+/7NIpusTthmnTJJARQghxlAQyPcVkhgYPOGvCEsjA0emmYFQ1lHTcqAOpqcatpxQUGGumhRBCiCayRqYnmc1QUQ5B1owJWzcUG7Xeajy+6NoDymIxApnjezJUCCFEZ0gg05NsdmNEpq7tLQ16gkW14fG5cPkiVHmqi6zWo4X9hBBCCJBApmdZzOBxQ01kAwiLYqNej85Axu02lhkJIYQQIIFMz1IUoyBeZWWEu6Gio1Pnjc5ApjY05XiEEEIcBySQ6WlWq5GKXR/Z+REFhTpv6Ora9ARNMzbClEBGCCFEEwlkelrTQo9I7YzWyKxYqW44HNE+dJVMLQkhhGgigUxPU1Vjiqk6sqMhZsVGtfcIPt0X0X50lqJEPAYUQgjRi0ggEwlNm0g2RG7DIotqw63X4fZF1zyN1Qrl5ZHuhRBC9E3Tpk3jjjvuCLr9yy+/TGJiYtj6AxLIRIbNZkwv1dRErAsW1Y7HG32ZSxaLsVZaaskIISLl2muv5dJLLwWMQqTt3X7729/6n/fmm28yffp0kpKSsNvtjBgxguuvv57169f727z88sv+56qqSv/+/bnuuusoKel+EdPjlQQykaBpxjtxdeSCCJNipgFPVGYu1dVJLRkhRO9w6NAh/+2JJ54gPj4+4Ngvf/lLAP73f/+XH//4x0yYMIF3332XHTt2sGTJEgYPHsyCBQsCztl0jgMHDvDCCy/wn//8h5/+9KeR+PSigmxREClWq1HlNzsrLJtIBivaRmSsVmMgq7bWGNgSQhw/dF2n1hOZ6e4YcwyKonT6eZmZmf5/JyQkoChKwDGANWvW8Mc//pEnn3yS2267zX88NzeXiRMncuzezc3PkZ2dzW233cZ9991HXV0ddru9RR+mTZvGuHHj0DSNV155BYvFwsMPP8yVV17JrbfeyhtvvEFGRgZPPfUUs2bN8j9v5cqV3H333Xz//fckJydzzTXX8PDDD2MyGaFBTU0NP//5z1m6dCkOh8MflDXndrv59a9/zb/+9S8qKioYO3YsjzzyCNOmTev0a9lVEshEis1mrFqtrYU4R0S6oKHhbIiuBSdSFE+I41etp5a4heHZi64jzgVOYi2xYTn3v/71L+Li4rj55ptbfbyjAMput+Pz+WhoaGizzSuvvMI999zDt99+y2uvvcbPf/5z3nrrLS677DJ+9atf8fjjj/PTn/6UgoICYmJiKCws5Pzzz+faa6/lH//4B9u3b2fevHnYbDb/dNjdd9/NypUreeedd0hPT+dXv/oV69atY8KECf7r3nrrrWzdupVXX32V7Oxs3nrrLc477zw2bdrEsGFd25i4s2RqKVJMJqMoSgRTcCyqnSpvdKVgSy0ZIUS02blzJ4MHD/aPdAA89thjxMXF+W+VbRRK3bVrF3/729846aSTcDja/qP3hBNO4P/+7/8YNmwYCxYswGazkZqayrx58xg2bBi/+c1vKCsrY+PGjQA888wz5OTk8PTTTzNy5EguvfRSHnjgAR599FF8Ph9Op5OXXnqJP//5z5x99tmMGzeOV155JSCYKigoYNGiRbz++uuceeaZDBkyhF/+8pecccYZLFq0KESvXsdkRCaSzGYjBScjA5SejynNio06bzUenxuzau3x63eHBDJCHH9izDE4F0Tmj7sYc0yPXu/666/n4osv5ptvvuHqq68OmF6qrKwkLi4On8+Hy+XijDPO4MUXX2z3fOPHj/f/W9M0UlJSGDdunP9YRkYGgH/R8LZt25g0aVLAaNDpp5+O0+nkwIEDlJeXU19fz6mnnup/PDk5mREjRvjvb9q0Ca/Xy/DhwwP64na7SUlJ6czL0S0SyESSzQa1NUYGk71nf4jASMGuajhMnc8ZVYGMokQ04UsIESaKooRteieShg0bxhdffIHH48FsNgOQmJhIYmIiBw4caNHe4XCwbt06VFUlKyur1XUxx2o6bxNFUQKONQUsPl/oaoc5nU40TeO7775D0wLXesbF9dwUoUwtRZLFAvWeiE0vWRQbHt2NKwozl6SWjBAiWlxxxRU4nU6eeeaZoNqrqsrQoUMZPHhwUEFMV4waNYqvv/46YCToyy+/xOFw0L9/f4YMGYLZbOabb77xP15eXs7OnTv990888US8Xi8lJSUMHTo04Hbsgudwimggs3DhQk4++WQcDgfp6elceuml7NixI6DNtGnTWuTl/8///E+EehwGJpNRHC8CmjaPjLbMJaklI4SIJpMmTeKuu+7irrvuYv78+XzxxRfk5+ezZs0aXnrpJX/NmJ508803s3//fn7xi1+wfft23nnnHe6//37mz5+PqqrExcVxww03cPfdd/P555+zefNmrr322oB+Dh8+nKuuuoq5c+eydOlS8vLy+Pbbb1m4cCEffPBBj30uEZ1aWrlyJbfccgsnn3wyDQ0N/OpXv2LGjBls3bqV2Nijw4vz5s3jwQcf9N+Pien5aZiwsdmM7QrcbmOooYcpKNR6q3r8ut3RvJaMpGALIaLBn//8Z0455RSeffZZ/v73v1NbW0tGRgZTpkzh66+/Jj4+vkf7069fPz788EPuvvtuTjjhBJKTk7nhhhv4v//7P3+bP/3pTzidTi666CIcDgd33XVXi0XJixYt4uGHH+auu+6isLCQ1NRUTjvtNC688MIe+1wU/dgE9ggqLS0lPT2dlStXMmXKFMAYkZkwYQJPPPFEUOdwu924m1VLq6qqIicnh8rKypB/ozz12Et8tnUd47IHd/0kPh+UH4FhwyElNXSdC1JpfQHploGcnHhBj1+7q2proawMfvITSE6OdG+EEF3lcrnIy8tj0KBB2OSvkj6pve+BqqoqEhISOnz/7lVrZJoiveRj3p0WL15MamoqY8eOZcGCBdS2k7KycOFCEhIS/LecnJyw9rnbVNXIWGoj9S7cLKodZ5RtHmm1Qn291JIRQgjRi7KWfD4fd9xxB6effjpjx471H7/yyisZMGAA2dnZbNy4kf/93/9lx44dLF26tNXzLFiwgPnz5/vvN43I9Gp2uzHEYDIZqdjWnvvLxKLYqPNV4/LVEKNFpjBfZ0ktGSGEEE16TSBzyy23sHnzZr744ouA4zfddJP/3+PGjSMrK4uzzz6bPXv2MGTIkBbnsVqtWCOw1qRb7HYjp7iwEI4cgaxsSE0BLfxfHotqo7KhFJfPGTWBTBMJZIQQQvSKqaVbb72V999/n+XLl9O/f/922zYV59m9e3dPdK3n2GyQkmKk4uTtgZ07jb2YwjzloylmvDREXQq21JIRQggBEQ5kdF3n1ltv5a233uLzzz9n0KBBHT5nw4YNAGRlZYW5dxGgKBAXB4lJRm2ZnTshLw9qwhxk6Dp1UZaCLbVkhDh+9KKcE9HDQvG1j+jU0i233MKSJUt45513cDgcFBUVAcYOona7nT179rBkyRLOP/98UlJS2LhxI3feeSdTpkwJKMd83NE0SEwEjwdKSow6M+kZkJEOZkvoL6eYo3LzyIoKYwCrCxvWCiF6gaZqsPX19WEr/CZ6t6bknWMrE3dGRAOZZ599FqDFdt+LFi3i2muvxWKx8Omnn/LEE09QU1NDTk4Oc+bMCchzP66ZzcZ0U10tFBRA2WHjmKaBqoGmGllPmtZ4TA1+z6Z4h39bhKatCqKJxWLs7CC1ZISIXiaTiZiYGEpLSzGbzT1eFE5Ejq7r1NbWUlJSQmJiYostDjojooFMR0NKOTk5rFy5sod604vZY4xMpro6491bB/CBD2MNja53rsxtgxcGDYR+jYGMYsflc1Lvc2FRoyMqsFqN2bfaWglkhIhWiqKQlZVFXl4e+fn5ke6OiIDExMRub2fQa7KWRAdUFWJDtJlaRYVRiKXR0cylmqgKZNxuI5CRonhCRC+LxcKwYcOob/Y7SfQNZrO5WyMxTSSQ6YtUzYgCGpkVq3/zyHhTz2293h2aZhRFlqJ4QkQ/VVWlsq/oMpmQ7Is01RiRaUztjtbNI0FqyQghRF8ngUxf1DSc4fX6D6lRuHmkqhr7bQohhOi7JJDpi5pq/Dc0+A+ZFCuVUZi5FKEtqoQQQvQSEsj0RaraIpBp2jzSq3vbeWLv0ryWjBBCiL5JApm+qGlqqXkgo9jw+Fy4fdFT999qNRb7Nlu3LIQQoo+RQKYvCxiRseH21VEXRXsuWSzGmmVZ8CuEEH2XBDJ9WbNARlPM6HijKnOpeS0ZIYQQfZMEMn2Vohh7OTWj60RVINM0QyaBjBBC9F0SyPRVmtZicYlJMVPdcCRCHeo6KYonhBB9lwQyfZWqBmxTAGBWbVQ3lEWoQ10jtWSEEKJvk0CmrzJp0OAB39F0a4tio65x88ho0ZSCLYQQom+SQKavUjVjF+xjasl4fK6oWidjsUgtGSGE6MskkOmrWtmmwKxY8OjuqErBtlrB5TJuQggh+h4JZPqqpuq+nqMjMoqiouvRtXlkUwq2LPgVQoi+SQKZvkpVjfmYhsAUbFWJrs0jpSieEEL0bRLI9HXewL2VzIqNqijaPFJqyQghRN8mgUxfd8yIjFm14fSWR9XmkSCBjBBC9FUSyPRlqgruwFoyFsUedZtHqio4o2dZjxBCiBCSQKYva6W6bzRuHmm1Qnl5pHshhBAiEiSQ6cs0rbG679EiLJpiwheFm0dWVkotGSGE6IskkOnLmlKwj1nwS5SlYFssUktGCCH6Kglk+jJNM4KYZtV9AUyKJao2j2yqJSMLfoUQou+RQKYva8pdPiaQsah2qhpK0aNkrsZikaJ4QgjRV0kg05c1TS0dE8iYFSsuXy31enTM1WiasT5GRmSEEKLvkUCmL1MU42MrIzIenwtXFGUugQQyQgjRF0kgI1odkfHobuqiaMGvqkJ1daR7IYQQoqdJINPXKQp4PMccUqIuc8lqhYqKSPdCCCFETzNFugMiwtSWRfHA2Am7ynOYMu1gu083q1biTSnh6l3QmgIZXT86YyaEEOL4J4FMX6epjUXxAtnUOPbWrSev7vt2n27T4jjBMZ1M6+Bw9TAoVuvRWjJ2e0S7IoQQogdJINPXaRp46sHnNUZnGiWZM0nQ0zp8+hHPQTZWL8esWEmx9AtnT9tlsRjVfWtrJZARQoi+RNbI9HWaBl5fy+q+gKpoHd5SLTm4fTV8X/0ZFZ6SCHwChqZaMpK5JIQQfYsEMn2d1notmc5INw+kquEwG6s/w9kQmd0bm2rJSFE8IYToWySQ6evU1rcp6AxFUci0DKasvpDvqz+P6M7ZMiIjhBB9iwQyfZ2qGkMZ3QhkwJiGyrQOodi9l03VK3D7en5oRNOgqqrHLyuEECKCJJARhm4GMgCaYiLTMpgDrq1srV5Ng+7p+EkhZLFILRkhhOhrJJARhhAEMgAm1UK6ZSB5dd+zzfklXr3lIuJwsVqNzKUo2etSCCFECEggI1qt7tsdFtVOqrk/u2vWsqvmW3y6L2Tnbo/VKrtgCyFEXxPRQGbhwoWcfPLJOBwO0tPTufTSS9mxY0dAG5fLxS233EJKSgpxcXHMmTOH4uLiCPX4OGVqvbpvd9i0OBLNmeyoWUNe7Qb0HhgmkUBGCCH6nogGMitXruSWW25hzZo1fPLJJ3g8HmbMmEFNTY2/zZ133sl7773H66+/zsqVKzl48CCzZ8+OYK+PQ6oG7pbVfbsrVksgVktiq/MLDrp3hfz8x5JaMkII0fdEtLLvRx99FHD/5ZdfJj09ne+++44pU6ZQWVnJSy+9xJIlS5g+fToAixYtYtSoUaxZs4bTTjstEt0+/mgaNHjA2wBaaL8l4k0peHwutjhXE6MlkGTOCOn5m2tKwJJARggh+o5etUamsrISgOTkZAC+++47PB4P55xzjr/NyJEjyc3N5euvv271HG63m6qqqoCb6ICqgc8HDeFZmJtszqbOW8Xm6pVhrzEjRfGEEKJv6TV7Lfl8Pu644w5OP/10xo4dC0BRUREWi4XExMSAthkZGRQVFbV6noULF/LAAw+Eu7vHF391X4+x0CTEFEUhwzKIg+6dbHN+yQnxZ6Mp4fnWM5mgvBzKysJy+hYUBRITjdEgIYQQPa/XBDK33HILmzdv5osvvujWeRYsWMD8+fP996uqqsjJyelu945vqmqMyLSy31LILqFopFsGke/aTKyWyPDYU1AUJeTXsdth0ybYujXkp26VqsKECXDaaUZQI4QQomf1ikDm1ltv5f3332fVqlX079/ffzwzM5P6+noqKioCRmWKi4vJzMxs9VxWqxVrGEYVjmshqu7bEYtqI0FLY2fNN8SZkuhnGx7ya2RlhTwBq101NfDNN5CQAKNH99x1hRBCGCIayOi6zi9+8QveeustVqxYwaBBgwIenzhxImazmc8++4w5c+YAsGPHDgoKCpg0aVIkunx884Q3kAGIMyVRr9c1Lv6NJ8ncekDaVYoCNltIT9kum80owbN6NTgcIIN/QgjRsyI6s3/LLbfwz3/+kyVLluBwOCgqKqKoqIi6xtWaCQkJ3HDDDcyfP5/ly5fz3Xffcd111zFp0iTJWAo1RTHWyPSAJFNW4+LfVRHdYDJUMjOhvh5WroQjRyLdGyGE6FsiGsg8++yzVFZWMm3aNLKysvy31157zd/m8ccf58ILL2TOnDlMmTKFzMxMli5dGsFeH6dU1Xg37gFNi39L6/PZ6vyix/dkCofcXCgqglWrJGtKCCF6UsSnljpis9n461//yl//+tce6FEfpoa+um+7l1M00i0DKXBtIVZLZETsqWFZ/NtTVBUGD4adOyEuDs46yyjPI4QQIrwkaVQYtMYRmR7aFwmMxb+JpnR21XxLoXtnj103XMxmGDAANmyA776TzSuFEKInSCAjDJoW9hTs1sRqiZhVK1udqyn3tF4bKJrExEB6OqxZY4zOCCGECC8JZIRB0xqL4oU/c+lYRuXfarY6v6Te5+rx64daUpJRV3D1ajh4MNK9EUKI45sEMl3g9XlZsW8F39V/w2FbIT56bjombCIYyACkWwZQ5N7Drppve2Sn7HDLzgan08hkatx5QwghRBj0ioJ40WTptqXc/tHtHKg6YBxIg436Cmb4LmEU4yPbue5oqu4boUBGU8ykmPuxp3Y9SeYssm3DItKPUBo4EHbvNjKZzjrL2D6hN7FapRqxECL69bJfrb3b0m1L+eG/f4hO4IhBNZW8qf6DOb650R3MQMQCGYAYLZ46bxXbnF/hMKXgMCVHrC+hoGkwaBBs3w4lJZHuTSBFgeRkI9MqKwtSUmS/KCFEdJJAJkhen5fbP7q9RRADgALosEx9lxG+sajRPGMXwUAGINncj4PunWyv+YoT42diUswR7U93WSxGsFBTE+metFRYaIwY2e3GAuUhQ4ygJj1dUseFENFDApkgrS5YfXQ6qTUKVFNBAXsZyNCe61goKYpRbz+iXVBItwzkgGsHiaZMhsWeFNH+hILFYtx6m6Qk42NtLRw+DAUFRgp5aqoR1GRnG0GNbF0mhOjNJJAJ0qHqQ0G1c1IV5p6EkaaBqwd3XGyDWbUSr6Wwq+ZbEs3ppFlyI92l41pMjHEDcLmgvNzIuDKZID7emILKyjICn4QESEyU4EYI0XtIIBOkLEdWUO3iiA9zT8JI06A+8oEMgMOUQm19NducXxKXkIxdi4t0l/oEm80IWrKyjPqITiccOgR79hgF/qxWiI0NDG5iY/vuouG++nkLcazUVGNENxIkkAnSmbln0j++P4VVha2vk9HBQSK5DO75zoWKpoK3AXxeY8uCCEsz53DQvYsdNWsY75iOqkTx2qMoZLEYAUtyszXXbrex3qd5cNPbsrGEED3LYoHp02HkyMhcX34FBUlTNZ4870l++O8foqAEBjON/5zhuzi6F/qqJmNEpqEBLJEPZFRFI82Sy766jSSZMxlgHxvpLvV5Vqtxax7c9HAx6Ig7DsocCRFSe/dG9vdAlwKZhoYGVqxYwZ49e7jyyitxOBwcPHiQ+Ph44uKO3ymA2aNm88blbwTWkWl0ie+K6E+91prVkrH0jkUQVjUGu+pge83XxJvSSDJnRLpL4hiS4SSEiKROBzL5+fmcd955FBQU4Ha7Offcc3E4HDzyyCO43W7+9re/haOfvcbsUbO5ZMQlrC5YzaJ/Lebftf/CZaoxJsuj/S81VW2s7tu7/sROMmdy0L2L7c4vmRA/A5PS/RQgRVHQMEX1jttCCCG6EMjcfvvtnHTSSXz//fekpKT4j1922WXMmzcvpJ3rrTRVY9rAaWyy7uGb0g3sSFjLFmU94/QfRLpr3aOqxrh5Q2RTsFuTYRnIIfcenOX/Dtk5NcWERbVjVWKwqDasaixm1YJJOXqL1RKJ1RIk4BFCiF6q04HM6tWr+eqrr7AcUxhj4MCBFBYWhqxj0aJf7TB2JKxlLzuopYYYYiPdpe6LcFG81miKmUzLYFy+0FSW09Hx6g04G45QpZfi1Rvw6g2g6GD8D0VRsKoxxGlJpFlyiTelEW9KlcBGCCF6kU4HMj6fD28rq3oOHDiAw+EISaeiiaMhiUy9H0VKIduU75moT450l7pHUYzMpV7IpFqIU3uuspyu+3D5aqnxVlBWU4iu69i02GMCmxTMasfricyKTbKuhBAiDDodyMyYMYMnnniC559/HjD+anU6ndx///2cf/75Ie9gNBijn0iRUshmZX30BzKqCu76SPeiV1AUFbsW569h0yKwQceqxqAFsY3CsJiTGBwzIcw9FkKIvqfTgcyjjz7KzJkzGT16NC6XiyuvvJJdu3aRmprKv/71r3D0sdcbo0/gM/0D9it5VFJBAomR7lLXqapRLES00Fpg4/bV4sPX7vOOeA5S543iis9CCNGLdTqQ6d+/P99//z2vvvoqGzduxOl0csMNN3DVVVdht9vD0cdeL55EchlEAXvZqqxnkn5WpLvUdZpmlHQ1VolEuje9mqKo2IKoOFzjrcDtq+2BHgkhRN/TpToyJpOJq6++OtR9iWpj9R9QoOxlc7QHMv4U7AYwRffO072Fppio8zkj3Q0hhDgudTqQ+cc//tHu43Pnzu1yZ6LZSH0cH+lLKVYOUkoRaWRGuktdo2nGDtgSyISMiol6Xx26rku2kxBChFiX6sg05/F4qK2txWKxEBMT02cDmRhiGcIIdrGNLcoGpunnRbpLXaNpRnXfvlZ3Pow0xUSD7qFB92AOQTE/IYQQR3U6H7S8vDzg5nQ62bFjB2eccUafXezbZExjQbwtyvrWN5aMBk1TS57emYIdjUyKGS8NNOiSDSaEEKEWksIWw4YN4w9/+EOL0Zq+Zrg+GrNuplwp4yD7I92drmma+uiltWSikaaY8Po8EsgIIUQYhKxCl8lk4uDBg6E6XVSyYGW4buzQvEVZH+HedFMvrO4brTTFhFdvwKNLWrsQQoRap9fIvPvuuwH3dV3n0KFDPP3005x++ukh61i0GqufyBbWs1XZwDn6RaihixV7jqIYC35FSKiY8OGlwScjMkIIEWqdDmQuvfTSgPuKopCWlsb06dN59NFHQ9WvXs1b72X1M5v4brmTwybwZfhQNSNgGcxw7HoMTqWaPN8utF0DcDohLg5yh1r87Zr4fFBQasfp0oizeclNq0M9JvYJVZugqZoUxQshI1NJl6klIYQIgy7ttdSXLb1nDbc/lssB7wTIrYIsnY3b0pgxfB+jJtjQMDFKH886ZQ1vFOzEs+Ei/3Md31f52wFs2x/LsvXpVNcdTXN22D3MOLGEUTk1IW3TKZraWBRPhIyOBDJCCBEGUTjvETlL71nDD/90Cge8gTViqvU43twxlm0bXADE7RoDgCfnv6DWt9pu2/5Y3vwqm+q6wFiyus7Em19ls21/bMjaNPH5YF+xnc35cewrttNWTOpTNfYdsrB5s499+bTZTnSCgqyREUKIMAhqRGb+/PlBn/Cxxx7rcmd6M2+9l9sfy21Mqj42/lMBH8t2DmTYmELWrZsKOW9DTBmMWgrOLKhLhtLRoCss2zEQ/Ns5HFsgzZiGWLY+/ZhjXW8zol8eOwqDG7XZtj+WZesGUu06Wu/E4YAZM2HUyDZfHtEhhXqfK9KdEEKI405Qgcz69cFl4BzPVUtXP7PJmE5qdDpfYD10BEozwNu0MNbO9qf7cUq9nd1bTqHg5P+QFrcZfe+JHI4BHIVQMo7q6rEdXq86iD612kbxgrXKuJlrqK4z88XWZFZtSWn5/MZRmzmTDzIqp8Y/utOiXTW8+QbM+aEEM12lYZL9loQQIgyCCmSWL18e7n70eof2BL4Jqfj43HMpHJvc0zST9N0gOPk/lObuhH/fBO74nuhmoMag5svSCjBXg7UaLFWgNaVWHx21GZad12yEp/WAdNkyGDGcri8i7sNMihmX7LckhBAh16VNI/uirCExAfdrsTPZ8iFYnNBwdNfvREsNFXEH0VUPGyrSqEss5cxTLsdVOJn/ZhqLfPHYYfd54DgIGRvBXHf0xB47FI+H6n7GfUdhx22a85qhPt4InHQNXEl4XUmBbUx1RpDTqBp4co+XOrd2tI2iQ2IeJOYfbVcFBfth4ICgXjLRjKqYcHtlREYIIUKtS4HM2rVr+fe//01BQQH1x2S3LF26NCQd623OvHkc/X95kEJvJjoq33EyZK6CrJ1QPgTw4VCcXDR7FR9anw947uqzP0b1fYzFB/WNr7h514V4hr5v3Gk+ANK4s4Htm7sBcJ36p3bbmA+d1rjQ95hRFB3wxGD2OvDUJBmBjTveCLqaBV5N6lorG1MyHnwmSN7jP+QMZs5LtKApZhr0erx6A5oifz8IIUSodPo36quvvsrcuXOZOXMmy5YtY8aMGezcuZPi4mIuu+yycPSxV9AsGk/OL+CHf8pEwYcesODXSOuZMXwftaZjpg90yHRCkQPqmz3FM+x9I9hofY0u3pP+evShNtooE1/g3MKBLP2qPy1OpuhgqWHSmAJWbUk9etxrhvrYFic9eVg5/93VbOSmJgOODIPDxgJlUnYDEOdo/fUR7dMUE/W6iwa9XgIZIYQIoU6vdvj973/P448/znvvvYfFYuHJJ59k+/btXH755eTm5oajj73G7D+exht3f0s/rSjguENxMmfEZkZNsBHHMWthFEhwwb7H4PV/w6AjgY+1SgGPqZZ6U227berMFcTkbGLO5IM47IFbCjjsDcyZfJAzRh/BYffgH8bRPGCvAHt54+0IjuQSzj5tJ47kErAfMY6nboeU7cZzykZB2TAcDh+5/bygSz52Z5kUM17dg0eq+wohREh1+k/DPXv2cMEFFwBgsVioqalBURTuvPNOpk+fzgMPPBDyTvYms/94Gpc87GX1Mxt4+bP17DbtYurZHlTNWP+Sy2AcegLVVPqDkB1p8K9xcO+XcFIhTLzFxhFLaFJxnVQxNqeGEf3y2qzsO+PEksZspGOHgHT/4yatlXYpu4yRncOjoGwk/bMqUDcvM1b7qppROM9uh9xc475ok4axcaTUkhFCiNDq9IhMUlIS1dXGQol+/fqxefNmACoqKqit7RuLGTWLxrQ7JjDxrDhSUwjYdkBFZYbvEuOOfvQ5D02FgngYWAmPrW6Z4txVTSNAqgoDM+oYO8DJwIzA7QlG5dS0O2rTVEem1XbJu7FkbQJg2+bTWPn1NHSfjq/ew74DGps3etm3w9Vq0TyfD/blw+bNtFlYL1RtejtNMeGlQar7CiFEiHV6RGbKlCl88sknjBs3jh/96EfcfvvtfP7553zyySecffbZ4ehj1BnFeOb45rJMfccYmQFqLfCrmTH88/VarvoqnydOiGNDirP1qSMdHCQABIzstGyTSC6Dg+tTB6M27bfbybfflPHpp9NY/fUUSmtiOUA+Tldjcb2NLYvmbdsOyz42atA0CVebaKAoKjo+CWSEECLEOj0i8/TTT/OTn/wEgF//+tfMnz+f4uJi5syZw0svvdSpc61atYqLLrqI7OxsFEXh7bffDnj82muvRVGUgNt5553X2S5HxCjG8wvfr7na+z9c6r2Sq73/w4AR97NryAhMXi9//0+8MWKjH/PExvszfJe0OrLT3Dm+Czu1u3Z7ozYdtTtt0nece65RT2j7xok4948L6Fd1tc6bbxiBx7btRgG96mMynJoK64WyTXRRZAdsIYQIsU6PyCQnJ/v/raoq9957b5cvXlNTwwknnMD111/P7NmzW21z3nnnsWjRIv99q9Xa5ev1NBWVgQw9ekCB92deyi+e+zMn7jnIH7dO5aExG/yjNmCMsszwXcwoxgO0GNkBjCwiReeIcrjNICccTj5lHau2JOM+eAKUDzM+odRtjSNGxrDRso87Pk/I2kRhgT5ZIyOEEKHV6UDmnHPO4eqrr2b27NnEx3evWu2sWbOYNWtWu22sViuZmZnttokmR1LS+GLSWUz74lPmLfuemiF3s8dyACdVxBFPLoMDRllGMZ4RvrEUsNffpkqp4F3lVVYrnzBCH0M6WT3S94JSO+64AkhXoWQclA+F2lRQA4vrdaTLbdQGSNsCFmNNT7QV6FNQ8PgkkBFCiFDqdCAzZswYFixYwM0338wFF1zA1Vdfzfnnn4/ZbO74yV2wYsUK0tPTSUpKYvr06Tz88MOkpLTcN6iJ2+3G7T76ZlFVVRWWfnXHqjOmc8Km70iqLGf66s/wjj0ZXGaw2SGNFhN+x47s6LrOdn0TO5UtvKu+ynW+29AIf9aQ09V4jcR9gG4UzHMnhv26Acw1kL7laJ+iqECfiib7LQkhRIh1OpB58sknefzxx/n0009ZsmQJc+fORdM0fvjDH3LVVVcxderUkHXuvPPOY/bs2QwaNIg9e/bwq1/9ilmzZvH111+jaa2/cS9cuLDXp4B7zBY+nHkpV/17EZO/XsH6g6UctjRW27Xb4cQTISenzecrKMzyzaFA3UuRUsjXynLO0M8Je7/jbEdHXkjMN2rO1MeF/boAuJKMCsruhMA+RVGBPpNilkBGCCFCrEslRlVVZcaMGcyYMYO//e1vvPfee/zud7/jpZdewuv1dnyCIDUtKgYYN24c48ePZ8iQIaxYsaLNDKkFCxYwf/58//2qqipy2gkKImW73cGO2ARG1FRyQUkBr/QbDooCdXXw1VcweXK7wYyDeGbql/KO8i9WKZ8wvAemmHLT6nDYPUe3RLA2bkTpp+NwACgtFugG9L0x+OhUG4vTCGRcCf4yN454yO19X9o2qYpJNo4UQogQ69YyyaKiIv72t7/xyCOPsHHjRk4++eRQ9atVgwcPJjU1ld27d7fZxmq1Eh8fH3DrdXw+2LCBD9Jy8SgKQ2urGOssD2yzfn2HBVPG6j9guD4Gn+LlXfVV9rKDzaxjH7vx0fK5PnzsY3e7bdqjqkbRPEPr6VYzprmZMbP988yYSefbWJzGRpe6CTzGBp4zZkTXQt+mbQp8UhlZCCFCptMjMlVVVbz55pssWbKEFStWMHjwYK666ipee+01hgwZEo4++h04cICysjKysnpmcWvYlB6GujrKLTZWJ2cxvewgF5bkU2iNodzSuEN2XZ3RLiO9zdM0TTHlqbsoUgpZor3gf8yhJzDDd4k/+2kbG43sJ6WyzTbBaCqat2x9OtV1R9dFOewNzBi2h1Hp8ZCVzZwftlL/Jd4IPprqv3SujQ6WKnAnYVMTuOCHtVFVRwaM6r4NuocGvR6LYot0d4QQ4rjQ6UAmIyODpKQkfvzjH7Nw4UJOOumkLl/c6XQGjK7k5eWxYcMGkpOTSU5O5oEHHmDOnDlkZmayZ88e7rnnHoYOHcrMmR38Od/buer8/1ydlMUIZwX93LX8tHAXL+SOok4ztWjXlgPsw0PL2iTVVPKm+g/m+OYC8Kb6j3bbdDaYabW4Xk0NlDVARgajRmqMGG5kFTmrjbUsuTmBIyijRtKpNl+8UcW+75P4wegERo08FHR/ewuTYqbeV2cEMkggI4QQodDpQObdd9/l7LPPRg3BmP7atWs566yz/Peb1rZcc801PPvss2zcuJFXXnmFiooKsrOzmTFjBg899FBU1ZJplc3u/2eDqrK43zBuKthGmsfFFQd380q/4XhVNaBda3z4WKa+0/qDjTtkv6e+FnislTbL1HcZ4RvbpeJ6Aex2qKoCpxPiE4w2HaRGd6ZN2YmV7PseigsS2n9CL6UpZhp0j5GCLVtTCSFESHQ6kDn33HNDdvFp06ah621XdPv44yCqokWjtFTjTb/OCASqTRb+2W8YN+7fzqC6ai4rzuONQWOMdu0oYG/AVFELCtTTQd0SBaqpoIC9gcX7usJkAl2HykqID32wkZFrfK5F+b1w3VMQNMWEV5f9loQQIpSiaKnkcURVjRTrZoqtMfwrawheFE6oPsLZuDtcyeokdDVyQnYumw2OHIEGT2jO10xGTjWKolNTaaO6IvpG5VRFw4cXjwQyQggRMhLIREpOjpFibT86fbQ3NoF3+w8DYNrGb/nBhm/bPUXTztehELJzNY00haEQodnqJSXLSF8uzo/O6SV0aJBtCoQQImS6VEdGhEhODvTrZ2QnuerAZmddWipJK5cx7YtPufiDN6iMT2TPwKEBbUhLBVUll8E49IQOdsgO7S7aHVJVox5ORQUkt12BuasyBlRy+KCDovx4hp5Q0vETehsFPLJxpBBChIwEMpGmqi1SrD+bNpOkijJO2Lyen/z7ZV4cNI7i5oNnjdV/1ZwcZvguMTKSGovE+TXbRRvooM3FnVro26GYGCOQaQq8QihzQCVbvu4fvSMyIGtkhBAihLoUyHz22Wd89tlnlJSU4DumaNvf//73kHSsT1MU3rrox8SXljCouJCr927i+dxRVJssxuPNqv+Oyhnf6g7ZDgJrxLTWRkXlMt/VnUq9DorVCjVOo0BMiAOZjFxjyqooSgMZFY162aZACCFCptOBzAMPPMCDDz7ISSedRFZWForS2nyF6C6vqrIkNZebystIq3dxdeEuXsoZSb3aLG93/Xro149RhUmM2DCegrgSnHYPcXVmcp3pqBOSoLGE/6j9R9uUOVz859R8fIqP3EIr9Atx5xUFTGYoK4PUVFBCN9qTOcAIxMpLYnHVmrDFNITs3D3BpJipk20KhBAiZDodyPztb3/j5Zdf5qc//Wk4+iOalB7G5WngH/2G87OCrWS7a7n2wA62xSVxyBpDkTUGZx2wdRts2YwKDKxtvmDXdXTPJoCvvvK3GVgSz3fDSyhJqmNfwWeM8cW0u69Tl8TEGPVkamshNnQbS8Y4PMQn11F1xE5xQTwDRh4J2bl7gqaYZONIIYQIoU4HMvX19UxuenMU4dNY1bfCbOWf2cO4/sAOclw15Lhq/E2cmolDB3dRZLZRZI3hkDWGMostcAeldeuMj8fU6xlYHG8EMpnVjGkc2QnpxkVms5GCXVUZ0kAGjFEZI5BJiLpARsVEva8OXddlNFMIIUKg04HMjTfeyJIlS7jvvvvC0R/RpNnakkJ7HH/LHc3Imgqy3LVkumtJqXcR521gmLOCYZ08tVtRqUrN5NuRsC+jCr7teF+nLrHa4HAZZGSCGrpSthkDKtm5PjMqC+OZGqv7NugezIol0t0RQoio1+lAxuVy8fzzz/Ppp58yfvx4zGZzwOOPPfZYyDrXpx1T/bfUaqfUejS4Mfu8ZPgayHRWkumuJdNdR6a7FmsQOytbdR+X7Hbz1LlQ7nBTEeMmMYh9nTrNbjeq/FZXQ0JiyE7btE4mGjOXNMXk32/JjAQyQgjRXZ0OZDZu3MiECRMA2Lx5c8BjMlQeQk3Vf7/6qtWHParGgXEncGDL0a+BouvYfe0vfh1VXcGlJfsYUu0m+0gshak17MusYkKIs4sA0BpHYSorQxrIZAwwMpdKCx00eFRM5o6Dt96iaZsCj+7GTmin3IQQoi/qdCCzfPnycPRDtKap+u/69f6RGcBfR4Z+/WDvHv9juqJQqwWOkPkrBze2OWCPBSC9vo6BRWlGIJNdy4QO9nXqMnvjlgXZ2UYmUwgkpNRhi63HVWOhtNBB1sB29pvqZWS/JSGECK1uFcQ7cOAAAP379w9JZ0QrWqn+21TZF2h31Mb/OPjbHLbY8KJg93kZUxjDl2NhX3YNuqK0Wvi326w2ozheXR04QhPIKIoxvbRvaxpF+fFRFciomPDhpUGq+wohREh0Ok3F5/Px4IMPkpCQwIABAxgwYACJiYk89NBDLYrjiRBpqv47YIDxsXl2USt7NgHG/cmTjcebtfEqKmUWY8PFk0ptaLqG01RDGaXh67uugye0m0hmNk4vRds6GUVR0NFlREYIIUKk0yMyv/71r3nppZf4wx/+wOmnnw7AF198wW9/+1tcLhe/+93vQt5J0YGORm2OaVP8cTnp+bvpP2AQOdSzj93sU3aRqoc4a6m5EAcyGY0LfqOxwq+ig0c2jhRCiJDodCDzyiuv8OKLL3LxxRf7j40fP55+/fpx8803SyATKa3s2dRWm5KBQyB/NxmHixmoD2Wfspt9ym5O0k8PT98UBdyhfePOzDUCmZL98ei+kBYPDj9F9lsSQohQ6fSv/yNHjjBy5MgWx0eOHMmRI9FVnKyvKk7PBCC9pIiB+lAA9rEbH2GaGjSZjQq/IZSSVYPJ7KXeZeJIcWxIzx1+CvU+V6Q7IYQQx4VOBzInnHACTz/9dIvjTz/9NCeccEJIOiXCqzitMZApLaaf3g+LbsWl1FHMwfBc0KxBvRt83pCdUtV00nOicwNJk2LG5avpuKEQQogOdXpq6Y9//CMXXHABn376KZMmTQLg66+/Zv/+/Xz44Ych76AIvfKkFDwmE5YGD8nlleSmDmY329in7CZLD0MGmmoyppY8HrCGrsJv5oBKDu5Nojg/njGnhSkICwMNkwQyQggRIp0ekZk6dSo7d+7ksssuo6KigoqKCmbPns2OHTs488wzw9FHEWK6qlKSmgFARmkRg3Rjk4N9yq7wXNBsMvZdqg/tupCmwnhFBdE1IqMqJuq9snGkEEKEQqdHZAoKCsjJyWl1UW9BQQG5ubkh6ZgIr5L0TPoVFZJRUsTAEaMBKCAPLw1o3Ssv1FLYUrCPblWg68aa4migKWYa9Hq8egOaEuLXWggh+phOj8gMGjSI0tKWNUfKysoYNGhQSDolwq/Ev06miHQyidFj8Sj1FLI/fBcNcSCT3r8aRdGpqbLirLCG9NzhZFLMNOCRzCUhhAiBTgcyuq63uqeS0+nEZrOFpFMi/JoW/GaUFKGgMkAfAoRxeikMKdhmq5eUbCcQXQt+/fst+aSWjBBCdFfQ49rz588HjMqk9913HzExMf7HvF4v33zzjX8zSdH7lTSmYKeWlaB5GxhoGsY2NrJP2c0UfUboLxiGFGwwppcOFzooyk9g2ISSkJ8/HDRMeH0ePDIiI4QQ3RZ0ILN+/XrAGJHZtGkTFovF/5jFYuGEE07gl7/8Zeh7KMKiMj4Rl8WKrd5NStlhBqUb9WQOkI+HesxYOjhDJzVPwVZDm7m0+av+UbVVgaaY8CIbRwohRCgEHcg07Xp93XXX8eSTTxIfHx+2TokeoCiUpGeSeyCf9NIiitNPwKEnUK1UUkAeQxgR2uuFKQXbv1VBQfR8PyqKKvstCSFEiHR6jcyiRYskiDlOBK6TUfxp2PnK7tBfLEwp2Jm5Rgp2RUksrtroygCSNTJCCNF9Qf3mnz17Ni+//DLx8fHMnj273bZLly4NScdE+DWtk0kvLQJgIEPZyFr2KbtBD/HFwpSCbY/zEJ9SS1VZDMUFCQwYWRbS84eTjMgIIUT3BRXIJCQk+DOVEhKiZy2CaJ9/RKYpkGncd+kQB3BRhw176C8a4kAGIHNAFVVlMRTti4+aQEZBkREZIYQIgaACmUWLFrX6bxHdmkZkko6UYfbUE29OJFlP44hSSj57GMHY0F4wDCnYYCz43bkuM7pSsDHh9kl1XyGE6K5Or5HJy8tj166WtUZ27drFvn37QtEn0UNqYh04Y2JR0Uk7bKQuD2ocldmorGUz69rcFduHj33sbrdNC2FMwQYojqKtCjTFRJ3PGeluCCFE1Ov06shrr72W66+/nmHDhgUc/+abb3jxxRdZsWJFqPomekBJeiZx+/aQXnKIg1n9MelG2vUOdTM72AyAQ09ghu8SRjEegG1sZJn6DtVKpf88x7ZpVZhSsDMaF/wePhhHQ72KyRJEUBVhqmKiXkZkhBCi2zo9IrN+/XpOP/30FsdPO+00NmzYEIo+iR5UnJYFGOtktrGRb9SVLdpUU8mb6j/Yxka2sZE31X9QTWWbbdqkmsDjDfk6mfiUOuyx9fi8KqWFjpCeO1w0xUS97sKn9/6gSwgherNOBzKKolBdXd3ieGVlJV6vNySdEj3Hn7lUUsQy9Z3WGzXuSPGx+jYfq28HHDu2zTL13banmcKUgq0ozerJRMk6GZNixqtLUTwhhOiuTgcyU6ZMYeHChQFBi9frZeHChZxxxhkh7ZwIv6bMpeTSQmOqqK0dpBVwKlU4lap221QrFRSwt/XHw5SCDUfXyRTlR0eNIw0TXl02jhRCiO7q9BqZRx55hClTpjBixAjOPPNMAFavXk1VVRWff/55yDsowqskLQOA1Con8S6oCsG+n06q2m8QphRsIGq2KtAaR2Q8PjeEbrmQEEL0OZ0ekRk9ejQbN27k8ssvp6SkhOrqaubOncv27dsZOzbE6boi7Nw2OxXxiQCMCdGei3G0MyoSxhRsgEP58WzaCPvywdfKDJfPZzy2eXP427SnaQdsGZERQoju6VJN9+zsbH7/+9+Hui8iQkrSM0msquCkEjtf59S1PnWkgwNjtKOatqegNN1EMmmAkaJdwF6cVBFHPLkMRg1TCnZJpRMUL16PiXfeiAVLDQ4HzJgJo0YabbZth2UfQ/MlXuFq0xFV0fDhlR2whRCim7oUyFRUVPDtt99SUlKC75g/RefOnRuSjomeU5yWyfDd2zmveABPsd3YnqB5oNK4XcEM3yUAvKn+o802XqWBv6tPMtE3iXXqmpYp2rbzGFU/JqQp2Nu2w9KlgLUKXEngSgBLDdXV8OYbMOeHRrs332j53HC0CTaYUYAGXar7CiFEd3Q6kHnvvfe46qqrcDqdxMfH+7cuACOjSQKZ6FPSuOB3ZKmHOb65Ro2YZunVDhKZ4bvYXyOmrTan+aawXl3DYaWElerHLa5TTSVv2l5jTs2PGOUZGZJdsH0+Y3QEAGulEchUDoD6OH+b95qKUbcTM3S5jVYPifmgGJHcsmUwYrixrrkjOuDxyYiMEEJ0R6cDmbvuuovrr7+e3//+98TExHTr4qtWreJPf/oT3333HYcOHeKtt97i0ksv9T+u6zr3338/L7zwAhUVFZx++uk8++yzLYrxie4pbpaCPYrxjPCNbTkl1Gw5VXttTvCdzBPqgzQorSzoVQAdltk/YoT7IlRr91cWF+xvNsVjq4BKoC7VuDUKJlToVhvdBMnGjuHVVUafBg4I4oTIxpFCCNFdnQ5kCgsLue2227odxADU1NRwwgkncP3117e6q/Yf//hH/vKXv/DKK68waNAg7rvvPmbOnMnWrVux2UKQXiMAOJyajg+FuNoaYmuqqYl1MJCh7T5HRW21TRGFrQcxTRSo1qopqNvCwPiWhRU7y9m8pJGjEDx28Fq6fd6geC3g7Adlw8BxAMyuln1qh4om1X2FEKKbOh3IzJw5k7Vr1zJ48OBuX3zWrFnMmjWr1cd0XeeJJ57g//7v/7jkEmNtxj/+8Q8yMjJ4++23+clPftLt6wuDx2yhPDmFlCOHSS8pIm9Q16vjdph63dTOc7jL12gurnlXVR+k7gzJeYOiA/vt4EqGw6Mga33LPrXDpJhlvyUhhOimTgcyF1xwAXfffTdbt25l3LhxmM3mgMcvvvjikHQsLy+PoqIizjnnHP+xhIQETj31VL7++us2Axm32427WXpvVVVwb6x9XXFaJilHDpNRWkTeoK5P3bWbet28XUNsl6/RXG6OkTHUSrFpP0djYBHyNgqQvhkKzoTq/pC4D0dGObk5wfVdU2QHbCGE6K5OBzLz5s0D4MEHH2zxmKIoIdumoKioCICMjIyA4xkZGf7HWrNw4UIeeOCBkPShLylJy2T0js2kl7T92gYjl8E49IS2U7R1iPPFkevJ7tZ1mqiqkfbcWiZRkxkzjY9haWOrhPgCqBoAJeM496pVQS30BVAx4fbVoet6wKJ5IYQQwet0QTyfz9fmrTfstbRgwQIqKyv9t/3790e6S1GhacFvRmn3AhkV1Z+m3ZSS7deYsp2uZ6K4G3fBDoFRI420Z8cxUzqO+KPp0GFtk7odNA+4E3AV5wbdb2O/JQ8NeugrHQshRF/RpToyPSEz03hjLS4uJisry3+8uLiYCRMmtPk8q9WK1WoNd/eOO00p2OklRcZ+SN0YIRjF+FZTtG3E4NJr2WvazRfaCs70jA5JCjYYAcaI4UbGkLPaWKeSmxOYBh2+NvUUbdvBp0vGsvz1UYw65RD22I6DE00xUe+ro0Gvx0wPLVAWQojjTKcDmdamlJr7zW9+0+XONDdo0CAyMzP57LPP/IFLVVUV33zzDT//+c9Dcg1xVFlKKg2qhq3eTUJVBZUJSd06X1sp2t8pX/Gx8jYr7cuJrRzMhPQLKajbitN7hDgtmVz7aNQubj6kqh2nPYerTU6/fXy/MpfSwnhWLR3OzJ9u6bC/TdsUeHQ3duI6bC+EEKKlTgcyb731VsB9j8dDXl4eJpOJIUOGdCqQcTqd7N69238/Ly+PDRs2kJycTG5uLnfccQcPP/www4YN86dfZ2dnB9SaEaHh1UyUpaSRUVpEeklRtwMZaD1F+2T9DJy+ar5UP+ND59/5vPbfuHxHV9g6tBRmpM5jVOzkbl+/J2kmnRlXb2HxI5NY+9lATpxWQHpO+3nYst+SEEJ0X6cDmfXr17c4VlVVxbXXXstll13WqXOtXbuWs846y39//vz5AFxzzTW8/PLL3HPPPdTU1HDTTTdRUVHBGWecwUcffSQ1ZMKkOD2TjNIiMkqL2DVsVNiuM00/j0L3bvZZ8wOCGIBqbxlvFv+BORn3Rl0wM2jMYUaefJDt/83m43+O5ep7v253hk7FhA8vDVLdVwghuqzTi31bEx8fzwMPPMB9993XqedNmzYNXddb3F5++WXAyIJ68MEHKSoqwuVy8emnnzJ8+PBQdFm0ommdTEY3M5c6oqNz2FTWbptlh1/ER+QXj3fWOT/ZisnsJX9bKtv+m9VuW0VR0NFlREYIIbohZIt9m7KERPTyb1XQzcyljhSwF6fWfiG4au9hCuq2MtA+Lqx9CbXEtDomXbCb1W+P4NMlY7AkleBye1tdNAzGFk2uBjebNsGRI5CcDKNHg3bMMiGvF7Zu7Zk2QggRTTodyPzlL38JuK/rOocOHeL//b//12aVXhEdihtHZNJKi1F8PvRgC6J0UtDVf71HwnL9cJt8wR6++zyHqiMxvPrXIf5qww6HUYum+e7Yefnw5pv1VG4/eiwlBebNg8mNM2tffQUvvABlZeFvI4QQ0abTgczjjz8ecF9VVdLS0rjmmmtYsGBByDomel5FUjL1JjOWBg/J5WWUpaSF5TpBV//VksNy/XDbneelNnYrVJ0E5UMhYT+Y66iuNorpNdWk2bYdln+ugNMV8PyyMvjDH+Dee437f/hDy2uEo40EM0KIaBRUILNx40bGjh2Lqqrk5eWFu08iQnRFpSQtg/6HDpBRUhS2QMao/htPNVWtV/8FHFoqufbRYbl+OPl8sOxjIO4Q2EuhLg1Kx0D2Wn+bZctg2LDGdqoZLDWtnuuFFzq+XqjavPginHqqTDMJIaJPUHMHJ554IocPG5v8DR48mLKy9hdqiuhV0gPrZIzqv5e222ZG6o1dricTSQX7G/diUoD0LYAPnFmwbyrsmwL7plC9cQpP/3IK1ZumwOYroPCUVs9VVhY4DRTONocPG2tnhBAi2gQVyCQmJvpHYvbt24fP5wtrp0TkNK2TCfeC31GMZ07lbBwktnhMxUSmpfu7q0eCs3k2ubUaEhtHMOvjoT7Bf3OWNf67LhXcCRHp67GOROeSJCFEHxfU1NKcOXOYOnUqWVlZKIrCSSedhNbGGPTevXtD2kHRs0rSjZThcKdgA4zyjGSENpWCdCdO7xFi1SS+rPw3++o28vHh5/lx5n1Rt5li3DH7NJG2DeKKQA/8m+EHE2Hdd4C1ceFz3jmgR3YEKrlxSZJkNgkhoklQgczzzz/P7Nmz2b17N7fddhvz5s3DcezOeuK40DQik1JWirZ3L97YOEhLbZk3HAomE6rLHZBiHW9K5rkDt7G7bi07atcwMnZS6K8bRrk5RnZSddPIjKJDTOBQhyMeZlwGuwqhur4KzLVgcoMnJqBdSorxsb1poVC1AVi+HEpL4f/9P8lsEkJEj6Czls477zwAvvvuO26//XYJZI5T1RWV1Gkm7N4GUr9YSbE1Bux2OPFEyMkJ7cVMJnC7jF2wVeNP/hRLfyYlzubLin+z7PALDLZPwKLaQ3vdMFJVI8X6zTfabjNjBpi0xnZvm8DaAFrLQGbePONja9lGoW4D8Omnxu1YktkkhOjNOv1n9qJFiySIOV7t3w9ff02J2dgCIt1dZxyvqzOKkOzff7StzwfFJZCfb3zsyropzQQNXvA0BBw+I/FHJJjSqfIeZnX5a139bCJm1EgjxfrYHxNH/NHU66Z2l15qIsbhAe1odd/U1KNBw+TJxr+bRlXC1eZ3v+t40O3FF41pJyGE6E1CVtlXRDmfDxr30Sq22hngcjKwrpptcUk0NL3DrV8P/fpBYaHx77q6o8/vyqiNSYPaBvDUg9XqP2xWrZyX8jNeK36IbyrfYZzjLNItHWxH3cuMGgkjhhtZTM5q2qzsO2aEicQBDaSdXY+vvPU1KZMnG6nR7a1b6W6bTZs6jkWbMpvGNc4E9mS14WDX7fS2Pkm/e1+b3tinaO/31q1Gm5EjI7OeTgIZYSg97A9Miq3GVM4plaVMrDzMQVsM+21x7LfHUfDdWqr2tlJLqGnUZvLk4IMZTTPePetb7jU0LPZkRsScxo7aNfzn8LNMSbySGl85cVoyufbRraZm+/BSULcVp/dIm+2CaRMqqgoDO4i/FEVFUXWGDHeT3c5eqJp2NIAIR5tgM5aa1s70ZLXhYCsS97Y+Sb97X5ve2Kfjpd+LF8NvfgNPPgmzZ9OjFF3X9Z69ZM+qqqoiISGByspK4uODqygbrKcee4nPtq5jXHZ0pgoHyM+HNWsAsHsbuKAkn8G11Ti8nhZNK0wW9ttiKbDHsS0uiUrz0dEU7Ha48MLgFweXlcGgwZCR0eKhyoZSnin4H7wE9sGhpTAjdV7A7tjbar5i2eEXqPaWtdkumDbQs8EOQKF7JxPjZ0W0AOCmTfDrX3fcLinJCIRWrWq7TXuVhMPRZvJk45dqT10vVG2k3z3bRvod/jZNSaZvvBGaYCbY928JZLrhuApkiktgxfLAY7pOYkM9uXVOcuqc5LicZLprA97SXarKm5mD2R6XdPTgtLMgIz246x45AllZkNty6GJbzVe8Wdz2T9ScjHsZFTs5qHZA0OcKJtgJpUL3Tk5wnM3gmAlhOX8wvF648cb2M5sUBYL5bZGYaHysqAh/m6QkY33Pr37Vc9cDKC/vXpvkZHj8cbjjju6fqyfbSL+l3x21URTo3x/y8ro/zSSBTCMJZILk88H77weuezmWxYLFVUc/Vw25dU5GOcvp564F4LOUbFYmZ6MrCpx2GgwIck1LVRXExcGIkQGHfXh5Kv/GgIDiWA4tlVtyn+OvBTe1305NAYUOz3Vu6g0sLX6kzTZNwU6oHXTvYlTs6YyIOzXk5+6Mjv7qu+suY+DujXYysoQQAoxyDtOmde8cwb5/h2d7YxF9VNVYrNueYcOpVzXyYuJZmZLN87mjWJNojLycXXaQHx/ag8XnBVsn0qWbp2A3U1C3td3AA6Dae5jn9t/acTtfWVDner/kL+22WXb4RXwY/fThZV/dJjY7V7KvbpP/eHPBtAHQMOHytb7fUk/qKLNp6tTg49OeJMX6hOh9Dh3quWvJYl9xVE6O8W7WVkZSv36wd4//MZ+i8kH6AA5ZY7ioJJ8xznJSD7hZbDqXcjBGeUoPg6vOCG5aK6ynmaDebaRgW4++Izm9wa0+LW8I3U9Lvd7OaBRGsFNQt5U6X3XI1uMAaErvCGSg4+ynpuq/vcm118JLL0W6F5133XWwaFGke9F50u+eFa39zsrquWtJICMC5eQYAUtbAciJJxpzEM2sS0ij1GLnJwd3k+Gq5X/+/hf+PWUme4qPdJyi3UYKdpwW3DvmuNiz2FSzvOOGIbKh6hM216xocbzaW8abxX9odz1O8zbNgxlVMVHvqw1bnzurveyn0aONEZueqDYcTJvUVDj/fHj77d7Tp2D7feGF8O67vadP0m/pdyjaNK2ROfPMts8RajK1JFpSVWOx7oABxsfmoyhNozb2wOmj/clp/G3OXPb3yyXGVcfcZW8zuTAvcHVoa4X12kjBzrWPxqEdM8dxDIeWygXpt3bcTk3psI1dDW79VGtBTHPLSl9g2eEX2m/TbIoKjBGZet2FT+/9m7Fq2tFKwW2ZN6/n2tx4I5jNvatP0m/pd1/td1PW0hNP9OyUryz27YbjarFvZ7UxbWSqd3Ph839hYnkxABscKbyTMfBoUT1omaLdRgp2T2YtzU6/h0/KXmp3LY2KCR8NbT7eGVdn/c6/x1SNtwKPXs+05KuwqO0Uk+lFWqszkZpq/OJtrxZFuNr0xj5Jv3tfm97Yp+Op3zk5RhATqjoykrXUSAKZHlZcAss/59SKEmaVFqAB+bY4/p4zEl/znaybp2h3kILdcq1JKjNSbwyijkxgu47adBQQnRJ/Md9WvdvZV6RVl6bfxdi4qQC4vE5qfJVMTb6SGC2036Ph1NuqjPbGPkm/e1+b3tinaO/31q1w9tkwd25oR2IkkGkkgUwPa1ZYb1BtFVcV7sKq+3ghZyQFdsfRds1TtNtIwW4SbIG6UFT2bS/YsasO/nkoiKpxQWg+IuPxuSlvKOLMpB+TYE4LyfmFEKKn7NwJ550HY8aE9rzBvn/LYl8RWs1Sr/Ni4tkZl8i46iMMqakKDGSap2i3sgt2cyqa/02/PcG066jNqNjJjIg9tdVgx4cXh5YSkpo1zav4aooJr95Ag95yqwYhhBDtk8W+3aDIy9dSWmrAQuDdMUYUPaS26mgbe+OamiZt7IIdKU3Bzti4qQy0j/OP2KhozEhtfyXcjLR5HbdJvTFgFEhVNHx6Ax7d3f3OCyFEHyPvxN3gUOLRVR86x/XsXOccU1hvT2Mg09/lxOptzNQ58cTATCiTBg0NUFcLbnf7t2MK5/W0UbGTmZNxb4ssKIeW6l983FYbDXOb1YEVRZERGSGE6AKZWuqGJDUZs9eKGxc2OlHN9njXrLBeJXDYbCXV42aQ1832M89puTu2phkjMnv3dnxui8UoZBAfDzExoPR8LN7e9FNrbQ64trGi/J9oisbwmFNaPacOeHwSyAghRGdJINMN8UoCsd4EanBKIHOsZoX19uAidecmBqcmsv3YIKZJcpIRzHSk3g35+8BkNhYINwU11p5NW+7MepwBtjF8W/ketb5KCl07yLW3viJORmSEEKLzZGqpG1RFJcWdjYv2S9v3WY2F9fac8AMAhubtarutpoHV0vHN4YCUVGM0xumEPbthyxZj64QjZdDg6aFPLniKojLQPh6AvXUbWm2jovWabQqEECKaSCDTTfENyahoNND73kB7i7yBQ/EpCmllJcRXVYTmpGYzJCRAcorx79JS2LXLCGqKi0JzjRAabJ8AQF4bgYxJMVPrraSq4TDHeUUEIYQIKQlkuimuIZE4HNTgjHRXei2XzU5htjGlNKS9UZmuUBSw2YyKTYmJxohMcRF4e0cGVJNBMRMAOOjehcvb8nslVkuk0LWDL8pf55vKdymo24KzoaJnOymEEFFIApluMulm0vUsaiWQadeeQcMAGLI3xIFMc6oKsXFQ54Ka3jVNk2BKI9ncDx0f+1ybWjweo8XT3zaSWDWRw/X7+a7yP3xR/hprK//DAdcO6loJfoQQQshi35BIIY3dbEPHJ7Vl2rBn8HCmffEZg/N2GRtJNt+uIJQ0DXQfVFdDfEJ4rtFFg+0ncMRTSF7dBkbGTmq1jV2Lw67Foes6tb4qDrp2st+1hVgtkXTLINIsOahKaGqAK6hoioaKhtr8Y8AxFUVRUVBQaPwYrq+dEEJ0gQQyIZBIMjHEUkstscRFuju90v5+A6g3m3HUVJNRcojijOzwXcxihfIKY/+mVioFR8og+wTWVn3I3toNHbZVFIVYLYFYLQFd9+H0VpBft7HNNTZd1RSgNAUs/sCl6d9NwQsKKEpAe1XRUBQVmxpLsjkbhykZh5aCTYsNaR+FEKI9EsiEQAyxJJFCCYckkGmD12Ri34AhDN+9nSF5u8IbyNht4KyFujpjqqmXGGAfh4JKecMhKjzFJJozOn4SRtaTw5SMw5Qc8j7puo6ODx0fPr3xIz503YcPb+Pjxn/oPnzozZ6jAzoVehH7XdtQUbFpDuJNKaSY+xNvSsVhSiZGjZdRHCFE2EggEyLpehYHlPxId6NX2z1ouBHI7N3JV6dNDd+FTGbwesBZ06sCGZsaSz/rcA64t7O3bgM/MM+MdJdQFAUFDdDQuhlrePUGXD4n5fVFFLn2+EdrYrVEks3ZIZwS67ijMVo8GdZBWNWYkFxTCNF7SSATIokkY8Wo8mulZ4uzRYu9jQt+BxbsRWtowGsK47efyQwV5ZCRDkG88fWUQfYJHHBvJ69uAz+Ij3wgE0qaYiJWSyRWSwRA1324fDXUeCs44jnYc1t56MYu5wmmdHLso8iyDg3LaJYQoneQQCZE4knEgVHlVwKZ1hWnZ1Id68BRU03OgX3sGzg0fBez2YzMJZcrcKftCBscM4HVFa+yr24jPt0bslGK3khRVOyaA7vm6LhxiPl0L1UNZWyuXsne2vVk24bTzzqcJHMWagS2tRBChI/8RIeIikqGnk0dtZHuSu+lKP5RmZDXkzmWxWJsZ9DL0rCzrcOxKHbqfNUU1+dFujvHLVXRSDSn0886Aqsaw57adXxVsZS1lR9w0LWbBl0KWApxvJARmRBKJhUVFS8NaPLStmr34GGcsHkdQ/bu5LOzZoXvQopibChZWWlsadBLaIqJgfZx7Kz9lr11G8iyhnFUSjRmfxnTXW5fLUXuvRx07yLZnEWWdViHI2ImxUyObbSM4gjRi8m7bQglkEQscdTgJJ7ESHenV9ozaDgA/Q4dwFZXi8sexsWYdjtUVRnVfk3m8F2nkwbZJ7Cz9lvyajdweuIPI92dPsOqxpBpHUyD7qHSU8xmz4p2Fw7ruo5FtRNvSiXJnNmDPRVCdEav/jPjt7/9rZFV0ew2cuTISHerTRaspEmV33ZVxydQkpqOqusM3rcnvBezWsHtNjaX7EWa9l3a79qKx+eObGf6IJNiJsXSn37WEWRbh7d562cbQb3uosQt2YhC9Ga9OpABGDNmDIcOHfLfvvjii0h3qV2ppONtrMshWtc0KjM4b2d4L6Q2fntXV4f3Op2UbO5HvJaKlwYKXFsi3R3Rjlg1gUL3Dgk4hejFen0gYzKZyMzM9N9SU3vPeofWJJKMHTt11EW6K73WnsHGgt+h4V7wC8aoTEUF+Lzhv1aQFEXxbyIZ6kq9IrQcpmSqGg5T5imMdFeEEG3o9YHMrl27yM7OZvDgwVx11VUUFBS0297tdlNVVRVw60kxxJJIMjX0rlGA3mTfgCF4FZWUI4dJrDgS3otZrUYKdi/LXmqaXtorgUyvpilmFBSK3GGeBhVCdFmvDmROPfVUXn75ZT766COeffZZ8vLyOPPMM6luZ6pg4cKFJCQk+G85OTk92GOj6miGno0bV49eN5q4rTYO9M8FeiAN22QCb0OvC2QG2k8AoKR+H86G8gj3RrTHoaVQVJ9Hjbcy0l0RQrSiVwcys2bN4kc/+hHjx49n5syZfPjhh1RUVPDvf/+7zecsWLCAyspK/23//v092GNDIimYsVKPzKu3ZU9TPZm9YV4nA2C2QHk59FRl2SDEaglkWgYDkFf3fYR7I9oTqyVS11DF4fqe/10ihOhYrw5kjpWYmMjw4cPZvXt3m22sVivx8fEBt55mVPmNp0ayl9q0Z3DTgt9dKHqYF0ZbbVDbuIlkLzKocXpJ1sn0boqiYFHtFLp24gv396oQotOiKpBxOp3s2bOHrKysSHelXRoamXo/auld0xm9yYHsXFwWK7F1tWQWHQzvxSxm8NT3ujTs5oGMrvee0SLRUrwplSOeg1Q2lES6K0KIY/TqQOaXv/wlK1euZN++fXz11VdcdtllaJrGFVdcEemudSiJFFQUvPSebJnexKdp7BswBOiBdTKKAprJqPLbi+TaRmNSLFR7j3DYI9MWvZlVjcGju6WmjBC9UK+u7HvgwAGuuOIKysrKSEtL44wzzmDNmjWkpaVFumt+rjqdkvyW+yt5FDsNcRYO6UeI8yWAphp1TZTGj5pCOHZlVgCzScdm9vrLqPRWuwcPZ+SurQzZu5MvJp8V3otZrUY9mXo3WKzhvVaQTKqFHNto8uo28F3Vf+hvG0mclkyufTQqx+9mktGqqabM4JgJmNXe8T0khOjlgcyrr74a6S60Kz47jn7D61t9zEIM6aYcDpryMHsaM2d8DeDzNd50AhafmkwQF5pdgl31KpU1Jny6gknzYTP7sFu9mDUdJfSxU5c1bSA5oCAPk8dDgzmM2whYrcaCX6cTknvPm1CslgTA2qoPWFv1AWBkycxInceo2MmR7Jo4hsOUTHH9Pso8hWRaB0e6O0KIRr06kOntJswZyoQ5bT++/XA87+98n+HJw1F8PmPPH48HPA3N/u2Beg/sywO9BBITu9UnHXC5VZxuE846E+U1JsqdZiprTNQ3GH/lW81GUNMRq9mHzRK+xY2lqelUOhJIqK4kd+0a9g4eAWmptBhK8vmg9DC46sBmb71NR1TVmGJyOiE5JXSfRDdsq/mKzc7lLY5Xe8t4s/gPzMm41x/M+PBSULcVp/dIm6M2PdmmL2peU0YCGSF6Dwlkwig9Np04Sxw1nhriLHGgaUYGTWtMGqzfAPEOULv+pqEAdqsPu7WetPh6BgENPoUal0aNS6Oq1kRZtQW3p+NA4IjTTFKcB3u4gpkDB9hjsvEDKhny3TfsLThobPR44onQVP9n/35Yvz4w4+jYNsGyWqGiHPr1M9bMRJAPL8sOv9Bum2WHX2RE7KnsqPmGZYdfoNpb5n/s2FGbbTVf9Vib5p9DXwt4mteUidUSIt0dIQSg6Md5ukRVVRUJCQlUVlb2eCq2ruu8te0timuK6R/fv/3GHg988w1UVkBaevj71tHjOmzOd7DrYCzZKW40NcTfJvv3w1dfMb6qjB8V7aXQGsPfBow5+vjkxjfNr75q+xyTJ3cumPF6jQW/o0ZBfGTfhPbVbeKfh37dYbspSVeyqnxJm4/PybgXgDeL/9AjbboS8BxPdF3noHsnP0g4jwH2sZHujhC9ws6dcN55MGZMx207I9j3bxmRCSNFURicPJi8ijz2lO8h3hJPgi0Bi2Zp2dhshqFD4NtvjR2breFdx9HRUhlFgRH9a6iuM1FSYSErOYTF/Xw+Y5QF2BtjfHNmuWs55/CBowHWh28ZHxs8/qc1KCpb45IotdqNA+vXG6MrwU4zaRroPmN6KcKBjNMb3NYMX5a/3u7jy0pf6PCLGbI2zUaIWgt4wjkl1ls0rymTYxuNqvTyFfVC9AESyITZ6LTR2E12DlYfJL8in/1V+2nwNRBrjiXBmkCsJfboL8OMDOjXHw7sh6zsyHYcsJp8jM518u3ORMobp5lCovSwf6rIaTJzyGony13H1COHOnzqOWWF7IhN4KukTPbqunGujMYRrGDW0liscKQcsrKMDLIIidOSg2rnpf3XvNpX1u7jIW3jPcye2vU9PiUGwQc7PREUNa8pk2TODOm5hRCdJ1NLPajeW09pTSklNSXkledRWluKs96JqqjEWeKMgKaqCtavA4sF7DEBz1cVlWTNgdrDqUcFpTbW700gMdaD3RqC9TL5+bBmjf9ulquGCVVlKB1MeCV56hleU+EvflRksfPlyaezaco5eA8dCm4tjcdjVPkdNQpi47r/uXSRDy9P5d8Y8AZ+LLNiwaO3nhXX24VqSmxU7OSgg52enO4qdO9kdOwZjIg7NaTnFSIaRXpqSQKZCNF1nUp3JSU1JRysOkhhdeHR8uc7d8KunY2jBkeDFqfPhVUxk2bq2WkRnw5bCuLYdTCOzGQ3pu6ulykugRUts3WCkVzv4rSKYn5QeRhr4+tVbY/hm5gkvk1Mp661RbzHrqUpOwyDhhgjYBG0reardt/IpyReyaqKtoOB3sykWGnQ256OdKgpoNBuIOfQUjk39QaWFj/SZpvmwU6w63tCocJTjEm1cGbSj6WmjOjzJJAJs94ayLTL6YQ33wSXC7KPTjGtcW5ndc1WRlo7WDgcBu4Ghe92J1JSaSEryd29ejQ+H7z/fvt7H9kb18G00cbmbeCk2gpOc5aRUF0FQL2isiE+heUp/XCamtWksdvhwguPTjNVVoLDAcOHR3R6CdoaRUhlRuqNjIg9tcNRm6ACghC1iVNTOC/tZ7xR/PsOPqvQMWGhgbZHpaxKLGckXc4X5a/h1lsWpmzi0FL5xYAXQjbN5NUbKK7P47TESyUVW/R5kQ5kZKVabxQXByed1FiJ9ugv8cHWTOJUG9Xent/80GrSGZ1TTYzVS7mzm4XrVNWY8mnPiSe228almfhi5sU89uN5vJ45mEJrDBbdxymVpVxVuBOleXxeV2esnWlit0NFBRw4AL7IbiExKnYyvxjwIldn/Y5L0+/i6qzf8YsBLzAqdjIqGjNS57X7/Blp83qszcy0eQyPPRmH1n4dHhOhK2zYXhAD4NZr+OzIonaDGDDW9xTUbQ1ZvzTFhKqoFLn3hOycQoiukUCmtxo+HAYPhsJC/6E0UwIDLemUeCOzZ1BibAOjc5y4G1Rq3d38yzYnx5jyaRp5aWK3H50KCqKNr76ejfEp/C13NC/1H4FL1ejvrmVC1eHA57iaBX8WC8TGQuEBY71OQ4gWMXeRisZA+zjGxk1loH1cwKjBqNjJzMm4t0Xw4NBS/dMlPdkmmOBqcuKPuvIydFmyKbiF8U2ZYj687KvbxGbnSvbVbcLXyn5owbRpXlNGCBE5krXUW5nNMHGiMWrgdEJcHIqiMMLWn+2uQjx6A2al5798/VJcVNSY2FkYh8XkwxREheA25eQY6dPtZRp11MbWGOQoCvti4lmenM2sw/s59/ABtsYl49a0wHZNrFbjHEVF0NAAAwb0mj2YjjUqdjIjYk9tNxunp9vMybi33Smx9dUfd3sqy67GU+er6vD1mRg/i0+OvNRhuxg1IaRFAWPUBCrcxRyu30+sXYrjCREpskamN9N1+Owz2LChcT2Hgkdv4I0jX1LlqyPbHFwKb6jVNyis25NAUYWNrCRXZPdvOma9jab7uHXfFlI9LlYnZbIsLaflGpnmvF5jD6bERBg4sEWmmGhbe6nOwSy+hfazlman38MnZS91uCD4ltzn+GvBTe22A4g3pVHVUNqtPh27aLi0voAkcxYTE2ahdFCIx6xYUXrTZmdChEik18hIINPblZXB0qXGppKpqQB8X5vHx1XrGGntH7FfjFV1Jr7ZkUB9g0qcrefWmVjMessqw41VgpsMc1Yw9+AuGlB4auBYjkyb3n4FYJ/PCGZiY41gxhGF3ye9UHsLmdsf/TjaJthspI7aWRQ79Xr7a8uCzaRqvmjY7avlsOdAENsVKMRq8aRbBpFoziDBlIZFbWO7EiGijAQyYRb1gQzA2rWwfDkMGwaaRqW3hn+Xf4EFE8mm0OyY3RWFR6xsLXDg9fVcMOXyaGQnu1o+cMyeTD89sJPhtZVszxnE4mtv6fjEPp+xANhqNYKZxKSQ9ruvCkVl32ACoo7aKbrKGyWhyba6Out3DLSP8993eZ14W1lDE0jH5XXi0mtR0YjVEki19CfF3J8EczpxWpJUCRZRK9KBjKyRiQZjxhjfKYcOQf/+JGixDLNm813t7ogGMv2S3aQ4POhh2lPyWBW1Zv67KxFPg4LZdEz8fcxamv+4xjPkjUWM3J/H0D072D1kRPsnV1VISoLqKtizB3JzIS2NjjdzEO1pWsjcnTbBrNvpqN1m58qQfD7QcnsJmxZcYcVYLREAr+6hxltFQd0W9tZ+j02LxaGlkGEdRIwWpX9shYhJMZNmyUWLwPo/Eb3kuyUa2O3Gwt8PPzSymJKTGWbNZmPtPup89djVVvZu6iE2cw9FMYDF7CbZUU9lrYnU+FYyjVTVv13BYWDNyWdw+jerOP/jd3j6Z3fh0zrItFIUYw+mmhrIyzOymTIyu7UbuQiNYAKi9toFuyVEMLp7Lk0xE29KId6Ugq7ruH01OBuOcLh+f4h6GL0URaG/bQTDY08j3tR+mr8QTSSQiRZDh8K0acbITEkJWXW19DcrHLSWMCCu5wvkRYKmQv8UF+sqEvDpHtQOBktWTDmXEzZ9R1pZCaes/Yo1p54Z3IViY42gqGA/uOuhf38wha42iuh5ufbROLSU7hcO1FLJtY8OWb8URcGmxQU9qnO88/jcHHBt54iniBGxp9LfNgpNkT8kRPtkUjZaaJpRIO6HP4Qf/hB1+tmMThmJq7oC74H9Rtl9dwh3qO6l0hPqibV5qXV1/MvNZbPz6VmzAJi+8mNiapzBX8huNwoTHjoEu3dDXfsF10TvFqriguekXNdrd+Y+HphVK1mWYei6j3VVH7Oh6hOqG4LbKV70XRLIRBtNg8xMmDiRAZffRNqpZ3F4VK6RaVNVZUw9HQzi5qyO9GfSJTFWL9nJdVTVBTeYuG7CKRzKyMbudnH2io86dzGLxVg3U1lp7H1VLr9Qo1l3igI2rZXKr9vUQ73tuxRFIcmcSZo5h4K6zXxT8Q7767Yd3YtOiGNI1lKU++bAN6zKX8XIlOFQWWWkEXsb2n+S2w07dxmbUrZWW6WXK62y8NW2JFLj61su+m3FgIK93PjKM/hQeHbeHRRl9uvcBXXdWATsA/r3MzablHUzUasrmVT1ei3/Lvo9oDMr9X+YGH9+ZDrfx+i6TnnDIdy+WnJtYxged2oQqe6ip0nWkuiWwUmDWXdoHVX1TuITE43Cbh3x1ENpqZFunByZonrdkRxXT0p7i36PkZ87mE2jJzBu6wbO//gd/j5zDrhdrVcSbk3TIuC6OsjfZ3zMyQFz5BZZi67raibV9OS5fH7kFT4+/AIp5v4MtI8PZzcFxuhMsjkbt6+WPNdGjngOMSLu1A73+wJjPyyzasWkWGWdzXFOApkolxabxuCkwWw7vI14a5AjTmaLUStl3Xoj8ImyURlNNbZKKNmbgK57gqos/PE5FzByxyYGFexlzPtL2eJoDODsdmPtUXsF85rY7UZhwqJiY1QrNxdiZZFmXzEpYTbF9fvY4lzJm8WPcG2/P1LdcKRbNXJEcKxqDP0swzjiOch/Kz/ArHS8nYiqaGiKCRNmzKoVqxqDTY3DqsZiUW2YFSuaYva30xQTKlrjhqAaGsZHNYxBUOvVoKOv5INPByL4fS2BzHFgeMpwtpZupd5bj0ULcpQgKxuS8qCqMiqLv6UnGot+a1wacfaOKwtXVjlZnZDB9CMHOa90PztiE2lQVWN05auvjm5U2RGzGVKSjdGsXbuM56SkEI2/fETnKIrCham3csRTyCH3bp7bf2vAZpJd3bMJQlM4sKfb9PT1FEUlxdIfr96AT+/4Z96Hlwbdg1dvoM7rxNlQgbfxvq4ETkkrKCioRuDS+FFRVFSM++HU0dYW0aDYozHOeTpjGByR60sgcxzoH9+fTEcmpTWl9IsPcv1HUwXbDd9DQgJEWVXRWKuXzCQXecUxHQcyPh+sX88XyZlMrColsaGe6WWFfJLaH71pOGf9eqOgXjCjU03F85xO2LsXamuN9UaSon3cM6tWTnTM5JB7d4sdsau9ZbxZ/Id292xq3qYzAU9vaxOJ6zVpGj0JRrDbwOq6Dx++xo9efPjw6V58uhedUC8jbf180bxYtVo/hNvb/hYg4SSLfY8TG4s3smzPMoYlDwu+1LnbBV9+CQ3e4NbW9DKlVRa+2p5EqqODRb/FJbBiOQDjqsq4vGivcdhiZ3lKNlvjkoyAZtpZRkE9n6/9Hbmbc7mg2glJidCvPxzH32PC+Cv/qfwb2601Y1ViAXDrNW22adqzaUfNN93eXLOn2wS7B1Yoryd6tw37d3LjtPO4ZHJoV/vKYt8+ZmDiQBJtiZS7ykmxB1kR02qDAQPg+42QEB91ozLJcR6S4+qpqjWR0t6iX9fRvxQ2OZJJaKhnypFDZNTX8ZNDeyhqDGi21dWiH7NnE9D+OhqbzUjTbkrRzsoyspo0+dE6HhXUbe1wl+32Apgm1d7DvF38KHtrN7TbblnpCx3OWvZom8MvMizmZJYdfqHHrjci9lRZVyTaJb9tjxPx1niGpQxjbeHa4AMZgOx+Rjn+6mojMyeKaKpO/xQ36/ZYSW5v0a/NfvTfisIXyVmsTUhjcnkxkyqKyayv44pDezj07hKWxyazLTaRgJN1tI6maaqprg7y843Xsn9/WQh8HDp2n6Xu2FrzRYdtqn3tB0093sZ7mKfyr6fGV9lj1yuo28pA+7iQru0RxxcJZI4jw5KHsbFoI0XOog7TDeOt8VhNVmO0IXcAbN7cOC0SXQvP0hLcHS/6TUs1Ps9moywuzcTnqf34OimDyeVFnFZRQlblEa6sPMJBawzLU7LZfmxA03wdTWvTT3a7MTpTUWHs19Svn7HxpNScOW6Ecs+mLMsQDtXvCdn5ekpHQUyoOb1HQr7WRgKe44uskTmO+HQfy/Yso6SmpMO2xc5iBicNNrKcamvgiy+NN+gofI2+z3OwrySGrOR2tmjYv98YVWmDfdgwTv96OaeVF2NtrCBaZLGzLiGVTY5knKbGbLBpZ0G9u+Ppp5oaI8hJTTPWztjtiOgXzBqZYPdsujj9dhYfui8c3Qyrkxzns7b6wx67Xoq5H2WewjYf7+xam2ADnr6eJdaZNltKtjJ7wtksOH8uWgj/cAv2/VsCmeNQR1/Sem89y/YsY0fZjqOLg3dshy1bjcq1UTYqU1Jp4evtSaQl1GPS2vnc21v/4vPBmjXYvQ2cXl4UEND4gD0x8Xwfn8K2CSdTvzev7Ws0n35qaIDKCmPEJiXFqEGjaqAqRtCoacZHRaGaKip9ZY2vvEpTDoOqqEZaKMZHRVGMc2hq40hP179WSuP/K/5RJyUgFVRBxaSYsamxmCK4w3pvE6qFriNiTw1NUNSTbbRUbsl9jr8W3NQj1wtGrJIICtT4Ktq+VicWVzctZu7LWWJdbdM/vj9Pnvcks0fNbvM17gwJZBr1xUAmGJWuSj7Y+QGltaUMThpspBJ/9aXxZhvnCO3F6mqNhcVhKrzn9Sl8sS2JOrdGsqODSr9tZSQ1y2wCsHsbGFt9hAlVh8l1HV28Wa+obItLZEN8Kntj4vEduzDHbocLLwycfqooN4KWxERaLORpvH+obie5lSkkqRn40pLxKeBTvDTgNf7TPTSUl+D11BkLjNNSQTWB2WTUtjGbjUKHpsbgyKQZC46bAh5NOxo4NX850NF1H7rxr6P/1nV8+PDobtzeGhp0D6qiYFVjsaqx2NTYoFNgj0et/6JPZUbqjR28GbRs05sykoJp05NZSyc5LmBt9QdtPt4Zpyf+iPVVy6htZ2rMoaVybuoNLC1+pM02x/Pr3d02TX8IvXH5GyEJZiSQaSSBTNsKq/5/e/ceHFd1J3j8e2+/1S2pJUuWLMsv/MIGW0wcW3EIEwc7hiSVkABb1BS7eCsFJARSEFIzC7tJCFVTBRVqUg6PAmqSCbM1Q3gkgWxgE3CwccIbjFls/MbyU5JlWZKlfnffe/aP093qlvV2S62Wf5+qW+q+fXT76Ej2/fV5/M5JXj74MgYG9YF62LsH9u7TE1UL5UynvqEnkv2bMDoLfwNsOVXGzsMVzJ4RG1Wm33PYNrz0Un5vTVpVIkZT3xku6+tiRiKWPd/ncLK7vJoD/iBHfQGSmS7V0Q4/ge4l+nAnJ/2nWXVoJnNPl+tAcv16WLpUl9m/H157LX+jT38A/v7vYcECsCzd+2NZ0N6u37OsLJ3bxtkfxDhMnevG49FHRQWUl0N5QAd1gzRcwo4RtnoIWz2cTXXSnWwjbPUQs8LYWJg48Jhl+jB8F1TPTaG65wsZFE1Wmcl6P0slebHjX4b5LRSe1wgQU6EhX5/OPWCFKGNg0FjRSMudLec9zCSBTJoEMsPbc3oPr376KjW+GiqTBrz5FnjchVlxc7YHkilYuRJQcOSoDmxMU2cT9ow2XdXIQjEHb+ypxuOy8XtHzvo5qBHm0bB4MY0f76Sp7wwr+rrw52zOmTIMjnkDHC6r4NDFl9LacaY/2d5AmeGn9PtZhk1HVZQvfDKLGX05c2muu15//d1vh67TddfDsmWwdy+8+qre3DIjUA4bNsCiRTrIsS39+zhxQq+s8nhgVj34yiAQgJqa/uDG7x+0B00pRdyOELZ6CFnd9KaDm6gdJmFFSJEEBU7Dhdv0pYMcHw5DkgUOZ6rOfSj2nI0j0V38R9v/GnN7DqbcMeO8h7GKodY1j9PJo8Wuxpht27SNdfPXndc1JJBJk0BmeEop3j7xNm8ee5P5wfl49x3Sqfdnj3GH6IHCIT1ctbJJ56oBfTM9fVrfwNvb9Y01GNQ30gLY2VLBsQ7f8JN+RzLcPBq3Jzv8ZCqbReFeloW6WRjppSqVyLtM1HTQUlbOobJKWsrK6XO4SJgOHdz4fPC1r8HLL0M0StiTJOGy+OKu2XiTOb1V5em/19zgZKDyCti48fyCnXXrdGAVj+udvt1u6OrSgcysWfpnr6jQvTqDUEqRUFEiVi9Rq4+o3Udv6gxnkx3EVJiEFcUiNfrZPApUurChDEwjkzp+9Pve+MxyfI4CD5GKSSeTq0vX09c+zT+s+IfzuoYkxBOjYhgGqxtW0xvvZdepXSxubMBx4rheyVTmH99Fo1GdIG75JXpjxQyHA+rrdfbcrm44cRxaW/XjiorR9dA4nUPOtWmoinGsw0fKMoaf9DucOXN0EDfYPBrbzi7jtg2TA4EgBwJBUIrqZJyFkV4WxUIsCPXgsy2Wh3pYHurJu3zcMImbDuKHPyaWTBI3HfS5wVJOapM9ZKbgKgzoy0z5NbJfLUxSOPuPPiepP54kRSp7LoEbO/cT76uv6q+DBTuhPnjpj/nBzp//rAPRDH8AvvQl3ZMUDOoem0C6x27PHoyuLjzV1XiWL6fKVZ/9NlvZxO0IEauXuB1hNEnYbazsXjoWKVJ2kqSKk1RxUnaClEqgsIe9hkLRlWwlZofz6iNKj4mDjTW3DDtnY2PtLcDw8zo21tzMPN+lI/bK+MwKovYwHxyKYFnZ5eyNvFnsaozZrPJZk/Ze0iMjAOiL9/GnQ3/iZO9JFp4IY3x6eHy9MokEdHTA0iWwfPnI2YJ7z8LJk3q4IzHCRF3QvQYB/6D7Q6Vsgzf3VBGOOwgGUkNc4DydOAFv9w8/GYAj98a6ZAnm/v00xMIsjPSyMNJLYyyEa5L/mUXxEKWMMGVEKCPiqiKSdBChjBhezlntNJqenfXrdWDq9ujf2fbt+b07M2rgllt0wJNhWbBnj+7hqa7WfxND9OwUilKKE7F9fBL6K0kVZ6ZrHkaJZa0W+SZrcvW1M/+JLWd+NSXmmmTqL3NkZGhJApkxOBU6xcsHXybR3cnsj1v0hNGxDPukUtDeBgsugpUrxpamPx6D5AiBjFJw5ozeqLGnR/fiDEjid/hUGZ8cC6DUqAcyxu7UKdi3F+JxbEy8xKj2xc4Zfsqtt1MpPLaF27bw2haeiy7Cc2A/Htsi6ouw+JSPqkhmoqzK9stAXh8NJhZOUrjy+2XyDnOEng8Lkyg+4nhI4CaOhzhu4q5yEknS5/W5JK5sDSivgO9/XydP/D9/GPoNvvtd+MIV8PHH8Ktf6XlRGZMY7HQmTrCr73V6ku3UeS7CKfN0StpkTa6eaiuEpmKdhiojq5YmiAQyY3PwzEH+fOjPVH56nKojp/SNxe9nxHwltgWtbXrF099dppcCT5R4TPeMtLRAby9UBvXKGwxStkFfdBJGTC0bWk/S2anY3TufWQs9mJnhpyFWP2XlzJFJxcN0Vkb5wicNVIe8+eVGM0fGV6aXt2cpXCQz/TD4018zh4/oiIFOrhQOYniJ4iWGj+glq4kdOkE0DlF8xPDmBzughyQvvxy2vDr0hf/HPbrMW2/Bv/5r4YKdAeVCS2axO/omJ2P7qXXPxWv69d/q8eN6s8/ygB5OlOzLF5SRAp4LdZXY+ZaZUzGHzVdvljwyhSaBzNi9d/I9/rrvFRpPx/F2dOlJu2Vlei+mAUunDQx9Y2xt03Nf/u4zk5fFNhKB48f0/kahsF7a7R/nvJ5xiiVN3thThVIGlf70cNZIq59yVi2FPtxOymHzxd2z8SQH3ExHs2rp2utgy5ZRBzsGNl5ilBFN98Uksl892b4Z/djF6IbnErgIEcg/PDOIxE0UQwzpZJaY/+HFoS98z726rUYb7AxRLnHLTexdoTgc3knFkW7KX3knv73KK+CqjXDxsv5zowl2ClVmst9P6j2qchfiKrHxlpHMvhNMApmxS9kpXj/yOrs7duueha4uvcoolJ59GgjopGxASlm4u3qoq5xN2erPFz6Z3miE+nQwc/w4RGMQrNQTh52TM5RwoLWM3UcH5LAZ5S7aZ9o+puLDw1z+YbC/XGa+yrL0jXWw1Ua5ZfbuLWiwk2FiZfph0n0vMXz1QbztLelzUdwMPRxoYxDGT4hAeijLTSIdJiWyQ1nq3B6d3J/x61+Hp/9z6Hr/4z/B5z4H77wDD/1syGLWP/6QFvMQ+7ZuxmEbVPd587IYA3D99TqY2bcXXhmkvdPBjqVSxPbvJPrmFuKJnORqZX5dl/nz9fMjR3S9IuEhyxjKwDx6FPPNdzFDYYzMkKg/AF+4HC5aqJ8f/lRvIzJwEnaxykzQ+xmAM2Xi8lXivHIjzqUrdObpEX4nwOjKjKVciQZgxSjzUfthbl7RzDU3/5eCzoGbVoHMY489xkMPPUR7eztNTU088sgjrFmzZlTfK4HM+CSsBJ2Rzv7tDlJJaGvXwznHjmb/uCOJMHudPRxdWkfC76PWX0vQE8xJez+Jes/qm0f7KZ2QLpXuUTBNPXfF49ZLi11D3DjHKZPDxu209caVmQR1iYRebh6N6sAqGNR1SW9LgGnS6mxlaWoZy45X6x6mQKB/Y8rcNlRKT7ANh3WZOXP6/8MwTZ0075VX8pPmFTrYKa+Ab3wD/vM/sqccWPgJD+yPIUAofxL0MGyMdIDjTg9hZQ4fMWc50ZRj8CEs0DfFTZvg3/89/2Y5UDovUqunnU/mdRFxJ6nr8WPmzqUqL4f1G+DFF7KnFIqk0ybqThFzWyS/vA4HDrz/93Uqoi5m9HoJxFw4bLO/brfdpr8+/jiZeU4KUIbCMsE2FdbN/x2r6VJS/28HyaefIumwSDptbEOlL5O+1rXpLvrf/55zV30VqczSi/WWJhPwfrahdDs7FUnTIrXxS/q1rVtxWCYuy8RpGf0BH+hhWtDpDHK4UyaepEMHrLlB6m+H+XcwymAWmNwyk/1+Yyzz0QwvNx86yTWeBPziF/2/2/M0bQKZZ599lptuuoknnniC5uZmNm/ezPPPP8/+/fuZOXPmiN8vgcwE6O7WAc3e9ITXL62jvcbLgc4D7O/aT2+sl6A3SG1ZbUG7GUctHtdLp6NR3UMTCukgJxqFeAKS6ZwvhqGDAWcmxX863f+Qk5SVngNjpYMVy9bPkwl2Hy3nYEclsytD/Zl0XS7dC1NWpoMNZeuEdJYFKQusFCftI6xOrKExOVsHK6C/DvxnmXsu8zj3gPzMvj6fDoi83v5MvgcOnF/PznXX62zDjzwyit6dMD6i2aDGm+2Pief0ySRGPXwFepJynEGW6Hu8et7UaK9j6OAk5DIIuRz0OZ30uRyEnA5CHjd9ppF9njBNXJaBJ+GkMuKmwqzBH3dR1hnBk8r/O8lM0aYiqPMFne3pP5f7OuiEkP/8z/CjH+ktLAZcJzvdu2qGft7dnXON3GDO0Pt4Qf6QWp4ClqmpgSefhFtvnbD3swxFwmURd9nEa8tJOC3i4U4inhQhb5KoOwWG6r9OJhVAbhAPxJ02cZcFBnjdlXj/23fwPfG/MXuHCXgrKuDLX4bf/W7oMtenh3xHCogKVWa0Adhk1mlAmWwg09nS/1oBgplpE8g0NzezevVqHn30UQBs22bOnDl8//vf55577hnx+yWQmUDJpM4QW12dPdUd7eZw92F2n97N6fBpfE4fdf46PM7CZfEdt2RCBzbRqA504nEIR9I7Vcd0L0oyCZmMvYpzO25M89w9jHxeuo1q3jpYS6DSxFfh7t//aJhlvyk7wZnkSb4QvJ4qx0wdFJ0TzKj0x/mcgCVTLnMMfG5Z+mfs7dX5fKLpn9W29fXOdOneokBA5/XJXNO24NCneq7JYMMhmcSGR4/C1teGbuf16+Gdd4fvIUkPZZlY6QAniSe/Lyavb8ZDYuhrXWBsDGzMEY4J7BGtqYXOwQOU/JvJxNRhtDcsy1SkTBvLoUg4baygHyukA3BDGThsUDjS7WlgGSaWYWC5XFiWpR8b+VPjFYbu2QVUPPOBKLdO6QA0XYZ0GZXzcjag9Xh0kJoThCuM/GbzePUw3Btv5gXr57SBJ71QYEBAn5uHSnm9KMNAxXQZZRjnXsebnt8YG2axwiBljgVcXNoVZX33Cf0BsbFRf9g9z2GmaZEQL5FIsGPHDu69997sOdM02bBhA2+//fag3xOPx4nH+zO79vZOreRG04rLlRfEAFT5qljlW8Xy2uUc6TnCJ6c/4djZYwQ9QWr9tUWqaJrLrY/B/kFYKf2fTjyub/LxuA58TIfegNHp7D8cmceOdFDjIKig3qMXU/lGOd84ZofxOPz4XdV6A8iJYNs6SItE9BEK6aXr4bAOejIBmTs97NYwG668Uv8goZAeDlu0qD8RoWHA59fqnpnf/Ca/NyEYhG9co8tXVMILvx+6Xs3N8N572JFwOmzxAQN+L15f9j/LzHwd92ABzZrPwXvvjLlpXCSzs3ZyD0/OY3OUw2NG3i3j3HOFvKXrKdQWMM6tOM5XZ1dx3nes7PSRAuJAuETvBc8cLHYNRnYKPgrU6MdK6bk1f/ubzho+CaZ0INPZ2YllWdTV1eWdr6urY9++fYN+zwMPPMD9998/GdUTw/C5fCyrXcaSGUvYc3oP249upz3UrjennIocTihz6mGgcTAMPW0lk9fPPYp5xjE7TJW7HrfpHbnweJmm/pkG/lyJdECQGQYb6NJLh7/uV76ih6SGWhJ92WWwZIleRdSVkzirqlp3TTet1Bte/vrfhn6Pdev0f4bhEDaO9GLyAVFimR+WrYVdx8+ZrJwnkw9puDJjHKI6b1+4At7424CTucGPGhAM6UP3t+i+BN3/Yg3SHzOBHe2Ll8DBA9mnuYNnAw332kQaNHBctBgO9QcFKdMm6UxhO1NYpoXtSJF0pbAcKTDO7dsycn6E7LlMj+mA9zRyvyp17rmc6+U+H7Te6Wzi/dce0FU8yPv3vzfZdAuZ6xsoDMVQ6wnHJWo6sewB4URbWwHfYXhTOpAZj3vvvZe77747+7y3t5c5ubsNi0nlMB2sqFuB03Sy7cg2WvtaaShvKHa1JsSMGVBbq3P21Y08fYu4ilDlnLw03nncBcjz43DAihVDv3755XpIaqhgZ+48qKs7d8l0TS18+9uwZo0u//N/Gfo9broJVqWX/D/x+NDlNm3SX4crc/PN8PTT0D1Mj0N1el5HbnA2njIzauCOO9Jtk1uuP/2hKuT7FbLMjzfDXXdNnTpVpXuFR/q9/ejn8IMf9JezgUT6yCivwA6dJeayiLtTRN0WSed59nwNiDmUoSd+K0NPbgawDBvLBAyVPZe18Wp49c/nXFYZejK6MsFGZa+Zve4krrdoVQ3817a9QHv/yVmT93/blA5kampqcDgcnDp1Ku/8qVOnqK8f/JO9x+PBU8BdlUVhLKtdhsN0sLVlKyd6T9BY0VjsKhWcw9TTSDo69Fxe5yiGh8ud1SMXKmUjBTuf/7weZhoq2Fm3TgddgwU7N9/cn0fmq1/VQ1sjlRupTHk5PJjJWJp7Q0nfFW69VX893zK33KJ7yW69dXLer5BlgsGpVe/vfGd016mu1mWHK3fbbZi/+hVlZ85QlnBSxUC5k5TPMHhPUwHL1NTA1f8Tfn9kct5vnGUOsJA6DqWLpOfIXHHFIN8/MUpisu+aNWt45JFHAD3Zd+7cudxxxx0y2bcEHeo6xNaWrSStJHMr5478DSUmmUrPlY3AjGFilKQdpyvVxhVVNxB0jaL75kI3zsy+g5YbqcxgifUGBkSFKjPZ7yf1HrncW28NH+xk7juTVWYq1mlAmQMs5mpe4RJjrz4lq5byPfvss2zatIknn3ySNWvWsHnzZp577jn27dt3ztyZwUggM/W0dLfwWstrRJNR5lXOK07OmQl05Ch8uAMaGobcqJu+1BlsbNZV34jLlB7EKacQAdFoy0z2+0m9p1YwOw0Cx2wgM6cPNm+WPDKDefTRR7MJ8S677DIefvhhmpubR/W9EshMTcfOHuMvh/9CKBFifuX8aRXMxOJ6DqetdJLhwXQmjjPD3Uhz8BuTWzkhxOiUYgBWpDIH9iS5en2KS25aJZl9J4IEMlPXyd6T/OXwX+iOdbMguABzmJwrpebAAdi1Ww8VDxainYwf4BL/FSwJjC5DtRBCTFUHDsDVV8MllxT2uqO9f0+fO4coObMrZrNx4UZqymo43H0YW40uZ0cpaGjQ+1eGw+e+lvnsEHCeO5VQCCHE2EggI4pqVvksNi7cSK2/lhO9J4pdnYIJBKBxNpztOfe1pIrjNrz4HcHJrpYQQkw7EsiIopvpn8nqhtXEU3ES1vRJRT97tl45HB2QYy1mh/GYZfidwaLUSwghphMJZMSUsLB6IfOD8znZd7LYVSmYYBDqZ+kdAXLF7TAVzlqcxijS/wohhBiWBDJiSnCaTprqm7Btm1hqEtPET6DMtgWgty3ISNhRqt1FyugrhBDTzJTO7CsuLPOD81lYvZBPuz9lYdXCYlenIDLbFrS16ZwySik6FXT0BLGL/DEiGISZkotPCFHiJJARU4bDdNBU30RLdwuRZIQy1/g2cJxKHKZektiY3pEhlorSnfDx1TlBgkXMgxeJwLvvQns7DLHbhxBClAQJZMSU0ljRyOIZi9nbuZfF1YuLXZ2CqKzQB8DpcJgZpp81KytxFrlHpqwMtm2TYEYIUdpkjoyYUkzDZGXdSjwOD33xvmJXp+AiyQh1/jqcZvE/QyxfDldeCYmEDmaEEKIUSSAjppyG8gaW1iylNdRa7KoUXMyKURcYeY+wybJsGaxfD8mknscjhBClRgIZMeUYhsHKupX4XX56Yj3Frk7B2MrGwCDoDRa7Knkuvlj3zKRS0Dr9YkchxDQngYyYkmb6Z7J85nLaQ+1Ml+3AYqkYZa6yKRfIgA5m1q8H25ZgRghRWiSQEVPWipkrqPRW0hXrKnZVCiKcCBNwB6j0DLEldpEtXap7ZiSYEUKUEglkxJRV7atmxcwVdIQ7pkWvTCgZYqZ/Jg6zcNvcF9rSpdIzI4QoLRLIiCltee1yaspq6Ix0Frsq5y1pJafURN+hLFmigxml4NgxsKxi10gIIYYmgYyY0iq9laycuZLOaCe2sotdnXGbqhN9h7JkCWzcqLP/HjwIXdNjdE8IMQ1JICOmvGW1y6jz19ER7ih2VcYtkozgc/lKJpABuOgi+Na34IorIBbTAU00WuxaCSFEPglkxJTnd/u5rP4yemI9WHZpjnNkJvpWeCqKXZUxKSuDz30OvvlNnXPm5EkZbhJCTC3FTy8qxCgsrVnK7o7d7DuzD5fpKsg1naYTp+nEZbr0Y4d+nHleyEm5kWSE+VXzMY3S/OxQVwdXXQWLFsEHH+jemdpavSmmEEIUkwQyoiR4nV7WzV9Ha19hltLYyiaSjOQdSStJNBklaSdJ2SlSVgq3w019oB6fy3de75e0k9SW1Rak7sVimrB4sd4Ac9cu2LkTDhzQQY5j6i7EKgjD0MfA57nnhBDFIYGMKBmzK2Yzu2L2hFzbVjYJK5E94qk44WSYPaf3cLTnKLayqQ/UE3AHxnxty7YwDIMqX9UE1Hzy+XywZg0sWAA7dsDRo8Wu0cRTSh8DHw/2XIgLjd9f3A8zEsgIgd6s0uv04nV6884vql7Eid4T7D29l0PdhzjZd5KZ/pkEPUGMUX4cj6ai+F3+KZsIb7xqa/XKpnC42DWZWJlAJfcYeF6IC11VET+nSSAjxDBMw2Ru5VzmVMyhKdzEvtP72N+1n45QB9W+amaUzRhx3ksoEaLcXU65p3ySaj15TBPKp9+PJYQoIRLICDEKhmFQH6inPlDPyvqVHDxzkE9Of8LBroOYIyz+i6airJ2ztmQn+gohxFQmgYwQY1Ttq6a5sZlLZl5CS3cLcSs+4vfMLp+YuT1CCHGhk0BGiHEKuAOsqFtR7GoIIcQFTfq6hRBCCFGyJJARQgghRMmSQEYIIYQQJUsCGSGEEEKULAlkhBBCCFGyJJARQgghRMmSQEYIIYQQJUsCGSGEEEKULAlkhBBCCFGyJJARQgghRMmSQEYIIYQQJUsCGSGEEEKULAlkhBBCCFGypv3u10opAHp7e4tcEyGEEEKMVua+nbmPD2XaBzJ9fX0AzJkzp8g1EUIIIcRY9fX1UVlZOeTrhhop1Clxtm3T2tpKeXk5hmEU7Lq9vb3MmTOH48ePU1FRUbDrisFJe08uae/JJ20+uaS9J9d42lspRV9fHw0NDZjm0DNhpn2PjGmaNDY2Ttj1Kyoq5B/BJJL2nlzS3pNP2nxySXtPrrG293A9MRky2VcIIYQQJUsCGSGEEEKULAlkxsnj8XDffffh8XiKXZULgrT35JL2nnzS5pNL2ntyTWR7T/vJvkIIIYSYvqRHRgghhBAlSwIZIYQQQpQsCWSEEEIIUbIkkBFCCCFEyZJARgghhBAlSwKZcXrssceYP38+Xq+X5uZm3nvvvWJXaVr461//yte//nUaGhowDIMXX3wx73WlFD/5yU+YNWsWPp+PDRs2cPDgweJUdhp44IEHWL16NeXl5cycOZNvfvOb7N+/P69MLBbj9ttvZ8aMGQQCAa677jpOnTpVpBqXtscff5yVK1dms5uuXbuWP/3pT9nXpa0nzoMPPohhGNx1113Zc9LehfXTn/4UwzDyjosvvjj7+kS1twQy4/Dss89y9913c9999/Hhhx/S1NTEVVddRUdHR7GrVvLC4TBNTU089thjg77+s5/9jIcffpgnnniCd999F7/fz1VXXUUsFpvkmk4P27dv5/bbb+edd95hy5YtJJNJNm7cSDgczpb5wQ9+wB//+Eeef/55tm/fTmtrK9dee20Ra126GhsbefDBB9mxYwcffPABV155Jddccw2ffPIJIG09Ud5//32efPJJVq5cmXde2rvwLrnkEtra2rLHG2+8kX1twtpbiTFbs2aNuv3227PPLctSDQ0N6oEHHihiraYfQL3wwgvZ57Ztq/r6evXQQw9lz/X09CiPx6N+85vfFKGG009HR4cC1Pbt25VSun1dLpd6/vnns2X27t2rAPX2228Xq5rTSlVVlfrlL38pbT1B+vr61OLFi9WWLVvUF7/4RXXnnXcqpeRveyLcd999qqmpadDXJrK9pUdmjBKJBDt27GDDhg3Zc6ZpsmHDBt5+++0i1mz6a2lpob29Pa/tKysraW5ulrYvkLNnzwJQXV0NwI4dO0gmk3ltfvHFFzN37lxp8/NkWRbPPPMM4XCYtWvXSltPkNtvv52vfe1ree0K8rc9UQ4ePEhDQwMXXXQRN954I8eOHQMmtr2n/e7XhdbZ2YllWdTV1eWdr6urY9++fUWq1YWhvb0dYNC2z7wmxs+2be666y4uv/xyLr30UkC3udvtJhgM5pWVNh+/Xbt2sXbtWmKxGIFAgBdeeIHly5fz0UcfSVsX2DPPPMOHH37I+++/f85r8rddeM3NzTz11FMsXbqUtrY27r//fq644gp27949oe0tgYwQAtCfXHfv3p03pi0Kb+nSpXz00UecPXuW3/72t2zatInt27cXu1rTzvHjx7nzzjvZsmULXq+32NW5IHzlK1/JPl65ciXNzc3MmzeP5557Dp/PN2HvK0NLY1RTU4PD4ThnpvWpU6eor68vUq0uDJn2lbYvvDvuuIOXXnqJbdu20djYmD1fX19PIpGgp6cnr7y0+fi53W4WLVrEqlWreOCBB2hqauIXv/iFtHWB7dixg46ODj7zmc/gdDpxOp1s376dhx9+GKfTSV1dnbT3BAsGgyxZsoRDhw5N6N+3BDJj5Ha7WbVqFa+99lr2nG3bvPbaa6xdu7aINZv+FixYQH19fV7b9/b28u6770rbj5NSijvuuIMXXniBrVu3smDBgrzXV61ahcvlymvz/fv3c+zYMWnzArFtm3g8Lm1dYOvXr2fXrl189NFH2eOzn/0sN954Y/axtPfECoVCfPrpp8yaNWti/77Pa6rwBeqZZ55RHo9HPfXUU2rPnj3q1ltvVcFgULW3txe7aiWvr69P7dy5U+3cuVMB6uc//7nauXOnOnr0qFJKqQcffFAFg0H1hz/8QX388cfqmmuuUQsWLFDRaLTINS9Nt912m6qsrFSvv/66amtryx6RSCRb5rvf/a6aO3eu2rp1q/rggw/U2rVr1dq1a4tY69J1zz33qO3bt6uWlhb18ccfq3vuuUcZhqFeffVVpZS09UTLXbWklLR3of3whz9Ur7/+umppaVFvvvmm2rBhg6qpqVEdHR1KqYlrbwlkxumRRx5Rc+fOVW63W61Zs0a98847xa7StLBt2zYFnHNs2rRJKaWXYP/4xz9WdXV1yuPxqPXr16v9+/cXt9IlbLC2BtSvf/3rbJloNKq+973vqaqqKlVWVqa+9a1vqba2tuJVuoR9+9vfVvPmzVNut1vV1taq9evXZ4MYpaStJ9rAQEbau7BuuOEGNWvWLOV2u9Xs2bPVDTfcoA4dOpR9faLa21BKqfPr0xFCCCGEKA6ZIyOEEEKIkiWBjBBCCCFKlgQyQgghhChZEsgIIYQQomRJICOEEEKIkiWBjBBCCCFKlgQyQgghhChZEsgIIYQQomRJICOEEEKIkiWBjBBCCCFKlgQyQgghhChZ/x/A/uYa1bLE+gAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if not SMOKE_TEST:\n",
+    "    plt.plot(bo_results_itr.mean(0),color = 'red', label = 'no outliers')\n",
+    "    plt.scatter(range(50),bo_results_itr.mean(0), color = 'red')\n",
+    "    plt.fill_between(range(50),(bo_results_itr.mean(0)-bo_results_itr.std(0)),\n",
+    "                    (bo_results_itr.mean(0)+bo_results_itr.std(0)), alpha = 0.3, color = 'red' )\n",
+    "    plt.plot(bo_results_outliers_itr.mean(0),color = 'blue', label = 'baseline')\n",
+    "    plt.scatter(range(50),bo_results_outliers_itr.mean(0), color = 'blue')\n",
+    "    plt.fill_between(range(50),(bo_results_outliers_itr.mean(0)-bo_results_outliers_itr.std(0)),\n",
+    "                    (bo_results_outliers_itr.mean(0)+bo_results_outliers_itr.std(0)), alpha = 0.3, color = 'blue' )\n",
+    "    plt.plot(bo_results_no_outliers_itr.mean(0),color = 'green', label = 'ITGP model')\n",
+    "    plt.scatter(range(50),bo_results_no_outliers_itr.mean(0), color = 'green')\n",
+    "    plt.fill_between(range(50),(bo_results_no_outliers_itr.mean(0)-bo_results_no_outliers_itr.std(0)),\n",
+    "                    (bo_results_no_outliers_itr.mean(0)+bo_results_no_outliers_itr.std(0)), alpha = 0.3, color = 'green' )\n",
+    "\n",
+    "    plt.ylabel('funciton value')\n",
+    "    #plt.yscale('log',base=10)\n",
+    "    plt.legend()\n",
+    "    plt.title('outliers moderately outrageous')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Outliers too outrageous\n",
+    "Now we run optimization to compare the three models for too outrageous outliers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "run 00 with current best 10.357: 100%|██████████| 50/50 [00:00<00:00, 67.98it/s]\n",
+      "run 00 with current best 0.015: 100%|██████████| 50/50 [03:15<00:00,  3.90s/it] \n",
+      "run 00 with current best 0.039: 100%|██████████| 50/50 [02:53<00:00,  3.47s/it] \n",
+      "run 00 with current best 0.791: 100%|██████████| 50/50 [03:15<00:00,  3.90s/it] \n",
+      "run 00 with current best 3.929: 100%|██████████| 50/50 [00:00<00:00, 55.68it/s] \n",
+      "run 00 with current best 0.016: 100%|██████████| 50/50 [03:13<00:00,  3.88s/it]\n",
+      "run 00 with current best 0.338: 100%|██████████| 50/50 [02:42<00:00,  3.25s/it]\n",
+      "run 00 with current best 0.520: 100%|██████████| 50/50 [03:18<00:00,  3.98s/it] \n",
+      "run 00 with current best 8.848: 100%|██████████| 50/50 [00:00<00:00, 66.24it/s]\n",
+      "run 00 with current best 0.072: 100%|██████████| 50/50 [03:08<00:00,  3.77s/it]\n",
+      "run 00 with current best 3.802: 100%|██████████| 50/50 [02:39<00:00,  3.18s/it]\n",
+      "run 00 with current best 0.295: 100%|██████████| 50/50 [03:11<00:00,  3.84s/it] \n",
+      "run 00 with current best 8.148: 100%|██████████| 50/50 [00:00<00:00, 62.74it/s]\n",
+      "run 00 with current best 0.044: 100%|██████████| 50/50 [03:30<00:00,  4.21s/it]\n",
+      "run 00 with current best 8.148: 100%|██████████| 50/50 [02:47<00:00,  3.35s/it]\n",
+      "run 00 with current best 0.190: 100%|██████████| 50/50 [03:29<00:00,  4.19s/it]\n",
+      "run 00 with current best 4.040: 100%|██████████| 50/50 [00:01<00:00, 46.24it/s]\n",
+      "run 00 with current best 0.019: 100%|██████████| 50/50 [03:12<00:00,  3.86s/it]\n",
+      "run 00 with current best 9.742: 100%|██████████| 50/50 [02:44<00:00,  3.28s/it]  \n",
+      "run 00 with current best 0.180: 100%|██████████| 50/50 [03:27<00:00,  4.15s/it] \n",
+      "run 00 with current best 0.084: 100%|██████████| 50/50 [00:01<00:00, 40.28it/s] \n",
+      "run 00 with current best 0.041: 100%|██████████| 50/50 [03:00<00:00,  3.62s/it]\n",
+      "run 00 with current best 0.336: 100%|██████████| 50/50 [02:58<00:00,  3.56s/it] \n",
+      "run 00 with current best 0.018: 100%|██████████| 50/50 [03:27<00:00,  4.15s/it] \n",
+      "run 00 with current best 0.448: 100%|██████████| 50/50 [00:01<00:00, 40.23it/s]\n",
+      "run 00 with current best 0.021: 100%|██████████| 50/50 [03:09<00:00,  3.80s/it]\n",
+      "run 00 with current best 0.448: 100%|██████████| 50/50 [02:59<00:00,  3.58s/it]\n",
+      "run 00 with current best 0.139: 100%|██████████| 50/50 [03:17<00:00,  3.94s/it]\n",
+      "run 00 with current best 4.038: 100%|██████████| 50/50 [00:01<00:00, 42.01it/s]\n",
+      "run 00 with current best 0.024: 100%|██████████| 50/50 [17:18:28<00:00, 1246.18s/it]    \n",
+      "run 00 with current best 11.580: 100%|██████████| 50/50 [07:14<00:00,  8.70s/it]\n",
+      "run 00 with current best 1.396: 100%|██████████| 50/50 [06:44<00:00,  8.09s/it] \n",
+      "run 00 with current best 6.455: 100%|██████████| 50/50 [00:00<00:00, 54.94it/s] \n",
+      "run 00 with current best 0.002: 100%|██████████| 50/50 [05:40<00:00,  6.81s/it]\n",
+      "run 00 with current best 14.254: 100%|██████████| 50/50 [05:22<00:00,  6.44s/it]\n",
+      "run 00 with current best 0.724: 100%|██████████| 50/50 [04:03<00:00,  4.87s/it] \n",
+      "run 00 with current best 3.752: 100%|██████████| 50/50 [00:00<00:00, 72.67it/s]\n",
+      "run 00 with current best 0.006: 100%|██████████| 50/50 [02:42<00:00,  3.25s/it]\n",
+      "run 00 with current best 9.092: 100%|██████████| 50/50 [02:21<00:00,  2.84s/it] \n",
+      "run 00 with current best 9.408: 100%|██████████| 50/50 [02:53<00:00,  3.47s/it] \n"
+     ]
+    }
+   ],
+   "source": [
+    "bo_results_set=[]\n",
+    "bo_results_outliers_set=[]\n",
+    "bo_results_no_outliers_set=[]\n",
+    "n_iterations = 10 if not SMOKE_TEST else 1\n",
+    "for kk in range(n_iterations):\n",
+    "    Benchmark = Himmelblau()\n",
+    "    sampled = sample(Benchmark.domain)\n",
+    "    sampled_xy = Benchmark.f(sampled, return_complete=True)\n",
+    "    random_results = run(\n",
+    "        Himmelblau(),\n",
+    "        strategy_factory=RandomStrategy,\n",
+    "        n_iterations=50,                     # random strategy \n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    bo_results = run(\n",
+    "        Himmelblau(),\n",
+    "        strategy_factory=partial(SoboStrategy, acquisition_function=qEI()),\n",
+    "        n_iterations=50 if not SMOKE_TEST else 1,\n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    Benchmark = Himmelblau(outlier_rate = 0.2, outlier_prior = UniformOutlierPrior(bounds =(5000,10000)))\n",
+    "    sampled_xy1 = Benchmark.f(sampled, return_complete=True)\n",
+    "\n",
+    "    bo_results_outliers = run(\n",
+    "        Benchmark,\n",
+    "        strategy_factory=partial(SoboStrategy, acquisition_function=qEI()),\n",
+    "        n_iterations=50 if not SMOKE_TEST else 1,\n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy1,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    domain = Benchmark.domain\n",
+    "    detectors = []\n",
+    "    for output_feature in domain.outputs.get_keys():\n",
+    "        if len(domain.inputs.get(CategoricalInput, exact=True)):\n",
+    "                detectors.append(IterativeTrimming(\n",
+    "                        base_gp=MixedSingleTaskGPSurrogate(\n",
+    "                            inputs=domain.inputs,\n",
+    "                            outputs=Outputs(features=[domain.outputs.get_by_key(output_feature)]),  # type: ignore\n",
+    "                        ))\n",
+    "                    )\n",
+    "        else:\n",
+    "            detectors.append(IterativeTrimming(\n",
+    "                base_gp=SingleTaskGPSurrogate(\n",
+    "                    inputs=domain.inputs,\n",
+    "                    outputs=Outputs(features=[domain.outputs.get_by_key(output_feature)]),  # type: ignore\n",
+    "                ))\n",
+    "            )\n",
+    "    outlier_detection_specs = OutlierDetections(detectors=detectors)\n",
+    "\n",
+    "    bo_results_no_outliers = run(\n",
+    "        Benchmark,\n",
+    "        strategy_factory=partial(SoboStrategy, acquisition_function=qEI(), outlier_detection_specs = outlier_detection_specs,\n",
+    "                                min_experiments_before_outlier_check = 10, \n",
+    "                                frequency_check = 2),\n",
+    "        n_iterations=50 if not SMOKE_TEST else 1,\n",
+    "        metric=best,\n",
+    "        initial_sampler=sampled_xy1,\n",
+    "        n_runs=1,\n",
+    "        n_procs=1,\n",
+    "    )\n",
+    "\n",
+    "    bo_results_set.append(bo_results[0])\n",
+    "    bo_results_outliers_set.append(bo_results_outliers[0])\n",
+    "    bo_results_no_outliers_set.append(bo_results_no_outliers[0])\n",
+    "\n",
+    "## Collecting data evolution over iterations\n",
+    "\n",
+    "bo_results_itr = np.zeros((len(bo_results_set),50))\n",
+    "bo_results_outliers_itr = np.zeros((len(bo_results_set),50))\n",
+    "bo_results_no_outliers_itr = np.zeros((len(bo_results_set),50))\n",
+    "for i in range(len(bo_results_set)):\n",
+    "    bo_results_itr[i] = bo_results_set[i][1].to_numpy()\n",
+    "    bo_results_outliers_itr[i] = bo_results_outliers_set[i][1].to_numpy()\n",
+    "    bo_results_no_outliers_itr[i] = bo_results_no_outliers_set[i][1].to_numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Performance of models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'outliers too outrageous')"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if not SMOKE_TEST:\n",
+    "    plt.plot(bo_results_itr.mean(0),color = 'red', label = 'no outliers')\n",
+    "    plt.scatter(range(50),bo_results_itr.mean(0), color = 'red')\n",
+    "    plt.fill_between(range(50),(bo_results_itr.mean(0)-bo_results_itr.std(0)),\n",
+    "                    (bo_results_itr.mean(0)+bo_results_itr.std(0)), alpha = 0.3, color = 'red' )\n",
+    "    plt.plot(bo_results_outliers_itr.mean(0),color = 'blue', label = 'baseline')\n",
+    "    plt.scatter(range(50),bo_results_outliers_itr.mean(0), color = 'blue')\n",
+    "    plt.fill_between(range(50),(bo_results_outliers_itr.mean(0)-bo_results_outliers_itr.std(0)),\n",
+    "                    (bo_results_outliers_itr.mean(0)+bo_results_outliers_itr.std(0)), alpha = 0.3, color = 'blue' )\n",
+    "    plt.plot(bo_results_no_outliers_itr.mean(0),color = 'green', label = 'ITGP model')\n",
+    "    plt.scatter(range(50),bo_results_no_outliers_itr.mean(0), color = 'green')\n",
+    "    plt.fill_between(range(50),(bo_results_no_outliers_itr.mean(0)-bo_results_no_outliers_itr.std(0)),\n",
+    "                    (bo_results_no_outliers_itr.mean(0)+bo_results_no_outliers_itr.std(0)), alpha = 0.3, color = 'green' )\n",
+    "\n",
+    "    plt.ylabel('funciton value')\n",
+    "    #plt.yscale('log',base=10)\n",
+    "    plt.legend()\n",
+    "    plt.title('outliers too outrageous')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}