diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 99c0269..6e4e178 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -50,11 +50,6 @@ repos:
       - id: ruff
         args: ["--fix", "--show-fixes"]
 
-  - repo: https://github.com/codespell-project/codespell
-    rev: "v2.2.6"
-    hooks:
-      - id: codespell
-
   - repo: https://github.com/shellcheck-py/shellcheck-py
     rev: "v0.9.0.6"
     hooks:
diff --git a/paper-examples/Data.py b/paper-examples/Data.py
new file mode 100644
index 0000000..9e05b3a
--- /dev/null
+++ b/paper-examples/Data.py
@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import pickle
+import random
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import sklearn
+from scipy.io import arff
+from sklearn.model_selection import train_test_split
+
+DATA_DIR = "data/"
+
+
+def get_corpus_and_outlier_paths(df, desired_class):
+    corpus_paths = []
+    outlier_paths = []
+
+    for i in range(df.shape[0]):
+        if df.iloc[i]["target"] == desired_class:
+            corpus_paths.append(
+                np.column_stack([list(range(df.shape[1] - 1)), df.iloc[i][:-1]])
+            )
+        else:
+            outlier_paths.append(
+                np.column_stack([list(range(df.shape[1] - 1)), df.iloc[i][:-1]])
+            )
+
+    return corpus_paths, outlier_paths
+
+
+def normalise(streams):
+    return [
+        sklearn.preprocessing.MinMaxScaler().fit_transform(stream) for stream in streams
+    ]
+
+
+class Data:
+    """
+    Hold time-series data and allow augmentations
+    """
+
+    def __init__(self, if_sample=True, n_samples=(800, 10, 10), random_seed=1):
+        self.corpus = (
+            None  # unlabelled corpus consists of streams, numpy.array(numpy.array)
+        )
+        self.test_inlier = None  # test set consists of numpy.array of inliers,
+        self.test_outlier = None  # test set consists of numpy.array of outliers
+        self.if_sample = if_sample
+        self.n_samples = n_samples
+        self.random_seed = random_seed
+
+    def sample(self):
+        random.seed(self.random_seed)
+        self.corpus = random.choices(list(self.corpus), k=self.n_samples[0])
+        self.test_inlier = random.choices(list(self.test_inlier), k=self.n_samples[1])
+        self.test_outlier = random.choices(list(self.test_outlier), k=self.n_samples[2])
+
+    def load_pen_digit(self, digit: int = 1):
+        """
+        Load pen digit dataset with a specific digit as training set
+        :param digit: 0-9, use as "normality" training corpus
+        :return: None
+        """
+        train_df = pd.read_pickle(DATA_DIR + "pen_digit_train.pkl")
+        test_df = pd.read_pickle(DATA_DIR + "pen_digit_test.pkl")
+        self.corpus = train_df[train_df["Digit"] == digit]["Stream"].to_numpy()
+        self.test_inlier = test_df[test_df["Digit"] == digit]["Stream"].to_numpy()
+        self.test_outlier = test_df[test_df["Digit"] != digit]["Stream"].to_numpy()
+
+        if self.if_sample:
+            self.sample()
+        self.corpus, self.test_inlier, self.test_outlier = map(
+            normalise, (self.corpus, self.test_inlier, self.test_outlier)
+        )
+
+    def load_language_data(self):
+        """
+        Load language data set with English and German words.
+        :return: None
+        """
+        paths = np.load(DATA_DIR + "paths_en_de.npy")
+        labels = np.load(DATA_DIR + "labels_en_de.npy")
+        (paths_train, paths_test, labels_train, labels_test) = train_test_split(
+            paths, labels, random_state=1, test_size=0.2
+        )
+        paths_train = paths_train[labels_train == 0]
+
+        self.corpus = paths_train
+        self.test_inlier = paths_test[labels_test == 0]
+        self.test_outlier = paths_test[labels_test == 1]
+        if self.if_sample:
+            self.sample()
+        self.corpus, self.test_inlier, self.test_outlier = map(
+            normalise, (self.corpus, self.test_inlier, self.test_outlier)
+        )
+
+    def load_ship_movements(self, thres_distance=32000, n_samples=5000):
+        """
+
+        :param thres_distance: Must be one of [4000, 8000, 16000, 32000]
+        :param n_samples: samples taken for each of the train, test_in and test_out
+        :return:
+        """
+
+        # process data in a format where it could be indexed.
+        def process_data(data_frame):
+            data_frame["TimeDiff"] = data_frame["BaseDateTime"].apply(
+                lambda x: np.append(0, np.diff(x))
+            )
+            data_frame = data_frame[["LAT", "LON", "TimeDiff"]]
+            res = []
+            for i in range(len(data_frame)):
+                res.append(
+                    np.array(
+                        list(
+                            zip(
+                                data_frame.iloc[i].to_numpy()[0],
+                                data_frame.iloc[i].to_numpy()[1],
+                                data_frame.iloc[i].to_numpy()[2],
+                            )
+                        )
+                    )
+                )
+            return res
+
+        # subsample data
+        def sample_data(ais_by_vessel_split, random_state):
+            return ais_by_vessel_split.sample(
+                n=n_samples,
+                weights="SUBSTREAM_WEIGHT",
+                replace=True,
+                random_state=random_state,
+            )
+
+        with Path(DATA_DIR + "inlier_mmsis_train.pkl").open("rb") as f:
+            inlier_mmsis_train = pickle.load(f)
+        with Path(DATA_DIR + "inlier_mmsis_test.pkl").open("rb") as f:
+            inlier_mmsis_test = pickle.load(f)
+        with Path(DATA_DIR + "outlier_mmsis.pkl").open("rb") as f:
+            outlier_mmsis = pickle.load(f)
+
+        if thres_distance not in [4000, 8000, 16000, 32000]:
+            msg = "thres_distance needs to be in [4000, 8000, 16000, 32000]"
+            raise ValueError(msg)
+        ais_by_vessel_split_local = pd.read_pickle(
+            DATA_DIR + "substreams_" + str(thres_distance) + ".pkl"
+        )
+
+        self.corpus = process_data(
+            sample_data(
+                ais_by_vessel_split_local.loc[inlier_mmsis_train],
+                random_state=self.random_seed,
+            )
+        )
+        self.test_inlier = process_data(
+            sample_data(
+                ais_by_vessel_split_local.loc[inlier_mmsis_test],
+                random_state=self.random_seed,
+            )
+        )
+        self.test_outlier = process_data(
+            sample_data(
+                ais_by_vessel_split_local.loc[outlier_mmsis],
+                random_state=self.random_seed,
+            )
+        )
+        if self.if_sample:
+            self.sample()
+        self.corpus, self.test_inlier, self.test_outlier = map(
+            normalise, (self.corpus, self.test_inlier, self.test_outlier)
+        )
+
+    def load_ucr_dataset(
+        self, data_set_name="Adiac", anomaly_level=0.001, random_state=1
+    ):
+        """
+
+         :param data_set_name: Must be one of ['Adiac', 'ArrowHead', 'Beef', 'BeetleFly', 'BirdChicken', 'CBF',
+        'ChlorineConcentration', 'Coffee', 'ECG200', 'ECGFiveDays', 'FaceFour',
+        'GunPoint', 'Ham', 'Herring', 'Lightning2', 'Lightning7', 'Meat',
+        'MedicalImages', 'MoteStrain', 'Plane', 'Strawberry', 'Symbols',
+        'ToeSegmentation1', 'ToeSegmentation2', 'Trace', 'TwoLeadECG', 'Wafer',
+        'Wine']
+         :param anomaly_level: Must be one of [0.001, 0.05]
+         :param random_state:
+         :return:
+        """
+        Level_To_COLUMN = {0.001: "Atra", 0.05: "A5tra"}
+        comparisons = pd.read_csv(
+            DATA_DIR + "results_beggel_et_al_2019_tables_2_and_4.csv"
+        )
+        comparisons = comparisons.set_index("Dataset")
+        if data_set_name not in comparisons.index:
+            msg = "data_set_name must be in "
+            raise ValueError(msg, comparisons.index)
+        DATASET_PATH = DATA_DIR + "Univariate_arff"
+        datatrain = arff.loadarff(
+            Path(DATASET_PATH) / data_set_name / (data_set_name + "_TRAIN.arff")
+        )
+        datatest = arff.loadarff(
+            Path(DATASET_PATH) / data_set_name / (data_set_name + "_TEST.arff")
+        )
+        alldata = pd.concat(
+            [pd.DataFrame(datatrain[0]), pd.DataFrame(datatest[0])], ignore_index=True
+        )
+        alldata["target"] = pd.to_numeric(alldata["target"])
+        corpus_paths, outlier_paths = get_corpus_and_outlier_paths(
+            alldata, comparisons.loc[data_set_name].normal
+        )
+        corpus_train, corpus_test = train_test_split(
+            corpus_paths,
+            test_size=comparisons.loc[data_set_name].Ntes.astype("int"),
+            random_state=random_state,
+        )
+        outliers_injection = comparisons.loc[data_set_name][
+            Level_To_COLUMN[anomaly_level]
+        ].astype("int")
+        if outliers_injection != 0:
+            outlier_paths, outlier_paths_to_train = train_test_split(
+                outlier_paths, test_size=outliers_injection, random_state=random_state
+            )
+            corpus_train = (
+                corpus_train + outlier_paths_to_train
+            )  # injecting anomaly into the corpus
+
+        self.corpus = corpus_train
+        self.test_inlier = corpus_test
+        self.test_outlier = outlier_paths
+        if self.if_sample:
+            self.sample()
+        self.corpus, self.test_inlier, self.test_outlier = map(
+            normalise, (self.corpus, self.test_inlier, self.test_outlier)
+        )
diff --git a/paper-examples/UCR_data_support.py b/paper-examples/UCR_data_support.py
new file mode 100644
index 0000000..f9e46e3
--- /dev/null
+++ b/paper-examples/UCR_data_support.py
@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import matplotlib.lines as mlines
+import numpy as np
+import pandas as pd
+
+DATA_DIR = "data/"
+
+
+def compute_best_and_std(
+    data_set,
+    iter,
+    data,
+    signature_maha_knn,
+    depth,
+    n_neighbours,
+    anomaly_level=0.001,
+):
+    tnfn = {}
+    for d in data_set:
+        tnfn[d] = []
+        for random_state in range(iter):
+            # data loading
+            data.load_ucr_dataset(
+                data_set_name=d, random_state=random_state, anomaly_level=anomaly_level
+            )
+            # anomaly detection
+            # Measure the time spent on fit
+            signature_maha_knn.fit(
+                knn_library="sklearn",
+                X_train=data.corpus,
+                signature_kwargs={
+                    "augmentation_list": ("addtime",),
+                    "depth": depth,
+                },
+            )
+
+            # Measure the time spent on conformance
+            inlier_dists = signature_maha_knn.conformance(
+                data.test_inlier, n_neighbors=n_neighbours
+            )
+            outlier_dists = signature_maha_knn.conformance(
+                data.test_outlier, n_neighbors=n_neighbours
+            )
+
+            tnfn[d].append(compute_tn_fn_for_all_thres(inlier_dists, outlier_dists))
+
+    roughpathsbest = []
+    roughpathserror = []
+    for d in data_set:
+        balanced_accuracies = []
+        for tn, fn in tnfn[d]:
+            balanced_accuracies.append(compute_balanced_accuracy(tn, fn))
+        roughpathsbest.append(max(np.median(balanced_accuracies, axis=0)))
+        bestthreshold = np.argmax(np.median(balanced_accuracies, axis=0))
+        roughpathserror.append(
+            np.std(balanced_accuracies, axis=0, ddof=1)[bestthreshold]
+        )
+
+    return roughpathsbest, roughpathserror
+
+
+def plot_ucr_result(roughpathsbest, roughpathserror, anomaly_level, ax_num, axs):
+    # result from beggels 2019
+    comparisons = pd.read_csv(DATA_DIR + "results_beggel_et_al_2019_tables_2_and_4.csv")
+    adslbest = np.maximum(comparisons.ADSL, comparisons.ADSLbest)
+    adslerror = comparisons["ADSL sd"] * (
+        comparisons.ADSLbest < comparisons.ADSL
+    ) + comparisons["ADSLbest sd"] * (comparisons.ADSLbest >= comparisons.ADSL)
+
+    # table
+    comparison_table = pd.DataFrame(
+        np.column_stack(
+            [comparisons.Dataset, roughpathsbest, roughpathserror, adslbest, adslerror]
+        )
+    )
+
+    # plotting
+    fontsize = 15
+    ax = axs.flatten()[ax_num]
+
+    ax.scatter(adslbest, roughpathsbest)
+    ax.set_xlim(0.45, 1.01)
+    ax.set_ylim(0.45, 1.01)
+
+    line = mlines.Line2D([0, 1.01], [0, 1.01], color="black", ls=":")
+    ax.add_line(line)
+    ax.set_xlabel("ADSL: median balanced accuracy", fontsize=fontsize)
+    ax.set_ylabel("Signature variance: best achievable median BA", fontsize=fontsize)
+    ax.set_title(str(anomaly_level) + " training anomaly rate", fontsize=fontsize)
+    ax.tick_params(axis="both", which="major", labelsize=fontsize)
+    ax.tick_params(axis="both", which="minor", labelsize=fontsize)
+    for i in range(len(adslbest)):
+        if comparisons.Dataset[i] in [
+            "Wafer",
+            "ChlorineConcentration",
+            "BeetleFly",
+            "Wine",
+        ]:
+            ax.text(
+                adslbest[i] + 0.01,
+                roughpathsbest[i],
+                comparisons.Dataset[i],
+                fontsize=fontsize,
+            )
+        if comparisons.Dataset[i] in ["FaceFour"]:
+            ax.text(
+                adslbest[i],
+                roughpathsbest[i] + 0.01,
+                comparisons.Dataset[i],
+                fontsize=fontsize,
+            )
+        if comparisons.Dataset[i] in ["ECG200", "BirdChicken"]:
+            ax.text(
+                adslbest[i],
+                roughpathsbest[i] - 0.025,
+                comparisons.Dataset[i],
+                fontsize=fontsize,
+            )
+        if comparisons.Dataset[i] in ["ToeSegmentation1", "ToeSegmentation2"]:
+            ax.text(
+                adslbest[i] + 0.01,
+                roughpathsbest[i] - 0.005,
+                comparisons.Dataset[i][:3] + comparisons.Dataset[i][-1],
+                fontsize=fontsize,
+            )
+
+    return comparison_table
+
+
+def compute_tn_fn_for_all_thres(inlier_dists, outlier_dists):
+    # The below two lines compute the true negatives and false negatives for all possible threshold
+    corpus_variances = list(inlier_dists)
+    outlier_variances = list(outlier_dists)
+    tn = np.concatenate(
+        [
+            [0],
+            np.cumsum(
+                np.array(
+                    [
+                        y
+                        for _, y in sorted(
+                            zip(
+                                corpus_variances + outlier_variances,
+                                [0] * len(corpus_variances)
+                                + [1] * len(outlier_variances),
+                            )
+                        )
+                    ]
+                )
+                == 0
+            ),
+        ]
+    )
+    fn = np.concatenate(
+        [
+            [0],
+            np.cumsum(
+                np.array(
+                    [
+                        y
+                        for _, y in sorted(
+                            zip(
+                                corpus_variances + outlier_variances,
+                                [0] * len(corpus_variances)
+                                + [1] * len(outlier_variances),
+                            )
+                        )
+                    ]
+                )
+                == 1
+            ),
+        ]
+    )
+    return (tn, fn)
+
+
+def compute_balanced_accuracy(tn, fn):
+    # compute balanced accuracy as the average between sensitivity and specificity
+    false_pos = np.flip(max(tn) - tn)
+    true_pos = np.flip(max(fn) - fn)
+    true_neg = max(false_pos) - false_pos
+    false_neg = max(true_pos) - true_pos
+    sens = true_pos / (true_pos + false_neg)
+    spec = true_neg / (true_neg + false_pos)
+    return (sens + spec) / 2
diff --git a/paper-examples/example2.ipynb b/paper-examples/example2.ipynb
new file mode 100644
index 0000000..97a87c8
--- /dev/null
+++ b/paper-examples/example2.ipynb
@@ -0,0 +1,221 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b430e261-33b2-4878-94d6-46e5dbb18c72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import os\n",
+    "\n",
+    "sys.path.insert(0, os.path.join(\"..\", \"..\"))\n",
+    "import random\n",
+    "import time\n",
+    "\n",
+    "import sklearn\n",
+    "import numpy as np\n",
+    "import matplotlib.lines as mlines\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "\n",
+    "import Data\n",
+    "from signature_mahalanobis_knn import SignatureMahalanobisKNN, Mahalanobis\n",
+    "\n",
+    "from signature_mahalanobis_knn.utils import compute_auc_given_dists\n",
+    "import UCR_data_support"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "34fc097e-0eb5-4c0d-9973-4dc8810ec398",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "DATA_DIR = \"./data/\"\n",
+    "# importlib.reload(Data)\n",
+    "# importlib.reload(SigMahaKNN)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "b7a56abc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_neighbours = 50"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1dd07d56-fd79-4918-b9f8-db9190a837d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n",
+    "data.load_pen_digit()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79e05b28",
+   "metadata": {},
+   "source": [
+    "## Can we reproduce distances?\n",
+    "\n",
+    "For depth 4, digit 0:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "a4675b42",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "doing digit 0 doing signature level  4\n",
+      "fit_time: 1.7248878479003906\n"
+     ]
+    }
+   ],
+   "source": [
+    "digit = 0\n",
+    "depth = 4\n",
+    "data.load_pen_digit(digit=digit)\n",
+    "print(\"doing digit\", digit, \"doing signature level \", depth)\n",
+    "signature_maha_knn = SignatureMahalanobisKNN()\n",
+    "# Measure the time spent on fit\n",
+    "start_time = time.time()\n",
+    "signature_maha_knn.fit(\n",
+    "    knn_library=\"sklearn\",\n",
+    "    X_train=data.corpus,\n",
+    "    signature_kwargs={\n",
+    "        \"augmentation_list\": None,\n",
+    "        \"depth\": depth,\n",
+    "    },\n",
+    ")\n",
+    "fit_time = time.time() - start_time\n",
+    "print(f\"fit_time: {fit_time}\")\n",
+    "\n",
+    "inlier_dists, inlier_ix = signature_maha_knn.conformance(\n",
+    "    data.test_inlier, n_neighbors=n_neighbours, return_indices=True\n",
+    ")\n",
+    "outlier_dists, outlier_ix = signature_maha_knn.conformance(\n",
+    "    data.test_outlier, n_neighbors=n_neighbours, return_indices=True\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "index of closest train point to test_point[0] = 342\n",
+      "Reported conformance = 0.03967368329534612\n",
+      "Reported conformance squared = 0.0015740011462194255\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"index of closest train point to test_point[0] =\", inlier_ix[0, 0])\n",
+    "print(\"Reported conformance =\", inlier_dists[0])\n",
+    "print(\"Reported conformance squared =\", inlier_dists[0] ** 2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reported distance = 0.0015739502850919962\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Compute distances as per the old method\n",
+    "test_sig = (\n",
+    "    signature_maha_knn.signature_transform.transform(data.test_inlier[0]).iloc[0].values\n",
+    ")\n",
+    "train_sig = signature_maha_knn.signatures_train[inlier_ix[0, 0]]\n",
+    "dist = signature_maha_knn.mahal_distance.distance(test_sig, train_sig)\n",
+    "print(\"Reported distance =\", dist)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "5.086112742926606e-08"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inlier_dists[0] ** 2 - dist"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6.409984413327519e-07"
+      ]
+     },
+     "execution_count": 42,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inlier_dists[0] - np.sqrt(dist)"
+   ]
+  }
+ ],
+ "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.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/paper-examples/examples.ipynb b/paper-examples/examples.ipynb
new file mode 100644
index 0000000..f587397
--- /dev/null
+++ b/paper-examples/examples.ipynb
@@ -0,0 +1,3225 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b430e261-33b2-4878-94d6-46e5dbb18c72",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "import time\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import Data\n",
+    "from signature_mahalanobis_knn import SignatureMahalanobisKNN\n",
+    "from signature_mahalanobis_knn.utils import (\n",
+    "    compute_auc_given_dists,\n",
+    "    plot_cdf_given_dists,\n",
+    ")\n",
+    "import UCR_data_support"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "seed = 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46aff929-3380-43d7-8949-2df9564af3dc",
+   "metadata": {},
+   "source": [
+    "### Pen digit data example; Reproduce the result."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "b7a56abc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_neighbours = 100"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1dd07d56-fd79-4918-b9f8-db9190a837d9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n",
+    "data = Data.Data(if_sample=False, random_seed=seed)\n",
+    "data.load_pen_digit()\n",
+    "\n",
+    "depths = [1, 2, 3, 4, 5]\n",
+    "digits = range(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "a9b82cb0-4754-409c-891b-b19ec7e9b1a3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "doing digit 0 doing signature level  1\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 363\n",
+      "len(data.test_outlier) 3135\n",
+      "fit_time: 9.688912153244019\n",
+      "compute_auc_time: 10.269761800765991\n",
+      "depth:  1 , Auc of  digit:  0  is  0.9236207222288126\n",
+      "doing digit 1 doing signature level  1\n",
+      "len(data.corpus) 779\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.2819938659667969\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 6.245326042175293\n",
+      "depth:  1 , Auc of  digit:  1  is  0.8300113256239612\n",
+      "doing digit 2 doing signature level  1\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.3130040168762207\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 6.352444171905518\n",
+      "depth:  1 , Auc of  digit:  2  is  0.9320072476980582\n",
+      "doing digit 3 doing signature level  1\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.315458059310913\n",
+      "compute_auc_time: 6.223802804946899\n",
+      "depth:  1 , Auc of  digit:  3  is  0.922022303545074\n",
+      "doing digit 4 doing signature level  1\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.4521958827972412\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 6.100835084915161\n",
+      "depth:  1 , Auc of  digit:  4  is  0.9830396151391684\n",
+      "doing digit 5 doing signature level  1\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 335\n",
+      "len(data.test_outlier) 3163\n",
+      "fit_time: 1.3075149059295654\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 6.035906076431274\n",
+      "depth:  1 , Auc of  digit:  5  is  0.9057290216637331\n",
+      "doing digit 6 doing signature level  1\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.3131701946258545\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 6.04359769821167\n",
+      "depth:  1 , Auc of  digit:  6  is  0.8962102986355833\n",
+      "doing digit 7 doing signature level  1\n",
+      "len(data.corpus) 778\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.364300012588501\n",
+      "compute_auc_time: 6.059554100036621\n",
+      "depth:  1 , Auc of  digit:  7  is  0.8957924255068479\n",
+      "doing digit 8 doing signature level  1\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.1893792152404785\n",
+      "compute_auc_time: 6.056625843048096\n",
+      "depth:  1 , Auc of  digit:  8  is  0.9399820412035783\n",
+      "doing digit 9 doing signature level  1\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.2779922485351562\n",
+      "compute_auc_time: 6.125757932662964\n",
+      "depth:  1 , Auc of  digit:  9  is  0.8178161049365983\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overall,  depth:  1 AUC:  0.9011941225982674\n",
+      "doing digit 0 doing signature level  2\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 363\n",
+      "len(data.test_outlier) 3135\n",
+      "fit_time: 1.3745968341827393\n",
+      "compute_auc_time: 6.313787221908569\n",
+      "depth:  2 , Auc of  digit:  0  is  0.9994156440437432\n",
+      "doing digit 1 doing signature level  2\n",
+      "len(data.corpus) 779\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.3893768787384033\n",
+      "compute_auc_time: 6.167309761047363\n",
+      "depth:  2 , Auc of  digit:  1  is  0.882206498032918\n",
+      "doing digit 2 doing signature level  2\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.3798871040344238\n",
+      "compute_auc_time: 6.319882392883301\n",
+      "depth:  2 , Auc of  digit:  2  is  0.9511227445177669\n",
+      "doing digit 3 doing signature level  2\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.27274489402771\n",
+      "compute_auc_time: 6.294939994812012\n",
+      "depth:  2 , Auc of  digit:  3  is  0.9886656275413391\n",
+      "doing digit 4 doing signature level  2\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.3157386779785156\n",
+      "compute_auc_time: 6.4051289558410645\n",
+      "depth:  2 , Auc of  digit:  4  is  0.9971212578104729\n",
+      "doing digit 5 doing signature level  2\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 335\n",
+      "len(data.test_outlier) 3163\n",
+      "fit_time: 1.2873790264129639\n",
+      "compute_auc_time: 6.221255779266357\n",
+      "depth:  2 , Auc of  digit:  5  is  0.9647887656249261\n",
+      "doing digit 6 doing signature level  2\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.2547879219055176\n",
+      "compute_auc_time: 6.341688871383667\n",
+      "depth:  2 , Auc of  digit:  6  is  0.9924061022258366\n",
+      "doing digit 7 doing signature level  2\n",
+      "len(data.corpus) 778\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.333056926727295\n",
+      "compute_auc_time: 6.299951076507568\n",
+      "depth:  2 , Auc of  digit:  7  is  0.9607328695554606\n",
+      "doing digit 8 doing signature level  2\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.288444995880127\n",
+      "compute_auc_time: 6.317756175994873\n",
+      "depth:  2 , Auc of  digit:  8  is  0.9951771030993043\n",
+      "doing digit 9 doing signature level  2\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.2493579387664795\n",
+      "compute_auc_time: 6.216753244400024\n",
+      "depth:  2 , Auc of  digit:  9  is  0.8993403813138158\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overall,  depth:  2 AUC:  0.964656389818477\n",
+      "doing digit 0 doing signature level  3\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 363\n",
+      "len(data.test_outlier) 3135\n",
+      "fit_time: 1.4438748359680176\n",
+      "compute_auc_time: 6.563769817352295\n",
+      "depth:  3 , Auc of  digit:  0  is  0.9978321712119015\n",
+      "doing digit 1 doing signature level  3\n",
+      "len(data.corpus) 779\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.415640115737915\n",
+      "compute_auc_time: 6.474632024765015\n",
+      "depth:  3 , Auc of  digit:  1  is  0.970122092330133\n",
+      "doing digit 2 doing signature level  3\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.3865909576416016\n",
+      "compute_auc_time: 6.617231845855713\n",
+      "depth:  3 , Auc of  digit:  2  is  0.9907229815494015\n",
+      "doing digit 3 doing signature level  3\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.4027378559112549\n",
+      "compute_auc_time: 6.600866794586182\n",
+      "depth:  3 , Auc of  digit:  3  is  0.9952787566639559\n",
+      "doing digit 4 doing signature level  3\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.4259991645812988\n",
+      "compute_auc_time: 6.604549884796143\n",
+      "depth:  3 , Auc of  digit:  4  is  0.9998316935138888\n",
+      "doing digit 5 doing signature level  3\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 335\n",
+      "len(data.test_outlier) 3163\n",
+      "fit_time: 1.4912703037261963\n",
+      "compute_auc_time: 6.5209479331970215\n",
+      "depth:  3 , Auc of  digit:  5  is  0.9819583712798636\n",
+      "doing digit 6 doing signature level  3\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.4395511150360107\n",
+      "compute_auc_time: 6.649335145950317\n",
+      "depth:  3 , Auc of  digit:  6  is  0.9945587105810065\n",
+      "doing digit 7 doing signature level  3\n",
+      "len(data.corpus) 778\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.3501660823822021\n",
+      "compute_auc_time: 6.567941904067993\n",
+      "depth:  3 , Auc of  digit:  7  is  0.9778264970511301\n",
+      "doing digit 8 doing signature level  3\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.467175006866455\n",
+      "compute_auc_time: 6.605494022369385\n",
+      "depth:  3 , Auc of  digit:  8  is  0.9984290759314479\n",
+      "doing digit 9 doing signature level  3\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.4061648845672607\n",
+      "compute_auc_time: 6.380589962005615\n",
+      "depth:  3 , Auc of  digit:  9  is  0.9264809418391013\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overall,  depth:  3 AUC:  0.9833291162703119\n",
+      "doing digit 0 doing signature level  4\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 363\n",
+      "len(data.test_outlier) 3135\n",
+      "fit_time: 1.4975659847259521\n",
+      "compute_auc_time: 6.91232705116272\n",
+      "depth:  4 , Auc of  digit:  0  is  0.9949666301993401\n",
+      "doing digit 1 doing signature level  4\n",
+      "len(data.corpus) 779\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.502849817276001\n",
+      "compute_auc_time: 6.871154069900513\n",
+      "depth:  4 , Auc of  digit:  1  is  0.9852398718065597\n",
+      "doing digit 2 doing signature level  4\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.708885908126831\n",
+      "compute_auc_time: 7.093451976776123\n",
+      "depth:  4 , Auc of  digit:  2  is  0.9894510403444672\n",
+      "doing digit 3 doing signature level  4\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.5545158386230469\n",
+      "compute_auc_time: 7.326997995376587\n",
+      "depth:  4 , Auc of  digit:  3  is  0.9959752718291617\n",
+      "doing digit 4 doing signature level  4\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.5915489196777344\n",
+      "compute_auc_time: 7.074462890625\n",
+      "depth:  4 , Auc of  digit:  4  is  0.999876399924262\n",
+      "doing digit 5 doing signature level  4\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 335\n",
+      "len(data.test_outlier) 3163\n",
+      "fit_time: 1.531661033630371\n",
+      "compute_auc_time: 6.867708921432495\n",
+      "depth:  4 , Auc of  digit:  5  is  0.9878785018945739\n",
+      "doing digit 6 doing signature level  4\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.3417651653289795\n",
+      "compute_auc_time: 6.920623779296875\n",
+      "depth:  4 , Auc of  digit:  6  is  0.9949408526851601\n",
+      "doing digit 7 doing signature level  4\n",
+      "len(data.corpus) 778\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.7207341194152832\n",
+      "compute_auc_time: 6.845315933227539\n",
+      "depth:  4 , Auc of  digit:  7  is  0.9857894976752666\n",
+      "doing digit 8 doing signature level  4\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.491410255432129\n",
+      "compute_auc_time: 6.841398000717163\n",
+      "depth:  4 , Auc of  digit:  8  is  0.998694504683594\n",
+      "doing digit 9 doing signature level  4\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.2827157974243164\n",
+      "compute_auc_time: 6.803714990615845\n",
+      "depth:  4 , Auc of  digit:  9  is  0.9442176063973977\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overall,  depth:  4 AUC:  0.9873373465898034\n",
+      "doing digit 0 doing signature level  5\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 363\n",
+      "len(data.test_outlier) 3135\n",
+      "fit_time: 2.2053072452545166\n",
+      "compute_auc_time: 17.268661975860596\n",
+      "depth:  5 , Auc of  digit:  0  is  0.9947574922781535\n",
+      "doing digit 1 doing signature level  5\n",
+      "len(data.corpus) 779\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 2.007657766342163\n",
+      "compute_auc_time: 22.80258798599243\n",
+      "depth:  5 , Auc of  digit:  1  is  0.9900453726235474\n",
+      "doing digit 2 doing signature level  5\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.6560781002044678\n",
+      "compute_auc_time: 15.648115873336792\n",
+      "depth:  5 , Auc of  digit:  2  is  0.9912226414300441\n",
+      "doing digit 3 doing signature level  5\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.6908342838287354\n",
+      "compute_auc_time: 12.489221096038818\n",
+      "depth:  5 , Auc of  digit:  3  is  0.9964675386283546\n",
+      "doing digit 4 doing signature level  5\n",
+      "len(data.corpus) 780\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.6653599739074707\n",
+      "compute_auc_time: 14.69511604309082\n",
+      "depth:  5 , Auc of  digit:  4  is  0.9999254893160445\n",
+      "doing digit 5 doing signature level  5\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 335\n",
+      "len(data.test_outlier) 3163\n",
+      "fit_time: 1.873572826385498\n",
+      "compute_auc_time: 13.695110082626343\n",
+      "depth:  5 , Auc of  digit:  5  is  0.9896433104789049\n",
+      "doing digit 6 doing signature level  5\n",
+      "len(data.corpus) 720\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.7203340530395508\n",
+      "compute_auc_time: 15.188550233840942\n",
+      "depth:  5 , Auc of  digit:  6  is  0.9954961823439054\n",
+      "doing digit 7 doing signature level  5\n",
+      "len(data.corpus) 778\n",
+      "len(data.test_inlier) 364\n",
+      "len(data.test_outlier) 3134\n",
+      "fit_time: 1.8180418014526367\n",
+      "compute_auc_time: 14.598641157150269\n",
+      "depth:  5 , Auc of  digit:  7  is  0.9868265110766707\n",
+      "doing digit 8 doing signature level  5\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 1.985002040863037\n",
+      "compute_auc_time: 23.181287050247192\n",
+      "depth:  5 , Auc of  digit:  8  is  0.9993119559651817\n",
+      "doing digit 9 doing signature level  5\n",
+      "len(data.corpus) 719\n",
+      "len(data.test_inlier) 336\n",
+      "len(data.test_outlier) 3162\n",
+      "fit_time: 2.2729718685150146\n",
+      "compute_auc_time: 23.99567413330078\n",
+      "depth:  5 , Auc of  digit:  9  is  0.9467071774946538\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overall,  depth:  5 AUC:  0.9887056355253816\n",
+      "CPU times: user 21min 50s, sys: 4min 16s, total: 26min 7s\n",
+      "Wall time: 9min 11s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "depth_to_auc = {}\n",
+    "\n",
+    "for depth in depths:\n",
+    "    digit_to_inlier_dists = {}\n",
+    "    digit_to_outlier_dists = {}\n",
+    "\n",
+    "    for digit in digits:\n",
+    "        data.load_pen_digit(digit=digit)\n",
+    "        print(\"doing digit\", digit, \"doing signature level \", depth)\n",
+    "        print(\"len(data.corpus)\", len(data.corpus))\n",
+    "        print(\"len(data.test_inlier)\", len(data.test_inlier))\n",
+    "        print(\"len(data.test_outlier)\", len(data.test_outlier))\n",
+    "        signature_maha_knn = SignatureMahalanobisKNN(random_state=seed)\n",
+    "        # Measure the time spent on fit\n",
+    "        start_time = time.time()\n",
+    "        signature_maha_knn.fit(\n",
+    "            knn_library=\"pynndescent\",\n",
+    "            X_train=data.corpus,\n",
+    "            signature_kwargs={\n",
+    "                \"augmentation_list\": None,\n",
+    "                \"depth\": depth,\n",
+    "            },\n",
+    "        )\n",
+    "        fit_time = time.time() - start_time\n",
+    "        print(f\"fit_time: {fit_time}\")\n",
+    "\n",
+    "        # Measure the time spent on conformance\n",
+    "        start_time = time.time()\n",
+    "        inlier_dists = signature_maha_knn.conformance(\n",
+    "            data.test_inlier, n_neighbors=n_neighbours\n",
+    "        )\n",
+    "        outlier_dists = signature_maha_knn.conformance(\n",
+    "            data.test_outlier, n_neighbors=n_neighbours\n",
+    "        )\n",
+    "        compute_auc_time = time.time() - start_time\n",
+    "        print(f\"compute_auc_time: {compute_auc_time}\")\n",
+    "\n",
+    "        digit_to_inlier_dists[digit] = inlier_dists\n",
+    "        digit_to_outlier_dists[digit] = outlier_dists\n",
+    "\n",
+    "        auc = compute_auc_given_dists(inlier_dists, outlier_dists)\n",
+    "        print(\"depth: \", depth, \", Auc of\", \" digit: \", digit, \" is \", auc)\n",
+    "\n",
+    "    # plot and compute auc\n",
+    "    all_inlier_dists = np.concatenate(list(digit_to_inlier_dists.values()))\n",
+    "    all_outlier_dists = np.concatenate(list(digit_to_outlier_dists.values()))\n",
+    "    auc = compute_auc_given_dists(\n",
+    "        all_inlier_dists,\n",
+    "        all_outlier_dists,\n",
+    "        plot=True,\n",
+    "        title=f\"Pen Digit (depth={depth})\",\n",
+    "    )\n",
+    "\n",
+    "    # plot CDF\n",
+    "    plot_cdf_given_dists(\n",
+    "        all_inlier_dists,\n",
+    "        all_outlier_dists,\n",
+    "        bins=10000000,\n",
+    "        xrange=(10e-7, 10e4),\n",
+    "        xlog=True,\n",
+    "        title=f\"\",\n",
+    "    )\n",
+    "\n",
+    "    print(\"Overall, \", \"depth: \", depth, \"AUC: \", auc)\n",
+    "    depth_to_auc[depth] = auc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{1: 0.9011941225982674, 2: 0.964656389818477, 3: 0.9833291162703119, 4: 0.9873373465898034, 5: 0.9887056355253816}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(depth_to_auc)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "79e05b28",
+   "metadata": {},
+   "source": [
+    "## Can we reproduce distances?\n",
+    "\n",
+    "For depth 2, digit 0, no augmentation_list:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = Data.Data(n_samples=(800, 30, 30), if_sample=True)\n",
+    "data.load_pen_digit()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a4675b42",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "doing digit 0 doing signature level  2\n",
+      "fit_time: 1.8049709796905518\n"
+     ]
+    }
+   ],
+   "source": [
+    "digit = 0\n",
+    "depth = 2\n",
+    "data.load_pen_digit(digit=digit)\n",
+    "print(\"doing digit\", digit, \"doing signature level \", depth)\n",
+    "signature_maha_knn = SignatureMahalanobisKNN()\n",
+    "# Measure the time spent on fit\n",
+    "start_time = time.time()\n",
+    "signature_maha_knn.fit(\n",
+    "    knn_library=\"sklearn\",\n",
+    "    X_train=data.corpus,\n",
+    "    signature_kwargs={},\n",
+    ")\n",
+    "fit_time = time.time() - start_time\n",
+    "print(f\"fit_time: {fit_time}\")\n",
+    "\n",
+    "inlier_dists = signature_maha_knn.conformance(\n",
+    "    data.test_inlier, n_neighbors=n_neighbours\n",
+    ")\n",
+    "outlier_dists = signature_maha_knn.conformance(\n",
+    "    data.test_outlier, n_neighbors=n_neighbours\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Inlier dists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "fa3d0039-5d50-4aa8-ac91-f76a83513315",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.02203349, 0.02636506, 0.01619603, 0.01555797, 0.11322956,\n",
+       "       0.03182318, 0.02529738, 0.09760276, 0.01769069, 0.0184093 ,\n",
+       "       0.03047298, 0.01305365, 0.02557788, 0.07339484, 0.01822537,\n",
+       "       0.07480418, 0.02407774, 0.17452867, 0.03732281, 0.10320762,\n",
+       "       0.01851509, 0.01398619, 0.01354816, 0.01247237, 0.02372335,\n",
+       "       0.01140402, 0.02230901, 0.04476067, 0.0622557 , 0.02477818])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inlier_dists"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Should be \n",
+    "array([[0.00048547],\n",
+    "       [0.00069512],\n",
+    "       [0.00026231],\n",
+    "       [0.00024205],\n",
+    "       [0.01478617],\n",
+    "       [0.00101271],\n",
+    "       [0.00063996],\n",
+    "       [0.01085489],\n",
+    "       [0.00031296],\n",
+    "       [0.0003389 ],\n",
+    "       [0.0009286 ],\n",
+    "       [0.0001704 ],\n",
+    "       [0.00065423],\n",
+    "       [0.0053868 ],\n",
+    "       [0.00033216],\n",
+    "       [0.00559567],\n",
+    "       [0.00057974],\n",
+    "       [0.03442473],\n",
+    "       [0.00139299],\n",
+    "       [0.01456522],\n",
+    "       [0.00034281],\n",
+    "       [0.00019561],\n",
+    "       [0.00018355],\n",
+    "       [0.00015556],\n",
+    "       [0.0005628 ],\n",
+    "       [0.00013005],\n",
+    "       [0.00049769],\n",
+    "       [0.00200352],\n",
+    "       [0.00387577],\n",
+    "       [0.00061396]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "previous_output = np.array(\n",
+    "    [\n",
+    "        [0.00048547],\n",
+    "        [0.00069512],\n",
+    "        [0.00026231],\n",
+    "        [0.00024205],\n",
+    "        [0.01478617],\n",
+    "        [0.00101271],\n",
+    "        [0.00063996],\n",
+    "        [0.01085489],\n",
+    "        [0.00031296],\n",
+    "        [0.0003389],\n",
+    "        [0.0009286],\n",
+    "        [0.0001704],\n",
+    "        [0.00065423],\n",
+    "        [0.0053868],\n",
+    "        [0.00033216],\n",
+    "        [0.00559567],\n",
+    "        [0.00057974],\n",
+    "        [0.03442473],\n",
+    "        [0.00139299],\n",
+    "        [0.01456522],\n",
+    "        [0.00034281],\n",
+    "        [0.00019561],\n",
+    "        [0.00018355],\n",
+    "        [0.00015556],\n",
+    "        [0.0005628],\n",
+    "        [0.00013005],\n",
+    "        [0.00049769],\n",
+    "        [0.00200352],\n",
+    "        [0.00387577],\n",
+    "        [0.00061396],\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.02203338, 0.02636513, 0.01619599, 0.01555796, 0.1215984 ,\n",
+       "       0.0318231 , 0.02529743, 0.1041868 , 0.01769068, 0.01840924,\n",
+       "       0.03047294, 0.01305374, 0.02557792, 0.07339482, 0.01822526,\n",
+       "       0.07480421, 0.02407779, 0.18553903, 0.03732278, 0.12068645,\n",
+       "       0.01851513, 0.01398606, 0.01354806, 0.01247237, 0.02372341,\n",
+       "       0.01140395, 0.02230897, 0.0447607 , 0.06225568, 0.02477822])"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(previous_output).reshape(30)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "square root the expected distance array and compare to what we get:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([-1.02698604e-07,  7.06201024e-08, -4.48023166e-08, -1.52162402e-08,\n",
+       "        8.36883323e-03, -7.46429760e-08,  5.43689659e-08,  6.58404394e-03,\n",
+       "       -1.29966361e-08, -6.40953989e-08, -3.90337506e-08,  8.24570676e-08,\n",
+       "        4.13584945e-08, -1.25793449e-08, -1.17102862e-07,  2.81579632e-08,\n",
+       "        4.75885919e-08,  1.10103507e-02, -3.11002757e-08,  1.74788333e-02,\n",
+       "        3.86669326e-08, -1.21665173e-07, -1.00438225e-07,  3.97413871e-09,\n",
+       "        5.21471378e-08, -6.93480474e-08, -4.72183132e-08,  2.90194190e-08,\n",
+       "       -2.10565009e-08,  4.07364884e-08])"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(previous_output).reshape(30) - inlier_dists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([-4.52560604e-09,  3.72381116e-09, -1.45123750e-09, -4.73467427e-10,\n",
+       "        1.96523603e-03, -4.75074807e-09,  2.75078734e-09,  1.32859135e-03,\n",
+       "       -4.59838713e-10, -2.35989886e-09, -2.37894771e-09,  2.15273864e-09,\n",
+       "        2.11572683e-09, -1.84651773e-09, -4.26847328e-09,  4.21266765e-09,\n",
+       "        2.29165403e-09,  3.96447167e-03, -2.32149854e-09,  3.91340718e-03,\n",
+       "        1.43184499e-09, -3.40324873e-09, -2.72149679e-09,  9.91338369e-11,\n",
+       "        2.47421274e-09, -1.58168768e-09, -2.10678580e-09,  2.59785800e-09,\n",
+       "       -2.62177412e-09,  2.01875338e-09])"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "previous_output.reshape(30) - (inlier_dists**2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.00048547, 0.00069512, 0.00026231, 0.00024205, 0.01282093,\n",
+       "       0.00101271, 0.00063996, 0.0095263 , 0.00031296, 0.0003389 ,\n",
+       "       0.0009286 , 0.0001704 , 0.00065423, 0.0053868 , 0.00033216,\n",
+       "       0.00559567, 0.00057974, 0.03046026, 0.00139299, 0.01065181,\n",
+       "       0.00034281, 0.00019561, 0.00018355, 0.00015556, 0.0005628 ,\n",
+       "       0.00013005, 0.00049769, 0.00200352, 0.00387577, 0.00061396])"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inlier_dists**2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Outlier dists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "7b24a162-ab61-42ec-92d0-31067441e1ea",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.67234357, 0.24378294, 0.12239674, 0.2594328 , 0.24765937,\n",
+       "       0.12541939, 0.21369961, 0.20740823, 0.70915457, 0.71401431,\n",
+       "       0.23341582, 0.55010934, 0.18330298, 0.28309617, 0.24274554,\n",
+       "       0.27733141, 0.74215369, 0.43625734, 0.62571779, 0.26774461,\n",
+       "       0.22821211, 0.70655548, 0.45673413, 0.43718576, 0.09406633,\n",
+       "       0.17178055, 0.2021866 , 0.50789138, 0.46324354, 0.2810891 ])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "outlier_dists"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Should be\n",
+    "array([[0.51469102],\n",
+    "       [0.05943012],\n",
+    "       [0.01498096],\n",
+    "       [0.06730538],\n",
+    "       [0.06133516],\n",
+    "       [0.01573002],\n",
+    "       [0.04566752],\n",
+    "       [0.04301818],\n",
+    "       [0.5029002 ],\n",
+    "       [0.56088974],\n",
+    "       [0.05448295],\n",
+    "       [0.39831413],\n",
+    "       [0.03359998],\n",
+    "       [0.08014344],\n",
+    "       [0.05892539],\n",
+    "       [0.07691271],\n",
+    "       [0.67933435],\n",
+    "       [0.20881273],\n",
+    "       [0.42321369],\n",
+    "       [0.07168717],\n",
+    "       [0.05208077],\n",
+    "       [0.51004513],\n",
+    "       [0.29315337],\n",
+    "       [0.21727576],\n",
+    "       [0.00884847],\n",
+    "       [0.02950856],\n",
+    "       [0.04087942],\n",
+    "       [0.33563053],\n",
+    "       [0.26939553],\n",
+    "       [0.07901108]])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "square root the expected distance array and compare to what we get:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "previous_output = np.array(\n",
+    "    [\n",
+    "        [0.51469102],\n",
+    "        [0.05943012],\n",
+    "        [0.01498096],\n",
+    "        [0.06730538],\n",
+    "        [0.06133516],\n",
+    "        [0.01573002],\n",
+    "        [0.04566752],\n",
+    "        [0.04301818],\n",
+    "        [0.5029002],\n",
+    "        [0.56088974],\n",
+    "        [0.05448295],\n",
+    "        [0.39831413],\n",
+    "        [0.03359998],\n",
+    "        [0.08014344],\n",
+    "        [0.05892539],\n",
+    "        [0.07691271],\n",
+    "        [0.67933435],\n",
+    "        [0.20881273],\n",
+    "        [0.42321369],\n",
+    "        [0.07168717],\n",
+    "        [0.05208077],\n",
+    "        [0.51004513],\n",
+    "        [0.29315337],\n",
+    "        [0.21727576],\n",
+    "        [0.00884847],\n",
+    "        [0.02950856],\n",
+    "        [0.04087942],\n",
+    "        [0.33563053],\n",
+    "        [0.26939553],\n",
+    "        [0.07901108],\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.7174197 , 0.24378294, 0.12239673, 0.2594328 , 0.24765936,\n",
+       "       0.12541938, 0.2136996 , 0.20740824, 0.70915457, 0.74892572,\n",
+       "       0.23341583, 0.63112133, 0.18330297, 0.28309617, 0.24274553,\n",
+       "       0.27733141, 0.82421742, 0.45696032, 0.65054876, 0.2677446 ,\n",
+       "       0.22821212, 0.71417444, 0.5414364 , 0.46612848, 0.09406631,\n",
+       "       0.17178056, 0.2021866 , 0.57933628, 0.51903326, 0.2810891 ])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(previous_output).reshape(30)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 4.50761275e-02, -6.08927639e-09, -7.72790068e-09, -5.17113019e-10,\n",
+       "       -9.18373180e-09, -9.48045786e-09, -4.75888406e-09,  1.14024833e-08,\n",
+       "        1.77743376e-10,  3.49114167e-02,  8.53382895e-09,  8.10119833e-02,\n",
+       "       -4.34167857e-09, -5.11723497e-10, -1.01032923e-08,  2.49688659e-10,\n",
+       "        8.20637253e-02,  2.07029803e-02,  2.48309681e-02, -8.65450989e-09,\n",
+       "        4.68641612e-09,  7.61895942e-03,  8.47022696e-02,  2.89427237e-02,\n",
+       "       -2.48877985e-08,  6.82265699e-09,  5.94662181e-10,  7.14449057e-02,\n",
+       "        5.57897246e-02, -7.37194078e-09])"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(previous_output).reshape(30) - outlier_dists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 6.26451461e-02, -2.96892338e-09, -1.89173964e-09, -2.68312150e-10,\n",
+       "       -4.54887442e-09, -2.37806632e-09, -2.03394328e-09,  4.72993795e-09,\n",
+       "        2.52095012e-10,  5.10733090e-02,  3.98386147e-09,  9.56938395e-02,\n",
+       "       -1.59168519e-09, -2.89733917e-10, -4.90505807e-09,  1.38493023e-10,\n",
+       "        1.28542248e-01,  1.84922675e-02,  3.16909341e-02, -4.63439662e-09,\n",
+       "        2.13899385e-09,  1.08244836e-02,  8.45473085e-02,  2.61443743e-02,\n",
+       "       -4.68220719e-09,  2.34399960e-09,  2.40465446e-10,  7.76768778e-02,\n",
+       "        5.48009524e-02, -4.14434438e-09])"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "previous_output.reshape(30) - (outlier_dists**2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.45204587, 0.05943012, 0.01498096, 0.06730538, 0.06133516,\n",
+       "       0.01573002, 0.04566752, 0.04301818, 0.5029002 , 0.50981643,\n",
+       "       0.05448295, 0.30262029, 0.03359998, 0.08014344, 0.05892539,\n",
+       "       0.07691271, 0.5507921 , 0.19032046, 0.39152276, 0.07168717,\n",
+       "       0.05208077, 0.49922065, 0.20860606, 0.19113139, 0.00884847,\n",
+       "       0.02950856, 0.04087942, 0.25795365, 0.21459458, 0.07901108])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "outlier_dists**2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Can we reproduce distances?\n",
+    "\n",
+    "For depth 4, digit 0, with augmentation_list=None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "doing digit 0 doing signature level  4\n",
+      "fit_time: 1.5386781692504883\n"
+     ]
+    }
+   ],
+   "source": [
+    "digit = 0\n",
+    "depth = 4\n",
+    "data.load_pen_digit(digit=digit)\n",
+    "print(\"doing digit\", digit, \"doing signature level \", depth)\n",
+    "signature_maha_knn = SignatureMahalanobisKNN()\n",
+    "# Measure the time spent on fit\n",
+    "start_time = time.time()\n",
+    "signature_maha_knn.fit(\n",
+    "    knn_library=\"sklearn\",\n",
+    "    X_train=data.corpus,\n",
+    "    signature_kwargs={\n",
+    "        \"augmentation_list\": None,\n",
+    "        \"depth\": depth,\n",
+    "    },\n",
+    ")\n",
+    "fit_time = time.time() - start_time\n",
+    "print(f\"fit_time: {fit_time}\")\n",
+    "\n",
+    "inlier_dists = signature_maha_knn.conformance(\n",
+    "    data.test_inlier, n_neighbors=n_neighbours\n",
+    ")\n",
+    "outlier_dists = signature_maha_knn.conformance(\n",
+    "    data.test_outlier, n_neighbors=n_neighbours\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Inlier dists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.03967367, 0.05504537, 0.03504562, 0.02803288, 0.79020931,\n",
+       "       0.09154714, 0.03940437, 0.60588313, 0.05382932, 0.0664232 ,\n",
+       "       0.07546581, 0.04712501, 0.05999963, 0.27495292, 0.04513797,\n",
+       "       0.39363584, 0.08103539, 1.12660827, 0.13128929, 0.72245765,\n",
+       "       0.06584397, 0.0319688 , 0.02719407, 0.06510798, 0.05253445,\n",
+       "       0.03191909, 0.04620362, 0.10642687, 0.21951508, 0.04757213])"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inlier_dists"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Should be \n",
+    "array([[1.57399406e-03],\n",
+    "       [3.02998419e-03],\n",
+    "       [1.22819305e-03],\n",
+    "       [7.85843469e-04],\n",
+    "       [6.24430478e-01],\n",
+    "       [8.38084612e-03],\n",
+    "       [1.55270391e-03],\n",
+    "       [3.67094040e-01],\n",
+    "       [2.89758784e-03],\n",
+    "       [4.41202335e-03],\n",
+    "       [5.69510600e-03],\n",
+    "       [2.22076988e-03],\n",
+    "       [3.59995430e-03],\n",
+    "       [7.55992085e-02],\n",
+    "       [2.03744438e-03],\n",
+    "       [1.54949293e-01],\n",
+    "       [6.56671124e-03],\n",
+    "       [1.26924562e+00],\n",
+    "       [1.72368567e-02],\n",
+    "       [5.21945238e-01],\n",
+    "       [4.33543418e-03],\n",
+    "       [1.02200045e-03],\n",
+    "       [7.39515584e-04],\n",
+    "       [4.23905114e-03],\n",
+    "       [2.75986036e-03],\n",
+    "       [1.01882860e-03],\n",
+    "       [2.13477737e-03],\n",
+    "       [1.13266921e-02],\n",
+    "       [4.81867641e-02],\n",
+    "       [2.26310734e-03]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "previous_output = np.array(\n",
+    "    [\n",
+    "        [1.57399406e-03],\n",
+    "        [3.02998419e-03],\n",
+    "        [1.22819305e-03],\n",
+    "        [7.85843469e-04],\n",
+    "        [6.24430478e-01],\n",
+    "        [8.38084612e-03],\n",
+    "        [1.55270391e-03],\n",
+    "        [3.67094040e-01],\n",
+    "        [2.89758784e-03],\n",
+    "        [4.41202335e-03],\n",
+    "        [5.69510600e-03],\n",
+    "        [2.22076988e-03],\n",
+    "        [3.59995430e-03],\n",
+    "        [7.55992085e-02],\n",
+    "        [2.03744438e-03],\n",
+    "        [1.54949293e-01],\n",
+    "        [6.56671124e-03],\n",
+    "        [1.26924562e00],\n",
+    "        [1.72368567e-02],\n",
+    "        [5.21945238e-01],\n",
+    "        [4.33543418e-03],\n",
+    "        [1.02200045e-03],\n",
+    "        [7.39515584e-04],\n",
+    "        [4.23905114e-03],\n",
+    "        [2.75986036e-03],\n",
+    "        [1.01882860e-03],\n",
+    "        [2.13477737e-03],\n",
+    "        [1.13266921e-02],\n",
+    "        [4.81867641e-02],\n",
+    "        [2.26310734e-03],\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.03967359, 0.05504529, 0.03504559, 0.0280329 , 0.79020914,\n",
+       "       0.09154696, 0.03940436, 0.60588286, 0.05382925, 0.06642306,\n",
+       "       0.07546593, 0.04712505, 0.05999962, 0.2749531 , 0.04513806,\n",
+       "       0.39363599, 0.08103525, 1.12660802, 0.13128921, 0.72245778,\n",
+       "       0.06584401, 0.03196874, 0.02719404, 0.065108  , 0.05253437,\n",
+       "       0.03191909, 0.04620365, 0.10642693, 0.21951484, 0.04757213])"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(previous_output).reshape(30)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "square root the expected distance array and compare to what we get:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([-7.68822677e-08, -7.29154133e-08, -3.01010823e-08,  2.25582237e-08,\n",
+       "       -1.75527447e-07, -1.74475403e-07, -1.03651831e-08, -2.69768624e-07,\n",
+       "       -7.08082831e-08, -1.33603602e-07,  1.14141816e-07,  3.97771448e-08,\n",
+       "       -1.01507058e-08,  1.83509061e-07,  8.58520603e-08,  1.46178658e-07,\n",
+       "       -1.38500575e-07, -2.50542729e-07, -7.64500813e-08,  1.26416519e-07,\n",
+       "        4.15011214e-08, -5.37298039e-08, -3.83827406e-08,  1.13304001e-08,\n",
+       "       -7.41194778e-08,  2.26507350e-09,  3.39079999e-08,  6.54568523e-08,\n",
+       "       -2.45914014e-07, -4.55573797e-09])"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(previous_output).reshape(30) - inlier_dists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([-6.10039766e-09, -8.02730577e-09, -2.10982100e-09,  1.26474434e-09,\n",
+       "       -2.77406814e-07, -3.19454164e-08, -8.16867004e-10, -3.26896443e-07,\n",
+       "       -7.62311814e-09, -1.77487390e-08,  1.72276227e-08,  3.74899791e-09,\n",
+       "       -1.21807706e-09,  1.00912738e-07,  7.75038337e-09,  1.15082340e-07,\n",
+       "       -2.24468758e-08, -5.64526956e-07, -2.00741474e-08,  1.82661179e-07,\n",
+       "        5.46519911e-09, -3.43535134e-09, -2.08756472e-09,  1.47539916e-09,\n",
+       "       -7.78764610e-09,  1.44598185e-10,  3.13334564e-09,  1.39327398e-08,\n",
+       "       -1.07963610e-07, -4.33452318e-10])"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "previous_output.reshape(30) - (inlier_dists**2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([1.57400016e-03, 3.02999222e-03, 1.22819516e-03, 7.85842204e-04,\n",
+       "       6.24430755e-01, 8.38087807e-03, 1.55270473e-03, 3.67094367e-01,\n",
+       "       2.89759546e-03, 4.41204110e-03, 5.69508877e-03, 2.22076613e-03,\n",
+       "       3.59995552e-03, 7.55991076e-02, 2.03743663e-03, 1.54949178e-01,\n",
+       "       6.56673369e-03, 1.26924618e+00, 1.72368768e-02, 5.21945055e-01,\n",
+       "       4.33542871e-03, 1.02200389e-03, 7.39517672e-04, 4.23904966e-03,\n",
+       "       2.75986815e-03, 1.01882846e-03, 2.13477424e-03, 1.13266782e-02,\n",
+       "       4.81868721e-02, 2.26310777e-03])"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "inlier_dists**2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Outlier dists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([15.68734774,  2.88892802,  0.55714101,  1.50823125,  1.5675811 ,\n",
+       "        1.00905713,  2.91069471,  2.05114721, 18.6500535 , 17.46589804,\n",
+       "        2.31507787, 11.18594221,  2.08877256,  3.5896572 ,  2.07437671,\n",
+       "        1.70494233, 16.20276287, 11.34922168, 14.22447212,  1.79131614,\n",
+       "        1.72692897, 17.4224665 , 10.45685905, 11.10301968,  0.40264396,\n",
+       "        1.66121212,  2.47344445,  8.79436824, 10.39406515,  3.76990887])"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "outlier_dists"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Should be\n",
+    "array([[2.46092896e+02],\n",
+    "       [8.34590435e+00],\n",
+    "       [3.10406297e-01],\n",
+    "       [2.27476239e+00],\n",
+    "       [2.45730543e+00],\n",
+    "       [1.01819646e+00],\n",
+    "       [8.47214222e+00],\n",
+    "       [4.20720434e+00],\n",
+    "       [3.47824524e+02],\n",
+    "       [3.05057648e+02],\n",
+    "       [5.35958481e+00],\n",
+    "       [1.25125313e+02],\n",
+    "       [4.36297131e+00],\n",
+    "       [1.28856373e+01],\n",
+    "       [4.30303574e+00],\n",
+    "       [2.90682650e+00],\n",
+    "       [2.62529602e+02],\n",
+    "       [1.28804825e+02],\n",
+    "       [2.02335602e+02],\n",
+    "       [3.20881152e+00],\n",
+    "       [2.98228765e+00],\n",
+    "       [3.03542328e+02],\n",
+    "       [1.09345932e+02],\n",
+    "       [1.23277054e+02],\n",
+    "       [1.62122369e-01],\n",
+    "       [2.75962615e+00],\n",
+    "       [6.11792469e+00],\n",
+    "       [7.73409119e+01],\n",
+    "       [1.08036621e+02],\n",
+    "       [1.42122135e+01]])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "square root the expected distance array and compare to what we get:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "previous_output = np.array(\n",
+    "    [\n",
+    "        [2.46092896e02],\n",
+    "        [8.34590435e00],\n",
+    "        [3.10406297e-01],\n",
+    "        [2.27476239e00],\n",
+    "        [2.45730543e00],\n",
+    "        [1.01819646e00],\n",
+    "        [8.47214222e00],\n",
+    "        [4.20720434e00],\n",
+    "        [3.47824524e02],\n",
+    "        [3.05057648e02],\n",
+    "        [5.35958481e00],\n",
+    "        [1.25125313e02],\n",
+    "        [4.36297131e00],\n",
+    "        [1.28856373e01],\n",
+    "        [4.30303574e00],\n",
+    "        [2.90682650e00],\n",
+    "        [2.62529602e02],\n",
+    "        [1.28804825e02],\n",
+    "        [2.02335602e02],\n",
+    "        [3.20881152e00],\n",
+    "        [2.98228765e00],\n",
+    "        [3.03542328e02],\n",
+    "        [1.09345932e02],\n",
+    "        [1.23277054e02],\n",
+    "        [1.62122369e-01],\n",
+    "        [2.75962615e00],\n",
+    "        [6.11792469e00],\n",
+    "        [7.73409119e01],\n",
+    "        [1.08036621e02],\n",
+    "        [1.42122135e01],\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([15.68734828,  2.88892789,  0.55714118,  1.50823154,  1.56757948,\n",
+       "        1.00905721,  2.91069446,  2.05114708, 18.65005426, 17.46589958,\n",
+       "        2.31507771, 11.18594265,  2.08877268,  3.58965699,  2.07437599,\n",
+       "        1.70494179, 16.20276526, 11.34922134, 14.22447194,  1.79131558,\n",
+       "        1.72693012, 17.42246619, 10.45686052, 11.10302004,  0.40264422,\n",
+       "        1.66121225,  2.47344389,  8.79436819, 10.39406662,  3.76990895])"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(previous_output).reshape(30)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 5.42484775e-07, -1.29776750e-07,  1.75441668e-07,  2.94098708e-07,\n",
+       "       -1.62299082e-06,  8.76969586e-08, -2.51089855e-07, -1.30321758e-07,\n",
+       "        7.60598049e-07,  1.53263119e-06, -1.56555142e-07,  4.40688039e-07,\n",
+       "        1.22148594e-07, -2.11279730e-07, -7.22020625e-07, -5.40076410e-07,\n",
+       "        2.38531468e-06, -3.37048846e-07, -1.81282125e-07, -5.52109745e-07,\n",
+       "        1.15006647e-06, -3.10771561e-07,  1.47711321e-06,  3.62471932e-07,\n",
+       "        2.64911725e-07,  1.32784811e-07, -5.56680642e-07, -5.20487173e-08,\n",
+       "        1.47285028e-06,  8.01633524e-08])"
+      ]
+     },
+     "execution_count": 31,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.sqrt(previous_output).reshape(30) - outlier_dists"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 1.70202949e-05, -7.49831361e-07,  1.95491525e-07,  8.87137809e-07,\n",
+       "       -5.08833685e-06,  1.76982489e-07, -1.46169176e-06, -5.34618203e-07,\n",
+       "        2.83703892e-05,  5.35375625e-05, -7.24874663e-07,  9.85902207e-06,\n",
+       "        5.10281278e-07, -1.51684356e-06, -2.99548501e-06, -1.84159797e-06,\n",
+       "        7.72973819e-05, -7.65048404e-06, -5.15728505e-06, -1.97800588e-06,\n",
+       "        3.97216755e-06, -1.08288141e-05,  3.08919314e-05,  8.04906610e-06,\n",
+       "        2.13330280e-07,  4.41167494e-07, -2.75383698e-06, -9.15471176e-07,\n",
+       "        3.06178058e-05,  6.04417075e-07])"
+      ]
+     },
+     "execution_count": 32,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "previous_output.reshape(30) - (outlier_dists**2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([2.46092879e+02, 8.34590510e+00, 3.10406102e-01, 2.27476150e+00,\n",
+       "       2.45731052e+00, 1.01819628e+00, 8.47214368e+00, 4.20720487e+00,\n",
+       "       3.47824496e+02, 3.05057594e+02, 5.35958553e+00, 1.25125303e+02,\n",
+       "       4.36297080e+00, 1.28856388e+01, 4.30303874e+00, 2.90682834e+00,\n",
+       "       2.62529525e+02, 1.28804833e+02, 2.02335607e+02, 3.20881350e+00,\n",
+       "       2.98228368e+00, 3.03542339e+02, 1.09345901e+02, 1.23277046e+02,\n",
+       "       1.62122156e-01, 2.75962571e+00, 6.11792744e+00, 7.73409128e+01,\n",
+       "       1.08036590e+02, 1.42122129e+01])"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "outlier_dists**2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "535655b1-d733-47b0-b471-f25a6fd11593",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "### Ship movement data example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "9f49674f-86c7-4d6e-88f9-98218ab69be3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# data = Data.Data(\n",
+    "#     n_samples=(800, 30, 30),\n",
+    "#     if_sample=True,\n",
+    "# )\n",
+    "data = Data.Data(\n",
+    "    if_sample=False,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "60165b32-c950-4b0c-9526-3edcb7674e62",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Threshold distance:  4000\n",
+      "lead_lag:  True\n",
+      "inv_reset:  True\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 27.13375997543335\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 332.76756405830383\n",
+      "lead_lag: True inv_rest: True thres_distance: 4000 auc: 0.8228045999999999\n",
+      "Threshold distance:  8000\n",
+      "lead_lag:  True\n",
+      "inv_reset:  True\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 21.94414520263672\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 255.8750569820404\n",
+      "lead_lag: True inv_rest: True thres_distance: 8000 auc: 0.8354452200000001\n",
+      "Threshold distance:  16000\n",
+      "lead_lag:  True\n",
+      "inv_reset:  True\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 21.80716109275818\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAHcCAYAAAB1fsZ+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACc6klEQVR4nOzdd1hT1xsH8C8gU2Q4UEQEcW8tbsWJ4qxWrahVce9RrdZVt9WqdbXaWne1DpytddW99957b1EBRXbO74/zSyAkIMHABfL9PA9P7r25uXkzSN6ce857zIQQAkRERESU5syVDoCIiIjIVDERIyIiIlIIEzEiIiIihTARIyIiIlIIEzEiIiIihTARIyIiIlIIEzEiIiIihTARIyIiIlIIEzEiIiIihTARI/oMnp6e6Ny5s9JhmJzatWujdu3aSofxSePHj4eZmRmCgoKUDiXdMTMzw/jx441yrAcPHsDMzAzLly83yvGI0hITMUq3li9fDjMzM81flixZ4Obmhs6dO+Pp06dKh5euhYWFYdKkSShTpgzs7Ozg6OgIHx8frFixAhllVrNr165h/PjxePDggdKh6IiNjcWyZctQu3ZtZM+eHdbW1vD09ESXLl1w5swZpcMzitWrV2POnDlKh6ElPcZE9LmyKB0A0adMnDgRBQoUQEREBE6cOIHly5fjyJEjuHLlCmxsbBSN7ebNmzA3T1+/Z16+fIl69erh+vXraNu2Lfr374+IiAhs3LgRAQEB2L59O1atWgULCwulQ03StWvXMGHCBNSuXRuenp5a1+3atUuZoACEh4ejZcuW2LlzJ2rWrIlRo0Yhe/bsePDgAdatW4c///wTjx49Qr58+RSL0RhWr16NK1eu4Ntvv02V44eHhyNLFsO+ghKLycPDA+Hh4bC0tDRihERpg4kYpXuNGjVChQoVAADdu3dHzpw5MW3aNGzZsgVt2rRRNDZra+s0v8+IiAhYWVklmgAGBATg+vXr2Lx5M7788kvN9oEDB2LYsGH4+eefUb58eQwfPjytQgYgW+myZs1qlGNZWVkZ5TgpMWzYMOzcuROzZ8/WSQjGjRuH2bNnp2k8QghERETA1tY2Te83JVQqFaKiomBjY2PUH1FmZmaK/ygjSjFBlE4tW7ZMABCnT5/W2r5161YBQEyZMkVr+/Xr10WrVq2Es7OzsLa2Ft7e3uKff/7ROe67d+/Et99+Kzw8PISVlZVwc3MTHTt2FK9fv9bsExERIcaOHSsKFiworKysRL58+cSwYcNERESE1rE8PDxEQECAEEKI06dPCwBi+fLlOve5c+dOAUD8+++/mm1PnjwRXbp0ES4uLsLKykqUKFFCLFmyROt2+/fvFwDEmjVrxOjRo0XevHmFmZmZePfund7n7Pjx4wKA6Nq1q97ro6OjReHChYWzs7P4+PGjEEKI+/fvCwBixowZYtasWSJ//vzCxsZG1KxZU1y+fFnnGMl5ntWv3YEDB0SfPn1Erly5hJOTkxBCiAcPHog+ffqIIkWKCBsbG5E9e3bRunVrcf/+fZ3bJ/zbv3+/EEKIWrVqiVq1auk8T4GBgWLy5MnCzc1NWFtbi7p164rbt2/rPIZ58+aJAgUKCBsbG1GxYkVx6NAhnWPq8/jxY5ElSxZRv379JPdTGzdunAAgbt++LQICAoSjo6NwcHAQnTt3FmFhYVr7Ll26VNSpU0fkypVLWFlZieLFi4vffvtN55geHh6iSZMmYufOncLb21tYW1uL2bNnG3QMIYTYvn27qFmzprC3txfZsmUTFSpUEKtWrRJCyOc34XPv4eGhuW1y/z8AiH79+om//vpLlChRQmTJkkVs3rxZc924ceM0+4aGhopBgwZp/i9z5colfH19xdmzZz8Zk/o9vGzZMq37v379uvj6669Fzpw5hY2NjShSpIgYNWpUUi8ZUZpjixhlOOo+Q87OzpptV69eRfXq1eHm5oYRI0Yga9asWLduHVq0aIGNGzfiq6++AgB8+PABPj4+uH79Orp27YovvvgCQUFB2LJlC548eYKcOXNCpVLhyy+/xJEjR9CzZ08UL14cly9fxuzZs3Hr1i38/fffeuOqUKECvLy8sG7dOgQEBGhdFxgYCGdnZ/j5+QGQpw+rVKkCMzMz9O/fH7ly5cKOHTvQrVs3hIaG6rS0TJo0CVZWVhg6dCgiIyMTbRH6999/AQCdOnXSe32WLFnQvn17TJgwAUePHoWvr6/muhUrVuD9+/fo168fIiIiMHfuXNStWxeXL19G7ty5DXqe1fr27YtcuXJh7NixCAsLAwCcPn0ax44dQ9u2bZEvXz48ePAAv//+O2rXro1r167Bzs4ONWvWxMCBA/HLL79g1KhRKF68OABoLhPz008/wdzcHEOHDkVISAimT5+Ob775BidPntTs8/vvv6N///7w8fHB4MGD8eDBA7Ro0QLOzs6fPJ24Y8cOxMTEoGPHjknul1CbNm1QoEABTJ06FefOncPixYvh4uKCadOmacVVsmRJfPnll8iSJQv+/fdf9O3bFyqVCv369dM63s2bN9GuXTv06tULPXr0QNGiRQ06xvLly9G1a1eULFkSI0eOhJOTE86fP4+dO3eiffv2GD16NEJCQvDkyRNNC5+9vT0AGPz/sW/fPqxbtw79+/dHzpw5dU4zq/Xu3RsbNmxA//79UaJECbx58wZHjhzB9evX8cUXXyQZkz6XLl2Cj48PLC0t0bNnT3h6euLu3bv4999/8eOPPybvhSNKC0pngkSJUbeK7NmzR7x+/Vo8fvxYbNiwQeTKlUtYW1uLx48fa/atV6+eKF26tNYvcpVKJapVqyYKFy6s2TZ27FgBQGzatEnn/lQqlRBCiJUrVwpzc3Nx+PBhresXLFggAIijR49qtsVvERNCiJEjRwpLS0vx9u1bzbbIyEjh5OSk1UrVrVs34erqKoKCgrTuo23btsLR0VHTWqVu6fHy8tJsS0qLFi0EgERbzIQQYtOmTQKA+OWXX4QQca0Jtra24smTJ5r9Tp48KQCIwYMHa7Yl93lWv3Y1atQQMTExWvev73GoW/JWrFih2bZ+/XqtVrD4EmsRK168uIiMjNRsnzt3rgCgadmLjIwUOXLkEBUrVhTR0dGa/ZYvXy4AfLJFbPDgwQKAOH/+fJL7qalbxBK2UH711VciR44cWtv0PS9+fn7Cy8tLa5uHh4cAIHbu3Kmzf3KOERwcLLJlyyYqV64swsPDtfZV/w8IIUSTJk20WsHUDPn/ACDMzc3F1atXdY6DBC1ijo6Ool+/fjr7xZdYTPpaxGrWrCmyZcsmHj58mOhjJEoP0lcvYyI9fH19kStXLri7u6N169bImjUrtmzZomm9ePv2Lfbt24c2bdrg/fv3CAoKQlBQEN68eQM/Pz/cvn1bM8py48aNKFu2rE7LDSD7mQDA+vXrUbx4cRQrVkxzrKCgINStWxcAsH///kRj9ff3R3R0NDZt2qTZtmvXLgQHB8Pf3x+A7NOzceNGNGvWDEIIrfvw8/NDSEgIzp07p3XcgICAZPUBev/+PQAgW7Zsie6jvi40NFRre4sWLeDm5qZZr1SpEipXrozt27cDMOx5VuvRo4fOoID4jyM6Ohpv3rxBoUKF4OTkpPO4DdWlSxet1kIfHx8AwL179wAAZ86cwZs3b9CjRw+tjuLffPONVgtrYtTPWVLPrz69e/fWWvfx8cGbN2+0XoP4z0tISAiCgoJQq1Yt3Lt3DyEhIVq3L1CggKZ1Nb7kHGP37t14//49RowYodOvSv0/kBRD/z9q1aqFEiVKfPK4Tk5OOHnyJJ49e/bJfT/l9evXOHToELp27Yr8+fNrXZecx0iUlnhqktK9+fPno0iRIggJCcHSpUtx6NAhrU7yd+7cgRACY8aMwZgxY/Qe49WrV3Bzc8Pdu3fRqlWrJO/v9u3buH79OnLlypXosRJTtmxZFCtWDIGBgejWrRsAeVoyZ86cmi+q169fIzg4GAsXLsTChQuTdR8FChRIMmY1dYLw/v17ODk56d0nsWStcOHCOvsWKVIE69atA2DY85xU3OHh4Zg6dSqWLVuGp0+fapXTSJhwGCrhl646uXr37h0A4OHDhwCAQoUKae2XJUuWRE+Zxefg4AAg7jk0RlzqYx49ehTjxo3D8ePH8fHjR639Q0JC4OjoqFlP7P2QnGPcvXsXAFCqVCmDHoOaof8fyX3vTp8+HQEBAXB3d4e3tzcaN26MTp06wcvLy+AY1Yl3Sh8jUVpiIkbpXqVKlTSjJlu0aIEaNWqgffv2uHnzJuzt7aFSqQAAQ4cO1dtKAOh+8SZFpVKhdOnSmDVrlt7r3d3dk7y9v78/fvzxRwQFBSFbtmzYsmUL2rVrp2mBUcfboUMHnb5kamXKlNFaT+6IuOLFi+Pvv//GpUuXULNmTb37XLp0CQCS1UoRX0qeZ31xDxgwAMuWLcO3336LqlWrwtHREWZmZmjbtq3mPlIqsZIcwki104oVKwYAuHz5MsqVK5fs230qrrt376JevXooVqwYZs2aBXd3d1hZWWH79u2YPXu2zvOi73k19BgpZej/R3Lfu23atIGPjw82b96MXbt2YcaMGZg2bRo2bdqERo0afXbcROkVEzHKUCwsLDB16lTUqVMH8+bNw4gRIzS/mC0tLbU6n+tTsGBBXLly5ZP7XLx4EfXq1UvRaQx/f39MmDABGzduRO7cuREaGoq2bdtqrs+VKxeyZcuG2NjYT8ZrqKZNm2Lq1KlYsWKF3kQsNjYWq1evhrOzM6pXr6513e3bt3X2v3XrlqalyJDnOSkbNmxAQEAAZs6cqdkWERGB4OBgrf1S4xSSh4cHANm6V6dOHc32mJgYPHjwQCcBTqhRo0awsLDAX3/9ZXCH/aT8+++/iIyMxJYtW7Raz5I6DZ7SYxQsWBAAcOXKlSR/oCT2/H/u/0dSXF1d0bdvX/Tt2xevXr3CF198gR9//FGTiCX3/tTv1U/9rxOlB+wjRhlO7dq1UalSJcyZMwcRERFwcXFB7dq18ccff+D58+c6+79+/Vqz3KpVK1y8eBGbN2/W2U/dOtGmTRs8ffoUixYt0tknPDxcM/ovMcWLF0fp0qURGBiIwMBAuLq6aiVFFhYWaNWqFTZu3Kj3iyJ+vIaqVq0afH19sWzZMmzdulXn+tGjR+PWrVv4/vvvdVoq/v77b60+XqdOncLJkyc1X4KGPM9JsbCw0Gmh+vXXXxEbG6u1TV1zLGGC9jkqVKiAHDlyYNGiRYiJidFsX7Vqleb0ZVLc3d3Ro0cP7Nq1C7/++qvO9SqVCjNnzsSTJ08MikvdYpbwNO2yZcuMfowGDRogW7ZsmDp1KiIiIrSui3/brFmz6j1V/Ln/H/rExsbq3JeLiwvy5s2LyMjIT8aUUK5cuVCzZk0sXboUjx490rrOWK2jRMbCFjHKkIYNG4avv/4ay5cvR+/evTF//nzUqFEDpUuXRo8ePeDl5YWXL1/i+PHjePLkCS5evKi53YYNG/D111+ja9eu8Pb2xtu3b7FlyxYsWLAAZcuWRceOHbFu3Tr07t0b+/fvR/Xq1REbG4sbN25g3bp1+O+//zSnShPj7++PsWPHwsbGBt26ddMpvvrTTz9h//79qFy5Mnr06IESJUrg7du3OHfuHPbs2YO3b9+m+LlZsWIF6tWrh+bNm6N9+/bw8fFBZGQkNm3ahAMHDsDf3x/Dhg3TuV2hQoVQo0YN9OnTB5GRkZgzZw5y5MiB77//XrNPcp/npDRt2hQrV66Eo6MjSpQogePHj2PPnj3IkSOH1n7lypWDhYUFpk2bhpCQEFhbW6Nu3bpwcXFJ8XNjZWWF8ePHY8CAAahbty7atGmDBw8eYPny5ShYsGCyWlxmzpyJu3fvYuDAgdi0aROaNm0KZ2dnPHr0COvXr8eNGze0WkCTo0GDBrCyskKzZs3Qq1cvfPjwAYsWLYKLi4vepPdzjuHg4IDZs2eje/fuqFixItq3bw9nZ2dcvHgRHz9+xJ9//gkA8Pb2RmBgIIYMGYKKFSvC3t4ezZo1M8r/R0Lv379Hvnz50Lp1a5QtWxb29vbYs2cPTp8+rdVymlhM+vzyyy+oUaMGvvjiC/Ts2RMFChTAgwcPsG3bNly4cMGg+IhSlSJjNYmSIbGCrkIIERsbKwoWLCgKFiyoKY9w9+5d0alTJ5EnTx5haWkp3NzcRNOmTcWGDRu0bvvmzRvRv39/4ebmpilGGRAQoFVKIioqSkybNk2ULFlSWFtbC2dnZ+Ht7S0mTJggQkJCNPslLF+hdvv2bU3RySNHjuh9fC9fvhT9+vUT7u7uwtLSUuTJk0fUq1dPLFy4ULOPuizD+vXrDXru3r9/L8aPHy9KliwpbG1tRbZs2UT16tXF8uXLdYbvxy/oOnPmTOHu7i6sra2Fj4+PuHjxos6xk/M8J/XavXv3TnTp0kXkzJlT2NvbCz8/P3Hjxg29z+WiRYuEl5eXsLCwSFZB14TPU2KFPn/55Rfh4eEhrK2tRaVKlcTRo0eFt7e3aNiwYTKeXSFiYmLE4sWLhY+Pj3B0dBSWlpbCw8NDdOnSRau0hbp8RfxiwfGfn/hFbLds2SLKlCkjbGxshKenp5g2bZpYunSpzn7qgq76JPcY6n2rVasmbG1thYODg6hUqZJYs2aN5voPHz6I9u3bCycnJ52Crsn9/8D/C7rqg3jlKyIjI8WwYcNE2bJlRbZs2UTWrFlF2bJldYrRJhZTYq/zlStXxFdffSWcnJyEjY2NKFq0qBgzZozeeIiUYiYE22mJTNmDBw9QoEABzJgxA0OHDlU6HEWoVCrkypULLVu21HvKjYgotbCPGBGZlIiICJ1+QitWrMDbt29Ru3ZtZYIiIpPFPmJEZFJOnDiBwYMH4+uvv0aOHDlw7tw5LFmyBKVKlcLXX3+tdHhEZGKYiBGRSfH09IS7uzt++eUXvH37FtmzZ0enTp3w008/JTqHJxFRamEfMSIiIiKFsI8YERERkUKYiBEREREpRJFE7MCBAzAzM8OGDRuUuHsdqRHP+PHjkz0dh5mZGcaPH5+i+1HHfuDAAc22zp07J2sCY8q8li9fnibvv8/x4MEDmJmZYfny5al6G5KzUXTu3PmT+6nfNw8ePEj1mCh9OnXqFKysrPDw4cNP7uvp6Zms91VqUH8W/Pzzz4rcf3xv3rxB1qxZsX379hTd3miJmJmZWbL+4icMlH5cu3YN48ePz/QfwKdOnULfvn3h7e0NS0vLTyYrL1++RK9eveDm5gYbGxt4enqiW7duOvs9ffoUbdq0gZOTExwcHNC8eXPcu3dP7zGXLFmC4sWLw8bGBoULF9Y7VY6hx6S0p/6x9ak/lsTI2D73s1Gd3H7qL738eB49ejTatWunmZdVadu3b1fkhyIAbN68GX5+fsibNy+sra01sz8knJouR44c6N69O8aMGZOi+zHaqMmVK1dqra9YsQK7d+/W2V68eHFcv37dWHdLeixatAgqlcqg21y7dg0TJkxA7dq1080HQmrYvn07Fi9ejDJlysDLywu3bt1KdN/Hjx9rJsbu3bs33Nzc8OzZM5w6dUprvw8fPqBOnToICQnBqFGjYGlpidmzZ6NWrVq4cOGC1tQ9f/zxB3r37o1WrVphyJAhOHz4MAYOHIiPHz9i+PDhKTomKaNly5Zak2Z/+PABffr0wVdffYWWLVtqtufOnVuJ8FKkY8eOaNu2LaytrZUOJd343M/GmjVr6nwPdu/eHZUqVULPnj012+zt7T831M924cIF7NmzB8eOHVM6FI3t27dj/vz5iiRjly9fhrOzMwYNGoScOXPixYsXWLp0KSpVqoTjx4+jbNmymn179+6NX375Bfv27UPdunUNuh+jJWIdOnTQWj9x4gR2796tsx3AZydiHz9+hJ2d3WcdIzOztLRUOoR0q0+fPhg+fDhsbW3Rv3//JBOxXr16IUuWLDh9+nSSic9vv/2G27dv49SpU6hYsSIAoFGjRihVqhRmzpyJKVOmAJATIo8ePRpNmjTRnAbv0aMHVCoVJk2ahJ49e8LZ2dmgY5JyypQpgzJlymjWg4KC0KdPH5QpU0bv555aREQErKysdOYfTQ8sLCw0k4enJzExMVCpVBmyvIiXlxe8vLy0tvXu3RteXl5Jvk+UeMzLli1D/vz5UaVKlTS7z/Rs7NixOtu6d++OfPny4ffff8eCBQs024sXL45SpUph+fLlBidiin4SqFQq/Pjjj8iXLx9sbGxQr1493LlzR2uf2rVro1SpUjh79ixq1qwJOzs7jBo1CgAQGRmJcePGoVChQrC2toa7uzu+//57REZGah1j9+7dqFGjBpycnGBvb4+iRYtqjmFoPACwfv16eHt7w9bWFjlz5kSHDh3w9OnTTz7eyMhIDB48GLly5UK2bNnw5Zdf4smTJ8l+vp48eYIWLVoga9ascHFxweDBg3UeK6C/j9jatWvh7e2NbNmywcHBAaVLl8bcuXMByKZzdSHLOnXq6JxG/ueff9CkSRNN82zBggUxadIkxMbGat2H+rW6du0a6tSpAzs7O7i5uWH69Ok6MUZERGD8+PEoUqQIbGxs4OrqipYtW+Lu3buafVQqFebMmYOSJUvCxsYGuXPnRq9evfDu3TutY4WEhODGjRsICQn55HOYO3du2NrafnK/GzduYMeOHRg2bBhy5MiBiIgIREdH6913w4YNqFixoiZhAoBixYqhXr16WLdunWbb/v378ebNG/Tt21fr9v369UNYWBi2bdtm8DFTy9OnT9G1a1fkzp0b1tbWKFmyJJYuXaq1T1RUFMaOHQtvb284Ojoia9as8PHxwf79+3WOFxwcjM6dO8PR0RFOTk4ICAhAcHCwUWK9dOkSOnfuDC8vL9jY2CBPnjzo2rUr3rx5o7PvgQMHUKFCBdjY2KBgwYL4448/9PbnDAoKwo0bN/Dx48fPik3dh3Pt2rX44Ycf4ObmBjs7O4SGhibajzSxflo7duyAj48PsmbNimzZsqFJkya4evXqZ8WXnPv29PRE06ZNceTIEVSqVAk2Njbw8vLCihUrNPucOXMGZmZmmgnD4/vvv/9gZmaGrVu3JiuG+H1/5syZg4IFC8La2hrXrl0DIP83W7dujezZs8PGxgYVKlTAli1btI4RHR2NCRMmoHDhwrCxsUGOHDlQo0YN7N69W2u/Tx3rU5+Nhnz2pPQxJ/Z+0Nc/GABOnjyJhg0bwtHREXZ2dqhVqxaOHj2arDj+/vtv1K1bV+d9KYTA5MmTkS9fPtjZ2aFOnTqJvveCg4Px7bffwt3dHdbW1ihUqBCmTZumdZYm/uOdPXs2PDw8YGtri1q1ammd9uvcuTPmz58PQLv7U0ILFy7UPGcVK1bE6dOnk/V4U8LFxQV2dnZ6P7/q16+Pf//9V2fmjk9RtKDrTz/9BHNzcwwdOhQhISGYPn06vvnmG5w8eVJrvzdv3qBRo0Zo27YtOnTogNy5c0OlUuHLL7/EkSNH0LNnTxQvXhyXL1/G7NmzcevWLfz9998AgKtXr6Jp06YoU6YMJk6cCGtra9y5c0fvGzM58SxfvhxdunRBxYoVMXXqVLx8+RJz587F0aNHcf78eTg5OSX6eLt3746//voL7du3R7Vq1bBv3z40adIkWc9VeHg46tWrh0ePHmHgwIHImzcvVq5ciX379n3ytrt370a7du1Qr149TJs2DYBslTx69CgGDRqEmjVrYuDAgfjll18watQoFC9eHAA0l8uXL4e9vT2GDBkCe3t77Nu3D2PHjkVoaChmzJihdV/v3r1Dw4YN0bJlS7Rp0wYbNmzA8OHDUbp0aTRq1AgAEBsbi6ZNm2Lv3r1o27YtBg0ahPfv32P37t24cuUKChYsCEC2SKmf74EDB+L+/fuYN28ezp8/j6NHj2pa/jZv3owuXbpg2bJlRus4umfPHgAycatXrx727dsHCwsL1K9fH7///rsm0VWpVLh06RK6du2qc4xKlSph165deP/+PbJly4bz588DACpUqKC1n7e3N8zNzXH+/Hl06NDBoGOmhpcvX6JKlSowMzND//79kStXLuzYsQPdunVDaGgovv32WwBAaGgoFi9ejHbt2qFHjx54//49lixZAj8/P5w6dQrlypUDID/EmzdvjiNHjqB3794oXrw4Nm/ejICAAKPEu3v3bty7dw9dunRBnjx5cPXqVSxcuBBXr17FiRMnNB/c58+fR8OGDeHq6ooJEyYgNjYWEydORK5cuXSOOW/ePEyYMAH79+83Sh+vSZMmwcrKCkOHDkVkZKTBrRwrV65EQEAA/Pz8MG3aNHz8+BG///47atSogfPnz6d6d4I7d+6gdevW6NatGwICArB06VJ07twZ3t7eKFmyJCpUqAAvLy+sW7dO53UNDAyEs7Mz/Pz8DLrPZcuWISIiAj179oS1tTWyZ8+Oq1evonr16nBzc8OIESOQNWtWrFu3Di1atMDGjRvx1VdfAZD996ZOnao5BRgaGoozZ87g3LlzqF+/PgAk61if+mw09mePvsdsiH379qFRo0bw9vbGuHHjYG5ujmXLlqFu3bo4fPgwKlWqlOhtnz59ikePHuGLL77QuW7s2LGYPHkyGjdujMaNG+PcuXNo0KABoqKitPb7+PEjatWqhadPn6JXr17Inz8/jh07hpEjR+L58+eYM2eO1v4rVqzA+/fv0a9fP0RERGDu3LmoW7cuLl++rPnh/ezZM73dnNRWr16N9+/fo1evXjAzM8P06dPRsmVL3Lt3T/MdERkZiffv3yfrOcyZM6fOtuDgYERHR+PFixeYM2cOQkNDUa9ePZ39vL29MXv2bFy9ehWlSpVK1v0BAFJrNvF+/fqJxA6/f/9+AUAUL15cREZGarbPnTtXABCXL1/WbKtVq5YAIBYsWKB1jJUrVwpzc3Nx+PBhre0LFiwQAMTRo0eFEELMnj1bABCvX79ONNbkxhMVFSVcXFxEqVKlRHh4uGa/rVu3CgBi7Nixmm3jxo3TevwXLlwQAETfvn217rt9+/YCgBg3blyi8QkhxJw5cwQAsW7dOs22sLAwUahQIQFA7N+/X7M9ICBAeHh4aNYHDRokHBwcRExMTKLHX79+vc5x1D5+/KizrVevXsLOzk5ERERotqlfqxUrVmi2RUZGijx58ohWrVppti1dulQAELNmzdI5rkqlEkIIcfjwYQFArFq1Suv6nTt36mxftmyZACCWLVuW6OPTJ6n36MCBAwUAkSNHDtGwYUMRGBgoZsyYIezt7UXBggVFWFiYEEKI169fCwBi4sSJOseYP3++ACBu3LihuT8LCwu995crVy7Rtm1bg4+ZGPVzkhwJ33/dunUTrq6uIigoSGu/tm3bCkdHR837ISYmRuv/RQgh3r17J3Lnzi26du2q2fb3338LAGL69OmabTExMcLHx8fg1+3+/fs6t9H3/lyzZo0AIA4dOqTZ1qxZM2FnZyeePn2q2Xb79m2RJUsWnedK/f+r7/8hMerXLf5zqf5s8fLy0okz4WeEmvq1u3//vhBCiPfv3wsnJyfRo0cPrf1evHghHB0ddbbrU6tWLREQEPDJ/RLetxBCeHh46DyXr169EtbW1uK7777TbBs5cqSwtLQUb9++1WyLjIwUTk5OWu+HT1G/xg4ODuLVq1da19WrV0+ULl1a63NHpVKJatWqicKFC2u2lS1bVjRp0iTJ+0nusZL6bEzpZ0/WrFm1Xo+kHrO+10SIuPeWOi6VSiUKFy4s/Pz8NJ+jQsj/jwIFCoj69esnGdOePXsEAPHvv/9qbX/16pWwsrISTZo00TruqFGjBACtxzFp0iSRNWtWcevWLa1jjBgxQlhYWIhHjx5pPV5bW1vx5MkTzX4nT54UAMTgwYM12xL7nFYfI0eOHFrvuX/++Ufncaifw+T86VO0aFHN9fb29uKHH34QsbGxOvsdO3ZMABCBgYF6j5MYRU9NdunSReuXoY+PDwDojAyztrZGly5dtLatX78exYsXR7FixRAUFKT5U5+bVZ8eUbdQ/fPPP5/swP6peM6cOYNXr16hb9++sLGx0ezXpEkTFCtWTOvUUkLqYa0DBw7U2q5uXfiU7du3w9XVFa1bt9Zss7Oz0+rsmRgnJyeEhYXpNMsnV/xTee/fv0dQUBB8fHzw8eNH3LhxQ2tfe3t7rX4PVlZWqFSpktZrunHjRuTMmRMDBgzQuS9168X69evh6OiI+vXra72+3t7esLe31zr91blzZwghjDqM+sOHDwCAPHnyYNu2bWjTpg2GDh2KRYsW4e7du1i9ejUA2VIJQG/nZvV7RL1PeHh4oi0hNjY2Wvsl95jGJoTAxo0b0axZMwghtJ57Pz8/hISE4Ny5cwBkfyL141GpVHj79i1iYmJQoUIFzT6AfO9myZIFffr00WyzsLDQ+/qnRPz3Z0REBIKCgjR9XNRxxMbGYs+ePWjRogXy5s2r2b9QoUKaltr4xo8fDyGE0UY8BgQEJOuUuD67d+9GcHAw2rVrp/V6WFhYoHLlynpPBRtbiRIlNJ+HAJArVy4ULVpU6//a398f0dHR2LRpk2bbrl27EBwcDH9/f4Pvs1WrVlqtlW/fvsW+ffvQpk0bzedQUFAQ3rx5Az8/P9y+fVvTRcTJyQlXr17F7du39R7bkGMlxdifPQkfsyEuXLiA27dvo3379njz5o3mMYWFhaFevXo4dOhQkt+B6lP56n6qanv27EFUVBQGDBigdVpQ33fX+vXr4ePjA2dnZ633qq+vL2JjY3Ho0CGt/Vu0aAE3NzfNeqVKlVC5cmWDykD4+/trxawvj/Dz88Pu3buT9afPsmXLsHPnTvz2228oXrw4wsPDdbrmAHHPXVBQULLjBxQ+NZk/f36tdfWDSNgHyM3NTecL7Pbt27h+/Xqib9pXr14BkC/S4sWL0b17d4wYMQL16tVDy5Yt0bp1a53Osp+KR11XpWjRojr3V6xYMRw5ciTRx/rw4UOYm5trTrup6TtWYrcvVKiQzvnx5Ny+b9++WLduHRo1agQ3Nzc0aNAAbdq0QcOGDZN131evXsUPP/yAffv2ITQ0VOu6hH0j8uXLpxOjs7MzLl26pFm/e/cuihYtiixZEn/73b59GyEhIXBxcdF7vfr1TS3qL802bdpovU++/vprdOzYEceOHUP37t01++nrqxcREaF1LFtbW52m/Pj7xt8vucc0ttevXyM4OBgLFy7EwoUL9e4T/7n/888/MXPmTNy4cUOrD12BAgU0yw8fPoSrq6vOqLDkvvc/5e3bt5gwYQLWrl2r875Qvz9fvXqF8PBwrVGOavq2GVv858NQ6mQisQ7ADg4OKT52ciX8bATk/3X8z+qyZcuiWLFiCAwM1JR4CQwMRM6cOQ3uvAzoPmd37tyBEAJjxoxJtEzAq1ev4ObmhokTJ6J58+YoUqQISpUqhYYNG6Jjx46awRWGHCstGeN9ktQp/5CQEJ1EKyGRoH+T+nuvcOHCWttz5cqlc6zbt2/j0qVLn/xeVkt4TAAoUqSIQf1gk5NHuLq6wtXVNdnHTKhq1aqa5bZt22pOTSesYaZ+7pJbw1FN0UQssdE5Cd8I+r50VCoVSpcujVmzZuk9hru7u+a2hw4dwv79+7Ft2zbs3LkTgYGBqFu3Lnbt2qUVQ3LjyWhcXFxw4cIF/Pfff9ixYwd27NiBZcuWoVOnTno718YXHByMWrVqwcHBARMnTkTBggVhY2ODc+fOYfjw4Tq/sIz1HKpUKri4uGDVqlV6r0/pr8bkUreaJCw9YGFhgRw5cmj+ybNnzw5ra2s8f/5c5xjqbepjubq6IjY2Fq9evdJKMKOiovDmzRvNfoYc09jUr2eHDh0S/UBXf5n99ddf6Ny5M1q0aIFhw4bBxcUFFhYWmDp1qtagi9TWpk0bHDt2DMOGDUO5cuVgb28PlUqFhg0bGlzGJbXo+wxL7MM64S9t9WNYuXIl8uTJo7N/Uj9ojCW5/9f+/v748ccfERQUhGzZsmHLli1o165dimJM+Jypn4ehQ4cm2t9MnVTXrFkTd+/exT///INdu3Zh8eLFmD17NhYsWIDu3bsbdKy0ZIz3yYwZMzT9MxNKqkSGemR4woYQQ6hUKtSvXx/ff/+93uuLFCmS4mMnJjnvzfDw8GQPqND3Pxafs7Mz6tati1WrVukkYurnTl8/s6Qomoh9joIFC+LixYuoV6/eJ7NPc3Nz1KtXD/Xq1cOsWbMwZcoUjB49Gvv374evr2+y71Nd4O7mzZs6v/Bu3ryZZAE8Dw8PqFQqTWtQ/Nsl976vXLkCIYTW403u7a2srNCsWTM0a9YMKpUKffv2xR9//IExY8bobWlTO3DgAN68eYNNmzahZs2amu33799P1v3qU7BgQZw8eRLR0dGJltooWLAg9uzZg+rVq6da609SvL29AUDn9ERUVBSCgoI0iaC5uTlKly6NM2fO6Bzj5MmT8PLy0nSqV384njlzBo0bN9bsd+bMGahUKs31hhzT2NQjemNjYz/5v7FhwwZ4eXlh06ZNWu+fcePGae3n4eGBvXv34sOHD1pfBMl97ybl3bt32Lt3LyZMmKA11DzhKSkXFxfY2NjoHQWtb1taUP9yDw4O1hrkk7CiuboV3cXFxaDPKyX4+/tjwoQJ2LhxI3Lnzo3Q0FC0bdvWKMdWl4CwtLRM1vOQPXt2dOnSBV26dMGHDx9Qs2ZNjB8/Ht27dzfoWIa2bhhb/PdJfIm9TxwcHFL0PilWrBgA3c929ffa7du3tcpwvH79WidpK1iwID58+JDs+9d36vjWrVtag0+M8fwHBgbqdG9KTHIaDRJL7NTPnbrFLLnSXyGbZGrTpg2ePn2KRYsW6VwXHh6OsLAwAPK0RULqLzx9p36SUqFCBbi4uGDBggVat92xYweuX7+e5AhIdT+UX375RWt7wlEkiWncuDGePXumNQ3Tx48fEz19FF/CYfzm5uaaVg3148iaNSsA3X929a+N+G/OqKgo/Pbbb8mKW59WrVohKCgI8+bN07lOfT9t2rRBbGwsJk2apLNPTEyMVpzGGkIeX+3atTUtcurTgYAcQRobG6sZeQUArVu3xunTp7USp5s3b2Lfvn2aoe+APLWUPXt2/P7771r39fvvv8POzk7r/ZPcYxqbhYUFWrVqhY0bN+pUjwbkh2/8fQHt98bJkydx/Phxrds0btwYMTExWo87NjY20RkFDI03YQyA7v+VhYUFfH198ffff+PZs2ea7Xfu3MGOHTt0jmus8hVJUX9xxu83ExYWptNK7efnBwcHB0yZMkVvCZX4r4nSihcvjtKlSyMwMBCBgYFwdXXV+gH3OVxcXFC7dm388ccfeluL4z8PCT/z7O3tUahQIc3nnSHHSuyzEUidz56E9L1PYmNjdT77vb29UbBgQfz888+aPq7xfep94ubmBnd3d50fgL6+vrC0tMSvv/6q9X+m77urTZs2OH78OP777z+d64KDgxETE6O17e+//9b6sXvq1CmcPHlSq99mUs9/cqW0j5i+LjAPHjzA3r17dUa/A8DZs2fh6OiIkiVLGhRfhm0R69ixI9atW4fevXtj//79qF69OmJjY3Hjxg2sW7cO//33HypUqICJEyfi0KFDaNKkCTw8PPDq1Sv89ttvyJcvH2rUqGHQfVpaWmLatGno0qULatWqhXbt2mnKV3h6emLw4MGJ3rZcuXJo164dfvvtN4SEhKBatWrYu3dvsn+N9+jRA/PmzUOnTp1w9uxZuLq6YuXKlckqbNu9e3e8ffsWdevWRb58+fDw4UP8+uuvKFeunCZzL1euHCwsLDBt2jSEhITA2toadevWRbVq1eDs7IyAgAAMHDgQZmZmWLly5Wedru3UqRNWrFiBIUOG4NSpU/Dx8UFYWBj27NmDvn37onnz5qhVqxZ69eqFqVOn4sKFC2jQoAEsLS1x+/ZtrF+/HnPnztUMXDBkCPnDhw81w6DVHziTJ08GIH/5dezYEYDsKD9jxgwEBASgZs2a6NixIx49eoS5c+fCx8dHq3J63759sWjRIjRp0gRDhw6FpaUlZs2ahdy5c+O7777T7Gdra4tJkyahX79++Prrr+Hn54fDhw/jr7/+wo8//qg1VD25x0wNP/30E/bv34/KlSujR48eKFGiBN6+fYtz585hz549mh83TZs2xaZNm/DVV1+hSZMmuH//PhYsWIASJUpofRE0a9YM1atXx4gRI/DgwQOUKFECmzZtMsqXl4ODA2rWrInp06cjOjoabm5u2LVrl94W2/Hjx2PXrl2oXr06+vTpg9jYWMybNw+lSpXChQsXtPY1dvkKfRo0aID8+fOjW7duGDZsGCwsLLB06VLkypULjx490nqMv//+Ozp27IgvvvgCbdu21eyzbds2VK9eXe+PGqX4+/tj7NixsLGxQbdu3YxauHb+/PmoUaMGSpcujR49esDLywsvX77E8ePH8eTJE1y8eBGAHFxQu3ZteHt7I3v27Dhz5gw2bNiA/v37G3ysxD4bXVxcUqV0TkIlS5ZElSpVMHLkSLx9+xbZs2fH2rVrdZIac3NzLF68GI0aNULJkiXRpUsXuLm54enTp9i/fz8cHBzw77//JnlfzZs3x+bNm7XOvOTKlQtDhw7F1KlT0bRpUzRu3Bjnz5/Hjh07dE7BDRs2DFu2bEHTpk015U3CwsJw+fJlbNiwAQ8ePNC6TaFChVCjRg306dMHkZGRmDNnDnLkyKF1alN9dmLgwIHw8/ODhYWFwa2sKe0jVrp0adSrVw/lypWDs7Mzbt++jSVLliA6Oho//fSTzv67d+9Gs2bNDG/FM2iMpQGSU75i/fr1Wtv1DU2vVauWKFmypN7jREVFiWnTpomSJUsKa2tr4ezsLLy9vcWECRNESEiIEEKIvXv3iubNm4u8efMKKysrkTdvXtGuXTut4bWGxCOEEIGBgaJ8+fLC2tpaZM+eXXzzzTdaQ3CF0D80PTw8XAwcOFDkyJFDZM2aVTRr1kw8fvw4WeUrhBDi4cOH4ssvvxR2dnYiZ86cYtCgQZpyDkmVr9iwYYNo0KCBcHFxEVZWViJ//vyiV69e4vnz51rHX7RokfDy8hIWFhZaxzx69KioUqWKsLW1FXnz5hXff/+9+O+//3TuN7HXKmE8Qsgh1aNHjxYFChQQlpaWIk+ePKJ169bi7t27WvstXLhQeHt7C1tbW5EtWzZRunRp8f3334tnz55p9jFkCLn6tdb3V6tWLZ3916xZI8qWLSusra1F7ty5Rf/+/UVoaKjOfo8fPxatW7cWDg4Owt7eXjRt2lTcvn1bbwwLFy4URYsWFVZWVqJgwYJi9uzZWsPCU3LMhD6nfIUQQrx8+VL069dPuLu7a16fevXqiYULF2r2UalUYsqUKcLDw0NYW1uL8uXLi61bt+p9vd+8eSM6duwoHBwchKOjo+jYsaM4f/68UcpXPHnyRHz11VfCyclJODo6iq+//lo8e/ZM7+Pau3evKF++vOa5X7x4sfjuu++EjY2N1n7GLl+R8LNF7ezZs6Jy5cqa/8tZs2YlWa7Az89PODo6ChsbG1GwYEHRuXNncebMmU/G9rnlK/SVgqhVq5be/5nbt29r/qeOHDnyyftMSP0az5gxQ+/1d+/eFZ06dRJ58uQRlpaWws3NTTRt2lRs2LBBs8/kyZNFpUqVhJOTk7C1tRXFihUTP/74o4iKijL4WEIk/tlo7PIVST1mX19fzefQqFGjxO7du/W+R8+fPy9atmwpcuTIIaytrYWHh4do06aN2Lt37yfjOnfunACgUxYqNjZWTJgwQbi6ugpbW1tRu3ZtceXKFeHh4aHzvnr//r0YOXKkKFSokLCyshI5c+YU1apVEz///LPm+Y//eGfOnCnc3d2FtbW18PHxERcvXtQ6XkxMjBgwYIDIlSuXMDMz03yuJfWcJfc79VPGjRsnKlSoIJydnUWWLFlE3rx5Rdu2bcWlS5d09r1+/boAIPbs2WPw/Zj9P2giykTUhXD57/1pLVq0SLLUQWagnidx+fLlSodC6Vy9evU0BcNTy4MHD1CgQAHMmDEDQ4cOTbX7SUvffvstDh06hLNnzxrcIpZh+4gRERkqYf2127dvY/v27al2+pEoo5kyZQoCAwN1BgNQ4t68eYPFixdj8uTJKRpckGH7iBFR5hEVFaV3YE18jo6Onz2C1svLSzMv5cOHD/H777/Dysoq0eH2ZDyxsbGf7DBub2+fZIkFSn2VK1dOtN4h6ZcjRw69AySSi4kYESnu2LFjqFOnTpL7GKNDdMOGDbFmzRq8ePEC1tbWqFq1KqZMmaK3sCQZ1+PHjz9ZsHTcuHEYP3582gRElE4o2kfs0KFDmDFjBs6ePYvnz59j8+bNaNGiRZK3OXDgAIYMGYKrV6/C3d0dP/zwQ6qNViGitPHu3TucPXs2yX1Kliz5WdWxSVkRERFJzj4CyBbL+LWqiEyBoi1iYWFhKFu2LLp27apVDiAx9+/fR5MmTdC7d2+sWrUKe/fuRffu3eHq6ppodWQiSv+cnZ3TfbFS+jw2NjZ8jYn0SDejJs3MzD7ZIjZ8+HBs27ZNq9Bk27ZtERwcjJ07d6ZBlERERETGk6H6iB0/flznF5Wfn5/eWeDVIiMjtargq1QqvH37Fjly5FB86goiIiJKHiEE3r9/j7x58xq1ULDSMlQi9uLFC51JmNXzmYWHh+sdUTV16lRMmDAhrUIkIiKiVPT48WPky5dP6TCMJkMlYikxcuRIDBkyRLMeEhKC/Pnz4/Hjx3BwcFAwMiIiopQLDweio4HY2Li/kBDgyRPg1Svg6lXg5k3g0CGgaFG579WrgJ0dkIrTqAIA8uUDsmQBzM0BCwvgxQvAywvImhWwsQEKFJDXJfx7+RIoVgywt5e3z3/+H7yvWh8lvO3w4UMo6tVzR7Zs2VI3+DSWoRKxPHny4OXLl1rbXr58CQcHh0TrC1lbW8Pa2lpnu4ODAxMxIiJKcyoVEBEhk47372XS9OGDTJQePQIOHwZu3wZy5JDJVXQ0cPo04OoKxMTIdUPnwI4/nWr8JMzeHnBwACwtgYcPgVKlgKpVASsrmTxVrw6EhgIlS8qEKksWeRkbC+TNC9jayttmzQq4uMjrjSIsDOjXD1j5J2DdHeizCKGh8qrM1q0oQyViVatWxfbt27W27d69G1WrVlUoIiIiIl1CAJGRwJ49MtmKigIuXQJOnACOHUvZMZ8/T/p6dbcplUomV8WLy6SrWDGgShWgdGmZNFlbA25ugLMzkC4bl65cAdq0Aa5flw8qf375hGZSiiZiHz58wJ07dzTr9+/fx4ULF5A9e3bkz58fI0eOxNOnT7FixQoAQO/evTFv3jx8//336Nq1K/bt24d169Zh27ZtSj0EIiIyYaGhwOPHMul68gRo3lxuNzNLfu6QP79sCatcWSZG4eHyMn7yZGkpW5tcXeWlpaXcJ1u2uFaqDN9QJASwdCkwYIB8ElxdgdWrgUw+BZmiidiZM2e0qmmr+3IFBARg+fLleP78OR49eqS5vkCBAti2bRsGDx6MuXPnIl++fFi8eDFriBERkdGoVPIUYHAw8O4d8OCBTLju3JGn4qKjgWvXgD//TDzZSri9YUPZEvX4MdC0KdC7tzyVZ2GR2o8mg/jwQT4pq1bJ9QYNgJUr5ZOUyaWbOmJpJTQ0FI6OjggJCWEfMSIiEyaEPHU3ahTwyy9ym7m5TMQM5eYm+1U9fAh88QUQGBh36s9o/aYysydPgHLlZPY7eTLw/fdx51r/L7N+f/PtQUREmU5UlOyPdeOGbGy5fVtenjoFvHkjkzB988zrS8Jy5JC3KV9e3k59ujA4WJ5O7NdPdlanz5AvH7BmjWxyrFFD6WjSFBMxIiLKsISQ3YlevgQuXgR275anE9esSf4xsmSRpyJ/+w348kt5CjFLFnmZyIB8+lyhoUDPnkDbtoB6Rp369RUNSSlMxIiIKMMIDZV9szZvjquV9SleXkCZMrI/VsGCsoWrYEGgSBF5StHJSecsGKWms2cBf3/g7l1g/37ZH8zOTumoFMNEjIiI0hWVSpaRunxZ1r+6cweYPTv5t69dW57d+vprmYBROiEEMG8eMHSoPHfs4QGsXWvSSRjARIyIiBR0/76s/K5SAdu2ARs3Jv+2HTsCAQGyXlbu3ByBmK4FBwPdugGbNsn1Fi1kqQpnZyWjSheYiBERUaoSAjh+HFi4UJZ+MDOTpxTjV3tPSoUKQK1ast9Wz55yepwMXzPLlAQHy5EODx7IUQ4//yxrhfFFBMBEjIiIPlN4uEysVCpZJys0FDh5EsieXRY6nTXr08fIkUOeUrS2Br76CvDzk9Pv8Ls6E3ByAho1Av77T9b1qFBB6YjSFSZiRET0SWFhso91eLisAn/5siwPcfq0YccpVw5o1kyeSgTkvIZffGH0cElpb97IoajqF3rWLJmVOzoqG1c6xESMiMjExcbKBOvZM5lg3b0rW6KiooAffkj+cczNAXd3WdS0eXNZRqJKFVnoNFcuoH9/jk40CceOybIUhQrJeiIWFoCNjfwjHUzEiIgyqbAweTbo339l36z374EjR+Qk0IA8lXjihOHHrVwZuHcPKFoU8PEBfH1lHy52ljdxKhUwYwYwerTM7q2t5Uzl+fIpHVm6xkSMiCiDi4oCDh4EzpwBDhwAdu1KetLpY8c+fcyqVYGSJeOm55kyhQPcKAmvX8shrDt2yPV27YA//pBzPFGSmIgREWUAMTHylOHVq3JeZDs7mYBt3SrnS0wofhJWtixQogRQrZpstRICyJs3br+CBeWfjQ1btSgFDh+WpyKfPZNvol9+Abp350iLZGIiRkSkICGAkBA5Pc/Nm7LQeHCw/D6LiZHJ1q5dyT+ery+QM6f8XqxWDXBwkGeIiFJFbCzQt69MwooVA9atk5NxUrIxESMiSmPPn8sC49evy6l6DOXuLjvAf/utvMybV1YHYGsWpTkLCzmx59y5cvoDe3ulI8pwmIgREaWyqCjg0iXZN+vvv2WrV2KKFZPJVfv2cqRhlizyr3BhWRMzCz+1SWn79gG3bwO9esn1UqWARYuUjSkD4780EVEqiIkBfvsNGDQo8X3y5wfatAFatpRlHtilhtK12Fhg4kRg0iTZEubtzeKsRsBEjIjISObMkXW3wsIS36dwYTk34qhRsgwEUYbw7BnwzTdyWC4AdO4sR4DQZ2MiRkRkgNBQ2Xl+40Y5c8vGjbJzfXR04rdZsUKO5udpRcqQ/vtPzrD++rXsA/bHH/LcORkFPxaIiBIhBLB0KXDjhiyKevNm8m43fjzQo4fs42VpmaohEqWu8eOBCRPkctmyclRkkSKKhpTZMBEjIkogLCx5g798fICmTWVn/HLlgEqVABeXVA+PKO04OcnL3r3lqEhOU2R0TMSIyOSFhMialE+eyM71UVG6+/TpIy/795cjGzlnImVaYWFA1qxyedAgOVy3Vi1lY8rEmIgRkUl6+lQWAJ8+Pen9nj8H8uRJm5iIFBUdLUeRbNki58vKlk0O5WUSlqr4m46ITMbjx0C3bvK7JV8+/UlYtWrydOOjR7KPGJMwMgkPHwI1awI//wzcuiUL3lGaYIsYEWVa9+8DZ88CS5YAO3fq38fBARg8GBg9mh3ryUT9848sRxEcDDg6yhEqLVsqHZXJYCJGRJmCEMDLl8Dy5cDIkUnvW6kSMGYM0KQJi6iSCYuKAr7/Xk5PBMh/jLVrgQIFlI3LxDARI6IM78ULwNU18esLFAAqVgS6dgX8/NIuLqJ0bfjwuCTsu++AKVPk/FqUpthHjIgytB9/1J+ETZwo608KAdy7BwQGMgkj0jJiBFCypOyc//PPTMIUwhYxIspQ3r+XLVsbNuheN2qUTMyISI+ICGDzZjnNAwDkzi1no2ctFkUxESOidEkIWZ3+0SNg927Ay0uWN3r5Uv/+u3cDvr5pGyNRhnH7tpxh/sIFua5OxpiEKY6JGBGlK0+fyvIR6u8LtXv3dPedOlVOeZc/f5qERpQxrVkD9OwJfPgA5MwJZM+udEQUDxMxIlJUcLAsMXHmDDB/vqz1ldD69YCFhUy4rKzkVHfW1mkeKlHGEh4uK+MvWiTXa9YEVq8G3NyUjYu0MBEjojQXFSXrdv36KxAZqX+fRo2AyZOBL75I29iIMoUbN+SpyMuXZY2W0aOBceOALPzaT2/4ihBRqnvxAti3TxZVjYiQLVwJeXgAb94AQ4YAY8fKFjAiSqG7d2US5uICrFrFDpTpGBMxIjK6V6+AqlVll5RXrxLfz8oKWLAA6NCBVe2JjKpJE3lKskmTpIvskeKYiBFRit24IUcxfved7FwfG5v0/uXKAc7OQOPGQJkyQIMGaRElkQm4ehXo3Rv46y/ZvAwA3bsrGxMlCxMxIkq26Gg5UnH5cjmP46cUKyanscuWjT/KiVKFEMCyZUD//rJz/rffylphlGEwESOiRIWEAFeuyMtdu+JmQ0koXz7gyRPZ+b5mTTm60dGR8zgSpaoPH2Qr2KpVcr1BA+CPP5SNiQzGRIyINHbskJ/p0dHA/v1yiiB9SpeW1e3r1pWnGIkojV28KEdF3rolR7ZMmiTnjmSB1gyHiRiRCXv1Cjh4UPbvmjIl6X1r1JBV7qdPB/z90yQ8ItLn8GGgfn1Z+8XNDVi7Vv6DUobERIzIBF24AJQvn/j1/v5AlSpApUpA5cosJUGUrlSsKDtgurkBf/4pq+VThsVEjMhEPH0KnDsHjBkjz2ok1KOHPNXo78++XUTpzvXrckoJCwvAxgbYs0dOVcRTkRkeX0GiTOzcOaBfP5lY5csHfPmldhLWv78cdCUEsHAh0LYtkzCidEUIYN48Wfvlxx/jtufMySQsk2CLGFEmERsrS0U8fQr8/besZK9PwYJA1qzA9u2cco4oXQsOBrp1AzZtkusXLwIqFROwTIaJGFEGJoRMqEaP1n+6Ua14cVnpfsYMeTaDiNK5U6dkP4EHD+S0EzNmAAMHssk6E2IiRpTBfPwIjBwp++iGhOjfp2tXwMlJDqzy8+NnN1GGIQQwZ44sRREdDRQoAAQGyg76lCkxESPKICIjgdOnAR8f/dcPGyY74mfLlrZxEZER3b8PjBolk7BWrYDFi+WvKsq0mIgRpVNRUcCJE8DWrXIGk6Ag7euLFgVWr5Z9vhwdlYmRiIzMywuYP19OV9S3L5uzTQATMaJ05ONH2cn+9Glg4kT9+7i4yGmE1q9P29iIKBWoVMDMmbKpu0oVua1rV2VjojTFRIxIYdu2ybMPb98Chw7pXl+gAODhIUtPdO3K1i+iTOP1ayAgQM4t5uEhJ3a1t1c6KkpjTMSIFPD6tTzrsGGD/uuLFpWnHH/4QY52JKJM5tAhoF074NkzWaB19GhZV4ZMDhMxojT28CHg6am7vV07ecqxdWvOWEKUaalUwNSpwNixcrloUWDdOqBMGaUjI4UwESNKZYcPy+mD7O2Bs2d1r9+7F6hVi/M5EmV6Hz4ALVsCu3fL9Y4dgd9+4+lIE8dEjCgVvH0LLFki633Fxurfp0wZmZhl4X8hkWnImhWwtZV/v/0GdO6sdESUDvArgMhIoqPl5+rq1fqvr1NH1vny8JAj1InIBMTGylo0trayFMWyZcCLF0CJEkpHRukEEzEiI9i4UfbtSih3btnhXj3xNhGZkOfPgfbt5aSuK1fKD4Hs2TnPGGlhIkaUQhERwNChsvZiQidOAJUrp31MRJRO7NoFdOggh0hnzQrcuyeHQhMlwCnciVLIz083CVu3Tk4VxySMyETFxMhSFA0byiSsTBngzBkmYZQoJmJEKbBnj3bx1V9+kZ+/X3+tXExEpLAnT4C6dYEpU+Qvsl69ZPN4sWJKR0bpGE9NEhkgIkL2uY3vzRt2+SAyeSoV0KiRrI6fLRuwaBHg7690VJQBMBEjSkJUFHD0KHDpklz+/nvt65cuZRJGRADMzYE5c4ARI4A1a4BChZSOiDIIJmJEeqhUskvHgwf6r3d2Bh4/5owkRCbt0SPgxg2gQQO5Xq8ecPKkTMqIkonvFqL/U6mAf/4BKlWSVe4TJmEFCshBUKNGyYKtTMKITNiWLUC5crJuzZ07cduZhJGB2CJGJi0mBjhwQE5DNHGi/n3CwgA7uzQNi4jSq6goYPhweRoSACpW5PQY9FkUT93nz58PT09P2NjYoHLlyjh16lSS+8+ZMwdFixaFra0t3N3dMXjwYERERKRRtJRZqFRy8m1LS6B+fd0krG5d4OVLOfCJSRgRAQDu3wdq1IhLwgYPBo4cATw9lYyKMjhFE7HAwEAMGTIE48aNw7lz51C2bFn4+fnh1atXevdfvXo1RowYgXHjxuH69etYsmQJAgMDMWrUqDSOnDKqjx/liHILC93PzlKlZPkfIeRE3C4uioRIROnRxo1A+fLA6dOyk+g//wCzZgFWVkpHRhmcou2ps2bNQo8ePdClSxcAwIIFC7Bt2zYsXboUI0aM0Nn/2LFjqF69Otq3bw8A8PT0RLt27XDy5Mk0jZsynqAgoEIF2QqWULlywPnzaR4SEWUkx44BISFA1arA2rVA/vxKR0SZhGItYlFRUTh79ix8fX3jgjE3h6+vL44fP673NtWqVcPZs2c1py/v3buH7du3o3HjxoneT2RkJEJDQ7X+yHSEhcnp3XLl0k7C7OyAbdvkKUomYUSklxBxy1OnAnPnAgcPMgkjo1IsEQsKCkJsbCxy586ttT137tx48eKF3tu0b98eEydORI0aNWBpaYmCBQuidu3aSZ6anDp1KhwdHTV/7u7uRn0clD4FB8t+Xvb2utfduCETtMaNORE3ESVi7Vr5IREdLdetrICBA2XHUiIjUryzviEOHDiAKVOm4LfffsO5c+ewadMmbNu2DZMmTUr0NiNHjkRISIjm7/Hjx2kYMaW16GiZfDk7A/v3x21v1ky2fgkBFC2qXHxElM6Fh8uOpO3aATt3ygr5RKlIsT5iOXPmhIWFBV6+fKm1/eXLl8iTJ4/e24wZMwYdO3ZE9+7dAQClS5dGWFgYevbsidGjR8NcT/0Wa2trWFtbG/8BULoTHg44OMiSFGq2tsCFC0CRIoqFRUQZxc2bQJs2cioNMzNZNLBnT6WjokxOsRYxKysreHt7Y+/evZptKpUKe/fuRdWqVfXe5uPHjzrJloWFBQBAxD+XTybn0CHZ70udhBUuLFvAPn5kEkZEyfDXX4C3t0zCXFyA//4DJk9mjTBKdYq+w4YMGYKAgABUqFABlSpVwpw5cxAWFqYZRdmpUye4ublh6tSpAIBmzZph1qxZKF++PCpXrow7d+5gzJgxaNasmSYhI9Nx544cUa5ngC1u3mT/LyJKph9/BH74QS7XqQOsWgW4uiobE5kMRRMxf39/vH79GmPHjsWLFy9Qrlw57Ny5U9OB/9GjR1otYD/88APMzMzwww8/4OnTp8iVKxeaNWuGH3/8UamHQAqIjZX9wPTV8V27FvD3T/uYiCgDa90amD4dGDJEJmT8YU9pyEyY2Dm90NBQODo6IiQkBA4ODkqHQwYKCQGcnLS3+frKOXcHDWJtRSJKBiHkKciyZeO2vXkD5MihXEz0SZn1+5snvylDSZiERUVxNDkRGeDDB6BPH2D1amDfPqBWLbmdSRgpJEOVryDTdfmydp8vDw/5o5ZJGBEl26VLcoqNv/6S61euKBsPEZiIUTp37hyQMydQpoz29tu3lYmHiDIgIYCFC4FKleRIHjc34MABoF8/pSMjYiJG6Y9KBcybJ1vAvL1l1w21ypXl9WwJI6JkCQ0F2reXRVojI4FGjWRxQR8fpSMjAsA+YpSOCAGcPQtUrKh7nY8PsGmTbB0jIkq2f/6Rw6ktLOR8kd99B+gp/k2kFCZilC7s2wfUq6e7fdw4+ceaYESUIh06AOfPA19/DSRSLJxISfxZQIrbvFk3CZs/X7aQjR/PJIyIDBAcDPTvD7x7J9fNzIBZs5iEUbrFFjFS1LRp2pXx16wB2rZVLh4iysBOn5YVne/fB4KC5ClJonSOiRgpQgigeXPg33/jtm3bBjRurFxMRJRBCQHMnQt8/z0QHQ0UKCD7ghFlAEzEKM2dOydHQ8Z38aJuiQoiok96+xbo0gXYskWut2oFLF6sW/2ZKJ1iHzFKU6NG6SZhISFMwogoBS5fBsqXl0mYlZWse7N+PZMwylCYiFGaCAsDPD3l6HG1iRPlGYVMNGUYEaWlvHnlh0jBgsDx47JAK0f3UAbDU5OU6t6+1Z3G7fFjIF8+ZeIhogzs/XvA3l4mXDlyADt2AO7u/EVHGRZbxChVvXunm4Q9f84kjIhS4PBhoHhxYPnyuG0lSzIJowyNiRilCiGA7duB7NnjttWsKbfnyaNcXESUAalUwJQpQJ06wNOnwK+/ArGxSkdFZBQ8NUlG9/o14OKiva1GDeDgQWXiIaIM7NUrWR1/92653qED8PvvcsoiokyALWJkdAmTsObN5RkFIiKD7N8PlC0rkzBbW2DJEmDFCtlHjCiTYIsYGdWCBXHLvr5xP2KJiAzy8CHQoAEQEwOUKAGsWyf7gxFlMkzEyCiiouRsIn36xG3bsUO5eIgog/PwAEaOBJ48kX3CsmZVOiKiVMFEjD5bTAxgba297fp1IAvfXURkiD17ZMHBQoXk+oQJrAtGmR77iNFnEQKwsdHetngxUKyYMvEQUQYUEwP88IM8FenvD0RGyu1MwsgEsM2CUmzXLsDPT3tbTAwHMxGRAZ4+Bdq1ixvRU7Gi/IVHZCKYiFGKlCwJXLumvY1JGBEZZMcOoFMnICgIyJYNWLgQaNtW6aiI0hRPTZLB6tXTTsJ++UX+gGUSRkTJEh0NDB8ONG4sk7Dy5YGzZ5mEkUliixgZZOxYYN++uHWVit04iMhAQsgaYYCcqPvnn3U7mxKZCCZilGwHDgCTJsWtf/jAJIyIDCCE/NCwsgICA4Fz54BWrZSOikhRTMQoWZYuBbp1i1u/fZtlfYgomaKigBEjZKvXlClyW4EC8o/IxDERo08KCdFOwlasiCvzQ0SUpPv3Zd+vU6dka1inTqxvQxQPO+tTkiZNApyc4taPHwc6dlQsHCLKSDZtkh3xT52SHySbNzMJI0qALWKUqGHDZB9aNU9PoEoVxcIhoowiMhIYOhSYN0+uV6ki50Dz8FA2LqJ0iIkY6fX339pJ2I0bQNGiioVDRBmFELJC/qFDcv3774HJkwFLS2XjIkqnmIiRXl99Fbd8+zb7hBFRMpmZAd27A1evyg6ljRsrHRFRusY+YqQj/uwi48YxCSOiTwgPB65fj1vv2BG4dYtJGFEyMBEjHR06xC1/951ycRBRBnDzpuwD5usLvH4dtz17duViIspAmIiRFiGA1avj1rNlUy4WIkrn/voL8PYGLl2S0xbdv690REQZDhMx0lK7dtzymTOKhUFE6dnHj7K4YMeOQFiY/OC4cAGoVEnpyIgyHCZipLF6ddxAJwD44gvlYiGidOraNZlwLV0qO+aPGwfs2QPkzat0ZEQZEkdNEgDg4UPgm2/i1u/f5zySRKTHtGlyRGSePMCqVUDdukpHRJShMREjAEDhwnHLK1bI4q1ERDp++QXIkkXOGZk7t9LREGV4PDVJCA2V/WwBOSUcpzAiIo3Ll+U0G+q6No6OwJIlTMKIjIQtYiYuNhaoUCFu/c8/lYuFiNIRIYDFi4GBA4GICDm1RvfuSkdFlOkwETNhHz8CWbPGrefJA1hZKRcPEaUToaFAr15yfkgAaNQIaN5c2ZiIMimemjRhCxZor1+9qkwcRJSOnD8va4OtXQtYWMjO+Vu3ArlyKR0ZUab0WS1iERERsLGxMVYslIaEkJ+vAJAjBxAUpGw8RJQOrFwpTz9GRQHu7jIZq1ZN6aiIMjWDW8RUKhUmTZoENzc32Nvb4969ewCAMWPGYMmSJUYPkFLHTz8Br17J5cGDlY2FiNKJAgVkx9FmzWSBViZhRKnO4ERs8uTJWL58OaZPnw6reB2KSpUqhcWLFxs1OEodDRsCo0bFrTMRIzJhISFxyzVqAMePA//8w7kiidKIwYnYihUrsHDhQnzzzTewsLDQbC9btixu3Lhh1OAodfz3X9zy3r2AnZ1ysRCRQoQA5s6VRQOvXYvbXrEiqzkTpSGDE7GnT5+iUKFCOttVKhWi1cWoKN06cSJu+eJFFsUmMklv3wJffQV8+y0QHAwsX65wQESmy+BErESJEjh8+LDO9g0bNqB8+fJGCYpSzx9/xC2XKaNcHESkkBMngPLl5elHKyvg11/jRu4QUZozeNTk2LFjERAQgKdPn0KlUmHTpk24efMmVqxYga1bt6ZGjGQkMTFxP3x79lQ0FCJKayoVMGsWMHKk/DAoWBAIDJSlKohIMQa3iDVv3hz//vsv9uzZg6xZs2Ls2LG4fv06/v33X9SvXz81YiQjUKkAS8u49bZtlYuFiBTw119yqqKYGKBNG+DsWSZhROmAmRDqCcRMQ2hoKBwdHRESEgIHBwelw0kz69fLz14AqF0b2L9f0XCIKK3FxABNmsi+Yb16sUM+ZTiZ9fvb4BYxLy8vvHnzRmd7cHAwvLy8jBIUGZdKFZeEAUzCiEyCSiXnioyMlOtZsgA7dwK9ezMJI0pHDE7EHjx4gNjYWJ3tkZGRePr0qVGCIuPati1umYOjiEzAq1dyfsgePYDhw+O2MwEjSneS3Vl/y5YtmuX//vsPjo6OmvXY2Fjs3bsXnp6eRg2OjGPMmLjlgADl4iCiNHDgANC+PfD8OWBry+HRROlcshOxFi1aAADMzMwQkODb3NLSEp6enpg5c6ZRgyPjuHhRXnbsqGwcRJSKYmOBH38EJkyQpyWLF5edQ0uWVDoyIkpCshMxlUoFAChQoABOnz6NnDlzplpQZDzxh2KwNYwok3rxAvjmG2DfPrnepYusD5Y1q7JxEdEnGVxH7P79+6kRB6WS16/jlitWVC4OIkpFHz8CZ87I+coWLGDzN1EGYnAiBgBhYWE4ePAgHj16hKioKK3rBg4caJTAyDjid87PRKN9iUiIuM73Xl7AunWAhwdQrJiycRGRQQyuI3b+/Hk0btwYHz9+RFhYGLJnz46goCDY2dnBxcUF9+7dS61YjSKz1iHR5+PHuDMTHh7AgweKhkNExvL0KdChg6yS36CB0tEQpYnM+v1tcPmKwYMHo1mzZnj37h1sbW1x4sQJPHz4EN7e3vj5559TI0ZKoalT45Z//FG5OIjIiHbuBMqVk6Mj+/aVhVqJKMMyOBG7cOECvvvuO5ibm8PCwgKRkZFwd3fH9OnTMWrUqNSIkVLg7l1g8mS5bGUl+/ESUQYWHQ2MGCHrgwUFyWRs+3ZZqJWIMiyDEzFLS0uYm8ububi44NGjRwAAR0dHPH782OAA5s+fD09PT9jY2KBy5co4depUkvsHBwejX79+cHV1hbW1NYoUKYLt27cbfL+ZXaFCccuHDikXBxEZwePHcm6yadPket++wPHjQJEiioZFRJ/P4J9S5cuXx+nTp1G4cGHUqlULY8eORVBQEFauXIlSpUoZdKzAwEAMGTIECxYsQOXKlTFnzhz4+fnh5s2bcHFx0dk/KioK9evXh4uLCzZs2AA3Nzc8fPgQTk5Ohj6MTC06Om65enWgcmXlYiGiz/T0qWz9evtWjrhZsgRo3VrpqIjISAzurH/mzBm8f/8ederUwatXr9CpUyccO3YMhQsXxpIlS1CuXLlkH6ty5cqoWLEi5s2bB0DWKnN3d8eAAQMwYsQInf0XLFiAGTNm4MaNG7C0tDQkbI3M2tkvvv37gbp15XJ0NM9cEGV4nTsDV68CgYFyhCSRCcqs398GJ2LGEhUVBTs7O2zYsEFTtR8AAgICEBwcjH/++UfnNo0bN0b27NlhZ2eHf/75B7ly5UL79u0xfPhwWFhYJOt+M+sLGV/t2sDBg0DOnNp1xIgog3jwALC3l//EgBwCbWEBWFsrGhaRkjLr97fBfcQSc+7cOTRt2jTZ+wcFBSE2Nha5c+fW2p47d268ePFC723u3buHDRs2IDY2Ftu3b8eYMWMwc+ZMTFb3StcjMjISoaGhWn+Z3c2b8vLbbxUNg4hSYvNmeSoyIEBOVQTIQq1MwogyJYMSsf/++w9Dhw7FqFGjNPXCbty4gRYtWqBixYqaaZBSi0qlgouLCxYuXAhvb2/4+/tj9OjRWLBgQaK3mTp1KhwdHTV/7u7uqRqj0m7flrOdAMCXXyobCxEZIDISGDgQaNkSCAkB3ryRl0SUqSU7EVuyZAkaNWqE5cuXY9q0aahSpQr++usvVK1aFXny5MGVK1cMGr2YM2dOWFhY4OXLl1rbX758iTx58ui9jaurK4oUKaJ1GrJ48eJ48eKFToV/tZEjRyIkJETzl5KRnRlJ/fpxy8WLKxcHERng7l05subXX+X60KHA4cOAs7OycRFRqkt2IjZ37lxMmzYNQUFBWLduHYKCgvDbb7/h8uXLWLBgAYob+K1vZWUFb29v7N27V7NNpVJh7969qFq1qt7bVK9eHXfu3NFqebt16xZcXV1hZWWl9zbW1tZwcHDQ+svM1Hmmhwc76RNlCOvWAeXLA2fPAjlyAFu3AjNmACkckEREGUuyE7G7d+/i66+/BgC0bNkSWbJkwYwZM5AvX74U3/mQIUOwaNEi/Pnnn7h+/Tr69OmDsLAwdOnSBQDQqVMnjBw5UrN/nz598PbtWwwaNAi3bt3Ctm3bMGXKFPTr1y/FMWQmd+7EdSkZN07ZWIgoGSIi5DRF79/LFrELF4AmTZSOiojSULLbTMLDw2FnZwcAMDMzg7W1NVxdXT/rzv39/fH69WuMHTsWL168QLly5bBz505NB/5Hjx5piscCgLu7O/777z8MHjwYZcqUgZubGwYNGoThw4d/VhyZxVdfxS3/P2cmovTMxkaWpNi8GZgwgc3YRCYo2eUrzM3NMXnyZNjb2wMAhg8fjmHDhiGnenj1/w0cOND4URpRZh3+CgBlywKXLskZUDjZAFE6tXq1LEfRvbvSkRBlKJn1+zvZiZinpyfMzMySPpiZmWY0ZXqVWV9IIQB14+Hx40CVKsrGQ0QJfPwIDBoELF4sJ4C9cIEjaogMkFm/v5PdDv7gwYNUDIM+15EjccseHsrFQUR6XL8OtGkDXLkCmJnJfmGcJ5KIkIK5Jil9qlkzbvkzu+4RkTH9+aecpPvjRyB3bnlqUj0HGRGZPCZimcCFC3HLLVsqFgYRxScE0KOHnKQbAHx9gb/+kskYEdH/GW2KI1JOtWpxy+vXKxcHEcVjZiYn6DY3ByZNAnbuZBJGRDrYIpbBCQGEh8vlmjXjOuwTkQKEkNMSOTnJ9REjgIYNgS++UDQsIkq/+LWdwd24Ebe8YoVycRCZvPfvgW++AXx8ZH8wQP4yYhJGRElIUSJ29+5d/PDDD2jXrh1evXoFANixYweuXr1q1ODo0w4ciFvmaEkihVy4AHh7A2vWyBGShw4pHRERZRAGJ2IHDx5E6dKlcfLkSWzatAkfPnwAAFy8eBHjOK9OmuvbV+kIiEyYEMDvv8vCfbdvA+7uMglr2FDpyIgogzA4ERsxYgQmT56M3bt3a020XbduXZw4ccKowVHS9uyJW27cWLk4iExSSAjg7y9/DUVGAs2aAefPa4+eISL6BIMTscuXL+Or+JMa/p+LiwuCgoKMEhQlT/36cctr1igXB5FJ6t9fDlPOkgWYORP45x8gRw6loyKiDMbgRMzJyQnPnz/X2X7+/Hm4ubkZJSj6tJ0745Y3bAAy0WwPRBnD1KmyX9iRI8CQIbJcBRGRgQxOxNq2bYvhw4fjxYsXMDMzg0qlwtGjRzF06FB06tQpNWIkPUaPjltu1Uq5OIhMxrt3skq+Wr58wOnTQOXKysVERBmewYnYlClTUKxYMbi7u+PDhw8oUaIEatasiWrVquGHH35IjRhJj7t35WWHDsrGQWQSTp4EypcHOneWpyDV2ApGRJ/J4IKuVlZWWLRoEcaMGYMrV67gw4cPKF++PAoXLpwa8ZEeQgBhYXK5a1dlYyHK1IQAZs2ShVljYoCCBWVLGBGRkRiciB05cgQ1atRA/vz5kT9//tSIiT5h1y75nQDILipElArevJEtYFu3yvU2bYBFi9ghk4iMyuBTk3Xr1kWBAgUwatQoXLt2LTViok+IX6LI3l65OIgyraNHgXLlZBJmbS1rha1dyySMiIzO4ETs2bNn+O6773Dw4EGUKlUK5cqVw4wZM/DkyZPUiI8SiF8hZNIkzi1JlCqePQOePAEKFwZOnAB692Z/MCJKFWZCCJHSG9+/fx+rV6/GmjVrcOPGDdSsWRP79u0zZnxGFxoaCkdHR4SEhMAhA/66nTABGD9eLkdHyxJGRGQEQmgnW3/+CbRsCWTLplxMRKSR0b+/E/NZ7SkFChTAiBEj8NNPP6F06dI4ePCgseKiRPz3n7wsWpRJGJHRHDwoO1zGr5EYEMAkjIhSXYoTsaNHj6Jv375wdXVF+/btUapUKWzbts2YsVECHz4Ax4/L5W7dlI2FKFOIjZXn+OvWldMTjR2rdEREZGIMblMZOXIk1q5di2fPnqF+/fqYO3cumjdvDjs7u9SIj+I5eTJuuV075eIgyhRevJCF+PbuleudOwNz5igZERGZIIMTsUOHDmHYsGFo06YNcubMmRoxUSK++05eurqylBHRZ9m7F/jmG+DlS8DOTo6K5MwgRKQAgxOxo0ePpkYclAwXL8rLXLmUjYMoQ9u8Wc4LJgRQqhSwbh1QvLjSURGRiUpWIrZlyxY0atQIlpaW2LJlS5L7fvnll0YJjLTFH9s6b55ycRBlePXry9EuPj7A3LmAra3SERGRCUtW+Qpzc3O8ePECLi4uME+icJWZmRliY2ONGqCxZdThr6tXyzMpABASwrqSRAY5fVqOilR/foWEAI6OysZERAbJqN/fn5KsUZMqlQouLi6a5cT+0nsSllFFR8clYQCTMKJki4kBRo4EKlWSc0aqMQkjonTC4PIVK1asQGRkpM72qKgorFixwihBkbb4NXLV094R0Sc8fgzUrg389JNc5+wfRJQOGZyIdenSBSEhITrb379/jy5duhglKNK2eXPccpMmysVBlGFs2ybnijx6VDYhr1/P0hRElC4ZnIgJIWCmZ861J0+ewJHN/anizBl5Wbu2omEQpX9RUcDQoUDTpsDbt0CFCrJQa+vWSkdGRKRXsstXlC9fHmZmZjAzM0O9evWQJd78OrGxsbh//z4aNmyYKkGaurNn5WXLlsrGQZTuXb8O/PKLXB40CJg2DbC2VjYmIqIkJDsRa9GiBQDgwoUL8PPzg729veY6KysreHp6olWrVkYP0NTduxe3XKmScnEQZQhly8r6Li4uwP8/s4iI0rNkJ2Ljxo0DAHh6esLf3x82NjapFhTFOXIkbpmJGFECkZHAqFFAx46yTxgA9OypaEhERIYwuLJ+QEBAasRBiYiKkpdFiwJ6uuYRma67dwF/f3nufutW4MoVwNJS6aiIiAySrEQse/bsuHXrFnLmzAlnZ2e9nfXV3r59a7TgSJZAAoDSpZWNgyhdWb8e6N4dCA0FsmeXNcKYhBFRBpSsRGz27NnIli2bZjmpRIyMJzgYCAqSy0WLKhoKUfoQEQEMGSIn6QaA6tWBNWsAd3dl4yIiSqFkTXGUmWSUKRKuXNFuBQsNBf6fCxOZptevgQYNgAsX5PrIkcDEiUAWg3tYEFEGlFG+vw1lcB2xc+fO4fLly5r1f/75By1atMCoUaMQpe7QRJ9t6tS45QEDmIQRIXt2IGdOIFcuYOdOYMoUJmFElOEZnIj16tULt27dAgDcu3cP/v7+sLOzw/r16/H9998bPUBTpS7i2qhRXFkkIpPz8SMQHi6XLSyAVatki5ifn6JhEREZi8GJ2K1bt1Du/8PE169fj1q1amH16tVYvnw5Nm7caOz4TJJKBfw/10XjxsrGQqSY69eBypWBb7+N2+biAuTNq1hIRETGlqIpjlQqFQBgz549aPz/TMHd3R1B6p7l9Fk6doxbbtRIuTiIFPPnn3J6oitXgH/+kf3DiIgyIYMTsQoVKmDy5MlYuXIlDh48iCb/n4X6/v37yJ07t9EDNDWxscDq1XI5Tx6gYEFl4yFKU2FhQOfO8u/jR6BePXkqMlcuhQMjIkodBidic+bMwblz59C/f3+MHj0ahQoVAgBs2LAB1apVM3qApuaff+KWT51SLg6iNHflClCxomwNMzcHJk0C/vtP/iIhIsqkjFa+IiIiAhYWFrBM50UV0/Pw16go7fmJTauwCJm0qCjZ/PvkiewDtno1UKuW0lERUTqSnr+/P0eKx36fPXsW169fBwCUKFECX3zxhdGCMlUNG8Yt796tXBxEac7KCliwAJg/X7aI8VQkEZkIgxOxV69ewd/fHwcPHoSTkxMAIDg4GHXq1MHatWuRix+gKaYeKenhAfj6KhsLUaq7eBF49QqoX1+uN2kihwlz5g4iMiEG9xEbMGAAPnz4gKtXr+Lt27d4+/Ytrly5gtDQUAwcODA1YjQZT5/Ky507lY2DKFUJIVu/KleWk3Y/ehR3HZMwIjIxBreI7dy5E3v27EHx4sU120qUKIH58+ejQYMGRg3OlDx5ErfMRkXKtEJCgJ49gXXr5Hr9+kDWrMrGRESkIINbxFQqld4O+ZaWlpr6YmS4KVPilnPkUC4OolRz9izwxRcyCcuSBZg5E9iyhW94IjJpBididevWxaBBg/Ds2TPNtqdPn2Lw4MGoV6+eUYMzJbGx8tLNTdk4iFLFr78C1aoB9+7JTpBHjgBDhvBUJBGZPIMTsXnz5iE0NBSenp4oWLAgChYsiAIFCiA0NBS//vprasRoEo4elZeDBysbB1GquHpVlqho0QI4f172DyMiIsP7iLm7u+PcuXPYu3evpnxF8eLF4cthfp/l6lV5aWGhbBxERiNEXIvX7NmyRaxjR7aCERHFY1AiFhgYiC1btiAqKgr16tXDgAEDUisuk3LxYtwyJ/mmDE8ImXjt3g1s3Sp/XdjaAp06KR0ZEVG6k+xE7Pfff0e/fv1QuHBh2NraYtOmTbh79y5mzJiRmvGZhAsX4paLFFEsDKLP9+aNnCdy61a5vmkT8PXXioZERJSeJbuP2Lx58zBu3DjcvHkTFy5cwJ9//onffvstNWMzGYsXy0svL2XjIPosx44B5cvLJMzaGvj9d6B1a6WjIiJK15KdiN27dw8BAQGa9fbt2yMmJgbPnz9PlcBMyZEj8rJqVWXjIEoRlQqYNg2oWRN4/BgoXBg4cQLo3Zv9wYiIPiHZiVhkZCSyxiu8aG5uDisrK4SHh6dKYKbi4MG45REjlIuDKMUGDpRv3thYoH17WS+sXDmloyIiyhAM6qw/ZswY2NnZadajoqLw448/wtHRUbNt1qxZxovOBNSpE7dcqpRycRClWM+ewJo1wPTpQNeubAUjIjJAshOxmjVr4ubNm1rbqlWrhnv37mnWzfgBbJDoaDnADJDdaYgyhNhY4MyZuFpgZcoADx4A2bIpGhYRUUaU7ETswIEDqRiGadq7N265e3fl4iBKtpcvgQ4dgAMHZOdGdTLGJIyIKEUMrqxPxvP6ddxyFoNL6xKlsX37gLJlgT17ACsr7ZnqiYgoRZiIKSgyUl42a6ZsHERJio0Fxo0DfH1li1ipUvLUZKtWSkdGRJThsR1GQa9eyUtra2XjIErUs2fAN9/IU5GAPIc+dy4Qb9AOERGlXLpoEZs/fz48PT1hY2ODypUr49SpU8m63dq1a2FmZoYWLVqkboCpQKUCRo+Wy7a2ysZClKhNm2QSZm8PrFoFLFrEJIyIyIgUT8QCAwMxZMgQjBs3DufOnUPZsmXh5+eHV+rmokQ8ePAAQ4cOhY+PTxpFalxHj8Ytd+6sWBhESevXDxg6VNYGa99e6WiIiDKdFCVihw8fRocOHVC1alU8ffoUALBy5UocUZeIN8CsWbPQo0cPdOnSBSVKlMCCBQtgZ2eHpUuXJnqb2NhYfPPNN5gwYQK8MuC8QELIIuSAnA+5bl1l4yHSePJE/jJ4/16um5kBM2ZwElQiolRicCK2ceNG+Pn5wdbWFufPn0fk/3uch4SEYMqUKQYdKyoqCmfPnoWvr29cQObm8PX1xfHjxxO93cSJE+Hi4oJu3boZGn66EP9patNGuTiItGzbJivi//kn8N13SkdDRGQSDE7EJk+ejAULFmDRokWwtLTUbK9evTrOnTtn0LGCgoIQGxuL3Llza23PnTs3Xrx4ofc2R44cwZIlS7Bo0aJk3UdkZCRCQ0O1/pT2889xy8uWKRcHEQBZWXjYMKBpU+DNG8DbGxg+XOmoiIhMgsGJ2M2bN1FTfV4tHkdHRwQHBxsjpkS9f/8eHTt2xKJFi5AzZ85k3Wbq1KlwdHTU/Lm7u6dqjJ8SGwuon6YZMzhikhT28KE8T67+dTBwoOzAWLCgsnEREZkIg8tX5MmTB3fu3IGnp6fW9iNHjhjcXytnzpywsLDAy5cvtba/fPkSefLk0dn/7t27ePDgAZrFK7ylUqkAAFmyZMHNmzdRMMEXyMiRIzFkyBDNemhoqKLJWPypjHr0UCwMIuDwYeDLL+UvAycn2TybAUcgExFlZAa3iPXo0QODBg3CyZMnYWZmhmfPnmHVqlUYOnQo+vTpY9CxrKys4O3tjb3x5vpRqVTYu3cvqlatqrN/sWLFcPnyZVy4cEHz9+WXX6JOnTq4cOGC3gTL2toaDg4OWn9K2rIlbjneXOlEaa9wYdkkW7kycP48kzAiIgUY3CI2YsQIqFQq1KtXDx8/fkTNmjVhbW2NoUOHYsCAAQYHMGTIEAQEBKBChQqoVKkS5syZg7CwMHTp0gUA0KlTJ7i5uWHq1KmwsbFBqVKltG7v5OQEADrb06OYGGD3brncu7eysZCJevMGyJFDLufJI2uEeXnJKYuIiCjNGZyImZmZYfTo0Rg2bBju3LmDDx8+oESJErC3t09RAP7+/nj9+jXGjh2LFy9eoFy5cti5c6emA/+jR49gbq54uTOj+PHHuGV1MVeiNLNhA9CtG7BwIeDvL7cVK6ZsTEREJs5MCCGUDiIthYaGwtHRESEhIWl+mrJ2beDgQSBrVuDDhzS9azJlERGyHMVvv8n1Ro1kqQozM2XjIiIygJLf36nJ4BaxOnXqwCyJD/B9+/Z9VkCZ1ZMnMgkDgHhjB4hS1+3bsljdhQtyfcQIYOJEJmFEROmEwYlYuXLltNajo6Nx4cIFXLlyBQEBAcaKK9OJX5ZJT/UPIuNbswbo2VM2v+bMCaxcCTRsqHRUREQUj9FOTY4fPx4fPnzAz/GrlaZDSjVtqhsgsmQBoqLYIEGp7NIloGxZuVyzJrB6NeDmpmxMRESfIbOemjRaL/gOHTokOT+kqcuWTV7+9ReTMEoDZcrIybrHjAH27mUSRkSUThl8ajIxx48fh42NjbEOl6mEhMTNoVyypLKxUCa2ahXg4wPkzy/Xp09n1k9ElM4ZnIi1bNlSa10IgefPn+PMmTMYM2aM0QLLLISQRcvVWC2AjC4sDBgwQFbGr1ZN1gaztGQSRkSUARiciDkmKAdvbm6OokWLYuLEiWjQoIHRAsss4neZK11a9hEjMpqrV+WoyGvXAHNzwM9PXhIRUYZgUFoQGxuLLl26oHTp0nB2dk6tmDKVK1fils+eVS4OymSEkC1g/fsD4eGAq6vskF+7ttKRERGRAQz66WxhYYEGDRogODg4lcLJfAID5WXXrvJsEdFnCwsDOnWSVfLDw2Ur2IULTMKIiDIgg89hlCpVCvfu3UuNWDKdS5eAyEi5XKGCsrFQJmJuLt9cFhbA1KnA9u2Ai4vSURERUQoY3GNp8uTJGDp0KCZNmgRvb29kzZpV6/rMVNvjcy1cGLfctatycVAmIIT8MzcHbG2BdeuA16+BGjWUjoyIiD5DshOxiRMn4rvvvkPjxo0BAF9++aXWVEdCCJiZmSE2Ntb4UWZQly7Jy+rVAWtrZWOhDCwkRFbIL10a+OEHua1oUflHREQZWrITsQkTJqB3797Yv39/asaTqagbB7/4Qtk4KAM7exbw9wfu3gW2bJH9wlxdlY6KiIiMJNmJmHompFq1aqVaMJmNuohrlSrKxkEZkBDAvHmyOn5UFODhAaxdyySMiCiTMaiPmBkLRCZbTAxw6JBctrVVNhbKYIKDZcvXpk1yvUULYOlSgCVjiIgyHYMSsSJFinwyGXv79u1nBZRZvHgRt8wWMUq2mBhZHf/6dVnv5OefZdV8/ggiIsqUDErEJkyYoFNZn/S7cEFeOjvzbBIZIEsWYNAgOU9kYCDrnhARZXIGJWJt27aFC+sVJYu6RezdO2XjoAzg7Vvg+fO4GeF79gQ6dAASlIYhIqLMJ9kFXdk/zDBRUfKyVStl46B07tgxoFw5oGlT2TcMkKchmYQREZmEZCdi6lGTlDzqRIz1w0gvlQqYNg2oWRN4/Fj2B3v1SumoiIgojSX71KRKpUrNODKdkyflpZWVsnFQOvT6NRAQAOzYIdfbtQP++APIlk3ZuIiIKM0ZPMURJY+6mOuzZ8rGQenMoUMy8Xr2DLCxAX79VZaq4Kl/IiKTxEQslTx4IC/r1VM0DEpvZs2SSVixYnK+yNKllY6IiIgUxEQsFahUwK5dcpnFXEnLkiWAlxcwcSJgb690NEREpLBkd9an5Dt9Om65USPl4qB0YN8+4Lvv5JRFAJAjh2wVYxJGRERgi1iq+PFHeengABQqpGwspJDYWNnqNWmSTMIqVwbatFE6KiIiSmeYiKWCbdvkJacGNFHPngHffAMcOCDXu3WTdcKIiIgSYCJmZJGRso8YAMycqWwspIBdu2RV/NevZVHWP/6QSRkREZEe7CNmZF9+GbfM/mEmZsYMoGFDmYSVLQucO8ckjIiIksREzMjUoyUBwM5OuThIAeXLy8s+fYATJ4AiRZSNh4iI0j2emjSi0NC45YsXlYuD0tCrV4CLi1z29QUuX46bvJuIiOgT2CJmRNOnxy2XKaNcHJQGoqOBYcNkq9fdu3HbmYQREZEBmIgZ0W+/ycuyZZWNg1LZw4eAjw/w889ASAjw779KR0RERBkUT00ayZ49wLt3crl/f2VjoVT0999Aly5AcDDg6AgsXQq0bKl0VERElEGxRcxI6tePW27XTrk4KJVERQHffgt89ZVMwipVAs6fZxJGRESfhYmYEURGxi0PGCDLR1EmM28eMHeuXB4yBDh8GChQQNmYiIgow+OpSSM4eTJuOX6HfcpE+vcHdu8G+vYFmjVTOhoiIsok2CJmBLdvy0szM8DGRtlYyEgiIuTk3NHRct3KCtixg0kYEREZFVvEjMDSUl7myqVsHGQkt28D/v6yD9jr18DUqUpHREREmRRbxIwgPFxeVq2qbBxkBGvXAl98IZOwnDmBmjWVjoiIiDIxJmJGsGGDvMzC9sWMKzwc6NVLDnn98EHWCbtwgROGEhFRqmIiZgT79snL+KMnKQO5dQuoXBlYuFB29PvhB/miurkpHRkREWVybMMxApVKXtarp2wclEIqFXDvnpwzctUqOWckERFRGmAiZgQ2NnKQHc9iZSAqFWD+/wbhYsWATZuA0qUBV1dl4yIiIpPCU5Of6fhxmYQBQPbsysZCyXT1KlCuHHDoUNy2Bg2YhBERUZpjIvaZ+vaNW3Z0VC4OSgYhgCVLgIoVgcuXge++k9uIiIgUwkTsM6hUcmAdIBtUrKwUDYeS8v490LEj0L27HCHZoAGwbZvsnE9ERKQQJmKfYc+euOX585WLgz7h4kWgQgXZEd/CApgyRVbJd3FROjIiIjJx7Kz/Gfbvj1suVEi5OCgJ16/L0hSRkbIcxdq1QI0aSkdFREQEgInYZ1F30vf3VzYOSkKxYsCXXwJhYcCff8pq+UREROkEE7EUEgKYM0culyihaCiU0PnzQIECgJOT7AP255+AtXVcuQoiIqJ0gt9MKfToUdyyl5dycVA8QgDz5gFVqshO+eoRkba2TMKIiChdYotYCv3+e9zyN98oFwf9X3Aw0K2bLMwKADEx8tyxra2iYRERESWFzQQpNG2avMyShRUQFHfqFFC+vEzCLC3lOePNm5mEERFRusdELAXiT+69apVycZg8IYDZs+UoyAcPZL+wo0eBQYOYHRMRUYbARCwFDh+OW27eXLk4TF5ICDBrFhAdDbRqBZw7J6vmExERZRDsI5YCBw/KSycnORiPFOLkBKxZIwu29u3LVjAiIspwmIilwPr18rJsWWXjMDkqFfDzz0CePECnTnJbjRos0EpERBkWEzEDCQHcvCmXO3RQNhaT8vo1EBAgpyayswPq1AHc3ZWOioiI6LMwETPQ+fNxyy1aKBaGaTl8GGjbFnj2DLCxkaMi8+VTOioiIqLPxs76Bpo7N26Zs+WkMpUK+PFHoHZtmYQVLQqcPAn06MH+YERElCmwRcxADx/Ky549lY0j04uNBZo0Af77T6537Aj89htgb69sXEREREbEFjEDqUdMensrG0emZ2EBVKgg+4MtWwasWMEkjIiIMp10kYjNnz8fnp6esLGxQeXKlXHq1KlE9120aBF8fHzg7OwMZ2dn+Pr6Jrm/MUVFxS0XL54md2laYmNlp3y18eOBCxeAzp0VCoiIiCh1KZ6IBQYGYsiQIRg3bhzOnTuHsmXLws/PD69evdK7/4EDB9CuXTvs378fx48fh7u7Oxo0aICnT5+meqzffRe3zBYxI3v+HKhfH2jUKG7qgixZgMKFlY2LiIgoFZkJIYSSAVSuXBkVK1bEvHnzAAAqlQru7u4YMGAARowY8cnbx8bGwtnZGfPmzUMndW2pJISGhsLR0REhISFwcHAwKNZChYC7d+UUhh8/GnRTSsquXbIWyOvXQNaswL59QKVKSkdFRETpyOd8f6dniraIRUVF4ezZs/D19dVsMzc3h6+vL44fP56sY3z8+BHR0dHInj17aoUJQJ41u3tXLk+fnqp3ZTpiYoDRo4GGDWUSVqYMcPYskzAiIjIZio6aDAoKQmxsLHLnzq21PXfu3Lhx40ayjjF8+HDkzZtXK5mLLzIyEpHxZukODQ1NUawnTsQtt26dokNQfE+eAO3bx03c2auXnMDb1lbZuIiIiNKQ4n3EPsdPP/2EtWvXYvPmzbCxsdG7z9SpU+Ho6Kj5c09hNfb4Xdby5EnRISi+Hj1kEpYtG7B2LbBgAZMwIiIyOYomYjlz5oSFhQVevnyptf3ly5fI84ls5+eff8ZPP/2EXbt2oUyZMonuN3LkSISEhGj+Hj9+nKJYt26Vl9Wrp+jmlND8+XKaonPnAH9/paMhIiJShKKJmJWVFby9vbF3717NNpVKhb1796Jq1aqJ3m769OmYNGkSdu7ciQoVKiR5H9bW1nBwcND6S4mlS+Xlu3cpujk9egQsXhy37uUlO+UXKqRcTERERApTvLL+kCFDEBAQgAoVKqBSpUqYM2cOwsLC0KVLFwBAp06d4ObmhqlTpwIApk2bhrFjx2L16tXw9PTEixcvAAD29vawT6WCn9euxS1Pm5Yqd5G5bdkia4EFBwP58wMNGigdERERUbqgeCLm7++P169fY+zYsXjx4gXKlSuHnTt3ajrwP3r0CObmcQ13v//+O6KiotA6QY/5cePGYfz48akS45dfxi03bpwqd5E5RUUBw4fLSboBoGJF1gUjIiKKR/E6YmktJXVIKlUCTp+Wc0/v35+68WUa9+/Lvl+nT8v1wYOBn34CrKyUjYuIiDKkzFpHTPEWsYxAnUuMGaNsHBnG33/LU5EhIYCzM7B8uXazIhEREQFgIvZJ8SvoFyyoXBwZSmioTMKqVpWlKfLnVzoiIiKidImJ2Cdcvx63nMISZKYhNhawsJDLnToBNjbAV18BlpbKxkVERJSOZeiCrmnh5El56e4OmPPZ0m/tWqB0aSAoKG5bmzZMwoiIiD6BqcUn/PyzvDStIQ3JFB4upyZq1042Hc6apXREREREGQpPTSZBCDn4D+BpSR03bshWr8uXATMzYNQoIJXKhxAREWVWTMSSoJ6PGgBWrlQujnRn5UqgTx8gLAxwcQH++guoX1/pqIiIiDIcJmJJ6NEjbpkjJv/vjz+A3r3lcp06wKpVgKursjERERFlUOwjloi3b4Fbt+Ryx47KxpKutG0r54ccPx7YvZtJGBER0Wdgi1givLziln/7Tbk4FCeEnJy7bl3ZF8zREbh0CbC1VToyIiKiDI8tYokICZGXhQoBqTSXePr34QMQEAD4+gILFsRtZxJGRERkFGwR0yMiIm55507l4lDUpUtyVOTNm7KAWliY0hERERFlOkzE9AgMjFs2udl5hAAWLgQGDQIiIwE3N2DNGsDHR+nIiIiIMh0mYnq8eiUvs2UzseLwoaFAz55xmWijRsCKFUDOnMrGRURElEmxj5ge06fLy1atlI0jzV25AqxfL+eMnD4d2LqVSRgREVEqYotYAi9fxk2ZaHKd9KtVA+bNA8qVA6pWVToaIiKiTI8tYgmMGhW3PGmScnGkieBgWSTt+vW4bX36MAkjIiJKI2wRSyA8XF56eQFOToqGkrpOnwb8/eVkmteuAWfOyDphRERElGbYIpbAmjXycsQIZeNINUIAc+YA1avLJMzTU9YIYxJGRESU5piIJVCokLzMlP3D3r4FWrQABg8GoqOBli2B8+eBihWVjoyIiMgk8dRkAnfuyMuiRZWNw+ju3wdq1wYePQKsrIBZs4C+fdkSRkREpCAmYvFERsYtOzsrF0eqcHeX1WktLYF164AvvlA6IiIiIpPHRCye0NC45UxRUf/NG1mV1soKyJJF1gizswMcHJSOjIiIiMA+YlqOHpWX1taypmmGdvgwULYsMHx43LY8eZiEERERpSNMxOI5cEBeurkpGsbnUamAKVOAOnWAp0/lrOWcsJuIiChdYiIWz4kT8tLdXdk4UuzVK6BhQ2D0aCA2FujQQdYLy5pV6ciIiIhID/YRi+f1a3lZvbqycaTI/v1A+/bAixeArS0wfz7QuTNHRRIREaVjTMTiuXdPXlarpmwcBgsNlTOUv3sHlCghR0WWLKl0VERERPQJTMT+782buOVixZSLI0UcHIA//gB27AB+/ZWnIomIiDIIJmL/F7+sVp48ysWRbHv2AObmQN26cv3rr+UfERERZRjsrP9/jx7FLafrBqWYGOCHH4AGDYB27YDnz5WOiIiIiFKILWL/5+IiBx1u2aJ0JEl4+lQmX4cPy/UWLQAnJyUjIiIios/ARCyBAgWUjiARO3YAnToBQUFyRvJFi4C2bZWOioiIiD4DT01C1kB99UrpKBKhUsnq+I0byySsfHng3DkmYURERJkAEzEAx47FLae7qvrm5rI2GAD06yeDLVxY2ZiIiIjIKHhqEsCzZ3HLzs7KxaElJkZO1A3I4qxffw00bapsTEREqUwIgZiYGMTGxiodCinA0tISFhl+smfDMBEDMGKEvGzSRNk4AABRUTKgO3eAf/6RlfHt7ZmEEVGmFxUVhefPn+Pjx49Kh0IKMTMzQ758+WBvb690KGmGiRiA+/flpXqKI8Xcvw/4+8v5IQE5C3mdOoqGRESUFlQqFe7fvw8LCwvkzZsXVlZWMOMUbSZFCIHXr1/jyZMnKFy4sMm0jJl8IhYVFbe8ZIlycWDTJqBrVyAkRJakWL6cSRgRmYyoqCioVCq4u7vDzs5O6XBIIbly5cKDBw8QHR1tMomYyXfWf/gwbrl4cQUCiIwEBgyQc0WGhABVqgAXLgDNmysQDBGRsszNTf5ryaSZYiuoyb/j44+YVCT5/uYbYN48uTxsGHDoEODhoUAgRERElNZMPhF7/15eZsumUADDhwOursDWrcD06YClpUKBEBERUVoz+UQsOlpeNmyYRncYHg4cPBi3XrEicO9eOhmySUREKXH8+HFYWFigiZ7P8gMHDsDMzAzBwcE613l6emLOnDla2/bv34/GjRsjR44csLOzQ4kSJfDdd9/h6dOnqRQ9EBERgX79+iFHjhywt7dHq1at8PLlyyRv8+HDB/Tv3x/58uWDra0tSpQogQULFujdVwiBRo0awczMDH///XcqPIKMy+QTMXWt1DQZKXvzpuwD5ucn+4Gp2dikwZ0TEVFqWbJkCQYMGIBDhw7hWfzilAb6448/4Ovrizx58mDjxo24du0aFixYgJCQEMycOdOIEWsbPHgw/v33X6xfvx4HDx7Es2fP0LJlyyRvM2TIEOzcuRN//fUXrl+/jm+//Rb9+/fHFj2TNs+ZM8ck+38lh8mPmrx5U16meu3AVauAXr2AsDAgVy5Azy8jIiLKeD58+IDAwECcOXMGL168wPLlyzFq1CiDj/PkyRMMHDgQAwcOxOzZszXbPT09UbNmTb0tasYQEhKCJUuWYPXq1ahbty4AYNmyZShevDhOnDiBKlWq6L3dsWPHEBAQgNq1awMAevbsiT/++AOnTp3Cl19+qdnvwoULmDlzJs6cOQNXV9dUeQwZmcm3iKn7hjk4pNIdfPwIdO8OdOggk7DatWVr2P/fuEREpEsI+ZGpxJ8QhsW6bt06FCtWDEWLFkWHDh2wdOlSCEMPAmD9+vWIiorC999/r/d6JyenRG/bqFEj2NvbJ/pXsmTJRG979uxZREdHw9fXV7OtWLFiyJ8/P44fP57o7apVq4YtW7bg6dOnEEJg//79uHXrFho0aKDZ5+PHj2jfvj3mz5+PPHnyJPHoTZfJt4jt2CEvU6V0xbVrQJs2wNWrskL+2LHAmDEKDc8kIso4Pn5Moy4jenz4AGTNmvz9lyxZgg4dOgAAGjZsiJCQEBw8eFDTUpRct2/fhoODQ4pajRYvXozw8PBEr7dMYiDYixcvYGVlpZPo5c6dGy/U/Xf0+PXXX9GzZ0/ky5cPWbJkgbm5ORYtWoSaNWtq9hk8eDCqVauG5izJlCiTT8Ty5gXevDH8F1Cy/POPTMLy5JGnJv/f5EtERJnDzZs3cerUKWzevBkAkCVLFvj7+2PJkiUGJ2JCiBT3o3Jzc0vR7T7Hr7/+ihMnTmDLli3w8PDAoUOH0K9fP+TNmxe+vr7YsmUL9u3bh/Pnz6d5bBmJySdi6mmNypZNhYN//71s5x4wAMidOxXugIgoc7Kzky1TSt13ci1ZsgQxMTHImzevZpsQAtbW1pg3bx4cHR3h8P++LyEhITqtTsHBwXB0dAQAFClSBCEhIXj+/LnBrWKNGjXC4cOHE73ew8MDV69e1Xtdnjx5EBUVheDgYK34Xr58mejpxPDwcIwaNQqbN2/WjBQtU6YMLly4gJ9//hm+vr7Yt28f7t69q/OYW7VqBR8fHxw4cMCgx5hZmXQiFhZm5FGTly8DEycCK1YAtrbyFOTkyUY4MBGRaTEzM+z0oBJiYmKwYsUKzJw5U6tfFAC0aNECa9asQe/evVG4cGGYm5vj7Nmz8IhXsPvevXsICQlBkSJFAACtW7fGiBEjMH36dK3O+moJE6X4PufUpLe3NywtLbF37160atUKgGzpe/ToEapWrar3NtHR0YiOjtaZCcHCwgIqlQoAMGLECHTv3l3r+tKlS2P27Nlo1qxZovGYGpNOxOJP8l2q1GccSAhg8WJg4EAgIgLw8gKmTfvs+IiIKP3aunUr3r17h27dumlatdRatWqFJUuWoHfv3siWLRu6d++O7777DlmyZEHp0qXx+PFjDB8+HFWqVEG1atUAAO7u7pg9ezb69++P0NBQdOrUCZ6ennjy5AlWrFgBe3v7REtYfM6pSUdHR3Tr1g1DhgxB9uzZ4eDggAEDBqBq1apaIyaLFSuGqVOn4quvvoKDgwNq1aqFYcOGwdbWFh4eHjh48CBWrFiBWbNmAZAtbfpa1PLnz48CBQqkON5MR5iYkJAQAUCEhISIa9eEAIRwdv6sAwrRtq08ECBEw4ZCvHpltHiJiExBeHi4uHbtmggPD1c6lGRr2rSpaNy4sd7rTp48KQCIixcvCiHk4xs3bpwoVqyYsLW1FQUKFBA9e/YUr1+/1rnt7t27hZ+fn3B2dhY2NjaiWLFiYujQoeLZs2ep9ljCw8NF3759hbOzs7CzsxNfffWVeP78udY+AMSyZcs068+fPxedO3cWefPmFTY2NqJo0aJi5syZQqVSJXo/AMTmzZuTjCOx90H87+/MxEyIVOmmnm6FhobC0dERISEh2L3bAa1bAy4uwCcKCOt3/rwcFXnnjjwNOWUKMHQowElriYgMEhERgfv376NAgQKwYZFrk5XU+yD+97dDqtWcSnsmfWry6FF5GRmZghtv3gy0bQtERQHu7sDatcD/m5eJiIiIksOkE7EjR+RlxYopuHGFCrKHf/XqwLJlQI4cRo2NiIiIMj+TTsTu3pWXyU7Enj4F1B0i3d2BU6dkx3zOn0VEREQpYLKdmWJigLdv5XL16p/YWQhg7lyZdMWfzLRgQSZhRERElGImm4jt3x+3HG96LV1v3wJffQV8+63sD6ZnVnkiIiKilDDZROzZs7hla+tEdjpxAihfXk5VZGUF/PorsGhRmsRHRGSKTGwgPyVgiq+/ySZi6pGSCYohSyoV8PPPgI8P8OiRPAV57BjQvz9PRRIRpQJ15fePHz8qHAkpKSoqCoCs0G8qTLaz/v9fa+TKpefKQ4eAYcPkcps2shUsE9UsISJKbywsLODk5IRXr14BAOzs7FI8ATZlTCqVCq9fv4adnR2yZDGd9MR0HmkCS5fKSysrPVfWrg0MGgQUKwb06sVWMCKiNKCeDkedjJHpMTc3R/78+U0qCTfZREw9ybelJeSpyLlzgXbtAPW8WHPmKBUaEZFJMjMzg6urK1xcXBAdHa10OKQAKysrnYnEM7t0kYjNnz8fM2bMwIsXL1C2bFn8+uuvqFSpUqL7r1+/HmPGjMGDBw9QuHBhTJs2DY0bNzboPt+/l5cd/V4BjToCu3YBW7cCu3dziiIiIgVZWFiYVB8hMm2KZxyBgYEYMmQIxo0bh3PnzqFs2bLw8/NLtGn62LFjaNeuHbp164bz58+jRYsWaNGiBa5cuWLQ/d67B9TCAVTqVU4mYba2wDff8DQkERERpRnFJ/2uXLkyKlasiHnz5gGQnfXc3d0xYMAAjBgxQmd/f39/hIWFYevWrZptVapUQbly5bBgwYJP3p960tDvMRJTMA0WUAHFiwPr1gGlShnvgREREZHRZNZJvxVtEYuKisLZs2fhG6+iqrm5OXx9fXH8+HG9tzl+/LjW/gDg5+eX6P6JGY2psIAKonMX4PRpJmFERESU5hTtIxYUFITY2Fjkzp1ba3vu3Llx48YNvbd58eKF3v1fvHihd//IyEhEqouGAQgJCZHHgQ1uDJ6LYuPbArGxQGjo5zwUIiIiSkWh//+ezmxFX9NFZ/3UNHXqVEyYMEFne1FEALN7yT8iIiLKEN68eQNHR0elwzAaRROxnDlzwsLCAi9fvtTa/vLlS009mYTy5Mlj0P4jR47EkCFDNOvBwcHw8PDAo0ePMtULmRGFhobC3d0djx8/zlTn+zMqvh7pB1+L9IOvRfoREhKC/PnzI3v27EqHYlSKJmJWVlbw9vbG3r170aJFCwCys/7evXvRv39/vbepWrUq9u7di2+//Vazbffu3ahatare/a2trWGtZzJJR0dH/lOlEw4ODnwt0hG+HukHX4v0g69F+pHZ6owpfmpyyJAhCAgIQIUKFVCpUiXMmTMHYWFh6NKlCwCgU6dOcHNzw9SpUwEAgwYNQq1atTBz5kw0adIEa9euxZkzZ7Bw4UIlHwYRERGRwRRPxPz9/fH69WuMHTsWL168QLly5bBz505Nh/xHjx5pZb/VqlXD6tWr8cMPP2DUqFEoXLgw/v77b5TiqEciIiLKYBRPxACgf//+iZ6KPHDggM62r7/+Gl9//XWK7sva2hrjxo3Te7qS0hZfi/SFr0f6wdci/eBrkX5k1tdC8YKuRERERKYqc/V4IyIiIspAmIgRERERKYSJGBEREZFCMmUiNn/+fHh6esLGxgaVK1fGqVOnktx//fr1KFasGGxsbFC6dGls3749jSLN/Ax5LRYtWgQfHx84OzvD2dkZvr6+n3ztyDCG/m+orV27FmZmZpp6f/T5DH0tgoOD0a9fP7i6usLa2hpFihThZ5WRGPpazJkzB0WLFoWtrS3c3d0xePBgREREpFG0mdehQ4fQrFkz5M2bF2ZmZvj7778/eZsDBw7giy++gLW1NQoVKoTly5enepxGJzKZtWvXCisrK7F06VJx9epV0aNHD+Hk5CRevnypd/+jR48KCwsLMX36dHHt2jXxww8/CEtLS3H58uU0jjzzMfS1aN++vZg/f744f/68uH79uujcubNwdHQUT548SePIMydDXw+1+/fvCzc3N+Hj4yOaN2+eNsFmcoa+FpGRkaJChQqicePG4siRI+L+/fviwIED4sKFC2kceeZj6GuxatUqYW1tLVatWiXu378v/vvvP+Hq6ioGDx6cxpFnPtu3bxejR48WmzZtEgDE5s2bk9z/3r17ws7OTgwZMkRcu3ZN/Prrr8LCwkLs3LkzbQI2kkyXiFWqVEn069dPsx4bGyvy5s0rpk6dqnf/Nm3aiCZNmmhtq1y5sujVq1eqxmkKDH0tEoqJiRHZsmUTf/75Z2qFaFJS8nrExMSIatWqicWLF4uAgAAmYkZi6Gvx+++/Cy8vLxEVFZVWIZoMQ1+Lfv36ibp162ptGzJkiKhevXqqxmlqkpOIff/996JkyZJa2/z9/YWfn18qRmZ8merUZFRUFM6ePQtfX1/NNnNzc/j6+uL48eN6b3P8+HGt/QHAz88v0f0peVLyWiT08eNHREdHZ7p5xZSQ0tdj4sSJcHFxQbdu3dIiTJOQktdiy5YtqFq1Kvr164fcuXOjVKlSmDJlCmJjY9Mq7EwpJa9FtWrVcPbsWc3py3v37mH79u1o3LhxmsRMcTLL93e6KOhqLEFBQYiNjdVU5VfLnTs3bty4ofc2L1680Lv/ixcvUi1OU5CS1yKh4cOHI2/evDr/aGS4lLweR44cwZIlS3DhwoU0iNB0pOS1uHfvHvbt24dvvvkG27dvx507d9C3b19ER0dj3LhxaRF2ppSS16J9+/YICgpCjRo1IIRATEwMevfujVGjRqVFyBRPYt/foaGhCA8Ph62trUKRGSZTtYhR5vHTTz9h7dq12Lx5M2xsbJQOx+S8f/8eHTt2xKJFi/C/9u49pqkrjgP4lxZLEYuEISkdDwWFEQdDHjpkhsHcKJnKRIVNgigoRoYYnW5kKo8xEB1gwOjEGMExIg/jBpEJipMNarah8lgEiyBVF5FlsIAojEfP/li4WeUxi0pd+X2S+8c995xzf+eeNP3l3NtbExMTTYcz5SmVSpiamuLYsWNwcXFBYGAgdu/ejaNHj2o6tCmnoqICSUlJOHLkCK5du4YzZ86gpKQECQkJmg6N/E9p1YqYiYkJ+Hw+2tvbVcrb29shFotHbSMWi9WqT57MROZiWEpKCpKTk1FeXg5HR8fnGeaUoe58tLS0QKFQYPny5VyZUqkEAOjq6kIul8PGxub5Bq2lJvLZMDMzw7Rp08Dn87kye3t73L9/H/39/RAIBM81Zm01kbnYu3cvgoODsXHjRgCAg4MDHj58iPDwcOzevVvlv5HJ8zXW97ehoeH/ZjUM0LIVMYFAABcXF1y8eJErUyqVuHjxItzd3Udt4+7urlIfAC5cuDBmffJkJjIXAHDgwAEkJCSgtLQUrq6ukxHqlKDufLzyyiv49ddfUVtby20rVqyAl5cXamtrYWFhMZnha5WJfDY8PDzQ3NzMJcMA0NTUBDMzM0rCnsJE5uLRo0cjkq3hBJnRPwZOKq35/tb0rwWetby8PKanp8eys7NZQ0MDCw8PZ0ZGRuz+/fuMMcaCg4NZdHQ0V18mkzFdXV2WkpLCGhsbWWxsLL2+4hlRdy6Sk5OZQCBgp0+fZm1tbdz24MEDTQ1Bq6g7H4+jX00+O+rOxZ07d5hIJGKRkZFMLpezs2fPMlNTU/b5559raghaQ925iI2NZSKRiJ06dYrdunWLnT9/ntnY2LCAgABNDUFrPHjwgNXU1LCamhoGgKWlpbGamhp2+/Ztxhhj0dHRLDg4mKs//PqKXbt2scbGRnb48GF6fcWL4tChQ8zS0pIJBAK2cOFC9tNPP3HHPD09WUhIiEr9goICZmtrywQCAZs/fz4rKSmZ5Ii1lzpzYWVlxQCM2GJjYyc/cC2l7mfj3ygRe7bUnYvLly+zRYsWMT09PWZtbc0SExPZ4ODgJEetndSZi4GBARYXF8dsbGyYUChkFhYWLCIigv3555+TH7iWuXTp0qjfAcPXPyQkhHl6eo5o4+TkxAQCAbO2tmZZWVmTHvfT0mGM1lIJIYQQQjRBq54RI4QQQgj5P6FEjBBCCCFEQygRI4QQQgjREErECCGEEEI0hBIxQgghhBANoUSMEEIIIURDKBEjhBBCCNEQSsQIIYQQQjSEEjFCiIrs7GwYGRlpOowJ09HRwbfffjtunfXr1+O9996blHgIIWQ8lIgRooXWr18PHR2dEVtzc7OmQ0N2djYXD4/Hg7m5OTZs2IDff//9mfTf1tYGX19fAIBCoYCOjg5qa2tV6qSnpyM7O/uZnG8scXFx3Dj5fD4sLCwQHh6Ozs5OtfqhpJEQ7aar6QAIIc+HVCpFVlaWStmsWbM0FI0qQ0NDyOVyKJVK1NXVYcOGDbh37x7Kysqeum+xWPyfdWbOnPnU53kS8+fPR3l5OYaGhtDY2IjQ0FB0dXUhPz9/Us5PCHnx0YoYIVpKT08PYrFYZePz+UhLS4ODgwMMDAxgYWGBiIgI9PT0jNlPXV0dvLy8IBKJYGhoCBcXF1y5coU7XlVVhSVLlkBfXx8WFhaIiorCw4cPx41NR0cHYrEYEokEvr6+iIqKQnl5OXp7e6FUKvHZZ5/B3Nwcenp6cHJyQmlpKde2v78fkZGRMDMzg1AohJWVFfbt26fS9/CtyTlz5gAAFixYAB0dHbz55psAVFeZjh07BolEAqVSqRKjn58fQkNDuf2ioiI4OztDKBTC2toa8fHxGBwcHHecurq6EIvFePnll7F06VKsWbMGFy5c4I4PDQ0hLCwMc+bMgb6+Puzs7JCens4dj4uLw8mTJ1FUVMStrlVUVAAA7t69i4CAABgZGcHY2Bh+fn5QKBTjxkMIefFQIkbIFMPj8ZCRkYHr16/j5MmT+P777/Hxxx+PWT8oKAjm5uaorq7G1atXER0djWnTpgEAWlpaIJVKsWrVKtTX1yM/Px9VVVWIjIxUKyZ9fX0olUoMDg4iPT0dqampSElJQX19PXx8fLBixQrcvHkTAJCRkYHi4mIUFBRALpcjNzcXs2fPHrXfX375BQBQXl6OtrY2nDlzZkSdNWvWoKOjA5cuXeLKOjs7UVpaiqCgIABAZWUl1q1bh23btqGhoQGZmZnIzs5GYmLiE49RoVCgrKwMAoGAK1MqlTA3N0dhYSEaGhoQExODTz/9FAUFBQCAnTt3IiAgAFKpFG1tbWhra8PixYsxMDAAHx8fiEQiVFZWQiaTYcaMGZBKpejv73/imAghLwBGCNE6ISEhjM/nMwMDA25bvXr1qHULCwvZSy+9xO1nZWWxmTNncvsikYhlZ2eP2jYsLIyFh4erlFVWVjIej8d6e3tHbfN4/01NTczW1pa5uroyxhiTSCQsMTFRpY2bmxuLiIhgjDG2detW5u3tzZRK5aj9A2DffPMNY4yx1tZWBoDV1NSo1AkJCWF+fn7cvp+fHwsNDeX2MzMzmUQiYUNDQ4wxxt566y2WlJSk0kdOTg4zMzMbNQbGGIuNjWU8Ho8ZGBgwoVDIADAALC0tbcw2jDH24YcfslWrVo0Z6/C57ezsVK7BX3/9xfT19VlZWdm4/RNCXiz0jBghWsrLywtffvklt29gYADgn9Whffv24caNG+ju7sbg4CD6+vrw6NEjTJ8+fUQ/O3bswMaNG5GTk8PdXrOxsQHwz23L+vp65ObmcvUZY1AqlWhtbYW9vf2osXV1dWHGjBlQKpXo6+vDG2+8gePHj6O7uxv37t2Dh4eHSn0PDw/U1dUB+Oe24ttvvw07OztIpVIsW7YM77zzzlNdq6CgIGzatAlHjhyBnp4ecnNz8f7774PH43HjlMlkKitgQ0ND4143ALCzs0NxcTH6+vrw9ddfo7a2Flu3blWpc/jwYZw4cQJ37txBb28v+vv74eTkNG68dXV1aG5uhkgkUinv6+tDS0vLBK4AIURTKBEjREsZGBhg7ty5KmUKhQLLli3Dli1bkJiYCGNjY1RVVSEsLAz9/f2jJhRxcXFYu3YtSkpKcO7cOcTGxiIvLw8rV65ET08PNm/ejKioqBHtLC0tx4xNJBLh2rVr4PF4MDMzg76+PgCgu7v7P8fl7OyM1tZWnDt3DuXl5QgICMDSpUtx+vTp/2w7luXLl4MxhpKSEri5uaGyshIHDx7kjvf09CA+Ph7+/v4j2gqFwjH7FQgE3BwkJyfj3XffRXx8PBISEgAAeXl52LlzJ1JTU+Hu7g6RSIQvvvgCP//887jx9vT0wMXFRSUBHvai/CCDEPJkKBEjZAq5evUqlEolUlNTudWe4eeRxmNrawtbW1ts374dH3zwAbKysrBy5Uo4OzujoaFhRML3X3g83qhtDA0NIZFIIJPJ4OnpyZXLZDIsXLhQpV5gYCACAwOxevVqSKVSdHZ2wtjYWKW/4eexhoaGxo1HKBTC398fubm5aG5uhp2dHZydnbnjzs7OkMvlao/zcXv27IG3tze2bNnCjXPx4sWIiIjg6jy+oiUQCEbE7+zsjPz8fJiamsLQ0PCpYiKEaBY9rE/IFDJ37lwMDAzg0KFDuHXrFnJycnD06NEx6/f29iIyMhIVFRW4ffs2ZDIZqquruVuOn3zyCS5fvozIyEjU1tbi5s2bKCoqUvth/X/btWsX9u/fj/z8fMjlckRHR6O2thbbtm0DAKSlpeHUqVO4ceMGmpqaUFhYCLFYPOpLaE1NTaGvr4/S0lK0t7ejq6trzPMGBQWhpKQEJ06c4B7SHxYTE4OvvvoK8fHxuH79OhobG5GXl4c9e/aoNTZ3d3c4OjoiKSkJADBv3jxcuXIFZWVlaGpqwt69e1FdXa3SZvbs2aivr4dcLscff/yBgYEBBAUFwcTEBH5+fqisrERraysqKioQFRWF3377Ta2YCCGaRYkYIVPIa6+9hrS0NOzfvx+vvvoqcnNzVV798Dg+n4+Ojg6sW7cOtra2CAgIgK+vL+Lj4wEAjo6O+OGHH9DU1IQlS5ZgwYIFiImJgUQimXCMUVFR2LFjBz766CM4ODigtLQUxcXFmDdvHoB/bmseOHAArq6ucHNzg0KhwHfffcet8P2brq4uMjIykJmZCYlEAj8/vzHP6+3tDWNjY8jlcqxdu1blmI+PD86ePYvz58/Dzc0Nr7/+Og4ePAgrKyu1x7d9+3YcP34cd+/exebNm+Hv74/AwEAsWrQIHR0dKqtjALBp0ybY2dnB1dUVs2bNgkwmw/Tp0/Hjjz/C0tIS/v7+sLe3R1hYGPr6+miFjJD/GR3GGNN0EIQQQgghUxGtiBFCCCGEaAglYoQQQgghGkKJGCGEEEKIhlAiRgghhBCiIZSIEUIIIYRoCCVihBBCCCEaQokYIYQQQoiGUCJGCCGEEKIhlIgRQgghhGgIJWKEEEIIIRpCiRghhBBCiIZQIkYIIYQQoiF/A+SQE5kQ5H8mAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 294.45983505249023\n",
+      "lead_lag: True inv_rest: True thres_distance: 16000 auc: 0.8360074\n",
+      "Threshold distance:  32000\n",
+      "lead_lag:  True\n",
+      "inv_reset:  True\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 26.57306218147278\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 333.42611503601074\n",
+      "lead_lag: True inv_rest: True thres_distance: 32000 auc: 0.84355992\n",
+      "Threshold distance:  4000\n",
+      "lead_lag:  True\n",
+      "inv_reset:  False\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 19.67205309867859\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 380.14289903640747\n",
+      "lead_lag: True inv_rest: False thres_distance: 4000 auc: 0.8257225199999999\n",
+      "Threshold distance:  8000\n",
+      "lead_lag:  True\n",
+      "inv_reset:  False\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 16.292973041534424\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmAAAAHcCAYAAABxixZDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACbR0lEQVR4nOzdd1hT1xsH8C8gU6YiioiCE7cWR92zWmfduHFr3Vr3XnXWVefPPVu31TponXVWW/fAjQsFRWWI7JzfH6cJREATBG6A7+d5eHJzc3PzJpckb8495z1GQggBIiIiIko3xkoHQERERJTVMAEjIiIiSmdMwIiIiIjSGRMwIiIionTGBIyIiIgonTEBIyIiIkpnTMCIiIiI0hkTMCIiIqJ0xgSMiIiIKJ0xASP6Am5ubujWrZvSYWQ5tWvXRu3atZUO47OmTJkCIyMjBAUFKR2KwTEyMsKUKVNSZV+PHz+GkZERNmzYkCr7I0oPTMDIYG3YsAFGRkaav2zZssHFxQXdunWDv7+/0uEZtPDwcEyfPh1lypSBlZUV7OzsUKNGDWzatAkZZfax27dvY8qUKXj8+LHSoSQSFxeH9evXo3bt2siRIwfMzc3h5uaG7t27499//1U6vFTxyy+/YNGiRUqHocUQYyJKqWxKB0D0OdOmTYO7uzsiIyPx999/Y8OGDThz5gxu3rwJCwsLRWO7e/cujI0N63dMYGAg6tWrB19fX7Rv3x4DBw5EZGQkdu/eDW9vbxw6dAhbt26FiYmJ0qF+0u3btzF16lTUrl0bbm5uWrf9+eefygQFICIiAq1atYKPjw9q1qyJcePGIUeOHHj8+DF27NiBjRs34unTp8iXL59iMaaGX375BTdv3sTQoUPTZP8RERHIlk2/r6DkYipQoAAiIiJgamqaihESpS0mYGTwGjVqhAoVKgAAevXqBUdHR8yZMwf79+9Hu3btFI3N3Nw83R8zMjISZmZmySZ+3t7e8PX1xd69e9G8eXPN+sGDB2PkyJH46aefUL58eYwePTq9QgYgW+WyZ8+eKvsyMzNLlf2kxMiRI+Hj44OFCxcmSgQmT56MhQsXpms8QghERkbC0tIyXR83JVQqFaKjo2FhYZGqP56MjIwU/zFGpDdBZKDWr18vAIh//vlHa/2BAwcEADFz5kyt9b6+vqJ169bCwcFBmJubC09PT7Fv375E+3337p0YOnSoKFCggDAzMxMuLi6iS5cu4vXr15ptIiMjxaRJk0ShQoWEmZmZyJcvnxg5cqSIjIzU2leBAgWEt7e3EEKIf/75RwAQGzZsSPSYPj4+AoD4/fffNeueP38uunfvLpycnISZmZkoUaKEWLt2rdb9Tpw4IQCIX3/9VYwfP17kzZtXGBkZiXfv3iX5mp0/f14AED169Ejy9piYGFGkSBHh4OAgPnz4IIQQws/PTwAQ8+bNEwsWLBD58+cXFhYWombNmuLGjRuJ9qHL66w+didPnhTff/+9yJUrl7C3txdCCPH48WPx/fffi6JFiwoLCwuRI0cO0aZNG+Hn55fo/h//nThxQgghRK1atUStWrUSvU7bt28XM2bMEC4uLsLc3FzUrVtX3L9/P9FzWLp0qXB3dxcWFhaiYsWK4tSpU4n2mZRnz56JbNmyiW+++eaT26lNnjxZABD3798X3t7ews7OTtja2opu3bqJ8PBwrW3XrVsn6tSpI3LlyiXMzMxE8eLFxfLlyxPts0CBAqJJkybCx8dHeHp6CnNzc7Fw4UK99iGEEIcOHRI1a9YU1tbWwsbGRlSoUEFs3bpVCCFf349f+wIFCmjuq+v7A4AYMGCA2LJliyhRooTIli2b2Lt3r+a2yZMna7YNDQ0VQ4YM0bwvc+XKJerXry8uXbr02ZjU/8Pr16/XenxfX1/Rtm1b4ejoKCwsLETRokXFuHHjPnXIiNINW8Aow1H3CXJwcNCsu3XrFqpVqwYXFxeMGTMG2bNnx44dO9CiRQvs3r0bLVu2BAC8f/8eNWrUgK+vL3r06IGvvvoKQUFB2L9/P54/fw5HR0eoVCo0b94cZ86cQZ8+fVC8eHHcuHEDCxcuxL179/Dbb78lGVeFChVQsGBB7NixA97e3lq3bd++HQ4ODmjYsCEAeZrw66+/hpGREQYOHIhcuXLh8OHD6NmzJ0JDQxO1rEyfPh1mZmYYMWIEoqKikm0B+v333wEAXbt2TfL2bNmyoWPHjpg6dSrOnj2L+vXra27btGkTwsLCMGDAAERGRmLx4sWoW7cubty4gdy5c+v1Oqv1798fuXLlwqRJkxAeHg4A+Oeff3Du3Dm0b98e+fLlw+PHj7FixQrUrl0bt2/fhpWVFWrWrInBgwfj559/xrhx41C8eHEA0FwmZ/bs2TA2NsaIESMQEhKCuXPnolOnTrhw4YJmmxUrVmDgwIGoUaMGhg0bhsePH6NFixZwcHD47GnDw4cPIzY2Fl26dPnkdh9r164d3N3dMWvWLFy+fBlr1qyBk5MT5syZoxVXyZIl0bx5c2TLlg2///47+vfvD5VKhQEDBmjt7+7du+jQoQP69u2L3r17o1ixYnrtY8OGDejRowdKliyJsWPHwt7eHleuXIGPjw86duyI8ePHIyQkBM+fP9e06FlbWwOA3u+P48ePY8eOHRg4cCAcHR0TnU5W69evH3bt2oWBAweiRIkSePPmDc6cOQNfX1989dVXn4wpKdevX0eNGjVgamqKPn36wM3NDQ8fPsTvv/+OH3/8UbcDR5SWlM4AiZKjbgU5evSoeP36tXj27JnYtWuXyJUrlzA3NxfPnj3TbFuvXj1RunRprV/gKpVKVK1aVRQpUkSzbtKkSQKA2LNnT6LHU6lUQgghNm/eLIyNjcXp06e1bl+5cqUAIM6ePatZl7AFTAghxo4dK0xNTcXbt28166KiooS9vb1Wq1TPnj2Fs7OzCAoK0nqM9u3bCzs7O03rlLplp2DBgpp1n9KiRQsBINkWMiGE2LNnjwAgfv75ZyFEfOuBpaWleP78uWa7CxcuCABi2LBhmnW6vs7qY1e9enURGxur9fhJPQ91y92mTZs063bu3KnV6pVQci1gxYsXF1FRUZr1ixcvFgA0LXlRUVEiZ86comLFiiImJkaz3YYNGwSAz7aADRs2TAAQV65c+eR2auoWsI9bJFu2bCly5syptS6p16Vhw4aiYMGCWusKFCggAAgfH59E2+uyj+DgYGFjYyMqV64sIiIitLZVvweEEKJJkyZarV5q+rw/AAhjY2Nx69atRPvBRy1gdnZ2YsCAAYm2Syi5mJJqAatZs6awsbERT548SfY5EinJsHoPEyWhfv36yJUrF1xdXdGmTRtkz54d+/fv17RWvH37FsePH0e7du0QFhaGoKAgBAUF4c2bN2jYsCHu37+vGTW5e/dulC1bNlFLDSD7kQDAzp07Ubx4cXh4eGj2FRQUhLp16wIATpw4kWysXl5eiImJwZ49ezTr/vzzTwQHB8PLywuA7LOze/duNGvWDEIIrcdo2LAhQkJCcPnyZa39ent769THJywsDABgY2OT7Dbq20JDQ7XWt2jRAi4uLprrlSpVQuXKlXHo0CEA+r3Oar17907U2T/h84iJicGbN29QuHBh2NvbJ3re+urevbtW62CNGjUAAI8ePQIA/Pvvv3jz5g169+6t1QG8U6dOWi2qyVG/Zp96fZPSr18/res1atTAmzdvtI5BwtclJCQEQUFBqFWrFh49eoSQkBCt+7u7u2taUxPSZR9HjhxBWFgYxowZk6jflPo98Cn6vj9q1aqFEiVKfHa/9vb2uHDhAl68ePHZbT/n9evXOHXqFHr06IH8+fNr3abLcyRKDzwFSQZv2bJlKFq0KEJCQrBu3TqcOnVKq/P7gwcPIITAxIkTMXHixCT38erVK7i4uODhw4do3br1Jx/v/v378PX1Ra5cuZLdV3LKli0LDw8PbN++HT179gQgTz86OjpqvqBev36N4OBgrFq1CqtWrdLpMdzd3T8Zs5o6MQgLC4O9vX2S2ySXpBUpUiTRtkWLFsWOHTsA6Pc6fyruiIgIzJo1C+vXr4e/v79WWYyPEw19ffxlq06q3r17BwB48uQJAKBw4cJa22XLli3ZU2MJ2draAoh/DVMjLvU+z549i8mTJ+P8+fP48OGD1vYhISGws7PTXE/u/0GXfTx8+BAAUKpUKb2eg5q+7w9d/3fnzp0Lb29vuLq6wtPTE40bN0bXrl1RsGBBvWNUJ9wpfY5E6YEJGBm8SpUqaUZBtmjRAtWrV0fHjh1x9+5dWFtbQ6VSAQBGjBiRZKsAkPgL91NUKhVKly6NBQsWJHm7q6vrJ+/v5eWFH3/8EUFBQbCxscH+/fvRoUMHTYuLOt7OnTsn6iumVqZMGa3ruo5wK168OH777Tdcv34dNWvWTHKb69evA4BOrRIJpeR1TiruQYMGYf369Rg6dCiqVKkCOzs7GBkZoX379prHSKnkSmuIVKp95uHhAQC4ceMGypUrp/P9PhfXw4cPUa9ePXh4eGDBggVwdXWFmZkZDh06hIULFyZ6XZJ6XfXdR0rp+/7Q9X+3Xbt2qFGjBvbu3Ys///wT8+bNw5w5c7Bnzx40atToi+MmMjRMwChDMTExwaxZs1CnTh0sXboUY8aM0fxCNjU11epUnpRChQrh5s2bn93m2rVrqFevXopOV3h5eWHq1KnYvXs3cufOjdDQULRv315ze65cuWBjY4O4uLjPxquvpk2bYtasWdi0aVOSCVhcXBx++eUXODg4oFq1alq33b9/P9H29+7d07QM6fM6f8quXbvg7e2N+fPna9ZFRkYiODhYa7u0OFVUoEABALI1r06dOpr1sbGxePz4caLE92ONGjWCiYkJtmzZondH/E/5/fffERUVhf3792u1ln3qdHdK91GoUCEAwM2bNz/5wyS51/9L3x+f4uzsjP79+6N///549eoVvvrqK/z444+aBEzXx1P/r37uvU6kJPYBowyndu3aqFSpEhYtWoTIyEg4OTmhdu3a+N///oeXL18m2v7169ea5datW+PatWvYu3dvou3UrRHt2rWDv78/Vq9enWibiIgIzWi+5BQvXhylS5fG9u3bsX37djg7O2slQyYmJmjdujV2796d5BdEwnj1VbVqVdSvXx/r16/HgQMHEt0+fvx43Lt3D6NGjUrUMvHbb79p9eG6ePEiLly4oPny0+d1/hQTE5NELVJLlixBXFyc1jp1zbCPE7MvUaFCBeTMmROrV69GbGysZv3WrVs1pyk/xdXVFb1798aff/6JJUuWJLpdpVJh/vz5eP78uV5xqVvIPj4du379+lTfR4MGDWBjY4NZs2YhMjJS67aE982ePXuSp4S/9P2RlLi4uESP5eTkhLx58yIqKuqzMX0sV65cqFmzJtatW4enT59q3ZZaraFEX4otYJQhjRw5Em3btsWGDRvQr18/LFu2DNWrV0fp0qXRu3dvFCxYEIGBgTh//jyeP3+Oa9euae63a9cutG3bFj169ICnpyfevn2L/fv3Y+XKlShbtiy6dOmCHTt2oF+/fjhx4gSqVauGuLg43LlzBzt27MAff/yhOSWaHC8vL0yaNAkWFhbo2bNnoqKps2fPxokTJ1C5cmX07t0bJUqUwNu3b3H58mUcPXoUb9++TfFrs2nTJtSrVw/fffcdOnbsiBo1aiAqKgp79uzByZMn4eXlhZEjRya6X+HChVG9enV8//33iIqKwqJFi5AzZ06MGjVKs42ur/OnNG3aFJs3b4adnR1KlCiB8+fP4+jRo8iZM6fWduXKlYOJiQnmzJmDkJAQmJubo27dunByckrxa2NmZoYpU6Zg0KBBqFu3Ltq1a4fHjx9jw4YNKFSokE4tLPPnz8fDhw8xePBg7NmzB02bNoWDgwOePn2KnTt34s6dO1otnrpo0KABzMzM0KxZM/Tt2xfv37/H6tWr4eTklGSy+yX7sLW1xcKFC9GrVy9UrFgRHTt2hIODA65du4YPHz5g48aNAABPT09s374dw4cPR8WKFWFtbY1mzZqlyvvjY2FhYciXLx/atGmDsmXLwtraGkePHsU///yj1VKaXExJ+fnnn1G9enV89dVX6NOnD9zd3fH48WMcPHgQV69e1Ss+ojShyNhLIh0kV4hVCCHi4uJEoUKFRKFChTRlDh4+fCi6du0q8uTJI0xNTYWLi4to2rSp2LVrl9Z937x5IwYOHChcXFw0RSS9vb21SkJER0eLOXPmiJIlSwpzc3Ph4OAgPD09xdSpU0VISIhmu4/LUKjdv39fUyzyzJkzST6/wMBAMWDAAOHq6ipMTU1Fnjx5RL169cSqVas026jLK+zcuVOv1y4sLExMmTJFlCxZUlhaWgobGxtRrVo1sWHDhkTD8BMWYp0/f75wdXUV5ubmokaNGuLatWuJ9q3L6/ypY/fu3TvRvXt34ejoKKytrUXDhg3FnTt3knwtV69eLQoWLChMTEx0KsT68euUXIHOn3/+WRQoUECYm5uLSpUqibNnzwpPT0/x7bff6vDqChEbGyvWrFkjatSoIezs7ISpqakoUKCA6N69u1aJCnUZioRFfhO+PgmLz+7fv1+UKVNGWFhYCDc3NzFnzhyxbt26RNupC7EmRdd9qLetWrWqsLS0FLa2tqJSpUri119/1dz+/v170bFjR2Fvb5+oEKuu7w/8V4g1KUhQhiIqKkqMHDlSlC1bVtjY2Ijs2bOLsmXLJioim1xMyR3nmzdvipYtWwp7e3thYWEhihUrJiZOnJhkPETpzUgItscSZWWPHz+Gu7s75s2bhxEjRigdjiJUKhVy5cqFVq1aJXlqjYgotbEPGBFlKZGRkYn6AW3atAlv375F7dq1lQmKiLIc9gEjoizl77//xrBhw9C2bVvkzJkTly9fxtq1a1GqVCm0bdtW6fCIKItgAkZEWYqbmxtcXV3x888/4+3bt8iRIwe6du2K2bNnJzvHJhFRamMfMCIiIqJ0xj5gREREROmMCRgRERFROlM0ATt58iSMjIywa9cuJcPQSIt4pkyZovP0GUZGRpgyZUqKHkcd+8mTJzXrunXrptMEw5TxGBkZYcOGDZ/dTsn/gdq1a+s9qjAl98nqNmzYkC6fMZT2kvocTy9z586Fh4fHZ+cMffz4sc6fP2lB/f/+77//KvL4Cfn4+MDa2jrFs5ekegJmZGSk058S/2D0ebdv38aUKVPw+PFjpUNJczt27MDXX38Ne3t75MyZE7Vq1cLBgwcTbadSqTB37ly4u7vDwsICZcqUwa+//prkPn19ffHtt9/C2toaOXLkQJcuXZJ8c+qzT0p/6i8ZXf6ywnslM5s5cyZ+++23L9qHOilI6m/MmDGpE2gaCg0NxZw5czB69OhEs3YoZfny5YoleTNnzsTXX3+NXLlywcLCAkWKFMHQoUMTfZZ/++23KFy4MGbNmpWix0n1UZCbN2/Wur5p0yYcOXIk0frixYvD19c3tR+eEli9evVnf8187Pbt25g6dSpq166dqVvPlixZgsGDB6NJkyaYPXs2IiMjsWHDBjRt2hS7d+9Gq1atNNuOHz8es2fPRu/evVGxYkXs27cPHTt2hJGRkdaUM8+fP0fNmjVhZ2eHmTNn4v379/jpp59w48YNXLx4UWuEna77JGXkypUr0WeWeo7HhQsXJto2o4iIiEC2bBz8ntDMmTPRpk0btGjR4ov3NW3aNLi7u2utK1Wq1BfvN62tW7cOsbGx6NChg9KhaCxfvhyOjo7o1q1buj/2pUuXUK5cObRv3x42Njbw9fXF6tWrNdNYqeepBYC+fftixIgRmDp1KmxsbPR6nFR/J3bu3Fnr+t9//40jR44kWg/gixOwDx8+wMrK6ov2kZmZmpoqHYLBWrJkCSpWrIjff/9dc/qmR48ecHFxwcaNGzUJmL+/P+bPn48BAwZg6dKlAIBevXqhVq1amvko1ZMgz5w5E+Hh4bh06RLy588PAKhUqRK++eYbbNiwAX369NF7n6SM7NmzJ/rM2rZtG969e5fkZ5maEAKRkZGJJjo3FBYWFkqHkKTM8lneqFEjvefBNATr169H8+bNDfb/I73t3r070boqVaqgTZs2+P3337V+JLdu3RqDBg3Czp070aNHD70exyDaGlUqFX788Ufky5cPFhYWqFevHh48eKC1Te3atVGqVClcunQJNWvWhJWVFcaNGwcAiIqKwuTJk1G4cGGYm5vD1dUVo0aNQlRUlNY+jhw5gurVq8Pe3h7W1tYoVqyYZh/6xgMAO3fuhKenJywtLeHo6IjOnTvD39//s883KioKw4YNQ65cuWBjY4PmzZvj+fPnOr9ez58/R4sWLZA9e3Y4OTlh2LBhiZ4rkHT/n23btsHT0xM2NjawtbVF6dKlsXjxYgCyGV1diLJOnTqJThfv27cPTZo0Qd68eWFubo5ChQph+vTpiIuL03oM9bG6ffs26tSpAysrK7i4uGDu3LmJYoyMjMSUKVNQtGhRWFhYwNnZGa1atcLDhw8126hUKixatAglS5aEhYUFcufOjb59++Ldu3da+woJCcGdO3cQEhLy2dcwNDQUTk5OWn1nbG1tYW1trfXluW/fPsTExKB///6adUZGRvj+++/x/PlznD9/XrN+9+7daNq0qSb5AoD69eujaNGi2LFjR4r2mRZ0fT11Pd4AsGrVKhQqVAiWlpaoVKkSTp8+nSqxRkdHY9KkSfD09ISdnR2yZ8+OGjVq4MSJE4m2ffPmDbp06QJbW1vY29vD29sb165dS9RfJSYmBnfu3NF5kutPcXNzQ9OmTTUTUFtaWuJ///vfJ/vJJNUPy9/fHz169EDu3Llhbm6OkiVLYt26dV8c3+ceW91H9cGDB+jWrRvs7e1hZ2eH7t2748OHD5rtSpUqhTp16iTan0qlgouLC9q0aaNzDOn1Wa7LvoyMjBAeHo6NGzdqPu8StrjcuXMHT58+1fm5JefJkyfo378/ihUrBktLS+TMmRNt27bV6fT1/fv30bp1a+TJkwcWFhbIly8f2rdvn+hzbsuWLZrvoxw5cqB9+/Z49uzZZ/fv5+eH69evo379+oluCw4ORrdu3WBnZ6d5TwUHBye5nzt37qBNmzbIkSMHLCwsUKFCBezfv19rG/Wp2lOnTqFv377ImTMnbG1t0bVrV63PHzc3N9y6dQt//fWX5rh83Dc0KioKw4cPR65cuZA9e3a0bNkyxX2xdKH+Lv34+Ts5OaFMmTLYt2+f3vs0iLbo2bNnw9jYGCNGjEBISAjmzp2LTp064cKFC1rbvXnzBo0aNUL79u3RuXNn5M6dGyqVCs2bN8eZM2fQp08fFC9eHDdu3MDChQtx7949zbn9W7duoWnTpihTpgymTZsGc3NzPHjwAGfPnk1RPBs2bED37t1RsWJFzJo1C4GBgVi8eDHOnj2LK1euwN7ePtnn26tXL2zZsgUdO3ZE1apVcfz4cTRp0kSn1yoiIgL16tXD06dPMXjwYOTNmxebN2/G8ePHP3vfI0eOoEOHDqhXrx7mzJkDQLZCnj17FkOGDEHNmjUxePBg/Pzzzxg3bhyKFy8OAJrLDRs2wNraGsOHD4e1tTWOHz+OSZMmITQ0FPPmzdN6rHfv3uHbb79Fq1at0K5dO+zatQujR49G6dKl0ahRIwBAXFwcmjZtimPHjqF9+/YYMmQIwsLCcOTIEdy8eROFChUCIJt41a/34MGD4efnh6VLl+LKlSs4e/aspqVv79696N69O9avX//ZZuvatWtj165dWLJkCZo1a4bIyEgsWbIEISEhGDJkiGa7K1euIHv27JrXQK1SpUqa26tXrw5/f3+8evUqyV+/lSpVwqFDh/TeZ1rR9fXU9XivXbsWffv2RdWqVTF06FA8evQIzZs3R44cOeDq6vpFsYaGhmLNmjXo0KEDevfujbCwMKxduxYNGzbExYsXUa5cOQAyEWjWrBkuXryI77//Hh4eHti3bx+8vb0T7dPf3x/FixeHt7d3qvQxuXv3Ljp06IC+ffuid+/eKFasmF73DwwMxNdffw0jIyMMHDgQuXLlwuHDh9GzZ0+EhoZi6NChXxzj57Rr1w7u7u6YNWsWLl++jDVr1sDJyUnzOeHl5YUpU6YgICAAefLk0dzvzJkzePHihd6nzdP6s1zXfW3evBm9evVCpUqVNC3U6s8dQH721apVS+c+yyEhIQgKCtJa5+joiH/++Qfnzp1D+/btkS9fPjx+/BgrVqxA7dq1cfv27WRb/6Kjo9GwYUNERUVh0KBByJMnD/z9/XHgwAEEBwfDzs4OAPDjjz9i4sSJaNeuHXr16oXXr19jyZIlqFmz5me/j86dOwcA+Oqrr7TWCyHw3Xff4cyZM+jXrx+KFy+OvXv3JvmeunXrFqpVqwYXFxeMGTMG2bNnx44dO9CiRQvs3r0bLVu21Np+4MCBsLe3x5QpU3D37l2sWLECT5480QxCWLRoEQYNGgRra2uMHz8eAJA7d26tfQwaNAgODg6YPHkyHj9+jEWLFmHgwIHYvn27Zpv3798jMjIy2eeuZmpqqnktEz7/N2/eIDY2Fvfv38eYMWNgYmKS5CAhT0/PlPUjTOvZvgcMGCCSe5gTJ04IAKJ48eIiKipKs37x4sUCgLhx44ZmXa1atQQAsXLlSq19bN68WRgbG4vTp09rrV+5cqUAIM6ePSuEEGLhwoUCgHj9+nWyseoaT3R0tHBychKlSpUSERERmu0OHDggAIhJkyZp1k2ePFnr+V+9elUAEP3799d67I4dOwoAYvLkycnGJ4QQixYtEgDEjh07NOvCw8NF4cKFBQBx4sQJzXpvb29RoEABzfUhQ4YIW1tbERsbm+z+d+7cmWg/ah8+fEi0rm/fvsLKykpERkZq1qmP1aZNmzTroqKiRJ48eUTr1q0169atWycAiAULFiTar0qlEkIIcfr0aQFAbN26Vet2Hx+fROvXr18vAIj169cn+/zUAgMDRb169QQAzZ+jo6M4d+6c1nZNmjQRBQsWTHT/8PBwAUCMGTNGCCHEP//8k+g5q40cOVIA0LxGuu7zU3R9nh//D+jzeupyvNXvhXLlymm9Z1atWiUAiFq1an02xoRq1aqldZ/Y2Fit/QohxLt370Tu3LlFjx49NOt2794tAIhFixZp1sXFxYm6desmeq38/PwEAOHt7a1XbE2aNNF6LYUQokCBAgKA8PHx0VqvfoykjtHH7/OePXsKZ2dnERQUpLVd+/bthZ2dXZLHISH1/70uPn5s9edTwtdSCCFatmwpcubMqbl+9+5dAUAsWbJEa7v+/fsLa2vrz8aYUHp8luu6LyGEyJ49e7L/C7r+D6uPQVJ/QiT9Xjp//nyizwz1d5D68/fKlSsCgNi5c2eyj/348WNhYmIifvzxR631N27cENmyZUu0/mMTJkwQAERYWJjW+t9++00AEHPnztWsi42NFTVq1Ej0v12vXj1RunRpre8BlUolqlatKooUKaJZp36dPD09RXR0tGb93LlzBQCxb98+zbqSJUsm+dqr91G/fn3N94QQQgwbNkyYmJiI4OBgzTpvb+9kj0vCv6Qe5+XLl1rb5MuXT2zfvj3J13DmzJkCgAgMDEzy9uQYxCnI7t27a3VQrlGjBgDg0aNHWtuZm5uje/fuWut27tyJ4sWLw8PDA0FBQZq/unXrAoDmVIX6F8C+ffs+2zH9c/H8+++/ePXqFfr37691zrxJkybw8PBIciSdmrolZPDgwVrrdf2Ve+jQITg7O2s1+VtZWWl+vX2Kvb09wsPDceTIEZ0e62MJT82FhYUhKCgINWrUwIcPH3Dnzh2tba2trbX6ypiZmaFSpUpax3T37t1wdHTEoEGDEj2W+tTgzp07YWdnh2+++Ubr+Hp6esLa2lrrVFS3bt0ghNCp06aVlRWKFSsGb29v7Ny5E+vWrdOc/kx4ujkiIgLm5uaJ7q8+7hEREVqXum6ry3ZpQZ/XU5fjrX4v9OvXT+s9oz5t8aVMTEw0+1WpVHj79i1iY2NRoUIFXL58WbOdj48PTE1N0bt3b806Y2NjDBgwINE+3dzcIIRItRFW7u7uaNiwYYruK4TA7t270axZMwghtI5Jw4YNERISovU800q/fv20rteoUQNv3rxBaGgoAKBo0aIoV66cVutCXFwcdu3ahWbNmund5y2tP8t13dfnCCH0GrG/bNkyHDlyROsP0H4vxcTE4M2bNyhcuDDs7e0/eXzV76E//vhD65RwQnv27IFKpUK7du20nmuePHlQpEiRzz7XN2/eIFu2bLC2ttZaf+jQIWTLlg3ff/+9Zp2JiUmiz+u3b9/i+PHjaNeuneZzIigoCG/evEHDhg1x//79RF1z+vTpo9VH+fvvv0e2bNm0zhR8Tp8+fbS6kNSoUQNxcXF48uSJZt2oUaMSHY+k/ubPn59o/zly5MCRI0fw+++/Y9q0aXB0dMT79++TjMXBwQEAErV+fo5BnIJM2GcGiH8yH/dJcXFxSTRX2/379+Hr65vsSKRXr14BkE3oa9asQa9evTBmzBjUq1cPrVq1Qps2bRINu/1cPOoDnNSpBg8PD5w5cybZ5/rkyRMYGxtrNXMnt6/k7l+4cOFEdX90uX///v2xY8cONGrUCC4uLmjQoAHatWuHb7/9VqfHvnXrFiZMmIDjx49rPpjVPu6PkC9fvkQxOjg44Pr165rrDx8+RLFixT45Kuv+/fsICQmBk5NTkrerj6++2rZti2zZsuH333/XrPvuu+9QpEgRjB8/XvNFY2lpmWT/OnWztvqDVX2p67a6bJcW9Hk9dTne6vdCkSJFtG43NTVFwYIFUyXmjRs3Yv78+bhz5w5iYmI06xOONnvy5AmcnZ0TncopXLhwqsTwKR+PetPH69evERwcjFWrVmHVqlVJbpPS/3F9fOozz9bWFoD8DB03bhz8/f3h4uKCkydP4tWrV/Dy8tL78dL6s1zXfaW2SpUqJdkNISIiArNmzcL69evh7+8PkWAGwE/1WXV3d8fw4cOxYMECbN26FTVq1EDz5s3RuXNnTXJ2//59CCESvQfVUjoYS/2e+jgx+/i75sGDBxBCYOLEiZg4cWKS+3r16hVcXFw01z+O1draGs7OznqVdNElbyhRogRKlCih8z4TMjMz0/SLa9q0KerVq4dq1arByckJTZs21dpWfTx1rcenZhAJWHIjvhL+kwJJfzGpVCqULl0aCxYsSHIf6j4olpaWOHXqFE6cOIGDBw/Cx8cH27dvR926dfHnn39qxaBrPBmNk5MTrl69ij/++AOHDx/G4cOHsX79enTt2hUbN2785H2Dg4NRq1Yt2NraYtq0aShUqBAsLCxw+fJljB49OtEv0dR6DVUqFZycnLB169Ykb09JCYBHjx7Bx8cn0Rdejhw5UL16da2+JM7Ozjhx4gSEEFpvLnUH7rx582q2S7g+oZcvXyJHjhyaVi9d95kWdH099T3eaWXLli3o1q0bWrRogZEjR8LJyQkmJiaYNWuW1kANJSX1uZTcB/HHAxjUr2Pnzp2T7FsDAGXKlPnCCD9Pl/erl5cXxo4di507d2Lo0KHYsWMH7OzsdP4Bl1Baf5bruq/0MmjQIKxfvx5Dhw5FlSpVYGdnpyk587n30vz589GtWzfs27cPf/75JwYPHoxZs2bh77//Rr58+aBSqWBkZITDhw8neRw/TqA+ljNnTsTGxiIsLEzvMgpA/P/wiBEjkm0JTosfQrr8z4aEhOh0RsHMzAw5cuT45DZVq1aFs7Mztm7dmigBUyd9jo6On32shAwiAfsShQoVwrVr11CvXr3PZp/GxsaoV68e6tWrhwULFmDmzJkYP348Tpw4keQIkOQUKFAAgOx8q27SVrt7967m9uTuq1KpNK0/Ce+n62PfvHkz0Ze3rvc3MzNDs2bN0KxZM6hUKvTv3x//+9//MHHixCRb1tROnjyJN2/eYM+ePahZs6ZmvZ+fn06Pm5RChQrhwoULiImJSfZXWqFChXD06FFUq1Yt1VqGAgMDAST+MgTk6YHY2FjN9XLlymHNmjXw9fXV+iWlHpCh7gTu4uKCXLlyJVmdOWFncX32mRZ0fT11Pd7q//X79+9rvRdiYmLg5+eHsmXLflG8u3btQsGCBbFnzx6t/83JkycniuPEiROJyhkkNXo5Pah/jX88Yirh6REAmpHQcXFxen0GKcHd3R2VKlXC9u3bMXDgQOzZswctWrRI8nR6SqTmZ7k++9K31SIldu3aBW9vb61TXZGRkcmOKPxY6dKlUbp0aUyYMAHnzp1DtWrVsHLlSsyYMQOFChWCEALu7u4oWrSo3rF5eHgAkO/thMl+gQIFcOzYMbx//14rifv4u0bd0m1qaqrz//D9+/e1RtW+f/8eL1++ROPGjTXrUuO4DBky5LONCwB0HmgRGRmZZIuln58fHB0d9W4QMIg+YF+iXbt28Pf3x+rVqxPdFhERgfDwcADyPPXH1F90SZ0O+pQKFSrAyckJK1eu1Lrv4cOH4evr+8kRjeoRgD///LPW+kWLFun02I0bN8aLFy+0pkv68OFDsqcvEnrz5o3WdWNjY80bTv081AXmPv5gUP/aSPjrIjo6GsuXL9cp7qS0bt0aQUFBmlpYCakfp127doiLi8P06dMTbRMbG6sVp65lKAoXLgxjY2Ns375d6/k8f/4cp0+fRvny5TXrvvvuO5iammo9TyEEVq5cCRcXF1StWlXr+Rw4cEBr6PexY8dw7949TXkPffeZ2nR9PXU93hUqVECuXLmwcuVKREdHa9Zv2LBB5y+XT0kqjgsXLiQq1dGwYUPExMRofQ6oVCosW7Ys0T5TswxFcmxtbeHo6IhTp05prf/49TMxMUHr1q2xe/du3Lx5M9F+0nJYfUp4eXnh77//xrp16xAUFJSi04/JSc3Pcl33BcjPvE+VVkiNMhQmJiaJWv+XLFmS5I/AhEJDQ7V+EAIyGTM2NtY811atWsHExARTp05N9Bjiv5F8n1KlShUASPTjsXHjxoiNjcWKFSs06+Li4rBkyRKt7ZycnFC7dm3873//S/I9ldT/8KpVq7S6E6xYsQKxsbGa70fg08dFVynpAxYeHp5kf7vdu3fj3bt3SZ5ivnTpkuZ11EeGbwHr0qULduzYgX79+uHEiROoVq0a4uLicOfOHezYsUNTn2fatGk4deoUmjRpggIFCuDVq1dYvnw58uXLp/eQf1NTU8yZMwfdu3dHrVq10KFDB00ZCjc3NwwbNizZ+5YrVw4dOnTA8uXLERISgqpVq+LYsWM6/1Lv3bs3li5diq5du+LSpUtwdnbG5s2bdSpi2KtXL7x9+xZ169ZFvnz58OTJEyxZsgTlypXTlEQoV64cTExMMGfOHISEhMDc3Bx169ZF1apV4eDgAG9vbwwePBhGRkbYvHnzF52W7dq1KzZt2oThw4fj4sWLqFGjBsLDw3H06FH0798f3333HWrVqoW+ffti1qxZuHr1Kho0aABTU1Pcv38fO3fuxOLFizUDEnQtQ5ErVy706NEDa9as0fQfCQsLw/LlyxEREYGxY8dqts2XLx+GDh2KefPmISYmBhUrVsRvv/2G06dPY+vWrVrN4OPGjcPOnTtRp04dDBkyBO/fv8e8efNQunRprQ7H+uwzten6eup6vE1NTTFjxgz07dsXdevWhZeXF/z8/LB+/fpU6QPWtGlT7NmzBy1btkSTJk3g5+eHlStXokSJElodYlu0aIFKlSrhhx9+wIMHD+Dh4YH9+/drvqwT/ppO7TIUyenVqxdmz56NXr16oUKFCjh16hTu3buXaLvZs2fjxIkTqFy5Mnr37o0SJUrg7du3uHz5Mo4ePZpkwqGUdu3aYcSIERgxYgRy5MiRqq12qflZruu+AFlC4OjRo1iwYAHy5s0Ld3d3VK5cGYD+ZSiS07RpU2zevBl2dnYoUaIEzp8/j6NHjyJnzpyfvN/x48cxcOBAtG3bFkWLFkVsbCw2b96sSdwB2XI4Y8YMjB07Fo8fP0aLFi1gY2MDPz8/7N27F3369MGIESOSfYyCBQuiVKlSOHr0qFYh0WbNmqFatWoYM2YMHj9+jBIlSmDPnj1J/sBdtmwZqlevjtKlS6N3794oWLAgAgMDcf78eTx//hzXrl3T2j46Ohr16tVDu3btcPfuXSxfvhzVq1dH8+bNNdt4enpixYoVmDFjBgoXLgwnJ6dEZ5w+JyV9wO7fv4/69evDy8sLHh4eMDY2xr///ostW7bAzc1Nq0wRIPu3Xb9+PckBP5+l15jJFNClDMXHQ2yTGsJdq1YtUbJkyST3Ex0dLebMmSNKliwpzM3NhYODg/D09BRTp04VISEhQgghjh07Jr777juRN29eYWZmJvLmzSs6dOgg7t27l6J4hBBi+/btonz58sLc3FzkyJFDdOrUSTx//lxrm4/LUAghREREhBg8eLDImTOnyJ49u2jWrJl49uyZTmUohBDiyZMnonnz5sLKyko4OjqKIUOGaMoIfKoMxa5du0SDBg2Ek5OTMDMzE/nz5xd9+/YVL1++1Nr/6tWrRcGCBYWJiYnWPs+ePSu+/vprYWlpKfLmzStGjRol/vjjj0SPm9yx+jgeIeTw7PHjxwt3d3dhamoq8uTJI9q0aSMePnyotd2qVauEp6ensLS0FDY2NqJ06dJi1KhR4sWLF5pt9ClDERMTI5YsWSLKlSsnrK2thbW1tahTp444fvx4om3j4uLEzJkzRYECBYSZmZkoWbKk2LJlS5L7vXnzpmjQoIGwsrIS9vb2olOnTiIgIOCL9pkUXZ9nUq+5ELq9nroebyGEWL58uXB3dxfm5uaiQoUK4tSpU4lKSuji4/uoVCrN62Rubi7Kly8vDhw4kOTzev36tejYsaOwsbERdnZ2olu3buLs2bMCgNi2bZtmu9QuQ9GkSZMkt//w4YPo2bOnsLOzEzY2NqJdu3bi1atXSb7PAwMDxYABA4Srq6vmfVCvXj2xatWqz8aVGmUoPi7poN6nn59fon1Uq1ZNABC9evXS6TE/lh6f5bruSwgh7ty5I2rWrCksLS0T/V9AzzIU//zzT5K3v3v3TnTv3l04OjoKa2tr0bBhQ3Hnzh1RoEABrcf7uAzFo0ePRI8ePUShQoWEhYWFyJEjh6hTp444evRoosfYvXu3qF69usiePbvInj278PDwEAMGDBB37979bPwLFixIspzImzdvRJcuXYStra2ws7MTXbp00ZTG+Pjz5+HDh6Jr164iT548wtTUVLi4uIimTZuKXbt2JXqd/vrrL9GnTx/h4OAgrK2tRadOncSbN2+09hcQECCaNGkibGxstI5Dcq/1x69dSr1+/Vr06dNHeHh4iOzZswszMzNRpEgRMXTo0CRLn6xYsUJYWVmJ0NBQvR/LSIgM3rOcKAsyMjLSqeBsVvfbb7+hZcuWOHPmDKpVq6Z0OGlCXVSXH+WUUiEhIShYsCDmzp2Lnj17ptnjqP9X//nnnww5ZVNSypcvj9q1ayeaI1YXGb4PGBERkLh+mrq/iq2tbaIq30QUz87ODqNGjcK8efPSbYRzZuDj44P79+9rdVvRR4bvA0ZEhu/169ef7HCsyzDwzxk0aBAiIiJQpUoVREVFYc+ePTh37hxmzpxpsJNjZyZv377VGojxMRMTkxSVjaH0MXr0aIwePVrpMDKUb7/9NtnirLpgAkZEaa5ixYqJSjAklBodnevWrYv58+fjwIEDiIyMROHChbFkyRIMHDjwi/ZLumnVqhX++uuvZG8vUKCAXoU2iTI7RfuAnTp1CvPmzcOlS5fw8uVL7N27Fy1atPjkfU6ePInhw4fj1q1bcHV1xYQJE9gPhsjAnT179pMFER0cHODp6ZmOEVFqu3TpUqLZSxKytLTMtP3wiFJC0Raw8PBwlC1bFj169ECrVq0+u72fnx+aNGmCfv36YevWrTh27Bh69eoFZ2fnFM/FRkRpj1+8mR8TaCL9GMwoSCMjo8+2gI0ePRoHDx7UKljYvn17BAcHw8fHJx2iJCIiIvpyGaoP2Pnz5xMV/mvYsCGGDh2a7H2ioqK0qtWrVCq8ffsWOXPmTJcpKIiIiOjLCSEQFhaGvHnzaiZez8gyVAIWEBCA3Llza63LnTs3QkNDERERkeRIp1mzZmHq1KnpFSIRERGloWfPniFfvnxKh/HFMlQClhJjx47F8OHDNddDQkKQP39+PHv2DLa2tgpGRkRE9GXi4oD374EPH4AXL4CnT4HoaODqVcDWFoiIAM6fB549A5ydgZgY4MYNwNoaEEJe/0T1EJ24uQGmpsD9+0CdOkC2bPLv0SOgZk3AxERef/UKKF0aMDYGjIzkn7oh6+N16uX8V/fhVZlv4FzICtmzh6JePVfY2Nh86ctmEDJUApYnTx4EBgZqrQsMDIStrW2ydX7Mzc1hbm6eaL2trS0TMCIiUpxKBQQGAsePyyQlMlImRleuADlyyNtjY4HLlwErK+Dff4E8eYDgYLmtrhLOlf2p8lXt2gElSgBFigAWFjKBUv8BMuGytARy55aXaSI8HBgwANi4EejVCxi6GqGh8qbM0n0oQyVgVapUwaFDh7TWHTlyJEWzkBMREaW1mBjZMnTtmnaL07RpMgkKDk7ZfgMCkl6fKxcQFAQ0bSpbvWrXlq1P0dGAuztQvDhgbg6YmckEytRU/tnZyfXqJEtRN2/KLNDXVzaH5c8vX7xMRtEE7P3793jw4IHmup+fH65evYocOXIgf/78GDt2LPz9/bFp0yYAQL9+/bB06VKMGjUKPXr0wPHjx7Fjxw4cPHhQqadARESkIQSwfz/w55/y8vlz3e9rbCxbu9q3lwmRqalMoipXlglTtmyyYcjDA8ieXeYl5uby1KKFhTxll6EJAaxbBwwaJM+dOjsDv/wis8hMSNEE7N9//0WdOnU019V9tby9vbFhwwa8fPkST58+1dzu7u6OgwcPYtiwYVi8eDHy5cuHNWvWsAYYERGlmrg42TLl7y9P8cXGyr8nT2QiBABnzsh8ISoKOHJEti7pMpnDt9/KxMrMTOYYw4cDRYvKU4qmpmn5rAzc+/dAv37A1q3yeoMGwObNgJOTsnGlIYOpA5ZeQkNDYWdnh5CQEPYBIyLKIoQAHjwAHj8GwsJk4qTuqH7mjFyfIwdw7lzqPWbFikCjRsCECVk8udLF8+dAuXIy850xAxg1Kr6H/n8y2/d3huoDRkRE9CkREcCtW0BICLB9u0yobt36sn0WLixP/5mYyH2pT9yYmwPVq8vWrKgooFQpwMYGKFlStmiRHvLlA379Vfbqr15d6WjSBRMwIiLKEA4dkq1Wjx7JhpLAQOD1a+DuXcDRUXY+11W1arIUw4sXQK1aMmErXlw2wpiYyNuzZ0+jJ0JAaCjQp4/s8KaeAeebbxQNKb0xASMiIoMRHS1PBx44ALx5A5w9K0cRvnjx6ft9nHxZWMhSCk5OQP36MrEqVw7ImTONAifdXboEeHkBDx8CJ07I/l5WVkpHle6YgBERUboLD5dJ1tGjwJo1svXpyRNZUPRz+vePHySXM6c8e+XsLP+srORlhh8RmBkJASxdCowYITPtAgWAbduyZPIFMAEjIqI09PatbJ1S179asybp8gy+vonvW60aULWq/J52c5N9q9zc0iNqSnXBwUDPnsCePfJ6ixay5ISDg5JRKYoJGBERfZIQssUpKkr2lXr7Vp4WBORpwqdPZX+pmBhZcNTaWm7j4/P5fWfPLvtgVasG1Ksn+2CXLGkgBUEpdQQHA+XLy3PLpqbATz/JWl9ZvJmSCRgREQGQ9a8ePJDfl8ePAzt3ylOF9+59+b4dHeV3r7GxrK+1aBHQt6/sq0WZnL29rMfxxx9yaGqFCkpHZBCYgBERZTFCyNpXW7bIFi1fX+D6df324e4uTyPWrStbx0xNZYV2U1M5n2H58rIlzNNT1sOiLObNG1m9NndueX3BAtmEamenbFwGhAkYEVEmpp4aZ8ECOZnzpyZhVrO2lt+dtrby9GCLFrIvVt68MsHK4meO6HPOnZPlJQoXltMEmJjIpk42d2phAkZElMGpW7SuXJHJkY+PnFPw2jXg5ctP37dsWXl2yMEBKFQIaNxY9sMi0ptKBcybB4wfL89nm5vLf8B8+ZSOzCAxASMiykBevwbu3JHlGo4eBTZs0L0Aab16st9V2bLyOzGLjv6ntPD6NeDtDRw+LK936AD8739yagBKEhMwIiID9/o1MHu2LJn0uYKkuXPLCZ/t7YGvv5ZnfypWZPkGSkOnT8tTji9eyNOMP/8M9OrFc9WfwQSMiMiAREfLqXbOnZMlkw4eTHq7UqXk91tsLDBkCNC5M6fOIQXExcnKuC9eyFEYO3YApUsrHVWGwASMiCgdffgAbN0qLx8+lCMIs2UDNm6Uy5/i7g506iQLiXMwGRkEExM5ifbixcDChXIEB+mECRgRURoQQtad3LkTePZMJlmLFum3D1tboHJloHdvoHVrWUOLSHHHj8tKvH37yuulSgGrVysbUwbEBIyIKJU8eQJMmSJHIQYEfHpbW1ugZUvg3Ts51U7evLIxoUkTeSaHyRYZnLg4YNo0YPp0+c/q6cmiql+ACRgRUQqFh8vvovPnZWvX06fJb9u6tWwocHKSDQecaocylBcv5Pnvkyfl9W7dgBIllIwow2MCRkSkh2fP5ACvv/6Shb2T0qcP8NVXQNOmgItL+sZHlOr++APo0kUOx7W2luUlOnZUOqoMjwkYEZGOnj6VpwsTMjeXidisWUCdOnIAGOtrUaYxZQowdapcLltWjnIsWlTRkDILJmBERMm4dw+YO1f+8N+/X/u2AgXkLCuFC7PcEWVi9vbysl8/OcqR0wmlGiZgRJSlRUfLDvN//ik7xP/6q5yK59y55O/TuHHy9bmIMrzw8PiickOGyJnVa9VSNqZMiAkYEWUJAQHAhQvA2rVASAhw+7buU/gAwKRJQLFi7PpCmVhMDDBunGzu/fdfOY2QkRGTrzTCBIyIMqUbN4CZMwF/fzlTiq769wfy5JH1t+zt5TQ+PMVImd6TJ3I6ob//ltd/+012vKc0wwSMiDKs2Fg59+8ffwBv3sgWLhMT4MGD5O/j4SFHJnp5ATlyyLIQVauyLARlYfv2ybISwcFyioV164BWrZSOKtNjAkZEGUpEBODnB3z/PXDq1Oe39/ICuneXpw8LFGBrFpFGdDQwapScRggAKlWSM767uysbVxbBBIyIDJ5KJTvHd+6c9O3ZssmWrBYtAFdXoFo1IH9++ceEiygZo0fHJ18//CDP2ZuZKRtTFsIEjIgMlp+fnK7n2rXEt+XIAdSoAfzyC+tuEaXImDGylsqsWUCzZkpHk+UwASMixQkBrFkD7N0L3Lkj50U8ezbpbceOBX78kS1bRHqLjJRvsg4d5PXcuYHr1znxqEKYgBFRunvxAnj0SE5a/eOPiW/384tfNjOTo+H//lsWPSWiFLh/H2jXDrh6VV5XJ2FMvhTDBIyI0tyHD7KryYMHcoDVp/TsKSetLloUKFJE/hHRF/j1VzlB6fv3gKOjPH9PimMCRkRp5uVLYMUKYPr0pG8vUEAWRW3ZUraEOTunb3xEmVpEhKxkv3q1vF6zpuw0yRniDQITMCJKVXFxsrXrhx8S32ZiIuf2bdZMzutLRGnkzh15yvHGDdlhcvx4YPJkOWSYDAKPBBGlirdvgS1b5A/ujzVtKlvBypVL97CIsqaHD2Xy5eQEbN0K1K+vdET0ESZgRJRiV67IKeP69En69i1bgE6d0jcmIgLQpIk89dikCc/tGygOfyAivd26JedK/OqrxMlX1apywJUQTL6I0s2tW7Iw3pMn8et69WLyZcCYgBGRzp48kaWDSpUCLl6MX1+woEy24uJk/S6WiyBKJ0LIocUVKwJnzgBDhyodEemIpyCJKFlCyDqNK1YAe/YAr19r316kCLB/v5zgmojS2fv3QL9+so8XADRoAPzvf8rGRDpjAkZEWiIjgZIlgagowN8/6W3MzWWJCQeH9I2NiP5z7Zoc5XjvnhxePH26nNuRhVUzDCZgRFnYhw9Ajx7y1OHNm0BsrCyWmhQHB2DzZqBxY04DRKSo06eBb76Rv5JcXIBt24Dq1ZWOivTEBIwoi1Gp5HyKe/Ykn2ypXb0K5M/Pli4ig1Kxojzv7+ICbNwoq9tThsMEjCiLeP0aKF8+6dOKBQoA338P2NoCderITvSs10hkQHx95fxcJiaAhQVw9KicUoinHDMsfsQSZXJRUbJcxO3b2uutrIDhw4EBA4A8eZSJjYg+Qwhg2TI5tcT48cCkSXI9W70yPCZgRJnU06cywdq9W3t9xYrA77/LchJEZMCCg+Xs9Hv2yOvXrsk+BGz1yhSYgBFlInfvyunetm9PfFvhwrJPV/bs6R4WEenr4kXAywt4/BgwNQXmzQMGD+YImEyEaTRRBvfmDTBypPxc9vBInHw5O8sf0PfvM/kiMnhCAAsXylGNjx8D7u6yuvGQIUy+Mhm2gBFlQO/eAa1aAX/9JT+vP+blBbRvD3z3HT+ziTIUPz9g3DggJgZo3RpYswawt1c6KkoDTMCIMohHj2TfrdOnE/frAmS3kP/9T3YZYdJFlEEVLCg73UdEAP37882ciTEBI8oAKlYE/v038Xp7e2D5cvlD2cws3cMioi+lUgHz58uJtL/+Wq7r0UPZmChdMAEjMmAxMUDp0rJzvVqzZkDOnMCPPwJ58yoXGxF9odevAW9v4PBhWYzv5k3A2lrpqCidMAEjMkABAcD69bIrSEIhIbJYKhFlcKdOAR06AC9eyMKq48dzlEwWwwSMyIDExcmiqdevJ77t/Xt+PhNleCoVMGuWLKiqUgHFigE7dgBlyigdGaUzlqEgUlBAALBypexna2Qkp/9JmHzlywf89pv8nGbyRZTBvX8PfPstMGGCfFN36SI7dzL5ypLYAkakgJAQoGbNpFu6AJl4Xb/OSbCJMpXs2QFLS/m3fDnQrZvSEZGCmIARpaMzZ4AWLWTx1ITy55cd6leuBIoUkfM0ElEmEBcHREfLpMvISHbuDAgASpRQOjJSGBMwonRw6RLQsGHixKtcOTkAipNhE2VCL18CHTsCLi7A5s0yAcuRQ/5Rlsc+YERpQAg5e4i3t+zXVaGCdvK1YwcQGwtcucLkiyhT+vNPoGxZ4ORJ2ZHz0SOlIyIDwwSMKJX9+qusSl+9OrBpkzwDoTZsmOz/1bYtYGKiXIxElEZiY2VJiW+/lXW+ypSRHe0LFVI6MjIwPAVJlEqePAEGDwb279deX6OGPAvh7S27gRBRJvX8uXyznz4tr/ftKyfW5hufksAEjOgLCAHMmQOMHZv4tk2b5ChzIsoCVCqgUSNZzd7GBli9GvDyUjoqMmA8BUmUQqtWyVONHydf330ni1sz+SLKQoyNgUWLZIfPy5eZfNFnsQWMSA8BAYCzc9K3zZ8PDB0qP4eJKAt4+hS4cwdo0EBer1cPuHCBHwKkE/6XEOng8mXA0zPp5OvcOXkqcvhwfu4SZRn798s6Mm3aAA8exK/nhwDpiC1gRJ/w/Dng6pp4vbOz7OrBcj5EWUx0NDB6tDzdCAAVK8paM0R6UjxVX7ZsGdzc3GBhYYHKlSvj4sWLn9x+0aJFKFasGCwtLeHq6ophw4YhMjIynaKlrODePWD6dFkz8ePkq2lTmZS9eMHkiyjL8fOT9WXUydewYXJ6Czc3JaOiDErRtH379u0YPnw4Vq5cicqVK2PRokVo2LAh7t69Cycnp0Tb//LLLxgzZgzWrVuHqlWr4t69e+jWrRuMjIywYMECBZ4BZSZ//CEHMQmR+LY8eWQdRY4mJ8qidu8GevaUhfwcHIANG4DmzZWOijIwRVvAFixYgN69e6N79+4oUaIEVq5cCSsrK6xbty7J7c+dO4dq1aqhY8eOcHNzQ4MGDdChQ4fPtpoRfU7FirJuYsLkq2JFOcJRpZIzijD5IsrCzp2TyVeVKsDVq0y+6IsploBFR0fj0qVLqF+/fnwwxsaoX78+zp8/n+R9qlatikuXLmkSrkePHuHQoUNo3Lhxso8TFRWF0NBQrT8ilQq4dg1o0kSeavz33/jbRo8GIiOBixeBmTPl7USUBSX8RTZrFrB4MfDXX0D+/MrFRJmGYqcgg4KCEBcXh9y5c2utz507N+7cuZPkfTp27IigoCBUr14dQgjExsaiX79+GDduXLKPM2vWLEydOjVVY6eMbfNmoGvXpG+LigLMzNI3HiIyQNu2ARs3ytGOpqbyg2HwYKWjokxE8U74+jh58iRmzpyJ5cuX4/Lly9izZw8OHjyI6dOnJ3ufsWPHIiQkRPP37NmzdIyYDE2JEomTL2dn2dolBJMvoiwvIkJOIdShA+DjIyvaE6UBxVrAHB0dYWJigsDAQK31gYGByJMnT5L3mThxIrp06YJevXoBAEqXLo3w8HD06dMH48ePh3ES9VfMzc1hbm6e+k+AMpz27QFf3/jrPj5Aw4bKxUNEBubuXaBdO+D6ddn3YNw4oE8fpaOiTEqxFjAzMzN4enri2LFjmnUqlQrHjh1DlSpVkrzPhw8fEiVZJiYmAACR1NA1Isj+XUZGwPbt8etUKiZfRJTAli2y2vL164CTkxwWPWMGa3xRmlH0FOTw4cOxevVqbNy4Eb6+vvj+++8RHh6O7t27AwC6du2KsQkm2mvWrBlWrFiBbdu2wc/PD0eOHMHEiRPRrFkzTSJGBMjTiefPy7ISFSvGr/f0lHUU2bGeiDR+/FFO3hoeDtSpI0c5fvON0lFRJqdoau/l5YXXr19j0qRJCAgIQLly5eDj46PpmP/06VOtFq8JEybAyMgIEyZMgL+/P3LlyoVmzZrhxx9/VOopkIE5e1aOXDx0KPFtK1fKrh1ERFratAHmzpXziU2YAPAHPaUDI5HFzt2FhobCzs4OISEhsLW1VTocSiVRUYCFRdK3ubkBp08D+fKla0hEZKiEkKcay5aNX/fmDZAzp3Ix0Wdltu/vDDUKkigpCxcmTr7c3YG//5afs35+TL6I6D/v38uh0F99JWt6qTH5onTGBIwyJCGABQtkX67hw+PX16olb3v0CKhcWbn4iMgAXb8OVKggO9wDwM2bysZDWRqHd1CG88cfctqgj504AdSune7hEJGhE0LW8xo8WPZXcHEBfv0VqFFD6cgoC2MLGGUoNWsmTr42bZKfr0y+iCiR0FCgY0c5AicqSg6NvnqVyRcpji1glGHkzSsnxVbjqEYi+qx9++S0QiYmcj7HH34AkijaTZTemICRwbt0SXbbSCgiIvlRj0REGp07A1euAG3bAskU+SZSAn8GkEHbvj1x8hUXx+SLiJIRHAwMHAi8eyevGxnJETtMvsjAMAEjg9W+vfxTmzdP9vXi2QMiStI//8jyEsuWAd9/r3Q0RJ/EU5BkkI4c0Z678cIFoFIl5eIhIgMmBLB4MTBqFBATIwsB/vCD0lERfRITMDI4nToBv/wSf/35czlqnIgokbdvge7dgf375fXWrYE1awB7e0XDIvocJmBkUKZP106+fv2VyRcRJePGDaBpU+DpU8DMTPb16t9f9vsiMnBMwMhgTJ0KTJkSf93fX5aeICJKUt688vRjoULAjh2y/xdRBsEEjAxCkybAoUPx1y9dYvJFREkICwOsrWUrV86cwOHDgKsrkAkmZ6ashePJSHG9e2snX0+f8ocsESXh9GmgeHFgw4b4dSVLMvmiDIkJGClq1CjZX1YtIkL+mCUi0lCpgJkzgTp1ZN+EJUtkQUCiDIwJGCkmLEzW9lJ7944FVonoI69eyQlgx4+XSVfnzsCpU3JqIaIMjAkYKWLLFu2zBmfPctQ4EX3kxAmgbFlZGNDSEli7Fti0SfYBI8rg2Amf0t2UKXLEo9qYMUDVqoqFQ0SG6MkToEEDIDYWKFFCjnIsWVLpqIhSDRMwSjdBQbL/bFBQ/Lo//wS++Ua5mIjIQBUoAIwdKysxL1kCZM+udEREqYqnICldTJsG5MqlnXwdO8bki4gSOHoUePAg/vrUqcC6dUy+KFNiAkZpJjYW+PlnWa5n8uT49c2aydvq1lUuNiIyILGxwIQJ8pSjlxcQFSXXs6I9ZWI8BUlpxtQ08bqjR4F69dI/FiIyUP7+QIcOssYXAFSsKKvbE2VyTMAo1cXFyTkdE/rjD/njlohI4/BhoGtX2TfBxgZYtQpo317pqIjSBRMwSlUxMXJO3ISiohKvI6IsLCZGnnKcO1deL18e2L4dKFJE2biI0hH7gFGqCQxMnGjdv8/ki4g+IoSs8QUAAwYA584x+aIshy1glCri4oA8eeKvly4NXL+uXDxEZICEkB3rzcxki9fly0Dr1kpHRaQItoBRqsifP37Z25vJFxElEB0NDB8upxNSc3dn8kVZGlvA6Is9eAC8eBF/fcMGxUIhIkPj5yc71l+8KFu/unYFPDyUjopIcWwBoy+WsOvG27fKxUFEBmbPHtnB/uJFOdnr3r1Mvoj+wwSMvsiiRfHLy5YBDg6KhUJEhiIqChg0SJ5iDAkBvv4auHoV+O47pSMjMhg8BUkpdu4cMGxY/PX+/ZWLhYgMhBCy6N+pU/L6qFHAjBlJV2YmysLYAkYp8uuvQLVq8dfv3lUuFiIyIEZGQK9eQM6cwMGDwJw5TL6IksAWMNJb5cqyS4fatGlA0aLKxUNECouIAB4/BooXl9e7dAGaNAFy5FA0LCJDxhYw0svOndrJ18qVwMSJysVDRAq7e1f28apfH3j9On49ky+iT2ILGOllwYL45ZgYIBv/g4iyri1bgH79gPBwIFcuWXIiVy6loyLKENgCRjqLiAD+/lsuDx7M5Isoy/rwAejZU55qDA8HateWoxwrVVI6MqIMgwkY6WzIkPjlCROUi4OIFHT7tky01q2THe4nTwaOHgXy5lU6MqIMhW0YpJOwMGD1arlcvDjPMhBlWXPmALduyclft24F6tZVOiKiDIkJGOnE1jZ++cIF5eIgIoX9/LPsfzBzJpA7t9LREGVYPAVJn9W1a/xy3ryAjY1ysRBROrtxAxg5UhZYBQA7O2DtWiZfRF+ILWCUrA0bgO7dtdex4CpRFiEEsGaNHHETGQkUKyYLrBJRqmACRkkSInHydeMGYG2tTDxElI5CQ4G+fYFt2+T1Ro04jyNRKuMpSEpSwrMLa9fKhKxUKeXiIaJ0cuUK4Okpky8TE9np/sABjrwhSmVf1AIWGRkJCwuL1IqFDMS+ffEFrT08gB49lI2HiNLJ5s3yNGN0NODqKpOwqlWVjoooU9K7BUylUmH69OlwcXGBtbU1Hj16BACYOHEi1q5dm+oBUvoKCQFatIi/fvu2YqEQUXpzdwfi4oBmzWRhVSZfRGlG7wRsxowZ2LBhA+bOnQszMzPN+lKlSmHNmjWpGhylv7lz45ePHJF1FokoEwsJiV+uXh04f142g3MuR6I0pXcCtmnTJqxatQqdOnWCiYmJZn3ZsmVx586dVA2O0t/MmfLyq6/k3LpElEkJASxeDLi5aTd1V6zIX15E6UDvBMzf3x+FCxdOtF6lUiEmJiZVgiJl7N4dvzxtmnJxEFEae/sWaNkSGDoUCA6WNWeIKF3pnYCVKFECp0+fTrR+165dKF++fKoERelPpQLatJHL1tZAkybKxkNEaeTvv4Hy5eVpRjMzYMkSOdKRiNKV3qMgJ02aBG9vb/j7+0OlUmHPnj24e/cuNm3ahAMHDqRFjJQO6tSJX+aPYaJMSKUCFiwAxo4FYmOBQoWA7dtlyQkiSnd6t4B99913+P3333H06FFkz54dkyZNgq+vL37//Xd88803aREjpbF9+4BTp+Ry6dJA69bKxkNEaWDLFjmlUGws0K4dcOkSky8iBRkJoZ7gK2sIDQ2FnZ0dQkJCYJtwhuks6uVLOb+j2vv3QPbsysVDRGkkNlb2LWjZUla5Z0d7ymAy2/e33i1gBQsWxJs3bxKtDw4ORsGCBVMlKEo/tWvHL2/cyOSLKNNQqeRcjlFR8nq2bICPD9CvH5MvIgOgdwL2+PFjxMXFJVofFRUFf3//VAmK0sfjx8C9e3K5XDmga1cloyGiVPPqlZy/sXdvYPTo+PVMvIgMhs6d8Pfv369Z/uOPP2BnZ6e5HhcXh2PHjsHNzS1Vg6O0M3Ik8NNP8dd9fJSLhYhS0cmTQMeOsn+BpSVQpozSERFREnROwFr8Nz+NkZERvL29tW4zNTWFm5sb5s+fn6rBUdpYtEg7+Ro0SHvybSLKgOLigB9/BKZOlacfixcHdu4ESpZUOjIiSoLOCZhKpQIAuLu7459//oGjo2OaBUVpK2Hy9eCBHI1ORBlYQADQqRNw/Li83r27rO/FTp1EBkvvOmB+fn5pEQelk6tXAXVXvXXrmHwRZQofPgD//gtYWQErVwJduigdERF9ht4JGACEh4fjr7/+wtOnTxEdHa112+DBg1MlMEobCScraN5cuTiI6AsJEd+pvmBBYMcOoEABwMND2biISCd6J2BXrlxB48aN8eHDB4SHhyNHjhwICgqClZUVnJycmIAZsIQ/irt0AXLmVC4WIvoC/v5A586yqn2DBnJdw4bKxkREetG7DMWwYcPQrFkzvHv3DpaWlvj777/x5MkTeHp64qeEnYvIoGzeLAthq3G6IaIMysdH1o05eRLo318WWCWiDEfvBOzq1av44YcfYGxsDBMTE0RFRcHV1RVz587FuHHj0iJG+kKHDmnX+Hr7FjDW+8gTkaJiYoAxY2R9r6AgmYQdOiQLrBJRhqP317CpqSmM//v2dnJywtOnTwEAdnZ2ePbsmd4BLFu2DG5ubrCwsEDlypVx8eLFT24fHByMAQMGwNnZGebm5ihatCgOHTqk9+NmJU2axC8fPw44OCgXCxGlwLNnctqKOXPk9f79gfPngaJFFQ2LiFJO759O5cuXxz///IMiRYqgVq1amDRpEoKCgrB582aUKlVKr31t374dw4cPx8qVK1G5cmUsWrQIDRs2xN27d+Hk5JRo++joaHzzzTdwcnLCrl274OLigidPnsDe3l7fp5FlJMyJFywA6tRRLhYiSgF/f9na9fYtYGsLrF0LtGmjdFRE9IX0noz733//RVhYGOrUqYNXr16ha9euOHfuHIoUKYK1a9eiXLlyOu+rcuXKqFixIpYuXQpA1hpzdXXFoEGDMGbMmETbr1y5EvPmzcOdO3dgamqqT9gamW0yz89p0AA4ckQuR0cDKXzZiEhJ3boBt24B27fLEY9EWVBm+/7WOwFLLdHR0bCyssKuXbs0VfYBwNvbG8HBwdi3b1+i+zRu3Bg5cuSAlZUV9u3bh1y5cqFjx44YPXo0TExMdHrczHYAP0c9Sv2rr4BLl5SNhYh09PgxYG0NqAtef/gAmJgA5uaKhkWkpMz2/Z1qXbEvX76Mpk2b6rx9UFAQ4uLikPujOXBy586NgICAJO/z6NEj7Nq1C3FxcTh06BAmTpyI+fPnY8aMGck+TlRUFEJDQ7X+soqE3ekmTFAuDiLSw9698pSjt7ecUgiQBVaZfBFlKnolYH/88QdGjBiBcePG4dGjRwCAO3fuoEWLFqhYsaJmuqK0olKp4OTkhFWrVsHT0xNeXl4YP348Vq5cmex9Zs2aBTs7O82fq6trmsZoSA4ciF/+7jvl4iAiHURFAYMHA61aASEhwJs38pKIMiWdE7C1a9eiUaNG2LBhA+bMmYOvv/4aW7ZsQZUqVZAnTx7cvHlTr9GIjo6OMDExQWBgoNb6wMBA5MmTJ8n7ODs7o2jRolqnG4sXL46AgIBEFfnVxo4di5CQEM1fSkZqZkSRkcD06XK5WTOWnSAyaA8fAtWqyfkbAWDECOD0aQ5ZJsrEdP5aXrx4MebMmYOgoCDs2LEDQUFBWL58OW7cuIGVK1eiePHiej2wmZkZPD09cezYMc06lUqFY8eOoUqVKknep1q1anjw4IFWS9u9e/fg7OwMMzOzJO9jbm4OW1tbrb+s4Jtv4pdbt1YuDiL6jB075Bxhly7J6SkOHADmzeOIGaJMTucE7OHDh2jbti0AoFWrVsiWLRvmzZuHfPnypfjBhw8fjtWrV2Pjxo3w9fXF999/j/DwcHTv3h0A0LVrV4wdO1az/ffff4+3b99iyJAhuHfvHg4ePIiZM2diwIABKY4hM7pyBThzJv66t7dysRDRJ0RGyumEwsJkC9jVq9qF+4go09K5DlhERASsrKwAAEZGRjA3N4ezs/MXPbiXlxdev36NSZMmISAgAOXKlYOPj4+mY/7Tp081RV8BwNXVFX/88QeGDRuGMmXKwMXFBUOGDMHo0aO/KI7M5quv4pcfPFAuDiL6DAsLWVpi715g6lRWtSfKQnQuQ2FsbIwZM2bA2toaADB69GiMHDkSjuph0v8x9Mm4M9sw1o/98gvQqZNc7tFD1mwkIgPyyy+yrESvXkpHQpShZLbvb50TMDc3Nxipi0oltzMjI83oSEOV2Q7gxxIeothYWTqIiAzAhw/AkCHAmjWAmZk83ahn31mirCyzfX/r3N79+PHjNAyDUkNkZPzyDz8w+SIyGL6+QLt2wM2b8lfS2LGcx5Eoi2OHg0zk6NH45blzlYuDiBLYuFFOnv3hA5A7tzwFWbeu0lERkcKYgGUSQsh6X2qs+0WkMCGA3r3jO2LWrw9s2SKTMCLK8vg1nUncvRu/vGOHcnEQ0X+MjOTE2cbGsiqyjw+TLyLSUGwybqVktk58anXrAidOyOWsdUSJDIgQcvoge3t5XaWSne0T1oYhohTJbN/fbAHLJNTJV6FCysZBlGWFhckaMDVqyP5egGz9YvJFRElIUQL28OFDTJgwAR06dMCrV68AAIcPH8atW7dSNTjSzfPn8ctbtigXB1GWdfUq4OkJ/PqrHPF46pTSERGRgdM7Afvrr79QunRpXLhwAXv27MH79+8BANeuXcPkyZNTPUD6vJIl45e//lq5OIiyHCGAFSvkG+/+fcDVVSZf336rdGREZOD0TsDGjBmDGTNm4MiRI1oTYNetWxd///13qgZHn/fiBRAaKpfr1VM2FqIsJSQE8PKSJSaiouQw5CtXgKpVlY6MiDIAvROwGzduoGXLlonWOzk5ISgoKFWCIt2tXBm/vGePcnEQZTkDBwI7d8r5G+fPB/btA3LmVDoqIsog9E7A7O3t8fLly0Trr1y5AhcXl1QJinS3bp28/PprIBMMCiHKOGbNkv2+zpwBhg/XngeMiOgz9E7A2rdvj9GjRyMgIABGRkZQqVQ4e/YsRowYga5du6ZFjJSMR48Af3+5zMr3RGns3TtZ1V4tXz7gn3+AypWVi4mIMiy9E7CZM2fCw8MDrq6ueP/+PUqUKIGaNWuiatWqmDBhQlrESMlIWHKiWjXl4iDK9C5cAMqXB7p1k6ca1djqRUQppPdURGZmZli9ejUmTpyImzdv4v379yhfvjyKFCmSFvHRJ+TNKzvhN2nCqYeI0oQQwIIFwJgxQGys/NWTL5/SURFRJqB3AnbmzBlUr14d+fPnR/78+dMiJtLRixfycvZsZeMgypTevJEtXgcOyOvt2gGrV7OzJRGlCr3bTerWrQt3d3eMGzcOt2/fTouYSAfPnsUvOzoqFwdRpnT2LFCunEy+zM1lra9t25h8EVGq0TsBe/HiBX744Qf89ddfKFWqFMqVK4d58+bhecJy7JSmoqKAhI2PefIoFwtRpvTihZxiokgR4O+/gX792N+LiFKV3gmYo6MjBg4ciLNnz+Lhw4do27YtNm7cCDc3N9StWzctYqSPtGoVv9ytm2JhEGUuCWexb9sW2LABuHRJtoQREaUyIyESfuroLy4uDocPH8bEiRNx/fp1xMXFpVZsaSKjz6b+xx/as5zExbEDPtEX++svYNgw4OBBwNlZ6WiIKAkZ/fv7Yyn+6j579iz69+8PZ2dndOzYEaVKlcLBgwdTMzb6iJ+fdvIVEMDki+iLxMUB06cDdevKaYQmTVI6IiLKIvQeBTl27Fhs27YNL168wDfffIPFixfju+++g5WVVVrERwkMHRq/fPw4kDu3YqEQZXwBAUDnzsCxY/J6t27AokVKRkREWYjeCdipU6cwcuRItGvXDo4cfpeu9u+Xl+3bA3XqKBsLUYZ27BjQqRMQGAhYWclRjpzJg4jSkd4J2NmzZ9MiDvqM0ND45eHDlYuDKMPbuxdo3Vp2ui9VCtixAyheXOmoiCiL0SkB279/Pxo1agRTU1PsVzfDJKN58+apEhhpS9i9rmJF5eIgyvC++QYoVgyoUQNYvBiwtFQ6IiLKgnQaBWlsbIyAgAA4OTnB+BO9vo2MjDgKMg0Iod3Z/svGrRJlQf/8A3h6xr+RQkIAOztlYyIivWTE7+9P0WkMnUqlgpOTk2Y5uT9DT74yqoTJV/fuysVBlOHExgJjxwKVKsk5HdWYfBGRwvQuYrBp0yZERUUlWh8dHY1NmzalSlAUb/t27eurVysTB1GG8+wZULt2/GSpnK2DiAyI3glY9+7dERISkmh9WFgYurN5JtX99lv8skoFmJgoFgpRxnHwoKxgf/asnL9x506WmCAig6J3AiaEgFESc6I9f/4cdmzWT3XbtsnLBQs4FR3RZ0VHAyNGAE2bAm/fAhUqyAKrbdooHRkRkRady1CUL18eRkZGMDIyQr169ZAtW/xd4+Li4Ofnh28TlmmnL/bmTfxy2bLKxUGUYfj6Aj//LJeHDAHmzAHMzZWNiYgoCTonYC1atAAAXL16FQ0bNoS1tbXmNjMzM7i5uaF169apHmBWlrDPMAuvEumgbFlg6VLAyQn47zOLiMgQ6T0Z98aNG+Hl5QULC4u0iilNZZRhrGFhsusKALi4sP8wUZKiooBx44AuXWSfLyLKtDLK97eu9K6E7+3tnRZx0EeuXo1fPnJEsTCIDNfDh4CXF3DpEnDgAHDzJmBqqnRUREQ60SkBy5EjB+7duwdHR0c4ODgk2Qlf7e3bt6kWXFamnvGpeHHOkkKUyM6dQK9eco6uHDnk+XomX0SUgeiUgC1cuBA2Njaa5U8lYJQ6xo6Vl/7+ysZBZFAiI+VkqCtWyOvVqgG//gq4uiobFxGRnnRKwBKeduzWrVtaxUL/efIkfnnGDOXiIDIor18DDRrEn58fOxaYNg3IpndPCiIixeldB+zy5cu4ceOG5vq+ffvQokULjBs3DtHR0akaXFalHkUPAAMHKhcHkUHJkQNwdARy5QJ8fICZM5l8EVGGpXcC1rdvX9y7dw8A8OjRI3h5ecHKygo7d+7EqFGjUj3ArEaI+PITuXOz+CplcR8+ABERctnEBNi6VbaANWyoaFhERF9K7wTs3r17KPffcO+dO3eiVq1a+OWXX7Bhwwbs3r07tePLcvr0iV/esUO5OIgU5+sLVK4MDB0av87JCcibV7GQiIhSS4qmIlKpVACAo0ePonHjxgAAV1dXBAUFpW50WVBgYPxyzZrKxUGkqI0b5TRCN28C+/bJ/l9ERJmI3glYhQoVMGPGDGzevBl//fUXmjRpAgDw8/ND7ty5Uz3ArOb33+Xl6tXKxkGkiPBwoFs3+ffhA1CvnjzlmCuXwoEREaUuvROwRYsW4fLlyxg4cCDGjx+PwoULAwB27dqFqlWrpnqAWYmvb/xy5crKxUGkiJs3gYoVZeuXsTEwfTrwxx9AnjxKR0ZElOr0noooOZGRkTAxMYGpgRdDNOSpDDZtAtQVP1LnqBBlENHRQKFCcs6tvHmBX34BatVSOioiMiCG/P2dEikew33p0iX4/tdkU6JECXz11VepFlRW9eaNvEwwzzlR1mBmBqxcCSxbJlvAeMqRiDI5vROwV69ewcvLC3/99Rfs7e0BAMHBwahTpw62bduGXPzgTLERI+Rl27bKxkGULq5dA169Ar75Rl5v0gRo3Ji1V4goS9C7D9igQYPw/v173Lp1C2/fvsXbt29x8+ZNhIaGYvDgwWkRY5bw7h3w3+BSODkpGwtRmhJCtnZVriwn0376NP42Jl9ElEXo3QLm4+ODo0ePoniCGaJLlCiBZcuWoUGDBqkaXFaintoOAKZOVS4OojQVEiKL3amL3H3zDZA9u7IxEREpQO8WMJVKlWRHe1NTU019MNLfhw/y0txc/hFlOpcuAV99JZOvbNmA+fOB/fuBnDmVjoyIKN3pnYDVrVsXQ4YMwYsXLzTr/P39MWzYMNSrVy9Vg8tKwsPlZefOysZBlCaWLAGqVgUePQIKFADOnAGGD+cpRyLKsvROwJYuXYrQ0FC4ubmhUKFCKFSoENzd3REaGoolS5akRYxZwqJF8tLRUdEwiNLGrVuy1ESLFsCVKyx0R0RZnt59wFxdXXH58mUcO3ZMU4aiePHiqF+/fqoHlxWVKqV0BESpRIj4Fq6FC2ULWJcubPUiIoKeCdj27duxf/9+REdHo169ehg0aFBaxZWlXLwYv6wekU+UYQkhE64jR4ADBwATE8DSEujaVenIiIgMhs4J2IoVKzBgwAAUKVIElpaW2LNnDx4+fIh58+alZXxZwuLF8cucTpMytDdv5DyOBw7I63v2sLAdEVESdO4DtnTpUkyePBl3797F1atXsXHjRixfvjwtY8sy1CMgK1RQNg6iL3LuHFC+vEy+zM1lbZU2bZSOiojIIOmcgD169Aje6okKAXTs2BGxsbF4+fJlmgSWlfz2m7wcOlTJKIhSSKUC5swBatYEnj0DihQB/v4b6NeP/b2IiJKhcwIWFRWF7AkKJhobG8PMzAwRERFpElhWkaCaByvgU8Y0eDAwZgwQFwd07CjrfZUrp3RUREQGTa9O+BMnToSVlZXmenR0NH788UfY2dlp1i1YsCD1ossCRo2KX65TR7k4iFKsTx/g11+BuXOBHj3Y6kVEpAMjIYTQZcPatWvD6DMfrEZGRjh+/HiqBJZWQkNDYWdnh5CQENja2iodjua7qkmT+H7LRAYtLg7491/tWl5hYYCNjXIxEVGmZ2jf319K5xawkydPpmEYWdPVq/HLnMecMoTAQDldw8mTspq9Oglj8kVEpBe9K+FT6ilfPn6Z85iTwTt+HChbFjh6FDAzA54/VzoiIqIMiwmYQhJ2lRswQLk4iD4rLg6YPBmoX1+2gJUqJU9Btm6tdGRERBmWzn3AMgtDOYecsDudSsV+y2SgXrwAOnWSpxwBoFcvWTk4wWAcIqL0YCjf36nFIFrAli1bBjc3N1hYWKBy5cq4mHBunk/Ytm0bjIyM0KJFi7QNMJUlLD2xZw+TLzJge/bI5MvaGti6FVi9mskXEVEqUDwB2759O4YPH47Jkyfj8uXLKFu2LBo2bIhXr1598n6PHz/GiBEjUKNGjXSKNPUcPhy/3LKlcnEQfdaAAcCIEbK2V8eOSkdDRJRppCgBO336NDp37owqVarA398fALB582acOXNG730tWLAAvXv3Rvfu3VGiRAmsXLkSVlZWWLduXbL3iYuLQ6dOnTB16lQULFgwJU9BUXfvyssyZZSNgyiR58/lXI5hYfK6kREwbx5QtKiiYRERZTZ6J2C7d+9Gw4YNYWlpiStXriAqKgoAEBISgpkzZ+q1r+joaFy6dAn169ePD8jYGPXr18f58+eTvd+0adPg5OSEnj176hu+QQgPl5e1aikbB5GWgwdlBfuNG4EfflA6GiKiTE3vBGzGjBlYuXIlVq9eDVNTU836atWq4fLly3rtKygoCHFxccidO7fW+ty5cyMgICDJ+5w5cwZr167F6tWrdXqMqKgohIaGav0pTT2HubOzsnEQAQBiYoCRI4GmTYE3bwBPT2D0aKWjIiLK1PROwO7evYuaNWsmWm9nZ4fg4ODUiClZYWFh6NKlC1avXg1HR0ed7jNr1izY2dlp/lxdXdM0xs+5ciV+uVAh5eIgAgA8eSIn0f7pJ3l98GDg7Fn+cxIRpTG95oIEgDx58uDBgwdwc3PTWn/mzBm9+2M5OjrCxMQEgYGBWusDAwORJ0+eRNs/fPgQjx8/RrNmzTTrVCoVACBbtmy4e/cuCn30xTF27FgMHz5ccz00NFTRJOyrr+KX27ZVLAwi4PRpoHlzIDgYsLcH1q8HMtiIYiKijErvFrDevXtjyJAhuHDhAoyMjPDixQts3boVI0aMwPfff6/XvszMzODp6Yljx45p1qlUKhw7dgxVqlRJtL2Hhwdu3LiBq1evav6aN2+OOnXq4OrVq0kmVubm5rC1tdX6U8rbt/HL48ez/AQprEgRwNxcTid05QqTLyKidKR3C9iYMWOgUqlQr149fPjwATVr1oS5uTlGjBiBQYMG6R3A8OHD4e3tjQoVKqBSpUpYtGgRwsPD0b17dwBA165d4eLiglmzZsHCwgKlSpXSur+9vT0AJFpviGbNil+eMUO5OCgLe/MGyJlTLufJI2t8FSwopxYiIqJ0o3cCZmRkhPHjx2PkyJF48OAB3r9/jxIlSsDa2jpFAXh5eeH169eYNGkSAgICUK5cOfj4+Gg65j99+hTGxoqXK0sV6m42RIrYtQvo2RNYtQrw8pLrPDyUjYmIKIviVETpJCwMUD/c6tVyRheidBEZKctKqIffNmokS07wHDgRZSCZbSoivVvA6tSpA6NPfHAfP378iwLKrP79N365XTvl4qAs5v59+Q939aq8PmYMMG0aky8iIoXpnYCVK1dO63pMTAyuXr2KmzdvwtvbO7XiynTUZcvKlo1vCSNKU7/+CvTpA7x/Dzg6Aps3A99+q3RURESEFCRgCxcuTHL9lClT8P79+y8OKDMSQn4XAnLQGVGau349fu7GmjWBX34BXFyUjYmIiDRSrQ/YgwcPUKlSJbxNWGvBAClxDvnhQ6BwYbl85gxQrVq6PCxldSNHApaWwKRJQDa9f2sRERmULN8HLDnnz5+HhYVFau0uU0k4QxOTL0ozW7cCNWoA+fPL63Pnsq8XEZGB0jsBa9WqldZ1IQRevnyJf//9FxMnTky1wDKTyZPlJWd3oTQRHg4MGiQr2VetKmt7mZoy+SIiMmB6J2B2dnZa142NjVGsWDFMmzYNDRo0SLXAMhNfX3lZu7aiYVBmdOuWHOV4+zZgbAw0bCgviYjIoOmVgMXFxaF79+4oXbo0HBwc0iqmTOXdu/jlAQOUi4MyGSFki9fAgUBEBODsLDvaM8snIsoQ9PqpbGJiggYNGiA4ODiNwsl8zp+PXy5bVrk4KBMJDwe6dpVV7SMiZKvX1atMvoiIMhC9z1WUKlUKjx49SotYMiX19JiFC/PMEKUSY2NZZsLERE4weugQ4OSkdFRERKQHvfuAzZgxAyNGjMD06dPh6emJ7Nmza92eGYaGppY//wTUuWrJksrGQhmcEPLP2FiWltixA3j9GqheXenIiIgoBXSuAzZt2jT88MMPsLGxib9zglFWQggYGRkhLi4u9aNMRelVR0T9XakWFgakcL5yyupCQmRF+9KlgQkTlI6GiEgRma0OmM4JmImJCV6+fAlf9ZC+ZNSqVStVAksr6XUA9+0DWrSQy2vXAj16pNlDUWZ26RLg5SWr+VpYyCZVZ2eloyIiSneZLQHT+RSkOk8z9ATLUCTsfM/ki/QmBLB0KTBiBBAdDRQoAGzbxuSLiCiT0KsPmBELO+rsxAl5OWSIsnFQBhQcLEc47tkjr7doAaxbB7D0CxFRpqFXAla0aNHPJmGGPhdkerl4UV7yO5P0Ehsrq9n7+spq9j/9JIfS8scPEVGmolcCNnXq1ESV8Cmx58/jlytVUi4OyoCyZZPNpnPnAtu3AxUqKB0RERGlAZ074RsbGyMgIABOGbzeUHp04mvRQnbCB4DISMDcPE0ehjKLt2+Bly/ja5UIAXz4AHxU4oWIKCvLbJ3wdS4Nyv5furt3T17WqMHkiz7j3DmgXDmgaVPZ9wuQpxuZfBERZWo6J2A6NpQR4iffHjhQ2TjIgKlUwJw5QM2awLNnsr/Xq1dKR0VEROlE5z5gKpUqLePINF68iF+uWlW5OMiAvX4NeHsDhw/L6x06AP/7H5CgyDEREWVuek9FRJ+mnvsRAPLlUy4OMlCnTsmE68ULWVh1yRJZcoKn+ImIshQmYKlM3fnew0PZOMhALVggky8PDzmfY+nSSkdEREQKYAKWih4/BtRTYS5frmgoZKjWrgUKFgSmTePkoEREWZjOnfDp8yZNil+uUUO5OMiAHD8O/PCDLC0BADlzylYwJl9ERFkaW8BS0Y4d8tLLS9bTpCwsLk62ck2fLpOvypWBdu2UjoqIiAwE04RU8v49EBUllzt0UDYWUtiLF0CnTsDJk/J6z56yzhcREdF/mIClkmHD4pcbNVIuDlLYn38CnTvLUhPZs8vyEp06KR0VEREZGPYBSwUqFbBmTfx1MzPlYiEFzZsHfPutTL7KlgUuX2byRURESWIClgquX49fvnpVsTBIaeXLy8vvvwf+/hsoWlTZeIiIyGDxFGQqOHo0frlsWeXiIAW8egWoJ6ivXx+4cSN+Um0iIqJksAUsFaxYIS9r1lQ2DkpHMTHAyJGylevhw/j1TL6IiEgHTMC+kEoFPHoklytXVjYWSidPnshCbz/9BISEAL//rnRERESUwfAU5BeaPz9+uW9f5eKgdPLbb0D37kBwMGBnB6xbB7RqpXRURESUwbAF7AtduCAvs2UDChVSNhZKQ9HRwNChQMuWMvmqVAm4coXJFxERpQgTsC+0e7e8nDhR2TgojS1dCixeLJeHDwdOnwbc3ZWNiYiIMiyegvwCERHxy+yAn8kNHAgcOQL07w80a6Z0NERElMGxBewLHDoUv1yrlnJxUBqIjJSTZsfEyOtmZsDhw0y+iIgoVbAF7Au0aRO/bGSkXByUyu7flzOqX7kiq9rPmqV0RERElMmwBSyF1BNvA/LsFGUS27YBX30lky9HR55bJiKiNMEELIWWLYtf/vln5eKgVBIRIeuIdOgAvH8v63xdvcqZ1YmIKE0wAUuhv/+OX+bpxwzu3j1ZRXfVKnkwJ0wAjh8HXFyUjoyIiDIp9gFLoZ075eW4ccrGQalAPZ2BkxOwdauc05GIiCgNMQH7QtWqKR0BpYhKBRj/1wDs4QHs2QOULg04OysbFxERZQk8BZkCV67EL9eooVwclEK3bgHlygGnTsWva9CAyRcREaUbJmApoJ5+CABsbJSLg/QkBLB2LVCxInDjBvDDD3IdERFROmMClgLv38tL1uTMQMLCgC5dgF695IjHBg2Agwc5goKIiBTBBCwF/vxTXubJo2wcpKNr14AKFWQHexMTYOZMWdXeyUnpyIiIKItiJ/wUuH9fXiYsxkoGytdXlpiIipJlJbZtA6pXVzoqIiLK4piApYC1tbysWFHZOEgHHh5A8+ZAeDiwcaOsbk9ERKQwJmB6evIEuHlTLleooGwslIwrVwB3d8DeXvbx2rgRMDePLztBRESkMH4j6Wno0PjlwoUVC4OSIgSwdCnw9deys716hKOlJZMvIiIyKGwB09PJk/KyQgWezTIowcFAz56yoCoAxMYCkZEy+SIiIjIwbBbQU3CwvOzZU9EwKKGLF4Hy5WXyZWoKLFoE7N3L5IuIiAwWEzA9hIXFLzdvrlwc9B8hgIUL5ajGx49lv6+zZ4EhQ1jfi4iIDBoTMD0knLmGs9YYgJAQYMECICYGaN0auHyZQ1OJiChDYB8wPUREyEsHBzawGAR7e+DXX2Wh1f79eVCIiCjDYAKmhzdv5CXLTyhEpQJ++klOQdC1q1xXvToLqxIRUYbDBEwPN24oHUEW9vo14O0tpxCysgLq1AFcXZWOioiIKEWYgOnh3Dl5aWOjbBxZzunTQPv2wIsXgIWFHOWYL5/SUREREaUYO+Hr4coVeVmunKJhZB0qFfDjj0Dt2jL5KlYMuHAB6N2b/b2IiChDYwuYjvbti19u0EC5OLKMuDigSRPgjz/k9S5dgOXL4yfiJCIiysDYAqajvn3jlytVUi6OLMPERI52sLIC1q8HNm1i8kVERJmGQSRgy5Ytg5ubGywsLFC5cmVcvHgx2W1Xr16NGjVqwMHBAQ4ODqhfv/4nt08t6gr4c+fy7FeaiYuTne3VpkwBrl4FunVTKCAiIqK0oXgCtn37dgwfPhyTJ0/G5cuXUbZsWTRs2BCvXr1KcvuTJ0+iQ4cOOHHiBM6fPw9XV1c0aNAA/v7+aRZjQAAQFSWXmzZNs4fJ2l6+BL75BmjUKP7FzpYNKFJE2biIiIjSgJEQQigZQOXKlVGxYkUsXboUAKBSqeDq6opBgwZhzJgxn71/XFwcHBwcsHTpUnRV14b6hNDQUNjZ2SEkJAS2trY6xXjokOyOJONjC1iq+/NPoHNn2fqVPTtw/DjP8xIRkZaUfH8bMkVbwKKjo3Hp0iXUr19fs87Y2Bj169fH+fPnddrHhw8fEBMTgxw5cqRVmLh5U17mz8/kK1XFxgLjxwPffiuTrzJlgEuXmHwREVGmp+goyKCgIMTFxSF37txa63Pnzo07d+7otI/Ro0cjb968WklcQlFRUYhSn9KCzKD1pb6LnZ3ed6XkPH8OdOwoa3wBcpTDwoWApaWycREREaUDxfuAfYnZs2dj27Zt2Lt3LywsLJLcZtasWbCzs9P8uaagevqPP8pLzniTinr3lsmXjQ2wbRuwciWTLyIiyjIUTcAcHR1hYmKCwMBArfWBgYHIkyfPJ+/7008/Yfbs2fjzzz9RpkyZZLcbO3YsQkJCNH/Pnj3TK8b37+OXc+XS6670KcuWyemELl8GvLyUjoaIiChdKZqAmZmZwdPTE8eOHdOsU6lUOHbsGKpUqZLs/ebOnYvp06fDx8cHFT4zM7a5uTlsbW21/vRx4UL88vjxet2VEnr6FFizJv56wYKys33hwsrFREREpBDFK+EPHz4c3t7eqFChAipVqoRFixYhPDwc3bt3BwB07doVLi4umDVrFgBgzpw5mDRpEn755Re4ubkhICAAAGBtbQ3rNCjUqW4BMzYGzMxSffdZw/79spZXcLAcycCpBIiIKItTPAHz8vLC69evMWnSJAQEBKBcuXLw8fHRdMx/+vQpjI3jG+pWrFiB6OhotGnTRms/kydPxpQpU1I1trg4QF3ZonbtVN111hAdDYweLSfPBoCKFVnXi4iICAZQByy96VNH5NQpoFYtudyhA/DLL+kQYGbh5yf7dv3zj7w+bBgwezabEYmIKEUyWx0wxVvADNnBg/HLa9cqF0eG89tv8pRjSAjg4ABs2AA0b65wUERERIaDCdgnhIfLy2LFWCFBL6GhMvmqUkWWmMifX+mIiIiIDAoTsE9Ytkxe/jcegD4lLg4wMZHLXbsCFhZAy5aAqamycRERERmgDF2INS2FhcUvf6YkGW3bBpQuDQQFxa9r147JFxERUTKYgCVjz5745U6dlIvDoEVEyCmEOnQAfH2BBQuUjoiIiChD4CnIZPxXXgzZswPZ+ColdueObOW6cUPOUD5uHJDKZUCIiIgyK6YWyZg9W162b69sHAZp82bg++/lKAUnJ2DLFuCbb5SOioiIKMNgApaM4GB56eamZBQG6H//A/r1k8t16gBbtwLOzsrGRERElMGwD1gSQkLil9W5Bv2nfXs5f+OUKcCRI0y+iIiIUoAtYEk4dy5+2dFRuTgMghBy0uy6dWVfLzs74Pp1FkYjIiL6AmwBS8K0afLSyEjZOBT3/j3g7Q3Urw+sXBm/nskXERHRF2ELWBKuX5eXPXsqG4eirl+Xoxzv3gWMjeOnBSAiIqIvxhawJKi7NTVpomwcihBCdrSvVEkmXy4uwMmTwIgRSkdGRESUabAFLAmvXsnLAgWUjSPdhYYCffoA27fL640aAZs2sSMcERFRKmML2EdCQ+OnIbKwUDaWdHfzJrBzp5zTce5c4MABJl9ERERpgC1gHzl6NH65aFHl4lBE1arA0qVAuXJAlSpKR0NERJRpsQXsIwlbv0xMlI0lzQUHA126yHkc1b7/nskXERFRGmML2EfUNcAaN1Y2jjT3zz+Alxfg5wfcvg38+y/rbhAREaUTtoB9JHt2efn6tbJxpBkhgEWLgGrVZPLl5iZrfDH5IiIiSjdsAfvItm3yskEDZeNIE2/fAt27A/v3y+utWgFr1wL29oqGRURElNUwAfvIy5fyMi5O2ThSnZ8fULs28PQpYGYGLFgA9O/Pli8iIiIFMAFL4N27+OVvvlEujjTh6grkzw+YmgI7dgBffaV0RERERFkWE7AEjh2LX65YUbk4Us2bN4CNjWzxypZN1viysgJsbZWOjIiIKEtjJ/wE7t+Xl+qGogzt9GmgbFlg9Oj4dXnyMPkiIiIyAEzAEhg3Tl4WKaJsHF9EpQJmzgTq1AH8/QEfH06kTUREZGCYgP0nIiJ+uXRp5eL4Iq9eAd9+C4wfL0cRdO4s632pa2sQERGRQWAfsP8kPFM3Z45ycaTYiRNAx45AQABgaQksWwZ068ZRjkRERAaICdh/7t2Tl7a2ss96hhIaCrRuLYdxlighRzmWLKl0VERERJQMJmD/Mf7vZOyUKYqGkTK2tsD//gccPgwsWcJTjkRERAaOCdh//PzkZY4cysahs6NHZdZYt6683rat/CMiIiKDx074//H3l5cqlbJxfFZsLDBhgpwrqUOH+NL9RERElGGwBew/Jiby0tNT2Tg+yd9fJl2nT8vrLVpwHkciIqIMiAnYf2Jj5aXBdp86fBjo2hUICgKsrYHVq4H27ZWOioiIiFKApyD/ExMjLw2uAr5KJWtkNG4sk6/y5YHLl5l8ERERZWBMwP4TFSUvsxlam6CxsaztBQADBgDnzmXwUv1ERERkaOmGIiIj45cNpgUsNjY+G1y2TI5wbNpU2ZiIiNKYEAKxsbGIi4tTOhRSgKmpKUzUnbIzOSZgiG9gAgBHR+XiAABERwNjxgAPHgD79slK9tbWTL6IKNOLjo7Gy5cv8eHDB6VDIYUYGRkhX758sLa2VjqUNMcEDDLnAeSAQkVn7vHzA7y85PyNAHDypJxUm4gok1OpVPDz84OJiQny5s0LMzMzGHEqtSxFCIHXr1/j+fPnKFKkSKZvCWMChvgETNEpiPbsAXr0AEJCZCa4YQOTLyLKMqKjo6FSqeDq6gorKyulwyGF5MqVC48fP0ZMTEymT8DYCR/AnTvyUpEELCoKGDRIzuUYEgJ8/TVw9Srw3XcKBENEpCxjY34tZWVZqdWT/+kA/vpLXgqhwIN36gQsXSqXR44ETp0CChRQIBAiIiJKL0zAAOzcKS9r1FDgwUePBpydgQMHgLlzDWgYJhEREaUVJmAAAgPlZenS6fBgERHxTW4AULEi8OgR0KRJOjw4ERGlhfPnz8PExARNkvgsP3nyJIyMjBAcHJzoNjc3NyxatEhr3YkTJ9C4cWPkzJkTVlZWKFGiBH744Qf4qyctTgORkZEYMGAAcubMCWtra7Ru3RqB6i/HZLx//x4DBw5Evnz5YGlpiRIlSmDlypVa2/Tt2xeFChWCpaUlcuXKhe+++w531P1+srgsn4C9eRO/3LlzGj/Y3buyj1fDhrKfl5qFRRo/MBERpaW1a9di0KBBOHXqFF68eJHi/fzvf/9D/fr1kSdPHuzevRu3b9/GypUrERISgvnz56dixNqGDRuG33//HTt37sRff/2FFy9eoFWrVp+8z/Dhw+Hj44MtW7bA19cXQ4cOxcCBA7F//37NNp6enli/fj18fX3xxx9/QAiBBg0asM4bAIgsJiQkRAAQISEhQgghzp0TQvb+SuMH3rJFiOzZ5QPlyiXEiRNp/IBERBlHRESEuH37toiIiFA6FL2FhYUJa2trcefOHeHl5SV+/PFHrdtPnDghAIh3794lum+BAgXEwoULhRBCPHv2TJiZmYmhQ4cm+ThJ3T81BAcHC1NTU7Fz507NOl9fXwFAnD9/Ptn7lSxZUkybNk1r3VdffSXGjx+f7H2uXbsmAIgHDx4kefun/g8+/v7O6LJ8C9j27fKyZMk0eoAPH4BevWTzWng4ULu2bP2qXTuNHpCIKOMTQn5kKvGn74CsHTt2wMPDA8WKFUPnzp2xbt06iBSM6tq5cyeio6MxatSoJG+3t7dP9r6NGjWCtbV1sn8lP/Eld+nSJcTExKB+/fqadR4eHsifPz/Onz+f7P2qVq2K/fv3w9/fH0IInDhxAvfu3UODBg2S3D48PBzr16+Hu7s7XF1dk91vVpHl64AtXiwvb91Kg53fvg20ayd3bmQETJoETJwIZPLaJkREX+rDBzkJiBLevweyZ9d9+7Vr16Lzf31Yvv32W4SEhOCvv/5CbT1/aN+/fx+2trZwdnbW634AsGbNGkRERCR7u+knBngFBATAzMwsUYKXO3duBCScKuYjS5YsQZ8+fZAvXz5ky5YNxsbGWL16NWrWrKm13fLlyzFq1CiEh4ejWLFiOHLkCMwULbxpGLJ0ApbwB8rYsWnwAPv2yeQrTx5g61agbt00eBAiIlLK3bt3cfHiRezduxcAkC1bNnh5eWHt2rV6J2BCiBTXwXJxcUnR/b7EkiVL8Pfff2P//v0oUKAATp06hQEDBiBv3rxarWmdOnXCN998g5cvX+Knn35Cu3btcPbsWVhk8f7PWToBu3kzfnnAgDR4gFGjZHv2oEFA7txp8ABERJmTlZVsiVLqsXW1du1axMbGIm/evJp1QgiYm5tj6dKlsLOzg62tLQAgJCQkUStTcHAw7OzsAABFixZFSEgIXr58qXcrWKNGjXD69Olkby9QoABuJXOqJ0+ePIiOjkZwcLBWfIGBgciTJ0+S94mIiMC4ceOwd+9ezcjPMmXK4OrVq/jpp5+0EjA7OzvY2dmhSJEi+Prrr+Hg4IC9e/eiQ4cOej3HzCZLJ2BhYfHLqfLj4cYNYNo0YNMmwNJSnmqcMSMVdkxElLUYGel3GlAJsbGx2LRpE+bPn5+o31OLFi3w66+/ol+/fihSpAiMjY1x6dIlFEhQaPvRo0cICQlB0aJFAQBt2rTBmDFjMHfuXCxcuDDR432cICX0JacgPT09YWpqimPHjqF169YAZMve06dPUaVKlSTvExMTg5iYmEQzF5iYmEClUiX7WEIICCEQFRWV7DZZBRMwpEIHfCGANWuAwYOByEigYEFgzpwvjo+IiAzXgQMH8O7dO/Ts2VPTiqXWunVrrF27Fv369YONjQ169eqFH374AdmyZUPp0qXx7NkzjB49Gl9//TWqVq0KAHB1dcXChQsxcOBAhIaGomvXrnBzc8Pz58+xadMmWFtbJ1uK4ktOQdrZ2aFnz54YPnw4cuTIAVtbWwwaNAhVqlTB119/rdnOw8MDs2bNQsuWLWFra4tatWph5MiRsLS0RIECBfDXX39h06ZNWLBgAQCZYG7fvh0NGjRArly58Pz5c8yePRuWlpZo3LhxiuPNNJQcgqmEhMNY582TVSHKlPmiHQrRvn18LYtvvxXi1atUi5eIKCvIiGUomjZtKho3bpzkbRcuXBAAxLVr14QQ8vlNnjxZeHh4CEtLS+Hu7i769OkjXr9+nei+R44cEQ0bNhQODg7CwsJCeHh4iBEjRogXL16k2XOJiIgQ/fv3Fw4ODsLKykq0bNlSvHz5UmsbAGL9+vWa6y9fvhTdunUTefPmFRYWFqJYsWJi/vz5QqVSCSGE8Pf3F40aNRJOTk7C1NRU5MuXT3Ts2FHcuXPnk3FklTIURkIoMgOiYkJDQ2FnZ4eQkBB07GiLgweBcuWAK1dSsLMrV+QoxwcP5OnGmTOBESMATiZLRKSXyMhI+Pn5wd3dPct3zs7KPvV/kPD7W92vLiPL0qcgL12Sl2XLpuDOe/cC7dsD0dGAqyuwbRvwXzMyERER0adk6QRMXd4kRTVRK1SQRWqqVQPWrwdy5kzN0IiIiCgTy7IJWGxs/HKtWjreyd8/frikqytw8aLscJ/Cui1ERESUNWXZzkpHj8Yv58v3mY2FkCXzCxYEEkwyikKFmHwRERGR3rJsAnbypLy0sgI+UR4FePsWaNkSGDpU9vdKmIARERERpUCWTcD+9z95OXToJzb6+2+gfHk5pZCZGbBkCbB6dXqER0SUJWWxgfn0kax0/LNsAqYu1JsrVzI3/vQTUKMG8PSpPNV47hwwcCBPORIRpQF1pfYPHz4oHAkpKTo6GoCsqJ/ZZdlO+Gq9eyex8tQpYORIudyunWz1ygQ1R4iIDJWJiQns7e3x6tUrAICVlVWKJ6amjEmlUuH169ewsrJCtmyZPz3J/M/wEywskplrrHZtYMgQwMMD6NuXrV5EROlAPfGzOgmjrMfY2Bj58+fPEsl3lq2ED4QAsIUQkKccFy8GOnQAkpn5nYiI0kdcXBxiYmKUDoMUYGZmlmiCbzVWwk8Dy5Ytw7x58xAQEICyZctiyZIlqFSpUrLb79y5ExMnTsTjx49RpEgRzJkzJ0UTe7ZsCeDVK6BLF+DPP4EDB4AjRziVEBGRgkxMTLJEHyDK2hTPNLZv347hw4dj8uTJuHz5MsqWLYuGDRsm2wR97tw5dOjQAT179sSVK1fQokULtGjRAjdv3tT7sXsWOikngvzzT8DSEujUiacbiYiIKM0pfgqycuXKqFixIpYuXQpAdsJzdXXFoEGDMGbMmETbe3l5ITw8HAcOHNCs+/rrr1GuXDmsXLnys4+nbsIchbGYbTwHRioVULw4sGMHUKpU6j0xIiIiSjWZ7RSkoi1g0dHRuHTpEurXr69ZZ2xsjPr16+P8+fNJ3uf8+fNa2wNAw4YNk90+OeMxSyZf3bsD//zD5IuIiIjSjaJ9wIKCghAXF4fcuXNrrc+dOzfu3LmT5H0CAgKS3D5APbP2R6KiohAVFaW5HhISAgB4Y2IBLF8MtG8PxMUBoaFf8lSIiIgoDYX+9z2dWcYOGkQn/LQ0a9YsTJ06NdH6gnGRssRE374KREVEREQp8ebNm/+qGWRsiiZgjo6OMDExQWBgoNb6wMBATT2Yj+XJk0ev7ceOHYvhw4drrgcHB6NAgQJ4+vRppjiAGVloaChcXV3x7NmzTHE+P6Pj8TAcPBaGg8fCcISEhCB//vzIkSOH0qGkCkUTMDMzM3h6euLYsWNo0aIFANkJ/9ixYxg4cGCS96lSpQqOHTuGoQkmcTxy5AiqVKmS5Pbm5uYwNzdPtN7Ozo5vJgNha2vLY2FAeDwMB4+F4eCxMBzJ1QnLaBQ/BTl8+HB4e3ujQoUKqFSpEhYtWoTw8HB0794dANC1a1e4uLhg1qxZAIAhQ4agVq1amD9/Ppo0aYJt27bh33//xapVq5R8GkREREQ6UzwB8/LywuvXrzFp0iQEBASgXLly8PHx0XS0f/r0qVa2W7VqVfzyyy+YMGECxo0bhyJFiuC3335DKY5iJCIiogxC8QQMAAYOHJjsKceTJ08mWte2bVu0bds2RY9lbm6OyZMnJ3laktIXj4Vh4fEwHDwWhoPHwnBktmOheCFWIiIioqwmc/RkIyIiIspAmIARERERpTMmYERERETpLFMmYMuWLYObmxssLCxQuXJlXLx48ZPb79y5Ex4eHrCwsEDp0qVx6NChdIo089PnWKxevRo1atSAg4MDHBwcUL9+/c8eO9KPvu8NtW3btsHIyEhTr4++nL7HIjg4GAMGDICzszPMzc1RtGhRflalEn2PxaJFi1CsWDFYWlrC1dUVw4YNQ2RkZDpFm3mdOnUKzZo1Q968eWFkZITffvvts/c5efIkvvrqK5ibm6Nw4cLYsGFDmseZakQms23bNmFmZibWrVsnbt26JXr37i3s7e1FYGBgktufPXtWmJiYiLlz54rbt2+LCRMmCFNTU3Hjxo10jjzz0fdYdOzYUSxbtkxcuXJF+Pr6im7dugk7Ozvx/PnzdI48c9L3eKj5+fkJFxcXUaNGDfHdd9+lT7CZnL7HIioqSlSoUEE0btxYnDlzRvj5+YmTJ0+Kq1evpnPkmY++x2Lr1q3C3NxcbN26Vfj5+Yk//vhDODs7i2HDhqVz5JnPoUOHxPjx48WePXsEALF3795Pbv/o0SNhZWUlhg8fLm7fvi2WLFkiTExMhI+PT/oE/IUyXQJWqVIlMWDAAM31uLg4kTdvXjFr1qwkt2/Xrp1o0qSJ1rrKlSuLvn37pmmcWYG+x+JjsbGxwsbGRmzcuDGtQsxSUnI8YmNjRdWqVcWaNWuEt7c3E7BUou+xWLFihShYsKCIjo5OrxCzDH2PxYABA0TdunW11g0fPlxUq1YtTePManRJwEaNGiVKliyptc7Ly0s0bNgwDSNLPZnqFGR0dDQuXbqE+vXra9YZGxujfv36OH/+fJL3OX/+vNb2ANCwYcNktyfdpORYfOzDhw+IiYnJNPN+KSmlx2PatGlwcnJCz5490yPMLCElx2L//v2oUqUKBgwYgNy5c6NUqVKYOXMm4uLi0ivsTCklx6Jq1aq4dOmS5jTlo0ePcOjQITRu3DhdYqZ4Gf372yAKsaaWoKAgxMXFaaroq+XOnRt37txJ8j4BAQFJbh8QEJBmcWYFKTkWHxs9ejTy5s2b6A1G+kvJ8Thz5gzWrl2Lq1evpkOEWUdKjsWjR49w/PhxdOrUCYcOHcKDBw/Qv39/xMTEYPLkyekRdqaUkmPRsWNHBAUFoXr16hBCIDY2Fv369cO4cePSI2RKILnv79DQUERERMDS0lKhyHSTqVrAKPOYPXs2tm3bhr1798LCwkLpcLKcsLAwdOnSBatXr4ajo6PS4WR5KpUKTk5OWLVqFTw9PeHl5YXx48dj5cqVSoeW5Zw8eRIzZ87E8uXLcfnyZezZswcHDx7E9OnTlQ6NMphM1QLm6OgIExMTBAYGaq0PDAxEnjx5krxPnjx59NqedJOSY6H2008/Yfbs2Th69CjKlCmTlmFmGfoej4cPH+Lx48do1qyZZp1KpQIAZMuWDXfv3kWhQoXSNuhMKiXvDWdnZ5iamsLExESzrnjx4ggICEB0dDTMzMzSNObMKiXHYuLEiejSpQt69eoFAChdujTCw8PRp08fjB8/XmvuYkpbyX1/29raGnzrF5DJWsDMzMzg6emJY8eOadapVCocO3YMVapUSfI+VapU0doeAI4cOZLs9qSblBwLAJg7dy6mT58OHx8fVKhQIT1CzRL0PR4eHh64ceMGrl69qvlr3rw56tSpg6tXr8LV1TU9w89UUvLeqFatGh48eKBJggHg3r17cHZ2ZvL1BVJyLD58+JAoyVInxoIz+6WrDP/9rfQogNS2bds2YW5uLjZs2CBu374t+vTpI+zt7UVAQIAQQoguXbqIMWPGaLY/e/asyJYtm/jpp5+Er6+vmDx5MstQpBJ9j8Xs2bOFmZmZ2LVrl3j58qXmLywsTKmnkKnoezw+xlGQqUffY/H06VNhY2MjBg4cKO7evSsOHDggnJycxIwZM5R6CpmGvsdi8uTJwsbGRvz666/i0aNH4s8//xSFChUS7dq1U+opZBphYWHiypUr4sqVKwKAWLBggbhy5Yp48uSJEEKIMWPGiC5dumi2V5ehGDlypPD1/X87dx9TZfn/Afx9DnoeOpwDI3Nw5PiABmsupWPSxBr5FMdlkU9osQlC2iDE1axYM4EaWito6KykJkeJyUOrcGPAYsEGuBI1YBMEIciaLFc4GAUC53y+fzTueeTBSH8Hf/h+bfcf9/V0f67rHuOz676gWY4ePcp/QzHVjhw5InPnzhWNRiMhISHyww8/KHVhYWESHR3t0r6wsFACAwNFo9HI4sWLpaSkxM0RT1+TeRfz5s0TAKOulJQU9wc+TU32Z+NmTMDursm+izNnzsgTTzwhWq1WAgICJD09XYaHh90c9fQ0mXcxNDQkqampsnDhQtHpdGKxWCQhIUGuX7/u/sCnmcrKyjF/B4ysf3R0tISFhY3qExwcLBqNRgICAiQnJ8ftcf9XKhHumRIRERG507Q6A0ZERET0/wETMCIiIiI3YwJGRERE5GZMwIiIiIjcjAkYERERkZsxASMiIiJyMyZgRERERG7GBIyIiIjIzZiAEZELu90Ob2/vqQ7jP1OpVPj2228nbBMTE4MXXnjBLfEQEY2FCRjRNBQTEwOVSjXqamtrm+rQYLfblXjUajX8/f2xc+dOXLt27a6M39XVhfXr1wMAOjs7oVKpUF9f79ImKysLdrv9rjxvPKmpqco8PTw8YLFYsHv3bnR3d09qHCaLRNPTjKkOgIj+b9hsNuTk5LiUPfTQQ1MUjSuTyYSWlhY4nU40NDRg586duHr1KsrLy+94bF9f39u28fLyuuPn/BuLFy9GRUUFHA4HmpubERsbi56eHhQUFLjl+UR07+IOGNE0pdVq4evr63J5eHggMzMTjz76KAwGAywWCxISEtDX1zfuOA0NDVi1ahWMRiNMJhOWLVuGc+fOKfU1NTV46qmnoNfrYbFYkJSUhL/++mvC2FQqFXx9fWE2m7F+/XokJSWhoqIC/f39cDqdePfdd+Hv7w+tVovg4GCUlZUpfQcHB5GYmAg/Pz/odDrMmzcPhw4dchl75BPkggULAACPPfYYVCoVnn76aQCuu0rZ2dkwm81wOp0uMUZERCA2Nla5Ly4uhtVqhU6nQ0BAANLS0jA8PDzhPGfMmAFfX1/MmTMHa9euxdatW/Hdd98p9Q6HA3FxcViwYAH0ej2CgoKQlZWl1KempuLEiRMoLi5WdtOqqqoAAL/++isiIyPh7e0NHx8fREREoLOzc8J4iOjewQSM6D6jVqtx+PBhXLx4ESdOnMD333+PN998c9z2UVFR8Pf3R11dHc6fP4/k5GTMnDkTANDe3g6bzYbNmzejsbERBQUFqKmpQWJi4qRi0uv1cDqdGB4eRlZWFjIyMvDRRx+hsbER4eHheP7553H58mUAwOHDh3H69GkUFhaipaUFeXl5mD9//pjjnj17FgBQUVGBrq4ufP3116PabN26FX/++ScqKyuVsu7ubpSVlSEqKgoAUF1djR07dmDv3r1oamrCsWPHYLfbkZ6e/q/n2NnZifLycmg0GqXM6XTC398fRUVFaGpqwoEDB/D222+jsLAQALBv3z5ERkbCZrOhq6sLXV1dCA0NxdDQEMLDw2E0GlFdXY3a2lp4enrCZrNhcHDwX8dERFNIiGjaiY6OFg8PDzEYDMq1ZcuWMdsWFRXJgw8+qNzn5OSIl5eXcm80GsVut4/ZNy4uTnbv3u1SVl1dLWq1Wvr7+8fsc+v4ra2tEhgYKI8//riIiJjNZklPT3fps3z5cklISBARkT179sjq1avF6XSOOT4A+eabb0REpKOjQwDITz/95NImOjpaIiIilPuIiAiJjY1V7o8dOyZms1kcDoeIiKxZs0YOHjzoMkZubq74+fmNGYOISEpKiqjVajEYDKLT6QSAAJDMzMxx+4iIvPrqq7J58+ZxYx15dlBQkMsa3LhxQ/R6vZSXl084PhHdG3gGjGiaWrVqFT799FPl3mAwAPhnN+jQoUO4dOkSent7MTw8jIGBAfz999944IEHRo3z+uuv4+WXX0Zubq7yGW3hwoUA/vk82djYiLy8PKW9iMDpdKKjowOPPPLImLH19PTA09MTTqcTAwMDePLJJ/HFF1+gt7cXV69excqVK13ar1y5Eg0NDQD++Xy4bt06BAUFwWazYcOGDXjmmWfuaK2ioqKwa9cufPLJJ9BqtcjLy8P27duhVquVedbW1rrseDkcjgnXDQCCgoJw+vRpDAwM4Msvv0R9fT327Nnj0ubo0aM4fvw4rly5gv7+fgwODiI4OHjCeBsaGtDW1gaj0ehSPjAwgPb29v+wAkTkbkzAiKYpg8GARYsWuZR1dnZiw4YNiI+PR3p6Onx8fFBTU4O4uDgMDg6OmUikpqbipZdeQklJCUpLS5GSkoL8/Hxs3LgRfX19eOWVV5CUlDSq39y5c8eNzWg04sKFC1Cr1fDz84NerwcA9Pb23nZeVqsVHR0dKC0tRUVFBSIjI7F27Vp89dVXt+07nueeew4igpKSEixfvhzV1dX4+OOPlfq+vj6kpaVh06ZNo/rqdLpxx9VoNMo7eP/99/Hss88iLS0N7733HgAgPz8f+/btQ0ZGBlasWAGj0YgPP/wQP/7444Tx9vX1YdmyZS6J74h75Q8tiGhiTMCI7iPnz5+H0+lERkaGsrszct5oIoGBgQgMDMRrr72GF198ETk5Odi4cSOsViuamppGJXq3o1arx+xjMplgNptRW1uLsLAwpby2thYhISEu7bZt24Zt27Zhy5YtsNls6O7uho+Pj8t4I+etHA7HhPHodDps2rQJeXl5aGtrQ1BQEKxWq1JvtVrR0tIy6Xneav/+/Vi9ejXi4+OVeYaGhiIhIUFpc+sOlkajGRW/1WpFQUEBZs+eDZPJdEcxEdHU4CF8ovvIokWLMDQ0hCNHjuDnn39Gbm4uPvvss3Hb9/f3IzExEVVVVfjll19QW1uLuro65dPiW2+9hTNnziAxMRH19fW4fPkyiouLJ30I/2ZvvPEGPvjgAxQUFKClpQXJycmor6/H3r17AQCZmZk4deoULl26hNbWVhQVFcHX13fMfx47e/Zs6PV6lJWV4ffff0dPT8+4z42KikJJSQmOHz+uHL4fceDAAZw8eRJpaWm4ePEimpubkZ+fj/37909qbitWrMCSJUtw8OBBAMDDDz+Mc+fOoby8HK2trXjnnXdQV1fn0mf+/PlobGxES0sL/vjjDwwNDSEqKgqzZs1CREQEqqur0dHRgaqqKiQlJeG3336bVExENEWm+hAaEd19Yx3cHpGZmSl+fn6i1+slPDxcTp48KQDk+vXrIuJ6SP7GjRuyfft2sVgsotFoxGw2S2JiossB+7Nnz8q6devE09NTDAaDLFmyZNQh+pvdegj/Vg6HQ1JTU2XOnDkyc+ZMWbp0qZSWlir12dnZEhwcLAaDQUwmk6xZs0YuXLig1OOmQ/giIp9//rlYLBZRq9USFhY27vo4HA7x8/MTANLe3j4qrrKyMgkNDRW9Xi8mk0lCQkIkOzt73HmkpKTI0qVLR5WfOnVKtFqtXLlyRQYGBiQmJka8vLzE29tb4uPjJTk52aXftWvXlPUFIJWVlSIi0tXVJTt27JBZs2aJVquVgIAA2bVrl/T09IwbExHdO1QiIlObAhIRERHdX/gJkoiIiMjNmIARERERuRkTMCIiIiI3YwJGRERE5GZMwIiIiIjcjAkYERERkZsxASMiIiJyMyZgRERERG7GBIyIiIjIzZiAEREREbkZEzAiIiIiN2MCRkRERORm/wO+qQksq4FUZgAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 266.170264005661\n",
+      "lead_lag: True inv_rest: False thres_distance: 8000 auc: 0.8343324400000001\n",
+      "Threshold distance:  16000\n",
+      "lead_lag:  True\n",
+      "inv_reset:  False\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 16.08999800682068\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 278.8102180957794\n",
+      "lead_lag: True inv_rest: False thres_distance: 16000 auc: 0.84074052\n",
+      "Threshold distance:  32000\n",
+      "lead_lag:  True\n",
+      "inv_reset:  False\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 21.187442302703857\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 294.34289026260376\n",
+      "lead_lag: True inv_rest: False thres_distance: 32000 auc: 0.8419482599999999\n",
+      "Threshold distance:  4000\n",
+      "lead_lag:  False\n",
+      "inv_reset:  True\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 13.107696056365967\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 60.903258085250854\n",
+      "lead_lag: False inv_rest: True thres_distance: 4000 auc: 0.79083568\n",
+      "Threshold distance:  8000\n",
+      "lead_lag:  False\n",
+      "inv_reset:  True\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 13.742963075637817\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmAAAAHcCAYAAABxixZDAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACbjklEQVR4nOzdd1hT1xsH8C97yFTAgShu3FrcirturaOKG/fe1bqq1g6t29b507onbq1aW+vWat0bRxXcoqgMkZ3z++M0gQhogoEL4ft5Hh7uvbm5eZNLyJtzzn2PiRBCgIiIiIgyjKnSARARERFlN0zAiIiIiDIYEzAiIiKiDMYEjIiIiCiDMQEjIiIiymBMwIiIiIgyGBMwIiIiogzGBIyIiIgogzEBIyIiIspgTMCIPoGnpyd69OihdBjZTt26dVG3bl2lw/iob7/9FiYmJggJCVE6lEzHxMQE3377rUGOFRQUBBMTE6xevdogxyPKCEzAKNNavXo1TExMND/m5uZwd3dHjx498OTJE6XDy9QiIyPx/fffo1y5crC1tYWjoyN8fHywdu1aZJXZx27evIlvv/0WQUFBSoeSTEJCAlatWoW6desiZ86csLKygqenJ3r27Inz588rHZ5BbNy4EfPnz1c6DC2ZMSaitDJXOgCij/nuu+9QqFAhREdH48yZM1i9ejVOnjyJ69evw9raWtHYbt++DVPTzPU9Jjg4GA0aNEBAQAA6duyIIUOGIDo6Gtu3b4efnx/279+PDRs2wMzMTOlQP+jmzZuYOnUq6tatC09PT63b/vzzT2WCAhAVFYW2bdviwIEDqF27NiZMmICcOXMiKCgIW7ZswZo1a/Dw4UPkz59fsRgNYePGjbh+/TpGjBiRLsePioqCubl+H0GpxVSwYEFERUXBwsLCgBESpS8mYJTpNW3aFJUqVQIA9OnTBy4uLpgxYwb27NmDDh06KBqblZVVhj9mdHQ0LC0tU038/Pz8EBAQgJ07d6JVq1aa7cOGDcOYMWMwe/ZsVKxYEWPHjs2okAHIVrkcOXIY5FiWlpYGOU5ajBkzBgcOHMC8efOSJQJTpkzBvHnzMjQeIQSio6NhY2OToY+bFiqVCrGxsbC2tjbolycTExPFv4wR6U0QZVKrVq0SAMS5c+e0tu/du1cAENOmTdPaHhAQINq1ayecnZ2FlZWV8Pb2Frt370523Ddv3ogRI0aIggULCktLS+Hu7i66desmXr58qdknOjpaTJ48WRQpUkRYWlqK/PnzizFjxojo6GitYxUsWFD4+fkJIYQ4d+6cACBWr16d7DEPHDggAIjffvtNs+3x48eiZ8+ews3NTVhaWopSpUqJFStWaN3vyJEjAoDYtGmTmDhxosiXL58wMTERb968SfE1O336tAAgevXqleLtcXFxolixYsLZ2Vm8e/dOCCFEYGCgACBmzZol5s6dKwoUKCCsra1F7dq1xbVr15IdQ5fXWX3ujh49KgYOHChcXV2Fk5OTEEKIoKAgMXDgQFG8eHFhbW0tcubMKb788ksRGBiY7P7v/xw5ckQIIUSdOnVEnTp1kr1O/v7+4ocffhDu7u7CyspK1K9fX9y9ezfZc1i4cKEoVKiQsLa2FpUrVxbHjx9PdsyUPHr0SJibm4vPP//8g/upTZkyRQAQd+/eFX5+fsLR0VE4ODiIHj16iMjISK19V65cKerVqydcXV2FpaWlKFmypFi8eHGyYxYsWFA0b95cHDhwQHh7ewsrKysxb948vY4hhBD79+8XtWvXFnZ2dsLe3l5UqlRJbNiwQQghX9/3X/uCBQtq7qvr+wOAGDx4sFi/fr0oVaqUMDc3Fzt37tTcNmXKFM2+4eHhYvjw4Zr3paurq2jYsKG4cOHCR2NS/w2vWrVK6/EDAgJE+/bthYuLi7C2thbFixcXEyZM+NApI8owbAGjLEc9JsjZ2Vmz7caNG6hZsybc3d0xbtw45MiRA1u2bEHr1q2xfft2tGnTBgDw9u1b+Pj4ICAgAL169cJnn32GkJAQ7NmzB48fP4aLiwtUKhVatWqFkydPol+/fihZsiSuXbuGefPm4c6dO9i1a1eKcVWqVAmFCxfGli1b4Ofnp3Wbv78/nJ2d0bhxYwCym7BatWowMTHBkCFD4Orqit9//x29e/dGeHh4spaV77//HpaWlhg9ejRiYmJSbQH67bffAADdu3dP8XZzc3N07twZU6dOxalTp9CwYUPNbWvXrkVERAQGDx6M6Oho/Pzzz6hfvz6uXbuG3Llz6/U6qw0aNAiurq6YPHkyIiMjAQDnzp3D33//jY4dOyJ//vwICgrCkiVLULduXdy8eRO2traoXbs2hg0bhl9++QUTJkxAyZIlAUDzOzU//fQTTE1NMXr0aISFhWHmzJno0qUL/vnnH80+S5YswZAhQ+Dj44ORI0ciKCgIrVu3hrOz80e7DX///XfEx8ejW7duH9zvfR06dEChQoUwffp0XLx4Eb/++ivc3NwwY8YMrbhKly6NVq1awdzcHL/99hsGDRoElUqFwYMHax3v9u3b6NSpE/r374++ffuiRIkSeh1j9erV6NWrF0qXLo3x48fDyckJly5dwoEDB9C5c2dMnDgRYWFhePz4saZFz87ODgD0fn8cPnwYW7ZswZAhQ+Di4pKsO1ltwIAB2LZtG4YMGYJSpUrh1atXOHnyJAICAvDZZ599MKaUXL16FT4+PrCwsEC/fv3g6emJe/fu4bfffsOPP/6o24kjSk9KZ4BEqVG3gvz111/i5cuX4tGjR2Lbtm3C1dVVWFlZiUePHmn2bdCggShbtqzWN3CVSiVq1KghihUrptk2efJkAUDs2LEj2eOpVCohhBDr1q0Tpqam4sSJE1q3L126VAAQp06d0mxL2gImhBDjx48XFhYW4vXr15ptMTExwsnJSatVqnfv3iJv3rwiJCRE6zE6duwoHB0dNa1T6padwoULa7Z9SOvWrQWAVFvIhBBix44dAoD45ZdfhBCJrQc2Njbi8ePHmv3++ecfAUCMHDlSs03X11l97mrVqiXi4+O1Hj+l56FuuVu7dq1m29atW7VavZJKrQWsZMmSIiYmRrP9559/FgA0LXkxMTEiV65conLlyiIuLk6z3+rVqwWAj7aAjRw5UgAQly5d+uB+auoWsPdbJNu0aSNy5cqltS2l16Vx48aicOHCWtsKFiwoAIgDBw4k21+XY4SGhgp7e3tRtWpVERUVpbWv+j0ghBDNmzfXavVS0+f9AUCYmpqKGzduJDsO3msBc3R0FIMHD062X1KpxZRSC1jt2rWFvb29ePDgQarPkUhJmWv0MFEKGjZsCFdXV3h4eODLL79Ejhw5sGfPHk1rxevXr3H48GF06NABERERCAkJQUhICF69eoXGjRvj7t27mqsmt2/fjvLlyydrqQHkOBIA2Lp1K0qWLAkvLy/NsUJCQlC/fn0AwJEjR1KN1dfXF3FxcdixY4dm259//onQ0FD4+voCkGN2tm/fjpYtW0IIofUYjRs3RlhYGC5evKh1XD8/P53G+ERERAAA7O3tU91HfVt4eLjW9tatW8Pd3V2zXqVKFVStWhX79+8HoN/rrNa3b99kg/2TPo+4uDi8evUKRYsWhZOTU7Lnra+ePXtqtQ76+PgAAO7fvw8AOH/+PF69eoW+fftqDQDv0qWLVotqatSv2Yde35QMGDBAa93HxwevXr3SOgdJX5ewsDCEhISgTp06uH//PsLCwrTuX6hQIU1ralK6HOPgwYOIiIjAuHHjko2bUr8HPkTf90edOnVQqlSpjx7XyckJ//zzD54+ffrRfT/m5cuXOH78OHr16oUCBQpo3abLcyTKCOyCpExv0aJFKF68OMLCwrBy5UocP35ca/D7v//+CyEEJk2ahEmTJqV4jBcvXsDd3R337t1Du3btPvh4d+/eRUBAAFxdXVM9VmrKly8PLy8v+Pv7o3fv3gBk96OLi4vmA+rly5cIDQ3FsmXLsGzZMp0eo1ChQh+MWU2dGERERMDJySnFfVJL0ooVK5Zs3+LFi2PLli0A9HudPxR3VFQUpk+fjlWrVuHJkydaZTHeTzT09f6HrTqpevPmDQDgwYMHAICiRYtq7Wdubp5q11hSDg4OABJfQ0PEpT7mqVOnMGXKFJw+fRrv3r3T2j8sLAyOjo6a9dT+HnQ5xr179wAAZcqU0es5qOn7/tD1b3fmzJnw8/ODh4cHvL290axZM3Tv3h2FCxfWO0Z1wp3W50iUEZiAUaZXpUoVzVWQrVu3Rq1atdC5c2fcvn0bdnZ2UKlUAIDRo0en2CoAJP/A/RCVSoWyZcti7ty5Kd7u4eHxwfv7+vrixx9/REhICOzt7bFnzx506tRJ0+Kijrdr167JxoqplStXTmtd1yvcSpYsiV27duHq1auoXbt2ivtcvXoVAHRqlUgqLa9zSnEPHToUq1atwogRI1C9enU4OjrCxMQEHTt21DxGWqVWWkMYqPaZl5cXAODatWuoUKGCzvf7WFz37t1DgwYN4OXlhblz58LDwwOWlpbYv38/5s2bl+x1Sel11fcYaaXv+0PXv90OHTrAx8cHO3fuxJ9//olZs2ZhxowZ2LFjB5o2bfrJcRNlNkzAKEsxMzPD9OnTUa9ePSxcuBDjxo3TfEO2sLDQGlSekiJFiuD69esf3efKlSto0KBBmrorfH19MXXqVGzfvh25c+dGeHg4OnbsqLnd1dUV9vb2SEhI+Gi8+mrRogWmT5+OtWvXppiAJSQkYOPGjXB2dkbNmjW1brt7926y/e/cuaNpGdLndf6Qbdu2wc/PD3PmzNFsi46ORmhoqNZ+6dFVVLBgQQCyNa9evXqa7fHx8QgKCkqW+L6vadOmMDMzw/r16/UeiP8hv/32G2JiYrBnzx6t1rIPdXen9RhFihQBAFy/fv2DX0xSe/0/9f3xIXnz5sWgQYMwaNAgvHjxAp999hl+/PFHTQKm6+Op/1Y/9l4nUhLHgFGWU7duXVSpUgXz589HdHQ03NzcULduXfzvf//Ds2fPku3/8uVLzXK7du1w5coV7Ny5M9l+6taIDh064MmTJ1i+fHmyfaKiojRX86WmZMmSKFu2LPz9/eHv74+8efNqJUNmZmZo164dtm/fnuIHRNJ49VWjRg00bNgQq1atwt69e5PdPnHiRNy5cwdff/11spaJXbt2aY3hOnv2LP755x/Nh58+r/OHmJmZJWuRWrBgARISErS2qWuGvZ+YfYpKlSohV65cWL58OeLj4zXbN2zYoOmm/BAPDw/07dsXf/75JxYsWJDsdpVKhTlz5uDx48d6xaVuIXu/O3bVqlUGP0ajRo1gb2+P6dOnIzo6Wuu2pPfNkSNHil3Cn/r+SElCQkKyx3Jzc0O+fPkQExPz0Zje5+rqitq1a2PlypV4+PCh1m2Gag0l+lRsAaMsacyYMWjfvj1Wr16NAQMGYNGiRahVqxbKli2Lvn37onDhwggODsbp06fx+PFjXLlyRXO/bdu2oX379ujVqxe8vb3x+vVr7NmzB0uXLkX58uXRrVs3bNmyBQMGDMCRI0dQs2ZNJCQk4NatW9iyZQv++OMPTZdoanx9fTF58mRYW1ujd+/eyYqm/vTTTzhy5AiqVq2Kvn37olSpUnj9+jUuXryIv/76C69fv07za7N27Vo0aNAAX3zxBTp37gwfHx/ExMRgx44dOHr0KHx9fTFmzJhk9ytatChq1aqFgQMHIiYmBvPnz0euXLnw9ddfa/bR9XX+kBYtWmDdunVwdHREqVKlcPr0afz111/IlSuX1n4VKlSAmZkZZsyYgbCwMFhZWaF+/fpwc3NL82tjaWmJb7/9FkOHDkX9+vXRoUMHBAUFYfXq1ShSpIhOLSxz5szBvXv3MGzYMOzYsQMtWrSAs7MzHj58iK1bt+LWrVtaLZ66aNSoESwtLdGyZUv0798fb9++xfLly+Hm5pZisvspx3BwcMC8efPQp08fVK5cGZ07d4azszOuXLmCd+/eYc2aNQAAb29v+Pv7Y9SoUahcuTLs7OzQsmVLg7w/3hcREYH8+fPjyy+/RPny5WFnZ4e//voL586d02opTS2mlPzyyy+oVasWPvvsM/Tr1w+FChVCUFAQ9u3bh8uXL+sVH1G6UOTaSyIdpFaIVQghEhISRJEiRUSRIkU0ZQ7u3bsnunfvLvLkySMsLCyEu7u7aNGihdi2bZvWfV+9eiWGDBki3N3dNUUk/fz8tEpCxMbGihkzZojSpUsLKysr4ezsLLy9vcXUqVNFWFiYZr/3y1Co3b17V1Ms8uTJkyk+v+DgYDF48GDh4eEhLCwsRJ48eUSDBg3EsmXLNPuoyyts3bpVr9cuIiJCfPvtt6J06dLCxsZG2Nvbi5o1a4rVq1cnuww/aSHWOXPmCA8PD2FlZSV8fHzElStXkh1bl9f5Q+fuzZs3omfPnsLFxUXY2dmJxo0bi1u3bqX4Wi5fvlwULlxYmJmZ6VSI9f3XKbUCnb/88osoWLCgsLKyElWqVBGnTp0S3t7eokmTJjq8ukLEx8eLX3/9Vfj4+AhHR0dhYWEhChYsKHr27KlVokJdhiJpkd+kr0/S4rN79uwR5cqVE9bW1sLT01PMmDFDrFy5Mtl+6kKsKdH1GOp9a9SoIWxsbISDg4OoUqWK2LRpk+b2t2/fis6dOwsnJ6dkhVh1fX/gv0KsKUGSMhQxMTFizJgxonz58sLe3l7kyJFDlC9fPlkR2dRiSu08X79+XbRp00Y4OTkJa2trUaJECTFp0qQU4yHKaCZCsD2WKDsLCgpCoUKFMGvWLIwePVrpcBShUqng6uqKtm3bpti1RkRkaBwDRkTZSnR0dLJxQGvXrsXr169Rt25dZYIiomyHY8CIKFs5c+YMRo4cifbt2yNXrly4ePEiVqxYgTJlyqB9+/ZKh0dE2QQTMCLKVjw9PeHh4YFffvkFr1+/Rs6cOdG9e3f89NNPqc6xSURkaBwDRkRERJTBOAaMiIiIKIMxASMiIiLKYIomYEePHoWJiQm2bdumZBga6RHPt99+q/P0GSYmJvj222/T9Djq2I8eParZ1qNHD50mGKasx8TEBKtXr/7ofkr+DdStW1fvqwrTcp+sYPXq1TAxMUFQUFCGPm5W+DuhzGHmzJnw8vL66JyhQUFBOv9dpQf1e+n8+fOKPH5SBw4cgJ2dXZpnLzF4AmZiYqLTT9JEgTKPmzdv4ttvv83wDwolbNmyBdWqVYOTkxNy5cqFOnXqYN++fcn2U6lUmDlzJgoVKgRra2uUK1cOmzZtSvGYAQEBaNKkCezs7JAzZ05069YtxTenPsck5ai/QKX0s3TpUqXDo3S0f//+NH8hBmRSq8tnYY8ePQwWc1qFh4djxowZGDt2bLJZO5SyePFixZK8adOmoVq1anB1dYW1tTWKFSuGESNGJPtf3qRJExQtWhTTp09P0+MY/CrIdevWaa2vXbsWBw8eTLa9ZMmSCAgIMPTDUxLLly//6LeZ9928eRNTp05F3bp1jfob8YIFCzBs2DA0b94cP/30E6Kjo7F69Wq0aNEC27dvR9u2bTX7Tpw4ET/99BP69u2LypUrY/fu3ejcuTNMTEy0ppx5/PgxateuDUdHR0ybNg1v377F7Nmzce3aNZw9e1brCjtdj0mZw5IlS2BnZ6e1rWrVqgpFY3hp+V9h7Pbv349FixalOQnr37+/1qT1gYGBmDx5Mvr16wcfHx/NdvXk6EpauXIl4uPj0alTJ6VD0Vi8eDFcXFwUSVAvXLiAChUqoGPHjrC3t0dAQACWL1+umcZKPU8tIM/z6NGjMXXqVNjb2+v1OAZPwLp27aq1fubMGRw8eDDZdgCfnIC9e/cOtra2n3QMY2ZhYaF0CJnWggULULlyZfz222+aLuJevXrB3d0da9as0SRgT548wZw5czB48GAsXLgQANCnTx/UqVNHMx+lehLkadOmITIyEhcuXECBAgUAAFWqVMHnn3+O1atXo1+/fnofkzKHL7/8Ei4uLkqHkW4y6/+KyMhIrQ+7rKR69eqoXr26Zv38+fOYPHkyqlevnuLnoZoSz3nVqlVo1aoVrK2tM/RxM6vt27cn21a9enV8+eWX+O2337S+JLdr1w5Dhw7F1q1b0atXL70eJ1O0NapUKvz444/Inz8/rK2t0aBBA/z7779a+9StWxdlypTBhQsXULt2bdja2mLChAkAgJiYGEyZMgVFixaFlZUVPDw88PXXXyMmJkbrGAcPHkStWrXg5OQEOzs7lChRQnMMfeMBgK1bt8Lb2xs2NjZwcXFB165d8eTJk48+35iYGIwcORKurq6wt7dHq1at8PjxY51fr8ePH6N169bIkSMH3NzcMHLkyGTPFUh5XMfmzZvh7e0Ne3t7ODg4oGzZsvj5558ByL51dSHKevXqJesu3r17N5o3b458+fLBysoKRYoUwffff4+EhAStx1Cfq5s3b6JevXqwtbWFu7s7Zs6cmSzG6OhofPvttyhevDisra2RN29etG3bFvfu3dPso1KpMH/+fJQuXRrW1tbInTs3+vfvjzdv3mgdKywsDLdu3UJYWNhHX8Pw8HC4ublpjc9zcHCAnZ0dbGxsNNt2796NuLg4DBo0SLPNxMQEAwcOxOPHj3H69GnN9u3bt6NFixaa5AsAGjZsiOLFi2PLli1pOmZ60PX11PV8A8CyZctQpEgR2NjYoEqVKjhx4oRBYo2NjcXkyZPh7e0NR0dH5MiRAz4+Pjhy5EiyfV+9eoVu3brBwcEBTk5O8PPzw5UrV5KNV4mLi8OtW7d0nuT6Q65evYoePXqgcOHCsLa2Rp48edCrVy+8evXqo/c9f/48GjduDBcXF9jY2KBQoULJ/oHreq4+1fv/K9TjfGbPnq05t1ZWVqhcuTLOnTun2W/27NkwMTHBgwcPkh1z/PjxsLS01DlW9dieY8eOYdCgQXBzc0P+/Pk1t//+++/w8fFBjhw5YG9vj+bNm+PGjRtax3j+/Dl69uyJ/Pnzw8rKCnnz5sUXX3yRbEjFx47Vo0cPLFq0CID2sBq1Z8+e4datW4iLi9PpuaXlOac2Li+1ccXr16/XfB7lzJkTHTt2xKNHjz4aQ2BgIK5evarVWqcWGhqKHj16wNHRUfOeCg0NTfE4t27dwpdffomcOXPC2toalSpVwp49e1J8vsePH0f//v2RK1cuODg4oHv37lp/J56enrhx4waOHTumee3fHxsaExODUaNGwdXVFTly5ECbNm3SPBZLF+pz8f7zd3NzQ7ly5bB79269j5kpCrH+9NNPMDU1xejRoxEWFoaZM2eiS5cu+Oeff7T2e/XqFZo2bYqOHTuia9euyJ07N1QqFVq1aoWTJ0+iX79+KFmyJK5du4Z58+bhzp072LVrFwDgxo0baNGiBcqVK4fvvvsOVlZW+Pfff3Hq1Kk0xbN69Wr07NkTlStXxvTp0xEcHIyff/4Zp06dwqVLl+Dk5JTq8+3Tpw/Wr1+Pzp07o0aNGjh8+DCaN2+u02sVFRWFBg0a4OHDhxg2bBjy5cuHdevW4fDhwx+978GDB9GpUyc0aNAAM2bMACBbIU+dOoXhw4ejdu3aGDZsGH755RdMmDABJUuWBADN79WrV8POzg6jRo2CnZ0dDh8+jMmTJyM8PByzZs3Seqw3b96gSZMmaNu2LTp06IBt27Zh7NixKFu2LJo2bQoASEhIQIsWLXDo0CF07NgRw4cPR0REBA4ePIjr169rmub79++veb2HDRuGwMBALFy4EJcuXcKpU6c039537tyJnj17YtWqVR9ttq5bty62bduGBQsWoGXLloiOjsaCBQsQFhaG4cOHa/a7dOkScuTIoXkN1KpUqaK5vVatWnjy5AlevHiBSpUqJXusKlWqYP/+/XofM73o+nrqer5XrFiB/v37o0aNGhgxYgTu37+PVq1aIWfOnPDw8PikWMPDw/Hrr7+iU6dO6Nu3LyIiIrBixQo0btwYZ8+eRYUKFQDIRKVly5Y4e/YsBg4cCC8vL+zevRt+fn7JjvnkyROULFkSfn5+Oo8xef36tda6mZkZnJ2dcfDgQdy/fx89e/ZEnjx5cOPGDSxbtgw3btzAmTNnUr0A58WLF2jUqBFcXV0xbtw4ODk5ISgoCDt27NDaT9dzlV42btyIiIgI9O/fHyYmJpg5cybatm2L+/fvw8LCAh06dMDXX3+NLVu2YMyYMVr33bJlCxo1agRnZ2e9HnPQoEFwdXXF5MmTERkZCUAObfHz80Pjxo0xY8YMvHv3DkuWLEGtWrVw6dIlzYdju3btcOPGDQwdOhSenp548eIFDh48iIcPH2r20eVY/fv3x9OnT1McPgPI5HLNmjUIDAw0yFCNlJ6zPn788UdMmjQJHTp0QJ8+ffDy5UssWLAAtWvX/ujn0d9//w0A+Oyzz7S2CyHwxRdf4OTJkxgwYABKliyJnTt3pvieunHjBmrWrAl3d3eMGzcOOXLkwJYtW9C6dWts374dbdq00dp/yJAhcHJywrfffovbt29jyZIlePDggeZisvnz52Po0KGws7PDxIkTAQC5c+fWOsbQoUPh7OyMKVOmICgoCPPnz8eQIUPg7++v2eft27eIjo7+6OtnYWEBR0fHZM//1atXiI+Px927dzFu3DiYmZmleJGQt7e3JtfQS3rP9j148GCR2sMcOXJEABAlS5YUMTExmu0///yzACCuXbum2VanTh0BQCxdulTrGOvWrROmpqbixIkTWtuXLl0qAIhTp04JIYSYN2+eACBevnyZaqy6xhMbGyvc3NxEmTJlRFRUlGa/vXv3CgBi8uTJmm1TpkzRev6XL18WAMSgQYO0Hrtz584CgJgyZUqq8QkhxPz58wUAsWXLFs22yMhIUbRoUQFAHDlyRLPdz89PFCxYULM+fPhw4eDgIOLj41M9/tatW5MdR+3du3fJtvXv31/Y2tqK6OhozTb1uVq7dq1mW0xMjMiTJ49o166dZtvKlSsFADF37txkx1WpVEIIIU6cOCEAiA0bNmjdfuDAgWTbV61aJQCIVatWpfr81IKDg0WDBg0EAM2Pi4uL+Pvvv7X2a968uShcuHCy+0dGRgoAYty4cUIIIc6dO5fsOauNGTNGANC8Rroe80N0fZ7v/w3o83rqcr7V74UKFSpovWeWLVsmAIg6dep8NMak6tSpo3Wf+Ph4reMKIcSbN29E7ty5Ra9evTTbtm/fLgCI+fPna7YlJCSI+vXrJ3utAgMDBQDh5+f30XjU79/3f9SvaUqv0aZNmwQAcfz4cc029d9mYGCgEEKInTt3CgDi3LlzqT62PucqNWn9O1G/Rrly5RKvX7/WbN+9e7cAIH777TfNturVqwtvb2+t4509ezbV90Nq1K9RrVq1tP5HRURECCcnJ9G3b1+t/Z8/fy4cHR0129+8eSMAiFmzZqX6GLoeS4gPf3b5+flpnU9dqP9HJD0fqT1n9WMkPSdq73+mBAUFCTMzM/Hjjz9q7Xft2jVhbm6ebPv7vvnmGwFAREREaG3ftWuXACBmzpyp2RYfHy98fHySPY8GDRqIsmXLan0OqFQqUaNGDVGsWLFkz9fb21vExsZqts+cOVMAELt379ZsK126dIr/P9THaNiwoeZzQgghRo4cKczMzERoaKhmm/o8fewnpcd59uyZ1j758+cX/v7+Kb6G06ZNEwBEcHBwirenJlN0Qfbs2VNrgLJ6gOL9+/e19rOyskLPnj21tm3duhUlS5aEl5cXQkJCND/169cHAE1XhfobwO7duz862PRj8Zw/fx4vXrzAoEGDtPrMmzdvDi8vrxSvpFNTt4QMGzZMa/uIESM+GFPS++fNmxdffvmlZputra1mfNGHODk5ITIyEgcPHtTpsd6XtGsuIiICISEh8PHxwbt373Dr1i2tfe3s7LTGOVhaWqJKlSpa53T79u1wcXHB0KFDkz2WuuVg69atcHR0xOeff651fr29vWFnZ6fVFdWjRw8IIXQatGlra4sSJUrAz88PW7duxcqVKzXdn0m7m6OiomBlZZXs/urzHhUVpfVb13112S896PN66nK+1e+FAQMGaL1n1N0Wn8rMzExzXJVKhdevXyM+Ph6VKlXCxYsXNfsdOHAAFhYW6Nu3r2abqakpBg8enOyYnp6eEELodYXV9u3bcfDgQc3Phg0bAGi/RtHR0QgJCUG1atUAQCu+96n/H+3duzfVbix9zlV68fX11WrBSul/s6+vLy5cuKA1bMDf3x9WVlb44osv9H7Mvn37ao2BPHjwIEJDQ9GpUyet18HMzAxVq1bVvA42NjawtLTE0aNHU+321PVYH7N69WoIIQx2odL7z1kfO3bsgEqlQocOHbSeU548eVCsWLGPPqdXr17B3Nw82UUm+/fvh7m5OQYOHKjZZmZmluz/9evXr3H48GF06NBB838iJCQEr169QuPGjXH37t1kQ3P69eun1Xo7cOBAmJuba/UUfEy/fv20Wph9fHyQkJCg1R3+9ddfa71vU/uZM2dOsuPnzJkTBw8exG+//YbvvvsOLi4uePv2bYqxqN8jISEhOscPZJIuyKRjZoDEJ/P+m8jd3T3ZXG13795FQEAAXF1dUzz2ixcvAMh/Er/++iv69OmDcePGoUGDBmjbti2+/PLLZJfdfiwe9QkuUaJEssfz8vLCyZMnU32uDx48gKmpabIrX1I6Vmr3L1q0aLKuDV3uP2jQIGzZsgVNmzaFu7s7GjVqhA4dOqBJkyY6PfaNGzfwzTff4PDhwwgPD9e67f1xV/nz508Wo7OzM65evapZv3fvHkqUKAFz89T/DO/evYuwsDC4ubmleLv6/Oqrffv2MDc3x2+//abZ9sUXX6BYsWKYOHGiphnbxsYmxfF16mZt9Qew+reu++qyX3rQ5/XU5Xyr3wvFihXTut3CwgKFCxc2SMxr1qzBnDlzko25KVSokGb5wYMHyJs3b7KLcooWLWqQGGrXrp3iIPzXr19j6tSp2Lx5c7K/xQ+NRaxTpw7atWuHqVOnYt68eahbty5at26Nzp07a5Lz9Prb14cu/5vbt2+PUaNGwd/fHxMmTIAQAlu3bkXTpk3h4OCg92MmPa+AfB0AaL5Uv0/9GFZWVpgxYwa++uor5M6dG9WqVUOLFi3QvXt35MmTR69jZbT3n7M+7t69CyFEsvegWlq7qdXvqfcTs/c/a/79918IITBp0iRMmjQpxWO9ePEC7u7umvX3Y7Wzs0PevHn1Kn+ky99mqVKlUKpUKZ2PmZSlpaVmXFyLFi3QoEED1KxZE25ubmjRooXWvuK/GR11rfmplikSsNQyf/HeNJUpfTCpVCqULVsWc+fOTfEY6jEoNjY2OH78OI4cOYJ9+/bhwIED8Pf3R/369fHnn39qxaBrPFmNm5sbLl++jD/++AO///47fv/9d6xatQrdu3fHmjVrPnjf0NBQ1KlTBw4ODvjuu+9QpEgRWFtb4+LFixg7dmyyVkVDvYYqlQpubm6aFof3pZZ4f8j9+/dx4MABLFu2TGt7zpw5UatWLa1xgXnz5sWRI0cghEg2CBcA8uXLp9kv6faknj17hpw5c2o+WHU9ZnrQ9fXU93ynl/Xr16NHjx5o3bo1xowZAzc3N5iZmWH69OlaLS5K6dChA/7++2+MGTMGFSpUgJ2dHVQqFZo0afLB10hd8PnMmTP47bff8Mcff6BXr16YM2cOzpw5ozmOof/29aXL+zhfvnzw8fHBli1bMGHCBJw5cwYPHz7UjDPV1/v/59Wv47p16zSJVFJJv8CNGDECLVu2xK5du/DHH39g0qRJmD59Og4fPoyKFSvqdayMlNJnW2of5u9fBKNSqWBiYoLff/89xfP1fgL1vly5ciE+Ph4RERF6l1FQPz4AjB49Go0bN05xH0N9EUpKl7/NsLAwnXoULC0tkTNnzg/uU6NGDeTNmxcbNmxIloCpkz59r5TOFAnYpyhSpAiuXLmCBg0afDT7NDU1RYMGDdCgQQPMnTsX06ZNw8SJE3HkyJEUrwBJTcGCBQEAt2/fTvZN6vbt25rbU7uvSqXStP4kvZ+uj339+vVkH9663t/S0hItW7ZEy5YtoVKpMGjQIPzvf//DpEmTUmxZUzt69ChevXqFHTt2oHbt2prtgYGBOj1uSooUKYJ//vkHcXFxqX5LK1KkCP766y/UrFnTYC1DwcHBAJL/IwPkFXLx8fGa9QoVKuDXX39FQECA1jcp9QUZ6kHg7u7ucHV1TbE6c9LB4vocMz3o+nrqer7Vf+t3797Vei/ExcUhMDAQ5cuX/6R4t23bhsKFC2PHjh1af5tTpkxJFseRI0eSlaZJ6eplQ3nz5g0OHTqEqVOnYvLkyZrt6lYWXVSrVg3VqlXDjz/+iI0bN6JLly7YvHkz+vTpky5/++nF19cXgwYNwu3bt+Hv7w9bW1u0bNnSIMdW9xa4ubnp9H+6SJEi+Oqrr/DVV1/h7t27qFChAubMmYP169frdSx9WzMMzdnZOcUrDt+/4rRIkSIQQqBQoUIoXry43o/j5eUFQL63y5Urp9lesGBBHDp0CG/fvtVK4t7/rFG3dFtYWOj8OXr37l3Uq1dPs/727Vs8e/YMzZo102wzxOs/fPjwjzYuALJFWpfi8NHR0Sm2bAcGBsLFxUXvL0WZYgzYp+jQoQOePHmC5cuXJ7stKipKc0XJ+1cxAYkfdCl1B31IpUqV4ObmhqVLl2rd9/fff0dAQMAHr2hUXwH4yy+/aG2fP3++To/drFkzPH36VGu6pHfv3iVrzUnJ+5fGm5qaat5w6uehrj/z/htf/W0j6beL2NhYLF68WKe4U9KuXTuEhIRoamElpX6cDh06ICEhAd9//32yfeLj47Xi1LUMRdGiRWFqagp/f3+t5/P48WOcOHECFStW1Gz74osvYGFhofU8hRBYunQp3N3dUaNGDa3ns3fvXq1Lvw8dOoQ7d+5oynvoe0xD0/X11PV8V6pUCa6urli6dCliY2M121evXp3q5er6SCmOf/75J1mpjsaNGyMuLk7r/4BKpdKUEkjKUGUoUooN0O29/ObNm2T3e///kT5/+0pr164dzMzMsGnTJmzduhUtWrQwWC2rxo0bw8HBAdOmTUtxvJy69MC7d++SXfFWpEgR2Nvba15TXY8FpP6/EDBcGYoPKVKkCMLCwrSGbTx79gw7d+7U2q9t27YwMzPD1KlTk/1Nif+u5PsQda2y9788NmvWDPHx8ViyZIlmW0JCAhYsWKC1n5ubG+rWrYv//e9/Kb6nUioNsWzZMq3XbsmSJYiPj9d8PgLy9f/Uv/G0jAGLjIzEu3fvkh1r+/btePPmTYpXul+4cEGr5puusnwLWLdu3bBlyxYMGDAAR44cQc2aNZGQkIBbt25hy5Yt+OOPP1CpUiV89913OH78OJo3b46CBQvixYsXWLx4MfLnz6/3Jf8WFhaYMWMGevbsiTp16qBTp06aMhSenp4YOXJkqvetUKECOnXqhMWLFyMsLAw1atTAoUOHdP6m3rdvXyxcuBDdu3fHhQsXkDdvXqxbt06ngrR9+vTB69evUb9+feTPnx8PHjzAggULUKFCBU1JhAoVKsDMzAwzZsxAWFgYrKysUL9+fdSoUQPOzs7w8/PDsGHDYGJignXr1n1St2z37t2xdu1ajBo1CmfPnoWPjw8iIyPx119/YdCgQfjiiy9Qp04d9O/fH9OnT8fly5fRqFEjWFhY4O7du9i6dSt+/vlnzQUJupahcHV1Ra9evfDrr79qxgJGRERg8eLFiIqKwvjx4zX75s+fHyNGjMCsWbMQFxeHypUrY9euXThx4gQ2bNig1Qw+YcIEbN26FfXq1cPw4cPx9u1bzJo1C2XLltW6eESfYxqarq+nrufbwsICP/zwA/r374/69evD19cXgYGBWLVqlUHGgLVo0QI7duxAmzZt0Lx5cwQGBmLp0qUoVaqU1oDY1q1bo0qVKvjqq6/w77//wsvLC3v27NF88Ur6bTotZShS4uDggNq1a2PmzJmIi4uDu7s7/vzzT51ahdesWYPFixejTZs2KFKkCCIiIrB8+XI4ODhoWgH0+dtXmpubG+rVq4e5c+ciIiICvr6+Bju2g4MDlixZgm7duuGzzz5Dx44d4erqiocPH2Lfvn2oWbMmFi5ciDt37qBBgwbo0KEDSpUqBXNzc+zcuRPBwcGawpm6HguQpQUAecFU48aNYWZmpjmOoctQpKRjx44YO3Ys2rRpg2HDhmnKZRQvXlzrAo8iRYrghx9+wPjx4xEUFITWrVvD3t4egYGB2LlzJ/r164fRo0en+jiFCxdGmTJl8Ndff2nVoWvZsiVq1qyJcePGISgoCKVKlcKOHTtS/IK7aNEi1KpVC2XLlkXfvn1RuHBhBAcH4/Tp03j8+DGuXLmitX9sbKzmXN2+fRuLFy9GrVq10KpVK80+3t7eWLJkCX744QcULVoUbm5uqY7dS01axoDdvXsXDRs2hK+vL7y8vGBqaorz589j/fr18PT01CpTBMjxbVevXk3xgp+P0uuayTTQpQzF1q1btbarL4FOeplrnTp1ROnSpVM8TmxsrJgxY4YoXbq0sLKyEs7OzsLb21tMnTpVhIWFCSGEOHTokPjiiy9Evnz5hKWlpciXL5/o1KmTuHPnTpriEUIIf39/UbFiRWFlZSVy5swpunTpIh4/fqy1z/uXDAshRFRUlBg2bJjIlSuXyJEjh2jZsqV49OiRTmUohBDiwYMHolWrVsLW1la4uLiI4cOHay5N/1AZim3btolGjRoJNzc3YWlpKQoUKCD69+8vnj17pnX85cuXi8KFCwszMzOtY546dUpUq1ZN2NjYiHz58omvv/5a/PHHH8keN7VzldJl1e/evRMTJ04UhQoVEhYWFiJPnjziyy+/FPfu3dPab9myZcLb21vY2NgIe3t7UbZsWfH111+Lp0+favbRpwxFXFycWLBggahQoYKws7MTdnZ2ol69euLw4cPJ9k1ISBDTpk0TBQsWFJaWlqJ06dJi/fr1KR73+vXrolGjRsLW1lY4OTmJLl26iOfPn3/SMVOi6/NM7VJ2XV5PXc+3EEIsXrxYFCpUSFhZWYlKlSqJ48ePJyspoYv376NSqTSvk5WVlahYsaLYu3dvis/r5cuXonPnzsLe3l44OjqKHj16iFOnTgkAYvPmzZr90lKGIrXyNY8fPxZt2rQRTk5OwtHRUbRv3148ffo02Xv5/TIUFy9eFJ06dRIFChQQVlZWws3NTbRo0UKcP38+2WPocq5Sk9a/E/VrlFJJh9T+Ty1fvlwAEPb29lrleXSlfo1SK81x5MgR0bhxY+Ho6Cisra1FkSJFRI8ePTSvWUhIiBg8eLDw8vISOXLkEI6OjqJq1apaJXt0PZYQsuTC0KFDhaurqzAxMdH6P27oMhSpPec///xTlClTRlhaWooSJUqI9evXp/iZIoQsxVKrVi2RI0cOkSNHDuHl5SUGDx4sbt++/dHY5s6dK+zs7JKVVXn16pXo1q2bcHBwEI6OjqJbt27i0qVLKf5d3bt3T3Tv3l3kyZNHWFhYCHd3d9GiRQuxbdu2ZM/32LFjol+/fsLZ2VnY2dmJLl26iFevXmkd7/nz56J58+bC3t5eq1REaq+Z+vM7pRJK+nj58qXo16+f5u/I0tJSFCtWTIwYMSLF/wNLliwRtra2Ijw8XO/HMhEii48sJ8qGTExMdCo4m93t2rULbdq0wcmTJ1GzZk2lw8lw/DshXYSFhaFw4cKYOXMmevfunW6Poy4qfO7cuRS78rKiihUrom7dupg3b57e983yY8CIiIDk9dPU41UcHBySVfkmokSOjo74+uuvMWvWLE7KrocDBw7g7t27WsNW9JHlx4ARUeb38uXLFK86VdPlMvCPGTp0KKKiolC9enXExMRgx44d+PvvvzFt2rRMfxWhMYuKivrohTE5c+ZMVuORMtbYsWMxduxYpcPIUpo0aZJqcVZdMAEjonRXuXLlFCdsVtP1MvAPqV+/PubMmYO9e/ciOjoaRYsWxYIFCzBkyJBPOi59Gn9//2QzmLzvyJEjKc6xR2TMFB0Ddvz4ccyaNQsXLlzQXF7bunXrD97n6NGjGDVqFG7cuAEPDw988803HN9AlMmdOnXqgwURnZ2dNVedkXF59uwZbty48cF9vL299Z60myirU7QFLDIyEuXLl0evXr3Qtm3bj+4fGBiI5s2bY8CAAdiwYQMOHTqEPn36IG/evKlW4CUi5WXHAfAk5c2bVzNTBBElyjRXQZqYmHy0BWzs2LHYt28frl+/rtnWsWNHhIaG4sCBAxkQJREREdGny1JjwE6fPp1sqoPGjRtjxIgRqd4nJiZGq1q9SqXC69evkStXLsWnmiAiIiLdCCEQERGBfPnywdQ06xdxyFIJ2PPnz5E7d26tbblz50Z4eDiioqJSvNJp+vTpmDp1akaFSEREROno0aNHyJ8/v9JhfLIslYClxfjx4zFq1CjNelhYGAoUKIBHjx7BwcFBwciIiIgyxsuXwLt3QEJC4k98PHDjBhAZCWzeDDg4AMeOAba2gCGnGs2VC3j1CihZUv6YmQGmpvJ3QgIQFweULi3jK1pUbjcxkb/zX9iNkIqfI9rUFi4u4WjVygP29vaGC05BWSoBy5MnD4KDg7W2BQcHw8HBIdU6P1ZWVrCyskq23cHBgQkYERFlaa9fA48fA6tXA+bmQFgYcOECkD8/EB0N/PGH/seMjU1cdnAAChYELCyAq1eBRo0AKyv5WObmQFAQUK8eEBEhkytnZ6BsWbm/gwOQJ08an1hkJDB4MLBmDdCnD7B8OcLD5U3GMnwoSyVg1atXx/79+7W2HTx4ME2zkBMREWUVr1/L1qrNm4H164ESJYBz51Lf/8KFlLfb2cmWJXNz+TsuDoiJARo0AIKDgZ49ZetUlSpAqVKAIvVxr18HOnQAAgJkMAUKAJnjekGDUjQBe/v2Lf7991/NemBgIC5fvoycOXOiQIECGD9+PJ48eYK1a9cCAAYMGICFCxfi66+/Rq9evXD48GFs2bIF+/btU+opEBER6UylkonOP//I32fOADY2MrlSd8fdvw+EhAD58sn7PH2a/DjvJ18eHsCjR8C4cTKxUqmA4sVlS5StLeDtLfOYTE0IYOVKYOhQICoKyJsX2LgRMNIivYomYOfPn0e9evU06+qxWn5+fli9ejWePXuGhw8fam4vVKgQ9u3bh5EjR+Lnn39G/vz58euvv7IGGBERZSghgNu3gTdv5LipqCiZPL15I7sDy5SRXXlXr8r9bW3l7XFxuj9GSolXoULAgweAnx/QuTPg5ia7/LJ8r9zbt8CAAcCGDXK9USNg3Tr5BI1UpqkDllHCw8Ph6OiIsLAwjgEjIqJkXr2SSc6xY8D27XJc06lT8repKZCk4ybN7OzkGKnatWVrV61assUrd27ZapWQIHMPCwu5v5WVHGOV5ROt1Dx+DFSoIEf///AD8PXX8sVOwtg+v7PUGDAiIiJ9CZHYvffmjRyo/vChbHS5fVt25129Crx4Ibel5s2b5Nty55ZX+T18CPTuLRMmCws5AL5JEzmGytRUDoq3tJS3ubjIbkJKIn9+YNMm2R9bq5bS0WQIJmBERGQ04uKAK1dkT9b8+Z9+vAoVZCtVlSry2IULA9bWskuxSBGZL1AahIcD/foBHTsC6hlwPv9c0ZAyGhMwIiLKlBISZMvSv//Kq/qsrWXtqrg42WqVJ4/8HD91SpZD0IeTk+ztKlBA/lSuDHTpIo/p5ATkyGH450P/uXAB8PUF7t0DjhyR471sbZWOKsMxASMiIkWoi4PGxMghQAkJshvw+HH5e9euTzt+lSpAnTrAV1/Jrj9zczmWKoXSkJQRhAAWLgRGj5ZXKBQsKOtqZMPkC2ACRkREBhQbCxw6JBs5Ll2SA8nj4oBnz2SDx+3bgLs78OSJ7sd0cpID1J8/B1q0kImUhYVM2mrWlMuWlrKaetGicjgRx1hlMqGhcpDcjh1yvXVrWXLC2VnJqBTFBIyIiHSSkCAHoj9+LBOpK1eArVtl95+dne7T1yRNvkxMAHv7xMHvn30muxXt7ID27YF27YBixQz9TChDhYYCFSvKPxQLC2D2bFnry2gv6dQNEzAiIkrRixdA9eoy8Xrw4MP7ppR8Va8uW8CqVJGfu0LI1qyCBWXhUBcXoy7zRGpOTkDTpnJeJH9/oFIlpSPKFJiAERGRxv37QN++wOHDH95PPQC+UCFgxAjZFWhjI8dXubgk1q+ibOrVK3nFRO7ccn3uXDnYz9FR2bgyESZgRETZlBDAnTuyG3Hy5NSn26tfX/YaOTrKlismV/RBf/8ty0sULQocPCgH5Flbyx/SYAJGRGTEVCo5ZuvZM1m64dw54NYt4OzZD9+vc2dg7Fg56TOvGiSdqFTArFnAxImy39rKSv7h5c+vdGSZEhMwIiIjoVLJBGv3bjmNzt9/63f/YcNkyQYPj2w/Ppr09fKlnKDy99/leqdOwP/+J6+woBQxASMiyuKePQOKF//wNDo2NnLCaHd3wNsb8PSUVxy2b59tyzCRoZw4Ibscnz6V3Yy//AL06cMs/iOYgBERZUFCAIMGAUuXpnx7y5YyKatcWZZyMOd/e0oPCQnyD/HpU8DLC9iyBShbVumosgS+JYmIMrngYDkWKywMcHCQxU6jo1Pe98EDObUOUYYwM5OTaP/8MzBvnizgRjoxVToAIiLS9uKFrCTfpo0sFJ4nj0y+AFn64f3k6++/5fgvIZh8UQY4fFiO71IrUwZYvpzJl57YAkZElAkcPgz8+iuwZw8QGZnyPsWLy5IRjo5y6p2cOXmFImWghATgu++A77+XLV/e3iyq+gmYgBERKWT9emDBgg+XhDA1leUgRoxg1XhS0NOnQJcuwNGjcr1HD6BUKSUjyvKYgBERpaN374DTp2Vh8Fu3gIAAOR+xEHKS6vfVqgU0by5LQvDqRMoU/vgD6NZNlpqws5Pdj507Kx1VlscEjIjIwN69A8aMARYv1m3/MWPklYpVq6ZvXER6+/ZbYOpUuVy+vLzKsXhxRUMyFkzAiIgMZPp0YMKElG8zMUmclLp5czl8pkIFwNU1Q0Mk0o+Tk/w9YIC8ypHTCRkMEzAiok909mzKrVfFiwMrVwLVq8uxXERZQmQkkCOHXB4+HKhYEahTR9mYjBD/JRARpUFQkLwAzMQkefI1e7asOn/7NlCzJpMvyiLi4mR/+GefARERcpuJCZOvdMJ/C0REOtq1S7ZqmZgAhQrJWl1JDRsGxMfL+RTZU0NZyoMHQO3a8tvDnTvyj53SFbsgiYg+4tUrwMUl9duvXZO1KImypN27ZVmJ0FBZZG7lSqBtW6WjMnpsASMiSoFKBcyYIYe/vJ98ffedHPelrj7P5IuypNhYWWCudWuZfFWpAly6xOQrg7AFjIgoidevgV69ZKPA+woVAu7elUXAibK8sWPlHI6A7DefNk1OsUAZgi1gREQAbt6UY7ty5UqefE2fDty/L3+YfJHRGDcOKF1azn81ezaTrwzGFjAiytZu3AAaNACCg7W3ly0L7NwJFCmiTFxEBhcdLf+oO3WS67lzA1ev8jJdhfBVJ6Js5/ff5XAXExM5fitp8jVtmhzXdfUqky8yInfvyoJ0nTsDmzYlbmfypRi2gBFRtvHoEVCgQMq39ewJfP894O6esTERpbtNm4B+/YC3b+UVJTlzKh0RgQkYERm5gweBX34BEhJky1dSo0cDvXvLli4LC2XiI0o3UVGykv3y5XK9dm1g40Z+y8gkmIARkdERApg7VyZYKWnQANi/n2OOyYjdugV06CCL1JmYABMnAlOmAOb82M8seCaIyGjcvi27Efftk2WNkurSBahfXzYCFC2qSHhEGefePZl8ubkBGzYADRsqHRG9hwkYEWV5KhVQowbwzz/Jb9u1C/jiiwwPiUhZzZvLrsfmzYG8eZWOhlLAyx+IKMsSQvaqmJlpJ1+tWsm6XkIw+aJs4sYNwMdHzumo1qcPk69MjC1gRJQlHT4sx3K97+XLD8/bSGRUhABWrQKGDJGD7keMkLW+KNNjCxgRZRkqlSzY7eycPPnauFF+FjH5omzj7VugWzd5KW9UFNCoEfC//ykdFemILWBElCWsWCF7VN7366/y84coW7lyRV7leOeO7IP//ns5tyMLq2YZTMCIKFO7cgWoUEF7W/Hichq7zp0BKytFwiJSzokTwOefAzExsqbX5s1ArVpKR0V6YgJGRJmSEEChQtpjigEgIADw8lImJqJMoXJl+SZwdwfWrGG/exbFBIyIMp2YGMDRUf5WK1xY1pZkxXrKlgICZNOvmRlgbQ389ZecUohdjlkWzxwRZRrBwcB338nPl6TJV2SkrCvJ5IuyHSGAhQtlP/yPPyZud3Fh8pXFsQWMiBQXEyOTrvcVLSrreTHxomwpNFReYbJjh1y/ckVeCszEyyjwLBKRYkJDZdHU95MvW1vA3x+4e5fJF2VTZ88CFSvK5MvCApg/H9i2jcmXEWELGBEp4sQJOS/j+xIS+BlD2ZgQMtkaOxaIi5NXovj7y4H3ZFT4b46IMlR0NFCzpnbyVaAAcP++/Oxh8kXZWmAgMGGCTL7atQMuXmTyZaTYAkZEGSIuDliwAPjqK+3tS5YAAwYoExNRplO4MLBokaxsP2gQYGKidESUTpiAEVG6i48HcucG3rzR3v7oEZA/vzIxEWUKKhUwZ46cSLtaNbmtVy9lY6IMwcZ+IkpXW7fKMcRJk6/Dh2V3I5MvytZevgRatAC+/hro2FHO7UjZBlvAiChd3L8vh668fp24LX9+eWVjSiUniLKV48eBTp2Ap0/lG2LiRCBHDqWjogzEFjAiMqj4eFm6qEgR7eRr/XrZ5cjki7I1lUoWVK1XTyZfJUoA//wD9O3L8V7ZDFvAiMhgDh8GGjTQ3ta6tRxonyePIiERZR5v3wJt2wIHD8r1bt2AxYsBOztl4yJFMAEjIoMICkqefO3bBzRrpkg4RJlPjhyAjY38WbwY6NFD6YhIQeyCJKJP8uqVrBlZqFDitl9/lYPsmXxRtpeQIEtKALKLcdUq4Px5Jl/EFjAiSruFC4GhQ7W3zZsnx4ARZXvPngGdOwPu7sC6dTIBy5lT/lC2xwSMiNLE0lIWV1Vzd5ctX02aKBcTUabx559A166y1ESOHPKy4CJFlI6KMhEmYESkN19f7eSLBVWJ/hMfD0yZAkyfLvvhy5WTczky+aL3MAEjIr107Ahs2ZK4HhcHmPM/CRHw+LHscjxxQq737y/75G1slI2LMiX+2yQinQQEyJlSwsMTt4WGMvkiAiDrezVtCly/DtjbA8uXy6ZiolTwKkgiSpUQcpC9iQlQqpR28hUeDjg6KhcbUaZiagrMnw9UqgRcvMjkiz6KCRgRpap3b3mlY1KNG8ur6u3tlYmJKNN4+FAOtldr0EBWtS9aVLmYKMtg5wERpej332XJIrUrV4CyZTlbChEAYM8eWcsrPl62eKmTLlO2a5Bu+JdCRFpu3waqV9cuohoaKi/mYvJF2V5sLDByJPDFF8CbN4CXFwdCUpoonoAtWrQInp6esLa2RtWqVXH27NkP7j9//nyUKFECNjY28PDwwMiRIxEdHZ1B0RIZr+vXZYLl5QWcOZO4/c4djvUiAgAEBgK1asmxXoBMxE6eBDw9lYyKsihFEzB/f3+MGjUKU6ZMwcWLF1G+fHk0btwYL168SHH/jRs3Yty4cZgyZQoCAgKwYsUK+Pv7Y8KECRkcOZFxeftWdi8mVbIkcPcuUKyYMjERZSrbtwMVKwLnzgHOzsDu3cDcubIiMVEaKJqAzZ07F3379kXPnj1RqlQpLF26FLa2tli5cmWK+//999+oWbMmOnfuDE9PTzRq1AidOnX6aKsZESUXFwecOiVbvZIOqG/ZUg5ruXmTY4mJNP7+GwgLk/3zly8DrVopHRFlcYolYLGxsbhw4QIaNmyYGIypKRo2bIjTp0+neJ8aNWrgwoULmoTr/v372L9/P5p9YMbfmJgYhIeHa/0QZTd37gAtWgA+PvLLu4WF/OJeq5b2foMGybHFZmbKxEmUqQiRuDx9OvDzz8CxY0CBAsrFREZDsZGDISEhSEhIQO7cubW2586dG7du3UrxPp07d0ZISAhq1aoFIQTi4+MxYMCAD3ZBTp8+HVOnTjVo7ESZmRByWMrKlfL3v//qdr/Hj+V8jkQEYPNmYM0a+Y1E/Y1l2DCloyIjovggfH0cPXoU06ZNw+LFi3Hx4kXs2LED+/btw/fff5/qfcaPH4+wsDDNz6NHjzIwYqKMoU66TEzkVfC1awOrVydPvsqVA/buBe7dA54+lV2NQsgfJl9EkEXu+vcHOnUCDhyQFe2J0oFiLWAuLi4wMzNDcHCw1vbg4GDkyZMnxftMmjQJ3bp1Q58+fQAAZcuWRWRkJPr164eJEyfCNIX6K1ZWVrCysjL8EyBSWEgIMGMGMHt26vu4uABduwJdusgC3UT0AbdvAx06AFevym8zEyYA/fopHRUZKcUSMEtLS3h7e+PQoUNo3bo1AEClUuHQoUMYMmRIivd59+5dsiTL7L/BKiJpXz2REXv7FvjsM3mFYkoqVACOHmXpCCK9rF8PDBgAREYCbm5y/fPPlY6KjJiiXZCjRo3C8uXLsWbNGgQEBGDgwIGIjIxEz549AQDdu3fH+PHjNfu3bNkSS5YswebNmxEYGIiDBw9i0qRJaNmypSYRIzJW9+4B3bvLKxaTJl/lywOjRwPPn8uuxEuXmHwR6eXHH4Fu3WTyVa+evMqRyRelM0XL9/r6+uLly5eYPHkynj9/jgoVKuDAgQOagfkPHz7UavH65ptvYGJigm+++QZPnjyBq6srWrZsiR9//FGpp0CU7n75BRg+PPl2e3vg5UuAPexEn+jLL4GZM4FRo4BvvuFlwJQhTEQ267sLDw+Ho6MjwsLC4ODgoHQ4RMkIAVy4IOdhXLw4+e0tWsjxwR06cAYUojQRQo7zKl8+cdurV0CuXMrFRB9lbJ/f/PdNlAnExsqiqPPny6veU7J+PdC5M+djJPokb98CAwcCGzcChw8DderI7Uy+KINlqTIURMbmzh051MTKCqhfP3nyZWMDfP01kJAgr2Rk8kX0Ca5elZcDr18v169fVzYeytbYAkakACHk/L0PHya/rVQpWXS7ZUsmXEQGIYSs5zVsGBATI4vebdokp4YgUghbwIgykEoFTJwoi6UmTb7KlQOuXJGfEzduyGnmmHwRGUB4uOy7799fJl9Nm8qrHJl8kcLYAkaUAQID5ZWMv/2W/La4OA6mJ0o3u3fLaYXMzGTT8ldfyW9ARArjv32idHTsGNCggRzDlVSuXPIKxw4dlImLKNvo2lUWx2vfHqheXeloiDT4NYAoHTx9KqcBqltXO/nKmxc4dEhOI8TkiygdhIYCQ4YAb97IdRMTYO5cJl+U6TABIzKQiAiZVJmYyDG+r14l3ubnJ4efPH0qr3YkonRw7pycp2vRIllqgigTYwJG9AlUKsDfH6hWDXBwALZu1b69dm3g3Ttg9WrA0lKREImMnxCyiF7NmnLAZaFCcqwXUSbGMWBEafDypZy1RF1OKKnChYEVK2R9R17JSJTOXr8GevZMLKLXrh3w66+Ak5OiYRF9DBMwIj2cPw+0bQs8epT8tsGDgWnTZEsYEWWAa9fk3FwPH8om5rlzgUGD+M2HsgQmYEQ6evsWqFxZe1vx4sDBg0CBAsrERJSt5csnux+LFAG2bJHjv4iyCI4BI/qIhARgxAjA3j5x2y+/yPpdt28z+SLKUBERMukCZD2X338HLl5k8kVZDhMwolRcvAg0ayaLpP78c+L26tWBoUNZPJUow504AZQsKa9qUStdmv3+lCUxASN6T2wsYGEBeHvLL9dJnTgB/P23MnERZVsqlRxgWa8e8OQJsGBB8urGRFkMEzCi/7x7JwunWlkB8fGJ27t1A3btkr0etWopFR1RNvXiBdCkiZxENSFBVrY/flxOLUSUhbEThbK9S5eAmTPldHFJWVsDkZGcNo5IMUeOyIm0nz8HbGyAhQtlyQle5UhGgAkYZVvBwYCPD3D3bvLb7t2T9byISCEPHgCNGsnm6FKl5FWOpUsrHRWRwfC7PWVLQgB58mgnX926AQEB8jYmX0QKK1gQGD9etnidPcvki4wOW8AoW2rZMnF50iTgu++Ui4WI/vPXX4CnJ1C0qFyfOpXdjWS02AJG2U758sC+fXLZ3JzJF5Hi4uOBb76RXY6+vnLmeoDJFxk1toBRtvLLL8DVq4nrr18rFwsRQZaV6NRJ1ngB5HQT6kKrREaMCRhlC5GRspJ90v/rKhW/YBMp6vffge7dgZAQ+QZdtgzo2FHpqIgyBLsgyej99RdgZ6edfF29yuSLSDFxccDYsXKqiZAQoGJF4MIFJl+UrbAFjIyanZ1s/VKrWVP2dDD5IlKQELLGFwAMHgzMni0L7xFlI0zAyCgJAbi7aydfK1YAvXopFxNRtieE/PZjaQn4+8sJV9u1UzoqIkUwASOj5OgIREQkrnO8F5GCYmOBceNkK9e0aXJboULyhyib4hgwMhoqFbBkiUy0kiZf6i/dRKSAwEA55cS8ecBPPwG3bikdEVGmwBYwMgpCpDw3b9IuSCLKYDt2yH7/sDDAyQlYvRrw8lI6KqJMgS1glOWtW5d8wuw//5RJma2tMjERZWsxMcDQoXJ8V1gYUK0acPky8MUXSkdGlGmwBYyytFGjZM+GmoWFHG5CRAoRQla0P35crn/9NfDDD/LNSUQabAGjLGvTJu3ka9cuJl9EijMxAfr0AXLlknN+zZjB5IsoBWwBoywnPl6WmHjxInHbo0dA/vzKxUSUrUVFAUFBQMmScr1bN6B5cyBnTkXDIsrM2AJGWYoQ8st00uTr8mUmX0SKuX1bjvFq2BB4+TJxO5Mvog9iAkZZSoUK2uuxsUD58oqEQkTr1wPe3nJur7g4WXKCiHTCBIyyjFmz5P95tYQEDi0hUsS7d0Dv3rKrMTISqFtXNkVXqaJ0ZERZBhMwyhIiIuTFVGqxsclLTxBRBrh5UyZaK1fKAfdTpsgZ7/PlUzoyoiyFg/ApS3BwSFw+fpwtX0SKmTEDuHEDyJMH2LABqF9f6YiIsiQmYJSpxcYCOXIkrtvZyVlNiEghv/wCmJvLOR1z51Y6GqIsi504lKl9840sO6EWGqpYKETZ07VrwJgx8hJkQM50v2IFky+iT8QWMMq0hJAD79UiIlKe75GI0oEQwK+/AsOGAdHRQIkSssAqERkEEzDKtAYMSFy+fVt2PxJRBggPB/r3BzZvlutNm3IeRyIDYxckZUq9egHLliWuFy+uXCxE2cqlS7K21+bNssl5xgxg717A1VXpyIiMyie1gEVHR8Pa2tpQsRABAJYuBVatSly/ckW5WIiylXXrZDdjbCzg4SGTsBo1lI6KyCjp3QKmUqnw/fffw93dHXZ2drh//z4AYNKkSVixYoXBA6TsZcgQYODAxPVbt4By5ZSLhyhbKVRIVjhu2VIWVmXyRZRu9E7AfvjhB6xevRozZ86EpaWlZnuZMmXw66+/GjQ4yl7i4oBFixLXr16V436JKB2FhSUu16oFnD4N7N7NuRyJ0pneCdjatWuxbNkydOnSBWZJLkkrX748bt26ZdDgKPt4+xZIks8jIAAoW1a5eIiMnhDAzz8Dnp6yur1a5cqywj0RpSu9E7AnT56gaNGiybarVCrExcUZJCjKXsaMAeztE9fLlWPLF1G6ev0aaNMGGDFCFtdbvVrhgIiyH70TsFKlSuHEiRPJtm/btg0VK1Y0SFCUffz8MzB7duL6qFFy0D2/gBOlkzNngIoVZTejpSWwYIG80pGIMpTeV0FOnjwZfn5+ePLkCVQqFXbs2IHbt29j7dq12Lt3b3rESEbqp5+A8eMT18+fl1e/E1E6UKmAuXPlmy4+HihSBPD355uOSCEmQqjnl9DdiRMn8N133+HKlSt4+/YtPvvsM0yePBmNGjVKjxgNKjw8HI6OjggLC4ND0hmeKcOZm8sLrgAgMFAORSGidLJ2LeDnJ5c7dJCF9hwdlY2JSA/G9vmdpjpgPj4+OHjwoKFjoWxk0KDE5GvOHCZfROmuc2dgwwY59qt/f/bzEylM7zFghQsXxqtXr5JtDw0NReHChQ0SFBm3/v2BJUsS13v1Ui4WIqOlUsm5HGNi5Lq5OXDggJzji8kXkeL0TsCCgoKQoG66SCImJgZPnjwxSFBkvNat055i6NIlwMlJsXCIjNOLF3L+xr59gbFjE7cz8SLKNHTugtyzZ49m+Y8//oBjkrEDCQkJOHToEDzZj0QfcOEC0L174vrNm0DJksrFQ2SUjh6V3Y3PngE2NpxKgiiT0jkBa926NQDAxMQEfuqBnP+xsLCAp6cn5syZY9DgyLgkTb4OHGDyRWRQCQnAjz8CU6fK7seSJYGtW4HSpZWOjIhSoHMCplKpAACFChXCuXPn4OLikm5BkfFZuzax2HaPHkDjxoqGQ2Rcnj8HunQBDh+W6z17yvpeOXIoGxcRpSpNZSiyMmO7jDWrSDr05M0bjvsiMqj792Vx1fh4YOlSoFs3pSMiMjhj+/xOUxmKyMhIHDt2DA8fPkRsbKzWbcOGDTNIYGQc7t+X9R7VNm1i8kVkEEIkfrMpXBjYsgUoWBDw8lI2LiLSid4tYJcuXUKzZs3w7t07REZGImfOnAgJCYGtrS3c3Nxw//799IrVIIwtg87M4uMBC4vE9QIFgAcPlIuHyGg8eQJ07Sqr2meBAthEhmBsn996l6EYOXIkWrZsiTdv3sDGxgZnzpzBgwcP4O3tjdlJJ/WjbG/x4sTlZs2YfBEZxIEDQIUK8mrHQYPkNx0iynL0TsAuX76Mr776CqampjAzM0NMTAw8PDwwc+ZMTJgwIT1ipCwoKgoYPjxxfd8+5WIhMgpxccC4cbK+V0iITML275cFVokoy9E7AbOwsICpqbybm5sbHj58CABwdHTEo0eP9A5g0aJF8PT0hLW1NapWrYqzZ89+cP/Q0FAMHjwYefPmhZWVFYoXL479+/fr/biUfqKjAVvbxHX11Y9ElEaPHgF16wIzZsj1QYOA06eB4sUVDYuI0k7vr04VK1bEuXPnUKxYMdSpUweTJ09GSEgI1q1bhzJlyuh1LH9/f4waNQpLly5F1apVMX/+fDRu3Bi3b9+Gm5tbsv1jY2Px+eefw83NDdu2bYO7uzsePHgAJ47qzlQaNkxc7tGD9b6IPsmTJ7K16/VrwMEBWLEC+PJLpaMiok+k9yD88+fPIyIiAvXq1cOLFy/QvXt3/P333yhWrBhWrFiBChUq6HysqlWronLlyli4cCEAWWvMw8MDQ4cOxbhx45Ltv3TpUsyaNQu3bt2CRdLR3XowtkF8mY0QwH8NpGjcWA5XIaJP1KMHcOMG4O8vr3gkyoaM7fNbsTpgsbGxsLW1xbZt2zRV9gHAz88PoaGh2L17d7L7NGvWDDlz5oStrS12794NV1dXdO7cGWPHjoWZmZlOj2tsJzCz+d//5Fy/ABAeDtjbKxsPUZYUFATY2QHqgtfv3gFmZoCVlaJhESnJ2D6/9R4DlpqLFy+iRYsWOu8fEhKChIQE5M6dW2t77ty58fz58xTvc//+fWzbtg0JCQnYv38/Jk2ahDlz5uCHH35I9XFiYmIQHh6u9UPpZ9q0xGUmX0RpsHOn7HL085NTCgFyUCWTLyKjolcC9scff2D06NGYMGGCpt7XrVu30Lp1a1SuXFkzXVF6UalUcHNzw7Jly+Dt7Q1fX19MnDgRS5cuTfU+06dPh6Ojo+bHw8MjXWPMzi5fBv67JgMjRyoaClHWExMDDBsGtG0LhIUBr17J30RklHROwFasWIGmTZti9erVmDFjBqpVq4b169ejevXqyJMnD65fv67X1YguLi4wMzNDcHCw1vbg4GDkyZMnxfvkzZsXxYsX1+puLFmyJJ4/f56sIr/a+PHjERYWpvlJy5WapJuKFROXx4xRLg6iLOfePaBmTTl/IwCMHg2cOAE4OysbFxGlG50TsJ9//hkzZsxASEgItmzZgpCQECxevBjXrl3D0qVLUVLPS90sLS3h7e2NQ4cOabapVCocOnQI1atXT/E+NWvWxL///qvV0nbnzh3kzZsXlpaWKd7HysoKDg4OWj+UPtzd5e9WrYC8eZWNhSjL2LJFfnu5cAHIlQvYuxeYNUt7GgkiMjo6J2D37t1D+/btAQBt27aFubk5Zs2ahfz586f5wUeNGoXly5djzZo1CAgIwMCBAxEZGYmePXsCALp3747x48dr9h84cCBev36N4cOH486dO9i3bx+mTZuGwYMHpzkGMozr1+XV8gAwc6aysRBlGdHRcjqhiAjZAnb5MtC8udJREVEG0LkOWFRUFGz/q65pYmICKysr5P3EZg5fX1+8fPkSkydPxvPnz1GhQgUcOHBAMzD/4cOHmqKvAODh4YE//vgDI0eORLly5eDu7o7hw4dj7NixnxQHfRohgLJlE9fZ+kWkI2trWVpi505g6lRWtSfKRnQuQ2FqaooffvgBdnZ2AICxY8dizJgxcFFfJv2fYcOGGT5KAzK2y1gzAxOTxOXly4E+fZSLhSjT27hRlpXgG4VIL8b2+a1zAubp6QmTpJ+0KR3MxERzdWRmZWwnUGkREbI4NyATsXS+EJYo63r3Tk6Q+uuvgKWl7G7kNBFEOjO2z2+d27uDgoLSMQzKioRITL4AICFBuViIMrWAAKBDBzlY0sREjvviPI5E2RoHHFCazZmTuNyxo3ZXJBH9Z80aOXn2u3dA7tyyC7J+faWjIiKFKTYVkVKMrQlTKQkJ2uOFs9dfEZEOhAD69pWTZwNylvr162USRkR6M7bPb4NNRUTZy+HDict//aVcHESZlomJnDjb1BT4/ns5Mz2TLyL6D1vAKE3U3Y3FiwO3bysbC1GmIYScPsjJSa6rVHKw/WefKRkVkVEwts9vtoCRXoQAklYe+a82LxFFRABdugA+PnK8FyBbv5h8EVEK0pSA3bt3D9988w06deqEFy9eAAB+//133Lhxw6DBUeYzYICcI1jthx+Ui4Uo07h8GfD2BjZtklc8Hj+udERElMnpnYAdO3YMZcuWxT///IMdO3bg7du3AIArV65gypQpBg+QMo9Xr4BlyxLXWXaCsj0hgCVLgGrVgLt3AQ8PmXw1aaJ0ZESUyemdgI0bNw4//PADDh48qDUBdv369XHmzBmDBkeZS9Kux+ho2btClG2FhQG+vrLEREwM0LIlcOkSUKOG0pERURag90fotWvX0KZNm2Tb3dzcEBISYpCgKPNp3Tpx+dtvASsrpSIhyiSGDAG2bpX1WObMAXbvBnLlUjoqIsoi9E7AnJyc8OzZs2TbL126BHd3d4MERZlLRIT8bFFjTzMRgOnT5bivkyeBUaNYiZiI9KJ3AtaxY0eMHTsWz58/h4mJCVQqFU6dOoXRo0eje/fu6REjKSxp1+OFC8rFQaSoN29kVXu1/PmBc+eAqlWVi4mIsiy9E7Bp06bBy8sLHh4eePv2LUqVKoXatWujRo0a+Oabb9IjRlLQkydAbKxcLlWKV9RTNvXPP0DFikCPHtrNwWz1IqI0SnMh1ocPH+L69et4+/YtKlasiGLFihk6tnRhbIXc0tODB4CnZ+L6u3eAjY1i4RBlPCGAuXOBceOA+HigSBHA3192PRJRhjK2z2+9J+M+efIkatWqhQIFCqBAgQLpERNlAvfvy88atZ9/ZvJF2cyrV7LFa+9eud6hA7B8OWAE//iJSHl6d0HWr18fhQoVwoQJE3Dz5s30iIkUpv6ir/bjj8CwYcrFQ5ThTp0CKlSQyZeVlaz1tXkzky8iMhi9E7CnT5/iq6++wrFjx1CmTBlUqFABs2bNwuPHj9MjPlJA//6Jy+vWARMmKBcLkSKePgUePwaKFQPOnJFTQHC8FxEZ0CdNxh0YGIiNGzdi06ZNuHXrFmrXro3Dhw8bMj6DM7Y+ZEN79AhI2rOcvaZqp2xNCO0ka80aoG1bwN5euZiISMPYPr8/qZZ5oUKFMG7cOPz0008oW7Ysjh07Zqi4SCEVKyYunz6tXBxEGerYMTmwPmmNQz8/Jl9ElG7SnICdOnUKgwYNQt68edG5c2eUKVMG+/btM2RslMEWLUqcaPuLL+T0dkRGLSEB+P57oH59OY3Q5MlKR0RE2YTeXZDjx4/H5s2b8fTpU3z++efo0qULvvjiC9ja2qZXjAZlbE2YhhIXBySZ2hNv3gBOToqFQ5T+nj8HunYFDh2S6z16AAsXAjlyKBoWEaXM2D6/9S5Dcfz4cYwZMwYdOnSAS9IS6ZSlJU2+tmxh8kVG7tAhoEsXIDgYsLWVVzlyJg8iykB6J2CnTp1KjzhIQSpV4nLevED79srFQpTudu4E2rWTg+7LlJHfOEqWVDoqIspmdErA9uzZg6ZNm8LCwgJ79uz54L6tWrUySGCUcXLlSlzmXI9k9D7/HChRAvDxYYVhIlKMTmPATE1N8fz5c7i5ucHUNPVx+yYmJkhISDBogIZmbH3In+rdO+0hLyw7QUbp3Dl5laP6/1dYGODoqGxMRKQXY/v81ukqSJVKBTc3N81yaj+ZPfmi5Lp1S1xWXwFJZDTi44Hx44EqVeScjmpMvohIYXqXoVi7di1iYmKSbY+NjcXatWsNEhRljCdPgB075HKNGkDOnMrGQ2RQjx4BdesCP/0k1zlbBxFlInqXoTAzM8OzZ880LWJqr169gpubW6ZvBTO2Jsy0OndONgqo3b0LFC2qXDxEBrVvn7yq8fVrOX/jihXAl18qHRURfQJj+/zWuwVMCAGTFOZEe/z4MRzZrJ9lJE2+xoxh8kVGIjYWGD0aaNFCJl+VKskCq0y+iCiT0bkMRcWKFWFiYgITExM0aNAA5uaJd01ISEBgYCCaNGmSLkGSYTVtmrjcrh0wc6ZysRAZVEAA8Msvcnn4cGDGDMDKStmYiIhSoHMC1rp1awDA5cuX0bhxY9jZ2Wlus7S0hKenJ9q1a2fwAMmwYmOBAwcS1zlsj4xK+fKymr2bG/Df/ywiosxI5wRsypQpAABPT0/4+vrC2to63YKi9LNqVeLyy5eyCDhRlhUTA0yYIC/nrVBBbuvXT9GQiIh0ofcg/KzO2Abx6SPpfI9mZvIKfaIs6949wNdXVg8uXhy4fh2wsFA6KiJKJ8b2+a1TC1jOnDlx584duLi4wNnZOcVB+GqvX782WHBkOCqV9nyPw4crFwvRJ9u6FejTBwgPl/VT5s5l8kVEWYpOCdi8efNgb2+vWf5QAkaZU+XK2utz5igTB9EniY4GRo2Sk2cDQM2awKZNgIeHsnEREemJXZDZwM6dQNu2ievZ64yT0Xj5EmjUCLh8Wa6PHw989x1grvNQViLKwozt81vvOmAXL17EtWvXNOu7d+9G69atMWHCBMTGxho0ODKMpMlXUJBiYRB9mpw5ARcXwNVVXso7bRqTLyLKsvROwPr37487d+4AAO7fvw9fX1/Y2tpi69at+Prrrw0eIH2aK1cSlxctAgoWVC4WIr29ewdERcllMzNgwwbZAta4saJhERF9Kr0TsDt37qDCf5d7b926FXXq1MHGjRuxevVqbN++3dDx0Sfq2TNxeeBA5eIg0ltAAFC1KjBiROI2NzcgXz7FQiIiMpQ0TUWkUqkAAH/99ReaNWsGAPDw8EBISIhho6NP8r//yVlYAKBzZ4DXTlCWsWaNnEbo+nVg9245/ouIyIjonYBVqlQJP/zwA9atW4djx46hefPmAIDAwEDkzp3b4AFS2qhUwIABievq2VmIMrXISKBHD/nz7h3QoIHscnR1VTgwIiLD0jsBmz9/Pi5evIghQ4Zg4sSJKPrfLM7btm1DjRo1DB4gpU2LFonLp08DuXIpFwuRTq5fl/VS1qwBTE2B778H/vgDyJNH6ciIiAzOYGUooqOjYWZmBotMXgzR2C5jTcnbt8B/Zdtgbi4r4BNlarGxQJEiwOPHcozXxo1AnTpKR0VEmYixfX6n+RruCxcuICAgAABQqlQpfPbZZwYLitLu9Wvt1q4nT5SLhUhnlpbA0qXyUt01a9jlSERGT+8E7MWLF/D19cWxY8fg5OQEAAgNDUW9evWwefNmuPIfp6KSJl/du8uLxogypStXgBcvgM8/l+vNmwPNmvFqESLKFvQeAzZ06FC8ffsWN27cwOvXr/H69Wtcv34d4eHhGDZsWHrESDp6/DhxuW9f2ZBAlOkIIVu7qlaVk2k/fJh4G5MvIsom9G4BO3DgAP766y+ULFlSs61UqVJYtGgRGjVqZNDgSD9XryYuL1umXBxEqQoLA/r1A7Zskeuffw7kyKFsTERECtC7BUylUqU40N7CwkJTH4yU8V9FEDg6KhsHUYouXAA++0wmX+bmckb4PXt4iS4RZUt6J2D169fH8OHD8fTpU822J0+eYOTIkWjQoIFBg6O06dVL6QiI3rNgAVCjBnD/vpwP6+RJYNQodjkSUbaldwK2cOFChIeHw9PTE0WKFEGRIkVQqFAhhIeHY8GCBekRI+mgfPnE5W++US4OohTduCFLTbRuLadnqFpV6YiIiBSVpjpgQggcOnRIU4aiZMmSaNiwocGDSw/GVkcEAEJDAWfnxHXDVHYj+kRCJLZwRUUBW7cC3bqx1YuI0sTYPr/1GoTv7++PPXv2IDY2Fg0aNMDQoUPTKy7SkUqlnXy9eaNcLEQAZOI1bx5w8CCwdy9gZgbY2Mi6KEREBECPBGzJkiUYPHgwihUrBhsbG+zYsQP37t3DrFmz0jM++oCEBDmWWW3YMOC/0mxEynj1Ss7juHevXN+xA2jfXtGQiIgyI53HgC1cuBBTpkzB7du3cfnyZaxZswaLFy9Oz9joI9q0SVy2tATmz1csFCLg77+BihVl8mVlBSxZAnz5pdJRERFlSjqPAbOxsUFAQAA8PT0ByHIUNjY2CAoKQt68edMzRoMypj7kpENpOO6LFKNSAbNmARMnymbZYsVkqYkKFZSOjIiMiDF9fgN6tIDFxMQgR5KCiaamprC0tERUVFS6BEYfFhSUuLx/v2JhEMm+73HjZPLVubOs98Xki4jog/QahD9p0iTY2tpq1mNjY/Hjjz/CMUnlz7lz5xouOkpVoUKJy02aKBcHEfr1AzZtAmbOlEXoeJUjEdFH6ZyA1a5dG7dv39baVqNGDdy/f1+zbsJ/vBli27bE5UaN+HlHGSwhATh/PrGWV7lysknW3l7RsIiIspI01QHLyoyhDzlXLuD1a7kcGwukMDMUUfoIDga6dgWOHpXV7FlQlYgyiDF8fieldyV8UtbIkYnJ19q1TL4oAx0+LKdc+Osvednt48dKR0RElGUxActChNAuNdGxo2KhUHaSkABMmQI0bChbwMqUkV2Q7dopHRkRUZal1yB8Uo4QsrSS2vXrbP2iDPD0KdCli+xyBIA+fYCffwaSXIxDRET6yxQtYIsWLYKnpyesra1RtWpVnD17Vqf7bd68GSYmJmjdunX6BpgJtG0LxMUlrpcurVwslI3s2CGTLzs7YMMGYPlyJl9ERAageALm7++PUaNGYcqUKbh48SLKly+Pxo0b48WLFx+8X1BQEEaPHg0fH58MilRZu3YlLkdGKhYGZTeDBwOjR8vaXp07Kx0NEZHRSFMCduLECXTt2hXVq1fHkydPAADr1q3DyZMn9T7W3Llz0bdvX/Ts2ROlSpXC0qVLYWtri5UrV6Z6n4SEBHTp0gVTp05F4cKF0/IUspSxYxOXb99mAwSlo8eP5VyOERFy3cREVrkvXlzRsIiIjI3eCdj27dvRuHFj2NjY4NKlS4iJiQEAhIWFYdq0aXodKzY2FhcuXEDDhg0TAzI1RcOGDXH69OlU7/fdd9/Bzc0NvXv31jf8LGn79sRlfg5Sutm3T1awX7MG+OorpaMhIjJqeidgP/zwA5YuXYrly5fDIsko8Jo1a+LixYt6HSskJAQJCQnInTu31vbcuXPj+fPnKd7n5MmTWLFiBZYvX67TY8TExCA8PFzrJysZOBC4d08u6/iUifQTFweMGQO0aAG8egV4e2s3uxIRkcHpnYDdvn0btWvXTrbd0dERoaGhhogpVREREejWrRuWL18OFxcXne4zffp0ODo6an48PDzSNUZDunkTWLo0cf3LL5WLhYzUgwdA7drA7Nlyfdgw4NQpoEgRZeMiIjJyepehyJMnD/799194enpqbT958qTe47FcXFxgZmaG4OBgre3BwcHIkydPsv3v3buHoKAgtGzZUrNNpVIBAMzNzXH79m0Uee+DY/z48Rg1apRmPTw8PMskYUl6ZhEaCiSZcpPo0504AbRqJf+4nJyAVauAbHBFMRFRZqB3C1jfvn0xfPhw/PPPPzAxMcHTp0+xYcMGjB49GgMHDtTrWJaWlvD29sahQ4c021QqFQ4dOoTq1asn29/LywvXrl3D5cuXNT+tWrVCvXr1cPny5RQTKysrKzg4OGj9ZAVv3wLPnsnlpk2ZfFE6KFZMFperWhW4dInJFxFRBtK7BWzcuHFQqVRo0KAB3r17h9q1a8PKygqjR4/G0KFD9Q5g1KhR8PPzQ6VKlVClShXMnz8fkZGR6NmzJwCge/fucHd3x/Tp02FtbY0yZcpo3d/JyQkAkm3P6pJ2PW7cqFwcZGRevZKTiQJAnjyyxlfhwnJqISIiyjB6J2AmJiaYOHEixowZg3///Rdv375FqVKlYGdnl6YAfH198fLlS0yePBnPnz9HhQoVcODAAc3A/IcPH8LUVPFyZRlOfUFprlyyd4jok23bBvTuDSxbBvj6ym1eXsrGRESUTZkIIYTSQWSkrDCbup+fnGgbACZPBqZOVTYeyuKio2VZicWL5XrTprLkhImJsnEREekhK3x+60PvBKxevXow+cA/7sOHD39yUOkps59AIYCkDX4REXIWGKI0uXsX6NABuHxZro8bB3z3HScSJaIsJ7N/futL7y7IChUqaK3HxcXh8uXLuH79Ovz8/AwVV7bl7Z24HBzM5Is+waZNQL9+8ooOFxdg3TqgSROloyIiIqQhAZs3b16K27/99lu8ffv2kwPKznbvlhejqbm5KRcLZXFXrybO3Vi7trySw91d2ZiIiEjDYKPbu3bt+sH5G+njks6+xFyWPkm5cnIS7UmTgEOHmHwREWUyereApeb06dOwtrY21OGypTNn5O9evYAcOZSNhbKgDRsAHx+gQAG5PnMmB9oTEWVSeidgbdu21VoXQuDZs2c4f/48Jk2aZLDAspudO4Fjx+Ry0aLKxkJZTGQkMHSorGRfo4as7WVhweSLiCgT0zsBc3yvJLupqSlKlCiB7777Do0aNTJYYNnNN98kLg8bplwclMXcuCGvcrx5U14+27ix9mW0RESUKemVgCUkJKBnz54oW7YsnJ2d0yumbGf5cvn5CcheJHY/0kcJIVu8hgwBoqKAvHnlQPu6dZWOjIiIdKDXV2UzMzM0atQIoaGh6RRO9hMbKysFqLERkT4qMhLo3l1WtY+Kkq1ely8z+SIiykL07qsoU6YM7t+/nx6xZEs3biQuBwTIck1EH2RqKstMmJkB06cD+/ezZgkRURaj9xiwH374AaNHj8b3338Pb29v5Hivv8wYqtNmJB8f+dvTk9Py0QcIkThNgo0NsGUL8PIlUKuW0pEREVEa6JyAfffdd/jqq6/QrFkzAECrVq20piQSQsDExAQJCQmGj9JI3bwpe5MA4PPPlY2FMrGwMNlPXbZs4tUaJUrIHyIiypJ0ngvSzMwMz549Q0BAwAf3q1OnjkECSy+ZaS6pL74A9uyRywkJvHiNUnDhAuDrC9y7B1hbA/fvywH3RETZTGb6/DYEnVvA1HlaZk+wsoorVxKTry5dmHzRe4QAFi6U1exjY4GCBYHNm5l8EREZCb3GgJmwsKPBJJ3T/JdfFAuDMqPQUHmF444dcr11a2DlSoClX4iIjIZeCVjx4sU/moS9fv36kwLKDpIO3enSBciZU7lYKJOJj5fV7AMCZDX72bNllXt++SEiMip6JWBTp05NVgmf9BMdDdy5k7i+dq1ysVAmZG4ODB8u53H09wcqVVI6IiIiSgd6JWAdO3aEG+sNfRJ//8RllYoNGwTg9Wvg2TOgdGm53q8f0LUrp0QgIjJiOg/95vivTycE0KOHXM6Vi8kXAfj7bzkgsEULOfYLkH8YTL6IiIyazgmYjtUq6AN2705cZtdjNqdSATNmALVrA48eyfFeL14oHRUREWUQnbsgVSpVesaRLXTunLj8Xz1byo5evgT8/IDff5frnToB//sfYG+vbFxERJRh9J6KiNLm1Ck5bzIAzJ+vaCikpOPHZcL19KksrLpggSw5wf5oIqJshQlYBvj3X+0p+4YNUy4WUtjcuTL58vKS8zmWLat0REREpAAmYBmgWLHE5e++Y2NHtrZiBVC4sPxDsLNTOhoiIlIIJ8BJZ+fOJS5Pnw5MmqRcLKSAw4eBr76Sl8AC8vLXuXOZfBERZXNsAUtHcXFAlSqJ6+PGKRcLZbCEBNnK9f33MvmqWhXo0EHpqIiIKJNgApaONm1KXN6+Xbk4KIM9fSrnmDp6VK737i3rfBEREf2HCVg6+vln+dvWFmjbVtlYKIP8+aesYv/ypSym+r//yWSMiIgoCY4BSydv3wIXL8rloUOVjYUyyKxZQJMmMvkqX17+ATD5IiKiFDABSyeDBycut2qlXByUgSpWlL8HDgTOnAGKF1c2HiIiyrTYBZkOnjxJnGrI1RWoXl3ZeCgdvXgBqCeob9gQuHYtcVJtIiKiVLAFLB2MGZO4fOkS634Zpbg4eaKLFwfu3UvczuSLiIh0wAQsHaivfmzUCHB3VzYWSgcPHgA+PsDs2UBYGPDbb0pHREREWQy7IA0sPj5xuXdv5eKgdLJrF9CzJxAaCjg6AitX8hJXIiLSG1vADOzHHxOXW7ZULg4ysNhYYMQIoE0bmXxVqSL7l5l8ERFRGjABM7BlyxKXbWyUi4MMbOHCxMJuo0YBJ04AhQopGxMREWVZ7II0oDdvZBF0AFi1StlYyMCGDAEOHgQGDWLTJhERfTK2gBlQ+/YpL1MWFB0tJ82Oi5PrlpbA778z+SIiIoNgC5iBCAEcOiSXq1SRs9BQFnX3LuDrK8d4vXwJTJ+udERERGRk2AJmIP7+ictLlyoXB32izZuBzz6TyZeLC1C7ttIRERGREWICZiDbtycuq2ekoSwkKgro3x/o1ElO5OnjA1y+DDRtqnRkRERkhJiAGYgQ8vcXXygbB6XBnTtA1aryElYTE+Cbb4DDh1lFl4iI0g3HgBnAb78ltoDVratoKJQWKhVw/76c03HDBjmnIxERUTpiAvaJbt4EWrVKXG/USLlYSA8qFWD6XwOwlxewYwdQtiyQN6+ycRERUbbALshPlLTy/W+/AaVKKRcL6ejGDaBCBeD48cRtjRox+SIiogzDBOwTHTwof9epA7RooWws9BFCACtWAJUrA9euAV99lTh4j4iIKAMxAfsEQsgyUQDQt6+ysdBHREQA3boBffrIKx4bNQL27ZOD7omIiDIYE7BPoJ4aEADq11cuDvqIK1eASpXkAHszM2DaNFnV3s1N6ciIiCib4iD8T7BuXeIyhw9lUgEBssRETIwsK7F5M1CrltJRERFRNscE7BNcvCh/r12rbBz0AV5e8jLVyEhgzRpZ3Z6IiEhhTMDS6Ny5xOVmzZSLg1Jw6RJQqBDg5CTHeK1ZA1hZJZadICIiUhg/kdLon38Sl3PlUi4OSkIIYOFCoFo1OdhefYWjjQ2TLyIiylTYApZGf/0lf3fpomwc9J/QUKB3b1lQFQDi44HoaJl8ERERZTJsFkij3buVjoA0zp6VM6Dv2AFYWADz5wM7dzL5IiKiTIsJWBrcu5e43K6dcnFke0IA8+bJqxqDguS4r1OngOHDWd+LiIgyNSZgaXDgQOJy69aKhUFhYcDcuUBcnMyEL16UVe6JiIgyOY4BSwN1AdZmzdjQoignJ2DTJlloddAgngwiIsoymIClwd278nehQsrGke2oVMDs2UCePED37nJbrVosrEpERFkOEzA9nTyZuDx8uHJxZDsvXwJ+fnIKIVtboF49wMND6aiIiIjShAmYngYNSlwuVky5OLKVEyeAjh2Bp08Ba2t5lWP+/EpHRURElGYchK+nmzflbx8fZePIFlQq4Mcfgbp1ZfJVooSsgNu3L8d7ERFRlsYWMD3ExwMJCXL5m2+UjcXoJSQAzZsDf/wh17t1AxYvBuzslI2LiIjIANgCpoeePROXWe0gnZmZAZUqyfFeq1bJGc+ZfBERkZHIFAnYokWL4OnpCWtra1StWhVnz55Ndd/ly5fDx8cHzs7OcHZ2RsOGDT+4v6HExgLr18tlKyvA2TndHzL7SUiQg+3Vvv0WuHwZ6NFDoYCIiIjSh+IJmL+/P0aNGoUpU6bg4sWLKF++PBo3bowXL16kuP/Ro0fRqVMnHDlyBKdPn4aHhwcaNWqEJ0+epGucFy4kLt+6la4PlT09ewZ8/jnQtCkQEyO3mZvzSgciIjJKJkIIoWQAVatWReXKlbFw4UIAgEqlgoeHB4YOHYpx48Z99P4JCQlwdnbGwoUL0V1dG+oDwsPD4ejoiLCwMDg4OOgc56BBwJIlgKsrkEpuSGn1559A166y9StHDuDwYaBKFaWjIiKiTCStn9+ZlaItYLGxsbhw4QIaNmyo2WZqaoqGDRvi9OnTOh3j3bt3iIuLQ86cOdMrTAghky9AzvlMBhIfD0ycCDRpIpOvcuVkUyOTLyIiMnKKXgUZEhKChIQE5M6dW2t77ty5cUvHfr6xY8ciX758WklcUjExMYhRd2lBZtD6EAIoUCBxXYdGOdLF48dA586yxhcA9O8vJ9a2sVE2LiIiogyg+BiwT/HTTz9h8+bN2LlzJ6ytrVPcZ/r06XB0dNT8eOhZPf3sWZkrqNWr9ykRk0bfvjL5srcHNm8Gli5l8kVERNmGogmYi4sLzMzMEBwcrLU9ODgYefLk+eB9Z8+ejZ9++gl//vknypUrl+p+48ePR1hYmObn0aNHesX4+nXicny8XnelD1m0SGazFy8Cvr5KR0NERJShFE3ALC0t4e3tjUOHDmm2qVQqHDp0CNWrV0/1fjNnzsT333+PAwcOoFKlSh98DCsrKzg4OGj96CM6Wv6uUUOWpqI0evgQ+PXXxPXCheVg+6JFlYuJiIhIIYpXwh81ahT8/PxQqVIlVKlSBfPnz0dkZCR6/lf1tHv37nB3d8f06dMBADNmzMDkyZOxceNGeHp64vnz5wAAOzs72KVDoU71UDQrK4MfOvvYs0fW8goNlQPqGjVSOiIiIiJFKZ6A+fr64uXLl5g8eTKeP3+OChUq4MCBA5qB+Q8fPoSpaWJD3ZIlSxAbG4svv/xS6zhTpkzBt99+a/D4AgPl7/d6SUkXsbHA2LFy8mxATh/Aul5ERETK1wHLaPrWEVHP+Tx4MPBfqTLSRWCgHNt17pxcHzkS+OknwNJS2biIiChLMrY6YIq3gGVmp04lLletqlwcWc6uXbLLMSxMztm0ejXQqpXCQREREWUeTMA+YPHixOWuXZWLI8sJD5fJV/XqssRE0kJqRERExATsQzZulL/btEnsiqRUJCQkXibavTtgbS1fOAsLZeMiIiLKhLJ0Idb0pC4/AcjeNPqAzZuBsmWBkJDEbR06MPkiIiJKBROwVMTGJi5//rlycWRqUVFyCqFOnYCAAGDuXKUjIiIiyhLYBZmK69cTl835KiV365Zs5bp2TfbPTpgApEMZECIiImPE1CIVSRtz2JP2nnXrgIEDgchIwM0NWL+ezYRERER6YAKWgidPgO3b5TKnH3rP//4HDBggl+vVAzZsAPLmVTYmIiKiLIZjwFKQtODq4cPKxZEpdewo52/89lvg4EEmX0RERGnAFrAUnDwpf5cqBdSurWwsihNCZqH168uxXo6OwNWrgI2N0pERERFlWWwBS4E6AWvYUNk4FPf2LeDnJ1+IpUsTtzP5IiIi+iRsAXvPixeJy4MGKReH4q5elVc53r4NmJrKAfdERERkEEzA3hMQkLhcooRycShGCGDZMmD4cCAmBnB3BzZtAnx8lI6MiIjIaDABe09UlPydJ4+ycSgiPBzo1w/w95frTZsCa9cCLi7KxkVERGRkOAbsPVeuyN+FCysbhyKuXwe2bpW1N2bOBPbuZfJFRESUDtgC9p4LF+TvpGPBso0aNWQNjgoVgOrVlY6GiIjIaLEF7D0PHsjf1aopG0eGCA0FunXTHvg2cCCTLyIionTGFrAkhADOnpXLjRsrG0u6O3cO8PUFAgOBmzeB8+dlnS8iIiJKd2wBS2LXrsTlZs0UCyN9CQHMnw/UrCmTL09PWeOLyRcREVGGYQtYEqdOJS7nzKlcHOnm9WugZ09gzx653rYtsGIF4OSkaFhERETZDROw/6hUwJw5crluXUVDSR+BgfKJPXwIWFoCc+fKSrNs+SIiIspwTMD+888/ictffaVcHOnGwwMoUACwsAC2bAE++0zpiIiIiLItJmD/Uc//CAAtWigXh0G9egXY28sWL3NzWePL1hZwcFA6MiIiomyNg/D/Exwsf3t5KRuHwZw4AZQvD4wdm7gtTx4mX0RERJkAE7D/GM34L5UKmDYNqFcPePIEOHCAE2kTERFlMkzAANy6lbhctqxycXyyFy+AJk2AiROBhASga1dZ7ytHDqUjIyIioiQ4BgzAmDGJywMGKBfHJzlyBOjcGXj+HLCxARYtAnr04FWOREREmRATMMg5pwGgZUvANCu2CYaHA+3aAW/eAKVKyascS5dWOioiIiJKRbZPwNSD7wE5DWKW5OAA/O9/wO+/AwsWsMuRiIgok8v2CdiOHYnLn3+uXBx6++sv2VxXv75cb99e/hAREVGmlxU73Azqzz/l76JFZamsTC8+HvjmG6BRI6BTJ+DZM6UjIiIiIj1lhZQjXakn4K5VS9EwdPPkiUy6TpyQ661bcx5HIiKiLChbJ2APHyYut22rXBw6+f13oHt3ICQEsLMDli8HOnZUOioiIiJKg2zdBXnxYuJypp1+SKWS1eybNZPJV8WKMnAmX0RERFlWtk7ALl+Wvxs2zMTlskxNZW0vABg8GPj7b6BYMWVjIiIiok+Srbsgly+Xv9+8UTaOFMXHJ14VsGiRvMIx0zbTERFlnISEBMTFxSkdBqUDCwsLmJmZKR1GhsjWCdjTp/J3tWrKxqElNhYYNw74919g927ZNGdnx+SLiAjA27dv8fjxYwghlA6F0oGJiQny588POzs7pUNJd9k2AUv63u3USbk4tAQGAr6+cv5GADh6VE6qTURESEhIwOPHj2FrawtXV1eYZNqxI5QWQgi8fPkSjx8/RrFixYy+JSzbJmDR0YnL5copF4fGjh1Ar15AWJgsLbF6NZMvIqIk4uLiIISAq6srbGxslA6H0oGrqyuCgoIQFxdn9AlYth2EHxSUuKzo+zgmBhg6VM7lGBYm+0MvXwa++ELBoIiIMi+2fBmv7HRus20Ctnu3/G1qqnAF/C5dgIUL5fKYMcDx40DBggoGREREROkt2yZg6gtoSpVSNg6MHQvkzQvs3QvMnAlYWCgcEBEREaW3bJuALVsmf7dsmcEPHBUFHDuWuF65MnD/PtC8eQYHQkREGen06dMwMzND8xT+3x89ehQmJiYIDQ1Ndpunpyfmz5+vte3IkSNo1qwZcuXKBVtbW5QqVQpfffUVnjx5kk7RA9HR0Rg8eDBy5coFOzs7tGvXDsHBwR+8z9u3bzFkyBDkz58fNjY2KFWqFJYuXZpuMWYl2TYBU4/ty9AGp9u35Rivxo0Tq8ACgLV1BgZBRERKWLFiBYYOHYrjx4/jqboOUhr873//Q8OGDZEnTx5s374dN2/exNKlSxEWFoY5c+YYMGJtI0eOxG+//YatW7fi2LFjePr0Kdp+ZB6/UaNG4cCBA1i/fj0CAgIwYsQIDBkyBHv27Em3OLOKbHsVpDrxyrCGpw0bgP79gchIwNUVSOFbDhERGae3b9/C398f58+fx/Pnz7F69WpMmDBB7+M8fvwYw4YNw7BhwzBv3jzNdk9PT9SuXTvFFjRDCAsLw4oVK7Bx40bUr18fALBq1SqULFkSZ86cQbVUCmr+/fff8PPzQ926dQEA/fr1w//+9z+cPXsWrVq1SpdYs4ps2wKmHgOW7rXe3r0D+vQBunaVyVfdurL1678/RiIiShsh5L9VJX70rQO7ZcsWeHl5oUSJEujatStWrlyZpmKyW7duRWxsLL7++usUb3dyckr1vk2bNoWdnV2qP6VLl071vhcuXEBcXBwaNmyo2ebl5YUCBQrg9OnTqd6vRo0a2LNnD548eQIhBI4cOYI7d+6gUaNGH3+yRi7btoDFx8vf6doFefMm0KEDcOOGrGg/eTIwaVJi/ycREaXZu3cZ8CU6FW/fAjly6L7/ihUr0LVrVwBAkyZNEBYWhmPHjmlahnR19+5dODg4IG/evHrdDwB+/fVXREVFpXq7xQc+EJ8/fw5LS8tkCV7u3LnxXD1fcQoWLFiAfv36IX/+/DA3N4epqSmWL1+O2rVr6x2/scm2CVhEhPydrgnY7t0y+cqTR3ZB/tdsS0RE2cft27dx9uxZ7Ny5EwBgbm4OX19frFixQu8ETAiR5lpZ7u7uabrfp1iwYAHOnDmDPXv2oGDBgjh+/DgGDx6MfPnyabWmZUfZNgFT+0Br7af7+mvZVj10KJA7dzo+EBFR9mNrK1uilHpsXa1YsQLx8fHIly+fZpsQAlZWVli4cCEcHR3h4OAAQI61er+VKTQ0FI6OjgCA4sWLIywsDM+ePdO7Faxp06Y4ceJEqrcXLFgQN27cSPG2PHnyIDY2FqGhoVrxBQcHI0+ePCneJyoqChMmTMDOnTs1V36WK1cOly9fxuzZs5mAKR2A0gyagF27Bnz3HbB2rSyvb2YG/PCDAR+AiIjUTEz06wZUQnx8PNauXYs5c+YkG/fUunVrbNq0CQMGDECxYsVgamqKCxcuoGCSYtz3799HWFgYihcvDgD48ssvMW7cOMycOVNrEL7a+wlSUp/SBent7Q0LCwscOnQI7dq1AyBb9h4+fIjq1auneJ+4uDjExcXB1FR7uLmZmRlUKlWqj5VdZOsEzNRQlyAIAfz6KzBsmJxksnBhYMYMAx2ciIiyqr179+LNmzfo3bu3phVLrV27dlixYgUGDBgAe3t79OnTB1999RXMzc1RtmxZPHr0CGPHjkW1atVQo0YNAICHhwfmzZuHIUOGIDw8HN27d4enpyceP36MtWvXws7OLtVSFJ/SBeno6IjevXtj1KhRyJkzJxwcHDB06FBUr15d6wpILy8vTJ8+HW3atIGDgwPq1KmDMWPGwMbGBgULFsSxY8ewdu1azJ07N82xGA2RzYSFhQkAAggTX35pkAMK0bGjEDINE6JJEyFevDDAgYmIKKmoqChx8+ZNERUVpXQoOmvRooVo1qxZirf9888/AoC4cuWKEEI+vylTpggvLy9hY2MjChUqJPr16ydevnyZ7L4HDx4UjRs3Fs7OzsLa2lp4eXmJ0aNHi6dPn6bbc4mKihKDBg0Szs7OwtbWVrRp00Y8e/ZMax8AYtWqVZr1Z8+eiR49eoh8+fIJa2trUaJECTFnzhyhUqlSfYzUzrH68zssLMygz0spJkKk4TrYLCw8PPy/byFhmDPHAaNGfcLBLl2SVzn++6/sbpw2DRg92oBNa0REpBYdHY3AwEAUKlQI1ixgbZQ+dI7Vn99hYWGaMXNZWbbugvTx+YQ779wJdOwIxMYCHh7A5s3Af03ERERERB+SrROwT6ofU6mSPEDNmsCqVUCuXAaLi4iIiIxbtk7ALC31vMOTJ4B6EKOHB3D2rBxwn8aaLERERJQ9ZevBSvb2Ou4oBPDzzzLZSjqBaJEiTL6IiIhIb9k6AXNz02Gn16+BNm2AESPkeC/O4E5ERESfKNsmYDolX2fOABUryimFLC2BBQuA5cvTPTYiIkpdNrt4P1vJTuc22yZgJUt+4EaVCpg9W14m+fCh7Gr8+29gyBB2ORIRKcTMzAwAEBsbq3AklF7U51Z9ro1Zth2E/+rVB248fhwYM0Yud+ggW72MoOYIEVFWZm5uDltbW7x8+RIWFhbJprihrE2lUuHly5ewtbWFubnxpyfG/wxTUb78B26sWxcYPhzw8gL692erFxFRJmBiYoK8efMiMDAQDx48UDocSgempqYoUKAATLLB5262TcDKlk2yolLJqxw7dQLUs7rPn69EWERE9AGWlpYoVqwYuyGNlKWlZbZp2cwUCdiiRYswa9YsPH/+HOXLl8eCBQtQpUqVVPffunUrJk2ahKCgIBQrVgwzZsxAs2bN9HpMTRHWFy+Abt2AP/8E9u4FDh7kVEJERJmYqakppyKiLE/xTMPf3x+jRo3ClClTcPHiRZQvXx6NGzfGixcvUtz/77//RqdOndC7d29cunQJrVu3RuvWrXH9+nW9HtfcHMDRo0CFCjL5srEBunRhdyMRERGlO8Un465atSoqV66MhQsXApCD8Dw8PDB06FCMGzcu2f6+vr6IjIzE3r17NduqVauGChUqYOnSpR99PPVknqdajUeNvTNk92PJksCWLUCZMoZ7YkRERGQwxjYZt6ItYLGxsbhw4QIaNmyo2WZqaoqGDRvi9OnTKd7n9OnTWvsDQOPGjVPdPzVl9kyXyVfPnsC5c0y+iIiIKMMoOgYsJCQECQkJyJ07t9b23Llz49atWyne5/nz5ynu//z58xT3j4mJQUxMjGY9LCwMAPDawhpY+DPQsSOQkACEh3/KUyEiIqJ0FP7f57SxFGvNFIPw09P06dMxderUZNsLxUXLEhP9+ysQFREREaXFq1ev4OjoqHQYn0zRBMzFxQVmZmYIDg7W2h4cHIw86nIQ78mTJ49e+48fPx6jRo3SrIeGhqJgwYJ4+PChUZzArCw8PBweHh549OiRUfTnZ3U8H5kHz0XmwXOReYSFhaFAgQLImTOn0qEYhKIJmKWlJby9vXHo0CG0bt0agByEf+jQIQwZMiTF+1SvXh2HDh3CiBEjNNsOHjyI6tWrp7i/lZUVrKyskm13dHTkmymTcHBw4LnIRHg+Mg+ei8yD5yLzMJY6YYp3QY4aNQp+fn6oVKkSqlSpgvnz5yMyMhI9e/YEAHTv3h3u7u6YPn06AGD48OGoU6cO5syZg+bNm2Pz5s04f/48li1bpuTTICIiItKZ4gmYr68vXr58icmTJ+P58+eoUKECDhw4oBlo//DhQ61st0aNGti4cSO++eYbTJgwAcWKFcOuXbtQhlcxEhERURaheAIGAEOGDEm1y/Ho0aPJtrVv3x7t27dP02NZWVlhypQpKXZLUsbiuchceD4yD56LzIPnIvMwtnOheCFWIiIiouzGOEayEREREWUhTMCIiIiIMhgTMCIiIqIMZpQJ2KJFi+Dp6Qlra2tUrVoVZ8+e/eD+W7duhZeXF6ytrVG2bFns378/gyI1fvqci+XLl8PHxwfOzs5wdnZGw4YNP3ruSD/6vjfUNm/eDBMTE029Pvp0+p6L0NBQDB48GHnz5oWVlRWKFy/O/1UGou+5mD9/PkqUKAEbGxt4eHhg5MiRiI6OzqBojdfx48fRsmVL5MuXDyYmJti1a9dH73P06FF89tlnsLKyQtGiRbF69ep0j9NghJHZvHmzsLS0FCtXrhQ3btwQffv2FU5OTiI4ODjF/U+dOiXMzMzEzJkzxc2bN8U333wjLCwsxLVr1zI4cuOj77no3LmzWLRokbh06ZIICAgQPXr0EI6OjuLx48cZHLlx0vd8qAUGBgp3d3fh4+Mjvvjii4wJ1sjpey5iYmJEpUqVRLNmzcTJkydFYGCgOHr0qLh8+XIGR2589D0XGzZsEFZWVmLDhg0iMDBQ/PHHHyJv3rxi5MiRGRy58dm/f7+YOHGi2LFjhwAgdu7c+cH979+/L2xtbcWoUaPEzZs3xYIFC4SZmZk4cOBAxgT8iYwuAatSpYoYPHiwZj0hIUHky5dPTJ8+PcX9O3ToIJo3b661rWrVqqJ///7pGmd2oO+5eF98fLywt7cXa9asSa8Qs5W0nI/4+HhRo0YN8euvvwo/Pz8mYAai77lYsmSJKFy4sIiNjc2oELMNfc/F4MGDRf369bW2jRo1StSsWTNd48xudEnAvv76a1G6dGmtbb6+vqJx48bpGJnhGFUXZGxsLC5cuICGDRtqtpmamqJhw4Y4ffp0ivc5ffq01v4A0Lhx41T3J92k5Vy87927d4iLizOaeb+UlNbz8d1338HNzQ29e/fOiDCzhbSciz179qB69eoYPHgwcufOjTJlymDatGlISEjIqLCNUlrORY0aNXDhwgVNN+X9+/exf/9+NGvWLENipkRZ/fM7UxRiNZSQkBAkJCRoquir5c6dG7du3UrxPs+fP09x/+fPn6dbnNlBWs7F+8aOHYt8+fIle4OR/tJyPk6ePIkVK1bg8uXLGRBh9pGWc3H//n0cPnwYXbp0wf79+/Hvv/9i0KBBiIuLw5QpUzIibKOUlnPRuXNnhISEoFatWhBCID4+HgMGDMCECRMyImRKIrXP7/DwcERFRcHGxkahyHRjVC1gZDx++uknbN68GTt37oS1tbXS4WQ7ERER6NatG5YvXw4XFxelw8n2VCoV3NzcsGzZMnh7e8PX1xcTJ07E0qVLlQ4t2zl69CimTZuGxYsX4+LFi9ixYwf27duH77//XunQKIsxqhYwFxcXmJmZITg4WGt7cHAw8uTJk+J98uTJo9f+pJu0nAu12bNn46effsJff/2FcuXKpWeY2Ya+5+PevXsICgpCy5YtNdtUKhUAwNzcHLdv30aRIkXSN2gjlZb3Rt68eWFhYQEzMzPNtpIlS+L58+eIjY2FpaVlusZsrNJyLiZNmoRu3bqhT58+AICyZcsiMjIS/fr1w8SJE7XmLqb0ldrnt4ODQ6Zv/QKMrAXM0tIS3t7eOHTokGabSqXCoUOHUL169RTvU716da39AeDgwYOp7k+6Scu5AICZM2fi+++/x4EDB1CpUqWMCDVb0Pd8eHl54dq1a7h8+bLmp1WrVqhXrx4uX74MDw+PjAzfqKTlvVGzZk38+++/miQYAO7cuYO8efMy+foEaTkX7969S5ZkqRNjwZn9MlSW//xW+ioAQ9u8ebOwsrISq1evFjdv3hT9+vUTTk5O4vnz50IIIbp16ybGjRun2f/UqVPC3NxczJ49WwQEBIgpU6awDIWB6HsufvrpJ2FpaSm2bdsmnj17pvmJiIhQ6ikYFX3Px/t4FaTh6HsuHj58KOzt7cWQIUPE7du3xd69e4Wbm5v44YcflHoKRkPfczFlyhRhb28vNm3aJO7fvy/+/PNPUaRIEdGhQwelnoLRiIiIEJcuXRKXLl0SAMTcuXPFpUuXxIMHD4QQQowbN0506/b/du4+psqyjwP49xz0vHQ4B0bm4MjxBQ3WXErHpIk18i2OyyLf0GKPIKQNQlxNizUTqKG1gobOSmqCEpOXVuHGgMWCDXAlasAmCEKQNVmucDCKI3DO7/mjcc8jL0X5HHzw+9nuP+7r7f5d1z3nb9d9cf6jtB/5GYr9+/dLS0uLHDt2jD9DMdWOHj0qc+fOFY1GIyEhIfLtt98qdWFhYRIdHe3SvqioSAIDA0Wj0cjixYultLTUzRFPX5N5F/PmzRMAo66UlBT3Bz5NTfbfxq2YgN1Zk30XZ8+elccee0y0Wq0EBARIenq6DA8Puznq6Wky72JoaEhSU1Nl4cKFotPpxGKxSEJCgty4ccP9gU8zVVVVY/4fMLL+0dHREhYWNqpPcHCwaDQaCQgIkJycHLfH/U+pRLhnSkRERORO0+oMGBEREdH/AyZgRERERG7GBIyIiIjIzZiAEREREbkZEzAiIiIiN2MCRkRERORmTMCIiIiI3IwJGBEREZGbMQEjIhe5ubnw9vae6jD+MZVKha+++mrCNjExMXjuuefcEg8R0ViYgBFNQzExMVCpVKOu9vb2qQ4Nubm5SjxqtRr+/v7YuXMnrl+/fkfG7+7uxvr16wEAXV1dUKlUaGhocGmTlZWF3NzcO/K88aSmpirz9PDwgMViwe7du9HT0zOpcZgsEk1PM6Y6ACL637DZbMjJyXEpe+CBB6YoGlcmkwmtra1wOp1obGzEzp07ce3aNVRUVPzrsX19ff+yjZeX179+zt+xePFiVFZWwuFwoKWlBbGxsejt7UVhYaFbnk9Edy/ugBFNU1qtFr6+vi6Xh4cHMjMz8fDDD8NgMMBisSAhIQH9/f3jjtPY2IhVq1bBaDTCZDJh2bJlOH/+vFJfW1uLJ554Anq9HhaLBUlJSfj9998njE2lUsHX1xdmsxnr169HUlISKisrMTAwAKfTibfeegv+/v7QarUIDg5GeXm50ndwcBCJiYnw8/ODTqfDvHnzcPjwYZexRz5BLliwAADwyCOPQKVS4cknnwTguquUnZ0Ns9kMp9PpEmNERARiY2OV+5KSElitVuh0OgQEBCAtLQ3Dw8MTznPGjBnw9fXFnDlzsHbtWmzduhVff/21Uu9wOBAXF4cFCxZAr9cjKCgIWVlZSn1qaipOnjyJkpISZTeturoaAPDTTz8hMjIS3t7e8PHxQUREBLq6uiaMh4juHkzAiO4xarUaR44cwaVLl3Dy5El88803eO2118ZtHxUVBX9/f9TX1+PChQtITk7GzJkzAQAdHR2w2WzYvHkzmpqaUFhYiNraWiQmJk4qJr1eD6fTieHhYWRlZSEjIwPvv/8+mpqaEB4ejmeffRZXrlwBABw5cgRnzpxBUVERWltbkZ+fj/nz54857rlz5wAAlZWV6O7uxhdffDGqzdatW/Hbb7+hqqpKKevp6UF5eTmioqIAADU1NdixYwf27t2L5uZmHD9+HLm5uUhPT//bc+zq6kJFRQU0Go1S5nQ64e/vj+LiYjQ3N+PgwYN44403UFRUBADYt28fIiMjYbPZ0N3dje7uboSGhmJoaAjh4eEwGo2oqalBXV0dPD09YbPZMDg4+LdjIqIpJEQ07URHR4uHh4cYDAbl2rJly5hti4uL5f7771fuc3JyxMvLS7k3Go2Sm5s7Zt+4uDjZvXu3S1lNTY2o1WoZGBgYs8/t47e1tUlgYKA8+uijIiJiNpslPT3dpc/y5cslISFBRET27Nkjq1evFqfTOeb4AOTLL78UEZHOzk4BIN9//71Lm+joaImIiFDuIyIiJDY2Vrk/fvy4mM1mcTgcIiKyZs0aOXTokMsYeXl54ufnN2YMIiIpKSmiVqvFYDCITqcTAAJAMjMzx+0jIvLyyy/L5s2bx4115NlBQUEua3Dz5k3R6/VSUVEx4fhEdHfgGTCiaWrVqlX46KOPlHuDwQDgz92gw4cP4/Lly+jr68Pw8DDsdjv++OMP3HfffaPGefXVV/Hiiy8iLy9P+Yy2cOFCAH9+nmxqakJ+fr7SXkTgdDrR2dmJhx56aMzYent74enpCafTCbvdjscffxyffvop+vr6cO3aNaxcudKl/cqVK9HY2Ajgz8+H69atQ1BQEGw2GzZs2ICnnnrqX61VVFQUdu3ahQ8//BBarRb5+fnYvn071Gq1Ms+6ujqXHS+HwzHhugFAUFAQzpw5A7vdjs8++wwNDQ3Ys2ePS5tjx47hxIkTuHr1KgYGBjA4OIjg4OAJ421sbER7ezuMRqNLud1uR0dHxz9YASJyNyZgRNOUwWDAokWLXMq6urqwYcMGxMfHIz09HT4+PqitrUVcXBwGBwfHTCRSU1PxwgsvoLS0FGVlZUhJSUFBQQE2btyI/v5+vPTSS0hKShrVb+7cuePGZjQacfHiRajVavj5+UGv1wMA+vr6/nJeVqsVnZ2dKCsrQ2VlJSIjI7F27Vp8/vnnf9l3PM888wxEBKWlpVi+fDlqamrwwQcfKPX9/f1IS0vDpk2bRvXV6XTjjqvRaJR38M477+Dpp59GWloa3n77bQBAQUEB9u3bh4yMDKxYsQJGoxHvvfcevvvuuwnj7e/vx7Jly1wS3xF3yx9aENHEmIAR3UMuXLgAp9OJjIwMZXdn5LzRRAIDAxEYGIhXXnkFzz//PHJycrBx40ZYrVY0NzePSvT+ilqtHrOPyWSC2WxGXV0dwsLClPK6ujqEhIS4tNu2bRu2bduGLVu2wGazoaenBz4+Pi7jjZy3cjgcE8aj0+mwadMm5Ofno729HUFBQbBarUq91WpFa2vrpOd5uwMHDmD16tWIj49X5hkaGoqEhASlze07WBqNZlT8VqsVhYWFmD17Nkwm07+KiYimBg/hE91DFi1ahKGhIRw9ehQ//PAD8vLy8PHHH4/bfmBgAImJiaiursaPP/6Iuro61NfXK58WX3/9dZw9exaJiYloaGjAlStXUFJSMulD+Lfav38/3n33XRQWFqK1tRXJycloaGjA3r17AQCZmZk4ffo0Ll++jLa2NhQXF8PX13fMH4+dPXs29Ho9ysvL8csvv6C3t3fc50ZFRaG0tBQnTpxQDt+POHjwIE6dOoW0tDRcunQJLS0tKCgowIEDByY1txUrVmDJkiU4dOgQAODBBx/E+fPnUVFRgba2Nrz55puor6936TN//nw0NTWhtbUVv/76K4aGhhAVFYVZs2YhIiICNTU16OzsRHV1NZKSkvDzzz9PKiYimiJTfQiNiO68sQ5uj8jMzBQ/Pz/R6/USHh4up06dEgBy48YNEXE9JH/z5k3Zvn27WCwW0Wg0YjabJTEx0eWA/blz52TdunXi6ekpBoNBlixZMuoQ/a1uP4R/O4fDIampqTJnzhyZOXOmLF26VMrKypT67OxsCQ4OFoPBICaTSdasWSMXL15U6nHLIXwRkU8++UQsFouo1WoJCwsbd30cDof4+fkJAOno6BgVV3l5uYSGhoperxeTySQhISGSnZ097jxSUlJk6dKlo8pPnz4tWq1Wrl69Kna7XWJiYsTLy0u8vb0lPj5ekpOTXfpdv35dWV8AUlVVJSIi3d3dsmPHDpk1a5ZotVoJCAiQXbt2SW9v77gxEdHdQyUiMrUpIBEREdG9hZ8giYiIiNyMCRgRERGRmzEBIyIiInIzJmBEREREbsYEjIiIiMjNmIARERERuRkTMCIiIiI3YwJGRERE5GZMwIiIiIjcjAkYERERkZsxASMiIiJyMyZgRERERG72X18aPkRyQUeDAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 78.29260683059692\n",
+      "lead_lag: False inv_rest: True thres_distance: 8000 auc: 0.7972313600000001\n",
+      "Threshold distance:  16000\n",
+      "lead_lag:  False\n",
+      "inv_reset:  True\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 13.91839075088501\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmUAAAHcCAYAAACXot0HAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACboElEQVR4nOzdd1gUVxcG8BeQKgoqoogoir0b7L1jjy1gx96j0diNPWrU2GKJsZcYu8beu8bYjb2LHRQVUKTu3u+P+7GwUtzFhVnY9/c8PDszOzN7tjFn79w510wIIUBEREREijJXOgAiIiIiYlJGREREZBSYlBEREREZASZlREREREaASRkRERGREWBSRkRERGQEmJQRERERGQEmZURERERGgEkZERERkRFgUkb0Fdzd3dGlSxelwzA5tWrVQq1atZQO44smTJgAMzMzBAYGKh2K0TEzM8OECRMMsi8/Pz+YmZlh1apVBtkfkVKYlJHRWrVqFczMzDR/GTJkgKurK7p06YIXL14oHZ5RCw0NxeTJk1GqVCnY2dnBwcEB1atXx5o1a5BWRla7desWJkyYAD8/P6VDiUelUmHlypWoVasWsmbNCmtra7i7u6Nr1664ePGi0uEZxF9//YW5c+cqHYYWY4yJyJAyKB0A0ZdMmjQJ+fLlQ3h4OP7991+sWrUKp0+fxo0bN2BjY6NobHfv3oW5uXH9tgkICEDdunVx+/ZttG3bFgMGDEB4eDi2bt0KX19f7N27F+vWrYOFhYXSoSbp1q1bmDhxImrVqgV3d3et+w4ePKhMUADCwsLQqlUr7N+/HzVq1MDo0aORNWtW+Pn5YdOmTVi9ejWePn2K3LlzKxajIfz111+4ceMGfvjhhxTZf1hYGDJk0O8QlFhMefPmRVhYGCwtLQ0YIVHqY1JGRq9Ro0YoV64cAKBHjx5wcnLC9OnTsXPnTnh7eysam7W1dao/Znh4OKysrBJNBn19fXH79m1s374dzZs31ywfOHAghg0bhl9//RVly5bFiBEjUitkALL1LmPGjAbZl5WVlUH2kxzDhg3D/v37MWfOnHjJwfjx4zFnzpxUjUcIgfDwcNja2qbq4yaHWq1GZGQkbGxsDPqDyszMTPEfaEQGIYiM1MqVKwUAceHCBa3lu3fvFgDE1KlTtZbfvn1btG7dWmTJkkVYW1sLT09PsWPHjnj7ff/+vfjhhx9E3rx5hZWVlXB1dRWdOnUSb9680awTHh4uxo0bJzw8PISVlZXInTu3GDZsmAgPD9faV968eYWvr68QQogLFy4IAGLVqlXxHnP//v0CgNi1a5dm2fPnz0XXrl2Fs7OzsLKyEsWKFRPLly/X2u7YsWMCgFi/fr0YM2aMyJUrlzAzMxPv379P8DU7e/asACC6deuW4P1RUVGiYMGCIkuWLOLTp09CCCEeP34sAIiZM2eK2bNnizx58ggbGxtRo0YNcf369Xj70OV1jnnvjh8/Lvr27SuyZ88uHB0dhRBC+Pn5ib59+4pChQoJGxsbkTVrVtGmTRvx+PHjeNt//nfs2DEhhBA1a9YUNWvWjPc6bdy4Ufz888/C1dVVWFtbizp16oj79+/Hew4LFiwQ+fLlEzY2NqJ8+fLi5MmT8faZkGfPnokMGTKI+vXrJ7lejPHjxwsA4v79+8LX11c4ODiIzJkziy5duojQ0FCtdVesWCFq164tsmfPLqysrETRokXFokWL4u0zb968okmTJmL//v3C09NTWFtbizlz5ui1DyGE2Lt3r6hRo4awt7cXmTJlEuXKlRPr1q0TQsjX9/PXPm/evJptdf1+ABD9+/cXf/75pyhWrJjIkCGD2L59u+a+8ePHa9YNCQkRgwYN0nwvs2fPLurVqycuXbr0xZhiPsMrV67Uevzbt2+L7777Tjg5OQkbGxtRqFAhMXr06KTeMiJFsaWM0pyYPkZZsmTRLLt58yaqVq0KV1dXjBw5EhkzZsSmTZvQokULbN26FS1btgQAfPz4EdWrV8ft27fRrVs3fPPNNwgMDMTOnTvx/PlzODk5Qa1Wo3nz5jh9+jR69eqFokWL4vr165gzZw7u3buHv//+O8G4ypUrh/z582PTpk3w9fXVum/jxo3IkiULvLy8AMhTjJUqVYKZmRkGDBiA7NmzY9++fejevTtCQkLitcBMnjwZVlZWGDp0KCIiIhJtKdq1axcAoHPnzgnenyFDBrRv3x4TJ07EmTNnUK9ePc19a9aswYcPH9C/f3+Eh4dj3rx5qFOnDq5fv44cOXLo9TrH6NevH7Jnz45x48YhNDQUAHDhwgX8888/aNu2LXLnzg0/Pz/8/vvvqFWrFm7dugU7OzvUqFEDAwcOxG+//YbRo0ejaNGiAKC5Tcwvv/wCc3NzDB06FMHBwZgxYwY6dOiAc+fOadb5/fffMWDAAFSvXh2DBw+Gn58fWrRogSxZsnzxlOO+ffsQHR2NTp06Jbne57y9vZEvXz5MmzYNly9fxrJly+Ds7Izp06drxVW8eHE0b94cGTJkwK5du9CvXz+o1Wr0799fa393795Fu3bt0Lt3b/Ts2ROFCxfWax+rVq1Ct27dULx4cYwaNQqOjo64cuUK9u/fj/bt22PMmDEIDg7G8+fPNS1/9vb2AKD39+Po0aPYtGkTBgwYACcnp3inomP06dMHW7ZswYABA1CsWDG8ffsWp0+fxu3bt/HNN98kGVNCrl27hurVq8PS0hK9evWCu7s7Hj58iF27dmHKlCm6vXFEqU3prJAoMTGtJYcPHxZv3rwRz549E1u2bBHZs2cX1tbW4tmzZ5p169atK0qWLKn1S12tVosqVaqIggULapaNGzdOABDbtm2L93hqtVoIIcTatWuFubm5OHXqlNb9ixcvFgDEmTNnNMvitpQJIcSoUaOEpaWlePfunWZZRESEcHR01Gq96t69u3BxcRGBgYFaj9G2bVvh4OCgacWKaQHKnz+/ZllSWrRoIQAk2pImhBDbtm0TAMRvv/0mhIhtZbC1tRXPnz/XrHfu3DkBQAwePFizTNfXOea9q1atmoiOjtZ6/ISeR0wL35o1azTLNm/erNU6FldiLWVFixYVERERmuXz5s0TADQtfhERESJbtmyifPnyIioqSrPeqlWrBIAvtpQNHjxYABBXrlxJcr0YMS1ln7dctmzZUmTLlk1rWUKvi5eXl8ifP7/Wsrx58woAYv/+/fHW12UfQUFBIlOmTKJixYoiLCxMa92Y74AQQjRp0kSrdSyGPt8PAMLc3FzcvHkz3n7wWUuZg4OD6N+/f7z14kospoRaymrUqCEyZcoknjx5kuhzJDI2xtVDmSgB9erVQ/bs2eHm5oY2bdogY8aM2Llzp6ZV4927dzh69Ci8vb3x4cMHBAYGIjAwEG/fvoWXlxfu37+vuVpz69atKF26dLwWHUD2SwGAzZs3o2jRoihSpIhmX4GBgahTpw4A4NixY4nG6uPjg6ioKGzbtk2z7ODBgwgKCoKPjw8A2Qdo69ataNasGYQQWo/h5eWF4OBgXL58WWu/vr6+OvUZ+vDhAwAgU6ZMia4Tc19ISIjW8hYtWsDV1VUzX6FCBVSsWBF79+4FoN/rHKNnz57xLiiI+zyioqLw9u1bFChQAI6OjvGet766du2q1YpYvXp1AMCjR48AABcvXsTbt2/Rs2dPrU7mHTp00Gp5TUzMa5bU65uQPn36aM1Xr14db9++1XoP4r4uwcHBCAwMRM2aNfHo0SMEBwdrbZ8vXz5Nq2tcuuzj0KFD+PDhA0aOHBmvH1bMdyAp+n4/atasiWLFin1xv46Ojjh37hxevnz5xXW/5M2bNzh58iS6deuGPHnyaN2ny3MkUgpPX5LRW7hwIQoVKoTg4GCsWLECJ0+e1Opg/+DBAwghMHbsWIwdOzbBfbx+/Rqurq54+PAhWrduneTj3b9/H7dv30b27NkT3VdiSpcujSJFimDjxo3o3r07AHnq0snJSXPQevPmDYKCgrBkyRIsWbJEp8fIly9fkjHHiEkWPnz4AEdHxwTXSSxxK1iwYLx1CxUqhE2bNgHQ73VOKu6wsDBMmzYNK1euxIsXL7RKdHyefOjr8wNwTKL1/v17AMCTJ08AAAUKFNBaL0OGDImeVosrc+bMAGJfQ0PEFbPPM2fOYPz48Th79iw+ffqktX5wcDAcHBw084l9HnTZx8OHDwEAJUqU0Os5xND3+6HrZ3fGjBnw9fWFm5sbPD090bhxY3Tu3Bn58+fXO8aYJDy5z5FIKUzKyOhVqFBBc/VlixYtUK1aNbRv3x53796Fvb091Go1AGDo0KEJth4A8Q/CSVGr1ShZsiRmz56d4P1ubm5Jbu/j44MpU6YgMDAQmTJlws6dO9GuXTtNy0xMvB07dozX9yxGqVKltOZ1vbKuaNGi+Pvvv3Ht2jXUqFEjwXWuXbsGADq1XsSVnNc5obi///57rFy5Ej/88AMqV64MBwcHmJmZoW3btprHSK7EynwIA9VmK1KkCADg+vXrKFOmjM7bfSmuhw8fom7duihSpAhmz54NNzc3WFlZYe/evZgzZ0681yWh11XffSSXvt8PXT+73t7eqF69OrZv346DBw9i5syZmD59OrZt24ZGjRp9ddxEaQGTMkpTLCwsMG3aNNSuXRsLFizAyJEjNb+kLS0ttTquJ8TDwwM3btz44jr//fcf6tatm6xTHT4+Ppg4cSK2bt2KHDlyICQkBG3bttXcnz17dmTKlAkqleqL8eqradOmmDZtGtasWZNgUqZSqfDXX38hS5YsqFq1qtZ99+/fj7f+vXv3NC1I+rzOSdmyZQt8fX0xa9YszbLw8HAEBQVprZcSp5ny5s0LQLb61a5dW7M8Ojoafn5+8ZLhzzVq1AgWFhb4888/9e7sn5Rdu3YhIiICO3fu1GpVS+pUeXL34eHhAQC4ceNGkj9WEnv9v/b7kRQXFxf069cP/fr1w+vXr/HNN99gypQpmqRM18eL+ax+6btOZGzYp4zSnFq1aqFChQqYO3cuwsPD4ezsjFq1auGPP/7Aq1ev4q3/5s0bzXTr1q3x33//Yfv27fHWi2m18Pb2xosXL7B06dJ464SFhWmuIkxM0aJFUbJkSWzcuBEbN26Ei4uLVoJkYWGB1q1bY+vWrQkeNOLGq68qVaqgXr16WLlyJXbv3h3v/jFjxuDevXsYPnx4vBaMv//+W6tP2Pnz53Hu3DnNAVGf1zkpFhYW8Vqu5s+fD5VKpbUspqbZ58na1yhXrhyyZcuGpUuXIjo6WrN83bp1mlOcSXFzc0PPnj1x8OBBzJ8/P979arUas2bNwvPnz/WKK6Yl7fNTuStXrjT4Pho0aIBMmTJh2rRpCA8P17ov7rYZM2ZM8HTy134/EqJSqeI9lrOzM3LlyoWIiIgvxvS57Nmzo0aNGlixYgWePn2qdZ+hWk2JUgJbyihNGjZsGL777jusWrUKffr0wcKFC1GtWjWULFkSPXv2RP78+REQEICzZ8/i+fPn+O+//zTbbdmyBd999x26desGT09PvHv3Djt37sTixYtRunRpdOrUCZs2bUKfPn1w7NgxVK1aFSqVCnfu3MGmTZtw4MABzenUxPj4+GDcuHGwsbFB9+7d4xV6/eWXX3Ds2DFUrFgRPXv2RLFixfDu3TtcvnwZhw8fxrt375L92qxZswZ169bFt99+i/bt26N69eqIiIjAtm3bcPz4cfj4+GDYsGHxtitQoACqVauGvn37IiIiAnPnzkW2bNkwfPhwzTq6vs5Jadq0KdauXQsHBwcUK1YMZ8+exeHDh5EtWzat9cqUKQMLCwtMnz4dwcHBsLa2Rp06deDs7Jzs18bKygoTJkzA999/jzp16sDb2xt+fn5YtWoVPDw8dGqJmTVrFh4+fIiBAwdi27ZtaNq0KbJkyYKnT59i8+bNuHPnjlbLqC4aNGgAKysrNGvWDL1798bHjx+xdOlSODs7J5gAf80+MmfOjDlz5qBHjx4oX7482rdvjyxZsuC///7Dp0+fsHr1agCAp6cnNm7ciCFDhqB8+fKwt7dHs2bNDPL9+NyHDx+QO3dutGnTBqVLl4a9vT0OHz6MCxcuaLWoJhZTQn777TdUq1YN33zzDXr16oV8+fLBz88Pe/bswdWrV/WKjyjVKHLNJ5EOEiseK4QQKpVKeHh4CA8PD03JhYcPH4rOnTuLnDlzCktLS+Hq6iqaNm0qtmzZorXt27dvxYABA4Srq6um8KWvr69WeYrIyEgxffp0Ubx4cWFtbS2yZMkiPD09xcSJE0VwcLBmvc9LYsS4f/++psDl6dOnE3x+AQEBon///sLNzU1YWlqKnDlzirp164olS5Zo1okp9bB582a9XrsPHz6ICRMmiOLFiwtbW1uRKVMmUbVqVbFq1ap4JQHiFo+dNWuWcHNzE9bW1qJ69eriv//+i7dvXV7npN679+/fi65duwonJydhb28vvLy8xJ07dxJ8LZcuXSry588vLCwsdCoe+/nrlFhR0d9++03kzZtXWFtbiwoVKogzZ84IT09P0bBhQx1eXSGio6PFsmXLRPXq1YWDg4OwtLQUefPmFV27dtUqlxFTEiNuYeK4r0/cgrk7d+4UpUqVEjY2NsLd3V1Mnz5drFixIt56McVjE6LrPmLWrVKlirC1tRWZM2cWFSpUEOvXr9fc//HjR9G+fXvh6OgYr3isrt8P/L94bEIQpyRGRESEGDZsmChdurTIlCmTyJgxoyhdunS8wreJxZTY+3zjxg3RsmVL4ejoKGxsbEThwoXF2LFjE4yHyBiYCcG2XCJT5ufnh3z58mHmzJkYOnSo0uEoQq1WI3v27GjVqlWCp+WIiFID+5QRkUkJDw+P169ozZo1ePfuHWrVqqVMUEREYJ8yIjIx//77LwYPHozvvvsO2bJlw+XLl7F8+XKUKFEC3333ndLhEZEJY1JGRCbF3d0dbm5u+O233/Du3TtkzZoVnTt3xi+//JLomKJERKmBfcqIiIiIjAD7lBEREREZASZlREREREYg1ZKy48ePw8zMDFu2bEmth0xSSsQzYcIEnYcBMTMzw4QJE5L1ODGxHz9+XLOsS5cuOg2oTOnXqlWrUuXz9zX8/PxgZmaGVatWpeg2aUWtWrVS/YrPtPA5IeOgVqtRokQJTJky5Yvr6nP8Swm1atUymgHo27ZtC29v72Rt+1VJmZmZmU5/cZMHMh63bt3ChAkT4Ofnp3QoKer8+fPo168fPD09YWlp+cV/HAEBAejduzdcXV1hY2MDd3d3dO/ePd56L168gLe3NxwdHZE5c2Z8++23ePToUYL7XL58OYoWLQobGxsULFgwwSF69N0nKcfd3T3R/3efD11E6cvUqVPx999/J3v7tHTcXL9+PZ49e4YBAwYoHQoA4OXLl5gwYYIiIzK8fPkSHTt2ROHChZEpUyY4OjqiQoUKWL16dbwSOyNGjMDWrVt1GuHkc1919eXatWu15tesWYNDhw7FW160aFHcvn37ax6KvmDp0qVQq9V6bXPr1i1MnDgRtWrVStetbHv37sWyZctQqlQp5M+fH/fu3Ut03WfPnmkG6u7Tpw9cXV3x8uVLnD9/Xmu9jx8/onbt2ggODsbo0aNhaWmJOXPmoGbNmrh69arWkEF//PEH+vTpg9atW2PIkCE4deoUBg4ciE+fPmHEiBHJ2icpr0yZMvjxxx/jLU9PV3CGhYUhQwZepB/X1KlT0aZNG7Ro0SJZ2+tz3FTazJkz0bZtWzg4OCgdCgCZGE2cOBHu7u4oU6ZMqj52YGAgnj9/jjZt2iBPnjyIiorCoUOH0KVLF9y9exdTp07VrFu2bFmUK1cOs2bNwpo1a/R6nK/6tnXs2FFr/t9//8WhQ4fiLQfw1UnZp0+fYGdn91X7SM8sLS2VDsFo9e3bFyNGjICtrS0GDBiQZFLWu3dvZMiQARcuXEgyCVq0aBHu37+P8+fPo3z58gCARo0aoUSJEpg1a5bmCxoWFoYxY8agSZMmmlPlPXv2hFqtxuTJk9GrVy9kyZJFr32ScXB1dU3wf116YmNjo3QICUrLxwN9jptxpfZzvnLlCv777z+tsUdNWalSpeK1Xg4YMADNmjXDb7/9hsmTJ8PCwkJzn7e3N8aPH49FixbB3t5e58dJ9Y7+arUaU6ZMQe7cuWFjY4O6deviwYMHWuvEnBu+dOkSatSoATs7O4wePRoAEBERgfHjx6NAgQKwtraGm5sbhg8fjoiICK19HDp0CNWqVYOjoyPs7e1RuHBhzT70jQcANm/eDE9PT9ja2sLJyQkdO3bEixcvvvh8IyIiMHjwYGTPnh2ZMmVC8+bN8fz5c51fr+fPn6NFixbImDEjnJ2dMXjw4HjPFUi4T9mGDRvg6emJTJkyIXPmzChZsiTmzZsHQPYriSmUWbt27XhN5jt27ECTJk2QK1cuWFtbw8PDA5MnT4ZKpdJ6jJj36tatW6hduzbs7Ozg6uqKGTNmxIsxPDwcEyZMQKFChWBjYwMXFxe0atUKDx8+1KyjVqsxd+5cFC9eHDY2NsiRIwd69+6N9+/fa+0rODgYd+7cQXBw8Bdfwxw5csDW1vaL6925cwf79u3DsGHDkC1bNoSHhyMqKirBdbds2YLy5ctrkicAKFKkCOrWrYtNmzZplh07dgxv375Fv379tLbv378/QkNDsWfPHr33mVJevHiBbt26IUeOHLC2tkbx4sWxYsUKrXUiIyMxbtw4eHp6wsHBARkzZkT16tVx7NixePsLCgpCly5d4ODgAEdHR/j6+iIoKMggsV67dg1dunRB/vz5YWNjg5w5c6Jbt254+/ZtvHWPHz+OcuXKwcbGBh4eHvjjjz8S7P8SGBiIO3fu4NOnT18d38qVKzWDp1tbW6NYsWL4/fffddp2/vz5KF68OOzs7JAlSxaUK1cOf/31l9Y6urxXhvB5n7KY1+3Bgwfo0qULHB0d4eDggK5du2q9biVKlEDt2rXj7U+tVsPV1RVt2rTROYbUOh7osi8zMzOEhoZi9erVmv+ZXbp00dx/584dPH36VOfnlpznnFg/P3d3d61YAPkd/OGHH+Dm5gZra2sUKFAA06dP1+msyt9//w0rKyvUqFEj3n2nT59G+fLltb5Tifnzzz81x86sWbOibdu2ePbsWaLPt0qVKrC1tUW+fPmwePFizTrHjx/X/G/s2rWr5vX/vK+pLsciQ3J3d8enT58QGRmptbx+/foIDQ3FoUOH9NpfqrdL//LLLzA3N8fQoUMRHByMGTNmoEOHDjh37pzWem/fvkWjRo3Qtm1bdOzYETly5IBarUbz5s1x+vRp9OrVC0WLFsX169cxZ84c3Lt3T3Oe/+bNm2jatClKlSqFSZMmwdraGg8ePMCZM2eSFc+qVavQtWtXlC9fHtOmTUNAQADmzZuHM2fO4MqVK3B0dEz0+fbo0QN//vkn2rdvjypVquDo0aNo0qSJTq9VWFgY6tati6dPn2LgwIHIlSsX1q5di6NHj35x20OHDqFdu3aoW7cupk+fDkC2Vp45cwaDBg1CjRo1MHDgQPz2228YPXq0pqk85nbVqlWwt7fHkCFDYG9vj6NHj2LcuHEICQnBzJkztR7r/fv3aNiwIVq1agVvb29s2bIFI0aMQMmSJdGoUSMAgEqlQtOmTXHkyBG0bdsWgwYNwocPH3Do0CHcuHEDHh4eAGRLVczrPXDgQDx+/BgLFizAlStXcObMGU2L4Pbt29G1a1esXLky3j+i5Dp8+DAAmcTVrVsXR48ehYWFBerXr4/ff/9dk/Sq1Wpcu3YN3bp1i7ePChUq4ODBg/jw4QMyZcqEK1euAADKlSuntZ6npyfMzc1x5coVdOzYUa99poSAgABUqlQJZmZmGDBgALJnz459+/ahe/fuCAkJwQ8//AAACAkJwbJly9CuXTv07NkTHz58wPLly+Hl5YXz589rTikIIfDtt9/i9OnT6NOnD4oWLYrt27fD19fXIPEeOnQIjx49QteuXZEzZ07cvHkTS5Yswc2bN/Hvv/9qEq4rV66gYcOGcHFxwcSJE6FSqTBp0iRkz5493j4XLFiAiRMn4tixYzp1vo+KikJgYKDWMjs7O9jZ2eH3339H8eLF0bx5c2TIkAG7du1Cv379oFar0b9//0T3uXTpUgwcOBBt2rTBoEGDEB4ejmvXruHcuXNo3749AN3fq5Tk7e2NfPnyYdq0abh8+TKWLVsGZ2dnzf8aHx8fTJgwAf7+/siZM6dmu9OnT+Ply5do27atXo+X0scDXfe1du1a9OjRAxUqVECvXr0AQPO/C5D/P2vWrGmQ/mAJPWd9fPr0CTVr1sSLFy/Qu3dv5MmTB//88w9GjRqFV69eYe7cuUlu/88//6BEiRLxzsJcv34dDRo0QPbs2TFhwgRER0dj/PjxCcY3ZcoUjB07Ft7e3ujRowfevHmD+fPno0aNGvGOne/fv0fjxo3h7e2Ndu3aYdOmTejbty+srKzQrVs3FC1aFJMmTcK4cePQq1cvVK9eHQBQpUoVrX186VgEIN73NjGZMmWCtbW11rKwsDCEhobi48ePOHHiBFauXInKlSvH++FfrFgx2Nra4syZM2jZsqVOjwcAMOTo5v379xeJ7fLYsWMCgChatKiIiIjQLJ83b54AIK5fv65ZVrNmTQFALF68WGsfa9euFebm5uLUqVNayxcvXiwAiDNnzgghhJgzZ44AIN68eZNorLrGExkZKZydnUWJEiVEWFiYZr3du3cLAGLcuHGaZePHj9d6/levXhUARL9+/bQeu3379gKAGD9+fKLxCSHE3LlzBQCxadMmzbLQ0FBRoEABAUAcO3ZMs9zX11fkzZtXMz9o0CCROXNmER0dnej+N2/eHG8/MT59+hRvWe/evYWdnZ0IDw/XLIt5r9asWaNZFhERIXLmzClat26tWbZixQoBQMyePTveftVqtRBCiFOnTgkAYt26dVr379+/P97ylStXCgBi5cqViT6/hCT1GR04cKAAILJlyyYaNmwoNm7cKGbOnCns7e2Fh4eHCA0NFUII8ebNGwFATJo0Kd4+Fi5cKACIO3fuaB7PwsIiwcfLnj27aNu2rd77TEzMa6KLzz9/3bt3Fy4uLiIwMFBrvbZt2woHBwfN5yE6Olrr+yKEEO/fvxc5cuQQ3bp10yz7+++/BQAxY8YMzbLo6GhRvXp1vd+3x48fx9smoc/n+vXrBQBx8uRJzbJmzZoJOzs78eLFC82y+/fviwwZMsR7rWK+vwl9Hz6XN29eASDeX8xrmlB8Xl5eIn/+/FrLatasKWrWrKmZ//bbb0Xx4sWTfGxd36vEfM3nJOY1ivteCyFEy5YtRbZs2TTzd+/eFQDE/Pnztdbr16+fsLe3/2KMcaXG8UDXfQkhRMaMGYWvr2+C+wGg9X7qIqH/SYk955jHSOjYkTdvXq24Jk+eLDJmzCju3buntd7IkSOFhYWFePr0aZJx5c6dW+t/eIwWLVoIGxsb8eTJE82yW7duCQsLC63n4efnJywsLMSUKVO0tr9+/brIkCGD1vKY5ztr1izNsoiICFGmTBnh7OwsIiMjhRBCXLhwIdH/H7oei4QQCX53E/pL6HGmTZumtU7dunUTfS0LFSokGjVqlOB9iUn105ddu3bV6ggbk+1+foWZtbU1unbtqrVs8+bNKFq0KIoUKYLAwEDNX506dQBAcwolJvvesWPHF5tpvxTPxYsX8fr1a/Tr10+rf0WTJk1QpEgRrdNPn9u7dy8AYODAgVrLdf0lu3fvXri4uGg19dvZ2Wl+oSXF0dExWU2nMeJm/R8+fEBgYCCqV6+OT58+4c6dO1rr2tvba/WHsLKyQoUKFbTe061bt8LJyQnff/99vMeKadXYvHkzHBwcUL9+fa3319PTE/b29lqnyLp06QIhhMFayQDZ0R4AcubMiT179sDb2xtDhw7F0qVL8fDhQ80ppLCwMACI9wsKiO2DE7NOWFhYoh2/bWxstNbTdZ+GJoTA1q1b0axZMwghtF57Ly8vBAcH4/LlywAACwsLzfNRq9V49+4doqOjUa5cOc06gPzsZsiQAX379tUss7CwSPD9T464n8/w8HAEBgaiUqVKAKCJQ6VS4fDhw2jRogVy5cqlWb9AgQJav5pjTJgwAUIInUtUVKxYEYcOHdL669y5c7z4goODERgYiJo1a+LRo0dJnnJ3dHTE8+fPceHChQTv1+e9Skl9+vTRmq9evTrevn2LkJAQAEChQoVQpkwZbNy4UbOOSqXCli1b0KxZM526E8SV0scDXff1JUIIg101mdBz1sfmzZtRvXp1ZMmSRes51atXDyqVCidPnkxy+7dv32r6u8ZQqVQ4cOAAWrRogTx58miWFy1aFF5eXlrrbtu2DWq1Gt7e3lqPnzNnThQsWDDea5ohQwb07t1bM29lZYXevXvj9evXuHTpkk7PWZdjEYB439vE/j5/TgDQrl07HDp0CH/99Zem9Tqx/80xr70+Uv30Zdw3EoDmTf+8z5Crq2u8g9n9+/dx+/btBE89AMDr168ByKbzZcuWoUePHhg5ciTq1q2LVq1aoU2bNjA3185DvxTPkydPAACFCxeO93hFihTB6dOnE32uT548gbm5uVbzdmL7Smz7AgUKxOv7osv2/fr1w6ZNm9CoUSO4urqiQYMG8Pb2RsOGDXV67Js3b+Knn37C0aNHNf9oY3x+UMmdO3e8GLNkyYJr165p5h8+fIjChQsneSXX/fv3ERwcDGdn5wTvj3l/U0rMgcLb21vrc/Ldd9+hU6dO+Oeff9CjRw/Negn17YsphxCzjq2tbby+BnHXjbuervs0tDdv3iAoKAhLlizBkiVLElwn7mu/evVqzJo1C3fu3NHqc5cvXz7N9JMnT+Di4hKvg6uun/0veffuHSZOnIgNGzbE+1zEfD5fv36NsLAwFChQIN72CS3Tl5OTE+rVq5fgfWfOnMH48eNx9uzZeH3UgoODE72abcSIETh8+DAqVKiAAgUKoEGDBmjfvr3mimB936uUktT/zcyZMwOQ/4dHjx6NFy9ewNXVFcePH8fr16/h4+Oj9+Ol9PFA132lpoSesz7u37+Pa9eufdVzEp+Venjz5g3CwsJQsGDBeOsWLlxY0xAR8/hCiATXBeJfnJYrVy5kzJhRa1mhQoUAyFqFMT+6kqLLsQhAot9bXeTNmxd58+YFIBO0Xr16oV69erh79268/9FCCL1rt6V6Uhb36oS4Pn/zEzoAqdVqlCxZErNnz05wH25ubpptT548iWPHjmHPnj3Yv38/Nm7ciDp16uDgwYNaMegaT1rj7OyMq1ev4sCBA9i3bx/27duHlStXonPnzli9enWS2wYFBaFmzZrInDkzJk2aBA8PD9jY2ODy5csYMWJEvF+bhnoN1Wo1nJ2dsW7dugTvT+yfi6HEtKZ83jfCwsIC2bJl0yTqWbNmhbW1NV69ehVvHzHLYvbl4uIClUqF169fayWbkZGRePv2rWY9ffZpaDHvZ8eOHRPt81WqVCkAstNuly5d0KJFCwwbNgzOzs6wsLDAtGnTtC7YSGne3t74559/MGzYMJQpUwb29vZQq9Vo2LCh3qVhDO3hw4eoW7cuihQpgtmzZ8PNzQ1WVlbYu3cv5syZk2R8RYsWxd27d7F7927s378fW7duxaJFizBu3DhMnDhRr/cqJenynffx8cGoUaOwefNm/PDDD9i0aRMcHBx0/mEYV0ofD3TdV2rS90fY5xdhqdVq1K9fH8OHD09w/ZiEJzFx/+clh1qthpmZGfbt25fg50WfKxJ1peuxyN/fX6f9OTg4fPF9aNOmDZYuXYqTJ0/Ga1l7//59oklpYtJUARoPDw/8999/qFu37hezT3Nzc9StWxd169bF7NmzMXXqVIwZMwbHjh3TK0uOyYjv3r2racqOcffuXc39iW2rVqs1rURxt9P1sW/cuBEv29Z1eysrKzRr1gzNmjWDWq1Gv3798Mcff2Ds2LEJtsDFOH78ON6+fYtt27ZpXXnz+PFjnR43IR4eHjh37hyioqISLd/h4eGBw4cPo2rVqinWKpQUT09PAIh3VW1kZCQCAwM1SaG5uTlKliyJixcvxtvHuXPnkD9/fk2H/JiO7xcvXkTjxo016128eBFqtVpzvz77NLSYK4NVKtUXvxtbtmxB/vz5sW3bNq3Pz/jx47XWy5s3L44cOYKPHz9q/fPV9bOblPfv3+PIkSOYOHEixo0bp1l+//59rfWcnZ1hY2OT4NXUCS0zlF27diEiIgI7d+7UalHS9RRYxowZ4ePjAx8fH0RGRqJVq1aYMmUKRo0apdd7pbR8+fKhQoUK2LhxIwYMGIBt27ahRYsWCZ6iTw5DHg/02ZeSVesB2fLz+VXMkZGR8X7QeXh44OPHj8n+nBQpUiTe//zs2bPD1tY23ncNiP/d9vDwgBAC+fLl+2ICCMgaZKGhoVqtZTHli2IusjLUa+/i4qLTerpcSBZz6vLzM0jR0dF49uwZmjdvrldsaWrsS29vb7x48QJLly6Nd1/MFRGAPLXxuZiDX0Knh5JSrlw5ODs7Y/HixVrb7tu3D7dv307ySsqYfiu//fab1vIvXfUSo3Hjxnj58qXWUFCfPn1K9LRFXJ+XBjA3N9f8go55HjEf/s+/4DG/NuL+uoiMjMSiRYt0ijshrVu3RmBgIBYsWBDvvpjH8fb2hkqlwuTJk+OtEx0drRWnPiUxdFWrVi1NS13cquyrVq2CSqVC/fr1NcvatGmDCxcuaCVRd+/exdGjRzWlRgCgTp06yJo1a7xyCL///jvs7Oy0Pj+67tPQLCws0Lp1a2zduhU3btyId/+bN2+01gW0Pxvnzp3D2bNntbZp3LgxoqOjtZ63SqVKdCQDfeP9PAYg/vfKwsIC9erVw99//42XL19qlj948AD79u2Lt19DlcRIKL7g4GCsXLnyi9t+/r21srJCsWLFIIRAVFSUXu+VMfDx8cG///6LFStWIDAwMFmnLhNjyOOBrvsC5P/NxEq7GKokRlI8PDzi9QdbsmRJvJYyb29vnD17FgcOHIi3j6CgIERHRyf5OJUrV8aNGze0jnsWFhbw8vLC33//rfU8b9++He9xWrVqBQsLC0ycODHed1UIEe+zHh0drVVaIzIyEn/88QeyZ8+u+cGc2DFLX8npU5bYd2v58uUwMzPDN998o7X81q1bCA8P17o6VBdpqqWsU6dO2LRpE/r06YNjx46hatWqUKlUuHPnDjZt2oQDBw6gXLlymDRpEk6ePIkmTZogb968eP36NRYtWoTcuXOjWrVqej2mpaUlpk+fjq5du6JmzZpo166dpiSGu7s7Bg8enOi2ZcqUQbt27bBo0SIEBwejSpUqOHLkiM6/0nv27IkFCxagc+fOuHTpElxcXLB27VqdCgj26NED7969Q506dZA7d248efIE8+fPR5kyZTRlL8qUKQMLCwtMnz4dwcHBsLa2Rp06dVClShVkyZIFvr6+GDhwIMzMzLB27dqvOqXbuXNnrFmzBkOGDMH58+dRvXp1hIaG4vDhw+jXrx++/fZb1KxZE71798a0adNw9epVNGjQAJaWlrh//z42b96MefPmaS560KckxpMnTzTVsmMSnp9//hmAbNHp1KkTANmxdubMmfD19UWNGjXQqVMnPH36FPPmzUP16tXRqlUrzT779euHpUuXokmTJhg6dCgsLS0xe/Zs5MiRQ6vKu62tLSZPnoz+/fvju+++g5eXF06dOoU///wTU6ZMQdasWfXeZ0r45ZdfcOzYMVSsWBE9e/ZEsWLF8O7dO1y+fBmHDx/WHNiaNm2Kbdu2oWXLlmjSpAkeP36MxYsXo1ixYpoLJQCgWbNmqFq1KkaOHAk/Pz8UK1YM27ZtM0gSnTlzZtSoUQMzZsxAVFQUXF1dcfDgwQRbcidMmICDBw+iatWq6Nu3L1QqFRYsWIASJUrEG6pF35IYiWnQoIGmlbp37974+PEjli5dCmdn5wRPT3++bc6cOVG1alXkyJEDt2/fxoIFC9CkSRNNS6mu75UxiLlYZujQociaNatBW/cMeTzQdV+AbFE/fPgwZs+ejVy5ciFfvnyoWLEiAMOWxEhMjx49NCOE1K9fH//99x8OHDgAJycnrfWGDRuGnTt3omnTpujSpQs8PT0RGhqK69evY8uWLfDz84u3TVzffvstJk+ejBMnTqBBgwaa5RMnTsT+/ftRvXp19OvXD9HR0ZraenH7bnl4eODnn3/GqFGj4OfnhxYtWiBTpkx4/Pgxtm/fjl69emHo0KGa9XPlyoXp06fDz88PhQoVwsaNG3H16lUsWbJEc3bFw8MDjo6OWLx4MTJlyoSMGTOiYsWKWv1ZdZGcz+GUKVNw5swZNGzYEHny5MG7d++wdetWXLhwAd9//328fqqHDh2CnZ2d1o95neh1reYX6FISY/PmzVrLE7rcvWbNmoleFh4ZGSmmT58uihcvLqytrUWWLFmEp6enmDhxoggODhZCCHHkyBHx7bffily5cgkrKyuRK1cu0a5dO61Lg/WJRwghNm7cKMqWLSusra1F1qxZRYcOHcTz58+11vm8JIYQQoSFhYmBAweKbNmyiYwZM4pmzZqJZ8+e6VQSQwghnjx5Ipo3by7s7OyEk5OTGDRokKZERFIlMbZs2SIaNGggnJ2dhZWVlciTJ4/o3bu3ePXqldb+ly5dKvLnz6+5nDlmn2fOnBGVKlUStra2IleuXGL48OHiwIED8R43sffq83iEkGUCxowZI/LlyycsLS1Fzpw5RZs2bcTDhw+11luyZInw9PQUtra2IlOmTKJkyZJi+PDh4uXLl5p19CmJEfNeJ/SX0OXr69evF6VLlxbW1tYiR44cYsCAASIkJCTees+ePRNt2rQRmTNnFvb29qJp06bi/v37CcawZMkSUbhwYWFlZSU8PDzEnDlzNKVAkrvPz31NqQMhhAgICBD9+/cXbm5umvenbt26YsmSJZp11Gq1mDp1qsibN6+wtrYWZcuWFbt3707w/X779q3o1KmTyJw5s3BwcBCdOnUSV65cMUhJjOfPn4uWLVsKR0dH4eDgIL777jvx8uXLBJ/XkSNHRNmyZTWv/bJly8SPP/4obGxstNbTtyRGkyZNEr1/586dolSpUsLGxka4u7uL6dOna8rCPH78WLPe5yUx/vjjD1GjRg2RLVs2YW1tLTw8PMSwYcM0/9ti6PJeJcYQJTE+Ly8Rs8+4zy1G1apVBQDRo0cPnR7zc6lxPNB1X0IIcefOHVGjRg1ha2srAGiVoUjsf0pSEiuJkdhzVqlUYsSIEcLJyUnY2dkJLy8v8eDBg3glMYQQ4sOHD2LUqFGiQIECwsrKSjg5OYkqVaqIX3/9VVNmIimlSpUS3bt3j7f8xIkTwtPTU1hZWYn8+fOLxYsXJ3j8E0KIrVu3imrVqomMGTOKjBkziiJFioj+/fuLu3fvxnu+Fy9eFJUrVxY2NjYib968YsGCBfH2t2PHDlGsWDFNWZuY/wv6HIuS4+DBg6Jp06YiV65cwtLSUmTKlElUrVpVrFy5MsH/5RUrVhQdO3bU+3HMhEjjPdqJCEBskWN+pb+sRYsWuHnzZoJ9Y9I7fk5IV2vXrkX//v3x9OnTJIukf61atWohMDAwwVPyadHVq1fxzTff4PLly3qP0Zmm+pQREenr8xpC9+/fx969e7/qFCWRKejQoQPy5MmDhQsXKh1KmvLLL7+gTZs2yRo0PU31KSOi9CMyMvKL/Z90uST9S/Lnz68ZJ/PJkyf4/fffYWVllWipAEod7969S7SGHyA7lad0GRxKmrm5ebppvUpNGzZsSPa2TMqISBH//PNPgoNWx2WIsU0bNmyI9evXw9/fH9bW1qhcuTKmTp2qd/0gMqxWrVrhxIkTid6fN29e+Pn5pV5AREZA0T5lJ0+exMyZM3Hp0iW8evUK27dvR4sWLZLc5vjx4xgyZAhu3rwJNzc3/PTTTwYdaoeIUsf79++/OHxK8eLFda4pRGnLpUuXkixOamtrqxnJgMhUKNpSFhoaitKlS6Nbt25a5QYS8/jxYzRp0gR9+vTBunXrcOTIEfTo0QMuLi4JjlFFRMYrS5YsRl8AlVJOTO0pIoplNFdfmpmZfbGlbMSIEdizZ4/WOe62bdsiKCgI+/fvT4UoiYiIiFJGmupTdvbs2Xi/rL28vPDDDz8kuk1ERIRWRWK1Wo13794hW7Zsig+XQURERLoRQuDDhw/IlSuXZjD59CZNJWX+/v7xBovOkSMHQkJCEBYWluBVWtOmTcPEiRNTK0QiIiJKQc+ePUPu3LmVDiNFpKmkLDlGjRqFIUOGaOaDg4ORJ08ePHv2DJkzZ1YwMiIiotSnVgOfPgHR0YBKBURFAadPA3fvApaWQMxJpEOH5Dr+/sCLF4Z5bE9PwMICuHMHKFECqFZNzltaAiEhgJsbkCkTkCGD/HM+uwNWTevDwt4OkZEhqF/fTTPkWHqUppKynDlzIiAgQGtZQEAAMmfOnGgtI2tra1hbW8dbnjlzZiZlRESU5gghE5iXL4HISCAiAvDzA96+Bc6dk+uYmclk68gRoGBB4PFj4PlzIEsWIImLXnWSIYNM1kqXBt69AwoXBgoVAsLCgCpVYhO7PHkAFxfA2hrInh34/3jiugkNBfr3B1avBqJ6AEuXIiQk5rml365HaSopq1y5Mvbu3au17NChQ6hcubJCERERERlecDBw8CCwYwcQGAg4Osok6+hRmfS8eaP7vvz9Y6cTSsjMzWXrGSATuGrVZOIFyNuWLWVrVunSQLZsyX5KurtxA/D2Bm7flsHlySMzUROgaFL28eNHPHjwQDP/+PFjXL16FVmzZkWePHkwatQovHjxAmvWrAEA9OnTBwsWLMDw4cPRrVs3HD16FJs2bcKePXuUegpERETJFhEhk6anT2XSdeeOTMQOHtRteycnwNZW7ic6WrZYWVjIxCp7dpnAhYYCxYvL/MbVVZ4ezJEDsLGR6xpNn3khgBUrgO+/l81uLi7AX38BJjQkmqJJ2cWLF7Uqesf0/fL19cWqVavw6tUrPH36VHN/vnz5sGfPHgwePBjz5s1D7ty5sWzZMtYoIyKiNCEsDLh3D/DyAj7rjZOgMmVk0ta5M+DuHntq8NtvZatVujmT9/Ej0KcPsG6dnG/QAFi7FnB2VjauVGY0dcpSS0hICBwcHBAcHMw+ZUREZBDR0TLhevMGOH9eTr9+DSxaJFuk7t378j7s7IAiRWQ/sfLlgR9+AEqVSvHQjcPz5zIDDQoCfv4ZGD48XhOeKRy/01SfMiIiIiVERAA3bwLXrslO9hERwL//As+eARcuJG+fGTIAS5YAbdvKU5AmLXduYP16+UJUq6Z0NIphUkZERATZ2nXnDrBtm7y1sgJ27ZJXGCZHkyay1StnTuC772R/dWdnOZ9uTjsmV0gI0KuXzEhjRvKpX1/RkIwBkzIiIkr33r2TVzFGRsrWratXgRMnAHt7YOtW2eFdpdJ9fx06yEadZ8+AokVlPlGrljxVaTQd543VpUuAjw/w8CFw7JjsP2Znp3RURoFJGRERpRuPH8taXRs3ysoKkZHyysYvSSgha9VK1t3KmFHelizJFq6vIgSwYAEwdKh8Y/LmBTZsYEIWB5MyIiJKk+7fBzZvlp3r587VbZuYMhEvXwIFCsjWrcqVZetWsWKyr7mVVQoGbaqCgoDu3eW5YUCeslyxQlazJQ0mZUREZPTUanmB3uHDwLx5ssN9UkqWlH23GjcGKlYE8uWT86SAoCCgbFk57IClJfDrr7IWGZsd42FSRkRERicqCmjYUFa2v3Qp6XWzZweaN5fjKvr4AFmzpk6MpCNHR6BRI+DAAXleuVw5pSMyWkzKiIhIcR8+APv2yf5gJ04knojZ2sqhgFQq2eDSsGHqxkk6evtWXs6aI4ecnz1b1hFxcFA2LiPHpIyIiFKNELJC/eHD8pgdGSmvfjx0KOH18+YFFi+WV0dWrco+4WnCP//IUhcFCsg31sJCXpZqY6N0ZEaPSRkRERlUZKQsrPrhA/D333KsxaNHZReiq1e/vH25ckC9eoCvr6xwT2mEWg3MnAmMGSObMq2tgVevZGFY0gmTMiIiShaVSg4ndPWqrHY/e7ZcrsuQQjFatJBXOwYFARMnApUqpUCglPLevJFZ9L59cr5dO+CPP2RGTjpjUkZERDoLDgYGDQJWr/7yui4ugIcHcOsW0LevXFa1qmz9ypcvZeOkVHTqlDxd+fKlPEX5229Ajx68ujIZmJQREZGWoCBZcuLUKeDyZVmE1cbmy2UonJxk2ampU4EKFeSwQpTOqVRAv34yIStSBNi0SdYjoWRhUkZEZOJUKuD4cXk14/79um2TP78szl6jhkzYLCxSNEQyVhYWciDxefOAOXPkuFWUbEzKiIhMTESETL5ixoFOjLW1bO0qVw4oVUr+5coFlCgBZODRw3QdPSqHU+jdW86XKAEsXapsTOkEv1ZERCYgPFw2aHTrlvR6Xl6yj3anThxYmz6jUgGTJgGTJ8sWMk9PFoI1MCZlRETpzNu3wKxZwPbtwJ07Sa9bs6ZM1pyc5Ag4RAl6+RLo0EGe5waALl3kYKFkUEzKiIjSkcOHgfr1k16nWjV5+jJjxtSJidK4Awdk0+mbN7LP2B9/AO3bKx1VusSkjIgojRFCNlzs3SuHJcqcWV4pefGi9np58sjGjZYtAVdXWaKCVQpILxMmyAJyAFC6tLy6slAhRUNKz5iUERGlEU+fyvqcMWeQkrJ2LdCxY4qHROmdo6O87dNHXl3JoZJSFJMyIiIjFRkJzJ8PrFola4UlJHt2oGxZoHJlIDRUDk/UoAFbxOgrhIbGntseNEh+wGrWVDYmE8GkjIjIiLx6BWzbJjvrjx+f8Dq5cslO/OXLM/kiA4qKAkaPBnbulOfCM2WSHzAmZKmGSRkRUSpSq4HXr4HoaODuXSAkRB4D378HduxIfLvp0+Wpyxw5Ui9WMiFPnsihkv79V87//bfs3E+pikkZEVEK++cfOVbkkiW6b+PgADRrJktDLV8O2NqmXHxk4nbskCUugoLkB2/FCqBVK6WjMklMyoiIDOz4cTnqzOnTQGBg0utmzSoH5zYzAwYMkPNNm/K0JKWCyEhg+HD5YQXkgKUbNnC0eAUxKSMiMhAhgDp1Er86snlzoFcvoG5dXsRGRmDEiNiE7Mcf5UjyVlbKxmTimJQRERnApk2Aj4/2shEjZH2wb74BqlRh6xcZmZEjgUOHgGnT5LlyUhyTMiKiZIqIANzcZKHzz717B2TJkvoxESUqPFxettuunZzPkQO4do2DnBoRvhNERHpQq4HixWWrl41N/ISsb1+5DhMyMir378tidu3by8FOYzAhMyp8N4iIdBAdLceLtLAAbt3Svq9kSXnMEwJYtIinKcnIrF8vz6FfvSpHns+aVemIKBFMyoiIEiAEsG8f4OUlkyxLS6BRI+11/vlH1tu8dg0oUECZOIkSFRYmryxp3x74+BGoUUMmZl5eSkdGiWBSRkQUR1QUMHmyPKvTuDFw8GD8daZOlacoK1cGMrBnLhmjO3eAihWBpUvlr4qffgKOHJFXnpDR4r8TIjJZu3bJwqw2NsCpU8DLlwmv16IF0KGDvGUSRmnCw4fA9euAszOwbp0cFJWMHv+9EJFJiI4Gdu+WjQUqFfD771/e5tQpoFq1lI+NyOCaNJGtZE2aAC4uSkdDOmJSRkTpSng4cOAAEBwsW742b5Yjxxw7lvg21aoBLVvK6ZIlgVq1ZB8yojTj5k2gTx/gzz+BvHnlsh49lI2J9MakjIjSBbUaGDYMmD37y+tWry5rZdasKUeWIUqzhABWrpRjdIWFAT/8IGuRUZrEpIyI0qw7d4Bz54BffpHTcVlby4vMVCqgWDFZUT9/fqBUKWViJTK4jx9l69i6dXK+QQPgjz+UjYm+CpMyIkqTOnWSZ2o+V6SIXP7NN6wXRunYf/8B3t7AvXuyeN7kyXJcLxaDTdOYlBFRmvHxIzB6NDB/vvbyli1lX7KlS3nFP5mAU6eA+vXlOF+ursCGDbwiJZ1gUkZERs3fH1iyBBg/PuH7b96UpyeJTEb58rJJ2NUVWL1aVumndIFJGREZrStX5GnIhCxaJMeZJDIJt28DhQrJU5U2NsDhw3K4JJ6uTFf4bhKRUVGpgKFDAU9P7YQsa1bgt99kvTEhmJCRiRACWLAAKFMGmDIldrmTExOydIgtZURkFAICZOf9Q4fi37d2LdCxY+rHRKSooCCge3dg2zY5/99/svYLk7F0i0kZESnm40d5Ff/Zswnff+AAUKcOhzYiE3T+PODjA/j5yUrGM2cCAwfykuJ0juk2ESni/n0gU6b4CVnVqsClS/KsTYMGTMjIxAgBzJkjr6b08wPy5QPOnAEGDWJCZgKYlBFRiouIAMaNk8cUFxd5W6hQ7P1OTvK4o1IBp08n3rmfKN17/FjWfYmKAlq3Bi5flldbkkngb1AiSlG7dgHNm8fO+/tr39+rF4uQE2nkzw8sXCiHTOrXj61jJoZJGREZ3KdPsn/yhg3x7/v+e6BzZ3lWJlu21I+NyKio1cCsWXJA1kqV5LJu3ZSNiRTDpIyIDEatBubOBX78Mf59v/wCDB/OH/5EGm/eAL6+wL59QN68wI0bgL290lGRgpiUEdFXe/YM+O47OTh4XJkyyeNNlSpMxoi0nDwJtGsHvHwpi8GOGQNkzKh0VKQwdvQnomQ7f14mW3nyxE/Ixo0DQkLk1ZRMyIj+T62WRWBr15YJWeHC8svTsye/KMSWMiLS37VrQOnS8Ze3bCkvHCtXLvVjIjJ6Hz8CrVrFVkju1EmOF8ZTlvR/TMqISGdRUfL4ERmpvbxmTVno1dpambiI0oSMGQFbW/m3aBHQpYvSEZGRYVJGRDp58gRwd9de1r07sHgxC7wSJUqlkr9ibG3l6cmVK2VdmGLFlI6MjBD7lBHRF/3wg3ZC5uwMhIcDy5YxISNK1KtXQL16sr+YEHJZ1qxMyChR/HdKRIkKCgKyZNFe5uOTcP0xIorj4EGgY0dZ9iJjRuDRI8DDQ+moyMixpYyI4nn7FmjaNH5C9v49EzKiJEVHy/IWDRvKhKxUKeDiRSZkpBO2lBGRlufPATc37WWenrKskp2dMjERpQnPnwPt2wOnTsn53r3l4OK2tsrGRWkGW8qICE+eAL/9Jvshx03IrK2B//6TP/SZkBElQa0GGjWSCVmmTLJJefFiJmSkF7aUEZm4xOpV1q8P7N8PmPOnG9GXmZvLMcZGjgTWrwcKFFA6IkqD+O+WyEStXh0/IcuaVY5P6e8v+ykzISNKwtOn8osSo25dWZ2fCRklE1vKiExMQACQM2f85Wo1R3kh0tnOnbL4a3Q0cPlybCLGXzL0FfjpITIBBw/KMY/NzOInZPPnMyEj0llkJDB4MPDtt/Jy5CJFWKyPDEbxpGzhwoVwd3eHjY0NKlasiPPnzye5/ty5c1G4cGHY2trCzc0NgwcPRnh4eCpFS5S2CCGTLS8vICJC+76hQ+X9AwYwISPSyePHQLVqsu8YIJOz06fjD3VBlEyKJmUbN27EkCFDMH78eFy+fBmlS5eGl5cXXr9+neD6f/31F0aOHInx48fj9u3bWL58OTZu3IjRo0encuRExq9Fi/hnUpo3B27dki1jM2cqEhZR2rR1K1C2LHDhgizgt2MHMHs2YGWldGSUjiialM2ePRs9e/ZE165dUaxYMSxevBh2dnZYsWJFguv/888/qFq1Ktq3bw93d3c0aNAA7dq1+2LrGpGpePQIGDhQtnzt2KF9nxByWdGibBkj0ts//wDBwUDlysDVq/IXDpGBKZaURUZG4tKlS6hXr15sMObmqFevHs6ePZvgNlWqVMGlS5c0SdijR4+wd+9eNG7cONHHiYiIQEhIiNYfUXq0b58sGj5/vvbyGzdih90jIj3E/eJMmwbMmwecOAHkyaNcTJSuKZaUBQYGQqVSIUeOHFrLc+TIAX9//wS3ad++PSZNmoRq1arB0tISHh4eqFWrVpKnL6dNmwYHBwfNn9vnpcqJ0oFly4C4v03KlgV+/VX2SS5eXLm4iNKsDRvklyoqSs5bWclmaEtLZeOidE3xjv76OH78OKZOnYpFixbh8uXL2LZtG/bs2YPJkycnus2oUaMQHBys+Xv27FkqRkyUcj58AHr2lKcie/aMXb56tbxC/8cfefwg0ltYmBweqV07WT156VKlIyIToth1vE5OTrCwsEBAQIDW8oCAAORMqIgSgLFjx6JTp07o0aMHAKBkyZIIDQ1Fr169MGbMGJgnUB/G2toa1tbWhn8CRApRq+WP+A4d4t+3YgXQuXPqx0SULty9C3h7A9euyV87o0cDvXopHRWZEMVayqysrODp6YkjR45olqnVahw5cgSVK1dOcJtPnz7FS7wsLCwAAIKdZsgE+PkBFhbxE7KFC+Wpyq5dFQmLKO3780/A01MmZM7OwIEDwM8/swYZpSpFP21DhgyBr68vypUrhwoVKmDu3LkIDQ1F1/8fWTp37gxXV1dMmzYNANCsWTPMnj0bZcuWRcWKFfHgwQOMHTsWzZo10yRnROmVWg3ky6e9bPlyoFs3ZeIhSjemTAF++klO164NrFsHuLgoGxOZJEWTMh8fH7x58wbjxo2Dv78/ypQpg/3792s6/z99+lSrZeynn36CmZkZfvrpJ7x48QLZs2dHs2bNMGXKFKWeAlGKE0Je+DVmTOyy8eOBCRMUC4kofWnTBpgxAxgyRCZn/JFPCjETJnbeLyQkBA4ODggODkbmzJmVDocoUWfPyg77AwbEv8+0vrVEBiaEPE1ZunTssrdvgWzZlIuJvsgUjt9p6upLIlPx8CFQpYp2QubuDhw5woSM6Kt8/CivhvnmG1lzLAYTMjICTMqIjExkJFCgQOx8x46yIOyjR0CdOsrFRZTmXbsGlCsnO/UDsrIykRHhZSVERuThQ+2EbPp0YPhw5eIhSheEkPXGBg4EIiIAV1dg/XqgenWlIyPSwqSMyEgIoZ2QOTkxISP6aiEhshjshg1yvlEjYM0a+QUjMjI8fUlkBObNA+KW4HN3B16/ViwcovRjxw6ZkFlYyCssd+9mQkZGiy1lRApSqRKuTfnokSwoTkRfqWNH4MoV4LvvgEQKkxMZC7aUESnk9u34CdnRo/I0JhMyomQKCpKXLb9/L+fNzIDZs5mQUZrAljKiVLZsmTxmRERoL2epC6KvdOEC4OMDPH4MBAbG9iMjSiPYUkaUCiIjgWrV5JB6PXtqJ2Rt2sjjBxElkxDA3LlA1aoyIcuXD/jxR6WjItIbW8qIUtDbt3IovevX4983eTLQpw/7HBN9lXfvgK5dgZ075Xzr1rI52tFR0bCIkoNJGVEKCAsDvL3lhV6f27ULqFkTyJQp9eMiSleuXweaNgWePgWsrGTfsX792CmT0iwmZUQGdvEiUL689rJGjYAtWwA7O2ViIkqXcuWSpy49PIBNm+TQSURpGJMyIgO6elU7ITM3B+7cAQoWVCwkovTlwwfA3l62hmXLBuzbB7i5Ael0gGoyLezoT2Qgr18DZcvGzo8ZI+uQMSEjMpBTp4CiRYFVq2KXFS/OhIzSDSZlRAZSo0bs9MSJsiM/ERmAWg1MnSqvmnnxApg/X/7iIUpnmJQRfaWICKBuXeDuXTlfvz4wbhz7GhMZxOvXQMOGsU3PHTsCJ0/KYZOI0hkmZURfYdMmwMZGVuKPsX27cvEQpSvHjgGlSwOHDgG2tsDy5XIwcXt7pSMjShHs6E+UTN27AytWxM6bmcm6lRkzKhcTUbrx5AnQoAEQHQ0UKyZ/ARUvrnRURCmKLWVEyfDqlXZCtnKl7PaSN69yMRGlK3nzAqNGycKw588zISOTwJYyIj0EBAAHDgC+vrHLAgPllflE9JUOHwbc3YECBeT8xInsnEkmhS1lRDpavRrImVM7IWvZkgkZ0VeLjgZ++kmervTxiR0clgkZmRi2lBHp4PJloEuX2Hl7e1mTbMMGxUIiSh9evADatZM1yABZfVkIZWMiUgiTMqIv+OcfoGrV2Pl9++QV+kT0lfbtAzp3ln0AMmUCliwB2rZVOioixfD0JVEitm0DHB21E7IJE5iQEX21qChgxAigcWOZkJUtC1y6xISMTB5byog+I4Ts2nL4sPby2bOBwYOViYkoXRFC1iADgP79gV9/lQX/iEwckzKiOH7+GRg7VnvZtGnAgAGsV0n01YSQnfetrICNG2VnzdatlY6KyGgwKSP6v7Zt5XEirshIwNJSmXiI0o3ISGDkSNkaNnWqXJYvn/wjIg0mZUQAtmzRTshevgRcXJSLhyjdePxY/uI5f162knXuDBQponRUREaJSRmZvLJlgatXY+dZDJbIQLZtA7p1A4KD5VUzq1YxISNKAq++JJM2d652Qnb+PBMyoq8WEQF8/73sLxYcDFSqJL9o336rdGRERo0tZWSyIiK0r6YMDQXs7JSLhyhdiLl8+eRJOT98uLyChp0zib6ISRmZpOho7fpjly4xISMyCDMzoEcP4OZNYM0aWYuMiHTCpIxMTlQU4OoKvHkj5ytVAr75RtmYiNK0sDDAzw8oWlTOd+oENGkCZM2qaFhEaQ37lJFJiYqSJZJiEjJXV+DIEWVjIkrT7t6Vv2zq1Yv9YgFMyIiSgUkZmZRhw2Kny5cHnj/naUuiZPvzT8DTE7h2Tf7iefxY6YiI0jQmZWQy7t0D5s2LnT93TrlYiNK0T5+A7t3lacrQUKBWLXl1ZYUKSkdGlKYxKSOT4OMDFC4cO3/1quyPTER6unVLJl8rVsgv0fjxcqDYXLmUjowozWNHf0r3SpSQF4LFGDwYKF1auXiI0rTp0+UXKmdOYN06oE4dpSMiSjeYlFG6FREBDB2qnZA9fQq4uSkXE1Ga99tvQIYMcgzLHDmUjoYoXWFSRulSzKgucanVPGVJpLfr12W9sRkz5BfIwQFYvlzpqIjSJSZllO6o1fETsnv3mJAR6UUIYNkyYOBAIDxcdsrs0UPpqIjSNXb0p3Tn9OnY6ebN5bGlYEHl4iFKc0JCgPbtgV69ZELWqBHHrSRKBUzKKN2pWTN2escO5eIgSpOuXJG1xzZsACwsZMf+3buB7NmVjowo3fuqpCw8PNxQcRB9tfv3gUKFYuc7d1YuFqI0ae1aWZ3/wQN5RczJk3JAcXP+fidKDXp/09RqNSZPngxXV1fY29vj0aNHAICxY8diOTt/kgLu3JH9xQoVkolZDH4cifSULx+gUgHNmsliflWqKB0RkUnROyn7+eefsWrVKsyYMQNWVlaa5SVKlMCyZcsMGhzRl2zYEDsGcoxu3YD37+VV+0T0BcHBsdPVqgFnz8rz/hy7kijV6Z2UrVmzBkuWLEGHDh1gYWGhWV66dGncuXPHoMERJSUiAmjXLna+UiXA31+2kH1+9SURfUYIOe6Yu7us0h+jfHleqkykEL2TshcvXqBAgQLxlqvVakRFRRkkKKIv+flnwMYmdn7lSvkDn7UsiXTw7h3QsiXwww9AUBCwapXCARERkIykrFixYjh16lS85Vu2bEHZsmUNEhRRUqZMAcaOjZ3/7jugSxfFwiFKW/79FyhbVp6itLIC5s+XV1gSkeL07nUzbtw4+Pr64sWLF1Cr1di2bRvu3r2LNWvWYPfu3SkRI5HGp0/ATz/Fzp8+DVStqlw8RGmGWg3Mng2MGgVERwMeHsDGjbL8BREZBb1byr799lvs2rULhw8fRsaMGTFu3Djcvn0bu3btQv369VMiRiKNuAOJL1vGhIxIZ3/+CQwbJhMyb2/g0iUmZERGxkwIIZQOIjWFhITAwcEBwcHByJw5s9LhkI6EiF8qybQ+uURfKToaaNJE9iXr3Zud+SnNMYXjt94tZfnz58fbt2/jLQ8KCkL+/PkNEhTR58qU0Z5/906RMIjSDrVaNidHRMj5DBmA/fuBPn2YkBEZKb2TMj8/P6hUqnjLIyIi8OLFC4MERQTI8kk//iiPH9euxS6PjgayZFEuLiKj9/q1HK+yZ09gxIjY5UzGiIyazh39d+7cqZk+cOAAHBwcNPMqlQpHjhyBu7u7QYMj0/X6dcLlLT59ksPxEVEijh+Xg4m/egXY2gKlSikdERHpSOekrEWLFgAAMzMz+Pr6at1naWkJd3d3zJo1y6DBkWm6eFHWr4xr2zbZFYaIEqFSyXoxEyfKU5dFiwKbNwPFiysdGRHpSOekTK1WAwDy5cuHCxcuwMnJKcWCItP19q12Qta3L7BokXLxEKUJ/v5Ahw7A0aNyvmtXWX8sY0Zl4yIivehdp+zx48cpEQcRgoKAuLn+9u3A/xtoiSgpnz7JJmY7O2DxYqBTJ6UjIqJkSNaQzaGhoThx4gSePn2KyMhIrfsGDhxokMDItAih3Xl/8mQmZERJEiK2437+/MCmTUDevECRIsrGRUTJpndSduXKFTRu3BifPn1CaGgosmbNisDAQNjZ2cHZ2ZlJGSXLmTOx099+q121n4g+8+IF0LGjrM7foIFc5uWlbExE9NX0LokxePBgNGvWDO/fv4etrS3+/fdfPHnyBJ6envj1119TIkZK5y5dAqpXj53/+2/FQiEyfvv3y8J9x48D/frJGjFElC7onZRdvXoVP/74I8zNzWFhYYGIiAi4ublhxowZGD16dErESOnYkiVAuXKx8yNHKhcLkVGLipJfkEaNgMBAmZjt3SuLwhJRuqB3UmZpaQnz/4934+zsjKdPnwIAHBwc8OzZM70DWLhwIdzd3WFjY4OKFSvi/PnzSa4fFBSE/v37w8XFBdbW1ihUqBD27t2r9+OS8tq0kaO9xJg0CZg2Tbl4iIzWs2dArVrA9Olyvl8/4OxZoFAhRcMiIsPS+ydW2bJlceHCBRQsWBA1a9bEuHHjEBgYiLVr16JEiRJ67Wvjxo0YMmQIFi9ejIoVK2Lu3Lnw8vLC3bt34ezsHG/9yMhI1K9fH87OztiyZQtcXV3x5MkTODo66vs0SGHz5gFbt8bO37olyyoR0WdevJCtYu/eAZkzA8uXy180RJTu6D0g+cWLF/HhwwfUrl0br1+/RufOnfHPP/+gYMGCWL58Ocp8PkhhEipWrIjy5ctjwYIFAGQtNDc3N3z//fcYmcB5rMWLF2PmzJm4c+cOLC0t9QlbwxQGNDV2ERGAjU3s/PPngKurcvEQGb0uXYCbN4GNG+WVlkQmyBSO33onZYYSGRkJOzs7bNmyRTNaAAD4+voiKCgIO3bsiLdN48aNkTVrVtjZ2WHHjh3Inj072rdvjxEjRsBCx7F3TOFNNWZCAOZxTpq/egXkzKlcPERGyc8PsLePLdwXM76YtbWiYREpyRSO33r3KUvM5cuX0bRpU53XDwwMhEqlQo7PBjjMkSMH/P39E9zm0aNH2LJlC1QqFfbu3YuxY8di1qxZ+PnnnxN9nIiICISEhGj9kXL27ImdbtqUCRlRPNu3y9OVvr5yuCRAFoVlQkaU7umVlB04cABDhw7F6NGj8ejRIwDAnTt30KJFC5QvX14zFFNKUavVcHZ2xpIlS+Dp6QkfHx+MGTMGixcvTnSbadOmwcHBQfPn5uaWojFSwvz9ZZ3LZs3kvI0NsGuXsjERGZWICGDgQKBVKyA4WI45FhysdFRElIp0TsqWL1+ORo0aYdWqVZg+fToqVaqEP//8E5UrV0bOnDlx48YNva6CdHJygoWFBQICArSWBwQEIGcizScuLi4oVKiQ1qnKokWLwt/fP97IAjFGjRqF4OBgzV9yrhClr3P5MuDior3s/90IiQgAHj4EqlaV41UCwNChwKlT2sNcEFG6p3NSNm/ePEyfPh2BgYHYtGkTAgMDsWjRIly/fh2LFy9GUT0vnbOysoKnpyeOHDmiWaZWq3HkyBFUrlw5wW2qVq2KBw8eaLXI3bt3Dy4uLrCyskpwG2tra2TOnFnrj1JPeDjg6Rk737atPCPTvbtyMREZlU2bgLJlZRXlbNmA3buBmTOBZF7MRERpl85J2cOHD/Hdd98BAFq1aoUMGTJg5syZyJ07d7IffMiQIVi6dClWr16N27dvo2/fvggNDUXXrl0BAJ07d8aoUaM06/ft2xfv3r3DoEGDcO/ePezZswdTp05F//79kx0DpRy1GrC1jZ2fNg1Yvz52uD4ikxceLodK+vBBtpRdvQo0aaJ0VESkEJ3rlIWFhcHOzg4AYGZmBmtra7h8fk5KTz4+Pnjz5g3GjRsHf39/lClTBvv379d0/n/69KmmUC0AuLm54cCBAxg8eDBKlSoFV1dXDBo0CCNGjPiqOChlnD2rPc9q/USfsbGRZS62bwcmTmR1fiITp3NJDHNzc/z888+wt7cHAIwYMQLDhg2DU8wl2/9n7AOSm8Iltcbg8WPtckrKFF4hMkJ//SVLXPTooXQkRGmKKRy/dU7K3N3dYfaF805mZmaaqzKNlSm8qcYg7kelb19g0SLlYiEyCp8+AYMGAcuWAVZW8lQlh7Eg0pkpHL91biv38/NLwTAoPXnwIHa6bFkmZES4fRvw9gZu3JC/WEaN4riVRBQPOzCQwfXtGzt9/LhiYRAZh9Wr5QDinz4BOXLI05d16igdFREZISZlZDCRkdpFx2vUkOMnE5kkIYCePeUA4gBQrx7w558yMSMiSoDBhlki+nyUrWXLlImDyCiYmcmrXczNgcmTgf37mZARUZIUG5BcKabQUVAJKpX21fym9aki+j8h5NBIjo5yXq2WHfq/+UbJqIjSBVM4frOljL7agQPaCVncjv5EJuPDB6BDB6B6ddl/DJCtZEzIiEhHyUrKHj58iJ9++gnt2rXD69evAQD79u3DzZs3DRocGb/27YGGDWPn8+YFPDyUi4dIEVevyvHE1q+XV1qePKl0RESUBumdlJ04cQIlS5bEuXPnsG3bNnz8+BEA8N9//2H8+PEGD5CM1++/y2NQjEaNAFZOIZMihPwiVKoE3L8PuLnJhCzuLxUiIh3pnZSNHDkSP//8Mw4dOqQ1CHidOnXw77//GjQ4Ml6bN8ur/GPcugXs3atcPESpLjgY8PGRX4SICKBZM+DKFaBKFaUjI6I0Su+k7Pr162jZsmW85c7OzggMDDRIUGS8IiKAMWNkHcwYt2+zMDmZoAED5K+TDBmAWbOAHTuAbNmUjoqI0jC965Q5Ojri1atXyJcvn9byK1euwNXV1WCBkfF5+xb4bKhT/PEHUKSIMvEQKWraNPmLZOFCoGJFpaMhonRA75aytm3bYsSIEfD394eZmRnUajXOnDmDoUOHonPnzikRIxkBIeInZOfPA716KRMPUap7/15W54+ROzdw4QITMiIyGL2TsqlTp6JIkSJwc3PDx48fUaxYMdSoUQNVqlTBTz/9lBIxksKE0K7M36WLXFa+vGIhEaWuc+fkQK5dusjTlDHMzBQLiYjSn2QXj3369Clu3LiBjx8/omzZsihYsKChY0sRplB8ztBOnZJDJsVQq3ksIhMhBDB7NjByJBAdLeu9bNwoy18QUaoyheO33n3KTp8+jWrVqiFPnjzIkydPSsRERiQyUjshi4hgQkYm4u1b2TK2e7ec9/YGli7lgK5ElGL0Pn1Zp04d5MuXD6NHj8atW7dSIiYyIm3axE736QPEqYJClH6dOQOUKSMTMmtrWYtswwYmZESUovROyl6+fIkff/wRJ06cQIkSJVCmTBnMnDkTz58/T4n4SEF37wK7dsXOL1igXCxEqerlS+D5c6BgQeDff+UvEjYRE1EK+6oByR8/foy//voL69evx507d1CjRg0cPXrUkPEZnCmckzaEc+dkkfIYt26xFhmlc0JoJ16rVwOtWgGZMikXExFpmMLx+6uSMgBQqVTYt28fxo4di2vXrkGlUhkqthRhCm/q14qOBiwtY+ePHgVq11YuHqIUd+IEMHgwsGcP4OKidDRElABTOH4na0ByADhz5gz69esHFxcXtG/fHiVKlMCePXsMGRspxNo6dnrsWCZklI6pVMDkyUCdOnKIpHHjlI6IiEyY3ldfjho1Chs2bMDLly9Rv359zJs3D99++y3s7OxSIj5KZbt3y5IXAFCgADBpkrLxEKUYf3+gY0fgyBE536ULMHeukhERkYnTOyk7efIkhg0bBm9vbzh9XuKd0rSrV+WYyjHu3lUsFKKUdeQI0KEDEBAA2NnJqys5IgkRKUzvpOzMmTMpEQcZgd69Y6c3bwbMk31ym8iIbd8OtG4tO/aXKAFs2sSrWIjIKOiUlO3cuRONGjWCpaUldu7cmeS6zZs3N0hglLqOHZNjWQLy6v+49cmI0pX69YHChYHq1YF58wBbW6UjIiICoOPVl+bm5vD394ezszPMk2g+MTMz49WXaVBkpHbn/jdv4g8+TpSmXbggh0aK+f8VHAw4OCgbExHpxRSO3zqdoFKr1XB2dtZMJ/Zn7AkZJSxuQjZjBhMySkeio4FRo4AKFeQYljGYkBGREdK719CaNWsQERERb3lkZCTWrFljkKAo9cyapT0/bJgycRAZ3LNnQK1awC+/yHmOOkJERk7v4rEWFhZ49eqVpuUsxtu3b+Hs7Gz0rWWm0Pypj7gFzKOigAx6X/pBZIT27JFXU757J8erXL6cHSWJ0jhTOH7r3VImhIBZAmPAPX/+HA48JZCm/PZb7PTBg0zIKB2IjASGDgWaNpUJWblysigsEzIiSgN0PgyXLVsWZmZmMDMzQ926dZEhzhFcpVLh8ePHaNiwYYoESSlj9erY6fr1lYuDyGBu3479tTFoEDB9unanSSIiI6ZzUtaiRQsAwNWrV+Hl5QV7e3vNfVZWVnB3d0fr1q0NHiClnMuX5e2UKcrGQWQwpUsDCxYAzs7A//9nERGlFTonZePHjwcAuLu7w8fHBzY2NikWFKW8W7dip9nASWlWRAQwejTQqRNQpoxc1quXoiERESWX3h390zpT6Cj4JUJoV+s3rU8ApRsPHwI+PsClS0ChQsCNG4ClpdJREVEKMYXjt04tZVmzZsW9e/fg5OSELFmyJNjRP8a7d+8MFhyljBw5YqeHDlUuDqJk27wZ6NEDCAkBsmaVNciYkBFRGqdTUjZnzhxkypRJM51UUkbGrWpVWbEfAFxdgZkzlY2HSC/h4cCQIXIAcUB+oNevB9zclI2LiMgAePrShJw5A1SrFjuvUnHQcUpD3rwBGjQArl6V86NGAZMmsZYLkYkwheO33ofky5cv4/r165r5HTt2oEWLFhg9ejQiIyMNGhwZVtyE7PVrJmSUxmTNKscAy54d2L8fmDqVCRkRpSt6H5Z79+6Ne/fuAQAePXoEHx8f2NnZYfPmzRg+fLjBAyTDuHIldnriRHlcIzJ6nz4BYWFy2sICWLdOtpR5eSkaFhFRStA7Kbt37x7K/P/S882bN6NmzZr466+/sGrVKmzdutXQ8ZEBPHgAfPNN7PyYMcrFQqSz27eBihWBH36IXebsDOTKpVhIREQpKVnDLKnVagDA4cOH0bhxYwCAm5sbAgMDDRsdGUTcJOzHH2WDA5FRW71aDpF04wawY0fs1SlEROmY3klZuXLl8PPPP2Pt2rU4ceIEmjRpAgB4/PgxcsSttUBG4dUrYNMmOV24MPDrr8rGQ5Sk0FCgSxf59+kTULeuPF3J8+1EZAL0Tsrmzp2Ly5cvY8CAARgzZgwKFCgAANiyZQuqVKli8AAp+c6e1T7TM3u2crEQfdGNG0D58rKVzNwcmDwZOHAAyJlT6ciIiFKFwUpihIeHw8LCApZGXsDRFC6pjRG3nFzdusDhw8rFQpSkyEjAwwN4/lz+kvjrL6BmTaWjIiIjYgrH72RfT37p0iXcvn0bAFCsWDF8E7cnOSmue/fY6RUrgK5dlYuF6IusrIDFi4GFC2VLGU9XEpEJ0rul7PXr1/Dx8cGJEyfg6OgIAAgKCkLt2rWxYcMGZDfyf6amkGnv3Al8+23svGmVB6Y047//ZMG8+vVjlwmh3cRLRPR/pnD81rtP2ffff4+PHz/i5s2bePfuHd69e4cbN24gJCQEAwcOTIkYSQ8qlRyjOcaLF8rFQpQgIWSrWMWK8sP69GnsfUzIiMiE6X36cv/+/Th8+DCKFi2qWVasWDEsXLgQDRo0MGhwpL+jR+XwgABw6BBLOpGRCQ4GevWKvSS4fn0gY0ZlYyIiMhJ6t5Sp1eoEO/NbWlpq6peRcmLy4syZgXr1lI2FSMulS7KK8aZNcnikWbPkufZs2ZSOjIjIKOidlNWpUweDBg3Cy5cvNctevHiBwYMHo27dugYNjvSzZ0/s9KhRysVBFM/8+UCVKsCjR0DevMDp08CQITxdSUQUh95J2YIFCxASEgJ3d3d4eHjAw8MD+fLlQ0hICObPn58SMdIXCAF4ewNNm8YuGzlSuXiI4rl5U5a9aNFCDsRasaLSERERGR29+5S5ubnh8uXLOHLkiKYkRtGiRVGP58oUM2UKsHmz9jyR4uJeSTlnjmwp69SJrWNERInQKynbuHEjdu7cicjISNStWxfff/99SsVFeliwIHb68mWgbFnlYiGCEDIJO3QI2L1bDrZqawt07qx0ZERERk3npOz3339H//79UbBgQdja2mLbtm14+PAhZs6cmZLx0RdERwMBAXJ6714mZKSwt2/luJW7d8v5bduA775TNCQiorRC5z5lCxYswPjx43H37l1cvXoVq1evxqJFi1IyNvqC9++BuBfCVq6sXCxE+Ocf+atg927A2hr4/XegTRuloyIiSjN0TsoePXoEX19fzXz79u0RHR2NV69epUhglLSrV4GsWWPnS5cG/j/AAlHqUquB6dOBGjWAZ8+AggWBf/8F+vRh/zEiIj3onJRFREQgY5wij+bm5rCyskJYWFiKBEaJ+/BB+zRlo0bAhQvKxUMmbuBAebmvSgW0by/rkZUpo3RURERpjl4d/ceOHQs7OzvNfGRkJKZMmQIHBwfNstmzZxsuOkpQ3CG/mjWT9TeJFNOrF7B+PTBjBtCtG1vHiIiSSeekrEaNGrh7967WsipVquDRo0eaeTP+M05xO3Zoz2/dqkwcZMJUKuDixdhaY6VKAX5+QKZMioZFRJTW6ZyUHT9+PAXDIF28eydrb8YICdHu6E+U4gICgI4dgePHZVX+mMSMCRkR0VfTu6I/KSfueO9bt/I4SKns6FF5Rcnhw4CVFfD8udIRERGlK0zK0gghZP9pAMidG2jVStl4yISoVMD48XKE+4AAoEQJefqydWulIyMiSlf0HmaJlBGn6x6OHVMuDjIxL18CHTrI05UA0KMHMG8eEOeCHyIiMgyjaClbuHAh3N3dYWNjg4oVK+L8+fM6bbdhwwaYmZmhRdyOVunU4MGx0wUKKBcHmZht22RCZm8PrFsHLF3KhIyIKIUonpRt3LgRQ4YMwfjx43H58mWULl0aXl5eeP36dZLb+fn5YejQoahevXoqRaqsU6fkbdu2ysZBJqZ/f2DoUHnuvH17paMhIkrXkpWUnTp1Ch07dkTlypXx4sULAMDatWtx+vRpvfc1e/Zs9OzZE127dkWxYsWwePFi2NnZYcWKFYluo1Kp0KFDB0ycOBH58+dPzlNIU/79FwgKktMcapRS1PPncuzKDx/kvJmZ/NAVKqRoWEREpkDvpGzr1q3w8vKCra0trly5goiICABAcHAwpk6dqte+IiMjcenSJdSrVy82IHNz1KtXD2fPnk10u0mTJsHZ2Rndu3fXN/w0qVmz2OlcuZSLg9K5PXtkJf7Vq4Eff1Q6GiIik6N3Uvbzzz9j8eLFWLp0KSzjFMmqWrUqLl++rNe+AgMDoVKpkCNHDq3lOXLkgL+/f4LbnD59GsuXL8fSpUt1eoyIiAiEhIRo/aUlhw4BgYFyeuRIwFzxE86U7kRFAcOGAU2bAm/fAp6ewIgRSkdFRGRy9D7E3717FzVq1Ii33MHBAUEx59hSyIcPH9CpUycsXboUTk5OOm0zbdo0ODg4aP7c3NxSNEZD++GH2Olx4xQLg9KrJ0/kQOK//irnBw4EzpwBPDyUjYuIyATpXRIjZ86cePDgAdzd3bWWnz59Wu/+XU5OTrCwsEBAQIDW8oCAAOTMmTPe+g8fPoSfnx+axTmfp1arAQAZMmTA3bt34fHZwWTUqFEYMmSIZj4kJCTNJGZqNXDrlpweNQqwtVU2HkpnTp0CmjeXHRYdHYGVK7WHjCAiolSld0tZz549MWjQIJw7dw5mZmZ4+fIl1q1bh6FDh6Jv37567cvKygqenp44cuSIZplarcaRI0dQuXLleOsXKVIE169fx9WrVzV/zZs3R+3atXH16tUEky1ra2tkzpxZ6y+tuHEjdrprV+XioHSqYEHA2loOlXTlChMyIiKF6d1SNnLkSKjVatStWxefPn1CjRo1YG1tjaFDh+L777/XO4AhQ4bA19cX5cqVQ4UKFTB37lyEhoai6/+zkM6dO8PV1RXTpk2DjY0NSpQoobW9o6MjAMRbnh7EHXy8YEHl4qB05O1bIFs2OZ0zp6xBlj+/HDaJiIgUpXdSZmZmhjFjxmDYsGF48OABPn78iGLFisHe3j5ZAfj4+ODNmzcYN24c/P39UaZMGezfv1/T+f/p06cwN9He7YsXy1sWiyWD2LIF6N4dWLIE8PGRy4oUUTYmIiLSMBNCCKWDSE0hISFwcHBAcHCwUZ/KFCL2Ssu1a4GOHZWNh9Kw8HBZ4mLRIjnfqJEsf2FmpmxcRER6SCvH76+hd0tZ7dq1YZbEP/OjR49+VUAkBQfHTjdurFwclMbdvw94ewNXr8r5kSOBSZOYkBERGSG9k7IyZcpozUdFReHq1au4ceMGfH19DRWXydu7N3Y6a1bl4qA0bP16oFcv4ONHwMlJNrk2bKh0VERElAi9k7I5c+YkuHzChAn4+PHjVwdEUiK1c4l0c+1a7FiVNWoAf/0FuLoqGxMRESXJYH3KHjx4gAoVKuDdu3eG2F2KSSvnpGPOLnXsKBs4iPQ2bJgsbjduHJBB799fRERGJa0cv7+Gwf5Tnz17FjY2NobanUnr3z92Ol8+5eKgNGbdOqB6dSBPHjk/Ywb7jhERpSF6J2WtWrXSmhdC4NWrV7h48SLGjh1rsMBMVUBA7EVyAPDTT8rFQmlEaCjw/feyIn+VKrL2mKUlEzIiojRG76TMwcFBa97c3ByFCxfGpEmT0KBBA4MFZqq++SZ2+v591vSkL7h5U15deeuWrKHi5cVR64mI0ii9kjKVSoWuXbuiZMmSyJIlS0rFZLLu3gVevpTTxYqxaCwlQQjZMjZgABAWBri4yM78tWopHRkRESWTXj+pLSws0KBBAwQFBaVQOKatVKnY6TNnlIuDjFxoKNC5s6zOHxYmW8euXmVCRkSUxul9nqNEiRJ49OhRSsRi0oKDgchIOd27N/D/IT2J4jM3lyUvLCyAadNkUTtnZ6WjIiKir6R3SYz9+/dj1KhRmDx5Mjw9PZExY0at+439MlVjvaS2Zk3g5Ek5rVazjzZ9Rgjtsbfu3gXevAGqVVM2LiKiVGKsx29D0jkpmzRpEn788UdkypQpduM4mYMQAmZmZlCpVIaP0oCM8U394w+gTx857eoKPH+ubDxkZIKDZWX+kiV5OS4RmSxjPH4bms5JmYWFBV69eoXbt28nuV7NmjUNElhKMbY3NSQEiHtB6/PnLLxOcVy6BPj4AA8fAjY2wKNHslM/EZGJMbbjd0rQ+erLmNzN2JOutKZfv9jp06eZkNH/CQEsWAAMHSo7G+bNC2zYwISMiCgd06skhhk7OhnUyZOyCDsAlC4NVK2qbDxkJIKC5JWV27bJ+RYtgBUrAJahISJK1/RKygoVKvTFxMzYx740JvXqxU7/+adycZARiY6WVflv35ZV+X/9VVbr5w8iIqJ0T6+kbOLEifEq+lPyZcgAREXJjv4lSigdDRmFDBmAQYPkuJUbNwLlyikdERERpRKdO/qbm5vD398fzmm8HpKxdBSMioodQunNG8DJSbFQSGnv3gGvXgHFi8t5IYBPn4DPys0QEZkyYzl+pySdi8eyP5lh7dgRO83GRxP2zz9AmTJA06ayLxkgT1UyISMiMjk6J2V61pilLxg4MHba0lK5OEghajUwfTpQowbw7Jn8ELx+rXRURESkIJ37lKnV6pSMw+R8+CBve/dWNg5SwJs3gK8vsG+fnG/XTnYsjFOYmYiITI9eHf3JMP78E/j4UU537apsLJTKTp6USdjLl7IY7Pz5svwFuwcQEZk8JmUK6NQpdrpkSeXiIAXMni0TsiJFgE2b+AEgIiINJmWpLOa0JQAcOwbY2SkXCylg+XIgf35g0iTA3l7paIiIyIjo3NGfDOPatdjpWrUUC4NSy9GjwI8/yjIXAJAtm2wtY0JGRESfYUtZKps2Td7G1CijdEqlkq1hkyfLhKxiRcDbW+moiIjIiDEpS2V79shbT09l46AU9PIl0KEDcPy4nO/eXdYhIyIiSgKTslTk7x87vXKlcnFQCjp4EOjYUZa9yJhRlrro0EHpqIiIKA1gn7JU9PvvsdOFCysXB6WQmTOBhg1lQla6NHD5MhMyIiLSGZOyVNKvn+xiBAC5cysbC6WQsmXlbd++wL//AoUKKRsPERGlKTx9mQoCA7VbyTZsUC4WMrDXrwFnZzldrx5w/XrswOJERER6YEtZCouKArJnj51/+BCoWlW5eMhAoqKAYcNka9jDh7HLmZAREVEyMSlLYfnzx0537Kg9T2nUkydA9erAr78CwcHArl1KR0REROkAT1+moMmTgefPY+fXrlUuFjKQv/+WA5YGBQEODsCKFUCrVkpHRURE6QBbylJIVBQwblzs/Js3ysVCBhAZCfzwA9CypUzIKlQArlxhQkZERAbDpCwFRERoV+zfvx9wclIuHjKABQuAefPk9JAhwKlTQL58ysZERETpCk9fpoBq1bTnvbyUiYMMaMAA4NAhWdukWTOloyEionSILWUGJgRw8WLsvEqlXCz0FcLD5cDhUVFy3soK2LePCRkREaUYtpQZ2P37sdPPnwPmTHvTnvv3AR8f2WfszZvYUeSJiIhSEFMGA/vwIXba1VW5OCiZNmwAvvlGJmROTkCNGkpHREREJoJJmYH995+8LVhQ2ThIT2FhQO/eQLt2wMePsg7Z1atAo0ZKR0ZERCaCSZkBBQUB3bvL6Y8fFQ2F9HHvHlCxIrBkCWBmBvz0E3D0KJs6iYgoVbFPmQE1bBg7PXmycnGQntRq4NEjOYblunVyDEsiIqJUxqTMQPz8gHPn5HTRorEtZmSk1OrYqzCKFAG2bQNKlgRcXJSNi4iITBZPXxpIgQKx0/v3KxcH6eDmTaBMGeDkydhlDRowISMiIkUxKTOAv/+OrUfWpw+QJ4+i4VBihACWLwfKlweuXwd+/FEuIyIiMgJMygwg7qnKmJF4yMh8+AB06gT06CGvtGzQANizR3bsJyIiMgJMygwgc2Z527ev9piXZCT++w8oV0524rewAKZOldX5nZ2VjoyIiEiDHf2/0rt3spM/IE9dkpG5fVuWu4iIkCUuNmyIPzgpERGREWBS9pW8vWOnWTDWCBUpAjRvDoSGAqtXyyr9RERERohJ2Vc6ckTefvMNYGurbCz0f1euAPnyAY6Oss/Y6tWAtTUHIiUiIqPGo5SBLF+udAQEIYAFC4BKlWSH/pgrK21tmZAREZHRY0vZV3j8OHa6cGHl4iDEjnG1bZucj44GwsPZfElERGkGmw++wo8/xk7z2K+g8+eBsmVlQmZpCcydC2zfzjeFiIjSFCZlX2HHDnnr7q5oGKZLCGDOHHk1pZ+f7Ed25gwwaBDrjxERUZrDpCyZTp6UwycCwO7dysZisoKDgdmzgagooHVr4PJlWa2fiIgoDWKfsmQaPFje2tsDxYsrG4vJcnQE1q+XxWH79WPrGBERpWlMypIhLEw2ygBAz57KxmJS1Grg11+BnDmBzp3lsmrVWAyWiIjSBSZlyXD1auz0qFGKhWFa3rwBfH3l8Eh2dkDt2oCbm9JRERERGQyTsmQIDZW3efIA2bMrG4tJOHUKaNsWePkSsLGRV1fmzq10VERERAbFjv7J8Oef8jZXLmXjSPfUamDKFKBWLZmQFS4MnDsnzxmz/xgREaUzbClLhpAQefvmjbJxpGsqFdCkCXDggJzv1AlYtEheWUFERJQOsaUsGbZvl7c//KBoGOmbhQVQrpzsP7ZyJbBmDRMyIiJK14wiKVu4cCHc3d1hY2ODihUr4vz584muu3TpUlSvXh1ZsmRBlixZUK9evSTXTwmZMsnbAgVS9WHTP5VKu/lxwgR5VUWXLgoFRERElHoUT8o2btyIIUOGYPz48bh8+TJKly4NLy8vvH79OsH1jx8/jnbt2uHYsWM4e/Ys3Nzc0KBBA7x48SJV4vXzAz58kNPsU2ZAr14B9esDjRoBERFyWYYMQMGCysZFRESUSsyEEELJACpWrIjy5ctjwYIFAAC1Wg03Nzd8//33GDly5Be3V6lUyJIlCxYsWIDOMbWrkhASEgIHBwcEBwcjc+bMesc7dSowZoycjogArKz03gV97uBBoGNH2UqWMSNw9ChQoYLSURERkRH52uN3WqBoS1lkZCQuXbqEevXqaZaZm5ujXr16OHv2rE77+PTpE6KiopA1a9aUClMjICA2IatfnwnZV4uOli9ow4YyIStVCrh0iQkZERGZJEWvvgwMDIRKpUKOHDm0lufIkQN37tzRaR8jRoxArly5tBK7uCIiIhARczoMMtNOrrFjY6fLlUv2bggAnj8H2reXNcgAoHdvObi4ra2ycRERESlE8T5lX+OXX37Bhg0bsH37dtjY2CS4zrRp0+Dg4KD5c0tmFXghgKVL5XSBAvI0Jn2Fnj1lQpYpE7BhA7B4MRMyIiIyaYomZU5OTrCwsEBAQIDW8oCAAOTMmTPJbX/99Vf88ssvOHjwIEqVKpXoeqNGjUJwcLDm79mzZ8mKddiw2OlffknWLiiuhQvlUEmXLwM+PkpHQ0REpDhFkzIrKyt4enriyJEjmmVqtRpHjhxB5cqVE91uxowZmDx5Mvbv349yXziPaG1tjcyZM2v9JcesWbHTrVsnaxem7elTYNmy2Pn8+WWHftYVISIiAmAEFf2HDBkCX19flCtXDhUqVMDcuXMRGhqKrl27AgA6d+4MV1dXTJs2DQAwffp0jBs3Dn/99Rfc3d3h7+8PALC3t4d9ChUXjRnrEojtAkV62LlT1hoLCpIDhjZooHRERERERkfxpMzHxwdv3rzBuHHj4O/vjzJlymD//v2azv9Pnz6FuXlsg97vv/+OyMhItGnTRms/48ePx4QJE1IkxpgK/gBQvnyKPET6FBkJjBghBxAH5IvHumNEREQJUrxOWWpLTp2Tjh2BdeuAnDlljVPSwePHsq/YhQtyfvBg2RmPdUSIiCgZTKFOmeItZWmBSiVvK1VSNo404++/5enK4GAgSxZg1SqgeXOFgyIiIjJuTMq+IDpaVmwAgJo1lY0lzQgJkQlZ5cryxcuTR+mIiIiIjB6Tsi+IGecSALy8lIvD6KlUgIWFnO7cGbCxAVq2BCwtlY2LiIgojUjTxWNTQ5cusdOFCikWhnHbsAEoWRIIDIxd5u3NhIyIiEgPTMqSEB4uqznEiGkIov8LC5PDI7VrB9y+DcyerXREREREaRZPXyZh167Y6U+flIvDKN25I1vDrl8HzMyA0aOBFCpJQkREZAqYlCXhxg15W6AAh2XUsnYt0LevrKrr7Az8+SdQv77SUREREaVpTMqScOaMvC1aVNk4jMoffwB9+sjp2rVlATcXF2VjIiIiSgfYpywJ2bPL2/z5lY3DqLRtK5sOJ0wADh1iQkZERGQgbClLwr178takkzIh5MDhderIvmMODsC1azyfS0REZGBsKUtCWJi8jTsguUn5+BHw9QXq1QMWL45dzoSMiIjI4NhSlgQ7O3nr4aFsHIq4dk1eXXn3LmBubsKZKRERUepgUpYIlQq4dElOOzsrG0uqEgJYsgQYNAiIiABcXYH164Hq1ZWOjIiIKF1jUpaIVatip4sVUyyM1BUSAvTqBWzcKOcbNQLWrAGcnJSNi4iIyASwT1kiBg+OnTaZlrIbN4DNm+XQBTNmALt3MyEjIiJKJWwpS0TMQOQ+PsrGkaqqVAEWLADKlAEqV1Y6GiIiIpPClrIEqFSx0/37KxdHigsKAjp1kuNWxujblwkZERGRAthSloCBA2Ony5ZVLo4UdeGCbAZ8/Bi4dQu4eFHWISMiIiJFsKUsAXv3xk7b2ysXR4oQApg7F6haVSZk7u6yBhkTMiIiIkWxpSwBz57J20mTlI3D4N69A7p2BXbulPOtWgHLlwOOjoqGRUREREzK4jl2LLZPWbVqysZiUI8fA7VqAU+fAlZWwOzZQL9+bCEjIiIyEkzKPvPrr7HT6apeqpsbkCcPYGkJbNoEfPON0hERERFRHEzKPvPunbwdNAjIkNZfnbdvgUyZZMtYhgyyBpmdHZA5s9KRERER0WfY0f8z//4rbytVUjaOr3bqFFC6NDBiROyynDmZkBERERkpJmVxRETEThcpolwcX0WtBqZOBWrXBl68APbv52DiREREaQCTsjiuXo2dTpNJ2evXQMOGwJgx8mqFjh1lPbKMGZWOjIiIiL4grfeaMqjly2OnbWyUiyNZjh0D2rcH/P0BW1tg4UKgSxdeXUlERJRGMCmLY88eeZsnj7Jx6C0kBGjdGnj/HihWTF5dWby40lERERGRHpiUxWFnJ2+nTFE2Dr1lzgz88Qewbx8wfz5PVxIREaVBTMr+TwjgwQM5nSYamQ4fBszNgTp15Px338k/IiIiSpPY0f//Vq6Mnc6bV7k4vig6GvjpJ6BBA6BdO+DVK6UjIiIiIgNgS9n/de8eO501q3JxJOnFC5mInTol51u04LiVRERE6QSTMshTlzFmzFAujiTt2wd07gwEBgL29sDSpUDbtkpHRURERAbC05fQLhrbubNycSRIrZZV+Rs3lglZ2bLA5ctMyIiIiNIZJmUAPn2Knc6WTbk4EmRuLmuPAUD//sA//wAFCyobExERERkcT18itpJ/hgxGNAh5dHRsMAsXyisrmzZVNiYiohQmhEB0dDRUKpXSoZACLC0tYWFhoXQYijGWFERRMUlZdLSiYUiRkcDIkbI+x44dsiK/vT0TMiJK9yIjI/Hq1St8inv6gkyKmZkZcufODXt7e6VDUQSTMgA//ihvY0p+KebxY8DHR45XCQDHj8uBxYmI0jm1Wo3Hjx/DwsICuXLlgpWVFcw4TJxJEULgzZs3eP78OQoWLGiSLWYmn5Tdvx87Xa+ecnFg2zagWzcgOFiWuVi1igkZEZmMyMhIqNVquLm5wS5meBUyOdmzZ4efnx+ioqJMMikz+Y7+q1bFTo8YoUAAERHA99/LsSuDg4FKleT51G+/VSAYIiJlmZub/GHJpJl666jJf/p37ZK39erJCx1TXYcOwIIFcnrYMODkSSMfUoCIiIhSgsknZeHh8rZUKYUCGDECcHEBdu+WlWstLRUKhIiIiJRk0klZaGhsn7K6dVPpQcPCgBMnYufLlwcePQKaNEmlAIiIyNDOnj0LCwsLNEngf/nx48dhZmaGoKCgePe5u7tj7ty5WsuOHTuGxo0bI1u2bLCzs0OxYsXw448/4sWLFykUPRAeHo7+/fsjW7ZssLe3R+vWrREQEJDkNmZmZgn+zZw5U7PO5cuXUb9+fTg6OiJbtmzo1asXPn78mGLPI60z6aTst99ip8uWTYUHvHtX9hnz8oqtwwEANjap8OBERJRSli9fju+//x4nT57Ey5cvk72fP/74A/Xq1UPOnDmxdetW3Lp1C4sXL0ZwcDBmzZplwIi1DR48GLt27cLmzZtx4sQJvHz5Eq1atUpym1evXmn9rVixAmZmZmjdujUA4OXLl6hXrx4KFCiAc+fOYf/+/bh58ya6dOmSYs8jrTPpqy9Pn46ddnFJ4Qdbtw7o3Vs2z2XPDiTwi4mIiNKejx8/YuPGjbh48SL8/f2xatUqjB49Wu/9PH/+HAMHDsTAgQMxZ84czXJ3d3fUqFEjwZY2QwgODsby5cvx119/oc7/a0OtXLkSRYsWxb///otKlSoluF3OnDm15nfs2IHatWsjf/78AIDdu3fD0tISCxcu1FzAsXjxYpQqVQoPHjxAgQIFUuT5pGUm3VKWI4e8TdELHT99Anr0ADp2lAlZrVqylaxWrRR8UCKitE0I+S9TiT8h9It106ZNKFKkCAoXLoyOHTtixYoVEPruBMDmzZsRGRmJ4cOHJ3i/o6Njots2atQI9vb2if4VL1480W0vXbqEqKgo1ItTF6pIkSLIkycPzp49q1PsAQEB2LNnD7p3765ZFhERASsrK60ram1tbQEAp+O2ipCGybaURUQAK1fK6RTrT3brFuDtDdy8KSvzjxsHjB0LmGDtFSIifXz6JAczUcLHj0DGjLqvv3z5cnTs2BEA0LBhQwQHB+PEiROopeeP7/v37yNz5sxwScapm2XLliEsLCzR+y2TuIjM398fVlZW8ZK+HDlywD9m7OUvWL16NTJlyqR1yrNOnToYMmQIZs6ciUGDBiE0NBQjR44EIE99Unwmm5SVKRM7nWJXXu7YIROynDnl6UvFhwwgIiJDunv3Ls6fP4/t27cDADJkyAAfHx8sX75c76RMCJHsOl2urq7J2s5QVqxYgQ4dOsAmTh/p4sWLY/Xq1RgyZAhGjRoFCwsLDBw4EDly5GA9ukSYbFIW0w8zWzagZs0UepDhw2Vb+Pffx54rJSKiL7Kzky1WSj22rpYvX47o6GjkypVLs0wIAWtrayxYsAAODg7InDkzANl36/PWqKCgIDg4OAAAChUqhODgYLx69Urv1rJGjRrh1KlTid6fN29e3Lx5M8H7cubMicjISAQFBWnFFxAQEK/fWEJOnTqFu3fvYuPGjfHua9++Pdq3b4+AgABkzJgRZmZmmD17tqbfGWkz2aQsxv79BtzZ9evApEnAmjWAra08TfnzzwZ8ACIi02Bmpt8pRCVER0djzZo1mDVrFho0aKB1X4sWLbB+/Xr06dMHBQsWhLm5OS5duoS8cYqDP3r0CMHBwShUqBAAoE2bNhg5ciRmzJih1dE/xudJU1xfc/rS09MTlpaWOHLkiObKybt37+Lp06eoXLlyotvFWL58OTw9PVG6dOlE18nx/4aJFStWwMbGBvXr1//ifk2SMDHBwcECgACCBSBEdLQBdqpWC7FkiRA2NkIAQgwfboCdEhGZjrCwMHHr1i0RFhamdCg62759u7CyshJBQUHx7hs+fLgoV66cZr5Xr17C3d1d7NixQzx69EicOHFCVKpUSVSqVEmo1WrNegsXLhRmZmaiW7du4vjx48LPz0+cPn1a9OrVSwwZMiTFnkufPn1Enjx5xNGjR8XFixdF5cqVReXKlbXWKVy4sNi2bZvWsuDgYGFnZyd+//33BPc7f/58cenSJXH37l2xYMECYWtrK+bNm5doHEl9DmKO38HBwcl4hmmDSSdlGTMaZIdCtG0rkzFAiIYNhXj92gA7JiIyHWkxKWvatKlo3LhxgvedO3dOABD//fefEEI+v/Hjx4siRYoIW1tbkS9fPtGrVy/x5s2beNseOnRIeHl5iSxZsggbGxtRpEgRMXToUPHy5csUey5hYWGiX79+IkuWLMLOzk60bNlSvHr1SmsdAGLlypVay/744w9ha2ubYGIqhBCdOnUSWbNmFVZWVqJUqVJizZo1X4zDlJMyMyGScd1uGhYSEvL/8/fBcHTMjPfvv2JnV67IqysfPJCnKqdOBYYOVWgQTSKitCs8PByPHz9Gvnz5tDqLk2lJ6nMQc/wODg7W9NNLb0y6T5m7+1dsvH070LYtEBkJuLkBGzYAVaoYKjQiIiIyMSadlNWu/RUblysni+hUrSoLnmXLZrC4iIiIyPSYdFKmdwv5ixdATC0YNzfg/Hkgf355mRARERHRVzDpzk/W1jquKAQwb55MwHbujF3u4cGEjIiIiAzCpJOyZs10WOndO6BlS+CHH2T/sbhJGREREZGBmHRS9sWO/v/+C5QtK4dLsrIC5s8Hli5NjdCIiEySiRUEoM+Y+vtv0klZokNpqNXAr78C1asDT5/K05T//AMMGMDTlUREKSCm4vynT58UjoSUFBkZCQCwsLBQOBJlmHRH/0T7lJ08CQwbJqe9vWXrWDqtiUJEZAwsLCzg6OiI169fAwDs7OySPTg3pU1qtRpv3ryBnZ0dMmQwzfTENJ815FnJRL/vtWoBgwYBRYoAvXuzdYyIKBXEDH4dk5iR6TE3N0eePHlMNiE32aTMxSXOjFotr65s1w74/z8FzJ2rRFhERCbLzMwMLi4ucHZ2RlRUlNLhkAKsrKxgbsKj4hhFUrZw4ULMnDkT/v7+KF26NObPn48KFSokuv7mzZsxduxY+Pn5oWDBgpg+fToaN26s12NqWkZfvwY6dQIOHgR27wYOHeIwSURECrKwsDDZPkVk2hTPPjZu3IghQ4Zg/PjxuHz5MkqXLg0vL69Em6//+ecftGvXDt27d8eVK1fQokULtGjRAjdu3NDrcS0sABw/DpQpIxMyW1ugQweeqiQiIiJFKD4gecWKFVG+fHksWLAAgOzo5+bmhu+//x4jR46Mt76Pjw9CQ0Oxe/duzbJKlSqhTJkyWLx48RcfL2ZA09XFRqHzneny1GXRosCmTUCJEoZ7YkRERGQwpjAguaItZZGRkbh06RLq1aunWWZubo569erh7NmzCW5z9uxZrfUBwMvLK9H1E9Pi1jSZkHXtCly4wISMiIiIFKVon7LAwECoVCrkyJFDa3mOHDlw586dBLfx9/dPcH1/f/8E14+IiEBERIRmPjg4WD62uQ3w+zygbVtApQJCQr7mqRAREVEKCvn/cTo9F5g1io7+KWnatGmYOHFivOUe6nBZ7qJ3bwWiIiIiouR4+/YtHBwclA4jRSialDk5OcHCwgIBAQFaywMCAjT1aj6XM2dOvdYfNWoUhgwZopkPCgpC3rx58fTp03T7pqYVISEhcHNzw7Nnz9Jt/4C0hO+H8eB7YTz4XhiP4OBg5MmTB1mzZlU6lBSjaFJmZWUFT09PHDlyBC1atAAgO/ofOXIEAwYMSHCbypUr48iRI/jhhx80yw4dOoTKlSsnuL61tTWsEyjd7+DgwC+YkcicOTPfCyPC98N48L0wHnwvjEd6rmOm+OnLIUOGwNfXF+XKlUOFChUwd+5chIaGomvXrgCAzp07w9XVFdOmTQMADBo0CDVr1sSsWbPQpEkTbNiwARcvXsSSJUuUfBpEREREX0XxpMzHxwdv3rzBuHHj4O/vjzJlymD//v2azvxPnz7VyoqrVKmCv/76Cz/99BNGjx6NggUL4u+//0YJXj1JREREaZjiSRkADBgwINHTlcePH4+37LvvvsN3332XrMeytrbG+PHjEzylSamL74Vx4fthPPheGA++F8bDFN4LxYvHEhEREZERDLNEREREREzKiIiIiIwCkzIiIiIiI5Auk7KFCxfC3d0dNjY2qFixIs6fP5/k+ps3b0aRIkVgY2ODkiVLYu/evakUafqnz3uxdOlSVK9eHVmyZEGWLFlQr169L753pB99vxsxNmzYADMzM009Qfp6+r4XQUFB6N+/P1xcXGBtbY1ChQrxf5WB6PtezJ07F4ULF4atrS3c3NwwePBghIeHp1K06dfJkyfRrFkz5MqVC2ZmZvj777+/uM3x48fxzTffwNraGgUKFMCqVatSPM4UJdKZDRs2CCsrK7FixQpx8+ZN0bNnT+Ho6CgCAgISXP/MmTPCwsJCzJgxQ9y6dUv89NNPwtLSUly/fj2VI09/9H0v2rdvLxYuXCiuXLkibt++Lbp06SIcHBzE8+fPUzny9Enf9yPG48ePhaurq6hevbr49ttvUyfYdE7f9yIiIkKUK1dONG7cWJw+fVo8fvxYHD9+XFy9ejWVI09/9H0v1q1bJ6ytrcW6devE48ePxYEDB4SLi4sYPHhwKkee/uzdu1eMGTNGbNu2TQAQ27dvT3L9R48eCTs7OzFkyBBx69YtMX/+fGFhYSH279+fOgGngHSXlFWoUEH0799fM69SqUSuXLnEtGnTElzf29tbNGnSRGtZxYoVRe/evVM0TlOg73vxuejoaJEpUyaxevXqlArRpCTn/YiOjhZVqlQRy5YtE76+vkzKDETf9+L3338X+fPnF5GRkakVosnQ973o37+/qFOnjtayIUOGiKpVq6ZonKZGl6Rs+PDhonjx4lrLfHx8hJeXVwpGlrLS1enLyMhIXLp0CfXq1dMsMzc3R7169XD27NkEtzl79qzW+gDg5eWV6Pqkm+S8F5/79OkToqKi0vU4Z6klue/HpEmT4OzsjO7du6dGmCYhOe/Fzp07UblyZfTv3x85cuRAiRIlMHXqVKhUqtQKO11KzntRpUoVXLp0SXOK89GjR9i7dy8aN26cKjFTrPR4/DaK4rGGEhgYCJVKpRkNIEaOHDlw586dBLfx9/dPcH1/f/8Ui9MUJOe9+NyIESOQK1eueF860l9y3o/Tp09j+fLluHr1aipEaDqS8148evQIR48eRYcOHbB37148ePAA/fr1Q1RUFMaPH58aYadLyXkv2rdvj8DAQFSrVg1CCERHR6NPnz4YPXp0aoRMcSR2/A4JCUFYWBhsbW0Viiz50lVLGaUfv/zyCzZs2IDt27fDxsZG6XBMzocPH9CpUycsXboUTk5OSodj8tRqNZydnbFkyRJ4enrCx8cHY8aMweLFi5UOzeQcP34cU6dOxaJFi3D58mVs27YNe/bsweTJk5UOjdKBdNVS5uTkBAsLCwQEBGgtDwgIQM6cORPcJmfOnHqtT7pJznsR49dff8Uvv/yCw4cPo1SpUikZpsnQ9/14+PAh/Pz80KxZM80ytVoNAMiQIQPu3r0LDw+PlA06nUrOd8PFxQWWlpawsLDQLCtatCj8/f0RGRkJKyurFI05vUrOezF27Fh06tQJPXr0AACULFkSoaGh6NWrF8aMGaM1VjOlrMSO35kzZ06TrWRAOmsps7KygqenJ44cOaJZplarceTIEVSuXDnBbSpXrqy1PgAcOnQo0fVJN8l5LwBgxowZmDx5Mvbv349y5cqlRqgmQd/3o0iRIrh+/TquXr2q+WvevDlq166Nq1evws3NLTXDT1eS892oWrUqHjx4oEmMAeDevf+1d/cxVdV/HMDfXOgC4kVGyeDGg4LCnGmIoKk5kixgWSQqlExRSJyEOE2LNeOhwocSHDgrmhOMmDy4CiYJxpKC6yo0HjbBiyioTaoFDSQhHu7n94fjrisPRfqTG75f2/njnPP5fs/ne75zfPY95x4b4eDgwILsLvybubh169aQwmuwWBb+r4X31YT8+z3evzS413Jzc8Xc3FyysrKkvr5eoqKixMbGRn7++WcREVm3bp3ExcXp4zUajZiZmcmBAwekoaFBEhIS+EmMe2Ssc7Fv3z5RKpVy4sQJaW1t1W83b94cryFMKGOdjzvx15f3zljn4tq1a6JSqSQmJka0Wq2cPHlS7Ozs5N133x2vIUwYY52LhIQEUalUcvz4cbly5YqcPn1a3NzcJCQkZLyGMGHcvHlTqqurpbq6WgBIamqqVFdXy9WrV0VEJC4uTtatW6ePH/wkxq5du6ShoUEOHz7MT2IYo0OHDomzs7MolUpZsGCBfPfdd/pzvr6+Eh4ebhCfn58v7u7uolQqZfbs2VJcXHyfM564xjIXLi4uAmDIlpCQcP8Tn6DG+m/jr1iU3VtjnYuzZ8/KwoULxdzcXFxdXSU5OVn6+/vvc9YT01jmoq+vTxITE8XNzU0sLCzEyclJoqOj5ffff7//iU8wZ86cGfZvwOD9Dw8PF19f3yFtPD09RalUiqurq2RmZt73vO8lExGutxIRERGNtwn1ThkRERHRfxWLMiIiIiIjwKKMiIiIyAiwKCMiIiIyAizKiIiIiIwAizIiIiIiI8CijIiIiMgIsCgjIiIiMgIsyojIQFZWFmxsbMY7jX/NxMQEX3zxxagxGzZswIsvvnhf8iEi+qdYlBFNQBs2bICJicmQrampabxTQ1ZWlj4fhUIBR0dHbNy4Eb/++us96b+1tRWBgYEAgJaWFpiYmKCmpsYgJi0tDVlZWffkeiNJTEzUj9PU1BROTk6IiopCe3v7mPphAUn04DAb7wSI6P8jICAAmZmZBsemTp06TtkYsra2hlarhU6nQ21tLTZu3IgbN26gtLT0rvu2t7f/25gpU6bc9XX+idmzZ6OsrAwDAwNoaGhAREQEOjo6kJeXd1+uT0T/LVwpI5qgzM3NYW9vb7CZmpoiNTUVc+bMgZWVFZycnBAdHY2urq4R+6mtrcWyZcugUqlgbW2N+fPn49y5c/rzlZWVWLp0KSwtLeHk5ITY2Fj88ccfo+ZmYmICe3t7qNVqBAYGIjY2FmVlZeju7oZOp8Pbb78NR0dHmJubw9PTEyUlJfq2vb29iImJgYODAywsLODi4oK9e/ca9D34+HL69OkAgHnz5sHExARPPfUUAMPVp48//hhqtRo6nc4gx6CgIEREROj3CwsL4eXlBQsLC7i6uiIpKQn9/f2jjtPMzAz29vZ49NFHsXz5cqxZswZfffWV/vzAwAAiIyMxffp0WFpawsPDA2lpafrziYmJOHbsGAoLC/WrbuXl5QCA69evIyQkBDY2NrC1tUVQUBBaWlpGzYeIjBuLMqIHjEKhQHp6Oi5cuIBjx47h66+/xuuvvz5ifFhYGBwdHVFVVYXz588jLi4ODz30EADg8uXLCAgIwKpVq1BXV4e8vDxUVlYiJiZmTDlZWlpCp9Ohv78faWlpSElJwYEDB1BXVwd/f3+88MILuHTpEgAgPT0dRUVFyM/Ph1arRU5ODqZNmzZsvz/88AMAoKysDK2trfjss8+GxKxZswZtbW04c+aM/lh7eztKSkoQFhYGAKioqMD69euxbds21NfXIyMjA1lZWUhOTv7HY2xpaUFpaSmUSqX+mE6ng6OjIwoKClBfX4/4+Hi8+eabyM/PBwDs3LkTISEhCAgIQGtrK1pbW7F48WL09fXB398fKpUKFRUV0Gg0mDx5MgICAtDb2/uPcyIiIyNENOGEh4eLqampWFlZ6bfVq1cPG1tQUCAPP/ywfj8zM1OmTJmi31epVJKVlTVs28jISImKijI4VlFRIQqFQrq7u4dtc2f/jY2N4u7uLt7e3iIiolarJTk52aCNj4+PREdHi4jI1q1bxc/PT3Q63bD9A5DPP/9cRESam5sFgFRXVxvEhIeHS1BQkH4/KChIIiIi9PsZGRmiVqtlYGBARESefvpp2bNnj0Ef2dnZ4uDgMGwOIiIJCQmiUCjEyspKLCwsBIAAkNTU1BHbiIi8+uqrsmrVqhFzHby2h4eHwT34888/xdLSUkpLS0ftn4iMF98pI5qgli1bhg8//FC/b2VlBeD2qtHevXtx8eJFdHZ2or+/Hz09Pbh16xYmTZo0pJ8dO3bglVdeQXZ2tv4RnJubG4Dbjzbr6uqQk5OjjxcR6HQ6NDc3Y9asWcPm1tHRgcmTJ0On06GnpwdPPvkkjhw5gs7OTty4cQNLliwxiF+yZAlqa2sB3H70+Mwzz8DDwwMBAQFYsWIFnn322bu6V2FhYdi0aRM++OADmJubIycnBy+99BIUCoV+nBqNxmBlbGBgYNT7BgAeHh4oKipCT08PPv30U9TU1GDr1q0GMYcPH8bRo0dx7do1dHd3o7e3F56enqPmW1tbi6amJqhUKoPjPT09uHz58r+4A0RkDFiUEU1QVlZWmDFjhsGxlpYWrFixAlu2bEFycjJsbW1RWVmJyMhI9Pb2DltcJCYmYu3atSguLsapU6eQkJCA3NxcrFy5El1dXdi8eTNiY2OHtHN2dh4xN5VKhR9//BEKhQIODg6wtLQEAHR2dv7tuLy8vNDc3IxTp06hrKwMISEhWL58OU6cOPG3bUfy/PPPQ0RQXFwMHx8fVFRU4ODBg/rzXV1dSEpKQnBw8JC2FhYWI/arVCr1c7Bv3z4899xzSEpKwjvvvAMAyM3Nxc6dO5GSkoJFixZBpVLh/fffx/fffz9qvl1dXZg/f75BMTzIWH7MQURjx6KM6AFy/vx56HQ6pKSk6FeBBt9fGo27uzvc3d2xfft2vPzyy8jMzMTKlSvh5eWF+vr6IcXf31EoFMO2sba2hlqthkajga+vr/64RqPBggULDOJCQ0MRGhqK1atXIyAgAO3t7bC1tTXob/D9rYGBgVHzsbCwQHBwMHJyctDU1AQPDw94eXnpz3t5eUGr1Y55nHfavXs3/Pz8sGXLFv04Fy9ejOjoaH3MnStdSqVySP5eXl7Iy8uDnZ0drK2t7yonIjIefNGf6AEyY8YM9PX14dChQ7hy5Qqys7Px0UcfjRjf3d2NmJgYlJeX4+rVq9BoNKiqqtI/lnzjjTdw9uxZxMTEoKamBpcuXUJhYeGYX/T/q127dmH//v3Iy8uDVqtFXFwcampqsG3bNgBAamoqjh8/josXL6KxsREFBQWwt7cf9oO3dnZ2sLS0RElJCX755Rd0dHSMeN2wsDAUFxfj6NGj+hf8B8XHx+OTTz5BUlISLly4gIaGBuTm5mL37t1jGtuiRYswd+5c7NmzBwAwc+ZMnDt3DqWlpWhsbMRbb72FqqoqgzbTpk1DXV0dtFotfvvtN/T19SEsLAyPPPIIgoKCUFFRgebmZpSXlyM2NhY//fTTmHIiIuPBoozoAfL4448jNTUV+/fvx2OPPYacnByDz0ncydTUFG1tbVi/fj3c3d0REhKCwMBAJCUlAQDmzp2Lb775Bo2NjVi6dCnmzZuH+Ph4qNXqf51jbGwsduzYgddeew1z5sxBSUkJioqKMHPmTAC3H32+99578Pb2ho+PD1paWvDll1/qV/7+yszMDOnp6cjIyIBarUZQUNCI1/Xz84OtrS20Wi3Wrl1rcM7f3x8nT57E6dOn4ePjgyeeeAIHDx6Ei4vLmMe3fft2HDlyBNevX8fmzZsRHByM0NBQLFy4EG1tbQarZgCwadMmeHh4wNvbG1OnToVGo8GkSZPw7bffwtnZGcHBwZg1axYiIyPR09PDlTOi/zATEZHxToKIiIjoQceVMiIiIiIjwKKMiIiIyAiwKCMiIiIyAizKiIiIiIwAizIiIiIiI8CijIiIiMgIsCgjIiIiMgIsyoiIiIiMAIsyIiIiIiPAooyIiIjICLAoIyIiIjICLMqIiIiIjMD/APqXaUHfwE9WAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 66.64873790740967\n",
+      "lead_lag: False inv_rest: True thres_distance: 16000 auc: 0.7872241999999998\n",
+      "Threshold distance:  32000\n",
+      "lead_lag:  False\n",
+      "inv_reset:  True\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 13.570491790771484\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 73.1102991104126\n",
+      "lead_lag: False inv_rest: True thres_distance: 32000 auc: 0.78283072\n",
+      "Threshold distance:  4000\n",
+      "lead_lag:  False\n",
+      "inv_reset:  False\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 9.498934030532837\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 18.494549036026\n",
+      "lead_lag: False inv_rest: False thres_distance: 4000 auc: 0.80501948\n",
+      "Threshold distance:  8000\n",
+      "lead_lag:  False\n",
+      "inv_reset:  False\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 9.560570001602173\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 18.934290885925293\n",
+      "lead_lag: False inv_rest: False thres_distance: 8000 auc: 0.80946924\n",
+      "Threshold distance:  16000\n",
+      "lead_lag:  False\n",
+      "inv_reset:  False\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 9.271188974380493\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 18.92277979850769\n",
+      "lead_lag: False inv_rest: False thres_distance: 16000 auc: 0.79710896\n",
+      "Threshold distance:  32000\n",
+      "lead_lag:  False\n",
+      "inv_reset:  False\n",
+      "len(data.corpus) 5000\n",
+      "len(data.test_inlier) 5000\n",
+      "len(data.test_outlier) 5000\n",
+      "fit_time: 9.519912004470825\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "compute_auc_time: 19.96116018295288\n",
+      "lead_lag: False inv_rest: False thres_distance: 32000 auc: 0.78804452\n",
+      "CPU times: user 5h 31min 42s, sys: 9min 42s, total: 5h 41min 24s\n",
+      "Wall time: 54min 25s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "lead_lag_and_inv_rest_and_thres_distance_to_auc = {}\n",
+    "depth = 3\n",
+    "for lead_lag in [True, False]:\n",
+    "    augmentation_list1 = []\n",
+    "    lead_lag_and_inv_rest_and_thres_distance_to_auc[lead_lag] = {}\n",
+    "    if lead_lag:\n",
+    "        augmentation_list1.append(\"leadlag\")\n",
+    "    for inv_reset in [True, False]:\n",
+    "        lead_lag_and_inv_rest_and_thres_distance_to_auc[lead_lag][inv_reset] = {}\n",
+    "        if inv_reset:\n",
+    "            augmentation_list = augmentation_list1 + [\"ir\"]\n",
+    "        else:\n",
+    "            augmentation_list = augmentation_list1\n",
+    "\n",
+    "        if (not inv_reset) and (not lead_lag):\n",
+    "            augmentation_list = None\n",
+    "\n",
+    "        for thres_distance in [4000, 8000, 16000, 32000]:\n",
+    "            signature_maha_knn = SignatureMahalanobisKNN(random_state=seed)\n",
+    "            data.load_ship_movements(\n",
+    "                thres_distance=thres_distance,\n",
+    "            )\n",
+    "            print(\"Threshold distance: \", thres_distance)\n",
+    "            print(\"lead_lag: \", lead_lag)\n",
+    "            print(\"inv_reset: \", inv_reset)\n",
+    "            print(\"len(data.corpus)\", len(data.corpus))\n",
+    "            print(\"len(data.test_inlier)\", len(data.test_inlier))\n",
+    "            print(\"len(data.test_outlier)\", len(data.test_outlier))\n",
+    "\n",
+    "            # Measure the time spent on fit\n",
+    "            start_time = time.time()\n",
+    "            signature_maha_knn.fit(\n",
+    "                knn_library=\"pynndescent\",\n",
+    "                X_train=data.corpus,\n",
+    "                signature_kwargs={\n",
+    "                    \"augmentation_list\": augmentation_list,\n",
+    "                    \"depth\": depth,\n",
+    "                },\n",
+    "            )\n",
+    "            fit_time = time.time() - start_time\n",
+    "            print(f\"fit_time: {fit_time}\")\n",
+    "\n",
+    "            # Measure the time spent on compute_auc\n",
+    "            start_time = time.time()\n",
+    "            inlier_dists = signature_maha_knn.conformance(\n",
+    "                data.test_inlier, n_neighbors=n_neighbours\n",
+    "            )\n",
+    "            outlier_dists = signature_maha_knn.conformance(\n",
+    "                data.test_outlier, n_neighbors=n_neighbours\n",
+    "            )\n",
+    "            auc = compute_auc_given_dists(\n",
+    "                inlier_dists,\n",
+    "                outlier_dists,\n",
+    "                plot=True,\n",
+    "                title=f\"\\nThreshold distance: {thres_distance} | lead_lag: {lead_lag} | inv_reset: {inv_reset} (depth={depth})\",\n",
+    "            )\n",
+    "            auc = compute_auc_given_dists(inlier_dists, outlier_dists)\n",
+    "            compute_auc_time = time.time() - start_time\n",
+    "            print(f\"compute_auc_time: {compute_auc_time}\")\n",
+    "\n",
+    "            print(\n",
+    "                f\"lead_lag: {lead_lag}\",\n",
+    "                f\"inv_rest: {inv_reset}\",\n",
+    "                f\"thres_distance: {thres_distance}\",\n",
+    "                f\"auc: {auc}\",\n",
+    "            )\n",
+    "\n",
+    "            lead_lag_and_inv_rest_and_thres_distance_to_auc[lead_lag][inv_reset][\n",
+    "                thres_distance\n",
+    "            ] = auc"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "12e4c956-0b49-4d06-9ff0-201cd1f3a27e",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "### UCR data example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "303b9c84",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# data = Data.Data(if_sample=True, n_samples=[100, 10, 10])\n",
+    "data = Data.Data(if_sample=False)\n",
+    "data_full_names = [\n",
+    "    \"Adiac\",\n",
+    "    \"ArrowHead\",\n",
+    "    \"Beef\",\n",
+    "    \"BeetleFly\",\n",
+    "    \"BirdChicken\",\n",
+    "    \"CBF\",\n",
+    "    \"ChlorineConcentration\",\n",
+    "    \"Coffee\",\n",
+    "    \"ECG200\",\n",
+    "    \"ECGFiveDays\",\n",
+    "    \"FaceFour\",\n",
+    "    \"GunPoint\",\n",
+    "    \"Ham\",\n",
+    "    \"Herring\",\n",
+    "    \"Lightning2\",\n",
+    "    \"Lightning7\",\n",
+    "    \"Meat\",\n",
+    "    \"MedicalImages\",\n",
+    "    \"MoteStrain\",\n",
+    "    \"Plane\",\n",
+    "    \"Strawberry\",\n",
+    "    \"Symbols\",\n",
+    "    \"ToeSegmentation1\",\n",
+    "    \"ToeSegmentation2\",\n",
+    "    \"Trace\",\n",
+    "    \"TwoLeadECG\",\n",
+    "    \"Wafer\",\n",
+    "    \"Wine\",\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n_neighbours = 10"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "a22e802a-c924-4ead-9c8d-0fb3c262e84d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n",
+      "/Users/rchan/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:264: RuntimeWarning: invalid value encountered in divide\n",
+      "  rho = numerator / denominator\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 4h 3min 20s, sys: 1h 6min 6s, total: 5h 9min 27s\n",
+      "Wall time: 54min 29s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "depth = 5\n",
+    "signature_maha_knn = SignatureMahalanobisKNN(random_state=seed)\n",
+    "\n",
+    "iter = 10\n",
+    "data_names = data_full_names\n",
+    "\n",
+    "anomaly_level = 0.001\n",
+    "roughpathsbest, roughpathserror = UCR_data_support.compute_best_and_std(\n",
+    "    data_set=data_names,\n",
+    "    iter=iter,\n",
+    "    data=data,\n",
+    "    signature_maha_knn=signature_maha_knn,\n",
+    "    depth=depth,\n",
+    "    n_neighbours=n_neighbours,\n",
+    "    anomaly_level=anomaly_level,\n",
+    ")\n",
+    "\n",
+    "anomaly_level = 0.05\n",
+    "roughpathsbest, roughpathserror = UCR_data_support.compute_best_and_std(\n",
+    "    data_set=data_names,\n",
+    "    iter=iter,\n",
+    "    data=data,\n",
+    "    signature_maha_knn=signature_maha_knn,\n",
+    "    depth=depth,\n",
+    "    n_neighbours=n_neighbours,\n",
+    "    anomaly_level=anomaly_level,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "e6043a4d-1ba9-4e77-acbb-5a758d9c1693",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2, figsize=(12, 6))\n",
+    "comparison_table_1 = UCR_data_support.plot_ucr_result(\n",
+    "    roughpathsbest, roughpathserror, anomaly_level=0.001, ax_num=0, axs=axs\n",
+    ")\n",
+    "comparison_table_2 = UCR_data_support.plot_ucr_result(\n",
+    "    roughpathsbest, roughpathserror, anomaly_level=0.05, ax_num=1, axs=axs\n",
+    ")\n",
+    "fig.savefig(\"benchmark.pdf\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "4c52ba35-77cf-45e4-bc24-b8084a0a6583",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>0</th>\n",
+       "      <th>1</th>\n",
+       "      <th>2</th>\n",
+       "      <th>3</th>\n",
+       "      <th>4</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Adiac</td>\n",
+       "      <td>0.998026</td>\n",
+       "      <td>0.064889</td>\n",
+       "      <td>0.99</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>ArrowHead</td>\n",
+       "      <td>0.758741</td>\n",
+       "      <td>0.06979</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Beef</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>BeetleFly</td>\n",
+       "      <td>0.894737</td>\n",
+       "      <td>0.160296</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>0.08</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>BirdChicken</td>\n",
+       "      <td>0.921053</td>\n",
+       "      <td>0.143551</td>\n",
+       "      <td>0.85</td>\n",
+       "      <td>0.15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>CBF</td>\n",
+       "      <td>0.875265</td>\n",
+       "      <td>0.01985</td>\n",
+       "      <td>0.8</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>ChlorineConcentration</td>\n",
+       "      <td>0.855262</td>\n",
+       "      <td>0.01644</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>Coffee</td>\n",
+       "      <td>0.730769</td>\n",
+       "      <td>0.097301</td>\n",
+       "      <td>0.84</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>ECG200</td>\n",
+       "      <td>0.759014</td>\n",
+       "      <td>0.062465</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>ECGFiveDays</td>\n",
+       "      <td>0.824828</td>\n",
+       "      <td>0.024429</td>\n",
+       "      <td>0.94</td>\n",
+       "      <td>0.11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>FaceFour</td>\n",
+       "      <td>0.843496</td>\n",
+       "      <td>0.060361</td>\n",
+       "      <td>0.94</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>GunPoint</td>\n",
+       "      <td>0.768229</td>\n",
+       "      <td>0.062154</td>\n",
+       "      <td>0.75</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>Ham</td>\n",
+       "      <td>0.509346</td>\n",
+       "      <td>0.014708</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>Herring</td>\n",
+       "      <td>0.539583</td>\n",
+       "      <td>0.06667</td>\n",
+       "      <td>0.52</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>Lightning2</td>\n",
+       "      <td>0.780435</td>\n",
+       "      <td>0.044914</td>\n",
+       "      <td>0.63</td>\n",
+       "      <td>0.07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>Lightning7</td>\n",
+       "      <td>0.955285</td>\n",
+       "      <td>0.091263</td>\n",
+       "      <td>0.73</td>\n",
+       "      <td>0.11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>Meat</td>\n",
+       "      <td>0.967949</td>\n",
+       "      <td>0.073</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>MedicalImages</td>\n",
+       "      <td>0.973492</td>\n",
+       "      <td>0.039607</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>MoteStrain</td>\n",
+       "      <td>0.840384</td>\n",
+       "      <td>0.012495</td>\n",
+       "      <td>0.74</td>\n",
+       "      <td>0.01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>Plane</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.027236</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>Strawberry</td>\n",
+       "      <td>0.861812</td>\n",
+       "      <td>0.012319</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21</th>\n",
+       "      <td>Symbols</td>\n",
+       "      <td>0.999409</td>\n",
+       "      <td>0.020256</td>\n",
+       "      <td>0.96</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>22</th>\n",
+       "      <td>ToeSegmentation1</td>\n",
+       "      <td>0.73829</td>\n",
+       "      <td>0.036519</td>\n",
+       "      <td>0.95</td>\n",
+       "      <td>0.01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23</th>\n",
+       "      <td>ToeSegmentation2</td>\n",
+       "      <td>0.764865</td>\n",
+       "      <td>0.039496</td>\n",
+       "      <td>0.88</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>24</th>\n",
+       "      <td>Trace</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.01688</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25</th>\n",
+       "      <td>TwoLeadECG</td>\n",
+       "      <td>0.783216</td>\n",
+       "      <td>0.017189</td>\n",
+       "      <td>0.89</td>\n",
+       "      <td>0.01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26</th>\n",
+       "      <td>Wafer</td>\n",
+       "      <td>0.834789</td>\n",
+       "      <td>0.022035</td>\n",
+       "      <td>0.56</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27</th>\n",
+       "      <td>Wine</td>\n",
+       "      <td>0.774476</td>\n",
+       "      <td>0.086879</td>\n",
+       "      <td>0.53</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                        0         1         2     3     4\n",
+       "0                   Adiac  0.998026  0.064889  0.99   0.1\n",
+       "1               ArrowHead  0.758741   0.06979  0.65  0.03\n",
+       "2                    Beef       1.0       0.0  0.57  0.15\n",
+       "3               BeetleFly  0.894737  0.160296   0.9  0.08\n",
+       "4             BirdChicken  0.921053  0.143551  0.85  0.15\n",
+       "5                     CBF  0.875265   0.01985   0.8  0.04\n",
+       "6   ChlorineConcentration  0.855262   0.01644   0.5   0.0\n",
+       "7                  Coffee  0.730769  0.097301  0.84  0.04\n",
+       "8                  ECG200  0.759014  0.062465   0.5  0.03\n",
+       "9             ECGFiveDays  0.824828  0.024429  0.94  0.11\n",
+       "10               FaceFour  0.843496  0.060361  0.94   0.1\n",
+       "11               GunPoint  0.768229  0.062154  0.75  0.03\n",
+       "12                    Ham  0.509346  0.014708   0.5  0.02\n",
+       "13                Herring  0.539583   0.06667  0.52  0.02\n",
+       "14             Lightning2  0.780435  0.044914  0.63  0.07\n",
+       "15             Lightning7  0.955285  0.091263  0.73  0.11\n",
+       "16                   Meat  0.967949     0.073   1.0  0.04\n",
+       "17          MedicalImages  0.973492  0.039607   0.9  0.03\n",
+       "18             MoteStrain  0.840384  0.012495  0.74  0.01\n",
+       "19                  Plane       1.0  0.027236   1.0  0.04\n",
+       "20             Strawberry  0.861812  0.012319  0.77  0.03\n",
+       "21                Symbols  0.999409  0.020256  0.96  0.02\n",
+       "22       ToeSegmentation1   0.73829  0.036519  0.95  0.01\n",
+       "23       ToeSegmentation2  0.764865  0.039496  0.88  0.02\n",
+       "24                  Trace       1.0   0.01688   1.0  0.04\n",
+       "25             TwoLeadECG  0.783216  0.017189  0.89  0.01\n",
+       "26                  Wafer  0.834789  0.022035  0.56  0.02\n",
+       "27                   Wine  0.774476  0.086879  0.53  0.02"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "comparison_table_1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "168f43f7-d6a7-49de-b95a-336ac6b2cb1c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>0</th>\n",
+       "      <th>1</th>\n",
+       "      <th>2</th>\n",
+       "      <th>3</th>\n",
+       "      <th>4</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Adiac</td>\n",
+       "      <td>0.998026</td>\n",
+       "      <td>0.064889</td>\n",
+       "      <td>0.99</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>ArrowHead</td>\n",
+       "      <td>0.758741</td>\n",
+       "      <td>0.06979</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Beef</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>BeetleFly</td>\n",
+       "      <td>0.894737</td>\n",
+       "      <td>0.160296</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>0.08</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>BirdChicken</td>\n",
+       "      <td>0.921053</td>\n",
+       "      <td>0.143551</td>\n",
+       "      <td>0.85</td>\n",
+       "      <td>0.15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>CBF</td>\n",
+       "      <td>0.875265</td>\n",
+       "      <td>0.01985</td>\n",
+       "      <td>0.8</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>ChlorineConcentration</td>\n",
+       "      <td>0.855262</td>\n",
+       "      <td>0.01644</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>Coffee</td>\n",
+       "      <td>0.730769</td>\n",
+       "      <td>0.097301</td>\n",
+       "      <td>0.84</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>ECG200</td>\n",
+       "      <td>0.759014</td>\n",
+       "      <td>0.062465</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>ECGFiveDays</td>\n",
+       "      <td>0.824828</td>\n",
+       "      <td>0.024429</td>\n",
+       "      <td>0.94</td>\n",
+       "      <td>0.11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>FaceFour</td>\n",
+       "      <td>0.843496</td>\n",
+       "      <td>0.060361</td>\n",
+       "      <td>0.94</td>\n",
+       "      <td>0.1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>GunPoint</td>\n",
+       "      <td>0.768229</td>\n",
+       "      <td>0.062154</td>\n",
+       "      <td>0.75</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>Ham</td>\n",
+       "      <td>0.509346</td>\n",
+       "      <td>0.014708</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>Herring</td>\n",
+       "      <td>0.539583</td>\n",
+       "      <td>0.06667</td>\n",
+       "      <td>0.52</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>Lightning2</td>\n",
+       "      <td>0.780435</td>\n",
+       "      <td>0.044914</td>\n",
+       "      <td>0.63</td>\n",
+       "      <td>0.07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>Lightning7</td>\n",
+       "      <td>0.955285</td>\n",
+       "      <td>0.091263</td>\n",
+       "      <td>0.73</td>\n",
+       "      <td>0.11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>16</th>\n",
+       "      <td>Meat</td>\n",
+       "      <td>0.967949</td>\n",
+       "      <td>0.073</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>17</th>\n",
+       "      <td>MedicalImages</td>\n",
+       "      <td>0.973492</td>\n",
+       "      <td>0.039607</td>\n",
+       "      <td>0.9</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>18</th>\n",
+       "      <td>MoteStrain</td>\n",
+       "      <td>0.840384</td>\n",
+       "      <td>0.012495</td>\n",
+       "      <td>0.74</td>\n",
+       "      <td>0.01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>19</th>\n",
+       "      <td>Plane</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.027236</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>20</th>\n",
+       "      <td>Strawberry</td>\n",
+       "      <td>0.861812</td>\n",
+       "      <td>0.012319</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.03</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>21</th>\n",
+       "      <td>Symbols</td>\n",
+       "      <td>0.999409</td>\n",
+       "      <td>0.020256</td>\n",
+       "      <td>0.96</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>22</th>\n",
+       "      <td>ToeSegmentation1</td>\n",
+       "      <td>0.73829</td>\n",
+       "      <td>0.036519</td>\n",
+       "      <td>0.95</td>\n",
+       "      <td>0.01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>23</th>\n",
+       "      <td>ToeSegmentation2</td>\n",
+       "      <td>0.764865</td>\n",
+       "      <td>0.039496</td>\n",
+       "      <td>0.88</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>24</th>\n",
+       "      <td>Trace</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.01688</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.04</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25</th>\n",
+       "      <td>TwoLeadECG</td>\n",
+       "      <td>0.783216</td>\n",
+       "      <td>0.017189</td>\n",
+       "      <td>0.89</td>\n",
+       "      <td>0.01</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>26</th>\n",
+       "      <td>Wafer</td>\n",
+       "      <td>0.834789</td>\n",
+       "      <td>0.022035</td>\n",
+       "      <td>0.56</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>27</th>\n",
+       "      <td>Wine</td>\n",
+       "      <td>0.774476</td>\n",
+       "      <td>0.086879</td>\n",
+       "      <td>0.53</td>\n",
+       "      <td>0.02</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                        0         1         2     3     4\n",
+       "0                   Adiac  0.998026  0.064889  0.99   0.1\n",
+       "1               ArrowHead  0.758741   0.06979  0.65  0.03\n",
+       "2                    Beef       1.0       0.0  0.57  0.15\n",
+       "3               BeetleFly  0.894737  0.160296   0.9  0.08\n",
+       "4             BirdChicken  0.921053  0.143551  0.85  0.15\n",
+       "5                     CBF  0.875265   0.01985   0.8  0.04\n",
+       "6   ChlorineConcentration  0.855262   0.01644   0.5   0.0\n",
+       "7                  Coffee  0.730769  0.097301  0.84  0.04\n",
+       "8                  ECG200  0.759014  0.062465   0.5  0.03\n",
+       "9             ECGFiveDays  0.824828  0.024429  0.94  0.11\n",
+       "10               FaceFour  0.843496  0.060361  0.94   0.1\n",
+       "11               GunPoint  0.768229  0.062154  0.75  0.03\n",
+       "12                    Ham  0.509346  0.014708   0.5  0.02\n",
+       "13                Herring  0.539583   0.06667  0.52  0.02\n",
+       "14             Lightning2  0.780435  0.044914  0.63  0.07\n",
+       "15             Lightning7  0.955285  0.091263  0.73  0.11\n",
+       "16                   Meat  0.967949     0.073   1.0  0.04\n",
+       "17          MedicalImages  0.973492  0.039607   0.9  0.03\n",
+       "18             MoteStrain  0.840384  0.012495  0.74  0.01\n",
+       "19                  Plane       1.0  0.027236   1.0  0.04\n",
+       "20             Strawberry  0.861812  0.012319  0.77  0.03\n",
+       "21                Symbols  0.999409  0.020256  0.96  0.02\n",
+       "22       ToeSegmentation1   0.73829  0.036519  0.95  0.01\n",
+       "23       ToeSegmentation2  0.764865  0.039496  0.88  0.02\n",
+       "24                  Trace       1.0   0.01688   1.0  0.04\n",
+       "25             TwoLeadECG  0.783216  0.017189  0.89  0.01\n",
+       "26                  Wafer  0.834789  0.022035  0.56  0.02\n",
+       "27                   Wine  0.774476  0.086879  0.53  0.02"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "comparison_table_2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "847fb50d-44b1-42fc-84e5-f5088493a60b",
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
+   "source": [
+    "### Language dataset example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "887c4530-28dd-4df7-b1f5-58c74e40f0eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "len(data.corpus) 63862\n",
+      "len(data.test_inlier) 16138\n",
+      "len(data.test_outlier) 15862\n"
+     ]
+    }
+   ],
+   "source": [
+    "data = Data.Data(if_sample=False)\n",
+    "data.load_language_data()\n",
+    "print(\"len(data.corpus)\", len(data.corpus))\n",
+    "print(\"len(data.test_inlier)\", len(data.test_inlier))\n",
+    "print(\"len(data.test_outlier)\", len(data.test_outlier))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb0e4bf6-b7eb-4c9b-a4bf-63cd343b4378",
+   "metadata": {},
+   "source": [
+    "##### Takes a while as signature dimension very large"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "87ec6dc8-75f7-436b-8528-00093a576ba7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/rchan/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_signature_method.py:100: UserWarning: iisignature backend of SignatureTransformer is experimental and not systematically tested, due to lack of stable installation process for iisignature via pip. Kindly exercise caution, and report any issues on the sktime issue tracker.\n",
+      "  warn(\n"
+     ]
+    },
+    {
+     "ename": "ValueError",
+     "evalue": "iisignature does not name a valid backend",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "File \u001b[0;32m<timed exec>:5\u001b[0m\n",
+      "File \u001b[0;32m~/Library/CloudStorage/OneDrive-TheAlanTuringInstitute/rough_paths/signature_mahalanobis_knn/src/signature_mahalanobis_knn/sig_mahal_knn.py:142\u001b[0m, in \u001b[0;36mSignatureMahalanobisKNN.fit\u001b[0;34m(self, knn_library, X_train, signatures_train, knn_algorithm, signature_kwargs, **kwargs)\u001b[0m\n\u001b[1;32m    137\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignature_transform \u001b[39m=\u001b[39m SignatureTransformer(\n\u001b[1;32m    138\u001b[0m         \u001b[39m*\u001b[39m\u001b[39m*\u001b[39msignature_kwargs,\n\u001b[1;32m    139\u001b[0m     )\n\u001b[1;32m    141\u001b[0m     \u001b[39m# compute signatures\u001b[39;00m\n\u001b[0;32m--> 142\u001b[0m     sigs \u001b[39m=\u001b[39m Parallel(n_jobs\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mn_jobs)(\n\u001b[1;32m    143\u001b[0m         delayed(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_transform\u001b[39m.\u001b[39;49mfit_transform)(X_train[i])\n\u001b[1;32m    144\u001b[0m         \u001b[39mfor\u001b[39;49;00m i \u001b[39min\u001b[39;49;00m \u001b[39mrange\u001b[39;49m(\u001b[39mlen\u001b[39;49m(X_train))\n\u001b[1;32m    145\u001b[0m     )\n\u001b[1;32m    146\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msignatures_train \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(pd\u001b[39m.\u001b[39mconcat(sigs))\n\u001b[1;32m    147\u001b[0m \u001b[39melse\u001b[39;00m:\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1863\u001b[0m, in \u001b[0;36mParallel.__call__\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1861\u001b[0m     output \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_sequential_output(iterable)\n\u001b[1;32m   1862\u001b[0m     \u001b[39mnext\u001b[39m(output)\n\u001b[0;32m-> 1863\u001b[0m     \u001b[39mreturn\u001b[39;00m output \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mreturn_generator \u001b[39melse\u001b[39;00m \u001b[39mlist\u001b[39;49m(output)\n\u001b[1;32m   1865\u001b[0m \u001b[39m# Let's create an ID that uniquely identifies the current call. If the\u001b[39;00m\n\u001b[1;32m   1866\u001b[0m \u001b[39m# call is interrupted early and that the same instance is immediately\u001b[39;00m\n\u001b[1;32m   1867\u001b[0m \u001b[39m# re-used, this id will be used to prevent workers that were\u001b[39;00m\n\u001b[1;32m   1868\u001b[0m \u001b[39m# concurrently finalizing a task from the previous call to run the\u001b[39;00m\n\u001b[1;32m   1869\u001b[0m \u001b[39m# callback.\u001b[39;00m\n\u001b[1;32m   1870\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_lock:\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/joblib/parallel.py:1792\u001b[0m, in \u001b[0;36mParallel._get_sequential_output\u001b[0;34m(self, iterable)\u001b[0m\n\u001b[1;32m   1790\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_batches \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m   1791\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_dispatched_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[0;32m-> 1792\u001b[0m res \u001b[39m=\u001b[39m func(\u001b[39m*\u001b[39;49margs, \u001b[39m*\u001b[39;49m\u001b[39m*\u001b[39;49mkwargs)\n\u001b[1;32m   1793\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mn_completed_tasks \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m   1794\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprint_progress()\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:669\u001b[0m, in \u001b[0;36mBaseTransformer.fit_transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m    604\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"Fit to data, then transform it.\u001b[39;00m\n\u001b[1;32m    605\u001b[0m \n\u001b[1;32m    606\u001b[0m \u001b[39mFits the transformer to X and y and returns a transformed version of X.\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    665\u001b[0m \u001b[39m        Example: i-th instance of the output is the i-th window running over `X`\u001b[39;00m\n\u001b[1;32m    666\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m    667\u001b[0m \u001b[39m# Non-optimized default implementation; override when a better\u001b[39;00m\n\u001b[1;32m    668\u001b[0m \u001b[39m# method is possible for a given algorithm.\u001b[39;00m\n\u001b[0;32m--> 669\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mfit(X, y)\u001b[39m.\u001b[39;49mtransform(X, y)\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:583\u001b[0m, in \u001b[0;36mBaseTransformer.transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m    580\u001b[0m X_inner, y_inner, metadata \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_X_y(X\u001b[39m=\u001b[39mX, y\u001b[39m=\u001b[39my, return_metadata\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m    582\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(X_inner, VectorizedDF):\n\u001b[0;32m--> 583\u001b[0m     Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_transform(X\u001b[39m=\u001b[39;49mX_inner, y\u001b[39m=\u001b[39;49my_inner)\n\u001b[1;32m    584\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    585\u001b[0m     \u001b[39m# otherwise we call the vectorized version of predict\u001b[39;00m\n\u001b[1;32m    586\u001b[0m     Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_vectorize(\u001b[39m\"\u001b[39m\u001b[39mtransform\u001b[39m\u001b[39m\"\u001b[39m, X\u001b[39m=\u001b[39mX_inner, y\u001b[39m=\u001b[39my_inner)\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_signature_method.py:142\u001b[0m, in \u001b[0;36mSignatureTransformer._transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m    141\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_transform\u001b[39m(\u001b[39mself\u001b[39m, X, y\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m):\n\u001b[0;32m--> 142\u001b[0m     \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msignature_method\u001b[39m.\u001b[39;49mtransform(X)\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sklearn/pipeline.py:696\u001b[0m, in \u001b[0;36mPipeline.transform\u001b[0;34m(self, X)\u001b[0m\n\u001b[1;32m    694\u001b[0m Xt \u001b[39m=\u001b[39m X\n\u001b[1;32m    695\u001b[0m \u001b[39mfor\u001b[39;00m _, _, transform \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_iter():\n\u001b[0;32m--> 696\u001b[0m     Xt \u001b[39m=\u001b[39m transform\u001b[39m.\u001b[39;49mtransform(Xt)\n\u001b[1;32m    697\u001b[0m \u001b[39mreturn\u001b[39;00m Xt\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/base.py:583\u001b[0m, in \u001b[0;36mBaseTransformer.transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m    580\u001b[0m X_inner, y_inner, metadata \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_check_X_y(X\u001b[39m=\u001b[39mX, y\u001b[39m=\u001b[39my, return_metadata\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[1;32m    582\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(X_inner, VectorizedDF):\n\u001b[0;32m--> 583\u001b[0m     Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_transform(X\u001b[39m=\u001b[39;49mX_inner, y\u001b[39m=\u001b[39;49my_inner)\n\u001b[1;32m    584\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m    585\u001b[0m     \u001b[39m# otherwise we call the vectorized version of predict\u001b[39;00m\n\u001b[1;32m    586\u001b[0m     Xt \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_vectorize(\u001b[39m\"\u001b[39m\u001b[39mtransform\u001b[39m\u001b[39m\"\u001b[39m, X\u001b[39m=\u001b[39mX_inner, y\u001b[39m=\u001b[39my_inner)\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/sktime/transformations/panel/signature_based/_compute.py:68\u001b[0m, in \u001b[0;36m_WindowSignatureTransform._transform\u001b[0;34m(self, X, y)\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mesig\u001b[39;00m\n\u001b[1;32m     67\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mbackend \u001b[39m==\u001b[39m \u001b[39m\"\u001b[39m\u001b[39miisignature\u001b[39m\u001b[39m\"\u001b[39m:\n\u001b[0;32m---> 68\u001b[0m     esig\u001b[39m.\u001b[39;49mset_backend(\u001b[39m\"\u001b[39;49m\u001b[39miisignature\u001b[39;49m\u001b[39m\"\u001b[39;49m)\n\u001b[1;32m     70\u001b[0m depth \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msig_depth\n\u001b[1;32m     71\u001b[0m data \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mswapaxes(X, \u001b[39m1\u001b[39m, \u001b[39m2\u001b[39m)\n",
+      "File \u001b[0;32m~/opt/miniconda3/envs/anomaly-detection-paper/lib/python3.9/site-packages/esig/backends.py:47\u001b[0m, in \u001b[0;36mset_backend\u001b[0;34m(cls_or_name)\u001b[0m\n\u001b[1;32m     45\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(cls_or_name, \u001b[39mstr\u001b[39m):\n\u001b[1;32m     46\u001b[0m     \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m cls_or_name \u001b[39min\u001b[39;00m BACKENDS:\n\u001b[0;32m---> 47\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39m%s\u001b[39;00m\u001b[39m does not name a valid backend\u001b[39m\u001b[39m\"\u001b[39m \u001b[39m%\u001b[39m cls_or_name)\n\u001b[1;32m     48\u001b[0m     _BACKEND_CONTAINER\u001b[39m.\u001b[39mcontext \u001b[39m=\u001b[39m BACKENDS[cls_or_name]()\n\u001b[1;32m     49\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39misinstance\u001b[39m(cls_or_name, BackendBase):\n",
+      "\u001b[0;31mValueError\u001b[0m: iisignature does not name a valid backend"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "\n",
+    "depth = 2\n",
+    "signature_maha_knn = SignatureMahalanobisKNN(random_state=seed)\n",
+    "# Measure the time spent on fit\n",
+    "start_time = time.time()\n",
+    "signature_maha_knn.fit(\n",
+    "    knn_library=\"pynndescent\",\n",
+    "    X_train=data.corpus,\n",
+    "    signature_kwargs={\n",
+    "        \"augmentation_list\": None,\n",
+    "        \"depth\": depth,\n",
+    "        \"backend\": \"iisignature\",\n",
+    "    },\n",
+    ")\n",
+    "fit_time = time.time() - start_time\n",
+    "print(f\"fit_time: {fit_time}\")\n",
+    "\n",
+    "# Measure the time spent on conformance\n",
+    "start_time = time.time()\n",
+    "inlier_dists = signature_maha_knn.conformance(\n",
+    "    data.test_inlier, n_neighbors=n_neighbours\n",
+    ")\n",
+    "outlier_dists = signature_maha_knn.conformance(\n",
+    "    data.test_outlier, n_neighbors=n_neighbours\n",
+    ")\n",
+    "compute_auc_time = time.time() - start_time\n",
+    "print(f\"compute_auc_time: {compute_auc_time}\")\n",
+    "\n",
+    "auc = compute_auc_given_dists(\n",
+    "    all_inlier_dists,\n",
+    "    all_outlier_dists,\n",
+    "    plot=True,\n",
+    "    title=f\"Language One-Hot (depth={depth})\",\n",
+    ")\n",
+    "print(\"Overall, \", \"depth: \", depth, \"AUC: \", auc)"
+   ]
+  }
+ ],
+ "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.9.18"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/pyproject.toml b/pyproject.toml
index 767f6cf..e9855c2 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,7 +29,7 @@ classifiers = [
 ]
 dynamic = ["version"]
 dependencies = [
-  "sktime",
+  "sktime >= 0.24.1",
   "numpy",
   "scikit-learn",
   "pynndescent",
@@ -38,6 +38,9 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+signatures = [
+  'esig; python_version < "3.10"',
+]
 test = [
   "pytest >=6",
   "pytest-cov >=3",
diff --git a/src/signature_mahalanobis_knn/mahal_distance.py b/src/signature_mahalanobis_knn/mahal_distance.py
index a4edd58..53c7146 100644
--- a/src/signature_mahalanobis_knn/mahal_distance.py
+++ b/src/signature_mahalanobis_knn/mahal_distance.py
@@ -10,6 +10,7 @@ def __init__(
         subspace_thres: float = 1e-3,
         svd_thres: float = 1e-12,
         zero_thres: float = 1e-15,
+        default_dtype: np.dtype = np.float64,
     ):
         """
         After fit is called, becomes callable and intended to be used
@@ -40,7 +41,7 @@ def __init__(
         self.S: np.ndarray | None = None
         # numerical rank of the corpus
         self.numerical_rank: int | None = None
-        self.default_dtype = np.float32
+        self.default_dtype = default_dtype
 
     def fit(self, X: np.ndarray, y: None = None, **kwargs) -> None:  # noqa: ARG002
         """
@@ -57,9 +58,10 @@ def fit(self, X: np.ndarray, y: None = None, **kwargs) -> None:  # noqa: ARG002
         self.mu = np.mean(X, axis=0)
         X = X - self.mu
 
-        _, S, Vt = np.linalg.svd(X)
+        U, S, Vt = np.linalg.svd(X)
         k = np.sum(self.svd_thres <= S)  # detected numerical rank
         self.numerical_rank = k
+        self.U = U[:, :k].astype(self.default_dtype)
         self.Vt = Vt[:k].astype(self.default_dtype)
         self.S = S[:k].astype(self.default_dtype)
 
@@ -83,7 +85,7 @@ def calc_distance(
         x2 : np.ndarray
             One-dimensional array.
         Vt : np.ndarray
-            Two-dimensional arrat, truncated right singular matrix transposed of the corpus.
+            Two-dimensional array, truncated right singular matrix transposed of the corpus.
         S : np.ndarray
             One-dimensional array, truncated singular values of the corpus.
         subspace_thres : float
diff --git a/src/signature_mahalanobis_knn/sig_mahal_knn.py b/src/signature_mahalanobis_knn/sig_mahal_knn.py
index 5e4d97c..eacbd41 100644
--- a/src/signature_mahalanobis_knn/sig_mahal_knn.py
+++ b/src/signature_mahalanobis_knn/sig_mahal_knn.py
@@ -16,6 +16,7 @@ class SignatureMahalanobisKNN:
     def __init__(
         self,
         n_jobs: int = 1,
+        random_state: int | None = None,
     ):
         """
         Parameters
@@ -23,45 +24,49 @@ def __init__(
         n_jobs : int, optional
             Parameter for joblib, number of parallel processors to use, by default 1.
             -1 means using all processors, -2 means using all processors but one.
+        random_state : int | None, optional
+            Random state for the knn library, by default None.
         """
-        self.signature_transform = None
-        self.n_jobs = n_jobs
-        self.mahal_distance = None
-        self.signatures = None
-        self.knn = None
+        self.signature_transform: object | None = None
+        self.n_jobs: int = n_jobs
+        self.mahal_distance: Mahalanobis | None = None
+        self.signatures_train: np.array | None = None
+        self.knn: NearestNeighbors | NNDescent | None = None
+        self.random_state: int | None = random_state
 
     def fit(
         self,
         knn_library: str = "sklearn",
-        X: np.ndarray | None = None,
-        signatures: np.ndarray | None = None,
+        X_train: np.ndarray | None = None,
+        signatures_train: np.ndarray | None = None,
         knn_algorithm: str = "auto",
         signature_kwargs: dict | None = None,
         **kwargs,
     ) -> None:
         """
-        Fit the KNN model with the corpus of signatures.
-        If signatures is not provided, then X must be provided
-        to compute the signatures.
-        If signatures is provided, then X is ignored.
+        Fit the KNN model with the corpus of signatures_train.
+        If signatures_train is not provided, then X_train must be provided
+        to compute the signatures_train.
+        If signatures_train is provided, then X_train is ignored.
 
         Parameters
         ----------
-        X : np.ndarray | None, optional
+        X_train : np.ndarray | None, optional
             Data points, by default None.
-            Must support index operation X[i] where
-            each X[i] returns a data point in the corpus.
-        signatures : np.ndarray | None, optional
+            Must support index operation X_train[i] where
+            each X_train[i] returns a data point in the corpus.
+            Typically a three-dimensional array of shape
+            (batch, length, channels).
+        signatures_train : np.ndarray | None, optional
             Signatures of the data points, by default None.
-            Must support index operation X[i] where
-            each X[i] returns a data point in the corpus.
+            Two dimensional array of shape (n_samples, sig_dim).
         knn_algorithm : str, optional
             Algorithm used to compute the nearest neighbors
             (see scikit-learn documentation for `sklearn.neighbors.NearestNeighbors`),
             by default "auto".
         signature_kwargs : dict | None, optional
             Keyword arguments passed to the signature transformer if
-            signatures are not provided and X is provided.
+            signatures_train are not provided and X_train is provided.
             See sktime documentation for
             `sktime.transformations.panel.signature_based.SignatureTransformer`
             for more details on what arguments are available.
@@ -76,13 +81,15 @@ def fit(
                   (Active only if `window_name in ['sliding, 'expanding'].
                 - window_step: int, The step of the sliding/expanding window.
                   (Active only if `window_name in ['sliding, 'expanding'].
-                - rescaling: "pre" or "post",
+                - rescaling: str, "pre" or "post",
                     - "pre": rescale the path last signature term should
                       be roughly O(1)
                     - "post": Rescals the output signature by multiplying
                       the depth-d term by d!. Aim is that every term become ~O(1).
-                - sig_tfm: One of: ['signature', 'logsignature']).
+                - sig_tfm: str, One of: ['signature', 'logsignature']).
                 - depth: int, Signature truncation depth.
+                - backend: str, one of: `'esig'` (default), or `'iisignature'`.
+                  The backend to use for signature computation.
             By default, the following arguments are used:
                 - augmentation_list: ("addtime",)
                 - window_name: "global"
@@ -97,8 +104,8 @@ def fit(
             See scikit-learn documentation for `sklearn.neighbors.NearestNeighbors`
             and pynndescent documentation for `pynndescent.NNDescent`.
         """
-        if signatures is None:
-            if X is None:
+        if signatures_train is None:
+            if X_train is None:
                 raise ValueError(X_OR_SIGNATURE_ERROR_MSG)
 
             from sktime.transformations.panel.signature_based import (
@@ -115,6 +122,7 @@ def fit(
                 "rescaling": None,
                 "sig_tfm": "signature",
                 "depth": 2,
+                "backend": "esig",
             }
 
             if signature_kwargs is None:
@@ -132,71 +140,68 @@ def fit(
 
             # compute signatures
             sigs = Parallel(n_jobs=self.n_jobs)(
-                delayed(self.signature_transform.fit_transform)(X[i])
-                for i in range(len(X))
+                delayed(self.signature_transform.fit_transform)(X_train[i])
+                for i in range(len(X_train))
             )
-            self.signatures = np.array(pd.concat(sigs))
+            self.signatures_train = np.array(pd.concat(sigs))
         else:
-            self.signatures = signatures
+            self.signatures_train = signatures_train
 
-        # fit mahalanobis distance for the signatures
+        # fit mahalanobis distance for the signatures_train
         self.mahal_distance = Mahalanobis()
-        self.mahal_distance.fit(self.signatures)
-
-        # set metric parameters for NearestNeighbors and NNDescent
-        metric_params = {
-            "Vt": self.mahal_distance.Vt,
-            "S": self.mahal_distance.S,
-            "subspace_thres": self.mahal_distance.subspace_thres,
-            "zero_thres": self.mahal_distance.zero_thres,
-        }
+        self.mahal_distance.fit(self.signatures_train)
 
         if knn_library == "sklearn":
             # fit knn for the mahalanobis distance
             knn = NearestNeighbors(
-                metric=self.mahal_distance.calc_distance,
-                metric_params=metric_params,
+                metric="euclidean",
                 n_jobs=self.n_jobs,
                 algorithm=knn_algorithm,
                 **kwargs,
             )
-            knn.fit(self.signatures)
+            knn.fit(self.mahal_distance.U)
             self.knn = knn
         elif knn_library == "pynndescent":
             # fit pynndescent for the mahalanobis distance
             knn = NNDescent(
-                data=self.signatures,
-                metric=self.mahal_distance.calc_distance,
-                metric_kwds=metric_params,
+                data=self.mahal_distance.U,
+                metric="euclidean",
                 n_jobs=self.n_jobs,
+                random_state=self.random_state,
                 **kwargs,
             )
             self.knn = knn
 
     def conformance(
         self,
-        X: np.ndarray | None = None,
-        signatures: np.ndarray | None = None,
+        X_test: np.ndarray | None = None,
+        signatures_test: np.ndarray | None = None,
+        n_neighbors: int = 20,
+        return_indices: bool = False,
     ) -> np.ndarray:
         """
         Compute the conformance scores for the data points either passed in
-        directly as X or the signatures of the data points in signatures.
-        If signatures is not provided, then X must be provided
-        to compute the signatures.
-        If signatures is provided, then X is ignored.
+        directly as X_test or the signatures_test of the data points in signatures_test.
+        If signatures_test is not provided, then X_test must be provided
+        to compute the signatures_test.
+        If signatures_test is provided, then X_test is ignored.
 
         Must call fit() method first.
 
         Parameters
         ----------
-        X : np.ndarray | None, optional
+        X_test : np.ndarray | None, optional
             Data points, by default None.
-            Must support index operation X[i] where
-            each X[i] returns a data point in the corpus.
-        signatures : np.ndarray | None, optional
+            Must support index operation X_test[i] where
+            each X_test[i] returns a data point in the corpus.
+            Typically a three-dimensional array of shape
+            (batch, length, channels).
+        signatures_test : np.ndarray | None, optional
             Signatures of the data points, by default None.
-            Must support index operation X[i] where
-            each X[i] returns a data point in the corpus.
+            Two dimensional array of shape (n_samples, sig_dim).
+        return_indices : bool, optional
+            Whether to return the indices of the nearest neighbors,
+            by default False.
 
         Returns
         -------
@@ -206,28 +211,68 @@ def conformance(
         if self.knn is None:
             raise ValueError(MODEL_NOT_FITTED_ERROR_MSG)
 
-        if signatures is None:
-            if X is None:
+        if signatures_test is None:
+            if X_test is None:
                 raise ValueError(X_OR_SIGNATURE_ERROR_MSG)
             if self.signature_transform is None:
                 raise ValueError(MODEL_NOT_FITTED_ERROR_MSG)
 
             # compute signatures
             sigs = Parallel(n_jobs=self.n_jobs)(
-                delayed(self.signature_transform.fit_transform)(X[i])
-                for i in range(len(X))
+                delayed(self.signature_transform.fit_transform)(X_test[i])
+                for i in range(len(X_test))
             )
-            signatures = np.array(pd.concat(sigs))
+            signatures_test = np.array(pd.concat(sigs))
+
+        # pre-process the signatures
+        sig_dim = signatures_test.shape[1]
+        modified_signatures = (
+            (signatures_test - self.mahal_distance.mu)
+            @ self.mahal_distance.Vt.T
+            @ np.diag(self.mahal_distance.S ** (-1))
+        )
 
+        # compute Euclidean NNs
         if isinstance(self.knn, NearestNeighbors):
-            # compute KNN distances for the signatures of the data points
-            # against the signatures of the corpus
-            distances, _ = self.knn.kneighbors(
-                signatures, n_neighbors=1, return_distance=True
+            # compute KNN distances for the modified_signatures of the data points
+            # against the modified_signatures of the corpus
+            candidate_distances, train_indices = self.knn.kneighbors(
+                modified_signatures, n_neighbors=n_neighbors, return_distance=True
             )
         elif isinstance(self.knn, NNDescent):
-            # compute KNN distances for the signatures of the data points
-            # against the signatures of the corpus
-            _, distances = self.knn.query(signatures, k=1)
+            # compute KNN distances for the modified_signatures of the data points
+            # against the modified_signatures of the corpus
+            train_indices, candidate_distances = self.knn.query(
+                modified_signatures, k=n_neighbors
+            )
+
+        # post-process the candidate distances
+        test_indices = np.tile(
+            np.arange(train_indices.shape[0]), (train_indices.shape[1], 1)
+        ).T
+        # differences has shape (n_test x n_neighbors x sig_dim)
+        differences = (
+            self.signatures_train[train_indices] - signatures_test[test_indices]
+        )
+
+        denominator = np.linalg.norm(differences, axis=-1)
+        numerator = np.linalg.norm(
+            differences
+            @ (
+                np.identity(sig_dim) - self.mahal_distance.Vt.T @ self.mahal_distance.Vt
+            ),
+            axis=-1,
+        )
+
+        rho = numerator / denominator
+        # get rid of nans from zero denominator
+        rho[denominator == 0] = 0
+
+        candidate_distances[denominator < self.mahal_distance.zero_thres] = 0
+        candidate_distances[rho > self.mahal_distance.subspace_thres] = np.inf
+
+        # compute the minimum of the candidate distances for each data point
+        if return_indices:
+            return np.min(candidate_distances, axis=-1), train_indices
 
-        return distances[:, 0]
+        return np.min(candidate_distances, axis=-1)
diff --git a/src/signature_mahalanobis_knn/utils.py b/src/signature_mahalanobis_knn/utils.py
index 5542ba7..8e6ec35 100644
--- a/src/signature_mahalanobis_knn/utils.py
+++ b/src/signature_mahalanobis_knn/utils.py
@@ -40,9 +40,9 @@ def plot_roc_curve(
         roc_auc = roc_auc_score(y_true, y_score)
 
     plt.title(f"Receiver Operating Characteristic {title}")
-    plt.plot(fp_rate, tp_rate, "b", label=f"AUC = {round(roc_auc, 2)}")
+    plt.plot(fp_rate, tp_rate, "b", label=f"AUC = {round(roc_auc, 2)}", linewidth=2)
     plt.legend(loc="lower right")
-    plt.plot([0, 1], [0, 1], "r--")
+    plt.plot([0, 1], [0, 1], "r--", linewidth=2)
     plt.xlim([0, 1])
     plt.ylim([0, 1])
     plt.ylabel("True Positive Rate")
@@ -82,8 +82,9 @@ def compute_auc_given_dists(
     distances_in[distances_in == np.inf] = np.nan
     distances_out[distances_out == np.inf] = np.nan
     max_val = max(np.nanmax(distances_in), np.nanmax(distances_out))
-    distances_in = np.nan_to_num(distances_in, max_val * 2)
-    distances_out = np.nan_to_num(distances_out, max_val * 2)
+    two_times_max = 2 * max_val
+    distances_in = np.nan_to_num(distances_in, nan=two_times_max)
+    distances_out = np.nan_to_num(distances_out, nan=two_times_max)
 
     y_true = [0] * len(distances_in) + [1] * len(distances_out)
     y_score = np.concatenate([distances_in, distances_out])
@@ -161,3 +162,87 @@ def compute_auc(
         plot=plot,
         title=title,
     )
+
+
+def plot_cdf_given_dists(
+    distances_in: np.ndarray,
+    distances_out: np.ndarray,
+    bins: int | np.array = 50,
+    xrange: tuple[float, float] | None = None,
+    xticks: list[float] | None = None,
+    xlog: bool = False,
+    xlog_base: int = 10,
+    title: str = "",
+):
+    """
+    Plot an empirical cumulative distributions of the
+    distances of inliers and outliers.
+
+    Parameters
+    ----------
+    distances_in : np.ndarray
+        KNN distances for the inlier data points.
+    distances_out : np.ndarray
+        KNN distances for the outlier data points.
+    bins : int | np.array, optional
+        Number of bins or the bins, by default 10.
+        If int, then the bins will be equally spaced.
+        If array, then the sequence defines the bin edges.
+    xrange : tuple[float, float] | None, optional
+        Range of the x-axis, by default None.
+        If None, then the range will be the minimum and maximum
+        of the distances.
+    xticks : list[float] | None, optional
+        Tick values of the x-axis, by default None.
+        If None, then the ticks will be automatically generated.
+    xlog : bool, optional
+        Whether to use log scale for the x-axis, by default False.
+    xlog_base : int, optional
+        Base of the log scale, by default 10.
+        Only used when xlog is True.
+    title : str, optional
+        Title for the ROC curve plot, by default "".
+        Only used when plot is True.
+    """
+    # obtain the empirical cumulative distribution functions
+    sorted_inlier = np.sort(distances_in)
+    cumulative_inliers = np.arange(1, len(sorted_inlier) + 1) / len(sorted_inlier)
+    sorted_outlier = np.sort(distances_out)
+    cumulative_outliers = np.arange(1, len(sorted_outlier) + 1) / len(sorted_outlier)
+
+    # define the empirical cumulative distribution functions
+    def empirical_cdf_inliers(x):
+        return np.interp(x, sorted_inlier, cumulative_inliers, left=0.0, right=1.0)
+
+    def empirical_cdf_outliers(x):
+        return np.interp(x, sorted_outlier, cumulative_outliers, left=0.0, right=1.0)
+
+    # obtain the range of x to evaluate the ECDFs
+    xmin = min(np.min(distances_in), np.min(distances_out))
+    xmax = max(np.max(distances_in), np.max(distances_out))
+    x = np.linspace(xmin, xmax, bins)
+
+    # plot the cumulative functions
+    plt.plot(
+        x,
+        empirical_cdf_inliers(x),
+        c="blue",
+        label="inliers",
+        linestyle="--",
+        linewidth=2,
+    )
+    plt.plot(x, empirical_cdf_outliers(x), c="orange", label="anomalies", linewidth=2)
+    plt.grid()
+    if title != "":
+        plt.title(title)
+    plt.legend(loc="lower right")
+    if xrange is not None:
+        plt.xlim(xrange)
+    if xticks is not None:
+        plt.xticks(xticks)
+    if xlog:
+        plt.xscale("log", base=xlog_base)
+    plt.ylim([0, 1])
+    plt.ylabel("Cumulative probability")
+    plt.xlabel("Conformance")
+    plt.show()