{"cells": [{"cell_type": "markdown", "id": "fdc76c70f0c03636", "metadata": {"ExecuteTime": {"end_time": "2025-12-08T12:23:35.247239Z", "start_time": "2025-12-08T12:23:35.245655Z"}}, "source": ["# Bayesian Active Learning"]}, {"cell_type": "markdown", "id": "c2b48ddbedec9816", "metadata": {}, "source": ["> **_Google Colab Note:_** If the notebook fails to run after installing the needed packages, try to restart the runtime (Ctrl + M) under Runtime -> Restart session.\n", "\n", "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/scikit-activeml/scikit-activeml.github.io/blob/gh-pages/1.0/generated/tutorials_colab//09_bayesian_al.ipynb)"]}, {"cell_type": "markdown", "id": "53a0f97d7db7c206", "metadata": {"ExecuteTime": {"end_time": "2025-12-08T12:23:49.135466Z", "start_time": "2025-12-08T12:23:49.132978Z"}}, "source": ["**Notebook Dependencies**\n", "\n", "Uncomment the following cells to install all dependencies for this tutorial."]}, {"cell_type": "code", "execution_count": 1, "id": "239365aa43eca8e", "metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:01:49.056093Z", "start_time": "2025-12-08T16:01:49.054432Z"}}, "outputs": [], "source": ["# !pip install scikit-activeml[opt] torch torchvision torchaudio transformers datasets[audio]"]}, {"cell_type": "markdown", "id": "b74db498512bdcd1", "metadata": {}, "source": ["<hr style=\"border-style: solid; border-top: 1px solid; border-right: 0; border-bottom: 0; border-left: 0;\">"]}, {"cell_type": "markdown", "id": "a109acd3b472dc16", "metadata": {}, "source": ["This tutorial illustrates how Bayesian active learning query strategies can be applied within ``scikit-activeml`` to an audio classification task. In particular, we demonstrate pool-based active learning on the AudioMNIST dataset, where raw audio signals are first transformed into fixed embeddings using a pretrained Wav2Vec 2.0 model. These embeddings serve as input to a lightweight classification head, enabling efficient training and uncertainty estimation.\n", "\n", "The main focus of this notebook is on **Bayesian active learning**, where epistemic uncertainty is approximated via Monte Carlo (MC) dropout and exploited by Bayesian query strategies available in ``scikit-activeml``, such as uncertainty-based or information-theoretic selection methods. By repeatedly querying the most informative audio samples for annotation, we aim to achieve strong predictive performance with a minimal labeling budget.\n", "\n", "From a structural perspective, this tutorial closely follows the general workflow used in other deep active learning examples in ``scikit-activeml``:\n", "1. dataset preparation and embedding extraction,\n", "2. definition of a neural network ``pytorch`` module,\n", "3. specification of Bayesian query strategies,\n", "4. execution of an active learning loop with iterative querying and retraining.\n", "\n", "Compared to image-based tutorials (e.g., those using frozen Vision Transformers), this notebook highlights how the same active learning principles transfer seamlessly to the audio domain. In doing so, it demonstrates that ``scikit-activeml`` can be combined with modern audio foundation models for speech processing to perform Bayesian active learning on real-world audio data."]}, {"cell_type": "code", "execution_count": 2, "id": "d31a01c1996154f1", "metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:01:51.997187Z", "start_time": "2025-12-08T16:01:49.096408Z"}}, "outputs": [], "source": ["import numpy as np\n", "import matplotlib as mlp\n", "import matplotlib.pyplot as plt\n", "import torch\n", "import warnings\n", "\n", "from copy import deepcopy\n", "from functools import lru_cache\n", "from datasets import load_dataset, Audio\n", "from multiprocess import set_start_method\n", "from skactiveml.classifier import SkorchClassifier\n", "from skactiveml.pool import (\n", "    RandomSampling,\n", "    UncertaintySampling,\n", "    GreedyBALD,\n", "    BatchBALD,\n", "    QueryByCommittee,\n", "    SubSamplingWrapper,\n", ")\n", "from skactiveml.utils import call_func\n", "from skorch.callbacks import LRScheduler\n", "from torch import nn\n", "from torch.nn import functional as F\n", "from torch.optim.lr_scheduler import CosineAnnealingLR\n", "from tqdm import tqdm\n", "from transformers import AutoFeatureExtractor\n", "\n", "set_start_method(\"spawn\", force=True)\n", "warnings.filterwarnings(\"ignore\")\n", "mlp.rcParams[\"figure.facecolor\"] = \"white\"\n", "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "random_state = 0\n", "missing_label = -1"]}, {"cell_type": "markdown", "id": "62872e4cb3282705", "metadata": {}, "source": ["## Embed AudioMNIST with Wac2Vec\n", "We turn the raw AudioMNIST waveforms into fixed-size feature vectors using a pretrained Wav2Vec 2.0 model. We first resample all audio clips to the sampling rate expected by Wav2Vec, then use the corresponding feature extractor and model to obtain hidden representations. For each recording, we pool the hidden states into a single embedding vector (e.g., by averaging over time). These embeddings are stored as our feature matrix ``X``, while the spoken digit labels form ``y``. All subsequent active learning steps in ``scikit-activeml`` operate only on these precomputed Wav2Vec embeddings, without re-running the foundation model."]}, {"cell_type": "code", "execution_count": 3, "id": "1945fbc5040ff2bb", "metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:05:07.933245Z", "start_time": "2025-12-08T16:01:52.041793Z"}}, "outputs": [{"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "42043b1620c94e8f8ce101e0b208756d", "version_major": 2, "version_minor": 0}, "text/plain": ["Map (num_proc=2):   0%|          | 0/24000 [00:00<?, ? examples/s]"]}, "metadata": {}, "output_type": "display_data"}, {"data": {"application/vnd.jupyter.widget-view+json": {"model_id": "ba7c30fb39064e4ba04402684a59b032", "version_major": 2, "version_minor": 0}, "text/plain": ["Map (num_proc=2):   0%|          | 0/6000 [00:00<?, ? examples/s]"]}, "metadata": {}, "output_type": "display_data"}], "source": ["# Spoken digit dataset: 0\u20139, circa 30k clips of 60 speakers\n", "ds = load_dataset(\"gilkeyio/AudioMNIST\")\n", "\n", "# Use provided train / test splits\n", "train_ds = ds[\"train\"]\n", "test_ds = ds[\"test\"]\n", "\n", "# Ensure a fixed sampling rate for all audio (16 kHz for Wav2Vec2)\n", "train_ds = train_ds.cast_column(\"audio\", Audio(sampling_rate=16_000))\n", "test_ds = test_ds.cast_column(\"audio\", Audio(sampling_rate=16_000))\n", "\n", "# Load the processor for the audio foundation model (wav2vec2-base).\n", "model_name = \"facebook/wav2vec2-base\"\n", "processor = AutoFeatureExtractor.from_pretrained(model_name)\n", "\n", "\n", "# Load once per worker to avoid serializing the parametrized model.\n", "@lru_cache(maxsize=1)\n", "def get_embedding_model(model_name, device):\n", "    import warnings\n", "    from transformers import Wav2Vec2Model\n", "\n", "    warnings.filterwarnings(\"ignore\")\n", "    return Wav2Vec2Model.from_pretrained(model_name).to(device).eval()\n", "\n", "\n", "def embed(\n", "    batch,\n", "    processor,\n", "    device,\n", "    model_name,\n", "    get_embedding_model=get_embedding_model,\n", "):\n", "    import torch\n", "\n", "    model = get_embedding_model(model_name, device)\n", "    audio_arrays = [a[\"array\"] for a in batch[\"audio\"]]\n", "    sampling_rate = batch[\"audio\"][0][\"sampling_rate\"]\n", "\n", "    inputs = processor(\n", "        audio_arrays,\n", "        sampling_rate=sampling_rate,\n", "        return_tensors=\"pt\",\n", "        padding=True,\n", "    ).to(device)\n", "\n", "    with torch.no_grad():\n", "        out = model(**inputs).last_hidden_state\n", "        # Global mean pooling\n", "        emb = out.mean(dim=1)\n", "\n", "    return {\"emb\": emb.cpu().numpy()}\n", "\n", "\n", "embed_kwargs = {\n", "    \"processor\": processor,\n", "    \"model_name\": model_name,\n", "    \"device\": device,\n", "}\n", "train_ds = train_ds.map(\n", "    embed,\n", "    batched=True,\n", "    batch_size=2,\n", "    num_proc=2,\n", "    fn_kwargs=embed_kwargs,\n", "    remove_columns=[\"audio\"],\n", ")\n", "test_ds = test_ds.map(\n", "    embed,\n", "    batched=True,\n", "    batch_size=2,\n", "    num_proc=2,\n", "    fn_kwargs=embed_kwargs,\n", "    remove_columns=[\"audio\"],\n", ")\n", "\n", "# Digit labels: 0-9\n", "label_col = \"digit\"\n", "\n", "# Create numpy arrays\n", "X_pool = np.stack(train_ds[\"emb\"], dtype=np.float32)\n", "y_pool = np.array(train_ds[label_col], dtype=np.int64)\n", "X_test = np.stack(test_ds[\"emb\"], dtype=np.float32)\n", "y_test = np.array(test_ds[label_col], dtype=np.int64)\n", "n_features = X_pool.shape[1]\n", "classes = np.unique(y_pool)"]}, {"cell_type": "markdown", "id": "7a78eeeeefa76b42", "metadata": {}, "source": ["## PyTorch Module with Monte-Carlo Dropout\n", "\n", "This following module assumes that the inputs are fixed embeddings produced by a (possibly frozen) foundational model. During training, dropout is applied directly to the input embeddings with a different random mask for each forward pass. During evaluation, if Monte Carlo (MC) dropout is enabled, a fixed set of dropout masks is sampled once and reused across multiple forward calls, so that each MC sample can be interpreted as a persistent ensemble member."]}, {"cell_type": "code", "execution_count": 4, "id": "1a8c8f89df3ce616", "metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:05:07.984906Z", "start_time": "2025-12-08T16:05:07.980351Z"}}, "outputs": [], "source": ["class ClassificationModule(nn.Module):\n", "    \"\"\"MLP classifier with optional MC dropout on input embeddings.\n", "\n", "    Parameters\n", "    ----------\n", "    n_features : int\n", "        Dimensionality of the input embeddings.\n", "    n_classes : int\n", "        Number of output classes.\n", "    n_hidden_units : int\n", "        Number of hidden units in the hidden layer.\n", "    mc_dropout_p : float, default=0.5\n", "        Dropout probability applied to the input embeddings. Used during\n", "        training for regularization and, if MC sampling is enabled, during\n", "        evaluation by means of fixed dropout masks.\n", "    n_mc_samples : int, default=0\n", "        Number of MC dropout samples in evaluation mode. If\n", "        ``n_mc_samples <= 1`` or ``mc_dropout_p <= 0``, evaluation is\n", "        deterministic and no MC statistics are returned.\n", "    \"\"\"\n", "    def __init__(\n", "        self,\n", "        n_features,\n", "        n_classes,\n", "        n_hidden_units,\n", "        mc_dropout_p=0.5,\n", "        n_mc_samples=0,\n", "    ):\n", "        super().__init__()\n", "        self.linear_1 = nn.Linear(n_features, n_hidden_units)\n", "        self.linear_2 = nn.Linear(n_hidden_units, n_classes)\n", "        self.activation = nn.ReLU()\n", "\n", "        self.mc_dropout_p = mc_dropout_p\n", "        self.n_mc_samples = n_mc_samples\n", "\n", "        # Fixed dropout masks (n_mc_samples, n_features), used only in eval.\n", "        self.register_buffer(\"mc_masks\", None)\n", "\n", "    def _mc_enabled(self):\n", "        \"\"\"Return True if MC dropout is configured to be active in eval.\"\"\"\n", "        return (\n", "            not self.training\n", "            and self.n_mc_samples is not None\n", "            and self.n_mc_samples > 1\n", "            and self.mc_dropout_p > 0.0\n", "        )\n", "\n", "    def _init_mc_masks(self, device, n_features):\n", "        \"\"\"Sample fixed dropout masks if MC is enabled and masks are missing.\n", "        \"\"\"\n", "        if not self._mc_enabled():\n", "            self.mc_masks = None\n", "            return\n", "\n", "        expected_shape = (self.n_mc_samples, n_features)\n", "        if self.mc_masks is not None and self.mc_masks.shape == expected_shape:\n", "            return\n", "\n", "        keep_prob = 1.0 - self.mc_dropout_p\n", "        mask = torch.empty(\n", "            *expected_shape,\n", "            device=device,\n", "        ).bernoulli_(keep_prob) / keep_prob\n", "        self.mc_masks = mask\n", "\n", "    def _forward_head(self, x):\n", "        \"\"\"Shared MLP head.\n", "\n", "        Parameters\n", "        ----------\n", "        x : torch.Tensor of shape (batch_size, n_features)\n", "            Input embeddings or masked embeddings.\n", "\n", "        Returns\n", "        -------\n", "        logits : torch.Tensor of shape (batch_size, n_classes)\n", "            Class logits.\n", "        \"\"\"\n", "        hidden = self.activation(self.linear_1(x))\n", "        logits = self.linear_2(hidden)\n", "        return logits\n", "\n", "    def forward(self, x):\n", "        \"\"\"Compute logits and, in evaluation mode, optional MC statistics.\n", "\n", "        Parameters\n", "        ----------\n", "        x : torch.Tensor of shape (n_samples, n_features)\n", "            Input embeddings.\n", "\n", "        Returns\n", "        -------\n", "        Training mode (``self.training is True``)\n", "            logits : torch.Tensor of shape (n_samples, n_classes)\n", "                Class logits from a single forward pass with standard dropout\n", "                on the input embeddings.\n", "\n", "        Evaluation mode, MC disabled\n", "            logits : torch.Tensor of shape (n_samples, n_classes)\n", "                Deterministic class logits from a single forward pass without\n", "                dropout on the input embeddings.\n", "\n", "        Evaluation mode, MC enabled\n", "            logits_mean : torch.Tensor of shape (n_samples, n_classes)\n", "                Mean logits over MC ensemble members, i.e.\n", "                ``logits_mc.mean(axis=1)``.\n", "            logits_mc : torch.Tensor of shape (n_samples, n_mc_samples, n_classes)\n", "                Logits for each MC ensemble member, obtained by applying the\n", "                fixed dropout masks to the input embeddings.\n", "        \"\"\"\n", "        n_samples, n_features = x.shape\n", "\n", "        # Training: standard dropout with varying masks\n", "        if self.training:\n", "            if self.mc_dropout_p > 0.0:\n", "                x_dropped = F.dropout(x, p=self.mc_dropout_p, training=True)\n", "            else:\n", "                x_dropped = x\n", "            logits = self._forward_head(x_dropped)\n", "            return logits\n", "\n", "        # Evaluation, MC disabled: deterministic forward without dropout\n", "        if not self._mc_enabled():\n", "            logits = self._forward_head(x)\n", "            return logits\n", "\n", "        # Evaluation, MC enabled: use fixed masks as ensemble members\n", "        self._init_mc_masks(x.device, n_features)\n", "        if self.mc_masks is None:\n", "            # Safety fallback: behave as if MC were disabled\n", "            logits = self._forward_head(x)\n", "            return logits\n", "\n", "        # x: (B, F) -> (B, 1, F)\n", "        x_expanded = x.unsqueeze(1)\n", "        # mc_masks: (S, F) -> (1, S, F)\n", "        mc_masks_expanded = self.mc_masks.unsqueeze(0)\n", "\n", "        # Apply fixed masks: (B, S, F)\n", "        x_masked = x_expanded * mc_masks_expanded\n", "\n", "        # Flatten batch and sample dims for shared head: (B * S, F)\n", "        x_masked_flat = x_masked.reshape(-1, n_features)\n", "        logits_mc_flat = self._forward_head(x_masked_flat)\n", "        # Reshape back to (B, S, C)\n", "        logits_mc = logits_mc_flat.view(n_samples, self.n_mc_samples, -1)\n", "\n", "        logits_mean = logits_mc.mean(dim=1)\n", "        return logits_mean, logits_mc"]}, {"cell_type": "markdown", "id": "ced770af8b09b8fb", "metadata": {}, "source": ["## Bayesian Skorch Classifier\n", "\n", "In this step, we define a ``BayesianSkorchClassifier`` that extends ``SkorchClassifier`` with a sample_proba method, which returns the class probabilities predicted by each individual ensemble member (e.g., MC dropout samples). We then initialize the classifier with the ClassificationModule as ``pytorch`` module, configure MC dropout via ``n_mc_samples`` and ``mc_dropout_p``, and set standard training hyperparameters such as optimizer, learning rate, batch size, and learning rate scheduler."]}, {"cell_type": "code", "execution_count": 5, "id": "86e08db36c0d3778", "metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:05:08.030485Z", "start_time": "2025-12-08T16:05:08.026422Z"}}, "outputs": [], "source": ["class BayesianSkorchClassifier(SkorchClassifier):\n", "    \"\"\"\n", "    Helper class implement a function returning the predicted class probabilities\n", "    predicted by the individual ensemble members.\n", "    \"\"\"\n", "\n", "    def sample_proba(self, X):\n", "        \"\"\"Returns the predicted class probabilities predicted by\n", "         the individual ensemble members.\n", "\n", "         Parameters\n", "         ----------\n", "         X : numpy.ndarray of shape (n_samples, n_features)\n", "            Test samples\n", "\n", "        Returns\n", "        -------\n", "        P_mc : numpy.ndarray of shape (n_members, n_samples, n_classes)\n", "            Probabilities predicted by the individual ensemble members.\n", "        \"\"\"\n", "        # Swap axes to have desired shape.\n", "        P_mc = self.predict_proba(X, extra_outputs=[\"probas_mc\"])[-1].swapaxes(0, 1)\n", "        return P_mc\n", "\n", "\n", "# Initialize classifier including training hyperparameters.\n", "clf_init = BayesianSkorchClassifier(\n", "    module=ClassificationModule,\n", "    criterion=nn.CrossEntropyLoss,\n", "    forward_outputs={\"proba\": (0, nn.Softmax(dim=-1)), \"probas_mc\": (1, nn.Softmax(dim=-1))},\n", "    neural_net_param_dict={\n", "        # Module-related parameters.\n", "        \"module__n_features\": n_features,\n", "        \"module__n_hidden_units\": 128,\n", "        \"module__n_classes\": len(classes),\n", "        \"module__n_mc_samples\": 10,\n", "        \"module__mc_dropout_p\": 0.2,\n", "        # Optimizer-related parameters.\n", "        \"max_epochs\": 50,\n", "        \"batch_size\": 16,\n", "        \"lr\": 0.01,\n", "        \"optimizer\": torch.optim.RAdam,\n", "        \"callbacks\": [\n", "            (\"lr_scheduler\", LRScheduler(policy=CosineAnnealingLR, T_max=50))\n", "        ],\n", "        # General parameters.\n", "        \"verbose\": 0,\n", "        \"device\": device,\n", "        \"train_split\": False,\n", "        \"iterator_train__shuffle\": True,\n", "    },\n", "    classes=classes,\n", "    missing_label=missing_label,\n", ").initialize()"]}, {"cell_type": "markdown", "id": "53f53ca730aa54fb", "metadata": {}, "source": ["## Active Classification\n", "For our classifier, we evaluate five different query strategies regarding their sample selection. For this purpose, we start with ``n_init_labels=64`` initial labels selected via random sampling and make ``n_cycles=10`` iterations of an active learning cycle with ``batch_size=32``."]}, {"cell_type": "code", "execution_count": 6, "id": "cef2ac8b873523c9", "metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:18:22.014635Z", "start_time": "2025-12-08T16:17:35.964345Z"}}, "outputs": [{"name": "stdout", "output_type": "stream", "text": ["Execute active learning using RandomSampling.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:06<00:00,  1.54it/s]\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Execute active learning using UncertaintySampling.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:07<00:00,  1.38it/s]\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Execute active learning using QBC.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:07<00:00,  1.38it/s]\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Execute active learning using GreedyBALD.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:07<00:00,  1.36it/s]\n"]}, {"name": "stdout", "output_type": "stream", "text": ["Execute active learning using BatchBALD.\n"]}, {"name": "stderr", "output_type": "stream", "text": ["100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:12<00:00,  1.22s/it]\n"]}], "source": ["# Define setup.\n", "n_cycles = 10\n", "batch_size = 32\n", "n_sub_set = 5000\n", "n_init_labels = 64\n", "qs_dict = {\n", "    \"RandomSampling\": RandomSampling(\n", "        random_state=random_state, missing_label=missing_label\n", "    ),\n", "    \"UncertaintySampling\": UncertaintySampling(\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "        method=\"margin_sampling\",\n", "    ),\n", "    \"QBC\": QueryByCommittee(\n", "        method=\"vote_entropy\",\n", "        sample_predictions_method_name=\"sample_proba\",\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "    ),\n", "    \"GreedyBALD\": GreedyBALD(\n", "        sample_predictions_method_name=\"sample_proba\",\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "    ),\n", "    \"BatchBALD\": BatchBALD(\n", "        sample_predictions_method_name=\"sample_proba\",\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "    ),\n", "}\n", "acc_dict = {key: np.zeros(n_cycles + 1) for key in qs_dict}\n", "\n", "\n", "# Perform active learning with each query strategy.\n", "for qs_name, qs in qs_dict.items():\n", "    print(f\"Execute active learning using {qs_name}.\")\n", "    # Set seed and copy classifier for consistent initialization.\n", "    torch.manual_seed(random_state)\n", "    torch.cuda.manual_seed(random_state)\n", "    clf = deepcopy(clf_init)\n", "\n", "    # Wrapper to subsample unlabeled samples.\n", "    qs = SubSamplingWrapper(\n", "        query_strategy=qs,\n", "        max_candidates=n_sub_set,\n", "        exclude_non_subsample=True,\n", "        random_state=random_state,\n", "        missing_label=missing_label,\n", "    )\n", "    qs_init = RandomSampling(random_state=random_state, missing_label=missing_label)\n", "\n", "    # Create array with 64 initial labels.\n", "    y = np.full_like(y_pool, fill_value=missing_label, dtype=np.int64)\n", "    init_indices = np.random.RandomState(0).choice(\n", "        np.arange(len(y)), size=n_init_labels, replace=False\n", "    )\n", "    y[init_indices] = y_pool[init_indices]\n", "\n", "    # Execute active learning cycle.\n", "    for c in tqdm(range(n_cycles)):\n", "        # Fit and evaluate clf.\n", "        acc = clf.fit(X_pool, y).score(X_test, y_test)\n", "        acc_dict[qs_name][c] = acc\n", "\n", "        # Select and update training data.\n", "        query_idx = call_func(\n", "            qs.query,\n", "            X=X_pool,\n", "            y=y,\n", "            clf=clf,\n", "            fit_clf=False,\n", "            ensemble=clf,\n", "            fit_ensemble=False,\n", "            batch_size=batch_size,\n", "        )\n", "        y[query_idx] = y_pool[query_idx]\n", "\n", "    # Fit and evaluate clf.\n", "    clf.fit(X_pool, y)\n", "    acc_dict[qs_name][n_cycles] = clf.score(X_test, y_test)"]}, {"cell_type": "markdown", "id": "a75b9e609395597d", "metadata": {}, "source": ["## Visualize Results\n", "In the following, we plot the obtained learning curves including the area under learning curve (AULC) scores per query strategy."]}, {"cell_type": "code", "execution_count": 7, "id": "29fb5f84c2666a20", "metadata": {"ExecuteTime": {"end_time": "2025-12-08T16:18:22.110798Z", "start_time": "2025-12-08T16:18:22.017097Z"}}, "outputs": [{"data": {"image/png": "iVBORw0KGgoAAAANSUhEUgAABS8AAAMACAYAAADFYpKQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/Xd8nGl97/+/pjf1LtuyreJ173V7Xy/LLmvTQnIgHE5yTgohhJJvfiE5BEg7OaElAUIScgj9hAPYS1nWZgvLNq97t2yruap3TS/37497NNKouMszkt7Px2MeM3O3ucZjW9Jbn+v6WAzDMBARERERERERERHJMtZMD0BERERERERERERkIgovRUREREREREREJCspvBQREREREREREZGspPBSREREREREREREspLCSxEREREREREREclKCi9FREREREREREQkKym8FBERERERERERkayk8FJERERERERERESykj3TA5huEokEly9fJjc3F4vFkunhiIiIiIiIiIiITCuGYTA4OMicOXOwWq9cW6nw8jpdvnyZqqqqTA9DRERERERERERkWrtw4QLz5s274jEKL69Tbm4uYP7h5uXlZXg0UyMajbJ7924ee+wxHA5Hpocj10mf3/Snz3D602c4/ekznN70+U1/+gynP32G05s+v+lPn+H0N9M/w4GBAaqqqlI525UovLxOw1PF8/LyZnR46fV6ycvLm5H/QGY6fX7Tnz7D6U+f4fSnz3B60+c3/ekznP70GU5v+vymP32G099s+QyvZUlGNewRERERERERERGRrKTwUkRERERERERERLKSwksRERERERERERHJSgovRUREREREREREJCspvBQREREREREREZGspPBSREREREREREREspLCSxEREREREREREclKCi9FREREREREREQkKym8FBERERERERERkayk8FJERERERERERESyksJLERERERERERERyUoKL0VERERERERERCQrKbwUERERERERERGRrKTwUkRERERERERERLKSwksRERERERERERHJSgovRUREREREREREJCspvBQREREREREREZGspPBSREREREREREREspLCSxEREREREREREclKCi9FREREREREREQkKym8FBERERERERERkayk8FJERERERERERESykj3TAxAREREREREREZm2DAMScYiHIRaGeDT5OGLexyOTPI4mjx/9OAKxMNZoiKWXW4AnMv3uMk7hpYiIiIiIiIiIZD/DGAkGJwz+xoeAxCOTPI5eY9h4pWuPugbGLX2rNqDG6rzFV52eFF6KiIiIiIiIiMgIw5g8/Js0+BsbAkbGBIKThIDXdO1R15sWLGB3gc0FNkfysTN57zC3pz12mvtTj13ELTYaz12iJtNvJQsovBQRERERERERyTbxKEQDEA2Z97HQqOdBiAXN++HbqOfWsJ815xuwPfMTSESvP2BMRDP97q+NxXZdgeBIkDgmVEwFi8OPnddwvStc22oDi+Wm3loiGqX+2WcVXqLwUkRERERERETk2sSjE4aF6c8nChuvJ3xMHmfEb3iYNmABQPctet9W+xUCvLHB3wQhYFogeKUQcPQ1rhYwJkNCmfEUXoqIiIiIiIjI9HW7AsVYEBKxDLxBCzi84HCb93b3mMdj93mIW12cbjrH4mUrsTk9VwkYr1JxaHOC1ZqB9y1iUngpIiIiIiIiIrfWcKB4w2Fh8NrPz1ig6DFv9uT9VQLF8cdP9nzM+TbndU9BTkSjnA08y6ItT2BzOKboz0Dk9lB4KSIiIiIiIjIbxWMQHoBQf/J+AMIDWPy9VHfuwfpGQ7KJyrUEimP2ZSRQZILw8AbCwmsJH+2um17TUESujcJLERERERERkelmkuAx/b5/gu2jtkUDE17aDqwCuHiLxnrNgeJNVioqUBSZkRReioiIiIiIiNxOw8Hj2LAxLYicKHgcdR/137rxOLzgygN3HrjySLhyae0ZonJ+LVanV4GiiGSUwksRERERERGRazVZ8Dg2dLxSReStDB7tHjN0dOenBZAj95NtzwNXvnlvS18TMR6Nsv/ZZ3niiSewar3EaSdhJLg8dJnLscu0+dsozy3HaXNmelgiN0zhpYiIiIiIiMwOifgNTLMeE0RORfA4Nmy8ieBRZo9oIsqFgQs09TfR1N9EY18jzf3NtAy0EIwFAfjKM18BINeZS7G7mGJPMUXuotTjYk/xyOPkvcfuyeTbEhlH4aWIiIiIiIhkv0R8ktCx/9qmWYcHIDJ068YzYfA4OoBU8Ci3RjAWpKW/JRVSNvWZ9+cHzhMzJm6M5LA6cBtugpYgsUSMwcggg5FBWgZarvp6XrvXDDhHB5sThJxF7iJyHDlYtCyATDGFlyIiIiIiIjK1Jg0eRwWQY5vJZDJ4nLQSMhk8unLBrmm4cmsNRAZo6muiub+Zxr7GVFh5eegyBsaE53jtXmrya6gpqKE6v5ra/FpqCmooc5Wx+7ndvOUtbyFoBOkOdtMd6k677wn1jNsejocJxAIEhgJcHLp6xyaXzXXFSs7RIWi+K19Bp9wQhZciIiIiIiJy46Ih6G2G7obUzdbdyIMd57E3/AmEBzMYPI66d+creJSMMwyD7lB3qnpyeKp3U38TncHOSc8rcBWkQsqa/JpUSFnuLZ8wEIxGowBYLBbynfnku/KpoeaqY/NH/dcUcnYHuwnEAoTjYVr9rbT6W6/63u0WeyrMLPIUTRpyFnuKKXQVYrParnpNmR0UXoqIiIiIiMiVJeLQfyEZTjamBZX0XYAxVWFWIA8gNOY6dvck1YxXW99x1H4FjzINJIwErf7WVEg5err3QGRg0vPKveVpIeXw4yJ30ZSP2WKxkOPMIceZw4K8BVc9PhgLXlPI2R3qZjAySMyI0RHsoCPYcdVrWy1WClwF46apj526Xuw2g1CHVUswzGQKL0VERERERAQMA/yd6cHkcFDZ0wTxyOTnuvKguC51ixUs4M3jzWy67xEcviIFjzJjRRNRLgxeoLmvmcb+xlRIObppzlhWi5V5OfOoya+huiA51TvfnPad48y5ze/gxnnsHublzmNe7ryrHhuJR64YbvYEe1LP+8J9JIwEPaEeekI9nOXsVa+f78qfsIJz3L2nGJfNdSvevtxGCi9FRERERERmk9AA9DSOr6DsbjTXlpyMzQVFNVBcmxZUUlwHvhIYNXXViEbpOvcsVK4BhyqiZPoLxUK0DLSk1qJs7m+mqa+Jc4PniCUmbppjt9pZmLcwVT1Zm19LdX41C/MXzroAzWlzUuGroMJXcdVjY4kYvaHeK4adw/e9oV7iRpz+cD/94X6a+puuen2fwzd5uDm6ytNTjNfu1TqdWUDhpYiIiIiIyEwTC0NP+jqU9DSZ90PtVzjRAgXzx4STybAyfx5oDTqZ4UY3zRme7t3Y13jFpjkeuydtivfw43m587BbFbtcL7vVTqm3lFJv6VWPTRgJ+sP9Vw05h6e1RxNR/FE//qif84Pnr3p9t82dNj197HT10c/znHkKOqeI/hWJiIiIiIhMR4k49F+ceB3K/gtgJCY/N6ccimrHV1EWLgSH+7a9BZFMGNs0Z/R6lFdqmpPvyk9VT9bk11BbYE73LveVY7VYb+M7kGFWi5VCdyGF7kLqqLvisYZhMBgdNAPNyaavJ6s9e0I9BGNBQvEQl4YucWno0lXH4rA6xk1bn6wTe4GrQH9nroPCSxERERERkWxlGODvGjO9OxlW9jRBPDz5uc5cKKkbX0VZVGs2wRGZ4cY2zWnub05N+75S05wyb1mqerK2YCSsLHIXqbJuGrNYLOQ588hz5lGdX33V4wPRwFVDzuFtQ9Ehooko7YF22gNXqm432Sw2Ct2FE6/TmXyc78hnMDGIYUxc8TubKLwUERERERHJtPDgqOrJxjHrUPZPfp7NmVyHsm58FaWvNG0dSpGZanTTnKb+JrNxzlWa5liwMC933rjp3tX51eQ6c2/zO5Bs5HV48Tq8VOVVXfXYUCw0LtDsCfVMGHz2h/uJG3G6gl10BbuueF0LFt7Fu27VW5q2FF6KiIiIiIjcDrEI9LZM3M17qO0KJ1qgoGqSdSirtA6lzBrDTXPGTve+lqY5Y6d6L8hbgNuuJRLk1nDb3czJmcOcnDlXPTYaj6YFm5OFnN3BbqLhqKaXo/BSRERERETk1kkkYGCidSgboe/cldeh9JVOXEFZWK11KGVWGYwMpq1DOfz40tClKzbNGQ4oR1dSzsudh8OqjveSPRw2B+W+csp95Vc8LhqN8tOf/fQ2jSq7KbwUERERERG5HoYBge7J16GMhSY/15kzpoJyOKysBXf+7XsPIhk23DSnub+Zpr7kVO/+Jpr7mukIdkx6Xp4zL1U9OTqkrPBVqEJNZhz9nTYpvBQREREREZlIeAh6JlqHsgFCV1iH0uqYfB3KnDKtQymzSsJI0OZvM9ei7Gs0w8pkNWX/FdZzLfOUUV2QnOqdX0tNgbkeZbG7WE1zRGYZhZciIiIiIjJ7xSLmdO6J1qEcbL3CiRZzvcmx4WRxrbndph+1ZHaJJWJcGLwwbrp3c3/zFZvmzM2Zm6qeHK6krM6vJs+Zd5vfgYhkK31FFRERERGRmS2RgMHL48PJ7gboPQdGfPJzvSXjm+QU10FRNTg8t+89iGSJUCzEuYFzNPY1pgWULQMtkzfNsdhZkLcgFUwOV1IuzFuopjkiclUKL0VEREREZPozDAj0jF+HsqfJDCsnqfwCkutQjqmgLKqF4hrwFN6+9yCSRUJGiGNdxzg3dC411buxr/GqTXMW5i1MVVLW5tdSXVBNVW6VmuaIyA1TeCkiIiIiItNHxD+qcnLsOpR9k59ndZjVkhOuQ1mudShlVorEI1wcvEjLQAvnBs5xbuCc+bj/HF2hLtg98Xm5ztxU9eTo6d6Vvko1GBGRW07hpYiIiIiIZJdYGF+oFcvZXdDXkj7de/Dylc+ddB3K+VqHUmaleCJOW6AtFU6ODigv+y+TMBKTnlviKTGrJ/OrRzp8F9SoaY7IDYpF4oQDMUKBKOFAjLA/eR+IEUo9jhLyxwj5I/T1e+CJTI868/TVW0REREREpl7ED/5OGOoEfwcMdSSfdySfd5rP/R04Qv08AnBqkmt5iydZh7JG61DKrGQYBj2hnvRwMvn4/MB5IonIpOd67V4W5C1gYd5CFuQvYEHeAuZ551H/Rj3vePIdOBya7i0yWjyeIOw3Q8axoaMZSI4KJ5NB5PC+eHTyXxZMyGLDMCZepmE2UXgpIiIiIiLXzzAgPJAWOqYHkmOCyaj/ui4fs7qwld6BpWRRekhZVAPeoil6UyLZzR/1jw8o+83ng9HBSc+zW+3Mz52fCinn5408LvGUjKuijEajnLOem+q3I5IxiYRBZMIKyCihK1VEBmLEwldo8nYNLBZweR24vHZcPgdurz312OW1p/Y5XBYOHT1wi97x9KbwUkRERERETIYBwd5RoWMH+LsmDybj4eu7vt0DOaXgKwVfWfJxGeSUmdtyysBXRtRVyLMvvsYTb32rqr5k1onGo1wYupAKJUdXUXYGOyc9z4KFSl8lC/LM6smF+QtTjyt9ldit+vFfZhbDMIiE4qmgMRSIplVEXimIjARjN/36ruHQ0TsqdPTZk2HkyDa3z54WVjpdNizWqy+7EI1GOXkpriUaUHgpIiIiIjKzJeIQ6B4zPXuSYNLfCYnr/IHOmTsqhLxKMOnMubbGONGoGujIjJYwErT728c3yhk4x6WhS1dch7LIXZQKJVPTvfMWUJVbhdvuvo3vQuTmGYZBLJJIn3rtn7giMr0K0tx2szOqHS7bmApIM4AcDhvdYyoih4NIp8eO9RoCSLk1FF6KiIiIiEw3sQgEuiZZN3JMGBnohisEIRNyF6SqICcOJkcFklpjUmRChmHQG+41g8n+9JDywuAFwleoXPbYPalQcnRIOT9vPvmu/Nv4LkSuTSwan3C9x2sJIhPxm0sg7Q7ruGnXEwaRqf0j+2w26y36E5CppPBSRERERCQbRIPpoeO4QHJUMBnqu86LW8wmN2OmZ6eCSV9p+mO7cyreociMFIgGJmyU0zLQwmDkyutQVuVWpVVPXmkdSpGpNrYRzbhmNP5RU7FHBZKhG2lEM4bVZhkTMI6tgJzsuR27w3aL/gQkWym8FBERERGZCoYBkaHx1ZH+romDySuEHBOy2NJDxysFk95isOlbf5EbFY1HuTh0ccJmOR3Bjiuem7YOZTKkXJi3kMocrUMpUycciBHpt3LxVC+xiHHlIDK5PXorG9FcKYgc05jG7XNgd1oV2Muk9D+liIiIiMi1Mgyz6nHs9OzJgslY8Pqub3NOMFV7omCyzJzabdV0N5FbJWEk6Ah0mMFkf3oV5aWhS8SNyYOdQlfhhI1yqnKr8Ni1tIJMLSNh0NseoK2pP3kboLfVD/h49vXj1309p8ee3mRm7JqQac1prr8Rjcj1UngpIiIiIrNbImGuC+mfYHr2uOnbnZCIXt/1Hb6Jp2dPVCnpylOjGpEp1hfqm7BRzvmB84TioUnPm2gdyuGb1qGU2ykSitHeMkB7Uz+tjQO0N/cTDoxvtmZ1JSgozsWT40jrdp1qRDNBRaQa0Ug2UngpIiIiIjOOxYjBYCuEe0dCx3GBZPI+0HX9DW1c+dfRYds3NW9SRCYViAY4P3g+VUU5OqgciAxMep7dYmde7ryRkDJ/ZKp3qadU01rltjMMg4GuIG1NA7Q19tPa1E/PpaFxXbZtDivlC/OoqMmjoiaf4iovL73yPE88cT8OhyMzgxe5RRReioiIiEj2MQwID0Kof8ytb/y2YPo2e6iPt4UH4PB1vqanaJJ1I0vHryHpcN/69ywi1yWaiHJp8NKEjXI6Aldeh7LCVzFho5w5OXO0DqVkVCwSp+Pc4Kgp4P0EB8dX/OcUuaisyae8Jp/K2nyK5+Wkdc6ORq9zloBIFtP/yiIiIiJy6xkGRANXCRone5y8XW81ZNJwXZRhsWLxlowJJEcFk2kdtkvApsoUkWwzvA7lRN28Lw5evOI6lAWugnGNchbkLWB+3nytQylZY7AnNBJUNvbTdWGIRCK9rNJqt1BalUtFbT4V1flU1OSTU+jK0IhFbj+FlyIiIiIysVh4XFWjGTKO3Ta++pFQ//WvDTkRqwM8BWZzGnf++Jtn7PYConYfz7+6n0eeehcOlyokRaaD/nB/Kphs6R8JKM8Pnid4hcZXHrsnbe3J0SGl1qGUbBOPJei8MEhbo9lUp62pH39feNxx3jynGVTWmLfS+TnYHbYMjFgkOyi8FBEREZmp4tGJKxsnChonCiRjkzeuuGYW2yQhY/6YQLJg4kDS7r7+BjbRKBHHGbDqBz2RbBKMBTk/cH7CKsq+cN+k5w2vQzlRSFnmLdM6lJK1/P1h2psGaG3qp72pn45zg8Rj6bMKLFYLJfNyzKCyNo+K6nxyi936ey0yisJLERERkWyViE8QMk4SNE4USkb9t2AQFnDnTVD5WHBtoaTTp+7ZIjOYYRhEEhGGIkP4o36GouZ9b6CX10KvcXjvYS4MXaBloIX2QPsVr1XuLU9fgzLffDwnZw4Oq5Z1kOyWiCfovuSnramf1sZ+2pv7Gega/0tAt8+RrKo0G+uULcjD4dIv20SuROGliIiIyFRJJCAyUdOZa6x+DE/eEfe6OHMnCRnHVj9OUPnozAWr9SovICLTTcJIEIwF00LHoegQgWggFUCO3Td22/B9LBGb/IUa0p+OXYdyft58FuYtpCq3Cq/DO7VvWuQWCg1F05rqtLcMEIuMWavZAsVzfKnp3xU1+eSXeVRVKXKdFF6KiIiITMYwIOK/hqCxb+JAMjxww01n0ji8Vw8ZJwskXXlg07d8IjNFLBHDH/WnB4gTBIoTbfNHRp77o34MjKu/4HXwOXwjN7sPBmDzHZupKawxA8vcBRS4C27pa4rcDkbCoKfVPyqsHKCvPTDuOKfHTkV1XqqxTll1Hi6PvgaL3Cz9KxIREREZFo/Cgf/Avu9rPN57CfuRIFypouha2VzXsObj2FCyYCR8tDtvfgwikjGTTa0eigylh4uTBJHDYaM/6r9i85obYbPY8Dl85Dhy8DmT944x98ntE20bfu51eLFaRqq0o9Eozz77LE+sfgKHQ1O+ZXoJB2O0N5vdv9uaB2hv6icSGt/ZvrDCS3lNPpU1+ZTX5FFU4cNiVVWlyK2m8FJERETEMODsbtj959B1BgvgGr3far/GyseCiUNJhzpei0xHk02tnihkvFoAecWp1TfAZXOlh4zO8aHjRNvGho4um0tTWGVWMwyD/o4grY0jU8B7Wv2MLUy2u2yUL8wdmQJenY87R8G8yO2g8FJERERmt7bjsPvPoOmX5nNvCfF7/z9ePhfj3kefwpFbbE7b1g/3ItPG8NTq4enTgVgg66ZWp1UyXkPIOPo8n8OHw6bQRORGRMNx2lsGRtaqbBog5I+OOy6vxJ2a/l1Rm0/xHB9Wm9aAFskEhZciIiIyOw22w0t/BQe/BRhgc8KW34d7P0rC5mWw41nIqwRNdxS57bqD3VyOXWZ/+35CidA1T60e3h6Kj+/wezNsFhs5zpwrTqmeMGS8ytRqEZlahmEw2B0yg8rkFPCui0MYifRfStjsVsoW5qaCyoqafLx5WrJFJFsovBQREZHZJRqEN74Er3wBon5z2/K3wyN/AYULk8eMr8AQkVvPMAxa/a2c6j7FyZ6T1PfUc6r7FJ3BTvOAF27u+m6be/LKxuGQUVOrRa6bYRiQSEAiMfI4Hh+/PR7HSCTM5VkSCYx4wmxkl0iY24ePTRhgJDDicUg+Tm1PJK+ROmb8NYb3x2MJunoMurotdPZa6eyzEgqP/4WB1xmnJDdMcW6YEl+YAncQKwnoMqAzgf+1OP7h10skIPma5ngSI+NIJDCM5NhGj3P0+xs+Lx4fdWzyvLHXGPtnmJho/2TXGH5d88/QSCSoDYdp+l9/Z/7/lbqBhdHPLWC1jN82+lirNX2bxQLXew3L6OtMMAaLJble6PjzsVgmvsYE45jsGmnHWq0j1x13jeHt1mu6RurP9qrXGPV6adeZYFvy+EQiQf6ZM/DEE7fjn3VWU3gpIiIis0MiAcd/AM9/GgYumtvmboCtfwPzN2d2bCKzQMJIcG7gXCqgHA4r+8P94461YCHXkktJXokZLtqvfWr1cIWk1+HFYVXltMi1Svj9BA4fJnjgIP79+6g9foLGT39mJHgcFTZi3NrlFG5U2JlPf34N/XnV9OfXMJhThWFNjzksiRi5QxfJ728ib6CZ/IEm3OG+1P440H17h33b2IBEYHxXdJk+Sh0O+Mu/zPQwMk7hpYiIiMx8596AXZ+AywfN5/lV8MinYMU7tJalyBSIJqI09TVxqucUp7pPUd9TT31PPYHY+B+i7VY7dQV1LC1aytLipSwtWkp1TjW//MUveeIJdaoWmSqxnh4CBw4Q3H+AwIEDhE6dgvhIR20b43rW3BirFWw2s7rMagWr1Xw8dlvyfvR+syrN3Jaw2hh0VdDnmkOfs4JeRyUhW+64l3MZQQoSnRQZXRTSTYGtH3ueAQVWsBZisW5Kvp4FLGNf25J8nP7aFpt11LHJ82zJ8yzJ82y2kcfJa4x+DXO7bWT/tVzDknzt4cdWy8jYhsdsmfi1Y4k4r7zyCvfeey92a/LTNEZuhmGYH7BhmPuSoXRq+9jjE8bIsVe4hpE6hwmONcyq0Wu6BiOvz+TXSHu91OOrXQPz/V7pGhjJquGrXGP42HFjmPwaaa93hWskEnEutXfcin+F057CSxEREZm5eprh+b+Ak8+Yz505cO9HzbUtHZ7Mjk1khgjFQpztPWsGlcmw8mzvWSKJyLhj3TY3dxTdYQaVybCyrqAOpy19bbmolm4QuaUMwyB66RKB/fsJHjhI4MABIk1N446zz6nEu34DrjVr2D/Qz31bt2J3upKh2dgwbSRAmzh4tN7UcguBgUiqqU5bUz8d5waJRxNpx1gsUDwvZ6QDeE0+eSVuLfOA+f9o5MwZXHV1+iXQNBWNRjn47LOZHkZWUHgpIiIiM0+wD175LLz5LxCPmNUI634THvwzyCnL9OhEpq2hyBCne09zqvtUKqxs6msibsTHHZvjyGFJ0ZJUNeXSoqUszF+I3aofQUSmmpFIED7bQODA/lRlZay9fdxxrkV1eNavx7t+A97163DMmQOYoUn42WdxVFXdluArEU/QfdlPe1M/rU39tDUNMNAZHD9en90MKZONdcoW5OJ06/8UkZlO/8pFRERk5ohH4cB/wEt/A8Eec1vNg7D1r6F8eUaHJjLd9IZ606Z9n+o5xbmBcxMeW+QuSlVSLilawrKiZczNnavO2iK3iRGJEDx+YiSsPHSIxMBA+kF2O+7ly8ygcsN6PGvXYi8szMh4Q/4obU39tDcP0NrYT0fLANHwmF+CWKCo0pesqMyjoiafgnKvqipFZiGFlyIiIjL9GQac3Q27/xy6zpjbShaboWXdI1rXUuQKDMOgI9CRNu37VM8p2vxtEx5f4atIm/a9tGgpZd4yBQoit1F8yE/w0CECB801K4NHj2KEw2nHWLxevGtWpyorPatXYfXc/iVTjIRBb1sgbQp4b9v49W+dbhvl1Xmp6d/l1Xm4vJruLCIKL0VERGS6azsOu/8Mmn5pPvcWw4OfgHX/FWz6VkdkNMMwuDh0MW3a96nuU/SEeiY8fn7u/LRp30uKl1DkLrrNoxaRWFcXgQMHU5WVofr6ZMOREbbCQrOict16vBvW416yBEsG1jqMBGO0twykgsr25gHCgdi44wrKvVRU51FRa4aVhZU+rFb9EkRExtN39CIiIjI9DbbDS38Fh74NRgJsTtjye3Dvx8Cdn+nRiWRcPBGnZaCFk90nU9O+67vrGYwOjjvWarFSk1/DsuJl5jqVReb07xxnTgZGLjK7GYZB9MIFAvsPmGHlgYNEWlrGHeeYO9cMK9evx7thA87q6tteAW0YBv2dQTOobDTXquy+PDSuTbndaaV8YR7lNflU1uRTXpOHJ8c58UVFRMZQeCkiIiLTSzQIb3wJXv0iRIbMbcu3wyOfgsKFGRyYSOZE4hEa+hqo76nnZPdJTvWYHb+DsfENLxxWB4sKF7G0aCnLipextGgpiwoX4ba7MzByETHiccJnz46ElfsPEOvsTD/IYsG1aNFIWLl+PY6Kits+1mgkTkeqqtK8Dw1Fxx2XW+xOTf+urM2neK4Pq01r4IrIjVF4KSIiItNDIgHHfwDPfxoGLprb5q6HrX8D87dkdmwit1EgGuBM7xmzkrKnnlPdpzjbd5ZYYvy0TI/dk1ZJuax4GTUFNTisWkdOJFMSkQihY8dGwspDh0kMjqmIdjjwrFiBd/06M6xctw5b/u2dVWAYMNgTovt8D61N/bQ39dN1YYhEIr2s0ma3Ujo/Nzn921yz0pfvuq1jFZGZTeGliIiIZL/ze2DXJ+DSAfN53jyz0nLFO8CqSg6ZuQYiA9R316etT9ky0ELCSIw7Ns+Zl9ZEZ2nxUubnzsdmtWVg5CIyLD44SPDw4VRYGTp6DCMSSTvG6vXiWbs2VVnpWbUKq3vqq6GjkThDPSEGe0IMdocY6g0z2B1ioDtA+wUf33tu37hzfPnO1DqVFTX5lFblYnPoa7GITB2FlyIiIpK9eprh+U/ByZ3mc2cO3PMRuPOD4Lj9HVNFplJXsCtVSTkcVF4cujjhsSWeknFB5RzfHHX8FskCsc5OAgcOJMPKA4RPnx7fXKe4GO/69cnKyg24lyzGYr+1P54bhkHYHzODyWQ4Ofx4OLAMDo6f8j3CisVqobQqxwwqk4FlTqFL/9eIyG2l8FJERESyT7APXvkcvPlViEfAYoW174MH/wxyyzM9OpGbYhgGbf42TvacHAkru0/REeyY8Pi5OXNT076Hw8pSb+ltHrWITMQwDKLnzo2ElQcPED13ftxxjqoqM6xMVlY6Fy686QAwEU/g74+kBZOjqygHe8PEwvGrXsfhspFb7Ca3yLzlFLnw5js4dvogT73rUTw+rYcrIpml8FJERESyRzwGB74Ov/xbCHSb22oegMf+GipWZHRoIjciYSQ4P3DebKTTc5JT3eY6lX3hvnHHWrCwMH+huTZl0TKWFpuBZb7r9q5zJyKTM+JxwqdPp6oqAwcPEO/sSj/IYsG1ePFIWLluPY7ysut+rbFTukeqJs2p3UN9YYwx609OxJPnJLfQNRJQFrvJKXSnnru89nFBajQa5UxHArtTy06ISOYpvBQREZHMMww4+wvY/efQddrcVnKHGVouehQ0PU2mgVgiRlN/UyqgPNl9ktO9p/FH/eOOtVvs1BbUpgLKZcXLWFy4GK/Dm4GRi8hkEuEwoaNHU5WVwUOHSPjT/01bHA7cK1eOhJVr12LLy7viddOmdI8KJkfWnrzalG6T1Wohp8g1qmrSnV5FWehSACki057CSxEREcms9hOw68+g6SXzubcYHvhTWP9fwaaOyJKdwvEwZ3vPptamHO74HY6Hxx3rsrlYXLh4ZNp38VLqCupw2dSNVyTbxAcGCB46lKqsDB07hhFNDxGtOTlmc51kWOleuRKrK/3f80RTulPTuq9nSrfblgoiU1WTRS5yizzkFrnx5juxWvULPhGZ2RReioiISGYMtsNLfw2HvgVGAmxO2Py7cO/HwFOQ6dGJpPijfk73nOZUzylOdpvrVDb2NRI3xgcPPofPDCmLlrKseBlLipZQnV+N3apvu0WyUbS9g+CB/SPNdc6cMWcDjGIrLcG7fgPedevwbliPa/FiYnEY6gnR1R1icG9XetVkT/j6pnSnwsmRqd05RZNP6RYRmW2y+ruo1tZWvv71r3P06FEcDgebN2/m/e9/P7m5udd1HcMweO6553j22We5fPkyBQUFPPDAA7znPe/B4VBFh4iIyG0VDcIbX4ZXvwCRIXPbsm3wyKegqDqTIxOhL9THqZ5TaV2/zw2cw2B8CFHoKkxN+15avJRlRcuYlzsPq8WagZGLyNUYhkGkuYXAgf0EDxwkcOAA0QsXxh1nXzAf+9o7MRavJTq3joA1l46eMIO9IQZ3+hnseZ3Q0DVM6bZZyCkcNaV71HTu4cY4doemdIuIXE3WhpevvvoqTz31FH19falt3/72t/n85z/Piy++yMKFC6/pOsFgkLe//e0899xzadv/z//5P/zDP/wDv/jFLygsLLyFIxcREZEJJRJw/Ifw/Kdg4KK5bc46ePxvYf6WjA5NZh/DMOgMdqbWphxep/Ky//KEx5d7y1latDTV7Xtp8VLKveWqiBLJYkYsRqj+9Ehl5cGDxLu7SVisRJz5hNxFhCo2EZt3B9HyGsK+UgKGh6H+KLG+BLwJ0J68jZea0l3sJndUA5zhqklN6RYRuTWyMrwcGBjg7W9/O319fTz88MP8t//23wgGg/zTP/0TR44c4d3vfjdvvvnmNX2z+Md//Mc899xz5Ofn86EPfYiVK1fS1dXF1772NQ4cOMAHPvABdu7cOfVvSkREZDY7vwd2fQIuHTCf580zKy1XvAOsqlKTqWUYBpeGLo2sT5m87w51T3h8VW5VWlC5pGgJxZ7i2zxqEbleiVCI4JGjDOw7QM/BM/Q3txHAZ4aUrjmEqlYQvqOIsLMAY2yFtD95Y2TdWm+eMxVEmsGkK61bt6Z0i4jcHlkZXv7rv/4rnZ2d3HfffezevRtr8oeaX/u1X2PlypXs27eP3bt3s3Xr1iteJxwO8/Wvfx2LxcLu3bvZtGlTat9v//Zvs2nTJp555hmOHDnC6tWrp/Q9iYiIzEo9zWal5cmd5nNnDtzzEbjzg+DwZHJkMoNd9l/mSOQIpw+e5nSfuVblYGRw3HFWi5Wa/JpUQDk8BTzXeX1LFInI7WMYBiF/lMHuEAMXe+g+1kR/czsDnQECERshZyFR52JwLobFk18nNaU7WTWpKd0iItkrK8PLZ555BoA/+ZM/SQWXADk5OfzBH/wBH//4x9m5c+dVw8sLFy4QCARYuHBhWnAJ4HQ62bZtG0eOHGHHjh0KL0VERG6lUD/86rPw5lchHgGLFda+Dx78M8gtz/ToZIbpD/ezr20fe1r38MblNzg/eN7cUT9yjMPqoK6gjmXFy8ywsngJdxTegceuEF0km6S6dHePNMAZ7A0x1B1ioGOIwd4w8fjYasdycGLekuy2BLkFTvIq88gt9qR1684tcuPJ05RuEZHpIivDyyNHjgBw3333jdt3//33px1zJS6XC4De3l4SiURaEArQ1dUFwKFDh25qvCIiIpIUj8GBr8Mv/xYCySm5NQ/AY38NFSsyOjSZOcLxMIc7DrOndQ97Lu/hZM9JEkYitd9msVFpreTu2rtZXrKcpcVLqc2vxWFTo0aRTIuG46nO3EPD4WTPyM3fF7lKl24zcHSG+3GHe/DawuSUeChYUEbRyhoK7phHXrEbl1f/3kVEZoqsCy/7+voYHByktLSUnJyccfuHG/VcmKAr3FhVVVXMmzePixcv8id/8if87d/+LXa7+ZZfeeUVvv71r1/ztUREROQKDAPO/gJ2/zl0nTa3ldxhhpaLHgWtCSY3IWEkqO+pT4WVBzsOEo6H046pya9hS+UWtlRuYU3JGn71i1/xxIYncDgUYIhMNcMwiIbjhAMxQv4o4UAMf3+QwWYHr/+wkUBfNBVOXkuXbgsJ3OE+XIFO3KEe3OFe8z7SS/7cQorW3kHOhnV4192LvaTkNrxDERHJpKwLL4eGhgAmDC4BcnNz0467mr/8y7/kAx/4AJ/97Gf5zne+w9KlS+ns7OTYsWNs3ryZN998k8HB8WsgDQuHw4TDI98cDwwMABCNRolGr/6Fdzoafl8z9f3NdPr8pj99htPfrPsMO05ie/6TWJt/CYDhKSJx3/+PxNr3gc0BsVhmx3cDZt1nmIUuDV3izbY3ebPtTfa176Mv3Je2v8RTwubyzWyu2Mymik2UectS+/T5TX/6DDMjkTCIBGOEA6NuyTBydDA5cosS9puPE/GJqiXd9NdfHrfV4baRU+DEawvhDnTh6GjB1nIK92Ab7lAPzsgAFgwsLheulSvx3L8Oz/qncK9ejdXnS13HQH9Hpor+DU5/+gynt3jCoGsgQFdo5n6G1/O+LIZhXKkm/7Zra2ujsrKSqqoqzp8/P27/0NAQubm5lJSU0NnZeU3X/NrXvsYnPvGJtOOffvppPvShD/HII4+wfPlyjh8/PuG5n/rUp/j0pz89bvt3v/tdvF7vNb4rERGRmccV7WNJ649Y0P0yFgziFjtNpY9xpvwpYnbf1S8gMkogEaAp1kRDrIHGWCO9id60/U6c1NhrqHXUUmuvpdRaqi6/IpMwEpCIWkhELCRiFhKR5POr3IwoDE/LviEWA6vTwOowbzaXgc1jYPcksFuC+HouknvpLLnNZ3BfuoQlkUg7Pe5xE1y4kODCaoLVCwnPnYthz7p6GxGR6xZNwFAU/DEYiloYisJQDPxjH8fM4wIxMLDgsxv8zcZ4poc/JQKBAL/xG79Bf38/eXl5Vzw268LLYDCI1+vF6/Xi9/vH7T9//jwLFiygrq6Os2fPXvN1Y7EYR48epbu7m+rqaurq6viP//gPPvCBD/DQQw/xwgsvTHjeRJWXVVVVdHV1XfUPd7qKRqP84he/4NFHH9VUq2lIn9/0p89w+pvxn2E0iHXvv2B9/QtYIubX6sSStxF/6H9CYXWGB3drzPjPMAuEYiGOdB1JVVfW99RjMPJtqd1iZ0XJCjZXmNWVy4uX47Be22ehz2/602doTsWORRLplY9jKiHD/hjh4Ej14/D+WCRx9Re4AofLhstrx+Wz4/Ik772O1Db38OPhm898bndasVgsZkfwCxfY/61vsSgaI3L4MJHGxnGvYysrw7N+HZ5163CvW4ezrg7LmD4Fkhn6Nzj96TOcOoZhMBiK0ROI0OOP0uuPjDwOROjxj3kciBKI3FgA6bMbvPmnD+JyOq9+8DQzMDBASUnJNYWXWfdrLI/Hk1qnsqWlJbXG5bATJ04AsGjRouu6rt1uZ926dWnbdu3aBcD69esnPc/lcqUa/4zmcDhm/H8As+E9zmT6/KY/fYbT34z7DA0Djv8Qnv8U9CfXi56zDrb+DdYFdzITf9yccZ9hBsUTcep76nmj9Q32tO7hUPshIolI2jF1BXVsqdzCnXPuZH35enyOm6vg1ec3/c2Ez3B4KnZqyrU/Sig53TrkT94HRu3zR1Mh5MRTsa+RBVzeZNDoc+BOhoype58jPYgc3ua1Y7Nf3//oiVCI0IkTDB4+TPDwEYJHjhDr6KASGL3Yl7OmBu/69Xg3rMezfgOOuXNUQZ3lZsK/wdlOn+HVReOJkaBxaDiIjNA9FKE3EKE7uX34ca8/QuyKjcUm5rBZKPQ6KfI5Kc5xUuh1UuxzUuRzUeRzJO+dqVuOA3bveg6X0zkjP8PreU9ZF14C3HvvvXzve99jx44dfOQjH0nbt2PHjtQxN6OpqYkf/ehHALzzne+8qWuJiIjMeOffhF2fgEv7zed5c+GRT8GKd4KqZGQChmFwcfBiKqzc27aX/nB/2jFl3rJUk50tlVso9ZZmaLQiVxePJcYEkCNhY9p6kGMCyHAwBjeRQVptlmTQOFEAaVZEDoeOo7e5PHYs1lsfDBqGQfTiRYLDQeXhw4ROnx6/vrHNRqiykoqHHsK3cQPe9euxFxXd8vGIiIxmGAaBSDxZ/ZgMIZOBY7c/Qo8/TI8/mrw39w+Ebmx99hyXncJk6FjsS4aROcnwMRlSFuUkH+c4yXXZr+sXNjN1rcsbkZXh5fve9z6+973v8Vd/9Vc89thjLF++HIDdu3fz9a9/HYfDwXve855rutaZM2c4cuQI73znO1N/SRoaGti+fTuRSITHHnuMTZs2Tdl7ERERmdZ6W8xKyxPmLw9x+ODej8CWD4JTaz9Lup5QD3tb95pdwVv3cGnoUtr+HEcOGys2mmHlnC1U51Wr6kpuq9FdscOBKCH/BAHk8OPR+wMxYuGbW3PM4bKlpl+7faMqIq8QQLp9jtRU7ExJ+P0Ejx0neMQMKoNHjhDv6Rl3nK20BO+aNXhWr8azZg22O+7guZdeYsUTT8zIiiERuT0SCYO+YDQtdEwPI8ffwrHrXzrDaoFCr5PCZNVjsc98XDyqEnL0rdDrxO2wTcE7lolkZXj5lre8haeeeoqf/OQnrF27li1bthAKhdi/fz+GYfCnf/qnVFenr6m1b98+Pv3pT7N8+XL+7u/+LrW9o6ODd7/73ZSWlrJs2TICgQAHDx4kHo+zYMEC/v3f//12vz0REZHsF+qHVz4He/4Z4hHAAuveBw/+OeSWZ3p0kiWCsSCH2g+xp3UPb7S+QX1Pfdp+u9XOmtI1qbByefFy7Nas/PZTppmRrtijA8b0qdjhQHp15K2ciu3ymtWP4yoik1Oxh/ffzFTsTDAMg0hzS1pQGT5zBsY01sHhwL1sKZ7Vq1OBpX1O+hRwVQyJyERC0bg5/XrIDBpHP+4JpE/b7vFH6AtEuIEZ2rjs1lQAOT6MHD9NO9/jwDYF1epya2Ttd4/f/e53+eAHP8h3vvMdXnnlFQDcbjcf+9jH+MxnPjPu+Pb2dn72s5/R19eXtn3x4sX8+q//Ot///vd5+eWXAXP9y3e961188YtfZM6cOVP+XkRERKaNeAwO/ge89DcQ6Da3Vd8PW/8aKlZmdGiSefFEnJPdJ1OVlYc6DhFNpAcUdxTekZoGvr58PV6HKnTl+oT8UZqOdNB/xsmrQw1EQ4mpm4o9YQCZnHY9QXXkVE3FzpT44CDBo0dTQWXwyFES/f3jjrNXVuJZs9qsqly9GveyZVgn6AsgIrOLYRgMhGJpVZCTTs9OBpP+G2xck+e2U5zjSlU9Fo+ekj1BZaTXadPsjhkka8PLnJwcvvGNb/C///f/5uTJk9jtdlavXj1pB6JNmzbxk5/8hKIx66iUlpby3e9+ly996UucOHECi8XCsmXLxh0nIiIyqxkGNDwPu/4Muk6b20rugMf+ChY9Bvrmb1YyDIPzg+d54/LIupWDkcG0Yyp8FdxZeSdbKrewqXITJZ6SDI1WpjN/f5jmw500Hurk8pk+EgkDcHGysfWK5410xZ54KnZaOJlFU7EzwUgkCDc0JENKs7Iy0thk/v8/isXlwr1iRSqo9KxZjaNcFfcis0Fa45oJbsPTtYef9wYiRG+gmt1utaRNyb7S9OzhsNJhy/7qdZk6WRteDisvL6f8Gr5YlpWV8eSTT066v6io6Kab/IiIiMxI7Sdg959D44vmc08RPPgJWP9fwaZ1ymabrmBX2rqVrf708CjXkcumyk2p6soFeQtmXQgkt0ZfR4Cmw500H+6krWkgbV9hpZeIo4/Fy2rx5Lgmnp49TaZiZ0qst5fQ0aMjU8CPHiMxNDTuOEdV1aigcg3uxXdgcTozMGIRuZUMwyAch4u9QQbC/pEp2aOqILuTAaTZWTt8w41rfE7bJGHkxF2089zX17hGJOvDSxEREZkiQx3w0l/DwW+CkQCrA7b8Ltz7cfAUZHp0cpsEogEOtB9IhZVnes+k7XdYHawtW5sKK5cWL9W6lXJDDMOg+9IQTYc6aTrcSfclf9r+8uo8ataUUrOmFF+Rg2effZYNTyxUs5drYMRihM+eNYPKQ+YU8EhLy7jjLB4PnpUrzaBy7Ro8q1ZhL1G1tMjNSCQMIvEE0XiCSCxBJHkfjScIx4YfG8l9cSIxI3XM8HGjzxt9/vAx4XiC6AT7wsOP065npK4Ddtj7ynW9H8tw4xqvg+Jk6Hi1ykg1rpGppu88RUREZptoEPZ8BV75PESSVTjLnoZHPgVFNRkdmky9WCLGie4T7LlshpWHOw8TS6RXWiwpWpKaCr62fC0euydDo5XpzkgYtDUP0HSog6bDnQx0hVL7LFYLc+8ooGZNKdWrS8kpHFlDUc1erizW1ZWsqExOAT9+HCMQGHecc+FCPGvWpNardC1ahMWuHwFlehoOCcPXEfpded/oQHEk9AuPuXZaiDgmLIzGEzc0bfp2cg43rvE6Kc5xTrpmZHGOub3A61TjGsk6+solIiIyWxgGHP8hPP8p6L9gbpuzFrb+LSy4M6NDk6ljGAbNA82psHJf2z6GoulTR+f45nDnnJF1K4vcWhtcblw8nuDS6V6aDnfRfLiTwEAktc/msDJ/WRE1a0pZuLIEd46qKq/GiEQInT49ElQePkz04sVxx1lzcvCsWpUKKt2rVmEvLMzAiGUmMAyDYAw6B8MkLNGRar7rCAtHVwpOFgiO3X6lEDF+Iy2nM8ButeC0W82bzYrDZsWVfO6wjdqevHfZrThso8+x4bBbcNnGnGMfda0J9jnHXNtqxPnVSy+w/cm34NRSEDLNKbwUERGZDc6/Cbs+AZf2m8/z5pqVliveCVatGTfTdAW7zGngycCyPdCetj/Pmcfmys1sqdzCnZV3Mi93ntaekpsSjcS5cKKHpsOdtBzrIhwYqeZ1um0sWFlC7dpSqpYV4XTrR5Ariba3pwWVoRMnMMLh9IMsFlx1tbiTa1V616zBWVODxaapm3J9/OEYzV3+tFtTl5/mziEGQnbY93KmhzipkQDPkhbujQSC6cGew269gUDQMhIojnod1yRBpNNmxZolVYvRaBS3DX19lxlB3zmIiIjMZL0tZqXliR3mc4cP7v0IbPkgOL2ZHJncQv6onwPtB1JdwRv6GtL2O61O1pavTYWVS4qWYLMq5JCbEw5EaTnWTdOhTs6f6CYWTaT2eXIdVK8upWZtKfMWF6qxziQS4TChkydHwsojR4i1ju+wbs3Px7N6lTkFfPVqPKtWYcvNzcCIZTqKxBJc6A3Q3DkqnOwaornLT/tA+KrnO68Q+qXvGw73zKBvOBBMCwPHVghOVDk4Zt/YINJhs+C0WRXKicwiCi9FRERmolA/vPI52PPPEI8AFlj3PnjwzyC3ItOjk5sUTUQ50XWCN1rfYM/lPRztPErMGKl0s2BhafHSVJOdtWVrcdvdGRyxzBT+/jDNR7poOtzJpfpeEqOmceYWualZazbcqajNz5rqo2xhGAaxy5cJHD6cWq8ydOoUjF3f02rFdccdyenf5nqVzoULFdTIFSUSBq0DoWRAOURzVyAVUF7oDV5xynWxz0l1ic+8lfqoKfFRVeDi5N5XeFpTjkUkCyi8FBERmUniMTj4H/DS30Cg29xWfT9s/WuoWJnRocmNMwyDpv6m1FTwfe378EfTOzXPy5nHljlmZeWmik0UuAsyM1iZcfo7gzQd7qTpUCdtzf0wKgMpmuNLdQgvqcpRwDZKIhgkdPw4wSNHUoFlvLNr3HG2oqKRiso1a/CsWI7V58vAiCXbGYZBbyBKc9cQTZ3+cdO9w7HEpOd6nbZUQFmTDCmrS3KoLvaR7x2/9mw0GqVBU45FJEsovBQREZkpzv4Cdv85dNabz4sXmaHlosdAP3xMO+3+dt5sezO1bmVnsDNtf4GrILVu5ebKzVTlVmVopDLTGIZBz2U/jYc6aTrcSffF9AZPZQvzqE1WWBaUa/kJMP/MoufPp9apDB4+Quj0aYjH0w+023EvWTISVK5ZjWOe1pyVdIHIqHUo06Z6++kPRic9z261ML/Ya4aTJclwssRHTamPslyX/p6JyLSl8FJERGS6az9phpaNL5jPPUXwwJ/Chg+ATZ18p4uhyBD72/enqisb+xvT9rtsLtaVrUt1BV9ctBirResIyq1hJAzaWwZoOtRJ4+FOBjqDqX0Wq4U5iwqSFZYl5BRqCYL4kJ/Q8WOpoDJ45Ajx3t5xx9lLS5MhpRlUupctw+rxZGDEkm2i8QQXegJjmuSYj9sGQlc8d26BZ2Sa96jbvEIPdpu+LojIzKPwUkREZLoa6jCnhx/8BhgJsDpg8+/AfR8HT2GmRydXEY1HOdp1NBVWHus6RtwYqdKyYGF58XK2zDHXrVxTtgaXzZXBEctME48nuHymj6ZDnTQd6STQH0nts9mtVC0romZNKdWrSnDnzN5fhBiJBJHm5rQO4OGGBkikT9G1OBy4ly1LBZWeNWuwV1So2m0WSyQM2gZCtIyqnBy+ne8JXHEdyqLR61COmuq9oMiHx6mGayIyuyi8FBERmW6iIdjzFXjl8xAZNLctfRs8+mkoqsns2GRShmHQ0NdghpWte9jXto9gLJh2zIK8BakmOxsrNpLvys/QaGWmikbiXDjZQ9PhTlqOdhEOjDR6crhtLFxZQs2aUuYvL8Lpnp0/KsT7+wkePTYyBfzoURIDA+OOs8+pxDtqrUrX0qVY1dhkVur1R0aFk2aTnKZOPy3dfkLRydeh9DhsaU1yRoeVBV79XRIRGTY7vyMRERGZjgwDjv8Qnv809J83t81ZC1v/BhbcldmxyYTa/G2psHLP5T10h7rT9he5i9hcsTlVXTknZ06GRiozWTgQpeVYN02HOzl/optYZCRM8eQ6qF5VQs3aMuYtLsTmmF1TTo14nHBDI8EjI9O/I42N446zuN24VywfWaty1Woc5WUZGLFkSiASo6UrkAooR1dS9gWusg5lkTetm7dZSZlDeZ7WoRQRuRYKL0VERKaDC3th1yfg4j7zed5cePgvYOW7wDq7woZsNhgZZF/bPva07uGNy2/QMtCStt9tc7O+Yj13VprrVi4qXKR1K2VK+PvDNB/povlwJxdP95KIj0xPzSlyUbumjJq1JVTUFmC1zp7wJNbba1ZTHjGDytDRYyT8/nHHOebPTwaVq/GsXoN78R1YHLN36vxsEY0nuNgbnLCbd2v/ldehnJPvprrUx8JiX6pJTnVJDvMKPTi0DqWIyE1ReCkiIpLNes/B85+CEz8ynzt8cM9H4M4PglNdfjMtEo9wpPNIqrryeNdxEsZIVZvVYmVF8Qo2V27mzjl3srp0NU6bpgLK1BjoCtJ0uJOmQ520NvXDqOX0Cit91KwpoXZtGSVVObOi2suIxQidPm2GlEeOEDh8mOi58+OOs3i9eFauNCsqk4GlvagoAyOW28EwDNoHwjQlp3c3d6avQxm7wjqUhV5Hqot3TenIFO+FxVqHUkRkKim8FBERyUahfnNNyz3/DPEwYIG174WH/hxyKzI9ulkrYSQ423vWrKxsfYOD7QfHrVu5MG+huW7lHHPdyjxnXoZGKzOdYRj0XPabgeXhTrouDKXtL1uQS83aUmrWlFJY4cvQKG+fWGdnqqIyeOgwwRMnMILBccc5q6tHgsq1a3DV1WGxKXiaafoCkbQO3qNvwWh80vPcDqsZTo5eg7LUR3Wxj0KffvkkIpIJCi9FRESySTxmdg9/6W8g0GVuq77PXNeyYmVmxzZLtQ61psLKN1vfpCfUk7a/2F2cWrNyS+UWKnwKl2XqGAmD9paBVIVlf+dIOGexwJw7CswO4atLyS1yZ3CkU8uIRAjV15tTwJNrVUYvXRp3nDU3F8+qVamg0rNyJbaCgts/YJkSwUiclu6RUNKc6m1WVPZeYR1K29h1KEd18y7Pdc+qpRRERKYDhZciIiLZ4uzzsPvPoLPefF68CB77K7hjq5lKyG0RioV4+cLL/DjwY/71J//K+cH0aaYeu4cN5RtS1ZWLChbNiim4kjnxeILLZ/toPmRWWPr7I6l9VruF+UuLqFlbysJVJXhyZmZlWLStLS2oDJ04gRGJpB9kseCqqzPXqUxWVjprarBoXeBpLZZah9KfbJIzMt378lXWoazMd5trUI7p5l1V5NU6lCIi04jCSxERkUxrPwm7/xwaXzCfewrhgU/Ahg+ATQ0ibgfDMDjRfYIdZ3fw8+afMxgdNHdEwGaxsbJkZaq6clXJKhz6XGSKxSJxLpzqoelQJ83Hugj7Y6l9DpeNBSuLqVlTyoIVxTjdM+tbeiMaJXj4CIW/+hWtzz9P+OgxYu3t446z5efjXrMabzKodK9ahS0nJwMjlptlGAYdg+FRTXKGUmHl+e4rr0OZ73Gk1p+sSa5HWV3iY2GJF69zZv3bEBGZrfS/uYiISKYMdZjTww9+A4wEWB2w+Xfgvo+bAaZMue5gNz9t+ik7G3bS0NeQ2l7pq2RBdAG/tuXX2DJ3CzlOBSIy9cLBGOeOddF0uJNzJ3qIhUfW5XPnOKheXULNmlLmLSnE7pg5azQakQjB4ycI7N1r3g4fxggEKAVSfcCtVlyLFye7f5uBpWPBAlU9TzP9gShNXUPmVO/O4UpK8xaIXHkdyoXFvlFNcnJSYaXWoRQRmfkUXoqIiNxu0RDs+YrZkCeSrPBb+jZ49NNQVJPZsc0CsUSMVy+9ys6Gnbx84WVihlnR5rK5eGTBI2yv286a4jU89/PnuH/e/TgcqrKUqRMYiNB8xJwOfrG+l0R8pMIsp9BFzZpSataWUlmbj3WGTHM1IhGCx44R2LfPDCsPHsIIpU//tebnMzB3DgsefQzf+nV4li/H6pv5TYdmgkgswbluP/Wt/fzikoWXf3Sccz3mtO8ef2TS82xWC1WFnpFwctRU74o8rUMpIjKbKbwUERG5XQwDjv8Qnv809CfXUZyz1mzGs+CuzI5tFmjqb2Jnw05+0vgTuoJdqe0rS1ayrW4bj1c/nuoMHo1O3uhB5GYNdAVTHcJbG/th1IzYwgpvKrAsnZ87IyoLE5EIoaNH8e/dS2DfPoKHDo8LK20FBXg3bsS7aRPeTZuwLlzAz597jjVPPKFfIGSpwVCUxk4/jR1DNHQO0dAxRGPHEOd6AsRT07xtcP5y2nnlea5UQFkzqpt3VaEXp31mBPQiInJrKbwUERG5HS7shV2fgIv7zOd5c+Hhv4CV7wI1k5gyQ5EhdrXsYkfDDo50HkltL3IX8WTNk2yr28aiwkUZHKHMBoZh0NPqp/lwJ42HOum6MJS2v2xBLtVrSqlZU0pR5fSvLkyEwwSPHElWVu4jePgwRjicdoytsNAMKjduxLtpI666urTGOvoFQnYwDIPOoXAqmGzoGKKx009DxxBtA5M3y8lx2akp8eIK93H36juoK88116Es9uFz6UdQERG5PvrKISIiMpV6z8Hzn4ITPzKfO3xwz0fgzg+C05vRoc1UhmGwv30/Oxt28otzvyAYCwJm4517597LtkXbuG/ufWq6I1PKSBh0nBuk6XAHTYe76GsPpPZZLFBZV0DNWjOwzC1yZ3CkNy8RDhM8fMScAr4vGVaO6QRuKypKVlVuxLdxI866uhlRVTpTxBMGF3oCyXDSDCkbOs3AciAUm/S80lwXdaU51Jb5qCvNoa4sl7qyHMrzXMRiMZ599lmeeKBG1bMiInJTFF6KiIhMAXs8iPXFz8Def4F4GLDA2vfCQ38OuRWZHt6M1OZv45mGZ3im8RkuDF5Iba/Or2Z73Xaeqn2KEk9JBkcoM10inuDy2T6aDptNd/x9I9WGVruFqqVF1KwppXpVCZ7c6dtkJBEKjYSVe/cSPHp0fFhZUoJv08bUVHBnTY3CyiwQisZp6vSnTfNu7ByiqctPJJaY8ByrBaqKvMlwMofashxqS3OoK80h36tQUkREpp7CSxERkVspFsZ64D945ORfYoslm/FU3weP/TVUrsrs2GagSDzCixdeZOfZnbx++XWM5OKBPoePxxc+zra6bawuXa3QRKZMLBrnwqlemg510HK0m5B/ZLqzw2VjwYpiataWsmB5MU7P9PzWOxEMEjx8mMC+ffj37iV05CjGmGndttISfBs3paorndXV+neXQX2BiFk9OaaS8mJvEMOY+ByX3UrNcEBZ6qOuzHy8sNiHewZ1txcRkelnen4HJSIikm3CQ3DgP+CNL2EbbMUGGEW1WLb+NdzxuDlPVG6ZU92n2NGwg2ebn6U/3J/avrFiI9vqtvHI/EfwOjQtX6ZGJBij5XgXTYe6OHeim1g4ntrn9jmoXl1CzZpS5i0txD4NQ59EIEDw8OFkg539BI8ehTFhpb20NNVcx7tpI86FCxVW3maGYXC5P5Rai3K4mrKpc4iuocm7eud7HGYwmQwq65KVlHMLPdjU0VtERLKQwksREZGbEeiBvf8Kb34Vgr0AGDkVHCt4hKXv/XscbgVot0pfqI+fNf+MnQ07qe+pT20v95bzdN3TbKvdRlVeVQZHKDNZYCBCy9EuGg91cvF0D4nYSPlaTqGL6jWl1K4ppbIuH6ttejXhSvj9BA4dTjbY2Uvw+PHxYWV5ebLBzgZ8mzbhWLBAYeVtEo0nONftH1VJ6U9VVAYi8UnPm5PvpnZUODkcVBb7nPrsRERkWlF4KSIiciMGLsMbX4b9X4eo39xWVAN3/xGxZe+gefcLLFVDmJsWT8R5/fLr7GzYyUsXXiKaMAMVh9XBw/MfZnvddjZXbsZmnX7VbZL9BrqDNCfXr2xt6EubbltQ7k013ClbkDutwqCE30/g4KGRBjvHj0MsvSmLvaLCbK6TrK50VFVNq/c4HQ2FY6k1KEdP+T7XHSCWmHiut91qYWGJL22ad11pLjWl6uotIiIzh76iiYiIXI/uRnjti3Dk/0I8OS2vYiXc81FY9jRYbeMqluT6nR84z86GnTzT+AwdgY7U9qVFS9m+aDtPVD9Bvis/gyOUmaqn1U/ToU6aDnfSeX4wbV/p/Fxq1pRSs7aUokpfhkZ4/eJDfoKHDhLYu9dcs/L4CYinV+zZ51Qm16w0G+w45s1TWDkFDMOgayiS1s17OKxs7Q9Nep7PaTOrKEtHNcwpy2FBsRfHNKv0FRERuV4KL0VERK5F61F49QtwcicYyY6sC+42Q8u6h7Wm5S0QiAbYfW43O87u4GDHwdT2AlcBT9Y8yba6bSwuWpzBEcpMZBgGHecGaTrcSdOhTvraAyM7LTCnrsDsEL6mhLxiT+YGeh3iQ0MEDxxINtjZR+jE+LDSMWfOqDUrN+GcNzdDo52Z4gmDi72B9IY5ySnf/cHJf8FVkuOirsyXNs27riyHijy3wmQREZm1FF6KiIhcybnX4ZXPQ8MvRrYt2gr3fhTmb8ncuGYIwzA43HmYHWd3sKtlF4GYGRxZLVbumnMX2+u280DVAzhtzgyPVGaSRDxBa0M/jYc7aT7cyVBvOLXParMwb0kRtWtLWbiqBG9e9v/diw8OEjhwgMBec83K0MmTkEikHeOYNw/vxo3JdSs3Kqy8RULROM1dI+tRDldTNnf5CccSE55jsUBVoXfUNO8cast81JXmku/VciMiIiJjKbwUEREZyzDg7G4ztLywx9xmscLyt8M9H4GKFZkd3wzQEejgx40/5pmGZ2gZaEltn587n+2LtvNUzVOU+8ozN0CZcWLROBdP9dJ0uJPmI12E/CPVb3aXjQXLi6lZW8KCFSW4PNn9LXJ8YIDA/gOpBjuhU6fGh5VVVSNrVm7ciGPOnAyNdmboD0Rp6BykscOf6urd0DHEhd5A2lqoozntVmpKfOMa5lSX+HBPwy70IiIimZLd35mJiIjcTvGYOS381S9A+3Fzm80Ja/4L3P2HZkMeuWHReJSXL77MjoYdvHrpVRLJ6fceu4etC7eyvW47a8vWamqk3DKRUIyWIz00Herk3PFuouGRqdMun53qVSXUrC2jakkhdmf2hknx/n6zsvJNs8FO6NQpxiZmjgXz8W4cFVZWVmZotNOXYRi0DYRGqihTU779dA2FJz0vz21Pm+I9HFTOK/Ris+r/MxERkZul8FJERCQWhsPfhdf+AXqbzW3OHNjwAdjyQchTCHAzzvSeYcfZHfys6Wf0hntT29eVrWNb3Ta2LtyK1+HN4AhlOjISBuFgjNBQlJA/mroPDkUJDITpOuzhm7/YQyI2EvL5Clxmw501JcxZVIA1SxudxPv6ktPA9+Lfu49wff24sNK5YMGoNSs34ihXpfK1isYTnOseWY+ycdR0b38kPul5lfnuVDg53DynriyHkhynfukiIiIyhRReiojI7BUehP1fhze+DENt5jZPEWz5Pdj038FTmNnxTWP94X5+3vxzdjTs4GT3ydT2Uk8pb6t9G9vqtrEwf2HmBihZxUgYhAMxgkMRQv4YoaFIKogMJ+/HhpShoeik03VNdsAgv8xD7dpSataUUbYgF0sWVsLFensJ7N9vrlm5bx/h06fHh5XV1WlrVjrKyzI02unDH46Z4eSoad4NHUOc6w4QS0z8l8dmtbCg2JsKJkeHlTku/egkIiKSCfoKLCIis4+/G978Kuz9Vwj1mdvy5sKdfwDr3w9OX0aHN10ljAR7Wvew8+xOXjj/ApFEBAC71c6DVQ+yrW4bd825C7tV337MZImEMRI4jgkbQ0NRgqMep7YHonDFIHJyDpcNt8+BO8eBJ8eBy+fA5bVxoa2JR99xF2VV+VlXFRfr7U2uV2muWRk+c2bcMc6aGrybNpqB5caNOMoUVk7EMAy6/ZEx07zNKsrL/aFJz/M6banp3bWlvlRQOb/Ih9OenRW5IiIis5V+ehARkdmj/xK88SU48B8QNbtaU1wHd/8RrPo1sGd/V+FsdHHwIs80PsMzDc/Q6m9Nbb+j8A62123nrTVvpdCtKtbpKB5PEPYPT82OjK+AHDVVe3hbOBi74SDS6bbhznEkw0gn7hw7Hp95785xpkJKt88MKt0+BzbH+KApGo3y7LOnKar0ZUVwGevpSVVVBvbuJXz27LhjnHW1I2tWbtiAvbQ0AyPNXomEwcXeYHoVZbKqsi8QnfS8khwnNaUjXb3ryswqyso8N9YsrMIVERGR8RReiojIzNfVAK99AY78JySSP+RWroZ7PgpLnwJr9jbqyFbBWJDnzz3Pzoad7G3bm9qe68zlrdVvZfui7SwtWpoVwZGY4rHExKHjBGtGDj+PBGM3/Hourx3XcMiYCiTTg8ex220zpOIt1t2dCioD+/YRPtsw7hjXojq8G831Kr0bNmAvKcnASLOPYRhc6gty+FwPP79gYff3j9LUFaCpc4hwLDHhORYLzCv0jISTo+4LffqllIiIyHSn8FJERGauy4fh1c/DyR+TKgVbcA/c+1Gofcj8iVeumWEYHOs6xo6GHTzX/BxD0SEALFi4c86dbK/bzoPzH8Rlc2V4pDNfLBonNBRLhozj14mcKJCMhiZvRHJFFjOITIWOOU7cPnvq3jOmItK8t2dtM5ypEOvqIrBvH/69ewns3UeksXHcMa5Fi0Ya7GzcgL2oKAMjzS6GYXC5P8Sxi30cu9TPsUsDHLvYR2+qktIGF9tSxzttVqpLfKnqyeFqyuoSH54s7hYvIiIiN0fhpYiIzCyGAedeg1c+B40vjmy/4y1maFm1KXNjm6a6gl38tPGn7GjYQVN/U2r73Jy5bKvbxtO1T1OZo47sNyoWiU+8PuREQWRyzchY+MaCSIsFXL6R6scrVkYmby6vQ9Nrx4h2dIysWblvH5GmpnHHuBYvTjbYMdestBfO7qUTRoLKfo5f6ufoJfO+xx8Zd6zdauGO8hxyYv3cv3YxiyvyqSvLoarIi01/F0VERGYdhZciIjIzJBJwdhe88nm4mJzGbLHBinfAPX8E5cszOrzpJpqI8srFV9jZsJNfXfwVccMMy9w2N48ueJTti7azvnw9Vsvsqa67GsMwiEUSBIcihP3DnbNHTdOeYFp2aChKLDrxVNirsVgtZgVkqlnN6IrIkfBx9BRtl8eeld22s120vWNkGvjevURaWtIPsFjMsHKTuWalZ/36WR1WGoZBa3+IY8mA8mgysOyeNKjMZeXcfFbOy2fl3HwWV+RiI8Gzzz7LE/dW43A4MvAuREREJFsovBQRkektHoMTP4JXvwAdJ81tNhesfS/c9SEoqs7s+KaZxr5Gdjbs5MeNP6Yn1JPavqp0FdvrtrN14VZynbkZHOHtYRgGiRgMdoeIhYMjFZBXWB8y5I8Sv8Eg0mq1pMLGVFVkjgPPqBBybGWk060gcqpE29uTQaUZWEbOnUs/wGLBtXQJvo0bzWng69djKyjIyFgzzTAM2gbMikpz6rcZVHYNjQ8qbamgMo+V8wpYOTefJRW5uB3jp3xHb/DfkoiIiMw8Ci9FRGR6iobg8LfhtX+EvmSw4MyFjf8NtnwQcsszO75pZDAyyHMtz7Hz7E6Odh1NbS92F/O22rexrW4bNQU1GRzh7RMORDnw83Mcf+US0VAu3/vFvuu+htVuGRM6OsdVQI4NIh1um5obZVC0tXVkzcp9+4ieO59+gMWCe+nS5JqVG82wMj8/M4PNIMMwaB8ImyHlqHUqu4bC4461WS0sKsthVbKacsXcfJZW5k0YVIqIiIhcicJLERGZXkIDsP//wJ6vwFC7uc1bDFt+Dzb+d/AUZHR400XCSLC/bT87Gnbw/LnnCcVDANgtdu6ddy/b67Zzz7x7cFhnx3TNeDzByVcus/cnzYT80dR2m8N69bUhxwSSDpeCyGwXvXw5FVQG9u4jeuFC+gFWK+5ly0bWrFy/HlteXmYGm0HtyYrKo6Omf18pqBw99VtBpYiIiNwqCi9FRGR68HfBnn+Gff8GoX5zW948uPsPYe37wOnN7PimidahVnY27uSZhme4NHQptb02v5bti7bz1pq3UuIpyeAIby/DMDh3rJvXfthAX3sAgMIKL5ueXsix5jd58qkntN7eDBC9dAl/cgp4YN8+ohcvph9gteJevjzVXMe7fj223Jm/PMJoHQMhjl4cmfZ99FI/nYPjg0qrBe4oz2XF3PxUWLm0Ik/dvkVERGTKKLwUEZHs1ncBXv8nOPhNiAXNbSV3wN1/BCvfBXZnRoc3HYTjYV48/yI7zu5gT+seDAwAchw5vKX6LWyv286KkhWzrlqw88Igr/2ggUunewFw5zjY/FQ1y+6ZQzwR58T5q1xAslass5O8/ftpf+11Qvv3E718Of0Amw338uX4NplrVnrWrcOWk5OZwWZAx0AotT7l8FqVHZMElYvKhoNKc53KZZUKKkVEROT2UngpIiLZqfMMvPZFOPqfkIiZ2+ashXs+CkueBKu6XF+JYRic7DnJjrM7eLb5WQYjg6l9mys2s23RNh6e/zAeuyeDo8wMf1+YPT9uov6NVjDAZrey+uF5rHt8IS6P+a1RPBHP8CjlekXb2hjc/QsGdu8ieOAgFYZB6m+9zYZnxQqzsnLTJjxr12HL8WVyuLdNx2CI45f6OXZxgGOXzHUq2wcmDirrynJYMTefVcMVlZV5eJ36cUFEREQyS9+NiIhIdrl0EF79PJz6KSQrBKm+zwwtax6AWVYdeL16Qj38rOln7GjYwdnes6ntlb5Knq57mqdrn2Ze7rwMjjBzouE4h35xnkO7zxGLmJ2MF20oY8u2WvJKZl+IOxNEL19mYPduBnftJnjoUNq+0Lx5VD6+lZzNW/CuW4vVN/PDys7BcGptyuHp320DoXHHWS1QW5q+RuWyOQoqRUREJDvpOxQREck8w4CWV+CVz0PTSyPblzwJ93wE5m3I3NimgVgixuuXX2fH2R388uIviSUrVZ1WJw8veJjtddvZXLkZq2V2VqsaCYP6PW28+Uwj/v4IABU1edz9zkVU1My+jtHTXeTiRQZ37WZg9y5CR46m7fOsW0fe1sdwP/QQvzh4kBVPzNw1S7uGwmnTvo9dnDiotCSDylXJjt8r5+WzrDIPn0s/BoiIiMj0oO9aREQkcxIJOPNzM7S8tN/cZrGZa1ne80dQtjSjw8t2Lf0t7GzYyY8bf0xnsDO1fXnxcrbXbefx6sfJd83ucO7i6V5e+8FZui4MAZBX4mbLtlrq1pfNujU+p7PI+fMM7NrF4HO7CJ04MbLDYsG7fj25W7eS+9ijOMrLAYhGo5NcaXoaDiqPDweVl/pp7Z84qKwp8bFqXkGqoc7yOQoqRUREZHrTdzIiInL7xaNw/Ifw6heh85S5ze42u4bf9SEoXJDR4WUzf9TP7pbd7GjYwaGOkWmyha5Cnqx9km1127ij8I4MjjA79Lb5ef1HjbQc7QLA6bGz4S0LWfXgPGyO2VmBOt2Em5vNCstduwifOjWyw2rFu3EjeY9vJfeRR7CXlmZukFOgezioHNVQ5/IVgsqVyYrKVfMKWDYnjxwFlSIiIjLD6LsbERG5faJBOPRteP0foS/ZytmVBxt/G7b8HuSUZXZ8WcowDA52HGTH2R3sPrebYLLrutVi5d6597Ktbhv3z7sfh21mTo+9HsGhCPt+1sKJly+RSBhYrBZW3DeXjU8uxJOjzvTZLtzYmKqwDJ85M7LDZsO3eRO5Wx8n95GHsRcXZ26Qt1CPP5IKKo9e7OP4pQEu9QUnPLam1Awqh2/L5+YrqBQREZFZQd/xiIjI1Av1w75/hz1fAX9yerOv1AwsN/42uGf31ObJtPvb+XHjj9nZsJPzg+dT2xfmLWRb3Taeqn2KMq8CX4B4NMHRly6y/+ctRILmmp8LV5Vw19trKayY+Y1apivDMAifPcvgc7sY2L2LSEPjyE67Hd+WLeQ9vpWchx/GXliYuYHeAr3JoHL0OpWTBpUlvmQ1pVlVuXxOHrlu/XJCREREZieFlyIiMnWGOs3Act/XIDxgbsufD3f/Iax9LzjU4XmsSDzCSxdeYmfDTl6//DoJw+yK7bV7ebz6cbbXbWd16Wqt15hkGAaNBzt5Y0cDA13m1NqSqhzufkcd85YUZXh0MhHDMAifPp2qsIw0N4/sdDjw3XUneVsfJ/ehB7EVFGRsnDejL2AGlUcvjkz/vtg7cVBZPRxUJqd/L5+bR56CShEREZEUhZciInLr9Z2H1/4RDn0LYsm12kqXmJ3DV7wDNL15nPqeenY27OSnTT+lP9yf2r6+fD3b67bz6IJH8Tq8GRxh9mlr7ue1/9dAW5P55+XNd7Ll6RoWb6nEalW4m00MwyB08mSqwjJ6bqSS2OJw4LvnHrPC8sEHseXlZXCk168vEOH4pQGOXupLTv+ePKhcWOxNq6hcMTdfQaWIiIjIVSi8FBGRW6ejHl77Ihz7f5Awp+4ydz3c+zG44y1gVaOU0frD/fys6WfsbNjJqZ6RhiRl3jKern2abXXbmJ83P4MjzE4D3UH27Gzi7L52AOxOK2sfnc/axxbgcNkyPDoZZhgGoePHGXjuOQZ37SZ68WJqn8XlIue+e8l9bCs5Dz6ALScncwO9Dv2BaGrq9/FL/Ry91MeFnomDygXF3nFrVOZ7FFSKiIiIXC+FlyIicvMuHoBXPw/1Px3ZVvMA3PNRqL7PbIsrAMQTcfa07mFHww5ePP8i0UQUAIfVwUPzH2Jb3TburLwTm1Uh3FiRYIwDz53jyAsXiMcSYIElWyrY/LZacgpdmR6eAEYiQejoUQaSFZaxy62pfRa3m5z77ydv62P47rsfW052r0XaH4hy/HL6GpXnewITHju/yMvKeWZIuUpBpYiIiMgtpfBSRERujGFA0y/N0LL5VyPblz5lTg+fuz5jQ8tGFwYusKNhBz9u/DHtgfbU9qVFS3m67mneWv1WCtwFmRtgFkvEE5x8rZW9P2kiOGiGvXMXF3D3OxZROj83w6MTI5EgeOiQuYbl7l8Qa2tL7bN4veQ+cL9ZYXnfvVi92bn0QX8wyolkReXRZFXlue4rBJXJKd+r5uWzYk4++V4FlSIiIiJTReGliIhcn0QCTv8MXvk8XD5obrPaYeW74Z4/gtLFGR1eNgnGgjx77ll2Nuxkf/v+1PY8Zx5P1jzJtrptLC1emsERZjfDMDh/oofXfthAb6sfgIJyL3e9o46FK4vVtCiDjHicwIEDDO7azeDu3cQ6O1P7rD4fOQ8+SO7Wx8i5916sbncGRzreQChqNtG5ODL9u2WSoLKqyJOc9l2QDCzzKPA6b/OIRURERGY3hZciInJt4lFzLctXvwhdp81tdg+s+0246w+gQGszDjvedZwdgR387Y/+Fn/MDN0sWLhr7l1sq9vGg1UP4rJpmvOVdF8a4rUfnOXCqV4A3D4HG5+sZvl9c7DZtHZqJhixGIH9+80Ky188T7yrK7XPmpND7sMPkbt1K76778bqyo6/34OhGKfPD3DsUh/HLg1w/FI/zV3+CY+dV5gMKpPTv1fMyafQp6BSREREJNMUXoqIyJVFAmbX8Nf/CfovmNtc+bDpv8Pm34Wc0syOL4u09Lfw+QOf56ULL6W2VeVWsa1uG2+rfRsVvooMjm568PeH2fvjJk693ophgNVuYdWDVWx4ywJcmpp72xnRKP69e80Ky+efJ97Tk9pnzcsj9+GHyd36GL677sLqvP1BXzgWp60/xOW+EK39QVr7Q1zuC3KpN8CJ8zY633hxwvPmFqQHlSvnKqgUERERyVYKL0VEZGLBPtj3b7DnqxBIVlj5yuDO34cNvwXuvIwOL5v0hnr56pGv8v3T3ydmxLBZbKy0r+SD93+QzXM2a3rzNYhG4hx5/jwHdp0nFo4DULuujDu315Jf6snw6GYXIxrFv2cPA7t2MfT8C8T7+lL7bPn55Dz6CHlbH8e3eROWKQwsY/EE7YNhWvuCXO4P0do3Ek629pthZddQ5ApXMP/djQ4qVySDyiIFlSIiIiLThsJLERFJN9gOe74C+/4dIoPmtoL5cPeHYc1/AYeCpGHheJjvnvou/3b03xiMmn9W98+7nw+t/hD1r9Wzvmy9gsurMBIGZ/a2seeZJoZ6wwCUV+dx9zvqqKwryOzgZpFEJIL/9dfNCssXXyTR35/aZysqIveRR8h7fCvejRuxOG6+AjaRMOjyh2ntM8PItHCyP0hrX4iOwRAJ4+rXctmtzCnwUJnvpjLfw5wCN2U5Ti6fPcb7n36YioLs7mouIiIiIlem8FJEREy9LfDaP8Khb0PcDJEoW2Z2Dl/+drDpS8YwwzDY1bKLLx78IpeGLgGwpGgJH9/wcTZXbiYajVJPfYZHmf0un+3l1f/XQOd5M/jNKXJx1/Y66jaUKfS9DRLhMP7XXmNw1y4GX3yJxOBgap+tpITcZIWld8N6LPZr//dvGAZ9gWgqhGztHwknLycrJtv6Q0TjV08m7VYL5Xlu5hS4kwGlGU5W5pth5ZwCD4Vex7i/L9FolGc7j1KsCksRERGRaU8/iYqIzHbtJ+HVL8DxH4JhTtdl3ka456Nwx+NgVXOU0Q53HObv9/89RzuPAlDmKeND6z7EUzVPYbPaMjy66aGvPcAbOxppOmx2qHa4bax/fAGrH6rC7tSf4VRKhEIMvfIKg7t2M/TSSyT8I81r7KWl5D72GHmPb8Wzbh0W28SfxWAomj59e1Qo2dpnVk6GoomrjsVigbJc14SB5PB9SY4Lm1VBtoiIiMhspvBSRGS2urAPXv08nH52ZFvtQ2ZoufAeM1mQlAuDF/jigS+y+9xuADx2Dx9Y8QHev+z9eB3eDI9uegj5o+z7WTPHf3mJRMLAYoHl985l45PVePNUITdVEoEAQ796hcHduxj85csYgUBqn72igrytj5G7dSueNWsIxw0zlGzuTVtbMtUQpy/EYDh2Ta9b7HNSmQwl5+S7qSxIDyfL89w41DleRERERK5C4aWIyGxiGND4ollp2fJKcqMFlr3NnB4+Z21Gh5eN+sP9/NvRf+O79d8lmohitVjZXredD675IKVedVq/FvFYgmO/vMj+Z1sIB8zga8GKYu56ex1Fc7Qe4VRI+P0MvfwyA7t2M/SrX2EEgyP7yiro23gvzcs3cbpgPq2DYS6/4qf1p8/TG4he0/Xz3PaRdSYLkuFkvofKAjdz8j1U5LtxO1RFKyIiIiI3T+GliMhskEhA/U/glc9D62Fzm9UOq94D9/wRlCzK5OiyUjQe5T9P/ydfPfpV+sNm85K75tzFR9d/lMVFizM8uunBMAyaD3fx+o8a6O80w7PiuT7ufsciqpYVZXh0M0s8YdDR2k3HL14g+uLzuA/txRYd6cTdkVPMy5UreXXOKs4UVJmV1WcALoy7lsdho7LAzdwxTXCG7yvyPeS49C2kiIiIiNwe+s5TRGQmi0Xg2Pfh1S9C91lzm8ML694Pd/0B5M/L6PCykWEYvHj+Rb5w8AucGzgHQF1BHR/b8DHumXtPhkc3fXScG+DV/3eW1gYz+PXkOdnythqW3FWJVWsYXhfDMOj2R1LrSY505Q7R295N+Yl9rDy7n3Udp3Em4gxPwL/kK+GVuat4dc4qGvPngsWC02Zlfr47bfr26MrJOQVu8j3jG+CIiIiIiGSKwksRkZko4oeD34TXvwQDF81t7nzY9Duw+XfBV5zZ8WWpE10n+Pv9f8+B9gMAFLmL+IO1f8D2uu3YrfqSeS0Ge0LseaaRM2+2A2B3WFnz6HzWPjYfp1t/hmMZhsFAMGaGkmPWljS3hWjtDxGJjTTAyYkE2NJ6gnsvH2Ftx1kcw422gNa8cuqXbKR9zV24Fi9mYYGHO0dVThb7nAqPRURERGRa0U8RIiIzSbAX9n4N3vxnCHSb23Iq4M4PwoYPgCs3s+PLUq1DrfzDoX/gZ00/A8Blc/Gby36T31r5W/gcWpPxWkRCMQ7uOsfh5y8QT3aaXry5gs1P15Bb5M7w6DLHH46lhZKpcHJUt+5AJH7V6+SF/Tzae5p7Lx+h7mI9tsTIOYkF1XgefZTyJ59gyeI7eEhVkyIiIiIygyi8FBGZCQbb4I0vw/7/A5Ehc1vhQrj7w7D6N8Axe8OjKxmKDPHvx/+db538FuF4GICnap7iD9f9IRW+igyPbnpIJAxOvXaZN3/STHDAXGNxzqIC7n5nHWUL8jI8uqkVjsVp6w9NGEgO3/cHr60BToHXMaort1klOd8SYu6JveTs+RXxg/shPhJYuhYvJnfrY+Rt3Yqrtnaq3qKIiIiISMYpvBQRmc56muG1f4DD34Vk+Eb5CrNz+LJtYNN/8xOJJWL86OyP+PLhL9MT6gFgQ/kGPr7x4ywvXp7h0U0f509289oPGui57Acgv9TDXe+oo3p1ybRfMzEWT9AThgPneunwx0bWmewbnsodpGsocvULATku+6RduYfvPU6zM3ess5PB559nYMcuAvv2QSLBcGTpWraUvMe2krv1MVzV1VP0zkVEREREsot+qhURmY7ajsOrX4ATPwIjuRZe1Ra496Ow6DGzk7CMYxgGr1x6hc/v/zyN/Y0ALMxbyEfWf4QHqx6c9oHb7dJ9eYjXf9jA+RNm8Ovy2tn41mpW3D8Xm92a4dHduJYuPy/Wd/BifQdvNncTjdvh4L4rnuOyW0ca34xaW3J0OJnndlzxGtH2Dnp272Zw1y4CBw6AYaT2uVesSFVYOufPvyXvU0RERERkOlF4KSIynZx/E179PJx5bmRb3SNw78dgwV2ZG9c0cLrnNJ/d/1n2tO4BoMBVwO+t/j3etfhdOKxXDpfEFBiIsPcnTZx89TKGAVabhZUPzGPDEwtx+6bfn2E0nmB/Sy8v1rfzQn0HTZ3+tP1Wi8GcfA9zCrypqdypcDLZrbvQe2OduaOtrQzu3s3Art0EDx5M2+devSpZYbkV57y5N/UeRURERESmO4WXIiLZzjCg4QUztDz3WnKjBZZvM6eHV67O5OiyXkeggy8d+hI7G3ZiYOCwOnjv0vfy26t+mzznzF6T8VaJReIcefECB547RzRkTmKuWVvKndtrKSjzZnh016fXH+GXZzp44VQHL5/pZDAUS+2zWy1sqi7ioSVl3FtbxMm9L/PkW+/D4bg1wWz00iUGdpkVlsEjR9L2edauJe/xreQ++iiOOXNuyeuJiIiIiMwECi9FRLJVIg7Hf2JOD287am6zOmDNr8PdfwTFatJxJYFogG+c+AZfP/F1grEgAI8vfJwPr/sw83LnZXh004ORMDi7v503djYy1GOuqVq2IJe731nHnEWFGR7dtTEMgzPtQ7xQ386Lpzo4eL6XxMisbIp8Th5YXMrDS8q5946S1BTvaDRK/S1YRSBy4QKDu3YxsGs3oWPHRnZYLHjWryNv6+PkPvYojvLym38xEREREZEZSOGliEi2iUeY3/0y9n/5FPQ0mdscPtjwAbjzg5CnqqwriSfi/Ljxx/zToX+iM9gJwOrS1fzxxj9mdamqVK9Va0Mfr/6ggY6WAQByCl1s2VbLHRvLsVize23QUDTOG03dvHjKXL/yUl8wbf/SyjweXlLGQ0vLWD2vANstfj+RlpZUhWXo5MmRHVYr3g0byH18K7mPPIKjrOyWvq6IiIiIyEyk8FJEJJsMtmH/5jbWdp4yn7sLYPPvwubfAW9RRoc2Hbxx+Q0+t/9znO49DcDcnLl8ZP1HeGzBY2rGc436OwO88aNGGg+Zwa/DZWPd4wtY83AV9mRH7GzUPhDixXpzOvhrDV0Eo/HUPpfdyt11JTy0pIwHl5Qxt8Bzy18/3NSUqrAM19eP7LDZ8G7aaFZYPvIw9pKSW/7aIiIiIiIzmcJLEZFs0XcBvvk2LD1NhO252B/4Y2wbfwtcOZkeWdZr7Gvkc/s/xyuXXgEg15nL76z6HX59ya/jtDkzPLrpIeSPsv/nLRx76SKJuIHFAkvvmcOmJ6vx5bsyPbxxEgmDY5f6eaG+gxfr2zl+aSBtf0Wem4eWlvHwkjLuqi3BMwXBa/js2VSFZfjs2ZEdNhu+LVvMCsuHH8ZepF88iIiIiIjcKIWXIiLZoKcZvvE26D+PkT+fX839MA9sfj+2W9QoZKbqDnbzlcNf4Ydnf0jciGO32HnPkvfwO6t+hwJ3QaaHNy3E4wmOv3yJfT9rJuw3m9dULSvi7nfUUTw3u4LzoXCMV8928WJ9Oy/Wd9I1FE7ts1hgTVUBDy02p4Mvq8y75dW2hmEQPnMmVWEZaWwc2elw4LvrTvIe20rOQw9iL5wea4KKiIiIiGQ7hZciIpnW1QDfeAoGL0NRLbH/8iMCrx65+nmzWCgW4tunvs3Xjn0Nf9QPwMPzH+Yj6z/CgrwFGR7d9GAYBs1HunhjRyN97QEAiub4uOsddSxYXpzh0Y043x3gxfp2Xqjv4M2mHiLxRGpfjsvOfXeU8NCSch5YXEpJzq2vEDUMg9DJk6kKy0hLS2qfxeHAd8895G59jNwHH8SWn3/LX19EREREZLZTeCkikkkdp8yKS38HlC6B33wG3MWAwsuJJIwEzzY/yz8e/Eda/a0ALC9ezsc3fJwNFRsyPLrpo/P8IK/94CyXzvQB4Ml1sOmpGpbdXYnVZs3o2GLxBAfO9ZrrV9Z30NAxlLZ/QbGXh5eU8/DSMjYuLMJpv/XjNQyD0ImTlPz855z/0peJXriQ2mdxOvHddy95W7eS88AD2HJzb/nri4iIiIjICIWXIiKZ0noUvrUNAt1QvhJ+cyf4SiAazfTIstKB9gP8/b6/50T3CQAqfBV8eN2HeaL6CayWzAZu08VQb5g3n2mk/s02MMBmt7L6kSrWb12A05O5bwn6AhFePtPJC6c6ePlMJ/3BkX8DNquFjQsLeXhJOQ8tLaOmxDelzZeira20feYvGXrpJYqAKGBxu8m57z5ytz5Gzv0PYMvxTdnri4iIiIhIOoWXIiKZcPEAfHs7hPphzjp47w/VTXwS5wbO8YUDX+CF8y8A4HP4+O2Vv817l74Xt92d4dFND5FQjEO/OM/h3eeJRc1p14s2lrNlWw15xbe+8/bVGIZBQ8eQ2WznVAf7z/WQMEb2F3gdPLi4jIeWlHHfHaXke6Z+7VcjHqf3O9+h44v/gBEIgN3O4LJlLPrN3yT/oQexer1TPgYRERERERlP4aWIyO127g34zrsgMghVm+G//D9wa628sfpCfXz16Ff5z/r/JGbEsFqsvHPRO/n9Nb9PsSd71mTMZomEQf0brbz54yYC/REAKmvzufudiyivzrutYwnH4uxp6uGl+g5eqG/nQk8wbf+SilweWmIGlmvnF2KzTl115Vihkydp/eRfEDp+HADPunWUfvJ/8vzp06zd+hhWNc4SEREREckYhZciIrdT08vwvfdANAAL74Vf/7/gyq6OzpkWiUf4Xv33+Jej/8JgZBCAe+fey8c2fIzagtoMj276uHCqh9d+0ED3JXPNyLwSN3e9vY6ataVTOu16tI6BEC+d7uCFUx282tBFIBJP7XPardxVW8zDS8p4cEkZ8wpvf2VjIhCg85++RM83vwnxONbcXMo+9jEK3v0uYvE4nD5928ckIiIiIiLpFF6KiNwuZ5+H//wvEAtB7cPwnu+A4/ZP2c1WhmGw+9xuvnjgi1wcugjA4sLFfGzDx7hzzp0ZHt300dPq5/UfNXDuWDcATo+dDU8sZNUD87A5pnZt0ETC4MTlAV6ob+fF+g6OXuxP21+W6+LhpWU8tKScu+uK8Toz923I0K9+RdunPk308mUAct/yOOV/+qc4ysrMA+LxK5wtIiIiIiK3i8JLEZHbof5n8P33QyIKi5+Ad/0H2F2ZHlXWONJ5hM/u+yyHOw8DUOop5UNrP8Tbat+GzWrL7OCmieBghL0/bebEK5cxEgZWq4UV989l41urcedM3bTnQCTGq2e7eLG+gxfrO+gYDKftXz0vn4eS3cGXz8m7bVWfk4l1ddH+N3/LwLPPAmCfU0nFJz9J7gMPZHRcIiIiIiIyMYWXIiJT7fiP4Ef/HRIxWLYN3vE1sGkNPYCLgxf5h4P/wHMtzwHgsXv4wPIP8P7l78frUIOUaxGLxjn64kUO/LyFSMisFqxeXcJdb6+joHxq/gwv9ARS08HfaOomEkuk9vmcNu5dVMpDS8t4YHEpZbnZ0VTJSCTo++EP6fj7z5IYGACrlaLf/E1KP/QHWH3qHi4iIiIikq0UXoqITKXD34Nnfh+MBKx6Dzz9ZbDpv96ByABfO/o1vn3q20QTUSxY2Fa3jT9Y+weUecsyPbxpwTAMGg508MaORga7QwCUVOVwzzsXMXdx4S19rVg8waELfbxwqoOX6js43T6Ytr+qyMPDyerKTdVFuOzZVS0bbmyk9S/+guD+AwC4ly2j4jOfwbNieYZHJiIiIiIiV6OfoEVEpsr+r8NPPwIYsO434cl/AOvUrjmY7aKJKN8//X2+euSr9IX7ANhSuYWPb/g4i4sWZ3Zw00hbUz+v/r+ztDcPAODLd7JlWy2LN1dguUVduvsDUV4+28mLp9r55ZlO+gLR1D6b1cL6BYU8vKSMh5eWUVuak/Hp4BNJhMN0/8u/0vVv/wbRKBaPh9IP/yFF730vFru+BRIRERERmQ70nbuIyFR481/g5/+f+XjT/4DH/25WB5eGYfDShZf4woEv0DLQAkBNfg0f2/Ax7p17b1YGX9looCvIGzsbadjfAYDdaWXd1gWseWQ+DtfNVTsahkFjp58X69t54VQH+8/1Ek8Yqf35HgcPLi7lwSVl3H9HKQVe50293lTz791L2198ikhzMwA5999PxSf/J465czM8MhERERERuR4KL0VEbrVXvwjP/4X5+K4/hEc/A7M4nDvRfYLP7f8c+9r2AVDkLuKDaz7I2xe9HbtVX4auRTgY48DPWzjy4gUSMQMssPTOSja/rQZfwY03forEEuxt7kl1Bz/XHUjbf0d5TqrZztqqAuy27A/g4319tP/939P/wx8BYCstoeLP/ozcrVsVkouIiIiITEP6qVFE5FYxDHj5f8Mv/8Z8fv+fwAN/OmuDyzZ/G/948B/5SdNPAHDZXLxv2fv4rRW/RY4zJ8Ojmx7i8QQnX7nM3p82Exoyp23PW1LI3e+so2Re7g1ds3MwzEunO3jxVAevnO3EH4mn9jltVrbUFvPwkjIeWlJGVdH0aZpkGAYDP/0Z7f/rfxHv7gag4Nd+jbKPfRRbXl6GRyciIiIiIjdK4aWIyK1gGPDCp+HVL5jPH/4k3PuxzI4pQ/xRP/9+7N/55slvEo6HAXiy5kn+cO0fUplTmeHRTQ+GYXDuWDev/6iB3jazGrKwwstd76hjwYri66ogNAyDE5cHeLG+gxfqOzhyoS9tf2mui4cWl/HQ0jLuqSvB55p+3xpELl6k7VOfxv/qqwA462qp/PSn8a5fn+GRiYiIiIjIzZp+P6GIiGQbw4Dn/hTe/Gfz+da/hTt/P7NjyoBYIsaOhh18+dCX6Q6ZlW/ry9fzxxv+mOUl6up8rbouDvLaDxq4WN8LgDvHwaYnq1l27xxs1zhtOxiJ81pDFy/Um93B2wZCaftXzs3noWSznRVz8rHeoiY/t5sRjdLzjW/Q+aUvY4RCWJxOSn7vdyn+rd/C4szuNTlFREREROTaKLwUEbkZiQT87KNw4Ovm87d+Djb+dmbHlAGvXnqVz+3/HA19DQAsyFvAR9Z/hIeqHtI6g9fI3xfmzR83ceqNVjDAarew+qEq1r9lIS7P1b9cX+oL8mJ9By+eauf1xm7CsURqn9dp4566Eh5eWsaDi8soy3NP5Vu5LYJHj9L6Pz9J+PRpALybNlHx6U/hqq7O8MhERERERORWUngpInKjEnH48Yfg8HcACzz9JVj73kyP6rY603uGz+3/HK9ffh2AfFc+v7f693j3He/GYXNkeHTTQzQc5/Dz5zm46xyxiBk41m0o485tteSVeCY9L54wOHyhL9UdvL5tMG3/vEKPuXbl0nI2VxfhdtxcN/JsER/y0/nFL9L7ne+AYWDLz6fsT/6E/O3bFJSLiIiIiMxACi9FRG5EPAo7fgeO/xAsNnj7v8LKd2Z6VLdNZ6CTLx/+MjsadpAwEjisDn5jyW/w31f9d/Jd+Zke3rRgJAxOv9nGnp2N+PsjAJRX53HPuxZRUTPxn+FAKMqvznTy4qkOfnmmkx5/JLXPaoH1CwpT3cEXleXMuDBv8IUXaPvLvyLW1gZA/tNvo+xP/gR7UVGGRyYiIiIiIlNF4aWIyPWKheEH/w3qfwpWB7zz/8Cyt2V6VLdFIBrgGye/wdePf51gLAjA1oVb+fC6D1OVW5Xh0U0fF0/38toPztJ1YQiA3GI3d26vpW592bjAsalzyGy2c6qDfS09xBJGal+e2879i8t4eEkZ999RSqFvZq7zGG1vp/2v/orBXzwPgKOqiopP/QU5d9+d4ZGJiIiIiMhUU3gpInI9oiH4/vvg7G6wueDXvgV3bM30qKZcwkjw48Yf808H/4mOYAcAq0pX8ccb/pg1ZWsyO7hppLfNz+s/aqTlaBcATreN9U8sZNWD87Anp3VHYgn2t/TwQn0HL9Z30NzlT7tGXVmOOR18SRnrFxRiv8YmPtOREY/T+3//L52f/wIJvx/sdoo/8AFKfv/3sHomn1IvIiIiIiIzh8JLEZFrFfHD934dml8Guwd+/btQ+1CmRzXl3mx9k8/u/yz1PfUAzM2Zyx+t/yO2Ltg646YlT5XQUJS9P2vmxMuXSCQMLFYLK+6dw8Ynq/HkOukaCvPLo628WN/OK2e6GAzHUuc6bBa21BTzUDKwXFDsy+A7uX1Cp0/T+slPEjpyFAD36lVUfuYzuBcvzvDIRERERETkdlJ4KSJyLUID8N1fg/OvgzMHfuM/YeE9mR7VlGrqb+Lz+z/PyxdfBiDXkcv/WPU/+I2lv4HTNjOnJ99q8WiC4788z4GftxAOmIHkgpXF3Lm9lnYS/Pu+c7xQ38HhC30YI7PBKclx8uDiMh5eWsY9i0rJcc2eL9eJUIiuL3+F7q9/HWIxrD4fpR/9CIXveQ8W28xoOiQiIiIiItdu9vw0JCJyo4J98O13wKX94MqD9/4QqjZlelRTpifUw1cOf4UfnPkBcSOO3WLn3Yvfze+u/l0K3YWZHt60YBgGgVY73/+bAwx2hQAomusjZ3MJb/gD/PU33qS1P5R2zoq5eTy0pJyHlpSxam4+Vuvsq2odeu012j71aaIXLgCQ++ijlP/5n+EoL8/wyEREREREJFMUXoqIXIm/G761DdqOgqcQ3rcD5qzN9KimRDge5tsnv83Xjn2NoajZSObBqgf56PqPsjB/YWYHN00EBiI0Herg1But9LR4gBAWj42WSgdfGugh+GJX6li3w8o9daU8vLSMBxeXUZHvztzAMyzW00P7//pfDPz4JwDYy8up+OT/JPfhhzM8MhERERERyTSFlyIikxnqgG8+DR0nwVsCv/kMVKzI9KhuOcMw+Hnzz/mHg//AZf9lAJYWLeWPN/4xGys2Znh02W84sDx7oIPLZ/sgOf07ZjHY64yx1xkk2mNum1vgMdeuXFrGnTXFuB2zexq0YRj079hJx9/9HfH+frBYKHzveyn98Iex5cyOtT1FREREROTKFF6KiExk4DJ8423QfRZyKuD9P4bSmdco5GD7QT67/7Mc6zoGQLm3nA+v+zBvrXkrVsvM7WJ9MwzD4ELrIAdfu8zl4z0k2kOMnuDdaktw2hHnpDNGwAbr5hfy0BJz/crF5blqcpQUbm6m7VOfJvDmmwC4liyh8jOfxrNqVYZHJiIiIiIi2UThpYjIWH3n4RtPQW8L5FeZFZfFtZke1S11fuA8XzjwBZ4//zwAXruX31r5W7xv2fvw2D0ZHl32CEXjnG0f4lTbAGfO9dFzug9PW4SKCFiTkaWFkcDygs9gztxc7ijP4Y7ec/zhOx+mvEAVhKMZkQjd//7vdP3zVzEiESxuN6V/8EGK3v9+LA5HpocnIiIiIiJZRuGliMho3Y1mxeXARShcCO//CRTMz/Sobpn+cD9fPfJV/u/p/0ssEcNqsfKORe/g99f8PiWekkwPL2MMw+Bib5D6tkHqWweobzfv2zr81EVsLI7aqIpZKcQCydCyxwXROW5KlhZyX20hv1OZx9wCD1arhWg0yrPPtlDkU1f20QIHD9L6yU8SaWgEwHfPPVT8xSdxVlVleGQiIiIiIpKtFF6KiAzrPG0Gl0NtULzInCqeNyfTo7olovEo36v/Hv9y9F8YiAwAcM/ce/jY+o9RV1iX4dHdXgOhKGfaBjk1HFS2DXKmbZDBcAwAbwIWRW2sj9qoirlTFZYA9hIXVatL2HDPXMoqczL1Fqad+MAAHZ/7PH3/+Z8A2IqKKP/EJ8h76xOaRi8iIiIiIlek8FJEBKDtuNmcJ9AFZcvMqeI5ZZke1U0zDIPnzz/PFw58gQuDFwBYVLiIj2/4OHfNuSvDo5tasXiClu4A9W0D1LcOUt82wKnWQS71Bccd603A+ridVYaT4oCRtoZl6YJc6taXUbeujLwSTam/HoZhMLhrF21//dfEO81O6/nvfAflH/84toKCzA5ORERERESmBYWXIiKXD8G3tkOwFypWwft2gq8406O6acc6j/HZ/Z/lYMdBAEo8JXxo7Yd4uvZpbNaZ1eW6ayicCijr28z7M+1DRGKJCY+fk+9mebGPJXEH+V1RwpcDyS7hZqvwsgW51K4ro269AssbFb10ibbP/CVDL78MgLO6mopPfwrfpk0ZHpmIiIiIiEwnCi9FZHa7sBe+/Q4ID8DcDfDeH4KnINOjuimXhy7zxYNf5OfNPwfAbXPzX1f8Vz6w/AN4Hd4Mj+7mhKJxGjqGqG8b5HQyqDzVOkjXUHjC471OG4srcllSkcuSijxq8zy42sJcOtbN5UO9GAYMnzkcWNauKyO/VIHljTJiMXq+9W06/+mfMAIBcDgo+R//g+Lf+R9YnVoDVEREREREro/CSxGZvVpehe+8G6J+mH8X/Jfvgys306O6YYORQb527Gt8++S3iSQiWLDwttq38aG1H6LcV57p4V0XwzC43B9KrUl5qnWA022DNHX5iSeMccdbLLCw2JcKKRdX5LK0MpeqQi9hf5TGQ5007u3g6OkmjFGnl843p4QrsLw1gidO0PY/P0no5EkAPBvWU/npT+Oqrc3wyEREREREZLpSeCkis1Pji/C934BYEGoegPd8F5y+TI/qhkQTUX545od85fBX6A33ArC5YjMf3/hxlhQtyfDorm4oHON0cqr36Knfg6HYhMcXeB2pkHJpZS6LK/K4ozwHr3PkS1pwMELjoU5+cvAMl073KrCcYgm/n85/+hI93/wmJBJY8/Io+/jHKHjnO7FYrZkenoiIiIiITGMKL0Vk9jn9HHz/NyEehkWPwbu/BQ53pkd13QzD4OWLL/P5A5+nub8ZgOr8aj6+4ePcO/ferOviHE8YtHT7zaCydcDs9t02wIWe8Q10ABw2C7WlOWZQWZnHkopcllbmUZbrmvC9BQcjNB3upOFAB5fO9GGMqtBUYDl1Bn/5S9o+8xlil1sByHviCcr/9P+HvbQ0wyMTEREREZGZQOGliMwuJ38MP/hvkIj+/9m7z/iqqqyP47/b0gsphN5C771LVcEuKopiQUXaiArCqKPjA+qoo4iiMqM0EQE7ilhBgYCC9N57T0jv7ZbzvLgSzdCSmwsp/L9vcnL2OXuvw+GGDyt77wVNboKBs8Fa/vbh2520mzc2vMG6uHUAhPuF87fWf+P2RrdjM9tKOTpIzsovSFCe2Zty3+kMcu3nLqBTNcSPJtWC3cu9q4bQpFow0ZFB+FgvPGtPCcvS40hIIO6VV8j48ScAbNWrU3XiBIJ69izlyEREREREpCJR8lJErhzbvoCvR4DhhBZ3wG3TwFL6ib7iOJ11mnc2v8O3B7/FwMDH7MP9ze5naMuhBPtc/v068xxODsZn/aXKt3tWZXzGuQvo+NssNKoaTNOqwX8U0nHPqAwLLHoCuWgJy8qEVi7fxYnKKsPlIvXzL4ifPBlXRgZYLIQPGULl0Y9iDtCfuYiIiIiIeJeSlyJyZdg8D74ZDRjQ5l645V0wW0o7qiLLtmfzwY4PmLNzDrnOXABuqHcDT7R7gupB1S/5+IZhEJeey57YDHb/ZW/KQwlZOM5RQAegTkTAWXtT1g4PwGIu/nL2iyUs67erTIP2UUpYXmJ5+/cTO2EiOZs2AeDXvDnVXnoRv2bNSjkyERERERGpqJS8FJGKb/1M+H6c+7jDw3DDZCgnRUScLicLDyxk6papJOYkAtAuqh3jO4ynZeWWl2TMrDwH+07/OYty9x9f089TQCfEz0qTaiE0/cvelI2qBBPoW7J/YnIy8zm0WQnLssCVl0fi+++TNHMW2O2YAgKIGvMEYffei8lSfn4JICIiIiIi5Y+SlyJSsf3+H1j8rPu4y9+g/ytQxgrZnM/vsb8zZcsU9qfsB6B2cG3Gth/L1bWv9koxHqfL4FhyNntizyz5dn89mpR9zuutZncBncZVg2lS7c+9KauG+HmtONCZhOXBTfGc2KuEZVmQtWYtcRMmkH/0KABBffpQ9fl/Yqt+6Wf8ioiIiIiIKHkpIhXXyjdg2Uvu46uehKv/r1wkLg+nHWZO5hz2L3cnLUN8QhjVehSDGg/C5uEenSlZ+QUJyr1xGeyOy2BfXAY5duc5r48K9i2YTXlmb8r6UYH4Wr0/y+5CCcvIWkEFRXcqRSlheTk5UlKIn/QGaV99BYC1cmWq/POfBPe7tsxVshcRERERkYpLyUsRqXgMA5a/Aitfd3/f5zno+fdykbg8lHqIIUuGkOnIxGq2MrjJYIa3Gk6ob2iR7s93uDiUmFlob8q9cRnEpeee83pfq/mP5OSfxXMaVw0mIsjXm491FiUsyy7DMEj/9ltOv/pvnCkpYDJR6e5BRD35JJbgy18USkRERERErmxKXopIxWIY8PPzsPpd9/fXvgjdnyjdmIooJTeFR5c+SqY9k1qWWky9YSrR4dHnvNYwDE6n5/1Z5fuPpd8HEzKxO89dQKdWuL+7eM5f9qasExHoUQEdT+Rm2v8ounNaCcsyKv/YMeImvkDW6tUA+DZsQNUXXiSgXdtSjkxERERERK5USl6KSMXhcsFPT8O66e7vr38dOo8o3ZiKKN+Zz5jlYziReYKaQTW5z3wftYJrAZCd72Df6Uz2xqWzO/bPvSlTs+3n7CvYz0rTqiEFe1M2+eM4qIQFdDxRkLDcFM+JPSlKWJZRht1O0uwPSfzPfzDy8jD5+BD5t78R8fBDmHx8Sjs8ERERERG5gil5KSIVg8sJ342BTR8BJrh5CrR/sHRjKiLDMHjh9xfYFL+JYFswo5u+zHfLTrDiky3si8/iSFIWxjkmU1rMJqIjAwtmUTb5Y0Zl9VDvFdDxhBKW5UvOli3E/t8E8vbtAyCgSxeqTZyAT926pRuYiIiIiIgISl6KSEXgdMA3f4Ntn4HJDAPeg9Z3l3ZURfbBjg9YdHARFpOFLsFP8NjcWFyGBYgvuCYyyJem1f7cm7Jx1WAaRAXhZ/N+AR1PXCxhWb9dFA3aRVGpihKWZYUzM5OEN98i5ZNPwDCwVKpE1DNPE3rrrSrIIyIiIiIiZYaSlyJSvjntsOAR2LUQzFa4fQa0uL20oyqyX47+wpRNUwColHMnX+0KAqBFmItbujSleY1KNK4aTOQlLqDjidxMO4e2JnBgoxKW5U36zz9z+l8v4zh9GoDQW28l6pmnsYaFlXJkIiIiIiIihSl5KSLllyMPvngQ9v4AFh+480NocmNpR1Vku5J28Y/f/gGAK7U7R2LbEOJn5cVbmmE6vokbutXBZrOVcpSFnUlYHvwjYelSwrJcscfFEfevf5H5y1IAbHVqU23iRAK7di3lyERERERERM6tzCcv8/PzOXbsGDabjVq1amE2mz3uy+FwcPz4cWw2G9WrVy9RXyJSyvKz4bP74OBSsPrBoPnQ8JrSjqrITmed5tFfRpPryMWR2Yic2BvoXC+cNwe1ISrQyg/HSzvCP10oYRlR072HpRKWZZvhdJLy8SckTJmCKysLrFYihg4lctRIzH5+pR2eiIiIiIjIeZXZ5KXdbueFF15g6tSppKWlAVCtWjX+7//+j5EjRxarrx07dvDcc8/x/fff43Q6AfD19eX+++9n4sSJ1KhRw+vxi8gllJcJn9wNR34FWwDc8ylE9yrtqIos257Nwz+OIjE3AWduFeyxg3nqumaM6Fkfi9mE3X7uKuKX00UTlu2iaNBeCcvyIHfPHmL/bwK527YB4N+mDVVffAG/Ro1KOTIREREREZGLK7PJyxEjRjB79mwA6tWrR25uLrGxsYwaNYqcnBzGjh1bpH727NlD165dyczMxGq1Eh0djd1u58SJE8ycOZMlS5awbds2QkNDL+XjiIi35KbB/Dvh+FrwCYb7voTaXUo7qiLLtTsYuOBxjuftx+UIJDJrJFNHXk2rmpVKOzRys9xFd5SwrBhcOTkk/uc/JM3+EJxOzEFBRI17kkqDBmHSygMRERERESknymTyctWqVcyePZuAgAC+/fZb+vbtC8Ds2bMZOnQo//znP7nnnnuoWrXqRft65513yMzMpHv37nz++edUr14dgF27dnHjjTdy5MgR5s6dy+jRoy/pM4mIF2Qnw7zb4dRm8AuF+76Gmu1LO6oiO5iQyQNfTyTddy2Gy8JVweN46/4BBPiU3o/igoTlpnhO7FbCsqLI/PU34l54AfuJEwAE9+tHleeew1YlqpQjExERERERKZ4ymbycNWsWAE8//XRB4hLgoYceYsmSJXz66ad8+umnjBkz5qJ9HTt2DIBnn322IHEJ0KxZM0aPHs348eM5evSodx9ARLwvKxE+GgCnt0NABNy/EKq1Ku2oisQwDD5Zd5yXVszBWmUxAPdEj+e5XneWSjwXTFjW+GMPSyUsyyVHUhKnX/036d99B4C1WjWqPv88wX37lHJkIiIiIiIinimTycuYmBgABg0adFbboEGD+PTTT1m+fHmRkpeNGzfm+++/58Qfs0/+6vhxd0WMRtr3S6Rsy4iDObdA4l4IqgIPfANRTUs7qiJJzsrn6QXbWHZ4Df51FgBwb+OHeabLfZc1josnLCtTv10UYVUDL2tc4h2GYZD21Vecfn0SrrQ0MJsJu+9eKj/+BJYgvVMRERERESm/ylzyMi8vjyNHjuDn53fOpGKrVu6ZVnv37i1Sf2PHjmX+/Pn8/e9/Jy0tja5du2K321m8eDFTp06lRYsW3H///V59BhHxorQTMOdmSD4EITXggUUQ2aC0oyqSlfsSGPfFVhJzTxFYby4mk5Nra1/LU52fuCzj52bZObw1gQMblbCsyPIOHSZuwgSy168HwLdpU6q9+CL+LVuUcmQiIiIiIiIlV+aSl6mpqRiGQWRkJCaT6az2qCj3fl0pKSlF6q9mzZps3LiRcePG8dRTTxVqe/zxx3nppZfw8/M77/15eXnk5eUVfJ+eng64q6GXhYrAl8KZ56qoz1fRVaj3l3oU67zbMKUdwwitjeO+ryG0DpTxZ8uzO5n8ywFmrz4K5hwq1Z+L05JNs/BmTOwyEafDiRPnee8vyTvMy7ZzZFsShzYncmJPKsZfEpbh1QOIbluZ6LaRhZaEV4i/K2XM5fgcGvn5pMz6gOQZM8Bux+TvR/jf/kal++7DZLXqvZZQhfpZegXS+yv/9A7LP73D8k3vr/zTOyz/Kvo7LM5zmQzDMC5+2eVz/PhxateuTb169Th06NBZ7Xl5efj5+REaGkpqaupF+7Pb7Tz++OPMmDEDgNq1a5Ofn8+pU6fw9fXln//8J88999x57584cSIvvPDCWec//vhjAgK0H5zIpRKYG0v3A//G355Cpm8VVjV4hlyfiNIO66Jis+Gj/RZOZZsAJ9UbzCbDdoAQUwijgkcRbA72+pguO+SctpITZyM30QLGn7/4sQU78a/qwL+qHVtQmfpxLyXgf/gwUQu+wjchAYCsRo04fdsAHOHhpRyZiIiIiIjIxWVnZzN48GDS0tIICQm54LVlLnmZlJREZGQkVapUIS4u7qz2lJQUwsPDqV69OidPnrxof8888wyvvfYa/fv354MPPigo2rNnzx4GDRrEtm3bmD17Ng8++OA57z/XzMtatWqRmJh40T/c8sput/Pzzz9z7bXXYrPZSjscKaYK8f4S9mCdfzumrHiMyEY4Bn8FwVVLO6oLMgyDeWuP89rifeQ5XEQE+tCh/XJWJ3yLv9WfD679gMZhjYvUV1HeoXuGZTKHNidwcm8qLuc5Zli2iaRSVf2SpTRcqs+hMy2dpLfeIn2Be/9US3g4kc88TdB1151ztYJ4rkL8LL2C6f2Vf3qH5Z/eYfmm91f+6R2WfxX9HaanpxMZGVmk5GWZWzYeFhaGv78/8fHx5ObmnrWk+0z18L9WDr+QadOmATB37lwqV65ccL5Jkya89957dO/enenTp583eenr64uvr+9Z5202W4X8y/NXV8IzVmTl9v3FboN5AyA7Caq0wHT/QmxBlS96W2lKyMjjqS+3snyvexZc78aV6dZ2D+9u/RYTJv7d49+0iCr+/oP/+w7de1gmuvew3JNcKGEZUSOQ+u3cVcK1h2XZ4a3PoWEYZPz4I3GvvIozMRGASnfeSdT4cVhCQ0vcv5xfuf1ZKoDeX0Wgd1j+6R2Wb3p/5Z/eYflXUd9hcZ6pzCUvzWYzLVq0YP369fz+++/06dOnUPuqVasAaNmy5UX7ysjIIDU1lcDAwEKJyzPq1q0L/JkQFZFSdmIjzLsNctOgelu47ysIKNvLYJftOc3fv9hGUlY+PlYzz93QlOjaxxm9bDIAY9uPpW/tvh73fyZheXBTPMd3J//PDMtAGrRXwrKiyz9xkrgXXyBr5a8A+ERHU+3FFwjo0KGUIxMREREREbn0ylzyEuDGG29k/fr1TJkypVDyMj8/n//+978A3HTTTRftJygoiKCgIDIzM1m5ciU9e/Ys1P7tt98CULVq2V6OKnJFOPo7zL8T8jOgVme49wvwK7szynLtTl75YTcf/X4UgCZVg3nnnraYfOK4/8e/4zJc3NbgNh5s/mCx+87PdZB1wsqP7+04x5JwJSyvFIbDQfKcj0iYOhUjJweTzUbEiBFEDB+G2centMMTERERERG5LMpk8nLUqFFMnjyZRYsW8cADD/DII4+Qm5vLG2+8wc6dO2ncuDG33HJLoXvS09M5dOgQQUFBNGjQAACTycTtt9/ORx99xB133MHTTz9N586dyc/P55dffmHKlCkADBw48HI/ooj81aEV8MndYM+Guj3gnk/BN6i0ozqvnafSeOLTLRyIzwRg6FX1+Hv/xmQ5Urn3h8fIsmfRoUoHnu/yfLH3IczNsvPV65tJT/AnhRTgz4Rl/XZRhFdTwvJKkLN9B7ET/o+8XbsBCOjQgaovvoBvdHQpRyYiIiIiInJ5lcnkZVRUFB999BGDBg1i7ty5zJ07t6AtPDyczz77DKu1cOgrV67k5ptvpnv37vz2228F59944w02bdrEjh07+Pvf/37WWP3792fs2LGX7mFE5ML2/wKf3QuOXKjfFwbNB5+yWWTG5TL4YNVhXv9pL/lOF5WDfZl8Z2t6NqpMnjOPMcvHcDLzJLWDa/NW77ewWYq3L4lhGCyds5v0hFzMvi7aXl2XRh2rKWF5BXFlZZHwzjskz50HLhfm0FCq/H08obffjslsLu3wRERERERELrsymbwEGDBgAJs2beLdd99l+/btWK1WunTpwhNPPHHOYj2hoaG0bt2ahg0bFjpfuXJl1q9fz5w5c1iyZAknTpzAbDYTHR3NrbfeysCBAzHrP4QipWPP9/D5EHDZodH1cNccsJ5dIKssOJ2ey7jPt/LbAXexlGubVeG1O1oRHuiDYRhMXD2RLQlbCPYJZurVU6nkV6nYY2z5+ThHtiVisZqIaJ9D++vrVMiNmeXcMpYtJ+6ll3DExgIQctNNVHnmaayRkaUcmYiIiIiISOkps8lLgObNm/P+++8X6doePXqwZcuWc7b5+fkxYsQIRowY4cXoRKREdnwFXw0DlwOa3Qq3zwRr2dzH76cdcTzz1TZSs+342cz8303NuadTrYIl4TO2z+C7Q99hMVl4s/eb1AutV+wxYg+k8vvCgwB0vaM+R9I3e/UZpOyyx8dz+uVXyFi8GABbzZpUnTCBoB5XlXJkIiIiIiIipa9MJy9FpILa8gl88zcwXNBqENz6X7CUvR9H2fkOXvpuF5+sOw5AixohTBnUlgZRf+7HufjIYt7d/C4Az3V5ji7VuhR7nJyMfBbP3InhMmjYsQpNu1flyI/eeQYpuwyXi9TPPiN+8pu4MjPBYiHioQeJfPRRzP7+pR2eiIiIiIhImVD2sgUiUrFtmA3fjQUMaPcA3DQFzJbSjuos206kMubTLRxKzMJkghE96/PktY3wsf65zcSOxB0899tzANzf7H7ubHRnsccxXAa/zN5FVmoelaoE0PvexphMxsVvlHItd98+4iZMJGeze4atX8uWVHvxBfyaNi3lyERERERERMoWJS9F5PJZOw1+fMp93HEYXP86lLE9Z50ug2krD/Lmkn04XAZVQ/x4c1BrutUvvO9gXFYcjy17jDxnHj1r9mRc+3Eejbdx8VGO7UrGajNz3fAW+PhZsdvt3ngUKYNcubkkvvc+SbNmgcOBOSCAymPGEHbvYEyWspfEFxERERERKW1KXorI5bHqbfj5/9zH3R6Da1+CP/aMLCtOpeYw9rMtrD2cDMANLavyym0tqRRQeC/ObHs2jy17jMScRBqGNeT1nq9j8WD26Mm9KaxbdAiAnvc0IqJG0EXukPIsa80aYidMwH70GABBfftS9fl/YqtWrZQjExERERERKbuUvBSRS8swYOUkWP6y+/ueT0GfZ8tc4vK7bad49qvtpOc6CPCx8MItzRnYvmZBUZ4znC4nT//6NHuS9xDuF87UvlMJtAUWe7zs9HyWzNqJYUCTrlVp2q26tx5FyhhHSgrxr71O2sKFAFijoqjyz+cIvvbas/5+iYiIiIiISGFKXorIpWMYsPRF+O1N9/d9n4ee40s3pv+Rmedgwjc7WbDpBABtalViyqA21I08d0Ly7U1vE3M8Bh+zD+/0fYfqQcVPOrpcBktm7SQ7PZ/w6oH0vKdxSR5ByirDIH3RIpImvYEzNRVMJsLuuYfKY8dgCQ4u7ehERERERETKBSUvReTSMAxY/Cys+a/7+/6vQNdHSzem/7HpWApjPt3CseRszCYY3acBj13dEJvl3PtwfrX/K2bvnA3Av676F60rt/Zo3PXfH+bk3hSsvhauG94Cm4/2Oqxo8o8do8bMWcQfOACAb8OGVHvpRfzbtCndwERERERERMoZJS9FxPtcLvhhHGz4wP39jZOh4yOlG9NfOJwu/rP8IO8s24/TZVCjkj9T7m5Dx7rh571nfdx6Xvr9JQBGtR7F9fWu92jsY7uS2PDDEQD63NuYsKrFX3IuZVf+0aMkzZxF6sKFBNrtmHx9iXz0USIeehCTzVba4YmIiIiIiJQ7Sl6KiHe5nLDoMdgyHzDBLe9Cu/tLO6oCx5OzGfPZFjYeTQFgQJvqvDigBSF+508sHU0/ytiYsTgMB9fXvZ5RrUd5NHZmSh4/f7ALDGjeozqNOlX1qB8pe3L37iVp2nTSf/rJnbwHsho2pNnbUwiIji7l6ERERERERMovJS9FxHucdvh6JOz4EkwWuG0atLqztKMCwDAMFm45yfMLd5KZ5yDY18pLA1owoG2NC96XlpfG6KWjSctLo1VkK17s/qJHRVZcThdLZu0gN9NOZK0grrqroaePImVI9qbNJE2fTmZMTMG5wF49qfTwwyyPi6N1rVqlF5yIiIiIiEgFoOSliHiHIx++fAj2fAdmGwycBc1uLe2oAEjLsfP8wh0s2noKgA51wnhrUBtqhQdc8D67y864mHEcST9CtcBqvN33bfysfh7FsHbRIWIPpGHzs9B/WAusNu1zWV4ZhkHWqtUkTZtG9vr17pMmEyHXX0fEsGH4NW2K3W6HH34o3UBFREREREQqACUvRaTk7Lnw+QOwfzFYfOCuudD4utKOCoB1h5MZ+9kWTqbmYDGbGHN1Q0b1ro/1PEV5zjAMg1fWvsLauLUEWAN4t++7RPpHehTDkW2JbFp8DIC+9zelUtSFk6ZSNhkuFxk//0LS9Onk7tzpPmmzEXrrLUQMHYpvvXqlG6CIiIiIiEgFpOSliJRMfhZ8OhgOxYDVH+75GOr3Le2osDtdvP3Lfv4bcwCXAXUiApgyqA1ta4cV6f55u+fx5b4vMWHi9Z6v0zi8sUdxpCfl8MuHuwBo2acmDdpHedSPlB7Dbiftu+9JmjGD/EOHADD5+xN2152EP/QQtqrau1RERERERORSUfJSRDyXlwHz74Jjq8EnCAZ/BnWvKu2oOJyYxZhPN7P1RBoAd7avyYRbmhPkW7QfeSuOr2DS+kkAjO8wnl61enkUh9PhYsnMneRlO4iqE0z32xt41I+UDlduLqlfLiDpg1k4TsUCYA4JIfy+ewm7/36sYUVLhIuIiIiIiIjnlLwUEc/kpML8gXBiPfiGwH0LoFanUg3JMAy+2HCCid/uJDvfSYiflVdvb8WNraoVuY+9yXt5auVTGBgMbDSQ+5t5Xin9968OcvpwOr4BVvoPa4HFduGl6lI2ODMySPnkU5LnzMGZlASAJTKSiAeHUOnuu7EEBZVyhCIiIiIiIlcOJS9FpPiyk2HuAIjdCv5hcP/XUL1tqYaUmp3PP77azo874gDoEh3Om3e1oXol/yL3kZiTyGPLHiPbkU3nqp15tvOzHlUWBzi0OYGty44DcPWQpoREFj0OKR2OpCSSP5pLyvz5uDIzAbDVqEHEI0MJve02zH6eFWsSERERERERzyl5KSLFkxkPH90K8bsgIBIe+AaqtijVkFYfSOTJz7cSl56L1WxifP/GDOsRjcVc9MRjriOXJ5Y9QWxWLHVD6jK592RsZptH8aQlZLP0o90AtLm2NvVaV/aoH7k87KdOkfTBbFK//BIjNxcAnwb1iRw2jJAbbsBk8+zvgYiIiIiIiJSckpciUnTpp2DOLZC0H4KqwpBFUNmzQjbekO9wMXnJXqb/egjDgOjIQN6+uy0ta4YWqx/DMPi/Vf/HtsRthPiEMPXqqYT6Fq+PMxx2J4tn7CQ/x0HV6FC6DIj2qB+59PIOHSZp5kzSFi0ChwMAv5YtiRwxnKC+fTGZtcxfRERERESktCl5KSJFk3oM5twMKUcgtJZ7xmVE/VIL50B8Jk98upmdp9IBGNy5Nv+8sSkBPsX/sfb+1vf58ciPWE1WpvSZQp2QOh7HteqLAyQcy8Av0Eb/Yc2xWJQAK2tydu4kafoMMpYsAcMAIKBLFyKHDyOga1ePtwoQERERERER71PyUkQuLumge6l42nEIqwtDvoVKtUslFMMwmL/2GP/6fhe5dhdhATZeu6MV/ZpX9ai/Hw79wH+3/heA57s+T8eqHT2Obf/60+xYeRKAax5uRlCY9kgsS7I3bCBx2nSyfv214FxQ375EDh+Gf5s2pReYiIiIiIiInJeSlyJyYQn73DMuM+MgoqF7qXhI9VIJJSkzj6cXbOOX3fEA9GgYyeQ7WxMV4lmScGvCVp5f9TwADzV/iNsb3u5xbClxWSyftweA9tfXoU7zCI/7Eu8xDIOslStJnDadnE2b3CfNZkJuvJGIYY/g16hR6QYoIiIiIiIiF+Rx8vK2226ja9euDB06lIgI/SddpEI6vdM94zIrAaKauZeKB0WVSigxe+MZ/8U2EjPz8LGYefr6JjzUrS7mYhTl+atTmad4fNnj5Lvy6V2rN0+0e8Lj2Oz5ThbP2IE9z0mNRpXodFM9j/sS7zCcTjIWLyZx+gzy9riTyiabjdA7bidi6FB8atUq5QhFRERERESkKDxOXp44cYKnn36aCRMmMGjQIEaPHk2HDh28GZuIlKZTm2HubZCTAlVbwf0LIfDy/6Ii1+7ktZ/2MHvVEQAaVQni7bvb0rRaiMd9ZtmzGL1sNMm5yTQOa8xrPV7DYrZ43N+vn+0j6WQW/iE+XDu0OWbtc1lqjPx80hYtImnGTPKPHgXAFBBA2N13Ez5kCLYqpZN8FxEREREREc94nLxcvnw5H3/8MdOnT2fOnDnMmTOHTp06MXr0aO666y58fX29GaeIXE7H18G8gZCXBjU6wH0LwL/SZQ9jT1w6T3yyhb2nMwB4sFtdnrm+CX42zxONTpeTp1Y+xf6U/UT6RzL16qkE2AI8j/H3WHavisVkgn4PNyMwVD/7SoMrO5vUL74g6YPZOE6fBsASGkrY/fcTft+9WCpVKt0ARURERERExCMeTw8KCgpi+PDhbNiwgU2bNjFy5Ej27NnDAw88QM2aNfnHP/7BsWPHvBmriFwOR1a5Z1zmpUHtbvDAwsueuDQMg9mrDnPL1FXsPZ1BZJAPsx/syMRbmpcocQkweeNkVp5Yia/Fl3f7vkvVQM8K/QAkncpkxcd7Aeh4Uz1qNgkvUWxSfM60NBL++18O9L2a06/+G8fp01grVybq6adpsGwplUc/qsSliIiIiIhIOeaVtY1t27blvffe49SpU8ycOZP69evz73//m+joaAYMGMCSJUswDMMbQ4nIpXRwGcy7A/IzIbo33Pcl+AZf1hDiM3J5cPZ6Xvh2F/kOF32bRPHTmJ70aVLy5b6f7/2cubvmAvDyVS/TIrKFx33l5zpYPH0HDruLWs3C6XB93RLHJ0XnSEgg/o03ONCnL4nvvIszNRVb7dpUffEF6i/9hYiHHsQcGFjaYYqIiIiIiEgJebXaeGBgIEOHDqVDhw6MGTOGmJgYvvnmG7755hvq1q3LuHHjGDVqFBZLyWZOicglsPcn+PwBcOZBw35w11yweVbF21O/7DrNUwu2kZyVj6/VzD9vbMp9XepgMnlWlOev1sSu4ZW1rwAwus1o+tft73FfhmGw4uO9pMRlExjqw7UPNcPkYeEgKZ78EydImjWLtAVfYeTnA+DbqBERw4cTcl1/TFav/rMmIiIiIiIipcxr/8vLysrik08+Yfr06axfvx6Abt26MWrUKE6dOsVrr73GY489xrp16/joo4+8NayIeMOuRfDlw+CyQ5ObYOBssPpctuFz8p28/MMu5q1xbzXRtFoI79zdhoZVvDPr83DaYZ6MeRKn4eTG6BsZ3mp4ifrb9dsp9q07jclsot8jLfAPvnx/VleqvAMHSJoxg7TvvgenEwD/Nm2IGDGcoN69vZLgFhERERERkbKnxMnLjRs3MmPGDD7++GMyMjIK9sJ89NFHadWqVcF1AwcOpFmzZsydO5c333yTyMjIkg4tIt6w7Qv4egQYTmhxB9w2DSy2yzb8jpNpPPHpZg4mZAEwrEc9xvdvjK/VOzO0U3NTGb10NBn5GbSp3IYXur1QokRXwvEMfv1sPwBdbo2mesNKXolTzi1n2zYSp08n85elBecCu3cnYsRwAjp2VNJSRERERESkgvM4eTl//nzefPNNNm3aBECzZs0YOXIkQ4YMISQk5Kzro6OjadCgATt37uTkyZNKXoqUBZvnwTejAQPa3Au3vAvmy7Otg8tlMPO3Q0xavBe70yAq2JfJd7WmR8PKXhvD7rQzNmYsxzKOUSOoBlP6TMHX4nk18Pwc9z6XToeLOi0jaHttba/FKn8yDIPstWtJnDaN7N/XuE+aTARfcw0Rw4fj39LzvUpFRERERESkfPE4eTlp0iR27tzJwIED+dvf/kafPn0ues+tt95KmzZtCAsL83RYEfGW9TPh+3Hu4w4Pww2TweyVGl4XFZeWy7gvtrDqQBIA/ZpV4d93tCI80HvLrw3D4KU1L7Hh9AYCbYFM7TuVCP+IEvW3bO4e0hJyCAr35Zoh2ufS2wyXi8yYGBKnTSN36zb3SYuF0JtvJmLYI/jWr1+6AYqIiIiIiMhl53HycuzYsfTr149q1aoV+Z6XX37Z0+FExJt+/w8sftZ93HkUXPcqXKbltz/tiOWZr7aTmm3H32bh/25uxt0da3l9+e+HOz/k6wNfYzaZmdRzEg3CGpSov+0xJzm4KR6zxUT/YS3wC7p8S+srOsPhIP3HH0maPp28/QcAMPn6UmngQCIefghbjRqlHKGIiIiIiIiUFo+Tl0OGDPFmHCJyuax8A5a95D6+aixcPeGyJC6z8hy8+O0uPttwHICWNUKZcncb6lcO8vpYy44t462NbwHwVMen6FGzR4n6O30knVVfuve57HZ7A6rWCy1xjAKuvDzSvl5I0syZ2E+cAMAcGEjY4MGED3kAq7YXERERERERueJ5nLw0DIOXXnqJ3Nxcnn/+efz9/Qu1z5s3jx07dvDAAw/QrFmzEgcqIiVkGLD8FVj5uvv73s9Cr6cuS+Jy6/FUxny2hcOJWZhMMLJXfcZe0wgfq/eXqe9O2s0zvz6DgcGgxoMY3GRwifrLzbKzeMYOXE6D6LaVadW3ppcivXI5M7NI/ewzkj6cjTMhEQBLWBjhQ4YQNvgeLOfYN1lERERERESuTB4nLxcuXMiECRO47bbbzkpcAgQHB/Paa6+xb98+vvrqqxIFKSIlZBjw8/Ow+l3399e8AFeNueTDOl0G7684yFs/78PhMqge6sfku9rQtb7ne09eSHx2PKOXjSbHkUPXal15ptMzJVqObhgGyz7aTUZSLiGRfvS9v4mqW5eAIyWFlLnzSJ4/H1daGgDWatWIeOghKt05EPM5/i0RERERERGRK5vHycsFCxYAMHDgwHO233TTTfj6+rJo0SLsdjs2m/aHEykVLhf89DSsm+7+/rrXoMvISz7siZRsnvxsK+uOJANwY6tqvDKgJaEBl+ZnQY4jh8eXPU58djz1QuvxRu83sJo9/hEHwNalxzm8NRGz1cR1w1vie4lir+jsp0+TPPtDUj7/HCM7GwCfunWJGDaM0JtvwuTjvUJNIiIiIiIiUrF4/D/7gwcPAlCvXr1ztlssFmrXrs3+/fs5evQoDRqUrFiGiHjA5YTvxsCmjwAT3PQWdHjokg+7aOspnvt6Oxm5DgJ9LLx4awtub1fjks1adBkunvvtOXYm7aSSbyX+0/c/hPiUbOlx7ME0fv/K/XOux50NqVw72BuhXlHyjx4laeYs0hYuxLDbAfBt1pTI4cMJvvZaTBZLKUcoIiIiIiIiZZ3HycszS8VPnjx53mtiY2MBNOtSpDS4HPDtGNj2KZjMcOt/oc09l3TIjFw7E77ZyVeb3T8X2tauxJRBbagTEXhJx/3Plv/w89GfsZqtTOkzhVohtUrUX05mPktm7sDlMmjYIYrmPVXtujhy9+4lafoM0n/80T3zF/Dv0J7IESMIvOoqLb0XERERERGRIvM4edmuXTuWL1/OF198cc6l4z/88AOZmZmEh4dTq1bJEgkiUjwmw4Fl4QjY/Q2YLHDHDGhxxyUdc+PRZMZ8toXjyTmYTfBY34Y81rcBVov3i/L81bcHv2X6NveS+IldJ9K+SvsS9We4DH6ZvYvMlDwqVQmg933a57KosjdvJmnadDJjYgrOBfbqSeTw4QS0L9l7ERERERERkSuTx8nLoUOHMmXKFD7//HOaNWvGs88+WzDDMiYmhuHDhwMwbNgwzOZLm7wQkb9w5NHx8FTMaZvAbIM7P4SmN1264Zwu3l12gHeX7cdlQM0wf6YMakOHuuGXbMwzNsdvZsLqCQAMbTGUWxvcWuI+Ny05yrGdyVhsZq4b3gIfv5Ltm1nRGYZB1qrVJE2bRvb69e6TJhPB1/Uncvhw/Jo2Ld0ARUREREREpFzz+H/lTZs2ZfLkyYwdO5aJEyfy2muvUb9+fU6fPk1CQgIA3bt3Z8KECV4LVkQuzvzL81RL24Rh9cM0aB40vPaSjXUsKZsxn21m07FUAG5vW4OJtzYnxO/SbxVxIuMETyx7ArvLztW1r+bxdo+XuM+T+1JY+80hAHre3YiIGkEl7rOiMlwuMn75haRp08ndudN90mYj9NZbiBg6FN/z7IcsIiIiIiIiUhwlmlL0xBNP0KRJE1599VVWr17Njh07AIiOjubhhx9m/Pjx+Pr6eiVQESmCrCTMWz8GwHn7LKyXKHFpGAZfbTrJhEU7ycxzEOxn5V8DWnBrm8uzN2RGfgajl44mJS+FpuFNeeWqVzCbSjbDOzs9nyUzd2IY0KRLVZp2q+alaCsWw24n7bvvSZoxg/xD7kSvyc+PsEF3Ef7QQ9iqVi3lCEVERERERKQiKfF6yP79+9O/f3/sdjspKSkEBAQQFKTZSiKlYtOHmBy5pPrXJbBBv0syRFq2necWbue7be6CXJ3qhvPmoNbUDAu4JOP9L4fLwd9X/p2DaQeJ8o/i3b7vEmAr2dgul8HPH+wkOz2f8OqB9Lynsfa5/B+u3FxSv1xA0gezcJxyv3tzSAhh9w4m/P77sYZf+m0CRERERERE5Mrjtc3cbDYbUVFR3upORIrLaYf1swA4VLkfLS9B8m3NoSSe/GwLp9JysZhNjL2mIaN6N8BivnyJvknrJ7Hq5Cr8LH68c/U7VAmsUuI+N3x/mBN7UrD6Wug/rAU2X4sXIq0YnBkZpHzyKclz5uBMSgLAEhlJxINDqHT33Vj0yyoRERERERG5hLySvMzIyODIkSNkZ2djGMZZ7a1atSIg4PLMyhK5Yu35DtJPYgRW5mRYZ1p6sWu708WUX/bx35iDGAbUiQjg7bvb0qZWJS+OcnGf7PmEj/e4l8W/2uNVmkc0L3Gfx3cls/6HIwD0HtyY8GqBJe6zInAkJZH80VxS5s/HlZkJgK1GDcKHPkyl22/H7OdXyhGKiIiIiIjIlaBEycs9e/bw+OOPs3TpUlwu13mv27x5M23atCnJUCJyMWunAeBq+wCuLO8VzDmcmMUTn25m24k0AO7qUJMJNzcn0PfyVuFefXI1r617DYAn2j3BNXWuKXGfWal5/Dx7JxjQrEd1GnfWfo32U6dI+mA2qV9+iZGbC4BP/fpEDh9GyA03YLJd+mJMIiIiIiIiImd4nH2Ii4ujZ8+eJCQk0KNHD3bt2kVSUhIDBgzg4MGDbN++nW7dutG2bVsqV67szZhF5H+d2gLHfgezFVe7B+HXzSXu0jAMPt9wnImLdpFjdxLqb+PV21tyQ8vLX8jmYOpBxq0Yh9Nwckv9WxjaYmiJ+3Q5XSyeuYOcDDsRNYPocWdDL0RafuUdOkzSzJmkLVoEDgcAfi1aEDlyBEF9+2Iyl6wgkoiIiIiIiIgnPE5evvfeeyQkJHDrrbeycOFC2rRpQ1JSEhMmTKBVq1YMGzaMefPm8dJLL1GjxuWpQCxyxVo33f212QAIrgaULHmZkpXPM19tY/HO0wB0jY7gzUGtqRbqX7I4PZCcm8yjSx8l055Ju6h2TOg6wSvFdNYuOkzsgTRsfhauG9YCq8+Vuc9l7q5dJE6fQcbixfDHth8BnTsTOWI4AV27qnCRiIiIiIiIlCqPk5erV68GYMiQIWe1mc1mJk2axEcffcTo0aPZtWuX5xGKyIVlJsD2L9zHnUeWuLvf9icy7ostnE7Pw2YxMb5fY4b1iMZ8GYvynJHvzGfs8rGczDxJzaCaTOkzBR+LT4n7PbI9kU2LjwLQ9/6mVKpy5e3Jm71hA4nTppP1668F54L69iVy+DD8tc2HiIiIiIiIlBEeJy/T09MBqF69OuCuNg6Q+8ceaeHh4dSuXZvdu3cTGxtLtWqXf6mpyBVh04fgzIfq7aBmh4Ilv8WV53DyxuK9zPj1MADRlQN55+62tKgR6sVgi84wDF74/QU2xW8i2BbMf67+D2F+YSXuNyM5l18+dP9CpWWfmjRoH1XiPssLwzDIWrmSxGnTydm0yX3SbCbkhhuIGDYMv8aNSjdAERERERERkf/hcfKyZs2arFu3jsTERACiotwJgFOnThVc4/gjiZL5R6VaEfEypx3Wz3Ifdx4JHi7x3X86g8c/3cLuWPcvJe7rUpvnbmiGfykupZ61YxaLDi7CYrLwRq83iK4UXeI+nQ4Xi2fsIC/LQVSdYLrf3sALkZZ9htNJxuLFJE6fQd6ePQCYbDZCb7+diKEP41O7dilHKCIiIiIiInJuHldgaN++PQDbt28HoFOnTgB8/vnnAKxdu5Zjx45htVqpU6dOSeMUkXPZ9Q1kxEJQFWh+W7FvNwyDub8f4aZ3f2N3bDrhgT7MfKAD/xrQslQTl78c/YW3N70NwD86/YNuNbp5pd/fvz7I6cPp+AZY6T+sBRZbxS5CY+Tnk/rllxy64UZOPjmOvD17MAUEEP7ww9T/5ReqvTBRiUsREREREREp0zz+n/uQIUOwWCzMnDkTl8vF0KFDCQoK4rPPPiM6Opo+ffoAMGLECHx8Sr5HnYicw9pp7q8dHgZr8T5niZl5DJ2zgee/2Umew0XPRpX5aUwPrmlW5RIEWnQ7k3byj1//AcDgJoMZ1GSQV/o9tDmBrUuPA3D1kKaERF7+4kOXiys7m+Q5czjQrz+x/3ye/KNHsYSGEjl6NA2XLaXKU3/HVuXKWS4vIiIiIiIi5ZfHy8Zr1KjBhg0byM3NxW63U7NmTZYsWcLYsWPZuHEjUVFRjBo1ipdfftmb8YrIGSc3wol1YLZB+4eKdevyvfH8/YutJGbm42M184/rmzCka91SKcrzV6ezTvP40sfJdebSvUZ3/t7x717pNy0hh6Uf7QagzTW1qNe6slf6LWucaWmkfPwxyXM+wpmaCoC1cmXCH36YsLvuxBwYWLoBioiIiIiIiBSTx8lLgDb/U5G2a9eurFmzpiRdikhRrZ3u/tridggu2mzJXLuTf/+4hw9XHwGgcZVg3r6nDU2qhlyiIIsu257NY8seIz4nngaVGjCp5ySs5hL9iALAaXfvc5mf46BqdAhdbqvvhWjLFkdCAslz5pDyyae4srIAsNWqRcSwRwgdMACzZr+LiIiIiIhIOeVxZqBt27Zs2bKFzZs3n5XEFJFLLOM07FjgPu48oki37IlL54lPtrD3dAYAD3aryzPXN8HPVnp7W57hMlz849d/sDt5N+F+4bzb912CfYK90veqL/eTcCwDv0Ab/R5pgcVScfa5zD9xgqRZs0hb8BVGfj4Avo0aETF8OCHX9cdkLXnyV0RERERERKQ0efw/25AQ90yt/D/+wywil9HGD8Flh5odoUb7C17qchl8uPoI//5pD/kOF5FBvky6sxV9GpedPQ/f2fQOy44vw2a2MaXPFGoG1/RKv/s3nGb7ipMAXPNwM4LD/bzSb2nLO3CApBkzSPvue3A6AfBv3ZqIkSMI6t0bk4dV50VERERERETKGo+Tlx06dGDlypXs2bOnoNK4iFwGjnzYMMt93HnkBS+NT89l/JfbWLkvAYCrm0Tx2sBWRAb5Xuooi2zhgYXM2uF+nhe6vUDbqLZe6Tf1dDbL5+4BoP11dajTPMIr/ZamnO3bSZw2jcxflhacC+zWjYgRIwjo1FFJSxEREREREalwPE5ejhkzhjlz5vDqq68yYMCAgpmYInKJ7foGMk9DUFVoest5L1u6O55nv9lFclY+vlYz/7ypGfd1rl2mElwb4jbwwu8vADC81XBurn+zV/p15Dv5afoO7HlOqjesRKeb63ml39JgGAbZa9eSNH06Wat/LzgffO21RAwfjn/LFqUYnYiIiIiIiMil5XHycu3atTz44INMmTKFhg0bMnjwYKKjo7HZbGdde+eddxIRUf5nPYmUCWvfd3/t+AhYzy7EkpPv5PNDZlb9vgWAZtVCeOeeNjSI8s4ekt5yLP0YY2LG4HA56FenH4+2edRrff/62T6STmbiH2yj3yPNMZfHfS5dLrKWLydl1ixyt25zn7NYCL35ZiKGPYJv/YpXeEhERERERETkf3mcvPzXv/7F1q1bAYiPj2fKlCnnvbZLly5KXop4w4kNcHIDWHyg/YPnvGTCt7tYddqdrBveM5px/Rrhay39ojx/lZ6fzuhlo0nLS6NFRAv+ddW/MJu8k2DcsyaWXatiwQTXDm1OYGjZWSJfFPbT8aT98gt1ZkwnNu40ACZfXyrdcQfhDz+MT80apRyhiIiIiIiIyOXjcfLyn//8J4mJiUW6tlatWp4OIyJ/dWbWZYuBEFT5rOZjSdl8szUWgOn3taVfi+qXM7oisbvsjI8Zz+G0w1QJqMI7fd/B3+rvlb6TT2Wx4uO9AHS6qR61moR7pd9LyXC5yN25k8zlMWTGxJC7axcAvoApMJDwwYMJH/IA1sjI0g1UREREREREpBR4nLwcOHCgN+MQkYtJj4WdX7uPOw8/5yUzfj2Ey4CmlVz0aXx2crO0GYbBv9f+m99jf8ff6s/Uq6dSOcA7cdrznPw0fTuOfBe1mobR/vq6Xun3UnBmZpH1+2oyY2LIXLES519/EWQy4duyBSdq1KTTP5/DT7PWRURERERE5ArmcfJSRC6zjbPB5YBaXaD62RW5EzPz+HzDcQCurm5c7uiK5OM9H/P5vs8xYeLfPf5Nk/AmXunXMAxWfLyXlLhsAkN9uOah5pjNZacwEUD+8eNkxqwgMyaG7HXrMOz2gjZzQACBV11FUO/eBPXsgREayvYffsCiQmgiIiIiIiJyhVPyUqQ8cOTBhg/cx51HnPOSOauPkOdw0apmCA1Cki9jcEWz8sRKXl//OgBPtn+SvrX7eq3v3ati2bs2DpPZRL9HmhMQcnYho8vNcDjI2byZjJgYMmNWkH/wYKF2W+3aBPXuRXDv3gR06IDJ58+Y7X9JbIqIiIiIiIhcyTxOXj733HMcPXq0SNe+8sor1K5d29OhRGTn15CVAMHVoenNZzVn5jn46Hf353H4VfVwHi1bycv9Kft5auVTuAwXtzW4jSHNh3it78QTGaz8bB8AXW6NpnrDMK/1XVzO1FQyf/3NvRz8t99wpaX92WixENC+vXt2Ze/e+NSri8lUtmaHioiIiIiIiJQ1Hicvv//++4Jq4xczfvx4JS9FPGUYsOY993HHoWCxnXXJp+uOkZZjJzoykGuaRrG4aL9XuCyScpIYvXQ0WfYsOlTpwPNdnvda0i4/x8FP03fgtLuo0zKCttde3p8zhmGQf/AgmTExZMTEkLNpM7hcBe2W0FACe/UkuHdvAq+6SsvARURERERERIrJ4+TlwoULyc3NPet8RkYGK1eu5IUXXqBTp05MmTKFhg0blihIkSvaifUQuwUsvtD+wbOa8x0uZv56GIDhPaOxlKG9HvOceTyx/AlOZZ2idnBt3ur9FrZzJF89YRgGy+buIS0+h6AwX64Z0gzTZXh2V34+2evWu2dXxsRgP3GiULtvw4bu2ZV9euPfujUmi+WSxyQiIiIiIiJSUXmcvKxbt+552zp27EiDBg0YMGAAc+fO5bXXXvN0GBE5M+uy1Z0QGHlW8zdbThKXnktUsC+3tasBhuusa0qDYRj836r/Y2vCVoJ9gpl69VQq+VXyWv87Vpzk4KZ4zGYT/Ye1wC/IO0nRc3EkJJC5cqU7YblqNUZ2dkGbyceHgM6dCerdi6BevfGpWeOSxSEiIiIiIiJypblkBXtuvfVWKlWqxNSpU5k4cSL+/v6XaiiRiivtJOz6xn3c6exCPS6XwbSVhwAYelU9fK0W7Paykbyctm0aPxz+AavJypu936ReaD2v9R1/NJ3fvtwPQLc7GlA1OtRrfQMYLhe5u3YXzK7M3bGjULu1cuWC2ZWBXbpgDgjw6vgiIiIiIiIi4nZJq41HRkZy4MABjh07RuPGjS/lUCIV04YPwHBCne5QrdVZzUv3xHMgPpNgPyuDO5edfWV/OvIT/9nyHwCe7fIsXap18VrfuVl2fpq+A5fDILpNZVr1remVfl3Z2WT9/vsfCcsVOBISCrX7tWzpnl3Zuzd+zZqp2I6IiIiIiIjIZXDJkpfHjx/nyJEjAISoSIVI8dlzYeNs93Hns2ddGobBezEHALivSx2C/S7dsuni2J6wnX/+9k8A7m92P3c2utNrfRuGwbKPdpORlEtIpB99H2hSoiRi/omTZK5wJyuz167FyM8vaDMFBBDUvZt7hmXPnlgrV/bGI4iIiIiIiIhIMXicvFy9ejXp6elnnXc6nRw5coS3334bh8NBx44dqVatWomCFLki7VgA2UkQUhMa33hW8/ojKWw6loqP1cxD3ete/vjOITYzlseWPUaeM4+eNXsyrv04r/a/delxDm9NxGx173PpG1C8hK3hcJCzdSuZMSvIjIkhb//+Qu22mjUJ6tOHoF69COjUEbOPjzfDFxEREREREZFi8jh5+be//Y2tW7de8JpGjRoxf/58T4cQuXIZBqx9333c6RGwnP1RfX/FQQDuaFeTqGC/yxndOWXZsxi9bDRJuUk0DGvI6z1fx2L2XqXtuENp/P6V+5mvGtiQqDpFm9HtTEsj87ffyIxZQdbKlTjT0v5stFgIaNuWoD69CerdG5/oaC0HFxERERERESlDPE5eDhs2jNjY2LPOm0wmQkJCaN26NX379sVqvaTbaopUTMfWQNw2sPpBuyFnNe+Ny2DZnnjMJhjRM7oUAizM6XLyzMpn2Jeyj3C/cKb2nUqgLdBr/edk5rN4xg5cLoMGHaJo0ev8Fb0NwyD/8GEyl7uL7WRv2gROZ0G7OTSUoB493MvBr+qOpVIlr8UpIiIiIiIiIt7lcWbx0Ucf9WYcIvJXZ2ZdtroLAsLPap72x6zL61tUo26k95KEnpqyaQoxJ2LwMfvwTt93qB5U3Wt9Gy6DX2bvJjMlj0pVAuhz39n7XBr5+WRv2EDGH8V27MeOFWr3aVCf4N7u2ZX+bdpg0i9VRERERERERMoF/Q9epKxJOwG7v3Ufdx55VvPJ1BwWbT0FwMhe9S9nZOe0YN8CPtz5IQD/uupftK7c2qv9b1pylGM7k7DYzPQf1gIfP/ePLUdiIpkrfyUzJoasVatwZWUV3GOy2Qjo3Nk9u7J3L3xqeqciuYiIiIiIiIhcXh4nLw3D4KWXXiI3N5fnn38ef3//Qu3z5s1jx44dPPDAAzRr1qzEgYpcMdbPBMMJdXtAleZnNc/89RAOl0H3BhG0rBlaCgH+aV3sOv615l8A/K3137i+3vVe7f/kvhTWfnMIgB6DGhKUfoyE/8aQuWIFudu2u/cG/YOlciRBvXoR3Ls3gV27Yg4s/RmpIiIiIiIiIlIyHicvFy5cyIQJE7jtttvOSlwCBAcH89prr7Fv3z6++uqrEgUpcsWw58DGD93H55h1mZKVz6frjgOlP+vySNoRxsaMxWE4uL7e9YxsfXa8JZGdns+SmTswDKjtF4ftuRc5fPp0oWv8mjf/Y3Zlb/yaN8NkNns1BhEREREREREpXR4nLxcsWADAwIEDz9l+00034evry6JFi7Db7dhsNk+HErlybP8CclIgtDY0PnsW45zfj5Bjd9K8eghXNYgshQDd0vLSGL1sNOn56bSKbMWL3V70WpVu+6lTpMes4JcVBtmmqgRmxVJv5es4XfmY/P0J7NaNoN69COrZC1uVKK+MKSIiIiIiIiJlk8fJy4MH3QVD6tWrd852i8VC7dq12b9/P0ePHqVBgwaeDiVyZTAMWDvNfdxpGJgthZqz8x3MWX0EgFG963stWVhcdpedJ2Oe5Gj6UaoFVuPtvm/jZ/XzuD/D6SRn2zYyY1aQGRND3t69HK5zA4n1bsTszKNNwiIi77mToN69CejUEbOvrxefRkRERERERETKMo+Tl2eWip88efK818TGxgJo1qVIURxdBad3gC0A2t1/VvPn64+Tkm2nTkQA17eoVgoBuve6fXnNy6yLW0eANYB3+75LpH/xZ4A6MzLIWrWKzOUxZK5ciTMlpaAtObwph+veAECPm6rR/JZPSy1RKyIiIiIiIiKly+PkZbt27Vi+fDlffPHFOZeO//DDD2RmZhIeHk6tWrVKFKTIFWHt++6vrQaBf1ihJrvTxYxfDwMwrEc0FnPpJPM+2vURC/YvwGwyM6nXJBqHNy7yvXmHD7tnV65YQfaGDeBwFLSZQ0IIuuoqzF378PvaEMh00Oyq6rS4tcmleAwRERERERERKSc8Tl4OHTqUKVOm8Pnnn9OsWTOeffbZghmWMTExDB8+HIBhw4ZhVhENkQtLPQZ7vncfdx5xVvN3205xMjWHyCAfBraveZmDc4s5HsPkDZMBGNd+HD1r9rzg9UZ+PtmbNrlnV8bEkH/0aKF2n+joP4rt9CKgbVsMs4VvpmwhJzOViJpB9Lir4aV6FBEREREREREpJzxOXjZt2pTJkyczduxYJk6cyGuvvUb9+vU5ffo0CQkJAHTv3p0JEyZ4LViRCmv9TDBcUK8XRDUt1GQYBtNWHALgoe718LNZztXDJbU3eS9PrXwKA4OBjQZyf7Ozl7UDOJKTyVy5ksyYFWT99huuzMw/G202Ajt2LEhY+tSuXejeNQsPcmp/KjY/C9cNa4HV5/I/p4iIiIiIiIiULR4nLwGeeOIJmjRpwquvvsrq1avZsWMHANHR0Tz88MOMHz8eXxXXELmw/GzYOMd93GXUWc0xexPYE5dBkK+V+7rUuczBQWJOIqOXjSbHkUPnqp15tvOzBXtQGoZB3r59BbMrc7ZudRce+oMlIoKgXr0I6t2LwG7dsQQFnnOMI9sT2fSTe2Zmn/uaUKlKwKV/MBEREREREREp80qUvATo378//fv3x263k5KSQkBAAEFBQd6ITeTKsO0zyE2FsLrQsN9Zze+tOAjA4M61CfW/vMWvch25PL7sceKy4qgbUpfJvSdjyXeSuXY1GTExZMaswPFHYa4zfJs1Jbh3b4J698avRQtMF9k2IiM5l18+3AVAy941adihyiV7HhEREREREREpX0qcvDzDZrMRFRXlre5ErgyGAWunuY87DQdz4aXSm46lsO5wMjaLiYe717usobkMF/9c9U+2J26nbm4QbxnXk/7EM8SuWYORm1twncnPj8CuXQuWg9uqFD356HS4WDxjB3lZDqLqBNP9jgaX4lFEREREREREpJzyOHlpGAYvvfQSubm5PP/88/j7+xdqnzdvHjt27OCBBx6gWbNmJQ5UpEI6vBISdoMtENrce1bz+zHuWZe3ta1B1VC/yxaW4XIxf8EEKv34A68fhLqnU7HzLvY/2q3VqhHcxz27MqBTJ8x+nsX2+8KDnD6cjo+/lf7DWmCxqbiXiIiIiIiIiPzJ4+TlwoULmTBhArfddttZiUuA4OBgXnvtNfbt28dXX31VoiBFKqwzsy7b3AP+lQo1HYjPYMmu05hMMLxn/UseijMzk6xVq8mMiSFp+c90SM2kw5lGkwn/Nm3+mF3ZG99GDQv2vfTUoS0JbP3lOABXD2lKSOTZP0dERERERERE5MrmcfJywYIFAAwcOPCc7TfddBO+vr4sWrQIu92OzXZ59+oTKfNSjsDeH9zHnYaf1Xymwvi1TavQIOrS7CObf+wYmTHuYjtZ6zeA3T230gpk+0Jam2ja3z6cwJ49sYaFeW3ctIQcls7ZDUDra2oR3aay1/oWERERERERkYrD4+TlwYPu5az16p17Hz6LxULt2rXZv38/R48epUED7WUnUsi6GYAB9ftC5caFmmLTcli45SQAI3t7b9alYbeTvXkzmTEryIyJIf/QoULt5jq1WFwjkVV186jWtQ+Tr34by//sw1lSTrt7n8v8HAdVo0Poetuln1UqIiIiIiIiIuWTx8nLM0vFT548ed5rYv+oQqxZlyL/Iy8TNs11H3ceeVbzB78dxu406FwvnHa1Szbj0ZGSQtavv7pnWP76G66MjD8brVYCOnYguHdvTN068vCu5ziQGkvjsKa80vt1rycuAVYtOEDCsQz8Am30e6QFFov2uRQRERERERGRc/M4edmuXTuWL1/OF198cc6l4z/88AOZmZmEh4dTq1atEgUpUuFs+wzy0iA8GhpcW6gpLdvOx2uPAZ7PuvSJiyNl5iyyf/2VnC1bwOUqaLOEhRHUqxdBvXsT2L0bluBgHC4Hjy17jAOpB4j0j2Tq1VMJsAV4/Hjns3/DabbHnADgmoeaERx++YoQiYiIiIiIiEj543HycujQoUyZMoXPP/+cZs2a8eyzzxbMsIyJiWH4cPcefsOGDcNs1swqkQKG8Wehnk4j4H8+H/PWHiUr30mTqsH0blT8vSCT/vtf6r73Pkl/OefbpAlBvXsR3Ls3fi1bYrIUnlE5ecNkfjv5G74WX97t+y5VA6sWe9yLST2dzfJ5ewBod10d6rSI8PoYIiIiIiIiIlKxeJy8bNq0KZMnT2bs2LFMnDiR1157jfr163P69GkSEhIA6N69OxMmTPBasCIVwqHlkLgXfIKgzeBCTbl2Jx/8dhiAkb3qF7uid/7Ro6TMmAlAQI8ehFx9NUG9emKrVu2893y+93Pm7Z4HwMtXvUyLyBbFGrMoHPlOfpq+A3uuk+oNK9H55nPvlSsiIiIiIiIi8lclmhL5xBNP8OOPP9KrVy8cDgc7duwgISGB6Oho/vWvf7F06dKCvTFF5A9nZl22uRf8Qgo1fbHxBElZ+dSo5M9Nrc6fcDyfhLffBoeDrEaNqP7f/xB296ALJi5/P/U7r6x9BYDH2j5G/7r9iz1mUfz6+X6STmbiH2yj39DmmLXPpYiIiIiIiIgUgcczL8/o378//fv3x263k5KSQkBAAEFBQd6ITaTiSToI+xa7jzsNL9TkcLqYsdJd/Xt4z2isxUzw5WzfTvoPP4LJRMIN11/0+kNphxgXMw6n4eSm6JsY1nJYscYrqr1rYtn12ykwwbVDmxNYyfeSjCMiIiIiIiIiFU+Jk5dn2Gw2oqKivNWdSMW0fiZguIv0RDYo1PTjjjiOJWcTHujDXR2KV+TKMAzi35gMQPDNN5F/gdmWACm5KYxeOpoMewZtKrdhYreJxV6iXhTJp7KI+XgvAB1vrEetJuFeH0NEREREREREKi6vJC8zMjI4cuQI2dnZGIZxVnurVq0ICPB+5WKRciUvAza795ak88hCTYZh8P6KgwAM6VoXfx/L/959QVm//kr22rWYfHwIHz0aNm8+77V2p52xMWM5nnGcGkE1mNJnCr4W78+GtOc5+WnGDhz5Lmo2CaPDDXW9PoaIiIiIiIiIVGwlSl7u2bOHxx9/nKVLl+Jyuc573ebNm2nTpk1JhhIp/7Z+CnnpENEA6vct1PTr/kR2nkrH32bhga51itWt4XQWzLoMu/de9x6X50leGobBi2teZOPpjQTaApnadyoR/t6v+m0YBis+3ktKbBYBoT5c+3BzzGbvz+wUERERERERkYrN4+RlXFwcPXv2JCEhgR49erBr1y6SkpIYMGAABw8eZPv27XTr1o22bdtSuXJlb8YsUv64XH8W6uk0AsyF97M8M+vy7k61CAv0KVbXad9+S96+fZhDQogcMZzz/xoBZu+czcIDCzGbzLzR6w0ahDW4wNWe2706lr1r4zCZoP8jzQkIKd4ziYiIiIiIiIhACaqNv/feeyQkJHDrrbeycuVKatasCcCECRPYsmULDz/8MBs2bOD222+nRo0aXgtYpFw6tAyS9oNvCLS5p1DTthOprD6YhNVs4pEe0cXq1pWXR8I77wAQOXwYlkqVznvt0qNLmbJxCgBPdXyKq2pcVayxiirxRCYrP90HQOdbo6neMOySjCMiIiIiIiIiFZ/HycvVq1cDMGTIkLM7NZuZNGkSLpeL0aNHex6dSEWx5n3317b3gW9woaYzsy5vaVOdGpX8i9Vtyrz5OE7FYq1albD77jvvdbuTdvOP3/6BgcGgxoMY3GRw8eIvovwcBz9N347T7qJOiwja9SveEngRERERERERkb/yOHmZnp4OQPXq1QF3tXGA3NxcAMLDw6lduza7d+8mNja2pHGKlF+JB+DAz4AJOj5SqOlwYhY/7ogDYGSv+sXq1pmWRuL06QBUfuwxzH5+57wuPjue0ctGk+PIoVv1bjzT6ZlLUlncMAyWz99DWnwOQWG+XPNgM0za51JERERERERESsDj5OWZZeKJiYkAREVFAXDq1KmCaxwOBwCZmZkeByhS7q1zJxhp1B8iCicop688hGHA1U2iaFQl+Bw3n1/SjBm40tLwbdiQ0AG3nvOaHEcOjy17jPjseKJDo5nUaxJWc4nqdJ3XjhUnObAhHrPZRP9hLfALsl2ScURERERERETkyuFx8rJ9+/YAbN++HYBOnToB8PnnnwOwdu1ajh07htVqpU4dLR2VK1RuOmyZ7z7uPKJQU3x6Lgs2ngBgZO/izbq0x8aS/NFcACqPexKTxXLWNS7DxXO/PceupF1U8q3E1L5TCfEJ8eAhLi7+aDq/fbkfgK6316dqdOglGUdEREREREREriweJy+HDBmCxWJh5syZuFwuhg4dSlBQEJ999hnR0dH06dMHgBEjRuDjo0rDcoXa8jHkZ0JkY4juU6jpg1VHyHe6aF8njI51w4vVbcI772Lk5xPQsSNBvXqd85r/bvsvPx/9GavZypQ+U6gVUsvjx7iQvGw7i2fswOUwqNc6ktZXX5pxREREREREROTK4/H60Ro1arBhwwZyc3Ox2+3UrFmTJUuWMHbsWDZu3EhUVBSjRo3i5Zdf9ma8IuWHywXrprmPOw+Hv+wzmZ5rZ/6ao0Dx97rM3buPtIULAYgaP+6c+1duzt/Mgp0LAJjYdSLtq7T34AEuzjAMln20h/TEXEIi/ej7QNNLsp+miIiIiIiIiFyZSrT5XZs2bQp937VrV9asWVOSLkUqjgO/QPIh8A2FVncXavp47TEy8hw0jAri6iZRxeo24c03wTAI7t8f/9atz2rfkrCFhdkLAXik5SPc2uDc+2F6w7ZlJzi0JQGz9Y99LgO1z6WIiIiIiIiIeI/Hy8ZF5CLWvu/+2u5+8A0qOJ3ncPLBb4cBGNGrPuZiVOTOWreOzBUrwGolauyYs9rznflMXDMRJ0761urLY20fK9EjXEjcoTRWLzgAwFUDGxJV59LspykiIiIiIiIiVy4lL0UuhYR9cHApYIJOwwo1fb3pJPEZeVQL9eOW1tWL3KVhGMS/MRmAsLvuxKdu3bOumbd7HscyjhFkCmJil4mYTZfmI56b+cc+ly6DBh2iaNGrxiUZR0RERERERESubEpeilwKZ/a6bHwDhNUtOO10GUxbeQiAoVfVw8da9I9gxuIl5G7bhikggMi//e2s9vjseKZtdY/bz78fQbags67xBsNl8MuHu8hMySM0yp8+9zbRPpciIiIiIiIickmUaM9LETmHnFTY8on7uPOIQk1LdsZxODGLUH8b93SqXeQuDbudhLfeAiDioYewRkaedc2UjVPIdmTTIqIFbRxtPI3+ojb/fIyjO5Kw2MxcN7wFPv76MSIiIiIiIiIil4ZmXop425b5YM+Cyk2hXs+C04Zh8P6KgwAM6VqHQN+iJ/1SvviC/KNHsUREEP7QQ2cPGb+Fbw99C8DTHZ6+ZMvFT+1PYc037pmjPQc1IrJm8CUZR0REREREREQElLwU8S6XE9ZNdx93HgF/WU79+6Ektp5Iw89mZki3ukXu0pmZReJ//gtA5KN/wxIUWLjd5eTVda8CcFuD22ge0bxkz3Ae2en5LJ65E8Nl0LhzVZp2r3ZJxhEREREREREROcPj5OXx48c5cOAA+fn5JbpGpELZvwRSjoBfJWh1V6Gm91e4Zyze1aEWEUG+Re4y+cMPcSYlYatTm7A77zyrfeGBhexK2kWQLYjH2z1ekujPy+Uy+PmDnWSn5RNWLZBegxtrn0sRERERERERueQ8Tl7efPPNNGzYkF27dpXoGpEKZe377q/tHgCfP2dI7jyVxsp9CVjMJob1iC5yd47ERJI++ACAqLFjMdlshdrT89N5e9PbAIxqPYpI/7P3wvSGjT8e4cSeFKw+Zq4b1gKbr+WSjCMiIiIiIiIi8leXdNm4YRgAmqElV4b4PXAoBkxm6PhIoaYzsy5vbFmNWuEBRe4y8b//xcjOxq9VK4L79z+r/b0t75GSl0J0aDT3NL2nROGfz/E9yaz77jAAvQc3Jrx64EXuEBERERERERHxjkuavExISAAgOFhFPeQKsG6a+2vjGyCsTsHpY0nZfL/tFAAjehV91mX+kSOkfP4FAFHjx531S4ADKQf4ZI+7qvnTnZ7GZrad1UdJZaXl8fOsnWBAs+7VaNxF+1yKiIiIiIiIyOVT9HLHwPz58wsSkme+zp8/n5iYmELXORwONm7cSGxsLOHh4dSpU+d/uxKpWHJSYOun7uMuowo1zfj1EC4DejWqTPPqoUXuMn7K2+BwENirJ4GdOhVqMwyDf6//N07DSd9afelWvVuJH+F/uZwulszcSU6GnYgaQfQY1MjrY4iIiIiIiIiIXEixkpeTJk1i69athc698cYb573ex8eHyZMnY7Fofzyp4DbNBXs2VGkBdboXnE7MzOPzDccBGNmrfpG7y9m2jYyffgKTiagnx53VvuzYMtbGrsXH7MP4juNLHv85rPv2MKf2p2LztXDd8BZYffQ5FhEREREREZHLq1jJy1deeYXk5GQAnnvuOY4dO8bLL79M7dq1C11nsVgIDw+nY8eOhIeHey9akbLI5YR1M9zHnUfAX5Z3z1l9hDyHi9a1KtElumifBcMwiJ/k/qVA6IAB+DUuPOMx15HLpA2TABjSfAi1gmt54SEKO7ojiY0/HQWgz/1NqFSl6Pt0ioiIiIiIiIh4S7GSlzfccEPB8caNGzl8+DD33HMP9erV83pgIuXG3h8h7Rj4h0HLOwtOZ+Y5mLP6CACjekUXuXBV5ooVZK9fj8nHh8qPP3ZW+4c7P+Rk5kmiAqJ4pOUj5+ihZDKSc/ll9i4AWvaqQcMOVbw+hoiIiIiIiIhIURQreflXb7311nnb4uLiSEpKolmzZqo0LhXf2vfdX9s/CDb/gtOfrjtGeq6D6MhArm1WtUhdGU4nCZPfBCDs/vuwVStcICc2M5ZZ22cBML7DeAJs3p0R6XS6WDJzB7lZdirXDqb7wIZe7V9EREREREREpDg8rjbudDoZPnw4Dz74IDk5OQXnn3jiCapVq0aLFi1o27Yt8fHxXglUpEw6vROO/AomC3QYWnA63+Fi5q+HARjeMxqLuWhJ/LRvFpG3fz/m0FAihw8/q33yxsnkOnNpF9WO6+pe551n+Is1Xx8k7lA6Pv5W+g9rgcXm8Y8IEREREREREZES8zgzsWDBAmbMmEF+fj7+/u7ZZj///DPvvPMOffr0oU6dOmzdupUJEyZ4LViRMmftNPfXpjdBpT/3nvxmy0ni0nOJCvbltnY1itSVKzeXhHfeASBy+HAsoYUrk6+PW8/iI4sxm8z8o/M/vD6r+dCWBLb84i4udPWQpoRW9r/IHSIiIiIiIiIil5bHycvvvvsOgBtvvLHg3CeffEL37t1ZtmwZS5cuxWQyMXfuXFwuV8kjFSlrspNh2+fu484jC067XAbTVh4CYOhV9fC1Fq1Kd8q8eTji4rBWq0bYffcWanO4HLy67lUA7mx0J03Cm3jhAf6UnpjDso92A9D6mlpEt6ns1f5FRERERERERDzhcfLy8GH3ktj69esXnFu9ejU33XRTwfnatWuTlZXF6dOnSximSBm06SNw5EDVVlC7a8HppXviORCfSbCflcGdaxepK2dqKonT3RXLKz/+OGZf30LtX+z7gv0p+wnxCWF0m9HeewbAaXexeMYO8rIdVKkXQtfb6l/8JhERERERERGRy8Dj5KXNZgMgOzsbgJSUFPbt20e7du0KrvH9IwGTmZlZkhhFyh6nA9a5k410Hgl/LOE2DIP3Yg4AcF+XOgT72YrUXeL0GbjS0/Ft1IjQW24u1JaSm8LUzVMBeKztY1Tyq+SdZ/jDqq8OEH80A9/AP/a5tGifSxEREREREREpGzzOUpyZcbl48WIAFi5ciNVqpWtX9ww0wzA4duwYJpOJ2rWLNvtMpNzY+z2kn4CACGhxR8Hp9UdS2HQsFR+rmYe61y1SV/ZTp0iZNw+AqPHjMFkKLzOfunkq6fnpNAprxMBGA732CAAHNsazffkJAK55sBnB4X5e7V9EREREREREpCSsnt740EMPMXPmTN544w3WrFnDxo0bGTBgAMHBwQBs2bKF3Nxc2rdvXzADs7hOnz7NnDlz2LZtGzabjc6dO3P//fcTGBhY5D7Gjx/PgQMHLnjNjTfeyLBhwzyKUa5QZwr1tH8IbH8m/N5fcRCAO9rVJCq4aInAhLffwcjPJ6BzZwJ79CjUtjtpN1/s+wKAZzo9g9Xs8Uf2LKmns1k2173PZbv+dajbMtJrfYuIiIiIiIiIeIPHmZBu3boxadIkXnrpJX777Td69uzJ22+/XdA+e/ZsAIYMGeJR/6tXr+bmm28mOTm54NyHH37IG2+8wbJly4o8mzMmJoaNGzde8JqePXt6FKNcoWK3wdFVYLJAx6EFp/fGZbBsTzxmE4zoGV2krnL37iVt0SLgj1mXf6kgbhgG/173bwwMrqt7HR2rdvTaIzjynSyeuQN7rpNqDULpfEs9r/UtIiIiIiIiIuItJZrGNX78eMaNG4fdbsfHx6dQ21NPPcXjjz9OrVq1it1vRkYGt99+O8nJyfTu3ZuHHnqInJwcpk6dyo4dO7jrrrtYs2ZNkfqaPHkyKSkpZ503DIMhQ4aQnZ3N4MGDix2jXMHW/THrstmtEFK94PS0P2ZdXt+iGnUjizY7OH7yZDAMgq+/Dv+WLQu1/XTkJzbFb8LP4se4DuO8E/sffv1iP4nHM/EPttH/kRaYtc+liIiIiIiIiJRBJV6DajKZChKXDocDq9XdZc2aNT3uc/r06Zw+fZqrrrqKpUuXYja7Eyv33HMPrVq1Yu3atSxZsoR+/fpdtK9evXqd8/zy5cvJyMjgxhtvpGrVqh7HKleYrCTY5l7GTeeRBadPpGSzaOspAEb2Klq17qw1a8la+StYrUSNGVOoLduezRsb3gDgkZaPUDXQe39H966NY9evp8AE1z7cnMBKnm3rICIiIiIiIiJyqZVoupXD4eCNN96gRYsW+Pj4YLPZ2LJlCwBTp07lkUceYdu2bcXu95tvvgHg6aefLkhcAoSEhPDoo48C7gJBJfHBBx8A8OCDD5aoH7nCbPoQnHlQrQ3U6lRweuavh3G4DLo3iKBlzdCLdmO4XMS/4U5Ohg0ahE+dOoXaZ26fSXx2PDWCajCkuWdbL5xLcmwWMfP3ANDxhrrUahrutb5FRERERERERLzN45mXLpeLO+64g0WLFhEcHIzVasVutxe0BwQEMGvWLKxWK++//36x+j6TAD3XrMk+ffoUusYT6enpLFiwgPDwcG655RaP+5ErjNMO62e5jzuPhD/2p0zJyuez9ceBos+6zFi8mNwdOzAHBBD5t1GF2o6nH+fDnR8C8PcOf8fP6p0K4PY8J4tn7MCR76JmkzA63Kh9LkVERERERESkbPN45uVnn33GokWLaN68OceOHaNRo0aF2gcOHAjAF198gWEYRe43NTWVjIwMIiMjCyqX/1XdunUBOH78uKeh88knn5CTk8Pdd9991l6dIue1+1tIPwmBlaHF7QWn5/x+hBy7kxY1QriqwcUrdhv5+cS/NQWA8KEPY42IKNQ+acMk7C47Xap1oW/tvl4J3TAMVnyyl+RTWQSE+nDtw80xm00Xv1FEREREREREpBR5PPNywYIFAPz973+nUqVKhaokg3uJd2RkJImJiZw4caLIhXsyMzMBzpm4/Ov5M9d5YtYs9+y5oiwZz8vLIy8vr+D79PR0AOx2e6GZphXJmeeqqM/nKcua9zEDzrZDcBlmsNvJzncwZ/URAIZ1r4vD4bhoP6mffIr92DEsERGE3HdfoT/n1adWs/z4ciwmC+PbjS9Sf//rXO9vz+9x7F0Th8kEfYc0xuZv0vstw/QZLP/0Dss/vcPyTe+v/NM7LP/0Dss3vb/yT++w/Kvo77A4z2UyijMt8i86derE+vXr+f333+nSpQvt2rVj8+bNbN68mTZt2gDQpEkT9u7dy44dO2jevHmR+o2Li6NatWrUqlWLY8eOndWelZVFUFAQkZGRJCQkFDvunTt30qJFC5o3b86OHTsuev3EiRN54YUXzjr/8ccfExAQUOzxpXwKzT5M770TcGFhSYu3yLNVAmBlrIkFRyxE+ho819bJxSYzmnNzqfv6JKxZWZy+bQBpXboUtDkMB1MzppLoSqSbbzdu8L/BK7Hnp5uJ/z0AXCZCGuURUj/fK/2KiIiIiIiIiHgiOzubwYMHk5aWRkhIyAWv9Xjm5ZnEXXZ29nmvOXHiBAAR/7Ms9kLOBJycnHzO9jPnK1WqVOQ+/+rMrMshQ4pWBOUf//gHTz75ZMH36enp1KpVi379+l30D7e8stvt/Pzzz1x77bXYbLbSDqdMsHw72n3QfABX3zoYALvTxetTfgNyeaxfM27qdPHZxUn/+Q8pWVnY6tah2/PPY/rLn++83fNI3JxImG8Yr978KsE+5559fDF/fX+G08TXk7aAK4dazcK4bkRzTFouXubpM1j+6R2Wf3qH5ZveX/mnd1j+6R2Wb3p/5Z/eYflX0d/hmZXNReFx8rJNmzasWLGCDRs20Ldv37OWjf/4449kZWVRq1YtqlatWuR+AwICqFGjBidPnuTo0aPU+Z8qzDt37gSgYcOGxY7Zbrczb948LBYL9913X5Hu8fX1xdfX96zzNputQv7l+asr4RmLJDMBdn4FgLnr3zD/8Wfy3Y4TnEzNJTLIh0Gd6mCzWS7YjSMhgdSP5gIQNfZJfP4yczcxJ5FpO6YBMKb9GMIDS14F3Gq1EvPxPtLicwgK8+Xah5vj46s9XssTfQbLP73D8k/vsHzT+yv/9A7LP73D8k3vr/zTOyz/Kuo7LM4zeVyw55FHHsFsNjNlyhQOHjxYqG3Lli2MGuWuoPzoo48Wu+8ePXoA8PXXX5/VtnDhQgC6d+9e7H6//fZbEhIS6N+/P9WqVSv2/XKF2vghOPOhRnuo2QFwF8CZtuIQAA91r4ffRRKXAAn/+Q9Gdjb+rVsT3O/aQm1vb3qbLHsWzSOaM6DBAK+Evfu3WPZviMdsNtHvkRb4BylxKSIiIiIiIiLli8fJyxYtWvDmm28SFxdHkyZNCmZE3njjjbRt25ajR4/Sr18/xo0bV+y+z8yK/Ne//sWePXsKzi9btowPPvgAq9XKPffcU+x+P/jgA6BohXpEAHDaYf1M93HnkQWnY/YmsCcugyBfK/d1qXOem/+Ud+gwqV98CUDU+HGFZipvT9jOwgMLAXim0zOYTR5/LAvkp5lZ/ZU7udr19vpUqx9a4j5FRERERERERC63EmVJnnjiCX7++Wd69+5dcO7UqVNER0fz6quv8t1332G1Fn9l+o033sgNN9xAUlISrVu3pm/fvnTr1o1rrrkGu93Ok08+SXR0dKF7NmzYwIABA3j22WfP2eepU6f46aefCAsL45Zbbil2THKF2vUNZMZBUBVoNqDg9Hsr3LONB3euTaj/xac6J0yZAk4nQb17E9CxY8F5l+Hi1XWvAnBL/VtoE9WmxCHnZTtI2uyPy2FQr3Ukra+++F6cIiIiIiIiIiJlkcd7Xp5x9dVXc/XVV+NwOEhOTsbf35/gYM8KjfzVp59+ysiRI/n0009Zvnw54N5/csyYMbzyyitnXR8XF8c333xDYmLiOfubM2cOTqeTe+6555x7WIqc01r3PpR0GApW97LrjUdTWHc4GZvFxMPd6120i5wtW8hYsgTMZqLGPVmo7duD37I9cTsB1gDGtBtT4nANw2DlJ/tx5pgJDvel7wNNz9qPVkRERERERESkvPA4eXn8+HHy8vKoXbs2Pj4+WK1WoqKiLnhNcQQHBzN//nwmTZrEzp07sVqttG3b9rxVxjt27MjXX3993srmvXv35uuvv6bjX2a9iVzQyY1wYh2YbdDhoYLT7/8x6/K2tjWoGup3wS4Mw+D0G28AEHrbAHz/UmgqMz+Ttza+BcDI1iOpHFC5xCHvXh3L4S2JYDK4+uGm+AVWvE19RUREREREROTK4XHy8uabb2br1q1s3ryZNm3aeHzNxVSvXp3q1atf9LoqVaowYMCA87Z37drVo/HlCnZm1mWLOyDInZg/EJ/Bz7tOYzLB8J71L9pF5vIYcjZsxOTrS+XHHivUNm3bNJJyk6gTUof7mt5X4nBT4rL49bN9AIQ2yieqTslnQIuIiIiIiIiIlKaSVwa5AMMwALRsVcqfjNOw4yv3cefhBafPVBi/tmkVGkQFXbALw+kk/s3JAIQ/cD+2qlUL2g6lHWLernkAPNXxKWyWks2QdDpc/PzBLhz5Lqo3CiWoXn6J+hMRERERERERKQsuafIyISEBwCt7YIpcVhtng8sONTtBjfYAxKblsHDLSQBG9r74rMu0hQvJP3AQS2goEcOGFZw3DIPX172Ow3DQs2ZPetbsWeJw135ziIRjGfgF2uhzf2P0+wIRERERERERqQiKtWx8/vz5BQnJM1/nz59PTExMoescDgcbN24kNjaW8PBw6tSp451oRS4HRz6sn+U+7jyi4PQHvx3G7jToXC+cdrXDLtiFKyeHhHfeBSBi5EgsISEFbStOrGDVqVVYzVae6vhUicM9vjuZzT8fA6DP/U0IrKSCVCIiIiIiIiJSMRQreTlp0iS2bt1a6NwbfxQjORcfHx8mT56MxWLxLDqR0rBrIWTFQ3A1aHYrAGnZdj5e604QFmXWZfLceThOn8ZWvTph9w4uOJ/nzOO1da8B8ECzB6gTUrLEfk5mPr98uAuA5j1rEN2mMna7vUR9ioiIiIiIiIiUFcVKXr7yyiskJycD8Nxzz3Hs2DFefvllateuXeg6i8VCeHg4HTt2JDw83HvRilwOa993f+0wFP7Yi3LumiNk5TtpUjWY3o0uXBXckZJC0owZAFR+4nHMPj4FbXN3zeVE5gkq+1dmeKvh5+uiSAzDYNlHe8hOyyesagDdBzYoUX8iIiIiIiIiImVNsZKXN9xwQ8Hxxo0bOXz4MPfccw/16tXzemAipeLEBji5ESw+0P5BAHLtTmavOgLAyF71L1qAKmnadFwZGfg2aULIzTcXnI/LimP6tukAjG0/lkBbYIlC3bnyJEe2JWK2muj3SHNsPprhLCIiIiIiIiIVS7GSl3/11ltveTMOkbLhzKzLlndCkHuG5RcbT5CUlU+NSv7c1KraBW/PP3GSlPnzAYgaNw6T+c+aWG9tfIscRw6tK7fmpuibShRm8qksfvvyAADdbmtAZE0VxRIRERERERGRiueSVhsXKVfSY2Hn1+7jTu4l3Q6nixkrDwEwvGc0VsuFPzIJ77yNYbcT0LULgVd1Lzi/6fQmfjj8AyZM/KPzPy46e/NCHHYnS2btxGl3Ubt5OK361PS4LxERERERERGRskzJS5EzNnwALgfU7grV2wDw4444jiVnEx7ow10dal3w9tzdu0n/9jsAosaNL0hQOl1OXl33KgC3N7yd5hHNSxTm718fJOlkJv7BNq4e0gyT2fNEqIiIiIiIiIhIWabkpQiAI8+dvAToPAJwF8R5f8VBAIZ0rYv/RfaUjJ/8JhgGITfcgH+LPxOUXx34ij3Jewi2BfN4u8dLFObRHUlsW3YCgL4PNCUgxOcid4iIiIiIiIiIlF9KXooA7PgKshMhpAY0ce9H+ev+RHaeSsffZuGBrnUueHvW77+T9dtvYLNReeyYgvNpeWm8s+kdAB5t+yjhfuEeh5idns/SObsAaNWnJnVbRnrcl4iIiIiIiIhIeaDkpYhh/Fmop+NQsNgACmZd3t2pFmGB55/haLhcxE96A4Cwu+/Gp9afy8v/u+W/pOalUj+0Pnc1vqsEIRosnbObnAw7ETUC6Xp7fY/7EhEREREREREpL5S8FDm+DmK3gMUX2j0IwLYTqaw+mITVbOKRHtEXvD39xx/J3bULc2AgkaNGFpzfl7KPz/Z+BsDTnZ7GZrZ5HOK25Sc4tjMJi83MtUObY7VdeAm7iIiIiIiIiEhFoOSlyJlZl63uhMAI4M9Zl7e0qU6NSv7nvdXIzydhytsARDwyFGu4e1m4YRi8tu41nIaTa2pfQ9fqXT0OL/FEJqu/OgBA9zsaEFE9yOO+RERERERERETKEyUv5cqWdhJ2feM+7uyeNXk4MYsfd8QBMLLXhZdnp3z6Gfbjx7FWrkz4kCEF538++jPr4tbha/FlfMfxHodnz3eyZNZOXA6Duq0iadGrhsd9iYiIiIiIiIiUN0peypVtwywwnFDnKqjaEoDpKw9hGHB1kygaVQk+763OzEwS33sPgMjRozEHBACQ48jhjQ3uPTAfavEQNYI8Tziu/vIAKbFZBIT60PeBJphMJo/7EhEREREREREpb5S8lCuXPQc2zHYfdx4BQHx6Lgs2ngBgZO8Lz7pMmjULZ0oKPvXqUemO2wvOz94xm9isWKoGVuXhFg97HN7hrQnsWHkSgGuGNMM/6PxFg0REREREREREKiIlL+XKtWMB5CRDaC1ofAMAH6w6Qr7TRfs6YXSsG37eW+3x8SR/OAeAyk+OxWS1AnAy8yQf7PgAgPEdxuNvPf9+mReSlZrHso/2ANDm2trUanb+WEREREREREREKiolL+XKZBh/Furp+AhYrKTn2pm/5igAoy6y12Xi1P9g5OTg37YtwddcU3B+8obJ5Dnz6Fi1I/3q9PMsNJfBLx/uIjfLTuXawXS59cLVzkVEREREREREKiolL+XKdOx3iNsOVn9o9wAAH689Rkaeg4ZRQfRtEnXeW/MOHSJ1wQIAosaPK9iHck3sGn4++jNmk5lnOj3j8f6UW345zok9KVh9zFz7cDMsVn1MRUREREREROTKpKyIXJnOzLpsdRcEhJNrdzLrt8MAjOhVH7P5/InHhLfeAqeToL59CWjfHgCHy8Fr614DYFDjQTQKa+RRWPFH01nzzUEAetzViLCqgR71IyIiIiIiIiJSESh5KVee1OOw+zv38R+Fer7efJKEjDyqhfpxS+vq5701e9NmMn7+Bcxmop4cW3D+s72fcSD1AJV8K/Fom0c9Csue5+TnD3bhchrUb1uZpt2redSPiIiIiIiIiEhFoeSlXHk2zALDCXV7QJXmOF0G01ceAmDoVfXwOc8ybcMwiH/jDQAq3XE7vg0aAJCcm8x/tvwHgMfaPkaob6hHYf32+T5ST2cTFOZL7/uaeLzsXERERERERESkolDyUq4s9hzY+KH7uMsoAJbsjONwYhah/jbu6VT7vLdmLltGzqZNmPz8iBw9uuD8u5vfJSM/gybhTbij4R0ehXVgYzy7VsWCCa55sBl+gTaP+hERERERERERqUiUvJQry7bPIScFKtWGRtdhGAbvr3DvMTmkax0Cfa3nvM1wOIh/8y0Awh94AFuVKgDsStrFgn3u4j3PdHoGi9lS7JAyknOJmb8HgPb961CjcVix+xARERERERERqYiUvJQrh2HA2mnu407DwWzh90NJbD2Rhp/NzJBudc97a+rXX5N/8CCWSpWIGPbIH90ZvLr2VQwMrq93Pe2rtC92SC6XwS+zd5GX7SCqbggdb67nyZOJiIiIiIiIiFRISl7KlePIbxC/E2wB0PY+AN5f4d7r8q4OtYgI8j3nba6cHBLfnQpA5KiRWIKDAfj+8PdsSdiCv9WfJ9s/6VFImxYf5dT+VGy+FvoNbYbFoo+kiIiIiIiIiMgZypTIlWPt++6vre8G/zB2nExj5b4ELGYTw3pEn/e25Dkf4YiPx1ajBpXuuQeALHsWb254E4BhLYdRNbBqscOJO5zGum8PA9DznkaEVg4odh8iIiIiIiIiIhWZkpdyZUg5Cnt/cB93GgHAtD8qjN/Yshq1ws+dOHSkpJA0cyYAlcc8gdnHB4AZ22aQkJNAzaCaPND8gWKHk5/j4OdZOzFcBg07VqFx5+InP0VEREREREREKjolL+XKsH4mGC6I7g1RTTiWlM33204BMKLX+WddJr3/Pq7MTHybNSXkxhsBOJp+lI92fQTAUx2fwtdy7uXmF7Lys32kJ+YSHO5Hr8GNMZlMxX8mEREREREREZEKTslLqfjys2DTHPdx55EAzPj1EC4DejWqTPPqoee+7cQJkj/+BICoceMwmd0fl0nrJ2F32elevTu9a/Uudjj71sWxd00cJhNc+3AzfP3PXeFcRERERERERORKp+SlVHzbPofcNAirCw37kZiZx+cbjgMwslf9896WMOVtsNsJ7NaNoO7dAVh5YiUrTqzAarLyVKenij1jMj0xhxUf7wWgw431qNagkkePJCIiIiIiIiJyJVDyUio2w4C109zHnUaA2cKc1UfIc7hoXasSXaLDz3lb7q5dpH/3HQCVx7kriduddiatnwTAvU3vJTr0/MvNz8XldPHzBzvJz3VSrX4oHa6v4+FDiYiIiIiIiIhcGZS8lIrt8ApI2A22QGh7L5l5DuasPgLAqF7R5505Gf/GZABCbroJ/+bNAZi/ez5H0o8Q4RfByNYjix3Khh+OEHcoHR8/C9c81AyzRR8/EREREREREZELUfZEKrYzsy7bDAa/UD5dd4z0XAfRkYFc2+zcFb4zV60ia/VqTDYblcc8AUBCdgLvbX0PgDHtxxDkE1SsME4dSGXDD0cA6H1vE0Ii/T17HhERERERERGRK4iSl1JxJR+GvT+6jzsNJ9/hYuavhwF3hXGL+exZl4bLRfxk96zLsMH34FOzJgBTNk0h25FNy8iW3FL/lmKFkZdt5+cPdmIY0KRLVRp2rFKChxIRERERERERuXIoeSkV1/qZgAH1r4bKjfhmy0ni0nOpEuLLgLY1znlL+vc/kLdrN+agICJGupeGb03YyqKDiwB4ptMzmE1F/9gYhkHMx3vJTM4jpLI/Pe5uVOLHEhERERERERG5Uih5KRVTXiZsmus+7jwSl8tg2spDADzcvR6+VstZt7jy80mYMgWAiEcewRoWhstw8eraVwG4tf6ttKrcqlhh7F0Tx4EN8ZjNJvo93BwfP6vnzyQiIiIiIiIicoVR8lIqpm2fQl4ahEdDg2tYuieeA/GZBPtZGdy59jlvSf3kE+wnT2KNiiJ8yAMAfHPgG3Ym7STQFsiY9mOKFUJqfDYrPt0HQKdb6lGlXkiJHklERERERERE5Eqj5KVUPIbxZ6GeTiMwTCbeizkAwH1d6hDsZzvrFmdGBonvvQ9A5GOjMfv7k56fzpRNUwAY1XoUkf6RRQ7B6XTx86ydOPKcVG9Yibb96pTsmURERERERERErkBKXkrFc2g5JO4Dn2BoM5j1R1LYdCwVH6uZh7rXPectSTNn4UxNxSc6mkq33QbA+1vfJzk3mbohdRncZHCxQlj37WHij2bgG2DlmoeaYT5HcSAREREREREREbkwJS+l4lnjnkFJ23vBL4T3VxwEYGD7mkQF+511uf30aZLnzAEgatyTmKxWDqYe5JPdnwDwdKensVnOnq15Pif2prBp8VEA+tzXhODws8cUEREREREREZGLU/JSKpakg7B/sfu403D2xmWwbE88ZhMM7xF9zlsSp07FyM3Fv107gvr2xTAM/r3u3zgMB71r9eaqGlcVefjcTDu/zN4FBjS7qjr120V546lERERERERERK5ISl5KxbJuhvtrw34QUZ9pf8y6vL5FNepGBp51ed6BA6Qu+AqAqPHjMZlMLDu+jDWxa7CZbTzV4akiD20YBsvn7yErNY9KVQK46s6GJX8eEREREREREZErmJKXUnHkZcDmee7jziM4kZLNN1tPATCyV/1z3hL/1hRwuQi65moC2rUlz5nHpPWTAHiw+YPUCqlV5OF3/XaKQ5sTMFtM9BvaHJuvpUSPIyIiIiIiIiJypVPyUiqOLZ9AfgZENITovsz89TBOl0H3BhG0rBl61uXZmzaRuXQpWCxEPfkkAHN2zuFk5kmiAqJ4pOUjRR46JS6L3z7fD0CXAfWpXDvYO88kIiIiIiIiInIFU/JSKgaXC9ZNcx93HkFKjoPP1h8Hzj3r0jAM4l93z7CsdMcd+EZHE5cVx8ztMwEY134cAbaAIg3ttLtYMmsnDruLWk3DaHN10WdrioiIiIiIiIjI+Sl5KRXDwWWQdAB8Q6D13cz5/Qg5dictaoRwVYPIsy7P+OUXcrZsweTvT+ToRwF4c8Ob5DhyaBfVjuvrXV/kodd8c5DE45n4Bdm4+sFmmMwmrz2WiIiIiIiIiMiVTMlLqRjWvu/+2vY+sk3+zFl9BHDPujSZCicTDYeDhDffAiB8yAPYoqLYELeBH4/8iAkTz3R65qx7zufYriS2/OKe4dn3gaYEhvp653lERERERERERETJS6kAEg/AgZ8BE3Qaxufrj5OSbadORADXt6h21uWpC74i//BhLGFhRDzyCA6Xg1fXvQrAwEYDaRrRtEjD5mTks/TD3QC07FWDeq3OnuEpIiIiIiIiIiKeU/JSyr8ze102ug57aF1m/HoYgGE9orH8zxJuV3Y2CVPfBSBy1CgsQUEs2LeAfSn7CPYJ5rG2jxVpSMMwWPbRbrLT8wmvHki3Oxp473lERERERERERARQ8lLKu9w02PKx+7jzCL7bdoqTqTlEBvkwsH3Nsy5PnjMHZ0Iitpo1Cbt7EKm5qby7xZ3MHN1mNGF+YUUadseKkxzZnoTFaubah5tj9bF47ZFERERERERERMRNyUsp37Z8DPmZENkYo14vpq04BMBD3evhZyucUHQkJ5M0cxYAlceMweTjw9QtU0nLS6NBpQbc1fiuIg2ZdDKTVV8e4P/Zu+/oqKq9jePfSSa9EZLQe5ciXZEqvQsoRQVFLIiiglixXPTavYoKitKlVxFBmoAgRUB6771DSM8kkzLn/SPvjAyZNAgk0eez1izMObuePZOYX3YBaPxQRUJL+edih0RERERERERExE7BSym4bDbY8v9Lxu99lrVHwjl0KRZ/LzP9GpVNlzz8+x+wxcfjXaMGgZ06cjjiMPOOzANg+D3DMbuZs6wyJSmV3ybuJzXFRtmaIdS6P/3sThERERERERERyR0KXkrBdWwlRJ4EryCo/TDf/3EcgEfvLUOQj4dT0qSzZ4mcPRuAIq++AiYTn/z1CTbDRruy7bin+D3ZqvLPn48TcSEen0BPWj1+V7ZPJRcRERERERERkZxT8FIKri0/pP1b7zG2X0zir5MReLibeLJJ+XRJr371NSQn49e0KX733ceKUyvYfnk73u7evNLglWxVd2pvOHvXnAOgdf+78A30zK2eiIiIiIiIiIiICwpeSsF09TAc/x0wwT3P8MP/z7rsUbckxYK8nZIm7N1HzNKlYDJR5JVhWJItfLHtCwCerPUkJfxLZFldfLSV36ceBKB269KUrRGSu/0REREREREREZF0FLyUgumvcWn/Vu3EseQQVh64jMkEA5tXdEpmGAZXvvwSgMCuXfC+6y4m7ZvEZctlSviVYECNAVlWZdgMVk85SEJsMiGl/Lmve8Us84iIiIiIiIiIyK1T8FIKnoQo2DUr7b8bDXKcMN72rqJUKuJ88nf8ho1YNm/G5OFB2EtDOBd7jsn7JgPwWsPX8DY7z9J0ZffvZzl7IAKzhxvtnqyBu4c+NiIiIiIiIiIid4KiMFLw7JwOyfFQpDoXgxuwcNd5AAbdf8OsS5vNMesyuG9fPEuV5IttX5BkS+Le4vfSukzrLKu6ejaWTQvTlqQ36VWZwiX8crkzIiIiIiIiIiKSEQUvpWCxpf69ZPzeZ5m08RTJqQb3li9MvTLBTkljFi/GeugQbgEBhDw7kD8v/MnqM6txN7nzZsM3szwpPDkplZUT92NLMShfO5QazbLeG1NERERERERERHKPgpdSsBxZAVGnwbsQ0ZV6MHPLGSD9rEub1cqVb74BIOSZZzCC/Pnsr88AeLjaw1QKrpRlVRvnHSXykgW/IE9aPlYty2CniIiIiIiIiIjkLgUvpWDZ8kPav/X7M237FeKTUqlWLID7q4Q5JYucOYuUCxcxFy1K4ccfY/ah2ZyIPkGwVzDP1X4uy2pO7LzK/vUXwAStB1THx9/zdvRGREREREREREQyoeClFBxXDsLJP8DkRmLdJ5m88RQAg1pUdJoVmchZbeMAAL0eSURBVBoTw7Uf0oKcYS+9SKQRz5hdYwB4qd5LBHkFZVpNXKSV36cfBKBu2zKUrlb4NnRGRERERERERESyouClFBxbxqb9W60z846ZuBafRKlgH7rcXdwp2bXx40mNjsazUkWCunVj1M5RxCXHcVfhu+hRqUemVdhsBqt+3I81PoWwMgHc+0CF29UbERERERERERHJgoKXUjAkRMLu2QCkNHyW8etOAPBMswqY3f9+GydfukTE1GkAFBn2CvujDvHz0Z8BGH7vcNzd3DOtZtfKM5w/HIXZy512T9XA3ayPiIiIiIiIiIhIXlFkRgqGHdMgJQGK1mJZTAXORFgo7OdJ7walnZJdHT0aw2rFp0F9fO9vzid/fYKBQZcKXahbpG6mVVw5HcOWX9KCos37VKZQUd/b1h0REREREREREcmagpeS/6WmwF/jATDuHcj3f6QFGPvfVw4fz79nUlqPHiX654UAFH31VZacXMKeq3vwMfvwcv2XM60iKTGF3ybsx2YzqFivCNXuK55pehERERERERERuf0UvJT878gyiD4DPoXZ6N2SAxdj8PFw5/H7yjolu/LlSLDZCGjbFluNyny1/SsAnr37WYr4Fsm0ivVzjxJ9NQH/YC/u71vV6QAgERERERERERHJGwpeSv5nP6in/hOM2XgegIfvKU2wn6cjiWXrVuLWrgV3d8Jefpmxe8YSnhBOmYAyPFb9sUyLP7rtMof+vIjJBG2frIG3n8ft6omIiIiIiIiIiOSAgpeSv13aB6fWg8mdg6V68efxa5jdTDzd7O9TwA3D4MoXXwJQqFdPLoaYmHYg7dCeN+55A093T5dFA8RcS2DtjMMA1O9YjhKVC92+voiIiIiIiIiISI4oeCn521//P+vyrq6M3p4AwAN1SlCykI8jSexvK0nYvRuTjw9hgwfz+dbPSbGl0KxkM5qXap5h0TabwarJB0hKSKFo+UAadC53O3siIiIiIiIiIiI5pOCl5F+WCNgzF4AL1fqzbN8lAAa1qOhIYiQnc3XkSABCBjzBn9aDrD+/HrObmdcbvp5p8duXneLisWg8vN1p+2QN3N31cRARERERERERyU8UrZH8a8cUSEmEYncz+mgIhgGtqxWhStEAR5Kon34i6fRp3AsXJuCJx/jsr88AeOyuxygXVC7Doi+diGbrklMAtHikKkFhPhmmFRERERERERGRvKHgpeRPqSnw1wQAYmo/xU87LgAw6P6/Z13a4uO5+u13AIQ+/zwzTi/gTOwZQn1CGXj3wAyLtiak8NvE/Rg2gyr3FKXqvcVuY0dERERERERERORmKXgp+dPhJRBzDnxDGRtRl6RUG/XLBtOwXGFHkms//khqeDgeZcqQ3PV+xu5J2x/z5fov4+/pn2HR62YdJvZaIoGh3jR/pOpt74qIiIiIiIiIiNwcBS8lf9r8AwDWOv2Z+lfaXpfPXbfXZcq1a0RMnARAkaFD+HrPtySkJHB32N10qdAlw2IPb7nEkb8uY3Iz0fbJGnj5mG9jJ0RERERERERE5FYoeCn5z8XdcOZPcDMzl7bEWlOoXMSfVtWKOJKEj/kem8WCd82aHK9XlF9P/IoJE8PvGY6byfXbOvpqAn/MOgxAw87lKFYh6I50R0REREREREREbo6mnUn+s2UcAKnVHmDU1ngAnm1RETc3EwBJp08TOWcOAKGvDOONrWmH9PSo3IOaoTVdFpmaamPlpP0kJ6ZSvFIQ9TuWu82dEBERERERERGRW6WZl5K/xIfD3nkArA7qwdVYK8WDvHmgdglHkitffw0pKfg1b8aKkPMcjDiIv4c/L9V9KcNity05xeWTMXj6mGn7ZA1HIFRERERERERERPIvBS8lf9n+I6RaMUrU5ZM9AQA81bQ8nua0t2rC3r3ELlsOJhO+Lw5k1I5RADxf53lCfEJcFnnhaCTbl50C4P6+VQko7H3buyEiIiIiIiIiIrdOwUvJP1KTYetEAPaUeJiT1ywE+XjwyD1lADAMgyv/+wKAoAceYGLCaiKtkVQIqsDD1R52WWRifDIrJx3AMKBa4+JUblD0zvRFRERERERERERumYKXkn8cXAyxFzD8wvjvyaoA9L+vLH5eaVuzxq9fj+WvvzB5ehL/xAPMOjQLgDfueQMPN490xRmGwdoZh4mLtBJUxIdmvSvfub6IiIiIiIiIiMgtU/BS8o8tYwE4V/Fhtp+34O3hRv/G5QAwUlO58sWXAAT368tnZyeRaqTSukxrGpdo7LK4Q5sucnzHFdzcTLR7qgae3jqfSkRERERERESkIFHwUvKHCzvh7GZw8+Cz8LRgZO8GpQnx9wIgetFirEeO4BYYyL6OVdlycQuebp682uBVl8VFXbawbs5RAO7tVoEiZQPvTD9ERERERERERCTXKHgp+cP/z7qMqtCFX08YuLuZeKZZBQBsVitXR6UdzBP09AA+PzwGgCdqPkGpgFLpikpNsfHbxP2kWFMpWTWYum3L3KFOiIiIiIiIiIhIblLwUvJe3BXY9xMAE5LaAdC5VnFKF/YFIHL6DFIuXsRcrBi/1E3mQvwFivoW5amaT7ksbsuiE1w9E4uXn5k2T1TH5Ga6M/0QEREREREREZFcpeCl5L3tP0JqEtai9RhzNAiAQS0qApAaHU34uHEAeDz7GOMPTwHg1Qav4uvhm66os4ci2LnyDACtHrsL/2CvO9ABERERERERERG5HRS8lLyVkgRbJwKwyLsrNgNaVAmjeom0PSrDx43DFh2NV+XKfFt0H9ZUK/WL1qd9ufbpikqIS2L15ANgQI1mJahQJ+yOdkVERERERERERHKXgpeStw4ugrhL2PyK8P7xysDfsy6TL14kctp0ACIHdGHF2ZW4mdwYfs9wTCbnpeCGYbBm2iHio5MILuZLk16V72w/REREREREREQk1yl4KXlryw8AbAruTlyKG7VLF6JRhcIAXB01GiMpCZ+GDfjQbSkAvar0omrhqumK2b/+Aid3h+NmNtH2qRp4eLrfuT6IiIiIiIiIiMhtoeCl5J1z2+HcVgx3T94+1wCA51pUwGQykXj4CNELFwKwq+fdHIs+TpBXEC/UeSFdMREX4tk47ygA93WvSFjpgDvWBRERERERERERuX0UvJS889dYAI6GteNUoj8VQv1oW70YAFdGfgmGgVeblnxu+RmAF+u8SCHvQk5FpCSn8tuk/aQk2yhTvTC1W5W+o10QEREREREREZHbR8FLyRuxl2DfAgA+Cm8BwLMtKuDuZiJ+y1/E/7EOzGZ+ae1HbFIsVYOr0rNKz3TFbP75BNfOxeET4EGr/ndhcjOlSyMiIiIiIiIiIgWTgpeSN7ZNBlsy4cF1+COuJEUDvehetySGYXDlyy/T0jzQhskxKwB48543cXdz3sfy9P5r7P79LACtHr8LvyCvO9oFERERERERERG5vRS8lDsvxQrbJgHwQ2JbAJ5sUh4vszuxK1aQuGcPJl8fRtW5jIFBx3IdaVCsgVMRlpgkVv94AIBaLUtRrlbone2DiIiIiIiIiIjcdgpeyp23fyHEXyHRuwg/RtYiwNvMo/eWwUhO5spXXwEQ0b0ZGxL24u3uzbAGw5yyG4bB71MPkhCbTOESfjR+sGIedEJERERERERERG43BS/lzjIM2PI9AD+5dyAFM/0alSXA24PIefNIPn0Gt8KF+bDCHgCervU0xfyKORWxd+05Tu+7hrvZjXZP1cDs4Z6uGhERERERERERKfgUvJQ769w2uLATm5snX15rjKfZjQFNypEaF0/4d2MA2N+tBmdTwynpX5Inaj7hlD38XBx//nQcgCY9KxFS0v9O90BERERERERERO4QBS/lztryAwB/+rYkgkB61i9FkQBvIiZPJvXaNUylS/BJ0a0AvNbwNbzc/z6EJyUpld8m7ic1xUa5WiHUbFEyT7ogIiIiIiIiIiJ3hoKXcufEXIQDCwH45FoL3EwwsFkFUq5e5drkyQAsbx9CoimF+4rfR6vSrZyy//nTMSIvxuMb6Emrx+/CZDLd6R6IiIiIiIiIiMgdpOCl3DnbJoEtheM+d7PfKEfHmsUpF+pH+PffY1gsJFcrz8TQA5hNZt68502n4OTJPeHs/eM8AG2eqI5PgGde9UJERERERERERO4QBS/lzkhOTAteAiNj0mZUDmpRkaRTp4icOw+Aic2SwGTikbseoUKhCo6s8VFWfp9yEIA6bUpTunrhO9x4ERERERERERHJCwpeyp2xfwFYwon2KMLy1Po0qRRCrVJBXPnqa0hJIap+RX4PvUxh78I8V/s5RzbDZrDqxwMkxicTWtqfRt0q5l0fRERERERERETkjlLwUm4/w4DN3wMwwdqaVNwZ1KIiCbt3E7tiBZhMfNngMgBD6w0lwDPAkXXX6rOcOxSJ2cONdk/VwN1Db1kRERERERERkX8LRYLk9ju7BS7tIcXNi+lJLahZMpAmFUO48r8vADjeuAyHCydSI6QG3Sp1c2S7eiaWzQuPA9C0d2WCi/nlSfNFRERERERERCRvKHgpt9+WHwBYbGtCJIEMalGR+HXrsGzbhuHpwRd1zgEw/N7huJnS3pLJ1lR+m7gfW6pBhbphVG9aIs+aLyIiIiIiIiIiecOc1w2Qf7jo83BgEQDjrG0pG+JLh7uKcObBQQBsahLMtcAIHqj4ALXDajuybZh3lKjLFvwKedGyXzWnk8dFREREREREROTfQTMv5fbaNhGMVHaYanDQKMszzSoQt2gR1qNHSfX3YXzta/iafRlab6gjy/EdVziw4QKYoO2A6nj7eeRd+0VEREREREREJM8oeCm3T3ICbJsMwFhrW0L9PXmwRihXR48GYGFjd+J9TAyqPYgw3zAAYiMSWTP9EAD12pelZNXgvGm7iIiIiIiIiIjkOQUv5fbZOx8SIrhsKsIqW30GNClPwpxZpFy6hCXEjwW1EygXWI5+d/UDwGYzWDX5AFZLCkXKBnBP1/J53AEREREREREREclLCl7K7WEYsGUsABOTWuPj5cWjdxUifNx4AKY0TiLZbOL1hq/j4Z62LHznb6e5cDQKDy932j5VA3d3vT1FRERERERERP7NFB2S2+P0n3B5L1a8mJPakkfvLUPSlEnYYmK4WsKPtdVttCjVgmalmgFw6WQ0WxadBKD5w1UoVMQ3L1svIiIiIiIiIiL5gIKXcnts+QGAn1KaYHEPoH8FLyKnTwdgfNMEzGZPXm/4OgBJiSmsnLgfw2ZQuUERqjYqlmfNFhERERERERGR/EPBS8l9UWfh0K8A/Jjanh51S2KaPA4jOZmjFbzZVcHE49Ufp0xgGQDWzz5CTHgiAYW9afFoVUwmU162XkRERERERERE8gkFLyX3bZ0Aho2NqTU4SmmeKZFK9KJFAExqlkwR36IMvHsgAEe2XuLQ5kuYTNDmyep4+XrkZctFRERERERERCQfUfBScleSBXZMAdJmXbarXhSvyT+AYbClupnjJUy83OBlfD18iQlP4I8ZhwFo0KkcJSoVysOGi4iIiIiIiIhIfmPO6wbIP8zeeZAQyVmjCKtt9fg5MJL49euxuZmY3sygTlhdOpfvjC3VxqrJB0hKTKVYhSAadCqX1y0XEREREREREZF8RjMvJfcYBmwZC8CPKW25p1xhAqeNA2BFXbhS2I3h9w7HZDKxbdlpLh6PxtPbnbZPVsfNXW9FERERERERERFxppmXkntOrYcr+7EYXsxLvZ+x5rMk7tuH1cuNn5qYeKjKQ1QPqc7FY1FsW3ISgBZ9qxIY6pPHDRcRERERKXiSk5NJTU3N62a4lJycjNlsJjExMd+2UTKm8Sv4NIYFX0EbQ3d3dzw8bs85JgpeSu75/1mXP6U2o3RYKGFzPiUZWHgPGIUCebHui1gtyaycdADDgKqNilGlYbG8bbOIiIiISAETExNDeHg4Vqs1r5uSIcMwKFasGGfPnsVkMuV1cySHNH4Fn8aw4CuIY+jl5UVoaCiBgYG5Wq6Cl5I7Ik9hHF6KCZiS2o53kg+SfPYs0X4mfr3HxMt1BxPsFczKifuJjUgkMNSb5g9XyetWi4iIiIgUKDExMZw/fx5/f39CQ0Px8PDIl7/U2mw24uLi8Pf3x81NW0QVNBq/gk9jWPAVpDE0DIPk5GSio6M5f/48QK4GMBW8lNyxdQImw8a61FrgW4oSiz4mFZjb1ETpIpXpXbU3h7dc4ui2K5jcTLR9qgae3nr7iYiIiIjkRHh4OP7+/pQqVSpfBi3tbDYbSUlJeHt75/tfuiU9jV/BpzEs+AraGPr4+BAQEMC5c+cIDw/P1eBl/u+95H9J8Rg7pgLwY2p73ozZTmpEBBcKw++1TbxxzxvEhyezbtYRAO7pWp5i5YPyssUiIiIiIgVOcnIyVquVoKCgfB24FBGRfyeTyURQUBBWq5Xk5ORcK1fBS7l1e+ZgSozmlK0op42qlFq5EIBZLdxoVaEdDYvcw8pJB0i2plKiciHqtS+bt+0VERERESmA7Ac23K4DEURERG6V/WdUbh4ypHW7cmsMA2PLWEzA1NR2vHF1E0ZiAkdKwK7q3vzS4BW2Lj7JlVMxePmaaTOgOm5u+iuxiIiIiMjN0qxLERHJr27HzyjNvJRbc/IPTFcPEWd4szW+FqU3rQRgeit3nqz1FJz3ZfuK0wDc37caAYW987K1IiIiIiIiIiJSgGjmpdyaLWMBmJ/anJfObYLUVLZVMhFdrQSPlu/HL5/uBQOqNylOpfpF8rixIiIiIiLyTxAdHe20n5rJZMLPzw9v7/w7WcIwDK5du4anp2euHmSRm6xWKykpKfj4+OR1U3KN/QRkX19ffH19s7xekCQkJBAfH4/ZbKZQoUIZpktMTCQuLg4fHx/8/PxcpklJSSEqKgoPDw+Cgv4+oyI1NZXIyMh013PCarVis9nu6PsqNTUVq9WaK2Nrs9mwWq05an9sbCw+Pj6YzRmH3SwWCxaLJdN6LRZLvv1+cSdp5qXcvIgTGIeXAbDxai1K7duCzQQz73fjlfqvsmn2aeIirRQq6kvT3lXyuLEiIiIiIvJP0a1bN8LCwhyv0NBQfHx8KF68OAMHDuT8+fN53cR0rl27RlhYGL17987rpjiJiYnhzTffpEKFCnh7e+Pv709oaCgdO3Zk1KhRXL58Oa+beEv++OMPwsLC+O9//5ut6wXJk08+SVhYGCVLliQ2NjbDdBMmTCAsLIy33347wzSbN28mLCyMbt26OV3fu3cvYWFhtG/fPkdtW7duHb169SI0NBRvb298fX0JDg6mXr16vP/++xw9ejRH5WXXhg0baN68OZ6envj5+VGmTBk++eSTHO+/mJiYyFdffUW1atUc7S9WrBiPPfaYy7afP3+ekSNH0qRJE4KCgggMDMTb25t77rmH6dOnu6zj448/dvo+duOraNGitG3b9qaewz+NZl7KzftrAiYM1qbczSOndgKwtpaJErXupdS5GqzdeRg3dxNtn6yOh5d7HjdWRERERET+aYKCgjCbzRiGQVRUFJcuXWL8+PEsX76c3bt3ExwcnNdNzNciIyNp0qQJBw8edFzz9/cnMjKSzZs3s3nzZs6dO8cXX3yRh628PTw9PQkJCclwJmJ+Fx0dzS+//AKkzeCbP38+AwYMyONWpc3gfOmll/j+++8d1zw9PfHw8CAqKoqdO3eyc+dONm3axPLly3O17lWrVtGxY0dSUlJwc3PDx8eHs2fP8tZbb3HgwAGmTZuWrXIMw6BLly6sXr0aAHd3d3x8fLh8+TLTp09n4cKFbNiwgdq1azvyfPDBB4wdO9bxta+vLxaLha1bt/LYY4+xY8cORo4c6VSPn58fISEhLttgsVhISEigWbNmOX0M/0j5fuZlUlISx44d4/Tp09hstlsuz2q1cuLECS5cuJALrfsXs8Zh2zEVgPXna1L89CGSzPBTcw9eKD+MDfPS/hLRqFtFipTVFGcREREREcl9y5cvJzw8nGvXrpGUlMTSpUsJDg7m7NmzTJgwIa+bl+99/vnnHDx4kOLFi7Nw4UISExOJjY0lKiqK3377jaFDh1K8ePG8buZt0bx5c8LDw3n33Xfzuik3Ze7cuSQkJNCjRw8ApkyZksctSvP666/z/fff4+HhwZtvvsnhw4exWq3ExcURFRXFrl27eP/996lSJXdXZyYlJfHMM8+QkpLCc889R1RUFBaLhSVLlhAYGMj06dOzHSxduXIlq1evxsfHh3nz5pGYmIjFYuHQoUM0bdqUuLi4dDN2S5UqxbBhw9i4cSNRUVHEx8cTHh7Oyy+/DMBXX33Fnj17nPIMHz6c8PBwl6/77rsPgEcffTQXnk7Bl2+Dl8nJybzzzjsUKVKEypUrU65cOUqVKsUPP/xwU+VdvHiR/v37U7hwYSpWrEjJkiUpWbIkn3/+OSkpKbnc+n+B3bNwS4rleEox7j9yBIAlDU20rfcIR+bFk5Jko1S1YOq0KZ3HDRURERERkX8Dd3d3OnbsyODBgwHYv39/punj4uIy/V0wKSmJ8PBwEhISnK5d/3VmDMMgLi4uW2mvl5CQQGJiYo7aZbVanfYAvV5KSkqGbf79998BGDNmDN26dcPLywuAgIAAGjZsyJdffskrr7ySaXtv5jnebHszKispKSnTNrqSnJxMeHh4uj0Hc3vcDcMgPDycmJiYHLcxM/Zg5YgRI7j77rtZt24dp06dytU6cmrPnj189dVXuLm58fPPP/PJJ584BSmDgoKoXbs2//nPfxg1alSu1r1ixQpOnTrF3XffzbfffktAQAAAnTp14sMPPwRwmhmZmSP/H+Po378/PXv2dOxbWbVqVUaPHg3A4cOHnfK88847fPnllzRu3NixN2hISAgjR46kdevWAKxduzZb9Z86dYo1a9Zw11130aBBg2zl+afLt8HLZ599lo8++ojo6GjKly9P8eLFuXjxIs899xxfffVVjso6evQoDRo0YOrUqVgsFsqWLUvlypW5dOkSb7zxBlFRUbenE/9UNhspm9M+9BtO1CT02gVivWFt82DuPdeV8LNxePt50OaJ6pjcTHncWBERERER+TexB45uXDKekpLCvHnz6NChA4ULFyYgIABvb28aNWrEokWL0pWzYMECwsLC+Oabb/jzzz9p1KiRY++7OnXqOAJ/N4qKimLgwIEEBgYSEBBASEgIb7/9dobBOkjbX+8///kPZcqUwdfXFx8fHypWrMinn36aLjB4fbtWr15NvXr18PHxwcfHh06dOjn2+/zrr79o3ry5o82NGzd2Wh4O4OaWFhIoVapUFk81d57jrbb3+rJWrFhB3bp18fHxcdS/cePGbPcjoz0vb3bcIyMjefrppwkICHAa98uXL2e412lUVBTh4eGZvjdcOX78OBs3bqRq1arUrl2bPn36YBgGU6dOzVE5uc2+VLxfv3507tz5jta9atUqAPr27et4X9v169cPNzc3Vq1ahWEYWZZVtmxZAJd/fLBfs6fJjnr16gFkq26AyZMnYxgGjz/+eLbr+KfLl8HLjRs3MnnyZHx9fVm9erVjmfekSZMwmUy88847XLp0KVtlpaSk0KdPHy5cuEDdunXZv38/p06d4siRI1y8eJE33ngDDw+P29yjf5gTazBHHCU62Ydqh88BsKCJG4+XfJWDv6dt5tzq8Wr4FfLKy1aKiIiIiMg/XHR0NOHh4Vy9epVDhw7x1VdfMWbMGAAeeughp7THjh2jd+/erFixgsjISPz9/UlNTWXLli1069aNGTNmuKxjy5YttGzZki1btjhOM9+9ezedOnVyzNCyS0pKom3btowfP564uDg8PT2JjIzk448/5rnnnnNZfkpKCh07duSDDz7g7NmzmM1m3N3dOXHiBMOHD6d3794ugx5//vknHTp0YOfOnXh7e5OamsqyZcvo3Lkzf/31Fy1atGD9+vV4enoCsGnTJrp27ep0cIl9VtdHH32U7Uk9N/scc6O9dhs2bKBz587s2rULLy8vDMNgy5YttG7dmvXr12erH1nJybhbrVZat27NxIkTiY+Pdxr3QYMGZVjH/fffT1hYWI6CrvD3rMs+ffo4/ZvXwcs1a9YAN7fUOaPl0xm9bpwJaw902wOF1wsODqZcuXLExcVx7ty5LNvSsWNH6taty8yZM/nwww85ePAgZ8+eZdGiRTz55JOYzWZef/31bPdty5YtQNpWBVmx2Wz8+OOPuLu7069fv2zX8U+XL4OXEydOBOCNN96gVatWjusDBgygT58+WCwWZs+ena2yfvrpJ3bu3EmhQoVYtmwZ1atXd9wrUqQIn376qWNKr2RP8qa0v6ZsPlyNwPgYrgTB+eZ1SF4dBkDNFiUpXzssL5soIiIiIvKvYhgGlqSUfPVKSEp1eT27s4+yo0OHDoSFhVGkSBHuuusuhg0bRmBgIBMmTKBp06ZOaT08PHjsscf4888/iYuLIzY2lri4OCZMmIC3tzfDhw932baFCxfy0EMPcfr0aSwWC5cvX6ZDhw5YrdZ025p9++23bNu2jdKlS7Nq1Sri4+OJiYnhm2++YenSpS778N1337F27VqKFCnCokWLiI+PJy4ujunTpxMQEMDPP//sMiC4ePFi+vXrx8WLF7FYLBw4cIAKFSqwe/du2rZtS6dOnRxtPnnyJHfffTfHjx/n559/dpTx7rvvOva7LFasGM2bN+fll19m1qxZhIeHu2zvzT7H3Giv3ZIlS+jQoQMnT54kISGBs2fP8tBDD2G1Wnn22Wdz5T2Wk3EfNWoUO3fupFy5cqxZs4b4+HhiY2MZM2ZMpvssBgcHExISkqMJVYZhOA6esQctK1asSL169Th+/DgbNmy4id7mjtOnTwNQs2bNHOVLTEzM9NRtV68vv/zSqQz7+7VYsWIu67Bfv3btWpbtMZvNrFmzhiFDhvDf//6X6tWrU6ZMGbp160ZoaChr1qyhRYsW2erbrFmzWLduHd26daNu3bpZpl+1ahVnzpyhbdu2lChRIlt1/Bvky9PG7fsA2D+I1+vTpw+zZ89mzZo1DB06NMuyZs2aBcDAgQMpWrRobjbz3+nacTyOryQ50Y2wI5EAzGnmRscLzxIZnURwcT+aPFQpjxspIiIiIvLvkpCcSvX/rMjrZmTLgf+2x9czd34VtZ82npSURGxsLAD33Xcfffv2TZe2YsWKjplphmEQGxuL1WqlW7durF27lunTp3PkyBGqVq3qlK9OnTpMmzYNd3d3IG0SzOjRo6lcuTLbt293SmsPMk6ZMoWWLVsCaad3v/TSS5w9e9blqd32QNS4cePo2rWr43rfvn2JjY3lueeeY8qUKelmYdWrV4+JEyc6lsjag7cvvPACYWFhzJo1yzGLsVy5crz77rv06tWLvXv30rNnT0dfdu7cyWeffcbs2bNZv369Y+ai2WymX79+fPPNNwQG/n0I680+x9xor12pUqWYN28ePj4+jq9nzZpF9erVOXjwINu3b7/lvQJzMu4zZ84E0sbSHjQ3m80899xznDlzhk8//dRlHfaZijlh39uyVq1aTpOz+vTpw44dO5g6dWq6wP2dkJqa6tirNacnuJtMpgxP3c6Ir6+v09dWqxXA8R66kX0/18z2k73epk2b+OWXX0hOTsbNzQ0vLy8SEhLYuXMnc+bM4d57780y6Lx582aeeuopypQpw/jx47NV76RJkwB44oknspX+3yLfzby0Wq2cOnUKb29vl6dP3X333UD6zVEzsnXrVgC6dOkCQEREBAcPHtQ+lzcpZXPaX5h27S+PT1ISp4pA8aqDiDycgrvZjXZP1cDs6Z7HrRQRERERkX8D+2njMTExHDt2jNatW7N48WKGDBniMv1vv/1GmzZtCAgIIDAw0DGLa/r06QBcuHAhXZ527do5Alh2FStWxGw2ExkZ6XR97969hISEOAKX1+vVq5fLNu3Zswdvb28eeOCBdPceeeQRIG258o3atGmTbm+/ihUrAtCiRYt0QZxKldImmdj3mLQrWrQoI0eO5MKFCxw/fpx58+bx/PPP4+Pjw48//ki3bt3S1X0zzzG32gvQuXNnR+DSzsPDw/EMbzzV+WbkZNz37dtHaGioy6DhjdsX3Kobl4zb2ffUnDt3broAncmU9VkU9tmq2Unriru7uyOgGB0dnaO8Xl5eOV42PmzYMKcy7O+HjIKT9mXmNwY9XdmxYwddunQhMjKS+fPnk5CQgMVi4fDhw9x///18++23GX6Psdu6dSsdO3YkKCiIlStXEhaW9erUyMhIFi5cSKFChVx+7v7N8t3My6ioKAzDIDQ01OWHpkiRIgDpvlm4YhiGY2/MMmXK0Lt3b+bPn49hGJhMJpo1a8bXX3+d6dRdq9XqiOADjhPCkpOTc7ypbkFh71e6/lljMXbMICnOHe/jad8QFrcoR63dNbFhcG+3cgQV9frHPpeCIsPxkwJDY1jwaQwLPo1hwabxK/g0hq4lJydjGAY2mw2bzeZ0z8vdxL732uZRy9IzDIO42Dj8A/zT/V7n5W5K1/6bdf2zKF++PHPnzuWuu+5i/PjxDB482Gn56vz583n44YcdQRr7oTEmkwmLxUJCQgIJCQmO8uz/FipUyGV73d3dnepPTEwkOTmZYsWKuUxvXwloH0P4+9Tt4sWLYxhGuuXOAQEB+Pr6Ehsbm6122YODmd1LTk7O8PmXK1eOcuXK0aNHDwYNGsT999/P2rVrWb9+PU2aNMn155jT9tr/LVq0aKbPOCYmJl2e6597dq7nZNxTUlIybJM9aHVjPTfDYrEwf/58AFq2bMmVK1cc93x9falduza7d+9mwYIFjuCmYRiOWYfXv49uZI91+Pj4uHweN/63K1WqVGHXrl2OrRNyIqNtCjLi5+fnFMC2x4rOnDnjctm6fa/LsLCwLPvx9ddfk5qaykcffUSPHj2AtL5XqlSJuXPnUqpUKcaNG8enn36Kv79/uvybN2+mU6dOeHp6snLlSipVqpStsZ8+fTpWq5UnnngCT09Px2csN947d5LNZsMwDJKTk9P9AeB6OfkZn++Cl0lJSQAZTr+1X78+oJgRq9WKzWbDy8uLJ554grVr11K0aFH8/Pw4c+YM69ato1mzZmzatIlatWq5LOOTTz7h/fffT3f9t99+y1bEviBbuXKl09flrvxG7dR49u8tgdlmsLu8B5Usz2JLMfAOS+F0/G7OLE3/F0HJGzeOnxQ8GsOCT2NY8GkMCzaNX8GnMXRmNpspVqwYcXFxjt+b8jMfT3dSrQnprsdmb9VmpuwncNv3lLRzc3Nj8ODBjBgxgo8++oixY8c67n388ccYhsGHH37II488QuHChR33Xn/9dcaPH4/FYnGUZ5+plZiY6FTH9VJTU53ueXt7c+bMGZfp7QeK3JjHx8eHCxcuEBERgdns/Ct6eHg4FouF4sWLZ6tdFosFSPu9+sZ79lOSk5OTM+zP9UqXLs0999zD8uXL2bFjh+N35tx8jjltr72s48ePu+zDsWPHgLRxsN+312G1Wp3yZHT9Zsf97NmzLtMfOnTIZZ6bMWfOHMf2CPZgsiuTJk2iU6dOQFrAMjg4GEibIZpRG3bu3AmkBQGvTxMfH5/t9jdr1oxdu3Yxbtw4Wrdunc1epT3r4sWLZzs9wNtvv82rr77q+Lpy5cosW7aM9evXp5sBe/HiRc6dO0fhwoXx8fHJsh/2A5nKlSvnMm3p0qXZv38/+/fv56677nK6t3HjRh555BG8vLxYuHAhpUqVyva4T5gwAYCePXs65bGPeUGRlJREQkIC69atc3yvdsX+GcyOfBe8tAcEM+qE/Xp29lDw9vbGzc0Nq9XKnj17nN7EFy5coG/fvqxdu5a3336bRYsWuSxj+PDhTtORY2JiKF26NO3atXPa9+OfJDk5mZUrV9K2bdu/g8iGDes375IYaYa0PXg5VPdRwiIC8Qnw4KGh9+Ib6HpvCbmzXI6fFCgaw4JPY1jwaQwLNo1fwacxdC0xMZGzZ8/i7+/vOP04v7LvhRgQEHDTy1AzYw/y+fn5pfu97MUXX+R///sfP//8M1988QUlS5YE0mZeFSlShOHDhzulj4+P5/fffwfSfh+1l2ef1eXt7Z3h737u7u5O9xo0aMCGDRtYsWJFumXi9n0RXeVZv3498+fPZ+DAgU55Ro0aBUDDhg2z1S7779Oenp7p7tlniHl4eDju2Wy2dEu5IW38rl696tiurUiRIo48ufkcc9pee1lLlizh66+/dgqcxsXF8csvvwBpQTR7HnsdXl5eTnVkdP1mxr1+/fps3LiR33//ne7duzulnTt3rss8N2PevHlA2rOxz6a80bVr11i7di1xcXH4+/sTEBDA/fffj6enJ9u2bePcuXNOe2VC2h8D7O1s2bKlUzvtsZfstH/o0KH88MMP/Pbbb8yYMYPnnnsuw7TXv/e8vLxyvOdlcHCwU3u6devGqFGjmDNnDv/5z3+cZmXaD/fp2LFjtsbAPlt2165dtG/f3unepUuXOH78OJC2wvf68latWkXv3r3x9fVl1apVGU6Sc2XXrl3s2bOHatWqOQ6uvt3fR2+XxMREfHx8aN68eaY/q3ISzM93wcvg4GB8fHy4cuUKiYmJ6Tp65swZgGyfulSiRAnOnTvHW2+95RR9L1GiBJMmTaJChQqZbpLr5eXl8puCh4fHP/5/pK7vo3HkNzziT3NgTxHcgHW1axAWcQ8ArZ+oTlBIzjbkldvv3/Ae/afTGBZ8GsOCT2NYsGn8Cj6NobPU1FRMJhNubm4uA075iX2Jo729t4urZxEcHEz//v357rvv+O677xyHpVSqVIktW7bw7rvv8vjjj+Pt7c3evXv573//6whGXF+e/d+s+nD9vaeffpoNGzYwcOBAIiIiaNOmDXFxcUyaNMmxH+SN5T377LOsX7+el19+mdjYWLp06UJqairz5s3j448/BmDQoEHZaldO77Vv357g4GC6dOlC5cqVKVWqFFarlb179/LZZ59x8uRJfHx8aN26tSNPbj7HnN6z/xsVFUWbNm347LPPqFatGseOHWP48OFcuXKFpk2bUqNGjSzryOn1G11/b8CAAWzcuJGnnnqK8PBwWrVqRVxcHFOmTOHHH3/MsLyoqChSUlIICgrK8nvduXPnWLNmDSaTiW3btqU7EMmuWbNmbNiwgZkzZzJw4EDHYTj9+vVj0qRJdOzYkY8++ohmzZrh5eXFoUOH+OSTT9i7dy8lS5akd+/eLp9HSkoKERERLut0d3cnODiYChUq8Omnn/LKK6/wwgsv8PvvvzNgwABq1qyJ2WzmwoULnDp1il9++QWr1epYAu/j45PjZeM3atmyJXXq1GHXrl307NmTjz76iNDQUObPn+/4HjB06NB0Y2CvNzQ01HHtgQce4Ndff+X999/HZDLRtWtX/P392b17N++88w6JiYnUr1/f8YcRSNt/t0ePHpjNZubMmUPJkiXTPS8fH58MJ+JNnjwZgP79+zvaeKe+j+Y2Nzc3TCZTlj/Dc/LzPd8FL93c3KhZsyZbt25l06ZN6TY63rhxI0C2I9i1a9fm3LlzlClTJt290qVL4+bmRnx8fIZ/cZI0UWtH43nJE9NFMxavAKxFBuCeDLVblaZsjZz9hUREREREROR2GjJkCGPGjGHcuHG8++67+Pn58dprr9GzZ08+/vhjR1AQ0mYVPv74444TtG/F448/zsKFC1m4cCHPP/+8070XX3yR0aNHp8vTt29fVqxYwbRp03j99dd5/fXXne6//PLLdOzY8Zbb5orFYmHVqlWOGX03MpvNfP/99479BIE78hyz0r9/f3766Sc6dOjgdD0kJCTbpzrnpgEDBrBgwQKWLl3Ks88+63Rv8ODBfPfddy5Pwb7//vvZvXs3a9as4f7778+0jmnTpmGz2ejcuXOGgUuAYcOGsWHDBqZOneo0k3fkyJHs3buXrVu30r9//3T5ChUqxNy5c9MdhGS3ffv2DA+dKVu2LKdOnXLUD2mrWBcsWMCCBQtc5rEva88tJpOJqVOn0qxZM5YvX87y5cud7o8YMSLdCfQpKSmOPsXGxjpm+z7xxBP89NNPrFixguHDh6ebZRwUFOS0JQXADz/84DgsKKMl80OGDOHrr79Od91qtTJz5kzc3Nx47LHHst/pf5F8Ga3r3LkzQLpBTUpKYsyYMcDfp4dnxX7a2I1vXIAVK1Zgs9koW7asApeZCT9KofPrOL63EAYm/mz4OO7JPoSU9KdRjwp53ToREREREfmXCQoKIiQkJMOZO5UrV6ZXr164ubk5Znc99NBDLFmyhDZt2lCmTBmqVavGwIED2b59O9WqVSMkJMQpwGRfyprRWQehoaGOvQTtTCYT8+bN48svv6Ru3bqUKFGC++67j8mTJ/Pee+8REhJCUFBQurKmTJnCtGnTaNOmDaVLl6ZMmTJ07NiRn376iZEjRzqlzaxdnp6ehISEuJzdZTabCQkJISAgwHHtt99+Y/78+QwYMIDGjRtTpkwZSpUqRcOGDRk0aBA7d+5MF+jKzeeY0/baVatWjc2bN9OrVy/KlStH+fLlefzxx9m6dSvVqlXLVh0ZXb+ZcXdzc+Pnn3/ms88+o06dOpQoUYLGjRszdepU+vXr58h3o+Dg4Ezfx9dbunQpISEh6U7ZvlG3bt2oU6cOly5d4sCBA47rQUFBrF+/njFjxtCmTRvKli1LiRIlqF+/Pq+99hp79+6lcePG6cqzj0Nmr+uX70NaAPPIkSO89dZbNG7cmLJly1K2bFkaNWrEI488wuzZszMMmN+KWrVqsWvXLp5++mmqVKlCqVKlaN26NQsWLOC9995Ll94+KzUkJMRpWbaHhwdLlixh/PjxtG3blrJly1K8eHHq1KnDyy+/zN69e6lfv75TWYGBgVk+J1eH+0Da/s4mk4nu3bs7zeaUv5mMG48zyweuXLlCpUqViI2N5bHHHuPpp58mMTGRL774gpUrV1K1alX27dvntJlxTEwMJ06cwN/fn0qVKjmuWywWqlSpwvnz53nqqafo1asXfn5+bNq0iY8//pioqChGjBjh8o3sSkxMDEFBQURHR/+j97xcunQpnTp1wsPDg2tzh2BaNofLm4I5XrYlp8v3xN3Djd7DG1K4hJaL5zc3jp8UPBrDgk9jWPBpDAs2jV/BpzF0LTExkZMnT1K+fPl8v+elzWYjJiaGwMBATRQpgPLr+M2ePZtHHnmETz75hDfffDOvm+PEMAyX+xI+//zzfP/994waNYoXX3zxjrUnv46hZF9BHcPs/qzKSXwt3y0bh7Tp5lOnTqVPnz5MmzaNadOmOe4VLlyYOXPmpDuFbd26dXTt2pUmTZqwYcMGx3VfX1/mz59Phw4dmDhxIhMnTnTK17lzZ956663b26GCLDEa331zOLQviGS/kpwq3x0T0LRXZQUuRUREREREREhbanz33XfTrFkzSpQowdmzZ5kyZQrjxo3D29ubnj175nUTRQqsfBm8BOjevTs7duxg9OjR7N27F7PZTKNGjRgyZIjLw3qCgoKoXbs2lStXTnevUaNG7Nu3j2+//ZbNmzeTkJBAuXLlePDBB+ndu3eBOrXpTovcOJnY4+54xHuxveEATJgpXzuUGs2yd2CSiIiIiIiIyD/dxYsXXe73aTKZ+PrrrylevHgetErknyHfBi8BatSowQ8//JCttM2aNWPXrl0Z3i9VqpTjhCnJJlsqqevHcm1/AKcrPoTVpzi+QZ60fKyaAr4iIiIiIiJyR2W1H2VemjJlCt988w3r16/nzJkzeHt7U6dOHV544QVatGiR180TKdDydfBS8lbcvmVc3G8h1r8R50s2A6DNgOr4+Kc/JU1ERERERETkdurRowc9evTI62a4VLx4cU2YErlNCs6On3LHXVs6isTjxThYtS8AdduVoXS1wlnkEhERERERERERyR0KXopLnvHnubz9DEcrP0GKhz/BpXy494EKed0sERERERERERH5F1HwUlzy2reYaEsnIoOrglsqnZ6pjbtZbxcREREREREREblztOelpJMUF4llfzJnyj0AQPNHqlGoaP7bEFlERERERERERP7ZNJVO0tn4/TtcCXoKw82doDJWajYtlddNEhERERERERGRfyEFL8VJSlISl/eWIcG3KCZbFD2HtMFkMuV1s0RERERERERE5F9IwUtxMue/nxAT1BgMG3d3K4y3n0deN0lERERERERERP6lFLwUJykx8bilJuGVtIZ72zXJ6+aIiIiIiIiIiMi/mIKX4qT/qM+5p68v/s1K53VTRERERERERETkX06njUs6dze5j3PRkXndDBEREREREZeuXbuGYRiEhoZmmCY6Oprk5GSCg4Nxd3e/g63L36KiokhNTSUkJCSvm5Ipm81GXFwc/v7+uLn9c+ZdZfT8C8q4ZCY8PByAQoUKYTZnHG66lc+v/XpWdWTEMAxiY2MJDAzMcd5bERcXh5+fX66cKRIfH4+fn1+G9w3D4Nq1a1mWExQUhIdH5lsFZlXXnfLP+Q4gIiIiIiIi/wpFixYlLCws0zStW7cmLCyMvXv33qFW3R6RkZFERETkWnlNmzalZMmSuVJWbrcNYPHixbRs2RI/Pz+CgoLw8fGhcuXKPP/886xbty5X68oLGT3/3ByXvLBlyxbCwsIICwtj1KhRmaa9lc9vt27dCAsLY9u2bdlu27Vr13j33XepVasWHh4eBAUF4eXlRbly5Xj00UdZvHgxKSkp2S4vu2JjYxkyZAghISEEBATg7e1Nt27dOHr0aI7L2rJlC507dyYkJAR/f398fX2pX78+M2bMwDAMp7TXrl1zjEVmr1WrVrms69ixY/Tt25dChQrh7+9PUFAQPXr04K+//rqp55AbNPNSREREREREJJ9q2LAh4eHhREVF5Up5wcHBmc54y4ncbttnn33Gm2++6fja29ublJQUjh07xrFjxxg3btxtCTLlB7k5LnlhypQpTv89bNiwPGzN39atW8eDDz7omIloMpkIDAwkNjaW06dPc/r0aWbNmsXBgwepVq1artVrtVpp164dmzdvBsDPzw+LxcKiRYvYsGEDmzdvpnLlytkqa+HChfTq1QubzeZU1o4dO+jXrx+bN29m9OjRjvRubm4ZzuA1DIOIiAi8vb1p3Lhxuvu///47Xbt2xWKxAODr64vFYmHhwoWcPXs2R0Hj3KSZlyIiIiIiIiL/EuvXr+fcuXN53Yx0zp8/zzvvvAPAkCFDOHPmDAkJCSQmJnLy5EnGjh1LixYt8riVt09+HZfssFqtzJkzh6CgIFq2bMmePXvYtWtXXjeLgwcP0qlTJ65du0ajRo1YtmwZFouF6OhorFYrp0+fZs6cOTzwwANZLp/OqVGjRrF582bKli3Ltm3biIuL4+LFi3Tq1ImIiAhefPHFbJf1zjvvYLPZeOSRR7hw4QJxcXHEx8fz5ZdfYjKZ+O677zhz5owjfeHChQkPD3f5+vHHHwHo3r07QUFBTvVcvHiRhx56CIvFQocOHTh06BDx8fFYLBYWL15Mo0aNcuXZ3AwFL0VERERERORfIyIiIt1S59jY2HRLLzMTHx/vmAWVlbi4OJKTk3PUnujoaGJjYwkPD8dms2EYhlMAIi4uzmVZycnJjhlTGYmKinK5H15OnktqamqmbbPZbISHhxMdHZ1hO6xWK+Hh4SQkJABpM+RSUlJo0aIFX3/9NaVLpx0i6+7uTrly5Rg4cCCrV6/OtG/Z6f+N/TQMg/j4+AzTx8XFZfjecFVWRmOTldwYF1csFovTbNW4uDjCw8NJTU29qXa6snjxYiIiIujRowePPfYY4DwTM68MHjyY+Ph4unTpwrp16+jQoQPe3t4AeHh4UKZMGXr37s0vv/xCxYoVc7XusWPHAjBhwgTq168PpC2XnzVrFoUKFWLFihWcOnUqW2UdOXIEd3d3xo8fT/HixQHw8fFh2LBhNG/eHMMwOHLkSLbKmjRpEgBPPPFEunsff/wxUVFRNGjQgEWLFlG1alUg7Vl16dKFb7/9Nlt13A4KXoqIiIiIiMi/RvXq1alevToWi4UXX3yRwMBAAgMDCQ4O5pVXXskw0Hj48GH69etH4cKFHXvO3XvvvcydO9dl2kceeYRChQoREBCAl5cX9evXd5nW3p6YmBgGDRpEUFAQhQoV4rXXXiMsLIyTJ08SExPjtFfdoEGDHPkPHTrEsGHDqFixIj4+Pvj5+VG8eHGGDh3qMpCW0d6K1z+Xl156iTJlylCoUCGXz2Xv3r1Ztq1BgwaULFmS2NhYl8/zhRdeICwsjA0bNgA4DuUpVaqUy/QZyWn/7f2Mjo7mqaeewt/fH39/f8qUKcOMGTMASExM5JVXXiE4OJiAgADCwsIYOXJkhmVFRUUxYMAA/P39CQgIoEiRIrz77rs5WuKenXHJyft11qxZNGzY0PH+a9WqFfv372fQoEGEhYWl23fRHkzOaLwyYw9U9unThx49euDp6cnMmTPzdIn/4cOHWbNmDZ6enowfPz7XZ1Zm5uTJkxw/fpwSJUrQpk0bp3uBgYF0794dIMM9J29UtmxZbDabI9B/Pft7vGzZslmWc+XKFZYsWULJkiVp27at0z3DMBzv/xEjRtzR55UdCl6KiIiIiIjIv0pqaipdu3bl22+/JSEhAQ8PD6Kjoxk5ciSvv/56uvTr16+nQYMGzJgxg8jISDw9PUlJSeGvv/6iT58+JCYmOtJu3LiRhg0bMnv2bKKjox0nDO/YsYM+ffrwv//9z2V7OnXqxNixY4mPjyckJARfX19CQkJwc3PDZDIREhLieAUEBDjyDh06lK+++ooTJ07g6emJ2Wzm0qVLfPPNN7Rr1y5HAST7c/nuu+8yfS5msznTtrm5ufHss88SHx/vCIhcLzY2ltmzZ1OlShVHcKdevXqYTCYWLVrE+vXrs93mm+m/vZ+TJk0iJSUFd3d3zp49y2OPPcbKlSvp1q0bI0eOJC4uDrPZzLVr13jllVf45ZdfXJbVuXNnfvzxR5KSknB3d+fq1at8+OGH9O/fP9v9yExO36/jxo2jX79+HDt2DABPT0/WrFlDs2bNOHv2rMs6Zs2aRVhYmGPmZHZduXKF5cuXExISQps2bShUqBDt2rXjypUrLFu2LOedzSVr1qwBoFWrVhQrVixHeePj4zNcdu3qdePM2IMHDwJQt25dl+XXq1fPKV1W3nzzTQzDoEePHqxZs4bz58+ze/dunn32WbZv306vXr2ytX/m1KlTSU5O5rHHHnP8scDu0KFDREZG4uPjQ/v27YHszWS+UxS8FBERERERKegMA5Li89cr2eL6eg6WZ98u4eHhHD58mCVLlmCxWLBYLEyfPh03NzfGjRvnNMMpMTGRhx9+mLi4ODp16sSePXscebZs2UKvXr0wmUwAJCUl8eijj5KcnMzo0aOJiIggLi4Oq9XKokWLCAsL45133uHChQvp2nP8+HEWLVrkCJyMHDmS8PBwypcvT2BgoFOw5Pvvv3fkrVmzJhMnTuT8+fPEx8eTlJTEjh07aNKkCZs2bWLhwoU5fi6LFy927K3n6rnUrFkzy7Y9/fTTeHp6Mm7cuHT1zJw5k7i4OAYPHux4dpUrV+bll18mNjaW5s2bU6lSJfr168dXX32V6SEhN9P/8PBwzpw5w+rVq4mPjycuLo6XX34ZwzDo2bMnu3fvZtGiRY5x/vDDDwFcBp7Dw8M5dOgQCxYsIC4ujri4OKZOnYq/vz8zZ85kxYoV2X7+GcnJ+zUqKspxWM5rr73GtWvXsFgs7Nq1i/Lly2d4Yru3tzchISEEBgbmqG0zZswgJSWFhx56CLM57Uzo3r17A3m7dNy+JLtmzZo5zvvKK69k67Ru+6tKlSpO+cPDwwEyDJrar7vaJsCVp556igULFnDt2jVatWpFqVKlqFOnDrNnz+aDDz5w+QcCVyZPngy4XjJuD2rXqFGDixcv0rlzZ8dM5tKlS/Puu+9itVqzVc/toNPGRURERERECrpkC3xcIq9b4eAGFMro5lsXwNPvzjUmA1OnTqVVq1aOr/v27cusWbNYsmQJhw4dcsyaWrRoERcuXKBevXr88ssvjgCNu7s799xzj9NS8CVLlnDmzBmGDx9Ov379MAyDyMhIDMOgSZMmvPHGG7z66qssX76cJ5980qk93333HV27ds1xP7744gvHf1utVuLj4yldujSffvopzZo1Y/Xq1fTs2TNHz+X+++8nJiYGs9mc4XPJSlhYGD179mTmzJls377dse8fwPjx4/Hz80s3M/HLL7+kfv36jBkzhs2bN3P8+HFHYOauu+7iu+++o2XLlrnS/ylTpjgOADKbzXz66aeMGzeOmJgYJk2a5DQWb731Fj/88AN79+512devv/6aHj16OL5+7LHHCA8PZ9iwYUybNs0xk+1WZPf9+ssvvxAfH8+DDz7IW2+9RWBgICaTidq1a7NgwQKqVavmNFPY7uGHH+bhhx++qXZB2pJxu27duuHl5cWvv/5KZGQkwcHBOS73Vtn3MfXzy/n3Gn9//wxP63blxrT2IJ+np6fL9F5eXgAux8GV6OhoZs+e7djX0n4CeExMDD/99BNdu3aldu3amZaxefNmDhw4QKNGjRx7WV7v+tPFmzZtytmzZx3tPHfuHB9++CEbNmxg5cqVju+Bd5JmXoqIiIiIiEiBYp+tlxn7gSau0np7e3P//fenu27/pT4yMtJxbfv27QD0798/y1/a//rrLwA++eQTgoODKVy4MIULF3YsqX711VcB0i3ddXNzo3Pnzln2yZXw8HCGDBlC2bJlHbPnwsLCaNasGUC6WZ6ZyclzyY7nn38ewGn25c6dO9m+fTv9+vVLd9oxwKOPPsqGDRuIjIxk3bp1fPrppzRo0ICDBw/Svn17xzO2u5n++/j4OO7beXp6OvbbbNeundM9k8lExYoViYmJSbePpslkchkctV/bs2eP64eTAzkZF3uA1b6v4vXKli3rFES+VfZTxYsWLep0EnxgYCAdO3bEarUye/bsdPlu9fObHfYZpJkdGpWRL774IkfLxg8fPuyU38fHB8g4OGmfKevr65ut9jz00EPMnTuX/v37O2YYx8fHM2bMGPbt20eLFi24cuVKpmVkdlDP9W1et24dgYGBbNmyhYSEBBISEpg/fz4BAQGsXbs227M8c5tmXoqIiIiIiBR0Hr5pMxrzCZvNRkxsLIH/v/+hE4/s/cKeGR8fH2JjY4mLi8Pf399lGnuQyVWAICgoKH27wHFIxfUnicfExADZO0gmKioKSAucZHbgxY0zskJDQx2znHLCYrHQtGlTR/DE3d0df39/zGYzhmEQERGRo6We9udy40nqrp5LdjRp0oTatWsza9YsvvzyS/z9/R2nMA8ePDjTvAEBATRr1oxmzZrxxhtvMHDgQMaPH8///vc/5s2bB9x8/wMDA12Ov9lsxt3d3WlP0evvAen20AwMDHQEfq5nXxp8Mwfg3Cgn71f7+75o0aIuy8ro+s2wLwvv0KFDusB2+/btWbhwIVOmTOG5555zunern9/ssC/l3rFjR47zxsfHuzwcJyNubm4ULlzY8bX9GZ87d85levv17IzFnj17WLNmDdWrV2f8+PGO94Gvry/PPfccx44dY+TIkUyaNIk333zTZRkWi4U5c+bg7e3tNEP2etcvcZ88eTINGzYE0t5jDz30EKdOnXLMGs+tvVxzQjMvRURERERECjqTKW0pdn56efi6vn6TM6muZz+VOaMDLxISEjh16hRubm4UL178luqyLwk9fvx4lmnty2M//vjjTGdqDR8+3Cnfzc4u++mnnzh8+DBNmjRhz549WK1WoqKiCA8PTzdDMa8899xzxMbGMmvWLOLj45k5cybNmzenVq1aOSrHvqT5wIEDjmv5of/R0dEuZ/edOXMG4I4vmbbXl9HBPBldz6mUlBTHLLwpU6ak2wfSHrDcsmULhw4dcsp7Jz6/rVq1ws3NjQ0bNjiWW2fXre55ad9nc9u2baSmpqYrf8uWLUDa/pJZOXnyJJC2bYKrALa9rsy+P82fP5+YmBi6d+9OoUKFXKapWrWqIxhevXr1dPftbb3xcKI7RcFLERERERERKVCaNm0K/L0U8kZTp04lKSmJOnXqZDizK7uaNGkCwJgxY9ItGYa/l7cCjqXI48aNy/SUXiMHhxZ5eHhkOAvs9OnTQNosxlq1auHu7u64Z5+deDtl1ja7fv36ERgYyPjx45k9ezaxsbEuZ11mNavTfmjP9QfK5HX/7Vy9DydOnAjgmMF2p9iXhU+bNi3dvT179ji2QbhVK1as4PLly7i7uzudNn/9y9vbG/h7X0y7O/H5LV26NA8++CA2m41+/fo5ZkVn5PrPpH3Py5y8rle8eHFq165NZGSk0564AOfPn2fx4sW4ubml257AFXswetu2bS6Xof/xxx8ATjM/b2R/L2Y2Y9Lb29uxp+qGDRvS3bdfy84M9NtBy8ZFRERERESkQHn++eeZPHkyP/zwA+7u7gwYMICSJUsSGRnJL7/8wnvvvQfAkCFDbrmu9u3bU7NmTfbt20ejRo147733qF27NsnJyWzbto2RI0eyefNmvL29ad++PbVr12b37t00bdqUN954g9q1a+Pj48Pp06fZsmULkyZNYuXKldkOApQoUYJDhw4xceJEOnbsiKenJ97e3vj7+1OpUiUg7RTs4sWLU7lyZS5fvszs2bP56quvbrnvt9I2Oz8/Px5//HG+/fZbLl68SIkSJXjwwQfTlTVv3jw+++wzHnzwQe69915KlSpFYGAgFy9eZMGCBY6Tvq/fGzSv+283fPhwkpKSeOCBB0hNTWXu3Ll8/vnnmEwmnn766TvWDkh7PkWKFOGPP/7gqaee4tVXX6V48eJs3bqVV155JcMgsdVqJTY2Fi8vL5fL5m9kXzI+cOBAxowZ4zLNTz/9RM+ePZk2bRoffvihY+Zgbnx+o6OjHad63ygwMBBPT09GjRrF+vXr2bp1K3Xq1GHYsGG0bNmS0NBQIiMjOX/+PJs2bWLmzJksXLiQatWqAWl7Xl5/ENTNGDp0KAMGDOD555/HZrPRokULTp48yYsvvkhiYiL9+vWjSJEiTnnsy9X9/PwcWxE0bNiQkJAQTp8+TdeuXXnrrbeoXLkyV69e5ccff3SMQ5cuXVy24/jx46xfv54SJUrQtm3bTNs8bNgwVqxYwRNPPMFnn31Gs2bNSExMZMGCBXz22WcAGS47v+0MyZHo6GgDMKKjo/O6KbdNUlKSsXDhQiMpKSmvmyI3QeNX8GkMCz6NYcGnMSzYNH4Fn8bQtYSEBOPAgQNGQkJCXjclS6mpqUZkZKSRmpp62+oYPXq04ebmZgAuXwMHDnSZr2jRokbRokVd3nvjjTcMwFi5cqXT9UOHDhmlSpVyWY/JZDISExMdaU+cOGFUqlQpw3YBxvnz57PVHsMwjG+++SZd/r59+xqGYRgWi8WoWrWqyzpeffVVAzDat2/vVF6NGjUMLy+vTJ/LjeOX0XPJrG3XO3DggOP+e++957Kfc+fOzfSZAUbz5s2N+Ph4R56b6X9mz7tGjRqGu7u7y3utW7c2ACMyMjJdWT179nTZhrfffttlHa6ef3bG5UYZjcvixYsNs9mcrj0VK1Y02rdvbwDG8ePHnfJMnjzZAIxu3bq5rOt6kZGRhpeXl2EymYzDhw9nmC41NdUoX768yzbe7Oe3RYsWWb5Pfv75Z0f6w4cPG3fddVeWeY4cOZJlv3PCZrNl+L6oVKmScfXq1XR5Bg8ebADGBx98YBjG35/DefPmGR4eHhm2ffDgwRm246233jIA44033shWu1955ZUM6xkyZEi2ysjuz6qcxNc081JEREREREQKnBdeeIFGjRoxZswYtmzZQkREBP7+/tx9990MGDAgw5lINy7xvJ6fnx8hISHpDtSpWrUqu3fvZtSoUSxdupTz588TGhpK/fr1GTp0qNNhO+XLl2fnzp2MGzeOxYsXc/z4ccxmM2XLlqVRo0Y88cQTlChRIlvtgbQl0RaLhXnz5nH+/HlSUlIcM+N8fHz4448/eP/991m3bh0xMTFUqVKFQYMG0apVKyZPnpzuRO/g4GBCQ0Nz5blk1rbr3XXXXdSpU4f9+/czcOBAl3X06tWLnTt3snDhQjZt2sTZs2eJjIwkMDCQGjVq8OCDD/Loo4867ft3M/3PrJ8ZPRtIOzQnJCTE5b6Ds2bNok6dOsybN4+rV69Svnx5nnvuOfr27ZvtOnJzXLp06cIff/zBBx98wP79+/Hx8aF169a8//77dO3a1WW59pPar1+Wn5Fff/0Vf39/WrdunW6/x+u5ubnxyiuvMGLECH755RfatGnjuHezn1/7OGTm+s9jlSpV2LNnD7NmzWLhwoUcOHCA6OhoQkJCKFmyJI0bN+aRRx6hcuXKWfY7J0wmE3PmzGHs2LFMmzaN06dPExwcTKdOnXjrrbdc7j1pX65+4yFFDz74INu3b+ebb75h06ZNRERE4OvrS61atXjiiSdcniwPaUvhly5dSkhISIanjN/oiy++oFGjRowbN45Dhw7h5uZGzZo1eeaZZ+jWrVsOn0LuMRlGDjbbEGJiYggKCiI6OjpbH+qCKDk5maVLl9KpU6dMT8iT/EnjV/BpDAs+jWHBpzEs2DR+BZ/G0LXExEROnjxJ+fLlHXvJ5Vc2m42YmJgMT3WW/C23x+/s2bNUqlSJbt26pdsDsCCzn9B86dKlPG6JM8MwMAwj3Rju37+funXrUrp06WwdQCV5q6B+H83uz6qcxNc081JEREREREREcpXNZiMiIoKrV6/y/PPPk5SUxDPPPJPXzfpXWLZsGTNmzKB79+7Uq1cPq9XKli1bGDFiBMnJyfTr1y+vmyiSIwpeioiIiIiIiEiuOnHihNNS3MaNG2d5YIjknpkzZzJz5sx01+vXr88bb7yRBy0SuXkKXoqIiIiIiIhIrnJ3d3fs39ekSRNGjhyZ103KdVntvZhXOnbsyIwZM5g2bRqnTp0iNjaWMmXK0K1bN1588cV0eyqK5HcKXoqIiIiIiIhIripfvjzh4eF53Yzbav/+/XndBJdMJhMPP/wwnTp1KnD7JYq4onewiIiIiIiIiIiI5EsKXoqIiIiIiIiIiEi+pOCliIiIiIiIiIiI5EsKXoqIiIiIiIiIiEi+pOCliIiIiIiIiIiI5EsKXoqIiIiIiIiIiEi+pOCliIiIiIiIiIiI5EsKXoqIiIiIiIiIiEi+pOCliIiIiIiIiIiI5EvmvG6AiIiIiIiIyK1KTk4mKSkJPz+/LNNGR0eTnJzsdM1sNhMYGIibW87m+CQlJZGSkoKvr2+O8uWE1WolNjYWNzc3ChcunGlbYmJi8PLyIiAgwGUam81GREQEZrOZQoUKOa4bhsG1a9dwd3cnKCjoptp5J57FjWw2GwkJCdka96wYhkFCQkKW7Y+IiMBms7m8d+NzvZU8IpJGMy9FRERERESkQDp//jwvvfQS5cqVw9PTE39/fwIDA3nggQdYs2ZNhvm6detGWFiY0ys4OBg/Pz9atWrFypUrM613+/bt9OvXj+LFi+Pl5YWfnx9BQUHUqlWL4cOHs3fv3lzt55tvvulo57lz5zJMt2jRIsLCwnjmmWcyTHPixAnCwsJo1KiR0/XLly8TFhZG3bp1c9S2O/0s7Hbv3k379u3x8vLC39+fokWL8tZbb5GYmJijclJSUpgwYQJ33303Pj4++Pn5ERYWxoMPPsiePXtc5qlevXq694/9deNzvZU8IpJGMy9FRERERESkwPntt9946KGHiIuLA8DDwwNPT09iY2NZvHgxixcvZujQoYwcORKTyeSyjKCgIMzmtF+LExISsFgsrFmzhrVr1/LTTz/Ro0cPp/SGYTBixAg++OADxzUPDw+8vLyIiYlh37597Nu3j2XLlrFr165c6WdKSgozZ84E0mYZTps2jeHDh+dK2bciL56F3Y4dO2jWrBkWiwWTyYSvry9Xrlzhk08+YceOHSxZsgR3d/dslfX4448za9YsANzc3PDz8yM8PJyff/6ZJUuWsHz5clq2bJkun8lkcjkLNjg4OMO6biaPiGjmpYiIiIiIiBQw+/bto3v37sTFxdGqVSs2bdqE1WolLi6OM2fO8Prrr+Pm5sbXX3/Np59+mmE5y5cvJzw8nPDwcOLj4zl9+jQPPvgghmHw/vvvp0v/v//9jw8++ACTycTgwYPZu3evY0l3bGws+/fv57PPPuPuu+/Otb4uW7aMK1eu0LVrV8xmM1OmTMm1sm9FXjwLu4EDB2KxWOjduzdXr14lPj6e9evXU7RoUVasWMG0adOyVc6ePXuYNWsW7u7ujB8/noSEBOLi4jh16hRdunQhKSmJd955x2XeIkWKON471782bdqUYX03k0dENPNSRERERERECpgXXniBhIQEunTpwsKFC51m2ZUuXZrPPvuMChUqMGjQIN577z369+9PiRIlsiy3TJkyfP/99yxYsIBjx4453Tt//jzvvvsuABMnTmTAgAFO9/39/alevTrVq1fPhR7+zR6sHDx4MFarld9++40tW7Zw77335mo9OZFXzwJg69atbN++nZIlSzJlyhS8vb0BaNq0KaNHj6Z3796MHTuWJ554Isuyjhw5AkDXrl15+umnHdfLli3L+PHjKV68OIcPH871PohIzmjmpYiIiIiIiBQYhw4d4o8//sDDw4OxY8dmuDz42WefpUmTJiQlJTF58uRslx8fHw9A0aJFna5PmDCBpKQk2rVrly5Yl5WYmBjCw8NJSkrKUb7IyEh+/fVXQkJCaN26NX369AHI89mXt/IsbtWqVasA6N27tyNwadejRw8CAgLYsmULMTExWZZVtmxZAMfWA9ezX7OnyUhcXBwpKSnZavut5BH5N1PwUkRERERERAqMP/74A4CWLVtmOZvy0Ucfdcpzo+joaMfS3bNnz7Jq1SpHnhtn7tkPALLfz4nevXsTFhbGggULcpRv1qxZWK1WHnroIcxmMz169MDDw4PZs2djtVpz3I7ccivPIiIiwuXS6Yxe9mCy3cGDBwGoV69eurLNZjO1atXCMIxszZhs2LAhbdu2ZdWqVbz22mvs27ePc+fO8dtvv9G7d29MJlOG+4tGRkZSsmRJAgIC8PLyol69eowfPx7DMDKs72byiIiWjYuIiIiIiBR4hmGQkJKQ181wsNlsJKQkYE424+bmPGfGx+yT4QE62XHy5EkAatWqlWVae5qzZ8+6vN+hQ4d018LCwvjmm2948cUXna6fOnUKgJo1a+akuUDawUAhISF4eXnlKJ99huXDDz8MpB3s0rZtW5YuXcrixYvp2bNnjtuSG27lWVSoUIHo6Ohspx88eDDffvut4+vw8HAAihUr5jK9/fq1a9eyVf6iRYv4+OOP+fLLL/niiy8c1++++25+/fVXOnXq5DJfUlISFy5cwMfHh4SEBHbu3MnAgQNZu3Yt06dPd/kev5k8IqLgpYiIiIiISIGXkJLAvTPzbg/EnNjy6BZ8PXxvOr99Jp6/v3+WaQMCAgDXy4LB+bTx5ORkYmJiuHr1KpMnT6Zdu3ZUq1YtXb1+fn45bvOcOXNynOfw4cP89ddfFC1alBYtWjiu9+nTh6VLlzJ16tQ8C17eyrMICQlxPPPsuHGc7TNOPT09Xaa3B4gTExOzVf6uXbv46aefHCeX+/j4YLFYOHjwILNnz6ZFixbp+tm1a1ceffRRGjZsiL+/P5cuXWLs2LF8+OGHzJw5k/bt2/P444/fch4RSaPgpYiIiIiIiBQYgYGBAERFRWWZNjIyEkgLUrqyfPlyGjVq5Pg6JiaGcePG8frrr3P//fdz7NgxR/AsMDCQ8PDwHM0avBX2WZe9evVymr3avXt3vLy8HKeQFylSxHEvOzP37EuUb2WW3608i+PHj990vQA+Pj5AxsHJhIS0Gci+vlkHyE+dOkWrVq0AmDx5Mg8//DDe3t6OE+unTZtGXFxcuuX+48ePd/q6WLFijBgxAg8PD95++22mTp2aLhB5M3lEJI2ClyIiIiIiIgWcj9mHLY9uyetmONhsNmJjYwkICHC5bPxWVKlSBYDt27dnmdaeJrunXgcGBvLqq6+yceNGFi5cyMyZMxk4cKCj3hMnTrBjx47bftK3zWZj+vTpALRp08axVNquRYsW/Pbbb8ycOZOhQ4c6rtsDexnNNL3+XnaCexm5lWcRERGBzWbLdnofHx+nmY/2g5TOnTvnMr39+o0HLrny/fffk5CQwHvvvee0x2mZMmWYPn06mzdv5ueff+bUqVOUK1cuy/J69erF22+/7TjFPDtuJo/Iv40O7BERERERESngTCYTvh6++erlY/Zxef1W9/Vr1aoVbm5ubNy4kUOHDmWYLjU1lR9//BGAzp0756iOSpUqATgd+tK2bVsgbYbe7T5g5ffff3fs09m9e3fCwsKcXr/99huQ/tTxkiVLAn8fauPKgQMHnNLejFt5FhUqVEjXn8xeb7zxhlN++z6bW7akD9YnJCSwd+9ezGazI8idGfss0Bo1aqS7ZzabqVq1qlO6rNhng7q7u2cr/c3mEfm3UfBSRERERERECozSpUvTvXt3DMOgf//+xMbGukz37rvvsn//fsqUKUOfPn1yVMe2bdsA5z0dBwwYQEBAAFu3bmXEiBGZ5s/JzEJX7EFJX19fQkJCXL5MJhO7du1iz549jnw1atQgODiYEydOZHjC+sSJEwFo1qzZTbfvVp5FRv3J6HXjnpcdO3YEYO7cuURERDjdmzx5Mlarlfvvv98xCzUzhQsXBmDDhg3p7sXExLBr1y6ndECmwVr70vAbDzK6mTwi8jctGxcREREREZEC5ZtvvuGPP/7gr7/+okGDBrz11ls0bdoUb29vDh48yHfffcfChQvx8fFhwYIFeHt7uywnOjrasSQ7OTmZc+fOMW7cONauXQv8HSiDtJO+f/jhB/r27csHH3zAli1bePbZZ6lTpw5eXl5cunSJM2fO8Ouvv3L8+HFHGZAWCEtKSiIwMDDDg2bsrt9jcdmyZTRv3txlul69ejF//nymTJnCl19+CaTNFnzuuef4+OOPeeihh/joo49o3bo1fn5+nDhxgpEjR7JmzRqCgoKclklfz2azER4eTmxsLElJSU7L/k0mEyEhIbf0LG51z8tq1arRvn17VqxYQZcuXRg5ciSlSpVi+fLlvPbaawBOS+nt7MvVCxcu7OhT165dGT9+PKNHj8bPz48+ffoQHBzMwYMHee+997hy5QplypShdu3ajnI++OADDhw4wMMPP0zFihUpVKgQJ06cYPz48cyYMQOAZ5991qnum8kjItcxJEeio6MNwIiOjs7rptw2SUlJxsKFC42kpKS8borcBI1fwacxLPg0hgWfxrBg0/gVfBpD1xISEowDBw4YCQkJed2ULKWmphqRkZFGamrqbatjz549RtmyZQ3A5atq1arG+vXrXeZt0aJFhvnsr6FDh7rM++OPPxq+vr6Z5q1Xr55Tnvbt2xuAMWvWrCz7NWnSJAMw6tevn2m6P//80wCMokWLGsnJyY7riYmJRtu2bTNsm4+Pj/Hrr7+mK+/ixYtZPhMvL69bfha54dSpU0bx4sVd1vfss8+6zBMSEmIAxtGjR52u9+3bN8O2e3t7G7/99ptT+v/85z+Z9vedd95JV/fN5LlVd+IzKLdXQR3D7P6sykl8TTMvRUREREREpMCpVasWhw4dYsKECSxatIhjx44RGxtLeHg4JpOJefPmUatWLZd5g4KCCAkJcbrm5uZGoUKFqF27NgMGDKBTp04u8/bv358OHTowbtw4Vq9ezenTp0lJSaF48eKULVuWzp0706NHD5f1eXl5ZdmvX3/9lZCQEF599dVM09133320bt2aXbt2sW7dOsep2faTyKdPn87cuXM5ePAgiYmJFClShObNm/PSSy859vS8sf/XPxPDMNLtT3rjDNabeRa5oWzZsuzatYsPP/yQlStXEhsbS4UKFXjqqafo37+/yzz2vt24t+T06dPp3Lkz06dP58CBAyQmJhIWFkbTpk0ZOnRour0z3333XerVq8fs2bM5ePAgV65cITg4mIYNG/LMM8/QpEmTdHXfTB4R+ZvJMG7zTsP/MDExMQQFBREdHU1gYGBeN+e2SE5OZunSpXTq1AkPD4+8bo7kkMav4NMYFnwaw4JPY1iwafwKPo2ha4mJiZw8eZLy5ctnuAw6v7DZbMTExBAYGJjutPHbbeDAgYwfP54GDRrw559/6j10E/Jy/CR3aAwLvoI6htn9WZWT+FrB6b2IiIiIiIhIFr7++muqVavGtm3beO+99/K6OSIicosUvBQREREREZF/DF9fX2bNmkXRokWZMGEC27dvz+smiYjILdCelyIiIiIiIvKPUqdOHS5dupTXzRARkVygmZciIiIiIiIiIiKSLyl4KSIiIiIiIiIiIvmSgpciIiIiIiIiIiKSLyl4KSIiIiIiIiIiIvmSgpciIiIiIiIiIiKSLyl4KSIiIiIiIiIiIvmSgpciIiIiIiIiIiKSLyl4KSIiIiIiIiIiIvmSgpciIiIiIiIiIiKSLyl4KSIiIiIiIiIiIvmSOa8bICIiIiIiIpIbYmNj8fX1xd3dPa+bclMMw+DatWt4enoSGBh40+WkpqYSGRnpdM1kMuHr64uPj0+2y0lISCAhIQGz2UyhQoWyrM/Dw4OgoKActc1kMuHj44Ovr2+223UrEhISiI+Pz7JPiYmJxMXF4ePjg5+fn8s0KSkpREVFpet3Tp5HRqxWKzabLUfjdatSU1OxWq25MhY2mw2r1Zqj9sfGxuLj44PZnLNQVWpqKklJSXf0WcmdpZmXIiIiIiIiUiBFRETw/vvvU69ePTw8PAgMDMTT05NixYrRuHFjPvnkE44cOZLXzcy2a9euERYWRu/evW+pnL179xIWFub0Cg0NxdfXlxIlSvDSSy9x7dq1LMt56qmnCAsLo2TJksTGxmZZX/v27XPcttDQUPz8/PDw8KBmzZo888wzbNiwIUf9zYknn3wyW32aMGECYWFhvP322xmm2bx5M2FhYXTr1s3pek6ex/XWrVtHr169CA0NxdvbG19fX4KDg6lXrx7vv/8+R48ezVF52bVhwwaaN2+Op6cnfn5+lClThk8++YTU1NQclZOYmMhXX31FtWrVHO0vVqwYjz32mMu2nz9/npEjR9KkSROCgoIIDAzE29ube+65h+nTp2dal2EY/PjjjzRs2BAvLy/8/PyoWLEiH374ITExMTlqt+R/mnkpIiIiIiIiBc7atWvp1asX4eHhjmv+/v5YrVYuX77M5cuX2bRpE0uWLLmtwbD8zGw2O2b+GYZBVFQUFy9eZPTo0axatYrt27dnOFstOjqaRYsWAWCxWJg/fz4DBgy4LW1LTk4mNjaW/fv3s3//fiZMmECvXr2YOHEiAQEBuVZndHQ0v/zyC3B7+nSzUlJSeOmll/j+++8d1zw9PfHw8CAqKoqdO3eyc+dONm3axPLly3O17lWrVtGxY0dSUlJwc3PDx8eHs2fP8tZbb3HgwAGmTZuWrXIMw6BLly6sXr0aAHd3d3x8fLh8+TLTp09n4cKFbNiwgdq1azvyfPDBB4wdO9bxta+vLxaLha1bt/LYY4+xY8cORo4cma6u1NRU+vfvz4wZM4C02bv+/v6cOHGCd999l3LlytGvX79beSySz2jmpYiIiIiIiBQo+/bto3PnzoSHh3PvvfeyaNEiYmNjiY2NxWq1cuXKFTZv3szbb79NtWrV8rq5eaZ+/fqEh4cTHh7OtWvXSEpKYunSpQQHB3Pw4EHmzJmTYd6FCxeSkJBAjx49AJgyZcpta1t0dDSJiYls3bqVl156CbPZzLx583jkkUdytc65c+fe1j7drNdff53vv/8eDw8P3nzzTQ4fPozVaiUuLo6oqCh27drF+++/T5UqVXK13qSkJJ555hlSUlJ47rnniIqKwmKxsGTJEgIDA5k+fXq2g6UrV65k9erV+Pj4MG/ePBITE7FYLBw6dIimTZsSFxfHf//7X6c8pUqVYtiwYWzcuJGoqCji4+MJDw/n5ZdfBuCrr75iz5496er6/PPPmTFjBt7e3owePZrY2FhiYmK4ePEiI0aMyHQ7ACmYNPNSRERERERECpTBgwdjsVjo1q0b8+fPd9ojz2QyOZYk33vvvS7zR0REAFC4cGHHtejoaDw8PNLt95eSkoLFYsn2HpQ5SW8YBvHx8fj7+2eYxmKxYLFYCAgIwMvLy2WaqKgoUlJSCAkJwWQyZViWu7s7HTt2ZNCgQXzyySccO3Ysw7SzZs0CYMSIERw/fpx169Zx6tQpypUrl2W/boanpycNGjSgQYMGdOvWjQ4dOrBkyRKWLFlC586dc6UOe7DyTvUpO/bs2cNXX32Fm5sbP//8c7q+BgUFUbt2bacZi7llxYoVnDp1irvvvptvv/0WN7e0+W2dOnXiww8/5KWXXmLs2LF06NAhy7Ls2zP079+fnj17Oq5XrVqV0aNHU7duXQ4fPuyU55133klXTkhICCNHjmTPnj2sXr2atWvXcvfddzvux8TE8NFHHwEwZswYp5mzxYoV47333sv+A5ACQzMvRUREREREpMA4ePAg69atw9vbm3HjxuX4cA+A6tWrU716dWJiYhg0aBBBQUEUKlSIzz//3JFm0qRJ1KtXD09PT4KCgggKCqJfv36cPXvWZZk5SR8VFcXAgQMJDAwkICCAkJAQ3n77bZKTk9OlXbZsGWFhYbz22msu642IiKBYsWK0aNEi08Dl9eLj4wEoWrSoy/vHjx9ny5YtVK1aldq1a9OnTx8Mw2Dq1KnZKv9WtWrVimeffRaAH3/80eleVFQU4eHhLp9VZo4fP87GjRvzrE8ZsS8V79evX64FabNr1apVAPTt29cRuLTr168fbm5urFq1CsMwsiyrbNmyAMTFxaW7Z79mT5Md9erVA0hX94IFC4iPj6dy5co88cQT2S5PCjYFL0VERERERKTAWLt2LQAtW7akSJEiN11OamoqnTp1YuzYscTHxxMSEuKYdfnUU0/x1FNPsXPnTkwmE35+fsTExDBjxgwaNmyYLiCZk/RJSUm0bduW8ePHExcXh6enJ5GRkXz88cc899xz6drZrVs3SpYsybRp00hISEh3f8qUKVitVgYPHpzuXkpKimNp9tWrVzl8+DCjRo1i7Nix+Pv7O82Qu549oGc/OKhPnz5O1+8Ee91//vmn0/X777+fsLAwNm7cmKPy7LMu7X3Jiz65smbNGgAeffTRHOe1j21Gr2vXrjl9feP75+DBg8DfgcLrBQcHU65cOeLi4jh37lyWbenYsSN169Zl5syZfPjhhxw8eJCzZ8+yaNEinnzyScxmM6+//nq2+7ZlyxYAmjdv7nR906ZNADzwwAOOYH1cXFyODxeSgkXBSxERERERkQLOMAxsFkv+eiUkuLyenVlcmTl9+jQANWrUcHnfVRDHZrO5THf8+HEWLVrk2Gvv9ddfZ86cOUyaNIlGjRqxceNGkpKSiIuL49KlSwwePJjLly8zfPhwRzk5Tf/tt9+ybds2SpcuzapVq4iPjycmJoZvvvmGpUuXpmun2WzmmWeeISoqinnz5qW7P378eAICAnj88cfT3du+fbtjCX2RIkWoVq0aQ4YMoXnz5mzYsIHixYuny2MYhuOkZ3sAsWLFitSrV4/jx4/fscOP7rrrLgAuXbrk9J4JDg4mJCQEDw+PbJdlGIbj4Bl70DIv+uSK/f1cs2bNHOVLTExMd6L89a+iRYtSqVIlihYt6rj25ZdfOpVhP+yqWLFiLuuwX8/OyfRms5k1a9YwZMgQ/vvf/1K9enXKlClDt27dCA0NZc2aNbRo0SJbfZs1axbr1q2jW7du1K1b1+me/Q8BdevWZcqUKZQrV46AgAC8vb1p0aIFv//+e7bqkIJFe16KiIiIiIgUcEZCAofr1c/rZqRz2cW1qju2Y7phX8mcsC95drVPpD2gc6OjR49SqVKldNe/++47unbt6nRtzJgxeHh4MH36dEJCQoiJiQHAw8OD999/n99++43FixffdHr7CclTpkyhZcuWjr689NJLnD17li+++CJdOwcOHMiHH37I+PHjnYKUGzZs4ODBg7zwwgsun8f1J3pD2n6BycnJrF+/nqlTp/L555/j7u7ulMe+D6R9ab1dnz592LFjB1OnTqVp06bp6spt9v7YbDYsFgt+fn7A3zMVc8Lep1q1auVpn26UmppKYmIigKN/2WUymQgJCck0jWEYTlsJ3Lifq9VqBdL2G3XFvseqvY1Z2bRpE7/88gvJycm4ubnh5eVFQkICO3fuZM6cOdx7771ZBp03b97MU089RZkyZRg/fny6+xaLBUjbTsH+WbKfUr5u3Tratm3L7Nmz6dWrV7baLAWDZl6KiIiIiIhIgWE/CCcqKirdPXtAx/66MTB3PTc3N5d7DG7dupXk5GQqVapEcHAwhQsXpnDhwoSEhBAaGsrRo0eJiYkhOjr6ptLv3buXkJAQR+DyehkFXIoXL0737t0dwUq7cePGAfD888+7zHf9id7h4eFYrVb27NlDw4YNGTlyJCNGjEiXx7682n4it519FubcuXOzHcy6FfbxNZvNOQ7s3ejGJeN2mfUpO/uH2meEZnev0Ru5u7s7Aor290d2eXl5Zbpk/MqVKxw/fpwrV644rg0bNsypDB8fHyDj4KR9mfmNQU9XduzYQZcuXYiMjGT+/PkkJCRgsVg4fPgw999/P99++y1DhgzJtIytW7fSsWNHgoKCWLlypcs/RNjbPGPGDF599VUiIiKIj4/n4sWLPPbYY9hsNl544YUc74kq+ZtmXoqIiIiIiBRwJh8fqu7YntfNcLDZbMTExhIYEJDuIBDT/wcfblblypUB2LlzZ7p79oCOXZ06ddi9e7fLckJDQ9Od3m21WklISMDd3Z1ChQpl2o7U1NQcp09MTCQ5OTnDZbqulnHbPf/888yfP59x48bx1VdfERUVxfz582ndurVjiXVWTCYTtWrVYtq0aZQrV46vv/6a//73v44xslgszJ8/H4AWLVoQHh7uuOfv70/t2rXZvXs3Cxcu5OGHH85WnTdr165dAJQpU+aWyrm+T61bt3Z6f2TWJ3uQzNUBNHb2e9kJ7mWkSpUq7Nq1ix07duToQBvAqS83stlsxMbGkpSU5BhDPz8/R7/g7wObzp0753Sit519r8uMDna63jfffENqaiqffPIJDz30kON6lSpVmD9/PiVKlGDcuHF8/vnnLmcJb968mQ4dOuDp6cnq1aupUqWKy3rsn53GjRvzv//9z+n6pEmTWL9+PadOnWLHjh3ce++9WbZbCgYFL0VERERERAo4k8l0S0uxc53NhltKCm6+vumCl7eqZcuWmEwm1q9fz/Hjx6lYseJNleNqtpyXlxe+vr6YTCYuXLiQ4XLa6+U0vbe3d4Ynlp85cybDfC1btuSuu+5i6tSpfPrpp0ydOpWEhASXB/VkpUyZMnh4eBAfH8/58+cpXbo0kHaSc2xsLADt2rXLMP+UKVNue/DSfsp4dvdJzMj1fbrvvvsyTHdjn0qWLAngNNP1RgcOHHBKezPatm3Lrl27mDhxYrrZrpnJaIuEzHzwwQe88847jq9r1qzJ0qVL2bJlC506dXJKe+HCBc6dO0dISEi2gpfHjx8HXO9F6+fnR7ly5dizZw+nT59Ol2bdunV06dIFb29vfv/9d6el/TeqVasWgMs0ZrOZqlWrcurUKSIiIrJssxQcWjYuIiIiIiIiBUbZsmXp3r07NpuNfv365Xi5bVaaNm1KfHy8y/327K4/ACin6Rs0aEBMTIzLw3fsy8Az8txzzxEREcFPP/3E+PHjKV26NA888ECmeVzZs2ePY1nt9Uuy7cur/f39HUvfb3wBrFy5kosXL+a43uwaP348c+bMAWDQoEG3VNb1fXLVn4z6dM899+Dp6cnmzZsdQcrrpaSkOMpu1qzZTbfv+eefx8PDgyVLljBmzJhM017/PrpxiwRXrxvH8MYZoh07dgTSntGNJ5H/8MMPTmmyUrhwYQCXhx9dunSJI0eOOKWzW7VqFR07dsTLy4vVq1dneXCRPci6efPmdCeMx8XFOWbslipVKlvtloJBMy9FRERERESkQBk9ejQbNmxg8+bN1KpViyFDhtCyZUuKFSuG1Wrl0qVLrFy5kpMnTwLkaPbn66+/zsqVKxk6dCgHDx7k0UcfpXTp0kRHR3PixAl+/vlnDMNwzAzMafqnn36aDRs28PTTTxMeHk6bNm2Ii4tj0qRJjhOxM9K/f3+GDx/OG2+8wblz5/joo48y3dczJSXFaWlxdHQ0O3fu5O233wbSAnT2YNK5c+f4/fffMZlM/PXXXxQvXpzAwMB0z65Zs2Zs2LCB6dOn89prr2Va3/Xc3d0JDg52mTY5OZmIiAh27drF9OnTWb58OQAvvvgi99xzj1M5UVFRpKSkEBQUlOXhL9f3adu2bVStWtVlOld9Cg4Opl+/fkyaNIn27dvz0Ucf0axZM7y8vDh06BCffPIJe/fupWTJkvTs2dNludl5HuXKlePTTz/llVdeYfDgwaxevZoBAwZQs2ZNzGYzFy5c4NSpU/zyyy9YrVbHEvgbt0i4kc1mIyYmxuUY2rVo0YI6deqwa9cuHnzwQT766CNCQ0OZP38+n3zyCYDLfSrt9YaGhjqude3alcWLF/Pee+85vvb392f37t288847JCYmUr9+faetEZYvX06PHj0wm83MmTOH4sWLp+uTj4+PU4C9WrVqdOzYkWXLltGzZ09ef/11SpcuzbFjxxgxYgSXL1+mevXqOT69XfI5Q3IkOjraAIzo6Oi8bsptk5SUZCxcuNBISkrK66bITdD4FXwaw4JPY1jwaQwLNo1fwacxdC0hIcE4cOCAkZCQkNdNyVJqaqoRGRlppKam3rY6Dh06ZFSvXt0AMnwFBQUZkyZNSpe3aNGiRtGiRTMs+6uvvjLc3NwyLLd37943nd5msxndu3d3me7FF180AKN9+/YZtu3ZZ581AMPT09O4fPmyyzQ7d+7M9LkARnBwsLFz505Hno8//tgAjM6dO2c6fgsWLDAAo0aNGjmqr2zZstlO6+HhYfznP/8xUlJS0tVfu3ZtAzDWrFmT4TNy1afMuOqTYRhGVFSU0bBhwwzbWahQIWPjxo3pysvJ87D78ssvDU9Pz0zzdOrUKcs+22X3M7hnzx4jKCjIZX0jRoxIlz45OdlxPzY21nE9KSnJaN++faafxW3btjmV1a1btyyf05AhQ9K14ezZs0aZMmUyfF9v3749288pP7sT30dvh+z+rMpJfE0zL0VERERERKTAqVq1Knv27GHu3Ln88ssv7N27l8jISPz8/KhUqRLt27dnwIABBAUFpctrXyqckaFDh3L//fczZswY/vzzTyIiIggLC6NixYp079493Uy7nKQ3mUzMmzePUaNGMX36dC5fvkzZsmUZOHAgDzzwADNnznTZZrtHHnmEsWPH0rt3b4oUKeIyjdlsdtlHLy8vSpYsScuWLRkyZAglSpRw3Fu6dCkhISHpTqS+Ubdu3ahTpw5nz55l3759jhmCWT1T+wzPG9OaTCa8vb0pVKgQVapUoXHjxvTt2zfDQ42Cg4MJCQnJctblrfYJICgoiPXr1zNp0iQWLFjA0aNHSU5Opnjx4rRq1YqXXnrJ5fLknDwPu2HDhvHQQw8xbtw41q5dy/nz54G0Q5zKly9Pt27d6Nq1a5Z9zqlatWqxa9cuPvroI9atW4fFYqFq1aoMHjzY5R6c9uXq9v+2sy99nzx5MnPnzuXIkSMkJSVRtGhRWrZsycsvv+zYW9UuMDAwy+fk6nCfUqVKsXPnTj799FOWL19OeHg4ISEhtG7dmldffVVLxv+BTIZhGHndiIIkJiaGoKAgoqOjCQwMzOvm3BbJycksXbqUTp06ZesHguQvGr+CT2NY8GkMCz6NYcGm8Sv4NIauJSYmcvLkScqXL4+3t3deNydT2VmyKjdn+PDhfPrpp2zcuJHGjRvfljo0fgWfxrDgK6hjmN2fVTmJr2nmpYiIiIiIiEg+Fh8fT1xcHOvXr+err76ievXqty1wKSKS3yh4KSIiIiIiIpKPvfHGG3z33XeOr0eMGJGHrRERubMUvBQRERERERHJx/z9/QkNDaV48eIMGjSI3r1753WTRETuGAUvRURERERERPKxTz/9lE8//TSvmyEikicKzo6fIiIiIiIiIiIi8q+i4KWIiIiIiIiIiIjkSwpeioiIiIiIiIiISL6k4KWIiIiIiIiIiIjkSwpeioiIiIiIiIiISL6k4KWIiIiIiIiIiIjkSwpeioiIiIiIiIiISL6k4KWIiIiIiIiIiIjkSwpeioiIiIiIiIiISL5kzusGiIiIiIiIiOREdHQ0ycnJTtfMZjOBgYG4ueXPOToREREAFC5cONt5cquf4eHhABQqVAizOeMwgL2+wMDAHLftTj//7Pbp2rVrGIZBaGhohmnsfQkODsbd3T3d9azqyIhhGMTGxmbreeamuLg4fHx8cqWs+Ph4/Pz8sp3eZrMRFxdHQEAAJpPpttYl/x7587u6iIiIiIiISAa6detGWFiY0ys4OBg/Pz9atWrFypUrc6WeyMhIR9DxVlWvXp3q1avnKE9u9HPLli2OvKNGjcpWfdu2bctx2+yBv6JFi9KxY0e+//57YmNjs93XnMhJn4oWLUpYWFimaVq3bk1YWBh79+51up6T52F37do13n33XWrVqoWHhwdBQUF4eXlRrlw5Hn30URYvXkxKSkq2y8uu2NhYhgwZQkhICAEBAfj6+vLoo49y9OjRHJe1ZcsWOnfuTEhICP7+/vj6+lK/fn1mzJiBYRjp0h86dIi33nqLGjVq4OPjQ1BQEAEBAXTu3JlNmzZlWtexY8fo27cvhQoVwt/fn6CgIHr06MFff/2V43bLP5eClyIiIiIiIlIgBQUFERISQkhICL6+viQmJrJmzRrat2/Pzz//fMvlN2zYkAoVKuRCS2/NrfRzypQpLv87t9tWuHBhPDw8uHLlCsuXL+f555+natWq/P7777le5+3u081at24dVatW5cMPP2Tfvn3YbDYCAwNJTk7m9OnTzJo1iwceeIBjx47lar1Wq5V27doxatQoIiIi8PPzIzk5mWXLltG4ceMcBTAXLlxI48aNWbp0qaOsxMREduzYQb9+/XjppZfS5Rk0aBCffPIJBw4cwGaz4e3tTXx8PEuXLqV58+YsXrzYZV2///47tWvXZubMmURHR+Pr64vFYmHhwoU8//zzN/085J9HwUsREREREREpkJYvX054eDjh4eHEx8dz+vRpHnzwQQzD4P3338/r5uWam+2n1Wplzpw5BAUF0bJlS/bs2cOuXbtuS9uuXbtGUlISZ8+eZdKkSVStWpWLFy/StWvXXK3zTvTpZhw8eJBOnTpx7do1GjVqxLJly7BYLERHR2O1Wjl9+jRz5szhgQcewMPDI1frHjVqFJs3b6Zs2bJs27aNuLg4zp8/T9u2bYmIiODFF1/MdllvvfUWNpuNRx55hAsXLhAXF0d8fDxffvklJpOJ7777jjNnzjjlqVWrFqNHj+bIkSMkJCSQkJDA0aNHefDBB0lJSWHYsGHp6rl48SIPPfQQFouFDh06cOjQIeLj47FYLCxevJhGjRrd8nORfw4FL0VEREREROQfoUyZMnz//fcAWc5uS05OxmKxuLyXmppKeHg4NpsNwzAcgcPw8HDi4uIyLDM+Ph6bzZbt9sbGxrpchpuV7PZz8eLFRERE0KNHDx577DHg9s9ULFWqFAMGDGDHjh00a9YMi8XCa6+9lmvl50WfsmPw4MHEx8fTpUsX1q1bR4cOHfD29gbAw8ODMmXK0Lt3b3755RcqVqyYq3WPHTsWgAkTJlC/fn0gbbn8hAkTKFSoECtWrODUqVPZKuvIkSO4u7szfvx4ihcvDoCPjw/Dhg2jefPmGIbBkSNHnPKMHj2aF154gcqVKzv2Bq1UqRLTp0/Hw8ODY8eOYbVanfJ8/PHHREVF0aBBAxYtWkTVqlWBtGfVpUsXvv3225t+HvLPo+CliIiIiIiI/GPEx8cDacGbGx06dIhhw4ZRsWJFfHx88PPzo3jx4gwdOtQpKLl3717CwsI4efIkMTExTns7Dho0yKnMw4cP069fPwoXLuzYH/Dee+9l7ty5LttnsVh48cUXCQwMJDAwkODgYF555ZV0B/PcSj/t7EG9Pn360KNHDzw9PZk5c+Zt2XPxRr6+vkyYMAE3NzdWrVrF+fPnHfesVivh4eE3tSdmXvYpI4cPH2bNmjV4enoyfvz4XJ9ZmZmTJ09y/PhxSpQoQZs2bZzuBQYG0q1bNwBWrVqVrfLKli2LzWYjISEh3T37Z6Rs2bLZKispKQmbzUZoaCheXl6O64ZhMGPGDABGjBhxR5+XFEwKXoqIiIiIiEiBFB0d7ZgRefbsWVatWsWjjz4KwBNPPJEu/dChQ/nqq684ceIEnp6emM1mLl26xDfffEO7du0cATCz2UxISAhubm6YTCbHfpP2w1Ds1q9fT4MGDZgxYwaRkZF4enqSkpLCX3/9RZ8+fUhMTHSqPzU1la5du/Ltt9+SkJCAh4cH0dHRjBw5ktdffz3X+gk49p4MCQmhTZs2FCpUiHbt2nHlyhWWLVuWk8d806pUqUKdOnUA+PPPPx3XZ82aRVhYmGPmZHblhz65smbNGgBatWpFsWLFcpQ3Pj7eaWZvVq8bD5A6ePAgAHXr1nVZfr169ZzSZeWtt97CMAx69OjBmjVrOH/+PLt37+bZZ59l+/bt9OrVi8qVK7vMGxsb6/Qe7dq1K6mpqQwfPtwp3aFDh4iMjMTHx4f27dsDmc+EFlHwUkREREREpIAzDOP/2rvzuKjq/X/gr5kB2UEFRAUV3BUXzI3c991Q1MiwRc3UrPSmfrvd22Jp5r358KaWlrnklqZW7lnmmhsh4haKqICAGzuyyPr+/eFvTo4zA8POyOv5eMyjPOfzOefzOR/OzJn3fBbkZudXqVdejuHtJRkmbcyQIUOUHpENGzbEwIEDcePGDSxduhTvv/++Xvo2bdpgzZo1iIuLQ0ZGBnJycnDu3Dl0794dp0+fxs6dO5V0CQkJ8PLygqOjo07wSDtc++HDh3jhhReQnp6OYcOG4eLFi8jMzERmZiaCgoIwbtw4qFQqnfMnJCQgPDwc+/btU9Ju2rQJarUaq1atMtjbrST1BIDNmzcjLy8PY8aMUYbyPv/88wAqdph1q1atAAC3b99WtllbW8PZ2RmOjo7FOlZVqdOTtEOy27RpU+y8s2fP1ltRvrBX8+bNdfInJCQAgNGgqbZnbmJioknlmTx5Mn766SckJiaiX79+8PDwgI+PD7Zu3Yr58+crPSYNmThxos7faFxcHDZu3Kg352VMTAwAwNvbG3fu3MHw4cOVntANGjTABx98oDfMnKo3i8ouABEREREREZVOXk4BVs08VtnFMMnrS3vD0kpTJsdycnJSgli5ublIS0tDfHw81q1bh0GDBqFly5Y66RcvXqz8f3Z2NjIyMtCgQQMsWrQIPXv2xKFDhzB27FiTzr17927cvn0bzzzzDHbt2qWUQ6PRoEuXLkaHjW/YsAH9+vVT/h0YGIgtW7Zg3759uHr1qsEedMWtp/Y8wKPh1Vp+fn6wsrLC3r17kZycjFq1aplU19Kwt7cHAJ1h+S+88AJeeOGFYh+rqtTpSdoh/HZ2dsXOa29vD2dnZ5PTP5lWG+SrUaOGwfTa4dpP9gI2JjU1FVu3blXmtdSuAJ6WloYff/wRI0eORPv27Q3mdXR0hLOzM9LT05GdnY3IyEhs3LgR/fr1Q/369ZV02h6Wtra26NGjB2JiYpRyxsbGYsGCBThx4gQOHjyo/N1T9cael0RERERERGSWHl+FOzU1Fampqfj8889x4cIF9OnTR29xnYSEBMycORONGjVSev+5urqiZ8+eAHR7BxYlJCQEAPDKK6+YHGCxtrZGnz599LZrFytJTk42mK+49dSuwO3m5obevXsr2x0dHTF06FBkZ2dj69atJpW5tFJSUgA8CsCWRknr9GTvV0O0vYFNSWuItgdpampqsfMuXry4WMPGw8PDdfLb2NgAMB6c1PbmtbW1Nak8o0ePxrZt2/DKK68oPZQzMjKwYsUKXL58Gb1798b9+/cN5l27di0SEhKU1cYnTJiA3377DUOGDEF+fr5emY8fPw5HR0cEBQUpq5Tv2LEDDg4OOHr0aKG9PKl6YQibiIiIiIjIzFnUUOP1pb2LTlhBCgoK8OBBGhwcHKFW6/aZsahRfn1oHB0dMWfOHJw8eRI7d+7E999/j9dffx3Ao95ePXr0UII/Go0G9vb2sLCwgIggKSmpWENV09LSADxaXdtUTk5OetcDgLJgiakrlRdWT+DvIdRDhgzRC4gOHjwYO3fuxPr16zF9+nSTy15S58+fB2D6Ii/GlLRONjY2ePDgAdLT05VeoE/SBn9NDfA9STuU+9y5c8XOm5GRYXS6AEPUajVq166t/Fs7LDw2NtZgeu1CSYUt7KQVGhqKI0eOoHXr1vj222+Vv1VbW1tMnz4d169fx5IlS7B27Vr885//NHoclUqFpk2bYv369bh69SqCg4Nx/Phx9O3bF4DuEPd169ahc+fOAB7dB2PGjEFUVBTmzJmDAwcO4JVXXimy3PT0Y/CSiIiIiIjIzKlUqjIbil0WCgpUsMjWwNJKYzBYV96aNm0KADq91H788UeEh4eje/fuWLlyJVq3bg2N5tE1u3HjhpLHVNrhuzdu3CijUhefoXrm5eUpPdbWr19vdC7IoKAgXL161eCQ87Jy5swZhIeHQ6PRoHv37iU+Tmnq5O7ujqtXr+LKlStKkOxxWVlZiIqKglqtRr169UpUvn79+kGtVuPEiRO4du2a3ryUhZk9eza++eYbk9M7Ozsr81wCf8+zefbsWeTn5yt/01pBQUEAHs0vWRTt33KrVq0M3rfac5n6N69SqeDt7Y3g4GBER0cr21u0aAFLS0vk5uaidevWevm0ZX1ycSKqvjhsnIiIiIiIiJ4qZ8+eBaA7B6E2eDJjxgy0bdtWJ8izfft2g8extLQ02itOG4xbsWKF3rBtAGW6MJExhur566+/4t69e9BoNDqrpD/+sra2BvD3HJLlIS4uTuk1FxAQoNNbsLhKU6cePXoAeDSk2ZANGzYgJycHPj4+RntmFqVBgwbw9/dHQUEBJkyYoAyVN+bxvw3tnJfFeT2uXr16aN++PZKTk/XmWb19+zb27t0LtVqNQYMGFVkPbRudPXvW4DD0Y8eO6aR7si5PysjIwPHjxwE8CiJrWVtbK/O+njhxQi+fdltxejXT043BSyIiIiIiIjJLqampylyAd+7cQXBwMKZMmYKjR48CAIYOHaqk1fZS/Pzzz3H06FHExcXh3Llz+L//+z988MEHBo9fv3595OTkYM2aNbh9+zYSEhKUQOXgwYPRpk0bREVFwdfXFzt27EBERATCwsKwYcMGdOjQweRFUsqyntpeia+//rrReRM3bdoEANi4caPBoeqpqalITEw0mDcnJ8dg2eLj4xEZGYlDhw7hn//8J9q2bYtr166hXr16+M9//qOTJzs7GwkJCXjw4IFJ9S9Nnd544w1oNBp8/fXXePPNNxESEoK7d+/iypUrWLRoEWbOnAkAyn+Luv7GrseyZcvg5uaG4OBg+Pj4YNmyZbh06RLu3LmDsLAwHDx4EJ988glatmyp01O2tHNeAsCsWbOUum7evBmxsbH4448/EBAQgIcPH+LFF19EnTp1dPJkZGQo81NqPfvss3B2dkZ0dDRGjhyJI0eOIDY2FqGhoZg5c6bSDiNGjFDyXLx4EV27dsXq1asRFBSE2NhYXLlyBVu3bkXv3r1x8+ZNeHh4oFevXjrn165A/uqrr2LDhg2IjIzElStX8Omnnyp/L48vzETVnFCxpKamCgBJTU2t7KKUm5ycHNm5c6fk5ORUdlGoBNh+5o9taP7YhuaPbWje2H7mj21oWFZWloSFhUlWVlZlF6VI+fn5kpycLPn5+eVy/N69ewuAQl+zZs3SyZOZmSktWrQwmHbOnDkCQAYPHqyTZ+nSpXppAwMDlf1Xr14VDw8Pg8dUqVTy8OFDJa2bm5u4ubkZrM+7774rAOTgwYOlqmdycrJYWVmJSqWS8PBwo9cvPz9fvLy89M5pyvl+/vlnk9N26dJFrl27pnf+devWCQDx8/MzWsayqpOIyPLly0WtVhst5+uvv27wmMW5HiIi4eHh0qpVqyLzGLompVFQUCBjx441eK6mTZtKfHy8Xp4ZM2YIAJk/f77O9h9//FEsLS2Nln3GjBk66S9cuFBoXWvXri2nTp0yWO7Zs2cbzTdz5swyuz7mqrzfR8uLqZ9VxYmvcc5LIiIiIiIiMitOTk56w2fVajVq1qyJ9u3bY+LEiRg2bJjOfhsbGxw7dgwff/wxjh8/jrS0NDRv3hzTpk1Dv379sG7dOr0VsWfMmIHMzExs374dcXFxyMvLg4ODg7K/RYsWuHDhApYtW4b9+/cjLi4OLi4u6NixI2bNmgUrKysl7ZPlfZydnR2cnZ1Ro0aNUtVz7969sLe3R//+/Qudd1GtVmP27Nn46KOPsGvXLgwYMEDvfCJicPVtbZ2eLJuFhQUcHR1Rr149PPPMM/Dz8zO4sjoAZaV37SrdhSltnQDgzTffhK+vL1asWIGgoCAkJSXB3t4e7dq1w8SJE3V6Ej7O0PV/0uNt3Lx5c1y8eBFbtmzBzp07ERYWhtTUVDg7O8Pd3R3dunXD+PHj0axZsyLrXRwqlQo//PADvvnmG2zcuBHR0dGoVasW+vXrh3nz5hkcsq8drv7kIkX+/v4ICQnB0qVLcfr0aSQlJcHW1hZt27bFq6++ilGjRumkb9euHS5cuID169cjKCgI0dHR0Gg0aNSoEQYMGIBp06bB1dXVYLkXL14MX19frFq1ClevXoVarUabNm0wZcoU+Pn5ldn1IfOnEqmAiTieImlpaXByckJqaqpJb7TmKDc3F/v378ewYcOUVe/IfLD9zB/b0PyxDc0f29C8sf3MH9vQsIcPHyIyMhJeXl7K/H5VVUFBAdLS0uDoqL/aOFV9bD/zxzY0f+bahqZ+VhUnvmY+tSciIiIiIiIiIqJqhcFLIiIiIiIiIiIiqpIYvCQiIiIiIiIiIqIqicFLIiIiIiIiIiIiqpIYvCQiIiIiIiIiIqIqicFLIiIiIiIiIiIiqpIYvCQiIiIiIiIiIqIqicFLIiIiIiIiIiIiqpIYvCQiIiIiIjIjIlLZRSAiIjKoPD6jGLwkIiIiIiIyAxqNBgCQm5tbySUhIiIyTPsZpf3MKgsMXhIREREREZkBS0tLWFlZITU1lb0viYioyhERpKamwsrKCpaWlmV2XIsyOxIRERERERGVKxcXF8TFxSE2NhZOTk6wtLSESqWq7GLpKSgoQE5ODh4+fAi1mn1mzA3bz/yxDc2fObWhiCA3NxepqalIT0+Hu7t7mR6fwUsiIiIiIiIz4ejoCABISEhAXFxcJZfGOBFBVlYWbGxsqmRwlQrH9jN/bEPzZ45taGVlBXd3d+WzqqwweElERERERGRGHB0d4ejoiNzcXOTn51d2cQzKzc3F8ePH0atXrzIdOkgVg+1n/tiG5s/c2lCj0ZRbOat08PLevXtYv349Ll68CEtLS3Tt2hUvvfQS7OzsTD5GaGgoPv74Y6P7X375Zfj7+5dFcYmIiIiIiCqMpaVllf1Cq9FokJeXB2tr6ypbRjKO7Wf+2Ibmj234tyobvDx16hRGjhyJpKQkZdt3332HxYsX4/Dhw2jYsKFJx7l37x527dpldL+vr2+py0pERERERERERERlr0oGLx88eAB/f38kJSWhT58+mDhxIrKysvDll1/i8uXLeP7553HmzJliHdPf3x8vvfSS3nZvb++yKjYRERERERERERGVoSoZvFy1ahXu3buHHj164NChQ8qqSuPHj0e7du0QFBSE3377DYMGDTL5mM2aNcOoUaPKqcRERERERERERERU1qrkWuvaYd7vvvuuznLwjo6OmDFjBgBg586dlVE0IiIiIiIiIiIiqiBVsufl+fPnAQC9e/fW29e3b1+dNMU55vTp05GUlIR69eph4MCBGDZsmNksN09ERERERERERFTdVLngZUpKCh48eAAXFxc4ODjo7ff09AQAxMTEFOu4v/76q86/ly5dim7dumHnzp1wdXUtcXmJiIiIiIiIiIiofFS54GV6ejoAGAxcPr5dm84UjRo1wrhx4+Dt7Y3c3FyEhITgu+++w6lTpzB27FgcO3bMaN7s7GxkZ2cr/05NTQUAJCUlITc31+QymJPc3FxkZmYiMTERlpaWlV0cKia2n/ljG5o/tqH5YxuaN7af+WMbmj+2oXlj+5k/tqH5e9rb8MGDBwAAESkyrUpMSVWB7t69i3r16qFBgwa4deuW3v6MjAzY29vDxcUF8fHxRR4vOTkZ9vb2eg198eJFPPvss8jMzMSxY8fQq1cvg/nnzZuHjz/+uGSVISIiIiIiIiIiIoNiYmLg4eFRaJoqF7zMzMyEnZ0d7OzsDPaujImJQcOGDdG0aVNERESU6lxTp07FqlWrsHDhQrz33nsG0zzZ87KgoABJSUlwdnZ+aufLTEtLQ4MGDRATEwNHR8fKLg4VE9vP/LENzR/b0PyxDc0b28/8sQ3NH9vQvLH9zB/b0Pw97W0oInjw4AHq16+vs1i3IVVu2LitrS3c3d0RFxeH6OhoNGrUSGf/X3/9BQBo1qxZqc/l7u4OoPAh6FZWVrCystLZVrNmzVKf2xw4Ojo+lTdIdcH2M39sQ/PHNjR/bEPzxvYzf2xD88c2NG9sP/PHNjR/T3MbOjk5mZSu8NBmJenZsycA4Oeff9bbt3PnTgBA9+7dS32eEydOAPg7iElERERERERERERVR5UMXk6YMAEAsGDBAly9elXZfvjwYaxduxYWFhYYP368ScdasmQJoqOjdbY9fPgQH3zwAQ4ePAgLCwsMHTq07ApPREREREREREREZaLKDRsHgOHDh2PYsGHYv38/2rdvj+7du+Phw4c4c+YMRAT/93//h8aNG+vkOXv2LBYsWIDWrVtj4cKFyvYlS5Zg7ty58PT0hKenJ3JychAWFoakpCQAwHvvvQcvL68KrV9VZ2VlhY8++khvuDyZB7af+WMbmj+2ofljG5o3tp/5YxuaP7aheWP7mT+2ofljG/6tyi3Yo/XgwQNMmzYNW7duRUFBAYBHDTdr1iwsXLhQbzLPvXv3YuTIkejevbsyHBwAli9fjhUrVuj04AQADw8PfPDBB3j99dfLvzJERERERERERERUbFU2eKl1+/Zt/PXXX7CwsECHDh2MLpZz7949nD59Gs7OzsqcmY+7desWbt68iezsbDRs2BAtW7Z8alcLJyIiIiIiIiIiehpU+eAlERERERERERERVU9Vcs5Lqhx5eXk4ffo07t69i3r16sHX1xcWFvwTqWru3LmD8PBw3L9/H66urujYsSMcHR2NphcRRERE4ObNm0hPT4enpyd8fHzYtpUsKysLQUFBSExMhJeXF9q1a2dSm4gIfvjhB+Tl5aFp06bw9fWtgNLS40QEly9fRkREBCwtLeHj44MGDRqYlPfevXsIDQ1FdnY2vL290bRp03IubfWWlZWFY8eOISEhAR4eHujTp0+R6a9cuYKoqChYWFigbdu2Js2Lff/+feV92cPDA61atSr0fZlMd//+ffzxxx/IyspCp06d0LJlS5Py3b59GxcuXEBubi7atGmjN1f6k+Lj4xEcHKzcm82bNy+L4hOAK1euIDQ0FAUFBXjuueeKvDeysrIQHByMu3fvwtnZGb6+vrCzsys0T2RkJG7cuIHk5GTUr18fnTp14vxgZSAvLw9Xr15FZGSk8tzRpk2bQkevlSTPk/bs2YPU1FS4ublh4MCBZVGVauvBgwe4evUqbt26BWtra/j4+MDd3d1o+p9//hkZGRkG9zk4OMDPz6/Q86WkpCA4OBjp6elo3rw5vL29S1V+evTsGB4errwndu7c2aRnDO19mJ+fDy8vL7Rq1Upv6r2yyENFe7INO3bsaHREsdb169dx48YNpKWloWHDhnjmmWdgaWlZ5LkuX76M8PBw2NnZwdfXt8jzmBUhEpEDBw5IvXr1BIDyql+/vhw8eLCyi0b/388//yzdunXTaSMAYm1tLbNnz5bc3Fyd9Dk5OTJ79mxp2LChXh53d3fZtm1bJdWkesvNzZUPP/xQ7OzsdNrEy8tLdu3aVWT+b775RskzefLkCigxPS44OFjatGmj03YqlUoCAgIkNTXVaL67d+/KuHHjRK1W6+Tt2bOnhIeHV2ANqofvv/9ehgwZItbW1sq1Hj58uNH0f/31lwQEBOjdlwCkd+/ecu3aNYP5EhMTZeLEiWJhYaGTx97eXj744APJy8srryo+1QoKCuTDDz+UTp06iUqlUq7r//73vyLzxsTEiJ+fn04+ANK/f3+JjIzUS5+fny9z5szRa8MhQ4bI/fv3y75y1UR0dLRMnz5dPD09da7rlStXCs23fPlyqVmzpk4eOzs7Wb58ucH08+fPlxYtWujdt7Vr15Zly5aVR9Wqhfj4eJk6daq4uLjoXduWLVvKsWPHyiSPIYcOHdJ5/6WSCQoKEj8/P7GystJ7Zhk+fLjExsYazOfu7q7XftpXkyZNjJ4vLS1Npk2bJpaWljp52rdvL6dPny6vaj7VNmzYIL6+vga/+73zzjuSk5NjMN8ff/whHTt21MvXunVrOXDgQJnloaL98ssv0qtXL71nEisrK5kxY4Y8fPhQJ31BQYG8++674uXlpdcWbm5usn79eqPnioqK0osVWFlZyWeffVbe1awwDF6ShISEKF/wmjdvLmPGjJHmzZsLALGxsZHz589XdhFJRAICAgSANGjQQAYMGCCjR48Wb29v5c1p6tSpOumTk5OVh5QWLVrI4MGDZfjw4VKnTh1l+88//1w5lammCgoKZNy4cUqbtWvXTsaNGye9evUSS0vLIoORCQkJUrt2bXFzc2PwshJERESIo6OjABBXV1cZPny4DB48WJycnASADB482GC+e/fuKe+pFhYW0rt3bxk3bpy0a9dOAMiWLVsquCZPv969eyufYT4+PkUGL7/99lsBILa2ttKhQwcZNWqU9O7dW/kSVrduXYmPj9fL17dvXwEgarVaevbsKWPHjpUOHToo9/js2bPLs5pPrdzcXOUaurq6SpMmTUwKXsbGxkqjRo0EgFhaWkrfvn1l3Lhx0rp1awEge/bs0cvz3nvvKW3Yt29f8fPzEwcHBwEgvr6+kp+fX061fLrt2bNHacMWLVpIrVq1igxefvXVVzpfmP39/aVbt27Kl75Vq1bp5dG+/3p5eUn//v3Fz89PGjRooBzniy++KM9qPrWCg4OVzyxvb28ZMWKEDBo0SPkMtLKykrNnz5Y6z5NycnKkZcuWynMOg5clN3/+fAEgDg4O0qlTJ/H395fu3bsrP6I2b95cMjMz9fK5u7uLlZWVBAYG6r2MfaZlZmbKs88+q3y/8PX1lXHjxkmXLl1EpVI9VcGTiqR9lqlbt6707NlT/P39lc8zAPLqq6/q5bl+/brY2NgIAHF2dpZhw4bJc889J3Xr1lXuz+Dg4FLnIdNMnjxZgEcdh/r16yf+/v7K8z8ACQwM1En/+PNP06ZNZdCgQTJy5EidTmabNm3SO09mZqbyQ17t2rVl9OjR0qNHD+Xzc+nSpRVV5XLF4CVJ//79BYC89tprykN6fn6+crMNGTKkkktIIiLbt2+XS5cu6W3/4YcflC9qDx48ULZnZGTI4sWL5datWzrp09PTxd/fX/k1lCqOtteklZWV7N69W2dfdHS0wS/Wj5s0aZLUqlVLli1bxuBlJZg0aZIAkKFDh+rcawkJCdK5c2cBoNeuIqIErJs2barXy/LkyZMSGhpa3kWvdr755hvZv3+/ZGZmypEjR4oMXp46dUp++OEHycjI0NkeHh6uPDDOnz9fZ19ERIQSIH3yC/nGjRuVL40FBQVlV7FqIj8/Xz7++GP5888/paCgQP7973+bFLwcOnSoABBvb2+5efOmzr4jR47I5cuXdbZFR0eLpaWlaDQa+e2335TtcXFxSo9BQ18SqGgXL16Ur776Suntqu3RYyx4mZubK7Vr1zb4JevkyZNibW0ttWvX1nnvFRFZvHixXL16VWdbTk6OvPnmm8oXcfaALr6oqCj5+uuv9X60iY+Pl65duwoAGTNmTKnzPGnhwoViYWEha9euZfCylH777TfZtWuXZGdn62w/e/asEvT/9ttv9fK5u7uLs7Nzsc41d+5cASAuLi4SFBSks+/SpUty9OjR4leAZM2aNXLmzBm97StXrlQCWU+OKPjoo48EgPTo0UPnmSY7O1uee+45ASDTpk0rdR4yzc8//yznzp3T275nzx5Rq9WiVqt1Rnnk5+fLokWL9No1KytLAgMDjfaA/vzzzwWAtG3bVhITE5XtW7duFQDi5ORU6Agxc8HgZTV3+/ZtUalU4uDgIGlpaTr70tLSxMHBQe+moqpH29MkOjrapPRxcXHKL2lUMfLz85Uvw4sXLy52/pMnT4pKpZKVK1fKli1bGLysBNrekyEhIXr79u7dKwBk7NixOtvDw8NFpVKJSqUy+PBC5c+U4GVhli5dKgAkICBAZ3tQUJAAj4b+G+Lg4CAqlUpvSBAVnynBy3Pnzimfa0UNTdZavHixAJAJEybo7du0aZPyYwWVXlHBy4sXLyo9KA159dVXBYBs3brVpPPl5uaKra2tAJCYmJgSl5v0HTt2TOlRW5Z5oqKixNbWVmbPnq304mTwsnxoe5zPnDlTb19xg5cpKSnKvbZz584yLCUVRvuj+ZMdH9566y0BIN98841enp07dwoAef7550udh0pPO4Lyr7/+Mil9cnKy0pMyKytLZ592lJGhIf5DhgwRALJ58+YyKXdl4uyr1dzp06chIujbty8cHBx09jk4OKBv374oKChAUFBQJZWQihIbG4s7d+7A1dUVHh4eJuVxdnaGSqWCk5NTOZeOtM6fP4+oqCjY2Nhg2rRpxcqbn5+PN954A506dcLrr79eTiWkomRnZwOA3nvl49tOnDihs33nzp3Ke2yHDh3Kv5BU5lxcXABAb8Lzli1bws7ODteuXUNqaqrOvrCwMDx48ABt2rThoiEV5OeffwYADBs2zORFfU6ePAkAeO655/T2jRgxAiqVCqdOnSq7QpJRhb2/Pr79yfdYYywsLODk5ASVSsXFs8qYsffE0uaZOXMmatWqhXnz5pWidGQKU9rj8uXL2LFjB/bv3487d+4YTffrr78iMzMTjRs3LnIxHyo7xtqwY8eOAIDg4GC9PH/++adOmtLkodK5f/8+bt26BScnpyIXFNRydHSElZUVbGxsdJ4tMzIycOHCBdjZ2aF///56+bTPOE/D8wyXG67mrl+/DgBo3bq1wf2tWrXC7t27ERERUZHFokIEBwcjPDwc2dnZuHHjBtavXw8RwYoVK0xeDW779u0QEYwePbqcS0ta586dAwB069YNdnZ2uHv3LoKCgqBSqeDj44OGDRsazbt8+XJcunQJf/75J1f8q0TNmzdHdHQ0NmzYgPnz5+vsW79+PQDg7t27SE9Ph729PYC/2127WmpYWBjCwsLg5OSEzp07P10rAD6ltm3bBgB675eOjo744osvMHXqVHTt2hUvv/wy3NzccOPGDaxevRr29vZYvnx5ZRS5WnryXrt48SLCw8NRq1YtdOnSxWAAq7BnICcnJ9SvXx9xcXGIj4+Hq6trOZaemjRpArVajbCwMISEhOh8UU5JScGuXbsAwOTn0RMnTuDOnTsYMGAAg5dlzNh7Ymny7Nu3D7t27cK2bduUz08qHyKC7du3A4DRYGNiYiLatm2r/FulUsHPzw8rV65E3bp1ddI++d4bGRmJ0NBQWFtbo1OnTqhTp055VKNau3//Po4dO4Z69eqha9euOvsCAwPx/fffY/Xq1UhMTES/fv2g0Whw4sQJbN26FZ07d8aMGTNKnYeK5/z587h8+TJycnIQGRmJDRs2IDMzE+vWrYO1tbVJx9i9ezcePnyIF154ASqVStl+48YNiAiaNWsGCwv98F6rVq0AmP75WaVVZrdPqnz/+te/BID897//Nbh/0aJFAkA++uijii0YGTVjxgxlnhMAUq9ePZNXcBR5NMdXnTp1pHbt2kZXGqSy9+mnnwoAefvtt+U///mP1KhRQ6cd/fz8JCEhQS/f7du3xdHRUd544w1lG4eNV45t27Yp7TV69GhZvny5fPHFFzJgwACxsLBQFiV4/L7SLuiydetWef7553Xa3NraWv71r39xQZByVpph49q5K4cNG2Y0za+//irOzs46bdusWTODcxRTyZgybFw7hG7Xrl3KHF3al62trXzyySd68482bNhQAMjt27cNHrNNmzYCQCIiIsqyOtVSUcPGRUR5j3RwcJB//OMfsmrVKvnkk0+kUaNGyj3m6+tb5LmSk5OlRYsWYmVlxTmFy1hwcLBYW1tLs2bN9OYILmmerKws8fLykkGDBunkAYeNlwvt3HiTJk0yuN/d3V0cHByke/fuMnr0aGU4qvazLSUlRSf9xIkTlffnt956S1kQCIBoNBqZMmWKwYWBqGTy8vJk2LBhAkC+//57o2lmz56t8zkIQF5++WWjbVGSPGS6d999V+e6urq66sy1XZQ7d+6Ih4eHODg4yPXr13X2HT9+XABIv379DOY9f/68AJCuXbuWqg5VAYOX1Zz2RjI2B5/2A+7999+v4JKRMevXr5fAwEAZNWqUsuKctbW1SSsWx8fHS+vWrcXS0tLgnBhUfubNmycAlJWImzVrJqNHj5ZevXqJRqNRvpQ9Gch64YUXpE6dOpKcnKxsY/Cy8vz73/9W5pvRvtRqtXz11VfKqoyPL5LVo0cPAaA8/Hft2lX8/f2lbdu2Sv5//etflVijp19Jg5cHDx6UGjVqSLNmzQyuNC4i8t1330mNGjVEo9FI9+7dxd/fX7nHa9euLcePHy+LKlR7pgQvtfeYj4+PqFQq6datm97KrAsXLtTJ4+7uLgDk7t27Bo/Zvn17AaC3IAwVnynBy6SkJOnWrZvel2c3NzdlwbsuXboUep7MzExlhd41a9aUdTWqtWvXrombm5s4OTnJxYsXyyzP+++/L1ZWVjo/EjB4WT62bt0qarVaOnXqZDT4vHnzZr359P78809l8bonvxNOmDBB5zmnffv24u/vL126dFHu4RdffLHc6lTdTJ06VQDIW2+9ZXB/VlaWjBkzRoBHCygNGTJERowYobRf37599QLQJclDxbN161YJDAyU0aNHK98BLC0tZe3atUXmTUlJkWeeeUY0Go389NNPevu1z7kDBgwwmP/SpUsCQDp16lTqelQ2Bi+rufnz5xfas/LDDz8UAPKf//ynYgtGJtu/f79YW1uLtbV1oQv2xMfHS/v27UWj0cj27dsrsIQk8vfCEAD0egBdvHhRWflx3759yvZDhw4JANmwYYPOsRi8rFyXLl2Sjz/+WCZNmiSzZ8+Ws2fPSlpamhLUfHw1XO0k2TVq1JDDhw/rHGfNmjUCPFp9/skF06jslCR4+fvvv4utra14enrqBKMfd+XKFbGwsJDatWvr9bLcvXu3WFhYiJubm97qyFR8pgQvtT8U2NjYyOnTp3X2LVu2TACIvb29zgJKLVq0KLRnZePGjQWAxMXFlUk9qjNTgpcijxa327Nnj7zzzjsyadIkWbRokdy/f1/WrVsnAGTw4MFG82ZmZsqAAQOK/Fuh4rt27Zp4eHiIvb29nDp1qszyXLt2TaysrOTDDz/U2c7gZdnbtm2bWFhYSLt27XRWIzbVTz/9pAQpHzdt2jTl+XbTpk06+3799VexsLDgj0BloKCgQBl9N3HiRL2RBFra7+7PPfeczvPHw4cPZdKkSQJApk6dWuo8VDqHDx8We3t7sbCwkPDwcKPpUlJSpEuXLqJSqWT9+vUG02jfL431rDx16pQShDZ3DF5Wc+vXrxcA8tJLLxncr/01zZRefVR5pkyZIgBk1apVBvffvXtX2rRpIxqNhm1ZSbZv3670xjL0wDFnzhwBoPMA3759e6lTp45s3LhR56V9eOnTp49s3LhRjhw5UoE1IUMOHDggAKRhw4Y627W/kI8bN85gPm1PBfbQKz/FDV7+8ssvYm1tLY0aNZLIyEij6RYsWFDoyATt0OXHf5CgkjEleBkYGKh8qTOkadOmAkDOnTunbBs4cKAAkF9//VUvfU5OjtSoUUNq1KgheXl5pa5DdWdq8NKY1157TQDIO++8Y3B/enq69OnTRwDjUyFRyVy5ckXq1asndnZ2Jn9WmZpnzJgxYmVlJd9++63Oc84nn3wiAKRly5ayceNG2b17d1lVp1ravHmzaDQa8fb2lvv375foGLdv31aGuz7us88+EwDSuXNng/lGjRpl8Id4Ml1BQYG8/vrrynf2wqYbatmypdFgcWpqqqhUKqlVq1ap81Dp/eMf/xAAsmTJEoP7ExMTpWPHjqJSqWT16tVGj3Pv3j2D96bWpk2bBIC88sorZVHsSsUFe6o57YToR48eRUFBgc5iIAUFBTh27BgAcJXcKs7Ozg4AkJycrLcvLi4O/fv3x/Xr17Fhwwa88MILFV08wt/3mr29vc4ky1ralVRzcnKUbbGxsUhMTMRLL71k8JhHjx7F0aNHMXz4cPTp06fsC00mW7t2LYC/J6zX0rZ7USvoPt7uVHl2796NcePGwc3NDUeOHIGnp6fRtPfv3wdgvG21i4Ro01H56tixIzZv3lyse61jx444ePAgDh8+jEGDBumkP3HiBHJyctCpUydoNJryKzgVKS0tDT/++CMA/fdY7f6hQ4fi1KlTWLRoEebOnVvRRXxqXbx4EQMHDkRGRgb279+Pnj17lmme2NhYZGdnY8qUKQb3X716FS+99BJatGiBkSNHlrge1dnatWsxZcoUtGzZEocPHy7x4mPR0dEAoLcAFp9zyld+fj4mTZqEDRs2IDAwEN99912hi3cW9mxiY2MDS0tLJCcnIzc3F5aWliXOQ6VX2Pf3+/fvY+DAgbh06RK++eYbTJ482ehx6tSpAw8PD8TGxuLy5cto06aNzv7Dhw8DeEriOZUdPaXK16xZM4NzA61evVoASOvWrSupZKSVlZVldEh4TEyM1K9fXwDInj17dPZFRUVJ48aNRa1Wy8aNGyuiqFQI7Vx4R48e1dmelZUl3t7eer9MT5s2TQIDA/Ve2uGRTZo0kcDAQKNz1lLZM9QTb/v27aJSqUStVuv06hJ51OvZ0tJS6tatq7cgU1hYmFhbW3NYajkzteeldkidh4eH3Lhxo8jj/u9//1Pmsc3OztbZFxcXJy4uLgKgWAuqkWGm9LyMjIwUtVotjRo1ktTUVJ19ISEhYmFhIRqNRmf+4DNnzggAcXZ21lm0Jz8/X/r3729wnkwqGVN6Xt6/f1/S09N1tuXl5SmjgFq0aKHX4ygpKUk6derEtioHZ8+eldq1a4utra3JIzyKm+ejjz4y+JwzdOhQASB16tSRwMBAmTt3bukqU0199dVXolKppFWrVkbn9n1cZGSkztQaWg8fPlTmkn355Zd19uXk5Iizs7PY2trKtWvXdPbdvXtXXF1dBYDJ0w3Q33JzcyUgIEAAyPjx400aBaB9rzX0fqidrqhBgwalzkNFy83NNfo8effuXfH09DQ4wvX27dvSsmVLUalU8vXXX5t0rjfffFMAyPPPP6+z/dq1a2JraytqtbrQ0UTmQiUiUlGBUqqaNm/ejAkTJsDCwgLTp09H+/btcf78eXz99dfIy8vDDz/8gOeff76yi1mt3b17Fx4eHhg6dCg6dOiAhg0bIiMjA1euXMGWLVuQlpYGb29vhIaGKr+IJScno0OHDoiOjsaIESMQEBBg8Nhjx46FtbV1RVan2tq3bx9GjBgBGxsbTJ48GW3btkViYiLWr1+P8PBweHh4IDw8HLa2toUeZ+vWrRg/fjwmT56M1atXV1DpCXj0q/Tw4cPRpUsX2Nra4ujRo9i2bRtEBHPnzsV///tfvTz/+Mc/8MUXX8DDwwOTJ0+Gh4cHIiIisGrVKqSkpGDcuHHYtm1bJdTm6fXXX38hNDQUAHDlyhUsXLgQPj4+mD17NgDA2toaY8eOVdL/8ssvGDlyJAoKCvDRRx+hSZMmesesU6eOTu+8O3fuoGnTpsjMzETLli0xYcIEuLm54ebNm1i9ejXi4+PRrFkzhIWFwcKCA12K69ChQ7hz5w4AYMeOHdi1axcmTJiAwYMHAwA8PT3Ro0cPnTxTpkzB6tWr4enpiUmTJqFu3bq4evUqVq1ahfT0dEycOFHpJa01dOhQHDhwAI0aNcIbb7wBR0dHbNmyBcePH4erqysiIiLg5ORUMZV+iogINm/erPz7ww8/RGRkJP773/+iXr16AIBu3bqhcePGSpq9e/di0qRJePHFF9GqVSukpaVhy5YtCA0NRY0aNfD777/r9OIrKChAx44dcf78eXTt2hVvvvmmwbIMGTIELi4u5VTTp9O1a9fQpUsXpKamYvLkyQZHd1haWuo8W5YkjzFnz55F586d0bt3bxw9erQUNam+NmzYgFdeeQWWlpZYuHAh6tatq5emUaNGOvfUvHnzsGLFCowePRpNmzZFzZo1ERkZiU2bNiEmJgbW1tY4e/YsvL29dY6zdOlSzJo1C7Vr18aUKVPQtGlTxMbGYtWqVbhz5w66dOmCM2fOGBx5RMa9/PLL2LhxIzw8PLBgwQKDowC6du2KZs2aKf/+6quv8Oabb0KlUmH06NHo06cP1Go1Tp06ha1bt6KgoAAffPABPvnkk1LloaKlp6fDyckJgwYNQqdOndCwYUNkZWUhPDwcW7ZsQXJyMho3bozLly/DxsYGAJCRkYEOHTogIiICAwYMwCuvvGLw2KNGjYK9vb3y71u3bqF169bIyMjA0KFDMWrUKMTHx2P58uW4d++ewecfs1S5sVOqKrSrjj/+UqlUXGW8ikhJSZEmTZrotZH21bVrV72emVeuXDGa/vHXnTt3KqlW1dPnn3+urC7++KtBgwYSGhpq0jG4YE/leXzlYu1LrVbL3LlzjU6enp2dLaNHjzZ4/3EFx/KhnYPL2MvZ2VknvXbxusJe3bt31zvP3r17lcW2nnx5enrK5cuXK6rKTx1tz0djr4CAAL08mZmZyiJZT76GDh2q16tP5NFidtpe8Y+/XFxc5OTJkxVR1adSbm5ukffUunXrdPIEBQWJvb29XjpXV1eDc8dmZWWZ9Jzz5AJOVLQ9e/YUeV3t7OxKnccYLthTetr50Qt7jRkzRifP+vXrxcbGxmBaV1dXOXDggNHzaXt+Pflq166dxMTElHd1n0raReUKe61cuVInT0FBgUyfPt1o+ueff15ycnJKnYeK9vDhw0Lb0MfHR65fv66TJyYmxqTPNUMLDe7Zs8fgZ2ifPn0MPv+YI3YFIADAokWLMHbsWPz000+4d+8e6tatC39/f2UeE6pcTk5OuH79Ov744w+cOHECUVFRKCgoQMOGDdGnTx/06NFD79dMJycnBAYGFnls7S89VDHmzJmDESNGYNu2bYiOjoaNjQ26dOmCcePGmdwWnp6eCAwMxLPPPlvOpaUnXbp0Cbt378apU6eQkpKCxo0bw9/fH82bNzeap0aNGvjpp59w6NAhHDhwAAkJCXB1dcWAAQMwcOBA9kQoB23atCn0/e/JeZ3atm1b5PtlixYt9LYNHz4cN2/exI8//ogLFy4gPT0dtWvXRteuXeHn58de7aUwYMAAgz2FtAy9/9nY2OCXX37BgQMHcPDgQSQnJys9Zvv162fwOC4uLggKCsKOHTtw8uRJ5OTkwNvbG4GBgeytVwpqtbrIe+rJHs5dunTBrVu3sGXLFly+fBkajQbPPPMM/P39DfZ+1Wg0Jj3nlHSOv+rMw8OjyGv75PtbSfIY4+zsjMDAQLRq1cqk9KSvS5cuSElJKTLN415++WX4+flh165dCAsLw/3791GrVi106tQJfn5+hY4MWr58OV566SXs2rULd+7cgZOTE3r27Ak/Pz/OG1xCzz33HG7fvl1omiefP1UqFVasWIFp06Zhz549iIyMBAA0aNAAgwcPhq+vr94xSpKHimZlZYWrV6/izJkzOHbsGCIjI5Gfnw8PDw/06tULffr00fsOYGdnZ9LnmqH5SUeMGIGrV69i8+bNiIiIgK2tLfr06QM/P79C50k1Jxw2TkRERERERERERFXS0xGCJSIiIiIiIiIioqcOg5dERERERERERERUJTF4SURERERERERERFUSg5dERERERERERERUJTF4SURERERERERERFUSg5dERERERERERERUJTF4SURERERERERERFUSg5dERERERERERERUJTF4SURERERERERERFUSg5dERERElejWrVvw8fHBpk2blG0zZ87EyJEji3Wc33//HT4+Pli3bl2pyrNjxw74+Phgx44dpTpOYcqqrIWJiYmBj48P/vnPf5bbOcxBRVxrIiIiovLE4CURERFRJTpy5AguXLiA5s2bAwBEBJs3b0atWrWKdZyUlBRcuHAB9+7dK1V5EhIScOHCBSQkJJTqOIUpq7IWJjs7GxcuXEBUVFS5ncMcVMS1JiIiIipPDF4SERERVaJjx47B0dERHTt2BACcP38eiYmJ6Nu3byWXjIiIiIio8jF4SURERFSJjh07hp49e0Kj0QAADh8+DAAMXhIRERERAbCo7AIQERERVSeff/45Nm/erPz75s2bePDgAXx8fAAAsbGxUKlUGDVqlJLm/PnzpTpnXFwcNmzYgJCQEMTExMDJyQndu3fH9OnTUadOHaP5oqOjsWTJEoSEhMDS0hL9+vXDrFmz4ODgYDB9WFgYVq9ejdDQUGRmZqJhw4bw9/dHQEAA1GrTfzMvznFEBBs3bsS2bduQkJCApk2b4o033ii0XsYEBQVhzZo1uHnzJnJycuDl5YXhw4djzJgxSnAZKN713LFjBxYsWID3338fvr6+WLx4MUJCQmBtbY1Ro0Zh+vTpUKvVSEhIwBdffIGTJ08iPz8fQ4YMwezZs2FlZWXwWJ07dy5W25TFtTb1+hARERGVKSEiIiKiCjNz5kwBUKyXKbZv3y4A5LPPPtPZfv78edFoNAaP6+bmJuHh4TrpV65cKQDknXfekdq1a+vladWqlcTHx+ud/8svvzR6nueee07y8vKKLGtxj1NQUCDjx4/XS6fRaGT+/PkCQAICAky6fkuWLDF6/adMmVLq6zl37lxxcXHRy/Pmm29KdHS0NGrUSG/f+PHjS902ZXWtTb0+RERERGWNw8aJiIiIKtDcuXMRGhqK0NBQTJw4ESqVCsePH0doaCh+/fVXAMDbb7+tpAkNDS3V+bKysuDp6YnPPvsMe/bswZkzZ/Djjz/Cz88P9+7dw1tvvWUw39KlS1GzZk189913+OOPP7Bq1SrUr18fV65cwaxZs3TSHjlyBG+99RZcXFywcOFC/P777zh16hTWrVsHb29v7N69G//73/+KLGtxj7N+/Xps2bIFVlZWmDdvHo4cOYKffvoJffv2xbx580y+RiKCefPmQa1WY+7cuTh06BBOnTqFjRs3Yvz48cjJySn19VyyZAkaNGiALVu24MSJE/j8889hZWWFFStWwM/PDzY2NtiwYQNOnjyJL7/8Eg4ODti6dSsuX76sd6zitE1ZXOviXB8iIiKiMlfZ0VMiIiKi6srX11c6dOig/Hvz5s0CQE6ePFnsYxnrYffw4UPJz883mKdnz56iVqslLS1N2abt3VezZk29XnyRkZFiZWUlGo1GZ9+AAQPEwsJCIiIi9M6RnJwsDg4O0qZNmyLLWtzjdO7cWQDIli1bdNIWFBRIr169TO55mZ2dLWq1Wnr16mVwf2ZmpvL/Jb2eTZs21TmOiMjbb7+t9NhMSkrS2bdgwQIBICtXrtQ7VnHapiyudXGuDxEREVFZ45yXRERERJUgJSUFwcHBmDNnjrLt999/h4ODA7p06VJm57GyssKdO3ewZs0anDlzBvfv31d6ysXGxqKgoABRUVFo27atTr7AwEC4uLjobPP09ISfnx+2bduGP//8E8OGDUNeXh7++OMPaDQavPDCCwAe9dTT/ldEkJeXh/Dw8ELLWdzjZGdn49y5c6hbt66SXkulUmHWrFk4fvy4SdeoRo0a6NmzJ86ePYt169Zh1KhRqFWrlrLfxsam1NczICBA5zgAlBXmnzwfAHTu3BnAo3lHn2Rq2xhT3GtdnOtDREREVNYYvCQiIiKqIHPnzsXBgwcBAJmZmcjPz8eWLVtw4MABAEBERAREBJ06dQIAuLm5KUPJSyooKAiDBg1CWlqa0TSZmZl625o0aWIwrXZ7QkICACApKQnZ2dkAgJCQkELLkpeXBwsLw4+fxT1OSkoK8vPz0bhx40LLaarNmzdj5syZmDp1KiZPnozmzZujW7duGD9+PAYOHKikK+n19PDw0Ntma2tb5L6srCy9faa2jTElaTNTrw8RERFRWWPwkoiIiKiCREZG4sKFCzrbbt26hVu3buls06Zxd3cv9TlnzpyJtLQ0jB07FgEBAXB3d4e1tTVUKhU+/vhj7Ny5U+l197jExESDx9Nu1/a20/63fv362LdvX6FlMRa4LMlxtOmNlbOoAN6T3N3dsWPHDqSlpeHMmTMICQnBvn37MGjQILz99ttYunQpgJJfz7JkatsYU5I2M/X6EBEREZU1Bi+JiIiIKsjixYvx/vvvA3gUBLt58yb27NkDADh9+jTeeOMNfPnll+jevTuAR8N1SyskJAReXl7Yvn27zvaCggLcuHHDaL4DBw5g/vz5UKlUyrbc3FwcOnQIANC6dWsAgIODA7y8vBAZGQkA8PHxKVE5i3scR0dHuLu74/r164iIiECzZs109u/fv79E5XB0dMSgQYMwaNAgvPfee+jbty+WLVuG9957D3Xr1i3x9SxLpraNMaVps6KuDxEREVFZ42rjRERERBXE09MTPj4+aN++PcLCwtC3b1/4+PjAx8cHd+/ehVqtxosvvqhsKyoIZYo6derg7t27CAoKUrYlJSVhypQpuHTpktF8ISEhmDNnjjKfY2ZmJqZNm4YbN27A29sb3t7eStopU6YAeDR3o3YIvFZaWhrWrVuHL7/8ssiyFvc448aNQ35+PiZMmKAzN+T3339v0vm0YmNjMXPmTJw/f16n12RUVBSioqIA/N2rsaTXsywVp22MKc61Ls71ISIiIiprDF4SERERVbBLly4hISEBffv2VbYdOXIEPj4+egu3lFZAQACysrLg6+sLT09PNGnSBG5ubti0aRO6detmNF+PHj2wZMkSODo6olmzZqhZsybWrl0LCwsLLF++XCftnDlz0L9/f0RHR2Po0KFwcHBAy5YtUadOHTg5OWHSpEk4f/58kWUt7nH+/e9/w93dHX/++Se8vLzg5eWFWrVqITAwsFiLHj18+BDLli1Dhw4dYGtrixYtWsDLywuNGzdGVFQU2rVrpwSSS3o9y1Jx2saY4lzr4lwfIiIiorLG4CURERFRBTty5AgAKMHLrKwsBAUF6QQzy8qnn36KadOmwcLCAtHR0bh58yaaNWuG/fv3o0OHDkbzBQYG4osvvoCtrS2uX7+O3NxcNG7cGLt379Yrp6WlJX755Rd8+umn8PDwQHp6OsLDwxEfH4+aNWvitddew1tvvVVkWYt7HBcXFxw7dgx9+/aFiCAqKgoZGRl47bXX8NVXX5l8jRo0aIClS5fimWeeQXZ2Nq5du4aoqCjY2tpi6tSpOHjwoDJEu6TXsywVp22MKc61Ls71ISIiIiprKinvGcWJiIiISEdsbCySkpLQrl07AEB2djauXLmCBg0awNnZuUTHTE1NRWRkJOrXr486dero7c/OzkZ0dDQcHBxQr149AEBcXBzi4+PRvHlzZXXrxMRExMTEKGXJzc1FdHQ0LCws4OnpaVJZbt++jZSUFLi5uRmsT1FlNfU4j4uPj0diYiI8PDxgb2+PnJwchIWFoVatWmjUqJFJ5QYe9TK8desW7O3tUbduXajVhn/rL+n1NHQd6tWrBzc3N519GRkZiIiIgKurq7Jw09dff43p06dj5cqVmDZtmkltU9bX2tTrQ0RERFRWGLwkIiIiIjIDTwYviYiIiKoD/lRKREREREREREREVRKDl0RERERERERERFQlcdg4EREREZEZKGz+TCIiIqKnFYOXREREREREREREVCVx2DgRERERERERERFVSQxeEhERERERERERUZXE4CURERERERERERFVSQxeEhERERERERERUZXE4CURERERERERERFVSQxeEhERERERERERUZXE4CURERERERERERFVSQxeEhERERERERERUZXE4CURERERERERERFVSf8PGYVnu2QFRz4AAAAASUVORK5CYII=", "text/plain": ["<Figure size 1600x900 with 1 Axes>"]}, "metadata": {}, "output_type": "display_data"}], "source": ["cycles = np.arange(n_cycles + 1, dtype=int)\n", "plt.figure(figsize=(16, 9))\n", "for qs_name, acc in acc_dict.items():\n", "    plt.plot(\n", "        cycles * batch_size,\n", "        acc,\n", "        label=f\"{qs_name}: AULC={round(acc.mean(), 3)}\",\n", "    )\n", "plt.xticks(cycles * batch_size, fontsize=\"x-large\")\n", "plt.yticks(np.arange(0.5, 1.0, 0.1), fontsize=\"x-large\")\n", "plt.grid()\n", "plt.xlabel(\"# labeled samples\", fontsize=\"x-large\")\n", "plt.ylabel(\"test accuracy\", fontsize=\"x-large\")\n", "plt.legend(loc=\"lower right\", fontsize=\"x-large\")\n", "plt.show()#%%\n"]}], "metadata": {"kernelspec": {"display_name": "scikit-activeml", "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.12.11"}, "nbsphinx": {"orphan": true}}, "nbformat": 4, "nbformat_minor": 5}