From 3df36b4ad1024efb2f5fe00b4fdad4099c024779 Mon Sep 17 00:00:00 2001 From: "paul.novello" Date: Mon, 15 Apr 2024 23:23:29 +0200 Subject: [PATCH 01/10] feat: add new methods to operator * squeeze * log --- oodeel/utils/operator.py | 17 +++++++++++++++++ oodeel/utils/tf_operator.py | 15 +++++++++++++++ oodeel/utils/torch_operator.py | 19 +++++++++++++++++++ 3 files changed, 51 insertions(+) diff --git a/oodeel/utils/operator.py b/oodeel/utils/operator.py index 0f121f05..9cf068fc 100644 --- a/oodeel/utils/operator.py +++ b/oodeel/utils/operator.py @@ -221,6 +221,11 @@ def unsqueeze(tensor: TensorType, dim: int) -> TensorType: "unsqueeze/expand_dim along dim" raise NotImplementedError() + @staticmethod + def squeeze(tensor: TensorType, dim: int = None) -> TensorType: + "squeeze along dim" + raise NotImplementedError() + @staticmethod def abs(tensor: TensorType) -> TensorType: "compute absolute value" @@ -234,3 +239,15 @@ def where( ) -> TensorType: "Applies where function to condition" raise NotImplementedError() + + @staticmethod + @abstractmethod + def avg_pool_2d(tensor: TensorType) -> TensorType: + """Perform avg pool in 2d as in torch.nn.functional.adaptive_avg_pool2d""" + raise NotImplementedError() + + @staticmethod + @abstractmethod + def log(tensor: TensorType) -> TensorType: + """Perform log""" + raise NotImplementedError() diff --git a/oodeel/utils/tf_operator.py b/oodeel/utils/tf_operator.py index 7dea88c5..c3957571 100644 --- a/oodeel/utils/tf_operator.py +++ b/oodeel/utils/tf_operator.py @@ -231,6 +231,11 @@ def unsqueeze(tensor: TensorType, dim: int) -> tf.Tensor: "expand_dim along dim" return tf.expand_dims(tensor, dim) + @staticmethod + def squeeze(tensor: TensorType, dim: int = None) -> tf.Tensor: + "expand_dim along dim" + return tf.squeeze(tensor, dim) + @staticmethod def abs(tensor: TensorType) -> tf.Tensor: "compute absolute value" @@ -248,3 +253,13 @@ def where( @staticmethod def percentile(x, q): return tfp.stats.percentile(x, q) + + @staticmethod + def avg_pool_2d(tensor: TensorType) -> tf.Tensor: + """Perform avg pool in 2d as in torch.nn.functional.adaptive_avg_pool2d""" + return tf.reduce_mean(tensor, axis=(-3, -2)) + + @staticmethod + def log(tensor: TensorType) -> tf.Tensor: + """Perform log""" + return tf.math.log(tensor) diff --git a/oodeel/utils/torch_operator.py b/oodeel/utils/torch_operator.py index 62b37bbe..ec95755e 100644 --- a/oodeel/utils/torch_operator.py +++ b/oodeel/utils/torch_operator.py @@ -254,6 +254,15 @@ def unsqueeze(tensor: TensorType, dim: int) -> torch.Tensor: "unsqueeze along dim" return torch.unsqueeze(tensor, dim) + @staticmethod + def squeeze(tensor: TensorType, dim: int = None) -> torch.Tensor: + "squeeze along dim" + + if dim is None: + return torch.squeeze(tensor) + + return torch.squeeze(tensor, dim) + @staticmethod def abs(tensor: TensorType) -> torch.Tensor: "compute absolute value" @@ -267,3 +276,13 @@ def where( ) -> torch.Tensor: "Applies where function , to condition" return torch.where(condition, input, other) + + @staticmethod + def avg_pool_2d(tensor: TensorType) -> torch.Tensor: + """Perform avg pool in 2d as in torch.nn.functional.adaptive_avg_pool2d""" + return torch.mean(tensor, dim=(-2, -1)) + + @staticmethod + def log(tensor: TensorType) -> torch.Tensor: + """Perform log""" + return torch.log(tensor) From 74fd0dc00436ed8ff578917b20458d512d8faac6 Mon Sep 17 00:00:00 2001 From: "paul.novello" Date: Mon, 15 Apr 2024 23:46:21 +0200 Subject: [PATCH 02/10] feat: added SHE baseline --- oodeel/methods/__init__.py | 1 + oodeel/methods/she.py | 191 +++++++++++++++++++++++++++++++++++++ 2 files changed, 192 insertions(+) create mode 100644 oodeel/methods/she.py diff --git a/oodeel/methods/__init__.py b/oodeel/methods/__init__.py index a21f5234..80c6c0e9 100644 --- a/oodeel/methods/__init__.py +++ b/oodeel/methods/__init__.py @@ -29,6 +29,7 @@ from .mls import MLS from .odin import ODIN from .rmds import RMDS +from .she import SHE from .vim import VIM __all__ = [ diff --git a/oodeel/methods/she.py b/oodeel/methods/she.py new file mode 100644 index 00000000..3a99f1a3 --- /dev/null +++ b/oodeel/methods/she.py @@ -0,0 +1,191 @@ +# -*- coding: utf-8 -*- +# Copyright IRT Antoine de Saint Exupéry et Université Paul Sabatier Toulouse III - All +# rights reserved. DEEL is a research program operated by IVADO, IRT Saint Exupéry, +# CRIAQ and ANITI - https://www.deel.ai/ +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +import numpy as np +from sklearn.linear_model import LogisticRegression +from sklearn.neural_network import MLPClassifier + +from ..types import DatasetType +from ..types import List +from ..types import TensorType +from ..types import Union +from .base import OODBaseDetector + + +class SHE(OODBaseDetector): + """ + "Out-of-Distribution Detection based on In-Distribution Data Patterns Memorization + with Modern Hopfield Energy" + [link](https://openreview.net/forum?id=KkazG4lgKL) + + This method first computes the mean of the internal layer representation of ID data + for each ID class. This mean is seen as the average of the ID activation patterns + as defined in the original paper. + The method then returns the maximum value of the dot product between the internal + layer representation of the input and the average patterns, which is a simplified + version of Hopfield energy as defined in the original paper. + + Remarks: + * An input perturbation is applied in the same way as in Mahalanobis score + * The original paper only considers the penultimate layer of the neural + network, while we aggregate the results of multiple layers after normalizing by + the dimension of each vector (the activation vector for dense layers, and the + average pooling of the feature map for convolutional layers). + """ + + def __init__( + self, + eps: float = 0.0014, + ): + super().__init__() + self.eps = eps + self.postproc_fns = None + + def _postproc_feature_maps(self, feature_map): + if len(feature_map.shape) > 2: + feature_map = self.op.avg_pool_2d(feature_map) + return self.op.flatten(feature_map) + + def _fit_to_dataset( + self, + fit_dataset: Union[TensorType, DatasetType], + ) -> None: + """ + Compute the means of the input dataset in the activation space of the selected + layers. The means are computed for each class in the dataset. + + Args: + fit_dataset (Union[TensorType, DatasetType]): input dataset (ID) to + construct the index with. + ood_dataset (Union[TensorType, DatasetType]): OOD dataset to tune the + aggregation coefficients. + """ + self.postproc_fns = [ + self._postproc_feature_maps + for i in range(len(self.feature_extractor.feature_layers_id)) + ] + + features, infos = self.feature_extractor.predict( + fit_dataset, postproc_fns=self.postproc_fns + ) + + labels = infos["labels"] + + # unique sorted classes + self._classes = np.sort(np.unique(self.op.convert_to_numpy(labels))) + + self._mus = list() + for feature in features: + mus_f = list() + for cls in self._classes: + indexes = self.op.equal(labels, cls) + _features_cls = feature[indexes] + mus_f.append( + self.op.unsqueeze(self.op.mean(_features_cls, dim=0), dim=0) + ) + self._mus.append(self.op.permute(self.op.cat(mus_f), (1, 0))) + + def _score_tensor(self, inputs: TensorType) -> np.ndarray: + """ + Computes an OOD score for input samples "inputs" based on + the aggregation of neural mean discrepancies from different layers. + + Args: + inputs: input samples to score + + Returns: + scores + """ + + inputs_p = self._input_perturbation(inputs) + features, logits = self.feature_extractor.predict_tensor( + inputs_p, postproc_fns=self.postproc_fns + ) + + scores = self._get_she_output(features) + + return -scores + + def _get_she_output(self, features): + scores = None + for feature, mus_f in zip(features, self._mus): + she = self.op.matmul(self.op.squeeze(feature), mus_f) / features.shape[1] + she = self.op.max(she, dim=1) + scores = she if scores is None else she + scores + return scores + + def _input_perturbation(self, inputs: TensorType) -> TensorType: + """ + Apply small perturbation on inputs to make the in- and out- distribution + samples more separable. + + Args: + inputs (TensorType): input samples + + Returns: + TensorType: Perturbed inputs + """ + + def __loss_fn(inputs: TensorType) -> TensorType: + """ + Loss function for the input perturbation. + + Args: + inputs (TensorType): input samples + + Returns: + TensorType: loss value + """ + # extract features + out_features, _ = self.feature_extractor.predict(inputs, detach=False) + # get mahalanobis score for the class maximizing it + she_score = self._get_she_output(out_features) + log_probs_f = self.op.log(she_score) + return self.op.mean(log_probs_f) + + # compute gradient + gradient = self.op.gradient(__loss_fn, inputs) + gradient = self.op.sign(gradient) + + inputs_p = inputs - self.eps * gradient + return inputs_p + + @property + def requires_to_fit_dataset(self) -> bool: + """ + Whether an OOD detector needs a `fit_dataset` argument in the fit function. + + Returns: + bool: True if `fit_dataset` is required else False. + """ + return True + + @property + def requires_internal_features(self) -> bool: + """ + Whether an OOD detector acts on internal model features. + + Returns: + bool: True if the detector perform computations on an intermediate layer + else False. + """ + return True From dbcc3b302c4fa5413ef11a735d3ca66e07bedfd9 Mon Sep 17 00:00:00 2001 From: "paul.novello" Date: Tue, 16 Apr 2024 12:02:57 +0200 Subject: [PATCH 03/10] fix: Some fixes on gram requires_internal_feature was False Docstring of tests where inaccurate --- oodeel/methods/gram.py | 2 +- tests/tests_tensorflow/methods/test_tf_gram.py | 5 +---- tests/tests_torch/methods/test_torch_gram.py | 5 +---- 3 files changed, 3 insertions(+), 9 deletions(-) diff --git a/oodeel/methods/gram.py b/oodeel/methods/gram.py index 1802a283..925ec6a7 100644 --- a/oodeel/methods/gram.py +++ b/oodeel/methods/gram.py @@ -304,4 +304,4 @@ def requires_internal_features(self) -> bool: bool: True if the detector perform computations on an intermediate layer else False. """ - return False + return True diff --git a/tests/tests_tensorflow/methods/test_tf_gram.py b/tests/tests_tensorflow/methods/test_tf_gram.py index 0d9e0412..6ca9a9b0 100644 --- a/tests/tests_tensorflow/methods/test_tf_gram.py +++ b/tests/tests_tensorflow/methods/test_tf_gram.py @@ -27,10 +27,7 @@ def test_gram_shape(): """ - Test Mahalanobis on MNIST vs FashionMNIST OOD dataset-wise task - - We check that the area under ROC is above a certain threshold, and that the FPR95TPR - is below an other threshold. + Test Gram method on MNIST vs FashionMNIST OOD dataset-wise task """ gram = Gram(orders=range(1, 6)) diff --git a/tests/tests_torch/methods/test_torch_gram.py b/tests/tests_torch/methods/test_torch_gram.py index e1aa3980..ea358fb7 100644 --- a/tests/tests_torch/methods/test_torch_gram.py +++ b/tests/tests_torch/methods/test_torch_gram.py @@ -28,10 +28,7 @@ def test_gram_shape(): """ - Test Mahalanobis on MNIST vs FashionMNIST OOD dataset-wise task - - We check that the area under ROC is above a certain threshold, and that the FPR95TPR - is below an other threshold. + Test Gram method on MNIST vs FashionMNIST OOD dataset-wise task """ gram = Gram(orders=range(1, 6)) From d48e791c5ec8ff8ad55691cb103dbd5ce8333e53 Mon Sep 17 00:00:00 2001 From: "paul.novello" Date: Tue, 16 Apr 2024 12:05:23 +0200 Subject: [PATCH 04/10] feat: added SHE and tests As Gram, tests are not conducted on blobs because the method only works for high dim data --- oodeel/methods/she.py | 8 +-- tests/tests_tensorflow/methods/test_tf_she.py | 50 ++++++++++++++++++ tests/tests_torch/methods/test_torch_she.py | 52 +++++++++++++++++++ 3 files changed, 107 insertions(+), 3 deletions(-) create mode 100644 tests/tests_tensorflow/methods/test_tf_she.py create mode 100644 tests/tests_torch/methods/test_torch_she.py diff --git a/oodeel/methods/she.py b/oodeel/methods/she.py index 3a99f1a3..c36fbe66 100644 --- a/oodeel/methods/she.py +++ b/oodeel/methods/she.py @@ -123,12 +123,12 @@ def _score_tensor(self, inputs: TensorType) -> np.ndarray: scores = self._get_she_output(features) - return -scores + return -self.op.convert_to_numpy(scores) def _get_she_output(self, features): scores = None for feature, mus_f in zip(features, self._mus): - she = self.op.matmul(self.op.squeeze(feature), mus_f) / features.shape[1] + she = self.op.matmul(self.op.squeeze(feature), mus_f) / feature.shape[1] she = self.op.max(she, dim=1) scores = she if scores is None else she + scores return scores @@ -156,7 +156,9 @@ def __loss_fn(inputs: TensorType) -> TensorType: TensorType: loss value """ # extract features - out_features, _ = self.feature_extractor.predict(inputs, detach=False) + out_features, _ = self.feature_extractor.predict( + inputs, detach=False, postproc_fns=self.postproc_fns + ) # get mahalanobis score for the class maximizing it she_score = self._get_she_output(out_features) log_probs_f = self.op.log(she_score) diff --git a/tests/tests_tensorflow/methods/test_tf_she.py b/tests/tests_tensorflow/methods/test_tf_she.py new file mode 100644 index 00000000..28ce9a19 --- /dev/null +++ b/tests/tests_tensorflow/methods/test_tf_she.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# Copyright IRT Antoine de Saint Exupéry et Université Paul Sabatier Toulouse III - All +# rights reserved. DEEL is a research program operated by IVADO, IRT Saint Exupéry, +# CRIAQ and ANITI - https://www.deel.ai/ +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +from oodeel.methods import SHE +from tests.tests_tensorflow import generate_data_tf +from tests.tests_tensorflow import generate_model + + +def test_she_shape(): + """ + Test SHE on MNIST vs FashionMNIST OOD dataset-wise task + """ + she = SHE() + + input_shape = (32, 32, 3) + num_labels = 10 + samples = 100 + + data = generate_data_tf( + x_shape=input_shape, num_labels=num_labels, samples=samples + ).batch(samples // 2) + + model = generate_model(input_shape=input_shape, output_shape=num_labels) + + she.fit(model, data, feature_layers_id=[-5, -2]) + score, _ = she.score(data) + assert score.shape == (100,) + + she.fit(model, data, feature_layers_id=[-2]) + score, _ = she.score(data) + assert score.shape == (100,) diff --git a/tests/tests_torch/methods/test_torch_she.py b/tests/tests_torch/methods/test_torch_she.py new file mode 100644 index 00000000..de9c1918 --- /dev/null +++ b/tests/tests_torch/methods/test_torch_she.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +# Copyright IRT Antoine de Saint Exupéry et Université Paul Sabatier Toulouse III - All +# rights reserved. DEEL is a research program operated by IVADO, IRT Saint Exupéry, +# CRIAQ and ANITI - https://www.deel.ai/ +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +from oodeel.datasets import OODDataset +from oodeel.methods import SHE +from tests.tests_torch import generate_data_torch +from tests.tests_torch import Net + + +def test_she_shape(): + """ + Test SHE method on MNIST vs FashionMNIST OOD dataset-wise task + """ + she = SHE() + + input_shape = (3, 32, 32) + num_labels = 10 + samples = 100 + + data = generate_data_torch( + x_shape=input_shape, num_labels=num_labels, samples=samples + ) + data = OODDataset(data, backend="torch").prepare(batch_size=samples // 2) + + model = Net(num_classes=num_labels) + + she.fit(model, data, feature_layers_id=["conv2", "fc2"]) + score, _ = she.score(data) + assert score.shape == (100,) + + she.fit(model, data, feature_layers_id=["fc2"]) + score, _ = she.score(data) + assert score.shape == (100,) From edb204f65b295223011d0826cbfe2f56ca05bfa7 Mon Sep 17 00:00:00 2001 From: "paul.novello" Date: Tue, 16 Apr 2024 12:05:47 +0200 Subject: [PATCH 05/10] feat: added notebooks for SHE --- docs/notebooks/tensorflow/demo_she_tf.ipynb | 584 +++++++++++++ docs/notebooks/torch/demo_she_torch.ipynb | 921 ++++++++++++++++++++ 2 files changed, 1505 insertions(+) create mode 100644 docs/notebooks/tensorflow/demo_she_tf.ipynb create mode 100644 docs/notebooks/torch/demo_she_torch.ipynb diff --git a/docs/notebooks/tensorflow/demo_she_tf.ipynb b/docs/notebooks/tensorflow/demo_she_tf.ipynb new file mode 100644 index 00000000..d50dc682 --- /dev/null +++ b/docs/notebooks/tensorflow/demo_she_tf.ipynb @@ -0,0 +1,584 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SHE (Simplified Hopfield Energy) method \n", + "\n", + "This method first computes the mean of the internal layer representation of ID data\n", + "for each ID class. This mean is seen as the average of the ID activation patterns\n", + "as defined in the original paper.\n", + "The method then returns the maximum value of the dot product between the internal\n", + "layer representation of the input and the average patterns, which is a simplified\n", + "version of Hopfield energy as defined in the original paper.\n", + "\n", + "**Reference**\n", + "[Out-of-Distribution Detection based on In-Distribution Data Patterns Memorization\n", + "with Modern Hopfield Energy](https://openreview.net/forum?id=KkazG4lgKL), ICLR 2023\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import os\n", + "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n", + "\n", + "from IPython.display import clear_output\n", + "import tensorflow as tf\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from oodeel.methods import SHE\n", + "from oodeel.eval.metrics import bench_metrics\n", + "from oodeel.eval.plots import plot_ood_scores, plot_roc_curve, plot_2D_features\n", + "from oodeel.datasets import OODDataset\n", + "from oodeel.utils.tf_training_tools import train_tf_model" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that models are saved at _~/.oodeel/saved_models_ and data is supposed to be found\n", + "at _~/.oodeel/datasets_ by default. Change the following cell for a custom path.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "model_path = os.path.expanduser(\"~/\") + \".oodeel/saved_models\"\n", + "data_path = os.path.expanduser(\"~/\") + \".oodeel/datasets\"\n", + "os.makedirs(model_path, exist_ok=True)\n", + "os.makedirs(data_path, exist_ok=True)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## First experiment: MNIST[0-4] vs MNIST[5-9]\n", + "\n", + "For this first experiment, we train a toy convolutional network on the MNIST dataset\n", + "restricted to digits 0 to 4. After fitting the train subset of this dataset to the gram\n", + "method, we will compare the scores returned for MNIST[0-4] (in-distribution) and\n", + "MNIST[5-9] (out-of-distribution) test subsets.\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data loading\n", + "\n", + "- In-distribution data: MNIST[0-4]\n", + "- Out-of-distribution data: MNIST[5-9]\n", + "\n", + "> **Note:** We denote In-Distribution (ID) data with `_in` and Out-Of-Distribution (OOD)\n", + "> data with `_out` to avoid confusion with OOD detection which is the name of the task,\n", + "> and is therefore used to denote core classes such as `OODDataset` and `OODBaseDetector`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# === Load ID and OOD data ===\n", + "batch_size = 128\n", + "in_labels = [0, 1, 2, 3, 4]\n", + "\n", + "# 1- Load train/test MNIST dataset\n", + "ds_train = OODDataset(\"mnist\", load_kwargs=dict(split=\"train\"))\n", + "data_test = OODDataset(\"mnist\", load_kwargs=dict(split=\"test\"))\n", + "\n", + "# 2- Split ID / OOD data depending on label value:\n", + "# in-distribution: MNIST[0-4] / out-of-distribution: MNIST[5-9]\n", + "ds_train, _ = ds_train.split_by_class(in_labels)\n", + "oods_in, oods_out = data_test.split_by_class(in_labels)\n", + "\n", + "\n", + "# 3- Prepare data (preprocess, shuffle, batch)\n", + "def preprocess_fn(*inputs):\n", + " x = inputs[0] / 255\n", + " return tuple([x] + list(inputs[1:]))\n", + "\n", + "\n", + "ds_train = ds_train.prepare(batch_size, preprocess_fn, shuffle=True)\n", + "ds_in = oods_in.prepare(batch_size, preprocess_fn, with_ood_labels=False)\n", + "ds_out = oods_out.prepare(batch_size, preprocess_fn, with_ood_labels=False)\n", + "\n", + "clear_output()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model training\n", + "\n", + "Now let's train a simple model on MNIST[0-4] on a simple MLP using `train_tf_model` function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# === Train / Load model ===\n", + "model_path_mnist_04 = os.path.join(model_path, \"mnist_mlp_0-4.h5\")\n", + "\n", + "try:\n", + " # if the model exists, load it\n", + " model = tf.keras.models.load_model(model_path_mnist_04)\n", + "except OSError:\n", + " # else, train a new model\n", + " train_config = {\n", + " \"model\": \"toy_mlp\",\n", + " \"input_shape\": (28, 28, 1),\n", + " \"num_classes\": 10,\n", + " \"batch_size\": 128,\n", + " \"epochs\": 5,\n", + " \"save_dir\": model_path_mnist_04,\n", + " \"validation_data\": ds_in,\n", + " }\n", + "\n", + " model = train_tf_model(ds_train, **train_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "41/41 [==============================] - 1s 12ms/step - loss: 0.0217 - accuracy: 0.9934\n", + "Test accuracy:\t0.9934\n", + "\n", + "=== Penultimate features viz ===\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_, accuracy = model.evaluate(ds_in)\n", + "print(f\"Test accuracy:\\t{accuracy:.4f}\")\n", + "\n", + "# penultimate features 2d visualization\n", + "print(\"\\n=== Penultimate features viz ===\")\n", + "plt.figure(figsize=(4.5, 3))\n", + "plot_2D_features(\n", + " model=model,\n", + " in_dataset=ds_in,\n", + " out_dataset=ds_out,\n", + " output_layer_id=-2,\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SHE score\n", + "\n", + "We now fit a SHE detector with MNIST[0-4] train dataset, and compare OOD scores\n", + "returned for MNIST[0-4] (ID) and MNIST[5-9] (OOD) test datasets.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# === gram scores ===\n", + "she = SHE()\n", + "she.fit(model, ds_train, feature_layers_id=[\"dense\", \"dense_1\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Metrics ===\n", + "auroc 0.725072\n", + "fpr95tpr 0.689239\n" + ] + } + ], + "source": [ + "scores_in, _ = she.score(ds_in)\n", + "scores_out, _ = she.score(ds_out)\n", + "\n", + "# Since many scores are equal to 0, we add a random noise to avoid bugs\n", + "# in Auroc and TPR computation.\n", + "scores_in += np.random.random_sample(size=scores_in.shape) * 10e-6\n", + "scores_out += np.random.random_sample(size=scores_out.shape) * 10e-6\n", + "\n", + "# === metrics ===\n", + "# auroc / fpr95\n", + "metrics = bench_metrics(\n", + " (scores_in, scores_out),\n", + " metrics=[\"auroc\", \"fpr95tpr\"],\n", + ")\n", + "print(\"=== Metrics ===\")\n", + "for k, v in metrics.items():\n", + " print(f\"{k:<10} {v:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Plots ===\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"\\n=== Plots ===\")\n", + "# hists / roc\n", + "plt.figure(figsize=(9, 3))\n", + "plt.subplot(121)\n", + "plot_ood_scores(scores_in, scores_out)\n", + "plt.subplot(122)\n", + "plot_roc_curve(scores_in, scores_out)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Second experiment: CIFAR-10 vs SVHN\n", + "\n", + "For this second experiment, we oppose **CIFAR-10** (in-distribution dataset) to **SVHN**\n", + "(out-of-distribution dataset).\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data loading\n", + "\n", + "- In-distribution data: CIFAR-10\n", + "- Out-of-distribution data: SVHN\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# === Load ID and OOD data ===\n", + "batch_size = 128\n", + "\n", + "# 1a- Load in-distribution dataset: CIFAR-10\n", + "ds_fit = OODDataset(\"cifar10\", load_kwargs={\"split\": \"train\"}, input_key=\"image\")\n", + "ds_in = OODDataset(\"cifar10\", load_kwargs={\"split\": \"test\"}, input_key=\"image\")\n", + "\n", + "# 1b- Load out-of-distribution dataset: SVHN\n", + "ds_out = OODDataset(\"svhn_cropped\", load_kwargs={\"split\": \"test\"})\n", + "\n", + "\n", + "# 2- prepare data (preprocess, shuffle, batch)\n", + "def preprocess_fn(*inputs):\n", + " x = inputs[0] / 255\n", + " return tuple([x] + list(inputs[1:]))\n", + "\n", + "\n", + "ds_fit = ds_fit.prepare(batch_size, preprocess_fn)\n", + "ds_in = ds_in.prepare(batch_size, preprocess_fn)\n", + "ds_out = ds_out.prepare(batch_size, preprocess_fn)\n", + "clear_output()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model loading\n", + "\n", + "The model is a **ResNet** pretrained on CIFAR-10 and getting an accuracy score of\n", + "92.75%.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# === Load model ===\n", + "# ResNet pretrained on CIFAR-10\n", + "model_path_resnet_cifar10 = tf.keras.utils.get_file(\n", + " \"cifar10_resnet256.h5\",\n", + " origin=\"https://share.deel.ai/s/kram9kLpx6JwRX4/download/cifar10_resnet256.h5\",\n", + " cache_dir=model_path,\n", + " cache_subdir=\"\",\n", + ")\n", + "model = tf.keras.models.load_model(model_path_resnet_cifar10)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "79/79 [==============================] - 3s 13ms/step - loss: 0.1268 - accuracy: 0.9278\n", + "Test accuracy:\t0.9278\n", + "\n", + "=== Penultimate features viz ===\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Evaluate model\n", + "model.compile(metrics=[\"accuracy\"])\n", + "_, accuracy = model.evaluate(ds_in)\n", + "print(f\"Test accuracy:\\t{accuracy:.4f}\")\n", + "\n", + "# penultimate features 2d visualization\n", + "print(\"\\n=== Penultimate features viz ===\")\n", + "plt.figure(figsize=(4.5, 3))\n", + "plot_2D_features(\n", + " model=model,\n", + " in_dataset=ds_in,\n", + " out_dataset=ds_out,\n", + " output_layer_id=-2,\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SHE score\n", + "\n", + "We now fit a SHE detector with CIFAR-10 train dataset, and compare OOD scores returned\n", + "for CIFAR-10 (ID) and SVHN (OOD) test datasets.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:5 out of the last 158 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:5 out of the last 158 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:6 out of the last 160 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:6 out of the last 160 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Metrics ===\n", + "auroc 0.988443\n", + "fpr95tpr 0.054600\n" + ] + } + ], + "source": [ + "# === gram scores ===\n", + "she = SHE()\n", + "she.fit(\n", + " model, \n", + " ds_fit, \n", + " feature_layers_id=['conv2d_18', 'activation_17', 'conv2d_37', 'activation_35', 'conv2d_56', 'activation_53', 'flatten']\n", + ")\n", + "\n", + "scores_in, _ = she.score(ds_in)\n", + "scores_out, _ = she.score(ds_out)\n", + "\n", + "scores_in += np.random.random_sample(size=scores_in.shape) * 10e-6\n", + "scores_out += np.random.random_sample(size=scores_out.shape) * 10e-6\n", + "\n", + "# === metrics ===\n", + "# auroc / fpr95\n", + "metrics = bench_metrics(\n", + " (scores_in, scores_out),\n", + " metrics=[\"auroc\", \"fpr95tpr\"],\n", + ")\n", + "print(\"=== Metrics ===\")\n", + "for k, v in metrics.items():\n", + " print(f\"{k:<10} {v:.6f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Plots ===\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"\\n=== Plots ===\")\n", + "# hists / roc\n", + "plt.figure(figsize=(9, 3))\n", + "plt.subplot(121)\n", + "plot_ood_scores(scores_in, scores_out)\n", + "plt.subplot(122)\n", + "plot_roc_curve(scores_in, scores_out)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tfmetal", + "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.5" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "dada21ee7726b34311237058025d0293bf4743ff9612a3722201b24280433f0a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/notebooks/torch/demo_she_torch.ipynb b/docs/notebooks/torch/demo_she_torch.ipynb new file mode 100644 index 00000000..08edb0a3 --- /dev/null +++ b/docs/notebooks/torch/demo_she_torch.ipynb @@ -0,0 +1,921 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# SHE (Simplified Hopfield Energy) method \n", + "\n", + "This method first computes the mean of the internal layer representation of ID data\n", + "for each ID class. This mean is seen as the average of the ID activation patterns\n", + "as defined in the original paper.\n", + "The method then returns the maximum value of the dot product between the internal\n", + "layer representation of the input and the average patterns, which is a simplified\n", + "version of Hopfield energy as defined in the original paper.\n", + "\n", + "**Reference**\n", + "[Out-of-Distribution Detection based on In-Distribution Data Patterns Memorization\n", + "with Modern Hopfield Energy](https://openreview.net/forum?id=KkazG4lgKL), ICLR 2023" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import os\n", + "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n", + "\n", + "from IPython.display import clear_output\n", + "from sklearn.metrics import accuracy_score\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "from torchvision import transforms\n", + "import numpy as np\n", + "\n", + "from oodeel.methods import SHE\n", + "from oodeel.eval.metrics import bench_metrics\n", + "from oodeel.eval.plots import plot_ood_scores, plot_roc_curve, plot_2D_features\n", + "from oodeel.datasets import OODDataset\n", + "from oodeel.utils.torch_training_tools import train_torch_model\n", + "from oodeel.preprocess import TorchRandomPatchPermutation\n", + "\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that models are saved at _~/.oodeel/saved_models_ and data is supposed to be found\n", + "at _~/.oodeel/datasets_ by default. Change the following cell for a custom path.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "model_path = os.path.expanduser(\"~/\") + \".oodeel/saved_models\"\n", + "data_path = os.path.expanduser(\"~/\") + \".oodeel/datasets\"\n", + "os.makedirs(model_path, exist_ok=True)\n", + "os.makedirs(data_path, exist_ok=True)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## First exp: MNIST[0-4] vs MNIST[5-9]\n", + "\n", + "For this first experiment, we train a toy convolutional network on the MNIST dataset\n", + "restricted to digits 0 to 4. After fitting the train subset of this dataset to the Gram\n", + "method, we will compare the scores returned for MNIST[0-4] (in-distrubtion) and\n", + "MNIST[5-9] (out-of-distribution) test subsets.\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data loading\n", + "\n", + "- In-distribution data: MNIST[0-4]\n", + "- Out-of-distribution data: MNIST[5-9]\n", + "\n", + "> **Note:** We denote In-Distribution (ID) data with `_in` and Out-Of-Distribution (OOD)\n", + "> data with `_out` to avoid confusion with OOD detection which is the name of the task,\n", + "> and is therefore used to denote core classes such as `OODDataset` and `OODBaseDetector`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# === load ID and OOD data ===\n", + "batch_size = 128\n", + "in_labels = [0, 1, 2, 3, 4]\n", + "\n", + "# 1- load train/test MNIST dataset\n", + "mnist_train = OODDataset(\n", + " dataset_id=\"MNIST\",\n", + " backend=\"torch\",\n", + " load_kwargs={\"root\": data_path, \"train\": True, \"download\": True},\n", + ")\n", + "mnist_test = OODDataset(\n", + " dataset_id=\"MNIST\",\n", + " backend=\"torch\",\n", + " load_kwargs={\"root\": data_path, \"train\": False, \"download\": True},\n", + ")\n", + "\n", + "# 2- split ID / OOD data depending on label value:\n", + "# in-distribution: MNIST[0-4] / out-of-distribution: MNIST[5-9]\n", + "oods_fit, _ = mnist_train.split_by_class(in_labels=in_labels)\n", + "oods_in, oods_out = mnist_test.split_by_class(in_labels=in_labels)\n", + "\n", + "\n", + "# 3- prepare data (preprocess, shuffle, batch) => torch dataloaders\n", + "def preprocess_fn(*inputs):\n", + " \"\"\"Simple preprocessing function to normalize images in [0, 1].\"\"\"\n", + " x = inputs[0] / 255.0\n", + " return tuple([x] + list(inputs[1:]))\n", + "\n", + "\n", + "ds_fit = oods_fit.prepare(\n", + " batch_size=batch_size, preprocess_fn=preprocess_fn, shuffle=True\n", + ")\n", + "ds_in = oods_in.prepare(batch_size=batch_size, preprocess_fn=preprocess_fn)\n", + "ds_out = oods_out.prepare(batch_size=batch_size, preprocess_fn=preprocess_fn)\n", + "\n", + "clear_output()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model training\n", + "\n", + "Now let's train a simple model on MNIST[0-4] using `train_torch_model` function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test accuracy:\t0.991438\n", + "\n", + "=== Penultimate features viz ===\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# === Train / Load model ===\n", + "# model path\n", + "model_path_mnist_04 = os.path.join(model_path, \"mnist_mlp_0-4\")\n", + "\n", + "try:\n", + " # if the model exists, load it\n", + " model = torch.load(os.path.join(model_path_mnist_04, \"best.pt\")).to(device)\n", + "except OSError:\n", + " # else, train a new model\n", + " train_config = {\n", + " \"model\": \"toy_mlp\",\n", + " \"num_classes\": 10,\n", + " \"epochs\": 5,\n", + " \"save_dir\": model_path_mnist_04,\n", + " \"validation_data\": ds_in,\n", + " }\n", + " model = train_torch_model(ds_fit, **train_config).to(device)\n", + " clear_output()\n", + "\n", + "# evaluate model\n", + "model.eval()\n", + "labels, preds = [], []\n", + "for x, y in ds_in:\n", + " x = x.to(device)\n", + " preds.append(torch.argmax(model(x), dim=-1).detach().cpu())\n", + " labels.append(y)\n", + "print(f\"Test accuracy:\\t{accuracy_score(torch.cat(labels), torch.cat(preds)):.6f}\")\n", + "\n", + "# penultimate features 2d visualization\n", + "print(\"\\n=== Penultimate features viz ===\")\n", + "plt.figure(figsize=(4.5, 3))\n", + "plot_2D_features(\n", + " model=model,\n", + " in_dataset=ds_in,\n", + " out_dataset=ds_out,\n", + " output_layer_id=-2,\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SHE score\n", + "\n", + "We now fit a SHE detector with MNIST[0-4] train dataset, and compare OOD scores\n", + "returned for MNIST[0-4] (ID) and MNIST[5-9] (OOD) test datasets.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Metrics ===\n", + "auroc 0.735984\n", + "fpr95tpr 0.646429\n" + ] + } + ], + "source": [ + "%autoreload 2\n", + "\n", + "# === gram scores ===\n", + "she = SHE()\n", + "she.fit(model, ds_fit, feature_layers_id=[\"relu1\", \"relu2\"])\n", + "scores_in, _ = she.score(ds_in)\n", + "scores_out, _ = she.score(ds_out)\n", + "\n", + "# === metrics ===\n", + "# auroc / fpr95\n", + "metrics = bench_metrics(\n", + " (scores_in, scores_out),\n", + " metrics=[\"auroc\", \"fpr95tpr\"],\n", + ")\n", + "print(\"=== Metrics ===\")\n", + "for k, v in metrics.items():\n", + " print(f\"{k:<10} {v:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Plots ===\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"\\n=== Plots ===\")\n", + "# hists / roc\n", + "plt.figure(figsize=(9, 3))\n", + "plt.subplot(121)\n", + "plot_ood_scores(scores_in, scores_out)\n", + "plt.subplot(122)\n", + "plot_roc_curve(scores_in, scores_out)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Second exp: CIFAR-10 vs SVHN\n", + "\n", + "For this second experiment, we oppose **CIFAR-10** (in-distribution dataset) to **SVHN**\n", + "(out-of-distribution dataset).\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data loading\n", + "\n", + "- In-distribution data: CIFAR-10\n", + "- Out-of-distribution data: SVHN\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# === load ID and OOD data ===\n", + "batch_size = 128\n", + "\n", + "# 1a- load in-distribution dataset: CIFAR-10\n", + "oods_fit = OODDataset(\n", + " dataset_id=\"CIFAR10\",\n", + " backend=\"torch\",\n", + " load_kwargs={\"root\": data_path, \"train\": True, \"download\": True},\n", + ")\n", + "oods_in = OODDataset(\n", + " dataset_id=\"CIFAR10\",\n", + " backend=\"torch\",\n", + " load_kwargs={\"root\": data_path, \"train\": False, \"download\": True},\n", + ")\n", + "# 1b- load out-of-distribution dataset: SVHN\n", + "oods_out = OODDataset(\n", + " dataset_id=\"SVHN\",\n", + " backend=\"torch\",\n", + " load_kwargs={\"root\": data_path, \"split\": \"test\", \"download\": True},\n", + ")\n", + "\n", + "\n", + "# 2- prepare data (preprocess, shuffle, batch) => torch dataloaders\n", + "\n", + "\n", + "def preprocess_fn(*inputs):\n", + " \"\"\"Preprocessing function from\n", + " https://github.com/chenyaofo/pytorch-cifar-models\n", + " \"\"\"\n", + " x = inputs[0] / 255.0\n", + " x = transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))(x)\n", + " return tuple([x] + list(inputs[1:]))\n", + "\n", + "\n", + "patch_permutation = TorchRandomPatchPermutation(patch_size=(4, 4))\n", + "\n", + "\n", + "def preprocess_fn_ood(*inputs):\n", + " \"\"\"Simple preprocessing function to normalize images in [0, 1].\"\"\"\n", + " x = inputs[0] / 255.0\n", + " x = patch_permutation(x)\n", + " return tuple([x] + list(inputs[1:]))\n", + "\n", + "\n", + "ds_fit = oods_fit.prepare(\n", + " batch_size=batch_size, preprocess_fn=preprocess_fn, shuffle=True\n", + ")\n", + "ds_fit_ood = oods_fit.prepare(\n", + " batch_size=batch_size, preprocess_fn=preprocess_fn_ood, shuffle=True\n", + ")\n", + "ds_in = oods_in.prepare(batch_size=batch_size, preprocess_fn=preprocess_fn)\n", + "ds_out = oods_out.prepare(batch_size=batch_size, preprocess_fn=preprocess_fn)\n", + "\n", + "clear_output()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model loading\n", + "\n", + "The model is a **ResNet20** pretrained on CIFAR-10 and getting an accuracy score of\n", + "92.60%, loaded from\n", + "[pytorch-cifar-models](https://github.com/chenyaofo/pytorch-cifar-models) repository.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# === load model ===\n", + "# resnet20 pretrained on CIFAR-10\n", + "model = torch.hub.load(\n", + " repo_or_dir=\"chenyaofo/pytorch-cifar-models\",\n", + " model=\"cifar10_resnet20\",\n", + " pretrained=True,\n", + " verbose=False,\n", + ").to(device)\n", + "model.eval()\n", + "clear_output()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test accuracy:\t0.925900\n", + "\n", + "=== Penultimate features viz ===\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAEmCAYAAAA+46QSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3gc1dW43ztlm3bVq9UlS3LHvVJNx1QTCD0kQOgJfBC+JF8ILQHCjySUUAI4ELrBEHo31WDccO+2utXbSqstU39/LF4kLBewjW2y7/Po0erOnbl3Zkdz5px7irBt2yZOnDhx4sTZz5H29QTixIkTJ06cXSEusOLEiRMnzgFBXGDFiRMnTpwDgrjAihMnTpw4BwRxgRUnTpw4cQ4I4gIrTpw4ceIcEMQFVpw4ceLEOSCIC6w4ceLEiXNAEBdYceLEiRPngEDZ1xOIsy1r167lgw8+AOC0004jLy9vl/azbZs33niDp556ipqaGsLhMMnJyRQUFDBu3DiuueaaWN/p06ezZcsWAE4//XRuv/322LZrr72Wt956C4C5c+eSl5dHfX09Rx555HbHPu2007jzzju3u33x4sW8/PLLLFu2jNbWVgzDID8/n1NPPZXzzjsPh8MR63v++eezcOFCAIQQOJ1OkpKSKCkp4ZhjjmHmzJm4XK5duiY/JH2v0VVXXcXVV1+9V8b4z3/+A8BRRx3F0KFDY9sWLFjABRdcAMAdd9zBzJkz9/j4ceLsS+ICaz9k7dq1/OMf/wBg4sSJuyyw/vGPf8T220pTUxNNTU1s2LChn8Dqy2uvvcbVV19NTk7Obs17R7z22mu89NJL/drWr1/PX/7yF7788kseeeSRAfezbZtwOEw4HKa5uZn58+cze/ZsHnnkEbKysvbafPdXtmzZEvuOc3Nz+wmsOHF+7MQF1o8EwzB4/PHHARg5ciR///vfycrKoqGhgaVLl/Lxxx9vd19d13n00Uf54x//uEtjTZw4kaeeeuo7zU+WZWbOnMk555xDWVkZy5Yt48orryQQCPDJJ5+wcuVKRo4cuc1+c+fOJTMzk7Vr1/L3v/+d+fPns27dOq6++mpmz56NEOI7zeO7oGkaiqIgSbtmOc/Ly2P9+vV7bT47Y9KkSft0/Dhx9jbxNaz9jPPPP5/f/e53sb8vuOACKioqqKio2OF+HR0d9Pb2AjBs2DDy8/NxOBwUFRVx2mmnce+99w64nyzLAMyZM4fW1tY9dBbbct1113HHHXcwcuRIXC4XkydP5tRTT41tr6mp2e6+DoeDgw46iEceeYTc3FwAli9fzkcffbTDMbdet9/+9rfMnj2bo48+mpEjR3L66aezZMmSWL/6+vpY33vuuYd7772XQw45hFGjRhEIBABYsWIFl112GZMmTWLEiBFMnz6dP/3pT3R1dQ14nPvvvz/Wbts2zz33HDNnzmT06NEcdNBBnHnmmTGza1/WrVvHNddcw8EHH8yIESM4+OCDueKKK/D7/fz2t7+NmfwAfve738XGq6+vZ8GCBbG/X3755Vg/TdN44IEHOOGEExg5ciRjx47l/PPP3+b6nX/++VRUVDB9+nQWL17MmWeeyahRozjuuON48803d3it48T5IYhrWD8SUlNTUVUVXdeZPXs2VVVVTJ06lXHjxjFmzBhUVR1wv5SUFEpLS1mwYAGPP/44N9xww16Zn9fr3aYtEonEPu+Kec/hcHD22Wdz9913A/Dpp58yffr0ne738ccfx9Z9AFatWsVFF13EnDlzGDx4cL++zz33XD8htHWcK664Al3XY21btmzhqaee4rPPPuPFF18kMTFxu+P//ve/7ydAICpwr732WhoaGrj44osBmD9/Ppdcckm/cVpbW5k7dy49PT07Pc+BMAyDiy++mAULFsTaNE1j4cKFLFy4kD/+8Y+ce+65/fZpb2/nwgsvjM2jqqqK66+/niFDhlBaWvq95hEnzp4grmHtZzz11FPccccdsb+ffPJJ1q9fv1NTj6Io/PSnP439vXDhQu655x7OP/98Dj30UGbPnr3dfS+//HJg4If1QCxcuDD2Jr/1Z6uTyK5SWVnJG2+8AUBxcTHjxo3bpf2Ki4tjn7c6jeyMrq4u/vrXv7JkyRKuu+46AEKhEA899NA2ff1+P7fccgtLlizhrbfewu12c+utt6LrOk6nk8cee4zFixfzs5/9DIDq6mpmzZq13bG3OpsAXHbZZSxZsoQvv/ySo48+GoD77ruPzs5OAG666aaYkLjhhhtYuHAhn376KTfeeCNut5s777yTJ598MnbsO+64I3ZvbG+d84033ogJq6OPPpr58+fz8ssvk56eDsDdd99Nd3d3v33C4TCnnnoqCxcu5NZbbwXAsizee++9HV3mOHH2OnGB9SPi97//PTfccMM2D6+Ojg7++Mc/xjzvvs2UKVMYPXo0wWCw3wNxb1FXV8fFF19MKBTC6/Vyzz337PI6kWVZsc+7un41ZswYTjzxRLxeLxdffDFpaWkA/bSOrUybNo2zzjoLr9dLaWkpdXV11NXVAXD44YdzyCGH4PP5uPbaa2Na62effbbdsT/99NPY54cffphx48YxefJk3n//fSCqZS5dupSqqqqYWXTatGlcdNFFJCUlkZWVxXnnnReb83el7/i//vWvSU1NZfjw4fzkJz8BIBgMsnjx4n77yLLMb3/7W5KSkjjllFNi7Y2Njd9rDnHi7CniAusAY+s6w9afviYxWZa56KKLmDt3Lm+++SZ/+MMfKCoqim2fO3fudo+7Vct6+umnY2th22PixImxN/utP0cdddQuzb+yspJzzz2XLVu24PV6eeSRRxgyZMgu7QtRjWYrW9ezdkZf70dJksjMzASIaTZ9+fZc+vbpexy3201ycjIQfSHYHjvathW/39+vX0lJyU732VW2N/++n789x7S0tJgJ1+l0xto1Tdtj84oT5/sQX8PaD/k+nm+2bRMKhfB4PAAMHjyYwYMHM3bs2Fg8jt/v3+7+hx9+OEOHDmXt2rXMmzfv+018J2zcuJELL7yQtrY2kpOTeeyxxwb0DNwemqbx/PPPx/4+7LDDdmm/vpqBZVm0tLQA0fW7b/Pt+K6+fZqammKfw+FwzHw60HG2kpqaGvs8e/ZsRo8e3W+7bdsIIaiqqoq19f38bb7rvfHt+W9ds+t7Tb49/77rnXvTCzNOnO9KXMPaD+m7gL9p0yZs2479/dRTT/XTbD788EMg+jA/8sgjuffee1m9ejWRSITu7u5+nmg7e3O/9NJLATBNc0+eDhCNLTv//PNpa2sjPT2dJ598cpeFlaZprFixgksvvTS2bjV69OhdFlhLly7lrbfeIhAI8Nhjj9He3g5E3cB3RnFxcczE+tFHH/HFF18QCAS45557YutNhxxyyHb3P/TQQ2Of77zzTjZv3oymadTV1fHUU09x4YUXxsbZqg3PmzePJ554gu7ublpbW3n22Wdjc/72vbGz76rv3Laul61duzYWE+d2uxk/fvxOr0OcOPsDcQ1rP2TYsGEoioJhGNx6663ceuutjB07lueee26H+3V0dPDggw/y4IMPbrMtNTV1p5kPjj32WEpKSqisrNxhv61OF33ZWWzWv//975h5qq2tjZNPPrnf9u1lhhgou8bQoUO57777dvntPz09nWuvvbZfm8vliplBd4QQgj/+8Y9cccUVRCIRfv7zn/fbXlhYyEUXXbTd/cePH8/MmTN5+eWXWbp0KSeccEK/7X3NmjfffHPMS/COO+7o53yzVfAVFhaSlJSE3+9n1qxZzJo1i6ysrH5rVX056aSTeOmll1i0aBHvvvsu7777br/t1113HUlJSTu9DnHi7A/ENaz9kJycHG699VYKCgpQlF17p3A4HNx+++3MmDGDoqIifD4fiqKQlZXFySefzPPPPx/zDNsekiTFtKz9ha2pmbKyspgyZQo333wzs2fP/k5ZLg4++GDuvPNOCgsLUVWV4cOHM2vWrG1c2rfHYYcdxtNPP80RRxxBUlISiqIwaNAgzjvvPJ5//vnYA7+vQ0hfs9rtt9/OLbfcwsiRI3G73bjdboqKijjllFO46aabYv2mTJnCiy++yPHHH096ejqKopCens706dPx+XxAVCO66667KCsr226oQl8URWHWrFlcddVVlJSUoKoqHo+H8ePH88ADD3D++efv0jWIE2d/QNh97U1x4vyI2KoF7izP4Z7ivffei2mJ/+///b9ttMg4ceLsHnGTYJw4e4DTTjuNDRs2ANF1pr5rV3HixNkzxE2CceLsAerq6pBlmVGjRvHwww/HXN7jxImz54ibBOPEiRMnzgFBXMOKEydOnDgHBHGBdYCxo0wX06dPp6Ki4kfn+VVfX89f/vIXTj/9dKZMmcKoUaM49thjufXWW2PxSXtyrIEyrvfN/L4vqaqq4je/+U0sm/vUqVO56KKLWLFixYD9N23axIgRI2Lz7xsa8cEHH2yTE3KgdFVx4uwvxJ0u4uz3LF++nH/961/92qqrq6murmbu3Lm8+uqr/xVrRosXL+aSSy4hGAzG2trb25k3bx7HHXcco0aN2mafW265pV/29zhxDmTiAusA5fsUUdwfCIfD36u8/cSJE7nooouYOHEizc3NXHvttaxdu5ampiZeeumlHQbv7gn2dWFETdO4/vrrCQaDJCcnc+uttzJt2rRY8tyMjIxt9nnttddYuHAhHo+nn5DbylFHHcX69etZsGBBvzpbceLsr8RNgj9yXn31Vc4///yYCemggw7i5JNP5vHHH4+l9TnnnHOoqKjg8MMP7xf8+t5778VMRe+8806s/e233+acc85h7NixjBw5kpNPPplnn322Xwqp+++/P7bvl19+yaWXXsqYMWP4n//5n+98DocffjhPPfUUhx9+OB6Ph+Li4n5ZKnZU/HFHWJbFPffcw7Rp0xg9ejRXXXXVdotYDmQS7GuCfeONNzj66KMZPXo0V155JR0dHaxbt46zzz6b0aNHc/LJJzN//vx+x+x7jXZminvvvfdi+f9+85vfcOyxx+L1eklLS+Ooo47ioIMO6tc/EAhw11134XK5+MUvfvF9Lk+cOPsdcQ3rR878+fP7lRXRdZ3169dz55130tXVxbXXXsu5557LkiVLaGxs5PPPP4/ln9uaxic5OTm2VvaPf/yj39oORLWPW265hY0bN/bL3LCVX//617tUZ2t7JCQkbNPWt/jj1uzr35UHH3ywX02s999/n2XLln3n46xfv57rr78+JrA/+OADurq62LRpU+y8169fzxVXXMFHH330vcyXfb/DjRs3cvTRR9PU1ERBQQEXX3wxp512Wr/+99xzD62trfz6178mOzv7O48XJ87+SFzD+pFz2mmn8Z///IeFCxeyevVqPvzwQ4YPHw4Q04qOOeaYmElpa1JUTdNiJdRnzJiBw+Ggvr4+lqdw5syZzJ8/nyVLlsQq1j777LOx4Nm+JCYm8tJLL7Fs2TKuv/763T6nUCjEo48+CkRTUvWt2bSr9PT0xNbFMjIyeOWVV/jiiy++V0Vdv9/PjTfeyOLFixkzZgwQXW8aNGgQ8+bN4/e//z0QrT21vZx/O6NvdvUnnniC2tpaNE1j06ZN/Pa3v+3nTLFu3TqeffZZioqKYtWM48T5MRAXWD9y0tPTefjhh5kxYwajRo1i+vTprF69GoDu7m7a29tRVZUzzjgDiNbM6urq4rPPPovVxdr69v7555/HzIgvv/wyU6ZMYdy4cTzzzDOx8QYybV1zzTWMGDECt9u927WewuEwV111VUww3nzzzeTn53/n46xfvz52fqeccgpDhw4lLS2Nyy677DsfKzs7m3PPPRefz9evcvK5555LRkZGv6wXfQXP1VdfHcu6v7PM8X2zso8YMYIvvviCl19+GbfbDUQ1X9u2sW2bm2++GdM0ufHGG3E4HN/5fOLE2V+JC6wfMYFAgIsuuoh3332X1tbWAUtRhMNhAM466ywURUHTNF577bWYObCsrCxWBmRXixF+m10p0NjXnXwgt3KA3t5eLrnkEubNm4cQgj/84Q+cfvrpOz32QGytiQX0S6T7XZLqbmXQoEGxz30dSra2901S+32LIPY1I55yyimkpaUxfPhwJkyYAEQz4Le1tTF//nyWLl3K6NGjSUtLY+3atTQ0NMT2bWpq2ucOJHHifF/ia1g/YpYtWxZ7oz/llFO48cYb8fl8/OpXv9qmzERWVhZHHnkk7777Li+88ALNzc0AnHrqqbE+fYsR/u1vf2PGjBn9jrG1GOG36Vu19vsSCAS4+OKLWbp0KZIkceutt8a0wu9D33Wvref67c+7yvYy6suy/N0nth2GDh3Km2++ucM+Lpcr5g24bNmyft/dVh5++GGeeeYZFi9evMfmFifOD0Vcw/oR0/dt3uVyoaoqn3/+OZ988smA/c855xwguqjf3d2NLMv9Mo5PmzYt9hC+7777WLlyJZqm0dTUxJw5cwZ8QO4qeXl5/QpTrl+/Ppb53O/3c+GFF7J06VIUReGuu+7arrB6+eWXd8nzrqKiIubM8eqrr7J27Vra29t5+OGHv/c5fFe+i5fgcccdFxOMr776Ku3t7axevZpFixYBUYG2tQRJnDg/VuIa1o+YsWPHkpycTFdXF7Nnz2b27NkIIcjLy6Ourm6b/pMnT2bw4MFs2rQJiAqovppIXl4eV1xxBffffz/V1dX85Cc/+UHOY+7cuaxcuRIAwzC4/vrr+zlvfJ+YNJ/Pxy9+8Qvuv/9+WltbY8J2fw1Azs/P5/LLL+f+++9n1apVTJ06NbZNVVX+93//F/gmtqovL7/8Mr/73e+A6Jrf2Wef/cNNPE6cPUhcw/oRk5yczEMPPcTIkSNxOp0UFRVx11137bAket+H2bddpSFaGfiee+5h/PjxJCQk4HQ6yc/P59hjj+Xuu+/eK+fxXdjqRu7xeCgsLNxh3yuuuILLL7+ctLQ03G43RxxxBA888MAPMMvvx1VXXcXtt9/O0KFDcTgceL1eDjnkEJ5++mmmTJmyr6cXJ85eJ56t/QDj/PPPZ+HChXst08Xf//53Hn74YVJSUvj0008POC+ziy66iHnz5vF///d/8ewNu0jfTBdPPvnkTj0W48TZV8RNggcoCxcupKKigtzcXD788MPdPt5f//pX3njjjZhH2YUXXnjACStN02KxUOedd96+ns5+zwcffMCVV165r6cRJ84uExdYcQBobW2loaGB5ORkTjrpJC655JJ9PaXvjMPhYPny5ft6GnHixNlLxE2CceLEiRPngCDudBEnTpw4cQ4I4gIrTpw4ceIcEMQFVpw4ceLEOSCIO13EiRMnTh9M04xXaf4BcTgcSNKu6U5xgRUnTpw4RHNhNjY20tXVRdwV7YdDliVKSkp2KYwm7iW4Hdrbe/rdtEJAWppvm/YDhfj89z0H+jns6/lvHX9v0dDQQGdnFz5f8tcJm7dN5Bxnz2LbNp2dbbjdTgoLCwdMnt2XuIa1HWybAf8pt9d+oBCf/77nQD+HA33+A2GaJl1dUWHl8yXt6+n8V5GYmExXVzuGYfQrxTMQcaeLOHHi/Nej6zq2vWdK4cT5bihKVEgNVK/v28QFVpw4ceLEiJsB92fiJsE4PwiqEOhf25H6fo4TJ872MQyDJ56Yxfvvv4ssy8iyzLBhw5k69WAee+yfPPXU8/t6ij8ocYEVZ6+ToIGysQdKvWgyONb1QJkXv2vn+8aJ89/M7bffit/v59FHnyAxMRHbtvnwww/o7vbv66ntE+ICK85eQZYEpmXjsgTOsIVp2kjtGm6PguWWEI1hvIUegoqNZUW1LUkSsc9x4vy3U1dXy9y5H/Dqq2+SmJgIgBCCI488miVLFsf6GYbBddf9Cr/fTyQSoaysnN/97kbcbje1tbXcdttNhEJBbNvmkEMO47LLruSzzz7h4YcfQJIkTNPkssuu5NBDD99HZ7rrxAVWnD2OywDn+h7MCh/ysi601+tQzynBrutFf3ML6gWlWC1hHJku1IBBIENFMW0c9SHCBS40BRw6CAsiTlBMcBj7+qzixPlhWb9+Hfn5+SQnp+ywnyzL3Hrr7SQlJWPbNnfddQcvvvg8F1zwc+bMmc3BBx/Cz372CwD8/qhm9s9/Pshvf/t/jBx5EJZl0dvbu9fPZ08QF1hx9giqLfD22kRcArVbR87xQG0QucyH6VXRn64EQOR6sAM68mAfdkMIq7KHhBIvVnsE88Mm3OeX4E5xYC3rgE4N1zGDoC6I+WUr1gWlOC1BWMS1sDhxtmLbNs899wxffDEP0zQJBAKMHDkKgNGjx/KPf9xDMBhk7NhxTJgQLc45fvxE/v73uzniiCOZNGkK5eUV+/IUdpm4l2Cc3UYWAm+7gf6Pdahzm5FlGf3JzdhLOrAjFvKE9G/6TkiHVAcYNqQ7kcoSEV4VOS8B9YISRKYb1ncj53iwW8KIjT3Y6/zIB2dit4ZxvNGIT4t7csX58VNRMYS6ujr8/q4d9nv33bdZsmQRDz30KM888wLnnHM+mqYBMH36kTzyyL8oLCzixRdnc911vwbgmmuu4w9/uBmXy8Wtt/6Rp556Yi+fzZ4hLrDi7DambWO7ZaRSH+a8FrS7V2N3RJDGpWI3hjDnNiIyXeBTMV6rRbgVbFmAACtkIFQJWxGQ4oTGEObyTqxeA+W0AszKHswFbVhftKI9tB5rWQdKq0ZKWODcedhGnDgHLPn5BRxxxHT+/Odb6enpAfja6WIuDQ31sX49PT0kJSWTkOClt7eXN998PbattraW1NQ0TjjhRK666tesXr0SgOrqKkpKSjnjjLOYOfMMVq1a+cOe3PckbhKMs9uoNlh1vShHZKOt6ASipj86dKQCD1KpD2l0KlK+B7MljLWhG/P9RpSfFkHAQHt+LerZxWDaGK0h5AlpCI+KvTmAMj0HvT2CtTZqe1cvLUf4FOzaXlwBDQ5KJiLvw5OPE2cv8oc/3MTjjz/GRRddgCzLWJbFmDFjmTJlWqzPCSfM4NNPP+bMM08jOTmF0aPH0NTUCMBHH33AO++8haqqWJbFDTf8HoCHHvoHtbU1qKqK0+nihht+t0/O77sSzyW4Hdrats0lmJ7u26b9QGFvzl8WgsRWA+PpSuyOCCLThd0cRp6YjjQ2FeFRsHt07IgFAR3hkNHfrIOeqCeFKPZG+6Y5sSSifWQZq7oHqdCL3a1Dj47xbgPy1AxQJMwvWnBcXkEwRSG842wu+w3xe2jPjL83CIfDbN5cSXp6Ng5HPNvFD4mmRWhra6K0tASXa8exLnGTYJzdxsIGpwQpDpRzipEnZyCNT0VUJIJpYXzQAJkuRIYLkaBgdkVwnF+KVJYITgn1lAJIUbETFIRDRkpyor9Qhd2pIdwy5sdNWFUBlJ8WYX7ZhlSWiPLTYqxEBe0AEVZx4sTZfeICK85uI5tAxEQengxuGZHnQZ6YAd06Vo+BPCkD+8s2aA9jJ6vIxV60xzYilXpRzy5Ge2wD9uYAmDZmTQDbtJGGJ2N91YH2wHrstgjyhDRs3UK9oBTjtTqEU0J0G3jNH/ctrCLj1FUcprrTTNZx4vzY+XH/t8fZIyg2JIcEKQGQBCRpgpRekKSvg31lQJIwPmnGmLUJa1UX5vxWjFfroCmE8VodxtxGcMjQqSMUCZHpwninAf3fmyFkIhV5AZDLfGDZKOO+8SwUmS5s3cZ8pRa7OYjdo6M/VYmwQW7XSIz8eB7kspBwRRx4TRcJfhdSjYKxRsJYKpDWqLi0ndcMihPnx0pcYMXZIaoQeBs17I8a0Z+pJLnThs9b0e9ZS1I3+DaHcOgQSZJwXFgKNpifNCNVJCFKfJgfN4MkcFw7DGNNJyLHBRKopxdFB7BBGp2KHTFBlRC9JoRN9BeqABA5buyWMFZlD+qVQzDXdqOeWoBycj62AP3+dUjdOj8G5cMVdGJ8KSP8Mj2fW7S/YRBYaiEAo9tGEhL+V0xcuhNZjv/rxvnvI+4lGGe7qJbAWxuCNCeMTEUZmozVFEIU+1CHJ2O1hBC6jafDwI5Y6O9sAUAUeEARENQh2YFycBbavWtQzyuFgIHdpaO/XhdV1xJVrCXtSGlOzLog1uI2lEkZiCw3ypE5iEEejM+aEdlurC292NUB9JYwYpAbRU5DObOQQLpyQDox9MUVdNAxWyfjVCfhegvnIAlngUTvCp2OuSaeCplwnUnSVBV7C0hhB6oXpAwIucIH/PnHibMrHLCvaY888ggVFRX8+c9/jrVFIhFuueUWJk2axJgxY7j66qtpa2vbh7McGCFAU0z8coSwYiBJ+6d64Os00WdtwvyyFVpC0BrBDuqIiIm91o+c6oS2CNojGxAuGbs1jHxWEcopBQhZoByShTI9K+pwkeRAf3Iz+j83gG0jPArqLwajnlWEyE8An4pIVJGy3Ij8BJQT87CcAjOgoRyejTzYh/lyHdK4VJRT8rE392Bu6gZZwhsWKAfwA1uSBFqlRfpJTtrf0un50sAK2hhtNo5MmfSTHfgmKHiGy2iNNm0va3Qv0AltNun5xMDd7t5v76E4cfYkB6SGtWLFCp5//nkqKvqnE7n99tv55JNPuOeee/D5fNx2221cddVVPP/8D5uCf6u5RtYtJAt0p4SJSZseJCRMbOCtynV81d5IisPNiQVDGJmcSbK5/6Qvd9gCq64X+ZAsRLoL89Mm7LYI0oQ09MXtiGQHIsWB8c4WRJ4Hq6EX9cLBiAQFqyaAuaAVek2UMwoxF7ciT8/GeKkWLLC7ddRfDEZ/dCMiz4N6VhFWbQB7eRdSqQ8UgfF+IyJZRZT6sLcEIdXxdQyWirGiA/WcEkh3oj+6AfWnxXgUQaDQyYGYO1c1FORBCk2PRVDTBYkTFdrf0sH6po/kgvTTHDgKBTnDnYQ3W4S3WKgpElbIxt3rIugJxTWtfYDT0JHbuxDBELbHjZmWTESJu6/uDQ44gdXb28tvfvMb/vSnP/HQQw/F2nt6enjppZe4++67mTJlChAVYCeccALLli1j9OjRe3VeIcmgRvPTEQnikGS8ioMExUFbqAfJVJi9eQXLO5oAyHQlcHrJCFrDQb5sqWNVZzMHZxVy5ZDJJJr7blFdCIHDhIhkowkb5/BEZNPGeKUW9awi9P/UYi1qB6eEcmYR+qyNACjHDMJc3IY1pxbltAIY7EM2ovvpT1eizshDf6kG3DIoEsbbW1B8KtLoFAgYGO81ROOtQgbGuw2IdGfUM/D4XOzNPRhftuG4tBxrsx99biPqGUVYDb1IOS6Uk/IxV3YijsjmQH1WK0EF/xcGtgG+iSrtr2t8+2SsMLS9qpF2igNds1DTBWZQQm+zsHULpybhyXGhKyaaou+bE/kvxBMIYD//FnZja+wrkwZl4vnp8QS93r027qmnzuCuu/62V3MAdnR0cOutN1JfX4/D4eA3v/ktY8aM22vj7QoHnEnw1ltv5bDDDmPq1Kn92letWoWu6/3aS0tLGTRoEMuWLfvO4wix7c9A7ZIE9fRw9eI3uO7Lt/j7ys/5qr2Bmt4udNskOSGBW776MCasAFrCvTy0ZgHDUjLJckdv6nnNNWwItGHI1oBjb/2RZUG3iLAu0saaSCsdIoQkb7//zub/zXkIEtsMHB+24DEFiQEbtcvAeLUWaUIqtmlD+OtcSBELuyGEKItqQ/rz1ciTM5GPzkaUJyLaIiAJRKoTdAuEQCQ7UH9SiPqz0mg8VqKKKPJiLmhDyvEg0p2o55eCALstEu1TlICU74Wwifb3NRhvb0FkuLADOiLJifFxc9SMOCYVuymILwQJxq5di3318+3vwIkKGvSuNlFSBHqbtY2w2ooVjO5j9ULbKzpKoqB3lYn/U4OW5zW0ahCtEm7T8YPNf19cv/0Fp6FjP/8WNLb239DQgj37bZzGgf3i8OCD9zF8+EjmzHmVP/zhZv74x//D2MfndEBpWG+++SZr1qxhzpw522xra2tDVdVY3ZitpKWl0drauk3/nZGWNnBE/bfb13Q0c+eyjzkhv4JkZ9SkJxBopsHClnqKfClcNWwyL1au5Oi8MiQhkISgIdjNq9VrOKlwKE9s+AqAt+s2EMrROTiniEz3tm9nQUPnwy2b+euKefQa0eSWqiTx8/JxnF4yghSn+3uflx00MCPdYNqIOXXIkzOwZVB/UYZIUtEe3YhIcaCeW4L+fBXGh404rhqCXR3A+KgJkaAgcr3QHsFqCmFv7sFujyCKvOiv1kbXtdKcYIN8WBa2LDAe3wQeGauhFxEysJd1RB/WAuzWMNQHsSyQRiZjLetEOasIqcCL/moN0uBE1KNy0N9rQEpxoE7KQJ9Tg5zsIPWUAqTU/TdbQd/vINxgEG63ERIoyQK9fcd6ot5iIyVE+3Yv0Mk43UHnRxpYgvY3NLLOc9D7kUXyER6c2XsnZ9X27qH/NuT2LuxvC6utNLQgt3dBVsZujbFy5XLuv/9egsFebNvm0kuv2KZu1bPPPs3777+DYRgoisL//M9vYmVD/va3u1i0aCGqqiLLMo888jjBYJCbbvo/2tuj6/tDhgzlxhtv2WbsuXPfZ86cVwEYNmw4GRkZfPXVV0ycOGm3zml3OGAEVmNjI3/+85/517/+hdO59x9G7e3bpmZKS/P1a7clqOrp5JTiYTy6dhG9fd4+irzJnFs2mic2fMXEzDwuHz6Zh1bNpzbYDUChN5mfV4xDNy1kIXF4TjGj03Lwqg5qu7vY2NFGxDLIdHrJVDxIlmBNpI1bv/qw3zx1y+KRdYtIUFSOTRu83QKI356/Jlk0aN20RUK4JJliRxJZHzYh5XhQDsvG+KABUe6DoIU5rxn154NBt9Ee2YDj8iEggfFxE/KkdNSLy9DfrEcZlQo+GWlUCrZbRuR7kEenYTcFMVd3IRXloj9Zid0cwnFFBfJBqdFs7aVe7JYIxkvVSGNSUY4ZhP7UZqxODSnFibmsE/nMQuxODe31dTguq8Cq6kH72xocl5SjPbYB84tWCJnIh2WhhTQCbdqevSH2AN/+DlRLwdwoodVZJIyUCddYeMokQjs4huSE9ld1sn/uxAzaqBmCtOMcWDpICmALQtUWwYcjZFykEnaH99r8f2i2jr+/IIKhHZqhRXBH3+TO8fv93HDDddxxx12MHj0Wy7JiSXD7cvzxMzjnnPMAWLVqBbfddjOzZ7/Mxo0bWLRoIc89NwdJkggEelBVlXfeeZNBgwZx330PxsbZduwuDMMgLe2beMicnEE0Nzfu1jntLgeMwFq9ejXt7e3MnDkz1maaJosWLeKZZ55h1qxZ6LpOd3d3Py2rvb2djIzv/pZj2wz4T9m3PSQbyJLE/au+xLStfv2qA108tXEZEzPzeKlqNa/XrOPqEVN4eM0Ceg2dmkAX9676gtsnHMO1I6fxZu16qns6OXvwKAKmhiLJbPC386dlH3NYTjHnl47msQ2Ltjvfx9YvYeqkfDxE18C2Vvzd+tn6etK2DZ0iwt2rPmNp+zc3X4Li4JZjD2Hs813I81shYiFnupAPycKqDqA/uhFsG3lyBmZND8ICeWhyNJ2SX0MZl4b5VTtWZQD11ALEiGTw62j/WIvIciGVJaI/V4V6VhF2QxBjWTvy4VnQEMKY24g02IdybC5WZwSrthd5XHr07jSJehEO9iK1aJhfmwexbESWCxJkhFfBDhiIdCfyxHRszcZ27Gf2oz5svYekTplIq4XskVDTJIJrTNTMrx12vCC5BYbfxv5a9gonKKnR8/LP1/GOkmn6l4YVjG535AgSp6lknK5idIFRbeHKcRJJ0qLps/bw/P/bsT07tmjsbPvOWLVqBYWFhYwePRYASZJISkrapt+GDet44olZ+P1+ZFmmpqaacDhMbm4upmnypz/dwrhx45k27WAkSWLEiJE8//yz3Hvv3xgzZiyTJ0/d5pj7KwfMGtbkyZN5/fXXeeWVV2I/I0aM4KSTTop9VlWV+fPnx/aprKykoaFhrzlc6Fis7WzZRlhtpTbQRbYn+kaoWSbPblrOjIIKTi8ezhXDJnNh+Tjaw0EUATOLh3NwTiGPrFvMX5Z9ytyGTaS7Evjt6MMYlpJJi9bLlt7o21WConJUbiknFQ5haHJUGPfoEbp6elEUCZcB3pU9eHRwmuBdEyAh8vWcZYu/rp7XT1gB9Boa/7vhQ6pOSoSIhUhzIk/JiJoI3RKYdtRrzSEhZbqx6nvR/70J1nVjfNyE/q9NKIdmg2Fh9xpY9b1Q14tyQh7qmUWIdBfKxHQwLazWMNbiDoQQGIvakLLcGE9XYXzUhJTtxni9DvPzZqTcBMxN3chjU5FtEdXYxqWx1RVQPaMIY2Er8jG5OC4fEjVrLu9AdsrIB0AGd6tDoG2x8QyR6ZyrkXq8AxuLrAsceMcqOPMlko9QST1ORU6EtBkOQhtN0meqmH6bSL2N1eclXmu0afuPhtEGWr1FuMbGbBE42uLZMfYGZloyDMoceOOgzOj2vYyu6/z2t9dz9dXX8uyzL/Lww4/F2r1eH88++yLHHnscNTXVnHfeT6mrq2XkyIN48snnGD58BB9//CE///l5mGb/Wj1JScnIshwzGwI0NjaQlZWz189pRxwwGpbX66W8vLxfm8fjITk5OdZ++umnc+edd5KUlITX6+VPf/oTY8aM2SsCSwhBZU8HqztbdthP63MjNAZ7GJeeS23Aj2FbRCyDx9YvxrAsrht1ME3BAP5ImARV5YP6TXy4ZTNXDp+CZVvctfxTflY+BhmJHiPCZ43VeBSV8el5nFw4lOc2r0D2KFiWjbMhgtAsnHVhjNYQwgTVrWB4HTSHAnzV3jDgXE3b5n2jntLiNCSvirk5AO1hrFV+pAnp2K1hzI+bkbLdUe2quhfjP7UAyIdnEU5VcF0zDDugIyHQ/rUZUZCAHTEx39qCNCYF0akhjUhBHpuG9uRm6IjAIVmoF5QiUhyY/giOSytAM7Hbw6gn5oFuYa7oRDhlzIVt4FMhaKA9vgnHJWXYLWH0l2pQLymHgI7xxGYSTysgkKGgf60KqAj0/ciP0CkULA0Q0LNSJ+VoB+EaA0e2RPOTfc2ZJpILMs920vaGhtFqk3ayRPJRKgKQfSpCAiFDz1cmWoNFcL2JZ6hE62wjqqG6bFxHKGjC2Edn++Mkoqh4fno89uy3oaHPc2BQJuKnx++2a/vIkQdRV1fHsmVf9TMJ9tWyNC2CrutkZWUD8MIL34TwdHZ2IkkSkyZNYeLEySxduoSqqipkWSYjI5OjjjqGKVOmcvzxRxEKBfF6+5tbp08/mpdfnsMll1zGmjWraW1tYezYsbt1TrvLASOwdoXf//73SJLEr371KzRN4+CDD+amm27aK2OFJIM3azeQ5vLssJ8i9VdiN/d08MjaqGkvUXVyzuCDmNdUw5+Xfsw1I6cyNn0QumXSEQnhklUWtdST7fEyMjWbf6z+kl+NmEJldyfH5ZdTE+iiOtCJEPDrEVOpDnaR7HORlO3GnNuIVduLelohxpI27A8acFw/gtadVC9dFGzil78Yh7o6EPXwS3WhHD0Iu1tDmpgOw5Ow2sIIIRBJKnZ7VHUTgzxRV/ZPm5FHpmIsbkU+JgfzvUbM2l5EjhvlsGzMlV2gCGxZRDWubDdCtzHe2YJyQi5S0EJ/dSPyWUUIRQIh0Fd1II/PQNT0IrJdqL8ow24OY7xcA5qFbVjYWzU+IaBLg04Nd1cYUerF2WshVnYiT0ghvJ/c8XJYxgjZeIbKdLytE0rWyDjVSdPjkW36WmFofUnDN0am65OoUOt4TydS3UezF5B8mILsheB6E++Y6IkGlpmknagiAjbsP8s/PxqCXi/On526V+KwEhMT+ctf7ubee/9OMNiLJEn88peXc8ghh8X6JCR4ufTSK7joovNJSkrm6KOPjW1rbm7ijjtuwzAMLMti1KiDmDp1Ku+88xbPPfcMkiRhmiZXXXXNNsIK4Morf8Utt9zIT35yCqqqcvPNf0LZx/Fl8XpY22Fn9bACks45n83mimGTuX/1/AGP4ZYVzi0bzWPrFgPRulGXDJnAw2sX9ut37chp3L9qPmcNHsXrNWuZnFmAQ5LIdHvJ8SQiRHSN6aE1C6hIyiDN5ea5zSu2GevGsdNZ39HCRd5hKB0G+rNVEDRAFqiXlGG8WMPiCxP5n1Xvbfe8J2XkcVfOYUhzm1COysF4rQ47YmFXBXBcNxxjdSe0hBGSwFzcjjQ+Dbs6gN0ewfGrodH1qLFpgI29JVptGIimUjq7BPP9BqQhiUhfJ7+VDstERGz0pyvBp0DIRJT6UA7JgoiJyPNgt2vg17ALPIhuA+OrNqRJ6UiWiAYfD/YhD0/GmFMDgHJyPqYisF+uRRyWhb28A/w6yvXD8SdJ7Ktbvu895NactM4ySDtBpflpjdQTFSJ1Nr3Lt19GOfUEldAmE8kRdWcfiLSTHXR+qJF1jpPGxyJgQeqxKspgm0jS7jmifPt/4Idm6/h7g3g9rH3Hd6mHtZ+8bx54OIXM4MQ0lrY3MKOggjdr1/fbLguJXw6dyLOblsfajs4r47Om6m2O9Vbteo4YVEJVdye5CUm0h4NMzSrgsfWLCX7teeiUZE4vGUFFcgY3Lf5gm2OETIO7V3zGjPwK6u0ghc1WVAMKGiCIlqEPmRRU2/hUJz36tm/yADOTyuC+9VgCmJKBta47KkgA/cnNKKflY3ZpyFMzIdkBbhnlsCzMpR1EkmQcpxVgL+9AKvSiPVmJyPUgDfaBZkG3hshPwGoJIzwKJKqIZCd22ESelI65oA2R5kQ9pQDtnjWgCNSTC6JBxy4Jx1VDsdoDqIfloP11NWaSA+WEXIRDxvjwmzU587NmlIvKsE7MxXxjC8gC5VdDIWSSqFt0pyv7TGgByLIMCiQeomCGbIQKSrJE77KdmOwscJfLdLy5/ViY3pUGqUepRFpM0maotL+uIxxge+PvpXEOfA4Yp4v9DdWUuHDwWOY11dCtRbhl/JEclVvKyNRszi49iF+PmMJLVatoDfcigKNyS0lUnQOuea33t1HkSyHZ6UI3TaZkFXDf6vkxYQUQ+dppoyUYIMUxsPdRRyREvi+ZgMuiPR16jkyF0/LAraA9sQnHLwaT8Z6fW/KmIYttv/pjMksY3uGBiInjl+WYDSFEvgf17JJoCXtsUCTkIUkYC1ui1YRHJtOdLKMfnokjYmM1hBCFXow1XSg/LUI9NR8bG5HsiGpD2AhFQn9iM/KwZGy/hjBtzCXtIAmUUwrQZm1APb0wmrX9+SoQ4LioDNs0kUoTsTUT5fRC1NMLMJtCURNj0ED5SSHqBaXYXRo0BKE0EeXoHByXVyB6dES3hvXkZnz7KPZRFjLBTQb6XJnWRwwCCwzMHsg4w4GcAGrGTjwbJVC8YruBxQCRBgtnkUTnmwbhWgvXYAlXkYQez34R50dAXMPaDYYmpPPLIRN4dN0iWkIBjsodzIkFQ3ixciVOWebEgiGYtk1JYiovbF7JB1s2D3gcVZIwbYsSXyqKkHi1Zu12x3x+83KOLyjvp7n1RTMNLLfB2jyd1lCQzkiI7Ct8DHemkftyA/TojFsh8+jk4/nAX8Oi7kZSHW5mJpYxQkkheV0EAzAXtCJNy0RKd2Kt6cKq7UU5twRzeQfK2HSs/9RCi4ZyQi4eU0JoJug2wq9hrg4ij07BDhgYnzRH8xF6ZMSydow3oxndpfLEaA7CDX7QAYeMeloBdq+BclRO1CsRAdjRX6aNXRNCf6UW9eJy7FQHkiKhDPZh1gdxXFyOHTSwMlQcN4zA+KwZybIRB6VgdxuYKzpRDstCuagMv8Pul6fvh0BCoDY6aHwygt1HdmhNOs5iQcIwBWe+TGDpwKY+JVngyJEwAzvWlJTEqNCTkwW9K02yf+ak80Md70kqESkutOIc2MQF1m6gWjInZVQwOS2fiDCp6/WzvL2R2oCfz5trY/2Ozh1MxNq+uWf6oFJkIbGgpY6D0nKoDXRtt297JESCsn03Za/qZFOgh4fWLIhlw4CoUPzzjKOYckQ5kkOhfFE7pet9/LwiG7lFQwlEUGaokCmQRiZjLmlHmpQRjb+CaFJazUKamIY+uxrHxeVYLSGMZR3IBV7IdmEFdeyaANaiduz6XuwtQUSyAxSB1RZBKvBiNkYDWaXChGg2i0QHQpFQZxZgtUcQ2U6kTF/UJOiQUGbkYrxah/bEZtQT8xDpToRbRgoZaE9vAguUGXloszaABer5JRjLO5FHJGP1GtgdYcw5dagn52M0BpFzErB+YGEF4A47aX1D6yestuLKl/F/oqOmSaSdpNL+ht5Pi5K9kDpDpfnpCBkzHThyBFrjwILLO1ohtNEifYaDpicj6O0WwdUWvskOyIoLrDgHNnGT4G4i2YIskUBA17hj6cdIQnBy0dB+fSq7Ozi7dBQuedv3gzSnm2PyBrO6s5mFrfXY2AOa6/qNuZ2kavkJSchC8PDa/sIKohkxfrf8AyrtANT0RrOtSwLHp+3I63pQLxgMvQb6K7VIg304rhmGHf5GyIoib3QtLGKjTM3Eqg5gvteAMi4d/elK9Ic2INrCSDluRK4buz4INqgXlWH7NejWo2tUBQmILBfG+41ggfVaHWZVABwSdnUAKdOD/lwlyon5UfNej456Tgnq8bkY72xBPaMI/a06zIZe1J8UgmFhvFQDEQv11HzwKgi3jP7kZqRMF5Ik47i0HDvPjZLqQtg2PuOHDyo2O0FvHljIyG6BGQBkUNIFaSeqpByrknSwQurxKolTVFpf1LAjEGmySJqmIg3gnOoulzCDUe0xsNIg4ywHtiuqoWr1FmJ/S8YXJ853JC6w9gBCCDZ3t2MDs9YvwSFkShJTY9stbJa0NnD5sEkcn19OisNNhiuBC8vH8qsRU/m/Re/zxdca2WZ/O0fnlW53rEmZeZT4UpC/9fDJcnu5dOhEGoM9BPSBvcFM22JxqBlrvR90C7sxFLsDjFdqsRqCIMD4Tx3Wmi6EIiEdmon42k3e7tKx6nux9Wi6JuWUfGwJlJ8UQo8eTY+UoGI3fBPNanzUhF0ZQBrsQxqfhjw8GXlaJtLYVEh3IgoSkJwSxtdVio25jcgTMsCnYDYFEV4V/ZVa9C+asf062qyNqMfmIRV5EcnObzKiStHsqPo/N2B+0owoSABFQp9Tg/lZC2gW2sPr0f9Ti2L/8A9uewcOenqHjZopSJygoPgEvatNQpUmZtim412dzvf12P7BlSZas0XqsSppJwrc5RIJowTpP5FRkiSCq03UTIEzR0IIm3cS6gifoyGcsMPFrzhxDgDiAmuPYPfTeu5d9QVH5BRzxbBJDPL46NJCDE5K4+8rP2eTv50jc0s5OLuQD7Zs4ovmWn5RMZ7fjT6My4dNItnpZkRK9oCOFQmKgzOKR/JpYxW/PegwLhkygXMHj+bK4ZO5oHwMr1WvoUvbce649VoHUpEXqy6IyHHjuGII8mFZWA0hpOHJOH4+OOpKbtmgCuTSRNSziqMOFi4JZAkp14Py0yLMxe0IC0RyNDZDGpqEtagtmpn90nKkMalYa/1Ik9KxqgPRpagVHZifNEVjrBpDyIdmYa7oRK5IwmoLISU7MJt6ER4Fu6oHnBLCq6Aeko0yswDhlMGwkBJUtFnRdFHKqfkA6K/Woc4sBIimedrcjVTuQ+R5EB161MR4WDbadjKT7E3kRIHYTghLqNok/RSV8BaLtld0JJcgoULGVSRvs9amt9m4B3dg9T5CcM1pKL6rEeJSQhsuw1WygZRjVFpna7S/qRNYZnGkI5c72pfRU67F0yntJVQrgNqxGqXhC9SO1ahWYK+PeeqpM9iwYf3OO+4GTzwxizPPPI0pU8bxyScf7dWxdpX4GtYewLahLDEt9reFzaz1S/j1iCmMz8jDJSuETZ3SxFQ2drezsbs91re+t5ux6b1kuBJ4tz66XnRMXhlXDp/Een8bnzVWYwGH5xQzMSOPO5d9gtfhJNnp4fnNy3HKCkFDpywpjWJvKl51x2l4ipxJWFuCiDQH8vg0jPktyOPTkSZlYLUEMf9difLTImxZYIctzNfqsHt05AnpWEETkepAf64K5bhc5MGJ6E9vRjk+D7JciIRowUVxfC7Gx80oUzOQhydjVfYg53sx1vpRzyoGITDerIdkB/qzldCmwagUaAwjDs3CnlMDQ5KxN/fCiBTUc0rQn9qMKE+MJtqd1wwbe1COzUWkqJDnRk11YndpGEvaoyVPntiEem4JZLggxYn5cVN0PS3HhbEPXtOsJAPfRIXuz/uvZcpeSJ6m0vgvDfr4WwTXmKSeqOIZKRNc+c2GlGMNwjWzCK76DwBm4JvUOd2dV5E45RGscF70GKtNpM1wxZnDWBv2M86xbR66OLuHM9yA/80b0Vs3xtrUzDKSTriNiGvQPpzZ7jNhwiSOPvpY/vSnbTO57yviAmsPke9M4vCcYj5urIq1fdJYTbLDxWuNVQjg0qETGZzYyYcNm9EtC5escFLhEFyywlMblwHgkGRGpmbxp6Ufk+32MjEzn+Pzy2gM9vBO/Ua6tDATM/MZnz4IRRK8X78ZWUikOT0ck1fKxu4OnJJMxBrY22zEoEF0pXlIWRhA+BSkAi+oEjSFMJ+sRKpIxK7txVzjR51ZgHzMIMz5rUilXmzDjvrttUZTIQHRwGTbRj2rGLtXRzhkzC9asFd2wqR0jM+asWt6MZ0S8ozcqKNFkoo8Ixf9nrVg2EgHpSAKElDKk7C9Mup5JRizq5CG+LCbwmizq1FOysduCaPduQr1l+WYPQbmiqhjCBrRHIZVPcgVSYipmRjvbkF4VazN3ZgfNyMPT0YU+zDf3IIrwwkHpxNRonXAtpfhfk8SlnS8E1zYukLPYiOmOSVOVel4t7+w2krHGzrZFztJGCbTPd/AM1LCkVJN53uvDDiGHQlgdH+BkvxTjK7oOVlhyF7vYVlFLZNSUzCMfeBx8iNFtQLbCCsAvWUj/rduxHfqvejS7hVx3JflRYYPH7Fbc98bxAXWHsJtKvyyfALlSek8v3kF3XoE07I4oaCC1Z0ttIZ7eXjtQsqT0vlZ+VhcssKIlCweWrMgVtxxSHIGJxUO4d/ro/WxmkIBXqtZS5bby6PrFjE0OYNrRk4jyeHk2i/fItnh4tCcYtyKymZ/O0taG8h2J3DF8Mncv2o+Rh/TlwCuGTmNxzYupikY4PrJ05ggBHJbMJq26fIhKCfkgmFjt0dQf1aK8XQldmcE5ehB6C/WgGHjuHoIyvF5UQ0JUM4oxCjzonTq0Vgrr4w6LTNaNiTJgXJ8LvqsTainFGC7ZUh2IFwy+jOVYNgggbWyE3lsGqapYT5ahXx6IcrJBdjYSD4Vc0k7xqt1QNQdHqeEKPYhOyWMdxtQzypG/6ABeWIm5qdN2BY4zi9Be2YzyqSMqGPGa3WIFAd2p4Z8SCYykBgGJWQSSJbQfoBlrWBCmNQZHrzjZIxOG8kFVoR+CWy/jX+eDhYkTpYxA2B0b2FHa1Fa/bs4C07F6OqjaS+TGDs6A0Hc6WKP0lWzjbDait6yEbpqIHX49z78viwvsr8SF1h7kCTTycysoRyWVUyvqYGAa754g3PLxqBZJotb65FEtOxHr6WzuHULMwoqODK3lIChUdndyd9XfN5P0MA3+QjXdrWyvquN/zf5OMoT09jQ3c5rX8dsSQjOKRnFo+sXcVLhUG4dfyRVPZ3UBLoY5EkkyeHiy+ZaBiems6KjmRu+eo97Rx3HhClZiElZ2LqJ7VEwv05vJA7JQJmRhz6nBuPdBhCg/rwMK6hjfNYcm5vxbgNyiZfOZAkhwLZtkhIVZFcC2v3rkEemoP6sFP3FaqT8BOQJadiagt0WQTk6B6ksEe3pSqyaAHbYwHFRGQD6+42oJ+VhdkSia2MLom+D8qR0zKoerDe2YJf5UE4vxLZtRLITke5EOa8E8/1GrIYQtEewZVDOKUa/cxW4ZKQpGYgsN842HXNhG9rSDrzXDKMj6Yd5mKuJMn6tBzsFErpcGB071u7MbvCOkrA18H9mkDx9J/+yshP72zZPG/JUD2qPiu7efuqnON8NO7zjB/3Otu+MeHmRbYkLrD2Madok4yQZJ0uCjQRNg0fXLSJRdTIyNRsLmxcqV9JraJT4UqlITmd8Ri5/W/n5gMebkJHH8j6lQCxsHl23mJsqDqOuuY1qo4c0h5uhqZl0N/aw1t/G2hWfkaA4yPb4UIRgSesW2iPR1/hLhkyIHeuhmsUMLTkK13styHkJmG/UR2tMuWRaatoxRyThnpKE97POr0vd29h2NJhX+UkhIs2J/kI1NIWQyxIwbRvFBqldx2oOIVUkYS5si2ZYFyCNSIFkB/bmHtQzijBXdURTMf1iMAiBvSWI/nETypRM5BHJmIvawSVjfe0Ob3dp6M9URs2PhQkoJ+RhrOpCGZ+GfEgm5pdtKEflIAo8GK/WIFUkIhDYyzuRp2Ui0l3YLWFQJcwPGrHWdyONTUVz7xvNw+gAZSeC0pkrIXkEVi+YPTa2mQ+yA8yB3Q5dhafT8W7/f+uEkTIODfQmG1ERr2W1pxCuHa8J7mz7nmBreZEHHniEYcOG09sb4MgjD0XXdXy+aHmRpUuXsGTJYh566H4eeuixWHmRRYsW8PHHH/LPfz7Ik08+F00Ztp8TF1h7EavPk6Fbj/B5c02/7ZIQDE/JZEV7E2eWjOTFypX9jD2DE9OYmJnHw2sWMC59EIkOF7WBLtZ1tdJOhCmzepjiUVDPzIUWQWWmD1EXNRj1Ghqb+zh3AGS4EujSvrE/rfO30drWTVGxD+FRkIYk0XJ8Ch8Y9TxdtYiehREKkpL45a/GMfZLSPj3ZhzXDUc+txRjZQdyYQLqGYX05rkwtxaIBIRHhnQnSn4C2rIOAEShF6nAE43zynJjbQog8tzRApC6hVUfRC7xIaU5Mdd0IRUkYKzqQj29AHtsKtKoFIRbwfykCbvXwG4KYYdMrIWt6Ov9YIHdEMQenoy1vhvl9CKkYi/6M5XYdUGk4cmYn7cgkh0o5YmITDes70aekkHQyT7x+JYSQG+3ceZJROoHWFuSiGW3sEI2cqKgZ2EOiZOupWfBX7bprmaUYQUPwu6TJlKo4CqUkSPQtcDAVyGjD7RgFue7k1yImlkWNf99CzWzDJILd+vw+7q8yP5IXGDtRfISElGEtI2JbyuH5RTREQ7xas1ahqdkcsXwyYQNA80yKE1MY3l7I+u7Wrls2CQWtdRTF/BTlpTOSYVDovEIXhVCJvqzVajnl5Cvu5meU8LcxsoBxzu+oJxXq79J+yQAOcWJ6Ab9gwa6Lszjj9WfsLrrm3yHtb1+/rDyQy4ZPZ7zDipDf6EKuz6EckIu+oPrwbRx/e9wtK+XTLwRgfboRtTTCtBmb4oGG2e5sasDmPNakCdkRNeS2sPYW6Ju7GgWdGlY9b1Yq7uw1vhhUjrK9CzM9d0Ij4yU5kJ7YB3y0TmInKjLv/FWPeq5JegPbwBAPjwbsz2McmhW1IyZXoh6RhHaYxuxVndFs9b/fDDm8k6s+gCoEvqsTSReWUFH8j5wHUy36H7TJPUYlc65BtqWPmuOTsg800HHuzreMQo9XxkkTVbpnKsTXHcUSYdmE1z3GHrLaiRXIgkjz8NReBStz2WwVfq6SiR8ExQ63tZJPUbFNmzYBzFoP1Z0yUvSCbfhf+vGfkIr5iW4mw4X+7q8yL/+9Rj/+c8curo6uf32zdx991948snnSElJ2a3z2h3i5UW2w87Ki+wKkgwvNK3h8fVLttmW4Urgl0Mn8uel/eMbZCGhShKXDJnAqs5mZCG2yUEoIbhp7HSObEpBkiSMV2pRTslHeBRqRS//u+VTqnu7+u0zKTOf/IQk5lStirUdnl3ELQUHI82uxaoMMO+XPv5v8yfbzHWQO5Fj80YyMSGPDMVB+tNViJpekATyFeX0ZKtYdjSAOtlvYa/zgw3mqi6UQ7Ow/RrWpm6kwYmYyzuRDkpGSlDRn61ClCUinBLWqi6UYwdhrvMjnDKiIAHzi1YcFw5Ge3ozQpVQjs+FRBXj3S0o03PAIWG8Woc8KhVrUzeiOAGpyIfdHY25QrOQMl1o96+NeeUpp+ZjaxbWxDSUNg3zw0Y4LZ/uHVc12CMMdA8l9LhpeVrDPUTGlS99HSBsI6cIlGyLnk9BTRG0v6GTOEXB6LYJrjZBBu+oEI7sXoSqImVksLTJxCkJkhWBLUF9j0VmokTKEhPfUBnLthHj9O/tFRkvLzIwqhWArhrssD9qBkwu3G3vwP8mvkt5kbjA2g57QmAB9Mo6izsb+PfGr2gOBVCExLF5ZYxMy+LvKz7frvv5H8ceQXskxAOrvxxwu1NW+Hf20eRttJCGJKH/e3P0xdq26LyulHVyJ/Nba3DKTrI9iazzt/Je/abY/m5Z4b6JRzGkKgHF58Cyba7v/oL5LbX9xjmrZAKWkck7VWGChoVDEpyc4+UnmV6yXq+HE3IxkxSEEASdkLghCA4Ja0ErUrYHU7aRU1zYtdHcgjgkpCkZ0UwbLWHM96Prc9L4tGiNrYVt4FNw/LwM7bENyAdnYTeHsJZ3glvC8fMyrKABbhnaIhAyMZd3Io9JRSpLxHi9DpHlRmQ5MebUIk/LxDYslEkZ6K/UYreFUS8uJ5IoE3aBxxAE5B/mX2B795BHc2E2gdZoIXsEzjwJPVVHsw0SIi4ilTaRGovAVyYJo2RchRJGp41tgiNbIHsFyzotlqwdOF/ljCkOkqotEsbpBBMGPlchwGGo0CuQnIDDRpctjD73Z1xgxdkbxOth7UckmCrTU4o4aFI2XVoYpyLTGQ6xuqtlu8JKERJpzgQ+a6oZcDtAxDSoknrJ05xR93BFgrCB8tNi0hf0Mm6ohEPdhEPx0iPlsdIIIgsJScAxg4o5PM1FZm07okHCaOrALvIS8fV/4B05qILazjQWNgVjbZplM2dLDyt7ItxxdA7p7RGY24jIcJFwcAbkuWFdDyLRAQkKik+NpoKSJayqAKLYi/Cq0fWmpj5ZOdojiKmZKCU+jBeqMT5txnHtMMx5LVgrOpGnZ2N+3oI2ayOOK4eg/W0N8gUlyIVezOUdGK/VQaIK3TpymhNrYw+ixIs0LhWhytgOUGcWgCwwunWsZBnL5gcTVjsi6AhDAYhCgWHbGBBbU+t1hnGXOXDkKDjzJLo+MehdYaKkgneMgpol0eW3WbZh+8mVl1YZHDu8FUvqBvqvqzjsXhx6GL0hncBKG3exTG+lidZioaZL+KaoGBk6hhRf94qz74kLrB+AmOeg5AQLctwJ+BxOXq9ZG/Pe68tpRcP4qHEz7eHgAEf7hp4UweojnaS0h8j0yUj5HuiIYH7chCuQhjQS1nS8Tnn+0ZyVkck5+ePQzTAbNz/Dlo4wY7dcgzTKi5XqwHq/iWPPLOKr9obY8YcnFfNg1cCFHtd3a2wohOT5LSjTsqNJvszoL2N1F9Y6P9KwJKwN3dHSIeeVgAzmZy1YlT0IjxKNv5qSAW4Z88MmpJEp0fpbvxoCAQO7MYRU4kNkuhAZTqRMN3bIwHYIxOgUzCcrEReUoJ5finb7SujWETluRLoL8/W6qJegW8Hc6EdoNqIiEf2jJtTDswns20rfA7I9Y0dI0ZBSBW6vk6xcB7YFkhP0LouOtzS0Q1XMHciThiaL3uyl+Lxl/dpdZidKpBWzuwT/lzLeoTJWMOoE4syTEB6b0Jpe1BwH7jKZsBIXWnH2LXGBtS8wBXmyjz9NOIbnNy/ns8YaLGzSnB5OLRpGVU8HqzpbODS7iBVfBxUPhN+McOmKT3DJCuedOopTcopJXRFEnpyO+WUb5UWT2WB9xBerHu63n1P1cnrR3Tg6fFjrupDHZyAdM4gxDpM0p4f2SBCXrNAVUYCBBRbAZx0hpkzLQn9mM9L4dMwyL2JDAHlSenTdak00DkW9fDBIYJs26jklkOPCWtcdzcaOjchyIxX7sIMG+gPrUY4dhFUbwFrbjXplBSQqGOv9qBXJ0RyHIRNlXDpWQQIiwxULKkYR0YS+hoV8aj7mK3WYC1oRgxOxPmpCZLujpVAsG6cpCO0H2tWuYlk2vUoYp+Gk5dGvq1AfrpB8Soju3jCwfTOWywWy043pzoppbm6jBWvLQsLdLciJG0k7pgRLz6Lj7XSEZJA4aRNay9uY3SvBzseRdiq+1Bz0jk4UOQV9J8WR48TZG8QF1j5CmIICErluyMGcVzoazbLwqQ7+tWFJLL1TToIPhySjDWA6LPGlsqW3G4CwafBY9Vd0mWGuzBuJvDzqSp7wUoSTLriJhoINLG/8D4apMST7aEoSJpP0qQMpz4XIdWMFNKxVnWSt7+a+K4/kgealfOVv2mleBNm2Mec2gldFGZ+O7NcxizzITeFoCqavsdb5sSMmUoYLs7obOcOJdFAydmsE+6sOjCcrocCN45xSRKYr6uEHyNOzsTo0pDwPSrob7ZUalKMGYX7cjFXVg/qroQghsJtCyEflIE9KR39yM1ZbGPnIHMRMgUhQ0GdtRD56EMZrddgtYRz/Mwxh2LD/h51sg5Ghk36OSscrOtZ6k03ZCQzWN5KZVkxL+8Df2EHlvfhyC+i1o66cbr2ZnndvwjvqFCK1i9Ea1wAgHAkkTvk1Qpbxf3xbbH+9dRPhyo9IGHUKlh5GTSvEWziRSEIxunUAXsQ4Byxxp4vtsKecLnYFIUCWJWwbIrZBvdFDSyiAIgSqonDHsk/w98nCXp6UzvH55fxj9fxY/BNE3dSfGHESRX+tRz4yBwwL85NmlLOLsSqc2GED++FahE9FHp2C8Xo90shkpGmZCEXCeL0Ou7YXbWQijccm0SHcXL+wZYAZR/lLaSrjH69EKk9EGpMGEohUJ8Zr9ditIRwXl2O8XY9V3YvjmqFYPTpsDmBbFtLkDPQ7ViKy3CiHZUGqE7sljLWyE2t9VBArPylEjEhChCz0xa3QGEE9OgdbEdjNIYQsYYdNpEIvdsRAf74a9eeDIWBg+iOITg3hVjEWtUB1EGSBPDMfqSSRLt8PH0C7p+4hSRKoYRW7U9CbIBHp7MAhWbyywIf+rRqNaSlw3BEawqFg2yBLNvbCf6Cm5OH//FFsrb/ZOemwK/F/+jDYA5v/ko/4FV0f3YcjZzi+KReCMwUtIR+jj4bnIIxs9mILCU1J3WO5GuNOFz9O4k4XBwiyLAjgpyNQRVeoDVXxkuorJkdOZaTsI0gLnUYj946bRIsuEbYEfl1jnb+V+1fNx/pWtKsNNCghyi4uwwroSDlupMGJWC1h5CYHIsmFdUQ2xn9qMep6EdkupNGpSF+7QdtBA2xwrOimJNtLpifE0Zke3m/Zdi1tZJKT0qZI9PjruhGpUW3N/KwF5chsRKoTc10X8ol5KBbYLhk29WBWB1BPLyDggYTLyrF7DPSPm3CcWYQVNGLZJ+z6IMacGtSMCrR/b0Y5PhdpZCrag+sR+R6UowahP12JyPcgPAr6yzU4LowWodT+vQnHBYPRPm3BcXI+6qRMjHAzyiFZ4JSwDRMJ+YANn7Usm4hDgyxwCIGlpBBq7eG06SbVWwQb62UURTByqCA7WwLJiglIVWujp3YJYGFrQeTkXDwVRyKpLvSOOrDM7QorAL2tEiW1AK1xNUZbJSIhHTXciZo6GBQ3SqgJvWUjekcNwuHBlV4CKaUE5Ywf5uLE+VFzwAisf/7zn7z33ntUVlbicrkYM2YM119/PSUlJbE+kUiEO++8k7feegtN0zj44IO56aabSE9P34cz3xYhoEUEcdkhqttbaNfcKCIXd6SGmsrbKK/4JWF3JlXta+m0EzB6m0iWNHx2D881Sazt2r7WI9o0NH+I+lKJpp5GlEyZQXkOMjBQVgaRpD5mI0lE61I5ZGgLox41CMslIUImQpLwZTi5rFejPMXFk1Vd9GgWLllwRlESJyoqWQkqZq+JnOKIZnMPmtCtQbYLu1MH3cZuDgECa0EryBL4NQibuIUMQoLWMMr5pdgRE4RAObcYe0MP8kn5WHXRjPLK8bmYi9uw1qnIRw/CfLMeffOGqMY0MT3q6dFjoP1zA5g2yALbr+G4oBT90Y3YLWGUnxRifNCA3anh+N8RWNG883v7q97r2LaN0xXGXegm0qswuNymYqiEKpvoYtuYK2FqOHNHEK5ZTNIhl2EZGrYRwdJD4EgAsWMTnxnsQnJGtRytsx5PxmCMtkpor0TNHkJg7VyCK18DQEkrImHEDERvB05AJOVjJxUREft/RoXvgrADRAI16Jof1ZGE01uILfZuHNapp87grrv+Rnl5xV4b47bbbmLFiuU4nU7cbg/XXns9w4Z9/2S+e4IDRmAtXLiQc889l5EjR2KaJn/729+46KKLePPNN/F4ovXCb7/9dj755BPuuecefD4ft912G1dddRXPP//8To7+wxEVVjq2JfHsRguXM4tkl4kkJBb1ZDIudxjrN9xDecWl/HHdln4mv8MyB3FCbu52BZYqSeTkpXGfsYZXlm2IaWCZrgSurihnyFCZ9Kdl5EFupINSMd/egrm4PZqH7/MWrJpe1AsHYyxpxd7UjeOGESSkuDmzNswRE3Lp2dSNS7PI2hBEOSwb45UarFV+pDEp6C/XokzJgEQVEbEwPm3CWu1HGpsadb4wbdRzS5CGJGGu6kKakk640k99hqCppx0lbJHvgkFJCZhL2zE3dOH4ZXk05VIgWo9LynJh22B6ZOSDUqMeiEET2ydQjh+E8eaW6HU4tQicEsYXzainF6I9sQnjherotp9FX3CSAxYhj8ARAs0B4QPmP2FgLMtAdUc9ISwgYjOgPLZULyhuvAedhpBkCPkJrn0fWwvgzBuNnDdqh+Oo6cX0rliJs3ACamIW7a/8Fsxv7JDuiul4x/0UrXEtnooj6PrkAbC+8dBQ0opJmXELvc7C7XpFHkjYegMrP7uRQMc3mS58qWUMP+Q2hHpg18M67LDp/O53N6IoCvPmfcrvf38Dr7zy5j6d03f6Nw2Hw6xatYrk5GQGDx7cb1skEuHtt9/m1FNP3ZPzizFr1qx+f995551MmTKF1atXM2HCBHp6enjppZe4++67mTJlChAVYCeccALLli1j9OjRe2Ve35Um22LOhl6KkyRyU0O8XL2E5lC0QumYtDwsx0GUlv0PBiEuHjIB07b4qKGSzd0dfNLSwCGDSinxJVPZ07XNsa8qmcBHbdW83NS/EmlLuJdbVizn5mHF6D9RKawbAk4Z5dQChEdG+FSkw7Ox5tRCwIh62R07CNOv4ZQdCCFI+esaUkw7mlapJYyV6ACXgnxkDlJBAnZbBKtDQ7gVjPcbUE4tQO/ajPVV1AFEPasY/eUapCIvyoxc6l0mL+R185+qGqyvc/t6FIUbHMM45OclSLMqMdf4kYp9SEkO9Beqo8UbX6lFPaUAc00X8sR0hE/FXNSGVJYIigDTRn+nHsdFZQhFjnoVKl9rlRKIZCfa39cgT8vEMywZ7d+bUEenYk/PJHKAC61dQVeSceaNRjhc+D+8B6OzLrYtXPUlanopctIgTH/DNvsK1Y3kSsTSgrhLp9H14T3b9Amt/5CEMaeTePAltL1w9TbbjfYqut79M0nTryPkHYxlH7hFz4Ud2EZYAfR0bGT1Zzcy8oh7d1vT2pf1sA499JsUUCNGjKS1tTU2xr5il0euqqrioosuoqGhASEE48aN429/+xuZmZkA9PT08Lvf/W6vCaxvs7UuzNZEkKtWrULXdaZO/SZVfmlpKYMGDfpeAkuIgf/+dvt3oVvo/N+8Nn4+LJ1mrY5Za/tnaF/WXs+07Dzea+vi7boNmLaFU5I5sXAIlw2dyLObVnDXis95YOrxLGhp4rnKFfQaOuWJaVxSPJYc1ctfqxZw6dCJWLaNjc2HWzZT2dOJYVss8Ov4e98gw/crHLOiGdCVE3LR7l+LenYx6mn5UU3p4Ewo8WGmq8gdOjgE0oQ0lHFpWDW9WA1B5IpEzBwXUqYbunWUs4uxuzQkp4ztUaLJadu/cYm32sI4LilDf3sLhoA36up5qap/YHTQMLh51QrurxjNmMvKwacCNiQ7kCemY63zo55TglUTwFrjRx6divFhA3ZtEHlUarTCsBDoz1ZiN4eRhyajz66Kzu/kfIyPGrHW+5GKvJgfNmF+2ASSQBqejKGy16tF7Yl7aPfGF3jbDUiqILT5zX7Cais9X71AylHX0bN4Nkb7N8VIpYQ0kqZdhH/eo3jKD6d39dvbHad3xes4s4dud7vevB69eS0JDjeaJxdtF0tA76vrtj0igZpthNVWejo2EgnU4PD9OOphzZ79HFOnTtunwgq+g8C6++67KSsrY86cOfT09HD77bdz9tln89RTTzFo0A+r+lqWxe23387YsWMpLy8HoK2tDVVVSUxM7Nc3LS2N1tbW7zxGWtrAdvbtte8Ky6obaQ2ZJLl07lu/aJvtZ5aO4q3aDVT2dMTaIpbJS1Wr2ehvZ3puCSWJKVQGejg6p5STMsrQqntIVBz4WmWWF2kkqCqPrl2EhY1TkjmuoJwpWYU8s2kZizs6GZU8iB7RRsbYVKwVnaDK0SSw/9oUrTxsWOBRsDf4UczEaKCubSMPScJc0o40LBk5UUV7aD2OS8ohoEedIk7IRcgCc2MPYlg07kkanoQ8NQPz/UbMDxuRirzIw5KpsyM8X1m93ev0VGsd5XoeHqcvmitxTRciQUEa5EF/cjPqWUVIF5ZizKlBOSoHa7oC6a7o+Ao4rhmGbVpYho1yZiFClTF6NByXlkcrHJcnoX3tiSgNS0ItTyTV88NFEu/OPbQ72LqJsboVKydEcN37A3cydTrfv5uMM+/DCnZihbpAUjC6ttD1yYPYkQDOoskE125nfwBTwwp3D7hJODwkTjwPIcn0fPlvJHcinsGH4MgdheJJ3u1z/CHRtR0/6HXNj2OHPXbM/lIP6+2332Tu3Pd56KHHduNs9gy7LLCWLl3K448/TmpqKqmpqTz88MPcfPPNnHvuuTz55JO43e69Oc9+3HLLLWzcuJFnn312r43R3r6tW3tamm+b9l1FVSU2dkSzWvSaQQJ6/3pGshCkOt39hFVfVnQ0cVhOMfkJyWS6vbxQu5qZVgElig87ZNEQ7ObPy76kPvjNgyJimbxavZYJGXkcOaiU6kAnhtGLyHIiXDLKSfno/9qIeuFg9AfWgWYhH54NRQmI9Sb6Q+uRjx0Elo3xfmNUS3mjDrshBEkObNPGdkoIVWC8UI18RDZ2Wxgp7EM5owhzfgt06Ugn5KIcm4tZ2Y35QROtP0lHt7Zfqn1ZVye944aQ0BmtwSWX+sC0EV4FgkZUuCoCwia2BfbKTpieEw1CXteDXeTF8kiIyl5Emgvt3rUoMwuiTiEW6K/VRh1O0pxYq7rQ32sgPCUNbS8HEu/uPbQnUId5cXX3YOvh7XeyDAx/A1rjGhzZQ9Ca1qOk5JF06OU4MssxAh1I7uSoMNsOQvVs2yg7SD78KvyfPdJv395lL+MZcSKOyZeh7cCEtvX67S+ojh3Xu9rZ9j3B3q6H9f777zJr1iP84x8Pk5aWttfPZ2fssgE5HA73UweFENxyyy0cccQRnHfeeVRXV++N+W3Drbfeyscff8y///1vsrOzY+3p6enouk53d/83u/b2djIyvrtLrW1v+7O99l35sSxIdEQPYgwQl5KbkERl98DCaiu9hsbC1jr+sOgDFrVuYaHXT2NXN/qLVaxODfYTVn1Z1FrPsJRMTshOo7t7Pd6uZKQiL+FhCXReU0xbbTskq+CSMT9pQnTp0QSyxV7Mdxsw329EKk+Mrl9tCYEN6llF6K/UIKkS8s9KwQYpx4NVGUD/9yaMOTWYn7ZgLu9EOGT0JAW7KYx6SgFOece3nc+hokZs9Kcq0WZtjK5LvVSD/mot6jnF0XIkQRPluFxs28Za3AFdGsIWCK8arXu1JYxQJXBKiFQHxuzqaG2soIFIdqCeU4z688FIg6O1wNTv+b1+15/duYf2xI+rx8L+yMBZMm37X4CkICek4R58CEZ7DbZloHgzsCIBele/hdG+mZSjb0DypA64uyNnBFJi9jbtCcOPI/DVnAEFXXDVG0hNS3bp+u0vOL2F+FLLBtzmSy3D6S3creP3rYcFUcvSt813O6uHFQqFmDRpCpdffhU5OYOoqqqioWELHo+Ho446huuuu4G6ulpCoW1DVz744D3++c8Huf/+h8jOztmtc9lT7LKGVVJSwsqVKyktLe3X/sc//hGAyy+/fM/O7FvYts1tt93G+++/z1NPPUV+fn6/7SNGjEBVVebPn8+xx0ZrwlRWVtLQ0LBfOFwYhsWQFAeg0as5SFSddOvfrPHYto20EyN92DRY0dFEQYKXGdlpqHodG4uScZyTx6faup3sq5Nr1FI2+FJkPZHFOX6e2DSfFf5mkhwuzj13JIenl5B2Xw12jw4eBSnbjVkVdQgRBQmYi9rAJYMWrcHl+GU5+DWMlhBNV+TRE/TjvSqPrOdbYHMPIt+DlJcQrRJ8Yj52jgerPUzBpBSK/V6qegIDzvXsnAK8bzTi+MVgtIc3oD9dCU4J9aySqAATgABjbiOOSyuQrx+O6ddgSTvmB40oJ+Vhre3CWtGF4/IKlFPy0R/fjHJiHnZbGGVmIeaqTiTLRj4yBzvNgdJr4UgUuDWBCFuEEgSRH1kSBwUBa7uwl3SRcP2JBFe92c+DbyveMaeD7KD9petIPvo6pN4O2l+/kb5uh0J1kXLkdXR98kDMbOgumYqcmo8zbzRa/fJoEPInD3wzfko+vSte2+78ehY/T/KMYQTEgRGzZQsvww+5jdWf3UjPt7wERxxy2247XOzrelg33fQH0tLSuOGG/4m1/eMfD5OUlLxb57U77HKmi3/+858sXryYRx99dMDtN998M88//zzr1u34wfl9ufnmm3njjTd48MEHKS4ujrX7fL5YdPRNN93Ep59+yh133IHX6+VPf/oTwPdya98bmS500c3b9b182apyRFGQe1Z9U3tKAFcMn7zdciIAVw2fDHoHvu55VNW9hWUZgKA451ByC8/mf5Z9td1ikdePmMjYkJ/s1bnMHWvw5zWfbtOnIimdO4dMJ7NTgupgtFTHYB9ETOy6IMppBYhSL3ZVL8a7W3CcX8qW1g5eTm1kTt0aNMtEERInZ5VxVriIrJdbUX9RFl0j++cGpPJElGMGof1rE+suyOaaDcuJfCtr62CfjzsKhjFIcmKHTPR/bYxqVMkO1DOL0P+1EeWUAoRDQn+5BnVmIXaaA8mjRDWx56ujZUw8CupPizBer0M55muz5twmlCNzsIWN+XkrwqsiynzIgzxo/9qIMiMPQibG21uQzywkcFAi5h7K0gD7vjwHgNMEVxgCPhtn12q63rsTs6s+ulF24Bt3JsLpRe+oQRISrrLDaf/PDQzkIy8cCaSddCvhuqUoiVkE183F6KhBSRqEu/xwlNRCTH8jekcNVrgbd/FkOt7+03bnJnlSST78V9gZwwirmduOt59mutgXcVg/Jn6U9bAqKgYOkLvjjjuYOXMm8E3g8JtvvtkvcPj7mAT3VmomTfKzzh9CKKk0hNp4pWYxtb1+JASXD5vMgpY6FrfVb7PfwdmFTEjLQK99lJa2bQtCJiXkoRRdzUObBvZamjVhBhVf2tSnGvws8CERc+DspTcOP4zjW9KxQyZ2YxCR64GQid0eQR6fht0WxljYhjIpg/YWP7ekrWFxV+M2xxmalM4dwTGkrY2gnFGI+Wkz5hdfO78oAvWcEjblS8xta+ajpiZciswZuQWMFV7S79uMekkZ+nNV0US3J+djvFmPSHOinlOCMa8JocjRLBvdGlK2G2N1B8rB2ZhLOrDe2RIVcGcXoz+yAZxy9I0gZKCcUQQeGbvXQPKqmJu7sSt7kSelY8yJei2KbBf2LwYT2MPLsvuDwPr2fBxWD6JnC5IZRlg63UtmkzD8OOyQn1DVAtTUAgJL52z3GCkn/BG9eR2BJS9ssy1h9Gm4iqegNa5GcnhxZFfQ+sKvtnssZ8F4Eg/+JVpnPXre9G2u0f4qsOLsHj/K1Ezr16/faR+n08lNN93ETTfd9APM6PvhsJIYneQlLEw+rHMwNvlgjsu1AcGSRpsj8zI5KC2HFypX0KNHSHW6Oat0BE3BIClWK6sGEFYA/t56xqvdOCV5mzpbZ+YMpSjiQxoKdWobkdXbT7X90pa1HJF+GI72MLaILnLagDg0C9uvY0Us5FGp6M9WUX1xCovrthVWAGv9bVSOlckQSWiPbMBxXmlMYIkMFyLFweBGnZJQKj81PCgdBp5WkEYq8PPB0czuPymKei4mqqiXlEPIwKzrRR6TjrWoDbs1jJTribq9T8uCphCSbiGdVYzdGcGu7MFxeQXaA+vABuWMQnDJ2C0RpOJogLIyLRt7jIm99pu1ATEhnfAPUIF4X2PbRLNOJA4hIbgJvXYhdqgLs6eZ7nmP4hg0AsO/ZYfHEIpzQGEF0LvsP6gp+fQseo6UI68lsPJNnPljkJxenPljsI1INNuJkAiueRfPsGPpmf84rsEHI8sShrF9x5w4/50cMALrx4RlyXh7OslNXYtkDOatSolxWQrjsoO8Ub8GSQiuHDaBQW4XevdawlIPs+o2cVDhjhdV/O2LuGTomTyx4SsCukaW28sZxSM4wpmL05RBtjF28o2HTR071YH5dA34dew0Z7QQoiphLG5FOSoX/YlNMMjNartrh8da0FHP5KIRqBkFaI9tBEUglfiwNnRjfNCIKPMhpTlJzk2DTg2R7sSoCUBTCHlwIpYC1sp27C/bcfx6KJZHQkr0YMypxm4IIgZ5sN9vQL28AilRwTZtjLmNSGU+SHFiLmxD1i2kUh/Wph6Md7bguLg86qixpAMpNwHLMqGuF+PdBkS6EySB9Xo9nmQHgYoETNtGSCFCejOWbeF2pCPZifuFhrQnsW0b2zLxDDsO/2fRcjRmTyuOrCHb3Uc4vZgDxHL1xehqwDf2JwS+ehG9rYr0mf+PwPJX6Provm86SQqJ0y5GuJKI1C/DXbGtdhUnDsQF1j7DYQhaQrV81PIy/zv6Sj5taOaBtZWx7Ss7mgH47YjxDHUGOCo7D0nacTyZLDlY1FLPaUXDcMkqnZEQ/964lLJiH4NsB7ZtM8g1gLtxH47MKsG1KYTRraP+rBQ7aGC8WINU4I1WNhYgcj0oJ+UjS5t3eCwlYoNXQdggDUlErkhC5CdgftES1bIqfFATxHYa0BxCf2IT6oWDIU+KutufXoi1rgd5SrTMPboNio08MQNKEpAkCaumF+PDRtQjcyDXg3xUDuYHjUAP0ujUaNzVxHTk8WnoL9Rg1fZiftYcLfToURAm4JSjMWOnFGBv6sFa1YldkICFRa++gc9W/p3mzrUA+DxZHDLy12QkTiIU9CBJ0Sz7qmqjKkZUAB6AWJ5swg0r8Qw+LOaIYfY0oyQPgu3kXZQSUrG0HRcZtbRenBml6IuexZE9lNCGjwhvnvetTgbdnz1M6oybsU0dKxLANOPaVZxtOXDzohzgWF4vJySOQQIkW2FuQ+WA/f6+Zil1PW2ckqaR4isZsM9WBmVNYVHrFp7auIxH1y1iTtUqevQIH/lrwSkBgvwOlZOzywfc36OoHBLJwFrvx3HdcIyl7VhL23FcPxzLryFKEyFsIo9Pw6rqYWTKtq7LfZnoyY46bCgSyuHZ2LLA2tiNPC0T8jzYEQuR68H8ogWp2AsuGX3WxmgW9iQHCIHdoyMNTcJc2IZd3Yu1OlpbS7RG0O5ahXBKKCNT0O5fh73WH03F9DV20ECemoEY5IYCL+olZZjL2qOOFy1hjKcrEaqEWe5DPjkfa70fa4gP6bQCxMpOQtpmXp53RUxYAfQEm3lrwe+pbfmC9g7B+3N1XnpFY/YcnQWLJXTdud9lZNgVIpIP30GnRvML9qF31VskHXp51HTXB6G6SRx/Dmr6ju9JNbUQKxQ1t7rLD6d3zbvb7duz5Hk85UcguVO+51nE+bET17D2ESGHk2GRHB4eey0Pbdy+phKxTLqlFFYt/j9OP+xBRpaewcrNL27TLy9jLA1W0jYlRwCCkomlCGgO4s7x8PP6AryDVF5sWhsL4C1PTOOGoikM9nvQV25G+zoHoHxSHmZAR5mQji0B3TrWV+1Y67rJ9ydxdHEx7/dJ4bOVKUm5lHnT0O/ZgHpmEXaOC+GQMFb2IJUnYn3Vjr2uG6NLQ720HDtBRpmagfF+dE1MPjwbszYQFWKPb8Jx1RD0N+uxN/dE8wa6UxGpTvR/f33tEhSkHDfGW1uQxqYhnBLm/FbMrzqiXoOmhXxqAcq0LEhzoJxeCN06hltG6jWxvmzF/KwFuTULszaA6bL4yvv0156Y27Jg/T0MzzwIf3f04WrbsGGjSW2dyckzHKiKNuB++yu2DaRVIPv7p8vSWzdhFU8l+cjrsAKtmL3tyInZCFnBP++fJIw6GTk57xtPwz7I3gxsU0MorqjAs8wB3ehjYzVvxF16CCJ94NimOHG+l8Cqrq5mwYIFtLe3Y30rY8FVV121Ryb2Y8e2IeRLxaG34f921b1vodsCyzbo6KnENIJMHXEpq6vewN+7BY8zhWFFJ5KZMYlfLlk54P7TUvOgqhfSXFi6RVZqEpd8EGLGwUfSmQquFDcFkhf3Sw1wTBLCq2B3Rh+4UlkSdlsYq74TUe4Dv4ZyagHanavwLg1w1YiRjMjK5vFNS+nSwvhUJ+dnj+Co5hQSHq5GvbAUkh2YbzegHDcI9cgcjHe2oByejbbGHxVerWFEMxgfNEbzB5oWxmt1qBeXoUxKx6oLYgd0lHFp6G1hrI3d2N0ayow89CejAkuenIFZH4ymiEpxYpsWSmECyBLmR004rh6C+WUr8oR0kAXm8jakCenRFE5vbUEq9SFVJGJ+GjXFar9OY9OKTwa8ngDBcDsOVzPQXxsIh6G6xqaiTOyxwoU/FGElDTW0As+IGdEYra3YJv7PHgLbRnL5sIJd2EY0U0bPwmdInv5rgms/QNuyPLaLmjUE76iT6PzwXhzZQ/FUHAnSjh83kicFx6CRhBw71tz3NywCdIdqCGtduBzJJLoLkfhxlBdZt24tkiShKApXXHE1EyZM2mvj7QrfWWC98MIL3HzzzaSkpJCeno7oY/8QQsQF1nfAtm26e2sZm+xlVWfzdvslSgZbgJ5gE2lJpXy1/mlK8w7H685AN8JkuMt4vaEHbYD1k0xXAsM6PEg5bhBgVQYwlncg1QXJey5InltG/WUGdGuIkwrQn9mM3akhTUrHWtGJ3aWhP7kZqdgbjXXSLYwnNoFLRp1ZQNrqAD8ZmscRYwvobe3F7XCQGXFgq2FMZy8iQcEOmJDhxKzrRUp2IIq8WHW9iBQVMl3R44ZNRKYLZXoOIs2J/kJ1NBUTYLdr2IpAaBb4dfApKMcMQn+mEjwyKBLmh42oF5RipzqwqgLIZYkYazqxPmpGlPuwW8KYHzdjVQcQHiVa8sQlo01Nwz02Fbp07ECft3/DRggJeztxbUC/e78va9dZlJUqwI5fRPY3LAtE5ig87iQk1U3vyjewjTBGZx1qeinaluWYWu+3djLomnsvGWc/iBVowdZDIDtQkgbR8e4dYGpoW5bjnPwzbNvEkT0UrWntgOP7xp9FJGU4lnXgRGxHzAbeWXwjbV0bYm3pyeUcN/42nPKBXV7kmmuux+eLhhGsX7+Oq6++jHfe+RBJ2ncrSd9ZYD300ENcc801/PKXv9wb8/mvQsgGuhWi3CXjlJUBY6NGJqehdy0GQFXcrKp6jcNGX4db+KApQnJiPr5AKmfpPfRkw/tNm2NGwXFpg/if0snkVgk0R4SQ1o083IFjvo58ZDZSWSL6YxuxlnVAYQLCMFGOGoTdFEKakIY9PBnbMKPFD9/dgvVCNcqZhSBLKBeUYK3vxvyiFalbI/nlEEldGurlFej/3oR0cCbKmYWYC9sxP29BOa0AuyqAvqAN9ReDsQwT9SdF2PXBqMZk2siTM7CqA9jVAeSpmRift2Kt7oJeHcevh2Fs6EIMcqFeMBhCZjQu6/RC7PYIxqfN4JAwHtuEclQOxsJWpGQn8pnF6C9UYeW4UY7PxXh7CzYgjU9DH5+CM2IhFfsw392CvSWIfFgWdlsY55tBhh16PKtqXx/wu0tMyCHYM3C6Gtv+OhRg92+RH5ywkkZCQojwlpX4Jp+PQICkIrkT+2lQfXGXHUJg2UuE+qxPJR3+K9zFk5GGH4/eVokV7MJZPImkQy+n/bU/bJMc15F7EFLJdLQDSFhZBLYRVgBtXRt4Z/GNnDTp3t3WtPZleZGtwgogEBg4K80PzXcWWH6/n+OPP35vzOW/jrDeRETrpqbyGW4c9hvu3VhNa/ibN9jxaZnMzIBly/+DU/ViWQadPdW0dG3k4NQLgQi26gCPRG69ye9zJnFx+TA0oxtFUvEqWSQYNnVJy1mw+Sm2dC7DoXgYO/NshmQfTcJbbTiuGAI+BWNuI2zowUqQQRWEgxGaMltpNbagWQbeK7JIbksnd34njnOKsVvDiFIfdnsEa1UX8HWck09BOTYXMTwJegyk0SlYG7sx/lMLgDQyBRSBnOrBDhjYiQoiy435n1ostxwNFD4lH3NFB3Zl9J9E+WlRNLFtr4VywWDsuiBWTQD1knKsjX7MBe3IE9LRZ1cjEhRQJYRLwXi1DlGUgHpmESLJgfHZN1qs3RbGaQrsyh7MTT2IQR6U0wuxVnUiVSQiJ6YxOuM01jfMRTe+7QknGFtyAws/T2QgKiokZMlgB/l992uCzjy8B51G1/t3xtpcRZPwTTiXnsXPQR+t05F7EM7C8XS9///6HSO86VOUlDx6lryAkpSDbRn0rngV4fSSdPAl2FqI0OZ5CNVNwqiTsdJHEJYPLGeL7lDNNsJqK21dG+gO1ZDsPrDLizzwwH18+OEH9PR0c8cd/2+falfwPQTWcccdx7x58zj77LP3xnz+q9DNIMs3vcTEoRfy5cpb+HXpeajJU2kPNJMg6fS2zmPZ8vdwOZKYNvJy5q2I5mUryJxEp0OQXOChx2ljWjbOcouG8CK+XPgYbf6NyJLKmLKzSUsq4d3VN8fGjOgB5q9/lLX173DqsFtJuG8tIs2J3R5BmpSOXJ5Ij1dng/kJi766j/DXJRRUxcOQsp8TPv5gyj5tRmQ4kcuTog4NX2NVBZAMGyoS6XTauGQZl61E46VaomseUokXc1MPkk+FYi/CpWLVhRCZLtSfFmE1hhAuGbu1T57F1jAYNubHTdjNIayGIHTrSCNTsJZ3IJf5MF6PxgNJE9OxVnVirfEj0pzIEzIg0xUVcl91IE3LQLgVzA8asZa0I41Ixm4OY23uQYxLQxqRjLm8E/mUfFJWpXBGyd9Z0vUCG1o/wrYtslNHMbrkcsLdI9AG8KtwOqC0SDrg1q/6YttgFh5B6qkpdM/7J0ZbJeG6r1AHjSTjrAcxuuqx9TByQhqSN2NbN3UgUr8MOXkQiRPPI7D8lVi+QVfx5Gi5kqCf5KN+g+HOImQemFHaYa1rJ9v9sBvZUvaH8iJXXvkrrrzyVyxcuIB//ONeHnnkcVT1hyvF822+s8AqLCzk3nvvZfny5ZSXl29T0OuCCy7YY5P7seNUkwhr3Sxe/zTjK84nFOkiuOVlhuVMxjA1AsnFlOX8HxE9QENXPXm5R5OoOPG5CvGFBRoWpgWSorGx5SM+Wnp37NimpSPLKh/3aetLV28dNSWrGJZYjt0eQaQ5UY7MQXt8Aw0XdPHZotv69deNICvXPoAy0k3KYUeSGXRgzmvB7tKimklVD9biqKZjBw0Ujwoq2B+3YS3rQKpIwm4PY7xah3pRGbYColuHLg17cw/ykTmYdQFEsS9aWLFXR7mwFOurdswPm3BcOQRpeBLW6q8F6HklGMvakUemYsypQWS6QJWiyW9n5GH79ahLfL4HY2k72tg0/NcPReo2SFnrRz2vJOpSv6wDvCpSoRf8WjSrxk+LsLoiKKNSyexK4CjlV0ybeikhWbBqbTKdLV6SfBJTJ9usWGkQ6I0Kp+ICiQnj/z975x0eR3X27ftM2b6rsupdsiRL7r0XiumdUEMJgUAgCW/ql/qSAMkb0kNCQhJIQiChhNAJvRv3XmS5SLZ6rytp67Tvj3UTkgzGNsag+7q4sKaemd2dZ845z/P7ydhs0RO+8FXHjp4yG/cFE7DFOrDCvcQ6qom1bkeye1FSxiA5E9FsSTiKFzOw8Qms6OBho1DFi3hmXkXyuXeidVQhAFPTQEg4J13IgJKOdWKWrQHgsCW+z/qhweVoc6ztRfYxa9Zsfv3rn7N7dxVlZeOO+XWNxGEHrH//+9+4XC7WrFnDmjVrBq0TQowGrMPALqUxpfgy1u/6F+9uuQenLRGvK52GjnVkZp5MYsZZbA5FEbKELVlmU1cLpc4kCmMSCe+2IyXZ8I5LoEutZ0XFn4ccX5FtRLWRx5431f6Hkol3oK7UsbqiGNt6MK7LZE3lz0fcZ1fVP8iaM520eh/y4gykealYEQPZpyLPTMHEwuqM4nbISKaFGJcIYQN5cToEdYyVHZCgQlU/JNlANxHJNvAoSG4Zc3VnfB7tpAzMbb0oc9KwpvqxFIHZeKA3Z1T3oSxMR8RMpImJKKdmgk1Gf6kRkWRDOjkd4+EaIm+3suvMTB6s6mFtRwhVEpxf5OP8fDc5/6lHPScbsyuKiBnoqzqwmsNIF+QgZ7iI/WkH6rm5qElu+FM7niuKmT7GRWu3SWurTk6WxLln2TD6dNTuCL5cG/3q0Q9WQgjcpoYUiWKaJjG3m9hHVEIZE25idjeSw8LuzcWuWoRNByHhiV+nAcJZiP8zd9P3zu+JNW2Jt1l14p5yMVZ0gK7nf4B73JkoyXk4cqYQdhUQNeXhapFPKHzOfFISS4cdFkxJLMXnPHr2IgcPCR7cy3o/exFJkpg9ey6zZs1h48b11NTUIMsyqalpLFlyOnPnzuOss5YQDocGKbbrukZLSwu5uXkAbNtWQU9PN1lZOUd0TUfKYQesN99881i041OJaQrG5X2GnoF69jQvJRzrJRzrZfKk7/Fwm0nlusGK6hfkl7N9oJt/123j94WLKfJ6kJAIBgMIIVGcfTJCCJo6NxOKdB0yww1AN6JQ4MS2oAirKwKSIKx00RUYXkAXIBjpRIv2IOVmErt3B/IMP6LAg/CpRFJVJA1Euh3rT1WIBWnoqzqQpiSjvdSEtbknnqxR1Ye5rituwNgbQ/2fcszGIFK2G2NlB+b2AKLYi7m2C6bHEEUezK09CEkg31CMua4Lc2sv8uwULEUgTU0m9ocdSCU+5FMzEV6FAbfAe/NY1vpkvr2yiX0jdDHT4om6AK+3DvD7y/LJfbwOeXIy+rttKKdkov23ASXLjdUdhaiJWTeA8CVhnltG+/OgdcZw2mFshoQXA0dDD1J7ECwLkZnOEVnMvgchIDEUhNYOzO17QAjU4jwU3cCRm0G/96OTiDItQUTx4/F7CbxHvNeyIOgqxnnWL/GGW7GMCJY9CexepN7d2AtmIRwJGL4i+nHBCTq3914kPJw548cjZgkeacLF8bQX0XWdO+/8EcHgALIs43A4+elPfzHE0f2j5ojU2vftOlJ674nMsVJrHxYpTDBaT89AHU5nGg82D/BG89BiXIBbxs3m7zvWsSRjDN8qnotRo9Lt30J93wraurcjSSr+hCIcqhdJklm25V5Ma/hizelFn2V+7CokRUZ7qh5lXip9U2M8uOqqEfcBOG/2/eT9PAayQL2qEGNAQ4xNILBX9UkI8PaamH/ahXpFYbymK6xjBnXkqclYu/uxemMYy9pRzs/F7I4iFXkwG4PIaU60x2rjt2WMF/m0TKyeGFbMQEp1gmYisp0Q0DDbI/Fkiq3dqHPTsdrD6Nu7Uc7MpcdhEZEk/md5M22h4a/lyjwfN7zagTIlCRJVJFOgPV0fN3Us8SH8dmgMovkTaf6vCsMMXyUtBF9RFClBRd/WQ3hWMpoY/gvyQb5DLj2G0tuHrEoIIdCffB2rNZ7NJZITEPlZ4HMjJfnQ87Lpd390NhbHW23+46rWfqAOK4DDlvCR1GF9kjjmau3PPPMMf/vb3/a7DBcUFHDDDTdw4YUXfpjDjWI6catjcSeNpZ0gbzY/NeKmrzdWszirkJebqrgmawpKrIUdTa9QbDuDwr5LscIylgjQ696JLUVhfOF5bN3z9JDjKLKDsqQlGL+uRVyYh/Ao6C8346xxUTrrdHY0vDjs+dP9U0hsSwA6kMYlQIoDJcWB0RxCKnVjmlY8rdsmIc9PRXgUjNp+zKXt2K4vRlvRjrW2C/XKQgyvgrG1B/WSfIzVnUjZLsyDkjis7ijCZ8MMxJDLEtH+VoXVEUE+IxvjrZa48/FVRSjjktAerMYKxLD9vwkYAhJigkbDGDFYATzbPMAlZ2SSluPGChno/9wdF+hdkonp1IjUNiFN8RKpkIcNVgC9q8CVAtLaFsTpGXEFo8N8mLssHVtHNyLQDy4HlmUiVA9WcwfylDIsWULYVKy2LszqemiTsaaUoQwMIHk9J2w24icFCU88G/Ao29GMMpTDDlgPPPAAv/vd77jqqqv42te+BsD69eu5/fbb6e3t5brrrjvKTfx00R0LHPJ5VzvQw/yMfAwrHhh6XbsYV3UDsRVeDuTVufH6MrFd1kiSp42Z5V9g065/oRnxTL2UhBKWTPg2Se94sAijP98Qr5/6ww7EzhDTLryc2rbl+zME96HKDuZM/DLSShDJNsytvYgcN1KpD7Jd+zPj3IaE9dge5DOzif2tCvXKQuR8D7HHalBOzsTKdmL5bdiuKyZ2366491ZnGKnUh760DWlcAvLkZLTHatBfaUKen4b+dgvKkky05xswXm4CQdw65LEa6I6n66lXF6H9czdSvgep0IM+Qk9nH5ppYQQ0LDmMsSOAen0JRjRCwL6Tqq3309O+CalGJSvvfNIv+wwDz+ZgRUGoYOmABZYGht2JnOFA6tFx7QwjTU4gIo18bkkSqIqEhcDRG8B64hWMxjaw21AuPR3qWtBWbEQak4tUWoBwOaA/BG4nVkyD9m6M5g5EajLeq88j8D6CxqOM8knhsAPWP//5T26//fZBvalTTz2VkpIS7rnnntGAdQgkCSypF9MykIUHUx889CDJFjYO5ErbJJnShBQAqgKdRE2DdKeH7miYbJcPB30owWJiK4YOk5h9Av2FbHKuXsT/7lzPqePuwE0YhEJecjHpvanoy3Ygz0tDKvOhP14b39Gl0Gz4KZl4F1L/Kqrqnse0DMbknE565ul8f2Mv356Vy9SxKejP1SPcCmZTCCnJhjvdTtAOYcXEe35uvHLWtNAeqAZFgpgBssAKW0gIYg/uxvbFsfGgdFIGxpZu1BtLMHf3oy9tRb2yECtmYvVpmBW9yPneuPswxINFn4ZIsmF1x+LncspxNfjl7RjL20m7JA+3KhHUhu+CLMx0k1AxgNkQQjhlrAGNLttmNr7xnQP30dRorH2SdscbTPvcH3A2K4hQAGwONDmF7rUehDAgqKPdvwscMq6xPiLDxBAhwKxvwbu7AWtHDaIkD3P7HqzGeH2YfNJMrNYujHfXIy+egdUdQP/vQfJQdhvKqbMxNu3Eam7H6uhG2rqThImlWJJE2O5Asz55w/OjjLKPww5YHR0dTJ06dcjyqVOn0tFxaPuLTzO6aKS5cxM76l8hpvWTnTqVkpxT8drKsMz4xxAhiNcMMM2fTllSBl7VztbuVizgc2OnEdI17JLMY7u38rUJs7ALFX19ysjnbJGQuz1U9LZT0du+f3m2u5vflp9GzheKMXb3I1IcoJmolxcgxvp4q3U3T+7pINc9kcX5s7BJEo+0h6iqjwvTVgf7mehOQzk7B7MphPFiE9INxehOAaaF0xRIdglzex/qVWPiD3LdQF6SidUTxXyzFfnKQnArWIEYGCZWfRBzZSeYICywmsJozzbEe2H/qUE9Ixv9teb4MOD1xehP16M9WoN6XTFmQT/Gmi60x2qw3VJGbF0XqIKM+hA3zUvht5vah9wbWcBliS6c422YtQPIc1IJ76mjsv2XQ7YFiEV6aWt9nsK1SdDeA4AqSaSffjrCcMBeOwz1igIMZXg7joTeXmIPPgsD8WFPpTQfq6YJXA6Uk2YiCrPRHngGUZCF1RfE3Pqe5JdoDP2ld1EuOAX9v+8gTSlD2FREezdEIrgdDqx0PwH7aI9rlE8mH6oO66WXXuLmm28etPzFF1+koKDgaLXrE4Ummnhn069o6ty4f1lXXw3bap7n7Dn/R6pnDoZhIUs2Ors38aXy8/jp5hXs6e/Zv/3KtnryPYl8sXwW15VOoSk4AD4/ZpfCoSZNzMjQ2oqmYB8dIkJOph+pOYzVEUa5qgjTNJFNaA7GH6gNwRD/2jPU72hA0whVtJMwMQXz3TZst5ZhOWUsAzwayGu6EJOTwK2g/bsm3vuRBcbbrXHn4BQ75p5+1PNzsfo05EsL0P+xGzExEbnUh/bPPeBRIGwQe7Aa9dxcLLuEcl4uRAxwKijXjoEBHVMzkCYkIY9NABOM6gDqJfmgSGjP1nPayenI5Sn8ZXc3/Xt7Z/leG98s8zPmH3vQDipQjkwfIFrXOeK9bKh/kdwJ30J5c+/nYprw8svIFy+B8UmIRD/YTIRpcrAwkxACtxHDeP7t/cEKjwvhT0Q5ayEk+cCmwkAYQhHkcWPQXx5ajAvxj9qsbUa59AyMt9eir9sWX25TkedMQorG8OZn0W8bnVAZ5ZPHYQesW2+9la9//eusXbuWadPiFdgbNmxg1apV3H333Ue7fSc8kiRo6dwwKFjtwzA13tzwCy5a+EdkMrCZDmyqjxfrKwcFq33UDfSyur0em6SwvK2OuUofKWkLMfqGbLqfNhEeoV0Spm5hvNMGQT0uZnvtGPS3Wpg4NZGVbSP3lv0OB64EFbM3Fi82/t12lLOzcZf6sGIm+ivNmI1B1EVxPyzl4nyEV0V7vBarMYhZPwABHcmwkPLdhF0C53XFmMKCxr2qF58tjAvvPtOAyHBgxgyES4GoCTYJDAt9ew/sCSItyST2dH2893VZPtqT9fEe4y1jUXs0zvpPPTNPy6QzSUUe0MlWJDy7+jE1C9tXy9HfbMHY1AVzD529YJlavGv2Hsy6FqzgbqydNeBPRjl1Do7CbJRoDLm1A6uzB9nngYklGAMhcDmRp5WjPfX6gQBmt6Fce37834YJh1DKkAqz0Z94FbSDEkpiGsbS9chzpyCnJ6O43BiGecIXMI8yysEcdvXhGWecweOPP05SUhJvvPEGb7zxBklJSfznP//htNNOOxZtPKGxpD4qap4dcX0w0kkguM+DyCIhdR4vNNaPuP0L9buYl5rK/LQcukI7UGb3jritLQekpOCQ5YXeJPKiTiSIK0RAvOcixXsDs5NSUEYoVUh1OihRXSiJdvQn69H+UwcOGanAAzaZYKqC/Jk86Ncx2sKoVxRivNuG9kwdti+XYTSFkKenIs9OQfvnbgjq2OsjxH5ZgWiPYvREUa8pwuqMYuwIYLuxFO3NFkSvhvbrSqx+DWNzN8ICdWEGVmsY/YVG1AvzIGqg/WN3XCXj3Bwsy8TSTZRF6aQ8XkfZX6oZu66bxBw38vgkbDeVYnoUlPNzsX21HIfkQ1HdI97P9MyFKNVdQ5Zbze1I44vjukyd3ej/fQtnYyvi3kcxH30R67WV6E++hv7yMuRTZiOduQD9ubcOBCsApx0UGVGUA9LI81AiIwWzsW1wsDoIY80WxEAY9yvvkLC5koSBvkMdbpRRTig+VLn8hAkT+NWvfsVTTz3FU089xa9+9SvGjTt+ch0fZ0wrRjg6srgkgBASumiiI7gaoq1cWVBAwgi1ILpl0ttbybjouyS501jb90d8S4a+RstJJtFTtzAQeImT0nMPnAv4yrg5eBwOaAyhzElFOjU9PtwWM5FnplD4j0Z+Om0qzvdItaQ5Hfxg6iQKnm1He6Aa9aJ4Fbw8NxXTJgh6BKoOdEVRTsvCeLYB/cUmzM/m03JWKnvaegifm4lwSojk+PXF/rgD/a9V4FLi9icvN6M9VY/2WA3m5h4wTdRTs5AKPMiXFSAl21Em+zEbQ2hP1gJgCRG/MHXv11mWEA4ZSZWQ0hxYrQd6mVZ7BGIm5sp2tIeqMZQowUAnWksvtnaDkrLrhr3vkqSS5z8FalqHfn6JXsxdtShnLwKPC+XUOej/eQWi7xEbNEz0p15H9Lzn+5DoRVk8E/2vT8bT2INhRPLwsj5SQRbmrtph1+07B62dmGsqMF54B/OPj5LQ0Ij0PhmTo3x4wiLMruge1g5sYVd0D+ERRjWOJhdeeA67du085ucBWLduDfPmzeCxxx7+SM53KD7QkODAwAAej2f/vw/Fvu2OJw8//DB/+9vf6OjooKysjNtuu41JkyYdl7YoIpEs/yR2Nb4+7PqirIX0BZt5ec3txPbKKHmcqXxv7C38vSnErr7eQdt7VBtCD1BZ+wzR2EKy06ewO/ZvUj47EUdnFoRlzPQ+2pQNLN91NyC4at7dvN3WwMSkdL6QP5VJb+hISwRmXTAuejspCWNtJ9Z/+7H9TzlKmou5HSr3TZvFbiNEn6GTaLNRYHOR126hnpyNmdePsa4T4bfH9ftsMq6i+Gevv92GFdJQv1BCdaLBgw3VvN3RhgWM6fdwy5gSJlWZOBemx00bAfXcHMh1IeW7MavjitS2r45Ff6sNc0cA9apCaAwSe6oe9YZiRKEHxS5hzU9HSncQ+/MuiBnIp2RgLG1De7oe29fKsTqi8RqvSUlIBR705xvQ325DO91Nw6wBPOEmErv6ESu3Y0ZipC8eD3O+SfXGv6FF4/fel1xK2ZjrcT03vAKINCYX/YV30Du7CV8zA3uHhvTeYOVxIfwJEIxgdfaA2wnB+INNmT81ng1oGPGkitPnoZy1EO3fL4H+ngIwrxuhKIcu9XLakcqLMBtaYSCE/vALeL/yWQLuY1N0+2mm3erkR5vvpar/wKhIiS+fOybeQpoYOSHqRGFgoJ97772HuXPnH++mAB8wYM2cOZNly5bh9/uZMWPGsMoWlmUhhGD79uHN2T4qXnzxRe666y7uuOMOJk+ezIMPPsgNN9zAyy+/jN/v/8jbY+gyE4suYlfjG7w3OcLtSCE3dTpvb/rNoOUD4Q42bPox10/7P35QGcA4aCLi0tw8GuruBmBP87tML72K55b/P6JaP3bVgyI7CDX2YB2kKqrqPfxr8jmkrIzgfKID9Zqi+OR9og1hWpgVvVhV/cinZ2IMxJBPzUDf0EX+gJ2i4qT4/I7dwmzpxNrSg3VjCUZbGGVOatxs8dGauB6gTSKcIOG4bgxmtpNd9hhfWbGekH5g+Gp3/wDf2rSRH0+ewEkNfSiXJWPu1NGeqMN2Yylm24G3U21lO8q0ZMwt3Wj3x4OFND4RHDLmmk6MpW0oVxagb+tFOSUT0h2Y9QOo15fERXWj8bkg9YYSRKodszWMen0xbQUmr7TvJDlq49S3d6A2tu//ZKTnV+O9ciJT596OaOlGCBl7m4k9mIIeqhjy+cqzJmLWNGF53QROTqFi1W3MSfyfA0MXCR6UhdOx+oNYbV2IND8i3Y80fgzmmgpEfhaWqiBNLAFZwqprRn/2LSjIQv3cBZhVdZjba8CuIk0fh5SXEZ+vemfdsN83kZECOZlILjfSlHJwOzFXbkTUt0D5aMA6moRFeEiwAqjqq+NHW//EbyZ/C6d1ZMkvx9MPC+BXv/o51133Bd5+++MhyfeBAtaDDz64X3DxoYceOqYNOlIeeOABLrvsMj7zmc8AcMcdd/D222/z5JNPfmSmk0KAZnUwEGnGsiwSPTmcPefHvL7+Z/t7UQALJn6JpZt/P8JRLJrqHufkjAt5vaURgNMys8jWKtkVOjAsNRBqQ1UcRLV+otrAsGK3kpB5fcsXOL/8x7ia3Xvdd1uxOiOINAdySQLmlh6kQi+WBNq/a1EuykNoFtqydpQcN0ZlL8q8NJiUFHf3vTgfSzfo84Lnc2MQhkXQCVHLQi72EBEG/61tGhSsDua3O3YxTnHhf+0VpCnjkE8pxQrqoEjYvlaOvqoDc00X4uRMpALP/l6XPDcVElTE9GSUMh80h5FsMhT7oC2MJEtYPgVzazfmy03YbirF2N2P8fAebLeW0euzuK92NX2axndsuaht3UPa5mg3Celd+J45oA+nu+tQlszBCkfjUkluJ9LYQsz12zB31KCdPYEtFT/D0KOYnr32Cx4Xysmz4r2ng3tKayuQlsxFvekSrFAUsBD5maAbiLEFmKaJ0I34PBcCkZsOmo7x7gbEGfMRHhciyYfVMzjbRuRmIM+agH7f4xA74HYsTS1HuBxIkjihbU8+bjREWoYEq31U9dXREGmh1F70oY9/vP2w3nzzdSRJYtGixSdWwJo1a9aw//64EYvF2LZtG1/84hf3L5MkiXnz5rFx49AsvUPx3k7kvr/fVzZRRGnoepu61lUUZS/AMGKEoi0kews4a9YdWFjYbV7C0V5kIRM+hKdOW9cmLi2/hen+DFxGJ4G219lV+/agbSRkSnJOZWPVY8Mew+NMw+VMJhTp4pna73LF1N/grQkjjU9EHuvDtCzMZe3xFPS/VmH7chl6QxD9kRqsvhgi2YY1NxXJJoFuQroDeUE6VlsE7ZE9uD9XhDBAf6sN9wU52O0SPFFD7JIsXm5oHPHauqMxWlLT8APmpkrkUxOw0jPiKekC5HlpyAvSMZa2YVb3I3JcSIU2rN5mrM3VEI0hyosRriS057qQJ4cw1naCW8U21gelCZirO4n9Kp72Lc1OwVQE7ZLFooxJtIc0lksSeV/8LFnVdfhfWcq+lDplRTWuaxYjkloPBIVgGP3Fd8HlQKQkIhQZs6IKc0dc8zHoDqFr8QSXfkcAv6ogz5mM/vLyocN6gPn6SsR1FyFiMYx312O17E2nl2XkuZOw7DasjnimqNVxIKjqT76Gcv7JyHMmY/X2YWzYDrEYoiAHefF09H8MTfAxN24Hu4pcmMeR1BV/4N/AMeLjJlkaOIQTAkBAH4DDkyUcxPH0w+rq6uSBB/7Kvffe/+Ev4Bhw2GntS5cuxeVyMWPGDCA+X/T4449TXFzMD3/4w2Fv6EdFT08PhmEMGfrz+/3s2bPnsI7l9w8/fDLS8oFwJ12B3QSCTTjsHgoz5/LO5t+iyk5mlV/HS2t+RFpSGcnefDZW/RvdiDJ/4i2HbIMkKYR61pNumayq/OuQ9YrswOfKoifUSII7m0CwadB6IWRmll1Le/cOACKxPtrTmki0zcTKcBL74w6U83KRT8tEWZyOsb4bozeK7eYyLM3E1A3kBDtmQwip0ANBHf3NVpQzskC3QAjMJxoQ89Mwq/rQHtwNgNURxRxIO1Rm9hCMd9ehlpViKjI0hyHXhbm9F5HuRJqSjHxSIsbb72Curz2wU3U9uJ2ol5yF9mgnSAL10rilg5TlRGS69htMyhOS2O00+MfOapY2t+wfAsxxufhc2Times4i5Ym9+onhKMqz6xBnz8N6+OXBDQ1FsBpakaePjw/d7cU8SKFkx+4HmHnRt3ENqBCJMhLWtmosjxN5ShlMsrB0A2P9NoxlG5GmlCGNycXc3TB4p5iGFQxh7qiF7DSU6y8C1Y4ZFZhvvjXseQDMNVvxLZyOlJk64jYflJF+A582EtRDz9cnKMd+Pv9Y+WHt2LGdzs5OrrnmCgACgV6WLXuHnp4ebrnlK8f8ukbisAPWL3/5S771rW8BsHPnTu666y6uv/56Vq9ezc9+9jPuuuuuo97I40FX11C1dr/fu3+5JQaIaF1IQkZWFZZt+T2NHevilh2Ay+FnwYQvgYC3N/4WtzOF3LQZvL3x1/uP2dNfT0pCMZ2B6mHbUJpzKpoWJqoNHQYAOGni19FjURw2HwsmfonWnu3sqHsZTQ+TkzqVgsy5xLQQW3YfENPtDO+hmJmIjn5sN+aBx4mxvhu5xIe0OA3qw3HbkIVpiBw3sX9UIi9Mx2gNYyxvj0/DzU9DS5ARYzxYW3oxN3ejnJ+L/lz84aqcmklygpPTsjN5vn74XpbPppLRf1Bad0zD3NWFVJJD7L4qpIlJyKdlYdUMIM3wY7XWYw2XHRcMo69ajjx1Jsa6AFZXFDNmYG3txWqPIJ2Sgfl2K709Ie6NNLP6PfVljaEQv9m8kR9Om076RachQiFQZMyGViTNInbF2SgvLYVA/G3aSklEnLEA441VHKw6a+PAQzwa7mDd7l+zoPD/hr12AFwOpOJcjJWb0Gub48scduS5k7ECA5gbK1HOWTw0YAFWXQvKmfOxegIITUeLupFjvRj1QzMY92NaGN0ButUP7+773t/AR82+839cyHVkUuLLp6qvbsi6El8+uY7MI/L8Op5+WPPnL+Sllw4kit15548oLS3liiuu+vAXdBQ47IDV2NjImDFjAHj11Vc55ZRT+MY3vsG2bds+sjmikUhKSkKWZbq6BtfKdHV1kZJyeBk7lsWwP0oLja7QZrbueZrslIn4E4rYXbMUm+JgVvnnMUyNdTv+SSjSxbtb/sCSGd/DMGOcMvVbvLpu8ANsZ/1rnDTl67y96TcYpjZondOWSIZ/AoneYoTsICWxhA27HiEc7SUreSJl+Weyec9TtHTFDfNSE0uYUnI5ZflnIoDW7ko2VT3B3Ak3kp06lUhzPzFtgLHJ8xB19RjL12H0BxGZaUiTp2LUW4igG6EIpDEejHf3yhn5VKRCD9ojNfFi3BuK0d9pRV2YTmxLL6LMhzQxCWPpXj28eakYe/pQct1clJTJq3ILUWPokNitOTmkPHeQ35cAkenBihqoXy7D8ihYdUH0J+pQrszGXLZ25A+ruQ35DBdmXQT9lWbUL5TAonSUkzMw1neh3lhKTbLO6rXDF0OHDYON3d2UIUh6ZXm8OYU5gKDNkllxxtlMtxl4bDLvhCXWdGnccspCcioqccgSUlEOiZbJ4pJfEnKGqO94g7aWpUQdDkYyE1dOnYP+1OuDU98jUYy31iDPnYLIShux1kq4nZgtHUhpfrR/PANXXRGXtHI7sd6bnXgwsnzYgUYRMkoormKCK77zSL+NTxtOy8kdE2/hR1v/NCho7csSPNKEi+Pph/Vx5bD9sGbNmsUjjzxCcXExV155JRdeeCGXX345jY2NnHPOOWzevPlYtfUDcemllzJp0iRuu+02AEzT5KSTTuLqq68+rIA6kh/WnqZVxPQA4WiAurbVVDcNHobxONOYVf453tr4GyzLYN74m2juqqA4ezGvrx/a+/S6MphZdg11bWuoa12NLCmU5JxKpn8CWNDas5Pc9Oms2/EQk4suIsMzjp3Nr7O2+qEhBo0Om4+5E77Itj3PMb7wPGyqi3c3/wGHPYHSnFPItpWQ9XoH1p6mIe2Qz1yIKBmHOWAg9etoD8WH9+S5qWCaGKvjLwHyDD+kOxETEzAqA0hTkxGNIfS/VaN+aSzGinbkskTw2zC39LBrvpd7d+9iQ098PibD5eQrWVnMWLUVx64DP3JpbBHyaadiNcfQ32lDvSQ/Lnq7oxfhMTFW/XfEBziAcvVFEE2IF92qUjxNvy2MPD0Fkebg5aQQP9k08nezLCmBO9OySXvgyQMLs9OJnT6TZ60E/lTZh88mc2aBD69NRhKCGXaD0g0bsVZtGXQsY0oBjbkNJGVfgO/fr8N7kyP8iUilBRgrNw3fGFlCOWM+mNawEk3KuYuxNC2eYVjbjGWzYSZlITdWY7y1ZpgDgkhJwvrCZ+gXI4XQ92wvwDFgR6sHa2/ipmlY2HNl9PQYuvjove0/rn5YYRGmIdJCQB8gQfGQ68g84mD1aeKY+mFNmzaNu+66i2nTprF169b9cky1tbVkZGR8qAYfTT7/+c/zne98hwkTJjBp0iQefPBBwuEwF1988REfu6evgd5gLe9u+QMzxl49JFgBDITb2V73CsXZi6lqfJOuvj0UZ580YnJFf6iVNzf8kuyUqVy08LdEYv2Eot3xYNj4NqalU5Axk2C4g9fW/5TTZnyfNVX/GPZYkVgfhhGjLP8sqpuWkuzLY2b5tWzY9ShrdjzI53N/OWywAjBeXYaSkY0UdsYVKHwqIsmGsbID5dRM1FvLMJa1Y2zoxvbNcZh7gih5nnjCRpId27fHY3XHMLcFMHf0IeW5MXf1URox+GlpAS3zC4jE+nFF2vEGKpFKE6DRAaEI+DzIi+cRu6cK4VJQLskn9tcqEKB+thBjQzsiOw1r39DZexEC4XNjbApivNMef/3XrXgwzXNhOiUcylBNxYNxKQrOwHuGXpvaCEYaKbZv5SfTFvOP6gEe39WD1ybxhQI3pS2NQ4IVgLyploKM2fR7FQLnXUDCs0/vH1IEEEU5mDuHN+iMfxh7pZmGeZeU50zG3FWLNGcy+r/+G79/gPjspeBPRuSk71d/349NhYtOZ0By7vVFGRmbZWLv60MKGUS1DALvmOjde5NRkgSyS0LSZKR8czTjcC9OyxnPBtwX50ZvyzHjsAPWD3/4Q+644w5eeeUVfvSjH5Geng7EkzEWLlx41Bt4uJx99tl0d3fz+9//no6ODsrLy/nrX/962EOC70UIQSDUzFsbf015/pnsrH91xG1burZwxqzb2dO8DI8rA92M0ty5mdy06TS0rx92H68rnWVb76Wla+uQdbub32V84Xms2f4AwchQaaDB2y5FllQa2tfQ0L4GWVJZNPmr1Laswrm1ZeQdTQvC/Vi9MlKpD3lxOlZjGDPRhjQhEW1pK+qCdKyZKRg1AxhP1CHNSoGQjvFGK8oFuRhVAWw3lhC7dyfmrj6kYi9WsZNgwiZqXrgDDuoRKjYP06+4A19vElJOJtoTbSinZ6E/14D2l10ggXpdMfqT9YhpScgTZqDXPjds06XJ5ZiKC3mqB2NNF/RpoErIU5LjwbM8gaJ+E7skER3B7fCs7By8Dw49vj+SSOLSJkT7I0yeOp7wjInI1fWktHdgLB8589R6ZxPuwjSCdic1Z1xGcqwHW6gPw+7ESE0hcaTgu49EL5ZhIE0rj9dvJfniSRi76rA6e7CaO/YHKwDrxZfh8guQT5kL7Z0YldUQ1ZDKComUlNIo0nAHBaGIjCSB12thU7X9QUeSBM5wFPnVpVg79hC5/Gba/zW4F6X3WHQ9GyP1ChU1ohK1HWL4cZRRjgGHHbCysrL4y1/+MmT597///aPSoKPB1VdfzdVXX31Uj2lJATp6dmJZBnnps6lqeOOQ24ejPSye8jUS3Nl09lbTFahhZtk1tPXsHFSLBeCyJ1GaewrPLf/2sMfS9QiqEh9iEOLQalqq7CSmH9APNEyNVdv+ypzxNyIqzEO//IW1+FxShhPtgd2IbBfKkgy0p+uw6kNY45MwmoMIu4w0LRlzTTwVW5qSjNUeQTk1C33NAbVzszFE5GKNzW/czntfO/XYABs23Mnc0/6O8vcWrLYIYmFG3DdLM8EhI7wq8sI0pLE+jMY+5LMWY7yydJAwrCgpQBRMQAgZ/e2WeLBKUCGgYSxrRypwg0smc12Eb8wq567KbUMue1qKn4k9fRAcqkwvRQzMpvjcl3vnbnw2CWPZRsQZ8/crVQx/L6OIUIzEaDtqUw+9mUV0J6cgCxN/XyfStHKMvfNlQ7Cp4LRjPPAMIjMVkZyANLEE/bGXEWnJKBctQTsofV3kZaKdcRJ9lo1+JRMtM5vk4gm4nBY9YRu6rNJQrVO5/UAAUhRYOF8lO9PAMGUGAoLWTgO9ZBFZC5YQenawRYqwgZoiYekWvW9qpF7SALKLqJw08j0YZZSjzGEHLIjPC9XV1dHV1cV7p8Bmzpx5VBr2cUM3g4SiPciSSoI7i2RvIW29I6l6CEzL4O2Nv+HM2bfjdqUxe9x1LN18D3PHfYGegXpqWpYjkBiTvYj8jPm8vvYnI547L30mrV3xB60QMpJQMEcY2slJncqKisEvFOFYL7oRJViaimvPyLVRJCVgbYvuT6AgomN1x7AaQsjn5mDZBFKBFynNgf7Ke3oIAgjqmGs7kWanIJf60F9tpr1pGSONkWjRAMGBGpKycpAvzif292owLOS5qRirOtD+tQf1plKMyh6kdBdGIAP181diDQQgpoPPi5nux9JlJM0CzUKalYJyUgbGyo54YfTEJDS3hDo+kZNebSPz9Kn8u6uJip5eEu02LisqYFZbD6mPvji0gfLglwMpNRlzb72UZVmgKiPPq8kSliIhFCcuTx/ugXrMPY1gWYiiHKS8DIxEL/QOzQCVF83A6guCAKulAxQJ4XKifPZsrJaOuJbg3kSW2IypNE+ch2baWLlaIxSyyMqUKB5jo3qjTmenidMZo7REYepkwcbN8fbqOrz1js7559gJ9JqsWqcRjSqAwmlTVOzN8SQgoYJ6mkrACQ29JjZZkJ8gEQpZ6Ctvx33aD4koH72CzCifTg47YG3atIlvfvObNDc3DwlWHwdppmOFIjnwOFM5feYPCUd6KSs4k7ZNw19rQcYcGts3YFo6lbUvYFoGDlsCs8o/z/KKP+NxplKQMQ8hJGRnDhVBUO0JEBlqNOh2pDAQ6aS84Cwqap9jR93LLJj4ZZZu+d2QbbNTp9IXah02mBlmlPbkAQoO0rA7GGnsGKIJNroL9hApD+JwJ+JbJ+GoDyJP92Msa8d2dRGWBOa2XsyN3fuHBK26AeRL8zG29WL72jjMtghWTwz1+hICFUPrxw4mMtCFNHsKRksIZW4qpNqx+jSUSwoQNgkrrCOXJ8alpP7VTixm7FW+CCFNtqOcIxN7cDeMT0CanoSV7CCYIHCO9SLN9BNMkfG0aBi1A7hnpzFpRS/jcrIITSzBJks4FAtRXzFsSJXPXYyx8kCihhWKIFKTsABz6y6kyWMx1w3tsQFIU8sIqN0kBfyYm3fG1TH2IroDWL39KAumYbV1YWzaAZqOyExBnjkRc1s1Is0PCV6ksYVI44riGX7Z6UhOB9Ze8Vy9tIiNqbOxh1U2bIoRi0FSoiAnW2bpsgPDdTHNYu16jcwMiUkTFLZUHPh+rNugkZMtMXG8iqrCho0aQgZkkNyQ9Pkwne01qKbArqZTucdJhWFQWpTLlLQZGPXLEWMuGPIsGGWUY8FhB6wf/ehHTJgwgfvuu4/U1NRhdQU/iUhWMqmJpWyreYGUxCJaOrcyrfRKNux6dNB2KQnF5KbN4N0t9wBQ17aaOeNuYOW2+4lqA5w24/v0BeO9E4+ngD81hNjQuZVvj7sZV/NTNLUdGCZKS57IzLJreGX1bdgUJ+mJZWSkTKQo8zSSvIWs2/UQ7d2VuBx+JhRdQCQaYP2u4RWVZcnGmw33c/3n7ofnl0HD3vksVcU4dy69hS5eq/j2oF6jP3EMZy/6Ecl7UmB9F2bNAMb2XpQL8uL2HYaOvMCJub0dc91bSOmpWN2Aw4vITUTf2Ys3sYTO5lUj3le7JxkhyZiNQaQCD1K+G2tzD2Z7CGl+GoZDIiJZOAyw3VRC7O7tceWLXBdSlovYT+NzftaZWcjJdsyghpVsR0q2Y/TEsHsULJ8CMQvtwd0ol+QjNYaQn2lEvamE/jwHysnzsY8txly+HgIDiMx05LJxWMKGdZAFiNXcjjytPB6AWjqRp5RjpSVjtQ+WdxIpScizp6C6+rC2NA4KVkB8bkoS6P99B5HuR148AyHLmJ096C8ujbszF+WgnLMIy26D/iD6tt3Ezj8VlxAgy6Aq9E2cztatMtOmQGxvfCobq7Bm7eASiX20tJoUFsjI0n6DZFrbTHKyZdZt0Bg/TuaUk2309Fg4rlRISQoS2XI/9m1PICdkMW7GVyg7Yxq1rV42VxjkTDyLlI3fwFN4ClFx/EWvR/nkc9hp7VOmTOHZZ58lPz//WLXpY8F709plGeq7X6apcwvRWB8xLUhaYinZqVNo69mJbkTxOFMIBJvZXP0k+4bBJElhVtnnWFX5NwDmT/wSy7fGNbxsqoecCT/hZ5UVCGBhWhYL/S6EEQTJQZYvg+UrvoJmhJk85hImFl6IEF4kMxEJsBND7+8DAY3WVl5Ze+eQVHeAjORxZPqnUCrNJVMrxajsRMqEqN+iJbmZ3mgzG6v+TV9oaFKGy+Hnigl/JEHOhIhB7N6doJlIExOQpxjoT700ZMRPPudUzJ5E1LkZ9HRXsHrVl4a9x4rNw9wZf0H5Uy/qNWOwBjT0J+ridVQ2CT1ZRQlb0BcDvx1awpi1QYy3W0ERqBfno7/WjGWXsV2aT+zPu1DOzkZkOuPB6aR0xLhE0Kx4ivi/a7D2OgxLkxJRzs2h+6DsYxsWDt2EF1sx1/aAQ8b2lWy0Z1+DpnjvVxo3BnwezFWbQQjkRTMQTjtmbTz7UppYishKI/bnJpQvZmL86d/DDhsq5y6OawyOgHLuYkjzQ0c3enUd1lmLGbA7USwTdyiI1NPH9mAq62udpKdJ7NwVHyKcO1tl5erhAxZAbo5EQoKgvt6kr9/C5YTSEgVVFTQ1G7S0mmRmSDjsgp5ek5zUfsqz26jtSGVTlY9YDHxewbhyhUjEpHTgXrzTLyEiHfu5rI9rWntE6NSHA/RpUXyqnTxnAg7rQ822fCo5pmntkyZNoq6u7hMfsIYgdCr2/BcwcTtTkSSF9t5dmJZBXftaQuHOYYVnS7JPpqZlxf6/D1ZRj2kD2APLuG3Kefyhch1L25tZ2g4pDhc3jUmhYtvdaEZ8+C7Zl09Y68ej5CIj8DZEkFId6P8ZwGwMkv69UhZN/iorKv6Mph8Y8stJm8HiibditoWxOdxEl7YjrevDuCSTTdHnWL32n8yfeMuwwQogFOmiTezGvcmGnOcBpxwPWCUK+tMvDDs9Zbz4BvKZFxD95Tac6Qrjl3yHbZt+PmgbWXEwbcHPcbYlodn60B6Iq32IbGdc1/B321E/X4z+bAPSGC/ywjS0N1oQSXZs3xpP7N6dGBu7kRamY7zQiDWgI3xqXG1DiLgZZZ4nrofod2BW9MalmvYFrEIvZlDHaVMJy/GLMBDQqGGu2+v2HDHQ1kexPnshYqAvrpLucmK4HKjjimF9BeaeBhiThzh7ERGPl6hmIFvgvigfYUZGnOMy61uQxhdjbhuqciJNHgvJiViWiZmVhjaulIgUT8vXhUTA7cXu82HUKUSjBk7HgVGO93v91DRwOwV5uTKJifHEirp6E49bwu0WzJuj0thk0h+0yMyUycn1s77Ky+6aAwfu67dYtUZjXLmCkr8IQ3Z9alO5O8wQt298k+r+A9m7JT4/P5pyCqmS65id98ILz+EXv/gNpaVjj9k5brnlRlpbW/ZbRp199rlceeXRTWY7XA47YF1zzTX8/Oc/p7Ozk9LSUhRl8CHKysqOWuM+TliWhWFG6e6roTz/bFZu+wuTxlzMpuonmDf+Jt7e9Nsh+9hUD1kpk9nZ8BoAimwnnp1wgPyUCTjVHv4wayE7O3dhmjpyrInaih/tr91SZAf+hDGYe8dx3DGgJ4b2TD3q54rRnmsgcZuXMcpkUmf+ikC0CcPU8fuKGAi389zK79C/V+G9qHAB806+AexBVi39By6Hf/+6kWjq2EjpzIVof6+GPg15YRoY3SPbuFtAqBNkG6JVJyv7DLxWPj3GNkKRFnzuEpLSJuEeSEPf0o48JRljfRdSvideqOyWkS/Iw9wzgEh3YKzpxFjfFU/ImJgEqkC9uhAUCTMSwbrKj2aLol6Sj/ZOA9EJGvhl9OQIbbpKkxFAFFkUpnpJK3BjVQbQn22IJ3QcVO1g1wTWO22QZEP+YinmK81Yq7uQ5qTSlzi4BxFOT0M5bwmSZWIIgWFYoMVfRgwBA0UOvDELfB7oG/oiY27ZhTx/KspnlmC8tRarO4BISUReMB0y/JiqStDtQR8hKzRqWCQmSYTDBh7Pge+U8j6/6MwMiYrtBsFg/LObM0uhpFimsTH+3Vq+8kDvrKPDZPsOnQXzbLS2a/v32Ufldp3xJWP5tHpDRoQ+JFgBVPV1ccemN/nl9DNxnuA9ra997ZssXnzy8W7Gfg77bt56663A4DR2IcTHxg/rWCGwMTb3NJZt/SOBYBNeZzqK7ECRbFTUPMsp077F9rpXaOnaghAyxdknUZJ9Em9u/OX+Y0woPH9Q/da00qsIRrp4ec3tTCi8gOKMubyy9qdo+oF5E1VxsWjyrRiGTpIjHwsBEQNR5EV0R7FiJsKrYm7uwTsjFc9aLxkb7YiT0qhMW8Yb238x6Dr2tC2jsXsT58yOZyXqegSbMrItPIDLkYTRr6Gcno3VHcWMGAhtaAr4wViBPkRKNlZdEPPpFnyLS0lwjcPY04fxcCPCFUTLb0cu9KK/2Ih6aQFmYwizqg85yQ49URACZX46scoAGBYizYFIdWBs7YUJDnr7t1LX+ST9vVV4EoooHHc19WOfpK3mbRLkC9hkns4jtR3M9ru5KNWkKbSCJrORpIVTSTt9BopfJXZQ1yCkWrivyEcyIOAC17lZKKdn0e9m2B6Evm8iaJiVpgX9dhe+k2ZgPPf28DfJboPiPOScDDCt+EuRzUbE5SJmvH8UcLsN8nIlqncbTJuqsGGjTkurSV6uRH3D0KFhmw1cLjEo8Kxao3PW6TZSU6VBwWoflgWr1sSYOlllzbqh67v77GS6op9Kqab6cGBIsNpHVV8XDeEApY4jy6A83n5YHzcOO2C98cah648+qZimRVHWAtbueIgNux5l/oQvMhDuZO6Em9hR9zJvbfwNY7IWMX/CzSR6cglH+3hxdVweSgiZSUUXUZi5ABAUZS3EaU/E7UihdyAublpR8yxj805jZtm1SEImEgtgt/mwLIOVFfejGREuWvBb3FoE8699WIm2uArEqy0Im4R8eSHGuk6sXg1pTir9hSHe3fTHYa8lpg1Q27qSZF8h3X01OO2Jh7z2XP9M5IiEkWYHm0BxqZh1h55LEJlpqKeNQX+5GbqiWNsD6DsDqNcUYWa7IGIgT/UjQjrSgnTMPf0YKzqQJiehPbwbqzOKestYtM3dMN6DCIO1ZwCzdgBzjI3mnpfZse7u/fe3ZOb36Og1sKWeT37KHLa7Cvnn9mbmpni5zLaN7hV/39+27pZ17BEPMHXRXThsMzn4MRw8aPoipAIqH3q4yzQtjJICpDmT43NeByFNHouYXEqPZAfXe+ZMPkCwiqMzf66NikpoazNZME+lrc2kIE/G4RBUVRv7A0lSkmDKRJUVq4cW+/b3mzQ1j3xOTYvP4Q67ThcIYcOyPn1FxH3ayEr8+9d/eK3h4+6HBXDvvfdw331/oqCgkC996Vays3M+/AUdBQ47YGVnZx+LdpwQpCWN5fz5v+LdLfewvOLPJPsKcTqSmTPuCwhJorV7G5ZpsLXmOTL945k/8RYsy0SWVGpbV6O2O9nV8Bq6EWN84XnUta0myz8JVXEiSzZauypZUfFnQKAqzr1zUQceJO29u6hueocFl32eTFsRxu5+rKCGWRnArOrH6oggCj3IU/0EenYOKiB+LzsbXqU09zS6+2qobnyLqSWXs7Hq30O2m1lyLSlWHmYghuRUEE4FM6gh5WRgOGwQGeZBpSqItDQIGghJICYlIbJdyEk26NNBs5AXpCOpgti6TuRL82mWwwyMF7h7TdI7JMRNWXS7K2lMe56Ir5Xk9JmknzYHV70gkhlgx8vxtH6bI5G86X9k5ZYcmlviQ2Mul6BkssHJ6YKzknsGBat9WJbOpmW3MfesB0FJP7wvwmHQb3PiWjwT++Sx0NEV73qlJqEnJRKQbUd8fEnEmDJRIqbZiAQtMtMkDEvQ0Wkxd7aKaUJCgqCh0WTp8hjD6BATjlqEw4cOkiP1oNwuCPQLvIfupH8i8amHTs54v/Xvx/H0wwK4/fYfk56egWVZPPHEv/nmN7/KY489Oey2HxUfaoD1mWee4bHHHqOxsZF///vfZGdn849//IOcnByWLFlytNv4scKtFrNw0v8QifXQ019PgiebvlAbCe4MttU8T89eB9L6ttWD9ps+9mqEUBhXcC4uRxLVjW/T3LUFVXaS6MnBsiy6+vbpy1mDhgX30RdqwedK57m6H3LVnL/h7rXD7BTMuiBWRwTsEsopGWj374Jr3u8tXeCyJQPQ3LUFm+ph8eSvsadlOb0D9SS6c5mW+Bmykichnu5AOj8PY1cAc3Un6rVjsAIC5ayz0V95eZBEEA4b6mfPx4o50aoDKNP8YJoIVUJ7ph5sMspJ6ehP1CKS7HR+JY//tGzmqYZKYqaBXZL5zFllnObpo+7Nr+8/bG97Bd359bim30CPpuGYeweunm0kJpzCa+/moh3UTQqFLDavlDh3QSlK5+8ZyWbPNCL0D+zBnnjsAhZASFIJJfuRUlLw+z1DMlCPFNM0UeQIfq9BR22M2mACobBg+874TZk/V6Vy+8gagrIsyMoUtLUPL1sV3yb+/6REgd0uCARMsrNkdlYZ5OdK+DwK1vvoFH7SyHMmUOLzU9U3dFiwxOcnz5lwzJNRjpUfFrDfskQIwaWXXsE999xNINBLQkLisb2oQ3BonZ9heOSRR/jZz37G4sWL6e/vx9yrzebz+XjwwQePegM/dlgKbmUsie4xdASqeWHl93lt3Y/ZVvtf5k+4BVkaqobtdWXgsieyve4Ftu55hqWbf0/zXlsQu+pG0yOEIt0keg7de42nzTcRinTRGtxJY85u2jy1aBNtIAuImpg7+5CmJOPVU7EdwmBufNa5jI3Ooyh1AQC1rStYuuX3pHiLuLD855xb/RWKPHOw99hQJiQR+2UFwhIoJ2cS+9U2rMYQ+gYd5cpLkc86E/nMk1GuOh/5lPPQNpmIZAdKcQL6s3XgtaG92RJPVw/r6C82gUOh74Zc7tjxDo/VbSVmxl/9o6bBI43b+F1jC0llV+xtrSBl9vf4t3MOd23fSE3Exh5RTnvW1TT1jB8UrA6mrU6G0KE1+/TY8F5jx6K88FgX10aFjCfTQ0WljsslmD9XpXiMjKLEe53DIQSk+iUSEyWkEZ4GqSkCjxsWzFVJT5dx2AWTJiqUlym0tpl0d1vY+xUcYRvySAf5BOKwFH405RRKfIPnqfZlCR5pavvBflgQfzF57/Dd+/lhhcNhZs+eyy23fIXMzCxqampobm7C5XKxZMnpfPOb36ahoZ5wePALsq7rg2ya3nzzDZKTk49rsIIP0cP617/+xU9+8hOWLFnCfffdt3/5hAkT+PnPf36IPT85WBZIViqzSm+lNPsMttU+TU9/PTEtwkWLfs/22hfY3fwuimxnQtH5yJKNFRX3YZhDh8/Sk8rZVvtfAFISxhDPIhxGpVtSSfLk09S5CYCeSD2bqh8nHA2QmlHMkh98l6SnZcyqPpSL8wl5gsxKuY5lW/8w5Fh21Uth3kK8rzk4+5Qf0VPYSJg+HJYb77syyppQ3PDP3Yk00w8xBZFgQ38m3nvEpSAVepEKPBhrOpFm5mA1hND+3ohyUR5yliD2862ony1CvaIIozmINM0/OKvQsqiWBtjS2zakfQCbersYGDsFeIyksZfy506dREcy81PLeGhriJgZ5aoiL85ak6kT+0jyNIIZwxSpVO7JpL1doqvbYuyEKXQ1rhzxs1RsTiSCmMTHtGR6ifTXEAzsRlE9eJLLkGzZmNYHs+U43shOi4njZLZs0xECTjvFxs4qnTmzVFatjhE6SORElmDuHJUVqzQmTpA5ZbGNd5fHBll0paZILJyvUr3HYMvWAz2o2npQFJ2TF9kI9Bl0aiA1CVwhGft4maht5FqwTxKpkotfTj+ThoPqsHKdCUclO/B4+mFpmsY3v/k/aJqGEILExER++cu7j/iajpTDLhyeNGkSL730EtnZ2UydOpXnnnuO3NxcamtrOf/889myZajdwonISH5Yww3nyApgmViWjGlaSEoUzewGYSJJKrsb32J5xb1DzlGWdwapiaUIIWjvqaIoawFRrZ831v+cg4OWJCmcPuN/aezYTEP7aiaOuRhFUunur8PtSEGSZLbXvsT5U39GUm8qlkNmk7KN3dX/oCBjDlv2PE1goBEhJAoy5lKYOZ+e/iYWuT6PaI5g5TiRFBn9qXrM1jDqdWMw3mnD3NmH7avlaA/tRl6Sif5IfMhSOT8XK9kGVX2gSEiFXogZaM81wED8oSYyHCifyQenAu0RUCW0f1SDS0E5JQNjRTv3nxvkn81D1en3cU1eIeN23A1Tv8lP9zRwdeEZ3L/1QI/oxrF+FthqaNz6E8L98Z6UkBQyxlxOn7icjVsTOfec3VS9eSOWOXS4yuFOJ7PodBSbj+T8S0BvY+s73yEUGOwgWzz9Fvy5F2AeyQw6h/4OHU1MU6VyB2zdZjBrhsqqNRqqCmcssdHXbxEMxjMGIZ5wkZAgYZrg9wt0Hfr7LQwDFBm6ey38yYJ3lw8fgJwOmDFdJRaDxASBFLTw1Ro4F4AmHd0hwo9r4fAoR8YxLRzOyclh+/btQ5Iv3n333f1OxJ82DB3io6vxp5Cp25HJ3LsSijMuINlXyMaqR+nq24PXlUFJzsn09Nfvl3Aam3c6AoEiObho4d20dlfQ019Psjef1MRSWrsq0YwwU0ou490tf8A86AGsyA4WTb6Vlr5teNdNRA9E6TutjYb2tbR2b6M8/0w8BecAgvq2Nby54RckuLNJH3cOnfkSWXZB9m4T+3m5yFED/bkG1EsL4JRMzLYwykV5aH+rihcNKwL9+QbUa8ZgzkpBtivEHtiFlOpEnpWC8Wa8pktZkoX+eB3K6VlYhfHaJ+XCPIQqoVd0o1xRiKwdugRCEgLLgi5T5jMFU3h292ANxHJnA7uXfxXzILdmy9RpqXqYjDEa+bm30CVlkTnvx7StuhPjoIJqhzuDosnXUlvxGBmFpyAbzWxf/cshwQqgev2f8CaVoHimfbAvxHFGkjQmTZAYW6IQ0+JDgakpEhawdFk8eOk6zJuj0t1jUVF54P4lJAgWzrfR02MSDFvomklT88jjo+FIXId39VoNRYEzT7OjF4EUAJI+XXNaoxx7Djtgff7zn+fOO+8ktle8bMuWLfz3v//lvvvu4yc/GVlx/FON5SDZOYvTppeyq+kVOnp2srry7+jGgbTYnfWvkpU6g2WbfoNmREhwZ5OSUMzOhtdZse0+CjPnUZZ3Fq+suWOIuK1uRHh38z0snvINrM4ItglJ2JT4m4qmh9iy+6khTbLZvDzaUcVrLQ1ICK4omMgVezJIeC5upWF2RDDebMHqiqFelIdItMXlkyIG+pN14FEQrRFizzZgu7EEqz2C9mgNwm/Hihhoj9agXjsGMxBFCsSwIkZcQT2oI/JcWMJiRnIW67ubuCQxD7sF9WaEh9urCcTi96XcIREJd2ITMMmXyr9CB7IeixMUrNZXBwWrg2nd8wTTTruIynA/4x0O0hbfHheUD9QjJBm7MwXF7iGz6DTqKh9HtXnoads04kdYX/kYJXMmYZgnRiGoaZqoagxVtTFhvMKYApmOrvh8s6bBuHKFqmqD9o4DiRYF+TLZWRIrV8Xo6raw22HKJBW7DfbUjOwwvM9iTNfhraUxzjjVhtlhwKjzyChHmcP+9V166aXY7XbuvvtuwuEw3/zmN0lLS+P73/8+55xzzrFo4yeGnlDzfh3B4dha/TgTxlzMxl2PEAg2EQgecAcuzj6Z/lDbiLYimhFB08MIE4TfQZotD4ctgUhs+BqLjOxz+fueuByTicUjtVvw5Shc84US6IigP1KD7avlxH5TifZ0PerlBZgJCqI7gjw3Fe0/tdAZBa8KigCXjMh3o5yfi7BAe7o+HtSiOlbExHixCZHjQp6UhPFOG9b6HiYtdPGbFjv2F98F02RegodTF03mnwl9dEs6zs71RIACFUJ6F7Jw7C9RmppkEq4Zah+/j9TsORh961E23k9FNH4PnN4sCsZfSf2OJwn21pKefxKWZaDH+ofVYDyYgZ49CPo50Z7ClgUlYyRWrtYoKjyQBZaUKKjcfuCaU1MkkhLFoOJhw4CWVoPERMGsGQpr1g3/3Ts4uSwYtOjuMUlM+vQkX4zy0fGhXhfPP/98zj//fMLhMKFQCL9/1A/ngxDWRq6LAugLtZKaPBV4ZNDy7JSpmKZBR2/VoOUpCSWkJhYT1YLUt60mGu3D7NcxH6gi/XtlzJn8Hd5Zd9sg/UKA1OTJ1Bh+wkbvoOUPtW7llMIcMrcHsH1jHNo/d8dXSMTFZC/Kgzw31s5+2KvJZ7t2DEbdAHJJAupnC4n9fgdYFupni9D+vBPhUVGuLEQ5PQtpcjL6mg7UL48FWxTzoWewH+wHFRgg9fnl3HrKLILTSjDDdvIyp6B4klm5+z8szLyOt5vj1xI2JBTFyXDYnSkkpI1nx6pfDb7//c1sX/1bxs39JpUrf01b3duMnfVVJNlBQko5JdNuxuZMxtBDGFoIISlosX4adz6Lw5OBdAIaEyiKRjRqp7XNJDMzrhcYDFpD6rFKS2RWrDoQrKZOVrDbBQ2NBu3tFgX5EvPnqqxdpxE7qFOblCjo6xs8ISfJgojtvSJko4xy5BzR+IbT6cTpHP6hMcpQVDXxkOsTvUX4PIWkJ4+jo2cXLkcy5flnYVkGK7b9mXH58R5soieXKcWX0tpTSWv3Nuyqj1nlnyc9qRzblQUYm7rxRCSK6saStPB3bKt5hpauCuyql4yc86g1U/j7nt1Dzh/SNbp7+8l0yFhRE6ImytnZSBOS0P61G5HnxmoMYazuALsEMZPYP3dju74Ec2s35Hmwfb6Y2F92ov21ClwyypWFxFY2o8+XMGN92GckYD3XjDI9CopC95nzMVQFb10zjopqMC3Ut9fiK0lh5brfEA11kFp4KgG9jiWFrWzuyqAnarC0zeKi0s8wsOZXQ64ju+Rs6rb9Z/ibbJm01rxJas48Ap2VeBIL6GxcydqX45JjLl8ueWUXE+xrINhbSzTcQ8n0LyKQMY0TU80hvLdMrrJSZ+4cG8tXxoak7RvGgeLgmdNVausMOjoP9MBa20wcDpg318bSZTFMM67aPmmiyrvLB98Xux1QP4VaTaMccw47YPX09PD73/+e1atXD+s4vGbNmqPWuE8aDkcO2enzaGpbMez64sIriJHEGTN+TVBvYXf9y1TUPEs42guA2+nH7UhhSvGlvLP5d4N6Tq3dFRSmzye1pACHUyZ293Z8N5WwruFhAgNN5KfPJjV1Nv+7o5Wu6J4R22hzqQgXGGs6UG8eizWgYQViqFcWYjQEEVjgU1GvLIKQhvZEPegm+GxYDhkrqKOcnRNXTQeC7hZqih+jZdWrWJaB05vN5LN+QG/Ew8snT+OJtjbCusHUHD/XTS2j/M21qA2txFrriYbi82k9jaspm3IZq7Z8l6+Ou42aaAFvtsjYEsvxJBYx0Dv4emTFgbb3ng1Hd8t6SqbdRErOHDa9+T0MPYKsupBlB4rqob3+XTKLzwQgLW8h0VAP/uxZWKb5ISoXjy+maeHcm3gVjcHqtTFmzVBJTBCDfLH24XELNM2io9PEnyyw2QTdPSbRKEQisHOXzikn2YiELXwJEq+8Gt0/hwWQlSnR3m6SlmKhj+ZcjHKUOeyA9e1vf5v6+no+85nPkJKS8qkxcDwaGJaNstKbCUU66QnsGrSurPh6hKuUkG6QJLsIBVvZVP34oG0q9jzHkhnf5ZU1dw4Z5gOoaVtOk3sjhdvysd1citY+QIdeTVvPdtp6tpPQsYHTsm7msbqaIfsCTEhMwZ4awNhioJyZg76sHXlqElZIRzhlrG0BTJ+Ken4u2t+qkC/Px/Y/ZcTu2YFU4Ea2paA9tAepxIvty2X099SwbsVXiUV69p8j3N9EvaJzR0szLeEDChkbegNs6A1w50nTWfTsO4NK0XRtAGdMJ8mTy5atP8DjTOW7Y7+ILaKQW3YhkVAXLbtfQY8NkJw5DZ//0I4BkqSi2H30tG7E5x9Lev5JGHoYQ4/i8GRgmTqhvibS8hZTueJnyIqTxPQJYAk4cjWljxTLAq/XIitTornFJByOK7IvXqAwa+YB76x9Ku8lxTLhiMWCuSrtnfFANWGcit0O6zdqe00gLdo7TGrqjEEBLy1VorBApqbWYHz5p6eHFREmDeEwgViMBJuNXKcTh3Vs32w+CnsRy7L461//wquvvozNZiMhIZF7773v/Xc8hhx2wFq3bh2PPvroJ9ZG5FjiFDIvdQomjvsRsXADWrghPg9jz0eyZ/Lgrma+N8kPJhjGUGHN7v5aevsbicT6RjzHxt6nKTzz/4j9aSfql8rI6C+jZa+qRmCggUmOfnJdXhpCgxUe3IqNq3L9vL3pdi674XfIYRuyVwGXguFTEZH48KD2nzq0lR2IqUkIIdBfaY4nUqzswNwWAI+Cck4O+u4+OlLWDwpWAHZXCuuD8qBgdTC/amigfP4UVMdgf67Gzf9kytRrCWefjKaHiNS8ztbGuPyVzeknPX8xiurCm1xKV+t63An5BIdJUQdILzwFLDAMjYTU8exY87vBn5M3i6LJ11Hx7k8YO/PL7Fz7B+q3Pc7YmbcSPQGfw4qsMXumnbfeidEbiF9ANCbYU2OweIGNxiaDrm6TokKZ1FSJmlqDZQclX9TVG9hsMH+OjWUrY0gS5OXKhEIWebkylnWgZmv5So1TT1YxzUMLw35S6DA17tywmerAgd9kcYKPH06bTOowqjcnEo8//ijV1VU88sh/UFV1v7r78eSwA1ZRURGRyPAPm1EOjWrAtBQ/v9myjdPz8rA7CzAtQXcwwsvbd/GNSeNxW/F6GY8zY9hj7DN0HImIFsC0mQi7jHbPdsbeejIbOdBTq9j6K74w7lZaKeG19m5ipsHClGTGOWNs3/JjIrE+ehM7cfe40d9sQb2qEFWSsQwTY2MP8rhErDJf3FKmLYy0JBPRGsZYGR++E6kOzD4Ncww0bnhuSPvceafx35aR1P2gL6bRWOzH2vGXwfsl5JKeMplA1y4c7kIqGh9GUd1kFZ+N3eUHy8I0Y+ze/HeyxpxJ/rjL2L7qN0N6oqrdR1L6VByedLIcp7H57duGtCHc30zjjmeYuOg2arf9m+zS86jb9m9yyy/B4fWhmSea0quJ2xXl9FPt9PVbdHaZJCQI2jtM2jtiZGZI2OwSebkCy4Sq6qG991gs3sMaX66QnibR2GSweu3QMb+kREFaivWpsBuJCHNIsAKoDvRx54bN/GLmNJxH2NM6nvYi//rXQ/zxj39BVeOB1+9PGbLNR81hB6wf/ehH/PrXv+bLX/4yJSUl+y9mH/vcKY8mjY2N3HvvvaxatYrOzk7S0tI4//zzufnmm7HZDozR7NixgzvvvJOtW7eSnJzM1VdfzY033njU23MkjLG7+dL4cn67dRsde3sZCTYbt04oZ7I3Yf8P3ePIIy1pHO09lYP2j5tAjky+fxaKbkeckYVVHyR5h+D00u/x6q6fARampbNt229JdOdy29RvU9X0Nm2Nj7A5eEBzzzJ1jIpeRKGHPtmGpoHdpWBvCmJV9SONT8DYFkBkOlGnJBN7uAY8ClJZAua6Lsy1nTDXMbzEt6QSMw+dQh5WY0S6Kvb/7UsZT8H4y9nw+v8jOXMalmXhTiggr/xiaiseJTwQ740pNg/55ZfidKdTvelvlM/9Bu31y+hqWhNXwCg8hcyi0+lq2YjTk0nDjqdHbEOgs5JQXwNpufORFQdgEepvQLX7QCk+ZPs/jliWic0Wo7NL4PPKNDYapKZIdHSatLTG/4tGZaKH6EL29Vv4/RK7qnTKxioosmDLNp3+fgtFgfHlCuVlAkn6dPSuGsLhIcFqH9WBPhrDYUocH/7l5njaiwSDA3R3d7N06du8+WbcUurKK68aJP10PDjsgOXz+RgYGOBzn/vcoOXH0sBxz549WJbFnXfeSX5+Prt27eK2224jHA7zne98B4CBgQFuuOEG5s6dyx133MGuXbv4/ve/j8/n4/LLLz/qbfqwSBZMcnn5w5xZtEejmFik2ez4hIJ5kNaeMD2cNu123t7yM5o6Nuxf3tVXS2HmAmpahtYgSUKhTD0JKRCXSRJFHtR0H8UvFJJ6yr20Kbvpd3TjdCQSiQZ4bdV3h1iQJHhycMUSCM5KZ/uAnU2vmPGAZYeZi0oYM6YTx8v14JRRLsjFWNmBPDsFqTwBK2oiPApShgu2DZBddA7VFX8ddPxo6yoWZM/g2cbhH2qqJJHt8rFH7FP/FpRM+wIbX/82lmWgqG5C/S3kj7+UypW/hoPqp/TYALs3P8DYmbdiGhqVK36JP2sWY6Zcj9dfSvWG+0hKn0K4v4E+m4tgX8MhPyvTiFG96e9MPfmnCElBCBlTjyDZxKDP6kTBsgzGFDlpajbZsdNg0QIb766I7U+OKCuVWbbi0BqApgEVlQZut0SKX7BgnorDLhACfN4omnbol5FPEoHYobNG+2LaEflhHU97EV03MAydaDTK3//+EM3Nzdx003UUFBRSUlL64S/qCDnsgPWtb30LVVX59a9/jd/v/0iSLhYtWsSiRYv2/52bm0tNTQ2PPvro/oD13HPPoWkaP/3pT7HZbJSUlLB9+3YeeOCBj1XAgnjHw2VJFKh7SwIsMIfpjSikc9qUuxiINRCOdqMqbnzOvL1meYKalnf3b+u0JXJGwfdIetcDk0F4VdRzc8EpI1X0kvjPIIm2MXT8vzEEjR6WbfnjIKWNOILZ5Z/HFsri1SqV5oNUEKJRWLZapy0nkYUzwqjrOrBaw5gNIYRXAVmgv9mM5LOhbe3Bdn0J6cZC6uyPo0UPvIUGu3exqDzGy5JEdJie1jW5BeQ22khZfA97qh7GRCfYW7tf0aK/p5q8ss/QVvv2oGB1MLs3/4P88kvYvfkBuprX0NW8htIZXyYa7sLhTsPnLyPQUYHTk7k/E3E4JNmGZepEIz2Mm/ttXN4cZJsHIcH7dBI/tiiyTl+fwJ8isXqdxpmn29m922AgaNLZZZKcLNHXP7KqRUyzkASoKjS3mMhy3BwyJdn4VAUriI+MHAqf7djPYR0re5GEhARcLhdnnnk2AFlZWUyaNIXKym0nVsCqqqri6aefpqio6Fi05wPT398/6G1j06ZNzJgxY9AQ4YIFC7j//vsJBALDvpkcivfG4X1/f+RJkZYDj1qCZ993f29cWzzxNmaObSISbEexbCT2puLeoqKck47RFUH9Yml8054YUqEXo09DPSMLJwG6tXpOmfb/2FH/KvVt8TKEtKQyJhVdhN9ZQHfYMShYHUxVI0w+M5eUxn70t9uwfaGE2IPVsLQV22fHoD26G7piaJXtmCU6k0+6k7rK/9DRsAKwsLtSydCa+NmUSfyxupvqvvgQh0uR+XxJMackq+zZ+QBdG9eTmjOXzPxTaW14a//5Q32NuBML2bH2nhFvmR7rR5IPPCzszhQMI0rJ1BvZueaPjJv3LSTZhmpz09s+vFizJ2kMA711e8/ZQP2OpxAISmd8iYR0G0IMP8d4KI7bd+ggJEnH4VQoHSNTvcdg8xaNpETB9Kkqz70QZcE8G7V1wwes9DSJzk6T4mKZUMhENwTdPRZpaQLpKAvdDsfHLSE51+mkOME37LBgcYKPXKfziPywDrYXOXhI8OBn2fvZi0iSxOzZc5k1aw4bN66npqYGWZZJTU1jyZLTmTt3HmedtYRwODREsf20085g5coVXHLJZQQCASorK7jqqms//AUdBQ47YE2YMIHW1tbjGrDq6ur417/+tb93BdDZ2UlOzmD75pSUlP3rDjdg+f3Dq0KPtPyjxwukoPdGYGsveFVMtRejug90C+2VZtRrxxB7tAbtDA/RRW5Efy/u9QpStkmfvZ2xuadTnH0yAHbFjWFqJBhprG455IlpazHI/GwhVtAg9qcd8cLhPQPE7q5EvamUaHc7teaT1L37H8DCnzWTkulfxOFKw7J0dq79I4Ye4VsTb0TknYahyqTYHTgCFax/4Zv7EyWCgVpUuxfVnjjo/P3du5AkG6ZxiOQfEX9bVFQ3ExfdjmGEiIV7GDf/W2xf8Sv6e6rJKDyV7JJzaar676BdbU4/eeUXs2PV3fG/HYkYWtz9uXLlL5mw4AckZ6h4kgo+0Cf1Xo73d6isxOTJZyOMLZVJSpRI8Ami0XivsapaZ+F8lWUrtEFTkElJgtIShbXrYixcYGP3boO0NEFtnUF6mg2f9wTL9z8KOCyJH06bPGKW4JGmth9PexGAL33pVn7849t56ql4Ef7VV1/H+PETjuiajpTDthd56aWX+MMf/sANN9xAaWkpijI45h1OuvuvfvUr7r///kNu8+KLLw5SgW9ra+Pqq69m1qxZ/N///d/+5ddffz05OTnceeed+5dVV1dzzjnnDDnGB6Gra6i9iN/vHbL8eKMa4KwOIdll8KmYW3uQSn2YW3owxjtotG1j6Z4/0zNQixASpdmnMSPpUmKxIJt7nwcV7KqP3ISpZOlluPu9LO1xs3Xk2mIWzJAZv6kGdW4a2t+rIWoikmzgVZHnp9Hoep3tm3477L5jpnyehh3P7E93n3rewzTHBB67nVjtszRseWjQ9ml5C/Fnz6Z6w18xjQje5BLciYXIso367U8Mew6XL4ey2V8n0LENT+IYAl2VNOx4Gn/WTLRoHz2tG/dvm5Izl5zS8+luWYcWG8CTUIBlGezZ8i9MI4LN6Se39Hx2b37gwD7ZsymYeC2Sc/wH/ZiAj9d3SNNt1NSCYQpUBdweWLtWR5LjDsWhkAUIwmELRYb+AYtw2CIzQ0ZRYWuFRkmxQlamwG77aLKG992/Y8GR2IuEhUljOExfTMNnU8lxOo84O/DTxDG1F/n61+O25d///vf3LxNCfKiki+uvv56LLrrokNvk5ubu/3dbWxvXXnstU6dO5cc//vGg7VJSUujsHFwnsO/vfT2tw8Gyhk9yG2n58UKTBS6/HasniugwMV5rwdzdj0h3UKWv4NUdd+3f1rJMdja+Ql37Sj5T9htOrfgsxpIExM4ILl8G2hO1WJNl8gs8bN0z8kWmJ4HttGzMphDqVUXorzWjzE5FZLkI9rcQdppkzLoJWcgQ7KJt54voWjyVvWHns2QVn0Vd5eOk5Mxh24DBb3c0EdR0zs+fxxmnL6Du1Zv2n6u9YTnphaeRd8r/UdFfR6URpdCbw1xbAq01rxOL9A5qmxAy+eOvwDINFJuPgUANtVsfBiApbSI71w42tOxsXEl/dzWlM75E3bbHaat9G3Pv3J7dlcqYKZ9n55rBw4+97dvQor24vdKHmrf5OHyHFDlGWakgFHbQ1Gzy7jKNBXNt9A9YLF0WY9oUG8tXxMjLk0lLlXA4BK1tJrphMGmiwpxZNiIRC5cz9qlXtHBaUjwbcN+z9mP0fPikcdgB64033jhqJ09OTiY5OfkDbbsvWI0fP5677roL6T1W3FOmTOHuu+9G07T9qfYrVqygsLDwsIcDTyQUC2gMxZUoBjTkUzMw3mhlYLLGO3XDz/NEYn1UhF5h+qwLcf6+FdvXx4FpoVxWCBKkdIVIT3bS1j1036I8iSS7gdVvoD9Sg8h2IU9NRnuyjvBVPtaqT1Kx7bn96uc+VybzZ99M68aHiAbbiYW7caeNI8NzE9Wd64nV/JIvZc1Dc47n3l1dVPY4+MrsH9C8Ot57dvnLaPJl8rOKh7gg/2SaBpp4tPYV7ik4m6LJ19HfvZvWmtcxjRj+7Fmk5S2ktuJR3An5WKaO05vJ2Fm3UrX+/hG1AKOhDnauvYf8cZeT57wYw4hg6jFikV52rvk9hj64B6HavTicKchSFI0TtzjUMCwc9gjZWQ5q6yRq6wxKS2T6++M1V3Pn2AgETGpqDRwOQfEYmc4uEyx46dUoKX6JjPSP2cTSKJ9oDjtgvde48aOgra2Na665hqysLL7zne/Q3X3gSZqamgrAeeedxx//+Ed+8IMfcOONN1JVVcVDDz3E9773vY+8vR8lwgJLNxGZHiTDor+mi/rP26nzd5Guf4kES6ex9jl6AtWD9qtqfJP08WWM/ewsLN2Efh0ry4HYE8T+WA1nXF/GloCdrVVxZW9VhWkTZcYVgLMzir62A+W8HPTnG9GbQpizPaySHqOy5oVB5+kLtfDq1t9xxuSvULvit+RM+iyra5+hvmPt/m1aurZgUz18d9L/ccfWPnqKxoGQwDJxT/4cj9S/yfyMKbzYuIw9A43xnfQoO9b+EU9SEfnjL0NICr1tW6lc8QsgrqghSQoNO57G7kyhZPqNWOYhst/C3bTVvonLl4tq99HVtIZQfyMgSMtbSFL6ZEwjhiTbUOwJbH73Tkqn34wrcSIGiUfjozwuWFY8aM2Z5eC5F6Lk5EhIEgwMWLy7PIbPK0hOlojFLFasips0JidJaBpkpgtg5Hs6yihHmw8UsN544w0WLVqEqqrv28M69dRTj0rDDmb58uXU1dVRV1c3KL0dYOfOnQB4vV7+9re/ceedd3LxxReTlJTEl770pY9dSvvRJiYslEkJqKagM9rNPe5nebV9DbTH1ytC5vqCs8lyrqW5deWBHS2Tjr4qMtR8vP8wsd1YggiZmFgo5+aSkCwzN9THxCU+tLCJPVHBY2mwLYCV40aanQr1of2HC0wMU1n9AsNhmDGa+qvxpY4j6k6kvuZAsPJ7i/D78gnH+qit+j3n5H6ddd1BZnqzsUydLtXGyvZN3DT2kgPBCgjb4gWZAz17GOgZOuGWmDqepqp4e6LhToKBelRbAt6kYvp7qodsD5BecDK7Nz2AEBJjZ32F6g1/Z9y8b9Gw4+lBQ4nJGdMoHH85fd270GIRfBmnn5B1WfuwLAuPO8oF59qpqdUpGSOzsyoeiPr6rUFp7mVjFSq36wgBhYUShnHiXvcoJx4fKGB9+ctfZvny5fj9fr785S+PuN2xKhy++OKLufjii993u7KyMh555JH33e6TRkgFJJOHu9/i1e7Bavm6ZXBfzSvcVnYJcvs6jL31TEVZC6lvW03JmEX4FBVLM7E6IxgrO5BOycAMakhhHe+7TQifishzY2zsQjk5E1QJemNozzcg/HakKUn069sO2cb6rk2cNO463q76BwDJngJmF15MtLOKYPtOMlyp+MdcCx4nT7XGhxPtrhQ69DBpTj91A4NTF1eE25ifPolg29C0dEX1oNoTBukYtux5jfxxl5FbfhHVG/9GLDx4vDOjcAmhvgawTCwsBnr2MHHR/7J91W/iyw+iu3UD4WAruWMvor9rGwlpM+EE7mVB3KHY5YyQl2vDNCU6u0y6ugcHo7Q0CadDMBC0OOM0FadDO+5zcaN8uvhAAWvHjh3D/nuUjw+dVjdP1L824vonmtdyUfap1DS8jE1xk5JQTEXN89jdPpQrM0C3MG0SyoV5CLeCsbYTqyWMubUXqdCD+VYrOGSsGSkIVcJY24lybi5SqRerT0NxuQ7ZPpvixunOJBTpxutMZ17+hexZ+bv9xb/93VV0Nq4gtfh8Lp/wOSTfl1HtCYRlE0UoKJI86HhPNq+ktPgCMm0+Ag0HVD/cCfkUjL+CnesGOzubehRJUti55h4KJ12DEDL93dXIipO0/EX0de1EVd04JqUjSSoOdzqRgdYhwWof4f7m/bVephECOfGQ138iYFkWXo9GJKoye5ZKKBh3HJbkuNitqoJpCi65SEGRY0OshUYZ5VhzRAaOo3x86NX60IexHNnHzr56PIUnkxudQWnuEpZv/RNj0hfhWSFjuYPozzeinJ+DFTYxavtRZqdBeSJaTwyzJp7hp95QghXSMTFRFqVjuWWiDgn51RYSJ6dgVz1EteGFbcsyFtG07XHSEkoZkzaTunV/GVapoqP6OeSMuaSkzUYyJTKlDmakjCPblTZk27t2P8si/wTOmP9txtsSiA20EuyrZ/vq3w2p0UrOmklvewUICS3aT1LaJHwp5fR1bCcy0Ea4v4nd1S/t397uSiW94ORD3vNgoAFdjyLJjk/MTI5lmdhtURx2QapfkJ8nAAtd1xACUlK8dHaGR3tWBxFB0BA26IsZ+GwyuU4Zx2iq4DHhsAKWaZo89dRTvPbaazQ1NSGEIDs7mzPPPJMLLrhg1BvrOOKQDl07kmT3kZ5QzEDXZt5Y/3MSXTnMt1+DqqtI4xMRm7rRn2tEKvIgjU9Ee6Ye5fQsrJYD6vDm6g6k+WkIzcSsC2LuDKCenY1+YTYew2Rh+q28vj4usnsw6Ynl2CMDNNYvZdzc/0Ho0SGZdwcTq3+VzsRJ5CpuUi0/p2TMoqK3ijmpE1nVsXXQtku7KnDbPCR37cZnc9O489mhBxQSOSXnojp8JLZNpLNlHe31cVmrosnXEQv30HxQsIK4jqD0nl7de1HtXtyJJViSH07gOazhsCwLXf9kXdOxoMOAH69rZXfvAZmz4kQ7/zsjndRDf32OiI/CD+v6669F0+KZtYZhsGfPbv75z8dODGkmy7K45ZZbeOeddygrK6O0tBTLsti9ezff/e53efXVV7n33nvf/0CjHBPS1VQmJZawpbdq2PVX5p9KR+sKFNnBGdNvI6s6H9e/onC6jNkaRsp1YzSEMPcMIJ+ehVroRX+xERwy6iX5GOu7MDZ0I01ORrhkzM4I2GWEZhH2QczWzdbtz3LKtG9R27KSlu4KHDYf4/LPIdWexq63fwxY9O1+i4wxpx/yWsxIJ1WBXgrSvBgGjJHzSUzxMiV5LDP843hkz8t0xwKk2JO4vugs5iePI9a4kt72rRROuob67U9iaPGEEIc7g3Hzvo2iegkPNJCYNhHF7qGrcTWy6sTlyaJ6/V+GtEGLBrC7Ug/ZzqS0iaiuIoxPWLAa5YMRQQwJVgDVvVF+sq6Nn83OwHkC97T+/vcDRfxvvvk6f/vbfcc1WMFhBKynnnqKtWvX8o9//IM5c+YMWrdy5Uq+/OUv88wzz3DhhRce7TaO8gFQDZVvlF/LV9f9nMB7huXG+/LJiHbR2LGRaQWXk/92Pg5PAmZRELMygOxQMFZ0IMZ4EVkuzJ0BpHQXUnkCylnZWEEdkeHEtiQTszsKDoG0MB0MiwFPPLHZtDTaeipp66kkJ3UaZXlnENOCrN/1MNnJEymdcytaVw2R/macjkPX3kkp0+iIHlSNagpShJ+ylAKKpAKWpMwmYgZxCBU3yRgGOLPOISF1AuH+JiYtvgPLiCGrHmzuXAySARMHgpbq5+jr2kli2iSyxpyBaWpEw8Mb03U1rSGr+Gyaq18csi5n7AXYPMXo1ie3xm+UQ9MQNoYEq31U90ZpDBuUOE9cP6yDee65ZzjvvAuO6FqOBh84YL3wwgvcfPPNQ4IVwNy5c7npppt4/vnnRwPWcSSTdO6d8QPW91byastKnLKD87LnkavYIdLFtLk/wRNOQy2MYI31YkqpKNv6kIq9yLNTEPPTwCFhre7E2NmLck4uRt0A5tI21M8WYVoWZkUv8imZ9LoGm/QpspcEdxaBYDONHRtoPMgSZXfrchq7NnPlyY8ii0SENYDXX0Z/19AEHklSCSZNY6I3GcMYOsdlmiYOy4ODuO/avrkj01JAGYM9aQySJPaqSVgcGNWSwFZM9oSvk2OFEcKGiYyk16Gonv1KHAfT2bSKzKIzGL/g+9RXPkGorwGXN5vCiVfh8s9Et46+99soJw59sUPPXPbFDDiCgHU8/bAOpq2tlY0bN3D77T8+5HYfBR84YO3cuZP/9//+34jrFy1axD//+c+j0qhRPhyWBX78nJG4iDP8C5EQGHuf2MIOKUleOo1+YlNs6HujjTItAd2y8J6dRVA2MS3wzU/FNC267Sa2Ujeu/CK67RZCgPv8HPoVc8iku2R5mDPuZl5Z+8Nh2zar/AaElYBumICL8gW3UbnsJwx0HSiDUO0+Emd8j8e6JP4n3Q0f0q3iUDVRpikA1/5pNtWWR07ZBfvlm4ZuH6Ol+iU8iQXkll1EYtp0NNIYLT8axWc79CTV+61/P46nH9bBvPDC8yxYsJDExKQjup6jwQcOWIFAAL/fP+J6v9//vpF6lI8Gy7JAB2OE8XP9oGiz79/9krn/Id6nHlgfwyJm33dcGJDNYbXSLAvSE2Yyd9zNrNp+/0HW9IKpxVdQkLZkUCCxRDali39GT28tgf4OdMlGg5VMteHjS+XZuMyPRjxU0yUyis6ip3UTgY7BtWTuhHwKJ11LLBJGUT1I9kw088SVYhrl6JLrlClOtFM9zLBgcaKdXKfMsRYWPFZ+WPuwLIv//vc5vv3tj4di0AcOWIZhDFFmPxhZljGMT0py7ygfBmG5GJt9GQUZiwgE67EsC587G6echWUNfdDLZgKpCZOxJRqEDIN0SSJJqFgfcRKDIXIon/cDQr1VdNQvw7QMUnMX4EkuwxBZyHs7ZMOMUI7yKcaBxf/OSOcn69oGBa3iRDu3zUg/4tT24+2HBbBu3RoMw2DWrKFTQceDw8oS/O53vzvIIPFgYu9jFz3KpwPLlLGJbFI9BzQnD1WzY1ngs2R8Qoa9807HA0Nk4UjOYkxGvPYqGjWPTm2VJBG0QABuaXQc8ZNGqgw/m51B40F1WDlO+ahkBx5vPyyA559/lnPPPW+I2Pjx4gP7YX1QEdm77rrr/Tc6AejsHOqHFS+aPP5eRh+G0fZ/tMRkgzYtSkfE5I3aCNu6NE7L93HemEQSDQ3zBOytHe/PYN/5jwVH4oc1ypFxTPywPimBaJRjh6kK2rQwMUMnWYEkIaGbh5Zs+qRhCJM9sV4aew16IgqaCWcV+fjcBBsxHV6sCXBqjofUD5tRMsoon2JGpZlGOXIENFpRHq3cw7LmNkzA77DzubFFzPH241ZSMT8FDqxCCHZEutkTUHigIsSlpW7ssuC+rb30RQ2mprk4pzABJADxiVPHGGWUY80n/ykyyjGnyYrxg1UbWLo3WAF0RaL8ZvN2XuyIYugth9z/k0KfiNIagr9tHeAzJUls7gjxYGUXdX0xeqIGbzb0862ljVT1xOh/H9mnUUYZZSijAWuUI0MRrGhtpzs6fMX/v3bV0KyBLH3yfdT7jCia7uLmSamUJDpYmO1lSqpz0DYW8MfN7dT2x5DkUe3NUUY5HEaHBEc5Ivosg3dbWgctS3c6yfa46I3G2NPXT3NUkGcPgBi5ju9EQpIEtoiK1icwBOgJFpJTR9Y8rG3tYV17XMdQEjA/y8NNE1O5f2vH/ryxAc2kvl8jx62SqkBcDd1ECIGQBQIw9NE5rlFGeS+jAWuUIyb+iIWyBC/fLvNgRBrQYo3YVC+KM5d+S4pb3n8CUA0Fo1Km42UNc6/gvJIoiF4rcXtFCy1Bbf+2pgXvNg3QFtQ4f0wiz+7u3b8uzaWwpSvCiuYBnIrEybleFCF4dFc3TllwdkECpV4V9zAWLKOM8mllNGCNckR4hcyCzHQULH5QJnhl7beIxPr2r/c4Uzlj6vcQ0vgPLbV0OMhyXEfwWFjWS5LA3C7R84w2aLkxYFHTFRsUrA5mV2+UJfm+Qcv6oga/39S+/++NHSGuG+fnnIIEuqI6bWGd1pDOgnQn3tGg9bHGtBT6+wWRCDgc4PVaSOLYDoF/FPYi27ZV8Jvf/AJN04hGo5x77vlcc811x+x8H4TRgDXKESF0i3npqZyeGuOFd29Be49x4kC4g5fW/4SL5/4KWR5zzNohW12EA7sZ6NuNECoJKRNQnHmYHL20ejWi0vny0AeRmiJYFwwect+wbnLLpFQMC1IcCtGDVGFSnArXlPv5a0UH/bEDwSnfa2NCigOfLEbdfT+mRGM2Xn9To7PrwOeT4hcsOcWG3XZiiyn87Gc/4cYbb2HRosUEAgGuuOJiFixYRGFh0XFr02jAGuXIEFESaaWma92QYLWPULSbzr4qslJKhlVgP1Jkq5Xqjg3UorPDDOFX3UwYqCGlexuZ2WdgcHRU1a1+MMPDLDfAKR96yFMz4LGdnYR1C4csuGlSKl+c6OethgGuHZfCnauaib2nV1jXH+OuNa38aE4mGcI6IQqmP02YljIkWAF0dlm8/qbGWWcoR9zTOp72IkIIBgbi6vCRSBhFUfH5fEO2+ygZDVijHBIhBJYYwEJHkTwIVAzDwrIsonKE3Y1PI/ny6OrZecjj9AabyU0XHG25SVmKsquvju82vEa/NriX84W8Uzk7VIPLNfGonGukaTitw2K2w82T9A673meTyfHaUETcbj5iWNyzsZ3b52ZxUbFK1DAHCRIfTFNQo2FAI+JQyFFBHo1aHxv6+8WQYLWPzi6L/n5BwhE834+3vcj//u/tfPvbX+cvf7mX3t4evvOdH+D3p3z4CzoKnHABKxaLcemll7Jjxw6eeeYZysvL96/bsWMHd955J1u3biU5OZmrr76aG2+88Ti29sRAkgC9HdMIYlkmsurDklLRrS4aOlayp/ktklLm43Hn4PdmUxdxkOn20dO9nbWVf2bM9B9hdxz6i+xxZaAfg8y3PrOTO6qfHhKsAP5a/wZjXelMcUcwrENLvnwgEiyUNIHeHn9IyR6wygXYIDugsCDLw7LmuK+WTRJcUZZMoc/GgGZiWRZfn55OT0TnyapemoMabzf00xfT6YoY3DwpjXs3tw972v6YQW0gSleCjSleFWk0aH0siAw/oDBo/ZEErONtL/LQQw9wyy23csYZZ9HU1Mgtt9xIefm40SHBw+EXv/gFaWlp7Ngx2PxvYGCAG264gblz53LHHXewa9cuvv/97+Pz+bj88suPU2s//kgiTLsWpjoIK9ujSEKwIM1knLue5Vt/Q2r2xTQnfp4eKRGHJlNbN4BHjYFQcZjxIBE1wti8BSOeQwiZtKSyY5IIURfpoifWx8VZc5nlSEMyYkQVOy/07GRV93Ze6d7O1PQ59BkBBIIEy4f5IXt5UUnDf5Gdtr9rxM4WNGX20S230B5txCELPpM0lfH+FF6qDXBVWQoP7+jiof4D8xjZHpWvTE7jc+OSeaCym8ruMN+Yns4PVzSzuSPED2ZlsrUzzGv1AcIHnCdRZYlp6W5kYdFuSQgs+qIGCapEqiIQJ6Iw4SeA95G9e9/1R4NjZS/S29vDO++8xU9+8jMAsrNzmDBhIps3bxoNWB+Ud955h+XLl3PPPfewdOnSQeuee+45NE3jpz/9KTabjZKSErZv384DDzwwGrBGQAjolBQ29xsMaDqliYk0BoPcXbGbH47VGVP+XW7fUMNVY9N4enctjcHQ/n2f2F3HgvQkFpd8ARWTpzoqubDsc1TuePC9Z+Gk6d/FLuePLPgqDRCI1BKKdqDIDnzufJwi6wMJxIYtjV+WXIqx9WFC3dX7z3lV/iJOGnM+T3Zs4rn2ldy360kkJM7Mns852QvJIetDzQlFU2LwNZll3U1s7n6WVZ3rDlr7MGdmLuR7s67mf5e30RUZPH/RNKDx83Wt/HBOJteUJfPcngArmoOcW5TIU1U9TPA72dgR4osT03i6uoe6/hg2SdAbNfjdhjb+Z2oa27r6mJ7mZntPhKerezg918dVpYn4RjMJP3K8XosU//DDgil+gdd74tqLeL0+nE4n69atYcaMWfT29rBtWwVXXnnVEV3TkXLCBKzOzk5uu+02/vjHPw6r6Ltp0yZmzJgxyP5kwYIF3H///QQCgWG70p92OoXGrzdVsrW7Z/+yAq+Hn8+dQk1vBxUtQYoSvKxr7xwUrPaxrK2HyeWzUVseoCx5Is8PNHPBtO8S7txMONSM21fI/2/vvMOjqNY//pmtyWaTbHoPJIEkkJAQIDQpAlKkXYo0aQoXBVRE8AeIorRL8XIFBVRUBFFQ1KteQRQRBURBUYoCoaSQSnqv2+b3x5KFNQk9hMh8nofn2Tlzzpl3Nux855zznvd1dovB1aUFmWXH0ToEYZbZYY8KpUmJ2SxiEC6y58iL5BSes/arVNjzQOxLeDjGIpiu/l80TOlI/L7FGKqunIcXKUzej1dlIQ+1+AdfZPxCpcky0vksZS97Lh5mdeyz+It+tXd6FUrkJezPFSni2F/EykJc0XlSS/RWsYpws6ODtxZBgNQSPT+klnChWE+Qk4ru/lreO53HIxHuiFiSaaaW6HnteBZPx3ix9ngWkyLd+TKhEL1Z5JWjWcyL9SGpuIoIVzt+06r4JqWYnEoj86LdUUkjrTuKTDDyQM/avQR791QiE27NS7Ah04vI5XKWLl3J2rVrMJlMGI1GRo16mFatom/pnm6VRiFY1bm4Ro8eTatWrUhLS6tRJzc3F39/f5syd3d367kbFSxBqP34r+WNhb/aXy4TeenICZJLSm3qZZSVc76onKxKGXtTM5gQ3oy3TtXtULE9KY9/Rz+CPOVTfN1ieCP1J+zkavydIoh2aYGvNpzkzN9RuYXzReoefs39E61Cw9DAXkQ5BnD490U2YgVgMFbw3ZHFDOixgQpBjRw5bnKdjf3Vn015Z/8iVpcpzTpBq1ZjWV6UaFNeYihje9I3PNtsEhiv/w9qlBtILSvGIAjsSPsaAE87V9RyFSWGMp4Jf4rMEldO5hrQKGRMaeXB8Zxy3judi0m0JPabFuVBcZWJvEoTzio5VSYRo1lEABQyiy1mEX5ILebFDr5sOpVLxqX9XWYRTuVVkF1uQAY8FuXByiOZ/J5dzsUqM01rT1V322jo38Dd+NtTq/Q82Le2fVi3x6U9MjKKt9/eVKP8iy++sn4eP/4Rm/1R48ZNBCzef++9t61G24ED/8HAgf+45rXbt+9A+/Y12zckDSpYq1at4u23375qnV27dvHTTz9RVlbG448/focsAze32vPu1FV+t1NUbCYzy4RS4YBOJxCXnVVDrACmtAzli6Rkuvp6ozebMYniVVPR5VZWUV6UiZ/GhyMn1zK5SX8cnIJwcmrF2pN5REdUUaRrwtwjL2MULy8eLT+5kWhdc4Z5dSS7wHY9MsivJ97NRvJTfgJ60UCVyUBaWSYjAnsQbO+GTuuLcMllL/6wZWpYZafDwSMSRBPFmccxGS3+5+Ul6bXa/X3mESY2G0wL9+ufjz9ZcB57BBTyKmJcomnncj8ZJRpCdAKeGjlvHDOSV1nKoGAdkyLd2XQql2L95XuOL6zitePZzGrjxU8ZJbT3cgAsQhXr7cDx7HLUcoEHAp3wdrBkaA7R2ZFaqqfaXyWhsAqNUsb7Z/LRKGRMi/bgtWPZZFaaaOeru+57uRUa62+gvpAJRpydbs3BQuL6aFDBmjRpEkOHDr1qnYCAAA4fPszx48dp1crWPXn48OEMGjSIlStX4u7uTm5urs356uPqkdaNkJdXM4Gjm5tjjfK7HbOoIK9IoFhVTompCju5AqcCexIMtu6xWqWCwUGBBDhq6R3gh6tKRRsPN2SCgFwQMNVx0z4aewyFf+LpHkzLFs9gEhw4V+7ER6eSeSoyCFGt4N+/v2cjVtWcKDxPd7dQVEoteoNFPIMC+1Po3obVx16nwmQJqOukdODh4Ad56/z/GB3Uhx/OfU5zp6Z0do9CaafDpcMMzgrwfeF5lIKMfoHT8a8ooOD4ZqrqkFuTaEZvMpKbW9NNuC4yK/NxNZhooQsmtag/bxwzMjBE5MfcHbTUDiC5xKIqgY5KTudX2YjVlWw6lcvgEB1ymYCHvQKjSaS9twO7LxTxeJQH/0so5Ksky6gxzMWOGa292H4un/RSAz5aJW09NcTlVVBiMLMjsYj7/R2RI97QvdwMDf0bqL6+xL1LgwqWq6srrq6u16z3wgsvMHPmTOtxdnY2kydPZvXq1URHW+ZUW7duzZo1azAYDCiVlrfTn3/+maCgoJtavxLF2lO711V+NyIIci7qq/i+JI0vLqRYoyu093Snq4+3tV6Qo5YRIU3Jq6oipaSUwio9BrOZsaEhfJ2cSk8/H/akZdR6jWHBTVAayinJOsH/hAc4nV9AuAtMb9WCUCeB8yWJ5FYV1NoWYGfWCR727UZC8i40aheMnh14Pc52GqLYUMabZz/lmZbj+Dr9MHn6Qr7K+Jk3ZJ/wRtuZLDixgYIrwkEdLzhPMwdfZsU+SZ7C/q+XBCDcuSlKwQmTKFy3m7idTE1ZVSKlYjh7ko0oZODlmE1WoZkjF1WAxc+5WG9mf1rd4lFQZcJRJed8fhVzYr0xmUXO5FcwIMiZNcdsXdvPFlQSX1jJ0zFerDmWRXOdmnXHs5kW5cG6E9mcK6jkfn9HAh2UdywaRmP6DUj8vWgUa1i+vr42xxqNJdxOYGAg3t6WB++gQYNYv349zz//PFOmTOH8+fNs2bKF55577o7be7dQhsgnKfF8l26bj+rX7Fw6e3siACOaBdHa3ZXcikp2JadxsfxyKAcZsKh9DC5qNRnl5ZzKL7Tp5wF/XxKLS/mhSMusgE48qPYlVOdEUnEpr544xdpuMRQbrv7WX2woQ6a1vLQ0CRrMq4lf1Vl3R+p+Hm32D8qMFXTxjCGvqpC3k74hyqU5LXRBiCKklGWy9+IvxJdl8KtnNIl/Wb+qZkLIEGb+UMSC9va0sJdd1wPY386bPJmad49bvodW7nYcyT+AvVzDlVvM8itNmK/RoZudAjmw9HAGRXozI0Nd+CG1sNa6JhH2phYzo7UnP18so9Rg5oMz+QwM1vHJuQK8HZS4y+Gqc7cSEn8DGoVgXQ+Ojo5s3LiRxYsXM2zYMFxcXJg+ffo97dJ+UV9eQ6yq2ZOawbquHTlbWEx+RSVfJKXYiBVA30B/9mdkcSAjkwXtWpNZUUFORSUKmYCLWs3RnDwOZVpGBLmhEdjLlGw7d1kgzKKAVumAgEBdK2GxbuGUFp6w1FfpyKvDgQIgviSV5LKLl1zUBZbGPEWAgze703/mzbOfAtDMMZAZLcbwv9R9fJzyAwtbT+VYUbx1Y7Gb2pmZLR6mqdqNxR09QSbya4kBuWDC30GJj1yByVS7rVqzA3qVHRllWQDYySHbWEZiaQoDvQZw7tJA8lhOOR19tHyXUlxrPw5KGWZR5NUrgt86quQkl9S9UH8ip4I+gU78mmm5j4tlBpo5q1HJBByVMkQZcJujiEhI3G00SsHy9/fn7Nmanmvh4eFs23Z3ebU0JBcrLA83uSDQzdebaHcXPO3tUQoySowGtidcIL+yihgPV/o38Wf7+SRyLm3fd1Qq8XGw59248wQ7OfJ9+kV+SL+Ik0qJ0SxSbrTdY3S2pJJmzmqbMplZRCU40sMnlu8v/lrDPhkCgwJ7gEcEjs7NcVBdfepWIcitsicCSrmC1Sc+wGC+bEt8SQqrTm1hVsR43jjzMWq5ihFNeqOUKbCTq/Cx92DFyXfp59MXY2UsXyWVWTPVq+UCj0fp6O7ugKIWD3FRBGeZCn+tiriCShKKjHRu2prTyZ+htc/CWeVJkd7EuYJK+jd15sf0EqpqEb8xYa68c/LyeqsA2CuunX4lv8pWkUwiDG/uwht/5DA9yoPm9ewlKCHR0Pw9khRJ1IpckKEQBJ6KakmVyYgMgV+yctiRnMriI8c5kJHJyfwC3j+bwFunzjI+LASnS+t/vQN8+eqCZfuAwWxGfWkXfLHeUEOsAEyigPyKYHs9/HzwtVejFlxo49KC+73b2dR3UjqwsPU0KDiDj1Mw3k0GINj70toltM77GRvcH2ellimhwxkfPJAvkvfaiNWVfHJhD6OC+nKmKIn4klQ2nPuUV+O2kVGRjZedGypTO3YkXhYrgCqTyGvHCogrq3ukIzOYGBVmmcLMLjfio26JnVzNpoSNPBpdTrSHRTW2xOUyo7UnkW6X9wy62Sl4ItqDU3kV1lQkA4OdmRrlgUom0NSpbsVp46nhdJ7tCNhJJaOjjwOJRVVsPZOP6RoBeCXqB4VRgSJLiSxJiSJLicLYKMcBjQLpm/2bIcoFsg1VFBkNeGjUzIlpxXtn4xkS3IQtZ+J5pnUkSSUlNHXU8n1ahnVDsN5sZvOZ8wwMCmDbuURc7dRkVVgekKmlZQwOCrzqdZs6afk2NR1nlYpxoSHc5+GOwiAn3MGLQ/l67vd0pZNHNKWGMhwUDvhr/HBXOuJkH4jM4EoQ7oiORh5q2puzxclWD0EAZ6WWaeEjOZZ3hq2JuzCJZjq6t6KrdxuSyy6SVl4zBl9qWSZhTk1ZfGIDk5sP5UDW7wAklaQzvdmzLPg5p857+eBMIUtjvVAaa58abOGoYHSoCx+dK+Cj00qejprJlqSN/Pv0y9zn2Z7Jfu1xUrgQ7CzQ3MWOTr6OmC4pY26FiUMXLSPfceFunMgtZ2diEWq5wLQoT149llVj8lQhgx4Bjqw+mmUtC3exQyET2JlYRKhOzYnccsrNIPnQ3VmUpSryPzSgv3j5r6byFXAdrcKgrb/0InciH9bp06dYvXoVFRXlCILA00/Pol279vV2vetBEqy/CYIAeYKJ98/FszftovWhF+XmwriwEBBhTGgw6/48zcXyCjQKOX0C/Olnr+bd0+cwA/lVepyUlrf8UoMRnUpFod7yoztfWExHLw8OZ9V80A9s4k+IvT3NDSLjIltQqbHH0WwZkTmY5XR3a0KavoxiQxUucjM6tR2eKjvsDEqbfmR6JeWGKqaGjSC59CLfZ/6KQpDzbOREFh/fQPkV6UsO5f7BkbxTPBMxntdOb6XKXDN5YpGhlApTFR52LigEOUbRhJ3cgQvFYq1TddWcyddTajbjQu07Ve3MZh5q6khHHy1HssrIKHRiVvhzlJlyyCwvQyk4oVO6s/VMKXZyGZ/HX/7Opkd7AuDtoKTCZObPXMtLQZVJ5IuEAma28WJXUhFnCyz3Gu1hz/BmLhxML7GOBgMdVfwjRMfB9FJyK41oVXI0ChlyJO4kCqOihlgB6DNE8j8y4PKIAqOifhM51heiKDJ37mwWLFhE+/YdSElJ5qmnprF9+2e1Rhq6U0iC9TdALxPJMlZxtqiYEGdnWrrqMJpFdqekc7awmPu8LdN4752Nt7YpN5r4IimZICcto5sHs+28xVnCeCkm3Z7UdPo38beWf5uazrDgJjwS3pzdKWlklVcQ6KhlSFAg7e01+K58l4oWwWySiYT7eROgvfyfWmkSCJJrLeHNq6klOa8oikQ7hfHiyXU81KQ3Cpmc+zxasyN1v41YVWMUTXyW/B29fTuxM802tqS/xpNzxckICGgVGhbHPEFcUSIhmijyrp5rEQel7FIqkLpRmswEKcDFX8vh7Ar+82s+ZSY1Hb1dae+t5d2T+SSX6BkcrGNMmCs7EwspMZg5mFbCIy3dMJhFvkgotOnzQrGetcez6O7nSFc/LU2d1Hx9oYiFhzN4saMvnhoVTmo55QYTBrPIN8lFDA1x4Ye0EoY1c0ErmKmH+MISdZEn1BCravQZIuQJ4HVrl2iofFhFRYUUFhbQvn0HAAIDm6DVajl06Cd69Oh1azd1C0iC1diRwW9FFvc0vcmMSTSTUlKFi1rF1Mhwiqr0VBhNbDh1ptbmScWl9PL3RS2XU2UyEapzppe/L/YKOVFuriQUFaNWKPCwU5NZUcHetIv8IyiQTt4e7LiQyoZTZ2nr60dO/67scVDzcVo6ywP9a73W9eBsduaFqMc4U5SIo0JDdlU+32fWdNioJqEkjd6+HWuUj2jahw1nP6WzZzRH8k4B4GPvTlzxcdq56gh3seNMQe35IYY206JDwHQdfuI60cyDnmq6e/phBhxkcKbMSFqpZWT6ZWIhXhoFQ5q54G6vwFEp41h2OV38HNl6Jr9Gf0Yz7E0tgdQSJke689OldCV/5JTjYadAKQMfByWrfs9ChoCHRolKJtDLzwGzFEvwjmKuGV7zhs5fi4bMh6XTueDm5s53333LAw/04fTpU6SkJHPxYu1ex3cKSbAaObmiAZMoYhJF3jt7nnLjZU8yuSDweEQYGoWCqz3KjuXkEeGqw2g2cyInjzYermw7l0iF0cj9fj7sTE7lZF4+AVoHZka3xEAWJwuK2JVsmeqK99DxSuZFSgoMOCgUBGo0t7QnyFv0ZF/lb7TUhXCuOBnzNTpzUGisn4O1/gxt0pOdqQfwtnenjVsL1sZ9CIBapmRGi4dZfebfzGu1kIWH9JQZbL+ZAEc5XXxVdbq214Yogn31N2yCcI2Mdd0D2JtWwpGscpzUcpo4qjiVX8Hn8YUAaFVydGo5hVW1+6Kr5QJXmpBTYcRDo6S4ysSrx7JxUsl5vJU75QYzizr5oqslkohE/SLTXPv8rbxCNHQ+rH//ezXr17/Kli2bCAoKJjq6tU0KkoZAEqxGTInMRIHegN5s5p3TZ23ECsAkirx58gzLO8VetR+jKBLs6Ii/1oEqs4mk4lKi3FwxiyIrj/1prZdfpedEXgFDQzzx1ZajU6kwmM1cKC+nxGBAIQgsbNcanaC45sbZq2EyifTy7MCB3N85W3yBKJfm/FFwvta6nnau2MvVrOswD7kgwyiaySzPo5/ffYDIDxePYCdXUWnSU2U28M75z3mu1STOlh5kZkwXzhTo+T2rDJVMoE9TLc72WXjKFLf2pDGDr1xkQpAjY4KckAsgmM1olRq+SixCbxbZk1zM4GAdW+Lyau2idxMnfki9vI+rracDoS4qUkuNLOrki4e9AkQRZ6UM7e1O4yxxfbiJqHwFy/TfX1D5CuBW//Oz9ZUPC6B581DWrFlvPR41ahjBwQ2XCwskt/ZGS5XcTKHJiL1Cgb1cTqmh9sVdM3CusBB3O3Wt5wG6+Xghlwms+/M0AnAgI5P2Xu7sTq09cOznCdm4qn2wU8gZHtKUC8UlTAgN4fUunQi3096WRI2uJld0Kkd+zDpKX7/7EOpwgHim5VhMopk3znzMtMPLmPHLSg5mHyXY0Y/zxSk4qbTMaPEw08NGohDkFOiLuVCWwfeZv+Bon8XvWWWEOKuJ8rDDzzGHSK0ncvPteY8TzSIKsxnBZAYRWmpkbOobxHOx3gwKdqaVuz09A2r69UW52+OiVpBcbJlW1ChkhOrU6PVmonUqmmuVuMohQIEkVg2IUWHEdbTSIk5XoPIVcButvGWHiyvzYQGYzeYa03fXyodVUVFBhw6dmDbtSXx8fElKSiIjIx2NRsMDD/Rh9uw5pKamUFFRc/4yN/eys9AXX3yGvb295CUoceMIAqTrKzlXVMIXickMahpw1frxRSX0C/Tng3MJNc6526mpMJn4NOECAGUGI572auKLrh5SKbsMuvp4MsDfDwdkCGYsQnUbXyqDNH6YRDOfXtjDMxHj+Dhpt9WF3U3tzPSwUZhEMyv+fNcaSUNEZH/W7/yae5Inw0fz71PvcTD7GP4aL+a1msTSP97GZDYTV5TI4j/WMLrJMxzNlDMmTIeX4FQvWZGtiBDkrMbRoAdnS+y/JmEuDAlyJq6wEqPZ4vBxpqCK9y+NvNztFSxo70OAwoxZJsAVAiWtWDU8Bq0el0cUkCdgLr80Tegmolfcukt7Q+bDAotI7d79NaIo0rRpECtX/gehgXO8COKdipjZyMjNrRmt3d3dsUZ5Q1AsmNiTeZHNZ+Jp7eZKD38fVp84VWf9CWHNEIByk4mdSSlUmEwIQHsvD+7z9mT9n3FUXVqwnxYZToneQE5FZZ0jLIBHwpsxOMAfZf1tNcEoM/BW6sd8mbofjdyOfv734WnngiiCUqbA296NdWe2k1mRW2v7Ht7tyK0q4s9L04l9fTtzsSKHbl5tWXfG8ib6fxGTud+lE3Jj/T/+r/Z/qPo5UCWTk1xhoqDKhFYpo4mDAq3Z1OD/56DhfwPV168PKisrSUhIxN3dG5Wq7tkIiduPXl9Fbm4mISHB13SZl6YEGyHZhio+jr8AQDsvd3RqFfZ1LIYKQFsPN3anpnM4M5uX2scwpWUoUyLCHny+1AAAIhpJREFUMIsir5w4ZRUrF7WKSqMJT409AY4OV7Uh1Nm5XsUKQGFWMjFwCLNajsdOruaz5L1sjt9BsaEUvdlAWnlWnWIFcCDrKB3dL6ek+e7iYUY27UNS6WUh/in7N1Tyhh+rVEdAV5lMNFdBe0c5Le0EHEx3h1hJSNwNSILVyJDJBHIqKq3hkezkcjLKypgWGY5aZvvnFIAnW7Wk0mRkTkwrDGYzr544hUap5L0z8RzJvvywd1WreKJVC7zs7dgcdx6TWcStjnWvAK0DwZqrC9rtoEpWRVJFGsfyzzCp2T9YHfss/243k6YOftjJ1ehUV8+YZxZFmzS1JtGMVqHh67SD1jK1XEWOqXbHBwkJibsLaQ2rkWE2i9a4fgAahYJ3TiciFwQebRFKudFIZnkFbnZqXO3UfJ2cyoyoCP7v518ZEtwEVzs1ZpOZxe1jKDMYya2sxEWtRqtSciD9It+mZmASRbadS+DF2Bg2nznP+aLL3mpRri7MjorAwVy/7zoGQc9/L37LlqQd3OfZmvSKHF45/b7Vxd1J6cDyNjNwV+vIrSqstY+OHlEcz7+8/0wjt6PEUGbjJh+pCyG7Mh9XhVu93o+EhMStIwlWIyRQ64CzSkWRXk9BVRX5VZa4e2+eOoNGocDdTk2R3kDRpbBKGeVlVJnNbI9Psumnm683VUYjv2TXnFYziiJ5lZWEODvSK8AXZ5WSJg5afBTqWiOZ327STVlsSdqBSqa02UtVzaTmQziQdZTJzYey8uSmGu0VgpyuXjG8fHKztWx40158fGGP9fg+j9akl2cTqWteb/chISFx+5CmBBsh3goV0yLDASjSG3BVX566KzcaSSkts4qVXBBq7M+q5kBGJlHubsR6uNuUa5UKpkWG82nCBQ5n5mA0m2np7EyA7M6IlUwmcDT/NAA9fWL5Jv0nm/NNtb4UVBajkinYnfEzM1o8jI/95XsIdw5iVsR4tiTstJZ192pLtEsY50uS8dd48UzLcfTwicVNrcNVfuMZqSUkJO480girEWIymPF3sOfp6Ah+TM+kf5PaXdbBkuYjubi0zr7ePn2WRbExtPf2oMpkoqmjFnc7O7LKKxjVPBg/B3u8lXb1PgV4JYIABQbLNGSAgw+70w/ZnG/r1hKtUsPmhC8pM1YQX5zCg/5dcFE5IRMEzKIZpaBgTFA/qkx6/B28KDdU8HX6T8xqOYEWzk2JL0nlj/zz9PBqh7PofM1oGhISEg2PJFiNEFEEnVxFcnEpHvZ2hOqc6ebrzYGMTJt6zZwdaa5zuqqXmYedHacLCtken0SosxMRkeF4yFU0cbK4lxqN5ju+4cdkEonShfJJ8h6K9aW4qZ1t1qlERDztXSkzWiKdlxor+OSKqb5qXoqeikwlsOyPdyi9VNdD7UKYYyBOSi29fTrip/Cp371XEn971AaQ5+oRyoyIDgpM7iqqlNduV59MmzaF0aMfpnv3Hg1ryG1GEqxGirMoZ2jTAH7LzePNU2do4eLMrOgIcioqKTYY8HPQkFVRybazCTwV1ZKefj58n24buNJOLmdCeDNrYNzx4c0wmc2ozYI1antDEerQFFeVM99dPEx/vy68n/iV9dypgnjaubW8ant7uZrksgy0Co1VrAB8NO4klqXTzjkStdFOEiuJW0JTYsb8XgLm9Mv/xwQ/ezQTQyh3lFZcbjfSN9qIcTUr6O3hxbL2bXgopCnBzo4cy82jb4Afoijiolbxj+AmvHX6LDJB4KlWLejh5020uyujmwUxuWUom+LOo5LJmN8mCrVMwFdtz92wl9zZ7Mx/2s3CWemITJARoQuxnuvkEcXZwguEONYdFf4fAfdTaazi55wT1rJ+fp35LfcUrmodKoNaEiuJW0JtAPN7CZBumwma9ArM7yWgriWFzo3SsWMbmwjtffv2JCMjA7AkcXzrrTf45z8nMnToQN59951a+/j++72MGzeKtLRUfv/9Nx5+eAQvv7ycceNGMWbMQ8TFnbbW/frrnYwdO5KxY0cya9YMsrMtkWWmTHmEP/6w/JbWrl3DoEGXI2oMGzaIzMyL1+z7diAJViNHMIGbWYGvoMYOGSObBfHu6XPo1Goyysr5b8IFKk0mXO1UOKqUFFUZaO/hRt9AX/wcNMyOieDFdjF4a+zxt9PgKN49aQB9zD6sjHma5k5NmNJ8GC9ETeE+z2iiXEL5IesIDzXpjVpWc+7Fy86VTh5R+Dt4kV6WRWuXMJ5qMQaTaCahJA1Ppau0GVfilpHn6muKVTXpFZbz9UxJSQnvvPMemza9z9atW6wCU822bR+wfftW1q/fgL+/JYRbcvIF+vcfyAcfbGfEiNG8+eY6ABIS4lm79lVWr17H1q0f06pVFMuWLQYgNrYDR478AsDvvx/Bw8OLpKRE0tJSkcvleHv7XLXv24U0Jfg3QSaCl6DCW6OmVbQz+QYDLZ2cGB8SjFy0eN5d1FcxIrgp7mo1rqISd3slekFEEAVUIjTwLGCtOBqc8Va7cSD7KOHOTdHI7bBX2BGhC2Hj+S94osVo4gqT+DX3T5QyJT28Y9GptIDAgayj3O/djghdCItPvIVRNLEg6jHcRBcpDp/ELSOUXT24reW8ql5t6Nu3H2DJX+Xn50dGRjqenpas1ps2vYOrqxuvvfYG6is8if39A4iMtESAadUqim3btgDw+++/0bFjZ2v74cNH8u67b2MymYiNbc+GDa8zfPgI5HI5PXv25tdff0GlUtoExK2r79uFNML6myGKIgojeApKdKICrUmGvVmGnUkg1suDVhpHvGUqZGbADCqTgNLMXT3iCBD86OIRw9H8OPr4dqbUUE6MazhFhhJeOfU+8SUp9PCOpaNHK/Ze/IWk0gxSyzLJryomyNGfl09uxiSaGRc8gHaOEUh5DiVuB6LD1d/3r3X+epDL5ZjNl7el6PVVNuevjHtYHcy2moiISFJSksnISP9LG5VNG2Md216uDHTbqlUUiYkJHDiwn3btYmnf3jLiOnLkV2JjLwvW9fZ9szQqwdq3bx8jRowgKiqK2NhYpk+fbnM+IyODxx57jOjoaDp16sTKlSsxGm8txL9EwyOK0ETmz1MtxuCm0uGqcsRJqWVmi7F427tzvjiFT5O/Y2fqAdq7R9LTOxYfjTvPt5oMosislhN4t+MixngPQG2yb+jbkfibYHJXgV8d/5/87C3nbxF//wBOnToJwA8/7KWioo4pyFpo374jL7zwEs8+O5MzZ+KuWb9t23YcPvwzOTmWtCKff/4p7dq1Ry6Xo1AoiYhoxbvvvk1sbAeaNWvOhQuJHD36G23bXj3f3u2k0UwJ7t69mwULFvDMM8/QsWNHTCYT586ds543mUw8/vjjuLu789FHH5Gdnc3cuXNRKpXMmjWrAS2XuF1olRr88MEsmFFr7MitKqCHdzt0KidMogmVTIG93B53tY4T+edRadV0dmqLynzpwSGNrCRuI1VK0EwMqel44WePbGII5bfBtf3pp2fzyisv8+abr3PffV1wdtbdUPvWrduwZMly5s+fw0svLblq3ZCQZjz11NPMnPkEAF5e3jz33ALr+djYDhw9+jtRUa0RBIGWLSNJTr5Qaxbk+qJRpBcxGo307NmTp556ihEjRtRaZ//+/UydOpUff/wRd3dL1IMPP/yQVatWcejQIZuh6vVwN6cXuRn+jvYXyQtIq8omuSwDUQQ/B0987TzwlXkhmgVMprtLof6Of4OGuH59cCvpRe7GfViNiRtJL9IoRlinT58mKysLmUzGkCFDyM3NJTw8nDlz5hAaGgrA8ePHCQ0NtYoVQJcuXVi4cCHx8fG0bHn1fTt/5a95yqqPGzh/2U3zd7RfZ3bBReVKS00IIqAWVRiNZkxmERDvunv9O/4NGuL6dxtVSsBHRX07WEg0EsFKTU0FYN26dcybNw8/Pz82bdrE+PHj2b17NzqdjtzcXBuxAqzH1XOyN4KbW+1vcnWVNxYk+xuexn4Pjd1+icZLgwrWqlWrePvtt69aZ9euXZgvuXVNnTqVvn0tG9aWL19Ot27d+Oabbxg9evRtty0vr+aUoJubY43yxoJkf8PT2O+hoe2vvr7EvUuDCtakSZMYOnToVesEBARYR0ghIZejHahUKgICArh40RJuyN3dnT/++MOmbW6uJW2Gh4fH7TRbQkJCQqIBaFDBcnV1xdXV9Zr1IiMjUalUJCUl0a5dOwAMBgPp6en4+voC0Lp1a958803y8vJwc7Mk4/v555/RarU0a9bshm2TpgTvThq7/dD476Gx2y/ReGkUa1harZbRo0ezdu1afHx88PX1ZePGjQD062fZ6d2lSxeaNWvGnDlz+L//+z9ycnJYs2YNY8eOvWEPQQkJCQmJu49GIVgAc+bMQaFQMGfOHCorK4mOjua9996z7gGQy+W8+eabLFy4kFGjRmFvb8/QoUOZMWNGA1suISEhIXE7aBT7sCQkJCTqk1vZh1WfDBkyAJVKhUqlorKygqCgEMaPf4SoqOhrtt2//wfc3NyIjIy64et+9NFWevfui5ub+7Ur3yI3sg+rUYVmkpCQkLjXWLp0BR98sJ1PP/2S/v0HMmvWU5w8+ec12+3fv++66tXGRx9tIy8v76ba1ieNZkpQQkJC4l6nR49enD59im3b3mfZspc5cuQXNmx4Hb1ej8FgYMyYcQwePISffz7IwYP7OXLkMF99tYOHHhpFly5dWbBgPmVlpej1etq2bcesWXOQyWzHLRs3vkVubg4vvDAPtVrN3LnzmTNnNps2vY+XlzcAb7yxFpPJzJNPPs2QIQPo1esBfvvtCGVlpQwZMpxx4yYCkJKSwpo1qygoyEev1zNkyDBGjLj5bUiSYElISEg0IiIiIvnxx/0AhIW1YMOGd5HL5RQVFTFx4hg6duxE585d6NKlO6GhoYwePRaAqqoqVq1ag0ajwWQyMWfOM+zdu4fevfva9D958mPs2PE/li5dQWhoGACDBv2Dzz77hGnTnkKv17Nz5w7eeWeztU1+fj6bN2+lqKiQiRPHEhXVmoiISF588TkWLlxK06ZBVFZWMHnyRCIiWtGyZcRN3bskWBISEhKNiCvdDoqKCvnXvxaRmppiFa2EhHg8Pb1qaWdm/fpXOXHiOKIoUlBQQHBwsxqCVRvDh49k8uTxTJ78OHv37qFlywh8fHyt5wcNGoIgCOh0Ltx/fw+OHPkFR0dHkpISWbDgOWu98vJykpISJcGSkJCQuBeIiztNSIhlb+nKlcvo3LkLK1asQhAEJkx4GL2+9kzH27ZtpaCggI0bt6BWq1mz5j818mvVhaenJ61bt+G7777ls88+YcqUaVetLwgCoiji5OTE++9/dGM3eBUkpwsJCQmJRsKBA/v47LNPGDNmHAAlJcV4e/sgCALHjv1OfPzllEsODg6UlpZaj0tKinF1dUOtVpOXl8v3339X53X+2hZg1KgxvPnmekpKSmjfvoPNua+++hKAoqIi9u//gXbt2hMY2ASNxoGdO/9nrZeamkJRUdFN3780wpKQkJC4i3nhhXlWt/amTYN55ZW11jT006fP4N//Xs6mTW/TvHkYERGR1nYPPjiAJUte4sCBfQwfPpJRo8Ywf/4cxox5CHd3D5tMwX9l5MgxLF++BDs7OxYsWERoaBiRkVFotVqGDBluk40YQKdzYeLEhykrK+Whh0ZZ3e7/859XWb16FR9+uBWz2YxOp2PRomU3/V1I+7Cug549e5Kebptmevbs2Tz22GPW4zNnzrB48WL+/PNPXF1dGTduHFOmTLnTptYgLS2N119/ncOHD5Obm4unpyeDBw9m6tSp1gggaWlp9OrVq0bb7du307p16ztsce1s3bqVjRs3kpOTQ3h4OAsWLCAq6sb3l9Q3GzZs4NtvvyUxMRE7OztiYmJ49tlnCQ4OttYZP348v/76q027UaNGsXjx4jttbg3Wrl3LunXrbMqCgoL45ptvAMvC/YoVK9i1axd6vZ4uXbrw0ksv1ciU0Ni4W/dh3U1kZ2fz6KPj+Pjjz3FwcLCWDxkygJdffsXqoHGj/O3yYd0NzJgxg5EjR1qPr/yDlZaWMnnyZDp16sSiRYs4d+4c8+fPx8nJiVGjRjWEuVYSExMRRZHFixfTpEkTzp07x4IFC6ioqGDu3Lk2dTdv3mwTd1Gn091ha2tn165dLF++nEWLFlkjnEyePJlvvvnGGjfybuHXX39l7NixtGrVCpPJxCuvvMLkyZP56quv0Gg01nojR460icJib19HqvUGoHnz5mzatMl6LJfLrZ+XLVvG/v37WbNmDY6OjixZsoQnn3ySjz66fesUEncfb731Bjt2/I/p05+yefbdaSTBuk4cHBzqjPr+5ZdfYjAYWLZsGSqViubNmxMXF8emTZsaXLC6detGt27drMcBAQEkJSXx4Ycf1hAsnU53V0a237RpEyNHjmT48OEALFq0iH379vHf//7XZpR7N1Ad47KaFStW0KlTJ06dOkVsbKy13M7O7q78rsEiULXZVlJSwn//+19WrVpFp06dAIuA9e/fn+PHj981o3GJ289jj03jscdqd7T44ouv7pgdktPFdfL222/ToUMHhgwZwjvvvIPRaLSeO378OO3atbMJstulSxeSkpJuaYGxvigpKbHGYLySadOm0alTJ8aMGcPevXsbwLKa6PV6Tp06RefOna1lMpmMzp07c+zYsQa07PooKSkBqPF979ixgw4dOjBw4ED+85//UFFR0RDm1UpycjJdunShV69ezJ49m4yMDABOnjyJwWCw+VuEhITg6+vL8ePHG8haiXsJaYR1HYwfP56WLVvi7OzMsWPHeOWVV8jJyeG55yz7C3Jzc/H397dpUz2nn5ubW6s4NBTJycl88MEHNqMrjUbDvHnzaNOmDYIg8O233/LEE0+wfv36Wte27iQFBQWYTKYaU39ubm4kJiY2kFXXh9lsZtmyZbRp04bQ0FBr+cCBA/H19cXT05OzZ8+yatUqkpKSaqwdNQRRUVEsX76coKAgcnJyWL9+PWPHjmXHjh3k5uaiVCpxcnKyaePm5nZTWb0lJG6Ue1awrjfbcUhICI8++qi1LDw8HKVSyUsvvcTs2bMbLHXJjdhfTVZWFv/85z/p16+fzXqcq6urzT1GRUWRnZ3Nxo0bG1ywGjOLFi3i/PnzbNu2zab8ymnisLAwPDw8eOSRR0hJSSEwMPBOm2lD9+7drZ/Dw8OJjo6mR48efP3119dcEJeQqG/uWcG63mzHtREdHY3RaCQtLY3g4GDc3d2t2Y2rqT6uL++pG7U/KyuLCRMmEBMTw5IlS67Zf3R0ND///PMt23mruLi4IJfLawTizMvLu6s90xYvXsy+ffv44IMP8Pb2vmrd6GiLC3BycnKDC9ZfcXJyomnTpqSkpNC5c2cMBgPFxcU2o6y8vLy7dj3uTiKTCZjNktN1fXLPCtb1Zjuujbi4OGQymXWaqnXr1qxZswaDwYBSqQQs2Y6DgoLqbTrwRuyvFquIiAiWL19eI9hlbcTFxd0VDyGVSkVERASHDh3igQceACxTbYcOHWLcuHENbF1NRFFkyZIl7Nmzh/fff7/Ol54riYuLA7grvu+/UlZWRmpqKh4eHkRGRqJUKjl06BB9+1rC+SQmJpKRkXEPO1yIZGamc+rUSVJSkgkMbEJERCTe3n6AcM3W16LaZfyjj7Zx5MhhXFxcKS8vx9XVjaFDh/HggwNv/RYaEfesYF0vx44d48SJE3Ts2BEHBweOHTvG8uXLGTx4sFWMBg0axPr163n++eeZMmUK58+fZ8uWLdY1roYkKyuL8ePH4+vry9y5c8nPz7eeq35Afv755yiVSlq0aAHAnj17+O9//8vSpUsbxOa/8uijjzJ37lwiIyOJiorivffeo6KigmHDhjW0aTVYtGgRO3fu5PXXX8fBwcG6tuPo6IidnR0pKSns2LGD7t27o9PpOHv2LMuXLyc2Npbw8PAGth5WrlxJjx498PX1JTs7m7Vr1yKTyRg4cCCOjo4MHz6cFStW4OzsjFarZenSpcTExNyjgiVy4sTvzJs318YJS6FQsGLFSqKj23I7RKuasWMnWAPZnjt3lhdemEdBQSEPP3z3vbjVF5JgXQOVSsWuXbtYt24der0ef39/HnnkEZs1H0dHRzZu3MjixYsZNmwYLi4uTJ8+vcFd2gF++uknkpOTSU5OtnFvBzh79qz18+uvv05GRgZyuZzg4GBWr15Nv3797rS5tdK/f3/y8/N57bXXyMnJoUWLFrzzzjt35ZTghx9+CFgcda5k+fLlDBs2zDpC2bJlC+Xl5fj4+NCnTx+mT5/eEObWIDMzk1mzZlFYWIirqytt27bl448/to7m58+fj0wmY8aMGTYbh+9FMjPTa4gVgNFoZN68ubz77mZ8fK49wr4ZQkPDeOaZZ1m8+CXGjBlbI/LE3xUp0oWEhMQ9z81Euti79xtWrFhe5/l5856jV69be+m7ckrwylQhAMXFxfTpcz+7dn1308sbdwNSxmEJCQmJekQmE0hJSb5qndTUFGSy+hv53ItjDUmwJCQkJG4Qs1kkMLDJVesEBATWq9dgXNwpXFxu3nmsMSIJloSEhMRNEBERiUJRuxuAQqG46SSF18P58+dYvXoV48c/Um/XuBuRnC4kJCQkbgJvbz9WrFhZp5egj4//VVrfOFu3buGrr3ZQWVmJi4srEydOon//e8utXXK6kJCQuOe5+fQiIhcvpnH69ClSU1MICAi8lD7en9vp0v53RkovIiEhIXFHEPDxCcDHJ0CKdHEHkNawJCQkJG4DkljVP5JgSUhISEg0CiTBkqh3wsLC+O677xrajKvyyy+/EBYWRnFxcUObIiEhUQfSGpbETTFv3jw+//xzwOIV5ezsTFhYGAMGDGDYsGE2AXYPHjx4V+UEq42YmBgOHjyIo6NjvV7nyJEjbNy4kZMnT1rzTVUH9ZWQkLg60ghL4qbp2rUrBw8e5Pvvv7dmZP7Xv/7F448/buPm6+Hh0WB5w64XlUqFh4dHvcdkKy8vJyws7J6NvychcStIgiVx01Q/5L28vIiIiGDq1Km8/vrrHDhwwDr6AtspwbS0NMLCwti1axcPP/wwUVFRDB8+nKSkJP744w+GDRtGTEwM//znP20iywN88sknPPjgg7Rq1Yp+/fqxdetW67nqfr/99lvGjx9PdHQ0gwcP5tixY9Y66enpTJ06ldjYWFq3bs2AAQPYv38/UPuU4O7duxkwYACRkZH07NmTd99918aenj178uabb/Lcc88RExPD/fffz/bt26/6nXXv3p1nnnmG3r173+C3LSEhIU0JStxWOnXqRHh4ON9++y0jRoyos97atWuZP38+vr6+zJ8/n9mzZ+Pg4MDzzz+Pvb09M2fO5NVXX2XRokUAfPnll7z66qu8+OKLtGjRgri4OBYsWIBGo7FJZLl69Wrmzp1LkyZNWL16NbNnz+bbb79FoVCwePFiDAYDH3zwARqNhvj4eDQaTa32nTx5kpkzZ/Lkk0/Sv39/jh07xqJFi9DpdDZpTTZt2sSMGTOYOnUqu3fvZuHChcTGxhIcHHybvlGJux1BgOrdrFd+vh0YDAY2bHidffv2IpcrUCgUPPzweAYMGARAdnY2r732CqdPn0Imk+Hh4cETT8wgMjIKgJ07v2T16lX4+flRVVWFUqnk/vt7Mm7cxEaZQVoSLInbTnBwsE3qktqYNGkSXbt2BWDChAnMmjWLzZs307ZtWwAeeughPvvsM2v9tWvXMm/ePPr06QNYsinHx8ezfft2G8GaNGkS999/PwAzZsxgwIABJCcnExISQkZGBn379iUsLMzaR11s2rSJTp068cQTTwAQFBREfHw8GzdutBGsbt26MXasJYL2lClT2Lx5M7/88oskWPcIKSkJJCQk0Lp1DADHjx8jJCSEwMCQ29L/kiUvodfref/97djb25ORkcEzzzyJyWSid+++TJ8+hcGDh7J06QoAjhz5hWefncn69W8REtIMgLZt2/Hyy68AkJ+fz7Jli3nhhXmsWrXmtth4J5EES+K2I4riNdeCqkUDsGZu/mtZ9ZRgeXk5KSkpPP/88yxYsMBax2g01nCSuLKP6gSV+fn5hISEMGHCBBYuXMjBgwfp3Lkzffr0qTNpYmJiIr169bIpa9OmDVu2bMFkMiGXy2tcTxAE3N3dycvLu+q9S/w9EARISEhg2bJ/WZ2KioqKmD//eZo0CbnlkVZKSgr79+/jyy93YW9vD4Cvry9PPz2LlSuXIYoiTk5OTJjwiLVNbGwHBgwYzAcfvMdLLy2p0aerqysvvriYQYP6kZiYQHDw7RHWO4UkWBK3nYSEBPz9rx5HTalUWj9Xi9uVgUQFQcBsNgMWwQJYsmQJ0dHRNv1c6Y1YV7/V/YwYMYIuXbqwb98+fvrpJ9566y3mzp1bI9nijfDX4KeCINyTaR/uRUQRWreOwdnZmaKiIgCcnZ1p3TrmtkwLnjt3hoCAAJyddTblkZFRZGVlcuZMnHXq70patYpiw4bX6+zXycmJgICARilYktOFxG3l0KFDnDt3zjp1dztwd3fH09OT1NRUmjRpYvPvatN6teHj48OYMWNYt24djz76KB9//HGt9YKDgzl69KhN2dGjR2natKl1dCUh0VhprC9V0ghL4qbR6/Xk5ORgNpvJzc3lxx9/ZMOGDfTo0YMhQ4bc1mvNmDGDpUuX4ujoSNeuXdHr9Zw8eZLi4mIeffTR6+rjX//6F926daNp06YUFxfzyy+/EBJS+xvmpEmTeOihh1i/fj39+/fn+PHjbN269Zbd0cvKykhJSbEep6WlERcXh7OzM76+vrfUt8SdRRAsa1ZFRUU2U4LHjx+jZ88+tzzKCg0NJzU1laKiQptR1smTf+Dl5U14eAv+97/ParT7888/CAurfaobLJmK09LSrGtcjQlJsCRumh9//JEuXbqgUChwcnIiPDycF154gaFDh9aYqrtVRowYgZ2dHRs3buTll19Go9EQGhrKxIkTr7sPs9nM4sWLyczMRKvV0rVrV5577rla60ZERLBmzRpee+013njjDTw8PJgxY4aNw8XNcPLkSSZMmGA9Xr7ckmJ96NChrFix4pb6lriziCKEhIQwf/7zNZwubscAJjAwkC5durJ8+VIWLlyCnZ3F6eLVV1/h0Uf/SZ8+/diyZRNbtmy2rmP99tuv7Nz5JevWvVlrnwUFBaxYsZTY2PYEBTU+xyApvYiEhMQ9z82nF6lft3a9Xs+GDevZt+8HFAoFcrmcMWPGMmjQEACysjJ57bXVnD59Crlcjru7O9OnzyAqyrLWW5tbe/fuPRg//pG7xq39RtKLSIIlISFxz3MrgiVxa9yIYElOFxISEhISjQJJsCQkJCQkGgWSYElISEhINAokwZKQkJC4hLSk3xBc/3cuubVLSEjc86hUKuRyGQUFuTg56VAolNduJHEbECkuLkImE2yi1NSF5CUoISEhgcWFPCMjg7Ky8oY25Z5CJhMICAhAq9Ves64kWBISEhKXEEURo9GIyWRqaFPuGZRK5XWHO5MES0JCQkKiUSA5XUhISEhINAokwZKQkJCQaBRIgiUhISEh0SiQBEtCQkJColEgCZaEhISERKNAEiwJCQkJiUaBJFgSEhISEo2C/wfPUqv2L09KOAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# evaluate model\n", + "labels, preds = [], []\n", + "for x, y in ds_in:\n", + " x = x.to(device)\n", + " preds.append(torch.argmax(model(x), dim=-1).detach().cpu())\n", + " labels.append(y)\n", + "print(f\"Test accuracy:\\t{accuracy_score(torch.cat(labels), torch.cat(preds)):.6f}\")\n", + "\n", + "# penultimate features 2d visualization\n", + "print(\"\\n=== Penultimate features viz ===\")\n", + "plt.figure(figsize=(4.5, 3))\n", + "plot_2D_features(\n", + " model=model,\n", + " in_dataset=ds_in,\n", + " out_dataset=ds_out,\n", + " output_layer_id=-2,\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### SHE score\n", + "\n", + "We now fit a SHE detector with CIFAR-10 train dataset, and compare OOD scores returned\n", + "for CIFAR-10 (ID) and SVHN (OOD) test datasets.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "%autoreload 2\n", + "\n", + "# === gram scores ===\n", + "she = SHE()\n", + "she.fit(model, ds_fit, feature_layers_id=[\"layer1.2.conv2\", \"layer2.2.conv2\", \"layer3.2.conv2\"])\n", + "\n", + "\"\"\"\n", + " feature_layers_id=[\n", + " \"layer1.0.relu\",\n", + " \"layer1.0.conv1\",\n", + " \"layer1.0.conv2\",\n", + " \"layer1.1.relu\",\n", + " \"layer1.1.conv1\",\n", + " \"layer1.1.conv2\",\n", + " \"layer1.2.relu\",\n", + " \"layer1.2.conv1\",\n", + " \"layer1.2.conv2\",\n", + " \"layer2.0.relu\",\n", + " \"layer2.0.conv1\",\n", + " \"layer2.0.conv2\",\n", + " \"layer2.1.relu\",\n", + " \"layer2.1.conv1\",\n", + " \"layer2.1.conv2\",\n", + " \"layer2.2.relu\",\n", + " \"layer2.2.conv1\",\n", + " \"layer2.2.conv2\",\n", + " \"layer3.0.relu\",\n", + " \"layer3.0.conv1\",\n", + " \"layer3.0.conv2\",\n", + " \"layer3.1.relu\",\n", + " \"layer3.1.conv1\",\n", + " \"layer3.1.conv2\",\n", + " \"layer3.2.relu\",\n", + " \"layer3.2.conv1\",\n", + " \"layer3.2.conv2\",\n", + " ],\n", + ")\n", + "\"\"\"\n", + "scores_in, _ = she.score(ds_in)\n", + "scores_out, _ = she.score(ds_out)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Metrics ===\n", + "auroc 0.990858\n", + "fpr95tpr 0.040200\n", + "\n", + "=== Plots ===\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# === metrics ===\n", + "# auroc / fpr95\n", + "metrics = bench_metrics(\n", + " (scores_in, scores_out),\n", + " metrics=[\"auroc\", \"fpr95tpr\"],\n", + ")\n", + "print(\"=== Metrics ===\")\n", + "for k, v in metrics.items():\n", + " print(f\"{k:<10} {v:.6f}\")\n", + "\n", + "print(\"\\n=== Plots ===\")\n", + "# hists / roc\n", + "plt.figure(figsize=(9, 3))\n", + "plt.subplot(121)\n", + "plot_ood_scores(scores_in, scores_out)\n", + "plt.subplot(122)\n", + "plot_roc_curve(scores_in, scores_out)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('', CifarResNet(\n", + " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (layer1): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (layer2): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (layer3): Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", + " (fc): Linear(in_features=64, out_features=10, bias=True)\n", + "))\n", + "('conv1', Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('bn1', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('relu', ReLU(inplace=True))\n", + "('layer1', Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + "))\n", + "('layer1.0', BasicBlock(\n", + " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + "))\n", + "('layer1.0.conv1', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer1.0.bn1', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer1.0.relu', ReLU(inplace=True))\n", + "('layer1.0.conv2', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer1.0.bn2', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer1.1', BasicBlock(\n", + " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + "))\n", + "('layer1.1.conv1', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer1.1.bn1', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer1.1.relu', ReLU(inplace=True))\n", + "('layer1.1.conv2', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer1.1.bn2', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer1.2', BasicBlock(\n", + " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + "))\n", + "('layer1.2.conv1', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer1.2.bn1', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer1.2.relu', ReLU(inplace=True))\n", + "('layer1.2.conv2', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer1.2.bn2', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer2', Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + "))\n", + "('layer2.0', BasicBlock(\n", + " (conv1): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + "))\n", + "('layer2.0.conv1', Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False))\n", + "('layer2.0.bn1', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer2.0.relu', ReLU(inplace=True))\n", + "('layer2.0.conv2', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer2.0.bn2', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer2.0.downsample', Sequential(\n", + " (0): Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + "))\n", + "('layer2.0.downsample.0', Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False))\n", + "('layer2.0.downsample.1', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer2.1', BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + "))\n", + "('layer2.1.conv1', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer2.1.bn1', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer2.1.relu', ReLU(inplace=True))\n", + "('layer2.1.conv2', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer2.1.bn2', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer2.2', BasicBlock(\n", + " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + "))\n", + "('layer2.2.conv1', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer2.2.bn1', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer2.2.relu', ReLU(inplace=True))\n", + "('layer2.2.conv2', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer2.2.bn2', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer3', Sequential(\n", + " (0): BasicBlock(\n", + " (conv1): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " )\n", + " (1): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + " (2): BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + "))\n", + "('layer3.0', BasicBlock(\n", + " (conv1): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " )\n", + "))\n", + "('layer3.0.conv1', Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False))\n", + "('layer3.0.bn1', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer3.0.relu', ReLU(inplace=True))\n", + "('layer3.0.conv2', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer3.0.bn2', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer3.0.downsample', Sequential(\n", + " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + "))\n", + "('layer3.0.downsample.0', Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False))\n", + "('layer3.0.downsample.1', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer3.1', BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + "))\n", + "('layer3.1.conv1', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer3.1.bn1', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer3.1.relu', ReLU(inplace=True))\n", + "('layer3.1.conv2', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer3.1.bn2', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer3.2', BasicBlock(\n", + " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (relu): ReLU(inplace=True)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + "))\n", + "('layer3.2.conv1', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer3.2.bn1', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('layer3.2.relu', ReLU(inplace=True))\n", + "('layer3.2.conv2', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", + "('layer3.2.bn2', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", + "('avgpool', AdaptiveAvgPool2d(output_size=(1, 1)))\n", + "('fc', Linear(in_features=64, out_features=10, bias=True))\n" + ] + } + ], + "source": [ + "for m in model.named_modules():\n", + " print(m)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tfmetal", + "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.5" + }, + "orig_nbformat": 4, + "vscode": { + "interpreter": { + "hash": "dada21ee7726b34311237058025d0293bf4743ff9612a3722201b24280433f0a" + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 252135e533e66b1f78f21feba46e87a0624a636a Mon Sep 17 00:00:00 2001 From: "paul.novello" Date: Tue, 16 Apr 2024 15:48:59 +0200 Subject: [PATCH 06/10] chore: updated readme and doc --- README.md | 1 + docs/index.md | 1 + 2 files changed, 2 insertions(+) diff --git a/README.md b/README.md index 2b2230d5..44e2221f 100644 --- a/README.md +++ b/README.md @@ -178,6 +178,7 @@ Currently, **oodeel** includes the following baselines: | Gram | [Detecting Out-of-Distribution Examples with Gram Matrices](https://proceedings.mlr.press/v119/sastry20a.html) | ICML 2020 | avail [tensorflow](docs/notebooks/tensorflow/demo_gram_tf.ipynb) or [torch](docs/notebooks/torch/demo_gram_torch.ipynb) | | GEN | [GEN: Pushing the Limits of Softmax-Based Out-of-Distribution Detection](https://openaccess.thecvf.com/content/CVPR2023/html/Liu_GEN_Pushing_the_Limits_of_Softmax-Based_Out-of-Distribution_Detection_CVPR_2023_paper.html) | CVPR 2023 | avail [tensorflow](docs/notebooks/tensorflow/demo_gen_tf.ipynb) or [torch](docs/notebooks/torch/demo_gen_torch.ipynb) | | RMDS | [A Simple Fix to Mahalanobis Distance for Improving Near-OOD Detection](https://arxiv.org/abs/2106.09022) | preprint | avail [tensorflow](docs/notebooks/tensorflow/demo_rmds_tf.ipynb) or [torch](docs/notebooks/torch/demo_rmds_torch.ipynb) | +| SHE | [Out-of-Distribution Detection based on In-Distribution Data Patterns Memorization with Modern Hopfield Energy](https://openreview.net/forum?id=KkazG4lgKL) | ICLR 2023 | avail [tensorflow](docs/notebooks/tensorflow/demo_she_tf.ipynb) or [torch](docs/notebooks/torch/demo_she_torch.ipynb) | diff --git a/docs/index.md b/docs/index.md index 0fe92c4e..0a8443ad 100644 --- a/docs/index.md +++ b/docs/index.md @@ -176,6 +176,7 @@ Currently, **oodeel** includes the following baselines: | NMD | [Neural Mean Discrepancy for Efficient Out-of-Distribution Detection](https://openaccess.thecvf.com/content/CVPR2022/html/Dong_Neural_Mean_Discrepancy_for_Efficient_Out-of-Distribution_Detection_CVPR_2022_paper.html) | CVPR 2022 | planned | | Gram | [Detecting Out-of-Distribution Examples with Gram Matrices](https://proceedings.mlr.press/v119/sastry20a.html) | ICML 2020 | avail [tensorflow](./notebooks/tensorflow/demo_gram_tf.ipynb) or [torch](./notebooks/torch/demo_gram_torch.ipynb) | | GEN | [GEN: Pushing the Limits of Softmax-Based Out-of-Distribution Detection](https://openaccess.thecvf.com/content/CVPR2023/html/Liu_GEN_Pushing_the_Limits_of_Softmax-Based_Out-of-Distribution_Detection_CVPR_2023_paper.html) | CVPR 2023 | avail [tensorflow](./notebooks/tensorflow/demo_gen_tf.ipynb) or [torch](./notebooks/torch/demo_gen_torch.ipynb) | +| SHE | [Out-of-Distribution Detection based on In-Distribution Data Patterns Memorization with Modern Hopfield Energy](https://openreview.net/forum?id=KkazG4lgKL) | ICLR 2023 | avail [tensorflow](docs/notebooks/tensorflow/demo_she_tf.ipynb) or [torch](docs/notebooks/torch/demo_she_torch.ipynb) | **Oodeel** also includes standard training functions with data augmentation and learning rate scheduler for toy convnet models or models from `keras.applications` in [tf_training_tools.py](https://github.com/deel-ai/oodeel/tree/master/oodeel/utils/tf_training_tools.py) and `torchvision.models` in [torch_training_tools.py](https://github.com/deel-ai/oodeel/tree/master/oodeel/utils/torch_training_tools.py) files. These functions come in handy for benchmarks like *leave-k-classes-out* that requires retraining models on a subset of dataset classes. From abf53b56106ec462e3a69c35e1d7c0a3a7e05068 Mon Sep 17 00:00:00 2001 From: paulnovello Date: Tue, 16 Apr 2024 15:59:01 +0200 Subject: [PATCH 07/10] fix: unused imports --- oodeel/methods/she.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/oodeel/methods/she.py b/oodeel/methods/she.py index c36fbe66..e730b74e 100644 --- a/oodeel/methods/she.py +++ b/oodeel/methods/she.py @@ -21,11 +21,8 @@ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import numpy as np -from sklearn.linear_model import LogisticRegression -from sklearn.neural_network import MLPClassifier from ..types import DatasetType -from ..types import List from ..types import TensorType from ..types import Union from .base import OODBaseDetector From d48924510523a79d7edd5395ca40711f033d792b Mon Sep 17 00:00:00 2001 From: paulnovello Date: Fri, 19 Apr 2024 10:22:36 +0200 Subject: [PATCH 08/10] feat: S_i computed with correctly classified points only --- docs/notebooks/tensorflow/demo_she_tf.ipynb | 46 +-- docs/notebooks/torch/demo_she_torch.ipynb | 356 +------------------- oodeel/methods/she.py | 9 +- 3 files changed, 42 insertions(+), 369 deletions(-) diff --git a/docs/notebooks/tensorflow/demo_she_tf.ipynb b/docs/notebooks/tensorflow/demo_she_tf.ipynb index d50dc682..4fcb6973 100644 --- a/docs/notebooks/tensorflow/demo_she_tf.ipynb +++ b/docs/notebooks/tensorflow/demo_she_tf.ipynb @@ -179,7 +179,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "41/41 [==============================] - 1s 12ms/step - loss: 0.0217 - accuracy: 0.9934\n", + "41/41 [==============================] - 2s 21ms/step - loss: 0.0217 - accuracy: 0.9934\n", "Test accuracy:\t0.9934\n", "\n", "=== Penultimate features viz ===\n" @@ -187,7 +187,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAawAAAEiCAYAAAClcuYEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3RUVdeHn+mZtEnvPZBAKqGH3hEEaVYQxRcrNhQ/e0FsqNhFUEF9wQJSVHrvvbcQkpBCek8mmUyfud8fMUNiEgSk+s6zFmvN3HNPuTfD/d19zj57iwRBELBjx44dO3ZucMTXewB27NixY8fOxWAXLDt27Nixc1NgFyw7duzYsXNTYBcsO3bs2LFzU2AXLDt27Nixc1NgFyw7duzYsXNTYBcsO3bs2LFzU2AXLDt27Nixc1NgFyw7duzYsXNTIL3eA7DTnNTUVDZt2gTAmDFjCAoKuqh6giCwatUqFi5cyLlz59Dr9bi5uRESEkKnTp2YOnWq7dwBAwZQUFAAwLhx43j33XdtZc888wxr1qwBYPPmzQQFBZGfn8/AgQNb7XvMmDHMnDmz1fJDhw6xfPlyjh07RllZGWazmeDgYEaPHs29996LXC63nTtx4kQOHDgAgEgkQqFQoFKpiIiIYMiQIYwdOxYHB4eLuifXksb36IknnuDJJ5+8Kn389ttvAAwaNIj27dvbyvbv3899990HwHvvvcfYsWOveP927FxP7IJ1A5KamsqXX34JQNeuXS9asL788ktbvQaKi4spLi4mPT29iWA1ZsWKFTz55JP4+/v/o3FfiBUrVrBs2bImx9LS0nj//ffZt28f33zzTYv1BEFAr9ej1+spKSlh7969LF68mG+++QZfX9+rNt4blYKCAtvfODAwsIlg2bHzb8cuWP8SzGYz33//PQDx8fF88skn+Pr6UlhYyNGjR9m2bVurdU0mE99++y2vv/76RfXVtWtXFi5ceEnjk0gkjB07lvHjx9O2bVuOHTvG448/jkajYfv27Zw8eZL4+Phm9TZv3oyPjw+pqal88skn7N27lzNnzvDkk0+yePFiRCLRJY3jUjAajUilUsTii5s5DwoKIi0t7aqN5+/o1q3bde3fjp2rjX0N6wZj4sSJvPTSS7bv9913H9HR0URHR1+wXmVlJXV1dQDExMQQHByMXC4nLCyMMWPG8Nlnn7VYTyKRALB06VLKysqu0FU0Z9q0abz33nvEx8fj4OBA9+7dGT16tK383LlzrdaVy+UkJibyzTffEBgYCMDx48fZunXrBftsuG8vvvgiixcvZvDgwcTHxzNu3DgOHz5sOy8/P9927qeffspnn31G7969SUhIQKPRAHDixAkeffRRunXrRlxcHAMGDODtt9+murq6xXa++OIL23FBEPjll18YO3YsHTp0IDExkTvvvNM27dqYM2fOMHXqVHr16kVcXBy9evViypQpqNVqXnzxRduUH8BLL71k6y8/P5/9+/fbvi9fvtx2ntFoZPbs2QwfPpz4+Hg6duzIxIkTm92/iRMnEh0dzYABAzh06BB33nknCQkJ3HLLLaxevfqC99qOnWuB3cL6l+Dh4YFMJsNkMrF48WKys7Pp0aMHnTp1IikpCZlM1mI9d3d3IiMj2b9/P99//z3PP//8VRmfs7Nzs2MGg8H2+WKm9+RyOffccw+zZs0CYMeOHQwYMOBv623bts227gNw6tQpJk+ezNKlS2nTpk2Tc3/55ZcmItTQz5QpUzCZTLZjBQUFLFy4kJ07d7JkyRJcXV1b7f/ll19uIiBQL7jPPPMMhYWFPPjggwDs3buXhx56qEk/ZWVlbN68mdra2r+9zpYwm808+OCD7N+/33bMaDRy4MABDhw4wOuvv86ECROa1KmoqGDSpEm2cWRnZ/Pcc8/Rrl07IiMjL2scduxcCewW1g3GwoULee+992zfFyxYQFpa2t9O9UilUu666y7b9wMHDvDpp58yceJE+vTpw+LFi1ut+9hjjwEtP6xb4sCBA7Y3+YZ/DU4iF0tWVharVq0CIDw8nE6dOl1UvfDwcNvnBqeRv6O6upqPPvqIw4cPM23aNAB0Oh1z5sxpdq5arebNN9/k8OHDrFmzBqVSyYwZMzCZTCgUCubNm8ehQ4e4//77AcjJyWH+/Pmt9t3gbALw6KOPcvjwYfbt28fgwYMB+Pzzz6mqqgLgjTfesInE888/z4EDB9ixYwevvfYaSqWSmTNnsmDBAlvb7733nu230do656pVq2xiNXjwYPbu3cvy5cvx8vICYNasWdTU1DSpo9frGT16NAcOHGDGjBkAWK1WNmzYcKHbbMfOVccuWP8iXn75ZZ5//vlmD6/Kykpef/11m+fdX0lOTqZDhw5otdomD8SrRV5eHg8++CA6nQ5nZ2c+/fTTi14nslqtts8Xu36VlJTEiBEjcHZ25sEHH8TT0xOgidXRQM+ePbn77rtxdnYmMjKSvLw88vLyAOjXrx+9e/fGxcWFZ555xma17ty5s9W+d+zYYfs8d+5cOnXqRPfu3dm4cSNQb2UePXqU7Oxs27Roz549mTx5MiqVCl9fX+69917bmC+Vxv0//fTTeHh4EBsby+233w6AVqvl0KFDTepIJBJefPFFVCoVo0aNsh0vKiq6rDHYsXOlsAvWTUbDOkPDv8ZTYhKJhMmTJ7N582ZWr17Nq6++SlhYmK188+bNrbbbYGX9+OOPtrWw1ujatavtzb7h36BBgy5q/FlZWUyYMIGCggKcnZ355ptvaNeu3UXVhXqLpoGG9ay/o7H3o1gsxsfHB8Bm2TTmr2NpfE7jdpRKJW5ubkD9C0FrXKisAbVa3eS8iIiIv61zsbQ2/saf/zpGT09P2xSuQqGwHTcajVdsXHbsXA72NawbkMvxfBMEAZ1Oh6OjIwBt2rShTZs2dOzY0bYfR61Wt1q/X79+tG/fntTUVHbt2nV5A/8bMjIymDRpEuXl5bi5uTFv3rwWPQNbw2g0smjRItv3vn37XlS9xpaB1WqltLQUqF+/+yt/3d/V+Jzi4mLbZ71eb5s+bamdBjw8PGyfFy9eTIcOHZqUC4KASCQiOzvbdqzx579yqb+Nv46/Yc2u8T356/gbr3deTS9MO3YuFbuFdQPSeAH/7NmzCIJg+75w4cImls2WLVuA+of5wIED+eyzz0hJScFgMFBTU9PEE+3v3twfeeQRACwWy5W8HKB+b9nEiRMpLy/Hy8uLBQsWXLRYGY1GTpw4wSOPPGJbt+rQocNFC9bRo0dZs2YNGo2GefPmUVFRAdS7gf8d4eHhtinWrVu3smfPHjQaDZ9++qltval3796t1u/Tp4/t88yZM8nMzMRoNJKXl8fChQuZNGmSrZ8Ga3jXrl388MMP1NTUUFZWxs8//2wb819/G3/3t2o8tob1stTUVNueOKVSSefOnf/2PtixcyNgt7BuQGJiYpBKpZjNZmbMmMGMGTPo2LEjv/zyywXrVVZW8tVXX/HVV181K/Pw8PjbyAdDhw4lIiKCrKysC57X4HTRmL/bm/Xf//7XNj1VXl7Obbfd1qS8tcgQLUXXaN++PZ9//vlFv/17eXnxzDPPNDnm4OBgmwa9ECKRiNdff50pU6ZgMBh44IEHmpSHhoYyefLkVut37tyZsWPHsnz5co4ePcrw4cOblDee1pw+fbrNS/C9995r4nzTIHyhoaGoVCrUajXz589n/vz5+Pr6NlmraszIkSNZtmwZBw8eZP369axfv75J+bRp01CpVH97H+zYuRGwW1g3IP7+/syYMYOQkBCk0ot7p5DL5bz77rvceuuthIWF4eLiglQqxdfXl9tuu41FixbZPMNaQywW26ysG4WG0Ey+vr4kJyczffp0Fi9efElRLnr16sXMmTMJDQ1FJpMRGxvL/Pnzm7m0t0bfvn358ccf6d+/PyqVCqlUSkBAAPfeey+LFi2yPfAbO4Q0nlZ79913efPNN4mPj0epVKJUKgkLC2PUqFG88cYbtvOSk5NZsmQJw4YNw8vLC6lUipeXFwMGDMDFxQWot4g++OAD2rZt2+pWhcZIpVLmz5/PE088QUREBDKZDEdHRzp37szs2bOZOHHiRd0DO3ZuBERC4/kmO3b+RTRYgX8X5/BKsWHDBpuV+OGHHzazIu3YsfPPsE8J2rFzBRgzZgzp6elA/TpT47UrO3bsXBnsU4J27FwB8vLykEgkJCQkMHfuXJvLux07dq4c9ilBO3bs2LFzU2C3sOzYsWPHzk2BfQ3rBqZxIkOod4Fu2HfVkIDxclJ93Mjk5+fz008/ceDAAQoLC6mrq8Pf35+ePXvy+OOPX3aIotb6ainh4rV21vgrRqORTz75hKNHj5KSkmKLMPHtt982Wxt78cUXmwT2bcxLL71k2+cF9V6MCxYs4NdffyUvLw8XFxf69OnDM88808TrsnPnzk2C7V6v+2DHzl+xC5adG4rjx4/z3XffNTmWk5NDTk4Omzdv5o8//vjXrw/p9fpm9+BK0LAloIGKigp+++039u/fz9KlS6/oy4AdO1cD+5TgTUBD7L4G6+pmQa/XX1a9rl278vXXX3P06FHWrVtny6pbXFzcLGvx1aAhisj1siqkUikTJkxg1qxZ3H333RdVZ8yYMc3iOza2ro4fP24Tq/79+7N3717effddAAoLC5vk7zp06BBpaWkXHavRjp1rhV2w/kX88ccfTJw40Zb8LzExkdtuu43vv//eFsJn/PjxREdH069fvyYbXTds2GALqLtu3Trb8bVr1zJ+/Hg6duxIfHw8t912Gz///HOTcFFffPGFre6+fft45JFHSEpK4tlnn73ka+jXrx8LFy6kX79+ODo6Eh4e3iQixYUSPV4Iq9XKp59+Ss+ePenQoQNPPPFEqwkrGyd+bGDAgAFER0czceJEVq1axeDBg+nQoQOPP/44lZWVnDlzhnvuuYcOHTpw2223sXfv3iZtNr5HLUWJb4yjoyOvv/46I0eO/NvN3hfLypUrbZ8fffRRPDw8GDdunC0c1OrVq5v8HuzYuRGxTwn+i9i7d2+TNS+TyWSzFKqrq3nmmWeYMGEChw8fpqioiN27d9tizTWE7HFzc7NFgP/yyy+bvHlDvfXx5ptvkpGR0SRKQwNPP/30ReXUag0nJ6dmxxonemyItH6pfPXVV03yX23cuJFjx45dcjtpaWk899xzNsHetGkT1dXVnD171nbdaWlpTJkyha1bt16z6cuNGzeydu1aANq2bcu9997bJKNzSkqK7XPjmJIRERHk5ORQU1NDfn4+ISEh12S8duxcDnYL61/EmDFj+O233zhw4AApKSls2bKF2NhYAJtVNGTIELy9vQFs02tGo9GWLv3WW29FLpeTn59vi0k4duxY9u7dy+HDh23ZaX/++WfbRtnGuLq6smzZMo4dO8Zzzz33j69Jp9Px7bffAvXhpxrnZ7pYamtrbWtC3t7e/P777+zZs+eysueq1Wpee+01Dh06RFJSElA/hRYQEMCuXbt4+eWXgfo8U63F97saaDQa9Ho9er2ekydP8sILL/D111/byhunEGmc/bnx54YAu3bs3KjYBetfhJeXF3PnzuXWW28lISGBAQMG2N6sa2pqqKioQCaTcccddwD1+bGqq6vZuXOnLQfWmDFjANi9e7dtGnH58uUkJyfTqVMnfvrpJ1t/LU1tTZ06lbi4OJRK5T/O66TX63niiSdswjh9+nSCg4MvuZ20tDTb9Y0aNYr27dvj6enJo48+eslt+fn5MWHCBFxcXJpkSZ4wYQLe3t5NvPgap/B48sknbWtLFxMl/mJJTk5m7ty57N69m8OHD/P222/bkmF+9dVX6HS6C9ZvPLVrTyVi50bHLlj/EjQaDZMnT2b9+vWUlZW1mHaiwQni7rvvRiqVYjQaWbFihW06sG3btraUHxebePCvXEwyxvz8/CZJKKOjo5tNPdbV1fHQQw+xa9cuRCIRr776KuPGjfvbtluiIf8V0MR9+1IC6DYQEBBg+9w4d1bD8cYBaa9FwsNRo0bRv39/vLy8cHZ25o477qBHjx5A/d87IyMDaJqXq7HLeuNknY3PsWPnRsQuWP8Sjh07ZnujHzVqlM3Ta+jQoc3O9fX1te0/+vXXX23TgY3XPBo/vD7++ONmHmhnzpzhiSeeaNZ24wy1l0uD+B44cACxWMxbb731j6KKN173KikpafHzxdJa9HyJRHLpA/uHCILA3wWqabCaGqaGoWmCyIZUMq6urra8X3bs3KjYBetfQuO3eQcHB2QyGbt372b79u0tnj9+/HigPgtwTU0NEomkSXTxnj172h7Cn3/+OSdPnsRoNFJcXMzSpUubiNulEhQU1EwAGzbtqtVqJk2axNGjR5FKpXzwwQe2Kcy/snz58ovyvIuOjrY5c/zxxx+kpqZSUVHB3LlzL/saLpVL8RKEegu3srKyyZSeRqOhsrLSZiHV1tZyxx13sHbtWqqrq9FoNCxZsoQ9e/YA9etTUVFRQH1erAbmzp1LZWUly5YtIycnB6hfu2yYSrRj50bF7iX4L6Fjx464ublRXV3N4sWLWbx4MSKRiKCgIPLy8pqd3717d9q0acPZs2eBeoFqbIkEBQUxZcoUvvjiC3Jycrj99tuvyXVs3ryZkydPAmA2m3nuueeaOG9cTmQPFxcX/vOf//DFF19QVlZmE9sbeQNycnJys2MNSSgb34OTJ08yderUFtt4/vnnbRZvYmIid911F4sXL2br1q1N2g8ICGgxeaYdOzca9leqfwlubm7MmTOH+Ph4FAoFYWFhfPDBBxdMf37PPffYPjc4WzTmiSee4NNPP6Vz5844OTmhUCgIDg5m6NChzJo166pcx6XQ4Ebu6OhIaGjoBc+dMmUKjz32GJ6eniiVSvr378/s2bOvwSivHo6Ojrz22mv06tULPz8/ZDIZrq6u9OzZk3nz5nHXXXc1OX/69Om89NJLREZGIpPJ8PDwYPTo0SxatMge5cLOTYE9WvsNTEMswasVL/CTTz5h7ty5uLu7s2PHDuRy+RXv42oyefJkdu3axSuvvMJ99913vYfzr6MhXqU9lqCdGwX7lOBNwIEDB4iOjm4S/Paf8NFHH7Fq1SoKCwsBmDRp0k0nVkaj0bYX6t57773ew/lX8dfgt3bs3CjYBet/kLKyMgoLC3Fzc2PkyJE89NBD13tIl4xcLuf48ePXexh27Ni5htinBO3YsWPHzk2B3enCjh07duzcFNgFy44dO3bs3BTYBcuOHTt27NwU2AXLjh07duzcFNi9BO3YsWPnTywWCyaT6XoP438KmUx20bE47YJlx44dO9THaszLy8NqtTtOX0vEYhHBwcFNcrO1ht2tvQUqKmq5HndFJAJPT5fr1v/lcrOOG+xjv15cztgb6lwNLBYL6enpSKUKXF1VgD032LVBoKZGjdlsICoq6m8tLbuF1QKCwHV9AFzv/i+Xm3XcYB/79eJGGbvJZMJqFXB1VSGXO/x9BTtXDFdXKC8vwWQy/a1g2Z0u7Nz0iCUglltxdJQjkzX/SYtEIkQSgeuQssrOTYfdsrr2XPw9t1tYdm5atNSQrkllWeZSqnRVJHonkuSThIeDB8GKMOSCI6XWfPaX7Gdz7iaUEiUjIkcQ55aIq3A+OrnGqEFDNQqxEqn1nyegtGPnSmE2m/nhh/ls3LgeiUSCRCIhJiaWHj16MW/e1yxcuOh6D/GaYhcsOzclWpGaL059yvpz623HTleeZmnGUp7t9CxFsiLivRKYf2oeW/O2YrLWe37tK95HnGccbybPwAlXTqmPs2D/f8lWZxPsGsz97SYR79YBB+HvF4Dt2LnavPvuDNRqNd9++wOurq4IgsCWLZuoqVFf76FdF+yCZee6IxKJ0FCNzlKHVCTDXeKFYL3ANIFI4Fj14SZi1YBKoSLAOYASbQk/nllIqGsoM3vP5FzNOTblbqJ/cH+sgpXs2ixqDDW8te8tBASkIinV+mo+OPw+g0OGMKntZOSC41W8ajt2LkxeXi6bN2/ijz9W4+rqCtT/Xxk4cDCHDx+ynWc2m5k27SnUajUGg4G2baN46aXXUCqV5Obm8tZbb6DTaREEgd69+/Loo4+zc+d25s6djVgsxmKx8Oijj9OnT7/rdKUXj12w7FxRRCJwEOoQC2aMEmdM1qYLR2IpWAQzUmRYLAJ6kYYcXSYZ6nSKNEW4yl2JdIukjUsUnmI/RCIRFovV1rZEIqbMUsjyjOXN+naRufBG8hu8susVaow1TcoeS3yMh+Mf5rntzyESiRjbdizJ/sl8OfBL5GI5MomMzOpMnGROWK1WSk1FBEkjr96NsmPnb0hLO0NwcDBubu4XPE8ikTBjxruoVG4IgsAHH7zHkiWLuO++B1i6dDG9evXm/vv/A4BaXW+Zff31V7z44ivExyditVqpq6u76tdzJbALlp0rhpOljFJNJqk12egtJnydfAlyCUNQRqK16snUpvNb5nJKdaXcGnYrXXy7Um4oY/q+N6g11tLFrwuV+krWZK9hePhwEr0S2Zi7kSTvjrR1b0NhbRFl+lIiVBE03o3h5+THLWG3kOyfzGt7XmsmVgBzjs/h434f80ynZ/B39MeChXkn53Gq4hRSkZT+wf0Z3XY07+x7h/ae7ekb1BcvDz8crE7X8hbasXPJCILAL7/8xJ49u7BYLGg0GuLjEwDo0KEjX375KVqtlo4dO9GlSzcAOnfuyiefzKJ//4F065ZMVFT09byEi8YuWHauCMaqc+wp3cVrJ+dSazqf/G+wfw+eTHycfJOaWnMNt7W5DYlIwu8Zv7M1fysdvDvwfJfnyVJnsTN/J25yN6Z0mIKTzAlnhTM56hxOlp/k7nZ3c6r8FLsKdqGUKhndZjR9g/uiM+uoMdawLH0ZbdzaUKotbXWMm85tokRbQp+gPnxy+BPbcbNgZmPuRvYX72dGzxlM3ToVq2DFS+FFO2WHq3nb7NhplejoduTl5aFWV6NSubV63vr1azl8+CBz5nyLk5Mzixf/wuHDBwEYMGAgCQkJHDiwnyVLFrNo0c988skXTJ06jaysTA4fPsiMGa8zdOgwJk6cdG0u7B9gFyw7/xipVMypyjM8e/QjrIK1SZmrkz97K0+xJG0Jke71U2wldSXcEn4LP6X+RIxnDN+d/I60qjRe7PoiTjInCjWFWAQLbgo37o+7H61JS1FdESGuIXQ1d6WdVzuq9FW0cWvDL2d+IaUiBQCNSXPBcebW5jIifATzTs1rsbzGWMOegj3EesayNW8rPQJ6EOEUjdyqvAJ3yY6dSyM4OIT+/QfwzjszeO21N3FxcUEQBLZu3UJd3fmXwtraWlQqN5ycnKmrq2P16pX4+fkBkJubS1BQEMOHjyAmJpaHH34AgJycbCIiIomIiEQikbJ//97rco2Xil2w7Fw2WmrJ0qYjNWvZcG5jM7Hyd/In2iOaWlMtyYHJ7C7YjUgkomdAT+pMdfwn9j/k1uZyuvI0r3R7hTJtGR+kfGDz6AMYHDqYAcEDcHdwJ7M6k+4B3Zl3ah4ldSU8nPCwTawAnKQXnr4Lcg7CIlgo15W3es6a7DU8GP8gKRUpVBuqMQoG5NgFy8714dVX3+D77+cxefJ9SCQSrFYrSUkdSU7uaTtn+PBb2bFjG3feOQY3N3c6dEiiuLgIgK1bN7Fu3RpkMhlWq5Xnn38ZgDlzviQ39xwymQyFwoHnn3/pulzfpXLTCNYXX3zBl19+2eRYeHg469atA8BgMDBz5kzWrFmD0WikV69evPHGG3h5eV2P4f7r0VDFR8c/YFfhLn4YMJt9laealDvJnHgk4RGMViM/p/5Mhb7CVpZZnYmX0otnOj1DqbYUlVyFg8SBb05+06yfjec2opKr6BvcF71Zj1kw83iHx3GUOnKw+GCTcyv0FXgrvSnTlbU45livWOpMF15cNlvNmK1mAJRSJQqRA9wAkRjs/G8ilcp46KHHeOihx5qV9e3bHwBnZxe+/HJui/Xvv/8/NoeLxrz//kdXdqDXiJtGsADatm3L999/b/veOIzHu+++y/bt2/n0009xcXHhrbfe4oknnmDRov+tjXXXAkFsYW/pLtq6t6VXUC+QKFDJXanQVTClwxQ8HTwpqivCUebIrpxdTcSqgXJdOZtzN9MnoA/hqnB+OvNTq/2tyFxBr8BefHjoQ9sxF5kLL3R9gde7vc6nRz+lxljDNye+4a2eb/Hm3jebOV5MjpvM5nOb6ezXGReZS5N1tsb0C+7HzoKduMpdiXKLQma1h+mxY+dG4aYSLIlEgre3d7PjtbW1LFu2jFmzZpGcnAzUC9jw4cM5duwYHTp0uMYj/fdiEulJrT1JsEswWrOWU+Wn0Jl1TGh7B85KTz46/BEFmgIAHu/wOFvytiAWiXGWOaMz65pM923P286YNmNABGcqz7Tap9FqbLY+VWuqZcbeGTzV8SmmdJjCzAMz0Zq1TN8znWmdp2G0GMlSZ+Gp9CTGI4bZx2dzuuI0xdpi7m53N9+e/LZZP3KxnF6BvXh9z+u82u1VQhwiwNrsNDt27FwnbirBOnfuHL169UKhUNChQwemTZtGQEAAp06dwmQy0aNHD9u5kZGRBAQEXJZgia5TOLGGfq9X/xdDRl0qKgdX9hXtQywS46Zww1nmjLeTHx8f/sQmVgASkYQHYh/AUeZIpb4SF5kLcomclZkrya7JxiJYACjQFKBSqFAbWt+97yBpbukYrUaqDdWEuIQwrdM0LIKF42XHmb53OgNDBhKpiiS/Np/jZceJUEXUC1ZdMamVqUxJnMLitMU26y/GM4bJcZMxmA3MGzwPo8WIQnC8oUPLXevfi0gkQmOxojcLKGVinMQiLjfZw+WM/Ub+f2Hn2nDTCFZCQgLvvfce4eHhlJWVMXv2bCZMmMDKlSspLy9HJpPZdoM34OnpSVlZy+sZF+JqpTC4WfpvDa1JS12NhmOFR1mesZxKfSUeDh5M6zQNs2AhozrDdq6DxIFwVThv73u7yZSgRCThscTH2HhuI9WGagxmA4HOgdwZdWcTq8ffyR8XuQsFmgIiXCNIq0prcUynyk9xuOQwR0uPAtDVryvv936fk+Un+T7lex5OeJg/Mv9gaNhQnkx6ks25mzlZfhJBEHil2yuIRCJ0Zh0ZVRmU68o5WX6S9h7tifGMwcvrxvw7/JVr8XvJKtOw7mQxiw7k0dbXiaQQdzqHuuHhpCDMywm59PIiC9+ov3U7NyY3jWD17dvX9rldu3YkJibSv39/1q5di4PDlV1nsOfDapkKClmbvZZt+dtsx9p5tKNSX9lszej2qNv54OAHzdavLIKF2cdmM63zNBQSBfNOzmNC+wl08O5AO/d2qBQqegT2IK8mj2pDNf2D+9PJtxMv7HihxTF5OniSWplq+36g+ACCIODl6IXJakJr0hLoHMj6nPVsyd1C36C+dPDuQHFdMd+nfE+UexSZ1Zm81v01smuySfROxEHqgNlqJrviHC6Cx5W7gVeYa/F7kUrFVBgsbEwtpb2/C8/dEk1VnRG1zsjqE8X0jvLmyLkqovxcCHWWX7TFdaPlw7Jzc3DTCNZfcXV1JSwsjNzcXHr06IHJZKKmpqaJlVVRUdHimtffcb1z9Fzv/lujUFfYRKwAuvl1wyJY8JA3fbB7KusdL1pCQOCc+hxx3nG4Klx5fc/rvNj1Re6MvpNzNeeabOrdlLsJF5kLT3V8ik8Of4LWrG3SVpR7FKuzVzc5drDkIG/3fJtCTSEpFSncH3M/W/O2sq9oH5tyNyERSegf3J++QX2ZfWw2M3rMYMa+GRwvO25rw0XmwsvdXqadWywq643taXo1fi9VJgsnCmtQyqQ4O0hRKeWcLKhBLBKxLa2UXm296BDqTkapBn+VA8fy1UhC3AhwuLRHyo36W7dzY3LT5sOqq6sjLy8Pb29v4uLikMlk7N17fvNbVlYWhYWFdoeLK4REIrJNuzUQ5BJEdk02RosRNwc3/Jz8bGVGi/GC7aVVpeEkdaKTbycEBFZnrUZA4L+n/9vs3FpTLfNOzmN0m9FNjt/e9nb2F+9vsX2DxYCbwg0RIvQWPZNiJ/FOz3d4LPExHkt8jHJdOV8e+5JbI25lafrSJmLV0Odru1+jQJuLWPy/tXhSbrSwOqUEX1cHzpZpePTHI8xYdZr8Kh1ujlKmDmpLfpWW55ee4MP1aTz763G+3HKWco0RJP9b98rOteWmsbDef/99+vfvT0BAAKWlpXzxxReIxWJGjBiBi4sL48aNY+bMmahUKpydnXn77bdJSkqyC9YVQhBotjHYWeZMjaGGTr6dyKjKYHLcZD478hkakwaZWHbB9vyc/MhUZ6KSqwCQiqXsyN/R6vkl2hLauLUhwSsBXydfuvl1Y1v+NvYU7mnx/GpDNdvztwOwv3g/ng6ePJzwMF+f+LrJdST5JLEqa1WLbZgFM7sKduEapsJd4o0Tri2ed6NgFUOt0YoIUMkkTabnNEBelZ6SGj0OMgmhHkr8lFJEf7VuRJBVoWVfdiX+KiWfbMogIUjFbYkB/LI/l18P5QGQFOzGGyNjmLMtkyK1nso6I08vOsa8+zvRxlXxP2U1ac1Wsqt0VGlNuDvKCHdX4ii9urbA6NG38sEHH1/VGICVlZXMmPEa+fn5yOVy/u//XiQpqdNV6+9iuGkEq7i4mGeffZbq6mo8PDzo1KkTv/76Kx4e9VNRL7/8MmKxmKeeeqrJxmE7VwarVSDJJ6mJBZRfm0+/oH6YrWY+PfIprnJXJsVOQmfWoVKocFO4UW2obrG9OK841mWvIzmgfhuCt9Kbs+qzFxxDtaEaF7kLxZpiaow17CrY1eJ5SqnStvm3gQp9BZtzN/Ng/IP8cfYPPB086RfcD4PFcME+j5YeJdE7kZ/zf+aJ2Kk4CjfeGorWKpBWruNobhVmq4CnkxwQ6NPWC5FIhNZoYd7ObGr0ZrqEe4AgcLpITYcgN0I9HBGLRah1JtJKanGUS6kzmLk9KYivd2bhqpRya7w/b69ObdLn0bxqUgprePnW9kxf8WdoLIOZPZkVOLT1ItBJfh3uxLWnqM7EtKXHSS0+v+2ivb8LH41LwN/pwi9tNzpfffU5sbHxfPrpbE6fTuGFF6bx228rkUqv33XdNIL1ySefXLBcoVDwxhtv2EXqKtLGOZoYzxhOV5wG6mP3Ragi+PrE10B9LL4vj32Js8yZdh7teL3767yy+xV0Zl2Tdu5tfy+7Cnbh7ejN8dL6qTg/Jz/EIjGZ1ZkXHMPuwt0ARLpHkhyQzN7CpjHQRIh4KP4hlqQvaVb3QPEBhoQOoWdgT2oMNXx36jseSnjogv15Kj1xkDiwLmctw0KHE+90fd8w/0p+lZaX/jjN7symzi2jOgSQFOKORm9m+ZF8ukZ4svF0MZ9uSkcQINhDicpBhouDlFd+O0WYlzM923jy66EczhTVMvfejpwt1XB/jzAW7D3XYt9Gi5WtZ0pJjvRk75/955Rr2SyUc3/HwMt2eb9Z0JqtzcQKILWolmnLTjBvfNI/trROnjzOF198hlZbhyAIPPLIlGZ5q37++Uc2blyH2WxGKpXy7LP/Z0sb8vHHH3Dw4AFkMhkSiYRvvvkerVbLG2+8QkVFfYiydu3a89prbzbre/PmjSxd+gcAMTGxeHt7c+TIEbp27faPrumfcNMIlp3rj5Og4vnOz/P72d9Zlb0Ks9VMQV0BmeqmIqMxaThUcogeAT14NOFRaow1ZNdk4+ngSZBzENvzt3Ok9Ajv9HyH1/a8hqPUka5+XTFZTazNWdti3+Gu4RRqCm3ffz/7O+PajuOVbq+wMnMlFfoKEr0TifOK4/ezv7fq8FGhr2iSS0tv1uMsc241cO6gkEHUGuujYvyR9RsdOnSx5ee6nojFIsQSMfN3ZjcTK4A/jhXSxseZWH9XOoS4M2t9GhrDeaszr1LHzHVpTL8thqcHtSW3UkdhtY5hcX7U6s0czatGIRXj4SijoFrXrP0GdmSU8fTAtjbB8nSWs/JEIV3CPChS6whxVxLs6oDiX7i0lV2layZWDaQW1ZJdpSPW+/LT06jVap5/fhrvvfcBHTp0xGq1UlvbPELLsGG3Mn78vQCcOnWCt96azuLFy8nISOfgwQP88stSxGIxGk0tMpmMdetWExAQwOeff2Xrp3nf1ZjNZjw9zzsc+fsHUFLS8v+ra4VdsOxcNBrUvHfgPV7r9hpDwoZwpvIMXX274ih1bOa9B/BT6k9Mjp/Msoxl+Dj6oDfp8XPyo7t/d4aHD8dL6cU90ffQP7g/GdUZlGnLeCrpKb44+gVCowB+vo6+jG8/ng8OftCk/dSKVIaHDWd8u/H4OflRUFvAvJR5ZKuzWxy/VCzF39mfxxLr47IdKD7Ab2d/49lOz/Lu/ncxC02nEYeGDiWlIoUYzxjCXcOp1FciiK6vWBmsAufUBnZmltPWx5mf9+e2eu6aE0WEeTqSWlTTRKwa8/HGdO7tFspX2zLxdVXwcJ8IJiWH8svBPG7vFPS34/mrDnUJ80CtNbHxdAkL99VbZoPa+/LcoDZ4yi9vr9aNSpXWdMHy6r8p/ztOnTpBaGgoHTp0BEAsFqNSqZqdl55+hh9+mI9arUYikXDuXA56vZ7AwEAsFgtvv/0mnTp1pmfPXojFYuLi4lm06Gc+++xjkpI60r17j2Zt3qjYBcvORaM2VZFWlUaWOguNWYOAQEZVBne3u5vvTn3X7PwKfQVHS47yfu/3EQSB3YW7mXN8jm19ydPBk2mdp/HFsS9sXnpR7lE83fFpAGqNtXgpvRCLxJisJm6LvI0jJUdQSpWMbTsWnVnHgxsftIlbn8A+TGw/kRn7ZrQ4/jFtxrCvYB9rctYgFonpHdibxxIeQyFR8Hry65wqP8WxsmN4OHgwPHw4KRUpLE5bTJJPEsMjhiNBAlYR1ysarlYQOF5US3Z5HUqZBIlYjMHcuoDmVmpRKeVsPtN6jrAanRmFrF5ISmoMvLvmDF/ek8SZ4lqe6N+GtJJagtyV5Fe1bGX1jfJhX1a9dfVInwi+3p5Jh2AVvdp60sbHmU2pJWxKLcHLWc5/kkNxk4lv5OAhl4S744XXctz+pvxKYDKZePHF55g9+xtiYmKpq9MwcGAfTCYTLi4u/PzzEo4ePczhw4eYM+cL5syZR3x8IgsW/MLBg/vZtm0LX3/9FQsW/NIkNqtK5YZEIqGiotxmZRUVFeLr63/Vr+lC2AXLzkUjE8sRIaJCX4G7gztl2jJqjDV09+vO1tytZNc0tWzcFG7cEXUHRdoiUitSWZTWNBBxhb6CV3a9wgtdX+BE2QkEBNKr0smrzWNy3GR8nXzZlrcNhURBgncCrjJX2nm2o7tfdzaf28yOwqZehTsKduDr6Muk2EksOL2giTdgn8A+OMucWZK+hOSAZLr5dcNgMaA2qvFx8qG4rhitScugkEFkV2czY+8MzIIZH0cf3BRuFNcV082rM1br9RErjRWWHy/i6+1ZGP+cknxuSBRSsYgIbydGJgZgFQBBQC4Vsz6lhKxyDSrlpf0Xt1gF1p4qokuoO4sP5TJ1YBTujjJmrEptdq5CKmZ4vB97MyuYf39nitU6YgLCKVbr2Z5WjkUQuCXWj9s7BvHCshOMTPCnHGjj7vCvEK1wdyXt/V1ILWo+Tdfe34Vw93+WliY+PpG8vDyOHTvSZEqwsZVlNBowmUz4+tZvKfn11/P/x6qqqhCLxXTrlkzXrt05evQw2dnZf8Zk9WHQoCEkJ/dg2LBB6HRanJ2bOhQNGDCY5cuX8tBDj3L6dAplZaV07NjxH13TP8UuWHYuGk+pDwOCB5KpzuQu37tYn7Oe9Kp0ErwSGBk5EoPFwN7CvZisJvoF9yNSFUlObQ7V+mp+O/tbi20KCOwp2MM7Pd9hU94mtudtZ2rHqXxz4psmUTK25m2ls29nxrQZg7PcuZlY+Tr6MjRsKM4yZ2I9Y/F08ERvqV+fclO4cbDkIN+nfM8DsQ+QXZPNp0c+tdV1lbvyQtcXOF15mlXZ513cVQoVD8U/xLmac/g7+hMgC73mtpVegCKNgeP5NXyxpakX5abUUqYNjkKtN/HF5rM2IZOIRdzeKYjxXYPJrazj1nh/fmpl6tBVKcVgsjQ5tutsBZ/cmYjebKGizojeZOHjOxP5dkcWqcX1D+du4R7c1TkYJ7mYoXF+fLg+jdFJgXy3O4fMssYpXPIY1N6X6bfFUqYxklNRR4nGkVhfZ27s7dh/j6NUzEfjEpi27EQT0Wrv78JHtyf8Y4cLV1dX3n9/Fp999glabR1isZiHH36M3r3PR/1xcnLmkUemMHnyRFQqNwYPHmorKykp5r333sJsNmO1WklISKRHjx6sW7eGX375CbFYjMVi4YknpjYTK4DHH3+KN998jdtvH4VMJmP69Levq4cggEj4t7vyXAbl5dcvNJOXl8t16/9iKLHmMW3nM7zc9WXW5KxhTfYabgm7hd5BvXln3zt08u2EVCzlRNkJIt0ikYgldPDuwJzjc1pt00HiwPj240mtTGVo6FCWZyznRPmJFs+d2nEqBbUFLMmo9wIUIeKhhIfQGDWszl6N2qCmjVsbxrcbj0wsQyFRUKGv4P2D79PFrwsquYpNuZuatSsWifm8/+ekV6VTUFuAr5MvVsHKj6k/clf0XfT360uQIgKrcO322teYraSUaDhdWMPSI/n1G3P/5K4uwUR4OaE3WdCbrKgcZexIL2NPIweM/xsaTUqBmlEdApm25HiL61hPD2zLr4fyKFLrbceC3JVM6BrC++vr4zdGeDkxsXsoVVojcqmYUE9H3BxlrDtZQpiXI2eKaymsrt/ftTWt5enHl4e3A+DdNfVR+b2dFXw3qTP+DpJLCs10teI76vV6MjOz8PLyQy5XXFLdhn1Y1VoTbtdoH9a/CaPRQHl5MZGREX8bZs9+V+1cEn6SYD7p/TlOcic6+tRPD6zLWcf+wv1M6zyNE+Un2Jq3lQp9BW3c2pBZnYlEdOHFdieZE3qznr2FexGJRK2KFcCitEXEeMbYvk9oP4Htedv5+czPtmjvZ6vPMmPfDHJqcjhQfABXRf2G354BPdmcu7nFdq2Cld/O/kZaZRp+zn58e/Jb5p6Yi8akwcfRh4qDpzCqW18LutKIxSIyyrSsOVmMUi5pIlbPDo4ipVDNe2vP8MmmDOZsz2Tm2jP4qRwYmXB+jeGbHVnc0TmI73Zn88ldifRq42WLeB7i4ciLt7TjQE4lNToTikYP2OHx/szbdX56N6u8jjdXnUYmFfPfPed48pdjfLrpLCargMki8MexQnq08WRbeuv354fdOShl538HZRoDDy04TM0F1uBuFhylYmK9negZ6kast5NdrK4i9ilBO5eEIIC3OACxWITCU8EtYbewLmcdK7JWsK9oH1MSp+Akc0IhURDkEsSxsmOU6koJcg4iX5PfYptDw4ayJW8LACV1JRfsv1xbTqBLIFM7TsViteAoc8Q7wpvgsuBmltMPKT/wef/POVt9FjeFGwaLoYn34V85UXaCvkF9EQTBlrdLKpYS6RqBUZeORNncQ+tqUW20oJBL2HC6mJgAV0Si+nvfOdSdlMIaThXUNKuz/EgBzw6OwselklsT/PF0UqDWmbg/ORSACG8nuoR7IBWLiPR2Ys/ZcvpGeRMXoEImEaFSykgrqUUuFVNR1zy01g+7cxjXKYhvdmRx+FwVg9v7EurpiNkqYLEKF7SUCtV6avRNveaKa/RkV+pI+Aeu33b+t7ALlp3LwmoV8BeFc3/M/XT3786S9CWUakvZVbCLO6LuQIQIi9XCuLbj+PjwxzyZ9CSzDs1qFoEiyCUIdwd3iuuKAZCIJUhEEluurL9ye9TtHCw+yPxT85s4VST7J/NA7AN8n3I+I7VFsFCgKaCrf1cUUgV1prqWmrThqnBFa9Yi+tMMEYvEvNjlRQIcQnDo3wYklzZV9E8wCZBfrcUqwKGcSnpFelKtMzM6KZDX/zjVar3fjxbwzug43lx1mnEdgzhZUMP6lGK0RgtdwjwI93Li+9053JccSkpRDQv2NV3bmtAthLzK5lsUACrqjDgpzj8ysss1tPd3pl+UF0qZBLEIWvNJCXJXEubZXJgq64xgFyw7F4ldsOxcNoIg4Esovl5BdPPvRp1Bh6vEjSxNBo9ueQSxSMz7vd+nR0APFqQsYFqnaZwsP8newr04SB0YHDoYZ5mzLVIGwK6CXQwLH9ZifD8HiQMxnjG8vuf1ZmV7i/bipfSivUf7JulGqgxV/Jr2KwNDBmK0GPFWelOmazlH2sCQgezK30WYKoyxbcYyNGwowQ7hOFid4RpvIbIKAltSy+gR6UFCkIqYABV/HCvAaLa2KgpQP313uriGcR2D+ONYATkV58VnfUoxm1NLmDEqlkM5VRw+V92s/k/7c3lmUFsc5RK0xhZeGhqZURZBYOPpUuqMFuQSEcPi/Fh9srjFcU3qEYaTXIKzQoLGcL5dV4ebO3yRnWuLfbLVzj9GZJUQ5BKEJ35IzQ6EKiOZ0O5erIKV53c8z73t7uWpjk9xsvwkfko/Xun+CskByazNXstXx79qYnVpTVqGhA6hk2/TEEgiRLzQ5QUWnF7Q6jjW5qzlwfgHGd9uPK7y+nUrpVTJH5l/IBVLyajKYGqnqUjFzd/T4rzi0Jv13B51OynlKfQO7EOUIqFerK4DDhIR+7LKmTY4mpxyLVN+OsL6lBJ0ppYtzwYCVA7ojRZq9aYmYtWA2Sowe2smrsrWheK3owXcmtB8v427o6yJiIV7ObPoYB4Hc6p4c1UqCUFuxPg3DxA8NNaPtJJaimoMTEwOsx1XKWWEe/4z1287/1vYLSw7VxyF4MiEyPvp7tudZZlLMVqNvLnnTUJcQyjUFCKRSMhWZzezdFzlrtwedTs5NTn4OfrxTKdn0Jl0SMVSZGIZBquBs9WtB8g1W82crT7L5tzNPBD3ADXGGg4WH8QqWCnVlqI1a/Fy8GJWn1nsLdrLnsI9uMhc6BPUp37dTapgXfY6bo+6g1jnxOsaC89VJuGh3hFklGpYdfJ8OJyD2ZX0iPRs4g3YmDu7BFOjN7GmFUsHoKBah8cFgtPmVGgZ1SGw2fFJPcP58c/oFW19nCnXGDA3MvdmrjvDE/3bMLF7KKcK1bg5yvBzdWB7ehlLDuWTWlTDI30iAFDKJMy5tyOeCgnWm9/vws41wi5Ydq4KDoITsU4diU3qgFZUQ5BLkC3N/dnqs7za/VV6BfbiQNEB9BY9id6JuCncWJiykJ5BPVmdvZrV2asRi8S2taoJ7Sfg4eBBpb6y1X6lYikl2hI+O/IZL3R5gRVnV9iOx7vHkXLuCAl+SfQK6EWSdxKuCldkEhkWq4X0ynSe6/x/eBN43bcVCFaBEQl+vLg8pcnx7RllfDOxE7mV2mbRJ/pGeeMsl1KrN1PXSiimBqwXuEBfVwVK2fnJlxAPR+7tHsKm1FKqtUZuSwgg2t+FjzakNR2zAGtOFvHs4CjkEjGbU0sY1ymYnRn1QVZTi2pROch5rG8k/aO96RrhSXl58023NxsKSw2y6nTEukqsSg9MblEYJFc3Fc21SC/yww/zWbNmFXl5ucycOYu+fftftb4uFrtg2bm6WMQ4Wp24N+Ze3thTH0m/nUc7W9LERO9E7ml3D7+m/8qRkiP4OPpgspz3JmvsWLE+Zz0jIka0Oi2Y5JPEyfKTtu/zTs5jROQIlqQtwd/RH/P+HLTLtrLLuA7vdlEk/OcecnXFFNUVEqGKpK//QFwE9+sUeKk5epOVMo2+yTFBgLOlGkYk+OMol5JaVINCKqGdnwtnimswWKycKlDTOcyj1T1RcokYH5fWHUgmdAsh2N2R2eOTEASQS0UIgogHeoTx9MA2zN56lhXrC5vUcXeU8Vi/Npwt1fD26lQkYhGD2vsiE4sYkxTAooP5eDnLqdAaWHG8gHFJAf/8Bt0AOOtykP7+MKLSekcYCSD1jUM26hs0yrDrOrZ/Spcu3Rg8eChvv908kvv1wi5Ydq4+Yhmd3bsyps0Yfjv7G1bBikKiwGQ1cajkEEdKj3B39N30CexDfm0+8d7xLM1Y2qyZcl05UrGURO/EZhmCPR08uSXsFt4/+L7tWIW+AiepE08mPYlK4sKmNb/jGx5J30mPsOaz9zny6XeMfO41vNuOvCE3a8ulYqJ9XcirPG9JScUi6owW5m7PQiEVE+bphMli5fdjBQCM7hCIs0JKr7ZebE8vbdFB4/ZOQSik4hZjBPaL9sZJLmXn2XKkEjFHc6sorTXw0rB2LDucT99ob8SipoGVJGIRzwyO4v21Z6hrtMb1w54cfFwUvD06jkUH87mvexjvr01jXKdAPOQ3//K5wlLTRKwaEJWcQvrHwyjuWIJB8s+2QlzP9CKxsXH/aOxXA7tg2bkmKAUVD7ebwuCQIRwtO4Kn0pO9RfW5rKyClZ/P/IxYJMbfyZ++QX2Jco8ivSq9WTvb87dzf8z99Anqw/HS4+gsOhK9E5GL5Xx65NNmWZHburfFWeKMm9iPUS+8iUSmQKxUcevUlwEQKeojJygUUsxmAbP5wk4NVxuxWIRYLMJqFciv0nFrvD+bUs9bSmargOOfG3ANZitpJU2n1H4/VsB7Y+ofNNNvi+WLLWcpq61PUimTiLi3WyhxASpmrk3l9k7BBLor2ZVRjkIqZkisL2KRiAM5lezMKEdvstAj0pPbOwXx2aYM7ukaQoXGwMjEQHadPb+GNqi9D78fLWgiVg2U1hrYlFrC7R0DERBwlEsYHut73WIyXklk1enNxKoBUckpZNUZGDw7X3b71zO9yI2KXbDsXDMUVic85F7syNvBsIhhzUTJKlgp0BSws2AnTyc9zaqsVWw4twGLYEEiktA3uC/xXvG8secNHGWOTE+eTkFtAd+lfEeNsflG2gCnAPyU/viKg0AQI3P1sZVJnD2xSoyc0Z5g14Gd5NbkEuMZQ2ffLgQrwpBbHa/JPWnAIjJTbimkqK4QmViO3qKnWqRG6eLE/AeD+GBlJWkl9V5/GoMZDyd5/R6mvyAWgUIm4WhuFUNifPny7iROFamp1ZuRisWsPVXE78cKeGpgW8prDSjlYuKDVEjFItyUcp5fdqJJ/quVJ4rYcLqEl4a3p7BaS6SXM0sP5/F4/zZ8syMTk0UgNkDFxxubv1w08PvRQmaPTyKnQsundybio/h3PHbEutbXUi+m/O+wpxdpzr/jl2PnpkAsFrGncBdp1WmkH0nnkYRHSPJJYnXWajQmDUHOQYxqM4r0qnQe3/I4nXw68UKXFzBZTbjIXXBXuHO68jRTOkxBEARkIhldfbvx7alvm/UlQsQLnV/ETxzS4lSfTlzD2rxVrMhcQbRH/cL1Dyk/MP/kfN7u9Ta+jn4EykOQWi4c2+xKYBGZOV13lO352wlThbEqa1UTIZeKpDw35GU86MbZEgNuShkf35nI04uOodadX++TikU8OziK73ZlIxKJuLNzMM//JTBrAzPXnuHVW9sz7df6MFihno70iPRsMVmjwWxl4d5zjEkKwN1RRr9oH8QieGNkLJ5OchxkF96kZrRYUcol9G3jibvs5p8KbMCq9Ljg9jyr0uOqj+FqpRe5UbELlp1rhllkZP25dUB9lPa5J+YS6BzIg/EPEq4Kp7C2kC+Pf2mLSHG49DCHSw8D8Gr3V/n48MeU6cro5NOZCe3uJcIhCglSvh7wLT+eWcCG3A1YBSuJ3ok8Fj+FNsr2LYqVWCwiuy4TJ5kT49uNR21UU2OoIdE7kXJdOW/seYPnuzzPx2c/4vlOzxMkjbyq61tllgKOlh1FY9KwJXdLs6lQs2Bm5qEZfNhzDh9tUPPy8PZM+/UYj/ePRCmTkF6iwc1RhqNcgkwiYkB7H84U1ZJSWNOiWEHDdKKGAJUDhWo9Q2P9LpgMMrNMQ1sfZ44XqJm7PQvLn1N6YhHcnxzG3V2CWXQwr8W67f1cCHNz4NrFCbk2mNyikPrGISppPi0o+MZhcov6R+1f7/QiNyJ2wbJzzRCLJDhIm1osBZoCPj3yKaMiR5Hsn0y4KpxT5U0fAA/HP0xHr06EdwtHIpbi5+CP3OQMQn0qxQBJGP8X/woPxjyCgBVXiTsyq0OreRa1ohrEYhEak4bNuZsp1ZYSoYqgb3B9HMFxbcchIJBbk8vjWx9n3sDv8BJdHa82sVhEsaaIZenL+E/8f9hwbkOr567OWc6wuLvIrdRSUWfi3TVn6BTqzpikAPZnVdKrrRez1qdTpqlfs4oJuLBr9enCGtr4OFOo1uMgE6M1tu4K76qUUlJrYPbWzCbHrQJ8vyeH54dG4+2isK2XNebJgW3+dWIFYJC4Ihv1DdI/Hm4iWoJvHOZR3/xj1/brnV7ku+/m8dtvS6muruLddzOZNet9Fiz4BXd39390Xf8Ee3qRFrCnF7k0LmXce6q28ureV1osi/eM58WuL1KsLSa3NhcnqRNxHnFk1GQw5/gcW7zBrr5deSTxUSLl7S9r8b5clM/XJ75mc17zyO33xdxHgFMAaoOaOnMdC04v4NmOzzLS/46rspFYKhVzSL2HZ7c/y2OJj10wDYu/kz+jfT5kc0odh89VNSl7tE8Ee7IqOJF/fgF92pAoPtrQ+trSwPY+VGqMHM2rZkA7H2r1Jg7mVLV47uSeYaw+WUxxjb7Fcg8nOa/d2p4Xl5+0ZUF2UUh5bmg08QEuBP9lo/Ll/NZv1PQiCosaWXVGo31Ybf+xd+D/EpeSXsRuYdm5psS5JxDjEcPpytPNysZEjiVYEUGQNJIkp2QkEjGripbx4aEPm5x3oOQAp7acYvaA2YRKL33jZJ4mr0WxAvgx9Ude6PIC4W7hZKvrU2xsyN3AiMCxYLny6y9W6/m9Zi2FjGqMj9KX8horni1EqXB2kDURq9sSA4jydcFBJsbHxYEOwW4YLVaO51UR4OaIr6uCW2J9+XpH/TVuSyvltRExrQpWUqg783fntDq2yjoj5Rojj/dvgyAI+KuUFFTrkIpFmP7lkSwMEtU/8ga0c/H8e1ZA7dwUuOLJ291nMjXpGTwdPBGLxHTx7cL8wfORiCVMP/wKs1Le4WTdIYrMOa1aHFqzlpVZKxHLLu1pKJGI2Vmws9Vyq2BFY9RgsVpsebyUUiVi0dX5r2JAy56iPXTx60KZtgx/J386+3ZmUuwkxrcbj7/T+Zh+I8PuZlNKJR1Dm0/JmBvFN/pPzzDKNQY+35TB53cn0butFxmltXQN8+DB3hE4K6QYzQJlGiN3dAripWHt6B7hydLD+bxwSzTujufjDCqkYiZ2D0VvtCCTtJ7YXiwCrcnCxxvT+WRTBr8dLeBgTiWVWqPN4rJj559it7DsXHPc8GJ04J0MChiCGTM6q5ap25+iRHs+F9bKrJW80OUFNCZNq+1sztvMPZF34a53ROzkeVF9i0RQo2/uAt8Yq2DlZNlJyvX1GyvHRo7DeuFIR5eNgMCRkiOMbz+e9dnreaHLCyzLWMbitMUopUoGhw7Gx9GH1LIcNOogPr4rmO0ZZdyWGMCK4+ejTcgkYkQi8HVxQCQScfhcFS8Pb8/UxcfQmSy8PiKGudszKak5v8a0KbWEpGA3ukV4EOXrQmpRDRkltbw8vD3FNXqsVoEwLyf2Zpbz/Z4chsb6sepEUUuXQb9oH3ZlnI8NWWswEeXrgtFsxfFf5Blo5/piFyw71wWrVcARFRaxkZlH32kiVg3UGi8cZ06ECK26itq0VEKSuiJ2cPv7fs0mevonsyV/S6vnhLiG4Obgxq8HfiXeK54Y1dXb8e+AI7eG38q8E/N4ttOzTNs+zZYLTGfWsThtMX5O/rzRZRZikz+1ehPHzlUxKimQ3lFerD9VTEmNAbGofgNvmKczvx7K49YEf37en4vWaKFftDcbUkqaiFUDR/Oq6RjqzpqTRbw+IobVJ4v4v6VNMz6/NKwdiw7mc1tiAEdzq5u5vvu4KOjVxosZq85P83YMdicuSIVGb8LN4cZ3l7Zzc2AXLDvXlWJjIfuK97VYZrQacZW7trgpGGBI6BDOrdmGm7s3fze7LRKJMNeUoq2roZ1TJCqFCrWh+Q7/du7tUMlVfHfyOx7v8Dj9/AfhwtXbT2O1CvT270eduY5Pj37aYuLK4roiTlbt4c7ge9lfUIOPqwPPLTmBSAQdQ9zxcVWw5FA+Lw1vR16lDrXORLiXE8uP1Idr6hzqway/BKptzG9HCxiTFMius+WcLGh+T/ZnV9Ip1J2PNqTzaL8IzBaBnRnlWAWBXm28cJRLeH/dGdv5SpmE3lFenC3VEOrhiLtc+q+IbGHn+nPT2Opff/0148aNIykpieTkZKZMmUJWVlaTcyZOnEh0dHSTf6+/3jzZn53rj0gEZrEBkUhAKW05J9LKzJXc2/7eFstcZC4M8u2LqbaOhKEjEDu07kIsEokwVhWw8pN32Pbfb/Eyu/BO1MtEukY2Oa9HQA9m9HgLLwcfPur1KWMC70bFxU01/hN8JYF08e1i84JsicVpi9AIauRSMe38XPBxUSAIcPhcFZtTS8kqr+NUgRp3Rykqpcy2TwrA8jf5OyrrjLg4SCnXGFC1kCcrv0qLj4sCo8XK55vP8tP+XB7sHc7bo+Moq9XzyaYM2zpVkLuSL8cnUVZrIMzTkURfZ7tY2bli3DQW1oEDB5gwYQLx8fFYLBY+/vhjJk+ezOrVq3F0PB9G58477+Spp56yfVcq7QnibiREIhFF5nNsK9zClrwtKKVKnu74NFbByocHP0RotHmqRFtCbk0u7/d+n6+Of8W5mnOIRWL6BPZhfOSdpHy8gNryMgpSTuAXHYfIQfVnH6CvLEQilSN18cJaV8bRtSuI7t6LgyuW8ctrzyGRyZjxzDMUWSpQ6yoJDYwm3D0KUUNIJgGs1yhuuyDUJ8G8EFqzFqtgwUUuRyIRc3+PMEprDWxIKcZksdK7rTfdwz04UVDDhG4hiEQiFFJxvZCIRMgkIkyWlq8nwsuJgiodkd7OLXoJhnk6Uaw+786u1pkwma2YTWZeGRzJ+K4hlNQacJRJ8HVVoDNYiAh1w0Uqvqm2Z9i58blpBGv+/PlNvs+cOZPk5GRSUlLo0qWL7biDgwPe3t7Xenh2LpJs4xke3zoFnfn8OsjJ8pPEeMQws/dMXtj5QpPzu3l3Rlidypu9pqFztOLs6o6kQEPZjjMMe/xZ/vjwLfLPpOAXFWOrY9VVs/2Hr/EJj6Rdz75kHNpLTO/+aGvUKBydMGjrkEhlyHRw6svvQRBw6JpM8Agv5M5WBPm1zzLsrfTBQeKA3tLyPqfeAX1wErsS4CLm1yP5RPm64qyQMrF7KM4OUuQSMScLaxCLoJ2/CzvTyxnfLYTvd+ewIaWYkYkBtinCvzK2YxDzd2XxUO+IJqGeGugU6s57a89P+fWN8ibC25lQZwlWi4hQZzmhzo1c7eX14vu/IlZaQUOuNhu1UY1KriLEMRxH0dX9DV2LfFhvvfUGJ04cR6FQoFQ68swzzxETE3vV+rsYbpopwb/SELX4r8EgV65cSbdu3RgxYgQfffQROl3z2Gh/h0h0/f5d7/6v5rgNkjre2j+jiVg1cLryNNnqbPoE9bEdu73t7ewq2YtyaDza0+cIFwWgKhEoOX6KmJ59MZuMjH1pBomDh1FbVgwWQ/1YBCs97pyARCpFKpPRtksyMgclh1b9hkFbR0BUO4w6Lft//5VxL71Ju179yDx8EINOS11lCZi11/z+eUv9mBz3YIu/R4lIwj3R9yAWJCglIh7rHUFZrYFVJwrZnl7Gz/tz2Z9dQe82XgS4KdEaLBgtVga392FUhwBOF9Xg46KgR2TT6U2RCCb3CiOzTMP74xJYcaywWd/PDGpr8/5zVUp5uE8ETw9sQ6izDEEQXfPf+o1GibmAp3ZN4eHND/F/O5/j4c0P8dSuKZSYW345uJno23cAv/yylB9/XMz99z/Ayy8/f72HdGmRLvR6PadOncLNzY02bdo0KTMYDKxdu5bRo0df6TE2w2q18thjj1FTU8Mvv/xiO7548WICAgLw8fEhLS2NWbNmkZCQwJdffnnVx2Tn7zmQt5fJWx5utdzX0Zd3er7D4dLDOEgc2Jq3lWNlx3CWOfO600OYMovJP30Kg1bL2BffYNvC+fQZP4kt339dL14vTsc7NJyK/Dz2/76E1J1biOzcjZC4RMrzckGwovLxw2I2YzYaEKwCge1jkCkckCoUlOfl4uEfSFC7GETia/8uV6GrYFn6Mr49+a3N0vJz8uO1bq/TIzC5ycZii1XgXEUd1ToTzgopoZ6OKKQSavUm1qcUcyinih3pZfynVxgmi4DBbCXYwxGZWEROhRYBcFfKCPZQYhXg883pPDkgilq9ibSSWrycFcQHuuIpNVEryKkzCjgrJIR5O+GmbL5x+WbnciJdaAUNT+2a0mIanCj3KD7v9dU/trRay4fV2MK6WvmwGlNdXcWttw5l+/Y9SKVXdmLuqkS6yM7OZvLkyRQWFiISiejUqRMff/wxPj71KRtqa2t56aWXrolgvfnmm2RkZPDzzz83OX7XXXfZPkdHR+Pt7c2kSZPIzc0lJCTkotuvqLh+oZk8PV2uW/+Xy1/HLcGKpLwEQadD5OyC2dMHQQCttblbdWNqjDWojWq+PvF1k7xWGpMGc6grBau3YNDWcfurb1OSk0V5bg7Zx4+gr9PQ6577ETu514f6QUz73v3QqivJPLSfuuoquo+9C5FYTObBA/hGROKocqM4+ywbv/mSUc+9yspP3mPY48/i4OJKZZUGQbj013lBV43VakXqqMJirEMwm5E5q7AKF+vWLef2kHvo7tuPorpirFYJUqsPW48ZqCovITHABedGm3dVYogIcaeiopbaai0NmwB6h7oR7eNM5zB3dEYLP+/PIau8zlZPLAKFVMKsOxJwdpDiIJXwSjdXwl1NiHxU9A1zRRBECAKIRTLcBDE41dc11xkor7vw3/FiuJzfekOdG4VcbXaLYgWQXpVOrjabdk7xl93+jZQPa/HiX+jRo+cVF6tL5aJ7nzVrFm3btmXp0qXU1tby7rvvcs8997Bw4UICAq5duusZM2awbds2fvzxR/z8/C54bmJiIgDnzp27JMEShOs7/369+79cBAEUFcXU/LiQmt9/B5MJsYsL7g8+iCi5Ox7ebkhFUsxCy7twYz1j0Zv1zZIwAugx0n3c3cgcHNi1aAG9x0+i9/hJZB89RK+778MrKKTeG00EFrMRiVRKRV599PDis+lYrVYclI6Exiey4+fv6T3+AUQC9LhzAkfXrWDII08jkkhQlxShdNYgdVAidvK66Gs3qUs4sWEV+amnGP7ENHJOHuPYupWMeOZFpAolMtWFf6sAYjEU1lnYfVbMtzsNVNYZkYrVDIn1paTWwMdbSnm2XyRO0qZi+tffixjwc5DiEazibKWOt0bHcSJfzW9H89GZLAxu78vQWD/8HEVkbfwN/87dkZlrEcnDEASwWM63bxGurqV5s/7WAdTGCz/o1Ua1TegvhxslH9batavZvHkjc+bMu/yLuUJc9K/x6NGjPPvss3h4eBAaGsrcuXPp1asXEyZMIC+v5bQCVxJBEJgxYwYbN27kv//9L8HBwX9bJzU1FcDuhHGNkKsrKJn6NDVLloCpfvHeWltLxSefoP/xR5yLjYxqM6rV+kPDhnKi/ESLZdJaM9lHD+Hq5UNRRhorP36PlG2byE89RU15KYdW/45FU4FIBHK5nJOb19N7/CQmfvAFMf0GIVis/DrjZSqLC+k4fDRrv5yFyWhAJBYT23cQ6rJiUndtxcHJiYwDe0jftxOxqQaRQY1grGtxTA2IRGA26vEKCUVdVsKvM15i75KfcPPzpzgjjXWzZ4GxecQOkQjqrAKZaj0ZlRpKq2v49VA+769LsyVnNFsF1pwsZsHeHEI8HUkpbT3yx1+Ri0REeSpRiCHYzYHnhkTxwbgE7usSQKSrHCepjPhBI1F4heDVNhHhKoWf+reikl84wO3flV8JGvJhPfnkM/z88xLmzp1nO+7sXJ8Pa+jQWzh3Lod7772LvLxcWz6s2Ng4tm3bwgMP3IvF0nKm7Y0b1zN//jd8/vlXeHpe/S0ef8dF/0L1en0Tc1AkEvHmm2/Sv39/7r33XnJycq7G+Gy8+eabrFixgo8++ggnJyfKysooKytDr6+f68/NzWX27NmcOnWK/Px8Nm/ezAsvvECXLl1o167dVR3bvxazHov2z6ypFhNWbeUFF77NKacwZWe3WKZZsRJZYSl3hI1hcOjgJmVKqZIpiVNwljmzMnNls7rBzkG4VouI6TOATfNm0+vu+9Cqq6kszCdh8DC8QsKI7NQNkViEtiSbkuxMut42Dmd3D8rPZZM46BbkSiU+YRHsXrSArT98jUzhgG9EG6xmCzVlpRzfsAa/yChqykqpU1cTGt8Bo7aOLfNnU3ku/YKiJQjg6BNKYPs4gmMTsJjrLciOw25j77LF9L5nEvzFarQCx0rquPeHQ9w97wDjvz/CniIjC/efa7GP/Kp6R5UVxwsRXSCm31+RIiLURUH3IFc6+rrQxlWBk0Rqs2yEP/fA3axWzvUkxDGcKPeWc15FuUcR4hj+j9pvnA8L6tfu/zp993f5sHQ6Hd26JfPYY0/g7x9AdnY2hYUFODo6MmjQEKZNe568vFx0Om2z/jdt2sDXX3/FF1/Mwc/Pv1n59eCipwQjIiI4efIkkZFNN1s2bMx97LHHruzI/kKDc8XEiRObHH/vvfcYO3YsMpmMvXv3smDBArRaLf7+/gwZMoQpU6Zc1XH9WxHMelK3rCJt93ZGTnuF/NRT7F++iNHPv4HCs2XrVrNuzQXbdKjVkL5+H1OGPsTI0FvJ0uQgFonxV/rhUielskaN+S9B+wKcApjm9xDpC37Dc+xdxA0cSsaeXbbyswf2EtOrH/lpqTir3Vn23htEd++FSd+BzfPn0LZrMrH9BrLrl4XE9B1AaXZ9PqfILt3xCgph6TuvYajT0GXU7WxfMB/BamXg5MdYN/sTJDIZ1cWFRHTqipt/HWJEiOSOTcYnEomoQ43epEZbVUJZThZObu7UqavZ+csC+k78D7XlZZzatone9z2CIKkXiPRKHQ/9eLiJUGj0pgsKx77MCqJ9XbBYL929t75duypdSRxFzryT/B6v7H2pyVpWlHsU7yS/948dLq53Pqw33ngVT09Pnn/+WduxL7+ci0rl9o+u659w0V6CX3/9NYcOHeLbb5unIweYPn06ixYt4syZMy2W30zY82GBRCxQeGI/G77+ArFEjMVsxiskjOTb78E7Mgaz0Njarh937pQnqNvSctoOAK/pb3C0ppzgmDi2LZiHV3RbJA4KhFodQe3ikDsq0bqLqXY1ozHVIVOb8NQq8ZJ7sOHrL/BvE0W3sXey/L3pdB93DzKFgl2LFtBp+CiKzqbTddTtpOzYTPreekFTurgy5NGnObl5HeFJXdj232+QKhQ4uXlQWZBHr7vvwz8qmvVzPqemrASxRMKwJ59DXVrCrp9/AKDD0BHE9h3Iz69Oo/PIccQMHoXwZ2L0OqrZU7aLeae+pUxXhq+jL/eG3Eknx1jqMvJJ2b6ZxMHDOL1jC4MmT0HhGYiACJPZwJO/pXHoXHWT+/PM4Cg+2dh6/qrOoe6MTgpgWFsvrFbhhvq9XCqXM/aGOleDf5IP63rsw/o3cSleghf9ovbII4+0KlZQL1j/BrGyU4/FKsI/OpbQxCTbFFfyuLtx8fZtIlaNcb51+IXb9PKkw5BhlOZkYdTpSOw9hIRu/RCJxPiERmDQ1BHoEEicMZQuxjbESSKJCk/g0MrfGDj5MXrdcx+H16xk5LMv0aZrMuV55xj+5HPUlJcRGt+B0nM5tOnc3dafT1gEddWVSOUKzEYDXiFhjJz6Eh2H3UZQTDzuAUEcXbeKLreNReniiiAISGVyzp04amsj68gB1KUldBtzJ1Hde9nESi+q48uUz3jv4LuU6er3KZVoS/jozBcsLF2Oa5tQhj3xLNoaNTF9BqBQeSAgQl9RQHFlTTOxAlD8GXG9NXpEehLj63rZoY6kUkmLn+38MxxFzrRziqebey/aOcXbxeoqYl9ltdMyVhNZRw6Qc+wwjio3RCIx2xbMQ7C0HpdO2i4GeSvrha533E6pXoumsoqgmDiGPvY0CqWSlK2bCE/syL7fFuPs4YlOXc2WH+YiAAonJ4w6Pb0n3I+bXwA15WW06dwNuYMSs9FAaU4Wqz/7gPR9uzDodXiHhLDuq09RurgSFBPHuZPHKMpII3HIrUgdlER27obZZGTL93MJiGrH4TV/cPbAXmoryul3/4MolI6s/vwDYvsOpNfd99F/0sPUlJehLi3GIyiYDXM/w1JXH7ooT5fN+nPrW7zWtfkbyNGeoyTrLG6+AcgdlJScPQ1mPWaDAb26CnELwrQptYRxHYNabDPIXUlyhCfBzs1j/V0MFk0ZxSkHEQxqrNpKilMOYq2ruKy27Ni5Xtw0oZnsXDoiEfVebnJXBESIjWoEmTMiyfno2SKRqMXU7xKxCAQr3qHhdB45Fr1Gw5E1v6NVV+Lh5o3lLz8ds8lEjVmH98yZ1P3+O+pffkEwGJB4eKAcfw9lfl5sXvgt8QOG4t82mqrCAkISOmCxWDDr9CTFdsApPROrpo7+nXvjgAh1bS1Wi5misxl4h0egUCrJOX6EorPpWC1mKvLOkXzHeIoz0jm8cjnhCR2J7NSV+IFDKc87h6uXb32UC6UDPiGhIApFsELfiZPZ+sM3ACQNHYFvRFv2/Pojtzw+jbrqSjz8A/EKCuHsoX2MeOr/yD5+hJ0//4DKzx/BakYsFnGw5OAF732OpJTitacY8siT7F22CF1tDcOejMIlMBJzYRbDY31Ydaq0SZ1D56oIcnfk6YFt+Gl/LuUaIzKJiFGJAdwRqyKESkQi/0ue/pNJBDKPHGD3rz+SdMsIzCYTJzevp999DxLZYxAm8002n2jnfxa7YN2EiMUiZFVlCOpqRAoHLD7+mEVNp3hEIjBU5FNVVIBHYL2ThLqkCJWPHzqNBqlMitzRCb2mrr49hQK5RyCCAEptNZSX0T4onJAHorHK5UhkClTePji4qLCKZCAIiMw6m5dZUfoZfn3rZRIHD6fN8KHoAn3w8PLF0d+fpV99hHZnNSFxiQREt8diNhEzYBgIAl2H3opkz36qv5yNptGT2NK2LdJHHsSgcuH4xjUonJwY/X+vgiDgGRiEm68/gdExOLm5E9mpG227JiMg0K5nX7b88DXOKg8C2sew+9cfiR8wlIK0VIJj49HVVJNxYK+tnzN7dxLZuTsmowEnN3dMRgNrv/qYQQ8+jrO7B4fXrqIovT7P0/DHpyFzrd8iYfibTdB1ulpGPPQEZbk55J8+xYD/PAYyRwzqUnRlxYwKdqNK54m3iwPlGgN7syqwWAVWnShk4cQEYjVaXCNjcXZ0QFSSzb6vZ+P38BPIBAG4tE3NJouIsKTOZB8/wtF1qwAIie9AYEyCXazs3FTYpwRvMuR1NVh//5Wi8XdTOGE8BXeMQ/PW6ziU5jc5TzDUsvvXhez59Sc0FeUc+H0JW77/GovZhMVkYNm7r7N70ULUxQX8/sEMdv3yX6SacuSHd1P6xOPkTZhA3vgJGD75HJeKKiROHrgFR6LwDEIQBIxVRaz7/F2sdRWIjbUYdFriB97C8Q2rWfbOq+zZtgFJeDjHDu9Dq64GoLqkGKvFQuqu7fWWlb4Occ45qr/4splftTEjA/HipTjI5Ax97GlUPr5UFhWQumsbKds3cXjN7xxcsZTyvByyDu/nwIplGOrqUJcWE9Qulna9+4Ig4NcmCp+wCExGA1KZFEdXN0qzM+l062j6T3oYQ52G3JTjuHh4seaLD9GUl6IuKUGnViMSiylKP20L07T715+waNVYrQKdvDtf8O8Up2qPVl3FyS0bcFSpCIiKRiSRIRIsKL39scidUCllHMurwmIVmDY4imcHtWH2Lb4Ur/4viR3iCBBp2PPJa8hkEkY++zJOPmEIlyhWDYgkMtz9z7smu/sFIJa1HGJJLBahNlnJrTVSojcj3IhB/Oz8T3JJsQT/V7hRvQSlVjP6eXOoXriweZm3N37fzkPv+edDSV9N3qmjbP3vtzYxaN+7P11GjqO6rJjMg/tI2bYJALlSychnX8YtM4eil15uPi5HR4K/+QZtaP2eExECFVmnoKgQH6UzptQzGHNykIeFYW0XxZlzmYQFhuLq6ExxUT41MgluwSGIgPwzKYTGJ+Hi5Y1Vp0M/80P0+/e3ek+8v/2ao2knOXf8CMl3jKc8N4dDK39DpnCg8/0TULUJozQ9ncxVmxg25VkM2jqOrVtF9rFDeAWH0ufe/2A2mbCaTeSfOY1PWDgKpRPHNqwmLLEjge1iKExPRSpXIJFKEawCFosZvaaW6pIiCtNSGTR5CnmnT3JyywbGvDgDuZsvtZYKnts7jbTq5okRY9zbMz36/1j7xlsMfvgJ9i79BY+gIHrddR9nDu7jXEB33ljT3BtwUo9QHujgBupyDq/+neyjhwBwVLlx2/+9gdytabSMi/W0k0kE0nasZ9cv/yWofTxWi5nC9FT6T3qYiO4DmlhZdRYr2zIr+HxLJpV1RiRiESPi/Xi4Vzg+DlduQubf5CVo559xVWIJNiYnJ4f9+/dTUVGB9S/J4Z544onLadLORSApKaD6xx9bLDOXlWHcsxvp0KGIJXJQq4kMa0tZ7wEExSVQnJlBSFwCJpMBmVyJX0Qbm2C5+QXiJVNQ9PEnLbYtaLWULFtE/sMj8HcKxk3kTYCjCpMmm5LXZiCYmqakiH3qKTQ/LKTk1ClEIhGBAwciuSuIcqOO2D4DKUg7TVlOFmGRUZgyMy94zYJazYlN6whqH4dHQDBndu8gqFtnhORQ3imcR+62XJRSJWNHj6BcpKY65TTZx+of9EEx8ZzZs4O2XZPRqtVIJGJ0ajVpu3egqapk588/0Oue+8g/c5q4voOpLMjl9I4tdB1zJ44qN8wmEwP/8xjOnl6EJnQkJD4JuZMSU3Ux1NXyXve3mX/mB9aeW4tVsCIRSRgeMoz+hjhSlq6gx50TcHRVEdt3AGajEW1NNUJge97feJY7u3oQ5qfFghEsrqw5YuKHPeeIDbXgZs6h2533kHzHeHQ19et4IsGCCOGyLCyTRURIXGK9i37/ISBYObV1A/5R7W1iJRjrECud+Gl/Ad/uOr/522IV+ON4EQeyq/j+vk54KuzehTcC1yq9yJkzqYjFYqRSKVOmPEmXLt2uWn8XwyUL1q+//sr06dNxd3fHy8sLUaPpApFIZBesq4glO6veWpJKcezUEbGjE4b0dEwF9akMdKdOooqKQnfqJCKzGateT6LFgkQkRePsQs6Jo0R164lEImH7j98jVyoJjI4l+9ghjNk5mMvKWu3buHoDeUODeKvsbT7r8RF+J05S+vHHzcQKoPzzz/H5v+fQnzoFgoBm0yZkuedwf/H/+OW1/6PX3RMpPZdNRGwCsoAALOXlrfYrdnZmzPOvUZGfR3FmOrU1ldSNbsvcMx/bztGZdfyUu4T91Ud4yGkEQe3jaNerL1KZnIMrlnH2wB4CotuTc+wIYR060vOe+6irquToupXIHZR0GnYbe5b+QkzvflSXFHFy83radk1G5e2DXlOLpqoSqVyOZ2AIZZkZODg5s/m7uQx8cApPBE1ilPsgao21OEudCFIGkLp1M1K5nJC4RJa++zo9br8Hj0B3zGYLNUpfXh5bx6/ZM1mbUZ8xWy6WM7Lj3XSq7sG+DC0Zku/4j8N9CKtT6DrqDgrTUtmxcD7Dnn4BqUt9sGnBoMFs1IGXC4JJj1lXg8zVp1VrRaryp9Ntd2IS6r0MO4+62/bZaqilpvAclY6+zN/dcqSSoho9B85VMDxShdWkQ+TghkQwYNbVoq/T4ujujQjQVJagdPNGJP8HQfRuMqTaWqznsrFWVyN2c0McGo7Z8cYJ0nu5TJ36HC4u9deRlnaGJ598lHXrtiC+DpkMGrhkwZozZw5Tp07l4YdbTxNh5/Jw0FRRe+oI4sICRDI5stBQ8PXDKoBVBBaTEdWY0chDQ6nbfwBzaQlOvXohDwmm+rffUY0cif74MWqW/4apoACxSoXqtpFw4hTRwcHoAt2RObug02i4/YEpuEhkiB0UmAbcglhdc+HBCQIiRBRri5l1/GPe8RyLoG0ezqUBU2kpTr16UberfhOvKT0Dac45bpkyFbmDEt/IKOp0WtzunYD++ZbjB8rbtEEUGMiubz+nsiCfsa+8ReLk8Tywp+WoKmdrMtF1dqW9sjeBTiosGWcZ6heOoV0HapwcMGp1RCf3IWXrRhycXfAOjWDnz/9F4eTE8Cf/D6vZTLuefQlL7Mjm+XMQiUV0H3s3u3/9EYWjE6Off430vbsISeiAuqyENZ9/WL+ep9My+vnXSd+3i83pv5EwaCjluefIPHyA0dNeIf3AHgLbx4FgxUmo4O39zzVJ1Gi0GlmWtYBhIXV4SEehtCh55+j7fN7zbUpzahCIIH7w4xg0cqQOBiRSOLh6KRn7d3Hn9PdJ3bWNY2tWMO61d1F4BLb+NxFkzT6LEBCZDZTlZHHWRcyFtngtO1pEvCGb6vxs4voNJuvEUUpzsmjbNZmcowdxUrmxbeE8uo29m/YDRmL9H1gilxXnU/riCxjSzk8NK6Kj8Zn5Pia/lrcoXAqtpRdpzNVKL9IgVgAazcXHsLyaXLJgqdVqhg0bdjXG8j+NY2keZTPfQ3fw0PmDMhneTz+NvG0balesxPP++9Bu3UbZF18i9fFBMJnQpyxGJJcT/P13qH/7HfXSpbbqVrWaqoU/4hAXh9vt49B+twjfl19Cv2QJNWvWUmO1gkSCy+DBuN83EYmnJ5aKlvfmiAf3ZV3NPgAOlh2mOPYOLjTbbMzKxrl3b0QyKZqt2wCQF5awce9WAqLaE9tnAOu++oQew0fhOXo0mt9/b1Jf4u6O5xuvc+LAHnqPfwCjVotYIqYMNY9FjiNR6gqClSyMfHNuLRX6+nEfLz1KX00nSp99HhpNVyucnen/9ps4eYuJkCuxYkXin0hQu/Zs+f4bJFIJJVkZpO3ZSeGZ0/Qefz/bFszn9I4tuPsFMuCBRyg+m0FgbALFWRl0G3Mn+5bVx20b8MCjKF1VOLl7EN9/CFWFhQTFJmA2GFjy9iv0n/QIpVlnObR6OeV3R7eaVXh93m+81/0WVh/KY1TAOLQ5ARzZWQY0vBhUENPLD7/wOuL6DcI7NIzMg/tQefkQFJ+IwkUFJgGrWUAsFyOSXjhGoGDSYdaq+W3mG4x+/nXO5bU8rgbEIhEVBXkcX/0HhWdSKc5MxzMohJg+Azi+cTVGnQ43P3/adO31PyFWUm1tM7ECMKSlUfriC3h/NfcfWVo3QnqR2bM/Z8uWTdTW1vDeex9eV+sKLkOwbrnlFnbt2sU999xzNcbzP4nCVEflV7ObiJXE3R23u+9CHhKCKTcPh/btMKSlIQsMxPupJzGey0Xs4IDU3x/96dNgtiDz98P7qafQnTqFZvt2+DMCs/7UKSyDB+P54GRK3nkHY3rG+c4tFmrXrcOYnY3/22+R/1jz2IsihYKKEd04mve+7ZhGbLqgYMlDQ6iYPx/3e+5Be+gw1tpaUMjxj4zi3PEjZB3ej9loQubphezee/Ac0A/9jp2I6upw6NaNSgcZRi8Pwhw7YdDWodXUUJxxmh6dPBlyYDGo6zMEdHfyok+PKbxfk8K20oOMpgNlr73e7Elt1Wiomf4WHi+NQH70gz9vshz/7s8zYMK96DS1GHU6HN3cGDD5UcwGI96h9UF1pXIFZpMRq9WCSacjtnd/Vn72Id3H3Y1Bq2Xf8kXc9uxLuHh6IVgseAaFIHdwxN3PH3f/ALYvnE9Uci8Cu3ZiWeGKVu+ZVbCisRYhl8jpph/EmZ3Np2hP7ypGpvAgfd9vSCQS0vbupPPIMfS841HOHddybGMGBq0ZF08HOg8PwzvCpcX/5YJZz5nt60jbvY2R016hpqyUQCcVYhGtWllj472JDfQmfftGijPTkSoUDH74CQpSUzD+mdk7JK4DEll9h4KuCkQSRA6uzdoSiUTkVmpJLdJQqzfj7iQj3F2Ji/TmETrruexmYtWAIS0N67lsaJ9w2e3fCOlFHn/8KR5//CkOHNjPl19+xjfffI9Mdnmb168ElyxYoaGhfPbZZxw/fpyoqKhmCb3uu+++Kza4/xVE53LQbNlq+65o3x630aMROSgoeuklxCoV3k88gWAxU7dzB8bsHNu5yk6dcL11OCUffIBjxyQkKhXKxASc+/ej/PMvbOtSuuPHcPH1bSpWjTCkpWEqKsL//ZmUf/6FbV1M2iUJ9QMjeLnsm/PjRYSbgzsSNzcs1dXNG5NIkPn5Yy4tpWrJElQjR1L1yy84detG98pK4vUCiogIFN7eiIxmhOoaKuRSduurcAv0p2DTCixmMwM9PfAKDqMoPRW5oxOdE/xwWnZ/UzGqKydo4wyeHzqDErMGz4OZaFsxKyzV1Rh0bticuS1GnHa/TcBt86l09KdN5654h4WjdHVjyVsv0/fe/7B/+a/UVVcR238Qp7dvRuHkjH/bdiQOGkb20YM4ubnTf9LD7P/tV3SaWsKTOnN07UrGvPA6tWVlRCf3wcHFhfzUU7TrOAiHtA3NxuWucOfuoHsJEMII0gXyTuwszi1rOWcYwJl9NUR1iuLgHz8Q3qEzIfE92L30HMVZ56dtaiv0bF14hoQBQbTr599s65ZYIscrOJSD5WUYtXVUFRWQc3QFDydPZO6efP5KkJuCUGs5BWdK0dXWTx+bDQbS9+3Gv00UnoFBKJxdObFpLc7uHrRN7s3+5b8Q2C6GgNgkpI5uts3qYrGI0xVanvjlGGrd+TXQAJUDs+9JIsjp+j0QLwVrS7/9JuV/nxjxn9KQXmT27G+IiYmlrk7DwIF9MJlMuLjUpxc5evQwhw8fYs6cL5gzZ54tvcjBg/vZtm0LX3/9FQsW/IJE0rpDTdeu3fjoo/fJzMygXbuYq35drXHJgrV48WIcHR05cOAABw4caFImEonsgnUZWMrKQBBwnzABedu2YLUg8w+g6NVXsdbV4T5xImZNLRiNqG4bhWAxI5JIqTt0CKfOnTGezcQ5ORn1H39gLitD6ueHasxofF9/jYInnwJA7KpCd6LltaIGDGfO4BAbi//HH1GuKydFk8F202nW53+ARTifL2dQ8EACHPyRvPwSJe+8i7XxlIJMhs/TT1P959SkubAQiYc7/rM+pOL99zGknMb7qafQbtxE1c6dtmqKqCgGPzmFZT/Nx6jTMuTRp8k+fgQ3X392//ojHfr3RZm7rtU5ruA9c3h4+Az4bd0Fr9FcawCRuEm6D8WhOcj7fsL6b75k0INT0Gs09Bk/Cc+gEIZOeYaVH7/DqS0bkMoVDHv8WRROToQlJKGrVXN8wxryTp+i9z33IZHLKcs9x+j/ew2xRIoggrMH9xKV3BulsyunVq9mZM8hfFx9/qWhk0dn7nd+gpwVOgpqjBRQgtJFRkL/YHJPV1B0tvlDz1BnRu5Q/6Zt1Oswm1wpzipq8XpPbMknPMkLhVtTERBEYnyjE4hI6sL6rz5h5HOvYNLr6RWnItDNgS935VFSY0AuETMuyZ+7490R5Z3m0Ka1eAaFMOyJZ8k8dByz0YSrtx/97n8YuaMTh1ctx8XLm50/f4dBU0dpThYB7ROoOHsSV79AJI7uFNaZeGjhYfSmph7GhWo9D/90hJ8f6IKb7Ma3tMRubn9TrqL1QGZ/T+P0Io2nBBtbWX+XXkQsFtOtWzJdu3bn6NHDZGdnI5FI8Pb2YdCgISQn92DYsEHodNomEdvNZhNFRUUEB9cnvk1JOUVVVSUBAf98Xe6fcMmCtWXLlqsxjv9pJJ6eBH01m4r/LkCzbRuutw5HonLD/Z670WzbjljlijwwkLJZs85bV1IpqjFjkHh7YSwsQCJT4XbXnVg1GtQrV1ExZy6uw4fhft99VC1YgGPXLhhOp15wHCK5HItGQ+XZdA4UnCG3s4I1GVubnDMgeAAPxT3IoRMH8fDxJObbb9Dt3oO5sgKJSoVIKqVq0SJM+fkoO3XCeUB/ZGFh1P6xAkPKaVSjR1G7bRv6v4inIT0d06tv0O+pKWxY8SsnN6+n1z33UZabwy1TnsHbyYJ4xYzWB19bRHfHYGqjo9Hu2dvqaVIXebPcVJLiY0itWsx6HSs/mYm2ugpXbx9uffoF8k+fxGysT6ZoMZmoKMgjqF0c2ppq4gcMJXXnNnrdPZH9vy/503X8VtZ/9SlOHp50HjGGmN4DCIyN49SWDbTt2oMasYE2qkjOqjNxkDhwv9sUTv/UVJR0tSb2r8iix9hIyvM0mAxNk+uJJSKcPVR0GHorhelnyDzSuncnQHWJDt+/CBYWE9mHd5J15ACOKjeWzHiFTsNvQ1RTQc1/Z/HOyPEo/EOoLczDSXec8r16whM7MfihJxFL3Mg9XUfWiQBMRgtmi4mIJG/EUgMdbhmJUacjeew9WCxmasvLMdTWoHBUcuj3RfSc8CAHsyuaiVUDZbUGMiu0dPK78QPIikPDUURHtzgtqIiORhwa/o8E63qmFzGbzcyY8QZ1dRokEgkODkreffcDXF2bT+9eS/7RTsCGPcci+074v0VmNiAqzMNaWYnIyQlRcChGB2ekggWrppbaNWtxiIyEqLZU/fQz1ro6kEpxGTgQh6go8h9/AkHfaFHcbEa9ZAmC0YAiPJzyOXNtsfvcxo3FXFGJevlyAmZ9SK2/P+bycmR/k6VZ5udf74QRG4dm9xZ81S580OdlKlwNmLDQ3i2KY+oUJm96iFpTLSqFigmhdzLA3x1++AGrVmvLNKwaNQrkMspmfYT3009Ru3EjAIo2bVH//keL/VvVavzNAuP/8zj6yipcjRaco9pTXlyATlMCYglYW86MCqAvKcMU077VcrGrKwrH5ovWOHqCVEHf+x5CXVLEsQ1r6Hffg4glcvYvX4zCyZmhU55l4zefs3fJz9z5xnvkp6ZQvmE1Rp0WdWkJ/m2jSd25ldSd9QKfOGQ4+5b9goOzK14hoWTs30PKts2EJiTxSNxoMttWY7SKKdjYfFtAAyk7C4nq6kvKzsImx9t29sQ3XIXcIYGA6Biyjl94563VbEUkasE4FYnwCW/D0CnPUp6bTfrencQNHErX0XcQHBeHROnMubIsfKM7su6rTzm2diW97nmSjENq1OXnQ1Ol7ikl7UAZvW73IvfUejrfOoYNX3+OTKGg/wOPkn3kAAVnTtPz7vswadQcPFd5wfHmVmrp7O98w6dMMTu64DPz/da9BK+Aa3tcXALffvt9s+O//77a9nnixElMnDjJ9v3ee+8H6r3//vvfn5vVHTFiFCNGtJ75G8DBQdliv9eby7K7f//9d0aOHElCQgIJCQmMHDmS3//i5fW/iFgk4FBZjCLrDIqSPKR/JiN0qCymZvqr1C1bgjk9DdORQxjXrMAxNx1ZdhoSVxWC0YCpuJiqhT/WixWA2Yw+NZXajZuailUjalasBIkUwVD/ALFUVlLx7TwEvR7H5GSMOTl4PfoIFV/NQbBacBk6tMV2nPv3x6LXIY+OxqBQIJZIKDl1mtNf/URklgMdLBF8n76Q2cdnU2uqf+irDWq+Sv+Wr5z2w22DbWIl8fJCFh6OeslSEAQEs7n+aSkSYW0hs2lj6rZtx9FsRXk2E81332P+7Q/8LCIkHmEYI29ttZ7VL4HMrFJ27tqMz/Q3+GueDpGjI0GvP4b8zDfN6mpiJlJSUs262R9zcMUyBjzwMIVpqVjMBm59+gVGPT8dVXA0t017jduefZnis2kExyYgkcqI6TMAlbcvHYaMsLXn5hdASFwHfMIiyD56kFWfvc/A/zyK1WIm++hBCjbuYZTbIIY7DkVd0rpnnrpMh6OqadQFlbeS2N6+5Jw4jNxRSdqeXXgFXvjJ7qA0oq8obHpLJDJCO/ViyOPPoVWKKQw0saNLJS+lzOBsGwPVzmaQOBCa2BmxRErynRPoO3Eygji8iVjZ7r9Z4PiWWuQKN3588WlKszMJiU8iZetGdi/+EW1NDSadlhUfvUOQ64UjSXg4yW94sWrA5BeE91dzCfjuO/w+/oSA777D+6u5V8Sl3U5zLtnC+v777/nss8+YMGECU6dOBeDw4cNMnz6d6upqJk2adIWHeHPgUFWCdvkyyv6MUo5IhPOgQXg88gjlc+bg0rsX1cuWIxgMSH19sdTUolc6oggLQ3fiOMqOnSj76KNm7boOG2azTlpEEBD0umaHa9aswXvaNKx1dVi0OvzefgtpTCzy/oNQdkyicv58zKVlSH19UY0ehcTXD0v3BM6iRleXQfydozAVVHNm1zb2/Pojnd99hj0pLU+1bSnczj13f0mAgwrT5q24jh5F1Q//tZWLGhxzBAGR5MI/OYmLM5Xf/1C/6Rhg40ZE8+bh/8H7GOLvR567FQx/sZIkMmo6TqUupRyFqyu5zg44vvEKyuIyrCUliCPC8erWAcdtj4C26du9NaAzmXXebPrvR4glUnpPeIANX39BXP8hmHRaNn8/hxHPvIpgNaOvqcZRpUIik2My6HF290Rfp0GmVLLl+7kAuPsHUVWUz77lvxDeoTPHN64lqH0cRRnn38BrykrR1qhxcgu74L0A8Ap0IKi9GwgiIpPccPKH3KpjGMRGso4cIvPQXtr1HIaLp4LaiuZCEtxeRfq+VSDo6X73ZJA0EguxjDqllfePvMOeoj22w3sL9+Lh4MFnfT/j5OzvUZcWc8uUZ9CpDZzeWdLqWNWleqI610decPbwxCMgkNWf/YRILGboo09RV12FT0QbfJ1af2mRikVE+dxcm47Nji42b0Drn//sXB0uWbAWLlzI9OnTGT16tO3YwIEDadu2LV988cX/pGA5aKqo+uQj6v7cbwTUR3jYuBF9air+776DMSsbzwcfpOrnn6ndug15UBDygAAstTU49uyJds+e5u3GxiALDkLsqLxg/62JgGDQ4xAbi8XDHWtAAFpBgtWow9S9G16dOiKqqcVqMmGSSTkbYOX9o6+QUVMfKkmlUPFk9EMM7vgUZWlZbKo42mIfDRyuPEHYmNHk+3jgG5tIeaMwT9ojR3Hs1g3t/v0glYBEYnO5b3bNcXHUbmqatVgwmSh66WV8P/uUyqHzcMpYhiL9dxAsWKNHYOzwH/IKDER2bkOAphZ1cRFpqSeI6dMfS7s2nNq6kfiQQKJHfoPo7GYcstchyJzQRd9OnXNbtrw/C6jPv2U26PEOCSc8sSNrZn9M93HjETu4YK4tozQnk9M7tzD00adZ/t50rGYzcQOGIBKLcXJzI6pbT1w8veqdRXz8OLNnBz7hkSQOGc7Kj2cS2C6W7uPuZvVnH7Bv+SKGPDqN4Bg38k5Xt3gv/Ns4I3PQEN9bil5iYL91M/OP/IDaoCbCNZz/dLqPIXHPo6sopNcd7UjdqyHnRCUIIJGKad/TB4noDLmnchn0yFQESVPLRiSCPaU7mohVA5X6Sj44/AFvPfYKK195lT8+fJuuox/AqLvwb1EsUeDm6091SRFn9uyg04gxHF71G4dWLidx6Ahi+wxgz6oVPJE8hi/3Fjcbz4e3x+OnvDm8BO1cey5ZsMrKykhKSmp2PCkpibILhPb5tyKxmCA3u6lY/YmifXvcxoxGs3ETstCQ+tQYDz+EYDJRt3MXFfPn4TxgIK4jRyL19GxW3+WWYZS+9x4e992P/lRKi/2LHB3rp9xaKpPJMGRmIsqRINdqydfWcGDVcm6d+iKlVeXkHT2IRBBwGdqZR3c+jdl6vh21Qc3bJ2bxQuxT9A3ohrHyUIt92PqyWnAqrSDCxQORIAKZzDZFWLdzJz4vvIApP5+a1WvwuP9+Kr/7rlkbTn37YszMarLhtwFBr8eSloY+MR59h6lIoicglcmwKr04e+QIIfGJ6DUaSjLTadu1B74Rkaz5Yhajnn+dQW2iSdm2EZWvHw4Rt5Nd7kNxViZtQgPY9d1XIEBsn4Gk7NjM0XUr6XnXRCwWK5rKCtwDgsBs4OialXiFhFBVWMCBP5aSOHgYKl8//CKjKExLpfc9kzjwxxL2LV9E+979Ce/UFRARHJeATKlkxNQXULq4YhasjJj6AlaLBbNZR4eB/hRn1jZzrJDKxHQYFMyhdfnUlBpx8pYT1DmWZI9erCtaTVZNNq8eeZPJERPpZgpHWpVFXM8AEvq3Q1NZQ3VxNgWpiwlL7ICmshJjrRqxQY/MxQsQMFSVgJcLC04vaPVverL8JMXialy8ffAKjMAjMJzAKDG5p1teg5LIxHiHhTHoocc5uWUD4UmdkcnliG+7HatgpbaslLOH9qMvL+IWfwttBnqyvVTEObWFWE8pw+P8iPRRXWY8ejv/C1zyGlZoaChr165tdnzNmjWEhYVdiTHdNMh0GmRZaRhSzzQrk/r743rLUKx1Wizqakpnvk/hc8+R/8ST1K5bhzw0FO+nn0Z35DCCXocsqOmct9jZGUt1NVadHqtBjyK65SCXnpMno/7j9xbL5CEhlH/6KWJnJ9Q//kSYpy/dxtyFoyDGLSefiE07iazRsuTcb03EqjGz079DLzfQThJ2wXsRU+NK/qRJmLduxWo24do4GoogUPrRR/w/e2cdHtWV/vHPuE9kMnE3AkQgJLgHdynSlrbUW+q0W5et0u6Wlrq3UIEKVtzdCRYkgYS4e2Yybr8/hoamyJZu99dtl8/z8JC595xzz71z5773nPO+31czYgTaESMQqlSEvPIyih49EGq1SOLjCHz8MVS9etLy48UdMsAbR9VSWMD+5UvIO1HI/BfmkLNtCxWnT3F0wxo2fPQ2h1Yvp7WxAY0+hGuefhmJUsPexQsJjI7FJyiUYxtWI5QqsdnsnNm3m/SR4xg7+3GS+g1k0M130n38FNwuN8c2rmbcI0+x4vUXcDvtpAwdSUhCB2LTMyk8dICyU8eRqzU011RTVXCastwTFB7JRqMLIHfnVvJ2b0eu0dBQUUbB/j2IpFK2LPiETR+8hUAkQqpU4rbbWf3W3+g3VUeHHnpEYiEisZDEHoEMubkj2xeepfK0kdYmGzVnjJxZaGFA/ST6Bw5suyZfFH1Di8KOTKnix9f/Tl1hNrowOQIMhCV1RCJTYGysJ3vNcuwWE5UnsynJ3sl3z/0No6meOsu/8DC0NZEx+g6cnkFsW9RMbFf9JdNxJfUK4eimCiQKHZnjrqGutJiVb76KWCrFamhh9dv/IKJTMoNn3oFKKqJ6yfvM7qrkjf5qOp9cjLo2D8xNl+3PVf63ueIR1n333cdDDz3EwYMHSU/3RmAfPnyYffv2MW/evN+7f/+1CAQCPKdPYq8ox+O68GHvO2ECzqYmzHv3tXd7dTgwrFqNvbgYeXJK2+jJXlaGdvx4DD/+iDQ+Ht9rrgGhkIA770SgVOI/cybOujqaFi7EZTCgSO6M75QptKzfgKOi8oLja0aMoHnZcgCcNTVYjh1DVVREaFIHWl5/HdO2bQB47pvJlsoXL3merY5Wao2VdFbGkOqfQk7j8QvKZPqkEnTAO5VoXL8BeUoKPhPGYzl8GEd5edt5N372GZKYGPQPPoAgIZ7CugrkfXsQndkTc1EhklMXVw34CZHWB6VOT+Hy7yg8fICwpE7Eds1k5+kvKcnxTln2n3ELWn0wbokagUSNs6WGupJCio8eIiAqmrriQuK6dT+3rnSGmuJCguMTydm4BpfTQffxU1j+jxdx2Kx0HpBFz8nXI5AqkbqdlB4/QuHhg0jkCqoLzpCzeR19pt5I2tCRbPvyUwbNvAOpTE5Ffh4a/wDkajV5e3eSMXoidcWFdOzdDwC5WsvmT99D7edPh979WfP24wTFJpI6cCAh8R2QKH3Y+W0xsV31eNweSk81YmzwOmeU7Ghl9I2T2VHr/f7cHjeWQCm567YSFBuPT3AwLoeNiE6pCEQCBMDEx/+OWCqltaGeXd98hkSuQB8Th1ahI943nrzGC1+4AIQCIT4yP/YuN+Jyeke9douTXhPjOLy+BJvJe98LhQI69AzG7XRTnttESKyJUzu+Zfid91N6/Ch7F3s91eIyeiBVKhCKxIilUkbd9wh2mw2nzUrmhGuwtrYilCn5k/hbXOUP4IoN1vDhw/n++++ZP38+mzd71xpiY2P54Ycf6NTpj4uA/v9G0tqMWKej6rXX8Lv2WtSDBiFP7gx4VSNEQUGIhYJ2zgc/x3riJP4334yzpgZpTDQCmQy3zUb4Bx/gtlho/HIB1qPH2sprx41DIJWiHtAfoUqNLT+fyiefQn///QglEoybNoHDgVCjwXfyZDQjR9Dw/gfIU1O9XoRuN+6GBly5uW3GCkDgciERSi6pbwcgRIjko2946uGHWF69jiVFy7G77chEMqYFj2JUqT989VFb+YaPPyF07lwCH3sUW24epnMB5qrMTIRaDQIfH07nHsfqsHNk53pqmhvoMXg4UhcgFsNFpjiFPj6Ig4JosJrOfwdyBR48mJrOT1EZ6mrbeQiKfYIY9/BTLHxqNnXFhegioojv3huBQIhUrkCh9cFiNBAUG48+Jpmmahvdxt6Cf4gvIqmUsJQMPE47J7ZuQCQW4xMUTPfxUxCKRFiMBmqLCghNTGLQzDvZ+8M3FB87zMCbbidv9w6qC04z5dlXqCksoOhINpGdU9n9wzcMnzWbIXc8wIYP36RT/0EcWbuCmsIzCASg1IhQ69MJiNBw9nAtAqGAmNQANDoF2WuKcNrdCCpU6BX6ttGRGzcxaV2xmy2YGptorqpEplLjdjnZ9Mn7jLh3NkKhiJbaWiY98TyVZ/LQ6oMQm+zMSJrB03uevuj3nhWZhcroi8t53tHCZnGRt7eKTn1CkchEeDzeuLDCI3XUlXqdYSQyJb2vuZZTO7fiFxxKXbFXlV4boKfgwF5CEjrSUlNNx74DOL13F0HRsfjExqMNjcEjunw+pKv8b/Ob4rCSk5N5/fXXf+++/KkQtRrwWC0IZFJE/n64jEbq33kXka8v+tmzcdbW4qi6cOTzc8wHDtK6ZQuulhb0Dz6Ix+mg+rlncdvsqLp3x+fJJ2hcsABHRSXS8HDqP/roAmeFurlzkScnE3DnHciTkrCVlCCUy2lZugxnQwNivR5ZfBx+N92IyNcX09r2ShCChSuYdPMoFhR9d9E+BioDCW4VY92+g5CRI5nyWTaTnp5Dc0k+Sosb5VsbcOQXtKvjNhiw5Z5C5K9DEhmJb3QUHpfLm4okNJTlP3yFQCJm4I23IRAIsFss5B7LRiOWkfjSi1Q/82y7tCVCrZbAh2fjjopg+2vPEdqhE34hoZzctgnf4FACIqOJTu3K2UP7Obp+FfEZPVApVNiNzQhFIo5tOB+z0lheBh4PGn0AW+d/hNNhJ3PcNJQ+Sexd1kJzjRUQExIvoPvYQBCKEUjFxKZ3RyyVotT6cGrHFgbMuIW1779BU2UFnfoPJv/AHvpOv4mmqgq2LfgEgIyxkzmw7Ac6DxpC5wFZCARC0oaOwmpsofrMSXpPns6KN+YgVSiJTE6l8PBBMsffzeb5p3Haz6/jndxZiUIjocfYWHYvKcBp8qD0UcI551AfqxSBUIhvWBhSqYzNX3zIkFtnkb1qGSGJHZArVax4Yw79rr2RgyuWkr9/N32m3UD2yiWEDO7JTZ1u4qvcr3D/LKC6a2BXJsdN4sTHze2+25rCFvxDVRzZUHrR+0WqEKPyVSCReRCJRZzZt4uotHRMzU0cWbeKQTPvoOJMLj3GT0Hh44tAIECmViPWBP7mbMp/NB6HB2O9FZvJiUwlRhMgRyD5z57L/0c+rJ/Izj7A/ffP4v77H2L69Ov/48e7HL/KYLW2tqJWq9v+vhw/lfsrI7aZMS5binrgAAIfewzr8eOoe/cGjwftqJHUvvYaQq0Wdd++l21HIBHjcbkIuGcWjV99hbPqvLyOceNGjNu2EfTo36h9c95l27GeOIH1xAn0TzwObg81L7/SznGhdetW/GbMQDZoEK7vvm9fd+8+Rj10IytkG2iytV8/ECDgiU4PwItfgtuNs7QU5+kzBOzJg88/x2OzcdGwV7EYj91O9dNPo+zVC+nMG1H4+bF3/Sryln2NUuvD6AceRSQSE52WjkKjZcmc54hMTkM3OoWgjz/EU1yKo6oSsY8P4qhobFo1JiEMmnkHIQkdcHsgODaB4IREzC0GlFofwpI6UV9awpkDe0kZNIz1H86j56RpFGTvI65bdzLHXcOqt17j1I6t9Jp6HYNvvpOtX36CXNORPcvaq9RXFRhZ9c4Jxj6QhtRXjDo0DrelCd/gUAbNvBO308nIex5m+T9e4NSOLQgEQgJjYpEqlOcvg0SCPjoGu9lM4ZGDFB46QN9rb+T03p1U559m6nNzSOo7gA49++JyOolM7UHOtuZ2xuonLEYHNSUG9JEaZOEuqqu9HnaDgwfQtCsHbWwnnDYbUmUQmeP/xrEtrYgV40no6YvdZkAXHkFYx3S0+hRCOwzD47aiC29BWNnKxMHj6BaYzllDIXaXnUCFnhBhAJpSIcb69iPv8tNN9JuWQHleE56LqOSmDAqjKn8fZScOMmjmHeAREJGcgkSm4PSeHfgEBiGRyakuzCc+oydpIycikCj/tMbKbnSydUEeDRXnR/66MDWDbuqAVPP7ZWj+o2htNfL+++/Qq1efP7orwK80WJmZmezatQudTkdGRsZFlS08Hg8CgYDc3MvL//wVEJacRezjg3HDRlqWL0cSGIgoIADN0CEY1m/AbTLhNpmQRkVdth1JcAhClQpHZWU7Y9WGw0Hj19/gM3o0pn37UPfv15aq45eIAwORBARQ9eRTF/Wya/r6a2RJHdBOn07dc8+1rzvrWT748EWW1W5iacUaAhQBPB56Ex0t/sjzrQhvvAHX5Mlg98b5GDdtQjtyxCUVKzRDhtC6bTsA8u7dMShl5B05QFHeCeK69aAgex9N1VUExcax/avPCEvqzLDb78VkMKBQaWimlWZ/NVJdR2xWM+EJsax6cw7B8R2I6JTCd39/nJH3zEYoFrPo6b8x7K77KTyaTVzXDBx2KyXHDhHRKRm5Wo3VZGLSEy9gM7XisFkZduf9iCQS9i1eRHxmLzr2Hc3x7Rd/CXM53RzfUkb6CD8EKl8Ecj8CEvxxtDbTWleDuaUJm9n7oEoePJQDy3+grqSI1KEjKTl2mH1Lv2Xyky+w8dP3GH7n/TSWl7Frkdcrr+uIMRzbuJakPv3x4CF351Y69r+GmqKSi/YFoPBIHZmjozml2ofH4+G6uOkMlnSjRZWPWCbHYZVweruHpuqytjrlec34BMoZcvtz7PzuLLUl52PYfINT6DlWj7O4miRdGBGKAIQKKfWnzqCUuAiMDiMyuZ6S4+2lo3K2ltNncjw5W8sx1HuHeVKFmOT+YWj9RVglGrqNmUhzdRWJvfrgsFqpLylCqw+kvryUPd99TfLg4XTsMxCBXfinCRL+JR6H5wJjBdBQ0crWBacZdmenf3uk9UfmwwJ4/fXXmDnzNrZt+++Q5PtVBmvBggVtgotffnlpN9j/BUQiAa6qSlp37fJK2zz4APaSEpw1tYiDgrD8TBDYmpeHslcvzHsvDLhVDRyAUOdP4COPUPX0xdcQABwlJUjGj6f5hx8IeupJTHv2tqla/By/G27AUVF50X0/Ydq1G59rJiNQKPBYzgcbu+rrEV5zN7fdfw+3DPgISc4ZGu+fR/O50bRQpcJvxvVe/cJJE2lZugzt6FFIY2OxFxa2O4YkMhJFSjLGdeuQpaVSppSgdjioPpvPgBm3UJmfR4+J0wAP2SuW0nnAEPxCw5DIFTgddvYuWURCjz447XbOHjtMTHom+Qf2IFUoCYqJQ6MLQCyVsuotb4oQpdYHj9uFrz6QZa89z8h7H6briLGsfXcuvadcT2RyFwRSFS6Xk9b6BmxmIwERUfSYOJVlrz5P3+v+hmnfhYHXP1F4tJ64FCcKXSsy/3CcTg8CuQ8+QQ62LvgYsUTKqHsfZu/ib+k2ejxRKV0ozjlCv+tupvrsGU7t2MqgG2+jobwMqfL86EvtH0BCjz4YGxqQC4R07DcIj+fyDze3y0NgvIoWs4bPe39A9eZ9lDfsxS84FP/QcAqPiWiqvjB7c0yano2f57U5bvxEc7WF7d9WMeC6OCryjWh0GozNhdQX5CNAwPoP5pF127OU5wlx/Uz7r6XWwv4VhWTN7EhzjRmX04Pb6aam1IBSY8I3OJTd331NU2U5WbfPwtzUxL5l3zHx0WeRKpUExyQgU6uRyGRgtF/2nP+bMdZbLzBWP9FQ0Yqx3oo25PJxa5fjj86HtWXLJoRCIf37D/hzGazu3btf9O//Vr755hs+++wz6urqSEpK4plnniE19bfnpfk5AoEAXG4QCFBlZlL7z/NrefKU5HZlDatW4XfDDcg7daJl6VJcTU2IdDr8pk5FEhtD9TPP4j9zJm7LpR+YAJ5z+nnNK1cR8uocmr5ZiCXbGxcljYnGd9o0DGvXoe57+WG7q6kR8759hHz8EbUPP4KztrZtn6pvH8QiCYLsXGrnzGlXz20y0fDRx+gffABpRCRCrZa6t9/Bf+ZNCEePxnLkMHhANXiQN7/Wrl3IH32YKoeVM8cPkRoYSMaYiRQfO8zxzeuJSk3n+OZ1WIwGJj/xPKWnjtNxwHAshmyKjx7CUFeD2+WmubqSmPRMNDo9+ug41P4ByDVauo+fws6F8wHIGDuJQ6uWkZI1ApWvP2ve/icACq0PUoWSk9s2oI+Kwe12U1daTEh8BwQCAUVHDjHgxttQ+uqBi6/H/IRapkSkbC/6KVLrGf3AY7hdboQiIUPvuJe60iJCEjsiVaowG1vo0Kc/xro65BofTmzbRG3RWVKzhlOWe4KdC+cz6r5HcDntHN24jeKjh7n2pQ+QqyVYWy+uLxgQoabm9AGOfv0hUoUCu8VCl+GjMTU3Y7eIyD9wYXyUQABylQRjgxWVr4yYtAAkMhH1Za2U5TXisLlornVwaG0VTocbv2AFGSOHU3hkM0KRGJGohRF3dOLY5mrK87wPNv9QJZljYqgpauTMgXokMjHRKRIiOxjxDfJFodHSZ+r1bPv6czwuNye2bWLcQ08gFIlZOXcOmeOvIVD9508h/5OX5G/d/6/4I/NhNTTU88UXn/L++5/8W+fwe3PFk6w7duxAqVSSkZEBeI3D999/T3x8PM8+++xFL+j/J2vWrGHOnDk8//zzpKWlsWDBAm699VbWrVuH7iLBuVeKsLUFW3UV2mFD2xkrALexFVFAAK7682+5rVs243/77fhMGI9QpULWsSPOmhqq/vYo4F1/UnZLx7y/faqWnxAoleDxIFSr0c2ciUco8jogmM14nC48VivVL76Iq74eTVbWZfuu6NIFR0MjlU31hH38EZ6iItxGIy6DAfOBgzgqKjDt23/J+k3f/4B2zGh8Ro+madEiGj//AoFMhu+M62HcGA5t34RMoUQzfhQ7Fs7H5XQy/K4HaKmvQ65W02X4GIL1QQgMRhKj41HHJ1BwaD9pIybgESsJT+tNn2mtWCor0Pr44RcTi1MmozB7P8GxcZSdzMFiNLDr2y+Rq9S43S52f/cVw+683+s+PnZim8ND+sjxOKxWIjqlsPTVvxMcn0hMl26smvcqkclp+IWEUp57nI59IlD7yWhtuvjINCZJjaSuFKJ6tU1deRxmKk8fJyihEwKJjObSfCyGFjZ98h6ZYyfjGxKC1dBC+cnjqHz9EUulpA0dRWiHTgSERZLYuz9VZ/IoyTnCye1eT9vUISOwGKvo3M+HQ2svHCUBZIwMR6sPYtciMXaLBbWfjrSho7AYjditMpwXUUCXqyW0NtvIHBODzeygILsWu8VJwgAd6aO0nGo8xUHBGSJuikVQ5EPRFiMndkqRiJwMveNe9vzwDR37DabnhIHYWvVYTa2IZW4k0lqiU2SYGk7jsJkpPlxI6pBRWE2t7Pr2S7oMG033sZOwmlrR+OuoLyvBamolOKEDUrkCifqPfU78HshUl398/qv9vwf/qXxYeXm51NfXc8MN0wFoaWlm167tNDU1cffd9/7Hz+tSXHHg8D//+U9M58RZT58+zZw5cxgwYADl5eW8+uqrv3sHr5QvvviCqVOnMnnyZOLj43n++eeRy+UsWbLk325bIBDg3L0Tkb8/9uIL1xpaVqzAb/q0dtt8p0yh5uVXaPxiPvXvvof1xEmaf+b4YNq9G82QIReItf6E33XXIVBrCHtrHpKwMOynT1N6622U3Xob5XfeScuypYT+4zWCn38eWWICkkusmwkkEhRpaYiUSiJCwlk4bw7r921FEBWFQCLBtHs34sBAHKWXHm04KysRSqWIdP5t20QBOujVg7M5h4jonIrSx5etX36K2j8AhUbLxk/exT8kDJ2fDsH+A8jnvYfolX8gefk1RN8sIqNLDxrLisBpQWSoJ6zRQMTKDShfnYv7pVfxLyolLqEjTrsdsVSKVq9Howtg/GPPMu7hp1BqfRFLpXTuN4gdX39OYHQcCq0Pe77/Gr+wMGRqDX2m30h1wRn2Ll6Exj+AbqMn4BcchlLrS8WZQ/TK8r/o+YokQjpG2zBXlWNtrGy7B5rLzrLhw3ns+/5LTDWllOeeAAGkjxxHcHwCGz9+l7OHvGk77FYzLoeDlroaNDo9co0GBAISevSlqca7bhneMZmQhCTqy0qwGU/QY1wkYun5n6ZMKab7WD0qPzu7Fs7H7XIiU6lobWrg4IolIACVnwqlVnrBOTjtbkLjfck/WEPOlnLMBjtBXRXsDVjNHXtuZl7eP3kv9x0eP/kQ8yWv03GalqoCAx0HTEIqVyBXa6gtzOfYhuUsnXM/Tls1xUf38P0LT2Ksr+X03g3k7lxPY2U5LoeNTZ+8R6d+g6k5m0/Bwb1s//JTdBFRHN+6kX1LvqVjnwH4BAbisl7eeevPgCZAji7s4k5mujA1moB/z0X/5/mwANxu9wXTd/8qH5bFYqFHj17cffe9hISEUlRURGVlBUqlkiFDhvHww49SVlaK5Rei1H369GPt2k0sX76a5ctXM2jQEG655fY/1FjBbxhhlZeXExcXB8CGDRsYPHgws2fP5uTJk9xxxx2/ewevBLvdzsmTJ7nzzjvbtgmFQnr37s2RI5fXwvs1SI1N1H79NSEvvoBp564L9ruamrCePIn/LbfQtGgReDy4rbY2iSIAgUjYPpDY48GwZg0hL79Ew4IvsZ/bJ5DJ8JsxA82woZj2H6Dh08+QhIbS8gvD27ptO+aDBwmYNYvyl14i/N13qH31NexFReevgVaL/t57qH3nXdS9elL7zLPc8NSTlFWUYQvSI1ArCf/wA1wtLSAUXtRpo63/CgVCrRbFkCEoBw7AqFbi0Pkjr6rAFyFBcR2o6tWXzv0GIVOp2fL5h/joA2HLNureevt8Q2435g0bsWUfQvb3Z3Apq7F8+TWmFSvbijiKi6l79jm011yD8pqJWIJDkSrVjH3wcQz1dbTU1zDukadY994bDLjhVrqNnoBPUDD+oeHk7d6BuaUFrT4Ild95gyRVKBAKhRxasxxjfR0hCR1IjUtm6CgNhw47aKz2rvOExSrpkuTC/uYzBL0xF+u5tOBuq4HmmirSho4iJCGJpspyAqOi0YVHIxSKcDocdBs9gUOrlyMQiXDabCx+8SmG3nEv1lYDGz58iyG3zaLq9ClC4juQ2L03LXW1mJoaCYlPxNLaik+IiMCoGAwNVmQKBY2Vp/APluO0iTA1N9F1xFhSh4xg17df4bBaEEmkOO0tpGUFsXfZeYcL8BrdlloLzTXeB5JYIsTauZJv87654LvNbTnFj8qv6d/xOhwWwONgyK13s+SV5+jXrTv5Mjlr33sD8BrZutIi/MMi6Dwgi20LPuX41o2kDR3JyZ1b6DZyHHGZPTE01HN4jdc5p9uYiZzc7k2xoo+OveQ99mdBIBEw6KYObF1wmoaK8wb4Jy/Bf9fh4o/Mh/XfyhUbLIlEgvVcqos9e/a0ieD6+Pj8S5f3/zRNTU24XK4Lpv50Oh2Fv3AOuByXTO9lakV/371YDh/xxjzl5aLomg4eN+YDB3E1N9O6dRvSomLC334LR0UltqL2x/XY7W1OD+KgIPyuvw63wUjr9h1o+vdDdvddCKRScDoRBQRQ/+FHmLZsQT/7ofMPfIEAVd++KLul43E6EQhFuB0O/G66CcO6dSi7d8dn4gTvscRi3BYL9R9+hKuxEdGI4djy8rAcOoRersB89izC8HDOVBYT1SkFdVYWrZdQh1f27Ik4QE9jZCgmnQ+7N60jIiaOLmIpbNtNa24uVn8/+k6YiMXQSnVNNVm3zkLt9FD5wYcXbdPV2IiisBir2dzOWP0cw+LFBA7JwqpRemWOxCKqC/PJGD2JupIiXA4H+Qf2ERwXz8aP3yE+oydqfx2bPnmXXpOvpeTEUTQBemLSupGzeR2H165g0E13YLOY2fDBWxiwozq8kd4uEe4enREIPHgOLMcyfzP6Z56mqLqcgjVL6DfjNtwuNzUFZ1Botah8fVn3wZv4BYeSPmo8W+d/hC48kv7X38yh1cvZtWgBQ26dhUQuZ93780AAEpkcmUrF1gUfExgTT1NVBYWHDtBn6gwQCDiwYjEj7n0UqdJKkK+ahtJidi96H7lajdNup9voCUSmdkWg9Kf3tbcgk4pwipQIBAJCxC0k9fInb+/5tazIzjry9p33QA3NVPFF1dsXucpetlZtYVSXKUgUIkRCDZs++wC7xUx14VkiktPI378bgNShI5EpVcR1605DRQVZt96NtdXIqR1bqCspIv/gXpIHDsP9syBwiUyG1dSKSCxGcm5N8EpS6f03pt2TasQMu7PTfywO64/Kh/VLnn324l6E/99cscFKT09nzpw5pKenc/z48TY5puLiYoKDg3/v/v0h6HQXf9uw230w7C5GFBiIIjkZj82Gac8eEArxmTwZoVxGw8ef4DIYcFRXUzNnDrpbb23XhnHjRnxGj6Z1+3Z0t95C7etz8djbe0rpH3oQ48aN2PIL8Js+HcHgwd4yLhcCiYTARx7BuGULdfPe8lYQifAZOwbN8BHUv/8+1uMXyif9xE8BudaTp7BXVOB73bVUud2o/fzZ8On7TJ10Leb9+3EbDO3qCdVqfCZOxG02kbd7O6GJSfSZfC3qU3lU3HtfWzlnZSXWEydR9e9Pwv33oIiOxbRjxwXn+HPMO3ai6NGdi/tbebEdO4arRwb+YeHk7d5GUt9BePBwNnsfqUNGoNUHotD6EJfhdZsHiExJI6ZrBio/HQERkQjFYkI6JOGrD2bNu3NR+/kz+akX2Pblp8R16ExCQDCmHxbjrKlF0rEj8ueeZn9FMXnLd+MXHIpELMI/KpqkPgNY8cYrOGw2Bt10B1vnf8Tmz95HodEy+OY7Kcjej0YXQOa4a3A5HXQbM5FdixaAB3pOmobJYCCpd3+ObfRqcib27odYKqOmsIBRsx5CFxbadt7+QUH0nnY9u7/9yntvREUTHJ+A2+FEpgvF7XZhN1u804PLvyEyuRtDb47C6VDidDjwCZRRcfp8fJ1CL6CovohL4cGDXWqmMm8PkZ07YDObGHL7vZgNzez57msCIqNobWhg/ftvMuHRZ2ltakQmV5B/cA+B0bEMv/tBjm/dgD4impxNa2goL6X31BkUZO9j35Jvuebpl/ANCcMnQA9c+rf2Z0IgEfxb3oBX+fVcscF69tlnef7551m/fj3PPfccQUFBgNcZo1+/fr97B68EPz8/RCIRDQ3tg0AbGhoICAj41e00NBgvGhsiEckwHz6C/403UPHgg7iazj8IbKdPIw4NRf/II0iCg6h68ik8NhsCiQSBTNbmbm4vKsZnwgT8Z86kdt5bF32Q1705j8BHHqH2xOs0LlhAwH33IpB558P9b7mZhvnz28dtuVy0LP8Rt9OFLC7usgZLIP3ZOofbjbupGX1wENU2MzKVGltxCSFzXsG8bz+GtWvB7UYzbBjq/v3wuN1YThynx8ybqMrPI0Agovz1C3N4AZh27EAzahTNPr4IHZfOqgveAGp36+XMFbjNZnZ++yUDZtxMXLceCICykzlkjJ6IoaEOuVrDsQ1rkCnP51JK7NmX7d98Tse+g2htaiRvz3YCo2LP7evNodU/svglb0hBTHom244doPejj+A2tKAKj6S5oRa1w8KYhx7HRx+M0yOitqwcq8VMtzETiUruQlP1eTUTqUKBuaWZ+rISJj76HFazifqyYvYtXoREJkcgFLLr268Yff8j2H+WkNPc3Ix/eAQ5m9cRFJ+Ep6YeAUIQSzDVlHLwx8UIBEI8HjdbF3yCVKGkpqiQxL5Z1BfmUZ57gs6DRxDfvTdH1q6g+uwZwjp2piL3JDFduxPVeTKndnvllWxNHkJUIZQZ208d/hy9To20yczGj9+h66hxhCYmUVdcRHRaOp0HDEGqVLB/2fc0VJQhEonQ6IPwCQxCqlTTUF5Ka0M9MoWKLsNGE5KQhMXQQsboCZiam1D66nAgp6HBiE6nueRv7aL3ieCvYeCu8tu5YqeL0NBQPvroI1asWMGUKVPatj/55JM8fZl4ov8PpFIpnTt3Zu/P4p7cbjd79+69aEqUS+HxXOqfAM2QLBq+mH/eWIlEqLOy0N11F5ohQ3DW1uARCtuyBjctWkjIKy8jkJ9fgK17512EKhUe86UT2dlLS5Cce9Nu/u47JGGhCP39EUilFw8yBoyrVqEa0B9lj+4E3HcfAffeg9/11yHUeqdfxMHBuBq800Xyzp2wFRTgqCjH9NY7+DV6HyrSjkk0fvoZpl070Y4Ygd/06djKSimfdQ8VDzyIuk8fKvJO0VhRhv1s4WXjvoyrV2OsrqSyub69ofwFil69kaVf/vtxhIWi1GipLS7EabdzdP1qIpPTMDTU4kFA4eGDRCancWrHFsI6diahRx+UWl9MjY1s+uRddi1aQMGBvTRWlKFQawmIjEZy7iVArtYQnZZOee5JygrysLgcLHjiAepLStAGBLJ63j8oPprN8Y0rcFpa2bbgYxCAVKlk+1efotD60GX4WFpqa9j/42KCYuL44eWn2f7lp6j9dMjUaobf/QDjHn7yXNyYh9LjR+nQuz9JfQdSfuo41Wfz6Tp8DCXHssnbuoaaMzngtNJUVYHb7WbSUy8x+oHHsRhaaKmr4fCa5Wz/4j1WzXuVvN3bcdms6OM7M2zWbBRaHypyTyKWSOnUbwBx6X4Ixd4pqsoDZqaF3HDJ69wjuAc1W3azdcEnGOprcTud1BafpfJMLqlZI1j99j/Y9Ol7hCZ05PDq5WgC9Cg0WkDAmb07cDkcJPUZQHBcAmf270YboCc+sxcFB/dxcvtmnDZb2+8JLvdbu/i/q/xv85v8Lt1uNyUlJTQ0NOD5xV2UmZn5u3Tst3LzzTfz2GOPkZycTGpqKgsWLMBisTBp0qR/u22nWII8PBzzbu88vqJrFzTDR2Bct46GbdsQabVox4xB7OODPC0N67FjKLplYD5xksBHHwWXC3tREbKkJET+fgTcMwt7aRnGDRsuePA7qqoRBehxVFTirK3DWVlF6Esv4qyr8464xGLspWUYVq5sG6UJVSpEGg1ClZr6d98FjwdxcDC6m2/Gmn8GZbcMaufORZaYgLOhEZxOpLFxtKxYifWFl5A9/ywenR7LOQcVe1Fx+wvgctG6YwehN99ESc5h3PrLJ9pzGQzUFuTjFED8nXfQ9M67F5QR+ftDWjJVtV4RYOcvjwmI42KpspnoOmIsNnMrJ7ZuJHPcJDweD3KVGqvJTHLWcKyGFrpPmILSxxeBUERzbQ0j732YRc88QnNNFQERUcT36I3FaCB75TIcNishCR2oyj/NzkULGDTzTrZ99SnTnnsFrT6I3d97p+HUfjqkShVafRBn9u9m8hMvIJJIKMk5Qu+pM4hK6cqZ/TvpPeU6wjomk71yGRZDCxZDCxKZjD7TZlB6MgdNgJ5xjzwFAhhww23UFuUT3imFDr364bBaWf7aCyT07odYJKLydC7+YRGEpmQy/cUOiFQ61MEurnv5TZx2G32n38iWLz4iZfAwkvoMQCiRIJRIqDh1GGurEYFQSJfhoxFJpDTVnGTE7Z3ZvbiYljoroWWxZAUPY3P1hnbXOUQVwgOd7mHXYm+4hkAkQq5Wk79/L6lZw8ndtY3EXv04s3cn2auWMmLWQ4gkUszNzRhqq5EpVRxcsQS7xUJcRndSskYgEIiQ+gbSfcpNOC0GJL5BVw3PVX4zAs8vLc6/4OjRozz88MNUVlZeYKz+W6SZvv7667bA4Y4dO/L000+Tlpb2q+vX1198mkJqNSIqLabs1luRhIfjM2E89e++d2G5xAQCZz+Mo7oKkY8vzspKaufORaBUEvzM09iLimn+9ltczc3IEhPQjh2H+cABTDt3trXhd/11mA9m4zt9OuKgIERaDTWvvort5CkAxIF6pPHxaIaeiwdzOAibN4+qp57C1dx8QZ8C7r8f45YtyOPjkEZGUffOOwikUsLff4+yW28DQDl5Etqu6VRfZqQsjY9H9tLzOPDgU1NPzQMPXrKs/513YB40ALFMiq2+Hp/KGprf/wBnTQ0IhWiGD0d70w2Y1Crqy0qQNhuQrl6LdZf3hQCBAFm/vjhGj2Dt918hU6kYff/fqC8vJaJzCtUF+exf+i0tdbV0HzeZw+tWEpqQRO+p11N4JBtdWARn9u/m7MF9bX3KunUWUqWSqjO5KLW+qHz9MBuasZpaSeozEGN9HWK5jJaqKjZ//gHgDU42tzTTaUAWAkDp509TZTl2iwWnzcaZ/bvpPv4aTE1NnNm/i6iULmSvWo6hroaIzikExsSTv383E/72DPXlpRjr61D5+iEUi3G7XQgFQkpyjqCLiEIskVB09BBdho1GqlSh0EfiPqfZJxCA01BLyfHDtNRUE5bUGUNdLRZDCx37DUYggHXvv0n6qPHowiPZ/d2XmA0GRs56iJxN65AqdUR07oMHEW61lTJXGXtq9mBym+gV1Iskn0SOfPo59SUlTHjsGcwtzWz78jPGzX6S1qZ6bBYz6959E5FUgtNmwzckjD7TbkSrC8LltHJs4xp0YeF4PB5aaqtJGz4WiU/IRe8NgQACAjSX/K1drs5/AqvVytmzhQQEBCOVyv51hav8btjtNurrq4mLi0Uuv3wowBWPsJ577jmSk5P5+OOP0ev1F9UV/KOZMWMGM2bM+F3bFAoFCM7k4ZFKEfn64jN+HA2fXZg1F8B+Jh97STEty3/ElpuLavBgwt58A2dDA41fzMeWdz7/kO1MPnVz5+I/8yactbVel3eRCFliB5S9+9D87bfIEhIwrl+Ho6ISVb9+qHr0wFFRgctkwm00EvrKK9jr62jdvfuixgqg4ZNPCJ0zh/r33qNl+Y8IlEoCH3oQ58/W4ZyHjyDsc3m1DLG/HyKZjOaaKpoaa/Hr0gXr0aMXlBPI5Sh69eLA1g1UnD5FjwlTKLebiH35BZxlpYR0TKbe0sqyea8w9I778QsOYceWDSiigukw6AmCgkJwSMTk5ucSHRXN8LsfYP+y73E5neD2sGzO8zisFkY/8Chr3nmdA+fWebqNmYDCP4QOfQZhNxmoOpNHUu/+dOw7iK0LPqYgex/dx07GbrUSk96BosMHcNrtpI8cR3VhAQdXLKb31OvZ8sVHKH18EYpEZK9aRr/pN1JwzvAFx8az4aO3CY5LpPvEqZSfOkFt0Vm0gUHUFhagDQhk/N+e5tj61ZSeOEbXEWOpyj9N0dFD7Fw4n8lPvcD699/C1NJE1q2zKDl2mPwDewhL6kxNYQFCkZDMcZMxNtYjVaoQKM655TvMuBx2qs7kIZHJcVjM3qlZixmBAOxWCyNmPcSKua8QGBNLXEZPti34hK+feBCAxB59KLQ2Ed99HJvfK8dhdRMdOAiRSEhlnQVbWCO9rrkdt8vA8tdeIGPcJAbNvJ3Da1eQu3Mr4//2ND5BQQy7835sZjfNNS5O7xdgMTYSEq8iJLEvJcc2YmpqoLa40Kv92C3k6ojqKr8bV2ywSkpKePvtt4n6F8KufzUkTXXY8vORRkbiN3MmuFzt9Ph+Scuy5fhdd6136q6yksrHnyBg1t3tjNXPafz6G/T33Uvd2bPoH3wASWgo5bNm4XG5UGZ0w1FRiWbECAQSCbW/SO0iDg4m9B//oOnzC91ff8JjseAyGlH16Y125Eg8bheWU7k4ys8vvgt9tLgNBoQ+PrgvoS+mGTUah1xO/v7d1JUWc+0Tj9P41tuY9+xp1x/9s8/w/cLPaKmpIi6jB8aGejr2H4ShthZHoJ7vPnoTp81G1i13I5ZKObTmR6rO5BKdls6WTatxOuxMeuzvRHbNQCQW4Xa7GHHPbGymVg6uXEJrYwMRnVKw26w4zonyejxurCYTboQglFJTVMioex+mpa4Gt8dN1m2zaKmtxoOHLkNHYTa2EJ3WFYXWl5a6akzNDYy4+0E8QEBkFN3GTECj0+N2gUDgh8ZgQ6aSIpXZ6NR3EB0HDMZhtTHyvodZPe81rK1GOvTqR2RKGsaGOoQSMUPvuI99y74lZfAw1P469FEx/PjPlxlwwy3sXLiATZ+8S/cJUwhN7EhF3kkAht15P3uXfMvAG25FID8vCeURKxGJDQiEQvJ2b6f0xDHMLc3Ed++Fx+Nm/fvzyBw3ib7TZ7D2/XmEJiThGxxK8znHkMRefXHYhexdVo7D6pX7aqk9fw/XlpgpzzNwfOObOOw2pAolmz59H1NTIzFdMzA2NtBl+BjMRjvFORIKDjW31W2oaEUoFNBz/Hj2LXmdlMHDCUnoeNVYXeV35YoNVmpqKiUlJf9zBotWI2J/f5qXLEHRtSvypA4EPvIIbqsFgVAEYjHGdeuwnvJO2XlsVjxA9bPP4X/jDQQ98QSGlRePMwK8cVe+voS+OgdnYyN1772Lx+FApNPhrK5BIJEg79CBurfeurBqdTWm/ZeWVGorV1tD8+IluM1mhBoN+nvvxbBsWdt+db9+1H/0MQGzZmHaswdpZCSulhZaN2/GbTKh6t8fR3AgjRVlxGX0JDI5jfLWZsyjhhExfSqiVhMeqZQ6l53mAD9aaqoIjImjy7DRNNdUYTebEIoE7PzmC/pMv6EtsLj/9TeT2KMPMqWKriPGYG5p4cTWjVQWnGbvD98Q0yWDoLgEFBofVr3pVVOJSuni9eyb/zECBAy9/V72Lf2ODR/M49qX30SoCiAyLRO3w44yIAyBUITHYUblp8NYX8Pu75fS99obcVgt7PjqM/pedxPhHVNoqatBqwtkxD2zASFOu4TsNZWU5ea3XSddmIo+10yjoewwhvo6aovPx9qVHD9Kx34Daawoo2PfQdjNZqryT1NdkE+HXn0JS+qM1dSKy+nEabej8vVD7effro3yvBN0HT4ap92GTCPGbTEgVPjgdnvwICBl0DBKj3uNlUypIrFHH6wmE90nTEGh1SJTqkjNGk7V2TM0V1fiGxRCc00Ve374hn7XP05j1aVjEgsOW4hJ74faT0lLbU1bcsz4zJ7s/WER8Zk9kcg7UHDowlxvbreHQ+sNJGdNpjRn139n4NR/ALfdjKG6AmurEblagzY4DKFU+a8r/ge5++7bmT79OgYMGPSH9uP35ooN1g033MBrr71GfX09iYmJiMXtm0hKSvrdOvffhEckQqhWe0cpPbrTOH8BrecyLgMgEuF3/fWIAgIw7diBskcPEAgJfOQR6t5+m5CXXsJ9mVgkAGddPc0ffEjQ00+1ZRv2WC0IVSrUgwZi3LzpknUNy5ejHTGCxs8vPk0pUCgQSKUIlUq0o0Z617F+ZvwUGRm46huQhIUhEInw2O20rFiBOCAA3R13IOuQiNvtoTUwABobcTmdaPVBGBrr0EZFUlxZQempo3QdOY7morO0lhbTd/qNuF0ujm/ZSFKfflTknUQfGYPL6WTbl58iEHidVJU+vhQdPUREpxQOrlhKRMfOCEUiNP46Env0IW/vTjr2HYjK15eEHr0JjkvEbGimpaaGrFtn4XY58Q+LZOBNXtkjiVqH2+Ohuaocl8OOPiEZY3UpdosZiUzK3sWLSBk8nKbKcg6uWELqkJE0VVVgam5i93dfExgdS2x6JtGpvdmzvJba4vYK2Q0VJjZ8VsDgG5JQ++k4uGIJ3UZPIDQxidVvv07RkUMkDxpCXWkJBfv3MPKe2ez+9it8AoPZ/d1XjLrvEbbO/xipQsGIex8me8UShCIh1zz1Iie2beL07h106jeYqvzThIklNJSXotYFotSoqTpzivqyEuwWMyKJBJvZRPmpE4hlck5sXc+UZ+aw9r25+AQG4RscSnxGTyJT0nC7XJw9dACr6fJCy9ZWB7HpA6grOYM+KoyY9Ewq806x5YuPyLrlLopycjDmXNq71WZ24hfSmQNLP6PiVA7RPbMuJ5zyp8fWXMv69+dSX1rcti0gMobhs2Yj8w384zr2F+WKDdZ993mDRJ988sm2bQKB4C+fD8sTEISgogz9gw/Qsnx5e2MF4HLR9OWX6GfPxpqXh7xTJ1yGFpoXLiT01TnUv/c+qj69sR47dvEDAOKgQJzV1W2u5wBuk9mbHj4wEPOBg5es66ioQNG1CyJf34uuY+numYV8wAB87A7EQUGYd+1C5OuLNCoSn4kTsRcWYdq/H82QLGpeeqmtnr2lhbo330TVvz/O6VPY+Pbr9L/hFmzmVnZ/+yXjHn4St9uDTKWm5PhRYjN6Ymys5/jm9YQkJFGVn4dPUDBJffqh1Pri8XjoM20G2778FIDeU6/n8LqVlB4/SnBcAg6bFalCScrgYRQdPYRAKGTUvQ9zZv8eugwfTcqQkZzetZWEnn0RCIUUHztMVEoaZkMz2sAQpBp/jFWFyJQqts7/AGN9Hb2mzKCupBCfwCDCkzqj1PrQ2tSAQq3BZrGg0QWw8eN3MTU3kjZ0NHEZ3TmybjWhHYdQW1x80ettbXVQU2SkMncto+//G1KF14tw6t9fw2W3IZTKCU3tjm9wKAeWf09zTTUSuZzY9Ex8gkIY/cCjuF0upHIZvadch8vhQCgSkZI1nC4jxiASihCKJZzN3s/hNcsZec9sDm7fQJeskeTu3Ep89150Hz+FPd9/TW1xIZHJqfScfC2tTQ106p8FuBEIheecU86gC4uk33UzsVlkCISCiyZfBAiIVHN6v4XSUyoSMwPoMnwGXYY2c2T9Cq+jiECMqeXycXViiYKJjz+POijiL22s3HbzBcYKoL60iPXvv8GYR579t0daPXums3HjdjQar7PJ8OGD+eKLrwkNDWXChNGMGjWGAwf20dDQwNixE7jlltsuaGPLls18/vnHvPrq69TU1DB37mt06ZJOTs5RXC4Xzz77Ah07dgJg7dpVfP21N4VUUFAwjz/+NIGBgdx++0zuu+8hUlPTeOedeWzYsJaVK9cDMGnSWN5//2MqKiou2/bvwRXHYW3evPmCf5s2bWr7/6+KQyxDGB6BUCSi5RISQgCG1asJee45zIcO425qxu/a6/C4XNgKCxFptIh8fS9aTz14MEKlCnFoKLb8M0giI9v2tW7ejDQurt22i+GsribgnlmoBw70agIC4tBQgp55Gk98HNbduxEKhbgbG/C4nCgzuiEJCcVRVY1h/Xp8xo65pCOJaccO1MZWzIYW1r33xrkRQxCmpiZMzd5YJ7/gUAoPHyCicyoaXQBV+XlEdE5l+F0PcPbwQfRR0UiVCg78uJgJjz5D1q13c+DHxaQNGcn4vz2D3Wqh26jx6CKiMDTWk71yKZZWIzWF+ZzZt5PTe3agUKlJHToKqUKBx+2hQ6++iGUKlrz0NNvmf0RDUR4r5r7Cpk/eY9zDTyFTKNnz3ZfEZ/Tg6NqVrHnnddS6APb+sJATWzcy5Ja7yNu7g6S+A4jv3gu7xcSGj96mx4RraCy/+DreT9SWurGaWjHU17Jv8UKOb1mHVCHHampFIJLhNrfgstsoPX6U9FHj8Y+IRuWn4+T2zSh9dWz/6lPWvvMGpqYmdv+wkBVvzMFhtSCWq5D6BRPepRdhHVNwu9z8+PrL5G7fQl1ZCX2m30jG2ElUF5wmIDKayJQ0slctRxsQiEgsRunjg1AkoamqEv+IOIJiEyk5cQSRTIU2NICkXpdWpIntoqfkZCNul4e8fbVsX1iFSBpAfEZPTM3NZIwdS3Cs6pL1AZR+SrQRiQgkf231B0N1xQXG6ifqS4swVFf8x/tgNBr59NMFfPHFV3zzzZfU/ixlEHiTO3733Te8995HhIdHAFBSUsyoUWP4+uvvmDJlOh9+6A03OXu2gHfeeYs333yXb775npSUVF555QUAMjN7cPCgd9nh0KGD6PVBFBUVUl7uDR4PDg65bNu/F1dssMLCwi7776+MLTgSl8HQTsz2gjKnT2M9dRLDjz/S8Omn1L7+OpbDh/EZP56GTz8h4L57UXTt0lZeIJXiO3UqkrAwqh5/HJ8xoxEHBhEw6+62MpajR2nduhXfqVMveVxFly6Ig4Jo3b4dt8lEwD2z0D/0IEFPPYmjuoaGu2ZR9+pr1L31FnVvv4MqMxN5airy1JQ2aSncHnBeOoePZc06ugwfjdvlXbDvNeU6Nnz0Nk2V5XTqP5hBt9xFatYIzM1NGBvqic/oiS48EmNjA50HDKbg4D6aKioY/cCjHPxxCS21NYx96Any9+/CbjETmpBEQ0U5+ft346MPYthdD9Bj4lRsZjOTHv87HXr3Y+Nn72MxGmiurmLHN5/jtNoQy5SkDRtNRd5JVrz+Em6Xi97TZuByuvAIYNDMO6gtOsvoBx/FbjGTs3EtmgA9HfsOZOeiBcSkphMYHUdUchdi0zMxNTXx/fNP4nJceuoLQCLz4LTbObRqOZ0GZBHXNZPV817D3NxIQ9Fpls15jtamBiY+9hzJWaNQB4SSMng4aaMmIhDL6DZ6Is01Vax44xUqck+QkjXcm4ajuRGXW4BAJEEqk9F72vWIJBIGzbyD4NgE7OecfY5tWEv2yqU0VpTj8bjZ8sWHyNUa6kuLsFlaSR8zBZtJitUSjk/wWBrKBdhNTjr3DyM6RYePXkHm6Gi6j4mh+9gYRt2dgrHJ2m70ZTbYKTnRhFgmw9BQR3N1JeEdvKO0ixGa4IPST/o/4Wxhbb0wmWK7/abL7/89GD58BAC+vn6EhYVRWXneSH7xxadkZx/g7bc/wMfHt217eHgEyckpAKSkpFJRUQ7AoUPZ9OzZm8BA71Tm5MlTOXToIC6Xi8zM7hw8uJ/m5iZEIhFZWUM5cGA/Bw/uJyOj+79s+/fiig0WwPLly5k+fTp9+/alosJ7gebPn/+XHmGBN9JeqLl8HIhIp8NlaH+jNn31NbK4WNwWKzWvzEHkryPktVfRPzybgFl3I++SRtNXX+FxOGj4+BPq33uP1p27CH7hBcTnpK9MO3ZiOXbM66H4CyTh4WhGjKDiodl4nC7Ugweh6NIFZb9+3rxVn/wiCZvTSc0rc/DY7dS98SbGNatRJHdGILu0GgWAp7WV+tJi1H46BAIhmz/9gH7Xz+TA8sX4h4VTcfoUdquFk9s34xscSrcxEzi1YwsbP3qHk9u3cGD5DxzbuAaL0YDTYSd75VI2f/oeQTHxZK9YQmtTIx63m5LjxzA1NqILj2TJy88ikck4vG4lP/7zJTr3G8SRtStZ9/6b9L9uJmKlGqFcTVRKl7Z+agP0NJSVcmLLOrJuvouDPy5BJBbRVFXJwJtuJ2XwcOxmM4Gx8cR16wFAQEQEco2W0hM5ZN02C7fbiUhigsv4DcSk+dF1xFisrUacDhsytYbWxnp2LlrApk/fw9TciMNqQ6ZSY6gpp/zYfmzmVlqrK6g9ewp9VMw5lQgQS2X4h4QREBGNOjgckcCJo6WGpa8+S9GRQ4x/+Ckq8k5RdvIYan8dYpGE1KEj6DFxKhKZjIE33kbqkJHUl5ZQX1pCQmY/6kth+euH2fltPkc2lLFlQR6ndlRQX2ogZXA4HXoGc3RTGQdWFXFgZRFbv85DF6ImKqW9eHRxjpnm6kb2LV6EWCrDUJtLz/F+SBXtVxRC4n3oPSUez296qvz5kP8LhXO56t+PGROJvB6yP2G3txcY+HnM2E/q6z/RuXMypaUl7YyYt460XR2n08XF+HnIUkpKKoWFZ9mxYzsZGZl07+4dcR08eIDMzPMG69e2/Vu54ltr4cKFvPrqqwwYMACj0Yj73CS1VqtlwYIFv2vn/htxhUehSE+/5H6fsWO8Gny/oHXbdlQ9e3rVIjZvxllZRd3cN6ib9xbNCxcR+OjfkER4h+wemw37mTOIgwIJevEFwt6aR9g7b6Pu3w9nXS2h//wnAQ88gO+0qegfehDNsKFeV3eXC/O+fYj1egRh4djq6zD/FIR7ESyHDyNPTsZRUUnNSy8hjY+/7LnL+vVFIBIy/pGnGH7X/YhlMvzDIonL7MGuRV8iFAjwCQxi8Mw76TP1eqQKJeP/9jROu42TWzei0QXQqX8Wq+a9Rq/J1yIQCjG1NCNTa2iprWb1W//gyLqVVOXn0VxbdW49S0FgdBwpg4bidNjZ8NHbFBzcS2zXDECAACHWhgpWv/1PxFIZcd160FhZTuHhA0hkMjZ+8h6m5iZiu/VAJBaTvXIpDpuVYXfex+bPPqAyP4+Wulq2LfiUAz/+wPEt63FYrYQkJHF610oyR1181iCuawBanZTqokImPPYc+ft2c2rHZiY+/nfsFgs2s4nM8dfQWFVOc1UFS+c8h81sIn//bpa99neUGi0bP34Xi9FAZHIaTruNvYsX4bBacJpaaCw+jUAInfoNpuzEMZa+9jyJvfqy/evP2fjxu9ht3heD+tISpEoVR9atwm61YDO3YmppxmaWsuXL3HYjnZi0APThWhAIqDzTwoGVRThs5x8oFqODrV/l0aFHMMKfjaDcbjdBsQkMvvlOXHYbOxd+zqFV79C5dws9xmoZfGMCYx9Mo/8NiQgV/yPWCtAGhxEQGXPRfQGRMWiD//0Zp/DwCE6ePAHA1q2bsfyL7OQ/p3v3njz99HM88siD5OX9a9+Cbt0y2LdvD3V1dQAsW7aYjIzuiEQixGIJnTun8Pnnn5CZ2YP4+ASKiws5fDibbt3+/9SNrtjp4uuvv+all15iyJAhfPzxx23bk5OTee21137Xzv03Ypep0T/6NyruntVO/BZAnpyMQCJpl3H4Jxzl5Si7n/9iPT97a7KeOIG9qBDtmLGIA/WAAGd9PQKZDOPqNbT88EO7toyr1xD4wvNo0lKpm/cW1pwcACTR0ejuv4+WkGAkTivOkguTTP4cW34B8o4dsZ444ZV/AmSZGdgOZl9QVqjRQKckQmu1rH53LkKBgAEzbsHlctJz0nTiM3oiV2uwGFpw2GxI5QocNivVZ8+7g1sMBkRiEf2m38jxrRvwuN14BAJ2fP05w+68n1XzXqO5upK4jJ5Ed+lGc3UV4x9+imWvPc+o+/+GPiqG6oIzAMR0zWTXt1/S//qbEctkJPToTVhSZ4LjEvANCiEwNg6r0cjAG2+j5PgxpCotARFRRKV04eT2zeTt3g5A2rBRmJubKDvlFQzuMXEazdUVDLt7NrWFp6nI3caIO8dxbHMlDRUm1L4yUgeHERChobGyFZMhk8p8BSlDZqDycbPjm/lt7tzH1q+mz7QZ1JYU02XEGHI2r8NYX0dEcipCsYiE7r1I7NUH/9AIEnv1o6myHIFQhN1sxuV0YjUaSeozAIfdhm9gMGf27mLIbbNoKC/FZjYR0zWT0IQOOO02NDoduvBIjm/ZwLA77qc01ww/M1YB4Wo0/nL2/VjIgOs6cGLH2UveF8c2lxHXTU/+Qe96SFx6ACp/CT76FGqKCpAqlPSYMBWX08Ge715n1P1/QxmQ+D8xDfhzhFIlw2fNZv37b1Bfel4B/ycvwd/Dtf2BBx7mjTf+wYcfvk+fPn3bTe39Grp0SefFF+fw5JOP8txzL162bFxcPPfd9wAPPngP4HW6eOKJZ9r2Z2b24PDhQ6SmdkEgENCpUzIlJcX/r1nmr1iaKTU1lbVr1xIWFkbXrl1ZsWIFERERFBcXM27cOHLOPTz/zPwauRhlyWmsJ05g3LQZoUKBZkgWtjNnaPrmwvwzAKp+fRH5+WNYsQIA/SOPUDd37iUVPdWDBqEZPx5PayuuujoMa9dgL/YK4mpHjULo74+od2+EchXU1eBx2HFrNSx++zWM9XX46IMYkNEHxyuXfolQ9uwJgHmfV8HB/777kATqMW3eQuv27W19k8TFoX1kNrUCF0c3rMFYX0fHvgMxNtTRqX8WUoWC3J3b8AsJ5cTWjaQOHcmhVV7PtiWvPIN/WAR9pt/Imrf/icrXj6F33MeGj98mJL4DqVkjqCspInfnFqrOGSOxVMboBx5FJBJzYvtGhEIReDzk7dlBaGJHaooKEEukjH7gUVS+OoRSBeUnsik8dJDuE6fgcXuoKy8lOCYOY0MdpsYGinOOUlOYz6QnnvcqP3g8+AQFM+6hJ9izeCFns70LyjFdM+g9dQYSnyCqTh6ktb4WhCKiUwfRUGlDq1NQcaaJyvxmJFIRsel6nHY3e5YUMOzWDmz5/Gn6XTcTla8fS155loE33k5wbAKGhloMtTXk7tpGrynXYTEYsBiMFB45QM/J0zm2cQ36qGgiO6Vht9k4s3cHzbXVDLrpDk5u20RxzhEGzLgZh9VK7u7tdB4wBLWfPx48mJqakMg1uBwKGipaUPpoEUlUHN9WTn2ZN0ddz/GxHFhZhF+oiq5DItg0//Jv3L0nx7NnSQESmYgxD6Qh1YpoLDrJgaXfMWjmHTjsdjZ+9DYj73kIhT4Ut+fyupK/5K8kzdQWh2UyIlf9d8Rh/Zn4j0ozhYeHk5ube4GDxc6dO9syEf8v4NL44KitRTNsKIglWM+exXIZt3Pt2LGI9Xpk0dF43C5EWi3qIVm0brz4up/vtGk4UjMQW80IC8+gwQNuNx6XC1F8AsJOqdjFQppLC1BotZw5eIDQDh0Zde/DfPvsozTXVGHRqJAH6nHW1l30GKpePdtlARZ63NQ8/wKq7t3RP/QgHrsdkb8OUjpTb25FIRIhEovpdc21+AQGs/qtf1B46CDB8QmU554krlt3guMT2bf0O8Y+9Dhnjxxg7OynMLd4nTBG3vMQ5hYDxceP0GfqDBrKyxCJRWgD9NQWF5IxdhLRqV3Z8NHblJ067vXcy+yJxl+PsbEOgVhE+ohxmA0t5Gxai8pfD2I5LruF0MSO+IdFkr1iKQ0VpYy6728c27iWwkP7ybp1FkqtDyPumc26998Ej4cuw8cQntSJkzu2kDZsNBljJ1FbXMTWLz6kU/8sApRaAmM7cHzTOpRaX0SyrvgHa1n/yQls5vOOKaWnGgnr4EevSXFs+TKfcY+8hrH+LIdWL2f6C/9EKBLS2tDAgeU/UFN0ll6Tp7Pty09pqanm2hf/Sc7mdVTnnyG2ayYOm5WGijLkajWx3Xqw/oN5fPvcozhtNmK6ZuJyOFj99j/JGDuZs9n7ObVjMyNmPYTTIab0lJvT+0u936PIgFIrJS49EI2/nKJj9bhdHnThajr0DEaqvLxxEYoFKDUSQuK19Bgfi1QrxuPx4B/dkWF3PYhQ4YNMKGL8355FKNdcsbH6qyGUKvGNTPiju/E/wRVPON9888288MILrFmzBoCcnBw++OAD3njjDW677cIYgL8qdl0wyv4DaPnxRzwWMxK9Ht+pU9qcJH6O7rbbEKlUNHzwIW6LmfoPP6L62WeRxcah6t27XVmBXE7Q83/H1TEFl8uNTSLH3iEV8aRpSMdMQDrlOlwZfXCpNJTnHGTlG69wZt9unHY7a955ndLjx9BHeefVt69cgt/fn0OgvPBtTztmjFeV49wapLxLGoqu6YS+8jK+116L02Ck/t33qHnhBVyFhax+6zVO7thCWIdObP7sA/IP7GXUfY/gdNgpzz1JYGw8unMpO1Q+ftQUFlCRe5LmmiqKjmbjFxyCQCTCbjERGt8Bj9uDRCbjyLpVbP78Q0be+wiNFeW4nE4G33K3VyXCZMZps1OVn4dQICIwOpbjWzbgdrlIHjSM2rOnqS88RfGxg+Tu2o6xoZ6guASaa6pZ+NRsTm7bSEhCB7SBgUSnpdNcXYnaz5+ht9+HVC5nzbtz0YVHUpF7gu+eewylRsN1L81FJJWQu3UtpoYa0kdPIHnwBELidBxYWdTOWP1Exekmr2edQEBNUT31pc2EduiH0y6jsaISoVhM5vhrGDzzTo5tXEtLTTXD7noAgVBETHoG4ckp2K0WDHW1OB12Vr/9T3Z/9xV9ps3AeU7Fv+uIMWgDg0jq05/slUs4tWMziT374BMUgs0Sxun9DUjkIjJGRZMxKpro1ADkKjGd+4USEu+DUCQgMTOIXd/nIxR5pwgvRXx6ID5BUvpfG4nUV9Imcu1BiEDpj0cgwuPB+7fwf9tYXeX/lyseYU2ZMgWZTMa8efOwWCw8/PDDBAYG8uSTTzJ69Oj/RB//K/F4wB7fmYA5/8CVfxqBB8yHsvEZNxahUoWjshKhRo0sPh5RYCDVTzyJs74eaUI8kfPnY6+pwWOz4TdwIH6334azogKBVIY8MQGzPhSHu717mlMogZ+9Gbs9EJbUifBOKRxd540Li0xORSgWE5mcxqCZd7Dxk/c4nH+KDq+8iLCgEHdODmJ/HfKEeMzZh2jduhWEQvQP3I+tsJCyO+8EpxOBVIp23FjC3nmbivvux7J6DT0nTWfPD98A4B8WQaf+gzi57fzosLGslO7jJlOcc4Qht81ixdyXEUul+IeFI1erObx2Bb0mX4dEqsBhs1BfWkxoh44c37qB3lOvRxsYSEzXbuxcOJ+mqgqG3HYPB1d5XbbHPPgYuxZ9SXN1JdFd0ik5dpjGqgpKTxyjy7BRBERGU51/mqCYWHRh4QRGxbRJHXXsN4gdX3/hXfcxtTLpiee9UloCb7Dzxo/fATiXrr6SwiPZnN6zA5lShTYgkOqCM0SnD8bZZKO5+tJu7id3VtKxdwhul5QjW2S4nW7EG8+S2MOXmFQVal8pOxfOp+ek6exb+i3aAD1LXnmGDj37IQAOrVpGcFwipuYm5Co1fabNYO27b6DQaLEYDexf/j29rrkOn8Bg4jJ6cDZ7P34hYbhdCo5uLkUiE9FrQhz7VxZiM/3MqAqg96R4AqM1bP3Sq2PZVGWmU99Qdi8pwOVoH9mr0EgIitFirKtGG6hDJBNckJXhKlf5o/hN+bDGjRvHuHHjsFgsmM1mdDrdv670F8Tj8WDzC4TugQgEoEjvjqiqHGdpCYqICMTBwQh9fXGcLUA/+yFEAXoIj8Si8cMTlQhAm+tFfDICAcgDNLTW/7r4DaFcS1BMHOXnHAZCO3TCPyQMT3AoVQX59J02A6WPL/kH9pB7dM85dQUnzqo6UOchT03Fd/o0mhZ86VWJ/+m87HZaFi/BXlyMfvZDtG7dilanb9vvExiEUCQid9c2Err3JiVrOKvf+gfHt2zAPyycurJiRt4zG4lcwZ7F39Br0nTSR4xj25ef0HPSNARCIZoAPS6Xi7EPPUFTZTkiuQ8hCUn4BoWw+q1/sP5Dr2zUwJtu5+i6VTRXV6LQ+tBn6gyW/+NFTM1NiMRiOvUfjFAkwVBbi8rXnxPbNlJbXOjVz6utZteiBXQZPobyU8fpf/3NbJ3/EUPvuJ/KM3nEdOnGqR1bAEgfNY4j61ZRc/YMQpGIsQ8/yYrXX0bp40+HPlNpbXbRdXgUUrkIQ4OVU7sqL4hXkqsluJzgdnq3Ox1uTu1qpKnahsb3BIa6WiRyGVp9ECU5RwiOTyRn8zpytqxHgIDgYQmc2rkVgVCIx+0hvGNn4jN7UV9aTNXZM9SXFHFwxRLGzX6SpqpK9i/7npDE/jisLtKyIji0rqS9sQLwwJ4lBQy/I5mOvUPIz66h/HQTAqGAXhPjqD7bQumpRkRiAbFd9GgDFNgtTk5sN2I2NtChezBxmYFItaL/OaeKq/z38ZsM1k8oFAoUir92NPuvxeMBp0SGMzIOIuNwAW3hxeneQLy2z7/DD18ogNLjBzm0ejlhSZ0RioT4BYey4o1XiEpLJyGzFyvnvUZ89170mTqDuIyeyLW+uJ0OBAHBKNNSkQrEOLdva2esfo4l+xD+N96Iz4wZrF00H11EFD76QAoPH8QvJIxJTz5PQ1kpjZXlZN1yF74hYQjFUoRiIXgEVOSdoOxEDsb6epw2G2ZDM01VFViNrfgEBbFy7svoo2IYeteDCKUKWmrLweNColBgNXmdBWQKrwgrgMXQwtlDXiWNvN3bcTmdNFdXk79/Nx5AFx6JQqMltlsP0oaOxFBXw8ltm7GZvdmfy3NPMPzuBzmybhUafx0HflyMf2g4FqOBDR++xaCb7sBQW43FaKC+pJjEXgPQBPRizYd57YyTX4iS3hPj2LO0oO0hHhChwWywe4e+v6CqwETkuGT6TNMSlpSMXKWhubqSzLGTKTl2BDweQjok4bDbiOvWnQMrlrB38UIG3HArHreb4pwjJPUZgNXUStats6g6e4auw8dQV1qERCEBAWgD5JiaL539ufBIHU1VJsKT/GmsMhHd0Z9D60tQ+chI6hXszYJ8shGlj4ngGB+azo0mc7aWk7u3itH3piL1+bceF1e5yr/NFd+BTU1NvP322+zfv/+iGYcPHDjwu3XuKpfG7YGQ+ERSsoYTEp9EQGQUNYX5dBk+hqPrV1Fy7DAaXQCZY6/BI/NDEegHgOin+gA2M+bsC13Yf475YDb2sjJGTr+JWmMLTrsNv5BQ/ELCWTbneWK6ZqCPjKalphptUDC4nDRXVSOSSIno0ovMcdUcXLEEgH7X3kRDRTmBMbHoo+Podc21lJ7IAbcLj82I02rhwI+LMdbXkTZsNKd3b2fTp+8xdvYTqP0D2PzZ+xQeySaxRx9GpWdyeO0KagrzQSBA7eePPjYOpa8vcSIxCl8fqvJPE5mcim9QCB37DSJ351Y69R9MUp8BuJ1OIpPT6D31elxOJ7sWLcDj8TDgxts48ONidi6cz7hH3mH1+xd60zVVmSk4VEt8tyDys73GtHPfUOQqCVWFzaRlRXBsc1m7OhajhNO71qPU+rBz4Rdk3TqL9R/MA4EAH30gladzCU3oSERyKv3VGvxCw5BrtNjNJhK698LU1Mj+Zd/Tc/J07GYLm5d9SM9J05BIbHQZGoHbdfm3oJY6MypfGcc2l9F7Uhz7VhaSNsgb91dTZEAkEZAxOpqmahOH15W2q+u0uynPbSQuPRCBUIBYIcThdF0dcV3l/50rNliPPvoopaWlTJ48mYCAgP/KBI7/K4g0QaSPHIfFYGDXogUMuvlOPD9TG9UE6BFJLq1e4ZFIQHL5W0AgFmE5dAi5WEx5oJZ+M29nxzdfcHTDGqRyBbHdMmmuriY2PZMze3ai1QdxcMVibCYT0174Byd+ts51cscWuo0eT2BUHCj8SeidRUx6DyQ+wYAHn+BQel0znebqKqK7ZpCQ2YuqgtOo/QMQiMSkDBmJUqPFZjax8eN36TFpOqGJHRCKJUjVfgiEItRBChzGJuwmEyo/f+QqFbqIKEQSKTFdunHgx8VkjJmMRudP9wlT8HigqbqSQTPvxG4xYzUa6H/dTFwONyd3VV3yutQUG4jpoufs4Vp6TojFYrTTVGPi0JoSgqK1pA4KJ2freVkauVqN3WLG1NyEVh+MTKlGrtHS65rr8AsJZd+y71HrdHhcboLjE3DZHTRVlnN49Y80VpXT77qZ6MIi2Lt4EVOfm4NACGp/HQKBm9A4X5prLi8j5R+sROkjIyTeB48H+kyOp6bQQOGxOgLC1KSPiKah0oTb5UEoFrRNa4bE+RDbVc/ZI7UcXl+KXCUhqWcIwXFaFD5SRMr/nUDhP4IJE0YjlUqRSqVYrRZiYuK44YaZpKb+6wzq27dvRafTkZycesXH/fbbbxg6dDg6XcBv6fZ/jCs2WNnZ2SxatOgvm0bkz4ZH7o/U5aHHxGm0NjawZf7HaHQBBCd0IH/fbrJX/ECPqTfhEV04dWsTSlD37Yth2fJLti8OCMBtNGLevJmOzz7Jjq8/xz8sgrKTOViMBmrOFpDYow+n9+9CLJGy7ctPQCBg7ENPUl1wGpuplQEzbsHpcLD7+69x2u0UHc0mccBI3FIVYqmqbZQuUuvx0+jxCYvFI1agCfdDpQ9FIFWA241MpcLYWI9YImPcI0/SVFFBU1UlgXEdcDvt7Pt+ARljJ1NXUkTpiWN0HpiFRKGiIvckB5b/gKm5CbfLyY5vPmP4XQ+w/J8vEpmcho8+iC2ffUiX4aMJioun9Gg2QTGdaay8vNS4Qi1hxJ3JlJxowOlwU1fiXXusKTYQmaxDLBXitHvb8AuWMnb2ExxcsZSawnzKc4/Td9oNSJVK6kuLSerTH9/AEI5tWkPeLm9Qs1yjZdxDj9NSV4vDamHYnffTXFuNtVWEPmY49WUtIJDgEyggMEaLUiv1Tkv+AqFYQGKPEPYsKcDUYiOxezBOhxtdmIqYrnpMTTY2fXEKU7MdjU5O70nx7FlcgCZATlgHP3YvLmhry9xi5/D6EgLC1USnBRCVokOkumq0/pO89NKrJCZ2ALxqF7Nn38e8ee+1afZdiu3bt5GYmPgbDdZC0tMz/vwGKzY2FqvV+p/oy1V+I0KVDpUmAGdrI2lDR9FpQBYShQafwGBiu2aCWHHJdTNRQhKKzO5YDl44laseNAjz4SPeDx4PWpmC5ppqOvQZwKh7H+b41o3UFhUgVSqJTulK1Vlv4K9AIECmVOEfk8C05+MxNTXiGxZNVGo6ppZGNIHhuC8hOOf24O0v4HJ5cNmtNOSfRB8dg73VhKG2ls4Dh9BQUUJNSSHdRk/EabVgtZgpPJxNee5JAiKjKT91HKlCQad+g/APDUMslXgVGbRadnz9BS21NaRmjeDIOQ/LoNgEkvoM5PsXnmDSY8+Rs2UTSm1fDPWXvtelSjECoYDgOB8kUhHhSX7sXXYWc4udkhP1hCf5U5xTT1SyBqXGzamdO0keOARrq4HCQweJ69aD9R+9TcboCUikMmwWM77BHRj3yGjkaikr33iO/Oz9xKV3RxkQjEAgQmHzYcMnp38mqVSPQAD9pifSa1IcO789g93aXr8t68aObPkyl8AoLdGpAZzaVek1bAKI7OxPl6xIgqK1FB6tx9hgJXd3FQmZQfgEKji07uJqKfXlrcR00XNiWzldx0Thvjo/+P/CoEFZnDp1koULv+KVV/7BwYP7+eij97Hb7TgcDq69dgbjxk1gz55d7Nq1nYMH97F69UquuWYaffv245lnnsRkasVut9OtWwazZz+KUNj+t/jZZx9TX1/H008/jkwm47HHnuTRRx/miy++IijIq/T/wQfv4HK5uffeB5gwYTRZWUPIzj6IydTKhAmTmTHjJgBKS0uZN+91mpoasdvtTJgwiSlTpv/m879ipYucnBzmzp3LPffcQ0JCAhJJ+zgMtfrS8R1/Fq4k+v735LdE//8SkcCJy+N9DxF4HCCU/Mu2FA1VWLZsonHBl7hbWhDpdPhOnIjLaKT5u+/ayuk/+gBbcBCmpkZWzXuNriPHIhKLkSlVqAP0NJSVIBAIOLLWawSmvTgXodIfoVCA+5wzws//viROK267BYlKi7mhCqFAQNHRQyjUGoRiMeaWJmRKJT6BIVhbW1H6+qLy8cPYUIfL5SR7xVLkGg2hiUmIxFKkcjkKrRZDQz0SqRSl1pf6shIsrQaOrlsFQFy37vSePhObqZXiowc5tPpHht09l61fFV20ixp/OT3Gx7J94Xnj4RukpOf4WA6uLsLl9BAS54NC7SSyswanvRmVnx+lJ46j8vXDLySUhvJSNnzwFmKZjN5TZ9FYrSY/uwWXw42PXkb6iHD8At14hC4k2iDcFjcr3jyG3XIRRX2Bd5rPYXXhdnsw1FuQqyWo/GQIBQJy91QRnuRHzpYL1bNlKjF9rkmgrsTA8W1eodSeE2JxuzwcWHnx8wcIitEiV0nIGBt9xVODfyWli/8kEyaM5h//eKNthAWwbdsWPvzwPb79dgkGgwGVSoVIJKKlpYWbbrqWjz/+gsDAIF544TkSExOZPv16AGw2Gy6XC6VSicvl4tFHH2LEiNEMHTr8Xx73gw/eBTzcffd92O12Jk4cw6efzickxJuXq2vXdJ599gVaWpq56abrefHFOXTunMytt97I3//+EtHRMVitFm699Saeeuo5OnXq3Has/6jShVarpbW1lZtuuqnd9r96Asc/Cz8ZKwCPQPKrPBItuhBE028kNDkFa84xXAYjzUuX4mo8n0hSmpjA8RNHiVT3xmI0oNBqObzmR0RiMZOeeB6RVIpEKkcXFUt4x2Ram5oQKXzwQDsD9a+Mlcdp48zODZzevZ2R98ym+MhBcjavp//1N7Phw7eJ6JyCQCDwTkueOkFUaleW/+MF+l83E4lCwaZP36f/dTPJ270DfXQsLrudLV98RK/J05FIJOxdvIhhd95HcHwiK+e+QlBcArHpmRxe8yO5OzaRPGg4MV0ziOmSgamlkaRegeTtPZ9jyCdQQVKvEDR+Mgz1FrqNiKLgcC31Za0015jZ8NlJht/WmYozTcR2lbFz0YdYDLF07DuQ6rNniezSA5fNTHVBLoaGegbdfCetjXaO7xBibDivTdlSZ2PrV2fJGBWC036UuG49MTQoLm6sADzQUmehpc6CXCXG7fZw5mANQoGAmLQAEjKCOLjm4sbHZnJSV2JAqhDjE6igpdaC2+ldy7ocTrsboY8Ap92NSGLG7XAiVPqCy47bZkKo9Lts/av8Nn4+xmhpaebll5+nrKy0zWidPVtAYOCFAgYej5v33nuLY8eO4vF4aGpqIjY2/qIG65dMnjyVW2+9gVtvvZPNmzfSqVNnQkJC2/aPHTsBgUCAr68fAwcO4uDB/Wg0GoqKCnnmmSfaypnNZoqKCtsZrCvhig3WI488gkQiYe7cueh0uqtOF38RXC4P4shozAsXYt62rd0+oVaL72OPsnPpQuIGZpGzaS3mlmbiuvWg8PBB1r0/j8lPvYDMLww3AjThHVCHOvEIRBc/2GUQiMRo9UE0V1ey+KWncdis+IdFoPbXIVHIKT1xjIhOKfgEBnF8ywai09JRan3Y/rU38aRWH0hgTCx7flhEac5RolK7YjO1smPhAjweN3jA7XJRcjib0Q88ikLrw8ntmxl+14PIVRqWvPQUY2Y/QX15CRs/fJuuo6Yy8q4hFB5tRK6WoFDJyF5TjPNcwK1QKKBj31B8g5QUZNfidnkoOFxL5/46rC2lZI6djM1s4uj6lZzasZWek6+lIu8kZSdzmPjYc9SVlqDy74ax4eLG5PCGavpP64BIKsXcYqFzv1DUfnLcbg9CkYDinHpqigwExWgJiFBjMTpoqDCh8ZfTdUgkNUUtSOViPG5PmyPFxSg92Uhooi8JGUHkbCkjOM4HS+uF62E/JzTBl/LTTUikbkoO78NQW0OXkeOpPH2SkpwjZIybglD1vxmj+Z8kN/cUcXHezAqvvfYKvXv35dVXX0cgEHDjjddht1/8e1u48Buampr47LMvz4k/zL0gXcmlCAwMpEuXdDZt2sDSpT9w++13X7b8T1notVotX3317ZWd4GW4YoOVn5/PsmXLiI2N/d06cZX/DmwqX3wffwrt5Mm0rvgRd4sBVVYWJCVi1/kz7K77sVssdOqfRYfe/YhM6UpYUieaa6q8N6hAAJ5zb4C/wVgBIBARltyN2PTuFB72rqv1nX4D5bknsJu9nnBlp47TZcRYwjt25tSOLXTsN4jslUsBSB85DqlcybiHn0Tp40tjZRmZ469h35Jvz7V1IyKxhLOHDlBw+AAB4VGU5BxGJBZham5GqlR605D8uMTrcq7TcmbPd+giY9AGdGfT/Lx23XW7PZzcUUH68ChUvjJMzTZKTjSS1FPB8tdfInPMJLT6QDr2HUxtUSH7liwCIGXwcMQyOcGxHdi38uJaj+ANQm5tdFJ+agkJPaZzYls1LXXeFBMCoYCEjEBiUgNw2N1s+/p8PF1jpYmSEw0kDwglvKMfNUWGf3HdweVwIxAK6D05nvWfnCAwSktMWgBFxy7MPiCRi1D7y4jvpsNQm0/hkYOUncihrrSY2uJCovtkUe+RIXW48ZWJLhqfdpUrZ8eObSxd+gPz5r0HgNFoIDg4xDsVf+QQBecEpAFUKhWtra1tn41GA/7+OmQyGQ0N9WzZsolBgwZf9Di/rAswbdq1PPnkYygUCrp379Fu3+rVK0hP70ZLSwvbt2/lhRfmEBkZhVKpYtWqHxkzZjwAZWWlaLU+v1nh/YoNVnJyMtXV1VcN1l8Uu8oHuvRAndEL8I68BAIPYrd3NCE2ex/qYqkSj8dDWKc0wjt3wT80nPpfqdBxWdwOSo/uo/DwAeRqDdZWIzu++YJuoyagi4hi0Mw7OLZxDfWlRTRXV5GSNZydixag9tPhcjnZ/vXnXucKH38EYgkKtXfqUigS4fF4yF65lLEPP8mAmXew+s05mBobiE3PRKZU4xcSRpdho1n15qt0GzMBgVBIcGwC4cmp2M0Kdnx36XQtJ3dV0KlPKEc2lCKWCKnKP4VGF0BoUkcOrlhC5wFZSH+m6SiRy8nZvI6EjL64XZdf/5Eq1ST1ncK6D0+1jewAPG4PZw7UMOjGJPZ/lXfRuie2VxLZWYd/qAqRRHiBFNNPRCXrOHu41jtqymvCZnZSlttI6uBwOvUJIW9fdVusl3+oiuT+YTRWm0jM1ON2yhl8ywOs+OdzhHfpjt/4u3hvdxnHPjqMVCRkSrcwpmdEEKy4Gnj8W3j66cfb3Nqjo2N544132jwEZ826n3/+cw5ffPEJCQkd6Nw5ua3eyJGjefHF59ixYxuTJ089Z3Ae5dprryEgQN8u8eIvmTr1WubMeRG5XM4zzzxPYmIHkpNTUavVTJgw+YKZNV9fP2666TpMplauuWZam9v93Llv8eabr7No0Te43W58fX15/vlXfvO1uOI7aMaMGbz88svceuutJCYmIha3b+Kqu/tfA6fzZw/Gcy/HbrcHgdwHidz7diTAq578e84Kezwe7FYLAZHRDJ/1ECXHDnNsw2p0EZGkjxhLQ3kpHXoNoL60ELlWS1BMPAER0aQNGYlfaCjbFnyCUutDSc4hCg8doPt4b7qRCY8/j9vlZtWbL2NtbaXi1Im2Y9YUnSUqtSvZq5ZhN5u9+aX8AzizfzeagECUGj31FY7LxjrZTE7EUu+osmPvEMSyJmK7ZmK3Whl44+00lJVQeTqXftfdhFylYfPnHzDqvr9RdGQfMWkjaaw0XbRdgQCC43QUZLe0M1Y/IRILMdZbL+u4UHaqkZB4H7qPiWHvsgvzYCm1UhQaKQERGnwCFWxfeH6klrOlHH2khv7XJiKWiBAIvKMroUiI2+VmxVs5OO1uguO09JwymzKpiDu/O9lW3+5y882BMtafqmH+jRkEXTVaV8Ty5asvu79Hj54sXvzjRfd16tSZRYsWt9v2+edf/arjjh8/kfHjJ7bbVltbS0tLC6NHj72g/PDhI7nvvgcv2B4eHsHcuW/9qmP+Gq747nnooYcAePLJJ9u2/TRfedXp4ir/LgKRlNgeA4nu2h2hwpe47n290lMSKUHxidQWFyJXKQlJSCI4PhG3202/a29EKJHQUldDQo8+LP/HizisFmK6ZqKLTmD6S28gUvnj8Xi49sU3sLa2cHT9SpIHDSUoNoEtn39ITWEBwXGJ5O/fzfC7HqC1qZEOfQYgVSgxNtqxW4SIxEJczkvHZgmFAlS+MvRRakqPVaHy9cNuNrH7u6+ISu3KNU+/REN5KdmrljHu4aeoryijU//B1JXWIFdJsJocF7SZMjCE1sZaynIvYtAEEBTr9dS7VH0AU4udQ2tL0AYoGHxjR7LXFGGotyIUCojpEkBwnA85W8vpPy2RqvyWdsbPP1RFQkYgjZUmWhttaHRyolJ0bFmQS2vT+fWP6rMGqs8a6DQphkCNjFpj+7WR+lY7G3JruSkjFPflw9uu8l/Ixx9/wMqVPzJr1n2oVKo/rB9XbLA2b978n+jHVa5yHpEUocKr0OGRqJEHqPB4BAgEEJqoxCNVYWuqRijw8N1zj5LYux8xaRm01NRQdjIHh9W7xtNryvUIZF43aLfbg1DowdzSSEttDRMf/ztSpRK72cykJ5+n/NQJ9i/zuvDXl5diamokwbcPlpZmnA5/io45iEvXc+ZAzUW7HJroi0wlJnN0NHZzI4fXrkAXHklDRRk+gUFE05U177yOuaUZ36AQLEYDZ3ZvRywSs2/pt4x7ZC6HN1RTntsMeGO8+k2Jwumw4bCqkEjbx4MlZAShC1dTW2yg+EQ9HfuEIFWIObqx9IIUKH7BSspyG2moMNFca2bwTR2xGB1YjQ5qywy4HG469wvFYXHiF6okMFqD2+VBoZYSmuDLnmVn27xNVb4yPB5PO2P1c86uL+OWrAhe3VFwwb5F2WVMSgtBJbrqqPVn44477uaOOy7uaPGvRoG/J1dssH6ZuPH/g/Lyct5//3327dtHfX09gYGBjBs3jrvuugupVNpWJisr64K63333HV26dPl/7vFVfk88HsG5/8EjUYEHpL7BCNw2xjzk1RkUS2VUnz1DVX4ePkHBtNTWsOqNVxj/+PMIFb54bEZcDhs7vv6criPHIZHLWfvO6yAQMvzu+8leuYQRsx6itakR38Bgjm5YDW4PZSdzUOmiaW3S0aFHEJX5zRc8rGVKMV2GRLBnSQHJA0LxC3LjHxZOQ7lXk2/E3Q+xd/EizC3NAPSZfgNr351L/xm30FBRzqTH/45HYKTneD22oYE4bS4UWhXbF+bTUGFBIhORlhVB7TkljY69QzAb7exbfn56rzy3CalCTM/xsexZUtA2fSiVixCJhTjOBRM3VZmpLTZSW2JA7SujtdHG2UN1dB0WyYHVRST3DycuPZCqgha0OjkypbfNpmozpScbiOzkT9HRC50wfsJmctLdV01SkIa8mvZrmk6X+6r+4FX+LX6Vwdq8eTP9+/dHIpH8yxHWxYzGv0thYSEej4cXXniBqKgozpw5wzPPPIPFYuGxxx5rV3b+/PnEx8e3ffb19f3d+3OVPx6BAFoqiln3/hvEdM0kpmt3xBIJUaldGHjzLGoLC6gpOE1ZzmECY2I5tnENEZ3TGHjjbWz85D26jRqH2Whg8Mw70YVHMe3vr1Fy4hiB0bEc2bCaftffTHnuCQJj4ijPO0XnviPYv6KIbiOisNuclBxvwO32ENtFjy5cTWV+Fd3HBCCRNlNbVEhjZUVbX3M2r0UboEcskeJ02Dm4Ygk9J02n6PBB4jJ7UnBoPxr/AI6sW0GXYaMJSUjm8MYKGiq8I0WHzYXD5iIgQk1ztRmNTk7ungt1Du0WJ8e2lJHYI5hTuypR+UrpNiKa/SsK25VzOVwUZHtjy2RKMamDwqktMZAyMJy9y862yUn9RPLAMDweDx16BhMQrqb0VCOXQ9Bs5x5ff1xdI3l222kMVu+Ib0xqCGqp8KrH4FV+M7/KYN1zzz3s3r0bnU7HPffcc8ly/6k1rP79+9O/f/+2zxERERQVFbFo0aILDJavry96vf6XTVzlL4bHA5qgCBJ69OXElvXk7dpGUu/+9L32ZjwSDYEd0tDq/Pnu74/jHxpOVGpXNn3yLpEpacR0zQBA7euHUCikvqSI1sZGqvPzOLl1I1m33s2pHZtprq4ieeAQCrP34XGJSB00lCObvF6A4R38kanE+AQ6OLXtM+pKCtBdNxO1XwjFRw/jow+k77U3cWbfboqPHmbADbeS2LMPRccOc3rPDnQRkexZvJCkvgOQK1U4bFaaq6tA6EdjtYSiYw3tzvfYljK6Do0kZUAYx7dXXOySANBSa6Hn+FgiO/vjsLkw1HkVL34+TegTpCRrZkeM9VYQCHC73cSkBmBusdOpbyin91e3y6t1YlsFvSfFsWfpWXz0CnpOiGXz/Iv/zkViIR4PlO6vRXa8kZfHd+C+tSeRS4RM7BJ21Vhd5d/iVxmsvLy8i/79R2I0Gi/qy3/33Xdjs9mIjo7mtttu+00jvj8qFvqn4/7ZYrH/qH4LpDICo+PaPtttNkQy1bl+CJH7BdHv+pns/GY+jZXl+IWEEpXSFYlMRnnuSZqrqzi05keG3Ho3gfEJuJwOCo9k01hZQWVeLn2m38CJbRuRyOR06NWDqoJsUvqFoI9OwWYxofEVsfKN57CaWkkdOhKxVMbpPTsIjkug5+Rp1BQWoPHXMe6RpxCJxFSdPUOH3v2ISumCXKNh6rOvUHzsMBGdU/G43Qy/+xmy19lI6uW4UKHEA0c2lJKWFYG55fIBvRajoy2bsEQmIrFHMDFpQo5uLCMgXI1GJ6e5yoxCI0EiF3FyZyVHS4w4HW5UvlLSh0dx9lBt2xQkQHWhAX2khrpSI03VZnwDFTTXWi44durgcCoLmgGwmZ24ThuY0jWMKRnhRGmkbSoNv+We+bP9Lq7y+/On9DEtKSnh66+/bje6UiqVPP7446SnpyMQCNiwYQP33HMP77333hUbLZ3uP6NX9mc5/m/l/7vfxTlH2PL5+/iFhhEUE0fe7h34BgXRZ9oNSOUKTM3OdokX3W43AoGA7DU/knXzXWgDg1CoNZw9dBBdeAQhiUmMnf0kDouZzHGTkSlVdOw7iMyxk7AYW1H5+hLeMZbWpnJEQic/vv4ObpcbhUZLzqZ1aPwDKDqSjSZAT0hiEqd2biNjzERqiwrJ3bmFQTPvoPx0LiHxiax4/WU6DcgiPKkzu7/7isyxkzE0KDA22BBeximhoaIV/1DVRVXZf8JudbXFWzlsLk7uqCAs0ZfUQWHEdNGz7sPjBEZpScgMojyvCZWPjPBhfng8cHRTKXuXnqXPlHgaKk1t7bQ2WVFqvevFp3ZVknVTR/b/WEh9uTe4VCoX0blfGGaDHb8gFf4hKnK2lFN1tIGHHk0nNPrigaJ/1nv9Yvwqncyr/FtckcFyu90sXbqUjRs3UlFRgUAgICwsjBEjRjB+/Pgrlml6/fXX+eSTTy5bZs2aNcTFnX+Lrqmp4bbbbmPEiBFMnTq1bbu/vz8333xz2+fU1FRqa2v57LPPrthgNTT8ceK3Op3mDzv+b+WP6rfSP5CuI8bRaeAwRDIFGl0g8T36YGh1IjAZMVeXs2vRAgIio4hO60b2yqUU5xwhtksGHg/EdOuOoaaaUzu2EJGcSkNpMavf/iepQ0YQmpDEDy8+SeqQEcRl9qLw8AESevTG0tqKNiAQa6sBmVJF76kzkCmUbP/mc8QSCS6ng/RR49m58AtSs0ZibTWSvXIpWbfchdPppKGshIDwSFS+fmSvWMLR9avQhUfitNupOusV/rS2OghP8qM8r+mCcy4/3cSQmZ0uug8gLNGXmqKWC7ZXnGkmZVA4Gz47RUicD3K1hA2fnmxXRqGR0OtcapHc3VXEpwdyen81AL7BKupLvSMuu8WJSCyg+/hYWmrN2C0u3C4PZw5UY2zwejNGdvIntquewiN1uK2uC4LKf8s981Od/y48VFdXcPLkCUpLS4iMjKJz52SCg8PwRir+e/wkQvvttws5eHAffn7+mM1m/P11TJw4iZEjx/z7p/An4lcbLI/Hw91338327dtJSkoiMTERj8fD2bNnefzxx9mwYQPvv//+FR38lltuYeLEiZctExER0fZ3TU0NN954I127duXFF1/8l+2npaWxZ8+eK+oTnPNG+wMNxh99/N/K/3e/BTItaWOm4j6XR7nT0PF4BOK2fsh8/Bk08w5CEjoilkrwCwkjICISkUyJSOmHUCRCLJGS2KsfDqsFkURCZEoXcjatI2fTOhRaH/xDI6jOz0Oh1VJbdJadC+fTa/K1+EdEMvzuB8jZshG1vz9pQ0ZScvwopuZmVr/1GgNm3MrOb7/E43LhsNlwu92YmppIHTycvL3ZDJo5m8Nrf6Dw0G4kMjn66DjOHKontoseh91FVLKOljpLmwH4iahkHcYGK+nDoziysbTdCFIfqSaikz/7fmzvZPETLXUW0gaHofKVX3QNymJ0cGJ7OYndg8jdU0Xnft71LASgD1dz5pzxCkv0w2FzYTM52f3Dhe7rAKWnGuk1MQ5TsxWBUHDJ++LPeq978XDs2CEef/wxnM7za35isZhXX32NtLRu/B5G6yeuv/7GNuX1M2dO8/TTj9PU1Mx118343Y7x386vNlhLly7l4MGDzJ8/n549e7bbt3fvXu655x6WL1/OhAkTfvXB/f398ff3/1VlfzJWnTt3Zs6cORfkcLkYubm5Vx0w/uL8ZKwAPIL2t7NApiWmx0CcLu9DI7xLL9we78PTA+C24bJZObNvJ9UFZ8gYM5EOvfpRevwoAGFJnRCJxThsNg4s/wEAfXQcgbHxnN69ncDYOOIzemA3mcjP/r/27js8qip94Pj3TksmZdImkISENEhCSaEXQSSAoBSlWcEVsK2FXdRdLKtIUdjVtaDoIstiw131ZwNFBEVQRAEhlNBJIIUQSO/JtPv745ghQxIEBJKB83keHzNz79x7Zkjy5pzznvf8TJ8bbyJleDWbP/sIL/8AaisrQFXpO/4W9mz4huRhN5F/VEfuwVgObjuKOXwQg+8czoGfPyY7PY0OPZOpq4SfP89Eo1VIHhKBwVNHUV4lOr2WkBgTFcW1bF6RSWCYN31GR+PhraeqtI6AUC8s1TY2/O9gkxX6IzoFotVpOHGkgqO7m8/yKzleTULfUEI7mPAN8qRjrzYEhHhzYHM+gaHeGLx0dL2mHRlpBdjq7M1eB6C2ykq3ayPRe59nXclWLj//WKNgBWCz2XjssZn85z9vERoa0cyrf5+4uHhmzHiUOXNmceutt18xRcjPOmB9+eWX3HfffY2CFUC/fv245557WLly5TkFrLN14sQJJk+eTFhYGDNnzqS4wbYX9QHp008/Ra/X06lTJwDWrl3Lxx9/zLx58y54eyT3UR+sAOwO1x9qta6aIzu2YampJWXESCpLivh26esYTX74BgZxeMtP+Aaaie7Wk4xtm+k5ahwnj2Zit1rpMWosaatXsuXTjzCaTCQNu56jO7dzdMcvDLvnIT5Z8Iy4iaKw4+svueGv89myooDjGaeGxk4ereLk0Sp6jJiI3XqIwBAD3/8vBwCHXSVtTTYanYIpyIjd5uDAz8fpPSbGmXyQubOQ5NRwflqXQ1h8AB26BzcZrLxMBkJi/dj44SE6DwijoqjxkGFDHl469AYdh7aeJCY5GEWroNNrKMytpKbCQn5GGZ36hnB4u0iNN5mNdL0mjKBQH1SHis3mEKn4tXa8/PRoPTWX5dzOnj3pjYJVPZvNxt69ey5awALo0iWRkpJiSkpKzvoPf3d31gHrwIED/OUvf2n2+NVXX827755dnapz9eOPP5KVlUVWVpZLent9u+q9/vrr5OXlodVqiYmJ4aWXXmLEiBEXpU2S+7OpWiI6JxESG0dVSSl6g4GIzonE9uqLydyG9O/WEhgWTkHWEXqOGse6ZYu56uZJaLQaPpr7JH1unEhAWDjFx3LY8M6/SZ16H8aAAIpys7FUVzF6xuOodjtrlrxK2UnVJVg1lPZNITf8eQA6gwcl+a71Ch021aWGoSnIkz43xFKYU4HDoWK3ORg8uRM71+Vg9DUQEmMiP9O1Mnt83xB2rxcbN1YU1eLfxkhVafPbStRWWZ1rrQ5tPUFsj2Dieoew6ROxUDlnXwm71uWS+ocEdHotHl5adHotm1dkOjMLvf096DUqCrg8ExE0GoXs7OaLIYOoTH4xEzHOce/dy8JZB6yysjKCgprf2yYoKIiysjP/5Xa+xo0bx7hx4854ztixY39zPkySGtIZfdDqdXz9rzfwaxNK9+tv4Kpb7kCj0aCi0nnQEHwDzeTu342Xnx9anY7v3/sPiqKgaLQEhLbDJ8hMSEwHwjom4LDbueqmyWz+9EPGPTGH44cOsnvdam6d+yIbPzzZbDscNpW8A8do3zUKnwAPygtrmzzv6ls6su/H4+QeOJVwkZlWgMnsydW3xvHzZxm07xJEUDsfDm45gbXOjoeXDv8QL2orRZ3B3P3F9B0by7GDpU3eI7i9L0XHXOsWZmwrIDw+gKsmdsBSY0d1qGTvLeLwtpMYPLSYgkz8+NFhZ51FRaNQVVrH+vcOcPWtcbSN9UXxOLcdiVs7h0OlffvIM54TEdH+ogbrffv2EBBw9tMql4OzDlh2u71RZfaGtFotdvuZx7QlqTVxVBWzZvGrVJeV0/26G1j/9pt0u24Mu75ZTWl+HjG9+tLz+hvIP3yQPd+vY+Btd7L2zVcB6DfhJnyCzOxYvZL2Sd1oE9uB9HVrsNTWkJw6/Nc5BZVr732Y2io9UUlmwhMCyUovbNQDAjEEeCIjjeQhHfnhg0Mux7wDPEidnEDeoVKXYFWvvLCW9A3H8PTVs+2rLPzaGEkaHI5Gp0Fn0KDRnBoKVVXI3V9C0uBwdn2X63Id3yBP4vuG8OP/NU6k2PvjcSI6BbB9teg1RCWbSegXwq51ueQeLMG/rRcde7XBYVdx2FX0HlpKT1SzZeURhk7phHewJ6pyefUIunTpik6na3JYUKfTnfeuumfj0KGDvPTSC0yefOdFu0drdE5Zgo899pizdt/pmtvlUpJaK1XR0Xf8LWh1OtrEJuBrDsbgaaRtdCy9x95MWEISBUf24xNopsugoXzx8gK0ej0ajZYtn31IUER7TmQdYf+m7wnvlEh2+g7aJ3XDJzAIS20toR37krb2JLn7Rfq4olGISTHTa1Q0W79w3WE4OCoYvaEd+UeqiegcSM7eYvQeWnqMiCTg1x7Snh/ymn0vR3cXcd29idRV2bBbVfZtOu5cqzXinq6YzEbKC8VC35y9xVhqbPQbF0tdlQ2H3UFQuA9FxyrZ9PFhl8zDelUldc7qFw6HSmZaAbn7Sxg6pRO71uXSvksgmz/PdMn4M0f4kDI0Amutg5pSC54B+t/179XahIS0Y8GCvzebJRgaGn5B77d8+Tt8+eVKamtrCQgI5A9/mMr1119Zae2KepYDoY8//vhZXXD+/Pm/q0GtQWFhy63DMpt9W+z+58td2w2ApQK/oEDKK63YayvR6Q3YbVYUvScoWlRrDdiqOZFxiB+WL2Pwnfeg0WhZ99Ziet0wAXN4JB8/9xQA/iFhDL7zHj5d8AxD7p7JrnUaKoobzxW1jTIREOrN/p9EPcCYbmYiO9diqQth9/pj9BsbS2VJLd5+Hmz58gi9RkZRUVjbbLp6vaFTOlNeWENhTiU+AR54B3hwcHM+Md2DCWjjzdr/7Gn07+PtbyB1cicstTa+XrKn6QsD4QkBhMT4offQYrM6nIkfJrOnqKzRRK+s/nXdR0RitdjxDfV0Pn8+3zP1r7kYamtrycjIxGwOwWDwOIdXqhw/nsvevXvIyckmIqI9nTt3+TVYXRmZe7+XxVJHYWE+sbExeHp6nvHcs+5hXQ6BSJJOp3j4YvD0hEorGg8fHIDSYBTBUVvB6tdfpKa8jOun/wWdhwc7Vq+k34TbKMg6QtmJU0VoywtOYK2podeY8dRVeVFR3PSc7omj5cR0D0ajUUi4KpSOPbyoKbewfc0xEge3Y+3SPYTE+mHw1NKuoz9VpRZMwUZ8gzwbrcuqp9EplBfWsGVlg56bAr1HRePjb2D711kMuKkjGWkF5B0sRaNV6NCjDTHdgnE4HBhNBsLi/MlrZm4roV8o+37Mc5n70uo1DJvaiaO7m6/enru/hG7XtsfDyy2L6pwFhdDQCEJDI2Sli0vg8poJlaQLTFWhtqKcXmPG4xMUTPauNA5s+oH8jANEd+vBnvXfEtE1iZF/+ise3j5sWfF/tI3pQFHz9WnFdR0qY/+STMqIMDyD/PH09cfTV8/JIyL7Lzw+gKz0IgxGHQFtjRxNL6TXyCg8vZseVuvQoy2ZOwpOuwls+eII3gGelBXWsPHDQ+gNWnqNiua6+xKx2ewUH69iw/sH+fzlHfQeGY053MflEopGoefIKApyyhslatitDnL3lzZK0jhddbkFD7/LaziwKTJYXXyX6589knRB6ExtGPvks2g9fEBrIDKpO3oPT04ezSRrZxpjHn2SuqpKstN3c90DD2Otq2XTR+8T3uXeM15Xo7GCWkz6mh+JHzAUndGHyK5B7Nsoemzqr/8FhnpTcrKGyuI6MncUMui2OGwWB5WldVQW13Jw6wnaRJrwDfRwVqJwocLxw2X0GhnFpo8zyEov+nU9lZmcPSUEhvg49/f6YtFOrv9jIjUVVsoLa9EZNASGeVNRXMv65UebfB+1lVa8/QzOLMSm6D20qE0tEJOkcyQDliT9Bo0xABVQULFbrez9fh2FOVlotDoiEpPRGQzE9OxFQdZRQmI60HPkjRh8/DmwufmhMoNnDd8ufZv8wwcICm9PSEJPQmP9nPtU1VVb6TMmhp3rcijMqSQqyUxQmDfrlx9wbhViMhu55rZ4vPwNfP7ijmbvVZJfRZeBYcT3bcvxw2WEdfSnsriWoHAf8hvUHbRZHKx4ZSd+bYwkDg5Hq9PgsKsiy7CZeHN0dyE9RkRSdOxIk8f923rhG3zmeQlJOltySFBqlpdShcmai481H53iQKtR8KAWg6ZxGq/NUoelNB/sFhRUrGX5eFKFSS3AVylFq3H/CWi1towvXvk7Jfl5XD1pKlq9ntWLXsJg9MJaW4fOw0BRXg7bvvwMT69aIrsGNHmdzlcFsWf9x+QfPkDysOvwCQrGoYieSKf+oQAcO1CCtc7uTKAICvNm2+osl32tygtr+OatfdhqHU3ep54pyMiOb3PoMTKS6+5LpGPvtgSEeqM6VLTaxr8Cyk7WsPGDQ2xYfoCCrAp0+uZLK9ksDmwWB9HJ5kbHPLx0XDWhA1qj+//bS62D7GFJaLUKiqLB4XDgcKj4qSfR1xaCtQoFBay1eHIQFB3KhudQtUbsPe6iLrQ3tTqxaDFr904++8ccBtx6JwnduxDoyEHZ9AXK8TQwheHR6QasbZMp07dv4Xd7/hQPE9feNwONohIQFU/b2HiqSwoxmgIwGH0ozc/D6Gviuocepa6qkqCwXAJDwzm4tZqq0jr82xpJGtyG4mM/k7NnGwCW2lq8/M2oKug8rRh99bSJ8iWsgz97vhcTYfF9QprdtFF1qKT/cIzIxCCydhc1Oq7RKnh468nZU0xdpQ2tjxZPRU9we192rsuh1/XRZKU3fl29gFAv6qptZ0z4UDQKHl46Bt7ckfyMMmqrrLSN9iO0oz9eQXocZ46nknTWZMC6gunVWrxrstGVZULVSTAGQXAcZG9G+fFFqDwJGh3EX4cSPQj0Rkh9GqXiBDpvP7THNuCl1aP6t8c3OoKBEyaQ2C0ez5M/o3w5Q2Qs6I3gF45yZD360iz84kZTZojEXl2GotWi8fD57Ya2EioK/u3jQFGw2cGrTXuMwRGoKGg8oMNVQ8UaJq0BqmvY+tnbXHPnvVx3bxeydu/Gy2SgrjqdX1b8l6Sh11FTUc6+H74jOqUHbTv1wIEBb/9aYrqZo1pmrgAAKFpJREFU8Q/2Zsc3oq6gRqfBUtN0zTqA7D3FXH9/IscPlWKpPbV4X6vT0H98LDu+ycFg1GGptWP00aIYFAKjvRh0azyFOZWYI3wozKlsdN1O/UNJ//4YlSV1pAyL4KdPMrBZXKNPWEd/6qptZGwvIK53CBFdAkXygaLi0DQ7knhZUZRTFecbfn0hWK1WFi9+nfXrv0Wr1aHT6bjttsmMHDkagJMnT7Jw4Yvs3bsHjUZDcHAwDzwwna5dkwD44osVvPTSC7Rr1466ujr0ej3XXJPKpEl/+M0U8tZIBqwrlF6txVS0Bc3O5XBgFSha6DEF8rbDlsWnTnTYYN9KOLYduk0C72DY+ykcWuNcZaJ4+qEf8jS9E8NQ7SUoX/1VBLqr/gwePrDncyjYj+Kwoa/KQ68LYt3br+Nt8qfXhMluF7TqfwuLX0wNqkgoeuqLxxuD23PznH+i8TKhKBrCE9pjt9vR6oIZctf9BLULR+9hpF1CFzx9TDgcDlQ0eJoM1FVsRTUnExjmTXFe1W/utKvVKZw8Uk7ykAg0Wg01lRY8vfQEhfvwwwcHRcAZGoG1zoYRkbLvcEDbeBN+wUbCE/w5nlHG3o3HsdSI3lSnfqEUH6/i2IFSAHZ9m8t19yVy7EAJOftKMBi1tO8cRE2lBYddZeSDSXgG6rE5HHB5FmdvUnZ2BhkZGaSkdANgx440YmNjad8+9jdeeXbmzp2FxWLh3Xc/wGg0kpeXx4wZD2K32xk2bDj33383Y8aMZd68BQBs3bqZRx/9M4sWvUlsbAcAevToyT/+8SIAxcXFPPfcHP72t8d44YWXL0gbLyUZsK5Q3rVZaH5ZChnfQuJECEmEgGj46A+NTza1g6SbxfHyPPBvD55+UPvrhH1dOUpVEZzYi+IXDv0eAFM4nNgNlkroMhYOrYH0j1H2fobpxjcZPXEIHnoNiv0oSpUdh9aIxSuMSof7BK8zUVUVjbcYLlUBQ0A7cUDREOFjQtV5gaIhMsUH9F6oaFAt1fzy+X/Zu+EbwjsnEtf7Fn7+vIqqMgsms2ezNQY79GhDxvYCio9XieE5o46UYRFsXpFJZUkdJrORNlEmvPxcF8Q6VBVDgA5jgA4vk4Hw+EBsVjs2qwO9QYveU4u3vwe+gR5o9VpOZJUTmWwmbmAIWo0GW60dFNB4KNjt6hWX1q0okJGRwXPPPYufn9hRuaysjCeeeJLIyNjf3dPKzs5mw4b1rFixCqPRCEBYWBh/+tPD/P3vz6GqKiaTiTvuuNP5ml69+jBy5Bjee+9tZs1qvGdgYGAgTz89h9GjR5CZmUFMzIUJrJeKDFhXIK1WQVd6RASrruPBP1J0F4oOg3rahEPHayEkCbb+G2pLoU1niL4aRi+EH18RPbKe02D/F1B4ACa8BasehfLT5ly6/wE8fOHAKjRfPYrX9c/DsT2wYzlUnkTrFYRnzyl4tL+KGp9YqrWXV0FPtb4npqqoOp/6J0F/KkBr9J5EJnZD0WjoeeOtVBcX0+3aNuzZeILeI6P5sYmySZ4+eqKTzJjMRqrLLfi39cLTR8/eH/Jw2FV6j4nB289ATbWFgEivJofo7IDWV4u3rxbVqqLVa0ADvsEeKBoFjYcGRVGcc5wOVcVht8OvS6vs9isrUNVTVUhJ6Yafn5+z8Lefnx8pKd0uyLDgwYP7iYiIwM/P3+X5rl2TOHEin/379zmH/hpKTExi8eLmN9M1mUxERETIgCW5B0VRoPIEKBqIvArKcuCbWXDNaeW3fEMgLAU2/AP8IuCamZC3Aw6uhqwfIeV2iBoAXoEioCXdBBsWNA5WANvfhpEvQkWeuNa+lbD381PHq4tQvn8BJXoLXlGDIH4C1drmdwe4HKmKhjbxKZhjE1C1nngFhxIXUEdUSjhVpXUMv6sL+zblkb23BK1OIaFvKJGJQRTlVqLVa4hKDkJxqFRVWOl7QzRFx6rZ9vVRkfpuNvzmfJIKoFewo4IDMCiogN0usyYuN+66NYkMWFcgh0MFDxO06yHmmn5+QxzQGkQQq+9lJd0sApGnvxjmW/sU2BssEF39GIR1h55TxOPgTrDrw+ZvvPsjSBgN5nj4dlbT5xz5HiX5NjxPbqUmbESTf6nqsOFVm422JBNUB/aAaKq9orCp7l9NQVU0KHov8TUK6DzR+0KgtzdVRXUkXBVGp/5h6Awa6qqtHN1ViMGoo6rMwpEdBZiCjXTqH8rX/96Lf1sjQ+7sjDFIf8UN110KiiLmrMrKylyGBHfsSCM19drf3cuKi0sgJyeHsrJSl15Wevou2rYNISGhE59//kmj1+3evYv4+IRmr1teXk5ubq5zjsudyIB1BXI4VBzBndB6B0NdOdh+nRvZvxJ63X0q6UJvhOpi6HOfGP6zN1HNIG871I2HjsPB3vymgACUHBG9ufXPwdDZ4ppVBY3Py96EJiQFP/txqlQfvNVSFKBa4w92C977/4t24/PgEBlxOkVB3/s+qns8SK3G323/ejwTh0bF4KUjZ2+x+Pezq3h46fAN8iR7TxF11XYiOgUSlRSE1kPDtfd0xsNXj4Mrb27pUlFViI2N5YknnmyUdHEhvgXbt2/PgAEDmT9/Hs88MxdPT5F08corLzJlyl1ce+0I3nlnGe+885ZzHuuXX7bwxRcreO21fzV5zZKSEhYsmEevXr2Jjo75/Y28xGTAukKVe8fj32UcSk2D/ZWObYdrngD/CNi0UGQOAniboeJ40xcC+GUZpNwGgb/xAxAQJZI2HHb44Z/Q407Y+FLj8+wWlJ9fQ+fpi9/BtSh7/g9UB75xIyBuOMr3C1xOr4xI5bDPALanl1BqraBrO386BOjxtlag9QpAVS6PtDWtt4ZOg0KpKrJQXWZB56HB3M6HDn3b4LCpoAXbr5soatHguCKSyltW+/axLgkWF6Jn1dCsWXNZvHgRt99+MzqdDq1Wy6RJdzB69I0AvP76myxc+BJjx45Cq9ViNpt5/vmX6NgxznmNbdt+4Y47bnWmtQ8aNNht99GSAesKZXMolLcbgqk8HUWjFUEkoi8c/RHS3hHzUYExYI4Tqe1nUlsGZceg5KhI0Mjf1fR5cSNg3TzxdU0JGLybPs8cD7s/QvnuOTFvli6GGRW/cBHoGiiNm8BSzzt59ctyINv5fHSQkSdTtIR6ZhHSqQeXSyfDjopnkB7PID2KAn5mr1NbdPzGP5N0cTQMUBe6c28wGHjooRk89NCMJo+3bRvCs8/+vdnXjxo1hlGjxlzYRrUgGbCuYBaHHptXCPre98HPi0SP5/M/ip+6n98AvRcMfQYsVa5zW6eL7A8n0uHYNhj/b/h2jghO3sFimFCjB792kLHeNfg1FQjbdBK9OYddDCEqWjAGiADnbYayBrvkavVsDZvMq6sb7+B7pKiGNw/58c9RUZdNsJKkK52sJXiFq9QG4wiMhtSnwFrt+ieitRp+fl2kvXcd3/QFFI1Ifff0EwHoq5kiG3DfSvh2NqxfAOvmwpePQlgy+DXYhdU/SiR6gEj+6DJWrAnbuqRBA/Oh069/ITrsoDu1lqiqwxgW72l+Ve2W7DLybe63ml+SpKbJgHWFs6k6rO36oR7bDpom5npKjsLHUyGsG3SdiEvZBWOA6IFtehU6jYaOw6DbZPj8fpFc0ZClEtbOEkkdIJI0TOFw/fNwzWMw6K9QmiV6Z/VBM2ogZP0s1n35tBEVOTrf4LxkpakDh4vOnOhRWFKOIudyJOmyIIcEJcoNkfhe/TQe1cea39T76ydg1EsQmgTWKjFUZ62GnxaJNV01JVBTKua9yvOavobdIob7EieI894dDTe/D18/KQJaQwZvEZx2fwSHvoaeU8VwYFBHkbxRchSvyiwiA/pTWt38XkwBPh6/Fng7jw9GkqRWRQYsCYAKQzusHoH4JN6EsruJtVS+IVCRDxuameB12OD4DijOOPONCg/DkKfgwFcQd51YSDz6ZVG66cBX4py44WKN2Pr5MPgJqKsCSzl4mUHngXrDG6gF+/Hd/QH3phi5v5kdb7tFmEjwKkePhmouj5JP0sWh1YrRBZvNisHg8RtnSxeSzSb+4Kz/NzgTGbAkp1rViHfPu1BMYbDlTdGDUhToMAx63QUf3tH0C0MS4eQ+sU5LbzzzTXzMsOIhSL5F9JjWLxBFdfU+IukDBY5sgL0rYMDD4FDFIuOGc2umcJQxC+Hqv9Inbxd/SEng7R2uiRchJgPzr4vA/8Q61J0f4DlsLsXGTr/r85EuXzqdDm9vL8rLS9FqdaIajHTRqapKeXkpPj7e6HS/HY5kwJJcqDoPyPgORr0Cqk0kORQfEb2ruOGu5ZRAZO51v0MMGYIILDoPsDUzt9SmM+z8nyjpVJkvFg5vfAkSRkFgb5GR2GUc9GkDdhusfKjRJZTyXFj9OFw1nSC1hIeTrYyMC2Vjro2Sqjr6tLWT5NhL+4Ij4BuKkvMz2g9vJ+CW/8Om90HrsFJrMFPrkH9JS4KiKISFhZGZmUlR0YmWbs4VRavVEBoaelZ/JMiAJbmo8OqAX2wqyqHVYj1V4aFTB5NugYlvizmlukoIjhdZgmtnnaqCsf0dGPw3+PYZZyUKp953w+FvxNfHd8LQOVBdIPa62PU/UUAXIDRZJFoUNTO86BUoEjz0RjCF4ld7nN41e+gd7i8C6I73Yd8KGPioaOM1T0JAFFpLBbqTO+DgGnS2Orx730tFUPcL+OlJ7sxgMBAXF4fFYmnpplxRDAYDGs3Z5f8pqpvUsUlNTeXYMdeiqo888gj33HOP8/H+/fuZM2cOu3fvJjAwkEmTJnH33Xef872cCzEvMUUBs9m3xe5fL9CSgWb72yg4YNtbrge7jhd1CEOSYP2zUFXY+AJBHaDv/SLY5e8EUwSEdBXV4TPXiyA3fD6gQuFB0BkhvKf4f/4OsXA4dxtkrIWCA67XDo4XmYibFooNJq/6M6h2kZxRVSDa1XOa6OG17So2pszfDdWFYpsU/0jRi3NYYeNLqKlPo6Tc0uKf+floLd8v5+N82l7/GunK5VY9rOnTp3PTTTc5H3t7n6qUUFlZybRp0+jXrx+zZ8/m4MGDPPHEE5hMJm6++eaWaK7bKjbEEthjGprqkyi7PhRzWfXSPxYbPSoa6HyjKI57uqLDUFcBGd+AbyjEXA2fP3Dq+JBZoid2cg/oPCEwWqSst+survvT62I+K+V2WPv0qdcpisgWXP24WMTc+x448r2oZ1gvLw1WPAhDnhFV4z+5y3XBszEAhj8L+QdgwJ9R1jwh1odpGqwPkySpVXKrgOXt7U1wcHCTx1asWIHVauW5557DYDDQsWNH9u3bx7Jly2TAOg/F+kj8/bzQT3wH1jwhekIAWr0olluSAW0ToeddYq7LN0Sktu9dIdLWj2wQPazCQ2KB8PXPixJOtWWQtUlkEw58VFyvYL+oqmGOE9UxDqwSPajEm6DD0FPDiNGD4ODXIgDpPMTwX8Ng1dB382D8UhjytBgirG9/TYkYwhz5kligHJaC4+R+aBMCilv9OEjSFcetfkKXLFnCG2+8QWhoKKNGjeLOO+90Zpbs2LGDnj17YjAYnOcPGDCAJUuWuJT/l85euSaYgJqtaIY/C+XHRVCpyIPju0XPyD9CrK36eZFYYOzTBnrfKwJKxrpTFyrLEZs75mwWVTFiU6HDEJFscXpR3U5jRA/sq7/C7g/hlv+KoT2dh+it1Sd3RPSBIxubb7zDJoLU+vlin6+9n8GJPeJYVQFUnRDDhZ1vxFFbyfE92wjt2vvURouSJLU6bhOwJk+eTOfOnfHz8yMtLY0XX3yRgoICHn9cbDpYWFhIeLjrsI7ZbHYeO5eA1VIZrfX3bS0ZtaoKdSF98Dy2EcXDV/SEPExizujYdijNgZ3/PfWCypOiDFPUQEi+9dSxNgliKBHEeitTOzGv1FQF+H0rRAahd7CYnzqyAdLeBWuNuO6wubDtP6Lm4LFtv/EG7CJ4rn9OJHisferUMcuvi5+9zdh82hHkHwGK4lbhqrV9v5yL82m7O75P6cJq0YD1wgsvsGTJkjOes2rVKmJjY5kyZYrzuYSEBPR6PbNmzeKRRx5x6VVdCEFBLTux29L3d+HwgpIAMTfkFy4WDpfnwdjF8Om9Tb/m6A8wbI74DaM1iJ5R5clTx/0jYNuy5u+57S0YtwQ++6NrUDuyAY5+L/bS8gwQRXVzf2n+Or9uhIiqinm1Nl3A6C+CmE8I9JyG6hOM3dNM2/BotGexDqQ1alXfL+fIndsuXXot+hM6depUxo4de8ZzIiIimnw+OTkZm81Gbm4uMTExmM1mCgtdM9bqH9f3tM5WUVHLZQkGBfm22P2bYnSU4J23U2zkaKsTwSo0ybVqelPyd4ndiBMnivmohuzNpA1r9WL4LzBaJFM01QNTVfjpNbjuHyK9vb6S++k6DhNzZSCCZkiiyF48vBYUA9hqoPgwyqqH8WrXi8pB86gL6ARu1Mdqjd8vZ+t82l7/GunK1aIBKzAwkMDAwPN67b59+9BoNAQFBQGQkpLCyy+/jNVqRa8XW6Vv2rSJ6Ojoc56/UtULv6+NO92/IRUN1JZA9DVQv3Fi57FQU/wbr9RA0s3w/T8ap75rT+sRB3UUBXDrKkTqu60OPHyg/3QxP3b6eq7Kk2CthY0vi6SKtPdEWSgQQa/reDGkuOlV8dwNr4vK8Q0L8mZ+J3pcgx5DWT8fnx9moYx+ixqa2aOrFWtN3y/nyp3bLl16bjEGkpaWxs6dO+nbty/e3t6kpaUxf/58xowZ4wxGo0ePZtGiRTz55JPcfffdHDp0iHfeecc5xyWdnzqtP0ZTJFr/8FPp4fY6ERDOJDYVvvhT0xUvsn8WxzPWiSoZ0YNg44unkiIA9n8pekSpT8M3sxpfQ3VAXTl8/TgkjIb+D0LxUUAVNQl3/k+cN+Bh2PNJ4+rxINLq2/eBwBiU7J8wlGdSY0o8m49FkqQW4BbbixgMBlatWsWkSZMYOXIk//rXv7jzzjuZO3eu8xxfX1+WLl1Kbm4u48aNY8GCBdx///0ypf13cjhUrFGDRdJD5xvFkxqdWNDbrkfTLwqIAlOoSEtvSm0F9H1A9IQ8A8TcVMNgVa/osKiIEXZaNQq9UbQhJFFU2NjzicgqNPrB/lUixT6itxhDCusGB1c3/wZ3feB8X9qq/DN9FJIktTC36GF16dKFDz9sooL4aRISEnj//fcvQYuuLBUe7dFhRaf3Emufio/AsV/EL3r/SJHZ57CJABGTKgrl2iyoiTehhKaIOaeSI2K+qc99EJwAZXmi6G3ZMRFsmrN/JQx8xHW9Vc+74IfnIfk28G4jhhF9w0SJp9BEyNshdji+5X0xfNjcTskgsgV1YohSrU/SkCSpVXKLgCW1vHJjLAE1n6Fc/RdRXqnXXaIKRZvOMGimCAoanVj7pNqx5+1BCYxE+WYWjF8i9qPK3SqyAyvyxWaRE98RCRgNK2mcrr5GIYCHL/R/SKTFB8dBbSkkjIRe90BVPnzx51MTIvm7oLZczLcZvEVgaopfuJhjMwZg9e9wYT4sSZIuChmwpLNid0Bd59vw+OJuFIOvCDTjlojglfauWEicMAo18SbsljrqkqbgtepeMXxnqYKP73K9oMEXijNFxXbvYLGYtykeviIojnlNBDaNHizVsP1tOJEuzkl9CjYsaDx7X3RIJIyk3AZbmlk+0f9P8P3fUccspEofIjMAJKkVkwFLOmsV+lAY8288TmxDOfg15PwCXW4QvRh7HQ6vIKr1IdTgjR4HSm2Z6Iltf7fxxbqMFaWRrDViaHDjS03ftNddUFUkgo9PW7AWiWSLxAkQ3gu2vwWorj2xepUnRUaiohM9sf1fnjqmKJAyWWQKXvc8qtaIm9SBlqQrlgxY0jmp0IZQF5qKl7kT2uIMOLYT1RSONuYqSrQROBzil75d1WKPH43Wy1+UZDqdT7DI3FNVMSTXZSzs+dT1nM43AgrkbRM1CH9+3fV4aDJMfE8Es+b8vEgUwq06KRYc22rENb2CRO/tZDqsfRpl4ttoFLFfpCRJrZMMWNI5syhGLIYYNGGxaMKH43A4CAryRS2scJ7jcKjYogajPfQFeJqgstb1ImW5Im298JAYUowdIqpjWKrEfJiHr0ioWP0Y9L5LrLU63fGdkP4RRF7VfGMrT4qhx8BoUaoJRF3CvO2w+2OYsAxstShVBRgCq6h1w3VYknSlkAFLOm8Oh4rDoTZb463CGI2mw3XoVAfKD8+7Htz7uagV+N2z4nHGt+I/jVY8jhsp5p+6jocd/6VZ+1dC13Eilb7kaOPjeqNYhPzNM42P9bzrVBCzVKEqWpEcIklSq+QW67Ak96SqUGrsgK3TWFRzvOtBS5UYyut92gabDrsozxQ7CKKuEj2vcteNOxudX3AA+v4RzB1dj3kFiS1GjIEiHb+eRivmxhTEtXUeOAKiseD5u96vJEkXl+xhSRddqb49PuPew5D9HdpfRKKF2vFalM43gNYT/CJEPUBbrSiUW5wJqx4VEe+aJ0SyReWJpi+uaEQCxZq/QcokuHomFB8W2YR15fDlI9DnXhi/DKqLxHoxr0DY8qYImmU50OturH4dZIKgJLVyiipToxppqS3H3XXL87Ntt6IoeKiVKA4bGg0YivejLc9BObRaFLvV6kVyRQPqDa+jVBe67jzcUNwIUYMw60fxuE3nX3clfkwEp3rewTB6odgMcuf7Yp5s5EuoteUosakUasLc6jMH9/1+gfNre/1rpCuX7GFJl4yqqiKp4deB6KrAPhj94/H2aYNSclTst9WAo/d92EK6o604hrbjMDi01vWC5o4Q2d8lmKkGb9B5oQyfj2qrAWsNSkA0qrUG5ZN7wFqF2mkM9JyK1SuUKo8wAgJ8oEHCiCRJrZMMWFKLqtH4Yw0egO8NS9CUZoiCtB4mbKG9qPGJxaIYUQLD8R4Wh6HXQTRHvoO6SpSA9iId/rRkCvvVj1Me1BudWoddMaAoKlpbNYpWh3aKyCas05uxquJbX7G7WddEkq5gMmBJLc6maijxiIa20SghwwDVZZhIVaFSCYCAPmiC+uJrz0efuRZl539P1Qk0hWG/dgEVAd2wO8COx68ZfwpWxQccgC7k1wte2vcnSdKFIQOW1Kr81pSqw6FSprRFGzcZ34iBaCrzQGugzjeaam2g283lSJJ09mTAktyS3a5SaoiEwMhTT8pgJUmXNbkOS5IkSXILMmBJkiRJbkEOCTahuVJDl+q+LXX/8+Wu7QbZ9pZyPm13x/cpXVhy4bAkSZLkFuSQoCRJkuQWZMCSJEmS3IIMWJIkSZJbkAFLkiRJcgsyYEmSJEluQQYsSZIkyS3IgCVJkiS5BRmwJEmSJLcgA5YkSZLkFmTAaiVSU1OJj493+e/NN990OWf//v3cdtttJCYmMmjQIJYsWdJCrRVyc3N54oknSE1NJSkpiaFDh7Jw4UIsFovLOae/r/j4eHbs2NFyDW9g+fLlpKamkpiYyMSJE9m1a1dLN8nF4sWLGT9+PN26daNfv37cf//9ZGZmupwzefLkRp/v008/3cwVL51XX321UbtGjBjhPF5XV8fs2bPp06cP3bp146GHHqKwsLAFWyy1drKWYCsyffp0brrpJudjb29v59eVlZVMmzaNfv36MXv2bA4ePMgTTzyByWTi5ptvbonmkpmZiaqqzJkzh8jISA4ePMhTTz1FTU0NM2fOdDn3rbfeokOHDs7H/v7+l7i1ja1atYr58+cze/ZskpOTefvtt5k2bRqrV68mKCiopZsHwJYtW7j99ttJTEzEbrfz4osvMm3aNL788ku8vLyc5910001Mnz7d+dhoNLZEcxvp2LEjy5Ytcz7WarXOr5977jk2bNjAyy+/jK+vL3PnzuXBBx/kf//7X0s0VXIHqtQqDB48WF22bFmzx5cvX6726tVLraurcz73/PPPq8OHD78ErTt7S5YsUVNTU52Pc3Jy1Li4OHXv3r0t2KqmTZgwQZ09e7bzsd1uVwcMGKAuXry4BVt1ZkVFRWpcXJy6ZcsW53OTJk1S582b14KtatrChQvVMWPGNHmsvLxc7dKli/rVV185nzt8+LAaFxenpqWlXaIWSu5GDgm2IkuWLKFPnz7ceOON/Pvf/8ZmszmP7dixg549e2IwGJzPDRgwgCNHjlBWVtYSzW1SRUUFfn5+jZ7/4x//SL9+/bj11lv59ttvW6BlriwWC3v27KF///7O5zQaDf379yctLa0FW3ZmFRUVAI0+45UrV9KnTx9GjRrFP//5T2pqalqieY1kZWUxYMAAhgwZwiOPPEJeXh4A6enpWK1Wl88/NjaWsLCwVjNcLLU+ckiwlZg8eTKdO3fGz8+PtLQ0XnzxRQoKCnj88ccBKCwsJDw83OU1ZrPZeaypIHGpZWVl8d5777kMB3p5efHYY4/RvXt3FEVhzZo1PPDAAyxatIghQ4a0WFtLSkqw2+2Nhv6CgoIazRG1Fg6Hg+eee47u3bsTFxfnfH7UqFGEhYXRpk0bDhw4wAsvvMCRI0d47bXXWrC1kJSUxPz584mOjqagoIBFixZx++23s3LlSgoLC9Hr9ZhMJpfXBAUFUVBQ0EItllo7GbAuohdeeOE3EyNWrVpFbGwsU6ZMcT6XkJCAXq9n1qxZPPLIIy69qkvhXNpd78SJE9x1112MGDHCZR4uMDDQ5b0lJSVx8uRJli5d2qIByx3Nnj2bQ4cO8f7777s833AOMz4+nuDgYO68806ys7Np3779pW6m06BBg5xfJyQkkJyczODBg/nqq6/w9PRssXZJ7ksGrIto6tSpjB079oznRERENPl8cnIyNpuN3NxcYmJiMJvNjTKo6h/X97QulHNt94kTJ7jjjjvo1q0bc+fO/c3rJycns2nTpt/dzt8jICAArVZLUVGRy/NFRUUX/PO8EObMmcP69et57733CAkJOeO5ycnJgOjxtmTAOp3JZCIqKors7Gz69++P1WqlvLzcpZdVVFREcHBwC7ZSas1kwLqIAgMDCQwMPK/X7tu3D41G4xyySklJ4eWXX8ZqtaLX6wHYtGkT0dHRF3w48FzaXR+sunTpwvz589FofntadN++fS3+S8lgMNClSxd++uknhg4dCoght59++olJkya1aNsaUlWVuXPnsnbtWt59991m/8BpaN++fQAt/hmfrqqqipycHIKDg+natSt6vZ6ffvqJ4cOHAyLrNC8vj5SUlJZtqNRqyYDVCqSlpbFz50769u2Lt7c3aWlpzJ8/nzFjxjiD0ejRo1m0aBFPPvkkd999N4cOHeKdd95xznG1hBMnTjB58mTCwsKYOXMmxcXFzmP1vyw//fRT9Ho9nTp1AmDt2rV8/PHHzJs3r0Xa3NCUKVOYOXMmXbt2JSkpibfffpuamhrGjRvX0k1zmj17Nl988QWvv/463t7ezvkdX19fPD09yc7OZuXKlQwaNAh/f38OHDjA/Pnz6dWrFwkJCS3a9r///e8MHjyYsLAwTp48yauvvopGo2HUqFH4+voyfvx4FixYgJ+fHz4+PsybN49u3brJgCU1S1FVVW3pRlzp9uzZw+zZs8nMzMRisRAeHs4NN9zAlClTXOav9u/fz5w5c9i9ezcBAQFMmjSJe+65p8Xa/cknnzQbMA8cOACIgLVkyRLy8vLQarXExMQwbdo0lwWkLem9995j6dKlFBQU0KlTJ/72t785h9Rag/j4+Cafnz9/PuPGjeP48eP85S9/4dChQ1RXVxMaGsrQoUO5//778fHxucStdTVjxgy2bt1KaWkpgYGB9OjRgxkzZjiHKevq6liwYAFffvklFouFAQMGMGvWrFbXM5RaDxmwJEmSJLcg12FJkiRJbkEGLEmSJMktyIAlSZIkuQUZsCRJkiS3IAOWJEmS5BZkwJIkSZLcggxYkiRJkluQAUuSJElyCzJgSRddfHw833zzTUs344w2b95MfHw85eXlLd0USZKaIStdSOflscce49NPPwVAp9Ph5+dHfHw8I0eOZNy4cS5FcAsKCvDz87vk26ScC4vFQllZGWazGUVRLtp9tm7dytKlS0lPT3fuEVVffFeSpDOTPSzpvA0cOJCNGzeybt06527Jzz77LPfee6/LbsnBwcGtOliBqN4eHBx8UYMVQHV1NfHx8cyaNeui3keSLkcyYEnnrf6XfNu2benSpQv33Xcfr7/+Ot9//72z9wWuQ4K5ubnEx8ezatUqbrvtNpKSkhg/fjxHjhxh165djBs3jm7dunHXXXe5VH8H+Oijj7juuutITExkxIgRLF++3Hms/rpr1qxh8uTJJCcnM2bMGJft7o8dO8Z9991Hr169SElJYeTIkWzYsAFoekjw66+/ZuTIkXTt2pXU1FT+85//uLQnNTWVf/3rXzz++ON069aNa665hg8++OCMn9mgQYOYMWMGw4YNO8dPW5IkGbCkC6pfv34kJCSwZs2aM5736quv8sc//pFPP/0UnU7HI488wvPPP8+TTz7J8uXLyc7O5pVXXnGev2LFCl555RVmzJjBqlWrePjhh1m4cKFLYAR46aWXmDZtGp999hlRUVE88sgjzt7enDlzsFgsvPfee6xcuZJHH30ULy+vJtuXnp7On//8Z66//npWrlzJgw8+yCuvvMInn3zict6yZcvo2rUrn332GbfddhvPPPMMmZmZ5/PRSZL0G+R+WNIFFxMT49xepDlTp05l4MCBANxxxx08/PDDvPXWW/To0QOACRMmuASHV199lccee4xrr70WEDseHz58mA8++MBld+SpU6dyzTXXADB9+nRGjhxJVlYWsbGx5OXlMXz4cOeWHWfaDHHZsmX069ePBx54AIDo6GgOHz7M0qVLXfbLuvrqq7n99tsBuPvuu3nrrbfYvHkzMTExZ/VZSZJ09mTAki44VVV/cy6o4T5P9bsqn/5c/ZBgdXU12dnZPPnkkzz11FPOc2w2G76+vs1et35fpeLiYmJjY7njjjt45pln2LhxI/379+faa69tdpPDzMxMhgwZ4vJc9+7deeedd7Db7Wi12kb3UxQFs9lMUVHRGd+7JEnnRwYs6YLLyMggPDz8jOfo9Xrn1/XBTafTuTzncDgAEbAA5s6d22hzxYbZiM1dt/46EydOZMCAAaxfv54ff/yRN998k5kzZzJ58uRzen8NNWxz/T1l4q0kXRxyDku6oH766ScOHjzoHLq7EMxmM23atCEnJ4fIyEiX/840rNeU0NBQbr31Vl577TWmTJnChx9+2OR5MTExbN++3eW57du3ExUV5exdSZJ0ackelnTeLBYLBQUFOBwOCgsL+eGHH1i8eDGDBw/mxhtvvKD3mj59OvPmzcPX15eBAwdisVhIT0+nvLycKVOmnNU1nn32Wa6++mqioqIoLy9n8+bNxMbGNnnu1KlTmTBhAosWLeL6669nx44dLF++/Heno1dVVZGdne18nJuby759+/Dz8yMsLOx3XVuSLncyYEnn7YcffmDAgAHodDpMJhMJCQn87W9/Y+zYsY2G6n6viRMn4unpydKlS/nHP/6Bl5cXcXFx/OEPfzjrazgcDubMmUN+fj4+Pj4MHDiQxx9/vMlzu3Tpwssvv8zChQt54403CA4OZvr06S4JF+cjPT2dO+64w/l4/vz5AIwdO5YFCxb8rmtL0uVOVrqQJEmS3IKcw5IkSZLcggxYkiRJkluQAUuSJElyCzJgSZIkSW5BBixJkiTJLciAJUmSJLkFGbAkSZIktyADliRJkuQWZMCSJEmS3IIMWJIkSZJbkAFLkiRJcgsyYEmSJElu4f8Bx8/rElgCvHUAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -245,8 +245,8 @@ "output_type": "stream", "text": [ "=== Metrics ===\n", - "auroc 0.725072\n", - "fpr95tpr 0.689239\n" + "auroc 0.725269\n", + "fpr95tpr 0.688655\n" ] } ], @@ -330,7 +330,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -370,7 +370,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -387,14 +387,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "79/79 [==============================] - 3s 13ms/step - loss: 0.1268 - accuracy: 0.9278\n", + "79/79 [==============================] - 4s 13ms/step - loss: 0.1268 - accuracy: 0.9278\n", "Test accuracy:\t0.9278\n", "\n", "=== Penultimate features viz ===\n" @@ -443,35 +443,35 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "WARNING:tensorflow:5 out of the last 158 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" + "WARNING:tensorflow:5 out of the last 1093 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:tensorflow:5 out of the last 158 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" + "WARNING:tensorflow:5 out of the last 1093 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "WARNING:tensorflow:6 out of the last 160 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" + "WARNING:tensorflow:5 out of the last 2857 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "WARNING:tensorflow:6 out of the last 160 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" + "WARNING:tensorflow:5 out of the last 2857 calls to triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for more details.\n" ] }, { @@ -479,8 +479,8 @@ "output_type": "stream", "text": [ "=== Metrics ===\n", - "auroc 0.988443\n", - "fpr95tpr 0.054600\n" + "auroc 0.988420\n", + "fpr95tpr 0.055000\n" ] } ], @@ -488,9 +488,17 @@ "# === gram scores ===\n", "she = SHE()\n", "she.fit(\n", - " model, \n", - " ds_fit, \n", - " feature_layers_id=['conv2d_18', 'activation_17', 'conv2d_37', 'activation_35', 'conv2d_56', 'activation_53', 'flatten']\n", + " model,\n", + " ds_fit,\n", + " feature_layers_id=[\n", + " \"conv2d_18\",\n", + " \"activation_17\",\n", + " \"conv2d_37\",\n", + " \"activation_35\",\n", + " \"conv2d_56\",\n", + " \"activation_53\",\n", + " \"flatten\",\n", + " ],\n", ")\n", "\n", "scores_in, _ = she.score(ds_in)\n", @@ -507,7 +515,7 @@ ")\n", "print(\"=== Metrics ===\")\n", "for k, v in metrics.items():\n", - " print(f\"{k:<10} {v:.6f}\")\n" + " print(f\"{k:<10} {v:.6f}\")" ] }, { diff --git a/docs/notebooks/torch/demo_she_torch.ipynb b/docs/notebooks/torch/demo_she_torch.ipynb index 08edb0a3..38fc1595 100644 --- a/docs/notebooks/torch/demo_she_torch.ipynb +++ b/docs/notebooks/torch/demo_she_torch.ipynb @@ -40,6 +40,7 @@ "warnings.filterwarnings(\"ignore\")\n", "import os\n", "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1\"\n", "\n", "from IPython.display import clear_output\n", "from sklearn.metrics import accuracy_score\n", @@ -249,8 +250,8 @@ "output_type": "stream", "text": [ "=== Metrics ===\n", - "auroc 0.735984\n", - "fpr95tpr 0.646429\n" + "auroc 0.736096\n", + "fpr95tpr 0.645845\n" ] } ], @@ -289,7 +290,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -494,45 +495,13 @@ "she = SHE()\n", "she.fit(model, ds_fit, feature_layers_id=[\"layer1.2.conv2\", \"layer2.2.conv2\", \"layer3.2.conv2\"])\n", "\n", - "\"\"\"\n", - " feature_layers_id=[\n", - " \"layer1.0.relu\",\n", - " \"layer1.0.conv1\",\n", - " \"layer1.0.conv2\",\n", - " \"layer1.1.relu\",\n", - " \"layer1.1.conv1\",\n", - " \"layer1.1.conv2\",\n", - " \"layer1.2.relu\",\n", - " \"layer1.2.conv1\",\n", - " \"layer1.2.conv2\",\n", - " \"layer2.0.relu\",\n", - " \"layer2.0.conv1\",\n", - " \"layer2.0.conv2\",\n", - " \"layer2.1.relu\",\n", - " \"layer2.1.conv1\",\n", - " \"layer2.1.conv2\",\n", - " \"layer2.2.relu\",\n", - " \"layer2.2.conv1\",\n", - " \"layer2.2.conv2\",\n", - " \"layer3.0.relu\",\n", - " \"layer3.0.conv1\",\n", - " \"layer3.0.conv2\",\n", - " \"layer3.1.relu\",\n", - " \"layer3.1.conv1\",\n", - " \"layer3.1.conv2\",\n", - " \"layer3.2.relu\",\n", - " \"layer3.2.conv1\",\n", - " \"layer3.2.conv2\",\n", - " ],\n", - ")\n", - "\"\"\"\n", "scores_in, _ = she.score(ds_in)\n", "scores_out, _ = she.score(ds_out)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -540,7 +509,7 @@ "output_type": "stream", "text": [ "=== Metrics ===\n", - "auroc 0.990858\n", + "auroc 0.990859\n", "fpr95tpr 0.040200\n", "\n", "=== Plots ===\n" @@ -548,7 +517,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -578,317 +547,6 @@ "plt.tight_layout()\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "('', CifarResNet(\n", - " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (layer1): Sequential(\n", - " (0): BasicBlock(\n", - " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (1): BasicBlock(\n", - " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (2): BasicBlock(\n", - " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (layer2): Sequential(\n", - " (0): BasicBlock(\n", - " (conv1): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): BasicBlock(\n", - " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (2): BasicBlock(\n", - " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (layer3): Sequential(\n", - " (0): BasicBlock(\n", - " (conv1): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): BasicBlock(\n", - " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (2): BasicBlock(\n", - " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n", - " (fc): Linear(in_features=64, out_features=10, bias=True)\n", - "))\n", - "('conv1', Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('bn1', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('relu', ReLU(inplace=True))\n", - "('layer1', Sequential(\n", - " (0): BasicBlock(\n", - " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (1): BasicBlock(\n", - " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (2): BasicBlock(\n", - " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - "))\n", - "('layer1.0', BasicBlock(\n", - " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - "))\n", - "('layer1.0.conv1', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer1.0.bn1', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer1.0.relu', ReLU(inplace=True))\n", - "('layer1.0.conv2', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer1.0.bn2', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer1.1', BasicBlock(\n", - " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - "))\n", - "('layer1.1.conv1', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer1.1.bn1', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer1.1.relu', ReLU(inplace=True))\n", - "('layer1.1.conv2', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer1.1.bn2', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer1.2', BasicBlock(\n", - " (conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - "))\n", - "('layer1.2.conv1', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer1.2.bn1', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer1.2.relu', ReLU(inplace=True))\n", - "('layer1.2.conv2', Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer1.2.bn2', BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer2', Sequential(\n", - " (0): BasicBlock(\n", - " (conv1): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): BasicBlock(\n", - " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (2): BasicBlock(\n", - " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - "))\n", - "('layer2.0', BasicBlock(\n", - " (conv1): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - "))\n", - "('layer2.0.conv1', Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False))\n", - "('layer2.0.bn1', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer2.0.relu', ReLU(inplace=True))\n", - "('layer2.0.conv2', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer2.0.bn2', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer2.0.downsample', Sequential(\n", - " (0): Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - "))\n", - "('layer2.0.downsample.0', Conv2d(16, 32, kernel_size=(1, 1), stride=(2, 2), bias=False))\n", - "('layer2.0.downsample.1', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer2.1', BasicBlock(\n", - " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - "))\n", - "('layer2.1.conv1', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer2.1.bn1', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer2.1.relu', ReLU(inplace=True))\n", - "('layer2.1.conv2', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer2.1.bn2', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer2.2', BasicBlock(\n", - " (conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - "))\n", - "('layer2.2.conv1', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer2.2.bn1', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer2.2.relu', ReLU(inplace=True))\n", - "('layer2.2.conv2', Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer2.2.bn2', BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer3', Sequential(\n", - " (0): BasicBlock(\n", - " (conv1): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " )\n", - " (1): BasicBlock(\n", - " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - " (2): BasicBlock(\n", - " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - "))\n", - "('layer3.0', BasicBlock(\n", - " (conv1): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (downsample): Sequential(\n", - " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " )\n", - "))\n", - "('layer3.0.conv1', Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False))\n", - "('layer3.0.bn1', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer3.0.relu', ReLU(inplace=True))\n", - "('layer3.0.conv2', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer3.0.bn2', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer3.0.downsample', Sequential(\n", - " (0): Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", - " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - "))\n", - "('layer3.0.downsample.0', Conv2d(32, 64, kernel_size=(1, 1), stride=(2, 2), bias=False))\n", - "('layer3.0.downsample.1', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer3.1', BasicBlock(\n", - " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - "))\n", - "('layer3.1.conv1', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer3.1.bn1', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer3.1.relu', ReLU(inplace=True))\n", - "('layer3.1.conv2', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer3.1.bn2', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer3.2', BasicBlock(\n", - " (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (relu): ReLU(inplace=True)\n", - " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", - " (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - "))\n", - "('layer3.2.conv1', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer3.2.bn1', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('layer3.2.relu', ReLU(inplace=True))\n", - "('layer3.2.conv2', Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False))\n", - "('layer3.2.bn2', BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))\n", - "('avgpool', AdaptiveAvgPool2d(output_size=(1, 1)))\n", - "('fc', Linear(in_features=64, out_features=10, bias=True))\n" - ] - } - ], - "source": [ - "for m in model.named_modules():\n", - " print(m)" - ] } ], "metadata": { diff --git a/oodeel/methods/she.py b/oodeel/methods/she.py index e730b74e..b5133c55 100644 --- a/oodeel/methods/she.py +++ b/oodeel/methods/she.py @@ -47,6 +47,10 @@ class SHE(OODBaseDetector): network, while we aggregate the results of multiple layers after normalizing by the dimension of each vector (the activation vector for dense layers, and the average pooling of the feature map for convolutional layers). + + Args: + eps (float): magnitude for gradient based input perturbation. + Defaults to 0.0014. """ def __init__( @@ -86,15 +90,18 @@ def _fit_to_dataset( ) labels = infos["labels"] + preds = self.op.argmax(infos["logits"], dim=-1) + preds = self.op.convert_to_numpy(preds) # unique sorted classes self._classes = np.sort(np.unique(self.op.convert_to_numpy(labels))) + labels = self.op.convert_to_numpy(labels) self._mus = list() for feature in features: mus_f = list() for cls in self._classes: - indexes = self.op.equal(labels, cls) + indexes = np.equal(labels, cls) & np.equal(preds, cls) _features_cls = feature[indexes] mus_f.append( self.op.unsqueeze(self.op.mean(_features_cls, dim=0), dim=0) From 86e7df0a0e8dd31d69b14835201d7be565c88648 Mon Sep 17 00:00:00 2001 From: paulnovello Date: Fri, 19 Apr 2024 15:00:05 +0200 Subject: [PATCH 09/10] chore: fix doc and methods __init__.py --- mkdocs.yml | 2 ++ oodeel/methods/__init__.py | 1 + 2 files changed, 3 insertions(+) diff --git a/mkdocs.yml b/mkdocs.yml index 9b3a9812..f463c0d3 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -18,6 +18,7 @@ nav: - Gram: notebooks/tensorflow/demo_gram_tf.ipynb - GEN: notebooks/tensorflow/demo_gen_tf.ipynb - RMDS: notebooks/tensorflow/demo_rmds_tf.ipynb + - SHE: notebooks/tensorflow/demo_she_tf.ipynb - OOD Baselines (Torch): - MLS/MSP: notebooks/torch/demo_mls_msp_torch.ipynb - ODIN: notebooks/torch/demo_odin_torch.ipynb @@ -30,6 +31,7 @@ nav: - Gram: notebooks/torch/demo_gram_torch.ipynb - GEN: notebooks/torch/demo_gen_torch.ipynb - RMDS: notebooks/torch/demo_rmds_torch.ipynb + - SHE: notebooks/torch/demo_she_torch.ipynb - Advanced Topics: - Seamlessly handling torch and tf datasets with DataHandler: pages/datahandler_tuto.md - Seamlessly handling torch and tf Tensors with Operator: pages/operator_tuto.md diff --git a/oodeel/methods/__init__.py b/oodeel/methods/__init__.py index 80c6c0e9..f410e7e2 100644 --- a/oodeel/methods/__init__.py +++ b/oodeel/methods/__init__.py @@ -37,6 +37,7 @@ "Energy", "Entropy", "GEN", + "SHE", "Gram", "Mahalanobis", "MLS", From 003d410701878e2ffb0d68c163c4a61a269762dd Mon Sep 17 00:00:00 2001 From: Yannick Prudent Date: Tue, 23 Apr 2024 16:30:02 +0200 Subject: [PATCH 10/10] test: new path for blobs test files --- tests/tests_tensorflow/tf_methods_utils.py | 3 ++- tests/tests_torch/torch_methods_utils.py | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/tests_tensorflow/tf_methods_utils.py b/tests/tests_tensorflow/tf_methods_utils.py index e4647773..cbdf7154 100644 --- a/tests/tests_tensorflow/tf_methods_utils.py +++ b/tests/tests_tensorflow/tf_methods_utils.py @@ -66,7 +66,8 @@ def load_blobs_data(batch_size=128, num_samples=10000, train_ratio=0.8): def load_blob_mlp(): model_path_blobs = tf.keras.utils.get_file( "blobs_mlp.h5", - origin="https://share.deel.ai/s/bc5jx9HQAGYya9m/download/blobs_mlp.h5", + origin="https://github.com/deel-ai/oodeel/blob/assets/test_models/" + + "blobs_mlp.h5?raw=True", cache_dir=model_path, cache_subdir="", ) diff --git a/tests/tests_torch/torch_methods_utils.py b/tests/tests_torch/torch_methods_utils.py index 5621f755..0cb4d641 100644 --- a/tests/tests_torch/torch_methods_utils.py +++ b/tests/tests_torch/torch_methods_utils.py @@ -71,7 +71,8 @@ def load_blob_mlp(): # if model not in local, download it if not os.path.exists(model_path_blob): data = requests.get( - "https://share.deel.ai/s/xcyk3ET8fzfTp8S/download/blobs_mlp.pt" + "https://github.com/deel-ai/oodeel/blob/assets/test_models/" + + "blobs_mlp.pt?raw=True" ) with open(model_path_blob, "wb") as file: file.write(data.content)